diff options
Diffstat (limited to 'fs/ntfs3/fslog.c')
| -rw-r--r-- | fs/ntfs3/fslog.c | 728 |
1 files changed, 373 insertions, 355 deletions
diff --git a/fs/ntfs3/fslog.c b/fs/ntfs3/fslog.c index 7144ea8a9ab8..6f6057129fdd 100644 --- a/fs/ntfs3/fslog.c +++ b/fs/ntfs3/fslog.c @@ -30,8 +30,8 @@ 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 + __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: @@ -47,26 +47,26 @@ struct CLIENT_REC { __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 + 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. + __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 + __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: @@ -75,10 +75,10 @@ struct RESTART_AREA { 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 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: @@ -95,20 +95,20 @@ static_assert(sizeof(struct LOG_REC_HDR) == 0x20); #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 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 + __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 off; // Offset in the Open attribute Table. __le16 name_bytes; __le16 name[]; }; @@ -121,7 +121,7 @@ struct OPEN_ATTR_ENRTY { 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 + struct MFT_REF ref; // 0x10: File Reference of file containing attribute __le64 open_record_lsn; // 0x18: void *ptr; // 0x20: }; @@ -133,10 +133,10 @@ struct OPEN_ATTR_ENRTY_32 { struct MFT_REF ref; // 0x08: __le64 open_record_lsn; // 0x10: u8 is_dirty_pages; // 0x18: - u8 is_attr_name; // 0x19 + u8 is_attr_name; // 0x19: u8 res1[2]; enum ATTR_TYPE type; // 0x1C: - u8 name_len; // 0x20: in wchar + u8 name_len; // 0x20: In wchar u8 res2[3]; __le32 AttributeName; // 0x24: __le32 bytes_per_index; // 0x28: @@ -147,15 +147,15 @@ 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 + * 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 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 vcn; // 0x10: Vcn of dirty page __le64 oldest_lsn; // 0x18: __le64 page_lcns[]; // 0x20: }; @@ -164,17 +164,17 @@ 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: + __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); @@ -233,27 +233,27 @@ struct LCN_RANGE { __le64 len; }; -/* The following type defines the different log record types */ +/* 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 */ +/* 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 */ +/* 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: + __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) @@ -261,26 +261,26 @@ struct LFS_RECORD_HDR { 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 + __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 + 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 +// 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) @@ -294,7 +294,7 @@ 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 some tuning parameters to keep the restart tables a reasonable size. */ #define INITIAL_NUMBER_TRANSACTIONS 5 enum NTFS_LOG_OPERATION { @@ -342,8 +342,9 @@ enum NTFS_LOG_OPERATION { }; /* - * Array for log records which require a target attribute - * A true indicates that the corresponding restart operation requires a target attribute + * 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, @@ -380,14 +381,14 @@ static inline bool can_skip_action(enum NTFS_LOG_OPERATION op) enum { lcb_ctx_undo_next, lcb_ctx_prev, lcb_ctx_next }; -/* bytes per restart table */ +/* 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 */ +/* Log record length. */ static inline u32 lrh_length(const struct LOG_REC_HDR *lr) { u16 t16 = le16_to_cpu(lr->lcns_follow); @@ -396,11 +397,11 @@ static inline u32 lrh_length(const struct LOG_REC_HDR *lr) } struct lcb { - struct LFS_RECORD_HDR *lrh; // Log record header of the current lsn + 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' + bool alloc; // If true the we should deallocate 'log_rec'. }; static void lcb_put(struct lcb *lcb) @@ -411,11 +412,7 @@ static void lcb_put(struct lcb *lcb) kfree(lcb); } -/* - * oldest_client_lsn - * - * find the oldest lsn from active clients. - */ +/* Find the oldest lsn from active clients. */ static inline void oldest_client_lsn(const struct CLIENT_REC *ca, __le16 next_client, u64 *oldest_lsn) { @@ -423,7 +420,7 @@ static inline void oldest_client_lsn(const struct CLIENT_REC *ca, 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 */ + /* Ignore this block if it's oldest lsn is 0. */ if (lsn && lsn < *oldest_lsn) *oldest_lsn = lsn; @@ -444,11 +441,11 @@ static inline bool is_rst_page_hdr_valid(u32 file_off, return false; } - /* Check that if the file offset isn't 0, it is the system page size */ + /* 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+ */ + /* Check support version 1.1+. */ if (le16_to_cpu(rhdr->major_ver) <= 1 && !rhdr->minor_ver) return false; @@ -498,7 +495,7 @@ static inline bool is_rst_area_valid(const struct RESTART_HDR *rhdr) /* * Check the restart length field and whether the entire - * restart area is contained that length + * 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)) { @@ -507,7 +504,7 @@ static inline bool is_rst_area_valid(const struct RESTART_HDR *rhdr) /* * As a final check make sure that the use list and the free list - * are either empty or point to a valid client + * 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]); @@ -515,7 +512,7 @@ static inline bool is_rst_area_valid(const struct RESTART_HDR *rhdr) (ul != LFS_NO_CLIENT && ul >= cl)) return false; - /* Make sure the sequence number bits match the log file size */ + /* 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); @@ -525,7 +522,7 @@ static inline bool is_rst_area_valid(const struct RESTART_HDR *rhdr) return false; } - /* The log page data offset and record header length must be quad-aligned */ + /* 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; @@ -545,13 +542,13 @@ static inline bool is_client_area_valid(const struct RESTART_HDR *rhdr, if (usa_error && ra_len + ro > SECTOR_SIZE - sizeof(short)) return false; - /* Find the start of the client array */ + /* 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 + * 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]); @@ -584,7 +581,7 @@ static inline bool is_client_area_valid(const struct RESTART_HDR *rhdr, /* * remove_client * - * remove a client record from a client record list an restart area + * 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) @@ -599,9 +596,7 @@ static inline void remove_client(struct CLIENT_REC *ca, } /* - * add_client - * - * add a client record to the start of a list + * 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) { @@ -616,10 +611,6 @@ static inline void add_client(struct CLIENT_REC *ca, u16 index, __le16 *head) *head = cpu_to_le16(index); } -/* - * enum_rstbl - * - */ static inline void *enum_rstbl(struct RESTART_TABLE *t, void *c) { __le32 *e; @@ -634,7 +625,7 @@ static inline void *enum_rstbl(struct RESTART_TABLE *t, void *c) e = Add2Ptr(c, rsize); } - /* Loop until we hit the first one allocated, or the end of the list */ + /* 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) @@ -644,9 +635,7 @@ static inline void *enum_rstbl(struct RESTART_TABLE *t, void *c) } /* - * find_dp - * - * searches for a 'vcn' in Dirty Page Table, + * 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) @@ -670,10 +659,10 @@ 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 */ + /* 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 */ + /* File should contain at least 2 restart pages and MinLogRecordPages pages. */ if (*l_size < (MinLogRecordPages + 2) * page_size) return 0; @@ -743,8 +732,9 @@ static bool check_rstbl(const struct RESTART_TABLE *rt, size_t bytes) return false; } - /* Verify each entry is either allocated or points - * to a valid offset the table + /* + * 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( @@ -757,8 +747,9 @@ static bool check_rstbl(const struct RESTART_TABLE *rt, size_t bytes) } } - /* Walk through the list headed by the first entry to make - * sure none of the entries are currently being used + /* + * 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) @@ -771,9 +762,7 @@ static bool check_rstbl(const struct RESTART_TABLE *rt, size_t bytes) } /* - * free_rsttbl_idx - * - * frees a previously allocated index a Restart Table. + * free_rsttbl_idx - Free a previously allocated index a Restart Table. */ static inline void free_rsttbl_idx(struct RESTART_TABLE *rt, u32 off) { @@ -863,7 +852,7 @@ static inline struct RESTART_TABLE *extend_rsttbl(struct RESTART_TABLE *tbl, /* * alloc_rsttbl_idx * - * allocates an index from within a previously initialized Restart Table + * Allocate an index from within a previously initialized Restart Table. */ static inline void *alloc_rsttbl_idx(struct RESTART_TABLE **tbl) { @@ -900,7 +889,7 @@ static inline void *alloc_rsttbl_idx(struct RESTART_TABLE **tbl) /* * alloc_rsttbl_from_idx * - * allocates a specific index from within a previously initialized Restart Table + * Allocate a specific index from within a previously initialized Restart Table. */ static inline void *alloc_rsttbl_from_idx(struct RESTART_TABLE **tbl, u32 vbo) { @@ -910,23 +899,24 @@ static inline void *alloc_rsttbl_from_idx(struct RESTART_TABLE **tbl, u32 vbo) 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 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 + * 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 */ + /* + * 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. */ + /* See if the entry is already allocated, and just return if it is. */ e = Add2Ptr(rt, vbo); if (*e == RESTART_ENTRY_ALLOCATED_LE) @@ -934,7 +924,7 @@ static inline void *alloc_rsttbl_from_idx(struct RESTART_TABLE **tbl, u32 vbo) /* * Walk through the table, looking for the entry we're - * interested and the previous entry + * interested and the previous entry. */ off = le32_to_cpu(rt->first_free); e = Add2Ptr(rt, off); @@ -946,24 +936,28 @@ static inline void *alloc_rsttbl_from_idx(struct RESTART_TABLE **tbl, u32 vbo) } /* - * need to walk through the list looking for the predecessor of our entry + * 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. */ + /* Should never run of entries. */ - /* Lookup up the next entry the list */ + /* 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 this is our match we are done. */ if (off == vbo) { *last_e = *e; - /* If this was the last entry, we update that the table as well */ + /* + * 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; @@ -971,11 +965,11 @@ static inline void *alloc_rsttbl_from_idx(struct RESTART_TABLE **tbl, u32 vbo) } skip_looking: - /* If the list is now empty, we fix the last_free as well */ + /* If the list is now empty, we fix the last_free as well. */ if (!rt->first_free) rt->last_free = 0; - /* Zero this entry */ + /* Zero this entry. */ memset(e, 0, esize); *e = RESTART_ENTRY_ALLOCATED_LE; @@ -992,9 +986,7 @@ skip_looking: #define NTFSLOG_REUSE_TAIL 0x00000010 #define NTFSLOG_NO_OLDEST_LSN 0x00000020 -/* - * Helper struct to work with NTFS LogFile - */ +/* Helper struct to work with NTFS $LogFile. */ struct ntfs_log { struct ntfs_inode *ni; @@ -1022,15 +1014,15 @@ struct ntfs_log { 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 */ + 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 + * to the first position on the disk. */ bool init_ra; - bool set_dirty; /* true if we need to set dirty flag */ + bool set_dirty; /* True if we need to set dirty flag. */ u64 oldest_lsn; @@ -1048,7 +1040,7 @@ struct ntfs_log { short minor_ver; u32 l_flags; /* See NTFSLOG_XXX */ - u32 current_openlog_count; /* On-disk value for open_log_count */ + u32 current_openlog_count; /* On-disk value for open_log_count. */ struct CLIENT_ID client_id; u32 client_undo_commit; @@ -1061,7 +1053,7 @@ static inline u32 lsn_to_vbo(struct ntfs_log *log, const u64 lsn) return vbo; } -/* compute the offset in the log file of the next log page */ +/* 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; @@ -1184,8 +1176,9 @@ out: /* * 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 + * 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) @@ -1198,7 +1191,7 @@ static int log_read_rst(struct ntfs_log *log, u32 l_size, bool first, memset(info, 0, sizeof(struct restart_info)); - /* Determine which restart area we are looking for */ + /* Determine which restart area we are looking for. */ if (first) { vbo = 0; skip = 512; @@ -1207,21 +1200,21 @@ static int log_read_rst(struct ntfs_log *log, u32 l_size, bool first, skip = 0; } - /* loop continuously until we succeed */ + /* 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 */ + /* 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 */ + /* Ignore any errors. */ continue; } - /* exit if the signature is a log record page */ + /* Exit if the signature is a log record page. */ if (r_page->rhdr.sign == NTFS_RCRD_SIGNATURE) { info->initialized = true; break; @@ -1234,7 +1227,7 @@ static int log_read_rst(struct ntfs_log *log, u32 l_size, bool first, if (r_page->rhdr.sign != NTFS_FFFF_SIGNATURE) { /* * Remember if the signature does not - * indicate uninitialized file + * indicate uninitialized file. */ info->initialized = true; } @@ -1246,7 +1239,7 @@ static int log_read_rst(struct ntfs_log *log, u32 l_size, bool first, info->initialized = true; info->vbo = vbo; - /* Let's check the restart area if this is a valid page */ + /* 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)); @@ -1257,14 +1250,14 @@ static int log_read_rst(struct ntfs_log *log, u32 l_size, bool first, /* * 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 + * 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 */ + /* Read the entire restart area. */ sys_page_size = le32_to_cpu(r_page->sys_page_size); if (DefaultLogPageSize != sys_page_size) { kfree(r_page); @@ -1275,7 +1268,7 @@ static int log_read_rst(struct ntfs_log *log, u32 l_size, bool first, if (read_log_page(log, vbo, (struct RECORD_PAGE_HDR **)&r_page, &usa_error)) { - /* ignore any errors */ + /* Ignore any errors. */ kfree(r_page); r_page = NULL; continue; @@ -1288,7 +1281,10 @@ static int log_read_rst(struct ntfs_log *log, u32 l_size, bool first, } check_result: - /* If chkdsk was run then update the caller's values and return */ + /* + * 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); @@ -1297,7 +1293,10 @@ check_result: return 0; } - /* If we have a valid page then copy the values we need from it */ + /* + * 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; @@ -1312,9 +1311,7 @@ check_result: } /* - * log_init_pg_hdr - * - * init "log' from restart page header + * 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) @@ -1337,15 +1334,13 @@ static void log_init_pg_hdr(struct ntfs_log *log, u32 sys_page_size, } /* - * log_create - * - * init "log" in cases when we don't have a restart area to use + * 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 */ + /* 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; @@ -1357,21 +1352,21 @@ static void log_create(struct ntfs_log *log, u32 l_size, const u64 last_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 */ + /* 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 */ + /* 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 */ + /* Remember the different page sizes for reservation. */ log->reserved = log->data_size - log->record_header_len; /* Compute the restart page values. */ @@ -1384,15 +1379,15 @@ static void log_create(struct ntfs_log *log, u32 l_size, const u64 last_lsn, /* * The total available log file space is the number of - * log file pages times the space available on each page + * 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 + * 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; @@ -1400,9 +1395,7 @@ static void log_create(struct ntfs_log *log, u32 l_size, const u64 last_lsn, } /* - * log_create_ra - * - * This routine is called to fill a restart area from the values stored in 'log' + * log_create_ra - Fill a restart area from the values stored in @log. */ static struct RESTART_AREA *log_create_ra(struct ntfs_log *log) { @@ -1442,12 +1435,12 @@ static u32 final_log_off(struct ntfs_log *log, u64 lsn, u32 data_len) page_off -= 1; - /* Add the length of the header */ + /* 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 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; @@ -1457,7 +1450,10 @@ static u32 final_log_off(struct ntfs_log *log, u64 lsn, u32 data_len) for (;;) { final_log_off = next_page_off(log, final_log_off); - /* We are done if the remaining bytes fit on this page */ + /* + * We are done if the remaining bytes + * fit on this page. + */ if (data_len <= tail) break; data_len -= tail; @@ -1466,7 +1462,7 @@ static u32 final_log_off(struct ntfs_log *log, u64 lsn, u32 data_len) /* * 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 + * and then add that value to the file offset of this log page. */ return final_log_off + data_len + page_off; } @@ -1483,11 +1479,11 @@ static int next_log_lsn(struct ntfs_log *log, const struct LFS_RECORD_HDR *rh, u64 seq = this_lsn >> log->file_data_bits; struct RECORD_PAGE_HDR *page = NULL; - /* Remember if we wrapped */ + /* Remember if we wrapped. */ if (end <= vbo) seq += 1; - /* log page header for this page */ + /* Log page header for this page. */ err = read_log_page(log, hdr_off, &page, NULL); if (err) return err; @@ -1495,11 +1491,11 @@ static int next_log_lsn(struct ntfs_log *log, const struct LFS_RECORD_HDR *rh, /* * 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 + * 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 */ + /* 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; @@ -1509,12 +1505,12 @@ static int next_log_lsn(struct ntfs_log *log, const struct LFS_RECORD_HDR *rh, vbo = ALIGN(end, 8); } - /* Compute the lsn based on the file offset and the sequence count */ + /* 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 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; @@ -1525,32 +1521,30 @@ static int next_log_lsn(struct ntfs_log *log, const struct LFS_RECORD_HDR *rh, } /* - * current_log_avail - * - * calculate the number of bytes available for log records + * 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 */ + /* 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 + * 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 + * 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 @@ -1558,12 +1552,12 @@ static u32 current_log_avail(struct ntfs_log *log) ? log->l_size : log->next_page; - /* If the two offsets are the same then there is no available space */ + /* 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 + * this range from the total available pages. */ free_bytes = oldest_off < next_free_off @@ -1587,13 +1581,13 @@ static bool check_subseq_log_page(struct ntfs_log *log, /* * If the last lsn on the page occurs was written after the page - * that caused the original error then we have a fatal error + * 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 + * than lsn we expect, then this is a subsequent write. */ return lsn_seq >= seq || (lsn_seq == seq - 1 && log->first_page == vbo && @@ -1603,8 +1597,8 @@ static bool check_subseq_log_page(struct ntfs_log *log, /* * last_log_lsn * - * This routine walks through the log pages for a file, searching for the - * last log page written to the file + * 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) { @@ -1653,7 +1647,7 @@ static int last_log_lsn(struct ntfs_log *log) } next_tail: - /* Read second tail page (at pos 3/0x12000) */ + /* 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); @@ -1665,7 +1659,7 @@ next_tail: lsn2 = le64_to_cpu(second_tail->record_hdr.last_end_lsn); } - /* Read first tail page (at pos 2/0x2000 ) */ + /* 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); @@ -1811,10 +1805,10 @@ tail_read: next_page: tail_page = NULL; - /* Read the next log page */ + /* Read the next log page. */ err = read_log_page(log, curpage_off, &page, &usa_error); - /* Compute the next log page offset the file */ + /* Compute the next log page offset the file. */ nextpage_off = next_page_off(log, curpage_off); wrapped = nextpage_off == log->first_page; @@ -1893,14 +1887,14 @@ use_cur_page: /* * If we are at the expected first page of a transfer check to see - * if either tail copy is at this offset + * 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 + * 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 + * tail copy. It is possible it will match both. */ if (curpage_off == final_off) tail_page = first_tail; @@ -1922,32 +1916,35 @@ use_cur_page: use_tail_page: if (tail_page) { - /* we have a candidate for a tail copy */ + /* 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 + * 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 + * 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 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 + * last lsn or the sequence number is not expected. */ lsn_cur = le64_to_cpu(page->rhdr.lsn); if (last_ok_lsn != lsn_cur && @@ -1956,9 +1953,9 @@ use_tail_page: } /* - * Check that the page position and page count values are correct + * 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 + * and the count will be unknown. */ if (page_cnt == page_pos) { if (page->page_pos != cpu_to_le16(1) && @@ -1975,20 +1972,20 @@ use_tail_page: 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 + * 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 + * the tail copy area. * If the tail page was written after the page the file then - * break of the loop + * 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 */ + /* Remember if we will replace the page. */ replace_page = true; goto check_tail; } @@ -1998,7 +1995,7 @@ use_tail_page: if (is_log_record_end(page)) { /* * Since we have read this page we know the sequence number - * is the same as our expected value + * is the same as our expected value. */ log->seq_num = expected_seq; log->last_lsn = le64_to_cpu(page->record_hdr.last_end_lsn); @@ -2007,7 +2004,7 @@ use_tail_page: /* * If there is room on this page for another header then - * remember we want to reuse the page + * remember we want to reuse the page. */ if (log->record_header_len <= log->page_size - @@ -2019,14 +2016,14 @@ use_tail_page: log->next_page = nextpage_off; } - /* Remember if we wrapped the log file */ + /* 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 + * Also remember the last known lsn. */ page_cnt = le16_to_cpu(page->page_count); page_pos = le16_to_cpu(page->page_pos); @@ -2067,19 +2064,19 @@ check_tail: log->l_flags |= NTFSLOG_WRAPPED; } - /* Remember that the partial IO will start at the next page */ + /* 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 + * 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 + * immediately look at the next page. */ if (replace_page || (log->ra->flags & RESTART_SINGLE_PAGE_IO)) { page_cnt = 2; @@ -2105,19 +2102,19 @@ next_test_page: kfree(tst_page); tst_page = NULL; - /* Walk through the file, reading log pages */ + /* 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 + * 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 + * is the same or different Io block. */ if (err) goto next_test_page_1; @@ -2148,7 +2145,7 @@ next_test_page_1: goto next_test_page; check_valid: - /* Skip over the remaining pages this transfer */ + /* Skip over the remaining pages this transfer. */ remain_pages = page_cnt - page_pos - 1; part_io_count += remain_pages; @@ -2160,7 +2157,7 @@ check_valid: expected_seq += 1; } - /* Call our routine to check this log page */ + /* Call our routine to check this log page. */ kfree(tst_page); tst_page = NULL; @@ -2173,7 +2170,7 @@ check_valid: file_is_valid: - /* We have a valid file */ + /* We have a valid file. */ if (page_off1 || tail_page) { struct RECORD_PAGE_HDR *tmp_page; @@ -2203,11 +2200,11 @@ file_is_valid: /* * Correct page and copy the data from this page - * into it and flush it to disk + * into it and flush it to disk. */ memcpy(page, tmp_page, log->page_size); - /* Fill last flushed lsn value flush the page */ + /* Fill last flushed lsn value flush the page. */ if (log->major_ver < 2) page->rhdr.lsn = page->record_hdr.last_end_lsn; else @@ -2251,10 +2248,9 @@ out: } /* - * read_log_rec_buf + * read_log_rec_buf - Copy a log record from the file to a buffer. * - * copies a log record from the file to a buffer - * The log record may span several log pages and may even wrap the file + * 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) @@ -2268,7 +2264,7 @@ static int read_log_rec_buf(struct ntfs_log *log, /* * While there are more bytes to transfer, - * we continue to attempt to perform the read + * we continue to attempt to perform the read. */ for (;;) { bool usa_error; @@ -2285,7 +2281,7 @@ static int read_log_rec_buf(struct ntfs_log *log, /* * The last lsn on this page better be greater or equal - * to the lsn we are copying + * to the lsn we are copying. */ if (lsn > le64_to_cpu(ph->rhdr.lsn)) { err = -EINVAL; @@ -2294,7 +2290,7 @@ static int read_log_rec_buf(struct ntfs_log *log, memcpy(buffer, Add2Ptr(ph, off), tail); - /* If there are no more bytes to transfer, we exit the loop */ + /* 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)) { @@ -2314,8 +2310,8 @@ static int read_log_rec_buf(struct ntfs_log *log, off = log->data_off; /* - * adjust our pointer the user's buffer to transfer - * the next block to + * Adjust our pointer the user's buffer to transfer + * the next block to. */ buffer = Add2Ptr(buffer, tail); } @@ -2339,7 +2335,7 @@ static int read_rst_area(struct ntfs_log *log, struct NTFS_RESTART **rst_, *lsn = 0; *rst_ = NULL; - /* If the client doesn't have a restart area, go ahead and exit now */ + /* If the client doesn't have a restart area, go ahead and exit now. */ if (!lsnc) return 0; @@ -2352,7 +2348,7 @@ static int read_rst_area(struct ntfs_log *log, struct NTFS_RESTART **rst_, lsnr = le64_to_cpu(rh->this_lsn); if (lsnc != lsnr) { - /* If the lsn values don't match, then the disk is corrupt */ + /* If the lsn values don't match, then the disk is corrupt. */ err = -EINVAL; goto out; } @@ -2376,7 +2372,7 @@ static int read_rst_area(struct ntfs_log *log, struct NTFS_RESTART **rst_, goto out; } - /* Copy the data into the 'rst' buffer */ + /* Copy the data into the 'rst' buffer. */ err = read_log_rec_buf(log, rh, rst); if (err) goto out; @@ -2397,7 +2393,7 @@ static int find_log_rec(struct ntfs_log *log, u64 lsn, struct lcb *lcb) struct LFS_RECORD_HDR *rh = lcb->lrh; u32 rec_len, len; - /* Read the record header for this lsn */ + /* 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); @@ -2409,7 +2405,7 @@ static int find_log_rec(struct ntfs_log *log, u64 lsn, struct lcb *lcb) /* * If the lsn the log record doesn't match the desired - * lsn then the disk is corrupt + * lsn then the disk is corrupt. */ if (lsn != le64_to_cpu(rh->this_lsn)) return -EINVAL; @@ -2417,8 +2413,8 @@ static int find_log_rec(struct ntfs_log *log, u64 lsn, struct lcb *lcb) len = le32_to_cpu(rh->client_data_len); /* - * check that the length field isn't greater than the total - * available space the log file + * 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) @@ -2426,7 +2422,7 @@ static int find_log_rec(struct ntfs_log *log, u64 lsn, struct lcb *lcb) /* * If the entire log record is on this log page, - * put a pointer to the log record the context block + * put a pointer to the log record the context block. */ if (rh->flags & LOG_RECORD_MULTI_PAGE) { void *lr = kmalloc(len, GFP_NOFS); @@ -2437,12 +2433,12 @@ static int find_log_rec(struct ntfs_log *log, u64 lsn, struct lcb *lcb) lcb->log_rec = lr; lcb->alloc = true; - /* Copy the data into the buffer returned */ + /* 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 */ + /* 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) @@ -2456,9 +2452,7 @@ static int find_log_rec(struct ntfs_log *log, u64 lsn, struct lcb *lcb) } /* - * read_log_rec_lcb - * - * initiates the query operation. + * 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_) @@ -2476,7 +2470,7 @@ static int read_log_rec_lcb(struct ntfs_log *log, u64 lsn, u32 ctx_mode, return -EINVAL; } - /* check that the given lsn is the legal range for this client */ + /* 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)) @@ -2488,7 +2482,7 @@ static int read_log_rec_lcb(struct ntfs_log *log, u64 lsn, u32 ctx_mode, lcb->client = log->client_id; lcb->ctx_mode = ctx_mode; - /* Find the log record indicated by the given lsn */ + /* Find the log record indicated by the given lsn. */ err = find_log_rec(log, lsn, lcb); if (err) goto out; @@ -2505,7 +2499,7 @@ out: /* * find_client_next_lsn * - * attempt to find the next lsn to return to a client based on the context mode. + * 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) { @@ -2519,7 +2513,7 @@ static int find_client_next_lsn(struct ntfs_log *log, struct lcb *lcb, u64 *lsn) if (lcb_ctx_next != lcb->ctx_mode) goto check_undo_next; - /* Loop as long as another lsn can be found */ + /* Loop as long as another lsn can be found. */ for (;;) { u64 current_lsn; @@ -2705,7 +2699,7 @@ static inline bool check_attr(const struct MFT_REC *rec, u64 dsize, svcn, evcn; u16 run_off; - /* Check the fixed part of the attribute record header */ + /* Check the fixed part of the attribute record header. */ if (asize >= sbi->record_size || asize + PtrOffset(rec, attr) >= sbi->record_size || (attr->name_len && @@ -2714,7 +2708,7 @@ static inline bool check_attr(const struct MFT_REC *rec, return false; } - /* Check the attribute fields */ + /* Check the attribute fields. */ switch (attr->non_res) { case 0: rsize = le32_to_cpu(attr->res.data_size); @@ -2797,7 +2791,7 @@ static inline bool check_file_record(const struct MFT_REC *rec, u16 ao = le16_to_cpu(rec->attr_off); u32 rs = sbi->record_size; - /* check the file record header for consistency */ + /* 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 || @@ -2806,7 +2800,7 @@ static inline bool check_file_record(const struct MFT_REC *rec, return false; } - /* Loop to check all of the attributes */ + /* 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)) @@ -2959,7 +2953,11 @@ struct OpenAttr { // CLST rno; }; -/* Returns 0 if 'attr' has the same type and name */ +/* + * 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) { @@ -3032,10 +3030,8 @@ static struct ATTRIB *attr_create_nonres_log(struct ntfs_sb_info *sbi, } /* - * do_action - * - * common routine for the Redo and Undo Passes - * If rlsn is NULL then undo + * 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, @@ -3072,10 +3068,10 @@ static int do_action(struct ntfs_log *log, struct OPEN_ATTR_ENRTY *oe, oa = oe->ptr; - /* Big switch to prepare */ + /* Big switch to prepare. */ switch (op) { /* ============================================================ - * Process MFT records, as described by the current log record + * Process MFT records, as described by the current log record. * ============================================================ */ case InitializeFileRecordSegment: @@ -3104,7 +3100,7 @@ static int do_action(struct ntfs_log *log, struct OPEN_ATTR_ENRTY *oe, if (err) goto out; } else { - /* read from disk */ + /* Read from disk. */ err = mi_get(sbi, rno, &mi); if (err) return err; @@ -3161,9 +3157,8 @@ skip_load_parent: inode_parent = NULL; break; - /* ============================================================ - * Process attributes, as described by the current log record - * ============================================================ + /* + * Process attributes, as described by the current log record. */ case UpdateNonresidentValue: case AddIndexEntryAllocation: @@ -3208,7 +3203,7 @@ skip_load_parent: WARN_ON(1); } - /* Big switch to do operation */ + /* Big switch to do operation. */ switch (op) { case InitializeFileRecordSegment: if (roff + dlen > record_size) @@ -3311,7 +3306,7 @@ skip_load_parent: if (nsize < asize) { memmove(Add2Ptr(attr, aoff), data, dlen); - data = NULL; // To skip below memmove + data = NULL; // To skip below memmove(). } memmove(Add2Ptr(attr, nsize), Add2Ptr(attr, asize), @@ -3734,11 +3729,11 @@ dirty_vol: } /* - * log_replay + * 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' + * 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) { @@ -3784,7 +3779,7 @@ int log_replay(struct ntfs_inode *ni, bool *initialized) u16 t16; u32 t32; - /* Get the size of page. NOTE: To replay we can use default page */ + /* 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 @@ -3810,7 +3805,7 @@ int log_replay(struct ntfs_inode *ni, bool *initialized) log->page_mask = page_size - 1; log->page_bits = blksize_bits(page_size); - /* Look for a restart area on the disk */ + /* Look for a restart area on the disk. */ err = log_read_rst(log, l_size, true, &rst_info); if (err) goto out; @@ -3820,7 +3815,7 @@ int log_replay(struct ntfs_inode *ni, bool *initialized) if (!rst_info.restart) { if (rst_info.initialized) { - /* no restart area but the file is not initialized */ + /* No restart area but the file is not initialized. */ err = -EINVAL; goto out; } @@ -3843,14 +3838,14 @@ int log_replay(struct ntfs_inode *ni, bool *initialized) /* * If the restart offset above wasn't zero then we won't - * look for a second restart + * look for a second restart. */ if (rst_info.vbo) goto check_restart_area; err = log_read_rst(log, l_size, false, &rst_info2); - /* Determine which restart area to use */ + /* Determine which restart area to use. */ if (!rst_info2.restart || rst_info2.last_lsn <= rst_info.last_lsn) goto use_first_page; @@ -3877,10 +3872,13 @@ 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 */ + /* + * 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 */ + /* 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)) @@ -3892,7 +3890,7 @@ check_restart_area: bool use_multi_page = false; u32 open_log_count; - /* Do some checks based on whether we have a valid log page */ + /* 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; @@ -3901,7 +3899,7 @@ check_restart_area: /* * If the restart page size isn't changing then we want to - * check how much work we need to do + * 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; @@ -3919,7 +3917,9 @@ init_log_instance: } log->ra = ra; - /* Put the restart areas and initialize the log file as required */ + /* Put the restart areas and initialize + * the log file as required. + */ goto process_log; } @@ -3929,9 +3929,9 @@ init_log_instance: } /* - * 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 + * 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) { @@ -3946,7 +3946,7 @@ init_log_instance: goto out; } - /* If the file size has shrunk then we won't mount it */ + /* 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; @@ -3973,27 +3973,30 @@ init_log_instance: vbo = lsn_to_vbo(log, log->last_lsn); if (vbo < log->first_page) { - /* This is a pseudo lsn */ + /* 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 */ + /* 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 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 */ + /* 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 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; @@ -4002,7 +4005,10 @@ init_log_instance: } find_oldest: - /* Find the oldest client lsn. Use the last flushed lsn as a starting point */ + /* + * 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); @@ -4048,18 +4054,18 @@ find_oldest: le32_add_cpu(&ra->open_log_count, 1); - /* Now we need to walk through looking for the last lsn */ + /* 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 */ + /* 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 */ + /* 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: @@ -4073,12 +4079,12 @@ process_log: goto out; } - /* One client "NTFS" per logfile */ + /* 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 */ + /* Insert "NTFS" client LogFile. */ client = ra->client_idx[0]; if (client == LFS_NO_CLIENT_LE) return -EINVAL; @@ -4110,7 +4116,7 @@ process_log: break; } - /* Update the client handle with the client block information */ + /* Update the client handle with the client block information. */ log->client_id.seq_num = cr->seq_num; log->client_id.client_idx = client; @@ -4127,7 +4133,7 @@ process_log: if (!checkpt_lsn) checkpt_lsn = ra_lsn; - /* Allocate and Read the Transaction Table */ + /* Allocate and Read the Transaction Table. */ if (!rst->transact_table_len) goto check_dirty_page_table; @@ -4151,7 +4157,7 @@ process_log: rt = Add2Ptr(lrh, t16); t32 = rec_len - t16; - /* Now check that this is a valid restart table */ + /* Now check that this is a valid restart table. */ if (!check_rstbl(rt, t32)) { err = -EINVAL; goto out; @@ -4167,7 +4173,7 @@ process_log: lcb = NULL; check_dirty_page_table: - /* The next record back should be the Dirty Pages Table */ + /* The next record back should be the Dirty Pages Table. */ if (!rst->dirty_pages_len) goto check_attribute_names; @@ -4191,7 +4197,7 @@ check_dirty_page_table: rt = Add2Ptr(lrh, t16); t32 = rec_len - t16; - /* Now check that this is a valid restart table */ + /* Now check that this is a valid restart table. */ if (!check_rstbl(rt, t32)) { err = -EINVAL; goto out; @@ -4203,14 +4209,14 @@ check_dirty_page_table: goto out; } - /* Convert Ra version '0' into version '1' */ + /* 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 + // NOTE: Danger. Check for of boundary. memmove(&dp->vcn, &dp0->vcn_low, 2 * sizeof(u64) + le32_to_cpu(dp->lcns_follow) * sizeof(u64)); @@ -4220,7 +4226,10 @@ end_conv_1: lcb_put(lcb); lcb = NULL; - /* Go through the table and remove the duplicates, remembering the oldest lsn values */ + /* + * Go through the table and remove the duplicates, + * remembering the oldest lsn values. + */ if (sbi->cluster_size <= log->page_size) goto trace_dp_table; @@ -4242,7 +4251,7 @@ end_conv_1: } trace_dp_table: check_attribute_names: - /* The next record should be the Attribute Names */ + /* The next record should be the Attribute Names. */ if (!rst->attr_names_len) goto check_attr_table; @@ -4270,7 +4279,7 @@ check_attribute_names: lcb = NULL; check_attr_table: - /* The next record should be the attribute Table */ + /* The next record should be the attribute Table. */ if (!rst->open_attr_len) goto check_attribute_names2; @@ -4307,13 +4316,13 @@ check_attr_table: log->open_attr_tbl = oatbl; - /* Clear all of the Attr pointers */ + /* 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 */ + /* Really 'oe' points to OPEN_ATTR_ENRTY_32. */ memcpy(&oe0, oe, SIZEOF_OPENATTRIBUTEENTRY0); oe->bytes_per_index = oe0.bytes_per_index; @@ -4351,7 +4360,7 @@ check_attribute_names2: trace_attribute_table: /* * If the checkpt_lsn is zero, then this is a freshly - * formatted disk and we have no work to do + * formatted disk and we have no work to do. */ if (!checkpt_lsn) { err = 0; @@ -4371,12 +4380,12 @@ trace_attribute_table: /* Start the analysis pass from the Checkpoint lsn. */ rec_lsn = checkpt_lsn; - /* Read the first 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 */ + /* 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) @@ -4397,7 +4406,7 @@ next_log_record_analyze: /* * The first lsn after the previous lsn remembered - * the checkpoint is the first candidate for the rlsn + * the checkpoint is the first candidate for the rlsn. */ if (!rlsn) rlsn = rec_lsn; @@ -4406,8 +4415,8 @@ next_log_record_analyze: 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 + * 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), @@ -4435,12 +4444,12 @@ next_log_record_analyze: /* * If this is a compensation log record, then change - * the undo_next_lsn to be the undo_next_lsn of this record + * 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 */ + /* Dispatch to handle log record depending on type. */ switch (le16_to_cpu(lrh->redo_op)) { case InitializeFileRecordSegment: case DeallocateFileRecordSegment: @@ -4474,7 +4483,7 @@ next_log_record_analyze: /* * Calculate the number of clusters per page the system - * which wrote the checkpoint, possibly creating the table + * which wrote the checkpoint, possibly creating the table. */ if (dptbl) { t32 = (le16_to_cpu(dptbl->size) - @@ -4504,9 +4513,9 @@ next_log_record_analyze: 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 + * 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++) { @@ -4523,7 +4532,7 @@ copy_lcns: const struct LCN_RANGE *r = Add2Ptr(lrh, le16_to_cpu(lrh->redo_off)); - /* Loop through all of the Lcn ranges this log record */ + /* 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; @@ -4549,7 +4558,7 @@ copy_lcns: if (t16 >= bytes_per_rt(oatbl)) { /* * Compute how big the table needs to be. - * Add 10 extra entries for some cushion + * Add 10 extra entries for some cushion. */ u32 new_e = t16 / le16_to_cpu(oatbl->size); @@ -4563,7 +4572,7 @@ copy_lcns: } } - /* Point to the entry being opened */ + /* Point to the entry being opened. */ oe = alloc_rsttbl_from_idx(&oatbl, t16); log->open_attr_tbl = oatbl; if (!oe) { @@ -4571,10 +4580,10 @@ copy_lcns: goto out; } - /* Initialize this entry from the log record */ + /* Initialize this entry from the log record. */ t16 = le16_to_cpu(lrh->redo_off); if (!rst->major_ver) { - /* Convert version '0' into version '1' */ + /* Convert version '0' into version '1'. */ struct OPEN_ATTR_ENRTY_32 *oe0 = Add2Ptr(lrh, t16); oe->bytes_per_index = oe0->bytes_per_index; @@ -4642,13 +4651,13 @@ copy_lcns: case AttributeNamesDump: case DirtyPageTableDump: case TransactionTableDump: - /* The following cases require no action the Analysis Pass */ + /* 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 + * If we see a code we do not expect, then we are trouble. */ goto next_log_record_analyze; } @@ -4659,7 +4668,7 @@ end_log_records_enumerate: /* * Scan the Dirty Page Table and Transaction Table for - * the lowest lsn, and return it as the Redo lsn + * the lowest lsn, and return it as the Redo lsn. */ dp = NULL; while ((dp = enum_rstbl(dptbl, dp))) { @@ -4675,7 +4684,10 @@ end_log_records_enumerate: rlsn = t64; } - /* Only proceed if the Dirty Page Table or Transaction table are not empty */ + /* + * Only proceed if the Dirty Page Table or Transaction + * table are not empty. + */ if ((!dptbl || !dptbl->total) && (!trtbl || !trtbl->total)) goto end_reply; @@ -4683,7 +4695,7 @@ end_log_records_enumerate: if (is_ro) goto out; - /* Reopen all of the attributes with dirty pages */ + /* Reopen all of the attributes with dirty pages. */ oe = NULL; next_open_attribute: @@ -4779,8 +4791,8 @@ final_oe: 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 + * 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); @@ -4834,8 +4846,8 @@ 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 + * 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; @@ -4844,15 +4856,15 @@ do_redo_1: /* * Read the record at the Redo lsn, before falling - * into common code to handle each record + * 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 + * 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; @@ -4869,7 +4881,7 @@ do_action_next: goto out; } - /* Ignore log records that do not update pages */ + /* Ignore log records that do not update pages. */ if (lrh->lcns_follow) goto find_dirty_page; @@ -4914,11 +4926,11 @@ find_dirty_page: goto read_next_log_do_action; } - /* Point to the Redo data and get its length */ + /* 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 */ + /* Shorten length by any Lcns which were deleted. */ saved_len = dlen; for (i = le16_to_cpu(lrh->lcns_follow); i; i--) { @@ -4929,7 +4941,7 @@ find_dirty_page: 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.*/ + /* 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; @@ -4939,13 +4951,13 @@ find_dirty_page: /* * Calculate the allocated space left relative to the - * log record Vcn, after removing this unallocated Vcn + * 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 + * the allocated space, then we will have to reduce the length. */ if (voff >= alen) dlen = 0; @@ -4953,7 +4965,10 @@ find_dirty_page: dlen = alen - voff; } - /* If the resulting dlen from above is now zero, we can skip this log record */ + /* + * 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; @@ -4961,12 +4976,12 @@ find_dirty_page: if (can_skip_action(t16)) goto read_next_log_do_action; - /* Apply the Redo operation a common routine */ + /* 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 */ + /* 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) @@ -4976,7 +4991,7 @@ read_next_log_do_action: lcb = NULL; do_undo_action: - /* Scan Transaction Table */ + /* Scan Transaction Table. */ tr = NULL; transaction_table_next: tr = enum_rstbl(trtbl, tr); @@ -4993,19 +5008,19 @@ transaction_table_next: /* * We only have to do anything if the transaction has - * something its undo_next_lsn field + * something its undo_next_lsn field. */ if (!undo_next_lsn) goto commit_undo; - /* Read the first record to be undone by this transaction */ + /* 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 + * until we hit the end of the file, cleaning up at the end. */ undo_action_next: @@ -5035,7 +5050,7 @@ undo_action_next: /* * 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 + * there is no partial page already memory. */ if (is_mapped && lcn != SPARSE_LCN && clen >= t16) goto add_allocated_vcns; @@ -5063,17 +5078,17 @@ add_allocated_vcns: if (can_skip_action(t16)) goto read_next_log_undo_action; - /* Point to the Redo data and get its length */ + /* 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 */ + /* 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 + * last record for this transaction. */ err = read_next_log_rec(log, lcb, &rec_lsn); if (err) @@ -5148,7 +5163,10 @@ out: if (lcb) lcb_put(lcb); - /* Scan the Open Attribute Table to close all of the open attributes */ + /* + * 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); |