taglinefilesource code
inode15fs/block_dev.cint block_write(struct inode * inode, struct file * filp, char * buf, int count)
inode26fs/block_dev.cdev = inode->i_rdev;
inode59fs/block_dev.cint block_read(struct inode * inode, struct file * filp, char * buf, int count)
inode70fs/block_dev.cdev = inode->i_rdev;
inode50fs/exec.cwhile (file.f_op->write(inode,&file,(char *)(addr),(nr)) != (nr)) goto close_coredump
inode54fs/exec.cif (file.f_op->lseek(inode,&file,(offset),0) != (offset)) \
inode69fs/exec.cstruct inode * inode = NULL;
inode83fs/exec.cif (open_namei("core",O_CREAT | O_WRONLY | O_TRUNC,0600,&inode))
inode85fs/exec.cif (!S_ISREG(inode->i_mode))
inode87fs/exec.cif (!inode->i_op || !inode->i_op->default_file_ops)
inode92fs/exec.cfile.f_inode = inode;
inode95fs/exec.cfile.f_op = inode->i_op->default_file_ops;
inode97fs/exec.cif (file.f_op->open(inode,&file))
inode153fs/exec.cfile.f_op->release(inode,&file);
inode156fs/exec.ciput(inode);
inode169fs/exec.cstruct inode * inode;
inode178fs/exec.cinode = namei(library);
inode180fs/exec.cinode = NULL;
inode181fs/exec.cif (!inode)
inode183fs/exec.cif (!inode->i_sb || !S_ISREG(inode->i_mode) || !permission(inode,MAY_READ)) {
inode184fs/exec.ciput(inode);
inode187fs/exec.cif (!(bh = bread(inode->i_dev,bmap(inode,0),inode->i_sb->s_blocksize))) {
inode188fs/exec.ciput(inode);
inode191fs/exec.cif (!IS_RDONLY(inode)) {
inode192fs/exec.cinode->i_atime = CURRENT_TIME;
inode193fs/exec.cinode->i_dirt = 1;
inode199fs/exec.cinode->i_size < ex.a_text+ex.a_data+ex.a_syms+N_TXTOFF(ex)) {
inode200fs/exec.ciput(inode);
inode203fs/exec.ccurrent->libraries[libnum].library = inode;
inode354fs/exec.cstatic void read_omagic(struct inode *inode, int bytes)
inode362fs/exec.cif (inode->i_sb)
inode363fs/exec.cblock_size = inode->i_sb->s_blocksize;
inode365fs/exec.cif (!(blkno = bmap(inode, blk)))
inode367fs/exec.cif (!(bh = bread(inode->i_dev, blkno, block_size)))
inode380fs/exec.ciput(inode);
inode393fs/exec.cstruct inode * inode;
inode408fs/exec.cif (!(inode=namei(filename)))    /* get executables inode */
inode414fs/exec.cif (!S_ISREG(inode->i_mode)) {  /* must be regular file */
inode418fs/exec.cif (IS_NOEXEC(inode)) { /* FS mustn't be mounted noexec */
inode422fs/exec.cif (!inode->i_sb) {
inode426fs/exec.ci = inode->i_mode;
inode427fs/exec.cif (IS_NOSUID(inode) && (((i & S_ISUID) && inode->i_uid != current->
inode428fs/exec.ceuid) || ((i & S_ISGID) && inode->i_gid != current->egid)) &&
inode438fs/exec.ce_uid = (i & S_ISUID) ? inode->i_uid : current->euid;
inode439fs/exec.ce_gid = (i & S_ISGID) ? inode->i_gid : current->egid;
inode441fs/exec.cif (current->euid == inode->i_uid)
inode443fs/exec.celse if (in_group_p(inode->i_gid))
inode446fs/exec.c!((inode->i_mode & 0111) && suser())) {
inode450fs/exec.cif (!(bh = bread(inode->i_dev,bmap(inode,0),inode->i_sb->s_blocksize))) {
inode454fs/exec.cif (!IS_RDONLY(inode)) {
inode455fs/exec.cinode->i_atime = CURRENT_TIME;
inode456fs/exec.cinode->i_dirt = 1;
inode470fs/exec.ciput(inode);
inode523fs/exec.cif (!(inode=namei(interp))) { /* get executables inode */
inode535fs/exec.cinode->i_size < ex.a_text+ex.a_data+ex.a_syms+N_TXTOFF(ex)) {
inode570fs/exec.c!permission(inode,MAY_READ))
inode573fs/exec.ccurrent->executable = inode;
inode601fs/exec.cread_omagic(inode, ex.a_text+ex.a_data);
inode608fs/exec.ciput(inode);
inode157fs/ext/bitmap.cvoid ext_free_inode(struct inode * inode)
inode161fs/ext/bitmap.cif (!inode)
inode163fs/ext/bitmap.cif (!inode->i_dev) {
inode164fs/ext/bitmap.cmemset(inode,0,sizeof(*inode));
inode167fs/ext/bitmap.cif (inode->i_count>1) {
inode168fs/ext/bitmap.cprintk("free_inode: inode has count=%d\n",inode->i_count);
inode171fs/ext/bitmap.cif (inode->i_nlink) {
inode172fs/ext/bitmap.cprintk("free_inode: inode has nlink=%d\n",inode->i_nlink);
inode175fs/ext/bitmap.cif (!inode->i_sb) {
inode179fs/ext/bitmap.cif (inode->i_ino < 1 || inode->i_ino > inode->i_sb->s_ninodes) {
inode183fs/ext/bitmap.cif (!(bh=inode->i_sb->s_imap[inode->i_ino>>13])) {
inode187fs/ext/bitmap.cif (clear_bit(inode->i_ino&8191,bh->b_data))
inode190fs/ext/bitmap.cmemset(inode,0,sizeof(*inode));
inode193fs/ext/bitmap.cstruct inode * ext_new_inode(int dev)
inode195fs/ext/bitmap.cstruct inode * inode;
inode199fs/ext/bitmap.cif (!(inode=get_empty_inode()))
inode201fs/ext/bitmap.cif (!(inode->i_sb = get_super(dev))) {
inode203fs/ext/bitmap.ciput(inode);
inode206fs/ext/bitmap.cinode->i_flags = inode->i_sb->s_flags;
inode209fs/ext/bitmap.cif (bh=inode->i_sb->s_imap[i])
inode212fs/ext/bitmap.cif (!bh || j >= 8192 || j+i*8192 > inode->i_sb->s_ninodes) {
inode213fs/ext/bitmap.ciput(inode);
inode218fs/ext/bitmap.ciput(inode);
inode222fs/ext/bitmap.cinode->i_count = 1;
inode223fs/ext/bitmap.cinode->i_nlink = 1;
inode224fs/ext/bitmap.cinode->i_dev = dev;
inode225fs/ext/bitmap.cinode->i_uid = current->euid;
inode226fs/ext/bitmap.cinode->i_gid = current->egid;
inode227fs/ext/bitmap.cinode->i_dirt = 1;
inode228fs/ext/bitmap.cinode->i_ino = j + i*8192;
inode229fs/ext/bitmap.cinode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
inode230fs/ext/bitmap.cinode->i_op = NULL;
inode232fs/ext/bitmap.cprintk("ext_new_inode : allocating inode %d\n", inode->i_ino);
inode234fs/ext/bitmap.creturn inode;
inode23fs/ext/blkdev.cstatic int blkdev_open(struct inode * inode, struct file * filp)
inode27fs/ext/blkdev.ci = MAJOR(inode->i_rdev);
inode31fs/ext/blkdev.creturn filp->f_op->open(inode,filp);
inode23fs/ext/chrdev.cstatic int chrdev_open(struct inode * inode, struct file * filp)
inode27fs/ext/chrdev.ci = MAJOR(inode->i_rdev);
inode31fs/ext/chrdev.creturn filp->f_op->open(inode,filp);
inode22fs/ext/dir.cstatic int ext_readdir(struct inode *, struct file *, struct dirent *, int);
inode55fs/ext/dir.cstatic int ext_readdir(struct inode * inode, struct file * filp,
inode63fs/ext/dir.cif (!inode || !S_ISDIR(inode->i_mode))
inode67fs/ext/dir.cwhile (filp->f_pos < inode->i_size) {
inode69fs/ext/dir.cblock = ext_bmap(inode,(filp->f_pos)>>BLOCK_SIZE_BITS);
inode70fs/ext/dir.cif (!block || !(bh = bread(inode->i_dev, block, BLOCK_SIZE))) {
inode75fs/ext/dir.cwhile (offset < 1024 && filp->f_pos < inode->i_size) {
inode78fs/ext/dir.cif (de->inode) {
inode85fs/ext/dir.cput_fs_long(de->inode,&dirent->d_ino);
inode33fs/ext/file.cstatic int ext_file_read(struct inode *, struct file *, char *, int);
inode34fs/ext/file.cstatic int ext_file_write(struct inode *, struct file *, char *, int);
inode76fs/ext/file.cstatic int ext_file_read(struct inode * inode, struct file * filp, char * buf, int count)
inode83fs/ext/file.cif (!inode) {
inode87fs/ext/file.cif (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode))) {
inode88fs/ext/file.cprintk("ext_file_read: mode = %07o\n",inode->i_mode);
inode91fs/ext/file.cif (filp->f_pos > inode->i_size)
inode94fs/ext/file.cleft = inode->i_size - filp->f_pos;
inode107fs/ext/file.cif (nr = ext_bmap(inode,block++)) {
inode108fs/ext/file.c*bhb = getblk(inode->i_dev, nr, BLOCK_SIZE);
inode153fs/ext/file.cif (!IS_RDONLY(inode)) {
inode154fs/ext/file.cinode->i_atime = CURRENT_TIME;
inode155fs/ext/file.cinode->i_dirt = 1;
inode160fs/ext/file.cstatic int ext_file_write(struct inode * inode, struct file * filp, char * buf, int count)
inode167fs/ext/file.cif (!inode) {
inode171fs/ext/file.cif (!S_ISREG(inode->i_mode)) {
inode172fs/ext/file.cprintk("ext_file_write: mode = %07o\n",inode->i_mode);
inode180fs/ext/file.cpos = inode->i_size;
inode185fs/ext/file.cif (!(block = ext_create_block(inode,pos/BLOCK_SIZE))) {
inode194fs/ext/file.cbh = getblk(inode->i_dev, block, BLOCK_SIZE);
inode196fs/ext/file.cbh = bread(inode->i_dev, block, BLOCK_SIZE);
inode204fs/ext/file.cif (pos > inode->i_size) {
inode205fs/ext/file.cinode->i_size = pos;
inode206fs/ext/file.cinode->i_dirt = 1;
inode215fs/ext/file.cinode->i_mtime = CURRENT_TIME;
inode216fs/ext/file.cinode->i_ctime = CURRENT_TIME;
inode218fs/ext/file.cinode->i_dirt = 1;
inode183fs/ext/freelists.cvoid ext_free_inode(struct inode * inode)
inode189fs/ext/freelists.cif (!inode)
inode191fs/ext/freelists.cif (!inode->i_dev) {
inode192fs/ext/freelists.cmemset(inode,0,sizeof(*inode));
inode195fs/ext/freelists.cif (inode->i_count>1) {
inode196fs/ext/freelists.cprintk("free_inode: inode has count=%d\n",inode->i_count);
inode199fs/ext/freelists.cif (inode->i_nlink) {
inode200fs/ext/freelists.cprintk("free_inode: inode has nlink=%d\n",inode->i_nlink);
inode203fs/ext/freelists.cif (!inode->i_sb) {
inode207fs/ext/freelists.clock_super (inode->i_sb);
inode208fs/ext/freelists.cif (inode->i_ino < 1 || inode->i_ino > inode->i_sb->u.ext_sb.s_ninodes) {
inode210fs/ext/freelists.cfree_super (inode->i_sb);
inode213fs/ext/freelists.cif (inode->i_sb->u.ext_sb.s_imap[1])
inode214fs/ext/freelists.cefi = ((struct ext_free_inode *) inode->i_sb->u.ext_sb.s_imap[1]->b_data) +
inode215fs/ext/freelists.c(((unsigned long) inode->i_sb->u.ext_sb.s_imap[0])-1)%EXT_INODES_PER_BLOCK;
inode216fs/ext/freelists.cif (!inode->i_sb->u.ext_sb.s_imap[1] || efi->count == 14) {
inode218fs/ext/freelists.cprintk("ext_free_inode: inode full, skipping to %d\n", inode->i_ino);
inode220fs/ext/freelists.cif (inode->i_sb->u.ext_sb.s_imap[1])
inode221fs/ext/freelists.cbrelse (inode->i_sb->u.ext_sb.s_imap[1]);
inode222fs/ext/freelists.cblock = 2 + (inode->i_ino - 1) / EXT_INODES_PER_BLOCK;
inode223fs/ext/freelists.cif (!(bh = bread(inode->i_dev, block, inode->i_sb->s_blocksize)))
inode226fs/ext/freelists.c(inode->i_ino - 1) % EXT_INODES_PER_BLOCK;
inode227fs/ext/freelists.cefi->next = (unsigned long) inode->i_sb->u.ext_sb.s_imap[0];
inode229fs/ext/freelists.cinode->i_sb->u.ext_sb.s_imap[0] = (struct buffer_head *) inode->i_ino;
inode230fs/ext/freelists.cinode->i_sb->u.ext_sb.s_imap[1] = bh;
inode232fs/ext/freelists.cefi->free[efi->count++] = inode->i_ino;
inode234fs/ext/freelists.cinode->i_sb->u.ext_sb.s_imap[2] = (struct buffer_head *) (((unsigned long) inode->i_sb->u.ext_sb.s_imap[2]) + 1);
inode235fs/ext/freelists.cinode->i_sb->s_dirt = 1;
inode236fs/ext/freelists.cinode->i_sb->u.ext_sb.s_imap[1]->b_dirt = 1;
inode237fs/ext/freelists.cfree_super (inode->i_sb);
inode238fs/ext/freelists.cmemset(inode,0,sizeof(*inode));
inode241fs/ext/freelists.cstruct inode * ext_new_inode(int dev)
inode243fs/ext/freelists.cstruct inode * inode;
inode248fs/ext/freelists.cif (!(inode=get_empty_inode()))
inode250fs/ext/freelists.cif (!(inode->i_sb = get_super(dev))) {
inode252fs/ext/freelists.ciput(inode);
inode255fs/ext/freelists.cinode->i_flags = inode->i_sb->s_flags;
inode256fs/ext/freelists.cif (!inode->i_sb->u.ext_sb.s_imap[1])
inode258fs/ext/freelists.clock_super (inode->i_sb);
inode259fs/ext/freelists.cefi = ((struct ext_free_inode *) inode->i_sb->u.ext_sb.s_imap[1]->b_data) +
inode260fs/ext/freelists.c(((unsigned long) inode->i_sb->u.ext_sb.s_imap[0])-1)%EXT_INODES_PER_BLOCK;
inode263fs/ext/freelists.cinode->i_sb->u.ext_sb.s_imap[1]->b_dirt = 1;
inode268fs/ext/freelists.cj = (unsigned long) inode->i_sb->u.ext_sb.s_imap[0];
inode269fs/ext/freelists.cif (efi->next > inode->i_sb->u.ext_sb.s_ninodes) {
inode273fs/ext/freelists.cinode->i_sb->u.ext_sb.s_imap[0] = (struct buffer_head *) efi->next;
inode275fs/ext/freelists.cbrelse (inode->i_sb->u.ext_sb.s_imap[1]);
inode276fs/ext/freelists.cif (!inode->i_sb->u.ext_sb.s_imap[0]) {
inode277fs/ext/freelists.cinode->i_sb->u.ext_sb.s_imap[1] = NULL;
inode279fs/ext/freelists.cif (!(inode->i_sb->u.ext_sb.s_imap[1] = bread (dev, block, inode->i_sb->s_blocksize)))
inode283fs/ext/freelists.cinode->i_sb->u.ext_sb.s_imap[2] = (struct buffer_head *) (((unsigned long) inode->i_sb->u.ext_sb.s_imap[2]) - 1);
inode284fs/ext/freelists.cinode->i_sb->s_dirt = 1;
inode285fs/ext/freelists.cinode->i_count = 1;
inode286fs/ext/freelists.cinode->i_nlink = 1;
inode287fs/ext/freelists.cinode->i_dev = dev;
inode288fs/ext/freelists.cinode->i_uid = current->euid;
inode289fs/ext/freelists.cinode->i_gid = current->egid;
inode290fs/ext/freelists.cinode->i_dirt = 1;
inode291fs/ext/freelists.cinode->i_ino = j;
inode292fs/ext/freelists.cinode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
inode293fs/ext/freelists.cinode->i_op = NULL;
inode295fs/ext/freelists.cprintk("ext_new_inode : allocating inode %d\n", inode->i_ino);
inode297fs/ext/freelists.cfree_super (inode->i_sb);
inode298fs/ext/freelists.creturn inode;
inode25fs/ext/inode.cvoid ext_put_inode(struct inode *inode)
inode27fs/ext/inode.cinode->i_size = 0;
inode28fs/ext/inode.cext_truncate(inode);
inode29fs/ext/inode.cext_free_inode(inode);
inode212fs/ext/inode.cstatic int _ext_bmap(struct inode * inode,int block,int create)
inode226fs/ext/inode.cif (create && !inode->i_data[block])
inode227fs/ext/inode.cif (inode->i_data[block]=ext_new_block(inode->i_dev)) {
inode228fs/ext/inode.cinode->i_ctime=CURRENT_TIME;
inode229fs/ext/inode.cinode->i_dirt=1;
inode231fs/ext/inode.creturn inode->i_data[block];
inode235fs/ext/inode.cif (create && !inode->i_data[9])
inode236fs/ext/inode.cif (inode->i_data[9]=ext_new_block(inode->i_dev)) {
inode237fs/ext/inode.cinode->i_dirt=1;
inode238fs/ext/inode.cinode->i_ctime=CURRENT_TIME;
inode240fs/ext/inode.cif (!inode->i_data[9])
inode242fs/ext/inode.cif (!(bh = bread(inode->i_dev, inode->i_data[9], BLOCK_SIZE)))
inode246fs/ext/inode.cif (i=ext_new_block(inode->i_dev)) {
inode255fs/ext/inode.cif (create && !inode->i_data[10])
inode256fs/ext/inode.cif (inode->i_data[10]=ext_new_block(inode->i_dev)) {
inode257fs/ext/inode.cinode->i_dirt=1;
inode258fs/ext/inode.cinode->i_ctime=CURRENT_TIME;
inode260fs/ext/inode.cif (!inode->i_data[10])
inode262fs/ext/inode.cif (!(bh=bread(inode->i_dev, inode->i_data[10], BLOCK_SIZE)))
inode266fs/ext/inode.cif (i=ext_new_block(inode->i_dev)) {
inode273fs/ext/inode.cif (!(bh=bread(inode->i_dev, i, BLOCK_SIZE)))
inode277fs/ext/inode.cif (i=ext_new_block(inode->i_dev)) {
inode284fs/ext/inode.cif (create && !inode->i_data[11])
inode285fs/ext/inode.cif (inode->i_data[11] = ext_new_block(inode->i_dev)) {
inode286fs/ext/inode.cinode->i_dirt = 1;
inode287fs/ext/inode.cinode->i_ctime = CURRENT_TIME;
inode289fs/ext/inode.cif (!inode->i_data[11])
inode291fs/ext/inode.cif (!(bh = bread(inode->i_dev, inode->i_data[11], BLOCK_SIZE)))
inode295fs/ext/inode.cif (i = ext_new_block(inode->i_dev)) {
inode302fs/ext/inode.cif (!(bh = bread(inode->i_dev, i, BLOCK_SIZE)))
inode306fs/ext/inode.cif (i = ext_new_block(inode->i_dev)) {
inode313fs/ext/inode.cif (!(bh = bread(inode->i_dev, i, BLOCK_SIZE)))
inode317fs/ext/inode.cif (i = ext_new_block(inode->i_dev)) {
inode328fs/ext/inode.cint ext_bmap(struct inode * inode,int block)
inode330fs/ext/inode.creturn _ext_bmap(inode,block,0);
inode333fs/ext/inode.cint ext_create_block(struct inode * inode, int block)
inode335fs/ext/inode.creturn _ext_bmap(inode,block,1);
inode338fs/ext/inode.cvoid ext_read_inode(struct inode * inode)
inode345fs/ext/inode.cblock = 2 + inode->i_sb->u.ext_sb.s_imap_blocks + inode->i_sb->u.ext_sb.s_zmap_blocks +
inode346fs/ext/inode.c(inode->i_ino-1)/EXT_INODES_PER_BLOCK;
inode349fs/ext/inode.cblock = 2 + (inode->i_ino-1)/EXT_INODES_PER_BLOCK;
inode351fs/ext/inode.cif (!(bh=bread(inode->i_dev, block, BLOCK_SIZE)))
inode354fs/ext/inode.c(inode->i_ino-1)%EXT_INODES_PER_BLOCK;
inode355fs/ext/inode.cinode->i_mode = raw_inode->i_mode;
inode356fs/ext/inode.cinode->i_uid = raw_inode->i_uid;
inode357fs/ext/inode.cinode->i_gid = raw_inode->i_gid;
inode358fs/ext/inode.cinode->i_nlink = raw_inode->i_nlinks;
inode359fs/ext/inode.cinode->i_size = raw_inode->i_size;
inode360fs/ext/inode.cinode->i_mtime = inode->i_atime = inode->i_ctime = raw_inode->i_time;
inode361fs/ext/inode.cif (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
inode362fs/ext/inode.cinode->i_rdev = raw_inode->i_zone[0];
inode364fs/ext/inode.cinode->i_data[block] = raw_inode->i_zone[block];
inode366fs/ext/inode.cinode->i_op = NULL;
inode367fs/ext/inode.cif (S_ISREG(inode->i_mode))
inode368fs/ext/inode.cinode->i_op = &ext_file_inode_operations;
inode369fs/ext/inode.celse if (S_ISDIR(inode->i_mode))
inode370fs/ext/inode.cinode->i_op = &ext_dir_inode_operations;
inode371fs/ext/inode.celse if (S_ISLNK(inode->i_mode))
inode372fs/ext/inode.cinode->i_op = &ext_symlink_inode_operations;
inode373fs/ext/inode.celse if (S_ISCHR(inode->i_mode))
inode374fs/ext/inode.cinode->i_op = &ext_chrdev_inode_operations;
inode375fs/ext/inode.celse if (S_ISBLK(inode->i_mode))
inode376fs/ext/inode.cinode->i_op = &ext_blkdev_inode_operations;
inode377fs/ext/inode.celse if (S_ISFIFO(inode->i_mode)) {
inode378fs/ext/inode.cinode->i_op = &ext_fifo_inode_operations;
inode379fs/ext/inode.cinode->i_size = 0;
inode380fs/ext/inode.cinode->i_pipe = 1;
inode381fs/ext/inode.cPIPE_HEAD(*inode) = PIPE_TAIL(*inode) = 0;
inode382fs/ext/inode.cPIPE_READERS(*inode) = PIPE_WRITERS(*inode) = 0;
inode386fs/ext/inode.cvoid ext_write_inode(struct inode * inode)
inode393fs/ext/inode.cblock = 2 + inode->i_sb->u.ext_sb.s_imap_blocks + inode->i_sb->u.ext_sb.s_zmap_blocks +
inode394fs/ext/inode.c(inode->i_ino-1)/EXT_INODES_PER_BLOCK;
inode397fs/ext/inode.cblock = 2 + (inode->i_ino-1)/EXT_INODES_PER_BLOCK;
inode399fs/ext/inode.cif (!(bh=bread(inode->i_dev, block, BLOCK_SIZE)))
inode402fs/ext/inode.c(inode->i_ino-1)%EXT_INODES_PER_BLOCK;
inode403fs/ext/inode.craw_inode->i_mode = inode->i_mode;
inode404fs/ext/inode.craw_inode->i_uid = inode->i_uid;
inode405fs/ext/inode.craw_inode->i_gid = inode->i_gid;
inode406fs/ext/inode.craw_inode->i_nlinks = inode->i_nlink;
inode407fs/ext/inode.craw_inode->i_size = inode->i_size;
inode408fs/ext/inode.craw_inode->i_time = inode->i_mtime;
inode409fs/ext/inode.cif (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
inode410fs/ext/inode.craw_inode->i_zone[0] = inode->i_rdev;
inode412fs/ext/inode.craw_inode->i_zone[block] = inode->i_data[block];
inode414fs/ext/inode.cinode->i_dirt=0;
inode62fs/ext/namei.cif (!de || !de->inode || len > EXT_NAME_LEN)
inode91fs/ext/namei.cstatic struct buffer_head * ext_find_entry(struct inode * dir,
inode157fs/ext/namei.cint ext_lookup(struct inode * dir,const char * name, int len,
inode158fs/ext/namei.cstruct inode ** result)
inode175fs/ext/namei.cino = de->inode;
inode195fs/ext/namei.cstatic struct buffer_head * ext_add_entry(struct inode * dir,
inode249fs/ext/namei.cde->inode = 0;
inode272fs/ext/namei.cde->inode=0;
inode279fs/ext/namei.cif (!de->inode && de->rec_len >= rec_len) {
inode287fs/ext/namei.cde1->inode = 0;
inode307fs/ext/namei.cint ext_create(struct inode * dir,const char * name, int len, int mode,
inode308fs/ext/namei.cstruct inode ** result)
inode310fs/ext/namei.cstruct inode * inode;
inode317fs/ext/namei.cinode = ext_new_inode(dir->i_dev);
inode318fs/ext/namei.cif (!inode) {
inode322fs/ext/namei.cinode->i_op = &ext_file_inode_operations;
inode323fs/ext/namei.cinode->i_mode = mode;
inode324fs/ext/namei.cinode->i_dirt = 1;
inode327fs/ext/namei.cinode->i_nlink--;
inode328fs/ext/namei.cinode->i_dirt = 1;
inode329fs/ext/namei.ciput(inode);
inode333fs/ext/namei.cde->inode = inode->i_ino;
inode337fs/ext/namei.c*result = inode;
inode341fs/ext/namei.cint ext_mknod(struct inode * dir, const char * name, int len, int mode, int rdev)
inode343fs/ext/namei.cstruct inode * inode;
inode355fs/ext/namei.cinode = ext_new_inode(dir->i_dev);
inode356fs/ext/namei.cif (!inode) {
inode360fs/ext/namei.cinode->i_uid = current->euid;
inode361fs/ext/namei.cinode->i_mode = mode;
inode362fs/ext/namei.cinode->i_op = NULL;
inode363fs/ext/namei.cif (S_ISREG(inode->i_mode))
inode364fs/ext/namei.cinode->i_op = &ext_file_inode_operations;
inode365fs/ext/namei.celse if (S_ISDIR(inode->i_mode))
inode366fs/ext/namei.cinode->i_op = &ext_dir_inode_operations;
inode367fs/ext/namei.celse if (S_ISLNK(inode->i_mode))
inode368fs/ext/namei.cinode->i_op = &ext_symlink_inode_operations;
inode369fs/ext/namei.celse if (S_ISCHR(inode->i_mode))
inode370fs/ext/namei.cinode->i_op = &ext_chrdev_inode_operations;
inode371fs/ext/namei.celse if (S_ISBLK(inode->i_mode))
inode372fs/ext/namei.cinode->i_op = &ext_blkdev_inode_operations;
inode373fs/ext/namei.celse if (S_ISFIFO(inode->i_mode)) {
inode374fs/ext/namei.cinode->i_op = &ext_fifo_inode_operations;
inode375fs/ext/namei.cinode->i_size = 0;
inode376fs/ext/namei.cinode->i_pipe = 1;
inode377fs/ext/namei.cPIPE_HEAD(*inode) = PIPE_TAIL(*inode) = 0;
inode378fs/ext/namei.cPIPE_READERS(*inode) = PIPE_WRITERS(*inode) = 0;
inode381fs/ext/namei.cinode->i_rdev = rdev;
inode382fs/ext/namei.cinode->i_mtime = inode->i_atime = CURRENT_TIME;
inode383fs/ext/namei.cinode->i_dirt = 1;
inode386fs/ext/namei.cinode->i_nlink--;
inode387fs/ext/namei.cinode->i_dirt = 1;
inode388fs/ext/namei.ciput(inode);
inode392fs/ext/namei.cde->inode = inode->i_ino;
inode396fs/ext/namei.ciput(inode);
inode400fs/ext/namei.cint ext_mkdir(struct inode * dir, const char * name, int len, int mode)
inode402fs/ext/namei.cstruct inode * inode;
inode412fs/ext/namei.cinode = ext_new_inode(dir->i_dev);
inode413fs/ext/namei.cif (!inode) {
inode417fs/ext/namei.cinode->i_op = &ext_dir_inode_operations;
inode418fs/ext/namei.cinode->i_size = 2 * 16; /* Each entry is coded on 16 bytes for "." and ".."
inode423fs/ext/namei.cinode->i_mtime = inode->i_atime = CURRENT_TIME;
inode424fs/ext/namei.cif (!(inode->i_data[0] = ext_new_block(inode->i_dev))) {
inode426fs/ext/namei.cinode->i_nlink--;
inode427fs/ext/namei.cinode->i_dirt = 1;
inode428fs/ext/namei.ciput(inode);
inode431fs/ext/namei.cinode->i_dirt = 1;
inode432fs/ext/namei.cif (!(dir_block = bread(inode->i_dev, inode->i_data[0], BLOCK_SIZE))) {
inode434fs/ext/namei.cinode->i_nlink--;
inode435fs/ext/namei.cinode->i_dirt = 1;
inode436fs/ext/namei.ciput(inode);
inode440fs/ext/namei.cde->inode=inode->i_ino;
inode446fs/ext/namei.cde->inode = dir->i_ino;
inode450fs/ext/namei.cinode->i_nlink = 2;
inode453fs/ext/namei.cinode->i_mode = I_DIRECTORY | (mode & 0777 & ~current->umask);
inode454fs/ext/namei.cinode->i_dirt = 1;
inode458fs/ext/namei.cinode->i_nlink=0;
inode459fs/ext/namei.ciput(inode);
inode462fs/ext/namei.cde->inode = inode->i_ino;
inode467fs/ext/namei.ciput(inode);
inode475fs/ext/namei.cstatic int empty_dir(struct inode * inode)
inode484fs/ext/namei.cif (inode->i_size < 2 * 12 || !inode->i_data[0] ||
inode485fs/ext/namei.c!(bh=bread(inode->i_dev, inode->i_data[0], BLOCK_SIZE))) {
inode486fs/ext/namei.cprintk("warning - bad directory on dev %04x\n",inode->i_dev);
inode491fs/ext/namei.cif (de->inode != inode->i_ino || !de1->inode || 
inode493fs/ext/namei.cprintk("warning - bad directory on dev %04x\n",inode->i_dev);
inode499fs/ext/namei.cwhile (offset < inode->i_size ) {
inode502fs/ext/namei.cblock = ext_bmap(inode, offset >> BLOCK_SIZE_BITS);
inode507fs/ext/namei.cif (!(bh=bread(inode->i_dev, block, BLOCK_SIZE)))
inode511fs/ext/namei.cif (de->inode) {
inode525fs/ext/namei.cif (! nde->inode)
inode527fs/ext/namei.cif (! pde->inode)
inode531fs/ext/namei.cint ext_rmdir(struct inode * dir, const char * name, int len)
inode534fs/ext/namei.cstruct inode * inode;
inode538fs/ext/namei.cinode = NULL;
inode544fs/ext/namei.cif (!(inode = iget(dir->i_dev, de->inode)))
inode547fs/ext/namei.cinode->i_uid != current->euid)
inode549fs/ext/namei.cif (inode->i_dev != dir->i_dev)
inode551fs/ext/namei.cif (inode == dir)  /* we may not delete ".", but "../dir" is ok */
inode553fs/ext/namei.cif (!S_ISDIR(inode->i_mode)) {
inode557fs/ext/namei.cif (!empty_dir(inode)) {
inode561fs/ext/namei.cif (inode->i_count > 1) {
inode565fs/ext/namei.cif (inode->i_nlink != 2)
inode566fs/ext/namei.cprintk("empty directory has nlink!=2 (%d)\n",inode->i_nlink);
inode567fs/ext/namei.cde->inode = 0;
inode571fs/ext/namei.cinode->i_nlink=0;
inode572fs/ext/namei.cinode->i_dirt=1;
inode579fs/ext/namei.ciput(inode);
inode584fs/ext/namei.cint ext_unlink(struct inode * dir, const char * name, int len)
inode587fs/ext/namei.cstruct inode * inode;
inode592fs/ext/namei.cinode = NULL;
inode596fs/ext/namei.cif (!(inode = iget(dir->i_dev, de->inode)))
inode600fs/ext/namei.ccurrent->euid != inode->i_uid &&
inode603fs/ext/namei.cif (S_ISDIR(inode->i_mode))
inode605fs/ext/namei.cif (!inode->i_nlink) {
inode607fs/ext/namei.cinode->i_dev,inode->i_ino,inode->i_nlink);
inode608fs/ext/namei.cinode->i_nlink=1;
inode610fs/ext/namei.cde->inode = 0;
inode614fs/ext/namei.cinode->i_nlink--;
inode615fs/ext/namei.cinode->i_dirt = 1;
inode616fs/ext/namei.cinode->i_ctime = CURRENT_TIME;
inode620fs/ext/namei.ciput(inode);
inode625fs/ext/namei.cint ext_symlink(struct inode * dir, const char * name, int len, const char * symname)
inode628fs/ext/namei.cstruct inode * inode = NULL;
inode633fs/ext/namei.cif (!(inode = ext_new_inode(dir->i_dev))) {
inode637fs/ext/namei.cinode->i_mode = S_IFLNK | 0777;
inode638fs/ext/namei.cinode->i_op = &ext_symlink_inode_operations;
inode639fs/ext/namei.cif (!(inode->i_data[0] = ext_new_block(inode->i_dev))) {
inode641fs/ext/namei.cinode->i_nlink--;
inode642fs/ext/namei.cinode->i_dirt = 1;
inode643fs/ext/namei.ciput(inode);
inode646fs/ext/namei.cinode->i_dirt = 1;
inode647fs/ext/namei.cif (!(name_block = bread(inode->i_dev, inode->i_data[0], BLOCK_SIZE))) {
inode649fs/ext/namei.cinode->i_nlink--;
inode650fs/ext/namei.cinode->i_dirt = 1;
inode651fs/ext/namei.ciput(inode);
inode660fs/ext/namei.cinode->i_size = i;
inode661fs/ext/namei.cinode->i_dirt = 1;
inode664fs/ext/namei.cinode->i_nlink--;
inode665fs/ext/namei.cinode->i_dirt = 1;
inode666fs/ext/namei.ciput(inode);
inode673fs/ext/namei.cinode->i_nlink--;
inode674fs/ext/namei.cinode->i_dirt = 1;
inode675fs/ext/namei.ciput(inode);
inode679fs/ext/namei.cde->inode = inode->i_ino;
inode683fs/ext/namei.ciput(inode);
inode687fs/ext/namei.cint ext_link(struct inode * oldinode, struct inode * dir, const char * name, int len)
inode710fs/ext/namei.cde->inode = oldinode->i_ino;
inode721fs/ext/namei.cstatic int subdir(struct inode * new, struct inode * old)
inode751fs/ext/namei.c((struct ext_dir_entry *) buffer)->rec_len))->inode
inode769fs/ext/namei.cstatic int do_ext_rename(struct inode * old_dir, const char * old_name, int old_len,
inode770fs/ext/namei.cstruct inode * new_dir, const char * new_name, int new_len)
inode772fs/ext/namei.cstruct inode * old_inode, * new_inode;
inode793fs/ext/namei.cold_inode = iget(old_dir->i_dev, old_de->inode);
inode802fs/ext/namei.cnew_inode = iget(new_dir->i_dev, new_de->inode);
inode840fs/ext/namei.cif (new_inode && (new_de->inode != new_inode->i_ino))
inode842fs/ext/namei.cif (new_de->inode && !new_inode)
inode844fs/ext/namei.cif (old_de->inode != old_inode->i_ino)
inode847fs/ext/namei.cold_de->inode = 0;
inode849fs/ext/namei.cnew_de->inode = old_inode->i_ino;
inode886fs/ext/namei.cint ext_rename(struct inode * old_dir, const char * old_name, int old_len,
inode887fs/ext/namei.cstruct inode * new_dir, const char * new_name, int new_len)
inode23fs/ext/symlink.cstatic int ext_readlink(struct inode *, char *, int);
inode24fs/ext/symlink.cstatic struct inode * ext_follow_link(struct inode *, struct inode *);
inode46fs/ext/symlink.cstatic struct inode * ext_follow_link(struct inode * dir, struct inode * inode)
inode55fs/ext/symlink.cif (!inode) {
inode59fs/ext/symlink.cif (!S_ISLNK(inode->i_mode)) {
inode61fs/ext/symlink.creturn inode;
inode64fs/ext/symlink.cif ((current->link_count > 5) || !inode->i_data[0] ||
inode65fs/ext/symlink.c!(bh = bread(inode->i_dev, inode->i_data[0], BLOCK_SIZE))) {
inode67fs/ext/symlink.ciput(inode);
inode70fs/ext/symlink.ciput(inode);
inode73fs/ext/symlink.cinode = _namei(bh->b_data,dir,1);
inode77fs/ext/symlink.creturn inode;
inode80fs/ext/symlink.cstatic int ext_readlink(struct inode * inode, char * buffer, int buflen)
inode86fs/ext/symlink.cif (!S_ISLNK(inode->i_mode)) {
inode87fs/ext/symlink.ciput(inode);
inode92fs/ext/symlink.cif (inode->i_data[0])
inode93fs/ext/symlink.cbh = bread(inode->i_dev, inode->i_data[0], BLOCK_SIZE);
inode96fs/ext/symlink.ciput(inode);
inode33fs/ext/truncate.cstatic int trunc_direct(struct inode * inode)
inode37fs/ext/truncate.c#define DIRECT_BLOCK ((inode->i_size + 1023) >> 10)
inode43fs/ext/truncate.cif (!inode->i_data[i])
inode46fs/ext/truncate.cif (ext_free_block(inode->i_dev,inode->i_data[i]))
inode47fs/ext/truncate.cinode->i_data[i] = 0;
inode52fs/ext/truncate.cstatic int trunc_indirect(struct inode * inode, int offset, unsigned long * p)
inode61fs/ext/truncate.cbh = bread(inode->i_dev, *p, BLOCK_SIZE);
inode74fs/ext/truncate.cif (ext_free_block(inode->i_dev,*ind))
inode84fs/ext/truncate.cif (ext_free_block(inode->i_dev,*p))
inode90fs/ext/truncate.cstatic int trunc_dindirect(struct inode * inode, int offset, unsigned long * p)
inode99fs/ext/truncate.cbh = bread(inode->i_dev, *p, BLOCK_SIZE);
inode111fs/ext/truncate.cresult |= trunc_indirect(inode,offset+(i<<8),dind);
inode120fs/ext/truncate.cif (ext_free_block(inode->i_dev,*p))
inode126fs/ext/truncate.cstatic int trunc_tindirect(struct inode * inode)
inode134fs/ext/truncate.cif (inode->i_data[11])
inode135fs/ext/truncate.cbh = bread(inode->i_dev, inode->i_data[11], BLOCK_SIZE);
inode147fs/ext/truncate.cresult |= trunc_dindirect(inode,9+256+256*256+(i<<16),tind);
inode156fs/ext/truncate.cif (ext_free_block(inode->i_dev,inode->i_data[11]))
inode157fs/ext/truncate.cinode->i_data[11] = 0;
inode162fs/ext/truncate.cvoid ext_truncate(struct inode * inode)
inode166fs/ext/truncate.cif (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
inode167fs/ext/truncate.cS_ISLNK(inode->i_mode)))
inode172fs/ext/truncate.cflag = trunc_direct(inode);
inode173fs/ext/truncate.cflag |= trunc_indirect(inode,9,(unsigned long *)&inode->i_data[9]);
inode174fs/ext/truncate.cflag |= trunc_dindirect(inode,9+256,(unsigned long *)&inode->i_data[10]);
inode175fs/ext/truncate.cflag |= trunc_tindirect(inode);
inode181fs/ext/truncate.cinode->i_mtime = inode->i_ctime = CURRENT_TIME;
inode182fs/ext/truncate.cinode->i_dirt = 1;
inode190fs/ext/truncate.cvoid ext_release(struct inode * inode, struct file * filp)
inode16fs/fifo.cstatic int fifo_open(struct inode * inode,struct file * filp)
inode30fs/fifo.cPIPE_READERS(*inode)++;
inode32fs/fifo.cwhile (!PIPE_WRITERS(*inode)) {
inode33fs/fifo.cif (PIPE_HEAD(*inode) != PIPE_TAIL(*inode))
inode39fs/fifo.cinterruptible_sleep_on(&PIPE_READ_WAIT(*inode));
inode42fs/fifo.cPIPE_READERS(*inode)--;
inode51fs/fifo.cif ((filp->f_flags & O_NONBLOCK) && !PIPE_READERS(*inode)) {
inode56fs/fifo.cPIPE_WRITERS(*inode)++;
inode57fs/fifo.cwhile (!PIPE_READERS(*inode)) {
inode62fs/fifo.cinterruptible_sleep_on(&PIPE_WRITE_WAIT(*inode));
inode65fs/fifo.cPIPE_WRITERS(*inode)--;
inode76fs/fifo.cPIPE_WRITERS(*inode) += 1;
inode77fs/fifo.cPIPE_READERS(*inode) += 1;
inode83fs/fifo.cif (PIPE_WRITERS(*inode))
inode84fs/fifo.cwake_up(&PIPE_READ_WAIT(*inode));
inode85fs/fifo.cif (PIPE_READERS(*inode))
inode86fs/fifo.cwake_up(&PIPE_WRITE_WAIT(*inode));
inode87fs/fifo.cif (retval || inode->i_size)
inode90fs/fifo.cif (inode->i_size) {
inode96fs/fifo.cinode->i_size = page;
inode15fs/inode.cstruct inode inode_table[NR_INODE]={{0,},};
inode17fs/inode.cstatic inline void wait_on_inode(struct inode * inode)
inode20fs/inode.cwhile (inode->i_lock)
inode21fs/inode.csleep_on(&inode->i_wait);
inode25fs/inode.cstatic inline void lock_inode(struct inode * inode)
inode28fs/inode.cwhile (inode->i_lock)
inode29fs/inode.csleep_on(&inode->i_wait);
inode30fs/inode.cinode->i_lock=1;
inode34fs/inode.cstatic inline void unlock_inode(struct inode * inode)
inode36fs/inode.cinode->i_lock=0;
inode37fs/inode.cwake_up(&inode->i_wait);
inode40fs/inode.cstatic void write_inode(struct inode * inode)
inode42fs/inode.cif (!inode->i_dirt)
inode44fs/inode.cinode->i_dirt = 0;
inode45fs/inode.clock_inode(inode);
inode46fs/inode.cif (inode->i_dev && inode->i_sb &&
inode47fs/inode.cinode->i_sb->s_op && inode->i_sb->s_op->write_inode)
inode48fs/inode.cinode->i_sb->s_op->write_inode(inode);
inode49fs/inode.cunlock_inode(inode);
inode52fs/inode.cstatic void read_inode(struct inode * inode)
inode54fs/inode.clock_inode(inode);
inode55fs/inode.cif (inode->i_sb && inode->i_sb->s_op && inode->i_sb->s_op->read_inode)
inode56fs/inode.cinode->i_sb->s_op->read_inode(inode);
inode57fs/inode.cunlock_inode(inode);
inode70fs/inode.cint bmap(struct inode * inode, int block)
inode72fs/inode.cif (inode->i_op && inode->i_op->bmap)
inode73fs/inode.creturn inode->i_op->bmap(inode,block);
inode80fs/inode.cstruct inode * inode;
inode82fs/inode.cinode = 0+inode_table;
inode83fs/inode.cfor(i=0 ; i<NR_INODE ; i++,inode++) {
inode84fs/inode.cwait_on_inode(inode);
inode85fs/inode.cif (inode->i_dev == dev) {
inode86fs/inode.cif (inode->i_count) {
inode90fs/inode.cinode->i_dev = inode->i_dirt = 0;
inode98fs/inode.cstruct inode * inode;
inode100fs/inode.cinode = 0+inode_table;
inode101fs/inode.cfor(i=0 ; i<NR_INODE ; i++,inode++) {
inode102fs/inode.cwait_on_inode(inode);
inode103fs/inode.cif (inode->i_dirt)
inode104fs/inode.cwrite_inode(inode);
inode108fs/inode.cvoid iput(struct inode * inode)
inode110fs/inode.cif (!inode)
inode112fs/inode.cwait_on_inode(inode);
inode113fs/inode.cif (!inode->i_count) {
inode115fs/inode.cprintk("device %04x, inode %d, mode=%07o\n",inode->i_rdev,
inode116fs/inode.cinode->i_ino,inode->i_mode);
inode119fs/inode.cif (inode->i_pipe) {
inode120fs/inode.cwake_up(&inode->i_wait);
inode121fs/inode.cwake_up(&inode->i_wait2);
inode124fs/inode.cif (inode->i_count>1) {
inode125fs/inode.cinode->i_count--;
inode128fs/inode.cif (inode->i_pipe) {
inode129fs/inode.cfree_page(inode->i_size);
inode130fs/inode.cinode->i_size = 0;
inode132fs/inode.cif (!inode->i_dev) {
inode133fs/inode.cinode->i_count--;
inode136fs/inode.cif (!inode->i_nlink) {
inode137fs/inode.cif (inode->i_sb && inode->i_sb->s_op && inode->i_sb->s_op->put_inode) {
inode138fs/inode.cinode->i_sb->s_op->put_inode(inode);
inode142fs/inode.cif (inode->i_dirt) {
inode143fs/inode.cwrite_inode(inode);  /* we can sleep - so do again */
inode144fs/inode.cwait_on_inode(inode);
inode147fs/inode.cinode->i_count--;
inode151fs/inode.cstruct inode * get_empty_inode(void)
inode153fs/inode.cstruct inode * inode;
inode154fs/inode.cstatic struct inode * last_inode = inode_table;
inode158fs/inode.cinode = NULL;
inode163fs/inode.cinode = last_inode;
inode164fs/inode.cif (!inode->i_dirt && !inode->i_lock)
inode168fs/inode.cif (!inode) {
inode174fs/inode.cwait_on_inode(inode);
inode175fs/inode.cwhile (inode->i_dirt) {
inode176fs/inode.cwrite_inode(inode);
inode177fs/inode.cwait_on_inode(inode);
inode179fs/inode.c} while (inode->i_count);
inode180fs/inode.cmemset(inode,0,sizeof(*inode));
inode181fs/inode.cinode->i_count = 1;
inode182fs/inode.creturn inode;
inode185fs/inode.cstruct inode * get_pipe_inode(void)
inode187fs/inode.cstruct inode * inode;
inode189fs/inode.cif (!(inode = get_empty_inode()))
inode191fs/inode.cif (!(inode->i_size = get_free_page(GFP_USER))) {
inode192fs/inode.cinode->i_count = 0;
inode195fs/inode.cinode->i_count = 2;  /* sum of readers/writers */
inode196fs/inode.cPIPE_HEAD(*inode) = PIPE_TAIL(*inode) = 0;
inode197fs/inode.cPIPE_READERS(*inode) = PIPE_WRITERS(*inode) = 1;
inode198fs/inode.cinode->i_pipe = 1;
inode199fs/inode.creturn inode;
inode202fs/inode.cstruct inode * iget(int dev,int nr)
inode204fs/inode.cstruct inode * inode, * empty;
inode209fs/inode.cinode = inode_table;
inode210fs/inode.cwhile (inode < NR_INODE+inode_table) {
inode211fs/inode.cif (inode->i_dev != dev || inode->i_ino != nr) {
inode212fs/inode.cinode++;
inode215fs/inode.cwait_on_inode(inode);
inode216fs/inode.cif (inode->i_dev != dev || inode->i_ino != nr) {
inode217fs/inode.cinode = inode_table;
inode220fs/inode.cinode->i_count++;
inode221fs/inode.cif (inode->i_mount) {
inode225fs/inode.cif (super_block[i].s_covered==inode)
inode231fs/inode.creturn inode;
inode233fs/inode.ciput(inode);
inode234fs/inode.cif (!(inode = super_block[i].s_mounted))
inode237fs/inode.cinode->i_count++;
inode238fs/inode.cwait_on_inode(inode);
inode243fs/inode.creturn inode;
inode247fs/inode.cinode = empty;
inode248fs/inode.cif (!(inode->i_sb = get_super(dev))) {
inode250fs/inode.ciput(inode);
inode253fs/inode.cinode->i_dev = dev;
inode254fs/inode.cinode->i_ino = nr;
inode255fs/inode.cinode->i_flags = inode->i_sb->s_flags;
inode256fs/inode.cread_inode(inode);
inode257fs/inode.creturn inode;
inode145fs/minix/bitmap.cvoid minix_free_inode(struct inode * inode)
inode149fs/minix/bitmap.cif (!inode)
inode151fs/minix/bitmap.cif (!inode->i_dev) {
inode152fs/minix/bitmap.cmemset(inode,0,sizeof(*inode));
inode155fs/minix/bitmap.cif (inode->i_count>1) {
inode156fs/minix/bitmap.cprintk("free_inode: inode has count=%d\n",inode->i_count);
inode159fs/minix/bitmap.cif (inode->i_nlink) {
inode160fs/minix/bitmap.cprintk("free_inode: inode has nlink=%d\n",inode->i_nlink);
inode163fs/minix/bitmap.cif (!inode->i_sb) {
inode167fs/minix/bitmap.cif (inode->i_ino < 1 || inode->i_ino > inode->i_sb->u.minix_sb.s_ninodes) {
inode171fs/minix/bitmap.cif (!(bh=inode->i_sb->u.minix_sb.s_imap[inode->i_ino>>13])) {
inode175fs/minix/bitmap.cif (clear_bit(inode->i_ino&8191,bh->b_data))
inode178fs/minix/bitmap.cmemset(inode,0,sizeof(*inode));
inode181fs/minix/bitmap.cstruct inode * minix_new_inode(int dev)
inode183fs/minix/bitmap.cstruct inode * inode;
inode187fs/minix/bitmap.cif (!(inode=get_empty_inode()))
inode189fs/minix/bitmap.cif (!(inode->i_sb = get_super(dev))) {
inode191fs/minix/bitmap.ciput(inode);
inode194fs/minix/bitmap.cinode->i_flags = inode->i_sb->s_flags;
inode197fs/minix/bitmap.cif (bh=inode->i_sb->u.minix_sb.s_imap[i])
inode200fs/minix/bitmap.cif (!bh || j >= 8192 || j+i*8192 > inode->i_sb->u.minix_sb.s_ninodes) {
inode201fs/minix/bitmap.ciput(inode);
inode206fs/minix/bitmap.ciput(inode);
inode210fs/minix/bitmap.cinode->i_count = 1;
inode211fs/minix/bitmap.cinode->i_nlink = 1;
inode212fs/minix/bitmap.cinode->i_dev = dev;
inode213fs/minix/bitmap.cinode->i_uid = current->euid;
inode214fs/minix/bitmap.cinode->i_gid = current->egid;
inode215fs/minix/bitmap.cinode->i_dirt = 1;
inode216fs/minix/bitmap.cinode->i_ino = j + i*8192;
inode217fs/minix/bitmap.cinode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
inode218fs/minix/bitmap.cinode->i_op = NULL;
inode219fs/minix/bitmap.creturn inode;
inode17fs/minix/blkdev.cstatic int blkdev_open(struct inode * inode, struct file * filp)
inode21fs/minix/blkdev.ci = MAJOR(inode->i_rdev);
inode25fs/minix/blkdev.creturn filp->f_op->open(inode,filp);
inode17fs/minix/chrdev.cstatic int chrdev_open(struct inode * inode, struct file * filp)
inode21fs/minix/chrdev.ci = MAJOR(inode->i_rdev);
inode25fs/minix/chrdev.creturn filp->f_op->open(inode,filp);
inode16fs/minix/dir.cstatic int minix_readdir(struct inode *, struct file *, struct dirent *, int);
inode49fs/minix/dir.cstatic int minix_readdir(struct inode * inode, struct file * filp,
inode57fs/minix/dir.cif (!inode || !S_ISDIR(inode->i_mode))
inode61fs/minix/dir.cwhile (filp->f_pos < inode->i_size) {
inode63fs/minix/dir.cblock = minix_bmap(inode,(filp->f_pos)>>BLOCK_SIZE_BITS);
inode64fs/minix/dir.cif (!block || !(bh = bread(inode->i_dev,block,BLOCK_SIZE))) {
inode69fs/minix/dir.cwhile (offset < 1024 && filp->f_pos < inode->i_size) {
inode72fs/minix/dir.cif (de->inode) {
inode79fs/minix/dir.cput_fs_long(de->inode,&dirent->d_ino);
inode27fs/minix/file.cint minix_file_read(struct inode *, struct file *, char *, int);
inode28fs/minix/file.cstatic int minix_file_write(struct inode *, struct file *, char *, int);
inode76fs/minix/file.cint minix_file_read(struct inode * inode, struct file * filp, char * buf, int count)
inode83fs/minix/file.cif (!inode) {
inode87fs/minix/file.cif (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode))) {
inode88fs/minix/file.cprintk("minix_file_read: mode = %07o\n",inode->i_mode);
inode91fs/minix/file.cif (filp->f_pos > inode->i_size)
inode94fs/minix/file.cleft = inode->i_size - filp->f_pos;
inode107fs/minix/file.cif (nr = minix_bmap(inode,block++)) {
inode108fs/minix/file.c*bhb = getblk(inode->i_dev,nr,BLOCK_SIZE);
inode153fs/minix/file.cif (!IS_RDONLY(inode)) {
inode154fs/minix/file.cinode->i_atime = CURRENT_TIME;
inode155fs/minix/file.cinode->i_dirt = 1;
inode160fs/minix/file.cstatic int minix_file_write(struct inode * inode, struct file * filp, char * buf, int count)
inode167fs/minix/file.cif (!inode) {
inode171fs/minix/file.cif (!S_ISREG(inode->i_mode)) {
inode172fs/minix/file.cprintk("minix_file_write: mode = %07o\n",inode->i_mode);
inode180fs/minix/file.cpos = inode->i_size;
inode185fs/minix/file.cif (!(block = minix_create_block(inode,pos/BLOCK_SIZE))) {
inode194fs/minix/file.cbh = getblk(inode->i_dev, block, BLOCK_SIZE);
inode196fs/minix/file.cbh = bread(inode->i_dev,block, BLOCK_SIZE);
inode204fs/minix/file.cif (pos > inode->i_size) {
inode205fs/minix/file.cinode->i_size = pos;
inode206fs/minix/file.cinode->i_dirt = 1;
inode215fs/minix/file.cinode->i_mtime = CURRENT_TIME;
inode216fs/minix/file.cinode->i_ctime = CURRENT_TIME;
inode218fs/minix/file.cinode->i_dirt = 1;
inode19fs/minix/inode.cvoid minix_put_inode(struct inode *inode)
inode21fs/minix/inode.cinode->i_size = 0;
inode22fs/minix/inode.cminix_truncate(inode);
inode23fs/minix/inode.cminix_free_inode(inode);
inode133fs/minix/inode.cstatic int _minix_bmap(struct inode * inode,int block,int create)
inode147fs/minix/inode.cif (create && !inode->i_data[block])
inode148fs/minix/inode.cif (inode->i_data[block]=minix_new_block(inode->i_dev)) {
inode149fs/minix/inode.cinode->i_ctime=CURRENT_TIME;
inode150fs/minix/inode.cinode->i_dirt=1;
inode152fs/minix/inode.creturn inode->i_data[block];
inode156fs/minix/inode.cif (create && !inode->i_data[7])
inode157fs/minix/inode.cif (inode->i_data[7]=minix_new_block(inode->i_dev)) {
inode158fs/minix/inode.cinode->i_dirt=1;
inode159fs/minix/inode.cinode->i_ctime=CURRENT_TIME;
inode161fs/minix/inode.cif (!inode->i_data[7])
inode163fs/minix/inode.cif (!(bh = bread(inode->i_dev,inode->i_data[7],BLOCK_SIZE)))
inode167fs/minix/inode.cif (i=minix_new_block(inode->i_dev)) {
inode175fs/minix/inode.cif (create && !inode->i_data[8])
inode176fs/minix/inode.cif (inode->i_data[8]=minix_new_block(inode->i_dev)) {
inode177fs/minix/inode.cinode->i_dirt=1;
inode178fs/minix/inode.cinode->i_ctime=CURRENT_TIME;
inode180fs/minix/inode.cif (!inode->i_data[8])
inode182fs/minix/inode.cif (!(bh=bread(inode->i_dev,inode->i_data[8], BLOCK_SIZE)))
inode186fs/minix/inode.cif (i=minix_new_block(inode->i_dev)) {
inode193fs/minix/inode.cif (!(bh=bread(inode->i_dev,i,BLOCK_SIZE)))
inode197fs/minix/inode.cif (i=minix_new_block(inode->i_dev)) {
inode205fs/minix/inode.cint minix_bmap(struct inode * inode,int block)
inode207fs/minix/inode.creturn _minix_bmap(inode,block,0);
inode210fs/minix/inode.cint minix_create_block(struct inode * inode, int block)
inode212fs/minix/inode.creturn _minix_bmap(inode,block,1);
inode215fs/minix/inode.cvoid minix_read_inode(struct inode * inode)
inode221fs/minix/inode.cblock = 2 + inode->i_sb->u.minix_sb.s_imap_blocks + inode->i_sb->u.minix_sb.s_zmap_blocks +
inode222fs/minix/inode.c(inode->i_ino-1)/MINIX_INODES_PER_BLOCK;
inode223fs/minix/inode.cif (!(bh=bread(inode->i_dev,block, BLOCK_SIZE)))
inode226fs/minix/inode.c(inode->i_ino-1)%MINIX_INODES_PER_BLOCK;
inode227fs/minix/inode.cinode->i_mode = raw_inode->i_mode;
inode228fs/minix/inode.cinode->i_uid = raw_inode->i_uid;
inode229fs/minix/inode.cinode->i_gid = raw_inode->i_gid;
inode230fs/minix/inode.cinode->i_nlink = raw_inode->i_nlinks;
inode231fs/minix/inode.cinode->i_size = raw_inode->i_size;
inode232fs/minix/inode.cinode->i_mtime = inode->i_atime = inode->i_ctime = raw_inode->i_time;
inode233fs/minix/inode.cif (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
inode234fs/minix/inode.cinode->i_rdev = raw_inode->i_zone[0];
inode236fs/minix/inode.cinode->i_data[block] = raw_inode->i_zone[block];
inode238fs/minix/inode.cinode->i_op = NULL;
inode239fs/minix/inode.cif (S_ISREG(inode->i_mode))
inode240fs/minix/inode.cinode->i_op = &minix_file_inode_operations;
inode241fs/minix/inode.celse if (S_ISDIR(inode->i_mode))
inode242fs/minix/inode.cinode->i_op = &minix_dir_inode_operations;
inode243fs/minix/inode.celse if (S_ISLNK(inode->i_mode))
inode244fs/minix/inode.cinode->i_op = &minix_symlink_inode_operations;
inode245fs/minix/inode.celse if (S_ISCHR(inode->i_mode))
inode246fs/minix/inode.cinode->i_op = &minix_chrdev_inode_operations;
inode247fs/minix/inode.celse if (S_ISBLK(inode->i_mode))
inode248fs/minix/inode.cinode->i_op = &minix_blkdev_inode_operations;
inode249fs/minix/inode.celse if (S_ISFIFO(inode->i_mode)) {
inode250fs/minix/inode.cinode->i_op = &minix_fifo_inode_operations;
inode251fs/minix/inode.cinode->i_size = 0;
inode252fs/minix/inode.cinode->i_pipe = 1;
inode253fs/minix/inode.cPIPE_HEAD(*inode) = PIPE_TAIL(*inode) = 0;
inode254fs/minix/inode.cPIPE_READERS(*inode) = PIPE_WRITERS(*inode) = 0;
inode258fs/minix/inode.cvoid minix_write_inode(struct inode * inode)
inode264fs/minix/inode.cblock = 2 + inode->i_sb->u.minix_sb.s_imap_blocks + inode->i_sb->u.minix_sb.s_zmap_blocks +
inode265fs/minix/inode.c(inode->i_ino-1)/MINIX_INODES_PER_BLOCK;
inode266fs/minix/inode.cif (!(bh=bread(inode->i_dev, block, BLOCK_SIZE)))
inode269fs/minix/inode.c(inode->i_ino-1)%MINIX_INODES_PER_BLOCK;
inode270fs/minix/inode.craw_inode->i_mode = inode->i_mode;
inode271fs/minix/inode.craw_inode->i_uid = inode->i_uid;
inode272fs/minix/inode.craw_inode->i_gid = inode->i_gid;
inode273fs/minix/inode.craw_inode->i_nlinks = inode->i_nlink;
inode274fs/minix/inode.craw_inode->i_size = inode->i_size;
inode275fs/minix/inode.craw_inode->i_time = inode->i_mtime;
inode276fs/minix/inode.cif (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
inode277fs/minix/inode.craw_inode->i_zone[0] = inode->i_rdev;
inode279fs/minix/inode.craw_inode->i_zone[block] = inode->i_data[block];
inode281fs/minix/inode.cinode->i_dirt=0;
inode36fs/minix/namei.cif (!de || !de->inode || len > MINIX_NAME_LEN)
inode60fs/minix/namei.cstatic struct buffer_head * minix_find_entry(struct inode * dir,
inode107fs/minix/namei.cint minix_lookup(struct inode * dir,const char * name, int len,
inode108fs/minix/namei.cstruct inode ** result)
inode125fs/minix/namei.cino = de->inode;
inode145fs/minix/namei.cstatic struct buffer_head * minix_add_entry(struct inode * dir,
inode184fs/minix/namei.cde->inode=0;
inode189fs/minix/namei.cif (!de->inode) {
inode204fs/minix/namei.cint minix_create(struct inode * dir,const char * name, int len, int mode,
inode205fs/minix/namei.cstruct inode ** result)
inode207fs/minix/namei.cstruct inode * inode;
inode214fs/minix/namei.cinode = minix_new_inode(dir->i_dev);
inode215fs/minix/namei.cif (!inode) {
inode219fs/minix/namei.cinode->i_op = &minix_file_inode_operations;
inode220fs/minix/namei.cinode->i_mode = mode;
inode221fs/minix/namei.cinode->i_dirt = 1;
inode224fs/minix/namei.cinode->i_nlink--;
inode225fs/minix/namei.cinode->i_dirt = 1;
inode226fs/minix/namei.ciput(inode);
inode230fs/minix/namei.cde->inode = inode->i_ino;
inode234fs/minix/namei.c*result = inode;
inode238fs/minix/namei.cint minix_mknod(struct inode * dir, const char * name, int len, int mode, int rdev)
inode240fs/minix/namei.cstruct inode * inode;
inode252fs/minix/namei.cinode = minix_new_inode(dir->i_dev);
inode253fs/minix/namei.cif (!inode) {
inode257fs/minix/namei.cinode->i_uid = current->euid;
inode258fs/minix/namei.cinode->i_mode = mode;
inode259fs/minix/namei.cinode->i_op = NULL;
inode260fs/minix/namei.cif (S_ISREG(inode->i_mode))
inode261fs/minix/namei.cinode->i_op = &minix_file_inode_operations;
inode262fs/minix/namei.celse if (S_ISDIR(inode->i_mode))
inode263fs/minix/namei.cinode->i_op = &minix_dir_inode_operations;
inode264fs/minix/namei.celse if (S_ISLNK(inode->i_mode))
inode265fs/minix/namei.cinode->i_op = &minix_symlink_inode_operations;
inode266fs/minix/namei.celse if (S_ISCHR(inode->i_mode))
inode267fs/minix/namei.cinode->i_op = &minix_chrdev_inode_operations;
inode268fs/minix/namei.celse if (S_ISBLK(inode->i_mode))
inode269fs/minix/namei.cinode->i_op = &minix_blkdev_inode_operations;
inode270fs/minix/namei.celse if (S_ISFIFO(inode->i_mode)) {
inode271fs/minix/namei.cinode->i_op = &minix_fifo_inode_operations;
inode272fs/minix/namei.cinode->i_size = 0;
inode273fs/minix/namei.cinode->i_pipe = 1;
inode274fs/minix/namei.cPIPE_HEAD(*inode) = PIPE_TAIL(*inode) = 0;
inode275fs/minix/namei.cPIPE_READERS(*inode) = PIPE_WRITERS(*inode) = 0;
inode278fs/minix/namei.cinode->i_rdev = rdev;
inode279fs/minix/namei.cinode->i_mtime = inode->i_atime = CURRENT_TIME;
inode280fs/minix/namei.cinode->i_dirt = 1;
inode283fs/minix/namei.cinode->i_nlink--;
inode284fs/minix/namei.cinode->i_dirt = 1;
inode285fs/minix/namei.ciput(inode);
inode289fs/minix/namei.cde->inode = inode->i_ino;
inode293fs/minix/namei.ciput(inode);
inode297fs/minix/namei.cint minix_mkdir(struct inode * dir, const char * name, int len, int mode)
inode299fs/minix/namei.cstruct inode * inode;
inode309fs/minix/namei.cinode = minix_new_inode(dir->i_dev);
inode310fs/minix/namei.cif (!inode) {
inode314fs/minix/namei.cinode->i_op = &minix_dir_inode_operations;
inode315fs/minix/namei.cinode->i_size = 2 * sizeof (struct minix_dir_entry);
inode316fs/minix/namei.cinode->i_mtime = inode->i_atime = CURRENT_TIME;
inode317fs/minix/namei.cif (!(inode->i_data[0] = minix_new_block(inode->i_dev))) {
inode319fs/minix/namei.cinode->i_nlink--;
inode320fs/minix/namei.cinode->i_dirt = 1;
inode321fs/minix/namei.ciput(inode);
inode324fs/minix/namei.cinode->i_dirt = 1;
inode325fs/minix/namei.cif (!(dir_block = bread(inode->i_dev, inode->i_data[0], BLOCK_SIZE))) {
inode327fs/minix/namei.cinode->i_nlink--;
inode328fs/minix/namei.cinode->i_dirt = 1;
inode329fs/minix/namei.ciput(inode);
inode333fs/minix/namei.cde->inode=inode->i_ino;
inode336fs/minix/namei.cde->inode = dir->i_ino;
inode338fs/minix/namei.cinode->i_nlink = 2;
inode341fs/minix/namei.cinode->i_mode = I_DIRECTORY | (mode & 0777 & ~current->umask);
inode342fs/minix/namei.cinode->i_dirt = 1;
inode346fs/minix/namei.cinode->i_nlink=0;
inode347fs/minix/namei.ciput(inode);
inode350fs/minix/namei.cde->inode = inode->i_ino;
inode355fs/minix/namei.ciput(inode);
inode363fs/minix/namei.cstatic int empty_dir(struct inode * inode)
inode370fs/minix/namei.clen = inode->i_size / sizeof (struct minix_dir_entry);
inode371fs/minix/namei.cif (len<2 || !inode->i_data[0] ||
inode372fs/minix/namei.c!(bh=bread(inode->i_dev, inode->i_data[0], BLOCK_SIZE))) {
inode373fs/minix/namei.cprintk("warning - bad directory on dev %04x\n",inode->i_dev);
inode377fs/minix/namei.cif (de[0].inode != inode->i_ino || !de[1].inode || 
inode379fs/minix/namei.cprintk("warning - bad directory on dev %04x\n",inode->i_dev);
inode387fs/minix/namei.cblock = minix_bmap(inode,nr/MINIX_DIR_ENTRIES_PER_BLOCK);
inode392fs/minix/namei.cif (!(bh=bread(inode->i_dev, block, BLOCK_SIZE)))
inode396fs/minix/namei.cif (de->inode) {
inode407fs/minix/namei.cint minix_rmdir(struct inode * dir, const char * name, int len)
inode410fs/minix/namei.cstruct inode * inode;
inode414fs/minix/namei.cinode = NULL;
inode420fs/minix/namei.cif (!(inode = iget(dir->i_dev, de->inode)))
inode423fs/minix/namei.cinode->i_uid != current->euid)
inode425fs/minix/namei.cif (inode->i_dev != dir->i_dev)
inode427fs/minix/namei.cif (inode == dir)  /* we may not delete ".", but "../dir" is ok */
inode429fs/minix/namei.cif (!S_ISDIR(inode->i_mode)) {
inode433fs/minix/namei.cif (!empty_dir(inode)) {
inode437fs/minix/namei.cif (inode->i_count > 1) {
inode441fs/minix/namei.cif (inode->i_nlink != 2)
inode442fs/minix/namei.cprintk("empty directory has nlink!=2 (%d)\n",inode->i_nlink);
inode443fs/minix/namei.cde->inode = 0;
inode445fs/minix/namei.cinode->i_nlink=0;
inode446fs/minix/namei.cinode->i_dirt=1;
inode453fs/minix/namei.ciput(inode);
inode458fs/minix/namei.cint minix_unlink(struct inode * dir, const char * name, int len)
inode461fs/minix/namei.cstruct inode * inode;
inode466fs/minix/namei.cinode = NULL;
inode470fs/minix/namei.cif (!(inode = iget(dir->i_dev, de->inode)))
inode474fs/minix/namei.ccurrent->euid != inode->i_uid &&
inode477fs/minix/namei.cif (S_ISDIR(inode->i_mode))
inode479fs/minix/namei.cif (!inode->i_nlink) {
inode481fs/minix/namei.cinode->i_dev,inode->i_ino,inode->i_nlink);
inode482fs/minix/namei.cinode->i_nlink=1;
inode484fs/minix/namei.cde->inode = 0;
inode486fs/minix/namei.cinode->i_nlink--;
inode487fs/minix/namei.cinode->i_dirt = 1;
inode488fs/minix/namei.cinode->i_ctime = CURRENT_TIME;
inode492fs/minix/namei.ciput(inode);
inode497fs/minix/namei.cint minix_symlink(struct inode * dir, const char * name, int len, const char * symname)
inode500fs/minix/namei.cstruct inode * inode = NULL;
inode505fs/minix/namei.cif (!(inode = minix_new_inode(dir->i_dev))) {
inode509fs/minix/namei.cinode->i_mode = S_IFLNK | 0777;
inode510fs/minix/namei.cinode->i_op = &minix_symlink_inode_operations;
inode511fs/minix/namei.cif (!(inode->i_data[0] = minix_new_block(inode->i_dev))) {
inode513fs/minix/namei.cinode->i_nlink--;
inode514fs/minix/namei.cinode->i_dirt = 1;
inode515fs/minix/namei.ciput(inode);
inode518fs/minix/namei.cinode->i_dirt = 1;
inode519fs/minix/namei.cif (!(name_block = bread(inode->i_dev, inode->i_data[0], BLOCK_SIZE))) {
inode521fs/minix/namei.cinode->i_nlink--;
inode522fs/minix/namei.cinode->i_dirt = 1;
inode523fs/minix/namei.ciput(inode);
inode532fs/minix/namei.cinode->i_size = i;
inode533fs/minix/namei.cinode->i_dirt = 1;
inode536fs/minix/namei.cinode->i_nlink--;
inode537fs/minix/namei.cinode->i_dirt = 1;
inode538fs/minix/namei.ciput(inode);
inode545fs/minix/namei.cinode->i_nlink--;
inode546fs/minix/namei.cinode->i_dirt = 1;
inode547fs/minix/namei.ciput(inode);
inode551fs/minix/namei.cde->inode = inode->i_ino;
inode555fs/minix/namei.ciput(inode);
inode559fs/minix/namei.cint minix_link(struct inode * oldinode, struct inode * dir, const char * name, int len)
inode582fs/minix/namei.cde->inode = oldinode->i_ino;
inode593fs/minix/namei.cstatic int subdir(struct inode * new, struct inode * old)
inode622fs/minix/namei.c(((struct minix_dir_entry *) (buffer))[1].inode)
inode637fs/minix/namei.cstatic int do_minix_rename(struct inode * old_dir, const char * old_name, int old_len,
inode638fs/minix/namei.cstruct inode * new_dir, const char * new_name, int new_len)
inode640fs/minix/namei.cstruct inode * old_inode, * new_inode;
inode661fs/minix/namei.cold_inode = iget(old_dir->i_dev, old_de->inode);
inode670fs/minix/namei.cnew_inode = iget(new_dir->i_dev, new_de->inode);
inode708fs/minix/namei.cif (new_inode && (new_de->inode != new_inode->i_ino))
inode710fs/minix/namei.cif (new_de->inode && !new_inode)
inode712fs/minix/namei.cif (old_de->inode != old_inode->i_ino)
inode715fs/minix/namei.cold_de->inode = 0;
inode716fs/minix/namei.cnew_de->inode = old_inode->i_ino;
inode752fs/minix/namei.cint minix_rename(struct inode * old_dir, const char * old_name, int old_len,
inode753fs/minix/namei.cstruct inode * new_dir, const char * new_name, int new_len)
inode17fs/minix/symlink.cstatic int minix_readlink(struct inode *, char *, int);
inode18fs/minix/symlink.cstatic struct inode * minix_follow_link(struct inode *, struct inode *);
inode40fs/minix/symlink.cstatic struct inode * minix_follow_link(struct inode * dir, struct inode * inode)
inode49fs/minix/symlink.cif (!inode) {
inode53fs/minix/symlink.cif (!S_ISLNK(inode->i_mode)) {
inode55fs/minix/symlink.creturn inode;
inode58fs/minix/symlink.cif ((current->link_count > 5) || !inode->i_data[0] ||
inode59fs/minix/symlink.c!(bh = bread(inode->i_dev, inode->i_data[0], BLOCK_SIZE))) {
inode61fs/minix/symlink.ciput(inode);
inode64fs/minix/symlink.ciput(inode);
inode67fs/minix/symlink.cinode = _namei(bh->b_data,dir,1);
inode71fs/minix/symlink.creturn inode;
inode74fs/minix/symlink.cstatic int minix_readlink(struct inode * inode, char * buffer, int buflen)
inode80fs/minix/symlink.cif (!S_ISLNK(inode->i_mode)) {
inode81fs/minix/symlink.ciput(inode);
inode86fs/minix/symlink.cif (inode->i_data[0])
inode87fs/minix/symlink.cbh = bread(inode->i_dev, inode->i_data[0], BLOCK_SIZE);
inode90fs/minix/symlink.ciput(inode);
inode27fs/minix/truncate.cstatic int trunc_direct(struct inode * inode)
inode31fs/minix/truncate.c#define DIRECT_BLOCK ((inode->i_size + 1023) >> 10)
inode37fs/minix/truncate.cif (!inode->i_data[i])
inode40fs/minix/truncate.cif (minix_free_block(inode->i_dev,inode->i_data[i]))
inode41fs/minix/truncate.cinode->i_data[i] = 0;
inode46fs/minix/truncate.cstatic int trunc_indirect(struct inode * inode, int offset, unsigned short * p)
inode55fs/minix/truncate.cbh = bread(inode->i_dev, *p, BLOCK_SIZE);
inode68fs/minix/truncate.cif (minix_free_block(inode->i_dev,*ind))
inode78fs/minix/truncate.cif (minix_free_block(inode->i_dev,*p))
inode84fs/minix/truncate.cstatic int trunc_dindirect(struct inode * inode)
inode92fs/minix/truncate.cif (inode->i_data[8])
inode93fs/minix/truncate.cbh = bread(inode->i_dev, inode->i_data[8], BLOCK_SIZE);
inode105fs/minix/truncate.cresult |= trunc_indirect(inode,7+512+(i<<9),dind);
inode114fs/minix/truncate.cif (minix_free_block(inode->i_dev,inode->i_data[8]))
inode115fs/minix/truncate.cinode->i_data[8] = 0;
inode120fs/minix/truncate.cvoid minix_truncate(struct inode * inode)
inode124fs/minix/truncate.cif (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
inode125fs/minix/truncate.cS_ISLNK(inode->i_mode)))
inode127fs/minix/truncate.cif (inode->i_data[7] & 0xffff0000)
inode130fs/minix/truncate.cflag = trunc_direct(inode);
inode131fs/minix/truncate.cflag |= trunc_indirect(inode,7,(unsigned short *)&inode->i_data[7]);
inode132fs/minix/truncate.cflag |= trunc_dindirect(inode);
inode138fs/minix/truncate.cinode->i_mtime = inode->i_ctime = CURRENT_TIME;
inode139fs/minix/truncate.cinode->i_dirt = 1;
inode147fs/minix/truncate.cvoid minix_release(struct inode * inode, struct file * filp)
inode17fs/msdos/dir.cstatic int msdos_dummy_read(struct inode *inode,struct file *filp,char *buf,
inode19fs/msdos/dir.cstatic int msdos_readdir(struct inode *inode,struct file *filp,
inode54fs/msdos/dir.cstatic int msdos_dummy_read(struct inode *inode,struct file *filp,char *buf,
inode67fs/msdos/dir.cstatic int msdos_readdir(struct inode *inode,struct file *filp,
inode75fs/msdos/dir.cif (!inode || !S_ISDIR(inode->i_mode)) return -EBADF;
inode76fs/msdos/dir.cif (inode->i_ino == MSDOS_ROOT_INO) {
inode91fs/msdos/dir.cwhile ((ino = msdos_get_entry(inode,&filp->f_pos,&bh,&de)) > -1) {
inode114fs/msdos/dir.cino = inode->i_ino;
inode116fs/msdos/dir.cino = msdos_parent_ino(inode,0);
inode117fs/msdos/fat.cvoid cache_lookup(struct inode *inode,int cluster,int *f_clu,int *d_clu)
inode125fs/msdos/fat.cif (inode->i_dev == walk->device && walk->ino == inode->i_ino &&
inode152fs/msdos/fat.cvoid cache_add(struct inode *inode,int f_clu,int d_clu)
inode161fs/msdos/fat.cif (inode->i_dev == walk->device && walk->ino == inode->i_ino &&
inode175fs/msdos/fat.cwalk->device = inode->i_dev;
inode176fs/msdos/fat.cwalk->ino = inode->i_ino;
inode191fs/msdos/fat.cvoid cache_inval_inode(struct inode *inode)
inode196fs/msdos/fat.cif (walk->device == inode->i_dev && walk->ino == inode->i_ino)
inode210fs/msdos/fat.cint get_cluster(struct inode *inode,int cluster)
inode214fs/msdos/fat.cif (!(this = inode->i_data[D_START])) return 0;
inode217fs/msdos/fat.cfor (cache_lookup(inode,cluster,&count,&this); count < cluster;
inode219fs/msdos/fat.cif ((this = fat_access(inode->i_sb,this,-1)) == -1) return 0;
inode222fs/msdos/fat.ccache_add(inode,cluster,this);
inode227fs/msdos/fat.cint msdos_smap(struct inode *inode,int sector)
inode232fs/msdos/fat.csb = MSDOS_SB(inode->i_sb);
inode233fs/msdos/fat.cif (inode->i_ino == MSDOS_ROOT_INO || (S_ISDIR(inode->i_mode) &&
inode234fs/msdos/fat.c!inode->i_data[D_START])) {
inode240fs/msdos/fat.cif (!(cluster = get_cluster(inode,cluster))) return 0;
inode248fs/msdos/fat.cint fat_free(struct inode *inode,int skip)
inode252fs/msdos/fat.cif (!(this = inode->i_data[D_START])) return 0;
inode256fs/msdos/fat.cif ((this = fat_access(inode->i_sb,this,-1)) == -1)
inode264fs/msdos/fat.cfat_access(inode->i_sb,last,MSDOS_SB(inode->i_sb)->fat_bits ==
inode267fs/msdos/fat.cinode->i_data[D_START] = 0;
inode268fs/msdos/fat.cinode->i_dirt = 1;
inode271fs/msdos/fat.cif (!(this = fat_access(inode->i_sb,this,0)))
inode273fs/msdos/fat.ccache_inval_inode(inode);
inode22fs/msdos/file.cstatic int msdos_file_read(struct inode *inode,struct file *filp,char *buf,
inode24fs/msdos/file.cstatic int msdos_file_write(struct inode *inode,struct file *filp,char *buf,
inode76fs/msdos/file.cstatic int msdos_file_read(struct inode *inode,struct file *filp,char *buf,
inode86fs/msdos/file.cif (!inode) {
inode90fs/msdos/file.cif (!S_ISREG(inode->i_mode)) {
inode91fs/msdos/file.cprintk("msdos_file_read: mode = %07o\n",inode->i_mode);
inode94fs/msdos/file.cif (filp->f_pos >= inode->i_size || count <= 0) return 0;
inode96fs/msdos/file.cwhile (left = MIN(inode->i_size-filp->f_pos,count-(buf-start))) {
inode97fs/msdos/file.cif (!(sector = msdos_smap(inode,filp->f_pos >> SECTOR_BITS)))
inode100fs/msdos/file.cif (!(bh = msdos_sread(inode->i_dev,sector,&data))) break;
inode102fs/msdos/file.cif (inode->i_data[D_BINARY]) {
inode112fs/msdos/file.cfilp->f_pos = inode->i_size;
inode125fs/msdos/file.cstatic int msdos_file_write(struct inode *inode,struct file *filp,char *buf,
inode134fs/msdos/file.cif (!inode) {
inode138fs/msdos/file.cif (!S_ISREG(inode->i_mode)) {
inode139fs/msdos/file.cprintk("msdos_file_write: mode = %07o\n",inode->i_mode);
inode146fs/msdos/file.cif (filp->f_flags & O_APPEND) filp->f_pos = inode->i_size;
inode150fs/msdos/file.cwhile (!(sector = msdos_smap(inode,filp->f_pos >> SECTOR_BITS)))
inode151fs/msdos/file.cif ((error = msdos_add_cluster(inode)) < 0) break;
inode155fs/msdos/file.cif (!(bh = msdos_sread(inode->i_dev,sector,&data))) {
inode159fs/msdos/file.cif (inode->i_data[D_BINARY]) {
inode186fs/msdos/file.cif (filp->f_pos > inode->i_size) {
inode187fs/msdos/file.cinode->i_size = filp->f_pos;
inode188fs/msdos/file.cinode->i_dirt = 1;
inode193fs/msdos/file.cinode->i_mtime = inode->i_ctime = CURRENT_TIME;
inode194fs/msdos/file.cinode->i_data[D_ATTRS] |= ATTR_ARCH;
inode195fs/msdos/file.cinode->i_dirt = 1;
inode200fs/msdos/file.cvoid msdos_truncate(struct inode *inode)
inode204fs/msdos/file.ccluster = SECTOR_SIZE*MSDOS_SB(inode->i_sb)->cluster_size;
inode205fs/msdos/file.c(void) fat_free(inode,(inode->i_size+(cluster-1))/cluster);
inode206fs/msdos/file.cinode->i_data[D_ATTRS] |= ATTR_ARCH;
inode207fs/msdos/file.cinode->i_dirt = 1;
inode16fs/msdos/inode.cvoid msdos_put_inode(struct inode *inode)
inode18fs/msdos/inode.cstruct inode *depend;
inode20fs/msdos/inode.cinode->i_size = 0;
inode21fs/msdos/inode.cmsdos_truncate(inode);
inode22fs/msdos/inode.cdepend = (struct inode *) inode->i_data[D_DEPEND];
inode23fs/msdos/inode.cmemset(inode,0,sizeof(struct inode));
inode25fs/msdos/inode.cif ((struct inode *) depend->i_data[D_OLD] != inode) {
inode27fs/msdos/inode.c"0x%X\r\n",(int) depend,(int) inode,
inode176fs/msdos/inode.cint msdos_bmap(struct inode *inode,int block)
inode181fs/msdos/inode.csb = MSDOS_SB(inode->i_sb);
inode183fs/msdos/inode.cif (inode->i_ino == MSDOS_ROOT_INO) {
inode189fs/msdos/inode.cif (!(cluster = get_cluster(inode,cluster))) return 0;
inode194fs/msdos/inode.cvoid msdos_read_inode(struct inode *inode)
inode201fs/msdos/inode.cinode->i_data[D_BUSY] = inode->i_data[D_DEPEND] =
inode202fs/msdos/inode.cinode->i_data[D_OLD] = 0;
inode203fs/msdos/inode.cinode->i_data[D_BINARY] = 1;
inode204fs/msdos/inode.cinode->i_uid = MSDOS_SB(inode->i_sb)->fs_uid;
inode205fs/msdos/inode.cinode->i_gid = MSDOS_SB(inode->i_sb)->fs_gid;
inode206fs/msdos/inode.cif (inode->i_ino == MSDOS_ROOT_INO) {
inode207fs/msdos/inode.cinode->i_mode = (0777 & ~MSDOS_SB(inode->i_sb)->fs_umask) |
inode209fs/msdos/inode.cinode->i_op = &msdos_dir_inode_operations;
inode210fs/msdos/inode.cinode->i_nlink = 1;
inode211fs/msdos/inode.cinode->i_size = MSDOS_SB(inode->i_sb)->dir_entries*
inode213fs/msdos/inode.cinode->i_data[D_START] = 0;
inode214fs/msdos/inode.cinode->i_data[D_ATTRS] = 0;
inode215fs/msdos/inode.cinode->i_mtime = inode->i_atime = inode->i_ctime = 0;
inode218fs/msdos/inode.cif (!(bh = bread(inode->i_dev,inode->i_ino >> MSDOS_DPB_BITS, BLOCK_SIZE)))
inode221fs/msdos/inode.c[inode->i_ino & (MSDOS_DPB-1)];
inode223fs/msdos/inode.cinode->i_mode = MSDOS_MKMODE(raw_entry->attr,0777 &
inode224fs/msdos/inode.c~MSDOS_SB(inode->i_sb)->fs_umask) | S_IFDIR;
inode225fs/msdos/inode.cinode->i_op = &msdos_dir_inode_operations;
inode226fs/msdos/inode.cinode->i_nlink = 3;
inode227fs/msdos/inode.cinode->i_size = 0;
inode229fs/msdos/inode.cfat_access(inode->i_sb,this,-1))
inode230fs/msdos/inode.cinode->i_size += SECTOR_SIZE*MSDOS_SB(inode->i_sb)->
inode234fs/msdos/inode.cinode->i_mode = MSDOS_MKMODE(raw_entry->attr,0666 &
inode235fs/msdos/inode.c~MSDOS_SB(inode->i_sb)->fs_umask) | S_IFREG;
inode236fs/msdos/inode.cinode->i_op = MSDOS_CAN_BMAP(MSDOS_SB(inode->i_sb)) ? 
inode239fs/msdos/inode.cinode->i_nlink = 1;
inode240fs/msdos/inode.cinode->i_size = raw_entry->size;
inode242fs/msdos/inode.cinode->i_data[D_BINARY] = is_binary(MSDOS_SB(inode->i_sb)->conversion,
inode244fs/msdos/inode.cinode->i_data[D_START] = raw_entry->start;
inode245fs/msdos/inode.cinode->i_data[D_ATTRS] = raw_entry->attr & ATTR_UNUSED;
inode246fs/msdos/inode.cinode->i_mtime = inode->i_atime = inode->i_ctime =
inode252fs/msdos/inode.cvoid msdos_write_inode(struct inode *inode)
inode257fs/msdos/inode.cinode->i_dirt = 0;
inode258fs/msdos/inode.cif (inode->i_ino == MSDOS_ROOT_INO || !inode->i_nlink) return;
inode259fs/msdos/inode.cif (!(bh = bread(inode->i_dev,inode->i_ino >> MSDOS_DPB_BITS, BLOCK_SIZE)))
inode262fs/msdos/inode.c[inode->i_ino & (MSDOS_DPB-1)];
inode263fs/msdos/inode.cif (S_ISDIR(inode->i_mode)) {
inode269fs/msdos/inode.craw_entry->size = inode->i_size;
inode271fs/msdos/inode.craw_entry->attr |= MSDOS_MKATTR(inode->i_mode) | inode->i_data[D_ATTRS];
inode272fs/msdos/inode.craw_entry->start = inode->i_data[D_START];
inode273fs/msdos/inode.cdate_unix2dos(inode->i_mtime,&raw_entry->time,&raw_entry->date);
inode60fs/msdos/misc.cint msdos_add_cluster(struct inode *inode)
inode69fs/msdos/misc.cif (inode->i_ino == MSDOS_ROOT_INO) return -ENOSPC;
inode72fs/msdos/misc.climit = MSDOS_SB(inode->i_sb)->clusters;
inode76fs/msdos/misc.cif (fat_access(inode->i_sb,this,-1) == 0) break;
inode87fs/msdos/misc.cfat_access(inode->i_sb,this,MSDOS_SB(inode->i_sb)->fat_bits == 12 ?
inode92fs/msdos/misc.cprintk("set to %x\r\n",fat_access(inode->i_sb,this,-1));
inode94fs/msdos/misc.cif (!S_ISDIR(inode->i_mode)) {
inode95fs/msdos/misc.clast = inode->i_size ? get_cluster(inode,(inode->i_size-1)/
inode96fs/msdos/misc.cSECTOR_SIZE/MSDOS_SB(inode->i_sb)->cluster_size) : 0;
inode100fs/msdos/misc.cif (current = inode->i_data[D_START]) {
inode101fs/msdos/misc.ccache_lookup(inode,0x7fffffff,&last,&current);
inode103fs/msdos/misc.cif (!(current = fat_access(inode->i_sb,
inode111fs/msdos/misc.cif (last) fat_access(inode->i_sb,last,this);
inode113fs/msdos/misc.cinode->i_data[D_START] = this;
inode114fs/msdos/misc.cinode->i_dirt = 1;
inode117fs/msdos/misc.cif (last) printk("next set to %d\r\n",fat_access(inode->i_sb,last,-1));
inode119fs/msdos/misc.cfor (current = 0; current < MSDOS_SB(inode->i_sb)->cluster_size;
inode121fs/msdos/misc.csector = MSDOS_SB(inode->i_sb)->data_start+(this-2)*
inode122fs/msdos/misc.cMSDOS_SB(inode->i_sb)->cluster_size+current;
inode126fs/msdos/misc.cif (current < MSDOS_SB(inode->i_sb)->cluster_size-1 &&
inode128fs/msdos/misc.cif (!(bh = getblk(inode->i_dev,sector >> 1, BLOCK_SIZE)))
inode137fs/msdos/misc.cif (!(bh = msdos_sread(inode->i_dev,sector,&data)))
inode146fs/msdos/misc.cif (S_ISDIR(inode->i_mode)) {
inode147fs/msdos/misc.cif (inode->i_size & (SECTOR_SIZE-1))
inode149fs/msdos/misc.cinode->i_size += SECTOR_SIZE*MSDOS_SB(inode->i_sb)->
inode152fs/msdos/misc.cprintk("size is %d now (%x)\r\n",inode->i_size,inode);
inode154fs/msdos/misc.cinode->i_dirt = 1;
inode211fs/msdos/misc.cint msdos_get_entry(struct inode *dir,int *pos,struct buffer_head **bh,
inode239fs/msdos/misc.cint msdos_scan(struct inode *dir,char *name,struct buffer_head **res_bh,
inode244fs/msdos/misc.cstruct inode *inode;
inode256fs/msdos/misc.cif (!(inode = iget(dir->i_dev,*ino))) break;
inode257fs/msdos/misc.cif (!inode->i_data[D_BUSY]) {
inode258fs/msdos/misc.ciput(inode);
inode262fs/msdos/misc.ciput(inode);
inode340fs/msdos/misc.cint msdos_parent_ino(struct inode *dir,int locked)
inode90fs/msdos/namei.cstatic int msdos_find(struct inode *dir,const char *name,int len,
inode102fs/msdos/namei.cint msdos_lookup(struct inode *dir,const char *name,int len,
inode103fs/msdos/namei.cstruct inode **result)
inode108fs/msdos/namei.cstruct inode *next;
inode144fs/msdos/namei.cnext = (struct inode *) ((*result)->i_data[D_OLD]);
inode156fs/msdos/namei.cstatic int msdos_create_entry(struct inode *dir,char *name,int is_dir,
inode157fs/msdos/namei.cstruct inode **result)
inode184fs/msdos/namei.cint msdos_create(struct inode *dir,const char *name,int len,int mode,
inode185fs/msdos/namei.cstruct inode **result)
inode212fs/msdos/namei.cint msdos_mkdir(struct inode *dir,const char *name,int len,int mode)
inode216fs/msdos/namei.cstruct inode *inode,*dot;
inode232fs/msdos/namei.cif ((res = msdos_create_entry(dir,msdos_name,1,&inode)) < 0) {
inode237fs/msdos/namei.cinode->i_data[D_BUSY] = 1; /* prevent lookups */
inode238fs/msdos/namei.cif ((res = msdos_add_cluster(inode)) < 0) goto mkdir_error;
inode239fs/msdos/namei.cif ((res = msdos_create_entry(inode,MSDOS_DOT,1,&dot)) < 0)
inode241fs/msdos/namei.cdot->i_size = inode->i_size;
inode242fs/msdos/namei.cdot->i_data[D_START] = inode->i_data[D_START];
inode245fs/msdos/namei.cif ((res = msdos_create_entry(inode,MSDOS_DOTDOT,1,&dot)) < 0)
inode251fs/msdos/namei.cinode->i_data[D_BUSY] = 0;
inode253fs/msdos/namei.ciput(inode);
inode257fs/msdos/namei.ciput(inode);
inode264fs/msdos/namei.cint msdos_rmdir(struct inode *dir,const char *name,int len)
inode269fs/msdos/namei.cstruct inode *inode;
inode272fs/msdos/namei.cinode = NULL;
inode277fs/msdos/namei.cif (!(inode = iget(dir->i_dev,ino))) goto rmdir_done;
inode279fs/msdos/namei.cif (!S_ISDIR(inode->i_mode)) goto rmdir_done;
inode281fs/msdos/namei.cif (dir->i_dev != inode->i_dev || dir == inode) goto rmdir_done;
inode282fs/msdos/namei.cif (inode->i_count > 1) goto rmdir_done;
inode283fs/msdos/namei.cif (inode->i_data[D_START]) { /* may be zero in mkdir */
inode287fs/msdos/namei.cwhile (msdos_get_entry(inode,&pos,&dbh,&dde) > -1)
inode294fs/msdos/namei.cinode->i_nlink = 0;
inode296fs/msdos/namei.cinode->i_dirt = dir->i_dirt = 1;
inode303fs/msdos/namei.ciput(inode);
inode308fs/msdos/namei.cint msdos_unlink(struct inode *dir,const char *name,int len)
inode313fs/msdos/namei.cstruct inode *inode;
inode316fs/msdos/namei.cinode = NULL;
inode319fs/msdos/namei.cif (!(inode = iget(dir->i_dev,ino))) {
inode323fs/msdos/namei.cif (!S_ISREG(inode->i_mode)) {
inode327fs/msdos/namei.cinode->i_nlink = 0;
inode328fs/msdos/namei.cinode->i_data[D_BUSY] = 1;
inode329fs/msdos/namei.cinode->i_dirt = 1;
inode334fs/msdos/namei.ciput(inode);
inode340fs/msdos/namei.cstatic int rename_same_dir(struct inode *old_dir,char *old_name,
inode341fs/msdos/namei.cstruct inode *new_dir,char *new_name,struct buffer_head *old_bh,
inode346fs/msdos/namei.cstruct inode *new_inode,*old_inode;
inode385fs/msdos/namei.cstatic int rename_diff_dir(struct inode *old_dir,char *old_name,
inode386fs/msdos/namei.cstruct inode *new_dir,char *new_name,struct buffer_head *old_bh,
inode391fs/msdos/namei.cstruct inode *old_inode,*new_inode,*free_inode,*dotdot_inode,*walk;
inode489fs/msdos/namei.cint msdos_rename(struct inode *old_dir,const char *old_name,int old_len,
inode490fs/msdos/namei.cstruct inode *new_dir,const char *new_name,int new_len)
inode22fs/namei.cstruct inode * _namei(const char * filename, struct inode * base,
inode40fs/namei.cint permission(struct inode * inode,int mask)
inode42fs/namei.cint mode = inode->i_mode;
inode45fs/namei.cif (inode->i_dev && !inode->i_nlink)
inode47fs/namei.celse if (current->euid == inode->i_uid)
inode49fs/namei.celse if (in_group_p(inode->i_gid))
inode61fs/namei.cint lookup(struct inode * dir,const char * name, int len,
inode62fs/namei.cstruct inode ** result)
inode94fs/namei.cstruct inode * follow_link(struct inode * dir, struct inode * inode)
inode96fs/namei.cif (!dir || !inode) {
inode98fs/namei.ciput(inode);
inode101fs/namei.cif (!inode->i_op || !inode->i_op->follow_link) {
inode103fs/namei.creturn inode;
inode105fs/namei.creturn inode->i_op->follow_link(dir,inode);
inode114fs/namei.cstatic struct inode * dir_namei(const char * pathname,
inode115fs/namei.cint * namelen, const char ** name, struct inode * base)
inode120fs/namei.cstruct inode * inode;
inode139fs/namei.cerror = lookup(base,thisname,len,&inode);
inode144fs/namei.cif (!(base = follow_link(base,inode)))
inode152fs/namei.cstruct inode * _namei(const char * pathname, struct inode * base,
inode157fs/namei.cstruct inode * inode;
inode162fs/namei.cerror = lookup(base,basename,namelen,&inode);
inode168fs/namei.cinode = follow_link(base,inode);
inode171fs/namei.creturn inode;
inode174fs/namei.cstruct inode * lnamei(const char * pathname)
inode186fs/namei.cstruct inode * namei(const char * pathname)
inode197fs/namei.cstruct inode ** res_inode)
inode201fs/namei.cstruct inode * dir, *inode;
inode219fs/namei.cerror = lookup(dir,basename,namelen,&inode);
inode241fs/namei.ciput(inode);
inode244fs/namei.cif (!(inode = follow_link(dir,inode)))
inode246fs/namei.cif (S_ISBLK(inode->i_mode) || S_ISCHR(inode->i_mode)) {
inode247fs/namei.cif (IS_NODEV(inode)) {
inode248fs/namei.ciput(inode);
inode252fs/namei.cif (IS_RDONLY(inode) && (flag & (O_TRUNC | O_ACCMODE))) {
inode253fs/namei.ciput(inode);
inode257fs/namei.cif ((S_ISDIR(inode->i_mode) && (flag & O_ACCMODE)) ||
inode258fs/namei.c!permission(inode,ACC_MODE(flag))) {
inode259fs/namei.ciput(inode);
inode262fs/namei.cif ((inode->i_count > 1) && (flag & O_ACCMODE))
inode266fs/namei.cif (inode == (*p)->executable) {
inode267fs/namei.ciput(inode);
inode271fs/namei.cif (inode == (*p)->libraries[i].library) {
inode272fs/namei.ciput(inode);
inode277fs/namei.cif (inode->i_op && inode->i_op->truncate) {
inode278fs/namei.cinode->i_size = 0;
inode279fs/namei.cinode->i_op->truncate(inode);
inode281fs/namei.cif (!IS_RDONLY(inode)) {
inode282fs/namei.cinode->i_atime = CURRENT_TIME;
inode283fs/namei.cinode->i_dirt = 1;
inode285fs/namei.c*res_inode = inode;
inode293fs/namei.cstruct inode * dir;
inode327fs/namei.cstruct inode * dir;
inode354fs/namei.cstruct inode * dir;
inode381fs/namei.cstruct inode * dir;
inode406fs/namei.cstruct inode * dir;
inode434fs/namei.cstruct inode * oldinode, * dir;
inode476fs/namei.cstruct inode * old_dir, * new_dir;
inode35fs/open.cstruct inode * inode;
inode38fs/open.cif (!(inode = namei(path)))
inode40fs/open.cif (!inode->i_sb->s_op->statfs) {
inode41fs/open.ciput(inode);
inode44fs/open.cinode->i_sb->s_op->statfs(inode->i_sb, buf);
inode45fs/open.ciput(inode);
inode51fs/open.cstruct inode * inode;
inode57fs/open.cif (!(inode = file->f_inode))
inode59fs/open.cif (!inode->i_sb->s_op->statfs)
inode61fs/open.cinode->i_sb->s_op->statfs(inode->i_sb, buf);
inode67fs/open.cstruct inode * inode;
inode69fs/open.cif (!(inode = namei(path)))
inode71fs/open.cif (S_ISDIR(inode->i_mode) || !permission(inode,MAY_WRITE)) {
inode72fs/open.ciput(inode);
inode75fs/open.cif (IS_RDONLY(inode)) {
inode76fs/open.ciput(inode);
inode79fs/open.cinode->i_size = length;
inode80fs/open.cif (inode->i_op && inode->i_op->truncate)
inode81fs/open.cinode->i_op->truncate(inode);
inode82fs/open.cinode->i_atime = inode->i_mtime = CURRENT_TIME;
inode83fs/open.cinode->i_dirt = 1;
inode84fs/open.ciput(inode);
inode90fs/open.cstruct inode * inode;
inode95fs/open.cif (!(inode = file->f_inode))
inode97fs/open.cif (S_ISDIR(inode->i_mode) || !(file->f_mode & 2))
inode99fs/open.cinode->i_size = length;
inode100fs/open.cif (inode->i_op && inode->i_op->truncate)
inode101fs/open.cinode->i_op->truncate(inode);
inode102fs/open.cinode->i_atime = inode->i_mtime = CURRENT_TIME;
inode103fs/open.cinode->i_dirt = 1;
inode113fs/open.cstruct inode * inode;
inode116fs/open.cif (!(inode=namei(filename)))
inode118fs/open.cif (IS_RDONLY(inode)) {
inode119fs/open.ciput(inode);
inode123fs/open.cif ((current->euid != inode->i_uid) && !suser()) {
inode124fs/open.ciput(inode);
inode130fs/open.cif ((current->euid != inode->i_uid) &&
inode131fs/open.c!permission(inode,MAY_WRITE)) {
inode132fs/open.ciput(inode);
inode137fs/open.cinode->i_atime = actime;
inode138fs/open.cinode->i_mtime = modtime;
inode139fs/open.cinode->i_dirt = 1;
inode140fs/open.ciput(inode);
inode150fs/open.cstruct inode * inode;
inode154fs/open.cif (!(inode=namei(filename)))
inode156fs/open.ci_mode = res = inode->i_mode & 0777;
inode157fs/open.ciput(inode);
inode158fs/open.cif (current->uid == inode->i_uid)
inode160fs/open.celse if (in_group_p(inode->i_gid))
inode178fs/open.cstruct inode * inode;
inode180fs/open.cif (!(inode = namei(filename)))
inode182fs/open.cif (!S_ISDIR(inode->i_mode)) {
inode183fs/open.ciput(inode);
inode186fs/open.cif (!permission(inode,MAY_EXEC)) {
inode187fs/open.ciput(inode);
inode191fs/open.ccurrent->pwd = inode;
inode197fs/open.cstruct inode * inode;
inode199fs/open.cif (!(inode=namei(filename)))
inode201fs/open.cif (!S_ISDIR(inode->i_mode)) {
inode202fs/open.ciput(inode);
inode206fs/open.ciput(inode);
inode210fs/open.ccurrent->root = inode;
inode216fs/open.cstruct inode * inode;
inode221fs/open.cif (!(inode = file->f_inode))
inode223fs/open.cif ((current->euid != inode->i_uid) && !suser())
inode225fs/open.cif (IS_RDONLY(inode))
inode227fs/open.cinode->i_mode = (mode & 07777) | (inode->i_mode & ~07777);
inode228fs/open.cinode->i_dirt = 1;
inode234fs/open.cstruct inode * inode;
inode236fs/open.cif (!(inode = namei(filename)))
inode238fs/open.cif ((current->euid != inode->i_uid) && !suser()) {
inode239fs/open.ciput(inode);
inode242fs/open.cif (IS_RDONLY(inode)) {
inode243fs/open.ciput(inode);
inode246fs/open.cinode->i_mode = (mode & 07777) | (inode->i_mode & ~07777);
inode247fs/open.cinode->i_dirt = 1;
inode248fs/open.ciput(inode);
inode254fs/open.cstruct inode * inode;
inode259fs/open.cif (!(inode = file->f_inode))
inode261fs/open.cif (IS_RDONLY(inode))
inode263fs/open.cif ((current->euid == inode->i_uid && user == inode->i_uid &&
inode264fs/open.c(in_group_p(group) || group == inode->i_gid)) ||
inode266fs/open.cinode->i_uid = user;
inode267fs/open.cinode->i_gid = group;
inode268fs/open.cinode->i_dirt=1;
inode276fs/open.cstruct inode * inode;
inode278fs/open.cif (!(inode = lnamei(filename)))
inode280fs/open.cif (IS_RDONLY(inode)) {
inode281fs/open.ciput(inode);
inode284fs/open.cif ((current->euid == inode->i_uid && user == inode->i_uid &&
inode285fs/open.c(in_group_p(group) || group == inode->i_gid)) ||
inode287fs/open.cinode->i_uid = user;
inode288fs/open.cinode->i_gid = group;
inode289fs/open.cinode->i_dirt=1;
inode290fs/open.ciput(inode);
inode293fs/open.ciput(inode);
inode299fs/open.cstruct inode * inode;
inode313fs/open.cif ((i = open_namei(filename,flag,mode,&inode))<0) {
inode320fs/open.cf->f_inode = inode;
inode324fs/open.cif (inode->i_op)
inode325fs/open.cf->f_op = inode->i_op->default_file_ops;
inode327fs/open.cif (i = f->f_op->open(inode,f)) {
inode328fs/open.ciput(inode);
inode344fs/open.cstruct inode * inode;
inode360fs/open.cinode = filp->f_inode;
inode362fs/open.cfilp->f_op->release(inode,filp);
inode365fs/open.ciput(inode);
inode16fs/pipe.cstatic int pipe_read(struct inode * inode, struct file * filp, char * buf, int count)
inode21fs/pipe.cwhile (!PIPE_SIZE(*inode)) {
inode22fs/pipe.cwake_up(& PIPE_WRITE_WAIT(*inode));
inode23fs/pipe.cif (!PIPE_WRITERS(*inode)) /* are there any writers? */
inode27fs/pipe.cinterruptible_sleep_on(& PIPE_READ_WAIT(*inode));
inode29fs/pipe.cwhile (count>0 && (size = PIPE_SIZE(*inode))) {
inode30fs/pipe.cchars = PAGE_SIZE-PIPE_TAIL(*inode);
inode35fs/pipe.cmemcpy_tofs(buf, (char *)inode->i_size+PIPE_TAIL(*inode), chars );
inode37fs/pipe.cPIPE_TAIL(*inode) += chars;
inode38fs/pipe.cPIPE_TAIL(*inode) &= (PAGE_SIZE-1);
inode42fs/pipe.cwake_up(& PIPE_WRITE_WAIT(*inode));
inode46fs/pipe.cstatic int pipe_write(struct inode * inode, struct file * filp, char * buf, int count)
inode50fs/pipe.cif (!PIPE_READERS(*inode)) { /* no readers */
inode60fs/pipe.cwhile (PIPE_SIZE(*inode) >= size) {
inode61fs/pipe.cif (!PIPE_READERS(*inode)) { /* no readers */
inode70fs/pipe.cinterruptible_sleep_on(&PIPE_WRITE_WAIT(*inode));
inode72fs/pipe.cwhile (count>0 && (size = (PAGE_SIZE-1)-PIPE_SIZE(*inode))) {
inode73fs/pipe.cchars = PAGE_SIZE-PIPE_HEAD(*inode);
inode78fs/pipe.cmemcpy_fromfs((char *)inode->i_size+PIPE_HEAD(*inode), buf, chars );
inode80fs/pipe.cPIPE_HEAD(*inode) += chars;
inode81fs/pipe.cPIPE_HEAD(*inode) &= (PAGE_SIZE-1);
inode85fs/pipe.cwake_up(& PIPE_READ_WAIT(*inode));
inode91fs/pipe.cstatic int pipe_lseek(struct inode * inode, struct file * file, off_t offset, int orig)
inode96fs/pipe.cstatic int pipe_readdir(struct inode * inode, struct file * file, struct dirent * de, int count)
inode101fs/pipe.cstatic int bad_pipe_rw(struct inode * inode, struct file * filp, char * buf, int count)
inode106fs/pipe.cstatic int pipe_ioctl(struct inode *pino, struct file * filp,
inode119fs/pipe.cstatic int pipe_select(struct inode * inode, struct file * filp, int sel_type, select_table * wait)
inode123fs/pipe.cif (!PIPE_EMPTY(*inode) || !PIPE_WRITERS(*inode))
inode125fs/pipe.cselect_wait(&PIPE_READ_WAIT(*inode), wait);
inode128fs/pipe.cif (!PIPE_FULL(*inode) || !PIPE_WRITERS(*inode))
inode130fs/pipe.cselect_wait(&PIPE_WRITE_WAIT(*inode), wait);
inode133fs/pipe.cif (!PIPE_READERS(*inode) || !PIPE_WRITERS(*inode))
inode135fs/pipe.cselect_wait(&inode->i_wait,wait);
inode145fs/pipe.cstatic void pipe_read_release(struct inode * inode, struct file * filp)
inode147fs/pipe.cPIPE_READERS(*inode)--;
inode148fs/pipe.cwake_up(&PIPE_WRITE_WAIT(*inode));
inode151fs/pipe.cstatic void pipe_write_release(struct inode * inode, struct file * filp)
inode153fs/pipe.cPIPE_WRITERS(*inode)--;
inode154fs/pipe.cwake_up(&PIPE_READ_WAIT(*inode));
inode157fs/pipe.cstatic void pipe_rdwr_release(struct inode * inode, struct file * filp)
inode159fs/pipe.cPIPE_READERS(*inode)--;
inode160fs/pipe.cPIPE_WRITERS(*inode)--;
inode161fs/pipe.cwake_up(&PIPE_READ_WAIT(*inode));
inode162fs/pipe.cwake_up(&PIPE_WRITE_WAIT(*inode));
inode204fs/pipe.cstruct inode * inode;
inode230fs/pipe.cif (!(inode=get_pipe_inode())) {
inode237fs/pipe.cf[0]->f_inode = f[1]->f_inode = inode;
inode23fs/read_write.cstruct inode * inode;
inode26fs/read_write.c!(inode = file->f_inode))
inode30fs/read_write.creturn file->f_op->readdir(inode,file,dirent,count);
inode71fs/read_write.cstruct inode * inode;
inode73fs/read_write.cif (fd>=NR_OPEN || !(file=current->filp[fd]) || !(inode=file->f_inode))
inode81fs/read_write.creturn file->f_op->read(inode,file,buf,count);
inode88fs/read_write.cstruct inode * inode;
inode90fs/read_write.cif (fd>=NR_OPEN || !(file=current->filp[fd]) || !(inode=file->f_inode))
inode97fs/read_write.creturn file->f_op->write(inode,file,buf,count);
inode50fs/select.cstatic int check_in(select_table * wait, struct inode * inode, struct file * file)
inode53fs/select.creturn file->f_op->select(inode,file,SEL_IN,wait);
inode57fs/select.cstatic int check_out(select_table * wait, struct inode * inode, struct file * file)
inode60fs/select.creturn file->f_op->select(inode,file,SEL_OUT,wait);
inode64fs/select.cstatic int check_ex(select_table * wait, struct inode * inode, struct file * file)
inode67fs/select.creturn file->f_op->select(inode,file,SEL_EX,wait);
inode14fs/stat.cstatic void cp_old_stat(struct inode * inode, struct old_stat * statbuf)
inode18fs/stat.cif (inode->i_ino & 0xffff0000)
inode21fs/stat.ctmp.st_dev = inode->i_dev;
inode22fs/stat.ctmp.st_ino = inode->i_ino;
inode23fs/stat.ctmp.st_mode = inode->i_mode;
inode24fs/stat.ctmp.st_nlink = inode->i_nlink;
inode25fs/stat.ctmp.st_uid = inode->i_uid;
inode26fs/stat.ctmp.st_gid = inode->i_gid;
inode27fs/stat.ctmp.st_rdev = inode->i_rdev;
inode28fs/stat.cif( S_ISFIFO(inode->i_mode) )
inode31fs/stat.ctmp.st_size = inode->i_size;
inode32fs/stat.ctmp.st_atime = inode->i_atime;
inode33fs/stat.ctmp.st_mtime = inode->i_mtime;
inode34fs/stat.ctmp.st_ctime = inode->i_ctime;
inode38fs/stat.cstatic void cp_new_stat(struct inode * inode, struct new_stat * statbuf)
inode44fs/stat.ctmp.st_dev = inode->i_dev;
inode45fs/stat.ctmp.st_ino = inode->i_ino;
inode46fs/stat.ctmp.st_mode = inode->i_mode;
inode47fs/stat.ctmp.st_nlink = inode->i_nlink;
inode48fs/stat.ctmp.st_uid = inode->i_uid;
inode49fs/stat.ctmp.st_gid = inode->i_gid;
inode50fs/stat.ctmp.st_rdev = inode->i_rdev;
inode51fs/stat.cif( S_ISFIFO(inode->i_mode) )
inode54fs/stat.ctmp.st_size = inode->i_size;
inode55fs/stat.ctmp.st_atime = inode->i_atime;
inode56fs/stat.ctmp.st_mtime = inode->i_mtime;
inode57fs/stat.ctmp.st_ctime = inode->i_ctime;
inode84fs/stat.cstruct inode * inode;
inode86fs/stat.cif (!(inode=namei(filename)))
inode88fs/stat.ccp_old_stat(inode,statbuf);
inode89fs/stat.ciput(inode);
inode95fs/stat.cstruct inode * inode;
inode97fs/stat.cif (!(inode=namei(filename)))
inode99fs/stat.ccp_new_stat(inode,statbuf);
inode100fs/stat.ciput(inode);
inode106fs/stat.cstruct inode * inode;
inode108fs/stat.cif (!(inode = lnamei(filename)))
inode110fs/stat.ccp_old_stat(inode,statbuf);
inode111fs/stat.ciput(inode);
inode117fs/stat.cstruct inode * inode;
inode119fs/stat.cif (!(inode = lnamei(filename)))
inode121fs/stat.ccp_new_stat(inode,statbuf);
inode122fs/stat.ciput(inode);
inode129fs/stat.cstruct inode * inode;
inode131fs/stat.cif (fd >= NR_OPEN || !(f=current->filp[fd]) || !(inode=f->f_inode))
inode133fs/stat.ccp_old_stat(inode,statbuf);
inode140fs/stat.cstruct inode * inode;
inode142fs/stat.cif (fd >= NR_OPEN || !(f=current->filp[fd]) || !(inode=f->f_inode))
inode144fs/stat.ccp_new_stat(inode,statbuf);
inode150fs/stat.cstruct inode * inode;
inode155fs/stat.cif (!(inode = lnamei(path)))
inode157fs/stat.cif (!inode->i_op || !inode->i_op->readlink) {
inode158fs/stat.ciput(inode);
inode161fs/stat.creturn inode->i_op->readlink(inode,buf,bufsiz);
inode149fs/super.cstruct inode * inode;
inode157fs/super.cfor (inode = inode_table+0 ; inode < inode_table+NR_INODE ; inode++)
inode158fs/super.cif (inode->i_dev==dev && inode->i_count)
inode159fs/super.cif (inode == sb->s_mounted && inode->i_count == 1)
inode176fs/super.cstruct inode * inode;
inode181fs/super.cif (!(inode = namei(dev_name)))
inode183fs/super.cdev = inode->i_rdev;
inode184fs/super.cif (!S_ISBLK(inode->i_mode)) {
inode185fs/super.ciput(inode);
inode191fs/super.cblkdev_fops[MAJOR(dev)]->release(inode,NULL);
inode192fs/super.ciput(inode);
inode209fs/super.cstruct inode * inode, * dir_i;
inode222fs/super.cfor (inode = inode_table+0 ; inode < inode_table+NR_INODE ; inode++) {
inode223fs/super.cif (inode->i_dev != dev)
inode225fs/super.cif (inode->i_count || inode->i_dirt || inode->i_lock) {
inode229fs/super.cinode->i_dev = 0;
inode257fs/super.cstruct inode * inode;
inode267fs/super.cif (!(inode = namei(dev_name)))
inode269fs/super.cdev = inode->i_rdev;
inode270fs/super.cif (!S_ISBLK(inode->i_mode))
inode272fs/super.celse if (IS_NODEV(inode))
inode275fs/super.cretval = blkdev_fops[MAJOR(dev)]->open(inode,NULL);
inode277fs/super.ciput(inode);
inode301fs/super.cblkdev_fops[MAJOR(dev)]->release(inode,NULL);
inode302fs/super.ciput(inode);
inode311fs/super.cstruct inode * mi;
inode74include/linux/ext_fs.hunsigned long inode;
inode80include/linux/ext_fs.hextern int ext_open(struct inode * inode, struct file * filp);
inode81include/linux/ext_fs.hextern void ext_release(struct inode * inode, struct file * filp);
inode82include/linux/ext_fs.hextern int ext_lookup(struct inode * dir,const char * name, int len,
inode83include/linux/ext_fs.hstruct inode ** result);
inode84include/linux/ext_fs.hextern int ext_create(struct inode * dir,const char * name, int len, int mode,
inode85include/linux/ext_fs.hstruct inode ** result);
inode86include/linux/ext_fs.hextern int ext_mkdir(struct inode * dir, const char * name, int len, int mode);
inode87include/linux/ext_fs.hextern int ext_rmdir(struct inode * dir, const char * name, int len);
inode88include/linux/ext_fs.hextern int ext_unlink(struct inode * dir, const char * name, int len);
inode89include/linux/ext_fs.hextern int ext_symlink(struct inode * inode, const char * name, int len,
inode91include/linux/ext_fs.hextern int ext_link(struct inode * oldinode, struct inode * dir, const char * name, int len);
inode92include/linux/ext_fs.hextern int ext_mknod(struct inode * dir, const char * name, int len, int mode, int rdev);
inode93include/linux/ext_fs.hextern int ext_rename(struct inode * old_dir, const char * old_name, int old_len,
inode94include/linux/ext_fs.hstruct inode * new_dir, const char * new_name, int new_len);
inode95include/linux/ext_fs.hextern struct inode * ext_new_inode(int dev);
inode96include/linux/ext_fs.hextern void ext_free_inode(struct inode * inode);
inode102include/linux/ext_fs.hextern int ext_create_block(struct inode *, int);
inode103include/linux/ext_fs.hextern int ext_bmap(struct inode *,int);
inode105include/linux/ext_fs.hextern void ext_truncate(struct inode *);
inode109include/linux/ext_fs.hextern void ext_read_inode(struct inode *);
inode110include/linux/ext_fs.hextern void ext_write_inode(struct inode *);
inode111include/linux/ext_fs.hextern void ext_put_inode(struct inode *);
inode114include/linux/ext_fs.hextern int ext_lseek(struct inode *, struct file *, off_t, int);
inode115include/linux/ext_fs.hextern int ext_read(struct inode *, struct file *, char *, int);
inode116include/linux/ext_fs.hextern int ext_write(struct inode *, struct file *, char *, int);
inode50include/linux/fs.h#define PIPE_READ_WAIT(inode) ((inode).i_wait)
inode51include/linux/fs.h#define PIPE_WRITE_WAIT(inode) ((inode).i_wait2)
inode52include/linux/fs.h#define PIPE_HEAD(inode) ((inode).i_data[0])
inode53include/linux/fs.h#define PIPE_TAIL(inode) ((inode).i_data[1])
inode54include/linux/fs.h#define PIPE_READERS(inode) ((inode).i_data[2])
inode55include/linux/fs.h#define PIPE_WRITERS(inode) ((inode).i_data[3])
inode56include/linux/fs.h#define PIPE_SIZE(inode) ((PIPE_HEAD(inode)-PIPE_TAIL(inode))&(PAGE_SIZE-1))
inode57include/linux/fs.h#define PIPE_EMPTY(inode) (PIPE_HEAD(inode)==PIPE_TAIL(inode))
inode58include/linux/fs.h#define PIPE_FULL(inode) (PIPE_SIZE(inode)==(PAGE_SIZE-1))
inode80include/linux/fs.h#define IS_RDONLY(inode) ((inode)->i_flags & MS_RDONLY)
inode81include/linux/fs.h#define IS_NOSUID(inode) ((inode)->i_flags & MS_NOSUID)
inode82include/linux/fs.h#define IS_NODEV(inode) ((inode)->i_flags & MS_NODEV)
inode83include/linux/fs.h#define IS_NOEXEC(inode) ((inode)->i_flags & MS_NOEXEC)
inode84include/linux/fs.h#define IS_SYNC(inode) ((inode)->i_flags & MS_SYNC)
inode147include/linux/fs.hstruct inode * f_inode;
inode166include/linux/fs.hstruct inode * s_covered;
inode167include/linux/fs.hstruct inode * s_mounted;
inode177include/linux/fs.hint (*lseek) (struct inode *, struct file *, off_t, int);
inode178include/linux/fs.hint (*read) (struct inode *, struct file *, char *, int);
inode179include/linux/fs.hint (*write) (struct inode *, struct file *, char *, int);
inode180include/linux/fs.hint (*readdir) (struct inode *, struct file *, struct dirent *, int count);
inode181include/linux/fs.hint (*select) (struct inode *, struct file *, int, select_table *);
inode182include/linux/fs.hint (*ioctl) (struct inode *, struct file *, unsigned int, unsigned int);
inode183include/linux/fs.hint (*open) (struct inode *, struct file *);
inode184include/linux/fs.hvoid (*release) (struct inode *, struct file *);
inode189include/linux/fs.hint (*create) (struct inode *,const char *,int,int,struct inode **);
inode190include/linux/fs.hint (*lookup) (struct inode *,const char *,int,struct inode **);
inode191include/linux/fs.hint (*link) (struct inode *,struct inode *,const char *,int);
inode192include/linux/fs.hint (*unlink) (struct inode *,const char *,int);
inode193include/linux/fs.hint (*symlink) (struct inode *,const char *,int,const char *);
inode194include/linux/fs.hint (*mkdir) (struct inode *,const char *,int,int);
inode195include/linux/fs.hint (*rmdir) (struct inode *,const char *,int);
inode196include/linux/fs.hint (*mknod) (struct inode *,const char *,int,int,int);
inode197include/linux/fs.hint (*rename) (struct inode *,const char *,int,struct inode *,const char *,int);
inode198include/linux/fs.hint (*readlink) (struct inode *,char *,int);
inode199include/linux/fs.hstruct inode * (*follow_link) (struct inode *, struct inode *);
inode200include/linux/fs.hint (*bmap) (struct inode *,int);
inode201include/linux/fs.hvoid (*truncate) (struct inode *);
inode205include/linux/fs.hvoid (*read_inode)(struct inode *inode);
inode206include/linux/fs.hvoid (*write_inode) (struct inode *inode);
inode207include/linux/fs.hvoid (*put_inode) (struct inode *inode);
inode223include/linux/fs.hextern struct inode inode_table[NR_INODE];
inode240include/linux/fs.hextern void wait_on(struct inode * inode);
inode241include/linux/fs.hextern int bmap(struct inode * inode,int block);
inode242include/linux/fs.hextern struct inode * namei(const char * pathname);
inode243include/linux/fs.hextern struct inode * lnamei(const char * pathname);
inode244include/linux/fs.hextern int permission(struct inode * inode,int mask);
inode245include/linux/fs.hextern struct inode * _namei(const char * filename, struct inode * base,
inode248include/linux/fs.hstruct inode ** res_inode);
inode250include/linux/fs.hextern void iput(struct inode * inode);
inode251include/linux/fs.hextern struct inode * iget(int dev,int nr);
inode252include/linux/fs.hextern struct inode * get_empty_inode(void);
inode253include/linux/fs.hextern struct inode * get_pipe_inode(void);
inode273include/linux/fs.hextern int char_read(struct inode *, struct file *, char *, int);
inode274include/linux/fs.hextern int block_read(struct inode *, struct file *, char *, int);
inode276include/linux/fs.hextern int char_write(struct inode *, struct file *, char *, int);
inode277include/linux/fs.hextern int block_write(struct inode *, struct file *, char *, int);
inode43include/linux/minix_fs.hunsigned short inode;
inode47include/linux/minix_fs.hextern int minix_open(struct inode * inode, struct file * filp);
inode48include/linux/minix_fs.hextern void minix_release(struct inode * inode, struct file * filp);
inode49include/linux/minix_fs.hextern int minix_lookup(struct inode * dir,const char * name, int len,
inode50include/linux/minix_fs.hstruct inode ** result);
inode51include/linux/minix_fs.hextern int minix_create(struct inode * dir,const char * name, int len, int mode,
inode52include/linux/minix_fs.hstruct inode ** result);
inode53include/linux/minix_fs.hextern int minix_mkdir(struct inode * dir, const char * name, int len, int mode);
inode54include/linux/minix_fs.hextern int minix_rmdir(struct inode * dir, const char * name, int len);
inode55include/linux/minix_fs.hextern int minix_unlink(struct inode * dir, const char * name, int len);
inode56include/linux/minix_fs.hextern int minix_symlink(struct inode * inode, const char * name, int len,
inode58include/linux/minix_fs.hextern int minix_link(struct inode * oldinode, struct inode * dir, const char * name, int len);
inode59include/linux/minix_fs.hextern int minix_mknod(struct inode * dir, const char * name, int len, int mode, int rdev);
inode60include/linux/minix_fs.hextern int minix_rename(struct inode * old_dir, const char * old_name, int old_len,
inode61include/linux/minix_fs.hstruct inode * new_dir, const char * new_name, int new_len);
inode62include/linux/minix_fs.hextern struct inode * minix_new_inode(int dev);
inode63include/linux/minix_fs.hextern void minix_free_inode(struct inode * inode);
inode69include/linux/minix_fs.hextern int minix_create_block(struct inode *, int);
inode70include/linux/minix_fs.hextern int minix_bmap(struct inode *,int);
inode72include/linux/minix_fs.hextern void minix_truncate(struct inode *);
inode75include/linux/minix_fs.hextern void minix_read_inode(struct inode *);
inode76include/linux/minix_fs.hextern void minix_write_inode(struct inode *);
inode77include/linux/minix_fs.hextern void minix_put_inode(struct inode *);
inode80include/linux/minix_fs.hextern int minix_lseek(struct inode *, struct file *, off_t, int);
inode81include/linux/minix_fs.hextern int minix_read(struct inode *, struct file *, char *, int);
inode82include/linux/minix_fs.hextern int minix_write(struct inode *, struct file *, char *, int);
inode83include/linux/minix_fs.hextern int minix_file_read(struct inode *, struct file *, char *, int);
inode47include/linux/mm.hextern struct inode * swap_file;
inode54include/linux/mouse.hstruct inode    *inode;
inode115include/linux/msdos_fs.hextern int msdos_add_cluster(struct inode *inode);
inode119include/linux/msdos_fs.hextern int msdos_get_entry(struct inode *dir,int *pos,struct buffer_head **bh,
inode121include/linux/msdos_fs.hextern int msdos_scan(struct inode *dir,char *name,struct buffer_head **res_bh,
inode123include/linux/msdos_fs.hextern int msdos_parent_ino(struct inode *dir,int locked);
inode128include/linux/msdos_fs.hextern int msdos_smap(struct inode *inode,int sector);
inode129include/linux/msdos_fs.hextern int fat_free(struct inode *inode,int skip);
inode131include/linux/msdos_fs.hvoid cache_lookup(struct inode *inode,int cluster,int *f_clu,int *d_clu);
inode132include/linux/msdos_fs.hvoid cache_add(struct inode *inode,int f_clu,int d_clu);
inode133include/linux/msdos_fs.hvoid cache_inval_inode(struct inode *inode);
inode135include/linux/msdos_fs.hint get_cluster(struct inode *inode,int cluster);
inode139include/linux/msdos_fs.hextern int msdos_lookup(struct inode *dir,const char *name,int len,
inode140include/linux/msdos_fs.hstruct inode **result);
inode141include/linux/msdos_fs.hextern int msdos_create(struct inode *dir,const char *name,int len,int mode,
inode142include/linux/msdos_fs.hstruct inode **result);
inode143include/linux/msdos_fs.hextern int msdos_mkdir(struct inode *dir,const char *name,int len,int mode);
inode144include/linux/msdos_fs.hextern int msdos_rmdir(struct inode *dir,const char *name,int len);
inode145include/linux/msdos_fs.hextern int msdos_unlink(struct inode *dir,const char *name,int len);
inode146include/linux/msdos_fs.hextern int msdos_rename(struct inode *old_dir,const char *old_name,int old_len,
inode147include/linux/msdos_fs.hstruct inode *new_dir,const char *new_name,int new_len);
inode151include/linux/msdos_fs.hextern void msdos_put_inode(struct inode *inode);
inode155include/linux/msdos_fs.hextern int msdos_bmap(struct inode *inode,int block);
inode156include/linux/msdos_fs.hextern void msdos_read_inode(struct inode *inode);
inode157include/linux/msdos_fs.hextern void msdos_write_inode(struct inode *inode);
inode170include/linux/msdos_fs.hextern void msdos_truncate(struct inode *inode);
inode153include/linux/sched.hstruct inode * pwd;
inode154include/linux/sched.hstruct inode * root;
inode155include/linux/sched.hstruct inode * executable;
inode157include/linux/sched.hstruct inode * library;
inode229include/linux/tty.hextern int tty_ioctl(struct inode *, struct file *, unsigned int, unsigned int);
inode1002kernel/blk_drv/floppy.cstatic int fd_ioctl(struct inode *inode, struct file *filp, unsigned int cmd,
inode1009kernel/blk_drv/floppy.cRO_IOCTLS(inode->i_rdev,param);
inode1012kernel/blk_drv/floppy.cdrive = MINOR(inode->i_rdev);
inode1140kernel/blk_drv/floppy.cstatic int floppy_open(struct inode * inode, struct file * filp)
inode1145kernel/blk_drv/floppy.cdrive = inode->i_rdev & 3;
inode1148kernel/blk_drv/floppy.cif (old_dev != inode->i_rdev)
inode1151kernel/blk_drv/floppy.cfd_device[drive] = inode->i_rdev;
inode1152kernel/blk_drv/floppy.cif (old_dev && old_dev != inode->i_rdev)
inode1155kernel/blk_drv/floppy.ccheck_disk_change(inode->i_rdev);
inode1159kernel/blk_drv/floppy.cstatic void floppy_release(struct inode * inode, struct file * filp)
inode1161kernel/blk_drv/floppy.csync_dev(inode->i_rdev);
inode1162kernel/blk_drv/floppy.cif (!fd_ref[inode->i_rdev & 3]--) {
inode1164kernel/blk_drv/floppy.cfd_ref[inode->i_rdev & 3] = 0;
inode446kernel/blk_drv/hd.cstatic int hd_ioctl(struct inode * inode, struct file * file,
inode452kernel/blk_drv/hd.cif (!loc || !inode)
inode454kernel/blk_drv/hd.cdev = MINOR(inode->i_rdev) >> 6;
inode466kernel/blk_drv/hd.cput_fs_long(hd[MINOR(inode->i_rdev)].start_sect,
inode469kernel/blk_drv/hd.cRO_IOCTLS(inode->i_rdev,arg);
inode479kernel/blk_drv/hd.cstatic void hd_release(struct inode * inode, struct file * file)
inode481kernel/blk_drv/hd.csync_dev(inode->i_rdev);
inode47kernel/blk_drv/scsi/sd.cextern int sd_ioctl(struct inode *, struct file *, unsigned long, unsigned long);
inode49kernel/blk_drv/scsi/sd.cstatic void sd_release(struct inode * inode, struct file * file)
inode51kernel/blk_drv/scsi/sd.csync_dev(inode->i_rdev);
inode11kernel/blk_drv/scsi/sd_ioctl.cint sd_ioctl(struct inode * inode, struct file * file, unsigned long cmd, unsigned long arg)
inode13kernel/blk_drv/scsi/sd_ioctl.cint dev = inode->i_rdev;
inode10kernel/blk_drv/scsi/st_ioctl.cint st_ioctl(struct inode * inode, struct file * file, unsigned long cmd, unsigned long arg)
inode12kernel/blk_drv/scsi/st_ioctl.cint dev = inode->i_rdev;
inode49kernel/chr_drv/lp.cstatic int lp_write(struct inode * inode, struct file * file, char * buf, int count)
inode52kernel/chr_drv/lp.cunsigned int minor = MINOR(inode->i_rdev);
inode82kernel/chr_drv/lp.cstatic int lp_read(struct inode * inode, struct file * file, char * buf, int count)
inode87kernel/chr_drv/lp.cstatic int lp_lseek(struct inode * inode, struct file * file, off_t offset, int origin)
inode92kernel/chr_drv/lp.cstatic int lp_open(struct inode * inode, struct file * file)
inode94kernel/chr_drv/lp.cunsigned int minor = MINOR(inode->i_rdev);
inode106kernel/chr_drv/lp.cstatic void lp_release(struct inode * inode, struct file * file)
inode108kernel/chr_drv/lp.cunsigned int minor = MINOR(inode->i_rdev);
inode17kernel/chr_drv/mem.cstatic int read_ram(struct inode * inode, struct file * file,char * buf, int count)
inode22kernel/chr_drv/mem.cstatic int write_ram(struct inode * inode, struct file * file,char * buf, int count)
inode27kernel/chr_drv/mem.cstatic int read_mem(struct inode * inode, struct file * file,char * buf, int count)
inode64kernel/chr_drv/mem.cstatic int write_mem(struct inode * inode, struct file * file,char * buf, int count)
inode109kernel/chr_drv/mem.cstatic int read_kmem(struct inode * inode, struct file * file,char * buf, int count)
inode124kernel/chr_drv/mem.cstatic int write_kmem(struct inode * inode, struct file * file,char * buf, int count)
inode139kernel/chr_drv/mem.cstatic int read_port(struct inode * inode,struct file * file,char * buf, int count)
inode153kernel/chr_drv/mem.cstatic int write_port(struct inode * inode,struct file * file,char * buf, int count)
inode167kernel/chr_drv/mem.cstatic int read_zero(struct inode *node,struct file *file,char *buf,int count)
inode186kernel/chr_drv/mem.cstatic int mem_lseek(struct inode * inode, struct file * file, off_t offset, int orig)
inode203kernel/chr_drv/mem.cstatic int mem_read(struct inode * inode, struct file * file, char * buf, int count)
inode205kernel/chr_drv/mem.cswitch (MINOR(inode->i_rdev)) {
inode207kernel/chr_drv/mem.creturn read_ram(inode,file,buf,count);
inode209kernel/chr_drv/mem.creturn read_mem(inode,file,buf,count);
inode211kernel/chr_drv/mem.creturn read_kmem(inode,file,buf,count);
inode215kernel/chr_drv/mem.creturn read_port(inode,file,buf,count);
inode217kernel/chr_drv/mem.creturn read_zero(inode,file,buf,count);
inode223kernel/chr_drv/mem.cstatic int mem_write(struct inode * inode, struct file * file, char * buf, int count)
inode225kernel/chr_drv/mem.cswitch (MINOR(inode->i_rdev)) {
inode227kernel/chr_drv/mem.creturn write_ram(inode,file,buf,count);
inode229kernel/chr_drv/mem.creturn write_mem(inode,file,buf,count);
inode231kernel/chr_drv/mem.creturn write_kmem(inode,file,buf,count);
inode235kernel/chr_drv/mem.creturn write_port(inode,file,buf,count);
inode59kernel/chr_drv/mouse.cif (mouse.inode && mouse.inode->i_wait)
inode60kernel/chr_drv/mouse.cwake_up(&mouse.inode->i_wait);
inode65kernel/chr_drv/mouse.cstatic void release_mouse(struct inode * inode, struct file * file)
inode70kernel/chr_drv/mouse.cmouse.inode = NULL;
inode74kernel/chr_drv/mouse.cstatic int open_mouse(struct inode * inode, struct file * file)
inode82kernel/chr_drv/mouse.cmouse.inode = inode;
inode91kernel/chr_drv/mouse.cmouse.inode = NULL;
inode97kernel/chr_drv/mouse.cstatic int write_mouse(struct inode * inode, struct file * file, char * buffer, int count)
inode102kernel/chr_drv/mouse.cstatic int read_mouse(struct inode * inode, struct file * file, char * buffer, int count)
inode135kernel/chr_drv/mouse.cstatic int mouse_select(struct inode *inode, struct file *file, int sel_type, select_table * wait)
inode141kernel/chr_drv/mouse.cselect_wait(&inode->i_wait,wait);
inode461kernel/chr_drv/tty_io.cstatic int tty_read(struct inode * inode, struct file * file, char * buf, int count)
inode471kernel/chr_drv/tty_io.cinode->i_atime = CURRENT_TIME;
inode475kernel/chr_drv/tty_io.cstatic int tty_write(struct inode * inode, struct file * file, char * buf, int count)
inode485kernel/chr_drv/tty_io.cinode->i_mtime = CURRENT_TIME;
inode489kernel/chr_drv/tty_io.cstatic int tty_lseek(struct inode * inode, struct file * file, off_t offset, int orig)
inode502kernel/chr_drv/tty_io.cstatic int tty_open(struct inode * inode, struct file * filp)
inode507kernel/chr_drv/tty_io.cdev = inode->i_rdev;
inode554kernel/chr_drv/tty_io.cstatic void tty_release(struct inode * inode, struct file * filp)
inode583kernel/chr_drv/tty_io.cstatic int tty_select(struct inode * inode, struct file * filp, int sel_type, select_table * wait)
inode229kernel/chr_drv/tty_ioctl.cint tty_ioctl(struct inode * inode, struct file * file,
inode608mm/memory.cstatic int share_page(struct inode * inode, unsigned long address)
inode613mm/memory.cif (!inode || inode->i_count < 2)
inode621mm/memory.cif (inode != (*p)->executable)
inode625mm/memory.cif (inode == (*p)->libraries[i].library)
inode670mm/memory.cstruct inode * inode;
inode698mm/memory.cinode = NULL;
inode701mm/memory.cinode = tsk->executable;
inode711mm/memory.cinode = tsk->libraries[i].library;
inode716mm/memory.cif (!inode) {
inode729mm/memory.cif (share_page(inode,tmp)) {
inode741mm/memory.cnr[i] = bmap(inode,block);
inode742mm/memory.cbread_page(page,inode->i_dev,nr);
inode45mm/mmap.cstruct inode *inode, unsigned long off)
inode49mm/mmap.cmajor = MAJOR(inode->i_rdev);
inode50mm/mmap.cminor = MINOR(inode->i_rdev);
inode92mm/mmap.cstruct inode *inode;
inode105mm/mmap.cinode = file->f_inode;
inode170mm/mmap.cif (S_ISCHR(inode->i_mode))
inode172mm/mmap.cinode, off);
inode48mm/swap.cstruct inode * swap_file = NULL;
inode307mm/swap.cstruct inode * swap_inode;
inode40net/socket.cstatic int sock_lseek(struct inode *inode, struct file *file, off_t offset,
inode42net/socket.cstatic int sock_read(struct inode *inode, struct file *file, char *buf,
inode44net/socket.cstatic int sock_write(struct inode *inode, struct file *file, char *buf,
inode46net/socket.cstatic int sock_readdir(struct inode *inode, struct file *file,
inode48net/socket.cstatic void sock_close(struct inode *inode, struct file *file);
inode49net/socket.cstatic int sock_select(struct inode *inode, struct file *file, int which, select_table *seltable);
inode50net/socket.cstatic int sock_ioctl(struct inode *inode, struct file *file,
inode64net/socket.c#define SOCK_INODE(S) ((struct inode *)(S)->dummy)
inode74net/socket.cget_fd(struct inode *inode)
inode98net/socket.cfile->f_inode = inode;
inode116net/socket.csocki_lookup(struct inode *inode)
inode121net/socket.cif (sock->state != SS_FREE && SOCK_INODE(sock) == inode)
inode225net/socket.csock_lseek(struct inode *inode, struct file *file, off_t offset, int whence)
inode232net/socket.csock_read(struct inode *inode, struct file *file, char *ubuf, int size)
inode237net/socket.cif (!(sock = socki_lookup(inode))) {
inode247net/socket.csock_write(struct inode *inode, struct file *file, char *ubuf, int size)
inode252net/socket.cif (!(sock = socki_lookup(inode))) {
inode262net/socket.csock_readdir(struct inode *inode, struct file *file, struct dirent *dirent,
inode270net/socket.csock_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
inode275net/socket.cPRINTK("sock_ioctl: inode=0x%x cmd=0x%x arg=%d\n", inode, cmd, arg);
inode276net/socket.cif (!(sock = socki_lookup(inode))) {
inode294net/socket.csock_select(struct inode *inode, struct file *file, int sel_type, select_table * wait)
inode298net/socket.cPRINTK("sock_select: inode = 0x%x, kind = %s\n", inode,
inode301net/socket.cif (!(sock = socki_lookup(inode))) {
inode315net/socket.cselect_wait(&inode->i_wait, wait);
inode319net/socket.cselect_wait(&inode->i_wait, wait);
inode331net/socket.csock_close(struct inode *inode, struct file *file)
inode335net/socket.cPRINTK("sock_close: inode=0x%x (cnt=%d)\n", inode, inode->i_count);
inode340net/socket.cif (!inode)
inode342net/socket.cif (!(sock = socki_lookup(inode))) {
inode25net/unix.cstruct inode *inode;
inode126net/unix.cupd->inode = NULL;
inode207net/unix.cif (upd->inode) {
inode209net/unix.cupd->inode);
inode210net/unix.ciput(upd->inode);
inode211net/unix.cupd->inode = NULL;
inode246net/unix.cif (upd->sockaddr_len || upd->inode) {
inode264net/unix.ci = open_namei(fname, 0, S_IFSOCK, &upd->inode);