segment.c (e5451c8f8330e03ad3cfa16048b4daf961af434f) segment.c (4356e48e64374ceac6e4313244eb65158a954b40)
1/*
2 * fs/f2fs/segment.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

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

186 get_page(page);
187 list_add_tail(&new->list, &fi->inmem_pages);
188 inc_page_count(F2FS_I_SB(inode), F2FS_INMEM_PAGES);
189 mutex_unlock(&fi->inmem_lock);
190
191 trace_f2fs_register_inmem_page(page, INMEM);
192}
193
1/*
2 * fs/f2fs/segment.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

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

186 get_page(page);
187 list_add_tail(&new->list, &fi->inmem_pages);
188 inc_page_count(F2FS_I_SB(inode), F2FS_INMEM_PAGES);
189 mutex_unlock(&fi->inmem_lock);
190
191 trace_f2fs_register_inmem_page(page, INMEM);
192}
193
194int commit_inmem_pages(struct inode *inode, bool abort)
194static int __revoke_inmem_pages(struct inode *inode,
195 struct list_head *head, bool drop, bool recover)
195{
196 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
196{
197 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
198 struct inmem_pages *cur, *tmp;
199 int err = 0;
200
201 list_for_each_entry_safe(cur, tmp, head, list) {
202 struct page *page = cur->page;
203
204 if (drop)
205 trace_f2fs_commit_inmem_page(page, INMEM_DROP);
206
207 lock_page(page);
208
209 if (recover) {
210 struct dnode_of_data dn;
211 struct node_info ni;
212
213 trace_f2fs_commit_inmem_page(page, INMEM_REVOKE);
214
215 set_new_dnode(&dn, inode, NULL, NULL, 0);
216 if (get_dnode_of_data(&dn, page->index, LOOKUP_NODE)) {
217 err = -EAGAIN;
218 goto next;
219 }
220 get_node_info(sbi, dn.nid, &ni);
221 f2fs_replace_block(sbi, &dn, dn.data_blkaddr,
222 cur->old_addr, ni.version, true, true);
223 f2fs_put_dnode(&dn);
224 }
225next:
226 ClearPageUptodate(page);
227 set_page_private(page, 0);
228 ClearPageUptodate(page);
229 f2fs_put_page(page, 1);
230
231 list_del(&cur->list);
232 kmem_cache_free(inmem_entry_slab, cur);
233 dec_page_count(F2FS_I_SB(inode), F2FS_INMEM_PAGES);
234 }
235 return err;
236}
237
238void drop_inmem_pages(struct inode *inode)
239{
197 struct f2fs_inode_info *fi = F2FS_I(inode);
240 struct f2fs_inode_info *fi = F2FS_I(inode);
241
242 mutex_lock(&fi->inmem_lock);
243 __revoke_inmem_pages(inode, &fi->inmem_pages, true, false);
244 mutex_unlock(&fi->inmem_lock);
245}
246
247static int __commit_inmem_pages(struct inode *inode,
248 struct list_head *revoke_list)
249{
250 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
251 struct f2fs_inode_info *fi = F2FS_I(inode);
198 struct inmem_pages *cur, *tmp;
252 struct inmem_pages *cur, *tmp;
199 bool submit_bio = false;
200 struct f2fs_io_info fio = {
201 .sbi = sbi,
202 .type = DATA,
203 .rw = WRITE_SYNC | REQ_PRIO,
204 .encrypted_page = NULL,
205 };
253 struct f2fs_io_info fio = {
254 .sbi = sbi,
255 .type = DATA,
256 .rw = WRITE_SYNC | REQ_PRIO,
257 .encrypted_page = NULL,
258 };
259 bool submit_bio = false;
206 int err = 0;
207
260 int err = 0;
261
208 /*
209 * The abort is true only when f2fs_evict_inode is called.
210 * Basically, the f2fs_evict_inode doesn't produce any data writes, so
211 * that we don't need to call f2fs_balance_fs.
212 * Otherwise, f2fs_gc in f2fs_balance_fs can wait forever until this
213 * inode becomes free by iget_locked in f2fs_iget.
214 */
215 if (!abort) {
216 f2fs_balance_fs(sbi, true);
217 f2fs_lock_op(sbi);
218 }
219
220 mutex_lock(&fi->inmem_lock);
221 list_for_each_entry_safe(cur, tmp, &fi->inmem_pages, list) {
262 list_for_each_entry_safe(cur, tmp, &fi->inmem_pages, list) {
222 lock_page(cur->page);
223 if (!abort) {
224 if (cur->page->mapping == inode->i_mapping) {
225 set_page_dirty(cur->page);
226 f2fs_wait_on_page_writeback(cur->page, DATA);
227 if (clear_page_dirty_for_io(cur->page))
228 inode_dec_dirty_pages(inode);
229 trace_f2fs_commit_inmem_page(cur->page, INMEM);
230 fio.page = cur->page;
231 err = do_write_data_page(&fio);
232 if (err) {
233 unlock_page(cur->page);
234 break;
235 }
236 clear_cold_data(cur->page);
237 submit_bio = true;
263 struct page *page = cur->page;
264
265 lock_page(page);
266 if (page->mapping == inode->i_mapping) {
267 trace_f2fs_commit_inmem_page(page, INMEM);
268
269 set_page_dirty(page);
270 f2fs_wait_on_page_writeback(page, DATA, true);
271 if (clear_page_dirty_for_io(page))
272 inode_dec_dirty_pages(inode);
273
274 fio.page = page;
275 err = do_write_data_page(&fio);
276 if (err) {
277 unlock_page(page);
278 break;
238 }
279 }
239 } else {
240 ClearPageUptodate(cur->page);
241 trace_f2fs_commit_inmem_page(cur->page, INMEM_DROP);
280
281 /* record old blkaddr for revoking */
282 cur->old_addr = fio.old_blkaddr;
283
284 clear_cold_data(page);
285 submit_bio = true;
242 }
286 }
243 set_page_private(cur->page, 0);
244 ClearPagePrivate(cur->page);
245 f2fs_put_page(cur->page, 1);
287 unlock_page(page);
288 list_move_tail(&cur->list, revoke_list);
289 }
246
290
247 list_del(&cur->list);
248 kmem_cache_free(inmem_entry_slab, cur);
249 dec_page_count(F2FS_I_SB(inode), F2FS_INMEM_PAGES);
291 if (submit_bio)
292 f2fs_submit_merged_bio_cond(sbi, inode, NULL, 0, DATA, WRITE);
293
294 if (!err)
295 __revoke_inmem_pages(inode, revoke_list, false, false);
296
297 return err;
298}
299
300int commit_inmem_pages(struct inode *inode)
301{
302 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
303 struct f2fs_inode_info *fi = F2FS_I(inode);
304 struct list_head revoke_list;
305 int err;
306
307 INIT_LIST_HEAD(&revoke_list);
308 f2fs_balance_fs(sbi, true);
309 f2fs_lock_op(sbi);
310
311 mutex_lock(&fi->inmem_lock);
312 err = __commit_inmem_pages(inode, &revoke_list);
313 if (err) {
314 int ret;
315 /*
316 * try to revoke all committed pages, but still we could fail
317 * due to no memory or other reason, if that happened, EAGAIN
318 * will be returned, which means in such case, transaction is
319 * already not integrity, caller should use journal to do the
320 * recovery or rewrite & commit last transaction. For other
321 * error number, revoking was done by filesystem itself.
322 */
323 ret = __revoke_inmem_pages(inode, &revoke_list, false, true);
324 if (ret)
325 err = ret;
326
327 /* drop all uncommitted pages */
328 __revoke_inmem_pages(inode, &fi->inmem_pages, true, false);
250 }
251 mutex_unlock(&fi->inmem_lock);
252
329 }
330 mutex_unlock(&fi->inmem_lock);
331
253 if (!abort) {
254 f2fs_unlock_op(sbi);
255 if (submit_bio)
256 f2fs_submit_merged_bio(sbi, DATA, WRITE);
257 }
332 f2fs_unlock_op(sbi);
258 return err;
259}
260
261/*
262 * This function balances dirty node and dentry pages.
263 * In addition, it controls garbage collection.
264 */
265void f2fs_balance_fs(struct f2fs_sb_info *sbi, bool need)

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

