1 /* 2 * bmap.c - NILFS block mapping. 3 * 4 * Copyright (C) 2006-2008 Nippon Telegraph and Telephone Corporation. 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License as published by 8 * the Free Software Foundation; either version 2 of the License, or 9 * (at your option) any later version. 10 * 11 * This program is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 * GNU General Public License for more details. 15 * 16 * You should have received a copy of the GNU General Public License 17 * along with this program; if not, write to the Free Software 18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA 19 * 20 * Written by Koji Sato <koji@osrg.net>. 21 */ 22 23 #include <linux/fs.h> 24 #include <linux/string.h> 25 #include <linux/errno.h> 26 #include "nilfs.h" 27 #include "bmap.h" 28 #include "sb.h" 29 #include "btnode.h" 30 #include "mdt.h" 31 #include "dat.h" 32 #include "alloc.h" 33 34 int nilfs_bmap_lookup_at_level(struct nilfs_bmap *bmap, __u64 key, int level, 35 __u64 *ptrp) 36 { 37 __u64 ptr; 38 int ret; 39 40 down_read(&bmap->b_sem); 41 ret = bmap->b_ops->bop_lookup(bmap, key, level, ptrp); 42 if (ret < 0) 43 goto out; 44 if (bmap->b_pops->bpop_translate != NULL) { 45 ret = bmap->b_pops->bpop_translate(bmap, *ptrp, &ptr); 46 if (ret < 0) 47 goto out; 48 *ptrp = ptr; 49 } 50 51 out: 52 up_read(&bmap->b_sem); 53 return ret; 54 } 55 56 57 /** 58 * nilfs_bmap_lookup - find a record 59 * @bmap: bmap 60 * @key: key 61 * @recp: pointer to record 62 * 63 * Description: nilfs_bmap_lookup() finds a record whose key matches @key in 64 * @bmap. 65 * 66 * Return Value: On success, 0 is returned and the record associated with @key 67 * is stored in the place pointed by @recp. On error, one of the following 68 * negative error codes is returned. 69 * 70 * %-EIO - I/O error. 71 * 72 * %-ENOMEM - Insufficient amount of memory available. 73 * 74 * %-ENOENT - A record associated with @key does not exist. 75 */ 76 int nilfs_bmap_lookup(struct nilfs_bmap *bmap, 77 unsigned long key, 78 unsigned long *recp) 79 { 80 __u64 ptr; 81 int ret; 82 83 /* XXX: use macro for level 1 */ 84 ret = nilfs_bmap_lookup_at_level(bmap, key, 1, &ptr); 85 if (recp != NULL) 86 *recp = ptr; 87 return ret; 88 } 89 90 static int nilfs_bmap_do_insert(struct nilfs_bmap *bmap, __u64 key, __u64 ptr) 91 { 92 __u64 keys[NILFS_BMAP_SMALL_HIGH + 1]; 93 __u64 ptrs[NILFS_BMAP_SMALL_HIGH + 1]; 94 int ret, n; 95 96 if (bmap->b_ops->bop_check_insert != NULL) { 97 ret = bmap->b_ops->bop_check_insert(bmap, key); 98 if (ret > 0) { 99 n = bmap->b_ops->bop_gather_data( 100 bmap, keys, ptrs, NILFS_BMAP_SMALL_HIGH + 1); 101 if (n < 0) 102 return n; 103 ret = nilfs_btree_convert_and_insert( 104 bmap, key, ptr, keys, ptrs, n, 105 NILFS_BMAP_LARGE_LOW, NILFS_BMAP_LARGE_HIGH); 106 if (ret == 0) 107 bmap->b_u.u_flags |= NILFS_BMAP_LARGE; 108 109 return ret; 110 } else if (ret < 0) 111 return ret; 112 } 113 114 return bmap->b_ops->bop_insert(bmap, key, ptr); 115 } 116 117 /** 118 * nilfs_bmap_insert - insert a new key-record pair into a bmap 119 * @bmap: bmap 120 * @key: key 121 * @rec: record 122 * 123 * Description: nilfs_bmap_insert() inserts the new key-record pair specified 124 * by @key and @rec into @bmap. 125 * 126 * Return Value: On success, 0 is returned. On error, one of the following 127 * negative error codes is returned. 128 * 129 * %-EIO - I/O error. 130 * 131 * %-ENOMEM - Insufficient amount of memory available. 132 * 133 * %-EEXIST - A record associated with @key already exist. 134 */ 135 int nilfs_bmap_insert(struct nilfs_bmap *bmap, 136 unsigned long key, 137 unsigned long rec) 138 { 139 int ret; 140 141 down_write(&bmap->b_sem); 142 ret = nilfs_bmap_do_insert(bmap, key, rec); 143 up_write(&bmap->b_sem); 144 return ret; 145 } 146 147 static int nilfs_bmap_do_delete(struct nilfs_bmap *bmap, __u64 key) 148 { 149 __u64 keys[NILFS_BMAP_LARGE_LOW + 1]; 150 __u64 ptrs[NILFS_BMAP_LARGE_LOW + 1]; 151 int ret, n; 152 153 if (bmap->b_ops->bop_check_delete != NULL) { 154 ret = bmap->b_ops->bop_check_delete(bmap, key); 155 if (ret > 0) { 156 n = bmap->b_ops->bop_gather_data( 157 bmap, keys, ptrs, NILFS_BMAP_LARGE_LOW + 1); 158 if (n < 0) 159 return n; 160 ret = nilfs_direct_delete_and_convert( 161 bmap, key, keys, ptrs, n, 162 NILFS_BMAP_SMALL_LOW, NILFS_BMAP_SMALL_HIGH); 163 if (ret == 0) 164 bmap->b_u.u_flags &= ~NILFS_BMAP_LARGE; 165 166 return ret; 167 } else if (ret < 0) 168 return ret; 169 } 170 171 return bmap->b_ops->bop_delete(bmap, key); 172 } 173 174 int nilfs_bmap_last_key(struct nilfs_bmap *bmap, unsigned long *key) 175 { 176 __u64 lastkey; 177 int ret; 178 179 down_read(&bmap->b_sem); 180 ret = bmap->b_ops->bop_last_key(bmap, &lastkey); 181 if (!ret) 182 *key = lastkey; 183 up_read(&bmap->b_sem); 184 return ret; 185 } 186 187 /** 188 * nilfs_bmap_delete - delete a key-record pair from a bmap 189 * @bmap: bmap 190 * @key: key 191 * 192 * Description: nilfs_bmap_delete() deletes the key-record pair specified by 193 * @key from @bmap. 194 * 195 * Return Value: On success, 0 is returned. On error, one of the following 196 * negative error codes is returned. 197 * 198 * %-EIO - I/O error. 199 * 200 * %-ENOMEM - Insufficient amount of memory available. 201 * 202 * %-ENOENT - A record associated with @key does not exist. 203 */ 204 int nilfs_bmap_delete(struct nilfs_bmap *bmap, unsigned long key) 205 { 206 int ret; 207 208 down_write(&bmap->b_sem); 209 ret = nilfs_bmap_do_delete(bmap, key); 210 up_write(&bmap->b_sem); 211 return ret; 212 } 213 214 static int nilfs_bmap_do_truncate(struct nilfs_bmap *bmap, unsigned long key) 215 { 216 __u64 lastkey; 217 int ret; 218 219 ret = bmap->b_ops->bop_last_key(bmap, &lastkey); 220 if (ret < 0) { 221 if (ret == -ENOENT) 222 ret = 0; 223 return ret; 224 } 225 226 while (key <= lastkey) { 227 ret = nilfs_bmap_do_delete(bmap, lastkey); 228 if (ret < 0) 229 return ret; 230 ret = bmap->b_ops->bop_last_key(bmap, &lastkey); 231 if (ret < 0) { 232 if (ret == -ENOENT) 233 ret = 0; 234 return ret; 235 } 236 } 237 return 0; 238 } 239 240 /** 241 * nilfs_bmap_truncate - truncate a bmap to a specified key 242 * @bmap: bmap 243 * @key: key 244 * 245 * Description: nilfs_bmap_truncate() removes key-record pairs whose keys are 246 * greater than or equal to @key from @bmap. 247 * 248 * Return Value: On success, 0 is returned. On error, one of the following 249 * negative error codes is returned. 250 * 251 * %-EIO - I/O error. 252 * 253 * %-ENOMEM - Insufficient amount of memory available. 254 */ 255 int nilfs_bmap_truncate(struct nilfs_bmap *bmap, unsigned long key) 256 { 257 int ret; 258 259 down_write(&bmap->b_sem); 260 ret = nilfs_bmap_do_truncate(bmap, key); 261 up_write(&bmap->b_sem); 262 return ret; 263 } 264 265 /** 266 * nilfs_bmap_clear - free resources a bmap holds 267 * @bmap: bmap 268 * 269 * Description: nilfs_bmap_clear() frees resources associated with @bmap. 270 */ 271 void nilfs_bmap_clear(struct nilfs_bmap *bmap) 272 { 273 down_write(&bmap->b_sem); 274 if (bmap->b_ops->bop_clear != NULL) 275 bmap->b_ops->bop_clear(bmap); 276 up_write(&bmap->b_sem); 277 } 278 279 /** 280 * nilfs_bmap_propagate - propagate dirty state 281 * @bmap: bmap 282 * @bh: buffer head 283 * 284 * Description: nilfs_bmap_propagate() marks the buffers that directly or 285 * indirectly refer to the block specified by @bh dirty. 286 * 287 * Return Value: On success, 0 is returned. On error, one of the following 288 * negative error codes is returned. 289 * 290 * %-EIO - I/O error. 291 * 292 * %-ENOMEM - Insufficient amount of memory available. 293 */ 294 int nilfs_bmap_propagate(struct nilfs_bmap *bmap, struct buffer_head *bh) 295 { 296 int ret; 297 298 down_write(&bmap->b_sem); 299 ret = bmap->b_ops->bop_propagate(bmap, bh); 300 up_write(&bmap->b_sem); 301 return ret; 302 } 303 304 /** 305 * nilfs_bmap_lookup_dirty_buffers - 306 * @bmap: bmap 307 * @listp: pointer to buffer head list 308 */ 309 void nilfs_bmap_lookup_dirty_buffers(struct nilfs_bmap *bmap, 310 struct list_head *listp) 311 { 312 if (bmap->b_ops->bop_lookup_dirty_buffers != NULL) 313 bmap->b_ops->bop_lookup_dirty_buffers(bmap, listp); 314 } 315 316 /** 317 * nilfs_bmap_assign - assign a new block number to a block 318 * @bmap: bmap 319 * @bhp: pointer to buffer head 320 * @blocknr: block number 321 * @binfo: block information 322 * 323 * Description: nilfs_bmap_assign() assigns the block number @blocknr to the 324 * buffer specified by @bh. 325 * 326 * Return Value: On success, 0 is returned and the buffer head of a newly 327 * create buffer and the block information associated with the buffer are 328 * stored in the place pointed by @bh and @binfo, respectively. On error, one 329 * of the following negative error codes is returned. 330 * 331 * %-EIO - I/O error. 332 * 333 * %-ENOMEM - Insufficient amount of memory available. 334 */ 335 int nilfs_bmap_assign(struct nilfs_bmap *bmap, 336 struct buffer_head **bh, 337 unsigned long blocknr, 338 union nilfs_binfo *binfo) 339 { 340 int ret; 341 342 down_write(&bmap->b_sem); 343 ret = bmap->b_ops->bop_assign(bmap, bh, blocknr, binfo); 344 up_write(&bmap->b_sem); 345 return ret; 346 } 347 348 /** 349 * nilfs_bmap_mark - mark block dirty 350 * @bmap: bmap 351 * @key: key 352 * @level: level 353 * 354 * Description: nilfs_bmap_mark() marks the block specified by @key and @level 355 * as dirty. 356 * 357 * Return Value: On success, 0 is returned. On error, one of the following 358 * negative error codes is returned. 359 * 360 * %-EIO - I/O error. 361 * 362 * %-ENOMEM - Insufficient amount of memory available. 363 */ 364 int nilfs_bmap_mark(struct nilfs_bmap *bmap, __u64 key, int level) 365 { 366 int ret; 367 368 if (bmap->b_ops->bop_mark == NULL) 369 return 0; 370 371 down_write(&bmap->b_sem); 372 ret = bmap->b_ops->bop_mark(bmap, key, level); 373 up_write(&bmap->b_sem); 374 return ret; 375 } 376 377 /** 378 * nilfs_bmap_test_and_clear_dirty - test and clear a bmap dirty state 379 * @bmap: bmap 380 * 381 * Description: nilfs_test_and_clear() is the atomic operation to test and 382 * clear the dirty state of @bmap. 383 * 384 * Return Value: 1 is returned if @bmap is dirty, or 0 if clear. 385 */ 386 int nilfs_bmap_test_and_clear_dirty(struct nilfs_bmap *bmap) 387 { 388 int ret; 389 390 down_write(&bmap->b_sem); 391 ret = nilfs_bmap_dirty(bmap); 392 nilfs_bmap_clear_dirty(bmap); 393 up_write(&bmap->b_sem); 394 return ret; 395 } 396 397 398 /* 399 * Internal use only 400 */ 401 402 void nilfs_bmap_add_blocks(const struct nilfs_bmap *bmap, int n) 403 { 404 inode_add_bytes(bmap->b_inode, (1 << bmap->b_inode->i_blkbits) * n); 405 if (NILFS_MDT(bmap->b_inode)) 406 nilfs_mdt_mark_dirty(bmap->b_inode); 407 else 408 mark_inode_dirty(bmap->b_inode); 409 } 410 411 void nilfs_bmap_sub_blocks(const struct nilfs_bmap *bmap, int n) 412 { 413 inode_sub_bytes(bmap->b_inode, (1 << bmap->b_inode->i_blkbits) * n); 414 if (NILFS_MDT(bmap->b_inode)) 415 nilfs_mdt_mark_dirty(bmap->b_inode); 416 else 417 mark_inode_dirty(bmap->b_inode); 418 } 419 420 int nilfs_bmap_get_block(const struct nilfs_bmap *bmap, __u64 ptr, 421 struct buffer_head **bhp) 422 { 423 return nilfs_btnode_get(&NILFS_BMAP_I(bmap)->i_btnode_cache, 424 ptr, 0, bhp, 0); 425 } 426 427 void nilfs_bmap_put_block(const struct nilfs_bmap *bmap, 428 struct buffer_head *bh) 429 { 430 brelse(bh); 431 } 432 433 int nilfs_bmap_get_new_block(const struct nilfs_bmap *bmap, __u64 ptr, 434 struct buffer_head **bhp) 435 { 436 int ret; 437 438 ret = nilfs_btnode_get(&NILFS_BMAP_I(bmap)->i_btnode_cache, 439 ptr, 0, bhp, 1); 440 if (ret < 0) 441 return ret; 442 set_buffer_nilfs_volatile(*bhp); 443 return 0; 444 } 445 446 void nilfs_bmap_delete_block(const struct nilfs_bmap *bmap, 447 struct buffer_head *bh) 448 { 449 nilfs_btnode_delete(bh); 450 } 451 452 __u64 nilfs_bmap_data_get_key(const struct nilfs_bmap *bmap, 453 const struct buffer_head *bh) 454 { 455 struct buffer_head *pbh; 456 __u64 key; 457 458 key = page_index(bh->b_page) << (PAGE_CACHE_SHIFT - 459 bmap->b_inode->i_blkbits); 460 for (pbh = page_buffers(bh->b_page); pbh != bh; 461 pbh = pbh->b_this_page, key++); 462 463 return key; 464 } 465 466 __u64 nilfs_bmap_find_target_seq(const struct nilfs_bmap *bmap, __u64 key) 467 { 468 __s64 diff; 469 470 diff = key - bmap->b_last_allocated_key; 471 if ((nilfs_bmap_keydiff_abs(diff) < NILFS_INODE_BMAP_SIZE) && 472 (bmap->b_last_allocated_ptr != NILFS_BMAP_INVALID_PTR) && 473 (bmap->b_last_allocated_ptr + diff > 0)) 474 return bmap->b_last_allocated_ptr + diff; 475 else 476 return NILFS_BMAP_INVALID_PTR; 477 } 478 479 static struct inode *nilfs_bmap_get_dat(const struct nilfs_bmap *bmap) 480 { 481 return nilfs_dat_inode(NILFS_I_NILFS(bmap->b_inode)); 482 } 483 484 #define NILFS_BMAP_GROUP_DIV 8 485 __u64 nilfs_bmap_find_target_in_group(const struct nilfs_bmap *bmap) 486 { 487 struct inode *dat = nilfs_bmap_get_dat(bmap); 488 unsigned long entries_per_group = nilfs_palloc_entries_per_group(dat); 489 unsigned long group = bmap->b_inode->i_ino / entries_per_group; 490 491 return group * entries_per_group + 492 (bmap->b_inode->i_ino % NILFS_BMAP_GROUP_DIV) * 493 (entries_per_group / NILFS_BMAP_GROUP_DIV); 494 } 495 496 static int nilfs_bmap_prepare_alloc_v(struct nilfs_bmap *bmap, 497 union nilfs_bmap_ptr_req *req) 498 { 499 return nilfs_dat_prepare_alloc(nilfs_bmap_get_dat(bmap), &req->bpr_req); 500 } 501 502 static void nilfs_bmap_commit_alloc_v(struct nilfs_bmap *bmap, 503 union nilfs_bmap_ptr_req *req) 504 { 505 nilfs_dat_commit_alloc(nilfs_bmap_get_dat(bmap), &req->bpr_req); 506 } 507 508 static void nilfs_bmap_abort_alloc_v(struct nilfs_bmap *bmap, 509 union nilfs_bmap_ptr_req *req) 510 { 511 nilfs_dat_abort_alloc(nilfs_bmap_get_dat(bmap), &req->bpr_req); 512 } 513 514 static int nilfs_bmap_prepare_start_v(struct nilfs_bmap *bmap, 515 union nilfs_bmap_ptr_req *req) 516 { 517 return nilfs_dat_prepare_start(nilfs_bmap_get_dat(bmap), &req->bpr_req); 518 } 519 520 static void nilfs_bmap_commit_start_v(struct nilfs_bmap *bmap, 521 union nilfs_bmap_ptr_req *req, 522 sector_t blocknr) 523 { 524 nilfs_dat_commit_start(nilfs_bmap_get_dat(bmap), &req->bpr_req, 525 blocknr); 526 } 527 528 static void nilfs_bmap_abort_start_v(struct nilfs_bmap *bmap, 529 union nilfs_bmap_ptr_req *req) 530 { 531 nilfs_dat_abort_start(nilfs_bmap_get_dat(bmap), &req->bpr_req); 532 } 533 534 static int nilfs_bmap_prepare_end_v(struct nilfs_bmap *bmap, 535 union nilfs_bmap_ptr_req *req) 536 { 537 return nilfs_dat_prepare_end(nilfs_bmap_get_dat(bmap), &req->bpr_req); 538 } 539 540 static void nilfs_bmap_commit_end_v(struct nilfs_bmap *bmap, 541 union nilfs_bmap_ptr_req *req) 542 { 543 nilfs_dat_commit_end(nilfs_bmap_get_dat(bmap), &req->bpr_req, 0); 544 } 545 546 static void nilfs_bmap_commit_end_vmdt(struct nilfs_bmap *bmap, 547 union nilfs_bmap_ptr_req *req) 548 { 549 nilfs_dat_commit_end(nilfs_bmap_get_dat(bmap), &req->bpr_req, 1); 550 } 551 552 static void nilfs_bmap_abort_end_v(struct nilfs_bmap *bmap, 553 union nilfs_bmap_ptr_req *req) 554 { 555 nilfs_dat_abort_end(nilfs_bmap_get_dat(bmap), &req->bpr_req); 556 } 557 558 int nilfs_bmap_move_v(const struct nilfs_bmap *bmap, __u64 vblocknr, 559 sector_t blocknr) 560 { 561 return nilfs_dat_move(nilfs_bmap_get_dat(bmap), vblocknr, blocknr); 562 } 563 564 int nilfs_bmap_mark_dirty(const struct nilfs_bmap *bmap, __u64 vblocknr) 565 { 566 return nilfs_dat_mark_dirty(nilfs_bmap_get_dat(bmap), vblocknr); 567 } 568 569 int nilfs_bmap_prepare_update(struct nilfs_bmap *bmap, 570 union nilfs_bmap_ptr_req *oldreq, 571 union nilfs_bmap_ptr_req *newreq) 572 { 573 int ret; 574 575 ret = bmap->b_pops->bpop_prepare_end_ptr(bmap, oldreq); 576 if (ret < 0) 577 return ret; 578 ret = bmap->b_pops->bpop_prepare_alloc_ptr(bmap, newreq); 579 if (ret < 0) 580 bmap->b_pops->bpop_abort_end_ptr(bmap, oldreq); 581 582 return ret; 583 } 584 585 void nilfs_bmap_commit_update(struct nilfs_bmap *bmap, 586 union nilfs_bmap_ptr_req *oldreq, 587 union nilfs_bmap_ptr_req *newreq) 588 { 589 bmap->b_pops->bpop_commit_end_ptr(bmap, oldreq); 590 bmap->b_pops->bpop_commit_alloc_ptr(bmap, newreq); 591 } 592 593 void nilfs_bmap_abort_update(struct nilfs_bmap *bmap, 594 union nilfs_bmap_ptr_req *oldreq, 595 union nilfs_bmap_ptr_req *newreq) 596 { 597 bmap->b_pops->bpop_abort_end_ptr(bmap, oldreq); 598 bmap->b_pops->bpop_abort_alloc_ptr(bmap, newreq); 599 } 600 601 static int nilfs_bmap_translate_v(const struct nilfs_bmap *bmap, __u64 ptr, 602 __u64 *ptrp) 603 { 604 sector_t blocknr; 605 int ret; 606 607 ret = nilfs_dat_translate(nilfs_bmap_get_dat(bmap), ptr, &blocknr); 608 if (ret < 0) 609 return ret; 610 if (ptrp != NULL) 611 *ptrp = blocknr; 612 return 0; 613 } 614 615 static int nilfs_bmap_prepare_alloc_p(struct nilfs_bmap *bmap, 616 union nilfs_bmap_ptr_req *req) 617 { 618 /* ignore target ptr */ 619 req->bpr_ptr = bmap->b_last_allocated_ptr++; 620 return 0; 621 } 622 623 static void nilfs_bmap_commit_alloc_p(struct nilfs_bmap *bmap, 624 union nilfs_bmap_ptr_req *req) 625 { 626 /* do nothing */ 627 } 628 629 static void nilfs_bmap_abort_alloc_p(struct nilfs_bmap *bmap, 630 union nilfs_bmap_ptr_req *req) 631 { 632 bmap->b_last_allocated_ptr--; 633 } 634 635 static const struct nilfs_bmap_ptr_operations nilfs_bmap_ptr_ops_v = { 636 .bpop_prepare_alloc_ptr = nilfs_bmap_prepare_alloc_v, 637 .bpop_commit_alloc_ptr = nilfs_bmap_commit_alloc_v, 638 .bpop_abort_alloc_ptr = nilfs_bmap_abort_alloc_v, 639 .bpop_prepare_start_ptr = nilfs_bmap_prepare_start_v, 640 .bpop_commit_start_ptr = nilfs_bmap_commit_start_v, 641 .bpop_abort_start_ptr = nilfs_bmap_abort_start_v, 642 .bpop_prepare_end_ptr = nilfs_bmap_prepare_end_v, 643 .bpop_commit_end_ptr = nilfs_bmap_commit_end_v, 644 .bpop_abort_end_ptr = nilfs_bmap_abort_end_v, 645 646 .bpop_translate = nilfs_bmap_translate_v, 647 }; 648 649 static const struct nilfs_bmap_ptr_operations nilfs_bmap_ptr_ops_vmdt = { 650 .bpop_prepare_alloc_ptr = nilfs_bmap_prepare_alloc_v, 651 .bpop_commit_alloc_ptr = nilfs_bmap_commit_alloc_v, 652 .bpop_abort_alloc_ptr = nilfs_bmap_abort_alloc_v, 653 .bpop_prepare_start_ptr = nilfs_bmap_prepare_start_v, 654 .bpop_commit_start_ptr = nilfs_bmap_commit_start_v, 655 .bpop_abort_start_ptr = nilfs_bmap_abort_start_v, 656 .bpop_prepare_end_ptr = nilfs_bmap_prepare_end_v, 657 .bpop_commit_end_ptr = nilfs_bmap_commit_end_vmdt, 658 .bpop_abort_end_ptr = nilfs_bmap_abort_end_v, 659 660 .bpop_translate = nilfs_bmap_translate_v, 661 }; 662 663 static const struct nilfs_bmap_ptr_operations nilfs_bmap_ptr_ops_p = { 664 .bpop_prepare_alloc_ptr = nilfs_bmap_prepare_alloc_p, 665 .bpop_commit_alloc_ptr = nilfs_bmap_commit_alloc_p, 666 .bpop_abort_alloc_ptr = nilfs_bmap_abort_alloc_p, 667 .bpop_prepare_start_ptr = NULL, 668 .bpop_commit_start_ptr = NULL, 669 .bpop_abort_start_ptr = NULL, 670 .bpop_prepare_end_ptr = NULL, 671 .bpop_commit_end_ptr = NULL, 672 .bpop_abort_end_ptr = NULL, 673 674 .bpop_translate = NULL, 675 }; 676 677 static const struct nilfs_bmap_ptr_operations nilfs_bmap_ptr_ops_gc = { 678 .bpop_prepare_alloc_ptr = NULL, 679 .bpop_commit_alloc_ptr = NULL, 680 .bpop_abort_alloc_ptr = NULL, 681 .bpop_prepare_start_ptr = NULL, 682 .bpop_commit_start_ptr = NULL, 683 .bpop_abort_start_ptr = NULL, 684 .bpop_prepare_end_ptr = NULL, 685 .bpop_commit_end_ptr = NULL, 686 .bpop_abort_end_ptr = NULL, 687 688 .bpop_translate = NULL, 689 }; 690 691 static struct lock_class_key nilfs_bmap_dat_lock_key; 692 693 /** 694 * nilfs_bmap_read - read a bmap from an inode 695 * @bmap: bmap 696 * @raw_inode: on-disk inode 697 * 698 * Description: nilfs_bmap_read() initializes the bmap @bmap. 699 * 700 * Return Value: On success, 0 is returned. On error, the following negative 701 * error code is returned. 702 * 703 * %-ENOMEM - Insufficient amount of memory available. 704 */ 705 int nilfs_bmap_read(struct nilfs_bmap *bmap, struct nilfs_inode *raw_inode) 706 { 707 if (raw_inode == NULL) 708 memset(bmap->b_u.u_data, 0, NILFS_BMAP_SIZE); 709 else 710 memcpy(bmap->b_u.u_data, raw_inode->i_bmap, NILFS_BMAP_SIZE); 711 712 init_rwsem(&bmap->b_sem); 713 bmap->b_state = 0; 714 bmap->b_inode = &NILFS_BMAP_I(bmap)->vfs_inode; 715 switch (bmap->b_inode->i_ino) { 716 case NILFS_DAT_INO: 717 bmap->b_pops = &nilfs_bmap_ptr_ops_p; 718 bmap->b_last_allocated_key = 0; /* XXX: use macro */ 719 bmap->b_last_allocated_ptr = NILFS_BMAP_NEW_PTR_INIT; 720 lockdep_set_class(&bmap->b_sem, &nilfs_bmap_dat_lock_key); 721 break; 722 case NILFS_CPFILE_INO: 723 case NILFS_SUFILE_INO: 724 bmap->b_pops = &nilfs_bmap_ptr_ops_vmdt; 725 bmap->b_last_allocated_key = 0; /* XXX: use macro */ 726 bmap->b_last_allocated_ptr = NILFS_BMAP_INVALID_PTR; 727 break; 728 default: 729 bmap->b_pops = &nilfs_bmap_ptr_ops_v; 730 bmap->b_last_allocated_key = 0; /* XXX: use macro */ 731 bmap->b_last_allocated_ptr = NILFS_BMAP_INVALID_PTR; 732 break; 733 } 734 735 return (bmap->b_u.u_flags & NILFS_BMAP_LARGE) ? 736 nilfs_btree_init(bmap, 737 NILFS_BMAP_LARGE_LOW, 738 NILFS_BMAP_LARGE_HIGH) : 739 nilfs_direct_init(bmap, 740 NILFS_BMAP_SMALL_LOW, 741 NILFS_BMAP_SMALL_HIGH); 742 } 743 744 /** 745 * nilfs_bmap_write - write back a bmap to an inode 746 * @bmap: bmap 747 * @raw_inode: on-disk inode 748 * 749 * Description: nilfs_bmap_write() stores @bmap in @raw_inode. 750 */ 751 void nilfs_bmap_write(struct nilfs_bmap *bmap, struct nilfs_inode *raw_inode) 752 { 753 down_write(&bmap->b_sem); 754 memcpy(raw_inode->i_bmap, bmap->b_u.u_data, 755 NILFS_INODE_BMAP_SIZE * sizeof(__le64)); 756 if (bmap->b_inode->i_ino == NILFS_DAT_INO) 757 bmap->b_last_allocated_ptr = NILFS_BMAP_NEW_PTR_INIT; 758 759 up_write(&bmap->b_sem); 760 } 761 762 void nilfs_bmap_init_gc(struct nilfs_bmap *bmap) 763 { 764 memset(&bmap->b_u, 0, NILFS_BMAP_SIZE); 765 init_rwsem(&bmap->b_sem); 766 bmap->b_inode = &NILFS_BMAP_I(bmap)->vfs_inode; 767 bmap->b_pops = &nilfs_bmap_ptr_ops_gc; 768 bmap->b_last_allocated_key = 0; 769 bmap->b_last_allocated_ptr = NILFS_BMAP_INVALID_PTR; 770 bmap->b_state = 0; 771 nilfs_btree_init_gc(bmap); 772 } 773 774 void nilfs_bmap_init_gcdat(struct nilfs_bmap *gcbmap, struct nilfs_bmap *bmap) 775 { 776 memcpy(gcbmap, bmap, sizeof(union nilfs_bmap_union)); 777 init_rwsem(&gcbmap->b_sem); 778 lockdep_set_class(&bmap->b_sem, &nilfs_bmap_dat_lock_key); 779 gcbmap->b_inode = &NILFS_BMAP_I(gcbmap)->vfs_inode; 780 } 781 782 void nilfs_bmap_commit_gcdat(struct nilfs_bmap *gcbmap, struct nilfs_bmap *bmap) 783 { 784 memcpy(bmap, gcbmap, sizeof(union nilfs_bmap_union)); 785 init_rwsem(&bmap->b_sem); 786 lockdep_set_class(&bmap->b_sem, &nilfs_bmap_dat_lock_key); 787 bmap->b_inode = &NILFS_BMAP_I(bmap)->vfs_inode; 788 } 789