Lines Matching refs:inode
3 * linux/fs/ext2/inode.c
12 * linux/fs/minix/inode.c
43 static int __ext2_write_inode(struct inode *inode, int do_sync);
46 * Test whether an inode is a fast symlink.
48 static inline int ext2_inode_is_fast_symlink(struct inode *inode)
50 int ea_blocks = EXT2_I(inode)->i_file_acl ?
51 (inode->i_sb->s_blocksize >> 9) : 0;
53 return (S_ISLNK(inode->i_mode) &&
54 inode->i_blocks - ea_blocks == 0);
57 static void ext2_truncate_blocks(struct inode *inode, loff_t offset);
61 struct inode *inode = mapping->host;
63 if (to > inode->i_size) {
64 truncate_pagecache(inode, inode->i_size);
65 ext2_truncate_blocks(inode, inode->i_size);
72 void ext2_evict_inode(struct inode * inode)
77 if (!inode->i_nlink && !is_bad_inode(inode)) {
79 dquot_initialize(inode);
81 dquot_drop(inode);
84 truncate_inode_pages_final(&inode->i_data);
87 sb_start_intwrite(inode->i_sb);
89 EXT2_I(inode)->i_dtime = ktime_get_real_seconds();
90 mark_inode_dirty(inode);
91 __ext2_write_inode(inode, inode_needs_sync(inode));
93 inode->i_size = 0;
94 if (inode->i_blocks)
95 ext2_truncate_blocks(inode, 0);
96 ext2_xattr_delete_inode(inode);
99 invalidate_inode_buffers(inode);
100 clear_inode(inode);
102 ext2_discard_reservation(inode);
103 rsv = EXT2_I(inode)->i_block_alloc_info;
104 EXT2_I(inode)->i_block_alloc_info = NULL;
109 ext2_free_inode(inode);
110 sb_end_intwrite(inode->i_sb);
135 * @inode: inode in question (we are only interested in its superblock)
141 * for UNIX filesystems - tree of pointers anchored in the inode, with
150 * inode->i_sb).
163 static int ext2_block_to_path(struct inode *inode,
166 int ptrs = EXT2_ADDR_PER_BLOCK(inode->i_sb);
167 int ptrs_bits = EXT2_ADDR_PER_BLOCK_BITS(inode->i_sb);
175 ext2_msg(inode->i_sb, KERN_WARNING,
196 ext2_msg(inode->i_sb, KERN_WARNING,
207 * @inode: inode in question
209 * @offsets: offsets of pointers in inode/indirect blocks
218 * number (it points into struct inode for i==0 and into the bh->b_data
234 static Indirect *ext2_get_branch(struct inode *inode,
240 struct super_block *sb = inode->i_sb;
246 add_chain (chain, NULL, EXT2_I(inode)->i_data + *offsets);
253 read_lock(&EXT2_I(inode)->i_meta_lock);
257 read_unlock(&EXT2_I(inode)->i_meta_lock);
264 read_unlock(&EXT2_I(inode)->i_meta_lock);
276 * @inode: owner
284 * + if pointer will live in inode - allocate in the same cylinder group.
287 * prevent it from clashing with concurrent allocations for a different inode
294 static ext2_fsblk_t ext2_find_near(struct inode *inode, Indirect *ind)
296 struct ext2_inode_info *ei = EXT2_I(inode);
312 * It is going to be referred from inode itself? OK, just put it into
315 bg_start = ext2_group_first_block_no(inode->i_sb, ei->i_block_group);
317 (EXT2_BLOCKS_PER_GROUP(inode->i_sb) / 16);
323 * @inode: owner
330 static inline ext2_fsblk_t ext2_find_goal(struct inode *inode, long block,
335 block_i = EXT2_I(inode)->i_block_alloc_info;
346 return ext2_find_near(inode, partial);
395 static int ext2_alloc_blocks(struct inode *inode,
418 current_block = ext2_new_blocks(inode,goal,&count,err);
442 ext2_free_blocks(inode, new_blocks[i], 1);
444 mark_inode_dirty(inode);
450 * @inode: owner
460 * inode. It stores the information about that chain in the branch[], in
475 static int ext2_alloc_branch(struct inode *inode,
479 int blocksize = inode->i_sb->s_blocksize;
487 num = ext2_alloc_blocks(inode, goal, indirect_blks,
502 bh = sb_getblk(inode->i_sb, new_blocks[n-1]);
525 mark_buffer_dirty_inode(bh, inode);
526 /* We used to sync bh here if IS_SYNC(inode).
530 if (S_ISDIR(inode->i_mode) && IS_DIRSYNC(inode))
540 ext2_free_blocks(inode, new_blocks[i], 1);
541 ext2_free_blocks(inode, new_blocks[i], num);
546 * ext2_splice_branch - splice the allocated branch onto inode.
547 * @inode: owner
554 * inode (->i_blocks, etc.). In case of success we end up with the full
557 static void ext2_splice_branch(struct inode *inode,
564 block_i = EXT2_I(inode)->i_block_alloc_info;
572 * Update the host buffer_head or inode to point to more just allocated
596 mark_buffer_dirty_inode(where->bh, inode);
598 inode->i_ctime = current_time(inode);
599 mark_inode_dirty(inode);
612 * reachable from inode.
620 static int ext2_get_blocks(struct inode *inode,
633 struct ext2_inode_info *ei = EXT2_I(inode);
639 depth = ext2_block_to_path(inode,iblock,offsets,&blocks_to_boundary);
644 partial = ext2_get_branch(inode, depth, offsets, chain, &err);
697 partial = ext2_get_branch(inode, depth, offsets, chain, &err);
714 if (S_ISREG(inode->i_mode) && (!ei->i_block_alloc_info))
715 ext2_init_block_alloc_info(inode);
717 goal = ext2_find_goal(inode, iblock, partial);
730 err = ext2_alloc_branch(inode, indirect_blks, &count, goal,
738 if (IS_DAX(inode)) {
743 clean_bdev_aliases(inode->i_sb->s_bdev,
751 err = sb_issue_zeroout(inode->i_sb,
761 ext2_splice_branch(inode, iblock, partial, indirect_blks, count);
779 int ext2_get_block(struct inode *inode, sector_t iblock,
782 unsigned max_blocks = bh_result->b_size >> inode->i_blkbits;
787 ret = ext2_get_blocks(inode, iblock, max_blocks, &bno, &new, &boundary,
792 map_bh(bh_result, inode->i_sb, bno);
793 bh_result->b_size = (ret << inode->i_blkbits);
803 static int ext2_iomap_begin(struct inode *inode, loff_t offset, loff_t length,
806 unsigned int blkbits = inode->i_blkbits;
809 struct ext2_sb_info *sbi = EXT2_SB(inode->i_sb);
814 ret = ext2_get_blocks(inode, first_block, max_blocks,
820 iomap->bdev = inode->i_sb->s_bdev;
841 ext2_iomap_end(struct inode *inode, loff_t offset, loff_t length,
847 ext2_write_failed(inode->i_mapping, offset + length);
860 int ext2_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
863 return generic_block_fiemap(inode, fieinfo, start, len,
938 struct inode *inode = mapping->host;
943 ret = blockdev_direct_IO(iocb, inode, iter, ext2_get_block);
1012 * @inode: inode in question
1040 * c) free the subtrees growing from the inode past the @chain[0].p
1044 static Indirect *ext2_find_shared(struct inode *inode,
1056 partial = ext2_get_branch(inode, k, offsets, chain, &err);
1063 write_lock(&EXT2_I(inode)->i_meta_lock);
1065 write_unlock(&EXT2_I(inode)->i_meta_lock);
1073 * of branch is all ours and does not grow immediately from the inode
1082 write_unlock(&EXT2_I(inode)->i_meta_lock);
1095 * @inode: inode we are dealing with
1100 * stored as little-endian 32-bit) and updating @inode->i_blocks
1103 static inline void ext2_free_data(struct inode *inode, __le32 *p, __le32 *q)
1118 ext2_free_blocks (inode, block_to_free, count);
1119 mark_inode_dirty(inode);
1127 ext2_free_blocks (inode, block_to_free, count);
1128 mark_inode_dirty(inode);
1134 * @inode: inode we are dealing with
1140 * stored as little-endian 32-bit) and updating @inode->i_blocks
1143 static void ext2_free_branches(struct inode *inode, __le32 *p, __le32 *q, int depth)
1149 int addr_per_block = EXT2_ADDR_PER_BLOCK(inode->i_sb);
1155 bh = sb_bread(inode->i_sb, nr);
1161 ext2_error(inode->i_sb, "ext2_free_branches",
1162 "Read failure, inode=%ld, block=%ld",
1163 inode->i_ino, nr);
1166 ext2_free_branches(inode,
1171 ext2_free_blocks(inode, nr, 1);
1172 mark_inode_dirty(inode);
1175 ext2_free_data(inode, p, q);
1179 static void __ext2_truncate_blocks(struct inode *inode, loff_t offset)
1181 __le32 *i_data = EXT2_I(inode)->i_data;
1182 struct ext2_inode_info *ei = EXT2_I(inode);
1183 int addr_per_block = EXT2_ADDR_PER_BLOCK(inode->i_sb);
1191 blocksize = inode->i_sb->s_blocksize;
1192 iblock = (offset + blocksize-1) >> EXT2_BLOCK_SIZE_BITS(inode->i_sb);
1198 n = ext2_block_to_path(inode, iblock, offsets, NULL);
1209 ext2_free_data(inode, i_data+offsets[0],
1214 partial = ext2_find_shared(inode, n, offsets, chain, &nr);
1218 mark_inode_dirty(inode);
1220 mark_buffer_dirty_inode(partial->bh, inode);
1221 ext2_free_branches(inode, &nr, &nr+1, (chain+n-1) - partial);
1225 ext2_free_branches(inode,
1229 mark_buffer_dirty_inode(partial->bh, inode);
1240 mark_inode_dirty(inode);
1241 ext2_free_branches(inode, &nr, &nr+1, 1);
1248 mark_inode_dirty(inode);
1249 ext2_free_branches(inode, &nr, &nr+1, 2);
1256 mark_inode_dirty(inode);
1257 ext2_free_branches(inode, &nr, &nr+1, 3);
1263 ext2_discard_reservation(inode);
1268 static void ext2_truncate_blocks(struct inode *inode, loff_t offset)
1270 if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
1271 S_ISLNK(inode->i_mode)))
1273 if (ext2_inode_is_fast_symlink(inode))
1276 dax_sem_down_write(EXT2_I(inode));
1277 __ext2_truncate_blocks(inode, offset);
1278 dax_sem_up_write(EXT2_I(inode));
1281 static int ext2_setsize(struct inode *inode, loff_t newsize)
1285 if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
1286 S_ISLNK(inode->i_mode)))
1288 if (ext2_inode_is_fast_symlink(inode))
1290 if (IS_APPEND(inode) || IS_IMMUTABLE(inode))
1293 inode_dio_wait(inode);
1295 if (IS_DAX(inode)) {
1296 error = iomap_zero_range(inode, newsize,
1299 } else if (test_opt(inode->i_sb, NOBH))
1300 error = nobh_truncate_page(inode->i_mapping,
1303 error = block_truncate_page(inode->i_mapping,
1308 dax_sem_down_write(EXT2_I(inode));
1309 truncate_setsize(inode, newsize);
1310 __ext2_truncate_blocks(inode, newsize);
1311 dax_sem_up_write(EXT2_I(inode));
1313 inode->i_mtime = inode->i_ctime = current_time(inode);
1314 if (inode_needs_sync(inode)) {
1315 sync_mapping_buffers(inode->i_mapping);
1316 sync_inode_metadata(inode, 1);
1318 mark_inode_dirty(inode);
1343 * Figure out the offset within the block group inode table
1356 ext2_error(sb, "ext2_get_inode", "bad inode number: %lu",
1361 "unable to read inode block - inode=%lu, block=%lu",
1367 void ext2_set_inode_flags(struct inode *inode)
1369 unsigned int flags = EXT2_I(inode)->i_flags;
1371 inode->i_flags &= ~(S_SYNC | S_APPEND | S_IMMUTABLE | S_NOATIME |
1374 inode->i_flags |= S_SYNC;
1376 inode->i_flags |= S_APPEND;
1378 inode->i_flags |= S_IMMUTABLE;
1380 inode->i_flags |= S_NOATIME;
1382 inode->i_flags |= S_DIRSYNC;
1383 if (test_opt(inode->i_sb, DAX) && S_ISREG(inode->i_mode))
1384 inode->i_flags |= S_DAX;
1387 void ext2_set_file_ops(struct inode *inode)
1389 inode->i_op = &ext2_file_inode_operations;
1390 inode->i_fop = &ext2_file_operations;
1391 if (IS_DAX(inode))
1392 inode->i_mapping->a_ops = &ext2_dax_aops;
1393 else if (test_opt(inode->i_sb, NOBH))
1394 inode->i_mapping->a_ops = &ext2_nobh_aops;
1396 inode->i_mapping->a_ops = &ext2_aops;
1399 struct inode *ext2_iget (struct super_block *sb, unsigned long ino)
1404 struct inode *inode;
1410 inode = iget_locked(sb, ino);
1411 if (!inode)
1413 if (!(inode->i_state & I_NEW))
1414 return inode;
1416 ei = EXT2_I(inode);
1419 raw_inode = ext2_get_inode(inode->i_sb, ino, &bh);
1425 inode->i_mode = le16_to_cpu(raw_inode->i_mode);
1428 if (!(test_opt (inode->i_sb, NO_UID32))) {
1432 i_uid_write(inode, i_uid);
1433 i_gid_write(inode, i_gid);
1434 set_nlink(inode, le16_to_cpu(raw_inode->i_links_count));
1435 inode->i_size = le32_to_cpu(raw_inode->i_size);
1436 inode->i_atime.tv_sec = (signed)le32_to_cpu(raw_inode->i_atime);
1437 inode->i_ctime.tv_sec = (signed)le32_to_cpu(raw_inode->i_ctime);
1438 inode->i_mtime.tv_sec = (signed)le32_to_cpu(raw_inode->i_mtime);
1439 inode->i_atime.tv_nsec = inode->i_mtime.tv_nsec = inode->i_ctime.tv_nsec = 0;
1441 /* We now have enough fields to check if the inode was active or not.
1446 if (inode->i_nlink == 0 && (inode->i_mode == 0 || ei->i_dtime)) {
1447 /* this inode is deleted */
1451 inode->i_blocks = le32_to_cpu(raw_inode->i_blocks);
1453 ext2_set_inode_flags(inode);
1468 if (S_ISREG(inode->i_mode))
1469 inode->i_size |= ((__u64)le32_to_cpu(raw_inode->i_size_high)) << 32;
1472 if (i_size_read(inode) < 0) {
1477 inode->i_generation = le32_to_cpu(raw_inode->i_generation);
1479 ei->i_block_group = (ino - 1) / EXT2_INODES_PER_GROUP(inode->i_sb);
1483 * NOTE! The in-memory inode i_data array is in little-endian order
1489 if (S_ISREG(inode->i_mode)) {
1490 ext2_set_file_ops(inode);
1491 } else if (S_ISDIR(inode->i_mode)) {
1492 inode->i_op = &ext2_dir_inode_operations;
1493 inode->i_fop = &ext2_dir_operations;
1494 if (test_opt(inode->i_sb, NOBH))
1495 inode->i_mapping->a_ops = &ext2_nobh_aops;
1497 inode->i_mapping->a_ops = &ext2_aops;
1498 } else if (S_ISLNK(inode->i_mode)) {
1499 if (ext2_inode_is_fast_symlink(inode)) {
1500 inode->i_link = (char *)ei->i_data;
1501 inode->i_op = &ext2_fast_symlink_inode_operations;
1502 nd_terminate_link(ei->i_data, inode->i_size,
1505 inode->i_op = &ext2_symlink_inode_operations;
1506 inode_nohighmem(inode);
1507 if (test_opt(inode->i_sb, NOBH))
1508 inode->i_mapping->a_ops = &ext2_nobh_aops;
1510 inode->i_mapping->a_ops = &ext2_aops;
1513 inode->i_op = &ext2_special_inode_operations;
1515 init_special_inode(inode, inode->i_mode,
1518 init_special_inode(inode, inode->i_mode,
1522 unlock_new_inode(inode);
1523 return inode;
1527 iget_failed(inode);
1531 static int __ext2_write_inode(struct inode *inode, int do_sync)
1533 struct ext2_inode_info *ei = EXT2_I(inode);
1534 struct super_block *sb = inode->i_sb;
1535 ino_t ino = inode->i_ino;
1536 uid_t uid = i_uid_read(inode);
1537 gid_t gid = i_gid_read(inode);
1546 /* For fields not not tracking in the in-memory inode,
1551 raw_inode->i_mode = cpu_to_le16(inode->i_mode);
1572 raw_inode->i_links_count = cpu_to_le16(inode->i_nlink);
1573 raw_inode->i_size = cpu_to_le32(inode->i_size);
1574 raw_inode->i_atime = cpu_to_le32(inode->i_atime.tv_sec);
1575 raw_inode->i_ctime = cpu_to_le32(inode->i_ctime.tv_sec);
1576 raw_inode->i_mtime = cpu_to_le32(inode->i_mtime.tv_sec);
1578 raw_inode->i_blocks = cpu_to_le32(inode->i_blocks);
1585 if (!S_ISREG(inode->i_mode))
1588 raw_inode->i_size_high = cpu_to_le32(inode->i_size >> 32);
1589 if (inode->i_size > 0x7fffffffULL) {
1607 raw_inode->i_generation = cpu_to_le32(inode->i_generation);
1608 if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode)) {
1609 if (old_valid_dev(inode->i_rdev)) {
1611 cpu_to_le32(old_encode_dev(inode->i_rdev));
1616 cpu_to_le32(new_encode_dev(inode->i_rdev));
1625 printk ("IO error syncing ext2 inode [%s:%08lx]\n",
1635 int ext2_write_inode(struct inode *inode, struct writeback_control *wbc)
1637 return __ext2_write_inode(inode, wbc->sync_mode == WB_SYNC_ALL);
1643 struct inode *inode = d_inode(path->dentry);
1644 struct ext2_inode_info *ei = EXT2_I(inode);
1662 generic_fillattr(inode, stat);
1668 struct inode *inode = d_inode(dentry);
1675 if (is_quota_modification(inode, iattr)) {
1676 error = dquot_initialize(inode);
1680 if ((iattr->ia_valid & ATTR_UID && !uid_eq(iattr->ia_uid, inode->i_uid)) ||
1681 (iattr->ia_valid & ATTR_GID && !gid_eq(iattr->ia_gid, inode->i_gid))) {
1682 error = dquot_transfer(inode, iattr);
1686 if (iattr->ia_valid & ATTR_SIZE && iattr->ia_size != inode->i_size) {
1687 error = ext2_setsize(inode, iattr->ia_size);
1691 setattr_copy(inode, iattr);
1693 error = posix_acl_chmod(inode, inode->i_mode);
1694 mark_inode_dirty(inode);