taglinefilesource code
inode16fs/block_dev.cint block_write(struct inode * inode, struct file * filp, char * buf, int count)
inode27fs/block_dev.cdev = inode->i_rdev;
inode62fs/block_dev.cint block_read(struct inode * inode, struct file * filp, char * buf, int count)
inode76fs/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;
inode84fs/exec.cif (open_namei("core",O_CREAT | O_WRONLY | O_TRUNC,0600,&inode,NULL)) {
inode85fs/exec.cinode = NULL;
inode88fs/exec.cif (!S_ISREG(inode->i_mode))
inode90fs/exec.cif (!inode->i_op || !inode->i_op->default_file_ops)
inode95fs/exec.cfile.f_inode = inode;
inode98fs/exec.cfile.f_op = inode->i_op->default_file_ops;
inode100fs/exec.cif (file.f_op->open(inode,&file))
inode168fs/exec.cfile.f_op->release(inode,&file);
inode171fs/exec.ciput(inode);
inode184fs/exec.cstruct inode * inode;
inode193fs/exec.cerror = namei(library,&inode);
inode196fs/exec.cif (!inode->i_sb || !S_ISREG(inode->i_mode) || !permission(inode,MAY_READ)) {
inode197fs/exec.ciput(inode);
inode200fs/exec.cif (!inode->i_op || !inode->i_op->bmap) {
inode201fs/exec.ciput(inode);
inode204fs/exec.cif (!(bh = bread(inode->i_dev,bmap(inode,0),inode->i_sb->s_blocksize))) {
inode205fs/exec.ciput(inode);
inode208fs/exec.cif (!IS_RDONLY(inode)) {
inode209fs/exec.cinode->i_atime = CURRENT_TIME;
inode210fs/exec.cinode->i_dirt = 1;
inode216fs/exec.cinode->i_size < ex.a_text+ex.a_data+ex.a_syms+N_TXTOFF(ex)) {
inode217fs/exec.ciput(inode);
inode220fs/exec.ccurrent->libraries[libnum].library = inode;
inode380fs/exec.cstatic int read_exec(struct inode *inode, unsigned long offset,
inode386fs/exec.cif (!inode->i_op || !inode->i_op->default_file_ops)
inode391fs/exec.cfile.f_inode = inode;
inode394fs/exec.cfile.f_op = inode->i_op->default_file_ops;
inode396fs/exec.cif (file.f_op->open(inode,&file))
inode401fs/exec.cif (file.f_op->lseek(inode,&file,offset,0) != offset)
inode405fs/exec.cresult = file.f_op->read(inode, &file, addr, count);
inode408fs/exec.cfile.f_op->release(inode,&file);
inode422fs/exec.cstruct inode * inode;
inode438fs/exec.cretval = namei(filename,&inode);  /* get executable inode */
inode445fs/exec.cif (!S_ISREG(inode->i_mode)) {  /* must be regular file */
inode449fs/exec.cif (IS_NOEXEC(inode)) {    /* FS mustn't be mounted noexec */
inode453fs/exec.cif (!inode->i_sb) {
inode457fs/exec.ci = inode->i_mode;
inode458fs/exec.cif (IS_NOSUID(inode) && (((i & S_ISUID) && inode->i_uid != current->
inode459fs/exec.ceuid) || ((i & S_ISGID) && inode->i_gid != current->egid)) &&
inode469fs/exec.ce_uid = (i & S_ISUID) ? inode->i_uid : current->euid;
inode470fs/exec.ce_gid = (i & S_ISGID) ? inode->i_gid : current->egid;
inode472fs/exec.cif (current->euid == inode->i_uid)
inode474fs/exec.celse if (in_group_p(inode->i_gid))
inode477fs/exec.c!((inode->i_mode & 0111) && suser())) {
inode484fs/exec.cretval = read_exec(inode,0,buf,128);
inode497fs/exec.ciput(inode);
inode557fs/exec.cretval = namei(interp,&inode);
inode566fs/exec.cinode->i_size < ex.a_text+ex.a_data+ex.a_syms+N_TXTOFF(ex)) {
inode602fs/exec.c!permission(inode,MAY_READ))
inode631fs/exec.cread_exec(inode, 32, (char *) 0, ex.a_text+ex.a_data);
inode632fs/exec.ciput(inode);
inode633fs/exec.c} else if (!inode->i_op || !inode->i_op->bmap) {
inode634fs/exec.cread_exec(inode, 1024, (char *) 0, ex.a_text+ex.a_data);
inode635fs/exec.ciput(inode);
inode637fs/exec.ccurrent->executable = inode;
inode644fs/exec.ciput(inode);
inode23fs/ext/blkdev.cstatic int blkdev_open(struct inode * inode, struct file * filp)
inode27fs/ext/blkdev.ci = MAJOR(inode->i_rdev);
inode32fs/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);
inode32fs/ext/chrdev.creturn filp->f_op->open(inode,filp);
inode23fs/ext/dir.cstatic int ext_dir_read(struct inode * inode, struct file * filp, char * buf, int count)
inode28fs/ext/dir.cstatic int ext_readdir(struct inode *, struct file *, struct dirent *, int);
inode63fs/ext/dir.cstatic int ext_readdir(struct inode * inode, struct file * filp,
inode71fs/ext/dir.cif (!inode || !S_ISDIR(inode->i_mode))
inode75fs/ext/dir.cwhile (filp->f_pos < inode->i_size) {
inode77fs/ext/dir.cbh = ext_bread(inode,(filp->f_pos)>>BLOCK_SIZE_BITS,0);
inode83fs/ext/dir.cwhile (offset < 1024 && filp->f_pos < inode->i_size) {
inode89fs/ext/dir.cinode->i_dev, inode->i_ino, offset, de->rec_len, de->name_len);
inode91fs/ext/dir.cif (filp->f_pos > inode->i_size)
inode92fs/ext/dir.cfilp->f_pos = inode->i_size;
inode97fs/ext/dir.cif (de->inode) {
inode104fs/ext/dir.cput_fs_long(de->inode,&dirent->d_ino);
inode34fs/ext/file.cstatic int ext_file_read(struct inode *, struct file *, char *, int);
inode35fs/ext/file.cstatic int ext_file_write(struct inode *, struct file *, char *, int);
inode71fs/ext/file.cstatic int ext_file_read(struct inode * inode, struct file * filp, char * buf, int count)
inode81fs/ext/file.cif (!inode) {
inode85fs/ext/file.cif (!S_ISREG(inode->i_mode)) {
inode86fs/ext/file.cprintk("ext_file_read: mode = %07o\n",inode->i_mode);
inode90fs/ext/file.csize = inode->i_size;
inode106fs/ext/file.cblocks += read_ahead[MAJOR(inode->i_dev)] / (BLOCK_SIZE >> 9);
inode126fs/ext/file.c*bhb = ext_getblk(inode, block++, 0);
inode185fs/ext/file.cif (!IS_RDONLY(inode)) {
inode186fs/ext/file.cinode->i_atime = CURRENT_TIME;
inode187fs/ext/file.cinode->i_dirt = 1;
inode192fs/ext/file.cstatic int ext_file_write(struct inode * inode, struct file * filp, char * buf, int count)
inode199fs/ext/file.cif (!inode) {
inode203fs/ext/file.cif (!S_ISREG(inode->i_mode)) {
inode204fs/ext/file.cprintk("ext_file_write: mode = %07o\n",inode->i_mode);
inode212fs/ext/file.cpos = inode->i_size;
inode217fs/ext/file.cbh = ext_getblk(inode,pos/BLOCK_SIZE,1);
inode238fs/ext/file.cif (pos > inode->i_size) {
inode239fs/ext/file.cinode->i_size = pos;
inode240fs/ext/file.cinode->i_dirt = 1;
inode249fs/ext/file.cinode->i_mtime = CURRENT_TIME;
inode250fs/ext/file.cinode->i_ctime = CURRENT_TIME;
inode252fs/ext/file.cinode->i_dirt = 1;
inode176fs/ext/freelists.cvoid ext_free_inode(struct inode * inode)
inode182fs/ext/freelists.cif (!inode)
inode184fs/ext/freelists.cif (!inode->i_dev) {
inode188fs/ext/freelists.cif (inode->i_count != 1) {
inode189fs/ext/freelists.cprintk("free_inode: inode has count=%d\n",inode->i_count);
inode192fs/ext/freelists.cif (inode->i_nlink) {
inode193fs/ext/freelists.cprintk("free_inode: inode has nlink=%d\n",inode->i_nlink);
inode196fs/ext/freelists.cif (!inode->i_sb) {
inode200fs/ext/freelists.clock_super (inode->i_sb);
inode201fs/ext/freelists.cif (inode->i_ino < 1 || inode->i_ino > inode->i_sb->u.ext_sb.s_ninodes) {
inode203fs/ext/freelists.cunlock_super (inode->i_sb);
inode206fs/ext/freelists.cif (inode->i_sb->u.ext_sb.s_firstfreeinodeblock)
inode207fs/ext/freelists.cefi = ((struct ext_free_inode *) inode->i_sb->u.ext_sb.s_firstfreeinodeblock->b_data) +
inode208fs/ext/freelists.c(inode->i_sb->u.ext_sb.s_firstfreeinodenumber-1)%EXT_INODES_PER_BLOCK;
inode209fs/ext/freelists.cif (!inode->i_sb->u.ext_sb.s_firstfreeinodeblock || efi->count == 14) {
inode211fs/ext/freelists.cprintk("ext_free_inode: inode full, skipping to %d\n", inode->i_ino);
inode213fs/ext/freelists.cif (inode->i_sb->u.ext_sb.s_firstfreeinodeblock)
inode214fs/ext/freelists.cbrelse (inode->i_sb->u.ext_sb.s_firstfreeinodeblock);
inode215fs/ext/freelists.cblock = 2 + (inode->i_ino - 1) / EXT_INODES_PER_BLOCK;
inode216fs/ext/freelists.cif (!(bh = bread(inode->i_dev, block, inode->i_sb->s_blocksize)))
inode219fs/ext/freelists.c(inode->i_ino - 1) % EXT_INODES_PER_BLOCK;
inode220fs/ext/freelists.cefi->next = inode->i_sb->u.ext_sb.s_firstfreeinodenumber;
inode222fs/ext/freelists.cinode->i_sb->u.ext_sb.s_firstfreeinodenumber = inode->i_ino;
inode223fs/ext/freelists.cinode->i_sb->u.ext_sb.s_firstfreeinodeblock = bh;
inode225fs/ext/freelists.cefi->free[efi->count++] = inode->i_ino;
inode227fs/ext/freelists.cinode->i_sb->u.ext_sb.s_freeinodescount ++;
inode228fs/ext/freelists.cinode->i_sb->s_dirt = 1;
inode229fs/ext/freelists.cinode->i_sb->u.ext_sb.s_firstfreeinodeblock->b_dirt = 1;
inode230fs/ext/freelists.cunlock_super (inode->i_sb);
inode231fs/ext/freelists.cclear_inode(inode);
inode234fs/ext/freelists.cstruct inode * ext_new_inode(const struct inode * dir)
inode237fs/ext/freelists.cstruct inode * inode;
inode242fs/ext/freelists.cif (!dir || !(inode=get_empty_inode()))
inode245fs/ext/freelists.cinode->i_sb = sb;
inode246fs/ext/freelists.cinode->i_flags = sb->s_flags;
inode277fs/ext/freelists.cinode->i_count = 1;
inode278fs/ext/freelists.cinode->i_nlink = 1;
inode279fs/ext/freelists.cinode->i_dev = sb->s_dev;
inode280fs/ext/freelists.cinode->i_uid = current->euid;
inode281fs/ext/freelists.cinode->i_gid = (dir->i_mode & S_ISGID) ? dir->i_gid : current->egid;
inode282fs/ext/freelists.cinode->i_dirt = 1;
inode283fs/ext/freelists.cinode->i_ino = j;
inode284fs/ext/freelists.cinode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
inode285fs/ext/freelists.cinode->i_op = NULL;
inode286fs/ext/freelists.cinode->i_blocks = inode->i_blksize = 0;
inode288fs/ext/freelists.cprintk("ext_new_inode : allocating inode %d\n", inode->i_ino);
inode291fs/ext/freelists.creturn inode;
inode24fs/ext/inode.cvoid ext_put_inode(struct inode *inode)
inode26fs/ext/inode.cif (inode->i_nlink)
inode28fs/ext/inode.cinode->i_size = 0;
inode29fs/ext/inode.cext_truncate(inode);
inode30fs/ext/inode.cext_free_inode(inode);
inode157fs/ext/inode.c#define inode_bmap(inode,nr) ((inode)->u.ext_i.i_data[(nr)])
inode170fs/ext/inode.cint ext_bmap(struct inode * inode,int block)
inode183fs/ext/inode.creturn inode_bmap(inode,block);
inode186fs/ext/inode.ci = inode_bmap(inode,9);
inode189fs/ext/inode.creturn block_bmap(bread(inode->i_dev,i,BLOCK_SIZE),block);
inode193fs/ext/inode.ci = inode_bmap(inode,10);
inode196fs/ext/inode.ci = block_bmap(bread(inode->i_dev,i,BLOCK_SIZE),block>>8);
inode199fs/ext/inode.creturn block_bmap(bread(inode->i_dev,i,BLOCK_SIZE),block & 255);
inode202fs/ext/inode.ci = inode_bmap(inode,11);
inode205fs/ext/inode.ci = block_bmap(bread(inode->i_dev,i,BLOCK_SIZE),block>>16);
inode208fs/ext/inode.ci = block_bmap(bread(inode->i_dev,i,BLOCK_SIZE),(block>>8) & 255);
inode211fs/ext/inode.creturn block_bmap(bread(inode->i_dev,i,BLOCK_SIZE),block & 255);
inode214fs/ext/inode.cstatic struct buffer_head * inode_getblk(struct inode * inode, int nr, int create)
inode220fs/ext/inode.cp = inode->u.ext_i.i_data + nr;
inode224fs/ext/inode.cresult = getblk(inode->i_dev, tmp, BLOCK_SIZE);
inode232fs/ext/inode.ctmp = ext_new_block(inode->i_sb);
inode235fs/ext/inode.cresult = getblk(inode->i_dev, tmp, BLOCK_SIZE);
inode237fs/ext/inode.cext_free_block(inode->i_sb,tmp);
inode242fs/ext/inode.cinode->i_ctime = CURRENT_TIME;
inode243fs/ext/inode.cinode->i_dirt = 1;
inode247fs/ext/inode.cstatic struct buffer_head * block_getblk(struct inode * inode,
inode280fs/ext/inode.ctmp = ext_new_block(inode->i_sb);
inode287fs/ext/inode.cext_free_block(inode->i_sb,tmp);
inode297fs/ext/inode.cstruct buffer_head * ext_getblk(struct inode * inode, int block, int create)
inode310fs/ext/inode.creturn inode_getblk(inode,block,create);
inode313fs/ext/inode.cbh = inode_getblk(inode,9,create);
inode314fs/ext/inode.creturn block_getblk(inode,bh,block,create);
inode318fs/ext/inode.cbh = inode_getblk(inode,10,create);
inode319fs/ext/inode.cbh = block_getblk(inode,bh,block>>8,create);
inode320fs/ext/inode.creturn block_getblk(inode,bh,block & 255,create);
inode323fs/ext/inode.cbh = inode_getblk(inode,11,create);
inode324fs/ext/inode.cbh = block_getblk(inode,bh,block>>16,create);
inode325fs/ext/inode.cbh = block_getblk(inode,bh,(block>>8) & 255,create);
inode326fs/ext/inode.creturn block_getblk(inode,bh,block & 255,create);
inode329fs/ext/inode.cstruct buffer_head * ext_bread(struct inode * inode, int block, int create)
inode333fs/ext/inode.cbh = ext_getblk(inode,block,create);
inode344fs/ext/inode.cvoid ext_read_inode(struct inode * inode)
inode350fs/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.cinode->i_blocks = inode->i_blksize = 0;
inode362fs/ext/inode.cif (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
inode363fs/ext/inode.cinode->i_rdev = raw_inode->i_zone[0];
inode365fs/ext/inode.cinode->u.ext_i.i_data[block] = raw_inode->i_zone[block];
inode367fs/ext/inode.cinode->i_op = NULL;
inode368fs/ext/inode.cif (S_ISREG(inode->i_mode))
inode369fs/ext/inode.cinode->i_op = &ext_file_inode_operations;
inode370fs/ext/inode.celse if (S_ISDIR(inode->i_mode))
inode371fs/ext/inode.cinode->i_op = &ext_dir_inode_operations;
inode372fs/ext/inode.celse if (S_ISLNK(inode->i_mode))
inode373fs/ext/inode.cinode->i_op = &ext_symlink_inode_operations;
inode374fs/ext/inode.celse if (S_ISCHR(inode->i_mode))
inode375fs/ext/inode.cinode->i_op = &ext_chrdev_inode_operations;
inode376fs/ext/inode.celse if (S_ISBLK(inode->i_mode))
inode377fs/ext/inode.cinode->i_op = &ext_blkdev_inode_operations;
inode378fs/ext/inode.celse if (S_ISFIFO(inode->i_mode)) {
inode379fs/ext/inode.cinode->i_op = &ext_fifo_inode_operations;
inode380fs/ext/inode.cinode->i_pipe = 1;
inode381fs/ext/inode.cPIPE_BASE(*inode) = NULL;
inode382fs/ext/inode.cPIPE_HEAD(*inode) = PIPE_TAIL(*inode) = 0;
inode383fs/ext/inode.cPIPE_READ_WAIT(*inode) = PIPE_WRITE_WAIT(*inode) = NULL;
inode384fs/ext/inode.cPIPE_READERS(*inode) = PIPE_WRITERS(*inode) = 0;
inode388fs/ext/inode.cvoid ext_write_inode(struct inode * inode)
inode394fs/ext/inode.cblock = 2 + (inode->i_ino-1)/EXT_INODES_PER_BLOCK;
inode395fs/ext/inode.cif (!(bh=bread(inode->i_dev, block, BLOCK_SIZE)))
inode398fs/ext/inode.c(inode->i_ino-1)%EXT_INODES_PER_BLOCK;
inode399fs/ext/inode.craw_inode->i_mode = inode->i_mode;
inode400fs/ext/inode.craw_inode->i_uid = inode->i_uid;
inode401fs/ext/inode.craw_inode->i_gid = inode->i_gid;
inode402fs/ext/inode.craw_inode->i_nlinks = inode->i_nlink;
inode403fs/ext/inode.craw_inode->i_size = inode->i_size;
inode404fs/ext/inode.craw_inode->i_time = inode->i_mtime;
inode405fs/ext/inode.cif (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
inode406fs/ext/inode.craw_inode->i_zone[0] = inode->i_rdev;
inode408fs/ext/inode.craw_inode->i_zone[block] = inode->u.ext_i.i_data[block];
inode410fs/ext/inode.cinode->i_dirt=0;
inode60fs/ext/namei.cif (!de || !de->inode || len > EXT_NAME_LEN)
inode87fs/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,
inode242fs/ext/namei.cde->inode = 0;
inode263fs/ext/namei.cde->inode=0;
inode278fs/ext/namei.cif (!de->inode && de->rec_len >= rec_len) {
inode286fs/ext/namei.cde1->inode = 0;
inode306fs/ext/namei.cint ext_create(struct inode * dir,const char * name, int len, int mode,
inode307fs/ext/namei.cstruct inode ** result)
inode309fs/ext/namei.cstruct inode * inode;
inode316fs/ext/namei.cinode = ext_new_inode(dir);
inode317fs/ext/namei.cif (!inode) {
inode321fs/ext/namei.cinode->i_op = &ext_file_inode_operations;
inode322fs/ext/namei.cinode->i_mode = mode;
inode323fs/ext/namei.cinode->i_dirt = 1;
inode326fs/ext/namei.cinode->i_nlink--;
inode327fs/ext/namei.cinode->i_dirt = 1;
inode328fs/ext/namei.ciput(inode);
inode332fs/ext/namei.cde->inode = inode->i_ino;
inode336fs/ext/namei.c*result = inode;
inode340fs/ext/namei.cint ext_mknod(struct inode * dir, const char * name, int len, int mode, int rdev)
inode342fs/ext/namei.cstruct inode * inode;
inode354fs/ext/namei.cinode = ext_new_inode(dir);
inode355fs/ext/namei.cif (!inode) {
inode359fs/ext/namei.cinode->i_uid = current->euid;
inode360fs/ext/namei.cinode->i_mode = mode;
inode361fs/ext/namei.cinode->i_op = NULL;
inode362fs/ext/namei.cif (S_ISREG(inode->i_mode))
inode363fs/ext/namei.cinode->i_op = &ext_file_inode_operations;
inode364fs/ext/namei.celse if (S_ISDIR(inode->i_mode)) {
inode365fs/ext/namei.cinode->i_op = &ext_dir_inode_operations;
inode367fs/ext/namei.cinode->i_mode |= S_ISGID;
inode369fs/ext/namei.celse if (S_ISLNK(inode->i_mode))
inode370fs/ext/namei.cinode->i_op = &ext_symlink_inode_operations;
inode371fs/ext/namei.celse if (S_ISCHR(inode->i_mode))
inode372fs/ext/namei.cinode->i_op = &ext_chrdev_inode_operations;
inode373fs/ext/namei.celse if (S_ISBLK(inode->i_mode))
inode374fs/ext/namei.cinode->i_op = &ext_blkdev_inode_operations;
inode375fs/ext/namei.celse if (S_ISFIFO(inode->i_mode)) {
inode376fs/ext/namei.cinode->i_op = &ext_fifo_inode_operations;
inode377fs/ext/namei.cinode->i_pipe = 1;
inode378fs/ext/namei.cPIPE_BASE(*inode) = NULL;
inode379fs/ext/namei.cPIPE_HEAD(*inode) = PIPE_TAIL(*inode) = 0;
inode380fs/ext/namei.cPIPE_READ_WAIT(*inode) = PIPE_WRITE_WAIT(*inode) = NULL;
inode381fs/ext/namei.cPIPE_READERS(*inode) = PIPE_WRITERS(*inode) = 0;
inode384fs/ext/namei.cinode->i_rdev = rdev;
inode385fs/ext/namei.cinode->i_mtime = inode->i_atime = CURRENT_TIME;
inode386fs/ext/namei.cinode->i_dirt = 1;
inode389fs/ext/namei.cinode->i_nlink--;
inode390fs/ext/namei.cinode->i_dirt = 1;
inode391fs/ext/namei.ciput(inode);
inode395fs/ext/namei.cde->inode = inode->i_ino;
inode399fs/ext/namei.ciput(inode);
inode403fs/ext/namei.cint ext_mkdir(struct inode * dir, const char * name, int len, int mode)
inode405fs/ext/namei.cstruct inode * inode;
inode415fs/ext/namei.cinode = ext_new_inode(dir);
inode416fs/ext/namei.cif (!inode) {
inode420fs/ext/namei.cinode->i_op = &ext_dir_inode_operations;
inode421fs/ext/namei.cinode->i_size = 2 * 16; /* Each entry is coded on 16 bytes for "." and ".."
inode426fs/ext/namei.cinode->i_mtime = inode->i_atime = CURRENT_TIME;
inode427fs/ext/namei.cdir_block = ext_bread(inode,0,1);
inode430fs/ext/namei.cinode->i_nlink--;
inode431fs/ext/namei.cinode->i_dirt = 1;
inode432fs/ext/namei.ciput(inode);
inode436fs/ext/namei.cde->inode=inode->i_ino;
inode441fs/ext/namei.cde->inode = dir->i_ino;
inode445fs/ext/namei.cinode->i_nlink = 2;
inode448fs/ext/namei.cinode->i_mode = S_IFDIR | (mode & 0777 & ~current->umask);
inode450fs/ext/namei.cinode->i_mode |= S_ISGID;
inode451fs/ext/namei.cinode->i_dirt = 1;
inode455fs/ext/namei.cinode->i_nlink=0;
inode456fs/ext/namei.ciput(inode);
inode459fs/ext/namei.cde->inode = inode->i_ino;
inode464fs/ext/namei.ciput(inode);
inode472fs/ext/namei.cstatic int empty_dir(struct inode * inode)
inode478fs/ext/namei.cif (inode->i_size < 2 * 12 || !(bh = ext_bread(inode,0,0))) {
inode479fs/ext/namei.cprintk("warning - bad directory on dev %04x\n",inode->i_dev);
inode484fs/ext/namei.cif (de->inode != inode->i_ino || !de1->inode || 
inode486fs/ext/namei.cprintk("warning - bad directory on dev %04x\n",inode->i_dev);
inode491fs/ext/namei.cwhile (offset < inode->i_size ) {
inode494fs/ext/namei.cbh = ext_bread(inode, offset >> BLOCK_SIZE_BITS,1);
inode505fs/ext/namei.cinode->i_dev, inode->i_ino, offset, de->rec_len, de->name_len);
inode509fs/ext/namei.cif (de->inode) {
inode523fs/ext/namei.cif (nde && !nde->inode)
inode525fs/ext/namei.cif (pde && !pde->inode)
inode529fs/ext/namei.cint ext_rmdir(struct inode * dir, const char * name, int len)
inode532fs/ext/namei.cstruct inode * inode;
inode536fs/ext/namei.cinode = NULL;
inode542fs/ext/namei.cif (!(inode = iget(dir->i_sb, de->inode)))
inode545fs/ext/namei.cinode->i_uid != current->euid)
inode547fs/ext/namei.cif (inode->i_dev != dir->i_dev)
inode549fs/ext/namei.cif (inode == dir)  /* we may not delete ".", but "../dir" is ok */
inode551fs/ext/namei.cif (!S_ISDIR(inode->i_mode)) {
inode555fs/ext/namei.cif (!empty_dir(inode)) {
inode559fs/ext/namei.cif (inode->i_count > 1) {
inode563fs/ext/namei.cif (inode->i_nlink != 2)
inode564fs/ext/namei.cprintk("empty directory has nlink!=2 (%d)\n",inode->i_nlink);
inode565fs/ext/namei.cde->inode = 0;
inode569fs/ext/namei.cinode->i_nlink=0;
inode570fs/ext/namei.cinode->i_dirt=1;
inode577fs/ext/namei.ciput(inode);
inode582fs/ext/namei.cint ext_unlink(struct inode * dir, const char * name, int len)
inode585fs/ext/namei.cstruct inode * inode;
inode590fs/ext/namei.cinode = NULL;
inode594fs/ext/namei.cif (!(inode = iget(dir->i_sb, de->inode)))
inode598fs/ext/namei.ccurrent->euid != inode->i_uid &&
inode601fs/ext/namei.cif (S_ISDIR(inode->i_mode))
inode603fs/ext/namei.cif (!inode->i_nlink) {
inode605fs/ext/namei.cinode->i_dev,inode->i_ino,inode->i_nlink);
inode606fs/ext/namei.cinode->i_nlink=1;
inode608fs/ext/namei.cde->inode = 0;
inode612fs/ext/namei.cinode->i_nlink--;
inode613fs/ext/namei.cinode->i_dirt = 1;
inode614fs/ext/namei.cinode->i_ctime = CURRENT_TIME;
inode618fs/ext/namei.ciput(inode);
inode623fs/ext/namei.cint ext_symlink(struct inode * dir, const char * name, int len, const char * symname)
inode626fs/ext/namei.cstruct inode * inode = NULL;
inode631fs/ext/namei.cif (!(inode = ext_new_inode(dir))) {
inode635fs/ext/namei.cinode->i_mode = S_IFLNK | 0777;
inode636fs/ext/namei.cinode->i_op = &ext_symlink_inode_operations;
inode637fs/ext/namei.cname_block = ext_bread(inode,0,1);
inode640fs/ext/namei.cinode->i_nlink--;
inode641fs/ext/namei.cinode->i_dirt = 1;
inode642fs/ext/namei.ciput(inode);
inode651fs/ext/namei.cinode->i_size = i;
inode652fs/ext/namei.cinode->i_dirt = 1;
inode655fs/ext/namei.cinode->i_nlink--;
inode656fs/ext/namei.cinode->i_dirt = 1;
inode657fs/ext/namei.ciput(inode);
inode664fs/ext/namei.cinode->i_nlink--;
inode665fs/ext/namei.cinode->i_dirt = 1;
inode666fs/ext/namei.ciput(inode);
inode670fs/ext/namei.cde->inode = inode->i_ino;
inode674fs/ext/namei.ciput(inode);
inode678fs/ext/namei.cint ext_link(struct inode * oldinode, struct inode * dir, const char * name, int len)
inode706fs/ext/namei.cde->inode = oldinode->i_ino;
inode717fs/ext/namei.cstatic int subdir(struct inode * new, struct inode * old)
inode747fs/ext/namei.c((struct ext_dir_entry *) buffer)->rec_len))->inode
inode763fs/ext/namei.cstatic int do_ext_rename(struct inode * old_dir, const char * old_name, int old_len,
inode764fs/ext/namei.cstruct inode * new_dir, const char * new_name, int new_len)
inode766fs/ext/namei.cstruct inode * old_inode, * new_inode;
inode787fs/ext/namei.cold_inode = iget(old_dir->i_sb, old_de->inode);
inode797fs/ext/namei.cnew_inode = iget(new_dir->i_sb, new_de->inode);
inode839fs/ext/namei.cif (new_inode && (new_de->inode != new_inode->i_ino))
inode841fs/ext/namei.cif (new_de->inode && !new_inode)
inode843fs/ext/namei.cif (old_de->inode != old_inode->i_ino)
inode846fs/ext/namei.cold_de->inode = 0;
inode848fs/ext/namei.cnew_de->inode = old_inode->i_ino;
inode885fs/ext/namei.cint ext_rename(struct inode * old_dir, const char * old_name, int old_len,
inode886fs/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 int ext_follow_link(struct inode *, struct inode *, int, int, struct inode **);
inode47fs/ext/symlink.cstatic int ext_follow_link(struct inode * dir, struct inode * inode,
inode48fs/ext/symlink.cint flag, int mode, struct inode ** res_inode)
inode59fs/ext/symlink.cif (!inode) {
inode63fs/ext/symlink.cif (!S_ISLNK(inode->i_mode)) {
inode65fs/ext/symlink.c*res_inode = inode;
inode70fs/ext/symlink.ciput(inode);
inode73fs/ext/symlink.cif (!(bh = ext_bread(inode, 0, 0))) {
inode74fs/ext/symlink.ciput(inode);
inode78fs/ext/symlink.ciput(inode);
inode89fs/ext/symlink.cstatic int ext_readlink(struct inode * inode, char * buffer, int buflen)
inode95fs/ext/symlink.cif (!S_ISLNK(inode->i_mode)) {
inode96fs/ext/symlink.ciput(inode);
inode101fs/ext/symlink.cbh = ext_bread(inode, 0, 0);
inode102fs/ext/symlink.ciput(inode);
inode33fs/ext/truncate.cstatic int trunc_direct(struct inode * inode)
inode39fs/ext/truncate.c#define DIRECT_BLOCK ((inode->i_size + 1023) >> 10)
inode43fs/ext/truncate.cp = inode->u.ext_i.i_data+i;
inode46fs/ext/truncate.cbh = getblk(inode->i_dev,tmp,BLOCK_SIZE);
inode57fs/ext/truncate.cinode->i_dirt = 1;
inode59fs/ext/truncate.cext_free_block(inode->i_sb,tmp);
inode64fs/ext/truncate.cstatic int trunc_indirect(struct inode * inode, int offset, unsigned long * p)
inode76fs/ext/truncate.cind_bh = bread(inode->i_dev, tmp, BLOCK_SIZE);
inode95fs/ext/truncate.cbh = getblk(inode->i_dev,tmp,BLOCK_SIZE);
inode108fs/ext/truncate.cext_free_block(inode->i_sb,tmp);
inode120fs/ext/truncate.cinode->i_dirt = 1;
inode121fs/ext/truncate.cext_free_block(inode->i_sb,tmp);
inode127fs/ext/truncate.cstatic int trunc_dindirect(struct inode * inode, int offset, unsigned long * p)
inode138fs/ext/truncate.cdind_bh = bread(inode->i_dev, tmp, BLOCK_SIZE);
inode157fs/ext/truncate.cretry |= trunc_indirect(inode,offset+(i<<8),dind);
inode170fs/ext/truncate.cinode->i_dirt = 1;
inode171fs/ext/truncate.cext_free_block(inode->i_sb,tmp);
inode177fs/ext/truncate.cstatic int trunc_tindirect(struct inode * inode)
inode185fs/ext/truncate.cp = inode->u.ext_i.i_data+11;
inode188fs/ext/truncate.ctind_bh = bread(inode->i_dev, tmp, BLOCK_SIZE);
inode204fs/ext/truncate.cretry |= trunc_dindirect(inode,9+256+256*256+(i<<16),tind);
inode217fs/ext/truncate.cinode->i_dirt = 1;
inode218fs/ext/truncate.cext_free_block(inode->i_sb,tmp);
inode224fs/ext/truncate.cvoid ext_truncate(struct inode * inode)
inode228fs/ext/truncate.cif (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
inode229fs/ext/truncate.cS_ISLNK(inode->i_mode)))
inode232fs/ext/truncate.cretry = trunc_direct(inode);
inode233fs/ext/truncate.cretry |= trunc_indirect(inode,9,inode->u.ext_i.i_data+9);
inode234fs/ext/truncate.cretry |= trunc_dindirect(inode,9+256,inode->u.ext_i.i_data+10);
inode235fs/ext/truncate.cretry |= trunc_tindirect(inode);
inode241fs/ext/truncate.cinode->i_mtime = inode->i_ctime = CURRENT_TIME;
inode242fs/ext/truncate.cinode->i_dirt = 1;
inode250fs/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 || PIPE_BASE(*inode))
inode90fs/fifo.cif (PIPE_BASE(*inode)) {
inode96fs/fifo.cPIPE_HEAD(*inode) = PIPE_TAIL(*inode) = 0;
inode97fs/fifo.cPIPE_BASE(*inode) = (char *) page;
inode15fs/inode.cstatic struct inode * inode_table;
inode16fs/inode.cstatic struct inode * last_inode;
inode23fs/inode.cinode_table = (struct inode *) start;
inode26fs/inode.cmemset(inode_table,0,NR_INODE*sizeof(struct inode));
inode30fs/inode.cstatic void __wait_on_inode(struct inode *);
inode32fs/inode.cstatic inline void wait_on_inode(struct inode * inode)
inode34fs/inode.cif (inode->i_lock)
inode35fs/inode.c__wait_on_inode(inode);
inode38fs/inode.cstatic inline void lock_inode(struct inode * inode)
inode40fs/inode.cwait_on_inode(inode);
inode41fs/inode.cinode->i_lock = 1;
inode44fs/inode.cstatic inline void unlock_inode(struct inode * inode)
inode46fs/inode.cinode->i_lock = 0;
inode47fs/inode.cwake_up(&inode->i_wait);
inode62fs/inode.cvoid clear_inode(struct inode * inode)
inode66fs/inode.cwait_on_inode(inode);
inode67fs/inode.cwait = ((volatile struct inode *) inode)->i_wait;
inode68fs/inode.cmemset(inode,0,sizeof(*inode));
inode69fs/inode.c((volatile struct inode *) inode)->i_wait = wait;
inode74fs/inode.cstruct inode * inode;
inode76fs/inode.cfor (inode = inode_table+0 ; inode < inode_table+NR_INODE ; inode++) {
inode77fs/inode.cif (inode->i_dev != dev)
inode79fs/inode.cif (inode->i_count || inode->i_dirt || inode->i_lock)
inode81fs/inode.cclear_inode(inode);
inode86fs/inode.cint fs_may_umount(dev_t dev, struct inode * mount_root)
inode88fs/inode.cstruct inode * inode;
inode90fs/inode.cfor (inode = inode_table+0 ; inode < inode_table+NR_INODE ; inode++) {
inode91fs/inode.cif (inode->i_dev==dev && inode->i_count)
inode92fs/inode.cif (inode == mount_root && inode->i_count == 1)
inode100fs/inode.cstatic void write_inode(struct inode * inode)
inode102fs/inode.cif (!inode->i_dirt)
inode104fs/inode.cwait_on_inode(inode);
inode105fs/inode.cif (!inode->i_dirt)
inode107fs/inode.cif (!inode->i_sb || !inode->i_sb->s_op || !inode->i_sb->s_op->write_inode) {
inode108fs/inode.cinode->i_dirt = 0;
inode111fs/inode.cinode->i_lock = 1;  
inode112fs/inode.cinode->i_sb->s_op->write_inode(inode);
inode113fs/inode.cunlock_inode(inode);
inode116fs/inode.cstatic void read_inode(struct inode * inode)
inode118fs/inode.clock_inode(inode);
inode119fs/inode.cif (inode->i_sb && inode->i_sb->s_op && inode->i_sb->s_op->read_inode)
inode120fs/inode.cinode->i_sb->s_op->read_inode(inode);
inode121fs/inode.cunlock_inode(inode);
inode132fs/inode.cint notify_change(struct inode * inode)
inode134fs/inode.cif (inode->i_sb && inode->i_sb->s_op  &&
inode135fs/inode.cinode->i_sb->s_op->notify_change)
inode136fs/inode.creturn inode->i_sb->s_op->notify_change(inode);
inode150fs/inode.cint bmap(struct inode * inode, int block)
inode152fs/inode.cif (inode->i_op && inode->i_op->bmap)
inode153fs/inode.creturn inode->i_op->bmap(inode,block);
inode160fs/inode.cstruct inode * inode;
inode162fs/inode.cinode = 0+inode_table;
inode163fs/inode.cfor(i=0 ; i<NR_INODE ; i++,inode++) {
inode164fs/inode.cwait_on_inode(inode);
inode165fs/inode.cif (inode->i_dev == dev) {
inode166fs/inode.cif (inode->i_count) {
inode170fs/inode.cclear_inode(inode);
inode177fs/inode.cstruct inode * inode;
inode179fs/inode.cfor(inode = 0+inode_table ; inode < NR_INODE+inode_table ; inode++) {
inode180fs/inode.cwait_on_inode(inode);
inode181fs/inode.cif (inode->i_dirt)
inode182fs/inode.cwrite_inode(inode);
inode186fs/inode.cvoid iput(struct inode * inode)
inode188fs/inode.cif (!inode)
inode190fs/inode.cwait_on_inode(inode);
inode191fs/inode.cif (!inode->i_count) {
inode193fs/inode.cprintk("device %04x, inode %d, mode=%07o\n",inode->i_rdev,
inode194fs/inode.cinode->i_ino,inode->i_mode);
inode197fs/inode.cif (inode->i_pipe) {
inode198fs/inode.cwake_up(&PIPE_READ_WAIT(*inode));
inode199fs/inode.cwake_up(&PIPE_WRITE_WAIT(*inode));
inode202fs/inode.cif (inode->i_count>1) {
inode203fs/inode.cinode->i_count--;
inode207fs/inode.cif (inode->i_pipe) {
inode208fs/inode.cunsigned long page = (unsigned long) PIPE_BASE(*inode);
inode209fs/inode.cPIPE_BASE(*inode) = NULL;
inode212fs/inode.cif (inode->i_sb && inode->i_sb->s_op && inode->i_sb->s_op->put_inode) {
inode213fs/inode.cinode->i_sb->s_op->put_inode(inode);
inode214fs/inode.cif (!inode->i_nlink)
inode217fs/inode.cif (inode->i_dirt) {
inode218fs/inode.cwrite_inode(inode);  /* we can sleep - so do again */
inode219fs/inode.cwait_on_inode(inode);
inode222fs/inode.cinode->i_count--;
inode226fs/inode.cstruct inode * get_empty_inode(void)
inode228fs/inode.cstruct inode * inode;
inode232fs/inode.cinode = NULL;
inode237fs/inode.cinode = last_inode;
inode238fs/inode.cif (!inode->i_dirt && !inode->i_lock)
inode242fs/inode.cif (!inode) {
inode247fs/inode.cif (inode->i_lock) {
inode248fs/inode.cwait_on_inode(inode);
inode251fs/inode.cif (inode->i_dirt) {
inode252fs/inode.cwrite_inode(inode);
inode255fs/inode.cif (inode->i_count)
inode257fs/inode.cclear_inode(inode);
inode258fs/inode.cinode->i_count = 1;
inode259fs/inode.cinode->i_nlink = 1;
inode260fs/inode.creturn inode;
inode263fs/inode.cstruct inode * get_pipe_inode(void)
inode265fs/inode.cstruct inode * inode;
inode267fs/inode.cif (!(inode = get_empty_inode()))
inode269fs/inode.cif (!(PIPE_BASE(*inode) = (char *) get_free_page(GFP_USER))) {
inode270fs/inode.cinode->i_count = 0;
inode273fs/inode.cinode->i_count = 2;  /* sum of readers/writers */
inode274fs/inode.cPIPE_READ_WAIT(*inode) = PIPE_WRITE_WAIT(*inode) = NULL;
inode275fs/inode.cPIPE_HEAD(*inode) = PIPE_TAIL(*inode) = 0;
inode276fs/inode.cPIPE_READERS(*inode) = PIPE_WRITERS(*inode) = 1;
inode277fs/inode.cinode->i_pipe = 1;
inode278fs/inode.creturn inode;
inode281fs/inode.cstruct inode * iget(struct super_block * sb,int nr)
inode283fs/inode.cstruct inode * inode, * empty;
inode288fs/inode.cinode = inode_table;
inode289fs/inode.cwhile (inode < NR_INODE+inode_table) {
inode290fs/inode.cif (inode->i_dev != sb->s_dev || inode->i_ino != nr) {
inode291fs/inode.cinode++;
inode294fs/inode.cwait_on_inode(inode);
inode295fs/inode.cif (inode->i_dev != sb->s_dev || inode->i_ino != nr) {
inode296fs/inode.cinode = inode_table;
inode299fs/inode.cinode->i_count++;
inode300fs/inode.cif (inode->i_mount) {
inode304fs/inode.cif (super_block[i].s_covered==inode)
inode310fs/inode.creturn inode;
inode312fs/inode.ciput(inode);
inode313fs/inode.cif (!(inode = super_block[i].s_mounted))
inode316fs/inode.cinode->i_count++;
inode317fs/inode.cwait_on_inode(inode);
inode322fs/inode.creturn inode;
inode326fs/inode.cinode = empty;
inode327fs/inode.cinode->i_sb = sb;
inode328fs/inode.cinode->i_dev = sb->s_dev;
inode329fs/inode.cinode->i_ino = nr;
inode330fs/inode.cinode->i_flags = sb->s_flags;
inode331fs/inode.cread_inode(inode);
inode332fs/inode.creturn inode;
inode341fs/inode.cstatic void __wait_on_inode(struct inode * inode)
inode345fs/inode.cadd_wait_queue(&inode->i_wait, &wait);
inode348fs/inode.cif (inode->i_lock) {
inode352fs/inode.cremove_wait_queue(&inode->i_wait, &wait);
inode22fs/isofs/blkdev.cstatic int blkdev_open(struct inode * inode, struct file * filp)
inode26fs/isofs/blkdev.ci = MAJOR(inode->i_rdev);
inode31fs/isofs/blkdev.creturn filp->f_op->open(inode,filp);
inode22fs/isofs/chrdev.cstatic int chrdev_open(struct inode * inode, struct file * filp)
inode26fs/isofs/chrdev.ci = MAJOR(inode->i_rdev);
inode31fs/isofs/chrdev.creturn filp->f_op->open(inode,filp);
inode22fs/isofs/dir.cstatic int isofs_readdir(struct inode *, struct file *, struct dirent *, int);
inode62fs/isofs/dir.cstatic int isofs_readdir(struct inode * inode, struct file * filp,
inode75fs/isofs/dir.cif (!inode || !S_ISDIR(inode->i_mode))
inode79fs/isofs/dir.cblock = isofs_bmap(inode,(filp->f_pos)>>BLOCK_SIZE_BITS);
inode80fs/isofs/dir.cif (!block || !(bh = bread(inode->i_dev,block,ISOFS_BUFFER_SIZE)))
inode83fs/isofs/dir.cwhile (filp->f_pos < inode->i_size) {
inode97fs/isofs/dir.cblock = isofs_bmap(inode,(filp->f_pos)>>BLOCK_SIZE_BITS);
inode98fs/isofs/dir.cif (!block || !(bh = bread(inode->i_dev,block,ISOFS_BUFFER_SIZE)))
inode116fs/isofs/dir.cblock = isofs_bmap(inode,(filp->f_pos)>>BLOCK_SIZE_BITS);
inode117fs/isofs/dir.cif (!block || !(bh = bread(inode->i_dev,block,ISOFS_BUFFER_SIZE)))
inode128fs/isofs/dir.cinode_number = inode->i_ino;
inode139fs/isofs/dir.cif((inode->i_sb->u.isofs_sb.s_firstdatazone << BLOCK_SIZE_BITS) != inode->i_ino)
inode140fs/isofs/dir.cinode_number = inode->u.isofs_i.i_backlink;
inode142fs/isofs/dir.cinode_number = inode->i_ino;
inode147fs/isofs/dir.cisofs_lookup_grandparent(inode,
inode148fs/isofs/dir.cfind_rock_ridge_relocation(de, inode));
inode163fs/isofs/dir.crrflag = get_rock_ridge_filename(de, &dpnt, &dlen, inode);
inode175fs/isofs/dir.cif(inode->i_sb->u.isofs_sb.s_mapping == 'n')
inode196fs/isofs/dir.ccache.dir = inode->i_ino;
inode197fs/isofs/dir.ccache.dev = inode->i_dev;
inode32fs/isofs/file.cstatic int isofs_file_read(struct inode *, struct file *, char *, int);
inode87fs/isofs/file.cstatic void isofs_determine_filetype(struct inode * inode)
inode94fs/isofs/file.cblock = isofs_bmap(inode,0);
inode95fs/isofs/file.cif (block && (bh = bread(inode->i_dev,block, ISOFS_BUFFER_SIZE))) {
inode98fs/isofs/file.cfor(i=0;i<(inode->i_size < ISOFS_BUFFER_SIZE ? inode->i_size : ISOFS_BUFFER_SIZE);
inode108fs/isofs/file.cinode->u.isofs_i.i_file_format = result;
inode112fs/isofs/file.cstatic int isofs_file_read(struct inode * inode, struct file * filp, char * buf, int count)
inode122fs/isofs/file.cif (!inode) {
inode126fs/isofs/file.cif (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode))) {
inode127fs/isofs/file.cprintk("isofs_file_read: mode = %07o\n",inode->i_mode);
inode130fs/isofs/file.cif (inode->u.isofs_i.i_file_format == ISOFS_FILE_UNKNOWN)
inode131fs/isofs/file.cisofs_determine_filetype(inode);
inode132fs/isofs/file.cif (filp->f_pos > inode->i_size)
inode135fs/isofs/file.cleft = inode->i_size - filp->f_pos;
inode146fs/isofs/file.cra_blocks = read_ahead[MAJOR(inode->i_dev)] / (BLOCK_SIZE >> 9);
inode147fs/isofs/file.cmax_block = (inode->i_size + BLOCK_SIZE - 1)/BLOCK_SIZE;
inode165fs/isofs/file.c*bhb = getblk(inode->i_dev,isofs_bmap(inode, block++), ISOFS_BUFFER_SIZE);
inode191fs/isofs/file.c*bhb = getblk(inode->i_dev,isofs_bmap(inode, block++), ISOFS_BUFFER_SIZE);
inode234fs/isofs/file.cif (inode->u.isofs_i.i_file_format == ISOFS_FILE_TEXT ||
inode235fs/isofs/file.cinode->u.isofs_i.i_file_format == ISOFS_FILE_TEXT_M)
inode237fs/isofs/file.cchars, inode->u.isofs_i.i_file_format);
inode253fs/isofs/inode.cint isofs_bmap(struct inode * inode,int block)
inode260fs/isofs/inode.creturn inode->u.isofs_i.i_first_extent + block;
inode263fs/isofs/inode.cvoid isofs_read_inode(struct inode * inode)
inode272fs/isofs/inode.cblock = inode->i_ino >> ISOFS_BUFFER_BITS;
inode273fs/isofs/inode.cif (!(bh=bread(inode->i_dev,block, ISOFS_BUFFER_SIZE)))
inode276fs/isofs/inode.cpnt = ((char *) bh->b_data) + (inode->i_ino & (ISOFS_BUFFER_SIZE - 1));
inode279fs/isofs/inode.chigh_sierra = inode->i_sb->u.isofs_sb.s_high_sierra;
inode281fs/isofs/inode.cif ((inode->i_ino & (ISOFS_BUFFER_SIZE - 1)) + *pnt > ISOFS_BUFFER_SIZE){
inode285fs/isofs/inode.cif (!(bh = bread(inode->i_dev,++block, ISOFS_BUFFER_SIZE)))
inode288fs/isofs/inode.cpnt = ((char *) cpnt) + (inode->i_ino & (ISOFS_BUFFER_SIZE - 1));
inode293fs/isofs/inode.cinode->i_mode = 0444; /* Everybody gets to read the file. */
inode294fs/isofs/inode.cinode->i_nlink = 1;
inode297fs/isofs/inode.cinode->i_mode = 0555 | S_IFDIR;
inode298fs/isofs/inode.cinode->i_nlink = 2; /* There are always at least 2.  It is
inode301fs/isofs/inode.cinode->i_mode = 0444; /* Everybody gets to read the file. */
inode302fs/isofs/inode.cinode->i_nlink = 1;
inode303fs/isofs/inode.cinode->i_mode |= S_IFREG;
inode309fs/isofs/inode.cinode->i_mode |= 0111; /* execute permission */
inode311fs/isofs/inode.cinode->i_uid = 0;
inode312fs/isofs/inode.cinode->i_gid = 0;
inode313fs/isofs/inode.cinode->i_size = isonum_733 (raw_inode->size);
inode317fs/isofs/inode.cif(inode->i_size < 0 || inode->i_size > 700000000) {
inode319fs/isofs/inode.cinode->i_sb->u.isofs_sb.s_cruft = 'y';
inode326fs/isofs/inode.cif(inode->i_sb->u.isofs_sb.s_cruft == 'y' && 
inode327fs/isofs/inode.cinode->i_size & 0xff000000){
inode329fs/isofs/inode.cinode->i_size &= 0x00ffffff;
inode338fs/isofs/inode.cinode->i_size = 0;
inode346fs/isofs/inode.cinode->i_ino);
inode353fs/isofs/inode.cprintk("File unit size != 0 for ISO file.(%d)\n",inode->i_ino);
inode360fs/isofs/inode.cinode->i_ino, raw_inode->flags[-high_sierra]);
inode364fs/isofs/inode.cprintk("Get inode %d: %d %d: %d\n",inode->i_ino, block, 
inode365fs/isofs/inode.c((int)pnt) & 0x3ff, inode->i_size);
inode368fs/isofs/inode.cinode->i_mtime = inode->i_atime = inode->i_ctime = 
inode371fs/isofs/inode.cinode->u.isofs_i.i_first_extent = isonum_733 (raw_inode->extent) << 
inode374fs/isofs/inode.cinode->u.isofs_i.i_backlink = -1; /* Will be used for previous directory */
inode375fs/isofs/inode.cswitch (inode->i_sb->u.isofs_sb.s_conversion){
inode377fs/isofs/inode.cinode->u.isofs_i.i_file_format = ISOFS_FILE_UNKNOWN; /* File type */
inode380fs/isofs/inode.cinode->u.isofs_i.i_file_format = ISOFS_FILE_BINARY; /* File type */
inode383fs/isofs/inode.cinode->u.isofs_i.i_file_format = ISOFS_FILE_TEXT; /* File type */
inode386fs/isofs/inode.cinode->u.isofs_i.i_file_format = ISOFS_FILE_TEXT_M; /* File type */
inode395fs/isofs/inode.cparse_rock_ridge_inode(raw_inode, inode);
inode398fs/isofs/inode.cprintk("Inode: %x extent: %x\n",inode->i_ino, inode->u.isofs_i.i_first_extent);
inode407fs/isofs/inode.cinode->i_op = NULL;
inode408fs/isofs/inode.cif (S_ISREG(inode->i_mode))
inode409fs/isofs/inode.cinode->i_op = &isofs_file_inode_operations;
inode410fs/isofs/inode.celse if (S_ISDIR(inode->i_mode))
inode411fs/isofs/inode.cinode->i_op = &isofs_dir_inode_operations;
inode412fs/isofs/inode.celse if (S_ISLNK(inode->i_mode))
inode413fs/isofs/inode.cinode->i_op = &isofs_symlink_inode_operations;
inode414fs/isofs/inode.celse if (S_ISCHR(inode->i_mode))
inode415fs/isofs/inode.cinode->i_op = &isofs_chrdev_inode_operations;
inode416fs/isofs/inode.celse if (S_ISBLK(inode->i_mode))
inode417fs/isofs/inode.cinode->i_op = &isofs_blkdev_inode_operations;
inode418fs/isofs/inode.celse if (S_ISFIFO(inode->i_mode)) {
inode419fs/isofs/inode.cinode->i_op = &isofs_fifo_inode_operations;
inode420fs/isofs/inode.cinode->i_pipe = 1;
inode421fs/isofs/inode.cPIPE_BASE(*inode) = NULL;
inode422fs/isofs/inode.cPIPE_HEAD(*inode) = PIPE_TAIL(*inode) = 0;
inode423fs/isofs/inode.cPIPE_READ_WAIT(*inode) = PIPE_WRITE_WAIT(*inode) = NULL;
inode424fs/isofs/inode.cPIPE_READERS(*inode) = PIPE_WRITERS(*inode) = 0;
inode447fs/isofs/inode.cint isofs_lookup_grandparent(struct inode * parent, int extent) {
inode64fs/isofs/namei.cstatic struct buffer_head * isofs_find_entry(struct inode * dir,
inode193fs/isofs/namei.cint isofs_lookup(struct inode * dir,const char * name, int len,
inode194fs/isofs/namei.cstruct inode ** result)
inode78fs/isofs/rock.cstruct inode * inode) {
inode93fs/isofs/rock.cif (!inode->i_sb->u.isofs_sb.s_rock) return retval;
inode143fs/isofs/rock.cMAYBE_CONTINUE(repeat, inode->i_dev);
inode151fs/isofs/rock.cchar ** name, int * namlen, struct inode * inode)
inode159fs/isofs/rock.cif (!inode->i_sb->u.isofs_sb.s_rock) return 0;
inode210fs/isofs/rock.cprintk("RR: RE (%x)\n", inode->i_ino);
inode220fs/isofs/rock.cMAYBE_CONTINUE(repeat,inode->i_dev);
inode234fs/isofs/rock.cstruct inode * inode){
inode239fs/isofs/rock.cif (!inode->i_sb->u.isofs_sb.s_rock) return 0;
inode245fs/isofs/rock.cstruct inode * reloc;
inode274fs/isofs/rock.cinode->i_mode  = isonum_733(rr->u.PX.mode);
inode275fs/isofs/rock.cinode->i_nlink = isonum_733(rr->u.PX.n_links);
inode276fs/isofs/rock.cinode->i_uid   = isonum_733(rr->u.PX.uid);
inode277fs/isofs/rock.cinode->i_gid   = isonum_733(rr->u.PX.gid);
inode283fs/isofs/rock.cinode->i_rdev = ((high << 8) | (low & 0xff)) & 0xffff;
inode288fs/isofs/rock.cif(rr->u.TF.flags & TF_CREATE) inode->i_ctime = iso_date(rr->u.TF.times[cnt++].time, 0);
inode289fs/isofs/rock.cif(rr->u.TF.flags & TF_MODIFY) inode->i_mtime = iso_date(rr->u.TF.times[cnt++].time, 0);
inode290fs/isofs/rock.cif(rr->u.TF.flags & TF_ACCESS) inode->i_atime = iso_date(rr->u.TF.times[cnt++].time, 0);
inode300fs/isofs/rock.cinode->i_size += slp->len;
inode303fs/isofs/rock.cinode->i_size += 1;
inode306fs/isofs/rock.cinode->i_size += 2;
inode309fs/isofs/rock.cinode->i_size += 1;
inode318fs/isofs/rock.cinode->i_size += 1;
inode327fs/isofs/rock.cprintk("RR CL (%x)\n",inode->i_ino);
inode329fs/isofs/rock.cinode->u.isofs_i.i_first_extent = isonum_733(rr->u.CL.location) <<
inode331fs/isofs/rock.creloc = iget(inode->i_sb, inode->u.isofs_i.i_first_extent << ISOFS_BUFFER_BITS);
inode332fs/isofs/rock.cinode->i_mode = reloc->i_mode;
inode333fs/isofs/rock.cinode->i_nlink = reloc->i_nlink;
inode334fs/isofs/rock.cinode->i_uid = reloc->i_uid;
inode335fs/isofs/rock.cinode->i_gid = reloc->i_gid;
inode336fs/isofs/rock.cinode->i_rdev = reloc->i_rdev;
inode337fs/isofs/rock.cinode->i_size = reloc->i_size;
inode338fs/isofs/rock.cinode->i_atime = reloc->i_atime;
inode339fs/isofs/rock.cinode->i_ctime = reloc->i_ctime;
inode340fs/isofs/rock.cinode->i_mtime = reloc->i_mtime;
inode348fs/isofs/rock.cMAYBE_CONTINUE(repeat,inode->i_dev);
inode359fs/isofs/rock.cchar * get_rock_ridge_symlink(struct inode * inode)
inode372fs/isofs/rock.cif (!inode->i_sb->u.isofs_sb.s_rock)
inode377fs/isofs/rock.cblock = inode->i_ino >> ISOFS_BUFFER_BITS;
inode378fs/isofs/rock.cif (!(bh=bread(inode->i_dev,block, ISOFS_BUFFER_SIZE)))
inode381fs/isofs/rock.cpnt = ((char *) bh->b_data) + (inode->i_ino & (ISOFS_BUFFER_SIZE - 1));
inode385fs/isofs/rock.cif ((inode->i_ino & (ISOFS_BUFFER_SIZE - 1)) + *pnt > ISOFS_BUFFER_SIZE){
inode389fs/isofs/rock.cif (!(bh = bread(inode->i_dev,++block, ISOFS_BUFFER_SIZE)))
inode392fs/isofs/rock.cpnt = ((char *) cpnt) + (inode->i_ino & (ISOFS_BUFFER_SIZE - 1));
inode424fs/isofs/rock.crpnt = (char *) kmalloc (inode->i_size +1, GFP_KERNEL);
inode455fs/isofs/rock.cMAYBE_CONTINUE(repeat,inode->i_dev);
inode20fs/isofs/symlink.cstatic int isofs_readlink(struct inode *, char *, int);
inode21fs/isofs/symlink.cstatic int isofs_follow_link(struct inode *, struct inode *, int, int, struct inode **);
inode44fs/isofs/symlink.cstatic int isofs_follow_link(struct inode * dir, struct inode * inode,
inode45fs/isofs/symlink.cint flag, int mode, struct inode ** res_inode)
inode55fs/isofs/symlink.cif (!inode) {
inode60fs/isofs/symlink.cif (!S_ISLNK(inode->i_mode)) {
inode62fs/isofs/symlink.c*res_inode = inode;
inode67fs/isofs/symlink.c!(pnt = get_rock_ridge_symlink(inode))) {
inode69fs/isofs/symlink.ciput(inode);
inode73fs/isofs/symlink.ciput(inode);
inode83fs/isofs/symlink.cstatic int isofs_readlink(struct inode * inode, char * buffer, int buflen)
inode89fs/isofs/symlink.cif (!S_ISLNK(inode->i_mode)) {
inode90fs/isofs/symlink.ciput(inode);
inode96fs/isofs/symlink.cpnt = get_rock_ridge_symlink(inode);
inode98fs/isofs/symlink.ciput(inode);
inode156fs/minix/bitmap.cvoid minix_free_inode(struct inode * inode)
inode160fs/minix/bitmap.cif (!inode)
inode162fs/minix/bitmap.cif (!inode->i_dev) {
inode166fs/minix/bitmap.cif (inode->i_count != 1) {
inode167fs/minix/bitmap.cprintk("free_inode: inode has count=%d\n",inode->i_count);
inode170fs/minix/bitmap.cif (inode->i_nlink) {
inode171fs/minix/bitmap.cprintk("free_inode: inode has nlink=%d\n",inode->i_nlink);
inode174fs/minix/bitmap.cif (!inode->i_sb) {
inode178fs/minix/bitmap.cif (inode->i_ino < 1 || inode->i_ino >= inode->i_sb->u.minix_sb.s_ninodes) {
inode182fs/minix/bitmap.cif (!(bh=inode->i_sb->u.minix_sb.s_imap[inode->i_ino>>13])) {
inode186fs/minix/bitmap.cif (clear_bit(inode->i_ino&8191,bh->b_data))
inode187fs/minix/bitmap.cprintk("free_inode: bit %d already cleared.\n",inode->i_ino);
inode189fs/minix/bitmap.cclear_inode(inode);
inode192fs/minix/bitmap.cstruct inode * minix_new_inode(const struct inode * dir)
inode195fs/minix/bitmap.cstruct inode * inode;
inode199fs/minix/bitmap.cif (!dir || !(inode = get_empty_inode()))
inode202fs/minix/bitmap.cinode->i_sb = sb;
inode203fs/minix/bitmap.cinode->i_flags = inode->i_sb->s_flags;
inode206fs/minix/bitmap.cif ((bh = inode->i_sb->u.minix_sb.s_imap[i]) != NULL)
inode210fs/minix/bitmap.ciput(inode);
inode215fs/minix/bitmap.ciput(inode);
inode220fs/minix/bitmap.cif (!j || j >= inode->i_sb->u.minix_sb.s_ninodes) {
inode221fs/minix/bitmap.ciput(inode);
inode224fs/minix/bitmap.cinode->i_count = 1;
inode225fs/minix/bitmap.cinode->i_nlink = 1;
inode226fs/minix/bitmap.cinode->i_dev = sb->s_dev;
inode227fs/minix/bitmap.cinode->i_uid = current->euid;
inode228fs/minix/bitmap.cinode->i_gid = (dir->i_mode & S_ISGID) ? dir->i_gid : current->egid;
inode229fs/minix/bitmap.cinode->i_dirt = 1;
inode230fs/minix/bitmap.cinode->i_ino = j;
inode231fs/minix/bitmap.cinode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
inode232fs/minix/bitmap.cinode->i_op = NULL;
inode233fs/minix/bitmap.cinode->i_blocks = inode->i_blksize = 0;
inode234fs/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);
inode26fs/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);
inode26fs/minix/chrdev.creturn filp->f_op->open(inode,filp);
inode16fs/minix/dir.cstatic int minix_dir_read(struct inode * inode, struct file * filp, char * buf, int count)
inode21fs/minix/dir.cstatic int minix_readdir(struct inode *, struct file *, struct dirent *, int);
inode56fs/minix/dir.cstatic int minix_readdir(struct inode * inode, struct file * filp,
inode64fs/minix/dir.cif (!inode || !S_ISDIR(inode->i_mode))
inode68fs/minix/dir.cwhile (filp->f_pos < inode->i_size) {
inode70fs/minix/dir.cbh = minix_bread(inode,(filp->f_pos)>>BLOCK_SIZE_BITS,0);
inode76fs/minix/dir.cwhile (offset < 1024 && filp->f_pos < inode->i_size) {
inode79fs/minix/dir.cif (de->inode) {
inode86fs/minix/dir.cput_fs_long(de->inode,&dirent->d_ino);
inode28fs/minix/file.cstatic int minix_file_read(struct inode *, struct file *, char *, int);
inode29fs/minix/file.cstatic int minix_file_write(struct inode *, struct file *, char *, int);
inode65fs/minix/file.cstatic int minix_file_read(struct inode * inode, struct file * filp, char * buf, int count)
inode75fs/minix/file.cif (!inode) {
inode79fs/minix/file.cif (!S_ISREG(inode->i_mode)) {
inode80fs/minix/file.cprintk("minix_file_read: mode = %07o\n",inode->i_mode);
inode84fs/minix/file.csize = inode->i_size;
inode100fs/minix/file.cblocks += read_ahead[MAJOR(inode->i_dev)] / (BLOCK_SIZE >> 9);
inode120fs/minix/file.c*bhb = minix_getblk(inode, block++, 0);
inode179fs/minix/file.cif (!IS_RDONLY(inode)) {
inode180fs/minix/file.cinode->i_atime = CURRENT_TIME;
inode181fs/minix/file.cinode->i_dirt = 1;
inode186fs/minix/file.cstatic int minix_file_write(struct inode * inode, struct file * filp, char * buf, int count)
inode193fs/minix/file.cif (!inode) {
inode197fs/minix/file.cif (!S_ISREG(inode->i_mode)) {
inode198fs/minix/file.cprintk("minix_file_write: mode = %07o\n",inode->i_mode);
inode206fs/minix/file.cpos = inode->i_size;
inode211fs/minix/file.cbh = minix_getblk(inode,pos/BLOCK_SIZE,1);
inode232fs/minix/file.cif (pos > inode->i_size) {
inode233fs/minix/file.cinode->i_size = pos;
inode234fs/minix/file.cinode->i_dirt = 1;
inode243fs/minix/file.cinode->i_mtime = CURRENT_TIME;
inode244fs/minix/file.cinode->i_ctime = CURRENT_TIME;
inode246fs/minix/file.cinode->i_dirt = 1;
inode18fs/minix/inode.cvoid minix_put_inode(struct inode *inode)
inode20fs/minix/inode.cif (inode->i_nlink)
inode22fs/minix/inode.cinode->i_size = 0;
inode23fs/minix/inode.cminix_truncate(inode);
inode24fs/minix/inode.cminix_free_inode(inode);
inode138fs/minix/inode.c#define inode_bmap(inode,nr) ((inode)->u.minix_i.i_data[(nr)])
inode151fs/minix/inode.cint minix_bmap(struct inode * inode,int block)
inode164fs/minix/inode.creturn inode_bmap(inode,block);
inode167fs/minix/inode.ci = inode_bmap(inode,7);
inode170fs/minix/inode.creturn block_bmap(bread(inode->i_dev,i,BLOCK_SIZE),block);
inode173fs/minix/inode.ci = inode_bmap(inode,8);
inode176fs/minix/inode.ci = block_bmap(bread(inode->i_dev,i,BLOCK_SIZE),block>>9);
inode179fs/minix/inode.creturn block_bmap(bread(inode->i_dev,i,BLOCK_SIZE),block & 511);
inode182fs/minix/inode.cstatic struct buffer_head * inode_getblk(struct inode * inode, int nr, int create)
inode188fs/minix/inode.cp = inode->u.minix_i.i_data + nr;
inode192fs/minix/inode.cresult = getblk(inode->i_dev, tmp, BLOCK_SIZE);
inode200fs/minix/inode.ctmp = minix_new_block(inode->i_sb);
inode203fs/minix/inode.cresult = getblk(inode->i_dev, tmp, BLOCK_SIZE);
inode205fs/minix/inode.cminix_free_block(inode->i_sb,tmp);
inode210fs/minix/inode.cinode->i_ctime = CURRENT_TIME;
inode211fs/minix/inode.cinode->i_dirt = 1;
inode215fs/minix/inode.cstatic struct buffer_head * block_getblk(struct inode * inode, 
inode248fs/minix/inode.ctmp = minix_new_block(inode->i_sb);
inode255fs/minix/inode.cminix_free_block(inode->i_sb,tmp);
inode265fs/minix/inode.cstruct buffer_head * minix_getblk(struct inode * inode, int block, int create)
inode278fs/minix/inode.creturn inode_getblk(inode,block,create);
inode281fs/minix/inode.cbh = inode_getblk(inode,7,create);
inode282fs/minix/inode.creturn block_getblk(inode, bh, block, create);
inode285fs/minix/inode.cbh = inode_getblk(inode,8,create);
inode286fs/minix/inode.cbh = block_getblk(inode, bh, block>>9, create);
inode287fs/minix/inode.creturn block_getblk(inode, bh, block & 511, create);
inode290fs/minix/inode.cstruct buffer_head * minix_bread(struct inode * inode, int block, int create)
inode294fs/minix/inode.cbh = minix_getblk(inode,block,create);
inode305fs/minix/inode.cvoid minix_read_inode(struct inode * inode)
inode311fs/minix/inode.cino = inode->i_ino;
inode312fs/minix/inode.cinode->i_op = NULL;
inode313fs/minix/inode.cinode->i_mode = 0;
inode314fs/minix/inode.cif (!ino || ino >= inode->i_sb->u.minix_sb.s_ninodes) {
inode316fs/minix/inode.cinode->i_dev, ino);
inode319fs/minix/inode.cblock = 2 + inode->i_sb->u.minix_sb.s_imap_blocks +
inode320fs/minix/inode.cinode->i_sb->u.minix_sb.s_zmap_blocks +
inode322fs/minix/inode.cif (!(bh=bread(inode->i_dev,block, BLOCK_SIZE))) {
inode324fs/minix/inode.cinode->i_dev);
inode329fs/minix/inode.cinode->i_mode = raw_inode->i_mode;
inode330fs/minix/inode.cinode->i_uid = raw_inode->i_uid;
inode331fs/minix/inode.cinode->i_gid = raw_inode->i_gid;
inode332fs/minix/inode.cinode->i_nlink = raw_inode->i_nlinks;
inode333fs/minix/inode.cinode->i_size = raw_inode->i_size;
inode334fs/minix/inode.cinode->i_mtime = inode->i_atime = inode->i_ctime = raw_inode->i_time;
inode335fs/minix/inode.cinode->i_blocks = inode->i_blksize = 0;
inode336fs/minix/inode.cif (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
inode337fs/minix/inode.cinode->i_rdev = raw_inode->i_zone[0];
inode339fs/minix/inode.cinode->u.minix_i.i_data[block] = raw_inode->i_zone[block];
inode341fs/minix/inode.cif (S_ISREG(inode->i_mode))
inode342fs/minix/inode.cinode->i_op = &minix_file_inode_operations;
inode343fs/minix/inode.celse if (S_ISDIR(inode->i_mode))
inode344fs/minix/inode.cinode->i_op = &minix_dir_inode_operations;
inode345fs/minix/inode.celse if (S_ISLNK(inode->i_mode))
inode346fs/minix/inode.cinode->i_op = &minix_symlink_inode_operations;
inode347fs/minix/inode.celse if (S_ISCHR(inode->i_mode))
inode348fs/minix/inode.cinode->i_op = &minix_chrdev_inode_operations;
inode349fs/minix/inode.celse if (S_ISBLK(inode->i_mode))
inode350fs/minix/inode.cinode->i_op = &minix_blkdev_inode_operations;
inode351fs/minix/inode.celse if (S_ISFIFO(inode->i_mode)) {
inode352fs/minix/inode.cinode->i_op = &minix_fifo_inode_operations;
inode353fs/minix/inode.cinode->i_pipe = 1;
inode354fs/minix/inode.cPIPE_BASE(*inode) = NULL;
inode355fs/minix/inode.cPIPE_HEAD(*inode) = PIPE_TAIL(*inode) = 0;
inode356fs/minix/inode.cPIPE_READ_WAIT(*inode) = PIPE_WRITE_WAIT(*inode) = NULL;
inode357fs/minix/inode.cPIPE_READERS(*inode) = PIPE_WRITERS(*inode) = 0;
inode361fs/minix/inode.cvoid minix_write_inode(struct inode * inode)
inode367fs/minix/inode.cino = inode->i_ino;
inode368fs/minix/inode.cif (!ino || ino >= inode->i_sb->u.minix_sb.s_ninodes) {
inode370fs/minix/inode.cinode->i_dev, ino);
inode371fs/minix/inode.cinode->i_dirt = 0;
inode374fs/minix/inode.cblock = 2 + inode->i_sb->u.minix_sb.s_imap_blocks + inode->i_sb->u.minix_sb.s_zmap_blocks +
inode376fs/minix/inode.cif (!(bh=bread(inode->i_dev, block, BLOCK_SIZE)))
inode380fs/minix/inode.craw_inode->i_mode = inode->i_mode;
inode381fs/minix/inode.craw_inode->i_uid = inode->i_uid;
inode382fs/minix/inode.craw_inode->i_gid = inode->i_gid;
inode383fs/minix/inode.craw_inode->i_nlinks = inode->i_nlink;
inode384fs/minix/inode.craw_inode->i_size = inode->i_size;
inode385fs/minix/inode.craw_inode->i_time = inode->i_mtime;
inode386fs/minix/inode.cif (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
inode387fs/minix/inode.craw_inode->i_zone[0] = inode->i_rdev;
inode389fs/minix/inode.craw_inode->i_zone[block] = inode->u.minix_i.i_data[block];
inode390fs/minix/inode.cinode->i_dirt=0;
inode34fs/minix/namei.cif (!de || !de->inode || len > MINIX_NAME_LEN)
inode58fs/minix/namei.cstatic struct buffer_head * minix_find_entry(struct inode * dir,
inode102fs/minix/namei.cint minix_lookup(struct inode * dir,const char * name, int len,
inode103fs/minix/namei.cstruct inode ** result)
inode120fs/minix/namei.cino = de->inode;
inode143fs/minix/namei.cstatic struct buffer_head * minix_add_entry(struct inode * dir,
inode179fs/minix/namei.cde->inode=0;
inode184fs/minix/namei.cif (!de->inode) {
inode198fs/minix/namei.cint minix_create(struct inode * dir,const char * name, int len, int mode,
inode199fs/minix/namei.cstruct inode ** result)
inode201fs/minix/namei.cstruct inode * inode;
inode208fs/minix/namei.cinode = minix_new_inode(dir);
inode209fs/minix/namei.cif (!inode) {
inode213fs/minix/namei.cinode->i_op = &minix_file_inode_operations;
inode214fs/minix/namei.cinode->i_mode = mode;
inode215fs/minix/namei.cinode->i_dirt = 1;
inode218fs/minix/namei.cinode->i_nlink--;
inode219fs/minix/namei.cinode->i_dirt = 1;
inode220fs/minix/namei.ciput(inode);
inode224fs/minix/namei.cde->inode = inode->i_ino;
inode228fs/minix/namei.c*result = inode;
inode232fs/minix/namei.cint minix_mknod(struct inode * dir, const char * name, int len, int mode, int rdev)
inode234fs/minix/namei.cstruct inode * inode;
inode246fs/minix/namei.cinode = minix_new_inode(dir);
inode247fs/minix/namei.cif (!inode) {
inode251fs/minix/namei.cinode->i_uid = current->euid;
inode252fs/minix/namei.cinode->i_mode = mode;
inode253fs/minix/namei.cinode->i_op = NULL;
inode254fs/minix/namei.cif (S_ISREG(inode->i_mode))
inode255fs/minix/namei.cinode->i_op = &minix_file_inode_operations;
inode256fs/minix/namei.celse if (S_ISDIR(inode->i_mode)) {
inode257fs/minix/namei.cinode->i_op = &minix_dir_inode_operations;
inode259fs/minix/namei.cinode->i_mode |= S_ISGID;
inode261fs/minix/namei.celse if (S_ISLNK(inode->i_mode))
inode262fs/minix/namei.cinode->i_op = &minix_symlink_inode_operations;
inode263fs/minix/namei.celse if (S_ISCHR(inode->i_mode))
inode264fs/minix/namei.cinode->i_op = &minix_chrdev_inode_operations;
inode265fs/minix/namei.celse if (S_ISBLK(inode->i_mode))
inode266fs/minix/namei.cinode->i_op = &minix_blkdev_inode_operations;
inode267fs/minix/namei.celse if (S_ISFIFO(inode->i_mode)) {
inode268fs/minix/namei.cinode->i_op = &minix_fifo_inode_operations;
inode269fs/minix/namei.cinode->i_pipe = 1;
inode270fs/minix/namei.cPIPE_BASE(*inode) = NULL;
inode271fs/minix/namei.cPIPE_HEAD(*inode) = PIPE_TAIL(*inode) = 0;
inode272fs/minix/namei.cPIPE_READ_WAIT(*inode) = PIPE_WRITE_WAIT(*inode) = NULL;
inode273fs/minix/namei.cPIPE_READERS(*inode) = PIPE_WRITERS(*inode) = 0;
inode276fs/minix/namei.cinode->i_rdev = rdev;
inode277fs/minix/namei.cinode->i_mtime = inode->i_atime = CURRENT_TIME;
inode278fs/minix/namei.cinode->i_dirt = 1;
inode281fs/minix/namei.cinode->i_nlink--;
inode282fs/minix/namei.cinode->i_dirt = 1;
inode283fs/minix/namei.ciput(inode);
inode287fs/minix/namei.cde->inode = inode->i_ino;
inode291fs/minix/namei.ciput(inode);
inode295fs/minix/namei.cint minix_mkdir(struct inode * dir, const char * name, int len, int mode)
inode297fs/minix/namei.cstruct inode * inode;
inode311fs/minix/namei.cinode = minix_new_inode(dir);
inode312fs/minix/namei.cif (!inode) {
inode316fs/minix/namei.cinode->i_op = &minix_dir_inode_operations;
inode317fs/minix/namei.cinode->i_size = 2 * sizeof (struct minix_dir_entry);
inode318fs/minix/namei.cinode->i_mtime = inode->i_atime = CURRENT_TIME;
inode319fs/minix/namei.cdir_block = minix_bread(inode,0,1);
inode322fs/minix/namei.cinode->i_nlink--;
inode323fs/minix/namei.cinode->i_dirt = 1;
inode324fs/minix/namei.ciput(inode);
inode328fs/minix/namei.cde->inode=inode->i_ino;
inode331fs/minix/namei.cde->inode = dir->i_ino;
inode333fs/minix/namei.cinode->i_nlink = 2;
inode336fs/minix/namei.cinode->i_mode = S_IFDIR | (mode & 0777 & ~current->umask);
inode338fs/minix/namei.cinode->i_mode |= S_ISGID;
inode339fs/minix/namei.cinode->i_dirt = 1;
inode343fs/minix/namei.cinode->i_nlink=0;
inode344fs/minix/namei.ciput(inode);
inode347fs/minix/namei.cde->inode = inode->i_ino;
inode352fs/minix/namei.ciput(inode);
inode360fs/minix/namei.cstatic int empty_dir(struct inode * inode)
inode366fs/minix/namei.clen = inode->i_size / sizeof (struct minix_dir_entry);
inode367fs/minix/namei.cif (len<2 || !(bh = minix_bread(inode,0,0))) {
inode368fs/minix/namei.cprintk("warning - bad directory on dev %04x\n",inode->i_dev);
inode372fs/minix/namei.cif (de[0].inode != inode->i_ino || !de[1].inode || 
inode374fs/minix/namei.cprintk("warning - bad directory on dev %04x\n",inode->i_dev);
inode382fs/minix/namei.cbh = minix_bread(inode,nr/MINIX_DIR_ENTRIES_PER_BLOCK,0);
inode389fs/minix/namei.cif (de->inode) {
inode400fs/minix/namei.cint minix_rmdir(struct inode * dir, const char * name, int len)
inode403fs/minix/namei.cstruct inode * inode;
inode407fs/minix/namei.cinode = NULL;
inode413fs/minix/namei.cif (!(inode = iget(dir->i_sb, de->inode)))
inode416fs/minix/namei.cinode->i_uid != current->euid)
inode418fs/minix/namei.cif (inode->i_dev != dir->i_dev)
inode420fs/minix/namei.cif (inode == dir)  /* we may not delete ".", but "../dir" is ok */
inode422fs/minix/namei.cif (!S_ISDIR(inode->i_mode)) {
inode426fs/minix/namei.cif (!empty_dir(inode)) {
inode430fs/minix/namei.cif (inode->i_count > 1) {
inode434fs/minix/namei.cif (inode->i_nlink != 2)
inode435fs/minix/namei.cprintk("empty directory has nlink!=2 (%d)\n",inode->i_nlink);
inode436fs/minix/namei.cde->inode = 0;
inode438fs/minix/namei.cinode->i_nlink=0;
inode439fs/minix/namei.cinode->i_dirt=1;
inode446fs/minix/namei.ciput(inode);
inode451fs/minix/namei.cint minix_unlink(struct inode * dir, const char * name, int len)
inode454fs/minix/namei.cstruct inode * inode;
inode460fs/minix/namei.cinode = NULL;
inode464fs/minix/namei.cif (!(inode = iget(dir->i_sb, de->inode)))
inode466fs/minix/namei.cif (de->inode != inode->i_ino) {
inode467fs/minix/namei.ciput(inode);
inode475fs/minix/namei.ccurrent->euid != inode->i_uid &&
inode478fs/minix/namei.cif (S_ISDIR(inode->i_mode))
inode480fs/minix/namei.cif (!inode->i_nlink) {
inode482fs/minix/namei.cinode->i_dev,inode->i_ino,inode->i_nlink);
inode483fs/minix/namei.cinode->i_nlink=1;
inode485fs/minix/namei.cde->inode = 0;
inode489fs/minix/namei.cinode->i_nlink--;
inode490fs/minix/namei.cinode->i_ctime = CURRENT_TIME;
inode491fs/minix/namei.cinode->i_dirt = 1;
inode495fs/minix/namei.ciput(inode);
inode500fs/minix/namei.cint minix_symlink(struct inode * dir, const char * name, int len, const char * symname)
inode503fs/minix/namei.cstruct inode * inode = NULL;
inode508fs/minix/namei.cif (!(inode = minix_new_inode(dir))) {
inode512fs/minix/namei.cinode->i_mode = S_IFLNK | 0777;
inode513fs/minix/namei.cinode->i_op = &minix_symlink_inode_operations;
inode514fs/minix/namei.cname_block = minix_bread(inode,0,1);
inode517fs/minix/namei.cinode->i_nlink--;
inode518fs/minix/namei.cinode->i_dirt = 1;
inode519fs/minix/namei.ciput(inode);
inode528fs/minix/namei.cinode->i_size = i;
inode529fs/minix/namei.cinode->i_dirt = 1;
inode532fs/minix/namei.cinode->i_nlink--;
inode533fs/minix/namei.cinode->i_dirt = 1;
inode534fs/minix/namei.ciput(inode);
inode541fs/minix/namei.cinode->i_nlink--;
inode542fs/minix/namei.cinode->i_dirt = 1;
inode543fs/minix/namei.ciput(inode);
inode547fs/minix/namei.cde->inode = inode->i_ino;
inode551fs/minix/namei.ciput(inode);
inode555fs/minix/namei.cint minix_link(struct inode * oldinode, struct inode * dir, const char * name, int len)
inode583fs/minix/namei.cde->inode = oldinode->i_ino;
inode594fs/minix/namei.cstatic int subdir(struct inode * new, struct inode * old)
inode623fs/minix/namei.c(((struct minix_dir_entry *) (buffer))[1].inode)
inode638fs/minix/namei.cstatic int do_minix_rename(struct inode * old_dir, const char * old_name, int old_len,
inode639fs/minix/namei.cstruct inode * new_dir, const char * new_name, int new_len)
inode641fs/minix/namei.cstruct inode * old_inode, * new_inode;
inode662fs/minix/namei.cold_inode = iget(old_dir->i_sb, old_de->inode);
inode672fs/minix/namei.cnew_inode = iget(new_dir->i_sb, new_de->inode);
inode717fs/minix/namei.cif (new_inode && (new_de->inode != new_inode->i_ino))
inode719fs/minix/namei.cif (new_de->inode && !new_inode)
inode721fs/minix/namei.cif (old_de->inode != old_inode->i_ino)
inode724fs/minix/namei.cold_de->inode = 0;
inode725fs/minix/namei.cnew_de->inode = old_inode->i_ino;
inode761fs/minix/namei.cint minix_rename(struct inode * old_dir, const char * old_name, int old_len,
inode762fs/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 int minix_follow_link(struct inode *, struct inode *, int, int, struct inode **);
inode41fs/minix/symlink.cstatic int minix_follow_link(struct inode * dir, struct inode * inode,
inode42fs/minix/symlink.cint flag, int mode, struct inode ** res_inode)
inode53fs/minix/symlink.cif (!inode) {
inode57fs/minix/symlink.cif (!S_ISLNK(inode->i_mode)) {
inode59fs/minix/symlink.c*res_inode = inode;
inode63fs/minix/symlink.ciput(inode);
inode67fs/minix/symlink.cif (!(bh = minix_bread(inode, 0, 0))) {
inode68fs/minix/symlink.ciput(inode);
inode72fs/minix/symlink.ciput(inode);
inode83fs/minix/symlink.cstatic int minix_readlink(struct inode * inode, char * buffer, int buflen)
inode89fs/minix/symlink.cif (!S_ISLNK(inode->i_mode)) {
inode90fs/minix/symlink.ciput(inode);
inode95fs/minix/symlink.cbh = minix_bread(inode, 0, 0);
inode96fs/minix/symlink.ciput(inode);
inode27fs/minix/truncate.cstatic int trunc_direct(struct inode * inode)
inode33fs/minix/truncate.c#define DIRECT_BLOCK ((inode->i_size + 1023) >> 10)
inode37fs/minix/truncate.cp = i + inode->u.minix_i.i_data;
inode40fs/minix/truncate.cbh = getblk(inode->i_dev,tmp,BLOCK_SIZE);
inode51fs/minix/truncate.cinode->i_dirt = 1;
inode53fs/minix/truncate.cminix_free_block(inode->i_sb,tmp);
inode58fs/minix/truncate.cstatic int trunc_indirect(struct inode * inode, int offset, unsigned short * p)
inode70fs/minix/truncate.cind_bh = bread(inode->i_dev, tmp, BLOCK_SIZE);
inode89fs/minix/truncate.cbh = getblk(inode->i_dev,tmp,BLOCK_SIZE);
inode102fs/minix/truncate.cminix_free_block(inode->i_sb,tmp);
inode114fs/minix/truncate.cminix_free_block(inode->i_sb,tmp);
inode120fs/minix/truncate.cstatic int trunc_dindirect(struct inode * inode)
inode128fs/minix/truncate.cp = 8 + inode->u.minix_i.i_data;
inode131fs/minix/truncate.cdind_bh = bread(inode->i_dev, tmp, BLOCK_SIZE);
inode147fs/minix/truncate.cretry |= trunc_indirect(inode,7+512+(i<<9),dind);
inode160fs/minix/truncate.cinode->i_dirt = 1;
inode161fs/minix/truncate.cminix_free_block(inode->i_sb,tmp);
inode167fs/minix/truncate.cvoid minix_truncate(struct inode * inode)
inode171fs/minix/truncate.cif (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
inode172fs/minix/truncate.cS_ISLNK(inode->i_mode)))
inode175fs/minix/truncate.cretry = trunc_direct(inode);
inode176fs/minix/truncate.cretry |= trunc_indirect(inode,7,inode->u.minix_i.i_data+7);
inode177fs/minix/truncate.cretry |= trunc_dindirect(inode);
inode183fs/minix/truncate.cinode->i_mtime = inode->i_ctime = CURRENT_TIME;
inode184fs/minix/truncate.cinode->i_dirt = 1;
inode17fs/msdos/dir.cstatic int msdos_dir_read(struct inode * inode,struct file * filp, char * buf,int count)
inode22fs/msdos/dir.cstatic int msdos_readdir(struct inode *inode,struct file *filp,
inode55fs/msdos/dir.cstatic int msdos_readdir(struct inode *inode,struct file *filp,
inode63fs/msdos/dir.cif (!inode || !S_ISDIR(inode->i_mode)) return -EBADF;
inode64fs/msdos/dir.cif (inode->i_ino == MSDOS_ROOT_INO) {
inode79fs/msdos/dir.cwhile ((ino = msdos_get_entry(inode,&filp->f_pos,&bh,&de)) > -1) {
inode100fs/msdos/dir.cino = inode->i_ino;
inode102fs/msdos/dir.cino = msdos_parent_ino(inode,0);
inode119fs/msdos/fat.cvoid cache_lookup(struct inode *inode,int cluster,int *f_clu,int *d_clu)
inode124fs/msdos/fat.cprintk("cache lookup: <%d,%d> %d (%d,%d) -> ",inode->i_dev,inode->i_ino,cluster,
inode128fs/msdos/fat.cif (inode->i_dev == walk->device && walk->ino == inode->i_ino &&
inode159fs/msdos/fat.cvoid cache_add(struct inode *inode,int f_clu,int d_clu)
inode164fs/msdos/fat.cprintk("cache add: <%d,%d> %d (%d)\n",inode->i_dev,inode->i_ino,f_clu,d_clu);
inode168fs/msdos/fat.cif (inode->i_dev == walk->device && walk->ino == inode->i_ino &&
inode182fs/msdos/fat.cwalk->device = inode->i_dev;
inode183fs/msdos/fat.cwalk->ino = inode->i_ino;
inode198fs/msdos/fat.cvoid cache_inval_inode(struct inode *inode)
inode203fs/msdos/fat.cif (walk->device == inode->i_dev && walk->ino == inode->i_ino)
inode217fs/msdos/fat.cint get_cluster(struct inode *inode,int cluster)
inode221fs/msdos/fat.cif (!(this = MSDOS_I(inode)->i_start)) return 0;
inode224fs/msdos/fat.cfor (cache_lookup(inode,cluster,&count,&this); count < cluster;
inode226fs/msdos/fat.cif ((this = fat_access(inode->i_sb,this,-1)) == -1) return 0;
inode229fs/msdos/fat.cif (!(MSDOS_I(inode)->i_busy && inode->i_nlink))
inode230fs/msdos/fat.ccache_add(inode,cluster,this);
inode237fs/msdos/fat.cint msdos_smap(struct inode *inode,int sector)
inode242fs/msdos/fat.csb = MSDOS_SB(inode->i_sb);
inode243fs/msdos/fat.cif (inode->i_ino == MSDOS_ROOT_INO || (S_ISDIR(inode->i_mode) &&
inode244fs/msdos/fat.c!MSDOS_I(inode)->i_start)) {
inode250fs/msdos/fat.cif (!(cluster = get_cluster(inode,cluster))) return 0;
inode258fs/msdos/fat.cint fat_free(struct inode *inode,int skip)
inode262fs/msdos/fat.cif (!(this = MSDOS_I(inode)->i_start)) return 0;
inode266fs/msdos/fat.cif ((this = fat_access(inode->i_sb,this,-1)) == -1) return 0;
inode273fs/msdos/fat.cfat_access(inode->i_sb,last,MSDOS_SB(inode->i_sb)->fat_bits ==
inode276fs/msdos/fat.cMSDOS_I(inode)->i_start = 0;
inode277fs/msdos/fat.cinode->i_dirt = 1;
inode279fs/msdos/fat.clock_fat(inode->i_sb);
inode281fs/msdos/fat.cif (!(this = fat_access(inode->i_sb,this,0)))
inode283fs/msdos/fat.cif (MSDOS_SB(inode->i_sb)->free_clusters != -1)
inode284fs/msdos/fat.cMSDOS_SB(inode->i_sb)->free_clusters++;
inode285fs/msdos/fat.cinode->i_blocks -= MSDOS_SB(inode->i_sb)->cluster_size;
inode287fs/msdos/fat.cunlock_fat(inode->i_sb);
inode288fs/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,
inode79fs/msdos/file.cstatic int msdos_file_read(struct inode *inode,struct file *filp,char *buf,
inode89fs/msdos/file.cif (!inode) {
inode93fs/msdos/file.cif (!S_ISREG(inode->i_mode)) {
inode94fs/msdos/file.cprintk("msdos_file_read: mode = %07o\n",inode->i_mode);
inode97fs/msdos/file.cif (filp->f_pos >= inode->i_size || count <= 0) return 0;
inode99fs/msdos/file.cwhile ((left = MIN(inode->i_size-filp->f_pos,count-(buf-start))) > 0){
inode100fs/msdos/file.cif (!(sector = msdos_smap(inode,filp->f_pos >> SECTOR_BITS)))
inode103fs/msdos/file.cif (!(bh = msdos_sread(inode->i_dev,sector,&data))) break;
inode105fs/msdos/file.cif (MSDOS_I(inode)->i_binary) {
inode115fs/msdos/file.cfilp->f_pos = inode->i_size;
inode128fs/msdos/file.cstatic int msdos_file_write(struct inode *inode,struct file *filp,char *buf,
inode137fs/msdos/file.cif (!inode) {
inode141fs/msdos/file.cif (!S_ISREG(inode->i_mode)) {
inode142fs/msdos/file.cprintk("msdos_file_write: mode = %07o\n",inode->i_mode);
inode149fs/msdos/file.cif (filp->f_flags & O_APPEND) filp->f_pos = inode->i_size;
inode153fs/msdos/file.cwhile (!(sector = msdos_smap(inode,filp->f_pos >> SECTOR_BITS)))
inode154fs/msdos/file.cif ((error = msdos_add_cluster(inode)) < 0) break;
inode156fs/msdos/file.cmsdos_truncate(inode);
inode161fs/msdos/file.cif (!(bh = msdos_sread(inode->i_dev,sector,&data))) {
inode165fs/msdos/file.cif (MSDOS_I(inode)->i_binary) {
inode192fs/msdos/file.cif (filp->f_pos > inode->i_size) {
inode193fs/msdos/file.cinode->i_size = filp->f_pos;
inode194fs/msdos/file.cinode->i_dirt = 1;
inode199fs/msdos/file.cinode->i_mtime = inode->i_ctime = CURRENT_TIME;
inode200fs/msdos/file.cMSDOS_I(inode)->i_attrs |= ATTR_ARCH;
inode201fs/msdos/file.cinode->i_dirt = 1;
inode206fs/msdos/file.cvoid msdos_truncate(struct inode *inode)
inode210fs/msdos/file.ccluster = SECTOR_SIZE*MSDOS_SB(inode->i_sb)->cluster_size;
inode211fs/msdos/file.c(void) fat_free(inode,(inode->i_size+(cluster-1))/cluster);
inode212fs/msdos/file.cMSDOS_I(inode)->i_attrs |= ATTR_ARCH;
inode213fs/msdos/file.cinode->i_dirt = 1;
inode18fs/msdos/inode.cvoid msdos_put_inode(struct inode *inode)
inode20fs/msdos/inode.cstruct inode *depend;
inode22fs/msdos/inode.cif (inode->i_nlink)
inode24fs/msdos/inode.cinode->i_size = 0;
inode25fs/msdos/inode.cmsdos_truncate(inode);
inode26fs/msdos/inode.cdepend = MSDOS_I(inode)->i_depend;
inode27fs/msdos/inode.cclear_inode(inode);
inode29fs/msdos/inode.cif (MSDOS_I(depend)->i_old != inode) {
inode31fs/msdos/inode.c"0x%X\n",(int) depend,(int) inode,(int)
inode216fs/msdos/inode.cint msdos_bmap(struct inode *inode,int block)
inode221fs/msdos/inode.csb = MSDOS_SB(inode->i_sb);
inode223fs/msdos/inode.cif (inode->i_ino == MSDOS_ROOT_INO) {
inode229fs/msdos/inode.cif (!(cluster = get_cluster(inode,cluster))) return 0;
inode234fs/msdos/inode.cvoid msdos_read_inode(struct inode *inode)
inode241fs/msdos/inode.cMSDOS_I(inode)->i_busy = 0;
inode242fs/msdos/inode.cMSDOS_I(inode)->i_depend = MSDOS_I(inode)->i_old = NULL;
inode243fs/msdos/inode.cMSDOS_I(inode)->i_binary = 1;
inode244fs/msdos/inode.cinode->i_uid = MSDOS_SB(inode->i_sb)->fs_uid;
inode245fs/msdos/inode.cinode->i_gid = MSDOS_SB(inode->i_sb)->fs_gid;
inode246fs/msdos/inode.cif (inode->i_ino == MSDOS_ROOT_INO) {
inode247fs/msdos/inode.cinode->i_mode = (0777 & ~MSDOS_SB(inode->i_sb)->fs_umask) |
inode249fs/msdos/inode.cinode->i_op = &msdos_dir_inode_operations;
inode250fs/msdos/inode.cinode->i_nlink = msdos_subdirs(inode)+2;
inode252fs/msdos/inode.cinode->i_size = MSDOS_SB(inode->i_sb)->dir_entries*
inode254fs/msdos/inode.cinode->i_blksize = MSDOS_SB(inode->i_sb)->cluster_size*
inode256fs/msdos/inode.cinode->i_blocks = (inode->i_size+inode->i_blksize-1)/
inode257fs/msdos/inode.cinode->i_blksize*MSDOS_SB(inode->i_sb)->cluster_size;
inode258fs/msdos/inode.cMSDOS_I(inode)->i_start = 0;
inode259fs/msdos/inode.cMSDOS_I(inode)->i_attrs = 0;
inode260fs/msdos/inode.cinode->i_mtime = inode->i_atime = inode->i_ctime = 0;
inode263fs/msdos/inode.cif (!(bh = bread(inode->i_dev,inode->i_ino >> MSDOS_DPB_BITS, BLOCK_SIZE)))
inode266fs/msdos/inode.c[inode->i_ino & (MSDOS_DPB-1)];
inode269fs/msdos/inode.cinode->i_mode = MSDOS_MKMODE(raw_entry->attr,0777 &
inode270fs/msdos/inode.c~MSDOS_SB(inode->i_sb)->fs_umask) | S_IFDIR;
inode271fs/msdos/inode.cinode->i_op = &msdos_dir_inode_operations;
inode272fs/msdos/inode.cMSDOS_I(inode)->i_start = raw_entry->start;
inode273fs/msdos/inode.cinode->i_nlink = msdos_subdirs(inode);
inode276fs/msdos/inode.cif (!inode->i_nlink) {
inode277fs/msdos/inode.cprintk("directory %d: i_nlink == 0\n",inode->i_ino);
inode278fs/msdos/inode.cinode->i_nlink = 1;
inode281fs/msdos/inode.cinode->i_size = 0;
inode284fs/msdos/inode.cinode->i_size += SECTOR_SIZE*MSDOS_SB(inode->
inode286fs/msdos/inode.cif (!(this = fat_access(inode->i_sb,this,-1)))
inode288fs/msdos/inode.cinode->i_ino);
inode292fs/msdos/inode.cinode->i_mode = MSDOS_MKMODE(raw_entry->attr,0666 &
inode293fs/msdos/inode.c~MSDOS_SB(inode->i_sb)->fs_umask) | S_IFREG;
inode294fs/msdos/inode.cinode->i_op = MSDOS_CAN_BMAP(MSDOS_SB(inode->i_sb)) ? 
inode297fs/msdos/inode.cMSDOS_I(inode)->i_start = raw_entry->start;
inode298fs/msdos/inode.cinode->i_nlink = 1;
inode299fs/msdos/inode.cinode->i_size = raw_entry->size;
inode301fs/msdos/inode.cMSDOS_I(inode)->i_binary = is_binary(MSDOS_SB(inode->i_sb)->conversion,
inode303fs/msdos/inode.cMSDOS_I(inode)->i_attrs = raw_entry->attr & ATTR_UNUSED;
inode305fs/msdos/inode.cinode->i_blksize = MSDOS_SB(inode->i_sb)->cluster_size*SECTOR_SIZE;
inode306fs/msdos/inode.cinode->i_blocks = (inode->i_size+inode->i_blksize-1)/
inode307fs/msdos/inode.cinode->i_blksize*MSDOS_SB(inode->i_sb)->cluster_size;
inode308fs/msdos/inode.cinode->i_mtime = inode->i_atime = inode->i_ctime =
inode314fs/msdos/inode.cvoid msdos_write_inode(struct inode *inode)
inode319fs/msdos/inode.cinode->i_dirt = 0;
inode320fs/msdos/inode.cif (inode->i_ino == MSDOS_ROOT_INO || !inode->i_nlink) return;
inode321fs/msdos/inode.cif (!(bh = bread(inode->i_dev,inode->i_ino >> MSDOS_DPB_BITS, BLOCK_SIZE)))
inode324fs/msdos/inode.c[inode->i_ino & (MSDOS_DPB-1)];
inode325fs/msdos/inode.cif (S_ISDIR(inode->i_mode)) {
inode331fs/msdos/inode.craw_entry->size = inode->i_size;
inode333fs/msdos/inode.craw_entry->attr |= MSDOS_MKATTR(inode->i_mode) |
inode334fs/msdos/inode.cMSDOS_I(inode)->i_attrs;
inode335fs/msdos/inode.craw_entry->start = MSDOS_I(inode)->i_start;
inode336fs/msdos/inode.cdate_unix2dos(inode->i_mtime,&raw_entry->time,&raw_entry->date);
inode79fs/msdos/misc.cint msdos_add_cluster(struct inode *inode)
inode88fs/msdos/misc.cif (inode->i_ino == MSDOS_ROOT_INO) return -ENOSPC;
inode89fs/msdos/misc.cif (!MSDOS_SB(inode->i_sb)->free_clusters) return -ENOSPC;
inode92fs/msdos/misc.clock_fat(inode->i_sb);
inode93fs/msdos/misc.climit = MSDOS_SB(inode->i_sb)->clusters;
inode97fs/msdos/misc.cif (fat_access(inode->i_sb,this,-1) == 0) break;
inode104fs/msdos/misc.cMSDOS_SB(inode->i_sb)->free_clusters = 0;
inode105fs/msdos/misc.cunlock_fat(inode->i_sb);
inode110fs/msdos/misc.cfat_access(inode->i_sb,this,MSDOS_SB(inode->i_sb)->fat_bits == 12 ?
inode112fs/msdos/misc.cif (MSDOS_SB(inode->i_sb)->free_clusters != -1)
inode113fs/msdos/misc.cMSDOS_SB(inode->i_sb)->free_clusters--;
inode114fs/msdos/misc.cunlock_fat(inode->i_sb);
inode118fs/msdos/misc.cprintk("set to %x\n",fat_access(inode->i_sb,this,-1));
inode121fs/msdos/misc.cif ((current = MSDOS_I(inode)->i_start) != 0) {
inode122fs/msdos/misc.ccache_lookup(inode,0x7fffffff,&last,&current);
inode124fs/msdos/misc.cif (!(current = fat_access(inode->i_sb,
inode131fs/msdos/misc.cif (last) fat_access(inode->i_sb,last,this);
inode133fs/msdos/misc.cMSDOS_I(inode)->i_start = this;
inode134fs/msdos/misc.cinode->i_dirt = 1;
inode137fs/msdos/misc.cif (last) printk("next set to %d\n",fat_access(inode->i_sb,last,-1));
inode139fs/msdos/misc.cfor (current = 0; current < MSDOS_SB(inode->i_sb)->cluster_size;
inode141fs/msdos/misc.csector = MSDOS_SB(inode->i_sb)->data_start+(this-2)*
inode142fs/msdos/misc.cMSDOS_SB(inode->i_sb)->cluster_size+current;
inode146fs/msdos/misc.cif (current < MSDOS_SB(inode->i_sb)->cluster_size-1 &&
inode148fs/msdos/misc.cif (!(bh = getblk(inode->i_dev,sector >> 1, BLOCK_SIZE)))
inode157fs/msdos/misc.cif (!(bh = msdos_sread(inode->i_dev,sector,&data)))
inode166fs/msdos/misc.cinode->i_blocks += MSDOS_SB(inode->i_sb)->cluster_size;
inode167fs/msdos/misc.cif (S_ISDIR(inode->i_mode)) {
inode168fs/msdos/misc.cif (inode->i_size & (SECTOR_SIZE-1))
inode170fs/msdos/misc.cinode->i_size += SECTOR_SIZE*MSDOS_SB(inode->i_sb)->
inode173fs/msdos/misc.cprintk("size is %d now (%x)\n",inode->i_size,inode);
inode175fs/msdos/misc.cinode->i_dirt = 1;
inode238fs/msdos/misc.cint msdos_get_entry(struct inode *dir,int *pos,struct buffer_head **bh,
inode268fs/msdos/misc.cint msdos_scan(struct inode *dir,char *name,struct buffer_head **res_bh,
inode273fs/msdos/misc.cstruct inode *inode;
inode285fs/msdos/misc.cif (!(inode = iget(dir->i_sb,*ino))) break;
inode286fs/msdos/misc.cif (!MSDOS_I(inode)->i_busy) {
inode287fs/msdos/misc.ciput(inode);
inode291fs/msdos/misc.ciput(inode);
inode390fs/msdos/misc.cint msdos_parent_ino(struct inode *dir,int locked)
inode419fs/msdos/misc.cint msdos_subdirs(struct inode *dir)
inode99fs/msdos/namei.cstatic int msdos_find(struct inode *dir,const char *name,int len,
inode111fs/msdos/namei.cint msdos_lookup(struct inode *dir,const char *name,int len,
inode112fs/msdos/namei.cstruct inode **result)
inode117fs/msdos/namei.cstruct inode *next;
inode165fs/msdos/namei.cstatic int msdos_create_entry(struct inode *dir,char *name,int is_dir,
inode166fs/msdos/namei.cstruct inode **result)
inode194fs/msdos/namei.cint msdos_create(struct inode *dir,const char *name,int len,int mode,
inode195fs/msdos/namei.cstruct inode **result)
inode242fs/msdos/namei.cint msdos_mkdir(struct inode *dir,const char *name,int len,int mode)
inode246fs/msdos/namei.cstruct inode *inode,*dot;
inode262fs/msdos/namei.cif ((res = msdos_create_entry(dir,msdos_name,1,&inode)) < 0) {
inode268fs/msdos/namei.cinode->i_nlink = 2; /* no need to mark them dirty */
inode269fs/msdos/namei.cMSDOS_I(inode)->i_busy = 1; /* prevent lookups */
inode270fs/msdos/namei.cif ((res = msdos_add_cluster(inode)) < 0) goto mkdir_error;
inode271fs/msdos/namei.cif ((res = msdos_create_entry(inode,MSDOS_DOT,1,&dot)) < 0)
inode273fs/msdos/namei.cdot->i_size = inode->i_size; /* doesn't grow in the 2nd create_entry */
inode274fs/msdos/namei.cMSDOS_I(dot)->i_start = MSDOS_I(inode)->i_start;
inode275fs/msdos/namei.cdot->i_nlink = inode->i_nlink;
inode278fs/msdos/namei.cif ((res = msdos_create_entry(inode,MSDOS_DOTDOT,1,&dot)) < 0)
inode285fs/msdos/namei.cMSDOS_I(inode)->i_busy = 0;
inode287fs/msdos/namei.ciput(inode);
inode291fs/msdos/namei.ciput(inode);
inode298fs/msdos/namei.cint msdos_rmdir(struct inode *dir,const char *name,int len)
inode303fs/msdos/namei.cstruct inode *inode;
inode306fs/msdos/namei.cinode = NULL;
inode312fs/msdos/namei.cif (!(inode = iget(dir->i_sb,ino))) goto rmdir_done;
inode314fs/msdos/namei.cif (!S_ISDIR(inode->i_mode)) goto rmdir_done;
inode316fs/msdos/namei.cif (dir->i_dev != inode->i_dev || dir == inode) goto rmdir_done;
inode317fs/msdos/namei.cif (inode->i_count > 1) goto rmdir_done;
inode318fs/msdos/namei.cif (MSDOS_I(inode)->i_start) { /* may be zero in mkdir */
inode322fs/msdos/namei.cwhile (msdos_get_entry(inode,&pos,&dbh,&dde) > -1)
inode329fs/msdos/namei.cinode->i_nlink = 0;
inode332fs/msdos/namei.cinode->i_dirt = dir->i_dirt = 1;
inode339fs/msdos/namei.ciput(inode);
inode344fs/msdos/namei.cint msdos_unlink(struct inode *dir,const char *name,int len)
inode349fs/msdos/namei.cstruct inode *inode;
inode352fs/msdos/namei.cinode = NULL;
inode355fs/msdos/namei.cif (!(inode = iget(dir->i_sb,ino))) {
inode359fs/msdos/namei.cif (!S_ISREG(inode->i_mode)) {
inode363fs/msdos/namei.cinode->i_nlink = 0;
inode364fs/msdos/namei.cMSDOS_I(inode)->i_busy = 1;
inode365fs/msdos/namei.cinode->i_dirt = 1;
inode370fs/msdos/namei.ciput(inode);
inode376fs/msdos/namei.cstatic int rename_same_dir(struct inode *old_dir,char *old_name,
inode377fs/msdos/namei.cstruct inode *new_dir,char *new_name,struct buffer_head *old_bh,
inode382fs/msdos/namei.cstruct inode *new_inode,*old_inode;
inode421fs/msdos/namei.cstatic int rename_diff_dir(struct inode *old_dir,char *old_name,
inode422fs/msdos/namei.cstruct inode *new_dir,char *new_name,struct buffer_head *old_bh,
inode427fs/msdos/namei.cstruct inode *old_inode,*new_inode,*free_inode,*dotdot_inode,*walk;
inode530fs/msdos/namei.cint msdos_rename(struct inode *old_dir,const char *old_name,int old_len,
inode531fs/msdos/namei.cstruct inode *new_dir,const char *new_name,int new_len)
inode35fs/namei.cint permission(struct inode * inode,int mask)
inode37fs/namei.cint mode = inode->i_mode;
inode40fs/namei.cif (inode->i_dev && !inode->i_nlink)
inode42fs/namei.celse if (inode->i_op && inode->i_op->permission)
inode43fs/namei.creturn inode->i_op->permission(inode, mask);
inode44fs/namei.celse if (current->euid == inode->i_uid)
inode46fs/namei.celse if (in_group_p(inode->i_gid))
inode58fs/namei.cint lookup(struct inode * dir,const char * name, int len,
inode59fs/namei.cstruct inode ** result)
inode92fs/namei.cint follow_link(struct inode * dir, struct inode * inode,
inode93fs/namei.cint flag, int mode, struct inode ** res_inode)
inode95fs/namei.cif (!dir || !inode) {
inode97fs/namei.ciput(inode);
inode101fs/namei.cif (!inode->i_op || !inode->i_op->follow_link) {
inode103fs/namei.c*res_inode = inode;
inode106fs/namei.creturn inode->i_op->follow_link(dir,inode,flag,mode,res_inode);
inode116fs/namei.cstruct inode * base, struct inode ** res_inode)
inode121fs/namei.cstruct inode * inode;
inode141fs/namei.cerror = lookup(base,thisname,len,&inode);
inode146fs/namei.cerror = follow_link(base,inode,0,0,&base);
inode160fs/namei.cstatic int _namei(const char * pathname, struct inode * base,
inode161fs/namei.cint follow_links, struct inode ** res_inode)
inode165fs/namei.cstruct inode * inode;
inode172fs/namei.cerror = lookup(base,basename,namelen,&inode);
inode178fs/namei.cerror = follow_link(base,inode,0,0,&inode);
inode183fs/namei.c*res_inode = inode;
inode187fs/namei.cint lnamei(const char * pathname, struct inode ** res_inode)
inode199fs/namei.cint namei(const char * pathname, struct inode ** res_inode)
inode218fs/namei.cstruct inode ** res_inode, struct inode * base)
inode222fs/namei.cstruct inode * dir, *inode;
inode244fs/namei.cerror = lookup(dir,basename,namelen,&inode);
inode266fs/namei.ciput(inode);
inode269fs/namei.cerror = follow_link(dir,inode,flag,mode,&inode);
inode272fs/namei.cif (S_ISDIR(inode->i_mode) && (flag & 2)) {
inode273fs/namei.ciput(inode);
inode276fs/namei.cif (!permission(inode,ACC_MODE(flag))) {
inode277fs/namei.ciput(inode);
inode280fs/namei.cif (S_ISBLK(inode->i_mode) || S_ISCHR(inode->i_mode)) {
inode281fs/namei.cif (IS_NODEV(inode)) {
inode282fs/namei.ciput(inode);
inode286fs/namei.cif (IS_RDONLY(inode) && (flag & 2)) {
inode287fs/namei.ciput(inode);
inode291fs/namei.cif ((inode->i_count > 1) && (flag & 2))
inode295fs/namei.cif (inode == (*p)->executable) {
inode296fs/namei.ciput(inode);
inode300fs/namei.cif (inode == (*p)->libraries[i].library) {
inode301fs/namei.ciput(inode);
inode305fs/namei.c*res_inode = inode;
inode313fs/namei.cstruct inode * dir;
inode348fs/namei.cstruct inode * dir;
inode376fs/namei.cstruct inode * dir;
inode404fs/namei.cstruct inode * dir;
inode430fs/namei.cstruct inode * dir;
inode458fs/namei.cstruct inode * oldinode, * dir;
inode500fs/namei.cstruct inode * old_dir, * new_dir;
inode17fs/nfs/blkdev.cstatic int blkdev_open(struct inode * inode, struct file * filp)
inode21fs/nfs/blkdev.ci = MAJOR(inode->i_rdev);
inode26fs/nfs/blkdev.creturn filp->f_op->open(inode,filp);
inode17fs/nfs/chrdev.cstatic int chrdev_open(struct inode * inode, struct file * filp)
inode21fs/nfs/chrdev.ci = MAJOR(inode->i_rdev);
inode26fs/nfs/chrdev.creturn filp->f_op->open(inode,filp);
inode20fs/nfs/dir.cstatic int nfs_dir_read(struct inode *, struct file *filp, char *buf,
inode22fs/nfs/dir.cstatic int nfs_readdir(struct inode *, struct file *, struct dirent *, int);
inode23fs/nfs/dir.cstatic int nfs_lookup(struct inode *dir, const char *name, int len,
inode24fs/nfs/dir.cstruct inode **result);
inode25fs/nfs/dir.cstatic int nfs_create(struct inode *dir, const char *name, int len, int mode,
inode26fs/nfs/dir.cstruct inode **result);
inode27fs/nfs/dir.cstatic int nfs_mkdir(struct inode *dir, const char *name, int len, int mode);
inode28fs/nfs/dir.cstatic int nfs_rmdir(struct inode *dir, const char *name, int len);
inode29fs/nfs/dir.cstatic int nfs_unlink(struct inode *dir, const char *name, int len);
inode30fs/nfs/dir.cstatic int nfs_symlink(struct inode *inode, const char *name, int len,
inode32fs/nfs/dir.cstatic int nfs_link(struct inode *oldinode, struct inode *dir,
inode34fs/nfs/dir.cstatic int nfs_mknod(struct inode *dir, const char *name, int len, int mode,
inode36fs/nfs/dir.cstatic int nfs_rename(struct inode *old_dir, const char *old_name,
inode37fs/nfs/dir.cint old_len, struct inode *new_dir, const char *new_name,
inode70fs/nfs/dir.cstatic int nfs_dir_read(struct inode *inode, struct file *filp, char *buf,
inode84fs/nfs/dir.cstatic int nfs_readdir(struct inode *inode, struct file *filp,
inode96fs/nfs/dir.cif (!inode || !S_ISDIR(inode->i_mode)) {
inode115fs/nfs/dir.cif (inode->i_dev == c_dev && inode->i_ino == c_ino) {
inode132fs/nfs/dir.cresult = nfs_proc_readdir(NFS_SERVER(inode), NFS_FH(inode),
inode139fs/nfs/dir.cc_dev = inode->i_dev;
inode140fs/nfs/dir.cc_ino = inode->i_ino;
inode174fs/nfs/dir.cint inode;
inode181fs/nfs/dir.cstatic struct nfs_lookup_cache_entry *nfs_lookup_cache_index(struct inode *dir,
inode189fs/nfs/dir.cif (entry->dev == dir->i_dev && entry->inode == dir->i_ino
inode196fs/nfs/dir.cstatic int nfs_lookup_cache_lookup(struct inode *dir, char *filename,
inode220fs/nfs/dir.cstatic void nfs_lookup_cache_add(struct inode *dir, char *filename,
inode237fs/nfs/dir.centry->inode = dir->i_ino;
inode245fs/nfs/dir.cstatic void nfs_lookup_cache_remove(struct inode *dir, struct inode *inode,
inode253fs/nfs/dir.cif (inode) {
inode254fs/nfs/dir.cdev = inode->i_dev;
inode255fs/nfs/dir.cfileid = inode->i_ino;
inode270fs/nfs/dir.cstatic void nfs_lookup_cache_refresh(struct inode *file,
inode285fs/nfs/dir.cstatic int nfs_lookup(struct inode *dir, const char *name, int len,
inode286fs/nfs/dir.cstruct inode **result)
inode326fs/nfs/dir.cstatic int nfs_create(struct inode *dir, const char *name, int len, int mode,
inode327fs/nfs/dir.cstruct inode **result)
inode364fs/nfs/dir.cstatic int nfs_mknod(struct inode *dir, const char *name, int len,
inode399fs/nfs/dir.cstatic int nfs_mkdir(struct inode *dir, const char *name, int len, int mode)
inode429fs/nfs/dir.cstatic int nfs_rmdir(struct inode *dir, const char *name, int len)
inode452fs/nfs/dir.cstatic int nfs_unlink(struct inode *dir, const char *name, int len)
inode475fs/nfs/dir.cstatic int nfs_symlink(struct inode *dir, const char *name, int len,
inode515fs/nfs/dir.cstatic int nfs_link(struct inode *oldinode, struct inode *dir,
inode549fs/nfs/dir.cstatic int nfs_rename(struct inode *old_dir, const char *old_name, int old_len,
inode550fs/nfs/dir.cstruct inode *new_dir, const char *new_name, int new_len)
inode593fs/nfs/dir.cvoid nfs_refresh_inode(struct inode *inode, struct nfs_fattr *fattr)
inode597fs/nfs/dir.cif (!inode || !fattr) {
inode601fs/nfs/dir.cif (inode->i_ino != fattr->fileid) {
inode605fs/nfs/dir.cwas_empty = inode->i_mode == 0;
inode606fs/nfs/dir.cinode->i_mode = fattr->mode;
inode607fs/nfs/dir.cinode->i_nlink = fattr->nlink;
inode608fs/nfs/dir.cinode->i_uid = fattr->uid;
inode609fs/nfs/dir.cinode->i_gid = fattr->gid;
inode610fs/nfs/dir.cinode->i_size = fattr->size;
inode611fs/nfs/dir.cinode->i_blksize = fattr->blocksize;
inode612fs/nfs/dir.cif (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
inode613fs/nfs/dir.cinode->i_rdev = fattr->rdev;
inode615fs/nfs/dir.cinode->i_rdev = 0;
inode616fs/nfs/dir.cinode->i_blocks = fattr->blocks;
inode617fs/nfs/dir.cinode->i_atime = fattr->atime.seconds;
inode618fs/nfs/dir.cinode->i_mtime = fattr->mtime.seconds;
inode619fs/nfs/dir.cinode->i_ctime = fattr->ctime.seconds;
inode621fs/nfs/dir.cif (S_ISREG(inode->i_mode))
inode622fs/nfs/dir.cinode->i_op = &nfs_file_inode_operations;
inode623fs/nfs/dir.celse if (S_ISDIR(inode->i_mode))
inode624fs/nfs/dir.cinode->i_op = &nfs_dir_inode_operations;
inode625fs/nfs/dir.celse if (S_ISLNK(inode->i_mode))
inode626fs/nfs/dir.cinode->i_op = &nfs_symlink_inode_operations;
inode627fs/nfs/dir.celse if (S_ISCHR(inode->i_mode))
inode628fs/nfs/dir.cinode->i_op = &nfs_chrdev_inode_operations;
inode629fs/nfs/dir.celse if (S_ISBLK(inode->i_mode))
inode630fs/nfs/dir.cinode->i_op = &nfs_blkdev_inode_operations;
inode631fs/nfs/dir.celse if (S_ISFIFO(inode->i_mode)) {
inode632fs/nfs/dir.cinode->i_op = &nfs_fifo_inode_operations;
inode633fs/nfs/dir.cinode->i_pipe = 1;
inode634fs/nfs/dir.cPIPE_BASE(*inode) = NULL;
inode635fs/nfs/dir.cPIPE_HEAD(*inode) = PIPE_TAIL(*inode) = 0;
inode636fs/nfs/dir.cPIPE_READERS(*inode) = PIPE_WRITERS(*inode) = 0;
inode639fs/nfs/dir.cinode->i_op = NULL;
inode641fs/nfs/dir.cnfs_lookup_cache_refresh(inode, fattr);
inode20fs/nfs/file.cstatic int nfs_file_read(struct inode *, struct file *, char *, int);
inode21fs/nfs/file.cstatic int nfs_file_write(struct inode *, struct file *, char *, int);
inode52fs/nfs/file.cstatic int nfs_file_read(struct inode *inode, struct file *file, char *buf,
inode62fs/nfs/file.cif (!inode) {
inode66fs/nfs/file.cif (!S_ISREG(inode->i_mode)) {
inode68fs/nfs/file.cinode->i_mode);
inode71fs/nfs/file.cif (file->f_pos + count > inode->i_size)
inode72fs/nfs/file.ccount = inode->i_size - file->f_pos;
inode75fs/nfs/file.cn = NFS_SERVER(inode)->rsize;
inode81fs/nfs/file.cresult = nfs_proc_read(NFS_SERVER(inode), NFS_FH(inode), 
inode96fs/nfs/file.cnfs_refresh_inode(inode, &fattr);
inode100fs/nfs/file.cstatic int nfs_file_write(struct inode *inode, struct file *file, char *buf,
inode110fs/nfs/file.cif (!inode) {
inode114fs/nfs/file.cif (!S_ISREG(inode->i_mode)) {
inode116fs/nfs/file.cinode->i_mode);
inode122fs/nfs/file.cfile->f_pos = inode->i_size;
inode123fs/nfs/file.cn = NFS_SERVER(inode)->wsize;
inode130fs/nfs/file.cresult = nfs_proc_write(NFS_SERVER(inode), NFS_FH(inode), 
inode144fs/nfs/file.cnfs_refresh_inode(inode, &fattr);
inode23fs/nfs/inode.cstatic int nfs_notify_change(struct inode *);
inode149fs/nfs/inode.cstruct inode *nfs_fhget(struct super_block *sb, struct nfs_fh *fhandle,
inode154fs/nfs/inode.cstruct inode *inode;
inode169fs/nfs/inode.cif (!(inode = iget(sb, fattr->fileid))) {
inode173fs/nfs/inode.cif (inode->i_dev == sb->s_dev) {
inode174fs/nfs/inode.cif (inode->i_ino != fattr->fileid) {
inode176fs/nfs/inode.creturn inode;
inode178fs/nfs/inode.c*NFS_FH(inode) = *fhandle;
inode179fs/nfs/inode.cnfs_refresh_inode(inode, fattr);
inode181fs/nfs/inode.creturn inode;
inode184fs/nfs/inode.cint nfs_notify_change(struct inode *inode)
inode190fs/nfs/inode.csattr.mode = inode->i_mode;
inode191fs/nfs/inode.csattr.uid = inode->i_uid;
inode192fs/nfs/inode.csattr.gid = inode->i_gid;
inode193fs/nfs/inode.csattr.size = S_ISREG(inode->i_mode) ? inode->i_size : -1;
inode194fs/nfs/inode.csattr.mtime.seconds = inode->i_mtime;
inode196fs/nfs/inode.csattr.atime.seconds = inode->i_atime;
inode198fs/nfs/inode.cerror = nfs_proc_setattr(NFS_SERVER(inode), NFS_FH(inode),
inode201fs/nfs/inode.cnfs_refresh_inode(inode, &fattr);
inode202fs/nfs/inode.cinode->i_dirt = 0;
inode19fs/nfs/sock.cextern struct socket *socki_lookup(struct inode *inode);
inode34fs/nfs/sock.cstruct inode *inode;
inode42fs/nfs/sock.cint (*select) (struct inode *, struct file *, int, select_table *);
inode54fs/nfs/sock.cinode = file->f_inode;
inode56fs/nfs/sock.csock = socki_lookup(inode);
inode78fs/nfs/sock.cif (!select(inode, file, SEL_IN, &wait_table)
inode79fs/nfs/sock.c&& !select(inode, file, SEL_IN, NULL)) {
inode17fs/nfs/symlink.cstatic int nfs_readlink(struct inode *, char *, int);
inode18fs/nfs/symlink.cstatic int nfs_follow_link(struct inode *, struct inode *, int, int,
inode19fs/nfs/symlink.cstruct inode **);
inode42fs/nfs/symlink.cstatic int nfs_follow_link(struct inode *dir, struct inode *inode,
inode43fs/nfs/symlink.cint flag, int mode, struct inode **res_inode)
inode54fs/nfs/symlink.cif (!inode) {
inode58fs/nfs/symlink.cif (!S_ISLNK(inode->i_mode)) {
inode60fs/nfs/symlink.c*res_inode = inode;
inode64fs/nfs/symlink.ciput(inode);
inode69fs/nfs/symlink.cerror = nfs_proc_readlink(NFS_SERVER(inode), NFS_FH(inode), res);
inode71fs/nfs/symlink.ciput(inode);
inode76fs/nfs/symlink.ciput(inode);
inode87fs/nfs/symlink.cstatic int nfs_readlink(struct inode *inode, char *buffer, int buflen)
inode94fs/nfs/symlink.cif (!S_ISLNK(inode->i_mode)) {
inode95fs/nfs/symlink.ciput(inode);
inode101fs/nfs/symlink.cerror = nfs_proc_readlink(NFS_SERVER(inode), NFS_FH(inode), res);
inode102fs/nfs/symlink.ciput(inode);
inode39fs/open.cstruct inode * inode;
inode43fs/open.cerror = namei(path,&inode);
inode46fs/open.cif (!inode->i_sb->s_op->statfs) {
inode47fs/open.ciput(inode);
inode50fs/open.cinode->i_sb->s_op->statfs(inode->i_sb, buf);
inode51fs/open.ciput(inode);
inode57fs/open.cstruct inode * inode;
inode63fs/open.cif (!(inode = file->f_inode))
inode65fs/open.cif (!inode->i_sb->s_op->statfs)
inode67fs/open.cinode->i_sb->s_op->statfs(inode->i_sb, buf);
inode73fs/open.cstruct inode * inode;
inode76fs/open.cerror = namei(path,&inode);
inode79fs/open.cif (S_ISDIR(inode->i_mode) || !permission(inode,MAY_WRITE)) {
inode80fs/open.ciput(inode);
inode83fs/open.cif (IS_RDONLY(inode)) {
inode84fs/open.ciput(inode);
inode87fs/open.cinode->i_size = length;
inode88fs/open.cif (inode->i_op && inode->i_op->truncate)
inode89fs/open.cinode->i_op->truncate(inode);
inode90fs/open.cinode->i_atime = inode->i_mtime = CURRENT_TIME;
inode91fs/open.cinode->i_dirt = 1;
inode92fs/open.cerror = notify_change(inode);
inode93fs/open.ciput(inode);
inode99fs/open.cstruct inode * inode;
inode104fs/open.cif (!(inode = file->f_inode))
inode106fs/open.cif (S_ISDIR(inode->i_mode) || !(file->f_mode & 2))
inode108fs/open.cinode->i_size = length;
inode109fs/open.cif (inode->i_op && inode->i_op->truncate)
inode110fs/open.cinode->i_op->truncate(inode);
inode111fs/open.cinode->i_atime = inode->i_mtime = CURRENT_TIME;
inode112fs/open.cinode->i_dirt = 1;
inode113fs/open.creturn notify_change(inode);
inode122fs/open.cstruct inode * inode;
inode126fs/open.cerror = namei(filename,&inode);
inode129fs/open.cif (IS_RDONLY(inode)) {
inode130fs/open.ciput(inode);
inode134fs/open.cif ((current->euid != inode->i_uid) && !suser()) {
inode135fs/open.ciput(inode);
inode141fs/open.cif ((current->euid != inode->i_uid) &&
inode142fs/open.c!permission(inode,MAY_WRITE)) {
inode143fs/open.ciput(inode);
inode148fs/open.cinode->i_atime = actime;
inode149fs/open.cinode->i_mtime = modtime;
inode150fs/open.cinode->i_ctime = CURRENT_TIME;
inode151fs/open.cinode->i_dirt = 1;
inode152fs/open.cerror = notify_change(inode);
inode153fs/open.ciput(inode);
inode163fs/open.cstruct inode * inode;
inode167fs/open.cres = namei(filename,&inode);
inode170fs/open.ci_mode = res = inode->i_mode & 0777;
inode171fs/open.ciput(inode);
inode172fs/open.cif (current->uid == inode->i_uid)
inode174fs/open.celse if (in_group_p(inode->i_gid))
inode192fs/open.cstruct inode * inode;
inode195fs/open.cerror = namei(filename,&inode);
inode198fs/open.cif (!S_ISDIR(inode->i_mode)) {
inode199fs/open.ciput(inode);
inode202fs/open.cif (!permission(inode,MAY_EXEC)) {
inode203fs/open.ciput(inode);
inode207fs/open.ccurrent->pwd = inode;
inode213fs/open.cstruct inode * inode;
inode216fs/open.cerror = namei(filename,&inode);
inode219fs/open.cif (!S_ISDIR(inode->i_mode)) {
inode220fs/open.ciput(inode);
inode224fs/open.ciput(inode);
inode228fs/open.ccurrent->root = inode;
inode234fs/open.cstruct inode * inode;
inode239fs/open.cif (!(inode = file->f_inode))
inode241fs/open.cif ((current->euid != inode->i_uid) && !suser())
inode243fs/open.cif (IS_RDONLY(inode))
inode245fs/open.cinode->i_mode = (mode & 07777) | (inode->i_mode & ~07777);
inode246fs/open.cif (!suser() && !in_group_p(inode->i_gid))
inode247fs/open.cinode->i_mode &= ~S_ISGID;
inode248fs/open.cinode->i_ctime = CURRENT_TIME;
inode249fs/open.cinode->i_dirt = 1;
inode250fs/open.creturn notify_change(inode);
inode255fs/open.cstruct inode * inode;
inode258fs/open.cerror = namei(filename,&inode);
inode261fs/open.cif ((current->euid != inode->i_uid) && !suser()) {
inode262fs/open.ciput(inode);
inode265fs/open.cif (IS_RDONLY(inode)) {
inode266fs/open.ciput(inode);
inode269fs/open.cinode->i_mode = (mode & 07777) | (inode->i_mode & ~07777);
inode270fs/open.cif (!suser() && !in_group_p(inode->i_gid))
inode271fs/open.cinode->i_mode &= ~S_ISGID;
inode272fs/open.cinode->i_ctime = CURRENT_TIME;
inode273fs/open.cinode->i_dirt = 1;
inode274fs/open.cerror = notify_change(inode);
inode275fs/open.ciput(inode);
inode281fs/open.cstruct inode * inode;
inode286fs/open.cif (!(inode = file->f_inode))
inode288fs/open.cif (IS_RDONLY(inode))
inode291fs/open.cuser = inode->i_uid;
inode293fs/open.cgroup = inode->i_gid;
inode294fs/open.cif ((current->euid == inode->i_uid && user == inode->i_uid &&
inode295fs/open.c(in_group_p(group) || group == inode->i_gid)) ||
inode297fs/open.cinode->i_uid = user;
inode298fs/open.cinode->i_gid = group;
inode299fs/open.cinode->i_ctime = CURRENT_TIME;
inode300fs/open.cinode->i_dirt = 1;
inode301fs/open.creturn notify_change(inode);
inode308fs/open.cstruct inode * inode;
inode311fs/open.cerror = lnamei(filename,&inode);
inode314fs/open.cif (IS_RDONLY(inode)) {
inode315fs/open.ciput(inode);
inode319fs/open.cuser = inode->i_uid;
inode321fs/open.cgroup = inode->i_gid;
inode322fs/open.cif ((current->euid == inode->i_uid && user == inode->i_uid &&
inode323fs/open.c(in_group_p(group) || group == inode->i_gid)) ||
inode325fs/open.cinode->i_uid = user;
inode326fs/open.cinode->i_gid = group;
inode327fs/open.cinode->i_ctime = CURRENT_TIME;
inode328fs/open.cinode->i_dirt = 1;
inode329fs/open.cerror = notify_change(inode);
inode330fs/open.ciput(inode);
inode333fs/open.ciput(inode);
inode353fs/open.cstruct inode * inode;
inode373fs/open.ci = open_namei(filename,flag,mode,&inode,NULL);
inode380fs/open.cinode->i_size = 0;
inode381fs/open.cif (inode->i_op && inode->i_op->truncate)
inode382fs/open.cinode->i_op->truncate(inode);
inode383fs/open.cif ((i = notify_change(inode))) {
inode384fs/open.ciput(inode);
inode390fs/open.cif (!IS_RDONLY(inode)) {
inode391fs/open.cinode->i_atime = CURRENT_TIME;
inode392fs/open.cinode->i_dirt = 1;
inode394fs/open.cf->f_inode = inode;
inode398fs/open.cif (inode->i_op)
inode399fs/open.cf->f_op = inode->i_op->default_file_ops;
inode401fs/open.ci = f->f_op->open(inode,f);
inode403fs/open.ciput(inode);
inode420fs/open.cstruct inode *inode;
inode426fs/open.cinode = filp->f_inode;
inode427fs/open.cif (inode && S_ISREG(inode->i_mode))
inode434fs/open.cfilp->f_op->release(inode,filp);
inode437fs/open.ciput(inode);
inode491fs/open.cstruct inode *inode;
inode511fs/open.cif (!(inode = filep->f_inode))
inode513fs/open.cif (!S_ISCHR(inode->i_mode))
inode515fs/open.cif ((MAJOR(inode->i_rdev) == 5 ||
inode516fs/open.cMAJOR(inode->i_rdev) == 4 ) &&
inode523fs/open.ckill_wait (&inode->i_wait, SIGKILL);
inode528fs/open.cwake_up (&inode->i_wait);
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, PIPE_BASE(*inode)+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(PIPE_BASE(*inode)+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));
inode207fs/pipe.cstruct inode * inode;
inode233fs/pipe.cif (!(inode=get_pipe_inode())) {
inode240fs/pipe.cf[0]->f_inode = f[1]->f_inode = inode;
inode274fs/proc/array.cstatic int array_read(struct inode * inode, struct file * file,char * buf, int count)
inode286fs/proc/array.ctype = inode->i_ino;
inode16fs/proc/base.cstatic int proc_readbase(struct inode *, struct file *, struct dirent *, int);
inode17fs/proc/base.cstatic int proc_lookupbase(struct inode *,const char *,int,struct inode **);
inode89fs/proc/base.cstatic int proc_lookupbase(struct inode * dir,const char * name, int len,
inode90fs/proc/base.cstruct inode ** result)
inode130fs/proc/base.cstatic int proc_readbase(struct inode * inode, struct file * filp,
inode137fs/proc/base.cif (!inode || !S_ISDIR(inode->i_mode))
inode139fs/proc/base.cino = inode->i_ino;
inode16fs/proc/fd.cstatic int proc_readfd(struct inode *, struct file *, struct dirent *, int);
inode17fs/proc/fd.cstatic int proc_lookupfd(struct inode *,const char *,int,struct inode **);
inode52fs/proc/fd.cstatic int proc_lookupfd(struct inode * dir,const char * name, int len,
inode53fs/proc/fd.cstruct inode ** result)
inode120fs/proc/fd.cstatic int proc_readfd(struct inode * inode, struct file * filp,
inode127fs/proc/fd.cif (!inode || !S_ISDIR(inode->i_mode))
inode129fs/proc/fd.cino = inode->i_ino;
inode141fs/proc/fd.cfd = inode->i_ino;
inode143fs/proc/fd.cfd = (inode->i_ino & 0xffff0000) | 2;
inode19fs/proc/inode.cvoid proc_put_inode(struct inode *inode)
inode21fs/proc/inode.cif (inode->i_nlink)
inode23fs/proc/inode.cinode->i_size = 0;
inode70fs/proc/inode.cvoid proc_read_inode(struct inode * inode)
inode76fs/proc/inode.cinode->i_op = NULL;
inode77fs/proc/inode.cinode->i_mode = 0;
inode78fs/proc/inode.cinode->i_uid = 0;
inode79fs/proc/inode.cinode->i_gid = 0;
inode80fs/proc/inode.cinode->i_nlink = 1;
inode81fs/proc/inode.cinode->i_size = 0;
inode82fs/proc/inode.cinode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
inode83fs/proc/inode.cinode->i_blocks = inode->i_blksize = 0;
inode84fs/proc/inode.cino = inode->i_ino;
inode93fs/proc/inode.cinode->i_mode = S_IFDIR | 0555;
inode94fs/proc/inode.cinode->i_nlink = 2;
inode97fs/proc/inode.cinode->i_nlink++;
inode98fs/proc/inode.cinode->i_op = &proc_root_inode_operations;
inode102fs/proc/inode.cinode->i_mode = S_IFREG | 0444;
inode103fs/proc/inode.cinode->i_op = &proc_array_inode_operations;
inode105fs/proc/inode.cinode->i_op = &proc_kmsg_inode_operations;
inode109fs/proc/inode.cinode->i_uid = p->euid;
inode110fs/proc/inode.cinode->i_gid = p->egid;
inode113fs/proc/inode.cinode->i_nlink = 4;
inode114fs/proc/inode.cinode->i_mode = S_IFDIR | 0555;
inode115fs/proc/inode.cinode->i_op = &proc_base_inode_operations;
inode118fs/proc/inode.cinode->i_op = &proc_mem_inode_operations;
inode119fs/proc/inode.cinode->i_mode = S_IFCHR | 0600;
inode120fs/proc/inode.cinode->i_rdev = 0x0101;
inode125fs/proc/inode.cinode->i_op = &proc_link_inode_operations;
inode126fs/proc/inode.cinode->i_size = 64;
inode127fs/proc/inode.cinode->i_mode = S_IFLNK | 0700;
inode131fs/proc/inode.cinode->i_mode = S_IFDIR | 0500;
inode132fs/proc/inode.cinode->i_op = &proc_fd_inode_operations;
inode133fs/proc/inode.cinode->i_nlink = 2;
inode139fs/proc/inode.cinode->i_mode = S_IFREG | 0444;
inode140fs/proc/inode.cinode->i_op = &proc_array_inode_operations;
inode148fs/proc/inode.cinode->i_op = &proc_link_inode_operations;
inode149fs/proc/inode.cinode->i_size = 64;
inode150fs/proc/inode.cinode->i_mode = S_IFLNK | 0700;
inode156fs/proc/inode.cinode->i_op = &proc_link_inode_operations;
inode157fs/proc/inode.cinode->i_size = 64;
inode158fs/proc/inode.cinode->i_mode = S_IFLNK | 0700;
inode164fs/proc/inode.cvoid proc_write_inode(struct inode * inode)
inode166fs/proc/inode.cinode->i_dirt=0;
inode22fs/proc/kmsg.cstatic int kmsg_open(struct inode * inode, struct file * file)
inode27fs/proc/kmsg.cstatic void kmsg_release(struct inode * inode, struct file * file)
inode32fs/proc/kmsg.cstatic int kmsg_read(struct inode * inode, struct file * file,char * buf, int count)
inode37fs/proc/kmsg.cstatic int kmsg_select(struct inode *inode, struct file *file, int sel_type, select_table * wait)
inode17fs/proc/link.cstatic int proc_readlink(struct inode *, char *, int);
inode18fs/proc/link.cstatic int proc_follow_link(struct inode *, struct inode *, int, int, struct inode **);
inode41fs/proc/link.cstatic int proc_follow_link(struct inode * dir, struct inode * inode,
inode42fs/proc/link.cint flag, int mode, struct inode ** res_inode)
inode51fs/proc/link.cif (!inode)
inode53fs/proc/link.cino = inode->i_ino;
inode56fs/proc/link.ciput(inode);
inode62fs/proc/link.cinode = NULL;
inode65fs/proc/link.cinode = p->pwd;
inode68fs/proc/link.cinode = p->root;
inode71fs/proc/link.cinode = p->executable;
inode78fs/proc/link.cinode = p->filp[ino]->f_inode;
inode83fs/proc/link.cinode = p->libraries[ino].library;
inode86fs/proc/link.cif (!inode)
inode88fs/proc/link.c*res_inode = inode;
inode89fs/proc/link.cinode->i_count++;
inode93fs/proc/link.cstatic int proc_readlink(struct inode * inode, char * buffer, int buflen)
inode99fs/proc/link.ci = proc_follow_link(NULL, inode, 0, 0, &inode);
inode102fs/proc/link.cif (!inode)
inode104fs/proc/link.cdev = inode->i_dev;
inode105fs/proc/link.cino = inode->i_ino;
inode106fs/proc/link.ciput(inode);
inode23fs/proc/mem.cstatic int mem_read(struct inode * inode, struct file * file,char * buf, int count)
inode32fs/proc/mem.cpid = inode->i_ino;
inode72fs/proc/mem.cstatic int mem_write(struct inode * inode, struct file * file,char * buf, int count)
inode82fs/proc/mem.cpid = inode->i_ino;
inode129fs/proc/mem.cstatic int mem_lseek(struct inode * inode, struct file * file, off_t offset, int orig)
inode16fs/proc/root.cstatic int proc_readroot(struct inode *, struct file *, struct dirent *, int);
inode17fs/proc/root.cstatic int proc_lookuproot(struct inode *,const char *,int,struct inode **);
inode64fs/proc/root.cstatic int proc_lookuproot(struct inode * dir,const char * name, int len,
inode65fs/proc/root.cstruct inode ** result)
inode121fs/proc/root.cstatic int proc_readroot(struct inode * inode, struct file * filp,
inode128fs/proc/root.cif (!inode || !S_ISDIR(inode->i_mode))
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))
inode82fs/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))
inode98fs/read_write.creturn file->f_op->write(inode,file,buf,count);
inode65fs/select.cstruct inode * inode;
inode67fs/select.cint (*select) (struct inode *, struct file *, int, select_table *);
inode69fs/select.cinode = file->f_inode;
inode71fs/select.creturn select(inode, file, flag, wait)
inode72fs/select.c|| (wait && select(inode, file, flag, NULL));
inode73fs/select.cif (S_ISREG(inode->i_mode))
inode14fs/stat.cstatic void cp_old_stat(struct inode * inode, struct old_stat * statbuf)
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.ctmp.st_size = inode->i_size;
inode29fs/stat.ctmp.st_atime = inode->i_atime;
inode30fs/stat.ctmp.st_mtime = inode->i_mtime;
inode31fs/stat.ctmp.st_ctime = inode->i_ctime;
inode35fs/stat.cstatic void cp_new_stat(struct inode * inode, struct new_stat * statbuf)
inode41fs/stat.ctmp.st_dev = inode->i_dev;
inode42fs/stat.ctmp.st_ino = inode->i_ino;
inode43fs/stat.ctmp.st_mode = inode->i_mode;
inode44fs/stat.ctmp.st_nlink = inode->i_nlink;
inode45fs/stat.ctmp.st_uid = inode->i_uid;
inode46fs/stat.ctmp.st_gid = inode->i_gid;
inode47fs/stat.ctmp.st_rdev = inode->i_rdev;
inode48fs/stat.ctmp.st_size = inode->i_size;
inode49fs/stat.ctmp.st_atime = inode->i_atime;
inode50fs/stat.ctmp.st_mtime = inode->i_mtime;
inode51fs/stat.ctmp.st_ctime = inode->i_ctime;
inode60fs/stat.cif (!inode->i_blksize) {
inode74fs/stat.ctmp.st_blocks = inode->i_blocks;
inode75fs/stat.ctmp.st_blksize = inode->i_blksize;
inode82fs/stat.cstruct inode * inode;
inode85fs/stat.cerror = namei(filename,&inode);
inode88fs/stat.ccp_old_stat(inode,statbuf);
inode89fs/stat.ciput(inode);
inode95fs/stat.cstruct inode * inode;
inode98fs/stat.cerror = namei(filename,&inode);
inode101fs/stat.ccp_new_stat(inode,statbuf);
inode102fs/stat.ciput(inode);
inode108fs/stat.cstruct inode * inode;
inode111fs/stat.cerror = lnamei(filename,&inode);
inode114fs/stat.ccp_old_stat(inode,statbuf);
inode115fs/stat.ciput(inode);
inode121fs/stat.cstruct inode * inode;
inode124fs/stat.cerror = lnamei(filename,&inode);
inode127fs/stat.ccp_new_stat(inode,statbuf);
inode128fs/stat.ciput(inode);
inode135fs/stat.cstruct inode * inode;
inode137fs/stat.cif (fd >= NR_OPEN || !(f=current->filp[fd]) || !(inode=f->f_inode))
inode139fs/stat.ccp_old_stat(inode,statbuf);
inode146fs/stat.cstruct inode * inode;
inode148fs/stat.cif (fd >= NR_OPEN || !(f=current->filp[fd]) || !(inode=f->f_inode))
inode150fs/stat.ccp_new_stat(inode,statbuf);
inode156fs/stat.cstruct inode * inode;
inode162fs/stat.cerror = lnamei(path,&inode);
inode165fs/stat.cif (!inode->i_op || !inode->i_op->readlink) {
inode166fs/stat.ciput(inode);
inode169fs/stat.creturn inode->i_op->readlink(inode,buf,bufsiz);
inode223fs/super.cstruct inode * inode;
inode226fs/super.cstruct inode dummy_inode;
inode231fs/super.cretval = namei(name,&inode);
inode234fs/super.cif (S_ISBLK(inode->i_mode)) {
inode235fs/super.cdev = inode->i_rdev;
inode236fs/super.cif (IS_NODEV(inode)) {
inode237fs/super.ciput(inode);
inode240fs/super.c} else if (S_ISDIR(inode->i_mode)) {
inode241fs/super.cif (!inode || !inode->i_sb || inode != inode->i_sb->s_mounted) {
inode242fs/super.ciput(inode);
inode245fs/super.cdev = inode->i_sb->s_dev;
inode246fs/super.ciput(inode);
inode249fs/super.cinode = &dummy_inode;
inode251fs/super.ciput(inode);
inode255fs/super.ciput(inode);
inode261fs/super.cfops->release(inode,NULL);
inode265fs/super.cif (inode != &dummy_inode)
inode266fs/super.ciput(inode);
inode284fs/super.cstruct inode * dir_i;
inode329fs/super.cstruct inode * inode;
inode351fs/super.cretval = namei(dev_name,&inode);
inode354fs/super.cif (!S_ISBLK(inode->i_mode)) {
inode355fs/super.ciput(inode);
inode358fs/super.cif (IS_NODEV(inode)) {
inode359fs/super.ciput(inode);
inode362fs/super.cdev = inode->i_rdev;
inode364fs/super.ciput(inode);
inode371fs/super.cinode = NULL;
inode375fs/super.cretval = fops->open(inode,NULL);
inode377fs/super.ciput(inode);
inode385fs/super.ciput(inode);
inode398fs/super.cfops->release(inode,NULL);
inode399fs/super.ciput(inode);
inode407fs/super.cstruct inode * inode;
inode421fs/super.cinode = sb->s_mounted;
inode422fs/super.cinode->i_count += 3 ;  /* NOTE! it is logically used 4 times, not 1 */
inode423fs/super.csb->s_covered = inode;
inode425fs/super.ccurrent->pwd = inode;
inode426fs/super.ccurrent->root = inode;
inode56include/linux/ext_fs.hunsigned long inode;
inode62include/linux/ext_fs.hextern int ext_open(struct inode * inode, struct file * filp);
inode63include/linux/ext_fs.hextern void ext_release(struct inode * inode, struct file * filp);
inode64include/linux/ext_fs.hextern int ext_lookup(struct inode * dir,const char * name, int len,
inode65include/linux/ext_fs.hstruct inode ** result);
inode66include/linux/ext_fs.hextern int ext_create(struct inode * dir,const char * name, int len, int mode,
inode67include/linux/ext_fs.hstruct inode ** result);
inode68include/linux/ext_fs.hextern int ext_mkdir(struct inode * dir, const char * name, int len, int mode);
inode69include/linux/ext_fs.hextern int ext_rmdir(struct inode * dir, const char * name, int len);
inode70include/linux/ext_fs.hextern int ext_unlink(struct inode * dir, const char * name, int len);
inode71include/linux/ext_fs.hextern int ext_symlink(struct inode * inode, const char * name, int len,
inode73include/linux/ext_fs.hextern int ext_link(struct inode * oldinode, struct inode * dir, const char * name, int len);
inode74include/linux/ext_fs.hextern int ext_mknod(struct inode * dir, const char * name, int len, int mode, int rdev);
inode75include/linux/ext_fs.hextern int ext_rename(struct inode * old_dir, const char * old_name, int old_len,
inode76include/linux/ext_fs.hstruct inode * new_dir, const char * new_name, int new_len);
inode77include/linux/ext_fs.hextern struct inode * ext_new_inode(const struct inode * dir);
inode78include/linux/ext_fs.hextern void ext_free_inode(struct inode * inode);
inode84include/linux/ext_fs.hextern int ext_bmap(struct inode *,int);
inode86include/linux/ext_fs.hextern struct buffer_head * ext_getblk(struct inode *, int, int);
inode87include/linux/ext_fs.hextern struct buffer_head * ext_bread(struct inode *, int, int);
inode89include/linux/ext_fs.hextern void ext_truncate(struct inode *);
inode93include/linux/ext_fs.hextern void ext_read_inode(struct inode *);
inode94include/linux/ext_fs.hextern void ext_write_inode(struct inode *);
inode95include/linux/ext_fs.hextern void ext_put_inode(struct inode *);
inode98include/linux/ext_fs.hextern int ext_lseek(struct inode *, struct file *, off_t, int);
inode99include/linux/ext_fs.hextern int ext_read(struct inode *, struct file *, char *, int);
inode100include/linux/ext_fs.hextern int ext_write(struct inode *, struct file *, char *, int);
inode98include/linux/fs.h#define IS_RDONLY(inode) ((inode)->i_flags & MS_RDONLY)
inode99include/linux/fs.h#define IS_NOSUID(inode) ((inode)->i_flags & MS_NOSUID)
inode100include/linux/fs.h#define IS_NODEV(inode) ((inode)->i_flags & MS_NODEV)
inode101include/linux/fs.h#define IS_NOEXEC(inode) ((inode)->i_flags & MS_NOEXEC)
inode102include/linux/fs.h#define IS_SYNC(inode) ((inode)->i_flags & MS_SYNC)
inode162include/linux/fs.hstruct inode * i_next, * i_prev;
inode163include/linux/fs.hstruct inode * i_hash_next, * i_hash_prev;
inode164include/linux/fs.hstruct inode * i_bound_to, * i_bound_by;
inode190include/linux/fs.hstruct inode * f_inode;
inode220include/linux/fs.hstruct inode * s_covered;
inode221include/linux/fs.hstruct inode * s_mounted;
inode233include/linux/fs.hint (*lseek) (struct inode *, struct file *, off_t, int);
inode234include/linux/fs.hint (*read) (struct inode *, struct file *, char *, int);
inode235include/linux/fs.hint (*write) (struct inode *, struct file *, char *, int);
inode236include/linux/fs.hint (*readdir) (struct inode *, struct file *, struct dirent *, int);
inode237include/linux/fs.hint (*select) (struct inode *, struct file *, int, select_table *);
inode238include/linux/fs.hint (*ioctl) (struct inode *, struct file *, unsigned int, unsigned int);
inode240include/linux/fs.hint (*open) (struct inode *, struct file *);
inode241include/linux/fs.hvoid (*release) (struct inode *, struct file *);
inode246include/linux/fs.hint (*create) (struct inode *,const char *,int,int,struct inode **);
inode247include/linux/fs.hint (*lookup) (struct inode *,const char *,int,struct inode **);
inode248include/linux/fs.hint (*link) (struct inode *,struct inode *,const char *,int);
inode249include/linux/fs.hint (*unlink) (struct inode *,const char *,int);
inode250include/linux/fs.hint (*symlink) (struct inode *,const char *,int,const char *);
inode251include/linux/fs.hint (*mkdir) (struct inode *,const char *,int,int);
inode252include/linux/fs.hint (*rmdir) (struct inode *,const char *,int);
inode253include/linux/fs.hint (*mknod) (struct inode *,const char *,int,int,int);
inode254include/linux/fs.hint (*rename) (struct inode *,const char *,int,struct inode *,const char *,int);
inode255include/linux/fs.hint (*readlink) (struct inode *,char *,int);
inode256include/linux/fs.hint (*follow_link) (struct inode *,struct inode *,int,int,struct inode **);
inode257include/linux/fs.hint (*bmap) (struct inode *,int);
inode258include/linux/fs.hvoid (*truncate) (struct inode *);
inode259include/linux/fs.hint (*permission) (struct inode *, int);
inode263include/linux/fs.hvoid (*read_inode) (struct inode *);
inode264include/linux/fs.hint (*notify_change) (struct inode *);
inode265include/linux/fs.hvoid (*write_inode) (struct inode *);
inode266include/linux/fs.hvoid (*put_inode) (struct inode *);
inode284include/linux/fs.hextern int fs_may_umount(dev_t dev, struct inode * mount_root);
inode306include/linux/fs.hextern int bmap(struct inode * inode,int block);
inode307include/linux/fs.hextern int notify_change(struct inode * inode);
inode308include/linux/fs.hextern int namei(const char * pathname, struct inode ** res_inode);
inode309include/linux/fs.hextern int lnamei(const char * pathname, struct inode ** res_inode);
inode310include/linux/fs.hextern int permission(struct inode * inode,int mask);
inode312include/linux/fs.hstruct inode ** res_inode, struct inode * base);
inode314include/linux/fs.hextern void iput(struct inode * inode);
inode315include/linux/fs.hextern struct inode * iget(struct super_block * sb,int nr);
inode316include/linux/fs.hextern struct inode * get_empty_inode(void);
inode317include/linux/fs.hextern void clear_inode(struct inode *);
inode318include/linux/fs.hextern struct inode * get_pipe_inode(void);
inode334include/linux/fs.hextern int char_read(struct inode *, struct file *, char *, int);
inode335include/linux/fs.hextern int block_read(struct inode *, struct file *, char *, int);
inode338include/linux/fs.hextern int char_write(struct inode *, struct file *, char *, int);
inode339include/linux/fs.hextern int block_write(struct inode *, struct file *, char *, int);
inode130include/linux/iso_fs.hextern int parse_rock_ridge_inode(struct iso_directory_record *, struct inode *);
inode131include/linux/iso_fs.hextern int get_rock_ridge_filename(struct iso_directory_record *, char ** name, int * len, struct inode *);
inode133include/linux/iso_fs.hextern char * get_rock_ridge_symlink(struct inode *);
inode134include/linux/iso_fs.hextern int find_rock_ridge_relocation(struct iso_directory_record *, struct inode *);
inode156include/linux/iso_fs.hextern int isofs_open(struct inode * inode, struct file * filp);
inode157include/linux/iso_fs.hextern void isofs_release(struct inode * inode, struct file * filp);
inode158include/linux/iso_fs.hextern int isofs_lookup(struct inode * dir,const char * name, int len,
inode159include/linux/iso_fs.hstruct inode ** result);
inode163include/linux/iso_fs.hextern int isofs_bmap(struct inode *,int);
inode167include/linux/iso_fs.hextern void isofs_read_inode(struct inode *);
inode168include/linux/iso_fs.hextern void isofs_put_inode(struct inode *);
inode171include/linux/iso_fs.hextern int isofs_lseek(struct inode *, struct file *, off_t, int);
inode172include/linux/iso_fs.hextern int isofs_read(struct inode *, struct file *, char *, int);
inode173include/linux/iso_fs.hextern int isofs_lookup_grandparent(struct inode *, int);
inode69include/linux/minix_fs.hunsigned short inode;
inode73include/linux/minix_fs.hextern int minix_lookup(struct inode * dir,const char * name, int len,
inode74include/linux/minix_fs.hstruct inode ** result);
inode75include/linux/minix_fs.hextern int minix_create(struct inode * dir,const char * name, int len, int mode,
inode76include/linux/minix_fs.hstruct inode ** result);
inode77include/linux/minix_fs.hextern int minix_mkdir(struct inode * dir, const char * name, int len, int mode);
inode78include/linux/minix_fs.hextern int minix_rmdir(struct inode * dir, const char * name, int len);
inode79include/linux/minix_fs.hextern int minix_unlink(struct inode * dir, const char * name, int len);
inode80include/linux/minix_fs.hextern int minix_symlink(struct inode * inode, const char * name, int len,
inode82include/linux/minix_fs.hextern int minix_link(struct inode * oldinode, struct inode * dir, const char * name, int len);
inode83include/linux/minix_fs.hextern int minix_mknod(struct inode * dir, const char * name, int len, int mode, int rdev);
inode84include/linux/minix_fs.hextern int minix_rename(struct inode * old_dir, const char * old_name, int old_len,
inode85include/linux/minix_fs.hstruct inode * new_dir, const char * new_name, int new_len);
inode86include/linux/minix_fs.hextern struct inode * minix_new_inode(const struct inode * dir);
inode87include/linux/minix_fs.hextern void minix_free_inode(struct inode * inode);
inode93include/linux/minix_fs.hextern int minix_bmap(struct inode *,int);
inode95include/linux/minix_fs.hextern struct buffer_head * minix_getblk(struct inode *, int, int);
inode96include/linux/minix_fs.hextern struct buffer_head * minix_bread(struct inode *, int, int);
inode98include/linux/minix_fs.hextern void minix_truncate(struct inode *);
inode101include/linux/minix_fs.hextern void minix_read_inode(struct inode *);
inode102include/linux/minix_fs.hextern void minix_write_inode(struct inode *);
inode103include/linux/minix_fs.hextern void minix_put_inode(struct inode *);
inode31include/linux/mm.hstruct inode * vm_inode;
inode108include/linux/msdos_fs.hextern int msdos_add_cluster(struct inode *inode);
inode112include/linux/msdos_fs.hextern int msdos_get_entry(struct inode *dir,int *pos,struct buffer_head **bh,
inode114include/linux/msdos_fs.hextern int msdos_scan(struct inode *dir,char *name,struct buffer_head **res_bh,
inode116include/linux/msdos_fs.hextern int msdos_parent_ino(struct inode *dir,int locked);
inode117include/linux/msdos_fs.hextern int msdos_subdirs(struct inode *dir);
inode122include/linux/msdos_fs.hextern int msdos_smap(struct inode *inode,int sector);
inode123include/linux/msdos_fs.hextern int fat_free(struct inode *inode,int skip);
inode125include/linux/msdos_fs.hvoid cache_lookup(struct inode *inode,int cluster,int *f_clu,int *d_clu);
inode126include/linux/msdos_fs.hvoid cache_add(struct inode *inode,int f_clu,int d_clu);
inode127include/linux/msdos_fs.hvoid cache_inval_inode(struct inode *inode);
inode129include/linux/msdos_fs.hint get_cluster(struct inode *inode,int cluster);
inode133include/linux/msdos_fs.hextern int msdos_lookup(struct inode *dir,const char *name,int len,
inode134include/linux/msdos_fs.hstruct inode **result);
inode135include/linux/msdos_fs.hextern int msdos_create(struct inode *dir,const char *name,int len,int mode,
inode136include/linux/msdos_fs.hstruct inode **result);
inode137include/linux/msdos_fs.hextern int msdos_mkdir(struct inode *dir,const char *name,int len,int mode);
inode138include/linux/msdos_fs.hextern int msdos_rmdir(struct inode *dir,const char *name,int len);
inode139include/linux/msdos_fs.hextern int msdos_unlink(struct inode *dir,const char *name,int len);
inode140include/linux/msdos_fs.hextern int msdos_rename(struct inode *old_dir,const char *old_name,int old_len,
inode141include/linux/msdos_fs.hstruct inode *new_dir,const char *new_name,int new_len);
inode145include/linux/msdos_fs.hextern void msdos_put_inode(struct inode *inode);
inode149include/linux/msdos_fs.hextern int msdos_bmap(struct inode *inode,int block);
inode150include/linux/msdos_fs.hextern void msdos_read_inode(struct inode *inode);
inode151include/linux/msdos_fs.hextern void msdos_write_inode(struct inode *inode);
inode164include/linux/msdos_fs.hextern void msdos_truncate(struct inode *inode);
inode12include/linux/msdos_fs_i.hstruct inode *i_depend; /* pointer to inode that depends on the
inode14include/linux/msdos_fs_i.hstruct inode *i_old;  /* pointer to the old inode this inode
inode53include/linux/nfs_fs.h#define NFS_SERVER(inode)    (&(inode)->i_sb->u.nfs_sb.s_server)
inode54include/linux/nfs_fs.h#define NFS_FH(inode)      (&(inode)->u.nfs_i.fhandle)
inode102include/linux/nfs_fs.hextern struct inode *nfs_fhget(struct super_block *sb, struct nfs_fh *fhandle,
inode104include/linux/nfs_fs.hextern void nfs_refresh_inode(struct inode *inode, struct nfs_fattr *fattr);
inode14include/linux/pipe_fs_i.h#define PIPE_READ_WAIT(inode)  ((inode).u.pipe_i.read_wait)
inode15include/linux/pipe_fs_i.h#define PIPE_WRITE_WAIT(inode)  ((inode).u.pipe_i.write_wait)
inode16include/linux/pipe_fs_i.h#define PIPE_BASE(inode)  ((inode).u.pipe_i.base)
inode17include/linux/pipe_fs_i.h#define PIPE_HEAD(inode)  ((inode).u.pipe_i.head)
inode18include/linux/pipe_fs_i.h#define PIPE_TAIL(inode)  ((inode).u.pipe_i.tail)
inode19include/linux/pipe_fs_i.h#define PIPE_READERS(inode)  ((inode).u.pipe_i.readers)
inode20include/linux/pipe_fs_i.h#define PIPE_WRITERS(inode)  ((inode).u.pipe_i.writers)
inode21include/linux/pipe_fs_i.h#define PIPE_SIZE(inode)  ((PIPE_HEAD(inode)-PIPE_TAIL(inode))&(PAGE_SIZE-1))
inode22include/linux/pipe_fs_i.h#define PIPE_EMPTY(inode)  (PIPE_HEAD(inode)==PIPE_TAIL(inode))
inode23include/linux/pipe_fs_i.h#define PIPE_FULL(inode)  (PIPE_SIZE(inode)==(PAGE_SIZE-1))
inode19include/linux/proc_fs.hextern void proc_put_inode(struct inode *);
inode22include/linux/proc_fs.hextern void proc_read_inode(struct inode *);
inode23include/linux/proc_fs.hextern void proc_write_inode(struct inode *);
inode194include/linux/sched.hstruct inode * pwd;
inode195include/linux/sched.hstruct inode * root;
inode196include/linux/sched.hstruct inode * executable;
inode199include/linux/sched.hstruct inode * library;
inode286include/linux/tty.hextern int tty_ioctl(struct inode *, struct file *, unsigned int, unsigned int);
inode1033kernel/blk_drv/floppy.cstatic int fd_ioctl(struct inode *inode, struct file *filp, unsigned int cmd,
inode1040kernel/blk_drv/floppy.cRO_IOCTLS(inode->i_rdev,param);
inode1042kernel/blk_drv/floppy.cdrive = MINOR(inode->i_rdev);
inode1179kernel/blk_drv/floppy.cstatic int floppy_open(struct inode * inode, struct file * filp)
inode1184kernel/blk_drv/floppy.cdrive = inode->i_rdev & 3;
inode1187kernel/blk_drv/floppy.cif (old_dev != inode->i_rdev)
inode1190kernel/blk_drv/floppy.cfd_device[drive] = inode->i_rdev;
inode1192kernel/blk_drv/floppy.cif (old_dev && old_dev != inode->i_rdev)
inode1195kernel/blk_drv/floppy.ccheck_disk_change(inode->i_rdev);
inode1199kernel/blk_drv/floppy.cstatic void floppy_release(struct inode * inode, struct file * filp)
inode1201kernel/blk_drv/floppy.csync_dev(inode->i_rdev);
inode1202kernel/blk_drv/floppy.cif (!fd_ref[inode->i_rdev & 3]--) {
inode1204kernel/blk_drv/floppy.cfd_ref[inode->i_rdev & 3] = 0;
inode494kernel/blk_drv/hd.cstatic int hd_ioctl(struct inode * inode, struct file * file,
inode500kernel/blk_drv/hd.cif (!inode)
inode502kernel/blk_drv/hd.cdev = MINOR(inode->i_rdev) >> 6;
inode515kernel/blk_drv/hd.cput_fs_long(hd[MINOR(inode->i_rdev)].start_sect,
inode521kernel/blk_drv/hd.cput_fs_long(hd[MINOR(inode->i_rdev)].nr_sects,
inode525kernel/blk_drv/hd.creturn revalidate_hddisk(inode->i_rdev, 1);
inode526kernel/blk_drv/hd.cRO_IOCTLS(inode->i_rdev,arg);
inode532kernel/blk_drv/hd.cstatic int hd_open(struct inode * inode, struct file * filp)
inode535kernel/blk_drv/hd.ctarget =  DEVICE_NR(MINOR(inode->i_rdev));
inode547kernel/blk_drv/hd.cstatic void hd_release(struct inode * inode, struct file * file)
inode550kernel/blk_drv/hd.csync_dev(inode->i_rdev);
inode552kernel/blk_drv/hd.ctarget =  DEVICE_NR(MINOR(inode->i_rdev));
inode53kernel/blk_drv/scsi/sd.cextern int sd_ioctl(struct inode *, struct file *, unsigned int, unsigned int);
inode59kernel/blk_drv/scsi/sd.cstatic int sd_open(struct inode * inode, struct file * filp)
inode62kernel/blk_drv/scsi/sd.ctarget =  DEVICE_NR(MINOR(inode->i_rdev));
inode73kernel/blk_drv/scsi/sd.ccheck_disk_change(inode->i_rdev);
inode76kernel/blk_drv/scsi/sd.csd_ioctl(inode, NULL, SCSI_IOCTL_DOORLOCK, 0);
inode82kernel/blk_drv/scsi/sd.cstatic void sd_release(struct inode * inode, struct file * file)
inode85kernel/blk_drv/scsi/sd.csync_dev(inode->i_rdev);
inode87kernel/blk_drv/scsi/sd.ctarget =  DEVICE_NR(MINOR(inode->i_rdev));
inode93kernel/blk_drv/scsi/sd.csd_ioctl(inode, NULL, SCSI_IOCTL_DOORUNLOCK, 0);
inode598kernel/blk_drv/scsi/sd.cstruct inode inode;
inode609kernel/blk_drv/scsi/sd.cinode.i_rdev = full_dev;  /* This is all we really need here */
inode610kernel/blk_drv/scsi/sd.cretval = sd_ioctl(&inode, NULL, SCSI_IOCTL_TEST_UNIT_READY, 0);
inode17kernel/blk_drv/scsi/sd_ioctl.cint sd_ioctl(struct inode * inode, struct file * file, unsigned long cmd, unsigned long arg)
inode19kernel/blk_drv/scsi/sd_ioctl.cint dev = inode->i_rdev;
inode42kernel/blk_drv/scsi/sd_ioctl.cput_fs_long(sd[MINOR(inode->i_rdev)].start_sect,
inode48kernel/blk_drv/scsi/sd_ioctl.cput_fs_long(sd[MINOR(inode->i_rdev)].nr_sects,
inode39kernel/blk_drv/scsi/sr.cstatic int sr_open(struct inode *, struct file *);
inode41kernel/blk_drv/scsi/sr.cextern int sr_ioctl(struct inode *, struct file *, unsigned int, unsigned int);
inode45kernel/blk_drv/scsi/sr.cstatic void sr_release(struct inode * inode, struct file * file)
inode47kernel/blk_drv/scsi/sr.csync_dev(inode->i_rdev);
inode48kernel/blk_drv/scsi/sr.cif(! --scsi_CDs[MINOR(inode->i_rdev)].device->access_count)
inode49kernel/blk_drv/scsi/sr.csr_ioctl(inode, NULL, SCSI_IOCTL_DOORUNLOCK, 0);
inode77kernel/blk_drv/scsi/sr.cstruct inode inode;
inode86kernel/blk_drv/scsi/sr.cinode.i_rdev = full_dev;  /* This is all we really need here */
inode87kernel/blk_drv/scsi/sr.cretval = sr_ioctl(&inode, NULL, SCSI_IOCTL_TEST_UNIT_READY, 0);
inode257kernel/blk_drv/scsi/sr.cstatic int sr_open(struct inode * inode, struct file * filp)
inode259kernel/blk_drv/scsi/sr.cif(MINOR(inode->i_rdev) >= NR_SR || 
inode260kernel/blk_drv/scsi/sr.c!scsi_CDs[MINOR(inode->i_rdev)].device) return -ENODEV;   /* No such device */
inode262kernel/blk_drv/scsi/sr.ccheck_disk_change(inode->i_rdev);
inode264kernel/blk_drv/scsi/sr.cif(!scsi_CDs[MINOR(inode->i_rdev)].device->access_count++)
inode265kernel/blk_drv/scsi/sr.csr_ioctl(inode, NULL, SCSI_IOCTL_DOORLOCK, 0);
inode92kernel/blk_drv/scsi/sr_ioctl.cint sr_ioctl(struct inode * inode, struct file * file, unsigned long cmd, unsigned long arg)
inode96kernel/blk_drv/scsi/sr_ioctl.cint dev = inode->i_rdev;
inode85kernel/blk_drv/scsi/st.cstatic int st_int_ioctl(struct inode * inode,struct file * file,
inode254kernel/blk_drv/scsi/st.cstatic int flush_buffer(struct inode * inode, struct file * filp,
inode260kernel/blk_drv/scsi/st.cdev = inode->i_rdev & 127;
inode273kernel/blk_drv/scsi/st.cresult = st_int_ioctl(inode, filp, MTBSR, backspace);
inode285kernel/blk_drv/scsi/st.cstatic int scsi_tape_open(struct inode * inode, struct file * filp)
inode293kernel/blk_drv/scsi/st.cdev = inode->i_rdev & 127;
inode444kernel/blk_drv/scsi/st.cif (st_int_ioctl(inode, filp, MTSETBLK, ST_BLOCK_SIZE)) {
inode480kernel/blk_drv/scsi/st.cstatic void scsi_tape_close(struct inode * inode, struct file * filp)
inode488kernel/blk_drv/scsi/st.cdev = inode->i_rdev;
inode529kernel/blk_drv/scsi/st.cst_int_ioctl(inode, filp, MTBSF, 1); /* Back over the EOF hit */
inode531kernel/blk_drv/scsi/st.cflush_buffer(inode, filp, 0);
inode536kernel/blk_drv/scsi/st.cst_int_ioctl(inode, filp, MTREW, 1);
inode546kernel/blk_drv/scsi/st.cint st_write(struct inode * inode, struct file * filp, char * buf, int count)
inode554kernel/blk_drv/scsi/st.cdev = inode->i_rdev & 127;
inode566kernel/blk_drv/scsi/st.cretval = flush_buffer(inode, filp, 0);
inode685kernel/blk_drv/scsi/st.cint st_read(struct inode * inode, struct file * filp, char * buf, int count)
inode693kernel/blk_drv/scsi/st.cdev = inode->i_rdev & 127;
inode702kernel/blk_drv/scsi/st.ctransfer = flush_buffer(inode, filp, 0);
inode847kernel/blk_drv/scsi/st.cstatic int st_int_ioctl(struct inode * inode,struct file * file,
inode850kernel/blk_drv/scsi/st.cint dev = inode->i_rdev;
inode1060kernel/blk_drv/scsi/st.cioctl_result = st_int_ioctl(inode, file, MTFSF, 1);
inode1062kernel/blk_drv/scsi/st.cioctl_result = st_int_ioctl(inode, file, MTBSF, 1);
inode1088kernel/blk_drv/scsi/st.cstatic int st_ioctl(struct inode * inode,struct file * file,
inode1091kernel/blk_drv/scsi/st.cint dev = inode->i_rdev;
inode1116kernel/blk_drv/scsi/st.ci = flush_buffer(inode, file, mtc.mt_op == MTSEEK ||
inode1122kernel/blk_drv/scsi/st.creturn st_int_ioctl(inode, file, mtc.mt_op, mtc.mt_count);
inode1141kernel/blk_drv/scsi/st.ci = flush_buffer(inode, file, 0);
inode79kernel/chr_drv/atixlmouse.cstatic void release_mouse(struct inode * inode, struct file * file)
inode88kernel/chr_drv/atixlmouse.cstatic int open_mouse(struct inode * inode, struct file * file)
inode108kernel/chr_drv/atixlmouse.cstatic int write_mouse(struct inode * inode, struct file * file, char * buffer, int count)
inode113kernel/chr_drv/atixlmouse.cstatic int read_mouse(struct inode * inode, struct file * file, char * buffer, int count)
inode132kernel/chr_drv/atixlmouse.cstatic int mouse_select(struct inode *inode, struct file *file, int sel_type, select_table * wait)
inode60kernel/chr_drv/busmouse.cstatic void release_mouse(struct inode * inode, struct file * file)
inode68kernel/chr_drv/busmouse.cstatic int open_mouse(struct inode * inode, struct file * file)
inode88kernel/chr_drv/busmouse.cstatic int write_mouse(struct inode * inode, struct file * file, char * buffer, int count)
inode93kernel/chr_drv/busmouse.cstatic int read_mouse(struct inode * inode, struct file * file, char * buffer, int count)
inode123kernel/chr_drv/busmouse.cstatic int mouse_select(struct inode *inode, struct file *file, int sel_type, select_table * wait)
inode75kernel/chr_drv/lp.cstatic int lp_write(struct inode * inode, struct file * file, char * buf, int count)
inode78kernel/chr_drv/lp.cunsigned int minor = MINOR(inode->i_rdev);
inode157kernel/chr_drv/lp.cstatic int lp_lseek(struct inode * inode, struct file * file,
inode163kernel/chr_drv/lp.cstatic int lp_open(struct inode * inode, struct file * file)
inode165kernel/chr_drv/lp.cunsigned int minor = MINOR(inode->i_rdev);
inode177kernel/chr_drv/lp.cstatic void lp_release(struct inode * inode, struct file * file)
inode179kernel/chr_drv/lp.cunsigned int minor = MINOR(inode->i_rdev);
inode185kernel/chr_drv/lp.cstatic int lp_ioctl(struct inode *inode, struct file *file,
inode188kernel/chr_drv/lp.cunsigned int minor = MINOR(inode->i_rdev);
inode22kernel/chr_drv/mem.cstatic int read_ram(struct inode * inode, struct file * file,char * buf, int count)
inode27kernel/chr_drv/mem.cstatic int write_ram(struct inode * inode, struct file * file,char * buf, int count)
inode32kernel/chr_drv/mem.cstatic int read_core(struct inode * inode, struct file * file,char * buf, int count)
inode77kernel/chr_drv/mem.cstatic int read_mem(struct inode * inode, struct file * file,char * buf, int count)
inode102kernel/chr_drv/mem.cstatic int write_mem(struct inode * inode, struct file * file,char * buf, int count)
inode127kernel/chr_drv/mem.cstatic int read_port(struct inode * inode,struct file * file,char * buf, int count)
inode141kernel/chr_drv/mem.cstatic int write_port(struct inode * inode,struct file * file,char * buf, int count)
inode155kernel/chr_drv/mem.cstatic int read_null(struct inode * node,struct file * file,char * buf,int count)
inode160kernel/chr_drv/mem.cstatic int write_null(struct inode * inode,struct file * file,char * buf, int count)
inode165kernel/chr_drv/mem.cstatic int read_zero(struct inode * node,struct file * file,char * buf,int count)
inode176kernel/chr_drv/mem.cstatic int write_zero(struct inode * inode,struct file * file,char * buf, int count)
inode189kernel/chr_drv/mem.cstatic int memory_lseek(struct inode * inode, struct file * file, off_t offset, int orig)
inode293kernel/chr_drv/mem.cstatic int memory_open(struct inode * inode, struct file * filp)
inode295kernel/chr_drv/mem.cswitch (MINOR(inode->i_rdev)) {
inode321kernel/chr_drv/mem.creturn filp->f_op->open(inode,filp);
inode36kernel/chr_drv/mouse.cstatic int mouse_open(struct inode * inode, struct file * file)
inode38kernel/chr_drv/mouse.cint minor = MINOR(inode->i_rdev);
inode64kernel/chr_drv/mouse.creturn file->f_op->open(inode,file);
inode66kernel/chr_drv/msbusmouse.cstatic void release_mouse(struct inode * inode, struct file * file)
inode74kernel/chr_drv/msbusmouse.cstatic int open_mouse(struct inode * inode, struct file * file)
inode95kernel/chr_drv/msbusmouse.cstatic int write_mouse(struct inode * inode, struct file * file, char * buffer, int count)
inode100kernel/chr_drv/msbusmouse.cstatic int read_mouse(struct inode * inode, struct file * file, char * buffer, int count)
inode128kernel/chr_drv/msbusmouse.cstatic int mouse_select(struct inode *inode, struct file *file, int sel_type, select_table * wait)
inode160kernel/chr_drv/psaux.cstatic void release_aux(struct inode * inode, struct file * file)
inode177kernel/chr_drv/psaux.cstatic int open_aux(struct inode * inode, struct file * file)
inode201kernel/chr_drv/psaux.cstatic int write_aux(struct inode * inode, struct file * file, char * buffer, int count)
inode213kernel/chr_drv/psaux.cinode->i_mtime = CURRENT_TIME;
inode222kernel/chr_drv/psaux.cstatic int read_aux(struct inode * inode, struct file * file, char * buffer, int count)
inode248kernel/chr_drv/psaux.cinode->i_atime = CURRENT_TIME;
inode257kernel/chr_drv/psaux.cstatic int aux_select(struct inode *inode, struct file *file, int sel_type, select_table * wait)
inode60kernel/chr_drv/tty_io.cstatic int tty_read(struct inode *, struct file *, char *, int);
inode61kernel/chr_drv/tty_io.cstatic int tty_write(struct inode *, struct file *, char *, int);
inode62kernel/chr_drv/tty_io.cstatic int tty_select(struct inode *, struct file *, int, select_table *);
inode63kernel/chr_drv/tty_io.cstatic int tty_open(struct inode *, struct file *);
inode64kernel/chr_drv/tty_io.cstatic void tty_release(struct inode *, struct file *);
inode116kernel/chr_drv/tty_io.cstatic int hung_up_tty_read(struct inode * inode, struct file * file, char * buf, int count)
inode121kernel/chr_drv/tty_io.cstatic int hung_up_tty_write(struct inode * inode, struct file * file, char * buf, int count)
inode126kernel/chr_drv/tty_io.cstatic int hung_up_tty_select(struct inode * inode, struct file * filp, int sel_type, select_table * wait)
inode131kernel/chr_drv/tty_io.cstatic int tty_lseek(struct inode * inode, struct file * file, off_t offset, int orig)
inode750kernel/chr_drv/tty_io.cstatic int tty_read(struct inode * inode, struct file * file, char * buf, int count)
inode764kernel/chr_drv/tty_io.cif (MINOR(inode->i_rdev) && (tty->pgrp > 0) &&
inode775kernel/chr_drv/tty_io.cinode->i_atime = CURRENT_TIME;
inode779kernel/chr_drv/tty_io.cstatic int tty_write(struct inode * inode, struct file * file, char * buf, int count)
inode785kernel/chr_drv/tty_io.cis_console = (inode->i_rdev == 0x0400);
inode808kernel/chr_drv/tty_io.cinode->i_mtime = CURRENT_TIME;
inode986kernel/chr_drv/tty_io.cstatic int tty_open(struct inode * inode, struct file * filp)
inode991kernel/chr_drv/tty_io.cdev = inode->i_rdev;
inode1035kernel/chr_drv/tty_io.cstatic void tty_release(struct inode * inode, struct file * filp)
inode1052kernel/chr_drv/tty_io.cstatic int tty_select(struct inode * inode, struct file * filp, int sel_type, select_table * wait)
inode256kernel/chr_drv/tty_ioctl.cint tty_ioctl(struct inode * inode, struct file * file,
inode619mm/memory.cstatic int share_page(struct task_struct * tsk, struct inode * inode, unsigned long address)
inode624mm/memory.cif (!inode || inode->i_count < 2)
inode631mm/memory.cif (inode != (*p)->executable) {
inode633mm/memory.cif (inode == (*p)->libraries[i].library)
inode679mm/memory.cstruct inode * inode;
inode696mm/memory.cinode = NULL;
inode699mm/memory.cinode = tsk->executable;
inode709mm/memory.cinode = tsk->libraries[i].library;
inode717mm/memory.cif (!inode) {
inode729mm/memory.cif (share_page(tsk,inode,address)) {
inode742mm/memory.cnr[i] = bmap(inode,block);
inode743mm/memory.cbread_page(page,inode->i_dev,nr);
inode745mm/memory.cif (share_page(tsk,inode,address)) {
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);
inode31mm/swap.cstruct inode * swap_file;
inode541mm/swap.cstruct inode * inode;
inode547mm/swap.ci = namei(specialfile,&inode);
inode555mm/swap.cif (p->swap_file == inode)
inode558mm/swap.cif (!S_ISBLK(inode->i_mode))
inode560mm/swap.cif (p->swap_device == inode->i_rdev)
inode564mm/swap.ciput(inode);
inode592mm/swap.cstruct inode * swap_inode;
inode48net/socket.cstatic int sock_lseek(struct inode *inode, struct file *file, off_t offset,
inode50net/socket.cstatic int sock_read(struct inode *inode, struct file *file, char *buf,
inode52net/socket.cstatic int sock_write(struct inode *inode, struct file *file, char *buf,
inode54net/socket.cstatic int sock_readdir(struct inode *inode, struct file *file,
inode56net/socket.cstatic void sock_close(struct inode *inode, struct file *file);
inode57net/socket.cstatic int sock_select(struct inode *inode, struct file *file, int which, select_table *seltable);
inode58net/socket.cstatic int sock_ioctl(struct inode *inode, struct file *file,
inode73net/socket.c#define SOCK_INODE(S) ((struct inode *)(S)->dummy)
inode83net/socket.cget_fd(struct inode *inode)
inode107net/socket.cfile->f_inode = inode;
inode108net/socket.cif (inode)
inode109net/socket.cinode->i_count++;
inode127net/socket.csocki_lookup(struct inode *inode)
inode132net/socket.cif (sock->state != SS_FREE && SOCK_INODE(sock) == inode)
inode238net/socket.csock_lseek(struct inode *inode, struct file *file, off_t offset, int whence)
inode245net/socket.csock_read(struct inode *inode, struct file *file, char *ubuf, int size)
inode250net/socket.cif (!(sock = socki_lookup(inode))) {
inode260net/socket.csock_write(struct inode *inode, struct file *file, char *ubuf, int size)
inode265net/socket.cif (!(sock = socki_lookup(inode))) {
inode275net/socket.csock_readdir(struct inode *inode, struct file *file, struct dirent *dirent,
inode283net/socket.csock_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
inode288net/socket.cPRINTK(("sock_ioctl: inode=0x%x cmd=0x%x arg=%d\n", inode, cmd, arg));
inode289net/socket.cif (!(sock = socki_lookup(inode))) {
inode297net/socket.csock_select(struct inode *inode, struct file *file, int sel_type, select_table * wait)
inode301net/socket.cPRINTK(("sock_select: inode = 0x%x, kind = %s\n", inode,
inode304net/socket.cif (!(sock = socki_lookup(inode))) {
inode317net/socket.csock_close(struct inode *inode, struct file *file)
inode321net/socket.cPRINTK(("sock_close: inode=0x%x (cnt=%d)\n", inode, inode->i_count));
inode326net/socket.cif (!inode)
inode328net/socket.cif (!(sock = socki_lookup(inode))) {
inode25net/unix.cstruct inode *inode;
inode189net/unix.cstruct inode *inode)
inode197net/unix.cupd->inode == inode)
inode217net/unix.cupd->inode = NULL;
inode298net/unix.cif (upd->inode) {
inode300net/unix.cupd->inode));
inode301net/unix.ciput(upd->inode);
inode302net/unix.cupd->inode = NULL;
inode337net/unix.cif (upd->sockaddr_len || upd->inode) {
inode355net/unix.ci = open_namei(fname, 0, S_IFSOCK, &upd->inode, NULL);
inode367net/unix.cPRINTK(("to inode 0x%x\n", upd->inode));
inode384net/unix.cstruct inode *inode;
inode419net/unix.ci = open_namei(fname, 0, S_IFSOCK, &inode, NULL);
inode425net/unix.cserv_upd = unix_data_lookup(&sockun, sockaddr_len, inode);
inode426net/unix.ciput(inode);
inode429net/unix.cfname, inode));