1 /* 2 * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved. 3 * Copyright (C) 2004-2006 Red Hat, Inc. All rights reserved. 4 * 5 * This copyrighted material is made available to anyone wishing to use, 6 * modify, copy, or redistribute it subject to the terms and conditions 7 * of the GNU General Public License version 2. 8 */ 9 10 #include <linux/sched.h> 11 #include <linux/slab.h> 12 #include <linux/spinlock.h> 13 #include <linux/completion.h> 14 #include <linux/buffer_head.h> 15 #include <linux/gfs2_ondisk.h> 16 #include <linux/bio.h> 17 #include <linux/fs.h> 18 19 #include "gfs2.h" 20 #include "incore.h" 21 #include "inode.h" 22 #include "glock.h" 23 #include "log.h" 24 #include "lops.h" 25 #include "meta_io.h" 26 #include "recovery.h" 27 #include "rgrp.h" 28 #include "trans.h" 29 #include "util.h" 30 #include "trace_gfs2.h" 31 32 /** 33 * gfs2_pin - Pin a buffer in memory 34 * @sdp: The superblock 35 * @bh: The buffer to be pinned 36 * 37 * The log lock must be held when calling this function 38 */ 39 static void gfs2_pin(struct gfs2_sbd *sdp, struct buffer_head *bh) 40 { 41 struct gfs2_bufdata *bd; 42 43 gfs2_assert_withdraw(sdp, test_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags)); 44 45 clear_buffer_dirty(bh); 46 if (test_set_buffer_pinned(bh)) 47 gfs2_assert_withdraw(sdp, 0); 48 if (!buffer_uptodate(bh)) 49 gfs2_io_error_bh(sdp, bh); 50 bd = bh->b_private; 51 /* If this buffer is in the AIL and it has already been written 52 * to in-place disk block, remove it from the AIL. 53 */ 54 if (bd->bd_ail) 55 list_move(&bd->bd_ail_st_list, &bd->bd_ail->ai_ail2_list); 56 get_bh(bh); 57 trace_gfs2_pin(bd, 1); 58 } 59 60 /** 61 * gfs2_unpin - Unpin a buffer 62 * @sdp: the filesystem the buffer belongs to 63 * @bh: The buffer to unpin 64 * @ai: 65 * 66 */ 67 68 static void gfs2_unpin(struct gfs2_sbd *sdp, struct buffer_head *bh, 69 struct gfs2_ail *ai) 70 { 71 struct gfs2_bufdata *bd = bh->b_private; 72 73 gfs2_assert_withdraw(sdp, buffer_uptodate(bh)); 74 75 if (!buffer_pinned(bh)) 76 gfs2_assert_withdraw(sdp, 0); 77 78 lock_buffer(bh); 79 mark_buffer_dirty(bh); 80 clear_buffer_pinned(bh); 81 82 gfs2_log_lock(sdp); 83 if (bd->bd_ail) { 84 list_del(&bd->bd_ail_st_list); 85 brelse(bh); 86 } else { 87 struct gfs2_glock *gl = bd->bd_gl; 88 list_add(&bd->bd_ail_gl_list, &gl->gl_ail_list); 89 atomic_inc(&gl->gl_ail_count); 90 } 91 bd->bd_ail = ai; 92 list_add(&bd->bd_ail_st_list, &ai->ai_ail1_list); 93 clear_bit(GLF_LFLUSH, &bd->bd_gl->gl_flags); 94 trace_gfs2_pin(bd, 0); 95 gfs2_log_unlock(sdp); 96 unlock_buffer(bh); 97 } 98 99 100 static inline struct gfs2_log_descriptor *bh_log_desc(struct buffer_head *bh) 101 { 102 return (struct gfs2_log_descriptor *)bh->b_data; 103 } 104 105 static inline __be64 *bh_log_ptr(struct buffer_head *bh) 106 { 107 struct gfs2_log_descriptor *ld = bh_log_desc(bh); 108 return (__force __be64 *)(ld + 1); 109 } 110 111 static inline __be64 *bh_ptr_end(struct buffer_head *bh) 112 { 113 return (__force __be64 *)(bh->b_data + bh->b_size); 114 } 115 116 117 static struct buffer_head *gfs2_get_log_desc(struct gfs2_sbd *sdp, u32 ld_type) 118 { 119 struct buffer_head *bh = gfs2_log_get_buf(sdp); 120 struct gfs2_log_descriptor *ld = bh_log_desc(bh); 121 ld->ld_header.mh_magic = cpu_to_be32(GFS2_MAGIC); 122 ld->ld_header.mh_type = cpu_to_be32(GFS2_METATYPE_LD); 123 ld->ld_header.mh_format = cpu_to_be32(GFS2_FORMAT_LD); 124 ld->ld_type = cpu_to_be32(ld_type); 125 ld->ld_length = 0; 126 ld->ld_data1 = 0; 127 ld->ld_data2 = 0; 128 memset(ld->ld_reserved, 0, sizeof(ld->ld_reserved)); 129 return bh; 130 } 131 132 static void buf_lo_add(struct gfs2_sbd *sdp, struct gfs2_log_element *le) 133 { 134 struct gfs2_bufdata *bd = container_of(le, struct gfs2_bufdata, bd_le); 135 struct gfs2_trans *tr; 136 137 lock_buffer(bd->bd_bh); 138 gfs2_log_lock(sdp); 139 if (!list_empty(&bd->bd_list_tr)) 140 goto out; 141 tr = current->journal_info; 142 tr->tr_touched = 1; 143 tr->tr_num_buf++; 144 list_add(&bd->bd_list_tr, &tr->tr_list_buf); 145 if (!list_empty(&le->le_list)) 146 goto out; 147 set_bit(GLF_LFLUSH, &bd->bd_gl->gl_flags); 148 set_bit(GLF_DIRTY, &bd->bd_gl->gl_flags); 149 gfs2_meta_check(sdp, bd->bd_bh); 150 gfs2_pin(sdp, bd->bd_bh); 151 sdp->sd_log_num_buf++; 152 list_add(&le->le_list, &sdp->sd_log_le_buf); 153 tr->tr_num_buf_new++; 154 out: 155 gfs2_log_unlock(sdp); 156 unlock_buffer(bd->bd_bh); 157 } 158 159 static void buf_lo_before_commit(struct gfs2_sbd *sdp) 160 { 161 struct buffer_head *bh; 162 struct gfs2_log_descriptor *ld; 163 struct gfs2_bufdata *bd1 = NULL, *bd2; 164 unsigned int total; 165 unsigned int limit; 166 unsigned int num; 167 unsigned n; 168 __be64 *ptr; 169 170 limit = buf_limit(sdp); 171 /* for 4k blocks, limit = 503 */ 172 173 gfs2_log_lock(sdp); 174 total = sdp->sd_log_num_buf; 175 bd1 = bd2 = list_prepare_entry(bd1, &sdp->sd_log_le_buf, bd_le.le_list); 176 while(total) { 177 num = total; 178 if (total > limit) 179 num = limit; 180 gfs2_log_unlock(sdp); 181 bh = gfs2_get_log_desc(sdp, GFS2_LOG_DESC_METADATA); 182 gfs2_log_lock(sdp); 183 ld = bh_log_desc(bh); 184 ptr = bh_log_ptr(bh); 185 ld->ld_length = cpu_to_be32(num + 1); 186 ld->ld_data1 = cpu_to_be32(num); 187 188 n = 0; 189 list_for_each_entry_continue(bd1, &sdp->sd_log_le_buf, 190 bd_le.le_list) { 191 *ptr++ = cpu_to_be64(bd1->bd_bh->b_blocknr); 192 if (++n >= num) 193 break; 194 } 195 196 gfs2_log_unlock(sdp); 197 submit_bh(WRITE_SYNC_PLUG, bh); 198 gfs2_log_lock(sdp); 199 200 n = 0; 201 list_for_each_entry_continue(bd2, &sdp->sd_log_le_buf, 202 bd_le.le_list) { 203 get_bh(bd2->bd_bh); 204 gfs2_log_unlock(sdp); 205 lock_buffer(bd2->bd_bh); 206 bh = gfs2_log_fake_buf(sdp, bd2->bd_bh); 207 submit_bh(WRITE_SYNC_PLUG, bh); 208 gfs2_log_lock(sdp); 209 if (++n >= num) 210 break; 211 } 212 213 BUG_ON(total < num); 214 total -= num; 215 } 216 gfs2_log_unlock(sdp); 217 } 218 219 static void buf_lo_after_commit(struct gfs2_sbd *sdp, struct gfs2_ail *ai) 220 { 221 struct list_head *head = &sdp->sd_log_le_buf; 222 struct gfs2_bufdata *bd; 223 224 while (!list_empty(head)) { 225 bd = list_entry(head->next, struct gfs2_bufdata, bd_le.le_list); 226 list_del_init(&bd->bd_le.le_list); 227 sdp->sd_log_num_buf--; 228 229 gfs2_unpin(sdp, bd->bd_bh, ai); 230 } 231 gfs2_assert_warn(sdp, !sdp->sd_log_num_buf); 232 } 233 234 static void buf_lo_before_scan(struct gfs2_jdesc *jd, 235 struct gfs2_log_header_host *head, int pass) 236 { 237 struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode); 238 239 if (pass != 0) 240 return; 241 242 sdp->sd_found_blocks = 0; 243 sdp->sd_replayed_blocks = 0; 244 } 245 246 static int buf_lo_scan_elements(struct gfs2_jdesc *jd, unsigned int start, 247 struct gfs2_log_descriptor *ld, __be64 *ptr, 248 int pass) 249 { 250 struct gfs2_inode *ip = GFS2_I(jd->jd_inode); 251 struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode); 252 struct gfs2_glock *gl = ip->i_gl; 253 unsigned int blks = be32_to_cpu(ld->ld_data1); 254 struct buffer_head *bh_log, *bh_ip; 255 u64 blkno; 256 int error = 0; 257 258 if (pass != 1 || be32_to_cpu(ld->ld_type) != GFS2_LOG_DESC_METADATA) 259 return 0; 260 261 gfs2_replay_incr_blk(sdp, &start); 262 263 for (; blks; gfs2_replay_incr_blk(sdp, &start), blks--) { 264 blkno = be64_to_cpu(*ptr++); 265 266 sdp->sd_found_blocks++; 267 268 if (gfs2_revoke_check(sdp, blkno, start)) 269 continue; 270 271 error = gfs2_replay_read_block(jd, start, &bh_log); 272 if (error) 273 return error; 274 275 bh_ip = gfs2_meta_new(gl, blkno); 276 memcpy(bh_ip->b_data, bh_log->b_data, bh_log->b_size); 277 278 if (gfs2_meta_check(sdp, bh_ip)) 279 error = -EIO; 280 else 281 mark_buffer_dirty(bh_ip); 282 283 brelse(bh_log); 284 brelse(bh_ip); 285 286 if (error) 287 break; 288 289 sdp->sd_replayed_blocks++; 290 } 291 292 return error; 293 } 294 295 static void buf_lo_after_scan(struct gfs2_jdesc *jd, int error, int pass) 296 { 297 struct gfs2_inode *ip = GFS2_I(jd->jd_inode); 298 struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode); 299 300 if (error) { 301 gfs2_meta_sync(ip->i_gl); 302 return; 303 } 304 if (pass != 1) 305 return; 306 307 gfs2_meta_sync(ip->i_gl); 308 309 fs_info(sdp, "jid=%u: Replayed %u of %u blocks\n", 310 jd->jd_jid, sdp->sd_replayed_blocks, sdp->sd_found_blocks); 311 } 312 313 static void revoke_lo_add(struct gfs2_sbd *sdp, struct gfs2_log_element *le) 314 { 315 struct gfs2_trans *tr; 316 317 tr = current->journal_info; 318 tr->tr_touched = 1; 319 tr->tr_num_revoke++; 320 sdp->sd_log_num_revoke++; 321 list_add(&le->le_list, &sdp->sd_log_le_revoke); 322 } 323 324 static void revoke_lo_before_commit(struct gfs2_sbd *sdp) 325 { 326 struct gfs2_log_descriptor *ld; 327 struct gfs2_meta_header *mh; 328 struct buffer_head *bh; 329 unsigned int offset; 330 struct list_head *head = &sdp->sd_log_le_revoke; 331 struct gfs2_bufdata *bd; 332 333 if (!sdp->sd_log_num_revoke) 334 return; 335 336 bh = gfs2_get_log_desc(sdp, GFS2_LOG_DESC_REVOKE); 337 ld = bh_log_desc(bh); 338 ld->ld_length = cpu_to_be32(gfs2_struct2blk(sdp, sdp->sd_log_num_revoke, 339 sizeof(u64))); 340 ld->ld_data1 = cpu_to_be32(sdp->sd_log_num_revoke); 341 offset = sizeof(struct gfs2_log_descriptor); 342 343 while (!list_empty(head)) { 344 bd = list_entry(head->next, struct gfs2_bufdata, bd_le.le_list); 345 list_del_init(&bd->bd_le.le_list); 346 sdp->sd_log_num_revoke--; 347 348 if (offset + sizeof(u64) > sdp->sd_sb.sb_bsize) { 349 submit_bh(WRITE_SYNC_PLUG, bh); 350 351 bh = gfs2_log_get_buf(sdp); 352 mh = (struct gfs2_meta_header *)bh->b_data; 353 mh->mh_magic = cpu_to_be32(GFS2_MAGIC); 354 mh->mh_type = cpu_to_be32(GFS2_METATYPE_LB); 355 mh->mh_format = cpu_to_be32(GFS2_FORMAT_LB); 356 offset = sizeof(struct gfs2_meta_header); 357 } 358 359 *(__be64 *)(bh->b_data + offset) = cpu_to_be64(bd->bd_blkno); 360 kmem_cache_free(gfs2_bufdata_cachep, bd); 361 362 offset += sizeof(u64); 363 } 364 gfs2_assert_withdraw(sdp, !sdp->sd_log_num_revoke); 365 366 submit_bh(WRITE_SYNC_PLUG, bh); 367 } 368 369 static void revoke_lo_before_scan(struct gfs2_jdesc *jd, 370 struct gfs2_log_header_host *head, int pass) 371 { 372 struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode); 373 374 if (pass != 0) 375 return; 376 377 sdp->sd_found_revokes = 0; 378 sdp->sd_replay_tail = head->lh_tail; 379 } 380 381 static int revoke_lo_scan_elements(struct gfs2_jdesc *jd, unsigned int start, 382 struct gfs2_log_descriptor *ld, __be64 *ptr, 383 int pass) 384 { 385 struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode); 386 unsigned int blks = be32_to_cpu(ld->ld_length); 387 unsigned int revokes = be32_to_cpu(ld->ld_data1); 388 struct buffer_head *bh; 389 unsigned int offset; 390 u64 blkno; 391 int first = 1; 392 int error; 393 394 if (pass != 0 || be32_to_cpu(ld->ld_type) != GFS2_LOG_DESC_REVOKE) 395 return 0; 396 397 offset = sizeof(struct gfs2_log_descriptor); 398 399 for (; blks; gfs2_replay_incr_blk(sdp, &start), blks--) { 400 error = gfs2_replay_read_block(jd, start, &bh); 401 if (error) 402 return error; 403 404 if (!first) 405 gfs2_metatype_check(sdp, bh, GFS2_METATYPE_LB); 406 407 while (offset + sizeof(u64) <= sdp->sd_sb.sb_bsize) { 408 blkno = be64_to_cpu(*(__be64 *)(bh->b_data + offset)); 409 410 error = gfs2_revoke_add(sdp, blkno, start); 411 if (error < 0) { 412 brelse(bh); 413 return error; 414 } 415 else if (error) 416 sdp->sd_found_revokes++; 417 418 if (!--revokes) 419 break; 420 offset += sizeof(u64); 421 } 422 423 brelse(bh); 424 offset = sizeof(struct gfs2_meta_header); 425 first = 0; 426 } 427 428 return 0; 429 } 430 431 static void revoke_lo_after_scan(struct gfs2_jdesc *jd, int error, int pass) 432 { 433 struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode); 434 435 if (error) { 436 gfs2_revoke_clean(sdp); 437 return; 438 } 439 if (pass != 1) 440 return; 441 442 fs_info(sdp, "jid=%u: Found %u revoke tags\n", 443 jd->jd_jid, sdp->sd_found_revokes); 444 445 gfs2_revoke_clean(sdp); 446 } 447 448 static void rg_lo_add(struct gfs2_sbd *sdp, struct gfs2_log_element *le) 449 { 450 struct gfs2_rgrpd *rgd; 451 struct gfs2_trans *tr = current->journal_info; 452 453 tr->tr_touched = 1; 454 455 rgd = container_of(le, struct gfs2_rgrpd, rd_le); 456 457 gfs2_log_lock(sdp); 458 if (!list_empty(&le->le_list)){ 459 gfs2_log_unlock(sdp); 460 return; 461 } 462 gfs2_rgrp_bh_hold(rgd); 463 sdp->sd_log_num_rg++; 464 list_add(&le->le_list, &sdp->sd_log_le_rg); 465 gfs2_log_unlock(sdp); 466 } 467 468 static void rg_lo_after_commit(struct gfs2_sbd *sdp, struct gfs2_ail *ai) 469 { 470 struct list_head *head = &sdp->sd_log_le_rg; 471 struct gfs2_rgrpd *rgd; 472 473 while (!list_empty(head)) { 474 rgd = list_entry(head->next, struct gfs2_rgrpd, rd_le.le_list); 475 list_del_init(&rgd->rd_le.le_list); 476 sdp->sd_log_num_rg--; 477 478 gfs2_rgrp_repolish_clones(rgd); 479 gfs2_rgrp_bh_put(rgd); 480 } 481 gfs2_assert_warn(sdp, !sdp->sd_log_num_rg); 482 } 483 484 /** 485 * databuf_lo_add - Add a databuf to the transaction. 486 * 487 * This is used in two distinct cases: 488 * i) In ordered write mode 489 * We put the data buffer on a list so that we can ensure that its 490 * synced to disk at the right time 491 * ii) In journaled data mode 492 * We need to journal the data block in the same way as metadata in 493 * the functions above. The difference is that here we have a tag 494 * which is two __be64's being the block number (as per meta data) 495 * and a flag which says whether the data block needs escaping or 496 * not. This means we need a new log entry for each 251 or so data 497 * blocks, which isn't an enormous overhead but twice as much as 498 * for normal metadata blocks. 499 */ 500 static void databuf_lo_add(struct gfs2_sbd *sdp, struct gfs2_log_element *le) 501 { 502 struct gfs2_bufdata *bd = container_of(le, struct gfs2_bufdata, bd_le); 503 struct gfs2_trans *tr = current->journal_info; 504 struct address_space *mapping = bd->bd_bh->b_page->mapping; 505 struct gfs2_inode *ip = GFS2_I(mapping->host); 506 507 lock_buffer(bd->bd_bh); 508 gfs2_log_lock(sdp); 509 if (tr) { 510 if (!list_empty(&bd->bd_list_tr)) 511 goto out; 512 tr->tr_touched = 1; 513 if (gfs2_is_jdata(ip)) { 514 tr->tr_num_buf++; 515 list_add(&bd->bd_list_tr, &tr->tr_list_buf); 516 } 517 } 518 if (!list_empty(&le->le_list)) 519 goto out; 520 521 set_bit(GLF_LFLUSH, &bd->bd_gl->gl_flags); 522 set_bit(GLF_DIRTY, &bd->bd_gl->gl_flags); 523 if (gfs2_is_jdata(ip)) { 524 gfs2_pin(sdp, bd->bd_bh); 525 tr->tr_num_databuf_new++; 526 sdp->sd_log_num_databuf++; 527 list_add(&le->le_list, &sdp->sd_log_le_databuf); 528 } else { 529 list_add(&le->le_list, &sdp->sd_log_le_ordered); 530 } 531 out: 532 gfs2_log_unlock(sdp); 533 unlock_buffer(bd->bd_bh); 534 } 535 536 static void gfs2_check_magic(struct buffer_head *bh) 537 { 538 void *kaddr; 539 __be32 *ptr; 540 541 clear_buffer_escaped(bh); 542 kaddr = kmap_atomic(bh->b_page, KM_USER0); 543 ptr = kaddr + bh_offset(bh); 544 if (*ptr == cpu_to_be32(GFS2_MAGIC)) 545 set_buffer_escaped(bh); 546 kunmap_atomic(kaddr, KM_USER0); 547 } 548 549 static void gfs2_write_blocks(struct gfs2_sbd *sdp, struct buffer_head *bh, 550 struct list_head *list, struct list_head *done, 551 unsigned int n) 552 { 553 struct buffer_head *bh1; 554 struct gfs2_log_descriptor *ld; 555 struct gfs2_bufdata *bd; 556 __be64 *ptr; 557 558 if (!bh) 559 return; 560 561 ld = bh_log_desc(bh); 562 ld->ld_length = cpu_to_be32(n + 1); 563 ld->ld_data1 = cpu_to_be32(n); 564 565 ptr = bh_log_ptr(bh); 566 567 get_bh(bh); 568 submit_bh(WRITE_SYNC_PLUG, bh); 569 gfs2_log_lock(sdp); 570 while(!list_empty(list)) { 571 bd = list_entry(list->next, struct gfs2_bufdata, bd_le.le_list); 572 list_move_tail(&bd->bd_le.le_list, done); 573 get_bh(bd->bd_bh); 574 while (be64_to_cpu(*ptr) != bd->bd_bh->b_blocknr) { 575 gfs2_log_incr_head(sdp); 576 ptr += 2; 577 } 578 gfs2_log_unlock(sdp); 579 lock_buffer(bd->bd_bh); 580 if (buffer_escaped(bd->bd_bh)) { 581 void *kaddr; 582 bh1 = gfs2_log_get_buf(sdp); 583 kaddr = kmap_atomic(bd->bd_bh->b_page, KM_USER0); 584 memcpy(bh1->b_data, kaddr + bh_offset(bd->bd_bh), 585 bh1->b_size); 586 kunmap_atomic(kaddr, KM_USER0); 587 *(__be32 *)bh1->b_data = 0; 588 clear_buffer_escaped(bd->bd_bh); 589 unlock_buffer(bd->bd_bh); 590 brelse(bd->bd_bh); 591 } else { 592 bh1 = gfs2_log_fake_buf(sdp, bd->bd_bh); 593 } 594 submit_bh(WRITE_SYNC_PLUG, bh1); 595 gfs2_log_lock(sdp); 596 ptr += 2; 597 } 598 gfs2_log_unlock(sdp); 599 brelse(bh); 600 } 601 602 /** 603 * databuf_lo_before_commit - Scan the data buffers, writing as we go 604 * 605 */ 606 607 static void databuf_lo_before_commit(struct gfs2_sbd *sdp) 608 { 609 struct gfs2_bufdata *bd = NULL; 610 struct buffer_head *bh = NULL; 611 unsigned int n = 0; 612 __be64 *ptr = NULL, *end = NULL; 613 LIST_HEAD(processed); 614 LIST_HEAD(in_progress); 615 616 gfs2_log_lock(sdp); 617 while (!list_empty(&sdp->sd_log_le_databuf)) { 618 if (ptr == end) { 619 gfs2_log_unlock(sdp); 620 gfs2_write_blocks(sdp, bh, &in_progress, &processed, n); 621 n = 0; 622 bh = gfs2_get_log_desc(sdp, GFS2_LOG_DESC_JDATA); 623 ptr = bh_log_ptr(bh); 624 end = bh_ptr_end(bh) - 1; 625 gfs2_log_lock(sdp); 626 continue; 627 } 628 bd = list_entry(sdp->sd_log_le_databuf.next, struct gfs2_bufdata, bd_le.le_list); 629 list_move_tail(&bd->bd_le.le_list, &in_progress); 630 gfs2_check_magic(bd->bd_bh); 631 *ptr++ = cpu_to_be64(bd->bd_bh->b_blocknr); 632 *ptr++ = cpu_to_be64(buffer_escaped(bh) ? 1 : 0); 633 n++; 634 } 635 gfs2_log_unlock(sdp); 636 gfs2_write_blocks(sdp, bh, &in_progress, &processed, n); 637 gfs2_log_lock(sdp); 638 list_splice(&processed, &sdp->sd_log_le_databuf); 639 gfs2_log_unlock(sdp); 640 } 641 642 static int databuf_lo_scan_elements(struct gfs2_jdesc *jd, unsigned int start, 643 struct gfs2_log_descriptor *ld, 644 __be64 *ptr, int pass) 645 { 646 struct gfs2_inode *ip = GFS2_I(jd->jd_inode); 647 struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode); 648 struct gfs2_glock *gl = ip->i_gl; 649 unsigned int blks = be32_to_cpu(ld->ld_data1); 650 struct buffer_head *bh_log, *bh_ip; 651 u64 blkno; 652 u64 esc; 653 int error = 0; 654 655 if (pass != 1 || be32_to_cpu(ld->ld_type) != GFS2_LOG_DESC_JDATA) 656 return 0; 657 658 gfs2_replay_incr_blk(sdp, &start); 659 for (; blks; gfs2_replay_incr_blk(sdp, &start), blks--) { 660 blkno = be64_to_cpu(*ptr++); 661 esc = be64_to_cpu(*ptr++); 662 663 sdp->sd_found_blocks++; 664 665 if (gfs2_revoke_check(sdp, blkno, start)) 666 continue; 667 668 error = gfs2_replay_read_block(jd, start, &bh_log); 669 if (error) 670 return error; 671 672 bh_ip = gfs2_meta_new(gl, blkno); 673 memcpy(bh_ip->b_data, bh_log->b_data, bh_log->b_size); 674 675 /* Unescape */ 676 if (esc) { 677 __be32 *eptr = (__be32 *)bh_ip->b_data; 678 *eptr = cpu_to_be32(GFS2_MAGIC); 679 } 680 mark_buffer_dirty(bh_ip); 681 682 brelse(bh_log); 683 brelse(bh_ip); 684 if (error) 685 break; 686 687 sdp->sd_replayed_blocks++; 688 } 689 690 return error; 691 } 692 693 /* FIXME: sort out accounting for log blocks etc. */ 694 695 static void databuf_lo_after_scan(struct gfs2_jdesc *jd, int error, int pass) 696 { 697 struct gfs2_inode *ip = GFS2_I(jd->jd_inode); 698 struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode); 699 700 if (error) { 701 gfs2_meta_sync(ip->i_gl); 702 return; 703 } 704 if (pass != 1) 705 return; 706 707 /* data sync? */ 708 gfs2_meta_sync(ip->i_gl); 709 710 fs_info(sdp, "jid=%u: Replayed %u of %u data blocks\n", 711 jd->jd_jid, sdp->sd_replayed_blocks, sdp->sd_found_blocks); 712 } 713 714 static void databuf_lo_after_commit(struct gfs2_sbd *sdp, struct gfs2_ail *ai) 715 { 716 struct list_head *head = &sdp->sd_log_le_databuf; 717 struct gfs2_bufdata *bd; 718 719 while (!list_empty(head)) { 720 bd = list_entry(head->next, struct gfs2_bufdata, bd_le.le_list); 721 list_del_init(&bd->bd_le.le_list); 722 sdp->sd_log_num_databuf--; 723 gfs2_unpin(sdp, bd->bd_bh, ai); 724 } 725 gfs2_assert_warn(sdp, !sdp->sd_log_num_databuf); 726 } 727 728 729 const struct gfs2_log_operations gfs2_buf_lops = { 730 .lo_add = buf_lo_add, 731 .lo_before_commit = buf_lo_before_commit, 732 .lo_after_commit = buf_lo_after_commit, 733 .lo_before_scan = buf_lo_before_scan, 734 .lo_scan_elements = buf_lo_scan_elements, 735 .lo_after_scan = buf_lo_after_scan, 736 .lo_name = "buf", 737 }; 738 739 const struct gfs2_log_operations gfs2_revoke_lops = { 740 .lo_add = revoke_lo_add, 741 .lo_before_commit = revoke_lo_before_commit, 742 .lo_before_scan = revoke_lo_before_scan, 743 .lo_scan_elements = revoke_lo_scan_elements, 744 .lo_after_scan = revoke_lo_after_scan, 745 .lo_name = "revoke", 746 }; 747 748 const struct gfs2_log_operations gfs2_rg_lops = { 749 .lo_add = rg_lo_add, 750 .lo_after_commit = rg_lo_after_commit, 751 .lo_name = "rg", 752 }; 753 754 const struct gfs2_log_operations gfs2_databuf_lops = { 755 .lo_add = databuf_lo_add, 756 .lo_before_commit = databuf_lo_before_commit, 757 .lo_after_commit = databuf_lo_after_commit, 758 .lo_scan_elements = databuf_lo_scan_elements, 759 .lo_after_scan = databuf_lo_after_scan, 760 .lo_name = "databuf", 761 }; 762 763 const struct gfs2_log_operations *gfs2_log_ops[] = { 764 &gfs2_databuf_lops, 765 &gfs2_buf_lops, 766 &gfs2_rg_lops, 767 &gfs2_revoke_lops, 768 NULL, 769 }; 770 771