new copyright notice

[unix-history] / usr / src / sys / tahoe / stand / sys.c

/*
* Copyright (c) 1982, 1986 Regents of the University of California.
* All rights reserved.  The Berkeley software License Agreement
* specifies the terms and conditions for redistribution.
*
*      sys.c   1.4     88/03/03
*
* from vax     @(#)sys.c       7.1 (Berkeley) 6/5/86
*/

#include "param.h"
#include "inode.h"
#include "fs.h"
#include "dir.h"
#include "reboot.h"
#include "saio.h"
#include "../machine/mtpr.h"

ino_t   dlook();

struct dirstuff {
       int loc;
       struct iob *io;
};

static
openi(n, io)
       register struct iob *io;
{
       register struct dinode *dp;
       int cc;

       io->i_offset = 0;
       io->i_bn = fsbtodb(&io->i_fs, itod(&io->i_fs, n)) + io->i_boff;
       io->i_cc = io->i_fs.fs_bsize;
       io->i_ma = io->i_buf;
       cc = devread(io);
       dp = (struct dinode *)io->i_buf;
       io->i_ino.i_ic = dp[itoo(&io->i_fs, n)].di_ic;
       return (cc);
}

static
find(path, file)
       register char *path;
       struct iob *file;
{
       register char *q;
       char *dir;
       char c;
       int n;

       if (path==NULL || *path=='\0') {
               printf("null path\n");
               return (0);
       }

       if (openi((ino_t) ROOTINO, file) < 0) {
               printf("can't read root inode\n");
               return (0);
       }
       dir = path;
       while (*path) {
               while (*path == '/')
                       path++;
               q = path;
               while(*q != '/' && *q != '\0')
                       q++;
               c = *q;
               *q = '\0';
               if (q == path) path = "." ;     /* "/" means "/." */

               if ((n = dlook(path, file, dir)) != 0) {
                       if (c == '\0')
                               break;
                       if (openi(n, file) < 0)
                               return (0);
                       *q = c;
                       path = q;
                       continue;
               } else {
                       printf("%s: not found\n", path);
                       return (0);
               }
       }
       return (n);
}

static daddr_t
sbmap(io, bn)
       register struct iob *io;
       daddr_t bn;
{
       register struct inode *ip;
       int i, j, sh;
       daddr_t nb, *bap;

       ip = &io->i_ino;
       if (bn < 0) {
               printf("bn negative\n");
               return ((daddr_t)0);
       }

       /*
        * blocks 0..NDADDR are direct blocks
        */
       if(bn < NDADDR) {
               nb = ip->i_db[bn];
               return (nb);
       }

       /*
        * addresses NIADDR have single and double indirect blocks.
        * the first step is to determine how many levels of indirection.
        */
       sh = 1;
       bn -= NDADDR;
       for (j = NIADDR; j > 0; j--) {
               sh *= NINDIR(&io->i_fs);
               if (bn < sh)
                       break;
               bn -= sh;
       }
       if (j == 0) {
               printf("bn ovf %D\n", bn);
               return ((daddr_t)0);
       }

       /*
        * fetch the first indirect block address from the inode
        */
       nb = ip->i_ib[NIADDR - j];
       if (nb == 0) {
               printf("bn void %D\n",bn);
               return ((daddr_t)0);
       }

       /*
        * fetch through the indirect blocks
        */
       for (; j <= NIADDR; j++) {
               if (blknos[j] != nb) {
                       io->i_bn = fsbtodb(&io->i_fs, nb) + io->i_boff;
                       io->i_ma = b[j];
                       io->i_cc = io->i_fs.fs_bsize;
                       if (devread(io) != io->i_fs.fs_bsize) {
                               if (io->i_error)
                                       errno = io->i_error;
                               printf("bn %D: read error\n", io->i_bn);
                               return ((daddr_t)0);
                       }
                       blknos[j] = nb;
               }
               bap = (daddr_t *)b[j];
               sh /= NINDIR(&io->i_fs);
               i = (bn / sh) % NINDIR(&io->i_fs);
               nb = bap[i];
               if(nb == 0) {
                       printf("bn void %D\n",bn);
                       return ((daddr_t)0);
               }
       }
       return (nb);
}