286 if (!available_free_memory(sbi, NAT_ENTRIES))
287 try_to_free_nats(sbi, NAT_ENTRY_PER_BLOCK);
288
289 if (!available_free_memory(sbi, FREE_NIDS))
290 try_to_free_nids(sbi, NAT_ENTRY_PER_BLOCK * FREE_NID_PAGES);
291
292 /* checkpoint is the only way to shrink partial cached entries */
293 if (!available_free_memory(sbi, NAT_ENTRIES) ||
333 return err;
334}
335
336/*
337 * This function balances dirty node and dentry pages.
338 * In addition, it controls garbage collection.
339 */
340void f2fs_balance_fs(struct f2fs_sb_info *sbi, bool need)

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

361 if (!available_free_memory(sbi, NAT_ENTRIES))
362 try_to_free_nats(sbi, NAT_ENTRY_PER_BLOCK);
363
364 if (!available_free_memory(sbi, FREE_NIDS))
365 try_to_free_nids(sbi, NAT_ENTRY_PER_BLOCK * FREE_NID_PAGES);
366
367 /* checkpoint is the only way to shrink partial cached entries */
368 if (!available_free_memory(sbi, NAT_ENTRIES) ||
294 excess_prefree_segs(sbi) ||
295 !available_free_memory(sbi, INO_ENTRIES) ||
369 !available_free_memory(sbi, INO_ENTRIES) ||
370 excess_prefree_segs(sbi) ||
371 excess_dirty_nats(sbi) ||
296 (is_idle(sbi) && f2fs_time_over(sbi, CP_TIME))) {
372 (is_idle(sbi) && f2fs_time_over(sbi, CP_TIME))) {
297 if (test_opt(sbi, DATA_FLUSH))
373 if (test_opt(sbi, DATA_FLUSH)) {
374 struct blk_plug plug;
375
376 blk_start_plug(&plug);
298 sync_dirty_inodes(sbi, FILE_INODE);
377 sync_dirty_inodes(sbi, FILE_INODE);
378 blk_finish_plug(&plug);
379 }
299 f2fs_sync_fs(sbi->sb, true);
300 stat_inc_bg_cp_count(sbi->stat_info);
301 }
302}
303
304static int issue_flush_thread(void *data)
305{
306 struct f2fs_sb_info *sbi = data;

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

497 sbi->discard_blks--;
498 }
499 trace_f2fs_issue_discard(sbi->sb, blkstart, blklen);
500 return blkdev_issue_discard(sbi->sb->s_bdev, start, len, GFP_NOFS, 0);
501}
502
503bool discard_next_dnode(struct f2fs_sb_info *sbi, block_t blkaddr)
504{
380 f2fs_sync_fs(sbi->sb, true);
381 stat_inc_bg_cp_count(sbi->stat_info);
382 }
383}
384
385static int issue_flush_thread(void *data)
386{
387 struct f2fs_sb_info *sbi = data;

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

578 sbi->discard_blks--;
579 }
580 trace_f2fs_issue_discard(sbi->sb, blkstart, blklen);
581 return blkdev_issue_discard(sbi->sb->s_bdev, start, len, GFP_NOFS, 0);
582}
583
584bool discard_next_dnode(struct f2fs_sb_info *sbi, block_t blkaddr)
585{
505 int err = -ENOTSUPP;
586 int err = -EOPNOTSUPP;
506
507 if (test_opt(sbi, DISCARD)) {
508 struct seg_entry *se = get_seg_entry(sbi,
509 GET_SEGNO(sbi, blkaddr));
510 unsigned int offset = GET_BLKOFF_FROM_SEG0(sbi, blkaddr);
511
512 if (f2fs_test_bit(offset, se->discard_map))
513 return false;

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

836}
837
838static void write_sum_page(struct f2fs_sb_info *sbi,
839 struct f2fs_summary_block *sum_blk, block_t blk_addr)
840{
841 update_meta_page(sbi, (void *)sum_blk, blk_addr);
842}
843
587
588 if (test_opt(sbi, DISCARD)) {
589 struct seg_entry *se = get_seg_entry(sbi,
590 GET_SEGNO(sbi, blkaddr));
591 unsigned int offset = GET_BLKOFF_FROM_SEG0(sbi, blkaddr);
592
593 if (f2fs_test_bit(offset, se->discard_map))
594 return false;

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

917}
918
919static void write_sum_page(struct f2fs_sb_info *sbi,
920 struct f2fs_summary_block *sum_blk, block_t blk_addr)
921{
922 update_meta_page(sbi, (void *)sum_blk, blk_addr);
923}
924
925static void write_current_sum_page(struct f2fs_sb_info *sbi,
926 int type, block_t blk_addr)
927{
928 struct curseg_info *curseg = CURSEG_I(sbi, type);
929 struct page *page = grab_meta_page(sbi, blk_addr);
930 struct f2fs_summary_block *src = curseg->sum_blk;
931 struct f2fs_summary_block *dst;
932
933 dst = (struct f2fs_summary_block *)page_address(page);
934
935 mutex_lock(&curseg->curseg_mutex);
936
937 down_read(&curseg->journal_rwsem);
938 memcpy(&dst->journal, curseg->journal, SUM_JOURNAL_SIZE);
939 up_read(&curseg->journal_rwsem);
940
941 memcpy(dst->entries, src->entries, SUM_ENTRY_SIZE);
942 memcpy(&dst->footer, &src->footer, SUM_FOOTER_SIZE);
943
944 mutex_unlock(&curseg->curseg_mutex);
945
946 set_page_dirty(page);
947 f2fs_put_page(page, 1);
948}
949
844static int is_next_segment_free(struct f2fs_sb_info *sbi, int type)
845{
846 struct curseg_info *curseg = CURSEG_I(sbi, type);
847 unsigned int segno = curseg->segno + 1;
848 struct free_segmap_info *free_i = FREE_I(sbi);
849
850 if (segno < MAIN_SEGS(sbi) && segno % sbi->segs_per_sec)
851 return !test_bit(segno, free_i->free_segmap);

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

868 bool init = true;
869 int go_left = 0;
870 int i;
871
872 spin_lock(&free_i->segmap_lock);
873
874 if (!new_sec && ((*newseg + 1) % sbi->segs_per_sec)) {
875 segno = find_next_zero_bit(free_i->free_segmap,
950static int is_next_segment_free(struct f2fs_sb_info *sbi, int type)
951{
952 struct curseg_info *curseg = CURSEG_I(sbi, type);
953 unsigned int segno = curseg->segno + 1;
954 struct free_segmap_info *free_i = FREE_I(sbi);
955
956 if (segno < MAIN_SEGS(sbi) && segno % sbi->segs_per_sec)
957 return !test_bit(segno, free_i->free_segmap);

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

974 bool init = true;
975 int go_left = 0;
976 int i;
977
978 spin_lock(&free_i->segmap_lock);
979
980 if (!new_sec && ((*newseg + 1) % sbi->segs_per_sec)) {
981 segno = find_next_zero_bit(free_i->free_segmap,
876 MAIN_SEGS(sbi), *newseg + 1);
877 if (segno - *newseg < sbi->segs_per_sec -
878 (*newseg % sbi->segs_per_sec))
982 (hint + 1) * sbi->segs_per_sec, *newseg + 1);
983 if (segno < (hint + 1) * sbi->segs_per_sec)
879 goto got_it;
880 }
881find_other_zone:
882 secno = find_next_zero_bit(free_i->free_secmap, MAIN_SECS(sbi), hint);
883 if (secno >= MAIN_SECS(sbi)) {
884 if (dir == ALLOC_RIGHT) {
885 secno = find_next_zero_bit(free_i->free_secmap,
886 MAIN_SECS(sbi), 0);

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

1275
1276 mutex_unlock(&curseg->curseg_mutex);
1277}
1278
1279static void do_write_page(struct f2fs_summary *sum, struct f2fs_io_info *fio)
1280{
1281 int type = __get_segment_type(fio->page, fio->type);
1282
984 goto got_it;
985 }
986find_other_zone:
987 secno = find_next_zero_bit(free_i->free_secmap, MAIN_SECS(sbi), hint);
988 if (secno >= MAIN_SECS(sbi)) {
989 if (dir == ALLOC_RIGHT) {
990 secno = find_next_zero_bit(free_i->free_secmap,
991 MAIN_SECS(sbi), 0);

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

1380
1381 mutex_unlock(&curseg->curseg_mutex);
1382}
1383
1384static void do_write_page(struct f2fs_summary *sum, struct f2fs_io_info *fio)
1385{
1386 int type = __get_segment_type(fio->page, fio->type);
1387
1283 allocate_data_block(fio->sbi, fio->page, fio->blk_addr,
1284 &fio->blk_addr, sum, type);
1388 allocate_data_block(fio->sbi, fio->page, fio->old_blkaddr,
1389 &fio->new_blkaddr, sum, type);
1285
1286 /* writeout dirty page into bdev */
1287 f2fs_submit_page_mbio(fio);
1288}
1289
1290void write_meta_page(struct f2fs_sb_info *sbi, struct page *page)
1291{
1292 struct f2fs_io_info fio = {
1293 .sbi = sbi,
1294 .type = META,
1295 .rw = WRITE_SYNC | REQ_META | REQ_PRIO,
1390
1391 /* writeout dirty page into bdev */
1392 f2fs_submit_page_mbio(fio);
1393}
1394
1395void write_meta_page(struct f2fs_sb_info *sbi, struct page *page)
1396{
1397 struct f2fs_io_info fio = {
1398 .sbi = sbi,
1399 .type = META,
1400 .rw = WRITE_SYNC | REQ_META | REQ_PRIO,
1296 .blk_addr = page->index,
1401 .old_blkaddr = page->index,
1402 .new_blkaddr = page->index,
1297 .page = page,
1298 .encrypted_page = NULL,
1299 };
1300
1301 if (unlikely(page->index >= MAIN_BLKADDR(sbi)))
1302 fio.rw &= ~REQ_META;
1303
1304 set_page_writeback(page);

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

1318 struct f2fs_sb_info *sbi = fio->sbi;
1319 struct f2fs_summary sum;
1320 struct node_info ni;
1321
1322 f2fs_bug_on(sbi, dn->data_blkaddr == NULL_ADDR);
1323 get_node_info(sbi, dn->nid, &ni);
1324 set_summary(&sum, dn->nid, dn->ofs_in_node, ni.version);
1325 do_write_page(&sum, fio);
1403 .page = page,
1404 .encrypted_page = NULL,
1405 };
1406
1407 if (unlikely(page->index >= MAIN_BLKADDR(sbi)))
1408 fio.rw &= ~REQ_META;
1409
1410 set_page_writeback(page);

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

1424 struct f2fs_sb_info *sbi = fio->sbi;
1425 struct f2fs_summary sum;
1426 struct node_info ni;
1427
1428 f2fs_bug_on(sbi, dn->data_blkaddr == NULL_ADDR);
1429 get_node_info(sbi, dn->nid, &ni);
1430 set_summary(&sum, dn->nid, dn->ofs_in_node, ni.version);
1431 do_write_page(&sum, fio);
1326 dn->data_blkaddr = fio->blk_addr;
1432 dn->data_blkaddr = fio->new_blkaddr;
1327}
1328
1329void rewrite_data_page(struct f2fs_io_info *fio)
1330{
1433}
1434
1435void rewrite_data_page(struct f2fs_io_info *fio)
1436{
1437 fio->new_blkaddr = fio->old_blkaddr;
1331 stat_inc_inplace_blocks(fio->sbi);
1332 f2fs_submit_page_mbio(fio);
1333}
1334
1438 stat_inc_inplace_blocks(fio->sbi);
1439 f2fs_submit_page_mbio(fio);
1440}
1441
1335static void __f2fs_replace_block(struct f2fs_sb_info *sbi,
1336 struct f2fs_summary *sum,
1442void __f2fs_replace_block(struct f2fs_sb_info *sbi, struct f2fs_summary *sum,
1337 block_t old_blkaddr, block_t new_blkaddr,
1443 block_t old_blkaddr, block_t new_blkaddr,
1338 bool recover_curseg)
1444 bool recover_curseg, bool recover_newaddr)
1339{
1340 struct sit_info *sit_i = SIT_I(sbi);
1341 struct curseg_info *curseg;
1342 unsigned int segno, old_cursegno;
1343 struct seg_entry *se;
1344 int type;
1345 unsigned short old_blkoff;
1346

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

1373 if (segno != curseg->segno) {
1374 curseg->next_segno = segno;
1375 change_curseg(sbi, type, true);
1376 }
1377
1378 curseg->next_blkoff = GET_BLKOFF_FROM_SEG0(sbi, new_blkaddr);
1379 __add_sum_entry(sbi, type, sum);
1380
1445{
1446 struct sit_info *sit_i = SIT_I(sbi);
1447 struct curseg_info *curseg;
1448 unsigned int segno, old_cursegno;
1449 struct seg_entry *se;
1450 int type;
1451 unsigned short old_blkoff;
1452

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

1479 if (segno != curseg->segno) {
1480 curseg->next_segno = segno;
1481 change_curseg(sbi, type, true);
1482 }
1483
1484 curseg->next_blkoff = GET_BLKOFF_FROM_SEG0(sbi, new_blkaddr);
1485 __add_sum_entry(sbi, type, sum);
1486
1381 if (!recover_curseg)
1487 if (!recover_curseg || recover_newaddr)
1382 update_sit_entry(sbi, new_blkaddr, 1);
1383 if (GET_SEGNO(sbi, old_blkaddr) != NULL_SEGNO)
1384 update_sit_entry(sbi, old_blkaddr, -1);
1385
1386 locate_dirty_segment(sbi, GET_SEGNO(sbi, old_blkaddr));
1387 locate_dirty_segment(sbi, GET_SEGNO(sbi, new_blkaddr));
1388
1389 locate_dirty_segment(sbi, old_cursegno);

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

1397 }
1398
1399 mutex_unlock(&sit_i->sentry_lock);
1400 mutex_unlock(&curseg->curseg_mutex);
1401}
1402
1403void f2fs_replace_block(struct f2fs_sb_info *sbi, struct dnode_of_data *dn,
1404 block_t old_addr, block_t new_addr,
1488 update_sit_entry(sbi, new_blkaddr, 1);
1489 if (GET_SEGNO(sbi, old_blkaddr) != NULL_SEGNO)
1490 update_sit_entry(sbi, old_blkaddr, -1);
1491
1492 locate_dirty_segment(sbi, GET_SEGNO(sbi, old_blkaddr));
1493 locate_dirty_segment(sbi, GET_SEGNO(sbi, new_blkaddr));
1494
1495 locate_dirty_segment(sbi, old_cursegno);

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

1503 }
1504
1505 mutex_unlock(&sit_i->sentry_lock);
1506 mutex_unlock(&curseg->curseg_mutex);
1507}
1508
1509void f2fs_replace_block(struct f2fs_sb_info *sbi, struct dnode_of_data *dn,
1510 block_t old_addr, block_t new_addr,
1405 unsigned char version, bool recover_curseg)
1511 unsigned char version, bool recover_curseg,
1512 bool recover_newaddr)
1406{
1407 struct f2fs_summary sum;
1408
1409 set_summary(&sum, dn->nid, dn->ofs_in_node, version);
1410
1513{
1514 struct f2fs_summary sum;
1515
1516 set_summary(&sum, dn->nid, dn->ofs_in_node, version);
1517
1411 __f2fs_replace_block(sbi, &sum, old_addr, new_addr, recover_curseg);
1518 __f2fs_replace_block(sbi, &sum, old_addr, new_addr,
1519 recover_curseg, recover_newaddr);
1412
1413 dn->data_blkaddr = new_addr;
1414 set_data_blkaddr(dn);
1415 f2fs_update_extent_cache(dn);
1416}
1417
1520
1521 dn->data_blkaddr = new_addr;
1522 set_data_blkaddr(dn);
1523 f2fs_update_extent_cache(dn);
1524}
1525
1418static inline bool is_merged_page(struct f2fs_sb_info *sbi,
1419 struct page *page, enum page_type type)
1420{
1421 enum page_type btype = PAGE_TYPE_OF_BIO(type);
1422 struct f2fs_bio_info *io = &sbi->write_io[btype];
1423 struct bio_vec *bvec;
1424 struct page *target;
1425 int i;
1426
1427 down_read(&io->io_rwsem);
1428 if (!io->bio) {
1429 up_read(&io->io_rwsem);
1430 return false;
1431 }
1432
1433 bio_for_each_segment_all(bvec, io->bio, i) {
1434
1435 if (bvec->bv_page->mapping) {
1436 target = bvec->bv_page;
1437 } else {
1438 struct f2fs_crypto_ctx *ctx;
1439
1440 /* encrypted page */
1441 ctx = (struct f2fs_crypto_ctx *)page_private(
1442 bvec->bv_page);
1443 target = ctx->w.control_page;
1444 }
1445
1446 if (page == target) {
1447 up_read(&io->io_rwsem);
1448 return true;
1449 }
1450 }
1451
1452 up_read(&io->io_rwsem);
1453 return false;
1454}
1455
1456void f2fs_wait_on_page_writeback(struct page *page,
1526void f2fs_wait_on_page_writeback(struct page *page,
1457 enum page_type type)
1527 enum page_type type, bool ordered)
1458{
1459 if (PageWriteback(page)) {
1460 struct f2fs_sb_info *sbi = F2FS_P_SB(page);
1461
1528{
1529 if (PageWriteback(page)) {
1530 struct f2fs_sb_info *sbi = F2FS_P_SB(page);
1531
1462 if (is_merged_page(sbi, page, type))
1463 f2fs_submit_merged_bio(sbi, type, WRITE);
1464 wait_on_page_writeback(page);
1532 f2fs_submit_merged_bio_cond(sbi, NULL, page, 0, type, WRITE);
1533 if (ordered)
1534 wait_on_page_writeback(page);
1535 else
1536 wait_for_stable_page(page);
1465 }
1466}
1467
1468void f2fs_wait_on_encrypted_page_writeback(struct f2fs_sb_info *sbi,
1469 block_t blkaddr)
1470{
1471 struct page *cpage;
1472
1473 if (blkaddr == NEW_ADDR)
1474 return;
1475
1476 f2fs_bug_on(sbi, blkaddr == NULL_ADDR);
1477
1478 cpage = find_lock_page(META_MAPPING(sbi), blkaddr);
1479 if (cpage) {
1537 }
1538}
1539
1540void f2fs_wait_on_encrypted_page_writeback(struct f2fs_sb_info *sbi,
1541 block_t blkaddr)
1542{
1543 struct page *cpage;
1544
1545 if (blkaddr == NEW_ADDR)
1546 return;
1547
1548 f2fs_bug_on(sbi, blkaddr == NULL_ADDR);
1549
1550 cpage = find_lock_page(META_MAPPING(sbi), blkaddr);
1551 if (cpage) {
1480 f2fs_wait_on_page_writeback(cpage, DATA);
1552 f2fs_wait_on_page_writeback(cpage, DATA, true);
1481 f2fs_put_page(cpage, 1);
1482 }
1483}
1484
1485static int read_compacted_summaries(struct f2fs_sb_info *sbi)
1486{
1487 struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi);
1488 struct curseg_info *seg_i;

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

1493
1494 start = start_sum_block(sbi);
1495
1496 page = get_meta_page(sbi, start++);
1497 kaddr = (unsigned char *)page_address(page);
1498
1499 /* Step 1: restore nat cache */
1500 seg_i = CURSEG_I(sbi, CURSEG_HOT_DATA);
1553 f2fs_put_page(cpage, 1);
1554 }
1555}
1556
1557static int read_compacted_summaries(struct f2fs_sb_info *sbi)
1558{
1559 struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi);
1560 struct curseg_info *seg_i;

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

1565
1566 start = start_sum_block(sbi);
1567
1568 page = get_meta_page(sbi, start++);
1569 kaddr = (unsigned char *)page_address(page);
1570
1571 /* Step 1: restore nat cache */
1572 seg_i = CURSEG_I(sbi, CURSEG_HOT_DATA);
1501 memcpy(&seg_i->sum_blk->n_nats, kaddr, SUM_JOURNAL_SIZE);
1573 memcpy(seg_i->journal, kaddr, SUM_JOURNAL_SIZE);
1502
1503 /* Step 2: restore sit cache */
1504 seg_i = CURSEG_I(sbi, CURSEG_COLD_DATA);
1574
1575 /* Step 2: restore sit cache */
1576 seg_i = CURSEG_I(sbi, CURSEG_COLD_DATA);
1505 memcpy(&seg_i->sum_blk->n_sits, kaddr + SUM_JOURNAL_SIZE,
1506 SUM_JOURNAL_SIZE);
1577 memcpy(seg_i->journal, kaddr + SUM_JOURNAL_SIZE, SUM_JOURNAL_SIZE);
1507 offset = 2 * SUM_JOURNAL_SIZE;
1508
1509 /* Step 3: restore summary entries */
1510 for (i = CURSEG_HOT_DATA; i <= CURSEG_COLD_DATA; i++) {
1511 unsigned short blk_off;
1512 unsigned int segno;
1513
1514 seg_i = CURSEG_I(sbi, i);

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

1594 return err;
1595 }
1596 }
1597 }
1598
1599 /* set uncompleted segment to curseg */
1600 curseg = CURSEG_I(sbi, type);
1601 mutex_lock(&curseg->curseg_mutex);
1578 offset = 2 * SUM_JOURNAL_SIZE;
1579
1580 /* Step 3: restore summary entries */
1581 for (i = CURSEG_HOT_DATA; i <= CURSEG_COLD_DATA; i++) {
1582 unsigned short blk_off;
1583 unsigned int segno;
1584
1585 seg_i = CURSEG_I(sbi, i);

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

1665 return err;
1666 }
1667 }
1668 }
1669
1670 /* set uncompleted segment to curseg */
1671 curseg = CURSEG_I(sbi, type);
1672 mutex_lock(&curseg->curseg_mutex);
1602 memcpy(curseg->sum_blk, sum, PAGE_CACHE_SIZE);
1673
1674 /* update journal info */
1675 down_write(&curseg->journal_rwsem);
1676 memcpy(curseg->journal, &sum->journal, SUM_JOURNAL_SIZE);
1677 up_write(&curseg->journal_rwsem);
1678
1679 memcpy(curseg->sum_blk->entries, sum->entries, SUM_ENTRY_SIZE);
1680 memcpy(&curseg->sum_blk->footer, &sum->footer, SUM_FOOTER_SIZE);
1603 curseg->next_segno = segno;
1604 reset_curseg(sbi, type, 0);
1605 curseg->alloc_type = ckpt->alloc_type[type];
1606 curseg->next_blkoff = blk_off;
1607 mutex_unlock(&curseg->curseg_mutex);
1608 f2fs_put_page(new, 1);
1609 return 0;
1610}

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

