2 * volume.c - NTFS volume handling code. Originated from the Linux-NTFS project.
4 * Copyright (c) 2000-2006 Anton Altaparmakov
5 * Copyright (c) 2002-2009 Szabolcs Szakacsits
6 * Copyright (c) 2004-2005 Richard Russon
7 * Copyright (c) 2010 Jean-Pierre Andre
9 * This program/include file is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU General Public License as published
11 * by the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
14 * This program/include file is distributed in the hope that it will be
15 * useful, but WITHOUT ANY WARRANTY; without even the implied warranty
16 * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
19 * You should have received a copy of the GNU General Public License
20 * along with this program (in the main directory of the NTFS-3G
21 * distribution in the file COPYING); if not, write to the Free Software
22 * Foundation,Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
47 #ifdef HAVE_SYS_STAT_H
72 const char *ntfs_home
=
73 "Ntfs-3g news, support and information: http://ntfs-3g.org\n";
75 static const char *invalid_ntfs_msg
=
76 "The device '%s' doesn't seem to have a valid NTFS.\n"
77 "Maybe the wrong device is used? Or the whole disk instead of a\n"
78 "partition (e.g. /dev/sda, not /dev/sda1)? Or the other way around?\n";
80 static const char *corrupt_volume_msg
=
81 "NTFS is either inconsistent, or there is a hardware fault, or it's a\n"
82 "SoftRAID/FakeRAID hardware. In the first case run chkdsk /f on Windows\n"
83 "then reboot into Windows twice. The usage of the /f parameter is very\n"
84 "important! If the device is a SoftRAID/FakeRAID then first activate\n"
85 "it and mount a different device under the /dev/mapper/ directory, (e.g.\n"
86 "/dev/mapper/nvidia_eahaabcc1). Please see the 'dmraid' documentation\n"
87 "for more details.\n";
89 static const char *hibernated_volume_msg
=
90 "The NTFS partition is hibernated. Please resume and shutdown Windows\n"
91 "properly, or mount the volume read-only with the 'ro' mount option, or\n"
92 "mount the volume read-write with the 'remove_hiberfile' mount option.\n"
93 "For example type on the command line:\n"
95 " mount -t ntfs-3g -o remove_hiberfile %s %s\n"
98 static const char *unclean_journal_msg
=
99 "Write access is denied because the disk wasn't safely powered\n"
100 "off and the 'norecover' mount option was specified.\n";
102 static const char *opened_volume_msg
=
103 "Mount is denied because the NTFS volume is already exclusively opened.\n"
104 "The volume may be already mounted, or another software may use it which\n"
105 "could be identified for example by the help of the 'fuser' command.\n";
107 static const char *fakeraid_msg
=
108 "Either the device is missing or it's powered down, or you have\n"
109 "SoftRAID hardware and must use an activated, different device under\n"
110 "/dev/mapper/, (e.g. /dev/mapper/nvidia_eahaabcc1) to mount NTFS.\n"
111 "Please see the 'dmraid' documentation for help.\n";
113 static const char *access_denied_msg
=
114 "Please check '%s' and the ntfs-3g binary permissions,\n"
115 "and the mounting user ID. More explanation is provided at\n"
116 "http://ntfs-3g.org/support.html#unprivileged\n";
119 * ntfs_volume_alloc - Create an NTFS volume object and initialise it
125 ntfs_volume
*ntfs_volume_alloc(void)
127 return ntfs_calloc(sizeof(ntfs_volume
));
130 static void ntfs_attr_free(ntfs_attr
**na
)
133 ntfs_attr_close(*na
);
138 static int ntfs_inode_free(ntfs_inode
**ni
)
143 ret
= ntfs_inode_close(*ni
);
150 static void ntfs_error_set(int *err
)
157 * __ntfs_volume_release - Destroy an NTFS volume object
164 static int __ntfs_volume_release(ntfs_volume
*v
)
168 if (ntfs_inode_free(&v
->vol_ni
))
169 ntfs_error_set(&err
);
171 * FIXME: Inodes must be synced before closing
172 * attributes, otherwise unmount could fail.
174 if (v
->lcnbmp_ni
&& NInoDirty(v
->lcnbmp_ni
))
175 ntfs_inode_sync(v
->lcnbmp_ni
);
176 ntfs_attr_free(&v
->lcnbmp_na
);
177 if (ntfs_inode_free(&v
->lcnbmp_ni
))
178 ntfs_error_set(&err
);
180 if (v
->mft_ni
&& NInoDirty(v
->mft_ni
))
181 ntfs_inode_sync(v
->mft_ni
);
182 ntfs_attr_free(&v
->mftbmp_na
);
183 ntfs_attr_free(&v
->mft_na
);
184 if (ntfs_inode_free(&v
->mft_ni
))
185 ntfs_error_set(&err
);
187 if (v
->mftmirr_ni
&& NInoDirty(v
->mftmirr_ni
))
188 ntfs_inode_sync(v
->mftmirr_ni
);
189 ntfs_attr_free(&v
->mftmirr_na
);
190 if (ntfs_inode_free(&v
->mftmirr_ni
))
191 ntfs_error_set(&err
);
194 struct ntfs_device
*dev
= v
->dev
;
196 if (dev
->d_ops
->sync(dev
))
197 ntfs_error_set(&err
);
198 if (dev
->d_ops
->close(dev
))
199 ntfs_error_set(&err
);
202 ntfs_free_lru_caches(v
);
209 return errno
? -1 : 0;
212 static void ntfs_attr_setup_flag(ntfs_inode
*ni
)
214 STANDARD_INFORMATION
*si
;
216 si
= ntfs_attr_readall(ni
, AT_STANDARD_INFORMATION
, AT_UNNAMED
, 0, NULL
);
218 ni
->flags
= si
->file_attributes
;
224 * ntfs_mft_load - load the $MFT and setup the ntfs volume with it
225 * @vol: ntfs volume whose $MFT to load
227 * Load $MFT from @vol and setup @vol with it. After calling this function the
228 * volume @vol is ready for use by all read access functions provided by the
231 * Return 0 on success and -1 on error with errno set to the error code.
233 static int ntfs_mft_load(ntfs_volume
*vol
)
235 VCN next_vcn
, last_vcn
, highest_vcn
;
237 MFT_RECORD
*mb
= NULL
;
238 ntfs_attr_search_ctx
*ctx
= NULL
;
242 /* Manually setup an ntfs_inode. */
243 vol
->mft_ni
= ntfs_inode_allocate(vol
);
244 mb
= ntfs_malloc(vol
->mft_record_size
);
245 if (!vol
->mft_ni
|| !mb
) {
246 ntfs_log_perror("Error allocating memory for $MFT");
249 vol
->mft_ni
->mft_no
= 0;
250 vol
->mft_ni
->mrec
= mb
;
251 /* Can't use any of the higher level functions yet! */
252 l
= ntfs_mst_pread(vol
->dev
, vol
->mft_lcn
<< vol
->cluster_size_bits
, 1,
253 vol
->mft_record_size
, mb
);
257 ntfs_log_perror("Error reading $MFT");
261 if (ntfs_mft_record_check(vol
, 0, mb
))
264 ctx
= ntfs_attr_get_search_ctx(vol
->mft_ni
, NULL
);
268 /* Find the $ATTRIBUTE_LIST attribute in $MFT if present. */
269 if (ntfs_attr_lookup(AT_ATTRIBUTE_LIST
, AT_UNNAMED
, 0, 0, 0, NULL
, 0,
271 if (errno
!= ENOENT
) {
272 ntfs_log_error("$MFT has corrupt attribute list.\n");
275 goto mft_has_no_attr_list
;
277 NInoSetAttrList(vol
->mft_ni
);
278 l
= ntfs_get_attribute_value_length(ctx
->attr
);
279 if (l
<= 0 || l
> 0x40000) {
280 ntfs_log_error("$MFT/$ATTR_LIST invalid length (%lld).\n",
284 vol
->mft_ni
->attr_list_size
= l
;
285 vol
->mft_ni
->attr_list
= ntfs_malloc(l
);
286 if (!vol
->mft_ni
->attr_list
)
289 l
= ntfs_get_attribute_value(vol
, ctx
->attr
, vol
->mft_ni
->attr_list
);
291 ntfs_log_error("Failed to get value of $MFT/$ATTR_LIST.\n");
294 if (l
!= vol
->mft_ni
->attr_list_size
) {
295 ntfs_log_error("Partial read of $MFT/$ATTR_LIST (%lld != "
296 "%u).\n", (long long)l
,
297 vol
->mft_ni
->attr_list_size
);
301 mft_has_no_attr_list
:
303 ntfs_attr_setup_flag(vol
->mft_ni
);
305 /* We now have a fully setup ntfs inode for $MFT in vol->mft_ni. */
307 /* Get an ntfs attribute for $MFT/$DATA and set it up, too. */
308 vol
->mft_na
= ntfs_attr_open(vol
->mft_ni
, AT_DATA
, AT_UNNAMED
, 0);
310 ntfs_log_perror("Failed to open ntfs attribute");
313 /* Read all extents from the $DATA attribute in $MFT. */
314 ntfs_attr_reinit_search_ctx(ctx
);
315 last_vcn
= vol
->mft_na
->allocated_size
>> vol
->cluster_size_bits
;
316 highest_vcn
= next_vcn
= 0;
318 while (!ntfs_attr_lookup(AT_DATA
, AT_UNNAMED
, 0, 0, next_vcn
, NULL
, 0,
320 runlist_element
*nrl
;
323 /* $MFT must be non-resident. */
324 if (!a
->non_resident
) {
325 ntfs_log_error("$MFT must be non-resident.\n");
328 /* $MFT must be uncompressed and unencrypted. */
329 if (a
->flags
& ATTR_COMPRESSION_MASK
||
330 a
->flags
& ATTR_IS_ENCRYPTED
) {
331 ntfs_log_error("$MFT must be uncompressed and "
336 * Decompress the mapping pairs array of this extent and merge
337 * the result into the existing runlist. No need for locking
338 * as we have exclusive access to the inode at this time and we
339 * are a mount in progress task, too.
341 nrl
= ntfs_mapping_pairs_decompress(vol
, a
, vol
->mft_na
->rl
);
343 ntfs_log_perror("ntfs_mapping_pairs_decompress() failed");
346 vol
->mft_na
->rl
= nrl
;
348 /* Get the lowest vcn for the next extent. */
349 highest_vcn
= sle64_to_cpu(a
->highest_vcn
);
350 next_vcn
= highest_vcn
+ 1;
352 /* Only one extent or error, which we catch below. */
356 /* Avoid endless loops due to corruption. */
357 if (next_vcn
< sle64_to_cpu(a
->lowest_vcn
)) {
358 ntfs_log_error("$MFT has corrupt attribute list.\n");
363 ntfs_log_error("$MFT/$DATA attribute not found.\n");
366 if (highest_vcn
&& highest_vcn
!= last_vcn
- 1) {
367 ntfs_log_error("Failed to load runlist for $MFT/$DATA.\n");
368 ntfs_log_error("highest_vcn = 0x%llx, last_vcn - 1 = 0x%llx\n",
369 (long long)highest_vcn
, (long long)last_vcn
- 1);
372 /* Done with the $Mft mft record. */
373 ntfs_attr_put_search_ctx(ctx
);
376 * The volume is now setup so we can use all read access functions.
378 vol
->mftbmp_na
= ntfs_attr_open(vol
->mft_ni
, AT_BITMAP
, AT_UNNAMED
, 0);
379 if (!vol
->mftbmp_na
) {
380 ntfs_log_perror("Failed to open $MFT/$BITMAP");
389 ntfs_attr_put_search_ctx(ctx
);
391 ntfs_attr_close(vol
->mft_na
);
395 ntfs_inode_close(vol
->mft_ni
);
403 * ntfs_mftmirr_load - load the $MFTMirr and setup the ntfs volume with it
404 * @vol: ntfs volume whose $MFTMirr to load
406 * Load $MFTMirr from @vol and setup @vol with it. After calling this function
407 * the volume @vol is ready for use by all write access functions provided by
408 * the ntfs library (assuming ntfs_mft_load() has been called successfully
411 * Return 0 on success and -1 on error with errno set to the error code.
413 static int ntfs_mftmirr_load(ntfs_volume
*vol
)
417 vol
->mftmirr_ni
= ntfs_inode_open(vol
, FILE_MFTMirr
);
418 if (!vol
->mftmirr_ni
) {
419 ntfs_log_perror("Failed to open inode $MFTMirr");
423 vol
->mftmirr_na
= ntfs_attr_open(vol
->mftmirr_ni
, AT_DATA
, AT_UNNAMED
, 0);
424 if (!vol
->mftmirr_na
) {
425 ntfs_log_perror("Failed to open $MFTMirr/$DATA");
429 if (ntfs_attr_map_runlist(vol
->mftmirr_na
, 0) < 0) {
430 ntfs_log_perror("Failed to map runlist of $MFTMirr/$DATA");
438 if (vol
->mftmirr_na
) {
439 ntfs_attr_close(vol
->mftmirr_na
);
440 vol
->mftmirr_na
= NULL
;
442 ntfs_inode_close(vol
->mftmirr_ni
);
443 vol
->mftmirr_ni
= NULL
;
449 * ntfs_volume_startup - allocate and setup an ntfs volume
450 * @dev: device to open
451 * @flags: optional mount flags
453 * Load, verify, and parse bootsector; load and setup $MFT and $MFTMirr. After
454 * calling this function, the volume is setup sufficiently to call all read
455 * and write access functions provided by the library.
457 * Return the allocated volume structure on success and NULL on error with
458 * errno set to the error code.
460 ntfs_volume
*ntfs_volume_startup(struct ntfs_device
*dev
, unsigned long flags
)
462 LCN mft_zone_size
, mft_lcn
;
465 NTFS_BOOT_SECTOR
*bs
;
468 if (!dev
|| !dev
->d_ops
|| !dev
->d_name
) {
470 ntfs_log_perror("%s: dev = %p", __FUNCTION__
, dev
);
474 bs
= ntfs_malloc(sizeof(NTFS_BOOT_SECTOR
));
478 /* Allocate the volume structure. */
479 vol
= ntfs_volume_alloc();
483 /* Create the default upcase table. */
484 vol
->upcase_len
= 65536;
485 vol
->upcase
= ntfs_malloc(vol
->upcase_len
* sizeof(ntfschar
));
489 ntfs_upcase_table_build(vol
->upcase
,
490 vol
->upcase_len
* sizeof(ntfschar
));
492 if (flags
& MS_RDONLY
)
493 NVolSetReadOnly(vol
);
495 /* ...->open needs bracketing to compile with glibc 2.7 */
496 if ((dev
->d_ops
->open
)(dev
, NVolReadOnly(vol
) ? O_RDONLY
: O_RDWR
)) {
497 ntfs_log_perror("Error opening '%s'", dev
->d_name
);
500 /* Attach the device to the volume. */
503 /* Now read the bootsector. */
504 br
= ntfs_pread(dev
, 0, sizeof(NTFS_BOOT_SECTOR
), bs
);
505 if (br
!= sizeof(NTFS_BOOT_SECTOR
)) {
509 ntfs_log_error("Failed to read bootsector (size=0)\n");
511 ntfs_log_perror("Error reading bootsector");
514 if (!ntfs_boot_sector_is_ntfs(bs
)) {
518 if (ntfs_boot_sector_parse(vol
, bs
) < 0)
523 /* Now set the device block size to the sector size. */
524 if (ntfs_device_block_size_set(vol
->dev
, vol
->sector_size
))
525 ntfs_log_debug("Failed to set the device block size to the "
526 "sector size. This may affect performance "
527 "but should be harmless otherwise. Error: "
528 "%s\n", strerror(errno
));
530 /* We now initialize the cluster allocator. */
532 mft_zone_size
= vol
->nr_clusters
>> 3; /* 12.5% */
534 /* Setup the mft zone. */
535 vol
->mft_zone_start
= vol
->mft_zone_pos
= vol
->mft_lcn
;
536 ntfs_log_debug("mft_zone_pos = 0x%llx\n", (long long)vol
->mft_zone_pos
);
539 * Calculate the mft_lcn for an unmodified NTFS volume (see mkntfs
540 * source) and if the actual mft_lcn is in the expected place or even
541 * further to the front of the volume, extend the mft_zone to cover the
542 * beginning of the volume as well. This is in order to protect the
543 * area reserved for the mft bitmap as well within the mft_zone itself.
544 * On non-standard volumes we don't protect it as the overhead would be
545 * higher than the speed increase we would get by doing it.
547 mft_lcn
= (8192 + 2 * vol
->cluster_size
- 1) / vol
->cluster_size
;
548 if (mft_lcn
* vol
->cluster_size
< 16 * 1024)
549 mft_lcn
= (16 * 1024 + vol
->cluster_size
- 1) /
551 if (vol
->mft_zone_start
<= mft_lcn
)
552 vol
->mft_zone_start
= 0;
553 ntfs_log_debug("mft_zone_start = 0x%llx\n", (long long)vol
->mft_zone_start
);
556 * Need to cap the mft zone on non-standard volumes so that it does
557 * not point outside the boundaries of the volume. We do this by
558 * halving the zone size until we are inside the volume.
560 vol
->mft_zone_end
= vol
->mft_lcn
+ mft_zone_size
;
561 while (vol
->mft_zone_end
>= vol
->nr_clusters
) {
563 vol
->mft_zone_end
= vol
->mft_lcn
+ mft_zone_size
;
565 ntfs_log_debug("mft_zone_end = 0x%llx\n", (long long)vol
->mft_zone_end
);
568 * Set the current position within each data zone to the start of the
571 vol
->data1_zone_pos
= vol
->mft_zone_end
;
572 ntfs_log_debug("data1_zone_pos = %lld\n", (long long)vol
->data1_zone_pos
);
573 vol
->data2_zone_pos
= 0;
574 ntfs_log_debug("data2_zone_pos = %lld\n", (long long)vol
->data2_zone_pos
);
576 /* Set the mft data allocation position to mft record 24. */
577 vol
->mft_data_pos
= 24;
580 * The cluster allocator is now fully operational.
583 /* Need to setup $MFT so we can use the library read functions. */
584 if (ntfs_mft_load(vol
) < 0) {
585 ntfs_log_perror("Failed to load $MFT");
589 /* Need to setup $MFTMirr so we can use the write functions, too. */
590 if (ntfs_mftmirr_load(vol
) < 0) {
591 ntfs_log_perror("Failed to load $MFTMirr");
599 __ntfs_volume_release(vol
);
605 * ntfs_volume_check_logfile - check logfile on target volume
606 * @vol: volume on which to check logfile
608 * Return 0 on success and -1 on error with errno set error code.
610 static int ntfs_volume_check_logfile(ntfs_volume
*vol
)
613 ntfs_attr
*na
= NULL
;
614 RESTART_PAGE_HEADER
*rp
= NULL
;
617 ni
= ntfs_inode_open(vol
, FILE_LogFile
);
619 ntfs_log_perror("Failed to open inode FILE_LogFile");
624 na
= ntfs_attr_open(ni
, AT_DATA
, AT_UNNAMED
, 0);
626 ntfs_log_perror("Failed to open $FILE_LogFile/$DATA");
631 if (!ntfs_check_logfile(na
, &rp
) || !ntfs_is_logfile_clean(na
, rp
))
636 if (ntfs_inode_close(ni
))
637 ntfs_error_set(&err
);
646 * ntfs_hiberfile_open - Find and open '/hiberfil.sys'
647 * @vol: An ntfs volume obtained from ntfs_mount
649 * Return: inode Success, hiberfil.sys is valid
650 * NULL hiberfil.sys doesn't exist or some other error occurred
652 static ntfs_inode
*ntfs_hiberfile_open(ntfs_volume
*vol
)
656 ntfs_inode
*ni_hibr
= NULL
;
657 ntfschar
*unicode
= NULL
;
659 const char *hiberfile
= "hiberfil.sys";
666 ni_root
= ntfs_inode_open(vol
, FILE_root
);
668 ntfs_log_debug("Couldn't open the root directory.\n");
672 unicode_len
= ntfs_mbstoucs(hiberfile
, &unicode
);
673 if (unicode_len
< 0) {
674 ntfs_log_perror("Couldn't convert 'hiberfil.sys' to Unicode");
678 inode
= ntfs_inode_lookup_by_name(ni_root
, unicode
, unicode_len
);
679 if (inode
== (u64
)-1) {
680 ntfs_log_debug("Couldn't find file '%s'.\n", hiberfile
);
685 ni_hibr
= ntfs_inode_open(vol
, inode
);
687 ntfs_log_debug("Couldn't open inode %lld.\n", (long long)inode
);
691 if (ntfs_inode_close(ni_root
)) {
692 ntfs_inode_close(ni_hibr
);
700 #define NTFS_HIBERFILE_HEADER_SIZE 4096
703 * ntfs_volume_check_hiberfile - check hiberfil.sys whether Windows is
704 * hibernated on the target volume
705 * @vol: volume on which to check hiberfil.sys
707 * Return: 0 if Windows isn't hibernated for sure
708 * -1 otherwise and errno is set to the appropriate value
710 int ntfs_volume_check_hiberfile(ntfs_volume
*vol
, int verbose
)
713 ntfs_attr
*na
= NULL
;
717 ni
= ntfs_hiberfile_open(vol
);
724 buf
= ntfs_malloc(NTFS_HIBERFILE_HEADER_SIZE
);
728 na
= ntfs_attr_open(ni
, AT_DATA
, AT_UNNAMED
, 0);
730 ntfs_log_perror("Failed to open hiberfil.sys data attribute");
734 bytes_read
= ntfs_attr_pread(na
, 0, NTFS_HIBERFILE_HEADER_SIZE
, buf
);
735 if (bytes_read
== -1) {
736 ntfs_log_perror("Failed to read hiberfil.sys");
739 if (bytes_read
< NTFS_HIBERFILE_HEADER_SIZE
) {
741 ntfs_log_error("Hibernated non-system partition, "
742 "refused to mount.\n");
746 if (memcmp(buf
, "hibr", 4) == 0) {
748 ntfs_log_error("Windows is hibernated, refused to mount.\n");
752 /* All right, all header bytes are zero */
759 if (ntfs_inode_close(ni
))
760 ntfs_error_set(&err
);
762 return errno
? -1 : 0;
766 * Make sure a LOGGED_UTILITY_STREAM attribute named "$TXF_DATA"
767 * on the root directory is resident.
768 * When it is non-resident, the partition cannot be mounted on Vista
769 * (see http://support.microsoft.com/kb/974729)
771 * We take care to avoid this situation, however this can be a
772 * consequence of having used an older version (including older
773 * Windows version), so we had better fix it.
775 * Returns 0 if unneeded or successful
776 * -1 if there was an error, explained by errno
779 static int fix_txf_data(ntfs_volume
*vol
)
788 ntfs_log_debug("Loading root directory\n");
789 ni
= ntfs_inode_open(vol
, FILE_root
);
791 ntfs_log_perror("Failed to open root directory");
794 /* Get the $TXF_DATA attribute */
795 na
= ntfs_attr_open(ni
, AT_LOGGED_UTILITY_STREAM
, TXF_DATA
, 9);
797 if (NAttrNonResident(na
)) {
799 * Fix the attribute by truncating, then
802 ntfs_log_debug("Making $TXF_DATA resident\n");
803 txf_data
= ntfs_attr_readall(ni
,
804 AT_LOGGED_UTILITY_STREAM
,
805 TXF_DATA
, 9, &txf_data_size
);
807 if (ntfs_attr_truncate(na
, 0)
808 || (ntfs_attr_pwrite(na
, 0,
809 txf_data_size
, txf_data
)
815 ntfs_log_error("Failed to make $TXF_DATA resident\n");
817 ntfs_log_error("$TXF_DATA made resident\n");
821 if (ntfs_inode_close(ni
)) {
822 ntfs_log_perror("Failed to close root");
830 * ntfs_device_mount - open ntfs volume
831 * @dev: device to open
832 * @flags: optional mount flags
834 * This function mounts an ntfs volume. @dev should describe the device which
835 * to mount as the ntfs volume.
837 * @flags is an optional second parameter. The same flags are used as for
838 * the mount system call (man 2 mount). Currently only the following flag
840 * MS_RDONLY - mount volume read-only
842 * The function opens the device @dev and verifies that it contains a valid
843 * bootsector. Then, it allocates an ntfs_volume structure and initializes
844 * some of the values inside the structure from the information stored in the
845 * bootsector. It proceeds to load the necessary system files and completes
846 * setting up the structure.
848 * Return the allocated volume structure on success and NULL on error with
849 * errno set to the error code.
851 ntfs_volume
*ntfs_device_mount(struct ntfs_device
*dev
, unsigned long flags
)
855 u8
*m
= NULL
, *m2
= NULL
;
856 ntfs_attr_search_ctx
*ctx
= NULL
;
860 VOLUME_INFORMATION
*vinf
;
865 vol
= ntfs_volume_startup(dev
, flags
);
869 /* Load data from $MFT and $MFTMirr and compare the contents. */
870 m
= ntfs_malloc(vol
->mftmirr_size
<< vol
->mft_record_size_bits
);
871 m2
= ntfs_malloc(vol
->mftmirr_size
<< vol
->mft_record_size_bits
);
875 l
= ntfs_attr_mst_pread(vol
->mft_na
, 0, vol
->mftmirr_size
,
876 vol
->mft_record_size
, m
);
877 if (l
!= vol
->mftmirr_size
) {
879 ntfs_log_perror("Failed to read $MFT");
881 ntfs_log_error("Failed to read $MFT, unexpected length "
882 "(%lld != %d).\n", (long long)l
,
888 l
= ntfs_attr_mst_pread(vol
->mftmirr_na
, 0, vol
->mftmirr_size
,
889 vol
->mft_record_size
, m2
);
890 if (l
!= vol
->mftmirr_size
) {
892 ntfs_log_perror("Failed to read $MFTMirr");
895 vol
->mftmirr_size
= l
;
897 ntfs_log_debug("Comparing $MFTMirr to $MFT...\n");
898 for (i
= 0; i
< vol
->mftmirr_size
; ++i
) {
899 MFT_RECORD
*mrec
, *mrec2
;
900 const char *ESTR
[12] = { "$MFT", "$MFTMirr", "$LogFile",
901 "$Volume", "$AttrDef", "root directory", "$Bitmap",
902 "$Boot", "$BadClus", "$Secure", "$UpCase", "$Extend" };
912 mrec
= (MFT_RECORD
*)(m
+ i
* vol
->mft_record_size
);
913 if (mrec
->flags
& MFT_RECORD_IN_USE
) {
914 if (ntfs_is_baad_recordp(mrec
)) {
915 ntfs_log_error("$MFT error: Incomplete multi "
916 "sector transfer detected in "
920 if (!ntfs_is_mft_recordp(mrec
)) {
921 ntfs_log_error("$MFT error: Invalid mft "
922 "record for '%s'.\n", s
);
926 mrec2
= (MFT_RECORD
*)(m2
+ i
* vol
->mft_record_size
);
927 if (mrec2
->flags
& MFT_RECORD_IN_USE
) {
928 if (ntfs_is_baad_recordp(mrec2
)) {
929 ntfs_log_error("$MFTMirr error: Incomplete "
930 "multi sector transfer "
931 "detected in '%s'.\n", s
);
934 if (!ntfs_is_mft_recordp(mrec2
)) {
935 ntfs_log_error("$MFTMirr error: Invalid mft "
936 "record for '%s'.\n", s
);
940 if (memcmp(mrec
, mrec2
, ntfs_mft_record_get_data_size(mrec
))) {
941 ntfs_log_error("$MFTMirr does not match $MFT (record "
951 /* Now load the bitmap from $Bitmap. */
952 ntfs_log_debug("Loading $Bitmap...\n");
953 vol
->lcnbmp_ni
= ntfs_inode_open(vol
, FILE_Bitmap
);
954 if (!vol
->lcnbmp_ni
) {
955 ntfs_log_perror("Failed to open inode FILE_Bitmap");
959 vol
->lcnbmp_na
= ntfs_attr_open(vol
->lcnbmp_ni
, AT_DATA
, AT_UNNAMED
, 0);
960 if (!vol
->lcnbmp_na
) {
961 ntfs_log_perror("Failed to open ntfs attribute");
965 if (vol
->lcnbmp_na
->data_size
> vol
->lcnbmp_na
->allocated_size
) {
966 ntfs_log_error("Corrupt cluster map size (%lld > %lld)\n",
967 (long long)vol
->lcnbmp_na
->data_size
,
968 (long long)vol
->lcnbmp_na
->allocated_size
);
972 /* Now load the upcase table from $UpCase. */
973 ntfs_log_debug("Loading $UpCase...\n");
974 ni
= ntfs_inode_open(vol
, FILE_UpCase
);
976 ntfs_log_perror("Failed to open inode FILE_UpCase");
979 /* Get an ntfs attribute for $UpCase/$DATA. */
980 na
= ntfs_attr_open(ni
, AT_DATA
, AT_UNNAMED
, 0);
982 ntfs_log_perror("Failed to open ntfs attribute");
986 * Note: Normally, the upcase table has a length equal to 65536
987 * 2-byte Unicode characters but allow for different cases, so no
988 * checks done. Just check we don't overflow 32-bits worth of Unicode
991 if (na
->data_size
& ~0x1ffffffffULL
) {
992 ntfs_log_error("Error: Upcase table is too big (max 32-bit "
997 if (vol
->upcase_len
!= na
->data_size
>> 1) {
998 vol
->upcase_len
= na
->data_size
>> 1;
999 /* Throw away default table. */
1001 vol
->upcase
= ntfs_malloc(na
->data_size
);
1005 /* Read in the $DATA attribute value into the buffer. */
1006 l
= ntfs_attr_pread(na
, 0, na
->data_size
, vol
->upcase
);
1007 if (l
!= na
->data_size
) {
1008 ntfs_log_error("Failed to read $UpCase, unexpected length "
1009 "(%lld != %lld).\n", (long long)l
,
1010 (long long)na
->data_size
);
1014 /* Done with the $UpCase mft record. */
1015 ntfs_attr_close(na
);
1016 if (ntfs_inode_close(ni
)) {
1017 ntfs_log_perror("Failed to close $UpCase");
1022 * Now load $Volume and set the version information and flags in the
1023 * vol structure accordingly.
1025 ntfs_log_debug("Loading $Volume...\n");
1026 vol
->vol_ni
= ntfs_inode_open(vol
, FILE_Volume
);
1028 ntfs_log_perror("Failed to open inode FILE_Volume");
1031 /* Get a search context for the $Volume/$VOLUME_INFORMATION lookup. */
1032 ctx
= ntfs_attr_get_search_ctx(vol
->vol_ni
, NULL
);
1036 /* Find the $VOLUME_INFORMATION attribute. */
1037 if (ntfs_attr_lookup(AT_VOLUME_INFORMATION
, AT_UNNAMED
, 0, 0, 0, NULL
,
1039 ntfs_log_perror("$VOLUME_INFORMATION attribute not found in "
1044 /* Has to be resident. */
1045 if (a
->non_resident
) {
1046 ntfs_log_error("Attribute $VOLUME_INFORMATION must be "
1047 "resident but it isn't.\n");
1051 /* Get a pointer to the value of the attribute. */
1052 vinf
= (VOLUME_INFORMATION
*)(le16_to_cpu(a
->value_offset
) + (char*)a
);
1053 /* Sanity checks. */
1054 if ((char*)vinf
+ le32_to_cpu(a
->value_length
) > (char*)ctx
->mrec
+
1055 le32_to_cpu(ctx
->mrec
->bytes_in_use
) ||
1056 le16_to_cpu(a
->value_offset
) + le32_to_cpu(
1057 a
->value_length
) > le32_to_cpu(a
->length
)) {
1058 ntfs_log_error("$VOLUME_INFORMATION in $Volume is corrupt.\n");
1062 /* Setup vol from the volume information attribute value. */
1063 vol
->major_ver
= vinf
->major_ver
;
1064 vol
->minor_ver
= vinf
->minor_ver
;
1065 /* Do not use le16_to_cpu() macro here as our VOLUME_FLAGS are
1066 defined using cpu_to_le16() macro and hence are consistent. */
1067 vol
->flags
= vinf
->flags
;
1069 * Reinitialize the search context for the $Volume/$VOLUME_NAME lookup.
1071 ntfs_attr_reinit_search_ctx(ctx
);
1072 if (ntfs_attr_lookup(AT_VOLUME_NAME
, AT_UNNAMED
, 0, 0, 0, NULL
, 0,
1074 if (errno
!= ENOENT
) {
1075 ntfs_log_perror("Failed to lookup of $VOLUME_NAME in "
1080 * Attribute not present. This has been seen in the field.
1081 * Treat this the same way as if the attribute was present but
1084 vol
->vol_name
= ntfs_malloc(1);
1087 vol
->vol_name
[0] = '\0';
1090 /* Has to be resident. */
1091 if (a
->non_resident
) {
1092 ntfs_log_error("$VOLUME_NAME must be resident.\n");
1096 /* Get a pointer to the value of the attribute. */
1097 vname
= (ntfschar
*)(le16_to_cpu(a
->value_offset
) + (char*)a
);
1098 u
= le32_to_cpu(a
->value_length
) / 2;
1100 * Convert Unicode volume name to current locale multibyte
1103 vol
->vol_name
= NULL
;
1104 if (ntfs_ucstombs(vname
, u
, &vol
->vol_name
, 0) == -1) {
1105 ntfs_log_perror("Volume name could not be converted "
1106 "to current locale");
1107 ntfs_log_debug("Forcing name into ASCII by replacing "
1108 "non-ASCII characters with underscores.\n");
1109 vol
->vol_name
= ntfs_malloc(u
+ 1);
1113 for (j
= 0; j
< (s32
)u
; j
++) {
1114 u16 uc
= le16_to_cpu(vname
[j
]);
1117 vol
->vol_name
[j
] = (char)uc
;
1119 vol
->vol_name
[u
] = '\0';
1122 ntfs_attr_put_search_ctx(ctx
);
1124 /* Now load the attribute definitions from $AttrDef. */
1125 ntfs_log_debug("Loading $AttrDef...\n");
1126 ni
= ntfs_inode_open(vol
, FILE_AttrDef
);
1128 ntfs_log_perror("Failed to open $AttrDef");
1131 /* Get an ntfs attribute for $AttrDef/$DATA. */
1132 na
= ntfs_attr_open(ni
, AT_DATA
, AT_UNNAMED
, 0);
1134 ntfs_log_perror("Failed to open ntfs attribute");
1137 /* Check we don't overflow 32-bits. */
1138 if (na
->data_size
> 0xffffffffLL
) {
1139 ntfs_log_error("Attribute definition table is too big (max "
1140 "32-bit allowed).\n");
1144 vol
->attrdef_len
= na
->data_size
;
1145 vol
->attrdef
= ntfs_malloc(na
->data_size
);
1148 /* Read in the $DATA attribute value into the buffer. */
1149 l
= ntfs_attr_pread(na
, 0, na
->data_size
, vol
->attrdef
);
1150 if (l
!= na
->data_size
) {
1151 ntfs_log_error("Failed to read $AttrDef, unexpected length "
1152 "(%lld != %lld).\n", (long long)l
,
1153 (long long)na
->data_size
);
1157 /* Done with the $AttrDef mft record. */
1158 ntfs_attr_close(na
);
1159 if (ntfs_inode_close(ni
)) {
1160 ntfs_log_perror("Failed to close $AttrDef");
1164 * Check for dirty logfile and hibernated Windows.
1165 * We care only about read-write mounts.
1167 if (!(flags
& MS_RDONLY
)) {
1168 if (!(flags
& MS_IGNORE_HIBERFILE
) &&
1169 ntfs_volume_check_hiberfile(vol
, 1) < 0)
1171 if (ntfs_volume_check_logfile(vol
) < 0) {
1172 if (!(flags
& MS_RECOVER
))
1174 ntfs_log_info("The file system wasn't safely "
1175 "closed on Windows. Fixing.\n");
1176 if (ntfs_logfile_reset(vol
))
1180 /* make $TXF_DATA resident if present on the root directory */
1181 if (!NVolReadOnly(vol
) && fix_txf_data(vol
))
1190 ntfs_attr_put_search_ctx(ctx
);
1193 __ntfs_volume_release(vol
);
1199 * ntfs_mount - open ntfs volume
1200 * @name: name of device/file to open
1201 * @flags: optional mount flags
1203 * This function mounts an ntfs volume. @name should contain the name of the
1204 * device/file to mount as the ntfs volume.
1206 * @flags is an optional second parameter. The same flags are used as for
1207 * the mount system call (man 2 mount). Currently only the following flags
1209 * MS_RDONLY - mount volume read-only
1211 * The function opens the device or file @name and verifies that it contains a
1212 * valid bootsector. Then, it allocates an ntfs_volume structure and initializes
1213 * some of the values inside the structure from the information stored in the
1214 * bootsector. It proceeds to load the necessary system files and completes
1215 * setting up the structure.
1217 * Return the allocated volume structure on success and NULL on error with
1218 * errno set to the error code.
1220 * Note, that a copy is made of @name, and hence it can be discarded as
1221 * soon as the function returns.
1223 ntfs_volume
*ntfs_mount(const char *name
__attribute__((unused
)),
1224 unsigned long flags
__attribute__((unused
)))
1226 #ifndef NO_NTFS_DEVICE_DEFAULT_IO_OPS
1227 struct ntfs_device
*dev
;
1230 /* Allocate an ntfs_device structure. */
1231 dev
= ntfs_device_alloc(name
, 0, &ntfs_device_default_io_ops
, NULL
);
1234 /* Call ntfs_device_mount() to do the actual mount. */
1235 vol
= ntfs_device_mount(dev
, flags
);
1238 ntfs_device_free(dev
);
1241 ntfs_create_lru_caches(vol
);
1245 * ntfs_mount() makes no sense if NO_NTFS_DEVICE_DEFAULT_IO_OPS is
1246 * defined as there are no device operations available in libntfs in
1255 * ntfs_umount - close ntfs volume
1256 * @vol: address of ntfs_volume structure of volume to close
1257 * @force: if true force close the volume even if it is busy
1259 * Deallocate all structures (including @vol itself) associated with the ntfs
1262 * Return 0 on success. On error return -1 with errno set appropriately
1263 * (most likely to one of EAGAIN, EBUSY or EINVAL). The EAGAIN error means that
1264 * an operation is in progress and if you try the close later the operation
1265 * might be completed and the close succeed.
1267 * If @force is true (i.e. not zero) this function will close the volume even
1268 * if this means that data might be lost.
1270 * @vol must have previously been returned by a call to ntfs_mount().
1272 * @vol itself is deallocated and should no longer be dereferenced after this
1273 * function returns success. If it returns an error then nothing has been done
1274 * so it is safe to continue using @vol.
1276 int ntfs_umount(ntfs_volume
*vol
, const BOOL force
__attribute__((unused
)))
1278 struct ntfs_device
*dev
;
1286 ret
= __ntfs_volume_release(vol
);
1287 ntfs_device_free(dev
);
1291 #ifdef HAVE_MNTENT_H
1293 #ifndef HAVE_REALPATH
1295 * realpath - If there is no realpath on the system
1297 static char *realpath(const char *path
, char *resolved_path
)
1299 strncpy(resolved_path
, path
, PATH_MAX
);
1300 resolved_path
[PATH_MAX
] = '\0';
1301 return resolved_path
;
1306 * ntfs_mntent_check - desc
1308 * If you are wanting to use this, you actually wanted to use
1309 * ntfs_check_if_mounted(), you just didn't realize. (-:
1311 * See description of ntfs_check_if_mounted(), below.
1313 static int ntfs_mntent_check(const char *file
, unsigned long *mnt_flags
)
1316 char *real_file
= NULL
, *real_fsname
= NULL
;
1320 real_file
= ntfs_malloc(PATH_MAX
+ 1);
1323 real_fsname
= ntfs_malloc(PATH_MAX
+ 1);
1328 if (!realpath(file
, real_file
)) {
1332 if (!(f
= setmntent(MOUNTED
, "r"))) {
1336 while ((mnt
= getmntent(f
))) {
1337 if (!realpath(mnt
->mnt_fsname
, real_fsname
))
1339 if (!strcmp(real_file
, real_fsname
))
1345 *mnt_flags
= NTFS_MF_MOUNTED
;
1346 if (!strcmp(mnt
->mnt_dir
, "/"))
1347 *mnt_flags
|= NTFS_MF_ISROOT
;
1348 #ifdef HAVE_HASMNTOPT
1349 if (hasmntopt(mnt
, "ro") && !hasmntopt(mnt
, "rw"))
1350 *mnt_flags
|= NTFS_MF_READONLY
;
1361 #endif /* HAVE_MNTENT_H */
1364 * ntfs_check_if_mounted - check if an ntfs volume is currently mounted
1365 * @file: device file to check
1366 * @mnt_flags: pointer into which to return the ntfs mount flags (see volume.h)
1368 * If the running system does not support the {set,get,end}mntent() calls,
1369 * just return 0 and set *@mnt_flags to zero.
1371 * When the system does support the calls, ntfs_check_if_mounted() first tries
1372 * to find the device @file in /etc/mtab (or wherever this is kept on the
1373 * running system). If it is not found, assume the device is not mounted and
1374 * return 0 and set *@mnt_flags to zero.
1376 * If the device @file is found, set the NTFS_MF_MOUNTED flags in *@mnt_flags.
1378 * Further if @file is mounted as the file system root ("/"), set the flag
1379 * NTFS_MF_ISROOT in *@mnt_flags.
1381 * Finally, check if the file system is mounted read-only, and if so set the
1382 * NTFS_MF_READONLY flag in *@mnt_flags.
1384 * On success return 0 with *@mnt_flags set to the ntfs mount flags.
1386 * On error return -1 with errno set to the error code.
1388 int ntfs_check_if_mounted(const char *file
__attribute__((unused
)),
1389 unsigned long *mnt_flags
)
1392 #ifdef HAVE_MNTENT_H
1393 return ntfs_mntent_check(file
, mnt_flags
);
1400 * ntfs_version_is_supported - check if NTFS version is supported.
1401 * @vol: ntfs volume whose version we're interested in.
1403 * The function checks if the NTFS volume version is known or not.
1404 * Version 1.1 and 1.2 are used by Windows NT3.x and NT4.
1405 * Version 2.x is used by Windows 2000 Betas.
1406 * Version 3.0 is used by Windows 2000.
1407 * Version 3.1 is used by Windows XP, Windows Server 2003 and Longhorn.
1409 * Return 0 if NTFS version is supported otherwise -1 with errno set.
1411 * The following error codes are defined:
1412 * EOPNOTSUPP - Unknown NTFS version
1413 * EINVAL - Invalid argument
1415 int ntfs_version_is_supported(ntfs_volume
*vol
)
1424 major
= vol
->major_ver
;
1425 minor
= vol
->minor_ver
;
1427 if (NTFS_V1_1(major
, minor
) || NTFS_V1_2(major
, minor
))
1430 if (NTFS_V2_X(major
, minor
))
1433 if (NTFS_V3_0(major
, minor
) || NTFS_V3_1(major
, minor
))
1441 * ntfs_logfile_reset - "empty" $LogFile data attribute value
1442 * @vol: ntfs volume whose $LogFile we intend to reset.
1444 * Fill the value of the $LogFile data attribute, i.e. the contents of
1445 * the file, with 0xff's, thus marking the journal as empty.
1447 * FIXME(?): We might need to zero the LSN field of every single mft
1448 * record as well. (But, first try without doing that and see what
1449 * happens, since chkdsk might pickup the pieces and do it for us...)
1451 * On success return 0.
1453 * On error return -1 with errno set to the error code.
1455 int ntfs_logfile_reset(ntfs_volume
*vol
)
1466 ni
= ntfs_inode_open(vol
, FILE_LogFile
);
1468 ntfs_log_perror("Failed to open inode FILE_LogFile");
1472 na
= ntfs_attr_open(ni
, AT_DATA
, AT_UNNAMED
, 0);
1475 ntfs_log_perror("Failed to open $FILE_LogFile/$DATA");
1479 if (ntfs_empty_logfile(na
)) {
1481 ntfs_attr_close(na
);
1485 ntfs_attr_close(na
);
1486 return ntfs_inode_close(ni
);
1489 ntfs_inode_close(ni
);
1495 * ntfs_volume_write_flags - set the flags of an ntfs volume
1496 * @vol: ntfs volume where we set the volume flags
1499 * Set the on-disk volume flags in the mft record of $Volume and
1500 * on volume @vol to @flags.
1502 * Return 0 if successful and -1 if not with errno set to the error code.
1504 int ntfs_volume_write_flags(ntfs_volume
*vol
, const le16 flags
)
1507 VOLUME_INFORMATION
*c
;
1508 ntfs_attr_search_ctx
*ctx
;
1509 int ret
= -1; /* failure */
1511 if (!vol
|| !vol
->vol_ni
) {
1515 /* Get a pointer to the volume information attribute. */
1516 ctx
= ntfs_attr_get_search_ctx(vol
->vol_ni
, NULL
);
1520 if (ntfs_attr_lookup(AT_VOLUME_INFORMATION
, AT_UNNAMED
, 0, 0, 0, NULL
,
1522 ntfs_log_error("Attribute $VOLUME_INFORMATION was not found "
1528 if (a
->non_resident
) {
1529 ntfs_log_error("Attribute $VOLUME_INFORMATION must be resident "
1534 /* Get a pointer to the value of the attribute. */
1535 c
= (VOLUME_INFORMATION
*)(le16_to_cpu(a
->value_offset
) + (char*)a
);
1536 /* Sanity checks. */
1537 if ((char*)c
+ le32_to_cpu(a
->value_length
) > (char*)ctx
->mrec
+
1538 le32_to_cpu(ctx
->mrec
->bytes_in_use
) ||
1539 le16_to_cpu(a
->value_offset
) +
1540 le32_to_cpu(a
->value_length
) > le32_to_cpu(a
->length
)) {
1541 ntfs_log_error("Attribute $VOLUME_INFORMATION in $Volume is "
1546 /* Set the volume flags. */
1547 vol
->flags
= c
->flags
= flags
& VOLUME_FLAGS_MASK
;
1548 /* Write them to disk. */
1549 ntfs_inode_mark_dirty(vol
->vol_ni
);
1550 if (ntfs_inode_sync(vol
->vol_ni
))
1553 ret
= 0; /* success */
1555 ntfs_attr_put_search_ctx(ctx
);
1559 int ntfs_volume_error(int err
)
1565 ret
= NTFS_VOLUME_OK
;
1568 ret
= NTFS_VOLUME_NOT_NTFS
;
1571 ret
= NTFS_VOLUME_CORRUPT
;
1574 ret
= NTFS_VOLUME_HIBERNATED
;
1577 ret
= NTFS_VOLUME_UNCLEAN_UNMOUNT
;
1580 ret
= NTFS_VOLUME_LOCKED
;
1583 ret
= NTFS_VOLUME_RAID
;
1586 ret
= NTFS_VOLUME_NO_PRIVILEGE
;
1589 ret
= NTFS_VOLUME_UNKNOWN_REASON
;
1596 void ntfs_mount_error(const char *volume
, const char *mntpoint
, int err
)
1599 case NTFS_VOLUME_NOT_NTFS
:
1600 ntfs_log_error(invalid_ntfs_msg
, volume
);
1602 case NTFS_VOLUME_CORRUPT
:
1603 ntfs_log_error("%s", corrupt_volume_msg
);
1605 case NTFS_VOLUME_HIBERNATED
:
1606 ntfs_log_error(hibernated_volume_msg
, volume
, mntpoint
);
1608 case NTFS_VOLUME_UNCLEAN_UNMOUNT
:
1609 ntfs_log_error("%s", unclean_journal_msg
);
1611 case NTFS_VOLUME_LOCKED
:
1612 ntfs_log_error("%s", opened_volume_msg
);
1614 case NTFS_VOLUME_RAID
:
1615 ntfs_log_error("%s", fakeraid_msg
);
1617 case NTFS_VOLUME_NO_PRIVILEGE
:
1618 ntfs_log_error(access_denied_msg
, volume
);
1623 int ntfs_set_locale(void)
1627 locale
= setlocale(LC_ALL
, "");
1629 locale
= setlocale(LC_ALL
, NULL
);
1630 ntfs_log_error("Couldn't set local environment, using default "
1638 * Feed the counts of free clusters and free mft records
1641 int ntfs_volume_get_free_space(ntfs_volume
*vol
)
1646 ret
= -1; /* default return */
1647 vol
->free_clusters
= ntfs_attr_get_free_bits(vol
->lcnbmp_na
);
1648 if (vol
->free_clusters
< 0) {
1649 ntfs_log_perror("Failed to read NTFS $Bitmap");
1651 na
= vol
->mftbmp_na
;
1652 vol
->free_mft_records
= ntfs_attr_get_free_bits(na
);
1654 if (vol
->free_mft_records
>= 0)
1655 vol
->free_mft_records
+= (na
->allocated_size
- na
->data_size
) << 3;
1657 if (vol
->free_mft_records
< 0)
1658 ntfs_log_perror("Failed to calculate free MFT records");