1 | // SPDX-License-Identifier: GPL-2.0+ |
2 | /* |
3 | * NILFS block mapping. |
4 | * |
5 | * Copyright (C) 2006-2008 Nippon Telegraph and Telephone Corporation. |
6 | * |
7 | * Written by Koji Sato. |
8 | */ |
9 | |
10 | #include <linux/fs.h> |
11 | #include <linux/string.h> |
12 | #include <linux/errno.h> |
13 | #include "nilfs.h" |
14 | #include "bmap.h" |
15 | #include "btree.h" |
16 | #include "direct.h" |
17 | #include "btnode.h" |
18 | #include "mdt.h" |
19 | #include "dat.h" |
20 | #include "alloc.h" |
21 | |
22 | struct inode *nilfs_bmap_get_dat(const struct nilfs_bmap *bmap) |
23 | { |
24 | struct the_nilfs *nilfs = bmap->b_inode->i_sb->s_fs_info; |
25 | |
26 | return nilfs->ns_dat; |
27 | } |
28 | |
29 | static int nilfs_bmap_convert_error(struct nilfs_bmap *bmap, |
30 | const char *fname, int err) |
31 | { |
32 | struct inode *inode = bmap->b_inode; |
33 | |
34 | if (err == -EINVAL) { |
35 | __nilfs_error(sb: inode->i_sb, function: fname, |
36 | fmt: "broken bmap (inode number=%lu)" , inode->i_ino); |
37 | err = -EIO; |
38 | } |
39 | return err; |
40 | } |
41 | |
42 | /** |
43 | * nilfs_bmap_lookup_at_level - find a data block or node block |
44 | * @bmap: bmap |
45 | * @key: key |
46 | * @level: level |
47 | * @ptrp: place to store the value associated to @key |
48 | * |
49 | * Description: nilfs_bmap_lookup_at_level() finds a record whose key |
50 | * matches @key in the block at @level of the bmap. |
51 | * |
52 | * Return Value: On success, 0 is returned and the record associated with @key |
53 | * is stored in the place pointed by @ptrp. On error, one of the following |
54 | * negative error codes is returned. |
55 | * |
56 | * %-EIO - I/O error. |
57 | * |
58 | * %-ENOMEM - Insufficient amount of memory available. |
59 | * |
60 | * %-ENOENT - A record associated with @key does not exist. |
61 | */ |
62 | int nilfs_bmap_lookup_at_level(struct nilfs_bmap *bmap, __u64 key, int level, |
63 | __u64 *ptrp) |
64 | { |
65 | sector_t blocknr; |
66 | int ret; |
67 | |
68 | down_read(sem: &bmap->b_sem); |
69 | ret = bmap->b_ops->bop_lookup(bmap, key, level, ptrp); |
70 | if (ret < 0) |
71 | goto out; |
72 | |
73 | if (NILFS_BMAP_USE_VBN(bmap)) { |
74 | ret = nilfs_dat_translate(nilfs_bmap_get_dat(bmap), *ptrp, |
75 | &blocknr); |
76 | if (!ret) |
77 | *ptrp = blocknr; |
78 | else if (ret == -ENOENT) { |
79 | /* |
80 | * If there was no valid entry in DAT for the block |
81 | * address obtained by b_ops->bop_lookup, then pass |
82 | * internal code -EINVAL to nilfs_bmap_convert_error |
83 | * to treat it as metadata corruption. |
84 | */ |
85 | ret = -EINVAL; |
86 | } |
87 | } |
88 | |
89 | out: |
90 | up_read(sem: &bmap->b_sem); |
91 | return nilfs_bmap_convert_error(bmap, fname: __func__, err: ret); |
92 | } |
93 | |
94 | int nilfs_bmap_lookup_contig(struct nilfs_bmap *bmap, __u64 key, __u64 *ptrp, |
95 | unsigned int maxblocks) |
96 | { |
97 | int ret; |
98 | |
99 | down_read(sem: &bmap->b_sem); |
100 | ret = bmap->b_ops->bop_lookup_contig(bmap, key, ptrp, maxblocks); |
101 | up_read(sem: &bmap->b_sem); |
102 | |
103 | return nilfs_bmap_convert_error(bmap, fname: __func__, err: ret); |
104 | } |
105 | |
106 | static int nilfs_bmap_do_insert(struct nilfs_bmap *bmap, __u64 key, __u64 ptr) |
107 | { |
108 | __u64 keys[NILFS_BMAP_SMALL_HIGH + 1]; |
109 | __u64 ptrs[NILFS_BMAP_SMALL_HIGH + 1]; |
110 | int ret, n; |
111 | |
112 | if (bmap->b_ops->bop_check_insert != NULL) { |
113 | ret = bmap->b_ops->bop_check_insert(bmap, key); |
114 | if (ret > 0) { |
115 | n = bmap->b_ops->bop_gather_data( |
116 | bmap, keys, ptrs, NILFS_BMAP_SMALL_HIGH + 1); |
117 | if (n < 0) |
118 | return n; |
119 | ret = nilfs_btree_convert_and_insert( |
120 | bmap, key, ptr, keys, ptrs, n); |
121 | if (ret == 0) |
122 | bmap->b_u.u_flags |= NILFS_BMAP_LARGE; |
123 | |
124 | return ret; |
125 | } else if (ret < 0) |
126 | return ret; |
127 | } |
128 | |
129 | return bmap->b_ops->bop_insert(bmap, key, ptr); |
130 | } |
131 | |
132 | /** |
133 | * nilfs_bmap_insert - insert a new key-record pair into a bmap |
134 | * @bmap: bmap |
135 | * @key: key |
136 | * @rec: record |
137 | * |
138 | * Description: nilfs_bmap_insert() inserts the new key-record pair specified |
139 | * by @key and @rec into @bmap. |
140 | * |
141 | * Return Value: On success, 0 is returned. On error, one of the following |
142 | * negative error codes is returned. |
143 | * |
144 | * %-EIO - I/O error. |
145 | * |
146 | * %-ENOMEM - Insufficient amount of memory available. |
147 | * |
148 | * %-EEXIST - A record associated with @key already exist. |
149 | */ |
150 | int nilfs_bmap_insert(struct nilfs_bmap *bmap, __u64 key, unsigned long rec) |
151 | { |
152 | int ret; |
153 | |
154 | down_write(sem: &bmap->b_sem); |
155 | ret = nilfs_bmap_do_insert(bmap, key, ptr: rec); |
156 | up_write(sem: &bmap->b_sem); |
157 | |
158 | return nilfs_bmap_convert_error(bmap, fname: __func__, err: ret); |
159 | } |
160 | |
161 | static int nilfs_bmap_do_delete(struct nilfs_bmap *bmap, __u64 key) |
162 | { |
163 | __u64 keys[NILFS_BMAP_LARGE_LOW + 1]; |
164 | __u64 ptrs[NILFS_BMAP_LARGE_LOW + 1]; |
165 | int ret, n; |
166 | |
167 | if (bmap->b_ops->bop_check_delete != NULL) { |
168 | ret = bmap->b_ops->bop_check_delete(bmap, key); |
169 | if (ret > 0) { |
170 | n = bmap->b_ops->bop_gather_data( |
171 | bmap, keys, ptrs, NILFS_BMAP_LARGE_LOW + 1); |
172 | if (n < 0) |
173 | return n; |
174 | ret = nilfs_direct_delete_and_convert( |
175 | bmap, key, keys, ptrs, n); |
176 | if (ret == 0) |
177 | bmap->b_u.u_flags &= ~NILFS_BMAP_LARGE; |
178 | |
179 | return ret; |
180 | } else if (ret < 0) |
181 | return ret; |
182 | } |
183 | |
184 | return bmap->b_ops->bop_delete(bmap, key); |
185 | } |
186 | |
187 | /** |
188 | * nilfs_bmap_seek_key - seek a valid entry and return its key |
189 | * @bmap: bmap struct |
190 | * @start: start key number |
191 | * @keyp: place to store valid key |
192 | * |
193 | * Description: nilfs_bmap_seek_key() seeks a valid key on @bmap |
194 | * starting from @start, and stores it to @keyp if found. |
195 | * |
196 | * Return Value: On success, 0 is returned. On error, one of the following |
197 | * negative error codes is returned. |
198 | * |
199 | * %-EIO - I/O error. |
200 | * |
201 | * %-ENOMEM - Insufficient amount of memory available. |
202 | * |
203 | * %-ENOENT - No valid entry was found |
204 | */ |
205 | int nilfs_bmap_seek_key(struct nilfs_bmap *bmap, __u64 start, __u64 *keyp) |
206 | { |
207 | int ret; |
208 | |
209 | down_read(sem: &bmap->b_sem); |
210 | ret = bmap->b_ops->bop_seek_key(bmap, start, keyp); |
211 | up_read(sem: &bmap->b_sem); |
212 | |
213 | if (ret < 0) |
214 | ret = nilfs_bmap_convert_error(bmap, fname: __func__, err: ret); |
215 | return ret; |
216 | } |
217 | |
218 | int nilfs_bmap_last_key(struct nilfs_bmap *bmap, __u64 *keyp) |
219 | { |
220 | int ret; |
221 | |
222 | down_read(sem: &bmap->b_sem); |
223 | ret = bmap->b_ops->bop_last_key(bmap, keyp); |
224 | up_read(sem: &bmap->b_sem); |
225 | |
226 | if (ret < 0) |
227 | ret = nilfs_bmap_convert_error(bmap, fname: __func__, err: ret); |
228 | return ret; |
229 | } |
230 | |
231 | /** |
232 | * nilfs_bmap_delete - delete a key-record pair from a bmap |
233 | * @bmap: bmap |
234 | * @key: key |
235 | * |
236 | * Description: nilfs_bmap_delete() deletes the key-record pair specified by |
237 | * @key from @bmap. |
238 | * |
239 | * Return Value: On success, 0 is returned. On error, one of the following |
240 | * negative error codes is returned. |
241 | * |
242 | * %-EIO - I/O error. |
243 | * |
244 | * %-ENOMEM - Insufficient amount of memory available. |
245 | * |
246 | * %-ENOENT - A record associated with @key does not exist. |
247 | */ |
248 | int nilfs_bmap_delete(struct nilfs_bmap *bmap, __u64 key) |
249 | { |
250 | int ret; |
251 | |
252 | down_write(sem: &bmap->b_sem); |
253 | ret = nilfs_bmap_do_delete(bmap, key); |
254 | up_write(sem: &bmap->b_sem); |
255 | |
256 | return nilfs_bmap_convert_error(bmap, fname: __func__, err: ret); |
257 | } |
258 | |
259 | static int nilfs_bmap_do_truncate(struct nilfs_bmap *bmap, __u64 key) |
260 | { |
261 | __u64 lastkey; |
262 | int ret; |
263 | |
264 | ret = bmap->b_ops->bop_last_key(bmap, &lastkey); |
265 | if (ret < 0) { |
266 | if (ret == -ENOENT) |
267 | ret = 0; |
268 | return ret; |
269 | } |
270 | |
271 | while (key <= lastkey) { |
272 | ret = nilfs_bmap_do_delete(bmap, key: lastkey); |
273 | if (ret < 0) |
274 | return ret; |
275 | ret = bmap->b_ops->bop_last_key(bmap, &lastkey); |
276 | if (ret < 0) { |
277 | if (ret == -ENOENT) |
278 | ret = 0; |
279 | return ret; |
280 | } |
281 | } |
282 | return 0; |
283 | } |
284 | |
285 | /** |
286 | * nilfs_bmap_truncate - truncate a bmap to a specified key |
287 | * @bmap: bmap |
288 | * @key: key |
289 | * |
290 | * Description: nilfs_bmap_truncate() removes key-record pairs whose keys are |
291 | * greater than or equal to @key from @bmap. |
292 | * |
293 | * Return Value: On success, 0 is returned. On error, one of the following |
294 | * negative error codes is returned. |
295 | * |
296 | * %-EIO - I/O error. |
297 | * |
298 | * %-ENOMEM - Insufficient amount of memory available. |
299 | */ |
300 | int nilfs_bmap_truncate(struct nilfs_bmap *bmap, __u64 key) |
301 | { |
302 | int ret; |
303 | |
304 | down_write(sem: &bmap->b_sem); |
305 | ret = nilfs_bmap_do_truncate(bmap, key); |
306 | up_write(sem: &bmap->b_sem); |
307 | |
308 | return nilfs_bmap_convert_error(bmap, fname: __func__, err: ret); |
309 | } |
310 | |
311 | /** |
312 | * nilfs_bmap_clear - free resources a bmap holds |
313 | * @bmap: bmap |
314 | * |
315 | * Description: nilfs_bmap_clear() frees resources associated with @bmap. |
316 | */ |
317 | void nilfs_bmap_clear(struct nilfs_bmap *bmap) |
318 | { |
319 | down_write(sem: &bmap->b_sem); |
320 | if (bmap->b_ops->bop_clear != NULL) |
321 | bmap->b_ops->bop_clear(bmap); |
322 | up_write(sem: &bmap->b_sem); |
323 | } |
324 | |
325 | /** |
326 | * nilfs_bmap_propagate - propagate dirty state |
327 | * @bmap: bmap |
328 | * @bh: buffer head |
329 | * |
330 | * Description: nilfs_bmap_propagate() marks the buffers that directly or |
331 | * indirectly refer to the block specified by @bh dirty. |
332 | * |
333 | * Return Value: On success, 0 is returned. On error, one of the following |
334 | * negative error codes is returned. |
335 | * |
336 | * %-EIO - I/O error. |
337 | * |
338 | * %-ENOMEM - Insufficient amount of memory available. |
339 | */ |
340 | int nilfs_bmap_propagate(struct nilfs_bmap *bmap, struct buffer_head *bh) |
341 | { |
342 | int ret; |
343 | |
344 | down_write(sem: &bmap->b_sem); |
345 | ret = bmap->b_ops->bop_propagate(bmap, bh); |
346 | up_write(sem: &bmap->b_sem); |
347 | |
348 | return nilfs_bmap_convert_error(bmap, fname: __func__, err: ret); |
349 | } |
350 | |
351 | /** |
352 | * nilfs_bmap_lookup_dirty_buffers - |
353 | * @bmap: bmap |
354 | * @listp: pointer to buffer head list |
355 | */ |
356 | void nilfs_bmap_lookup_dirty_buffers(struct nilfs_bmap *bmap, |
357 | struct list_head *listp) |
358 | { |
359 | if (bmap->b_ops->bop_lookup_dirty_buffers != NULL) |
360 | bmap->b_ops->bop_lookup_dirty_buffers(bmap, listp); |
361 | } |
362 | |
363 | /** |
364 | * nilfs_bmap_assign - assign a new block number to a block |
365 | * @bmap: bmap |
366 | * @bh: pointer to buffer head |
367 | * @blocknr: block number |
368 | * @binfo: block information |
369 | * |
370 | * Description: nilfs_bmap_assign() assigns the block number @blocknr to the |
371 | * buffer specified by @bh. |
372 | * |
373 | * Return Value: On success, 0 is returned and the buffer head of a newly |
374 | * create buffer and the block information associated with the buffer are |
375 | * stored in the place pointed by @bh and @binfo, respectively. On error, one |
376 | * of the following negative error codes is returned. |
377 | * |
378 | * %-EIO - I/O error. |
379 | * |
380 | * %-ENOMEM - Insufficient amount of memory available. |
381 | */ |
382 | int nilfs_bmap_assign(struct nilfs_bmap *bmap, |
383 | struct buffer_head **bh, |
384 | unsigned long blocknr, |
385 | union nilfs_binfo *binfo) |
386 | { |
387 | int ret; |
388 | |
389 | down_write(sem: &bmap->b_sem); |
390 | ret = bmap->b_ops->bop_assign(bmap, bh, blocknr, binfo); |
391 | up_write(sem: &bmap->b_sem); |
392 | |
393 | return nilfs_bmap_convert_error(bmap, fname: __func__, err: ret); |
394 | } |
395 | |
396 | /** |
397 | * nilfs_bmap_mark - mark block dirty |
398 | * @bmap: bmap |
399 | * @key: key |
400 | * @level: level |
401 | * |
402 | * Description: nilfs_bmap_mark() marks the block specified by @key and @level |
403 | * as dirty. |
404 | * |
405 | * Return Value: On success, 0 is returned. On error, one of the following |
406 | * negative error codes is returned. |
407 | * |
408 | * %-EIO - I/O error. |
409 | * |
410 | * %-ENOMEM - Insufficient amount of memory available. |
411 | */ |
412 | int nilfs_bmap_mark(struct nilfs_bmap *bmap, __u64 key, int level) |
413 | { |
414 | int ret; |
415 | |
416 | if (bmap->b_ops->bop_mark == NULL) |
417 | return 0; |
418 | |
419 | down_write(sem: &bmap->b_sem); |
420 | ret = bmap->b_ops->bop_mark(bmap, key, level); |
421 | up_write(sem: &bmap->b_sem); |
422 | |
423 | return nilfs_bmap_convert_error(bmap, fname: __func__, err: ret); |
424 | } |
425 | |
426 | /** |
427 | * nilfs_bmap_test_and_clear_dirty - test and clear a bmap dirty state |
428 | * @bmap: bmap |
429 | * |
430 | * Description: nilfs_test_and_clear() is the atomic operation to test and |
431 | * clear the dirty state of @bmap. |
432 | * |
433 | * Return Value: 1 is returned if @bmap is dirty, or 0 if clear. |
434 | */ |
435 | int nilfs_bmap_test_and_clear_dirty(struct nilfs_bmap *bmap) |
436 | { |
437 | int ret; |
438 | |
439 | down_write(sem: &bmap->b_sem); |
440 | ret = nilfs_bmap_dirty(bmap); |
441 | nilfs_bmap_clear_dirty(bmap); |
442 | up_write(sem: &bmap->b_sem); |
443 | return ret; |
444 | } |
445 | |
446 | |
447 | /* |
448 | * Internal use only |
449 | */ |
450 | __u64 nilfs_bmap_data_get_key(const struct nilfs_bmap *bmap, |
451 | const struct buffer_head *bh) |
452 | { |
453 | struct buffer_head *pbh; |
454 | __u64 key; |
455 | |
456 | key = page_index(page: bh->b_page) << (PAGE_SHIFT - |
457 | bmap->b_inode->i_blkbits); |
458 | for (pbh = page_buffers(bh->b_page); pbh != bh; pbh = pbh->b_this_page) |
459 | key++; |
460 | |
461 | return key; |
462 | } |
463 | |
464 | __u64 nilfs_bmap_find_target_seq(const struct nilfs_bmap *bmap, __u64 key) |
465 | { |
466 | __s64 diff; |
467 | |
468 | diff = key - bmap->b_last_allocated_key; |
469 | if ((nilfs_bmap_keydiff_abs(diff) < NILFS_INODE_BMAP_SIZE) && |
470 | (bmap->b_last_allocated_ptr != NILFS_BMAP_INVALID_PTR) && |
471 | (bmap->b_last_allocated_ptr + diff > 0)) |
472 | return bmap->b_last_allocated_ptr + diff; |
473 | else |
474 | return NILFS_BMAP_INVALID_PTR; |
475 | } |
476 | |
477 | #define NILFS_BMAP_GROUP_DIV 8 |
478 | __u64 nilfs_bmap_find_target_in_group(const struct nilfs_bmap *bmap) |
479 | { |
480 | struct inode *dat = nilfs_bmap_get_dat(bmap); |
481 | unsigned long entries_per_group = nilfs_palloc_entries_per_group(inode: dat); |
482 | unsigned long group = bmap->b_inode->i_ino / entries_per_group; |
483 | |
484 | return group * entries_per_group + |
485 | (bmap->b_inode->i_ino % NILFS_BMAP_GROUP_DIV) * |
486 | (entries_per_group / NILFS_BMAP_GROUP_DIV); |
487 | } |
488 | |
489 | static struct lock_class_key nilfs_bmap_dat_lock_key; |
490 | static struct lock_class_key nilfs_bmap_mdt_lock_key; |
491 | |
492 | /** |
493 | * nilfs_bmap_read - read a bmap from an inode |
494 | * @bmap: bmap |
495 | * @raw_inode: on-disk inode |
496 | * |
497 | * Description: nilfs_bmap_read() initializes the bmap @bmap. |
498 | * |
499 | * Return Value: On success, 0 is returned. On error, the following negative |
500 | * error code is returned. |
501 | * |
502 | * %-ENOMEM - Insufficient amount of memory available. |
503 | */ |
504 | int nilfs_bmap_read(struct nilfs_bmap *bmap, struct nilfs_inode *raw_inode) |
505 | { |
506 | if (raw_inode == NULL) |
507 | memset(bmap->b_u.u_data, 0, NILFS_BMAP_SIZE); |
508 | else |
509 | memcpy(bmap->b_u.u_data, raw_inode->i_bmap, NILFS_BMAP_SIZE); |
510 | |
511 | init_rwsem(&bmap->b_sem); |
512 | bmap->b_state = 0; |
513 | bmap->b_inode = &NILFS_BMAP_I(bmap)->vfs_inode; |
514 | switch (bmap->b_inode->i_ino) { |
515 | case NILFS_DAT_INO: |
516 | bmap->b_ptr_type = NILFS_BMAP_PTR_P; |
517 | bmap->b_last_allocated_key = 0; |
518 | bmap->b_last_allocated_ptr = NILFS_BMAP_NEW_PTR_INIT; |
519 | lockdep_set_class(&bmap->b_sem, &nilfs_bmap_dat_lock_key); |
520 | break; |
521 | case NILFS_CPFILE_INO: |
522 | case NILFS_SUFILE_INO: |
523 | bmap->b_ptr_type = NILFS_BMAP_PTR_VS; |
524 | bmap->b_last_allocated_key = 0; |
525 | bmap->b_last_allocated_ptr = NILFS_BMAP_INVALID_PTR; |
526 | lockdep_set_class(&bmap->b_sem, &nilfs_bmap_mdt_lock_key); |
527 | break; |
528 | case NILFS_IFILE_INO: |
529 | lockdep_set_class(&bmap->b_sem, &nilfs_bmap_mdt_lock_key); |
530 | fallthrough; |
531 | default: |
532 | bmap->b_ptr_type = NILFS_BMAP_PTR_VM; |
533 | bmap->b_last_allocated_key = 0; |
534 | bmap->b_last_allocated_ptr = NILFS_BMAP_INVALID_PTR; |
535 | break; |
536 | } |
537 | |
538 | return (bmap->b_u.u_flags & NILFS_BMAP_LARGE) ? |
539 | nilfs_btree_init(bmap) : nilfs_direct_init(bmap); |
540 | } |
541 | |
542 | /** |
543 | * nilfs_bmap_write - write back a bmap to an inode |
544 | * @bmap: bmap |
545 | * @raw_inode: on-disk inode |
546 | * |
547 | * Description: nilfs_bmap_write() stores @bmap in @raw_inode. |
548 | */ |
549 | void nilfs_bmap_write(struct nilfs_bmap *bmap, struct nilfs_inode *raw_inode) |
550 | { |
551 | memcpy(raw_inode->i_bmap, bmap->b_u.u_data, |
552 | NILFS_INODE_BMAP_SIZE * sizeof(__le64)); |
553 | if (bmap->b_inode->i_ino == NILFS_DAT_INO) |
554 | bmap->b_last_allocated_ptr = NILFS_BMAP_NEW_PTR_INIT; |
555 | } |
556 | |
557 | void nilfs_bmap_init_gc(struct nilfs_bmap *bmap) |
558 | { |
559 | memset(&bmap->b_u, 0, NILFS_BMAP_SIZE); |
560 | init_rwsem(&bmap->b_sem); |
561 | bmap->b_inode = &NILFS_BMAP_I(bmap)->vfs_inode; |
562 | bmap->b_ptr_type = NILFS_BMAP_PTR_U; |
563 | bmap->b_last_allocated_key = 0; |
564 | bmap->b_last_allocated_ptr = NILFS_BMAP_INVALID_PTR; |
565 | bmap->b_state = 0; |
566 | nilfs_btree_init_gc(bmap); |
567 | } |
568 | |
569 | void nilfs_bmap_save(const struct nilfs_bmap *bmap, |
570 | struct nilfs_bmap_store *store) |
571 | { |
572 | memcpy(store->data, bmap->b_u.u_data, sizeof(store->data)); |
573 | store->last_allocated_key = bmap->b_last_allocated_key; |
574 | store->last_allocated_ptr = bmap->b_last_allocated_ptr; |
575 | store->state = bmap->b_state; |
576 | } |
577 | |
578 | void nilfs_bmap_restore(struct nilfs_bmap *bmap, |
579 | const struct nilfs_bmap_store *store) |
580 | { |
581 | memcpy(bmap->b_u.u_data, store->data, sizeof(store->data)); |
582 | bmap->b_last_allocated_key = store->last_allocated_key; |
583 | bmap->b_last_allocated_ptr = store->last_allocated_ptr; |
584 | bmap->b_state = store->state; |
585 | } |
586 | |