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         if (gfs2_is_jdata(ip)) {
 476                 tr->tr_num_buf++;
 477                 list_add(&bd->bd_list_tr, &tr->tr_list_buf);
 478         }
 479         gfs2_log_unlock(sdp);
 480         if (!list_empty(&le->le_list))
 481                 return;
 482
 483         gfs2_trans_add_gl(bd->bd_gl);
 484         if (gfs2_is_jdata(ip)) {
 485                 sdp->sd_log_num_jdata++;
 486                 gfs2_pin(sdp, bd->bd_bh);
 487                 tr->tr_num_databuf_new++;
 488         }
 489         sdp->sd_log_num_databuf++;
 490         gfs2_log_lock(sdp);
 491         list_add(&le->le_list, &sdp->sd_log_le_databuf);
 492         gfs2_log_unlock(sdp);
 493 }
 494
 495 static int gfs2_check_magic(struct buffer_head *bh)
 496 {
 497         struct page *page = bh->b_page;
 498         void *kaddr;
 499         __be32 *ptr;
 500         int rv = 0;
 501
 502         kaddr = kmap_atomic(page, KM_USER0);
 503         ptr = kaddr + bh_offset(bh);
 504         if (*ptr == cpu_to_be32(GFS2_MAGIC))
 505                 rv = 1;
 506         kunmap_atomic(kaddr, KM_USER0);
 507
 508         return rv;
 509 }
 510
 511 /**
 512  * databuf_lo_before_commit - Scan the data buffers, writing as we go
 513  *
 514  * Here we scan through the lists of buffers and make the assumption
 515  * that any buffer thats been pinned is being journaled, and that
 516  * any unpinned buffer is an ordered write data buffer and therefore
 517  * will be written back rather than journaled.
 518  */
 519 static void databuf_lo_before_commit(struct gfs2_sbd *sdp)
 520 {
 521         LIST_HEAD(started);
 522         struct gfs2_bufdata *bd1 = NULL, *bd2, *bdt;
 523         struct buffer_head *bh = NULL,*bh1 = NULL;
 524         struct gfs2_log_descriptor *ld;
 525         unsigned int limit;
 526         unsigned int total_dbuf = sdp->sd_log_num_databuf;
 527         unsigned int total_jdata = sdp->sd_log_num_jdata;
 528         unsigned int num, n;
 529         __be64 *ptr = NULL;
 530
 531         limit = databuf_limit(sdp);
 532
 533         /*
 534          * Start writing ordered buffers, write journaled buffers
 535          * into the log along with a header
 536          */
 537         gfs2_log_lock(sdp);
 538         bd2 = bd1 = list_prepare_entry(bd1, &sdp->sd_log_le_databuf,
 539                                        bd_le.le_list);
 540         while(total_dbuf) {
 541                 num = total_jdata;
 542                 if (num > limit)
 543                         num = limit;
 544                 n = 0;
 545                 list_for_each_entry_safe_continue(bd1, bdt,
 546                                                   &sdp->sd_log_le_databuf,
 547                                                   bd_le.le_list) {
 548                         /* store off the buffer head in a local ptr since
 549                          * gfs2_bufdata might change when we drop the log lock
 550                          */
 551                         bh1 = bd1->bd_bh;
 552
 553                         /* An ordered write buffer */
 554                         if (bh1 && !buffer_pinned(bh1)) {
 555                                 list_move(&bd1->bd_le.le_list, &started);
 556                                 if (bd1 == bd2) {
 557                                         bd2 = NULL;
 558                                         bd2 = list_prepare_entry(bd2,
 559                                                         &sdp->sd_log_le_databuf,
 560                                                         bd_le.le_list);
 561                                 }
 562                                 total_dbuf--;
 563                                 if (bh1) {
 564                                         if (buffer_dirty(bh1)) {
 565                                                 get_bh(bh1);
 566
 567                                                 gfs2_log_unlock(sdp);
 568
 569                                                 ll_rw_block(SWRITE, 1, &bh1);
 570                                                 brelse(bh1);
 571
 572                                                 gfs2_log_lock(sdp);
 573                                         }
 574                                         continue;
 575                                 }
 576                                 continue;
 577                         } else if (bh1) { /* A journaled buffer */
 578                                 int magic;
 579                                 gfs2_log_unlock(sdp);
 580                                 if (!bh) {
 581                                         bh = gfs2_log_get_buf(sdp);
 582                                         ld = (struct gfs2_log_descriptor *)
 583                                              bh->b_data;
 584                                         ptr = (__be64 *)(bh->b_data +
 585                                                          DATABUF_OFFSET);
 586                                         ld->ld_header.mh_magic =
 587                                                 cpu_to_be32(GFS2_MAGIC);
 588                                         ld->ld_header.mh_type =
 589                                                 cpu_to_be32(GFS2_METATYPE_LD);
 590                                         ld->ld_header.mh_format =
 591                                                 cpu_to_be32(GFS2_FORMAT_LD);
 592                                         ld->ld_type =
 593                                                 cpu_to_be32(GFS2_LOG_DESC_JDATA);
 594                                         ld->ld_length = cpu_to_be32(num + 1);
 595                                         ld->ld_data1 = cpu_to_be32(num);
 596                                         ld->ld_data2 = cpu_to_be32(0);
 597                                         memset(ld->ld_reserved, 0, sizeof(ld->ld_reserved));
 598                                 }
 599                                 magic = gfs2_check_magic(bh1);
 600                                 *ptr++ = cpu_to_be64(bh1->b_blocknr);
 601                                 *ptr++ = cpu_to_be64((__u64)magic);
 602                                 clear_buffer_escaped(bh1);
 603                                 if (unlikely(magic != 0))
 604                                         set_buffer_escaped(bh1);
 605                                 gfs2_log_lock(sdp);
 606                                 if (++n >= num)
 607                                         break;
 608                         } else if (!bh1) {
 609                                 total_dbuf--;
 610                                 sdp->sd_log_num_databuf--;
 611                                 list_del_init(&bd1->bd_le.le_list);
 612                                 if (bd1 == bd2) {
 613                                         bd2 = NULL;
 614                                         bd2 = list_prepare_entry(bd2,
 615                                                 &sdp->sd_log_le_databuf,
 616                                                 bd_le.le_list);
 617                                 }
 618                                 kmem_cache_free(gfs2_bufdata_cachep, bd1);
 619                         }
 620                 }
 621                 gfs2_log_unlock(sdp);
 622                 if (bh) {
 623                         set_buffer_mapped(bh);
 624                         set_buffer_dirty(bh);
 625                         ll_rw_block(WRITE, 1, &bh);
 626                         bh = NULL;
 627                 }
 628                 n = 0;
 629                 gfs2_log_lock(sdp);
 630                 list_for_each_entry_continue(bd2, &sdp->sd_log_le_databuf,
 631                                              bd_le.le_list) {
 632                         if (!bd2->bd_bh)
 633                                 continue;
 634                         /* copy buffer if it needs escaping */
 635                         gfs2_log_unlock(sdp);
 636                         if (unlikely(buffer_escaped(bd2->bd_bh))) {
 637                                 void *kaddr;
 638                                 struct page *page = bd2->bd_bh->b_page;
 639                                 bh = gfs2_log_get_buf(sdp);
 640                                 kaddr = kmap_atomic(page, KM_USER0);
 641                                 memcpy(bh->b_data,
 642                                        kaddr + bh_offset(bd2->bd_bh),
 643                                        sdp->sd_sb.sb_bsize);
 644                                 kunmap_atomic(kaddr, KM_USER0);
 645                                 *(__be32 *)bh->b_data = 0;
 646                         } else {
 647                                 bh = gfs2_log_fake_buf(sdp, bd2->bd_bh);
 648                         }
 649                         set_buffer_dirty(bh);
 650                         ll_rw_block(WRITE, 1, &bh);
 651                         gfs2_log_lock(sdp);
 652                         if (++n >= num)
 653                                 break;
 654                 }
 655                 bh = NULL;
 656                 total_dbuf -= num;
 657                 total_jdata -= num;
 658         }
 659         gfs2_log_unlock(sdp);
 660
 661         /* Wait on all ordered buffers */
 662         while (!list_empty(&started)) {
 663                 gfs2_log_lock(sdp);
 664                 bd1 = list_entry(started.next, struct gfs2_bufdata,
 665                                  bd_le.le_list);
 666                 list_del_init(&bd1->bd_le.le_list);
 667                 sdp->sd_log_num_databuf--;
 668                 bh = bd1->bd_bh;
 669                 if (bh) {
 670                         bh->b_private = NULL;
 671                         get_bh(bh);
 672                         gfs2_log_unlock(sdp);
 673                         wait_on_buffer(bh);
 674                         brelse(bh);
 675                 } else
 676                         gfs2_log_unlock(sdp);
 677
 678                 kmem_cache_free(gfs2_bufdata_cachep, bd1);
 679         }
 680
 681         /* We've removed all the ordered write bufs here, so only jdata left */
 682         gfs2_assert_warn(sdp, sdp->sd_log_num_databuf == sdp->sd_log_num_jdata);
 683 }
 684
 685 static int databuf_lo_scan_elements(struct gfs2_jdesc *jd, unsigned int start,
 686                                     struct gfs2_log_descriptor *ld,
 687                                     __be64 *ptr, int pass)
 688 {
 689         struct gfs2_inode *ip = GFS2_I(jd->jd_inode);
 690         struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode);
 691         struct gfs2_glock *gl = ip->i_gl;
 692         unsigned int blks = be32_to_cpu(ld->ld_data1);
 693         struct buffer_head *bh_log, *bh_ip;
 694         u64 blkno;
 695         u64 esc;
 696         int error = 0;
 697
 698         if (pass != 1 || be32_to_cpu(ld->ld_type) != GFS2_LOG_DESC_JDATA)
 699                 return 0;
 700
 701         gfs2_replay_incr_blk(sdp, &start);
 702         for (; blks; gfs2_replay_incr_blk(sdp, &start), blks--) {
 703                 blkno = be64_to_cpu(*ptr++);
 704                 esc = be64_to_cpu(*ptr++);
 705
 706                 sdp->sd_found_blocks++;
 707
 708                 if (gfs2_revoke_check(sdp, blkno, start))
 709                         continue;
 710
 711                 error = gfs2_replay_read_block(jd, start, &bh_log);
 712                 if (error)
 713                         return error;
 714
 715                 bh_ip = gfs2_meta_new(gl, blkno);
 716                 memcpy(bh_ip->b_data, bh_log->b_data, bh_log->b_size);
 717
 718                 /* Unescape */
 719                 if (esc) {
 720                         __be32 *eptr = (__be32 *)bh_ip->b_data;
 721                         *eptr = cpu_to_be32(GFS2_MAGIC);
 722                 }
 723                 mark_buffer_dirty(bh_ip);
 724
 725                 brelse(bh_log);
 726                 brelse(bh_ip);
 727                 if (error)
 728                         break;
 729
 730                 sdp->sd_replayed_blocks++;
 731         }
 732
 733         return error;
 734 }
 735
 736 /* FIXME: sort out accounting for log blocks etc. */
 737
 738 static void databuf_lo_after_scan(struct gfs2_jdesc *jd, int error, int pass)
 739 {
 740         struct gfs2_inode *ip = GFS2_I(jd->jd_inode);
 741         struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode);
 742
 743         if (error) {
 744                 gfs2_meta_sync(ip->i_gl);
 745                 return;
 746         }
 747         if (pass != 1)
 748                 return;
 749
 750         /* data sync? */
 751         gfs2_meta_sync(ip->i_gl);
 752
 753         fs_info(sdp, "jid=%u: Replayed %u of %u data blocks\n",
 754                 jd->jd_jid, sdp->sd_replayed_blocks, sdp->sd_found_blocks);
 755 }
 756
 757 static void databuf_lo_after_commit(struct gfs2_sbd *sdp, struct gfs2_ail *ai)
 758 {
 759         struct list_head *head = &sdp->sd_log_le_databuf;
 760         struct gfs2_bufdata *bd;
 761
 762         while (!list_empty(head)) {
 763                 bd = list_entry(head->next, struct gfs2_bufdata, bd_le.le_list);
 764                 list_del_init(&bd->bd_le.le_list);
 765                 sdp->sd_log_num_databuf--;
 766                 sdp->sd_log_num_jdata--;
 767                 gfs2_unpin(sdp, bd->bd_bh, ai);
 768         }
 769         gfs2_assert_warn(sdp, !sdp->sd_log_num_databuf);
 770         gfs2_assert_warn(sdp, !sdp->sd_log_num_jdata);
 771 }
 772
 773
 774 const struct gfs2_log_operations gfs2_glock_lops = {
 775         .lo_add = glock_lo_add,
 776         .lo_after_commit = glock_lo_after_commit,
 777         .lo_name = "glock",
 778 };
 779
 780 const struct gfs2_log_operations gfs2_buf_lops = {
 781         .lo_add = buf_lo_add,
 782         .lo_incore_commit = buf_lo_incore_commit,
 783         .lo_before_commit = buf_lo_before_commit,
 784         .lo_after_commit = buf_lo_after_commit,
 785         .lo_before_scan = buf_lo_before_scan,
 786         .lo_scan_elements = buf_lo_scan_elements,
 787         .lo_after_scan = buf_lo_after_scan,
 788         .lo_name = "buf",
 789 };
 790
 791 const struct gfs2_log_operations gfs2_revoke_lops = {
 792         .lo_add = revoke_lo_add,
 793         .lo_before_commit = revoke_lo_before_commit,
 794         .lo_before_scan = revoke_lo_before_scan,
 795         .lo_scan_elements = revoke_lo_scan_elements,
 796         .lo_after_scan = revoke_lo_after_scan,
 797         .lo_name = "revoke",
 798 };
 799
 800 const struct gfs2_log_operations gfs2_rg_lops = {
 801         .lo_add = rg_lo_add,
 802         .lo_after_commit = rg_lo_after_commit,
 803         .lo_name = "rg",
 804 };
 805
 806 const struct gfs2_log_operations gfs2_databuf_lops = {
 807         .lo_add = databuf_lo_add,
 808         .lo_incore_commit = buf_lo_incore_commit,
 809         .lo_before_commit = databuf_lo_before_commit,
 810         .lo_after_commit = databuf_lo_after_commit,
 811         .lo_scan_elements = databuf_lo_scan_elements,
 812         .lo_after_scan = databuf_lo_after_scan,
 813         .lo_name = "databuf",
 814 };
 815
 816 const struct gfs2_log_operations *gfs2_log_ops[] = {
 817         &gfs2_glock_lops,
 818         &gfs2_buf_lops,
 819         &gfs2_revoke_lops,
 820         &gfs2_rg_lops,
 821         &gfs2_databuf_lops,
 822         NULL,
 823 };
 824