Lines Matching refs:ni
49 ntfs_inode *ni;
53 ni = NTFS_I(vi);
54 /* If !NInoAttr(ni), @vi is a normal file or directory inode. */
55 if (likely(!NInoAttr(ni))) {
61 if (ni->type != na->type)
63 if (ni->name_len != na->name_len)
65 if (na->name_len && memcmp(ni->name, na->name,
94 ntfs_inode *ni = NTFS_I(vi);
98 ni->type = na->type;
100 NInoSetMstProtected(ni);
102 ni->name = na->name;
103 ni->name_len = na->name_len;
113 NInoSetAttr(ni);
127 ni->name = kmalloc(i + sizeof(ntfschar), GFP_ATOMIC);
128 if (!ni->name)
130 memcpy(ni->name, na->name, i);
131 ni->name[na->name_len] = 0;
310 ntfs_inode *ni;
313 ni = kmem_cache_alloc(ntfs_big_inode_cache, GFP_NOFS);
314 if (likely(ni != NULL)) {
315 ni->state = 0;
316 return VFS_I(ni);
329 ntfs_inode *ni;
332 ni = kmem_cache_alloc(ntfs_inode_cache, GFP_NOFS);
333 if (likely(ni != NULL)) {
334 ni->state = 0;
335 return ni;
341 static void ntfs_destroy_extent_inode(ntfs_inode *ni)
344 BUG_ON(ni->page);
345 if (!atomic_dec_and_test(&ni->count))
347 kmem_cache_free(ntfs_inode_cache, ni);
359 * @ni: freshly allocated ntfs inode which to initialize
363 * NOTE: ni->mft_no, ni->state, ni->type, ni->name, and ni->name_len are left
368 void __ntfs_init_inode(struct super_block *sb, ntfs_inode *ni)
371 rwlock_init(&ni->size_lock);
372 ni->initialized_size = ni->allocated_size = 0;
373 ni->seq_no = 0;
374 atomic_set(&ni->count, 1);
375 ni->vol = NTFS_SB(sb);
376 ntfs_init_runlist(&ni->runlist);
377 mutex_init(&ni->mrec_lock);
378 ni->page = NULL;
379 ni->page_ofs = 0;
380 ni->attr_list_size = 0;
381 ni->attr_list = NULL;
382 ntfs_init_runlist(&ni->attr_list_rl);
383 lockdep_set_class(&ni->attr_list_rl.lock,
385 ni->itype.index.block_size = 0;
386 ni->itype.index.vcn_size = 0;
387 ni->itype.index.collation_rule = 0;
388 ni->itype.index.block_size_bits = 0;
389 ni->itype.index.vcn_size_bits = 0;
390 mutex_init(&ni->extent_lock);
391 ni->nr_extents = 0;
392 ni->ext.base_ntfs_ino = NULL;
405 ntfs_inode *ni = ntfs_alloc_extent_inode();
408 if (likely(ni != NULL)) {
409 __ntfs_init_inode(sb, ni);
410 lockdep_set_class(&ni->mrec_lock, &extent_inode_mrec_lock_key);
411 ni->mft_no = mft_no;
412 ni->type = AT_UNUSED;
413 ni->name = NULL;
414 ni->name_len = 0;
416 return ni;
527 ntfs_inode *ni;
548 ni = NTFS_I(vi);
550 m = map_mft_record(ni);
555 ctx = ntfs_attr_get_search_ctx(ni, m);
571 vi->i_generation = ni->seq_no = le16_to_cpu(m->sequence_number);
677 NInoSetAttrList(ni);
702 ni->attr_list_size = (u32)ntfs_attr_size(a);
703 ni->attr_list = ntfs_malloc_nofs(ni->attr_list_size);
704 if (!ni->attr_list) {
711 NInoSetAttrListNonResident(ni);
721 ni->attr_list_rl.rl = ntfs_mapping_pairs_decompress(vol,
723 if (IS_ERR(ni->attr_list_rl.rl)) {
724 err = PTR_ERR(ni->attr_list_rl.rl);
725 ni->attr_list_rl.rl = NULL;
731 if ((err = load_attribute_list(vol, &ni->attr_list_rl,
732 ni->attr_list, ni->attr_list_size,
749 memcpy(ni->attr_list, (u8*)a + le16_to_cpu(
801 NInoSetCompressed(ni);
808 NInoSetEncrypted(ni);
811 NInoSetSparse(ni);
836 ni->itype.index.collation_rule = ir->collation_rule;
837 ni->itype.index.block_size = le32_to_cpu(ir->index_block_size);
838 if (ni->itype.index.block_size &
839 (ni->itype.index.block_size - 1)) {
842 ni->itype.index.block_size);
845 if (ni->itype.index.block_size > PAGE_SIZE) {
849 ni->itype.index.block_size,
854 if (ni->itype.index.block_size < NTFS_BLOCK_SIZE) {
858 ni->itype.index.block_size,
863 ni->itype.index.block_size_bits =
864 ffs(ni->itype.index.block_size) - 1;
866 if (vol->cluster_size <= ni->itype.index.block_size) {
867 ni->itype.index.vcn_size = vol->cluster_size;
868 ni->itype.index.vcn_size_bits = vol->cluster_size_bits;
870 ni->itype.index.vcn_size = vol->sector_size;
871 ni->itype.index.vcn_size_bits = vol->sector_size_bits;
875 NInoSetMstProtected(ni);
876 ni->type = AT_INDEX_ALLOCATION;
877 ni->name = I30;
878 ni->name_len = 4;
882 vi->i_size = ni->initialized_size =
883 ni->allocated_size = 0;
886 unmap_mft_record(ni);
891 NInoSetIndexAllocPresent(ni);
947 ni->initialized_size = sle64_to_cpu(
949 ni->allocated_size = sle64_to_cpu(
956 unmap_mft_record(ni);
976 ni->itype.index.block_size_bits)) {
994 ni->type = AT_DATA;
995 ni->name = NULL;
996 ni->name_len = 0;
1001 vi->i_size = ni->initialized_size =
1002 ni->allocated_size = 0;
1034 NInoSetCompressed(ni);
1054 NInoSetSparse(ni);
1057 if (NInoCompressed(ni)) {
1062 NInoSetEncrypted(ni);
1065 NInoSetNonResident(ni);
1066 if (NInoCompressed(ni) || NInoSparse(ni)) {
1067 if (NInoCompressed(ni) && a->data.non_resident.
1080 ni->itype.compressed.block_size = 1U <<
1084 ni->itype.compressed.block_size_bits =
1085 ffs(ni->itype.
1088 ni->itype.compressed.block_clusters =
1093 ni->itype.compressed.block_size = 0;
1094 ni->itype.compressed.block_size_bits =
1096 ni->itype.compressed.block_clusters =
1099 ni->itype.compressed.size = sle64_to_cpu(
1111 ni->initialized_size = sle64_to_cpu(
1113 ni->allocated_size = sle64_to_cpu(
1116 vi->i_size = ni->initialized_size = le32_to_cpu(
1118 ni->allocated_size = le32_to_cpu(a->length) -
1121 if (vi->i_size > ni->allocated_size) {
1131 unmap_mft_record(ni);
1138 if (NInoMstProtected(ni))
1140 else if (NInoCompressed(ni))
1154 if (S_ISREG(vi->i_mode) && (NInoCompressed(ni) || NInoSparse(ni)))
1155 vi->i_blocks = ni->itype.compressed.size >> 9;
1157 vi->i_blocks = ni->allocated_size >> 9;
1168 unmap_mft_record(ni);
1203 ntfs_inode *ni, *base_ni;
1213 ni = NTFS_I(vi);
1223 vi->i_generation = ni->seq_no = base_ni->seq_no;
1239 err = ntfs_attr_lookup(ni->type, ni->name, ni->name_len,
1246 NInoSetCompressed(ni);
1247 if ((ni->type != AT_DATA) || (ni->type == AT_DATA &&
1248 ni->name_len)) {
1276 if (NInoMstProtected(ni) && ni->type != AT_INDEX_ROOT) {
1281 NInoCompressed(ni) ? "compressed" :
1286 NInoSetSparse(ni);
1289 if (NInoCompressed(ni)) {
1298 if (NInoMstProtected(ni) && ni->type != AT_INDEX_ROOT) {
1306 if (ni->type != AT_DATA) {
1311 NInoSetEncrypted(ni);
1321 if (NInoMstProtected(ni)) {
1328 vi->i_size = ni->initialized_size = le32_to_cpu(
1330 ni->allocated_size = le32_to_cpu(a->length) -
1332 if (vi->i_size > ni->allocated_size) {
1338 NInoSetNonResident(ni);
1350 if (NInoCompressed(ni) || NInoSparse(ni)) {
1351 if (NInoCompressed(ni) && a->data.non_resident.
1362 ni->itype.compressed.block_size = 1U <<
1366 ni->itype.compressed.block_size_bits =
1367 ffs(ni->itype.compressed.
1369 ni->itype.compressed.block_clusters = 1U <<
1373 ni->itype.compressed.block_size = 0;
1374 ni->itype.compressed.block_size_bits = 0;
1375 ni->itype.compressed.block_clusters = 0;
1377 ni->itype.compressed.size = sle64_to_cpu(
1386 ni->initialized_size = sle64_to_cpu(
1388 ni->allocated_size = sle64_to_cpu(
1392 if (NInoMstProtected(ni))
1394 else if (NInoCompressed(ni))
1396 if ((NInoCompressed(ni) || NInoSparse(ni)) && ni->type != AT_INDEX_ROOT)
1397 vi->i_blocks = ni->itype.compressed.size >> 9;
1399 vi->i_blocks = ni->allocated_size >> 9;
1405 ni->ext.base_ntfs_ino = base_ni;
1406 ni->nr_extents = -1;
1424 "Run chkdsk.", err, vi->i_ino, ni->type, ni->name_len,
1469 ntfs_inode *ni, *base_ni, *bni;
1480 ni = NTFS_I(vi);
1489 vi->i_generation = ni->seq_no = base_ni->seq_no;
1504 err = ntfs_attr_lookup(AT_INDEX_ROOT, ni->name, ni->name_len,
1551 ni->itype.index.collation_rule = ir->collation_rule;
1554 ni->itype.index.block_size = le32_to_cpu(ir->index_block_size);
1555 if (!is_power_of_2(ni->itype.index.block_size)) {
1557 "two.", ni->itype.index.block_size);
1560 if (ni->itype.index.block_size > PAGE_SIZE) {
1563 ni->itype.index.block_size, PAGE_SIZE);
1567 if (ni->itype.index.block_size < NTFS_BLOCK_SIZE) {
1570 ni->itype.index.block_size, NTFS_BLOCK_SIZE);
1574 ni->itype.index.block_size_bits = ffs(ni->itype.index.block_size) - 1;
1576 if (vol->cluster_size <= ni->itype.index.block_size) {
1577 ni->itype.index.vcn_size = vol->cluster_size;
1578 ni->itype.index.vcn_size_bits = vol->cluster_size_bits;
1580 ni->itype.index.vcn_size = vol->sector_size;
1581 ni->itype.index.vcn_size_bits = vol->sector_size_bits;
1586 vi->i_size = ni->initialized_size = ni->allocated_size = 0;
1594 NInoSetIndexAllocPresent(ni);
1597 err = ntfs_attr_lookup(AT_INDEX_ALLOCATION, ni->name, ni->name_len,
1645 ni->initialized_size = sle64_to_cpu(
1647 ni->allocated_size = sle64_to_cpu(a->data.non_resident.allocated_size);
1657 bvi = ntfs_attr_iget(base_vi, AT_BITMAP, ni->name, ni->name_len);
1672 if ((bvi_size << 3) < (vi->i_size >> ni->itype.index.block_size_bits)) {
1682 vi->i_blocks = ni->allocated_size >> 9;
1688 ni->ext.base_ntfs_ino = base_ni;
1689 ni->nr_extents = -1;
1705 ni->name_len);
1754 ntfs_inode *ni;
1766 ni = NTFS_I(vi);
1769 NInoSetNonResident(ni);
1770 NInoSetMstProtected(ni);
1771 NInoSetSparseDisabled(ni);
1772 ni->type = AT_DATA;
1773 ni->name = NULL;
1774 ni->name_len = 0;
1779 ni->itype.index.block_size = vol->mft_record_size;
1780 ni->itype.index.block_size_bits = vol->mft_record_size_bits;
1840 vi->i_generation = ni->seq_no = le16_to_cpu(m->sequence_number);
1845 ctx = ntfs_attr_get_search_ctx(ni, m);
1866 NInoSetAttrList(ni);
1890 ni->attr_list_size = (u32)ntfs_attr_size(a);
1891 if (!ni->attr_list_size) {
1895 ni->attr_list = ntfs_malloc_nofs(ni->attr_list_size);
1896 if (!ni->attr_list) {
1902 NInoSetAttrListNonResident(ni);
1910 ni->attr_list_rl.rl = ntfs_mapping_pairs_decompress(vol,
1912 if (IS_ERR(ni->attr_list_rl.rl)) {
1913 err = PTR_ERR(ni->attr_list_rl.rl);
1914 ni->attr_list_rl.rl = NULL;
1921 if ((err = load_attribute_list(vol, &ni->attr_list_rl,
1922 ni->attr_list, ni->attr_list_size,
1941 memcpy(ni->attr_list, (u8*)a + le16_to_cpu(
1958 al_entry = (ATTR_LIST_ENTRY*)ni->attr_list;
1959 al_end = (u8*)al_entry + ni->attr_list_size;
1962 if ((u8*)al_entry < ni->attr_list ||
1998 ni->seq_no)
2041 nrl = ntfs_mapping_pairs_decompress(vol, a, ni->runlist.rl);
2048 ni->runlist.rl = nrl;
2066 ni->initialized_size = sle64_to_cpu(
2068 ni->allocated_size = sle64_to_cpu(
2169 lockdep_set_class(&ni->runlist.lock, &mft_ni_runlist_lock_key);
2170 lockdep_set_class(&ni->mrec_lock, &mft_ni_mrec_lock_key);
2186 static void __ntfs_clear_inode(ntfs_inode *ni)
2189 down_write(&ni->runlist.lock);
2190 if (ni->runlist.rl) {
2191 ntfs_free(ni->runlist.rl);
2192 ni->runlist.rl = NULL;
2194 up_write(&ni->runlist.lock);
2196 if (ni->attr_list) {
2197 ntfs_free(ni->attr_list);
2198 ni->attr_list = NULL;
2201 down_write(&ni->attr_list_rl.lock);
2202 if (ni->attr_list_rl.rl) {
2203 ntfs_free(ni->attr_list_rl.rl);
2204 ni->attr_list_rl.rl = NULL;
2206 up_write(&ni->attr_list_rl.lock);
2208 if (ni->name_len && ni->name != I30) {
2210 BUG_ON(!ni->name);
2211 kfree(ni->name);
2215 void ntfs_clear_extent_inode(ntfs_inode *ni)
2217 ntfs_debug("Entering for inode 0x%lx.", ni->mft_no);
2219 BUG_ON(NInoAttr(ni));
2220 BUG_ON(ni->nr_extents != -1);
2223 if (NInoDirty(ni)) {
2224 if (!is_bad_inode(VFS_I(ni->ext.base_ntfs_ino)))
2225 ntfs_error(ni->vol->sb, "Clearing dirty extent inode! "
2231 __ntfs_clear_inode(ni);
2234 ntfs_destroy_extent_inode(ni);
2249 ntfs_inode *ni = NTFS_I(vi);
2255 if (NInoDirty(ni)) {
2261 if (!was_bad && (is_bad_inode(vi) || NInoDirty(ni))) {
2270 if (ni->nr_extents > 0) {
2273 for (i = 0; i < ni->nr_extents; i++)
2274 ntfs_clear_extent_inode(ni->ext.extent_ntfs_inos[i]);
2275 kfree(ni->ext.extent_ntfs_inos);
2278 __ntfs_clear_inode(ni);
2280 if (NInoAttr(ni)) {
2282 if (ni->nr_extents == -1) {
2283 iput(VFS_I(ni->ext.base_ntfs_ino));
2284 ni->nr_extents = 0;
2285 ni->ext.base_ntfs_ino = NULL;
2288 BUG_ON(ni->page);
2289 if (!atomic_dec_and_test(&ni->count))
2360 ntfs_inode *base_ni, *ni = NTFS_I(vi);
2361 ntfs_volume *vol = ni->vol;
2370 BUG_ON(NInoAttr(ni));
2372 BUG_ON(NInoMstProtected(ni));
2373 BUG_ON(ni->nr_extents < 0);
2379 down_write(&ni->runlist.lock);
2380 if (!NInoAttr(ni))
2381 base_ni = ni;
2383 base_ni = ni->ext.base_ntfs_ino;
2401 err = ntfs_attr_lookup(ni->type, ni->name, ni->name_len,
2424 if (NInoNonResident(ni))
2430 read_lock_irqsave(&ni->size_lock, flags);
2431 old_alloc_size = ni->allocated_size;
2432 read_unlock_irqrestore(&ni->size_lock, flags);
2458 err = ntfs_attr_size_bounds_check(vol, ni->type, new_size);
2468 le32_to_cpu(ni->type));
2475 le32_to_cpu(ni->type));
2483 if (NInoCompressed(ni) || NInoEncrypted(ni)) {
2486 NInoCompressed(ni) ? "compressed" :
2493 BUG_ON(NInoNonResident(ni));
2500 write_lock_irqsave(&ni->size_lock, flags);
2502 ni->allocated_size = le32_to_cpu(a->length) -
2532 ni->initialized_size = new_size;
2533 write_unlock_irqrestore(&ni->size_lock, flags);
2549 up_write(&ni->runlist.lock);
2554 err = ntfs_attr_make_non_resident(ni, old_size);
2567 (unsigned)le32_to_cpu(ni->type), err);
2593 if (ni->type == AT_ATTRIBUTE_LIST ||
2594 ni->type == AT_STANDARD_INFORMATION) {
2612 BUG_ON(!NInoNonResident(ni));
2628 (unsigned)le32_to_cpu(ni->type));
2641 write_lock_irqsave(&ni->size_lock, flags);
2642 if (new_size < ni->initialized_size) {
2643 ni->initialized_size = new_size;
2648 write_unlock_irqrestore(&ni->size_lock, flags);
2682 up_write(&ni->runlist.lock);
2683 err = ntfs_attr_extend_allocation(ni, new_size,
2696 nr_freed = ntfs_cluster_free(ni, new_alloc_size >>
2708 err = ntfs_rl_truncate_nolock(vol, &ni->runlist,
2726 mp_size = ntfs_get_size_for_mapping_pairs(vol, ni->runlist.rl, 0, -1);
2732 (unsigned)le32_to_cpu(ni->type), mp_size, es);
2750 mp_size, ni->runlist.rl, 0, -1, NULL);
2755 vi->i_ino, (unsigned)le32_to_cpu(ni->type),
2763 write_lock_irqsave(&ni->size_lock, flags);
2764 ni->allocated_size = new_alloc_size;
2766 if (NInoSparse(ni) || NInoCompressed(ni)) {
2768 ni->itype.compressed.size -= nr_freed <<
2770 BUG_ON(ni->itype.compressed.size < 0);
2772 ni->itype.compressed.size);
2773 vi->i_blocks = ni->itype.compressed.size >> 9;
2777 write_unlock_irqrestore(&ni->size_lock, flags);
2799 up_write(&ni->runlist.lock);
2822 NInoClearTruncateFailed(ni);
2832 NInoSetTruncateFailed(ni);
2840 up_write(&ni->runlist.lock);
2848 NInoSetTruncateFailed(ni);
2900 ntfs_inode *ni = NTFS_I(vi);
2905 if (NInoCompressed(ni) || NInoEncrypted(ni)) {
2909 NInoCompressed(ni) ?
2958 ntfs_inode *ni = NTFS_I(vi);
2965 ntfs_debug("Entering for %sinode 0x%lx.", NInoAttr(ni) ? "attr " : "",
2972 if (NInoAttr(ni)) {
2973 NInoClearDirty(ni);
2978 m = map_mft_record(ni);
2984 ctx = ntfs_attr_get_search_ctx(ni, m);
3049 if (NInoDirty(ni))
3050 err = write_mft_record(ni, m, sync);
3052 mutex_lock(&ni->extent_lock);
3053 if (ni->nr_extents > 0) {
3054 ntfs_inode **extent_nis = ni->ext.extent_ntfs_inos;
3057 ntfs_debug("Writing %i extent inodes.", ni->nr_extents);
3058 for (i = 0; i < ni->nr_extents; i++) {
3079 mutex_unlock(&ni->extent_lock);
3080 unmap_mft_record(ni);
3086 unmap_mft_record(ni);
3095 NVolSetErrors(ni->vol);