static ino_t
dlook(s, io, dir)
       char *s;
       register struct iob *io;
       char *dir;
{
       register struct direct *dp;
       register struct inode *ip;
       struct dirstuff dirp;
       int len;

       if (s == NULL || *s == '\0')
               return (0);
       ip = &io->i_ino;
       if ((ip->i_mode&IFMT) != IFDIR) {
               printf("%s: not a directory\n", dir);
               return (0);
       }
       if (ip->i_size == 0) {
               printf("%s: zero length directory\n", dir);
               return (0);
       }
       len = strlen(s);
       dirp.loc = 0;
       dirp.io = io;
       for (dp = readdir(&dirp); dp != NULL; dp = readdir(&dirp)) {
               if(dp->d_ino == 0)
                       continue;
               if (dp->d_namlen == len && !strcmp(s, dp->d_name))
                       return (dp->d_ino);
       }
       return (0);
}

/*
* get next entry in a directory.
*/
struct direct *
readdir(dirp)
       register struct dirstuff *dirp;
{
       register struct direct *dp;
       register struct iob *io;
       daddr_t lbn, d;
       int off;

       io = dirp->io;
       for(;;) {
               if (dirp->loc >= io->i_ino.i_size)
                       return (NULL);
               off = blkoff(&io->i_fs, dirp->loc);
               if (off == 0) {
                       lbn = lblkno(&io->i_fs, dirp->loc);
                       d = sbmap(io, lbn);
                       if(d == 0)
                               return NULL;
                       io->i_bn = fsbtodb(&io->i_fs, d) + io->i_boff;
                       io->i_ma = io->i_buf;
                       io->i_cc = blksize(&io->i_fs, &io->i_ino, lbn);
                       if (devread(io) < 0) {
                               errno = io->i_error;
                               printf("bn %D: directory read error\n",
                                       io->i_bn);
                               return (NULL);
                       }
               }
               dp = (struct direct *)(io->i_buf + off);
               dirp->loc += dp->d_reclen;
               if (dp->d_ino == 0)
                       continue;
               return (dp);
       }
}

lseek(fdesc, addr, ptr)
       int fdesc, ptr;
       off_t addr;
{
       register struct iob *io;

#ifndef SMALL
       if (ptr != 0) {
               printf("Seek not from beginning of file\n");
               errno = EOFFSET;
               return (-1);
       }
#endif SMALL
       fdesc -= 3;
       if (fdesc < 0 || fdesc >= NFILES ||
           ((io = &iob[fdesc])->i_flgs & F_ALLOC) == 0) {
               errno = EBADF;
               return (-1);
       }
       io->i_offset = addr;
       io->i_bn = addr / DEV_BSIZE;
       io->i_cc = 0;
       return (0);
}

getc(fdesc)
       int fdesc;
{
       register struct iob *io;
       register struct fs *fs;
       register char *p;
       int c, lbn, off, size, diff;


       if (fdesc >= 0 && fdesc <= 2)
               return (getchar());
       fdesc -= 3;
       if (fdesc < 0 || fdesc >= NFILES ||
           ((io = &iob[fdesc])->i_flgs&F_ALLOC) == 0) {
               errno = EBADF;
               return (-1);
       }
       p = io->i_ma;
       if (io->i_cc <= 0) {
               if ((io->i_flgs & F_FILE) != 0) {
                       diff = io->i_ino.i_size - io->i_offset;
                       if (diff <= 0)
                               return (-1);
                       fs = &io->i_fs;
                       lbn = lblkno(fs, io->i_offset);
                       io->i_bn = fsbtodb(fs, sbmap(io, lbn)) + io->i_boff;
                       off = blkoff(fs, io->i_offset);
                       size = blksize(fs, &io->i_ino, lbn);
               } else {
                       io->i_bn = io->i_offset / DEV_BSIZE;
                       off = 0;
                       size = DEV_BSIZE;
               }
               io->i_ma = io->i_buf;
               io->i_cc = size;
               if (devread(io) < 0) {
                       errno = io->i_error;
                       return (-1);
               }
               if ((io->i_flgs & F_FILE) != 0) {
                       if (io->i_offset - off + size >= io->i_ino.i_size)
                               io->i_cc = diff + off;
                       io->i_cc -= off;
               }
               p = &io->i_buf[off];
       }
       io->i_cc--;
       io->i_offset++;
       c = (unsigned)*p++;
       io->i_ma = p;
       return (c);
}

int     errno;

