Lines Matching refs:vol
90 * @vol: ntfs volume
93 * Parse the recognized options in @opt for the ntfs volume described by @vol.
95 static bool parse_options(ntfs_volume *vol, char *opt)
200 ntfs_warning(vol->sb, "Ignoring obsolete option %s.",
204 ntfs_warning(vol->sb, "Option iocharset is "
215 ntfs_error(vol->sb, "NLS character set "
219 ntfs_error(vol->sb, "NLS character set %s not "
228 ntfs_warning(vol->sb, "Option utf8 is no longer "
242 ntfs_error(vol->sb, "Unrecognized mount option %s.", p);
255 ntfs_warning(vol->sb, "Sloppy option given. Ignoring "
260 ntfs_error(vol->sb, "Invalid errors option argument "
266 if (vol->nls_map && vol->nls_map != nls_map) {
267 ntfs_error(vol->sb, "Cannot change NLS character set "
270 } /* else (!vol->nls_map) */
272 vol->nls_map = nls_map;
274 if (!vol->nls_map) {
275 vol->nls_map = load_nls_default();
276 if (!vol->nls_map) {
277 ntfs_error(vol->sb, "Failed to load default "
282 vol->nls_map->charset);
286 if (vol->mft_zone_multiplier && vol->mft_zone_multiplier !=
288 ntfs_error(vol->sb, "Cannot change mft_zone_multiplier "
293 ntfs_error(vol->sb, "Invalid mft_zone_multiplier. "
297 vol->mft_zone_multiplier = mft_zone_multiplier;
299 if (!vol->mft_zone_multiplier)
300 vol->mft_zone_multiplier = 1;
302 vol->on_errors = on_errors;
303 if (!vol->on_errors || vol->on_errors == ON_ERRORS_RECOVER)
304 vol->on_errors |= ON_ERRORS_CONTINUE;
306 vol->uid = uid;
308 vol->gid = gid;
310 vol->fmask = fmask;
312 vol->dmask = dmask;
315 NVolSetShowSystemFiles(vol);
317 NVolClearShowSystemFiles(vol);
321 NVolSetCaseSensitive(vol);
323 NVolClearCaseSensitive(vol);
327 NVolClearSparseEnabled(vol);
329 if (!NVolSparseEnabled(vol) &&
330 vol->major_ver && vol->major_ver < 3)
331 ntfs_warning(vol->sb, "Not enabling sparse "
334 "version 3.0).", vol->major_ver,
335 vol->minor_ver);
337 NVolSetSparseEnabled(vol);
342 ntfs_error(vol->sb, "The %s option requires an argument.", p);
345 ntfs_error(vol->sb, "The %s option requires a boolean argument.", p);
348 ntfs_error(vol->sb, "Invalid %s option argument: %s", p, ov);
356 * @vol: ntfs volume on which to modify the flags
362 * Replace the volume information flags on the volume @vol with the value
369 static int ntfs_write_volume_flags(ntfs_volume *vol, const VOLUME_FLAGS flags)
371 ntfs_inode *ni = NTFS_I(vol->vol_ino);
378 le16_to_cpu(vol->vol_flags), le16_to_cpu(flags));
379 if (vol->vol_flags == flags)
398 vol->vol_flags = vi->flags = flags;
411 ntfs_error(vol->sb, "Failed with error code %i.", -err);
417 * @vol: ntfs volume on which to modify the flags
420 * Set the bits in @flags in the volume information flags on the volume @vol.
424 static inline int ntfs_set_volume_flags(ntfs_volume *vol, VOLUME_FLAGS flags)
427 return ntfs_write_volume_flags(vol, vol->vol_flags | flags);
432 * @vol: ntfs volume on which to modify the flags
435 * Clear the bits in @flags in the volume information flags on the volume @vol.
439 static inline int ntfs_clear_volume_flags(ntfs_volume *vol, VOLUME_FLAGS flags)
442 flags = vol->vol_flags & cpu_to_le16(~le16_to_cpu(flags));
443 return ntfs_write_volume_flags(vol, flags);
462 ntfs_volume *vol = NTFS_SB(sb);
488 if (NVolErrors(vol)) {
493 if (vol->vol_flags & VOLUME_IS_DIRTY) {
497 if (vol->vol_flags & VOLUME_MODIFIED_BY_CHKDSK) {
502 if (vol->vol_flags & VOLUME_MUST_MOUNT_RO_MASK) {
505 (unsigned)le16_to_cpu(vol->vol_flags),
509 if (ntfs_set_volume_flags(vol, VOLUME_IS_DIRTY)) {
518 if ((vol->major_ver > 1)) {
519 if (ntfs_set_volume_flags(vol, VOLUME_MOUNTED_ON_NT4)) {
522 NVolSetErrors(vol);
527 if (!ntfs_empty_logfile(vol->logfile_ino)) {
530 NVolSetErrors(vol);
533 if (!ntfs_mark_quotas_out_of_date(vol)) {
536 NVolSetErrors(vol);
539 if (!ntfs_stamp_usnjrnl(vol)) {
542 NVolSetErrors(vol);
547 if (!NVolErrors(vol)) {
548 if (ntfs_clear_volume_flags(vol, VOLUME_IS_DIRTY))
558 if (!parse_options(vol, opt))
753 * parse_ntfs_boot_sector - parse the boot sector and store the data in @vol
754 * @vol: volume structure to initialise with data from boot sector
758 * the ntfs super block @vol. Return 'true' on success and 'false' on error.
760 static bool parse_ntfs_boot_sector(ntfs_volume *vol, const NTFS_BOOT_SECTOR *b)
766 vol->sector_size = le16_to_cpu(b->bpb.bytes_per_sector);
767 vol->sector_size_bits = ffs(vol->sector_size) - 1;
768 ntfs_debug("vol->sector_size = %i (0x%x)", vol->sector_size,
769 vol->sector_size);
770 ntfs_debug("vol->sector_size_bits = %i (0x%x)", vol->sector_size_bits,
771 vol->sector_size_bits);
772 if (vol->sector_size < vol->sb->s_blocksize) {
773 ntfs_error(vol->sb, "Sector size (%i) is smaller than the "
775 "supported. Sorry.", vol->sector_size,
776 vol->sb->s_blocksize);
785 vol->cluster_size = vol->sector_size << sectors_per_cluster_bits;
786 vol->cluster_size_mask = vol->cluster_size - 1;
787 vol->cluster_size_bits = ffs(vol->cluster_size) - 1;
788 ntfs_debug("vol->cluster_size = %i (0x%x)", vol->cluster_size,
789 vol->cluster_size);
790 ntfs_debug("vol->cluster_size_mask = 0x%x", vol->cluster_size_mask);
791 ntfs_debug("vol->cluster_size_bits = %i", vol->cluster_size_bits);
792 if (vol->cluster_size < vol->sector_size) {
793 ntfs_error(vol->sb, "Cluster size (%i) is smaller than the "
795 "Sorry.", vol->cluster_size, vol->sector_size);
802 vol->mft_record_size = vol->cluster_size <<
810 vol->mft_record_size = 1 << -clusters_per_mft_record;
811 vol->mft_record_size_mask = vol->mft_record_size - 1;
812 vol->mft_record_size_bits = ffs(vol->mft_record_size) - 1;
813 ntfs_debug("vol->mft_record_size = %i (0x%x)", vol->mft_record_size,
814 vol->mft_record_size);
815 ntfs_debug("vol->mft_record_size_mask = 0x%x",
816 vol->mft_record_size_mask);
817 ntfs_debug("vol->mft_record_size_bits = %i (0x%x)",
818 vol->mft_record_size_bits, vol->mft_record_size_bits);
823 if (vol->mft_record_size > PAGE_SIZE) {
824 ntfs_error(vol->sb, "Mft record size (%i) exceeds the "
827 vol->mft_record_size, PAGE_SIZE);
831 if (vol->mft_record_size < vol->sector_size) {
832 ntfs_error(vol->sb, "Mft record size (%i) is smaller than the "
834 "Sorry.", vol->mft_record_size,
835 vol->sector_size);
842 vol->index_record_size = vol->cluster_size <<
851 vol->index_record_size = 1 << -clusters_per_index_record;
852 vol->index_record_size_mask = vol->index_record_size - 1;
853 vol->index_record_size_bits = ffs(vol->index_record_size) - 1;
854 ntfs_debug("vol->index_record_size = %i (0x%x)",
855 vol->index_record_size, vol->index_record_size);
856 ntfs_debug("vol->index_record_size_mask = 0x%x",
857 vol->index_record_size_mask);
858 ntfs_debug("vol->index_record_size_bits = %i (0x%x)",
859 vol->index_record_size_bits,
860 vol->index_record_size_bits);
862 if (vol->index_record_size < vol->sector_size) {
863 ntfs_error(vol->sb, "Index record size (%i) is smaller than "
865 "supported. Sorry.", vol->index_record_size,
866 vol->sector_size);
876 ntfs_error(vol->sb, "Cannot handle 64-bit clusters. Sorry.");
879 vol->nr_clusters = ll;
880 ntfs_debug("vol->nr_clusters = 0x%llx", (long long)vol->nr_clusters);
887 if ((ll << vol->cluster_size_bits) >= (1ULL << 41)) {
888 ntfs_error(vol->sb, "Volume size (%lluTiB) is too "
892 vol->cluster_size_bits));
897 if (ll >= vol->nr_clusters) {
898 ntfs_error(vol->sb, "MFT LCN (%lli, 0x%llx) is beyond end of "
903 vol->mft_lcn = ll;
904 ntfs_debug("vol->mft_lcn = 0x%llx", (long long)vol->mft_lcn);
906 if (ll >= vol->nr_clusters) {
907 ntfs_error(vol->sb, "MFTMirr LCN (%lli, 0x%llx) is beyond end "
912 vol->mftmirr_lcn = ll;
913 ntfs_debug("vol->mftmirr_lcn = 0x%llx", (long long)vol->mftmirr_lcn);
923 if (vol->cluster_size <= (4 << vol->mft_record_size_bits))
924 vol->mftmirr_size = 4;
926 vol->mftmirr_size = vol->cluster_size >>
927 vol->mft_record_size_bits;
928 ntfs_debug("vol->mftmirr_size = %i", vol->mftmirr_size);
930 vol->serial_no = le64_to_cpu(b->volume_serial_number);
931 ntfs_debug("vol->serial_no = 0x%llx",
932 (unsigned long long)vol->serial_no);
938 * @vol: volume structure for which to setup the allocators
942 static void ntfs_setup_allocators(ntfs_volume *vol)
948 ntfs_debug("vol->mft_zone_multiplier = 0x%x",
949 vol->mft_zone_multiplier);
952 mft_zone_size = vol->nr_clusters;
953 switch (vol->mft_zone_multiplier) { /* % of volume size in clusters */
970 vol->mft_zone_start = vol->mft_zone_pos = vol->mft_lcn;
971 ntfs_debug("vol->mft_zone_pos = 0x%llx",
972 (unsigned long long)vol->mft_zone_pos);
982 mft_lcn = (8192 + 2 * vol->cluster_size - 1) / vol->cluster_size;
983 if (mft_lcn * vol->cluster_size < 16 * 1024)
984 mft_lcn = (16 * 1024 + vol->cluster_size - 1) /
985 vol->cluster_size;
986 if (vol->mft_zone_start <= mft_lcn)
987 vol->mft_zone_start = 0;
988 ntfs_debug("vol->mft_zone_start = 0x%llx",
989 (unsigned long long)vol->mft_zone_start);
995 vol->mft_zone_end = vol->mft_lcn + mft_zone_size;
996 while (vol->mft_zone_end >= vol->nr_clusters) {
998 vol->mft_zone_end = vol->mft_lcn + mft_zone_size;
1000 ntfs_debug("vol->mft_zone_end = 0x%llx",
1001 (unsigned long long)vol->mft_zone_end);
1006 vol->data1_zone_pos = vol->mft_zone_end;
1007 ntfs_debug("vol->data1_zone_pos = 0x%llx",
1008 (unsigned long long)vol->data1_zone_pos);
1009 vol->data2_zone_pos = 0;
1010 ntfs_debug("vol->data2_zone_pos = 0x%llx",
1011 (unsigned long long)vol->data2_zone_pos);
1014 vol->mft_data_pos = 24;
1015 ntfs_debug("vol->mft_data_pos = 0x%llx",
1016 (unsigned long long)vol->mft_data_pos);
1024 * @vol: ntfs super block describing device whose mft mirror to load
1028 static bool load_and_init_mft_mirror(ntfs_volume *vol)
1035 tmp_ino = ntfs_iget(vol->sb, FILE_MFTMirr);
1064 tmp_ni->itype.index.block_size = vol->mft_record_size;
1065 tmp_ni->itype.index.block_size_bits = vol->mft_record_size_bits;
1066 vol->mftmirr_ino = tmp_ino;
1073 * @vol: ntfs super block describing device whose mft mirror to check
1081 static bool check_mft_mirror(ntfs_volume *vol)
1083 struct super_block *sb = vol->sb;
1093 mrecs_per_page = PAGE_SIZE / vol->mft_record_size;
1095 BUG_ON(!vol->mftmirr_size);
1109 mft_page = ntfs_map_page(vol->mft_ino->i_mapping,
1117 mirr_page = ntfs_map_page(vol->mftmirr_ino->i_mapping,
1152 bytes > vol->mft_record_size ||
1156 bytes > vol->mft_record_size ||
1158 bytes = vol->mft_record_size;
1166 kmft += vol->mft_record_size;
1167 kmirr += vol->mft_record_size;
1168 } while (++i < vol->mftmirr_size);
1175 rl2[0].lcn = vol->mftmirr_lcn;
1176 rl2[0].length = (vol->mftmirr_size * vol->mft_record_size +
1177 vol->cluster_size - 1) / vol->cluster_size;
1185 mirr_ni = NTFS_I(vol->mftmirr_ino);
1206 * @vol: ntfs super block describing device whose logfile to load
1210 static bool load_and_check_logfile(ntfs_volume *vol,
1216 tmp_ino = ntfs_iget(vol->sb, FILE_LogFile);
1229 vol->logfile_ino = tmp_ino;
1238 * @vol: ntfs super block of device to check
1240 * Check if Windows is hibernated on the ntfs volume @vol. This is done by
1260 static int check_windows_hibernation_status(ntfs_volume *vol)
1281 inode_lock(vol->root_ino);
1282 mref = ntfs_lookup_inode_by_name(NTFS_I(vol->root_ino), hiberfil, 12,
1284 inode_unlock(vol->root_ino);
1294 ntfs_error(vol->sb, "Failed to find inode number for "
1301 vi = ntfs_iget(vol->sb, MREF(mref));
1305 ntfs_error(vol->sb, "Failed to load hiberfil.sys.");
1316 ntfs_error(vol->sb, "Failed to read from hiberfil.sys.");
1352 * @vol: ntfs super block describing device whose quota file to load
1355 * leave vol->quota_ino as NULL and return success.
1357 static bool load_and_init_quota(ntfs_volume *vol)
1374 inode_lock(vol->extend_ino);
1375 mref = ntfs_lookup_inode_by_name(NTFS_I(vol->extend_ino), Quota, 6,
1377 inode_unlock(vol->extend_ino);
1390 NVolSetQuotaOutOfDate(vol);
1394 ntfs_error(vol->sb, "Failed to find inode number for $Quota.");
1400 tmp_ino = ntfs_iget(vol->sb, MREF(mref));
1404 ntfs_error(vol->sb, "Failed to load $Quota.");
1407 vol->quota_ino = tmp_ino;
1409 tmp_ino = ntfs_index_iget(vol->quota_ino, Q, 2);
1411 ntfs_error(vol->sb, "Failed to load $Quota/$Q index.");
1414 vol->quota_q_ino = tmp_ino;
1421 * @vol: ntfs super block describing device whose usnjrnl file to load
1433 static bool load_and_init_usnjrnl(ntfs_volume *vol)
1457 inode_lock(vol->extend_ino);
1458 mref = ntfs_lookup_inode_by_name(NTFS_I(vol->extend_ino), UsnJrnl, 8,
1460 inode_unlock(vol->extend_ino);
1474 NVolSetUsnJrnlStamped(vol);
1478 ntfs_error(vol->sb, "Failed to find inode number for "
1485 tmp_ino = ntfs_iget(vol->sb, MREF(mref));
1489 ntfs_error(vol->sb, "Failed to load $UsnJrnl.");
1492 vol->usnjrnl_ino = tmp_ino;
1497 if (unlikely(vol->vol_flags & VOLUME_DELETE_USN_UNDERWAY)) {
1504 tmp_ino = ntfs_attr_iget(vol->usnjrnl_ino, AT_DATA, Max, 4);
1506 ntfs_error(vol->sb, "Failed to load $UsnJrnl/$DATA/$Max "
1510 vol->usnjrnl_max_ino = tmp_ino;
1512 ntfs_error(vol->sb, "Found corrupt $UsnJrnl/$DATA/$Max "
1519 tmp_ino = ntfs_attr_iget(vol->usnjrnl_ino, AT_DATA, J, 2);
1521 ntfs_error(vol->sb, "Failed to load $UsnJrnl/$DATA/$J "
1525 vol->usnjrnl_j_ino = tmp_ino;
1527 tmp_ni = NTFS_I(vol->usnjrnl_j_ino);
1529 ntfs_error(vol->sb, "$UsnJrnl/$DATA/$J attribute is resident "
1534 page = ntfs_map_page(vol->usnjrnl_max_ino->i_mapping, 0);
1536 ntfs_error(vol->sb, "Failed to read from $UsnJrnl/$DATA/$Max "
1544 ntfs_error(vol->sb, "Allocation delta (0x%llx) exceeds "
1556 i_size_read(vol->usnjrnl_j_ino))) {
1558 i_size_read(vol->usnjrnl_j_ino))) {
1567 ntfs_error(vol->sb, "$UsnJrnl has lowest valid usn (0x%llx) "
1571 i_size_read(vol->usnjrnl_j_ino));
1582 * @vol: ntfs super block describing device whose attrdef to load
1586 static bool load_and_init_attrdef(ntfs_volume *vol)
1589 struct super_block *sb = vol->sb;
1596 /* Read attrdef table and setup vol->attrdef and vol->attrdef_size. */
1608 vol->attrdef = (ATTR_DEF*)ntfs_malloc_nofs(i_size);
1609 if (!vol->attrdef)
1620 memcpy((u8*)vol->attrdef + (index++ << PAGE_SHIFT),
1629 vol->attrdef_size = i_size;
1634 ntfs_free(vol->attrdef);
1635 vol->attrdef = NULL;
1647 * @vol: ntfs super block describing device whose upcase to load
1651 static bool load_and_init_upcase(ntfs_volume *vol)
1654 struct super_block *sb = vol->sb;
1662 /* Read upcase table and setup vol->upcase and vol->upcase_len. */
1677 vol->upcase = (ntfschar*)ntfs_malloc_nofs(i_size);
1678 if (!vol->upcase)
1689 memcpy((char*)vol->upcase + (index++ << PAGE_SHIFT),
1698 vol->upcase_len = i_size >> UCHAR_T_SIZE_BITS;
1710 if (max > vol->upcase_len)
1711 max = vol->upcase_len;
1713 if (vol->upcase[i] != default_upcase[i])
1716 ntfs_free(vol->upcase);
1717 vol->upcase = default_upcase;
1718 vol->upcase_len = max;
1731 ntfs_free(vol->upcase);
1732 vol->upcase = NULL;
1736 vol->upcase = default_upcase;
1737 vol->upcase_len = default_upcase_len;
1759 * @vol: ntfs super block describing device whose system files to load
1762 * the ntfs super block @vol.
1766 static bool load_system_files(ntfs_volume *vol)
1768 struct super_block *sb = vol->sb;
1780 if (!load_and_init_mft_mirror(vol) || !check_mft_mirror(vol)) {
1787 if (!(vol->on_errors & (ON_ERRORS_REMOUNT_RO |
1792 !vol->mftmirr_ino ? es1 : es2,
1798 !vol->mftmirr_ino ? es1 : es2, es3);
1802 !vol->mftmirr_ino ? es1 : es2, es3);
1804 NVolSetErrors(vol);
1808 vol->mftbmp_ino = ntfs_attr_iget(vol->mft_ino, AT_BITMAP, NULL, 0);
1809 if (IS_ERR(vol->mftbmp_ino)) {
1813 lockdep_set_class(&NTFS_I(vol->mftbmp_ino)->runlist.lock,
1815 lockdep_set_class(&NTFS_I(vol->mftbmp_ino)->mrec_lock,
1817 /* Read upcase table and setup @vol->upcase and @vol->upcase_len. */
1818 if (!load_and_init_upcase(vol))
1822 * Read attribute definitions table and setup @vol->attrdef and
1823 * @vol->attrdef_size.
1825 if (!load_and_init_attrdef(vol))
1833 vol->lcnbmp_ino = ntfs_iget(sb, FILE_Bitmap);
1834 if (IS_ERR(vol->lcnbmp_ino) || is_bad_inode(vol->lcnbmp_ino)) {
1835 if (!IS_ERR(vol->lcnbmp_ino))
1836 iput(vol->lcnbmp_ino);
1839 lockdep_set_class(&NTFS_I(vol->lcnbmp_ino)->runlist.lock,
1841 lockdep_set_class(&NTFS_I(vol->lcnbmp_ino)->mrec_lock,
1844 NInoSetSparseDisabled(NTFS_I(vol->lcnbmp_ino));
1845 if ((vol->nr_clusters + 7) >> 3 > i_size_read(vol->lcnbmp_ino)) {
1846 iput(vol->lcnbmp_ino);
1855 vol->vol_ino = ntfs_iget(sb, FILE_Volume);
1856 if (IS_ERR(vol->vol_ino) || is_bad_inode(vol->vol_ino)) {
1857 if (!IS_ERR(vol->vol_ino))
1858 iput(vol->vol_ino);
1863 m = map_mft_record(NTFS_I(vol->vol_ino));
1866 iput(vol->vol_ino);
1869 if (!(ctx = ntfs_attr_get_search_ctx(NTFS_I(vol->vol_ino), m))) {
1878 unmap_mft_record(NTFS_I(vol->vol_ino));
1889 vol->vol_flags = vi->flags;
1890 vol->major_ver = vi->major_ver;
1891 vol->minor_ver = vi->minor_ver;
1893 unmap_mft_record(NTFS_I(vol->vol_ino));
1894 pr_info("volume version %i.%i.\n", vol->major_ver,
1895 vol->minor_ver);
1896 if (vol->major_ver < 3 && NVolSparseEnabled(vol)) {
1897 ntfs_warning(vol->sb, "Disabling sparse support due to NTFS "
1899 "3.0).", vol->major_ver, vol->minor_ver);
1900 NVolClearSparseEnabled(vol);
1904 if (vol->vol_flags & VOLUME_MUST_MOUNT_RO_MASK) {
1913 if (vol->vol_flags & VOLUME_IS_DIRTY)
1915 else if (vol->vol_flags & VOLUME_MODIFIED_BY_CHKDSK) {
1922 (unsigned)le16_to_cpu(vol->vol_flags));
1926 if (!(vol->on_errors & (ON_ERRORS_REMOUNT_RO |
1949 if (!load_and_check_logfile(vol, &rp) ||
1950 !ntfs_is_logfile_clean(vol->logfile_ino, rp)) {
1956 es1 = !vol->logfile_ino ? es1a : es1b;
1959 if (!(vol->on_errors & (ON_ERRORS_REMOUNT_RO |
1965 if (vol->logfile_ino) {
1977 NVolSetErrors(vol);
1982 vol->root_ino = ntfs_iget(sb, FILE_root);
1983 if (IS_ERR(vol->root_ino) || is_bad_inode(vol->root_ino)) {
1984 if (!IS_ERR(vol->root_ino))
1985 iput(vol->root_ino);
1997 err = check_windows_hibernation_status(vol);
2008 if (!(vol->on_errors & (ON_ERRORS_REMOUNT_RO |
2022 NVolSetErrors(vol);
2025 if (!sb_rdonly(sb) && ntfs_set_volume_flags(vol, VOLUME_IS_DIRTY)) {
2031 if (!(vol->on_errors & (ON_ERRORS_REMOUNT_RO |
2052 if (!(sb->s_flags & SB_RDONLY) && (vol->major_ver > 1) &&
2053 ntfs_set_volume_flags(vol, VOLUME_MOUNTED_ON_NT4)) {
2058 if (!(vol->on_errors & (ON_ERRORS_REMOUNT_RO |
2067 NVolSetErrors(vol);
2071 if (!sb_rdonly(sb) && !ntfs_empty_logfile(vol->logfile_ino)) {
2076 if (!(vol->on_errors & (ON_ERRORS_REMOUNT_RO |
2085 NVolSetErrors(vol);
2089 if (unlikely(vol->major_ver < 3))
2093 vol->secure_ino = ntfs_iget(sb, FILE_Secure);
2094 if (IS_ERR(vol->secure_ino) || is_bad_inode(vol->secure_ino)) {
2095 if (!IS_ERR(vol->secure_ino))
2096 iput(vol->secure_ino);
2102 vol->extend_ino = ntfs_iget(sb, FILE_Extend);
2103 if (IS_ERR(vol->extend_ino) || is_bad_inode(vol->extend_ino) ||
2104 !S_ISDIR(vol->extend_ino->i_mode)) {
2105 if (!IS_ERR(vol->extend_ino))
2106 iput(vol->extend_ino);
2112 if (!load_and_init_quota(vol)) {
2118 if (!(vol->on_errors & (ON_ERRORS_REMOUNT_RO |
2132 NVolSetErrors(vol);
2135 if (!sb_rdonly(sb) && !ntfs_mark_quotas_out_of_date(vol)) {
2140 if (!(vol->on_errors & (ON_ERRORS_REMOUNT_RO |
2149 NVolSetErrors(vol);
2155 if (!load_and_init_usnjrnl(vol)) {
2161 if (!(vol->on_errors & (ON_ERRORS_REMOUNT_RO |
2175 NVolSetErrors(vol);
2178 if (!sb_rdonly(sb) && !ntfs_stamp_usnjrnl(vol)) {
2184 if (!(vol->on_errors & (ON_ERRORS_REMOUNT_RO |
2193 NVolSetErrors(vol);
2199 iput(vol->usnjrnl_j_ino);
2200 iput(vol->usnjrnl_max_ino);
2201 iput(vol->usnjrnl_ino);
2203 iput(vol->quota_q_ino);
2204 iput(vol->quota_ino);
2205 iput(vol->extend_ino);
2208 iput(vol->secure_ino);
2210 iput(vol->root_ino);
2213 iput(vol->logfile_ino);
2216 iput(vol->vol_ino);
2218 iput(vol->lcnbmp_ino);
2220 vol->attrdef_size = 0;
2221 if (vol->attrdef) {
2222 ntfs_free(vol->attrdef);
2223 vol->attrdef = NULL;
2228 vol->upcase_len = 0;
2230 if (vol->upcase == default_upcase) {
2232 vol->upcase = NULL;
2235 if (vol->upcase) {
2236 ntfs_free(vol->upcase);
2237 vol->upcase = NULL;
2240 iput(vol->mftbmp_ino);
2243 iput(vol->mftmirr_ino);
2259 ntfs_volume *vol = NTFS_SB(sb);
2268 ntfs_commit_inode(vol->vol_ino);
2271 if (vol->major_ver >= 3) {
2272 if (vol->usnjrnl_j_ino)
2273 ntfs_commit_inode(vol->usnjrnl_j_ino);
2274 if (vol->usnjrnl_max_ino)
2275 ntfs_commit_inode(vol->usnjrnl_max_ino);
2276 if (vol->usnjrnl_ino)
2277 ntfs_commit_inode(vol->usnjrnl_ino);
2278 if (vol->quota_q_ino)
2279 ntfs_commit_inode(vol->quota_q_ino);
2280 if (vol->quota_ino)
2281 ntfs_commit_inode(vol->quota_ino);
2282 if (vol->extend_ino)
2283 ntfs_commit_inode(vol->extend_ino);
2284 if (vol->secure_ino)
2285 ntfs_commit_inode(vol->secure_ino);
2288 ntfs_commit_inode(vol->root_ino);
2290 down_write(&vol->lcnbmp_lock);
2291 ntfs_commit_inode(vol->lcnbmp_ino);
2292 up_write(&vol->lcnbmp_lock);
2294 down_write(&vol->mftbmp_lock);
2295 ntfs_commit_inode(vol->mftbmp_ino);
2296 up_write(&vol->mftbmp_lock);
2298 if (vol->logfile_ino)
2299 ntfs_commit_inode(vol->logfile_ino);
2301 if (vol->mftmirr_ino)
2302 ntfs_commit_inode(vol->mftmirr_ino);
2303 ntfs_commit_inode(vol->mft_ino);
2310 if (!NVolErrors(vol)) {
2311 if (ntfs_clear_volume_flags(vol, VOLUME_IS_DIRTY))
2315 ntfs_commit_inode(vol->vol_ino);
2316 ntfs_commit_inode(vol->root_ino);
2317 if (vol->mftmirr_ino)
2318 ntfs_commit_inode(vol->mftmirr_ino);
2319 ntfs_commit_inode(vol->mft_ino);
2327 iput(vol->vol_ino);
2328 vol->vol_ino = NULL;
2331 if (vol->major_ver >= 3) {
2333 if (vol->usnjrnl_j_ino) {
2334 iput(vol->usnjrnl_j_ino);
2335 vol->usnjrnl_j_ino = NULL;
2337 if (vol->usnjrnl_max_ino) {
2338 iput(vol->usnjrnl_max_ino);
2339 vol->usnjrnl_max_ino = NULL;
2341 if (vol->usnjrnl_ino) {
2342 iput(vol->usnjrnl_ino);
2343 vol->usnjrnl_ino = NULL;
2345 if (vol->quota_q_ino) {
2346 iput(vol->quota_q_ino);
2347 vol->quota_q_ino = NULL;
2349 if (vol->quota_ino) {
2350 iput(vol->quota_ino);
2351 vol->quota_ino = NULL;
2354 if (vol->extend_ino) {
2355 iput(vol->extend_ino);
2356 vol->extend_ino = NULL;
2358 if (vol->secure_ino) {
2359 iput(vol->secure_ino);
2360 vol->secure_ino = NULL;
2364 iput(vol->root_ino);
2365 vol->root_ino = NULL;
2367 down_write(&vol->lcnbmp_lock);
2368 iput(vol->lcnbmp_ino);
2369 vol->lcnbmp_ino = NULL;
2370 up_write(&vol->lcnbmp_lock);
2372 down_write(&vol->mftbmp_lock);
2373 iput(vol->mftbmp_ino);
2374 vol->mftbmp_ino = NULL;
2375 up_write(&vol->mftbmp_lock);
2378 if (vol->logfile_ino) {
2379 iput(vol->logfile_ino);
2380 vol->logfile_ino = NULL;
2382 if (vol->mftmirr_ino) {
2384 ntfs_commit_inode(vol->mftmirr_ino);
2385 ntfs_commit_inode(vol->mft_ino);
2386 iput(vol->mftmirr_ino);
2387 vol->mftmirr_ino = NULL;
2394 ntfs_commit_inode(vol->mft_ino);
2395 write_inode_now(vol->mft_ino, 1);
2398 iput(vol->mft_ino);
2399 vol->mft_ino = NULL;
2402 vol->attrdef_size = 0;
2403 if (vol->attrdef) {
2404 ntfs_free(vol->attrdef);
2405 vol->attrdef = NULL;
2407 vol->upcase_len = 0;
2413 if (vol->upcase == default_upcase) {
2415 vol->upcase = NULL;
2421 if (vol->cluster_size <= 4096 && !--ntfs_nr_compression_users)
2424 if (vol->upcase) {
2425 ntfs_free(vol->upcase);
2426 vol->upcase = NULL;
2429 unload_nls(vol->nls_map);
2432 kfree(vol);
2437 * @vol: ntfs volume for which to obtain free cluster count
2439 * Calculate the number of free clusters on the mounted NTFS volume @vol. We
2454 static s64 get_nr_free_clusters(ntfs_volume *vol)
2456 s64 nr_free = vol->nr_clusters;
2457 struct address_space *mapping = vol->lcnbmp_ino->i_mapping;
2463 down_read(&vol->lcnbmp_lock);
2469 max_index = (((vol->nr_clusters + 7) >> 3) + PAGE_SIZE - 1) >>
2507 if (vol->nr_clusters & 63)
2508 nr_free += 64 - (vol->nr_clusters & 63);
2509 up_read(&vol->lcnbmp_lock);
2519 * @vol: ntfs volume for which to obtain free inode count
2524 * volume @vol. We actually calculate the number of mft records in use instead
2534 static unsigned long __get_nr_free_mft_records(ntfs_volume *vol,
2537 struct address_space *mapping = vol->mftbmp_ino->i_mapping;
2604 ntfs_volume *vol = NTFS_SB(sb);
2605 ntfs_inode *mft_ni = NTFS_I(vol->mft_ino);
2619 sfs->f_blocks = vol->nr_clusters << vol->cluster_size_bits >>
2622 size = get_nr_free_clusters(vol) << vol->cluster_size_bits >>
2629 down_read(&vol->mftbmp_lock);
2631 size = i_size_read(vol->mft_ino) >> vol->mft_record_size_bits;
2637 max_index = ((((mft_ni->initialized_size >> vol->mft_record_size_bits)
2643 sfs->f_ffree = __get_nr_free_mft_records(vol, size, max_index);
2644 up_read(&vol->mftbmp_lock);
2655 sfs->f_fsid = u64_to_fsid(vol->serial_no);
2707 ntfs_volume *vol;
2729 vol = NTFS_SB(sb);
2730 if (!vol) {
2738 *vol = (ntfs_volume) {
2749 init_rwsem(&vol->mftbmp_lock);
2750 init_rwsem(&vol->lcnbmp_lock);
2753 NVolSetSparseEnabled(vol);
2756 if (!parse_options(vol, (char*)opt))
2784 vol->nr_blocks = sb_bdev_nr_blocks(sb);
2785 if (!vol->nr_blocks) {
2800 result = parse_ntfs_boot_sector(vol, (NTFS_BOOT_SECTOR*)bh->b_data);
2817 if (vol->sector_size > blocksize) {
2818 blocksize = sb_set_blocksize(sb, vol->sector_size);
2819 if (blocksize != vol->sector_size) {
2823 vol->sector_size);
2827 vol->nr_blocks = sb_bdev_nr_blocks(sb);
2833 ntfs_setup_allocators(vol);
2873 if (vol->cluster_size <= 4096 && !ntfs_nr_compression_users++) {
2900 if (!load_system_files(vol)) {
2906 ihold(vol->root_ino);
2907 if ((sb->s_root = d_make_root(vol->root_ino))) {
2925 iput(vol->vol_ino);
2926 vol->vol_ino = NULL;
2928 if (vol->major_ver >= 3) {
2930 if (vol->usnjrnl_j_ino) {
2931 iput(vol->usnjrnl_j_ino);
2932 vol->usnjrnl_j_ino = NULL;
2934 if (vol->usnjrnl_max_ino) {
2935 iput(vol->usnjrnl_max_ino);
2936 vol->usnjrnl_max_ino = NULL;
2938 if (vol->usnjrnl_ino) {
2939 iput(vol->usnjrnl_ino);
2940 vol->usnjrnl_ino = NULL;
2942 if (vol->quota_q_ino) {
2943 iput(vol->quota_q_ino);
2944 vol->quota_q_ino = NULL;
2946 if (vol->quota_ino) {
2947 iput(vol->quota_ino);
2948 vol->quota_ino = NULL;
2951 if (vol->extend_ino) {
2952 iput(vol->extend_ino);
2953 vol->extend_ino = NULL;
2955 if (vol->secure_ino) {
2956 iput(vol->secure_ino);
2957 vol->secure_ino = NULL;
2960 iput(vol->root_ino);
2961 vol->root_ino = NULL;
2962 iput(vol->lcnbmp_ino);
2963 vol->lcnbmp_ino = NULL;
2964 iput(vol->mftbmp_ino);
2965 vol->mftbmp_ino = NULL;
2967 if (vol->logfile_ino) {
2968 iput(vol->logfile_ino);
2969 vol->logfile_ino = NULL;
2971 if (vol->mftmirr_ino) {
2972 iput(vol->mftmirr_ino);
2973 vol->mftmirr_ino = NULL;
2977 vol->attrdef_size = 0;
2978 if (vol->attrdef) {
2979 ntfs_free(vol->attrdef);
2980 vol->attrdef = NULL;
2982 vol->upcase_len = 0;
2984 if (vol->upcase == default_upcase) {
2986 vol->upcase = NULL;
2989 if (vol->upcase) {
2990 ntfs_free(vol->upcase);
2991 vol->upcase = NULL;
2993 if (vol->nls_map) {
2994 unload_nls(vol->nls_map);
2995 vol->nls_map = NULL;
3008 if (vol->cluster_size <= 4096 && !--ntfs_nr_compression_users)
3013 if (vol->mft_ino && vol->mft_ino != tmp_ino)
3014 iput(vol->mft_ino);
3015 vol->mft_ino = NULL;
3019 kfree(vol);