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