read(fdesc, buf, count)
       int fdesc, count;
       char *buf;
{
       register i, size;
       register struct iob *file;
       register struct fs *fs;
       int lbn, off;

       errno = 0;
       if (fdesc >= 0 & fdesc <= 2) {
               i = count;
               do {
                       *buf = getchar();
               } while (--i && *buf++ != '\n');
               return (count - i);
       }
       fdesc -= 3;
       if (fdesc < 0 || fdesc >= NFILES ||
           ((file = &iob[fdesc])->i_flgs&F_ALLOC) == 0) {
               errno = EBADF;
               return (-1);
       }
       if ((file->i_flgs&F_READ) == 0) {
               errno = EBADF;
               return (-1);
       }
#ifndef SMALL
       if ((file->i_flgs & F_FILE) == 0) {
               file->i_cc = count;
               file->i_ma = buf;
               file->i_bn = file->i_boff + (file->i_offset / DEV_BSIZE);
               i = devread(file);
               if (i < 0)
                       errno = file->i_error;
               else
                       file->i_offset += i;
               return (i);
       }
#endif SMALL
       if (file->i_offset+count > file->i_ino.i_size)
               count = file->i_ino.i_size - file->i_offset;
       if ((i = count) <= 0)
               return (0);
       /*
        * While reading full blocks, do I/O into user buffer.
        * Anything else uses getc().
        */
       fs = &file->i_fs;
       while (i) {
               off = blkoff(fs, file->i_offset);
               lbn = lblkno(fs, file->i_offset);
               size = blksize(fs, &file->i_ino, lbn);
               if (off == 0 && size <= i) {
                       file->i_bn = fsbtodb(fs, sbmap(file, lbn)) +
                           file->i_boff;
                       file->i_cc = size;
                       file->i_ma = buf;
                       if (devread(file) < 0) {
                               errno = file->i_error;
                               return (-1);
                       }
                       file->i_offset += size;
                       file->i_cc = 0;
                       buf += size;
                       i -= size;
               } else {
                       size -= off;
                       if (size > i)
                               size = i;
                       i -= size;
                       do {
                               *buf++ = getc(fdesc+3);
                       } while (--size);
               }
       }
       return (count);
}

#ifndef SMALL
write(fdesc, buf, count)
       int fdesc, count;
       char *buf;
{
       register i;
       register struct iob *file;

       errno = 0;
       if (fdesc >= 0 && fdesc <= 2) {
               i = count;
               while (i--)
                       putchar(*buf++);
               return (count);
       }
       fdesc -= 3;
       if (fdesc < 0 || fdesc >= NFILES ||
           ((file = &iob[fdesc])->i_flgs&F_ALLOC) == 0) {
               errno = EBADF;
               return (-1);
       }
       if ((file->i_flgs&F_WRITE) == 0) {
               errno = EBADF;
               return (-1);
       }
       file->i_cc = count;
       file->i_ma = buf;
       file->i_bn = file->i_boff + (file->i_offset / DEV_BSIZE);
       i = devwrite(file);
       file->i_offset += count;
       if (i < 0)
               errno = file->i_error;
       return (i);
}
#endif SMALL

int     openfirst = 1;
unsigned opendev;               /* last device opened */
extern  unsigned bootdev;

