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 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