projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
f2fs: refactor flush_sit_entries codes for reducing SIT writes
[deliverable/linux.git] / fs / f2fs / node.c
1 /*
2 * fs/f2fs/node.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
9 * published by the Free Software Foundation.
10 */
11 #include <linux/fs.h>
12 #include <linux/f2fs_fs.h>
13 #include <linux/mpage.h>
14 #include <linux/backing-dev.h>
15 #include <linux/blkdev.h>
16 #include <linux/pagevec.h>
17 #include <linux/swap.h>
18
19 #include "f2fs.h"
20 #include "node.h"
21 #include "segment.h"
22 #include <trace/events/f2fs.h>
23
24 #define on_build_free_nids(nmi) mutex_is_locked(&nm_i->build_lock)
25
26 static struct kmem_cache *nat_entry_slab;
27 static struct kmem_cache *free_nid_slab;
28 static struct kmem_cache *nat_entry_set_slab;
29
30 bool available_free_memory(struct f2fs_sb_info *sbi, int type)
31 {
32 struct f2fs_nm_info *nm_i = NM_I(sbi);
33 struct sysinfo val;
34 unsigned long mem_size = 0;
35 bool res = false;
36
37 si_meminfo(&val);
38 /* give 25%, 25%, 50% memory for each components respectively */
39 if (type == FREE_NIDS) {
40 mem_size = (nm_i->fcnt * sizeof(struct free_nid)) >> 12;
41 res = mem_size < ((val.totalram * nm_i->ram_thresh / 100) >> 2);
42 } else if (type == NAT_ENTRIES) {
43 mem_size = (nm_i->nat_cnt * sizeof(struct nat_entry)) >> 12;
44 res = mem_size < ((val.totalram * nm_i->ram_thresh / 100) >> 2);
45 } else if (type == DIRTY_DENTS) {
46 if (sbi->sb->s_bdi->dirty_exceeded)
47 return false;
48 mem_size = get_pages(sbi, F2FS_DIRTY_DENTS);
49 res = mem_size < ((val.totalram * nm_i->ram_thresh / 100) >> 1);
50 }
51 return res;
52 }
53
54 static void clear_node_page_dirty(struct page *page)
55 {
56 struct address_space *mapping = page->mapping;
57 unsigned int long flags;
58
59 if (PageDirty(page)) {
60 spin_lock_irqsave(&mapping->tree_lock, flags);
61 radix_tree_tag_clear(&mapping->page_tree,
62 page_index(page),
63 PAGECACHE_TAG_DIRTY);
64 spin_unlock_irqrestore(&mapping->tree_lock, flags);
65
66 clear_page_dirty_for_io(page);
67 dec_page_count(F2FS_M_SB(mapping), F2FS_DIRTY_NODES);
68 }
69 ClearPageUptodate(page);
70 }
71
72 static struct page *get_current_nat_page(struct f2fs_sb_info *sbi, nid_t nid)
73 {
74 pgoff_t index = current_nat_addr(sbi, nid);
75 return get_meta_page(sbi, index);
76 }
77
78 static struct page *get_next_nat_page(struct f2fs_sb_info *sbi, nid_t nid)
79 {
80 struct page *src_page;
81 struct page *dst_page;
82 pgoff_t src_off;
83 pgoff_t dst_off;
84 void *src_addr;
85 void *dst_addr;
86 struct f2fs_nm_info *nm_i = NM_I(sbi);
87
88 src_off = current_nat_addr(sbi, nid);
89 dst_off = next_nat_addr(sbi, src_off);
90
91 /* get current nat block page with lock */
92 src_page = get_meta_page(sbi, src_off);
93 dst_page = grab_meta_page(sbi, dst_off);
94 f2fs_bug_on(sbi, PageDirty(src_page));
95
96 src_addr = page_address(src_page);
97 dst_addr = page_address(dst_page);
98 memcpy(dst_addr, src_addr, PAGE_CACHE_SIZE);
99 set_page_dirty(dst_page);
100 f2fs_put_page(src_page, 1);
101
102 set_to_next_nat(nm_i, nid);
103
104 return dst_page;
105 }
106
107 static struct nat_entry *__lookup_nat_cache(struct f2fs_nm_info *nm_i, nid_t n)
108 {
109 return radix_tree_lookup(&nm_i->nat_root, n);
110 }
111
112 static unsigned int __gang_lookup_nat_cache(struct f2fs_nm_info *nm_i,
113 nid_t start, unsigned int nr, struct nat_entry **ep)
114 {
115 return radix_tree_gang_lookup(&nm_i->nat_root, (void **)ep, start, nr);
116 }
117
118 static void __del_from_nat_cache(struct f2fs_nm_info *nm_i, struct nat_entry *e)
119 {
120 list_del(&e->list);
121 radix_tree_delete(&nm_i->nat_root, nat_get_nid(e));
122 nm_i->nat_cnt--;
123 kmem_cache_free(nat_entry_slab, e);
124 }
125
126 int is_checkpointed_node(struct f2fs_sb_info *sbi, nid_t nid)
127 {
128 struct f2fs_nm_info *nm_i = NM_I(sbi);
129 struct nat_entry *e;
130 int is_cp = 1;
131
132 read_lock(&nm_i->nat_tree_lock);
133 e = __lookup_nat_cache(nm_i, nid);
134 if (e && !e->checkpointed)
135 is_cp = 0;
136 read_unlock(&nm_i->nat_tree_lock);
137 return is_cp;
138 }
139
140 bool fsync_mark_done(struct f2fs_sb_info *sbi, nid_t nid)
141 {
142 struct f2fs_nm_info *nm_i = NM_I(sbi);
143 struct nat_entry *e;
144 bool fsync_done = false;
145
146 read_lock(&nm_i->nat_tree_lock);
147 e = __lookup_nat_cache(nm_i, nid);
148 if (e)
149 fsync_done = e->fsync_done;
150 read_unlock(&nm_i->nat_tree_lock);
151 return fsync_done;
152 }
153
154 void fsync_mark_clear(struct f2fs_sb_info *sbi, nid_t nid)
155 {
156 struct f2fs_nm_info *nm_i = NM_I(sbi);
157 struct nat_entry *e;
158
159 write_lock(&nm_i->nat_tree_lock);
160 e = __lookup_nat_cache(nm_i, nid);
161 if (e)
162 e->fsync_done = false;
163 write_unlock(&nm_i->nat_tree_lock);
164 }
165
166 static struct nat_entry *grab_nat_entry(struct f2fs_nm_info *nm_i, nid_t nid)
167 {
168 struct nat_entry *new;
169
170 new = kmem_cache_alloc(nat_entry_slab, GFP_ATOMIC);
171 if (!new)
172 return NULL;
173 if (radix_tree_insert(&nm_i->nat_root, nid, new)) {
174 kmem_cache_free(nat_entry_slab, new);
175 return NULL;
176 }
177 memset(new, 0, sizeof(struct nat_entry));
178 nat_set_nid(new, nid);
179 new->checkpointed = true;
180 list_add_tail(&new->list, &nm_i->nat_entries);
181 nm_i->nat_cnt++;
182 return new;
183 }
184
185 static void cache_nat_entry(struct f2fs_nm_info *nm_i, nid_t nid,
186 struct f2fs_nat_entry *ne)
187 {
188 struct nat_entry *e;
189 retry:
190 write_lock(&nm_i->nat_tree_lock);
191 e = __lookup_nat_cache(nm_i, nid);
192 if (!e) {
193 e = grab_nat_entry(nm_i, nid);
194 if (!e) {
195 write_unlock(&nm_i->nat_tree_lock);
196 goto retry;
197 }
198 node_info_from_raw_nat(&e->ni, ne);
199 }
200 write_unlock(&nm_i->nat_tree_lock);
201 }
202
203 static void set_node_addr(struct f2fs_sb_info *sbi, struct node_info *ni,
204 block_t new_blkaddr, bool fsync_done)
205 {
206 struct f2fs_nm_info *nm_i = NM_I(sbi);
207 struct nat_entry *e;
208 retry:
209 write_lock(&nm_i->nat_tree_lock);
210 e = __lookup_nat_cache(nm_i, ni->nid);
211 if (!e) {
212 e = grab_nat_entry(nm_i, ni->nid);
213 if (!e) {
214 write_unlock(&nm_i->nat_tree_lock);
215 goto retry;
216 }
217 e->ni = *ni;
218 f2fs_bug_on(sbi, ni->blk_addr == NEW_ADDR);
219 } else if (new_blkaddr == NEW_ADDR) {
220 /*
221 * when nid is reallocated,
222 * previous nat entry can be remained in nat cache.
223 * So, reinitialize it with new information.
224 */
225 e->ni = *ni;
226 f2fs_bug_on(sbi, ni->blk_addr != NULL_ADDR);
227 }
228
229 /* sanity check */
230 f2fs_bug_on(sbi, nat_get_blkaddr(e) != ni->blk_addr);
231 f2fs_bug_on(sbi, nat_get_blkaddr(e) == NULL_ADDR &&
232 new_blkaddr == NULL_ADDR);
233 f2fs_bug_on(sbi, nat_get_blkaddr(e) == NEW_ADDR &&
234 new_blkaddr == NEW_ADDR);
235 f2fs_bug_on(sbi, nat_get_blkaddr(e) != NEW_ADDR &&
236 nat_get_blkaddr(e) != NULL_ADDR &&
237 new_blkaddr == NEW_ADDR);
238
239 /* increment version no as node is removed */
240 if (nat_get_blkaddr(e) != NEW_ADDR && new_blkaddr == NULL_ADDR) {
241 unsigned char version = nat_get_version(e);
242 nat_set_version(e, inc_node_version(version));
243 }
244
245 /* change address */
246 nat_set_blkaddr(e, new_blkaddr);
247 __set_nat_cache_dirty(nm_i, e);
248
249 /* update fsync_mark if its inode nat entry is still alive */
250 e = __lookup_nat_cache(nm_i, ni->ino);
251 if (e)
252 e->fsync_done = fsync_done;
253 write_unlock(&nm_i->nat_tree_lock);
254 }
255
256 int try_to_free_nats(struct f2fs_sb_info *sbi, int nr_shrink)
257 {
258 struct f2fs_nm_info *nm_i = NM_I(sbi);
259
260 if (available_free_memory(sbi, NAT_ENTRIES))
261 return 0;
262
263 write_lock(&nm_i->nat_tree_lock);
264 while (nr_shrink && !list_empty(&nm_i->nat_entries)) {
265 struct nat_entry *ne;
266 ne = list_first_entry(&nm_i->nat_entries,
267 struct nat_entry, list);
268 __del_from_nat_cache(nm_i, ne);
269 nr_shrink--;
270 }
271 write_unlock(&nm_i->nat_tree_lock);
272 return nr_shrink;
273 }
274
275 /*
276 * This function always returns success
277 */
278 void get_node_info(struct f2fs_sb_info *sbi, nid_t nid, struct node_info *ni)
279 {
280 struct f2fs_nm_info *nm_i = NM_I(sbi);
281 struct curseg_info *curseg = CURSEG_I(sbi, CURSEG_HOT_DATA);
282 struct f2fs_summary_block *sum = curseg->sum_blk;
283 nid_t start_nid = START_NID(nid);
284 struct f2fs_nat_block *nat_blk;
285 struct page *page = NULL;
286 struct f2fs_nat_entry ne;
287 struct nat_entry *e;
288 int i;
289
290 memset(&ne, 0, sizeof(struct f2fs_nat_entry));
291 ni->nid = nid;
292
293 /* Check nat cache */
294 read_lock(&nm_i->nat_tree_lock);
295 e = __lookup_nat_cache(nm_i, nid);
296 if (e) {
297 ni->ino = nat_get_ino(e);
298 ni->blk_addr = nat_get_blkaddr(e);
299 ni->version = nat_get_version(e);
300 }
301 read_unlock(&nm_i->nat_tree_lock);
302 if (e)
303 return;
304
305 /* Check current segment summary */
306 mutex_lock(&curseg->curseg_mutex);
307 i = lookup_journal_in_cursum(sum, NAT_JOURNAL, nid, 0);
308 if (i >= 0) {
309 ne = nat_in_journal(sum, i);
310 node_info_from_raw_nat(ni, &ne);
311 }
312 mutex_unlock(&curseg->curseg_mutex);
313 if (i >= 0)
314 goto cache;
315
316 /* Fill node_info from nat page */
317 page = get_current_nat_page(sbi, start_nid);
318 nat_blk = (struct f2fs_nat_block *)page_address(page);
319 ne = nat_blk->entries[nid - start_nid];
320 node_info_from_raw_nat(ni, &ne);
321 f2fs_put_page(page, 1);
322 cache:
323 /* cache nat entry */
324 cache_nat_entry(NM_I(sbi), nid, &ne);
325 }
326
327 /*
328 * The maximum depth is four.
329 * Offset[0] will have raw inode offset.
330 */
331 static int get_node_path(struct f2fs_inode_info *fi, long block,
332 int offset[4], unsigned int noffset[4])
333 {
334 const long direct_index = ADDRS_PER_INODE(fi);
335 const long direct_blks = ADDRS_PER_BLOCK;
336 const long dptrs_per_blk = NIDS_PER_BLOCK;
337 const long indirect_blks = ADDRS_PER_BLOCK * NIDS_PER_BLOCK;
338 const long dindirect_blks = indirect_blks * NIDS_PER_BLOCK;
339 int n = 0;
340 int level = 0;
341
342 noffset[0] = 0;
343
344 if (block < direct_index) {
345 offset[n] = block;
346 goto got;
347 }
348 block -= direct_index;
349 if (block < direct_blks) {
350 offset[n++] = NODE_DIR1_BLOCK;
351 noffset[n] = 1;
352 offset[n] = block;
353 level = 1;
354 goto got;
355 }
356 block -= direct_blks;
357 if (block < direct_blks) {
358 offset[n++] = NODE_DIR2_BLOCK;
359 noffset[n] = 2;
360 offset[n] = block;
361 level = 1;
362 goto got;
363 }
364 block -= direct_blks;
365 if (block < indirect_blks) {
366 offset[n++] = NODE_IND1_BLOCK;
367 noffset[n] = 3;
368 offset[n++] = block / direct_blks;
369 noffset[n] = 4 + offset[n - 1];
370 offset[n] = block % direct_blks;
371 level = 2;
372 goto got;
373 }
374 block -= indirect_blks;
375 if (block < indirect_blks) {
376 offset[n++] = NODE_IND2_BLOCK;
377 noffset[n] = 4 + dptrs_per_blk;
378 offset[n++] = block / direct_blks;
379 noffset[n] = 5 + dptrs_per_blk + offset[n - 1];
380 offset[n] = block % direct_blks;
381 level = 2;
382 goto got;
383 }
384 block -= indirect_blks;
385 if (block < dindirect_blks) {
386 offset[n++] = NODE_DIND_BLOCK;
387 noffset[n] = 5 + (dptrs_per_blk * 2);
388 offset[n++] = block / indirect_blks;
389 noffset[n] = 6 + (dptrs_per_blk * 2) +
390 offset[n - 1] * (dptrs_per_blk + 1);
391 offset[n++] = (block / direct_blks) % dptrs_per_blk;
392 noffset[n] = 7 + (dptrs_per_blk * 2) +
393 offset[n - 2] * (dptrs_per_blk + 1) +
394 offset[n - 1];
395 offset[n] = block % direct_blks;
396 level = 3;
397 goto got;
398 } else {
399 BUG();
400 }
401 got:
402 return level;
403 }
404
405 /*
406 * Caller should call f2fs_put_dnode(dn).
407 * Also, it should grab and release a rwsem by calling f2fs_lock_op() and
408 * f2fs_unlock_op() only if ro is not set RDONLY_NODE.
409 * In the case of RDONLY_NODE, we don't need to care about mutex.
410 */
411 int get_dnode_of_data(struct dnode_of_data *dn, pgoff_t index, int mode)
412 {
413 struct f2fs_sb_info *sbi = F2FS_I_SB(dn->inode);
414 struct page *npage[4];
415 struct page *parent;
416 int offset[4];
417 unsigned int noffset[4];
418 nid_t nids[4];
419 int level, i;
420 int err = 0;
421
422 level = get_node_path(F2FS_I(dn->inode), index, offset, noffset);
423
424 nids[0] = dn->inode->i_ino;
425 npage[0] = dn->inode_page;
426
427 if (!npage[0]) {
428 npage[0] = get_node_page(sbi, nids[0]);
429 if (IS_ERR(npage[0]))
430 return PTR_ERR(npage[0]);
431 }
432 parent = npage[0];
433 if (level != 0)
434 nids[1] = get_nid(parent, offset[0], true);
435 dn->inode_page = npage[0];
436 dn->inode_page_locked = true;
437
438 /* get indirect or direct nodes */
439 for (i = 1; i <= level; i++) {
440 bool done = false;
441
442 if (!nids[i] && mode == ALLOC_NODE) {
443 /* alloc new node */
444 if (!alloc_nid(sbi, &(nids[i]))) {
445 err = -ENOSPC;
446 goto release_pages;
447 }
448
449 dn->nid = nids[i];
450 npage[i] = new_node_page(dn, noffset[i], NULL);
451 if (IS_ERR(npage[i])) {
452 alloc_nid_failed(sbi, nids[i]);
453 err = PTR_ERR(npage[i]);
454 goto release_pages;
455 }
456
457 set_nid(parent, offset[i - 1], nids[i], i == 1);
458 alloc_nid_done(sbi, nids[i]);
459 done = true;
460 } else if (mode == LOOKUP_NODE_RA && i == level && level > 1) {
461 npage[i] = get_node_page_ra(parent, offset[i - 1]);
462 if (IS_ERR(npage[i])) {
463 err = PTR_ERR(npage[i]);
464 goto release_pages;
465 }
466 done = true;
467 }
468 if (i == 1) {
469 dn->inode_page_locked = false;
470 unlock_page(parent);
471 } else {
472 f2fs_put_page(parent, 1);
473 }
474
475 if (!done) {
476 npage[i] = get_node_page(sbi, nids[i]);
477 if (IS_ERR(npage[i])) {
478 err = PTR_ERR(npage[i]);
479 f2fs_put_page(npage[0], 0);
480 goto release_out;
481 }
482 }
483 if (i < level) {
484 parent = npage[i];
485 nids[i + 1] = get_nid(parent, offset[i], false);
486 }
487 }
488 dn->nid = nids[level];
489 dn->ofs_in_node = offset[level];
490 dn->node_page = npage[level];
491 dn->data_blkaddr = datablock_addr(dn->node_page, dn->ofs_in_node);
492 return 0;
493
494 release_pages:
495 f2fs_put_page(parent, 1);
496 if (i > 1)
497 f2fs_put_page(npage[0], 0);
498 release_out:
499 dn->inode_page = NULL;
500 dn->node_page = NULL;
501 return err;
502 }
503
504 static void truncate_node(struct dnode_of_data *dn)
505 {
506 struct f2fs_sb_info *sbi = F2FS_I_SB(dn->inode);
507 struct node_info ni;
508
509 get_node_info(sbi, dn->nid, &ni);
510 if (dn->inode->i_blocks == 0) {
511 f2fs_bug_on(sbi, ni.blk_addr != NULL_ADDR);
512 goto invalidate;
513 }
514 f2fs_bug_on(sbi, ni.blk_addr == NULL_ADDR);
515
516 /* Deallocate node address */
517 invalidate_blocks(sbi, ni.blk_addr);
518 dec_valid_node_count(sbi, dn->inode);
519 set_node_addr(sbi, &ni, NULL_ADDR, false);
520
521 if (dn->nid == dn->inode->i_ino) {
522 remove_orphan_inode(sbi, dn->nid);
523 dec_valid_inode_count(sbi);
524 } else {
525 sync_inode_page(dn);
526 }
527 invalidate:
528 clear_node_page_dirty(dn->node_page);
529 F2FS_SET_SB_DIRT(sbi);
530
531 f2fs_put_page(dn->node_page, 1);
532
533 invalidate_mapping_pages(NODE_MAPPING(sbi),
534 dn->node_page->index, dn->node_page->index);
535
536 dn->node_page = NULL;
537 trace_f2fs_truncate_node(dn->inode, dn->nid, ni.blk_addr);
538 }
539
540 static int truncate_dnode(struct dnode_of_data *dn)
541 {
542 struct page *page;
543
544 if (dn->nid == 0)
545 return 1;
546
547 /* get direct node */
548 page = get_node_page(F2FS_I_SB(dn->inode), dn->nid);
549 if (IS_ERR(page) && PTR_ERR(page) == -ENOENT)
550 return 1;
551 else if (IS_ERR(page))
552 return PTR_ERR(page);
553
554 /* Make dnode_of_data for parameter */
555 dn->node_page = page;
556 dn->ofs_in_node = 0;
557 truncate_data_blocks(dn);
558 truncate_node(dn);
559 return 1;
560 }
561
562 static int truncate_nodes(struct dnode_of_data *dn, unsigned int nofs,
563 int ofs, int depth)
564 {
565 struct dnode_of_data rdn = *dn;
566 struct page *page;
567 struct f2fs_node *rn;
568 nid_t child_nid;
569 unsigned int child_nofs;
570 int freed = 0;
571 int i, ret;
572
573 if (dn->nid == 0)
574 return NIDS_PER_BLOCK + 1;
575
576 trace_f2fs_truncate_nodes_enter(dn->inode, dn->nid, dn->data_blkaddr);
577
578 page = get_node_page(F2FS_I_SB(dn->inode), dn->nid);
579 if (IS_ERR(page)) {
580 trace_f2fs_truncate_nodes_exit(dn->inode, PTR_ERR(page));
581 return PTR_ERR(page);
582 }
583
584 rn = F2FS_NODE(page);
585 if (depth < 3) {
586 for (i = ofs; i < NIDS_PER_BLOCK; i++, freed++) {
587 child_nid = le32_to_cpu(rn->in.nid[i]);
588 if (child_nid == 0)
589 continue;
590 rdn.nid = child_nid;
591 ret = truncate_dnode(&rdn);
592 if (ret < 0)
593 goto out_err;
594 set_nid(page, i, 0, false);
595 }
596 } else {
597 child_nofs = nofs + ofs * (NIDS_PER_BLOCK + 1) + 1;
598 for (i = ofs; i < NIDS_PER_BLOCK; i++) {
599 child_nid = le32_to_cpu(rn->in.nid[i]);
600 if (child_nid == 0) {
601 child_nofs += NIDS_PER_BLOCK + 1;
602 continue;
603 }
604 rdn.nid = child_nid;
605 ret = truncate_nodes(&rdn, child_nofs, 0, depth - 1);
606 if (ret == (NIDS_PER_BLOCK + 1)) {
607 set_nid(page, i, 0, false);
608 child_nofs += ret;
609 } else if (ret < 0 && ret != -ENOENT) {
610 goto out_err;
611 }
612 }
613 freed = child_nofs;
614 }
615
616 if (!ofs) {
617 /* remove current indirect node */
618 dn->node_page = page;
619 truncate_node(dn);
620 freed++;
621 } else {
622 f2fs_put_page(page, 1);
623 }
624 trace_f2fs_truncate_nodes_exit(dn->inode, freed);
625 return freed;
626
627 out_err:
628 f2fs_put_page(page, 1);
629 trace_f2fs_truncate_nodes_exit(dn->inode, ret);
630 return ret;
631 }
632
633 static int truncate_partial_nodes(struct dnode_of_data *dn,
634 struct f2fs_inode *ri, int *offset, int depth)
635 {
636 struct page *pages[2];
637 nid_t nid[3];
638 nid_t child_nid;
639 int err = 0;
640 int i;
641 int idx = depth - 2;
642
643 nid[0] = le32_to_cpu(ri->i_nid[offset[0] - NODE_DIR1_BLOCK]);
644 if (!nid[0])
645 return 0;
646
647 /* get indirect nodes in the path */
648 for (i = 0; i < idx + 1; i++) {
649 /* reference count'll be increased */
650 pages[i] = get_node_page(F2FS_I_SB(dn->inode), nid[i]);
651 if (IS_ERR(pages[i])) {
652 err = PTR_ERR(pages[i]);
653 idx = i - 1;
654 goto fail;
655 }
656 nid[i + 1] = get_nid(pages[i], offset[i + 1], false);
657 }
658
659 /* free direct nodes linked to a partial indirect node */
660 for (i = offset[idx + 1]; i < NIDS_PER_BLOCK; i++) {
661 child_nid = get_nid(pages[idx], i, false);
662 if (!child_nid)
663 continue;
664 dn->nid = child_nid;
665 err = truncate_dnode(dn);
666 if (err < 0)
667 goto fail;
668 set_nid(pages[idx], i, 0, false);
669 }
670
671 if (offset[idx + 1] == 0) {
672 dn->node_page = pages[idx];
673 dn->nid = nid[idx];
674 truncate_node(dn);
675 } else {
676 f2fs_put_page(pages[idx], 1);
677 }
678 offset[idx]++;
679 offset[idx + 1] = 0;
680 idx--;
681 fail:
682 for (i = idx; i >= 0; i--)
683 f2fs_put_page(pages[i], 1);
684
685 trace_f2fs_truncate_partial_nodes(dn->inode, nid, depth, err);
686
687 return err;
688 }
689
690 /*
691 * All the block addresses of data and nodes should be nullified.
692 */
693 int truncate_inode_blocks(struct inode *inode, pgoff_t from)
694 {
695 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
696 int err = 0, cont = 1;
697 int level, offset[4], noffset[4];
698 unsigned int nofs = 0;
699 struct f2fs_inode *ri;
700 struct dnode_of_data dn;
701 struct page *page;
702
703 trace_f2fs_truncate_inode_blocks_enter(inode, from);
704
705 level = get_node_path(F2FS_I(inode), from, offset, noffset);
706 restart:
707 page = get_node_page(sbi, inode->i_ino);
708 if (IS_ERR(page)) {
709 trace_f2fs_truncate_inode_blocks_exit(inode, PTR_ERR(page));
710 return PTR_ERR(page);
711 }
712
713 set_new_dnode(&dn, inode, page, NULL, 0);
714 unlock_page(page);
715
716 ri = F2FS_INODE(page);
717 switch (level) {
718 case 0:
719 case 1:
720 nofs = noffset[1];
721 break;
722 case 2:
723 nofs = noffset[1];
724 if (!offset[level - 1])
725 goto skip_partial;
726 err = truncate_partial_nodes(&dn, ri, offset, level);
727 if (err < 0 && err != -ENOENT)
728 goto fail;
729 nofs += 1 + NIDS_PER_BLOCK;
730 break;
731 case 3:
732 nofs = 5 + 2 * NIDS_PER_BLOCK;
733 if (!offset[level - 1])
734 goto skip_partial;
735 err = truncate_partial_nodes(&dn, ri, offset, level);
736 if (err < 0 && err != -ENOENT)
737 goto fail;
738 break;
739 default:
740 BUG();
741 }
742
743 skip_partial:
744 while (cont) {
745 dn.nid = le32_to_cpu(ri->i_nid[offset[0] - NODE_DIR1_BLOCK]);
746 switch (offset[0]) {
747 case NODE_DIR1_BLOCK:
748 case NODE_DIR2_BLOCK:
749 err = truncate_dnode(&dn);
750 break;
751
752 case NODE_IND1_BLOCK:
753 case NODE_IND2_BLOCK:
754 err = truncate_nodes(&dn, nofs, offset[1], 2);
755 break;
756
757 case NODE_DIND_BLOCK:
758 err = truncate_nodes(&dn, nofs, offset[1], 3);
759 cont = 0;
760 break;
761
762 default:
763 BUG();
764 }
765 if (err < 0 && err != -ENOENT)
766 goto fail;
767 if (offset[1] == 0 &&
768 ri->i_nid[offset[0] - NODE_DIR1_BLOCK]) {
769 lock_page(page);
770 if (unlikely(page->mapping != NODE_MAPPING(sbi))) {
771 f2fs_put_page(page, 1);
772 goto restart;
773 }
774 f2fs_wait_on_page_writeback(page, NODE);
775 ri->i_nid[offset[0] - NODE_DIR1_BLOCK] = 0;
776 set_page_dirty(page);
777 unlock_page(page);
778 }
779 offset[1] = 0;
780 offset[0]++;
781 nofs += err;
782 }
783 fail:
784 f2fs_put_page(page, 0);
785 trace_f2fs_truncate_inode_blocks_exit(inode, err);
786 return err > 0 ? 0 : err;
787 }
788
789 int truncate_xattr_node(struct inode *inode, struct page *page)
790 {
791 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
792 nid_t nid = F2FS_I(inode)->i_xattr_nid;
793 struct dnode_of_data dn;
794 struct page *npage;
795
796 if (!nid)
797 return 0;
798
799 npage = get_node_page(sbi, nid);
800 if (IS_ERR(npage))
801 return PTR_ERR(npage);
802
803 F2FS_I(inode)->i_xattr_nid = 0;
804
805 /* need to do checkpoint during fsync */
806 F2FS_I(inode)->xattr_ver = cur_cp_version(F2FS_CKPT(sbi));
807
808 set_new_dnode(&dn, inode, page, npage, nid);
809
810 if (page)
811 dn.inode_page_locked = true;
812 truncate_node(&dn);
813 return 0;
814 }
815
816 /*
817 * Caller should grab and release a rwsem by calling f2fs_lock_op() and
818 * f2fs_unlock_op().
819 */
820 void remove_inode_page(struct inode *inode)
821 {
822 struct dnode_of_data dn;
823
824 set_new_dnode(&dn, inode, NULL, NULL, inode->i_ino);
825 if (get_dnode_of_data(&dn, 0, LOOKUP_NODE))
826 return;
827
828 if (truncate_xattr_node(inode, dn.inode_page)) {
829 f2fs_put_dnode(&dn);
830 return;
831 }
832
833 /* remove potential inline_data blocks */
834 if (S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
835 S_ISLNK(inode->i_mode))
836 truncate_data_blocks_range(&dn, 1);
837
838 /* 0 is possible, after f2fs_new_inode() has failed */
839 f2fs_bug_on(F2FS_I_SB(inode),
840 inode->i_blocks != 0 && inode->i_blocks != 1);
841
842 /* will put inode & node pages */
843 truncate_node(&dn);
844 }
845
846 struct page *new_inode_page(struct inode *inode)
847 {
848 struct dnode_of_data dn;
849
850 /* allocate inode page for new inode */
851 set_new_dnode(&dn, inode, NULL, NULL, inode->i_ino);
852
853 /* caller should f2fs_put_page(page, 1); */
854 return new_node_page(&dn, 0, NULL);
855 }
856
857 struct page *new_node_page(struct dnode_of_data *dn,
858 unsigned int ofs, struct page *ipage)
859 {
860 struct f2fs_sb_info *sbi = F2FS_I_SB(dn->inode);
861 struct node_info old_ni, new_ni;
862 struct page *page;
863 int err;
864
865 if (unlikely(is_inode_flag_set(F2FS_I(dn->inode), FI_NO_ALLOC)))
866 return ERR_PTR(-EPERM);
867
868 page = grab_cache_page(NODE_MAPPING(sbi), dn->nid);
869 if (!page)
870 return ERR_PTR(-ENOMEM);
871
872 if (unlikely(!inc_valid_node_count(sbi, dn->inode))) {
873 err = -ENOSPC;
874 goto fail;
875 }
876
877 get_node_info(sbi, dn->nid, &old_ni);
878
879 /* Reinitialize old_ni with new node page */
880 f2fs_bug_on(sbi, old_ni.blk_addr != NULL_ADDR);
881 new_ni = old_ni;
882 new_ni.ino = dn->inode->i_ino;
883 set_node_addr(sbi, &new_ni, NEW_ADDR, false);
884
885 f2fs_wait_on_page_writeback(page, NODE);
886 fill_node_footer(page, dn->nid, dn->inode->i_ino, ofs, true);
887 set_cold_node(dn->inode, page);
888 SetPageUptodate(page);
889 set_page_dirty(page);
890
891 if (f2fs_has_xattr_block(ofs))
892 F2FS_I(dn->inode)->i_xattr_nid = dn->nid;
893
894 dn->node_page = page;
895 if (ipage)
896 update_inode(dn->inode, ipage);
897 else
898 sync_inode_page(dn);
899 if (ofs == 0)
900 inc_valid_inode_count(sbi);
901
902 return page;
903
904 fail:
905 clear_node_page_dirty(page);
906 f2fs_put_page(page, 1);
907 return ERR_PTR(err);
908 }
909
910 /*
911 * Caller should do after getting the following values.
912 * 0: f2fs_put_page(page, 0)
913 * LOCKED_PAGE: f2fs_put_page(page, 1)
914 * error: nothing
915 */
916 static int read_node_page(struct page *page, int rw)
917 {
918 struct f2fs_sb_info *sbi = F2FS_P_SB(page);
919 struct node_info ni;
920
921 get_node_info(sbi, page->index, &ni);
922
923 if (unlikely(ni.blk_addr == NULL_ADDR)) {
924 f2fs_put_page(page, 1);
925 return -ENOENT;
926 }
927
928 if (PageUptodate(page))
929 return LOCKED_PAGE;
930
931 return f2fs_submit_page_bio(sbi, page, ni.blk_addr, rw);
932 }
933
934 /*
935 * Readahead a node page
936 */
937 void ra_node_page(struct f2fs_sb_info *sbi, nid_t nid)
938 {
939 struct page *apage;
940 int err;
941
942 apage = find_get_page(NODE_MAPPING(sbi), nid);
943 if (apage && PageUptodate(apage)) {
944 f2fs_put_page(apage, 0);
945 return;
946 }
947 f2fs_put_page(apage, 0);
948
949 apage = grab_cache_page(NODE_MAPPING(sbi), nid);
950 if (!apage)
951 return;
952
953 err = read_node_page(apage, READA);
954 if (err == 0)
955 f2fs_put_page(apage, 0);
956 else if (err == LOCKED_PAGE)
957 f2fs_put_page(apage, 1);
958 }
959
960 struct page *get_node_page(struct f2fs_sb_info *sbi, pgoff_t nid)
961 {
962 struct page *page;
963 int err;
964 repeat:
965 page = grab_cache_page(NODE_MAPPING(sbi), nid);
966 if (!page)
967 return ERR_PTR(-ENOMEM);
968
969 err = read_node_page(page, READ_SYNC);
970 if (err < 0)
971 return ERR_PTR(err);
972 else if (err == LOCKED_PAGE)
973 goto got_it;
974
975 lock_page(page);
976 if (unlikely(!PageUptodate(page) || nid != nid_of_node(page))) {
977 f2fs_put_page(page, 1);
978 return ERR_PTR(-EIO);
979 }
980 if (unlikely(page->mapping != NODE_MAPPING(sbi))) {
981 f2fs_put_page(page, 1);
982 goto repeat;
983 }
984 got_it:
985 return page;
986 }
987
988 /*
989 * Return a locked page for the desired node page.
990 * And, readahead MAX_RA_NODE number of node pages.
991 */
992 struct page *get_node_page_ra(struct page *parent, int start)
993 {
994 struct f2fs_sb_info *sbi = F2FS_P_SB(parent);
995 struct blk_plug plug;
996 struct page *page;
997 int err, i, end;
998 nid_t nid;
999
1000 /* First, try getting the desired direct node. */
1001 nid = get_nid(parent, start, false);
1002 if (!nid)
1003 return ERR_PTR(-ENOENT);
1004 repeat:
1005 page = grab_cache_page(NODE_MAPPING(sbi), nid);
1006 if (!page)
1007 return ERR_PTR(-ENOMEM);
1008
1009 err = read_node_page(page, READ_SYNC);
1010 if (err < 0)
1011 return ERR_PTR(err);
1012 else if (err == LOCKED_PAGE)
1013 goto page_hit;
1014
1015 blk_start_plug(&plug);
1016
1017 /* Then, try readahead for siblings of the desired node */
1018 end = start + MAX_RA_NODE;
1019 end = min(end, NIDS_PER_BLOCK);
1020 for (i = start + 1; i < end; i++) {
1021 nid = get_nid(parent, i, false);
1022 if (!nid)
1023 continue;
1024 ra_node_page(sbi, nid);
1025 }
1026
1027 blk_finish_plug(&plug);
1028
1029 lock_page(page);
1030 if (unlikely(page->mapping != NODE_MAPPING(sbi))) {
1031 f2fs_put_page(page, 1);
1032 goto repeat;
1033 }
1034 page_hit:
1035 if (unlikely(!PageUptodate(page))) {
1036 f2fs_put_page(page, 1);
1037 return ERR_PTR(-EIO);
1038 }
1039 return page;
1040 }
1041
1042 void sync_inode_page(struct dnode_of_data *dn)
1043 {
1044 if (IS_INODE(dn->node_page) || dn->inode_page == dn->node_page) {
1045 update_inode(dn->inode, dn->node_page);
1046 } else if (dn->inode_page) {
1047 if (!dn->inode_page_locked)
1048 lock_page(dn->inode_page);
1049 update_inode(dn->inode, dn->inode_page);
1050 if (!dn->inode_page_locked)
1051 unlock_page(dn->inode_page);
1052 } else {
1053 update_inode_page(dn->inode);
1054 }
1055 }
1056
1057 int sync_node_pages(struct f2fs_sb_info *sbi, nid_t ino,
1058 struct writeback_control *wbc)
1059 {
1060 pgoff_t index, end;
1061 struct pagevec pvec;
1062 int step = ino ? 2 : 0;
1063 int nwritten = 0, wrote = 0;
1064
1065 pagevec_init(&pvec, 0);
1066
1067 next_step:
1068 index = 0;
1069 end = LONG_MAX;
1070
1071 while (index <= end) {
1072 int i, nr_pages;
1073 nr_pages = pagevec_lookup_tag(&pvec, NODE_MAPPING(sbi), &index,
1074 PAGECACHE_TAG_DIRTY,
1075 min(end - index, (pgoff_t)PAGEVEC_SIZE-1) + 1);
1076 if (nr_pages == 0)
1077 break;
1078
1079 for (i = 0; i < nr_pages; i++) {
1080 struct page *page = pvec.pages[i];
1081
1082 /*
1083 * flushing sequence with step:
1084 * 0. indirect nodes
1085 * 1. dentry dnodes
1086 * 2. file dnodes
1087 */
1088 if (step == 0 && IS_DNODE(page))
1089 continue;
1090 if (step == 1 && (!IS_DNODE(page) ||
1091 is_cold_node(page)))
1092 continue;
1093 if (step == 2 && (!IS_DNODE(page) ||
1094 !is_cold_node(page)))
1095 continue;
1096
1097 /*
1098 * If an fsync mode,
1099 * we should not skip writing node pages.
1100 */
1101 if (ino && ino_of_node(page) == ino)
1102 lock_page(page);
1103 else if (!trylock_page(page))
1104 continue;
1105
1106 if (unlikely(page->mapping != NODE_MAPPING(sbi))) {
1107 continue_unlock:
1108 unlock_page(page);
1109 continue;
1110 }
1111 if (ino && ino_of_node(page) != ino)
1112 goto continue_unlock;
1113
1114 if (!PageDirty(page)) {
1115 /* someone wrote it for us */
1116 goto continue_unlock;
1117 }
1118
1119 if (!clear_page_dirty_for_io(page))
1120 goto continue_unlock;
1121
1122 /* called by fsync() */
1123 if (ino && IS_DNODE(page)) {
1124 int mark = !is_checkpointed_node(sbi, ino);
1125 set_fsync_mark(page, 1);
1126 if (IS_INODE(page))
1127 set_dentry_mark(page, mark);
1128 nwritten++;
1129 } else {
1130 set_fsync_mark(page, 0);
1131 set_dentry_mark(page, 0);
1132 }
1133
1134 if (NODE_MAPPING(sbi)->a_ops->writepage(page, wbc))
1135 unlock_page(page);
1136 else
1137 wrote++;
1138
1139 if (--wbc->nr_to_write == 0)
1140 break;
1141 }
1142 pagevec_release(&pvec);
1143 cond_resched();
1144
1145 if (wbc->nr_to_write == 0) {
1146 step = 2;
1147 break;
1148 }
1149 }
1150
1151 if (step < 2) {
1152 step++;
1153 goto next_step;
1154 }
1155
1156 if (wrote)
1157 f2fs_submit_merged_bio(sbi, NODE, WRITE);
1158 return nwritten;
1159 }
1160
1161 int wait_on_node_pages_writeback(struct f2fs_sb_info *sbi, nid_t ino)
1162 {
1163 pgoff_t index = 0, end = LONG_MAX;
1164 struct pagevec pvec;
1165 int ret2 = 0, ret = 0;
1166
1167 pagevec_init(&pvec, 0);
1168
1169 while (index <= end) {
1170 int i, nr_pages;
1171 nr_pages = pagevec_lookup_tag(&pvec, NODE_MAPPING(sbi), &index,
1172 PAGECACHE_TAG_WRITEBACK,
1173 min(end - index, (pgoff_t)PAGEVEC_SIZE-1) + 1);
1174 if (nr_pages == 0)
1175 break;
1176
1177 for (i = 0; i < nr_pages; i++) {
1178 struct page *page = pvec.pages[i];
1179
1180 /* until radix tree lookup accepts end_index */
1181 if (unlikely(page->index > end))
1182 continue;
1183
1184 if (ino && ino_of_node(page) == ino) {
1185 f2fs_wait_on_page_writeback(page, NODE);
1186 if (TestClearPageError(page))
1187 ret = -EIO;
1188 }
1189 }
1190 pagevec_release(&pvec);
1191 cond_resched();
1192 }
1193
1194 if (unlikely(test_and_clear_bit(AS_ENOSPC, &NODE_MAPPING(sbi)->flags)))
1195 ret2 = -ENOSPC;
1196 if (unlikely(test_and_clear_bit(AS_EIO, &NODE_MAPPING(sbi)->flags)))
1197 ret2 = -EIO;
1198 if (!ret)
1199 ret = ret2;
1200 return ret;
1201 }
1202
1203 static int f2fs_write_node_page(struct page *page,
1204 struct writeback_control *wbc)
1205 {
1206 struct f2fs_sb_info *sbi = F2FS_P_SB(page);
1207 nid_t nid;
1208 block_t new_addr;
1209 struct node_info ni;
1210 struct f2fs_io_info fio = {
1211 .type = NODE,
1212 .rw = (wbc->sync_mode == WB_SYNC_ALL) ? WRITE_SYNC : WRITE,
1213 };
1214
1215 trace_f2fs_writepage(page, NODE);
1216
1217 if (unlikely(sbi->por_doing))
1218 goto redirty_out;
1219 if (unlikely(f2fs_cp_error(sbi)))
1220 goto redirty_out;
1221
1222 f2fs_wait_on_page_writeback(page, NODE);
1223
1224 /* get old block addr of this node page */
1225 nid = nid_of_node(page);
1226 f2fs_bug_on(sbi, page->index != nid);
1227
1228 get_node_info(sbi, nid, &ni);
1229
1230 /* This page is already truncated */
1231 if (unlikely(ni.blk_addr == NULL_ADDR)) {
1232 dec_page_count(sbi, F2FS_DIRTY_NODES);
1233 unlock_page(page);
1234 return 0;
1235 }
1236
1237 if (wbc->for_reclaim)
1238 goto redirty_out;
1239
1240 down_read(&sbi->node_write);
1241 set_page_writeback(page);
1242 write_node_page(sbi, page, &fio, nid, ni.blk_addr, &new_addr);
1243 set_node_addr(sbi, &ni, new_addr, is_fsync_dnode(page));
1244 dec_page_count(sbi, F2FS_DIRTY_NODES);
1245 up_read(&sbi->node_write);
1246 unlock_page(page);
1247 return 0;
1248
1249 redirty_out:
1250 redirty_page_for_writepage(wbc, page);
1251 return AOP_WRITEPAGE_ACTIVATE;
1252 }
1253
1254 static int f2fs_write_node_pages(struct address_space *mapping,
1255 struct writeback_control *wbc)
1256 {
1257 struct f2fs_sb_info *sbi = F2FS_M_SB(mapping);
1258 long diff;
1259
1260 trace_f2fs_writepages(mapping->host, wbc, NODE);
1261
1262 /* balancing f2fs's metadata in background */
1263 f2fs_balance_fs_bg(sbi);
1264
1265 /* collect a number of dirty node pages and write together */
1266 if (get_pages(sbi, F2FS_DIRTY_NODES) < nr_pages_to_skip(sbi, NODE))
1267 goto skip_write;
1268
1269 diff = nr_pages_to_write(sbi, NODE, wbc);
1270 wbc->sync_mode = WB_SYNC_NONE;
1271 sync_node_pages(sbi, 0, wbc);
1272 wbc->nr_to_write = max((long)0, wbc->nr_to_write - diff);
1273 return 0;
1274
1275 skip_write:
1276 wbc->pages_skipped += get_pages(sbi, F2FS_DIRTY_NODES);
1277 return 0;
1278 }
1279
1280 static int f2fs_set_node_page_dirty(struct page *page)
1281 {
1282 trace_f2fs_set_page_dirty(page, NODE);
1283
1284 SetPageUptodate(page);
1285 if (!PageDirty(page)) {
1286 __set_page_dirty_nobuffers(page);
1287 inc_page_count(F2FS_P_SB(page), F2FS_DIRTY_NODES);
1288 SetPagePrivate(page);
1289 return 1;
1290 }
1291 return 0;
1292 }
1293
1294 static void f2fs_invalidate_node_page(struct page *page, unsigned int offset,
1295 unsigned int length)
1296 {
1297 struct inode *inode = page->mapping->host;
1298 if (PageDirty(page))
1299 dec_page_count(F2FS_I_SB(inode), F2FS_DIRTY_NODES);
1300 ClearPagePrivate(page);
1301 }
1302
1303 static int f2fs_release_node_page(struct page *page, gfp_t wait)
1304 {
1305 ClearPagePrivate(page);
1306 return 1;
1307 }
1308
1309 /*
1310 * Structure of the f2fs node operations
1311 */
1312 const struct address_space_operations f2fs_node_aops = {
1313 .writepage = f2fs_write_node_page,
1314 .writepages = f2fs_write_node_pages,
1315 .set_page_dirty = f2fs_set_node_page_dirty,
1316 .invalidatepage = f2fs_invalidate_node_page,
1317 .releasepage = f2fs_release_node_page,
1318 };
1319
1320 static struct free_nid *__lookup_free_nid_list(struct f2fs_nm_info *nm_i,
1321 nid_t n)
1322 {
1323 return radix_tree_lookup(&nm_i->free_nid_root, n);
1324 }
1325
1326 static void __del_from_free_nid_list(struct f2fs_nm_info *nm_i,
1327 struct free_nid *i)
1328 {
1329 list_del(&i->list);
1330 radix_tree_delete(&nm_i->free_nid_root, i->nid);
1331 }
1332
1333 static int add_free_nid(struct f2fs_sb_info *sbi, nid_t nid, bool build)
1334 {
1335 struct f2fs_nm_info *nm_i = NM_I(sbi);
1336 struct free_nid *i;
1337 struct nat_entry *ne;
1338 bool allocated = false;
1339
1340 if (!available_free_memory(sbi, FREE_NIDS))
1341 return -1;
1342
1343 /* 0 nid should not be used */
1344 if (unlikely(nid == 0))
1345 return 0;
1346
1347 if (build) {
1348 /* do not add allocated nids */
1349 read_lock(&nm_i->nat_tree_lock);
1350 ne = __lookup_nat_cache(nm_i, nid);
1351 if (ne &&
1352 (!ne->checkpointed || nat_get_blkaddr(ne) != NULL_ADDR))
1353 allocated = true;
1354 read_unlock(&nm_i->nat_tree_lock);
1355 if (allocated)
1356 return 0;
1357 }
1358
1359 i = f2fs_kmem_cache_alloc(free_nid_slab, GFP_NOFS);
1360 i->nid = nid;
1361 i->state = NID_NEW;
1362
1363 spin_lock(&nm_i->free_nid_list_lock);
1364 if (radix_tree_insert(&nm_i->free_nid_root, i->nid, i)) {
1365 spin_unlock(&nm_i->free_nid_list_lock);
1366 kmem_cache_free(free_nid_slab, i);
1367 return 0;
1368 }
1369 list_add_tail(&i->list, &nm_i->free_nid_list);
1370 nm_i->fcnt++;
1371 spin_unlock(&nm_i->free_nid_list_lock);
1372 return 1;
1373 }
1374
1375 static void remove_free_nid(struct f2fs_nm_info *nm_i, nid_t nid)
1376 {
1377 struct free_nid *i;
1378 bool need_free = false;
1379
1380 spin_lock(&nm_i->free_nid_list_lock);
1381 i = __lookup_free_nid_list(nm_i, nid);
1382 if (i && i->state == NID_NEW) {
1383 __del_from_free_nid_list(nm_i, i);
1384 nm_i->fcnt--;
1385 need_free = true;
1386 }
1387 spin_unlock(&nm_i->free_nid_list_lock);
1388
1389 if (need_free)
1390 kmem_cache_free(free_nid_slab, i);
1391 }
1392
1393 static void scan_nat_page(struct f2fs_sb_info *sbi,
1394 struct page *nat_page, nid_t start_nid)
1395 {
1396 struct f2fs_nm_info *nm_i = NM_I(sbi);
1397 struct f2fs_nat_block *nat_blk = page_address(nat_page);
1398 block_t blk_addr;
1399 int i;
1400
1401 i = start_nid % NAT_ENTRY_PER_BLOCK;
1402
1403 for (; i < NAT_ENTRY_PER_BLOCK; i++, start_nid++) {
1404
1405 if (unlikely(start_nid >= nm_i->max_nid))
1406 break;
1407
1408 blk_addr = le32_to_cpu(nat_blk->entries[i].block_addr);
1409 f2fs_bug_on(sbi, blk_addr == NEW_ADDR);
1410 if (blk_addr == NULL_ADDR) {
1411 if (add_free_nid(sbi, start_nid, true) < 0)
1412 break;
1413 }
1414 }
1415 }
1416
1417 static void build_free_nids(struct f2fs_sb_info *sbi)
1418 {
1419 struct f2fs_nm_info *nm_i = NM_I(sbi);
1420 struct curseg_info *curseg = CURSEG_I(sbi, CURSEG_HOT_DATA);
1421 struct f2fs_summary_block *sum = curseg->sum_blk;
1422 int i = 0;
1423 nid_t nid = nm_i->next_scan_nid;
1424
1425 /* Enough entries */
1426 if (nm_i->fcnt > NAT_ENTRY_PER_BLOCK)
1427 return;
1428
1429 /* readahead nat pages to be scanned */
1430 ra_meta_pages(sbi, NAT_BLOCK_OFFSET(nid), FREE_NID_PAGES, META_NAT);
1431
1432 while (1) {
1433 struct page *page = get_current_nat_page(sbi, nid);
1434
1435 scan_nat_page(sbi, page, nid);
1436 f2fs_put_page(page, 1);
1437
1438 nid += (NAT_ENTRY_PER_BLOCK - (nid % NAT_ENTRY_PER_BLOCK));
1439 if (unlikely(nid >= nm_i->max_nid))
1440 nid = 0;
1441
1442 if (i++ == FREE_NID_PAGES)
1443 break;
1444 }
1445
1446 /* go to the next free nat pages to find free nids abundantly */
1447 nm_i->next_scan_nid = nid;
1448
1449 /* find free nids from current sum_pages */
1450 mutex_lock(&curseg->curseg_mutex);
1451 for (i = 0; i < nats_in_cursum(sum); i++) {
1452 block_t addr = le32_to_cpu(nat_in_journal(sum, i).block_addr);
1453 nid = le32_to_cpu(nid_in_journal(sum, i));
1454 if (addr == NULL_ADDR)
1455 add_free_nid(sbi, nid, true);
1456 else
1457 remove_free_nid(nm_i, nid);
1458 }
1459 mutex_unlock(&curseg->curseg_mutex);
1460 }
1461
1462 /*
1463 * If this function returns success, caller can obtain a new nid
1464 * from second parameter of this function.
1465 * The returned nid could be used ino as well as nid when inode is created.
1466 */
1467 bool alloc_nid(struct f2fs_sb_info *sbi, nid_t *nid)
1468 {
1469 struct f2fs_nm_info *nm_i = NM_I(sbi);
1470 struct free_nid *i = NULL;
1471 retry:
1472 if (unlikely(sbi->total_valid_node_count + 1 > nm_i->available_nids))
1473 return false;
1474
1475 spin_lock(&nm_i->free_nid_list_lock);
1476
1477 /* We should not use stale free nids created by build_free_nids */
1478 if (nm_i->fcnt && !on_build_free_nids(nm_i)) {
1479 f2fs_bug_on(sbi, list_empty(&nm_i->free_nid_list));
1480 list_for_each_entry(i, &nm_i->free_nid_list, list)
1481 if (i->state == NID_NEW)
1482 break;
1483
1484 f2fs_bug_on(sbi, i->state != NID_NEW);
1485 *nid = i->nid;
1486 i->state = NID_ALLOC;
1487 nm_i->fcnt--;
1488 spin_unlock(&nm_i->free_nid_list_lock);
1489 return true;
1490 }
1491 spin_unlock(&nm_i->free_nid_list_lock);
1492
1493 /* Let's scan nat pages and its caches to get free nids */
1494 mutex_lock(&nm_i->build_lock);
1495 build_free_nids(sbi);
1496 mutex_unlock(&nm_i->build_lock);
1497 goto retry;
1498 }
1499
1500 /*
1501 * alloc_nid() should be called prior to this function.
1502 */
1503 void alloc_nid_done(struct f2fs_sb_info *sbi, nid_t nid)
1504 {
1505 struct f2fs_nm_info *nm_i = NM_I(sbi);
1506 struct free_nid *i;
1507
1508 spin_lock(&nm_i->free_nid_list_lock);
1509 i = __lookup_free_nid_list(nm_i, nid);
1510 f2fs_bug_on(sbi, !i || i->state != NID_ALLOC);
1511 __del_from_free_nid_list(nm_i, i);
1512 spin_unlock(&nm_i->free_nid_list_lock);
1513
1514 kmem_cache_free(free_nid_slab, i);
1515 }
1516
1517 /*
1518 * alloc_nid() should be called prior to this function.
1519 */
1520 void alloc_nid_failed(struct f2fs_sb_info *sbi, nid_t nid)
1521 {
1522 struct f2fs_nm_info *nm_i = NM_I(sbi);
1523 struct free_nid *i;
1524 bool need_free = false;
1525
1526 if (!nid)
1527 return;
1528
1529 spin_lock(&nm_i->free_nid_list_lock);
1530 i = __lookup_free_nid_list(nm_i, nid);
1531 f2fs_bug_on(sbi, !i || i->state != NID_ALLOC);
1532 if (!available_free_memory(sbi, FREE_NIDS)) {
1533 __del_from_free_nid_list(nm_i, i);
1534 need_free = true;
1535 } else {
1536 i->state = NID_NEW;
1537 nm_i->fcnt++;
1538 }
1539 spin_unlock(&nm_i->free_nid_list_lock);
1540
1541 if (need_free)
1542 kmem_cache_free(free_nid_slab, i);
1543 }
1544
1545 void recover_inline_xattr(struct inode *inode, struct page *page)
1546 {
1547 void *src_addr, *dst_addr;
1548 size_t inline_size;
1549 struct page *ipage;
1550 struct f2fs_inode *ri;
1551
1552 ipage = get_node_page(F2FS_I_SB(inode), inode->i_ino);
1553 f2fs_bug_on(F2FS_I_SB(inode), IS_ERR(ipage));
1554
1555 ri = F2FS_INODE(page);
1556 if (!(ri->i_inline & F2FS_INLINE_XATTR)) {
1557 clear_inode_flag(F2FS_I(inode), FI_INLINE_XATTR);
1558 goto update_inode;
1559 }
1560
1561 dst_addr = inline_xattr_addr(ipage);
1562 src_addr = inline_xattr_addr(page);
1563 inline_size = inline_xattr_size(inode);
1564
1565 f2fs_wait_on_page_writeback(ipage, NODE);
1566 memcpy(dst_addr, src_addr, inline_size);
1567 update_inode:
1568 update_inode(inode, ipage);
1569 f2fs_put_page(ipage, 1);
1570 }
1571
1572 void recover_xattr_data(struct inode *inode, struct page *page, block_t blkaddr)
1573 {
1574 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
1575 nid_t prev_xnid = F2FS_I(inode)->i_xattr_nid;
1576 nid_t new_xnid = nid_of_node(page);
1577 struct node_info ni;
1578
1579 /* 1: invalidate the previous xattr nid */
1580 if (!prev_xnid)
1581 goto recover_xnid;
1582
1583 /* Deallocate node address */
1584 get_node_info(sbi, prev_xnid, &ni);
1585 f2fs_bug_on(sbi, ni.blk_addr == NULL_ADDR);
1586 invalidate_blocks(sbi, ni.blk_addr);
1587 dec_valid_node_count(sbi, inode);
1588 set_node_addr(sbi, &ni, NULL_ADDR, false);
1589
1590 recover_xnid:
1591 /* 2: allocate new xattr nid */
1592 if (unlikely(!inc_valid_node_count(sbi, inode)))
1593 f2fs_bug_on(sbi, 1);
1594
1595 remove_free_nid(NM_I(sbi), new_xnid);
1596 get_node_info(sbi, new_xnid, &ni);
1597 ni.ino = inode->i_ino;
1598 set_node_addr(sbi, &ni, NEW_ADDR, false);
1599 F2FS_I(inode)->i_xattr_nid = new_xnid;
1600
1601 /* 3: update xattr blkaddr */
1602 refresh_sit_entry(sbi, NEW_ADDR, blkaddr);
1603 set_node_addr(sbi, &ni, blkaddr, false);
1604
1605 update_inode_page(inode);
1606 }
1607
1608 int recover_inode_page(struct f2fs_sb_info *sbi, struct page *page)
1609 {
1610 struct f2fs_inode *src, *dst;
1611 nid_t ino = ino_of_node(page);
1612 struct node_info old_ni, new_ni;
1613 struct page *ipage;
1614
1615 get_node_info(sbi, ino, &old_ni);
1616
1617 if (unlikely(old_ni.blk_addr != NULL_ADDR))
1618 return -EINVAL;
1619
1620 ipage = grab_cache_page(NODE_MAPPING(sbi), ino);
1621 if (!ipage)
1622 return -ENOMEM;
1623
1624 /* Should not use this inode from free nid list */
1625 remove_free_nid(NM_I(sbi), ino);
1626
1627 SetPageUptodate(ipage);
1628 fill_node_footer(ipage, ino, ino, 0, true);
1629
1630 src = F2FS_INODE(page);
1631 dst = F2FS_INODE(ipage);
1632
1633 memcpy(dst, src, (unsigned long)&src->i_ext - (unsigned long)src);
1634 dst->i_size = 0;
1635 dst->i_blocks = cpu_to_le64(1);
1636 dst->i_links = cpu_to_le32(1);
1637 dst->i_xattr_nid = 0;
1638 dst->i_inline = src->i_inline & F2FS_INLINE_XATTR;
1639
1640 new_ni = old_ni;
1641 new_ni.ino = ino;
1642
1643 if (unlikely(!inc_valid_node_count(sbi, NULL)))
1644 WARN_ON(1);
1645 set_node_addr(sbi, &new_ni, NEW_ADDR, false);
1646 inc_valid_inode_count(sbi);
1647 set_page_dirty(ipage);
1648 f2fs_put_page(ipage, 1);
1649 return 0;
1650 }
1651
1652 /*
1653 * ra_sum_pages() merge contiguous pages into one bio and submit.
1654 * these pre-read pages are allocated in bd_inode's mapping tree.
1655 */
1656 static int ra_sum_pages(struct f2fs_sb_info *sbi, struct page **pages,
1657 int start, int nrpages)
1658 {
1659 struct inode *inode = sbi->sb->s_bdev->bd_inode;
1660 struct address_space *mapping = inode->i_mapping;
1661 int i, page_idx = start;
1662 struct f2fs_io_info fio = {
1663 .type = META,
1664 .rw = READ_SYNC | REQ_META | REQ_PRIO
1665 };
1666
1667 for (i = 0; page_idx < start + nrpages; page_idx++, i++) {
1668 /* alloc page in bd_inode for reading node summary info */
1669 pages[i] = grab_cache_page(mapping, page_idx);
1670 if (!pages[i])
1671 break;
1672 f2fs_submit_page_mbio(sbi, pages[i], page_idx, &fio);
1673 }
1674
1675 f2fs_submit_merged_bio(sbi, META, READ);
1676 return i;
1677 }
1678
1679 int restore_node_summary(struct f2fs_sb_info *sbi,
1680 unsigned int segno, struct f2fs_summary_block *sum)
1681 {
1682 struct f2fs_node *rn;
1683 struct f2fs_summary *sum_entry;
1684 struct inode *inode = sbi->sb->s_bdev->bd_inode;
1685 block_t addr;
1686 int bio_blocks = MAX_BIO_BLOCKS(max_hw_blocks(sbi));
1687 struct page *pages[bio_blocks];
1688 int i, idx, last_offset, nrpages, err = 0;
1689
1690 /* scan the node segment */
1691 last_offset = sbi->blocks_per_seg;
1692 addr = START_BLOCK(sbi, segno);
1693 sum_entry = &sum->entries[0];
1694
1695 for (i = 0; !err && i < last_offset; i += nrpages, addr += nrpages) {
1696 nrpages = min(last_offset - i, bio_blocks);
1697
1698 /* readahead node pages */
1699 nrpages = ra_sum_pages(sbi, pages, addr, nrpages);
1700 if (!nrpages)
1701 return -ENOMEM;
1702
1703 for (idx = 0; idx < nrpages; idx++) {
1704 if (err)
1705 goto skip;
1706
1707 lock_page(pages[idx]);
1708 if (unlikely(!PageUptodate(pages[idx]))) {
1709 err = -EIO;
1710 } else {
1711 rn = F2FS_NODE(pages[idx]);
1712 sum_entry->nid = rn->footer.nid;
1713 sum_entry->version = 0;
1714 sum_entry->ofs_in_node = 0;
1715 sum_entry++;
1716 }
1717 unlock_page(pages[idx]);
1718 skip:
1719 page_cache_release(pages[idx]);
1720 }
1721
1722 invalidate_mapping_pages(inode->i_mapping, addr,
1723 addr + nrpages);
1724 }
1725 return err;
1726 }
1727
1728 static struct nat_entry_set *grab_nat_entry_set(void)
1729 {
1730 struct nat_entry_set *nes =
1731 f2fs_kmem_cache_alloc(nat_entry_set_slab, GFP_ATOMIC);
1732
1733 nes->entry_cnt = 0;
1734 INIT_LIST_HEAD(&nes->set_list);
1735 INIT_LIST_HEAD(&nes->entry_list);
1736 return nes;
1737 }
1738
1739 static void release_nat_entry_set(struct nat_entry_set *nes,
1740 struct f2fs_nm_info *nm_i)
1741 {
1742 nm_i->dirty_nat_cnt -= nes->entry_cnt;
1743 list_del(&nes->set_list);
1744 kmem_cache_free(nat_entry_set_slab, nes);
1745 }
1746
1747 static void adjust_nat_entry_set(struct nat_entry_set *nes,
1748 struct list_head *head)
1749 {
1750 struct nat_entry_set *next = nes;
1751
1752 if (list_is_last(&nes->set_list, head))
1753 return;
1754
1755 list_for_each_entry_continue(next, head, set_list)
1756 if (nes->entry_cnt <= next->entry_cnt)
1757 break;
1758
1759 list_move_tail(&nes->set_list, &next->set_list);
1760 }
1761
1762 static void add_nat_entry(struct nat_entry *ne, struct list_head *head)
1763 {
1764 struct nat_entry_set *nes;
1765 nid_t start_nid = START_NID(ne->ni.nid);
1766
1767 list_for_each_entry(nes, head, set_list) {
1768 if (nes->start_nid == start_nid) {
1769 list_move_tail(&ne->list, &nes->entry_list);
1770 nes->entry_cnt++;
1771 adjust_nat_entry_set(nes, head);
1772 return;
1773 }
1774 }
1775
1776 nes = grab_nat_entry_set();
1777
1778 nes->start_nid = start_nid;
1779 list_move_tail(&ne->list, &nes->entry_list);
1780 nes->entry_cnt++;
1781 list_add(&nes->set_list, head);
1782 }
1783
1784 static void merge_nats_in_set(struct f2fs_sb_info *sbi)
1785 {
1786 struct f2fs_nm_info *nm_i = NM_I(sbi);
1787 struct list_head *dirty_list = &nm_i->dirty_nat_entries;
1788 struct list_head *set_list = &nm_i->nat_entry_set;
1789 struct nat_entry *ne, *tmp;
1790
1791 write_lock(&nm_i->nat_tree_lock);
1792 list_for_each_entry_safe(ne, tmp, dirty_list, list) {
1793 if (nat_get_blkaddr(ne) == NEW_ADDR)
1794 continue;
1795 add_nat_entry(ne, set_list);
1796 nm_i->dirty_nat_cnt++;
1797 }
1798 write_unlock(&nm_i->nat_tree_lock);
1799 }
1800
1801 static void remove_nats_in_journal(struct f2fs_sb_info *sbi)
1802 {
1803 struct f2fs_nm_info *nm_i = NM_I(sbi);
1804 struct curseg_info *curseg = CURSEG_I(sbi, CURSEG_HOT_DATA);
1805 struct f2fs_summary_block *sum = curseg->sum_blk;
1806 int i;
1807
1808 mutex_lock(&curseg->curseg_mutex);
1809 for (i = 0; i < nats_in_cursum(sum); i++) {
1810 struct nat_entry *ne;
1811 struct f2fs_nat_entry raw_ne;
1812 nid_t nid = le32_to_cpu(nid_in_journal(sum, i));
1813
1814 raw_ne = nat_in_journal(sum, i);
1815 retry:
1816 write_lock(&nm_i->nat_tree_lock);
1817 ne = __lookup_nat_cache(nm_i, nid);
1818 if (ne)
1819 goto found;
1820
1821 ne = grab_nat_entry(nm_i, nid);
1822 if (!ne) {
1823 write_unlock(&nm_i->nat_tree_lock);
1824 goto retry;
1825 }
1826 node_info_from_raw_nat(&ne->ni, &raw_ne);
1827 found:
1828 __set_nat_cache_dirty(nm_i, ne);
1829 write_unlock(&nm_i->nat_tree_lock);
1830 }
1831 update_nats_in_cursum(sum, -i);
1832 mutex_unlock(&curseg->curseg_mutex);
1833 }
1834
1835 /*
1836 * This function is called during the checkpointing process.
1837 */
1838 void flush_nat_entries(struct f2fs_sb_info *sbi)
1839 {
1840 struct f2fs_nm_info *nm_i = NM_I(sbi);
1841 struct curseg_info *curseg = CURSEG_I(sbi, CURSEG_HOT_DATA);
1842 struct f2fs_summary_block *sum = curseg->sum_blk;
1843 struct nat_entry_set *nes, *tmp;
1844 struct list_head *head = &nm_i->nat_entry_set;
1845 bool to_journal = true;
1846
1847 /* merge nat entries of dirty list to nat entry set temporarily */
1848 merge_nats_in_set(sbi);
1849
1850 /*
1851 * if there are no enough space in journal to store dirty nat
1852 * entries, remove all entries from journal and merge them
1853 * into nat entry set.
1854 */
1855 if (!__has_cursum_space(sum, nm_i->dirty_nat_cnt, NAT_JOURNAL)) {
1856 remove_nats_in_journal(sbi);
1857
1858 /*
1859 * merge nat entries of dirty list to nat entry set temporarily
1860 */
1861 merge_nats_in_set(sbi);
1862 }
1863
1864 if (!nm_i->dirty_nat_cnt)
1865 return;
1866
1867 /*
1868 * there are two steps to flush nat entries:
1869 * #1, flush nat entries to journal in current hot data summary block.
1870 * #2, flush nat entries to nat page.
1871 */
1872 list_for_each_entry_safe(nes, tmp, head, set_list) {
1873 struct f2fs_nat_block *nat_blk;
1874 struct nat_entry *ne, *cur;
1875 struct page *page;
1876 nid_t start_nid = nes->start_nid;
1877
1878 if (to_journal &&
1879 !__has_cursum_space(sum, nes->entry_cnt, NAT_JOURNAL))
1880 to_journal = false;
1881
1882 if (to_journal) {
1883 mutex_lock(&curseg->curseg_mutex);
1884 } else {
1885 page = get_next_nat_page(sbi, start_nid);
1886 nat_blk = page_address(page);
1887 f2fs_bug_on(sbi, !nat_blk);
1888 }
1889
1890 /* flush dirty nats in nat entry set */
1891 list_for_each_entry_safe(ne, cur, &nes->entry_list, list) {
1892 struct f2fs_nat_entry *raw_ne;
1893 nid_t nid = nat_get_nid(ne);
1894 int offset;
1895
1896 if (to_journal) {
1897 offset = lookup_journal_in_cursum(sum,
1898 NAT_JOURNAL, nid, 1);
1899 f2fs_bug_on(sbi, offset < 0);
1900 raw_ne = &nat_in_journal(sum, offset);
1901 nid_in_journal(sum, offset) = cpu_to_le32(nid);
1902 } else {
1903 raw_ne = &nat_blk->entries[nid - start_nid];
1904 }
1905 raw_nat_from_node_info(raw_ne, &ne->ni);
1906
1907 if (nat_get_blkaddr(ne) == NULL_ADDR &&
1908 add_free_nid(sbi, nid, false) <= 0) {
1909 write_lock(&nm_i->nat_tree_lock);
1910 __del_from_nat_cache(nm_i, ne);
1911 write_unlock(&nm_i->nat_tree_lock);
1912 } else {
1913 write_lock(&nm_i->nat_tree_lock);
1914 __clear_nat_cache_dirty(nm_i, ne);
1915 write_unlock(&nm_i->nat_tree_lock);
1916 }
1917 }
1918
1919 if (to_journal)
1920 mutex_unlock(&curseg->curseg_mutex);
1921 else
1922 f2fs_put_page(page, 1);
1923
1924 f2fs_bug_on(sbi, !list_empty(&nes->entry_list));
1925 release_nat_entry_set(nes, nm_i);
1926 }
1927
1928 f2fs_bug_on(sbi, !list_empty(head));
1929 f2fs_bug_on(sbi, nm_i->dirty_nat_cnt);
1930 }
1931
1932 static int init_node_manager(struct f2fs_sb_info *sbi)
1933 {
1934 struct f2fs_super_block *sb_raw = F2FS_RAW_SUPER(sbi);
1935 struct f2fs_nm_info *nm_i = NM_I(sbi);
1936 unsigned char *version_bitmap;
1937 unsigned int nat_segs, nat_blocks;
1938
1939 nm_i->nat_blkaddr = le32_to_cpu(sb_raw->nat_blkaddr);
1940
1941 /* segment_count_nat includes pair segment so divide to 2. */
1942 nat_segs = le32_to_cpu(sb_raw->segment_count_nat) >> 1;
1943 nat_blocks = nat_segs << le32_to_cpu(sb_raw->log_blocks_per_seg);
1944
1945 nm_i->max_nid = NAT_ENTRY_PER_BLOCK * nat_blocks;
1946
1947 /* not used nids: 0, node, meta, (and root counted as valid node) */
1948 nm_i->available_nids = nm_i->max_nid - F2FS_RESERVED_NODE_NUM;
1949 nm_i->fcnt = 0;
1950 nm_i->nat_cnt = 0;
1951 nm_i->ram_thresh = DEF_RAM_THRESHOLD;
1952
1953 INIT_RADIX_TREE(&nm_i->free_nid_root, GFP_ATOMIC);
1954 INIT_LIST_HEAD(&nm_i->free_nid_list);
1955 INIT_RADIX_TREE(&nm_i->nat_root, GFP_ATOMIC);
1956 INIT_LIST_HEAD(&nm_i->nat_entries);
1957 INIT_LIST_HEAD(&nm_i->dirty_nat_entries);
1958 INIT_LIST_HEAD(&nm_i->nat_entry_set);
1959
1960 mutex_init(&nm_i->build_lock);
1961 spin_lock_init(&nm_i->free_nid_list_lock);
1962 rwlock_init(&nm_i->nat_tree_lock);
1963
1964 nm_i->next_scan_nid = le32_to_cpu(sbi->ckpt->next_free_nid);
1965 nm_i->bitmap_size = __bitmap_size(sbi, NAT_BITMAP);
1966 version_bitmap = __bitmap_ptr(sbi, NAT_BITMAP);
1967 if (!version_bitmap)
1968 return -EFAULT;
1969
1970 nm_i->nat_bitmap = kmemdup(version_bitmap, nm_i->bitmap_size,
1971 GFP_KERNEL);
1972 if (!nm_i->nat_bitmap)
1973 return -ENOMEM;
1974 return 0;
1975 }
1976
1977 int build_node_manager(struct f2fs_sb_info *sbi)
1978 {
1979 int err;
1980
1981 sbi->nm_info = kzalloc(sizeof(struct f2fs_nm_info), GFP_KERNEL);
1982 if (!sbi->nm_info)
1983 return -ENOMEM;
1984
1985 err = init_node_manager(sbi);
1986 if (err)
1987 return err;
1988
1989 build_free_nids(sbi);
1990 return 0;
1991 }
1992
1993 void destroy_node_manager(struct f2fs_sb_info *sbi)
1994 {
1995 struct f2fs_nm_info *nm_i = NM_I(sbi);
1996 struct free_nid *i, *next_i;
1997 struct nat_entry *natvec[NATVEC_SIZE];
1998 nid_t nid = 0;
1999 unsigned int found;
2000
2001 if (!nm_i)
2002 return;
2003
2004 /* destroy free nid list */
2005 spin_lock(&nm_i->free_nid_list_lock);
2006 list_for_each_entry_safe(i, next_i, &nm_i->free_nid_list, list) {
2007 f2fs_bug_on(sbi, i->state == NID_ALLOC);
2008 __del_from_free_nid_list(nm_i, i);
2009 nm_i->fcnt--;
2010 spin_unlock(&nm_i->free_nid_list_lock);
2011 kmem_cache_free(free_nid_slab, i);
2012 spin_lock(&nm_i->free_nid_list_lock);
2013 }
2014 f2fs_bug_on(sbi, nm_i->fcnt);
2015 spin_unlock(&nm_i->free_nid_list_lock);
2016
2017 /* destroy nat cache */
2018 write_lock(&nm_i->nat_tree_lock);
2019 while ((found = __gang_lookup_nat_cache(nm_i,
2020 nid, NATVEC_SIZE, natvec))) {
2021 unsigned idx;
2022 nid = nat_get_nid(natvec[found - 1]) + 1;
2023 for (idx = 0; idx < found; idx++)
2024 __del_from_nat_cache(nm_i, natvec[idx]);
2025 }
2026 f2fs_bug_on(sbi, nm_i->nat_cnt);
2027 write_unlock(&nm_i->nat_tree_lock);
2028
2029 kfree(nm_i->nat_bitmap);
2030 sbi->nm_info = NULL;
2031 kfree(nm_i);
2032 }
2033
2034 int __init create_node_manager_caches(void)
2035 {
2036 nat_entry_slab = f2fs_kmem_cache_create("nat_entry",
2037 sizeof(struct nat_entry));
2038 if (!nat_entry_slab)
2039 goto fail;
2040
2041 free_nid_slab = f2fs_kmem_cache_create("free_nid",
2042 sizeof(struct free_nid));
2043 if (!free_nid_slab)
2044 goto destory_nat_entry;
2045
2046 nat_entry_set_slab = f2fs_kmem_cache_create("nat_entry_set",
2047 sizeof(struct nat_entry_set));
2048 if (!nat_entry_set_slab)
2049 goto destory_free_nid;
2050 return 0;
2051
2052 destory_free_nid:
2053 kmem_cache_destroy(free_nid_slab);
2054 destory_nat_entry:
2055 kmem_cache_destroy(nat_entry_slab);
2056 fail:
2057 return -ENOMEM;
2058 }
2059
2060 void destroy_node_manager_caches(void)
2061 {
2062 kmem_cache_destroy(nat_entry_set_slab);
2063 kmem_cache_destroy(free_nid_slab);
2064 kmem_cache_destroy(nat_entry_slab);
2065 }
Linux kernel - Deliverables
This page took 0.077043 seconds and 5 git commands to generate.