checkpoint.c (a3479c7fc096a1a7a2dccbfbdc6fcf86b805711a) checkpoint.c (af697c0f5c5b8798832e651baf23460d588393de)
1/*
2 * fs/f2fs/checkpoint.c
3 *
4 * Copyright (c) 2012 Samsung Electronics Co., Ltd.
5 * http://www.samsung.com/
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License version 2 as

--- 228 unchanged lines hidden (view full) ---

237static int __f2fs_write_meta_page(struct page *page,
238 struct writeback_control *wbc,
239 enum iostat_type io_type)
240{
241 struct f2fs_sb_info *sbi = F2FS_P_SB(page);
242
243 trace_f2fs_writepage(page, META);
244
1/*
2 * fs/f2fs/checkpoint.c
3 *
4 * Copyright (c) 2012 Samsung Electronics Co., Ltd.
5 * http://www.samsung.com/
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License version 2 as

--- 228 unchanged lines hidden (view full) ---

237static int __f2fs_write_meta_page(struct page *page,
238 struct writeback_control *wbc,
239 enum iostat_type io_type)
240{
241 struct f2fs_sb_info *sbi = F2FS_P_SB(page);
242
243 trace_f2fs_writepage(page, META);
244
245 if (unlikely(f2fs_cp_error(sbi))) {
246 dec_page_count(sbi, F2FS_DIRTY_META);
247 unlock_page(page);
248 return 0;
249 }
245 if (unlikely(f2fs_cp_error(sbi)))
246 goto redirty_out;
250 if (unlikely(is_sbi_flag_set(sbi, SBI_POR_DOING)))
251 goto redirty_out;
252 if (wbc->for_reclaim && page->index < GET_SUM_BLOCK(sbi, 0))
253 goto redirty_out;
254
255 f2fs_do_write_meta_page(sbi, page, io_type);
256 dec_page_count(sbi, F2FS_DIRTY_META);
257

--- 866 unchanged lines hidden (view full) ---

1124 DEFINE_WAIT(wait);
1125
1126 for (;;) {
1127 prepare_to_wait(&sbi->cp_wait, &wait, TASK_UNINTERRUPTIBLE);
1128
1129 if (!get_pages(sbi, F2FS_WB_CP_DATA))
1130 break;
1131
247 if (unlikely(is_sbi_flag_set(sbi, SBI_POR_DOING)))
248 goto redirty_out;
249 if (wbc->for_reclaim && page->index < GET_SUM_BLOCK(sbi, 0))
250 goto redirty_out;
251
252 f2fs_do_write_meta_page(sbi, page, io_type);
253 dec_page_count(sbi, F2FS_DIRTY_META);
254

--- 866 unchanged lines hidden (view full) ---

1121 DEFINE_WAIT(wait);
1122
1123 for (;;) {
1124 prepare_to_wait(&sbi->cp_wait, &wait, TASK_UNINTERRUPTIBLE);
1125
1126 if (!get_pages(sbi, F2FS_WB_CP_DATA))
1127 break;
1128
1129 if (unlikely(f2fs_cp_error(sbi)))
1130 break;
1131
1132 io_schedule_timeout(5*HZ);
1133 }
1134 finish_wait(&sbi->cp_wait, &wait);
1135}
1136
1137static void update_ckpt_flags(struct f2fs_sb_info *sbi, struct cp_control *cpc)
1138{
1139 unsigned long orphan_num = sbi->im[ORPHAN_INO].ino_num;

--- 57 unchanged lines hidden (view full) ---

1197
1198 f2fs_wait_on_page_writeback(page, META, true);
1199 f2fs_bug_on(sbi, PageWriteback(page));
1200 if (unlikely(!clear_page_dirty_for_io(page)))
1201 f2fs_bug_on(sbi, 1);
1202
1203 /* writeout cp pack 2 page */
1204 err = __f2fs_write_meta_page(page, &wbc, FS_CP_META_IO);
1132 io_schedule_timeout(5*HZ);
1133 }
1134 finish_wait(&sbi->cp_wait, &wait);
1135}
1136
1137static void update_ckpt_flags(struct f2fs_sb_info *sbi, struct cp_control *cpc)
1138{
1139 unsigned long orphan_num = sbi->im[ORPHAN_INO].ino_num;

--- 57 unchanged lines hidden (view full) ---

1197
1198 f2fs_wait_on_page_writeback(page, META, true);
1199 f2fs_bug_on(sbi, PageWriteback(page));
1200 if (unlikely(!clear_page_dirty_for_io(page)))
1201 f2fs_bug_on(sbi, 1);
1202
1203 /* writeout cp pack 2 page */
1204 err = __f2fs_write_meta_page(page, &wbc, FS_CP_META_IO);
1205 f2fs_bug_on(sbi, err);
1205 if (unlikely(err && f2fs_cp_error(sbi))) {
1206 f2fs_put_page(page, 1);
1207 return;
1208 }
1206
1209
1210 f2fs_bug_on(sbi, err);
1207 f2fs_put_page(page, 0);
1208
1209 /* submit checkpoint (with barrier if NOBARRIER is not set) */
1210 f2fs_submit_merged_write(sbi, META_FLUSH);
1211}
1212
1213static int do_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc)
1214{

--- 9 unchanged lines hidden (view full) ---

1224 struct curseg_info *seg_i = CURSEG_I(sbi, CURSEG_HOT_NODE);
1225 u64 kbytes_written;
1226 int err;
1227
1228 /* Flush all the NAT/SIT pages */
1229 while (get_pages(sbi, F2FS_DIRTY_META)) {
1230 f2fs_sync_meta_pages(sbi, META, LONG_MAX, FS_CP_META_IO);
1231 if (unlikely(f2fs_cp_error(sbi)))
1211 f2fs_put_page(page, 0);
1212
1213 /* submit checkpoint (with barrier if NOBARRIER is not set) */
1214 f2fs_submit_merged_write(sbi, META_FLUSH);
1215}
1216
1217static int do_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc)
1218{

--- 9 unchanged lines hidden (view full) ---

1228 struct curseg_info *seg_i = CURSEG_I(sbi, CURSEG_HOT_NODE);
1229 u64 kbytes_written;
1230 int err;
1231
1232 /* Flush all the NAT/SIT pages */
1233 while (get_pages(sbi, F2FS_DIRTY_META)) {
1234 f2fs_sync_meta_pages(sbi, META, LONG_MAX, FS_CP_META_IO);
1235 if (unlikely(f2fs_cp_error(sbi)))
1232 return -EIO;
1236 break;
1233 }
1234
1235 /*
1236 * modify checkpoint
1237 * version number is already updated
1238 */
1239 ckpt->elapsed_time = cpu_to_le64(get_mtime(sbi, true));
1240 ckpt->free_segment_count = cpu_to_le32(free_segments(sbi));

--- 63 unchanged lines hidden (view full) ---

1304 f2fs_update_meta_page(sbi, nm_i->nat_bits +
1305 (i << F2FS_BLKSIZE_BITS), blk + i);
1306
1307 /* Flush all the NAT BITS pages */
1308 while (get_pages(sbi, F2FS_DIRTY_META)) {
1309 f2fs_sync_meta_pages(sbi, META, LONG_MAX,
1310 FS_CP_META_IO);
1311 if (unlikely(f2fs_cp_error(sbi)))
1237 }
1238
1239 /*
1240 * modify checkpoint
1241 * version number is already updated
1242 */
1243 ckpt->elapsed_time = cpu_to_le64(get_mtime(sbi, true));
1244 ckpt->free_segment_count = cpu_to_le32(free_segments(sbi));

--- 63 unchanged lines hidden (view full) ---

1308 f2fs_update_meta_page(sbi, nm_i->nat_bits +
1309 (i << F2FS_BLKSIZE_BITS), blk + i);
1310
1311 /* Flush all the NAT BITS pages */
1312 while (get_pages(sbi, F2FS_DIRTY_META)) {
1313 f2fs_sync_meta_pages(sbi, META, LONG_MAX,
1314 FS_CP_META_IO);
1315 if (unlikely(f2fs_cp_error(sbi)))
1312 return -EIO;
1316 break;
1313 }
1314 }
1315
1316 /* write out checkpoint buffer at block 0 */
1317 f2fs_update_meta_page(sbi, ckpt, start_blk++);
1318
1319 for (i = 1; i < 1 + cp_payload_blks; i++)
1320 f2fs_update_meta_page(sbi, (char *)ckpt + i * F2FS_BLKSIZE,

--- 24 unchanged lines hidden (view full) ---

1345 percpu_counter_set(&sbi->alloc_valid_block_count, 0);
1346
1347 /* Here, we have one bio having CP pack except cp pack 2 page */
1348 f2fs_sync_meta_pages(sbi, META, LONG_MAX, FS_CP_META_IO);
1349
1350 /* wait for previous submitted meta pages writeback */
1351 wait_on_all_pages_writeback(sbi);
1352
1317 }
1318 }
1319
1320 /* write out checkpoint buffer at block 0 */
1321 f2fs_update_meta_page(sbi, ckpt, start_blk++);
1322
1323 for (i = 1; i < 1 + cp_payload_blks; i++)
1324 f2fs_update_meta_page(sbi, (char *)ckpt + i * F2FS_BLKSIZE,

--- 24 unchanged lines hidden (view full) ---

1349 percpu_counter_set(&sbi->alloc_valid_block_count, 0);
1350
1351 /* Here, we have one bio having CP pack except cp pack 2 page */
1352 f2fs_sync_meta_pages(sbi, META, LONG_MAX, FS_CP_META_IO);
1353
1354 /* wait for previous submitted meta pages writeback */
1355 wait_on_all_pages_writeback(sbi);
1356
1353 if (unlikely(f2fs_cp_error(sbi)))
1354 return -EIO;
1355
1356 /* flush all device cache */
1357 err = f2fs_flush_device_cache(sbi);
1358 if (err)
1359 return err;
1360
1361 /* barrier and flush checkpoint cp pack 2 page if it can */
1362 commit_checkpoint(sbi, ckpt, start_blk);
1363 wait_on_all_pages_writeback(sbi);
1364
1365 f2fs_release_ino_entry(sbi, false);
1366
1357 /* flush all device cache */
1358 err = f2fs_flush_device_cache(sbi);
1359 if (err)
1360 return err;
1361
1362 /* barrier and flush checkpoint cp pack 2 page if it can */
1363 commit_checkpoint(sbi, ckpt, start_blk);
1364 wait_on_all_pages_writeback(sbi);
1365
1366 f2fs_release_ino_entry(sbi, false);
1367
1367 if (unlikely(f2fs_cp_error(sbi)))
1368 return -EIO;
1369
1370 clear_sbi_flag(sbi, SBI_IS_DIRTY);
1371 clear_sbi_flag(sbi, SBI_NEED_CP);
1372 __set_cp_next_pack(sbi);
1373
1374 /*
1375 * redirty superblock if metadata like node page or inode cache is
1376 * updated during writing checkpoint.
1377 */
1378 if (get_pages(sbi, F2FS_DIRTY_NODES) ||
1379 get_pages(sbi, F2FS_DIRTY_IMETA))
1380 set_sbi_flag(sbi, SBI_IS_DIRTY);
1381
1382 f2fs_bug_on(sbi, get_pages(sbi, F2FS_DIRTY_DENTS));
1383
1368 clear_sbi_flag(sbi, SBI_IS_DIRTY);
1369 clear_sbi_flag(sbi, SBI_NEED_CP);
1370 __set_cp_next_pack(sbi);
1371
1372 /*
1373 * redirty superblock if metadata like node page or inode cache is
1374 * updated during writing checkpoint.
1375 */
1376 if (get_pages(sbi, F2FS_DIRTY_NODES) ||
1377 get_pages(sbi, F2FS_DIRTY_IMETA))
1378 set_sbi_flag(sbi, SBI_IS_DIRTY);
1379
1380 f2fs_bug_on(sbi, get_pages(sbi, F2FS_DIRTY_DENTS));
1381
1384 return 0;
1382 return unlikely(f2fs_cp_error(sbi)) ? -EIO : 0;
1385}
1386
1387/*
1388 * We guarantee that this checkpoint procedure will not fail.
1389 */
1390int f2fs_write_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc)
1391{
1392 struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi);

--- 117 unchanged lines hidden --- 		1383}
1384
1385/*
1386 * We guarantee that this checkpoint procedure will not fail.
1387 */
1388int f2fs_write_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc)
1389{
1390 struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi);

--- 117 unchanged lines hidden ---