Lines Matching refs:log
29 __le32 sys_page_size; // 0x10: Page size of the system which initialized the log.
30 __le32 page_size; // 0x14: Log page size used for this log file.
53 /* Two copies of these will exist at the beginning of the log file */
55 __le64 current_lsn; // 0x00: Current logical end of log file.
62 __le64 l_size; // 0x18: Usable log file size.
193 __le32 undo_records; // 0x20: Number of undo log records pending abort
232 /* The following type defines the different log record types. */
236 /* This is used to uniquely identify a client for a particular log file. */
242 /* This is the header that begins every Log Record in the log file. */
248 struct CLIENT_ID client; // 0x1C: Owner of this log record.
262 __le64 last_end_lsn; // 0x08: lsn for the last log record which ends on the page,
279 // Page contains the end of a log record.
341 * Array for log records which require a target attribute.
511 /* Make sure the sequence number bits match the log file size. */
523 /* The log page data offset and record header length must be quad-aligned. */
1079 static inline u32 lsn_to_vbo(struct ntfs_log *log, const u64 lsn)
1081 u32 vbo = (lsn << log->seq_num_bits) >> (log->seq_num_bits - 3);
1086 /* Compute the offset in the log file of the next log page. */
1087 static inline u32 next_page_off(struct ntfs_log *log, u32 off)
1089 off = (off & ~log->sys_page_mask) + log->page_size;
1090 return off >= log->l_size ? log->first_page : off;
1093 static inline u32 lsn_to_page_off(struct ntfs_log *log, u64 lsn)
1095 return (((u32)lsn) << 3) & log->page_mask;
1098 static inline u64 vbo_to_lsn(struct ntfs_log *log, u32 off, u64 Seq)
1100 return (off >> 3) + (Seq << log->file_data_bits);
1103 static inline bool is_lsn_in_file(struct ntfs_log *log, u64 lsn)
1105 return lsn >= log->oldest_lsn &&
1106 lsn <= le64_to_cpu(log->ra->current_lsn);
1109 static inline u32 hdr_file_off(struct ntfs_log *log,
1112 if (log->major_ver < 2)
1118 static inline u64 base_lsn(struct ntfs_log *log,
1122 u64 ret = (((h_lsn >> log->file_data_bits) +
1123 (lsn < (lsn_to_vbo(log, h_lsn) & ~log->page_mask) ? 1 : 0))
1124 << log->file_data_bits) +
1128 log->page_size) +
1135 static inline bool verify_client_lsn(struct ntfs_log *log,
1139 lsn <= le64_to_cpu(log->ra->current_lsn) && lsn;
1142 static int read_log_page(struct ntfs_log *log, u32 vbo,
1146 u32 page_idx = vbo >> log->page_bits;
1147 u32 page_off = vbo & log->page_mask;
1148 u32 bytes = log->page_size - page_off;
1150 u32 page_vbo = page_idx << log->page_bits;
1152 struct ntfs_inode *ni = log->ni;
1155 if (vbo >= log->l_size)
1159 to_free = kmalloc(log->page_size, GFP_NOFS);
1165 page_buf = page_off ? log->one_page_buf : *buffer;
1168 log->page_size, NULL);
1203 static int log_read_rst(struct ntfs_log *log, bool first,
1220 for (; vbo < log->l_size; vbo = 2 * vbo + skip, skip = 0) {
1226 if (read_log_page(log, vbo, (struct RECORD_PAGE_HDR **)&r_page,
1232 /* Exit if the signature is a log record page. */
1311 * Ilog_init_pg_hdr - Init @log from restart page header.
1313 static void log_init_pg_hdr(struct ntfs_log *log, u16 major_ver, u16 minor_ver)
1315 log->sys_page_size = log->page_size;
1316 log->sys_page_mask = log->page_mask;
1318 log->clst_per_page = log->page_size >> log->ni->mi.sbi->cluster_bits;
1319 if (!log->clst_per_page)
1320 log->clst_per_page = 1;
1322 log->first_page = major_ver >= 2 ? 0x22 * log->page_size :
1323 4 * log->page_size;
1324 log->major_ver = major_ver;
1325 log->minor_ver = minor_ver;
1329 * log_create - Init @log in cases when we don't have a restart area to use.
1331 static void log_create(struct ntfs_log *log, const u64 last_lsn,
1335 log->file_data_bits = blksize_bits(log->l_size) - 3;
1336 log->seq_num_mask = (8 << log->file_data_bits) - 1;
1337 log->seq_num_bits = sizeof(u64) * 8 - log->file_data_bits;
1338 log->seq_num = (last_lsn >> log->file_data_bits) + 2;
1339 log->next_page = log->first_page;
1340 log->oldest_lsn = log->seq_num << log->file_data_bits;
1341 log->oldest_lsn_off = 0;
1342 log->last_lsn = log->oldest_lsn;
1344 log->l_flags |= NTFSLOG_NO_LAST_LSN | NTFSLOG_NO_OLDEST_LSN;
1348 log->l_flags |= NTFSLOG_WRAPPED;
1351 log->l_flags |= NTFSLOG_MULTIPLE_PAGE_IO;
1353 /* Compute the log page values. */
1354 log->data_off = ALIGN(
1356 sizeof(short) * ((log->page_size >> SECTOR_SHIFT) + 1),
1358 log->data_size = log->page_size - log->data_off;
1359 log->record_header_len = sizeof(struct LFS_RECORD_HDR);
1362 log->reserved = log->data_size - log->record_header_len;
1365 log->ra_off = ALIGN(
1368 ((log->sys_page_size >> SECTOR_SHIFT) + 1),
1370 log->restart_size = log->sys_page_size - log->ra_off;
1371 log->ra_size = struct_size(log->ra, clients, 1);
1372 log->current_openlog_count = open_log_count;
1375 * The total available log file space is the number of
1376 * log file pages times the space available on each page.
1378 log->total_avail_pages = log->l_size - log->first_page;
1379 log->total_avail = log->total_avail_pages >> log->page_bits;
1386 log->max_current_avail = log->total_avail * log->reserved;
1387 log->total_avail = log->total_avail * log->data_size;
1388 log->current_avail = log->max_current_avail;
1392 * log_create_ra - Fill a restart area from the values stored in @log.
1394 static struct RESTART_AREA *log_create_ra(struct ntfs_log *log)
1397 struct RESTART_AREA *ra = kzalloc(log->restart_size, GFP_NOFS);
1402 ra->current_lsn = cpu_to_le64(log->last_lsn);
1405 if (log->l_flags & NTFSLOG_MULTIPLE_PAGE_IO)
1407 ra->seq_num_bits = cpu_to_le32(log->seq_num_bits);
1408 ra->ra_len = cpu_to_le16(log->ra_size);
1410 ra->l_size = cpu_to_le64(log->l_size);
1411 ra->rec_hdr_len = cpu_to_le16(log->record_header_len);
1412 ra->data_off = cpu_to_le16(log->data_off);
1413 ra->open_log_count = cpu_to_le32(log->current_openlog_count + 1);
1423 static u32 final_log_off(struct ntfs_log *log, u64 lsn, u32 data_len)
1426 u32 final_log_off = (base_vbo & log->seq_num_mask) & ~log->page_mask;
1427 u32 page_off = base_vbo & log->page_mask;
1428 u32 tail = log->page_size - page_off;
1433 data_len += log->record_header_len;
1436 * If this lsn is contained this log page we are done.
1437 * Otherwise we need to walk through several log pages.
1441 tail = log->data_size;
1442 page_off = log->data_off - 1;
1445 final_log_off = next_page_off(log, final_log_off);
1459 * and then add that value to the file offset of this log page.
1464 static int next_log_lsn(struct ntfs_log *log, const struct LFS_RECORD_HDR *rh,
1469 u32 vbo = lsn_to_vbo(log, this_lsn);
1471 final_log_off(log, this_lsn, le32_to_cpu(rh->client_data_len));
1472 u32 hdr_off = end & ~log->sys_page_mask;
1473 u64 seq = this_lsn >> log->file_data_bits;
1481 err = read_log_page(log, hdr_off, &page, NULL);
1493 hdr_off = next_page_off(log, hdr_off);
1494 if (hdr_off == log->first_page)
1497 vbo = hdr_off + log->data_off;
1503 *lsn = vbo_to_lsn(log, vbo, seq);
1509 if (!is_lsn_in_file(log, *lsn))
1518 * current_log_avail - Calculate the number of bytes available for log records.
1520 static u32 current_log_avail(struct ntfs_log *log)
1524 if (log->l_flags & NTFSLOG_NO_LAST_LSN) {
1526 return log->max_current_avail;
1534 oldest_off = (log->l_flags & NTFSLOG_NO_OLDEST_LSN) ?
1535 log->first_page :
1536 (log->oldest_lsn_off & ~log->sys_page_mask);
1539 * We will use the next log page offset to compute the next free page.
1543 next_free_off = (log->l_flags & NTFSLOG_REUSE_TAIL) ?
1544 log->next_page + log->page_size :
1545 log->next_page == log->first_page ? log->l_size :
1546 log->next_page;
1557 log->total_avail_pages - (next_free_off - oldest_off) :
1560 free_bytes >>= log->page_bits;
1561 return free_bytes * log->reserved;
1564 static bool check_subseq_log_page(struct ntfs_log *log,
1579 lsn_seq = lsn >> log->file_data_bits;
1586 (lsn_seq == seq - 1 && log->first_page == vbo &&
1587 vbo != (lsn_to_vbo(log, lsn) & ~log->page_mask));
1593 * Walks through the log pages for a file, searching for the
1594 * last log page written to the file.
1596 static int last_log_lsn(struct ntfs_log *log)
1601 bool reuse_page = log->l_flags & NTFSLOG_REUSE_TAIL;
1615 u64 last_ok_lsn = reuse_page ? log->last_lsn : 0;
1629 if (log->major_ver >= 2) {
1630 final_off = 0x02 * log->page_size;
1631 second_off = 0x12 * log->page_size;
1634 page_bufs = kmalloc(log->page_size * 0x10, GFP_NOFS);
1638 second_off = log->first_page - log->page_size;
1639 final_off = second_off - log->page_size;
1644 if (read_log_page(log, second_off, &second_tail, &usa_error) ||
1651 second_file_off = hdr_file_off(log, second_tail);
1656 if (read_log_page(log, final_off, &first_tail, &usa_error) ||
1663 first_file_off = hdr_file_off(log, first_tail);
1667 if (log->major_ver < 2) {
1687 seq_base = (best_page ? lsn2 : lsn1) >> log->file_data_bits;
1691 best_lsn1 = first_tail ? base_lsn(log, first_tail, first_file_off) : 0;
1692 best_lsn2 = second_tail ? base_lsn(log, second_tail, second_file_off) :
1721 seq_base = best_lsn >> log->file_data_bits;
1725 memmove(page_bufs, best_page, log->page_size);
1733 } else if (seq_base == (best_lsn >> log->file_data_bits) &&
1734 saved_off + log->page_size == this_off &&
1741 saved_off += log->page_size;
1744 memmove(Add2Ptr(page_bufs, tails * log->page_size), best_page,
1745 log->page_size);
1774 final_off += log->page_size;
1775 second_off += log->page_size;
1788 curpage_off = seq_base == log->seq_num ? min(log->next_page, page_off) :
1789 log->next_page;
1792 curpage_off == log->first_page &&
1793 !(log->l_flags & (NTFSLOG_NO_LAST_LSN | NTFSLOG_REUSE_TAIL));
1795 expected_seq = wrapped_file ? (log->seq_num + 1) : log->seq_num;
1801 /* Read the next log page. */
1802 err = read_log_page(log, curpage_off, &page, &usa_error);
1804 /* Compute the next log page offset the file. */
1805 nextpage_off = next_page_off(log, curpage_off);
1806 wrapped = nextpage_off == log->first_page;
1845 ((lsn_cur >> log->file_data_bits) +
1847 (lsn_to_vbo(log, lsn_cur) & ~log->page_mask)) ?
1859 log->seq_num = expected_seq;
1860 log->l_flags &= ~NTFSLOG_NO_LAST_LSN;
1861 log->last_lsn = le64_to_cpu(cur_page->record_hdr.last_end_lsn);
1862 log->ra->current_lsn = cur_page->record_hdr.last_end_lsn;
1864 if (log->record_header_len <=
1865 log->page_size -
1867 log->l_flags |= NTFSLOG_REUSE_TAIL;
1868 log->next_page = curpage_off;
1870 log->l_flags &= ~NTFSLOG_REUSE_TAIL;
1871 log->next_page = nextpage_off;
1875 log->l_flags |= NTFSLOG_WRAPPED;
1920 if (expected_seq != (lsn_cur >> log->file_data_bits))
1944 expected_seq != (lsn_cur >> log->file_data_bits)) {
1993 log->seq_num = expected_seq;
1994 log->last_lsn = le64_to_cpu(page->record_hdr.last_end_lsn);
1995 log->ra->current_lsn = page->record_hdr.last_end_lsn;
1996 log->l_flags &= ~NTFSLOG_NO_LAST_LSN;
2002 if (log->record_header_len <=
2003 log->page_size -
2005 log->l_flags |= NTFSLOG_REUSE_TAIL;
2006 log->next_page = curpage_off;
2008 log->l_flags &= ~NTFSLOG_REUSE_TAIL;
2009 log->next_page = nextpage_off;
2012 /* Remember if we wrapped the log file. */
2014 log->l_flags |= NTFSLOG_WRAPPED;
2040 log->seq_num = expected_seq;
2041 log->last_lsn = le64_to_cpu(tail_page->record_hdr.last_end_lsn);
2042 log->ra->current_lsn = tail_page->record_hdr.last_end_lsn;
2043 log->l_flags &= ~NTFSLOG_NO_LAST_LSN;
2045 if (log->page_size -
2048 log->record_header_len) {
2049 log->l_flags |= NTFSLOG_REUSE_TAIL;
2050 log->next_page = curpage_off;
2052 log->l_flags &= ~NTFSLOG_REUSE_TAIL;
2053 log->next_page = nextpage_off;
2057 log->l_flags |= NTFSLOG_WRAPPED;
2065 * the sequence number for log records which begon the next page.
2074 if (replace_page || (log->ra->flags & RESTART_SINGLE_PAGE_IO)) {
2083 * If the next page causes us to wrap to the beginning of the log
2098 /* Walk through the file, reading log pages. */
2099 err = read_log_page(log, nextpage_off, &tst_page, &usa_error);
2116 check_subseq_log_page(log, tst_page, nextpage_off, expected_seq)) {
2126 nextpage_off = next_page_off(log, curpage_off);
2127 wrapped = nextpage_off == log->first_page;
2146 nextpage_off = next_page_off(log, curpage_off);
2147 wrapped = nextpage_off == log->first_page;
2153 /* Call our routine to check this log page. */
2157 err = read_log_page(log, nextpage_off, &tst_page, &usa_error);
2159 check_subseq_log_page(log, tst_page, nextpage_off, expected_seq)) {
2170 if (sb_rdonly(log->ni->mi.sbi->sb)) {
2177 tails -= (page_off1 - page_off) / log->page_size;
2186 u64 off = hdr_file_off(log, tmp_page);
2189 page = kmalloc(log->page_size, GFP_NOFS);
2200 memcpy(page, tmp_page, log->page_size);
2203 if (log->major_ver < 2)
2210 ntfs_fix_pre_write(&page->rhdr, log->page_size);
2212 err = ntfs_sb_write_run(log->ni->mi.sbi,
2213 &log->ni->file.run, off, page,
2214 log->page_size, 0);
2220 second_off += log->page_size;
2224 tmp_page = Add2Ptr(tmp_page, log->page_size);
2229 if (sb_rdonly(log->ni->mi.sbi->sb)) {
2246 * read_log_rec_buf - Copy a log record from the file to a buffer.
2248 * The log record may span several log pages and may even wrap the file.
2250 static int read_log_rec_buf(struct ntfs_log *log,
2256 u32 vbo = lsn_to_vbo(log, lsn) & ~log->page_mask;
2257 u32 off = lsn_to_page_off(log, lsn) + log->record_header_len;
2266 u32 tail = log->page_size - off;
2273 err = read_log_page(log, vbo, &ph, &usa_error);
2304 vbo = next_page_off(log, vbo);
2305 off = log->data_off;
2319 static int read_rst_area(struct ntfs_log *log, struct NTFS_RESTART **rst_,
2325 Add2Ptr(log->ra, le16_to_cpu(log->ra->client_off));
2337 err = read_log_page(log, lsn_to_vbo(log, lsnc),
2371 err = read_log_rec_buf(log, rh, rst);
2385 static int find_log_rec(struct ntfs_log *log, u64 lsn, struct lcb *lcb)
2393 err = read_log_page(log, lsn_to_vbo(log, lsn),
2402 * If the lsn the log record doesn't match the desired
2412 * available space the log file.
2414 rec_len = len + log->record_header_len;
2415 if (rec_len >= log->total_avail)
2419 * If the entire log record is on this log page,
2420 * put a pointer to the log record the context block.
2432 err = read_log_rec_buf(log, rh, lr);
2437 u32 page_off = lsn_to_page_off(log, lsn);
2439 if (page_off + len + log->record_header_len > log->page_size)
2452 static int read_log_rec_lcb(struct ntfs_log *log, u64 lsn, u32 ctx_mode,
2469 cr = Add2Ptr(log->ra, le16_to_cpu(log->ra->client_off));
2471 if (!verify_client_lsn(log, cr, lsn))
2477 lcb->client = log->client_id;
2480 /* Find the log record indicated by the given lsn. */
2481 err = find_log_rec(log, lsn, lcb);
2499 static int find_client_next_lsn(struct ntfs_log *log, struct lcb *lcb, u64 *lsn)
2515 err = next_log_lsn(log, hdr, ¤t_lsn);
2526 err = read_log_page(log, lsn_to_vbo(log, current_lsn),
2559 log, Add2Ptr(log->ra, le16_to_cpu(log->ra->client_off)),
2564 err = read_log_page(log, lsn_to_vbo(log, next_lsn),
2576 static int read_next_log_rec(struct ntfs_log *log, struct lcb *lcb, u64 *lsn)
2580 err = find_client_next_lsn(log, lcb, lsn);
2595 return find_log_rec(log, *lsn, lcb);
2968 static struct OpenAttr *find_loaded_attr(struct ntfs_log *log,
2973 while ((oe = enum_rstbl(log->open_attr_tbl, oe))) {
3035 static int do_action(struct ntfs_log *log, struct OPEN_ATTR_ENRTY *oe,
3040 struct ntfs_sb_info *sbi = log->ni->mi.sbi;
3073 * Process MFT records, as described by the current log record.
3158 * Process attributes, as described by the current log record.
3253 oa2 = find_loaded_attr(log, attr, rno_base);
3320 oa2 = find_loaded_attr(log, attr, rno_base);
3360 oa2 = find_loaded_attr(log, attr, rno_base);
3379 oa2 = find_loaded_attr(log, attr, rno_base);
3723 log->set_dirty = true;
3728 * log_replay - Replays log and empties it.
3731 * It replays log and empties it.
3738 struct ntfs_log *log;
3777 log = kzalloc(sizeof(struct ntfs_log), GFP_NOFS);
3778 if (!log)
3781 log->ni = ni;
3782 log->l_size = log->orig_file_size = ni->vfs_inode.i_size;
3786 log->page_size = norm_file_page(PAGE_SIZE, &log->l_size, true);
3788 log->page_size = norm_file_page(PAGE_SIZE, &log->l_size, false);
3790 if (!log->page_size) {
3795 log->one_page_buf = kmalloc(log->page_size, GFP_NOFS);
3796 if (!log->one_page_buf) {
3801 log->page_mask = log->page_size - 1;
3802 log->page_bits = blksize_bits(log->page_size);
3805 err = log_read_rst(log, true, &log->rst_info);
3810 *initialized = log->rst_info.initialized;
3812 if (!log->rst_info.restart) {
3813 if (log->rst_info.initialized) {
3819 log_init_pg_hdr(log, 1, 1);
3820 log_create(log, 0, get_random_u32(), false, false);
3822 ra = log_create_ra(log);
3827 log->ra = ra;
3828 log->init_ra = true;
3837 if (log->rst_info.vbo)
3840 err = log_read_rst(log, false, &log->rst_info2);
3845 if (!log->rst_info2.restart ||
3846 log->rst_info2.last_lsn <= log->rst_info.last_lsn)
3851 if (log->rst_info.chkdsk_was_run &&
3852 log->page_size != log->rst_info.vbo) {
3856 if (!read_log_page(log, log->page_size, &sp, &usa_error) &&
3864 kfree(log->rst_info.r_page);
3865 memcpy(&log->rst_info, &log->rst_info2,
3867 log->rst_info2.r_page = NULL;
3871 kfree(log->rst_info2.r_page);
3878 log->init_ra = !!log->rst_info.vbo;
3881 ra2 = log->rst_info.valid_page ?
3882 Add2Ptr(log->rst_info.r_page,
3883 le16_to_cpu(log->rst_info.r_page->ra_off)) :
3886 if (log->rst_info.chkdsk_was_run ||
3892 /* Do some checks based on whether we have a valid log page. */
3893 open_log_count = log->rst_info.valid_page ?
3897 log_init_pg_hdr(log, 1, 1);
3899 log_create(log, log->rst_info.last_lsn, open_log_count, wrapped,
3902 ra = log_create_ra(log);
3907 log->ra = ra;
3910 * the log file as required.
3921 * If the log page or the system page sizes have changed, we can't
3922 * use the log file. We must use the system page size instead of the
3925 t32 = le32_to_cpu(log->rst_info.r_page->sys_page_size);
3926 if (log->page_size != t32) {
3927 log->l_size = log->orig_file_size;
3928 log->page_size = norm_file_page(t32, &log->l_size,
3932 if (log->page_size != t32 ||
3933 log->page_size != le32_to_cpu(log->rst_info.r_page->page_size)) {
3938 log->page_mask = log->page_size - 1;
3939 log->page_bits = blksize_bits(log->page_size);
3942 if (log->l_size < le64_to_cpu(ra2->l_size)) {
3947 log_init_pg_hdr(log, le16_to_cpu(log->rst_info.r_page->major_ver),
3948 le16_to_cpu(log->rst_info.r_page->minor_ver));
3950 log->l_size = le64_to_cpu(ra2->l_size);
3951 log->seq_num_bits = le32_to_cpu(ra2->seq_num_bits);
3952 log->file_data_bits = sizeof(u64) * 8 - log->seq_num_bits;
3953 log->seq_num_mask = (8 << log->file_data_bits) - 1;
3954 log->last_lsn = le64_to_cpu(ra2->current_lsn);
3955 log->seq_num = log->last_lsn >> log->file_data_bits;
3956 log->ra_off = le16_to_cpu(log->rst_info.r_page->ra_off);
3957 log->restart_size = log->sys_page_size - log->ra_off;
3958 log->record_header_len = le16_to_cpu(ra2->rec_hdr_len);
3959 log->ra_size = le16_to_cpu(ra2->ra_len);
3960 log->data_off = le16_to_cpu(ra2->data_off);
3961 log->data_size = log->page_size - log->data_off;
3962 log->reserved = log->data_size - log->record_header_len;
3964 vbo = lsn_to_vbo(log, log->last_lsn);
3966 if (vbo < log->first_page) {
3968 log->l_flags |= NTFSLOG_NO_LAST_LSN;
3969 log->next_page = log->first_page;
3973 /* Find the end of this log record. */
3974 off = final_log_off(log, log->last_lsn,
3979 log->seq_num += 1;
3980 log->l_flags |= NTFSLOG_WRAPPED;
3983 /* Now compute the next log page to use. */
3984 vbo &= ~log->sys_page_mask;
3985 tail = log->page_size - (off & log->page_mask) - 1;
3988 *If we can fit another log record on the page,
3989 * move back a page the log file.
3991 if (tail >= log->record_header_len) {
3992 log->l_flags |= NTFSLOG_REUSE_TAIL;
3993 log->next_page = vbo;
3995 log->next_page = next_page_off(log, vbo);
4003 log->oldest_lsn = log->last_lsn;
4005 ra2->client_idx[1], &log->oldest_lsn);
4006 log->oldest_lsn_off = lsn_to_vbo(log, log->oldest_lsn);
4008 if (log->oldest_lsn_off < log->first_page)
4009 log->l_flags |= NTFSLOG_NO_OLDEST_LSN;
4012 log->l_flags |= NTFSLOG_WRAPPED | NTFSLOG_MULTIPLE_PAGE_IO;
4014 log->current_openlog_count = le32_to_cpu(ra2->open_log_count);
4015 log->total_avail_pages = log->l_size - log->first_page;
4016 log->total_avail = log->total_avail_pages >> log->page_bits;
4017 log->max_current_avail = log->total_avail * log->reserved;
4018 log->total_avail = log->total_avail * log->data_size;
4020 log->current_avail = current_log_avail(log);
4022 ra = kzalloc(log->restart_size, GFP_NOFS);
4027 log->ra = ra;
4031 memcpy(ra, ra2, log->ra_size);
4037 log->current_openlog_count = get_random_u32();
4038 ra->open_log_count = cpu_to_le32(log->current_openlog_count);
4039 log->ra_size = offsetof(struct RESTART_AREA, clients) +
4043 ra->ra_len = cpu_to_le16(log->ra_size);
4049 err = last_log_lsn(log);
4053 log->current_avail = current_log_avail(log);
4056 log->init_ra = log->rst_info.vbo;
4059 /* 1.0, 1.1, 2.0 log->major_ver/minor_ver - short values. */
4060 switch ((log->major_ver << 16) + log->minor_ver) {
4067 log->major_ver, log->minor_ver);
4069 log->set_dirty = true;
4091 cr->oldest_lsn = cpu_to_le64(log->oldest_lsn);
4113 log->client_id.seq_num = cr->seq_num;
4114 log->client_id.client_idx = client;
4116 err = read_rst_area(log, &rst, &checkpt_lsn);
4133 err = read_log_rec_lcb(log, t64, lcb_ctx_prev, &lcb);
4173 err = read_log_rec_lcb(log, t64, lcb_ctx_prev, &lcb);
4225 if (sbi->cluster_size <= log->page_size)
4250 err = read_log_rec_lcb(log, t64, lcb_ctx_prev, &lcb);
4282 err = read_log_rec_lcb(log, t64, lcb_ctx_prev, &lcb);
4312 log->open_attr_tbl = oatbl;
4393 log->open_attr_tbl = oatbl;
4399 err = read_log_rec_lcb(log, checkpt_lsn, lcb_ctx_next, &lcb);
4403 /* Loop to read all subsequent records to the end of the log file. */
4405 err = read_next_log_rec(log, lcb, &rec_lsn);
4461 * If this is a compensation log record, then change
4467 /* Dispatch to handle log record depending on type. */
4508 t32 = log->clst_per_page;
4531 * Copy the Lcns from the log record into the Dirty Page Entry.
4550 /* Loop through all of the Lcn ranges this log record. */
4582 log->open_attr_tbl = oatbl;
4591 log->open_attr_tbl = oatbl;
4597 /* Initialize this entry from the log record. */
4880 err = read_log_rec_lcb(log, rlsn, lcb_ctx_next, &lcb);
4885 * Now loop to read all of our log records forwards, until
4903 /* Ignore log records that do not update pages. */
4973 * log record Vcn, after removing this unallocated Vcn.
4978 * If the update described this log record goes beyond
4989 * we can skip this log record.
4999 err = do_action(log, oe, lrh, t16, data, dlen, rec_len, &rec_lsn);
5005 err = read_next_log_rec(log, lcb, &rec_lsn);
5025 log->transaction_id = PtrOffset(trtbl, tr);
5036 err = read_log_rec_lcb(log, undo_next_lsn, lcb_ctx_undo_next, &lcb);
5041 * Now loop to read all of our log records forwards,
5078 vcn &= ~(u64)(log->clst_per_page - 1);
5105 err = do_action(log, oe, lrh, t16, data, dlen, rec_len, NULL);
5112 err = read_next_log_rec(log, lcb, &rec_lsn);
5123 free_rsttbl_idx(trtbl, log->transaction_id);
5125 log->transaction_id = 0;
5141 rh = kzalloc(log->page_size, GFP_NOFS);
5149 t16 = (log->page_size >> SECTOR_SHIFT) + 1;
5151 rh->sys_page_size = cpu_to_le32(log->page_size);
5152 rh->page_size = cpu_to_le32(log->page_size);
5169 ntfs_fix_pre_write(&rh->rhdr, log->page_size);
5171 err = ntfs_sb_write_run(sbi, &ni->file.run, 0, rh, log->page_size, 0);
5173 err = ntfs_sb_write_run(sbi, &log->ni->file.run, log->page_size,
5174 rh, log->page_size, 0);
5217 kfree(log->rst_info.r_page);
5220 kfree(log->one_page_buf);
5227 else if (log->set_dirty)
5230 kfree(log);