Lines Matching refs:vol
94 * @vol: ntfs volume
97 * Parse the recognized options in @opt for the ntfs volume described by @vol.
99 static bool parse_options(ntfs_volume *vol, char *opt)
180 ntfs_warning(vol->sb, "Ignoring obsolete option %s.",
184 ntfs_warning(vol->sb, "Option iocharset is "
195 ntfs_error(vol->sb, "NLS character set "
199 ntfs_error(vol->sb, "NLS character set %s not "
209 ntfs_warning(vol->sb, "Option utf8 is no longer "
223 ntfs_error(vol->sb, "Unrecognized mount option %s.", p);
236 ntfs_warning(vol->sb, "Sloppy option given. Ignoring "
241 ntfs_error(vol->sb, "Invalid errors option argument "
247 if (vol->nls_map && vol->nls_map != nls_map) {
248 ntfs_error(vol->sb, "Cannot change NLS character set "
251 } /* else (!vol->nls_map) */
253 vol->nls_map = nls_map;
255 if (!vol->nls_map) {
256 vol->nls_map = load_nls_default();
257 if (!vol->nls_map) {
258 ntfs_error(vol->sb, "Failed to load default "
263 vol->nls_map->charset);
267 if (vol->mft_zone_multiplier && vol->mft_zone_multiplier !=
269 ntfs_error(vol->sb, "Cannot change mft_zone_multiplier "
274 ntfs_error(vol->sb, "Invalid mft_zone_multiplier. "
278 vol->mft_zone_multiplier = mft_zone_multiplier;
280 if (!vol->mft_zone_multiplier)
281 vol->mft_zone_multiplier = 1;
283 vol->on_errors = on_errors;
284 if (!vol->on_errors || vol->on_errors == ON_ERRORS_RECOVER)
285 vol->on_errors |= ON_ERRORS_CONTINUE;
287 vol->uid = uid;
289 vol->gid = gid;
291 vol->fmask = fmask;
293 vol->dmask = dmask;
296 NVolSetShowSystemFiles(vol);
298 NVolClearShowSystemFiles(vol);
302 NVolSetCaseSensitive(vol);
304 NVolClearCaseSensitive(vol);
308 NVolClearSparseEnabled(vol);
310 if (!NVolSparseEnabled(vol) &&
311 vol->major_ver && vol->major_ver < 3)
312 ntfs_warning(vol->sb, "Not enabling sparse "
315 "version 3.0).", vol->major_ver,
316 vol->minor_ver);
318 NVolSetSparseEnabled(vol);
323 ntfs_error(vol->sb, "The %s option requires an argument.", p);
326 ntfs_error(vol->sb, "The %s option requires a boolean argument.", p);
329 ntfs_error(vol->sb, "Invalid %s option argument: %s", p, ov);
337 * @vol: ntfs volume on which to modify the flags
343 * Replace the volume information flags on the volume @vol with the value
350 static int ntfs_write_volume_flags(ntfs_volume *vol, const VOLUME_FLAGS flags)
352 ntfs_inode *ni = NTFS_I(vol->vol_ino);
359 le16_to_cpu(vol->vol_flags), le16_to_cpu(flags));
360 if (vol->vol_flags == flags)
379 vol->vol_flags = vi->flags = flags;
392 ntfs_error(vol->sb, "Failed with error code %i.", -err);
398 * @vol: ntfs volume on which to modify the flags
401 * Set the bits in @flags in the volume information flags on the volume @vol.
405 static inline int ntfs_set_volume_flags(ntfs_volume *vol, VOLUME_FLAGS flags)
408 return ntfs_write_volume_flags(vol, vol->vol_flags | flags);
413 * @vol: ntfs volume on which to modify the flags
416 * Clear the bits in @flags in the volume information flags on the volume @vol.
420 static inline int ntfs_clear_volume_flags(ntfs_volume *vol, VOLUME_FLAGS flags)
423 flags = vol->vol_flags & cpu_to_le16(~le16_to_cpu(flags));
424 return ntfs_write_volume_flags(vol, flags);
443 ntfs_volume *vol = NTFS_SB(sb);
466 if (NVolErrors(vol)) {
471 if (vol->vol_flags & VOLUME_IS_DIRTY) {
475 if (vol->vol_flags & VOLUME_MODIFIED_BY_CHKDSK) {
480 if (vol->vol_flags & VOLUME_MUST_MOUNT_RO_MASK) {
483 (unsigned)le16_to_cpu(vol->vol_flags),
487 if (ntfs_set_volume_flags(vol, VOLUME_IS_DIRTY)) {
492 if (!ntfs_empty_logfile(vol->logfile_ino)) {
495 NVolSetErrors(vol);
498 if (!ntfs_mark_quotas_out_of_date(vol)) {
501 NVolSetErrors(vol);
504 if (!ntfs_stamp_usnjrnl(vol)) {
507 NVolSetErrors(vol);
512 if (!NVolErrors(vol)) {
513 if (ntfs_clear_volume_flags(vol, VOLUME_IS_DIRTY))
523 if (!parse_options(vol, opt))
707 * parse_ntfs_boot_sector - parse the boot sector and store the data in @vol
708 * @vol: volume structure to initialise with data from boot sector
712 * the ntfs super block @vol. Return 'true' on success and 'false' on error.
714 static bool parse_ntfs_boot_sector(ntfs_volume *vol, const NTFS_BOOT_SECTOR *b)
720 vol->sector_size = le16_to_cpu(b->bpb.bytes_per_sector);
721 vol->sector_size_bits = ffs(vol->sector_size) - 1;
722 ntfs_debug("vol->sector_size = %i (0x%x)", vol->sector_size,
723 vol->sector_size);
724 ntfs_debug("vol->sector_size_bits = %i (0x%x)", vol->sector_size_bits,
725 vol->sector_size_bits);
726 if (vol->sector_size < vol->sb->s_blocksize) {
727 ntfs_error(vol->sb, "Sector size (%i) is smaller than the "
729 "supported. Sorry.", vol->sector_size,
730 vol->sb->s_blocksize);
739 vol->cluster_size = vol->sector_size << sectors_per_cluster_bits;
740 vol->cluster_size_mask = vol->cluster_size - 1;
741 vol->cluster_size_bits = ffs(vol->cluster_size) - 1;
742 ntfs_debug("vol->cluster_size = %i (0x%x)", vol->cluster_size,
743 vol->cluster_size);
744 ntfs_debug("vol->cluster_size_mask = 0x%x", vol->cluster_size_mask);
745 ntfs_debug("vol->cluster_size_bits = %i", vol->cluster_size_bits);
746 if (vol->cluster_size < vol->sector_size) {
747 ntfs_error(vol->sb, "Cluster size (%i) is smaller than the "
749 "Sorry.", vol->cluster_size, vol->sector_size);
756 vol->mft_record_size = vol->cluster_size <<
764 vol->mft_record_size = 1 << -clusters_per_mft_record;
765 vol->mft_record_size_mask = vol->mft_record_size - 1;
766 vol->mft_record_size_bits = ffs(vol->mft_record_size) - 1;
767 ntfs_debug("vol->mft_record_size = %i (0x%x)", vol->mft_record_size,
768 vol->mft_record_size);
769 ntfs_debug("vol->mft_record_size_mask = 0x%x",
770 vol->mft_record_size_mask);
771 ntfs_debug("vol->mft_record_size_bits = %i (0x%x)",
772 vol->mft_record_size_bits, vol->mft_record_size_bits);
777 if (vol->mft_record_size > PAGE_CACHE_SIZE) {
778 ntfs_error(vol->sb, "Mft record size (%i) exceeds the "
781 vol->mft_record_size, PAGE_CACHE_SIZE);
785 if (vol->mft_record_size < vol->sector_size) {
786 ntfs_error(vol->sb, "Mft record size (%i) is smaller than the "
788 "Sorry.", vol->mft_record_size,
789 vol->sector_size);
796 vol->index_record_size = vol->cluster_size <<
805 vol->index_record_size = 1 << -clusters_per_index_record;
806 vol->index_record_size_mask = vol->index_record_size - 1;
807 vol->index_record_size_bits = ffs(vol->index_record_size) - 1;
808 ntfs_debug("vol->index_record_size = %i (0x%x)",
809 vol->index_record_size, vol->index_record_size);
810 ntfs_debug("vol->index_record_size_mask = 0x%x",
811 vol->index_record_size_mask);
812 ntfs_debug("vol->index_record_size_bits = %i (0x%x)",
813 vol->index_record_size_bits,
814 vol->index_record_size_bits);
816 if (vol->index_record_size < vol->sector_size) {
817 ntfs_error(vol->sb, "Index record size (%i) is smaller than "
819 "supported. Sorry.", vol->index_record_size,
820 vol->sector_size);
830 ntfs_error(vol->sb, "Cannot handle 64-bit clusters. Sorry.");
833 vol->nr_clusters = ll;
834 ntfs_debug("vol->nr_clusters = 0x%llx", (long long)vol->nr_clusters);
841 if ((ll << vol->cluster_size_bits) >= (1ULL << 41)) {
842 ntfs_error(vol->sb, "Volume size (%lluTiB) is too "
846 vol->cluster_size_bits));
851 if (ll >= vol->nr_clusters) {
852 ntfs_error(vol->sb, "MFT LCN (%lli, 0x%llx) is beyond end of "
857 vol->mft_lcn = ll;
858 ntfs_debug("vol->mft_lcn = 0x%llx", (long long)vol->mft_lcn);
860 if (ll >= vol->nr_clusters) {
861 ntfs_error(vol->sb, "MFTMirr LCN (%lli, 0x%llx) is beyond end "
866 vol->mftmirr_lcn = ll;
867 ntfs_debug("vol->mftmirr_lcn = 0x%llx", (long long)vol->mftmirr_lcn);
877 if (vol->cluster_size <= (4 << vol->mft_record_size_bits))
878 vol->mftmirr_size = 4;
880 vol->mftmirr_size = vol->cluster_size >>
881 vol->mft_record_size_bits;
882 ntfs_debug("vol->mftmirr_size = %i", vol->mftmirr_size);
884 vol->serial_no = le64_to_cpu(b->volume_serial_number);
885 ntfs_debug("vol->serial_no = 0x%llx",
886 (unsigned long long)vol->serial_no);
892 * @vol: volume structure for which to setup the allocators
896 static void ntfs_setup_allocators(ntfs_volume *vol)
902 ntfs_debug("vol->mft_zone_multiplier = 0x%x",
903 vol->mft_zone_multiplier);
906 mft_zone_size = vol->nr_clusters;
907 switch (vol->mft_zone_multiplier) { /* % of volume size in clusters */
924 vol->mft_zone_start = vol->mft_zone_pos = vol->mft_lcn;
925 ntfs_debug("vol->mft_zone_pos = 0x%llx",
926 (unsigned long long)vol->mft_zone_pos);
936 mft_lcn = (8192 + 2 * vol->cluster_size - 1) / vol->cluster_size;
937 if (mft_lcn * vol->cluster_size < 16 * 1024)
938 mft_lcn = (16 * 1024 + vol->cluster_size - 1) /
939 vol->cluster_size;
940 if (vol->mft_zone_start <= mft_lcn)
941 vol->mft_zone_start = 0;
942 ntfs_debug("vol->mft_zone_start = 0x%llx",
943 (unsigned long long)vol->mft_zone_start);
949 vol->mft_zone_end = vol->mft_lcn + mft_zone_size;
950 while (vol->mft_zone_end >= vol->nr_clusters) {
952 vol->mft_zone_end = vol->mft_lcn + mft_zone_size;
954 ntfs_debug("vol->mft_zone_end = 0x%llx",
955 (unsigned long long)vol->mft_zone_end);
960 vol->data1_zone_pos = vol->mft_zone_end;
961 ntfs_debug("vol->data1_zone_pos = 0x%llx",
962 (unsigned long long)vol->data1_zone_pos);
963 vol->data2_zone_pos = 0;
964 ntfs_debug("vol->data2_zone_pos = 0x%llx",
965 (unsigned long long)vol->data2_zone_pos);
968 vol->mft_data_pos = 24;
969 ntfs_debug("vol->mft_data_pos = 0x%llx",
970 (unsigned long long)vol->mft_data_pos);
978 * @vol: ntfs super block describing device whose mft mirror to load
982 static bool load_and_init_mft_mirror(ntfs_volume *vol)
989 tmp_ino = ntfs_iget(vol->sb, FILE_MFTMirr);
1017 tmp_ni->itype.index.block_size = vol->mft_record_size;
1018 tmp_ni->itype.index.block_size_bits = vol->mft_record_size_bits;
1019 vol->mftmirr_ino = tmp_ino;
1026 * @vol: ntfs super block describing device whose mft mirror to check
1034 static bool check_mft_mirror(ntfs_volume *vol)
1036 struct super_block *sb = vol->sb;
1046 mrecs_per_page = PAGE_CACHE_SIZE / vol->mft_record_size;
1048 BUG_ON(!vol->mftmirr_size);
1062 mft_page = ntfs_map_page(vol->mft_ino->i_mapping,
1070 mirr_page = ntfs_map_page(vol->mftmirr_ino->i_mapping,
1105 bytes > vol->mft_record_size ||
1109 bytes > vol->mft_record_size ||
1111 bytes = vol->mft_record_size;
1119 kmft += vol->mft_record_size;
1120 kmirr += vol->mft_record_size;
1121 } while (++i < vol->mftmirr_size);
1128 rl2[0].lcn = vol->mftmirr_lcn;
1129 rl2[0].length = (vol->mftmirr_size * vol->mft_record_size +
1130 vol->cluster_size - 1) / vol->cluster_size;
1138 mirr_ni = NTFS_I(vol->mftmirr_ino);
1159 * @vol: ntfs super block describing device whose logfile to load
1163 static bool load_and_check_logfile(ntfs_volume *vol,
1169 tmp_ino = ntfs_iget(vol->sb, FILE_LogFile);
1182 vol->logfile_ino = tmp_ino;
1191 * @vol: ntfs super block of device to check
1193 * Check if Windows is hibernated on the ntfs volume @vol. This is done by
1213 static int check_windows_hibernation_status(ntfs_volume *vol)
1235 mutex_lock(&vol->root_ino->i_mutex);
1236 mref = ntfs_lookup_inode_by_name(NTFS_I(vol->root_ino), hiberfil, 12,
1238 mutex_unlock(&vol->root_ino->i_mutex);
1248 ntfs_error(vol->sb, "Failed to find inode number for "
1255 vi = ntfs_iget(vol->sb, MREF(mref));
1259 ntfs_error(vol->sb, "Failed to load hiberfil.sys.");
1271 ntfs_error(vol->sb, "Failed to read from hiberfil.sys.");
1307 * @vol: ntfs super block describing device whose quota file to load
1310 * leave vol->quota_ino as NULL and return success.
1312 static bool load_and_init_quota(ntfs_volume *vol)
1329 mutex_lock(&vol->extend_ino->i_mutex);
1330 mref = ntfs_lookup_inode_by_name(NTFS_I(vol->extend_ino), Quota, 6,
1332 mutex_unlock(&vol->extend_ino->i_mutex);
1345 NVolSetQuotaOutOfDate(vol);
1349 ntfs_error(vol->sb, "Failed to find inode number for $Quota.");
1355 tmp_ino = ntfs_iget(vol->sb, MREF(mref));
1359 ntfs_error(vol->sb, "Failed to load $Quota.");
1362 vol->quota_ino = tmp_ino;
1364 tmp_ino = ntfs_index_iget(vol->quota_ino, Q, 2);
1366 ntfs_error(vol->sb, "Failed to load $Quota/$Q index.");
1369 vol->quota_q_ino = tmp_ino;
1376 * @vol: ntfs super block describing device whose usnjrnl file to load
1388 static bool load_and_init_usnjrnl(ntfs_volume *vol)
1412 mutex_lock(&vol->extend_ino->i_mutex);
1413 mref = ntfs_lookup_inode_by_name(NTFS_I(vol->extend_ino), UsnJrnl, 8,
1415 mutex_unlock(&vol->extend_ino->i_mutex);
1429 NVolSetUsnJrnlStamped(vol);
1433 ntfs_error(vol->sb, "Failed to find inode number for "
1440 tmp_ino = ntfs_iget(vol->sb, MREF(mref));
1444 ntfs_error(vol->sb, "Failed to load $UsnJrnl.");
1447 vol->usnjrnl_ino = tmp_ino;
1452 if (unlikely(vol->vol_flags & VOLUME_DELETE_USN_UNDERWAY)) {
1459 tmp_ino = ntfs_attr_iget(vol->usnjrnl_ino, AT_DATA, Max, 4);
1461 ntfs_error(vol->sb, "Failed to load $UsnJrnl/$DATA/$Max "
1465 vol->usnjrnl_max_ino = tmp_ino;
1467 ntfs_error(vol->sb, "Found corrupt $UsnJrnl/$DATA/$Max "
1474 tmp_ino = ntfs_attr_iget(vol->usnjrnl_ino, AT_DATA, J, 2);
1476 ntfs_error(vol->sb, "Failed to load $UsnJrnl/$DATA/$J "
1480 vol->usnjrnl_j_ino = tmp_ino;
1482 tmp_ni = NTFS_I(vol->usnjrnl_j_ino);
1484 ntfs_error(vol->sb, "$UsnJrnl/$DATA/$J attribute is resident "
1489 page = ntfs_map_page(vol->usnjrnl_max_ino->i_mapping, 0);
1491 ntfs_error(vol->sb, "Failed to read from $UsnJrnl/$DATA/$Max "
1499 ntfs_error(vol->sb, "Allocation delta (0x%llx) exceeds "
1511 i_size_read(vol->usnjrnl_j_ino))) {
1513 i_size_read(vol->usnjrnl_j_ino))) {
1522 ntfs_error(vol->sb, "$UsnJrnl has lowest valid usn (0x%llx) "
1526 i_size_read(vol->usnjrnl_j_ino));
1537 * @vol: ntfs super block describing device whose attrdef to load
1541 static bool load_and_init_attrdef(ntfs_volume *vol)
1544 struct super_block *sb = vol->sb;
1551 /* Read attrdef table and setup vol->attrdef and vol->attrdef_size. */
1563 vol->attrdef = (ATTR_DEF*)ntfs_malloc_nofs(i_size);
1564 if (!vol->attrdef)
1575 memcpy((u8*)vol->attrdef + (index++ << PAGE_CACHE_SHIFT),
1584 vol->attrdef_size = i_size;
1589 ntfs_free(vol->attrdef);
1590 vol->attrdef = NULL;
1602 * @vol: ntfs super block describing device whose upcase to load
1606 static bool load_and_init_upcase(ntfs_volume *vol)
1609 struct super_block *sb = vol->sb;
1617 /* Read upcase table and setup vol->upcase and vol->upcase_len. */
1632 vol->upcase = (ntfschar*)ntfs_malloc_nofs(i_size);
1633 if (!vol->upcase)
1644 memcpy((char*)vol->upcase + (index++ << PAGE_CACHE_SHIFT),
1653 vol->upcase_len = i_size >> UCHAR_T_SIZE_BITS;
1665 if (max > vol->upcase_len)
1666 max = vol->upcase_len;
1668 if (vol->upcase[i] != default_upcase[i])
1671 ntfs_free(vol->upcase);
1672 vol->upcase = default_upcase;
1673 vol->upcase_len = max;
1686 ntfs_free(vol->upcase);
1687 vol->upcase = NULL;
1691 vol->upcase = default_upcase;
1692 vol->upcase_len = default_upcase_len;
1714 * @vol: ntfs super block describing device whose system files to load
1717 * the ntfs super block @vol.
1721 static bool load_system_files(ntfs_volume *vol)
1723 struct super_block *sb = vol->sb;
1735 if (!load_and_init_mft_mirror(vol) || !check_mft_mirror(vol)) {
1742 if (!(vol->on_errors & (ON_ERRORS_REMOUNT_RO |
1747 !vol->mftmirr_ino ? es1 : es2,
1753 !vol->mftmirr_ino ? es1 : es2, es3);
1757 !vol->mftmirr_ino ? es1 : es2, es3);
1759 NVolSetErrors(vol);
1763 vol->mftbmp_ino = ntfs_attr_iget(vol->mft_ino, AT_BITMAP, NULL, 0);
1764 if (IS_ERR(vol->mftbmp_ino)) {
1768 lockdep_set_class(&NTFS_I(vol->mftbmp_ino)->runlist.lock,
1770 lockdep_set_class(&NTFS_I(vol->mftbmp_ino)->mrec_lock,
1772 /* Read upcase table and setup @vol->upcase and @vol->upcase_len. */
1773 if (!load_and_init_upcase(vol))
1777 * Read attribute definitions table and setup @vol->attrdef and
1778 * @vol->attrdef_size.
1780 if (!load_and_init_attrdef(vol))
1788 vol->lcnbmp_ino = ntfs_iget(sb, FILE_Bitmap);
1789 if (IS_ERR(vol->lcnbmp_ino) || is_bad_inode(vol->lcnbmp_ino)) {
1790 if (!IS_ERR(vol->lcnbmp_ino))
1791 iput(vol->lcnbmp_ino);
1794 lockdep_set_class(&NTFS_I(vol->lcnbmp_ino)->runlist.lock,
1796 lockdep_set_class(&NTFS_I(vol->lcnbmp_ino)->mrec_lock,
1799 NInoSetSparseDisabled(NTFS_I(vol->lcnbmp_ino));
1800 if ((vol->nr_clusters + 7) >> 3 > i_size_read(vol->lcnbmp_ino)) {
1801 iput(vol->lcnbmp_ino);
1810 vol->vol_ino = ntfs_iget(sb, FILE_Volume);
1811 if (IS_ERR(vol->vol_ino) || is_bad_inode(vol->vol_ino)) {
1812 if (!IS_ERR(vol->vol_ino))
1813 iput(vol->vol_ino);
1818 m = map_mft_record(NTFS_I(vol->vol_ino));
1821 iput(vol->vol_ino);
1824 if (!(ctx = ntfs_attr_get_search_ctx(NTFS_I(vol->vol_ino), m))) {
1833 unmap_mft_record(NTFS_I(vol->vol_ino));
1844 vol->vol_flags = vi->flags;
1845 vol->major_ver = vi->major_ver;
1846 vol->minor_ver = vi->minor_ver;
1848 unmap_mft_record(NTFS_I(vol->vol_ino));
1849 printk(KERN_INFO "NTFS volume version %i.%i.\n", vol->major_ver,
1850 vol->minor_ver);
1851 if (vol->major_ver < 3 && NVolSparseEnabled(vol)) {
1852 ntfs_warning(vol->sb, "Disabling sparse support due to NTFS "
1854 "3.0).", vol->major_ver, vol->minor_ver);
1855 NVolClearSparseEnabled(vol);
1859 if (vol->vol_flags & VOLUME_MUST_MOUNT_RO_MASK) {
1868 if (vol->vol_flags & VOLUME_IS_DIRTY)
1870 else if (vol->vol_flags & VOLUME_MODIFIED_BY_CHKDSK) {
1877 (unsigned)le16_to_cpu(vol->vol_flags));
1881 if (!(vol->on_errors & (ON_ERRORS_REMOUNT_RO |
1904 if (!load_and_check_logfile(vol, &rp) ||
1905 !ntfs_is_logfile_clean(vol->logfile_ino, rp)) {
1911 es1 = !vol->logfile_ino ? es1a : es1b;
1914 if (!(vol->on_errors & (ON_ERRORS_REMOUNT_RO |
1920 if (vol->logfile_ino) {
1932 NVolSetErrors(vol);
1937 vol->root_ino = ntfs_iget(sb, FILE_root);
1938 if (IS_ERR(vol->root_ino) || is_bad_inode(vol->root_ino)) {
1939 if (!IS_ERR(vol->root_ino))
1940 iput(vol->root_ino);
1952 err = check_windows_hibernation_status(vol);
1963 if (!(vol->on_errors & (ON_ERRORS_REMOUNT_RO |
1977 NVolSetErrors(vol);
1981 ntfs_set_volume_flags(vol, VOLUME_IS_DIRTY)) {
1987 if (!(vol->on_errors & (ON_ERRORS_REMOUNT_RO |
2003 !ntfs_empty_logfile(vol->logfile_ino)) {
2008 if (!(vol->on_errors & (ON_ERRORS_REMOUNT_RO |
2017 NVolSetErrors(vol);
2021 if (unlikely(vol->major_ver < 3))
2025 vol->secure_ino = ntfs_iget(sb, FILE_Secure);
2026 if (IS_ERR(vol->secure_ino) || is_bad_inode(vol->secure_ino)) {
2027 if (!IS_ERR(vol->secure_ino))
2028 iput(vol->secure_ino);
2034 vol->extend_ino = ntfs_iget(sb, FILE_Extend);
2035 if (IS_ERR(vol->extend_ino) || is_bad_inode(vol->extend_ino)) {
2036 if (!IS_ERR(vol->extend_ino))
2037 iput(vol->extend_ino);
2043 if (!load_and_init_quota(vol)) {
2049 if (!(vol->on_errors & (ON_ERRORS_REMOUNT_RO |
2063 NVolSetErrors(vol);
2067 !ntfs_mark_quotas_out_of_date(vol)) {
2072 if (!(vol->on_errors & (ON_ERRORS_REMOUNT_RO |
2081 NVolSetErrors(vol);
2087 if (!load_and_init_usnjrnl(vol)) {
2093 if (!(vol->on_errors & (ON_ERRORS_REMOUNT_RO |
2107 NVolSetErrors(vol);
2110 if (!(sb->s_flags & MS_RDONLY) && !ntfs_stamp_usnjrnl(vol)) {
2116 if (!(vol->on_errors & (ON_ERRORS_REMOUNT_RO |
2125 NVolSetErrors(vol);
2131 if (vol->usnjrnl_j_ino)
2132 iput(vol->usnjrnl_j_ino);
2133 if (vol->usnjrnl_max_ino)
2134 iput(vol->usnjrnl_max_ino);
2135 if (vol->usnjrnl_ino)
2136 iput(vol->usnjrnl_ino);
2138 if (vol->quota_q_ino)
2139 iput(vol->quota_q_ino);
2140 if (vol->quota_ino)
2141 iput(vol->quota_ino);
2142 iput(vol->extend_ino);
2145 iput(vol->secure_ino);
2147 iput(vol->root_ino);
2150 if (vol->logfile_ino)
2151 iput(vol->logfile_ino);
2154 iput(vol->vol_ino);
2156 iput(vol->lcnbmp_ino);
2158 vol->attrdef_size = 0;
2159 if (vol->attrdef) {
2160 ntfs_free(vol->attrdef);
2161 vol->attrdef = NULL;
2166 vol->upcase_len = 0;
2168 if (vol->upcase == default_upcase) {
2170 vol->upcase = NULL;
2173 if (vol->upcase) {
2174 ntfs_free(vol->upcase);
2175 vol->upcase = NULL;
2178 iput(vol->mftbmp_ino);
2181 if (vol->mftmirr_ino)
2182 iput(vol->mftmirr_ino);
2198 ntfs_volume *vol = NTFS_SB(sb);
2206 ntfs_commit_inode(vol->vol_ino);
2209 if (vol->major_ver >= 3) {
2210 if (vol->usnjrnl_j_ino)
2211 ntfs_commit_inode(vol->usnjrnl_j_ino);
2212 if (vol->usnjrnl_max_ino)
2213 ntfs_commit_inode(vol->usnjrnl_max_ino);
2214 if (vol->usnjrnl_ino)
2215 ntfs_commit_inode(vol->usnjrnl_ino);
2216 if (vol->quota_q_ino)
2217 ntfs_commit_inode(vol->quota_q_ino);
2218 if (vol->quota_ino)
2219 ntfs_commit_inode(vol->quota_ino);
2220 if (vol->extend_ino)
2221 ntfs_commit_inode(vol->extend_ino);
2222 if (vol->secure_ino)
2223 ntfs_commit_inode(vol->secure_ino);
2226 ntfs_commit_inode(vol->root_ino);
2228 down_write(&vol->lcnbmp_lock);
2229 ntfs_commit_inode(vol->lcnbmp_ino);
2230 up_write(&vol->lcnbmp_lock);
2232 down_write(&vol->mftbmp_lock);
2233 ntfs_commit_inode(vol->mftbmp_ino);
2234 up_write(&vol->mftbmp_lock);
2236 if (vol->logfile_ino)
2237 ntfs_commit_inode(vol->logfile_ino);
2239 if (vol->mftmirr_ino)
2240 ntfs_commit_inode(vol->mftmirr_ino);
2241 ntfs_commit_inode(vol->mft_ino);
2248 if (!NVolErrors(vol)) {
2249 if (ntfs_clear_volume_flags(vol, VOLUME_IS_DIRTY))
2253 ntfs_commit_inode(vol->vol_ino);
2254 ntfs_commit_inode(vol->root_ino);
2255 if (vol->mftmirr_ino)
2256 ntfs_commit_inode(vol->mftmirr_ino);
2257 ntfs_commit_inode(vol->mft_ino);
2265 iput(vol->vol_ino);
2266 vol->vol_ino = NULL;
2269 if (vol->major_ver >= 3) {
2271 if (vol->usnjrnl_j_ino) {
2272 iput(vol->usnjrnl_j_ino);
2273 vol->usnjrnl_j_ino = NULL;
2275 if (vol->usnjrnl_max_ino) {
2276 iput(vol->usnjrnl_max_ino);
2277 vol->usnjrnl_max_ino = NULL;
2279 if (vol->usnjrnl_ino) {
2280 iput(vol->usnjrnl_ino);
2281 vol->usnjrnl_ino = NULL;
2283 if (vol->quota_q_ino) {
2284 iput(vol->quota_q_ino);
2285 vol->quota_q_ino = NULL;
2287 if (vol->quota_ino) {
2288 iput(vol->quota_ino);
2289 vol->quota_ino = NULL;
2292 if (vol->extend_ino) {
2293 iput(vol->extend_ino);
2294 vol->extend_ino = NULL;
2296 if (vol->secure_ino) {
2297 iput(vol->secure_ino);
2298 vol->secure_ino = NULL;
2302 iput(vol->root_ino);
2303 vol->root_ino = NULL;
2305 down_write(&vol->lcnbmp_lock);
2306 iput(vol->lcnbmp_ino);
2307 vol->lcnbmp_ino = NULL;
2308 up_write(&vol->lcnbmp_lock);
2310 down_write(&vol->mftbmp_lock);
2311 iput(vol->mftbmp_ino);
2312 vol->mftbmp_ino = NULL;
2313 up_write(&vol->mftbmp_lock);
2316 if (vol->logfile_ino) {
2317 iput(vol->logfile_ino);
2318 vol->logfile_ino = NULL;
2320 if (vol->mftmirr_ino) {
2322 ntfs_commit_inode(vol->mftmirr_ino);
2323 ntfs_commit_inode(vol->mft_ino);
2324 iput(vol->mftmirr_ino);
2325 vol->mftmirr_ino = NULL;
2334 ntfs_commit_inode(vol->mft_ino);
2335 write_inode_now(vol->mft_ino, 1);
2339 mutex_lock(&vol->mft_ino->i_mutex);
2340 truncate_inode_pages(vol->mft_ino->i_mapping, 0);
2341 mutex_unlock(&vol->mft_ino->i_mutex);
2342 write_inode_now(vol->mft_ino, 1);
2363 iput(vol->mft_ino);
2364 vol->mft_ino = NULL;
2367 vol->attrdef_size = 0;
2368 if (vol->attrdef) {
2369 ntfs_free(vol->attrdef);
2370 vol->attrdef = NULL;
2372 vol->upcase_len = 0;
2378 if (vol->upcase == default_upcase) {
2380 vol->upcase = NULL;
2386 if (vol->cluster_size <= 4096 && !--ntfs_nr_compression_users)
2389 if (vol->upcase) {
2390 ntfs_free(vol->upcase);
2391 vol->upcase = NULL;
2393 if (vol->nls_map) {
2394 unload_nls(vol->nls_map);
2395 vol->nls_map = NULL;
2398 kfree(vol);
2404 * @vol: ntfs volume for which to obtain free cluster count
2406 * Calculate the number of free clusters on the mounted NTFS volume @vol. We
2421 static s64 get_nr_free_clusters(ntfs_volume *vol)
2423 s64 nr_free = vol->nr_clusters;
2425 struct address_space *mapping = vol->lcnbmp_ino->i_mapping;
2431 down_read(&vol->lcnbmp_lock);
2437 max_index = (((vol->nr_clusters + 7) >> 3) + PAGE_CACHE_SIZE - 1) >>
2474 if (vol->nr_clusters & 63)
2475 nr_free += 64 - (vol->nr_clusters & 63);
2476 up_read(&vol->lcnbmp_lock);
2486 * @vol: ntfs volume for which to obtain free inode count
2491 * volume @vol. We actually calculate the number of mft records in use instead
2501 static unsigned long __get_nr_free_mft_records(ntfs_volume *vol,
2505 struct address_space *mapping = vol->mftbmp_ino->i_mapping;
2571 ntfs_volume *vol = NTFS_SB(sb);
2572 ntfs_inode *mft_ni = NTFS_I(vol->mft_ino);
2586 sfs->f_blocks = vol->nr_clusters << vol->cluster_size_bits >>
2589 size = get_nr_free_clusters(vol) << vol->cluster_size_bits >>
2596 down_read(&vol->mftbmp_lock);
2598 size = i_size_read(vol->mft_ino) >> vol->mft_record_size_bits;
2604 max_index = ((((mft_ni->initialized_size >> vol->mft_record_size_bits)
2610 sfs->f_ffree = __get_nr_free_mft_records(vol, size, max_index);
2611 up_read(&vol->mftbmp_lock);
2622 sfs->f_fsid.val[0] = vol->serial_no & 0xffffffff;
2623 sfs->f_fsid.val[1] = (vol->serial_no >> 32) & 0xffffffff;
2685 ntfs_volume *vol;
2707 vol = NTFS_SB(sb);
2708 if (!vol) {
2716 *vol = (ntfs_volume) {
2727 init_rwsem(&vol->mftbmp_lock);
2728 init_rwsem(&vol->lcnbmp_lock);
2733 NVolSetSparseEnabled(vol);
2736 if (!parse_options(vol, (char*)opt))
2769 vol->nr_blocks = i_size_read(sb->s_bdev->bd_inode) >>
2781 result = parse_ntfs_boot_sector(vol, (NTFS_BOOT_SECTOR*)bh->b_data);
2798 if (vol->sector_size > blocksize) {
2799 blocksize = sb_set_blocksize(sb, vol->sector_size);
2800 if (blocksize != vol->sector_size) {
2804 vol->sector_size);
2808 vol->nr_blocks = i_size_read(sb->s_bdev->bd_inode) >>
2815 ntfs_setup_allocators(vol);
2855 if (vol->cluster_size <= 4096 && !ntfs_nr_compression_users++) {
2882 if (!load_system_files(vol)) {
2886 if ((sb->s_root = d_alloc_root(vol->root_ino))) {
2888 atomic_inc(&vol->root_ino->i_count);
2906 iput(vol->vol_ino);
2907 vol->vol_ino = NULL;
2909 if (vol->major_ver >= 3) {
2911 if (vol->usnjrnl_j_ino) {
2912 iput(vol->usnjrnl_j_ino);
2913 vol->usnjrnl_j_ino = NULL;
2915 if (vol->usnjrnl_max_ino) {
2916 iput(vol->usnjrnl_max_ino);
2917 vol->usnjrnl_max_ino = NULL;
2919 if (vol->usnjrnl_ino) {
2920 iput(vol->usnjrnl_ino);
2921 vol->usnjrnl_ino = NULL;
2923 if (vol->quota_q_ino) {
2924 iput(vol->quota_q_ino);
2925 vol->quota_q_ino = NULL;
2927 if (vol->quota_ino) {
2928 iput(vol->quota_ino);
2929 vol->quota_ino = NULL;
2932 if (vol->extend_ino) {
2933 iput(vol->extend_ino);
2934 vol->extend_ino = NULL;
2936 if (vol->secure_ino) {
2937 iput(vol->secure_ino);
2938 vol->secure_ino = NULL;
2941 iput(vol->root_ino);
2942 vol->root_ino = NULL;
2943 iput(vol->lcnbmp_ino);
2944 vol->lcnbmp_ino = NULL;
2945 iput(vol->mftbmp_ino);
2946 vol->mftbmp_ino = NULL;
2948 if (vol->logfile_ino) {
2949 iput(vol->logfile_ino);
2950 vol->logfile_ino = NULL;
2952 if (vol->mftmirr_ino) {
2953 iput(vol->mftmirr_ino);
2954 vol->mftmirr_ino = NULL;
2958 vol->attrdef_size = 0;
2959 if (vol->attrdef) {
2960 ntfs_free(vol->attrdef);
2961 vol->attrdef = NULL;
2963 vol->upcase_len = 0;
2965 if (vol->upcase == default_upcase) {
2967 vol->upcase = NULL;
2970 if (vol->upcase) {
2971 ntfs_free(vol->upcase);
2972 vol->upcase = NULL;
2974 if (vol->nls_map) {
2975 unload_nls(vol->nls_map);
2976 vol->nls_map = NULL;
2989 if (vol->cluster_size <= 4096 && !--ntfs_nr_compression_users)
2994 if (vol->mft_ino && vol->mft_ino != tmp_ino)
2995 iput(vol->mft_ino);
2996 vol->mft_ino = NULL;
3008 kfree(vol);