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);
}
* 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);
}
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;
}
-
-
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;
}
UZI (Unix Z80 Implementation) Utilities: xfs1.c
***************************************************/
-/*LINTLIBRARY*/
+ /*LINTLIBRARY*/
+
#include <stdlib.h>
#include <stdint.h>
#include <stdio.h>
#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);
}
* 1.4.98 - Split xfs.c into parts for compilation with Hi-Tech C. HFB
*/
-/*LINTLIBRARY*/
+ /*LINTLIBRARY*/
#include <stdint.h>
#include <strings.h>
#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;
}
UZI (Unix Z80 Implementation) Utilities: xfs1a1.c
***************************************************/
-/*LINTLIBRARY*/
+ /*LINTLIBRARY*/
#include <stdint.h>
#include <strings.h>
#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);
}
* 25.2.96 Bug fix in i_deref() SN
*/
-/*LINTLIBRARY*/
+ /*LINTLIBRARY*/
#include <stdio.h>
#include <strings.h>
#include <stdint.h>
#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
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);
}
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);
}
* 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);
}
* 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);
}
* 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);
}
* 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 == '/');
}
* 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);
}
* 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);
}
int baddev(fsptr dev)
{
- return (swizzle16(dev->s_mounted) != SMOUNTED);
+ return (swizzle16(dev->s_mounted) != SMOUNTED);
}
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);
}
* 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);
+ }
}
* 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);
}
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;
+ }
}
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 */
}
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);
+ }
}
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)));
}
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);
}
*/
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);
}
*/
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");
}
*/
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);
}
*/
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);
}
*/
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);
}
*/
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");
}
public / FUZIX.git / commitdiff