leandrof/linux
1
0
Fork 0
forked from Minki/linux
Code Issues Pull Requests Packages Projects Releases Wiki Activity
dc5801f60b
linux/fs/ntfs3/fslog.c
Namjae Jeon f26967b9f7
fs/ntfs3: Fix invalid free in log_replay 
log_read_rst() returns ENOMEM error when there is not enough memory.
In this case, if info is returned without initialization,
it attempts to kfree the uninitialized info->r_page pointer. This patch
moves the memset initialization code to before log_read_rst() is called.

Reported-by: Gerald Lee <sundaywind2004@gmail.com>
Signed-off-by: Namjae Jeon <linkinjeon@kernel.org>
Signed-off-by: Konstantin Komarov <almaz.alexandrovich@paragon-software.com>
2022-05-31 17:29:29 +03:00

5216 lines
122 KiB
C
Raw Blame History

// SPDX-License-Identifier: GPL-2.0
/*
*
* Copyright (C) 2019-2021 Paragon Software GmbH, All rights reserved.
*
*/
#include <linux/blkdev.h>
#include <linux/fs.h>
#include <linux/random.h>
#include <linux/slab.h>
#include "debug.h"
#include "ntfs.h"
#include "ntfs_fs.h"
/*
* LOG FILE structs
*/
// clang-format off
#define MaxLogFileSize 0x100000000ull
#define DefaultLogPageSize 4096
#define MinLogRecordPages 0x30
struct RESTART_HDR {
struct NTFS_RECORD_HEADER rhdr; // 'RSTR'
__le32 sys_page_size; // 0x10: Page size of the system which initialized the log.
__le32 page_size; // 0x14: Log page size used for this log file.
__le16 ra_off; // 0x18:
__le16 minor_ver; // 0x1A:
__le16 major_ver; // 0x1C:
__le16 fixups[];
};
#define LFS_NO_CLIENT 0xffff
#define LFS_NO_CLIENT_LE cpu_to_le16(0xffff)
struct CLIENT_REC {
__le64 oldest_lsn;
__le64 restart_lsn; // 0x08:
__le16 prev_client; // 0x10:
__le16 next_client; // 0x12:
__le16 seq_num; // 0x14:
u8 align[6]; // 0x16:
__le32 name_bytes; // 0x1C: In bytes.
__le16 name[32]; // 0x20: Name of client.
};
static_assert(sizeof(struct CLIENT_REC) == 0x60);
/* Two copies of these will exist at the beginning of the log file */
struct RESTART_AREA {
__le64 current_lsn; // 0x00: Current logical end of log file.
__le16 log_clients; // 0x08: Maximum number of clients.
__le16 client_idx[2]; // 0x0A: Free/use index into the client record arrays.
__le16 flags; // 0x0E: See RESTART_SINGLE_PAGE_IO.
__le32 seq_num_bits; // 0x10: The number of bits in sequence number.
__le16 ra_len; // 0x14:
__le16 client_off; // 0x16:
__le64 l_size; // 0x18: Usable log file size.
__le32 last_lsn_data_len; // 0x20:
__le16 rec_hdr_len; // 0x24: Log page data offset.
__le16 data_off; // 0x26: Log page data length.
__le32 open_log_count; // 0x28:
__le32 align[5]; // 0x2C:
struct CLIENT_REC clients[]; // 0x40:
};
struct LOG_REC_HDR {
__le16 redo_op; // 0x00: NTFS_LOG_OPERATION
__le16 undo_op; // 0x02: NTFS_LOG_OPERATION
__le16 redo_off; // 0x04: Offset to Redo record.
__le16 redo_len; // 0x06: Redo length.
__le16 undo_off; // 0x08: Offset to Undo record.
__le16 undo_len; // 0x0A: Undo length.
__le16 target_attr; // 0x0C:
__le16 lcns_follow; // 0x0E:
__le16 record_off; // 0x10:
__le16 attr_off; // 0x12:
__le16 cluster_off; // 0x14:
__le16 reserved; // 0x16:
__le64 target_vcn; // 0x18:
__le64 page_lcns[]; // 0x20:
};
static_assert(sizeof(struct LOG_REC_HDR) == 0x20);
#define RESTART_ENTRY_ALLOCATED 0xFFFFFFFF
#define RESTART_ENTRY_ALLOCATED_LE cpu_to_le32(0xFFFFFFFF)
struct RESTART_TABLE {
__le16 size; // 0x00: In bytes
__le16 used; // 0x02: Entries
__le16 total; // 0x04: Entries
__le16 res[3]; // 0x06:
__le32 free_goal; // 0x0C:
__le32 first_free; // 0x10:
__le32 last_free; // 0x14:
};
static_assert(sizeof(struct RESTART_TABLE) == 0x18);
struct ATTR_NAME_ENTRY {
__le16 off; // Offset in the Open attribute Table.
__le16 name_bytes;
__le16 name[];
};
struct OPEN_ATTR_ENRTY {
__le32 next; // 0x00: RESTART_ENTRY_ALLOCATED if allocated
__le32 bytes_per_index; // 0x04:
enum ATTR_TYPE type; // 0x08:
u8 is_dirty_pages; // 0x0C:
u8 is_attr_name; // 0x0B: Faked field to manage 'ptr'
u8 name_len; // 0x0C: Faked field to manage 'ptr'
u8 res;
struct MFT_REF ref; // 0x10: File Reference of file containing attribute
__le64 open_record_lsn; // 0x18:
void *ptr; // 0x20:
};
/* 32 bit version of 'struct OPEN_ATTR_ENRTY' */
struct OPEN_ATTR_ENRTY_32 {
__le32 next; // 0x00: RESTART_ENTRY_ALLOCATED if allocated
__le32 ptr; // 0x04:
struct MFT_REF ref; // 0x08:
__le64 open_record_lsn; // 0x10:
u8 is_dirty_pages; // 0x18:
u8 is_attr_name; // 0x19:
u8 res1[2];
enum ATTR_TYPE type; // 0x1C:
u8 name_len; // 0x20: In wchar
u8 res2[3];
__le32 AttributeName; // 0x24:
__le32 bytes_per_index; // 0x28:
};
#define SIZEOF_OPENATTRIBUTEENTRY0 0x2c
// static_assert( 0x2C == sizeof(struct OPEN_ATTR_ENRTY_32) );
static_assert(sizeof(struct OPEN_ATTR_ENRTY) < SIZEOF_OPENATTRIBUTEENTRY0);
/*
* One entry exists in the Dirty Pages Table for each page which is dirty at
* the time the Restart Area is written.
*/
struct DIR_PAGE_ENTRY {
__le32 next; // 0x00: RESTART_ENTRY_ALLOCATED if allocated
__le32 target_attr; // 0x04: Index into the Open attribute Table
__le32 transfer_len; // 0x08:
__le32 lcns_follow; // 0x0C:
__le64 vcn; // 0x10: Vcn of dirty page
__le64 oldest_lsn; // 0x18:
__le64 page_lcns[]; // 0x20:
};
static_assert(sizeof(struct DIR_PAGE_ENTRY) == 0x20);
/* 32 bit version of 'struct DIR_PAGE_ENTRY' */
struct DIR_PAGE_ENTRY_32 {
__le32 next; // 0x00: RESTART_ENTRY_ALLOCATED if allocated
__le32 target_attr; // 0x04: Index into the Open attribute Table
__le32 transfer_len; // 0x08:
__le32 lcns_follow; // 0x0C:
__le32 reserved; // 0x10:
__le32 vcn_low; // 0x14: Vcn of dirty page
__le32 vcn_hi; // 0x18: Vcn of dirty page
__le32 oldest_lsn_low; // 0x1C:
__le32 oldest_lsn_hi; // 0x1C:
__le32 page_lcns_low; // 0x24:
__le32 page_lcns_hi; // 0x24:
};
static_assert(offsetof(struct DIR_PAGE_ENTRY_32, vcn_low) == 0x14);
static_assert(sizeof(struct DIR_PAGE_ENTRY_32) == 0x2c);
enum transact_state {
TransactionUninitialized = 0,
TransactionActive,
TransactionPrepared,
TransactionCommitted
};
struct TRANSACTION_ENTRY {
__le32 next; // 0x00: RESTART_ENTRY_ALLOCATED if allocated
u8 transact_state; // 0x04:
u8 reserved[3]; // 0x05:
__le64 first_lsn; // 0x08:
__le64 prev_lsn; // 0x10:
__le64 undo_next_lsn; // 0x18:
__le32 undo_records; // 0x20: Number of undo log records pending abort
__le32 undo_len; // 0x24: Total undo size
};
static_assert(sizeof(struct TRANSACTION_ENTRY) == 0x28);
struct NTFS_RESTART {
__le32 major_ver; // 0x00:
__le32 minor_ver; // 0x04:
__le64 check_point_start; // 0x08:
__le64 open_attr_table_lsn; // 0x10:
__le64 attr_names_lsn; // 0x18:
__le64 dirty_pages_table_lsn; // 0x20:
__le64 transact_table_lsn; // 0x28:
__le32 open_attr_len; // 0x30: In bytes
__le32 attr_names_len; // 0x34: In bytes
__le32 dirty_pages_len; // 0x38: In bytes
__le32 transact_table_len; // 0x3C: In bytes
};
static_assert(sizeof(struct NTFS_RESTART) == 0x40);
struct NEW_ATTRIBUTE_SIZES {
__le64 alloc_size;
__le64 valid_size;
__le64 data_size;
__le64 total_size;
};
struct BITMAP_RANGE {
__le32 bitmap_off;
__le32 bits;
};
struct LCN_RANGE {
__le64 lcn;
__le64 len;
};
/* The following type defines the different log record types. */
#define LfsClientRecord cpu_to_le32(1)
#define LfsClientRestart cpu_to_le32(2)
/* This is used to uniquely identify a client for a particular log file. */
struct CLIENT_ID {
__le16 seq_num;
__le16 client_idx;
};
/* This is the header that begins every Log Record in the log file. */
struct LFS_RECORD_HDR {
__le64 this_lsn; // 0x00:
__le64 client_prev_lsn; // 0x08:
__le64 client_undo_next_lsn; // 0x10:
__le32 client_data_len; // 0x18:
struct CLIENT_ID client; // 0x1C: Owner of this log record.
__le32 record_type; // 0x20: LfsClientRecord or LfsClientRestart.
__le32 transact_id; // 0x24:
__le16 flags; // 0x28: LOG_RECORD_MULTI_PAGE
u8 align[6]; // 0x2A:
};
#define LOG_RECORD_MULTI_PAGE cpu_to_le16(1)
static_assert(sizeof(struct LFS_RECORD_HDR) == 0x30);
struct LFS_RECORD {
__le16 next_record_off; // 0x00: Offset of the free space in the page,
u8 align[6]; // 0x02:
__le64 last_end_lsn; // 0x08: lsn for the last log record which ends on the page,
};
static_assert(sizeof(struct LFS_RECORD) == 0x10);
struct RECORD_PAGE_HDR {
struct NTFS_RECORD_HEADER rhdr; // 'RCRD'
__le32 rflags; // 0x10: See LOG_PAGE_LOG_RECORD_END
__le16 page_count; // 0x14:
__le16 page_pos; // 0x16:
struct LFS_RECORD record_hdr; // 0x18:
__le16 fixups[10]; // 0x28:
__le32 file_off; // 0x3c: Used when major version >= 2
};
// clang-format on
// Page contains the end of a log record.
#define LOG_PAGE_LOG_RECORD_END cpu_to_le32(0x00000001)
static inline bool is_log_record_end(const struct RECORD_PAGE_HDR *hdr)
{
return hdr->rflags & LOG_PAGE_LOG_RECORD_END;
}
static_assert(offsetof(struct RECORD_PAGE_HDR, file_off) == 0x3c);
/*
* END of NTFS LOG structures
*/
/* Define some tuning parameters to keep the restart tables a reasonable size. */
#define INITIAL_NUMBER_TRANSACTIONS 5
enum NTFS_LOG_OPERATION {
Noop = 0x00,
CompensationLogRecord = 0x01,
InitializeFileRecordSegment = 0x02,
DeallocateFileRecordSegment = 0x03,
WriteEndOfFileRecordSegment = 0x04,
CreateAttribute = 0x05,
DeleteAttribute = 0x06,
UpdateResidentValue = 0x07,
UpdateNonresidentValue = 0x08,
UpdateMappingPairs = 0x09,
DeleteDirtyClusters = 0x0A,
SetNewAttributeSizes = 0x0B,
AddIndexEntryRoot = 0x0C,
DeleteIndexEntryRoot = 0x0D,
AddIndexEntryAllocation = 0x0E,
DeleteIndexEntryAllocation = 0x0F,
WriteEndOfIndexBuffer = 0x10,
SetIndexEntryVcnRoot = 0x11,
SetIndexEntryVcnAllocation = 0x12,
UpdateFileNameRoot = 0x13,
UpdateFileNameAllocation = 0x14,
SetBitsInNonresidentBitMap = 0x15,
ClearBitsInNonresidentBitMap = 0x16,
HotFix = 0x17,
EndTopLevelAction = 0x18,
PrepareTransaction = 0x19,
CommitTransaction = 0x1A,
ForgetTransaction = 0x1B,
OpenNonresidentAttribute = 0x1C,
OpenAttributeTableDump = 0x1D,
AttributeNamesDump = 0x1E,
DirtyPageTableDump = 0x1F,
TransactionTableDump = 0x20,
UpdateRecordDataRoot = 0x21,
UpdateRecordDataAllocation = 0x22,
UpdateRelativeDataInIndex =
0x23, // NtOfsRestartUpdateRelativeDataInIndex
UpdateRelativeDataInIndex2 = 0x24,
ZeroEndOfFileRecord = 0x25,
};
/*
* Array for log records which require a target attribute.
* A true indicates that the corresponding restart operation
* requires a target attribute.
*/
static const u8 AttributeRequired[] = {
0xFC, 0xFB, 0xFF, 0x10, 0x06,
};
static inline bool is_target_required(u16 op)
{
bool ret = op <= UpdateRecordDataAllocation &&
(AttributeRequired[op >> 3] >> (op & 7) & 1);
return ret;
}
static inline bool can_skip_action(enum NTFS_LOG_OPERATION op)
{
switch (op) {
case Noop:
case DeleteDirtyClusters:
case HotFix:
case EndTopLevelAction:
case PrepareTransaction:
case CommitTransaction:
case ForgetTransaction:
case CompensationLogRecord:
case OpenNonresidentAttribute:
case OpenAttributeTableDump:
case AttributeNamesDump:
case DirtyPageTableDump:
case TransactionTableDump:
return true;
default:
return false;
}
}
enum { lcb_ctx_undo_next, lcb_ctx_prev, lcb_ctx_next };
/* Bytes per restart table. */
static inline u32 bytes_per_rt(const struct RESTART_TABLE *rt)
{
return le16_to_cpu(rt->used) * le16_to_cpu(rt->size) +
sizeof(struct RESTART_TABLE);
}
/* Log record length. */
static inline u32 lrh_length(const struct LOG_REC_HDR *lr)
{
u16 t16 = le16_to_cpu(lr->lcns_follow);
return struct_size(lr, page_lcns, max_t(u16, 1, t16));
}
struct lcb {
struct LFS_RECORD_HDR *lrh; // Log record header of the current lsn.
struct LOG_REC_HDR *log_rec;
u32 ctx_mode; // lcb_ctx_undo_next/lcb_ctx_prev/lcb_ctx_next
struct CLIENT_ID client;
bool alloc; // If true the we should deallocate 'log_rec'.
};
static void lcb_put(struct lcb *lcb)
{
if (lcb->alloc)
kfree(lcb->log_rec);
kfree(lcb->lrh);
kfree(lcb);
}
/* Find the oldest lsn from active clients. */
static inline void oldest_client_lsn(const struct CLIENT_REC *ca,
__le16 next_client, u64 *oldest_lsn)
{
while (next_client != LFS_NO_CLIENT_LE) {
const struct CLIENT_REC *cr = ca + le16_to_cpu(next_client);
u64 lsn = le64_to_cpu(cr->oldest_lsn);
/* Ignore this block if it's oldest lsn is 0. */
if (lsn && lsn < *oldest_lsn)
*oldest_lsn = lsn;
next_client = cr->next_client;
}
}
static inline bool is_rst_page_hdr_valid(u32 file_off,
const struct RESTART_HDR *rhdr)
{
u32 sys_page = le32_to_cpu(rhdr->sys_page_size);
u32 page_size = le32_to_cpu(rhdr->page_size);
u32 end_usa;
u16 ro;
if (sys_page < SECTOR_SIZE || page_size < SECTOR_SIZE ||
sys_page & (sys_page - 1) || page_size & (page_size - 1)) {
return false;
}
/* Check that if the file offset isn't 0, it is the system page size. */
if (file_off && file_off != sys_page)
return false;
/* Check support version 1.1+. */
if (le16_to_cpu(rhdr->major_ver) <= 1 && !rhdr->minor_ver)
return false;
if (le16_to_cpu(rhdr->major_ver) > 2)
return false;
ro = le16_to_cpu(rhdr->ra_off);
if (!IS_ALIGNED(ro, 8) || ro > sys_page)
return false;
end_usa = ((sys_page >> SECTOR_SHIFT) + 1) * sizeof(short);
end_usa += le16_to_cpu(rhdr->rhdr.fix_off);
if (ro < end_usa)
return false;
return true;
}
static inline bool is_rst_area_valid(const struct RESTART_HDR *rhdr)
{
const struct RESTART_AREA *ra;
u16 cl, fl, ul;
u32 off, l_size, file_dat_bits, file_size_round;
u16 ro = le16_to_cpu(rhdr->ra_off);
u32 sys_page = le32_to_cpu(rhdr->sys_page_size);
if (ro + offsetof(struct RESTART_AREA, l_size) >
SECTOR_SIZE - sizeof(short))
return false;
ra = Add2Ptr(rhdr, ro);
cl = le16_to_cpu(ra->log_clients);
if (cl > 1)
return false;
off = le16_to_cpu(ra->client_off);
if (!IS_ALIGNED(off, 8) || ro + off > SECTOR_SIZE - sizeof(short))
return false;
off += cl * sizeof(struct CLIENT_REC);
if (off > sys_page)
return false;
/*
* Check the restart length field and whether the entire
* restart area is contained that length.
*/
if (le16_to_cpu(rhdr->ra_off) + le16_to_cpu(ra->ra_len) > sys_page ||
off > le16_to_cpu(ra->ra_len)) {
return false;
}
/*
* As a final check make sure that the use list and the free list
* are either empty or point to a valid client.
*/
fl = le16_to_cpu(ra->client_idx[0]);
ul = le16_to_cpu(ra->client_idx[1]);
if ((fl != LFS_NO_CLIENT && fl >= cl) ||
(ul != LFS_NO_CLIENT && ul >= cl))
return false;
/* Make sure the sequence number bits match the log file size. */
l_size = le64_to_cpu(ra->l_size);
file_dat_bits = sizeof(u64) * 8 - le32_to_cpu(ra->seq_num_bits);
file_size_round = 1u << (file_dat_bits + 3);
if (file_size_round != l_size &&
(file_size_round < l_size || (file_size_round / 2) > l_size)) {
return false;
}
/* The log page data offset and record header length must be quad-aligned. */
if (!IS_ALIGNED(le16_to_cpu(ra->data_off), 8) ||
!IS_ALIGNED(le16_to_cpu(ra->rec_hdr_len), 8))
return false;
return true;
}
static inline bool is_client_area_valid(const struct RESTART_HDR *rhdr,
bool usa_error)
{
u16 ro = le16_to_cpu(rhdr->ra_off);
const struct RESTART_AREA *ra = Add2Ptr(rhdr, ro);
u16 ra_len = le16_to_cpu(ra->ra_len);
const struct CLIENT_REC *ca;
u32 i;
if (usa_error && ra_len + ro > SECTOR_SIZE - sizeof(short))
return false;
/* Find the start of the client array. */
ca = Add2Ptr(ra, le16_to_cpu(ra->client_off));
/*
* Start with the free list.
* Check that all the clients are valid and that there isn't a cycle.
* Do the in-use list on the second pass.
*/
for (i = 0; i < 2; i++) {
u16 client_idx = le16_to_cpu(ra->client_idx[i]);
bool first_client = true;
u16 clients = le16_to_cpu(ra->log_clients);
while (client_idx != LFS_NO_CLIENT) {
const struct CLIENT_REC *cr;
if (!clients ||
client_idx >= le16_to_cpu(ra->log_clients))
return false;
clients -= 1;
cr = ca + client_idx;
client_idx = le16_to_cpu(cr->next_client);
if (first_client) {
first_client = false;
if (cr->prev_client != LFS_NO_CLIENT_LE)
return false;
}
}
}
return true;
}
/*
* remove_client
*
* Remove a client record from a client record list an restart area.
*/
static inline void remove_client(struct CLIENT_REC *ca,
const struct CLIENT_REC *cr, __le16 *head)
{
if (cr->prev_client == LFS_NO_CLIENT_LE)
*head = cr->next_client;
else
ca[le16_to_cpu(cr->prev_client)].next_client = cr->next_client;
if (cr->next_client != LFS_NO_CLIENT_LE)
ca[le16_to_cpu(cr->next_client)].prev_client = cr->prev_client;
}
/*
* add_client - Add a client record to the start of a list.
*/
static inline void add_client(struct CLIENT_REC *ca, u16 index, __le16 *head)
{
struct CLIENT_REC *cr = ca + index;
cr->prev_client = LFS_NO_CLIENT_LE;
cr->next_client = *head;
if (*head != LFS_NO_CLIENT_LE)
ca[le16_to_cpu(*head)].prev_client = cpu_to_le16(index);
*head = cpu_to_le16(index);
}
static inline void *enum_rstbl(struct RESTART_TABLE *t, void *c)
{
__le32 *e;
u32 bprt;
u16 rsize = t ? le16_to_cpu(t->size) : 0;
if (!c) {
if (!t || !t->total)
return NULL;
e = Add2Ptr(t, sizeof(struct RESTART_TABLE));
} else {
e = Add2Ptr(c, rsize);
}
/* Loop until we hit the first one allocated, or the end of the list. */
for (bprt = bytes_per_rt(t); PtrOffset(t, e) < bprt;
e = Add2Ptr(e, rsize)) {
if (*e == RESTART_ENTRY_ALLOCATED_LE)
return e;
}
return NULL;
}
/*
* find_dp - Search for a @vcn in Dirty Page Table.
*/
static inline struct DIR_PAGE_ENTRY *find_dp(struct RESTART_TABLE *dptbl,
u32 target_attr, u64 vcn)
{
__le32 ta = cpu_to_le32(target_attr);
struct DIR_PAGE_ENTRY *dp = NULL;
while ((dp = enum_rstbl(dptbl, dp))) {
u64 dp_vcn = le64_to_cpu(dp->vcn);
if (dp->target_attr == ta && vcn >= dp_vcn &&
vcn < dp_vcn + le32_to_cpu(dp->lcns_follow)) {
return dp;
}
}
return NULL;
}
static inline u32 norm_file_page(u32 page_size, u32 *l_size, bool use_default)
{
if (use_default)
page_size = DefaultLogPageSize;
/* Round the file size down to a system page boundary. */
*l_size &= ~(page_size - 1);
/* File should contain at least 2 restart pages and MinLogRecordPages pages. */
if (*l_size < (MinLogRecordPages + 2) * page_size)
return 0;
return page_size;
}
static bool check_log_rec(const struct LOG_REC_HDR *lr, u32 bytes, u32 tr,
u32 bytes_per_attr_entry)
{
u16 t16;
if (bytes < sizeof(struct LOG_REC_HDR))
return false;
if (!tr)
return false;
if ((tr - sizeof(struct RESTART_TABLE)) %
sizeof(struct TRANSACTION_ENTRY))
return false;
if (le16_to_cpu(lr->redo_off) & 7)
return false;
if (le16_to_cpu(lr->undo_off) & 7)
return false;
if (lr->target_attr)
goto check_lcns;
if (is_target_required(le16_to_cpu(lr->redo_op)))
return false;
if (is_target_required(le16_to_cpu(lr->undo_op)))
return false;
check_lcns:
if (!lr->lcns_follow)
goto check_length;
t16 = le16_to_cpu(lr->target_attr);
if ((t16 - sizeof(struct RESTART_TABLE)) % bytes_per_attr_entry)
return false;
check_length:
if (bytes < lrh_length(lr))
return false;
return true;
}
static bool check_rstbl(const struct RESTART_TABLE *rt, size_t bytes)
{
u32 ts;
u32 i, off;
u16 rsize = le16_to_cpu(rt->size);
u16 ne = le16_to_cpu(rt->used);
u32 ff = le32_to_cpu(rt->first_free);
u32 lf = le32_to_cpu(rt->last_free);
ts = rsize * ne + sizeof(struct RESTART_TABLE);
if (!rsize || rsize > bytes ||
rsize + sizeof(struct RESTART_TABLE) > bytes || bytes < ts ||
le16_to_cpu(rt->total) > ne || ff > ts || lf > ts ||
(ff && ff < sizeof(struct RESTART_TABLE)) ||
(lf && lf < sizeof(struct RESTART_TABLE))) {
return false;
}
/*
* Verify each entry is either allocated or points
* to a valid offset the table.
*/
for (i = 0; i < ne; i++) {
off = le32_to_cpu(*(__le32 *)Add2Ptr(
rt, i * rsize + sizeof(struct RESTART_TABLE)));
if (off != RESTART_ENTRY_ALLOCATED && off &&
(off < sizeof(struct RESTART_TABLE) ||
((off - sizeof(struct RESTART_TABLE)) % rsize))) {
return false;
}
}
/*
* Walk through the list headed by the first entry to make
* sure none of the entries are currently being used.
*/
for (off = ff; off;) {
if (off == RESTART_ENTRY_ALLOCATED)
return false;
off = le32_to_cpu(*(__le32 *)Add2Ptr(rt, off));
}
return true;
}
/*
* free_rsttbl_idx - Free a previously allocated index a Restart Table.
*/
static inline void free_rsttbl_idx(struct RESTART_TABLE *rt, u32 off)
{
__le32 *e;
u32 lf = le32_to_cpu(rt->last_free);
__le32 off_le = cpu_to_le32(off);
e = Add2Ptr(rt, off);
if (off < le32_to_cpu(rt->free_goal)) {
*e = rt->first_free;
rt->first_free = off_le;
if (!lf)
rt->last_free = off_le;
} else {
if (lf)
*(__le32 *)Add2Ptr(rt, lf) = off_le;
else
rt->first_free = off_le;
rt->last_free = off_le;
*e = 0;
}
le16_sub_cpu(&rt->total, 1);
}
static inline struct RESTART_TABLE *init_rsttbl(u16 esize, u16 used)
{
__le32 *e, *last_free;
u32 off;
u32 bytes = esize * used + sizeof(struct RESTART_TABLE);
u32 lf = sizeof(struct RESTART_TABLE) + (used - 1) * esize;
struct RESTART_TABLE *t = kzalloc(bytes, GFP_NOFS);
if (!t)
return NULL;
t->size = cpu_to_le16(esize);
t->used = cpu_to_le16(used);
t->free_goal = cpu_to_le32(~0u);
t->first_free = cpu_to_le32(sizeof(struct RESTART_TABLE));
t->last_free = cpu_to_le32(lf);
e = (__le32 *)(t + 1);
last_free = Add2Ptr(t, lf);
for (off = sizeof(struct RESTART_TABLE) + esize; e < last_free;
e = Add2Ptr(e, esize), off += esize) {
*e = cpu_to_le32(off);
}
return t;
}
static inline struct RESTART_TABLE *extend_rsttbl(struct RESTART_TABLE *tbl,
u32 add, u32 free_goal)
{
u16 esize = le16_to_cpu(tbl->size);
__le32 osize = cpu_to_le32(bytes_per_rt(tbl));
u32 used = le16_to_cpu(tbl->used);
struct RESTART_TABLE *rt;
rt = init_rsttbl(esize, used + add);
if (!rt)
return NULL;
memcpy(rt + 1, tbl + 1, esize * used);
rt->free_goal = free_goal == ~0u
? cpu_to_le32(~0u)
: cpu_to_le32(sizeof(struct RESTART_TABLE) +
free_goal * esize);
if (tbl->first_free) {
rt->first_free = tbl->first_free;
*(__le32 *)Add2Ptr(rt, le32_to_cpu(tbl->last_free)) = osize;
} else {
rt->first_free = osize;
}
rt->total = tbl->total;
kfree(tbl);
return rt;
}
/*
* alloc_rsttbl_idx
*
* Allocate an index from within a previously initialized Restart Table.
*/
static inline void *alloc_rsttbl_idx(struct RESTART_TABLE **tbl)
{
u32 off;
__le32 *e;
struct RESTART_TABLE *t = *tbl;
if (!t->first_free) {
*tbl = t = extend_rsttbl(t, 16, ~0u);
if (!t)
return NULL;
}
off = le32_to_cpu(t->first_free);
/* Dequeue this entry and zero it. */
e = Add2Ptr(t, off);
t->first_free = *e;
memset(e, 0, le16_to_cpu(t->size));
*e = RESTART_ENTRY_ALLOCATED_LE;
/* If list is going empty, then we fix the last_free as well. */
if (!t->first_free)
t->last_free = 0;
le16_add_cpu(&t->total, 1);
return Add2Ptr(t, off);
}
/*
* alloc_rsttbl_from_idx
*
* Allocate a specific index from within a previously initialized Restart Table.
*/
static inline void *alloc_rsttbl_from_idx(struct RESTART_TABLE **tbl, u32 vbo)
{
u32 off;
__le32 *e;
struct RESTART_TABLE *rt = *tbl;
u32 bytes = bytes_per_rt(rt);
u16 esize = le16_to_cpu(rt->size);
/* If the entry is not the table, we will have to extend the table. */
if (vbo >= bytes) {
/*
* Extend the size by computing the number of entries between
* the existing size and the desired index and adding 1 to that.
*/
u32 bytes2idx = vbo - bytes;
/*
* There should always be an integral number of entries
* being added. Now extend the table.
*/
*tbl = rt = extend_rsttbl(rt, bytes2idx / esize + 1, bytes);
if (!rt)
return NULL;
}
/* See if the entry is already allocated, and just return if it is. */
e = Add2Ptr(rt, vbo);
if (*e == RESTART_ENTRY_ALLOCATED_LE)
return e;
/*
* Walk through the table, looking for the entry we're
* interested and the previous entry.
*/
off = le32_to_cpu(rt->first_free);
e = Add2Ptr(rt, off);
if (off == vbo) {
/* this is a match */
rt->first_free = *e;
goto skip_looking;
}
/*
* Need to walk through the list looking for the predecessor
* of our entry.
*/
for (;;) {
/* Remember the entry just found */
u32 last_off = off;
__le32 *last_e = e;
/* Should never run of entries. */
/* Lookup up the next entry the list. */
off = le32_to_cpu(*last_e);
e = Add2Ptr(rt, off);
/* If this is our match we are done. */
if (off == vbo) {
*last_e = *e;
/*
* If this was the last entry, we update that
* table as well.
*/
if (le32_to_cpu(rt->last_free) == off)
rt->last_free = cpu_to_le32(last_off);
break;
}
}
skip_looking:
/* If the list is now empty, we fix the last_free as well. */
if (!rt->first_free)
rt->last_free = 0;
/* Zero this entry. */
memset(e, 0, esize);
*e = RESTART_ENTRY_ALLOCATED_LE;
le16_add_cpu(&rt->total, 1);
return e;
}
#define RESTART_SINGLE_PAGE_IO cpu_to_le16(0x0001)
#define NTFSLOG_WRAPPED 0x00000001
#define NTFSLOG_MULTIPLE_PAGE_IO 0x00000002
#define NTFSLOG_NO_LAST_LSN 0x00000004
#define NTFSLOG_REUSE_TAIL 0x00000010
#define NTFSLOG_NO_OLDEST_LSN 0x00000020
/* Helper struct to work with NTFS $LogFile. */
struct ntfs_log {
struct ntfs_inode *ni;
u32 l_size;
u32 sys_page_size;
u32 sys_page_mask;
u32 page_size;
u32 page_mask; // page_size - 1
u8 page_bits;
struct RECORD_PAGE_HDR *one_page_buf;
struct RESTART_TABLE *open_attr_tbl;
u32 transaction_id;
u32 clst_per_page;
u32 first_page;
u32 next_page;
u32 ra_off;
u32 data_off;
u32 restart_size;
u32 data_size;
u16 record_header_len;
u64 seq_num;
u32 seq_num_bits;
u32 file_data_bits;
u32 seq_num_mask; /* (1 << file_data_bits) - 1 */
struct RESTART_AREA *ra; /* In-memory image of the next restart area. */
u32 ra_size; /* The usable size of the restart area. */
/*
* If true, then the in-memory restart area is to be written
* to the first position on the disk.
*/
bool init_ra;
bool set_dirty; /* True if we need to set dirty flag. */
u64 oldest_lsn;
u32 oldest_lsn_off;
u64 last_lsn;
u32 total_avail;
u32 total_avail_pages;
u32 total_undo_commit;
u32 max_current_avail;
u32 current_avail;
u32 reserved;
short major_ver;
short minor_ver;
u32 l_flags; /* See NTFSLOG_XXX */
u32 current_openlog_count; /* On-disk value for open_log_count. */
struct CLIENT_ID client_id;
u32 client_undo_commit;
};
static inline u32 lsn_to_vbo(struct ntfs_log *log, const u64 lsn)
{
u32 vbo = (lsn << log->seq_num_bits) >> (log->seq_num_bits - 3);
return vbo;
}
/* Compute the offset in the log file of the next log page. */
static inline u32 next_page_off(struct ntfs_log *log, u32 off)
{
off = (off & ~log->sys_page_mask) + log->page_size;
return off >= log->l_size ? log->first_page : off;
}
static inline u32 lsn_to_page_off(struct ntfs_log *log, u64 lsn)
{
return (((u32)lsn) << 3) & log->page_mask;
}
static inline u64 vbo_to_lsn(struct ntfs_log *log, u32 off, u64 Seq)
{
return (off >> 3) + (Seq << log->file_data_bits);
}
static inline bool is_lsn_in_file(struct ntfs_log *log, u64 lsn)
{
return lsn >= log->oldest_lsn &&
lsn <= le64_to_cpu(log->ra->current_lsn);
}
static inline u32 hdr_file_off(struct ntfs_log *log,
struct RECORD_PAGE_HDR *hdr)
{
if (log->major_ver < 2)
return le64_to_cpu(hdr->rhdr.lsn);
return le32_to_cpu(hdr->file_off);
}
static inline u64 base_lsn(struct ntfs_log *log,
const struct RECORD_PAGE_HDR *hdr, u64 lsn)
{
u64 h_lsn = le64_to_cpu(hdr->rhdr.lsn);
u64 ret = (((h_lsn >> log->file_data_bits) +
(lsn < (lsn_to_vbo(log, h_lsn) & ~log->page_mask) ? 1 : 0))
<< log->file_data_bits) +
((((is_log_record_end(hdr) &&
h_lsn <= le64_to_cpu(hdr->record_hdr.last_end_lsn))
? le16_to_cpu(hdr->record_hdr.next_record_off)
: log->page_size) +
lsn) >>
3);
return ret;
}
static inline bool verify_client_lsn(struct ntfs_log *log,
const struct CLIENT_REC *client, u64 lsn)
{
return lsn >= le64_to_cpu(client->oldest_lsn) &&
lsn <= le64_to_cpu(log->ra->current_lsn) && lsn;
}
struct restart_info {
u64 last_lsn;
struct RESTART_HDR *r_page;
u32 vbo;
bool chkdsk_was_run;
bool valid_page;
bool initialized;
bool restart;
};
static int read_log_page(struct ntfs_log *log, u32 vbo,
struct RECORD_PAGE_HDR **buffer, bool *usa_error)
{
int err = 0;
u32 page_idx = vbo >> log->page_bits;
u32 page_off = vbo & log->page_mask;
u32 bytes = log->page_size - page_off;
void *to_free = NULL;
u32 page_vbo = page_idx << log->page_bits;
struct RECORD_PAGE_HDR *page_buf;
struct ntfs_inode *ni = log->ni;
bool bBAAD;
if (vbo >= log->l_size)
return -EINVAL;
if (!*buffer) {
to_free = kmalloc(bytes, GFP_NOFS);
if (!to_free)
return -ENOMEM;
*buffer = to_free;
}
page_buf = page_off ? log->one_page_buf : *buffer;
err = ntfs_read_run_nb(ni->mi.sbi, &ni->file.run, page_vbo, page_buf,
log->page_size, NULL);
if (err)
goto out;
if (page_buf->rhdr.sign != NTFS_FFFF_SIGNATURE)
ntfs_fix_post_read(&page_buf->rhdr, PAGE_SIZE, false);
if (page_buf != *buffer)
memcpy(*buffer, Add2Ptr(page_buf, page_off), bytes);
bBAAD = page_buf->rhdr.sign == NTFS_BAAD_SIGNATURE;
if (usa_error)
*usa_error = bBAAD;
/* Check that the update sequence array for this page is valid */
/* If we don't allow errors, raise an error status */
else if (bBAAD)
err = -EINVAL;
out:
if (err && to_free) {
kfree(to_free);
*buffer = NULL;
}
return err;
}
/*
* log_read_rst
*
* It walks through 512 blocks of the file looking for a valid
* restart page header. It will stop the first time we find a
* valid page header.
*/
static int log_read_rst(struct ntfs_log *log, u32 l_size, bool first,
struct restart_info *info)
{
u32 skip, vbo;
struct RESTART_HDR *r_page = kmalloc(DefaultLogPageSize, GFP_NOFS);
if (!r_page)
return -ENOMEM;
/* Determine which restart area we are looking for. */
if (first) {
vbo = 0;
skip = 512;
} else {
vbo = 512;
skip = 0;
}
/* Loop continuously until we succeed. */
for (; vbo < l_size; vbo = 2 * vbo + skip, skip = 0) {
bool usa_error;
u32 sys_page_size;
bool brst, bchk;
struct RESTART_AREA *ra;
/* Read a page header at the current offset. */
if (read_log_page(log, vbo, (struct RECORD_PAGE_HDR **)&r_page,
&usa_error)) {
/* Ignore any errors. */
continue;
}
/* Exit if the signature is a log record page. */
if (r_page->rhdr.sign == NTFS_RCRD_SIGNATURE) {
info->initialized = true;
break;
}
brst = r_page->rhdr.sign == NTFS_RSTR_SIGNATURE;
bchk = r_page->rhdr.sign == NTFS_CHKD_SIGNATURE;
if (!bchk && !brst) {
if (r_page->rhdr.sign != NTFS_FFFF_SIGNATURE) {
/*
* Remember if the signature does not
* indicate uninitialized file.
*/
info->initialized = true;
}
continue;
}
ra = NULL;
info->valid_page = false;
info->initialized = true;
info->vbo = vbo;
/* Let's check the restart area if this is a valid page. */
if (!is_rst_page_hdr_valid(vbo, r_page))
goto check_result;
ra = Add2Ptr(r_page, le16_to_cpu(r_page->ra_off));
if (!is_rst_area_valid(r_page))
goto check_result;
/*
* We have a valid restart page header and restart area.
* If chkdsk was run or we have no clients then we have
* no more checking to do.
*/
if (bchk || ra->client_idx[1] == LFS_NO_CLIENT_LE) {
info->valid_page = true;
goto check_result;
}
/* Read the entire restart area. */
sys_page_size = le32_to_cpu(r_page->sys_page_size);
if (DefaultLogPageSize != sys_page_size) {
kfree(r_page);
r_page = kzalloc(sys_page_size, GFP_NOFS);
if (!r_page)
return -ENOMEM;
if (read_log_page(log, vbo,
(struct RECORD_PAGE_HDR **)&r_page,
&usa_error)) {
/* Ignore any errors. */
kfree(r_page);
r_page = NULL;
continue;
}
}
if (is_client_area_valid(r_page, usa_error)) {
info->valid_page = true;
ra = Add2Ptr(r_page, le16_to_cpu(r_page->ra_off));
}
check_result:
/*
* If chkdsk was run then update the caller's
* values and return.
*/
if (r_page->rhdr.sign == NTFS_CHKD_SIGNATURE) {
info->chkdsk_was_run = true;
info->last_lsn = le64_to_cpu(r_page->rhdr.lsn);
info->restart = true;
info->r_page = r_page;
return 0;
}
/*
* If we have a valid page then copy the values
* we need from it.
*/
if (info->valid_page) {
info->last_lsn = le64_to_cpu(ra->current_lsn);
info->restart = true;
info->r_page = r_page;
return 0;
}
}
kfree(r_page);
return 0;
}
/*
* Ilog_init_pg_hdr - Init @log from restart page header.
*/
static void log_init_pg_hdr(struct ntfs_log *log, u32 sys_page_size,
u32 page_size, u16 major_ver, u16 minor_ver)
{
log->sys_page_size = sys_page_size;
log->sys_page_mask = sys_page_size - 1;
log->page_size = page_size;
log->page_mask = page_size - 1;
log->page_bits = blksize_bits(page_size);
log->clst_per_page = log->page_size >> log->ni->mi.sbi->cluster_bits;
if (!log->clst_per_page)
log->clst_per_page = 1;
log->first_page = major_ver >= 2
? 0x22 * page_size
: ((sys_page_size << 1) + (page_size << 1));
log->major_ver = major_ver;
log->minor_ver = minor_ver;
}
/*
* log_create - Init @log in cases when we don't have a restart area to use.
*/
static void log_create(struct ntfs_log *log, u32 l_size, const u64 last_lsn,
u32 open_log_count, bool wrapped, bool use_multi_page)
{
log->l_size = l_size;
/* All file offsets must be quadword aligned. */
log->file_data_bits = blksize_bits(l_size) - 3;
log->seq_num_mask = (8 << log->file_data_bits) - 1;
log->seq_num_bits = sizeof(u64) * 8 - log->file_data_bits;
log->seq_num = (last_lsn >> log->file_data_bits) + 2;
log->next_page = log->first_page;
log->oldest_lsn = log->seq_num << log->file_data_bits;
log->oldest_lsn_off = 0;
log->last_lsn = log->oldest_lsn;
log->l_flags |= NTFSLOG_NO_LAST_LSN | NTFSLOG_NO_OLDEST_LSN;
/* Set the correct flags for the I/O and indicate if we have wrapped. */
if (wrapped)
log->l_flags |= NTFSLOG_WRAPPED;
if (use_multi_page)
log->l_flags |= NTFSLOG_MULTIPLE_PAGE_IO;
/* Compute the log page values. */
log->data_off = ALIGN(
offsetof(struct RECORD_PAGE_HDR, fixups) +
sizeof(short) * ((log->page_size >> SECTOR_SHIFT) + 1),
8);
log->data_size = log->page_size - log->data_off;
log->record_header_len = sizeof(struct LFS_RECORD_HDR);
/* Remember the different page sizes for reservation. */
log->reserved = log->data_size - log->record_header_len;
/* Compute the restart page values. */
log->ra_off = ALIGN(
offsetof(struct RESTART_HDR, fixups) +
sizeof(short) *
((log->sys_page_size >> SECTOR_SHIFT) + 1),
8);
log->restart_size = log->sys_page_size - log->ra_off;
log->ra_size = struct_size(log->ra, clients, 1);
log->current_openlog_count = open_log_count;
/*
* The total available log file space is the number of
* log file pages times the space available on each page.
*/
log->total_avail_pages = log->l_size - log->first_page;
log->total_avail = log->total_avail_pages >> log->page_bits;
/*
* We assume that we can't use the end of the page less than
* the file record size.
* Then we won't need to reserve more than the caller asks for.
*/
log->max_current_avail = log->total_avail * log->reserved;
log->total_avail = log->total_avail * log->data_size;
log->current_avail = log->max_current_avail;
}
/*
* log_create_ra - Fill a restart area from the values stored in @log.
*/
static struct RESTART_AREA *log_create_ra(struct ntfs_log *log)
{
struct CLIENT_REC *cr;
struct RESTART_AREA *ra = kzalloc(log->restart_size, GFP_NOFS);
if (!ra)
return NULL;
ra->current_lsn = cpu_to_le64(log->last_lsn);
ra->log_clients = cpu_to_le16(1);
ra->client_idx[1] = LFS_NO_CLIENT_LE;
if (log->l_flags & NTFSLOG_MULTIPLE_PAGE_IO)
ra->flags = RESTART_SINGLE_PAGE_IO;
ra->seq_num_bits = cpu_to_le32(log->seq_num_bits);
ra->ra_len = cpu_to_le16(log->ra_size);
ra->client_off = cpu_to_le16(offsetof(struct RESTART_AREA, clients));
ra->l_size = cpu_to_le64(log->l_size);
ra->rec_hdr_len = cpu_to_le16(log->record_header_len);
ra->data_off = cpu_to_le16(log->data_off);
ra->open_log_count = cpu_to_le32(log->current_openlog_count + 1);
cr = ra->clients;
cr->prev_client = LFS_NO_CLIENT_LE;
cr->next_client = LFS_NO_CLIENT_LE;
return ra;
}
static u32 final_log_off(struct ntfs_log *log, u64 lsn, u32 data_len)
{
u32 base_vbo = lsn << 3;
u32 final_log_off = (base_vbo & log->seq_num_mask) & ~log->page_mask;
u32 page_off = base_vbo & log->page_mask;
u32 tail = log->page_size - page_off;
page_off -= 1;
/* Add the length of the header. */
data_len += log->record_header_len;
/*
* If this lsn is contained this log page we are done.
* Otherwise we need to walk through several log pages.
*/
if (data_len > tail) {
data_len -= tail;
tail = log->data_size;
page_off = log->data_off - 1;
for (;;) {
final_log_off = next_page_off(log, final_log_off);
/*
* We are done if the remaining bytes
* fit on this page.
*/
if (data_len <= tail)
break;
data_len -= tail;
}
}
/*
* We add the remaining bytes to our starting position on this page
* and then add that value to the file offset of this log page.
*/
return final_log_off + data_len + page_off;
}
static int next_log_lsn(struct ntfs_log *log, const struct LFS_RECORD_HDR *rh,
u64 *lsn)
{
int err;
u64 this_lsn = le64_to_cpu(rh->this_lsn);
u32 vbo = lsn_to_vbo(log, this_lsn);
u32 end =
final_log_off(log, this_lsn, le32_to_cpu(rh->client_data_len));
u32 hdr_off = end & ~log->sys_page_mask;
u64 seq = this_lsn >> log->file_data_bits;
struct RECORD_PAGE_HDR *page = NULL;
/* Remember if we wrapped. */
if (end <= vbo)
seq += 1;
/* Log page header for this page. */
err = read_log_page(log, hdr_off, &page, NULL);
if (err)
return err;
/*
* If the lsn we were given was not the last lsn on this page,
* then the starting offset for the next lsn is on a quad word
* boundary following the last file offset for the current lsn.
* Otherwise the file offset is the start of the data on the next page.
*/
if (this_lsn == le64_to_cpu(page->rhdr.lsn)) {
/* If we wrapped, we need to increment the sequence number. */
hdr_off = next_page_off(log, hdr_off);
if (hdr_off == log->first_page)
seq += 1;
vbo = hdr_off + log->data_off;
} else {
vbo = ALIGN(end, 8);
}
/* Compute the lsn based on the file offset and the sequence count. */
*lsn = vbo_to_lsn(log, vbo, seq);
/*
* If this lsn is within the legal range for the file, we return true.
* Otherwise false indicates that there are no more lsn's.
*/
if (!is_lsn_in_file(log, *lsn))
*lsn = 0;
kfree(page);
return 0;
}
/*
* current_log_avail - Calculate the number of bytes available for log records.
*/
static u32 current_log_avail(struct ntfs_log *log)
{
u32 oldest_off, next_free_off, free_bytes;
if (log->l_flags & NTFSLOG_NO_LAST_LSN) {
/* The entire file is available. */
return log->max_current_avail;
}
/*
* If there is a last lsn the restart area then we know that we will
* have to compute the free range.
* If there is no oldest lsn then start at the first page of the file.
*/
oldest_off = (log->l_flags & NTFSLOG_NO_OLDEST_LSN)
? log->first_page
: (log->oldest_lsn_off & ~log->sys_page_mask);
/*
* We will use the next log page offset to compute the next free page.
* If we are going to reuse this page go to the next page.
* If we are at the first page then use the end of the file.
*/
next_free_off = (log->l_flags & NTFSLOG_REUSE_TAIL)
? log->next_page + log->page_size
: log->next_page == log->first_page
? log->l_size
: log->next_page;
/* If the two offsets are the same then there is no available space. */
if (oldest_off == next_free_off)
return 0;
/*
* If the free offset follows the oldest offset then subtract
* this range from the total available pages.
*/
free_bytes =
oldest_off < next_free_off
? log->total_avail_pages - (next_free_off - oldest_off)
: oldest_off - next_free_off;
free_bytes >>= log->page_bits;
return free_bytes * log->reserved;
}
static bool check_subseq_log_page(struct ntfs_log *log,
const struct RECORD_PAGE_HDR *rp, u32 vbo,
u64 seq)
{
u64 lsn_seq;
const struct NTFS_RECORD_HEADER *rhdr = &rp->rhdr;
u64 lsn = le64_to_cpu(rhdr->lsn);
if (rhdr->sign == NTFS_FFFF_SIGNATURE || !rhdr->sign)
return false;
/*
* If the last lsn on the page occurs was written after the page
* that caused the original error then we have a fatal error.
*/
lsn_seq = lsn >> log->file_data_bits;
/*
* If the sequence number for the lsn the page is equal or greater
* than lsn we expect, then this is a subsequent write.
*/
return lsn_seq >= seq ||
(lsn_seq == seq - 1 && log->first_page == vbo &&
vbo != (lsn_to_vbo(log, lsn) & ~log->page_mask));
}
/*
* last_log_lsn
*
* Walks through the log pages for a file, searching for the
* last log page written to the file.
*/
static int last_log_lsn(struct ntfs_log *log)
{
int err;
bool usa_error = false;
bool replace_page = false;
bool reuse_page = log->l_flags & NTFSLOG_REUSE_TAIL;
bool wrapped_file, wrapped;
u32 page_cnt = 1, page_pos = 1;
u32 page_off = 0, page_off1 = 0, saved_off = 0;
u32 final_off, second_off, final_off_prev = 0, second_off_prev = 0;
u32 first_file_off = 0, second_file_off = 0;
u32 part_io_count = 0;
u32 tails = 0;
u32 this_off, curpage_off, nextpage_off, remain_pages;
u64 expected_seq, seq_base = 0, lsn_base = 0;
u64 best_lsn, best_lsn1, best_lsn2;
u64 lsn_cur, lsn1, lsn2;
u64 last_ok_lsn = reuse_page ? log->last_lsn : 0;
u16 cur_pos, best_page_pos;
struct RECORD_PAGE_HDR *page = NULL;
struct RECORD_PAGE_HDR *tst_page = NULL;
struct RECORD_PAGE_HDR *first_tail = NULL;
struct RECORD_PAGE_HDR *second_tail = NULL;
struct RECORD_PAGE_HDR *tail_page = NULL;
struct RECORD_PAGE_HDR *second_tail_prev = NULL;
struct RECORD_PAGE_HDR *first_tail_prev = NULL;
struct RECORD_PAGE_HDR *page_bufs = NULL;
struct RECORD_PAGE_HDR *best_page;
if (log->major_ver >= 2) {
final_off = 0x02 * log->page_size;
second_off = 0x12 * log->page_size;
// 0x10 == 0x12 - 0x2
page_bufs = kmalloc(log->page_size * 0x10, GFP_NOFS);
if (!page_bufs)
return -ENOMEM;
} else {
second_off = log->first_page - log->page_size;
final_off = second_off - log->page_size;
}
next_tail:
/* Read second tail page (at pos 3/0x12000). */
if (read_log_page(log, second_off, &second_tail, &usa_error) ||
usa_error || second_tail->rhdr.sign != NTFS_RCRD_SIGNATURE) {
kfree(second_tail);
second_tail = NULL;
second_file_off = 0;
lsn2 = 0;
} else {
second_file_off = hdr_file_off(log, second_tail);
lsn2 = le64_to_cpu(second_tail->record_hdr.last_end_lsn);
}
/* Read first tail page (at pos 2/0x2000). */
if (read_log_page(log, final_off, &first_tail, &usa_error) ||
usa_error || first_tail->rhdr.sign != NTFS_RCRD_SIGNATURE) {
kfree(first_tail);
first_tail = NULL;
first_file_off = 0;
lsn1 = 0;
} else {
first_file_off = hdr_file_off(log, first_tail);
lsn1 = le64_to_cpu(first_tail->record_hdr.last_end_lsn);
}
if (log->major_ver < 2) {
int best_page;
first_tail_prev = first_tail;
final_off_prev = first_file_off;
second_tail_prev = second_tail;
second_off_prev = second_file_off;
tails = 1;
if (!first_tail && !second_tail)
goto tail_read;
if (first_tail && second_tail)
best_page = lsn1 < lsn2 ? 1 : 0;
else if (first_tail)
best_page = 0;
else
best_page = 1;
page_off = best_page ? second_file_off : first_file_off;
seq_base = (best_page ? lsn2 : lsn1) >> log->file_data_bits;
goto tail_read;
}
best_lsn1 = first_tail ? base_lsn(log, first_tail, first_file_off) : 0;
best_lsn2 =
second_tail ? base_lsn(log, second_tail, second_file_off) : 0;
if (first_tail && second_tail) {
if (best_lsn1 > best_lsn2) {
best_lsn = best_lsn1;
best_page = first_tail;
this_off = first_file_off;
} else {
best_lsn = best_lsn2;
best_page = second_tail;
this_off = second_file_off;
}
} else if (first_tail) {
best_lsn = best_lsn1;
best_page = first_tail;
this_off = first_file_off;
} else if (second_tail) {
best_lsn = best_lsn2;
best_page = second_tail;
this_off = second_file_off;
} else {
goto tail_read;
}
best_page_pos = le16_to_cpu(best_page->page_pos);
if (!tails) {
if (best_page_pos == page_pos) {
seq_base = best_lsn >> log->file_data_bits;
saved_off = page_off = le32_to_cpu(best_page->file_off);
lsn_base = best_lsn;
memmove(page_bufs, best_page, log->page_size);
page_cnt = le16_to_cpu(best_page->page_count);
if (page_cnt > 1)
page_pos += 1;
tails = 1;
}
} else if (seq_base == (best_lsn >> log->file_data_bits) &&
saved_off + log->page_size == this_off &&
lsn_base < best_lsn &&
(page_pos != page_cnt || best_page_pos == page_pos ||
best_page_pos == 1) &&
(page_pos >= page_cnt || best_page_pos == page_pos)) {
u16 bppc = le16_to_cpu(best_page->page_count);
saved_off += log->page_size;
lsn_base = best_lsn;
memmove(Add2Ptr(page_bufs, tails * log->page_size), best_page,
log->page_size);
tails += 1;
if (best_page_pos != bppc) {
page_cnt = bppc;
page_pos = best_page_pos;
if (page_cnt > 1)
page_pos += 1;
} else {
page_pos = page_cnt = 1;
}
} else {
kfree(first_tail);
kfree(second_tail);
goto tail_read;
}
kfree(first_tail_prev);
first_tail_prev = first_tail;
final_off_prev = first_file_off;
first_tail = NULL;
kfree(second_tail_prev);
second_tail_prev = second_tail;
second_off_prev = second_file_off;
second_tail = NULL;
final_off += log->page_size;
second_off += log->page_size;
if (tails < 0x10)
goto next_tail;
tail_read:
first_tail = first_tail_prev;
final_off = final_off_prev;
second_tail = second_tail_prev;
second_off = second_off_prev;
page_cnt = page_pos = 1;
curpage_off = seq_base == log->seq_num ? min(log->next_page, page_off)
: log->next_page;
wrapped_file =
curpage_off == log->first_page &&
!(log->l_flags & (NTFSLOG_NO_LAST_LSN | NTFSLOG_REUSE_TAIL));
expected_seq = wrapped_file ? (log->seq_num + 1) : log->seq_num;
nextpage_off = curpage_off;
next_page:
tail_page = NULL;
/* Read the next log page. */
err = read_log_page(log, curpage_off, &page, &usa_error);
/* Compute the next log page offset the file. */
nextpage_off = next_page_off(log, curpage_off);
wrapped = nextpage_off == log->first_page;
if (tails > 1) {
struct RECORD_PAGE_HDR *cur_page =
Add2Ptr(page_bufs, curpage_off - page_off);
if (curpage_off == saved_off) {
tail_page = cur_page;
goto use_tail_page;
}
if (page_off > curpage_off || curpage_off >= saved_off)
goto use_tail_page;
if (page_off1)
goto use_cur_page;
if (!err && !usa_error &&
page->rhdr.sign == NTFS_RCRD_SIGNATURE &&
cur_page->rhdr.lsn == page->rhdr.lsn &&
cur_page->record_hdr.next_record_off ==
page->record_hdr.next_record_off &&
((page_pos == page_cnt &&
le16_to_cpu(page->page_pos) == 1) ||
(page_pos != page_cnt &&
le16_to_cpu(page->page_pos) == page_pos + 1 &&
le16_to_cpu(page->page_count) == page_cnt))) {
cur_page = NULL;
goto use_tail_page;
}
page_off1 = page_off;
use_cur_page:
lsn_cur = le64_to_cpu(cur_page->rhdr.lsn);
if (last_ok_lsn !=
le64_to_cpu(cur_page->record_hdr.last_end_lsn) &&
((lsn_cur >> log->file_data_bits) +
((curpage_off <
(lsn_to_vbo(log, lsn_cur) & ~log->page_mask))
? 1
: 0)) != expected_seq) {
goto check_tail;
}
if (!is_log_record_end(cur_page)) {
tail_page = NULL;
last_ok_lsn = lsn_cur;
goto next_page_1;
}
log->seq_num = expected_seq;
log->l_flags &= ~NTFSLOG_NO_LAST_LSN;
log->last_lsn = le64_to_cpu(cur_page->record_hdr.last_end_lsn);
log->ra->current_lsn = cur_page->record_hdr.last_end_lsn;
if (log->record_header_len <=
log->page_size -
le16_to_cpu(cur_page->record_hdr.next_record_off)) {
log->l_flags |= NTFSLOG_REUSE_TAIL;
log->next_page = curpage_off;
} else {
log->l_flags &= ~NTFSLOG_REUSE_TAIL;
log->next_page = nextpage_off;
}
if (wrapped_file)
log->l_flags |= NTFSLOG_WRAPPED;
last_ok_lsn = le64_to_cpu(cur_page->record_hdr.last_end_lsn);
goto next_page_1;
}
/*
* If we are at the expected first page of a transfer check to see
* if either tail copy is at this offset.
* If this page is the last page of a transfer, check if we wrote
* a subsequent tail copy.
*/
if (page_cnt == page_pos || page_cnt == page_pos + 1) {
/*
* Check if the offset matches either the first or second
* tail copy. It is possible it will match both.
*/
if (curpage_off == final_off)
tail_page = first_tail;
/*
* If we already matched on the first page then
* check the ending lsn's.
*/
if (curpage_off == second_off) {
if (!tail_page ||
(second_tail &&
le64_to_cpu(second_tail->record_hdr.last_end_lsn) >
le64_to_cpu(first_tail->record_hdr
.last_end_lsn))) {
tail_page = second_tail;
}
}
}
use_tail_page:
if (tail_page) {
/* We have a candidate for a tail copy. */
lsn_cur = le64_to_cpu(tail_page->record_hdr.last_end_lsn);
if (last_ok_lsn < lsn_cur) {
/*
* If the sequence number is not expected,
* then don't use the tail copy.
*/
if (expected_seq != (lsn_cur >> log->file_data_bits))
tail_page = NULL;
} else if (last_ok_lsn > lsn_cur) {
/*
* If the last lsn is greater than the one on
* this page then forget this tail.
*/
tail_page = NULL;
}
}
/*
*If we have an error on the current page,
* we will break of this loop.
*/
if (err || usa_error)
goto check_tail;
/*
* Done if the last lsn on this page doesn't match the previous known
* last lsn or the sequence number is not expected.
*/
lsn_cur = le64_to_cpu(page->rhdr.lsn);
if (last_ok_lsn != lsn_cur &&
expected_seq != (lsn_cur >> log->file_data_bits)) {
goto check_tail;
}
/*
* Check that the page position and page count values are correct.
* If this is the first page of a transfer the position must be 1
* and the count will be unknown.
*/
if (page_cnt == page_pos) {
if (page->page_pos != cpu_to_le16(1) &&
(!reuse_page || page->page_pos != page->page_count)) {
/*
* If the current page is the first page we are
* looking at and we are reusing this page then
* it can be either the first or last page of a
* transfer. Otherwise it can only be the first.
*/
goto check_tail;
}
} else if (le16_to_cpu(page->page_count) != page_cnt ||
le16_to_cpu(page->page_pos) != page_pos + 1) {
/*
* The page position better be 1 more than the last page
* position and the page count better match.
*/
goto check_tail;
}
/*
* We have a valid page the file and may have a valid page
* the tail copy area.
* If the tail page was written after the page the file then
* break of the loop.
*/
if (tail_page &&
le64_to_cpu(tail_page->record_hdr.last_end_lsn) > lsn_cur) {
/* Remember if we will replace the page. */
replace_page = true;
goto check_tail;
}
tail_page = NULL;
if (is_log_record_end(page)) {
/*
* Since we have read this page we know the sequence number
* is the same as our expected value.
*/
log->seq_num = expected_seq;
log->last_lsn = le64_to_cpu(page->record_hdr.last_end_lsn);
log->ra->current_lsn = page->record_hdr.last_end_lsn;
log->l_flags &= ~NTFSLOG_NO_LAST_LSN;
/*
* If there is room on this page for another header then
* remember we want to reuse the page.
*/
if (log->record_header_len <=
log->page_size -
le16_to_cpu(page->record_hdr.next_record_off)) {
log->l_flags |= NTFSLOG_REUSE_TAIL;
log->next_page = curpage_off;
} else {
log->l_flags &= ~NTFSLOG_REUSE_TAIL;
log->next_page = nextpage_off;
}
/* Remember if we wrapped the log file. */
if (wrapped_file)
log->l_flags |= NTFSLOG_WRAPPED;
}
/*
* Remember the last page count and position.
* Also remember the last known lsn.
*/
page_cnt = le16_to_cpu(page->page_count);
page_pos = le16_to_cpu(page->page_pos);
last_ok_lsn = le64_to_cpu(page->rhdr.lsn);
next_page_1:
if (wrapped) {
expected_seq += 1;
wrapped_file = 1;
}
curpage_off = nextpage_off;
kfree(page);
page = NULL;
reuse_page = 0;
goto next_page;
check_tail:
if (tail_page) {
log->seq_num = expected_seq;
log->last_lsn = le64_to_cpu(tail_page->record_hdr.last_end_lsn);
log->ra->current_lsn = tail_page->record_hdr.last_end_lsn;
log->l_flags &= ~NTFSLOG_NO_LAST_LSN;
if (log->page_size -
le16_to_cpu(
tail_page->record_hdr.next_record_off) >=
log->record_header_len) {
log->l_flags |= NTFSLOG_REUSE_TAIL;
log->next_page = curpage_off;
} else {
log->l_flags &= ~NTFSLOG_REUSE_TAIL;
log->next_page = nextpage_off;
}
if (wrapped)
log->l_flags |= NTFSLOG_WRAPPED;
}
/* Remember that the partial IO will start at the next page. */
second_off = nextpage_off;
/*
* If the next page is the first page of the file then update
* the sequence number for log records which begon the next page.
*/
if (wrapped)
expected_seq += 1;
/*
* If we have a tail copy or are performing single page I/O we can
* immediately look at the next page.
*/
if (replace_page || (log->ra->flags & RESTART_SINGLE_PAGE_IO)) {
page_cnt = 2;
page_pos = 1;
goto check_valid;
}
if (page_pos != page_cnt)
goto check_valid;
/*
* If the next page causes us to wrap to the beginning of the log
* file then we know which page to check next.
*/
if (wrapped) {
page_cnt = 2;
page_pos = 1;
goto check_valid;
}
cur_pos = 2;
next_test_page:
kfree(tst_page);
tst_page = NULL;
/* Walk through the file, reading log pages. */
err = read_log_page(log, nextpage_off, &tst_page, &usa_error);
/*
* If we get a USA error then assume that we correctly found
* the end of the original transfer.
*/
if (usa_error)
goto file_is_valid;
/*
* If we were able to read the page, we examine it to see if it
* is the same or different Io block.
*/
if (err)
goto next_test_page_1;
if (le16_to_cpu(tst_page->page_pos) == cur_pos &&
check_subseq_log_page(log, tst_page, nextpage_off, expected_seq)) {
page_cnt = le16_to_cpu(tst_page->page_count) + 1;
page_pos = le16_to_cpu(tst_page->page_pos);
goto check_valid;
} else {
goto file_is_valid;
}
next_test_page_1:
nextpage_off = next_page_off(log, curpage_off);
wrapped = nextpage_off == log->first_page;
if (wrapped) {
expected_seq += 1;
page_cnt = 2;
page_pos = 1;
}
cur_pos += 1;
part_io_count += 1;
if (!wrapped)
goto next_test_page;
check_valid:
/* Skip over the remaining pages this transfer. */
remain_pages = page_cnt - page_pos - 1;
part_io_count += remain_pages;
while (remain_pages--) {
nextpage_off = next_page_off(log, curpage_off);
wrapped = nextpage_off == log->first_page;
if (wrapped)
expected_seq += 1;
}
/* Call our routine to check this log page. */
kfree(tst_page);
tst_page = NULL;
err = read_log_page(log, nextpage_off, &tst_page, &usa_error);
if (!err && !usa_error &&
check_subseq_log_page(log, tst_page, nextpage_off, expected_seq)) {
err = -EINVAL;
goto out;
}
file_is_valid:
/* We have a valid file. */
if (page_off1 || tail_page) {
struct RECORD_PAGE_HDR *tmp_page;
if (sb_rdonly(log->ni->mi.sbi->sb)) {
err = -EROFS;
goto out;
}
if (page_off1) {
tmp_page = Add2Ptr(page_bufs, page_off1 - page_off);
tails -= (page_off1 - page_off) / log->page_size;
if (!tail_page)
tails -= 1;
} else {
tmp_page = tail_page;
tails = 1;
}
while (tails--) {
u64 off = hdr_file_off(log, tmp_page);
if (!page) {
page = kmalloc(log->page_size, GFP_NOFS);
if (!page)
return -ENOMEM;
}
/*
* Correct page and copy the data from this page
* into it and flush it to disk.
*/
memcpy(page, tmp_page, log->page_size);
/* Fill last flushed lsn value flush the page. */
if (log->major_ver < 2)
page->rhdr.lsn = page->record_hdr.last_end_lsn;
else
page->file_off = 0;
page->page_pos = page->page_count = cpu_to_le16(1);
ntfs_fix_pre_write(&page->rhdr, log->page_size);
err = ntfs_sb_write_run(log->ni->mi.sbi,
&log->ni->file.run, off, page,
log->page_size, 0);
if (err)
goto out;
if (part_io_count && second_off == off) {
second_off += log->page_size;
part_io_count -= 1;
}
tmp_page = Add2Ptr(tmp_page, log->page_size);
}
}
if (part_io_count) {
if (sb_rdonly(log->ni->mi.sbi->sb)) {
err = -EROFS;
goto out;
}
}
out:
kfree(second_tail);
kfree(first_tail);
kfree(page);
kfree(tst_page);
kfree(page_bufs);
return err;
}
/*
* read_log_rec_buf - Copy a log record from the file to a buffer.
*
* The log record may span several log pages and may even wrap the file.
*/
static int read_log_rec_buf(struct ntfs_log *log,
const struct LFS_RECORD_HDR *rh, void *buffer)
{
int err;
struct RECORD_PAGE_HDR *ph = NULL;
u64 lsn = le64_to_cpu(rh->this_lsn);
u32 vbo = lsn_to_vbo(log, lsn) & ~log->page_mask;
u32 off = lsn_to_page_off(log, lsn) + log->record_header_len;
u32 data_len = le32_to_cpu(rh->client_data_len);
/*
* While there are more bytes to transfer,
* we continue to attempt to perform the read.
*/
for (;;) {
bool usa_error;
u32 tail = log->page_size - off;
if (tail >= data_len)
tail = data_len;
data_len -= tail;
err = read_log_page(log, vbo, &ph, &usa_error);
if (err)
goto out;
/*
* The last lsn on this page better be greater or equal
* to the lsn we are copying.
*/
if (lsn > le64_to_cpu(ph->rhdr.lsn)) {
err = -EINVAL;
goto out;
}
memcpy(buffer, Add2Ptr(ph, off), tail);
/* If there are no more bytes to transfer, we exit the loop. */
if (!data_len) {
if (!is_log_record_end(ph) ||
lsn > le64_to_cpu(ph->record_hdr.last_end_lsn)) {
err = -EINVAL;
goto out;
}
break;
}
if (ph->rhdr.lsn == ph->record_hdr.last_end_lsn ||
lsn > le64_to_cpu(ph->rhdr.lsn)) {
err = -EINVAL;
goto out;
}
vbo = next_page_off(log, vbo);
off = log->data_off;
/*
* Adjust our pointer the user's buffer to transfer
* the next block to.
*/
buffer = Add2Ptr(buffer, tail);
}
out:
kfree(ph);
return err;
}
static int read_rst_area(struct ntfs_log *log, struct NTFS_RESTART **rst_,
u64 *lsn)
{
int err;
struct LFS_RECORD_HDR *rh = NULL;
const struct CLIENT_REC *cr =
Add2Ptr(log->ra, le16_to_cpu(log->ra->client_off));
u64 lsnr, lsnc = le64_to_cpu(cr->restart_lsn);
u32 len;
struct NTFS_RESTART *rst;
*lsn = 0;
*rst_ = NULL;
/* If the client doesn't have a restart area, go ahead and exit now. */
if (!lsnc)
return 0;
err = read_log_page(log, lsn_to_vbo(log, lsnc),
(struct RECORD_PAGE_HDR **)&rh, NULL);
if (err)
return err;
rst = NULL;
lsnr = le64_to_cpu(rh->this_lsn);
if (lsnc != lsnr) {
/* If the lsn values don't match, then the disk is corrupt. */
err = -EINVAL;
goto out;
}
*lsn = lsnr;
len = le32_to_cpu(rh->client_data_len);
if (!len) {
err = 0;
goto out;
}
if (len < sizeof(struct NTFS_RESTART)) {
err = -EINVAL;
goto out;
}
rst = kmalloc(len, GFP_NOFS);
if (!rst) {
err = -ENOMEM;
goto out;
}
/* Copy the data into the 'rst' buffer. */
err = read_log_rec_buf(log, rh, rst);
if (err)
goto out;
*rst_ = rst;
rst = NULL;
out:
kfree(rh);
kfree(rst);
return err;
}
static int find_log_rec(struct ntfs_log *log, u64 lsn, struct lcb *lcb)
{
int err;
struct LFS_RECORD_HDR *rh = lcb->lrh;
u32 rec_len, len;
/* Read the record header for this lsn. */
if (!rh) {
err = read_log_page(log, lsn_to_vbo(log, lsn),
(struct RECORD_PAGE_HDR **)&rh, NULL);
lcb->lrh = rh;
if (err)
return err;
}
/*
* If the lsn the log record doesn't match the desired
* lsn then the disk is corrupt.
*/
if (lsn != le64_to_cpu(rh->this_lsn))
return -EINVAL;
len = le32_to_cpu(rh->client_data_len);
/*
* Check that the length field isn't greater than the total
* available space the log file.
*/
rec_len = len + log->record_header_len;
if (rec_len >= log->total_avail)
return -EINVAL;
/*
* If the entire log record is on this log page,
* put a pointer to the log record the context block.
*/
if (rh->flags & LOG_RECORD_MULTI_PAGE) {
void *lr = kmalloc(len, GFP_NOFS);
if (!lr)
return -ENOMEM;
lcb->log_rec = lr;
lcb->alloc = true;
/* Copy the data into the buffer returned. */
err = read_log_rec_buf(log, rh, lr);
if (err)
return err;
} else {
/* If beyond the end of the current page -> an error. */
u32 page_off = lsn_to_page_off(log, lsn);
if (page_off + len + log->record_header_len > log->page_size)
return -EINVAL;
lcb->log_rec = Add2Ptr(rh, sizeof(struct LFS_RECORD_HDR));
lcb->alloc = false;
}
return 0;
}
/*
* read_log_rec_lcb - Init the query operation.
*/
static int read_log_rec_lcb(struct ntfs_log *log, u64 lsn, u32 ctx_mode,
struct lcb **lcb_)
{
int err;
const struct CLIENT_REC *cr;
struct lcb *lcb;
switch (ctx_mode) {
case lcb_ctx_undo_next:
case lcb_ctx_prev:
case lcb_ctx_next:
break;
default:
return -EINVAL;
}
/* Check that the given lsn is the legal range for this client. */
cr = Add2Ptr(log->ra, le16_to_cpu(log->ra->client_off));
if (!verify_client_lsn(log, cr, lsn))
return -EINVAL;
lcb = kzalloc(sizeof(struct lcb), GFP_NOFS);
if (!lcb)
return -ENOMEM;
lcb->client = log->client_id;
lcb->ctx_mode = ctx_mode;
/* Find the log record indicated by the given lsn. */
err = find_log_rec(log, lsn, lcb);
if (err)
goto out;
*lcb_ = lcb;
return 0;
out:
lcb_put(lcb);
*lcb_ = NULL;
return err;
}
/*
* find_client_next_lsn
*
* Attempt to find the next lsn to return to a client based on the context mode.
*/
static int find_client_next_lsn(struct ntfs_log *log, struct lcb *lcb, u64 *lsn)
{
int err;
u64 next_lsn;
struct LFS_RECORD_HDR *hdr;
hdr = lcb->lrh;
*lsn = 0;
if (lcb_ctx_next != lcb->ctx_mode)
goto check_undo_next;
/* Loop as long as another lsn can be found. */
for (;;) {
u64 current_lsn;
err = next_log_lsn(log, hdr, &current_lsn);
if (err)
goto out;
if (!current_lsn)
break;
if (hdr != lcb->lrh)
kfree(hdr);
hdr = NULL;
err = read_log_page(log, lsn_to_vbo(log, current_lsn),
(struct RECORD_PAGE_HDR **)&hdr, NULL);
if (err)
goto out;
if (memcmp(&hdr->client, &lcb->client,
sizeof(struct CLIENT_ID))) {
/*err = -EINVAL; */
} else if (LfsClientRecord == hdr->record_type) {
kfree(lcb->lrh);
lcb->lrh = hdr;
*lsn = current_lsn;
return 0;
}
}
out:
if (hdr != lcb->lrh)
kfree(hdr);
return err;
check_undo_next:
if (lcb_ctx_undo_next == lcb->ctx_mode)
next_lsn = le64_to_cpu(hdr->client_undo_next_lsn);
else if (lcb_ctx_prev == lcb->ctx_mode)
next_lsn = le64_to_cpu(hdr->client_prev_lsn);
else
return 0;
if (!next_lsn)
return 0;
if (!verify_client_lsn(
log, Add2Ptr(log->ra, le16_to_cpu(log->ra->client_off)),
next_lsn))
return 0;
hdr = NULL;
err = read_log_page(log, lsn_to_vbo(log, next_lsn),
(struct RECORD_PAGE_HDR **)&hdr, NULL);
if (err)
return err;
kfree(lcb->lrh);
lcb->lrh = hdr;
*lsn = next_lsn;
return 0;
}
static int read_next_log_rec(struct ntfs_log *log, struct lcb *lcb, u64 *lsn)
{
int err;
err = find_client_next_lsn(log, lcb, lsn);
if (err)
return err;
if (!*lsn)
return 0;
if (lcb->alloc)
kfree(lcb->log_rec);
lcb->log_rec = NULL;
lcb->alloc = false;
kfree(lcb->lrh);
lcb->lrh = NULL;
return find_log_rec(log, *lsn, lcb);
}
static inline bool check_index_header(const struct INDEX_HDR *hdr, size_t bytes)
{
__le16 mask;
u32 min_de, de_off, used, total;
const struct NTFS_DE *e;
if (hdr_has_subnode(hdr)) {
min_de = sizeof(struct NTFS_DE) + sizeof(u64);
mask = NTFS_IE_HAS_SUBNODES;
} else {
min_de = sizeof(struct NTFS_DE);
mask = 0;
}
de_off = le32_to_cpu(hdr->de_off);
used = le32_to_cpu(hdr->used);
total = le32_to_cpu(hdr->total);
if (de_off > bytes - min_de || used > bytes || total > bytes ||
de_off + min_de > used || used > total) {
return false;
}
e = Add2Ptr(hdr, de_off);
for (;;) {
u16 esize = le16_to_cpu(e->size);
struct NTFS_DE *next = Add2Ptr(e, esize);
if (esize < min_de || PtrOffset(hdr, next) > used ||
(e->flags & NTFS_IE_HAS_SUBNODES) != mask) {
return false;
}
if (de_is_last(e))
break;
e = next;
}
return true;
}
static inline bool check_index_buffer(const struct INDEX_BUFFER *ib, u32 bytes)
{
u16 fo;
const struct NTFS_RECORD_HEADER *r = &ib->rhdr;
if (r->sign != NTFS_INDX_SIGNATURE)
return false;
fo = (SECTOR_SIZE - ((bytes >> SECTOR_SHIFT) + 1) * sizeof(short));
if (le16_to_cpu(r->fix_off) > fo)
return false;
if ((le16_to_cpu(r->fix_num) - 1) * SECTOR_SIZE != bytes)
return false;
return check_index_header(&ib->ihdr,
bytes - offsetof(struct INDEX_BUFFER, ihdr));
}
static inline bool check_index_root(const struct ATTRIB *attr,
struct ntfs_sb_info *sbi)
{
bool ret;
const struct INDEX_ROOT *root = resident_data(attr);
u8 index_bits = le32_to_cpu(root->index_block_size) >= sbi->cluster_size
? sbi->cluster_bits
: SECTOR_SHIFT;
u8 block_clst = root->index_block_clst;
if (le32_to_cpu(attr->res.data_size) < sizeof(struct INDEX_ROOT) ||
(root->type != ATTR_NAME && root->type != ATTR_ZERO) ||
(root->type == ATTR_NAME &&
root->rule != NTFS_COLLATION_TYPE_FILENAME) ||
(le32_to_cpu(root->index_block_size) !=
(block_clst << index_bits)) ||
(block_clst != 1 && block_clst != 2 && block_clst != 4 &&
block_clst != 8 && block_clst != 0x10 && block_clst != 0x20 &&
block_clst != 0x40 && block_clst != 0x80)) {
return false;
}
ret = check_index_header(&root->ihdr,
le32_to_cpu(attr->res.data_size) -
offsetof(struct INDEX_ROOT, ihdr));
return ret;
}
static inline bool check_attr(const struct MFT_REC *rec,
const struct ATTRIB *attr,
struct ntfs_sb_info *sbi)
{
u32 asize = le32_to_cpu(attr->size);
u32 rsize = 0;
u64 dsize, svcn, evcn;
u16 run_off;
/* Check the fixed part of the attribute record header. */
if (asize >= sbi->record_size ||
asize + PtrOffset(rec, attr) >= sbi->record_size ||
(attr->name_len &&
le16_to_cpu(attr->name_off) + attr->name_len * sizeof(short) >
asize)) {
return false;
}
/* Check the attribute fields. */
switch (attr->non_res) {
case 0:
rsize = le32_to_cpu(attr->res.data_size);
if (rsize >= asize ||
le16_to_cpu(attr->res.data_off) + rsize > asize) {
return false;
}
break;
case 1:
dsize = le64_to_cpu(attr->nres.data_size);
svcn = le64_to_cpu(attr->nres.svcn);
evcn = le64_to_cpu(attr->nres.evcn);
run_off = le16_to_cpu(attr->nres.run_off);
if (svcn > evcn + 1 || run_off >= asize ||
le64_to_cpu(attr->nres.valid_size) > dsize ||
dsize > le64_to_cpu(attr->nres.alloc_size)) {
return false;
}
if (run_unpack(NULL, sbi, 0, svcn, evcn, svcn,
Add2Ptr(attr, run_off), asize - run_off) < 0) {
return false;
}
return true;
default:
return false;
}
switch (attr->type) {
case ATTR_NAME:
if (fname_full_size(Add2Ptr(
attr, le16_to_cpu(attr->res.data_off))) > asize) {
return false;
}
break;
case ATTR_ROOT:
return check_index_root(attr, sbi);
case ATTR_STD:
if (rsize < sizeof(struct ATTR_STD_INFO5) &&
rsize != sizeof(struct ATTR_STD_INFO)) {
return false;
}
break;
case ATTR_LIST:
case ATTR_ID:
case ATTR_SECURE:
case ATTR_LABEL:
case ATTR_VOL_INFO:
case ATTR_DATA:
case ATTR_ALLOC:
case ATTR_BITMAP:
case ATTR_REPARSE:
case ATTR_EA_INFO:
case ATTR_EA:
case ATTR_PROPERTYSET:
case ATTR_LOGGED_UTILITY_STREAM:
break;
default:
return false;
}
return true;
}
static inline bool check_file_record(const struct MFT_REC *rec,
const struct MFT_REC *rec2,
struct ntfs_sb_info *sbi)
{
const struct ATTRIB *attr;
u16 fo = le16_to_cpu(rec->rhdr.fix_off);
u16 fn = le16_to_cpu(rec->rhdr.fix_num);
u16 ao = le16_to_cpu(rec->attr_off);
u32 rs = sbi->record_size;
/* Check the file record header for consistency. */
if (rec->rhdr.sign != NTFS_FILE_SIGNATURE ||
fo > (SECTOR_SIZE - ((rs >> SECTOR_SHIFT) + 1) * sizeof(short)) ||
(fn - 1) * SECTOR_SIZE != rs || ao < MFTRECORD_FIXUP_OFFSET_1 ||
ao > sbi->record_size - SIZEOF_RESIDENT || !is_rec_inuse(rec) ||
le32_to_cpu(rec->total) != rs) {
return false;
}
/* Loop to check all of the attributes. */
for (attr = Add2Ptr(rec, ao); attr->type != ATTR_END;
attr = Add2Ptr(attr, le32_to_cpu(attr->size))) {
if (check_attr(rec, attr, sbi))
continue;
return false;
}
return true;
}
static inline int check_lsn(const struct NTFS_RECORD_HEADER *hdr,
const u64 *rlsn)
{
u64 lsn;
if (!rlsn)
return true;
lsn = le64_to_cpu(hdr->lsn);
if (hdr->sign == NTFS_HOLE_SIGNATURE)
return false;
if (*rlsn > lsn)
return true;
return false;
}
static inline bool check_if_attr(const struct MFT_REC *rec,
const struct LOG_REC_HDR *lrh)
{
u16 ro = le16_to_cpu(lrh->record_off);
u16 o = le16_to_cpu(rec->attr_off);
const struct ATTRIB *attr = Add2Ptr(rec, o);
while (o < ro) {
u32 asize;
if (attr->type == ATTR_END)
break;
asize = le32_to_cpu(attr->size);
if (!asize)
break;
o += asize;
attr = Add2Ptr(attr, asize);
}
return o == ro;
}
static inline bool check_if_index_root(const struct MFT_REC *rec,
const struct LOG_REC_HDR *lrh)
{
u16 ro = le16_to_cpu(lrh->record_off);
u16 o = le16_to_cpu(rec->attr_off);
const struct ATTRIB *attr = Add2Ptr(rec, o);
while (o < ro) {
u32 asize;
if (attr->type == ATTR_END)
break;
asize = le32_to_cpu(attr->size);
if (!asize)
break;
o += asize;
attr = Add2Ptr(attr, asize);
}
return o == ro && attr->type == ATTR_ROOT;
}
static inline bool check_if_root_index(const struct ATTRIB *attr,
const struct INDEX_HDR *hdr,
const struct LOG_REC_HDR *lrh)
{
u16 ao = le16_to_cpu(lrh->attr_off);
u32 de_off = le32_to_cpu(hdr->de_off);
u32 o = PtrOffset(attr, hdr) + de_off;
const struct NTFS_DE *e = Add2Ptr(hdr, de_off);
u32 asize = le32_to_cpu(attr->size);
while (o < ao) {
u16 esize;
if (o >= asize)
break;
esize = le16_to_cpu(e->size);
if (!esize)
break;
o += esize;
e = Add2Ptr(e, esize);
}
return o == ao;
}
static inline bool check_if_alloc_index(const struct INDEX_HDR *hdr,
u32 attr_off)
{
u32 de_off = le32_to_cpu(hdr->de_off);
u32 o = offsetof(struct INDEX_BUFFER, ihdr) + de_off;
const struct NTFS_DE *e = Add2Ptr(hdr, de_off);
u32 used = le32_to_cpu(hdr->used);
while (o < attr_off) {
u16 esize;
if (de_off >= used)
break;
esize = le16_to_cpu(e->size);
if (!esize)
break;
o += esize;
de_off += esize;
e = Add2Ptr(e, esize);
}
return o == attr_off;
}
static inline void change_attr_size(struct MFT_REC *rec, struct ATTRIB *attr,
u32 nsize)
{
u32 asize = le32_to_cpu(attr->size);
int dsize = nsize - asize;
u8 *next = Add2Ptr(attr, asize);
u32 used = le32_to_cpu(rec->used);
memmove(Add2Ptr(attr, nsize), next, used - PtrOffset(rec, next));
rec->used = cpu_to_le32(used + dsize);
attr->size = cpu_to_le32(nsize);
}
struct OpenAttr {
struct ATTRIB *attr;
struct runs_tree *run1;
struct runs_tree run0;
struct ntfs_inode *ni;
// CLST rno;
};
/*
* cmp_type_and_name
*
* Return: 0 if 'attr' has the same type and name.
*/
static inline int cmp_type_and_name(const struct ATTRIB *a1,
const struct ATTRIB *a2)
{
return a1->type != a2->type || a1->name_len != a2->name_len ||
(a1->name_len && memcmp(attr_name(a1), attr_name(a2),
a1->name_len * sizeof(short)));
}
static struct OpenAttr *find_loaded_attr(struct ntfs_log *log,
const struct ATTRIB *attr, CLST rno)
{
struct OPEN_ATTR_ENRTY *oe = NULL;
while ((oe = enum_rstbl(log->open_attr_tbl, oe))) {
struct OpenAttr *op_attr;
if (ino_get(&oe->ref) != rno)
continue;
op_attr = (struct OpenAttr *)oe->ptr;
if (!cmp_type_and_name(op_attr->attr, attr))
return op_attr;
}
return NULL;
}
static struct ATTRIB *attr_create_nonres_log(struct ntfs_sb_info *sbi,
enum ATTR_TYPE type, u64 size,
const u16 *name, size_t name_len,
__le16 flags)
{
struct ATTRIB *attr;
u32 name_size = ALIGN(name_len * sizeof(short), 8);
bool is_ext = flags & (ATTR_FLAG_COMPRESSED | ATTR_FLAG_SPARSED);
u32 asize = name_size +
(is_ext ? SIZEOF_NONRESIDENT_EX : SIZEOF_NONRESIDENT);
attr = kzalloc(asize, GFP_NOFS);
if (!attr)
return NULL;
attr->type = type;
attr->size = cpu_to_le32(asize);
attr->flags = flags;
attr->non_res = 1;
attr->name_len = name_len;
attr->nres.evcn = cpu_to_le64((u64)bytes_to_cluster(sbi, size) - 1);
attr->nres.alloc_size = cpu_to_le64(ntfs_up_cluster(sbi, size));
attr->nres.data_size = cpu_to_le64(size);
attr->nres.valid_size = attr->nres.data_size;
if (is_ext) {
attr->name_off = SIZEOF_NONRESIDENT_EX_LE;
if (is_attr_compressed(attr))
attr->nres.c_unit = COMPRESSION_UNIT;
attr->nres.run_off =
cpu_to_le16(SIZEOF_NONRESIDENT_EX + name_size);
memcpy(Add2Ptr(attr, SIZEOF_NONRESIDENT_EX), name,
name_len * sizeof(short));
} else {
attr->name_off = SIZEOF_NONRESIDENT_LE;
attr->nres.run_off =
cpu_to_le16(SIZEOF_NONRESIDENT + name_size);
memcpy(Add2Ptr(attr, SIZEOF_NONRESIDENT), name,
name_len * sizeof(short));
}
return attr;
}
/*
* do_action - Common routine for the Redo and Undo Passes.
* @rlsn: If it is NULL then undo.
*/
static int do_action(struct ntfs_log *log, struct OPEN_ATTR_ENRTY *oe,
const struct LOG_REC_HDR *lrh, u32 op, void *data,
u32 dlen, u32 rec_len, const u64 *rlsn)
{
int err = 0;
struct ntfs_sb_info *sbi = log->ni->mi.sbi;
struct inode *inode = NULL, *inode_parent;
struct mft_inode *mi = NULL, *mi2_child = NULL;
CLST rno = 0, rno_base = 0;
struct INDEX_BUFFER *ib = NULL;
struct MFT_REC *rec = NULL;
struct ATTRIB *attr = NULL, *attr2;
struct INDEX_HDR *hdr;
struct INDEX_ROOT *root;
struct NTFS_DE *e, *e1, *e2;
struct NEW_ATTRIBUTE_SIZES *new_sz;
struct ATTR_FILE_NAME *fname;
struct OpenAttr *oa, *oa2;
u32 nsize, t32, asize, used, esize, bmp_off, bmp_bits;
u16 id, id2;
u32 record_size = sbi->record_size;
u64 t64;
u16 roff = le16_to_cpu(lrh->record_off);
u16 aoff = le16_to_cpu(lrh->attr_off);
u64 lco = 0;
u64 cbo = (u64)le16_to_cpu(lrh->cluster_off) << SECTOR_SHIFT;
u64 tvo = le64_to_cpu(lrh->target_vcn) << sbi->cluster_bits;
u64 vbo = cbo + tvo;
void *buffer_le = NULL;
u32 bytes = 0;
bool a_dirty = false;
u16 data_off;
oa = oe->ptr;
/* Big switch to prepare. */
switch (op) {
/* ============================================================
* Process MFT records, as described by the current log record.
* ============================================================
*/
case InitializeFileRecordSegment:
case DeallocateFileRecordSegment:
case WriteEndOfFileRecordSegment:
case CreateAttribute:
case DeleteAttribute:
case UpdateResidentValue:
case UpdateMappingPairs:
case SetNewAttributeSizes:
case AddIndexEntryRoot:
case DeleteIndexEntryRoot:
case SetIndexEntryVcnRoot:
case UpdateFileNameRoot:
case UpdateRecordDataRoot:
case ZeroEndOfFileRecord:
rno = vbo >> sbi->record_bits;
inode = ilookup(sbi->sb, rno);
if (inode) {
mi = &ntfs_i(inode)->mi;
} else if (op == InitializeFileRecordSegment) {
mi = kzalloc(sizeof(struct mft_inode), GFP_NOFS);
if (!mi)
return -ENOMEM;
err = mi_format_new(mi, sbi, rno, 0, false);
if (err)
goto out;
} else {
/* Read from disk. */
err = mi_get(sbi, rno, &mi);
if (err)
return err;
}
rec = mi->mrec;
if (op == DeallocateFileRecordSegment)
goto skip_load_parent;
if (InitializeFileRecordSegment != op) {
if (rec->rhdr.sign == NTFS_BAAD_SIGNATURE)
goto dirty_vol;
if (!check_lsn(&rec->rhdr, rlsn))
goto out;
if (!check_file_record(rec, NULL, sbi))
goto dirty_vol;
attr = Add2Ptr(rec, roff);
}
if (is_rec_base(rec) || InitializeFileRecordSegment == op) {
rno_base = rno;
goto skip_load_parent;
}
rno_base = ino_get(&rec->parent_ref);
inode_parent = ntfs_iget5(sbi->sb, &rec->parent_ref, NULL);
if (IS_ERR(inode_parent))
goto skip_load_parent;
if (is_bad_inode(inode_parent)) {
iput(inode_parent);
goto skip_load_parent;
}
if (ni_load_mi_ex(ntfs_i(inode_parent), rno, &mi2_child)) {
iput(inode_parent);
} else {
if (mi2_child->mrec != mi->mrec)
memcpy(mi2_child->mrec, mi->mrec,
sbi->record_size);
if (inode)
iput(inode);
else if (mi)
mi_put(mi);
inode = inode_parent;
mi = mi2_child;
rec = mi2_child->mrec;
attr = Add2Ptr(rec, roff);
}
skip_load_parent:
inode_parent = NULL;
break;
/*
* Process attributes, as described by the current log record.
*/
case UpdateNonresidentValue:
case AddIndexEntryAllocation:
case DeleteIndexEntryAllocation:
case WriteEndOfIndexBuffer:
case SetIndexEntryVcnAllocation:
case UpdateFileNameAllocation:
case SetBitsInNonresidentBitMap:
case ClearBitsInNonresidentBitMap:
case UpdateRecordDataAllocation:
attr = oa->attr;
bytes = UpdateNonresidentValue == op ? dlen : 0;
lco = (u64)le16_to_cpu(lrh->lcns_follow) << sbi->cluster_bits;
if (attr->type == ATTR_ALLOC) {
t32 = le32_to_cpu(oe->bytes_per_index);
if (bytes < t32)
bytes = t32;
}
if (!bytes)
bytes = lco - cbo;
bytes += roff;
if (attr->type == ATTR_ALLOC)
bytes = (bytes + 511) & ~511; // align
buffer_le = kmalloc(bytes, GFP_NOFS);
if (!buffer_le)
return -ENOMEM;
err = ntfs_read_run_nb(sbi, oa->run1, vbo, buffer_le, bytes,
NULL);
if (err)
goto out;
if (attr->type == ATTR_ALLOC && *(int *)buffer_le)
ntfs_fix_post_read(buffer_le, bytes, false);
break;
default:
WARN_ON(1);
}
/* Big switch to do operation. */
switch (op) {
case InitializeFileRecordSegment:
if (roff + dlen > record_size)
goto dirty_vol;
memcpy(Add2Ptr(rec, roff), data, dlen);
mi->dirty = true;
break;
case DeallocateFileRecordSegment:
clear_rec_inuse(rec);
le16_add_cpu(&rec->seq, 1);
mi->dirty = true;
break;
case WriteEndOfFileRecordSegment:
attr2 = (struct ATTRIB *)data;
if (!check_if_attr(rec, lrh) || roff + dlen > record_size)
goto dirty_vol;
memmove(attr, attr2, dlen);
rec->used = cpu_to_le32(ALIGN(roff + dlen, 8));
mi->dirty = true;
break;
case CreateAttribute:
attr2 = (struct ATTRIB *)data;
asize = le32_to_cpu(attr2->size);
used = le32_to_cpu(rec->used);
if (!check_if_attr(rec, lrh) || dlen < SIZEOF_RESIDENT ||
!IS_ALIGNED(asize, 8) ||
Add2Ptr(attr2, asize) > Add2Ptr(lrh, rec_len) ||
dlen > record_size - used) {
goto dirty_vol;
}
memmove(Add2Ptr(attr, asize), attr, used - roff);
memcpy(attr, attr2, asize);
rec->used = cpu_to_le32(used + asize);
id = le16_to_cpu(rec->next_attr_id);
id2 = le16_to_cpu(attr2->id);
if (id <= id2)
rec->next_attr_id = cpu_to_le16(id2 + 1);
if (is_attr_indexed(attr))
le16_add_cpu(&rec->hard_links, 1);
oa2 = find_loaded_attr(log, attr, rno_base);
if (oa2) {
void *p2 = kmemdup(attr, le32_to_cpu(attr->size),
GFP_NOFS);
if (p2) {
// run_close(oa2->run1);
kfree(oa2->attr);
oa2->attr = p2;
}
}
mi->dirty = true;
break;
case DeleteAttribute:
asize = le32_to_cpu(attr->size);
used = le32_to_cpu(rec->used);
if (!check_if_attr(rec, lrh))
goto dirty_vol;
rec->used = cpu_to_le32(used - asize);
if (is_attr_indexed(attr))
le16_add_cpu(&rec->hard_links, -1);
memmove(attr, Add2Ptr(attr, asize), used - asize - roff);
mi->dirty = true;
break;
case UpdateResidentValue:
nsize = aoff + dlen;
if (!check_if_attr(rec, lrh))
goto dirty_vol;
asize = le32_to_cpu(attr->size);
used = le32_to_cpu(rec->used);
if (lrh->redo_len == lrh->undo_len) {
if (nsize > asize)
goto dirty_vol;
goto move_data;
}
if (nsize > asize && nsize - asize > record_size - used)
goto dirty_vol;
nsize = ALIGN(nsize, 8);
data_off = le16_to_cpu(attr->res.data_off);
if (nsize < asize) {
memmove(Add2Ptr(attr, aoff), data, dlen);
data = NULL; // To skip below memmove().
}
memmove(Add2Ptr(attr, nsize), Add2Ptr(attr, asize),
used - le16_to_cpu(lrh->record_off) - asize);
rec->used = cpu_to_le32(used + nsize - asize);
attr->size = cpu_to_le32(nsize);
attr->res.data_size = cpu_to_le32(aoff + dlen - data_off);
move_data:
if (data)
memmove(Add2Ptr(attr, aoff), data, dlen);
oa2 = find_loaded_attr(log, attr, rno_base);
if (oa2) {
void *p2 = kmemdup(attr, le32_to_cpu(attr->size),
GFP_NOFS);
if (p2) {
// run_close(&oa2->run0);
oa2->run1 = &oa2->run0;
kfree(oa2->attr);
oa2->attr = p2;
}
}
mi->dirty = true;
break;
case UpdateMappingPairs:
nsize = aoff + dlen;
asize = le32_to_cpu(attr->size);
used = le32_to_cpu(rec->used);
if (!check_if_attr(rec, lrh) || !attr->non_res ||
aoff < le16_to_cpu(attr->nres.run_off) || aoff > asize ||
(nsize > asize && nsize - asize > record_size - used)) {
goto dirty_vol;
}
nsize = ALIGN(nsize, 8);
memmove(Add2Ptr(attr, nsize), Add2Ptr(attr, asize),
used - le16_to_cpu(lrh->record_off) - asize);
rec->used = cpu_to_le32(used + nsize - asize);
attr->size = cpu_to_le32(nsize);
memmove(Add2Ptr(attr, aoff), data, dlen);
if (run_get_highest_vcn(le64_to_cpu(attr->nres.svcn),
attr_run(attr), &t64)) {
goto dirty_vol;
}
attr->nres.evcn = cpu_to_le64(t64);
oa2 = find_loaded_attr(log, attr, rno_base);
if (oa2 && oa2->attr->non_res)
oa2->attr->nres.evcn = attr->nres.evcn;
mi->dirty = true;
break;
case SetNewAttributeSizes:
new_sz = data;
if (!check_if_attr(rec, lrh) || !attr->non_res)
goto dirty_vol;
attr->nres.alloc_size = new_sz->alloc_size;
attr->nres.data_size = new_sz->data_size;
attr->nres.valid_size = new_sz->valid_size;
if (dlen >= sizeof(struct NEW_ATTRIBUTE_SIZES))
attr->nres.total_size = new_sz->total_size;
oa2 = find_loaded_attr(log, attr, rno_base);
if (oa2) {
void *p2 = kmemdup(attr, le32_to_cpu(attr->size),
GFP_NOFS);
if (p2) {
kfree(oa2->attr);
oa2->attr = p2;
}
}
mi->dirty = true;
break;
case AddIndexEntryRoot:
e = (struct NTFS_DE *)data;
esize = le16_to_cpu(e->size);
root = resident_data(attr);
hdr = &root->ihdr;
used = le32_to_cpu(hdr->used);
if (!check_if_index_root(rec, lrh) ||
!check_if_root_index(attr, hdr, lrh) ||
Add2Ptr(data, esize) > Add2Ptr(lrh, rec_len) ||
esize > le32_to_cpu(rec->total) - le32_to_cpu(rec->used)) {
goto dirty_vol;
}
e1 = Add2Ptr(attr, le16_to_cpu(lrh->attr_off));
change_attr_size(rec, attr, le32_to_cpu(attr->size) + esize);
memmove(Add2Ptr(e1, esize), e1,
PtrOffset(e1, Add2Ptr(hdr, used)));
memmove(e1, e, esize);
le32_add_cpu(&attr->res.data_size, esize);
hdr->used = cpu_to_le32(used + esize);
le32_add_cpu(&hdr->total, esize);
mi->dirty = true;
break;
case DeleteIndexEntryRoot:
root = resident_data(attr);
hdr = &root->ihdr;
used = le32_to_cpu(hdr->used);
if (!check_if_index_root(rec, lrh) ||
!check_if_root_index(attr, hdr, lrh)) {
goto dirty_vol;
}
e1 = Add2Ptr(attr, le16_to_cpu(lrh->attr_off));
esize = le16_to_cpu(e1->size);
e2 = Add2Ptr(e1, esize);
memmove(e1, e2, PtrOffset(e2, Add2Ptr(hdr, used)));
le32_sub_cpu(&attr->res.data_size, esize);
hdr->used = cpu_to_le32(used - esize);
le32_sub_cpu(&hdr->total, esize);
change_attr_size(rec, attr, le32_to_cpu(attr->size) - esize);
mi->dirty = true;
break;
case SetIndexEntryVcnRoot:
root = resident_data(attr);
hdr = &root->ihdr;
if (!check_if_index_root(rec, lrh) ||
!check_if_root_index(attr, hdr, lrh)) {
goto dirty_vol;
}
e = Add2Ptr(attr, le16_to_cpu(lrh->attr_off));
de_set_vbn_le(e, *(__le64 *)data);
mi->dirty = true;
break;
case UpdateFileNameRoot:
root = resident_data(attr);
hdr = &root->ihdr;
if (!check_if_index_root(rec, lrh) ||
!check_if_root_index(attr, hdr, lrh)) {
goto dirty_vol;
}
e = Add2Ptr(attr, le16_to_cpu(lrh->attr_off));
fname = (struct ATTR_FILE_NAME *)(e + 1);
memmove(&fname->dup, data, sizeof(fname->dup)); //
mi->dirty = true;
break;
case UpdateRecordDataRoot:
root = resident_data(attr);
hdr = &root->ihdr;
if (!check_if_index_root(rec, lrh) ||
!check_if_root_index(attr, hdr, lrh)) {
goto dirty_vol;
}
e = Add2Ptr(attr, le16_to_cpu(lrh->attr_off));
memmove(Add2Ptr(e, le16_to_cpu(e->view.data_off)), data, dlen);
mi->dirty = true;
break;
case ZeroEndOfFileRecord:
if (roff + dlen > record_size)
goto dirty_vol;
memset(attr, 0, dlen);
mi->dirty = true;
break;
case UpdateNonresidentValue:
if (lco < cbo + roff + dlen)
goto dirty_vol;
memcpy(Add2Ptr(buffer_le, roff), data, dlen);
a_dirty = true;
if (attr->type == ATTR_ALLOC)
ntfs_fix_pre_write(buffer_le, bytes);
break;
case AddIndexEntryAllocation:
ib = Add2Ptr(buffer_le, roff);
hdr = &ib->ihdr;
e = data;
esize = le16_to_cpu(e->size);
e1 = Add2Ptr(ib, aoff);
if (is_baad(&ib->rhdr))
goto dirty_vol;
if (!check_lsn(&ib->rhdr, rlsn))
goto out;
used = le32_to_cpu(hdr->used);
if (!check_index_buffer(ib, bytes) ||
!check_if_alloc_index(hdr, aoff) ||
Add2Ptr(e, esize) > Add2Ptr(lrh, rec_len) ||
used + esize > le32_to_cpu(hdr->total)) {
goto dirty_vol;
}
memmove(Add2Ptr(e1, esize), e1,
PtrOffset(e1, Add2Ptr(hdr, used)));
memcpy(e1, e, esize);
hdr->used = cpu_to_le32(used + esize);
a_dirty = true;
ntfs_fix_pre_write(&ib->rhdr, bytes);
break;
case DeleteIndexEntryAllocation:
ib = Add2Ptr(buffer_le, roff);
hdr = &ib->ihdr;
e = Add2Ptr(ib, aoff);
esize = le16_to_cpu(e->size);
if (is_baad(&ib->rhdr))
goto dirty_vol;
if (!check_lsn(&ib->rhdr, rlsn))
goto out;
if (!check_index_buffer(ib, bytes) ||
!check_if_alloc_index(hdr, aoff)) {
goto dirty_vol;
}
e1 = Add2Ptr(e, esize);
nsize = esize;
used = le32_to_cpu(hdr->used);
memmove(e, e1, PtrOffset(e1, Add2Ptr(hdr, used)));
hdr->used = cpu_to_le32(used - nsize);
a_dirty = true;
ntfs_fix_pre_write(&ib->rhdr, bytes);
break;
case WriteEndOfIndexBuffer:
ib = Add2Ptr(buffer_le, roff);
hdr = &ib->ihdr;
e = Add2Ptr(ib, aoff);
if (is_baad(&ib->rhdr))
goto dirty_vol;
if (!check_lsn(&ib->rhdr, rlsn))
goto out;
if (!check_index_buffer(ib, bytes) ||
!check_if_alloc_index(hdr, aoff) ||
aoff + dlen > offsetof(struct INDEX_BUFFER, ihdr) +
le32_to_cpu(hdr->total)) {
goto dirty_vol;
}
hdr->used = cpu_to_le32(dlen + PtrOffset(hdr, e));
memmove(e, data, dlen);
a_dirty = true;
ntfs_fix_pre_write(&ib->rhdr, bytes);
break;
case SetIndexEntryVcnAllocation:
ib = Add2Ptr(buffer_le, roff);
hdr = &ib->ihdr;
e = Add2Ptr(ib, aoff);
if (is_baad(&ib->rhdr))
goto dirty_vol;
if (!check_lsn(&ib->rhdr, rlsn))
goto out;
if (!check_index_buffer(ib, bytes) ||
!check_if_alloc_index(hdr, aoff)) {
goto dirty_vol;
}
de_set_vbn_le(e, *(__le64 *)data);
a_dirty = true;
ntfs_fix_pre_write(&ib->rhdr, bytes);
break;
case UpdateFileNameAllocation:
ib = Add2Ptr(buffer_le, roff);
hdr = &ib->ihdr;
e = Add2Ptr(ib, aoff);
if (is_baad(&ib->rhdr))
goto dirty_vol;
if (!check_lsn(&ib->rhdr, rlsn))
goto out;
if (!check_index_buffer(ib, bytes) ||
!check_if_alloc_index(hdr, aoff)) {
goto dirty_vol;
}
fname = (struct ATTR_FILE_NAME *)(e + 1);
memmove(&fname->dup, data, sizeof(fname->dup));
a_dirty = true;
ntfs_fix_pre_write(&ib->rhdr, bytes);
break;
case SetBitsInNonresidentBitMap:
bmp_off =
le32_to_cpu(((struct BITMAP_RANGE *)data)->bitmap_off);
bmp_bits = le32_to_cpu(((struct BITMAP_RANGE *)data)->bits);
if (cbo + (bmp_off + 7) / 8 > lco ||
cbo + ((bmp_off + bmp_bits + 7) / 8) > lco) {
goto dirty_vol;
}
__bitmap_set(Add2Ptr(buffer_le, roff), bmp_off, bmp_bits);
a_dirty = true;
break;
case ClearBitsInNonresidentBitMap:
bmp_off =
le32_to_cpu(((struct BITMAP_RANGE *)data)->bitmap_off);
bmp_bits = le32_to_cpu(((struct BITMAP_RANGE *)data)->bits);
if (cbo + (bmp_off + 7) / 8 > lco ||
cbo + ((bmp_off + bmp_bits + 7) / 8) > lco) {
goto dirty_vol;
}
__bitmap_clear(Add2Ptr(buffer_le, roff), bmp_off, bmp_bits);
a_dirty = true;
break;
case UpdateRecordDataAllocation:
ib = Add2Ptr(buffer_le, roff);
hdr = &ib->ihdr;
e = Add2Ptr(ib, aoff);
if (is_baad(&ib->rhdr))
goto dirty_vol;
if (!check_lsn(&ib->rhdr, rlsn))
goto out;
if (!check_index_buffer(ib, bytes) ||
!check_if_alloc_index(hdr, aoff)) {
goto dirty_vol;
}
memmove(Add2Ptr(e, le16_to_cpu(e->view.data_off)), data, dlen);
a_dirty = true;
ntfs_fix_pre_write(&ib->rhdr, bytes);
break;
default:
WARN_ON(1);
}
if (rlsn) {
__le64 t64 = cpu_to_le64(*rlsn);
if (rec)
rec->rhdr.lsn = t64;
if (ib)
ib->rhdr.lsn = t64;
}
if (mi && mi->dirty) {
err = mi_write(mi, 0);
if (err)
goto out;
}
if (a_dirty) {
attr = oa->attr;
err = ntfs_sb_write_run(sbi, oa->run1, vbo, buffer_le, bytes, 0);
if (err)
goto out;
}
out:
if (inode)
iput(inode);
else if (mi != mi2_child)
mi_put(mi);
kfree(buffer_le);
return err;
dirty_vol:
log->set_dirty = true;
goto out;
}
/*
* log_replay - Replays log and empties it.
*
* This function is called during mount operation.
* It replays log and empties it.
* Initialized is set false if logfile contains '-1'.
*/
int log_replay(struct ntfs_inode *ni, bool *initialized)
{
int err;
struct ntfs_sb_info *sbi = ni->mi.sbi;
struct ntfs_log *log;
struct restart_info rst_info, rst_info2;
u64 rec_lsn, ra_lsn, checkpt_lsn = 0, rlsn = 0;
struct ATTR_NAME_ENTRY *attr_names = NULL;
struct ATTR_NAME_ENTRY *ane;
struct RESTART_TABLE *dptbl = NULL;
struct RESTART_TABLE *trtbl = NULL;
const struct RESTART_TABLE *rt;
struct RESTART_TABLE *oatbl = NULL;
struct inode *inode;
struct OpenAttr *oa;
struct ntfs_inode *ni_oe;
struct ATTRIB *attr = NULL;
u64 size, vcn, undo_next_lsn;
CLST rno, lcn, lcn0, len0, clen;
void *data;
struct NTFS_RESTART *rst = NULL;
struct lcb *lcb = NULL;
struct OPEN_ATTR_ENRTY *oe;
struct TRANSACTION_ENTRY *tr;
struct DIR_PAGE_ENTRY *dp;
u32 i, bytes_per_attr_entry;
u32 l_size = ni->vfs_inode.i_size;
u32 orig_file_size = l_size;
u32 page_size, vbo, tail, off, dlen;
u32 saved_len, rec_len, transact_id;
bool use_second_page;
struct RESTART_AREA *ra2, *ra = NULL;
struct CLIENT_REC *ca, *cr;
__le16 client;
struct RESTART_HDR *rh;
const struct LFS_RECORD_HDR *frh;
const struct LOG_REC_HDR *lrh;
bool is_mapped;
bool is_ro = sb_rdonly(sbi->sb);
u64 t64;
u16 t16;
u32 t32;
/* Get the size of page. NOTE: To replay we can use default page. */
#if PAGE_SIZE >= DefaultLogPageSize && PAGE_SIZE <= DefaultLogPageSize * 2
page_size = norm_file_page(PAGE_SIZE, &l_size, true);
#else
page_size = norm_file_page(PAGE_SIZE, &l_size, false);
#endif
if (!page_size)
return -EINVAL;
log = kzalloc(sizeof(struct ntfs_log), GFP_NOFS);
if (!log)
return -ENOMEM;
memset(&rst_info, 0, sizeof(struct restart_info));
log->ni = ni;
log->l_size = l_size;
log->one_page_buf = kmalloc(page_size, GFP_NOFS);
if (!log->one_page_buf) {
err = -ENOMEM;
goto out;
}
log->page_size = page_size;
log->page_mask = page_size - 1;
log->page_bits = blksize_bits(page_size);
/* Look for a restart area on the disk. */
err = log_read_rst(log, l_size, true, &rst_info);
if (err)
goto out;
/* remember 'initialized' */
*initialized = rst_info.initialized;
if (!rst_info.restart) {
if (rst_info.initialized) {
/* No restart area but the file is not initialized. */
err = -EINVAL;
goto out;
}
log_init_pg_hdr(log, page_size, page_size, 1, 1);
log_create(log, l_size, 0, get_random_int(), false, false);
log->ra = ra;
ra = log_create_ra(log);
if (!ra) {
err = -ENOMEM;
goto out;
}
log->ra = ra;
log->init_ra = true;
goto process_log;
}
/*
* If the restart offset above wasn't zero then we won't
* look for a second restart.
*/
if (rst_info.vbo)
goto check_restart_area;
memset(&rst_info2, 0, sizeof(struct restart_info));
err = log_read_rst(log, l_size, false, &rst_info2);
/* Determine which restart area to use. */
if (!rst_info2.restart || rst_info2.last_lsn <= rst_info.last_lsn)
goto use_first_page;
use_second_page = true;
if (rst_info.chkdsk_was_run && page_size != rst_info.vbo) {
struct RECORD_PAGE_HDR *sp = NULL;
bool usa_error;
if (!read_log_page(log, page_size, &sp, &usa_error) &&
sp->rhdr.sign == NTFS_CHKD_SIGNATURE) {
use_second_page = false;
}
kfree(sp);
}
if (use_second_page) {
kfree(rst_info.r_page);
memcpy(&rst_info, &rst_info2, sizeof(struct restart_info));
rst_info2.r_page = NULL;
}
use_first_page:
kfree(rst_info2.r_page);
check_restart_area:
/*
* If the restart area is at offset 0, we want
* to write the second restart area first.
*/
log->init_ra = !!rst_info.vbo;
/* If we have a valid page then grab a pointer to the restart area. */
ra2 = rst_info.valid_page
? Add2Ptr(rst_info.r_page,
le16_to_cpu(rst_info.r_page->ra_off))
: NULL;
if (rst_info.chkdsk_was_run ||
(ra2 && ra2->client_idx[1] == LFS_NO_CLIENT_LE)) {
bool wrapped = false;
bool use_multi_page = false;
u32 open_log_count;
/* Do some checks based on whether we have a valid log page. */
if (!rst_info.valid_page) {
open_log_count = get_random_int();
goto init_log_instance;
}
open_log_count = le32_to_cpu(ra2->open_log_count);
/*
* If the restart page size isn't changing then we want to
* check how much work we need to do.
*/
if (page_size != le32_to_cpu(rst_info.r_page->sys_page_size))
goto init_log_instance;
init_log_instance:
log_init_pg_hdr(log, page_size, page_size, 1, 1);
log_create(log, l_size, rst_info.last_lsn, open_log_count,
wrapped, use_multi_page);
ra = log_create_ra(log);
if (!ra) {
err = -ENOMEM;
goto out;
}
log->ra = ra;
/* Put the restart areas and initialize
* the log file as required.
*/
goto process_log;
}
if (!ra2) {
err = -EINVAL;
goto out;
}
/*
* If the log page or the system page sizes have changed, we can't
* use the log file. We must use the system page size instead of the
* default size if there is not a clean shutdown.
*/
t32 = le32_to_cpu(rst_info.r_page->sys_page_size);
if (page_size != t32) {
l_size = orig_file_size;
page_size =
norm_file_page(t32, &l_size, t32 == DefaultLogPageSize);
}
if (page_size != t32 ||
page_size != le32_to_cpu(rst_info.r_page->page_size)) {
err = -EINVAL;
goto out;
}
/* If the file size has shrunk then we won't mount it. */
if (l_size < le64_to_cpu(ra2->l_size)) {
err = -EINVAL;
goto out;
}
log_init_pg_hdr(log, page_size, page_size,
le16_to_cpu(rst_info.r_page->major_ver),
le16_to_cpu(rst_info.r_page->minor_ver));
log->l_size = le64_to_cpu(ra2->l_size);
log->seq_num_bits = le32_to_cpu(ra2->seq_num_bits);
log->file_data_bits = sizeof(u64) * 8 - log->seq_num_bits;
log->seq_num_mask = (8 << log->file_data_bits) - 1;
log->last_lsn = le64_to_cpu(ra2->current_lsn);
log->seq_num = log->last_lsn >> log->file_data_bits;
log->ra_off = le16_to_cpu(rst_info.r_page->ra_off);
log->restart_size = log->sys_page_size - log->ra_off;
log->record_header_len = le16_to_cpu(ra2->rec_hdr_len);
log->ra_size = le16_to_cpu(ra2->ra_len);
log->data_off = le16_to_cpu(ra2->data_off);
log->data_size = log->page_size - log->data_off;
log->reserved = log->data_size - log->record_header_len;
vbo = lsn_to_vbo(log, log->last_lsn);
if (vbo < log->first_page) {
/* This is a pseudo lsn. */
log->l_flags |= NTFSLOG_NO_LAST_LSN;
log->next_page = log->first_page;
goto find_oldest;
}
/* Find the end of this log record. */
off = final_log_off(log, log->last_lsn,
le32_to_cpu(ra2->last_lsn_data_len));
/* If we wrapped the file then increment the sequence number. */
if (off <= vbo) {
log->seq_num += 1;
log->l_flags |= NTFSLOG_WRAPPED;
}
/* Now compute the next log page to use. */
vbo &= ~log->sys_page_mask;
tail = log->page_size - (off & log->page_mask) - 1;
/*
*If we can fit another log record on the page,
* move back a page the log file.
*/
if (tail >= log->record_header_len) {
log->l_flags |= NTFSLOG_REUSE_TAIL;
log->next_page = vbo;
} else {
log->next_page = next_page_off(log, vbo);
}
find_oldest:
/*
* Find the oldest client lsn. Use the last
* flushed lsn as a starting point.
*/
log->oldest_lsn = log->last_lsn;
oldest_client_lsn(Add2Ptr(ra2, le16_to_cpu(ra2->client_off)),
ra2->client_idx[1], &log->oldest_lsn);
log->oldest_lsn_off = lsn_to_vbo(log, log->oldest_lsn);
if (log->oldest_lsn_off < log->first_page)
log->l_flags |= NTFSLOG_NO_OLDEST_LSN;
if (!(ra2->flags & RESTART_SINGLE_PAGE_IO))
log->l_flags |= NTFSLOG_WRAPPED | NTFSLOG_MULTIPLE_PAGE_IO;
log->current_openlog_count = le32_to_cpu(ra2->open_log_count);
log->total_avail_pages = log->l_size - log->first_page;
log->total_avail = log->total_avail_pages >> log->page_bits;
log->max_current_avail = log->total_avail * log->reserved;
log->total_avail = log->total_avail * log->data_size;
log->current_avail = current_log_avail(log);
ra = kzalloc(log->restart_size, GFP_NOFS);
if (!ra) {
err = -ENOMEM;
goto out;
}
log->ra = ra;
t16 = le16_to_cpu(ra2->client_off);
if (t16 == offsetof(struct RESTART_AREA, clients)) {
memcpy(ra, ra2, log->ra_size);
} else {
memcpy(ra, ra2, offsetof(struct RESTART_AREA, clients));
memcpy(ra->clients, Add2Ptr(ra2, t16),
le16_to_cpu(ra2->ra_len) - t16);
log->current_openlog_count = get_random_int();
ra->open_log_count = cpu_to_le32(log->current_openlog_count);
log->ra_size = offsetof(struct RESTART_AREA, clients) +
sizeof(struct CLIENT_REC);
ra->client_off =
cpu_to_le16(offsetof(struct RESTART_AREA, clients));
ra->ra_len = cpu_to_le16(log->ra_size);
}
le32_add_cpu(&ra->open_log_count, 1);
/* Now we need to walk through looking for the last lsn. */
err = last_log_lsn(log);
if (err)
goto out;
log->current_avail = current_log_avail(log);
/* Remember which restart area to write first. */
log->init_ra = rst_info.vbo;
process_log:
/* 1.0, 1.1, 2.0 log->major_ver/minor_ver - short values. */
switch ((log->major_ver << 16) + log->minor_ver) {
case 0x10000:
case 0x10001:
case 0x20000:
break;
default:
ntfs_warn(sbi->sb, "\x24LogFile version %d.%d is not supported",
log->major_ver, log->minor_ver);
err = -EOPNOTSUPP;
log->set_dirty = true;
goto out;
}
/* One client "NTFS" per logfile. */
ca = Add2Ptr(ra, le16_to_cpu(ra->client_off));
for (client = ra->client_idx[1];; client = cr->next_client) {
if (client == LFS_NO_CLIENT_LE) {
/* Insert "NTFS" client LogFile. */
client = ra->client_idx[0];
if (client == LFS_NO_CLIENT_LE) {
err = -EINVAL;
goto out;
}
t16 = le16_to_cpu(client);
cr = ca + t16;
remove_client(ca, cr, &ra->client_idx[0]);
cr->restart_lsn = 0;
cr->oldest_lsn = cpu_to_le64(log->oldest_lsn);
cr->name_bytes = cpu_to_le32(8);
cr->name[0] = cpu_to_le16('N');
cr->name[1] = cpu_to_le16('T');
cr->name[2] = cpu_to_le16('F');
cr->name[3] = cpu_to_le16('S');
add_client(ca, t16, &ra->client_idx[1]);
break;
}
cr = ca + le16_to_cpu(client);
if (cpu_to_le32(8) == cr->name_bytes &&
cpu_to_le16('N') == cr->name[0] &&
cpu_to_le16('T') == cr->name[1] &&
cpu_to_le16('F') == cr->name[2] &&
cpu_to_le16('S') == cr->name[3])
break;
}
/* Update the client handle with the client block information. */
log->client_id.seq_num = cr->seq_num;
log->client_id.client_idx = client;
err = read_rst_area(log, &rst, &ra_lsn);
if (err)
goto out;
if (!rst)
goto out;
bytes_per_attr_entry = !rst->major_ver ? 0x2C : 0x28;
checkpt_lsn = le64_to_cpu(rst->check_point_start);
if (!checkpt_lsn)
checkpt_lsn = ra_lsn;
/* Allocate and Read the Transaction Table. */
if (!rst->transact_table_len)
goto check_dirty_page_table;
t64 = le64_to_cpu(rst->transact_table_lsn);
err = read_log_rec_lcb(log, t64, lcb_ctx_prev, &lcb);
if (err)
goto out;
lrh = lcb->log_rec;
frh = lcb->lrh;
rec_len = le32_to_cpu(frh->client_data_len);
if (!check_log_rec(lrh, rec_len, le32_to_cpu(frh->transact_id),
bytes_per_attr_entry)) {
err = -EINVAL;
goto out;
}
t16 = le16_to_cpu(lrh->redo_off);
rt = Add2Ptr(lrh, t16);
t32 = rec_len - t16;
/* Now check that this is a valid restart table. */
if (!check_rstbl(rt, t32)) {
err = -EINVAL;
goto out;
}
trtbl = kmemdup(rt, t32, GFP_NOFS);
if (!trtbl) {
err = -ENOMEM;
goto out;
}
lcb_put(lcb);
lcb = NULL;
check_dirty_page_table:
/* The next record back should be the Dirty Pages Table. */
if (!rst->dirty_pages_len)
goto check_attribute_names;
t64 = le64_to_cpu(rst->dirty_pages_table_lsn);
err = read_log_rec_lcb(log, t64, lcb_ctx_prev, &lcb);
if (err)
goto out;
lrh = lcb->log_rec;
frh = lcb->lrh;
rec_len = le32_to_cpu(frh->client_data_len);
if (!check_log_rec(lrh, rec_len, le32_to_cpu(frh->transact_id),
bytes_per_attr_entry)) {
err = -EINVAL;
goto out;
}
t16 = le16_to_cpu(lrh->redo_off);
rt = Add2Ptr(lrh, t16);
t32 = rec_len - t16;
/* Now check that this is a valid restart table. */
if (!check_rstbl(rt, t32)) {
err = -EINVAL;
goto out;
}
dptbl = kmemdup(rt, t32, GFP_NOFS);
if (!dptbl) {
err = -ENOMEM;
goto out;
}
/* Convert Ra version '0' into version '1'. */
if (rst->major_ver)
goto end_conv_1;
dp = NULL;
while ((dp = enum_rstbl(dptbl, dp))) {
struct DIR_PAGE_ENTRY_32 *dp0 = (struct DIR_PAGE_ENTRY_32 *)dp;
// NOTE: Danger. Check for of boundary.
memmove(&dp->vcn, &dp0->vcn_low,
2 * sizeof(u64) +
le32_to_cpu(dp->lcns_follow) * sizeof(u64));
}
end_conv_1:
lcb_put(lcb);
lcb = NULL;
/*
* Go through the table and remove the duplicates,
* remembering the oldest lsn values.
*/
if (sbi->cluster_size <= log->page_size)
goto trace_dp_table;
dp = NULL;
while ((dp = enum_rstbl(dptbl, dp))) {
struct DIR_PAGE_ENTRY *next = dp;
while ((next = enum_rstbl(dptbl, next))) {
if (next->target_attr == dp->target_attr &&
next->vcn == dp->vcn) {
if (le64_to_cpu(next->oldest_lsn) <
le64_to_cpu(dp->oldest_lsn)) {
dp->oldest_lsn = next->oldest_lsn;
}
free_rsttbl_idx(dptbl, PtrOffset(dptbl, next));
}
}
}
trace_dp_table:
check_attribute_names:
/* The next record should be the Attribute Names. */
if (!rst->attr_names_len)
goto check_attr_table;
t64 = le64_to_cpu(rst->attr_names_lsn);
err = read_log_rec_lcb(log, t64, lcb_ctx_prev, &lcb);
if (err)
goto out;
lrh = lcb->log_rec;
frh = lcb->lrh;
rec_len = le32_to_cpu(frh->client_data_len);
if (!check_log_rec(lrh, rec_len, le32_to_cpu(frh->transact_id),
bytes_per_attr_entry)) {
err = -EINVAL;
goto out;
}
t32 = lrh_length(lrh);
rec_len -= t32;
attr_names = kmemdup(Add2Ptr(lrh, t32), rec_len, GFP_NOFS);
lcb_put(lcb);
lcb = NULL;
check_attr_table:
/* The next record should be the attribute Table. */
if (!rst->open_attr_len)
goto check_attribute_names2;
t64 = le64_to_cpu(rst->open_attr_table_lsn);
err = read_log_rec_lcb(log, t64, lcb_ctx_prev, &lcb);
if (err)
goto out;
lrh = lcb->log_rec;
frh = lcb->lrh;
rec_len = le32_to_cpu(frh->client_data_len);
if (!check_log_rec(lrh, rec_len, le32_to_cpu(frh->transact_id),
bytes_per_attr_entry)) {
err = -EINVAL;
goto out;
}
t16 = le16_to_cpu(lrh->redo_off);
rt = Add2Ptr(lrh, t16);
t32 = rec_len - t16;
if (!check_rstbl(rt, t32)) {
err = -EINVAL;
goto out;
}
oatbl = kmemdup(rt, t32, GFP_NOFS);
if (!oatbl) {
err = -ENOMEM;
goto out;
}
log->open_attr_tbl = oatbl;
/* Clear all of the Attr pointers. */
oe = NULL;
while ((oe = enum_rstbl(oatbl, oe))) {
if (!rst->major_ver) {
struct OPEN_ATTR_ENRTY_32 oe0;
/* Really 'oe' points to OPEN_ATTR_ENRTY_32. */
memcpy(&oe0, oe, SIZEOF_OPENATTRIBUTEENTRY0);
oe->bytes_per_index = oe0.bytes_per_index;
oe->type = oe0.type;
oe->is_dirty_pages = oe0.is_dirty_pages;
oe->name_len = 0;
oe->ref = oe0.ref;
oe->open_record_lsn = oe0.open_record_lsn;
}
oe->is_attr_name = 0;
oe->ptr = NULL;
}
lcb_put(lcb);
lcb = NULL;
check_attribute_names2:
if (!rst->attr_names_len)
goto trace_attribute_table;
ane = attr_names;
if (!oatbl)
goto trace_attribute_table;
while (ane->off) {
/* TODO: Clear table on exit! */
oe = Add2Ptr(oatbl, le16_to_cpu(ane->off));
t16 = le16_to_cpu(ane->name_bytes);
oe->name_len = t16 / sizeof(short);
oe->ptr = ane->name;
oe->is_attr_name = 2;
ane = Add2Ptr(ane, sizeof(struct ATTR_NAME_ENTRY) + t16);
}
trace_attribute_table:
/*
* If the checkpt_lsn is zero, then this is a freshly
* formatted disk and we have no work to do.
*/
if (!checkpt_lsn) {
err = 0;
goto out;
}
if (!oatbl) {
oatbl = init_rsttbl(bytes_per_attr_entry, 8);
if (!oatbl) {
err = -ENOMEM;
goto out;
}
}
log->open_attr_tbl = oatbl;
/* Start the analysis pass from the Checkpoint lsn. */
rec_lsn = checkpt_lsn;
/* Read the first lsn. */
err = read_log_rec_lcb(log, checkpt_lsn, lcb_ctx_next, &lcb);
if (err)
goto out;
/* Loop to read all subsequent records to the end of the log file. */
next_log_record_analyze:
err = read_next_log_rec(log, lcb, &rec_lsn);
if (err)
goto out;
if (!rec_lsn)
goto end_log_records_enumerate;
frh = lcb->lrh;
transact_id = le32_to_cpu(frh->transact_id);
rec_len = le32_to_cpu(frh->client_data_len);
lrh = lcb->log_rec;
if (!check_log_rec(lrh, rec_len, transact_id, bytes_per_attr_entry)) {
err = -EINVAL;
goto out;
}
/*
* The first lsn after the previous lsn remembered
* the checkpoint is the first candidate for the rlsn.
*/
if (!rlsn)
rlsn = rec_lsn;
if (LfsClientRecord != frh->record_type)
goto next_log_record_analyze;
/*
* Now update the Transaction Table for this transaction. If there
* is no entry present or it is unallocated we allocate the entry.
*/
if (!trtbl) {
trtbl = init_rsttbl(sizeof(struct TRANSACTION_ENTRY),
INITIAL_NUMBER_TRANSACTIONS);
if (!trtbl) {
err = -ENOMEM;
goto out;
}
}
tr = Add2Ptr(trtbl, transact_id);
if (transact_id >= bytes_per_rt(trtbl) ||
tr->next != RESTART_ENTRY_ALLOCATED_LE) {
tr = alloc_rsttbl_from_idx(&trtbl, transact_id);
if (!tr) {
err = -ENOMEM;
goto out;
}
tr->transact_state = TransactionActive;
tr->first_lsn = cpu_to_le64(rec_lsn);
}
tr->prev_lsn = tr->undo_next_lsn = cpu_to_le64(rec_lsn);
/*
* If this is a compensation log record, then change
* the undo_next_lsn to be the undo_next_lsn of this record.
*/
if (lrh->undo_op == cpu_to_le16(CompensationLogRecord))
tr->undo_next_lsn = frh->client_undo_next_lsn;
/* Dispatch to handle log record depending on type. */
switch (le16_to_cpu(lrh->redo_op)) {
case InitializeFileRecordSegment:
case DeallocateFileRecordSegment:
case WriteEndOfFileRecordSegment:
case CreateAttribute:
case DeleteAttribute:
case UpdateResidentValue:
case UpdateNonresidentValue:
case UpdateMappingPairs:
case SetNewAttributeSizes:
case AddIndexEntryRoot:
case DeleteIndexEntryRoot:
case AddIndexEntryAllocation:
case DeleteIndexEntryAllocation:
case WriteEndOfIndexBuffer:
case SetIndexEntryVcnRoot:
case SetIndexEntryVcnAllocation:
case UpdateFileNameRoot:
case UpdateFileNameAllocation:
case SetBitsInNonresidentBitMap:
case ClearBitsInNonresidentBitMap:
case UpdateRecordDataRoot:
case UpdateRecordDataAllocation:
case ZeroEndOfFileRecord:
t16 = le16_to_cpu(lrh->target_attr);
t64 = le64_to_cpu(lrh->target_vcn);
dp = find_dp(dptbl, t16, t64);
if (dp)
goto copy_lcns;
/*
* Calculate the number of clusters per page the system
* which wrote the checkpoint, possibly creating the table.
*/
if (dptbl) {
t32 = (le16_to_cpu(dptbl->size) -
sizeof(struct DIR_PAGE_ENTRY)) /
sizeof(u64);
} else {
t32 = log->clst_per_page;
kfree(dptbl);
dptbl = init_rsttbl(struct_size(dp, page_lcns, t32),
32);
if (!dptbl) {
err = -ENOMEM;
goto out;
}
}
dp = alloc_rsttbl_idx(&dptbl);
if (!dp) {
err = -ENOMEM;
goto out;
}
dp->target_attr = cpu_to_le32(t16);
dp->transfer_len = cpu_to_le32(t32 << sbi->cluster_bits);
dp->lcns_follow = cpu_to_le32(t32);
dp->vcn = cpu_to_le64(t64 & ~((u64)t32 - 1));
dp->oldest_lsn = cpu_to_le64(rec_lsn);
copy_lcns:
/*
* Copy the Lcns from the log record into the Dirty Page Entry.
* TODO: For different page size support, must somehow make
* whole routine a loop, case Lcns do not fit below.
*/
t16 = le16_to_cpu(lrh->lcns_follow);
for (i = 0; i < t16; i++) {
size_t j = (size_t)(le64_to_cpu(lrh->target_vcn) -
le64_to_cpu(dp->vcn));
dp->page_lcns[j + i] = lrh->page_lcns[i];
}
goto next_log_record_analyze;
case DeleteDirtyClusters: {
u32 range_count =
le16_to_cpu(lrh->redo_len) / sizeof(struct LCN_RANGE);
const struct LCN_RANGE *r =
Add2Ptr(lrh, le16_to_cpu(lrh->redo_off));
/* Loop through all of the Lcn ranges this log record. */
for (i = 0; i < range_count; i++, r++) {
u64 lcn0 = le64_to_cpu(r->lcn);
u64 lcn_e = lcn0 + le64_to_cpu(r->len) - 1;
dp = NULL;
while ((dp = enum_rstbl(dptbl, dp))) {
u32 j;
t32 = le32_to_cpu(dp->lcns_follow);
for (j = 0; j < t32; j++) {
t64 = le64_to_cpu(dp->page_lcns[j]);
if (t64 >= lcn0 && t64 <= lcn_e)
dp->page_lcns[j] = 0;
}
}
}
goto next_log_record_analyze;
;
}
case OpenNonresidentAttribute:
t16 = le16_to_cpu(lrh->target_attr);
if (t16 >= bytes_per_rt(oatbl)) {
/*
* Compute how big the table needs to be.
* Add 10 extra entries for some cushion.
*/
u32 new_e = t16 / le16_to_cpu(oatbl->size);
new_e += 10 - le16_to_cpu(oatbl->used);
oatbl = extend_rsttbl(oatbl, new_e, ~0u);
log->open_attr_tbl = oatbl;
if (!oatbl) {
err = -ENOMEM;
goto out;
}
}
/* Point to the entry being opened. */
oe = alloc_rsttbl_from_idx(&oatbl, t16);
log->open_attr_tbl = oatbl;
if (!oe) {
err = -ENOMEM;
goto out;
}
/* Initialize this entry from the log record. */
t16 = le16_to_cpu(lrh->redo_off);
if (!rst->major_ver) {
/* Convert version '0' into version '1'. */
struct OPEN_ATTR_ENRTY_32 *oe0 = Add2Ptr(lrh, t16);
oe->bytes_per_index = oe0->bytes_per_index;
oe->type = oe0->type;
oe->is_dirty_pages = oe0->is_dirty_pages;
oe->name_len = 0; //oe0.name_len;
oe->ref = oe0->ref;
oe->open_record_lsn = oe0->open_record_lsn;
} else {
memcpy(oe, Add2Ptr(lrh, t16), bytes_per_attr_entry);
}
t16 = le16_to_cpu(lrh->undo_len);
if (t16) {
oe->ptr = kmalloc(t16, GFP_NOFS);
if (!oe->ptr) {
err = -ENOMEM;
goto out;
}
oe->name_len = t16 / sizeof(short);
memcpy(oe->ptr,
Add2Ptr(lrh, le16_to_cpu(lrh->undo_off)), t16);
oe->is_attr_name = 1;
} else {
oe->ptr = NULL;
oe->is_attr_name = 0;
}
goto next_log_record_analyze;
case HotFix:
t16 = le16_to_cpu(lrh->target_attr);
t64 = le64_to_cpu(lrh->target_vcn);
dp = find_dp(dptbl, t16, t64);
if (dp) {
size_t j = le64_to_cpu(lrh->target_vcn) -
le64_to_cpu(dp->vcn);
if (dp->page_lcns[j])
dp->page_lcns[j] = lrh->page_lcns[0];
}
goto next_log_record_analyze;
case EndTopLevelAction:
tr = Add2Ptr(trtbl, transact_id);
tr->prev_lsn = cpu_to_le64(rec_lsn);
tr->undo_next_lsn = frh->client_undo_next_lsn;
goto next_log_record_analyze;
case PrepareTransaction:
tr = Add2Ptr(trtbl, transact_id);
tr->transact_state = TransactionPrepared;
goto next_log_record_analyze;
case CommitTransaction:
tr = Add2Ptr(trtbl, transact_id);
tr->transact_state = TransactionCommitted;
goto next_log_record_analyze;
case ForgetTransaction:
free_rsttbl_idx(trtbl, transact_id);
goto next_log_record_analyze;
case Noop:
case OpenAttributeTableDump:
case AttributeNamesDump:
case DirtyPageTableDump:
case TransactionTableDump:
/* The following cases require no action the Analysis Pass. */
goto next_log_record_analyze;
default:
/*
* All codes will be explicitly handled.
* If we see a code we do not expect, then we are trouble.
*/
goto next_log_record_analyze;
}
end_log_records_enumerate:
lcb_put(lcb);
lcb = NULL;
/*
* Scan the Dirty Page Table and Transaction Table for
* the lowest lsn, and return it as the Redo lsn.
*/
dp = NULL;
while ((dp = enum_rstbl(dptbl, dp))) {
t64 = le64_to_cpu(dp->oldest_lsn);
if (t64 && t64 < rlsn)
rlsn = t64;
}
tr = NULL;
while ((tr = enum_rstbl(trtbl, tr))) {
t64 = le64_to_cpu(tr->first_lsn);
if (t64 && t64 < rlsn)
rlsn = t64;
}
/*
* Only proceed if the Dirty Page Table or Transaction
* table are not empty.
*/
if ((!dptbl || !dptbl->total) && (!trtbl || !trtbl->total))
goto end_reply;
sbi->flags |= NTFS_FLAGS_NEED_REPLAY;
if (is_ro)
goto out;
/* Reopen all of the attributes with dirty pages. */
oe = NULL;
next_open_attribute:
oe = enum_rstbl(oatbl, oe);
if (!oe) {
err = 0;
dp = NULL;
goto next_dirty_page;
}
oa = kzalloc(sizeof(struct OpenAttr), GFP_NOFS);
if (!oa) {
err = -ENOMEM;
goto out;
}
inode = ntfs_iget5(sbi->sb, &oe->ref, NULL);
if (IS_ERR(inode))
goto fake_attr;
if (is_bad_inode(inode)) {
iput(inode);
fake_attr:
if (oa->ni) {
iput(&oa->ni->vfs_inode);
oa->ni = NULL;
}
attr = attr_create_nonres_log(sbi, oe->type, 0, oe->ptr,
oe->name_len, 0);
if (!attr) {
kfree(oa);
err = -ENOMEM;
goto out;
}
oa->attr = attr;
oa->run1 = &oa->run0;
goto final_oe;
}
ni_oe = ntfs_i(inode);
oa->ni = ni_oe;
attr = ni_find_attr(ni_oe, NULL, NULL, oe->type, oe->ptr, oe->name_len,
NULL, NULL);
if (!attr)
goto fake_attr;
t32 = le32_to_cpu(attr->size);
oa->attr = kmemdup(attr, t32, GFP_NOFS);
if (!oa->attr)
goto fake_attr;
if (!S_ISDIR(inode->i_mode)) {
if (attr->type == ATTR_DATA && !attr->name_len) {
oa->run1 = &ni_oe->file.run;
goto final_oe;
}
} else {
if (attr->type == ATTR_ALLOC &&
attr->name_len == ARRAY_SIZE(I30_NAME) &&
!memcmp(attr_name(attr), I30_NAME, sizeof(I30_NAME))) {
oa->run1 = &ni_oe->dir.alloc_run;
goto final_oe;
}
}
if (attr->non_res) {
u16 roff = le16_to_cpu(attr->nres.run_off);
CLST svcn = le64_to_cpu(attr->nres.svcn);
err = run_unpack(&oa->run0, sbi, inode->i_ino, svcn,
le64_to_cpu(attr->nres.evcn), svcn,
Add2Ptr(attr, roff), t32 - roff);
if (err < 0) {
kfree(oa->attr);
oa->attr = NULL;
goto fake_attr;
}
err = 0;
}
oa->run1 = &oa->run0;
attr = oa->attr;
final_oe:
if (oe->is_attr_name == 1)
kfree(oe->ptr);
oe->is_attr_name = 0;
oe->ptr = oa;
oe->name_len = attr->name_len;
goto next_open_attribute;
/*
* Now loop through the dirty page table to extract all of the Vcn/Lcn.
* Mapping that we have, and insert it into the appropriate run.
*/
next_dirty_page:
dp = enum_rstbl(dptbl, dp);
if (!dp)
goto do_redo_1;
oe = Add2Ptr(oatbl, le32_to_cpu(dp->target_attr));
if (oe->next != RESTART_ENTRY_ALLOCATED_LE)
goto next_dirty_page;
oa = oe->ptr;
if (!oa)
goto next_dirty_page;
i = -1;
next_dirty_page_vcn:
i += 1;
if (i >= le32_to_cpu(dp->lcns_follow))
goto next_dirty_page;
vcn = le64_to_cpu(dp->vcn) + i;
size = (vcn + 1) << sbi->cluster_bits;
if (!dp->page_lcns[i])
goto next_dirty_page_vcn;
rno = ino_get(&oe->ref);
if (rno <= MFT_REC_MIRR &&
size < (MFT_REC_VOL + 1) * sbi->record_size &&
oe->type == ATTR_DATA) {
goto next_dirty_page_vcn;
}
lcn = le64_to_cpu(dp->page_lcns[i]);
if ((!run_lookup_entry(oa->run1, vcn, &lcn0, &len0, NULL) ||
lcn0 != lcn) &&
!run_add_entry(oa->run1, vcn, lcn, 1, false)) {
err = -ENOMEM;
goto out;
}
attr = oa->attr;
t64 = le64_to_cpu(attr->nres.alloc_size);
if (size > t64) {
attr->nres.valid_size = attr->nres.data_size =
attr->nres.alloc_size = cpu_to_le64(size);
}
goto next_dirty_page_vcn;
do_redo_1:
/*
* Perform the Redo Pass, to restore all of the dirty pages to the same
* contents that they had immediately before the crash. If the dirty
* page table is empty, then we can skip the entire Redo Pass.
*/
if (!dptbl || !dptbl->total)
goto do_undo_action;
rec_lsn = rlsn;
/*
* Read the record at the Redo lsn, before falling
* into common code to handle each record.
*/
err = read_log_rec_lcb(log, rlsn, lcb_ctx_next, &lcb);
if (err)
goto out;
/*
* Now loop to read all of our log records forwards, until
* we hit the end of the file, cleaning up at the end.
*/
do_action_next:
frh = lcb->lrh;
if (LfsClientRecord != frh->record_type)
goto read_next_log_do_action;
transact_id = le32_to_cpu(frh->transact_id);
rec_len = le32_to_cpu(frh->client_data_len);
lrh = lcb->log_rec;
if (!check_log_rec(lrh, rec_len, transact_id, bytes_per_attr_entry)) {
err = -EINVAL;
goto out;
}
/* Ignore log records that do not update pages. */
if (lrh->lcns_follow)
goto find_dirty_page;
goto read_next_log_do_action;
find_dirty_page:
t16 = le16_to_cpu(lrh->target_attr);
t64 = le64_to_cpu(lrh->target_vcn);
dp = find_dp(dptbl, t16, t64);
if (!dp)
goto read_next_log_do_action;
if (rec_lsn < le64_to_cpu(dp->oldest_lsn))
goto read_next_log_do_action;
t16 = le16_to_cpu(lrh->target_attr);
if (t16 >= bytes_per_rt(oatbl)) {
err = -EINVAL;
goto out;
}
oe = Add2Ptr(oatbl, t16);
if (oe->next != RESTART_ENTRY_ALLOCATED_LE) {
err = -EINVAL;
goto out;
}
oa = oe->ptr;
if (!oa) {
err = -EINVAL;
goto out;
}
attr = oa->attr;
vcn = le64_to_cpu(lrh->target_vcn);
if (!run_lookup_entry(oa->run1, vcn, &lcn, NULL, NULL) ||
lcn == SPARSE_LCN) {
goto read_next_log_do_action;
}
/* Point to the Redo data and get its length. */
data = Add2Ptr(lrh, le16_to_cpu(lrh->redo_off));
dlen = le16_to_cpu(lrh->redo_len);
/* Shorten length by any Lcns which were deleted. */
saved_len = dlen;
for (i = le16_to_cpu(lrh->lcns_follow); i; i--) {
size_t j;
u32 alen, voff;
voff = le16_to_cpu(lrh->record_off) +
le16_to_cpu(lrh->attr_off);
voff += le16_to_cpu(lrh->cluster_off) << SECTOR_SHIFT;
/* If the Vcn question is allocated, we can just get out. */
j = le64_to_cpu(lrh->target_vcn) - le64_to_cpu(dp->vcn);
if (dp->page_lcns[j + i - 1])
break;
if (!saved_len)
saved_len = 1;
/*
* Calculate the allocated space left relative to the
* log record Vcn, after removing this unallocated Vcn.
*/
alen = (i - 1) << sbi->cluster_bits;
/*
* If the update described this log record goes beyond
* the allocated space, then we will have to reduce the length.
*/
if (voff >= alen)
dlen = 0;
else if (voff + dlen > alen)
dlen = alen - voff;
}
/*
* If the resulting dlen from above is now zero,
* we can skip this log record.
*/
if (!dlen && saved_len)
goto read_next_log_do_action;
t16 = le16_to_cpu(lrh->redo_op);
if (can_skip_action(t16))
goto read_next_log_do_action;
/* Apply the Redo operation a common routine. */
err = do_action(log, oe, lrh, t16, data, dlen, rec_len, &rec_lsn);
if (err)
goto out;
/* Keep reading and looping back until end of file. */
read_next_log_do_action:
err = read_next_log_rec(log, lcb, &rec_lsn);
if (!err && rec_lsn)
goto do_action_next;
lcb_put(lcb);
lcb = NULL;
do_undo_action:
/* Scan Transaction Table. */
tr = NULL;
transaction_table_next:
tr = enum_rstbl(trtbl, tr);
if (!tr)
goto undo_action_done;
if (TransactionActive != tr->transact_state || !tr->undo_next_lsn) {
free_rsttbl_idx(trtbl, PtrOffset(trtbl, tr));
goto transaction_table_next;
}
log->transaction_id = PtrOffset(trtbl, tr);
undo_next_lsn = le64_to_cpu(tr->undo_next_lsn);
/*
* We only have to do anything if the transaction has
* something its undo_next_lsn field.
*/
if (!undo_next_lsn)
goto commit_undo;
/* Read the first record to be undone by this transaction. */
err = read_log_rec_lcb(log, undo_next_lsn, lcb_ctx_undo_next, &lcb);
if (err)
goto out;
/*
* Now loop to read all of our log records forwards,
* until we hit the end of the file, cleaning up at the end.
*/
undo_action_next:
lrh = lcb->log_rec;
frh = lcb->lrh;
transact_id = le32_to_cpu(frh->transact_id);
rec_len = le32_to_cpu(frh->client_data_len);
if (!check_log_rec(lrh, rec_len, transact_id, bytes_per_attr_entry)) {
err = -EINVAL;
goto out;
}
if (lrh->undo_op == cpu_to_le16(Noop))
goto read_next_log_undo_action;
oe = Add2Ptr(oatbl, le16_to_cpu(lrh->target_attr));
oa = oe->ptr;
t16 = le16_to_cpu(lrh->lcns_follow);
if (!t16)
goto add_allocated_vcns;
is_mapped = run_lookup_entry(oa->run1, le64_to_cpu(lrh->target_vcn),
&lcn, &clen, NULL);
/*
* If the mapping isn't already the table or the mapping
* corresponds to a hole the mapping, we need to make sure
* there is no partial page already memory.
*/
if (is_mapped && lcn != SPARSE_LCN && clen >= t16)
goto add_allocated_vcns;
vcn = le64_to_cpu(lrh->target_vcn);
vcn &= ~(log->clst_per_page - 1);
add_allocated_vcns:
for (i = 0, vcn = le64_to_cpu(lrh->target_vcn),
size = (vcn + 1) << sbi->cluster_bits;
i < t16; i++, vcn += 1, size += sbi->cluster_size) {
attr = oa->attr;
if (!attr->non_res) {
if (size > le32_to_cpu(attr->res.data_size))
attr->res.data_size = cpu_to_le32(size);
} else {
if (size > le64_to_cpu(attr->nres.data_size))
attr->nres.valid_size = attr->nres.data_size =
attr->nres.alloc_size =
cpu_to_le64(size);
}
}
t16 = le16_to_cpu(lrh->undo_op);
if (can_skip_action(t16))
goto read_next_log_undo_action;
/* Point to the Redo data and get its length. */
data = Add2Ptr(lrh, le16_to_cpu(lrh->undo_off));
dlen = le16_to_cpu(lrh->undo_len);
/* It is time to apply the undo action. */
err = do_action(log, oe, lrh, t16, data, dlen, rec_len, NULL);
read_next_log_undo_action:
/*
* Keep reading and looping back until we have read the
* last record for this transaction.
*/
err = read_next_log_rec(log, lcb, &rec_lsn);
if (err)
goto out;
if (rec_lsn)
goto undo_action_next;
lcb_put(lcb);
lcb = NULL;
commit_undo:
free_rsttbl_idx(trtbl, log->transaction_id);
log->transaction_id = 0;
goto transaction_table_next;
undo_action_done:
ntfs_update_mftmirr(sbi, 0);
sbi->flags &= ~NTFS_FLAGS_NEED_REPLAY;
end_reply:
err = 0;
if (is_ro)
goto out;
rh = kzalloc(log->page_size, GFP_NOFS);
if (!rh) {
err = -ENOMEM;
goto out;
}
rh->rhdr.sign = NTFS_RSTR_SIGNATURE;
rh->rhdr.fix_off = cpu_to_le16(offsetof(struct RESTART_HDR, fixups));
t16 = (log->page_size >> SECTOR_SHIFT) + 1;
rh->rhdr.fix_num = cpu_to_le16(t16);
rh->sys_page_size = cpu_to_le32(log->page_size);
rh->page_size = cpu_to_le32(log->page_size);
t16 = ALIGN(offsetof(struct RESTART_HDR, fixups) + sizeof(short) * t16,
8);
rh->ra_off = cpu_to_le16(t16);
rh->minor_ver = cpu_to_le16(1); // 0x1A:
rh->major_ver = cpu_to_le16(1); // 0x1C:
ra2 = Add2Ptr(rh, t16);
memcpy(ra2, ra, sizeof(struct RESTART_AREA));
ra2->client_idx[0] = 0;
ra2->client_idx[1] = LFS_NO_CLIENT_LE;
ra2->flags = cpu_to_le16(2);
le32_add_cpu(&ra2->open_log_count, 1);
ntfs_fix_pre_write(&rh->rhdr, log->page_size);
err = ntfs_sb_write_run(sbi, &ni->file.run, 0, rh, log->page_size, 0);
if (!err)
err = ntfs_sb_write_run(sbi, &log->ni->file.run, log->page_size,
rh, log->page_size, 0);
kfree(rh);
if (err)
goto out;
out:
kfree(rst);
if (lcb)
lcb_put(lcb);
/*
* Scan the Open Attribute Table to close all of
* the open attributes.
*/
oe = NULL;
while ((oe = enum_rstbl(oatbl, oe))) {
rno = ino_get(&oe->ref);
if (oe->is_attr_name == 1) {
kfree(oe->ptr);
oe->ptr = NULL;
continue;
}
if (oe->is_attr_name)
continue;
oa = oe->ptr;
if (!oa)
continue;
run_close(&oa->run0);
kfree(oa->attr);
if (oa->ni)
iput(&oa->ni->vfs_inode);
kfree(oa);
}
kfree(trtbl);
kfree(oatbl);
kfree(dptbl);
kfree(attr_names);
kfree(rst_info.r_page);
kfree(ra);
kfree(log->one_page_buf);
if (err)
sbi->flags |= NTFS_FLAGS_NEED_REPLAY;
if (err == -EROFS)
err = 0;
else if (log->set_dirty)
ntfs_set_state(sbi, NTFS_DIRTY_ERROR);
kfree(log);
return err;
}
Reference in New Issue View Git Blame Copy Permalink