Lines Matching refs:ni
85 int ntfs_map_runlist_nolock(struct ntfs_inode *ni, s64 vcn, struct ntfs_attr_search_ctx *ctx) in ntfs_map_runlist_nolock() argument
101 if (!NInoAttr(ni)) in ntfs_map_runlist_nolock()
102 base_ni = ni; in ntfs_map_runlist_nolock()
104 base_ni = ni->ext.base_ntfs_ino; in ntfs_map_runlist_nolock()
125 read_lock_irqsave(&ni->size_lock, flags); in ntfs_map_runlist_nolock()
127 ntfs_bytes_to_cluster(ni->vol, ni->allocated_size); in ntfs_map_runlist_nolock()
128 read_unlock_irqrestore(&ni->size_lock, flags); in ntfs_map_runlist_nolock()
138 if (vcn >= allocated_size_vcn || (a->type == ni->type && in ntfs_map_runlist_nolock()
139 a->name_length == ni->name_len && in ntfs_map_runlist_nolock()
141 ni->name, ni->name_len) && in ntfs_map_runlist_nolock()
170 err = ntfs_attr_lookup(ni->type, ni->name, ni->name_len, in ntfs_map_runlist_nolock()
191 rl = ntfs_mapping_pairs_decompress(ni->vol, a, &ni->runlist, &new_rl_count); in ntfs_map_runlist_nolock()
195 ni->runlist.rl = rl; in ntfs_map_runlist_nolock()
196 ni->runlist.count = new_rl_count; in ntfs_map_runlist_nolock()
300 int ntfs_map_runlist(struct ntfs_inode *ni, s64 vcn) in ntfs_map_runlist() argument
304 down_write(&ni->runlist.lock); in ntfs_map_runlist()
306 if (likely(ntfs_rl_vcn_to_lcn(ni->runlist.rl, vcn) <= in ntfs_map_runlist()
308 err = ntfs_map_runlist_nolock(ni, vcn, NULL); in ntfs_map_runlist()
309 up_write(&ni->runlist.lock); in ntfs_map_runlist()
313 struct runlist_element *ntfs_attr_vcn_to_rl(struct ntfs_inode *ni, s64 vcn, s64 *lcn) in ntfs_attr_vcn_to_rl() argument
315 struct runlist_element *rl = ni->runlist.rl; in ntfs_attr_vcn_to_rl()
320 err = ntfs_attr_map_whole_runlist(ni); in ntfs_attr_vcn_to_rl()
323 rl = ni->runlist.rl; in ntfs_attr_vcn_to_rl()
334 if (!ntfs_map_runlist_nolock(ni, vcn, NULL)) { in ntfs_attr_vcn_to_rl()
335 rl = ni->runlist.rl; in ntfs_attr_vcn_to_rl()
373 s64 ntfs_attr_vcn_to_lcn_nolock(struct ntfs_inode *ni, const s64 vcn, in ntfs_attr_vcn_to_lcn_nolock() argument
381 ni->mft_no, (unsigned long long)vcn, in ntfs_attr_vcn_to_lcn_nolock()
383 if (!ni->runlist.rl) { in ntfs_attr_vcn_to_lcn_nolock()
384 read_lock_irqsave(&ni->size_lock, flags); in ntfs_attr_vcn_to_lcn_nolock()
385 if (!ni->allocated_size) { in ntfs_attr_vcn_to_lcn_nolock()
386 read_unlock_irqrestore(&ni->size_lock, flags); in ntfs_attr_vcn_to_lcn_nolock()
389 read_unlock_irqrestore(&ni->size_lock, flags); in ntfs_attr_vcn_to_lcn_nolock()
393 lcn = ntfs_rl_vcn_to_lcn(ni->runlist.rl, vcn); in ntfs_attr_vcn_to_lcn_nolock()
405 up_read(&ni->runlist.lock); in ntfs_attr_vcn_to_lcn_nolock()
406 down_write(&ni->runlist.lock); in ntfs_attr_vcn_to_lcn_nolock()
407 if (unlikely(ntfs_rl_vcn_to_lcn(ni->runlist.rl, vcn) != in ntfs_attr_vcn_to_lcn_nolock()
409 up_write(&ni->runlist.lock); in ntfs_attr_vcn_to_lcn_nolock()
410 down_read(&ni->runlist.lock); in ntfs_attr_vcn_to_lcn_nolock()
414 err = ntfs_map_runlist_nolock(ni, vcn, NULL); in ntfs_attr_vcn_to_lcn_nolock()
416 up_write(&ni->runlist.lock); in ntfs_attr_vcn_to_lcn_nolock()
417 down_read(&ni->runlist.lock); in ntfs_attr_vcn_to_lcn_nolock()
431 ntfs_error(ni->vol->sb, "Failed with error code %lli.", in ntfs_attr_vcn_to_lcn_nolock()
523 struct runlist_element *ntfs_attr_find_vcn_nolock(struct ntfs_inode *ni, const s64 vcn, in ntfs_attr_find_vcn_nolock() argument
532 ni->mft_no, (unsigned long long)vcn, ctx ? "" : "out"); in ntfs_attr_find_vcn_nolock()
533 if (!ni->runlist.rl) { in ntfs_attr_find_vcn_nolock()
534 read_lock_irqsave(&ni->size_lock, flags); in ntfs_attr_find_vcn_nolock()
535 if (!ni->allocated_size) { in ntfs_attr_find_vcn_nolock()
536 read_unlock_irqrestore(&ni->size_lock, flags); in ntfs_attr_find_vcn_nolock()
539 read_unlock_irqrestore(&ni->size_lock, flags); in ntfs_attr_find_vcn_nolock()
543 rl = ni->runlist.rl; in ntfs_attr_find_vcn_nolock()
545 rl = __ntfs_attr_find_vcn_nolock(&ni->runlist, vcn); in ntfs_attr_find_vcn_nolock()
565 err = ntfs_map_runlist_nolock(ni, vcn, ctx); in ntfs_attr_find_vcn_nolock()
576 ntfs_error(ni->vol->sb, "Failed with error code %i.", err); in ntfs_attr_find_vcn_nolock()
947 struct ntfs_inode *base_ni = ctx->base_ntfs_ino, *ni = ctx->ntfs_ino; in ntfs_external_attr_find() local
959 ntfs_debug("Entering for inode 0x%llx, type 0x%x.", ni->mft_no, type); in ntfs_external_attr_find()
966 if (ni == base_ni) in ntfs_external_attr_find()
1156 if (MREF_LE(al_entry->mft_reference) == ni->mft_no) { in ntfs_external_attr_find()
1157 if (MSEQNO_LE(al_entry->mft_reference) != ni->seq_no) { in ntfs_external_attr_find()
1166 if (ni != base_ni) in ntfs_external_attr_find()
1167 unmap_extent_mft_record(ni); in ntfs_external_attr_find()
1171 ni = ctx->ntfs_ino = base_ni; in ntfs_external_attr_find()
1178 al_entry->mft_reference), &ni); in ntfs_external_attr_find()
1188 ni = NULL; in ntfs_external_attr_find()
1191 ctx->ntfs_ino = ni; in ntfs_external_attr_find()
1309 if (ni != base_ni) { in ntfs_external_attr_find()
1310 if (ni) in ntfs_external_attr_find()
1311 unmap_extent_mft_record(ni); in ntfs_external_attr_find()
1355 if (ni != base_ni) in ntfs_external_attr_find()
1356 unmap_extent_mft_record(ni); in ntfs_external_attr_find()
1446 struct ntfs_inode *ni, struct mft_record *mrec) in ntfs_attr_init_search_ctx() argument
1449 mrec = map_mft_record(ni); in ntfs_attr_init_search_ctx()
1461 ctx->ntfs_ino = ni; in ntfs_attr_init_search_ctx()
1513 struct ntfs_attr_search_ctx *ntfs_attr_get_search_ctx(struct ntfs_inode *ni, in ntfs_attr_get_search_ctx() argument
1521 init = ntfs_attr_init_search_ctx(ctx, ni, mrec); in ntfs_attr_get_search_ctx()
1763 int ntfs_attr_make_non_resident(struct ntfs_inode *ni, const u32 data_size) in ntfs_attr_make_non_resident() argument
1766 struct inode *vi = VFS_I(ni); in ntfs_attr_make_non_resident()
1767 struct ntfs_volume *vol = ni->vol; in ntfs_attr_make_non_resident()
1779 if (NInoNonResident(ni)) { in ntfs_attr_make_non_resident()
1786 err = ntfs_attr_can_be_non_resident(vol, ni->type); in ntfs_attr_make_non_resident()
1795 if (NInoEncrypted(ni)) in ntfs_attr_make_non_resident()
1798 if (!NInoAttr(ni)) in ntfs_attr_make_non_resident()
1799 base_ni = ni; in ntfs_attr_make_non_resident()
1801 base_ni = ni->ext.base_ntfs_ino; in ntfs_attr_make_non_resident()
1814 err = ntfs_attr_lookup(ni->type, ni->name, ni->name_len, in ntfs_attr_make_non_resident()
1867 down_write(&ni->runlist.lock); in ntfs_attr_make_non_resident()
1876 if (NInoNonResident(ni) || a->non_resident) { in ntfs_attr_make_non_resident()
1884 if (NInoSparse(ni) || NInoCompressed(ni)) in ntfs_attr_make_non_resident()
1939 if (NInoSparse(ni) || NInoCompressed(ni)) { in ntfs_attr_make_non_resident()
1941 if (NInoCompressed(ni) || vol->major_ver < 3) in ntfs_attr_make_non_resident()
1957 ni->runlist.rl = rl; in ntfs_attr_make_non_resident()
1959 for (ni->runlist.count = 1; rl->length != 0; rl++) in ntfs_attr_make_non_resident()
1960 ni->runlist.count++; in ntfs_attr_make_non_resident()
1962 ni->runlist.count = 0; in ntfs_attr_make_non_resident()
1963 write_lock_irqsave(&ni->size_lock, flags); in ntfs_attr_make_non_resident()
1964 ni->allocated_size = new_size; in ntfs_attr_make_non_resident()
1965 if (NInoSparse(ni) || NInoCompressed(ni)) { in ntfs_attr_make_non_resident()
1966 ni->itype.compressed.size = ni->allocated_size; in ntfs_attr_make_non_resident()
1968 ni->itype.compressed.block_size = 1U << in ntfs_attr_make_non_resident()
1971 ni->itype.compressed.block_size_bits = in ntfs_attr_make_non_resident()
1972 ffs(ni->itype.compressed.block_size) - in ntfs_attr_make_non_resident()
1974 ni->itype.compressed.block_clusters = 1U << in ntfs_attr_make_non_resident()
1977 ni->itype.compressed.block_size = 0; in ntfs_attr_make_non_resident()
1978 ni->itype.compressed.block_size_bits = 0; in ntfs_attr_make_non_resident()
1979 ni->itype.compressed.block_clusters = 0; in ntfs_attr_make_non_resident()
1981 vi->i_blocks = ni->itype.compressed.size >> 9; in ntfs_attr_make_non_resident()
1983 vi->i_blocks = ni->allocated_size >> 9; in ntfs_attr_make_non_resident()
1984 write_unlock_irqrestore(&ni->size_lock, flags); in ntfs_attr_make_non_resident()
1991 NInoSetNonResident(ni); in ntfs_attr_make_non_resident()
1992 NInoSetFullyMapped(ni); in ntfs_attr_make_non_resident()
1997 up_write(&ni->runlist.lock); in ntfs_attr_make_non_resident()
2032 ni->mft_no, in ntfs_attr_make_non_resident()
2033 (unsigned int)le32_to_cpu(ni->type), in ntfs_attr_make_non_resident()
2035 ((ni->type == AT_DATA) && in ntfs_attr_make_non_resident()
2036 !ni->name_len) ? "FILE" : "ATTRIBUTE"); in ntfs_attr_make_non_resident()
2037 write_lock_irqsave(&ni->size_lock, flags); in ntfs_attr_make_non_resident()
2038 ni->initialized_size = attr_size; in ntfs_attr_make_non_resident()
2040 write_unlock_irqrestore(&ni->size_lock, flags); in ntfs_attr_make_non_resident()
2053 write_lock_irqsave(&ni->size_lock, flags); in ntfs_attr_make_non_resident()
2054 ni->allocated_size = arec_size - mp_ofs; in ntfs_attr_make_non_resident()
2055 write_unlock_irqrestore(&ni->size_lock, flags); in ntfs_attr_make_non_resident()
2059 up_write(&ni->runlist.lock); in ntfs_attr_make_non_resident()
2076 ni->runlist.rl = NULL; in ntfs_attr_make_non_resident()
2099 int ntfs_attr_set(struct ntfs_inode *ni, s64 ofs, s64 cnt, const u8 val) in ntfs_attr_set() argument
2101 struct address_space *mapping = VFS_I(ni)->i_mapping; in ntfs_attr_set()
2114 ntfs_error(VFS_I(ni)->i_sb, "Failed to read a page %lu for attr %#x: %ld", in ntfs_attr_set()
2115 index, ni->type, PTR_ERR(folio)); in ntfs_attr_set()
2140 int ntfs_attr_set_initialized_size(struct ntfs_inode *ni, loff_t new_size) in ntfs_attr_set_initialized_size() argument
2145 if (!NInoNonResident(ni)) in ntfs_attr_set_initialized_size()
2148 ctx = ntfs_attr_get_search_ctx(ni, NULL); in ntfs_attr_set_initialized_size()
2152 err = ntfs_attr_lookup(ni->type, ni->name, ni->name_len, in ntfs_attr_set_initialized_size()
2158 ni->initialized_size = new_size; in ntfs_attr_set_initialized_size()
2220 int ntfs_resident_attr_record_add(struct ntfs_inode *ni, __le32 type, in ntfs_resident_attr_record_add() argument
2231 if (!ni || (!name && name_len)) in ntfs_resident_attr_record_add()
2235 (long long) ni->mft_no, (unsigned int) le32_to_cpu(type), in ntfs_resident_attr_record_add()
2238 err = ntfs_attr_can_be_resident(ni->vol, type); in ntfs_resident_attr_record_add()
2248 ctx = ntfs_attr_get_search_ctx(ni, NULL); in ntfs_resident_attr_record_add()
2250 ntfs_error(ni->vol->sb, "%s: Failed to get search context", in ntfs_resident_attr_record_add()
2310 if (ni->nr_extents == -1) in ntfs_resident_attr_record_add()
2311 base_ni = ni->ext.base_ntfs_ino; in ntfs_resident_attr_record_add()
2313 base_ni = ni; in ntfs_resident_attr_record_add()
2315 err = ntfs_attrlist_entry_add(ni, a); in ntfs_resident_attr_record_add()
2323 mark_mft_record_dirty(ni); in ntfs_resident_attr_record_add()
2341 static int ntfs_non_resident_attr_record_add(struct ntfs_inode *ni, __le32 type, in ntfs_non_resident_attr_record_add() argument
2352 if (!ni || dataruns_size <= 0 || (!name && name_len)) in ntfs_non_resident_attr_record_add()
2356 (long long) ni->mft_no, (unsigned int) le32_to_cpu(type), in ntfs_non_resident_attr_record_add()
2360 err = ntfs_attr_can_be_non_resident(ni->vol, type); in ntfs_non_resident_attr_record_add()
2370 ctx = ntfs_attr_get_search_ctx(ni, NULL); in ntfs_non_resident_attr_record_add()
2435 if (ni->nr_extents == -1) in ntfs_non_resident_attr_record_add()
2436 base_ni = ni->ext.base_ntfs_ino; in ntfs_non_resident_attr_record_add()
2438 base_ni = ni; in ntfs_non_resident_attr_record_add()
2440 err = ntfs_attrlist_entry_add(ni, a); in ntfs_non_resident_attr_record_add()
2447 mark_mft_record_dirty(ni); in ntfs_non_resident_attr_record_add()
2479 struct ntfs_inode *base_ni, *ni; in ntfs_attr_record_rm() local
2490 ni = ctx->ntfs_ino; in ntfs_attr_record_rm()
2501 mark_mft_record_dirty(ni); in ntfs_attr_record_rm()
2526 if (ntfs_mft_record_free(ni->vol, ni)) { in ntfs_attr_record_rm()
2531 if (ni == base_ni) in ntfs_attr_record_rm()
2533 ntfs_inode_close(ni); in ntfs_attr_record_rm()
2534 ctx->ntfs_ino = ni = NULL; in ntfs_attr_record_rm()
2614 int ntfs_attr_add(struct ntfs_inode *ni, __le32 type, in ntfs_attr_add() argument
2626 if (!ni || size < 0 || type == AT_ATTRIBUTE_LIST) in ntfs_attr_add()
2630 (long long) ni->mft_no, type, size); in ntfs_attr_add()
2632 if (ni->nr_extents == -1) in ntfs_attr_add()
2633 ni = ni->ext.base_ntfs_ino; in ntfs_attr_add()
2636 err = ntfs_attr_size_bounds_check(ni->vol, type, size); in ntfs_attr_add()
2643 sb = ni->vol->sb; in ntfs_attr_add()
2645 err = ntfs_attr_can_be_non_resident(ni->vol, type); in ntfs_attr_add()
2657 if (size > ni->vol->mft_record_size) { in ntfs_attr_add()
2668 err = ntfs_attr_can_be_resident(ni->vol, type); in ntfs_attr_add()
2694 ni_mrec = map_mft_record(ni); in ntfs_attr_add()
2702 attr_ni = ni; in ntfs_attr_add()
2703 unmap_mft_record(ni); in ntfs_attr_add()
2706 unmap_mft_record(ni); in ntfs_attr_add()
2709 err = ntfs_inode_attach_all_extents(ni); in ntfs_attr_add()
2715 for (i = 0; i < ni->nr_extents; i++) { in ntfs_attr_add()
2716 attr_ni = ni->ext.extent_ntfs_inos[i]; in ntfs_attr_add()
2733 if (!NInoAttrList(ni)) { in ntfs_attr_add()
2735 err = ntfs_inode_add_attrlist(ni); in ntfs_attr_add()
2745 err = ntfs_mft_record_alloc(ni->vol, 0, &attr_ni, ni, NULL); in ntfs_attr_add()
2782 attr_vi = ntfs_attr_iget(VFS_I(ni), type, name, name_len); in ntfs_attr_add()
2846 static void __ntfs_attr_init(struct ntfs_inode *ni, in __ntfs_attr_init() argument
2849 ni->runlist.rl = NULL; in __ntfs_attr_init()
2850 ni->type = type; in __ntfs_attr_init()
2851 ni->name = name; in __ntfs_attr_init()
2853 ni->name_len = name_len; in __ntfs_attr_init()
2855 ni->name_len = 0; in __ntfs_attr_init()
2873 static void ntfs_attr_init(struct ntfs_inode *ni, const bool non_resident, in ntfs_attr_init() argument
2880 NInoSetNonResident(ni); in ntfs_attr_init()
2882 NInoSetCompressed(ni); in ntfs_attr_init()
2883 ni->flags |= FILE_ATTR_COMPRESSED; in ntfs_attr_init()
2886 NInoSetEncrypted(ni); in ntfs_attr_init()
2887 ni->flags |= FILE_ATTR_ENCRYPTED; in ntfs_attr_init()
2890 NInoSetSparse(ni); in ntfs_attr_init()
2891 ni->flags |= FILE_ATTR_SPARSE_FILE; in ntfs_attr_init()
2893 ni->allocated_size = allocated_size; in ntfs_attr_init()
2894 ni->data_size = data_size; in ntfs_attr_init()
2895 ni->initialized_size = initialized_size; in ntfs_attr_init()
2897 struct ntfs_volume *vol = ni->vol; in ntfs_attr_init()
2899 ni->itype.compressed.size = compressed_size; in ntfs_attr_init()
2900 ni->itype.compressed.block_clusters = 1 << compression_unit; in ntfs_attr_init()
2901 ni->itype.compressed.block_size = 1 << (compression_unit + in ntfs_attr_init()
2903 ni->itype.compressed.block_size_bits = ffs( in ntfs_attr_init()
2904 ni->itype.compressed.block_size) - 1; in ntfs_attr_init()
2915 int ntfs_attr_open(struct ntfs_inode *ni, const __le32 type, in ntfs_attr_open() argument
2925 if (!ni || !ni->vol) in ntfs_attr_open()
2929 ni->mft_no, type); in ntfs_attr_open()
2931 if (NInoAttr(ni)) in ntfs_attr_open()
2932 base_ni = ni->ext.base_ntfs_ino; in ntfs_attr_open()
2934 base_ni = ni; in ntfs_attr_open()
2972 __ntfs_attr_init(ni, type, name, name_len); in ntfs_attr_open()
2997 if (NInoCompressed(ni) in ntfs_attr_open()
2998 && (ni->vol->major_ver >= 3) in ntfs_attr_open()
2999 && NVolCompression(ni->vol) in ntfs_attr_open()
3000 && (ni->vol->cluster_size <= MAX_COMPRESSION_CLUSTER_SIZE)) in ntfs_attr_open()
3006 if (ni->type == AT_DATA && ni->name == AT_UNNAMED && in ntfs_attr_open()
3007 ((!(a->flags & ATTR_IS_COMPRESSED) != !NInoCompressed(ni)) || in ntfs_attr_open()
3008 (!(a->flags & ATTR_IS_SPARSE) != !NInoSparse(ni)) || in ntfs_attr_open()
3009 (!(a->flags & ATTR_IS_ENCRYPTED) != !NInoEncrypted(ni)))) { in ntfs_attr_open()
3012 (unsigned long long)ni->mft_no, in ntfs_attr_open()
3013 a->flags, ni->flags); in ntfs_attr_open()
3019 (ni->vol->major_ver < 3)) { in ntfs_attr_open()
3022 (unsigned long long)ni->mft_no, in ntfs_attr_open()
3023 ni->vol->major_ver, in ntfs_attr_open()
3024 ni->vol->major_ver); in ntfs_attr_open()
3031 (unsigned long long)ni->mft_no, type); in ntfs_attr_open()
3038 (unsigned long long)ni->mft_no, in ntfs_attr_open()
3043 ntfs_attr_init(ni, true, a->flags & ATTR_IS_COMPRESSED, in ntfs_attr_open()
3054 ntfs_attr_init(ni, false, a->flags & ATTR_IS_COMPRESSED, in ntfs_attr_open()
3078 void ntfs_attr_close(struct ntfs_inode *ni) in ntfs_attr_close() argument
3080 if (NInoNonResident(ni) && ni->runlist.rl) in ntfs_attr_close()
3081 kvfree(ni->runlist.rl); in ntfs_attr_close()
3083 if (ni->name != AT_UNNAMED && ni->name != I30) in ntfs_attr_close()
3084 kfree(ni->name); in ntfs_attr_close()
3097 int ntfs_attr_map_whole_runlist(struct ntfs_inode *ni) in ntfs_attr_map_whole_runlist() argument
3101 struct ntfs_volume *vol = ni->vol; in ntfs_attr_map_whole_runlist()
3110 (unsigned long long)ni->mft_no, ni->type); in ntfs_attr_map_whole_runlist()
3112 if (NInoFullyMapped(ni) && ni->runlist.rl) in ntfs_attr_map_whole_runlist()
3115 if (NInoAttr(ni)) in ntfs_attr_map_whole_runlist()
3116 base_ni = ni->ext.base_ntfs_ino; in ntfs_attr_map_whole_runlist()
3118 base_ni = ni; in ntfs_attr_map_whole_runlist()
3133 if (ntfs_rl_vcn_to_lcn(ni->runlist.rl, next_vcn) == LCN_RL_NOT_MAPPED) in ntfs_attr_map_whole_runlist()
3136 err = ntfs_attr_lookup(ni->type, ni->name, ni->name_len, in ntfs_attr_map_whole_runlist()
3145 rl = ntfs_mapping_pairs_decompress(ni->vol, a, &ni->runlist, in ntfs_attr_map_whole_runlist()
3151 ni->runlist.rl = rl; in ntfs_attr_map_whole_runlist()
3152 ni->runlist.count = new_rl_count; in ntfs_attr_map_whole_runlist()
3161 (unsigned long long)ni->mft_no); in ntfs_attr_map_whole_runlist()
3183 (unsigned long long)ni->mft_no); in ntfs_attr_map_whole_runlist()
3195 (unsigned long long)ni->mft_no, in ntfs_attr_map_whole_runlist()
3201 NInoSetFullyMapped(ni); in ntfs_attr_map_whole_runlist()
3217 int ntfs_attr_record_move_to(struct ntfs_attr_search_ctx *ctx, struct ntfs_inode *ni) in ntfs_attr_record_move_to() argument
3225 if (!ctx || !ctx->attr || !ctx->ntfs_ino || !ni) { in ntfs_attr_record_move_to()
3230 sb = ni->vol->sb; in ntfs_attr_record_move_to()
3234 (long long) ni->mft_no); in ntfs_attr_record_move_to()
3236 if (ctx->ntfs_ino == ni) in ntfs_attr_record_move_to()
3246 nctx = ntfs_attr_get_search_ctx(ni, NULL); in ntfs_attr_record_move_to()
3271 ni_mrec = map_mft_record(ni); in ntfs_attr_record_move_to()
3281 unmap_mft_record(ni); in ntfs_attr_record_move_to()
3290 mark_mft_record_dirty(ni); in ntfs_attr_record_move_to()
3294 MK_LE_MREF(ni->mft_no, le16_to_cpu(ni_mrec->sequence_number)); in ntfs_attr_record_move_to()
3296 unmap_mft_record(ni); in ntfs_attr_record_move_to()
3309 struct ntfs_inode *base_ni, *ni = NULL; in ntfs_attr_record_move_away() local
3343 ni = base_ni->ext.extent_ntfs_inos[i]; in ntfs_attr_record_move_away()
3345 if (ctx->ntfs_ino->mft_no == ni->mft_no) in ntfs_attr_record_move_away()
3347 m = map_mft_record(ni); in ntfs_attr_record_move_away()
3350 (unsigned long long)ni->mft_no); in ntfs_attr_record_move_away()
3356 unmap_mft_record(ni); in ntfs_attr_record_move_away()
3359 unmap_mft_record(ni); in ntfs_attr_record_move_away()
3366 if (!ntfs_attr_record_move_to(ctx, ni)) { in ntfs_attr_record_move_away()
3377 ni = NULL; in ntfs_attr_record_move_away()
3378 err = ntfs_mft_record_alloc(base_ni->vol, 0, &ni, base_ni, NULL); in ntfs_attr_record_move_away()
3383 unmap_mft_record(ni); in ntfs_attr_record_move_away()
3385 err = ntfs_attr_record_move_to(ctx, ni); in ntfs_attr_record_move_away()
3396 static int ntfs_attr_update_meta(struct attr_record *a, struct ntfs_inode *ni, in ntfs_attr_update_meta() argument
3401 struct super_block *sb = ni->vol->sb; in ntfs_attr_update_meta()
3404 (unsigned long long)ni->mft_no, ni->type); in ntfs_attr_update_meta()
3406 if (NInoAttr(ni)) in ntfs_attr_update_meta()
3407 base_ni = ni->ext.base_ntfs_ino; in ntfs_attr_update_meta()
3409 base_ni = ni; in ntfs_attr_update_meta()
3414 a->data.non_resident.allocated_size = cpu_to_le64(ni->allocated_size); in ntfs_attr_update_meta()
3416 sparse = ntfs_rl_sparse(ni->runlist.rl); in ntfs_attr_update_meta()
3459 NInoSetSparse(ni); in ntfs_attr_update_meta()
3460 ni->flags |= FILE_ATTR_SPARSE_FILE; in ntfs_attr_update_meta()
3477 NInoClearSparse(ni); in ntfs_attr_update_meta()
3478 ni->flags &= ~FILE_ATTR_SPARSE_FILE; in ntfs_attr_update_meta()
3494 if (NInoFullyMapped(ni) && (sparse || NInoCompressed(ni))) { in ntfs_attr_update_meta()
3497 new_compr_size = ntfs_rl_get_compressed_size(ni->vol, ni->runlist.rl); in ntfs_attr_update_meta()
3503 ni->itype.compressed.size = new_compr_size; in ntfs_attr_update_meta()
3507 if (NInoSparse(ni) || NInoCompressed(ni)) in ntfs_attr_update_meta()
3508 VFS_I(base_ni)->i_blocks = ni->itype.compressed.size >> 9; in ntfs_attr_update_meta()
3510 VFS_I(base_ni)->i_blocks = ni->allocated_size >> 9; in ntfs_attr_update_meta()
3515 if (ni->type == AT_DATA && ni->name == AT_UNNAMED) in ntfs_attr_update_meta()
3516 NInoSetFileNameDirty(ni); in ntfs_attr_update_meta()
3535 int ntfs_attr_update_mapping_pairs(struct ntfs_inode *ni, s64 from_vcn) in ntfs_attr_update_mapping_pairs() argument
3550 if (!ni || !ni->runlist.rl) in ntfs_attr_update_mapping_pairs()
3554 (unsigned long long)ni->mft_no, ni->type); in ntfs_attr_update_mapping_pairs()
3556 sb = ni->vol->sb; in ntfs_attr_update_mapping_pairs()
3557 if (!NInoNonResident(ni)) { in ntfs_attr_update_mapping_pairs()
3562 if (ni->nr_extents == -1) in ntfs_attr_update_mapping_pairs()
3563 base_ni = ni->ext.base_ntfs_ino; in ntfs_attr_update_mapping_pairs()
3565 base_ni = ni; in ntfs_attr_update_mapping_pairs()
3576 start_rl = ni->runlist.rl; in ntfs_attr_update_mapping_pairs()
3577 while (!(err = ntfs_attr_lookup(ni->type, ni->name, ni->name_len, in ntfs_attr_update_mapping_pairs()
3602 first_lcn = ntfs_rl_vcn_to_lcn(ni->runlist.rl, stop_vcn); in ntfs_attr_update_mapping_pairs()
3627 err = ntfs_attr_update_meta(a, ni, m, ctx); in ntfs_attr_update_mapping_pairs()
3651 mp_size = ntfs_get_size_for_mapping_pairs(ni->vol, start_rl, in ntfs_attr_update_mapping_pairs()
3665 if (ni->type == AT_ATTRIBUTE_LIST) { in ntfs_attr_update_mapping_pairs()
3721 err = ntfs_mapping_pairs_build(ni->vol, in ntfs_attr_update_mapping_pairs()
3747 err = ntfs_attr_lookup(ni->type, ni->name, ni->name_len, in ntfs_attr_update_mapping_pairs()
3751 a->data.non_resident.allocated_size = cpu_to_le64(ni->allocated_size); in ntfs_attr_update_mapping_pairs()
3752 if (NInoCompressed(ni) || NInoSparse(ni)) in ntfs_attr_update_mapping_pairs()
3754 cpu_to_le64(ni->itype.compressed.size); in ntfs_attr_update_mapping_pairs()
3756 if (ni->type == AT_DATA && ni->name == AT_UNNAMED) in ntfs_attr_update_mapping_pairs()
3757 NInoSetFileNameDirty(ni); in ntfs_attr_update_mapping_pairs()
3769 while (!(err = ntfs_attr_lookup(ni->type, ni->name, ni->name_len, in ntfs_attr_update_mapping_pairs()
3799 err = ntfs_mft_record_alloc(ni->vol, 0, &ext_ni, base_ni, NULL); in ntfs_attr_update_mapping_pairs()
3809 if (ntfs_mft_record_free(ni->vol, ext_ni)) in ntfs_attr_update_mapping_pairs()
3823 ((NInoCompressed(ni) || NInoSparse(ni)) ? in ntfs_attr_update_mapping_pairs()
3825 ((sizeof(__le16) * ni->name_len + 7) & ~7); in ntfs_attr_update_mapping_pairs()
3828 mp_size = ntfs_get_size_for_mapping_pairs(ni->vol, in ntfs_attr_update_mapping_pairs()
3841 err = ntfs_non_resident_attr_record_add(ext_ni, ni->type, in ntfs_attr_update_mapping_pairs()
3842 ni->name, ni->name_len, stop_vcn, mp_size, 0); in ntfs_attr_update_mapping_pairs()
3846 if (ntfs_mft_record_free(ni->vol, ext_ni)) in ntfs_attr_update_mapping_pairs()
3853 err = ntfs_mapping_pairs_build(ni->vol, (u8 *)a + in ntfs_attr_update_mapping_pairs()
3860 if (ntfs_mft_record_free(ni->vol, ext_ni)) in ntfs_attr_update_mapping_pairs()
3875 ni->i_dealloc_clusters = de_cluster_count; in ntfs_attr_update_mapping_pairs()
3891 static int ntfs_attr_make_resident(struct ntfs_inode *ni, struct ntfs_attr_search_ctx *ctx) in ntfs_attr_make_resident() argument
3893 struct ntfs_volume *vol = ni->vol; in ntfs_attr_make_resident()
3900 (unsigned long long)ni->mft_no, ni->type); in ntfs_attr_make_resident()
3909 if (!NInoNonResident(ni)) { in ntfs_attr_make_resident()
3915 if (ni->type == AT_BITMAP && ni->mft_no == FILE_MFT) in ntfs_attr_make_resident()
3919 err = ntfs_attr_can_be_resident(vol, ni->type); in ntfs_attr_make_resident()
3923 if (NInoCompressed(ni) || NInoEncrypted(ni)) { in ntfs_attr_make_resident()
3931 arec_size = (val_ofs + ni->data_size + 7) & ~7; in ntfs_attr_make_resident()
3941 err = ntfs_attr_map_whole_runlist(ni); in ntfs_attr_make_resident()
3965 a->data.resident.value_length = cpu_to_le32(ni->data_size); in ntfs_attr_make_resident()
3985 err = ntfs_cluster_free(ni, 0, -1, ctx); in ntfs_attr_make_resident()
3992 kvfree(ni->runlist.rl); in ntfs_attr_make_resident()
3993 ni->runlist.rl = NULL; in ntfs_attr_make_resident()
3994 ni->runlist.count = 0; in ntfs_attr_make_resident()
3996 NInoClearNonResident(ni); in ntfs_attr_make_resident()
3997 NInoClearCompressed(ni); in ntfs_attr_make_resident()
3998 ni->flags &= ~FILE_ATTR_COMPRESSED; in ntfs_attr_make_resident()
3999 NInoClearSparse(ni); in ntfs_attr_make_resident()
4000 ni->flags &= ~FILE_ATTR_SPARSE_FILE; in ntfs_attr_make_resident()
4001 NInoClearEncrypted(ni); in ntfs_attr_make_resident()
4002 ni->flags &= ~FILE_ATTR_ENCRYPTED; in ntfs_attr_make_resident()
4003 ni->initialized_size = ni->data_size; in ntfs_attr_make_resident()
4004 ni->allocated_size = ni->itype.compressed.size = (ni->data_size + 7) & ~7; in ntfs_attr_make_resident()
4005 ni->itype.compressed.block_size = 0; in ntfs_attr_make_resident()
4006 ni->itype.compressed.block_size_bits = ni->itype.compressed.block_clusters = 0; in ntfs_attr_make_resident()
4017 static int ntfs_non_resident_attr_shrink(struct ntfs_inode *ni, const s64 newsize) in ntfs_non_resident_attr_shrink() argument
4027 (unsigned long long)ni->mft_no, ni->type, (long long)newsize); in ntfs_non_resident_attr_shrink()
4029 vol = ni->vol; in ntfs_non_resident_attr_shrink()
4031 if (NInoAttr(ni)) in ntfs_non_resident_attr_shrink()
4032 base_ni = ni->ext.base_ntfs_ino; in ntfs_non_resident_attr_shrink()
4034 base_ni = ni; in ntfs_non_resident_attr_shrink()
4040 err = ntfs_attr_size_bounds_check(vol, ni->type, newsize); in ntfs_non_resident_attr_shrink()
4050 if (NInoCompressed(ni)) in ntfs_non_resident_attr_shrink()
4058 ((newsize - 1) | (ni->itype.compressed.block_size - 1)) + 1); in ntfs_non_resident_attr_shrink()
4069 if (ntfs_bytes_to_cluster(vol, ni->allocated_size) != first_free_vcn) { in ntfs_non_resident_attr_shrink()
4072 err = ntfs_attr_map_whole_runlist(ni); in ntfs_non_resident_attr_shrink()
4078 ctx = ntfs_attr_get_search_ctx(ni, NULL); in ntfs_non_resident_attr_shrink()
4085 nr_freed_clusters = ntfs_cluster_free(ni, first_free_vcn, -1, ctx); in ntfs_non_resident_attr_shrink()
4094 if (ntfs_rl_truncate_nolock(vol, &ni->runlist, first_free_vcn)) { in ntfs_non_resident_attr_shrink()
4099 kvfree(ni->runlist.rl); in ntfs_non_resident_attr_shrink()
4100 ni->runlist.rl = NULL; in ntfs_non_resident_attr_shrink()
4106 ni->allocated_size = ntfs_cluster_to_bytes(vol, first_free_vcn); in ntfs_non_resident_attr_shrink()
4108 if (NInoSparse(ni) || NInoCompressed(ni)) { in ntfs_non_resident_attr_shrink()
4110 ni->itype.compressed.size -= in ntfs_non_resident_attr_shrink()
4112 VFS_I(base_ni)->i_blocks = ni->itype.compressed.size >> 9; in ntfs_non_resident_attr_shrink()
4115 VFS_I(base_ni)->i_blocks = ni->allocated_size >> 9; in ntfs_non_resident_attr_shrink()
4118 err = ntfs_attr_update_mapping_pairs(ni, 0 /*first_free_vcn*/); in ntfs_non_resident_attr_shrink()
4132 err = ntfs_attr_lookup(ni->type, ni->name, ni->name_len, CASE_SENSITIVE, in ntfs_non_resident_attr_shrink()
4142 ni->data_size = newsize; in ntfs_non_resident_attr_shrink()
4144 if (newsize < ni->initialized_size) { in ntfs_non_resident_attr_shrink()
4145 ni->initialized_size = newsize; in ntfs_non_resident_attr_shrink()
4149 if (ni->type == AT_DATA && ni->name == AT_UNNAMED) in ntfs_non_resident_attr_shrink()
4150 NInoSetFileNameDirty(ni); in ntfs_non_resident_attr_shrink()
4153 if (!newsize && !NInoEncrypted(ni) && !NInoCompressed(ni)) { in ntfs_non_resident_attr_shrink()
4154 err = ntfs_attr_make_resident(ni, ctx); in ntfs_non_resident_attr_shrink()
4158 ntfs_error(ni->vol->sb, in ntfs_non_resident_attr_shrink()
4184 static int ntfs_non_resident_attr_expand(struct ntfs_inode *ni, const s64 newsize, in ntfs_non_resident_attr_expand() argument
4195 struct super_block *sb = ni->vol->sb; in ntfs_non_resident_attr_expand()
4199 (unsigned long long)ni->mft_no, ni->type, in ntfs_non_resident_attr_expand()
4200 (long long)newsize, (long long)ni->data_size); in ntfs_non_resident_attr_expand()
4202 vol = ni->vol; in ntfs_non_resident_attr_expand()
4204 if (NInoAttr(ni)) in ntfs_non_resident_attr_expand()
4205 base_ni = ni->ext.base_ntfs_ino; in ntfs_non_resident_attr_expand()
4207 base_ni = ni; in ntfs_non_resident_attr_expand()
4213 err = ntfs_attr_size_bounds_check(vol, ni->type, newsize); in ntfs_non_resident_attr_expand()
4220 org_alloc_size = ni->allocated_size; in ntfs_non_resident_attr_expand()
4221 org_compressed_size = ni->itype.compressed.size; in ntfs_non_resident_attr_expand()
4237 if (ntfs_bytes_to_cluster(vol, ni->allocated_size) < first_free_vcn) { in ntfs_non_resident_attr_expand()
4238 err = ntfs_attr_map_whole_runlist(ni); in ntfs_non_resident_attr_expand()
4248 if ((ni->type == AT_DATA && (vol->major_ver >= 3 || !NInoSparseDisabled(ni))) && in ntfs_non_resident_attr_expand()
4250 if (NInoCompressed(ni)) { in ntfs_non_resident_attr_expand()
4254 ntfs_bytes_to_cluster(vol, ni->allocated_size), in ntfs_non_resident_attr_expand()
4255 ni->itype.compressed.block_clusters); in ntfs_non_resident_attr_expand()
4257 do_div(more_entries, ni->itype.compressed.block_clusters); in ntfs_non_resident_attr_expand()
4259 while (ni->runlist.rl[last].length) in ntfs_non_resident_attr_expand()
4262 rl = ntfs_rl_realloc(ni->runlist.rl, last + 1, in ntfs_non_resident_attr_expand()
4269 alloc_size = ni->allocated_size; in ntfs_non_resident_attr_expand()
4273 rl[last].length = ni->itype.compressed.block_clusters - in ntfs_non_resident_attr_expand()
4275 (ni->itype.compressed.block_clusters - 1)); in ntfs_non_resident_attr_expand()
4278 alloc_size += ni->itype.compressed.block_size; in ntfs_non_resident_attr_expand()
4285 ni->runlist.rl = rl; in ntfs_non_resident_attr_expand()
4286 ni->runlist.count += more_entries; in ntfs_non_resident_attr_expand()
4294 rl[0].vcn = ntfs_bytes_to_cluster(vol, ni->allocated_size); in ntfs_non_resident_attr_expand()
4297 ntfs_bytes_to_cluster(vol, ni->allocated_size); in ntfs_non_resident_attr_expand()
4311 if (ni->runlist.rl->length) { in ntfs_non_resident_attr_expand()
4313 for (rl = ni->runlist.rl; (rl + 1)->length; rl++) in ntfs_non_resident_attr_expand()
4319 while (rl->lcn < 0 && rl != ni->runlist.rl) in ntfs_non_resident_attr_expand()
4329 ntfs_bytes_to_cluster(vol, ni->allocated_size), in ntfs_non_resident_attr_expand()
4331 ntfs_bytes_to_cluster(vol, ni->allocated_size), in ntfs_non_resident_attr_expand()
4336 ntfs_bytes_to_cluster(vol, ni->allocated_size)); in ntfs_non_resident_attr_expand()
4341 if (!NInoCompressed(ni)) { in ntfs_non_resident_attr_expand()
4343 rln = ntfs_runlists_merge(&ni->runlist, rl, 0, &new_rl_count); in ntfs_non_resident_attr_expand()
4351 ni->runlist.rl = rln; in ntfs_non_resident_attr_expand()
4352 ni->runlist.count = new_rl_count; in ntfs_non_resident_attr_expand()
4356 ni->allocated_size = ntfs_cluster_to_bytes(vol, first_free_vcn); in ntfs_non_resident_attr_expand()
4357 err = ntfs_attr_update_mapping_pairs(ni, 0); in ntfs_non_resident_attr_expand()
4367 if (ni->allocated_size == org_alloc_size) in ntfs_non_resident_attr_expand()
4372 err = ntfs_attr_lookup(ni->type, ni->name, ni->name_len, CASE_SENSITIVE, in ntfs_non_resident_attr_expand()
4377 if (ni->allocated_size != org_alloc_size) in ntfs_non_resident_attr_expand()
4383 ni->data_size = newsize; in ntfs_non_resident_attr_expand()
4386 if (ni->type == AT_DATA && ni->name == AT_UNNAMED) in ntfs_non_resident_attr_expand()
4387 NInoSetFileNameDirty(ni); in ntfs_non_resident_attr_expand()
4395 err2 = ntfs_cluster_free(ni, ntfs_bytes_to_cluster(vol, org_alloc_size), in ntfs_non_resident_attr_expand()
4402 down_write(&ni->runlist.lock); in ntfs_non_resident_attr_expand()
4403 err2 = ntfs_rl_truncate_nolock(vol, &ni->runlist, in ntfs_non_resident_attr_expand()
4406 up_write(&ni->runlist.lock); in ntfs_non_resident_attr_expand()
4412 kvfree(ni->runlist.rl); in ntfs_non_resident_attr_expand()
4413 ni->runlist.rl = NULL; in ntfs_non_resident_attr_expand()
4417 ni->allocated_size = org_alloc_size; in ntfs_non_resident_attr_expand()
4420 down_read(&ni->runlist.lock); in ntfs_non_resident_attr_expand()
4421 if (ntfs_attr_update_mapping_pairs(ni, 0)) in ntfs_non_resident_attr_expand()
4424 up_read(&ni->runlist.lock); in ntfs_non_resident_attr_expand()
4426 if (NInoSparse(ni) || NInoCompressed(ni)) { in ntfs_non_resident_attr_expand()
4427 ni->itype.compressed.size = org_compressed_size; in ntfs_non_resident_attr_expand()
4428 VFS_I(base_ni)->i_blocks = ni->itype.compressed.size >> 9; in ntfs_non_resident_attr_expand()
4430 VFS_I(base_ni)->i_blocks = ni->allocated_size >> 9; in ntfs_non_resident_attr_expand()
4683 int __ntfs_attr_truncate_vfs(struct ntfs_inode *ni, const s64 newsize, in __ntfs_attr_truncate_vfs() argument
4689 (ni->mft_no == FILE_MFT && ni->type == AT_DATA)) { in __ntfs_attr_truncate_vfs()
4695 (unsigned long long)ni->mft_no, ni->type, newsize); in __ntfs_attr_truncate_vfs()
4697 if (NInoNonResident(ni)) { in __ntfs_attr_truncate_vfs()
4699 down_write(&ni->runlist.lock); in __ntfs_attr_truncate_vfs()
4700 err = ntfs_non_resident_attr_expand(ni, newsize, 0, in __ntfs_attr_truncate_vfs()
4701 NVolDisableSparse(ni->vol) ? in __ntfs_attr_truncate_vfs()
4704 up_write(&ni->runlist.lock); in __ntfs_attr_truncate_vfs()
4706 err = ntfs_non_resident_attr_shrink(ni, newsize); in __ntfs_attr_truncate_vfs()
4708 err = ntfs_resident_attr_resize(ni, newsize, 0, in __ntfs_attr_truncate_vfs()
4709 NVolDisableSparse(ni->vol) ? in __ntfs_attr_truncate_vfs()
4715 int ntfs_attr_expand(struct ntfs_inode *ni, const s64 newsize, const s64 prealloc_size) in ntfs_attr_expand() argument
4720 (ni->mft_no == FILE_MFT && ni->type == AT_DATA)) { in ntfs_attr_expand()
4726 (unsigned long long)ni->mft_no, ni->type, newsize); in ntfs_attr_expand()
4728 if (ni->data_size == newsize) { in ntfs_attr_expand()
4737 if (NInoEncrypted(ni)) { in ntfs_attr_expand()
4742 if (NInoNonResident(ni)) { in ntfs_attr_expand()
4743 if (newsize > ni->data_size) in ntfs_attr_expand()
4744 err = ntfs_non_resident_attr_expand(ni, newsize, prealloc_size, in ntfs_attr_expand()
4745 NVolDisableSparse(ni->vol) ? in ntfs_attr_expand()
4748 err = ntfs_resident_attr_resize(ni, newsize, prealloc_size, in ntfs_attr_expand()
4749 NVolDisableSparse(ni->vol) ? in ntfs_attr_expand()
4752 i_size_write(VFS_I(ni), newsize); in ntfs_attr_expand()
4769 int ntfs_attr_truncate_i(struct ntfs_inode *ni, const s64 newsize, unsigned int holes) in ntfs_attr_truncate_i() argument
4774 (ni->mft_no == FILE_MFT && ni->type == AT_DATA)) { in ntfs_attr_truncate_i()
4780 (unsigned long long)ni->mft_no, ni->type, newsize); in ntfs_attr_truncate_i()
4782 if (ni->data_size == newsize) { in ntfs_attr_truncate_i()
4791 if (NInoEncrypted(ni)) { in ntfs_attr_truncate_i()
4796 if (NInoCompressed(ni)) { in ntfs_attr_truncate_i()
4801 if (NInoNonResident(ni)) { in ntfs_attr_truncate_i()
4802 if (newsize > ni->data_size) in ntfs_attr_truncate_i()
4803 err = ntfs_non_resident_attr_expand(ni, newsize, 0, holes, true); in ntfs_attr_truncate_i()
4805 err = ntfs_non_resident_attr_shrink(ni, newsize); in ntfs_attr_truncate_i()
4807 err = ntfs_resident_attr_resize(ni, newsize, 0, holes); in ntfs_attr_truncate_i()
4815 int ntfs_attr_truncate(struct ntfs_inode *ni, const s64 newsize) in ntfs_attr_truncate() argument
4817 return ntfs_attr_truncate_i(ni, newsize, in ntfs_attr_truncate()
4818 NVolDisableSparse(ni->vol) ? in ntfs_attr_truncate()
4822 int ntfs_attr_map_cluster(struct ntfs_inode *ni, s64 vcn_start, s64 *lcn_start, in ntfs_attr_map_cluster() argument
4826 struct ntfs_volume *vol = ni->vol; in ntfs_attr_map_cluster()
4834 err = ntfs_attr_map_whole_runlist(ni); in ntfs_attr_map_cluster()
4838 if (NInoAttr(ni)) in ntfs_attr_map_cluster()
4839 ctx = ntfs_attr_get_search_ctx(ni->ext.base_ntfs_ino, NULL); in ntfs_attr_map_cluster()
4841 ctx = ntfs_attr_get_search_ctx(ni, NULL); in ntfs_attr_map_cluster()
4847 err = ntfs_attr_lookup(ni->type, ni->name, ni->name_len, in ntfs_attr_map_cluster()
4852 ni->mft_no, ni->type, err); in ntfs_attr_map_cluster()
4856 rl = ntfs_attr_find_vcn_nolock(ni, vcn, ctx); in ntfs_attr_map_cluster()
4893 if (NInoCompressed(ni)) in ntfs_attr_map_cluster()
4926 rl = ntfs_runlists_merge(&ni->runlist, rlc, 0, &new_rl_count); in ntfs_attr_map_cluster()
4935 ni->runlist.rl = rl; in ntfs_attr_map_cluster()
4936 ni->runlist.count = new_rl_count; in ntfs_attr_map_cluster()
4948 err = ntfs_attr_update_mapping_pairs(ni, 0); in ntfs_attr_map_cluster()
4952 err2 = ntfs_cluster_free(ni, vcn, clu_count, ctx); in ntfs_attr_map_cluster()
4959 VFS_I(ni)->i_blocks += clu_count << (vol->cluster_size_bits - 9); in ntfs_attr_map_cluster()
4960 NInoSetRunlistDirty(ni); in ntfs_attr_map_cluster()
4961 mark_mft_record_dirty(ni); in ntfs_attr_map_cluster()
4979 int ntfs_attr_rm(struct ntfs_inode *ni) in ntfs_attr_rm() argument
4984 struct super_block *sb = ni->vol->sb; in ntfs_attr_rm()
4986 if (NInoAttr(ni)) in ntfs_attr_rm()
4987 base_ni = ni->ext.base_ntfs_ino; in ntfs_attr_rm()
4989 base_ni = ni; in ntfs_attr_rm()
4992 (long long) ni->mft_no, ni->type); in ntfs_attr_rm()
4995 if (NInoNonResident(ni)) { in ntfs_attr_rm()
4998 err = ntfs_attr_map_whole_runlist(ni); in ntfs_attr_rm()
5001 ctx = ntfs_attr_get_search_ctx(ni, NULL); in ntfs_attr_rm()
5007 ret = ntfs_cluster_free(ni, 0, -1, ctx); in ntfs_attr_rm()
5020 while (!(err = ntfs_attr_lookup(ni->type, ni->name, ni->name_len, in ntfs_attr_rm()
5039 int ntfs_attr_exist(struct ntfs_inode *ni, const __le32 type, __le16 *name, in ntfs_attr_exist() argument
5047 ctx = ntfs_attr_get_search_ctx(ni, NULL); in ntfs_attr_exist()
5049 ntfs_error(ni->vol->sb, "%s: Failed to get search context", in ntfs_attr_exist()
5061 int ntfs_attr_remove(struct ntfs_inode *ni, const __le32 type, __le16 *name, in ntfs_attr_remove() argument
5070 if (!ni) in ntfs_attr_remove()
5073 attr_vi = ntfs_attr_iget(VFS_I(ni), type, name, name_len); in ntfs_attr_remove()
5076 ntfs_error(ni->vol->sb, "Failed to open attribute 0x%02x of inode 0x%llx", in ntfs_attr_remove()
5077 type, (unsigned long long)ni->mft_no); in ntfs_attr_remove()
5084 ntfs_error(ni->vol->sb, "Failed to remove attribute 0x%02x of inode 0x%llx", in ntfs_attr_remove()
5085 type, (unsigned long long)ni->mft_no); in ntfs_attr_remove()
5107 void *ntfs_attr_readall(struct ntfs_inode *ni, const __le32 type, in ntfs_attr_readall() argument
5114 struct super_block *sb = ni->vol->sb; in ntfs_attr_readall()
5118 bmp_vi = ntfs_attr_iget(VFS_I(ni), type, name, name_len); in ntfs_attr_readall()
5127 bmp_ni->data_size > ((ni->vol->nr_clusters + 7) >> 3))) { in ntfs_attr_readall()
5153 int ntfs_non_resident_attr_insert_range(struct ntfs_inode *ni, s64 start_vcn, s64 len) in ntfs_non_resident_attr_insert_range() argument
5155 struct ntfs_volume *vol = ni->vol; in ntfs_non_resident_attr_insert_range()
5161 if (NInoAttr(ni) || ni->type != AT_DATA) in ntfs_non_resident_attr_insert_range()
5163 if (start_vcn > ntfs_bytes_to_cluster(vol, ni->allocated_size)) in ntfs_non_resident_attr_insert_range()
5176 down_write(&ni->runlist.lock); in ntfs_non_resident_attr_insert_range()
5177 ret = ntfs_attr_map_whole_runlist(ni); in ntfs_non_resident_attr_insert_range()
5179 up_write(&ni->runlist.lock); in ntfs_non_resident_attr_insert_range()
5183 rl = ntfs_rl_find_vcn_nolock(ni->runlist.rl, start_vcn); in ntfs_non_resident_attr_insert_range()
5185 up_write(&ni->runlist.lock); in ntfs_non_resident_attr_insert_range()
5190 rl = ntfs_rl_insert_range(ni->runlist.rl, (int)ni->runlist.count, in ntfs_non_resident_attr_insert_range()
5193 up_write(&ni->runlist.lock); in ntfs_non_resident_attr_insert_range()
5197 ni->runlist.rl = rl; in ntfs_non_resident_attr_insert_range()
5198 ni->runlist.count = new_rl_count; in ntfs_non_resident_attr_insert_range()
5200 ni->allocated_size += ntfs_cluster_to_bytes(vol, len); in ntfs_non_resident_attr_insert_range()
5201 ni->data_size += ntfs_cluster_to_bytes(vol, len); in ntfs_non_resident_attr_insert_range()
5202 if (ntfs_cluster_to_bytes(vol, start_vcn) < ni->initialized_size) in ntfs_non_resident_attr_insert_range()
5203 ni->initialized_size += ntfs_cluster_to_bytes(vol, len); in ntfs_non_resident_attr_insert_range()
5204 ret = ntfs_attr_update_mapping_pairs(ni, 0); in ntfs_non_resident_attr_insert_range()
5205 up_write(&ni->runlist.lock); in ntfs_non_resident_attr_insert_range()
5209 ctx = ntfs_attr_get_search_ctx(ni, NULL); in ntfs_non_resident_attr_insert_range()
5215 ret = ntfs_attr_lookup(ni->type, ni->name, ni->name_len, CASE_SENSITIVE, in ntfs_non_resident_attr_insert_range()
5222 ctx->attr->data.non_resident.data_size = cpu_to_le64(ni->data_size); in ntfs_non_resident_attr_insert_range()
5223 ctx->attr->data.non_resident.initialized_size = cpu_to_le64(ni->initialized_size); in ntfs_non_resident_attr_insert_range()
5224 if (ni->type == AT_DATA && ni->name == AT_UNNAMED) in ntfs_non_resident_attr_insert_range()
5225 NInoSetFileNameDirty(ni); in ntfs_non_resident_attr_insert_range()
5231 int ntfs_non_resident_attr_collapse_range(struct ntfs_inode *ni, s64 start_vcn, s64 len) in ntfs_non_resident_attr_collapse_range() argument
5233 struct ntfs_volume *vol = ni->vol; in ntfs_non_resident_attr_collapse_range()
5241 if (NInoAttr(ni) || ni->type != AT_DATA) in ntfs_non_resident_attr_collapse_range()
5244 end_vcn = ntfs_bytes_to_cluster(vol, ni->allocated_size); in ntfs_non_resident_attr_collapse_range()
5248 down_write(&ni->runlist.lock); in ntfs_non_resident_attr_collapse_range()
5249 ret = ntfs_attr_map_whole_runlist(ni); in ntfs_non_resident_attr_collapse_range()
5251 up_write(&ni->runlist.lock); in ntfs_non_resident_attr_collapse_range()
5256 for (rl = ni->runlist.rl, dst_cnt = 0; rl && rl->length; rl++) in ntfs_non_resident_attr_collapse_range()
5258 rl = ntfs_rl_find_vcn_nolock(ni->runlist.rl, start_vcn); in ntfs_non_resident_attr_collapse_range()
5260 up_write(&ni->runlist.lock); in ntfs_non_resident_attr_collapse_range()
5264 rl = ntfs_rl_collapse_range(ni->runlist.rl, dst_cnt + 1, in ntfs_non_resident_attr_collapse_range()
5267 up_write(&ni->runlist.lock); in ntfs_non_resident_attr_collapse_range()
5270 ni->runlist.rl = rl; in ntfs_non_resident_attr_collapse_range()
5271 ni->runlist.count = new_rl_cnt; in ntfs_non_resident_attr_collapse_range()
5273 ni->allocated_size -= ntfs_cluster_to_bytes(vol, len); in ntfs_non_resident_attr_collapse_range()
5274 if (ni->data_size > ntfs_cluster_to_bytes(vol, start_vcn)) { in ntfs_non_resident_attr_collapse_range()
5275 if (ni->data_size > ntfs_cluster_to_bytes(vol, (start_vcn + len))) in ntfs_non_resident_attr_collapse_range()
5276 ni->data_size -= ntfs_cluster_to_bytes(vol, len); in ntfs_non_resident_attr_collapse_range()
5278 ni->data_size = ntfs_cluster_to_bytes(vol, start_vcn); in ntfs_non_resident_attr_collapse_range()
5280 if (ni->initialized_size > ntfs_cluster_to_bytes(vol, start_vcn)) { in ntfs_non_resident_attr_collapse_range()
5281 if (ni->initialized_size > in ntfs_non_resident_attr_collapse_range()
5283 ni->initialized_size -= ntfs_cluster_to_bytes(vol, len); in ntfs_non_resident_attr_collapse_range()
5285 ni->initialized_size = ntfs_cluster_to_bytes(vol, start_vcn); in ntfs_non_resident_attr_collapse_range()
5288 if (ni->allocated_size > 0) { in ntfs_non_resident_attr_collapse_range()
5289 ret = ntfs_attr_update_mapping_pairs(ni, 0); in ntfs_non_resident_attr_collapse_range()
5291 up_write(&ni->runlist.lock); in ntfs_non_resident_attr_collapse_range()
5295 up_write(&ni->runlist.lock); in ntfs_non_resident_attr_collapse_range()
5297 ctx = ntfs_attr_get_search_ctx(ni, NULL); in ntfs_non_resident_attr_collapse_range()
5303 ret = ntfs_attr_lookup(ni->type, ni->name, ni->name_len, CASE_SENSITIVE, in ntfs_non_resident_attr_collapse_range()
5308 ctx->attr->data.non_resident.data_size = cpu_to_le64(ni->data_size); in ntfs_non_resident_attr_collapse_range()
5309 ctx->attr->data.non_resident.initialized_size = cpu_to_le64(ni->initialized_size); in ntfs_non_resident_attr_collapse_range()
5310 if (ni->allocated_size == 0) in ntfs_non_resident_attr_collapse_range()
5311 ntfs_attr_make_resident(ni, ctx); in ntfs_non_resident_attr_collapse_range()
5322 mark_mft_record_dirty(ni); in ntfs_non_resident_attr_collapse_range()
5326 int ntfs_non_resident_attr_punch_hole(struct ntfs_inode *ni, s64 start_vcn, s64 len) in ntfs_non_resident_attr_punch_hole() argument
5328 struct ntfs_volume *vol = ni->vol; in ntfs_non_resident_attr_punch_hole()
5335 if (NInoAttr(ni) || ni->type != AT_DATA) in ntfs_non_resident_attr_punch_hole()
5338 end_vcn = ntfs_bytes_to_cluster(vol, ni->allocated_size); in ntfs_non_resident_attr_punch_hole()
5342 down_write(&ni->runlist.lock); in ntfs_non_resident_attr_punch_hole()
5343 ret = ntfs_attr_map_whole_runlist(ni); in ntfs_non_resident_attr_punch_hole()
5345 up_write(&ni->runlist.lock); in ntfs_non_resident_attr_punch_hole()
5350 for (rl = ni->runlist.rl, dst_cnt = 0; rl && rl->length; rl++) in ntfs_non_resident_attr_punch_hole()
5352 rl = ntfs_rl_find_vcn_nolock(ni->runlist.rl, start_vcn); in ntfs_non_resident_attr_punch_hole()
5354 up_write(&ni->runlist.lock); in ntfs_non_resident_attr_punch_hole()
5358 rl = ntfs_rl_punch_hole(ni->runlist.rl, dst_cnt + 1, in ntfs_non_resident_attr_punch_hole()
5361 up_write(&ni->runlist.lock); in ntfs_non_resident_attr_punch_hole()
5364 ni->runlist.rl = rl; in ntfs_non_resident_attr_punch_hole()
5365 ni->runlist.count = new_rl_count; in ntfs_non_resident_attr_punch_hole()
5367 ret = ntfs_attr_update_mapping_pairs(ni, 0); in ntfs_non_resident_attr_punch_hole()
5368 up_write(&ni->runlist.lock); in ntfs_non_resident_attr_punch_hole()
5379 mark_mft_record_dirty(ni); in ntfs_non_resident_attr_punch_hole()
5383 int ntfs_attr_fallocate(struct ntfs_inode *ni, loff_t start, loff_t byte_len, bool keep_size) in ntfs_attr_fallocate() argument
5385 struct ntfs_volume *vol = ni->vol; in ntfs_attr_fallocate()
5395 if (NInoAttr(ni) || ni->type != AT_DATA) in ntfs_attr_fallocate()
5398 if (NInoNonResident(ni) && !NInoFullyMapped(ni)) { in ntfs_attr_fallocate()
5399 down_write(&ni->runlist.lock); in ntfs_attr_fallocate()
5400 err = ntfs_attr_map_whole_runlist(ni); in ntfs_attr_fallocate()
5401 up_write(&ni->runlist.lock); in ntfs_attr_fallocate()
5406 mutex_lock_nested(&ni->mrec_lock, NTFS_INODE_MUTEX_NORMAL); in ntfs_attr_fallocate()
5407 mrec = map_mft_record(ni); in ntfs_attr_fallocate()
5409 mutex_unlock(&ni->mrec_lock); in ntfs_attr_fallocate()
5413 ctx = ntfs_attr_get_search_ctx(ni, mrec); in ntfs_attr_fallocate()
5425 old_data_size = ni->data_size; in ntfs_attr_fallocate()
5426 if (start + byte_len > ni->data_size) { in ntfs_attr_fallocate()
5427 err = ntfs_attr_truncate(ni, start + byte_len); in ntfs_attr_fallocate()
5437 ni->data_size = old_data_size; in ntfs_attr_fallocate()
5438 if (NInoNonResident(ni)) in ntfs_attr_fallocate()
5444 mark_mft_record_dirty(ni); in ntfs_attr_fallocate()
5449 unmap_mft_record(ni); in ntfs_attr_fallocate()
5450 mutex_unlock(&ni->mrec_lock); in ntfs_attr_fallocate()
5452 if (!NInoNonResident(ni)) in ntfs_attr_fallocate()
5459 round_up(ni->initialized_size, vol->cluster_size)); in ntfs_attr_fallocate()
5468 down_read(&ni->runlist.lock); in ntfs_attr_fallocate()
5469 rl = ntfs_attr_find_vcn_nolock(ni, vcn, NULL); in ntfs_attr_fallocate()
5470 up_read(&ni->runlist.lock); in ntfs_attr_fallocate()
5488 mutex_lock_nested(&ni->mrec_lock, NTFS_INODE_MUTEX_NORMAL); in ntfs_attr_fallocate()
5489 down_write(&ni->runlist.lock); in ntfs_attr_fallocate()
5490 err = ntfs_attr_map_cluster(ni, vcn, &lcn, &alloc_cnt, in ntfs_attr_fallocate()
5492 up_write(&ni->runlist.lock); in ntfs_attr_fallocate()
5493 mutex_unlock(&ni->mrec_lock); in ntfs_attr_fallocate()
5497 err = ntfs_dio_zero_range(VFS_I(ni), in ntfs_attr_fallocate()
5518 mutex_lock_nested(&ni->mrec_lock, NTFS_INODE_MUTEX_NORMAL); in ntfs_attr_fallocate()
5519 down_write(&ni->runlist.lock); in ntfs_attr_fallocate()
5520 err = ntfs_attr_map_cluster(ni, vcn, &lcn, &alloc_cnt, in ntfs_attr_fallocate()
5522 up_write(&ni->runlist.lock); in ntfs_attr_fallocate()
5523 mutex_unlock(&ni->mrec_lock); in ntfs_attr_fallocate()
5532 if (NInoRunlistDirty(ni)) { in ntfs_attr_fallocate()
5533 mutex_lock_nested(&ni->mrec_lock, NTFS_INODE_MUTEX_NORMAL); in ntfs_attr_fallocate()
5534 down_write(&ni->runlist.lock); in ntfs_attr_fallocate()
5535 err = ntfs_attr_update_mapping_pairs(ni, 0); in ntfs_attr_fallocate()
5537 ntfs_error(ni->vol->sb, "Updating mapping pairs failed"); in ntfs_attr_fallocate()
5539 NInoClearRunlistDirty(ni); in ntfs_attr_fallocate()
5540 up_write(&ni->runlist.lock); in ntfs_attr_fallocate()
5541 mutex_unlock(&ni->mrec_lock); in ntfs_attr_fallocate()
5547 unmap_mft_record(ni); in ntfs_attr_fallocate()
5548 mutex_unlock(&ni->mrec_lock); in ntfs_attr_fallocate()