journal.c revision dabb44334060b4b84051b34c58573e57cc7432b2
1/* 2 * bcache journalling code, for btree insertions 3 * 4 * Copyright 2012 Google, Inc. 5 */ 6 7#include "bcache.h" 8#include "btree.h" 9#include "debug.h" 10 11#include <trace/events/bcache.h> 12 13/* 14 * Journal replay/recovery: 15 * 16 * This code is all driven from run_cache_set(); we first read the journal 17 * entries, do some other stuff, then we mark all the keys in the journal 18 * entries (same as garbage collection would), then we replay them - reinserting 19 * them into the cache in precisely the same order as they appear in the 20 * journal. 21 * 22 * We only journal keys that go in leaf nodes, which simplifies things quite a 23 * bit. 24 */ 25 26static void journal_read_endio(struct bio *bio, int error) 27{ 28 struct closure *cl = bio->bi_private; 29 closure_put(cl); 30} 31 32static int journal_read_bucket(struct cache *ca, struct list_head *list, 33 unsigned bucket_index) 34{ 35 struct journal_device *ja = &ca->journal; 36 struct bio *bio = &ja->bio; 37 38 struct journal_replay *i; 39 struct jset *j, *data = ca->set->journal.w[0].data; 40 struct closure cl; 41 unsigned len, left, offset = 0; 42 int ret = 0; 43 sector_t bucket = bucket_to_sector(ca->set, ca->sb.d[bucket_index]); 44 45 closure_init_stack(&cl); 46 47 pr_debug("reading %u", bucket_index); 48 49 while (offset < ca->sb.bucket_size) { 50reread: left = ca->sb.bucket_size - offset; 51 len = min_t(unsigned, left, PAGE_SECTORS << JSET_BITS); 52 53 bio_reset(bio); 54 bio->bi_iter.bi_sector = bucket + offset; 55 bio->bi_bdev = ca->bdev; 56 bio->bi_rw = READ; 57 bio->bi_iter.bi_size = len << 9; 58 59 bio->bi_end_io = journal_read_endio; 60 bio->bi_private = &cl; 61 bch_bio_map(bio, data); 62 63 closure_bio_submit(bio, &cl, ca); 64 closure_sync(&cl); 65 66 /* This function could be simpler now since we no longer write 67 * journal entries that overlap bucket boundaries; this means 68 * the start of a bucket will always have a valid journal entry 69 * if it has any journal entries at all. 70 */ 71 72 j = data; 73 while (len) { 74 struct list_head *where; 75 size_t blocks, bytes = set_bytes(j); 76 77 if (j->magic != jset_magic(&ca->sb)) { 78 pr_debug("%u: bad magic", bucket_index); 79 return ret; 80 } 81 82 if (bytes > left << 9 || 83 bytes > PAGE_SIZE << JSET_BITS) { 84 pr_info("%u: too big, %zu bytes, offset %u", 85 bucket_index, bytes, offset); 86 return ret; 87 } 88 89 if (bytes > len << 9) 90 goto reread; 91 92 if (j->csum != csum_set(j)) { 93 pr_info("%u: bad csum, %zu bytes, offset %u", 94 bucket_index, bytes, offset); 95 return ret; 96 } 97 98 blocks = set_blocks(j, block_bytes(ca->set)); 99 100 while (!list_empty(list)) { 101 i = list_first_entry(list, 102 struct journal_replay, list); 103 if (i->j.seq >= j->last_seq) 104 break; 105 list_del(&i->list); 106 kfree(i); 107 } 108 109 list_for_each_entry_reverse(i, list, list) { 110 if (j->seq == i->j.seq) 111 goto next_set; 112 113 if (j->seq < i->j.last_seq) 114 goto next_set; 115 116 if (j->seq > i->j.seq) { 117 where = &i->list; 118 goto add; 119 } 120 } 121 122 where = list; 123add: 124 i = kmalloc(offsetof(struct journal_replay, j) + 125 bytes, GFP_KERNEL); 126 if (!i) 127 return -ENOMEM; 128 memcpy(&i->j, j, bytes); 129 list_add(&i->list, where); 130 ret = 1; 131 132 ja->seq[bucket_index] = j->seq; 133next_set: 134 offset += blocks * ca->sb.block_size; 135 len -= blocks * ca->sb.block_size; 136 j = ((void *) j) + blocks * block_bytes(ca); 137 } 138 } 139 140 return ret; 141} 142 143int bch_journal_read(struct cache_set *c, struct list_head *list) 144{ 145#define read_bucket(b) \ 146 ({ \ 147 int ret = journal_read_bucket(ca, list, b); \ 148 __set_bit(b, bitmap); \ 149 if (ret < 0) \ 150 return ret; \ 151 ret; \ 152 }) 153 154 struct cache *ca; 155 unsigned iter; 156 157 for_each_cache(ca, c, iter) { 158 struct journal_device *ja = &ca->journal; 159 unsigned long bitmap[SB_JOURNAL_BUCKETS / BITS_PER_LONG]; 160 unsigned i, l, r, m; 161 uint64_t seq; 162 163 bitmap_zero(bitmap, SB_JOURNAL_BUCKETS); 164 pr_debug("%u journal buckets", ca->sb.njournal_buckets); 165 166 /* 167 * Read journal buckets ordered by golden ratio hash to quickly 168 * find a sequence of buckets with valid journal entries 169 */ 170 for (i = 0; i < ca->sb.njournal_buckets; i++) { 171 l = (i * 2654435769U) % ca->sb.njournal_buckets; 172 173 if (test_bit(l, bitmap)) 174 break; 175 176 if (read_bucket(l)) 177 goto bsearch; 178 } 179 180 /* 181 * If that fails, check all the buckets we haven't checked 182 * already 183 */ 184 pr_debug("falling back to linear search"); 185 186 for (l = find_first_zero_bit(bitmap, ca->sb.njournal_buckets); 187 l < ca->sb.njournal_buckets; 188 l = find_next_zero_bit(bitmap, ca->sb.njournal_buckets, l + 1)) 189 if (read_bucket(l)) 190 goto bsearch; 191 192 if (list_empty(list)) 193 continue; 194bsearch: 195 /* Binary search */ 196 m = r = find_next_bit(bitmap, ca->sb.njournal_buckets, l + 1); 197 pr_debug("starting binary search, l %u r %u", l, r); 198 199 while (l + 1 < r) { 200 seq = list_entry(list->prev, struct journal_replay, 201 list)->j.seq; 202 203 m = (l + r) >> 1; 204 read_bucket(m); 205 206 if (seq != list_entry(list->prev, struct journal_replay, 207 list)->j.seq) 208 l = m; 209 else 210 r = m; 211 } 212 213 /* 214 * Read buckets in reverse order until we stop finding more 215 * journal entries 216 */ 217 pr_debug("finishing up: m %u njournal_buckets %u", 218 m, ca->sb.njournal_buckets); 219 l = m; 220 221 while (1) { 222 if (!l--) 223 l = ca->sb.njournal_buckets - 1; 224 225 if (l == m) 226 break; 227 228 if (test_bit(l, bitmap)) 229 continue; 230 231 if (!read_bucket(l)) 232 break; 233 } 234 235 seq = 0; 236 237 for (i = 0; i < ca->sb.njournal_buckets; i++) 238 if (ja->seq[i] > seq) { 239 seq = ja->seq[i]; 240 ja->cur_idx = ja->discard_idx = 241 ja->last_idx = i; 242 243 } 244 } 245 246 if (!list_empty(list)) 247 c->journal.seq = list_entry(list->prev, 248 struct journal_replay, 249 list)->j.seq; 250 251 return 0; 252#undef read_bucket 253} 254 255void bch_journal_mark(struct cache_set *c, struct list_head *list) 256{ 257 atomic_t p = { 0 }; 258 struct bkey *k; 259 struct journal_replay *i; 260 struct journal *j = &c->journal; 261 uint64_t last = j->seq; 262 263 /* 264 * journal.pin should never fill up - we never write a journal 265 * entry when it would fill up. But if for some reason it does, we 266 * iterate over the list in reverse order so that we can just skip that 267 * refcount instead of bugging. 268 */ 269 270 list_for_each_entry_reverse(i, list, list) { 271 BUG_ON(last < i->j.seq); 272 i->pin = NULL; 273 274 while (last-- != i->j.seq) 275 if (fifo_free(&j->pin) > 1) { 276 fifo_push_front(&j->pin, p); 277 atomic_set(&fifo_front(&j->pin), 0); 278 } 279 280 if (fifo_free(&j->pin) > 1) { 281 fifo_push_front(&j->pin, p); 282 i->pin = &fifo_front(&j->pin); 283 atomic_set(i->pin, 1); 284 } 285 286 for (k = i->j.start; 287 k < bset_bkey_last(&i->j); 288 k = bkey_next(k)) { 289 unsigned j; 290 291 for (j = 0; j < KEY_PTRS(k); j++) { 292 struct bucket *g = PTR_BUCKET(c, k, j); 293 atomic_inc(&g->pin); 294 295 if (g->prio == BTREE_PRIO && 296 !ptr_stale(c, k, j)) 297 g->prio = INITIAL_PRIO; 298 } 299 300 __bch_btree_mark_key(c, 0, k); 301 } 302 } 303} 304 305int bch_journal_replay(struct cache_set *s, struct list_head *list) 306{ 307 int ret = 0, keys = 0, entries = 0; 308 struct bkey *k; 309 struct journal_replay *i = 310 list_entry(list->prev, struct journal_replay, list); 311 312 uint64_t start = i->j.last_seq, end = i->j.seq, n = start; 313 struct keylist keylist; 314 315 bch_keylist_init(&keylist); 316 317 list_for_each_entry(i, list, list) { 318 BUG_ON(i->pin && atomic_read(i->pin) != 1); 319 320 cache_set_err_on(n != i->j.seq, s, 321"bcache: journal entries %llu-%llu missing! (replaying %llu-%llu)", 322 n, i->j.seq - 1, start, end); 323 324 for (k = i->j.start; 325 k < bset_bkey_last(&i->j); 326 k = bkey_next(k)) { 327 trace_bcache_journal_replay_key(k); 328 329 bkey_copy(keylist.top, k); 330 bch_keylist_push(&keylist); 331 332 ret = bch_btree_insert(s, &keylist, i->pin, NULL); 333 if (ret) 334 goto err; 335 336 BUG_ON(!bch_keylist_empty(&keylist)); 337 keys++; 338 339 cond_resched(); 340 } 341 342 if (i->pin) 343 atomic_dec(i->pin); 344 n = i->j.seq + 1; 345 entries++; 346 } 347 348 pr_info("journal replay done, %i keys in %i entries, seq %llu", 349 keys, entries, end); 350err: 351 while (!list_empty(list)) { 352 i = list_first_entry(list, struct journal_replay, list); 353 list_del(&i->list); 354 kfree(i); 355 } 356 357 return ret; 358} 359 360/* Journalling */ 361 362static void btree_flush_write(struct cache_set *c) 363{ 364 /* 365 * Try to find the btree node with that references the oldest journal 366 * entry, best is our current candidate and is locked if non NULL: 367 */ 368 struct btree *b, *best; 369 unsigned i; 370retry: 371 best = NULL; 372 373 for_each_cached_btree(b, c, i) 374 if (btree_current_write(b)->journal) { 375 if (!best) 376 best = b; 377 else if (journal_pin_cmp(c, 378 btree_current_write(best)->journal, 379 btree_current_write(b)->journal)) { 380 best = b; 381 } 382 } 383 384 b = best; 385 if (b) { 386 rw_lock(true, b, b->level); 387 388 if (!btree_current_write(b)->journal) { 389 rw_unlock(true, b); 390 /* We raced */ 391 goto retry; 392 } 393 394 bch_btree_node_write(b, NULL); 395 rw_unlock(true, b); 396 } 397} 398 399#define last_seq(j) ((j)->seq - fifo_used(&(j)->pin) + 1) 400 401static void journal_discard_endio(struct bio *bio, int error) 402{ 403 struct journal_device *ja = 404 container_of(bio, struct journal_device, discard_bio); 405 struct cache *ca = container_of(ja, struct cache, journal); 406 407 atomic_set(&ja->discard_in_flight, DISCARD_DONE); 408 409 closure_wake_up(&ca->set->journal.wait); 410 closure_put(&ca->set->cl); 411} 412 413static void journal_discard_work(struct work_struct *work) 414{ 415 struct journal_device *ja = 416 container_of(work, struct journal_device, discard_work); 417 418 submit_bio(0, &ja->discard_bio); 419} 420 421static void do_journal_discard(struct cache *ca) 422{ 423 struct journal_device *ja = &ca->journal; 424 struct bio *bio = &ja->discard_bio; 425 426 if (!ca->discard) { 427 ja->discard_idx = ja->last_idx; 428 return; 429 } 430 431 switch (atomic_read(&ja->discard_in_flight)) { 432 case DISCARD_IN_FLIGHT: 433 return; 434 435 case DISCARD_DONE: 436 ja->discard_idx = (ja->discard_idx + 1) % 437 ca->sb.njournal_buckets; 438 439 atomic_set(&ja->discard_in_flight, DISCARD_READY); 440 /* fallthrough */ 441 442 case DISCARD_READY: 443 if (ja->discard_idx == ja->last_idx) 444 return; 445 446 atomic_set(&ja->discard_in_flight, DISCARD_IN_FLIGHT); 447 448 bio_init(bio); 449 bio->bi_iter.bi_sector = bucket_to_sector(ca->set, 450 ca->sb.d[ja->discard_idx]); 451 bio->bi_bdev = ca->bdev; 452 bio->bi_rw = REQ_WRITE|REQ_DISCARD; 453 bio->bi_max_vecs = 1; 454 bio->bi_io_vec = bio->bi_inline_vecs; 455 bio->bi_iter.bi_size = bucket_bytes(ca); 456 bio->bi_end_io = journal_discard_endio; 457 458 closure_get(&ca->set->cl); 459 INIT_WORK(&ja->discard_work, journal_discard_work); 460 schedule_work(&ja->discard_work); 461 } 462} 463 464static void journal_reclaim(struct cache_set *c) 465{ 466 struct bkey *k = &c->journal.key; 467 struct cache *ca; 468 uint64_t last_seq; 469 unsigned iter, n = 0; 470 atomic_t p; 471 472 while (!atomic_read(&fifo_front(&c->journal.pin))) 473 fifo_pop(&c->journal.pin, p); 474 475 last_seq = last_seq(&c->journal); 476 477 /* Update last_idx */ 478 479 for_each_cache(ca, c, iter) { 480 struct journal_device *ja = &ca->journal; 481 482 while (ja->last_idx != ja->cur_idx && 483 ja->seq[ja->last_idx] < last_seq) 484 ja->last_idx = (ja->last_idx + 1) % 485 ca->sb.njournal_buckets; 486 } 487 488 for_each_cache(ca, c, iter) 489 do_journal_discard(ca); 490 491 if (c->journal.blocks_free) 492 goto out; 493 494 /* 495 * Allocate: 496 * XXX: Sort by free journal space 497 */ 498 499 for_each_cache(ca, c, iter) { 500 struct journal_device *ja = &ca->journal; 501 unsigned next = (ja->cur_idx + 1) % ca->sb.njournal_buckets; 502 503 /* No space available on this device */ 504 if (next == ja->discard_idx) 505 continue; 506 507 ja->cur_idx = next; 508 k->ptr[n++] = PTR(0, 509 bucket_to_sector(c, ca->sb.d[ja->cur_idx]), 510 ca->sb.nr_this_dev); 511 } 512 513 bkey_init(k); 514 SET_KEY_PTRS(k, n); 515 516 if (n) 517 c->journal.blocks_free = c->sb.bucket_size >> c->block_bits; 518out: 519 if (!journal_full(&c->journal)) 520 __closure_wake_up(&c->journal.wait); 521} 522 523void bch_journal_next(struct journal *j) 524{ 525 atomic_t p = { 1 }; 526 527 j->cur = (j->cur == j->w) 528 ? &j->w[1] 529 : &j->w[0]; 530 531 /* 532 * The fifo_push() needs to happen at the same time as j->seq is 533 * incremented for last_seq() to be calculated correctly 534 */ 535 BUG_ON(!fifo_push(&j->pin, p)); 536 atomic_set(&fifo_back(&j->pin), 1); 537 538 j->cur->data->seq = ++j->seq; 539 j->cur->dirty = false; 540 j->cur->need_write = false; 541 j->cur->data->keys = 0; 542 543 if (fifo_full(&j->pin)) 544 pr_debug("journal_pin full (%zu)", fifo_used(&j->pin)); 545} 546 547static void journal_write_endio(struct bio *bio, int error) 548{ 549 struct journal_write *w = bio->bi_private; 550 551 cache_set_err_on(error, w->c, "journal io error"); 552 closure_put(&w->c->journal.io); 553} 554 555static void journal_write(struct closure *); 556 557static void journal_write_done(struct closure *cl) 558{ 559 struct journal *j = container_of(cl, struct journal, io); 560 struct journal_write *w = (j->cur == j->w) 561 ? &j->w[1] 562 : &j->w[0]; 563 564 __closure_wake_up(&w->wait); 565 continue_at_nobarrier(cl, journal_write, system_wq); 566} 567 568static void journal_write_unlock(struct closure *cl) 569{ 570 struct cache_set *c = container_of(cl, struct cache_set, journal.io); 571 572 c->journal.io_in_flight = 0; 573 spin_unlock(&c->journal.lock); 574} 575 576static void journal_write_unlocked(struct closure *cl) 577 __releases(c->journal.lock) 578{ 579 struct cache_set *c = container_of(cl, struct cache_set, journal.io); 580 struct cache *ca; 581 struct journal_write *w = c->journal.cur; 582 struct bkey *k = &c->journal.key; 583 unsigned i, sectors = set_blocks(w->data, block_bytes(c)) * 584 c->sb.block_size; 585 586 struct bio *bio; 587 struct bio_list list; 588 bio_list_init(&list); 589 590 if (!w->need_write) { 591 closure_return_with_destructor(cl, journal_write_unlock); 592 } else if (journal_full(&c->journal)) { 593 journal_reclaim(c); 594 spin_unlock(&c->journal.lock); 595 596 btree_flush_write(c); 597 continue_at(cl, journal_write, system_wq); 598 } 599 600 c->journal.blocks_free -= set_blocks(w->data, block_bytes(c)); 601 602 w->data->btree_level = c->root->level; 603 604 bkey_copy(&w->data->btree_root, &c->root->key); 605 bkey_copy(&w->data->uuid_bucket, &c->uuid_bucket); 606 607 for_each_cache(ca, c, i) 608 w->data->prio_bucket[ca->sb.nr_this_dev] = ca->prio_buckets[0]; 609 610 w->data->magic = jset_magic(&c->sb); 611 w->data->version = BCACHE_JSET_VERSION; 612 w->data->last_seq = last_seq(&c->journal); 613 w->data->csum = csum_set(w->data); 614 615 for (i = 0; i < KEY_PTRS(k); i++) { 616 ca = PTR_CACHE(c, k, i); 617 bio = &ca->journal.bio; 618 619 atomic_long_add(sectors, &ca->meta_sectors_written); 620 621 bio_reset(bio); 622 bio->bi_iter.bi_sector = PTR_OFFSET(k, i); 623 bio->bi_bdev = ca->bdev; 624 bio->bi_rw = REQ_WRITE|REQ_SYNC|REQ_META|REQ_FLUSH|REQ_FUA; 625 bio->bi_iter.bi_size = sectors << 9; 626 627 bio->bi_end_io = journal_write_endio; 628 bio->bi_private = w; 629 bch_bio_map(bio, w->data); 630 631 trace_bcache_journal_write(bio); 632 bio_list_add(&list, bio); 633 634 SET_PTR_OFFSET(k, i, PTR_OFFSET(k, i) + sectors); 635 636 ca->journal.seq[ca->journal.cur_idx] = w->data->seq; 637 } 638 639 atomic_dec_bug(&fifo_back(&c->journal.pin)); 640 bch_journal_next(&c->journal); 641 journal_reclaim(c); 642 643 spin_unlock(&c->journal.lock); 644 645 while ((bio = bio_list_pop(&list))) 646 closure_bio_submit(bio, cl, c->cache[0]); 647 648 continue_at(cl, journal_write_done, NULL); 649} 650 651static void journal_write(struct closure *cl) 652{ 653 struct cache_set *c = container_of(cl, struct cache_set, journal.io); 654 655 spin_lock(&c->journal.lock); 656 journal_write_unlocked(cl); 657} 658 659static void journal_try_write(struct cache_set *c) 660 __releases(c->journal.lock) 661{ 662 struct closure *cl = &c->journal.io; 663 struct journal_write *w = c->journal.cur; 664 665 w->need_write = true; 666 667 if (!c->journal.io_in_flight) { 668 c->journal.io_in_flight = 1; 669 closure_call(cl, journal_write_unlocked, NULL, &c->cl); 670 } else { 671 spin_unlock(&c->journal.lock); 672 } 673} 674 675static struct journal_write *journal_wait_for_write(struct cache_set *c, 676 unsigned nkeys) 677{ 678 size_t sectors; 679 struct closure cl; 680 bool wait = false; 681 682 closure_init_stack(&cl); 683 684 spin_lock(&c->journal.lock); 685 686 while (1) { 687 struct journal_write *w = c->journal.cur; 688 689 sectors = __set_blocks(w->data, w->data->keys + nkeys, 690 block_bytes(c)) * c->sb.block_size; 691 692 if (sectors <= min_t(size_t, 693 c->journal.blocks_free * c->sb.block_size, 694 PAGE_SECTORS << JSET_BITS)) 695 return w; 696 697 if (wait) 698 closure_wait(&c->journal.wait, &cl); 699 700 if (!journal_full(&c->journal)) { 701 if (wait) 702 trace_bcache_journal_entry_full(c); 703 704 /* 705 * XXX: If we were inserting so many keys that they 706 * won't fit in an _empty_ journal write, we'll 707 * deadlock. For now, handle this in 708 * bch_keylist_realloc() - but something to think about. 709 */ 710 BUG_ON(!w->data->keys); 711 712 journal_try_write(c); /* unlocks */ 713 } else { 714 if (wait) 715 trace_bcache_journal_full(c); 716 717 journal_reclaim(c); 718 spin_unlock(&c->journal.lock); 719 720 btree_flush_write(c); 721 } 722 723 closure_sync(&cl); 724 spin_lock(&c->journal.lock); 725 wait = true; 726 } 727} 728 729static void journal_write_work(struct work_struct *work) 730{ 731 struct cache_set *c = container_of(to_delayed_work(work), 732 struct cache_set, 733 journal.work); 734 spin_lock(&c->journal.lock); 735 if (c->journal.cur->dirty) 736 journal_try_write(c); 737 else 738 spin_unlock(&c->journal.lock); 739} 740 741/* 742 * Entry point to the journalling code - bio_insert() and btree_invalidate() 743 * pass bch_journal() a list of keys to be journalled, and then 744 * bch_journal() hands those same keys off to btree_insert_async() 745 */ 746 747atomic_t *bch_journal(struct cache_set *c, 748 struct keylist *keys, 749 struct closure *parent) 750{ 751 struct journal_write *w; 752 atomic_t *ret; 753 754 if (!CACHE_SYNC(&c->sb)) 755 return NULL; 756 757 w = journal_wait_for_write(c, bch_keylist_nkeys(keys)); 758 759 memcpy(bset_bkey_last(w->data), keys->keys, bch_keylist_bytes(keys)); 760 w->data->keys += bch_keylist_nkeys(keys); 761 762 ret = &fifo_back(&c->journal.pin); 763 atomic_inc(ret); 764 765 if (parent) { 766 closure_wait(&w->wait, parent); 767 journal_try_write(c); 768 } else if (!w->dirty) { 769 w->dirty = true; 770 schedule_delayed_work(&c->journal.work, 771 msecs_to_jiffies(c->journal_delay_ms)); 772 spin_unlock(&c->journal.lock); 773 } else { 774 spin_unlock(&c->journal.lock); 775 } 776 777 778 return ret; 779} 780 781void bch_journal_meta(struct cache_set *c, struct closure *cl) 782{ 783 struct keylist keys; 784 atomic_t *ref; 785 786 bch_keylist_init(&keys); 787 788 ref = bch_journal(c, &keys, cl); 789 if (ref) 790 atomic_dec_bug(ref); 791} 792 793void bch_journal_free(struct cache_set *c) 794{ 795 free_pages((unsigned long) c->journal.w[1].data, JSET_BITS); 796 free_pages((unsigned long) c->journal.w[0].data, JSET_BITS); 797 free_fifo(&c->journal.pin); 798} 799 800int bch_journal_alloc(struct cache_set *c) 801{ 802 struct journal *j = &c->journal; 803 804 spin_lock_init(&j->lock); 805 INIT_DELAYED_WORK(&j->work, journal_write_work); 806 807 c->journal_delay_ms = 100; 808 809 j->w[0].c = c; 810 j->w[1].c = c; 811 812 if (!(init_fifo(&j->pin, JOURNAL_PIN, GFP_KERNEL)) || 813 !(j->w[0].data = (void *) __get_free_pages(GFP_KERNEL, JSET_BITS)) || 814 !(j->w[1].data = (void *) __get_free_pages(GFP_KERNEL, JSET_BITS))) 815 return -ENOMEM; 816 817 return 0; 818} 819