open(str, how)
       char *str;
       int how;
{
       register char *cp;
       register int i;
       register struct iob *file;
       int fdesc;
       long atol();

       if (openfirst) {
               for (i = 0; i < NFILES; i++)
                       iob[i].i_flgs = 0;
               openfirst = 0;
       }

       for (fdesc = 0; fdesc < NFILES; fdesc++)
               if (iob[fdesc].i_flgs == 0)
                       goto gotfile;
       _stop("No more file slots");
gotfile:
       (file = &iob[fdesc])->i_flgs |= F_ALLOC;

       for (cp = str; *cp && *cp != '/' && *cp != ':' && *cp != '('; cp++)
               ;
       if (*cp == '(') {
               if ((file->i_ino.i_dev = getdev(str, cp - str)) == -1)
                       goto bad;
               cp++;
               if ((file->i_unit = getunit(cp)) == -1)
                       goto bad;
               for (; *cp != ','; cp++)
                       if (*cp == NULL) {
                               errno = EOFFSET;
                               goto badspec;
                       }
               file->i_boff = atol(++cp);
               for (;;) {
                       if (*cp == ')')
                               break;
                       if (*cp++)
                               continue;
                       goto badspec;
               }
               cp++;
       } else if (*cp != ':') {
               /* default bootstrap unit and device */
               file->i_ino.i_dev = (bootdev >> B_TYPESHIFT) & B_TYPEMASK;
               file->i_unit = ((bootdev >> B_UNITSHIFT) & B_UNITMASK) +
                    (8 * ((bootdev >> B_ADAPTORSHIFT) & B_ADAPTORMASK));
               file->i_boff = (bootdev >> B_PARTITIONSHIFT) & B_PARTITIONMASK;
               cp = str;
       } else {
# define isdigit(n)     ((n>='0') && (n<='9'))
               if (cp == str)
                       goto badspec;
               /*
                * syntax for possible device name:
                *      <alpha-string><digit-string><letter>:
                */
               for (cp = str; *cp != ':' && !isdigit(*cp); cp++)
                       ;
               if ((file->i_ino.i_dev = getdev(str, cp - str)) == -1)
                       goto bad;
               if ((file->i_unit = getunit(cp)) == -1)
                       goto bad;
               while (isdigit(*cp))
                       cp++;
               file->i_boff = 0;
               if (*cp >= 'a' && *cp <= 'h')
                       file->i_boff = *cp++ - 'a';
               if (*cp++ != ':') {
                       errno = EOFFSET;
                       goto badspec;
               }
       }
       opendev = file->i_ino.i_dev << B_TYPESHIFT;
       opendev |= ((file->i_unit % 8) << B_UNITSHIFT);
       opendev |= ((file->i_unit / 8) << B_ADAPTORSHIFT);
       opendev |= file->i_boff << B_PARTITIONSHIFT;
       opendev |= B_DEVMAGIC;
       if (errno = devopen(file))
               goto bad;
       if (cp != str && *cp == '\0') {
               file->i_flgs |= how+1;
               file->i_cc = 0;
               file->i_offset = 0;
               return (fdesc+3);
       }
       file->i_ma = (char *)(&file->i_fs);
       file->i_cc = SBSIZE;
       file->i_bn = SBOFF / DEV_BSIZE + file->i_boff;
       file->i_offset = 0;
       if (devread(file) < 0) {
               errno = file->i_error;
               printf("super block read error\n");
               goto bad;
       }
       if ((i = find(cp, file)) == 0) {
               errno = ESRCH;
               goto bad;
       }
#ifndef SMALL
       if (how != 0) {
               printf("Can't write files yet.. Sorry\n");
               errno = EIO;
               goto bad;
       }
#endif SMALL
       if (openi(i, file) < 0) {
               errno = file->i_error;
               goto bad;
       }
       file->i_offset = 0;
       file->i_cc = 0;
       file->i_flgs |= F_FILE | (how+1);
       return (fdesc+3);

badspec:
       printf("malformed device specification\n");
bad:
       file->i_flgs = 0;
       return (-1);
}

static
getdev(str, len)
       char *str;
       int len;
{
       register struct devsw *dp;

       for (dp = devsw; dp->dv_name; dp++) {
               if (!strncmp(str, dp->dv_name, len))
                       return (dp - devsw);
       }
       printf("Unknown device\n");
       errno = ENXIO;
       return (-1);
}

static
getunit(cp)
       register char *cp;
{
       register int i = 0;

       while (*cp >= '0' && *cp <= '9')
               i = i * 10 + *cp++ - '0';
       if ((unsigned) i > 255) {
               printf("minor device number out of range (0-255)\n");
               errno = EUNIT;
               i = -1;
       }
       return (i);
}

close(fdesc)
       int fdesc;
{
       struct iob *file;

       fdesc -= 3;
       if (fdesc < 0 || fdesc >= NFILES ||
           ((file = &iob[fdesc])->i_flgs&F_ALLOC) == 0) {
               errno = EBADF;
               return (-1);
       }
       if ((file->i_flgs&F_FILE) == 0)
               devclose(file);
       file->i_flgs = 0;
       return (0);
}

#ifndef SMALL
ioctl(fdesc, cmd, arg)
       int fdesc, cmd;
       char *arg;
{
       register struct iob *file;
       int error = 0;

       fdesc -= 3;
       if (fdesc < 0 || fdesc >= NFILES ||
           ((file = &iob[fdesc])->i_flgs&F_ALLOC) == 0) {
               errno = EBADF;
               return (-1);
       }
       switch (cmd) {

       case SAIOHDR:
               file->i_flgs |= F_HDR;
               break;

       case SAIOCHECK:
               file->i_flgs |= F_CHECK;
               break;

       case SAIOHCHECK:
               file->i_flgs |= F_HCHECK;
               break;

       case SAIONOBAD:
               file->i_flgs |= F_NBSF;
               break;

       case SAIODOBAD:
               file->i_flgs &= ~F_NBSF;
               break;

       default:
               error = devioctl(file, cmd, arg);
               break;
       }
       if (error < 0)
               errno = file->i_error;
       return (error);
}
#endif SMALL

exit()
{
       _stop("Exit called");
}

_stop(s)
       char *s;
{
       int i;

       for (i = 0; i < NFILES; i++)
               if (iob[i].i_flgs != 0)
                       close(i);
       printf("%s\n", s);
       _rtt();
}