1649 int written_size = 0;
1650 int i, j;
1651
1652 page = grab_meta_page(sbi, blkaddr++);
1653 kaddr = (unsigned char *)page_address(page);
1654
1655 /* Step 1: write nat cache */
1656 seg_i = CURSEG_I(sbi, CURSEG_HOT_DATA);
1681 curseg->next_segno = segno;
1682 reset_curseg(sbi, type, 0);
1683 curseg->alloc_type = ckpt->alloc_type[type];
1684 curseg->next_blkoff = blk_off;
1685 mutex_unlock(&curseg->curseg_mutex);
1686 f2fs_put_page(new, 1);
1687 return 0;
1688}

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

1727 int written_size = 0;
1728 int i, j;
1729
1730 page = grab_meta_page(sbi, blkaddr++);
1731 kaddr = (unsigned char *)page_address(page);
1732
1733 /* Step 1: write nat cache */
1734 seg_i = CURSEG_I(sbi, CURSEG_HOT_DATA);
1657 memcpy(kaddr, &seg_i->sum_blk->n_nats, SUM_JOURNAL_SIZE);
1735 memcpy(kaddr, seg_i->journal, SUM_JOURNAL_SIZE);
1658 written_size += SUM_JOURNAL_SIZE;
1659
1660 /* Step 2: write sit cache */
1661 seg_i = CURSEG_I(sbi, CURSEG_COLD_DATA);
1736 written_size += SUM_JOURNAL_SIZE;
1737
1738 /* Step 2: write sit cache */
1739 seg_i = CURSEG_I(sbi, CURSEG_COLD_DATA);
1662 memcpy(kaddr + written_size, &seg_i->sum_blk->n_sits,
1663 SUM_JOURNAL_SIZE);
1740 memcpy(kaddr + written_size, seg_i->journal, SUM_JOURNAL_SIZE);
1664 written_size += SUM_JOURNAL_SIZE;
1665
1666 /* Step 3: write summary entries */
1667 for (i = CURSEG_HOT_DATA; i <= CURSEG_COLD_DATA; i++) {
1668 unsigned short blkoff;
1669 seg_i = CURSEG_I(sbi, i);
1670 if (sbi->ckpt->alloc_type[i] == SSR)
1671 blkoff = sbi->blocks_per_seg;

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

1701 block_t blkaddr, int type)
1702{
1703 int i, end;
1704 if (IS_DATASEG(type))
1705 end = type + NR_CURSEG_DATA_TYPE;
1706 else
1707 end = type + NR_CURSEG_NODE_TYPE;
1708
1741 written_size += SUM_JOURNAL_SIZE;
1742
1743 /* Step 3: write summary entries */
1744 for (i = CURSEG_HOT_DATA; i <= CURSEG_COLD_DATA; i++) {
1745 unsigned short blkoff;
1746 seg_i = CURSEG_I(sbi, i);
1747 if (sbi->ckpt->alloc_type[i] == SSR)
1748 blkoff = sbi->blocks_per_seg;

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

1778 block_t blkaddr, int type)
1779{
1780 int i, end;
1781 if (IS_DATASEG(type))
1782 end = type + NR_CURSEG_DATA_TYPE;
1783 else
1784 end = type + NR_CURSEG_NODE_TYPE;
1785
1709 for (i = type; i < end; i++) {
1710 struct curseg_info *sum = CURSEG_I(sbi, i);
1711 mutex_lock(&sum->curseg_mutex);
1712 write_sum_page(sbi, sum->sum_blk, blkaddr + (i - type));
1713 mutex_unlock(&sum->curseg_mutex);
1714 }
1786 for (i = type; i < end; i++)
1787 write_current_sum_page(sbi, i, blkaddr + (i - type));
1715}
1716
1717void write_data_summaries(struct f2fs_sb_info *sbi, block_t start_blk)
1718{
1719 if (is_set_ckpt_flags(F2FS_CKPT(sbi), CP_COMPACT_SUM_FLAG))
1720 write_compacted_summaries(sbi, start_blk);
1721 else
1722 write_normal_summaries(sbi, start_blk, CURSEG_HOT_DATA);
1723}
1724
1725void write_node_summaries(struct f2fs_sb_info *sbi, block_t start_blk)
1726{
1727 write_normal_summaries(sbi, start_blk, CURSEG_HOT_NODE);
1728}
1729
1788}
1789
1790void write_data_summaries(struct f2fs_sb_info *sbi, block_t start_blk)
1791{
1792 if (is_set_ckpt_flags(F2FS_CKPT(sbi), CP_COMPACT_SUM_FLAG))
1793 write_compacted_summaries(sbi, start_blk);
1794 else
1795 write_normal_summaries(sbi, start_blk, CURSEG_HOT_DATA);
1796}
1797
1798void write_node_summaries(struct f2fs_sb_info *sbi, block_t start_blk)
1799{
1800 write_normal_summaries(sbi, start_blk, CURSEG_HOT_NODE);
1801}
1802
1730int lookup_journal_in_cursum(struct f2fs_summary_block *sum, int type,
1803int lookup_journal_in_cursum(struct f2fs_journal *journal, int type,
1731 unsigned int val, int alloc)
1732{
1733 int i;
1734
1735 if (type == NAT_JOURNAL) {
1804 unsigned int val, int alloc)
1805{
1806 int i;
1807
1808 if (type == NAT_JOURNAL) {
1736 for (i = 0; i < nats_in_cursum(sum); i++) {
1737 if (le32_to_cpu(nid_in_journal(sum, i)) == val)
1809 for (i = 0; i < nats_in_cursum(journal); i++) {
1810 if (le32_to_cpu(nid_in_journal(journal, i)) == val)
1738 return i;
1739 }
1811 return i;
1812 }
1740 if (alloc && __has_cursum_space(sum, 1, NAT_JOURNAL))
1741 return update_nats_in_cursum(sum, 1);
1813 if (alloc && __has_cursum_space(journal, 1, NAT_JOURNAL))
1814 return update_nats_in_cursum(journal, 1);
1742 } else if (type == SIT_JOURNAL) {
1815 } else if (type == SIT_JOURNAL) {
1743 for (i = 0; i < sits_in_cursum(sum); i++)
1744 if (le32_to_cpu(segno_in_journal(sum, i)) == val)
1816 for (i = 0; i < sits_in_cursum(journal); i++)
1817 if (le32_to_cpu(segno_in_journal(journal, i)) == val)
1745 return i;
1818 return i;
1746 if (alloc && __has_cursum_space(sum, 1, SIT_JOURNAL))
1747 return update_sits_in_cursum(sum, 1);
1819 if (alloc && __has_cursum_space(journal, 1, SIT_JOURNAL))
1820 return update_sits_in_cursum(journal, 1);
1748 }
1749 return -1;
1750}
1751
1752static struct page *get_current_sit_page(struct f2fs_sb_info *sbi,
1753 unsigned int segno)
1754{
1755 return get_meta_page(sbi, current_sit_addr(sbi, segno));

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

1843
1844 for_each_set_bit(segno, bitmap, MAIN_SEGS(sbi))
1845 add_sit_entry(segno, set_list);
1846}
1847
1848static void remove_sits_in_journal(struct f2fs_sb_info *sbi)
1849{
1850 struct curseg_info *curseg = CURSEG_I(sbi, CURSEG_COLD_DATA);
1821 }
1822 return -1;
1823}
1824
1825static struct page *get_current_sit_page(struct f2fs_sb_info *sbi,
1826 unsigned int segno)
1827{
1828 return get_meta_page(sbi, current_sit_addr(sbi, segno));

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

1916
1917 for_each_set_bit(segno, bitmap, MAIN_SEGS(sbi))
1918 add_sit_entry(segno, set_list);
1919}
1920
1921static void remove_sits_in_journal(struct f2fs_sb_info *sbi)
1922{
1923 struct curseg_info *curseg = CURSEG_I(sbi, CURSEG_COLD_DATA);
1851 struct f2fs_summary_block *sum = curseg->sum_blk;
1924 struct f2fs_journal *journal = curseg->journal;
1852 int i;
1853
1925 int i;
1926
1854 for (i = sits_in_cursum(sum) - 1; i >= 0; i--) {
1927 down_write(&curseg->journal_rwsem);
1928 for (i = 0; i < sits_in_cursum(journal); i++) {
1855 unsigned int segno;
1856 bool dirtied;
1857
1929 unsigned int segno;
1930 bool dirtied;
1931
1858 segno = le32_to_cpu(segno_in_journal(sum, i));
1932 segno = le32_to_cpu(segno_in_journal(journal, i));
1859 dirtied = __mark_sit_entry_dirty(sbi, segno);
1860
1861 if (!dirtied)
1862 add_sit_entry(segno, &SM_I(sbi)->sit_entry_set);
1863 }
1933 dirtied = __mark_sit_entry_dirty(sbi, segno);
1934
1935 if (!dirtied)
1936 add_sit_entry(segno, &SM_I(sbi)->sit_entry_set);
1937 }
1864 update_sits_in_cursum(sum, -sits_in_cursum(sum));
1938 update_sits_in_cursum(journal, -i);
1939 up_write(&curseg->journal_rwsem);
1865}
1866
1867/*
1868 * CP calls this function, which flushes SIT entries including sit_journal,
1869 * and moves prefree segs to free segs.
1870 */
1871void flush_sit_entries(struct f2fs_sb_info *sbi, struct cp_control *cpc)
1872{
1873 struct sit_info *sit_i = SIT_I(sbi);
1874 unsigned long *bitmap = sit_i->dirty_sentries_bitmap;
1875 struct curseg_info *curseg = CURSEG_I(sbi, CURSEG_COLD_DATA);
1940}
1941
1942/*
1943 * CP calls this function, which flushes SIT entries including sit_journal,
1944 * and moves prefree segs to free segs.
1945 */
1946void flush_sit_entries(struct f2fs_sb_info *sbi, struct cp_control *cpc)
1947{
1948 struct sit_info *sit_i = SIT_I(sbi);
1949 unsigned long *bitmap = sit_i->dirty_sentries_bitmap;
1950 struct curseg_info *curseg = CURSEG_I(sbi, CURSEG_COLD_DATA);
1876 struct f2fs_summary_block *sum = curseg->sum_blk;
1951 struct f2fs_journal *journal = curseg->journal;
1877 struct sit_entry_set *ses, *tmp;
1878 struct list_head *head = &SM_I(sbi)->sit_entry_set;
1879 bool to_journal = true;
1880 struct seg_entry *se;
1881
1952 struct sit_entry_set *ses, *tmp;
1953 struct list_head *head = &SM_I(sbi)->sit_entry_set;
1954 bool to_journal = true;
1955 struct seg_entry *se;
1956
1882 mutex_lock(&curseg->curseg_mutex);
1883 mutex_lock(&sit_i->sentry_lock);
1884
1885 if (!sit_i->dirty_sentries)
1886 goto out;
1887
1888 /*
1889 * add and account sit entries of dirty bitmap in sit entry
1890 * set temporarily
1891 */
1892 add_sits_in_set(sbi);
1893
1894 /*
1895 * if there are no enough space in journal to store dirty sit
1896 * entries, remove all entries from journal and add and account
1897 * them in sit entry set.
1898 */
1957 mutex_lock(&sit_i->sentry_lock);
1958
1959 if (!sit_i->dirty_sentries)
1960 goto out;
1961
1962 /*
1963 * add and account sit entries of dirty bitmap in sit entry
1964 * set temporarily
1965 */
1966 add_sits_in_set(sbi);
1967
1968 /*
1969 * if there are no enough space in journal to store dirty sit
1970 * entries, remove all entries from journal and add and account
1971 * them in sit entry set.
1972 */
1899 if (!__has_cursum_space(sum, sit_i->dirty_sentries, SIT_JOURNAL))
1973 if (!__has_cursum_space(journal, sit_i->dirty_sentries, SIT_JOURNAL))
1900 remove_sits_in_journal(sbi);
1901
1902 /*
1903 * there are two steps to flush sit entries:
1904 * #1, flush sit entries to journal in current cold data summary block.
1905 * #2, flush sit entries to sit page.
1906 */
1907 list_for_each_entry_safe(ses, tmp, head, set_list) {
1908 struct page *page = NULL;
1909 struct f2fs_sit_block *raw_sit = NULL;
1910 unsigned int start_segno = ses->start_segno;
1911 unsigned int end = min(start_segno + SIT_ENTRY_PER_BLOCK,
1912 (unsigned long)MAIN_SEGS(sbi));
1913 unsigned int segno = start_segno;
1914
1915 if (to_journal &&
1974 remove_sits_in_journal(sbi);
1975
1976 /*
1977 * there are two steps to flush sit entries:
1978 * #1, flush sit entries to journal in current cold data summary block.
1979 * #2, flush sit entries to sit page.
1980 */
1981 list_for_each_entry_safe(ses, tmp, head, set_list) {
1982 struct page *page = NULL;
1983 struct f2fs_sit_block *raw_sit = NULL;
1984 unsigned int start_segno = ses->start_segno;
1985 unsigned int end = min(start_segno + SIT_ENTRY_PER_BLOCK,
1986 (unsigned long)MAIN_SEGS(sbi));
1987 unsigned int segno = start_segno;
1988
1989 if (to_journal &&
1916 !__has_cursum_space(sum, ses->entry_cnt, SIT_JOURNAL))
1990 !__has_cursum_space(journal, ses->entry_cnt, SIT_JOURNAL))
1917 to_journal = false;
1918
1991 to_journal = false;
1992
1919 if (!to_journal) {
1993 if (to_journal) {
1994 down_write(&curseg->journal_rwsem);
1995 } else {
1920 page = get_next_sit_page(sbi, start_segno);
1921 raw_sit = page_address(page);
1922 }
1923
1924 /* flush dirty sit entries in region of current sit set */
1925 for_each_set_bit_from(segno, bitmap, end) {
1926 int offset, sit_offset;
1927
1928 se = get_seg_entry(sbi, segno);
1929
1930 /* add discard candidates */
1931 if (cpc->reason != CP_DISCARD) {
1932 cpc->trim_start = segno;
1933 add_discard_addrs(sbi, cpc);
1934 }
1935
1936 if (to_journal) {
1996 page = get_next_sit_page(sbi, start_segno);
1997 raw_sit = page_address(page);
1998 }
1999
2000 /* flush dirty sit entries in region of current sit set */
2001 for_each_set_bit_from(segno, bitmap, end) {
2002 int offset, sit_offset;
2003
2004 se = get_seg_entry(sbi, segno);
2005
2006 /* add discard candidates */
2007 if (cpc->reason != CP_DISCARD) {
2008 cpc->trim_start = segno;
2009 add_discard_addrs(sbi, cpc);
2010 }
2011
2012 if (to_journal) {
1937 offset = lookup_journal_in_cursum(sum,
2013 offset = lookup_journal_in_cursum(journal,
1938 SIT_JOURNAL, segno, 1);
1939 f2fs_bug_on(sbi, offset < 0);
2014 SIT_JOURNAL, segno, 1);
2015 f2fs_bug_on(sbi, offset < 0);
1940 segno_in_journal(sum, offset) =
2016 segno_in_journal(journal, offset) =
1941 cpu_to_le32(segno);
1942 seg_info_to_raw_sit(se,
2017 cpu_to_le32(segno);
2018 seg_info_to_raw_sit(se,
1943 &sit_in_journal(sum, offset));
2019 &sit_in_journal(journal, offset));
1944 } else {
1945 sit_offset = SIT_ENTRY_OFFSET(sit_i, segno);
1946 seg_info_to_raw_sit(se,
1947 &raw_sit->entries[sit_offset]);
1948 }
1949
1950 __clear_bit(segno, bitmap);
1951 sit_i->dirty_sentries--;
1952 ses->entry_cnt--;
1953 }
1954
2020 } else {
2021 sit_offset = SIT_ENTRY_OFFSET(sit_i, segno);
2022 seg_info_to_raw_sit(se,
2023 &raw_sit->entries[sit_offset]);
2024 }
2025
2026 __clear_bit(segno, bitmap);
2027 sit_i->dirty_sentries--;
2028 ses->entry_cnt--;
2029 }
2030
1955 if (!to_journal)
2031 if (to_journal)
2032 up_write(&curseg->journal_rwsem);
2033 else
1956 f2fs_put_page(page, 1);
1957
1958 f2fs_bug_on(sbi, ses->entry_cnt);
1959 release_sit_entry_set(ses);
1960 }
1961
1962 f2fs_bug_on(sbi, !list_empty(head));
1963 f2fs_bug_on(sbi, sit_i->dirty_sentries);
1964out:
1965 if (cpc->reason == CP_DISCARD) {
1966 for (; cpc->trim_start <= cpc->trim_end; cpc->trim_start++)
1967 add_discard_addrs(sbi, cpc);
1968 }
1969 mutex_unlock(&sit_i->sentry_lock);
2034 f2fs_put_page(page, 1);
2035
2036 f2fs_bug_on(sbi, ses->entry_cnt);
2037 release_sit_entry_set(ses);
2038 }
2039
2040 f2fs_bug_on(sbi, !list_empty(head));
2041 f2fs_bug_on(sbi, sit_i->dirty_sentries);
2042out:
2043 if (cpc->reason == CP_DISCARD) {
2044 for (; cpc->trim_start <= cpc->trim_end; cpc->trim_start++)
2045 add_discard_addrs(sbi, cpc);
2046 }
2047 mutex_unlock(&sit_i->sentry_lock);
1970 mutex_unlock(&curseg->curseg_mutex);
1971
1972 set_prefree_as_free_segments(sbi);
1973}
1974
1975static int build_sit_info(struct f2fs_sb_info *sbi)
1976{
1977 struct f2fs_super_block *raw_super = F2FS_RAW_SUPER(sbi);
1978 struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi);

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

2094
2095 SM_I(sbi)->curseg_array = array;
2096
2097 for (i = 0; i < NR_CURSEG_TYPE; i++) {
2098 mutex_init(&array[i].curseg_mutex);
2099 array[i].sum_blk = kzalloc(PAGE_CACHE_SIZE, GFP_KERNEL);
2100 if (!array[i].sum_blk)
2101 return -ENOMEM;
2048
2049 set_prefree_as_free_segments(sbi);
2050}
2051
2052static int build_sit_info(struct f2fs_sb_info *sbi)
2053{
2054 struct f2fs_super_block *raw_super = F2FS_RAW_SUPER(sbi);
2055 struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi);

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

2171
2172 SM_I(sbi)->curseg_array = array;
2173
2174 for (i = 0; i < NR_CURSEG_TYPE; i++) {
2175 mutex_init(&array[i].curseg_mutex);
2176 array[i].sum_blk = kzalloc(PAGE_CACHE_SIZE, GFP_KERNEL);
2177 if (!array[i].sum_blk)
2178 return -ENOMEM;
2179 init_rwsem(&array[i].journal_rwsem);
2180 array[i].journal = kzalloc(sizeof(struct f2fs_journal),
2181 GFP_KERNEL);
2182 if (!array[i].journal)
2183 return -ENOMEM;
2102 array[i].segno = NULL_SEGNO;
2103 array[i].next_blkoff = 0;
2104 }
2105 return restore_curseg_summaries(sbi);
2106}
2107
2108static void build_sit_entries(struct f2fs_sb_info *sbi)
2109{
2110 struct sit_info *sit_i = SIT_I(sbi);
2111 struct curseg_info *curseg = CURSEG_I(sbi, CURSEG_COLD_DATA);
2184 array[i].segno = NULL_SEGNO;
2185 array[i].next_blkoff = 0;
2186 }
2187 return restore_curseg_summaries(sbi);
2188}
2189
2190static void build_sit_entries(struct f2fs_sb_info *sbi)
2191{
2192 struct sit_info *sit_i = SIT_I(sbi);
2193 struct curseg_info *curseg = CURSEG_I(sbi, CURSEG_COLD_DATA);
2112 struct f2fs_summary_block *sum = curseg->sum_blk;
2194 struct f2fs_journal *journal = curseg->journal;
2113 int sit_blk_cnt = SIT_BLK_CNT(sbi);
2114 unsigned int i, start, end;
2115 unsigned int readed, start_blk = 0;
2195 int sit_blk_cnt = SIT_BLK_CNT(sbi);
2196 unsigned int i, start, end;
2197 unsigned int readed, start_blk = 0;
2116 int nrpages = MAX_BIO_BLOCKS(sbi);
2198 int nrpages = MAX_BIO_BLOCKS(sbi) * 8;
2117
2118 do {
2119 readed = ra_meta_pages(sbi, start_blk, nrpages, META_SIT, true);
2120
2121 start = start_blk * sit_i->sents_per_block;
2122 end = (start_blk + readed) * sit_i->sents_per_block;
2123
2124 for (; start < end && start < MAIN_SEGS(sbi); start++) {
2125 struct seg_entry *se = &sit_i->sentries[start];
2126 struct f2fs_sit_block *sit_blk;
2127 struct f2fs_sit_entry sit;
2128 struct page *page;
2129
2199
2200 do {
2201 readed = ra_meta_pages(sbi, start_blk, nrpages, META_SIT, true);
2202
2203 start = start_blk * sit_i->sents_per_block;
2204 end = (start_blk + readed) * sit_i->sents_per_block;
2205
2206 for (; start < end && start < MAIN_SEGS(sbi); start++) {
2207 struct seg_entry *se = &sit_i->sentries[start];
2208 struct f2fs_sit_block *sit_blk;
2209 struct f2fs_sit_entry sit;
2210 struct page *page;
2211
2130 mutex_lock(&curseg->curseg_mutex);
2131 for (i = 0; i < sits_in_cursum(sum); i++) {
2132 if (le32_to_cpu(segno_in_journal(sum, i))
2212 down_read(&curseg->journal_rwsem);
2213 for (i = 0; i < sits_in_cursum(journal); i++) {
2214 if (le32_to_cpu(segno_in_journal(journal, i))
2133 == start) {
2215 == start) {
2134 sit = sit_in_journal(sum, i);
2135 mutex_unlock(&curseg->curseg_mutex);
2216 sit = sit_in_journal(journal, i);
2217 up_read(&curseg->journal_rwsem);
2136 goto got_it;
2137 }
2138 }
2218 goto got_it;
2219 }
2220 }
2139 mutex_unlock(&curseg->curseg_mutex);
2221 up_read(&curseg->journal_rwsem);
2140
2141 page = get_current_sit_page(sbi, start);
2142 sit_blk = (struct f2fs_sit_block *)page_address(page);
2143 sit = sit_blk->entries[SIT_ENTRY_OFFSET(sit_i, start)];
2144 f2fs_put_page(page, 1);
2145got_it:
2146 check_block_count(sbi, start, &sit);
2147 seg_info_from_raw_sit(se, &sit);

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

2366static void destroy_curseg(struct f2fs_sb_info *sbi)
2367{
2368 struct curseg_info *array = SM_I(sbi)->curseg_array;
2369 int i;
2370
2371 if (!array)
2372 return;
2373 SM_I(sbi)->curseg_array = NULL;
2222
2223 page = get_current_sit_page(sbi, start);
2224 sit_blk = (struct f2fs_sit_block *)page_address(page);
2225 sit = sit_blk->entries[SIT_ENTRY_OFFSET(sit_i, start)];
2226 f2fs_put_page(page, 1);
2227got_it:
2228 check_block_count(sbi, start, &sit);
2229 seg_info_from_raw_sit(se, &sit);

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

2448static void destroy_curseg(struct f2fs_sb_info *sbi)
2449{
2450 struct curseg_info *array = SM_I(sbi)->curseg_array;
2451 int i;
2452
2453 if (!array)
2454 return;
2455 SM_I(sbi)->curseg_array = NULL;
2374 for (i = 0; i < NR_CURSEG_TYPE; i++)
2456 for (i = 0; i < NR_CURSEG_TYPE; i++) {
2375 kfree(array[i].sum_blk);
2457 kfree(array[i].sum_blk);
2458 kfree(array[i].journal);
2459 }
2376 kfree(array);
2377}
2378
2379static void destroy_free_segmap(struct f2fs_sb_info *sbi)
2380{
2381 struct free_segmap_info *free_i = SM_I(sbi)->free_info;
2382 if (!free_i)
2383 return;

--- 79 unchanged lines hidden --- 		2460 kfree(array);
2461}
2462
2463static void destroy_free_segmap(struct f2fs_sb_info *sbi)
2464{
2465 struct free_segmap_info *free_i = SM_I(sbi)->free_info;
2466 if (!free_i)
2467 return;

--- 79 unchanged lines hidden ---