From 0585c59580a14ad4ad683d57a6a459bd60a00338 Mon Sep 17 00:00:00 2001 From: Alan Cox Date: Mon, 1 Dec 2014 22:27:38 +0000 Subject: [PATCH] Standalone: feel it all through indent Now at least its readable and we can begin pruning the large chunks of it that we don't actually need. --- Standalone/devio.c | 247 ++++----- Standalone/util.c | 61 +- Standalone/xfs1.c | 610 ++++++++++---------- Standalone/xfs1a.c | 254 ++++----- Standalone/xfs1b.c | 752 ++++++++++++------------- Standalone/xfs2.c | 1324 +++++++++++++++++++++----------------------- 6 files changed, 1561 insertions(+), 1687 deletions(-) diff --git a/Standalone/devio.c b/Standalone/devio.c index 65a15750..0aab4595 100644 --- a/Standalone/devio.c +++ b/Standalone/devio.c @@ -32,72 +32,66 @@ Note that a pointer to a buffer structure is the same as a pointer to the data. This is very important. **********************************************************************/ -uint16_t bufclock = 0; /* Time-stamp counter for LRU */ +uint16_t bufclock = 0; /* Time-stamp counter for LRU */ struct blkbuf bufpool[NBUFS]; char *bread(int dev, blkno_t blk, int rewrite) { - register bufptr bp; + register bufptr bp; /*printf("Reading block %d\n", blk);*/ - bp = bfind (dev, blk); - if (bp) - { - if (bp->bf_busy) - panic ("want busy block"); - goto done; - } - bp = freebuf(); - bp->bf_dev = dev; - bp->bf_blk = blk; - - /* If rewrite is set, we are about to write over the entire block, - so we don't need the previous contents */ - - ifnot (rewrite) - if (bdread (bp) == -1) - { - udata.u_error = EIO; - return 0; - } - -/*-- if (rewrite == 2)--*/ -/*-- bzero (bp->bf_data, 512);--*/ + bp = bfind(dev, blk); + if (bp) { + if (bp->bf_busy) + panic("want busy block"); + goto done; + } + bp = freebuf(); + bp->bf_dev = dev; + bp->bf_blk = blk; + + /* If rewrite is set, we are about to write over the entire block, + so we don't need the previous contents */ + + ifnot(rewrite) + if (bdread(bp) == -1) { + udata.u_error = EIO; + return 0; + } done: - bp->bf_busy = 1; - bp->bf_time = ++bufclock; /* Time stamp it */ - return (bp->bf_data); + bp->bf_busy = 1; + bp->bf_time = ++bufclock; /* Time stamp it */ + return (bp->bf_data); } void brelse(bufptr bp) { /*printf("Releasing block %d (0)\n", bp->bf_blk);*/ - bfree (bp, 0); + bfree(bp, 0); } void bawrite(bufptr bp) { /*printf("Releasing block %d (1)\n", bp->bf_blk);*/ - bfree (bp, 1); + bfree(bp, 1); } int bfree(bufptr bp, int dirty) { /*printf("Releasing block %d (%d)\n", bp->bf_blk, dirty);*/ - bp->bf_dirty |= dirty; - bp->bf_busy = 0; - - if (dirty == 2) /* Extra dirty */ - { - if (bdwrite (bp) == -1) - udata.u_error = EIO; - bp->bf_dirty = 0; - return (-1); - } - return (0); + bp->bf_dirty |= dirty; + bp->bf_busy = 0; + + if (dirty == 2) { /* Extra dirty */ + if (bdwrite(bp) == -1) + udata.u_error = EIO; + bp->bf_dirty = 0; + return (-1); + } + return (0); } @@ -105,113 +99,106 @@ int bfree(bufptr bp, int dirty) * garbage contents. It is essentially a malloc for the kernel. * Free it with brelse()! */ -char * -tmpbuf () +char *tmpbuf() { - bufptr bp; - bufptr freebuf(); + bufptr bp; + bufptr freebuf(); /*printf("Allocating temp block\n");*/ - bp = freebuf(); - bp->bf_dev = -1; - bp->bf_busy = 1; - bp->bf_time = ++bufclock; /* Time stamp it */ - return (bp->bf_data); + bp = freebuf(); + bp->bf_dev = -1; + bp->bf_busy = 1; + bp->bf_time = ++bufclock; /* Time stamp it */ + return (bp->bf_data); } -char *zerobuf (void) +char *zerobuf(void) { - char *b; - char *tmpbuf(); + char *b; + char *tmpbuf(); - b = tmpbuf(); - bzero (b, 512); - return (b); + b = tmpbuf(); + bzero(b, 512); + return (b); } -void bufsync (void) +void bufsync(void) { - register bufptr bp; - - for (bp=bufpool; bp < bufpool+NBUFS; ++bp) - { - if (bp->bf_dev != -1 && bp->bf_dirty) - { - bdwrite (bp); - if (!bp->bf_busy) - bp->bf_dirty = 0; - } - } + register bufptr bp; + + for (bp = bufpool; bp < bufpool + NBUFS; ++bp) { + if (bp->bf_dev != -1 && bp->bf_dirty) { + bdwrite(bp); + if (!bp->bf_busy) + bp->bf_dirty = 0; + } + } } #ifndef ASM_BUFIO -bufptr bfind (int dev, blkno_t blk) +bufptr bfind(int dev, blkno_t blk) { - register bufptr bp; - - for (bp=bufpool; bp < bufpool+NBUFS; ++bp) - { - if (bp->bf_dev == dev && bp->bf_blk == blk) - return (bp); - } - return (NULL); + register bufptr bp; + + for (bp = bufpool; bp < bufpool + NBUFS; ++bp) { + if (bp->bf_dev == dev && bp->bf_blk == blk) + return (bp); + } + return (NULL); } bufptr freebuf(void) { - register bufptr bp; - register bufptr oldest; - register int oldtime; - - /* Try to find a non-busy buffer and write out the data if it is dirty */ - oldest = NULL; - oldtime = 0; - for (bp=bufpool; bp < bufpool+NBUFS; ++bp) - { - if (bufclock - bp->bf_time >= oldtime && !bp->bf_busy) - { - oldest = bp; - oldtime = bufclock - bp->bf_time; - } - } - ifnot (oldest) - panic ("no free buffers"); - - if (oldest->bf_dirty) - { - if (bdwrite (oldest) == -1) - udata.u_error = EIO; - oldest->bf_dirty = 0; - } - return (oldest); + register bufptr bp; + register bufptr oldest; + register int oldtime; + + /* Try to find a non-busy buffer and write out the data if it is dirty */ + oldest = NULL; + oldtime = 0; + for (bp = bufpool; bp < bufpool + NBUFS; ++bp) { + if (bufclock - bp->bf_time >= oldtime && !bp->bf_busy) { + oldest = bp; + oldtime = bufclock - bp->bf_time; + } + } + ifnot(oldest) + panic("no free buffers"); + + if (oldest->bf_dirty) { + if (bdwrite(oldest) == -1) + udata.u_error = EIO; + oldest->bf_dirty = 0; + } + return (oldest); } #endif - -void bufinit (void) + +void bufinit(void) { - register bufptr bp; + register bufptr bp; - for (bp=bufpool; bp < bufpool+NBUFS; ++bp) - { - bp->bf_dev = -1; - } + for (bp = bufpool; bp < bufpool + NBUFS; ++bp) { + bp->bf_dev = -1; + } } -void bufdump (void) +void bufdump(void) { - register bufptr j; + register bufptr j; - printf ("\ndev\tblock\tdirty\tbusy\ttime clock %d\n", bufclock); - for (j=bufpool; j < bufpool+NBUFS; ++j) - printf ("%d\t%u\t%d\t%d\t%u\n", - j->bf_dev,j->bf_blk,j->bf_dirty,j->bf_busy,j->bf_time); + printf("\ndev\tblock\tdirty\tbusy\ttime clock %d\n", bufclock); + for (j = bufpool; j < bufpool + NBUFS; ++j) + printf("%d\t%u\t%d\t%d\t%u\n", + j->bf_dev, j->bf_blk, j->bf_dirty, j->bf_busy, + j->bf_time); } @@ -226,28 +213,28 @@ and are handed a device number. Udata.u_base, count, and offset have the rest of the data. **********************************************************************/ -int bdread (bufptr bp) +int bdread(bufptr bp) { // printf("bdread(fd=%d, block %d)\n", dev_fd, bp->bf_blk); - udata.u_buf = bp; - if (lseek(dev_fd, dev_offset + (((int)bp->bf_blk) * 512), SEEK_SET) == -1) - perror("lseek"); - if(read(dev_fd, bp->bf_data, 512) != 512) - panic("read() failed"); + udata.u_buf = bp; + if (lseek + (dev_fd, dev_offset + (((int) bp->bf_blk) * 512), + SEEK_SET) == -1) + perror("lseek"); + if (read(dev_fd, bp->bf_data, 512) != 512) + panic("read() failed"); - return 0; + return 0; } -int bdwrite (bufptr bp) +int bdwrite(bufptr bp) { - udata.u_buf = bp; + udata.u_buf = bp; - lseek(dev_fd, dev_offset + (((int)bp->bf_blk) * 512), SEEK_SET); - if(write(dev_fd, bp->bf_data, 512) != 512) - panic("write() failed"); - return 0; + lseek(dev_fd, dev_offset + (((int) bp->bf_blk) * 512), SEEK_SET); + if (write(dev_fd, bp->bf_data, 512) != 512) + panic("write() failed"); + return 0; } - - diff --git a/Standalone/util.c b/Standalone/util.c index 9d1beed5..d6d48bce 100644 --- a/Standalone/util.c +++ b/Standalone/util.c @@ -17,51 +17,52 @@ extern int swizzling; int fd_open(char *name) { - char *namecopy, *sd; - int subdev = 0; + char *namecopy, *sd; + int subdev = 0; - namecopy=strdup(name); - sd = index(namecopy, ':'); - if(sd){ - *sd = 0; - sd++; - subdev=atoi(sd); - } + namecopy = strdup(name); + sd = index(namecopy, ':'); + if (sd) { + *sd = 0; + sd++; + subdev = atoi(sd); + } - printf("Opening %s sd%d\n", namecopy, subdev); - dev_offset = subdev << 25; // * 32MB - dev_fd = open(namecopy, O_RDWR | O_CREAT, 0666); - free(namecopy); + printf("Opening %s sd%d\n", namecopy, subdev); + dev_offset = subdev << 25; // * 32MB + dev_fd = open(namecopy, O_RDWR | O_CREAT, 0666); + free(namecopy); - if(dev_fd < 0) - return -1; - printf("fd=%d, dev_offset = %d\n", dev_fd, dev_offset); - return 0; + if (dev_fd < 0) + return -1; + printf("fd=%d, dev_offset = %d\n", dev_fd, dev_offset); + return 0; } void panic(char *s) { - fprintf(stderr, "panic: %s\n", s); - exit(1); + fprintf(stderr, "panic: %s\n", s); + exit(1); } uint16_t swizzle16(uint32_t v) { - if (v & 0xFFFF0000UL) { - fprintf(stderr, "swizzle16 given a 32bit input\n"); - exit(1); - } - if (swizzling) - return (v & 0xFF) << 8 | ((v & 0xFF00) >> 8); - else return v; + if (v & 0xFFFF0000UL) { + fprintf(stderr, "swizzle16 given a 32bit input\n"); + exit(1); + } + if (swizzling) + return (v & 0xFF) << 8 | ((v & 0xFF00) >> 8); + else + return v; } uint32_t swizzle32(uint32_t v) { - if (!swizzling) - return v; + if (!swizzling) + return v; - return (v & 0xFF) << 24 | (v & 0xFF00) << 8 | (v & 0xFF0000) >> 8 | - (v & 0xFF000000) >> 24; + return (v & 0xFF) << 24 | (v & 0xFF00) << 8 | (v & 0xFF0000) >> 8 | + (v & 0xFF000000) >> 24; } diff --git a/Standalone/xfs1.c b/Standalone/xfs1.c index 67722a08..3202b5a5 100644 --- a/Standalone/xfs1.c +++ b/Standalone/xfs1.c @@ -2,401 +2,369 @@ UZI (Unix Z80 Implementation) Utilities: xfs1.c ***************************************************/ -/*LINTLIBRARY*/ + /*LINTLIBRARY*/ + #include #include #include #include "fuzix_fs.h" - void fs_init(void) { - udata.u_euid = 0; - udata.u_insys = 1; + udata.u_euid = 0; + udata.u_insys = 1; } void xfs_init(int bootdev) { - register char *j; - inoptr i_open(); + register char *j; + inoptr i_open(); - fs_init(); - bufinit(); + fs_init(); + bufinit(); - /* User's file table */ - for (j=udata.u_files; j < (udata.u_files+UFTSIZE); ++j) - *j = -1; + /* User's file table */ + for (j = udata.u_files; j < (udata.u_files + UFTSIZE); ++j) + *j = -1; - /* Mount the root device */ - if (fmount(ROOTDEV, NULLINODE)) - panic("no filesys"); + /* Mount the root device */ + if (fmount(ROOTDEV, NULLINODE)) + panic("no filesys"); - ifnot (root = i_open(ROOTDEV,ROOTINODE)) - panic("no root"); + ifnot(root = i_open(ROOTDEV, ROOTINODE)) + panic("no root"); - i_ref(udata.u_cwd = root); + i_ref(udata.u_cwd = root); } void xfs_end(void) { - register int16_t j; + register int16_t j; - for (j=0; j < UFTSIZE; ++j) - { - ifnot (udata.u_files[j] & 0x80) /* Portable equivalent of == -1 */ - doclose(j); - } + for (j = 0; j < UFTSIZE; ++j) { + ifnot(udata.u_files[j] & 0x80) /* Portable equivalent of == -1 */ + doclose(j); + } } int _open(char *name, int16_t flag) { - int16_t uindex; - register int16_t oftindex; - register inoptr ino; - register int16_t perm; - inoptr n_open(); - int getperm(), getmode(), isdevice(), d_open(); - int uf_alloc(), oft_alloc(); - - udata.u_error = 0; - - if (flag < 0 || flag > 2) - { - udata.u_error = EINVAL; - return (-1); - } - if ((uindex = uf_alloc()) == -1) - return (-1); - - if ((oftindex = oft_alloc()) == -1) - goto nooft; - - ifnot(ino = n_open(name,NULLINOPTR)) - goto cantopen; - - of_tab[oftindex].o_inode = ino; - - perm = getperm(ino); - if (((flag == FO_RDONLY || flag == FO_RDWR) && !(perm & OTH_RD)) || - ((flag == FO_WRONLY || flag == FO_RDWR) && !(perm & OTH_WR))) - { - udata.u_error = EPERM; - goto cantopen; - } - - if (getmode(ino) == F_DIR && - (flag == FO_WRONLY || flag == FO_RDWR)) - { - udata.u_error = EISDIR; - goto cantopen; - } - - if (isdevice(ino)) // && d_open((int)ino->c_node.i_addr[0]) != 0) - { - udata.u_error = ENXIO; - goto cantopen; - } - - udata.u_files[uindex] = oftindex; - - of_tab[oftindex].o_ptr = 0; - of_tab[oftindex].o_access = flag; - - return (uindex); - -cantopen: - oft_deref(oftindex); /* This will call i_deref() */ -nooft: - udata.u_files[uindex] = -1; - return (-1); + int16_t uindex; + register int16_t oftindex; + register inoptr ino; + register int16_t perm; + inoptr n_open(); + int getperm(), getmode(), isdevice(), d_open(); + int uf_alloc(), oft_alloc(); + + udata.u_error = 0; + + if (flag < 0 || flag > 2) { + udata.u_error = EINVAL; + return (-1); + } + if ((uindex = uf_alloc()) == -1) + return (-1); + + if ((oftindex = oft_alloc()) == -1) + goto nooft; + + ifnot(ino = n_open(name, NULLINOPTR)) + goto cantopen; + + of_tab[oftindex].o_inode = ino; + + perm = getperm(ino); + if (((flag == FO_RDONLY || flag == FO_RDWR) && !(perm & OTH_RD)) || + ((flag == FO_WRONLY || flag == FO_RDWR) && !(perm & OTH_WR))) { + udata.u_error = EPERM; + goto cantopen; + } + + if (getmode(ino) == F_DIR && + (flag == FO_WRONLY || flag == FO_RDWR)) { + udata.u_error = EISDIR; + goto cantopen; + } + + if (isdevice(ino)) // && d_open((int)ino->c_node.i_addr[0]) != 0) + { + udata.u_error = ENXIO; + goto cantopen; + } + + udata.u_files[uindex] = oftindex; + + of_tab[oftindex].o_ptr = 0; + of_tab[oftindex].o_access = flag; + + return (uindex); + + cantopen: + oft_deref(oftindex); /* This will call i_deref() */ + nooft: + udata.u_files[uindex] = -1; + return (-1); } - - - - int doclose(int16_t uindex) { - register int16_t oftindex; - inoptr ino; - inoptr getinode(); - int isdevice(); + register int16_t oftindex; + inoptr ino; + inoptr getinode(); + int isdevice(); - udata.u_error = 0; - ifnot(ino = getinode(uindex)) - return(-1); - oftindex = udata.u_files[uindex]; + udata.u_error = 0; + ifnot(ino = getinode(uindex)) + return (-1); + oftindex = udata.u_files[uindex]; - //if (isdevice(ino) - // /* && ino->c_refs == 1 && of_tab[oftindex].o_refs == 1 */ ) - // d_close((int)(ino->c_node.i_addr[0])); + //if (isdevice(ino) + // /* && ino->c_refs == 1 && of_tab[oftindex].o_refs == 1 */ ) + // d_close((int)(ino->c_node.i_addr[0])); - udata.u_files[uindex] = -1; - oft_deref(oftindex); + udata.u_files[uindex] = -1; + oft_deref(oftindex); - return(0); + return (0); } int _close(int16_t uindex) { - udata.u_error = 0; - return(doclose(uindex)); + udata.u_error = 0; + return (doclose(uindex)); } - - int _creat(char *name, int16_t mode) { - register inoptr ino; - register int16_t uindex; - register int16_t oftindex; - inoptr parent; - register int16_t j; - inoptr n_open(); - inoptr newfile(); - int getperm(), getmode(), uf_alloc(), oft_alloc(); - - udata.u_error = 0; - parent = NULLINODE; - - if ((uindex = uf_alloc()) == -1) - return (-1); - if ((oftindex = oft_alloc()) == -1) - return (-1); - - ino = n_open(name,&parent); - if (ino) - { - i_deref(parent); - if (getmode(ino) == F_DIR) - { - i_deref(ino); - udata.u_error = EISDIR; - goto nogood; - } - ifnot (getperm(ino) & OTH_WR) - { - i_deref(ino); - udata.u_error = EACCES; - goto nogood; - } - if (getmode(ino) == F_REG) - { - /* Truncate the file to zero length */ - f_trunc(ino); - /* Reset any oft pointers */ - for (j=0; j < OFTSIZE; ++j) - if (of_tab[j].o_inode == ino) - of_tab[j].o_ptr = 0; - } - } - else - { - if (parent && (ino = newfile(parent,name))) - /* Parent was derefed in newfile */ - { - ino->c_node.i_mode = swizzle16(F_REG | (mode & MODE_MASK & ~udata.u_mask)); - setftime(ino, A_TIME|M_TIME|C_TIME); - /* The rest of the inode is initialized in newfile() */ - wr_inode(ino); - } - else - { - /* Doesn't exist and can't make it */ - if (parent) - i_deref(parent); - goto nogood; - } - } - udata.u_files[uindex] = oftindex; - - of_tab[oftindex].o_ptr = 0; - of_tab[oftindex].o_inode = ino; - of_tab[oftindex].o_access = FO_WRONLY; - - return (uindex); - -nogood: - oft_deref(oftindex); - return (-1); + register inoptr ino; + register int16_t uindex; + register int16_t oftindex; + inoptr parent; + register int16_t j; + inoptr n_open(); + inoptr newfile(); + int getperm(), getmode(), uf_alloc(), oft_alloc(); + + udata.u_error = 0; + parent = NULLINODE; + + if ((uindex = uf_alloc()) == -1) + return (-1); + if ((oftindex = oft_alloc()) == -1) + return (-1); + + ino = n_open(name, &parent); + if (ino) { + i_deref(parent); + if (getmode(ino) == F_DIR) { + i_deref(ino); + udata.u_error = EISDIR; + goto nogood; + } + ifnot(getperm(ino) & OTH_WR) { + i_deref(ino); + udata.u_error = EACCES; + goto nogood; + } + if (getmode(ino) == F_REG) { + /* Truncate the file to zero length */ + f_trunc(ino); + /* Reset any oft pointers */ + for (j = 0; j < OFTSIZE; ++j) + if (of_tab[j].o_inode == ino) + of_tab[j].o_ptr = 0; + } + } else { + if (parent && (ino = newfile(parent, name))) + /* Parent was derefed in newfile */ + { + ino->c_node.i_mode = + swizzle16(F_REG | + (mode & MODE_MASK & ~udata.u_mask)); + setftime(ino, A_TIME | M_TIME | C_TIME); + /* The rest of the inode is initialized in newfile() */ + wr_inode(ino); + } else { + /* Doesn't exist and can't make it */ + if (parent) + i_deref(parent); + goto nogood; + } + } + udata.u_files[uindex] = oftindex; + + of_tab[oftindex].o_ptr = 0; + of_tab[oftindex].o_inode = ino; + of_tab[oftindex].o_access = FO_WRONLY; + + return (uindex); + + nogood: + oft_deref(oftindex); + return (-1); } - - -int _link( char *name1, char *name2) +int _link(char *name1, char *name2) { - register inoptr ino; - register inoptr ino2; - inoptr parent2; - char *filename(); - inoptr n_open(); - int ch_link(), getmode(), super(); - - udata.u_error = 0; - ifnot (ino = n_open(name1,NULLINOPTR)) - return(-1); - - if (getmode(ino) == F_DIR && !super()) - { - udata.u_error = EPERM; - goto nogood; - } - - /* Make sure file2 doesn't exist, and get its parent */ - if ((ino2 = n_open(name2,&parent2))) - { - i_deref(ino2); - i_deref(parent2); - udata.u_error = EEXIST; - goto nogood; - } - - ifnot (parent2) - goto nogood; - - if (ino->c_dev != parent2->c_dev) - { - i_deref(parent2); - udata.u_error = EXDEV; - goto nogood; - } - - if (ch_link(parent2,"",filename(name2),ino) == 0) - goto nogood; - - /* Update the link count. */ - ino->c_node.i_nlink = swizzle16(swizzle16(ino->c_node.i_nlink)+1); - wr_inode(ino); - setftime(ino, C_TIME); - - i_deref(parent2); - i_deref(ino); - return(0); - -nogood: - i_deref(ino); - return(-1); + register inoptr ino; + register inoptr ino2; + inoptr parent2; + char *filename(); + inoptr n_open(); + int ch_link(), getmode(), super(); + + udata.u_error = 0; + ifnot(ino = n_open(name1, NULLINOPTR)) + return (-1); + + if (getmode(ino) == F_DIR && !super()) { + udata.u_error = EPERM; + goto nogood; + } + + /* Make sure file2 doesn't exist, and get its parent */ + if ((ino2 = n_open(name2, &parent2))) { + i_deref(ino2); + i_deref(parent2); + udata.u_error = EEXIST; + goto nogood; + } + + ifnot(parent2) + goto nogood; + + if (ino->c_dev != parent2->c_dev) { + i_deref(parent2); + udata.u_error = EXDEV; + goto nogood; + } + + if (ch_link(parent2, "", filename(name2), ino) == 0) + goto nogood; + + /* Update the link count. */ + ino->c_node.i_nlink = + swizzle16(swizzle16(ino->c_node.i_nlink) + 1); + wr_inode(ino); + setftime(ino, C_TIME); + + i_deref(parent2); + i_deref(ino); + return (0); + + nogood: + i_deref(ino); + return (-1); } - - int _unlink(char *path) { - register inoptr ino; - inoptr pino; - char *filename(); + register inoptr ino; + inoptr pino; + char *filename(); /*-- inoptr i_open();--*/ - inoptr n_open(); - int getmode(), ch_link(), super(); - - udata.u_error = 0; - ino = n_open(path,&pino); - - ifnot (pino && ino) - { - udata.u_error = ENOENT; - return (-1); - } - - if (getmode(ino) == F_DIR && !super()) - { - udata.u_error = EPERM; - goto nogood; - } - - /* Remove the directory entry */ - - if (ch_link(pino,filename(path),"",NULLINODE) == 0) - goto nogood; - - /* Decrease the link count of the inode */ - - if (ino->c_node.i_nlink == 0) - { - ino->c_node.i_nlink = swizzle16(swizzle16(ino->c_node.i_nlink)+2); - printf("_unlink: bad nlink\n"); - } else - ino->c_node.i_nlink = swizzle16(swizzle16(ino->c_node.i_nlink)-1); - setftime(ino, C_TIME); - i_deref(pino); - i_deref(ino); - return(0); -nogood: - i_deref(pino); - i_deref(ino); - return(-1); + inoptr n_open(); + int getmode(), ch_link(), super(); + + udata.u_error = 0; + ino = n_open(path, &pino); + + ifnot(pino && ino) { + udata.u_error = ENOENT; + return (-1); + } + + if (getmode(ino) == F_DIR && !super()) { + udata.u_error = EPERM; + goto nogood; + } + + /* Remove the directory entry */ + + if (ch_link(pino, filename(path), "", NULLINODE) == 0) + goto nogood; + + /* Decrease the link count of the inode */ + + if (ino->c_node.i_nlink == 0) { + ino->c_node.i_nlink = + swizzle16(swizzle16(ino->c_node.i_nlink) + 2); + printf("_unlink: bad nlink\n"); + } else + ino->c_node.i_nlink = + swizzle16(swizzle16(ino->c_node.i_nlink) - 1); + setftime(ino, C_TIME); + i_deref(pino); + i_deref(ino); + return (0); + nogood: + i_deref(pino); + i_deref(ino); + return (-1); } - - -int _read( int16_t d, char *buf, uint16_t nbytes) +int _read(int16_t d, char *buf, uint16_t nbytes) { - register inoptr ino; - inoptr rwsetup(); + register inoptr ino; + inoptr rwsetup(); - udata.u_error = 0; - /* Set up u_base, u_offset, ino; check permissions, file num. */ - if ((ino = rwsetup(1, d, buf, nbytes)) == NULLINODE) - return (-1); /* bomb out if error */ + udata.u_error = 0; + /* Set up u_base, u_offset, ino; check permissions, file num. */ + if ((ino = rwsetup(1, d, buf, nbytes)) == NULLINODE) + return (-1); /* bomb out if error */ - readi(ino); - updoff(d); + readi(ino); + updoff(d); - return (udata.u_count); + return (udata.u_count); } - - -int _write( int16_t d, char *buf, uint16_t nbytes) +int _write(int16_t d, char *buf, uint16_t nbytes) { - register inoptr ino; + register inoptr ino; /*-- off_t *offp;--*/ - inoptr rwsetup(); + inoptr rwsetup(); - udata.u_error = 0; - /* Set up u_base, u_offset, ino; check permissions, file num. */ - if ((ino = rwsetup(0, d, buf, nbytes)) == NULLINODE) - return (-1); /* bomb out if error */ + udata.u_error = 0; + /* Set up u_base, u_offset, ino; check permissions, file num. */ + if ((ino = rwsetup(0, d, buf, nbytes)) == NULLINODE) + return (-1); /* bomb out if error */ - writei(ino); - updoff(d); + writei(ino); + updoff(d); - return (udata.u_count); + return (udata.u_count); } - - -inoptr rwsetup( int rwflag, int d, char *buf, int nbytes) +inoptr rwsetup(int rwflag, int d, char *buf, int nbytes) { - register inoptr ino; - register struct oft *oftp; - inoptr getinode(); + register inoptr ino; + register struct oft *oftp; + inoptr getinode(); - udata.u_base = buf; - udata.u_count = nbytes; + udata.u_base = buf; + udata.u_count = nbytes; - if ((ino = getinode(d)) == NULLINODE) - return (NULLINODE); + if ((ino = getinode(d)) == NULLINODE) + return (NULLINODE); - oftp = of_tab + udata.u_files[d]; - if (oftp->o_access == (rwflag ? FO_WRONLY : FO_RDONLY)) - { - udata.u_error = EBADF; - return (NULLINODE); - } + oftp = of_tab + udata.u_files[d]; + if (oftp->o_access == (rwflag ? FO_WRONLY : FO_RDONLY)) { + udata.u_error = EBADF; + return (NULLINODE); + } - setftime(ino, rwflag ? A_TIME : (A_TIME | M_TIME | C_TIME)); + setftime(ino, rwflag ? A_TIME : (A_TIME | M_TIME | C_TIME)); - /* Initialize u_offset from file pointer */ - udata.u_offset = oftp->o_ptr; + /* Initialize u_offset from file pointer */ + udata.u_offset = oftp->o_ptr; - return (ino); + return (ino); } - - int psize(inoptr ino) { - return swizzle32(ino->c_node.i_size); + return swizzle32(ino->c_node.i_size); } diff --git a/Standalone/xfs1a.c b/Standalone/xfs1a.c index 1aefef44..f8e80132 100644 --- a/Standalone/xfs1a.c +++ b/Standalone/xfs1a.c @@ -5,153 +5,155 @@ * 1.4.98 - Split xfs.c into parts for compilation with Hi-Tech C. HFB */ -/*LINTLIBRARY*/ + /*LINTLIBRARY*/ #include #include #include "fuzix_fs.h" -int32_t _lseek( int16_t file, int32_t offset, int16_t flag) +int32_t _lseek(int16_t file, int32_t offset, int16_t flag) { - register inoptr ino; - register int32_t retval; - register int oftno; - - udata.u_error = 0; - if ((ino = getinode(file)) == NULLINODE) - return(-1); - - oftno = udata.u_files[file]; - - retval = of_tab[oftno].o_ptr; - - switch(flag) - { - case 0: - of_tab[oftno].o_ptr = offset; - break; - case 1: - of_tab[oftno].o_ptr += offset; - break; - case 2: - of_tab[oftno].o_ptr = swizzle32(ino->c_node.i_size) + offset; - break; - default: - udata.u_error = EINVAL; - return(-1); - } - retval = of_tab[oftno].o_ptr; - return retval; + register inoptr ino; + register int32_t retval; + register int oftno; + + udata.u_error = 0; + if ((ino = getinode(file)) == NULLINODE) + return (-1); + + oftno = udata.u_files[file]; + + retval = of_tab[oftno].o_ptr; + + switch (flag) { + case 0: + of_tab[oftno].o_ptr = offset; + break; + case 1: + of_tab[oftno].o_ptr += offset; + break; + case 2: + of_tab[oftno].o_ptr = + swizzle32(ino->c_node.i_size) + offset; + break; + default: + udata.u_error = EINVAL; + return (-1); + } + retval = of_tab[oftno].o_ptr; + return retval; } -void readi( inoptr ino ) +void readi(inoptr ino) { - register uint16_t amount; - register uint16_t toread; - register blkno_t pblk; - register char *bp; - int dev; - - dev = ino->c_dev; - switch (getmode(ino)) - { - - case F_DIR: - case F_REG: - - /* See of end of file will limit read */ - toread = udata.u_count = - min(udata.u_count, swizzle32(ino->c_node.i_size)-udata.u_offset); - goto loop; - - case F_BDEV: - toread = udata.u_count; - dev = swizzle16(*(ino->c_node.i_addr)); - -loop: - while (toread) - { - if ((pblk = bmap(ino, udata.u_offset>>9, 1)) != NULLBLK) - bp = bread(dev, pblk, 0); - else - bp = zerobuf(); - - bcopy(bp+(udata.u_offset&511), udata.u_base, - (amount = min(toread, 512 - (udata.u_offset&511)))); - brelse((bufptr)bp); - - udata.u_base += amount; - udata.u_offset += amount; - toread -= amount; - } - break; - - default: - udata.u_error = ENODEV; - } + register uint16_t amount; + register uint16_t toread; + register blkno_t pblk; + register char *bp; + int dev; + + dev = ino->c_dev; + switch (getmode(ino)) { + + case F_DIR: + case F_REG: + + /* See of end of file will limit read */ + toread = udata.u_count = + min(udata.u_count, + swizzle32(ino->c_node.i_size) - udata.u_offset); + goto loop; + + case F_BDEV: + toread = udata.u_count; + dev = swizzle16(*(ino->c_node.i_addr)); + + loop: + while (toread) { + if ((pblk = + bmap(ino, udata.u_offset >> 9, 1)) != NULLBLK) + bp = bread(dev, pblk, 0); + else + bp = zerobuf(); + + bcopy(bp + (udata.u_offset & 511), udata.u_base, + (amount = + min(toread, 512 - (udata.u_offset & 511)))); + brelse((bufptr) bp); + + udata.u_base += amount; + udata.u_offset += amount; + toread -= amount; + } + break; + + default: + udata.u_error = ENODEV; + } } /* Writei (and readi) need more i/o error handling */ -void writei( inoptr ino) +void writei(inoptr ino) { - register uint16_t amount; - register uint16_t towrite; - register char *bp; - blkno_t pblk; - int dev; - - dev = ino->c_dev; - - switch (getmode(ino)) - { - - case F_BDEV: - dev = swizzle16(*(ino->c_node.i_addr)); - case F_DIR: - case F_REG: - towrite = udata.u_count; - goto loop; - -loop: - while (towrite) - { - amount = min(towrite, 512 - (udata.u_offset&511)); - - if ((pblk = bmap(ino, udata.u_offset>>9, 0)) == NULLBLK) - break; /* No space to make more blocks */ - - /* If we are writing an entire block, we don't care - about its previous contents */ - bp = bread(dev, pblk, (amount == 512)); - - bcopy(udata.u_base, bp+(udata.u_offset&511), amount); - bawrite((bufptr)bp); - - udata.u_base += amount; - udata.u_offset += amount; - towrite -= amount; - } - - /* Update size if file grew */ - if ( udata.u_offset > swizzle32(ino->c_node.i_size)) { - ino->c_node.i_size = swizzle32(udata.u_offset); - ino->c_dirty = 1; - } - break; - - default: - udata.u_error = ENODEV; - } + register uint16_t amount; + register uint16_t towrite; + register char *bp; + blkno_t pblk; + int dev; + + dev = ino->c_dev; + + switch (getmode(ino)) { + + case F_BDEV: + dev = swizzle16(*(ino->c_node.i_addr)); + case F_DIR: + case F_REG: + towrite = udata.u_count; + goto loop; + + loop: + while (towrite) { + amount = + min(towrite, 512 - (udata.u_offset & 511)); + + if ((pblk = + bmap(ino, udata.u_offset >> 9, 0)) == NULLBLK) + break; /* No space to make more blocks */ + + /* If we are writing an entire block, we don't care + about its previous contents */ + bp = bread(dev, pblk, (amount == 512)); + + bcopy(udata.u_base, bp + (udata.u_offset & 511), + amount); + bawrite((bufptr) bp); + + udata.u_base += amount; + udata.u_offset += amount; + towrite -= amount; + } + + /* Update size if file grew */ + if (udata.u_offset > swizzle32(ino->c_node.i_size)) { + ino->c_node.i_size = swizzle32(udata.u_offset); + ino->c_dirty = 1; + } + break; + + default: + udata.u_error = ENODEV; + } } void updoff(int d) { - /* Update current file pointer */ - of_tab[udata.u_files[d]].o_ptr = udata.u_offset; + /* Update current file pointer */ + of_tab[udata.u_files[d]].o_ptr = udata.u_offset; } diff --git a/Standalone/xfs1b.c b/Standalone/xfs1b.c index df55420d..84ca02f6 100644 --- a/Standalone/xfs1b.c +++ b/Standalone/xfs1b.c @@ -2,504 +2,452 @@ UZI (Unix Z80 Implementation) Utilities: xfs1a1.c ***************************************************/ -/*LINTLIBRARY*/ + /*LINTLIBRARY*/ #include #include #include "fuzix_fs.h" + struct cinode i_tab[ITABSIZE]; struct filesys fs_tab[1]; int valadr(char *base, uint16_t size) { - return(1); + return (1); } -int _mknod( char *name, int16_t mode, int16_t dev) +int _mknod(char *name, int16_t mode, int16_t dev) { - register inoptr ino; - inoptr parent; - - udata.u_error = 0; - ifnot (super()) - { - udata.u_error = EPERM; - return(-1); - } - - if ((ino = n_open(name,&parent))) - { - udata.u_error = EEXIST; - goto nogood; - } - - ifnot (parent) - { - udata.u_error = ENOENT; - return(-1); - } - - ifnot (ino = newfile(parent,name)) - goto nogood2; - - /* Initialize mode and dev */ - ino->c_node.i_mode = swizzle16(mode & ~udata.u_mask); - ino->c_node.i_addr[0] = swizzle16(isdevice(ino) ? dev : 0); - setftime(ino, A_TIME|M_TIME|C_TIME); - wr_inode(ino); - - i_deref(ino); - return (0); - -nogood: - i_deref(ino); -nogood2: - i_deref(parent); - return (-1); + register inoptr ino; + inoptr parent; + + udata.u_error = 0; + ifnot(super()) { + udata.u_error = EPERM; + return (-1); + } + + if ((ino = n_open(name, &parent))) { + udata.u_error = EEXIST; + goto nogood; + } + + ifnot(parent) { + udata.u_error = ENOENT; + return (-1); + } + + ifnot(ino = newfile(parent, name)) + goto nogood2; + + /* Initialize mode and dev */ + ino->c_node.i_mode = swizzle16(mode & ~udata.u_mask); + ino->c_node.i_addr[0] = swizzle16(isdevice(ino) ? dev : 0); + setftime(ino, A_TIME | M_TIME | C_TIME); + wr_inode(ino); + + i_deref(ino); + return (0); + + nogood: + i_deref(ino); + nogood2: + i_deref(parent); + return (-1); } - - void _sync(void) { - int j; - inoptr ino; - char *buf; - - /* Write out modified inodes */ - - udata.u_error = 0; - for (ino=i_tab; ino < i_tab+ITABSIZE; ++ino) - if ((ino->c_refs) > 0 && ino->c_dirty != 0) - { - wr_inode(ino); - ino->c_dirty = 0; - } - - /* Write out modified super blocks */ - /* This fills the rest of the super block with garbage. */ - - for (j=0; j < NDEVS; ++j) - { - if (swizzle16(fs_tab[j].s_mounted) == SMOUNTED && fs_tab[j].s_fmod) - { - fs_tab[j].s_fmod = 0; - buf = bread(j, 1, 1); - bcopy((char *)&fs_tab[j], buf, 512); - bfree((bufptr)buf, 2); - } - } - bufsync(); /* Clear buffer pool */ + int j; + inoptr ino; + char *buf; + + /* Write out modified inodes */ + + udata.u_error = 0; + for (ino = i_tab; ino < i_tab + ITABSIZE; ++ino) + if ((ino->c_refs) > 0 && ino->c_dirty != 0) { + wr_inode(ino); + ino->c_dirty = 0; + } + + /* Write out modified super blocks */ + /* This fills the rest of the super block with garbage. */ + + for (j = 0; j < NDEVS; ++j) { + if (swizzle16(fs_tab[j].s_mounted) == SMOUNTED + && fs_tab[j].s_fmod) { + fs_tab[j].s_fmod = 0; + buf = bread(j, 1, 1); + bcopy((char *) &fs_tab[j], buf, 512); + bfree((bufptr) buf, 2); + } + } + bufsync(); /* Clear buffer pool */ } - - int _chdir(char *dir) { - register inoptr newcwd; - inoptr n_open(); - int getmode(); - - udata.u_error = 0; - ifnot (newcwd = n_open(dir,NULLINOPTR)) - return(-1); - - if (getmode(newcwd) != F_DIR) - { - udata.u_error = ENOTDIR; - i_deref(newcwd); - return(-1); - } - i_deref(udata.u_cwd); - udata.u_cwd = newcwd; - return(0); + register inoptr newcwd; + inoptr n_open(); + int getmode(); + + udata.u_error = 0; + ifnot(newcwd = n_open(dir, NULLINOPTR)) + return (-1); + + if (getmode(newcwd) != F_DIR) { + udata.u_error = ENOTDIR; + i_deref(newcwd); + return (-1); + } + i_deref(udata.u_cwd); + udata.u_cwd = newcwd; + return (0); } - - int min(int a, int b) { - return ( a < b ? a : b); + return (a < b ? a : b); } - - -int _access( char *path, int16_t mode) +int _access(char *path, int16_t mode) { - register inoptr ino; - register int16_t euid; - register int16_t egid; - register int16_t retval; - inoptr n_open(); - int getperm(); - - udata.u_error = 0; - if ((mode & 07) && !*(path)) - { - udata.u_error = ENOENT; - return (-1); - } - - /* Temporarily make eff. id real id. */ - euid = udata.u_euid; - egid = udata.u_egid; - udata.u_euid = 0; // udata.u_ptab->p_uid; - udata.u_egid = 0; // udata.u_gid; - - ifnot (ino = n_open(path,NULLINOPTR)) - { - retval = -1; - goto nogood; - } - - retval = 0; - if (~getperm(ino) & (mode&07)) - { - udata.u_error = EPERM; - retval = -1; - } - - i_deref(ino); + register inoptr ino; + register int16_t euid; + register int16_t egid; + register int16_t retval; + inoptr n_open(); + int getperm(); + + udata.u_error = 0; + if ((mode & 07) && !*(path)) { + udata.u_error = ENOENT; + return (-1); + } + + /* Temporarily make eff. id real id. */ + euid = udata.u_euid; + egid = udata.u_egid; + udata.u_euid = 0; // udata.u_ptab->p_uid; + udata.u_egid = 0; // udata.u_gid; + + ifnot(ino = n_open(path, NULLINOPTR)) { + retval = -1; + goto nogood; + } + + retval = 0; + if (~getperm(ino) & (mode & 07)) { + udata.u_error = EPERM; + retval = -1; + } + + i_deref(ino); nogood: - udata.u_euid = euid; - udata.u_egid = egid; + udata.u_euid = euid; + udata.u_egid = egid; - return(retval); + return (retval); } - -int _chmod( char *path, int16_t mode) +int _chmod(char *path, int16_t mode) { - inoptr ino; - inoptr n_open(); - int super(); - - udata.u_error = 0; - ifnot (ino = n_open(path,NULLINOPTR)) - return (-1); - - if (swizzle16(ino->c_node.i_uid) != udata.u_euid && !super()) - { - i_deref(ino); - udata.u_error = EPERM; - return(-1); - } - ino->c_node.i_mode = swizzle16((mode & MODE_MASK) | (swizzle16(ino->c_node.i_mode) & F_MASK)); - setftime(ino, C_TIME); - i_deref(ino); - return(0); + inoptr ino; + inoptr n_open(); + int super(); + + udata.u_error = 0; + ifnot(ino = n_open(path, NULLINOPTR)) + return (-1); + + if (swizzle16(ino->c_node.i_uid) != udata.u_euid && !super()) { + i_deref(ino); + udata.u_error = EPERM; + return (-1); + } + ino->c_node.i_mode = + swizzle16((mode & MODE_MASK) | + (swizzle16(ino->c_node.i_mode) & F_MASK)); + setftime(ino, C_TIME); + i_deref(ino); + return (0); } - -int _chown( char *path, int owner, int group) +int _chown(char *path, int owner, int group) { - register inoptr ino; - inoptr n_open(); - int super(); - - udata.u_error = 0; - ifnot (ino = n_open(path,NULLINOPTR)) - return (-1); - - if (swizzle16(ino->c_node.i_uid) != udata.u_euid && !super()) - { - i_deref(ino); - udata.u_error = EPERM; - return(-1); - } - - ino->c_node.i_uid = swizzle16(owner); - ino->c_node.i_gid = swizzle16(group); - setftime(ino, C_TIME); - i_deref(ino); - return(0); + register inoptr ino; + inoptr n_open(); + int super(); + + udata.u_error = 0; + ifnot(ino = n_open(path, NULLINOPTR)) + return (-1); + + if (swizzle16(ino->c_node.i_uid) != udata.u_euid && !super()) { + i_deref(ino); + udata.u_error = EPERM; + return (-1); + } + + ino->c_node.i_uid = swizzle16(owner); + ino->c_node.i_gid = swizzle16(group); + setftime(ino, C_TIME); + i_deref(ino); + return (0); } - - -int _stat( char *path, struct uzi_stat *buf) +int _stat(char *path, struct uzi_stat *buf) { - register inoptr ino; - - udata.u_error = 0; - ifnot(valadr((char*)buf,sizeof(struct uzi_stat)) && (ino = n_open(path,NULLINOPTR))) - { - return (-1); - } - stcpy(ino,buf); - i_deref(ino); - return(0); + register inoptr ino; + + udata.u_error = 0; + ifnot(valadr((char *) buf, sizeof(struct uzi_stat)) + && (ino = n_open(path, NULLINOPTR))) { + return (-1); + } + stcpy(ino, buf); + i_deref(ino); + return (0); } - - -int _fstat( int16_t fd, struct uzi_stat *buf) +int _fstat(int16_t fd, struct uzi_stat *buf) { - register inoptr ino; + register inoptr ino; - udata.u_error = 0; - ifnot(valadr((char*)buf,sizeof(struct uzi_stat))) - return(-1); + udata.u_error = 0; + ifnot(valadr((char *) buf, sizeof(struct uzi_stat))) + return (-1); - if ((ino = getinode(fd)) == NULLINODE) - return(-1); + if ((ino = getinode(fd)) == NULLINODE) + return (-1); - stcpy(ino,buf); - return(0); + stcpy(ino, buf); + return (0); } - - /* Utility for stat and fstat */ -void stcpy( inoptr ino, struct uzi_stat *buf) +void stcpy(inoptr ino, struct uzi_stat *buf) { - struct uzi_stat *b = (struct uzi_stat *)buf; + struct uzi_stat *b = (struct uzi_stat *) buf; - b->st_dev = swizzle16(ino->c_dev); - b->st_ino = swizzle16(ino->c_num); - b->st_mode = swizzle16(ino->c_node.i_mode); - b->st_nlink = swizzle16(ino->c_node.i_nlink); - b->st_uid = swizzle16(ino->c_node.i_uid); - b->st_gid = swizzle16(ino->c_node.i_gid); + b->st_dev = swizzle16(ino->c_dev); + b->st_ino = swizzle16(ino->c_num); + b->st_mode = swizzle16(ino->c_node.i_mode); + b->st_nlink = swizzle16(ino->c_node.i_nlink); + b->st_uid = swizzle16(ino->c_node.i_uid); + b->st_gid = swizzle16(ino->c_node.i_gid); - b->st_rdev = swizzle16(ino->c_node.i_addr[0]); + b->st_rdev = swizzle16(ino->c_node.i_addr[0]); - b->st_size = swizzle32(ino->c_node.i_size); - b->fst_atime = swizzle32(ino->c_node.i_atime); - b->fst_mtime = swizzle32(ino->c_node.i_mtime); - b->fst_ctime = swizzle32(ino->c_node.i_ctime); + b->st_size = swizzle32(ino->c_node.i_size); + b->fst_atime = swizzle32(ino->c_node.i_atime); + b->fst_mtime = swizzle32(ino->c_node.i_mtime); + b->fst_ctime = swizzle32(ino->c_node.i_ctime); } - - -int _dup( int16_t oldd) +int _dup(int16_t oldd) { - register int newd; - inoptr getinode(); - int uf_alloc(); + register int newd; + inoptr getinode(); + int uf_alloc(); - udata.u_error = 0; - if (getinode(oldd) == NULLINODE) - return(-1); + udata.u_error = 0; + if (getinode(oldd) == NULLINODE) + return (-1); - if ((newd = uf_alloc()) == -1) - return (-1); + if ((newd = uf_alloc()) == -1) + return (-1); - udata.u_files[newd] = udata.u_files[oldd]; - ++of_tab[udata.u_files[oldd]].o_refs; + udata.u_files[newd] = udata.u_files[oldd]; + ++of_tab[udata.u_files[oldd]].o_refs; - return(newd); + return (newd); } - - -int _dup2( int16_t oldd, int16_t newd) +int _dup2(int16_t oldd, int16_t newd) { - inoptr getinode(); + inoptr getinode(); - udata.u_error = 0; - if (getinode(oldd) == NULLINODE) - return(-1); + udata.u_error = 0; + if (getinode(oldd) == NULLINODE) + return (-1); - if (newd < 0 || newd >= UFTSIZE) - { - udata.u_error = EBADF; - return (-1); - } + if (newd < 0 || newd >= UFTSIZE) { + udata.u_error = EBADF; + return (-1); + } - ifnot (udata.u_files[newd] & 0x80) - doclose(newd); + ifnot(udata.u_files[newd] & 0x80) + doclose(newd); - udata.u_files[newd] = udata.u_files[oldd]; - ++of_tab[udata.u_files[oldd]].o_refs; + udata.u_files[newd] = udata.u_files[oldd]; + ++of_tab[udata.u_files[oldd]].o_refs; - return(0); + return (0); } - - -int _umask( int mask) +int _umask(int mask) { - register int omask; + register int omask; - udata.u_error = 0; - omask = udata.u_mask; - udata.u_mask = mask & 0777; - return(omask); + udata.u_error = 0; + omask = udata.u_mask; + udata.u_mask = mask & 0777; + return (omask); } - - /* Special system call returns super-block of given filesystem for * users to determine free space, etc. Should be replaced with a * sync() followed by a read of block 1 of the device. */ -int _getfsys(int dev,char * buf) +int _getfsys(int dev, char *buf) { - udata.u_error = 0; - if (dev < 0 || dev >= NDEVS || swizzle16(fs_tab[dev].s_mounted) != SMOUNTED) - { - udata.u_error = ENXIO; - return(-1); - } - - /* FIXME: endiam swapping here */ - bcopy((char *)&fs_tab[dev],(char *)buf,sizeof(struct filesys)); - return(0); + udata.u_error = 0; + if (dev < 0 || dev >= NDEVS + || swizzle16(fs_tab[dev].s_mounted) != SMOUNTED) { + udata.u_error = ENXIO; + return (-1); + } + + /* FIXME: endiam swapping here */ + bcopy((char *) &fs_tab[dev], (char *) buf, sizeof(struct filesys)); + return (0); } - - -int _ioctl( int fd, int request, char *data) +int _ioctl(int fd, int request, char *data) { - register inoptr ino; - // register int dev; + register inoptr ino; + // register int dev; - udata.u_error = 0; - if ((ino = getinode(fd)) == NULLINODE) - return(-1); + udata.u_error = 0; + if ((ino = getinode(fd)) == NULLINODE) + return (-1); - ifnot (isdevice(ino)) - { - udata.u_error = ENOTTY; - return(-1); - } + ifnot(isdevice(ino)) { + udata.u_error = ENOTTY; + return (-1); + } - ifnot (getperm(ino) & OTH_WR) - { - udata.u_error = EPERM; - return(-1); - } + ifnot(getperm(ino) & OTH_WR) { + udata.u_error = EPERM; + return (-1); + } - // dev = ino->c_node.i_addr[0]; + // dev = ino->c_node.i_addr[0]; - // if (d_ioctl(dev, request,data)) - // return(-1); + // if (d_ioctl(dev, request,data)) + // return(-1); - return(0); + return (0); } - - -int _mount( char *spec, char *dir, int rwflag) +int _mount(char *spec, char *dir, int rwflag) { - register inoptr sino, dino; - register int dev; - - udata.u_error = 0; - ifnot(super()) - { - udata.u_error = EPERM; - return (-1); - } - ifnot (sino = n_open(spec,NULLINOPTR)) - return (-1); - - ifnot (dino = n_open(dir,NULLINOPTR)) - { - i_deref(sino); - return (-1); - } - if (getmode(sino) != F_BDEV) - { - udata.u_error = ENOTBLK; - goto nogood; - } - if (getmode(dino) != F_DIR) - { - udata.u_error = ENOTDIR; - goto nogood; - } - dev = (int)swizzle16(sino->c_node.i_addr[0]); - - if ( dev >= NDEVS ) // || d_open(dev)) - { - udata.u_error = ENXIO; - goto nogood; - } - if (fs_tab[dev].s_mounted || dino->c_refs != 1 || dino->c_num == ROOTINODE) - { - udata.u_error = EBUSY; - goto nogood; - } - _sync(); - - if (fmount(dev,dino)) - { - udata.u_error = EBUSY; - goto nogood; - } - i_deref(dino); - i_deref(sino); - return(0); -nogood: - i_deref(dino); - i_deref(sino); - return (-1); + register inoptr sino, dino; + register int dev; + + udata.u_error = 0; + ifnot(super()) { + udata.u_error = EPERM; + return (-1); + } + ifnot(sino = n_open(spec, NULLINOPTR)) + return (-1); + + ifnot(dino = n_open(dir, NULLINOPTR)) { + i_deref(sino); + return (-1); + } + if (getmode(sino) != F_BDEV) { + udata.u_error = ENOTBLK; + goto nogood; + } + if (getmode(dino) != F_DIR) { + udata.u_error = ENOTDIR; + goto nogood; + } + dev = (int) swizzle16(sino->c_node.i_addr[0]); + + if (dev >= NDEVS) // || d_open(dev)) + { + udata.u_error = ENXIO; + goto nogood; + } + if (fs_tab[dev].s_mounted || dino->c_refs != 1 + || dino->c_num == ROOTINODE) { + udata.u_error = EBUSY; + goto nogood; + } + _sync(); + + if (fmount(dev, dino)) { + udata.u_error = EBUSY; + goto nogood; + } + i_deref(dino); + i_deref(sino); + return (0); + nogood: + i_deref(dino); + i_deref(sino); + return (-1); } - - int _umount(char *spec) { - register inoptr sino; - register int dev; - register inoptr ptr; - - udata.u_error = 0; - ifnot(super()) - { - udata.u_error = EPERM; - return (-1); - } - - ifnot (sino = n_open(spec,NULLINOPTR)) - return (-1); - - if (getmode(sino) != F_BDEV) - { - udata.u_error = ENOTBLK; - goto nogood; - } - - dev = (int)swizzle16(sino->c_node.i_addr[0]); - //ifnot (validdev(dev)) - //{ - // udata.u_error = ENXIO; - // goto nogood; - //} - - if (!fs_tab[dev].s_mounted) - { - udata.u_error = EINVAL; - goto nogood; - } - - for (ptr = i_tab; ptr < i_tab+ITABSIZE; ++ptr) - if (ptr->c_refs > 0 && ptr->c_dev == dev) - { - udata.u_error = EBUSY; - goto nogood; - } - _sync(); - fs_tab[dev].s_mounted = 0; - i_deref(fs_tab[dev].s_mntpt); - - i_deref(sino); - return(0); - -nogood: - i_deref(sino); - return (-1); + register inoptr sino; + register int dev; + register inoptr ptr; + + udata.u_error = 0; + ifnot(super()) { + udata.u_error = EPERM; + return (-1); + } + + ifnot(sino = n_open(spec, NULLINOPTR)) + return (-1); + + if (getmode(sino) != F_BDEV) { + udata.u_error = ENOTBLK; + goto nogood; + } + + dev = (int) swizzle16(sino->c_node.i_addr[0]); + //ifnot (validdev(dev)) + //{ + // udata.u_error = ENXIO; + // goto nogood; + //} + + if (!fs_tab[dev].s_mounted) { + udata.u_error = EINVAL; + goto nogood; + } + + for (ptr = i_tab; ptr < i_tab + ITABSIZE; ++ptr) + if (ptr->c_refs > 0 && ptr->c_dev == dev) { + udata.u_error = EBUSY; + goto nogood; + } + _sync(); + fs_tab[dev].s_mounted = 0; + i_deref(fs_tab[dev].s_mntpt); + + i_deref(sino); + return (0); + + nogood: + i_deref(sino); + return (-1); } - - -int _time( int tvec[]) +int _time(int tvec[]) { - udata.u_error = 0; - // rdtime(tvec); /* In machdep.c */ - return(0); + udata.u_error = 0; + // rdtime(tvec); /* In machdep.c */ + return (0); } diff --git a/Standalone/xfs2.c b/Standalone/xfs2.c index 68207deb..f44ae7b5 100644 --- a/Standalone/xfs2.c +++ b/Standalone/xfs2.c @@ -6,14 +6,13 @@ UZI (Unix Z80 Implementation) Utilities: xfs2.c * 25.2.96 Bug fix in i_deref() SN */ -/*LINTLIBRARY*/ + /*LINTLIBRARY*/ #include #include #include #include "fuzix_fs.h" /* UZI180 NOTE: This file is basically the FILESYS.C module. HFB */ - /* N_open is given a string containing a path name, and returns * an inode table pointer. If it returns NULL, the file did not * exist. If the parent existed, and parent is not null, parent @@ -24,79 +23,75 @@ UZI (Unix Z80 Implementation) Utilities: xfs2.c inoptr root; struct oft of_tab[OFTSIZE]; -inoptr n_open( register char *name, register inoptr *parent ) -{ - register inoptr wd; /* the directory we are currently searching. */ - register inoptr ninode; - register inoptr temp; - - if (*name == '/') - wd = root; - else - wd = udata.u_cwd; - - i_ref(ninode = wd); - i_ref(ninode); - - for(;;) - { - if (ninode) - magic(ninode); - - /* See if we are at a mount point */ - if (ninode) - ninode = srch_mt(ninode); - - while (*name == '/') /* Skip (possibly repeated) slashes */ - ++name; - ifnot (*name) /* No more components of path? */ - break; - ifnot (ninode) - { - udata.u_error = ENOENT; - goto nodir; - } - i_deref(wd); - wd = ninode; - if (getmode(wd) != F_DIR) - { - udata.u_error = ENOTDIR; - goto nodir; - } - ifnot (getperm(wd) & OTH_EX) - { - udata.u_error = EPERM; - goto nodir; - } - - /* See if we are going up through a mount point */ - if ( wd->c_num == ROOTINODE && wd->c_dev != ROOTDEV && name[1] == '.') - { - temp = fs_tab[wd->c_dev].s_mntpt; - ++temp->c_refs; - i_deref(wd); - wd = temp; - } - - ninode = srch_dir(wd,name); - - while (*name != '/' && *name ) - ++name; - } - - if (parent) - *parent = wd; - else - i_deref(wd); - ifnot (parent || ninode) - udata.u_error = ENOENT; - return (ninode); +inoptr n_open(register char *name, register inoptr * parent) +{ + register inoptr wd; /* the directory we are currently searching. */ + register inoptr ninode; + register inoptr temp; + + if (*name == '/') + wd = root; + else + wd = udata.u_cwd; + + i_ref(ninode = wd); + i_ref(ninode); + + for (;;) { + if (ninode) + magic(ninode); + + /* See if we are at a mount point */ + if (ninode) + ninode = srch_mt(ninode); + + while (*name == '/') /* Skip (possibly repeated) slashes */ + ++name; + ifnot(*name) /* No more components of path? */ + break; + ifnot(ninode) { + udata.u_error = ENOENT; + goto nodir; + } + i_deref(wd); + wd = ninode; + if (getmode(wd) != F_DIR) { + udata.u_error = ENOTDIR; + goto nodir; + } + ifnot(getperm(wd) & OTH_EX) { + udata.u_error = EPERM; + goto nodir; + } + + /* See if we are going up through a mount point */ + if (wd->c_num == ROOTINODE && wd->c_dev != ROOTDEV + && name[1] == '.') { + temp = fs_tab[wd->c_dev].s_mntpt; + ++temp->c_refs; + i_deref(wd); + wd = temp; + } + + ninode = srch_dir(wd, name); + + while (*name != '/' && *name) + ++name; + } + + if (parent) + *parent = wd; + else + i_deref(wd); + ifnot(parent || ninode) + udata.u_error = ENOENT; + return (ninode); nodir: - if (parent) - *parent = NULLINODE; - i_deref(wd); - return(NULLINODE); + if (parent) + *parent = NULLINODE; + i_deref(wd); + return (NULLINODE); } @@ -112,29 +107,29 @@ nodir: inoptr srch_dir(inoptr wd, register char *compname) { - register int curentry; - register blkno_t curblock; - register struct direct *buf; - register int nblocks; - unsigned inum; - - nblocks = (swizzle32(wd->c_node.i_size) + 511) >> 9; - - for (curblock=0; curblock < nblocks; ++curblock) - { - buf = (struct direct *)bread( wd->c_dev, bmap(wd, curblock, 1), 0); - for (curentry = 0; curentry < 16; ++curentry) - { - if (namecomp(compname,buf[curentry].d_name)) - { - inum = swizzle16(buf[curentry&0x0f].d_ino); - brelse((bufptr)buf); - return(i_open(wd->c_dev, inum)); - } - } - brelse((bufptr)buf); - } - return(NULLINODE); + register int curentry; + register blkno_t curblock; + register struct direct *buf; + register int nblocks; + unsigned inum; + + nblocks = (swizzle32(wd->c_node.i_size) + 511) >> 9; + + for (curblock = 0; curblock < nblocks; ++curblock) { + buf = + (struct direct *) bread(wd->c_dev, + bmap(wd, curblock, 1), 0); + for (curentry = 0; curentry < 16; ++curentry) { + if (namecomp(compname, buf[curentry].d_name)) { + inum = + swizzle16(buf[curentry & 0x0f].d_ino); + brelse((bufptr) buf); + return (i_open(wd->c_dev, inum)); + } + } + brelse((bufptr) buf); + } + return (NULLINODE); } @@ -143,19 +138,19 @@ inoptr srch_dir(inoptr wd, register char *compname) * root of the mounted filesystem. */ -inoptr srch_mt( inoptr ino) +inoptr srch_mt(inoptr ino) { - register int j; - inoptr i_open(); + register int j; + inoptr i_open(); - for (j=0; j < NDEVS; ++j) - if (fs_tab[j].s_mounted == SMOUNTED && fs_tab[j].s_mntpt == ino) - { - i_deref(ino); - return(i_open(j,ROOTINODE)); - } + for (j = 0; j < NDEVS; ++j) + if (fs_tab[j].s_mounted == SMOUNTED + && fs_tab[j].s_mntpt == ino) { + i_deref(ino); + return (i_open(j, ROOTINODE)); + } - return(ino); + return (ino); } @@ -165,90 +160,83 @@ inoptr srch_mt( inoptr ino) * An inode # of zero means a newly allocated inode. */ -inoptr i_open( register int dev, register unsigned ino) +inoptr i_open(register int dev, register unsigned ino) { - struct dinode *buf; - register inoptr nindex; - int i; - register inoptr j; - int new; - static inoptr nexti = i_tab; /* added inoptr. 26.12.97 HFB */ - unsigned i_alloc(); - - if (dev<0 || dev>=NDEVS) - panic("i_open: Bad dev"); - - new = 0; - ifnot (ino) /* Want a new one */ - { - new = 1; - ifnot (ino = i_alloc(dev)) - { - udata.u_error = ENOSPC; - return (NULLINODE); - } - } - - if (ino < ROOTINODE || ino >= (fs_tab[dev].s_isize-2)*8) - { - printf("i_open: bad inode number\n"); - return (NULLINODE); - } - - - nindex = NULLINODE; - j = (inoptr) nexti; - for (i=0; i < ITABSIZE; ++i) - { - nexti = (inoptr)j; - if (++j >= i_tab+ITABSIZE) - j = i_tab; - - ifnot (j->c_refs) - nindex = j; - - if (j->c_dev == dev && j->c_num == ino) - { - nindex = j; - goto found; - } - } - - /* Not already in table. */ - - ifnot (nindex) /* No unrefed slots in inode table */ - { - udata.u_error = ENFILE; - return(NULLINODE); - } - - buf = (struct dinode *)bread(dev, (ino>>3)+2, 0); - bcopy((char *)&(buf[ino & 0x07]), (char *)&(nindex->c_node), 64); - brelse((bufptr)buf); - - nindex->c_dev = dev; - nindex->c_num = ino; - nindex->c_magic = CMAGIC; + struct dinode *buf; + register inoptr nindex; + int i; + register inoptr j; + int new; + static inoptr nexti = i_tab; /* added inoptr. 26.12.97 HFB */ + unsigned i_alloc(); + + if (dev < 0 || dev >= NDEVS) + panic("i_open: Bad dev"); + + new = 0; + ifnot(ino) { /* Want a new one */ + new = 1; + ifnot(ino = i_alloc(dev)) { + udata.u_error = ENOSPC; + return (NULLINODE); + } + } + + if (ino < ROOTINODE || ino >= (fs_tab[dev].s_isize - 2) * 8) { + printf("i_open: bad inode number\n"); + return (NULLINODE); + } + + + nindex = NULLINODE; + j = (inoptr) nexti; + for (i = 0; i < ITABSIZE; ++i) { + nexti = (inoptr) j; + if (++j >= i_tab + ITABSIZE) + j = i_tab; + + ifnot(j->c_refs) + nindex = j; + + if (j->c_dev == dev && j->c_num == ino) { + nindex = j; + goto found; + } + } + + /* Not already in table. */ + + ifnot(nindex) { /* No unrefed slots in inode table */ + udata.u_error = ENFILE; + return (NULLINODE); + } + + buf = (struct dinode *) bread(dev, (ino >> 3) + 2, 0); + bcopy((char *) &(buf[ino & 0x07]), (char *) &(nindex->c_node), 64); + brelse((bufptr) buf); + + nindex->c_dev = dev; + nindex->c_num = ino; + nindex->c_magic = CMAGIC; found: - if (new) - { - if (nindex->c_node.i_nlink || swizzle16(nindex->c_node.i_mode) & F_MASK) - goto badino; - } - else - { - ifnot (nindex->c_node.i_nlink && swizzle16(nindex->c_node.i_mode) & F_MASK) - goto badino; - } - - ++nindex->c_refs; - return(nindex); + if (new) { + if (nindex->c_node.i_nlink + || swizzle16(nindex->c_node.i_mode) & F_MASK) + goto badino; + } else { + ifnot(nindex->c_node.i_nlink + && swizzle16(nindex->c_node.i_mode) & F_MASK) + goto badino; + } + + ++nindex->c_refs; + return (nindex); badino: - printf("i_open: bad disk inode\n"); - return (NULLINODE); + printf("i_open: bad disk inode\n"); + return (NULLINODE); } @@ -262,72 +250,75 @@ badino: * or the user did not have write permission. */ -int ch_link( inoptr wd, char *oldname, char *newname, inoptr nindex) +int ch_link(inoptr wd, char *oldname, char *newname, inoptr nindex) { - struct direct curentry; + struct direct curentry; - ifnot (getperm(wd) & OTH_WR) - { - udata.u_error = EPERM; - return (0); - } + ifnot(getperm(wd) & OTH_WR) { + udata.u_error = EPERM; + return (0); + } - /* Search the directory for the desired slot. */ + /* Search the directory for the desired slot. */ - udata.u_offset = 0; + udata.u_offset = 0; - for (;;) - { - udata.u_count = 32; - udata.u_base = (char *)&curentry; -// udata.u_sysio = 1; /*280*/ - readi(wd); + for (;;) { + udata.u_count = 32; + udata.u_base = (char *) &curentry; +// udata.u_sysio = 1; /*280*/ + readi(wd); - /* Read until EOF or name is found */ - /* readi() advances udata.u_offset */ - if (udata.u_count == 0 || namecomp(oldname, curentry.d_name)) - break; - } + /* Read until EOF or name is found */ + /* readi() advances udata.u_offset */ + if (udata.u_count == 0 + || namecomp(oldname, curentry.d_name)) + break; + } - if (udata.u_count == 0 && *oldname) - return (0); /* Entry not found */ + if (udata.u_count == 0 && *oldname) + return (0); /* Entry not found */ - bcopy(newname, curentry.d_name, 30); + bcopy(newname, curentry.d_name, 30); #if 1 - { - int i; - - for (i = 0; i < 30; ++i) if (curentry.d_name[i] == '\0') break; - for ( ; i < 30; ++i) curentry.d_name[i] = '\0'; - } + { + int i; + + for (i = 0; i < 30; ++i) + if (curentry.d_name[i] == '\0') + break; + for (; i < 30; ++i) + curentry.d_name[i] = '\0'; + } #endif - if (nindex) - curentry.d_ino = swizzle16(nindex->c_num); - else - curentry.d_ino = 0; + if (nindex) + curentry.d_ino = swizzle16(nindex->c_num); + else + curentry.d_ino = 0; - /* If an existing slot is being used, we must back up the file offset */ - if (udata.u_count) - udata.u_offset -= 32; + /* If an existing slot is being used, we must back up the file offset */ + if (udata.u_count) + udata.u_offset -= 32; - udata.u_count = 32; - udata.u_base = (char *)&curentry; - udata.u_sysio = 1; /*280*/ - writei(wd); + udata.u_count = 32; + udata.u_base = (char *) &curentry; + udata.u_sysio = 1; /*280 */ + writei(wd); - if (udata.u_error) - return (0); + if (udata.u_error) + return (0); - setftime(wd, A_TIME|M_TIME|C_TIME); /* Sets c_dirty */ + setftime(wd, A_TIME | M_TIME | C_TIME); /* Sets c_dirty */ - /* Update file length to next block */ - if (swizzle32(wd->c_node.i_size)&511) - wd->c_node.i_size = - swizzle32(wd->c_node.i_size) + 512 - (swizzle16(wd->c_node.i_size)&511); + /* Update file length to next block */ + if (swizzle32(wd->c_node.i_size) & 511) + wd->c_node.i_size = + swizzle32(wd->c_node.i_size) + 512 - + (swizzle16(wd->c_node.i_size) & 511); - return (1); + return (1); } @@ -336,36 +327,34 @@ int ch_link( inoptr wd, char *oldname, char *newname, inoptr nindex) * final component of it. */ -char * filename( char *path) +char *filename(char *path) { - register char *ptr; - - ptr = path; - while (*ptr) - ++ptr; - while (*ptr != '/' && ptr-- > path) - ; - return (ptr+1); + register char *ptr; + + ptr = path; + while (*ptr) + ++ptr; + while (*ptr != '/' && ptr-- > path); + return (ptr + 1); } /* Namecomp compares two strings to see if they are the same file name. - * It stops at 14 chars or a null or a slash. It returns 0 for difference. + * It stops at 30 chars or a null or a slash. It returns 0 for difference. */ -int namecomp( char *n1, char *n2) +int namecomp(char *n1, char *n2) { - register int n; - - n = 30; - while (*n1 && *n1 != '/') - { - if (*n1++ != *n2++) - return(0); - ifnot (--n) - return(-1); - } - return(*n2 == '\0' || *n2 == '/'); + register int n; + + n = 30; + while (*n1 && *n1 != '/') { + if (*n1++ != *n2++) + return (0); + ifnot(--n) + return (-1); + } + return (*n2 == '\0' || *n2 == '/'); } @@ -378,41 +367,40 @@ int namecomp( char *n1, char *n2) * Better make sure there isn't already an entry with the same name. */ -inoptr newfile( inoptr pino, char *name) +inoptr newfile(inoptr pino, char *name) { - register inoptr nindex; - register int j; + register inoptr nindex; + register int j; - /* First see if parent is writeable */ /*280*/ - ifnot (getperm(pino) & OTH_WR) /*280*/ - goto nogood; /*280*/ + /* First see if parent is writeable *//*280 */ + ifnot(getperm(pino) & OTH_WR) /*280 */ + goto nogood; /*280 */ - ifnot (nindex = i_open(pino->c_dev, 0)) - goto nogood; + ifnot(nindex = i_open(pino->c_dev, 0)) + goto nogood; - /* BIG FIX: user/group setting was missing SN */ /*280*/ - nindex->c_node.i_uid = swizzle16(udata.u_euid); /*280*/ - nindex->c_node.i_gid = swizzle16(udata.u_egid); /*280*/ + /* BIG FIX: user/group setting was missing SN *//*280 */ + nindex->c_node.i_uid = swizzle16(udata.u_euid); /*280 */ + nindex->c_node.i_gid = swizzle16(udata.u_egid); /*280 */ - nindex->c_node.i_mode = swizzle16(F_REG); /* For the time being */ - nindex->c_node.i_nlink = swizzle16(1); - nindex->c_node.i_size = 0; - for (j=0; j <20; j++) - nindex->c_node.i_addr[j] = 0; - wr_inode(nindex); + nindex->c_node.i_mode = swizzle16(F_REG); /* For the time being */ + nindex->c_node.i_nlink = swizzle16(1); + nindex->c_node.i_size = 0; + for (j = 0; j < 20; j++) + nindex->c_node.i_addr[j] = 0; + wr_inode(nindex); - ifnot (ch_link(pino,"",filename(name),nindex)) - { - i_deref(nindex); - goto nogood; - } + ifnot(ch_link(pino, "", filename(name), nindex)) { + i_deref(nindex); + goto nogood; + } - i_deref (pino); - return(nindex); + i_deref(pino); + return (nindex); nogood: - i_deref (pino); - return (NULLINODE); + i_deref(pino); + return (NULLINODE); } @@ -421,15 +409,15 @@ nogood: * Used when freeing and allocating blocks and inodes. */ -fsptr getdev( int devno) +fsptr getdev(int devno) { - register fsptr dev; + register fsptr dev; - dev = fs_tab + devno; - if (devno < 0 || devno >= NDEVS || !dev->s_mounted) - panic("getdev: bad dev"); - dev->s_fmod = 1; - return (dev); + dev = fs_tab + devno; + if (devno < 0 || devno >= NDEVS || !dev->s_mounted) + panic("getdev: bad dev"); + dev->s_fmod = 1; + return (dev); } @@ -438,7 +426,7 @@ fsptr getdev( int devno) int baddev(fsptr dev) { - return (swizzle16(dev->s_mounted) != SMOUNTED); + return (swizzle16(dev->s_mounted) != SMOUNTED); } @@ -448,71 +436,67 @@ int baddev(fsptr dev) unsigned i_alloc(int devno) { - fsptr dev; - blkno_t blk; - struct dinode *buf; - register int j; - register int k; - unsigned ino; - int baddev(); - /* struct dinode *bread(); -- HP */ /*????? HFB 26.12.97 */ - - if (baddev(dev = getdev(devno))) - goto corrupt; - -tryagain: - if (dev->s_ninode) - { - int i; - - ifnot (dev->s_tinode) - goto corrupt; - i = swizzle16(dev->s_ninode); - ino = swizzle16(dev->s_inode[--i]); - dev->s_ninode = swizzle16(i); - if (ino < 2 || ino >= (swizzle16(dev->s_isize)-2)*8) - goto corrupt; - dev->s_tinode = swizzle16(swizzle16(dev->s_tinode)-1); - return(ino); - } - - /* We must scan the inodes, and fill up the table */ - - _sync(); /* Make on-disk inodes consistent */ - k = 0; - for (blk = 2; blk < dev->s_isize; blk++) - { - buf = (struct dinode *)bread(devno, blk, 0); - for (j=0; j < 8; j++) - { - ifnot (buf[j].i_mode || buf[j].i_nlink) - dev->s_inode[k++] = swizzle16(8*(blk-2) + j); - if (k==50) - { - brelse((bufptr)buf); - goto done; - } - } - brelse((bufptr)buf); - } - -done: - ifnot (k) - { - if (dev->s_tinode) - goto corrupt; - udata.u_error = ENOSPC; - return(0); - } - - dev->s_ninode = swizzle16(k); - goto tryagain; - -corrupt: - printf("i_alloc: corrupt superblock\n"); - dev->s_mounted = swizzle16(1); - udata.u_error = ENOSPC; - return(0); + fsptr dev; + blkno_t blk; + struct dinode *buf; + register int j; + register int k; + unsigned ino; + int baddev(); + /* struct dinode *bread(); -- HP *//*????? HFB 26.12.97 */ + + if (baddev(dev = getdev(devno))) + goto corrupt; + + tryagain: + if (dev->s_ninode) { + int i; + + ifnot(dev->s_tinode) + goto corrupt; + i = swizzle16(dev->s_ninode); + ino = swizzle16(dev->s_inode[--i]); + dev->s_ninode = swizzle16(i); + if (ino < 2 || ino >= (swizzle16(dev->s_isize) - 2) * 8) + goto corrupt; + dev->s_tinode = swizzle16(swizzle16(dev->s_tinode) - 1); + return (ino); + } + + /* We must scan the inodes, and fill up the table */ + + _sync(); /* Make on-disk inodes consistent */ + k = 0; + for (blk = 2; blk < dev->s_isize; blk++) { + buf = (struct dinode *) bread(devno, blk, 0); + for (j = 0; j < 8; j++) { + ifnot(buf[j].i_mode || buf[j].i_nlink) + dev->s_inode[k++] = + swizzle16(8 * (blk - 2) + j); + if (k == 50) { + brelse((bufptr) buf); + goto done; + } + } + brelse((bufptr) buf); + } + + done: + ifnot(k) { + if (dev->s_tinode) + goto corrupt; + udata.u_error = ENOSPC; + return (0); + } + + dev->s_ninode = swizzle16(k); + goto tryagain; + + corrupt: + printf("i_alloc: corrupt superblock\n"); + dev->s_mounted = swizzle16(1); + udata.u_error = ENOSPC; + return (0); } @@ -521,22 +505,22 @@ corrupt: * inode table or in the filesystem. */ -void i_free( int devno, unsigned ino) +void i_free(int devno, unsigned ino) { - register fsptr dev; + register fsptr dev; - if (baddev(dev = getdev(devno))) - return; + if (baddev(dev = getdev(devno))) + return; - if (ino < 2 || ino >= (swizzle16(dev->s_isize)-2)*8) - panic("i_free: bad ino"); + if (ino < 2 || ino >= (swizzle16(dev->s_isize) - 2) * 8) + panic("i_free: bad ino"); - dev->s_tinode = swizzle16(swizzle16(dev->s_tinode) + 1); - if (swizzle16(dev->s_ninode) < 50) { - int i = swizzle16(dev->s_ninode); - dev->s_inode[i++] = swizzle16(ino); - dev->s_ninode = swizzle16(i); - } + dev->s_tinode = swizzle16(swizzle16(dev->s_tinode) + 1); + if (swizzle16(dev->s_ninode) < 50) { + int i = swizzle16(dev->s_ninode); + dev->s_inode[i++] = swizzle16(ino); + dev->s_ninode = swizzle16(i); + } } @@ -544,95 +528,91 @@ void i_free( int devno, unsigned ino) * from it. A returned block number of zero means no more blocks. */ -blkno_t blk_alloc( int devno ) +blkno_t blk_alloc(int devno) { - register fsptr dev; - register blkno_t newno; - blkno_t *buf; /*, *bread(); -- HP */ - register int j; - int i; - - if (baddev(dev = getdev(devno))) - goto corrupt2; - - if (swizzle16(dev->s_nfree) <= 0 || swizzle16(dev->s_nfree) > 50) - goto corrupt; - - i = swizzle16(dev->s_nfree); - newno = swizzle16(dev->s_free[--i]); - dev->s_nfree=swizzle16(i); - ifnot (newno) - { - if (dev->s_tfree != 0) - goto corrupt; - udata.u_error = ENOSPC; - dev->s_nfree=swizzle16(swizzle16(dev->s_nfree)+1); - return(0); - } - - /* See if we must refill the s_free array */ - - ifnot (dev->s_nfree) - { - buf = (blkno_t *)bread(devno,newno, 0); - dev->s_nfree = buf[0]; - for (j=0; j < 50; j++) - { - dev->s_free[j] = buf[j+1]; - } - brelse((bufptr)buf); - } - - validblk(devno, newno); - - ifnot (dev->s_tfree) - goto corrupt; - dev->s_tfree=swizzle16(swizzle16(dev->s_tfree)-1); - - /* Zero out the new block */ - buf = (blkno_t *)bread(devno, newno, 2); - bzero(buf, 512); - bawrite((bufptr)buf); - return(newno); - -corrupt: - printf("blk_alloc: corrupt\n"); - dev->s_mounted = swizzle16(1); -corrupt2: - udata.u_error = ENOSPC; - return(0); + register fsptr dev; + register blkno_t newno; + blkno_t *buf; /*, *bread(); -- HP */ + register int j; + int i; + + if (baddev(dev = getdev(devno))) + goto corrupt2; + + if (swizzle16(dev->s_nfree) <= 0 || swizzle16(dev->s_nfree) > 50) + goto corrupt; + + i = swizzle16(dev->s_nfree); + newno = swizzle16(dev->s_free[--i]); + dev->s_nfree = swizzle16(i); + ifnot(newno) { + if (dev->s_tfree != 0) + goto corrupt; + udata.u_error = ENOSPC; + dev->s_nfree = swizzle16(swizzle16(dev->s_nfree) + 1); + return (0); + } + + /* See if we must refill the s_free array */ + + ifnot(dev->s_nfree) { + buf = (blkno_t *) bread(devno, newno, 0); + dev->s_nfree = buf[0]; + for (j = 0; j < 50; j++) { + dev->s_free[j] = buf[j + 1]; + } + brelse((bufptr) buf); + } + + validblk(devno, newno); + + ifnot(dev->s_tfree) + goto corrupt; + dev->s_tfree = swizzle16(swizzle16(dev->s_tfree) - 1); + + /* Zero out the new block */ + buf = (blkno_t *) bread(devno, newno, 2); + bzero(buf, 512); + bawrite((bufptr) buf); + return (newno); + + corrupt: + printf("blk_alloc: corrupt\n"); + dev->s_mounted = swizzle16(1); + corrupt2: + udata.u_error = ENOSPC; + return (0); } /* Blk_free is given a device number and a block number, and frees the block. */ -void blk_free( int devno, blkno_t blk) +void blk_free(int devno, blkno_t blk) { - register fsptr dev; - register char *buf; - int b; - - ifnot (blk) - return; - - if (baddev(dev = getdev(devno))) - return; - - validblk(devno, blk); - - if (dev->s_nfree == 50) - { - buf = bread(devno, blk, 1); - bcopy((char *)&(dev->s_nfree), buf, 512); - bawrite((bufptr)buf); - dev->s_nfree = 0; - } - - dev->s_tfree = swizzle16(swizzle16(dev->s_tfree)+1); - b = swizzle16(dev->s_nfree); - dev->s_free[b++] = swizzle16(blk); - dev->s_nfree=swizzle16(b); + register fsptr dev; + register char *buf; + int b; + + ifnot(blk) + return; + + if (baddev(dev = getdev(devno))) + return; + + validblk(devno, blk); + + if (dev->s_nfree == 50) { + buf = bread(devno, blk, 1); + bcopy((char *) &(dev->s_nfree), buf, 512); + bawrite((bufptr) buf); + dev->s_nfree = 0; + } + + dev->s_tfree = swizzle16(swizzle16(dev->s_tfree) + 1); + b = swizzle16(dev->s_nfree); + dev->s_free[b++] = swizzle16(blk); + dev->s_nfree = swizzle16(b); } @@ -642,32 +622,29 @@ void blk_free( int devno, blkno_t blk) int oft_alloc(void) { - register int j; - - for (j=0; j < OFTSIZE ; ++j) - { - ifnot (of_tab[j].o_refs) - { - of_tab[j].o_refs = 1; - of_tab[j].o_inode = NULLINODE; - return (j); - } - } - udata.u_error = ENFILE; - return(-1); + register int j; + + for (j = 0; j < OFTSIZE; ++j) { + ifnot(of_tab[j].o_refs) { + of_tab[j].o_refs = 1; + of_tab[j].o_inode = NULLINODE; + return (j); + } + } + udata.u_error = ENFILE; + return (-1); } void oft_deref(int of) { - register struct oft *ofptr; - - ofptr = of_tab + of; - if (!(--ofptr->o_refs) && ofptr->o_inode) - { - i_deref(ofptr->o_inode); - ofptr->o_inode = NULLINODE; - } + register struct oft *ofptr; + + ofptr = of_tab + of; + if (!(--ofptr->o_refs) && ofptr->o_inode) { + i_deref(ofptr->o_inode); + ofptr->o_inode = NULLINODE; + } } @@ -676,30 +653,27 @@ void oft_deref(int of) int uf_alloc(void) { - register int j; - - for (j=0; j < UFTSIZE ; ++j) - { - if (udata.u_files[j] & 0x80) /* Portable, unlike == -1 */ - { - return (j); - } - } - udata.u_error = ENFILE; - return(-1); + register int j; + + for (j = 0; j < UFTSIZE; ++j) { + if (udata.u_files[j] & 0x80) { /* Portable, unlike == -1 */ + return (j); + } + } + udata.u_error = ENFILE; + return (-1); } /* I_ref increases the reference count of the given inode table entry. */ -void i_ref( inoptr ino) +void i_ref(inoptr ino) { - if (++(ino->c_refs) == 2*ITABSIZE) /* Arbitrary limit. */ - { /*280*/ - printf("inode %u,",ino->c_num); /*280*/ - panic("too many i-refs"); - } /*280*/ + if (++(ino->c_refs) == 2 * ITABSIZE) { /* Arbitrary limit. *//*280 */ + printf("inode %u,", ino->c_num); /*280 */ + panic("too many i-refs"); + } /*280 */ } @@ -710,37 +684,34 @@ void i_ref( inoptr ino) void i_deref(inoptr ino) { - unsigned int m; + unsigned int m; - magic(ino); + magic(ino); - ifnot (ino->c_refs) - panic("inode freed."); + ifnot(ino->c_refs) + panic("inode freed."); - /* If the inode has no links and no refs, it must have - its blocks freed. */ + /* If the inode has no links and no refs, it must have + its blocks freed. */ - ifnot (--ino->c_refs || ino->c_node.i_nlink) { + ifnot(--ino->c_refs || ino->c_node.i_nlink) { /* SN (mcy) */ - m = swizzle16(ino->c_node.i_mode); - if (((m & F_MASK) == F_REG) || - ((m & F_MASK) == F_DIR) || - ((m & F_MASK) == F_PIPE)) - f_trunc(ino); - } - /* If the inode was modified, we must write it to disk. */ - if (!(ino->c_refs) && ino->c_dirty) - { - ifnot (ino->c_node.i_nlink) - { - ino->c_node.i_mode = 0; - i_free(ino->c_dev, ino->c_num); - } - wr_inode(ino); - } + m = swizzle16(ino->c_node.i_mode); + if (((m & F_MASK) == F_REG) || + ((m & F_MASK) == F_DIR) || ((m & F_MASK) == F_PIPE)) + f_trunc(ino); + } + /* If the inode was modified, we must write it to disk. */ + if (!(ino->c_refs) && ino->c_dirty) { + ifnot(ino->c_node.i_nlink) { + ino->c_node.i_mode = 0; + i_free(ino->c_dev, ino->c_num); + } + wr_inode(ino); + } } @@ -750,31 +721,31 @@ void i_deref(inoptr ino) void wr_inode(inoptr ino) { - struct dinode *buf; - register blkno_t blkno; + struct dinode *buf; + register blkno_t blkno; - magic(ino); + magic(ino); - blkno = (ino->c_num >> 3) + 2; - buf = (struct dinode *)bread(ino->c_dev, blkno,0); - bcopy((char *)(&ino->c_node), - (char *)((char **)&buf[ino->c_num & 0x07]), 64); - bfree((bufptr)buf, 2); - ino->c_dirty = 0; + blkno = (ino->c_num >> 3) + 2; + buf = (struct dinode *) bread(ino->c_dev, blkno, 0); + bcopy((char *) (&ino->c_node), + (char *) ((char **) &buf[ino->c_num & 0x07]), 64); + bfree((bufptr) buf, 2); + ino->c_dirty = 0; } /* isdevice(ino) returns true if ino points to a device */ int isdevice(inoptr ino) { - return (swizzle16(ino->c_node.i_mode) & 020000); + return (swizzle16(ino->c_node.i_mode) & 020000); } /* This returns the device number of an inode representing a device */ int devnum(inoptr ino) { - return (swizzle16(*(ino->c_node.i_addr))); + return (swizzle16(*(ino->c_node.i_addr))); } @@ -784,46 +755,45 @@ int devnum(inoptr ino) void f_trunc(inoptr ino) { - int dev; - int j; + int dev; + int j; - dev = ino->c_dev; + dev = ino->c_dev; - /* First deallocate the double indirect blocks */ - freeblk(dev, swizzle16(ino->c_node.i_addr[19]), 2); + /* First deallocate the double indirect blocks */ + freeblk(dev, swizzle16(ino->c_node.i_addr[19]), 2); - /* Also deallocate the indirect blocks */ - freeblk(dev, swizzle16(ino->c_node.i_addr[18]), 1); + /* Also deallocate the indirect blocks */ + freeblk(dev, swizzle16(ino->c_node.i_addr[18]), 1); - /* Finally, free the direct blocks */ - for (j=17; j >= 0; --j) - freeblk(dev, swizzle16(ino->c_node.i_addr[j]), 0); + /* Finally, free the direct blocks */ + for (j = 17; j >= 0; --j) + freeblk(dev, swizzle16(ino->c_node.i_addr[j]), 0); - bzero((char *)ino->c_node.i_addr, sizeof(ino->c_node.i_addr)); + bzero((char *) ino->c_node.i_addr, sizeof(ino->c_node.i_addr)); - ino->c_dirty = 1; - ino->c_node.i_size = 0; + ino->c_dirty = 1; + ino->c_node.i_size = 0; } /* Companion function to f_trunc(). */ void freeblk(int dev, blkno_t blk, int level) { - blkno_t *buf; - int j; + blkno_t *buf; + int j; - ifnot (blk) - return; + ifnot(blk) + return; - if (level) - { - buf = (blkno_t *)bread(dev, blk, 0); - for (j=255; j >= 0; --j) - freeblk(dev, swizzle16(buf[j]), level-1); - brelse((bufptr)buf); - } + if (level) { + buf = (blkno_t *) bread(dev, blk, 0); + for (j = 255; j >= 0; --j) + freeblk(dev, swizzle16(buf[j]), level - 1); + brelse((bufptr) buf); + } - blk_free(dev,blk); + blk_free(dev, blk); } @@ -836,84 +806,81 @@ void freeblk(int dev, blkno_t blk, int level) */ blkno_t bmap(inoptr ip, blkno_t bn, int rwflg) { - register int i; - register bufptr bp; - register int j; - register blkno_t nb; - int sh; - int dev; - - if (getmode(ip) == F_BDEV) - return (bn); - - dev = ip->c_dev; - - /* - * blocks 0..17 are direct blocks - */ - if(bn < 18) { - nb = swizzle16(ip->c_node.i_addr[bn]); - if(nb == 0) { - if(rwflg || (nb = blk_alloc(dev))==0) - return(NULLBLK); - ip->c_node.i_addr[bn] = swizzle16(nb); - ip->c_dirty = 1; - } - return(nb); - } - - /* - * addresses 18 and 19 have single and double indirect blocks. - * the first step is to determine how many levels of indirection. - */ - bn -= 18; - sh = 0; - j = 2; - if (bn & 0xff00) /* bn > 255 so double indirect */ - { - sh = 8; - bn -= 256; - j = 1; - } - - /* - * fetch the address from the inode - * Create the first indirect block if needed. - */ - ifnot (nb = ip->c_node.i_addr[20-j]) - { - if(rwflg || !(nb = blk_alloc(dev))) - return(NULLBLK); - ip->c_node.i_addr[20-j] = swizzle16(nb); - ip->c_dirty = 1; - } - - /* - * fetch through the indirect blocks - */ - for(; j<=2; j++) { - bp = (bufptr)bread(dev, nb, 0); - /****** + register int i; + register bufptr bp; + register int j; + register blkno_t nb; + int sh; + int dev; + + if (getmode(ip) == F_BDEV) + return (bn); + + dev = ip->c_dev; + + /* + * blocks 0..17 are direct blocks + */ + if (bn < 18) { + nb = swizzle16(ip->c_node.i_addr[bn]); + if (nb == 0) { + if (rwflg || (nb = blk_alloc(dev)) == 0) + return (NULLBLK); + ip->c_node.i_addr[bn] = swizzle16(nb); + ip->c_dirty = 1; + } + return (nb); + } + + /* + * addresses 18 and 19 have single and double indirect blocks. + * the first step is to determine how many levels of indirection. + */ + bn -= 18; + sh = 0; + j = 2; + if (bn & 0xff00) { /* bn > 255 so double indirect */ + sh = 8; + bn -= 256; + j = 1; + } + + /* + * fetch the address from the inode + * Create the first indirect block if needed. + */ + ifnot(nb = ip->c_node.i_addr[20 - j]) { + if (rwflg || !(nb = blk_alloc(dev))) + return (NULLBLK); + ip->c_node.i_addr[20 - j] = swizzle16(nb); + ip->c_dirty = 1; + } + + /* + * fetch through the indirect blocks + */ + for (; j <= 2; j++) { + bp = (bufptr) bread(dev, nb, 0); + /****** if(bp->bf_error) { brelse(bp); return((blkno_t)0); } ******/ - i = (bn>>sh) & 0xff; - if ((swizzle16(nb) == ((blkno_t *)bp)[i])) - brelse(bp); - else - { - if(rwflg || !(nb = blk_alloc(dev))) { - brelse(bp); - return(NULLBLK); - } - ((blkno_t *)bp)[i] = swizzle16(nb); - bawrite(bp); - } - sh -= 8; - } - return(nb); + i = (bn >> sh) & 0xff; + if ((swizzle16(nb) == ((blkno_t *) bp)[i])) + brelse(bp); + else { + if (rwflg || !(nb = blk_alloc(dev))) { + brelse(bp); + return (NULLBLK); + } + ((blkno_t *) bp)[i] = swizzle16(nb); + bawrite(bp); + } + sh -= 8; + } + return (nb); } @@ -923,15 +890,16 @@ blkno_t bmap(inoptr ip, blkno_t bn, int rwflg) */ void validblk(int dev, blkno_t num) { - register fsptr devptr; + register fsptr devptr; - devptr = fs_tab + dev; + devptr = fs_tab + dev; - if (devptr->s_mounted == 0) - panic("validblk: not mounted"); + if (devptr->s_mounted == 0) + panic("validblk: not mounted"); - if (num < swizzle16(devptr->s_isize) || num >= swizzle16(devptr->s_fsize)) - panic("validblk: invalid blk"); + if (num < swizzle16(devptr->s_isize) + || num >= swizzle16(devptr->s_fsize)) + panic("validblk: invalid blk"); } @@ -940,32 +908,32 @@ void validblk(int dev, blkno_t num) */ inoptr getinode(int uindex) { - register int oftindex; - register inoptr inoindex; + register int oftindex; + register inoptr inoindex; - if (uindex < 0 || uindex >= UFTSIZE || udata.u_files[uindex] & 0x80 ) - { - udata.u_error = EBADF; - return (NULLINODE); - } + if (uindex < 0 || uindex >= UFTSIZE + || udata.u_files[uindex] & 0x80) { + udata.u_error = EBADF; + return (NULLINODE); + } - if ((oftindex = udata.u_files[uindex]) < 0 || oftindex >= OFTSIZE) - panic("Getinode: bad desc table"); + if ((oftindex = udata.u_files[uindex]) < 0 || oftindex >= OFTSIZE) + panic("Getinode: bad desc table"); - if ((inoindex = of_tab[oftindex].o_inode) < i_tab || - inoindex >= i_tab+ITABSIZE) - panic("Getinode: bad OFT"); + if ((inoindex = of_tab[oftindex].o_inode) < i_tab || + inoindex >= i_tab + ITABSIZE) + panic("Getinode: bad OFT"); - magic(inoindex); + magic(inoindex); - return(inoindex); + return (inoindex); } /* Super returns true if we are the superuser */ int super() { - return(udata.u_euid == 0); + return (udata.u_euid == 0); } @@ -974,18 +942,18 @@ int super() */ int getperm(inoptr ino) { - int mode; + int mode; - if (super()) - return(07); + if (super()) + return (07); - mode = swizzle16(ino->c_node.i_mode); - if (swizzle16(ino->c_node.i_uid) == udata.u_euid) - mode >>= 6; - else if (swizzle16(ino->c_node.i_gid) == udata.u_egid) - mode >>= 3; + mode = swizzle16(ino->c_node.i_mode); + if (swizzle16(ino->c_node.i_uid) == udata.u_euid) + mode >>= 6; + else if (swizzle16(ino->c_node.i_gid) == udata.u_egid) + mode >>= 3; - return(mode & 07); + return (mode & 07); } @@ -993,20 +961,20 @@ int getperm(inoptr ino) */ void setftime(inoptr ino, int flag) { - ino->c_dirty = 1; - - //if (flag & A_TIME) - // rdtime(&(ino->c_node.i_atime)); - //if (flag & M_TIME) - // rdtime(&(ino->c_node.i_mtime)); - //if (flag & C_TIME) - // rdtime(&(ino->c_node.i_ctime)); + ino->c_dirty = 1; + + //if (flag & A_TIME) + // rdtime(&(ino->c_node.i_atime)); + //if (flag & M_TIME) + // rdtime(&(ino->c_node.i_mtime)); + //if (flag & C_TIME) + // rdtime(&(ino->c_node.i_ctime)); } int getmode(inoptr ino) { - return( swizzle16(ino->c_node.i_mode) & F_MASK); + return (swizzle16(ino->c_node.i_mode) & F_MASK); } @@ -1014,32 +982,32 @@ int getmode(inoptr ino) */ int fmount(int dev, inoptr ino) { - char *buf; - register struct filesys *fp; - - /* Dev 0 blk 1 */ - fp = fs_tab + dev; - buf = bread(dev, 1, 0); - bcopy(buf, (char *)fp, sizeof(struct filesys)); - brelse((bufptr)buf); - - /* See if there really is a filesystem on the device */ - if (fp->s_mounted == SMOUNTED_WRONGENDIAN) - swizzling = 1; - if (swizzle16(fp->s_mounted) != SMOUNTED || - swizzle16(fp->s_isize) >= swizzle16(fp->s_fsize)) - return (-1); - - fp->s_mntpt = ino; - if (ino) - ++ino->c_refs; - - return (0); + char *buf; + register struct filesys *fp; + + /* Dev 0 blk 1 */ + fp = fs_tab + dev; + buf = bread(dev, 1, 0); + bcopy(buf, (char *) fp, sizeof(struct filesys)); + brelse((bufptr) buf); + + /* See if there really is a filesystem on the device */ + if (fp->s_mounted == SMOUNTED_WRONGENDIAN) + swizzling = 1; + if (swizzle16(fp->s_mounted) != SMOUNTED || + swizzle16(fp->s_isize) >= swizzle16(fp->s_fsize)) + return (-1); + + fp->s_mntpt = ino; + if (ino) + ++ino->c_refs; + + return (0); } void magic(inoptr ino) { - if (ino->c_magic != CMAGIC) - panic("Corrupt inode"); + if (ino->c_magic != CMAGIC) + panic("Corrupt inode"); } -- 2.34.1