2 * logfile.c - NTFS kernel journal handling. Part of the Linux-NTFS project.
4 * Copyright (c) 2002-2005 Anton Altaparmakov
6 * This program/include file is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License as published
8 * by the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
11 * This program/include file is distributed in the hope that it will be
12 * useful, but WITHOUT ANY WARRANTY; without even the implied warranty
13 * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program (in the main directory of the Linux-NTFS
18 * distribution in the file COPYING); if not, write to the Free Software
19 * Foundation,Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
24 #include <linux/types.h>
26 #include <linux/highmem.h>
27 #include <linux/buffer_head.h>
28 #include <linux/bitops.h>
39 * ntfs_check_restart_page_header - check the page header for consistency
40 * @vi: $LogFile inode to which the restart page header belongs
41 * @rp: restart page header to check
42 * @pos: position in @vi at which the restart page header resides
44 * Check the restart page header @rp for consistency and return TRUE if it is
45 * consistent and FALSE otherwise.
47 * This function only needs NTFS_BLOCK_SIZE bytes in @rp, i.e. it does not
48 * require the full restart page.
50 static BOOL
ntfs_check_restart_page_header(struct inode
*vi
,
51 RESTART_PAGE_HEADER
*rp
, s64 pos
)
53 u32 logfile_system_page_size
, logfile_log_page_size
;
54 u16 usa_count
, usa_ofs
, usa_end
, ra_ofs
;
56 ntfs_debug("Entering.");
58 * If the system or log page sizes are smaller than the ntfs block size
59 * or either is not a power of 2 we cannot handle this log file.
61 logfile_system_page_size
= le32_to_cpu(rp
->system_page_size
);
62 logfile_log_page_size
= le32_to_cpu(rp
->log_page_size
);
63 if (logfile_system_page_size
< NTFS_BLOCK_SIZE
||
64 logfile_log_page_size
< NTFS_BLOCK_SIZE
||
65 logfile_system_page_size
&
66 (logfile_system_page_size
- 1) ||
67 logfile_log_page_size
& (logfile_log_page_size
- 1)) {
68 ntfs_error(vi
->i_sb
, "$LogFile uses unsupported page size.");
72 * We must be either at !pos (1st restart page) or at pos = system page
73 * size (2nd restart page).
75 if (pos
&& pos
!= logfile_system_page_size
) {
76 ntfs_error(vi
->i_sb
, "Found restart area in incorrect "
77 "position in $LogFile.");
80 /* We only know how to handle version 1.1. */
81 if (sle16_to_cpu(rp
->major_ver
) != 1 ||
82 sle16_to_cpu(rp
->minor_ver
) != 1) {
83 ntfs_error(vi
->i_sb
, "$LogFile version %i.%i is not "
84 "supported. (This driver supports version "
85 "1.1 only.)", (int)sle16_to_cpu(rp
->major_ver
),
86 (int)sle16_to_cpu(rp
->minor_ver
));
89 /* Verify the size of the update sequence array. */
90 usa_count
= 1 + (logfile_system_page_size
>> NTFS_BLOCK_SIZE_BITS
);
91 if (usa_count
!= le16_to_cpu(rp
->usa_count
)) {
92 ntfs_error(vi
->i_sb
, "$LogFile restart page specifies "
93 "inconsistent update sequence array count.");
96 /* Verify the position of the update sequence array. */
97 usa_ofs
= le16_to_cpu(rp
->usa_ofs
);
98 usa_end
= usa_ofs
+ usa_count
* sizeof(u16
);
99 if (usa_ofs
< sizeof(RESTART_PAGE_HEADER
) ||
100 usa_end
> NTFS_BLOCK_SIZE
- sizeof(u16
)) {
101 ntfs_error(vi
->i_sb
, "$LogFile restart page specifies "
102 "inconsistent update sequence array offset.");
106 * Verify the position of the restart area. It must be:
107 * - aligned to 8-byte boundary,
108 * - after the update sequence array, and
109 * - within the system page size.
111 ra_ofs
= le16_to_cpu(rp
->restart_area_offset
);
112 if (ra_ofs
& 7 || ra_ofs
< usa_end
||
113 ra_ofs
> logfile_system_page_size
) {
114 ntfs_error(vi
->i_sb
, "$LogFile restart page specifies "
115 "inconsistent restart area offset.");
119 * Only restart pages modified by chkdsk are allowed to have chkdsk_lsn
122 if (!ntfs_is_chkd_record(rp
->magic
) && sle64_to_cpu(rp
->chkdsk_lsn
)) {
123 ntfs_error(vi
->i_sb
, "$LogFile restart page is not modified "
124 "by chkdsk but a chkdsk LSN is specified.");
132 * ntfs_check_restart_area - check the restart area for consistency
133 * @vi: $LogFile inode to which the restart page belongs
134 * @rp: restart page whose restart area to check
136 * Check the restart area of the restart page @rp for consistency and return
137 * TRUE if it is consistent and FALSE otherwise.
139 * This function assumes that the restart page header has already been
140 * consistency checked.
142 * This function only needs NTFS_BLOCK_SIZE bytes in @rp, i.e. it does not
143 * require the full restart page.
145 static BOOL
ntfs_check_restart_area(struct inode
*vi
, RESTART_PAGE_HEADER
*rp
)
149 u16 ra_ofs
, ra_len
, ca_ofs
;
152 ntfs_debug("Entering.");
153 ra_ofs
= le16_to_cpu(rp
->restart_area_offset
);
154 ra
= (RESTART_AREA
*)((u8
*)rp
+ ra_ofs
);
156 * Everything before ra->file_size must be before the first word
157 * protected by an update sequence number. This ensures that it is
158 * safe to access ra->client_array_offset.
160 if (ra_ofs
+ offsetof(RESTART_AREA
, file_size
) >
161 NTFS_BLOCK_SIZE
- sizeof(u16
)) {
162 ntfs_error(vi
->i_sb
, "$LogFile restart area specifies "
163 "inconsistent file offset.");
167 * Now that we can access ra->client_array_offset, make sure everything
168 * up to the log client array is before the first word protected by an
169 * update sequence number. This ensures we can access all of the
170 * restart area elements safely. Also, the client array offset must be
171 * aligned to an 8-byte boundary.
173 ca_ofs
= le16_to_cpu(ra
->client_array_offset
);
174 if (((ca_ofs
+ 7) & ~7) != ca_ofs
||
175 ra_ofs
+ ca_ofs
> NTFS_BLOCK_SIZE
- sizeof(u16
)) {
176 ntfs_error(vi
->i_sb
, "$LogFile restart area specifies "
177 "inconsistent client array offset.");
181 * The restart area must end within the system page size both when
182 * calculated manually and as specified by ra->restart_area_length.
183 * Also, the calculated length must not exceed the specified length.
185 ra_len
= ca_ofs
+ le16_to_cpu(ra
->log_clients
) *
186 sizeof(LOG_CLIENT_RECORD
);
187 if (ra_ofs
+ ra_len
> le32_to_cpu(rp
->system_page_size
) ||
188 ra_ofs
+ le16_to_cpu(ra
->restart_area_length
) >
189 le32_to_cpu(rp
->system_page_size
) ||
190 ra_len
> le16_to_cpu(ra
->restart_area_length
)) {
191 ntfs_error(vi
->i_sb
, "$LogFile restart area is out of bounds "
192 "of the system page size specified by the "
193 "restart page header and/or the specified "
194 "restart area length is inconsistent.");
198 * The ra->client_free_list and ra->client_in_use_list must be either
199 * LOGFILE_NO_CLIENT or less than ra->log_clients or they are
200 * overflowing the client array.
202 if ((ra
->client_free_list
!= LOGFILE_NO_CLIENT
&&
203 le16_to_cpu(ra
->client_free_list
) >=
204 le16_to_cpu(ra
->log_clients
)) ||
205 (ra
->client_in_use_list
!= LOGFILE_NO_CLIENT
&&
206 le16_to_cpu(ra
->client_in_use_list
) >=
207 le16_to_cpu(ra
->log_clients
))) {
208 ntfs_error(vi
->i_sb
, "$LogFile restart area specifies "
209 "overflowing client free and/or in use lists.");
213 * Check ra->seq_number_bits against ra->file_size for consistency.
214 * We cannot just use ffs() because the file size is not a power of 2.
216 file_size
= (u64
)sle64_to_cpu(ra
->file_size
);
222 if (le32_to_cpu(ra
->seq_number_bits
) != 67 - fs_bits
) {
223 ntfs_error(vi
->i_sb
, "$LogFile restart area specifies "
224 "inconsistent sequence number bits.");
227 /* The log record header length must be a multiple of 8. */
228 if (((le16_to_cpu(ra
->log_record_header_length
) + 7) & ~7) !=
229 le16_to_cpu(ra
->log_record_header_length
)) {
230 ntfs_error(vi
->i_sb
, "$LogFile restart area specifies "
231 "inconsistent log record header length.");
234 /* Dito for the log page data offset. */
235 if (((le16_to_cpu(ra
->log_page_data_offset
) + 7) & ~7) !=
236 le16_to_cpu(ra
->log_page_data_offset
)) {
237 ntfs_error(vi
->i_sb
, "$LogFile restart area specifies "
238 "inconsistent log page data offset.");
246 * ntfs_check_log_client_array - check the log client array for consistency
247 * @vi: $LogFile inode to which the restart page belongs
248 * @rp: restart page whose log client array to check
250 * Check the log client array of the restart page @rp for consistency and
251 * return TRUE if it is consistent and FALSE otherwise.
253 * This function assumes that the restart page header and the restart area have
254 * already been consistency checked.
256 * Unlike ntfs_check_restart_page_header() and ntfs_check_restart_area(), this
257 * function needs @rp->system_page_size bytes in @rp, i.e. it requires the full
258 * restart page and the page must be multi sector transfer deprotected.
260 static BOOL
ntfs_check_log_client_array(struct inode
*vi
,
261 RESTART_PAGE_HEADER
*rp
)
264 LOG_CLIENT_RECORD
*ca
, *cr
;
266 BOOL in_free_list
, idx_is_first
;
268 ntfs_debug("Entering.");
269 ra
= (RESTART_AREA
*)((u8
*)rp
+ le16_to_cpu(rp
->restart_area_offset
));
270 ca
= (LOG_CLIENT_RECORD
*)((u8
*)ra
+
271 le16_to_cpu(ra
->client_array_offset
));
273 * Check the ra->client_free_list first and then check the
274 * ra->client_in_use_list. Check each of the log client records in
275 * each of the lists and check that the array does not overflow the
276 * ra->log_clients value. Also keep track of the number of records
277 * visited as there cannot be more than ra->log_clients records and
278 * that way we detect eventual loops in within a list.
280 nr_clients
= le16_to_cpu(ra
->log_clients
);
281 idx
= le16_to_cpu(ra
->client_free_list
);
284 for (idx_is_first
= TRUE
; idx
!= LOGFILE_NO_CLIENT_CPU
; nr_clients
--,
285 idx
= le16_to_cpu(cr
->next_client
)) {
286 if (!nr_clients
|| idx
>= le16_to_cpu(ra
->log_clients
))
288 /* Set @cr to the current log client record. */
290 /* The first log client record must not have a prev_client. */
292 if (cr
->prev_client
!= LOGFILE_NO_CLIENT
)
294 idx_is_first
= FALSE
;
297 /* Switch to and check the in use list if we just did the free list. */
299 in_free_list
= FALSE
;
300 idx
= le16_to_cpu(ra
->client_in_use_list
);
306 ntfs_error(vi
->i_sb
, "$LogFile log client array is corrupt.");
311 * ntfs_check_and_load_restart_page - check the restart page for consistency
312 * @vi: $LogFile inode to which the restart page belongs
313 * @rp: restart page to check
314 * @pos: position in @vi at which the restart page resides
315 * @wrp: [OUT] copy of the multi sector transfer deprotected restart page
316 * @lsn: [OUT] set to the current logfile lsn on success
318 * Check the restart page @rp for consistency and return 0 if it is consistent
319 * and -errno otherwise. The restart page may have been modified by chkdsk in
320 * which case its magic is CHKD instead of RSTR.
322 * This function only needs NTFS_BLOCK_SIZE bytes in @rp, i.e. it does not
323 * require the full restart page.
325 * If @wrp is not NULL, on success, *@wrp will point to a buffer containing a
326 * copy of the complete multi sector transfer deprotected page. On failure,
327 * *@wrp is undefined.
329 * Simillarly, if @lsn is not NULL, on succes *@lsn will be set to the current
330 * logfile lsn according to this restart page. On failure, *@lsn is undefined.
332 * The following error codes are defined:
333 * -EINVAL - The restart page is inconsistent.
334 * -ENOMEM - Not enough memory to load the restart page.
335 * -EIO - Failed to reading from $LogFile.
337 static int ntfs_check_and_load_restart_page(struct inode
*vi
,
338 RESTART_PAGE_HEADER
*rp
, s64 pos
, RESTART_PAGE_HEADER
**wrp
,
342 RESTART_PAGE_HEADER
*trp
;
345 ntfs_debug("Entering.");
346 /* Check the restart page header for consistency. */
347 if (!ntfs_check_restart_page_header(vi
, rp
, pos
)) {
348 /* Error output already done inside the function. */
351 /* Check the restart area for consistency. */
352 if (!ntfs_check_restart_area(vi
, rp
)) {
353 /* Error output already done inside the function. */
356 ra
= (RESTART_AREA
*)((u8
*)rp
+ le16_to_cpu(rp
->restart_area_offset
));
358 * Allocate a buffer to store the whole restart page so we can multi
359 * sector transfer deprotect it.
361 trp
= ntfs_malloc_nofs(le32_to_cpu(rp
->system_page_size
));
363 ntfs_error(vi
->i_sb
, "Failed to allocate memory for $LogFile "
364 "restart page buffer.");
368 * Read the whole of the restart page into the buffer. If it fits
369 * completely inside @rp, just copy it from there. Otherwise map all
370 * the required pages and copy the data from them.
372 size
= PAGE_CACHE_SIZE
- (pos
& ~PAGE_CACHE_MASK
);
373 if (size
>= le32_to_cpu(rp
->system_page_size
)) {
374 memcpy(trp
, rp
, le32_to_cpu(rp
->system_page_size
));
378 int have_read
, to_read
;
380 /* First copy what we already have in @rp. */
381 memcpy(trp
, rp
, size
);
382 /* Copy the remaining data one page at a time. */
384 to_read
= le32_to_cpu(rp
->system_page_size
) - size
;
385 idx
= (pos
+ size
) >> PAGE_CACHE_SHIFT
;
386 BUG_ON((pos
+ size
) & ~PAGE_CACHE_MASK
);
388 page
= ntfs_map_page(vi
->i_mapping
, idx
);
390 ntfs_error(vi
->i_sb
, "Error mapping $LogFile "
391 "page (index %lu).", idx
);
393 if (err
!= -EIO
&& err
!= -ENOMEM
)
397 size
= min_t(int, to_read
, PAGE_CACHE_SIZE
);
398 memcpy((u8
*)trp
+ have_read
, page_address(page
), size
);
399 ntfs_unmap_page(page
);
403 } while (to_read
> 0);
405 /* Perform the multi sector transfer deprotection on the buffer. */
406 if (post_read_mst_fixup((NTFS_RECORD
*)trp
,
407 le32_to_cpu(rp
->system_page_size
))) {
409 * A multi sector tranfer error was detected. We only need to
410 * abort if the restart page contents exceed the multi sector
411 * transfer fixup of the first sector.
413 if (le16_to_cpu(rp
->restart_area_offset
) +
414 le16_to_cpu(ra
->restart_area_length
) >
415 NTFS_BLOCK_SIZE
- sizeof(u16
)) {
416 ntfs_error(vi
->i_sb
, "Multi sector transfer error "
417 "detected in $LogFile restart page.");
423 * If the restart page is modified by chkdsk or there are no active
424 * logfile clients, the logfile is consistent. Otherwise, need to
425 * check the log client records for consistency, too.
428 if (ntfs_is_rstr_record(rp
->magic
) &&
429 ra
->client_in_use_list
!= LOGFILE_NO_CLIENT
) {
430 if (!ntfs_check_log_client_array(vi
, trp
)) {
436 if (ntfs_is_rstr_record(rp
->magic
))
437 *lsn
= sle64_to_cpu(ra
->current_lsn
);
438 else /* if (ntfs_is_chkd_record(rp->magic)) */
439 *lsn
= sle64_to_cpu(rp
->chkdsk_lsn
);
452 * ntfs_check_logfile - check the journal for consistency
453 * @log_vi: struct inode of loaded journal $LogFile to check
454 * @rp: [OUT] on success this is a copy of the current restart page
456 * Check the $LogFile journal for consistency and return TRUE if it is
457 * consistent and FALSE if not. On success, the current restart page is
458 * returned in *@rp. Caller must call ntfs_free(*@rp) when finished with it.
460 * At present we only check the two restart pages and ignore the log record
463 * Note that the MstProtected flag is not set on the $LogFile inode and hence
464 * when reading pages they are not deprotected. This is because we do not know
465 * if the $LogFile was created on a system with a different page size to ours
466 * yet and mst deprotection would fail if our page size is smaller.
468 BOOL
ntfs_check_logfile(struct inode
*log_vi
, RESTART_PAGE_HEADER
**rp
)
471 LSN rstr1_lsn
, rstr2_lsn
;
472 ntfs_volume
*vol
= NTFS_SB(log_vi
->i_sb
);
473 struct address_space
*mapping
= log_vi
->i_mapping
;
474 struct page
*page
= NULL
;
476 RESTART_PAGE_HEADER
*rstr1_ph
= NULL
;
477 RESTART_PAGE_HEADER
*rstr2_ph
= NULL
;
478 int log_page_size
, log_page_mask
, err
;
479 BOOL logfile_is_empty
= TRUE
;
482 ntfs_debug("Entering.");
483 /* An empty $LogFile must have been clean before it got emptied. */
484 if (NVolLogFileEmpty(vol
))
486 size
= i_size_read(log_vi
);
487 /* Make sure the file doesn't exceed the maximum allowed size. */
488 if (size
> MaxLogFileSize
)
489 size
= MaxLogFileSize
;
491 * Truncate size to a multiple of the page cache size or the default
492 * log page size if the page cache size is between the default log page
493 * log page size if the page cache size is between the default log page
494 * size and twice that.
496 if (PAGE_CACHE_SIZE
>= DefaultLogPageSize
&& PAGE_CACHE_SIZE
<=
497 DefaultLogPageSize
* 2)
498 log_page_size
= DefaultLogPageSize
;
500 log_page_size
= PAGE_CACHE_SIZE
;
501 log_page_mask
= log_page_size
- 1;
503 * Use generic_ffs() instead of ffs() to enable the compiler to
504 * optimize log_page_size and log_page_bits into constants.
506 log_page_bits
= generic_ffs(log_page_size
) - 1;
507 size
&= ~(s64
)(log_page_size
- 1);
509 * Ensure the log file is big enough to store at least the two restart
510 * pages and the minimum number of log record pages.
512 if (size
< log_page_size
* 2 || (size
- log_page_size
* 2) >>
513 log_page_bits
< MinLogRecordPages
) {
514 ntfs_error(vol
->sb
, "$LogFile is too small.");
518 * Read through the file looking for a restart page. Since the restart
519 * page header is at the beginning of a page we only need to search at
520 * what could be the beginning of a page (for each page size) rather
521 * than scanning the whole file byte by byte. If all potential places
522 * contain empty and uninitialzed records, the log file can be assumed
525 for (pos
= 0; pos
< size
; pos
<<= 1) {
526 pgoff_t idx
= pos
>> PAGE_CACHE_SHIFT
;
527 if (!page
|| page
->index
!= idx
) {
529 ntfs_unmap_page(page
);
530 page
= ntfs_map_page(mapping
, idx
);
532 ntfs_error(vol
->sb
, "Error mapping $LogFile "
533 "page (index %lu).", idx
);
537 kaddr
= (u8
*)page_address(page
) + (pos
& ~PAGE_CACHE_MASK
);
539 * A non-empty block means the logfile is not empty while an
540 * empty block after a non-empty block has been encountered
543 if (!ntfs_is_empty_recordp((le32
*)kaddr
))
544 logfile_is_empty
= FALSE
;
545 else if (!logfile_is_empty
)
548 * A log record page means there cannot be a restart page after
549 * this so no need to continue searching.
551 if (ntfs_is_rcrd_recordp((le32
*)kaddr
))
553 /* If not a (modified by chkdsk) restart page, continue. */
554 if (!ntfs_is_rstr_recordp((le32
*)kaddr
) &&
555 !ntfs_is_chkd_recordp((le32
*)kaddr
)) {
557 pos
= NTFS_BLOCK_SIZE
>> 1;
561 * Check the (modified by chkdsk) restart page for consistency
562 * and get a copy of the complete multi sector transfer
563 * deprotected restart page.
565 err
= ntfs_check_and_load_restart_page(log_vi
,
566 (RESTART_PAGE_HEADER
*)kaddr
, pos
,
567 !rstr1_ph
? &rstr1_ph
: &rstr2_ph
,
568 !rstr1_ph
? &rstr1_lsn
: &rstr2_lsn
);
571 * If we have now found the first (modified by chkdsk)
572 * restart page, continue looking for the second one.
575 pos
= NTFS_BLOCK_SIZE
>> 1;
579 * We have now found the second (modified by chkdsk)
580 * restart page, so we can stop looking.
585 * Error output already done inside the function. Note, we do
586 * not abort if the restart page was invalid as we might still
587 * find a valid one further in the file.
589 if (err
!= -EINVAL
) {
590 ntfs_unmap_page(page
);
593 /* Continue looking. */
595 pos
= NTFS_BLOCK_SIZE
>> 1;
598 ntfs_unmap_page(page
);
599 if (logfile_is_empty
) {
600 NVolSetLogFileEmpty(vol
);
602 ntfs_debug("Done. ($LogFile is empty.)");
607 ntfs_error(vol
->sb
, "Did not find any restart pages in "
608 "$LogFile and it was not empty.");
611 /* If both restart pages were found, use the more recent one. */
614 * If the second restart area is more recent, switch to it.
615 * Otherwise just throw it away.
617 if (rstr2_lsn
> rstr1_lsn
) {
620 /* rstr1_lsn = rstr2_lsn; */
625 /* All consistency checks passed. */
639 * ntfs_is_logfile_clean - check in the journal if the volume is clean
640 * @log_vi: struct inode of loaded journal $LogFile to check
641 * @rp: copy of the current restart page
643 * Analyze the $LogFile journal and return TRUE if it indicates the volume was
644 * shutdown cleanly and FALSE if not.
646 * At present we only look at the two restart pages and ignore the log record
647 * pages. This is a little bit crude in that there will be a very small number
648 * of cases where we think that a volume is dirty when in fact it is clean.
649 * This should only affect volumes that have not been shutdown cleanly but did
650 * not have any pending, non-check-pointed i/o, i.e. they were completely idle
651 * at least for the five seconds preceeding the unclean shutdown.
653 * This function assumes that the $LogFile journal has already been consistency
654 * checked by a call to ntfs_check_logfile() and in particular if the $LogFile
655 * is empty this function requires that NVolLogFileEmpty() is true otherwise an
656 * empty volume will be reported as dirty.
658 BOOL
ntfs_is_logfile_clean(struct inode
*log_vi
, const RESTART_PAGE_HEADER
*rp
)
660 ntfs_volume
*vol
= NTFS_SB(log_vi
->i_sb
);
663 ntfs_debug("Entering.");
664 /* An empty $LogFile must have been clean before it got emptied. */
665 if (NVolLogFileEmpty(vol
)) {
666 ntfs_debug("Done. ($LogFile is empty.)");
670 if (!ntfs_is_rstr_record(rp
->magic
) &&
671 !ntfs_is_chkd_record(rp
->magic
)) {
672 ntfs_error(vol
->sb
, "Restart page buffer is invalid. This is "
673 "probably a bug in that the $LogFile should "
674 "have been consistency checked before calling "
678 ra
= (RESTART_AREA
*)((u8
*)rp
+ le16_to_cpu(rp
->restart_area_offset
));
680 * If the $LogFile has active clients, i.e. it is open, and we do not
681 * have the RESTART_VOLUME_IS_CLEAN bit set in the restart area flags,
682 * we assume there was an unclean shutdown.
684 if (ra
->client_in_use_list
!= LOGFILE_NO_CLIENT
&&
685 !(ra
->flags
& RESTART_VOLUME_IS_CLEAN
)) {
686 ntfs_debug("Done. $LogFile indicates a dirty shutdown.");
689 /* $LogFile indicates a clean shutdown. */
690 ntfs_debug("Done. $LogFile indicates a clean shutdown.");
695 * ntfs_empty_logfile - empty the contents of the $LogFile journal
696 * @log_vi: struct inode of loaded journal $LogFile to empty
698 * Empty the contents of the $LogFile journal @log_vi and return TRUE on
699 * success and FALSE on error.
701 * This function assumes that the $LogFile journal has already been consistency
702 * checked by a call to ntfs_check_logfile() and that ntfs_is_logfile_clean()
703 * has been used to ensure that the $LogFile is clean.
705 BOOL
ntfs_empty_logfile(struct inode
*log_vi
)
707 ntfs_volume
*vol
= NTFS_SB(log_vi
->i_sb
);
709 ntfs_debug("Entering.");
710 if (!NVolLogFileEmpty(vol
)) {
713 err
= ntfs_attr_set(NTFS_I(log_vi
), 0, i_size_read(log_vi
),
716 ntfs_error(vol
->sb
, "Failed to fill $LogFile with "
717 "0xff bytes (error code %i).", err
);
720 /* Set the flag so we do not have to do it again on remount. */
721 NVolSetLogFileEmpty(vol
);