Lines Matching +full:- +full:- +full:scan
2 * inode.c --- utility routines to read and write inodes
6 * %Begin-Header%
9 * %End-Header%
35 #define SCAN_BLOCK_STATUS(scan) ((scan)->temp_buffer + (scan)->inode_size) argument
53 ext2_inode_scan scan,
69 if (!fs->icache) in ext2fs_flush_icache()
72 for (i=0; i < fs->icache->cache_size; i++) in ext2fs_flush_icache()
73 fs->icache->cache[i].ino = 0; in ext2fs_flush_icache()
75 fs->icache->buffer_blk = 0; in ext2fs_flush_icache()
86 if (--icache->refcount) in ext2fs_free_inode_cache()
88 if (icache->buffer) in ext2fs_free_inode_cache()
89 ext2fs_free_mem(&icache->buffer); in ext2fs_free_inode_cache()
90 for (i = 0; i < icache->cache_size; i++) in ext2fs_free_inode_cache()
91 ext2fs_free_mem(&icache->cache[i].inode); in ext2fs_free_inode_cache()
92 if (icache->cache) in ext2fs_free_inode_cache()
93 ext2fs_free_mem(&icache->cache); in ext2fs_free_inode_cache()
94 icache->buffer_blk = 0; in ext2fs_free_inode_cache()
103 if (fs->icache) in ext2fs_create_inode_cache()
105 retval = ext2fs_get_mem(sizeof(struct ext2_inode_cache), &fs->icache); in ext2fs_create_inode_cache()
109 memset(fs->icache, 0, sizeof(struct ext2_inode_cache)); in ext2fs_create_inode_cache()
110 retval = ext2fs_get_mem(fs->blocksize, &fs->icache->buffer); in ext2fs_create_inode_cache()
114 fs->icache->buffer_blk = 0; in ext2fs_create_inode_cache()
115 fs->icache->cache_last = -1; in ext2fs_create_inode_cache()
116 fs->icache->cache_size = cache_size; in ext2fs_create_inode_cache()
117 fs->icache->refcount = 1; in ext2fs_create_inode_cache()
118 retval = ext2fs_get_array(fs->icache->cache_size, in ext2fs_create_inode_cache()
120 &fs->icache->cache); in ext2fs_create_inode_cache()
124 for (i = 0; i < fs->icache->cache_size; i++) { in ext2fs_create_inode_cache()
125 retval = ext2fs_get_mem(EXT2_INODE_SIZE(fs->super), in ext2fs_create_inode_cache()
126 &fs->icache->cache[i].inode); in ext2fs_create_inode_cache()
134 ext2fs_free_inode_cache(fs->icache); in ext2fs_create_inode_cache()
135 fs->icache = 0; in ext2fs_create_inode_cache()
142 ext2_inode_scan scan; in ext2fs_open_inode_scan() local
148 if (ext2fs_has_feature_journal_dev(fs->super)) in ext2fs_open_inode_scan()
151 if (fs->blocksize < 1024) in ext2fs_open_inode_scan()
155 * If fs->badblocks isn't set, then set it --- since the inode in ext2fs_open_inode_scan()
158 if (fs->badblocks == 0) { in ext2fs_open_inode_scan()
160 * Temporarily save fs->get_blocks and set it to zero, in ext2fs_open_inode_scan()
163 save_get_blocks = fs->get_blocks; in ext2fs_open_inode_scan()
164 fs->get_blocks = 0; in ext2fs_open_inode_scan()
165 retval = ext2fs_read_bb_inode(fs, &fs->badblocks); in ext2fs_open_inode_scan()
166 if (retval && fs->badblocks) { in ext2fs_open_inode_scan()
167 ext2fs_badblocks_list_free(fs->badblocks); in ext2fs_open_inode_scan()
168 fs->badblocks = 0; in ext2fs_open_inode_scan()
170 fs->get_blocks = save_get_blocks; in ext2fs_open_inode_scan()
173 retval = ext2fs_get_mem(sizeof(struct ext2_struct_inode_scan), &scan); in ext2fs_open_inode_scan()
176 memset(scan, 0, sizeof(struct ext2_struct_inode_scan)); in ext2fs_open_inode_scan()
178 scan->magic = EXT2_ET_MAGIC_INODE_SCAN; in ext2fs_open_inode_scan()
179 scan->fs = fs; in ext2fs_open_inode_scan()
180 scan->inode_size = EXT2_INODE_SIZE(fs->super); in ext2fs_open_inode_scan()
181 scan->bytes_left = 0; in ext2fs_open_inode_scan()
182 scan->current_group = 0; in ext2fs_open_inode_scan()
183 scan->groups_left = fs->group_desc_count - 1; in ext2fs_open_inode_scan()
184 scan->inode_buffer_blocks = buffer_blocks ? buffer_blocks : in ext2fs_open_inode_scan()
186 scan->current_block = ext2fs_inode_table_loc(scan->fs, in ext2fs_open_inode_scan()
187 scan->current_group); in ext2fs_open_inode_scan()
188 if (scan->current_block && in ext2fs_open_inode_scan()
189 ((scan->current_block < fs->super->s_first_data_block) || in ext2fs_open_inode_scan()
190 (scan->current_block + fs->inode_blocks_per_group - 1 >= in ext2fs_open_inode_scan()
191 ext2fs_blocks_count(fs->super)))) { in ext2fs_open_inode_scan()
192 ext2fs_free_mem(&scan); in ext2fs_open_inode_scan()
196 scan->inodes_left = EXT2_INODES_PER_GROUP(scan->fs->super); in ext2fs_open_inode_scan()
197 scan->blocks_left = scan->fs->inode_blocks_per_group; in ext2fs_open_inode_scan()
199 __u32 unused = ext2fs_bg_itable_unused(fs, scan->current_group); in ext2fs_open_inode_scan()
200 if (scan->inodes_left > unused) in ext2fs_open_inode_scan()
201 scan->inodes_left -= unused; in ext2fs_open_inode_scan()
203 scan->inodes_left = 0; in ext2fs_open_inode_scan()
204 scan->blocks_left = in ext2fs_open_inode_scan()
205 (scan->inodes_left + in ext2fs_open_inode_scan()
206 (fs->blocksize / scan->inode_size - 1)) * in ext2fs_open_inode_scan()
207 scan->inode_size / fs->blocksize; in ext2fs_open_inode_scan()
209 retval = io_channel_alloc_buf(fs->io, scan->inode_buffer_blocks, in ext2fs_open_inode_scan()
210 &scan->inode_buffer); in ext2fs_open_inode_scan()
211 scan->done_group = 0; in ext2fs_open_inode_scan()
212 scan->done_group_data = 0; in ext2fs_open_inode_scan()
213 scan->bad_block_ptr = 0; in ext2fs_open_inode_scan()
215 ext2fs_free_mem(&scan); in ext2fs_open_inode_scan()
218 retval = ext2fs_get_mem(scan->inode_size + scan->inode_buffer_blocks, in ext2fs_open_inode_scan()
219 &scan->temp_buffer); in ext2fs_open_inode_scan()
221 ext2fs_free_mem(&scan->inode_buffer); in ext2fs_open_inode_scan()
222 ext2fs_free_mem(&scan); in ext2fs_open_inode_scan()
225 memset(SCAN_BLOCK_STATUS(scan), 0, scan->inode_buffer_blocks); in ext2fs_open_inode_scan()
226 if (scan->fs->badblocks && scan->fs->badblocks->num) in ext2fs_open_inode_scan()
227 scan->scan_flags |= EXT2_SF_CHK_BADBLOCKS; in ext2fs_open_inode_scan()
229 scan->scan_flags |= EXT2_SF_DO_LAZY; in ext2fs_open_inode_scan()
230 *ret_scan = scan; in ext2fs_open_inode_scan()
234 void ext2fs_close_inode_scan(ext2_inode_scan scan) in ext2fs_close_inode_scan() argument
236 if (!scan || (scan->magic != EXT2_ET_MAGIC_INODE_SCAN)) in ext2fs_close_inode_scan()
239 ext2fs_free_mem(&scan->inode_buffer); in ext2fs_close_inode_scan()
240 scan->inode_buffer = NULL; in ext2fs_close_inode_scan()
241 ext2fs_free_mem(&scan->temp_buffer); in ext2fs_close_inode_scan()
242 scan->temp_buffer = NULL; in ext2fs_close_inode_scan()
243 ext2fs_free_mem(&scan); in ext2fs_close_inode_scan()
247 void ext2fs_set_inode_callback(ext2_inode_scan scan, in ext2fs_set_inode_callback() argument
249 ext2_inode_scan scan, in ext2fs_set_inode_callback()
254 if (!scan || (scan->magic != EXT2_ET_MAGIC_INODE_SCAN)) in ext2fs_set_inode_callback()
257 scan->done_group = done_group; in ext2fs_set_inode_callback()
258 scan->done_group_data = done_group_data; in ext2fs_set_inode_callback()
261 int ext2fs_inode_scan_flags(ext2_inode_scan scan, int set_flags, in ext2fs_inode_scan_flags() argument
266 if (!scan || (scan->magic != EXT2_ET_MAGIC_INODE_SCAN)) in ext2fs_inode_scan_flags()
269 old_flags = scan->scan_flags; in ext2fs_inode_scan_flags()
270 scan->scan_flags &= ~clear_flags; in ext2fs_inode_scan_flags()
271 scan->scan_flags |= set_flags; in ext2fs_inode_scan_flags()
279 static errcode_t get_next_blockgroup(ext2_inode_scan scan) in get_next_blockgroup() argument
281 ext2_filsys fs = scan->fs; in get_next_blockgroup()
283 scan->current_group++; in get_next_blockgroup()
284 scan->groups_left--; in get_next_blockgroup()
286 scan->current_block = ext2fs_inode_table_loc(scan->fs, in get_next_blockgroup()
287 scan->current_group); in get_next_blockgroup()
288 scan->current_inode = scan->current_group * in get_next_blockgroup()
289 EXT2_INODES_PER_GROUP(fs->super); in get_next_blockgroup()
291 scan->bytes_left = 0; in get_next_blockgroup()
292 scan->inodes_left = EXT2_INODES_PER_GROUP(fs->super); in get_next_blockgroup()
293 scan->blocks_left = fs->inode_blocks_per_group; in get_next_blockgroup()
295 __u32 unused = ext2fs_bg_itable_unused(fs, scan->current_group); in get_next_blockgroup()
296 if (scan->inodes_left > unused) in get_next_blockgroup()
297 scan->inodes_left -= unused; in get_next_blockgroup()
299 scan->inodes_left = 0; in get_next_blockgroup()
300 scan->blocks_left = in get_next_blockgroup()
301 (scan->inodes_left + in get_next_blockgroup()
302 (fs->blocksize / scan->inode_size - 1)) * in get_next_blockgroup()
303 scan->inode_size / fs->blocksize; in get_next_blockgroup()
305 if (scan->current_block && in get_next_blockgroup()
306 ((scan->current_block < fs->super->s_first_data_block) || in get_next_blockgroup()
307 (scan->current_block + fs->inode_blocks_per_group - 1 >= in get_next_blockgroup()
308 ext2fs_blocks_count(fs->super)))) in get_next_blockgroup()
313 errcode_t ext2fs_inode_scan_goto_blockgroup(ext2_inode_scan scan, in ext2fs_inode_scan_goto_blockgroup() argument
316 scan->current_group = group - 1; in ext2fs_inode_scan_goto_blockgroup()
317 scan->groups_left = scan->fs->group_desc_count - group; in ext2fs_inode_scan_goto_blockgroup()
318 scan->bad_block_ptr = 0; in ext2fs_inode_scan_goto_blockgroup()
319 return get_next_blockgroup(scan); in ext2fs_inode_scan_goto_blockgroup()
326 * This function assumes that badblocks_list->list is sorted in
329 static errcode_t check_for_inode_bad_blocks(ext2_inode_scan scan, in check_for_inode_bad_blocks() argument
332 blk64_t blk = scan->current_block; in check_for_inode_bad_blocks()
333 badblocks_list bb = scan->fs->badblocks; in check_for_inode_bad_blocks()
337 * bad blocks. :-) in check_for_inode_bad_blocks()
343 if (scan->bad_block_ptr >= bb->num) { in check_for_inode_bad_blocks()
344 scan->scan_flags &= ~EXT2_SF_CHK_BADBLOCKS; in check_for_inode_bad_blocks()
354 while (blk > bb->list[scan->bad_block_ptr]) { in check_for_inode_bad_blocks()
355 if (++scan->bad_block_ptr >= bb->num) { in check_for_inode_bad_blocks()
356 scan->scan_flags &= ~EXT2_SF_CHK_BADBLOCKS; in check_for_inode_bad_blocks()
369 if (blk == bb->list[scan->bad_block_ptr]) { in check_for_inode_bad_blocks()
370 scan->scan_flags |= EXT2_SF_BAD_INODE_BLK; in check_for_inode_bad_blocks()
372 if (++scan->bad_block_ptr >= bb->num) in check_for_inode_bad_blocks()
373 scan->scan_flags &= ~EXT2_SF_CHK_BADBLOCKS; in check_for_inode_bad_blocks()
383 if ((blk + *num_blocks) > bb->list[scan->bad_block_ptr]) in check_for_inode_bad_blocks()
384 *num_blocks = (int) (bb->list[scan->bad_block_ptr] - blk); in check_for_inode_bad_blocks()
395 if ((inode->i_flags & EXT4_INLINE_DATA_FL) || in block_map_looks_insane()
396 (inode->i_flags & EXT4_EXTENTS_FL)) in block_map_looks_insane()
398 if (!LINUX_S_ISREG(inode->i_mode) && in block_map_looks_insane()
399 !LINUX_S_ISLNK(inode->i_mode) && in block_map_looks_insane()
400 !LINUX_S_ISDIR(inode->i_mode)) in block_map_looks_insane()
402 if (LINUX_S_ISLNK(inode->i_mode) && in block_map_looks_insane()
403 EXT2_I_SIZE(inode) <= sizeof(inode->i_block)) in block_map_looks_insane()
407 if (inode->i_links_count == 0) in block_map_looks_insane()
412 if (inode->i_block[i] != 0 && in block_map_looks_insane()
413 (inode->i_block[i] < fs->super->s_first_data_block || in block_map_looks_insane()
414 inode->i_block[i] >= ext2fs_blocks_count(fs->super))) in block_map_looks_insane()
421 if (!(inode->i_flags & EXT4_EXTENTS_FL) || in extent_head_looks_insane()
422 ext2fs_extent_header_verify(inode->i_block, in extent_head_looks_insane()
423 sizeof(inode->i_block)) == 0) in extent_head_looks_insane()
430 * find here -- currently, we can observe that all checksums are ok; more
433 static void check_inode_block_sanity(ext2_inode_scan scan, blk64_t num_blocks) in check_inode_block_sanity() argument
443 if (!(scan->scan_flags & EXT2_SF_WARN_GARBAGE_INODES)) in check_inode_block_sanity()
446 inodes_to_scan = scan->inodes_left; in check_inode_block_sanity()
447 inodes_in_buf = num_blocks * scan->fs->blocksize / scan->inode_size; in check_inode_block_sanity()
451 p = (char *) scan->inode_buffer; in check_inode_block_sanity()
452 ino = scan->current_inode + 1; in check_inode_block_sanity()
454 block_status = SCAN_BLOCK_STATUS(scan); in check_inode_block_sanity()
455 memset(block_status, 0, scan->inode_buffer_blocks); in check_inode_block_sanity()
456 inodes_per_block = EXT2_INODES_PER_BLOCK(scan->fs->super); in check_inode_block_sanity()
462 if (ext2fs_get_mem(EXT2_INODE_SIZE(scan->fs->super), &inode)) in check_inode_block_sanity()
467 blk = (p - (char *)scan->inode_buffer) / scan->fs->blocksize; in check_inode_block_sanity()
468 bad_csum = ext2fs_inode_csum_verify(scan->fs, ino, in check_inode_block_sanity()
472 ext2fs_swap_inode_full(scan->fs, in check_inode_block_sanity()
475 0, EXT2_INODE_SIZE(scan->fs->super)); in check_inode_block_sanity()
485 block_map_looks_insane(scan->fs, inode)) in check_inode_block_sanity()
493 ino_adj = inodes_per_block - in check_inode_block_sanity()
494 ((ino - 1) % inodes_per_block); in check_inode_block_sanity()
497 inodes_to_scan -= ino_adj; in check_inode_block_sanity()
498 p += scan->inode_size * ino_adj; in check_inode_block_sanity()
509 inodes_to_scan--; in check_inode_block_sanity()
510 p += scan->inode_size; in check_inode_block_sanity()
523 static errcode_t get_next_blocks(ext2_inode_scan scan) in get_next_blocks() argument
533 num_blocks = scan->inode_buffer_blocks; in get_next_blocks()
534 if (num_blocks > scan->blocks_left) in get_next_blocks()
535 num_blocks = scan->blocks_left; in get_next_blocks()
539 * left-over extra bytes as also being bad. in get_next_blocks()
541 if (scan->scan_flags & EXT2_SF_BAD_INODE_BLK) { in get_next_blocks()
542 if (scan->bytes_left) in get_next_blocks()
543 scan->scan_flags |= EXT2_SF_BAD_EXTRA_BYTES; in get_next_blocks()
544 scan->scan_flags &= ~EXT2_SF_BAD_INODE_BLK; in get_next_blocks()
550 if (scan->scan_flags & EXT2_SF_CHK_BADBLOCKS) { in get_next_blocks()
551 retval = check_for_inode_bad_blocks(scan, &num_blocks); in get_next_blocks()
556 if ((scan->scan_flags & EXT2_SF_BAD_INODE_BLK) || in get_next_blocks()
557 (scan->current_block == 0)) { in get_next_blocks()
558 memset(scan->inode_buffer, 0, in get_next_blocks()
559 (size_t) num_blocks * scan->fs->blocksize); in get_next_blocks()
561 retval = io_channel_read_blk64(scan->fs->io, in get_next_blocks()
562 scan->current_block, in get_next_blocks()
564 scan->inode_buffer); in get_next_blocks()
568 check_inode_block_sanity(scan, num_blocks); in get_next_blocks()
570 scan->ptr = scan->inode_buffer; in get_next_blocks()
571 scan->bytes_left = num_blocks * scan->fs->blocksize; in get_next_blocks()
573 scan->blocks_left -= num_blocks; in get_next_blocks()
574 if (scan->current_block) in get_next_blocks()
575 scan->current_block += num_blocks; in get_next_blocks()
582 * Returns 1 if the entire inode_buffer has a non-zero size and
587 static inline int is_empty_scan(ext2_inode_scan scan)
591 if (scan->bytes_left == 0)
594 for (i=0; i < scan->bytes_left; i++)
595 if (scan->ptr[i])
601 errcode_t ext2fs_get_next_inode_full(ext2_inode_scan scan, ext2_ino_t *ino, in ext2fs_get_next_inode_full() argument
611 EXT2_CHECK_MAGIC(scan, EXT2_ET_MAGIC_INODE_SCAN); in ext2fs_get_next_inode_full()
612 length = EXT2_INODE_SIZE(scan->fs->super); in ext2fs_get_next_inode_full()
613 iblock_status = SCAN_BLOCK_STATUS(scan); in ext2fs_get_next_inode_full()
618 if (scan->inodes_left <= 0) { in ext2fs_get_next_inode_full()
620 if (scan->done_group) { in ext2fs_get_next_inode_full()
621 retval = (scan->done_group) in ext2fs_get_next_inode_full()
622 (scan->fs, scan, scan->current_group, in ext2fs_get_next_inode_full()
623 scan->done_group_data); in ext2fs_get_next_inode_full()
627 if (scan->groups_left <= 0) { in ext2fs_get_next_inode_full()
631 retval = get_next_blockgroup(scan); in ext2fs_get_next_inode_full()
639 if ((scan->scan_flags & EXT2_SF_DO_LAZY) && in ext2fs_get_next_inode_full()
640 (ext2fs_bg_flags_test(scan->fs, scan->current_group, EXT2_BG_INODE_UNINIT) in ext2fs_get_next_inode_full()
643 if (scan->inodes_left == 0) in ext2fs_get_next_inode_full()
645 if (scan->current_block == 0) { in ext2fs_get_next_inode_full()
646 if (scan->scan_flags & EXT2_SF_SKIP_MISSING_ITABLE) { in ext2fs_get_next_inode_full()
657 if (scan->bytes_left < scan->inode_size) { in ext2fs_get_next_inode_full()
658 if (scan->bytes_left) in ext2fs_get_next_inode_full()
659 memcpy(scan->temp_buffer, scan->ptr, scan->bytes_left); in ext2fs_get_next_inode_full()
660 extra_bytes = scan->bytes_left; in ext2fs_get_next_inode_full()
662 retval = get_next_blocks(scan); in ext2fs_get_next_inode_full()
670 if (is_empty_scan(scan)) in ext2fs_get_next_inode_full()
682 iblk = scan->current_inode % EXT2_INODES_PER_GROUP(scan->fs->super) / in ext2fs_get_next_inode_full()
683 EXT2_INODES_PER_BLOCK(scan->fs->super) % in ext2fs_get_next_inode_full()
684 scan->inode_buffer_blocks; in ext2fs_get_next_inode_full()
686 memcpy(scan->temp_buffer+extra_bytes, scan->ptr, in ext2fs_get_next_inode_full()
687 scan->inode_size - extra_bytes); in ext2fs_get_next_inode_full()
688 scan->ptr += scan->inode_size - extra_bytes; in ext2fs_get_next_inode_full()
689 scan->bytes_left -= scan->inode_size - extra_bytes; in ext2fs_get_next_inode_full()
693 !(scan->fs->flags & EXT2_FLAG_IGNORE_CSUM_ERRORS) && in ext2fs_get_next_inode_full()
694 !ext2fs_inode_csum_verify(scan->fs, scan->current_inode + 1, in ext2fs_get_next_inode_full()
695 (struct ext2_inode_large *)scan->temp_buffer)) in ext2fs_get_next_inode_full()
700 ext2fs_swap_inode_full(scan->fs, in ext2fs_get_next_inode_full()
702 (struct ext2_inode_large *) scan->temp_buffer, in ext2fs_get_next_inode_full()
705 memcpy(iptr, scan->temp_buffer, length); in ext2fs_get_next_inode_full()
707 if (scan->scan_flags & EXT2_SF_BAD_EXTRA_BYTES) in ext2fs_get_next_inode_full()
709 scan->scan_flags &= ~EXT2_SF_BAD_EXTRA_BYTES; in ext2fs_get_next_inode_full()
713 !(scan->fs->flags & EXT2_FLAG_IGNORE_CSUM_ERRORS) && in ext2fs_get_next_inode_full()
714 !ext2fs_inode_csum_verify(scan->fs, scan->current_inode + 1, in ext2fs_get_next_inode_full()
715 (struct ext2_inode_large *)scan->ptr)) in ext2fs_get_next_inode_full()
720 ext2fs_swap_inode_full(scan->fs, in ext2fs_get_next_inode_full()
722 (struct ext2_inode_large *) scan->ptr, in ext2fs_get_next_inode_full()
725 memcpy(iptr, scan->ptr, length); in ext2fs_get_next_inode_full()
727 scan->ptr += scan->inode_size; in ext2fs_get_next_inode_full()
728 scan->bytes_left -= scan->inode_size; in ext2fs_get_next_inode_full()
729 if (scan->scan_flags & EXT2_SF_BAD_INODE_BLK) in ext2fs_get_next_inode_full()
736 scan->inodes_left--; in ext2fs_get_next_inode_full()
737 scan->current_inode++; in ext2fs_get_next_inode_full()
738 *ino = scan->current_inode; in ext2fs_get_next_inode_full()
746 errcode_t ext2fs_get_next_inode(ext2_inode_scan scan, ext2_ino_t *ino, in ext2fs_get_next_inode() argument
749 return ext2fs_get_next_inode_full(scan, ino, inode, in ext2fs_get_next_inode()
768 int length = EXT2_INODE_SIZE(fs->super); in ext2fs_read_inode2()
774 if (ext2fs_has_feature_journal_dev(fs->super)) in ext2fs_read_inode2()
777 if (fs->blocksize < 1024) in ext2fs_read_inode2()
781 if (fs->read_inode && in ext2fs_read_inode2()
783 (EXT2_INODE_SIZE(fs->super) == sizeof(struct ext2_inode)))) { in ext2fs_read_inode2()
784 retval = (fs->read_inode)(fs, ino, inode); in ext2fs_read_inode2()
788 if ((ino == 0) || (ino > fs->super->s_inodes_count)) in ext2fs_read_inode2()
791 if (!fs->icache) { in ext2fs_read_inode2()
797 for (i = 0; i < fs->icache->cache_size; i++) { in ext2fs_read_inode2()
798 if (fs->icache->cache[i].ino == ino) { in ext2fs_read_inode2()
799 memcpy(inode, fs->icache->cache[i].inode, in ext2fs_read_inode2()
804 if (fs->flags & EXT2_FLAG_IMAGE_FILE) { in ext2fs_read_inode2()
805 inodes_per_block = fs->blocksize / EXT2_INODE_SIZE(fs->super); in ext2fs_read_inode2()
806 block_nr = ext2fs_le32_to_cpu(fs->image_header->offset_inode) / fs->blocksize; in ext2fs_read_inode2()
807 block_nr += (ino - 1) / inodes_per_block; in ext2fs_read_inode2()
808 offset = ((ino - 1) % inodes_per_block) * in ext2fs_read_inode2()
809 EXT2_INODE_SIZE(fs->super); in ext2fs_read_inode2()
810 io = fs->image_io; in ext2fs_read_inode2()
812 group = (ino - 1) / EXT2_INODES_PER_GROUP(fs->super); in ext2fs_read_inode2()
813 if (group > fs->group_desc_count) in ext2fs_read_inode2()
815 offset = ((ino - 1) % EXT2_INODES_PER_GROUP(fs->super)) * in ext2fs_read_inode2()
816 EXT2_INODE_SIZE(fs->super); in ext2fs_read_inode2()
817 block = offset >> EXT2_BLOCK_SIZE_BITS(fs->super); in ext2fs_read_inode2()
821 if ((block_nr < fs->super->s_first_data_block) || in ext2fs_read_inode2()
822 (block_nr + fs->inode_blocks_per_group - 1 >= in ext2fs_read_inode2()
823 ext2fs_blocks_count(fs->super))) in ext2fs_read_inode2()
826 io = fs->io; in ext2fs_read_inode2()
828 offset &= (EXT2_BLOCK_SIZE(fs->super) - 1); in ext2fs_read_inode2()
830 cache_slot = (fs->icache->cache_last + 1) % fs->icache->cache_size; in ext2fs_read_inode2()
831 iptr = (struct ext2_inode_large *)fs->icache->cache[cache_slot].inode; in ext2fs_read_inode2()
836 if ((offset + length) > fs->blocksize) in ext2fs_read_inode2()
837 clen = fs->blocksize - offset; in ext2fs_read_inode2()
839 if (block_nr != fs->icache->buffer_blk) { in ext2fs_read_inode2()
841 fs->icache->buffer); in ext2fs_read_inode2()
844 fs->icache->buffer_blk = block_nr; in ext2fs_read_inode2()
847 memcpy(ptr, ((char *) fs->icache->buffer) + (unsigned) offset, in ext2fs_read_inode2()
851 length -= clen; in ext2fs_read_inode2()
855 length = EXT2_INODE_SIZE(fs->super); in ext2fs_read_inode2()
868 fs->icache->cache_last = cache_slot; in ext2fs_read_inode2()
869 fs->icache->cache[cache_slot].ino = ino; in ext2fs_read_inode2()
873 if (!(fs->flags & EXT2_FLAG_IGNORE_CSUM_ERRORS) && in ext2fs_read_inode2()
905 int length = EXT2_INODE_SIZE(fs->super); in ext2fs_write_inode2()
909 if (ext2fs_has_feature_journal_dev(fs->super)) in ext2fs_write_inode2()
913 if (fs->write_inode) { in ext2fs_write_inode2()
914 retval = (fs->write_inode)(fs, ino, inode); in ext2fs_write_inode2()
919 if ((ino == 0) || (ino > fs->super->s_inodes_count)) in ext2fs_write_inode2()
936 if (fs->icache) { in ext2fs_write_inode2()
937 for (i=0; i < fs->icache->cache_size; i++) { in ext2fs_write_inode2()
938 if (fs->icache->cache[i].ino == ino) { in ext2fs_write_inode2()
939 memcpy(fs->icache->cache[i].inode, inode, in ext2fs_write_inode2()
951 if (!(fs->flags & EXT2_FLAG_RW)) { in ext2fs_write_inode2()
966 group = (ino - 1) / EXT2_INODES_PER_GROUP(fs->super); in ext2fs_write_inode2()
967 offset = ((ino - 1) % EXT2_INODES_PER_GROUP(fs->super)) * in ext2fs_write_inode2()
968 EXT2_INODE_SIZE(fs->super); in ext2fs_write_inode2()
969 block = offset >> EXT2_BLOCK_SIZE_BITS(fs->super); in ext2fs_write_inode2()
975 if ((block_nr < fs->super->s_first_data_block) || in ext2fs_write_inode2()
976 (block_nr + fs->inode_blocks_per_group - 1 >= in ext2fs_write_inode2()
977 ext2fs_blocks_count(fs->super))) { in ext2fs_write_inode2()
983 offset &= (EXT2_BLOCK_SIZE(fs->super) - 1); in ext2fs_write_inode2()
989 if ((offset + length) > fs->blocksize) in ext2fs_write_inode2()
990 clen = fs->blocksize - offset; in ext2fs_write_inode2()
992 if (fs->icache->buffer_blk != block_nr) { in ext2fs_write_inode2()
993 retval = io_channel_read_blk64(fs->io, block_nr, 1, in ext2fs_write_inode2()
994 fs->icache->buffer); in ext2fs_write_inode2()
997 fs->icache->buffer_blk = block_nr; in ext2fs_write_inode2()
1001 memcpy((char *) fs->icache->buffer + (unsigned) offset, in ext2fs_write_inode2()
1004 retval = io_channel_write_blk64(fs->io, block_nr, 1, in ext2fs_write_inode2()
1005 fs->icache->buffer); in ext2fs_write_inode2()
1011 length -= clen; in ext2fs_write_inode2()
1015 fs->flags |= EXT2_FLAG_CHANGED; in ext2fs_write_inode2()
1042 int size = EXT2_INODE_SIZE(fs->super); in ext2fs_write_new_inode()
1045 __u32 t = fs->now ? fs->now : time(NULL); in ext2fs_write_new_inode()
1047 if (!inode->i_ctime) in ext2fs_write_new_inode()
1048 inode->i_ctime = t; in ext2fs_write_new_inode()
1049 if (!inode->i_mtime) in ext2fs_write_new_inode()
1050 inode->i_mtime = t; in ext2fs_write_new_inode()
1051 if (!inode->i_atime) in ext2fs_write_new_inode()
1052 inode->i_atime = t; in ext2fs_write_new_inode()
1066 large_inode->i_extra_isize = sizeof(struct ext2_inode_large) - in ext2fs_write_new_inode()
1068 if (!large_inode->i_crtime) in ext2fs_write_new_inode()
1069 large_inode->i_crtime = t; in ext2fs_write_new_inode()
1085 if (ino > fs->super->s_inodes_count) in ext2fs_get_blocks()
1088 if (fs->get_blocks) { in ext2fs_get_blocks()
1089 if (!(*fs->get_blocks)(fs, ino, blocks)) in ext2fs_get_blocks()
1107 if (ino > fs->super->s_inodes_count) in ext2fs_check_directory()
1110 if (fs->check_directory) { in ext2fs_check_directory()
1111 retval = (fs->check_directory)(fs, ino); in ext2fs_check_directory()