fs/gfs2/lops.c

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