1 // SPDX-License-Identifier: GPL-2.0
4 * Copyright (C) 2019-2021 Paragon Software GmbH, All rights reserved.
8 #include <linux/blkdev.h>
9 #include <linux/buffer_head.h>
11 #include <linux/hash.h>
12 #include <linux/nls.h>
13 #include <linux/random.h>
14 #include <linux/ratelimit.h>
15 #include <linux/slab.h>
27 #define MaxLogFileSize 0x100000000ull
28 #define DefaultLogPageSize 4096
29 #define MinLogRecordPages 0x30
32 struct NTFS_RECORD_HEADER rhdr
; // 'RSTR'
33 __le32 sys_page_size
; // 0x10: Page size of the system which initialized the log.
34 __le32 page_size
; // 0x14: Log page size used for this log file.
35 __le16 ra_off
; // 0x18:
36 __le16 minor_ver
; // 0x1A:
37 __le16 major_ver
; // 0x1C:
41 #define LFS_NO_CLIENT 0xffff
42 #define LFS_NO_CLIENT_LE cpu_to_le16(0xffff)
46 __le64 restart_lsn
; // 0x08:
47 __le16 prev_client
; // 0x10:
48 __le16 next_client
; // 0x12:
49 __le16 seq_num
; // 0x14:
51 __le32 name_bytes
; // 0x1C: In bytes.
52 __le16 name
[32]; // 0x20: Name of client.
55 static_assert(sizeof(struct CLIENT_REC
) == 0x60);
57 /* Two copies of these will exist at the beginning of the log file */
59 __le64 current_lsn
; // 0x00: Current logical end of log file.
60 __le16 log_clients
; // 0x08: Maximum number of clients.
61 __le16 client_idx
[2]; // 0x0A: Free/use index into the client record arrays.
62 __le16 flags
; // 0x0E: See RESTART_SINGLE_PAGE_IO.
63 __le32 seq_num_bits
; // 0x10: The number of bits in sequence number.
64 __le16 ra_len
; // 0x14:
65 __le16 client_off
; // 0x16:
66 __le64 l_size
; // 0x18: Usable log file size.
67 __le32 last_lsn_data_len
; // 0x20:
68 __le16 rec_hdr_len
; // 0x24: Log page data offset.
69 __le16 data_off
; // 0x26: Log page data length.
70 __le32 open_log_count
; // 0x28:
71 __le32 align
[5]; // 0x2C:
72 struct CLIENT_REC clients
[]; // 0x40:
76 __le16 redo_op
; // 0x00: NTFS_LOG_OPERATION
77 __le16 undo_op
; // 0x02: NTFS_LOG_OPERATION
78 __le16 redo_off
; // 0x04: Offset to Redo record.
79 __le16 redo_len
; // 0x06: Redo length.
80 __le16 undo_off
; // 0x08: Offset to Undo record.
81 __le16 undo_len
; // 0x0A: Undo length.
82 __le16 target_attr
; // 0x0C:
83 __le16 lcns_follow
; // 0x0E:
84 __le16 record_off
; // 0x10:
85 __le16 attr_off
; // 0x12:
86 __le16 cluster_off
; // 0x14:
87 __le16 reserved
; // 0x16:
88 __le64 target_vcn
; // 0x18:
89 __le64 page_lcns
[]; // 0x20:
92 static_assert(sizeof(struct LOG_REC_HDR
) == 0x20);
94 #define RESTART_ENTRY_ALLOCATED 0xFFFFFFFF
95 #define RESTART_ENTRY_ALLOCATED_LE cpu_to_le32(0xFFFFFFFF)
97 struct RESTART_TABLE
{
98 __le16 size
; // 0x00: In bytes
99 __le16 used
; // 0x02: Entries
100 __le16 total
; // 0x04: Entries
101 __le16 res
[3]; // 0x06:
102 __le32 free_goal
; // 0x0C:
103 __le32 first_free
; // 0x10:
104 __le32 last_free
; // 0x14:
108 static_assert(sizeof(struct RESTART_TABLE
) == 0x18);
110 struct ATTR_NAME_ENTRY
{
111 __le16 off
; // Offset in the Open attribute Table.
116 struct OPEN_ATTR_ENRTY
{
117 __le32 next
; // 0x00: RESTART_ENTRY_ALLOCATED if allocated
118 __le32 bytes_per_index
; // 0x04:
119 enum ATTR_TYPE type
; // 0x08:
120 u8 is_dirty_pages
; // 0x0C:
121 u8 is_attr_name
; // 0x0B: Faked field to manage 'ptr'
122 u8 name_len
; // 0x0C: Faked field to manage 'ptr'
124 struct MFT_REF ref
; // 0x10: File Reference of file containing attribute
125 __le64 open_record_lsn
; // 0x18:
129 /* 32 bit version of 'struct OPEN_ATTR_ENRTY' */
130 struct OPEN_ATTR_ENRTY_32
{
131 __le32 next
; // 0x00: RESTART_ENTRY_ALLOCATED if allocated
133 struct MFT_REF ref
; // 0x08:
134 __le64 open_record_lsn
; // 0x10:
135 u8 is_dirty_pages
; // 0x18:
136 u8 is_attr_name
; // 0x19:
138 enum ATTR_TYPE type
; // 0x1C:
139 u8 name_len
; // 0x20: In wchar
141 __le32 AttributeName
; // 0x24:
142 __le32 bytes_per_index
; // 0x28:
145 #define SIZEOF_OPENATTRIBUTEENTRY0 0x2c
146 // static_assert( 0x2C == sizeof(struct OPEN_ATTR_ENRTY_32) );
147 static_assert(sizeof(struct OPEN_ATTR_ENRTY
) < SIZEOF_OPENATTRIBUTEENTRY0
);
150 * One entry exists in the Dirty Pages Table for each page which is dirty at
151 * the time the Restart Area is written.
153 struct DIR_PAGE_ENTRY
{
154 __le32 next
; // 0x00: RESTART_ENTRY_ALLOCATED if allocated
155 __le32 target_attr
; // 0x04: Index into the Open attribute Table
156 __le32 transfer_len
; // 0x08:
157 __le32 lcns_follow
; // 0x0C:
158 __le64 vcn
; // 0x10: Vcn of dirty page
159 __le64 oldest_lsn
; // 0x18:
160 __le64 page_lcns
[]; // 0x20:
163 static_assert(sizeof(struct DIR_PAGE_ENTRY
) == 0x20);
165 /* 32 bit version of 'struct DIR_PAGE_ENTRY' */
166 struct DIR_PAGE_ENTRY_32
{
167 __le32 next
; // 0x00: RESTART_ENTRY_ALLOCATED if allocated
168 __le32 target_attr
; // 0x04: Index into the Open attribute Table
169 __le32 transfer_len
; // 0x08:
170 __le32 lcns_follow
; // 0x0C:
171 __le32 reserved
; // 0x10:
172 __le32 vcn_low
; // 0x14: Vcn of dirty page
173 __le32 vcn_hi
; // 0x18: Vcn of dirty page
174 __le32 oldest_lsn_low
; // 0x1C:
175 __le32 oldest_lsn_hi
; // 0x1C:
176 __le32 page_lcns_low
; // 0x24:
177 __le32 page_lcns_hi
; // 0x24:
180 static_assert(offsetof(struct DIR_PAGE_ENTRY_32
, vcn_low
) == 0x14);
181 static_assert(sizeof(struct DIR_PAGE_ENTRY_32
) == 0x2c);
183 enum transact_state
{
184 TransactionUninitialized
= 0,
190 struct TRANSACTION_ENTRY
{
191 __le32 next
; // 0x00: RESTART_ENTRY_ALLOCATED if allocated
192 u8 transact_state
; // 0x04:
193 u8 reserved
[3]; // 0x05:
194 __le64 first_lsn
; // 0x08:
195 __le64 prev_lsn
; // 0x10:
196 __le64 undo_next_lsn
; // 0x18:
197 __le32 undo_records
; // 0x20: Number of undo log records pending abort
198 __le32 undo_len
; // 0x24: Total undo size
201 static_assert(sizeof(struct TRANSACTION_ENTRY
) == 0x28);
203 struct NTFS_RESTART
{
204 __le32 major_ver
; // 0x00:
205 __le32 minor_ver
; // 0x04:
206 __le64 check_point_start
; // 0x08:
207 __le64 open_attr_table_lsn
; // 0x10:
208 __le64 attr_names_lsn
; // 0x18:
209 __le64 dirty_pages_table_lsn
; // 0x20:
210 __le64 transact_table_lsn
; // 0x28:
211 __le32 open_attr_len
; // 0x30: In bytes
212 __le32 attr_names_len
; // 0x34: In bytes
213 __le32 dirty_pages_len
; // 0x38: In bytes
214 __le32 transact_table_len
; // 0x3C: In bytes
217 static_assert(sizeof(struct NTFS_RESTART
) == 0x40);
219 struct NEW_ATTRIBUTE_SIZES
{
226 struct BITMAP_RANGE
{
236 /* The following type defines the different log record types. */
237 #define LfsClientRecord cpu_to_le32(1)
238 #define LfsClientRestart cpu_to_le32(2)
240 /* This is used to uniquely identify a client for a particular log file. */
246 /* This is the header that begins every Log Record in the log file. */
247 struct LFS_RECORD_HDR
{
248 __le64 this_lsn
; // 0x00:
249 __le64 client_prev_lsn
; // 0x08:
250 __le64 client_undo_next_lsn
; // 0x10:
251 __le32 client_data_len
; // 0x18:
252 struct CLIENT_ID client
; // 0x1C: Owner of this log record.
253 __le32 record_type
; // 0x20: LfsClientRecord or LfsClientRestart.
254 __le32 transact_id
; // 0x24:
255 __le16 flags
; // 0x28: LOG_RECORD_MULTI_PAGE
256 u8 align
[6]; // 0x2A:
259 #define LOG_RECORD_MULTI_PAGE cpu_to_le16(1)
261 static_assert(sizeof(struct LFS_RECORD_HDR
) == 0x30);
264 __le16 next_record_off
; // 0x00: Offset of the free space in the page,
265 u8 align
[6]; // 0x02:
266 __le64 last_end_lsn
; // 0x08: lsn for the last log record which ends on the page,
269 static_assert(sizeof(struct LFS_RECORD
) == 0x10);
271 struct RECORD_PAGE_HDR
{
272 struct NTFS_RECORD_HEADER rhdr
; // 'RCRD'
273 __le32 rflags
; // 0x10: See LOG_PAGE_LOG_RECORD_END
274 __le16 page_count
; // 0x14:
275 __le16 page_pos
; // 0x16:
276 struct LFS_RECORD record_hdr
; // 0x18:
277 __le16 fixups
[10]; // 0x28:
278 __le32 file_off
; // 0x3c: Used when major version >= 2
283 // Page contains the end of a log record.
284 #define LOG_PAGE_LOG_RECORD_END cpu_to_le32(0x00000001)
286 static inline bool is_log_record_end(const struct RECORD_PAGE_HDR
*hdr
)
288 return hdr
->rflags
& LOG_PAGE_LOG_RECORD_END
;
291 static_assert(offsetof(struct RECORD_PAGE_HDR
, file_off
) == 0x3c);
294 * END of NTFS LOG structures
297 /* Define some tuning parameters to keep the restart tables a reasonable size. */
298 #define INITIAL_NUMBER_TRANSACTIONS 5
300 enum NTFS_LOG_OPERATION
{
303 CompensationLogRecord
= 0x01,
304 InitializeFileRecordSegment
= 0x02,
305 DeallocateFileRecordSegment
= 0x03,
306 WriteEndOfFileRecordSegment
= 0x04,
307 CreateAttribute
= 0x05,
308 DeleteAttribute
= 0x06,
309 UpdateResidentValue
= 0x07,
310 UpdateNonresidentValue
= 0x08,
311 UpdateMappingPairs
= 0x09,
312 DeleteDirtyClusters
= 0x0A,
313 SetNewAttributeSizes
= 0x0B,
314 AddIndexEntryRoot
= 0x0C,
315 DeleteIndexEntryRoot
= 0x0D,
316 AddIndexEntryAllocation
= 0x0E,
317 DeleteIndexEntryAllocation
= 0x0F,
318 WriteEndOfIndexBuffer
= 0x10,
319 SetIndexEntryVcnRoot
= 0x11,
320 SetIndexEntryVcnAllocation
= 0x12,
321 UpdateFileNameRoot
= 0x13,
322 UpdateFileNameAllocation
= 0x14,
323 SetBitsInNonresidentBitMap
= 0x15,
324 ClearBitsInNonresidentBitMap
= 0x16,
326 EndTopLevelAction
= 0x18,
327 PrepareTransaction
= 0x19,
328 CommitTransaction
= 0x1A,
329 ForgetTransaction
= 0x1B,
330 OpenNonresidentAttribute
= 0x1C,
331 OpenAttributeTableDump
= 0x1D,
332 AttributeNamesDump
= 0x1E,
333 DirtyPageTableDump
= 0x1F,
334 TransactionTableDump
= 0x20,
335 UpdateRecordDataRoot
= 0x21,
336 UpdateRecordDataAllocation
= 0x22,
338 UpdateRelativeDataInIndex
=
339 0x23, // NtOfsRestartUpdateRelativeDataInIndex
340 UpdateRelativeDataInIndex2
= 0x24,
341 ZeroEndOfFileRecord
= 0x25,
345 * Array for log records which require a target attribute.
346 * A true indicates that the corresponding restart operation
347 * requires a target attribute.
349 static const u8 AttributeRequired
[] = {
350 0xFC, 0xFB, 0xFF, 0x10, 0x06,
353 static inline bool is_target_required(u16 op
)
355 bool ret
= op
<= UpdateRecordDataAllocation
&&
356 (AttributeRequired
[op
>> 3] >> (op
& 7) & 1);
360 static inline bool can_skip_action(enum NTFS_LOG_OPERATION op
)
364 case DeleteDirtyClusters
:
366 case EndTopLevelAction
:
367 case PrepareTransaction
:
368 case CommitTransaction
:
369 case ForgetTransaction
:
370 case CompensationLogRecord
:
371 case OpenNonresidentAttribute
:
372 case OpenAttributeTableDump
:
373 case AttributeNamesDump
:
374 case DirtyPageTableDump
:
375 case TransactionTableDump
:
382 enum { lcb_ctx_undo_next
, lcb_ctx_prev
, lcb_ctx_next
};
384 /* Bytes per restart table. */
385 static inline u32
bytes_per_rt(const struct RESTART_TABLE
*rt
)
387 return le16_to_cpu(rt
->used
) * le16_to_cpu(rt
->size
) +
388 sizeof(struct RESTART_TABLE
);
391 /* Log record length. */
392 static inline u32
lrh_length(const struct LOG_REC_HDR
*lr
)
394 u16 t16
= le16_to_cpu(lr
->lcns_follow
);
396 return struct_size(lr
, page_lcns
, max_t(u16
, 1, t16
));
400 struct LFS_RECORD_HDR
*lrh
; // Log record header of the current lsn.
401 struct LOG_REC_HDR
*log_rec
;
402 u32 ctx_mode
; // lcb_ctx_undo_next/lcb_ctx_prev/lcb_ctx_next
403 struct CLIENT_ID client
;
404 bool alloc
; // If true the we should deallocate 'log_rec'.
407 static void lcb_put(struct lcb
*lcb
)
415 /* Find the oldest lsn from active clients. */
416 static inline void oldest_client_lsn(const struct CLIENT_REC
*ca
,
417 __le16 next_client
, u64
*oldest_lsn
)
419 while (next_client
!= LFS_NO_CLIENT_LE
) {
420 const struct CLIENT_REC
*cr
= ca
+ le16_to_cpu(next_client
);
421 u64 lsn
= le64_to_cpu(cr
->oldest_lsn
);
423 /* Ignore this block if it's oldest lsn is 0. */
424 if (lsn
&& lsn
< *oldest_lsn
)
427 next_client
= cr
->next_client
;
431 static inline bool is_rst_page_hdr_valid(u32 file_off
,
432 const struct RESTART_HDR
*rhdr
)
434 u32 sys_page
= le32_to_cpu(rhdr
->sys_page_size
);
435 u32 page_size
= le32_to_cpu(rhdr
->page_size
);
439 if (sys_page
< SECTOR_SIZE
|| page_size
< SECTOR_SIZE
||
440 sys_page
& (sys_page
- 1) || page_size
& (page_size
- 1)) {
444 /* Check that if the file offset isn't 0, it is the system page size. */
445 if (file_off
&& file_off
!= sys_page
)
448 /* Check support version 1.1+. */
449 if (le16_to_cpu(rhdr
->major_ver
) <= 1 && !rhdr
->minor_ver
)
452 if (le16_to_cpu(rhdr
->major_ver
) > 2)
455 ro
= le16_to_cpu(rhdr
->ra_off
);
456 if (!IS_ALIGNED(ro
, 8) || ro
> sys_page
)
459 end_usa
= ((sys_page
>> SECTOR_SHIFT
) + 1) * sizeof(short);
460 end_usa
+= le16_to_cpu(rhdr
->rhdr
.fix_off
);
468 static inline bool is_rst_area_valid(const struct RESTART_HDR
*rhdr
)
470 const struct RESTART_AREA
*ra
;
472 u32 off
, l_size
, file_dat_bits
, file_size_round
;
473 u16 ro
= le16_to_cpu(rhdr
->ra_off
);
474 u32 sys_page
= le32_to_cpu(rhdr
->sys_page_size
);
476 if (ro
+ offsetof(struct RESTART_AREA
, l_size
) >
477 SECTOR_SIZE
- sizeof(short))
480 ra
= Add2Ptr(rhdr
, ro
);
481 cl
= le16_to_cpu(ra
->log_clients
);
486 off
= le16_to_cpu(ra
->client_off
);
488 if (!IS_ALIGNED(off
, 8) || ro
+ off
> SECTOR_SIZE
- sizeof(short))
491 off
+= cl
* sizeof(struct CLIENT_REC
);
497 * Check the restart length field and whether the entire
498 * restart area is contained that length.
500 if (le16_to_cpu(rhdr
->ra_off
) + le16_to_cpu(ra
->ra_len
) > sys_page
||
501 off
> le16_to_cpu(ra
->ra_len
)) {
506 * As a final check make sure that the use list and the free list
507 * are either empty or point to a valid client.
509 fl
= le16_to_cpu(ra
->client_idx
[0]);
510 ul
= le16_to_cpu(ra
->client_idx
[1]);
511 if ((fl
!= LFS_NO_CLIENT
&& fl
>= cl
) ||
512 (ul
!= LFS_NO_CLIENT
&& ul
>= cl
))
515 /* Make sure the sequence number bits match the log file size. */
516 l_size
= le64_to_cpu(ra
->l_size
);
518 file_dat_bits
= sizeof(u64
) * 8 - le32_to_cpu(ra
->seq_num_bits
);
519 file_size_round
= 1u << (file_dat_bits
+ 3);
520 if (file_size_round
!= l_size
&&
521 (file_size_round
< l_size
|| (file_size_round
/ 2) > l_size
)) {
525 /* The log page data offset and record header length must be quad-aligned. */
526 if (!IS_ALIGNED(le16_to_cpu(ra
->data_off
), 8) ||
527 !IS_ALIGNED(le16_to_cpu(ra
->rec_hdr_len
), 8))
533 static inline bool is_client_area_valid(const struct RESTART_HDR
*rhdr
,
536 u16 ro
= le16_to_cpu(rhdr
->ra_off
);
537 const struct RESTART_AREA
*ra
= Add2Ptr(rhdr
, ro
);
538 u16 ra_len
= le16_to_cpu(ra
->ra_len
);
539 const struct CLIENT_REC
*ca
;
542 if (usa_error
&& ra_len
+ ro
> SECTOR_SIZE
- sizeof(short))
545 /* Find the start of the client array. */
546 ca
= Add2Ptr(ra
, le16_to_cpu(ra
->client_off
));
549 * Start with the free list.
550 * Check that all the clients are valid and that there isn't a cycle.
551 * Do the in-use list on the second pass.
553 for (i
= 0; i
< 2; i
++) {
554 u16 client_idx
= le16_to_cpu(ra
->client_idx
[i
]);
555 bool first_client
= true;
556 u16 clients
= le16_to_cpu(ra
->log_clients
);
558 while (client_idx
!= LFS_NO_CLIENT
) {
559 const struct CLIENT_REC
*cr
;
562 client_idx
>= le16_to_cpu(ra
->log_clients
))
566 cr
= ca
+ client_idx
;
568 client_idx
= le16_to_cpu(cr
->next_client
);
571 first_client
= false;
572 if (cr
->prev_client
!= LFS_NO_CLIENT_LE
)
584 * Remove a client record from a client record list an restart area.
586 static inline void remove_client(struct CLIENT_REC
*ca
,
587 const struct CLIENT_REC
*cr
, __le16
*head
)
589 if (cr
->prev_client
== LFS_NO_CLIENT_LE
)
590 *head
= cr
->next_client
;
592 ca
[le16_to_cpu(cr
->prev_client
)].next_client
= cr
->next_client
;
594 if (cr
->next_client
!= LFS_NO_CLIENT_LE
)
595 ca
[le16_to_cpu(cr
->next_client
)].prev_client
= cr
->prev_client
;
599 * add_client - Add a client record to the start of a list.
601 static inline void add_client(struct CLIENT_REC
*ca
, u16 index
, __le16
*head
)
603 struct CLIENT_REC
*cr
= ca
+ index
;
605 cr
->prev_client
= LFS_NO_CLIENT_LE
;
606 cr
->next_client
= *head
;
608 if (*head
!= LFS_NO_CLIENT_LE
)
609 ca
[le16_to_cpu(*head
)].prev_client
= cpu_to_le16(index
);
611 *head
= cpu_to_le16(index
);
614 static inline void *enum_rstbl(struct RESTART_TABLE
*t
, void *c
)
618 u16 rsize
= t
? le16_to_cpu(t
->size
) : 0;
623 e
= Add2Ptr(t
, sizeof(struct RESTART_TABLE
));
625 e
= Add2Ptr(c
, rsize
);
628 /* Loop until we hit the first one allocated, or the end of the list. */
629 for (bprt
= bytes_per_rt(t
); PtrOffset(t
, e
) < bprt
;
630 e
= Add2Ptr(e
, rsize
)) {
631 if (*e
== RESTART_ENTRY_ALLOCATED_LE
)
638 * find_dp - Search for a @vcn in Dirty Page Table.
640 static inline struct DIR_PAGE_ENTRY
*find_dp(struct RESTART_TABLE
*dptbl
,
641 u32 target_attr
, u64 vcn
)
643 __le32 ta
= cpu_to_le32(target_attr
);
644 struct DIR_PAGE_ENTRY
*dp
= NULL
;
646 while ((dp
= enum_rstbl(dptbl
, dp
))) {
647 u64 dp_vcn
= le64_to_cpu(dp
->vcn
);
649 if (dp
->target_attr
== ta
&& vcn
>= dp_vcn
&&
650 vcn
< dp_vcn
+ le32_to_cpu(dp
->lcns_follow
)) {
657 static inline u32
norm_file_page(u32 page_size
, u32
*l_size
, bool use_default
)
660 page_size
= DefaultLogPageSize
;
662 /* Round the file size down to a system page boundary. */
663 *l_size
&= ~(page_size
- 1);
665 /* File should contain at least 2 restart pages and MinLogRecordPages pages. */
666 if (*l_size
< (MinLogRecordPages
+ 2) * page_size
)
672 static bool check_log_rec(const struct LOG_REC_HDR
*lr
, u32 bytes
, u32 tr
,
673 u32 bytes_per_attr_entry
)
677 if (bytes
< sizeof(struct LOG_REC_HDR
))
682 if ((tr
- sizeof(struct RESTART_TABLE
)) %
683 sizeof(struct TRANSACTION_ENTRY
))
686 if (le16_to_cpu(lr
->redo_off
) & 7)
689 if (le16_to_cpu(lr
->undo_off
) & 7)
695 if (is_target_required(le16_to_cpu(lr
->redo_op
)))
698 if (is_target_required(le16_to_cpu(lr
->undo_op
)))
702 if (!lr
->lcns_follow
)
705 t16
= le16_to_cpu(lr
->target_attr
);
706 if ((t16
- sizeof(struct RESTART_TABLE
)) % bytes_per_attr_entry
)
710 if (bytes
< lrh_length(lr
))
716 static bool check_rstbl(const struct RESTART_TABLE
*rt
, size_t bytes
)
720 u16 rsize
= le16_to_cpu(rt
->size
);
721 u16 ne
= le16_to_cpu(rt
->used
);
722 u32 ff
= le32_to_cpu(rt
->first_free
);
723 u32 lf
= le32_to_cpu(rt
->last_free
);
725 ts
= rsize
* ne
+ sizeof(struct RESTART_TABLE
);
727 if (!rsize
|| rsize
> bytes
||
728 rsize
+ sizeof(struct RESTART_TABLE
) > bytes
|| bytes
< ts
||
729 le16_to_cpu(rt
->total
) > ne
|| ff
> ts
|| lf
> ts
||
730 (ff
&& ff
< sizeof(struct RESTART_TABLE
)) ||
731 (lf
&& lf
< sizeof(struct RESTART_TABLE
))) {
736 * Verify each entry is either allocated or points
737 * to a valid offset the table.
739 for (i
= 0; i
< ne
; i
++) {
740 off
= le32_to_cpu(*(__le32
*)Add2Ptr(
741 rt
, i
* rsize
+ sizeof(struct RESTART_TABLE
)));
743 if (off
!= RESTART_ENTRY_ALLOCATED
&& off
&&
744 (off
< sizeof(struct RESTART_TABLE
) ||
745 ((off
- sizeof(struct RESTART_TABLE
)) % rsize
))) {
751 * Walk through the list headed by the first entry to make
752 * sure none of the entries are currently being used.
754 for (off
= ff
; off
;) {
755 if (off
== RESTART_ENTRY_ALLOCATED
)
758 off
= le32_to_cpu(*(__le32
*)Add2Ptr(rt
, off
));
765 * free_rsttbl_idx - Free a previously allocated index a Restart Table.
767 static inline void free_rsttbl_idx(struct RESTART_TABLE
*rt
, u32 off
)
770 u32 lf
= le32_to_cpu(rt
->last_free
);
771 __le32 off_le
= cpu_to_le32(off
);
773 e
= Add2Ptr(rt
, off
);
775 if (off
< le32_to_cpu(rt
->free_goal
)) {
777 rt
->first_free
= off_le
;
779 rt
->last_free
= off_le
;
782 *(__le32
*)Add2Ptr(rt
, lf
) = off_le
;
784 rt
->first_free
= off_le
;
786 rt
->last_free
= off_le
;
790 le16_sub_cpu(&rt
->total
, 1);
793 static inline struct RESTART_TABLE
*init_rsttbl(u16 esize
, u16 used
)
795 __le32
*e
, *last_free
;
797 u32 bytes
= esize
* used
+ sizeof(struct RESTART_TABLE
);
798 u32 lf
= sizeof(struct RESTART_TABLE
) + (used
- 1) * esize
;
799 struct RESTART_TABLE
*t
= kzalloc(bytes
, GFP_NOFS
);
804 t
->size
= cpu_to_le16(esize
);
805 t
->used
= cpu_to_le16(used
);
806 t
->free_goal
= cpu_to_le32(~0u);
807 t
->first_free
= cpu_to_le32(sizeof(struct RESTART_TABLE
));
808 t
->last_free
= cpu_to_le32(lf
);
810 e
= (__le32
*)(t
+ 1);
811 last_free
= Add2Ptr(t
, lf
);
813 for (off
= sizeof(struct RESTART_TABLE
) + esize
; e
< last_free
;
814 e
= Add2Ptr(e
, esize
), off
+= esize
) {
815 *e
= cpu_to_le32(off
);
820 static inline struct RESTART_TABLE
*extend_rsttbl(struct RESTART_TABLE
*tbl
,
821 u32 add
, u32 free_goal
)
823 u16 esize
= le16_to_cpu(tbl
->size
);
824 __le32 osize
= cpu_to_le32(bytes_per_rt(tbl
));
825 u32 used
= le16_to_cpu(tbl
->used
);
826 struct RESTART_TABLE
*rt
;
828 rt
= init_rsttbl(esize
, used
+ add
);
832 memcpy(rt
+ 1, tbl
+ 1, esize
* used
);
834 rt
->free_goal
= free_goal
== ~0u
836 : cpu_to_le32(sizeof(struct RESTART_TABLE
) +
839 if (tbl
->first_free
) {
840 rt
->first_free
= tbl
->first_free
;
841 *(__le32
*)Add2Ptr(rt
, le32_to_cpu(tbl
->last_free
)) = osize
;
843 rt
->first_free
= osize
;
846 rt
->total
= tbl
->total
;
855 * Allocate an index from within a previously initialized Restart Table.
857 static inline void *alloc_rsttbl_idx(struct RESTART_TABLE
**tbl
)
861 struct RESTART_TABLE
*t
= *tbl
;
863 if (!t
->first_free
) {
864 *tbl
= t
= extend_rsttbl(t
, 16, ~0u);
869 off
= le32_to_cpu(t
->first_free
);
871 /* Dequeue this entry and zero it. */
876 memset(e
, 0, le16_to_cpu(t
->size
));
878 *e
= RESTART_ENTRY_ALLOCATED_LE
;
880 /* If list is going empty, then we fix the last_free as well. */
884 le16_add_cpu(&t
->total
, 1);
886 return Add2Ptr(t
, off
);
890 * alloc_rsttbl_from_idx
892 * Allocate a specific index from within a previously initialized Restart Table.
894 static inline void *alloc_rsttbl_from_idx(struct RESTART_TABLE
**tbl
, u32 vbo
)
898 struct RESTART_TABLE
*rt
= *tbl
;
899 u32 bytes
= bytes_per_rt(rt
);
900 u16 esize
= le16_to_cpu(rt
->size
);
902 /* If the entry is not the table, we will have to extend the table. */
905 * Extend the size by computing the number of entries between
906 * the existing size and the desired index and adding 1 to that.
908 u32 bytes2idx
= vbo
- bytes
;
911 * There should always be an integral number of entries
912 * being added. Now extend the table.
914 *tbl
= rt
= extend_rsttbl(rt
, bytes2idx
/ esize
+ 1, bytes
);
919 /* See if the entry is already allocated, and just return if it is. */
920 e
= Add2Ptr(rt
, vbo
);
922 if (*e
== RESTART_ENTRY_ALLOCATED_LE
)
926 * Walk through the table, looking for the entry we're
927 * interested and the previous entry.
929 off
= le32_to_cpu(rt
->first_free
);
930 e
= Add2Ptr(rt
, off
);
933 /* this is a match */
939 * Need to walk through the list looking for the predecessor
943 /* Remember the entry just found */
947 /* Should never run of entries. */
949 /* Lookup up the next entry the list. */
950 off
= le32_to_cpu(*last_e
);
951 e
= Add2Ptr(rt
, off
);
953 /* If this is our match we are done. */
958 * If this was the last entry, we update that
961 if (le32_to_cpu(rt
->last_free
) == off
)
962 rt
->last_free
= cpu_to_le32(last_off
);
968 /* If the list is now empty, we fix the last_free as well. */
972 /* Zero this entry. */
974 *e
= RESTART_ENTRY_ALLOCATED_LE
;
976 le16_add_cpu(&rt
->total
, 1);
981 #define RESTART_SINGLE_PAGE_IO cpu_to_le16(0x0001)
983 #define NTFSLOG_WRAPPED 0x00000001
984 #define NTFSLOG_MULTIPLE_PAGE_IO 0x00000002
985 #define NTFSLOG_NO_LAST_LSN 0x00000004
986 #define NTFSLOG_REUSE_TAIL 0x00000010
987 #define NTFSLOG_NO_OLDEST_LSN 0x00000020
989 /* Helper struct to work with NTFS $LogFile. */
991 struct ntfs_inode
*ni
;
997 u32 page_mask
; // page_size - 1
999 struct RECORD_PAGE_HDR
*one_page_buf
;
1001 struct RESTART_TABLE
*open_attr_tbl
;
1011 u16 record_header_len
;
1015 u32 seq_num_mask
; /* (1 << file_data_bits) - 1 */
1017 struct RESTART_AREA
*ra
; /* In-memory image of the next restart area. */
1018 u32 ra_size
; /* The usable size of the restart area. */
1021 * If true, then the in-memory restart area is to be written
1022 * to the first position on the disk.
1025 bool set_dirty
; /* True if we need to set dirty flag. */
1033 u32 total_avail_pages
;
1034 u32 total_undo_commit
;
1035 u32 max_current_avail
;
1042 u32 l_flags
; /* See NTFSLOG_XXX */
1043 u32 current_openlog_count
; /* On-disk value for open_log_count. */
1045 struct CLIENT_ID client_id
;
1046 u32 client_undo_commit
;
1049 static inline u32
lsn_to_vbo(struct ntfs_log
*log
, const u64 lsn
)
1051 u32 vbo
= (lsn
<< log
->seq_num_bits
) >> (log
->seq_num_bits
- 3);
1056 /* Compute the offset in the log file of the next log page. */
1057 static inline u32
next_page_off(struct ntfs_log
*log
, u32 off
)
1059 off
= (off
& ~log
->sys_page_mask
) + log
->page_size
;
1060 return off
>= log
->l_size
? log
->first_page
: off
;
1063 static inline u32
lsn_to_page_off(struct ntfs_log
*log
, u64 lsn
)
1065 return (((u32
)lsn
) << 3) & log
->page_mask
;
1068 static inline u64
vbo_to_lsn(struct ntfs_log
*log
, u32 off
, u64 Seq
)
1070 return (off
>> 3) + (Seq
<< log
->file_data_bits
);
1073 static inline bool is_lsn_in_file(struct ntfs_log
*log
, u64 lsn
)
1075 return lsn
>= log
->oldest_lsn
&&
1076 lsn
<= le64_to_cpu(log
->ra
->current_lsn
);
1079 static inline u32
hdr_file_off(struct ntfs_log
*log
,
1080 struct RECORD_PAGE_HDR
*hdr
)
1082 if (log
->major_ver
< 2)
1083 return le64_to_cpu(hdr
->rhdr
.lsn
);
1085 return le32_to_cpu(hdr
->file_off
);
1088 static inline u64
base_lsn(struct ntfs_log
*log
,
1089 const struct RECORD_PAGE_HDR
*hdr
, u64 lsn
)
1091 u64 h_lsn
= le64_to_cpu(hdr
->rhdr
.lsn
);
1092 u64 ret
= (((h_lsn
>> log
->file_data_bits
) +
1093 (lsn
< (lsn_to_vbo(log
, h_lsn
) & ~log
->page_mask
) ? 1 : 0))
1094 << log
->file_data_bits
) +
1095 ((((is_log_record_end(hdr
) &&
1096 h_lsn
<= le64_to_cpu(hdr
->record_hdr
.last_end_lsn
))
1097 ? le16_to_cpu(hdr
->record_hdr
.next_record_off
)
1105 static inline bool verify_client_lsn(struct ntfs_log
*log
,
1106 const struct CLIENT_REC
*client
, u64 lsn
)
1108 return lsn
>= le64_to_cpu(client
->oldest_lsn
) &&
1109 lsn
<= le64_to_cpu(log
->ra
->current_lsn
) && lsn
;
1112 struct restart_info
{
1114 struct RESTART_HDR
*r_page
;
1116 bool chkdsk_was_run
;
1122 static int read_log_page(struct ntfs_log
*log
, u32 vbo
,
1123 struct RECORD_PAGE_HDR
**buffer
, bool *usa_error
)
1126 u32 page_idx
= vbo
>> log
->page_bits
;
1127 u32 page_off
= vbo
& log
->page_mask
;
1128 u32 bytes
= log
->page_size
- page_off
;
1129 void *to_free
= NULL
;
1130 u32 page_vbo
= page_idx
<< log
->page_bits
;
1131 struct RECORD_PAGE_HDR
*page_buf
;
1132 struct ntfs_inode
*ni
= log
->ni
;
1135 if (vbo
>= log
->l_size
)
1139 to_free
= kmalloc(bytes
, GFP_NOFS
);
1145 page_buf
= page_off
? log
->one_page_buf
: *buffer
;
1147 err
= ntfs_read_run_nb(ni
->mi
.sbi
, &ni
->file
.run
, page_vbo
, page_buf
,
1148 log
->page_size
, NULL
);
1152 if (page_buf
->rhdr
.sign
!= NTFS_FFFF_SIGNATURE
)
1153 ntfs_fix_post_read(&page_buf
->rhdr
, PAGE_SIZE
, false);
1155 if (page_buf
!= *buffer
)
1156 memcpy(*buffer
, Add2Ptr(page_buf
, page_off
), bytes
);
1158 bBAAD
= page_buf
->rhdr
.sign
== NTFS_BAAD_SIGNATURE
;
1162 /* Check that the update sequence array for this page is valid */
1163 /* If we don't allow errors, raise an error status */
1168 if (err
&& to_free
) {
1179 * It walks through 512 blocks of the file looking for a valid
1180 * restart page header. It will stop the first time we find a
1181 * valid page header.
1183 static int log_read_rst(struct ntfs_log
*log
, u32 l_size
, bool first
,
1184 struct restart_info
*info
)
1187 struct RESTART_HDR
*r_page
= kmalloc(DefaultLogPageSize
, GFP_NOFS
);
1192 memset(info
, 0, sizeof(struct restart_info
));
1194 /* Determine which restart area we are looking for. */
1203 /* Loop continuously until we succeed. */
1204 for (; vbo
< l_size
; vbo
= 2 * vbo
+ skip
, skip
= 0) {
1208 struct RESTART_AREA
*ra
;
1210 /* Read a page header at the current offset. */
1211 if (read_log_page(log
, vbo
, (struct RECORD_PAGE_HDR
**)&r_page
,
1213 /* Ignore any errors. */
1217 /* Exit if the signature is a log record page. */
1218 if (r_page
->rhdr
.sign
== NTFS_RCRD_SIGNATURE
) {
1219 info
->initialized
= true;
1223 brst
= r_page
->rhdr
.sign
== NTFS_RSTR_SIGNATURE
;
1224 bchk
= r_page
->rhdr
.sign
== NTFS_CHKD_SIGNATURE
;
1226 if (!bchk
&& !brst
) {
1227 if (r_page
->rhdr
.sign
!= NTFS_FFFF_SIGNATURE
) {
1229 * Remember if the signature does not
1230 * indicate uninitialized file.
1232 info
->initialized
= true;
1238 info
->valid_page
= false;
1239 info
->initialized
= true;
1242 /* Let's check the restart area if this is a valid page. */
1243 if (!is_rst_page_hdr_valid(vbo
, r_page
))
1245 ra
= Add2Ptr(r_page
, le16_to_cpu(r_page
->ra_off
));
1247 if (!is_rst_area_valid(r_page
))
1251 * We have a valid restart page header and restart area.
1252 * If chkdsk was run or we have no clients then we have
1253 * no more checking to do.
1255 if (bchk
|| ra
->client_idx
[1] == LFS_NO_CLIENT_LE
) {
1256 info
->valid_page
= true;
1260 /* Read the entire restart area. */
1261 sys_page_size
= le32_to_cpu(r_page
->sys_page_size
);
1262 if (DefaultLogPageSize
!= sys_page_size
) {
1264 r_page
= kzalloc(sys_page_size
, GFP_NOFS
);
1268 if (read_log_page(log
, vbo
,
1269 (struct RECORD_PAGE_HDR
**)&r_page
,
1271 /* Ignore any errors. */
1278 if (is_client_area_valid(r_page
, usa_error
)) {
1279 info
->valid_page
= true;
1280 ra
= Add2Ptr(r_page
, le16_to_cpu(r_page
->ra_off
));
1285 * If chkdsk was run then update the caller's
1286 * values and return.
1288 if (r_page
->rhdr
.sign
== NTFS_CHKD_SIGNATURE
) {
1289 info
->chkdsk_was_run
= true;
1290 info
->last_lsn
= le64_to_cpu(r_page
->rhdr
.lsn
);
1291 info
->restart
= true;
1292 info
->r_page
= r_page
;
1297 * If we have a valid page then copy the values
1300 if (info
->valid_page
) {
1301 info
->last_lsn
= le64_to_cpu(ra
->current_lsn
);
1302 info
->restart
= true;
1303 info
->r_page
= r_page
;
1314 * Ilog_init_pg_hdr - Init @log from restart page header.
1316 static void log_init_pg_hdr(struct ntfs_log
*log
, u32 sys_page_size
,
1317 u32 page_size
, u16 major_ver
, u16 minor_ver
)
1319 log
->sys_page_size
= sys_page_size
;
1320 log
->sys_page_mask
= sys_page_size
- 1;
1321 log
->page_size
= page_size
;
1322 log
->page_mask
= page_size
- 1;
1323 log
->page_bits
= blksize_bits(page_size
);
1325 log
->clst_per_page
= log
->page_size
>> log
->ni
->mi
.sbi
->cluster_bits
;
1326 if (!log
->clst_per_page
)
1327 log
->clst_per_page
= 1;
1329 log
->first_page
= major_ver
>= 2
1331 : ((sys_page_size
<< 1) + (page_size
<< 1));
1332 log
->major_ver
= major_ver
;
1333 log
->minor_ver
= minor_ver
;
1337 * log_create - Init @log in cases when we don't have a restart area to use.
1339 static void log_create(struct ntfs_log
*log
, u32 l_size
, const u64 last_lsn
,
1340 u32 open_log_count
, bool wrapped
, bool use_multi_page
)
1342 log
->l_size
= l_size
;
1343 /* All file offsets must be quadword aligned. */
1344 log
->file_data_bits
= blksize_bits(l_size
) - 3;
1345 log
->seq_num_mask
= (8 << log
->file_data_bits
) - 1;
1346 log
->seq_num_bits
= sizeof(u64
) * 8 - log
->file_data_bits
;
1347 log
->seq_num
= (last_lsn
>> log
->file_data_bits
) + 2;
1348 log
->next_page
= log
->first_page
;
1349 log
->oldest_lsn
= log
->seq_num
<< log
->file_data_bits
;
1350 log
->oldest_lsn_off
= 0;
1351 log
->last_lsn
= log
->oldest_lsn
;
1353 log
->l_flags
|= NTFSLOG_NO_LAST_LSN
| NTFSLOG_NO_OLDEST_LSN
;
1355 /* Set the correct flags for the I/O and indicate if we have wrapped. */
1357 log
->l_flags
|= NTFSLOG_WRAPPED
;
1360 log
->l_flags
|= NTFSLOG_MULTIPLE_PAGE_IO
;
1362 /* Compute the log page values. */
1363 log
->data_off
= ALIGN(
1364 offsetof(struct RECORD_PAGE_HDR
, fixups
) +
1365 sizeof(short) * ((log
->page_size
>> SECTOR_SHIFT
) + 1), 8);
1366 log
->data_size
= log
->page_size
- log
->data_off
;
1367 log
->record_header_len
= sizeof(struct LFS_RECORD_HDR
);
1369 /* Remember the different page sizes for reservation. */
1370 log
->reserved
= log
->data_size
- log
->record_header_len
;
1372 /* Compute the restart page values. */
1373 log
->ra_off
= ALIGN(
1374 offsetof(struct RESTART_HDR
, fixups
) +
1375 sizeof(short) * ((log
->sys_page_size
>> SECTOR_SHIFT
) + 1), 8);
1376 log
->restart_size
= log
->sys_page_size
- log
->ra_off
;
1377 log
->ra_size
= struct_size(log
->ra
, clients
, 1);
1378 log
->current_openlog_count
= open_log_count
;
1381 * The total available log file space is the number of
1382 * log file pages times the space available on each page.
1384 log
->total_avail_pages
= log
->l_size
- log
->first_page
;
1385 log
->total_avail
= log
->total_avail_pages
>> log
->page_bits
;
1388 * We assume that we can't use the end of the page less than
1389 * the file record size.
1390 * Then we won't need to reserve more than the caller asks for.
1392 log
->max_current_avail
= log
->total_avail
* log
->reserved
;
1393 log
->total_avail
= log
->total_avail
* log
->data_size
;
1394 log
->current_avail
= log
->max_current_avail
;
1398 * log_create_ra - Fill a restart area from the values stored in @log.
1400 static struct RESTART_AREA
*log_create_ra(struct ntfs_log
*log
)
1402 struct CLIENT_REC
*cr
;
1403 struct RESTART_AREA
*ra
= kzalloc(log
->restart_size
, GFP_NOFS
);
1408 ra
->current_lsn
= cpu_to_le64(log
->last_lsn
);
1409 ra
->log_clients
= cpu_to_le16(1);
1410 ra
->client_idx
[1] = LFS_NO_CLIENT_LE
;
1411 if (log
->l_flags
& NTFSLOG_MULTIPLE_PAGE_IO
)
1412 ra
->flags
= RESTART_SINGLE_PAGE_IO
;
1413 ra
->seq_num_bits
= cpu_to_le32(log
->seq_num_bits
);
1414 ra
->ra_len
= cpu_to_le16(log
->ra_size
);
1415 ra
->client_off
= cpu_to_le16(offsetof(struct RESTART_AREA
, clients
));
1416 ra
->l_size
= cpu_to_le64(log
->l_size
);
1417 ra
->rec_hdr_len
= cpu_to_le16(log
->record_header_len
);
1418 ra
->data_off
= cpu_to_le16(log
->data_off
);
1419 ra
->open_log_count
= cpu_to_le32(log
->current_openlog_count
+ 1);
1423 cr
->prev_client
= LFS_NO_CLIENT_LE
;
1424 cr
->next_client
= LFS_NO_CLIENT_LE
;
1429 static u32
final_log_off(struct ntfs_log
*log
, u64 lsn
, u32 data_len
)
1431 u32 base_vbo
= lsn
<< 3;
1432 u32 final_log_off
= (base_vbo
& log
->seq_num_mask
) & ~log
->page_mask
;
1433 u32 page_off
= base_vbo
& log
->page_mask
;
1434 u32 tail
= log
->page_size
- page_off
;
1438 /* Add the length of the header. */
1439 data_len
+= log
->record_header_len
;
1442 * If this lsn is contained this log page we are done.
1443 * Otherwise we need to walk through several log pages.
1445 if (data_len
> tail
) {
1447 tail
= log
->data_size
;
1448 page_off
= log
->data_off
- 1;
1451 final_log_off
= next_page_off(log
, final_log_off
);
1454 * We are done if the remaining bytes
1457 if (data_len
<= tail
)
1464 * We add the remaining bytes to our starting position on this page
1465 * and then add that value to the file offset of this log page.
1467 return final_log_off
+ data_len
+ page_off
;
1470 static int next_log_lsn(struct ntfs_log
*log
, const struct LFS_RECORD_HDR
*rh
,
1474 u64 this_lsn
= le64_to_cpu(rh
->this_lsn
);
1475 u32 vbo
= lsn_to_vbo(log
, this_lsn
);
1477 final_log_off(log
, this_lsn
, le32_to_cpu(rh
->client_data_len
));
1478 u32 hdr_off
= end
& ~log
->sys_page_mask
;
1479 u64 seq
= this_lsn
>> log
->file_data_bits
;
1480 struct RECORD_PAGE_HDR
*page
= NULL
;
1482 /* Remember if we wrapped. */
1486 /* Log page header for this page. */
1487 err
= read_log_page(log
, hdr_off
, &page
, NULL
);
1492 * If the lsn we were given was not the last lsn on this page,
1493 * then the starting offset for the next lsn is on a quad word
1494 * boundary following the last file offset for the current lsn.
1495 * Otherwise the file offset is the start of the data on the next page.
1497 if (this_lsn
== le64_to_cpu(page
->rhdr
.lsn
)) {
1498 /* If we wrapped, we need to increment the sequence number. */
1499 hdr_off
= next_page_off(log
, hdr_off
);
1500 if (hdr_off
== log
->first_page
)
1503 vbo
= hdr_off
+ log
->data_off
;
1505 vbo
= ALIGN(end
, 8);
1508 /* Compute the lsn based on the file offset and the sequence count. */
1509 *lsn
= vbo_to_lsn(log
, vbo
, seq
);
1512 * If this lsn is within the legal range for the file, we return true.
1513 * Otherwise false indicates that there are no more lsn's.
1515 if (!is_lsn_in_file(log
, *lsn
))
1524 * current_log_avail - Calculate the number of bytes available for log records.
1526 static u32
current_log_avail(struct ntfs_log
*log
)
1528 u32 oldest_off
, next_free_off
, free_bytes
;
1530 if (log
->l_flags
& NTFSLOG_NO_LAST_LSN
) {
1531 /* The entire file is available. */
1532 return log
->max_current_avail
;
1536 * If there is a last lsn the restart area then we know that we will
1537 * have to compute the free range.
1538 * If there is no oldest lsn then start at the first page of the file.
1540 oldest_off
= (log
->l_flags
& NTFSLOG_NO_OLDEST_LSN
)
1542 : (log
->oldest_lsn_off
& ~log
->sys_page_mask
);
1545 * We will use the next log page offset to compute the next free page.
1546 * If we are going to reuse this page go to the next page.
1547 * If we are at the first page then use the end of the file.
1549 next_free_off
= (log
->l_flags
& NTFSLOG_REUSE_TAIL
)
1550 ? log
->next_page
+ log
->page_size
1551 : log
->next_page
== log
->first_page
1555 /* If the two offsets are the same then there is no available space. */
1556 if (oldest_off
== next_free_off
)
1559 * If the free offset follows the oldest offset then subtract
1560 * this range from the total available pages.
1563 oldest_off
< next_free_off
1564 ? log
->total_avail_pages
- (next_free_off
- oldest_off
)
1565 : oldest_off
- next_free_off
;
1567 free_bytes
>>= log
->page_bits
;
1568 return free_bytes
* log
->reserved
;
1571 static bool check_subseq_log_page(struct ntfs_log
*log
,
1572 const struct RECORD_PAGE_HDR
*rp
, u32 vbo
,
1576 const struct NTFS_RECORD_HEADER
*rhdr
= &rp
->rhdr
;
1577 u64 lsn
= le64_to_cpu(rhdr
->lsn
);
1579 if (rhdr
->sign
== NTFS_FFFF_SIGNATURE
|| !rhdr
->sign
)
1583 * If the last lsn on the page occurs was written after the page
1584 * that caused the original error then we have a fatal error.
1586 lsn_seq
= lsn
>> log
->file_data_bits
;
1589 * If the sequence number for the lsn the page is equal or greater
1590 * than lsn we expect, then this is a subsequent write.
1592 return lsn_seq
>= seq
||
1593 (lsn_seq
== seq
- 1 && log
->first_page
== vbo
&&
1594 vbo
!= (lsn_to_vbo(log
, lsn
) & ~log
->page_mask
));
1600 * Walks through the log pages for a file, searching for the
1601 * last log page written to the file.
1603 static int last_log_lsn(struct ntfs_log
*log
)
1606 bool usa_error
= false;
1607 bool replace_page
= false;
1608 bool reuse_page
= log
->l_flags
& NTFSLOG_REUSE_TAIL
;
1609 bool wrapped_file
, wrapped
;
1611 u32 page_cnt
= 1, page_pos
= 1;
1612 u32 page_off
= 0, page_off1
= 0, saved_off
= 0;
1613 u32 final_off
, second_off
, final_off_prev
= 0, second_off_prev
= 0;
1614 u32 first_file_off
= 0, second_file_off
= 0;
1615 u32 part_io_count
= 0;
1617 u32 this_off
, curpage_off
, nextpage_off
, remain_pages
;
1619 u64 expected_seq
, seq_base
= 0, lsn_base
= 0;
1620 u64 best_lsn
, best_lsn1
, best_lsn2
;
1621 u64 lsn_cur
, lsn1
, lsn2
;
1622 u64 last_ok_lsn
= reuse_page
? log
->last_lsn
: 0;
1624 u16 cur_pos
, best_page_pos
;
1626 struct RECORD_PAGE_HDR
*page
= NULL
;
1627 struct RECORD_PAGE_HDR
*tst_page
= NULL
;
1628 struct RECORD_PAGE_HDR
*first_tail
= NULL
;
1629 struct RECORD_PAGE_HDR
*second_tail
= NULL
;
1630 struct RECORD_PAGE_HDR
*tail_page
= NULL
;
1631 struct RECORD_PAGE_HDR
*second_tail_prev
= NULL
;
1632 struct RECORD_PAGE_HDR
*first_tail_prev
= NULL
;
1633 struct RECORD_PAGE_HDR
*page_bufs
= NULL
;
1634 struct RECORD_PAGE_HDR
*best_page
;
1636 if (log
->major_ver
>= 2) {
1637 final_off
= 0x02 * log
->page_size
;
1638 second_off
= 0x12 * log
->page_size
;
1640 // 0x10 == 0x12 - 0x2
1641 page_bufs
= kmalloc(log
->page_size
* 0x10, GFP_NOFS
);
1645 second_off
= log
->first_page
- log
->page_size
;
1646 final_off
= second_off
- log
->page_size
;
1650 /* Read second tail page (at pos 3/0x12000). */
1651 if (read_log_page(log
, second_off
, &second_tail
, &usa_error
) ||
1652 usa_error
|| second_tail
->rhdr
.sign
!= NTFS_RCRD_SIGNATURE
) {
1655 second_file_off
= 0;
1658 second_file_off
= hdr_file_off(log
, second_tail
);
1659 lsn2
= le64_to_cpu(second_tail
->record_hdr
.last_end_lsn
);
1662 /* Read first tail page (at pos 2/0x2000). */
1663 if (read_log_page(log
, final_off
, &first_tail
, &usa_error
) ||
1664 usa_error
|| first_tail
->rhdr
.sign
!= NTFS_RCRD_SIGNATURE
) {
1670 first_file_off
= hdr_file_off(log
, first_tail
);
1671 lsn1
= le64_to_cpu(first_tail
->record_hdr
.last_end_lsn
);
1674 if (log
->major_ver
< 2) {
1677 first_tail_prev
= first_tail
;
1678 final_off_prev
= first_file_off
;
1679 second_tail_prev
= second_tail
;
1680 second_off_prev
= second_file_off
;
1683 if (!first_tail
&& !second_tail
)
1686 if (first_tail
&& second_tail
)
1687 best_page
= lsn1
< lsn2
? 1 : 0;
1688 else if (first_tail
)
1693 page_off
= best_page
? second_file_off
: first_file_off
;
1694 seq_base
= (best_page
? lsn2
: lsn1
) >> log
->file_data_bits
;
1698 best_lsn1
= first_tail
? base_lsn(log
, first_tail
, first_file_off
) : 0;
1700 second_tail
? base_lsn(log
, second_tail
, second_file_off
) : 0;
1702 if (first_tail
&& second_tail
) {
1703 if (best_lsn1
> best_lsn2
) {
1704 best_lsn
= best_lsn1
;
1705 best_page
= first_tail
;
1706 this_off
= first_file_off
;
1708 best_lsn
= best_lsn2
;
1709 best_page
= second_tail
;
1710 this_off
= second_file_off
;
1712 } else if (first_tail
) {
1713 best_lsn
= best_lsn1
;
1714 best_page
= first_tail
;
1715 this_off
= first_file_off
;
1716 } else if (second_tail
) {
1717 best_lsn
= best_lsn2
;
1718 best_page
= second_tail
;
1719 this_off
= second_file_off
;
1724 best_page_pos
= le16_to_cpu(best_page
->page_pos
);
1727 if (best_page_pos
== page_pos
) {
1728 seq_base
= best_lsn
>> log
->file_data_bits
;
1729 saved_off
= page_off
= le32_to_cpu(best_page
->file_off
);
1730 lsn_base
= best_lsn
;
1732 memmove(page_bufs
, best_page
, log
->page_size
);
1734 page_cnt
= le16_to_cpu(best_page
->page_count
);
1740 } else if (seq_base
== (best_lsn
>> log
->file_data_bits
) &&
1741 saved_off
+ log
->page_size
== this_off
&&
1742 lsn_base
< best_lsn
&&
1743 (page_pos
!= page_cnt
|| best_page_pos
== page_pos
||
1744 best_page_pos
== 1) &&
1745 (page_pos
>= page_cnt
|| best_page_pos
== page_pos
)) {
1746 u16 bppc
= le16_to_cpu(best_page
->page_count
);
1748 saved_off
+= log
->page_size
;
1749 lsn_base
= best_lsn
;
1751 memmove(Add2Ptr(page_bufs
, tails
* log
->page_size
), best_page
,
1756 if (best_page_pos
!= bppc
) {
1758 page_pos
= best_page_pos
;
1763 page_pos
= page_cnt
= 1;
1771 kfree(first_tail_prev
);
1772 first_tail_prev
= first_tail
;
1773 final_off_prev
= first_file_off
;
1776 kfree(second_tail_prev
);
1777 second_tail_prev
= second_tail
;
1778 second_off_prev
= second_file_off
;
1781 final_off
+= log
->page_size
;
1782 second_off
+= log
->page_size
;
1787 first_tail
= first_tail_prev
;
1788 final_off
= final_off_prev
;
1790 second_tail
= second_tail_prev
;
1791 second_off
= second_off_prev
;
1793 page_cnt
= page_pos
= 1;
1795 curpage_off
= seq_base
== log
->seq_num
? min(log
->next_page
, page_off
)
1799 curpage_off
== log
->first_page
&&
1800 !(log
->l_flags
& (NTFSLOG_NO_LAST_LSN
| NTFSLOG_REUSE_TAIL
));
1802 expected_seq
= wrapped_file
? (log
->seq_num
+ 1) : log
->seq_num
;
1804 nextpage_off
= curpage_off
;
1808 /* Read the next log page. */
1809 err
= read_log_page(log
, curpage_off
, &page
, &usa_error
);
1811 /* Compute the next log page offset the file. */
1812 nextpage_off
= next_page_off(log
, curpage_off
);
1813 wrapped
= nextpage_off
== log
->first_page
;
1816 struct RECORD_PAGE_HDR
*cur_page
=
1817 Add2Ptr(page_bufs
, curpage_off
- page_off
);
1819 if (curpage_off
== saved_off
) {
1820 tail_page
= cur_page
;
1824 if (page_off
> curpage_off
|| curpage_off
>= saved_off
)
1830 if (!err
&& !usa_error
&&
1831 page
->rhdr
.sign
== NTFS_RCRD_SIGNATURE
&&
1832 cur_page
->rhdr
.lsn
== page
->rhdr
.lsn
&&
1833 cur_page
->record_hdr
.next_record_off
==
1834 page
->record_hdr
.next_record_off
&&
1835 ((page_pos
== page_cnt
&&
1836 le16_to_cpu(page
->page_pos
) == 1) ||
1837 (page_pos
!= page_cnt
&&
1838 le16_to_cpu(page
->page_pos
) == page_pos
+ 1 &&
1839 le16_to_cpu(page
->page_count
) == page_cnt
))) {
1844 page_off1
= page_off
;
1848 lsn_cur
= le64_to_cpu(cur_page
->rhdr
.lsn
);
1851 le64_to_cpu(cur_page
->record_hdr
.last_end_lsn
) &&
1852 ((lsn_cur
>> log
->file_data_bits
) +
1854 (lsn_to_vbo(log
, lsn_cur
) & ~log
->page_mask
))
1856 : 0)) != expected_seq
) {
1860 if (!is_log_record_end(cur_page
)) {
1862 last_ok_lsn
= lsn_cur
;
1866 log
->seq_num
= expected_seq
;
1867 log
->l_flags
&= ~NTFSLOG_NO_LAST_LSN
;
1868 log
->last_lsn
= le64_to_cpu(cur_page
->record_hdr
.last_end_lsn
);
1869 log
->ra
->current_lsn
= cur_page
->record_hdr
.last_end_lsn
;
1871 if (log
->record_header_len
<=
1873 le16_to_cpu(cur_page
->record_hdr
.next_record_off
)) {
1874 log
->l_flags
|= NTFSLOG_REUSE_TAIL
;
1875 log
->next_page
= curpage_off
;
1877 log
->l_flags
&= ~NTFSLOG_REUSE_TAIL
;
1878 log
->next_page
= nextpage_off
;
1882 log
->l_flags
|= NTFSLOG_WRAPPED
;
1884 last_ok_lsn
= le64_to_cpu(cur_page
->record_hdr
.last_end_lsn
);
1889 * If we are at the expected first page of a transfer check to see
1890 * if either tail copy is at this offset.
1891 * If this page is the last page of a transfer, check if we wrote
1892 * a subsequent tail copy.
1894 if (page_cnt
== page_pos
|| page_cnt
== page_pos
+ 1) {
1896 * Check if the offset matches either the first or second
1897 * tail copy. It is possible it will match both.
1899 if (curpage_off
== final_off
)
1900 tail_page
= first_tail
;
1903 * If we already matched on the first page then
1904 * check the ending lsn's.
1906 if (curpage_off
== second_off
) {
1909 le64_to_cpu(second_tail
->record_hdr
.last_end_lsn
) >
1910 le64_to_cpu(first_tail
->record_hdr
1912 tail_page
= second_tail
;
1919 /* We have a candidate for a tail copy. */
1920 lsn_cur
= le64_to_cpu(tail_page
->record_hdr
.last_end_lsn
);
1922 if (last_ok_lsn
< lsn_cur
) {
1924 * If the sequence number is not expected,
1925 * then don't use the tail copy.
1927 if (expected_seq
!= (lsn_cur
>> log
->file_data_bits
))
1929 } else if (last_ok_lsn
> lsn_cur
) {
1931 * If the last lsn is greater than the one on
1932 * this page then forget this tail.
1939 *If we have an error on the current page,
1940 * we will break of this loop.
1942 if (err
|| usa_error
)
1946 * Done if the last lsn on this page doesn't match the previous known
1947 * last lsn or the sequence number is not expected.
1949 lsn_cur
= le64_to_cpu(page
->rhdr
.lsn
);
1950 if (last_ok_lsn
!= lsn_cur
&&
1951 expected_seq
!= (lsn_cur
>> log
->file_data_bits
)) {
1956 * Check that the page position and page count values are correct.
1957 * If this is the first page of a transfer the position must be 1
1958 * and the count will be unknown.
1960 if (page_cnt
== page_pos
) {
1961 if (page
->page_pos
!= cpu_to_le16(1) &&
1962 (!reuse_page
|| page
->page_pos
!= page
->page_count
)) {
1964 * If the current page is the first page we are
1965 * looking at and we are reusing this page then
1966 * it can be either the first or last page of a
1967 * transfer. Otherwise it can only be the first.
1971 } else if (le16_to_cpu(page
->page_count
) != page_cnt
||
1972 le16_to_cpu(page
->page_pos
) != page_pos
+ 1) {
1974 * The page position better be 1 more than the last page
1975 * position and the page count better match.
1981 * We have a valid page the file and may have a valid page
1982 * the tail copy area.
1983 * If the tail page was written after the page the file then
1984 * break of the loop.
1987 le64_to_cpu(tail_page
->record_hdr
.last_end_lsn
) > lsn_cur
) {
1988 /* Remember if we will replace the page. */
1989 replace_page
= true;
1995 if (is_log_record_end(page
)) {
1997 * Since we have read this page we know the sequence number
1998 * is the same as our expected value.
2000 log
->seq_num
= expected_seq
;
2001 log
->last_lsn
= le64_to_cpu(page
->record_hdr
.last_end_lsn
);
2002 log
->ra
->current_lsn
= page
->record_hdr
.last_end_lsn
;
2003 log
->l_flags
&= ~NTFSLOG_NO_LAST_LSN
;
2006 * If there is room on this page for another header then
2007 * remember we want to reuse the page.
2009 if (log
->record_header_len
<=
2011 le16_to_cpu(page
->record_hdr
.next_record_off
)) {
2012 log
->l_flags
|= NTFSLOG_REUSE_TAIL
;
2013 log
->next_page
= curpage_off
;
2015 log
->l_flags
&= ~NTFSLOG_REUSE_TAIL
;
2016 log
->next_page
= nextpage_off
;
2019 /* Remember if we wrapped the log file. */
2021 log
->l_flags
|= NTFSLOG_WRAPPED
;
2025 * Remember the last page count and position.
2026 * Also remember the last known lsn.
2028 page_cnt
= le16_to_cpu(page
->page_count
);
2029 page_pos
= le16_to_cpu(page
->page_pos
);
2030 last_ok_lsn
= le64_to_cpu(page
->rhdr
.lsn
);
2039 curpage_off
= nextpage_off
;
2047 log
->seq_num
= expected_seq
;
2048 log
->last_lsn
= le64_to_cpu(tail_page
->record_hdr
.last_end_lsn
);
2049 log
->ra
->current_lsn
= tail_page
->record_hdr
.last_end_lsn
;
2050 log
->l_flags
&= ~NTFSLOG_NO_LAST_LSN
;
2052 if (log
->page_size
-
2054 tail_page
->record_hdr
.next_record_off
) >=
2055 log
->record_header_len
) {
2056 log
->l_flags
|= NTFSLOG_REUSE_TAIL
;
2057 log
->next_page
= curpage_off
;
2059 log
->l_flags
&= ~NTFSLOG_REUSE_TAIL
;
2060 log
->next_page
= nextpage_off
;
2064 log
->l_flags
|= NTFSLOG_WRAPPED
;
2067 /* Remember that the partial IO will start at the next page. */
2068 second_off
= nextpage_off
;
2071 * If the next page is the first page of the file then update
2072 * the sequence number for log records which begon the next page.
2078 * If we have a tail copy or are performing single page I/O we can
2079 * immediately look at the next page.
2081 if (replace_page
|| (log
->ra
->flags
& RESTART_SINGLE_PAGE_IO
)) {
2087 if (page_pos
!= page_cnt
)
2090 * If the next page causes us to wrap to the beginning of the log
2091 * file then we know which page to check next.
2105 /* Walk through the file, reading log pages. */
2106 err
= read_log_page(log
, nextpage_off
, &tst_page
, &usa_error
);
2109 * If we get a USA error then assume that we correctly found
2110 * the end of the original transfer.
2116 * If we were able to read the page, we examine it to see if it
2117 * is the same or different Io block.
2120 goto next_test_page_1
;
2122 if (le16_to_cpu(tst_page
->page_pos
) == cur_pos
&&
2123 check_subseq_log_page(log
, tst_page
, nextpage_off
, expected_seq
)) {
2124 page_cnt
= le16_to_cpu(tst_page
->page_count
) + 1;
2125 page_pos
= le16_to_cpu(tst_page
->page_pos
);
2133 nextpage_off
= next_page_off(log
, curpage_off
);
2134 wrapped
= nextpage_off
== log
->first_page
;
2145 goto next_test_page
;
2148 /* Skip over the remaining pages this transfer. */
2149 remain_pages
= page_cnt
- page_pos
- 1;
2150 part_io_count
+= remain_pages
;
2152 while (remain_pages
--) {
2153 nextpage_off
= next_page_off(log
, curpage_off
);
2154 wrapped
= nextpage_off
== log
->first_page
;
2160 /* Call our routine to check this log page. */
2164 err
= read_log_page(log
, nextpage_off
, &tst_page
, &usa_error
);
2165 if (!err
&& !usa_error
&&
2166 check_subseq_log_page(log
, tst_page
, nextpage_off
, expected_seq
)) {
2173 /* We have a valid file. */
2174 if (page_off1
|| tail_page
) {
2175 struct RECORD_PAGE_HDR
*tmp_page
;
2177 if (sb_rdonly(log
->ni
->mi
.sbi
->sb
)) {
2183 tmp_page
= Add2Ptr(page_bufs
, page_off1
- page_off
);
2184 tails
-= (page_off1
- page_off
) / log
->page_size
;
2188 tmp_page
= tail_page
;
2193 u64 off
= hdr_file_off(log
, tmp_page
);
2196 page
= kmalloc(log
->page_size
, GFP_NOFS
);
2202 * Correct page and copy the data from this page
2203 * into it and flush it to disk.
2205 memcpy(page
, tmp_page
, log
->page_size
);
2207 /* Fill last flushed lsn value flush the page. */
2208 if (log
->major_ver
< 2)
2209 page
->rhdr
.lsn
= page
->record_hdr
.last_end_lsn
;
2213 page
->page_pos
= page
->page_count
= cpu_to_le16(1);
2215 ntfs_fix_pre_write(&page
->rhdr
, log
->page_size
);
2217 err
= ntfs_sb_write_run(log
->ni
->mi
.sbi
,
2218 &log
->ni
->file
.run
, off
, page
,
2224 if (part_io_count
&& second_off
== off
) {
2225 second_off
+= log
->page_size
;
2229 tmp_page
= Add2Ptr(tmp_page
, log
->page_size
);
2233 if (part_io_count
) {
2234 if (sb_rdonly(log
->ni
->mi
.sbi
->sb
)) {
2251 * read_log_rec_buf - Copy a log record from the file to a buffer.
2253 * The log record may span several log pages and may even wrap the file.
2255 static int read_log_rec_buf(struct ntfs_log
*log
,
2256 const struct LFS_RECORD_HDR
*rh
, void *buffer
)
2259 struct RECORD_PAGE_HDR
*ph
= NULL
;
2260 u64 lsn
= le64_to_cpu(rh
->this_lsn
);
2261 u32 vbo
= lsn_to_vbo(log
, lsn
) & ~log
->page_mask
;
2262 u32 off
= lsn_to_page_off(log
, lsn
) + log
->record_header_len
;
2263 u32 data_len
= le32_to_cpu(rh
->client_data_len
);
2266 * While there are more bytes to transfer,
2267 * we continue to attempt to perform the read.
2271 u32 tail
= log
->page_size
- off
;
2273 if (tail
>= data_len
)
2278 err
= read_log_page(log
, vbo
, &ph
, &usa_error
);
2283 * The last lsn on this page better be greater or equal
2284 * to the lsn we are copying.
2286 if (lsn
> le64_to_cpu(ph
->rhdr
.lsn
)) {
2291 memcpy(buffer
, Add2Ptr(ph
, off
), tail
);
2293 /* If there are no more bytes to transfer, we exit the loop. */
2295 if (!is_log_record_end(ph
) ||
2296 lsn
> le64_to_cpu(ph
->record_hdr
.last_end_lsn
)) {
2303 if (ph
->rhdr
.lsn
== ph
->record_hdr
.last_end_lsn
||
2304 lsn
> le64_to_cpu(ph
->rhdr
.lsn
)) {
2309 vbo
= next_page_off(log
, vbo
);
2310 off
= log
->data_off
;
2313 * Adjust our pointer the user's buffer to transfer
2314 * the next block to.
2316 buffer
= Add2Ptr(buffer
, tail
);
2324 static int read_rst_area(struct ntfs_log
*log
, struct NTFS_RESTART
**rst_
,
2328 struct LFS_RECORD_HDR
*rh
= NULL
;
2329 const struct CLIENT_REC
*cr
=
2330 Add2Ptr(log
->ra
, le16_to_cpu(log
->ra
->client_off
));
2331 u64 lsnr
, lsnc
= le64_to_cpu(cr
->restart_lsn
);
2333 struct NTFS_RESTART
*rst
;
2338 /* If the client doesn't have a restart area, go ahead and exit now. */
2342 err
= read_log_page(log
, lsn_to_vbo(log
, lsnc
),
2343 (struct RECORD_PAGE_HDR
**)&rh
, NULL
);
2348 lsnr
= le64_to_cpu(rh
->this_lsn
);
2351 /* If the lsn values don't match, then the disk is corrupt. */
2357 len
= le32_to_cpu(rh
->client_data_len
);
2364 if (len
< sizeof(struct NTFS_RESTART
)) {
2369 rst
= kmalloc(len
, GFP_NOFS
);
2375 /* Copy the data into the 'rst' buffer. */
2376 err
= read_log_rec_buf(log
, rh
, rst
);
2390 static int find_log_rec(struct ntfs_log
*log
, u64 lsn
, struct lcb
*lcb
)
2393 struct LFS_RECORD_HDR
*rh
= lcb
->lrh
;
2396 /* Read the record header for this lsn. */
2398 err
= read_log_page(log
, lsn_to_vbo(log
, lsn
),
2399 (struct RECORD_PAGE_HDR
**)&rh
, NULL
);
2407 * If the lsn the log record doesn't match the desired
2408 * lsn then the disk is corrupt.
2410 if (lsn
!= le64_to_cpu(rh
->this_lsn
))
2413 len
= le32_to_cpu(rh
->client_data_len
);
2416 * Check that the length field isn't greater than the total
2417 * available space the log file.
2419 rec_len
= len
+ log
->record_header_len
;
2420 if (rec_len
>= log
->total_avail
)
2424 * If the entire log record is on this log page,
2425 * put a pointer to the log record the context block.
2427 if (rh
->flags
& LOG_RECORD_MULTI_PAGE
) {
2428 void *lr
= kmalloc(len
, GFP_NOFS
);
2436 /* Copy the data into the buffer returned. */
2437 err
= read_log_rec_buf(log
, rh
, lr
);
2441 /* If beyond the end of the current page -> an error. */
2442 u32 page_off
= lsn_to_page_off(log
, lsn
);
2444 if (page_off
+ len
+ log
->record_header_len
> log
->page_size
)
2447 lcb
->log_rec
= Add2Ptr(rh
, sizeof(struct LFS_RECORD_HDR
));
2455 * read_log_rec_lcb - Init the query operation.
2457 static int read_log_rec_lcb(struct ntfs_log
*log
, u64 lsn
, u32 ctx_mode
,
2461 const struct CLIENT_REC
*cr
;
2465 case lcb_ctx_undo_next
:
2473 /* Check that the given lsn is the legal range for this client. */
2474 cr
= Add2Ptr(log
->ra
, le16_to_cpu(log
->ra
->client_off
));
2476 if (!verify_client_lsn(log
, cr
, lsn
))
2479 lcb
= kzalloc(sizeof(struct lcb
), GFP_NOFS
);
2482 lcb
->client
= log
->client_id
;
2483 lcb
->ctx_mode
= ctx_mode
;
2485 /* Find the log record indicated by the given lsn. */
2486 err
= find_log_rec(log
, lsn
, lcb
);
2500 * find_client_next_lsn
2502 * Attempt to find the next lsn to return to a client based on the context mode.
2504 static int find_client_next_lsn(struct ntfs_log
*log
, struct lcb
*lcb
, u64
*lsn
)
2508 struct LFS_RECORD_HDR
*hdr
;
2513 if (lcb_ctx_next
!= lcb
->ctx_mode
)
2514 goto check_undo_next
;
2516 /* Loop as long as another lsn can be found. */
2520 err
= next_log_lsn(log
, hdr
, ¤t_lsn
);
2527 if (hdr
!= lcb
->lrh
)
2531 err
= read_log_page(log
, lsn_to_vbo(log
, current_lsn
),
2532 (struct RECORD_PAGE_HDR
**)&hdr
, NULL
);
2536 if (memcmp(&hdr
->client
, &lcb
->client
,
2537 sizeof(struct CLIENT_ID
))) {
2539 } else if (LfsClientRecord
== hdr
->record_type
) {
2548 if (hdr
!= lcb
->lrh
)
2553 if (lcb_ctx_undo_next
== lcb
->ctx_mode
)
2554 next_lsn
= le64_to_cpu(hdr
->client_undo_next_lsn
);
2555 else if (lcb_ctx_prev
== lcb
->ctx_mode
)
2556 next_lsn
= le64_to_cpu(hdr
->client_prev_lsn
);
2563 if (!verify_client_lsn(
2564 log
, Add2Ptr(log
->ra
, le16_to_cpu(log
->ra
->client_off
)),
2569 err
= read_log_page(log
, lsn_to_vbo(log
, next_lsn
),
2570 (struct RECORD_PAGE_HDR
**)&hdr
, NULL
);
2581 static int read_next_log_rec(struct ntfs_log
*log
, struct lcb
*lcb
, u64
*lsn
)
2585 err
= find_client_next_lsn(log
, lcb
, lsn
);
2593 kfree(lcb
->log_rec
);
2595 lcb
->log_rec
= NULL
;
2600 return find_log_rec(log
, *lsn
, lcb
);
2603 static inline bool check_index_header(const struct INDEX_HDR
*hdr
, size_t bytes
)
2606 u32 min_de
, de_off
, used
, total
;
2607 const struct NTFS_DE
*e
;
2609 if (hdr_has_subnode(hdr
)) {
2610 min_de
= sizeof(struct NTFS_DE
) + sizeof(u64
);
2611 mask
= NTFS_IE_HAS_SUBNODES
;
2613 min_de
= sizeof(struct NTFS_DE
);
2617 de_off
= le32_to_cpu(hdr
->de_off
);
2618 used
= le32_to_cpu(hdr
->used
);
2619 total
= le32_to_cpu(hdr
->total
);
2621 if (de_off
> bytes
- min_de
|| used
> bytes
|| total
> bytes
||
2622 de_off
+ min_de
> used
|| used
> total
) {
2626 e
= Add2Ptr(hdr
, de_off
);
2628 u16 esize
= le16_to_cpu(e
->size
);
2629 struct NTFS_DE
*next
= Add2Ptr(e
, esize
);
2631 if (esize
< min_de
|| PtrOffset(hdr
, next
) > used
||
2632 (e
->flags
& NTFS_IE_HAS_SUBNODES
) != mask
) {
2645 static inline bool check_index_buffer(const struct INDEX_BUFFER
*ib
, u32 bytes
)
2648 const struct NTFS_RECORD_HEADER
*r
= &ib
->rhdr
;
2650 if (r
->sign
!= NTFS_INDX_SIGNATURE
)
2653 fo
= (SECTOR_SIZE
- ((bytes
>> SECTOR_SHIFT
) + 1) * sizeof(short));
2655 if (le16_to_cpu(r
->fix_off
) > fo
)
2658 if ((le16_to_cpu(r
->fix_num
) - 1) * SECTOR_SIZE
!= bytes
)
2661 return check_index_header(&ib
->ihdr
,
2662 bytes
- offsetof(struct INDEX_BUFFER
, ihdr
));
2665 static inline bool check_index_root(const struct ATTRIB
*attr
,
2666 struct ntfs_sb_info
*sbi
)
2669 const struct INDEX_ROOT
*root
= resident_data(attr
);
2670 u8 index_bits
= le32_to_cpu(root
->index_block_size
) >= sbi
->cluster_size
2673 u8 block_clst
= root
->index_block_clst
;
2675 if (le32_to_cpu(attr
->res
.data_size
) < sizeof(struct INDEX_ROOT
) ||
2676 (root
->type
!= ATTR_NAME
&& root
->type
!= ATTR_ZERO
) ||
2677 (root
->type
== ATTR_NAME
&&
2678 root
->rule
!= NTFS_COLLATION_TYPE_FILENAME
) ||
2679 (le32_to_cpu(root
->index_block_size
) !=
2680 (block_clst
<< index_bits
)) ||
2681 (block_clst
!= 1 && block_clst
!= 2 && block_clst
!= 4 &&
2682 block_clst
!= 8 && block_clst
!= 0x10 && block_clst
!= 0x20 &&
2683 block_clst
!= 0x40 && block_clst
!= 0x80)) {
2687 ret
= check_index_header(&root
->ihdr
,
2688 le32_to_cpu(attr
->res
.data_size
) -
2689 offsetof(struct INDEX_ROOT
, ihdr
));
2693 static inline bool check_attr(const struct MFT_REC
*rec
,
2694 const struct ATTRIB
*attr
,
2695 struct ntfs_sb_info
*sbi
)
2697 u32 asize
= le32_to_cpu(attr
->size
);
2699 u64 dsize
, svcn
, evcn
;
2702 /* Check the fixed part of the attribute record header. */
2703 if (asize
>= sbi
->record_size
||
2704 asize
+ PtrOffset(rec
, attr
) >= sbi
->record_size
||
2706 le16_to_cpu(attr
->name_off
) + attr
->name_len
* sizeof(short) >
2711 /* Check the attribute fields. */
2712 switch (attr
->non_res
) {
2714 rsize
= le32_to_cpu(attr
->res
.data_size
);
2715 if (rsize
>= asize
||
2716 le16_to_cpu(attr
->res
.data_off
) + rsize
> asize
) {
2722 dsize
= le64_to_cpu(attr
->nres
.data_size
);
2723 svcn
= le64_to_cpu(attr
->nres
.svcn
);
2724 evcn
= le64_to_cpu(attr
->nres
.evcn
);
2725 run_off
= le16_to_cpu(attr
->nres
.run_off
);
2727 if (svcn
> evcn
+ 1 || run_off
>= asize
||
2728 le64_to_cpu(attr
->nres
.valid_size
) > dsize
||
2729 dsize
> le64_to_cpu(attr
->nres
.alloc_size
)) {
2733 if (run_unpack(NULL
, sbi
, 0, svcn
, evcn
, svcn
,
2734 Add2Ptr(attr
, run_off
), asize
- run_off
) < 0) {
2744 switch (attr
->type
) {
2746 if (fname_full_size(Add2Ptr(
2747 attr
, le16_to_cpu(attr
->res
.data_off
))) > asize
) {
2753 return check_index_root(attr
, sbi
);
2756 if (rsize
< sizeof(struct ATTR_STD_INFO5
) &&
2757 rsize
!= sizeof(struct ATTR_STD_INFO
)) {
2773 case ATTR_PROPERTYSET
:
2774 case ATTR_LOGGED_UTILITY_STREAM
:
2784 static inline bool check_file_record(const struct MFT_REC
*rec
,
2785 const struct MFT_REC
*rec2
,
2786 struct ntfs_sb_info
*sbi
)
2788 const struct ATTRIB
*attr
;
2789 u16 fo
= le16_to_cpu(rec
->rhdr
.fix_off
);
2790 u16 fn
= le16_to_cpu(rec
->rhdr
.fix_num
);
2791 u16 ao
= le16_to_cpu(rec
->attr_off
);
2792 u32 rs
= sbi
->record_size
;
2794 /* Check the file record header for consistency. */
2795 if (rec
->rhdr
.sign
!= NTFS_FILE_SIGNATURE
||
2796 fo
> (SECTOR_SIZE
- ((rs
>> SECTOR_SHIFT
) + 1) * sizeof(short)) ||
2797 (fn
- 1) * SECTOR_SIZE
!= rs
|| ao
< MFTRECORD_FIXUP_OFFSET_1
||
2798 ao
> sbi
->record_size
- SIZEOF_RESIDENT
|| !is_rec_inuse(rec
) ||
2799 le32_to_cpu(rec
->total
) != rs
) {
2803 /* Loop to check all of the attributes. */
2804 for (attr
= Add2Ptr(rec
, ao
); attr
->type
!= ATTR_END
;
2805 attr
= Add2Ptr(attr
, le32_to_cpu(attr
->size
))) {
2806 if (check_attr(rec
, attr
, sbi
))
2814 static inline int check_lsn(const struct NTFS_RECORD_HEADER
*hdr
,
2822 lsn
= le64_to_cpu(hdr
->lsn
);
2824 if (hdr
->sign
== NTFS_HOLE_SIGNATURE
)
2833 static inline bool check_if_attr(const struct MFT_REC
*rec
,
2834 const struct LOG_REC_HDR
*lrh
)
2836 u16 ro
= le16_to_cpu(lrh
->record_off
);
2837 u16 o
= le16_to_cpu(rec
->attr_off
);
2838 const struct ATTRIB
*attr
= Add2Ptr(rec
, o
);
2843 if (attr
->type
== ATTR_END
)
2846 asize
= le32_to_cpu(attr
->size
);
2851 attr
= Add2Ptr(attr
, asize
);
2857 static inline bool check_if_index_root(const struct MFT_REC
*rec
,
2858 const struct LOG_REC_HDR
*lrh
)
2860 u16 ro
= le16_to_cpu(lrh
->record_off
);
2861 u16 o
= le16_to_cpu(rec
->attr_off
);
2862 const struct ATTRIB
*attr
= Add2Ptr(rec
, o
);
2867 if (attr
->type
== ATTR_END
)
2870 asize
= le32_to_cpu(attr
->size
);
2875 attr
= Add2Ptr(attr
, asize
);
2878 return o
== ro
&& attr
->type
== ATTR_ROOT
;
2881 static inline bool check_if_root_index(const struct ATTRIB
*attr
,
2882 const struct INDEX_HDR
*hdr
,
2883 const struct LOG_REC_HDR
*lrh
)
2885 u16 ao
= le16_to_cpu(lrh
->attr_off
);
2886 u32 de_off
= le32_to_cpu(hdr
->de_off
);
2887 u32 o
= PtrOffset(attr
, hdr
) + de_off
;
2888 const struct NTFS_DE
*e
= Add2Ptr(hdr
, de_off
);
2889 u32 asize
= le32_to_cpu(attr
->size
);
2897 esize
= le16_to_cpu(e
->size
);
2902 e
= Add2Ptr(e
, esize
);
2908 static inline bool check_if_alloc_index(const struct INDEX_HDR
*hdr
,
2911 u32 de_off
= le32_to_cpu(hdr
->de_off
);
2912 u32 o
= offsetof(struct INDEX_BUFFER
, ihdr
) + de_off
;
2913 const struct NTFS_DE
*e
= Add2Ptr(hdr
, de_off
);
2914 u32 used
= le32_to_cpu(hdr
->used
);
2916 while (o
< attr_off
) {
2922 esize
= le16_to_cpu(e
->size
);
2928 e
= Add2Ptr(e
, esize
);
2931 return o
== attr_off
;
2934 static inline void change_attr_size(struct MFT_REC
*rec
, struct ATTRIB
*attr
,
2937 u32 asize
= le32_to_cpu(attr
->size
);
2938 int dsize
= nsize
- asize
;
2939 u8
*next
= Add2Ptr(attr
, asize
);
2940 u32 used
= le32_to_cpu(rec
->used
);
2942 memmove(Add2Ptr(attr
, nsize
), next
, used
- PtrOffset(rec
, next
));
2944 rec
->used
= cpu_to_le32(used
+ dsize
);
2945 attr
->size
= cpu_to_le32(nsize
);
2949 struct ATTRIB
*attr
;
2950 struct runs_tree
*run1
;
2951 struct runs_tree run0
;
2952 struct ntfs_inode
*ni
;
2959 * Return: 0 if 'attr' has the same type and name.
2961 static inline int cmp_type_and_name(const struct ATTRIB
*a1
,
2962 const struct ATTRIB
*a2
)
2964 return a1
->type
!= a2
->type
|| a1
->name_len
!= a2
->name_len
||
2965 (a1
->name_len
&& memcmp(attr_name(a1
), attr_name(a2
),
2966 a1
->name_len
* sizeof(short)));
2969 static struct OpenAttr
*find_loaded_attr(struct ntfs_log
*log
,
2970 const struct ATTRIB
*attr
, CLST rno
)
2972 struct OPEN_ATTR_ENRTY
*oe
= NULL
;
2974 while ((oe
= enum_rstbl(log
->open_attr_tbl
, oe
))) {
2975 struct OpenAttr
*op_attr
;
2977 if (ino_get(&oe
->ref
) != rno
)
2980 op_attr
= (struct OpenAttr
*)oe
->ptr
;
2981 if (!cmp_type_and_name(op_attr
->attr
, attr
))
2987 static struct ATTRIB
*attr_create_nonres_log(struct ntfs_sb_info
*sbi
,
2988 enum ATTR_TYPE type
, u64 size
,
2989 const u16
*name
, size_t name_len
,
2992 struct ATTRIB
*attr
;
2993 u32 name_size
= ALIGN(name_len
* sizeof(short), 8);
2994 bool is_ext
= flags
& (ATTR_FLAG_COMPRESSED
| ATTR_FLAG_SPARSED
);
2995 u32 asize
= name_size
+
2996 (is_ext
? SIZEOF_NONRESIDENT_EX
: SIZEOF_NONRESIDENT
);
2998 attr
= kzalloc(asize
, GFP_NOFS
);
3003 attr
->size
= cpu_to_le32(asize
);
3004 attr
->flags
= flags
;
3006 attr
->name_len
= name_len
;
3008 attr
->nres
.evcn
= cpu_to_le64((u64
)bytes_to_cluster(sbi
, size
) - 1);
3009 attr
->nres
.alloc_size
= cpu_to_le64(ntfs_up_cluster(sbi
, size
));
3010 attr
->nres
.data_size
= cpu_to_le64(size
);
3011 attr
->nres
.valid_size
= attr
->nres
.data_size
;
3013 attr
->name_off
= SIZEOF_NONRESIDENT_EX_LE
;
3014 if (is_attr_compressed(attr
))
3015 attr
->nres
.c_unit
= COMPRESSION_UNIT
;
3017 attr
->nres
.run_off
=
3018 cpu_to_le16(SIZEOF_NONRESIDENT_EX
+ name_size
);
3019 memcpy(Add2Ptr(attr
, SIZEOF_NONRESIDENT_EX
), name
,
3020 name_len
* sizeof(short));
3022 attr
->name_off
= SIZEOF_NONRESIDENT_LE
;
3023 attr
->nres
.run_off
=
3024 cpu_to_le16(SIZEOF_NONRESIDENT
+ name_size
);
3025 memcpy(Add2Ptr(attr
, SIZEOF_NONRESIDENT
), name
,
3026 name_len
* sizeof(short));
3033 * do_action - Common routine for the Redo and Undo Passes.
3034 * @rlsn: If it is NULL then undo.
3036 static int do_action(struct ntfs_log
*log
, struct OPEN_ATTR_ENRTY
*oe
,
3037 const struct LOG_REC_HDR
*lrh
, u32 op
, void *data
,
3038 u32 dlen
, u32 rec_len
, const u64
*rlsn
)
3041 struct ntfs_sb_info
*sbi
= log
->ni
->mi
.sbi
;
3042 struct inode
*inode
= NULL
, *inode_parent
;
3043 struct mft_inode
*mi
= NULL
, *mi2_child
= NULL
;
3044 CLST rno
= 0, rno_base
= 0;
3045 struct INDEX_BUFFER
*ib
= NULL
;
3046 struct MFT_REC
*rec
= NULL
;
3047 struct ATTRIB
*attr
= NULL
, *attr2
;
3048 struct INDEX_HDR
*hdr
;
3049 struct INDEX_ROOT
*root
;
3050 struct NTFS_DE
*e
, *e1
, *e2
;
3051 struct NEW_ATTRIBUTE_SIZES
*new_sz
;
3052 struct ATTR_FILE_NAME
*fname
;
3053 struct OpenAttr
*oa
, *oa2
;
3054 u32 nsize
, t32
, asize
, used
, esize
, bmp_off
, bmp_bits
;
3056 u32 record_size
= sbi
->record_size
;
3058 u16 roff
= le16_to_cpu(lrh
->record_off
);
3059 u16 aoff
= le16_to_cpu(lrh
->attr_off
);
3061 u64 cbo
= (u64
)le16_to_cpu(lrh
->cluster_off
) << SECTOR_SHIFT
;
3062 u64 tvo
= le64_to_cpu(lrh
->target_vcn
) << sbi
->cluster_bits
;
3063 u64 vbo
= cbo
+ tvo
;
3064 void *buffer_le
= NULL
;
3066 bool a_dirty
= false;
3071 /* Big switch to prepare. */
3073 /* ============================================================
3074 * Process MFT records, as described by the current log record.
3075 * ============================================================
3077 case InitializeFileRecordSegment
:
3078 case DeallocateFileRecordSegment
:
3079 case WriteEndOfFileRecordSegment
:
3080 case CreateAttribute
:
3081 case DeleteAttribute
:
3082 case UpdateResidentValue
:
3083 case UpdateMappingPairs
:
3084 case SetNewAttributeSizes
:
3085 case AddIndexEntryRoot
:
3086 case DeleteIndexEntryRoot
:
3087 case SetIndexEntryVcnRoot
:
3088 case UpdateFileNameRoot
:
3089 case UpdateRecordDataRoot
:
3090 case ZeroEndOfFileRecord
:
3091 rno
= vbo
>> sbi
->record_bits
;
3092 inode
= ilookup(sbi
->sb
, rno
);
3094 mi
= &ntfs_i(inode
)->mi
;
3095 } else if (op
== InitializeFileRecordSegment
) {
3096 mi
= kzalloc(sizeof(struct mft_inode
), GFP_NOFS
);
3099 err
= mi_format_new(mi
, sbi
, rno
, 0, false);
3103 /* Read from disk. */
3104 err
= mi_get(sbi
, rno
, &mi
);
3110 if (op
== DeallocateFileRecordSegment
)
3111 goto skip_load_parent
;
3113 if (InitializeFileRecordSegment
!= op
) {
3114 if (rec
->rhdr
.sign
== NTFS_BAAD_SIGNATURE
)
3116 if (!check_lsn(&rec
->rhdr
, rlsn
))
3118 if (!check_file_record(rec
, NULL
, sbi
))
3120 attr
= Add2Ptr(rec
, roff
);
3123 if (is_rec_base(rec
) || InitializeFileRecordSegment
== op
) {
3125 goto skip_load_parent
;
3128 rno_base
= ino_get(&rec
->parent_ref
);
3129 inode_parent
= ntfs_iget5(sbi
->sb
, &rec
->parent_ref
, NULL
);
3130 if (IS_ERR(inode_parent
))
3131 goto skip_load_parent
;
3133 if (is_bad_inode(inode_parent
)) {
3135 goto skip_load_parent
;
3138 if (ni_load_mi_ex(ntfs_i(inode_parent
), rno
, &mi2_child
)) {
3141 if (mi2_child
->mrec
!= mi
->mrec
)
3142 memcpy(mi2_child
->mrec
, mi
->mrec
,
3150 inode
= inode_parent
;
3152 rec
= mi2_child
->mrec
;
3153 attr
= Add2Ptr(rec
, roff
);
3157 inode_parent
= NULL
;
3161 * Process attributes, as described by the current log record.
3163 case UpdateNonresidentValue
:
3164 case AddIndexEntryAllocation
:
3165 case DeleteIndexEntryAllocation
:
3166 case WriteEndOfIndexBuffer
:
3167 case SetIndexEntryVcnAllocation
:
3168 case UpdateFileNameAllocation
:
3169 case SetBitsInNonresidentBitMap
:
3170 case ClearBitsInNonresidentBitMap
:
3171 case UpdateRecordDataAllocation
:
3173 bytes
= UpdateNonresidentValue
== op
? dlen
: 0;
3174 lco
= (u64
)le16_to_cpu(lrh
->lcns_follow
) << sbi
->cluster_bits
;
3176 if (attr
->type
== ATTR_ALLOC
) {
3177 t32
= le32_to_cpu(oe
->bytes_per_index
);
3186 if (attr
->type
== ATTR_ALLOC
)
3187 bytes
= (bytes
+ 511) & ~511; // align
3189 buffer_le
= kmalloc(bytes
, GFP_NOFS
);
3193 err
= ntfs_read_run_nb(sbi
, oa
->run1
, vbo
, buffer_le
, bytes
,
3198 if (attr
->type
== ATTR_ALLOC
&& *(int *)buffer_le
)
3199 ntfs_fix_post_read(buffer_le
, bytes
, false);
3206 /* Big switch to do operation. */
3208 case InitializeFileRecordSegment
:
3209 if (roff
+ dlen
> record_size
)
3212 memcpy(Add2Ptr(rec
, roff
), data
, dlen
);
3216 case DeallocateFileRecordSegment
:
3217 clear_rec_inuse(rec
);
3218 le16_add_cpu(&rec
->seq
, 1);
3222 case WriteEndOfFileRecordSegment
:
3223 attr2
= (struct ATTRIB
*)data
;
3224 if (!check_if_attr(rec
, lrh
) || roff
+ dlen
> record_size
)
3227 memmove(attr
, attr2
, dlen
);
3228 rec
->used
= cpu_to_le32(ALIGN(roff
+ dlen
, 8));
3233 case CreateAttribute
:
3234 attr2
= (struct ATTRIB
*)data
;
3235 asize
= le32_to_cpu(attr2
->size
);
3236 used
= le32_to_cpu(rec
->used
);
3238 if (!check_if_attr(rec
, lrh
) || dlen
< SIZEOF_RESIDENT
||
3239 !IS_ALIGNED(asize
, 8) ||
3240 Add2Ptr(attr2
, asize
) > Add2Ptr(lrh
, rec_len
) ||
3241 dlen
> record_size
- used
) {
3245 memmove(Add2Ptr(attr
, asize
), attr
, used
- roff
);
3246 memcpy(attr
, attr2
, asize
);
3248 rec
->used
= cpu_to_le32(used
+ asize
);
3249 id
= le16_to_cpu(rec
->next_attr_id
);
3250 id2
= le16_to_cpu(attr2
->id
);
3252 rec
->next_attr_id
= cpu_to_le16(id2
+ 1);
3253 if (is_attr_indexed(attr
))
3254 le16_add_cpu(&rec
->hard_links
, 1);
3256 oa2
= find_loaded_attr(log
, attr
, rno_base
);
3258 void *p2
= kmemdup(attr
, le32_to_cpu(attr
->size
),
3261 // run_close(oa2->run1);
3270 case DeleteAttribute
:
3271 asize
= le32_to_cpu(attr
->size
);
3272 used
= le32_to_cpu(rec
->used
);
3274 if (!check_if_attr(rec
, lrh
))
3277 rec
->used
= cpu_to_le32(used
- asize
);
3278 if (is_attr_indexed(attr
))
3279 le16_add_cpu(&rec
->hard_links
, -1);
3281 memmove(attr
, Add2Ptr(attr
, asize
), used
- asize
- roff
);
3286 case UpdateResidentValue
:
3287 nsize
= aoff
+ dlen
;
3289 if (!check_if_attr(rec
, lrh
))
3292 asize
= le32_to_cpu(attr
->size
);
3293 used
= le32_to_cpu(rec
->used
);
3295 if (lrh
->redo_len
== lrh
->undo_len
) {
3301 if (nsize
> asize
&& nsize
- asize
> record_size
- used
)
3304 nsize
= ALIGN(nsize
, 8);
3305 data_off
= le16_to_cpu(attr
->res
.data_off
);
3307 if (nsize
< asize
) {
3308 memmove(Add2Ptr(attr
, aoff
), data
, dlen
);
3309 data
= NULL
; // To skip below memmove().
3312 memmove(Add2Ptr(attr
, nsize
), Add2Ptr(attr
, asize
),
3313 used
- le16_to_cpu(lrh
->record_off
) - asize
);
3315 rec
->used
= cpu_to_le32(used
+ nsize
- asize
);
3316 attr
->size
= cpu_to_le32(nsize
);
3317 attr
->res
.data_size
= cpu_to_le32(aoff
+ dlen
- data_off
);
3321 memmove(Add2Ptr(attr
, aoff
), data
, dlen
);
3323 oa2
= find_loaded_attr(log
, attr
, rno_base
);
3325 void *p2
= kmemdup(attr
, le32_to_cpu(attr
->size
),
3328 // run_close(&oa2->run0);
3329 oa2
->run1
= &oa2
->run0
;
3338 case UpdateMappingPairs
:
3339 nsize
= aoff
+ dlen
;
3340 asize
= le32_to_cpu(attr
->size
);
3341 used
= le32_to_cpu(rec
->used
);
3343 if (!check_if_attr(rec
, lrh
) || !attr
->non_res
||
3344 aoff
< le16_to_cpu(attr
->nres
.run_off
) || aoff
> asize
||
3345 (nsize
> asize
&& nsize
- asize
> record_size
- used
)) {
3349 nsize
= ALIGN(nsize
, 8);
3351 memmove(Add2Ptr(attr
, nsize
), Add2Ptr(attr
, asize
),
3352 used
- le16_to_cpu(lrh
->record_off
) - asize
);
3353 rec
->used
= cpu_to_le32(used
+ nsize
- asize
);
3354 attr
->size
= cpu_to_le32(nsize
);
3355 memmove(Add2Ptr(attr
, aoff
), data
, dlen
);
3357 if (run_get_highest_vcn(le64_to_cpu(attr
->nres
.svcn
),
3358 attr_run(attr
), &t64
)) {
3362 attr
->nres
.evcn
= cpu_to_le64(t64
);
3363 oa2
= find_loaded_attr(log
, attr
, rno_base
);
3364 if (oa2
&& oa2
->attr
->non_res
)
3365 oa2
->attr
->nres
.evcn
= attr
->nres
.evcn
;
3370 case SetNewAttributeSizes
:
3372 if (!check_if_attr(rec
, lrh
) || !attr
->non_res
)
3375 attr
->nres
.alloc_size
= new_sz
->alloc_size
;
3376 attr
->nres
.data_size
= new_sz
->data_size
;
3377 attr
->nres
.valid_size
= new_sz
->valid_size
;
3379 if (dlen
>= sizeof(struct NEW_ATTRIBUTE_SIZES
))
3380 attr
->nres
.total_size
= new_sz
->total_size
;
3382 oa2
= find_loaded_attr(log
, attr
, rno_base
);
3384 void *p2
= kmemdup(attr
, le32_to_cpu(attr
->size
),
3394 case AddIndexEntryRoot
:
3395 e
= (struct NTFS_DE
*)data
;
3396 esize
= le16_to_cpu(e
->size
);
3397 root
= resident_data(attr
);
3399 used
= le32_to_cpu(hdr
->used
);
3401 if (!check_if_index_root(rec
, lrh
) ||
3402 !check_if_root_index(attr
, hdr
, lrh
) ||
3403 Add2Ptr(data
, esize
) > Add2Ptr(lrh
, rec_len
) ||
3404 esize
> le32_to_cpu(rec
->total
) - le32_to_cpu(rec
->used
)) {
3408 e1
= Add2Ptr(attr
, le16_to_cpu(lrh
->attr_off
));
3410 change_attr_size(rec
, attr
, le32_to_cpu(attr
->size
) + esize
);
3412 memmove(Add2Ptr(e1
, esize
), e1
,
3413 PtrOffset(e1
, Add2Ptr(hdr
, used
)));
3414 memmove(e1
, e
, esize
);
3416 le32_add_cpu(&attr
->res
.data_size
, esize
);
3417 hdr
->used
= cpu_to_le32(used
+ esize
);
3418 le32_add_cpu(&hdr
->total
, esize
);
3423 case DeleteIndexEntryRoot
:
3424 root
= resident_data(attr
);
3426 used
= le32_to_cpu(hdr
->used
);
3428 if (!check_if_index_root(rec
, lrh
) ||
3429 !check_if_root_index(attr
, hdr
, lrh
)) {
3433 e1
= Add2Ptr(attr
, le16_to_cpu(lrh
->attr_off
));
3434 esize
= le16_to_cpu(e1
->size
);
3435 e2
= Add2Ptr(e1
, esize
);
3437 memmove(e1
, e2
, PtrOffset(e2
, Add2Ptr(hdr
, used
)));
3439 le32_sub_cpu(&attr
->res
.data_size
, esize
);
3440 hdr
->used
= cpu_to_le32(used
- esize
);
3441 le32_sub_cpu(&hdr
->total
, esize
);
3443 change_attr_size(rec
, attr
, le32_to_cpu(attr
->size
) - esize
);
3448 case SetIndexEntryVcnRoot
:
3449 root
= resident_data(attr
);
3452 if (!check_if_index_root(rec
, lrh
) ||
3453 !check_if_root_index(attr
, hdr
, lrh
)) {
3457 e
= Add2Ptr(attr
, le16_to_cpu(lrh
->attr_off
));
3459 de_set_vbn_le(e
, *(__le64
*)data
);
3463 case UpdateFileNameRoot
:
3464 root
= resident_data(attr
);
3467 if (!check_if_index_root(rec
, lrh
) ||
3468 !check_if_root_index(attr
, hdr
, lrh
)) {
3472 e
= Add2Ptr(attr
, le16_to_cpu(lrh
->attr_off
));
3473 fname
= (struct ATTR_FILE_NAME
*)(e
+ 1);
3474 memmove(&fname
->dup
, data
, sizeof(fname
->dup
)); //
3478 case UpdateRecordDataRoot
:
3479 root
= resident_data(attr
);
3482 if (!check_if_index_root(rec
, lrh
) ||
3483 !check_if_root_index(attr
, hdr
, lrh
)) {
3487 e
= Add2Ptr(attr
, le16_to_cpu(lrh
->attr_off
));
3489 memmove(Add2Ptr(e
, le16_to_cpu(e
->view
.data_off
)), data
, dlen
);
3494 case ZeroEndOfFileRecord
:
3495 if (roff
+ dlen
> record_size
)
3498 memset(attr
, 0, dlen
);
3502 case UpdateNonresidentValue
:
3503 if (lco
< cbo
+ roff
+ dlen
)
3506 memcpy(Add2Ptr(buffer_le
, roff
), data
, dlen
);
3509 if (attr
->type
== ATTR_ALLOC
)
3510 ntfs_fix_pre_write(buffer_le
, bytes
);
3513 case AddIndexEntryAllocation
:
3514 ib
= Add2Ptr(buffer_le
, roff
);
3517 esize
= le16_to_cpu(e
->size
);
3518 e1
= Add2Ptr(ib
, aoff
);
3520 if (is_baad(&ib
->rhdr
))
3522 if (!check_lsn(&ib
->rhdr
, rlsn
))
3525 used
= le32_to_cpu(hdr
->used
);
3527 if (!check_index_buffer(ib
, bytes
) ||
3528 !check_if_alloc_index(hdr
, aoff
) ||
3529 Add2Ptr(e
, esize
) > Add2Ptr(lrh
, rec_len
) ||
3530 used
+ esize
> le32_to_cpu(hdr
->total
)) {
3534 memmove(Add2Ptr(e1
, esize
), e1
,
3535 PtrOffset(e1
, Add2Ptr(hdr
, used
)));
3536 memcpy(e1
, e
, esize
);
3538 hdr
->used
= cpu_to_le32(used
+ esize
);
3542 ntfs_fix_pre_write(&ib
->rhdr
, bytes
);
3545 case DeleteIndexEntryAllocation
:
3546 ib
= Add2Ptr(buffer_le
, roff
);
3548 e
= Add2Ptr(ib
, aoff
);
3549 esize
= le16_to_cpu(e
->size
);
3551 if (is_baad(&ib
->rhdr
))
3553 if (!check_lsn(&ib
->rhdr
, rlsn
))
3556 if (!check_index_buffer(ib
, bytes
) ||
3557 !check_if_alloc_index(hdr
, aoff
)) {
3561 e1
= Add2Ptr(e
, esize
);
3563 used
= le32_to_cpu(hdr
->used
);
3565 memmove(e
, e1
, PtrOffset(e1
, Add2Ptr(hdr
, used
)));
3567 hdr
->used
= cpu_to_le32(used
- nsize
);
3571 ntfs_fix_pre_write(&ib
->rhdr
, bytes
);
3574 case WriteEndOfIndexBuffer
:
3575 ib
= Add2Ptr(buffer_le
, roff
);
3577 e
= Add2Ptr(ib
, aoff
);
3579 if (is_baad(&ib
->rhdr
))
3581 if (!check_lsn(&ib
->rhdr
, rlsn
))
3583 if (!check_index_buffer(ib
, bytes
) ||
3584 !check_if_alloc_index(hdr
, aoff
) ||
3585 aoff
+ dlen
> offsetof(struct INDEX_BUFFER
, ihdr
) +
3586 le32_to_cpu(hdr
->total
)) {
3590 hdr
->used
= cpu_to_le32(dlen
+ PtrOffset(hdr
, e
));
3591 memmove(e
, data
, dlen
);
3594 ntfs_fix_pre_write(&ib
->rhdr
, bytes
);
3597 case SetIndexEntryVcnAllocation
:
3598 ib
= Add2Ptr(buffer_le
, roff
);
3600 e
= Add2Ptr(ib
, aoff
);
3602 if (is_baad(&ib
->rhdr
))
3605 if (!check_lsn(&ib
->rhdr
, rlsn
))
3607 if (!check_index_buffer(ib
, bytes
) ||
3608 !check_if_alloc_index(hdr
, aoff
)) {
3612 de_set_vbn_le(e
, *(__le64
*)data
);
3615 ntfs_fix_pre_write(&ib
->rhdr
, bytes
);
3618 case UpdateFileNameAllocation
:
3619 ib
= Add2Ptr(buffer_le
, roff
);
3621 e
= Add2Ptr(ib
, aoff
);
3623 if (is_baad(&ib
->rhdr
))
3626 if (!check_lsn(&ib
->rhdr
, rlsn
))
3628 if (!check_index_buffer(ib
, bytes
) ||
3629 !check_if_alloc_index(hdr
, aoff
)) {
3633 fname
= (struct ATTR_FILE_NAME
*)(e
+ 1);
3634 memmove(&fname
->dup
, data
, sizeof(fname
->dup
));
3637 ntfs_fix_pre_write(&ib
->rhdr
, bytes
);
3640 case SetBitsInNonresidentBitMap
:
3642 le32_to_cpu(((struct BITMAP_RANGE
*)data
)->bitmap_off
);
3643 bmp_bits
= le32_to_cpu(((struct BITMAP_RANGE
*)data
)->bits
);
3645 if (cbo
+ (bmp_off
+ 7) / 8 > lco
||
3646 cbo
+ ((bmp_off
+ bmp_bits
+ 7) / 8) > lco
) {
3650 __bitmap_set(Add2Ptr(buffer_le
, roff
), bmp_off
, bmp_bits
);
3654 case ClearBitsInNonresidentBitMap
:
3656 le32_to_cpu(((struct BITMAP_RANGE
*)data
)->bitmap_off
);
3657 bmp_bits
= le32_to_cpu(((struct BITMAP_RANGE
*)data
)->bits
);
3659 if (cbo
+ (bmp_off
+ 7) / 8 > lco
||
3660 cbo
+ ((bmp_off
+ bmp_bits
+ 7) / 8) > lco
) {
3664 __bitmap_clear(Add2Ptr(buffer_le
, roff
), bmp_off
, bmp_bits
);
3668 case UpdateRecordDataAllocation
:
3669 ib
= Add2Ptr(buffer_le
, roff
);
3671 e
= Add2Ptr(ib
, aoff
);
3673 if (is_baad(&ib
->rhdr
))
3676 if (!check_lsn(&ib
->rhdr
, rlsn
))
3678 if (!check_index_buffer(ib
, bytes
) ||
3679 !check_if_alloc_index(hdr
, aoff
)) {
3683 memmove(Add2Ptr(e
, le16_to_cpu(e
->view
.data_off
)), data
, dlen
);
3686 ntfs_fix_pre_write(&ib
->rhdr
, bytes
);
3694 __le64 t64
= cpu_to_le64(*rlsn
);
3697 rec
->rhdr
.lsn
= t64
;
3702 if (mi
&& mi
->dirty
) {
3703 err
= mi_write(mi
, 0);
3710 err
= ntfs_sb_write_run(sbi
, oa
->run1
, vbo
, buffer_le
, bytes
);
3719 else if (mi
!= mi2_child
)
3727 log
->set_dirty
= true;
3732 * log_replay - Replays log and empties it.
3734 * This function is called during mount operation.
3735 * It replays log and empties it.
3736 * Initialized is set false if logfile contains '-1'.
3738 int log_replay(struct ntfs_inode
*ni
, bool *initialized
)
3741 struct ntfs_sb_info
*sbi
= ni
->mi
.sbi
;
3742 struct ntfs_log
*log
;
3744 struct restart_info rst_info
, rst_info2
;
3745 u64 rec_lsn
, ra_lsn
, checkpt_lsn
= 0, rlsn
= 0;
3746 struct ATTR_NAME_ENTRY
*attr_names
= NULL
;
3747 struct ATTR_NAME_ENTRY
*ane
;
3748 struct RESTART_TABLE
*dptbl
= NULL
;
3749 struct RESTART_TABLE
*trtbl
= NULL
;
3750 const struct RESTART_TABLE
*rt
;
3751 struct RESTART_TABLE
*oatbl
= NULL
;
3752 struct inode
*inode
;
3753 struct OpenAttr
*oa
;
3754 struct ntfs_inode
*ni_oe
;
3755 struct ATTRIB
*attr
= NULL
;
3756 u64 size
, vcn
, undo_next_lsn
;
3757 CLST rno
, lcn
, lcn0
, len0
, clen
;
3759 struct NTFS_RESTART
*rst
= NULL
;
3760 struct lcb
*lcb
= NULL
;
3761 struct OPEN_ATTR_ENRTY
*oe
;
3762 struct TRANSACTION_ENTRY
*tr
;
3763 struct DIR_PAGE_ENTRY
*dp
;
3764 u32 i
, bytes_per_attr_entry
;
3765 u32 l_size
= ni
->vfs_inode
.i_size
;
3766 u32 orig_file_size
= l_size
;
3767 u32 page_size
, vbo
, tail
, off
, dlen
;
3768 u32 saved_len
, rec_len
, transact_id
;
3769 bool use_second_page
;
3770 struct RESTART_AREA
*ra2
, *ra
= NULL
;
3771 struct CLIENT_REC
*ca
, *cr
;
3773 struct RESTART_HDR
*rh
;
3774 const struct LFS_RECORD_HDR
*frh
;
3775 const struct LOG_REC_HDR
*lrh
;
3777 bool is_ro
= sb_rdonly(sbi
->sb
);
3782 /* Get the size of page. NOTE: To replay we can use default page. */
3783 #if PAGE_SIZE >= DefaultLogPageSize && PAGE_SIZE <= DefaultLogPageSize * 2
3784 page_size
= norm_file_page(PAGE_SIZE
, &l_size
, true);
3786 page_size
= norm_file_page(PAGE_SIZE
, &l_size
, false);
3791 log
= kzalloc(sizeof(struct ntfs_log
), GFP_NOFS
);
3796 log
->l_size
= l_size
;
3797 log
->one_page_buf
= kmalloc(page_size
, GFP_NOFS
);
3799 if (!log
->one_page_buf
) {
3804 log
->page_size
= page_size
;
3805 log
->page_mask
= page_size
- 1;
3806 log
->page_bits
= blksize_bits(page_size
);
3808 /* Look for a restart area on the disk. */
3809 err
= log_read_rst(log
, l_size
, true, &rst_info
);
3813 /* remember 'initialized' */
3814 *initialized
= rst_info
.initialized
;
3816 if (!rst_info
.restart
) {
3817 if (rst_info
.initialized
) {
3818 /* No restart area but the file is not initialized. */
3823 log_init_pg_hdr(log
, page_size
, page_size
, 1, 1);
3824 log_create(log
, l_size
, 0, get_random_int(), false, false);
3828 ra
= log_create_ra(log
);
3834 log
->init_ra
= true;
3840 * If the restart offset above wasn't zero then we won't
3841 * look for a second restart.
3844 goto check_restart_area
;
3846 err
= log_read_rst(log
, l_size
, false, &rst_info2
);
3848 /* Determine which restart area to use. */
3849 if (!rst_info2
.restart
|| rst_info2
.last_lsn
<= rst_info
.last_lsn
)
3850 goto use_first_page
;
3852 use_second_page
= true;
3854 if (rst_info
.chkdsk_was_run
&& page_size
!= rst_info
.vbo
) {
3855 struct RECORD_PAGE_HDR
*sp
= NULL
;
3858 if (!read_log_page(log
, page_size
, &sp
, &usa_error
) &&
3859 sp
->rhdr
.sign
== NTFS_CHKD_SIGNATURE
) {
3860 use_second_page
= false;
3865 if (use_second_page
) {
3866 kfree(rst_info
.r_page
);
3867 memcpy(&rst_info
, &rst_info2
, sizeof(struct restart_info
));
3868 rst_info2
.r_page
= NULL
;
3872 kfree(rst_info2
.r_page
);
3876 * If the restart area is at offset 0, we want
3877 * to write the second restart area first.
3879 log
->init_ra
= !!rst_info
.vbo
;
3881 /* If we have a valid page then grab a pointer to the restart area. */
3882 ra2
= rst_info
.valid_page
3883 ? Add2Ptr(rst_info
.r_page
,
3884 le16_to_cpu(rst_info
.r_page
->ra_off
))
3887 if (rst_info
.chkdsk_was_run
||
3888 (ra2
&& ra2
->client_idx
[1] == LFS_NO_CLIENT_LE
)) {
3889 bool wrapped
= false;
3890 bool use_multi_page
= false;
3893 /* Do some checks based on whether we have a valid log page. */
3894 if (!rst_info
.valid_page
) {
3895 open_log_count
= get_random_int();
3896 goto init_log_instance
;
3898 open_log_count
= le32_to_cpu(ra2
->open_log_count
);
3901 * If the restart page size isn't changing then we want to
3902 * check how much work we need to do.
3904 if (page_size
!= le32_to_cpu(rst_info
.r_page
->sys_page_size
))
3905 goto init_log_instance
;
3908 log_init_pg_hdr(log
, page_size
, page_size
, 1, 1);
3910 log_create(log
, l_size
, rst_info
.last_lsn
, open_log_count
,
3911 wrapped
, use_multi_page
);
3913 ra
= log_create_ra(log
);
3920 /* Put the restart areas and initialize
3921 * the log file as required.
3932 * If the log page or the system page sizes have changed, we can't
3933 * use the log file. We must use the system page size instead of the
3934 * default size if there is not a clean shutdown.
3936 t32
= le32_to_cpu(rst_info
.r_page
->sys_page_size
);
3937 if (page_size
!= t32
) {
3938 l_size
= orig_file_size
;
3940 norm_file_page(t32
, &l_size
, t32
== DefaultLogPageSize
);
3943 if (page_size
!= t32
||
3944 page_size
!= le32_to_cpu(rst_info
.r_page
->page_size
)) {
3949 /* If the file size has shrunk then we won't mount it. */
3950 if (l_size
< le64_to_cpu(ra2
->l_size
)) {
3955 log_init_pg_hdr(log
, page_size
, page_size
,
3956 le16_to_cpu(rst_info
.r_page
->major_ver
),
3957 le16_to_cpu(rst_info
.r_page
->minor_ver
));
3959 log
->l_size
= le64_to_cpu(ra2
->l_size
);
3960 log
->seq_num_bits
= le32_to_cpu(ra2
->seq_num_bits
);
3961 log
->file_data_bits
= sizeof(u64
) * 8 - log
->seq_num_bits
;
3962 log
->seq_num_mask
= (8 << log
->file_data_bits
) - 1;
3963 log
->last_lsn
= le64_to_cpu(ra2
->current_lsn
);
3964 log
->seq_num
= log
->last_lsn
>> log
->file_data_bits
;
3965 log
->ra_off
= le16_to_cpu(rst_info
.r_page
->ra_off
);
3966 log
->restart_size
= log
->sys_page_size
- log
->ra_off
;
3967 log
->record_header_len
= le16_to_cpu(ra2
->rec_hdr_len
);
3968 log
->ra_size
= le16_to_cpu(ra2
->ra_len
);
3969 log
->data_off
= le16_to_cpu(ra2
->data_off
);
3970 log
->data_size
= log
->page_size
- log
->data_off
;
3971 log
->reserved
= log
->data_size
- log
->record_header_len
;
3973 vbo
= lsn_to_vbo(log
, log
->last_lsn
);
3975 if (vbo
< log
->first_page
) {
3976 /* This is a pseudo lsn. */
3977 log
->l_flags
|= NTFSLOG_NO_LAST_LSN
;
3978 log
->next_page
= log
->first_page
;
3982 /* Find the end of this log record. */
3983 off
= final_log_off(log
, log
->last_lsn
,
3984 le32_to_cpu(ra2
->last_lsn_data_len
));
3986 /* If we wrapped the file then increment the sequence number. */
3989 log
->l_flags
|= NTFSLOG_WRAPPED
;
3992 /* Now compute the next log page to use. */
3993 vbo
&= ~log
->sys_page_mask
;
3994 tail
= log
->page_size
- (off
& log
->page_mask
) - 1;
3997 *If we can fit another log record on the page,
3998 * move back a page the log file.
4000 if (tail
>= log
->record_header_len
) {
4001 log
->l_flags
|= NTFSLOG_REUSE_TAIL
;
4002 log
->next_page
= vbo
;
4004 log
->next_page
= next_page_off(log
, vbo
);
4009 * Find the oldest client lsn. Use the last
4010 * flushed lsn as a starting point.
4012 log
->oldest_lsn
= log
->last_lsn
;
4013 oldest_client_lsn(Add2Ptr(ra2
, le16_to_cpu(ra2
->client_off
)),
4014 ra2
->client_idx
[1], &log
->oldest_lsn
);
4015 log
->oldest_lsn_off
= lsn_to_vbo(log
, log
->oldest_lsn
);
4017 if (log
->oldest_lsn_off
< log
->first_page
)
4018 log
->l_flags
|= NTFSLOG_NO_OLDEST_LSN
;
4020 if (!(ra2
->flags
& RESTART_SINGLE_PAGE_IO
))
4021 log
->l_flags
|= NTFSLOG_WRAPPED
| NTFSLOG_MULTIPLE_PAGE_IO
;
4023 log
->current_openlog_count
= le32_to_cpu(ra2
->open_log_count
);
4024 log
->total_avail_pages
= log
->l_size
- log
->first_page
;
4025 log
->total_avail
= log
->total_avail_pages
>> log
->page_bits
;
4026 log
->max_current_avail
= log
->total_avail
* log
->reserved
;
4027 log
->total_avail
= log
->total_avail
* log
->data_size
;
4029 log
->current_avail
= current_log_avail(log
);
4031 ra
= kzalloc(log
->restart_size
, GFP_NOFS
);
4038 t16
= le16_to_cpu(ra2
->client_off
);
4039 if (t16
== offsetof(struct RESTART_AREA
, clients
)) {
4040 memcpy(ra
, ra2
, log
->ra_size
);
4042 memcpy(ra
, ra2
, offsetof(struct RESTART_AREA
, clients
));
4043 memcpy(ra
->clients
, Add2Ptr(ra2
, t16
),
4044 le16_to_cpu(ra2
->ra_len
) - t16
);
4046 log
->current_openlog_count
= get_random_int();
4047 ra
->open_log_count
= cpu_to_le32(log
->current_openlog_count
);
4048 log
->ra_size
= offsetof(struct RESTART_AREA
, clients
) +
4049 sizeof(struct CLIENT_REC
);
4051 cpu_to_le16(offsetof(struct RESTART_AREA
, clients
));
4052 ra
->ra_len
= cpu_to_le16(log
->ra_size
);
4055 le32_add_cpu(&ra
->open_log_count
, 1);
4057 /* Now we need to walk through looking for the last lsn. */
4058 err
= last_log_lsn(log
);
4062 log
->current_avail
= current_log_avail(log
);
4064 /* Remember which restart area to write first. */
4065 log
->init_ra
= rst_info
.vbo
;
4068 /* 1.0, 1.1, 2.0 log->major_ver/minor_ver - short values. */
4069 switch ((log
->major_ver
<< 16) + log
->minor_ver
) {
4075 ntfs_warn(sbi
->sb
, "\x24LogFile version %d.%d is not supported",
4076 log
->major_ver
, log
->minor_ver
);
4078 log
->set_dirty
= true;
4082 /* One client "NTFS" per logfile. */
4083 ca
= Add2Ptr(ra
, le16_to_cpu(ra
->client_off
));
4085 for (client
= ra
->client_idx
[1];; client
= cr
->next_client
) {
4086 if (client
== LFS_NO_CLIENT_LE
) {
4087 /* Insert "NTFS" client LogFile. */
4088 client
= ra
->client_idx
[0];
4089 if (client
== LFS_NO_CLIENT_LE
)
4092 t16
= le16_to_cpu(client
);
4095 remove_client(ca
, cr
, &ra
->client_idx
[0]);
4097 cr
->restart_lsn
= 0;
4098 cr
->oldest_lsn
= cpu_to_le64(log
->oldest_lsn
);
4099 cr
->name_bytes
= cpu_to_le32(8);
4100 cr
->name
[0] = cpu_to_le16('N');
4101 cr
->name
[1] = cpu_to_le16('T');
4102 cr
->name
[2] = cpu_to_le16('F');
4103 cr
->name
[3] = cpu_to_le16('S');
4105 add_client(ca
, t16
, &ra
->client_idx
[1]);
4109 cr
= ca
+ le16_to_cpu(client
);
4111 if (cpu_to_le32(8) == cr
->name_bytes
&&
4112 cpu_to_le16('N') == cr
->name
[0] &&
4113 cpu_to_le16('T') == cr
->name
[1] &&
4114 cpu_to_le16('F') == cr
->name
[2] &&
4115 cpu_to_le16('S') == cr
->name
[3])
4119 /* Update the client handle with the client block information. */
4120 log
->client_id
.seq_num
= cr
->seq_num
;
4121 log
->client_id
.client_idx
= client
;
4123 err
= read_rst_area(log
, &rst
, &ra_lsn
);
4130 bytes_per_attr_entry
= !rst
->major_ver
? 0x2C : 0x28;
4132 checkpt_lsn
= le64_to_cpu(rst
->check_point_start
);
4134 checkpt_lsn
= ra_lsn
;
4136 /* Allocate and Read the Transaction Table. */
4137 if (!rst
->transact_table_len
)
4138 goto check_dirty_page_table
;
4140 t64
= le64_to_cpu(rst
->transact_table_lsn
);
4141 err
= read_log_rec_lcb(log
, t64
, lcb_ctx_prev
, &lcb
);
4147 rec_len
= le32_to_cpu(frh
->client_data_len
);
4149 if (!check_log_rec(lrh
, rec_len
, le32_to_cpu(frh
->transact_id
),
4150 bytes_per_attr_entry
)) {
4155 t16
= le16_to_cpu(lrh
->redo_off
);
4157 rt
= Add2Ptr(lrh
, t16
);
4158 t32
= rec_len
- t16
;
4160 /* Now check that this is a valid restart table. */
4161 if (!check_rstbl(rt
, t32
)) {
4166 trtbl
= kmemdup(rt
, t32
, GFP_NOFS
);
4175 check_dirty_page_table
:
4176 /* The next record back should be the Dirty Pages Table. */
4177 if (!rst
->dirty_pages_len
)
4178 goto check_attribute_names
;
4180 t64
= le64_to_cpu(rst
->dirty_pages_table_lsn
);
4181 err
= read_log_rec_lcb(log
, t64
, lcb_ctx_prev
, &lcb
);
4187 rec_len
= le32_to_cpu(frh
->client_data_len
);
4189 if (!check_log_rec(lrh
, rec_len
, le32_to_cpu(frh
->transact_id
),
4190 bytes_per_attr_entry
)) {
4195 t16
= le16_to_cpu(lrh
->redo_off
);
4197 rt
= Add2Ptr(lrh
, t16
);
4198 t32
= rec_len
- t16
;
4200 /* Now check that this is a valid restart table. */
4201 if (!check_rstbl(rt
, t32
)) {
4206 dptbl
= kmemdup(rt
, t32
, GFP_NOFS
);
4212 /* Convert Ra version '0' into version '1'. */
4217 while ((dp
= enum_rstbl(dptbl
, dp
))) {
4218 struct DIR_PAGE_ENTRY_32
*dp0
= (struct DIR_PAGE_ENTRY_32
*)dp
;
4219 // NOTE: Danger. Check for of boundary.
4220 memmove(&dp
->vcn
, &dp0
->vcn_low
,
4222 le32_to_cpu(dp
->lcns_follow
) * sizeof(u64
));
4230 * Go through the table and remove the duplicates,
4231 * remembering the oldest lsn values.
4233 if (sbi
->cluster_size
<= log
->page_size
)
4234 goto trace_dp_table
;
4237 while ((dp
= enum_rstbl(dptbl
, dp
))) {
4238 struct DIR_PAGE_ENTRY
*next
= dp
;
4240 while ((next
= enum_rstbl(dptbl
, next
))) {
4241 if (next
->target_attr
== dp
->target_attr
&&
4242 next
->vcn
== dp
->vcn
) {
4243 if (le64_to_cpu(next
->oldest_lsn
) <
4244 le64_to_cpu(dp
->oldest_lsn
)) {
4245 dp
->oldest_lsn
= next
->oldest_lsn
;
4248 free_rsttbl_idx(dptbl
, PtrOffset(dptbl
, next
));
4253 check_attribute_names
:
4254 /* The next record should be the Attribute Names. */
4255 if (!rst
->attr_names_len
)
4256 goto check_attr_table
;
4258 t64
= le64_to_cpu(rst
->attr_names_lsn
);
4259 err
= read_log_rec_lcb(log
, t64
, lcb_ctx_prev
, &lcb
);
4265 rec_len
= le32_to_cpu(frh
->client_data_len
);
4267 if (!check_log_rec(lrh
, rec_len
, le32_to_cpu(frh
->transact_id
),
4268 bytes_per_attr_entry
)) {
4273 t32
= lrh_length(lrh
);
4276 attr_names
= kmemdup(Add2Ptr(lrh
, t32
), rec_len
, GFP_NOFS
);
4282 /* The next record should be the attribute Table. */
4283 if (!rst
->open_attr_len
)
4284 goto check_attribute_names2
;
4286 t64
= le64_to_cpu(rst
->open_attr_table_lsn
);
4287 err
= read_log_rec_lcb(log
, t64
, lcb_ctx_prev
, &lcb
);
4293 rec_len
= le32_to_cpu(frh
->client_data_len
);
4295 if (!check_log_rec(lrh
, rec_len
, le32_to_cpu(frh
->transact_id
),
4296 bytes_per_attr_entry
)) {
4301 t16
= le16_to_cpu(lrh
->redo_off
);
4303 rt
= Add2Ptr(lrh
, t16
);
4304 t32
= rec_len
- t16
;
4306 if (!check_rstbl(rt
, t32
)) {
4311 oatbl
= kmemdup(rt
, t32
, GFP_NOFS
);
4317 log
->open_attr_tbl
= oatbl
;
4319 /* Clear all of the Attr pointers. */
4321 while ((oe
= enum_rstbl(oatbl
, oe
))) {
4322 if (!rst
->major_ver
) {
4323 struct OPEN_ATTR_ENRTY_32 oe0
;
4325 /* Really 'oe' points to OPEN_ATTR_ENRTY_32. */
4326 memcpy(&oe0
, oe
, SIZEOF_OPENATTRIBUTEENTRY0
);
4328 oe
->bytes_per_index
= oe0
.bytes_per_index
;
4329 oe
->type
= oe0
.type
;
4330 oe
->is_dirty_pages
= oe0
.is_dirty_pages
;
4333 oe
->open_record_lsn
= oe0
.open_record_lsn
;
4336 oe
->is_attr_name
= 0;
4343 check_attribute_names2
:
4344 if (!rst
->attr_names_len
)
4345 goto trace_attribute_table
;
4349 goto trace_attribute_table
;
4351 /* TODO: Clear table on exit! */
4352 oe
= Add2Ptr(oatbl
, le16_to_cpu(ane
->off
));
4353 t16
= le16_to_cpu(ane
->name_bytes
);
4354 oe
->name_len
= t16
/ sizeof(short);
4355 oe
->ptr
= ane
->name
;
4356 oe
->is_attr_name
= 2;
4357 ane
= Add2Ptr(ane
, sizeof(struct ATTR_NAME_ENTRY
) + t16
);
4360 trace_attribute_table
:
4362 * If the checkpt_lsn is zero, then this is a freshly
4363 * formatted disk and we have no work to do.
4371 oatbl
= init_rsttbl(bytes_per_attr_entry
, 8);
4378 log
->open_attr_tbl
= oatbl
;
4380 /* Start the analysis pass from the Checkpoint lsn. */
4381 rec_lsn
= checkpt_lsn
;
4383 /* Read the first lsn. */
4384 err
= read_log_rec_lcb(log
, checkpt_lsn
, lcb_ctx_next
, &lcb
);
4388 /* Loop to read all subsequent records to the end of the log file. */
4389 next_log_record_analyze
:
4390 err
= read_next_log_rec(log
, lcb
, &rec_lsn
);
4395 goto end_log_records_enumerate
;
4398 transact_id
= le32_to_cpu(frh
->transact_id
);
4399 rec_len
= le32_to_cpu(frh
->client_data_len
);
4402 if (!check_log_rec(lrh
, rec_len
, transact_id
, bytes_per_attr_entry
)) {
4408 * The first lsn after the previous lsn remembered
4409 * the checkpoint is the first candidate for the rlsn.
4414 if (LfsClientRecord
!= frh
->record_type
)
4415 goto next_log_record_analyze
;
4418 * Now update the Transaction Table for this transaction. If there
4419 * is no entry present or it is unallocated we allocate the entry.
4422 trtbl
= init_rsttbl(sizeof(struct TRANSACTION_ENTRY
),
4423 INITIAL_NUMBER_TRANSACTIONS
);
4430 tr
= Add2Ptr(trtbl
, transact_id
);
4432 if (transact_id
>= bytes_per_rt(trtbl
) ||
4433 tr
->next
!= RESTART_ENTRY_ALLOCATED_LE
) {
4434 tr
= alloc_rsttbl_from_idx(&trtbl
, transact_id
);
4439 tr
->transact_state
= TransactionActive
;
4440 tr
->first_lsn
= cpu_to_le64(rec_lsn
);
4443 tr
->prev_lsn
= tr
->undo_next_lsn
= cpu_to_le64(rec_lsn
);
4446 * If this is a compensation log record, then change
4447 * the undo_next_lsn to be the undo_next_lsn of this record.
4449 if (lrh
->undo_op
== cpu_to_le16(CompensationLogRecord
))
4450 tr
->undo_next_lsn
= frh
->client_undo_next_lsn
;
4452 /* Dispatch to handle log record depending on type. */
4453 switch (le16_to_cpu(lrh
->redo_op
)) {
4454 case InitializeFileRecordSegment
:
4455 case DeallocateFileRecordSegment
:
4456 case WriteEndOfFileRecordSegment
:
4457 case CreateAttribute
:
4458 case DeleteAttribute
:
4459 case UpdateResidentValue
:
4460 case UpdateNonresidentValue
:
4461 case UpdateMappingPairs
:
4462 case SetNewAttributeSizes
:
4463 case AddIndexEntryRoot
:
4464 case DeleteIndexEntryRoot
:
4465 case AddIndexEntryAllocation
:
4466 case DeleteIndexEntryAllocation
:
4467 case WriteEndOfIndexBuffer
:
4468 case SetIndexEntryVcnRoot
:
4469 case SetIndexEntryVcnAllocation
:
4470 case UpdateFileNameRoot
:
4471 case UpdateFileNameAllocation
:
4472 case SetBitsInNonresidentBitMap
:
4473 case ClearBitsInNonresidentBitMap
:
4474 case UpdateRecordDataRoot
:
4475 case UpdateRecordDataAllocation
:
4476 case ZeroEndOfFileRecord
:
4477 t16
= le16_to_cpu(lrh
->target_attr
);
4478 t64
= le64_to_cpu(lrh
->target_vcn
);
4479 dp
= find_dp(dptbl
, t16
, t64
);
4485 * Calculate the number of clusters per page the system
4486 * which wrote the checkpoint, possibly creating the table.
4489 t32
= (le16_to_cpu(dptbl
->size
) -
4490 sizeof(struct DIR_PAGE_ENTRY
)) /
4493 t32
= log
->clst_per_page
;
4495 dptbl
= init_rsttbl(struct_size(dp
, page_lcns
, t32
),
4503 dp
= alloc_rsttbl_idx(&dptbl
);
4508 dp
->target_attr
= cpu_to_le32(t16
);
4509 dp
->transfer_len
= cpu_to_le32(t32
<< sbi
->cluster_bits
);
4510 dp
->lcns_follow
= cpu_to_le32(t32
);
4511 dp
->vcn
= cpu_to_le64(t64
& ~((u64
)t32
- 1));
4512 dp
->oldest_lsn
= cpu_to_le64(rec_lsn
);
4516 * Copy the Lcns from the log record into the Dirty Page Entry.
4517 * TODO: For different page size support, must somehow make
4518 * whole routine a loop, case Lcns do not fit below.
4520 t16
= le16_to_cpu(lrh
->lcns_follow
);
4521 for (i
= 0; i
< t16
; i
++) {
4522 size_t j
= (size_t)(le64_to_cpu(lrh
->target_vcn
) -
4523 le64_to_cpu(dp
->vcn
));
4524 dp
->page_lcns
[j
+ i
] = lrh
->page_lcns
[i
];
4527 goto next_log_record_analyze
;
4529 case DeleteDirtyClusters
: {
4531 le16_to_cpu(lrh
->redo_len
) / sizeof(struct LCN_RANGE
);
4532 const struct LCN_RANGE
*r
=
4533 Add2Ptr(lrh
, le16_to_cpu(lrh
->redo_off
));
4535 /* Loop through all of the Lcn ranges this log record. */
4536 for (i
= 0; i
< range_count
; i
++, r
++) {
4537 u64 lcn0
= le64_to_cpu(r
->lcn
);
4538 u64 lcn_e
= lcn0
+ le64_to_cpu(r
->len
) - 1;
4541 while ((dp
= enum_rstbl(dptbl
, dp
))) {
4544 t32
= le32_to_cpu(dp
->lcns_follow
);
4545 for (j
= 0; j
< t32
; j
++) {
4546 t64
= le64_to_cpu(dp
->page_lcns
[j
]);
4547 if (t64
>= lcn0
&& t64
<= lcn_e
)
4548 dp
->page_lcns
[j
] = 0;
4552 goto next_log_record_analyze
;
4556 case OpenNonresidentAttribute
:
4557 t16
= le16_to_cpu(lrh
->target_attr
);
4558 if (t16
>= bytes_per_rt(oatbl
)) {
4560 * Compute how big the table needs to be.
4561 * Add 10 extra entries for some cushion.
4563 u32 new_e
= t16
/ le16_to_cpu(oatbl
->size
);
4565 new_e
+= 10 - le16_to_cpu(oatbl
->used
);
4567 oatbl
= extend_rsttbl(oatbl
, new_e
, ~0u);
4568 log
->open_attr_tbl
= oatbl
;
4575 /* Point to the entry being opened. */
4576 oe
= alloc_rsttbl_from_idx(&oatbl
, t16
);
4577 log
->open_attr_tbl
= oatbl
;
4583 /* Initialize this entry from the log record. */
4584 t16
= le16_to_cpu(lrh
->redo_off
);
4585 if (!rst
->major_ver
) {
4586 /* Convert version '0' into version '1'. */
4587 struct OPEN_ATTR_ENRTY_32
*oe0
= Add2Ptr(lrh
, t16
);
4589 oe
->bytes_per_index
= oe0
->bytes_per_index
;
4590 oe
->type
= oe0
->type
;
4591 oe
->is_dirty_pages
= oe0
->is_dirty_pages
;
4592 oe
->name_len
= 0; //oe0.name_len;
4594 oe
->open_record_lsn
= oe0
->open_record_lsn
;
4596 memcpy(oe
, Add2Ptr(lrh
, t16
), bytes_per_attr_entry
);
4599 t16
= le16_to_cpu(lrh
->undo_len
);
4601 oe
->ptr
= kmalloc(t16
, GFP_NOFS
);
4606 oe
->name_len
= t16
/ sizeof(short);
4608 Add2Ptr(lrh
, le16_to_cpu(lrh
->undo_off
)), t16
);
4609 oe
->is_attr_name
= 1;
4612 oe
->is_attr_name
= 0;
4615 goto next_log_record_analyze
;
4618 t16
= le16_to_cpu(lrh
->target_attr
);
4619 t64
= le64_to_cpu(lrh
->target_vcn
);
4620 dp
= find_dp(dptbl
, t16
, t64
);
4622 size_t j
= le64_to_cpu(lrh
->target_vcn
) -
4623 le64_to_cpu(dp
->vcn
);
4624 if (dp
->page_lcns
[j
])
4625 dp
->page_lcns
[j
] = lrh
->page_lcns
[0];
4627 goto next_log_record_analyze
;
4629 case EndTopLevelAction
:
4630 tr
= Add2Ptr(trtbl
, transact_id
);
4631 tr
->prev_lsn
= cpu_to_le64(rec_lsn
);
4632 tr
->undo_next_lsn
= frh
->client_undo_next_lsn
;
4633 goto next_log_record_analyze
;
4635 case PrepareTransaction
:
4636 tr
= Add2Ptr(trtbl
, transact_id
);
4637 tr
->transact_state
= TransactionPrepared
;
4638 goto next_log_record_analyze
;
4640 case CommitTransaction
:
4641 tr
= Add2Ptr(trtbl
, transact_id
);
4642 tr
->transact_state
= TransactionCommitted
;
4643 goto next_log_record_analyze
;
4645 case ForgetTransaction
:
4646 free_rsttbl_idx(trtbl
, transact_id
);
4647 goto next_log_record_analyze
;
4650 case OpenAttributeTableDump
:
4651 case AttributeNamesDump
:
4652 case DirtyPageTableDump
:
4653 case TransactionTableDump
:
4654 /* The following cases require no action the Analysis Pass. */
4655 goto next_log_record_analyze
;
4659 * All codes will be explicitly handled.
4660 * If we see a code we do not expect, then we are trouble.
4662 goto next_log_record_analyze
;
4665 end_log_records_enumerate
:
4670 * Scan the Dirty Page Table and Transaction Table for
4671 * the lowest lsn, and return it as the Redo lsn.
4674 while ((dp
= enum_rstbl(dptbl
, dp
))) {
4675 t64
= le64_to_cpu(dp
->oldest_lsn
);
4676 if (t64
&& t64
< rlsn
)
4681 while ((tr
= enum_rstbl(trtbl
, tr
))) {
4682 t64
= le64_to_cpu(tr
->first_lsn
);
4683 if (t64
&& t64
< rlsn
)
4688 * Only proceed if the Dirty Page Table or Transaction
4689 * table are not empty.
4691 if ((!dptbl
|| !dptbl
->total
) && (!trtbl
|| !trtbl
->total
))
4694 sbi
->flags
|= NTFS_FLAGS_NEED_REPLAY
;
4698 /* Reopen all of the attributes with dirty pages. */
4700 next_open_attribute
:
4702 oe
= enum_rstbl(oatbl
, oe
);
4706 goto next_dirty_page
;
4709 oa
= kzalloc(sizeof(struct OpenAttr
), GFP_NOFS
);
4715 inode
= ntfs_iget5(sbi
->sb
, &oe
->ref
, NULL
);
4719 if (is_bad_inode(inode
)) {
4723 iput(&oa
->ni
->vfs_inode
);
4727 attr
= attr_create_nonres_log(sbi
, oe
->type
, 0, oe
->ptr
,
4735 oa
->run1
= &oa
->run0
;
4739 ni_oe
= ntfs_i(inode
);
4742 attr
= ni_find_attr(ni_oe
, NULL
, NULL
, oe
->type
, oe
->ptr
, oe
->name_len
,
4748 t32
= le32_to_cpu(attr
->size
);
4749 oa
->attr
= kmemdup(attr
, t32
, GFP_NOFS
);
4753 if (!S_ISDIR(inode
->i_mode
)) {
4754 if (attr
->type
== ATTR_DATA
&& !attr
->name_len
) {
4755 oa
->run1
= &ni_oe
->file
.run
;
4759 if (attr
->type
== ATTR_ALLOC
&&
4760 attr
->name_len
== ARRAY_SIZE(I30_NAME
) &&
4761 !memcmp(attr_name(attr
), I30_NAME
, sizeof(I30_NAME
))) {
4762 oa
->run1
= &ni_oe
->dir
.alloc_run
;
4767 if (attr
->non_res
) {
4768 u16 roff
= le16_to_cpu(attr
->nres
.run_off
);
4769 CLST svcn
= le64_to_cpu(attr
->nres
.svcn
);
4771 err
= run_unpack(&oa
->run0
, sbi
, inode
->i_ino
, svcn
,
4772 le64_to_cpu(attr
->nres
.evcn
), svcn
,
4773 Add2Ptr(attr
, roff
), t32
- roff
);
4781 oa
->run1
= &oa
->run0
;
4785 if (oe
->is_attr_name
== 1)
4787 oe
->is_attr_name
= 0;
4789 oe
->name_len
= attr
->name_len
;
4791 goto next_open_attribute
;
4794 * Now loop through the dirty page table to extract all of the Vcn/Lcn.
4795 * Mapping that we have, and insert it into the appropriate run.
4798 dp
= enum_rstbl(dptbl
, dp
);
4802 oe
= Add2Ptr(oatbl
, le32_to_cpu(dp
->target_attr
));
4804 if (oe
->next
!= RESTART_ENTRY_ALLOCATED_LE
)
4805 goto next_dirty_page
;
4809 goto next_dirty_page
;
4812 next_dirty_page_vcn
:
4814 if (i
>= le32_to_cpu(dp
->lcns_follow
))
4815 goto next_dirty_page
;
4817 vcn
= le64_to_cpu(dp
->vcn
) + i
;
4818 size
= (vcn
+ 1) << sbi
->cluster_bits
;
4820 if (!dp
->page_lcns
[i
])
4821 goto next_dirty_page_vcn
;
4823 rno
= ino_get(&oe
->ref
);
4824 if (rno
<= MFT_REC_MIRR
&&
4825 size
< (MFT_REC_VOL
+ 1) * sbi
->record_size
&&
4826 oe
->type
== ATTR_DATA
) {
4827 goto next_dirty_page_vcn
;
4830 lcn
= le64_to_cpu(dp
->page_lcns
[i
]);
4832 if ((!run_lookup_entry(oa
->run1
, vcn
, &lcn0
, &len0
, NULL
) ||
4834 !run_add_entry(oa
->run1
, vcn
, lcn
, 1, false)) {
4839 t64
= le64_to_cpu(attr
->nres
.alloc_size
);
4841 attr
->nres
.valid_size
= attr
->nres
.data_size
=
4842 attr
->nres
.alloc_size
= cpu_to_le64(size
);
4844 goto next_dirty_page_vcn
;
4848 * Perform the Redo Pass, to restore all of the dirty pages to the same
4849 * contents that they had immediately before the crash. If the dirty
4850 * page table is empty, then we can skip the entire Redo Pass.
4852 if (!dptbl
|| !dptbl
->total
)
4853 goto do_undo_action
;
4858 * Read the record at the Redo lsn, before falling
4859 * into common code to handle each record.
4861 err
= read_log_rec_lcb(log
, rlsn
, lcb_ctx_next
, &lcb
);
4866 * Now loop to read all of our log records forwards, until
4867 * we hit the end of the file, cleaning up at the end.
4872 if (LfsClientRecord
!= frh
->record_type
)
4873 goto read_next_log_do_action
;
4875 transact_id
= le32_to_cpu(frh
->transact_id
);
4876 rec_len
= le32_to_cpu(frh
->client_data_len
);
4879 if (!check_log_rec(lrh
, rec_len
, transact_id
, bytes_per_attr_entry
)) {
4884 /* Ignore log records that do not update pages. */
4885 if (lrh
->lcns_follow
)
4886 goto find_dirty_page
;
4888 goto read_next_log_do_action
;
4891 t16
= le16_to_cpu(lrh
->target_attr
);
4892 t64
= le64_to_cpu(lrh
->target_vcn
);
4893 dp
= find_dp(dptbl
, t16
, t64
);
4896 goto read_next_log_do_action
;
4898 if (rec_lsn
< le64_to_cpu(dp
->oldest_lsn
))
4899 goto read_next_log_do_action
;
4901 t16
= le16_to_cpu(lrh
->target_attr
);
4902 if (t16
>= bytes_per_rt(oatbl
)) {
4907 oe
= Add2Ptr(oatbl
, t16
);
4909 if (oe
->next
!= RESTART_ENTRY_ALLOCATED_LE
) {
4922 vcn
= le64_to_cpu(lrh
->target_vcn
);
4924 if (!run_lookup_entry(oa
->run1
, vcn
, &lcn
, NULL
, NULL
) ||
4925 lcn
== SPARSE_LCN
) {
4926 goto read_next_log_do_action
;
4929 /* Point to the Redo data and get its length. */
4930 data
= Add2Ptr(lrh
, le16_to_cpu(lrh
->redo_off
));
4931 dlen
= le16_to_cpu(lrh
->redo_len
);
4933 /* Shorten length by any Lcns which were deleted. */
4936 for (i
= le16_to_cpu(lrh
->lcns_follow
); i
; i
--) {
4940 voff
= le16_to_cpu(lrh
->record_off
) +
4941 le16_to_cpu(lrh
->attr_off
);
4942 voff
+= le16_to_cpu(lrh
->cluster_off
) << SECTOR_SHIFT
;
4944 /* If the Vcn question is allocated, we can just get out. */
4945 j
= le64_to_cpu(lrh
->target_vcn
) - le64_to_cpu(dp
->vcn
);
4946 if (dp
->page_lcns
[j
+ i
- 1])
4953 * Calculate the allocated space left relative to the
4954 * log record Vcn, after removing this unallocated Vcn.
4956 alen
= (i
- 1) << sbi
->cluster_bits
;
4959 * If the update described this log record goes beyond
4960 * the allocated space, then we will have to reduce the length.
4964 else if (voff
+ dlen
> alen
)
4969 * If the resulting dlen from above is now zero,
4970 * we can skip this log record.
4972 if (!dlen
&& saved_len
)
4973 goto read_next_log_do_action
;
4975 t16
= le16_to_cpu(lrh
->redo_op
);
4976 if (can_skip_action(t16
))
4977 goto read_next_log_do_action
;
4979 /* Apply the Redo operation a common routine. */
4980 err
= do_action(log
, oe
, lrh
, t16
, data
, dlen
, rec_len
, &rec_lsn
);
4984 /* Keep reading and looping back until end of file. */
4985 read_next_log_do_action
:
4986 err
= read_next_log_rec(log
, lcb
, &rec_lsn
);
4987 if (!err
&& rec_lsn
)
4988 goto do_action_next
;
4994 /* Scan Transaction Table. */
4996 transaction_table_next
:
4997 tr
= enum_rstbl(trtbl
, tr
);
4999 goto undo_action_done
;
5001 if (TransactionActive
!= tr
->transact_state
|| !tr
->undo_next_lsn
) {
5002 free_rsttbl_idx(trtbl
, PtrOffset(trtbl
, tr
));
5003 goto transaction_table_next
;
5006 log
->transaction_id
= PtrOffset(trtbl
, tr
);
5007 undo_next_lsn
= le64_to_cpu(tr
->undo_next_lsn
);
5010 * We only have to do anything if the transaction has
5011 * something its undo_next_lsn field.
5016 /* Read the first record to be undone by this transaction. */
5017 err
= read_log_rec_lcb(log
, undo_next_lsn
, lcb_ctx_undo_next
, &lcb
);
5022 * Now loop to read all of our log records forwards,
5023 * until we hit the end of the file, cleaning up at the end.
5029 transact_id
= le32_to_cpu(frh
->transact_id
);
5030 rec_len
= le32_to_cpu(frh
->client_data_len
);
5032 if (!check_log_rec(lrh
, rec_len
, transact_id
, bytes_per_attr_entry
)) {
5037 if (lrh
->undo_op
== cpu_to_le16(Noop
))
5038 goto read_next_log_undo_action
;
5040 oe
= Add2Ptr(oatbl
, le16_to_cpu(lrh
->target_attr
));
5043 t16
= le16_to_cpu(lrh
->lcns_follow
);
5045 goto add_allocated_vcns
;
5047 is_mapped
= run_lookup_entry(oa
->run1
, le64_to_cpu(lrh
->target_vcn
),
5051 * If the mapping isn't already the table or the mapping
5052 * corresponds to a hole the mapping, we need to make sure
5053 * there is no partial page already memory.
5055 if (is_mapped
&& lcn
!= SPARSE_LCN
&& clen
>= t16
)
5056 goto add_allocated_vcns
;
5058 vcn
= le64_to_cpu(lrh
->target_vcn
);
5059 vcn
&= ~(log
->clst_per_page
- 1);
5062 for (i
= 0, vcn
= le64_to_cpu(lrh
->target_vcn
),
5063 size
= (vcn
+ 1) << sbi
->cluster_bits
;
5064 i
< t16
; i
++, vcn
+= 1, size
+= sbi
->cluster_size
) {
5066 if (!attr
->non_res
) {
5067 if (size
> le32_to_cpu(attr
->res
.data_size
))
5068 attr
->res
.data_size
= cpu_to_le32(size
);
5070 if (size
> le64_to_cpu(attr
->nres
.data_size
))
5071 attr
->nres
.valid_size
= attr
->nres
.data_size
=
5072 attr
->nres
.alloc_size
=
5077 t16
= le16_to_cpu(lrh
->undo_op
);
5078 if (can_skip_action(t16
))
5079 goto read_next_log_undo_action
;
5081 /* Point to the Redo data and get its length. */
5082 data
= Add2Ptr(lrh
, le16_to_cpu(lrh
->undo_off
));
5083 dlen
= le16_to_cpu(lrh
->undo_len
);
5085 /* It is time to apply the undo action. */
5086 err
= do_action(log
, oe
, lrh
, t16
, data
, dlen
, rec_len
, NULL
);
5088 read_next_log_undo_action
:
5090 * Keep reading and looping back until we have read the
5091 * last record for this transaction.
5093 err
= read_next_log_rec(log
, lcb
, &rec_lsn
);
5098 goto undo_action_next
;
5104 free_rsttbl_idx(trtbl
, log
->transaction_id
);
5106 log
->transaction_id
= 0;
5108 goto transaction_table_next
;
5112 ntfs_update_mftmirr(sbi
, 0);
5114 sbi
->flags
&= ~NTFS_FLAGS_NEED_REPLAY
;
5122 rh
= kzalloc(log
->page_size
, GFP_NOFS
);
5128 rh
->rhdr
.sign
= NTFS_RSTR_SIGNATURE
;
5129 rh
->rhdr
.fix_off
= cpu_to_le16(offsetof(struct RESTART_HDR
, fixups
));
5130 t16
= (log
->page_size
>> SECTOR_SHIFT
) + 1;
5131 rh
->rhdr
.fix_num
= cpu_to_le16(t16
);
5132 rh
->sys_page_size
= cpu_to_le32(log
->page_size
);
5133 rh
->page_size
= cpu_to_le32(log
->page_size
);
5135 t16
= ALIGN(offsetof(struct RESTART_HDR
, fixups
) +
5136 sizeof(short) * t16
, 8);
5137 rh
->ra_off
= cpu_to_le16(t16
);
5138 rh
->minor_ver
= cpu_to_le16(1); // 0x1A:
5139 rh
->major_ver
= cpu_to_le16(1); // 0x1C:
5141 ra2
= Add2Ptr(rh
, t16
);
5142 memcpy(ra2
, ra
, sizeof(struct RESTART_AREA
));
5144 ra2
->client_idx
[0] = 0;
5145 ra2
->client_idx
[1] = LFS_NO_CLIENT_LE
;
5146 ra2
->flags
= cpu_to_le16(2);
5148 le32_add_cpu(&ra2
->open_log_count
, 1);
5150 ntfs_fix_pre_write(&rh
->rhdr
, log
->page_size
);
5152 err
= ntfs_sb_write_run(sbi
, &ni
->file
.run
, 0, rh
, log
->page_size
);
5154 err
= ntfs_sb_write_run(sbi
, &log
->ni
->file
.run
, log
->page_size
,
5155 rh
, log
->page_size
);
5167 * Scan the Open Attribute Table to close all of
5168 * the open attributes.
5171 while ((oe
= enum_rstbl(oatbl
, oe
))) {
5172 rno
= ino_get(&oe
->ref
);
5174 if (oe
->is_attr_name
== 1) {
5180 if (oe
->is_attr_name
)
5187 run_close(&oa
->run0
);
5190 iput(&oa
->ni
->vfs_inode
);
5198 kfree(rst_info
.r_page
);
5201 kfree(log
->one_page_buf
);
5204 sbi
->flags
|= NTFS_FLAGS_NEED_REPLAY
;
5208 else if (log
->set_dirty
)
5209 ntfs_set_state(sbi
, NTFS_DIRTY_ERROR
);