Fork me on GitHub
i                 492 drivers/block/floppy.c int fdc_open(struct inode *i, struct fd *fd_table)
i                 496 drivers/block/floppy.c 	minor = MINOR(i->rdev);
i                 508 drivers/block/floppy.c int fdc_close(struct inode *i, struct fd *fd_table)
i                 512 drivers/block/floppy.c 	minor = MINOR(i->rdev);
i                 750 drivers/block/floppy.c int fdc_ioctl(struct inode *i, int cmd, unsigned long int arg)
i                 756 drivers/block/floppy.c 	minor = MINOR(i->rdev);
i                 782 drivers/block/floppy.c 			*(int *)arg = fdd_sizes[MINOR(i->rdev)] * 2;
i                 790 drivers/block/floppy.c int fdc_lseek(struct inode *i, __off_t offset)
i                 794 drivers/block/floppy.c 	minor = MINOR(i->rdev);
i                 645 drivers/block/ide.c int ide_open(struct inode *i, struct fd *fd_table)
i                 650 drivers/block/ide.c 	if(!(ide = get_ide_controller(i->rdev))) {
i                 654 drivers/block/ide.c 	if(!get_device(BLK_DEV, i->rdev)) {
i                 658 drivers/block/ide.c 	drive = get_ide_drive(i->rdev);
i                 660 drivers/block/ide.c 		return ide->drive[drive].fsop->open(i, fd_table);
i                 665 drivers/block/ide.c int ide_close(struct inode *i, struct fd *fd_table)
i                 670 drivers/block/ide.c 	if(!(ide = get_ide_controller(i->rdev))) {
i                 674 drivers/block/ide.c 	if(!get_device(BLK_DEV, i->rdev)) {
i                 678 drivers/block/ide.c 	drive = get_ide_drive(i->rdev);
i                 680 drivers/block/ide.c 		return ide->drive[drive].fsop->close(i, fd_table);
i                 729 drivers/block/ide.c int ide_ioctl(struct inode *i, int cmd, unsigned long int arg)
i                 734 drivers/block/ide.c 	if(!(ide = get_ide_controller(i->rdev))) {
i                 738 drivers/block/ide.c 	if(!get_device(BLK_DEV, i->rdev)) {
i                 742 drivers/block/ide.c 	drive = get_ide_drive(i->rdev);
i                 744 drivers/block/ide.c 		return ide->drive[drive].fsop->ioctl(i, cmd, arg);
i                 324 drivers/block/ide_cd.c int ide_cd_open(struct inode *i, struct fd *fd_table)
i                 333 drivers/block/ide_cd.c 	if(!(ide = get_ide_controller(i->rdev))) {
i                 337 drivers/block/ide_cd.c 	drive = get_ide_drive(i->rdev);
i                 347 drivers/block/ide_cd.c 		printk("WARNING: %s(): cdrom device %d,%d is not ready for TEST_UNIT, error %d.\n", __FUNCTION__, MAJOR(i->rdev), MINOR(i->rdev), errcode);
i                 348 drivers/block/ide_cd.c 		request_sense(buffer, i->rdev, ide, drive);
i                 355 drivers/block/ide_cd.c 		printk("WARNING: %s(): cdrom device %d,%d is not ready for CD_LOAD, error %d.\n", __FUNCTION__, MAJOR(i->rdev), MINOR(i->rdev), errcode);
i                 356 drivers/block/ide_cd.c 		atapi_read_data(i->rdev, buffer, ide, BLKSIZE_2K, 0);
i                 357 drivers/block/ide_cd.c 		errcode = request_sense(buffer, i->rdev, ide, drive);
i                 383 drivers/block/ide_cd.c 		printk("WARNING: %s(): error on cdrom device %d,%d while trying to lock medium.\n", __FUNCTION__, MAJOR(i->rdev), MINOR(i->rdev), ATAPI_MEDIUM_REMOVAL);
i                 384 drivers/block/ide_cd.c 		request_sense(buffer, i->rdev, ide, drive);
i                 388 drivers/block/ide_cd.c 	atapi_read_data(i->rdev, buffer, ide, BLKSIZE_2K, 0);
i                 395 drivers/block/ide_cd.c int ide_cd_close(struct inode *i, struct fd *fd_table)
i                 401 drivers/block/ide_cd.c 	if(!(ide = get_ide_controller(i->rdev))) {
i                 409 drivers/block/ide_cd.c 	drive = get_ide_drive(i->rdev);
i                 412 drivers/block/ide_cd.c 	invalidate_buffers(i->rdev);
i                 415 drivers/block/ide_cd.c 		printk("WARNING: %s(): error on cdrom device %d,%d during 0x%x command.\n", __FUNCTION__, MAJOR(i->rdev), MINOR(i->rdev), ATAPI_MEDIUM_REMOVAL);
i                 419 drivers/block/ide_cd.c 	atapi_read_data(i->rdev, buffer, ide, BLKSIZE_2K, 0);
i                 485 drivers/block/ide_cd.c int ide_cd_ioctl(struct inode *i, int cmd, unsigned long int arg)
i                 489 drivers/block/ide_cd.c 	if(!(ide = get_ide_controller(i->rdev))) {
i                 115 drivers/block/ide_hd.c int ide_hd_open(struct inode *i, struct fd *fd_table)
i                 120 drivers/block/ide_hd.c int ide_hd_close(struct inode *i, struct fd *fd_table)
i                 122 drivers/block/ide_hd.c 	sync_buffers(i->rdev);
i                 386 drivers/block/ide_hd.c int ide_hd_ioctl(struct inode *i, int cmd, unsigned long int arg)
i                 396 drivers/block/ide_hd.c 	if(!(ide = get_ide_controller(i->rdev))) {
i                 400 drivers/block/ide_hd.c 	minor = MINOR(i->rdev);
i                 401 drivers/block/ide_hd.c 	drive = get_ide_drive(i->rdev);
i                 434 drivers/block/ide_hd.c 			sync_buffers(i->rdev);
i                 435 drivers/block/ide_hd.c 			invalidate_buffers(i->rdev);
i                 438 drivers/block/ide_hd.c 			read_msdos_partition(i->rdev, part);
i                 439 drivers/block/ide_hd.c 			assign_minors(i->rdev, ide, part);
i                  82 drivers/block/ramdisk.c int ramdisk_open(struct inode *i, struct fd *fd_table)
i                  84 drivers/block/ramdisk.c 	if(!get_ramdisk(MINOR(i->rdev))) {
i                  90 drivers/block/ramdisk.c int ramdisk_close(struct inode *i, struct fd *fd_table)
i                  92 drivers/block/ramdisk.c 	if(!get_ramdisk(MINOR(i->rdev))) {
i                 140 drivers/block/ramdisk.c int ramdisk_ioctl(struct inode *i, int cmd, unsigned long int arg)
i                 145 drivers/block/ramdisk.c 	if(!get_ramdisk(MINOR(i->rdev))) {
i                 157 drivers/block/ramdisk.c 			geom->cylinders = rd_sizes[MINOR(i->rdev)] * 1024 / BPS;
i                 167 drivers/block/ramdisk.c 			*(int *)arg = rd_sizes[MINOR(i->rdev)] * 2;
i                 175 drivers/block/ramdisk.c int ramdisk_lseek(struct inode *i, __off_t offset)
i                  73 drivers/char/fb.c int fb_open(struct inode *i, struct fd *fd_table)
i                  78 drivers/char/fb.c int fb_close(struct inode *i, struct fd *fd_table)
i                  83 drivers/char/fb.c int fb_read(struct inode *i, struct fd *fd_table, char *buffer, __size_t count)
i                  98 drivers/char/fb.c int fb_write(struct inode *i, struct fd *fd_table, const char *buffer, __size_t count)
i                 113 drivers/char/fb.c int fb_ioctl(struct inode *i, int cmd, unsigned long int arg)
i                 118 drivers/char/fb.c int fb_lseek(struct inode *i, __off_t offset)
i                 135 drivers/char/lp.c int lp_open(struct inode *i, struct fd *fd_table)
i                 139 drivers/char/lp.c 	minor = MINOR(i->rdev);
i                 153 drivers/char/lp.c int lp_close(struct inode *i, struct fd *fd_table)
i                 157 drivers/char/lp.c 	minor = MINOR(i->rdev);
i                 165 drivers/char/lp.c int lp_write(struct inode *i, struct fd *fd_table, const char *buffer, __size_t count)
i                 171 drivers/char/lp.c 	minor = MINOR(i->rdev);
i                 282 drivers/char/memdev.c int mem_open(struct inode *i, struct fd *fd_table)
i                 287 drivers/char/memdev.c int mem_close(struct inode *i, struct fd *fd_table)
i                 292 drivers/char/memdev.c int mem_read(struct inode *i, struct fd *fd_table, char *buffer, __size_t count)
i                 306 drivers/char/memdev.c int mem_write(struct inode *i, struct fd *fd_table, const char *buffer, __size_t count)
i                 320 drivers/char/memdev.c int mem_lseek(struct inode *i, __off_t offset)
i                 325 drivers/char/memdev.c int kmem_open(struct inode *i, struct fd *fd_table)
i                 330 drivers/char/memdev.c int kmem_close(struct inode *i, struct fd *fd_table)
i                 335 drivers/char/memdev.c int kmem_read(struct inode *i, struct fd *fd_table, char *buffer, __size_t count)
i                 349 drivers/char/memdev.c int kmem_write(struct inode *i, struct fd *fd_table, const char *buffer, __size_t count)
i                 363 drivers/char/memdev.c int kmem_lseek(struct inode *i, __off_t offset)
i                 368 drivers/char/memdev.c int null_open(struct inode *i, struct fd *fd_table)
i                 373 drivers/char/memdev.c int null_close(struct inode *i, struct fd *fd_table)
i                 378 drivers/char/memdev.c int null_read(struct inode *i, struct fd *fd_table, char *buffer, __size_t count)
i                 383 drivers/char/memdev.c int null_write(struct inode *i, struct fd *fd_table, const char *buffer, __size_t count)
i                 388 drivers/char/memdev.c int null_lseek(struct inode *i, __off_t offset)
i                 393 drivers/char/memdev.c int zero_open(struct inode *i, struct fd *fd_table)
i                 398 drivers/char/memdev.c int zero_close(struct inode *i, struct fd *fd_table)
i                 403 drivers/char/memdev.c int zero_read(struct inode *i, struct fd *fd_table, char *buffer, __size_t count)
i                 409 drivers/char/memdev.c int zero_write(struct inode *i, struct fd *fd_table, const char *buffer, __size_t count)
i                 414 drivers/char/memdev.c int zero_lseek(struct inode *i, __off_t offset)
i                 419 drivers/char/memdev.c int urandom_open(struct inode *i, struct fd *fd_table)
i                 424 drivers/char/memdev.c int urandom_close(struct inode *i, struct fd *fd_table)
i                 429 drivers/char/memdev.c int urandom_read(struct inode *i, struct fd *fd_table, char *buffer, __size_t count)
i                 441 drivers/char/memdev.c int urandom_write(struct inode *i, struct fd *fd_table, const char *buffer, __size_t count)
i                 446 drivers/char/memdev.c int urandom_lseek(struct inode *i, __off_t offset)
i                 451 drivers/char/memdev.c int memdev_open(struct inode *i, struct fd *fd_table)
i                 455 drivers/char/memdev.c         minor = MINOR(i->rdev);
i                 458 drivers/char/memdev.c 			i->fsop = &mem_driver_fsop;
i                 461 drivers/char/memdev.c 			i->fsop = &kmem_driver_fsop;
i                 464 drivers/char/memdev.c 			i->fsop = &null_driver_fsop;
i                 467 drivers/char/memdev.c 			i->fsop = &zero_driver_fsop;
i                 470 drivers/char/memdev.c 			i->fsop = &urandom_driver_fsop;
i                 473 drivers/char/memdev.c 			i->fsop = &urandom_driver_fsop;
i                 478 drivers/char/memdev.c 	if(i->fsop->open) {
i                 479 drivers/char/memdev.c 		return i->fsop->open(i, fd_table);
i                 488 drivers/char/memdev.c int mem_mmap(struct inode *i, struct vma *vma)
i                 419 drivers/char/tty.c int tty_open(struct inode *i, struct fd *fd_table)
i                 427 drivers/char/tty.c 	if(MAJOR(i->rdev) == SYSCON_MAJOR && MINOR(i->rdev) == 0) {
i                 433 drivers/char/tty.c 	if(MAJOR(i->rdev) == VCONSOLES_MAJOR && MINOR(i->rdev) == 0) {
i                 437 drivers/char/tty.c 	if(!(tty = get_tty(i->rdev))) {
i                 438 drivers/char/tty.c 		printk("%s(): oops! (%x)\n", __FUNCTION__, i->rdev);
i                 459 drivers/char/tty.c int tty_close(struct inode *i, struct fd *fd_table)
i                 465 drivers/char/tty.c 	if(!(tty = get_tty(i->rdev))) {
i                 466 drivers/char/tty.c 		printk("%s(): oops! (%x)\n", __FUNCTION__, i->rdev);
i                 491 drivers/char/tty.c int tty_read(struct inode *i, struct fd *fd_table, char *buffer, __size_t count)
i                 499 drivers/char/tty.c 	if(!(tty = get_tty(i->rdev))) {
i                 500 drivers/char/tty.c 		printk("%s(): oops! (%x)\n", __FUNCTION__, i->rdev);
i                 634 drivers/char/tty.c 		i->i_atime = CURRENT_TIME;
i                 639 drivers/char/tty.c int tty_write(struct inode *i, struct fd *fd_table, const char *buffer, __size_t count)
i                 645 drivers/char/tty.c 	if(!(tty = get_tty(i->rdev))) {
i                 646 drivers/char/tty.c 		printk("%s(): oops! (%x)\n", __FUNCTION__, i->rdev);
i                 696 drivers/char/tty.c 		i->i_mtime = CURRENT_TIME;
i                 702 drivers/char/tty.c int tty_ioctl(struct inode *i, int cmd, unsigned long int arg)
i                 708 drivers/char/tty.c 	if(!(tty = get_tty(i->rdev))) {
i                 709 drivers/char/tty.c 		printk("%s(): oops! (%x)\n", __FUNCTION__, i->rdev);
i                 966 drivers/char/tty.c int tty_lseek(struct inode *i, __off_t offset)
i                 971 drivers/char/tty.c int tty_select(struct inode *i, int flag)
i                 975 drivers/char/tty.c 	if(!(tty = get_tty(i->rdev))) {
i                 976 drivers/char/tty.c 		printk("%s(): oops! (%x)\n", __FUNCTION__, i->rdev);
i                  53 fs/buffer.c    	int i;
i                  55 fs/buffer.c    	i = BUFFER_HASH(buf->dev, buf->block);
i                  56 fs/buffer.c    	h = &buffer_hash_table[i];
i                  72 fs/buffer.c    	int i;
i                  74 fs/buffer.c    	i = BUFFER_HASH(buf->dev, buf->block);
i                  75 fs/buffer.c    	h = &buffer_hash_table[i];
i                  85 fs/buffer.c    			if(h == &buffer_hash_table[i]) {
i                 242 fs/buffer.c    	int i;
i                 244 fs/buffer.c    	i = BUFFER_HASH(dev, block);
i                 245 fs/buffer.c    	buf = buffer_hash_table[i];
i                 199 fs/devices.c   int chr_dev_open(struct inode *i, struct fd *fd_table)
i                 203 fs/devices.c   	if((d = get_device(CHR_DEV, i->rdev))) {
i                 204 fs/devices.c   		i->fsop = d->fsop;
i                 205 fs/devices.c   		if(i->fsop && i->fsop->open) {
i                 206 fs/devices.c   			return i->fsop->open(i, fd_table);
i                 214 fs/devices.c   int blk_dev_open(struct inode *i, struct fd *fd_table)
i                 218 fs/devices.c   	if((d = get_device(BLK_DEV, i->rdev))) {
i                 220 fs/devices.c   			return d->fsop->open(i, fd_table);
i                 228 fs/devices.c   int blk_dev_close(struct inode *i, struct fd *fd_table)
i                 232 fs/devices.c   	if((d = get_device(BLK_DEV, i->rdev))) {
i                 234 fs/devices.c   			return d->fsop->close(i, fd_table);
i                 236 fs/devices.c   		printk("WARNING: %s(): block device %d,%d does not have the close() method.\n", __FUNCTION__, MAJOR(i->rdev), MINOR(i->rdev));
i                 243 fs/devices.c   int blk_dev_read(struct inode *i, struct fd *fd_table, char *buffer, __size_t count)
i                 253 fs/devices.c   	if(!(d = get_device(BLK_DEV, i->rdev))) {
i                 260 fs/devices.c   		printk("%s(): don't know the size of the block device %d,%d.\n", __FUNCTION__, MAJOR(i->rdev), MINOR(i->rdev));
i                 264 fs/devices.c   	device_size = ((unsigned int *)d->device_data)[MINOR(i->rdev)];
i                 274 fs/devices.c   		if(!(buf = bread(i->rdev, block, blksize))) {
i                 288 fs/devices.c   int blk_dev_write(struct inode *i, struct fd *fd_table, const char *buffer, __size_t count)
i                 298 fs/devices.c   	if(!(d = get_device(BLK_DEV, i->rdev))) {
i                 305 fs/devices.c   		printk("%s(): don't know the size of the block device %d,%d.\n", __FUNCTION__, MAJOR(i->rdev), MINOR(i->rdev));
i                 309 fs/devices.c   	device_size = ((unsigned int *)d->device_data)[MINOR(i->rdev)];
i                 319 fs/devices.c   		if(!(buf = bread(i->rdev, block, blksize))) {
i                 333 fs/devices.c   int blk_dev_ioctl(struct inode *i, int cmd, unsigned long int arg)
i                 337 fs/devices.c   	if((d = get_device(BLK_DEV, i->rdev))) {
i                 339 fs/devices.c   			return d->fsop->ioctl(i, cmd, arg);
i                 341 fs/devices.c   		printk("WARNING: %s(): block device %d,%d does not have the ioctl() method.\n", __FUNCTION__, MAJOR(i->rdev), MINOR(i->rdev));
i                 348 fs/devices.c   int blk_dev_lseek(struct inode *i, __off_t offset)
i                 352 fs/devices.c   	if((d = get_device(BLK_DEV, i->rdev))) {
i                 354 fs/devices.c   			return d->fsop->lseek(i, offset);
i                 401 fs/elf.c       int elf_load(struct inode *i, struct binargs *barg, struct sigcontext *sc, char *data)
i                 510 fs/elf.c       			errno = do_mmap(i, start, length, prot, MAP_PRIVATE | MAP_FIXED, elf32_ph->p_offset & PAGE_MASK, type, O_RDONLY);
i                  82 fs/ext2/bitmaps.c int ext2_ialloc(struct inode *i, int mode)
i                  91 fs/ext2/bitmaps.c 	sb = i->sb;
i                 144 fs/ext2/bitmaps.c 	i->inode = inode;
i                 145 fs/ext2/bitmaps.c 	i->i_atime = CURRENT_TIME;
i                 146 fs/ext2/bitmaps.c 	i->i_mtime = CURRENT_TIME;
i                 147 fs/ext2/bitmaps.c 	i->i_ctime = CURRENT_TIME;
i                 153 fs/ext2/bitmaps.c void ext2_ifree(struct inode *i)
i                 161 fs/ext2/bitmaps.c 	if(!i->inode || i->inode > i->sb->u.ext2.sb.s_inodes_count) {
i                 162 fs/ext2/bitmaps.c 		printk("WARNING: %s(): invalid inode %d!\n", __FUNCTION__, i->inode);
i                 166 fs/ext2/bitmaps.c 	if(i->i_blocks) {
i                 167 fs/ext2/bitmaps.c 		ext2_truncate(i, 0);
i                 170 fs/ext2/bitmaps.c 	sb = i->sb;
i                 174 fs/ext2/bitmaps.c 	bg = (i->inode - 1) / EXT2_INODES_PER_GROUP(sb);
i                 180 fs/ext2/bitmaps.c 	errno = change_bit(CLEAR_BIT, sb, gd->bg_inode_bitmap, (i->inode - 1) % EXT2_INODES_PER_GROUP(sb));
i                 184 fs/ext2/bitmaps.c 			printk("WARNING: %s(): unable to clear inode %d.\n", __FUNCTION__, i->inode);
i                 189 fs/ext2/bitmaps.c 			printk("WARNING: %s(): inode %d is already marked as free!\n", __FUNCTION__, i->inode);
i                 195 fs/ext2/bitmaps.c 	if(S_ISDIR(i->i_mode)) {
i                 200 fs/ext2/bitmaps.c 	i->i_size = 0;
i                 201 fs/ext2/bitmaps.c 	i->i_mtime = CURRENT_TIME;
i                 202 fs/ext2/bitmaps.c 	i->i_ctime = CURRENT_TIME;
i                 203 fs/ext2/bitmaps.c 	i->dirty = 1;
i                  61 fs/ext2/dir.c  int ext2_dir_open(struct inode *i, struct fd *fd_table)
i                  67 fs/ext2/dir.c  int ext2_dir_close(struct inode *i, struct fd *fd_table)
i                  72 fs/ext2/dir.c  int ext2_dir_read(struct inode *i, struct fd *fd_table, char *buffer, __size_t count)
i                  77 fs/ext2/dir.c  int ext2_dir_write(struct inode *i, struct fd *fd_table, const char *buffer, __size_t count)
i                  82 fs/ext2/dir.c  int ext2_dir_readdir(struct inode *i, struct fd *fd_table, struct dirent *dirent, unsigned int count)
i                  92 fs/ext2/dir.c  	if(!(S_ISDIR(i->i_mode))) {
i                  96 fs/ext2/dir.c  	blksize = i->sb->s_blocksize;
i                  97 fs/ext2/dir.c  	if(fd_table->offset > i->i_size) {
i                  98 fs/ext2/dir.c  		fd_table->offset = i->i_size;
i                 104 fs/ext2/dir.c  	while(fd_table->offset < i->i_size && count > 0) {
i                 105 fs/ext2/dir.c  		if((block = bmap(i, fd_table->offset, FOR_READING)) < 0) {
i                 109 fs/ext2/dir.c  			if(!(buf = bread(i->dev, block, blksize))) {
i                  62 fs/ext2/file.c int ext2_file_open(struct inode *i, struct fd *fd_table)
i                  65 fs/ext2/file.c 		fd_table->offset = i->i_size;
i                  70 fs/ext2/file.c 		i->i_size = 0;
i                  71 fs/ext2/file.c 		ext2_truncate(i, 0);
i                  76 fs/ext2/file.c int ext2_file_close(struct inode *i, struct fd *fd_table)
i                  81 fs/ext2/file.c int ext2_file_write(struct inode *i, struct fd *fd_table, const char *buffer, __size_t count)
i                  89 fs/ext2/file.c 	inode_lock(i);
i                  91 fs/ext2/file.c 	blksize = i->sb->s_blocksize;
i                  95 fs/ext2/file.c 		fd_table->offset = i->i_size;
i                 100 fs/ext2/file.c 		if((block = bmap(i, fd_table->offset, FOR_WRITING)) < 0) {
i                 101 fs/ext2/file.c 			inode_unlock(i);
i                 106 fs/ext2/file.c 		if(!(buf = bread(i->dev, block, blksize))) {
i                 107 fs/ext2/file.c 			inode_unlock(i);
i                 111 fs/ext2/file.c 		update_page_cache(i, fd_table->offset, buffer + total_written, bytes);
i                 117 fs/ext2/file.c 	if(fd_table->offset > i->i_size) {
i                 118 fs/ext2/file.c 		i->i_size = fd_table->offset;
i                 120 fs/ext2/file.c 	i->i_ctime = CURRENT_TIME;
i                 121 fs/ext2/file.c 	i->i_mtime = CURRENT_TIME;
i                 122 fs/ext2/file.c 	i->dirty = 1;
i                 124 fs/ext2/file.c 	inode_unlock(i);
i                 128 fs/ext2/file.c int ext2_file_lseek(struct inode *i, __off_t offset)
i                  30 fs/ext2/inode.c static void free_indblock(struct inode *i, int block, int offset)
i                  36 fs/ext2/inode.c 	if(!(buf = bread(i->dev, block, i->sb->s_blocksize))) {
i                  41 fs/ext2/inode.c 	for(n = offset; n < BLOCKS_PER_IND_BLOCK(i->sb); n++) {
i                  43 fs/ext2/inode.c 			ext2_bfree(i->sb, indblock[n]);
i                  45 fs/ext2/inode.c 			i->i_blocks -= i->sb->s_blocksize / 512;
i                  67 fs/ext2/inode.c int ext2_read_inode(struct inode *i)
i                  76 fs/ext2/inode.c 	if(!(sb = get_superblock(i->dev))) {
i                  80 fs/ext2/inode.c 	block_group = ((i->inode - 1) / EXT2_INODES_PER_GROUP(sb));
i                  84 fs/ext2/inode.c 	block = (((i->inode - 1) % EXT2_INODES_PER_GROUP(sb)) / EXT2_INODES_PER_BLOCK(sb));
i                  86 fs/ext2/inode.c 	if(!(buf = bread(i->dev, gd.bg_inode_table + block, i->sb->s_blocksize))) {
i                  89 fs/ext2/inode.c 	offset = ((((i->inode - 1) % EXT2_INODES_PER_GROUP(sb)) % EXT2_INODES_PER_BLOCK(sb)) * sizeof(struct ext2_inode));
i                  92 fs/ext2/inode.c 	memcpy_b(&i->u.ext2.i_data, ii->i_block, sizeof(ii->i_block));
i                  94 fs/ext2/inode.c 	i->i_mode = ii->i_mode;
i                  95 fs/ext2/inode.c 	i->i_uid = ii->i_uid;
i                  96 fs/ext2/inode.c 	i->i_size = ii->i_size;
i                  97 fs/ext2/inode.c 	i->i_atime = ii->i_atime;
i                  98 fs/ext2/inode.c 	i->i_ctime = ii->i_ctime;
i                  99 fs/ext2/inode.c 	i->i_mtime = ii->i_mtime;
i                 100 fs/ext2/inode.c 	i->i_gid = ii->i_gid;
i                 101 fs/ext2/inode.c 	i->i_nlink = ii->i_links_count;
i                 102 fs/ext2/inode.c 	i->i_blocks = ii->i_blocks;
i                 103 fs/ext2/inode.c 	i->i_flags = ii->i_flags;
i                 104 fs/ext2/inode.c 	i->count = 1;
i                 105 fs/ext2/inode.c 	switch(i->i_mode & S_IFMT) {
i                 107 fs/ext2/inode.c 			i->fsop = &def_chr_fsop;
i                 108 fs/ext2/inode.c 			i->rdev = ii->i_block[0];
i                 111 fs/ext2/inode.c 			i->fsop = &def_blk_fsop;
i                 112 fs/ext2/inode.c 			i->rdev = ii->i_block[0];
i                 115 fs/ext2/inode.c 			i->fsop = &pipefs_fsop;
i                 117 fs/ext2/inode.c 			memset_b(&i->u.pipefs, NULL, sizeof(struct pipefs_inode));
i                 120 fs/ext2/inode.c 			i->fsop = &ext2_dir_fsop;
i                 123 fs/ext2/inode.c 			i->fsop = &ext2_file_fsop;
i                 126 fs/ext2/inode.c 			i->fsop = &ext2_symlink_fsop;
i                 129 fs/ext2/inode.c 			i->fsop = NULL;
i                 132 fs/ext2/inode.c 			printk("WARNING: %s(): invalid inode (%d) mode %08o.\n", __FUNCTION__, i->inode, i->i_mode);
i                 140 fs/ext2/inode.c int ext2_write_inode(struct inode *i)
i                 149 fs/ext2/inode.c 	if(!(sb = get_superblock(i->dev))) {
i                 153 fs/ext2/inode.c 	block_group = ((i->inode - 1) / EXT2_INODES_PER_GROUP(sb));
i                 157 fs/ext2/inode.c 	block = (((i->inode - 1) % EXT2_INODES_PER_GROUP(sb)) / EXT2_INODES_PER_BLOCK(sb));
i                 159 fs/ext2/inode.c 	if(!(buf = bread(i->dev, gd.bg_inode_table + block, i->sb->s_blocksize))) {
i                 162 fs/ext2/inode.c 	offset = ((((i->inode - 1) % EXT2_INODES_PER_GROUP(sb)) % EXT2_INODES_PER_BLOCK(sb)) * sizeof(struct ext2_inode));
i                 166 fs/ext2/inode.c 	ii->i_mode = i->i_mode;
i                 167 fs/ext2/inode.c 	ii->i_uid = i->i_uid;
i                 168 fs/ext2/inode.c 	ii->i_size = i->i_size;
i                 169 fs/ext2/inode.c 	ii->i_atime = i->i_atime;
i                 170 fs/ext2/inode.c 	ii->i_ctime = i->i_ctime;
i                 171 fs/ext2/inode.c 	ii->i_mtime = i->i_mtime;
i                 172 fs/ext2/inode.c 	ii->i_dtime = i->u.ext2.i_dtime;
i                 173 fs/ext2/inode.c 	ii->i_gid = i->i_gid;
i                 174 fs/ext2/inode.c 	ii->i_links_count = i->i_nlink;
i                 175 fs/ext2/inode.c 	ii->i_blocks = i->i_blocks;
i                 176 fs/ext2/inode.c 	ii->i_flags = i->i_flags;
i                 177 fs/ext2/inode.c 	if(S_ISCHR(i->i_mode) || S_ISBLK(i->i_mode)) {
i                 178 fs/ext2/inode.c 		ii->i_block[0] = i->rdev;
i                 180 fs/ext2/inode.c 		memcpy_b(ii->i_block, &i->u.ext2.i_data, sizeof(i->u.ext2.i_data));
i                 182 fs/ext2/inode.c 	i->dirty = 0;
i                 187 fs/ext2/inode.c int ext2_bmap(struct inode *i, __off_t offset, int mode)
i                 195 fs/ext2/inode.c 	blksize = i->sb->s_blocksize;
i                 203 fs/ext2/inode.c 		if(block < (BLOCKS_PER_IND_BLOCK(i->sb) + EXT2_NDIR_BLOCKS)) {
i                 205 fs/ext2/inode.c 		} else if(block < ((BLOCKS_PER_IND_BLOCK(i->sb) * BLOCKS_PER_IND_BLOCK(i->sb)) + BLOCKS_PER_IND_BLOCK(i->sb) + EXT2_NDIR_BLOCKS)) {
i                 214 fs/ext2/inode.c 		if(!i->u.ext2.i_data[block] && mode == FOR_WRITING) {
i                 215 fs/ext2/inode.c 			if((newblock = ext2_balloc(i->sb)) < 0) {
i                 219 fs/ext2/inode.c 			if(!(buf = bread(i->dev, newblock, blksize))) {
i                 220 fs/ext2/inode.c 				ext2_bfree(i->sb, newblock);
i                 225 fs/ext2/inode.c 			i->u.ext2.i_data[block] = newblock;
i                 226 fs/ext2/inode.c 			i->i_blocks += blksize / 512;
i                 228 fs/ext2/inode.c 		return i->u.ext2.i_data[block];
i                 231 fs/ext2/inode.c 	if(!i->u.ext2.i_data[level]) {
i                 233 fs/ext2/inode.c 			if((newblock = ext2_balloc(i->sb)) < 0) {
i                 237 fs/ext2/inode.c 			if(!(buf = bread(i->dev, newblock, blksize))) {
i                 238 fs/ext2/inode.c 				ext2_bfree(i->sb, newblock);
i                 243 fs/ext2/inode.c 			i->u.ext2.i_data[level] = newblock;
i                 244 fs/ext2/inode.c 			i->i_blocks += blksize / 512;
i                 249 fs/ext2/inode.c 	if(!(buf = bread(i->dev, i->u.ext2.i_data[level], blksize))) {
i                 253 fs/ext2/inode.c 	dblock = block - BLOCKS_PER_IND_BLOCK(i->sb);
i                 254 fs/ext2/inode.c 	tblock = block - (BLOCKS_PER_IND_BLOCK(i->sb) * BLOCKS_PER_IND_BLOCK(i->sb)) - BLOCKS_PER_IND_BLOCK(i->sb);
i                 257 fs/ext2/inode.c 		block = dblock / BLOCKS_PER_IND_BLOCK(i->sb);
i                 260 fs/ext2/inode.c 		block = tblock / (BLOCKS_PER_IND_BLOCK(i->sb) * BLOCKS_PER_IND_BLOCK(i->sb));
i                 265 fs/ext2/inode.c 			if((newblock = ext2_balloc(i->sb)) < 0) {
i                 270 fs/ext2/inode.c 			if(!(buf2 = bread(i->dev, newblock, blksize))) {
i                 271 fs/ext2/inode.c 				ext2_bfree(i->sb, newblock);
i                 278 fs/ext2/inode.c 			i->i_blocks += blksize / 512;
i                 296 fs/ext2/inode.c 		if(!(buf3 = bread(i->dev, indblock[block], blksize))) {
i                 302 fs/ext2/inode.c 		block = tindblock[tblock / BLOCKS_PER_IND_BLOCK(i->sb)];
i                 305 fs/ext2/inode.c 				if((newblock = ext2_balloc(i->sb)) < 0) {
i                 311 fs/ext2/inode.c 				if(!(buf4 = bread(i->dev, newblock, blksize))) {
i                 312 fs/ext2/inode.c 					ext2_bfree(i->sb, newblock);
i                 319 fs/ext2/inode.c 				tindblock[tblock / BLOCKS_PER_IND_BLOCK(i->sb)] = newblock;
i                 320 fs/ext2/inode.c 				i->i_blocks += blksize / 512;
i                 330 fs/ext2/inode.c 		iblock = tblock / BLOCKS_PER_IND_BLOCK(i->sb);
i                 331 fs/ext2/inode.c 		if(!(buf2 = bread(i->dev, block, blksize))) {
i                 339 fs/ext2/inode.c 		if(!(buf2 = bread(i->dev, indblock[iblock], blksize))) {
i                 347 fs/ext2/inode.c 	block = dindblock[dblock - (iblock * BLOCKS_PER_IND_BLOCK(i->sb))];
i                 349 fs/ext2/inode.c 		if((newblock = ext2_balloc(i->sb)) < 0) {
i                 358 fs/ext2/inode.c 		if(!(buf4 = bread(i->dev, newblock, blksize))) {
i                 359 fs/ext2/inode.c 			ext2_bfree(i->sb, newblock);
i                 369 fs/ext2/inode.c 		dindblock[dblock - (iblock * BLOCKS_PER_IND_BLOCK(i->sb))] = newblock;
i                 370 fs/ext2/inode.c 		i->i_blocks += blksize / 512;
i                 382 fs/ext2/inode.c int ext2_truncate(struct inode *i, __off_t length)
i                 388 fs/ext2/inode.c 	blksize = i->sb->s_blocksize;
i                 391 fs/ext2/inode.c 	if(!S_ISDIR(i->i_mode) && !S_ISREG(i->i_mode) && !S_ISLNK(i->i_mode)) {
i                 397 fs/ext2/inode.c 			if(i->u.ext2.i_data[n]) {
i                 398 fs/ext2/inode.c 				ext2_bfree(i->sb, i->u.ext2.i_data[n]);
i                 399 fs/ext2/inode.c 				i->u.ext2.i_data[n] = 0;
i                 400 fs/ext2/inode.c 				i->i_blocks -= blksize / 512;
i                 406 fs/ext2/inode.c 	if(!block || block < (BLOCKS_PER_IND_BLOCK(i->sb) + EXT2_NDIR_BLOCKS)) {
i                 410 fs/ext2/inode.c 		if(i->u.ext2.i_data[EXT2_IND_BLOCK]) {
i                 411 fs/ext2/inode.c 			free_indblock(i, i->u.ext2.i_data[EXT2_IND_BLOCK], block);
i                 413 fs/ext2/inode.c 				ext2_bfree(i->sb, i->u.ext2.i_data[EXT2_IND_BLOCK]);
i                 414 fs/ext2/inode.c 				i->u.ext2.i_data[EXT2_IND_BLOCK] = 0;
i                 415 fs/ext2/inode.c 				i->i_blocks -= blksize / 512;
i                 423 fs/ext2/inode.c 		block -= BLOCKS_PER_IND_BLOCK(i->sb);
i                 425 fs/ext2/inode.c 	if(i->u.ext2.i_data[EXT2_DIND_BLOCK]) {
i                 426 fs/ext2/inode.c 		if(!(buf = bread(i->dev, i->u.ext2.i_data[EXT2_DIND_BLOCK], blksize))) {
i                 427 fs/ext2/inode.c 			printk("%s(): error reading block %d.\n", __FUNCTION__, i->u.ext2.i_data[EXT2_DIND_BLOCK]);
i                 431 fs/ext2/inode.c 		dblock = block % BLOCKS_PER_IND_BLOCK(i->sb);
i                 432 fs/ext2/inode.c 		for(n = block / BLOCKS_PER_IND_BLOCK(i->sb); n < BLOCKS_PER_IND_BLOCK(i->sb); n++) {
i                 434 fs/ext2/inode.c 				free_indblock(i, indblock[n], dblock);
i                 436 fs/ext2/inode.c 					ext2_bfree(i->sb, indblock[n]);
i                 437 fs/ext2/inode.c 					i->i_blocks -= blksize / 512;
i                 444 fs/ext2/inode.c 			ext2_bfree(i->sb, i->u.ext2.i_data[EXT2_DIND_BLOCK]);
i                 445 fs/ext2/inode.c 			i->u.ext2.i_data[EXT2_DIND_BLOCK] = 0;
i                 446 fs/ext2/inode.c 			i->i_blocks -= blksize / 512;
i                 450 fs/ext2/inode.c 	i->i_mtime = CURRENT_TIME;
i                 451 fs/ext2/inode.c 	i->i_ctime = CURRENT_TIME;
i                 452 fs/ext2/inode.c 	i->i_size = length;
i                 453 fs/ext2/inode.c 	i->dirty = 1;
i                  21 fs/ext2/namei.c static struct buffer * find_dir_entry(struct inode *dir, struct inode *i, struct ext2_dir_entry_2 **d_res, char *name)
i                  48 fs/ext2/namei.c 				if(!i) {
i                  71 fs/ext2/namei.c 					if((*d_res)->inode == i->inode) {
i                 250 fs/ext2/namei.c int ext2_rmdir(struct inode *dir, struct inode *i)
i                 255 fs/ext2/namei.c 	inode_lock(i);
i                 257 fs/ext2/namei.c 	if(!is_dir_empty(i)) {
i                 258 fs/ext2/namei.c 		inode_unlock(i);
i                 264 fs/ext2/namei.c 	if(!(buf = find_dir_entry(dir, i, &d, NULL))) {
i                 265 fs/ext2/namei.c 		inode_unlock(i);
i                 271 fs/ext2/namei.c 	i->i_nlink = 0;
i                 274 fs/ext2/namei.c 	i->i_ctime = CURRENT_TIME;
i                 275 fs/ext2/namei.c 	i->u.ext2.i_dtime = CURRENT_TIME;
i                 279 fs/ext2/namei.c 	i->dirty = 1;
i                 284 fs/ext2/namei.c 	inode_unlock(i);
i                 332 fs/ext2/namei.c int ext2_unlink(struct inode *dir, struct inode *i, char *name)
i                 338 fs/ext2/namei.c 	inode_lock(i);
i                 340 fs/ext2/namei.c 	if(!(buf = find_dir_entry(dir, i, &d, name))) {
i                 342 fs/ext2/namei.c 		inode_unlock(i);
i                 352 fs/ext2/namei.c 	if(!--i->i_nlink) {
i                 353 fs/ext2/namei.c 		i->u.ext2.i_dtime = CURRENT_TIME;
i                 356 fs/ext2/namei.c 	i->i_ctime = CURRENT_TIME;
i                 360 fs/ext2/namei.c 	i->dirty = 1;
i                 366 fs/ext2/namei.c 	inode_unlock(i);
i                 373 fs/ext2/namei.c 	struct inode *i;
i                 381 fs/ext2/namei.c 	if(!(i = ialloc(dir->sb, S_IFLNK))) {
i                 387 fs/ext2/namei.c 		iput(i);
i                 392 fs/ext2/namei.c 	i->i_mode = S_IFLNK | (S_IRWXU | S_IRWXG | S_IRWXO);
i                 393 fs/ext2/namei.c 	i->i_uid = current->euid;
i                 394 fs/ext2/namei.c 	i->i_gid = current->egid;
i                 395 fs/ext2/namei.c 	i->dev = dir->dev;
i                 396 fs/ext2/namei.c 	i->count = 1;
i                 397 fs/ext2/namei.c 	i->fsop = &ext2_symlink_fsop;
i                 402 fs/ext2/namei.c 			iput(i);
i                 408 fs/ext2/namei.c 			iput(i);
i                 414 fs/ext2/namei.c 		i->u.ext2.i_data[0] = block;
i                 423 fs/ext2/namei.c 		i->i_blocks = dir->sb->s_blocksize / 512;
i                 427 fs/ext2/namei.c 		data = (char *)i->u.ext2.i_data;
i                 438 fs/ext2/namei.c 	i->i_size = n;
i                 439 fs/ext2/namei.c 	i->dirty = 1;
i                 440 fs/ext2/namei.c 	i->i_nlink = 1;
i                 441 fs/ext2/namei.c 	d->inode = i->inode;
i                 458 fs/ext2/namei.c 	iput(i);
i                 466 fs/ext2/namei.c 	struct inode *i;
i                 474 fs/ext2/namei.c 	if(!(i = ialloc(dir->sb, S_IFDIR))) {
i                 479 fs/ext2/namei.c 	i->i_mode = ((mode & (S_IRWXU | S_IRWXG | S_IRWXO)) & ~current->umask);
i                 480 fs/ext2/namei.c 	i->i_mode |= S_IFDIR;
i                 481 fs/ext2/namei.c 	i->i_uid = current->euid;
i                 482 fs/ext2/namei.c 	i->i_gid = current->egid;
i                 483 fs/ext2/namei.c 	i->dev = dir->dev;
i                 484 fs/ext2/namei.c 	i->count = 1;
i                 485 fs/ext2/namei.c 	i->fsop = &ext2_dir_fsop;
i                 487 fs/ext2/namei.c 	if((block = bmap(i, 0, FOR_WRITING)) < 0) {
i                 488 fs/ext2/namei.c 		iput(i);
i                 493 fs/ext2/namei.c 	if(!(buf2 = bread(i->dev, block, dir->sb->s_blocksize))) {
i                 495 fs/ext2/namei.c 		iput(i);
i                 502 fs/ext2/namei.c 		iput(i);
i                 508 fs/ext2/namei.c 	d->inode = i->inode;
i                 523 fs/ext2/namei.c 	d2->inode = i->inode;
i                 529 fs/ext2/namei.c 	i->i_nlink = 1;
i                 536 fs/ext2/namei.c 	d2->rec_len = i->sb->s_blocksize - 12;
i                 538 fs/ext2/namei.c 	i->i_nlink++;
i                 539 fs/ext2/namei.c 	i->i_size = i->sb->s_blocksize;
i                 540 fs/ext2/namei.c 	i->i_blocks = dir->sb->s_blocksize / 512;
i                 541 fs/ext2/namei.c 	i->dirty = 1;
i                 550 fs/ext2/namei.c 	iput(i);
i                 558 fs/ext2/namei.c 	struct inode *i;
i                 565 fs/ext2/namei.c 	if(!(i = ialloc(dir->sb, mode & S_IFMT))) {
i                 571 fs/ext2/namei.c 		i->i_nlink = 0;
i                 572 fs/ext2/namei.c 		iput(i);
i                 577 fs/ext2/namei.c 	d->inode = i->inode;
i                 588 fs/ext2/namei.c 	i->i_mode = (mode & ~current->umask) & ~S_IFMT;
i                 589 fs/ext2/namei.c 	i->i_uid = current->euid;
i                 590 fs/ext2/namei.c 	i->i_gid = current->egid;
i                 591 fs/ext2/namei.c 	i->i_nlink = 1;
i                 592 fs/ext2/namei.c 	i->dev = dir->dev;
i                 593 fs/ext2/namei.c 	i->count = 1;
i                 594 fs/ext2/namei.c 	i->dirty = 1;
i                 598 fs/ext2/namei.c 			i->fsop = &def_chr_fsop;
i                 599 fs/ext2/namei.c 			i->rdev = dev;
i                 600 fs/ext2/namei.c 			i->i_mode |= S_IFCHR;
i                 604 fs/ext2/namei.c 			i->fsop = &def_blk_fsop;
i                 605 fs/ext2/namei.c 			i->rdev = dev;
i                 606 fs/ext2/namei.c 			i->i_mode |= S_IFBLK;
i                 610 fs/ext2/namei.c 			i->fsop = &pipefs_fsop;
i                 611 fs/ext2/namei.c 			i->i_mode |= S_IFIFO;
i                 613 fs/ext2/namei.c 			memset_b(&i->u.pipefs, NULL, sizeof(struct pipefs_inode));
i                 623 fs/ext2/namei.c 	iput(i);
i                 631 fs/ext2/namei.c 	struct inode *i;
i                 642 fs/ext2/namei.c 	if(!(i = ialloc(dir->sb, S_IFREG))) {
i                 648 fs/ext2/namei.c 		i->i_nlink = 0;
i                 649 fs/ext2/namei.c 		iput(i);
i                 654 fs/ext2/namei.c 	d->inode = i->inode;
i                 666 fs/ext2/namei.c 	i->i_mode = (mode & ~current->umask) & ~S_IFMT;
i                 667 fs/ext2/namei.c 	i->i_mode |= S_IFREG;
i                 668 fs/ext2/namei.c 	i->i_uid = current->euid;
i                 669 fs/ext2/namei.c 	i->i_gid = current->egid;
i                 670 fs/ext2/namei.c 	i->i_nlink = 1;
i                 671 fs/ext2/namei.c 	i->i_blocks = 0;
i                 672 fs/ext2/namei.c 	i->dev = dir->dev;
i                 673 fs/ext2/namei.c 	i->fsop = &ext2_file_fsop;
i                 674 fs/ext2/namei.c 	i->count = 1;
i                 675 fs/ext2/namei.c 	i->dirty = 1;
i                 677 fs/ext2/namei.c 	i->u.ext2.i_dtime = 0;
i                 683 fs/ext2/namei.c 	*i_res = i;
i                  60 fs/ext2/symlink.c int ext2_readlink(struct inode *i, char *buffer, __size_t count)
i                  65 fs/ext2/symlink.c 	if(!S_ISLNK(i->i_mode)) {
i                  66 fs/ext2/symlink.c 		printk("%s(): Oops, inode '%d' is not a symlink (!?).\n", __FUNCTION__, i->inode);
i                  70 fs/ext2/symlink.c 	inode_lock(i);
i                  71 fs/ext2/symlink.c 	blksize = i->sb->s_blocksize;
i                  72 fs/ext2/symlink.c 	count = MIN(count, i->i_size);
i                  74 fs/ext2/symlink.c 		inode_unlock(i);
i                  78 fs/ext2/symlink.c 	if(i->i_blocks) {	/* slow symlink */
i                  79 fs/ext2/symlink.c 		if(!(buf = bread(i->dev, i->u.ext2.i_data[0], blksize))) {
i                  80 fs/ext2/symlink.c 			inode_unlock(i);
i                  86 fs/ext2/symlink.c 		memcpy_b(buffer, (char *)i->u.ext2.i_data, count);
i                  89 fs/ext2/symlink.c 	inode_unlock(i);
i                  93 fs/ext2/symlink.c int ext2_followlink(struct inode *dir, struct inode *i, struct inode **i_res)
i                  99 fs/ext2/symlink.c 	if(!i) {
i                 103 fs/ext2/symlink.c 	if(!S_ISLNK(i->i_mode)) {
i                 104 fs/ext2/symlink.c 		printk("%s(): Oops, inode '%d' is not a symlink (!?).\n", __FUNCTION__, i->inode);
i                 113 fs/ext2/symlink.c 	inode_lock(i);
i                 114 fs/ext2/symlink.c 	if(i->i_blocks) {	/* slow symlink */
i                 115 fs/ext2/symlink.c 		if(!(buf = bread(i->dev, i->u.ext2.i_data[0], i->sb->s_blocksize))) {
i                 116 fs/ext2/symlink.c 			inode_unlock(i);
i                 122 fs/ext2/symlink.c 		name = (char *)i->u.ext2.i_data;
i                 124 fs/ext2/symlink.c 	inode_unlock(i);
i                 127 fs/ext2/symlink.c 	iput(i);
i                  19 fs/fd.c        int get_new_fd(struct inode *i)
i                  28 fs/fd.c        			fd_table[n].inode = i;
i                  47 fs/inode.c     static void insert_to_hash(struct inode *i)
i                  52 fs/inode.c     	n = INODE_HASH(i->dev, i->inode);
i                  56 fs/inode.c     		*h = i;
i                  59 fs/inode.c     		i->prev_hash = NULL;
i                  60 fs/inode.c     		i->next_hash = *h;
i                  61 fs/inode.c     		(*h)->prev_hash = i;
i                  62 fs/inode.c     		*h = i;
i                  66 fs/inode.c     static void remove_from_hash(struct inode *i)
i                  71 fs/inode.c     	if(!i->inode) {
i                  75 fs/inode.c     	n = INODE_HASH(i->dev, i->inode);
i                  79 fs/inode.c     		if(*h == i) {
i                  95 fs/inode.c     static void insert_on_free_list(struct inode *i)
i                  98 fs/inode.c     		i->prev_free = i->next_free = i;
i                  99 fs/inode.c     		inode_head = i;
i                 101 fs/inode.c     		i->next_free = inode_head;
i                 102 fs/inode.c     		i->prev_free = inode_head->prev_free;
i                 103 fs/inode.c     		inode_head->prev_free->next_free = i;
i                 104 fs/inode.c     		inode_head->prev_free = i;
i                 110 fs/inode.c     static void remove_from_free_list(struct inode *i)
i                 116 fs/inode.c     	i->prev_free->next_free = i->next_free;
i                 117 fs/inode.c     	i->next_free->prev_free = i->prev_free;
i                 119 fs/inode.c     	if(i == inode_head) {
i                 120 fs/inode.c     		inode_head = i->next_free;
i                 131 fs/inode.c     	struct inode *i;
i                 140 fs/inode.c     	i = inode_head;
i                 141 fs/inode.c     	remove_from_free_list(i);
i                 142 fs/inode.c     	remove_from_hash(i);
i                 143 fs/inode.c     	i->i_mode = 0;
i                 144 fs/inode.c     	i->i_uid = 0;
i                 145 fs/inode.c     	i->i_size = 0;
i                 146 fs/inode.c     	i->i_atime = 0;
i                 147 fs/inode.c     	i->i_ctime = 0;
i                 148 fs/inode.c     	i->i_mtime = 0;
i                 149 fs/inode.c     	i->i_gid = 0;
i                 150 fs/inode.c     	i->i_nlink = 0;
i                 151 fs/inode.c     	i->i_blocks = 0;
i                 152 fs/inode.c     	i->i_flags = 0;
i                 153 fs/inode.c     	i->locked = 0;
i                 154 fs/inode.c     	i->dirty = 0;
i                 155 fs/inode.c     	i->mount_point = NULL;
i                 156 fs/inode.c     	i->dev = 0;
i                 157 fs/inode.c     	i->inode = 0;
i                 158 fs/inode.c     	i->count = 0;
i                 159 fs/inode.c     	i->rdev = 0;
i                 160 fs/inode.c     	i->fsop = NULL;
i                 161 fs/inode.c     	i->sb = NULL;
i                 162 fs/inode.c     	memset_b(&i->u, NULL, sizeof(i->u));
i                 165 fs/inode.c     	return i;
i                 168 fs/inode.c     static int read_inode(struct inode *i)
i                 172 fs/inode.c     	inode_lock(i);
i                 173 fs/inode.c     	if(i->sb && i->sb->fsop && i->sb->fsop->read_inode) {
i                 174 fs/inode.c     		errno = i->sb->fsop->read_inode(i);
i                 175 fs/inode.c     		inode_unlock(i);
i                 178 fs/inode.c     	inode_unlock(i);
i                 182 fs/inode.c     static int write_inode(struct inode *i)
i                 186 fs/inode.c     	inode_lock(i);
i                 187 fs/inode.c     	if(i->sb && i->sb->fsop && i->sb->fsop->write_inode) {
i                 188 fs/inode.c     		errno = i->sb->fsop->write_inode(i);
i                 191 fs/inode.c     		i->dirty = 0;
i                 194 fs/inode.c     	inode_unlock(i);
i                 201 fs/inode.c     	struct inode *i;
i                 205 fs/inode.c     	i = inode_hash_table[n];
i                 207 fs/inode.c     	while(i) {
i                 208 fs/inode.c     		if(i->dev == dev && i->inode == inode) {
i                 209 fs/inode.c     			return i;
i                 211 fs/inode.c     		i = i->next_hash;
i                 217 fs/inode.c     void inode_lock(struct inode *i)
i                 223 fs/inode.c     		if(i->locked) {
i                 225 fs/inode.c     			sleep(i, PROC_UNINTERRUPTIBLE);
i                 230 fs/inode.c     	i->locked = 1;
i                 234 fs/inode.c     void inode_unlock(struct inode *i)
i                 239 fs/inode.c     	i->locked = 0;
i                 240 fs/inode.c     	wakeup(i);
i                 247 fs/inode.c     	struct inode *i;
i                 249 fs/inode.c     	if((i = get_free_inode())) {
i                 250 fs/inode.c     		i->sb = sb;
i                 251 fs/inode.c     		i->rdev = sb->dev;
i                 252 fs/inode.c     		if(i->sb && i->sb->fsop && i->sb->fsop->ialloc) {
i                 253 fs/inode.c     			errno = i->sb->fsop->ialloc(i, mode);
i                 256 fs/inode.c     			i->count = 1;
i                 257 fs/inode.c     			i->sb = NULL;
i                 258 fs/inode.c     			iput(i);
i                 262 fs/inode.c     			i->count = 1;
i                 263 fs/inode.c     			i->sb = NULL;
i                 264 fs/inode.c     			iput(i);
i                 267 fs/inode.c     		i->dev = sb->dev;
i                 268 fs/inode.c     		insert_to_hash(i);
i                 269 fs/inode.c     		return i;
i                 278 fs/inode.c     	struct inode *i;
i                 285 fs/inode.c     		if((i = search_inode_hash(sb->dev, inode))) {
i                 286 fs/inode.c     			inode_lock(i);
i                 288 fs/inode.c     			if(i->mount_point) {
i                 289 fs/inode.c     				inode_unlock(i);
i                 290 fs/inode.c     				i = i->mount_point;
i                 291 fs/inode.c     				inode_lock(i);
i                 293 fs/inode.c     			if(!i->count) {
i                 294 fs/inode.c     				remove_from_free_list(i);
i                 296 fs/inode.c     			i->count++;
i                 297 fs/inode.c     			inode_unlock(i);
i                 298 fs/inode.c     			return i;
i                 301 fs/inode.c     		if(!(i = get_free_inode())) {
i                 307 fs/inode.c     		i->dev = i->rdev = sb->dev;
i                 308 fs/inode.c     		i->inode = inode;
i                 309 fs/inode.c     		i->sb = sb;
i                 310 fs/inode.c     		i->count = 1;
i                 312 fs/inode.c     		if(read_inode(i)) {
i                 313 fs/inode.c     			iput(i);
i                 316 fs/inode.c     		insert_to_hash(i);
i                 317 fs/inode.c     		return i;
i                 321 fs/inode.c     int bmap(struct inode *i, __off_t offset, int mode)
i                 323 fs/inode.c     	if(i->fsop && i->fsop->bmap) {
i                 324 fs/inode.c     		return i->fsop->bmap(i, offset, mode);
i                 331 fs/inode.c     	struct inode *i;
i                 334 fs/inode.c     	i = &inode_table[0];
i                 335 fs/inode.c     	for(n = 0; n < NR_INODES; n++, i = &inode_table[n]) {
i                 336 fs/inode.c     		if(i->dev == dev && i->count) {
i                 337 fs/inode.c     			if(i == root && i->count == 1) {
i                 341 fs/inode.c     			printk("WARNING: root %d with count %d (on dev %d,%d)\n", root->inode, root->count, MAJOR(i->dev), MINOR(i->dev));
i                 342 fs/inode.c     			printk("WARNING: inode %d with count %d (on dev %d,%d)\n", i->inode, i->count, MAJOR(i->dev), MINOR(i->dev));
i                 349 fs/inode.c     void iput(struct inode *i)
i                 354 fs/inode.c     	if(!i) {
i                 358 fs/inode.c     	if(!i->count) {
i                 359 fs/inode.c     		printk("WARNING: %s(): trying to free an already freed inode (%d)!\n", __FUNCTION__, i->inode);
i                 363 fs/inode.c     	if(--i->count > 0) {
i                 367 fs/inode.c     	if(!i->i_nlink) {
i                 368 fs/inode.c     		if(i->sb && i->sb->fsop && i->sb->fsop->ifree) {
i                 369 fs/inode.c     			inode_lock(i);
i                 370 fs/inode.c     			i->sb->fsop->ifree(i);
i                 371 fs/inode.c     			inode_unlock(i);
i                 373 fs/inode.c     		remove_from_hash(i);
i                 375 fs/inode.c     	if(i->dirty) {
i                 376 fs/inode.c     		if(write_inode(i)) {
i                 377 fs/inode.c     			printk("WARNING: %s(): can't write inode %d (%d,%d), will remain as dirty.\n", __FUNCTION__, i->inode, MAJOR(i->dev), MINOR(i->dev));
i                 383 fs/inode.c     	insert_on_free_list(i);
i                 389 fs/inode.c     	struct inode *i;
i                 392 fs/inode.c     	i = &inode_table[0];
i                 396 fs/inode.c     		if(i->dirty) {
i                 397 fs/inode.c     			if(!dev || i->dev == dev) {
i                 398 fs/inode.c     				if(write_inode(i)) {
i                 399 fs/inode.c     					printk("WARNING: %s(): can't write inode %d (%d,%d), will remain as dirty.\n", __FUNCTION__, i->inode, MAJOR(i->dev), MINOR(i->dev));
i                 403 fs/inode.c     		i++;
i                 412 fs/inode.c     	struct inode *i;
i                 414 fs/inode.c     	i = &inode_table[0];
i                 418 fs/inode.c     		if(i->dev == dev) {
i                 419 fs/inode.c     			inode_lock(i);
i                 420 fs/inode.c     			remove_from_hash(i);
i                 421 fs/inode.c     			inode_unlock(i);
i                 423 fs/inode.c     		i++;
i                 431 fs/inode.c     	struct inode *i;
i                 437 fs/inode.c     		i = &inode_table[n];
i                 438 fs/inode.c     		i->count = 1;
i                 439 fs/inode.c     		insert_on_free_list(i);
i                  60 fs/iso9660/dir.c int iso9660_dir_open(struct inode *i, struct fd *fd_table)
i                  66 fs/iso9660/dir.c int iso9660_dir_close(struct inode *i, struct fd *fd_table)
i                  71 fs/iso9660/dir.c int iso9660_dir_read(struct inode *i, struct fd *fd_table, char *buffer, __size_t count)
i                  76 fs/iso9660/dir.c int iso9660_dir_readdir(struct inode *i, struct fd *fd_table, struct dirent *dirent, unsigned int count)
i                  88 fs/iso9660/dir.c 	if(!(S_ISDIR(i->i_mode))) {
i                  92 fs/iso9660/dir.c 	blksize = i->sb->s_blocksize;
i                  93 fs/iso9660/dir.c 	if(fd_table->offset > i->i_size) {
i                  94 fs/iso9660/dir.c 		fd_table->offset = i->i_size;
i                 101 fs/iso9660/dir.c 		if((block = bmap(i, fd_table->offset, FOR_READING)) < 0) {
i                 105 fs/iso9660/dir.c 			if(!(buf = bread(i->dev, block, blksize))) {
i                 112 fs/iso9660/dir.c 			while(doffset < i->i_size && offset < blksize) {
i                 130 fs/iso9660/dir.c 							if(i->u.iso9660.i_parent) {
i                 131 fs/iso9660/dir.c 								dirent->d_ino = i->u.iso9660.i_parent->inode;
i                 133 fs/iso9660/dir.c 								dirent->d_ino = i->inode;
i                 137 fs/iso9660/dir.c 							if(i->sb->u.iso9660.rrip) {
i                 138 fs/iso9660/dir.c 								nm_len = get_rrip_filename(d, i, nm_name);
i                  61 fs/iso9660/file.c int iso9660_file_open(struct inode *i, struct fd *fd_table)
i                  70 fs/iso9660/file.c int iso9660_file_close(struct inode *i, struct fd *fd_table)
i                  75 fs/iso9660/file.c int iso9660_file_lseek(struct inode *i, __off_t offset)
i                  22 fs/iso9660/inode.c static int read_pathtable(struct inode *i)
i                  29 fs/iso9660/inode.c 	sbi = (struct iso9660_sb_info *)&i->sb->u.iso9660;
i                  43 fs/iso9660/inode.c 		if(!(buf = bread(i->dev, pt_blk++, BLKSIZE_2K))) {
i                  89 fs/iso9660/inode.c int iso9660_read_inode(struct inode *i)
i                  99 fs/iso9660/inode.c 	sb = (struct superblock *)i->sb;
i                 101 fs/iso9660/inode.c 		if((errno = read_pathtable(i))) {
i                 106 fs/iso9660/inode.c 	dblock = (i->inode & ~ISO9660_INODE_MASK) >> ISO9660_INODE_BITS;
i                 107 fs/iso9660/inode.c 	doffset = i->inode & ISO9660_INODE_MASK;
i                 108 fs/iso9660/inode.c 	blksize = i->sb->s_blocksize;
i                 111 fs/iso9660/inode.c 	if(!(buf = bread(i->dev, dblock, blksize))) {
i                 116 fs/iso9660/inode.c 		printk("WARNING: %s(): inode %d (dblock=%d, doffset=%d) not found in directory entry.\n", __FUNCTION__, i->inode, dblock, doffset);
i                 122 fs/iso9660/inode.c 	i->i_mode = S_IFREG;
i                 124 fs/iso9660/inode.c 		i->i_mode = S_IFDIR;
i                 127 fs/iso9660/inode.c 		i->i_mode |= S_IRUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH;
i                 129 fs/iso9660/inode.c 	i->i_uid = 0;
i                 130 fs/iso9660/inode.c 	i->i_size = isonum_733(d->size);
i                 131 fs/iso9660/inode.c 	i->i_atime = isodate(d->date);
i                 132 fs/iso9660/inode.c 	i->i_ctime = isodate(d->date);
i                 133 fs/iso9660/inode.c 	i->i_mtime = isodate(d->date);
i                 134 fs/iso9660/inode.c 	i->i_gid = 0;
i                 135 fs/iso9660/inode.c 	i->i_nlink = 1;
i                 136 fs/iso9660/inode.c 	i->count = 1;
i                 138 fs/iso9660/inode.c 	i->u.iso9660.i_extent = isonum_733(d->extent);
i                 139 fs/iso9660/inode.c 	check_rrip_inode(d, i);
i                 142 fs/iso9660/inode.c 	switch(i->i_mode & S_IFMT) {
i                 144 fs/iso9660/inode.c 			i->fsop = &def_chr_fsop;
i                 147 fs/iso9660/inode.c 			i->fsop = &def_blk_fsop;
i                 150 fs/iso9660/inode.c 			i->fsop = &pipefs_fsop;
i                 152 fs/iso9660/inode.c 			memset_b(&i->u.pipefs, NULL, sizeof(struct pipefs_inode));
i                 155 fs/iso9660/inode.c 			i->fsop = &iso9660_dir_fsop;
i                 156 fs/iso9660/inode.c 			i->i_nlink++;
i                 159 fs/iso9660/inode.c 			i->fsop = &iso9660_file_fsop;
i                 162 fs/iso9660/inode.c 			i->fsop = &iso9660_symlink_fsop;
i                 165 fs/iso9660/inode.c 			i->fsop = NULL;
i                 168 fs/iso9660/inode.c 			PANIC("invalid inode (%d) mode %08o.\n", i->inode, i->i_mode);
i                 173 fs/iso9660/inode.c int iso9660_bmap(struct inode *i, __off_t offset, int mode)
i                 177 fs/iso9660/inode.c 	block = i->u.iso9660.i_extent + (offset / i->sb->s_blocksize);
i                  19 fs/iso9660/rrip.c void check_rrip_inode(struct iso9660_directory_record *d, struct inode *i)
i                  46 fs/iso9660/rrip.c 		if(!(buf = bread(i->dev, ce_block, i->sb->s_blocksize))) {
i                  79 fs/iso9660/rrip.c 				i->sb->u.iso9660.rrip = 1;
i                  87 fs/iso9660/rrip.c 				i->i_mode  = isonum_733(rrip->u.px.mode);
i                  88 fs/iso9660/rrip.c 				i->i_nlink = isonum_733(rrip->u.px.nlink);
i                  89 fs/iso9660/rrip.c 				i->i_uid   = isonum_733(rrip->u.px.uid);
i                  90 fs/iso9660/rrip.c 				i->i_gid   = isonum_733(rrip->u.px.gid);
i                  93 fs/iso9660/rrip.c 				if(S_ISBLK(i->i_mode) || S_ISCHR(i->i_mode)) {
i                  96 fs/iso9660/rrip.c 					i->rdev = MKDEV(dev_h, dev_l);
i                 127 fs/iso9660/rrip.c 				i->i_size = nm_len;
i                 132 fs/iso9660/rrip.c 					i->i_ctime = isodate(rrip->u.tf.times[n++].time);
i                 135 fs/iso9660/rrip.c 					i->i_mtime = isodate(rrip->u.tf.times[n++].time);
i                 138 fs/iso9660/rrip.c 					i->i_atime = isodate(rrip->u.tf.times[n++].time);
i                 141 fs/iso9660/rrip.c 					i->i_ctime = isodate(rrip->u.tf.times[n++].time);
i                 152 fs/iso9660/rrip.c int get_rrip_filename(struct iso9660_directory_record *d, struct inode *i, char *name)
i                 176 fs/iso9660/rrip.c 		if(!(buf = bread(i->dev, ce_block, i->sb->s_blocksize))) {
i                 228 fs/iso9660/rrip.c int get_rrip_symlink(struct inode *i, char *name)
i                 245 fs/iso9660/rrip.c 	dblock = (i->inode & ~ISO9660_INODE_MASK) >> ISO9660_INODE_BITS;
i                 246 fs/iso9660/rrip.c 	doffset = i->inode & ISO9660_INODE_MASK;
i                 248 fs/iso9660/rrip.c 	if(!(buf = bread(i->dev, dblock, i->sb->s_blocksize))) {
i                 266 fs/iso9660/rrip.c 		if(!(buf2 = bread(i->dev, ce_block, i->sb->s_blocksize))) {
i                  61 fs/iso9660/symlink.c int iso9660_readlink(struct inode *i, char *buffer, __size_t count)
i                  70 fs/iso9660/symlink.c 	inode_lock(i);
i                  72 fs/iso9660/symlink.c 	if((size_read = get_rrip_symlink(i, name))) {
i                  77 fs/iso9660/symlink.c 	inode_unlock(i);
i                  81 fs/iso9660/symlink.c int iso9660_followlink(struct inode *dir, struct inode *i, struct inode **i_res)
i                  86 fs/iso9660/symlink.c 	if(!i) {
i                  89 fs/iso9660/symlink.c 	if(!S_ISLNK(i->i_mode)) {
i                  90 fs/iso9660/symlink.c 		printk("%s(): Oops, inode '%d' is not a symlink (!?).\n", __FUNCTION__, i->inode);
i                  99 fs/iso9660/symlink.c 	if(get_rrip_symlink(i, name)) {
i                 100 fs/iso9660/symlink.c 		iput(i);
i                  19 fs/locks.c     static struct flock_file * get_new_flock(struct inode *i)
i                  29 fs/locks.c     			ff->inode = i;	/* mark it as busy */
i                  45 fs/locks.c     static struct flock_file * get_flock_file(struct inode *i, int op, struct proc *p)
i                  55 fs/locks.c     		if(ff->inode != i) {
i                  71 fs/locks.c     	struct inode *i;
i                  75 fs/locks.c     	i = fd_table[current->fd[ufd]].inode;
i                  78 fs/locks.c     		if(ff->inode != i) {
i                  85 fs/locks.c     		if(ff->inode == i) {
i                 110 fs/locks.c     		return flock_inode(i, type);
i                 113 fs/locks.c     		return flock_inode(i, type | LOCK_NB);
i                 118 fs/locks.c     void flock_release_inode(struct inode *i)
i                 126 fs/locks.c     		if(ff->inode != i) {
i                 138 fs/locks.c     int flock_inode(struct inode *i, int op)
i                 144 fs/locks.c     		if((ff = get_flock_file(i, op, current))) {
i                 156 fs/locks.c     		if(ff->inode != i) {
i                 194 fs/locks.c     		if(!(new = get_new_flock(i))) {
i                 198 fs/locks.c     	new->inode = i;
i                  61 fs/minix/dir.c int minix_dir_open(struct inode *i, struct fd *fd_table)
i                  67 fs/minix/dir.c int minix_dir_close(struct inode *i, struct fd *fd_table)
i                  72 fs/minix/dir.c int minix_dir_read(struct inode *i, struct fd *fd_table, char *buffer, __size_t count)
i                  77 fs/minix/dir.c int minix_dir_write(struct inode *i, struct fd *fd_table, const char *buffer, __size_t count)
i                  82 fs/minix/dir.c int minix_dir_readdir(struct inode *i, struct fd *fd_table, struct dirent *dirent, unsigned int count)
i                  92 fs/minix/dir.c 	if(!(S_ISDIR(i->i_mode))) {
i                  96 fs/minix/dir.c 	blksize = i->sb->s_blocksize;
i                  97 fs/minix/dir.c 	if(fd_table->offset > i->i_size) {
i                  98 fs/minix/dir.c 		fd_table->offset = i->i_size;
i                 104 fs/minix/dir.c 	while(fd_table->offset < i->i_size && count > 0) {
i                 105 fs/minix/dir.c 		if((block = bmap(i, fd_table->offset, FOR_READING)) < 0) {
i                 109 fs/minix/dir.c 			if(!(buf = bread(i->dev, block, blksize))) {
i                 134 fs/minix/dir.c 				doffset += i->sb->u.minix.dirsize;
i                 135 fs/minix/dir.c 				offset += i->sb->u.minix.dirsize;
i                  62 fs/minix/file.c int minix_file_open(struct inode *i, struct fd *fd_table)
i                  65 fs/minix/file.c 		fd_table->offset = i->i_size;
i                  70 fs/minix/file.c 		i->i_size = 0;
i                  71 fs/minix/file.c 		minix_truncate(i, 0);
i                  76 fs/minix/file.c int minix_file_close(struct inode *i, struct fd *fd_table)
i                  81 fs/minix/file.c int minix_file_write(struct inode *i, struct fd *fd_table, const char *buffer, __size_t count)
i                  89 fs/minix/file.c 	inode_lock(i);
i                  91 fs/minix/file.c 	blksize = i->sb->s_blocksize;
i                  95 fs/minix/file.c 		fd_table->offset = i->i_size;
i                 100 fs/minix/file.c 		if((block = bmap(i, fd_table->offset, FOR_WRITING)) < 0) {
i                 101 fs/minix/file.c 			inode_unlock(i);
i                 106 fs/minix/file.c 		if(!(buf = bread(i->dev, block, blksize))) {
i                 107 fs/minix/file.c 			inode_unlock(i);
i                 111 fs/minix/file.c 		update_page_cache(i, fd_table->offset, buffer + total_written, bytes);
i                 117 fs/minix/file.c 	if(fd_table->offset > i->i_size) {
i                 118 fs/minix/file.c 		i->i_size = fd_table->offset;
i                 120 fs/minix/file.c 	i->i_ctime = CURRENT_TIME;
i                 121 fs/minix/file.c 	i->i_mtime = CURRENT_TIME;
i                 122 fs/minix/file.c 	i->dirty = 1;
i                 124 fs/minix/file.c 	inode_unlock(i);
i                 128 fs/minix/file.c int minix_file_lseek(struct inode *i, __off_t offset)
i                  23 fs/minix/inode.c int minix_read_inode(struct inode *i)
i                  25 fs/minix/inode.c 	if(i->sb->u.minix.version == 1) {
i                  26 fs/minix/inode.c 		return v1_minix_read_inode(i);
i                  29 fs/minix/inode.c 	return v2_minix_read_inode(i);
i                  32 fs/minix/inode.c int minix_write_inode(struct inode *i)
i                  34 fs/minix/inode.c 	if(i->sb->u.minix.version == 1) {
i                  35 fs/minix/inode.c 		return v1_minix_write_inode(i);
i                  38 fs/minix/inode.c 	return v2_minix_write_inode(i);
i                  41 fs/minix/inode.c int minix_ialloc(struct inode *i, int mode)
i                  43 fs/minix/inode.c 	if(i->sb->u.minix.version == 1) {
i                  44 fs/minix/inode.c 		return v1_minix_ialloc(i, mode);
i                  47 fs/minix/inode.c 	return v2_minix_ialloc(i, mode);
i                  50 fs/minix/inode.c void minix_ifree(struct inode *i)
i                  52 fs/minix/inode.c 	if(i->sb->u.minix.version == 1) {
i                  53 fs/minix/inode.c 		return v1_minix_ifree(i);
i                  56 fs/minix/inode.c 	return v2_minix_ifree(i);
i                  59 fs/minix/inode.c int minix_bmap(struct inode *i, __off_t offset, int mode)
i                  61 fs/minix/inode.c 	if(i->sb->u.minix.version == 1) {
i                  62 fs/minix/inode.c 		return v1_minix_bmap(i, offset, mode);
i                  65 fs/minix/inode.c 	return v2_minix_bmap(i, offset, mode);
i                  68 fs/minix/inode.c int minix_truncate(struct inode *i, __off_t length)
i                  70 fs/minix/inode.c 	if(i->sb->u.minix.version == 1) {
i                  71 fs/minix/inode.c 		return v1_minix_truncate(i, length);
i                  74 fs/minix/inode.c 	return v2_minix_truncate(i, length);
i                  62 fs/minix/namei.c static struct buffer * find_dir_entry(struct inode *dir, struct inode *i, struct minix_dir_entry **d_res, char *name)
i                  83 fs/minix/namei.c 				if(!i) {
i                  93 fs/minix/namei.c 					if((*d_res)->inode == i->inode) {
i                 213 fs/minix/namei.c int minix_rmdir(struct inode *dir, struct inode *i)
i                 218 fs/minix/namei.c 	inode_lock(i);
i                 220 fs/minix/namei.c 	if(!is_dir_empty(i)) {
i                 221 fs/minix/namei.c 		inode_unlock(i);
i                 227 fs/minix/namei.c 	if(!(buf = find_dir_entry(dir, i, &d, NULL))) {
i                 228 fs/minix/namei.c 		inode_unlock(i);
i                 234 fs/minix/namei.c 	i->i_nlink = 0;
i                 237 fs/minix/namei.c 	i->i_ctime = CURRENT_TIME;
i                 241 fs/minix/namei.c 	i->dirty = 1;
i                 246 fs/minix/namei.c 	inode_unlock(i);
i                 292 fs/minix/namei.c int minix_unlink(struct inode *dir, struct inode *i, char *name)
i                 298 fs/minix/namei.c 	inode_lock(i);
i                 300 fs/minix/namei.c 	if(!(buf = find_dir_entry(dir, i, &d, name))) {
i                 302 fs/minix/namei.c 		inode_unlock(i);
i                 307 fs/minix/namei.c 	i->i_nlink--;
i                 309 fs/minix/namei.c 	i->i_ctime = CURRENT_TIME;
i                 313 fs/minix/namei.c 	i->dirty = 1;
i                 319 fs/minix/namei.c 	inode_unlock(i);
i                 326 fs/minix/namei.c 	struct inode *i;
i                 334 fs/minix/namei.c 	if(!(i = ialloc(dir->sb, S_IFLNK))) {
i                 339 fs/minix/namei.c 	i->i_mode = S_IFLNK | (S_IRWXU | S_IRWXG | S_IRWXO);
i                 340 fs/minix/namei.c 	i->i_uid = current->euid;
i                 341 fs/minix/namei.c 	i->i_gid = current->egid;
i                 342 fs/minix/namei.c 	i->i_nlink = 1;
i                 343 fs/minix/namei.c 	i->dev = dir->dev;
i                 344 fs/minix/namei.c 	i->count = 1;
i                 345 fs/minix/namei.c 	i->fsop = &minix_symlink_fsop;
i                 346 fs/minix/namei.c 	i->dirty = 1;
i                 350 fs/minix/namei.c 		i->i_nlink = 0;
i                 351 fs/minix/namei.c 		iput(i);
i                 356 fs/minix/namei.c 	if(i->sb->u.minix.version == 1) {
i                 357 fs/minix/namei.c 		i->u.minix.u.i1_zone[0] = block;
i                 359 fs/minix/namei.c 		i->u.minix.u.i2_zone[0] = block;
i                 364 fs/minix/namei.c 		i->i_nlink = 0;
i                 365 fs/minix/namei.c 		iput(i);
i                 372 fs/minix/namei.c 		i->i_nlink = 0;
i                 373 fs/minix/namei.c 		iput(i);
i                 378 fs/minix/namei.c 	d->inode = i->inode;
i                 379 fs/minix/namei.c 	for(n = 0; n < i->sb->u.minix.namelen; n++) {
i                 385 fs/minix/namei.c 	for(; n < i->sb->u.minix.namelen; n++) {
i                 397 fs/minix/namei.c 	i->i_size = n;
i                 405 fs/minix/namei.c 	iput(i);
i                 413 fs/minix/namei.c 	struct inode *i;
i                 424 fs/minix/namei.c 	if(!(i = ialloc(dir->sb, S_IFDIR))) {
i                 429 fs/minix/namei.c 	i->i_mode = ((mode & (S_IRWXU | S_IRWXG | S_IRWXO)) & ~current->umask);
i                 430 fs/minix/namei.c 	i->i_mode |= S_IFDIR;
i                 431 fs/minix/namei.c 	i->i_uid = current->euid;
i                 432 fs/minix/namei.c 	i->i_gid = current->egid;
i                 433 fs/minix/namei.c 	i->i_nlink = 1;
i                 434 fs/minix/namei.c 	i->dev = dir->dev;
i                 435 fs/minix/namei.c 	i->count = 1;
i                 436 fs/minix/namei.c 	i->fsop = &minix_dir_fsop;
i                 437 fs/minix/namei.c 	i->dirty = 1;
i                 439 fs/minix/namei.c 	if((block = bmap(i, 0, FOR_WRITING)) < 0) {
i                 440 fs/minix/namei.c 		i->i_nlink = 0;
i                 441 fs/minix/namei.c 		iput(i);
i                 447 fs/minix/namei.c 	if(!(buf_new = bread(i->dev, block, blksize))) {
i                 449 fs/minix/namei.c 		i->i_nlink = 0;
i                 450 fs/minix/namei.c 		iput(i);
i                 457 fs/minix/namei.c 		i->i_nlink = 0;
i                 458 fs/minix/namei.c 		iput(i);
i                 463 fs/minix/namei.c 	d->inode = i->inode;
i                 464 fs/minix/namei.c 	for(n = 0; n < i->sb->u.minix.namelen; n++) {
i                 470 fs/minix/namei.c 	for(; n < i->sb->u.minix.namelen; n++) {
i                 475 fs/minix/namei.c 	d_new->inode = i->inode;
i                 478 fs/minix/namei.c 	i->i_size += i->sb->u.minix.dirsize;
i                 479 fs/minix/namei.c 	i->i_nlink++;
i                 480 fs/minix/namei.c 	d_new = (struct minix_dir_entry *)(buf_new->data + i->sb->u.minix.dirsize);
i                 485 fs/minix/namei.c 	i->i_size += i->sb->u.minix.dirsize;
i                 494 fs/minix/namei.c 	iput(i);
i                 502 fs/minix/namei.c 	struct inode *i;
i                 508 fs/minix/namei.c 	if(!(i = ialloc(dir->sb, mode & S_IFMT))) {
i                 514 fs/minix/namei.c 		i->i_nlink = 0;
i                 515 fs/minix/namei.c 		iput(i);
i                 520 fs/minix/namei.c 	d->inode = i->inode;
i                 521 fs/minix/namei.c 	for(n = 0; n < i->sb->u.minix.namelen; n++) {
i                 527 fs/minix/namei.c 	for(; n < i->sb->u.minix.namelen; n++) {
i                 531 fs/minix/namei.c 	i->i_mode = (mode & ~current->umask) & ~S_IFMT;
i                 532 fs/minix/namei.c 	i->i_uid = current->euid;
i                 533 fs/minix/namei.c 	i->i_gid = current->egid;
i                 534 fs/minix/namei.c 	i->i_nlink = 1;
i                 535 fs/minix/namei.c 	i->dev = dir->dev;
i                 536 fs/minix/namei.c 	i->count = 1;
i                 537 fs/minix/namei.c 	i->dirty = 1;
i                 541 fs/minix/namei.c 			i->fsop = &def_chr_fsop;
i                 542 fs/minix/namei.c 			i->rdev = dev;
i                 543 fs/minix/namei.c 			i->i_mode |= S_IFCHR;
i                 546 fs/minix/namei.c 			i->fsop = &def_blk_fsop;
i                 547 fs/minix/namei.c 			i->rdev = dev;
i                 548 fs/minix/namei.c 			i->i_mode |= S_IFBLK;
i                 551 fs/minix/namei.c 			i->fsop = &pipefs_fsop;
i                 552 fs/minix/namei.c 			i->i_mode |= S_IFIFO;
i                 554 fs/minix/namei.c 			memset_b(&i->u.pipefs, NULL, sizeof(struct pipefs_inode));
i                 563 fs/minix/namei.c 	iput(i);
i                 571 fs/minix/namei.c 	struct inode *i;
i                 581 fs/minix/namei.c 	if(!(i = ialloc(dir->sb, S_IFREG))) {
i                 587 fs/minix/namei.c 		i->i_nlink = 0;
i                 588 fs/minix/namei.c 		iput(i);
i                 593 fs/minix/namei.c 	d->inode = i->inode;
i                 594 fs/minix/namei.c 	for(n = 0; n < i->sb->u.minix.namelen; n++) {
i                 600 fs/minix/namei.c 	for(; n < i->sb->u.minix.namelen; n++) {
i                 604 fs/minix/namei.c 	i->i_mode = (mode & ~current->umask) & ~S_IFMT;
i                 605 fs/minix/namei.c 	i->i_mode |= S_IFREG;
i                 606 fs/minix/namei.c 	i->i_uid = current->euid;
i                 607 fs/minix/namei.c 	i->i_gid = current->egid;
i                 608 fs/minix/namei.c 	i->i_nlink = 1;
i                 609 fs/minix/namei.c 	i->dev = dir->dev;
i                 610 fs/minix/namei.c 	i->fsop = &minix_file_fsop;
i                 611 fs/minix/namei.c 	i->count = 1;
i                 612 fs/minix/namei.c 	i->dirty = 1;
i                 618 fs/minix/namei.c 	*i_res = i;
i                  59 fs/minix/symlink.c int minix_readlink(struct inode *i, char *buffer, __size_t count)
i                  64 fs/minix/symlink.c 	if(!S_ISLNK(i->i_mode)) {
i                  65 fs/minix/symlink.c 		printk("%s(): Oops, inode '%d' is not a symlink (!?).\n", __FUNCTION__, i->inode);
i                  69 fs/minix/symlink.c 	inode_lock(i);
i                  70 fs/minix/symlink.c 	blksize = i->sb->s_blocksize;
i                  71 fs/minix/symlink.c 	count = MIN(count, i->i_size);
i                  73 fs/minix/symlink.c 		inode_unlock(i);
i                  77 fs/minix/symlink.c 	if(i->sb->u.minix.version == 1) {
i                  78 fs/minix/symlink.c 		if(!(buf = bread(i->dev, i->u.minix.u.i1_zone[0], blksize))) {
i                  79 fs/minix/symlink.c 			inode_unlock(i);
i                  83 fs/minix/symlink.c 		if(!(buf = bread(i->dev, i->u.minix.u.i2_zone[0], blksize))) {
i                  84 fs/minix/symlink.c 			inode_unlock(i);
i                  91 fs/minix/symlink.c 	inode_unlock(i);
i                  95 fs/minix/symlink.c int minix_followlink(struct inode *dir, struct inode *i, struct inode **i_res)
i                 101 fs/minix/symlink.c 	if(!i) {
i                 105 fs/minix/symlink.c 	if(!S_ISLNK(i->i_mode)) {
i                 106 fs/minix/symlink.c 		printk("%s(): Oops, inode '%d' is not a symlink (!?).\n", __FUNCTION__, i->inode);
i                 115 fs/minix/symlink.c 	inode_lock(i);
i                 116 fs/minix/symlink.c 	if(i->sb->u.minix.version == 1) {
i                 117 fs/minix/symlink.c 		if(!(buf = bread(i->dev, i->u.minix.u.i1_zone[0], i->sb->s_blocksize))) {
i                 118 fs/minix/symlink.c 			inode_unlock(i);
i                 122 fs/minix/symlink.c 		if(!(buf = bread(i->dev, i->u.minix.u.i2_zone[0], i->sb->s_blocksize))) {
i                 123 fs/minix/symlink.c 			inode_unlock(i);
i                 128 fs/minix/symlink.c 	inode_unlock(i);
i                 131 fs/minix/symlink.c 	iput(i);
i                  30 fs/minix/v1_inode.c static void free_zone(struct inode *i, int block, int offset)
i                  36 fs/minix/v1_inode.c 	if(!(buf = bread(i->dev, block, i->sb->s_blocksize))) {
i                  41 fs/minix/v1_inode.c 	for(n = offset; n < BLOCKS_PER_IND_BLOCK(i->sb); n++) {
i                  43 fs/minix/v1_inode.c 			minix_bfree(i->sb, zone[n]);
i                  50 fs/minix/v1_inode.c int v1_minix_read_inode(struct inode *i)
i                  58 fs/minix/v1_inode.c 	block = 1 + SUPERBLOCK + i->sb->u.minix.sb.s_imap_blocks + i->sb->u.minix.sb.s_zmap_blocks + (i->inode - 1) / MINIX_INODES_PER_BLOCK(i->sb);
i                  60 fs/minix/v1_inode.c 	if(!(buf = bread(i->dev, block, i->sb->s_blocksize))) {
i                  63 fs/minix/v1_inode.c 	offset = (i->inode - 1) % MINIX_INODES_PER_BLOCK(i->sb);
i                  66 fs/minix/v1_inode.c 	i->i_mode = ii->i_mode;
i                  67 fs/minix/v1_inode.c 	i->i_uid = ii->i_uid;
i                  68 fs/minix/v1_inode.c 	i->i_size = ii->i_size;
i                  69 fs/minix/v1_inode.c 	i->i_atime = ii->i_time;
i                  70 fs/minix/v1_inode.c 	i->i_ctime = ii->i_time;
i                  71 fs/minix/v1_inode.c 	i->i_mtime = ii->i_time;
i                  72 fs/minix/v1_inode.c 	i->i_gid = ii->i_gid;
i                  73 fs/minix/v1_inode.c 	i->i_nlink = ii->i_nlinks;
i                  74 fs/minix/v1_inode.c 	memcpy_b(i->u.minix.u.i1_zone, ii->i_zone, sizeof(ii->i_zone));
i                  75 fs/minix/v1_inode.c 	i->count = 1;
i                  78 fs/minix/v1_inode.c 	switch(i->i_mode & S_IFMT) {
i                  80 fs/minix/v1_inode.c 			i->fsop = &def_chr_fsop;
i                  81 fs/minix/v1_inode.c 			i->rdev = ii->i_zone[0];
i                  84 fs/minix/v1_inode.c 			i->fsop = &def_blk_fsop;
i                  85 fs/minix/v1_inode.c 			i->rdev = ii->i_zone[0];
i                  88 fs/minix/v1_inode.c 			i->fsop = &pipefs_fsop;
i                  90 fs/minix/v1_inode.c 			memset_b(&i->u.pipefs, NULL, sizeof(struct pipefs_inode));
i                  93 fs/minix/v1_inode.c 			i->fsop = &minix_dir_fsop;
i                  96 fs/minix/v1_inode.c 			i->fsop = &minix_file_fsop;
i                  99 fs/minix/v1_inode.c 			i->fsop = &minix_symlink_fsop;
i                 102 fs/minix/v1_inode.c 			i->fsop = NULL;
i                 105 fs/minix/v1_inode.c 			printk("WARNING: %s(): invalid inode (%d) mode %o.\n", __FUNCTION__, i->inode, i->i_mode);
i                 114 fs/minix/v1_inode.c int v1_minix_write_inode(struct inode *i)
i                 121 fs/minix/v1_inode.c 	block = 1 + SUPERBLOCK + i->sb->u.minix.sb.s_imap_blocks + i->sb->u.minix.sb.s_zmap_blocks + (i->inode - 1) / MINIX_INODES_PER_BLOCK(i->sb);
i                 123 fs/minix/v1_inode.c 	if(!(buf = bread(i->dev, block, i->sb->s_blocksize))) {
i                 126 fs/minix/v1_inode.c 	offset = (i->inode - 1) % MINIX_INODES_PER_BLOCK(i->sb);
i                 129 fs/minix/v1_inode.c 	ii->i_mode = i->i_mode;
i                 130 fs/minix/v1_inode.c 	ii->i_uid = i->i_uid;
i                 131 fs/minix/v1_inode.c 	ii->i_size = i->i_size;
i                 132 fs/minix/v1_inode.c 	ii->i_time = i->i_mtime;
i                 133 fs/minix/v1_inode.c 	ii->i_gid = i->i_gid;
i                 134 fs/minix/v1_inode.c 	ii->i_nlinks = i->i_nlink;
i                 135 fs/minix/v1_inode.c 	if(S_ISCHR(i->i_mode) || S_ISBLK(i->i_mode)) {
i                 136 fs/minix/v1_inode.c 		ii->i_zone[0] = i->rdev;
i                 138 fs/minix/v1_inode.c 		memcpy_b(ii->i_zone, i->u.minix.u.i1_zone, sizeof(i->u.minix.u.i1_zone));
i                 140 fs/minix/v1_inode.c 	i->dirty = 0;
i                 145 fs/minix/v1_inode.c int v1_minix_ialloc(struct inode *i, int mode)
i                 151 fs/minix/v1_inode.c 	sb = i->sb;
i                 173 fs/minix/v1_inode.c 	i->inode = inode;
i                 174 fs/minix/v1_inode.c 	i->i_atime = CURRENT_TIME;
i                 175 fs/minix/v1_inode.c 	i->i_mtime = CURRENT_TIME;
i                 176 fs/minix/v1_inode.c 	i->i_ctime = CURRENT_TIME;
i                 181 fs/minix/v1_inode.c void v1_minix_ifree(struct inode *i)
i                 186 fs/minix/v1_inode.c 	minix_truncate(i, 0);
i                 188 fs/minix/v1_inode.c 	sb = i->sb;
i                 191 fs/minix/v1_inode.c 	errno = minix_change_bit(CLEAR_BIT, i->sb, 1 + SUPERBLOCK, i->inode);
i                 195 fs/minix/v1_inode.c 			printk("WARNING: %s(): unable to clear inode %d.\n", __FUNCTION__, i->inode);
i                 197 fs/minix/v1_inode.c 			printk("WARNING: %s(): inode %d is already marked as free!\n", __FUNCTION__, i->inode);
i                 201 fs/minix/v1_inode.c 	i->i_size = 0;
i                 202 fs/minix/v1_inode.c 	i->i_mtime = CURRENT_TIME;
i                 203 fs/minix/v1_inode.c 	i->i_ctime = CURRENT_TIME;
i                 204 fs/minix/v1_inode.c 	i->dirty = 1;
i                 208 fs/minix/v1_inode.c int v1_minix_bmap(struct inode *i, __off_t offset, int mode)
i                 216 fs/minix/v1_inode.c 	blksize = i->sb->s_blocksize;
i                 223 fs/minix/v1_inode.c 		if(block < (BLOCKS_PER_IND_BLOCK(i->sb) + MINIX_NDIR_BLOCKS)) {
i                 232 fs/minix/v1_inode.c 		if(!i->u.minix.u.i1_zone[block] && mode == FOR_WRITING) {
i                 233 fs/minix/v1_inode.c 			if((newblock = minix_balloc(i->sb)) < 0) {
i                 237 fs/minix/v1_inode.c 			if(!(buf = bread(i->dev, newblock, blksize))) {
i                 238 fs/minix/v1_inode.c 				minix_bfree(i->sb, newblock);
i                 243 fs/minix/v1_inode.c 			i->u.minix.u.i1_zone[block] = newblock;
i                 245 fs/minix/v1_inode.c 		return i->u.minix.u.i1_zone[block];
i                 248 fs/minix/v1_inode.c 	if(!i->u.minix.u.i1_zone[level]) {
i                 250 fs/minix/v1_inode.c 			if((newblock = minix_balloc(i->sb)) < 0) {
i                 254 fs/minix/v1_inode.c 			if(!(buf = bread(i->dev, newblock, blksize))) {
i                 255 fs/minix/v1_inode.c 				minix_bfree(i->sb, newblock);
i                 260 fs/minix/v1_inode.c 			i->u.minix.u.i1_zone[level] = newblock;
i                 265 fs/minix/v1_inode.c 	if(!(buf = bread(i->dev, i->u.minix.u.i1_zone[level], blksize))) {
i                 269 fs/minix/v1_inode.c 	dblock = block - BLOCKS_PER_IND_BLOCK(i->sb);
i                 272 fs/minix/v1_inode.c 		block = dblock / BLOCKS_PER_IND_BLOCK(i->sb);
i                 277 fs/minix/v1_inode.c 			if((newblock = minix_balloc(i->sb)) < 0) {
i                 282 fs/minix/v1_inode.c 			if(!(buf2 = bread(i->dev, newblock, blksize))) {
i                 283 fs/minix/v1_inode.c 				minix_bfree(i->sb, newblock);
i                 307 fs/minix/v1_inode.c 	if(!(buf2 = bread(i->dev, indblock[iblock], blksize))) {
i                 313 fs/minix/v1_inode.c 	block = dindblock[dblock - (iblock * BLOCKS_PER_IND_BLOCK(i->sb))];
i                 315 fs/minix/v1_inode.c 		if((newblock = minix_balloc(i->sb)) < 0) {
i                 321 fs/minix/v1_inode.c 		if(!(buf3 = bread(i->dev, newblock, blksize))) {
i                 322 fs/minix/v1_inode.c 			minix_bfree(i->sb, newblock);
i                 329 fs/minix/v1_inode.c 		dindblock[dblock - (iblock * BLOCKS_PER_IND_BLOCK(i->sb))] = newblock;
i                 338 fs/minix/v1_inode.c int v1_minix_truncate(struct inode *i, __off_t length)
i                 345 fs/minix/v1_inode.c 	block = length / i->sb->s_blocksize;
i                 347 fs/minix/v1_inode.c 	if(!S_ISDIR(i->i_mode) && !S_ISREG(i->i_mode) && !S_ISLNK(i->i_mode)) {
i                 353 fs/minix/v1_inode.c 			if(i->u.minix.u.i1_zone[n]) {
i                 354 fs/minix/v1_inode.c 				minix_bfree(i->sb, i->u.minix.u.i1_zone[n]);
i                 355 fs/minix/v1_inode.c 				i->u.minix.u.i1_zone[n] = 0;
i                 361 fs/minix/v1_inode.c 	if(!block || block < (BLOCKS_PER_IND_BLOCK(i->sb) + MINIX_NDIR_BLOCKS)) {
i                 365 fs/minix/v1_inode.c 		if(i->u.minix.u.i1_zone[MINIX_IND_BLOCK]) {
i                 366 fs/minix/v1_inode.c 			free_zone(i, i->u.minix.u.i1_zone[MINIX_IND_BLOCK], block);
i                 368 fs/minix/v1_inode.c 				minix_bfree(i->sb, i->u.minix.u.i1_zone[MINIX_IND_BLOCK]);
i                 369 fs/minix/v1_inode.c 				i->u.minix.u.i1_zone[MINIX_IND_BLOCK] = 0;
i                 377 fs/minix/v1_inode.c 		block -= BLOCKS_PER_IND_BLOCK(i->sb);
i                 379 fs/minix/v1_inode.c 	if(i->u.minix.u.i1_zone[MINIX_DIND_BLOCK]) {
i                 380 fs/minix/v1_inode.c 		if(!(buf = bread(i->dev, i->u.minix.u.i1_zone[MINIX_DIND_BLOCK], i->sb->s_blocksize))) {
i                 381 fs/minix/v1_inode.c 			printk("%s(): error reading block %d.\n", __FUNCTION__, i->u.minix.u.i1_zone[MINIX_DIND_BLOCK]);
i                 384 fs/minix/v1_inode.c 		dblock = block % BLOCKS_PER_IND_BLOCK(i->sb);
i                 385 fs/minix/v1_inode.c 		for(n = block / BLOCKS_PER_IND_BLOCK(i->sb); n < BLOCKS_PER_IND_BLOCK(i->sb); n++) {
i                 387 fs/minix/v1_inode.c 				free_zone(i, zone[n], dblock);
i                 389 fs/minix/v1_inode.c 					minix_bfree(i->sb, zone[n]);
i                 396 fs/minix/v1_inode.c 			minix_bfree(i->sb, i->u.minix.u.i1_zone[MINIX_DIND_BLOCK]);
i                 397 fs/minix/v1_inode.c 			i->u.minix.u.i1_zone[MINIX_DIND_BLOCK] = 0;
i                 401 fs/minix/v1_inode.c 	i->i_mtime = CURRENT_TIME;
i                 402 fs/minix/v1_inode.c 	i->i_ctime = CURRENT_TIME;
i                 403 fs/minix/v1_inode.c 	i->i_size = length;
i                 404 fs/minix/v1_inode.c 	i->dirty = 1;
i                  31 fs/minix/v2_inode.c static void free_zone(struct inode *i, int block, int offset)
i                  37 fs/minix/v2_inode.c 	if(!(buf = bread(i->dev, block, i->sb->s_blocksize))) {
i                  42 fs/minix/v2_inode.c 	for(n = offset; n < BLOCKS_PER_IND_BLOCK(i->sb); n++) {
i                  44 fs/minix/v2_inode.c 			minix_bfree(i->sb, zone[n]);
i                  51 fs/minix/v2_inode.c int v2_minix_read_inode(struct inode *i)
i                  59 fs/minix/v2_inode.c 	block = 1 + SUPERBLOCK + i->sb->u.minix.sb.s_imap_blocks + i->sb->u.minix.sb.s_zmap_blocks + (i->inode - 1) / MINIX2_INODES_PER_BLOCK(i->sb);
i                  61 fs/minix/v2_inode.c 	if(!(buf = bread(i->dev, block, i->sb->s_blocksize))) {
i                  64 fs/minix/v2_inode.c 	offset = (i->inode - 1) % MINIX2_INODES_PER_BLOCK(i->sb);
i                  67 fs/minix/v2_inode.c 	i->i_mode = ii->i_mode;
i                  68 fs/minix/v2_inode.c 	i->i_nlink = ii->i_nlink;
i                  69 fs/minix/v2_inode.c 	i->i_uid = ii->i_uid;
i                  70 fs/minix/v2_inode.c 	i->i_gid = ii->i_gid;
i                  71 fs/minix/v2_inode.c 	i->i_size = ii->i_size;
i                  72 fs/minix/v2_inode.c 	i->i_atime = ii->i_atime;
i                  73 fs/minix/v2_inode.c 	i->i_mtime = ii->i_mtime;
i                  74 fs/minix/v2_inode.c 	i->i_ctime = ii->i_ctime;
i                  75 fs/minix/v2_inode.c 	memcpy_b(i->u.minix.u.i2_zone, ii->i_zone, sizeof(ii->i_zone));
i                  76 fs/minix/v2_inode.c 	i->count = 1;
i                  79 fs/minix/v2_inode.c 	switch(i->i_mode & S_IFMT) {
i                  81 fs/minix/v2_inode.c 			i->fsop = &def_chr_fsop;
i                  82 fs/minix/v2_inode.c 			i->rdev = ii->i_zone[0];
i                  85 fs/minix/v2_inode.c 			i->fsop = &def_blk_fsop;
i                  86 fs/minix/v2_inode.c 			i->rdev = ii->i_zone[0];
i                  89 fs/minix/v2_inode.c 			i->fsop = &pipefs_fsop;
i                  91 fs/minix/v2_inode.c 			memset_b(&i->u.pipefs, NULL, sizeof(struct pipefs_inode));
i                  94 fs/minix/v2_inode.c 			i->fsop = &minix_dir_fsop;
i                  97 fs/minix/v2_inode.c 			i->fsop = &minix_file_fsop;
i                 100 fs/minix/v2_inode.c 			i->fsop = &minix_symlink_fsop;
i                 103 fs/minix/v2_inode.c 			i->fsop = NULL;
i                 106 fs/minix/v2_inode.c 			printk("WARNING: %s(): invalid inode (%d) mode %o.\n", __FUNCTION__, i->inode, i->i_mode);
i                 115 fs/minix/v2_inode.c int v2_minix_write_inode(struct inode *i)
i                 122 fs/minix/v2_inode.c 	block = 1 + SUPERBLOCK + i->sb->u.minix.sb.s_imap_blocks + i->sb->u.minix.sb.s_zmap_blocks + (i->inode - 1) / MINIX2_INODES_PER_BLOCK(i->sb);
i                 124 fs/minix/v2_inode.c 	if(!(buf = bread(i->dev, block, i->sb->s_blocksize))) {
i                 127 fs/minix/v2_inode.c 	offset = (i->inode - 1) % MINIX2_INODES_PER_BLOCK(i->sb);
i                 130 fs/minix/v2_inode.c 	ii->i_mode = i->i_mode;
i                 131 fs/minix/v2_inode.c 	ii->i_nlink = i->i_nlink;
i                 132 fs/minix/v2_inode.c 	ii->i_uid = i->i_uid;
i                 133 fs/minix/v2_inode.c 	ii->i_gid = i->i_gid;
i                 134 fs/minix/v2_inode.c 	ii->i_size = i->i_size;
i                 135 fs/minix/v2_inode.c 	ii->i_atime = i->i_atime;
i                 136 fs/minix/v2_inode.c 	ii->i_mtime = i->i_mtime;
i                 137 fs/minix/v2_inode.c 	ii->i_ctime = i->i_ctime;
i                 138 fs/minix/v2_inode.c 	if(S_ISCHR(i->i_mode) || S_ISBLK(i->i_mode)) {
i                 139 fs/minix/v2_inode.c 		ii->i_zone[0] = i->rdev;
i                 141 fs/minix/v2_inode.c 		memcpy_b(ii->i_zone, i->u.minix.u.i2_zone, sizeof(i->u.minix.u.i2_zone));
i                 143 fs/minix/v2_inode.c 	i->dirty = 0;
i                 148 fs/minix/v2_inode.c int v2_minix_ialloc(struct inode *i, int mode)
i                 154 fs/minix/v2_inode.c 	sb = i->sb;
i                 176 fs/minix/v2_inode.c 	i->inode = inode;
i                 177 fs/minix/v2_inode.c 	i->i_atime = CURRENT_TIME;
i                 178 fs/minix/v2_inode.c 	i->i_mtime = CURRENT_TIME;
i                 179 fs/minix/v2_inode.c 	i->i_ctime = CURRENT_TIME;
i                 184 fs/minix/v2_inode.c void v2_minix_ifree(struct inode *i)
i                 189 fs/minix/v2_inode.c 	minix_truncate(i, 0);
i                 191 fs/minix/v2_inode.c 	sb = i->sb;
i                 194 fs/minix/v2_inode.c 	errno = minix_change_bit(CLEAR_BIT, i->sb, 1 + SUPERBLOCK, i->inode);
i                 198 fs/minix/v2_inode.c 			printk("WARNING: %s(): unable to clear inode %d.\n", __FUNCTION__, i->inode);
i                 200 fs/minix/v2_inode.c 			printk("WARNING: %s(): inode %d is already marked as free!\n", __FUNCTION__, i->inode);
i                 204 fs/minix/v2_inode.c 	i->i_size = 0;
i                 205 fs/minix/v2_inode.c 	i->i_mtime = CURRENT_TIME;
i                 206 fs/minix/v2_inode.c 	i->i_ctime = CURRENT_TIME;
i                 207 fs/minix/v2_inode.c 	i->dirty = 1;
i                 211 fs/minix/v2_inode.c int v2_minix_bmap(struct inode *i, __off_t offset, int mode)
i                 219 fs/minix/v2_inode.c 	blksize = i->sb->s_blocksize;
i                 227 fs/minix/v2_inode.c 		if(block < (BLOCKS_PER_IND_BLOCK(i->sb) + MINIX_NDIR_BLOCKS)) {
i                 229 fs/minix/v2_inode.c 		} else if(block < ((BLOCKS_PER_IND_BLOCK(i->sb) * BLOCKS_PER_IND_BLOCK(i->sb)) + BLOCKS_PER_IND_BLOCK(i->sb) + MINIX_NDIR_BLOCKS)) {
i                 238 fs/minix/v2_inode.c 		if(!i->u.minix.u.i2_zone[block] && mode == FOR_WRITING) {
i                 239 fs/minix/v2_inode.c 			if((newblock = minix_balloc(i->sb)) < 0) {
i                 243 fs/minix/v2_inode.c 			if(!(buf = bread(i->dev, newblock, blksize))) {
i                 244 fs/minix/v2_inode.c 				minix_bfree(i->sb, newblock);
i                 249 fs/minix/v2_inode.c 			i->u.minix.u.i2_zone[block] = newblock;
i                 251 fs/minix/v2_inode.c 		return i->u.minix.u.i2_zone[block];
i                 254 fs/minix/v2_inode.c 	if(!i->u.minix.u.i2_zone[level]) {
i                 256 fs/minix/v2_inode.c 			if((newblock = minix_balloc(i->sb)) < 0) {
i                 260 fs/minix/v2_inode.c 			if(!(buf = bread(i->dev, newblock, blksize))) {
i                 261 fs/minix/v2_inode.c 				minix_bfree(i->sb, newblock);
i                 266 fs/minix/v2_inode.c 			i->u.minix.u.i2_zone[level] = newblock;
i                 271 fs/minix/v2_inode.c 	if(!(buf = bread(i->dev, i->u.minix.u.i2_zone[level], blksize))) {
i                 275 fs/minix/v2_inode.c 	dblock = block - BLOCKS_PER_IND_BLOCK(i->sb);
i                 276 fs/minix/v2_inode.c 	tblock = block - (BLOCKS_PER_IND_BLOCK(i->sb) * BLOCKS_PER_IND_BLOCK(i->sb)) - BLOCKS_PER_IND_BLOCK(i->sb);
i                 279 fs/minix/v2_inode.c 		block = dblock / BLOCKS_PER_IND_BLOCK(i->sb);
i                 282 fs/minix/v2_inode.c 		block = tblock / (BLOCKS_PER_IND_BLOCK(i->sb) * BLOCKS_PER_IND_BLOCK(i->sb));
i                 287 fs/minix/v2_inode.c 			if((newblock = minix_balloc(i->sb)) < 0) {
i                 292 fs/minix/v2_inode.c 			if(!(buf2 = bread(i->dev, newblock, blksize))) {
i                 293 fs/minix/v2_inode.c 				minix_bfree(i->sb, newblock);
i                 317 fs/minix/v2_inode.c 		if(!(buf3 = bread(i->dev, indblock[block], blksize))) {
i                 323 fs/minix/v2_inode.c 		block = tindblock[tblock / BLOCKS_PER_IND_BLOCK(i->sb)];
i                 326 fs/minix/v2_inode.c 				if((newblock = minix_balloc(i->sb)) < 0) {
i                 332 fs/minix/v2_inode.c 				if(!(buf4 = bread(i->dev, newblock, blksize))) {
i                 333 fs/minix/v2_inode.c 					minix_bfree(i->sb, newblock);
i                 340 fs/minix/v2_inode.c 				tindblock[tblock / BLOCKS_PER_IND_BLOCK(i->sb)] = newblock;
i                 350 fs/minix/v2_inode.c 		iblock = tblock / BLOCKS_PER_IND_BLOCK(i->sb);
i                 351 fs/minix/v2_inode.c 		if(!(buf2 = bread(i->dev, block, blksize))) {
i                 359 fs/minix/v2_inode.c 		if(!(buf2 = bread(i->dev, indblock[iblock], blksize))) {
i                 367 fs/minix/v2_inode.c 	block = dindblock[dblock - (iblock * BLOCKS_PER_IND_BLOCK(i->sb))];
i                 369 fs/minix/v2_inode.c 		if((newblock = minix_balloc(i->sb)) < 0) {
i                 378 fs/minix/v2_inode.c 		if(!(buf4 = bread(i->dev, newblock, blksize))) {
i                 379 fs/minix/v2_inode.c 			minix_bfree(i->sb, newblock);
i                 389 fs/minix/v2_inode.c 		dindblock[dblock - (iblock * BLOCKS_PER_IND_BLOCK(i->sb))] = newblock;
i                 401 fs/minix/v2_inode.c int v2_minix_truncate(struct inode *i, __off_t length)
i                 408 fs/minix/v2_inode.c 	block = length / i->sb->s_blocksize;
i                 410 fs/minix/v2_inode.c 	if(!S_ISDIR(i->i_mode) && !S_ISREG(i->i_mode) && !S_ISLNK(i->i_mode)) {
i                 416 fs/minix/v2_inode.c 			if(i->u.minix.u.i2_zone[n]) {
i                 417 fs/minix/v2_inode.c 				minix_bfree(i->sb, i->u.minix.u.i2_zone[n]);
i                 418 fs/minix/v2_inode.c 				i->u.minix.u.i2_zone[n] = 0;
i                 424 fs/minix/v2_inode.c 	if(!block || block < (BLOCKS_PER_IND_BLOCK(i->sb) + MINIX_NDIR_BLOCKS)) {
i                 428 fs/minix/v2_inode.c 		if(i->u.minix.u.i2_zone[MINIX_IND_BLOCK]) {
i                 429 fs/minix/v2_inode.c 			free_zone(i, i->u.minix.u.i2_zone[MINIX_IND_BLOCK], block);
i                 431 fs/minix/v2_inode.c 				minix_bfree(i->sb, i->u.minix.u.i2_zone[MINIX_IND_BLOCK]);
i                 432 fs/minix/v2_inode.c 				i->u.minix.u.i2_zone[MINIX_IND_BLOCK] = 0;
i                 440 fs/minix/v2_inode.c 		block -= BLOCKS_PER_IND_BLOCK(i->sb);
i                 442 fs/minix/v2_inode.c 	if(i->u.minix.u.i2_zone[MINIX_DIND_BLOCK]) {
i                 443 fs/minix/v2_inode.c 		if(!(buf = bread(i->dev, i->u.minix.u.i2_zone[MINIX_DIND_BLOCK], i->sb->s_blocksize))) {
i                 444 fs/minix/v2_inode.c 			printk("%s(): error reading block %d.\n", __FUNCTION__, i->u.minix.u.i2_zone[MINIX_DIND_BLOCK]);
i                 447 fs/minix/v2_inode.c 		dblock = block % BLOCKS_PER_IND_BLOCK(i->sb);
i                 448 fs/minix/v2_inode.c 		for(n = block / BLOCKS_PER_IND_BLOCK(i->sb); n < BLOCKS_PER_IND_BLOCK(i->sb); n++) {
i                 450 fs/minix/v2_inode.c 				free_zone(i, zone[n], dblock);
i                 452 fs/minix/v2_inode.c 					minix_bfree(i->sb, zone[n]);
i                 459 fs/minix/v2_inode.c 			minix_bfree(i->sb, i->u.minix.u.i2_zone[MINIX_DIND_BLOCK]);
i                 460 fs/minix/v2_inode.c 			i->u.minix.u.i2_zone[MINIX_DIND_BLOCK] = 0;
i                 464 fs/minix/v2_inode.c 	i->i_mtime = CURRENT_TIME;
i                 465 fs/minix/v2_inode.c 	i->i_ctime = CURRENT_TIME;
i                 466 fs/minix/v2_inode.c 	i->i_size = length;
i                 467 fs/minix/v2_inode.c 	i->dirty = 1;
i                  31 fs/namei.c     	struct inode *i;
i                  76 fs/namei.c     		if((errno = namei_lookup(name, dir, &i))) {
i                  82 fs/namei.c     			if(!S_ISDIR(i->i_mode) && !S_ISLNK(i->i_mode)) {
i                  84 fs/namei.c     				iput(i);
i                  87 fs/namei.c     			if(S_ISLNK(i->i_mode)) {
i                  88 fs/namei.c     				if(i->fsop && i->fsop->followlink) {
i                  89 fs/namei.c     					if((errno = i->fsop->followlink(dir, i, &i))) {
i                  96 fs/namei.c     			if((i->fsop && i->fsop->followlink) && follow_links) {
i                  97 fs/namei.c     				if((errno = i->fsop->followlink(dir, i, &i))) {
i                 112 fs/namei.c     		dir = i;
i                 113 fs/namei.c     		*i_res = i;
i                  20 fs/pipefs/fifo.c int fifo_open(struct inode *i, struct fd *fd_table)
i                  23 fs/pipefs/fifo.c 	if(i->count == 1) {
i                  24 fs/pipefs/fifo.c 		if(!(i->u.pipefs.i_data = (void *)kmalloc())) {
i                  27 fs/pipefs/fifo.c 		i->u.pipefs.i_readoff = 0;
i                  28 fs/pipefs/fifo.c 		i->u.pipefs.i_writeoff = 0;
i                  32 fs/pipefs/fifo.c 		i->u.pipefs.i_readers++;
i                  35 fs/pipefs/fifo.c 			while(!i->u.pipefs.i_writers) {
i                  37 fs/pipefs/fifo.c 					if(!--i->u.pipefs.i_readers) {
i                  47 fs/pipefs/fifo.c 		if((fd_table->flags & O_NONBLOCK) && !i->u.pipefs.i_readers) {
i                  51 fs/pipefs/fifo.c 		i->u.pipefs.i_writers++;
i                  54 fs/pipefs/fifo.c 			while(!i->u.pipefs.i_readers) {
i                  56 fs/pipefs/fifo.c 					if(!--i->u.pipefs.i_writers) {
i                  66 fs/pipefs/fifo.c 		i->u.pipefs.i_readers++;
i                  67 fs/pipefs/fifo.c 		i->u.pipefs.i_writers++;
i                  23 fs/pipefs/pipe.c int pipefs_close(struct inode *i, struct fd *fd_table)
i                  26 fs/pipefs/pipe.c 		if(!--i->u.pipefs.i_readers) {
i                  32 fs/pipefs/pipe.c 		if(!--i->u.pipefs.i_writers) {
i                  38 fs/pipefs/pipe.c 		if(!--i->u.pipefs.i_readers) {
i                  42 fs/pipefs/pipe.c 		if(!--i->u.pipefs.i_writers) {
i                  50 fs/pipefs/pipe.c int pipefs_read(struct inode *i, struct fd *fd_table, char *buffer, __size_t count)
i                  57 fs/pipefs/pipe.c 	data = i->u.pipefs.i_data;
i                  60 fs/pipefs/pipe.c 		if(i->u.pipefs.i_writeoff) {
i                  61 fs/pipefs/pipe.c 			if(i->u.pipefs.i_readoff >= i->u.pipefs.i_writeoff) {
i                  62 fs/pipefs/pipe.c 				limit = PIPE_BUF - i->u.pipefs.i_readoff;
i                  64 fs/pipefs/pipe.c 				limit = i->u.pipefs.i_writeoff - i->u.pipefs.i_readoff;
i                  67 fs/pipefs/pipe.c 			limit = PIPE_BUF - i->u.pipefs.i_readoff;
i                  70 fs/pipefs/pipe.c 		if(i->i_size && n) {
i                  72 fs/pipefs/pipe.c 			memcpy_b(buffer + bytes_read, data + i->u.pipefs.i_readoff, n);
i                  74 fs/pipefs/pipe.c 			i->u.pipefs.i_readoff += n;
i                  75 fs/pipefs/pipe.c 			i->i_size -= n;
i                  76 fs/pipefs/pipe.c 			if(i->u.pipefs.i_writeoff >= PIPE_BUF) {
i                  77 fs/pipefs/pipe.c 				i->u.pipefs.i_writeoff = 0;
i                  84 fs/pipefs/pipe.c 			if(i->u.pipefs.i_writers) {
i                  92 fs/pipefs/pipe.c 				if(i->i_size) {
i                  93 fs/pipefs/pipe.c 					if(i->u.pipefs.i_readoff >= PIPE_BUF) {
i                  94 fs/pipefs/pipe.c 						i->u.pipefs.i_readoff = 0;
i                 102 fs/pipefs/pipe.c 	if(!i->i_size) {
i                 103 fs/pipefs/pipe.c 		i->u.pipefs.i_readoff = 0;
i                 104 fs/pipefs/pipe.c 		i->u.pipefs.i_writeoff = 0;
i                 109 fs/pipefs/pipe.c int pipefs_write(struct inode *i, struct fd *fd_table, const char *buffer, __size_t count)
i                 117 fs/pipefs/pipe.c 	data = i->u.pipefs.i_data;
i                 121 fs/pipefs/pipe.c 		if(!i->u.pipefs.i_readers) {
i                 126 fs/pipefs/pipe.c 		if(i->u.pipefs.i_readoff) {
i                 127 fs/pipefs/pipe.c 			if(i->u.pipefs.i_writeoff <= i->u.pipefs.i_readoff) {
i                 128 fs/pipefs/pipe.c 				limit = i->u.pipefs.i_readoff;
i                 136 fs/pipefs/pipe.c 		n = MIN((count - bytes_written), (limit - i->u.pipefs.i_writeoff));
i                 146 fs/pipefs/pipe.c 			memcpy_b(data + i->u.pipefs.i_writeoff, buffer + bytes_written, n);
i                 148 fs/pipefs/pipe.c 			i->u.pipefs.i_writeoff += n;
i                 149 fs/pipefs/pipe.c 			i->i_size += n;
i                 150 fs/pipefs/pipe.c 			if(i->u.pipefs.i_readoff >= PIPE_BUF) {
i                 151 fs/pipefs/pipe.c 				i->u.pipefs.i_readoff = 0;
i                 172 fs/pipefs/pipe.c int pipefs_ioctl(struct inode *i, int cmd, unsigned long int arg)
i                 181 fs/pipefs/pipe.c 			memcpy_b((void *)arg, &i->i_size, sizeof(unsigned int));
i                 189 fs/pipefs/pipe.c int pipefs_lseek(struct inode *i, __off_t offset)
i                 194 fs/pipefs/pipe.c int pipefs_select(struct inode *i, int flag)
i                 202 fs/pipefs/pipe.c 			if(i->i_size || !i->u.pipefs.i_writers) {
i                 211 fs/pipefs/pipe.c 			if(i->i_size < PIPE_BUF || !i->u.pipefs.i_readers) {
i                  74 fs/pipefs/super.c int pipefs_ialloc(struct inode *i, int mode)
i                  76 fs/pipefs/super.c 	struct superblock *sb = i->sb;
i                  82 fs/pipefs/super.c 	i->i_mode = S_IFIFO;
i                  83 fs/pipefs/super.c 	i->dev = i->rdev = sb->dev;
i                  84 fs/pipefs/super.c 	i->fsop = &pipefs_fsop;
i                  85 fs/pipefs/super.c 	i->inode = i_counter;
i                  86 fs/pipefs/super.c 	i->count = 2;
i                  87 fs/pipefs/super.c 	if(!(i->u.pipefs.i_data = (void *)kmalloc())) {
i                  90 fs/pipefs/super.c 	i->u.pipefs.i_readoff = 0;
i                  91 fs/pipefs/super.c 	i->u.pipefs.i_writeoff = 0;
i                  92 fs/pipefs/super.c 	i->u.pipefs.i_readers = 1;
i                  93 fs/pipefs/super.c 	i->u.pipefs.i_writers = 1;
i                  97 fs/pipefs/super.c void pipefs_ifree(struct inode *i)
i                  99 fs/pipefs/super.c 	if(!i->u.pipefs.i_readers && !i->u.pipefs.i_writers) {
i                 104 fs/pipefs/super.c 		if(i->u.pipefs.i_data) {
i                 105 fs/pipefs/super.c 			kfree((unsigned int)i->u.pipefs.i_data);
i                 472 fs/procfs/data.c 	struct inode *i;
i                 482 fs/procfs/data.c 		i = p->pwd;
i                 483 fs/procfs/data.c 		size = sprintk(buffer, "[%02d%02d]:%d", MAJOR(i->rdev), MINOR(i->rdev), i->inode);
i                 523 fs/procfs/data.c 	struct inode *i;
i                 533 fs/procfs/data.c 		i = p->vma->inode;
i                 534 fs/procfs/data.c 		size = sprintk(buffer, "[%02d%02d]:%d", MAJOR(i->rdev), MINOR(i->rdev), i->inode);
i                 625 fs/procfs/data.c 	struct inode *i;
i                 635 fs/procfs/data.c 		i = p->root;
i                 636 fs/procfs/data.c 		size = sprintk(buffer, "[%02d%02d]:%d", MAJOR(i->rdev), MINOR(i->rdev), i->inode);
i                 136 fs/procfs/dir.c static int dir_read(struct inode *i, struct fd *fd_table, char *buffer, __size_t count)
i                 149 fs/procfs/dir.c 	if(i->inode == PROC_ROOT_INO) {
i                 160 fs/procfs/dir.c 	lev = i->u.procfs.i_lev;
i                 178 fs/procfs/dir.c int procfs_dir_open(struct inode *i, struct fd *fd_table)
i                 184 fs/procfs/dir.c int procfs_dir_close(struct inode *i, struct fd *fd_table)
i                 189 fs/procfs/dir.c int procfs_dir_read(struct inode *i, struct fd *fd_table, char *buffer, __size_t count)
i                 194 fs/procfs/dir.c int procfs_dir_readdir(struct inode *i, struct fd *fd_table, struct dirent *dirent, unsigned int count)
i                 208 fs/procfs/dir.c 	lev = i->u.procfs.i_lev;
i                 216 fs/procfs/dir.c 	total_read = dir_read(i, fd_table, buffer, PAGE_SIZE);
i                  60 fs/procfs/file.c int procfs_file_open(struct inode *i, struct fd *fd_table)
i                  69 fs/procfs/file.c int procfs_file_close(struct inode *i, struct fd *fd_table)
i                  74 fs/procfs/file.c int procfs_file_read(struct inode *i, struct fd *fd_table, char *buffer, __size_t count)
i                  82 fs/procfs/file.c 	if(!(d = get_procfs_by_inode(i))) {
i                  92 fs/procfs/file.c 	size = d->data_fn(buf, (i->inode >> 12) & 0xFFFF);
i                  93 fs/procfs/file.c 	blksize = i->sb->s_blocksize;
i                 119 fs/procfs/file.c int procfs_file_lseek(struct inode *i, __off_t offset)
i                  22 fs/procfs/inode.c int procfs_read_inode(struct inode *i)
i                  29 fs/procfs/inode.c 	if((i->inode & 0xF0000FFF) == PROC_PID_INO) {	/* dynamic PID dir */
i                  34 fs/procfs/inode.c 		if(!(d = get_procfs_by_inode(i))) {
i                  42 fs/procfs/inode.c 	i->i_mode = mode;
i                  43 fs/procfs/inode.c 	i->i_uid = 0;
i                  44 fs/procfs/inode.c 	i->i_size = 0;
i                  45 fs/procfs/inode.c 	i->i_atime = CURRENT_TIME;
i                  46 fs/procfs/inode.c 	i->i_ctime = CURRENT_TIME;
i                  47 fs/procfs/inode.c 	i->i_mtime = CURRENT_TIME;
i                  48 fs/procfs/inode.c 	i->i_gid = 0;
i                  49 fs/procfs/inode.c 	i->i_nlink = nlink;
i                  50 fs/procfs/inode.c 	i->i_blocks = 0;
i                  51 fs/procfs/inode.c 	i->i_flags = 0;
i                  52 fs/procfs/inode.c 	i->locked = 1;
i                  53 fs/procfs/inode.c 	i->dirty = 0;
i                  54 fs/procfs/inode.c 	i->count = 1;
i                  55 fs/procfs/inode.c 	i->u.procfs.i_lev = lev;
i                  56 fs/procfs/inode.c 	switch(i->i_mode & S_IFMT) {
i                  58 fs/procfs/inode.c 			i->fsop = &procfs_dir_fsop;
i                  61 fs/procfs/inode.c 			i->fsop = &procfs_file_fsop;
i                  64 fs/procfs/inode.c 			i->fsop = &procfs_symlink_fsop;
i                  67 fs/procfs/inode.c 			PANIC("invalid inode (%d) mode %08o.\n", i->inode, i->i_mode);
i                  72 fs/procfs/inode.c int procfs_bmap(struct inode *i, __off_t offset, int mode)
i                  74 fs/procfs/inode.c 	return i->u.procfs.i_lev;
i                  61 fs/procfs/symlink.c int procfs_readlink(struct inode *i, char *buffer, __size_t count)
i                  67 fs/procfs/symlink.c 	if(!(d = get_procfs_by_inode(i))) {
i                  79 fs/procfs/symlink.c 	if((size_read = d->data_fn(buf, (i->inode >> 12) & 0xFFFF)) > 0) {
i                  89 fs/procfs/symlink.c int procfs_followlink(struct inode *dir, struct inode *i, struct inode **i_res)
i                  95 fs/procfs/symlink.c 	if(!i) {
i                  98 fs/procfs/symlink.c 	if(!(S_ISLNK(i->i_mode))) {
i                  99 fs/procfs/symlink.c 		printk("%s(): Oops, inode '%d' is not a symlink (!?).\n", __FUNCTION__, i->inode);
i                 104 fs/procfs/symlink.c 	if((pid = (i->inode >> 12) & 0xFFFF)) {
i                 116 fs/procfs/symlink.c 	switch(i->inode & 0xF0000FFF) {
i                 123 fs/procfs/symlink.c 			iput(i);
i                 131 fs/procfs/symlink.c 			iput(i);
i                 139 fs/procfs/symlink.c 			iput(i);
i                 142 fs/procfs/symlink.c 			iput(i);
i                  92 fs/procfs/tree.c struct procfs_dir_entry * get_procfs_by_inode(struct inode *i)
i                  98 fs/procfs/tree.c 	inode = i->inode;
i                 101 fs/procfs/tree.c 			if((i->inode & 0xF0000000) == PROC_PID_INO) {
i                 102 fs/procfs/tree.c 				inode = i->inode & 0xF0000FFF;
i                  43 kernel/init.c  	struct inode *i;
i                  47 kernel/init.c  	if(namei(INIT_PROGRAM, &i, NULL, FOLLOW_LINKS)) {
i                  50 kernel/init.c  	if(!S_ISREG(i->i_mode)) {
i                  53 kernel/init.c  	iput(i);
i                  59 kernel/sleep.c 	int signum, i;
i                  74 kernel/sleep.c 	i = SLEEP_HASH((unsigned int)address);
i                  75 kernel/sleep.c 	h = &sleep_hash_table[i];
i                 105 kernel/sleep.c 	int i;
i                 108 kernel/sleep.c 	i = SLEEP_HASH((unsigned int)address);
i                 109 kernel/sleep.c 	h = &sleep_hash_table[i];
i                 123 kernel/sleep.c 			if(h == &sleep_hash_table[i]) {	/* if it's the head */
i                 139 kernel/sleep.c 	int i;
i                 156 kernel/sleep.c 		i = SLEEP_HASH((unsigned int)p->sleep_address);
i                 157 kernel/sleep.c 		h = &sleep_hash_table[i];
i                  79 kernel/syscalls.c int check_user_permission(struct inode *i)
i                  82 kernel/syscalls.c 		if(current->euid != i->i_uid) {
i                  89 kernel/syscalls.c int check_group(struct inode *i)
i                 100 kernel/syscalls.c 	if(i->i_gid == gid) {
i                 108 kernel/syscalls.c 		if(current->groups[n] == i->i_gid) {
i                 153 kernel/syscalls.c int check_permission(int mask, struct inode *i)
i                 166 kernel/syscalls.c 	if(i->i_uid == uid) {
i                 167 kernel/syscalls.c 		if((((i->i_mode >> 6) & 7) & mask) == mask) {
i                 171 kernel/syscalls.c 	if(!check_group(i)) {
i                 172 kernel/syscalls.c 		if((((i->i_mode >> 3) & 7) & mask) == mask) {
i                 176 kernel/syscalls.c 	if(((i->i_mode & 7) & mask) == mask) {
i                  21 kernel/syscalls/access.c 	struct inode *i;
i                  36 kernel/syscalls/access.c 	if((errno = namei(tmp_name, &i, NULL, FOLLOW_LINKS))) {
i                  42 kernel/syscalls/access.c 		if(S_ISREG(i->i_mode) || S_ISDIR(i->i_mode) || S_ISLNK(i->i_mode)) {
i                  43 kernel/syscalls/access.c 			if(IS_RDONLY_FS(i)) {
i                  45 kernel/syscalls/access.c 				iput(i);
i                  51 kernel/syscalls/access.c 	errno = check_permission(mode, i);
i                  58 kernel/syscalls/access.c 	iput(i);
i                  20 kernel/syscalls/chdir.c 	struct inode *i;
i                  31 kernel/syscalls/chdir.c 	if((errno = namei(tmp_name, &i, NULL, FOLLOW_LINKS))) {
i                  35 kernel/syscalls/chdir.c 	if(!S_ISDIR(i->i_mode)) {
i                  36 kernel/syscalls/chdir.c 		iput(i);
i                  40 kernel/syscalls/chdir.c 	if((errno = check_permission(TO_EXEC, i))) {
i                  41 kernel/syscalls/chdir.c 		iput(i);
i                  46 kernel/syscalls/chdir.c 	current->pwd = i;
i                  22 kernel/syscalls/chmod.c 	struct inode *i;
i                  33 kernel/syscalls/chmod.c 	if((errno = namei(tmp_name, &i, NULL, FOLLOW_LINKS))) {
i                  38 kernel/syscalls/chmod.c 	if(IS_RDONLY_FS(i)) {
i                  39 kernel/syscalls/chmod.c 		iput(i);
i                  43 kernel/syscalls/chmod.c 	if(check_user_permission(i)) {
i                  44 kernel/syscalls/chmod.c 		iput(i);
i                  49 kernel/syscalls/chmod.c 	i->i_mode &= S_IFMT;
i                  50 kernel/syscalls/chmod.c 	i->i_mode |= mode & ~S_IFMT;
i                  51 kernel/syscalls/chmod.c 	i->i_ctime = CURRENT_TIME;
i                  52 kernel/syscalls/chmod.c 	i->dirty = 1;
i                  53 kernel/syscalls/chmod.c 	iput(i);
i                  22 kernel/syscalls/chown.c 	struct inode *i;
i                  33 kernel/syscalls/chown.c 	if((errno = namei(tmp_name, &i, NULL, !FOLLOW_LINKS))) {
i                  38 kernel/syscalls/chown.c 	if(IS_RDONLY_FS(i)) {
i                  39 kernel/syscalls/chown.c 		iput(i);
i                  43 kernel/syscalls/chown.c 	if(check_user_permission(i)) {
i                  44 kernel/syscalls/chown.c 		iput(i);
i                  50 kernel/syscalls/chown.c 		owner = i->i_uid;
i                  52 kernel/syscalls/chown.c 		i->i_mode &= ~(S_ISUID);
i                  53 kernel/syscalls/chown.c 		i->i_ctime = CURRENT_TIME;
i                  56 kernel/syscalls/chown.c 		group = i->i_gid;
i                  58 kernel/syscalls/chown.c 		i->i_mode &= ~(S_ISGID);
i                  59 kernel/syscalls/chown.c 		i->i_ctime = CURRENT_TIME;
i                  62 kernel/syscalls/chown.c 	i->i_uid = owner;
i                  63 kernel/syscalls/chown.c 	i->i_gid = group;
i                  64 kernel/syscalls/chown.c 	i->dirty = 1;
i                  65 kernel/syscalls/chown.c 	iput(i);
i                  20 kernel/syscalls/chroot.c 	struct inode *i;
i                  31 kernel/syscalls/chroot.c 	if((errno = namei(tmp_name, &i, NULL, FOLLOW_LINKS))) {
i                  35 kernel/syscalls/chroot.c 	if(!S_ISDIR(i->i_mode)) {
i                  36 kernel/syscalls/chroot.c 		iput(i);
i                  41 kernel/syscalls/chroot.c 	current->root = i;
i                  16 kernel/syscalls/close.c 	struct inode *i;
i                  29 kernel/syscalls/close.c 	i = fd_table[fd].inode;
i                  30 kernel/syscalls/close.c 	flock_release_inode(i);
i                  31 kernel/syscalls/close.c 	if(i->fsop && i->fsop->close) {
i                  32 kernel/syscalls/close.c 		i->fsop->close(i, &fd_table[fd]);
i                  34 kernel/syscalls/close.c 		iput(i);
i                 240 kernel/syscalls/execve.c 	struct inode *i;
i                 268 kernel/syscalls/execve.c 	if((errno = namei(name, &i, NULL, FOLLOW_LINKS))) {
i                 274 kernel/syscalls/execve.c 	if(!S_ISREG(i->i_mode)) {
i                 275 kernel/syscalls/execve.c 		iput(i);
i                 280 kernel/syscalls/execve.c 	if(check_permission(TO_EXEC, i) < 0) {
i                 281 kernel/syscalls/execve.c 		iput(i);
i                 287 kernel/syscalls/execve.c 	if((block = bmap(i, 0, FOR_READING)) < 0) {
i                 288 kernel/syscalls/execve.c 		iput(i);
i                 293 kernel/syscalls/execve.c 	if(!(buf = bread(i->dev, block, i->sb->s_blocksize))) {
i                 294 kernel/syscalls/execve.c 		iput(i);
i                 305 kernel/syscalls/execve.c 	memcpy_b(data, buf->data, i->sb->s_blocksize);
i                 308 kernel/syscalls/execve.c 	errno = elf_load(i, &barg, sc, data);
i                 316 kernel/syscalls/execve.c 			iput(i);
i                 328 kernel/syscalls/execve.c 		if(i->i_mode & S_ISUID) {
i                 329 kernel/syscalls/execve.c 			current->euid = i->i_uid;
i                 331 kernel/syscalls/execve.c 		if(i->i_mode & S_ISGID) {
i                 332 kernel/syscalls/execve.c 			current->egid = i->i_gid;
i                 336 kernel/syscalls/execve.c 	iput(i);
i                  19 kernel/syscalls/fchdir.c 	struct inode *i;
i                  26 kernel/syscalls/fchdir.c 	i = fd_table[current->fd[ufd]].inode;
i                  27 kernel/syscalls/fchdir.c 	if(!S_ISDIR(i->i_mode)) {
i                  31 kernel/syscalls/fchdir.c 	current->pwd = i;
i                  21 kernel/syscalls/fchmod.c 	struct inode *i;
i                  28 kernel/syscalls/fchmod.c 	i = fd_table[current->fd[ufd]].inode;
i                  30 kernel/syscalls/fchmod.c 	if(IS_RDONLY_FS(i)) {
i                  33 kernel/syscalls/fchmod.c 	if(check_user_permission(i)) {
i                  37 kernel/syscalls/fchmod.c 	i->i_mode &= S_IFMT;
i                  38 kernel/syscalls/fchmod.c 	i->i_mode |= mode & ~S_IFMT;
i                  39 kernel/syscalls/fchmod.c 	i->i_ctime = CURRENT_TIME;
i                  40 kernel/syscalls/fchmod.c 	i->dirty = 1;
i                  21 kernel/syscalls/fchown.c 	struct inode *i;
i                  28 kernel/syscalls/fchown.c 	i = fd_table[current->fd[ufd]].inode;
i                  30 kernel/syscalls/fchown.c 	if(IS_RDONLY_FS(i)) {
i                  33 kernel/syscalls/fchown.c 	if(check_user_permission(i)) {
i                  38 kernel/syscalls/fchown.c 		owner = i->i_uid;
i                  40 kernel/syscalls/fchown.c 		i->i_mode &= ~(S_ISUID);
i                  43 kernel/syscalls/fchown.c 		group = i->i_gid;
i                  45 kernel/syscalls/fchown.c 		i->i_mode &= ~(S_ISGID);
i                  48 kernel/syscalls/fchown.c 	i->i_uid = owner;
i                  49 kernel/syscalls/fchown.c 	i->i_gid = group;
i                  50 kernel/syscalls/fchown.c 	i->i_ctime = CURRENT_TIME;
i                  51 kernel/syscalls/fchown.c 	i->dirty = 1;
i                  19 kernel/syscalls/flock.c 	struct inode *i;
i                  26 kernel/syscalls/flock.c 	i = fd_table[current->fd[ufd]].inode;
i                  27 kernel/syscalls/flock.c 	return flock_inode(i, op);
i                  20 kernel/syscalls/fstat.c 	struct inode *i;
i                  31 kernel/syscalls/fstat.c 	i = fd_table[current->fd[ufd]].inode;
i                  32 kernel/syscalls/fstat.c 	statbuf->st_dev = i->dev;
i                  33 kernel/syscalls/fstat.c 	statbuf->st_ino = i->inode;
i                  34 kernel/syscalls/fstat.c 	statbuf->st_mode = i->i_mode;
i                  35 kernel/syscalls/fstat.c 	statbuf->st_nlink = i->i_nlink;
i                  36 kernel/syscalls/fstat.c 	statbuf->st_uid = i->i_uid;
i                  37 kernel/syscalls/fstat.c 	statbuf->st_gid = i->i_gid;
i                  38 kernel/syscalls/fstat.c 	statbuf->st_rdev = i->rdev;
i                  39 kernel/syscalls/fstat.c 	statbuf->st_size = i->i_size;
i                  40 kernel/syscalls/fstat.c 	statbuf->st_atime = i->i_atime;
i                  41 kernel/syscalls/fstat.c 	statbuf->st_mtime = i->i_mtime;
i                  42 kernel/syscalls/fstat.c 	statbuf->st_ctime = i->i_ctime;
i                  19 kernel/syscalls/fstatfs.c 	struct inode *i;
i                  30 kernel/syscalls/fstatfs.c 	i = fd_table[current->fd[ufd]].inode;
i                  31 kernel/syscalls/fstatfs.c 	if(i->sb && i->sb->fsop && i->sb->fsop->statfs) {
i                  32 kernel/syscalls/fstatfs.c 		i->sb->fsop->statfs(i->sb, statfsbuf);
i                  21 kernel/syscalls/fsync.c 	struct inode *i;
i                  28 kernel/syscalls/fsync.c 	i = fd_table[current->fd[ufd]].inode;
i                  29 kernel/syscalls/fsync.c 	if(!S_ISREG(i->i_mode)) {
i                  32 kernel/syscalls/fsync.c 	if(IS_RDONLY_FS(i)) {
i                  35 kernel/syscalls/fsync.c 	sync_superblocks(i->dev);
i                  36 kernel/syscalls/fsync.c 	sync_inodes(i->dev);
i                  37 kernel/syscalls/fsync.c 	sync_buffers(i->dev);
i                  21 kernel/syscalls/ftruncate.c 	struct inode *i;
i                  29 kernel/syscalls/ftruncate.c 	i = fd_table[current->fd[ufd]].inode;
i                  33 kernel/syscalls/ftruncate.c 	if(S_ISDIR(i->i_mode)) {
i                  36 kernel/syscalls/ftruncate.c 	if(IS_RDONLY_FS(i)) {
i                  39 kernel/syscalls/ftruncate.c 	if(check_permission(TO_WRITE, i) < 0) {
i                  42 kernel/syscalls/ftruncate.c 	if(length == i->i_size) {
i                  47 kernel/syscalls/ftruncate.c 	if(i->fsop && i->fsop->truncate) {
i                  48 kernel/syscalls/ftruncate.c 		inode_lock(i);
i                  49 kernel/syscalls/ftruncate.c 		errno = i->fsop->truncate(i, length);
i                  50 kernel/syscalls/ftruncate.c 		inode_unlock(i);
i                  20 kernel/syscalls/getdents.c 	struct inode *i;
i                  31 kernel/syscalls/getdents.c 	i = fd_table[current->fd[ufd]].inode;
i                  33 kernel/syscalls/getdents.c 	if(!S_ISDIR(i->i_mode)) {
i                  37 kernel/syscalls/getdents.c 	if(i->fsop && i->fsop->readdir) {
i                  38 kernel/syscalls/getdents.c 		errno = i->fsop->readdir(i, &fd_table[current->fd[ufd]], dirent, count);
i                  18 kernel/syscalls/ioctl.c 	struct inode *i;
i                  25 kernel/syscalls/ioctl.c 	i = fd_table[current->fd[fd]].inode;
i                  26 kernel/syscalls/ioctl.c 	if(i->fsop && i->fsop->ioctl) {
i                  27 kernel/syscalls/ioctl.c 		errno = i->fsop->ioctl(i, cmd, arg);
i                  20 kernel/syscalls/link.c 	struct inode *i, *dir, *i_new, *dir_new;
i                  36 kernel/syscalls/link.c 	if((errno = namei(tmp_oldname, &i, &dir, !FOLLOW_LINKS))) {
i                  44 kernel/syscalls/link.c 	if(S_ISDIR(i->i_mode)) {
i                  45 kernel/syscalls/link.c 		iput(i);
i                  51 kernel/syscalls/link.c 	if(IS_RDONLY_FS(i)) {
i                  52 kernel/syscalls/link.c 		iput(i);
i                  58 kernel/syscalls/link.c 	if(i->i_nlink == LINK_MAX) {
i                  59 kernel/syscalls/link.c 		iput(i);
i                  69 kernel/syscalls/link.c 			iput(i);
i                  77 kernel/syscalls/link.c 		iput(i);
i                  85 kernel/syscalls/link.c 	if(i->dev != dir_new->dev) {
i                  86 kernel/syscalls/link.c 		iput(i);
i                  94 kernel/syscalls/link.c 		iput(i);
i                 103 kernel/syscalls/link.c 		errno = dir_new->fsop->link(i, dir_new, basename);
i                 107 kernel/syscalls/link.c 	iput(i);
i                  20 kernel/syscalls/llseek.c 	struct inode *i;
i                  33 kernel/syscalls/llseek.c 	i = fd_table[current->fd[ufd]].inode;
i                  43 kernel/syscalls/llseek.c 			new_offset = i->i_size + offset;
i                  20 kernel/syscalls/lseek.c 	struct inode *i;
i                  29 kernel/syscalls/lseek.c 	i = fd_table[current->fd[ufd]].inode;
i                  38 kernel/syscalls/lseek.c 			new_offset = i->i_size + offset;
i                  46 kernel/syscalls/lseek.c 	if(i->fsop && i->fsop->lseek) {
i                  48 kernel/syscalls/lseek.c 		new_offset = i->fsop->lseek(i, new_offset);
i                  19 kernel/syscalls/lstat.c 	struct inode *i;
i                  33 kernel/syscalls/lstat.c 	if((errno = namei(tmp_name, &i, NULL, !FOLLOW_LINKS))) {
i                  37 kernel/syscalls/lstat.c 	statbuf->st_dev = i->dev;
i                  38 kernel/syscalls/lstat.c 	statbuf->st_ino = i->inode;
i                  39 kernel/syscalls/lstat.c 	statbuf->st_mode = i->i_mode;
i                  40 kernel/syscalls/lstat.c 	statbuf->st_nlink = i->i_nlink;
i                  41 kernel/syscalls/lstat.c 	statbuf->st_uid = i->i_uid;
i                  42 kernel/syscalls/lstat.c 	statbuf->st_gid = i->i_gid;
i                  43 kernel/syscalls/lstat.c 	statbuf->st_rdev = i->rdev;
i                  44 kernel/syscalls/lstat.c 	statbuf->st_size = i->i_size;
i                  45 kernel/syscalls/lstat.c 	statbuf->st_atime = i->i_atime;
i                  46 kernel/syscalls/lstat.c 	statbuf->st_mtime = i->i_mtime;
i                  47 kernel/syscalls/lstat.c 	statbuf->st_ctime = i->i_ctime;
i                  48 kernel/syscalls/lstat.c 	iput(i);
i                  21 kernel/syscalls/mkdir.c 	struct inode *i, *dir;
i                  33 kernel/syscalls/mkdir.c 	if((errno = namei(basename, &i, &dir, !FOLLOW_LINKS))) {
i                  40 kernel/syscalls/mkdir.c 		iput(i);
i                  21 kernel/syscalls/mknod.c 	struct inode *i, *dir;
i                  40 kernel/syscalls/mknod.c 	if((errno = namei(tmp_name, &i, &dir, !FOLLOW_LINKS))) {
i                  47 kernel/syscalls/mknod.c 		iput(i);
i                  19 kernel/syscalls/newfstat.c 	struct inode *i;
i                  30 kernel/syscalls/newfstat.c 	i = fd_table[current->fd[ufd]].inode;
i                  31 kernel/syscalls/newfstat.c 	statbuf->st_dev = i->dev;
i                  33 kernel/syscalls/newfstat.c 	statbuf->st_ino = i->inode;
i                  34 kernel/syscalls/newfstat.c 	statbuf->st_mode = i->i_mode;
i                  35 kernel/syscalls/newfstat.c 	statbuf->st_nlink = i->i_nlink;
i                  36 kernel/syscalls/newfstat.c 	statbuf->st_uid = i->i_uid;
i                  37 kernel/syscalls/newfstat.c 	statbuf->st_gid = i->i_gid;
i                  38 kernel/syscalls/newfstat.c 	statbuf->st_rdev = i->rdev;
i                  40 kernel/syscalls/newfstat.c 	statbuf->st_size = i->i_size;
i                  41 kernel/syscalls/newfstat.c 	statbuf->st_blksize = i->sb->s_blocksize;
i                  42 kernel/syscalls/newfstat.c 	statbuf->st_blocks = i->i_blocks;
i                  43 kernel/syscalls/newfstat.c 	if(!i->i_blocks) {
i                  44 kernel/syscalls/newfstat.c 		statbuf->st_blocks = (i->i_size / i->sb->s_blocksize * 2);
i                  47 kernel/syscalls/newfstat.c 	statbuf->st_atime = i->i_atime;
i                  49 kernel/syscalls/newfstat.c 	statbuf->st_mtime = i->i_mtime;
i                  51 kernel/syscalls/newfstat.c 	statbuf->st_ctime = i->i_ctime;
i                  19 kernel/syscalls/newlstat.c 	struct inode *i;
i                  33 kernel/syscalls/newlstat.c 	if((errno = namei(tmp_name, &i, NULL, !FOLLOW_LINKS))) {
i                  37 kernel/syscalls/newlstat.c 	statbuf->st_dev = i->dev;
i                  39 kernel/syscalls/newlstat.c 	statbuf->st_ino = i->inode;
i                  40 kernel/syscalls/newlstat.c 	statbuf->st_mode = i->i_mode;
i                  41 kernel/syscalls/newlstat.c 	statbuf->st_nlink = i->i_nlink;
i                  42 kernel/syscalls/newlstat.c 	statbuf->st_uid = i->i_uid;
i                  43 kernel/syscalls/newlstat.c 	statbuf->st_gid = i->i_gid;
i                  44 kernel/syscalls/newlstat.c 	statbuf->st_rdev = i->rdev;
i                  46 kernel/syscalls/newlstat.c 	statbuf->st_size = i->i_size;
i                  47 kernel/syscalls/newlstat.c 	statbuf->st_blksize = i->sb->s_blocksize;
i                  48 kernel/syscalls/newlstat.c 	statbuf->st_blocks = i->i_blocks;
i                  49 kernel/syscalls/newlstat.c 	if(!i->i_blocks) {
i                  50 kernel/syscalls/newlstat.c 		statbuf->st_blocks = (i->i_size / i->sb->s_blocksize) * 2;
i                  53 kernel/syscalls/newlstat.c 	statbuf->st_atime = i->i_atime;
i                  55 kernel/syscalls/newlstat.c 	statbuf->st_mtime = i->i_mtime;
i                  57 kernel/syscalls/newlstat.c 	statbuf->st_ctime = i->i_ctime;
i                  61 kernel/syscalls/newlstat.c 	iput(i);
i                  19 kernel/syscalls/newstat.c 	struct inode *i;
i                  33 kernel/syscalls/newstat.c 	if((errno = namei(tmp_name, &i, NULL, FOLLOW_LINKS))) {
i                  37 kernel/syscalls/newstat.c 	statbuf->st_dev = i->dev;
i                  39 kernel/syscalls/newstat.c 	statbuf->st_ino = i->inode;
i                  40 kernel/syscalls/newstat.c 	statbuf->st_mode = i->i_mode;
i                  41 kernel/syscalls/newstat.c 	statbuf->st_nlink = i->i_nlink;
i                  42 kernel/syscalls/newstat.c 	statbuf->st_uid = i->i_uid;
i                  43 kernel/syscalls/newstat.c 	statbuf->st_gid = i->i_gid;
i                  44 kernel/syscalls/newstat.c 	statbuf->st_rdev = i->rdev;
i                  46 kernel/syscalls/newstat.c 	statbuf->st_size = i->i_size;
i                  47 kernel/syscalls/newstat.c 	statbuf->st_blksize = i->sb->s_blocksize;
i                  48 kernel/syscalls/newstat.c 	statbuf->st_blocks = i->i_blocks;
i                  49 kernel/syscalls/newstat.c 	if(!i->i_blocks) {
i                  50 kernel/syscalls/newstat.c 		statbuf->st_blocks = (i->i_size / i->sb->s_blocksize) * 2;
i                  53 kernel/syscalls/newstat.c 	statbuf->st_atime = i->i_atime;
i                  55 kernel/syscalls/newstat.c 	statbuf->st_mtime = i->i_mtime;
i                  57 kernel/syscalls/newstat.c 	statbuf->st_ctime = i->i_ctime;
i                  61 kernel/syscalls/newstat.c 	iput(i);
i                  23 kernel/syscalls/old_mmap.c 	struct inode *i;
i                  38 kernel/syscalls/old_mmap.c 	i = NULL;
i                  42 kernel/syscalls/old_mmap.c 		if(!(i = fd_table[current->fd[mmap->fd]].inode)) {
i                  47 kernel/syscalls/old_mmap.c 	page = do_mmap(i, mmap->start, mmap->length, mmap->prot, mmap->flags, mmap->offset, P_MMAP, flags);
i                  19 kernel/syscalls/open.c 	struct inode *i, *dir;
i                  33 kernel/syscalls/open.c 	if((errno = namei(tmp_name, &i, &dir, follow_links))) {
i                  44 kernel/syscalls/open.c 	printk("\t(inode = %d)\n", i ? i->inode : -1);
i                  48 kernel/syscalls/open.c 		if(S_ISLNK(i->i_mode) && (flags & O_NOFOLLOW)) {
i                  49 kernel/syscalls/open.c 			iput(i);
i                  58 kernel/syscalls/open.c 			iput(i);
i                  64 kernel/syscalls/open.c 			iput(i);
i                  71 kernel/syscalls/open.c 				errno = dir->fsop->create(dir, basename, mode, &i);
i                  89 kernel/syscalls/open.c 		if(S_ISDIR(i->i_mode) && (flags & (O_RDWR | O_WRONLY | O_TRUNC))) {
i                  90 kernel/syscalls/open.c 			iput(i);
i                 105 kernel/syscalls/open.c 	if((errno = check_permission(perms, i))) {
i                 106 kernel/syscalls/open.c 		iput(i);
i                 111 kernel/syscalls/open.c 	if((fd = get_new_fd(i)) < 0) {
i                 112 kernel/syscalls/open.c 		iput(i);
i                 119 kernel/syscalls/open.c 		iput(i);
i                 131 kernel/syscalls/open.c 	if(i->fsop && i->fsop->open) {
i                 132 kernel/syscalls/open.c 		if((errno = i->fsop->open(i, &fd_table[fd])) < 0) {
i                 135 kernel/syscalls/open.c 			iput(i);
i                 145 kernel/syscalls/open.c 	printk("WARNING: %s(): file '%s' (inode %d) without the open() method!\n", __FUNCTION__, tmp_name, i->inode);
i                 148 kernel/syscalls/open.c 	iput(i);
i                  20 kernel/syscalls/pipe.c 	struct inode *i;
i                  34 kernel/syscalls/pipe.c 	if(!(i = ialloc(&fs->mt->sb, S_IFIFO))) {
i                  37 kernel/syscalls/pipe.c 	if((rfd = get_new_fd(i)) < 0) {
i                  38 kernel/syscalls/pipe.c 		iput(i);
i                  41 kernel/syscalls/pipe.c 	if((wfd = get_new_fd(i)) < 0) {
i                  43 kernel/syscalls/pipe.c 		iput(i);
i                  49 kernel/syscalls/pipe.c 		iput(i);
i                  56 kernel/syscalls/pipe.c 		iput(i);
i                  68 kernel/syscalls/pipe.c 	printk(" -> inode=%d, rufd=%d wufd=%d (rfd=%d wfd=%d)\n", i->inode, rufd, wufd, rfd, wfd);
i                  19 kernel/syscalls/read.c 	struct inode *i;
i                  40 kernel/syscalls/read.c 	i = fd_table[current->fd[ufd]].inode;
i                  41 kernel/syscalls/read.c 	if(i->fsop && i->fsop->read) {
i                  42 kernel/syscalls/read.c 		errno = i->fsop->read(i, &fd_table[current->fd[ufd]], buf, count);
i                  21 kernel/syscalls/readlink.c 	struct inode *i;
i                  38 kernel/syscalls/readlink.c 	if((errno = namei(tmp_name, &i, NULL, !FOLLOW_LINKS))) {
i                  42 kernel/syscalls/readlink.c 	if(!S_ISLNK(i->i_mode)) {
i                  43 kernel/syscalls/readlink.c 		iput(i);
i                  48 kernel/syscalls/readlink.c 	if(i->fsop && i->fsop->readlink) {
i                  49 kernel/syscalls/readlink.c 		errno = i->fsop->readlink(i, buffer, bufsize);
i                  50 kernel/syscalls/readlink.c 		iput(i);
i                  54 kernel/syscalls/readlink.c 	iput(i);
i                  20 kernel/syscalls/rename.c 	struct inode *i, *dir, *i_new, *dir_new;
i                  32 kernel/syscalls/rename.c 	if((errno = namei(tmp_oldpath, &i, &dir, !FOLLOW_LINKS))) {
i                  39 kernel/syscalls/rename.c 	if(IS_RDONLY_FS(i)) {
i                  40 kernel/syscalls/rename.c 		iput(i);
i                  47 kernel/syscalls/rename.c 		iput(i);
i                  55 kernel/syscalls/rename.c 			iput(i);
i                  80 kernel/syscalls/rename.c 		if(S_ISREG(i->i_mode)) {
i                  86 kernel/syscalls/rename.c 		if(S_ISDIR(i->i_mode)) {
i                  92 kernel/syscalls/rename.c 		if(i->inode == i_new->inode) {
i                 104 kernel/syscalls/rename.c 		errno = dir_new->fsop->rename(i, dir, i_new, dir_new, oldbasename, newbasename);
i                 110 kernel/syscalls/rename.c 	iput(i);
i                  19 kernel/syscalls/rmdir.c 	struct inode *i, *dir;
i                  30 kernel/syscalls/rmdir.c 	if((errno = namei(tmp_dirname, &i, &dir, !FOLLOW_LINKS))) {
i                  37 kernel/syscalls/rmdir.c 	if(!S_ISDIR(i->i_mode)) {
i                  38 kernel/syscalls/rmdir.c 		iput(i);
i                  43 kernel/syscalls/rmdir.c 	if(i == current->root || i->mount_point || i->count > 1) {
i                  44 kernel/syscalls/rmdir.c 		iput(i);
i                  49 kernel/syscalls/rmdir.c 	if(IS_RDONLY_FS(i)) {
i                  50 kernel/syscalls/rmdir.c 		iput(i);
i                  55 kernel/syscalls/rmdir.c 	if(i == dir) {
i                  56 kernel/syscalls/rmdir.c 		iput(i);
i                  62 kernel/syscalls/rmdir.c 		iput(i);
i                  70 kernel/syscalls/rmdir.c 		if(check_user_permission(i)) {
i                  71 kernel/syscalls/rmdir.c 			iput(i);
i                  78 kernel/syscalls/rmdir.c 	if(i->fsop && i->fsop->rmdir) {
i                  79 kernel/syscalls/rmdir.c 		errno = i->fsop->rmdir(dir, i);
i                  83 kernel/syscalls/rmdir.c 	iput(i);
i                  40 kernel/syscalls/select.c static int do_check(struct inode *i, int flag)
i                  42 kernel/syscalls/select.c 	if(i->fsop && i->fsop->select) {
i                  43 kernel/syscalls/select.c 		if(i->fsop->select(i, flag)) {
i                  54 kernel/syscalls/select.c 	struct inode *i;
i                  62 kernel/syscalls/select.c 			i = fd_table[current->fd[n]].inode;
i                  64 kernel/syscalls/select.c 				if(do_check(i, SEL_R)) {
i                  70 kernel/syscalls/select.c 				if(do_check(i, SEL_W)) {
i                  76 kernel/syscalls/select.c 				if(do_check(i, SEL_E)) {
i                  20 kernel/syscalls/stat.c 	struct inode *i;
i                  34 kernel/syscalls/stat.c 	if((errno = namei(tmp_name, &i, NULL, FOLLOW_LINKS))) {
i                  38 kernel/syscalls/stat.c 	statbuf->st_dev = i->dev;
i                  39 kernel/syscalls/stat.c 	statbuf->st_ino = i->inode;
i                  40 kernel/syscalls/stat.c 	statbuf->st_mode = i->i_mode;
i                  41 kernel/syscalls/stat.c 	statbuf->st_nlink = i->i_nlink;
i                  42 kernel/syscalls/stat.c 	statbuf->st_uid = i->i_uid;
i                  43 kernel/syscalls/stat.c 	statbuf->st_gid = i->i_gid;
i                  44 kernel/syscalls/stat.c 	statbuf->st_rdev = i->rdev;
i                  45 kernel/syscalls/stat.c 	statbuf->st_size = i->i_size;
i                  46 kernel/syscalls/stat.c 	statbuf->st_atime = i->i_atime;
i                  47 kernel/syscalls/stat.c 	statbuf->st_mtime = i->i_mtime;
i                  48 kernel/syscalls/stat.c 	statbuf->st_ctime = i->i_ctime;
i                  49 kernel/syscalls/stat.c 	iput(i);
i                  20 kernel/syscalls/statfs.c 	struct inode *i;
i                  34 kernel/syscalls/statfs.c 	if((errno = namei(tmp_name, &i, NULL, FOLLOW_LINKS))) {
i                  38 kernel/syscalls/statfs.c 	if(i->sb && i->sb->fsop && i->sb->fsop->statfs) {
i                  39 kernel/syscalls/statfs.c 		i->sb->fsop->statfs(i->sb, statfsbuf);
i                  40 kernel/syscalls/statfs.c 		iput(i);
i                  44 kernel/syscalls/statfs.c 	iput(i);
i                  20 kernel/syscalls/symlink.c 	struct inode *i, *dir;
i                  36 kernel/syscalls/symlink.c 	if((errno = namei(tmp_newpath, &i, &dir, !FOLLOW_LINKS))) {
i                  44 kernel/syscalls/symlink.c 		iput(i);
i                  21 kernel/syscalls/truncate.c 	struct inode *i;
i                  32 kernel/syscalls/truncate.c 	if((errno = namei(tmp_name, &i, NULL, FOLLOW_LINKS))) {
i                  36 kernel/syscalls/truncate.c 	if(S_ISDIR(i->i_mode)) {
i                  37 kernel/syscalls/truncate.c 		iput(i);
i                  41 kernel/syscalls/truncate.c 	if(IS_RDONLY_FS(i)) {
i                  42 kernel/syscalls/truncate.c 		iput(i);
i                  46 kernel/syscalls/truncate.c 	if(check_permission(TO_WRITE, i) < 0) {
i                  47 kernel/syscalls/truncate.c 		iput(i);
i                  51 kernel/syscalls/truncate.c 	if(length == i->i_size) {
i                  52 kernel/syscalls/truncate.c 		iput(i);
i                  58 kernel/syscalls/truncate.c 	if(i->fsop && i->fsop->truncate) {
i                  59 kernel/syscalls/truncate.c 		inode_lock(i);
i                  60 kernel/syscalls/truncate.c 		errno = i->fsop->truncate(i, length);
i                  61 kernel/syscalls/truncate.c 		inode_unlock(i);
i                  63 kernel/syscalls/truncate.c 	iput(i);
i                  21 kernel/syscalls/unlink.c 	struct inode *i, *dir;
i                  32 kernel/syscalls/unlink.c 	if((errno = namei(tmp_name, &i, &dir, !FOLLOW_LINKS))) {
i                  39 kernel/syscalls/unlink.c 	if(S_ISDIR(i->i_mode)) {
i                  40 kernel/syscalls/unlink.c 		iput(i);
i                  45 kernel/syscalls/unlink.c 	if(IS_RDONLY_FS(i)) {
i                  46 kernel/syscalls/unlink.c 		iput(i);
i                  52 kernel/syscalls/unlink.c 		iput(i);
i                  60 kernel/syscalls/unlink.c 		if(check_user_permission(i)) {
i                  61 kernel/syscalls/unlink.c 			iput(i);
i                  70 kernel/syscalls/unlink.c 		errno = dir->fsop->unlink(dir, i, basename);
i                  74 kernel/syscalls/unlink.c 	iput(i);
i                  22 kernel/syscalls/utime.c 	struct inode *i;
i                  33 kernel/syscalls/utime.c 	if((errno = namei(tmp_name, &i, NULL, FOLLOW_LINKS))) {
i                  38 kernel/syscalls/utime.c 	if(IS_RDONLY_FS(i)) {
i                  39 kernel/syscalls/utime.c 		iput(i);
i                  45 kernel/syscalls/utime.c 		if(check_user_permission(i) || check_permission(TO_WRITE, i)) {
i                  46 kernel/syscalls/utime.c 			iput(i);
i                  50 kernel/syscalls/utime.c 		i->i_atime = CURRENT_TIME;
i                  51 kernel/syscalls/utime.c 		i->i_mtime = CURRENT_TIME;
i                  54 kernel/syscalls/utime.c 			iput(i);
i                  58 kernel/syscalls/utime.c 		if(check_user_permission(i)) {
i                  59 kernel/syscalls/utime.c 			iput(i);
i                  63 kernel/syscalls/utime.c 		i->i_atime = times->actime;
i                  64 kernel/syscalls/utime.c 		i->i_mtime = times->modtime;
i                  67 kernel/syscalls/utime.c 	i->i_ctime = CURRENT_TIME;
i                  68 kernel/syscalls/utime.c 	i->dirty = 1;
i                  69 kernel/syscalls/utime.c 	iput(i);
i                  19 kernel/syscalls/write.c 	struct inode *i;
i                  40 kernel/syscalls/write.c 	i = fd_table[current->fd[ufd]].inode;
i                  41 kernel/syscalls/write.c 	if(i->fsop && i->fsop->write) {
i                  42 kernel/syscalls/write.c 		errno = i->fsop->write(i, &fd_table[current->fd[ufd]], buf, count);
i                 353 mm/mmap.c      int do_mmap(struct inode *i, unsigned int start, unsigned int length, unsigned int prot, unsigned int flags, unsigned int offset, char type, char mode)
i                 367 mm/mmap.c      	if(i) {
i                 368 mm/mmap.c      		if(!S_ISREG(i->i_mode) && !S_ISCHR(i->i_mode)) {
i                 393 mm/mmap.c      		i->count++;
i                 428 mm/mmap.c      	vma->inode = i;
i                 431 mm/mmap.c      	if(i && i->fsop->mmap) {
i                 432 mm/mmap.c      		if((errno = i->fsop->mmap(i, vma))) {
i                  49 mm/page.c      	int i;
i                  51 mm/page.c      	i = PAGE_HASH(pg->inode, pg->offset);
i                  52 mm/page.c      	h = &page_hash_table[i];
i                  69 mm/page.c      	int i;
i                  75 mm/page.c      	i = PAGE_HASH(pg->inode, pg->offset);
i                  76 mm/page.c      	h = &page_hash_table[i];
i                  86 mm/page.c      			if(h == &page_hash_table[i]) {
i                 191 mm/page.c      	int i;
i                 193 mm/page.c      	i = PAGE_HASH(inode->inode, offset);
i                 194 mm/page.c      	pg = page_hash_table[i];
i                 257 mm/page.c      void update_page_cache(struct inode *i, __off_t offset, const char *buf, int count)
i                 269 mm/page.c      		if((pg = search_page_hash(i, offset))) {
i                 278 mm/page.c      int write_page(struct page *pg, struct inode *i, __off_t offset, unsigned int length)
i                 284 mm/page.c      	size = MIN(i->i_size, length);
i                 285 mm/page.c      	fd_table.inode = i;
i                 289 mm/page.c      	if(i->fsop && i->fsop->write) {
i                 290 mm/page.c      		errno = i->fsop->write(i, &fd_table, pg->data, size);
i                 298 mm/page.c      int bread_page(struct page *pg, struct inode *i, __off_t offset, char prot, char flags)
i                 305 mm/page.c      	blksize = i->sb->s_blocksize;
i                 309 mm/page.c      		if((block = bmap(i, offset + size_read, FOR_READING)) < 0) {
i                 313 mm/page.c      			if(!(buf = bread(i->dev, block, blksize))) {
i                 327 mm/page.c      		pg->inode = i->inode;
i                 329 mm/page.c      		pg->dev = i->dev;
i                 336 mm/page.c      int file_read(struct inode *i, struct fd *fd_table, char *buffer, __size_t count)
i                 342 mm/page.c      	inode_lock(i);
i                 344 mm/page.c      	if(fd_table->offset > i->i_size) {
i                 345 mm/page.c      		fd_table->offset = i->i_size;
i                 351 mm/page.c      		count = (fd_table->offset + count > i->i_size) ? i->i_size - fd_table->offset : count;
i                 357 mm/page.c      		if(!(pg = search_page_hash(i, fd_table->offset & PAGE_MASK))) {
i                 359 mm/page.c      				inode_unlock(i);
i                 364 mm/page.c      			if(bread_page(pg, i, fd_table->offset & PAGE_MASK, 0, MAP_SHARED)) {
i                 366 mm/page.c      				inode_unlock(i);
i                 385 mm/page.c      	inode_unlock(i);