1 /* 2 * logfile.h - Defines for NTFS kernel journal ($LogFile) handling. Part of 3 * the Linux-NTFS project. 4 * 5 * Copyright (c) 2000-2005 Anton Altaparmakov 6 * 7 * This program/include file is free software; you can redistribute it and/or 8 * modify it under the terms of the GNU General Public License as published 9 * by the Free Software Foundation; either version 2 of the License, or 10 * (at your option) any later version. 11 * 12 * This program/include file is distributed in the hope that it will be 13 * useful, but WITHOUT ANY WARRANTY; without even the implied warranty 14 * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * GNU General Public License for more details. 16 * 17 * You should have received a copy of the GNU General Public License 18 * along with this program (in the main directory of the Linux-NTFS 19 * distribution in the file COPYING); if not, write to the Free Software 20 * Foundation,Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 21 */ 22 23 #ifndef _LINUX_NTFS_LOGFILE_H 24 #define _LINUX_NTFS_LOGFILE_H 25 26 #ifdef NTFS_RW 27 28 #include <linux/fs.h> 29 30 #include "types.h" 31 #include "endian.h" 32 #include "layout.h" 33 34 /* 35 * Journal ($LogFile) organization: 36 * 37 * Two restart areas present in the first two pages (restart pages, one restart 38 * area in each page). When the volume is dismounted they should be identical, 39 * except for the update sequence array which usually has a different update 40 * sequence number. 41 * 42 * These are followed by log records organized in pages headed by a log record 43 * header going up to log file size. Not all pages contain log records when a 44 * volume is first formatted, but as the volume ages, all records will be used. 45 * When the log file fills up, the records at the beginning are purged (by 46 * modifying the oldest_lsn to a higher value presumably) and writing begins 47 * at the beginning of the file. Effectively, the log file is viewed as a 48 * circular entity. 49 * 50 * NOTE: Windows NT, 2000, and XP all use log file version 1.1 but they accept 51 * versions <= 1.x, including 0.-1. (Yes, that is a minus one in there!) We 52 * probably only want to support 1.1 as this seems to be the current version 53 * and we don't know how that differs from the older versions. The only 54 * exception is if the journal is clean as marked by the two restart pages 55 * then it doesn't matter whether we are on an earlier version. We can just 56 * reinitialize the logfile and start again with version 1.1. 57 */ 58 59 /* Some $LogFile related constants. */ 60 #define MaxLogFileSize 0x100000000ULL 61 #define DefaultLogPageSize 4096 62 #define MinLogRecordPages 48 63 64 /* 65 * Log file restart page header (begins the restart area). 66 */ 67 typedef struct { 68 /*Ofs*/ 69 /* 0 NTFS_RECORD; -- Unfolded here as gcc doesn't like unnamed structs. */ 70 /* 0*/ NTFS_RECORD_TYPE magic; /* The magic is "RSTR". */ 71 /* 4*/ le16 usa_ofs; /* See NTFS_RECORD definition in layout.h. 72 When creating, set this to be immediately 73 after this header structure (without any 74 alignment). */ 75 /* 6*/ le16 usa_count; /* See NTFS_RECORD definition in layout.h. */ 76 77 /* 8*/ leLSN chkdsk_lsn; /* The last log file sequence number found by 78 chkdsk. Only used when the magic is changed 79 to "CHKD". Otherwise this is zero. */ 80 /* 16*/ le32 system_page_size; /* Byte size of system pages when the log file 81 was created, has to be >= 512 and a power of 82 2. Use this to calculate the required size 83 of the usa (usa_count) and add it to usa_ofs. 84 Then verify that the result is less than the 85 value of the restart_area_offset. */ 86 /* 20*/ le32 log_page_size; /* Byte size of log file pages, has to be >= 87 512 and a power of 2. The default is 4096 88 and is used when the system page size is 89 between 4096 and 8192. Otherwise this is 90 set to the system page size instead. */ 91 /* 24*/ le16 restart_area_offset;/* Byte offset from the start of this header to 92 the RESTART_AREA. Value has to be aligned 93 to 8-byte boundary. When creating, set this 94 to be after the usa. */ 95 /* 26*/ sle16 minor_ver; /* Log file minor version. Only check if major 96 version is 1. */ 97 /* 28*/ sle16 major_ver; /* Log file major version. We only support 98 version 1.1. */ 99 /* sizeof() = 30 (0x1e) bytes */ 100 } __attribute__ ((__packed__)) RESTART_PAGE_HEADER; 101 102 /* 103 * Constant for the log client indices meaning that there are no client records 104 * in this particular client array. Also inside the client records themselves, 105 * this means that there are no client records preceding or following this one. 106 */ 107 #define LOGFILE_NO_CLIENT cpu_to_le16(0xffff) 108 #define LOGFILE_NO_CLIENT_CPU 0xffff 109 110 /* 111 * These are the so far known RESTART_AREA_* flags (16-bit) which contain 112 * information about the log file in which they are present. 113 */ 114 enum { 115 RESTART_VOLUME_IS_CLEAN = cpu_to_le16(0x0002), 116 RESTART_SPACE_FILLER = cpu_to_le16(0xffff), /* gcc: Force enum bit width to 16. */ 117 } __attribute__ ((__packed__)); 118 119 typedef le16 RESTART_AREA_FLAGS; 120 121 /* 122 * Log file restart area record. The offset of this record is found by adding 123 * the offset of the RESTART_PAGE_HEADER to the restart_area_offset value found 124 * in it. See notes at restart_area_offset above. 125 */ 126 typedef struct { 127 /*Ofs*/ 128 /* 0*/ leLSN current_lsn; /* The current, i.e. last LSN inside the log 129 when the restart area was last written. 130 This happens often but what is the interval? 131 Is it just fixed time or is it every time a 132 check point is written or somethine else? 133 On create set to 0. */ 134 /* 8*/ le16 log_clients; /* Number of log client records in the array of 135 log client records which follows this 136 restart area. Must be 1. */ 137 /* 10*/ le16 client_free_list; /* The index of the first free log client record 138 in the array of log client records. 139 LOGFILE_NO_CLIENT means that there are no 140 free log client records in the array. 141 If != LOGFILE_NO_CLIENT, check that 142 log_clients > client_free_list. On Win2k 143 and presumably earlier, on a clean volume 144 this is != LOGFILE_NO_CLIENT, and it should 145 be 0, i.e. the first (and only) client 146 record is free and thus the logfile is 147 closed and hence clean. A dirty volume 148 would have left the logfile open and hence 149 this would be LOGFILE_NO_CLIENT. On WinXP 150 and presumably later, the logfile is always 151 open, even on clean shutdown so this should 152 always be LOGFILE_NO_CLIENT. */ 153 /* 12*/ le16 client_in_use_list;/* The index of the first in-use log client 154 record in the array of log client records. 155 LOGFILE_NO_CLIENT means that there are no 156 in-use log client records in the array. If 157 != LOGFILE_NO_CLIENT check that log_clients 158 > client_in_use_list. On Win2k and 159 presumably earlier, on a clean volume this 160 is LOGFILE_NO_CLIENT, i.e. there are no 161 client records in use and thus the logfile 162 is closed and hence clean. A dirty volume 163 would have left the logfile open and hence 164 this would be != LOGFILE_NO_CLIENT, and it 165 should be 0, i.e. the first (and only) 166 client record is in use. On WinXP and 167 presumably later, the logfile is always 168 open, even on clean shutdown so this should 169 always be 0. */ 170 /* 14*/ RESTART_AREA_FLAGS flags;/* Flags modifying LFS behaviour. On Win2k 171 and presumably earlier this is always 0. On 172 WinXP and presumably later, if the logfile 173 was shutdown cleanly, the second bit, 174 RESTART_VOLUME_IS_CLEAN, is set. This bit 175 is cleared when the volume is mounted by 176 WinXP and set when the volume is dismounted, 177 thus if the logfile is dirty, this bit is 178 clear. Thus we don't need to check the 179 Windows version to determine if the logfile 180 is clean. Instead if the logfile is closed, 181 we know it must be clean. If it is open and 182 this bit is set, we also know it must be 183 clean. If on the other hand the logfile is 184 open and this bit is clear, we can be almost 185 certain that the logfile is dirty. */ 186 /* 16*/ le32 seq_number_bits; /* How many bits to use for the sequence 187 number. This is calculated as 67 - the 188 number of bits required to store the logfile 189 size in bytes and this can be used in with 190 the specified file_size as a consistency 191 check. */ 192 /* 20*/ le16 restart_area_length;/* Length of the restart area including the 193 client array. Following checks required if 194 version matches. Otherwise, skip them. 195 restart_area_offset + restart_area_length 196 has to be <= system_page_size. Also, 197 restart_area_length has to be >= 198 client_array_offset + (log_clients * 199 sizeof(log client record)). */ 200 /* 22*/ le16 client_array_offset;/* Offset from the start of this record to 201 the first log client record if versions are 202 matched. When creating, set this to be 203 after this restart area structure, aligned 204 to 8-bytes boundary. If the versions do not 205 match, this is ignored and the offset is 206 assumed to be (sizeof(RESTART_AREA) + 7) & 207 ~7, i.e. rounded up to first 8-byte 208 boundary. Either way, client_array_offset 209 has to be aligned to an 8-byte boundary. 210 Also, restart_area_offset + 211 client_array_offset has to be <= 510. 212 Finally, client_array_offset + (log_clients 213 * sizeof(log client record)) has to be <= 214 system_page_size. On Win2k and presumably 215 earlier, this is 0x30, i.e. immediately 216 following this record. On WinXP and 217 presumably later, this is 0x40, i.e. there 218 are 16 extra bytes between this record and 219 the client array. This probably means that 220 the RESTART_AREA record is actually bigger 221 in WinXP and later. */ 222 /* 24*/ sle64 file_size; /* Usable byte size of the log file. If the 223 restart_area_offset + the offset of the 224 file_size are > 510 then corruption has 225 occurred. This is the very first check when 226 starting with the restart_area as if it 227 fails it means that some of the above values 228 will be corrupted by the multi sector 229 transfer protection. The file_size has to 230 be rounded down to be a multiple of the 231 log_page_size in the RESTART_PAGE_HEADER and 232 then it has to be at least big enough to 233 store the two restart pages and 48 (0x30) 234 log record pages. */ 235 /* 32*/ le32 last_lsn_data_length;/* Length of data of last LSN, not including 236 the log record header. On create set to 237 0. */ 238 /* 36*/ le16 log_record_header_length;/* Byte size of the log record header. 239 If the version matches then check that the 240 value of log_record_header_length is a 241 multiple of 8, i.e. 242 (log_record_header_length + 7) & ~7 == 243 log_record_header_length. When creating set 244 it to sizeof(LOG_RECORD_HEADER), aligned to 245 8 bytes. */ 246 /* 38*/ le16 log_page_data_offset;/* Offset to the start of data in a log record 247 page. Must be a multiple of 8. On create 248 set it to immediately after the update 249 sequence array of the log record page. */ 250 /* 40*/ le32 restart_log_open_count;/* A counter that gets incremented every 251 time the logfile is restarted which happens 252 at mount time when the logfile is opened. 253 When creating set to a random value. Win2k 254 sets it to the low 32 bits of the current 255 system time in NTFS format (see time.h). */ 256 /* 44*/ le32 reserved; /* Reserved/alignment to 8-byte boundary. */ 257 /* sizeof() = 48 (0x30) bytes */ 258 } __attribute__ ((__packed__)) RESTART_AREA; 259 260 /* 261 * Log client record. The offset of this record is found by adding the offset 262 * of the RESTART_AREA to the client_array_offset value found in it. 263 */ 264 typedef struct { 265 /*Ofs*/ 266 /* 0*/ leLSN oldest_lsn; /* Oldest LSN needed by this client. On create 267 set to 0. */ 268 /* 8*/ leLSN client_restart_lsn;/* LSN at which this client needs to restart 269 the volume, i.e. the current position within 270 the log file. At present, if clean this 271 should = current_lsn in restart area but it 272 probably also = current_lsn when dirty most 273 of the time. At create set to 0. */ 274 /* 16*/ le16 prev_client; /* The offset to the previous log client record 275 in the array of log client records. 276 LOGFILE_NO_CLIENT means there is no previous 277 client record, i.e. this is the first one. 278 This is always LOGFILE_NO_CLIENT. */ 279 /* 18*/ le16 next_client; /* The offset to the next log client record in 280 the array of log client records. 281 LOGFILE_NO_CLIENT means there are no next 282 client records, i.e. this is the last one. 283 This is always LOGFILE_NO_CLIENT. */ 284 /* 20*/ le16 seq_number; /* On Win2k and presumably earlier, this is set 285 to zero every time the logfile is restarted 286 and it is incremented when the logfile is 287 closed at dismount time. Thus it is 0 when 288 dirty and 1 when clean. On WinXP and 289 presumably later, this is always 0. */ 290 /* 22*/ u8 reserved[6]; /* Reserved/alignment. */ 291 /* 28*/ le32 client_name_length;/* Length of client name in bytes. Should 292 always be 8. */ 293 /* 32*/ ntfschar client_name[64];/* Name of the client in Unicode. Should 294 always be "NTFS" with the remaining bytes 295 set to 0. */ 296 /* sizeof() = 160 (0xa0) bytes */ 297 } __attribute__ ((__packed__)) LOG_CLIENT_RECORD; 298 299 extern bool ntfs_check_logfile(struct inode *log_vi, 300 RESTART_PAGE_HEADER **rp); 301 302 extern bool ntfs_is_logfile_clean(struct inode *log_vi, 303 const RESTART_PAGE_HEADER *rp); 304 305 extern bool ntfs_empty_logfile(struct inode *log_vi); 306 307 #endif /* NTFS_RW */ 308 309 #endif /* _LINUX_NTFS_LOGFILE_H */ 310