fs/ntfs/logfile.c

   1 /*
   2  * logfile.c - NTFS kernel journal handling. Part of the Linux-NTFS project.
   3  *
   4  * Copyright (c) 2002-2005 Anton Altaparmakov
   5  *
   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.
  10  *
  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.
  15  *
  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
  20  */
  21
  22 #ifdef NTFS_RW
  23
  24 #include <linux/types.h>
  25 #include <linux/fs.h>
  26 #include <linux/highmem.h>
  27 #include <linux/buffer_head.h>
  28 #include <linux/bitops.h>
  29
  30 #include "attrib.h"
  31 #include "aops.h"
  32 #include "debug.h"
  33 #include "logfile.h"
  34 #include "malloc.h"
  35 #include "volume.h"
  36 #include "ntfs.h"
  37
  38 /**
  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
  43  *
  44  * Check the restart page header @rp for consistency and return TRUE if it is
  45  * consistent and FALSE otherwise.
  46  *
  47  * This function only needs NTFS_BLOCK_SIZE bytes in @rp, i.e. it does not
  48  * require the full restart page.
  49  */
  50 static BOOL ntfs_check_restart_page_header(struct inode *vi,
  51                 RESTART_PAGE_HEADER *rp, s64 pos)
  52 {
  53         u32 logfile_system_page_size, logfile_log_page_size;
  54         u16 usa_count, usa_ofs, usa_end, ra_ofs;
  55
  56         ntfs_debug("Entering.");
  57         /*
  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.
  60          */
  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.");
  69                 return FALSE;
  70         }
  71         /*
  72          * We must be either at !pos (1st restart page) or at pos = system page
  73          * size (2nd restart page).
  74          */
  75         if (pos && pos != logfile_system_page_size) {
  76                 ntfs_error(vi->i_sb, "Found restart area in incorrect "
  77                                 "position in $LogFile.");
  78                 return FALSE;
  79         }
  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));
  87                 return FALSE;
  88         }
  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.");
  94                 return FALSE;
  95         }
  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.");
 103                 return FALSE;
 104         }
 105         /*
 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.
 110          */
 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.");
 116                 return FALSE;
 117         }
 118         /*
 119          * Only restart pages modified by chkdsk are allowed to have chkdsk_lsn
 120          * set.
 121          */
 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.");
 125                 return FALSE;
 126         }
 127         ntfs_debug("Done.");
 128         return TRUE;
 129 }
 130
 131 /**
 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
 135  *
 136  * Check the restart area of the restart page @rp for consistency and return
 137  * TRUE if it is consistent and FALSE otherwise.
 138  *
 139  * This function assumes that the restart page header has already been
 140  * consistency checked.
 141  *
 142  * This function only needs NTFS_BLOCK_SIZE bytes in @rp, i.e. it does not
 143  * require the full restart page.
 144  */
 145 static BOOL ntfs_check_restart_area(struct inode *vi, RESTART_PAGE_HEADER *rp)
 146 {
 147         u64 file_size;
 148         RESTART_AREA *ra;
 149         u16 ra_ofs, ra_len, ca_ofs;
 150         u8 fs_bits;
 151
 152         ntfs_debug("Entering.");
 153         ra_ofs = le16_to_cpu(rp->restart_area_offset);
 154         ra = (RESTART_AREA*)((u8*)rp + ra_ofs);
 155         /*
 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.
 159          */
 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.");
 164                 return FALSE;
 165         }
 166         /*
 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.
 172          */
 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.");
 178                 return FALSE;
 179         }
 180         /*
 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.
 184          */
 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.");
 195                 return FALSE;
 196         }
 197         /*
 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.
 201          */
 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.");
 210                 return FALSE;
 211         }
 212         /*
 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.
 215          */
 216         file_size = (u64)sle64_to_cpu(ra->file_size);
 217         fs_bits = 0;
 218         while (file_size) {
 219                 file_size >>= 1;
 220                 fs_bits++;
 221         }
 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.");
 225                 return FALSE;
 226         }
 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.");
 232                 return FALSE;
 233         }
 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.");
 239                 return FALSE;
 240         }
 241         ntfs_debug("Done.");
 242         return TRUE;
 243 }
 244
 245 /**
 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
 249  *
 250  * Check the log client array of the restart page @rp for consistency and
 251  * return TRUE if it is consistent and FALSE otherwise.
 252  *
 253  * This function assumes that the restart page header and the restart area have
 254  * already been consistency checked.
 255  *
 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.
 259  */
 260 static BOOL ntfs_check_log_client_array(struct inode *vi,
 261                 RESTART_PAGE_HEADER *rp)
 262 {
 263         RESTART_AREA *ra;
 264         LOG_CLIENT_RECORD *ca, *cr;
 265         u16 nr_clients, idx;
 266         BOOL in_free_list, idx_is_first;
 267
 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));
 272         /*
 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.
 279          */
 280         nr_clients = le16_to_cpu(ra->log_clients);
 281         idx = le16_to_cpu(ra->client_free_list);
 282         in_free_list = TRUE;
 283 check_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))
 287                         goto err_out;
 288                 /* Set @cr to the current log client record. */
 289                 cr = ca + idx;
 290                 /* The first log client record must not have a prev_client. */
 291                 if (idx_is_first) {
 292                         if (cr->prev_client != LOGFILE_NO_CLIENT)
 293                                 goto err_out;
 294                         idx_is_first = FALSE;
 295                 }
 296         }
 297         /* Switch to and check the in use list if we just did the free list. */
 298         if (in_free_list) {
 299                 in_free_list = FALSE;
 300                 idx = le16_to_cpu(ra->client_in_use_list);
 301                 goto check_list;
 302         }
 303         ntfs_debug("Done.");
 304         return TRUE;
 305 err_out:
 306         ntfs_error(vi->i_sb, "$LogFile log client array is corrupt.");
 307         return FALSE;
 308 }
 309
 310 /**
 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
 317  *
 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.
 321  *
 322  * This function only needs NTFS_BLOCK_SIZE bytes in @rp, i.e. it does not
 323  * require the full restart page.
 324  *
 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.
 328  *
 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.
 331  *
 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.
 336  */
 337 static int ntfs_check_and_load_restart_page(struct inode *vi,
 338                 RESTART_PAGE_HEADER *rp, s64 pos, RESTART_PAGE_HEADER **wrp,
 339                 LSN *lsn)
 340 {
 341         RESTART_AREA *ra;
 342         RESTART_PAGE_HEADER *trp;
 343         int size, err;
 344
 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. */
 349                 return -EINVAL;
 350         }
 351         /* Check the restart area for consistency. */
 352         if (!ntfs_check_restart_area(vi, rp)) {
 353                 /* Error output already done inside the function. */
 354                 return -EINVAL;
 355         }
 356         ra = (RESTART_AREA*)((u8*)rp + le16_to_cpu(rp->restart_area_offset));
 357         /*
 358          * Allocate a buffer to store the whole restart page so we can multi
 359          * sector transfer deprotect it.
 360          */
 361         trp = ntfs_malloc_nofs(le32_to_cpu(rp->system_page_size));
 362         if (!trp) {
 363                 ntfs_error(vi->i_sb, "Failed to allocate memory for $LogFile "
 364                                 "restart page buffer.");
 365                 return -ENOMEM;
 366         }
 367         /*
 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.
 371          */
 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));
 375         } else {
 376                 pgoff_t idx;
 377                 struct page *page;
 378                 int have_read, to_read;
 379
 380                 /* First copy what we already have in @rp. */
 381                 memcpy(trp, rp, size);
 382                 /* Copy the remaining data one page at a time. */
 383                 have_read = size;
 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);
 387                 do {
 388                         page = ntfs_map_page(vi->i_mapping, idx);
 389                         if (IS_ERR(page)) {
 390                                 ntfs_error(vi->i_sb, "Error mapping $LogFile "
 391                                                 "page (index %lu).", idx);
 392                                 err = PTR_ERR(page);
 393                                 if (err != -EIO && err != -ENOMEM)
 394                                         err = -EIO;
 395                                 goto err_out;
 396                         }
 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);
 400                         have_read += size;
 401                         to_read -= size;
 402                         idx++;
 403                 } while (to_read > 0);
 404         }
 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))) {
 408                 /*
 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.
 412                  */
 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.");
 418                         err = -EINVAL;
 419                         goto err_out;
 420                 }
 421         }
 422         /*
 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.
 426          */
 427         err = 0;
 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)) {
 431                         err = -EINVAL;
 432                         goto err_out;
 433                 }
 434         }
 435         if (lsn) {
 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);
 440         }
 441         ntfs_debug("Done.");
 442         if (wrp)
 443                 *wrp = trp;
 444         else {
 445 err_out:
 446                 ntfs_free(trp);
 447         }
 448         return err;
 449 }
 450
 451 /**
 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
 455  *
 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.
 459  *
 460  * At present we only check the two restart pages and ignore the log record
 461  * pages.
 462  *
 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.
 467  */
 468 BOOL ntfs_check_logfile(struct inode *log_vi, RESTART_PAGE_HEADER **rp)
 469 {
 470         s64 size, pos;
 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;
 475         u8 *kaddr = 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;
 480         u8 log_page_bits;
 481
 482         ntfs_debug("Entering.");
 483         /* An empty $LogFile must have been clean before it got emptied. */
 484         if (NVolLogFileEmpty(vol))
 485                 goto is_empty;
 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;
 490         /*
 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.
 495          */
 496         if (PAGE_CACHE_SIZE >= DefaultLogPageSize && PAGE_CACHE_SIZE <=
 497                         DefaultLogPageSize * 2)
 498                 log_page_size = DefaultLogPageSize;
 499         else
 500                 log_page_size = PAGE_CACHE_SIZE;
 501         log_page_mask = log_page_size - 1;
 502         /*
 503          * Use generic_ffs() instead of ffs() to enable the compiler to
 504          * optimize log_page_size and log_page_bits into constants.
 505          */
 506         log_page_bits = generic_ffs(log_page_size) - 1;
 507         size &= ~(s64)(log_page_size - 1);
 508         /*
 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.
 511          */
 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.");
 515                 return FALSE;
 516         }
 517         /*
 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
 523          * to be empty.
 524          */
 525         for (pos = 0; pos < size; pos <<= 1) {
 526                 pgoff_t idx = pos >> PAGE_CACHE_SHIFT;
 527                 if (!page || page->index != idx) {
 528                         if (page)
 529                                 ntfs_unmap_page(page);
 530                         page = ntfs_map_page(mapping, idx);
 531                         if (IS_ERR(page)) {
 532                                 ntfs_error(vol->sb, "Error mapping $LogFile "
 533                                                 "page (index %lu).", idx);
 534                                 goto err_out;
 535                         }
 536                 }
 537                 kaddr = (u8*)page_address(page) + (pos & ~PAGE_CACHE_MASK);
 538                 /*
 539                  * A non-empty block means the logfile is not empty while an
 540                  * empty block after a non-empty block has been encountered
 541                  * means we are done.
 542                  */
 543                 if (!ntfs_is_empty_recordp((le32*)kaddr))
 544                         logfile_is_empty = FALSE;
 545                 else if (!logfile_is_empty)
 546                         break;
 547                 /*
 548                  * A log record page means there cannot be a restart page after
 549                  * this so no need to continue searching.
 550                  */
 551                 if (ntfs_is_rcrd_recordp((le32*)kaddr))
 552                         break;
 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)) {
 556                         if (!pos)
 557                                 pos = NTFS_BLOCK_SIZE >> 1;
 558                         continue;
 559                 }
 560                 /*
 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.
 564                  */
 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);
 569                 if (!err) {
 570                         /*
 571                          * If we have now found the first (modified by chkdsk)
 572                          * restart page, continue looking for the second one.
 573                          */
 574                         if (!pos) {
 575                                 pos = NTFS_BLOCK_SIZE >> 1;
 576                                 continue;
 577                         }
 578                         /*
 579                          * We have now found the second (modified by chkdsk)
 580                          * restart page, so we can stop looking.
 581                          */
 582                         break;
 583                 }
 584                 /*
 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.
 588                  */
 589                 if (err != -EINVAL) {
 590                         ntfs_unmap_page(page);
 591                         goto err_out;
 592                 }
 593                 /* Continue looking. */
 594                 if (!pos)
 595                         pos = NTFS_BLOCK_SIZE >> 1;
 596         }
 597         if (page)
 598                 ntfs_unmap_page(page);
 599         if (logfile_is_empty) {
 600                 NVolSetLogFileEmpty(vol);
 601 is_empty:
 602                 ntfs_debug("Done.  ($LogFile is empty.)");
 603                 return TRUE;
 604         }
 605         if (!rstr1_ph) {
 606                 BUG_ON(rstr2_ph);
 607                 ntfs_error(vol->sb, "Did not find any restart pages in "
 608                                 "$LogFile and it was not empty.");
 609                 return FALSE;
 610         }
 611         /* If both restart pages were found, use the more recent one. */
 612         if (rstr2_ph) {
 613                 /*
 614                  * If the second restart area is more recent, switch to it.
 615                  * Otherwise just throw it away.
 616                  */
 617                 if (rstr2_lsn > rstr1_lsn) {
 618                         ntfs_free(rstr1_ph);
 619                         rstr1_ph = rstr2_ph;
 620                         /* rstr1_lsn = rstr2_lsn; */
 621                 } else
 622                         ntfs_free(rstr2_ph);
 623                 rstr2_ph = NULL;
 624         }
 625         /* All consistency checks passed. */
 626         if (rp)
 627                 *rp = rstr1_ph;
 628         else
 629                 ntfs_free(rstr1_ph);
 630         ntfs_debug("Done.");
 631         return TRUE;
 632 err_out:
 633         if (rstr1_ph)
 634                 ntfs_free(rstr1_ph);
 635         return FALSE;
 636 }
 637
 638 /**
 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
 642  *
 643  * Analyze the $LogFile journal and return TRUE if it indicates the volume was
 644  * shutdown cleanly and FALSE if not.
 645  *
 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.
 652  *
 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.
 657  */
 658 BOOL ntfs_is_logfile_clean(struct inode *log_vi, const RESTART_PAGE_HEADER *rp)
 659 {
 660         ntfs_volume *vol = NTFS_SB(log_vi->i_sb);
 661         RESTART_AREA *ra;
 662
 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.)");
 667                 return TRUE;
 668         }
 669         BUG_ON(!rp);
 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 "
 675                                 "this function.");
 676                 return FALSE;
 677         }
 678         ra = (RESTART_AREA*)((u8*)rp + le16_to_cpu(rp->restart_area_offset));
 679         /*
 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.
 683          */
 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.");
 687                 return FALSE;
 688         }
 689         /* $LogFile indicates a clean shutdown. */
 690         ntfs_debug("Done.  $LogFile indicates a clean shutdown.");
 691         return TRUE;
 692 }
 693
 694 /**
 695  * ntfs_empty_logfile - empty the contents of the $LogFile journal
 696  * @log_vi:     struct inode of loaded journal $LogFile to empty
 697  *
 698  * Empty the contents of the $LogFile journal @log_vi and return TRUE on
 699  * success and FALSE on error.
 700  *
 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.
 704  */
 705 BOOL ntfs_empty_logfile(struct inode *log_vi)
 706 {
 707         ntfs_volume *vol = NTFS_SB(log_vi->i_sb);
 708
 709         ntfs_debug("Entering.");
 710         if (!NVolLogFileEmpty(vol)) {
 711                 int err;
 712
 713                 err = ntfs_attr_set(NTFS_I(log_vi), 0, i_size_read(log_vi),
 714                                 0xff);
 715                 if (unlikely(err)) {
 716                         ntfs_error(vol->sb, "Failed to fill $LogFile with "
 717                                         "0xff bytes (error code %i).", err);
 718                         return FALSE;
 719                 }
 720                 /* Set the flag so we do not have to do it again on remount. */
 721                 NVolSetLogFileEmpty(vol);
 722         }
 723         ntfs_debug("Done.");
 724         return TRUE;
 725 }
 726
 727 #endif /* NTFS_RW */