1/* 2 * fs/logfs/segment.c - Handling the Object Store 3 * 4 * As should be obvious for Linux kernel code, license is GPLv2 5 * 6 * Copyright (c) 2005-2008 Joern Engel <joern@logfs.org> 7 * 8 * Object store or ostore makes up the complete device with exception of 9 * the superblock and journal areas. Apart from its own metadata it stores 10 * three kinds of objects: inodes, dentries and blocks, both data and indirect. 11 */ 12#include "logfs.h" 13#include <linux/slab.h> 14 15static int logfs_mark_segment_bad(struct super_block *sb, u32 segno) 16{ 17 struct logfs_super *super = logfs_super(sb); 18 struct btree_head32 *head = &super->s_reserved_segments; 19 int err; 20 21 err = btree_insert32(head, segno, (void *)1, GFP_NOFS); 22 if (err) 23 return err; 24 logfs_super(sb)->s_bad_segments++; 25 return 0; 26} 27 28int logfs_erase_segment(struct super_block *sb, u32 segno, int ensure_erase) 29{ 30 struct logfs_super *super = logfs_super(sb); 31 32 super->s_gec++; 33 34 return super->s_devops->erase(sb, (u64)segno << super->s_segshift, 35 super->s_segsize, ensure_erase); 36} 37 38static s64 logfs_get_free_bytes(struct logfs_area *area, size_t bytes) 39{ 40 s32 ofs; 41 42 logfs_open_area(area, bytes); 43 44 ofs = area->a_used_bytes; 45 area->a_used_bytes += bytes; 46 BUG_ON(area->a_used_bytes >= logfs_super(area->a_sb)->s_segsize); 47 48 return dev_ofs(area->a_sb, area->a_segno, ofs); 49} 50 51static struct page *get_mapping_page(struct super_block *sb, pgoff_t index, 52 int use_filler) 53{ 54 struct logfs_super *super = logfs_super(sb); 55 struct address_space *mapping = super->s_mapping_inode->i_mapping; 56 filler_t *filler = super->s_devops->readpage; 57 struct page *page; 58 59 BUG_ON(mapping_gfp_mask(mapping) & __GFP_FS); 60 if (use_filler) 61 page = read_cache_page(mapping, index, filler, sb); 62 else { 63 page = find_or_create_page(mapping, index, GFP_NOFS); 64 unlock_page(page); 65 } 66 return page; 67} 68 69int __logfs_buf_write(struct logfs_area *area, u64 ofs, void *buf, size_t len, 70 int use_filler) 71{ 72 pgoff_t index = ofs >> PAGE_SHIFT; 73 struct page *page; 74 long offset = ofs & (PAGE_SIZE-1); 75 long copylen; 76 77 /* Only logfs_wbuf_recover may use len==0 */ 78 BUG_ON(!len && !use_filler); 79 do { 80 copylen = min((ulong)len, PAGE_SIZE - offset); 81 82 page = get_mapping_page(area->a_sb, index, use_filler); 83 if (IS_ERR(page)) 84 return PTR_ERR(page); 85 BUG_ON(!page); 86 SetPageUptodate(page); 87 memcpy(page_address(page) + offset, buf, copylen); 88 SetPagePrivate(page); 89 page_cache_release(page); 90 91 buf += copylen; 92 len -= copylen; 93 offset = 0; 94 index++; 95 } while (len); 96 return 0; 97} 98 99static void pad_partial_page(struct logfs_area *area) 100{ 101 struct super_block *sb = area->a_sb; 102 struct page *page; 103 u64 ofs = dev_ofs(sb, area->a_segno, area->a_used_bytes); 104 pgoff_t index = ofs >> PAGE_SHIFT; 105 long offset = ofs & (PAGE_SIZE-1); 106 u32 len = PAGE_SIZE - offset; 107 108 if (len % PAGE_SIZE) { 109 page = get_mapping_page(sb, index, 0); 110 BUG_ON(!page); 111 memset(page_address(page) + offset, 0xff, len); 112 SetPagePrivate(page); 113 page_cache_release(page); 114 } 115} 116 117static void pad_full_pages(struct logfs_area *area) 118{ 119 struct super_block *sb = area->a_sb; 120 struct logfs_super *super = logfs_super(sb); 121 u64 ofs = dev_ofs(sb, area->a_segno, area->a_used_bytes); 122 u32 len = super->s_segsize - area->a_used_bytes; 123 pgoff_t index = PAGE_CACHE_ALIGN(ofs) >> PAGE_CACHE_SHIFT; 124 pgoff_t no_indizes = len >> PAGE_CACHE_SHIFT; 125 struct page *page; 126 127 while (no_indizes) { 128 page = get_mapping_page(sb, index, 0); 129 BUG_ON(!page); 130 SetPageUptodate(page); 131 memset(page_address(page), 0xff, PAGE_CACHE_SIZE); 132 SetPagePrivate(page); 133 page_cache_release(page); 134 index++; 135 no_indizes--; 136 } 137} 138 139/* 140 * bdev_writeseg will write full pages. Memset the tail to prevent data leaks. 141 * Also make sure we allocate (and memset) all pages for final writeout. 142 */ 143static void pad_wbuf(struct logfs_area *area, int final) 144{ 145 pad_partial_page(area); 146 if (final) 147 pad_full_pages(area); 148} 149 150/* 151 * We have to be careful with the alias tree. Since lookup is done by bix, 152 * it needs to be normalized, so 14, 15, 16, etc. all match when dealing with 153 * indirect blocks. So always use it through accessor functions. 154 */ 155static void *alias_tree_lookup(struct super_block *sb, u64 ino, u64 bix, 156 level_t level) 157{ 158 struct btree_head128 *head = &logfs_super(sb)->s_object_alias_tree; 159 pgoff_t index = logfs_pack_index(bix, level); 160 161 return btree_lookup128(head, ino, index); 162} 163 164static int alias_tree_insert(struct super_block *sb, u64 ino, u64 bix, 165 level_t level, void *val) 166{ 167 struct btree_head128 *head = &logfs_super(sb)->s_object_alias_tree; 168 pgoff_t index = logfs_pack_index(bix, level); 169 170 return btree_insert128(head, ino, index, val, GFP_NOFS); 171} 172 173static int btree_write_alias(struct super_block *sb, struct logfs_block *block, 174 write_alias_t *write_one_alias) 175{ 176 struct object_alias_item *item; 177 int err; 178 179 list_for_each_entry(item, &block->item_list, list) { 180 err = write_alias_journal(sb, block->ino, block->bix, 181 block->level, item->child_no, item->val); 182 if (err) 183 return err; 184 } 185 return 0; 186} 187 188static struct logfs_block_ops btree_block_ops = { 189 .write_block = btree_write_block, 190 .free_block = __free_block, 191 .write_alias = btree_write_alias, 192}; 193 194int logfs_load_object_aliases(struct super_block *sb, 195 struct logfs_obj_alias *oa, int count) 196{ 197 struct logfs_super *super = logfs_super(sb); 198 struct logfs_block *block; 199 struct object_alias_item *item; 200 u64 ino, bix; 201 level_t level; 202 int i, err; 203 204 super->s_flags |= LOGFS_SB_FLAG_OBJ_ALIAS; 205 count /= sizeof(*oa); 206 for (i = 0; i < count; i++) { 207 item = mempool_alloc(super->s_alias_pool, GFP_NOFS); 208 if (!item) 209 return -ENOMEM; 210 memset(item, 0, sizeof(*item)); 211 212 super->s_no_object_aliases++; 213 item->val = oa[i].val; 214 item->child_no = be16_to_cpu(oa[i].child_no); 215 216 ino = be64_to_cpu(oa[i].ino); 217 bix = be64_to_cpu(oa[i].bix); 218 level = LEVEL(oa[i].level); 219 220 log_aliases("logfs_load_object_aliases(%llx, %llx, %x, %x) %llx\n", 221 ino, bix, level, item->child_no, 222 be64_to_cpu(item->val)); 223 block = alias_tree_lookup(sb, ino, bix, level); 224 if (!block) { 225 block = __alloc_block(sb, ino, bix, level); 226 block->ops = &btree_block_ops; 227 err = alias_tree_insert(sb, ino, bix, level, block); 228 BUG_ON(err); /* mempool empty */ 229 } 230 if (test_and_set_bit(item->child_no, block->alias_map)) { 231 printk(KERN_ERR"LogFS: Alias collision detected\n"); 232 return -EIO; 233 } 234 list_move_tail(&block->alias_list, &super->s_object_alias); 235 list_add(&item->list, &block->item_list); 236 } 237 return 0; 238} 239 240static void kill_alias(void *_block, unsigned long ignore0, 241 u64 ignore1, u64 ignore2, size_t ignore3) 242{ 243 struct logfs_block *block = _block; 244 struct super_block *sb = block->sb; 245 struct logfs_super *super = logfs_super(sb); 246 struct object_alias_item *item; 247 248 while (!list_empty(&block->item_list)) { 249 item = list_entry(block->item_list.next, typeof(*item), list); 250 list_del(&item->list); 251 mempool_free(item, super->s_alias_pool); 252 } 253 block->ops->free_block(sb, block); 254} 255 256static int obj_type(struct inode *inode, level_t level) 257{ 258 if (level == 0) { 259 if (S_ISDIR(inode->i_mode)) 260 return OBJ_DENTRY; 261 if (inode->i_ino == LOGFS_INO_MASTER) 262 return OBJ_INODE; 263 } 264 return OBJ_BLOCK; 265} 266 267static int obj_len(struct super_block *sb, int obj_type) 268{ 269 switch (obj_type) { 270 case OBJ_DENTRY: 271 return sizeof(struct logfs_disk_dentry); 272 case OBJ_INODE: 273 return sizeof(struct logfs_disk_inode); 274 case OBJ_BLOCK: 275 return sb->s_blocksize; 276 default: 277 BUG(); 278 } 279} 280 281static int __logfs_segment_write(struct inode *inode, void *buf, 282 struct logfs_shadow *shadow, int type, int len, int compr) 283{ 284 struct logfs_area *area; 285 struct super_block *sb = inode->i_sb; 286 s64 ofs; 287 struct logfs_object_header h; 288 int acc_len; 289 290 if (shadow->gc_level == 0) 291 acc_len = len; 292 else 293 acc_len = obj_len(sb, type); 294 295 area = get_area(sb, shadow->gc_level); 296 ofs = logfs_get_free_bytes(area, len + LOGFS_OBJECT_HEADERSIZE); 297 LOGFS_BUG_ON(ofs <= 0, sb); 298 /* 299 * Order is important. logfs_get_free_bytes(), by modifying the 300 * segment file, may modify the content of the very page we're about 301 * to write now. Which is fine, as long as the calculated crc and 302 * written data still match. So do the modifications _before_ 303 * calculating the crc. 304 */ 305 306 h.len = cpu_to_be16(len); 307 h.type = type; 308 h.compr = compr; 309 h.ino = cpu_to_be64(inode->i_ino); 310 h.bix = cpu_to_be64(shadow->bix); 311 h.crc = logfs_crc32(&h, sizeof(h) - 4, 4); 312 h.data_crc = logfs_crc32(buf, len, 0); 313 314 logfs_buf_write(area, ofs, &h, sizeof(h)); 315 logfs_buf_write(area, ofs + LOGFS_OBJECT_HEADERSIZE, buf, len); 316 317 shadow->new_ofs = ofs; 318 shadow->new_len = acc_len + LOGFS_OBJECT_HEADERSIZE; 319 320 return 0; 321} 322 323static s64 logfs_segment_write_compress(struct inode *inode, void *buf, 324 struct logfs_shadow *shadow, int type, int len) 325{ 326 struct super_block *sb = inode->i_sb; 327 void *compressor_buf = logfs_super(sb)->s_compressed_je; 328 ssize_t compr_len; 329 int ret; 330 331 mutex_lock(&logfs_super(sb)->s_journal_mutex); 332 compr_len = logfs_compress(buf, compressor_buf, len, len); 333 334 if (compr_len >= 0) { 335 ret = __logfs_segment_write(inode, compressor_buf, shadow, 336 type, compr_len, COMPR_ZLIB); 337 } else { 338 ret = __logfs_segment_write(inode, buf, shadow, type, len, 339 COMPR_NONE); 340 } 341 mutex_unlock(&logfs_super(sb)->s_journal_mutex); 342 return ret; 343} 344 345/** 346 * logfs_segment_write - write data block to object store 347 * @inode: inode containing data 348 * 349 * Returns an errno or zero. 350 */ 351int logfs_segment_write(struct inode *inode, struct page *page, 352 struct logfs_shadow *shadow) 353{ 354 struct super_block *sb = inode->i_sb; 355 struct logfs_super *super = logfs_super(sb); 356 int do_compress, type, len; 357 int ret; 358 void *buf; 359 360 super->s_flags |= LOGFS_SB_FLAG_DIRTY; 361 BUG_ON(super->s_flags & LOGFS_SB_FLAG_SHUTDOWN); 362 do_compress = logfs_inode(inode)->li_flags & LOGFS_IF_COMPRESSED; 363 if (shadow->gc_level != 0) { 364 /* temporarily disable compression for indirect blocks */ 365 do_compress = 0; 366 } 367 368 type = obj_type(inode, shrink_level(shadow->gc_level)); 369 len = obj_len(sb, type); 370 buf = kmap(page); 371 if (do_compress) 372 ret = logfs_segment_write_compress(inode, buf, shadow, type, 373 len); 374 else 375 ret = __logfs_segment_write(inode, buf, shadow, type, len, 376 COMPR_NONE); 377 kunmap(page); 378 379 log_segment("logfs_segment_write(%llx, %llx, %x) %llx->%llx %x->%x\n", 380 shadow->ino, shadow->bix, shadow->gc_level, 381 shadow->old_ofs, shadow->new_ofs, 382 shadow->old_len, shadow->new_len); 383 /* this BUG_ON did catch a locking bug. useful */ 384 BUG_ON(!(shadow->new_ofs & (super->s_segsize - 1))); 385 return ret; 386} 387 388int wbuf_read(struct super_block *sb, u64 ofs, size_t len, void *buf) 389{ 390 pgoff_t index = ofs >> PAGE_SHIFT; 391 struct page *page; 392 long offset = ofs & (PAGE_SIZE-1); 393 long copylen; 394 395 while (len) { 396 copylen = min((ulong)len, PAGE_SIZE - offset); 397 398 page = get_mapping_page(sb, index, 1); 399 if (IS_ERR(page)) 400 return PTR_ERR(page); 401 memcpy(buf, page_address(page) + offset, copylen); 402 page_cache_release(page); 403 404 buf += copylen; 405 len -= copylen; 406 offset = 0; 407 index++; 408 } 409 return 0; 410} 411 412/* 413 * The "position" of indirect blocks is ambiguous. It can be the position 414 * of any data block somewhere behind this indirect block. So we need to 415 * normalize the positions through logfs_block_mask() before comparing. 416 */ 417static int check_pos(struct super_block *sb, u64 pos1, u64 pos2, level_t level) 418{ 419 return (pos1 & logfs_block_mask(sb, level)) != 420 (pos2 & logfs_block_mask(sb, level)); 421} 422 423 424static int read_obj_header(struct super_block *sb, u64 ofs, 425 struct logfs_object_header *oh) 426{ 427 __be32 crc; 428 int err; 429 430 err = wbuf_read(sb, ofs, sizeof(*oh), oh); 431 if (err) 432 return err; 433 crc = logfs_crc32(oh, sizeof(*oh) - 4, 4); 434 if (crc != oh->crc) { 435 printk(KERN_ERR"LOGFS: header crc error at %llx: expected %x, " 436 "got %x\n", ofs, be32_to_cpu(oh->crc), 437 be32_to_cpu(crc)); 438 return -EIO; 439 } 440 return 0; 441} 442 443static void move_btree_to_page(struct inode *inode, struct page *page, 444 __be64 *data) 445{ 446 struct super_block *sb = inode->i_sb; 447 struct logfs_super *super = logfs_super(sb); 448 struct btree_head128 *head = &super->s_object_alias_tree; 449 struct logfs_block *block; 450 struct object_alias_item *item, *next; 451 452 if (!(super->s_flags & LOGFS_SB_FLAG_OBJ_ALIAS)) 453 return; 454 455 block = btree_remove128(head, inode->i_ino, page->index); 456 if (!block) 457 return; 458 459 log_blockmove("move_btree_to_page(%llx, %llx, %x)\n", 460 block->ino, block->bix, block->level); 461 list_for_each_entry_safe(item, next, &block->item_list, list) { 462 data[item->child_no] = item->val; 463 list_del(&item->list); 464 mempool_free(item, super->s_alias_pool); 465 } 466 block->page = page; 467 SetPagePrivate(page); 468 page->private = (unsigned long)block; 469 block->ops = &indirect_block_ops; 470 initialize_block_counters(page, block, data, 0); 471} 472 473/* 474 * This silences a false, yet annoying gcc warning. I hate it when my editor 475 * jumps into bitops.h each time I recompile this file. 476 * TODO: Complain to gcc folks about this and upgrade compiler. 477 */ 478static unsigned long fnb(const unsigned long *addr, 479 unsigned long size, unsigned long offset) 480{ 481 return find_next_bit(addr, size, offset); 482} 483 484void move_page_to_btree(struct page *page) 485{ 486 struct logfs_block *block = logfs_block(page); 487 struct super_block *sb = block->sb; 488 struct logfs_super *super = logfs_super(sb); 489 struct object_alias_item *item; 490 unsigned long pos; 491 __be64 *child; 492 int err; 493 494 if (super->s_flags & LOGFS_SB_FLAG_SHUTDOWN) { 495 block->ops->free_block(sb, block); 496 return; 497 } 498 log_blockmove("move_page_to_btree(%llx, %llx, %x)\n", 499 block->ino, block->bix, block->level); 500 super->s_flags |= LOGFS_SB_FLAG_OBJ_ALIAS; 501 502 for (pos = 0; ; pos++) { 503 pos = fnb(block->alias_map, LOGFS_BLOCK_FACTOR, pos); 504 if (pos >= LOGFS_BLOCK_FACTOR) 505 break; 506 507 item = mempool_alloc(super->s_alias_pool, GFP_NOFS); 508 BUG_ON(!item); /* mempool empty */ 509 memset(item, 0, sizeof(*item)); 510 511 child = kmap_atomic(page, KM_USER0); 512 item->val = child[pos]; 513 kunmap_atomic(child, KM_USER0); 514 item->child_no = pos; 515 list_add(&item->list, &block->item_list); 516 } 517 block->page = NULL; 518 ClearPagePrivate(page); 519 page->private = 0; 520 block->ops = &btree_block_ops; 521 err = alias_tree_insert(block->sb, block->ino, block->bix, block->level, 522 block); 523 BUG_ON(err); /* mempool empty */ 524 ClearPageUptodate(page); 525} 526 527static int __logfs_segment_read(struct inode *inode, void *buf, 528 u64 ofs, u64 bix, level_t level) 529{ 530 struct super_block *sb = inode->i_sb; 531 void *compressor_buf = logfs_super(sb)->s_compressed_je; 532 struct logfs_object_header oh; 533 __be32 crc; 534 u16 len; 535 int err, block_len; 536 537 block_len = obj_len(sb, obj_type(inode, level)); 538 err = read_obj_header(sb, ofs, &oh); 539 if (err) 540 goto out_err; 541 542 err = -EIO; 543 if (be64_to_cpu(oh.ino) != inode->i_ino 544 || check_pos(sb, be64_to_cpu(oh.bix), bix, level)) { 545 printk(KERN_ERR"LOGFS: (ino, bix) don't match at %llx: " 546 "expected (%lx, %llx), got (%llx, %llx)\n", 547 ofs, inode->i_ino, bix, 548 be64_to_cpu(oh.ino), be64_to_cpu(oh.bix)); 549 goto out_err; 550 } 551 552 len = be16_to_cpu(oh.len); 553 554 switch (oh.compr) { 555 case COMPR_NONE: 556 err = wbuf_read(sb, ofs + LOGFS_OBJECT_HEADERSIZE, len, buf); 557 if (err) 558 goto out_err; 559 crc = logfs_crc32(buf, len, 0); 560 if (crc != oh.data_crc) { 561 printk(KERN_ERR"LOGFS: uncompressed data crc error at " 562 "%llx: expected %x, got %x\n", ofs, 563 be32_to_cpu(oh.data_crc), 564 be32_to_cpu(crc)); 565 goto out_err; 566 } 567 break; 568 case COMPR_ZLIB: 569 mutex_lock(&logfs_super(sb)->s_journal_mutex); 570 err = wbuf_read(sb, ofs + LOGFS_OBJECT_HEADERSIZE, len, 571 compressor_buf); 572 if (err) { 573 mutex_unlock(&logfs_super(sb)->s_journal_mutex); 574 goto out_err; 575 } 576 crc = logfs_crc32(compressor_buf, len, 0); 577 if (crc != oh.data_crc) { 578 printk(KERN_ERR"LOGFS: compressed data crc error at " 579 "%llx: expected %x, got %x\n", ofs, 580 be32_to_cpu(oh.data_crc), 581 be32_to_cpu(crc)); 582 mutex_unlock(&logfs_super(sb)->s_journal_mutex); 583 goto out_err; 584 } 585 err = logfs_uncompress(compressor_buf, buf, len, block_len); 586 mutex_unlock(&logfs_super(sb)->s_journal_mutex); 587 if (err) { 588 printk(KERN_ERR"LOGFS: uncompress error at %llx\n", ofs); 589 goto out_err; 590 } 591 break; 592 default: 593 LOGFS_BUG(sb); 594 err = -EIO; 595 goto out_err; 596 } 597 return 0; 598 599out_err: 600 logfs_set_ro(sb); 601 printk(KERN_ERR"LOGFS: device is read-only now\n"); 602 LOGFS_BUG(sb); 603 return err; 604} 605 606/** 607 * logfs_segment_read - read data block from object store 608 * @inode: inode containing data 609 * @buf: data buffer 610 * @ofs: physical data offset 611 * @bix: block index 612 * @level: block level 613 * 614 * Returns 0 on success or a negative errno. 615 */ 616int logfs_segment_read(struct inode *inode, struct page *page, 617 u64 ofs, u64 bix, level_t level) 618{ 619 int err; 620 void *buf; 621 622 if (PageUptodate(page)) 623 return 0; 624 625 ofs &= ~LOGFS_FULLY_POPULATED; 626 627 buf = kmap(page); 628 err = __logfs_segment_read(inode, buf, ofs, bix, level); 629 if (!err) { 630 move_btree_to_page(inode, page, buf); 631 SetPageUptodate(page); 632 } 633 kunmap(page); 634 log_segment("logfs_segment_read(%lx, %llx, %x) %llx (%d)\n", 635 inode->i_ino, bix, level, ofs, err); 636 return err; 637} 638 639int logfs_segment_delete(struct inode *inode, struct logfs_shadow *shadow) 640{ 641 struct super_block *sb = inode->i_sb; 642 struct logfs_super *super = logfs_super(sb); 643 struct logfs_object_header h; 644 u16 len; 645 int err; 646 647 super->s_flags |= LOGFS_SB_FLAG_DIRTY; 648 BUG_ON(super->s_flags & LOGFS_SB_FLAG_SHUTDOWN); 649 BUG_ON(shadow->old_ofs & LOGFS_FULLY_POPULATED); 650 if (!shadow->old_ofs) 651 return 0; 652 653 log_segment("logfs_segment_delete(%llx, %llx, %x) %llx->%llx %x->%x\n", 654 shadow->ino, shadow->bix, shadow->gc_level, 655 shadow->old_ofs, shadow->new_ofs, 656 shadow->old_len, shadow->new_len); 657 err = read_obj_header(sb, shadow->old_ofs, &h); 658 LOGFS_BUG_ON(err, sb); 659 LOGFS_BUG_ON(be64_to_cpu(h.ino) != inode->i_ino, sb); 660 LOGFS_BUG_ON(check_pos(sb, shadow->bix, be64_to_cpu(h.bix), 661 shrink_level(shadow->gc_level)), sb); 662 663 if (shadow->gc_level == 0) 664 len = be16_to_cpu(h.len); 665 else 666 len = obj_len(sb, h.type); 667 shadow->old_len = len + sizeof(h); 668 return 0; 669} 670 671void freeseg(struct super_block *sb, u32 segno) 672{ 673 struct logfs_super *super = logfs_super(sb); 674 struct address_space *mapping = super->s_mapping_inode->i_mapping; 675 struct page *page; 676 u64 ofs, start, end; 677 678 start = dev_ofs(sb, segno, 0); 679 end = dev_ofs(sb, segno + 1, 0); 680 for (ofs = start; ofs < end; ofs += PAGE_SIZE) { 681 page = find_get_page(mapping, ofs >> PAGE_SHIFT); 682 if (!page) 683 continue; 684 ClearPagePrivate(page); 685 page_cache_release(page); 686 } 687} 688 689int logfs_open_area(struct logfs_area *area, size_t bytes) 690{ 691 struct super_block *sb = area->a_sb; 692 struct logfs_super *super = logfs_super(sb); 693 int err, closed = 0; 694 695 if (area->a_is_open && area->a_used_bytes + bytes <= super->s_segsize) 696 return 0; 697 698 if (area->a_is_open) { 699 u64 ofs = dev_ofs(sb, area->a_segno, area->a_written_bytes); 700 u32 len = super->s_segsize - area->a_written_bytes; 701 702 log_gc("logfs_close_area(%x)\n", area->a_segno); 703 pad_wbuf(area, 1); 704 super->s_devops->writeseg(area->a_sb, ofs, len); 705 freeseg(sb, area->a_segno); 706 closed = 1; 707 } 708 709 area->a_used_bytes = 0; 710 area->a_written_bytes = 0; 711again: 712 area->a_ops->get_free_segment(area); 713 area->a_ops->get_erase_count(area); 714 715 log_gc("logfs_open_area(%x, %x)\n", area->a_segno, area->a_level); 716 err = area->a_ops->erase_segment(area); 717 if (err) { 718 printk(KERN_WARNING "LogFS: Error erasing segment %x\n", 719 area->a_segno); 720 logfs_mark_segment_bad(sb, area->a_segno); 721 goto again; 722 } 723 area->a_is_open = 1; 724 return closed; 725} 726 727void logfs_sync_area(struct logfs_area *area) 728{ 729 struct super_block *sb = area->a_sb; 730 struct logfs_super *super = logfs_super(sb); 731 u64 ofs = dev_ofs(sb, area->a_segno, area->a_written_bytes); 732 u32 len = (area->a_used_bytes - area->a_written_bytes); 733 734 if (super->s_writesize) 735 len &= ~(super->s_writesize - 1); 736 if (len == 0) 737 return; 738 pad_wbuf(area, 0); 739 super->s_devops->writeseg(sb, ofs, len); 740 area->a_written_bytes += len; 741} 742 743void logfs_sync_segments(struct super_block *sb) 744{ 745 struct logfs_super *super = logfs_super(sb); 746 int i; 747 748 for_each_area(i) 749 logfs_sync_area(super->s_area[i]); 750} 751 752/* 753 * Pick a free segment to be used for this area. Effectively takes a 754 * candidate from the free list (not really a candidate anymore). 755 */ 756static void ostore_get_free_segment(struct logfs_area *area) 757{ 758 struct super_block *sb = area->a_sb; 759 struct logfs_super *super = logfs_super(sb); 760 761 if (super->s_free_list.count == 0) { 762 printk(KERN_ERR"LOGFS: ran out of free segments\n"); 763 LOGFS_BUG(sb); 764 } 765 766 area->a_segno = get_best_cand(sb, &super->s_free_list, NULL); 767} 768 769static void ostore_get_erase_count(struct logfs_area *area) 770{ 771 struct logfs_segment_entry se; 772 u32 ec_level; 773 774 logfs_get_segment_entry(area->a_sb, area->a_segno, &se); 775 BUG_ON(se.ec_level == cpu_to_be32(BADSEG) || 776 se.valid == cpu_to_be32(RESERVED)); 777 778 ec_level = be32_to_cpu(se.ec_level); 779 area->a_erase_count = (ec_level >> 4) + 1; 780} 781 782static int ostore_erase_segment(struct logfs_area *area) 783{ 784 struct super_block *sb = area->a_sb; 785 struct logfs_segment_header sh; 786 u64 ofs; 787 int err; 788 789 err = logfs_erase_segment(sb, area->a_segno, 0); 790 if (err) 791 return err; 792 793 sh.pad = 0; 794 sh.type = SEG_OSTORE; 795 sh.level = (__force u8)area->a_level; 796 sh.segno = cpu_to_be32(area->a_segno); 797 sh.ec = cpu_to_be32(area->a_erase_count); 798 sh.gec = cpu_to_be64(logfs_super(sb)->s_gec); 799 sh.crc = logfs_crc32(&sh, sizeof(sh), 4); 800 801 logfs_set_segment_erased(sb, area->a_segno, area->a_erase_count, 802 area->a_level); 803 804 ofs = dev_ofs(sb, area->a_segno, 0); 805 area->a_used_bytes = sizeof(sh); 806 logfs_buf_write(area, ofs, &sh, sizeof(sh)); 807 return 0; 808} 809 810static const struct logfs_area_ops ostore_area_ops = { 811 .get_free_segment = ostore_get_free_segment, 812 .get_erase_count = ostore_get_erase_count, 813 .erase_segment = ostore_erase_segment, 814}; 815 816static void free_area(struct logfs_area *area) 817{ 818 if (area) 819 freeseg(area->a_sb, area->a_segno); 820 kfree(area); 821} 822 823static struct logfs_area *alloc_area(struct super_block *sb) 824{ 825 struct logfs_area *area; 826 827 area = kzalloc(sizeof(*area), GFP_KERNEL); 828 if (!area) 829 return NULL; 830 831 area->a_sb = sb; 832 return area; 833} 834 835static void map_invalidatepage(struct page *page, unsigned long l) 836{ 837 BUG(); 838} 839 840static int map_releasepage(struct page *page, gfp_t g) 841{ 842 /* Don't release these pages */ 843 return 0; 844} 845 846static const struct address_space_operations mapping_aops = { 847 .invalidatepage = map_invalidatepage, 848 .releasepage = map_releasepage, 849 .set_page_dirty = __set_page_dirty_nobuffers, 850}; 851 852int logfs_init_mapping(struct super_block *sb) 853{ 854 struct logfs_super *super = logfs_super(sb); 855 struct address_space *mapping; 856 struct inode *inode; 857 858 inode = logfs_new_meta_inode(sb, LOGFS_INO_MAPPING); 859 if (IS_ERR(inode)) 860 return PTR_ERR(inode); 861 super->s_mapping_inode = inode; 862 mapping = inode->i_mapping; 863 mapping->a_ops = &mapping_aops; 864 /* Would it be possible to use __GFP_HIGHMEM as well? */ 865 mapping_set_gfp_mask(mapping, GFP_NOFS); 866 return 0; 867} 868 869int logfs_init_areas(struct super_block *sb) 870{ 871 struct logfs_super *super = logfs_super(sb); 872 int i = -1; 873 874 super->s_alias_pool = mempool_create_kmalloc_pool(600, 875 sizeof(struct object_alias_item)); 876 if (!super->s_alias_pool) 877 return -ENOMEM; 878 879 super->s_journal_area = alloc_area(sb); 880 if (!super->s_journal_area) 881 goto err; 882 883 for_each_area(i) { 884 super->s_area[i] = alloc_area(sb); 885 if (!super->s_area[i]) 886 goto err; 887 super->s_area[i]->a_level = GC_LEVEL(i); 888 super->s_area[i]->a_ops = &ostore_area_ops; 889 } 890 btree_init_mempool128(&super->s_object_alias_tree, 891 super->s_btree_pool); 892 return 0; 893 894err: 895 for (i--; i >= 0; i--) 896 free_area(super->s_area[i]); 897 free_area(super->s_journal_area); 898 logfs_mempool_destroy(super->s_alias_pool); 899 return -ENOMEM; 900} 901 902void logfs_cleanup_areas(struct super_block *sb) 903{ 904 struct logfs_super *super = logfs_super(sb); 905 int i; 906 907 btree_grim_visitor128(&super->s_object_alias_tree, 0, kill_alias); 908 for_each_area(i) 909 free_area(super->s_area[i]); 910 free_area(super->s_journal_area); 911} 912