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