Lines Matching refs:vol
82 * @vol: ntfs volume
85 * Parse the recognized options in @opt for the ntfs volume described by @vol.
87 static bool parse_options(ntfs_volume *vol, char *opt)
192 ntfs_warning(vol->sb, "Ignoring obsolete option %s.",
196 ntfs_warning(vol->sb, "Option iocharset is "
207 ntfs_error(vol->sb, "NLS character set "
211 ntfs_error(vol->sb, "NLS character set %s not "
220 ntfs_warning(vol->sb, "Option utf8 is no longer "
234 ntfs_error(vol->sb, "Unrecognized mount option %s.", p);
247 ntfs_warning(vol->sb, "Sloppy option given. Ignoring "
252 ntfs_error(vol->sb, "Invalid errors option argument "
258 if (vol->nls_map && vol->nls_map != nls_map) {
259 ntfs_error(vol->sb, "Cannot change NLS character set "
262 } /* else (!vol->nls_map) */
264 vol->nls_map = nls_map;
266 if (!vol->nls_map) {
267 vol->nls_map = load_nls_default();
268 if (!vol->nls_map) {
269 ntfs_error(vol->sb, "Failed to load default "
274 vol->nls_map->charset);
278 if (vol->mft_zone_multiplier && vol->mft_zone_multiplier !=
280 ntfs_error(vol->sb, "Cannot change mft_zone_multiplier "
285 ntfs_error(vol->sb, "Invalid mft_zone_multiplier. "
289 vol->mft_zone_multiplier = mft_zone_multiplier;
291 if (!vol->mft_zone_multiplier)
292 vol->mft_zone_multiplier = 1;
294 vol->on_errors = on_errors;
295 if (!vol->on_errors || vol->on_errors == ON_ERRORS_RECOVER)
296 vol->on_errors |= ON_ERRORS_CONTINUE;
298 vol->uid = uid;
300 vol->gid = gid;
302 vol->fmask = fmask;
304 vol->dmask = dmask;
307 NVolSetShowSystemFiles(vol);
309 NVolClearShowSystemFiles(vol);
313 NVolSetCaseSensitive(vol);
315 NVolClearCaseSensitive(vol);
319 NVolClearSparseEnabled(vol);
321 if (!NVolSparseEnabled(vol) &&
322 vol->major_ver && vol->major_ver < 3)
323 ntfs_warning(vol->sb, "Not enabling sparse "
326 "version 3.0).", vol->major_ver,
327 vol->minor_ver);
329 NVolSetSparseEnabled(vol);
334 ntfs_error(vol->sb, "The %s option requires an argument.", p);
337 ntfs_error(vol->sb, "The %s option requires a boolean argument.", p);
340 ntfs_error(vol->sb, "Invalid %s option argument: %s", p, ov);
348 * @vol: ntfs volume on which to modify the flags
354 * Replace the volume information flags on the volume @vol with the value
361 static int ntfs_write_volume_flags(ntfs_volume *vol, const VOLUME_FLAGS flags)
363 ntfs_inode *ni = NTFS_I(vol->vol_ino);
370 le16_to_cpu(vol->vol_flags), le16_to_cpu(flags));
371 if (vol->vol_flags == flags)
390 vol->vol_flags = vi->flags = flags;
403 ntfs_error(vol->sb, "Failed with error code %i.", -err);
409 * @vol: ntfs volume on which to modify the flags
412 * Set the bits in @flags in the volume information flags on the volume @vol.
416 static inline int ntfs_set_volume_flags(ntfs_volume *vol, VOLUME_FLAGS flags)
419 return ntfs_write_volume_flags(vol, vol->vol_flags | flags);
424 * @vol: ntfs volume on which to modify the flags
427 * Clear the bits in @flags in the volume information flags on the volume @vol.
431 static inline int ntfs_clear_volume_flags(ntfs_volume *vol, VOLUME_FLAGS flags)
434 flags = vol->vol_flags & cpu_to_le16(~le16_to_cpu(flags));
435 return ntfs_write_volume_flags(vol, flags);
454 ntfs_volume *vol = NTFS_SB(sb);
480 if (NVolErrors(vol)) {
485 if (vol->vol_flags & VOLUME_IS_DIRTY) {
489 if (vol->vol_flags & VOLUME_MODIFIED_BY_CHKDSK) {
494 if (vol->vol_flags & VOLUME_MUST_MOUNT_RO_MASK) {
497 (unsigned)le16_to_cpu(vol->vol_flags),
501 if (ntfs_set_volume_flags(vol, VOLUME_IS_DIRTY)) {
510 if ((vol->major_ver > 1)) {
511 if (ntfs_set_volume_flags(vol, VOLUME_MOUNTED_ON_NT4)) {
514 NVolSetErrors(vol);
519 if (!ntfs_empty_logfile(vol->logfile_ino)) {
522 NVolSetErrors(vol);
525 if (!ntfs_mark_quotas_out_of_date(vol)) {
528 NVolSetErrors(vol);
531 if (!ntfs_stamp_usnjrnl(vol)) {
534 NVolSetErrors(vol);
539 if (!NVolErrors(vol)) {
540 if (ntfs_clear_volume_flags(vol, VOLUME_IS_DIRTY))
550 if (!parse_options(vol, opt))
745 * parse_ntfs_boot_sector - parse the boot sector and store the data in @vol
746 * @vol: volume structure to initialise with data from boot sector
750 * the ntfs super block @vol. Return 'true' on success and 'false' on error.
752 static bool parse_ntfs_boot_sector(ntfs_volume *vol, const NTFS_BOOT_SECTOR *b)
758 vol->sector_size = le16_to_cpu(b->bpb.bytes_per_sector);
759 vol->sector_size_bits = ffs(vol->sector_size) - 1;
760 ntfs_debug("vol->sector_size = %i (0x%x)", vol->sector_size,
761 vol->sector_size);
762 ntfs_debug("vol->sector_size_bits = %i (0x%x)", vol->sector_size_bits,
763 vol->sector_size_bits);
764 if (vol->sector_size < vol->sb->s_blocksize) {
765 ntfs_error(vol->sb, "Sector size (%i) is smaller than the "
767 "supported. Sorry.", vol->sector_size,
768 vol->sb->s_blocksize);
777 vol->cluster_size = vol->sector_size << sectors_per_cluster_bits;
778 vol->cluster_size_mask = vol->cluster_size - 1;
779 vol->cluster_size_bits = ffs(vol->cluster_size) - 1;
780 ntfs_debug("vol->cluster_size = %i (0x%x)", vol->cluster_size,
781 vol->cluster_size);
782 ntfs_debug("vol->cluster_size_mask = 0x%x", vol->cluster_size_mask);
783 ntfs_debug("vol->cluster_size_bits = %i", vol->cluster_size_bits);
784 if (vol->cluster_size < vol->sector_size) {
785 ntfs_error(vol->sb, "Cluster size (%i) is smaller than the "
787 "Sorry.", vol->cluster_size, vol->sector_size);
794 vol->mft_record_size = vol->cluster_size <<
802 vol->mft_record_size = 1 << -clusters_per_mft_record;
803 vol->mft_record_size_mask = vol->mft_record_size - 1;
804 vol->mft_record_size_bits = ffs(vol->mft_record_size) - 1;
805 ntfs_debug("vol->mft_record_size = %i (0x%x)", vol->mft_record_size,
806 vol->mft_record_size);
807 ntfs_debug("vol->mft_record_size_mask = 0x%x",
808 vol->mft_record_size_mask);
809 ntfs_debug("vol->mft_record_size_bits = %i (0x%x)",
810 vol->mft_record_size_bits, vol->mft_record_size_bits);
815 if (vol->mft_record_size > PAGE_SIZE) {
816 ntfs_error(vol->sb, "Mft record size (%i) exceeds the "
819 vol->mft_record_size, PAGE_SIZE);
823 if (vol->mft_record_size < vol->sector_size) {
824 ntfs_error(vol->sb, "Mft record size (%i) is smaller than the "
826 "Sorry.", vol->mft_record_size,
827 vol->sector_size);
834 vol->index_record_size = vol->cluster_size <<
843 vol->index_record_size = 1 << -clusters_per_index_record;
844 vol->index_record_size_mask = vol->index_record_size - 1;
845 vol->index_record_size_bits = ffs(vol->index_record_size) - 1;
846 ntfs_debug("vol->index_record_size = %i (0x%x)",
847 vol->index_record_size, vol->index_record_size);
848 ntfs_debug("vol->index_record_size_mask = 0x%x",
849 vol->index_record_size_mask);
850 ntfs_debug("vol->index_record_size_bits = %i (0x%x)",
851 vol->index_record_size_bits,
852 vol->index_record_size_bits);
854 if (vol->index_record_size < vol->sector_size) {
855 ntfs_error(vol->sb, "Index record size (%i) is smaller than "
857 "supported. Sorry.", vol->index_record_size,
858 vol->sector_size);
868 ntfs_error(vol->sb, "Cannot handle 64-bit clusters. Sorry.");
871 vol->nr_clusters = ll;
872 ntfs_debug("vol->nr_clusters = 0x%llx", (long long)vol->nr_clusters);
879 if ((ll << vol->cluster_size_bits) >= (1ULL << 41)) {
880 ntfs_error(vol->sb, "Volume size (%lluTiB) is too "
884 vol->cluster_size_bits));
889 if (ll >= vol->nr_clusters) {
890 ntfs_error(vol->sb, "MFT LCN (%lli, 0x%llx) is beyond end of "
895 vol->mft_lcn = ll;
896 ntfs_debug("vol->mft_lcn = 0x%llx", (long long)vol->mft_lcn);
898 if (ll >= vol->nr_clusters) {
899 ntfs_error(vol->sb, "MFTMirr LCN (%lli, 0x%llx) is beyond end "
904 vol->mftmirr_lcn = ll;
905 ntfs_debug("vol->mftmirr_lcn = 0x%llx", (long long)vol->mftmirr_lcn);
915 if (vol->cluster_size <= (4 << vol->mft_record_size_bits))
916 vol->mftmirr_size = 4;
918 vol->mftmirr_size = vol->cluster_size >>
919 vol->mft_record_size_bits;
920 ntfs_debug("vol->mftmirr_size = %i", vol->mftmirr_size);
922 vol->serial_no = le64_to_cpu(b->volume_serial_number);
923 ntfs_debug("vol->serial_no = 0x%llx",
924 (unsigned long long)vol->serial_no);
930 * @vol: volume structure for which to setup the allocators
934 static void ntfs_setup_allocators(ntfs_volume *vol)
940 ntfs_debug("vol->mft_zone_multiplier = 0x%x",
941 vol->mft_zone_multiplier);
944 mft_zone_size = vol->nr_clusters;
945 switch (vol->mft_zone_multiplier) { /* % of volume size in clusters */
962 vol->mft_zone_start = vol->mft_zone_pos = vol->mft_lcn;
963 ntfs_debug("vol->mft_zone_pos = 0x%llx",
964 (unsigned long long)vol->mft_zone_pos);
974 mft_lcn = (8192 + 2 * vol->cluster_size - 1) / vol->cluster_size;
975 if (mft_lcn * vol->cluster_size < 16 * 1024)
976 mft_lcn = (16 * 1024 + vol->cluster_size - 1) /
977 vol->cluster_size;
978 if (vol->mft_zone_start <= mft_lcn)
979 vol->mft_zone_start = 0;
980 ntfs_debug("vol->mft_zone_start = 0x%llx",
981 (unsigned long long)vol->mft_zone_start);
987 vol->mft_zone_end = vol->mft_lcn + mft_zone_size;
988 while (vol->mft_zone_end >= vol->nr_clusters) {
990 vol->mft_zone_end = vol->mft_lcn + mft_zone_size;
992 ntfs_debug("vol->mft_zone_end = 0x%llx",
993 (unsigned long long)vol->mft_zone_end);
998 vol->data1_zone_pos = vol->mft_zone_end;
999 ntfs_debug("vol->data1_zone_pos = 0x%llx",
1000 (unsigned long long)vol->data1_zone_pos);
1001 vol->data2_zone_pos = 0;
1002 ntfs_debug("vol->data2_zone_pos = 0x%llx",
1003 (unsigned long long)vol->data2_zone_pos);
1006 vol->mft_data_pos = 24;
1007 ntfs_debug("vol->mft_data_pos = 0x%llx",
1008 (unsigned long long)vol->mft_data_pos);
1016 * @vol: ntfs super block describing device whose mft mirror to load
1020 static bool load_and_init_mft_mirror(ntfs_volume *vol)
1027 tmp_ino = ntfs_iget(vol->sb, FILE_MFTMirr);
1056 tmp_ni->itype.index.block_size = vol->mft_record_size;
1057 tmp_ni->itype.index.block_size_bits = vol->mft_record_size_bits;
1058 vol->mftmirr_ino = tmp_ino;
1065 * @vol: ntfs super block describing device whose mft mirror to check
1073 static bool check_mft_mirror(ntfs_volume *vol)
1075 struct super_block *sb = vol->sb;
1085 mrecs_per_page = PAGE_SIZE / vol->mft_record_size;
1087 BUG_ON(!vol->mftmirr_size);
1101 mft_page = ntfs_map_page(vol->mft_ino->i_mapping,
1109 mirr_page = ntfs_map_page(vol->mftmirr_ino->i_mapping,
1144 bytes > vol->mft_record_size ||
1148 bytes > vol->mft_record_size ||
1150 bytes = vol->mft_record_size;
1158 kmft += vol->mft_record_size;
1159 kmirr += vol->mft_record_size;
1160 } while (++i < vol->mftmirr_size);
1167 rl2[0].lcn = vol->mftmirr_lcn;
1168 rl2[0].length = (vol->mftmirr_size * vol->mft_record_size +
1169 vol->cluster_size - 1) / vol->cluster_size;
1177 mirr_ni = NTFS_I(vol->mftmirr_ino);
1198 * @vol: ntfs super block describing device whose logfile to load
1202 static bool load_and_check_logfile(ntfs_volume *vol,
1208 tmp_ino = ntfs_iget(vol->sb, FILE_LogFile);
1221 vol->logfile_ino = tmp_ino;
1230 * @vol: ntfs super block of device to check
1232 * Check if Windows is hibernated on the ntfs volume @vol. This is done by
1252 static int check_windows_hibernation_status(ntfs_volume *vol)
1273 inode_lock(vol->root_ino);
1274 mref = ntfs_lookup_inode_by_name(NTFS_I(vol->root_ino), hiberfil, 12,
1276 inode_unlock(vol->root_ino);
1286 ntfs_error(vol->sb, "Failed to find inode number for "
1293 vi = ntfs_iget(vol->sb, MREF(mref));
1297 ntfs_error(vol->sb, "Failed to load hiberfil.sys.");
1308 ntfs_error(vol->sb, "Failed to read from hiberfil.sys.");
1344 * @vol: ntfs super block describing device whose quota file to load
1347 * leave vol->quota_ino as NULL and return success.
1349 static bool load_and_init_quota(ntfs_volume *vol)
1366 inode_lock(vol->extend_ino);
1367 mref = ntfs_lookup_inode_by_name(NTFS_I(vol->extend_ino), Quota, 6,
1369 inode_unlock(vol->extend_ino);
1382 NVolSetQuotaOutOfDate(vol);
1386 ntfs_error(vol->sb, "Failed to find inode number for $Quota.");
1392 tmp_ino = ntfs_iget(vol->sb, MREF(mref));
1396 ntfs_error(vol->sb, "Failed to load $Quota.");
1399 vol->quota_ino = tmp_ino;
1401 tmp_ino = ntfs_index_iget(vol->quota_ino, Q, 2);
1403 ntfs_error(vol->sb, "Failed to load $Quota/$Q index.");
1406 vol->quota_q_ino = tmp_ino;
1413 * @vol: ntfs super block describing device whose usnjrnl file to load
1425 static bool load_and_init_usnjrnl(ntfs_volume *vol)
1449 inode_lock(vol->extend_ino);
1450 mref = ntfs_lookup_inode_by_name(NTFS_I(vol->extend_ino), UsnJrnl, 8,
1452 inode_unlock(vol->extend_ino);
1466 NVolSetUsnJrnlStamped(vol);
1470 ntfs_error(vol->sb, "Failed to find inode number for "
1477 tmp_ino = ntfs_iget(vol->sb, MREF(mref));
1481 ntfs_error(vol->sb, "Failed to load $UsnJrnl.");
1484 vol->usnjrnl_ino = tmp_ino;
1489 if (unlikely(vol->vol_flags & VOLUME_DELETE_USN_UNDERWAY)) {
1496 tmp_ino = ntfs_attr_iget(vol->usnjrnl_ino, AT_DATA, Max, 4);
1498 ntfs_error(vol->sb, "Failed to load $UsnJrnl/$DATA/$Max "
1502 vol->usnjrnl_max_ino = tmp_ino;
1504 ntfs_error(vol->sb, "Found corrupt $UsnJrnl/$DATA/$Max "
1511 tmp_ino = ntfs_attr_iget(vol->usnjrnl_ino, AT_DATA, J, 2);
1513 ntfs_error(vol->sb, "Failed to load $UsnJrnl/$DATA/$J "
1517 vol->usnjrnl_j_ino = tmp_ino;
1519 tmp_ni = NTFS_I(vol->usnjrnl_j_ino);
1521 ntfs_error(vol->sb, "$UsnJrnl/$DATA/$J attribute is resident "
1526 page = ntfs_map_page(vol->usnjrnl_max_ino->i_mapping, 0);
1528 ntfs_error(vol->sb, "Failed to read from $UsnJrnl/$DATA/$Max "
1536 ntfs_error(vol->sb, "Allocation delta (0x%llx) exceeds "
1548 i_size_read(vol->usnjrnl_j_ino))) {
1550 i_size_read(vol->usnjrnl_j_ino))) {
1559 ntfs_error(vol->sb, "$UsnJrnl has lowest valid usn (0x%llx) "
1563 i_size_read(vol->usnjrnl_j_ino));
1574 * @vol: ntfs super block describing device whose attrdef to load
1578 static bool load_and_init_attrdef(ntfs_volume *vol)
1581 struct super_block *sb = vol->sb;
1588 /* Read attrdef table and setup vol->attrdef and vol->attrdef_size. */
1600 vol->attrdef = (ATTR_DEF*)ntfs_malloc_nofs(i_size);
1601 if (!vol->attrdef)
1612 memcpy((u8*)vol->attrdef + (index++ << PAGE_SHIFT),
1621 vol->attrdef_size = i_size;
1626 ntfs_free(vol->attrdef);
1627 vol->attrdef = NULL;
1639 * @vol: ntfs super block describing device whose upcase to load
1643 static bool load_and_init_upcase(ntfs_volume *vol)
1646 struct super_block *sb = vol->sb;
1654 /* Read upcase table and setup vol->upcase and vol->upcase_len. */
1669 vol->upcase = (ntfschar*)ntfs_malloc_nofs(i_size);
1670 if (!vol->upcase)
1681 memcpy((char*)vol->upcase + (index++ << PAGE_SHIFT),
1690 vol->upcase_len = i_size >> UCHAR_T_SIZE_BITS;
1702 if (max > vol->upcase_len)
1703 max = vol->upcase_len;
1705 if (vol->upcase[i] != default_upcase[i])
1708 ntfs_free(vol->upcase);
1709 vol->upcase = default_upcase;
1710 vol->upcase_len = max;
1723 ntfs_free(vol->upcase);
1724 vol->upcase = NULL;
1728 vol->upcase = default_upcase;
1729 vol->upcase_len = default_upcase_len;
1751 * @vol: ntfs super block describing device whose system files to load
1754 * the ntfs super block @vol.
1758 static bool load_system_files(ntfs_volume *vol)
1760 struct super_block *sb = vol->sb;
1772 if (!load_and_init_mft_mirror(vol) || !check_mft_mirror(vol)) {
1779 if (!(vol->on_errors & (ON_ERRORS_REMOUNT_RO |
1784 !vol->mftmirr_ino ? es1 : es2,
1790 !vol->mftmirr_ino ? es1 : es2, es3);
1794 !vol->mftmirr_ino ? es1 : es2, es3);
1796 NVolSetErrors(vol);
1800 vol->mftbmp_ino = ntfs_attr_iget(vol->mft_ino, AT_BITMAP, NULL, 0);
1801 if (IS_ERR(vol->mftbmp_ino)) {
1805 lockdep_set_class(&NTFS_I(vol->mftbmp_ino)->runlist.lock,
1807 lockdep_set_class(&NTFS_I(vol->mftbmp_ino)->mrec_lock,
1809 /* Read upcase table and setup @vol->upcase and @vol->upcase_len. */
1810 if (!load_and_init_upcase(vol))
1814 * Read attribute definitions table and setup @vol->attrdef and
1815 * @vol->attrdef_size.
1817 if (!load_and_init_attrdef(vol))
1825 vol->lcnbmp_ino = ntfs_iget(sb, FILE_Bitmap);
1826 if (IS_ERR(vol->lcnbmp_ino) || is_bad_inode(vol->lcnbmp_ino)) {
1827 if (!IS_ERR(vol->lcnbmp_ino))
1828 iput(vol->lcnbmp_ino);
1831 lockdep_set_class(&NTFS_I(vol->lcnbmp_ino)->runlist.lock,
1833 lockdep_set_class(&NTFS_I(vol->lcnbmp_ino)->mrec_lock,
1836 NInoSetSparseDisabled(NTFS_I(vol->lcnbmp_ino));
1837 if ((vol->nr_clusters + 7) >> 3 > i_size_read(vol->lcnbmp_ino)) {
1838 iput(vol->lcnbmp_ino);
1847 vol->vol_ino = ntfs_iget(sb, FILE_Volume);
1848 if (IS_ERR(vol->vol_ino) || is_bad_inode(vol->vol_ino)) {
1849 if (!IS_ERR(vol->vol_ino))
1850 iput(vol->vol_ino);
1855 m = map_mft_record(NTFS_I(vol->vol_ino));
1858 iput(vol->vol_ino);
1861 if (!(ctx = ntfs_attr_get_search_ctx(NTFS_I(vol->vol_ino), m))) {
1870 unmap_mft_record(NTFS_I(vol->vol_ino));
1881 vol->vol_flags = vi->flags;
1882 vol->major_ver = vi->major_ver;
1883 vol->minor_ver = vi->minor_ver;
1885 unmap_mft_record(NTFS_I(vol->vol_ino));
1886 pr_info("volume version %i.%i.\n", vol->major_ver,
1887 vol->minor_ver);
1888 if (vol->major_ver < 3 && NVolSparseEnabled(vol)) {
1889 ntfs_warning(vol->sb, "Disabling sparse support due to NTFS "
1891 "3.0).", vol->major_ver, vol->minor_ver);
1892 NVolClearSparseEnabled(vol);
1896 if (vol->vol_flags & VOLUME_MUST_MOUNT_RO_MASK) {
1905 if (vol->vol_flags & VOLUME_IS_DIRTY)
1907 else if (vol->vol_flags & VOLUME_MODIFIED_BY_CHKDSK) {
1914 (unsigned)le16_to_cpu(vol->vol_flags));
1918 if (!(vol->on_errors & (ON_ERRORS_REMOUNT_RO |
1941 if (!load_and_check_logfile(vol, &rp) ||
1942 !ntfs_is_logfile_clean(vol->logfile_ino, rp)) {
1948 es1 = !vol->logfile_ino ? es1a : es1b;
1951 if (!(vol->on_errors & (ON_ERRORS_REMOUNT_RO |
1957 if (vol->logfile_ino) {
1969 NVolSetErrors(vol);
1974 vol->root_ino = ntfs_iget(sb, FILE_root);
1975 if (IS_ERR(vol->root_ino) || is_bad_inode(vol->root_ino)) {
1976 if (!IS_ERR(vol->root_ino))
1977 iput(vol->root_ino);
1989 err = check_windows_hibernation_status(vol);
2000 if (!(vol->on_errors & (ON_ERRORS_REMOUNT_RO |
2014 NVolSetErrors(vol);
2017 if (!sb_rdonly(sb) && ntfs_set_volume_flags(vol, VOLUME_IS_DIRTY)) {
2023 if (!(vol->on_errors & (ON_ERRORS_REMOUNT_RO |
2044 if (!(sb->s_flags & SB_RDONLY) && (vol->major_ver > 1) &&
2045 ntfs_set_volume_flags(vol, VOLUME_MOUNTED_ON_NT4)) {
2050 if (!(vol->on_errors & (ON_ERRORS_REMOUNT_RO |
2059 NVolSetErrors(vol);
2063 if (!sb_rdonly(sb) && !ntfs_empty_logfile(vol->logfile_ino)) {
2068 if (!(vol->on_errors & (ON_ERRORS_REMOUNT_RO |
2077 NVolSetErrors(vol);
2081 if (unlikely(vol->major_ver < 3))
2085 vol->secure_ino = ntfs_iget(sb, FILE_Secure);
2086 if (IS_ERR(vol->secure_ino) || is_bad_inode(vol->secure_ino)) {
2087 if (!IS_ERR(vol->secure_ino))
2088 iput(vol->secure_ino);
2094 vol->extend_ino = ntfs_iget(sb, FILE_Extend);
2095 if (IS_ERR(vol->extend_ino) || is_bad_inode(vol->extend_ino) ||
2096 !S_ISDIR(vol->extend_ino->i_mode)) {
2097 if (!IS_ERR(vol->extend_ino))
2098 iput(vol->extend_ino);
2104 if (!load_and_init_quota(vol)) {
2110 if (!(vol->on_errors & (ON_ERRORS_REMOUNT_RO |
2124 NVolSetErrors(vol);
2127 if (!sb_rdonly(sb) && !ntfs_mark_quotas_out_of_date(vol)) {
2132 if (!(vol->on_errors & (ON_ERRORS_REMOUNT_RO |
2141 NVolSetErrors(vol);
2147 if (!load_and_init_usnjrnl(vol)) {
2153 if (!(vol->on_errors & (ON_ERRORS_REMOUNT_RO |
2167 NVolSetErrors(vol);
2170 if (!sb_rdonly(sb) && !ntfs_stamp_usnjrnl(vol)) {
2176 if (!(vol->on_errors & (ON_ERRORS_REMOUNT_RO |
2185 NVolSetErrors(vol);
2191 iput(vol->usnjrnl_j_ino);
2192 iput(vol->usnjrnl_max_ino);
2193 iput(vol->usnjrnl_ino);
2195 iput(vol->quota_q_ino);
2196 iput(vol->quota_ino);
2197 iput(vol->extend_ino);
2200 iput(vol->secure_ino);
2202 iput(vol->root_ino);
2205 iput(vol->logfile_ino);
2208 iput(vol->vol_ino);
2210 iput(vol->lcnbmp_ino);
2212 vol->attrdef_size = 0;
2213 if (vol->attrdef) {
2214 ntfs_free(vol->attrdef);
2215 vol->attrdef = NULL;
2220 vol->upcase_len = 0;
2222 if (vol->upcase == default_upcase) {
2224 vol->upcase = NULL;
2227 if (vol->upcase) {
2228 ntfs_free(vol->upcase);
2229 vol->upcase = NULL;
2232 iput(vol->mftbmp_ino);
2235 iput(vol->mftmirr_ino);
2251 ntfs_volume *vol = NTFS_SB(sb);
2260 ntfs_commit_inode(vol->vol_ino);
2263 if (vol->major_ver >= 3) {
2264 if (vol->usnjrnl_j_ino)
2265 ntfs_commit_inode(vol->usnjrnl_j_ino);
2266 if (vol->usnjrnl_max_ino)
2267 ntfs_commit_inode(vol->usnjrnl_max_ino);
2268 if (vol->usnjrnl_ino)
2269 ntfs_commit_inode(vol->usnjrnl_ino);
2270 if (vol->quota_q_ino)
2271 ntfs_commit_inode(vol->quota_q_ino);
2272 if (vol->quota_ino)
2273 ntfs_commit_inode(vol->quota_ino);
2274 if (vol->extend_ino)
2275 ntfs_commit_inode(vol->extend_ino);
2276 if (vol->secure_ino)
2277 ntfs_commit_inode(vol->secure_ino);
2280 ntfs_commit_inode(vol->root_ino);
2282 down_write(&vol->lcnbmp_lock);
2283 ntfs_commit_inode(vol->lcnbmp_ino);
2284 up_write(&vol->lcnbmp_lock);
2286 down_write(&vol->mftbmp_lock);
2287 ntfs_commit_inode(vol->mftbmp_ino);
2288 up_write(&vol->mftbmp_lock);
2290 if (vol->logfile_ino)
2291 ntfs_commit_inode(vol->logfile_ino);
2293 if (vol->mftmirr_ino)
2294 ntfs_commit_inode(vol->mftmirr_ino);
2295 ntfs_commit_inode(vol->mft_ino);
2302 if (!NVolErrors(vol)) {
2303 if (ntfs_clear_volume_flags(vol, VOLUME_IS_DIRTY))
2307 ntfs_commit_inode(vol->vol_ino);
2308 ntfs_commit_inode(vol->root_ino);
2309 if (vol->mftmirr_ino)
2310 ntfs_commit_inode(vol->mftmirr_ino);
2311 ntfs_commit_inode(vol->mft_ino);
2319 iput(vol->vol_ino);
2320 vol->vol_ino = NULL;
2323 if (vol->major_ver >= 3) {
2325 if (vol->usnjrnl_j_ino) {
2326 iput(vol->usnjrnl_j_ino);
2327 vol->usnjrnl_j_ino = NULL;
2329 if (vol->usnjrnl_max_ino) {
2330 iput(vol->usnjrnl_max_ino);
2331 vol->usnjrnl_max_ino = NULL;
2333 if (vol->usnjrnl_ino) {
2334 iput(vol->usnjrnl_ino);
2335 vol->usnjrnl_ino = NULL;
2337 if (vol->quota_q_ino) {
2338 iput(vol->quota_q_ino);
2339 vol->quota_q_ino = NULL;
2341 if (vol->quota_ino) {
2342 iput(vol->quota_ino);
2343 vol->quota_ino = NULL;
2346 if (vol->extend_ino) {
2347 iput(vol->extend_ino);
2348 vol->extend_ino = NULL;
2350 if (vol->secure_ino) {
2351 iput(vol->secure_ino);
2352 vol->secure_ino = NULL;
2356 iput(vol->root_ino);
2357 vol->root_ino = NULL;
2359 down_write(&vol->lcnbmp_lock);
2360 iput(vol->lcnbmp_ino);
2361 vol->lcnbmp_ino = NULL;
2362 up_write(&vol->lcnbmp_lock);
2364 down_write(&vol->mftbmp_lock);
2365 iput(vol->mftbmp_ino);
2366 vol->mftbmp_ino = NULL;
2367 up_write(&vol->mftbmp_lock);
2370 if (vol->logfile_ino) {
2371 iput(vol->logfile_ino);
2372 vol->logfile_ino = NULL;
2374 if (vol->mftmirr_ino) {
2376 ntfs_commit_inode(vol->mftmirr_ino);
2377 ntfs_commit_inode(vol->mft_ino);
2378 iput(vol->mftmirr_ino);
2379 vol->mftmirr_ino = NULL;
2386 ntfs_commit_inode(vol->mft_ino);
2387 write_inode_now(vol->mft_ino, 1);
2390 iput(vol->mft_ino);
2391 vol->mft_ino = NULL;
2394 vol->attrdef_size = 0;
2395 if (vol->attrdef) {
2396 ntfs_free(vol->attrdef);
2397 vol->attrdef = NULL;
2399 vol->upcase_len = 0;
2405 if (vol->upcase == default_upcase) {
2407 vol->upcase = NULL;
2413 if (vol->cluster_size <= 4096 && !--ntfs_nr_compression_users)
2416 if (vol->upcase) {
2417 ntfs_free(vol->upcase);
2418 vol->upcase = NULL;
2421 unload_nls(vol->nls_map);
2424 kfree(vol);
2429 * @vol: ntfs volume for which to obtain free cluster count
2431 * Calculate the number of free clusters on the mounted NTFS volume @vol. We
2446 static s64 get_nr_free_clusters(ntfs_volume *vol)
2448 s64 nr_free = vol->nr_clusters;
2449 struct address_space *mapping = vol->lcnbmp_ino->i_mapping;
2455 down_read(&vol->lcnbmp_lock);
2461 max_index = (((vol->nr_clusters + 7) >> 3) + PAGE_SIZE - 1) >>
2499 if (vol->nr_clusters & 63)
2500 nr_free += 64 - (vol->nr_clusters & 63);
2501 up_read(&vol->lcnbmp_lock);
2511 * @vol: ntfs volume for which to obtain free inode count
2516 * volume @vol. We actually calculate the number of mft records in use instead
2526 static unsigned long __get_nr_free_mft_records(ntfs_volume *vol,
2529 struct address_space *mapping = vol->mftbmp_ino->i_mapping;
2596 ntfs_volume *vol = NTFS_SB(sb);
2597 ntfs_inode *mft_ni = NTFS_I(vol->mft_ino);
2611 sfs->f_blocks = vol->nr_clusters << vol->cluster_size_bits >>
2614 size = get_nr_free_clusters(vol) << vol->cluster_size_bits >>
2621 down_read(&vol->mftbmp_lock);
2623 size = i_size_read(vol->mft_ino) >> vol->mft_record_size_bits;
2629 max_index = ((((mft_ni->initialized_size >> vol->mft_record_size_bits)
2635 sfs->f_ffree = __get_nr_free_mft_records(vol, size, max_index);
2636 up_read(&vol->mftbmp_lock);
2647 sfs->f_fsid = u64_to_fsid(vol->serial_no);
2699 ntfs_volume *vol;
2721 vol = NTFS_SB(sb);
2722 if (!vol) {
2730 *vol = (ntfs_volume) {
2741 init_rwsem(&vol->mftbmp_lock);
2742 init_rwsem(&vol->lcnbmp_lock);
2745 NVolSetSparseEnabled(vol);
2748 if (!parse_options(vol, (char*)opt))
2781 vol->nr_blocks = i_size_read(sb->s_bdev->bd_inode) >>
2793 result = parse_ntfs_boot_sector(vol, (NTFS_BOOT_SECTOR*)bh->b_data);
2810 if (vol->sector_size > blocksize) {
2811 blocksize = sb_set_blocksize(sb, vol->sector_size);
2812 if (blocksize != vol->sector_size) {
2816 vol->sector_size);
2820 vol->nr_blocks = i_size_read(sb->s_bdev->bd_inode) >>
2827 ntfs_setup_allocators(vol);
2867 if (vol->cluster_size <= 4096 && !ntfs_nr_compression_users++) {
2894 if (!load_system_files(vol)) {
2900 ihold(vol->root_ino);
2901 if ((sb->s_root = d_make_root(vol->root_ino))) {
2919 iput(vol->vol_ino);
2920 vol->vol_ino = NULL;
2922 if (vol->major_ver >= 3) {
2924 if (vol->usnjrnl_j_ino) {
2925 iput(vol->usnjrnl_j_ino);
2926 vol->usnjrnl_j_ino = NULL;
2928 if (vol->usnjrnl_max_ino) {
2929 iput(vol->usnjrnl_max_ino);
2930 vol->usnjrnl_max_ino = NULL;
2932 if (vol->usnjrnl_ino) {
2933 iput(vol->usnjrnl_ino);
2934 vol->usnjrnl_ino = NULL;
2936 if (vol->quota_q_ino) {
2937 iput(vol->quota_q_ino);
2938 vol->quota_q_ino = NULL;
2940 if (vol->quota_ino) {
2941 iput(vol->quota_ino);
2942 vol->quota_ino = NULL;
2945 if (vol->extend_ino) {
2946 iput(vol->extend_ino);
2947 vol->extend_ino = NULL;
2949 if (vol->secure_ino) {
2950 iput(vol->secure_ino);
2951 vol->secure_ino = NULL;
2954 iput(vol->root_ino);
2955 vol->root_ino = NULL;
2956 iput(vol->lcnbmp_ino);
2957 vol->lcnbmp_ino = NULL;
2958 iput(vol->mftbmp_ino);
2959 vol->mftbmp_ino = NULL;
2961 if (vol->logfile_ino) {
2962 iput(vol->logfile_ino);
2963 vol->logfile_ino = NULL;
2965 if (vol->mftmirr_ino) {
2966 iput(vol->mftmirr_ino);
2967 vol->mftmirr_ino = NULL;
2971 vol->attrdef_size = 0;
2972 if (vol->attrdef) {
2973 ntfs_free(vol->attrdef);
2974 vol->attrdef = NULL;
2976 vol->upcase_len = 0;
2978 if (vol->upcase == default_upcase) {
2980 vol->upcase = NULL;
2983 if (vol->upcase) {
2984 ntfs_free(vol->upcase);
2985 vol->upcase = NULL;
2987 if (vol->nls_map) {
2988 unload_nls(vol->nls_map);
2989 vol->nls_map = NULL;
3002 if (vol->cluster_size <= 4096 && !--ntfs_nr_compression_users)
3007 if (vol->mft_ino && vol->mft_ino != tmp_ino)
3008 iput(vol->mft_ino);
3009 vol->mft_ino = NULL;
3013 kfree(vol);