Commit | Line | Data |
---|---|---|
ae98043f | 1 | // SPDX-License-Identifier: GPL-2.0+ |
a60be987 RK |
2 | /* |
3 | * btnode.c - NILFS B-tree node cache | |
4 | * | |
5 | * Copyright (C) 2005-2008 Nippon Telegraph and Telephone Corporation. | |
6 | * | |
4b420ab4 RK |
7 | * Originally written by Seiji Kihara. |
8 | * Fully revised by Ryusuke Konishi for stabilization and simplification. | |
a60be987 RK |
9 | * |
10 | */ | |
11 | ||
12 | #include <linux/types.h> | |
13 | #include <linux/buffer_head.h> | |
14 | #include <linux/mm.h> | |
15 | #include <linux/backing-dev.h> | |
5a0e3ad6 | 16 | #include <linux/gfp.h> |
a60be987 RK |
17 | #include "nilfs.h" |
18 | #include "mdt.h" | |
19 | #include "dat.h" | |
20 | #include "page.h" | |
21 | #include "btnode.h" | |
22 | ||
a60be987 RK |
23 | void nilfs_btnode_cache_clear(struct address_space *btnc) |
24 | { | |
25 | invalidate_mapping_pages(btnc, 0, -1); | |
26 | truncate_inode_pages(btnc, 0); | |
27 | } | |
28 | ||
d501d736 RK |
29 | struct buffer_head * |
30 | nilfs_btnode_create_block(struct address_space *btnc, __u64 blocknr) | |
31 | { | |
32 | struct inode *inode = NILFS_BTNC_I(btnc); | |
33 | struct buffer_head *bh; | |
34 | ||
4ce5c342 | 35 | bh = nilfs_grab_buffer(inode, btnc, blocknr, BIT(BH_NILFS_Node)); |
d501d736 RK |
36 | if (unlikely(!bh)) |
37 | return NULL; | |
38 | ||
39 | if (unlikely(buffer_mapped(bh) || buffer_uptodate(bh) || | |
40 | buffer_dirty(bh))) { | |
41 | brelse(bh); | |
42 | BUG(); | |
43 | } | |
93407472 | 44 | memset(bh->b_data, 0, i_blocksize(inode)); |
0ef28f9a | 45 | bh->b_bdev = inode->i_sb->s_bdev; |
d501d736 RK |
46 | bh->b_blocknr = blocknr; |
47 | set_buffer_mapped(bh); | |
48 | set_buffer_uptodate(bh); | |
49 | ||
50 | unlock_page(bh->b_page); | |
09cbfeaf | 51 | put_page(bh->b_page); |
d501d736 RK |
52 | return bh; |
53 | } | |
54 | ||
a60be987 | 55 | int nilfs_btnode_submit_block(struct address_space *btnc, __u64 blocknr, |
2a222ca9 | 56 | sector_t pblocknr, int mode, int mode_flags, |
26dfdd8e | 57 | struct buffer_head **pbh, sector_t *submit_ptr) |
a60be987 RK |
58 | { |
59 | struct buffer_head *bh; | |
60 | struct inode *inode = NILFS_BTNC_I(btnc); | |
f8e6cc01 | 61 | struct page *page; |
a60be987 RK |
62 | int err; |
63 | ||
4ce5c342 | 64 | bh = nilfs_grab_buffer(inode, btnc, blocknr, BIT(BH_NILFS_Node)); |
a60be987 RK |
65 | if (unlikely(!bh)) |
66 | return -ENOMEM; | |
67 | ||
68 | err = -EEXIST; /* internal code */ | |
f8e6cc01 | 69 | page = bh->b_page; |
a60be987 RK |
70 | |
71 | if (buffer_uptodate(bh) || buffer_dirty(bh)) | |
72 | goto found; | |
73 | ||
74 | if (pblocknr == 0) { | |
75 | pblocknr = blocknr; | |
76 | if (inode->i_ino != NILFS_DAT_INO) { | |
0ef28f9a | 77 | struct the_nilfs *nilfs = inode->i_sb->s_fs_info; |
a60be987 RK |
78 | |
79 | /* blocknr is a virtual block number */ | |
0ef28f9a RK |
80 | err = nilfs_dat_translate(nilfs->ns_dat, blocknr, |
81 | &pblocknr); | |
a60be987 RK |
82 | if (unlikely(err)) { |
83 | brelse(bh); | |
84 | goto out_locked; | |
85 | } | |
86 | } | |
87 | } | |
26dfdd8e | 88 | |
2a222ca9 | 89 | if (mode_flags & REQ_RAHEAD) { |
26dfdd8e RK |
90 | if (pblocknr != *submit_ptr + 1 || !trylock_buffer(bh)) { |
91 | err = -EBUSY; /* internal code */ | |
92 | brelse(bh); | |
93 | goto out_locked; | |
94 | } | |
95 | } else { /* mode == READ */ | |
96 | lock_buffer(bh); | |
97 | } | |
a60be987 RK |
98 | if (buffer_uptodate(bh)) { |
99 | unlock_buffer(bh); | |
100 | err = -EEXIST; /* internal code */ | |
101 | goto found; | |
102 | } | |
103 | set_buffer_mapped(bh); | |
0ef28f9a | 104 | bh->b_bdev = inode->i_sb->s_bdev; |
a60be987 RK |
105 | bh->b_blocknr = pblocknr; /* set block address for read */ |
106 | bh->b_end_io = end_buffer_read_sync; | |
107 | get_bh(bh); | |
2a222ca9 | 108 | submit_bh(mode, mode_flags, bh); |
a60be987 | 109 | bh->b_blocknr = blocknr; /* set back to the given block address */ |
26dfdd8e | 110 | *submit_ptr = pblocknr; |
a60be987 RK |
111 | err = 0; |
112 | found: | |
113 | *pbh = bh; | |
114 | ||
115 | out_locked: | |
f8e6cc01 | 116 | unlock_page(page); |
09cbfeaf | 117 | put_page(page); |
a60be987 RK |
118 | return err; |
119 | } | |
120 | ||
a60be987 RK |
121 | /** |
122 | * nilfs_btnode_delete - delete B-tree node buffer | |
123 | * @bh: buffer to be deleted | |
124 | * | |
125 | * nilfs_btnode_delete() invalidates the specified buffer and delete the page | |
126 | * including the buffer if the page gets unbusy. | |
127 | */ | |
128 | void nilfs_btnode_delete(struct buffer_head *bh) | |
129 | { | |
130 | struct address_space *mapping; | |
131 | struct page *page = bh->b_page; | |
132 | pgoff_t index = page_index(page); | |
133 | int still_dirty; | |
134 | ||
09cbfeaf | 135 | get_page(page); |
a60be987 RK |
136 | lock_page(page); |
137 | wait_on_page_writeback(page); | |
138 | ||
139 | nilfs_forget_buffer(bh); | |
140 | still_dirty = PageDirty(page); | |
141 | mapping = page->mapping; | |
142 | unlock_page(page); | |
09cbfeaf | 143 | put_page(page); |
a60be987 RK |
144 | |
145 | if (!still_dirty && mapping) | |
146 | invalidate_inode_pages2_range(mapping, index, index); | |
147 | } | |
148 | ||
149 | /** | |
150 | * nilfs_btnode_prepare_change_key | |
151 | * prepare to move contents of the block for old key to one of new key. | |
152 | * the old buffer will not be removed, but might be reused for new buffer. | |
153 | * it might return -ENOMEM because of memory allocation errors, | |
154 | * and might return -EIO because of disk read errors. | |
155 | */ | |
156 | int nilfs_btnode_prepare_change_key(struct address_space *btnc, | |
157 | struct nilfs_btnode_chkey_ctxt *ctxt) | |
158 | { | |
159 | struct buffer_head *obh, *nbh; | |
160 | struct inode *inode = NILFS_BTNC_I(btnc); | |
161 | __u64 oldkey = ctxt->oldkey, newkey = ctxt->newkey; | |
162 | int err; | |
163 | ||
164 | if (oldkey == newkey) | |
165 | return 0; | |
166 | ||
167 | obh = ctxt->bh; | |
168 | ctxt->newbh = NULL; | |
169 | ||
09cbfeaf | 170 | if (inode->i_blkbits == PAGE_SHIFT) { |
a60be987 RK |
171 | lock_page(obh->b_page); |
172 | /* | |
173 | * We cannot call radix_tree_preload for the kernels older | |
174 | * than 2.6.23, because it is not exported for modules. | |
175 | */ | |
b1f1b8ce | 176 | retry: |
a60be987 RK |
177 | err = radix_tree_preload(GFP_NOFS & ~__GFP_HIGHMEM); |
178 | if (err) | |
179 | goto failed_unlock; | |
180 | /* BUG_ON(oldkey != obh->b_page->index); */ | |
181 | if (unlikely(oldkey != obh->b_page->index)) | |
182 | NILFS_PAGE_BUG(obh->b_page, | |
183 | "invalid oldkey %lld (newkey=%lld)", | |
184 | (unsigned long long)oldkey, | |
185 | (unsigned long long)newkey); | |
186 | ||
b93b0163 MW |
187 | xa_lock_irq(&btnc->i_pages); |
188 | err = radix_tree_insert(&btnc->i_pages, newkey, obh->b_page); | |
189 | xa_unlock_irq(&btnc->i_pages); | |
a60be987 RK |
190 | /* |
191 | * Note: page->index will not change to newkey until | |
192 | * nilfs_btnode_commit_change_key() will be called. | |
193 | * To protect the page in intermediate state, the page lock | |
194 | * is held. | |
195 | */ | |
196 | radix_tree_preload_end(); | |
197 | if (!err) | |
198 | return 0; | |
199 | else if (err != -EEXIST) | |
200 | goto failed_unlock; | |
201 | ||
202 | err = invalidate_inode_pages2_range(btnc, newkey, newkey); | |
203 | if (!err) | |
204 | goto retry; | |
205 | /* fallback to copy mode */ | |
206 | unlock_page(obh->b_page); | |
207 | } | |
208 | ||
45f4910b RK |
209 | nbh = nilfs_btnode_create_block(btnc, newkey); |
210 | if (!nbh) | |
211 | return -ENOMEM; | |
212 | ||
213 | BUG_ON(nbh == obh); | |
214 | ctxt->newbh = nbh; | |
215 | return 0; | |
a60be987 RK |
216 | |
217 | failed_unlock: | |
218 | unlock_page(obh->b_page); | |
219 | return err; | |
220 | } | |
221 | ||
222 | /** | |
223 | * nilfs_btnode_commit_change_key | |
224 | * commit the change_key operation prepared by prepare_change_key(). | |
225 | */ | |
226 | void nilfs_btnode_commit_change_key(struct address_space *btnc, | |
227 | struct nilfs_btnode_chkey_ctxt *ctxt) | |
228 | { | |
229 | struct buffer_head *obh = ctxt->bh, *nbh = ctxt->newbh; | |
230 | __u64 oldkey = ctxt->oldkey, newkey = ctxt->newkey; | |
231 | struct page *opage; | |
232 | ||
233 | if (oldkey == newkey) | |
234 | return; | |
235 | ||
236 | if (nbh == NULL) { /* blocksize == pagesize */ | |
237 | opage = obh->b_page; | |
238 | if (unlikely(oldkey != opage->index)) | |
239 | NILFS_PAGE_BUG(opage, | |
240 | "invalid oldkey %lld (newkey=%lld)", | |
241 | (unsigned long long)oldkey, | |
242 | (unsigned long long)newkey); | |
5fc7b141 | 243 | mark_buffer_dirty(obh); |
a60be987 | 244 | |
b93b0163 MW |
245 | xa_lock_irq(&btnc->i_pages); |
246 | radix_tree_delete(&btnc->i_pages, oldkey); | |
247 | radix_tree_tag_set(&btnc->i_pages, newkey, | |
a60be987 | 248 | PAGECACHE_TAG_DIRTY); |
b93b0163 | 249 | xa_unlock_irq(&btnc->i_pages); |
a60be987 RK |
250 | |
251 | opage->index = obh->b_blocknr = newkey; | |
252 | unlock_page(opage); | |
253 | } else { | |
254 | nilfs_copy_buffer(nbh, obh); | |
5fc7b141 | 255 | mark_buffer_dirty(nbh); |
a60be987 RK |
256 | |
257 | nbh->b_blocknr = newkey; | |
258 | ctxt->bh = nbh; | |
259 | nilfs_btnode_delete(obh); /* will decrement bh->b_count */ | |
260 | } | |
261 | } | |
262 | ||
263 | /** | |
264 | * nilfs_btnode_abort_change_key | |
265 | * abort the change_key operation prepared by prepare_change_key(). | |
266 | */ | |
267 | void nilfs_btnode_abort_change_key(struct address_space *btnc, | |
268 | struct nilfs_btnode_chkey_ctxt *ctxt) | |
269 | { | |
270 | struct buffer_head *nbh = ctxt->newbh; | |
271 | __u64 oldkey = ctxt->oldkey, newkey = ctxt->newkey; | |
272 | ||
273 | if (oldkey == newkey) | |
274 | return; | |
275 | ||
276 | if (nbh == NULL) { /* blocksize == pagesize */ | |
b93b0163 MW |
277 | xa_lock_irq(&btnc->i_pages); |
278 | radix_tree_delete(&btnc->i_pages, newkey); | |
279 | xa_unlock_irq(&btnc->i_pages); | |
a60be987 RK |
280 | unlock_page(ctxt->bh->b_page); |
281 | } else | |
282 | brelse(nbh); | |
283 | } |