#include "../h/param.h" #include "../h/systm.h" #include "../h/mount.h" #include "../h/dir.h" #include "../h/user.h" #include "../h/inode.h" #include "../h/ino.h" #include "../h/filsys.h" #include "../h/conf.h" #include "../h/buf.h" /* * Look up an inode by device,inumber. * If it is in core (in the inode structure), * honor the locking protocol. * If it is not in core, read it in from the * specified device. * If the inode is mounted on, perform * the indicated indirection. * In all cases, a pointer to a locked * inode structure is returned. * * printf warning: no inodes -- if the inode * structure is full * panic: no imt -- if the mounted file * system is not in the mount table. * "cannot happen" */ struct inode * iget(dev, ino) dev_t dev; ino_t ino; { register struct inode *ip; register struct mount *mp; register struct inode *oip; register struct buf *bp; register struct dinode *dp; loop: oip = NULL; for(ip = &inode[0]; ip < &inode[NINODE]; ip++) { if(ino == ip->i_number && dev == ip->i_dev) { if((ip->i_flag&ILOCK) != 0) { ip->i_flag |= IWANT; sleep((caddr_t)ip, PINOD); goto loop; } if((ip->i_flag&IMOUNT) != 0) { for(mp = &mount[0]; mp < &mount[NMOUNT]; mp++) if(mp->m_inodp == ip) { dev = mp->m_dev; ino = ROOTINO; goto loop; } panic("no imt"); } ip->i_count++; ip->i_flag |= ILOCK; return(ip); } if(oip==NULL && ip->i_count==0) oip = ip; } ip = oip; if(ip == NULL) { printf("Inode table overflow\n"); u.u_error = ENFILE; return(NULL); } ip->i_dev = dev; ip->i_number = ino; ip->i_flag = ILOCK; ip->i_count++; ip->i_un.i_lastr = 0; bp = bread(dev, itod(ino)); /* * Check I/O errors */ if((bp->b_flags&B_ERROR) != 0) { brelse(bp); iput(ip); return(NULL); } dp = bp->b_un.b_dino; dp += itoo(ino); iexpand(ip, dp); brelse(bp); return(ip); } iexpand(ip, dp) register struct inode *ip; register struct dinode *dp; { register char *p1; char *p2; int i; ip->i_mode = dp->di_mode; ip->i_nlink = dp->di_nlink; ip->i_uid = dp->di_uid; ip->i_gid = dp->di_gid; ip->i_size = dp->di_size; p1 = (char *)ip->i_un.i_addr; p2 = (char *)dp->di_addr; for(i=0; i<NADDR; i++) { *p1++ = *p2++; *p1++ = *p2++; *p1++ = *p2++; *p1++ = 0; } } /* * Decrement reference count of * an inode structure. * On the last reference, * write the inode out and if necessary, * truncate and deallocate the file. */ iput(ip) register struct inode *ip; { if(ip->i_count == 1) { ip->i_flag |= ILOCK; if(ip->i_nlink <= 0) { itrunc(ip); ip->i_mode = 0; ip->i_flag |= IUPD|ICHG; ifree(ip->i_dev, ip->i_number); } iupdat(ip, &time, &time); prele(ip); ip->i_flag = 0; ip->i_number = 0; } ip->i_count--; prele(ip); } /* * Check accessed and update flags on * an inode structure. * If either is on, update the inode * with the current time. */ iupdat(ip, ta, tm) register struct inode *ip; time_t *ta, *tm; { register struct buf *bp; struct dinode *dp; register char *p1; char *p2; int i; if((ip->i_flag&(IUPD|IACC|ICHG)) != 0) { if(getfs(ip->i_dev)->s_ronly) return; bp = bread(ip->i_dev, itod(ip->i_number)); if (bp->b_flags & B_ERROR) { brelse(bp); return; } dp = bp->b_un.b_dino; dp += itoo(ip->i_number); dp->di_mode = ip->i_mode; dp->di_nlink = ip->i_nlink; dp->di_uid = ip->i_uid; dp->di_gid = ip->i_gid; dp->di_size = ip->i_size; p1 = (char *)dp->di_addr; p2 = (char *)ip->i_un.i_addr; for(i=0; i<NADDR; i++) { *p1++ = *p2++; *p1++ = *p2++; *p1++ = *p2++; if(*p2++ != 0 && (ip->i_mode&IFMT)!=IFMPC && (ip->i_mode&IFMT)!=IFMPB) printf("iaddress > 2^24\n"); } if(ip->i_flag&IACC) dp->di_atime = *ta; if(ip->i_flag&IUPD) dp->di_mtime = *tm; if(ip->i_flag&ICHG) dp->di_ctime = time; ip->i_flag &= ~(IUPD|IACC|ICHG); bdwrite(bp); } } /* * Free all the disk blocks associated * with the specified inode structure. * The blocks of the file are removed * in reverse order. This FILO * algorithm will tend to maintain * a contiguous free list much longer * than FIFO. */ itrunc(ip) register struct inode *ip; { register i; dev_t dev; daddr_t bn; i = ip->i_mode & IFMT; if (i!=IFREG && i!=IFDIR) return; dev = ip->i_dev; for(i=NADDR-1; i>=0; i--) { bn = ip->i_un.i_addr[i]; if(bn == (daddr_t)0) continue; ip->i_un.i_addr[i] = (daddr_t)0; switch(i) { default: free(dev, bn); break; case NADDR-3: tloop(dev, bn, 0, 0); break; case NADDR-2: tloop(dev, bn, 1, 0); break; case NADDR-1: tloop(dev, bn, 1, 1); } } ip->i_size = 0; ip->i_flag |= ICHG|IUPD; } tloop(dev, bn, f1, f2) dev_t dev; daddr_t bn; { register i; register struct buf *bp; register daddr_t *bap; daddr_t nb; bp = NULL; for(i=NINDIR-1; i>=0; i--) { if(bp == NULL) { bp = bread(dev, bn); if (bp->b_flags & B_ERROR) { brelse(bp); return; } bap = bp->b_un.b_daddr; } nb = bap[i]; if(nb == (daddr_t)0) continue; if(f1) { brelse(bp); bp = NULL; tloop(dev, nb, f2, 0); } else free(dev, nb); } if(bp != NULL) brelse(bp); free(dev, bn); } /* * Make a new file. */ struct inode * maknode(mode) { register struct inode *ip; ip = ialloc(u.u_pdir->i_dev); if(ip == NULL) { iput(u.u_pdir); return(NULL); } ip->i_flag |= IACC|IUPD|ICHG; if((mode&IFMT) == 0) mode |= IFREG; ip->i_mode = mode & ~u.u_cmask; ip->i_nlink = 1; ip->i_uid = u.u_uid; ip->i_gid = u.u_gid; wdir(ip); return(ip); } /* * Write a directory entry with * parameters left as side effects * to a call to namei. */ wdir(ip) struct inode *ip; { u.u_dent.d_ino = ip->i_number; bcopy((caddr_t)u.u_dbuf, (caddr_t)u.u_dent.d_name, DIRSIZ); u.u_count = sizeof(struct direct); u.u_segflg = 1; u.u_base = (caddr_t)&u.u_dent; writei(u.u_pdir); iput(u.u_pdir); }