1 | // SPDX-License-Identifier: GPL-2.0+ |
2 | /* |
3 | * NILFS direct block pointer. |
4 | * |
5 | * Copyright (C) 2006-2008 Nippon Telegraph and Telephone Corporation. |
6 | * |
7 | * Written by Koji Sato. |
8 | */ |
9 | |
10 | #include <linux/errno.h> |
11 | #include "nilfs.h" |
12 | #include "page.h" |
13 | #include "direct.h" |
14 | #include "alloc.h" |
15 | #include "dat.h" |
16 | |
17 | static inline __le64 *nilfs_direct_dptrs(const struct nilfs_bmap *direct) |
18 | { |
19 | return (__le64 *) |
20 | ((struct nilfs_direct_node *)direct->b_u.u_data + 1); |
21 | } |
22 | |
23 | static inline __u64 |
24 | nilfs_direct_get_ptr(const struct nilfs_bmap *direct, __u64 key) |
25 | { |
26 | return le64_to_cpu(*(nilfs_direct_dptrs(direct) + key)); |
27 | } |
28 | |
29 | static inline void nilfs_direct_set_ptr(struct nilfs_bmap *direct, |
30 | __u64 key, __u64 ptr) |
31 | { |
32 | *(nilfs_direct_dptrs(direct) + key) = cpu_to_le64(ptr); |
33 | } |
34 | |
35 | static int nilfs_direct_lookup(const struct nilfs_bmap *direct, |
36 | __u64 key, int level, __u64 *ptrp) |
37 | { |
38 | __u64 ptr; |
39 | |
40 | if (key > NILFS_DIRECT_KEY_MAX || level != 1) |
41 | return -ENOENT; |
42 | ptr = nilfs_direct_get_ptr(direct, key); |
43 | if (ptr == NILFS_BMAP_INVALID_PTR) |
44 | return -ENOENT; |
45 | |
46 | *ptrp = ptr; |
47 | return 0; |
48 | } |
49 | |
50 | static int nilfs_direct_lookup_contig(const struct nilfs_bmap *direct, |
51 | __u64 key, __u64 *ptrp, |
52 | unsigned int maxblocks) |
53 | { |
54 | struct inode *dat = NULL; |
55 | __u64 ptr, ptr2; |
56 | sector_t blocknr; |
57 | int ret, cnt; |
58 | |
59 | if (key > NILFS_DIRECT_KEY_MAX) |
60 | return -ENOENT; |
61 | ptr = nilfs_direct_get_ptr(direct, key); |
62 | if (ptr == NILFS_BMAP_INVALID_PTR) |
63 | return -ENOENT; |
64 | |
65 | if (NILFS_BMAP_USE_VBN(direct)) { |
66 | dat = nilfs_bmap_get_dat(direct); |
67 | ret = nilfs_dat_translate(dat, ptr, &blocknr); |
68 | if (ret < 0) |
69 | goto dat_error; |
70 | ptr = blocknr; |
71 | } |
72 | |
73 | maxblocks = min_t(unsigned int, maxblocks, |
74 | NILFS_DIRECT_KEY_MAX - key + 1); |
75 | for (cnt = 1; cnt < maxblocks && |
76 | (ptr2 = nilfs_direct_get_ptr(direct, key: key + cnt)) != |
77 | NILFS_BMAP_INVALID_PTR; |
78 | cnt++) { |
79 | if (dat) { |
80 | ret = nilfs_dat_translate(dat, ptr2, &blocknr); |
81 | if (ret < 0) |
82 | goto dat_error; |
83 | ptr2 = blocknr; |
84 | } |
85 | if (ptr2 != ptr + cnt) |
86 | break; |
87 | } |
88 | *ptrp = ptr; |
89 | return cnt; |
90 | |
91 | dat_error: |
92 | if (ret == -ENOENT) |
93 | ret = -EINVAL; /* Notify bmap layer of metadata corruption */ |
94 | return ret; |
95 | } |
96 | |
97 | static __u64 |
98 | nilfs_direct_find_target_v(const struct nilfs_bmap *direct, __u64 key) |
99 | { |
100 | __u64 ptr; |
101 | |
102 | ptr = nilfs_bmap_find_target_seq(direct, key); |
103 | if (ptr != NILFS_BMAP_INVALID_PTR) |
104 | /* sequential access */ |
105 | return ptr; |
106 | |
107 | /* block group */ |
108 | return nilfs_bmap_find_target_in_group(direct); |
109 | } |
110 | |
111 | static int nilfs_direct_insert(struct nilfs_bmap *bmap, __u64 key, __u64 ptr) |
112 | { |
113 | union nilfs_bmap_ptr_req req; |
114 | struct inode *dat = NULL; |
115 | struct buffer_head *bh; |
116 | int ret; |
117 | |
118 | if (key > NILFS_DIRECT_KEY_MAX) |
119 | return -ENOENT; |
120 | if (nilfs_direct_get_ptr(direct: bmap, key) != NILFS_BMAP_INVALID_PTR) |
121 | return -EEXIST; |
122 | |
123 | if (NILFS_BMAP_USE_VBN(bmap)) { |
124 | req.bpr_ptr = nilfs_direct_find_target_v(direct: bmap, key); |
125 | dat = nilfs_bmap_get_dat(bmap); |
126 | } |
127 | ret = nilfs_bmap_prepare_alloc_ptr(bmap, req: &req, dat); |
128 | if (!ret) { |
129 | /* ptr must be a pointer to a buffer head. */ |
130 | bh = (struct buffer_head *)((unsigned long)ptr); |
131 | set_buffer_nilfs_volatile(bh); |
132 | |
133 | nilfs_bmap_commit_alloc_ptr(bmap, req: &req, dat); |
134 | nilfs_direct_set_ptr(direct: bmap, key, ptr: req.bpr_ptr); |
135 | |
136 | if (!nilfs_bmap_dirty(bmap)) |
137 | nilfs_bmap_set_dirty(bmap); |
138 | |
139 | if (NILFS_BMAP_USE_VBN(bmap)) |
140 | nilfs_bmap_set_target_v(bmap, key, ptr: req.bpr_ptr); |
141 | |
142 | nilfs_inode_add_blocks(inode: bmap->b_inode, n: 1); |
143 | } |
144 | return ret; |
145 | } |
146 | |
147 | static int nilfs_direct_delete(struct nilfs_bmap *bmap, __u64 key) |
148 | { |
149 | union nilfs_bmap_ptr_req req; |
150 | struct inode *dat; |
151 | int ret; |
152 | |
153 | if (key > NILFS_DIRECT_KEY_MAX || |
154 | nilfs_direct_get_ptr(direct: bmap, key) == NILFS_BMAP_INVALID_PTR) |
155 | return -ENOENT; |
156 | |
157 | dat = NILFS_BMAP_USE_VBN(bmap) ? nilfs_bmap_get_dat(bmap) : NULL; |
158 | req.bpr_ptr = nilfs_direct_get_ptr(direct: bmap, key); |
159 | |
160 | ret = nilfs_bmap_prepare_end_ptr(bmap, req: &req, dat); |
161 | if (!ret) { |
162 | nilfs_bmap_commit_end_ptr(bmap, req: &req, dat); |
163 | nilfs_direct_set_ptr(direct: bmap, key, NILFS_BMAP_INVALID_PTR); |
164 | nilfs_inode_sub_blocks(inode: bmap->b_inode, n: 1); |
165 | } |
166 | return ret; |
167 | } |
168 | |
169 | static int nilfs_direct_seek_key(const struct nilfs_bmap *direct, __u64 start, |
170 | __u64 *keyp) |
171 | { |
172 | __u64 key; |
173 | |
174 | for (key = start; key <= NILFS_DIRECT_KEY_MAX; key++) { |
175 | if (nilfs_direct_get_ptr(direct, key) != |
176 | NILFS_BMAP_INVALID_PTR) { |
177 | *keyp = key; |
178 | return 0; |
179 | } |
180 | } |
181 | return -ENOENT; |
182 | } |
183 | |
184 | static int nilfs_direct_last_key(const struct nilfs_bmap *direct, __u64 *keyp) |
185 | { |
186 | __u64 key, lastkey; |
187 | |
188 | lastkey = NILFS_DIRECT_KEY_MAX + 1; |
189 | for (key = NILFS_DIRECT_KEY_MIN; key <= NILFS_DIRECT_KEY_MAX; key++) |
190 | if (nilfs_direct_get_ptr(direct, key) != |
191 | NILFS_BMAP_INVALID_PTR) |
192 | lastkey = key; |
193 | |
194 | if (lastkey == NILFS_DIRECT_KEY_MAX + 1) |
195 | return -ENOENT; |
196 | |
197 | *keyp = lastkey; |
198 | |
199 | return 0; |
200 | } |
201 | |
202 | static int nilfs_direct_check_insert(const struct nilfs_bmap *bmap, __u64 key) |
203 | { |
204 | return key > NILFS_DIRECT_KEY_MAX; |
205 | } |
206 | |
207 | static int nilfs_direct_gather_data(struct nilfs_bmap *direct, |
208 | __u64 *keys, __u64 *ptrs, int nitems) |
209 | { |
210 | __u64 key; |
211 | __u64 ptr; |
212 | int n; |
213 | |
214 | if (nitems > NILFS_DIRECT_NBLOCKS) |
215 | nitems = NILFS_DIRECT_NBLOCKS; |
216 | n = 0; |
217 | for (key = 0; key < nitems; key++) { |
218 | ptr = nilfs_direct_get_ptr(direct, key); |
219 | if (ptr != NILFS_BMAP_INVALID_PTR) { |
220 | keys[n] = key; |
221 | ptrs[n] = ptr; |
222 | n++; |
223 | } |
224 | } |
225 | return n; |
226 | } |
227 | |
228 | int nilfs_direct_delete_and_convert(struct nilfs_bmap *bmap, |
229 | __u64 key, __u64 *keys, __u64 *ptrs, int n) |
230 | { |
231 | __le64 *dptrs; |
232 | int ret, i, j; |
233 | |
234 | /* no need to allocate any resource for conversion */ |
235 | |
236 | /* delete */ |
237 | ret = bmap->b_ops->bop_delete(bmap, key); |
238 | if (ret < 0) |
239 | return ret; |
240 | |
241 | /* free resources */ |
242 | if (bmap->b_ops->bop_clear != NULL) |
243 | bmap->b_ops->bop_clear(bmap); |
244 | |
245 | /* convert */ |
246 | dptrs = nilfs_direct_dptrs(direct: bmap); |
247 | for (i = 0, j = 0; i < NILFS_DIRECT_NBLOCKS; i++) { |
248 | if ((j < n) && (i == keys[j])) { |
249 | dptrs[i] = (i != key) ? |
250 | cpu_to_le64(ptrs[j]) : |
251 | NILFS_BMAP_INVALID_PTR; |
252 | j++; |
253 | } else |
254 | dptrs[i] = NILFS_BMAP_INVALID_PTR; |
255 | } |
256 | |
257 | nilfs_direct_init(bmap); |
258 | return 0; |
259 | } |
260 | |
261 | static int nilfs_direct_propagate(struct nilfs_bmap *bmap, |
262 | struct buffer_head *bh) |
263 | { |
264 | struct nilfs_palloc_req oldreq, newreq; |
265 | struct inode *dat; |
266 | __u64 key; |
267 | __u64 ptr; |
268 | int ret; |
269 | |
270 | if (!NILFS_BMAP_USE_VBN(bmap)) |
271 | return 0; |
272 | |
273 | dat = nilfs_bmap_get_dat(bmap); |
274 | key = nilfs_bmap_data_get_key(bmap, bh); |
275 | ptr = nilfs_direct_get_ptr(direct: bmap, key); |
276 | if (!buffer_nilfs_volatile(bh)) { |
277 | oldreq.pr_entry_nr = ptr; |
278 | newreq.pr_entry_nr = ptr; |
279 | ret = nilfs_dat_prepare_update(dat, &oldreq, &newreq); |
280 | if (ret < 0) |
281 | return ret; |
282 | nilfs_dat_commit_update(dat, &oldreq, &newreq, |
283 | bmap->b_ptr_type == NILFS_BMAP_PTR_VS); |
284 | set_buffer_nilfs_volatile(bh); |
285 | nilfs_direct_set_ptr(direct: bmap, key, ptr: newreq.pr_entry_nr); |
286 | } else |
287 | ret = nilfs_dat_mark_dirty(dat, ptr); |
288 | |
289 | return ret; |
290 | } |
291 | |
292 | static int nilfs_direct_assign_v(struct nilfs_bmap *direct, |
293 | __u64 key, __u64 ptr, |
294 | struct buffer_head **bh, |
295 | sector_t blocknr, |
296 | union nilfs_binfo *binfo) |
297 | { |
298 | struct inode *dat = nilfs_bmap_get_dat(direct); |
299 | union nilfs_bmap_ptr_req req; |
300 | int ret; |
301 | |
302 | req.bpr_ptr = ptr; |
303 | ret = nilfs_dat_prepare_start(dat, &req.bpr_req); |
304 | if (!ret) { |
305 | nilfs_dat_commit_start(dat, &req.bpr_req, blocknr); |
306 | binfo->bi_v.bi_vblocknr = cpu_to_le64(ptr); |
307 | binfo->bi_v.bi_blkoff = cpu_to_le64(key); |
308 | } |
309 | return ret; |
310 | } |
311 | |
312 | static int nilfs_direct_assign_p(struct nilfs_bmap *direct, |
313 | __u64 key, __u64 ptr, |
314 | struct buffer_head **bh, |
315 | sector_t blocknr, |
316 | union nilfs_binfo *binfo) |
317 | { |
318 | nilfs_direct_set_ptr(direct, key, ptr: blocknr); |
319 | |
320 | binfo->bi_dat.bi_blkoff = cpu_to_le64(key); |
321 | binfo->bi_dat.bi_level = 0; |
322 | memset(binfo->bi_dat.bi_pad, 0, sizeof(binfo->bi_dat.bi_pad)); |
323 | |
324 | return 0; |
325 | } |
326 | |
327 | static int nilfs_direct_assign(struct nilfs_bmap *bmap, |
328 | struct buffer_head **bh, |
329 | sector_t blocknr, |
330 | union nilfs_binfo *binfo) |
331 | { |
332 | __u64 key; |
333 | __u64 ptr; |
334 | |
335 | key = nilfs_bmap_data_get_key(bmap, *bh); |
336 | if (unlikely(key > NILFS_DIRECT_KEY_MAX)) { |
337 | nilfs_crit(bmap->b_inode->i_sb, |
338 | "%s (ino=%lu): invalid key: %llu" , |
339 | __func__, |
340 | bmap->b_inode->i_ino, (unsigned long long)key); |
341 | return -EINVAL; |
342 | } |
343 | ptr = nilfs_direct_get_ptr(direct: bmap, key); |
344 | if (unlikely(ptr == NILFS_BMAP_INVALID_PTR)) { |
345 | nilfs_crit(bmap->b_inode->i_sb, |
346 | "%s (ino=%lu): invalid pointer: %llu" , |
347 | __func__, |
348 | bmap->b_inode->i_ino, (unsigned long long)ptr); |
349 | return -EINVAL; |
350 | } |
351 | |
352 | return NILFS_BMAP_USE_VBN(bmap) ? |
353 | nilfs_direct_assign_v(direct: bmap, key, ptr, bh, blocknr, binfo) : |
354 | nilfs_direct_assign_p(direct: bmap, key, ptr, bh, blocknr, binfo); |
355 | } |
356 | |
357 | static const struct nilfs_bmap_operations nilfs_direct_ops = { |
358 | .bop_lookup = nilfs_direct_lookup, |
359 | .bop_lookup_contig = nilfs_direct_lookup_contig, |
360 | .bop_insert = nilfs_direct_insert, |
361 | .bop_delete = nilfs_direct_delete, |
362 | .bop_clear = NULL, |
363 | |
364 | .bop_propagate = nilfs_direct_propagate, |
365 | |
366 | .bop_lookup_dirty_buffers = NULL, |
367 | |
368 | .bop_assign = nilfs_direct_assign, |
369 | .bop_mark = NULL, |
370 | |
371 | .bop_seek_key = nilfs_direct_seek_key, |
372 | .bop_last_key = nilfs_direct_last_key, |
373 | |
374 | .bop_check_insert = nilfs_direct_check_insert, |
375 | .bop_check_delete = NULL, |
376 | .bop_gather_data = nilfs_direct_gather_data, |
377 | }; |
378 | |
379 | |
380 | int nilfs_direct_init(struct nilfs_bmap *bmap) |
381 | { |
382 | bmap->b_ops = &nilfs_direct_ops; |
383 | return 0; |
384 | } |
385 | |