taglinefilesource code
inode17fs/block_dev.cint block_write(struct inode * inode, struct file * filp, char * buf, int count)
inode29fs/block_dev.cdev = inode->i_rdev;
inode78fs/block_dev.cint block_read(struct inode * inode, struct file * filp, char * buf, int count)
inode94fs/block_dev.cdev = inode->i_rdev;
inode208fs/block_dev.cint block_fsync(struct inode *inode, struct file *filp)
inode210fs/block_dev.creturn fsync_dev (inode->i_rdev);
inode169fs/buffer.cint file_fsync (struct inode *inode, struct file *filp)
inode171fs/buffer.creturn fsync_dev(inode->i_dev);
inode177fs/buffer.cstruct inode * inode;
inode179fs/buffer.cif (fd>=NR_OPEN || !(file=current->filp[fd]) || !(inode=file->f_inode))
inode183fs/buffer.cif (file->f_op->fsync(inode,file))
inode49fs/devices.cint blkdev_open(struct inode * inode, struct file * filp)
inode53fs/devices.ci = MAJOR(inode->i_rdev);
inode58fs/devices.creturn filp->f_op->open(inode,filp);
inode100fs/devices.cint chrdev_open(struct inode * inode, struct file * filp)
inode104fs/devices.ci = MAJOR(inode->i_rdev);
inode109fs/devices.creturn filp->f_op->open(inode,filp);
inode53fs/exec.cstatic int open_inode(struct inode * inode, int mode)
inode58fs/exec.cif (!inode->i_op || !inode->i_op->default_file_ops)
inode75fs/exec.cf->f_inode = inode;
inode78fs/exec.cf->f_op = inode->i_op->default_file_ops;
inode80fs/exec.cerror = f->f_op->open(inode,f);
inode87fs/exec.cinode->i_count++;
inode96fs/exec.cwhile (file.f_op->write(inode,&file,(char *)(addr),(nr)) != (nr)) goto close_coredump
inode100fs/exec.cif (file.f_op->lseek(inode,&file,(offset),0) != (offset)) \
inode115fs/exec.cstruct inode * inode = NULL;
inode131fs/exec.cif (open_namei("core",O_CREAT | 2 | O_TRUNC,0600,&inode,NULL)) {
inode132fs/exec.cinode = NULL;
inode135fs/exec.cif (!S_ISREG(inode->i_mode))
inode137fs/exec.cif (!inode->i_op || !inode->i_op->default_file_ops)
inode142fs/exec.cfile.f_inode = inode;
inode145fs/exec.cfile.f_op = inode->i_op->default_file_ops;
inode147fs/exec.cif (file.f_op->open(inode,&file))
inode215fs/exec.cfile.f_op->release(inode,&file);
inode218fs/exec.ciput(inode);
inode394fs/exec.cint read_exec(struct inode *inode, unsigned long offset,
inode400fs/exec.cif (!inode->i_op || !inode->i_op->default_file_ops)
inode405fs/exec.cfile.f_inode = inode;
inode408fs/exec.cfile.f_op = inode->i_op->default_file_ops;
inode410fs/exec.cif (file.f_op->open(inode,&file))
inode415fs/exec.cif (file.f_op->lseek(inode,&file,offset,0) != offset)
inode419fs/exec.cresult = file.f_op->read(inode, &file, addr, count);
inode422fs/exec.cfile.f_op->release(inode,&file);
inode482fs/exec.c!permission(bprm->inode,MAY_READ))
inode519fs/exec.cretval = open_namei(filename, 0, 0, &bprm.inode, NULL);
inode527fs/exec.cif (!S_ISREG(bprm.inode->i_mode)) {  /* must be regular file */
inode531fs/exec.cif (IS_NOEXEC(bprm.inode)) {    /* FS mustn't be mounted noexec */
inode535fs/exec.cif (!bprm.inode->i_sb) {
inode539fs/exec.ci = bprm.inode->i_mode;
inode540fs/exec.cif (IS_NOSUID(bprm.inode) && (((i & S_ISUID) && bprm.inode->i_uid != current->
inode541fs/exec.ceuid) || ((i & S_ISGID) && !in_group_p(bprm.inode->i_gid))) &&
inode551fs/exec.cbprm.e_uid = (i & S_ISUID) ? bprm.inode->i_uid : current->euid;
inode552fs/exec.cbprm.e_gid = (i & S_ISGID) ? bprm.inode->i_gid : current->egid;
inode554fs/exec.cif (current->euid == bprm.inode->i_uid)
inode556fs/exec.celse if (in_group_p(bprm.inode->i_gid))
inode559fs/exec.c!((bprm.inode->i_mode & 0111) && suser())) {
inode566fs/exec.cretval = read_exec(bprm.inode,0,bprm.buf,128);
inode578fs/exec.ciput(bprm.inode);
inode638fs/exec.cretval = open_namei(interp, 0, 0, &bprm.inode, NULL);
inode659fs/exec.ciput(bprm.inode);
inode665fs/exec.ciput(bprm.inode);
inode718fs/exec.cbprm->inode->i_size < ex.a_text+ex.a_data+ex.a_syms+N_TXTOFF(ex)) {
inode722fs/exec.c(N_TXTOFF(ex) < bprm->inode->i_sb->s_blocksize)) {
inode742fs/exec.cread_exec(bprm->inode, 32, (char *) 0, ex.a_text+ex.a_data);
inode747fs/exec.cfd = open_inode(bprm->inode, O_RDONLY);
inode754fs/exec.cread_exec(bprm->inode, 1024, (char *) 0, ex.a_text+ex.a_data);
inode774fs/exec.ccurrent->executable = bprm->inode;
inode775fs/exec.cbprm->inode->i_count++;
inode795fs/exec.cstruct  inode * inode;
inode801fs/exec.cinode = file->f_inode;
inode804fs/exec.cif (file->f_op->read(inode, file, (char *) &ex, sizeof(ex)) != sizeof(ex)) {
inode812fs/exec.cinode->i_size < ex.a_text+ex.a_data+ex.a_syms+N_TXTOFF(ex)) {
inode816fs/exec.c(N_TXTOFF(ex) < inode->i_sb->s_blocksize)) {
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);
inode64fs/ext/dir.cstatic int ext_readdir(struct inode * inode, struct file * filp,
inode72fs/ext/dir.cif (!inode || !S_ISDIR(inode->i_mode))
inode76fs/ext/dir.cwhile (filp->f_pos < inode->i_size) {
inode78fs/ext/dir.cbh = ext_bread(inode,(filp->f_pos)>>BLOCK_SIZE_BITS,0);
inode84fs/ext/dir.cwhile (offset < 1024 && filp->f_pos < inode->i_size) {
inode90fs/ext/dir.cinode->i_dev, inode->i_ino, offset, de->rec_len, de->name_len);
inode92fs/ext/dir.cif (filp->f_pos > inode->i_size)
inode93fs/ext/dir.cfilp->f_pos = inode->i_size;
inode98fs/ext/dir.cif (de->inode) {
inode105fs/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);
inode72fs/ext/file.cstatic int ext_file_read(struct inode * inode, struct file * filp, char * buf, int count)
inode82fs/ext/file.cif (!inode) {
inode86fs/ext/file.cif (!S_ISREG(inode->i_mode)) {
inode87fs/ext/file.cprintk("ext_file_read: mode = %07o\n",inode->i_mode);
inode91fs/ext/file.csize = inode->i_size;
inode107fs/ext/file.cblocks += read_ahead[MAJOR(inode->i_dev)] / (BLOCK_SIZE >> 9);
inode127fs/ext/file.c*bhb = ext_getblk(inode, block++, 0);
inode186fs/ext/file.cif (!IS_RDONLY(inode)) {
inode187fs/ext/file.cinode->i_atime = CURRENT_TIME;
inode188fs/ext/file.cinode->i_dirt = 1;
inode193fs/ext/file.cstatic int ext_file_write(struct inode * inode, struct file * filp, char * buf, int count)
inode200fs/ext/file.cif (!inode) {
inode204fs/ext/file.cif (!S_ISREG(inode->i_mode)) {
inode205fs/ext/file.cprintk("ext_file_write: mode = %07o\n",inode->i_mode);
inode213fs/ext/file.cpos = inode->i_size;
inode218fs/ext/file.cbh = ext_getblk(inode,pos/BLOCK_SIZE,1);
inode239fs/ext/file.cif (pos > inode->i_size) {
inode240fs/ext/file.cinode->i_size = pos;
inode241fs/ext/file.cinode->i_dirt = 1;
inode250fs/ext/file.cinode->i_mtime = CURRENT_TIME;
inode251fs/ext/file.cinode->i_ctime = CURRENT_TIME;
inode253fs/ext/file.cinode->i_dirt = 1;
inode182fs/ext/freelists.cvoid ext_free_inode(struct inode * inode)
inode191fs/ext/freelists.cif (!inode)
inode193fs/ext/freelists.cif (!inode->i_dev) {
inode197fs/ext/freelists.cif (inode->i_count != 1) {
inode198fs/ext/freelists.cprintk("free_inode: inode has count=%d\n",inode->i_count);
inode201fs/ext/freelists.cif (inode->i_nlink) {
inode202fs/ext/freelists.cprintk("free_inode: inode has nlink=%d\n",inode->i_nlink);
inode205fs/ext/freelists.cif (!inode->i_sb) {
inode209fs/ext/freelists.csb = inode->i_sb;
inode210fs/ext/freelists.cino = inode->i_ino;
inode211fs/ext/freelists.cdev = inode->i_dev;
inode212fs/ext/freelists.cclear_inode(inode);
inode246fs/ext/freelists.cstruct inode * ext_new_inode(const struct inode * dir)
inode249fs/ext/freelists.cstruct inode * inode;
inode254fs/ext/freelists.cif (!dir || !(inode=get_empty_inode()))
inode257fs/ext/freelists.cinode->i_sb = sb;
inode258fs/ext/freelists.cinode->i_flags = sb->s_flags;
inode289fs/ext/freelists.cinode->i_count = 1;
inode290fs/ext/freelists.cinode->i_nlink = 1;
inode291fs/ext/freelists.cinode->i_dev = sb->s_dev;
inode292fs/ext/freelists.cinode->i_uid = current->euid;
inode293fs/ext/freelists.cinode->i_gid = (dir->i_mode & S_ISGID) ? dir->i_gid : current->egid;
inode294fs/ext/freelists.cinode->i_dirt = 1;
inode295fs/ext/freelists.cinode->i_ino = j;
inode296fs/ext/freelists.cinode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
inode297fs/ext/freelists.cinode->i_op = NULL;
inode298fs/ext/freelists.cinode->i_blocks = inode->i_blksize = 0;
inode299fs/ext/freelists.cinsert_inode_hash(inode);
inode301fs/ext/freelists.cprintk("ext_new_inode : allocating inode %d\n", inode->i_ino);
inode304fs/ext/freelists.creturn inode;
inode31fs/ext/fsync.cstatic int sync_block (struct inode * inode, unsigned long * block, int wait)
inode39fs/ext/fsync.cbh = get_hash_table(inode->i_dev, *block, blocksize);
inode60fs/ext/fsync.cstatic int sync_iblock (struct inode * inode, unsigned long * iblock, 
inode69fs/ext/fsync.crc = sync_block (inode, iblock, wait);
inode72fs/ext/fsync.c*bh = bread(inode->i_dev, tmp, blocksize);
inode84fs/ext/fsync.cstatic int sync_direct(struct inode *inode, int wait)
inode90fs/ext/fsync.crc = sync_block (inode, inode->u.ext_i.i_data + i, wait);
inode99fs/ext/fsync.cstatic int sync_indirect(struct inode *inode, unsigned long *iblock, int wait)
inode105fs/ext/fsync.crc = sync_iblock (inode, iblock, &ind_bh, wait);
inode110fs/ext/fsync.crc = sync_block (inode, 
inode122fs/ext/fsync.cstatic int sync_dindirect(struct inode *inode, unsigned long *diblock,
inode129fs/ext/fsync.crc = sync_iblock (inode, diblock, &dind_bh, wait);
inode134fs/ext/fsync.crc = sync_indirect (inode,
inode146fs/ext/fsync.cstatic int sync_tindirect(struct inode *inode, unsigned long *tiblock, 
inode153fs/ext/fsync.crc = sync_iblock (inode, tiblock, &tind_bh, wait);
inode158fs/ext/fsync.crc = sync_dindirect (inode,
inode170fs/ext/fsync.cint ext_sync_file(struct inode * inode, struct file *file)
inode174fs/ext/fsync.cif (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
inode175fs/ext/fsync.cS_ISLNK(inode->i_mode)))
inode179fs/ext/fsync.cerr |= sync_direct(inode, wait);
inode180fs/ext/fsync.cerr |= sync_indirect(inode, inode->u.ext_i.i_data+9, wait);
inode181fs/ext/fsync.cerr |= sync_dindirect(inode, inode->u.ext_i.i_data+10, wait);
inode182fs/ext/fsync.cerr |= sync_tindirect(inode, inode->u.ext_i.i_data+11, wait);
inode184fs/ext/fsync.cerr |= ext_sync_inode (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);
inode164fs/ext/inode.c#define inode_bmap(inode,nr) ((inode)->u.ext_i.i_data[(nr)])
inode177fs/ext/inode.cint ext_bmap(struct inode * inode,int block)
inode190fs/ext/inode.creturn inode_bmap(inode,block);
inode193fs/ext/inode.ci = inode_bmap(inode,9);
inode196fs/ext/inode.creturn block_bmap(bread(inode->i_dev,i,BLOCK_SIZE),block);
inode200fs/ext/inode.ci = inode_bmap(inode,10);
inode203fs/ext/inode.ci = block_bmap(bread(inode->i_dev,i,BLOCK_SIZE),block>>8);
inode206fs/ext/inode.creturn block_bmap(bread(inode->i_dev,i,BLOCK_SIZE),block & 255);
inode209fs/ext/inode.ci = inode_bmap(inode,11);
inode212fs/ext/inode.ci = block_bmap(bread(inode->i_dev,i,BLOCK_SIZE),block>>16);
inode215fs/ext/inode.ci = block_bmap(bread(inode->i_dev,i,BLOCK_SIZE),(block>>8) & 255);
inode218fs/ext/inode.creturn block_bmap(bread(inode->i_dev,i,BLOCK_SIZE),block & 255);
inode221fs/ext/inode.cstatic struct buffer_head * inode_getblk(struct inode * inode, int nr, int create)
inode227fs/ext/inode.cp = inode->u.ext_i.i_data + nr;
inode231fs/ext/inode.cresult = getblk(inode->i_dev, tmp, BLOCK_SIZE);
inode239fs/ext/inode.ctmp = ext_new_block(inode->i_sb);
inode242fs/ext/inode.cresult = getblk(inode->i_dev, tmp, BLOCK_SIZE);
inode244fs/ext/inode.cext_free_block(inode->i_sb,tmp);
inode249fs/ext/inode.cinode->i_ctime = CURRENT_TIME;
inode250fs/ext/inode.cinode->i_dirt = 1;
inode254fs/ext/inode.cstatic struct buffer_head * block_getblk(struct inode * inode,
inode287fs/ext/inode.ctmp = ext_new_block(inode->i_sb);
inode294fs/ext/inode.cext_free_block(inode->i_sb,tmp);
inode304fs/ext/inode.cstruct buffer_head * ext_getblk(struct inode * inode, int block, int create)
inode317fs/ext/inode.creturn inode_getblk(inode,block,create);
inode320fs/ext/inode.cbh = inode_getblk(inode,9,create);
inode321fs/ext/inode.creturn block_getblk(inode,bh,block,create);
inode325fs/ext/inode.cbh = inode_getblk(inode,10,create);
inode326fs/ext/inode.cbh = block_getblk(inode,bh,block>>8,create);
inode327fs/ext/inode.creturn block_getblk(inode,bh,block & 255,create);
inode330fs/ext/inode.cbh = inode_getblk(inode,11,create);
inode331fs/ext/inode.cbh = block_getblk(inode,bh,block>>16,create);
inode332fs/ext/inode.cbh = block_getblk(inode,bh,(block>>8) & 255,create);
inode333fs/ext/inode.creturn block_getblk(inode,bh,block & 255,create);
inode336fs/ext/inode.cstruct buffer_head * ext_bread(struct inode * inode, int block, int create)
inode340fs/ext/inode.cbh = ext_getblk(inode,block,create);
inode351fs/ext/inode.cvoid ext_read_inode(struct inode * inode)
inode357fs/ext/inode.cblock = 2 + (inode->i_ino-1)/EXT_INODES_PER_BLOCK;
inode358fs/ext/inode.cif (!(bh=bread(inode->i_dev, block, BLOCK_SIZE)))
inode361fs/ext/inode.c(inode->i_ino-1)%EXT_INODES_PER_BLOCK;
inode362fs/ext/inode.cinode->i_mode = raw_inode->i_mode;
inode363fs/ext/inode.cinode->i_uid = raw_inode->i_uid;
inode364fs/ext/inode.cinode->i_gid = raw_inode->i_gid;
inode365fs/ext/inode.cinode->i_nlink = raw_inode->i_nlinks;
inode366fs/ext/inode.cinode->i_size = raw_inode->i_size;
inode367fs/ext/inode.cinode->i_mtime = inode->i_atime = inode->i_ctime = raw_inode->i_time;
inode368fs/ext/inode.cinode->i_blocks = inode->i_blksize = 0;
inode369fs/ext/inode.cif (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
inode370fs/ext/inode.cinode->i_rdev = raw_inode->i_zone[0];
inode372fs/ext/inode.cinode->u.ext_i.i_data[block] = raw_inode->i_zone[block];
inode374fs/ext/inode.cinode->i_op = NULL;
inode375fs/ext/inode.cif (S_ISREG(inode->i_mode))
inode376fs/ext/inode.cinode->i_op = &ext_file_inode_operations;
inode377fs/ext/inode.celse if (S_ISDIR(inode->i_mode))
inode378fs/ext/inode.cinode->i_op = &ext_dir_inode_operations;
inode379fs/ext/inode.celse if (S_ISLNK(inode->i_mode))
inode380fs/ext/inode.cinode->i_op = &ext_symlink_inode_operations;
inode381fs/ext/inode.celse if (S_ISCHR(inode->i_mode))
inode382fs/ext/inode.cinode->i_op = &chrdev_inode_operations;
inode383fs/ext/inode.celse if (S_ISBLK(inode->i_mode))
inode384fs/ext/inode.cinode->i_op = &blkdev_inode_operations;
inode385fs/ext/inode.celse if (S_ISFIFO(inode->i_mode))
inode386fs/ext/inode.cinit_fifo(inode);
inode389fs/ext/inode.cstatic struct buffer_head * ext_update_inode(struct inode * inode)
inode395fs/ext/inode.cblock = 2 + (inode->i_ino-1)/EXT_INODES_PER_BLOCK;
inode396fs/ext/inode.cif (!(bh=bread(inode->i_dev, block, BLOCK_SIZE)))
inode399fs/ext/inode.c(inode->i_ino-1)%EXT_INODES_PER_BLOCK;
inode400fs/ext/inode.craw_inode->i_mode = inode->i_mode;
inode401fs/ext/inode.craw_inode->i_uid = inode->i_uid;
inode402fs/ext/inode.craw_inode->i_gid = inode->i_gid;
inode403fs/ext/inode.craw_inode->i_nlinks = inode->i_nlink;
inode404fs/ext/inode.craw_inode->i_size = inode->i_size;
inode405fs/ext/inode.craw_inode->i_time = inode->i_mtime;
inode406fs/ext/inode.cif (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
inode407fs/ext/inode.craw_inode->i_zone[0] = inode->i_rdev;
inode409fs/ext/inode.craw_inode->i_zone[block] = inode->u.ext_i.i_data[block];
inode411fs/ext/inode.cinode->i_dirt=0;
inode415fs/ext/inode.cvoid ext_write_inode(struct inode * inode)
inode418fs/ext/inode.cbh = ext_update_inode (inode);
inode422fs/ext/inode.cint ext_sync_inode (struct inode *inode)
inode427fs/ext/inode.cbh = ext_update_inode(inode);
inode435fs/ext/inode.cinode->i_dev, inode->i_ino);
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 = &chrdev_inode_operations;
inode373fs/ext/namei.celse if (S_ISBLK(inode->i_mode))
inode374fs/ext/namei.cinode->i_op = &blkdev_inode_operations;
inode375fs/ext/namei.celse if (S_ISFIFO(inode->i_mode))
inode376fs/ext/namei.cinit_fifo(inode);
inode378fs/ext/namei.cinode->i_rdev = rdev;
inode379fs/ext/namei.cinode->i_mtime = inode->i_atime = CURRENT_TIME;
inode380fs/ext/namei.cinode->i_dirt = 1;
inode383fs/ext/namei.cinode->i_nlink--;
inode384fs/ext/namei.cinode->i_dirt = 1;
inode385fs/ext/namei.ciput(inode);
inode389fs/ext/namei.cde->inode = inode->i_ino;
inode393fs/ext/namei.ciput(inode);
inode397fs/ext/namei.cint ext_mkdir(struct inode * dir, const char * name, int len, int mode)
inode399fs/ext/namei.cstruct inode * inode;
inode409fs/ext/namei.cinode = ext_new_inode(dir);
inode410fs/ext/namei.cif (!inode) {
inode414fs/ext/namei.cinode->i_op = &ext_dir_inode_operations;
inode415fs/ext/namei.cinode->i_size = 2 * 16; /* Each entry is coded on 16 bytes for "." and ".."
inode420fs/ext/namei.cinode->i_mtime = inode->i_atime = CURRENT_TIME;
inode421fs/ext/namei.cdir_block = ext_bread(inode,0,1);
inode424fs/ext/namei.cinode->i_nlink--;
inode425fs/ext/namei.cinode->i_dirt = 1;
inode426fs/ext/namei.ciput(inode);
inode430fs/ext/namei.cde->inode=inode->i_ino;
inode435fs/ext/namei.cde->inode = dir->i_ino;
inode439fs/ext/namei.cinode->i_nlink = 2;
inode442fs/ext/namei.cinode->i_mode = S_IFDIR | (mode & 0777 & ~current->umask);
inode444fs/ext/namei.cinode->i_mode |= S_ISGID;
inode445fs/ext/namei.cinode->i_dirt = 1;
inode449fs/ext/namei.cinode->i_nlink=0;
inode450fs/ext/namei.ciput(inode);
inode453fs/ext/namei.cde->inode = inode->i_ino;
inode458fs/ext/namei.ciput(inode);
inode466fs/ext/namei.cstatic int empty_dir(struct inode * inode)
inode472fs/ext/namei.cif (inode->i_size < 2 * 12 || !(bh = ext_bread(inode,0,0))) {
inode473fs/ext/namei.cprintk("warning - bad directory on dev %04x\n",inode->i_dev);
inode478fs/ext/namei.cif (de->inode != inode->i_ino || !de1->inode || 
inode480fs/ext/namei.cprintk("warning - bad directory on dev %04x\n",inode->i_dev);
inode485fs/ext/namei.cwhile (offset < inode->i_size ) {
inode488fs/ext/namei.cbh = ext_bread(inode, offset >> BLOCK_SIZE_BITS,1);
inode499fs/ext/namei.cinode->i_dev, inode->i_ino, offset, de->rec_len, de->name_len);
inode503fs/ext/namei.cif (de->inode) {
inode517fs/ext/namei.cif (nde && !nde->inode)
inode519fs/ext/namei.cif (pde && !pde->inode)
inode523fs/ext/namei.cint ext_rmdir(struct inode * dir, const char * name, int len)
inode526fs/ext/namei.cstruct inode * inode;
inode530fs/ext/namei.cinode = NULL;
inode536fs/ext/namei.cif (!(inode = iget(dir->i_sb, de->inode)))
inode539fs/ext/namei.cinode->i_uid != current->euid)
inode541fs/ext/namei.cif (inode->i_dev != dir->i_dev)
inode543fs/ext/namei.cif (inode == dir)  /* we may not delete ".", but "../dir" is ok */
inode545fs/ext/namei.cif (!S_ISDIR(inode->i_mode)) {
inode549fs/ext/namei.cif (!empty_dir(inode)) {
inode553fs/ext/namei.cif (inode->i_count > 1) {
inode557fs/ext/namei.cif (inode->i_nlink != 2)
inode558fs/ext/namei.cprintk("empty directory has nlink!=2 (%d)\n",inode->i_nlink);
inode559fs/ext/namei.cde->inode = 0;
inode563fs/ext/namei.cinode->i_nlink=0;
inode564fs/ext/namei.cinode->i_dirt=1;
inode571fs/ext/namei.ciput(inode);
inode576fs/ext/namei.cint ext_unlink(struct inode * dir, const char * name, int len)
inode579fs/ext/namei.cstruct inode * inode;
inode584fs/ext/namei.cinode = NULL;
inode588fs/ext/namei.cif (!(inode = iget(dir->i_sb, de->inode)))
inode592fs/ext/namei.ccurrent->euid != inode->i_uid &&
inode595fs/ext/namei.cif (S_ISDIR(inode->i_mode))
inode597fs/ext/namei.cif (!inode->i_nlink) {
inode599fs/ext/namei.cinode->i_dev,inode->i_ino,inode->i_nlink);
inode600fs/ext/namei.cinode->i_nlink=1;
inode602fs/ext/namei.cde->inode = 0;
inode606fs/ext/namei.cinode->i_nlink--;
inode607fs/ext/namei.cinode->i_dirt = 1;
inode608fs/ext/namei.cinode->i_ctime = CURRENT_TIME;
inode614fs/ext/namei.ciput(inode);
inode619fs/ext/namei.cint ext_symlink(struct inode * dir, const char * name, int len, const char * symname)
inode622fs/ext/namei.cstruct inode * inode = NULL;
inode627fs/ext/namei.cif (!(inode = ext_new_inode(dir))) {
inode631fs/ext/namei.cinode->i_mode = S_IFLNK | 0777;
inode632fs/ext/namei.cinode->i_op = &ext_symlink_inode_operations;
inode633fs/ext/namei.cname_block = ext_bread(inode,0,1);
inode636fs/ext/namei.cinode->i_nlink--;
inode637fs/ext/namei.cinode->i_dirt = 1;
inode638fs/ext/namei.ciput(inode);
inode647fs/ext/namei.cinode->i_size = i;
inode648fs/ext/namei.cinode->i_dirt = 1;
inode651fs/ext/namei.cinode->i_nlink--;
inode652fs/ext/namei.cinode->i_dirt = 1;
inode653fs/ext/namei.ciput(inode);
inode660fs/ext/namei.cinode->i_nlink--;
inode661fs/ext/namei.cinode->i_dirt = 1;
inode662fs/ext/namei.ciput(inode);
inode666fs/ext/namei.cde->inode = inode->i_ino;
inode670fs/ext/namei.ciput(inode);
inode674fs/ext/namei.cint ext_link(struct inode * oldinode, struct inode * dir, const char * name, int len)
inode702fs/ext/namei.cde->inode = oldinode->i_ino;
inode713fs/ext/namei.cstatic int subdir(struct inode * new_inode, struct inode * old_inode)
inode739fs/ext/namei.c((struct ext_dir_entry *) buffer)->rec_len))->inode
inode755fs/ext/namei.cstatic int do_ext_rename(struct inode * old_dir, const char * old_name, int old_len,
inode756fs/ext/namei.cstruct inode * new_dir, const char * new_name, int new_len)
inode758fs/ext/namei.cstruct inode * old_inode, * new_inode;
inode779fs/ext/namei.cold_inode = iget(old_dir->i_sb, old_de->inode);
inode789fs/ext/namei.cnew_inode = iget(new_dir->i_sb, new_de->inode);
inode831fs/ext/namei.cif (new_inode && (new_de->inode != new_inode->i_ino))
inode833fs/ext/namei.cif (new_de->inode && !new_inode)
inode835fs/ext/namei.cif (old_de->inode != old_inode->i_ino)
inode838fs/ext/namei.cold_de->inode = 0;
inode840fs/ext/namei.cnew_de->inode = old_inode->i_ino;
inode877fs/ext/namei.cint ext_rename(struct inode * old_dir, const char * old_name, int old_len,
inode878fs/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)
inode58fs/ext/symlink.cif (!inode) {
inode62fs/ext/symlink.cif (!S_ISLNK(inode->i_mode)) {
inode64fs/ext/symlink.c*res_inode = inode;
inode69fs/ext/symlink.ciput(inode);
inode72fs/ext/symlink.cif (!(bh = ext_bread(inode, 0, 0))) {
inode73fs/ext/symlink.ciput(inode);
inode77fs/ext/symlink.ciput(inode);
inode85fs/ext/symlink.cstatic int ext_readlink(struct inode * inode, char * buffer, int buflen)
inode91fs/ext/symlink.cif (!S_ISLNK(inode->i_mode)) {
inode92fs/ext/symlink.ciput(inode);
inode97fs/ext/symlink.cbh = ext_bread(inode, 0, 0);
inode98fs/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)
inode22fs/ext2/acl.cint ext2_permission (struct inode * inode, int mask)
inode24fs/ext2/acl.cint mode = inode->i_mode;
inode30fs/ext2/acl.celse if (current->euid == inode->i_uid)
inode32fs/ext2/acl.celse if (in_group_p (inode->i_gid))
inode24fs/ext2/dir.cstatic int ext2_dir_read (struct inode * inode, struct file * filp,
inode31fs/ext2/dir.c/* static */ int ext2_file_read (struct inode *, struct file *, char *, int);
inode32fs/ext2/dir.cstatic int ext2_readdir (struct inode *, struct file *, struct dirent *, int);
inode68fs/ext2/dir.cint ext2_check_dir_entry (char * function, struct inode * dir,
inode88fs/ext2/dir.coffset, de->inode, de->rec_len,  de->name_len);
inode93fs/ext2/dir.cstatic int ext2_readdir (struct inode * inode, struct file * filp,
inode102fs/ext2/dir.cif (!inode || !S_ISDIR(inode->i_mode))
inode104fs/ext2/dir.csb = inode->i_sb;
inode105fs/ext2/dir.cwhile (filp->f_pos < inode->i_size) {
inode107fs/ext2/dir.cbh = ext2_bread (inode, (filp->f_pos) >> EXT2_BLOCK_SIZE_BITS(sb),
inode114fs/ext2/dir.cwhile (offset < sb->s_blocksize && filp->f_pos < inode->i_size) {
inode115fs/ext2/dir.cif (! ext2_check_dir_entry ("ext2_readdir", inode, de,
inode122fs/ext2/dir.cif (de->inode) {
inode125fs/ext2/dir.cput_fs_long (de->inode, &dirent->d_ino);
inode129fs/ext2/dir.cext2_dcache_add (inode->i_dev, inode->i_ino,
inode131fs/ext2/dir.cde->inode);
inode34fs/ext2/file.c/* static */ int ext2_file_read (struct inode *, struct file *, char *, int);
inode35fs/ext2/file.cstatic int ext2_file_write (struct inode *, struct file *, char *, int);
inode72fs/ext2/file.c/* static */ int ext2_file_read (struct inode * inode, struct file * filp,
inode85fs/ext2/file.cif (!inode) {
inode89fs/ext2/file.csb = inode->i_sb;
inode90fs/ext2/file.cif (!S_ISREG(inode->i_mode) && !S_ISDIR(inode->i_mode)) {
inode91fs/ext2/file.cprintk ("ext2_file_read: mode = %07o\n", inode->i_mode);
inode95fs/ext2/file.csize = inode->i_size;
inode111fs/ext2/file.cblocks += read_ahead[MAJOR(inode->i_dev)] >>
inode132fs/ext2/file.c*bhb = ext2_getblk (inode, block++, 0, &err);
inode193fs/ext2/file.cif (!IS_RDONLY(inode)) {
inode194fs/ext2/file.cinode->i_atime = CURRENT_TIME;
inode195fs/ext2/file.cinode->i_dirt = 1;
inode200fs/ext2/file.cstatic int ext2_file_write (struct inode * inode, struct file * filp,
inode210fs/ext2/file.cif (!inode) {
inode214fs/ext2/file.csb = inode->i_sb;
inode215fs/ext2/file.cif (!S_ISREG(inode->i_mode)) {
inode216fs/ext2/file.cprintk ("ext2_file_write: mode = %07o\n", inode->i_mode);
inode224fs/ext2/file.cpos = inode->i_size;
inode229fs/ext2/file.cbh = ext2_getblk (inode, pos / sb->s_blocksize, 1, &err);
inode250fs/ext2/file.cif (pos > inode->i_size) {
inode251fs/ext2/file.cinode->i_size = pos;
inode252fs/ext2/file.cinode->i_dirt = 1;
inode261fs/ext2/file.cinode->i_mtime = CURRENT_TIME;
inode262fs/ext2/file.cinode->i_ctime = CURRENT_TIME;
inode264fs/ext2/file.cinode->i_dirt = 1;
inode27fs/ext2/fsync.c#define blocksize (EXT2_BLOCK_SIZE(inode->i_sb))
inode28fs/ext2/fsync.c#define addr_per_block (EXT2_ADDR_PER_BLOCK(inode->i_sb))
inode30fs/ext2/fsync.cstatic int sync_block (struct inode * inode, unsigned long * block, int wait)
inode38fs/ext2/fsync.cbh = get_hash_table (inode->i_dev, *block, blocksize);
inode58fs/ext2/fsync.cstatic int sync_iblock (struct inode * inode, unsigned long * iblock, 
inode67fs/ext2/fsync.crc = sync_block (inode, iblock, wait);
inode70fs/ext2/fsync.c*bh = bread (inode->i_dev, tmp, blocksize);
inode82fs/ext2/fsync.cstatic int sync_direct (struct inode * inode, int wait)
inode88fs/ext2/fsync.crc = sync_block (inode, inode->u.ext2_i.i_data + i, wait);
inode97fs/ext2/fsync.cstatic int sync_indirect (struct inode * inode, unsigned long * iblock,
inode104fs/ext2/fsync.crc = sync_iblock (inode, iblock, &ind_bh, wait);
inode109fs/ext2/fsync.crc = sync_block (inode, 
inode121fs/ext2/fsync.cstatic int sync_dindirect (struct inode * inode, unsigned long * diblock,
inode128fs/ext2/fsync.crc = sync_iblock (inode, diblock, &dind_bh, wait);
inode133fs/ext2/fsync.crc = sync_indirect (inode,
inode145fs/ext2/fsync.cstatic int sync_tindirect (struct inode * inode, unsigned long * tiblock, 
inode152fs/ext2/fsync.crc = sync_iblock (inode, tiblock, &tind_bh, wait);
inode157fs/ext2/fsync.crc = sync_dindirect (inode,
inode169fs/ext2/fsync.cint ext2_sync_file (struct inode * inode, struct file * file)
inode173fs/ext2/fsync.cif (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
inode174fs/ext2/fsync.cS_ISLNK(inode->i_mode)))
inode177fs/ext2/fsync.cif (S_ISLNK(inode->i_mode) && !(inode->i_blocks))
inode182fs/ext2/fsync.cerr |= sync_direct (inode, wait);
inode183fs/ext2/fsync.cerr |= sync_indirect (inode,
inode184fs/ext2/fsync.cinode->u.ext2_i.i_data+EXT2_IND_BLOCK,
inode186fs/ext2/fsync.cerr |= sync_dindirect (inode,
inode187fs/ext2/fsync.cinode->u.ext2_i.i_data+EXT2_DIND_BLOCK, 
inode189fs/ext2/fsync.cerr |= sync_tindirect (inode, 
inode190fs/ext2/fsync.cinode->u.ext2_i.i_data+EXT2_TIND_BLOCK, 
inode194fs/ext2/fsync.cerr |= ext2_sync_inode (inode);
inode162fs/ext2/ialloc.cstatic void set_inode_dtime (struct inode * inode,
inode169fs/ext2/ialloc.cinode_block = gdp[desc].bg_inode_table + (((inode->i_ino - 1) %
inode170fs/ext2/ialloc.cEXT2_INODES_PER_GROUP(inode->i_sb)) /
inode171fs/ext2/ialloc.cEXT2_INODES_PER_BLOCK(inode->i_sb));
inode172fs/ext2/ialloc.cbh = bread (inode->i_sb->s_dev, inode_block, inode->i_sb->s_blocksize);
inode174fs/ext2/ialloc.cprintk ("inode=%d, inode_block=%d\n", inode->i_ino, inode_block);
inode178fs/ext2/ialloc.c(((inode->i_ino - 1) %
inode179fs/ext2/ialloc.cEXT2_INODES_PER_GROUP(inode->i_sb)) %
inode180fs/ext2/ialloc.cEXT2_INODES_PER_BLOCK(inode->i_sb));
inode186fs/ext2/ialloc.cvoid ext2_free_inode (struct inode * inode)
inode199fs/ext2/ialloc.cif (!inode)
inode201fs/ext2/ialloc.cif (!inode->i_dev) {
inode205fs/ext2/ialloc.cif (inode->i_count > 1) {
inode207fs/ext2/ialloc.cinode->i_count);
inode210fs/ext2/ialloc.cif (inode->i_nlink) {
inode212fs/ext2/ialloc.cinode->i_nlink);
inode215fs/ext2/ialloc.cif (!inode->i_sb) {
inode220fs/ext2/ialloc.cprintk ("ext2_free_inode: freeing inode %d\n", inode->i_ino);
inode222fs/ext2/ialloc.csb = inode->i_sb;
inode224fs/ext2/ialloc.cif (inode->i_ino < 1 ||
inode225fs/ext2/ialloc.cinode->i_ino > sb->u.ext2_sb.s_es->s_inodes_count) {
inode231fs/ext2/ialloc.cblock_group = (inode->i_ino - 1) / EXT2_INODES_PER_GROUP(sb);
inode232fs/ext2/ialloc.cbit = (inode->i_ino - 1) % EXT2_INODES_PER_GROUP(sb);
inode241fs/ext2/ialloc.csb->s_dev, inode->i_ino);
inode252fs/ext2/ialloc.cif (S_ISDIR(inode->i_mode))
inode255fs/ext2/ialloc.cset_inode_dtime (inode, gdp, desc);
inode262fs/ext2/ialloc.cclear_inode (inode);
inode270fs/ext2/ialloc.cstatic void inc_inode_version (struct inode * inode,
inode278fs/ext2/ialloc.cinode_block = gdp->bg_inode_table + (((inode->i_ino - 1) %
inode279fs/ext2/ialloc.cEXT2_INODES_PER_GROUP(inode->i_sb)) /
inode280fs/ext2/ialloc.cEXT2_INODES_PER_BLOCK(inode->i_sb));
inode281fs/ext2/ialloc.cbh = bread (inode->i_sb->s_dev, inode_block, inode->i_sb->s_blocksize);
inode284fs/ext2/ialloc.cinode->i_ino, inode_block);
inode286fs/ext2/ialloc.cinode->u.ext2_i.i_version = 1;
inode290fs/ext2/ialloc.c(((inode->i_ino - 1) %
inode291fs/ext2/ialloc.cEXT2_INODES_PER_GROUP(inode->i_sb)) %
inode292fs/ext2/ialloc.cEXT2_INODES_PER_BLOCK(inode->i_sb));
inode294fs/ext2/ialloc.cinode->u.ext2_i.i_version = raw_inode->i_version;
inode324fs/ext2/ialloc.cstruct inode * ext2_new_inode (const struct inode * dir, int mode)
inode329fs/ext2/ialloc.cstruct inode * inode;
inode334fs/ext2/ialloc.cif (!dir || !(inode = get_empty_inode ()))
inode337fs/ext2/ialloc.cinode->i_sb = sb;
inode338fs/ext2/ialloc.cinode->i_flags = sb->s_flags;
inode411fs/ext2/ialloc.ciput(inode);
inode435fs/ext2/ialloc.ciput (inode);
inode445fs/ext2/ialloc.cinode->i_mode = mode;
inode446fs/ext2/ialloc.cinode->i_sb = sb;
inode447fs/ext2/ialloc.cinode->i_count = 1;
inode448fs/ext2/ialloc.cinode->i_nlink = 1;
inode449fs/ext2/ialloc.cinode->i_dev = sb->s_dev;
inode450fs/ext2/ialloc.cinode->i_uid = current->euid;
inode451fs/ext2/ialloc.cinode->i_gid = (dir->i_mode & S_ISGID) ? dir->i_gid : current->egid;
inode452fs/ext2/ialloc.cinode->i_dirt = 1;
inode453fs/ext2/ialloc.cinode->i_ino = j;
inode454fs/ext2/ialloc.cinode->i_blksize = sb->s_blocksize;
inode455fs/ext2/ialloc.cinode->i_blocks = 0;
inode456fs/ext2/ialloc.cinode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
inode457fs/ext2/ialloc.cinode->u.ext2_i.i_flags = 0;
inode458fs/ext2/ialloc.cinode->u.ext2_i.i_faddr = 0;
inode459fs/ext2/ialloc.cinode->u.ext2_i.i_frag = 0;
inode460fs/ext2/ialloc.cinode->u.ext2_i.i_fsize = 0;
inode461fs/ext2/ialloc.cinode->u.ext2_i.i_file_acl = 0;
inode462fs/ext2/ialloc.cinode->u.ext2_i.i_dir_acl = 0;
inode463fs/ext2/ialloc.cinode->u.ext2_i.i_dtime = 0;
inode464fs/ext2/ialloc.cinode->u.ext2_i.i_block_group = i;
inode465fs/ext2/ialloc.cinode->i_op = NULL;
inode466fs/ext2/ialloc.cinsert_inode_hash(inode);
inode467fs/ext2/ialloc.cinc_inode_version (inode, gdp, mode);
inode469fs/ext2/ialloc.cprintk ("ext2_new_inode : allocating inode %d\n", inode->i_ino);
inode472fs/ext2/ialloc.creturn inode;
inode27fs/ext2/inode.cvoid ext2_put_inode (struct inode * inode)
inode29fs/ext2/inode.cif (inode->i_nlink || inode->i_ino == EXT2_ACL_IDX_INO ||
inode30fs/ext2/inode.cinode->i_ino == EXT2_ACL_DATA_INO)
inode32fs/ext2/inode.cinode->i_size = 0;
inode33fs/ext2/inode.cif (inode->i_blocks)
inode34fs/ext2/inode.cext2_truncate (inode);
inode35fs/ext2/inode.cext2_free_inode (inode);
inode409fs/ext2/inode.c#define inode_bmap(inode, nr) ((inode)->u.ext2_i.i_data[(nr)])
inode422fs/ext2/inode.cint ext2_bmap (struct inode * inode, int block)
inode425fs/ext2/inode.cint addr_per_block = EXT2_ADDR_PER_BLOCK(inode->i_sb);
inode438fs/ext2/inode.creturn inode_bmap (inode, block);
inode441fs/ext2/inode.ci = inode_bmap (inode, EXT2_IND_BLOCK);
inode444fs/ext2/inode.creturn block_bmap (bread (inode->i_dev, i,
inode445fs/ext2/inode.cinode->i_sb->s_blocksize), block);
inode449fs/ext2/inode.ci = inode_bmap (inode, EXT2_DIND_BLOCK);
inode452fs/ext2/inode.ci = block_bmap (bread (inode->i_dev, i,
inode453fs/ext2/inode.cinode->i_sb->s_blocksize),
inode457fs/ext2/inode.creturn block_bmap (bread (inode->i_dev, i,
inode458fs/ext2/inode.cinode->i_sb->s_blocksize),
inode462fs/ext2/inode.ci = inode_bmap (inode, EXT2_TIND_BLOCK);
inode465fs/ext2/inode.ci = block_bmap (bread (inode->i_dev, i, inode->i_sb->s_blocksize),
inode469fs/ext2/inode.ci = block_bmap (bread (inode->i_dev, i, inode->i_sb->s_blocksize),
inode473fs/ext2/inode.creturn block_bmap (bread (inode->i_dev, i, inode->i_sb->s_blocksize),
inode477fs/ext2/inode.cstatic struct buffer_head * inode_getblk (struct inode * inode, int nr,
inode483fs/ext2/inode.cint blocks = inode->i_sb->s_blocksize / 512;
inode485fs/ext2/inode.cp = inode->u.ext2_i.i_data + nr;
inode489fs/ext2/inode.cresult = getblk (inode->i_dev, tmp, inode->i_sb->s_blocksize);
inode497fs/ext2/inode.cEXT2_BLOCK_SIZE_BITS(inode->i_sb))) {
inode501fs/ext2/inode.cif (inode->u.ext2_i.i_next_alloc_block == new_block)
inode502fs/ext2/inode.cgoal = inode->u.ext2_i.i_next_alloc_goal;
inode508fs/ext2/inode.cif (inode->u.ext2_i.i_data[tmp]) {
inode509fs/ext2/inode.cgoal = inode->u.ext2_i.i_data[tmp];
inode514fs/ext2/inode.cgoal = (inode->u.ext2_i.i_block_group * 
inode515fs/ext2/inode.cEXT2_BLOCKS_PER_GROUP(inode->i_sb)) +
inode516fs/ext2/inode.cinode->i_sb->u.ext2_sb.s_es->s_first_data_block;
inode522fs/ext2/inode.ctmp = ext2_new_block (inode->i_sb, goal);
inode525fs/ext2/inode.cresult = getblk (inode->i_dev, tmp, inode->i_sb->s_blocksize);
inode527fs/ext2/inode.cext2_free_block (inode->i_sb, tmp);
inode532fs/ext2/inode.cinode->u.ext2_i.i_next_alloc_block = new_block;
inode533fs/ext2/inode.cinode->u.ext2_i.i_next_alloc_goal = tmp;
inode534fs/ext2/inode.cinode->i_ctime = CURRENT_TIME;
inode535fs/ext2/inode.cinode->i_blocks += blocks;
inode536fs/ext2/inode.cinode->i_dirt = 1;
inode540fs/ext2/inode.cstatic struct buffer_head * block_getblk (struct inode * inode,
inode548fs/ext2/inode.cint blocks = inode->i_sb->s_blocksize / 512;
inode574fs/ext2/inode.cEXT2_BLOCK_SIZE_BITS(inode->i_sb))) {
inode579fs/ext2/inode.cif (inode->u.ext2_i.i_next_alloc_block == new_block)
inode580fs/ext2/inode.cgoal = inode->u.ext2_i.i_next_alloc_goal;
inode591fs/ext2/inode.ctmp = ext2_new_block (inode->i_sb, goal);
inode601fs/ext2/inode.cext2_free_block (inode->i_sb, tmp);
inode607fs/ext2/inode.cinode->i_ctime = CURRENT_TIME;
inode608fs/ext2/inode.cinode->i_blocks += blocks;
inode609fs/ext2/inode.cinode->i_dirt = 1;
inode610fs/ext2/inode.cinode->u.ext2_i.i_next_alloc_block = new_block;
inode611fs/ext2/inode.cinode->u.ext2_i.i_next_alloc_goal = tmp;
inode616fs/ext2/inode.cstruct buffer_head * ext2_getblk (struct inode * inode, int block,
inode621fs/ext2/inode.cunsigned long addr_per_block = EXT2_ADDR_PER_BLOCK(inode->i_sb);
inode639fs/ext2/inode.cinode->u.ext2_i.i_next_alloc_block,
inode640fs/ext2/inode.cinode->u.ext2_i.i_next_alloc_goal);
inode642fs/ext2/inode.cif (block == inode->u.ext2_i.i_next_alloc_block + 1) {
inode643fs/ext2/inode.cinode->u.ext2_i.i_next_alloc_block++;
inode644fs/ext2/inode.cinode->u.ext2_i.i_next_alloc_goal++;
inode650fs/ext2/inode.creturn inode_getblk (inode, block, create, b, err);
inode653fs/ext2/inode.cbh = inode_getblk (inode, EXT2_IND_BLOCK, create, b, err);
inode654fs/ext2/inode.creturn block_getblk (inode, bh, block, create,
inode655fs/ext2/inode.cinode->i_sb->s_blocksize, b, err);
inode659fs/ext2/inode.cbh = inode_getblk (inode, EXT2_DIND_BLOCK, create, b, err);
inode660fs/ext2/inode.cbh = block_getblk (inode, bh, block / addr_per_block, create,
inode661fs/ext2/inode.cinode->i_sb->s_blocksize, b, err);
inode662fs/ext2/inode.creturn block_getblk (inode, bh, block & (addr_per_block - 1),
inode663fs/ext2/inode.ccreate, inode->i_sb->s_blocksize, b, err);
inode666fs/ext2/inode.cbh = inode_getblk (inode, EXT2_TIND_BLOCK, create, b, err);
inode667fs/ext2/inode.cbh = block_getblk (inode, bh, block/(addr_per_block * addr_per_block),
inode668fs/ext2/inode.ccreate, inode->i_sb->s_blocksize, b, err);
inode669fs/ext2/inode.cbh = block_getblk (inode, bh, (block/addr_per_block) & (addr_per_block - 1),
inode670fs/ext2/inode.ccreate, inode->i_sb->s_blocksize, b, err);
inode671fs/ext2/inode.creturn block_getblk (inode, bh, block & (addr_per_block - 1), create,
inode672fs/ext2/inode.cinode->i_sb->s_blocksize, b, err);
inode675fs/ext2/inode.cstruct buffer_head * ext2_bread (struct inode * inode, int block, 
inode680fs/ext2/inode.cbh = ext2_getblk (inode, block, create, err);
inode692fs/ext2/inode.cvoid ext2_read_inode (struct inode * inode)
inode702fs/ext2/inode.cif ((inode->i_ino != EXT2_ROOT_INO && inode->i_ino != EXT2_ACL_IDX_INO &&
inode703fs/ext2/inode.cinode->i_ino != EXT2_ACL_DATA_INO && inode->i_ino < EXT2_FIRST_INO) ||
inode704fs/ext2/inode.cinode->i_ino > inode->i_sb->u.ext2_sb.s_es->s_inodes_count) {
inode706fs/ext2/inode.cinode->i_dev, inode->i_ino);
inode709fs/ext2/inode.cblock_group = (inode->i_ino - 1) / EXT2_INODES_PER_GROUP(inode->i_sb);
inode710fs/ext2/inode.cif (block_group >= inode->i_sb->u.ext2_sb.s_groups_count)
inode712fs/ext2/inode.cgroup_desc = block_group / EXT2_DESC_PER_BLOCK(inode->i_sb);
inode713fs/ext2/inode.cdesc = block_group % EXT2_DESC_PER_BLOCK(inode->i_sb);
inode714fs/ext2/inode.cbh = inode->i_sb->u.ext2_sb.s_group_desc[group_desc];
inode719fs/ext2/inode.c(((inode->i_ino - 1) % EXT2_INODES_PER_GROUP(inode->i_sb))
inode720fs/ext2/inode.c/ EXT2_INODES_PER_BLOCK(inode->i_sb));
inode721fs/ext2/inode.cif (!(bh = bread (inode->i_dev, block, inode->i_sb->s_blocksize)))
inode724fs/ext2/inode.c(inode->i_ino - 1) % EXT2_INODES_PER_BLOCK(inode->i_sb);
inode725fs/ext2/inode.cinode->i_mode = raw_inode->i_mode;
inode726fs/ext2/inode.cinode->i_uid = raw_inode->i_uid;
inode727fs/ext2/inode.cinode->i_gid = raw_inode->i_gid;
inode728fs/ext2/inode.cinode->i_nlink = raw_inode->i_links_count;
inode729fs/ext2/inode.cinode->i_size = raw_inode->i_size;
inode730fs/ext2/inode.cinode->i_atime = raw_inode->i_atime;
inode731fs/ext2/inode.cinode->i_ctime = raw_inode->i_ctime;
inode732fs/ext2/inode.cinode->i_mtime = raw_inode->i_mtime;
inode733fs/ext2/inode.cinode->u.ext2_i.i_dtime = raw_inode->i_dtime;
inode734fs/ext2/inode.cinode->i_blksize = inode->i_sb->s_blocksize;
inode735fs/ext2/inode.cinode->i_blocks = raw_inode->i_blocks;
inode736fs/ext2/inode.cinode->u.ext2_i.i_flags = raw_inode->i_flags;
inode737fs/ext2/inode.cinode->u.ext2_i.i_faddr = raw_inode->i_faddr;
inode738fs/ext2/inode.cinode->u.ext2_i.i_frag = raw_inode->i_frag;
inode739fs/ext2/inode.cinode->u.ext2_i.i_fsize = raw_inode->i_fsize;
inode740fs/ext2/inode.cinode->u.ext2_i.i_file_acl = raw_inode->i_file_acl;
inode741fs/ext2/inode.cinode->u.ext2_i.i_dir_acl = raw_inode->i_dir_acl;
inode742fs/ext2/inode.cinode->u.ext2_i.i_version = raw_inode->i_version;
inode743fs/ext2/inode.cinode->u.ext2_i.i_block_group = block_group;
inode744fs/ext2/inode.cinode->u.ext2_i.i_next_alloc_block = 0;
inode745fs/ext2/inode.cinode->u.ext2_i.i_next_alloc_goal = 0;
inode746fs/ext2/inode.cif (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
inode747fs/ext2/inode.cinode->i_rdev = raw_inode->i_block[0];
inode749fs/ext2/inode.cinode->u.ext2_i.i_data[block] = raw_inode->i_block[block];
inode751fs/ext2/inode.cinode->i_op = NULL;
inode752fs/ext2/inode.cif (inode->i_ino == EXT2_ACL_IDX_INO ||
inode753fs/ext2/inode.cinode->i_ino == EXT2_ACL_DATA_INO)
inode755fs/ext2/inode.celse if (S_ISREG(inode->i_mode))
inode756fs/ext2/inode.cinode->i_op = &ext2_file_inode_operations;
inode757fs/ext2/inode.celse if (S_ISDIR(inode->i_mode))
inode758fs/ext2/inode.cinode->i_op = &ext2_dir_inode_operations;
inode759fs/ext2/inode.celse if (S_ISLNK(inode->i_mode))
inode760fs/ext2/inode.cinode->i_op = &ext2_symlink_inode_operations;
inode761fs/ext2/inode.celse if (S_ISCHR(inode->i_mode))
inode762fs/ext2/inode.cinode->i_op = &chrdev_inode_operations;
inode763fs/ext2/inode.celse if (S_ISBLK(inode->i_mode))
inode764fs/ext2/inode.cinode->i_op = &blkdev_inode_operations;
inode765fs/ext2/inode.celse if (S_ISFIFO(inode->i_mode))
inode766fs/ext2/inode.cinit_fifo(inode);
inode769fs/ext2/inode.cstatic struct buffer_head * ext2_update_inode (struct inode * inode)
inode779fs/ext2/inode.cif ((inode->i_ino != EXT2_ROOT_INO && inode->i_ino < EXT2_FIRST_INO) ||
inode780fs/ext2/inode.cinode->i_ino > inode->i_sb->u.ext2_sb.s_es->s_inodes_count) {
inode782fs/ext2/inode.cinode->i_dev, inode->i_ino);
inode785fs/ext2/inode.cblock_group = (inode->i_ino - 1) / EXT2_INODES_PER_GROUP(inode->i_sb);
inode786fs/ext2/inode.cif (block_group >= inode->i_sb->u.ext2_sb.s_groups_count)
inode788fs/ext2/inode.cgroup_desc = block_group / EXT2_DESC_PER_BLOCK(inode->i_sb);
inode789fs/ext2/inode.cdesc = block_group % EXT2_DESC_PER_BLOCK(inode->i_sb);
inode790fs/ext2/inode.cbh = inode->i_sb->u.ext2_sb.s_group_desc[group_desc];
inode795fs/ext2/inode.c(((inode->i_ino - 1) % EXT2_INODES_PER_GROUP(inode->i_sb))
inode796fs/ext2/inode.c/ EXT2_INODES_PER_BLOCK(inode->i_sb));
inode797fs/ext2/inode.cif (!(bh = bread (inode->i_dev, block, inode->i_sb->s_blocksize)))
inode800fs/ext2/inode.c(inode->i_ino - 1) % EXT2_INODES_PER_BLOCK(inode->i_sb);
inode801fs/ext2/inode.craw_inode->i_mode = inode->i_mode;
inode802fs/ext2/inode.craw_inode->i_uid = inode->i_uid;
inode803fs/ext2/inode.craw_inode->i_gid = inode->i_gid;
inode804fs/ext2/inode.craw_inode->i_links_count = inode->i_nlink;
inode805fs/ext2/inode.craw_inode->i_size = inode->i_size;
inode806fs/ext2/inode.craw_inode->i_atime = inode->i_atime;
inode807fs/ext2/inode.craw_inode->i_ctime = inode->i_ctime;
inode808fs/ext2/inode.craw_inode->i_mtime = inode->i_mtime;
inode809fs/ext2/inode.craw_inode->i_blocks = inode->i_blocks;
inode810fs/ext2/inode.craw_inode->i_dtime = inode->u.ext2_i.i_dtime;
inode811fs/ext2/inode.craw_inode->i_flags = inode->u.ext2_i.i_flags;
inode812fs/ext2/inode.craw_inode->i_faddr = inode->u.ext2_i.i_faddr;
inode813fs/ext2/inode.craw_inode->i_frag = inode->u.ext2_i.i_frag;
inode814fs/ext2/inode.craw_inode->i_fsize = inode->u.ext2_i.i_fsize;
inode815fs/ext2/inode.craw_inode->i_file_acl = inode->u.ext2_i.i_file_acl;
inode816fs/ext2/inode.craw_inode->i_dir_acl = inode->u.ext2_i.i_dir_acl;
inode817fs/ext2/inode.craw_inode->i_version = inode->u.ext2_i.i_version;
inode818fs/ext2/inode.cif (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
inode819fs/ext2/inode.craw_inode->i_block[0] = inode->i_rdev;
inode821fs/ext2/inode.craw_inode->i_block[block] = inode->u.ext2_i.i_data[block];
inode823fs/ext2/inode.cinode->i_dirt = 0;
inode827fs/ext2/inode.cvoid ext2_write_inode (struct inode * inode)
inode830fs/ext2/inode.cbh = ext2_update_inode (inode);
inode834fs/ext2/inode.cint ext2_sync_inode (struct inode *inode)
inode839fs/ext2/inode.cbh = ext2_update_inode (inode);
inode847fs/ext2/inode.cinode->i_dev, inode->i_ino);
inode11fs/ext2/ioctl.cint ext2_ioctl (struct inode * inode, struct file * filp, unsigned int cmd,
inode37fs/ext2/namei.cif (!de || !de->inode || len > EXT2_NAME_LEN)
inode63fs/ext2/namei.cstatic struct buffer_head * ext2_find_entry (struct inode * dir,
inode115fs/ext2/namei.cint ext2_lookup (struct inode * dir, const char * name, int len,
inode116fs/ext2/namei.cstruct inode ** result)
inode136fs/ext2/namei.cino = de->inode;
inode163fs/ext2/namei.cstatic struct buffer_head * ext2_add_entry (struct inode * dir,
inode219fs/ext2/namei.cde->inode = 0;
inode237fs/ext2/namei.cif (de->inode) {
inode244fs/ext2/namei.cif ((!de->inode && de->rec_len >= rec_len) ||
inode247fs/ext2/namei.cif (de->inode) {
inode255fs/ext2/namei.cde->inode = 0;
inode294fs/ext2/namei.cdir->inode = 0;
inode304fs/ext2/namei.cint ext2_create (struct inode * dir,const char * name, int len, int mode,
inode305fs/ext2/namei.cstruct inode ** result)
inode307fs/ext2/namei.cstruct inode * inode;
inode315fs/ext2/namei.cinode = ext2_new_inode (dir, mode);
inode316fs/ext2/namei.cif (!inode) {
inode320fs/ext2/namei.cinode->i_op = &ext2_file_inode_operations;
inode321fs/ext2/namei.cinode->i_mode = mode;
inode322fs/ext2/namei.cinode->i_dirt = 1;
inode325fs/ext2/namei.cinode->i_nlink--;
inode326fs/ext2/namei.cinode->i_dirt = 1;
inode327fs/ext2/namei.ciput (inode);
inode331fs/ext2/namei.cde->inode = inode->i_ino;
inode334fs/ext2/namei.cde->inode);
inode339fs/ext2/namei.c*result = inode;
inode343fs/ext2/namei.cint ext2_mknod (struct inode * dir, const char * name, int len, int mode,
inode346fs/ext2/namei.cstruct inode * inode;
inode359fs/ext2/namei.cinode = ext2_new_inode (dir, mode);
inode360fs/ext2/namei.cif (!inode) {
inode364fs/ext2/namei.cinode->i_uid = current->euid;
inode365fs/ext2/namei.cinode->i_mode = mode;
inode366fs/ext2/namei.cinode->i_op = NULL;
inode367fs/ext2/namei.cif (S_ISREG(inode->i_mode))
inode368fs/ext2/namei.cinode->i_op = &ext2_file_inode_operations;
inode369fs/ext2/namei.celse if (S_ISDIR(inode->i_mode)) {
inode370fs/ext2/namei.cinode->i_op = &ext2_dir_inode_operations;
inode372fs/ext2/namei.cinode->i_mode |= S_ISGID;
inode374fs/ext2/namei.celse if (S_ISLNK(inode->i_mode))
inode375fs/ext2/namei.cinode->i_op = &ext2_symlink_inode_operations;
inode376fs/ext2/namei.celse if (S_ISCHR(inode->i_mode))
inode377fs/ext2/namei.cinode->i_op = &chrdev_inode_operations;
inode378fs/ext2/namei.celse if (S_ISBLK(inode->i_mode))
inode379fs/ext2/namei.cinode->i_op = &blkdev_inode_operations;
inode380fs/ext2/namei.celse if (S_ISFIFO(inode->i_mode)) 
inode381fs/ext2/namei.cinit_fifo(inode);
inode383fs/ext2/namei.cinode->i_rdev = rdev;
inode384fs/ext2/namei.cinode->i_mtime = inode->i_atime = CURRENT_TIME;
inode385fs/ext2/namei.cinode->i_dirt = 1;
inode388fs/ext2/namei.cinode->i_nlink--;
inode389fs/ext2/namei.cinode->i_dirt = 1;
inode390fs/ext2/namei.ciput (inode);
inode394fs/ext2/namei.cde->inode = inode->i_ino;
inode397fs/ext2/namei.cde->inode);
inode402fs/ext2/namei.ciput (inode);
inode406fs/ext2/namei.cint ext2_mkdir (struct inode * dir, const char * name, int len, int mode)
inode408fs/ext2/namei.cstruct inode * inode;
inode425fs/ext2/namei.cinode = ext2_new_inode (dir, S_IFDIR);
inode426fs/ext2/namei.cif (!inode) {
inode430fs/ext2/namei.cinode->i_op = &ext2_dir_inode_operations;
inode431fs/ext2/namei.cinode->i_size = inode->i_sb->s_blocksize;
inode432fs/ext2/namei.cinode->i_mtime = inode->i_atime = CURRENT_TIME;
inode433fs/ext2/namei.cdir_block = ext2_bread (inode, 0, 1, &err);
inode436fs/ext2/namei.cinode->i_nlink--;
inode437fs/ext2/namei.cinode->i_dirt = 1;
inode438fs/ext2/namei.ciput (inode);
inode441fs/ext2/namei.cinode->i_blocks = inode->i_sb->s_blocksize / 512;
inode443fs/ext2/namei.cde->inode = inode->i_ino;
inode448fs/ext2/namei.cde->inode = dir->i_ino;
inode449fs/ext2/namei.cde->rec_len = inode->i_sb->s_blocksize - EXT2_DIR_REC_LEN(1);
inode452fs/ext2/namei.cinode->i_nlink = 2;
inode455fs/ext2/namei.cinode->i_mode = S_IFDIR | (mode & S_IRWXUGO & ~current->umask);
inode457fs/ext2/namei.cinode->i_mode |= S_ISGID;
inode458fs/ext2/namei.cinode->i_dirt = 1;
inode462fs/ext2/namei.cinode->i_nlink = 0;
inode463fs/ext2/namei.ciput (inode);
inode466fs/ext2/namei.cde->inode = inode->i_ino;
inode469fs/ext2/namei.cde->inode);
inode475fs/ext2/namei.ciput (inode);
inode483fs/ext2/namei.cstatic int empty_dir (struct inode * inode)
inode491fs/ext2/namei.csb = inode->i_sb;
inode492fs/ext2/namei.cif (inode->i_size < EXT2_DIR_REC_LEN(1) + EXT2_DIR_REC_LEN(2) ||
inode493fs/ext2/namei.c!(bh = ext2_bread (inode, 0, 0, &err))) {
inode495fs/ext2/namei.cinode->i_dev, inode->i_ino);
inode500fs/ext2/namei.cif (de->inode != inode->i_ino || !de1->inode || 
inode503fs/ext2/namei.cinode->i_dev, inode->i_ino);
inode508fs/ext2/namei.cwhile (offset < inode->i_size ) {
inode511fs/ext2/namei.cbh = ext2_bread (inode, offset >> EXT2_BLOCK_SIZE_BITS(sb), 1, &err);
inode518fs/ext2/namei.cif (! ext2_check_dir_entry ("empty_dir", inode, de, bh,
inode523fs/ext2/namei.cif (de->inode) {
inode534fs/ext2/namei.cint ext2_rmdir (struct inode * dir, const char * name, int len)
inode537fs/ext2/namei.cstruct inode * inode;
inode544fs/ext2/namei.cinode = NULL;
inode550fs/ext2/namei.cif (!(inode = iget (dir->i_sb, de->inode)))
inode552fs/ext2/namei.cif (de->inode != inode->i_ino) {
inode553fs/ext2/namei.ciput(inode);
inode560fs/ext2/namei.cinode->i_uid != current->euid)
inode562fs/ext2/namei.cif (inode->i_dev != dir->i_dev)
inode564fs/ext2/namei.cif (inode == dir)  /* we may not delete ".", but "../dir" is ok */
inode566fs/ext2/namei.cif (!S_ISDIR(inode->i_mode)) {
inode570fs/ext2/namei.cif (!empty_dir (inode)) {
inode574fs/ext2/namei.cif (inode->i_count > 1 && inode->i_nlink <= 2) {
inode579fs/ext2/namei.cinode->i_size = 0;
inode581fs/ext2/namei.cext2_dcache_remove(inode->i_dev, inode->i_ino, ".", 1);
inode582fs/ext2/namei.cext2_dcache_remove(inode->i_dev, inode->i_ino, "..", 2);
inode585fs/ext2/namei.cif (inode->i_nlink != 2)
inode586fs/ext2/namei.cprintk ("empty  directory has nlink!=2 (%d)\n", inode->i_nlink);
inode594fs/ext2/namei.cinode->i_nlink = 0;
inode595fs/ext2/namei.cinode->i_dirt = 1;
inode601fs/ext2/namei.ciput (inode);
inode606fs/ext2/namei.cint ext2_unlink (struct inode * dir, const char * name, int len)
inode609fs/ext2/namei.cstruct inode * inode;
inode617fs/ext2/namei.cinode = NULL;
inode621fs/ext2/namei.cif (!(inode = iget (dir->i_sb, de->inode)))
inode623fs/ext2/namei.cif (de->inode != inode->i_ino) {
inode624fs/ext2/namei.ciput(inode);
inode632fs/ext2/namei.ccurrent->euid != inode->i_uid &&
inode635fs/ext2/namei.cif (S_ISDIR(inode->i_mode))
inode637fs/ext2/namei.cif (!inode->i_nlink) {
inode639fs/ext2/namei.cinode->i_dev, inode->i_ino, inode->i_nlink);
inode640fs/ext2/namei.cinode->i_nlink = 1;
inode651fs/ext2/namei.cinode->i_nlink--;
inode652fs/ext2/namei.cinode->i_dirt = 1;
inode653fs/ext2/namei.cinode->i_ctime = CURRENT_TIME;
inode657fs/ext2/namei.ciput (inode);
inode662fs/ext2/namei.cint ext2_symlink (struct inode * dir, const char * name, int len,
inode666fs/ext2/namei.cstruct inode * inode = NULL;
inode673fs/ext2/namei.cif (!(inode = ext2_new_inode (dir, S_IFLNK))) {
inode677fs/ext2/namei.cinode->i_mode = S_IFLNK | S_IRWXUGO;
inode678fs/ext2/namei.cinode->i_op = &ext2_symlink_inode_operations;
inode679fs/ext2/namei.cfor (l = 0; l < inode->i_sb->s_blocksize - 1 &&
inode686fs/ext2/namei.cname_block = ext2_bread (inode, 0, 1, &err);
inode689fs/ext2/namei.cinode->i_nlink--;
inode690fs/ext2/namei.cinode->i_dirt = 1;
inode691fs/ext2/namei.ciput (inode);
inode696fs/ext2/namei.clink = (char *) inode->u.ext2_i.i_data;
inode702fs/ext2/namei.cwhile (i < inode->i_sb->s_blocksize - 1 && (c = *(symname++)))
inode709fs/ext2/namei.cinode->i_size = i;
inode710fs/ext2/namei.cinode->i_dirt = 1;
inode713fs/ext2/namei.cinode->i_nlink--;
inode714fs/ext2/namei.cinode->i_dirt = 1;
inode715fs/ext2/namei.ciput (inode);
inode722fs/ext2/namei.cinode->i_nlink--;
inode723fs/ext2/namei.cinode->i_dirt = 1;
inode724fs/ext2/namei.ciput (inode);
inode728fs/ext2/namei.cde->inode = inode->i_ino;
inode731fs/ext2/namei.cde->inode);
inode736fs/ext2/namei.ciput (inode);
inode740fs/ext2/namei.cint ext2_link (struct inode * oldinode, struct inode * dir,
inode770fs/ext2/namei.cde->inode = oldinode->i_ino;
inode773fs/ext2/namei.cde->inode);
inode785fs/ext2/namei.cstatic int subdir (struct inode * new_inode, struct inode * old_inode)
inode811fs/ext2/namei.c((struct ext2_dir_entry *) buffer)->rec_len))->inode
inode828fs/ext2/namei.cstatic int do_ext2_rename (struct inode * old_dir, const char * old_name,
inode829fs/ext2/namei.cint old_len, struct inode * new_dir,
inode832fs/ext2/namei.cstruct inode * old_inode, * new_inode;
inode856fs/ext2/namei.cold_inode = iget (old_dir->i_sb, old_de->inode);
inode866fs/ext2/namei.cnew_inode = iget (new_dir->i_sb, new_de->inode);
inode917fs/ext2/namei.cif (new_inode && (new_de->inode != new_inode->i_ino))
inode919fs/ext2/namei.cif (new_de->inode && !new_inode)
inode921fs/ext2/namei.cif (old_de->inode != old_inode->i_ino)
inode924fs/ext2/namei.cnew_de->inode = old_inode->i_ino;
inode929fs/ext2/namei.cnew_de->name_len, new_de->inode);
inode975fs/ext2/namei.cint ext2_rename (struct inode * old_dir, const char * old_name, int old_len,
inode976fs/ext2/namei.cstruct inode * new_dir, const char * new_name, int new_len)
inode23fs/ext2/symlink.cstatic int ext2_readlink (struct inode *, char *, int);
inode24fs/ext2/symlink.cstatic int ext2_follow_link (struct inode *, struct inode *, int, int,
inode25fs/ext2/symlink.cstruct inode **);
inode48fs/ext2/symlink.cstatic int ext2_follow_link(struct inode * dir, struct inode * inode,
inode49fs/ext2/symlink.cint flag, int mode, struct inode ** res_inode)
inode60fs/ext2/symlink.cif (!inode) {
inode64fs/ext2/symlink.cif (!S_ISLNK(inode->i_mode)) {
inode66fs/ext2/symlink.c*res_inode = inode;
inode71fs/ext2/symlink.ciput (inode);
inode74fs/ext2/symlink.cif (inode->i_blocks) {
inode75fs/ext2/symlink.cif (!(bh = ext2_bread (inode, 0, 0, &error))) {
inode77fs/ext2/symlink.ciput (inode);
inode82fs/ext2/symlink.clink = (char *) inode->u.ext2_i.i_data;
inode86fs/ext2/symlink.ciput (inode);
inode92fs/ext2/symlink.cstatic int ext2_readlink (struct inode * inode, char * buffer, int buflen)
inode99fs/ext2/symlink.cif (!S_ISLNK(inode->i_mode)) {
inode100fs/ext2/symlink.ciput (inode);
inode103fs/ext2/symlink.cif (buflen > inode->i_sb->s_blocksize - 1)
inode104fs/ext2/symlink.cbuflen = inode->i_sb->s_blocksize - 1;
inode105fs/ext2/symlink.cif (inode->i_blocks) {
inode106fs/ext2/symlink.cbh = ext2_bread (inode, 0, 0, &err);
inode108fs/ext2/symlink.ciput (inode);
inode114fs/ext2/symlink.clink = (char *) inode->u.ext2_i.i_data;
inode120fs/ext2/symlink.ciput (inode);
inode33fs/ext2/truncate.cstatic int trunc_direct (struct inode * inode)
inode39fs/ext2/truncate.cint blocks = inode->i_sb->s_blocksize / 512;
inode40fs/ext2/truncate.c#define DIRECT_BLOCK ((inode->i_size + inode->i_sb->s_blocksize - 1) / \
inode41fs/ext2/truncate.cinode->i_sb->s_blocksize)
inode46fs/ext2/truncate.cp = inode->u.ext2_i.i_data + i;
inode50fs/ext2/truncate.cbh = get_hash_table (inode->i_dev, tmp, inode->i_sb->s_blocksize);
inode61fs/ext2/truncate.cinode->i_blocks -= blocks;
inode62fs/ext2/truncate.cinode->i_dirt = 1;
inode64fs/ext2/truncate.cext2_free_block (inode->i_sb, tmp);
inode69fs/ext2/truncate.cstatic int trunc_indirect (struct inode * inode, int offset, unsigned long * p)
inode76fs/ext2/truncate.cint addr_per_block = EXT2_ADDR_PER_BLOCK(inode->i_sb);
inode77fs/ext2/truncate.cint blocks = inode->i_sb->s_blocksize / 512;
inode84fs/ext2/truncate.cind_bh = bread (inode->i_dev, tmp, inode->i_sb->s_blocksize);
inode103fs/ext2/truncate.cbh = get_hash_table (inode->i_dev, tmp,
inode104fs/ext2/truncate.cinode->i_sb->s_blocksize);
inode117fs/ext2/truncate.cext2_free_block (inode->i_sb, tmp);
inode118fs/ext2/truncate.cinode->i_blocks -= blocks;
inode119fs/ext2/truncate.cinode->i_dirt = 1;
inode131fs/ext2/truncate.cinode->i_blocks -= blocks;
inode132fs/ext2/truncate.cinode->i_dirt = 1;
inode133fs/ext2/truncate.cext2_free_block (inode->i_sb, tmp);
inode139fs/ext2/truncate.cstatic int trunc_dindirect (struct inode * inode, int offset,
inode146fs/ext2/truncate.cint addr_per_block = EXT2_ADDR_PER_BLOCK(inode->i_sb);
inode147fs/ext2/truncate.cint blocks = inode->i_sb->s_blocksize / 512;
inode154fs/ext2/truncate.cdind_bh = bread (inode->i_dev, tmp, inode->i_sb->s_blocksize);
inode173fs/ext2/truncate.cretry |= trunc_indirect (inode, offset + (i * addr_per_block),
inode187fs/ext2/truncate.cinode->i_blocks -= blocks;
inode188fs/ext2/truncate.cinode->i_dirt = 1;
inode189fs/ext2/truncate.cext2_free_block (inode->i_sb, tmp);
inode195fs/ext2/truncate.cstatic int trunc_tindirect (struct inode * inode)
inode201fs/ext2/truncate.cint addr_per_block = EXT2_ADDR_PER_BLOCK(inode->i_sb);
inode202fs/ext2/truncate.cint blocks = inode->i_sb->s_blocksize / 512;
inode208fs/ext2/truncate.cp = inode->u.ext2_i.i_data + EXT2_TIND_BLOCK;
inode211fs/ext2/truncate.ctind_bh = bread (inode->i_dev, tmp, inode->i_sb->s_blocksize);
inode227fs/ext2/truncate.cretry |= trunc_dindirect(inode, EXT2_NDIR_BLOCKS +
inode244fs/ext2/truncate.cinode->i_blocks -= blocks;
inode245fs/ext2/truncate.cinode->i_dirt = 1;
inode246fs/ext2/truncate.cext2_free_block (inode->i_sb, tmp);
inode252fs/ext2/truncate.cvoid ext2_truncate (struct inode * inode)
inode256fs/ext2/truncate.cif (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
inode257fs/ext2/truncate.cS_ISLNK(inode->i_mode)))
inode260fs/ext2/truncate.cretry = trunc_direct(inode);
inode261fs/ext2/truncate.cretry |= trunc_indirect (inode, EXT2_IND_BLOCK,
inode262fs/ext2/truncate.c(unsigned long *) &inode->u.ext2_i.i_data[EXT2_IND_BLOCK]);
inode263fs/ext2/truncate.cretry |= trunc_dindirect (inode, EXT2_IND_BLOCK +
inode264fs/ext2/truncate.cEXT2_ADDR_PER_BLOCK(inode->i_sb),
inode265fs/ext2/truncate.c(unsigned long *) &inode->u.ext2_i.i_data[EXT2_DIND_BLOCK]);
inode266fs/ext2/truncate.cretry |= trunc_tindirect (inode);
inode272fs/ext2/truncate.cinode->i_mtime = inode->i_ctime = CURRENT_TIME;
inode273fs/ext2/truncate.cinode->i_dirt = 1;
inode281fs/ext2/truncate.cvoid ext2_release (struct inode * inode, struct file * filp)
inode12fs/fifo.cstatic int fifo_open(struct inode * inode,struct file * filp)
inode26fs/fifo.cif (!PIPE_READERS(*inode)++)
inode27fs/fifo.cwake_up(&PIPE_WRITE_WAIT(*inode));
inode28fs/fifo.cif (!(filp->f_flags & O_NONBLOCK) && !PIPE_WRITERS(*inode)) {
inode29fs/fifo.cPIPE_RD_OPENERS(*inode)++;
inode30fs/fifo.cwhile (!PIPE_WRITERS(*inode)) {
inode35fs/fifo.cinterruptible_sleep_on(&PIPE_READ_WAIT(*inode));
inode37fs/fifo.cif (!--PIPE_RD_OPENERS(*inode))
inode38fs/fifo.cwake_up(&PIPE_WRITE_WAIT(*inode));
inode40fs/fifo.cwhile (PIPE_WR_OPENERS(*inode))
inode41fs/fifo.cinterruptible_sleep_on(&PIPE_READ_WAIT(*inode));
inode42fs/fifo.cif (PIPE_WRITERS(*inode))
inode44fs/fifo.cif (retval && !--PIPE_READERS(*inode))
inode45fs/fifo.cwake_up(&PIPE_WRITE_WAIT(*inode));
inode54fs/fifo.cif ((filp->f_flags & O_NONBLOCK) && !PIPE_READERS(*inode)) {
inode59fs/fifo.cif (!PIPE_WRITERS(*inode)++)
inode60fs/fifo.cwake_up(&PIPE_READ_WAIT(*inode));
inode61fs/fifo.cif (!PIPE_READERS(*inode)) {
inode62fs/fifo.cPIPE_WR_OPENERS(*inode)++;
inode63fs/fifo.cwhile (!PIPE_READERS(*inode)) {
inode68fs/fifo.cinterruptible_sleep_on(&PIPE_WRITE_WAIT(*inode));
inode70fs/fifo.cif (!--PIPE_WR_OPENERS(*inode))
inode71fs/fifo.cwake_up(&PIPE_READ_WAIT(*inode));
inode73fs/fifo.cwhile (PIPE_RD_OPENERS(*inode))
inode74fs/fifo.cinterruptible_sleep_on(&PIPE_WRITE_WAIT(*inode));
inode75fs/fifo.cif (retval && !--PIPE_WRITERS(*inode))
inode76fs/fifo.cwake_up(&PIPE_READ_WAIT(*inode));
inode87fs/fifo.cif (!PIPE_READERS(*inode)++)
inode88fs/fifo.cwake_up(&PIPE_WRITE_WAIT(*inode));
inode89fs/fifo.cwhile (PIPE_WR_OPENERS(*inode))
inode90fs/fifo.cinterruptible_sleep_on(&PIPE_READ_WAIT(*inode));
inode91fs/fifo.cif (!PIPE_WRITERS(*inode)++)
inode92fs/fifo.cwake_up(&PIPE_READ_WAIT(*inode));
inode93fs/fifo.cwhile (PIPE_RD_OPENERS(*inode))
inode94fs/fifo.cinterruptible_sleep_on(&PIPE_WRITE_WAIT(*inode));
inode100fs/fifo.cif (retval || PIPE_BASE(*inode))
inode103fs/fifo.cif (PIPE_BASE(*inode)) {
inode109fs/fifo.cPIPE_HEAD(*inode) = PIPE_TAIL(*inode) = 0;
inode110fs/fifo.cPIPE_BASE(*inode) = (char *) page;
inode150fs/fifo.cvoid init_fifo(struct inode * inode)
inode152fs/fifo.cinode->i_op = &fifo_inode_operations;
inode153fs/fifo.cinode->i_pipe = 1;
inode154fs/fifo.cPIPE_BASE(*inode) = NULL;
inode155fs/fifo.cPIPE_HEAD(*inode) = PIPE_TAIL(*inode) = 0;
inode156fs/fifo.cPIPE_RD_OPENERS(*inode) = PIPE_WR_OPENERS(*inode) = 0;
inode157fs/fifo.cPIPE_READ_WAIT(*inode) = PIPE_WRITE_WAIT(*inode) = NULL;
inode158fs/fifo.cPIPE_READERS(*inode) = PIPE_WRITERS(*inode) = 0;
inode15fs/inode.cstatic struct inode * hash_table[NR_IHASH];
inode16fs/inode.cstatic struct inode * first_inode;
inode25fs/inode.cstatic inline struct inode ** const hash(dev_t dev, int i)
inode30fs/inode.cstatic void insert_inode_free(struct inode *inode)
inode32fs/inode.cinode->i_next = first_inode;
inode33fs/inode.cinode->i_prev = first_inode->i_prev;
inode34fs/inode.cinode->i_next->i_prev = inode;
inode35fs/inode.cinode->i_prev->i_next = inode;
inode36fs/inode.cfirst_inode = inode;
inode39fs/inode.cstatic void remove_inode_free(struct inode *inode)
inode41fs/inode.cif (first_inode == inode)
inode43fs/inode.cif (inode->i_next)
inode44fs/inode.cinode->i_next->i_prev = inode->i_prev;
inode45fs/inode.cif (inode->i_prev)
inode46fs/inode.cinode->i_prev->i_next = inode->i_next;
inode47fs/inode.cinode->i_next = inode->i_prev = NULL;
inode50fs/inode.cvoid insert_inode_hash(struct inode *inode)
inode52fs/inode.cstruct inode **h;
inode53fs/inode.ch = hash(inode->i_dev, inode->i_ino);
inode55fs/inode.cinode->i_hash_next = *h;
inode56fs/inode.cinode->i_hash_prev = NULL;
inode57fs/inode.cif (inode->i_hash_next)
inode58fs/inode.cinode->i_hash_next->i_hash_prev = inode;
inode59fs/inode.c*h = inode;
inode62fs/inode.cstatic void remove_inode_hash(struct inode *inode)
inode64fs/inode.cstruct inode **h;
inode65fs/inode.ch = hash(inode->i_dev, inode->i_ino);
inode67fs/inode.cif (*h == inode)
inode68fs/inode.c*h = inode->i_hash_next;
inode69fs/inode.cif (inode->i_hash_next)
inode70fs/inode.cinode->i_hash_next->i_hash_prev = inode->i_hash_prev;
inode71fs/inode.cif (inode->i_hash_prev)
inode72fs/inode.cinode->i_hash_prev->i_hash_next = inode->i_hash_next;
inode73fs/inode.cinode->i_hash_prev = inode->i_hash_next = NULL;
inode76fs/inode.cstatic void put_last_free(struct inode *inode)
inode78fs/inode.cremove_inode_free(inode);
inode79fs/inode.cinode->i_prev = first_inode->i_prev;
inode80fs/inode.cinode->i_prev->i_next = inode;
inode81fs/inode.cinode->i_next = first_inode;
inode82fs/inode.cinode->i_next->i_prev = inode;
inode87fs/inode.cstruct inode * inode;
inode90fs/inode.cif(!(inode = (struct inode*) get_free_page(GFP_KERNEL)))
inode93fs/inode.ci=PAGE_SIZE / sizeof(struct inode);
inode98fs/inode.cinode->i_next = inode->i_prev = first_inode = inode++, i--;
inode101fs/inode.cinsert_inode_free(inode++);
inode111fs/inode.cstatic void __wait_on_inode(struct inode *);
inode113fs/inode.cstatic inline void wait_on_inode(struct inode * inode)
inode115fs/inode.cif (inode->i_lock)
inode116fs/inode.c__wait_on_inode(inode);
inode119fs/inode.cstatic inline void lock_inode(struct inode * inode)
inode121fs/inode.cwait_on_inode(inode);
inode122fs/inode.cinode->i_lock = 1;
inode125fs/inode.cstatic inline void unlock_inode(struct inode * inode)
inode127fs/inode.cinode->i_lock = 0;
inode128fs/inode.cwake_up(&inode->i_wait);
inode143fs/inode.cvoid clear_inode(struct inode * inode)
inode147fs/inode.cwait_on_inode(inode);
inode148fs/inode.cremove_inode_hash(inode);
inode149fs/inode.cremove_inode_free(inode);
inode150fs/inode.cwait = ((volatile struct inode *) inode)->i_wait;
inode151fs/inode.cif (inode->i_count)
inode153fs/inode.cmemset(inode,0,sizeof(*inode));
inode154fs/inode.c((volatile struct inode *) inode)->i_wait = wait;
inode155fs/inode.cinsert_inode_free(inode);
inode160fs/inode.cstruct inode * inode, * next;
inode165fs/inode.cinode = next;
inode166fs/inode.cnext = inode->i_next;  /* clear_inode() changes the queues.. */
inode167fs/inode.cif (inode->i_dev != dev)
inode169fs/inode.cif (inode->i_count || inode->i_dirt || inode->i_lock)
inode171fs/inode.cclear_inode(inode);
inode176fs/inode.cint fs_may_umount(dev_t dev, struct inode * mount_root)
inode178fs/inode.cstruct inode * inode;
inode181fs/inode.cinode = first_inode;
inode182fs/inode.cfor (i=0 ; i < nr_inodes ; i++, inode = inode->i_next) {
inode183fs/inode.cif (inode->i_dev != dev || !inode->i_count)
inode185fs/inode.cif (inode == mount_root && inode->i_count == 1)
inode208fs/inode.cstatic void write_inode(struct inode * inode)
inode210fs/inode.cif (!inode->i_dirt)
inode212fs/inode.cwait_on_inode(inode);
inode213fs/inode.cif (!inode->i_dirt)
inode215fs/inode.cif (!inode->i_sb || !inode->i_sb->s_op || !inode->i_sb->s_op->write_inode) {
inode216fs/inode.cinode->i_dirt = 0;
inode219fs/inode.cinode->i_lock = 1;  
inode220fs/inode.cinode->i_sb->s_op->write_inode(inode);
inode221fs/inode.cunlock_inode(inode);
inode224fs/inode.cstatic void read_inode(struct inode * inode)
inode226fs/inode.clock_inode(inode);
inode227fs/inode.cif (inode->i_sb && inode->i_sb->s_op && inode->i_sb->s_op->read_inode)
inode228fs/inode.cinode->i_sb->s_op->read_inode(inode);
inode229fs/inode.cunlock_inode(inode);
inode240fs/inode.cint notify_change(int flags, struct inode * inode)
inode242fs/inode.cif (inode->i_sb && inode->i_sb->s_op  &&
inode243fs/inode.cinode->i_sb->s_op->notify_change)
inode244fs/inode.creturn inode->i_sb->s_op->notify_change(flags, inode);
inode258fs/inode.cint bmap(struct inode * inode, int block)
inode260fs/inode.cif (inode->i_op && inode->i_op->bmap)
inode261fs/inode.creturn inode->i_op->bmap(inode,block);
inode267fs/inode.cstruct inode * inode, * next;
inode272fs/inode.cinode = next;
inode273fs/inode.cnext = inode->i_next;    /* clear_inode() changes the queues.. */
inode274fs/inode.cif (inode->i_dev != dev)
inode276fs/inode.cif (inode->i_count || inode->i_dirt || inode->i_lock) {
inode280fs/inode.cclear_inode(inode);
inode287fs/inode.cstruct inode * inode;
inode289fs/inode.cinode = first_inode;
inode290fs/inode.cfor(i = 0; i < nr_inodes*2; i++, inode = inode->i_next) {
inode291fs/inode.cif (dev && inode->i_dev != dev)
inode293fs/inode.cwait_on_inode(inode);
inode294fs/inode.cif (inode->i_dirt)
inode295fs/inode.cwrite_inode(inode);
inode299fs/inode.cvoid iput(struct inode * inode)
inode301fs/inode.cif (!inode)
inode303fs/inode.cwait_on_inode(inode);
inode304fs/inode.cif (!inode->i_count) {
inode307fs/inode.cMAJOR(inode->i_rdev), MINOR(inode->i_rdev),
inode308fs/inode.cinode->i_ino, inode->i_mode);
inode311fs/inode.cif (inode->i_pipe) {
inode312fs/inode.cwake_up(&PIPE_READ_WAIT(*inode));
inode313fs/inode.cwake_up(&PIPE_WRITE_WAIT(*inode));
inode316fs/inode.cif (inode->i_count>1) {
inode317fs/inode.cinode->i_count--;
inode321fs/inode.cif (inode->i_pipe) {
inode322fs/inode.cunsigned long page = (unsigned long) PIPE_BASE(*inode);
inode323fs/inode.cPIPE_BASE(*inode) = NULL;
inode326fs/inode.cif (inode->i_sb && inode->i_sb->s_op && inode->i_sb->s_op->put_inode) {
inode327fs/inode.cinode->i_sb->s_op->put_inode(inode);
inode328fs/inode.cif (!inode->i_nlink)
inode331fs/inode.cif (inode->i_dirt) {
inode332fs/inode.cwrite_inode(inode);  /* we can sleep - so do again */
inode333fs/inode.cwait_on_inode(inode);
inode336fs/inode.cinode->i_count--;
inode341fs/inode.cstruct inode * get_empty_inode(void)
inode343fs/inode.cstruct inode * inode, * best;
inode349fs/inode.cinode = first_inode;
inode351fs/inode.cfor (i = 0; i<nr_inodes; inode = inode->i_next, i++) {
inode352fs/inode.cif (!inode->i_count) {
inode354fs/inode.cbest = inode;
inode355fs/inode.cif (!inode->i_dirt && !inode->i_lock) {
inode356fs/inode.cbest = inode;
inode366fs/inode.cinode = best;
inode367fs/inode.cif (!inode) {
inode372fs/inode.cif (inode->i_lock) {
inode373fs/inode.cwait_on_inode(inode);
inode376fs/inode.cif (inode->i_dirt) {
inode377fs/inode.cwrite_inode(inode);
inode380fs/inode.cif (inode->i_count)
inode382fs/inode.cclear_inode(inode);
inode383fs/inode.cinode->i_count = 1;
inode384fs/inode.cinode->i_nlink = 1;
inode390fs/inode.creturn inode;
inode393fs/inode.cstruct inode * get_pipe_inode(void)
inode395fs/inode.cstruct inode * inode;
inode398fs/inode.cif (!(inode = get_empty_inode()))
inode400fs/inode.cif (!(PIPE_BASE(*inode) = (char*) __get_free_page(GFP_USER))) {
inode401fs/inode.ciput(inode);
inode404fs/inode.cinode->i_op = &pipe_inode_operations;
inode405fs/inode.cinode->i_count = 2;  /* sum of readers/writers */
inode406fs/inode.cPIPE_READ_WAIT(*inode) = PIPE_WRITE_WAIT(*inode) = NULL;
inode407fs/inode.cPIPE_HEAD(*inode) = PIPE_TAIL(*inode) = 0;
inode408fs/inode.cPIPE_RD_OPENERS(*inode) = PIPE_WR_OPENERS(*inode) = 0;
inode409fs/inode.cPIPE_READERS(*inode) = PIPE_WRITERS(*inode) = 1;
inode410fs/inode.cinode->i_pipe = 1;
inode411fs/inode.cinode->i_mode |= S_IFIFO | S_IRUSR | S_IWUSR;
inode412fs/inode.cinode->i_uid = current->euid;
inode413fs/inode.cinode->i_gid = current->egid;
inode414fs/inode.cinode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
inode415fs/inode.creturn inode;
inode418fs/inode.cstruct inode * iget(struct super_block * sb,int nr)
inode420fs/inode.cstruct inode * inode, * empty;
inode426fs/inode.cinode = *(hash(sb->s_dev,nr));
inode427fs/inode.cwhile (inode) {
inode428fs/inode.cif (inode->i_dev != sb->s_dev || inode->i_ino != nr) {
inode429fs/inode.cinode = inode->i_hash_next;
inode432fs/inode.cwait_on_inode(inode);
inode433fs/inode.cif (inode->i_dev != sb->s_dev || inode->i_ino != nr)
inode435fs/inode.cif (!inode->i_count)
inode437fs/inode.cinode->i_count++;
inode438fs/inode.cif (inode->i_mount) {
inode442fs/inode.cif (super_blocks[i].s_covered==inode)
inode448fs/inode.creturn inode;
inode450fs/inode.ciput(inode);
inode451fs/inode.cif (!(inode = super_blocks[i].s_mounted))
inode453fs/inode.cMAJOR(inode->i_dev), MINOR(inode->i_dev));
inode455fs/inode.cif (!inode->i_count)
inode457fs/inode.cinode->i_count++;
inode458fs/inode.cwait_on_inode(inode);
inode463fs/inode.creturn inode;
inode467fs/inode.cinode = empty;
inode468fs/inode.cinode->i_sb = sb;
inode469fs/inode.cinode->i_dev = sb->s_dev;
inode470fs/inode.cinode->i_ino = nr;
inode471fs/inode.cinode->i_flags = sb->s_flags;
inode472fs/inode.cput_last_free(inode);
inode473fs/inode.cinsert_inode_hash(inode);
inode474fs/inode.cread_inode(inode);
inode475fs/inode.creturn inode;
inode484fs/inode.cstatic void __wait_on_inode(struct inode * inode)
inode488fs/inode.cadd_wait_queue(&inode->i_wait, &wait);
inode491fs/inode.cif (inode->i_lock) {
inode495fs/inode.cremove_wait_queue(&inode->i_wait, &wait);
inode22fs/isofs/dir.cstatic int isofs_readdir(struct inode *, struct file *, struct dirent *, int);
inode63fs/isofs/dir.cstatic int isofs_readdir(struct inode * inode, struct file * filp,
inode76fs/isofs/dir.cif (!inode || !S_ISDIR(inode->i_mode))
inode79fs/isofs/dir.coffset = filp->f_pos & (ISOFS_BUFFER_SIZE(inode) - 1);
inode80fs/isofs/dir.cblock = isofs_bmap(inode,(filp->f_pos)>>ISOFS_BUFFER_BITS(inode));
inode81fs/isofs/dir.cif (!block || !(bh = bread(inode->i_dev,block,ISOFS_BUFFER_SIZE(inode))))
inode84fs/isofs/dir.cwhile (filp->f_pos < inode->i_size) {
inode89fs/isofs/dir.cinode_number = (block << ISOFS_BUFFER_BITS(inode))+(offset & (ISOFS_BUFFER_SIZE(inode) - 1));
inode98fs/isofs/dir.cblock = isofs_bmap(inode,(filp->f_pos)>>ISOFS_BUFFER_BITS(inode));
inode99fs/isofs/dir.cif (!block || !(bh = bread(inode->i_dev,block,ISOFS_BUFFER_SIZE(inode))))
inode112fs/isofs/dir.cif (offset >=  ISOFS_BUFFER_SIZE(inode)) {
inode114fs/isofs/dir.cmemcpy(cpnt, bh->b_data, ISOFS_BUFFER_SIZE(inode));
inode117fs/isofs/dir.coffset = filp->f_pos & (ISOFS_BUFFER_SIZE(inode) - 1);
inode118fs/isofs/dir.cblock = isofs_bmap(inode,(filp->f_pos)>> ISOFS_BUFFER_BITS(inode));
inode119fs/isofs/dir.cif (!block || !(bh = bread(inode->i_dev,block,ISOFS_BUFFER_SIZE(inode))))
inode121fs/isofs/dir.cmemcpy(cpnt+ISOFS_BUFFER_SIZE(inode), bh->b_data, ISOFS_BUFFER_SIZE(inode));
inode130fs/isofs/dir.cinode_number = inode->i_ino;
inode141fs/isofs/dir.cif((inode->i_sb->u.isofs_sb.s_firstdatazone << ISOFS_BUFFER_BITS(inode)) != inode->i_ino)
inode142fs/isofs/dir.cinode_number = inode->u.isofs_i.i_backlink;
inode144fs/isofs/dir.cinode_number = inode->i_ino;
inode149fs/isofs/dir.cisofs_lookup_grandparent(inode,
inode150fs/isofs/dir.cfind_rock_ridge_relocation(de, inode));
inode165fs/isofs/dir.crrflag = get_rock_ridge_filename(de, &dpnt, &dlen, inode);
inode177fs/isofs/dir.cif(inode->i_sb->u.isofs_sb.s_mapping == 'n')
inode198fs/isofs/dir.ccache.dir = inode->i_ino;
inode199fs/isofs/dir.ccache.dev = inode->i_dev;
inode32fs/isofs/file.cstatic int isofs_file_read(struct inode *, struct file *, char *, int);
inode89fs/isofs/file.cstatic void isofs_determine_filetype(struct inode * inode)
inode96fs/isofs/file.cblock = isofs_bmap(inode,0);
inode97fs/isofs/file.cif (block && (bh = bread(inode->i_dev,block, ISOFS_BUFFER_SIZE(inode)))) {
inode100fs/isofs/file.cfor(i=0;i<(inode->i_size < ISOFS_BUFFER_SIZE(inode) ? inode->i_size : ISOFS_BUFFER_SIZE(inode));
inode110fs/isofs/file.cinode->u.isofs_i.i_file_format = result;
inode114fs/isofs/file.cstatic int isofs_file_read(struct inode * inode, struct file * filp, char * buf, int count)
inode124fs/isofs/file.cif (!inode) {
inode128fs/isofs/file.cif (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode))) {
inode129fs/isofs/file.cprintk("isofs_file_read: mode = %07o\n",inode->i_mode);
inode132fs/isofs/file.cif (inode->u.isofs_i.i_file_format == ISOFS_FILE_UNKNOWN)
inode133fs/isofs/file.cisofs_determine_filetype(inode);
inode134fs/isofs/file.cif (filp->f_pos > inode->i_size)
inode137fs/isofs/file.cleft = inode->i_size - filp->f_pos;
inode143fs/isofs/file.cblock = filp->f_pos >> ISOFS_BUFFER_BITS(inode);
inode144fs/isofs/file.coffset = filp->f_pos & (ISOFS_BUFFER_SIZE(inode)-1);
inode145fs/isofs/file.cblocks = (left + offset + ISOFS_BUFFER_SIZE(inode) - 1) / ISOFS_BUFFER_SIZE(inode);
inode148fs/isofs/file.cra_blocks = read_ahead[MAJOR(inode->i_dev)] / (BLOCK_SIZE >> 9);
inode149fs/isofs/file.cmax_block = (inode->i_size + BLOCK_SIZE - 1)/BLOCK_SIZE;
inode167fs/isofs/file.c*bhb = getblk(inode->i_dev,isofs_bmap(inode, block++), ISOFS_BUFFER_SIZE(inode));
inode193fs/isofs/file.c*bhb = getblk(inode->i_dev,isofs_bmap(inode, block++), ISOFS_BUFFER_SIZE(inode));
inode224fs/isofs/file.cif (left < ISOFS_BUFFER_SIZE(inode) - offset)
inode227fs/isofs/file.cchars = ISOFS_BUFFER_SIZE(inode) - offset;
inode232fs/isofs/file.cif (inode->u.isofs_i.i_file_format == ISOFS_FILE_TEXT ||
inode233fs/isofs/file.cinode->u.isofs_i.i_file_format == ISOFS_FILE_TEXT_M)
inode235fs/isofs/file.cchars, inode->u.isofs_i.i_file_format);
inode307fs/isofs/inode.cint isofs_bmap(struct inode * inode,int block)
inode314fs/isofs/inode.creturn inode->u.isofs_i.i_first_extent + block;
inode317fs/isofs/inode.cvoid isofs_read_inode(struct inode * inode)
inode327fs/isofs/inode.cblock = inode->i_ino >> ISOFS_BUFFER_BITS(inode);
inode328fs/isofs/inode.cif (!(bh=bread(inode->i_dev,block, ISOFS_BUFFER_SIZE(inode))))
inode331fs/isofs/inode.cpnt = ((unsigned char *) bh->b_data) + (inode->i_ino & (ISOFS_BUFFER_SIZE(inode) - 1));
inode334fs/isofs/inode.chigh_sierra = inode->i_sb->u.isofs_sb.s_high_sierra;
inode337fs/isofs/inode.cif ((inode->i_ino & (ISOFS_BUFFER_SIZE(inode) - 1)) + *pnt > ISOFS_BUFFER_SIZE(inode)){
inode339fs/isofs/inode.cmemcpy(cpnt, bh->b_data, ISOFS_BUFFER_SIZE(inode));
inode341fs/isofs/inode.cif (!(bh = bread(inode->i_dev,++block, ISOFS_BUFFER_SIZE(inode))))
inode343fs/isofs/inode.cmemcpy(cpnt+ISOFS_BUFFER_SIZE(inode), bh->b_data, ISOFS_BUFFER_SIZE(inode));
inode344fs/isofs/inode.cpnt = ((unsigned char *) cpnt) + (inode->i_ino & (ISOFS_BUFFER_SIZE(inode) - 1));
inode348fs/isofs/inode.cinode->i_mode = S_IRUGO; /* Everybody gets to read the file. */
inode349fs/isofs/inode.cinode->i_nlink = 1;
inode352fs/isofs/inode.cinode->i_mode = S_IRUGO | S_IXUGO | S_IFDIR;
inode353fs/isofs/inode.cinode->i_nlink = 2; /* There are always at least 2.  It is
inode356fs/isofs/inode.cinode->i_mode = S_IRUGO; /* Everybody gets to read the file. */
inode357fs/isofs/inode.cinode->i_nlink = 1;
inode358fs/isofs/inode.cinode->i_mode |= S_IFREG;
inode364fs/isofs/inode.cinode->i_mode |= S_IXUGO; /* execute permission */
inode366fs/isofs/inode.cinode->i_uid = 0;
inode367fs/isofs/inode.cinode->i_gid = 0;
inode368fs/isofs/inode.cinode->i_size = isonum_733 (raw_inode->size);
inode372fs/isofs/inode.cif((inode->i_size < 0 || inode->i_size > 700000000) &&
inode373fs/isofs/inode.cinode->i_sb->u.isofs_sb.s_cruft == 'n') {
inode375fs/isofs/inode.cinode->i_sb->u.isofs_sb.s_cruft = 'y';
inode382fs/isofs/inode.cif(inode->i_sb->u.isofs_sb.s_cruft == 'y' && 
inode383fs/isofs/inode.cinode->i_size & 0xff000000){
inode385fs/isofs/inode.cinode->i_size &= 0x00ffffff;
inode394fs/isofs/inode.cinode->i_size = 0;
inode402fs/isofs/inode.cinode->i_ino);
inode409fs/isofs/inode.cprintk("File unit size != 0 for ISO file.(%d)\n",inode->i_ino);
inode416fs/isofs/inode.cinode->i_ino, raw_inode->flags[-high_sierra]);
inode420fs/isofs/inode.cprintk("Get inode %d: %d %d: %d\n",inode->i_ino, block, 
inode421fs/isofs/inode.c((int)pnt) & 0x3ff, inode->i_size);
inode424fs/isofs/inode.cinode->i_mtime = inode->i_atime = inode->i_ctime = 
inode427fs/isofs/inode.cinode->u.isofs_i.i_first_extent = isonum_733 (raw_inode->extent) << 
inode428fs/isofs/inode.c(ISOFS_BLOCK_BITS - ISOFS_BUFFER_BITS(inode));
inode430fs/isofs/inode.cinode->u.isofs_i.i_backlink = 0xffffffff; /* Will be used for previous directory */
inode431fs/isofs/inode.cswitch (inode->i_sb->u.isofs_sb.s_conversion){
inode433fs/isofs/inode.cinode->u.isofs_i.i_file_format = ISOFS_FILE_UNKNOWN; /* File type */
inode436fs/isofs/inode.cinode->u.isofs_i.i_file_format = ISOFS_FILE_BINARY; /* File type */
inode439fs/isofs/inode.cinode->u.isofs_i.i_file_format = ISOFS_FILE_TEXT; /* File type */
inode442fs/isofs/inode.cinode->u.isofs_i.i_file_format = ISOFS_FILE_TEXT_M; /* File type */
inode451fs/isofs/inode.cparse_rock_ridge_inode(raw_inode, inode);
inode454fs/isofs/inode.cprintk("Inode: %x extent: %x\n",inode->i_ino, inode->u.isofs_i.i_first_extent);
inode463fs/isofs/inode.cinode->i_op = NULL;
inode464fs/isofs/inode.cif (S_ISREG(inode->i_mode))
inode465fs/isofs/inode.cinode->i_op = &isofs_file_inode_operations;
inode466fs/isofs/inode.celse if (S_ISDIR(inode->i_mode))
inode467fs/isofs/inode.cinode->i_op = &isofs_dir_inode_operations;
inode468fs/isofs/inode.celse if (S_ISLNK(inode->i_mode))
inode469fs/isofs/inode.cinode->i_op = &isofs_symlink_inode_operations;
inode470fs/isofs/inode.celse if (S_ISCHR(inode->i_mode))
inode471fs/isofs/inode.cinode->i_op = &chrdev_inode_operations;
inode472fs/isofs/inode.celse if (S_ISBLK(inode->i_mode))
inode473fs/isofs/inode.cinode->i_op = &blkdev_inode_operations;
inode474fs/isofs/inode.celse if (S_ISFIFO(inode->i_mode))
inode475fs/isofs/inode.cinit_fifo(inode);
inode497fs/isofs/inode.cint isofs_lookup_grandparent(struct inode * parent, int extent) {
inode64fs/isofs/namei.cstatic struct buffer_head * isofs_find_entry(struct inode * dir,
inode197fs/isofs/namei.cint isofs_lookup(struct inode * dir,const char * name, int len,
inode198fs/isofs/namei.cstruct inode ** result)
inode83fs/isofs/rock.cstruct inode * inode) {
inode98fs/isofs/rock.cif (!inode->i_sb->u.isofs_sb.s_rock) return retval;
inode148fs/isofs/rock.cMAYBE_CONTINUE(repeat, inode);
inode156fs/isofs/rock.cchar ** name, int * namlen, struct inode * inode)
inode164fs/isofs/rock.cif (!inode->i_sb->u.isofs_sb.s_rock) return 0;
inode215fs/isofs/rock.cprintk("RR: RE (%x)\n", inode->i_ino);
inode225fs/isofs/rock.cMAYBE_CONTINUE(repeat,inode);
inode239fs/isofs/rock.cstruct inode * inode){
inode244fs/isofs/rock.cif (!inode->i_sb->u.isofs_sb.s_rock) return 0;
inode250fs/isofs/rock.cstruct inode * reloc;
inode279fs/isofs/rock.cinode->i_mode  = isonum_733(rr->u.PX.mode);
inode280fs/isofs/rock.cinode->i_nlink = isonum_733(rr->u.PX.n_links);
inode281fs/isofs/rock.cinode->i_uid   = isonum_733(rr->u.PX.uid);
inode282fs/isofs/rock.cinode->i_gid   = isonum_733(rr->u.PX.gid);
inode288fs/isofs/rock.cinode->i_rdev = ((high << 8) | (low & 0xff)) & 0xffff;
inode293fs/isofs/rock.cif(rr->u.TF.flags & TF_CREATE) inode->i_ctime = iso_date(rr->u.TF.times[cnt++].time, 0);
inode294fs/isofs/rock.cif(rr->u.TF.flags & TF_MODIFY) inode->i_mtime = iso_date(rr->u.TF.times[cnt++].time, 0);
inode295fs/isofs/rock.cif(rr->u.TF.flags & TF_ACCESS) inode->i_atime = iso_date(rr->u.TF.times[cnt++].time, 0);
inode305fs/isofs/rock.cinode->i_size += slp->len;
inode308fs/isofs/rock.cinode->i_size += 1;
inode311fs/isofs/rock.cinode->i_size += 2;
inode314fs/isofs/rock.cinode->i_size += 1;
inode323fs/isofs/rock.cinode->i_size += 1;
inode332fs/isofs/rock.cprintk("RR CL (%x)\n",inode->i_ino);
inode334fs/isofs/rock.cinode->u.isofs_i.i_first_extent = isonum_733(rr->u.CL.location) <<
inode335fs/isofs/rock.c(ISOFS_BLOCK_BITS - ISOFS_BUFFER_BITS(inode));
inode336fs/isofs/rock.creloc = iget(inode->i_sb, inode->u.isofs_i.i_first_extent << ISOFS_BUFFER_BITS(inode));
inode337fs/isofs/rock.cinode->i_mode = reloc->i_mode;
inode338fs/isofs/rock.cinode->i_nlink = reloc->i_nlink;
inode339fs/isofs/rock.cinode->i_uid = reloc->i_uid;
inode340fs/isofs/rock.cinode->i_gid = reloc->i_gid;
inode341fs/isofs/rock.cinode->i_rdev = reloc->i_rdev;
inode342fs/isofs/rock.cinode->i_size = reloc->i_size;
inode343fs/isofs/rock.cinode->i_atime = reloc->i_atime;
inode344fs/isofs/rock.cinode->i_ctime = reloc->i_ctime;
inode345fs/isofs/rock.cinode->i_mtime = reloc->i_mtime;
inode353fs/isofs/rock.cMAYBE_CONTINUE(repeat,inode);
inode364fs/isofs/rock.cchar * get_rock_ridge_symlink(struct inode * inode)
inode378fs/isofs/rock.cif (!inode->i_sb->u.isofs_sb.s_rock)
inode383fs/isofs/rock.cblock = inode->i_ino >> ISOFS_BUFFER_BITS(inode);
inode384fs/isofs/rock.cif (!(bh=bread(inode->i_dev,block, ISOFS_BUFFER_SIZE(inode))))
inode387fs/isofs/rock.cpnt = ((unsigned char *) bh->b_data) + (inode->i_ino & (ISOFS_BUFFER_SIZE(inode) - 1));
inode391fs/isofs/rock.cif ((inode->i_ino & (ISOFS_BUFFER_SIZE(inode) - 1)) + *pnt > ISOFS_BUFFER_SIZE(inode)){
inode393fs/isofs/rock.cmemcpy(cpnt, bh->b_data, ISOFS_BUFFER_SIZE(inode));
inode395fs/isofs/rock.cif (!(bh = bread(inode->i_dev,++block, ISOFS_BUFFER_SIZE(inode))))
inode397fs/isofs/rock.cmemcpy(cpnt+ISOFS_BUFFER_SIZE(inode), bh->b_data, ISOFS_BUFFER_SIZE(inode));
inode398fs/isofs/rock.cpnt = ((unsigned char *) cpnt) + (inode->i_ino & (ISOFS_BUFFER_SIZE(inode) - 1));
inode430fs/isofs/rock.crpnt = (char *) kmalloc (inode->i_size +1, GFP_KERNEL);
inode461fs/isofs/rock.cMAYBE_CONTINUE(repeat,inode);
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)
inode54fs/isofs/symlink.cif (!inode) {
inode59fs/isofs/symlink.cif (!S_ISLNK(inode->i_mode)) {
inode61fs/isofs/symlink.c*res_inode = inode;
inode65fs/isofs/symlink.c!(pnt = get_rock_ridge_symlink(inode))) {
inode67fs/isofs/symlink.ciput(inode);
inode71fs/isofs/symlink.ciput(inode);
inode79fs/isofs/symlink.cstatic int isofs_readlink(struct inode * inode, char * buffer, int buflen)
inode85fs/isofs/symlink.cif (!S_ISLNK(inode->i_mode)) {
inode86fs/isofs/symlink.ciput(inode);
inode92fs/isofs/symlink.cpnt = get_rock_ridge_symlink(inode);
inode94fs/isofs/symlink.ciput(inode);
inode143fs/minix/bitmap.cvoid minix_free_inode(struct inode * inode)
inode148fs/minix/bitmap.cif (!inode)
inode150fs/minix/bitmap.cif (!inode->i_dev) {
inode154fs/minix/bitmap.cif (inode->i_count != 1) {
inode155fs/minix/bitmap.cprintk("free_inode: inode has count=%d\n",inode->i_count);
inode158fs/minix/bitmap.cif (inode->i_nlink) {
inode159fs/minix/bitmap.cprintk("free_inode: inode has nlink=%d\n",inode->i_nlink);
inode162fs/minix/bitmap.cif (!inode->i_sb) {
inode166fs/minix/bitmap.cif (inode->i_ino < 1 || inode->i_ino >= inode->i_sb->u.minix_sb.s_ninodes) {
inode170fs/minix/bitmap.cino = inode->i_ino;
inode171fs/minix/bitmap.cif (!(bh=inode->i_sb->u.minix_sb.s_imap[ino >> 13])) {
inode175fs/minix/bitmap.cclear_inode(inode);
inode181fs/minix/bitmap.cstruct inode * minix_new_inode(const struct inode * dir)
inode184fs/minix/bitmap.cstruct inode * inode;
inode188fs/minix/bitmap.cif (!dir || !(inode = get_empty_inode()))
inode191fs/minix/bitmap.cinode->i_sb = sb;
inode192fs/minix/bitmap.cinode->i_flags = inode->i_sb->s_flags;
inode195fs/minix/bitmap.cif ((bh = inode->i_sb->u.minix_sb.s_imap[i]) != NULL)
inode199fs/minix/bitmap.ciput(inode);
inode204fs/minix/bitmap.ciput(inode);
inode209fs/minix/bitmap.cif (!j || j >= inode->i_sb->u.minix_sb.s_ninodes) {
inode210fs/minix/bitmap.ciput(inode);
inode213fs/minix/bitmap.cinode->i_count = 1;
inode214fs/minix/bitmap.cinode->i_nlink = 1;
inode215fs/minix/bitmap.cinode->i_dev = sb->s_dev;
inode216fs/minix/bitmap.cinode->i_uid = current->euid;
inode217fs/minix/bitmap.cinode->i_gid = (dir->i_mode & S_ISGID) ? dir->i_gid : current->egid;
inode218fs/minix/bitmap.cinode->i_dirt = 1;
inode219fs/minix/bitmap.cinode->i_ino = j;
inode220fs/minix/bitmap.cinode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
inode221fs/minix/bitmap.cinode->i_op = NULL;
inode222fs/minix/bitmap.cinode->i_blocks = inode->i_blksize = 0;
inode223fs/minix/bitmap.cinsert_inode_hash(inode);
inode224fs/minix/bitmap.creturn inode;
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);
inode57fs/minix/dir.cstatic int minix_readdir(struct inode * inode, struct file * filp,
inode66fs/minix/dir.cif (!inode || !inode->i_sb || !S_ISDIR(inode->i_mode))
inode68fs/minix/dir.cinfo = &inode->i_sb->u.minix_sb;
inode71fs/minix/dir.cwhile (filp->f_pos < inode->i_size) {
inode73fs/minix/dir.cbh = minix_bread(inode,(filp->f_pos)>>BLOCK_SIZE_BITS,0);
inode78fs/minix/dir.cwhile (offset < 1024 && filp->f_pos < inode->i_size) {
inode82fs/minix/dir.cif (de->inode) {
inode89fs/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);
inode66fs/minix/file.cstatic int minix_file_read(struct inode * inode, struct file * filp, char * buf, int count)
inode76fs/minix/file.cif (!inode) {
inode80fs/minix/file.cif (!S_ISREG(inode->i_mode)) {
inode81fs/minix/file.cprintk("minix_file_read: mode = %07o\n",inode->i_mode);
inode85fs/minix/file.csize = inode->i_size;
inode101fs/minix/file.cblocks += read_ahead[MAJOR(inode->i_dev)] / (BLOCK_SIZE >> 9);
inode121fs/minix/file.c*bhb = minix_getblk(inode, block++, 0);
inode180fs/minix/file.cif (!IS_RDONLY(inode)) {
inode181fs/minix/file.cinode->i_atime = CURRENT_TIME;
inode182fs/minix/file.cinode->i_dirt = 1;
inode187fs/minix/file.cstatic int minix_file_write(struct inode * inode, struct file * filp, char * buf, int count)
inode194fs/minix/file.cif (!inode) {
inode198fs/minix/file.cif (!S_ISREG(inode->i_mode)) {
inode199fs/minix/file.cprintk("minix_file_write: mode = %07o\n",inode->i_mode);
inode207fs/minix/file.cpos = inode->i_size;
inode212fs/minix/file.cbh = minix_getblk(inode,pos/BLOCK_SIZE,1);
inode233fs/minix/file.cif (pos > inode->i_size) {
inode234fs/minix/file.cinode->i_size = pos;
inode235fs/minix/file.cinode->i_dirt = 1;
inode244fs/minix/file.cinode->i_mtime = inode->i_ctime = CURRENT_TIME;
inode246fs/minix/file.cinode->i_dirt = 1;
inode28fs/minix/fsync.cstatic int sync_block (struct inode * inode, unsigned short * block, int wait)
inode36fs/minix/fsync.cbh = get_hash_table(inode->i_dev, *block, blocksize);
inode57fs/minix/fsync.cstatic int sync_iblock (struct inode * inode, unsigned short * iblock, 
inode67fs/minix/fsync.crc = sync_block (inode, iblock, wait);
inode70fs/minix/fsync.c*bh = bread(inode->i_dev, tmp, blocksize);
inode82fs/minix/fsync.cstatic int sync_direct(struct inode *inode, int wait)
inode88fs/minix/fsync.crc = sync_block (inode, inode->u.minix_i.i_data + i, wait);
inode97fs/minix/fsync.cstatic int sync_indirect(struct inode *inode, unsigned short *iblock, int wait)
inode103fs/minix/fsync.crc = sync_iblock (inode, iblock, &ind_bh, wait);
inode108fs/minix/fsync.crc = sync_block (inode, 
inode120fs/minix/fsync.cstatic int sync_dindirect(struct inode *inode, unsigned short *diblock,
inode127fs/minix/fsync.crc = sync_iblock (inode, diblock, &dind_bh, wait);
inode132fs/minix/fsync.crc = sync_indirect (inode,
inode144fs/minix/fsync.cint minix_sync_file(struct inode * inode, struct file * file)
inode148fs/minix/fsync.cif (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
inode149fs/minix/fsync.cS_ISLNK(inode->i_mode)))
inode154fs/minix/fsync.cerr |= sync_direct(inode, wait);
inode155fs/minix/fsync.cerr |= sync_indirect(inode, inode->u.minix_i.i_data+7, wait);
inode156fs/minix/fsync.cerr |= sync_dindirect(inode, inode->u.minix_i.i_data+8, wait);
inode158fs/minix/fsync.cerr |= minix_sync_inode (inode);
inode19fs/minix/inode.cvoid minix_put_inode(struct inode *inode)
inode21fs/minix/inode.cif (inode->i_nlink)
inode23fs/minix/inode.cinode->i_size = 0;
inode24fs/minix/inode.cminix_truncate(inode);
inode25fs/minix/inode.cminix_free_inode(inode);
inode153fs/minix/inode.c#define inode_bmap(inode,nr) ((inode)->u.minix_i.i_data[(nr)])
inode166fs/minix/inode.cint minix_bmap(struct inode * inode,int block)
inode179fs/minix/inode.creturn inode_bmap(inode,block);
inode182fs/minix/inode.ci = inode_bmap(inode,7);
inode185fs/minix/inode.creturn block_bmap(bread(inode->i_dev,i,BLOCK_SIZE),block);
inode188fs/minix/inode.ci = inode_bmap(inode,8);
inode191fs/minix/inode.ci = block_bmap(bread(inode->i_dev,i,BLOCK_SIZE),block>>9);
inode194fs/minix/inode.creturn block_bmap(bread(inode->i_dev,i,BLOCK_SIZE),block & 511);
inode197fs/minix/inode.cstatic struct buffer_head * inode_getblk(struct inode * inode, int nr, int create)
inode203fs/minix/inode.cp = inode->u.minix_i.i_data + nr;
inode207fs/minix/inode.cresult = getblk(inode->i_dev, tmp, BLOCK_SIZE);
inode215fs/minix/inode.ctmp = minix_new_block(inode->i_sb);
inode218fs/minix/inode.cresult = getblk(inode->i_dev, tmp, BLOCK_SIZE);
inode220fs/minix/inode.cminix_free_block(inode->i_sb,tmp);
inode225fs/minix/inode.cinode->i_ctime = CURRENT_TIME;
inode226fs/minix/inode.cinode->i_dirt = 1;
inode230fs/minix/inode.cstatic struct buffer_head * block_getblk(struct inode * inode, 
inode263fs/minix/inode.ctmp = minix_new_block(inode->i_sb);
inode270fs/minix/inode.cminix_free_block(inode->i_sb,tmp);
inode280fs/minix/inode.cstruct buffer_head * minix_getblk(struct inode * inode, int block, int create)
inode293fs/minix/inode.creturn inode_getblk(inode,block,create);
inode296fs/minix/inode.cbh = inode_getblk(inode,7,create);
inode297fs/minix/inode.creturn block_getblk(inode, bh, block, create);
inode300fs/minix/inode.cbh = inode_getblk(inode,8,create);
inode301fs/minix/inode.cbh = block_getblk(inode, bh, block>>9, create);
inode302fs/minix/inode.creturn block_getblk(inode, bh, block & 511, create);
inode305fs/minix/inode.cstruct buffer_head * minix_bread(struct inode * inode, int block, int create)
inode309fs/minix/inode.cbh = minix_getblk(inode,block,create);
inode320fs/minix/inode.cvoid minix_read_inode(struct inode * inode)
inode326fs/minix/inode.cino = inode->i_ino;
inode327fs/minix/inode.cinode->i_op = NULL;
inode328fs/minix/inode.cinode->i_mode = 0;
inode329fs/minix/inode.cif (!ino || ino >= inode->i_sb->u.minix_sb.s_ninodes) {
inode331fs/minix/inode.cinode->i_dev, ino);
inode334fs/minix/inode.cblock = 2 + inode->i_sb->u.minix_sb.s_imap_blocks +
inode335fs/minix/inode.cinode->i_sb->u.minix_sb.s_zmap_blocks +
inode337fs/minix/inode.cif (!(bh=bread(inode->i_dev,block, BLOCK_SIZE))) {
inode339fs/minix/inode.cinode->i_dev);
inode344fs/minix/inode.cinode->i_mode = raw_inode->i_mode;
inode345fs/minix/inode.cinode->i_uid = raw_inode->i_uid;
inode346fs/minix/inode.cinode->i_gid = raw_inode->i_gid;
inode347fs/minix/inode.cinode->i_nlink = raw_inode->i_nlinks;
inode348fs/minix/inode.cinode->i_size = raw_inode->i_size;
inode349fs/minix/inode.cinode->i_mtime = inode->i_atime = inode->i_ctime = raw_inode->i_time;
inode350fs/minix/inode.cinode->i_blocks = inode->i_blksize = 0;
inode351fs/minix/inode.cif (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
inode352fs/minix/inode.cinode->i_rdev = raw_inode->i_zone[0];
inode354fs/minix/inode.cinode->u.minix_i.i_data[block] = raw_inode->i_zone[block];
inode356fs/minix/inode.cif (S_ISREG(inode->i_mode))
inode357fs/minix/inode.cinode->i_op = &minix_file_inode_operations;
inode358fs/minix/inode.celse if (S_ISDIR(inode->i_mode))
inode359fs/minix/inode.cinode->i_op = &minix_dir_inode_operations;
inode360fs/minix/inode.celse if (S_ISLNK(inode->i_mode))
inode361fs/minix/inode.cinode->i_op = &minix_symlink_inode_operations;
inode362fs/minix/inode.celse if (S_ISCHR(inode->i_mode))
inode363fs/minix/inode.cinode->i_op = &chrdev_inode_operations;
inode364fs/minix/inode.celse if (S_ISBLK(inode->i_mode))
inode365fs/minix/inode.cinode->i_op = &blkdev_inode_operations;
inode366fs/minix/inode.celse if (S_ISFIFO(inode->i_mode))
inode367fs/minix/inode.cinit_fifo(inode);
inode370fs/minix/inode.cstatic struct buffer_head * minix_update_inode(struct inode * inode)
inode376fs/minix/inode.cino = inode->i_ino;
inode377fs/minix/inode.cif (!ino || ino >= inode->i_sb->u.minix_sb.s_ninodes) {
inode379fs/minix/inode.cinode->i_dev, ino);
inode380fs/minix/inode.cinode->i_dirt = 0;
inode383fs/minix/inode.cblock = 2 + inode->i_sb->u.minix_sb.s_imap_blocks + inode->i_sb->u.minix_sb.s_zmap_blocks +
inode385fs/minix/inode.cif (!(bh=bread(inode->i_dev, block, BLOCK_SIZE))) {
inode387fs/minix/inode.cinode->i_dirt = 0;
inode392fs/minix/inode.craw_inode->i_mode = inode->i_mode;
inode393fs/minix/inode.craw_inode->i_uid = inode->i_uid;
inode394fs/minix/inode.craw_inode->i_gid = inode->i_gid;
inode395fs/minix/inode.craw_inode->i_nlinks = inode->i_nlink;
inode396fs/minix/inode.craw_inode->i_size = inode->i_size;
inode397fs/minix/inode.craw_inode->i_time = inode->i_mtime;
inode398fs/minix/inode.cif (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
inode399fs/minix/inode.craw_inode->i_zone[0] = inode->i_rdev;
inode401fs/minix/inode.craw_inode->i_zone[block] = inode->u.minix_i.i_data[block];
inode402fs/minix/inode.cinode->i_dirt=0;
inode407fs/minix/inode.cvoid minix_write_inode(struct inode * inode)
inode410fs/minix/inode.cbh = minix_update_inode(inode);
inode414fs/minix/inode.cint minix_sync_inode(struct inode * inode)
inode419fs/minix/inode.cbh = minix_update_inode(inode);
inode427fs/minix/inode.cinode->i_dev, inode->i_ino);
inode52fs/minix/namei.cif (!de->inode || len > info->s_namelen)
inode68fs/minix/namei.cstatic struct buffer_head * minix_find_entry(struct inode * dir,
inode111fs/minix/namei.cint minix_lookup(struct inode * dir,const char * name, int len,
inode112fs/minix/namei.cstruct inode ** result)
inode129fs/minix/namei.cino = de->inode;
inode149fs/minix/namei.cstatic int minix_add_entry(struct inode * dir,
inode185fs/minix/namei.cde->inode = 0;
inode190fs/minix/namei.cif (de->inode) {
inode214fs/minix/namei.cint minix_create(struct inode * dir,const char * name, int len, int mode,
inode215fs/minix/namei.cstruct inode ** result)
inode218fs/minix/namei.cstruct inode * inode;
inode225fs/minix/namei.cinode = minix_new_inode(dir);
inode226fs/minix/namei.cif (!inode) {
inode230fs/minix/namei.cinode->i_op = &minix_file_inode_operations;
inode231fs/minix/namei.cinode->i_mode = mode;
inode232fs/minix/namei.cinode->i_dirt = 1;
inode235fs/minix/namei.cinode->i_nlink--;
inode236fs/minix/namei.cinode->i_dirt = 1;
inode237fs/minix/namei.ciput(inode);
inode241fs/minix/namei.cde->inode = inode->i_ino;
inode245fs/minix/namei.c*result = inode;
inode249fs/minix/namei.cint minix_mknod(struct inode * dir, const char * name, int len, int mode, int rdev)
inode252fs/minix/namei.cstruct inode * inode;
inode264fs/minix/namei.cinode = minix_new_inode(dir);
inode265fs/minix/namei.cif (!inode) {
inode269fs/minix/namei.cinode->i_uid = current->euid;
inode270fs/minix/namei.cinode->i_mode = mode;
inode271fs/minix/namei.cinode->i_op = NULL;
inode272fs/minix/namei.cif (S_ISREG(inode->i_mode))
inode273fs/minix/namei.cinode->i_op = &minix_file_inode_operations;
inode274fs/minix/namei.celse if (S_ISDIR(inode->i_mode)) {
inode275fs/minix/namei.cinode->i_op = &minix_dir_inode_operations;
inode277fs/minix/namei.cinode->i_mode |= S_ISGID;
inode279fs/minix/namei.celse if (S_ISLNK(inode->i_mode))
inode280fs/minix/namei.cinode->i_op = &minix_symlink_inode_operations;
inode281fs/minix/namei.celse if (S_ISCHR(inode->i_mode))
inode282fs/minix/namei.cinode->i_op = &chrdev_inode_operations;
inode283fs/minix/namei.celse if (S_ISBLK(inode->i_mode))
inode284fs/minix/namei.cinode->i_op = &blkdev_inode_operations;
inode285fs/minix/namei.celse if (S_ISFIFO(inode->i_mode))
inode286fs/minix/namei.cinit_fifo(inode);
inode288fs/minix/namei.cinode->i_rdev = rdev;
inode289fs/minix/namei.cinode->i_mtime = inode->i_atime = CURRENT_TIME;
inode290fs/minix/namei.cinode->i_dirt = 1;
inode293fs/minix/namei.cinode->i_nlink--;
inode294fs/minix/namei.cinode->i_dirt = 1;
inode295fs/minix/namei.ciput(inode);
inode299fs/minix/namei.cde->inode = inode->i_ino;
inode303fs/minix/namei.ciput(inode);
inode307fs/minix/namei.cint minix_mkdir(struct inode * dir, const char * name, int len, int mode)
inode310fs/minix/namei.cstruct inode * inode;
inode330fs/minix/namei.cinode = minix_new_inode(dir);
inode331fs/minix/namei.cif (!inode) {
inode335fs/minix/namei.cinode->i_op = &minix_dir_inode_operations;
inode336fs/minix/namei.cinode->i_size = 2 * info->s_dirsize;
inode337fs/minix/namei.cinode->i_mtime = inode->i_atime = CURRENT_TIME;
inode338fs/minix/namei.cdir_block = minix_bread(inode,0,1);
inode341fs/minix/namei.cinode->i_nlink--;
inode342fs/minix/namei.cinode->i_dirt = 1;
inode343fs/minix/namei.ciput(inode);
inode347fs/minix/namei.cde->inode=inode->i_ino;
inode350fs/minix/namei.cde->inode = dir->i_ino;
inode352fs/minix/namei.cinode->i_nlink = 2;
inode355fs/minix/namei.cinode->i_mode = S_IFDIR | (mode & 0777 & ~current->umask);
inode357fs/minix/namei.cinode->i_mode |= S_ISGID;
inode358fs/minix/namei.cinode->i_dirt = 1;
inode362fs/minix/namei.cinode->i_nlink=0;
inode363fs/minix/namei.ciput(inode);
inode366fs/minix/namei.cde->inode = inode->i_ino;
inode371fs/minix/namei.ciput(inode);
inode379fs/minix/namei.cstatic int empty_dir(struct inode * inode)
inode386fs/minix/namei.cif (!inode || !inode->i_sb)
inode388fs/minix/namei.cinfo = &inode->i_sb->u.minix_sb;
inode392fs/minix/namei.cif (inode->i_size & (info->s_dirsize-1))
inode394fs/minix/namei.cif (inode->i_size < offset)
inode396fs/minix/namei.cbh = minix_bread(inode,0,0);
inode400fs/minix/namei.cif (!de->inode || strcmp(de->name,"."))
inode403fs/minix/namei.cif (!de->inode || strcmp(de->name,".."))
inode405fs/minix/namei.cwhile (block*BLOCK_SIZE+offset < inode->i_size) {
inode407fs/minix/namei.cbh = minix_bread(inode,block,0);
inode415fs/minix/namei.cif (de->inode) {
inode430fs/minix/namei.cprintk("Bad directory on device %04x\n",inode->i_dev);
inode434fs/minix/namei.cint minix_rmdir(struct inode * dir, const char * name, int len)
inode437fs/minix/namei.cstruct inode * inode;
inode441fs/minix/namei.cinode = NULL;
inode447fs/minix/namei.cif (!(inode = iget(dir->i_sb, de->inode)))
inode450fs/minix/namei.cinode->i_uid != current->euid)
inode452fs/minix/namei.cif (inode->i_dev != dir->i_dev)
inode454fs/minix/namei.cif (inode == dir)  /* we may not delete ".", but "../dir" is ok */
inode456fs/minix/namei.cif (!S_ISDIR(inode->i_mode)) {
inode460fs/minix/namei.cif (!empty_dir(inode)) {
inode464fs/minix/namei.cif (inode->i_count > 1) {
inode468fs/minix/namei.cif (inode->i_nlink != 2)
inode469fs/minix/namei.cprintk("empty directory has nlink!=2 (%d)\n",inode->i_nlink);
inode470fs/minix/namei.cde->inode = 0;
inode472fs/minix/namei.cinode->i_nlink=0;
inode473fs/minix/namei.cinode->i_dirt=1;
inode480fs/minix/namei.ciput(inode);
inode485fs/minix/namei.cint minix_unlink(struct inode * dir, const char * name, int len)
inode488fs/minix/namei.cstruct inode * inode;
inode494fs/minix/namei.cinode = NULL;
inode498fs/minix/namei.cif (!(inode = iget(dir->i_sb, de->inode)))
inode500fs/minix/namei.cif (de->inode != inode->i_ino) {
inode501fs/minix/namei.ciput(inode);
inode509fs/minix/namei.ccurrent->euid != inode->i_uid &&
inode512fs/minix/namei.cif (S_ISDIR(inode->i_mode))
inode514fs/minix/namei.cif (!inode->i_nlink) {
inode516fs/minix/namei.cinode->i_dev,inode->i_ino,inode->i_nlink);
inode517fs/minix/namei.cinode->i_nlink=1;
inode519fs/minix/namei.cde->inode = 0;
inode523fs/minix/namei.cinode->i_nlink--;
inode524fs/minix/namei.cinode->i_ctime = CURRENT_TIME;
inode525fs/minix/namei.cinode->i_dirt = 1;
inode529fs/minix/namei.ciput(inode);
inode534fs/minix/namei.cint minix_symlink(struct inode * dir, const char * name, int len, const char * symname)
inode537fs/minix/namei.cstruct inode * inode = NULL;
inode542fs/minix/namei.cif (!(inode = minix_new_inode(dir))) {
inode546fs/minix/namei.cinode->i_mode = S_IFLNK | 0777;
inode547fs/minix/namei.cinode->i_op = &minix_symlink_inode_operations;
inode548fs/minix/namei.cname_block = minix_bread(inode,0,1);
inode551fs/minix/namei.cinode->i_nlink--;
inode552fs/minix/namei.cinode->i_dirt = 1;
inode553fs/minix/namei.ciput(inode);
inode562fs/minix/namei.cinode->i_size = i;
inode563fs/minix/namei.cinode->i_dirt = 1;
inode566fs/minix/namei.cinode->i_nlink--;
inode567fs/minix/namei.cinode->i_dirt = 1;
inode568fs/minix/namei.ciput(inode);
inode575fs/minix/namei.cinode->i_nlink--;
inode576fs/minix/namei.cinode->i_dirt = 1;
inode577fs/minix/namei.ciput(inode);
inode581fs/minix/namei.cde->inode = inode->i_ino;
inode585fs/minix/namei.ciput(inode);
inode589fs/minix/namei.cint minix_link(struct inode * oldinode, struct inode * dir, const char * name, int len)
inode618fs/minix/namei.cde->inode = oldinode->i_ino;
inode629fs/minix/namei.cstatic int subdir(struct inode * new_inode, struct inode * old_inode)
inode654fs/minix/namei.c(((struct minix_dir_entry *) ((buffer)+info->s_dirsize))->inode)
inode666fs/minix/namei.cstatic int do_minix_rename(struct inode * old_dir, const char * old_name, int old_len,
inode667fs/minix/namei.cstruct inode * new_dir, const char * new_name, int new_len)
inode669fs/minix/namei.cstruct inode * old_inode, * new_inode;
inode692fs/minix/namei.cold_inode = iget(old_dir->i_sb, old_de->inode);
inode702fs/minix/namei.cnew_inode = iget(new_dir->i_sb, new_de->inode);
inode754fs/minix/namei.cif (new_inode && (new_de->inode != new_inode->i_ino))
inode756fs/minix/namei.cif (new_de->inode && !new_inode)
inode758fs/minix/namei.cif (old_de->inode != old_inode->i_ino)
inode761fs/minix/namei.cold_de->inode = 0;
inode762fs/minix/namei.cnew_de->inode = old_inode->i_ino;
inode803fs/minix/namei.cint minix_rename(struct inode * old_dir, const char * old_name, int old_len,
inode804fs/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)
inode52fs/minix/symlink.cif (!inode) {
inode56fs/minix/symlink.cif (!S_ISLNK(inode->i_mode)) {
inode58fs/minix/symlink.c*res_inode = inode;
inode62fs/minix/symlink.ciput(inode);
inode66fs/minix/symlink.cif (!(bh = minix_bread(inode, 0, 0))) {
inode67fs/minix/symlink.ciput(inode);
inode71fs/minix/symlink.ciput(inode);
inode79fs/minix/symlink.cstatic int minix_readlink(struct inode * inode, char * buffer, int buflen)
inode85fs/minix/symlink.cif (!S_ISLNK(inode->i_mode)) {
inode86fs/minix/symlink.ciput(inode);
inode91fs/minix/symlink.cbh = minix_bread(inode, 0, 0);
inode92fs/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 = get_hash_table(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 = get_hash_table(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,
inode57fs/msdos/dir.cstatic int msdos_readdir(struct inode *inode,struct file *filp,
inode65fs/msdos/dir.cif (!inode || !S_ISDIR(inode->i_mode)) return -EBADF;
inode66fs/msdos/dir.cif (inode->i_ino == MSDOS_ROOT_INO) {
inode81fs/msdos/dir.cwhile ((ino = msdos_get_entry(inode,&filp->f_pos,&bh,&de)) > -1) {
inode101fs/msdos/dir.cino = inode->i_ino;
inode103fs/msdos/dir.cino = msdos_parent_ino(inode,0);
inode120fs/msdos/fat.cvoid cache_lookup(struct inode *inode,int cluster,int *f_clu,int *d_clu)
inode125fs/msdos/fat.cprintk("cache lookup: <%d,%d> %d (%d,%d) -> ",inode->i_dev,inode->i_ino,cluster,
inode129fs/msdos/fat.cif (inode->i_dev == walk->device && walk->ino == inode->i_ino &&
inode160fs/msdos/fat.cvoid cache_add(struct inode *inode,int f_clu,int d_clu)
inode165fs/msdos/fat.cprintk("cache add: <%d,%d> %d (%d)\n",inode->i_dev,inode->i_ino,f_clu,d_clu);
inode169fs/msdos/fat.cif (inode->i_dev == walk->device && walk->ino == inode->i_ino &&
inode173fs/msdos/fat.ccache_inval_inode(inode);
inode186fs/msdos/fat.cwalk->device = inode->i_dev;
inode187fs/msdos/fat.cwalk->ino = inode->i_ino;
inode202fs/msdos/fat.cvoid cache_inval_inode(struct inode *inode)
inode207fs/msdos/fat.cif (walk->device == inode->i_dev && walk->ino == inode->i_ino)
inode221fs/msdos/fat.cint get_cluster(struct inode *inode,int cluster)
inode225fs/msdos/fat.cif (!(nr = MSDOS_I(inode)->i_start)) return 0;
inode228fs/msdos/fat.cfor (cache_lookup(inode,cluster,&count,&nr); count < cluster;
inode230fs/msdos/fat.cif ((nr = fat_access(inode->i_sb,nr,-1)) == -1) return 0;
inode233fs/msdos/fat.ccache_add(inode,cluster,nr);
inode238fs/msdos/fat.cint msdos_smap(struct inode *inode,int sector)
inode243fs/msdos/fat.csb = MSDOS_SB(inode->i_sb);
inode244fs/msdos/fat.cif (inode->i_ino == MSDOS_ROOT_INO || (S_ISDIR(inode->i_mode) &&
inode245fs/msdos/fat.c!MSDOS_I(inode)->i_start)) {
inode251fs/msdos/fat.cif (!(cluster = get_cluster(inode,cluster))) return 0;
inode259fs/msdos/fat.cint fat_free(struct inode *inode,int skip)
inode263fs/msdos/fat.cif (!(nr = MSDOS_I(inode)->i_start)) return 0;
inode267fs/msdos/fat.cif ((nr = fat_access(inode->i_sb,nr,-1)) == -1) return 0;
inode274fs/msdos/fat.cfat_access(inode->i_sb,last,MSDOS_SB(inode->i_sb)->fat_bits ==
inode277fs/msdos/fat.cMSDOS_I(inode)->i_start = 0;
inode278fs/msdos/fat.cinode->i_dirt = 1;
inode280fs/msdos/fat.clock_fat(inode->i_sb);
inode282fs/msdos/fat.cif (!(nr = fat_access(inode->i_sb,nr,0))) {
inode283fs/msdos/fat.cfs_panic(inode->i_sb,"fat_free: deleting beyond EOF");
inode286fs/msdos/fat.cif (MSDOS_SB(inode->i_sb)->free_clusters != -1)
inode287fs/msdos/fat.cMSDOS_SB(inode->i_sb)->free_clusters++;
inode288fs/msdos/fat.cinode->i_blocks -= MSDOS_SB(inode->i_sb)->cluster_size;
inode290fs/msdos/fat.cunlock_fat(inode->i_sb);
inode291fs/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,
inode80fs/msdos/file.cstatic int msdos_file_read(struct inode *inode,struct file *filp,char *buf,
inode90fs/msdos/file.cif (!inode) {
inode94fs/msdos/file.cif (!S_ISREG(inode->i_mode)) {
inode95fs/msdos/file.cprintk("msdos_file_read: mode = %07o\n",inode->i_mode);
inode98fs/msdos/file.cif (filp->f_pos >= inode->i_size || count <= 0) return 0;
inode100fs/msdos/file.cwhile ((left = MIN(inode->i_size-filp->f_pos,count-(buf-start))) > 0){
inode101fs/msdos/file.cif (!(sector = msdos_smap(inode,filp->f_pos >> SECTOR_BITS)))
inode104fs/msdos/file.cif (!(bh = msdos_sread(inode->i_dev,sector,&data))) break;
inode106fs/msdos/file.cif (MSDOS_I(inode)->i_binary) {
inode116fs/msdos/file.cfilp->f_pos = inode->i_size;
inode129fs/msdos/file.cstatic int msdos_file_write(struct inode *inode,struct file *filp,char *buf,
inode138fs/msdos/file.cif (!inode) {
inode142fs/msdos/file.cif (!S_ISREG(inode->i_mode)) {
inode143fs/msdos/file.cprintk("msdos_file_write: mode = %07o\n",inode->i_mode);
inode150fs/msdos/file.cif (filp->f_flags & O_APPEND) filp->f_pos = inode->i_size;
inode154fs/msdos/file.cwhile (!(sector = msdos_smap(inode,filp->f_pos >> SECTOR_BITS)))
inode155fs/msdos/file.cif ((error = msdos_add_cluster(inode)) < 0) break;
inode157fs/msdos/file.cmsdos_truncate(inode);
inode162fs/msdos/file.cif (!(bh = msdos_sread(inode->i_dev,sector,&data))) {
inode166fs/msdos/file.cif (MSDOS_I(inode)->i_binary) {
inode193fs/msdos/file.cif (filp->f_pos > inode->i_size) {
inode194fs/msdos/file.cinode->i_size = filp->f_pos;
inode195fs/msdos/file.cinode->i_dirt = 1;
inode200fs/msdos/file.cinode->i_mtime = inode->i_ctime = CURRENT_TIME;
inode201fs/msdos/file.cMSDOS_I(inode)->i_attrs |= ATTR_ARCH;
inode202fs/msdos/file.cinode->i_dirt = 1;
inode207fs/msdos/file.cvoid msdos_truncate(struct inode *inode)
inode211fs/msdos/file.ccluster = SECTOR_SIZE*MSDOS_SB(inode->i_sb)->cluster_size;
inode212fs/msdos/file.c(void) fat_free(inode,(inode->i_size+(cluster-1))/cluster);
inode213fs/msdos/file.cMSDOS_I(inode)->i_attrs |= ATTR_ARCH;
inode214fs/msdos/file.cinode->i_dirt = 1;
inode19fs/msdos/inode.cvoid msdos_put_inode(struct inode *inode)
inode21fs/msdos/inode.cstruct inode *depend;
inode24fs/msdos/inode.cif (inode->i_nlink) {
inode25fs/msdos/inode.cif (MSDOS_I(inode)->i_busy) cache_inval_inode(inode);
inode28fs/msdos/inode.cinode->i_size = 0;
inode29fs/msdos/inode.cmsdos_truncate(inode);
inode30fs/msdos/inode.cdepend = MSDOS_I(inode)->i_depend;
inode31fs/msdos/inode.csb = inode->i_sb;
inode32fs/msdos/inode.cclear_inode(inode);
inode34fs/msdos/inode.cif (MSDOS_I(depend)->i_old != inode) {
inode36fs/msdos/inode.c(int) depend,(int) inode,(int) MSDOS_I(depend)->
inode287fs/msdos/inode.cint msdos_bmap(struct inode *inode,int block)
inode292fs/msdos/inode.csb = MSDOS_SB(inode->i_sb);
inode294fs/msdos/inode.cif (inode->i_ino == MSDOS_ROOT_INO) {
inode300fs/msdos/inode.cif (!(cluster = get_cluster(inode,cluster))) return 0;
inode305fs/msdos/inode.cvoid msdos_read_inode(struct inode *inode)
inode312fs/msdos/inode.cMSDOS_I(inode)->i_busy = 0;
inode313fs/msdos/inode.cMSDOS_I(inode)->i_depend = MSDOS_I(inode)->i_old = NULL;
inode314fs/msdos/inode.cMSDOS_I(inode)->i_binary = 1;
inode315fs/msdos/inode.cinode->i_uid = MSDOS_SB(inode->i_sb)->fs_uid;
inode316fs/msdos/inode.cinode->i_gid = MSDOS_SB(inode->i_sb)->fs_gid;
inode317fs/msdos/inode.cif (inode->i_ino == MSDOS_ROOT_INO) {
inode318fs/msdos/inode.cinode->i_mode = (S_IRWXUGO & ~MSDOS_SB(inode->i_sb)->fs_umask) |
inode320fs/msdos/inode.cinode->i_op = &msdos_dir_inode_operations;
inode321fs/msdos/inode.cinode->i_nlink = msdos_subdirs(inode)+2;
inode323fs/msdos/inode.cinode->i_size = MSDOS_SB(inode->i_sb)->dir_entries*
inode325fs/msdos/inode.cinode->i_blksize = MSDOS_SB(inode->i_sb)->cluster_size*
inode327fs/msdos/inode.cinode->i_blocks = (inode->i_size+inode->i_blksize-1)/
inode328fs/msdos/inode.cinode->i_blksize*MSDOS_SB(inode->i_sb)->cluster_size;
inode329fs/msdos/inode.cMSDOS_I(inode)->i_start = 0;
inode330fs/msdos/inode.cMSDOS_I(inode)->i_attrs = 0;
inode331fs/msdos/inode.cinode->i_mtime = inode->i_atime = inode->i_ctime = 0;
inode334fs/msdos/inode.cif (!(bh = bread(inode->i_dev,inode->i_ino >> MSDOS_DPB_BITS,
inode336fs/msdos/inode.cprintk("dev = 0x%04X, ino = %d\n",inode->i_dev,inode->i_ino);
inode340fs/msdos/inode.c[inode->i_ino & (MSDOS_DPB-1)];
inode342fs/msdos/inode.cinode->i_mode = MSDOS_MKMODE(raw_entry->attr,S_IRWXUGO &
inode343fs/msdos/inode.c~MSDOS_SB(inode->i_sb)->fs_umask) | S_IFDIR;
inode344fs/msdos/inode.cinode->i_op = &msdos_dir_inode_operations;
inode345fs/msdos/inode.cMSDOS_I(inode)->i_start = CF_LE_W(raw_entry->start);
inode346fs/msdos/inode.cinode->i_nlink = msdos_subdirs(inode);
inode349fs/msdos/inode.cif (!inode->i_nlink) {
inode350fs/msdos/inode.cprintk("directory %d: i_nlink == 0\n",inode->i_ino);
inode351fs/msdos/inode.cinode->i_nlink = 1;
inode354fs/msdos/inode.cinode->i_size = 0;
inode357fs/msdos/inode.cinode->i_size += SECTOR_SIZE*MSDOS_SB(inode->
inode359fs/msdos/inode.cif (!(nr = fat_access(inode->i_sb,nr,-1)))
inode361fs/msdos/inode.cinode->i_ino);
inode365fs/msdos/inode.cinode->i_mode = MSDOS_MKMODE(raw_entry->attr,(IS_NOEXEC(inode)
inode366fs/msdos/inode.c? S_IRUGO|S_IWUGO : S_IRWXUGO) & ~MSDOS_SB(inode->i_sb)->fs_umask) |
inode368fs/msdos/inode.cinode->i_op = MSDOS_CAN_BMAP(MSDOS_SB(inode->i_sb)) ? 
inode371fs/msdos/inode.cMSDOS_I(inode)->i_start = CF_LE_W(raw_entry->start);
inode372fs/msdos/inode.cinode->i_nlink = 1;
inode373fs/msdos/inode.cinode->i_size = CF_LE_L(raw_entry->size);
inode375fs/msdos/inode.cMSDOS_I(inode)->i_binary = is_binary(MSDOS_SB(inode->i_sb)->conversion,
inode377fs/msdos/inode.cMSDOS_I(inode)->i_attrs = raw_entry->attr & ATTR_UNUSED;
inode379fs/msdos/inode.cinode->i_blksize = MSDOS_SB(inode->i_sb)->cluster_size*SECTOR_SIZE;
inode380fs/msdos/inode.cinode->i_blocks = (inode->i_size+inode->i_blksize-1)/
inode381fs/msdos/inode.cinode->i_blksize*MSDOS_SB(inode->i_sb)->cluster_size;
inode382fs/msdos/inode.cinode->i_mtime = inode->i_atime = inode->i_ctime =
inode388fs/msdos/inode.cvoid msdos_write_inode(struct inode *inode)
inode393fs/msdos/inode.cinode->i_dirt = 0;
inode394fs/msdos/inode.cif (inode->i_ino == MSDOS_ROOT_INO || !inode->i_nlink) return;
inode395fs/msdos/inode.cif (!(bh = bread(inode->i_dev,inode->i_ino >> MSDOS_DPB_BITS,
inode397fs/msdos/inode.cprintk("dev = 0x%04X, ino = %d\n",inode->i_dev,inode->i_ino);
inode401fs/msdos/inode.c[inode->i_ino & (MSDOS_DPB-1)];
inode402fs/msdos/inode.cif (S_ISDIR(inode->i_mode)) {
inode408fs/msdos/inode.craw_entry->size = CT_LE_L(inode->i_size);
inode410fs/msdos/inode.craw_entry->attr |= MSDOS_MKATTR(inode->i_mode) |
inode411fs/msdos/inode.cMSDOS_I(inode)->i_attrs;
inode412fs/msdos/inode.craw_entry->start = CT_LE_L(MSDOS_I(inode)->i_start);
inode413fs/msdos/inode.cdate_unix2dos(inode->i_mtime,&raw_entry->time,&raw_entry->date);
inode421fs/msdos/inode.cint msdos_notify_change(int flags,struct inode *inode)
inode426fs/msdos/inode.cif ((flags & NOTIFY_UIDGID) && (inode->i_uid != MSDOS_SB(inode->i_sb)->
inode427fs/msdos/inode.cfs_uid || inode->i_gid != MSDOS_SB(inode->i_sb)->fs_gid)) {
inode428fs/msdos/inode.cinode->i_uid = MSDOS_SB(inode->i_sb)->fs_uid;
inode429fs/msdos/inode.cinode->i_gid = MSDOS_SB(inode->i_sb)->fs_gid;
inode433fs/msdos/inode.creturn MSDOS_SB(inode->i_sb)->quiet ? 0 : error;
inode434fs/msdos/inode.cif (inode->i_mode & ~MSDOS_VALID_MODE) {
inode435fs/msdos/inode.cinode->i_mode &= MSDOS_VALID_MODE;
inode438fs/msdos/inode.cif (IS_NOEXEC(inode) && !S_ISDIR(inode->i_mode))
inode439fs/msdos/inode.cinode->i_mode &= S_IFMT | S_IRUGO | S_IWUGO;
inode440fs/msdos/inode.celse inode->i_mode |= S_IXUGO;
inode441fs/msdos/inode.cinode->i_mode = ((inode->i_mode & S_IFMT) | ((((inode->i_mode & S_IRWXU
inode442fs/msdos/inode.c& ~MSDOS_SB(inode->i_sb)->fs_umask) | S_IRUSR) >> 6)*S_IXUGO)) &
inode443fs/msdos/inode.c~MSDOS_SB(inode->i_sb)->fs_umask;
inode444fs/msdos/inode.creturn MSDOS_SB(inode->i_sb)->quiet ? 0 : error;
inode109fs/msdos/misc.cint msdos_add_cluster(struct inode *inode)
inode115fs/msdos/misc.cif (inode->i_ino == MSDOS_ROOT_INO) return -ENOSPC;
inode116fs/msdos/misc.cif (!MSDOS_SB(inode->i_sb)->free_clusters) return -ENOSPC;
inode117fs/msdos/misc.clock_fat(inode->i_sb);
inode118fs/msdos/misc.climit = MSDOS_SB(inode->i_sb)->clusters;
inode121fs/msdos/misc.cnr = ((count+MSDOS_SB(inode->i_sb)->prev_free) % limit)+2;
inode122fs/msdos/misc.cif (fat_access(inode->i_sb,nr,-1) == 0) break;
inode127fs/msdos/misc.cMSDOS_SB(inode->i_sb)->prev_free = (count+MSDOS_SB(inode->i_sb)->
inode130fs/msdos/misc.cMSDOS_SB(inode->i_sb)->free_clusters = 0;
inode131fs/msdos/misc.cunlock_fat(inode->i_sb);
inode134fs/msdos/misc.cfat_access(inode->i_sb,nr,MSDOS_SB(inode->i_sb)->fat_bits == 12 ?
inode136fs/msdos/misc.cif (MSDOS_SB(inode->i_sb)->free_clusters != -1)
inode137fs/msdos/misc.cMSDOS_SB(inode->i_sb)->free_clusters--;
inode138fs/msdos/misc.cunlock_fat(inode->i_sb);
inode140fs/msdos/misc.cprintk("set to %x\n",fat_access(inode->i_sb,nr,-1));
inode143fs/msdos/misc.cif ((current = MSDOS_I(inode)->i_start) != 0) {
inode144fs/msdos/misc.ccache_lookup(inode,INT_MAX,&last,&current);
inode146fs/msdos/misc.cif (!(current = fat_access(inode->i_sb,
inode148fs/msdos/misc.cfs_panic(inode->i_sb,"File without EOF");
inode155fs/msdos/misc.cif (last) fat_access(inode->i_sb,last,nr);
inode157fs/msdos/misc.cMSDOS_I(inode)->i_start = nr;
inode158fs/msdos/misc.cinode->i_dirt = 1;
inode161fs/msdos/misc.cif (last) printk("next set to %d\n",fat_access(inode->i_sb,last,-1));
inode163fs/msdos/misc.cfor (current = 0; current < MSDOS_SB(inode->i_sb)->cluster_size;
inode165fs/msdos/misc.csector = MSDOS_SB(inode->i_sb)->data_start+(nr-2)*
inode166fs/msdos/misc.cMSDOS_SB(inode->i_sb)->cluster_size+current;
inode170fs/msdos/misc.cif (current < MSDOS_SB(inode->i_sb)->cluster_size-1 &&
inode172fs/msdos/misc.cif (!(bh = getblk(inode->i_dev,sector >> 1,
inode182fs/msdos/misc.cif (!(bh = msdos_sread(inode->i_dev,sector,
inode192fs/msdos/misc.cinode->i_blocks += MSDOS_SB(inode->i_sb)->cluster_size;
inode193fs/msdos/misc.cif (S_ISDIR(inode->i_mode)) {
inode194fs/msdos/misc.cif (inode->i_size & (SECTOR_SIZE-1)) {
inode195fs/msdos/misc.cfs_panic(inode->i_sb,"Odd directory size");
inode196fs/msdos/misc.cinode->i_size = (inode->i_size+SECTOR_SIZE) &
inode199fs/msdos/misc.cinode->i_size += SECTOR_SIZE*MSDOS_SB(inode->i_sb)->
inode202fs/msdos/misc.cprintk("size is %d now (%x)\n",inode->i_size,inode);
inode204fs/msdos/misc.cinode->i_dirt = 1;
inode267fs/msdos/misc.cint msdos_get_entry(struct inode *dir, off_t *pos,struct buffer_head **bh,
inode330fs/msdos/misc.cinode = iget(sb,sector*MSDOS_DPS+entry); \
inode331fs/msdos/misc.cif (inode) { \
inode333fs/msdos/misc.cdone = !MSDOS_I(inode)->i_busy; \
inode334fs/msdos/misc.ciput(inode); \
inode352fs/msdos/misc.cstruct inode *inode;
inode455fs/msdos/misc.cint msdos_parent_ino(struct inode *dir,int locked)
inode491fs/msdos/misc.cint msdos_subdirs(struct inode *dir)
inode512fs/msdos/misc.cint msdos_scan(struct inode *dir,char *name,struct buffer_head **res_bh,
inode93fs/msdos/namei.cstatic int msdos_find(struct inode *dir,const char *name,int len,
inode105fs/msdos/namei.cint msdos_lookup(struct inode *dir,const char *name,int len,
inode106fs/msdos/namei.cstruct inode **result)
inode111fs/msdos/namei.cstruct inode *next;
inode161fs/msdos/namei.cstatic int msdos_create_entry(struct inode *dir,char *name,int is_dir,
inode162fs/msdos/namei.cstruct inode **result)
inode191fs/msdos/namei.cint msdos_create(struct inode *dir,const char *name,int len,int mode,
inode192fs/msdos/namei.cstruct inode **result)
inode239fs/msdos/namei.cint msdos_mkdir(struct inode *dir,const char *name,int len,int mode)
inode243fs/msdos/namei.cstruct inode *inode,*dot;
inode259fs/msdos/namei.cif ((res = msdos_create_entry(dir,msdos_name,1,&inode)) < 0) {
inode265fs/msdos/namei.cinode->i_nlink = 2; /* no need to mark them dirty */
inode266fs/msdos/namei.cMSDOS_I(inode)->i_busy = 1; /* prevent lookups */
inode267fs/msdos/namei.cif ((res = msdos_add_cluster(inode)) < 0) goto mkdir_error;
inode268fs/msdos/namei.cif ((res = msdos_create_entry(inode,MSDOS_DOT,1,&dot)) < 0)
inode270fs/msdos/namei.cdot->i_size = inode->i_size; /* doesn't grow in the 2nd create_entry */
inode271fs/msdos/namei.cMSDOS_I(dot)->i_start = MSDOS_I(inode)->i_start;
inode272fs/msdos/namei.cdot->i_nlink = inode->i_nlink;
inode275fs/msdos/namei.cif ((res = msdos_create_entry(inode,MSDOS_DOTDOT,1,&dot)) < 0)
inode282fs/msdos/namei.cMSDOS_I(inode)->i_busy = 0;
inode284fs/msdos/namei.ciput(inode);
inode288fs/msdos/namei.ciput(inode);
inode296fs/msdos/namei.cstatic int msdos_empty(struct inode *dir)
inode321fs/msdos/namei.cint msdos_rmdir(struct inode *dir,const char *name,int len)
inode326fs/msdos/namei.cstruct inode *inode;
inode329fs/msdos/namei.cinode = NULL;
inode335fs/msdos/namei.cif (!(inode = iget(dir->i_sb,ino))) goto rmdir_done;
inode337fs/msdos/namei.cif (!S_ISDIR(inode->i_mode)) goto rmdir_done;
inode339fs/msdos/namei.cif (dir->i_dev != inode->i_dev || dir == inode) goto rmdir_done;
inode340fs/msdos/namei.cres = msdos_empty(inode);
inode343fs/msdos/namei.cinode->i_nlink = 0;
inode346fs/msdos/namei.cinode->i_dirt = dir->i_dirt = 1;
inode353fs/msdos/namei.ciput(inode);
inode358fs/msdos/namei.cint msdos_unlink(struct inode *dir,const char *name,int len)
inode363fs/msdos/namei.cstruct inode *inode;
inode366fs/msdos/namei.cinode = NULL;
inode369fs/msdos/namei.cif (!(inode = iget(dir->i_sb,ino))) {
inode373fs/msdos/namei.cif (!S_ISREG(inode->i_mode)) {
inode377fs/msdos/namei.cinode->i_nlink = 0;
inode378fs/msdos/namei.cMSDOS_I(inode)->i_busy = 1;
inode379fs/msdos/namei.cinode->i_dirt = 1;
inode384fs/msdos/namei.ciput(inode);
inode390fs/msdos/namei.cstatic int rename_same_dir(struct inode *old_dir,char *old_name,
inode391fs/msdos/namei.cstruct inode *new_dir,char *new_name,struct buffer_head *old_bh,
inode396fs/msdos/namei.cstruct inode *new_inode,*old_inode;
inode441fs/msdos/namei.cstatic int rename_diff_dir(struct inode *old_dir,char *old_name,
inode442fs/msdos/namei.cstruct inode *new_dir,char *new_name,struct buffer_head *old_bh,
inode447fs/msdos/namei.cstruct inode *old_inode,*new_inode,*free_inode,*dotdot_inode,*walk;
inode560fs/msdos/namei.cint msdos_rename(struct inode *old_dir,const char *old_name,int old_len,
inode561fs/msdos/namei.cstruct inode *new_dir,const char *new_name,int new_len)
inode74fs/namei.cint permission(struct inode * inode,int mask)
inode76fs/namei.cint mode = inode->i_mode;
inode79fs/namei.cif (inode->i_dev && !inode->i_nlink)
inode81fs/namei.celse if (inode->i_op && inode->i_op->permission)
inode82fs/namei.creturn inode->i_op->permission(inode, mask);
inode83fs/namei.celse if (current->euid == inode->i_uid)
inode85fs/namei.celse if (in_group_p(inode->i_gid))
inode97fs/namei.cint lookup(struct inode * dir,const char * name, int len,
inode98fs/namei.cstruct inode ** result)
inode136fs/namei.cint follow_link(struct inode * dir, struct inode * inode,
inode137fs/namei.cint flag, int mode, struct inode ** res_inode)
inode139fs/namei.cif (!dir || !inode) {
inode141fs/namei.ciput(inode);
inode145fs/namei.cif (!inode->i_op || !inode->i_op->follow_link) {
inode147fs/namei.c*res_inode = inode;
inode150fs/namei.creturn inode->i_op->follow_link(dir,inode,flag,mode,res_inode);
inode160fs/namei.cstruct inode * base, struct inode ** res_inode)
inode165fs/namei.cstruct inode * inode;
inode185fs/namei.cerror = lookup(base,thisname,len,&inode);
inode190fs/namei.cerror = follow_link(base,inode,0,0,&base);
inode204fs/namei.cstatic int _namei(const char * pathname, struct inode * base,
inode205fs/namei.cint follow_links, struct inode ** res_inode)
inode209fs/namei.cstruct inode * inode;
inode216fs/namei.cerror = lookup(base,basename,namelen,&inode);
inode222fs/namei.cerror = follow_link(base,inode,0,0,&inode);
inode227fs/namei.c*res_inode = inode;
inode231fs/namei.cint lnamei(const char * pathname, struct inode ** res_inode)
inode251fs/namei.cint namei(const char * pathname, struct inode ** res_inode)
inode278fs/namei.cstruct inode ** res_inode, struct inode * base)
inode282fs/namei.cstruct inode * dir, *inode;
inode305fs/namei.cerror = lookup(dir,basename,namelen,&inode);
inode337fs/namei.ciput(inode);
inode340fs/namei.cerror = follow_link(dir,inode,flag,mode,&inode);
inode343fs/namei.cif (S_ISDIR(inode->i_mode) && (flag & 2)) {
inode344fs/namei.ciput(inode);
inode347fs/namei.cif (!permission(inode,ACC_MODE(flag))) {
inode348fs/namei.ciput(inode);
inode351fs/namei.cif (S_ISBLK(inode->i_mode) || S_ISCHR(inode->i_mode)) {
inode352fs/namei.cif (IS_NODEV(inode)) {
inode353fs/namei.ciput(inode);
inode357fs/namei.cif (IS_RDONLY(inode) && (flag & 2)) {
inode358fs/namei.ciput(inode);
inode362fs/namei.cif ((inode->i_count > 1) && (flag & 2)) {
inode367fs/namei.cif (inode == (*p)->executable) {
inode368fs/namei.ciput(inode);
inode372fs/namei.cif (inode == mpnt->vm_inode) {
inode373fs/namei.ciput(inode);
inode379fs/namei.c*res_inode = inode;
inode387fs/namei.cstruct inode * dir;
inode431fs/namei.cstruct inode * dir;
inode472fs/namei.cstruct inode * dir;
inode513fs/namei.cstruct inode * dir;
inode552fs/namei.cstruct inode * dir;
inode595fs/namei.cstatic int do_link(struct inode * oldinode, const char * newname)
inode597fs/namei.cstruct inode * dir;
inode638fs/namei.cstruct inode * oldinode;
inode653fs/namei.cstruct inode * old_dir, * new_dir;
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,
inode71fs/nfs/dir.cstatic int nfs_dir_read(struct inode *inode, struct file *filp, char *buf,
inode85fs/nfs/dir.cstatic int nfs_readdir(struct inode *inode, struct file *filp,
inode97fs/nfs/dir.cif (!inode || !S_ISDIR(inode->i_mode)) {
inode116fs/nfs/dir.cif (inode->i_dev == c_dev && inode->i_ino == c_ino) {
inode133fs/nfs/dir.cresult = nfs_proc_readdir(NFS_SERVER(inode), NFS_FH(inode),
inode140fs/nfs/dir.cc_dev = inode->i_dev;
inode141fs/nfs/dir.cc_ino = inode->i_ino;
inode175fs/nfs/dir.cint inode;
inode182fs/nfs/dir.cstatic struct nfs_lookup_cache_entry *nfs_lookup_cache_index(struct inode *dir,
inode190fs/nfs/dir.cif (entry->dev == dir->i_dev && entry->inode == dir->i_ino
inode197fs/nfs/dir.cstatic int nfs_lookup_cache_lookup(struct inode *dir, const char *filename,
inode221fs/nfs/dir.cstatic void nfs_lookup_cache_add(struct inode *dir, const char *filename,
inode238fs/nfs/dir.centry->inode = dir->i_ino;
inode246fs/nfs/dir.cstatic void nfs_lookup_cache_remove(struct inode *dir, struct inode *inode,
inode254fs/nfs/dir.cif (inode) {
inode255fs/nfs/dir.cdev = inode->i_dev;
inode256fs/nfs/dir.cfileid = inode->i_ino;
inode271fs/nfs/dir.cstatic void nfs_lookup_cache_refresh(struct inode *file,
inode286fs/nfs/dir.cstatic int nfs_lookup(struct inode *dir, const char *__name, int len,
inode287fs/nfs/dir.cstruct inode **result)
inode327fs/nfs/dir.cstatic int nfs_create(struct inode *dir, const char *name, int len, int mode,
inode328fs/nfs/dir.cstruct inode **result)
inode362fs/nfs/dir.cstatic int nfs_mknod(struct inode *dir, const char *name, int len,
inode394fs/nfs/dir.cstatic int nfs_mkdir(struct inode *dir, const char *name, int len, int mode)
inode421fs/nfs/dir.cstatic int nfs_rmdir(struct inode *dir, const char *name, int len)
inode441fs/nfs/dir.cstatic int nfs_unlink(struct inode *dir, const char *name, int len)
inode461fs/nfs/dir.cstatic int nfs_symlink(struct inode *dir, const char *name, int len,
inode489fs/nfs/dir.cstatic int nfs_link(struct inode *oldinode, struct inode *dir,
inode520fs/nfs/dir.cstatic int nfs_rename(struct inode *old_dir, const char *old_name, int old_len,
inode521fs/nfs/dir.cstruct inode *new_dir, const char *new_name, int new_len)
inode560fs/nfs/dir.cvoid nfs_refresh_inode(struct inode *inode, struct nfs_fattr *fattr)
inode564fs/nfs/dir.cif (!inode || !fattr) {
inode568fs/nfs/dir.cif (inode->i_ino != fattr->fileid) {
inode572fs/nfs/dir.cwas_empty = inode->i_mode == 0;
inode573fs/nfs/dir.cinode->i_mode = fattr->mode;
inode574fs/nfs/dir.cinode->i_nlink = fattr->nlink;
inode575fs/nfs/dir.cinode->i_uid = fattr->uid;
inode576fs/nfs/dir.cinode->i_gid = fattr->gid;
inode577fs/nfs/dir.cinode->i_size = fattr->size;
inode578fs/nfs/dir.cinode->i_blksize = fattr->blocksize;
inode579fs/nfs/dir.cif (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
inode580fs/nfs/dir.cinode->i_rdev = fattr->rdev;
inode582fs/nfs/dir.cinode->i_rdev = 0;
inode583fs/nfs/dir.cinode->i_blocks = fattr->blocks;
inode584fs/nfs/dir.cinode->i_atime = fattr->atime.seconds;
inode585fs/nfs/dir.cinode->i_mtime = fattr->mtime.seconds;
inode586fs/nfs/dir.cinode->i_ctime = fattr->ctime.seconds;
inode588fs/nfs/dir.cif (S_ISREG(inode->i_mode))
inode589fs/nfs/dir.cinode->i_op = &nfs_file_inode_operations;
inode590fs/nfs/dir.celse if (S_ISDIR(inode->i_mode))
inode591fs/nfs/dir.cinode->i_op = &nfs_dir_inode_operations;
inode592fs/nfs/dir.celse if (S_ISLNK(inode->i_mode))
inode593fs/nfs/dir.cinode->i_op = &nfs_symlink_inode_operations;
inode594fs/nfs/dir.celse if (S_ISCHR(inode->i_mode))
inode595fs/nfs/dir.cinode->i_op = &chrdev_inode_operations;
inode596fs/nfs/dir.celse if (S_ISBLK(inode->i_mode))
inode597fs/nfs/dir.cinode->i_op = &blkdev_inode_operations;
inode598fs/nfs/dir.celse if (S_ISFIFO(inode->i_mode))
inode599fs/nfs/dir.cinit_fifo(inode);
inode601fs/nfs/dir.cinode->i_op = NULL;
inode603fs/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);
inode22fs/nfs/file.cextern int nfs_mmap(struct inode * inode, struct file * file,
inode55fs/nfs/file.cstatic int nfs_file_read(struct inode *inode, struct file *file, char *buf,
inode66fs/nfs/file.cif (!inode) {
inode70fs/nfs/file.cif (!S_ISREG(inode->i_mode)) {
inode72fs/nfs/file.cinode->i_mode);
inode76fs/nfs/file.cif (file->f_pos + count > inode->i_size)
inode77fs/nfs/file.ccount = inode->i_size - pos;
inode80fs/nfs/file.cn = NFS_SERVER(inode)->rsize;
inode86fs/nfs/file.cresult = nfs_proc_read(NFS_SERVER(inode), NFS_FH(inode), 
inode102fs/nfs/file.cnfs_refresh_inode(inode, &fattr);
inode106fs/nfs/file.cstatic int nfs_file_write(struct inode *inode, struct file *file, char *buf,
inode117fs/nfs/file.cif (!inode) {
inode121fs/nfs/file.cif (!S_ISREG(inode->i_mode)) {
inode123fs/nfs/file.cinode->i_mode);
inode130fs/nfs/file.cpos = inode->i_size;
inode131fs/nfs/file.cn = NFS_SERVER(inode)->wsize;
inode138fs/nfs/file.cresult = nfs_proc_write(NFS_SERVER(inode), NFS_FH(inode), 
inode153fs/nfs/file.cnfs_refresh_inode(inode, &fattr);
inode23fs/nfs/inode.cstatic int nfs_notify_change(int, struct inode *);
inode24fs/nfs/inode.cstatic void nfs_put_inode(struct inode *);
inode39fs/nfs/inode.cstatic void nfs_put_inode(struct inode * inode)
inode41fs/nfs/inode.cclear_inode(inode);
inode160fs/nfs/inode.cstruct inode *nfs_fhget(struct super_block *sb, struct nfs_fh *fhandle,
inode165fs/nfs/inode.cstruct inode *inode;
inode180fs/nfs/inode.cif (!(inode = iget(sb, fattr->fileid))) {
inode184fs/nfs/inode.cif (inode->i_dev == sb->s_dev) {
inode185fs/nfs/inode.cif (inode->i_ino != fattr->fileid) {
inode187fs/nfs/inode.creturn inode;
inode189fs/nfs/inode.c*NFS_FH(inode) = *fhandle;
inode190fs/nfs/inode.cnfs_refresh_inode(inode, fattr);
inode192fs/nfs/inode.creturn inode;
inode195fs/nfs/inode.cint nfs_notify_change(int flags, struct inode *inode)
inode202fs/nfs/inode.csattr.mode = inode->i_mode;
inode206fs/nfs/inode.csattr.uid = inode->i_uid;
inode207fs/nfs/inode.csattr.gid = inode->i_gid;
inode212fs/nfs/inode.csattr.size = S_ISREG(inode->i_mode) ? inode->i_size : -1;
inode216fs/nfs/inode.csattr.mtime.seconds = inode->i_mtime;
inode218fs/nfs/inode.csattr.atime.seconds = inode->i_atime;
inode225fs/nfs/inode.cerror = nfs_proc_setattr(NFS_SERVER(inode), NFS_FH(inode),
inode228fs/nfs/inode.cnfs_refresh_inode(inode, &fattr);
inode229fs/nfs/inode.cinode->i_dirt = 0;
inode25fs/nfs/mmap.cstruct inode * inode, unsigned long address, unsigned long error_code,
inode48fs/nfs/mmap.cint nfs_mmap(struct inode * inode, struct file * file,
inode53fs/nfs/mmap.cif (off & (inode->i_sb->s_blocksize - 1))
inode59fs/nfs/mmap.cif (!inode->i_sb || !S_ISREG(inode->i_mode))
inode61fs/nfs/mmap.cif (!IS_RDONLY(inode)) {
inode62fs/nfs/mmap.cinode->i_atime = CURRENT_TIME;
inode63fs/nfs/mmap.cinode->i_dirt = 1;
inode76fs/nfs/mmap.cmpnt->vm_inode = inode;
inode77fs/nfs/mmap.cinode->i_count++;
inode93fs/nfs/mmap.cstruct inode * inode = area->vm_inode;
inode106fs/nfs/mmap.cif (share_page(area, area->vm_task, inode, address, error_code, page)) {
inode123fs/nfs/mmap.cn = NFS_SERVER(inode)->rsize; /* what we can read in one go */
inode131fs/nfs/mmap.cresult = nfs_proc_read(NFS_SERVER(inode), NFS_FH(inode),
inode143fs/nfs/mmap.cnfs_refresh_inode(inode, &fattr);
inode147fs/nfs/mmap.cif (share_page(area, area->vm_task, inode, address, error_code, page))
inode20fs/nfs/sock.cextern struct socket *socki_lookup(struct inode *inode);
inode35fs/nfs/sock.cstruct inode *inode;
inode43fs/nfs/sock.cint (*select) (struct inode *, struct file *, int, select_table *);
inode55fs/nfs/sock.cinode = file->f_inode;
inode57fs/nfs/sock.csock = socki_lookup(inode);
inode79fs/nfs/sock.cif (!select(inode, file, SEL_IN, &wait_table)
inode80fs/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)
inode53fs/nfs/symlink.cif (!inode) {
inode57fs/nfs/symlink.cif (!S_ISLNK(inode->i_mode)) {
inode59fs/nfs/symlink.c*res_inode = inode;
inode63fs/nfs/symlink.ciput(inode);
inode68fs/nfs/symlink.cerror = nfs_proc_readlink(NFS_SERVER(inode), NFS_FH(inode), res);
inode70fs/nfs/symlink.ciput(inode);
inode75fs/nfs/symlink.ciput(inode);
inode83fs/nfs/symlink.cstatic int nfs_readlink(struct inode *inode, char *buffer, int buflen)
inode90fs/nfs/symlink.cif (!S_ISLNK(inode->i_mode)) {
inode91fs/nfs/symlink.ciput(inode);
inode97fs/nfs/symlink.cerror = nfs_proc_readlink(NFS_SERVER(inode), NFS_FH(inode), res);
inode98fs/nfs/symlink.ciput(inode);
inode31fs/open.cstruct inode * inode;
inode37fs/open.cerror = namei(path,&inode);
inode40fs/open.cif (!inode->i_sb->s_op->statfs) {
inode41fs/open.ciput(inode);
inode44fs/open.cinode->i_sb->s_op->statfs(inode->i_sb, buf);
inode45fs/open.ciput(inode);
inode51fs/open.cstruct inode * inode;
inode60fs/open.cif (!(inode = file->f_inode))
inode62fs/open.cif (!inode->i_sb->s_op->statfs)
inode64fs/open.cinode->i_sb->s_op->statfs(inode->i_sb, buf);
inode70fs/open.cstruct inode * inode;
inode73fs/open.cerror = namei(path,&inode);
inode76fs/open.cif (S_ISDIR(inode->i_mode) || !permission(inode,MAY_WRITE)) {
inode77fs/open.ciput(inode);
inode80fs/open.cif (IS_RDONLY(inode)) {
inode81fs/open.ciput(inode);
inode84fs/open.cinode->i_size = length;
inode85fs/open.cif (inode->i_op && inode->i_op->truncate)
inode86fs/open.cinode->i_op->truncate(inode);
inode87fs/open.cinode->i_atime = inode->i_mtime = CURRENT_TIME;
inode88fs/open.cinode->i_dirt = 1;
inode89fs/open.cerror = notify_change(NOTIFY_SIZE, inode);
inode90fs/open.ciput(inode);
inode96fs/open.cstruct inode * inode;
inode101fs/open.cif (!(inode = file->f_inode))
inode103fs/open.cif (S_ISDIR(inode->i_mode) || !(file->f_mode & 2))
inode105fs/open.cinode->i_size = length;
inode106fs/open.cif (inode->i_op && inode->i_op->truncate)
inode107fs/open.cinode->i_op->truncate(inode);
inode108fs/open.cinode->i_atime = inode->i_mtime = CURRENT_TIME;
inode109fs/open.cinode->i_dirt = 1;
inode110fs/open.creturn notify_change(NOTIFY_SIZE, inode);
inode119fs/open.cstruct inode * inode;
inode123fs/open.cerror = namei(filename,&inode);
inode126fs/open.cif (IS_RDONLY(inode)) {
inode127fs/open.ciput(inode);
inode131fs/open.cif ((current->euid != inode->i_uid) && !suser()) {
inode132fs/open.ciput(inode);
inode137fs/open.cinode->i_ctime = CURRENT_TIME;
inode139fs/open.cif ((current->euid != inode->i_uid) &&
inode140fs/open.c!permission(inode,MAY_WRITE)) {
inode141fs/open.ciput(inode);
inode144fs/open.cactime = modtime = inode->i_ctime = CURRENT_TIME;
inode146fs/open.cinode->i_atime = actime;
inode147fs/open.cinode->i_mtime = modtime;
inode148fs/open.cinode->i_dirt = 1;
inode149fs/open.cerror = notify_change(NOTIFY_TIME, inode);
inode150fs/open.ciput(inode);
inode160fs/open.cstruct inode * inode;
inode165fs/open.cres = namei(filename,&inode);
inode168fs/open.ci_mode = inode->i_mode;
inode170fs/open.cif (current->uid == inode->i_uid)
inode172fs/open.celse if (in_group_p(inode->i_gid))
inode174fs/open.ciput(inode);
inode194fs/open.cstruct inode * inode;
inode197fs/open.cerror = namei(filename,&inode);
inode200fs/open.cif (!S_ISDIR(inode->i_mode)) {
inode201fs/open.ciput(inode);
inode204fs/open.cif (!permission(inode,MAY_EXEC)) {
inode205fs/open.ciput(inode);
inode209fs/open.ccurrent->pwd = inode;
inode215fs/open.cstruct inode * inode;
inode218fs/open.cerror = namei(filename,&inode);
inode221fs/open.cif (!S_ISDIR(inode->i_mode)) {
inode222fs/open.ciput(inode);
inode226fs/open.ciput(inode);
inode230fs/open.ccurrent->root = inode;
inode236fs/open.cstruct inode * inode;
inode241fs/open.cif (!(inode = file->f_inode))
inode243fs/open.cif ((current->euid != inode->i_uid) && !suser())
inode245fs/open.cif (IS_RDONLY(inode))
inode247fs/open.cinode->i_mode = (mode & S_IALLUGO) | (inode->i_mode & ~S_IALLUGO);
inode248fs/open.cif (!suser() && !in_group_p(inode->i_gid))
inode249fs/open.cinode->i_mode &= ~S_ISGID;
inode250fs/open.cinode->i_ctime = CURRENT_TIME;
inode251fs/open.cinode->i_dirt = 1;
inode252fs/open.creturn notify_change(NOTIFY_MODE, inode);
inode257fs/open.cstruct inode * inode;
inode260fs/open.cerror = namei(filename,&inode);
inode263fs/open.cif ((current->euid != inode->i_uid) && !suser()) {
inode264fs/open.ciput(inode);
inode267fs/open.cif (IS_RDONLY(inode)) {
inode268fs/open.ciput(inode);
inode271fs/open.cinode->i_mode = (mode & S_IALLUGO) | (inode->i_mode & ~S_IALLUGO);
inode272fs/open.cif (!suser() && !in_group_p(inode->i_gid))
inode273fs/open.cinode->i_mode &= ~S_ISGID;
inode274fs/open.cinode->i_ctime = CURRENT_TIME;
inode275fs/open.cinode->i_dirt = 1;
inode276fs/open.cerror = notify_change(NOTIFY_MODE, inode);
inode277fs/open.ciput(inode);
inode283fs/open.cstruct inode * inode;
inode288fs/open.cif (!(inode = file->f_inode))
inode290fs/open.cif (IS_RDONLY(inode))
inode293fs/open.cuser = inode->i_uid;
inode295fs/open.cgroup = inode->i_gid;
inode296fs/open.cif ((current->euid == inode->i_uid && user == inode->i_uid &&
inode297fs/open.c(in_group_p(group) || group == inode->i_gid)) ||
inode299fs/open.cinode->i_uid = user;
inode300fs/open.cinode->i_gid = group;
inode301fs/open.cinode->i_ctime = CURRENT_TIME;
inode302fs/open.cinode->i_dirt = 1;
inode303fs/open.creturn notify_change(NOTIFY_UIDGID, inode);
inode310fs/open.cstruct inode * inode;
inode313fs/open.cerror = lnamei(filename,&inode);
inode316fs/open.cif (IS_RDONLY(inode)) {
inode317fs/open.ciput(inode);
inode321fs/open.cuser = inode->i_uid;
inode323fs/open.cgroup = inode->i_gid;
inode324fs/open.cif ((current->euid == inode->i_uid && user == inode->i_uid &&
inode325fs/open.c(in_group_p(group) || group == inode->i_gid)) ||
inode327fs/open.cinode->i_uid = user;
inode328fs/open.cinode->i_gid = group;
inode329fs/open.cinode->i_ctime = CURRENT_TIME;
inode330fs/open.cinode->i_dirt = 1;
inode331fs/open.cerror = notify_change(NOTIFY_UIDGID, inode);
inode332fs/open.ciput(inode);
inode335fs/open.ciput(inode);
inode355fs/open.cstruct inode * inode;
inode375fs/open.cerror = open_namei(filename,flag,mode,&inode,NULL);
inode382fs/open.cinode->i_size = 0;
inode383fs/open.cif (inode->i_op && inode->i_op->truncate)
inode384fs/open.cinode->i_op->truncate(inode);
inode385fs/open.cif ((error = notify_change(NOTIFY_SIZE, inode))) {
inode386fs/open.ciput(inode);
inode391fs/open.cinode->i_dirt = 1;
inode393fs/open.cf->f_inode = inode;
inode397fs/open.cif (inode->i_op)
inode398fs/open.cf->f_op = inode->i_op->default_file_ops;
inode400fs/open.cerror = f->f_op->open(inode,f);
inode402fs/open.ciput(inode);
inode432fs/open.cstruct inode *inode;
inode438fs/open.cinode = filp->f_inode;
inode439fs/open.cif (inode && S_ISREG(inode->i_mode))
inode446fs/open.cfilp->f_op->release(inode,filp);
inode449fs/open.ciput(inode);
inode16fs/pipe.cstatic int pipe_read(struct inode * inode, struct file * filp, char * buf, int count)
inode21fs/pipe.cwhile (!PIPE_SIZE(*inode)) {
inode22fs/pipe.cwake_up(& PIPE_WRITE_WAIT(*inode));
inode23fs/pipe.cif (!PIPE_WRITERS(*inode)) /* are there any writers? */
inode27fs/pipe.cinterruptible_sleep_on(& PIPE_READ_WAIT(*inode));
inode29fs/pipe.cwhile (count>0 && (size = PIPE_SIZE(*inode))) {
inode30fs/pipe.cchars = PAGE_SIZE-PIPE_TAIL(*inode);
inode35fs/pipe.cmemcpy_tofs(buf, 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));
inode45fs/pipe.cif (PIPE_WRITERS(*inode))
inode50fs/pipe.cstatic int pipe_write(struct inode * inode, struct file * filp, char * buf, int count)
inode54fs/pipe.cif (!PIPE_READERS(*inode)) { /* no readers */
inode64fs/pipe.cwhile (PIPE_SIZE(*inode) >= size) {
inode65fs/pipe.cif (!PIPE_READERS(*inode)) { /* no readers */
inode74fs/pipe.cinterruptible_sleep_on(&PIPE_WRITE_WAIT(*inode));
inode76fs/pipe.cwhile (count>0 && (size = (PAGE_SIZE-1)-PIPE_SIZE(*inode))) {
inode77fs/pipe.cchars = PAGE_SIZE-PIPE_HEAD(*inode);
inode82fs/pipe.cmemcpy_fromfs(PIPE_BASE(*inode)+PIPE_HEAD(*inode), buf, chars );
inode84fs/pipe.cPIPE_HEAD(*inode) += chars;
inode85fs/pipe.cPIPE_HEAD(*inode) &= (PAGE_SIZE-1);
inode89fs/pipe.cwake_up(& PIPE_READ_WAIT(*inode));
inode95fs/pipe.cstatic int pipe_lseek(struct inode * inode, struct file * file, off_t offset, int orig)
inode100fs/pipe.cstatic int pipe_readdir(struct inode * inode, struct file * file, struct dirent * de, int count)
inode105fs/pipe.cstatic int bad_pipe_rw(struct inode * inode, struct file * filp, char * buf, int count)
inode110fs/pipe.cstatic int pipe_ioctl(struct inode *pino, struct file * filp,
inode126fs/pipe.cstatic int pipe_select(struct inode * inode, struct file * filp, int sel_type, select_table * wait)
inode130fs/pipe.cif (!PIPE_EMPTY(*inode) || !PIPE_WRITERS(*inode))
inode132fs/pipe.cselect_wait(&PIPE_READ_WAIT(*inode), wait);
inode135fs/pipe.cif (!PIPE_FULL(*inode) || !PIPE_READERS(*inode))
inode137fs/pipe.cselect_wait(&PIPE_WRITE_WAIT(*inode), wait);
inode140fs/pipe.cif (!PIPE_READERS(*inode) || !PIPE_WRITERS(*inode))
inode142fs/pipe.cselect_wait(&inode->i_wait,wait);
inode153fs/pipe.cstatic int connect_read(struct inode * inode, struct file * filp, char * buf, int count)
inode155fs/pipe.cwhile (!PIPE_SIZE(*inode)) {
inode156fs/pipe.cif (PIPE_WRITERS(*inode))
inode160fs/pipe.cwake_up(& PIPE_WRITE_WAIT(*inode));
inode163fs/pipe.cinterruptible_sleep_on(& PIPE_READ_WAIT(*inode));
inode166fs/pipe.creturn pipe_read(inode,filp,buf,count);
inode169fs/pipe.cstatic int connect_select(struct inode * inode, struct file * filp, int sel_type, select_table * wait)
inode173fs/pipe.cif (!PIPE_EMPTY(*inode)) {
inode177fs/pipe.cselect_wait(&PIPE_READ_WAIT(*inode), wait);
inode180fs/pipe.cif (!PIPE_FULL(*inode))
inode182fs/pipe.cselect_wait(&PIPE_WRITE_WAIT(*inode), wait);
inode185fs/pipe.cif (!PIPE_READERS(*inode) || !PIPE_WRITERS(*inode))
inode187fs/pipe.cselect_wait(&inode->i_wait,wait);
inode197fs/pipe.cstatic void pipe_read_release(struct inode * inode, struct file * filp)
inode199fs/pipe.cPIPE_READERS(*inode)--;
inode200fs/pipe.cwake_up(&PIPE_WRITE_WAIT(*inode));
inode203fs/pipe.cstatic void pipe_write_release(struct inode * inode, struct file * filp)
inode205fs/pipe.cPIPE_WRITERS(*inode)--;
inode206fs/pipe.cwake_up(&PIPE_READ_WAIT(*inode));
inode209fs/pipe.cstatic void pipe_rdwr_release(struct inode * inode, struct file * filp)
inode211fs/pipe.cPIPE_READERS(*inode)--;
inode212fs/pipe.cPIPE_WRITERS(*inode)--;
inode213fs/pipe.cwake_up(&PIPE_READ_WAIT(*inode));
inode214fs/pipe.cwake_up(&PIPE_WRITE_WAIT(*inode));
inode293fs/pipe.cstruct inode * inode;
inode321fs/pipe.cif (!(inode=get_pipe_inode())) {
inode328fs/pipe.cf[0]->f_inode = f[1]->f_inode = inode;
inode303fs/proc/array.cstatic int array_read(struct inode * inode, struct file * file,char * buf, int count)
inode314fs/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 **);
inode90fs/proc/base.cstatic int proc_lookupbase(struct inode * dir,const char * name, int len,
inode91fs/proc/base.cstruct inode ** result)
inode131fs/proc/base.cstatic int proc_readbase(struct inode * inode, struct file * filp,
inode138fs/proc/base.cif (!inode || !S_ISDIR(inode->i_mode))
inode140fs/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 **);
inode53fs/proc/fd.cstatic int proc_lookupfd(struct inode * dir,const char * name, int len,
inode54fs/proc/fd.cstruct inode ** result)
inode126fs/proc/fd.cstatic int proc_readfd(struct inode * inode, struct file * filp,
inode133fs/proc/fd.cif (!inode || !S_ISDIR(inode->i_mode))
inode135fs/proc/fd.cino = inode->i_ino;
inode147fs/proc/fd.cfd = inode->i_ino;
inode149fs/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;
inode74fs/proc/inode.cvoid proc_read_inode(struct inode * inode)
inode80fs/proc/inode.cinode->i_op = NULL;
inode81fs/proc/inode.cinode->i_mode = 0;
inode82fs/proc/inode.cinode->i_uid = 0;
inode83fs/proc/inode.cinode->i_gid = 0;
inode84fs/proc/inode.cinode->i_nlink = 1;
inode85fs/proc/inode.cinode->i_size = 0;
inode86fs/proc/inode.cinode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
inode87fs/proc/inode.cinode->i_blocks = inode->i_blksize = 0;
inode88fs/proc/inode.cino = inode->i_ino;
inode97fs/proc/inode.cinode->i_mode = S_IFDIR | S_IRUGO | S_IXUGO;
inode98fs/proc/inode.cinode->i_nlink = 2;
inode101fs/proc/inode.cinode->i_nlink++;
inode102fs/proc/inode.cinode->i_op = &proc_root_inode_operations;
inode106fs/proc/inode.cinode->i_mode = S_IFREG | S_IRUGO;
inode107fs/proc/inode.cinode->i_op = &proc_net_inode_operations;
inode113fs/proc/inode.cinode->i_mode = S_IFREG | S_IRUGO;
inode114fs/proc/inode.cinode->i_op = &proc_kmsg_inode_operations;
inode117fs/proc/inode.cinode->i_mode = S_IFDIR | S_IRUGO | S_IXUGO;
inode118fs/proc/inode.cinode->i_nlink = 2;
inode119fs/proc/inode.cinode->i_op = &proc_net_inode_operations;
inode122fs/proc/inode.cinode->i_mode = S_IFREG | S_IRUGO;
inode123fs/proc/inode.cinode->i_op = &proc_array_inode_operations;
inode129fs/proc/inode.cinode->i_uid = p->euid;
inode130fs/proc/inode.cinode->i_gid = p->egid;
inode133fs/proc/inode.cinode->i_nlink = 4;
inode134fs/proc/inode.cinode->i_mode = S_IFDIR | S_IRUGO | S_IXUGO;
inode135fs/proc/inode.cinode->i_op = &proc_base_inode_operations;
inode138fs/proc/inode.cinode->i_op = &proc_mem_inode_operations;
inode139fs/proc/inode.cinode->i_mode = S_IFREG | S_IRUSR | S_IWUSR;
inode144fs/proc/inode.cinode->i_op = &proc_link_inode_operations;
inode145fs/proc/inode.cinode->i_size = 64;
inode146fs/proc/inode.cinode->i_mode = S_IFLNK | S_IRWXU;
inode150fs/proc/inode.cinode->i_mode = S_IFDIR | S_IRUSR | S_IXUSR;
inode151fs/proc/inode.cinode->i_op = &proc_fd_inode_operations;
inode152fs/proc/inode.cinode->i_nlink = 2;
inode158fs/proc/inode.cinode->i_mode = S_IFREG | S_IRUGO;
inode159fs/proc/inode.cinode->i_op = &proc_array_inode_operations;
inode167fs/proc/inode.cinode->i_op = &proc_link_inode_operations;
inode168fs/proc/inode.cinode->i_size = 64;
inode169fs/proc/inode.cinode->i_mode = S_IFLNK | S_IRWXU;
inode182fs/proc/inode.cinode->i_op = &proc_link_inode_operations;
inode183fs/proc/inode.cinode->i_size = 64;
inode184fs/proc/inode.cinode->i_mode = S_IFLNK | S_IRWXU;
inode190fs/proc/inode.cvoid proc_write_inode(struct inode * inode)
inode192fs/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;
inode88fs/proc/link.cinode = mpnt->vm_inode;
inode97fs/proc/link.cif (!inode)
inode99fs/proc/link.c*res_inode = inode;
inode100fs/proc/link.cinode->i_count++;
inode104fs/proc/link.cstatic int proc_readlink(struct inode * inode, char * buffer, int buflen)
inode110fs/proc/link.ci = proc_follow_link(NULL, inode, 0, 0, &inode);
inode113fs/proc/link.cif (!inode)
inode115fs/proc/link.cdev = inode->i_dev;
inode116fs/proc/link.cino = inode->i_ino;
inode117fs/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;
inode71fs/proc/mem.cstatic int mem_write(struct inode * inode, struct file * file,char * buf, int count)
inode81fs/proc/mem.cpid = inode->i_ino;
inode127fs/proc/mem.cstatic int mem_lseek(struct inode * inode, struct file * file, off_t offset, int orig)
inode31fs/proc/net.cstatic int proc_readnet(struct inode * inode, struct file * file,
inode33fs/proc/net.cstatic int proc_readnetdir(struct inode *, struct file *,
inode35fs/proc/net.cstatic int proc_lookupnet(struct inode *,const char *,int,struct inode **);
inode101fs/proc/net.cstatic int proc_lookupnet(struct inode * dir,const char * name, int len,
inode102fs/proc/net.cstruct inode ** result)
inode130fs/proc/net.cstatic int proc_readnetdir(struct inode * inode, struct file * filp,
inode137fs/proc/net.cif (!inode || !S_ISDIR(inode->i_mode))
inode139fs/proc/net.cino = inode->i_ino;
inode157fs/proc/net.cstatic int proc_readnet(struct inode * inode, struct file * file,
inode169fs/proc/net.cino = inode->i_ino;
inode17fs/proc/root.cstatic int proc_readroot(struct inode *, struct file *, struct dirent *, int);
inode18fs/proc/root.cstatic int proc_lookuproot(struct inode *,const char *,int,struct inode **);
inode71fs/proc/root.cstatic int proc_lookuproot(struct inode * dir,const char * name, int len,
inode72fs/proc/root.cstruct inode ** result)
inode128fs/proc/root.cstatic int proc_readroot(struct inode * inode, struct file * filp,
inode135fs/proc/root.cif (!inode || !S_ISDIR(inode->i_mode))
inode23fs/read_write.cstruct inode * inode;
inode26fs/read_write.c!(inode = file->f_inode))
inode32fs/read_write.cerror = file->f_op->readdir(inode,file,dirent,count);
inode74fs/read_write.cstruct inode * inode;
inode76fs/read_write.cif (fd>=NR_OPEN || !(file=current->filp[fd]) || !(inode=file->f_inode))
inode87fs/read_write.creturn file->f_op->read(inode,file,buf,count);
inode94fs/read_write.cstruct inode * inode;
inode96fs/read_write.cif (fd>=NR_OPEN || !(file=current->filp[fd]) || !(inode=file->f_inode))
inode107fs/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)
inode20fs/stat.ctmp.st_dev = inode->i_dev;
inode21fs/stat.ctmp.st_ino = inode->i_ino;
inode22fs/stat.ctmp.st_mode = inode->i_mode;
inode23fs/stat.ctmp.st_nlink = inode->i_nlink;
inode24fs/stat.ctmp.st_uid = inode->i_uid;
inode25fs/stat.ctmp.st_gid = inode->i_gid;
inode26fs/stat.ctmp.st_rdev = inode->i_rdev;
inode27fs/stat.ctmp.st_size = inode->i_size;
inode28fs/stat.ctmp.st_atime = inode->i_atime;
inode29fs/stat.ctmp.st_mtime = inode->i_mtime;
inode30fs/stat.ctmp.st_ctime = inode->i_ctime;
inode34fs/stat.cstatic void cp_new_stat(struct inode * inode, struct new_stat * statbuf)
inode39fs/stat.ctmp.st_dev = inode->i_dev;
inode40fs/stat.ctmp.st_ino = inode->i_ino;
inode41fs/stat.ctmp.st_mode = inode->i_mode;
inode42fs/stat.ctmp.st_nlink = inode->i_nlink;
inode43fs/stat.ctmp.st_uid = inode->i_uid;
inode44fs/stat.ctmp.st_gid = inode->i_gid;
inode45fs/stat.ctmp.st_rdev = inode->i_rdev;
inode46fs/stat.ctmp.st_size = inode->i_size;
inode47fs/stat.ctmp.st_atime = inode->i_atime;
inode48fs/stat.ctmp.st_mtime = inode->i_mtime;
inode49fs/stat.ctmp.st_ctime = inode->i_ctime;
inode68fs/stat.cif (!inode->i_blksize) {
inode83fs/stat.ctmp.st_blocks = inode->i_blocks;
inode84fs/stat.ctmp.st_blksize = inode->i_blksize;
inode91fs/stat.cstruct inode * inode;
inode97fs/stat.cerror = namei(filename,&inode);
inode100fs/stat.ccp_old_stat(inode,statbuf);
inode101fs/stat.ciput(inode);
inode107fs/stat.cstruct inode * inode;
inode113fs/stat.cerror = namei(filename,&inode);
inode116fs/stat.ccp_new_stat(inode,statbuf);
inode117fs/stat.ciput(inode);
inode123fs/stat.cstruct inode * inode;
inode129fs/stat.cerror = lnamei(filename,&inode);
inode132fs/stat.ccp_old_stat(inode,statbuf);
inode133fs/stat.ciput(inode);
inode139fs/stat.cstruct inode * inode;
inode145fs/stat.cerror = lnamei(filename,&inode);
inode148fs/stat.ccp_new_stat(inode,statbuf);
inode149fs/stat.ciput(inode);
inode156fs/stat.cstruct inode * inode;
inode162fs/stat.cif (fd >= NR_OPEN || !(f=current->filp[fd]) || !(inode=f->f_inode))
inode164fs/stat.ccp_old_stat(inode,statbuf);
inode171fs/stat.cstruct inode * inode;
inode177fs/stat.cif (fd >= NR_OPEN || !(f=current->filp[fd]) || !(inode=f->f_inode))
inode179fs/stat.ccp_new_stat(inode,statbuf);
inode185fs/stat.cstruct inode * inode;
inode193fs/stat.cerror = lnamei(path,&inode);
inode196fs/stat.cif (!inode->i_op || !inode->i_op->readlink) {
inode197fs/stat.ciput(inode);
inode200fs/stat.creturn inode->i_op->readlink(inode,buf,bufsiz);
inode248fs/super.cstruct inode * inode;
inode251fs/super.cstruct inode dummy_inode;
inode256fs/super.cretval = namei(name,&inode);
inode258fs/super.cretval = lnamei(name,&inode);
inode262fs/super.cif (S_ISBLK(inode->i_mode)) {
inode263fs/super.cdev = inode->i_rdev;
inode264fs/super.cif (IS_NODEV(inode)) {
inode265fs/super.ciput(inode);
inode269fs/super.cif (!inode || !inode->i_sb || inode != inode->i_sb->s_mounted) {
inode270fs/super.ciput(inode);
inode273fs/super.cdev = inode->i_sb->s_dev;
inode274fs/super.ciput(inode);
inode277fs/super.cinode = &dummy_inode;
inode280fs/super.ciput(inode);
inode286fs/super.cfops->release(inode,NULL);
inode290fs/super.cif (inode != &dummy_inode)
inode291fs/super.ciput(inode);
inode309fs/super.cstruct inode * dir_i;
inode365fs/super.cstruct inode *dir_i;
inode397fs/super.cstruct inode * inode;
inode425fs/super.cretval = namei(dev_name,&inode);
inode428fs/super.cif (!S_ISBLK(inode->i_mode)) {
inode429fs/super.ciput(inode);
inode432fs/super.cif (IS_NODEV(inode)) {
inode433fs/super.ciput(inode);
inode436fs/super.cdev = inode->i_rdev;
inode438fs/super.ciput(inode);
inode444fs/super.cinode = NULL;
inode448fs/super.cretval = fops->open(inode,NULL);
inode450fs/super.ciput(inode);
inode458fs/super.ciput(inode);
inode462fs/super.ciput(inode);
inode474fs/super.cfops->release(inode,NULL);
inode475fs/super.ciput(inode);
inode483fs/super.cstruct inode * inode;
inode496fs/super.cinode = sb->s_mounted;
inode497fs/super.cinode->i_count += 3 ;  /* NOTE! it is logically used 4 times, not 1 */
inode498fs/super.csb->s_covered = inode;
inode500fs/super.ccurrent->pwd = inode;
inode501fs/super.ccurrent->root = inode;
inode283fs/xiafs/bitmap.cvoid xiafs_free_inode(struct inode * inode)
inode289fs/xiafs/bitmap.cif (!inode)
inode291fs/xiafs/bitmap.cif (!inode->i_dev || inode->i_count!=1 || inode->i_nlink || !inode->i_sb ||
inode292fs/xiafs/bitmap.cinode->i_ino < 3 || inode->i_ino > inode->i_sb->u.xiafs_sb.s_ninodes) {
inode296fs/xiafs/bitmap.csb = inode->i_sb;
inode297fs/xiafs/bitmap.cino = inode->i_ino;
inode301fs/xiafs/bitmap.cclear_inode(inode);
inode309fs/xiafs/bitmap.cstruct inode * xiafs_new_inode(struct inode * dir)
inode312fs/xiafs/bitmap.cstruct inode * inode;
inode316fs/xiafs/bitmap.cif (!dir || !(inode = get_empty_inode()))
inode318fs/xiafs/bitmap.cinode->i_sb = sb;
inode319fs/xiafs/bitmap.cinode->i_flags = inode->i_sb->s_flags;
inode323fs/xiafs/bitmap.ciput(inode);
inode326fs/xiafs/bitmap.cinode->i_count = 1;
inode327fs/xiafs/bitmap.cinode->i_nlink = 1;
inode328fs/xiafs/bitmap.cinode->i_dev = sb->s_dev;
inode329fs/xiafs/bitmap.cinode->i_uid = current->euid;
inode330fs/xiafs/bitmap.cinode->i_gid = (dir->i_mode & S_ISGID) ? dir->i_gid : current->egid;
inode331fs/xiafs/bitmap.cinode->i_dirt = 1;
inode332fs/xiafs/bitmap.cinode->i_ino = tmp;
inode333fs/xiafs/bitmap.cinode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
inode334fs/xiafs/bitmap.cinode->i_op = NULL;
inode335fs/xiafs/bitmap.cinode->i_blocks = 0;
inode336fs/xiafs/bitmap.cinode->i_blksize = XIAFS_ZSIZE(inode->i_sb);
inode337fs/xiafs/bitmap.cinsert_inode_hash(inode);
inode338fs/xiafs/bitmap.creturn inode;
inode22fs/xiafs/dir.cstatic int xiafs_dir_read(struct inode *, struct file *, char *, int);
inode23fs/xiafs/dir.cstatic int xiafs_readdir(struct inode *, struct file *, struct dirent *, int);
inode59fs/xiafs/dir.cstatic int xiafs_dir_read(struct inode * inode, 
inode65fs/xiafs/dir.cstatic int xiafs_readdir(struct inode * inode, 
inode72fs/xiafs/dir.cif (!inode || !inode->i_sb || !S_ISDIR(inode->i_mode))
inode74fs/xiafs/dir.cif (inode->i_size & (XIAFS_ZSIZE(inode->i_sb) - 1) )
inode76fs/xiafs/dir.cwhile (filp->f_pos < inode->i_size) {
inode77fs/xiafs/dir.coffset = filp->f_pos & (XIAFS_ZSIZE(inode->i_sb) - 1);
inode78fs/xiafs/dir.cbh = xiafs_bread(inode, filp->f_pos >> XIAFS_ZSIZE_BITS(inode->i_sb),0);
inode80fs/xiafs/dir.cfilp->f_pos += XIAFS_ZSIZE(inode->i_sb)-offset;
inode84fs/xiafs/dir.cwhile (offset < XIAFS_ZSIZE(inode->i_sb) && filp->f_pos < inode->i_size) {
inode85fs/xiafs/dir.cif (de->d_ino > inode->i_sb->u.xiafs_sb.s_ninodes ||
inode87fs/xiafs/dir.c(char *)de+de->d_rec_len > XIAFS_ZSIZE(inode->i_sb)+bh->b_data ||
inode104fs/xiafs/dir.cif (!IS_RDONLY (inode)) {
inode105fs/xiafs/dir.cinode->i_atime=CURRENT_TIME;        
inode106fs/xiafs/dir.cinode->i_dirt=1;
inode113fs/xiafs/dir.cif (offset > XIAFS_ZSIZE(inode->i_sb)) {
inode118fs/xiafs/dir.cif (!IS_RDONLY (inode)) {
inode119fs/xiafs/dir.cinode->i_atime=CURRENT_TIME;        
inode120fs/xiafs/dir.cinode->i_dirt=1;
inode31fs/xiafs/file.cstatic int xiafs_file_read(struct inode *, struct file *, char *, int);
inode32fs/xiafs/file.cstatic int xiafs_file_write(struct inode *, struct file *, char *, int);
inode70fs/xiafs/file.cxiafs_file_read(struct inode * inode, struct file * filp, char * buf, int count)
inode79fs/xiafs/file.cif (!inode) {
inode83fs/xiafs/file.cif (!S_ISREG(inode->i_mode)) {
inode88fs/xiafs/file.cleft = inode->i_size - offset;
inode94fs/xiafs/file.czone_nr = offset >> XIAFS_ZSIZE_BITS(inode->i_sb);
inode95fs/xiafs/file.coffset &= XIAFS_ZSIZE(inode->i_sb) -1 ;
inode96fs/xiafs/file.cf_zones =(inode->i_size+XIAFS_ZSIZE(inode->i_sb)-1)>>XIAFS_ZSIZE_BITS(inode->i_sb);
inode97fs/xiafs/file.czones = (left+offset+XIAFS_ZSIZE(inode->i_sb)-1) >> XIAFS_ZSIZE_BITS(inode->i_sb);
inode100fs/xiafs/file.czones += read_ahead[MAJOR(inode->i_dev)] >> (1+XIAFS_ZSHIFT(inode->i_sb));
inode119fs/xiafs/file.c*bhb = xiafs_getblk(inode, zone_nr++, 0);
inode148fs/xiafs/file.cif (left < XIAFS_ZSIZE(inode->i_sb) - offset)
inode151fs/xiafs/file.cchars = XIAFS_ZSIZE(inode->i_sb) - offset;
inode178fs/xiafs/file.cif (!IS_RDONLY (inode)) {
inode179fs/xiafs/file.cinode->i_atime = CURRENT_TIME;
inode180fs/xiafs/file.cinode->i_dirt = 1;
inode186fs/xiafs/file.cxiafs_file_write(struct inode * inode, struct file * filp, char * buf, int count)
inode193fs/xiafs/file.cif (!inode) {
inode197fs/xiafs/file.cif (!S_ISREG(inode->i_mode)) {
inode206fs/xiafs/file.cpos = inode->i_size;
inode211fs/xiafs/file.cbh = xiafs_getblk(inode, pos >> XIAFS_ZSIZE_BITS(inode->i_sb), 1);
inode217fs/xiafs/file.cc = XIAFS_ZSIZE(inode->i_sb) - (pos & (XIAFS_ZSIZE(inode->i_sb) - 1));
inode220fs/xiafs/file.cif (c != XIAFS_ZSIZE(inode->i_sb) && !bh->b_uptodate) {
inode230fs/xiafs/file.ccp = (pos & (XIAFS_ZSIZE(inode->i_sb)-1)) + bh->b_data;
inode232fs/xiafs/file.cif (pos > inode->i_size) {
inode233fs/xiafs/file.cinode->i_size = pos;
inode234fs/xiafs/file.cinode->i_dirt = 1;
inode243fs/xiafs/file.cinode->i_atime = inode->i_ctime = inode->i_mtime = CURRENT_TIME;
inode245fs/xiafs/file.cinode->i_dirt = 1;
inode27fs/xiafs/fsync.c#define blocksize (XIAFS_ZSIZE(inode->i_sb))
inode28fs/xiafs/fsync.c#define addr_per_block (XIAFS_ADDRS_PER_Z(inode->i_sb))
inode30fs/xiafs/fsync.cstatic int sync_block (struct inode * inode, unsigned long * block, int wait)
inode38fs/xiafs/fsync.cbh = get_hash_table(inode->i_dev, *block, blocksize);
inode59fs/xiafs/fsync.cstatic int sync_iblock (struct inode * inode, unsigned long * iblock, 
inode68fs/xiafs/fsync.crc = sync_block (inode, iblock, wait);
inode71fs/xiafs/fsync.c*bh = bread(inode->i_dev, tmp, blocksize);
inode83fs/xiafs/fsync.cstatic int sync_direct(struct inode *inode, int wait)
inode89fs/xiafs/fsync.crc = sync_block (inode, inode->u.ext_i.i_data + i, wait);
inode98fs/xiafs/fsync.cstatic int sync_indirect(struct inode *inode, unsigned long *iblock, int wait)
inode104fs/xiafs/fsync.crc = sync_iblock (inode, iblock, &ind_bh, wait);
inode109fs/xiafs/fsync.crc = sync_block (inode, 
inode121fs/xiafs/fsync.cstatic int sync_dindirect(struct inode *inode, unsigned long *diblock,
inode128fs/xiafs/fsync.crc = sync_iblock (inode, diblock, &dind_bh, wait);
inode133fs/xiafs/fsync.crc = sync_indirect (inode,
inode145fs/xiafs/fsync.cint xiafs_sync_file(struct inode * inode, struct file * file)
inode149fs/xiafs/fsync.cif (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
inode150fs/xiafs/fsync.cS_ISLNK(inode->i_mode)))
inode154fs/xiafs/fsync.cerr |= sync_direct(inode, wait);
inode155fs/xiafs/fsync.cerr |= sync_indirect(inode, &inode->u.xiafs_i.i_ind_zone, wait);
inode156fs/xiafs/fsync.cerr |= sync_dindirect(inode, &inode->u.xiafs_i.i_dind_zone, wait);
inode158fs/xiafs/fsync.cerr |= xiafs_sync_inode (inode);
inode26fs/xiafs/inode.cvoid xiafs_put_inode(struct inode *inode)
inode28fs/xiafs/inode.cif (inode->i_nlink)
inode30fs/xiafs/inode.cinode->i_size = 0;
inode31fs/xiafs/inode.cxiafs_truncate(inode);
inode32fs/xiafs/inode.cxiafs_free_inode(inode);
inode185fs/xiafs/inode.cint xiafs_bmap(struct inode * inode,int zone)
inode193fs/xiafs/inode.cif (zone >= 8+(1+XIAFS_ADDRS_PER_Z(inode->i_sb))*XIAFS_ADDRS_PER_Z(inode->i_sb)) {
inode197fs/xiafs/inode.cif (!IS_RDONLY (inode)) {
inode198fs/xiafs/inode.cinode->i_atime = CURRENT_TIME;
inode199fs/xiafs/inode.cinode->i_dirt = 1;
inode202fs/xiafs/inode.creturn inode->u.xiafs_i.i_zone[zone];
inode204fs/xiafs/inode.cif (zone < XIAFS_ADDRS_PER_Z(inode->i_sb)) {
inode205fs/xiafs/inode.ci = inode->u.xiafs_i.i_ind_zone;
inode207fs/xiafs/inode.ci = zone_bmap(bread(inode->i_dev, i, XIAFS_ZSIZE(inode->i_sb)), zone);
inode210fs/xiafs/inode.czone -= XIAFS_ADDRS_PER_Z(inode->i_sb);
inode211fs/xiafs/inode.ci = inode->u.xiafs_i.i_dind_zone;
inode213fs/xiafs/inode.ci = zone_bmap(bread(inode->i_dev, i, XIAFS_ZSIZE(inode->i_sb)), 
inode214fs/xiafs/inode.czone >> XIAFS_ADDRS_PER_Z_BITS(inode->i_sb));
inode216fs/xiafs/inode.ci= zone_bmap(bread(inode->i_dev,i, XIAFS_ZSIZE(inode->i_sb)),
inode217fs/xiafs/inode.czone & (XIAFS_ADDRS_PER_Z(inode->i_sb)-1));
inode221fs/xiafs/inode.cstatic u_long get_prev_addr(struct inode * inode, int zone)
inode227fs/xiafs/inode.cif ((tmp=xiafs_bmap(inode, zone)))
inode229fs/xiafs/inode.crandom_nr=(random_nr+23)%inode->i_sb->u.xiafs_sb.s_ndatazones;
inode230fs/xiafs/inode.creturn random_nr + inode->i_sb->u.xiafs_sb.s_firstdatazone;
inode234fs/xiafs/inode.cdt_getblk(struct inode * inode, u_long *lp, int create, u_long prev_addr)
inode241fs/xiafs/inode.cresult = getblk(inode->i_dev, tmp, XIAFS_ZSIZE(inode->i_sb));
inode249fs/xiafs/inode.ctmp = xiafs_new_zone(inode->i_sb, prev_addr);
inode252fs/xiafs/inode.cresult = getblk(inode->i_dev, tmp, XIAFS_ZSIZE(inode->i_sb));
inode254fs/xiafs/inode.cxiafs_free_zone(inode->i_sb, tmp);
inode259fs/xiafs/inode.cinode->i_blocks+=2 << XIAFS_ZSHIFT(inode->i_sb);
inode264fs/xiafs/inode.cindt_getblk(struct inode * inode, struct buffer_head * bh, 
inode284fs/xiafs/inode.cresult = getblk(bh->b_dev, tmp, XIAFS_ZSIZE(inode->i_sb));
inode296fs/xiafs/inode.ctmp = xiafs_new_zone(inode->i_sb, prev_addr);
inode301fs/xiafs/inode.cresult = getblk(bh->b_dev, tmp, XIAFS_ZSIZE(inode->i_sb));
inode303fs/xiafs/inode.cxiafs_free_zone(inode->i_sb, tmp);
inode308fs/xiafs/inode.cinode->i_blocks+=2 << XIAFS_ZSHIFT(inode->i_sb);
inode314fs/xiafs/inode.cstruct buffer_head * xiafs_getblk(struct inode * inode, int zone, int create)
inode323fs/xiafs/inode.cif (zone >= 8+(1+XIAFS_ADDRS_PER_Z(inode->i_sb))*XIAFS_ADDRS_PER_Z(inode->i_sb)) {
inode329fs/xiafs/inode.cprev_addr=get_prev_addr(inode, zone);
inode331fs/xiafs/inode.creturn dt_getblk(inode, zone+inode->u.xiafs_i.i_zone, create, prev_addr);
inode333fs/xiafs/inode.cif (zone < XIAFS_ADDRS_PER_Z(inode->i_sb)) {
inode334fs/xiafs/inode.cbh = dt_getblk(inode, &(inode->u.xiafs_i.i_ind_zone), create, prev_addr);
inode335fs/xiafs/inode.cbh = indt_getblk(inode, bh, zone, create, prev_addr);
inode338fs/xiafs/inode.czone -= XIAFS_ADDRS_PER_Z(inode->i_sb);
inode339fs/xiafs/inode.cbh = dt_getblk(inode, &(inode->u.xiafs_i.i_dind_zone), create, prev_addr);
inode340fs/xiafs/inode.cbh = indt_getblk(inode, bh, zone>>XIAFS_ADDRS_PER_Z_BITS(inode->i_sb), 
inode342fs/xiafs/inode.cbh = indt_getblk(inode, bh, zone&(XIAFS_ADDRS_PER_Z(inode->i_sb)-1), 
inode347fs/xiafs/inode.cstruct buffer_head * xiafs_bread(struct inode * inode, int zone, int create)
inode351fs/xiafs/inode.cbh = xiafs_getblk(inode, zone, create);
inode362fs/xiafs/inode.cvoid xiafs_read_inode(struct inode * inode)
inode369fs/xiafs/inode.cino = inode->i_ino;
inode370fs/xiafs/inode.cinode->i_op = NULL;
inode371fs/xiafs/inode.cinode->i_mode=0;
inode372fs/xiafs/inode.cif (!ino || ino > inode->i_sb->u.xiafs_sb.s_ninodes) {
inode376fs/xiafs/inode.czone = 1 + inode->i_sb->u.xiafs_sb.s_imap_zones +
inode377fs/xiafs/inode.cinode->i_sb->u.xiafs_sb.s_zmap_zones +
inode378fs/xiafs/inode.c(ino-1)/ XIAFS_INODES_PER_Z(inode->i_sb);
inode379fs/xiafs/inode.cif (!(bh=bread(inode->i_dev, zone, XIAFS_ZSIZE(inode->i_sb)))) {
inode384fs/xiafs/inode.c((ino-1) & (XIAFS_INODES_PER_Z(inode->i_sb) - 1));
inode385fs/xiafs/inode.cinode->i_mode = raw_inode->i_mode;
inode386fs/xiafs/inode.cinode->i_uid = raw_inode->i_uid;
inode387fs/xiafs/inode.cinode->i_gid = raw_inode->i_gid;
inode388fs/xiafs/inode.cinode->i_nlink = raw_inode->i_nlinks;
inode389fs/xiafs/inode.cinode->i_size = raw_inode->i_size;
inode390fs/xiafs/inode.cinode->i_mtime = raw_inode->i_mtime;
inode391fs/xiafs/inode.cinode->i_atime = raw_inode->i_atime;
inode392fs/xiafs/inode.cinode->i_ctime = raw_inode->i_ctime;
inode393fs/xiafs/inode.cinode->i_blksize = XIAFS_ZSIZE(inode->i_sb);
inode394fs/xiafs/inode.cif (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode)) {
inode395fs/xiafs/inode.cinode->i_blocks=0;
inode396fs/xiafs/inode.cinode->i_rdev = raw_inode->i_zone[0];
inode398fs/xiafs/inode.cXIAFS_GET_BLOCKS(raw_inode, inode->i_blocks);
inode400fs/xiafs/inode.cinode->u.xiafs_i.i_zone[zone] = raw_inode->i_zone[zone] & 0xffffff;
inode401fs/xiafs/inode.cinode->u.xiafs_i.i_ind_zone       = raw_inode->i_ind_zone   & 0xffffff;
inode402fs/xiafs/inode.cinode->u.xiafs_i.i_dind_zone      = raw_inode->i_dind_zone  & 0xffffff;
inode405fs/xiafs/inode.cif (S_ISREG(inode->i_mode))
inode406fs/xiafs/inode.cinode->i_op = &xiafs_file_inode_operations;
inode407fs/xiafs/inode.celse if (S_ISDIR(inode->i_mode))
inode408fs/xiafs/inode.cinode->i_op = &xiafs_dir_inode_operations;
inode409fs/xiafs/inode.celse if (S_ISLNK(inode->i_mode))
inode410fs/xiafs/inode.cinode->i_op = &xiafs_symlink_inode_operations;
inode411fs/xiafs/inode.celse if (S_ISCHR(inode->i_mode))
inode412fs/xiafs/inode.cinode->i_op = &chrdev_inode_operations;
inode413fs/xiafs/inode.celse if (S_ISBLK(inode->i_mode))
inode414fs/xiafs/inode.cinode->i_op = &blkdev_inode_operations;
inode415fs/xiafs/inode.celse if (S_ISFIFO(inode->i_mode))
inode416fs/xiafs/inode.cinit_fifo(inode);
inode419fs/xiafs/inode.cstatic struct buffer_head *  xiafs_update_inode(struct inode * inode)
inode426fs/xiafs/inode.cif (IS_RDONLY (inode)) {
inode428fs/xiafs/inode.cinode->i_dirt = 0;
inode432fs/xiafs/inode.cino = inode->i_ino;
inode433fs/xiafs/inode.cif (!ino || ino > inode->i_sb->u.xiafs_sb.s_ninodes) {
inode435fs/xiafs/inode.cinode->i_dirt=0;
inode438fs/xiafs/inode.czone = 1 + inode->i_sb->u.xiafs_sb.s_imap_zones + 
inode439fs/xiafs/inode.cinode->i_sb->u.xiafs_sb.s_zmap_zones +
inode440fs/xiafs/inode.c(ino-1) / XIAFS_INODES_PER_Z(inode->i_sb);
inode441fs/xiafs/inode.cif (!(bh=bread(inode->i_dev, zone, XIAFS_ZSIZE(inode->i_sb)))) {
inode443fs/xiafs/inode.cinode->i_dirt=0;
inode447fs/xiafs/inode.c((ino-1) & (XIAFS_INODES_PER_Z(inode->i_sb) -1));
inode448fs/xiafs/inode.craw_inode->i_mode = inode->i_mode;
inode449fs/xiafs/inode.craw_inode->i_uid = inode->i_uid;
inode450fs/xiafs/inode.craw_inode->i_gid = inode->i_gid;
inode451fs/xiafs/inode.craw_inode->i_nlinks = inode->i_nlink;
inode452fs/xiafs/inode.craw_inode->i_size = inode->i_size;
inode453fs/xiafs/inode.craw_inode->i_atime = inode->i_atime;
inode454fs/xiafs/inode.craw_inode->i_ctime = inode->i_ctime;
inode455fs/xiafs/inode.craw_inode->i_mtime = inode->i_mtime;
inode456fs/xiafs/inode.cif (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
inode457fs/xiafs/inode.craw_inode->i_zone[0] = inode->i_rdev;
inode459fs/xiafs/inode.cXIAFS_PUT_BLOCKS(raw_inode, inode->i_blocks);
inode462fs/xiafs/inode.c| (inode->u.xiafs_i.i_zone[zone] & 0xffffff);
inode464fs/xiafs/inode.c| (inode->u.xiafs_i.i_ind_zone   & 0xffffff);
inode466fs/xiafs/inode.c| (inode->u.xiafs_i.i_dind_zone  & 0xffffff);
inode468fs/xiafs/inode.cinode->i_dirt=0;
inode474fs/xiafs/inode.cvoid xiafs_write_inode(struct inode * inode)
inode477fs/xiafs/inode.cbh = xiafs_update_inode(inode);
inode481fs/xiafs/inode.cint xiafs_sync_inode (struct inode *inode)
inode486fs/xiafs/inode.cbh = xiafs_update_inode(inode);
inode494fs/xiafs/inode.cinode->i_dev, inode->i_ino);
inode57fs/xiafs/namei.cxiafs_find_entry(struct inode * inode, const char * name, int namelen, 
inode65fs/xiafs/namei.cif (!inode)
inode70fs/xiafs/namei.cif (inode->i_size & (XIAFS_ZSIZE(inode->i_sb) - 1)) {
inode74fs/xiafs/namei.czones=inode->i_size >> XIAFS_ZSIZE_BITS(inode->i_sb);
inode76fs/xiafs/namei.cbh = xiafs_bread(inode, i, 0);
inode87fs/xiafs/namei.cwhile ( pos < XIAFS_ZSIZE(inode->i_sb) ) {
inode88fs/xiafs/namei.cif (dep->d_ino > inode->i_sb->u.xiafs_sb.s_ninodes ||
inode90fs/xiafs/namei.cdep->d_rec_len+(char *)dep > bh->b_data+XIAFS_ZSIZE(inode->i_sb) ||
inode107fs/xiafs/namei.cif (pos > XIAFS_ZSIZE(inode->i_sb)) {
inode115fs/xiafs/namei.cint xiafs_lookup(struct inode * dir, const char * name, int len,
inode116fs/xiafs/namei.cstruct inode ** result)
inode153fs/xiafs/namei.cstatic struct buffer_head * xiafs_add_entry(struct inode * dir,
inode240fs/xiafs/namei.cint xiafs_create(struct inode * dir, const char * name, int len, int mode,
inode241fs/xiafs/namei.cstruct inode ** result)
inode243fs/xiafs/namei.cstruct inode * inode;
inode250fs/xiafs/namei.cinode = xiafs_new_inode(dir);
inode251fs/xiafs/namei.cif (!inode) {
inode255fs/xiafs/namei.cinode->i_op = &xiafs_file_inode_operations;
inode256fs/xiafs/namei.cinode->i_mode = mode;
inode257fs/xiafs/namei.cinode->i_dirt = 1;
inode260fs/xiafs/namei.cinode->i_nlink--;
inode261fs/xiafs/namei.cinode->i_dirt = 1;
inode262fs/xiafs/namei.ciput(inode);
inode266fs/xiafs/namei.cde->d_ino = inode->i_ino;
inode270fs/xiafs/namei.c*result = inode;
inode274fs/xiafs/namei.cint xiafs_mknod(struct inode *dir, const char *name, int len, int mode, int rdev)
inode276fs/xiafs/namei.cstruct inode * inode;
inode288fs/xiafs/namei.cinode = xiafs_new_inode(dir);
inode289fs/xiafs/namei.cif (!inode) {
inode293fs/xiafs/namei.cinode->i_uid = current->euid;
inode294fs/xiafs/namei.cinode->i_mode = mode;
inode295fs/xiafs/namei.cinode->i_op = NULL;
inode296fs/xiafs/namei.cif (S_ISREG(inode->i_mode))
inode297fs/xiafs/namei.cinode->i_op = &xiafs_file_inode_operations;
inode298fs/xiafs/namei.celse if (S_ISDIR(inode->i_mode)) {
inode299fs/xiafs/namei.cinode->i_op = &xiafs_dir_inode_operations;
inode301fs/xiafs/namei.cinode->i_mode |= S_ISGID;
inode303fs/xiafs/namei.celse if (S_ISLNK(inode->i_mode))
inode304fs/xiafs/namei.cinode->i_op = &xiafs_symlink_inode_operations;
inode305fs/xiafs/namei.celse if (S_ISCHR(inode->i_mode))
inode306fs/xiafs/namei.cinode->i_op = &chrdev_inode_operations;
inode307fs/xiafs/namei.celse if (S_ISBLK(inode->i_mode))
inode308fs/xiafs/namei.cinode->i_op = &blkdev_inode_operations;
inode309fs/xiafs/namei.celse if (S_ISFIFO(inode->i_mode))
inode310fs/xiafs/namei.cinit_fifo(inode);
inode312fs/xiafs/namei.cinode->i_rdev = rdev;
inode313fs/xiafs/namei.cinode->i_atime = inode->i_ctime = inode->i_atime = CURRENT_TIME;
inode314fs/xiafs/namei.cinode->i_dirt = 1;
inode317fs/xiafs/namei.cinode->i_nlink--;
inode318fs/xiafs/namei.cinode->i_dirt = 1;
inode319fs/xiafs/namei.ciput(inode);
inode323fs/xiafs/namei.cde->d_ino = inode->i_ino;
inode327fs/xiafs/namei.ciput(inode);
inode331fs/xiafs/namei.cint xiafs_mkdir(struct inode * dir, const char * name, int len, int mode)
inode333fs/xiafs/namei.cstruct inode * inode;
inode347fs/xiafs/namei.cinode = xiafs_new_inode(dir);
inode348fs/xiafs/namei.cif (!inode) {
inode352fs/xiafs/namei.cinode->i_op = &xiafs_dir_inode_operations;
inode353fs/xiafs/namei.cinode->i_size = XIAFS_ZSIZE(dir->i_sb);
inode354fs/xiafs/namei.cinode->i_atime = inode->i_ctime = inode->i_mtime = CURRENT_TIME;
inode355fs/xiafs/namei.cdir_block = xiafs_bread(inode,0,1);
inode358fs/xiafs/namei.cinode->i_nlink--;
inode359fs/xiafs/namei.cinode->i_dirt = 1;
inode360fs/xiafs/namei.ciput(inode);
inode364fs/xiafs/namei.cde->d_ino=inode->i_ino;
inode373fs/xiafs/namei.cinode->i_nlink = 2;
inode376fs/xiafs/namei.cinode->i_mode = S_IFDIR | (mode & S_IRWXUGO & ~current->umask);
inode378fs/xiafs/namei.cinode->i_mode |= S_ISGID;
inode379fs/xiafs/namei.cinode->i_dirt = 1;
inode383fs/xiafs/namei.cinode->i_nlink=0;
inode384fs/xiafs/namei.ciput(inode);
inode387fs/xiafs/namei.cde->d_ino = inode->i_ino;
inode392fs/xiafs/namei.ciput(inode);
inode400fs/xiafs/namei.cstatic int empty_dir(struct inode * inode)
inode406fs/xiafs/namei.cif (inode->i_size & (XIAFS_ZSIZE(inode->i_sb)-1) ) {
inode411fs/xiafs/namei.czones=inode->i_size >> XIAFS_ZSIZE_BITS(inode->i_sb);
inode413fs/xiafs/namei.cbh =  xiafs_bread(inode, i, 0);
inode420fs/xiafs/namei.cif (de->d_ino != inode->i_ino || strcmp(".", de->d_name) ||
inode438fs/xiafs/namei.cwhile (offset < XIAFS_ZSIZE(inode->i_sb)) {
inode440fs/xiafs/namei.cif (de->d_ino > inode->i_sb->u.xiafs_sb.s_ninodes ||
inode442fs/xiafs/namei.c(char *)de+de->d_rec_len > bh->b_data+XIAFS_ZSIZE(inode->i_sb) ||
inode480fs/xiafs/namei.cint xiafs_rmdir(struct inode * dir, const char * name, int len)
inode483fs/xiafs/namei.cstruct inode * inode;
inode487fs/xiafs/namei.cinode = NULL;
inode493fs/xiafs/namei.cif (!(inode = iget(dir->i_sb, de->d_ino)))
inode496fs/xiafs/namei.cinode->i_uid != current->euid)
inode498fs/xiafs/namei.cif (inode->i_dev != dir->i_dev)
inode500fs/xiafs/namei.cif (inode == dir)  /* we may not delete ".", but "../dir" is ok */
inode502fs/xiafs/namei.cif (!S_ISDIR(inode->i_mode)) {
inode506fs/xiafs/namei.cif (!empty_dir(inode)) {
inode510fs/xiafs/namei.cif (inode->i_count > 1) {
inode514fs/xiafs/namei.cif (inode->i_nlink != 2)
inode518fs/xiafs/namei.cinode->i_nlink=0;
inode519fs/xiafs/namei.cinode->i_dirt=1;
inode526fs/xiafs/namei.ciput(inode);
inode531fs/xiafs/namei.cint xiafs_unlink(struct inode * dir, const char * name, int len)
inode534fs/xiafs/namei.cstruct inode * inode;
inode540fs/xiafs/namei.cinode = NULL;
inode544fs/xiafs/namei.cif (!(inode = iget(dir->i_sb, de->d_ino)))
inode546fs/xiafs/namei.cif (de->d_ino != inode->i_ino) {
inode547fs/xiafs/namei.ciput(inode);
inode555fs/xiafs/namei.ccurrent->euid != inode->i_uid &&
inode558fs/xiafs/namei.cif (S_ISDIR(inode->i_mode))
inode560fs/xiafs/namei.cif (!inode->i_nlink) {
inode562fs/xiafs/namei.cinode->i_nlink=1;
inode568fs/xiafs/namei.cinode->i_nlink--;
inode569fs/xiafs/namei.cinode->i_dirt = 1;
inode573fs/xiafs/namei.ciput(inode);
inode578fs/xiafs/namei.cint xiafs_symlink(struct inode * dir, const char * name, 
inode582fs/xiafs/namei.cstruct inode * inode = NULL;
inode593fs/xiafs/namei.cif (!(inode = xiafs_new_inode(dir))) {
inode597fs/xiafs/namei.cinode->i_mode = S_IFLNK | S_IRWXUGO;
inode598fs/xiafs/namei.cinode->i_op = &xiafs_symlink_inode_operations;
inode599fs/xiafs/namei.cname_block = xiafs_bread(inode,0,1);
inode602fs/xiafs/namei.cinode->i_nlink--;
inode603fs/xiafs/namei.cinode->i_dirt = 1;
inode604fs/xiafs/namei.ciput(inode);
inode612fs/xiafs/namei.cinode->i_size = i;
inode613fs/xiafs/namei.cinode->i_dirt = 1;
inode616fs/xiafs/namei.cinode->i_nlink--;
inode617fs/xiafs/namei.cinode->i_dirt = 1;
inode618fs/xiafs/namei.ciput(inode);
inode622fs/xiafs/namei.cde->d_ino = inode->i_ino;
inode626fs/xiafs/namei.ciput(inode);
inode630fs/xiafs/namei.cint xiafs_link(struct inode * oldinode, struct inode * dir, 
inode670fs/xiafs/namei.cstatic int subdir(struct inode * new_inode, struct inode * old_inode)
inode707fs/xiafs/namei.cstatic int do_xiafs_rename(struct inode * old_dir, const char * old_name, 
inode708fs/xiafs/namei.cint old_len, struct inode * new_dir, 
inode711fs/xiafs/namei.cstruct inode * old_inode, * new_inode;
inode828fs/xiafs/namei.cint xiafs_rename(struct inode * old_dir, const char * old_name, int old_len,
inode829fs/xiafs/namei.cstruct inode * new_dir, const char * new_name, int new_len)
inode21fs/xiafs/symlink.cxiafs_readlink(struct inode *, char *, int);
inode24fs/xiafs/symlink.cxiafs_follow_link(struct inode *, struct inode *, int, int, struct inode **);
inode47fs/xiafs/symlink.cstatic int xiafs_readlink(struct inode * inode, char * buffer, int buflen)
inode53fs/xiafs/symlink.cif (!S_ISLNK(inode->i_mode)) {
inode54fs/xiafs/symlink.ciput(inode);
inode59fs/xiafs/symlink.cbh = xiafs_bread(inode, 0, 0);
inode60fs/xiafs/symlink.cif (!IS_RDONLY (inode)) {
inode61fs/xiafs/symlink.cinode->i_atime=CURRENT_TIME;
inode62fs/xiafs/symlink.cinode->i_dirt=1;
inode64fs/xiafs/symlink.ciput(inode);
inode75fs/xiafs/symlink.cstatic int xiafs_follow_link(struct inode * dir, struct inode * inode,
inode76fs/xiafs/symlink.cint flag, int mode, struct inode ** res_inode)
inode86fs/xiafs/symlink.cif (!inode) {
inode90fs/xiafs/symlink.cif (!S_ISLNK(inode->i_mode)) {
inode92fs/xiafs/symlink.c*res_inode = inode;
inode95fs/xiafs/symlink.cif (!IS_RDONLY (inode)) {
inode96fs/xiafs/symlink.cinode->i_atime=CURRENT_TIME;
inode97fs/xiafs/symlink.cinode->i_dirt=1;
inode100fs/xiafs/symlink.ciput(inode);
inode104fs/xiafs/symlink.cif (!(bh = xiafs_bread(inode, 0, 0))) {
inode105fs/xiafs/symlink.ciput(inode);
inode109fs/xiafs/symlink.ciput(inode);
inode36fs/xiafs/truncate.c#define DT_ZONE    ((inode->i_size + XIAFS_ZSIZE(inode->i_sb) - 1) \
inode37fs/xiafs/truncate.c>> XIAFS_ZSIZE_BITS(inode->i_sb) )
inode39fs/xiafs/truncate.cstatic int trunc_direct(struct inode * inode)
inode50fs/xiafs/truncate.clp=i + inode->u.xiafs_i.i_zone;
inode53fs/xiafs/truncate.cbh = getblk(inode->i_dev, tmp, XIAFS_ZSIZE(inode->i_sb));
inode62fs/xiafs/truncate.cinode->i_dirt = 1;
inode63fs/xiafs/truncate.cinode->i_blocks-=2 << XIAFS_ZSHIFT(inode->i_sb);
inode64fs/xiafs/truncate.cxiafs_free_zone(inode->i_sb, tmp);
inode71fs/xiafs/truncate.cstatic int trunc_indirect(struct inode * inode, int addr_off, u_long * lp)
inode83fs/xiafs/truncate.cind_bh = bread(inode->i_dev, tmp, XIAFS_ZSIZE(inode->i_sb));
inode93fs/xiafs/truncate.cfor (i = INDT_ZONE<0?0:INDT_ZONE; i < XIAFS_ADDRS_PER_Z(inode->i_sb); i++) {
inode99fs/xiafs/truncate.cbh = getblk(inode->i_dev, tmp, XIAFS_ZSIZE(inode->i_sb));
inode109fs/xiafs/truncate.cinode->i_blocks-= 2 << XIAFS_ZSHIFT(inode->i_sb);
inode110fs/xiafs/truncate.cxiafs_free_zone(inode->i_sb, tmp);
inode115fs/xiafs/truncate.cfor (i = 0; i < XIAFS_ADDRS_PER_Z(inode->i_sb) && !(*indp++); i++) ;
inode116fs/xiafs/truncate.cif (i >= XIAFS_ADDRS_PER_Z(inode->i_sb)) {
inode122fs/xiafs/truncate.cinode->i_blocks-= 2 << XIAFS_ZSHIFT(inode->i_sb);
inode123fs/xiafs/truncate.cxiafs_free_zone(inode->i_sb, tmp);
inode130fs/xiafs/truncate.cstatic int trunc_dindirect(struct inode * inode)
inode134fs/xiafs/truncate.c((DT_ZONE-XIAFS_ADDRS_PER_Z(inode->i_sb)-8)>>XIAFS_ADDRS_PER_Z_BITS(inode->i_sb))
inode141fs/xiafs/truncate.clp = &(inode->u.xiafs_i.i_dind_zone);
inode144fs/xiafs/truncate.cdind_bh = bread(inode->i_dev, tmp, XIAFS_ZSIZE(inode->i_sb));
inode154fs/xiafs/truncate.cfor (i=DINDT_ZONE<0?0:DINDT_ZONE ; i < XIAFS_ADDRS_PER_Z(inode->i_sb) ; i ++) {
inode158fs/xiafs/truncate.cretry |= trunc_indirect(inode, 
inode159fs/xiafs/truncate.c8+((1+i)<<XIAFS_ADDRS_PER_Z_BITS(inode->i_sb)), 
inode164fs/xiafs/truncate.cfor (i = 0; i < XIAFS_ADDRS_PER_Z(inode->i_sb) && !(*dindp++); i++);
inode165fs/xiafs/truncate.cif (i >= XIAFS_ADDRS_PER_Z(inode->i_sb)) {
inode171fs/xiafs/truncate.cinode->i_dirt = 1;
inode172fs/xiafs/truncate.cinode->i_blocks-=2 << XIAFS_ZSHIFT(inode->i_sb);
inode173fs/xiafs/truncate.cxiafs_free_zone(inode->i_sb, tmp);
inode180fs/xiafs/truncate.cvoid xiafs_truncate(struct inode * inode)
inode184fs/xiafs/truncate.cif (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
inode185fs/xiafs/truncate.cS_ISLNK(inode->i_mode)))
inode188fs/xiafs/truncate.cretry = trunc_direct(inode);
inode189fs/xiafs/truncate.cretry |= trunc_indirect(inode, 8, &(inode->u.xiafs_i.i_ind_zone)); 
inode190fs/xiafs/truncate.cretry |= trunc_dindirect(inode);
inode196fs/xiafs/truncate.cinode->i_atime = inode->i_ctime = inode->i_mtime = CURRENT_TIME;
inode197fs/xiafs/truncate.cinode->i_dirt = 1;
inode18include/linux/binfmts.hstruct inode * inode;
inode215include/linux/ext2_fs.hunsigned long  inode;      /* Inode number */
inode237include/linux/ext2_fs.hextern int ext2_permission (struct inode *, int);
inode257include/linux/ext2_fs.hextern int ext2_check_dir_entry (char *, struct inode *,
inode262include/linux/ext2_fs.hextern int ext2_read (struct inode *, struct file *, char *, int);
inode263include/linux/ext2_fs.hextern int ext2_write (struct inode *, struct file *, char *, int);
inode266include/linux/ext2_fs.hextern int ext2_sync_file (struct inode *, struct file *);
inode269include/linux/ext2_fs.hextern struct inode * ext2_new_inode (const struct inode *, int);
inode270include/linux/ext2_fs.hextern void ext2_free_inode (struct inode *);
inode274include/linux/ext2_fs.hextern int ext2_bmap (struct inode *, int);
inode276include/linux/ext2_fs.hextern struct buffer_head * ext2_getblk (struct inode *, int, int, int *);
inode277include/linux/ext2_fs.hextern struct buffer_head * ext2_bread (struct inode *, int, int, int *);
inode283include/linux/ext2_fs.hextern void ext2_read_inode (struct inode *);
inode284include/linux/ext2_fs.hextern void ext2_write_inode (struct inode *);
inode285include/linux/ext2_fs.hextern void ext2_put_inode (struct inode *);
inode287include/linux/ext2_fs.hextern int ext2_sync_inode(struct inode *);
inode290include/linux/ext2_fs.hextern int ext2_ioctl (struct inode *, struct file *, unsigned int,
inode294include/linux/ext2_fs.hextern int ext2_open (struct inode *, struct file *);
inode295include/linux/ext2_fs.hextern void ext2_release (struct inode *, struct file *);
inode296include/linux/ext2_fs.hextern int ext2_lookup (struct inode *,const char *, int, struct inode **);
inode297include/linux/ext2_fs.hextern int ext2_create (struct inode *,const char *, int, int,
inode298include/linux/ext2_fs.hstruct inode **);
inode299include/linux/ext2_fs.hextern int ext2_mkdir (struct inode *, const char *, int, int);
inode300include/linux/ext2_fs.hextern int ext2_rmdir (struct inode *, const char *, int);
inode301include/linux/ext2_fs.hextern int ext2_unlink (struct inode *, const char *, int);
inode302include/linux/ext2_fs.hextern int ext2_symlink (struct inode *, const char *, int, const char *);
inode303include/linux/ext2_fs.hextern int ext2_link (struct inode *, struct inode *, const char *, int);
inode304include/linux/ext2_fs.hextern int ext2_mknod (struct inode *, const char *, int, int, int);
inode305include/linux/ext2_fs.hextern int ext2_rename (struct inode *, const char *, int,
inode306include/linux/ext2_fs.hstruct inode *, const char *, int);
inode309include/linux/ext2_fs.hextern void ext2_truncate (struct 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 *);
inode97include/linux/ext_fs.hextern int ext_sync_inode(struct inode *);
inode98include/linux/ext_fs.hextern int ext_sync_file(struct inode *, struct file *);
inode100include/linux/ext_fs.hextern int ext_lseek(struct inode *, struct file *, off_t, int);
inode101include/linux/ext_fs.hextern int ext_read(struct inode *, struct file *, char *, int);
inode102include/linux/ext_fs.hextern int ext_write(struct inode *, struct file *, char *, int);
inode114include/linux/fs.h#define IS_RDONLY(inode) (((inode)->i_sb) && ((inode)->i_sb->s_flags & MS_RDONLY))
inode115include/linux/fs.h#define IS_NOSUID(inode) ((inode)->i_flags & MS_NOSUID)
inode116include/linux/fs.h#define IS_NODEV(inode) ((inode)->i_flags & MS_NODEV)
inode117include/linux/fs.h#define IS_NOEXEC(inode) ((inode)->i_flags & MS_NOEXEC)
inode118include/linux/fs.h#define IS_SYNC(inode) ((inode)->i_flags & MS_SYNC)
inode194include/linux/fs.hstruct inode * i_next, * i_prev;
inode195include/linux/fs.hstruct inode * i_hash_next, * i_hash_prev;
inode196include/linux/fs.hstruct inode * i_bound_to, * i_bound_by;
inode225include/linux/fs.hstruct inode * f_inode;
inode258include/linux/fs.hstruct inode * s_covered;
inode259include/linux/fs.hstruct inode * s_mounted;
inode273include/linux/fs.hint (*lseek) (struct inode *, struct file *, off_t, int);
inode274include/linux/fs.hint (*read) (struct inode *, struct file *, char *, int);
inode275include/linux/fs.hint (*write) (struct inode *, struct file *, char *, int);
inode276include/linux/fs.hint (*readdir) (struct inode *, struct file *, struct dirent *, int);
inode277include/linux/fs.hint (*select) (struct inode *, struct file *, int, select_table *);
inode278include/linux/fs.hint (*ioctl) (struct inode *, struct file *, unsigned int, unsigned long);
inode279include/linux/fs.hint (*mmap) (struct inode *, struct file *, unsigned long, size_t, int, unsigned long);
inode280include/linux/fs.hint (*open) (struct inode *, struct file *);
inode281include/linux/fs.hvoid (*release) (struct inode *, struct file *);
inode282include/linux/fs.hint (*fsync) (struct inode *, struct file *);
inode287include/linux/fs.hint (*create) (struct inode *,const char *,int,int,struct inode **);
inode288include/linux/fs.hint (*lookup) (struct inode *,const char *,int,struct inode **);
inode289include/linux/fs.hint (*link) (struct inode *,struct inode *,const char *,int);
inode290include/linux/fs.hint (*unlink) (struct inode *,const char *,int);
inode291include/linux/fs.hint (*symlink) (struct inode *,const char *,int,const char *);
inode292include/linux/fs.hint (*mkdir) (struct inode *,const char *,int,int);
inode293include/linux/fs.hint (*rmdir) (struct inode *,const char *,int);
inode294include/linux/fs.hint (*mknod) (struct inode *,const char *,int,int,int);
inode295include/linux/fs.hint (*rename) (struct inode *,const char *,int,struct inode *,const char *,int);
inode296include/linux/fs.hint (*readlink) (struct inode *,char *,int);
inode297include/linux/fs.hint (*follow_link) (struct inode *,struct inode *,int,int,struct inode **);
inode298include/linux/fs.hint (*bmap) (struct inode *,int);
inode299include/linux/fs.hvoid (*truncate) (struct inode *);
inode300include/linux/fs.hint (*permission) (struct inode *, int);
inode304include/linux/fs.hvoid (*read_inode) (struct inode *);
inode305include/linux/fs.hint (*notify_change) (int flags, struct inode *);
inode306include/linux/fs.hvoid (*write_inode) (struct inode *);
inode307include/linux/fs.hvoid (*put_inode) (struct inode *);
inode329include/linux/fs.hextern int blkdev_open(struct inode * inode, struct file * filp);
inode334include/linux/fs.hextern int chrdev_open(struct inode * inode, struct file * filp);
inode338include/linux/fs.hextern void init_fifo(struct inode * inode);
inode348include/linux/fs.hextern int fs_may_umount(dev_t dev, struct inode * mount_root);
inode370include/linux/fs.hextern int bmap(struct inode * inode,int block);
inode371include/linux/fs.hextern int notify_change(int flags, struct inode * inode);
inode372include/linux/fs.hextern int namei(const char * pathname, struct inode ** res_inode);
inode373include/linux/fs.hextern int lnamei(const char * pathname, struct inode ** res_inode);
inode374include/linux/fs.hextern int permission(struct inode * inode,int mask);
inode376include/linux/fs.hstruct inode ** res_inode, struct inode * base);
inode378include/linux/fs.hextern void iput(struct inode * inode);
inode379include/linux/fs.hextern struct inode * iget(struct super_block * sb,int nr);
inode380include/linux/fs.hextern struct inode * get_empty_inode(void);
inode381include/linux/fs.hextern void insert_inode_hash(struct inode *);
inode382include/linux/fs.hextern void clear_inode(struct inode *);
inode383include/linux/fs.hextern struct inode * get_pipe_inode(void);
inode400include/linux/fs.hextern int char_read(struct inode *, struct file *, char *, int);
inode401include/linux/fs.hextern int block_read(struct inode *, struct file *, char *, int);
inode404include/linux/fs.hextern int char_write(struct inode *, struct file *, char *, int);
inode405include/linux/fs.hextern int block_write(struct inode *, struct file *, char *, int);
inode407include/linux/fs.hextern int generic_mmap(struct inode *, struct file *, unsigned long, size_t, int, unsigned long);
inode409include/linux/fs.hextern int block_fsync(struct inode *, struct file *);
inode410include/linux/fs.hextern int file_fsync(struct inode *, struct file *);
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 *);
inode167include/linux/iso_fs.hextern int isofs_open(struct inode * inode, struct file * filp);
inode168include/linux/iso_fs.hextern void isofs_release(struct inode * inode, struct file * filp);
inode169include/linux/iso_fs.hextern int isofs_lookup(struct inode * dir,const char * name, int len,
inode170include/linux/iso_fs.hstruct inode ** result);
inode174include/linux/iso_fs.hextern int isofs_bmap(struct inode *,int);
inode178include/linux/iso_fs.hextern void isofs_read_inode(struct inode *);
inode179include/linux/iso_fs.hextern void isofs_put_inode(struct inode *);
inode182include/linux/iso_fs.hextern int isofs_lseek(struct inode *, struct file *, off_t, int);
inode183include/linux/iso_fs.hextern int isofs_read(struct inode *, struct file *, char *, int);
inode184include/linux/iso_fs.hextern int isofs_lookup_grandparent(struct inode *, int);
inode71include/linux/minix_fs.hunsigned short inode;
inode75include/linux/minix_fs.hextern int minix_lookup(struct inode * dir,const char * name, int len,
inode76include/linux/minix_fs.hstruct inode ** result);
inode77include/linux/minix_fs.hextern int minix_create(struct inode * dir,const char * name, int len, int mode,
inode78include/linux/minix_fs.hstruct inode ** result);
inode79include/linux/minix_fs.hextern int minix_mkdir(struct inode * dir, const char * name, int len, int mode);
inode80include/linux/minix_fs.hextern int minix_rmdir(struct inode * dir, const char * name, int len);
inode81include/linux/minix_fs.hextern int minix_unlink(struct inode * dir, const char * name, int len);
inode82include/linux/minix_fs.hextern int minix_symlink(struct inode * inode, const char * name, int len,
inode84include/linux/minix_fs.hextern int minix_link(struct inode * oldinode, struct inode * dir, const char * name, int len);
inode85include/linux/minix_fs.hextern int minix_mknod(struct inode * dir, const char * name, int len, int mode, int rdev);
inode86include/linux/minix_fs.hextern int minix_rename(struct inode * old_dir, const char * old_name, int old_len,
inode87include/linux/minix_fs.hstruct inode * new_dir, const char * new_name, int new_len);
inode88include/linux/minix_fs.hextern struct inode * minix_new_inode(const struct inode * dir);
inode89include/linux/minix_fs.hextern void minix_free_inode(struct inode * inode);
inode95include/linux/minix_fs.hextern int minix_bmap(struct inode *,int);
inode97include/linux/minix_fs.hextern struct buffer_head * minix_getblk(struct inode *, int, int);
inode98include/linux/minix_fs.hextern struct buffer_head * minix_bread(struct inode *, int, int);
inode100include/linux/minix_fs.hextern void minix_truncate(struct inode *);
inode103include/linux/minix_fs.hextern void minix_read_inode(struct inode *);
inode104include/linux/minix_fs.hextern void minix_write_inode(struct inode *);
inode105include/linux/minix_fs.hextern void minix_put_inode(struct inode *);
inode107include/linux/minix_fs.hextern int minix_sync_inode(struct inode *);
inode108include/linux/minix_fs.hextern int minix_sync_file(struct inode *, struct file *);
inode30include/linux/mm.hstruct inode * vm_inode;
inode132include/linux/msdos_fs.hextern int msdos_add_cluster(struct inode *inode);
inode136include/linux/msdos_fs.hextern int msdos_get_entry(struct inode *dir,off_t *pos,struct buffer_head **bh,
inode138include/linux/msdos_fs.hextern int msdos_scan(struct inode *dir,char *name,struct buffer_head **res_bh,
inode140include/linux/msdos_fs.hextern int msdos_parent_ino(struct inode *dir,int locked);
inode141include/linux/msdos_fs.hextern int msdos_subdirs(struct inode *dir);
inode146include/linux/msdos_fs.hextern int msdos_smap(struct inode *inode,int sector);
inode147include/linux/msdos_fs.hextern int fat_free(struct inode *inode,int skip);
inode149include/linux/msdos_fs.hvoid cache_lookup(struct inode *inode,int cluster,int *f_clu,int *d_clu);
inode150include/linux/msdos_fs.hvoid cache_add(struct inode *inode,int f_clu,int d_clu);
inode151include/linux/msdos_fs.hvoid cache_inval_inode(struct inode *inode);
inode153include/linux/msdos_fs.hint get_cluster(struct inode *inode,int cluster);
inode157include/linux/msdos_fs.hextern int msdos_lookup(struct inode *dir,const char *name,int len,
inode158include/linux/msdos_fs.hstruct inode **result);
inode159include/linux/msdos_fs.hextern int msdos_create(struct inode *dir,const char *name,int len,int mode,
inode160include/linux/msdos_fs.hstruct inode **result);
inode161include/linux/msdos_fs.hextern int msdos_mkdir(struct inode *dir,const char *name,int len,int mode);
inode162include/linux/msdos_fs.hextern int msdos_rmdir(struct inode *dir,const char *name,int len);
inode163include/linux/msdos_fs.hextern int msdos_unlink(struct inode *dir,const char *name,int len);
inode164include/linux/msdos_fs.hextern int msdos_rename(struct inode *old_dir,const char *old_name,int old_len,
inode165include/linux/msdos_fs.hstruct inode *new_dir,const char *new_name,int new_len);
inode169include/linux/msdos_fs.hextern void msdos_put_inode(struct inode *inode);
inode174include/linux/msdos_fs.hextern int msdos_bmap(struct inode *inode,int block);
inode175include/linux/msdos_fs.hextern void msdos_read_inode(struct inode *inode);
inode176include/linux/msdos_fs.hextern void msdos_write_inode(struct inode *inode);
inode177include/linux/msdos_fs.hextern int msdos_notify_change(int flags,struct inode *inode);
inode188include/linux/msdos_fs.hextern void msdos_truncate(struct inode *inode);
inode13include/linux/msdos_fs_i.hstruct inode *i_depend; /* pointer to inode that depends on the
inode15include/linux/msdos_fs_i.hstruct inode *i_old;  /* pointer to the old inode this inode
inode82include/linux/net.h#define SOCK_INODE(S)  ((struct inode *)(S)->dummy)
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)
inode103include/linux/nfs_fs.hextern struct inode *nfs_fhget(struct super_block *sb, struct nfs_fh *fhandle,
inode105include/linux/nfs_fs.hextern void nfs_refresh_inode(struct inode *inode, struct nfs_fattr *fattr);
inode121include/linux/nfs_fs.hextern int nfs_mmap(struct inode * inode, struct file * file,
inode16include/linux/pipe_fs_i.h#define PIPE_READ_WAIT(inode)  ((inode).u.pipe_i.read_wait)
inode17include/linux/pipe_fs_i.h#define PIPE_WRITE_WAIT(inode)  ((inode).u.pipe_i.write_wait)
inode18include/linux/pipe_fs_i.h#define PIPE_BASE(inode)  ((inode).u.pipe_i.base)
inode19include/linux/pipe_fs_i.h#define PIPE_HEAD(inode)  ((inode).u.pipe_i.head)
inode20include/linux/pipe_fs_i.h#define PIPE_TAIL(inode)  ((inode).u.pipe_i.tail)
inode21include/linux/pipe_fs_i.h#define PIPE_RD_OPENERS(inode)  ((inode).u.pipe_i.rd_openers)
inode22include/linux/pipe_fs_i.h#define PIPE_WR_OPENERS(inode)  ((inode).u.pipe_i.wr_openers)
inode23include/linux/pipe_fs_i.h#define PIPE_READERS(inode)  ((inode).u.pipe_i.readers)
inode24include/linux/pipe_fs_i.h#define PIPE_WRITERS(inode)  ((inode).u.pipe_i.writers)
inode25include/linux/pipe_fs_i.h#define PIPE_SIZE(inode)  ((PIPE_HEAD(inode)-PIPE_TAIL(inode))&(PAGE_SIZE-1))
inode26include/linux/pipe_fs_i.h#define PIPE_EMPTY(inode)  (PIPE_HEAD(inode)==PIPE_TAIL(inode))
inode27include/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 *);
inode203include/linux/sched.hstruct inode * pwd;
inode204include/linux/sched.hstruct inode * root;
inode205include/linux/sched.hstruct inode * executable;
inode366include/linux/tty.hextern int tty_ioctl(struct inode *, struct file *, unsigned int, unsigned long);
inode115include/linux/xd.hstatic int xd_open (struct inode *inode,struct file *file);
inode117include/linux/xd.hstatic int xd_ioctl (struct inode *inode,struct file *file,unsigned int cmd,unsigned long arg);
inode118include/linux/xd.hstatic void xd_release (struct inode *inode,struct file *file);
inode65include/linux/xia_fs.hextern int xiafs_lookup(struct inode * dir,const char * name, int len, 
inode66include/linux/xia_fs.hstruct inode ** result);
inode67include/linux/xia_fs.hextern int xiafs_create(struct inode * dir,const char * name, int len, int mode,
inode68include/linux/xia_fs.hstruct inode ** result);
inode69include/linux/xia_fs.hextern int xiafs_mkdir(struct inode * dir, const char * name, int len, int mode);
inode70include/linux/xia_fs.hextern int xiafs_rmdir(struct inode * dir, const char * name, int len);
inode71include/linux/xia_fs.hextern int xiafs_unlink(struct inode * dir, const char * name, int len);
inode72include/linux/xia_fs.hextern int xiafs_symlink(struct inode * inode, const char * name, int len,
inode74include/linux/xia_fs.hextern int xiafs_link(struct inode * oldinode, struct inode * dir, 
inode76include/linux/xia_fs.hextern int xiafs_mknod(struct inode * dir, const char * name, int len, 
inode78include/linux/xia_fs.hextern int xiafs_rename(struct inode * old_dir, const char * old_name, 
inode79include/linux/xia_fs.hint old_len, struct inode * new_dir, 
inode81include/linux/xia_fs.hextern struct inode * xiafs_new_inode(struct inode * dir);
inode82include/linux/xia_fs.hextern void xiafs_free_inode(struct inode * inode);
inode88include/linux/xia_fs.hextern int xiafs_bmap(struct inode *,int);
inode90include/linux/xia_fs.hextern struct buffer_head * xiafs_getblk(struct inode *, int, int);
inode91include/linux/xia_fs.hextern struct buffer_head * xiafs_bread(struct inode *, int, int);
inode93include/linux/xia_fs.hextern void xiafs_truncate(struct inode *);
inode96include/linux/xia_fs.hextern void xiafs_read_inode(struct inode *);
inode97include/linux/xia_fs.hextern void xiafs_write_inode(struct inode *);
inode98include/linux/xia_fs.hextern void xiafs_put_inode(struct inode *);
inode100include/linux/xia_fs.hextern int xiafs_sync_inode(struct inode *);
inode101include/linux/xia_fs.hextern int xiafs_sync_file(struct inode *, struct file *);
inode99kernel/blk_drv/cdu31a.cstatic int scd_open(struct inode *inode, struct file *filp);
inode1132kernel/blk_drv/cdu31a.cscd_ioctl(struct inode *inode,
inode1144kernel/blk_drv/cdu31a.cif (!inode)
inode1148kernel/blk_drv/cdu31a.cdev = MINOR(inode->i_rdev) >> 6;
inode1449kernel/blk_drv/cdu31a.cscd_open(struct inode *inode,
inode1498kernel/blk_drv/cdu31a.cif (inode)
inode1500kernel/blk_drv/cdu31a.ccheck_disk_change(inode->i_rdev);
inode1514kernel/blk_drv/cdu31a.cscd_release(struct inode *inode,
inode1527kernel/blk_drv/cdu31a.csync_dev(inode->i_rdev);
inode1106kernel/blk_drv/floppy.cstatic int fd_ioctl(struct inode *inode, struct file *filp, unsigned int cmd,
inode1113kernel/blk_drv/floppy.cRO_IOCTLS(inode->i_rdev,param);
inode1115kernel/blk_drv/floppy.cdrive = MINOR(inode->i_rdev);
inode1172kernel/blk_drv/floppy.cif (!permission(inode, 2))
inode1177kernel/blk_drv/floppy.ccheck_disk_change(inode->i_rdev);
inode1268kernel/blk_drv/floppy.cstatic int floppy_open(struct inode * inode, struct file * filp)
inode1273kernel/blk_drv/floppy.cdrive = inode->i_rdev & 3;
inode1276kernel/blk_drv/floppy.cif (old_dev != inode->i_rdev)
inode1279kernel/blk_drv/floppy.cfd_device[drive] = inode->i_rdev;
inode1281kernel/blk_drv/floppy.cif (old_dev && old_dev != inode->i_rdev)
inode1284kernel/blk_drv/floppy.ccheck_disk_change(inode->i_rdev);
inode1288kernel/blk_drv/floppy.cstatic void floppy_release(struct inode * inode, struct file * filp)
inode1290kernel/blk_drv/floppy.csync_dev(inode->i_rdev);
inode1291kernel/blk_drv/floppy.cif (!fd_ref[inode->i_rdev & 3]--) {
inode1293kernel/blk_drv/floppy.cfd_ref[inode->i_rdev & 3] = 0;
inode525kernel/blk_drv/hd.cstatic int hd_ioctl(struct inode * inode, struct file * file,
inode531kernel/blk_drv/hd.cif (!inode)
inode533kernel/blk_drv/hd.cdev = MINOR(inode->i_rdev) >> 6;
inode548kernel/blk_drv/hd.cput_fs_long(hd[MINOR(inode->i_rdev)].start_sect,
inode556kernel/blk_drv/hd.cput_fs_long(hd[MINOR(inode->i_rdev)].nr_sects,
inode561kernel/blk_drv/hd.cif(!inode->i_rdev) return -EINVAL;
inode562kernel/blk_drv/hd.csync_dev(inode->i_rdev);
inode563kernel/blk_drv/hd.cinvalidate_buffers(inode->i_rdev);
inode567kernel/blk_drv/hd.creturn revalidate_hddisk(inode->i_rdev, 1);
inode568kernel/blk_drv/hd.cRO_IOCTLS(inode->i_rdev,arg);
inode574kernel/blk_drv/hd.cstatic int hd_open(struct inode * inode, struct file * filp)
inode577kernel/blk_drv/hd.ctarget =  DEVICE_NR(MINOR(inode->i_rdev));
inode589kernel/blk_drv/hd.cstatic void hd_release(struct inode * inode, struct file * file)
inode592kernel/blk_drv/hd.csync_dev(inode->i_rdev);
inode594kernel/blk_drv/hd.ctarget =  DEVICE_NR(MINOR(inode->i_rdev));
inode170kernel/blk_drv/mcd.cmcd_ioctl(struct inode *ip, struct file *fp, unsigned int cmd,
inode725kernel/blk_drv/mcd.cmcd_open(struct inode *ip, struct file *fp)
inode754kernel/blk_drv/mcd.cmcd_release(struct inode * inode, struct file * file)
inode757kernel/blk_drv/mcd.csync_dev(inode->i_rdev);
inode758kernel/blk_drv/mcd.cinvalidate_buffers(inode -> i_rdev);
inode55kernel/blk_drv/scsi/sd.cextern int sd_ioctl(struct inode *, struct file *, unsigned int, unsigned long);
inode61kernel/blk_drv/scsi/sd.cstatic int sd_open(struct inode * inode, struct file * filp)
inode64kernel/blk_drv/scsi/sd.ctarget =  DEVICE_NR(MINOR(inode->i_rdev));
inode75kernel/blk_drv/scsi/sd.ccheck_disk_change(inode->i_rdev);
inode78kernel/blk_drv/scsi/sd.csd_ioctl(inode, NULL, SCSI_IOCTL_DOORLOCK, 0);
inode84kernel/blk_drv/scsi/sd.cstatic void sd_release(struct inode * inode, struct file * file)
inode87kernel/blk_drv/scsi/sd.csync_dev(inode->i_rdev);
inode89kernel/blk_drv/scsi/sd.ctarget =  DEVICE_NR(MINOR(inode->i_rdev));
inode95kernel/blk_drv/scsi/sd.csd_ioctl(inode, NULL, SCSI_IOCTL_DOORUNLOCK, 0);
inode621kernel/blk_drv/scsi/sd.cstruct inode inode;
inode632kernel/blk_drv/scsi/sd.cinode.i_rdev = full_dev;  /* This is all we really need here */
inode633kernel/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 int cmd, unsigned long arg)
inode19kernel/blk_drv/scsi/sd_ioctl.cint dev = inode->i_rdev;
inode44kernel/blk_drv/scsi/sd_ioctl.cput_fs_long(sd[MINOR(inode->i_rdev)].start_sect,
inode52kernel/blk_drv/scsi/sd_ioctl.cput_fs_long(sd[MINOR(inode->i_rdev)].nr_sects,
inode57kernel/blk_drv/scsi/sd_ioctl.cif(!inode->i_rdev) return -EINVAL;
inode58kernel/blk_drv/scsi/sd_ioctl.csync_dev(inode->i_rdev);
inode59kernel/blk_drv/scsi/sd_ioctl.cinvalidate_buffers(inode->i_rdev);
inode42kernel/blk_drv/scsi/sr.cstatic int sr_open(struct inode *, struct file *);
inode45kernel/blk_drv/scsi/sr.cextern int sr_ioctl(struct inode *, struct file *, unsigned int, unsigned long);
inode49kernel/blk_drv/scsi/sr.cstatic void sr_release(struct inode * inode, struct file * file)
inode51kernel/blk_drv/scsi/sr.csync_dev(inode->i_rdev);
inode52kernel/blk_drv/scsi/sr.cif(! --scsi_CDs[MINOR(inode->i_rdev)].device->access_count)
inode53kernel/blk_drv/scsi/sr.csr_ioctl(inode, NULL, SCSI_IOCTL_DOORUNLOCK, 0);
inode82kernel/blk_drv/scsi/sr.cstruct inode inode;
inode91kernel/blk_drv/scsi/sr.cinode.i_rdev = full_dev;  /* This is all we really need here */
inode92kernel/blk_drv/scsi/sr.cretval = sr_ioctl(&inode, NULL, SCSI_IOCTL_TEST_UNIT_READY, 0);
inode259kernel/blk_drv/scsi/sr.cstatic int sr_open(struct inode * inode, struct file * filp)
inode261kernel/blk_drv/scsi/sr.cif(MINOR(inode->i_rdev) >= NR_SR || 
inode262kernel/blk_drv/scsi/sr.c!scsi_CDs[MINOR(inode->i_rdev)].device) return -ENODEV;   /* No such device */
inode264kernel/blk_drv/scsi/sr.ccheck_disk_change(inode->i_rdev);
inode266kernel/blk_drv/scsi/sr.cif(!scsi_CDs[MINOR(inode->i_rdev)].device->access_count++)
inode267kernel/blk_drv/scsi/sr.csr_ioctl(inode, NULL, SCSI_IOCTL_DOORLOCK, 0);
inode274kernel/blk_drv/scsi/sr.cif(scsi_CDs[MINOR(inode->i_rdev)].needs_sector_size)
inode275kernel/blk_drv/scsi/sr.cget_sectorsize(MINOR(inode->i_rdev));
inode92kernel/blk_drv/scsi/sr_ioctl.cint sr_ioctl(struct inode * inode, struct file * file, unsigned int cmd, unsigned long arg)
inode96kernel/blk_drv/scsi/sr_ioctl.cint dev = inode->i_rdev;
inode248kernel/blk_drv/scsi/sr_ioctl.csr_ioctl (inode, NULL, SCSI_IOCTL_DOORUNLOCK, 0);
inode96kernel/blk_drv/scsi/st.cstatic int st_int_ioctl(struct inode * inode,struct file * file,
inode239kernel/blk_drv/scsi/st.cstatic int flush_buffer(struct inode * inode, struct file * filp,
inode245kernel/blk_drv/scsi/st.cdev = MINOR(inode->i_rdev) & 127;
inode261kernel/blk_drv/scsi/st.cresult = st_int_ioctl(inode, filp, MTBSR, backspace);
inode273kernel/blk_drv/scsi/st.cstatic int scsi_tape_open(struct inode * inode, struct file * filp)
inode281kernel/blk_drv/scsi/st.cdev = MINOR(inode->i_rdev) & 127;
inode469kernel/blk_drv/scsi/st.cstatic void scsi_tape_close(struct inode * inode, struct file * filp)
inode477kernel/blk_drv/scsi/st.cdev = MINOR(inode->i_rdev);
inode518kernel/blk_drv/scsi/st.cst_int_ioctl(inode, filp, MTBSF, 1); /* Back over the EOF hit */
inode520kernel/blk_drv/scsi/st.cflush_buffer(inode, filp, 0);
inode525kernel/blk_drv/scsi/st.cst_int_ioctl(inode, filp, MTREW, 1);
inode535kernel/blk_drv/scsi/st.cint st_write(struct inode * inode, struct file * filp, char * buf, int count)
inode543kernel/blk_drv/scsi/st.cdev = MINOR(inode->i_rdev) & 127;
inode558kernel/blk_drv/scsi/st.cretval = flush_buffer(inode, filp, 0);
inode699kernel/blk_drv/scsi/st.cint st_read(struct inode * inode, struct file * filp, char * buf, int count)
inode707kernel/blk_drv/scsi/st.cdev = MINOR(inode->i_rdev) & 127;
inode719kernel/blk_drv/scsi/st.ctransfer = flush_buffer(inode, filp, 0);
inode883kernel/blk_drv/scsi/st.cstatic int st_int_ioctl(struct inode * inode,struct file * file,
inode886kernel/blk_drv/scsi/st.cint dev = MINOR(inode->i_rdev);
inode1107kernel/blk_drv/scsi/st.cioctl_result = st_int_ioctl(inode, file, MTFSF, 1);
inode1109kernel/blk_drv/scsi/st.cioctl_result = st_int_ioctl(inode, file, MTBSF, 1);
inode1145kernel/blk_drv/scsi/st.cstatic int st_ioctl(struct inode * inode,struct file * file,
inode1148kernel/blk_drv/scsi/st.cint dev = MINOR(inode->i_rdev);
inode1175kernel/blk_drv/scsi/st.ci = flush_buffer(inode, file, mtc.mt_op == MTSEEK ||
inode1181kernel/blk_drv/scsi/st.creturn st_int_ioctl(inode, file, mtc.mt_op, mtc.mt_count);
inode1202kernel/blk_drv/scsi/st.ci = flush_buffer(inode, file, 0);
inode153kernel/blk_drv/xd.cstatic int xd_open (struct inode *inode,struct file *file)
inode155kernel/blk_drv/xd.cint dev = DEVICE_NR(MINOR(inode->i_rdev));
inode196kernel/blk_drv/xd.cstatic int xd_ioctl (struct inode *inode,struct file *file,u_int cmd,u_long arg)
inode199kernel/blk_drv/xd.cint dev = DEVICE_NR(MINOR(inode->i_rdev)),err;
inode201kernel/blk_drv/xd.cif (inode && (dev < xd_drives))
inode209kernel/blk_drv/xd.cput_fs_long(xd[MINOR(inode->i_rdev)].start_sect,(long *) &geometry->start);
inode217kernel/blk_drv/xd.cput_fs_long(xd[MINOR(inode->i_rdev)].nr_sects,(long *) arg);
inode224kernel/blk_drv/xd.cif(!inode->i_rdev) return -EINVAL;
inode225kernel/blk_drv/xd.csync_dev(inode->i_rdev);
inode226kernel/blk_drv/xd.cinvalidate_buffers(inode->i_rdev);
inode229kernel/blk_drv/xd.ccase BLKRRPART:    return (xd_reread_partitions(inode->i_rdev));
inode230kernel/blk_drv/xd.cRO_IOCTLS(inode->i_rdev,arg);
inode236kernel/blk_drv/xd.cstatic void xd_release (struct inode *inode, struct file *file)
inode238kernel/blk_drv/xd.cint dev = DEVICE_NR(MINOR(inode->i_rdev));
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)
inode69kernel/chr_drv/busmouse.cstatic void release_mouse(struct inode * inode, struct file * file)
inode77kernel/chr_drv/busmouse.cstatic int open_mouse(struct inode * inode, struct file * file)
inode97kernel/chr_drv/busmouse.cstatic int write_mouse(struct inode * inode, struct file * file, char * buffer, int count)
inode102kernel/chr_drv/busmouse.cstatic int read_mouse(struct inode * inode, struct file * file, char * buffer, int count)
inode131kernel/chr_drv/busmouse.cstatic int mouse_select(struct inode *inode, struct file *file, int sel_type, select_table * wait)
inode122kernel/chr_drv/lp.cstatic int lp_write_interrupt(struct inode * inode, struct file * file, char * buf, int count)
inode124kernel/chr_drv/lp.cunsigned int minor = MINOR(inode->i_rdev);
inode189kernel/chr_drv/lp.cstatic int lp_write_polled(struct inode * inode, struct file * file,
inode193kernel/chr_drv/lp.cunsigned int minor = MINOR(inode->i_rdev);
inode263kernel/chr_drv/lp.cstatic int lp_write(struct inode * inode, struct file * file, char * buf, int count)
inode265kernel/chr_drv/lp.cif (LP_IRQ(MINOR(inode->i_rdev)))
inode266kernel/chr_drv/lp.creturn lp_write_interrupt(inode, file, buf, count);
inode268kernel/chr_drv/lp.creturn lp_write_polled(inode, file, buf, count);
inode271kernel/chr_drv/lp.cstatic int lp_lseek(struct inode * inode, struct file * file,
inode277kernel/chr_drv/lp.cstatic int lp_open(struct inode * inode, struct file * file)
inode279kernel/chr_drv/lp.cunsigned int minor = MINOR(inode->i_rdev);
inode314kernel/chr_drv/lp.cstatic void lp_release(struct inode * inode, struct file * file)
inode316kernel/chr_drv/lp.cunsigned int minor = MINOR(inode->i_rdev);
inode329kernel/chr_drv/lp.cstatic int lp_ioctl(struct inode *inode, struct file *file,
inode332kernel/chr_drv/lp.cunsigned int minor = MINOR(inode->i_rdev);
inode24kernel/chr_drv/mem.cstatic int read_ram(struct inode * inode, struct file * file,char * buf, int count)
inode29kernel/chr_drv/mem.cstatic int write_ram(struct inode * inode, struct file * file,char * buf, int count)
inode34kernel/chr_drv/mem.cstatic int read_core(struct inode * inode, struct file * file,char * buf, int count)
inode79kernel/chr_drv/mem.cstatic int read_mem(struct inode * inode, struct file * file,char * buf, int count)
inode104kernel/chr_drv/mem.cstatic int write_mem(struct inode * inode, struct file * file,char * buf, int count)
inode129kernel/chr_drv/mem.cstatic int mmap_mem(struct inode * inode, struct file * file,
inode141kernel/chr_drv/mem.cstatic int read_port(struct inode * inode,struct file * file,char * buf, int count)
inode155kernel/chr_drv/mem.cstatic int write_port(struct inode * inode,struct file * file,char * buf, int count)
inode169kernel/chr_drv/mem.cstatic int read_null(struct inode * node,struct file * file,char * buf,int count)
inode174kernel/chr_drv/mem.cstatic int write_null(struct inode * inode,struct file * file,char * buf, int count)
inode179kernel/chr_drv/mem.cstatic int read_zero(struct inode * node,struct file * file,char * buf,int count)
inode190kernel/chr_drv/mem.cstatic int write_zero(struct inode * inode,struct file * file,char * buf, int count)
inode195kernel/chr_drv/mem.cstatic int mmap_zero(struct inode * inode, struct file * file,
inode213kernel/chr_drv/mem.cstatic int memory_lseek(struct inode * inode, struct file * file, off_t offset, int orig)
inode324kernel/chr_drv/mem.cstatic int memory_open(struct inode * inode, struct file * filp)
inode326kernel/chr_drv/mem.cswitch (MINOR(inode->i_rdev)) {
inode352kernel/chr_drv/mem.creturn filp->f_op->open(inode,filp);
inode37kernel/chr_drv/mouse.cstatic int mouse_open(struct inode * inode, struct file * file)
inode39kernel/chr_drv/mouse.cint minor = MINOR(inode->i_rdev);
inode65kernel/chr_drv/mouse.creturn file->f_op->open(inode,file);
inode74kernel/chr_drv/msbusmouse.cstatic void release_mouse(struct inode * inode, struct file * file)
inode81kernel/chr_drv/msbusmouse.cstatic int open_mouse(struct inode * inode, struct file * file)
inode100kernel/chr_drv/msbusmouse.cstatic int write_mouse(struct inode * inode, struct file * file, char * buffer, int count)
inode105kernel/chr_drv/msbusmouse.cstatic int read_mouse(struct inode * inode, struct file * file, char * buffer, int count)
inode126kernel/chr_drv/msbusmouse.cstatic int mouse_select(struct inode *inode, struct file *file, int sel_type, select_table * wait)
inode161kernel/chr_drv/psaux.cstatic void release_aux(struct inode * inode, struct file * file)
inode178kernel/chr_drv/psaux.cstatic int open_aux(struct inode * inode, struct file * file)
inode202kernel/chr_drv/psaux.cstatic int write_aux(struct inode * inode, struct file * file, char * buffer, int count)
inode214kernel/chr_drv/psaux.cinode->i_mtime = CURRENT_TIME;
inode223kernel/chr_drv/psaux.cstatic int read_aux(struct inode * inode, struct file * file, char * buffer, int count)
inode249kernel/chr_drv/psaux.cinode->i_atime = CURRENT_TIME;
inode258kernel/chr_drv/psaux.cstatic int aux_select(struct inode *inode, struct file *file, int sel_type, select_table * wait)
inode1769kernel/chr_drv/tpqic02.cstatic int tape_qic02_lseek(struct inode * inode, struct file * file, off_t offset, int origin)
inode1807kernel/chr_drv/tpqic02.cstatic int tape_qic02_read(struct inode * inode, struct file * filp, char * buf, int count)
inode1810kernel/chr_drv/tpqic02.cdev_t dev = inode->i_rdev;
inode1977kernel/chr_drv/tpqic02.cstatic int tape_qic02_write(struct inode * inode, struct file * filp, char * buf, int count)
inode1980kernel/chr_drv/tpqic02.cdev_t dev = inode->i_rdev;
inode2124kernel/chr_drv/tpqic02.cstatic int tape_qic02_open(struct inode * inode, struct file * filp)
inode2126kernel/chr_drv/tpqic02.cdev_t dev = inode->i_rdev;
inode2281kernel/chr_drv/tpqic02.cstatic int tape_qic02_readdir(struct inode * inode, struct file * filp, struct dirent * dp, int count)
inode2287kernel/chr_drv/tpqic02.cstatic void tape_qic02_release(struct inode * inode, struct file * filp)
inode2289kernel/chr_drv/tpqic02.cdev_t dev = inode->i_rdev;
inode2321kernel/chr_drv/tpqic02.cstatic int tape_qic02_ioctl(struct inode * inode, struct file * filp, 
inode2326kernel/chr_drv/tpqic02.cint dev_maj = MAJOR(inode->i_rdev);
inode2339kernel/chr_drv/tpqic02.cif (!inode || !ioarg)
inode77kernel/chr_drv/tty_io.cstatic int tty_read(struct inode *, struct file *, char *, int);
inode78kernel/chr_drv/tty_io.cstatic int tty_write(struct inode *, struct file *, char *, int);
inode79kernel/chr_drv/tty_io.cstatic int tty_select(struct inode *, struct file *, int, select_table *);
inode80kernel/chr_drv/tty_io.cstatic int tty_open(struct inode *, struct file *);
inode81kernel/chr_drv/tty_io.cstatic void tty_release(struct inode *, struct file *);
inode181kernel/chr_drv/tty_io.cstatic int hung_up_tty_read(struct inode * inode, struct file * file, char * buf, int count)
inode186kernel/chr_drv/tty_io.cstatic int hung_up_tty_write(struct inode * inode, struct file * file, char * buf, int count)
inode191kernel/chr_drv/tty_io.cstatic int hung_up_tty_select(struct inode * inode, struct file * filp, int sel_type, select_table * wait)
inode196kernel/chr_drv/tty_io.cstatic int hung_up_tty_ioctl(struct inode * inode, struct file * file,
inode202kernel/chr_drv/tty_io.cstatic int tty_lseek(struct inode * inode, struct file * file, off_t offset, int orig)
inode979kernel/chr_drv/tty_io.cstatic int tty_read(struct inode * inode, struct file * file, char * buf, int count)
inode993kernel/chr_drv/tty_io.cif ((inode->i_rdev != 0x0400) && /* don't stop on /dev/console */
inode1008kernel/chr_drv/tty_io.cinode->i_atime = CURRENT_TIME;
inode1012kernel/chr_drv/tty_io.cstatic int tty_write(struct inode * inode, struct file * file, char * buf, int count)
inode1018kernel/chr_drv/tty_io.cis_console = (inode->i_rdev == 0x0400);
inode1044kernel/chr_drv/tty_io.cinode->i_mtime = CURRENT_TIME;
inode1272kernel/chr_drv/tty_io.cstatic int tty_open(struct inode * inode, struct file * filp)
inode1278kernel/chr_drv/tty_io.cminor = MINOR(inode->i_rdev);
inode1279kernel/chr_drv/tty_io.cmajor = MAJOR(inode->i_rdev);
inode1293kernel/chr_drv/tty_io.cprintk("Bad major #%d in tty_open\n", MAJOR(inode->i_rdev));
inode1343kernel/chr_drv/tty_io.cstatic void tty_release(struct inode * inode, struct file * filp)
inode1360kernel/chr_drv/tty_io.cstatic int tty_select(struct inode * inode, struct file * filp, int sel_type, select_table * wait)
inode380kernel/chr_drv/tty_ioctl.cint tty_ioctl(struct inode * inode, struct file * file,
inode758mm/memory.cstruct inode * inode,
inode763mm/memory.cif (!inode || inode->i_count < 2)
inode770mm/memory.cif (inode != (*p)->executable) {
inode1123mm/memory.cstruct inode * inode = area->vm_inode;
inode1134mm/memory.cblock >>= inode->i_sb->s_blocksize_bits;
inode1137mm/memory.cif (share_page(area, area->vm_task, inode, address, error_code, page)) {
inode1148mm/memory.cfor (i=0, j=0; i< PAGE_SIZE ; j++, block++, i += inode->i_sb->s_blocksize)
inode1149mm/memory.cnr[j] = bmap(inode,block);
inode1162mm/memory.cpage = bread_page(page, inode->i_dev, nr, inode->i_sb->s_blocksize, prot);
inode1165mm/memory.cif (share_page(area, area->vm_task, inode, address, error_code, page))
inode193mm/mmap.cint generic_mmap(struct inode * inode, struct file * file,
inode200mm/mmap.cif (off & (inode->i_sb->s_blocksize - 1))
inode206mm/mmap.cif (!inode->i_sb || !S_ISREG(inode->i_mode))
inode208mm/mmap.cif (!inode->i_op || !inode->i_op->bmap)
inode210mm/mmap.cif (!(bh = bread(inode->i_dev,bmap(inode,0),inode->i_sb->s_blocksize)))
inode212mm/mmap.cif (!IS_RDONLY(inode)) {
inode213mm/mmap.cinode->i_atime = CURRENT_TIME;
inode214mm/mmap.cinode->i_dirt = 1;
inode228mm/mmap.cmpnt->vm_inode = inode;
inode229mm/mmap.cinode->i_count++;
inode37mm/swap.cstruct inode * swap_file;
inode667mm/swap.cstruct inode * inode;
inode673mm/swap.ci = namei(specialfile,&inode);
inode681mm/swap.cif (p->swap_file == inode)
inode684mm/swap.cif (!S_ISBLK(inode->i_mode))
inode686mm/swap.cif (p->swap_device == inode->i_rdev)
inode690mm/swap.ciput(inode);
inode719mm/swap.cstruct inode * swap_inode;
inode63net/drv/we8003/main.cwe_open(struct inode * inode, struct file * file)
inode68net/drv/we8003/main.cminor = MINOR(inode->i_rdev);
inode78net/drv/we8003/main.cwe_close(struct inode * inode, struct file * file)
inode83net/drv/we8003/main.cminor = MINOR(inode->i_rdev);
inode91net/drv/we8003/main.cwe_ioctl(struct inode *inode, struct file *file,
inode98net/drv/we8003/main.cminor = MINOR(inode->i_rdev);
inode1617net/inet/sock.cinet_fioctl(struct inode *inode, struct file *file,
inode1623net/inet/sock.cminor = MINOR(inode->i_rdev);
inode37net/socket.cstatic int sock_lseek(struct inode *inode, struct file *file, off_t offset,
inode39net/socket.cstatic int sock_read(struct inode *inode, struct file *file, char *buf,
inode41net/socket.cstatic int sock_write(struct inode *inode, struct file *file, char *buf,
inode43net/socket.cstatic int sock_readdir(struct inode *inode, struct file *file,
inode45net/socket.cstatic void sock_close(struct inode *inode, struct file *file);
inode46net/socket.cstatic int sock_select(struct inode *inode, struct file *file, int which, select_table *seltable);
inode47net/socket.cstatic int sock_ioctl(struct inode *inode, struct file *file,
inode87net/socket.cget_fd(struct inode *inode)
inode107net/socket.cfile->f_inode = inode;
inode108net/socket.cif (inode) inode->i_count++;
inode127net/socket.csocki_lookup(struct inode *inode)
inode132net/socket.cif (sock->state != SS_FREE && SOCK_INODE(sock) == inode) return(sock);
inode242net/socket.csock_lseek(struct inode *inode, struct file *file, off_t offset, int whence)
inode250net/socket.csock_read(struct inode *inode, struct file *file, char *ubuf, int size)
inode255net/socket.cif (!(sock = socki_lookup(inode))) {
inode265net/socket.csock_write(struct inode *inode, struct file *file, char *ubuf, int size)
inode270net/socket.cif (!(sock = socki_lookup(inode))) {
inode280net/socket.csock_readdir(struct inode *inode, struct file *file, struct dirent *dirent,
inode289net/socket.csock_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
inode295net/socket.cinode, cmd, arg));
inode296net/socket.cif (!(sock = socki_lookup(inode))) {
inode305net/socket.csock_select(struct inode *inode, struct file *file, int sel_type, select_table * wait)
inode309net/socket.cDPRINTF((net_debug, "NET: sock_select: inode = 0x%x, kind = %s\n", inode,
inode312net/socket.cif (!(sock = socki_lookup(inode))) {
inode325net/socket.csock_close(struct inode *inode, struct file *file)
inode330net/socket.cinode, inode->i_count));
inode333net/socket.cif (!inode) return;
inode334net/socket.cif (!(sock = socki_lookup(inode))) {
inode933net/socket.cnet_fioctl(struct inode *inode, struct file *file,
inode939net/socket.cswitch(MINOR(inode->i_rdev)) {
inode197net/unix/sock.cstruct inode *inode)
inode205net/unix/sock.cupd->inode == inode) return(upd);
inode226net/unix/sock.cupd->inode = NULL;
inode318net/unix/sock.cif (upd->inode) {
inode319net/unix/sock.cdprintf(1, "UNIX: release: releasing inode 0x%x\n", upd->inode);
inode320net/unix/sock.ciput(upd->inode);
inode321net/unix/sock.cupd->inode = NULL;
inode355net/unix/sock.cif (upd->sockaddr_len || upd->inode) {
inode373net/unix/sock.cif (i == 0) i = open_namei(fname, 0, S_IFSOCK, &upd->inode, NULL);
inode383net/unix/sock.cdprintf(1, "to inode 0x%x\n", upd->inode);
inode400net/unix/sock.cstruct inode *inode;
inode433net/unix/sock.ci = open_namei(fname, 0, S_IFSOCK, &inode, NULL);
inode439net/unix/sock.cserv_upd = unix_data_lookup(&sockun, sockaddr_len, inode);
inode440net/unix/sock.ciput(inode);
inode443net/unix/sock.cfname, inode);
inode758net/unix/sock.cunix_open(struct inode * inode, struct file * file)
inode763net/unix/sock.cminor = MINOR(inode->i_rdev);
inode771net/unix/sock.cunix_close(struct inode * inode, struct file * file)
inode778net/unix/sock.cunix_ioctl(struct inode *inode, struct file *file,
inode784net/unix/sock.cminor = MINOR(inode->i_rdev);
inode39net/unix/unix.hstruct inode  *inode;