blob: 17c5b5d7dc88c4b73e00c5918f97473df15b354f [file] [log] [blame]
David Teiglandb3b94fa2006-01-16 16:50:04 +00001/*
2 * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
Steven Whitehouse3a8a9a12006-05-18 15:09:15 -04003 * Copyright (C) 2004-2006 Red Hat, Inc. All rights reserved.
David Teiglandb3b94fa2006-01-16 16:50:04 +00004 *
5 * This copyrighted material is made available to anyone wishing to use,
6 * modify, copy, or redistribute it subject to the terms and conditions
Steven Whitehousee9fc2aa2006-09-01 11:05:15 -04007 * of the GNU General Public License version 2.
David Teiglandb3b94fa2006-01-16 16:50:04 +00008 */
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>
Steven Whitehouse75ca61c2012-03-08 12:10:23 +000015#include <linux/mempool.h>
Steven Whitehouse5c676f62006-02-27 17:23:27 -050016#include <linux/gfs2_ondisk.h>
Steven Whitehousec969f58c2009-04-07 14:13:01 +010017#include <linux/bio.h>
18#include <linux/fs.h>
Benjamin Marzinski7f632572013-05-07 09:58:49 -050019#include <linux/list_sort.h>
David Teiglandb3b94fa2006-01-16 16:50:04 +000020
21#include "gfs2.h"
Steven Whitehouse5c676f62006-02-27 17:23:27 -050022#include "incore.h"
Robert Peterson2332c442007-06-18 14:50:20 -050023#include "inode.h"
David Teiglandb3b94fa2006-01-16 16:50:04 +000024#include "glock.h"
25#include "log.h"
26#include "lops.h"
27#include "meta_io.h"
28#include "recovery.h"
29#include "rgrp.h"
30#include "trans.h"
Steven Whitehouse5c676f62006-02-27 17:23:27 -050031#include "util.h"
Steven Whitehouse63997772009-06-12 08:49:20 +010032#include "trace_gfs2.h"
David Teiglandb3b94fa2006-01-16 16:50:04 +000033
Steven Whitehouse9b9107a2007-08-27 13:54:05 +010034/**
35 * gfs2_pin - Pin a buffer in memory
36 * @sdp: The superblock
37 * @bh: The buffer to be pinned
38 *
39 * The log lock must be held when calling this function
40 */
Steven Whitehouse767f4332012-12-14 12:52:14 +000041void gfs2_pin(struct gfs2_sbd *sdp, struct buffer_head *bh)
Steven Whitehouse9b9107a2007-08-27 13:54:05 +010042{
43 struct gfs2_bufdata *bd;
44
Steven Whitehouse29687a22011-03-30 16:33:25 +010045 BUG_ON(!current->journal_info);
Steven Whitehouse9b9107a2007-08-27 13:54:05 +010046
47 clear_buffer_dirty(bh);
48 if (test_set_buffer_pinned(bh))
49 gfs2_assert_withdraw(sdp, 0);
50 if (!buffer_uptodate(bh))
51 gfs2_io_error_bh(sdp, bh);
52 bd = bh->b_private;
53 /* If this buffer is in the AIL and it has already been written
54 * to in-place disk block, remove it from the AIL.
55 */
Steven Whitehousec618e872011-03-14 12:40:29 +000056 spin_lock(&sdp->sd_ail_lock);
Benjamin Marzinski16ca9412013-04-05 20:31:46 -050057 if (bd->bd_tr)
58 list_move(&bd->bd_ail_st_list, &bd->bd_tr->tr_ail2_list);
Steven Whitehousec618e872011-03-14 12:40:29 +000059 spin_unlock(&sdp->sd_ail_lock);
Steven Whitehouse9b9107a2007-08-27 13:54:05 +010060 get_bh(bh);
Benjamin Marzinski5e687ea2010-05-04 14:29:16 -050061 atomic_inc(&sdp->sd_log_pinned);
Steven Whitehouse63997772009-06-12 08:49:20 +010062 trace_gfs2_pin(bd, 1);
Steven Whitehouse9b9107a2007-08-27 13:54:05 +010063}
64
Bob Peterson7c9ca622011-08-31 09:53:19 +010065static bool buffer_is_rgrp(const struct gfs2_bufdata *bd)
66{
67 return bd->bd_gl->gl_name.ln_type == LM_TYPE_RGRP;
68}
69
70static void maybe_release_space(struct gfs2_bufdata *bd)
71{
72 struct gfs2_glock *gl = bd->bd_gl;
73 struct gfs2_sbd *sdp = gl->gl_sbd;
74 struct gfs2_rgrpd *rgd = gl->gl_object;
75 unsigned int index = bd->bd_bh->b_blocknr - gl->gl_name.ln_number;
76 struct gfs2_bitmap *bi = rgd->rd_bits + index;
77
78 if (bi->bi_clone == 0)
79 return;
80 if (sdp->sd_args.ar_discard)
Steven Whitehouse66fc0612012-02-08 12:58:32 +000081 gfs2_rgrp_send_discards(sdp, rgd->rd_data0, bd->bd_bh, bi, 1, NULL);
Bob Peterson7c9ca622011-08-31 09:53:19 +010082 memcpy(bi->bi_clone + bi->bi_offset,
83 bd->bd_bh->b_data + bi->bi_offset, bi->bi_len);
84 clear_bit(GBF_FULL, &bi->bi_flags);
85 rgd->rd_free_clone = rgd->rd_free;
86}
87
Steven Whitehouse9b9107a2007-08-27 13:54:05 +010088/**
89 * gfs2_unpin - Unpin a buffer
90 * @sdp: the filesystem the buffer belongs to
91 * @bh: The buffer to unpin
92 * @ai:
Steven Whitehouse29687a22011-03-30 16:33:25 +010093 * @flags: The inode dirty flags
Steven Whitehouse9b9107a2007-08-27 13:54:05 +010094 *
95 */
96
97static void gfs2_unpin(struct gfs2_sbd *sdp, struct buffer_head *bh,
Benjamin Marzinski16ca9412013-04-05 20:31:46 -050098 struct gfs2_trans *tr)
Steven Whitehouse9b9107a2007-08-27 13:54:05 +010099{
100 struct gfs2_bufdata *bd = bh->b_private;
101
Steven Whitehouse29687a22011-03-30 16:33:25 +0100102 BUG_ON(!buffer_uptodate(bh));
103 BUG_ON(!buffer_pinned(bh));
Steven Whitehouse9b9107a2007-08-27 13:54:05 +0100104
105 lock_buffer(bh);
106 mark_buffer_dirty(bh);
107 clear_buffer_pinned(bh);
108
Bob Peterson7c9ca622011-08-31 09:53:19 +0100109 if (buffer_is_rgrp(bd))
110 maybe_release_space(bd);
111
Dave Chinnerd6a079e2011-03-11 11:52:25 +0000112 spin_lock(&sdp->sd_ail_lock);
Benjamin Marzinski16ca9412013-04-05 20:31:46 -0500113 if (bd->bd_tr) {
Steven Whitehouse9b9107a2007-08-27 13:54:05 +0100114 list_del(&bd->bd_ail_st_list);
115 brelse(bh);
116 } else {
117 struct gfs2_glock *gl = bd->bd_gl;
118 list_add(&bd->bd_ail_gl_list, &gl->gl_ail_list);
119 atomic_inc(&gl->gl_ail_count);
120 }
Benjamin Marzinski16ca9412013-04-05 20:31:46 -0500121 bd->bd_tr = tr;
122 list_add(&bd->bd_ail_st_list, &tr->tr_ail1_list);
Dave Chinnerd6a079e2011-03-11 11:52:25 +0000123 spin_unlock(&sdp->sd_ail_lock);
124
Steven Whitehouse29687a22011-03-30 16:33:25 +0100125 clear_bit(GLF_LFLUSH, &bd->bd_gl->gl_flags);
Steven Whitehouse63997772009-06-12 08:49:20 +0100126 trace_gfs2_pin(bd, 0);
Steven Whitehouse9b9107a2007-08-27 13:54:05 +0100127 unlock_buffer(bh);
Benjamin Marzinski5e687ea2010-05-04 14:29:16 -0500128 atomic_dec(&sdp->sd_log_pinned);
Steven Whitehouse9b9107a2007-08-27 13:54:05 +0100129}
130
Steven Whitehousee8c92ed2012-04-16 09:28:31 +0100131static void gfs2_log_incr_head(struct gfs2_sbd *sdp)
Steven Whitehouse16615be2007-09-17 10:59:52 +0100132{
Steven Whitehousee8c92ed2012-04-16 09:28:31 +0100133 BUG_ON((sdp->sd_log_flush_head == sdp->sd_log_tail) &&
134 (sdp->sd_log_flush_head != sdp->sd_log_head));
135
136 if (++sdp->sd_log_flush_head == sdp->sd_jdesc->jd_blocks) {
137 sdp->sd_log_flush_head = 0;
138 sdp->sd_log_flush_wrapped = 1;
139 }
Steven Whitehouse16615be2007-09-17 10:59:52 +0100140}
141
Steven Whitehousee8c92ed2012-04-16 09:28:31 +0100142static u64 gfs2_log_bmap(struct gfs2_sbd *sdp)
Steven Whitehouse16615be2007-09-17 10:59:52 +0100143{
Steven Whitehousee8c92ed2012-04-16 09:28:31 +0100144 unsigned int lbn = sdp->sd_log_flush_head;
145 struct gfs2_journal_extent *je;
146 u64 block;
Steven Whitehouse16615be2007-09-17 10:59:52 +0100147
Steven Whitehousee8c92ed2012-04-16 09:28:31 +0100148 list_for_each_entry(je, &sdp->sd_jdesc->extent_list, extent_list) {
149 if (lbn >= je->lblock && lbn < je->lblock + je->blocks) {
150 block = je->dblock + lbn - je->lblock;
151 gfs2_log_incr_head(sdp);
152 return block;
153 }
154 }
155
156 return -1;
Steven Whitehouse16615be2007-09-17 10:59:52 +0100157}
158
Steven Whitehouse47ac5532012-02-03 15:21:59 +0000159/**
Steven Whitehousee8c92ed2012-04-16 09:28:31 +0100160 * gfs2_end_log_write_bh - end log write of pagecache data with buffers
161 * @sdp: The superblock
162 * @bvec: The bio_vec
163 * @error: The i/o status
164 *
165 * This finds the relavent buffers and unlocks then and sets the
166 * error flag according to the status of the i/o request. This is
167 * used when the log is writing data which has an in-place version
168 * that is pinned in the pagecache.
169 */
170
171static void gfs2_end_log_write_bh(struct gfs2_sbd *sdp, struct bio_vec *bvec,
172 int error)
173{
174 struct buffer_head *bh, *next;
175 struct page *page = bvec->bv_page;
176 unsigned size;
177
178 bh = page_buffers(page);
179 size = bvec->bv_len;
180 while (bh_offset(bh) < bvec->bv_offset)
181 bh = bh->b_this_page;
182 do {
183 if (error)
184 set_buffer_write_io_error(bh);
185 unlock_buffer(bh);
186 next = bh->b_this_page;
187 size -= bh->b_size;
188 brelse(bh);
189 bh = next;
190 } while(bh && size);
191}
192
193/**
194 * gfs2_end_log_write - end of i/o to the log
195 * @bio: The bio
196 * @error: Status of i/o request
197 *
198 * Each bio_vec contains either data from the pagecache or data
199 * relating to the log itself. Here we iterate over the bio_vec
200 * array, processing both kinds of data.
Steven Whitehouse47ac5532012-02-03 15:21:59 +0000201 *
202 */
203
Steven Whitehousee8c92ed2012-04-16 09:28:31 +0100204static void gfs2_end_log_write(struct bio *bio, int error)
Steven Whitehouse47ac5532012-02-03 15:21:59 +0000205{
Steven Whitehousee8c92ed2012-04-16 09:28:31 +0100206 struct gfs2_sbd *sdp = bio->bi_private;
207 struct bio_vec *bvec;
208 struct page *page;
209 int i;
Steven Whitehouse47ac5532012-02-03 15:21:59 +0000210
Steven Whitehousee8c92ed2012-04-16 09:28:31 +0100211 if (error) {
212 sdp->sd_log_error = error;
213 fs_err(sdp, "Error %d writing to log\n", error);
214 }
215
Steven Whitehousee97e5482013-05-21 12:49:07 +0100216 bio_for_each_segment_all(bvec, bio, i) {
Steven Whitehousee8c92ed2012-04-16 09:28:31 +0100217 page = bvec->bv_page;
218 if (page_has_buffers(page))
219 gfs2_end_log_write_bh(sdp, bvec, error);
220 else
221 mempool_free(page, gfs2_page_pool);
222 }
223
224 bio_put(bio);
Steven Whitehouse47ac5532012-02-03 15:21:59 +0000225 if (atomic_dec_and_test(&sdp->sd_log_in_flight))
226 wake_up(&sdp->sd_log_flush_wait);
227}
228
229/**
Steven Whitehousee8c92ed2012-04-16 09:28:31 +0100230 * gfs2_log_flush_bio - Submit any pending log bio
231 * @sdp: The superblock
232 * @rw: The rw flags
Steven Whitehouse47ac5532012-02-03 15:21:59 +0000233 *
Steven Whitehousee8c92ed2012-04-16 09:28:31 +0100234 * Submit any pending part-built or full bio to the block device. If
235 * there is no pending bio, then this is a no-op.
Steven Whitehouse47ac5532012-02-03 15:21:59 +0000236 */
237
Steven Whitehousee8c92ed2012-04-16 09:28:31 +0100238void gfs2_log_flush_bio(struct gfs2_sbd *sdp, int rw)
Steven Whitehouse47ac5532012-02-03 15:21:59 +0000239{
Steven Whitehousee8c92ed2012-04-16 09:28:31 +0100240 if (sdp->sd_log_bio) {
241 atomic_inc(&sdp->sd_log_in_flight);
242 submit_bio(rw, sdp->sd_log_bio);
243 sdp->sd_log_bio = NULL;
244 }
Steven Whitehouse47ac5532012-02-03 15:21:59 +0000245}
246
247/**
Steven Whitehousee8c92ed2012-04-16 09:28:31 +0100248 * gfs2_log_alloc_bio - Allocate a new bio for log writing
249 * @sdp: The superblock
250 * @blkno: The next device block number we want to write to
Steven Whitehouse47ac5532012-02-03 15:21:59 +0000251 *
Steven Whitehousee8c92ed2012-04-16 09:28:31 +0100252 * This should never be called when there is a cached bio in the
253 * super block. When it returns, there will be a cached bio in the
254 * super block which will have as many bio_vecs as the device is
255 * happy to handle.
256 *
257 * Returns: Newly allocated bio
Steven Whitehouse47ac5532012-02-03 15:21:59 +0000258 */
259
Steven Whitehousee8c92ed2012-04-16 09:28:31 +0100260static struct bio *gfs2_log_alloc_bio(struct gfs2_sbd *sdp, u64 blkno)
Steven Whitehouse47ac5532012-02-03 15:21:59 +0000261{
Steven Whitehousee8c92ed2012-04-16 09:28:31 +0100262 struct super_block *sb = sdp->sd_vfs;
263 unsigned nrvecs = bio_get_nr_vecs(sb->s_bdev);
264 struct bio *bio;
Steven Whitehouse47ac5532012-02-03 15:21:59 +0000265
Steven Whitehousee8c92ed2012-04-16 09:28:31 +0100266 BUG_ON(sdp->sd_log_bio);
267
268 while (1) {
269 bio = bio_alloc(GFP_NOIO, nrvecs);
270 if (likely(bio))
271 break;
272 nrvecs = max(nrvecs/2, 1U);
273 }
274
275 bio->bi_sector = blkno * (sb->s_blocksize >> 9);
276 bio->bi_bdev = sb->s_bdev;
277 bio->bi_end_io = gfs2_end_log_write;
278 bio->bi_private = sdp;
279
280 sdp->sd_log_bio = bio;
281
282 return bio;
Steven Whitehouse47ac5532012-02-03 15:21:59 +0000283}
284
285/**
Steven Whitehousee8c92ed2012-04-16 09:28:31 +0100286 * gfs2_log_get_bio - Get cached log bio, or allocate a new one
287 * @sdp: The superblock
288 * @blkno: The device block number we want to write to
289 *
290 * If there is a cached bio, then if the next block number is sequential
291 * with the previous one, return it, otherwise flush the bio to the
292 * device. If there is not a cached bio, or we just flushed it, then
293 * allocate a new one.
294 *
295 * Returns: The bio to use for log writes
296 */
297
298static struct bio *gfs2_log_get_bio(struct gfs2_sbd *sdp, u64 blkno)
299{
300 struct bio *bio = sdp->sd_log_bio;
301 u64 nblk;
302
303 if (bio) {
Kent Overstreetf73a1c72012-09-25 15:05:12 -0700304 nblk = bio_end_sector(bio);
Steven Whitehousee8c92ed2012-04-16 09:28:31 +0100305 nblk >>= sdp->sd_fsb2bb_shift;
306 if (blkno == nblk)
307 return bio;
308 gfs2_log_flush_bio(sdp, WRITE);
309 }
310
311 return gfs2_log_alloc_bio(sdp, blkno);
312}
313
314
315/**
316 * gfs2_log_write - write to log
Steven Whitehouse47ac5532012-02-03 15:21:59 +0000317 * @sdp: the filesystem
Steven Whitehousee8c92ed2012-04-16 09:28:31 +0100318 * @page: the page to write
319 * @size: the size of the data to write
320 * @offset: the offset within the page
Steven Whitehouse47ac5532012-02-03 15:21:59 +0000321 *
Steven Whitehousee8c92ed2012-04-16 09:28:31 +0100322 * Try and add the page segment to the current bio. If that fails,
323 * submit the current bio to the device and create a new one, and
324 * then add the page segment to that.
Steven Whitehouse47ac5532012-02-03 15:21:59 +0000325 */
326
Steven Whitehousee8c92ed2012-04-16 09:28:31 +0100327static void gfs2_log_write(struct gfs2_sbd *sdp, struct page *page,
328 unsigned size, unsigned offset)
Steven Whitehouse47ac5532012-02-03 15:21:59 +0000329{
Steven Whitehousee8c92ed2012-04-16 09:28:31 +0100330 u64 blkno = gfs2_log_bmap(sdp);
331 struct bio *bio;
332 int ret;
Steven Whitehouse47ac5532012-02-03 15:21:59 +0000333
Steven Whitehousee8c92ed2012-04-16 09:28:31 +0100334 bio = gfs2_log_get_bio(sdp, blkno);
335 ret = bio_add_page(bio, page, size, offset);
336 if (ret == 0) {
337 gfs2_log_flush_bio(sdp, WRITE);
338 bio = gfs2_log_alloc_bio(sdp, blkno);
339 ret = bio_add_page(bio, page, size, offset);
340 WARN_ON(ret == 0);
341 }
Steven Whitehouse47ac5532012-02-03 15:21:59 +0000342}
Steven Whitehouse16615be2007-09-17 10:59:52 +0100343
Steven Whitehousee8c92ed2012-04-16 09:28:31 +0100344/**
345 * gfs2_log_write_bh - write a buffer's content to the log
346 * @sdp: The super block
347 * @bh: The buffer pointing to the in-place location
348 *
349 * This writes the content of the buffer to the next available location
350 * in the log. The buffer will be unlocked once the i/o to the log has
351 * completed.
352 */
353
354static void gfs2_log_write_bh(struct gfs2_sbd *sdp, struct buffer_head *bh)
Steven Whitehouse16615be2007-09-17 10:59:52 +0100355{
Steven Whitehousee8c92ed2012-04-16 09:28:31 +0100356 gfs2_log_write(sdp, bh->b_page, bh->b_size, bh_offset(bh));
357}
358
359/**
360 * gfs2_log_write_page - write one block stored in a page, into the log
361 * @sdp: The superblock
362 * @page: The struct page
363 *
364 * This writes the first block-sized part of the page into the log. Note
365 * that the page must have been allocated from the gfs2_page_pool mempool
366 * and that after this has been called, ownership has been transferred and
367 * the page may be freed at any time.
368 */
369
370void gfs2_log_write_page(struct gfs2_sbd *sdp, struct page *page)
371{
372 struct super_block *sb = sdp->sd_vfs;
373 gfs2_log_write(sdp, page, sb->s_blocksize, 0);
374}
375
Steven Whitehousedad30e92012-04-16 09:40:00 +0100376static struct page *gfs2_get_log_desc(struct gfs2_sbd *sdp, u32 ld_type,
377 u32 ld_length, u32 ld_data1)
Steven Whitehousee8c92ed2012-04-16 09:28:31 +0100378{
Steven Whitehouse144a4c22012-04-19 10:38:50 +0100379 struct page *page = mempool_alloc(gfs2_page_pool, GFP_NOIO);
Steven Whitehousee8c92ed2012-04-16 09:28:31 +0100380 struct gfs2_log_descriptor *ld = page_address(page);
381 clear_page(ld);
Steven Whitehouse16615be2007-09-17 10:59:52 +0100382 ld->ld_header.mh_magic = cpu_to_be32(GFS2_MAGIC);
383 ld->ld_header.mh_type = cpu_to_be32(GFS2_METATYPE_LD);
384 ld->ld_header.mh_format = cpu_to_be32(GFS2_FORMAT_LD);
385 ld->ld_type = cpu_to_be32(ld_type);
Steven Whitehousedad30e92012-04-16 09:40:00 +0100386 ld->ld_length = cpu_to_be32(ld_length);
387 ld->ld_data1 = cpu_to_be32(ld_data1);
Steven Whitehouse16615be2007-09-17 10:59:52 +0100388 ld->ld_data2 = 0;
Steven Whitehousee8c92ed2012-04-16 09:28:31 +0100389 return page;
Steven Whitehouse16615be2007-09-17 10:59:52 +0100390}
391
Steven Whitehousedad30e92012-04-16 09:40:00 +0100392static void gfs2_check_magic(struct buffer_head *bh)
393{
394 void *kaddr;
395 __be32 *ptr;
396
397 clear_buffer_escaped(bh);
398 kaddr = kmap_atomic(bh->b_page);
399 ptr = kaddr + bh_offset(bh);
400 if (*ptr == cpu_to_be32(GFS2_MAGIC))
401 set_buffer_escaped(bh);
402 kunmap_atomic(kaddr);
403}
404
Benjamin Marzinski7f632572013-05-07 09:58:49 -0500405static int blocknr_cmp(void *priv, struct list_head *a, struct list_head *b)
406{
407 struct gfs2_bufdata *bda, *bdb;
408
409 bda = list_entry(a, struct gfs2_bufdata, bd_list);
410 bdb = list_entry(b, struct gfs2_bufdata, bd_list);
411
412 if (bda->bd_bh->b_blocknr < bdb->bd_bh->b_blocknr)
413 return -1;
414 if (bda->bd_bh->b_blocknr > bdb->bd_bh->b_blocknr)
415 return 1;
416 return 0;
417}
418
Steven Whitehousedad30e92012-04-16 09:40:00 +0100419static void gfs2_before_commit(struct gfs2_sbd *sdp, unsigned int limit,
420 unsigned int total, struct list_head *blist,
421 bool is_databuf)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000422{
David Teiglandb3b94fa2006-01-16 16:50:04 +0000423 struct gfs2_log_descriptor *ld;
424 struct gfs2_bufdata *bd1 = NULL, *bd2;
Steven Whitehousee8c92ed2012-04-16 09:28:31 +0100425 struct page *page;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000426 unsigned int num;
427 unsigned n;
428 __be64 *ptr;
429
Bob Peterson905d2ae2007-07-24 14:05:31 -0500430 gfs2_log_lock(sdp);
Benjamin Marzinski7f632572013-05-07 09:58:49 -0500431 list_sort(NULL, blist, blocknr_cmp);
Bob Petersonc0752aa2012-05-01 12:00:34 -0400432 bd1 = bd2 = list_prepare_entry(bd1, blist, bd_list);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000433 while(total) {
434 num = total;
435 if (total > limit)
436 num = limit;
Bob Peterson905d2ae2007-07-24 14:05:31 -0500437 gfs2_log_unlock(sdp);
Bob Peterson4a586812013-05-24 15:02:49 -0400438 page = gfs2_get_log_desc(sdp,
439 is_databuf ? GFS2_LOG_DESC_JDATA :
440 GFS2_LOG_DESC_METADATA, num + 1, num);
Steven Whitehousee8c92ed2012-04-16 09:28:31 +0100441 ld = page_address(page);
Bob Peterson905d2ae2007-07-24 14:05:31 -0500442 gfs2_log_lock(sdp);
Steven Whitehousee8c92ed2012-04-16 09:28:31 +0100443 ptr = (__be64 *)(ld + 1);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000444
445 n = 0;
Bob Petersonc0752aa2012-05-01 12:00:34 -0400446 list_for_each_entry_continue(bd1, blist, bd_list) {
David Teiglandb3b94fa2006-01-16 16:50:04 +0000447 *ptr++ = cpu_to_be64(bd1->bd_bh->b_blocknr);
Steven Whitehousedad30e92012-04-16 09:40:00 +0100448 if (is_databuf) {
449 gfs2_check_magic(bd1->bd_bh);
450 *ptr++ = cpu_to_be64(buffer_escaped(bd1->bd_bh) ? 1 : 0);
451 }
David Teiglandb3b94fa2006-01-16 16:50:04 +0000452 if (++n >= num)
453 break;
454 }
455
Bob Peterson905d2ae2007-07-24 14:05:31 -0500456 gfs2_log_unlock(sdp);
Steven Whitehousee8c92ed2012-04-16 09:28:31 +0100457 gfs2_log_write_page(sdp, page);
Bob Peterson905d2ae2007-07-24 14:05:31 -0500458 gfs2_log_lock(sdp);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000459
460 n = 0;
Bob Petersonc0752aa2012-05-01 12:00:34 -0400461 list_for_each_entry_continue(bd2, blist, bd_list) {
Steven Whitehouse16615be2007-09-17 10:59:52 +0100462 get_bh(bd2->bd_bh);
Bob Peterson905d2ae2007-07-24 14:05:31 -0500463 gfs2_log_unlock(sdp);
Steven Whitehouse16615be2007-09-17 10:59:52 +0100464 lock_buffer(bd2->bd_bh);
Steven Whitehousedad30e92012-04-16 09:40:00 +0100465
466 if (buffer_escaped(bd2->bd_bh)) {
467 void *kaddr;
468 page = mempool_alloc(gfs2_page_pool, GFP_NOIO);
469 ptr = page_address(page);
470 kaddr = kmap_atomic(bd2->bd_bh->b_page);
471 memcpy(ptr, kaddr + bh_offset(bd2->bd_bh),
472 bd2->bd_bh->b_size);
473 kunmap_atomic(kaddr);
474 *(__be32 *)ptr = 0;
475 clear_buffer_escaped(bd2->bd_bh);
476 unlock_buffer(bd2->bd_bh);
477 brelse(bd2->bd_bh);
478 gfs2_log_write_page(sdp, page);
479 } else {
480 gfs2_log_write_bh(sdp, bd2->bd_bh);
481 }
Bob Peterson905d2ae2007-07-24 14:05:31 -0500482 gfs2_log_lock(sdp);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000483 if (++n >= num)
484 break;
485 }
486
Bob Peterson905d2ae2007-07-24 14:05:31 -0500487 BUG_ON(total < num);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000488 total -= num;
489 }
Bob Peterson905d2ae2007-07-24 14:05:31 -0500490 gfs2_log_unlock(sdp);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000491}
492
Steven Whitehousedad30e92012-04-16 09:40:00 +0100493static void buf_lo_before_commit(struct gfs2_sbd *sdp)
494{
495 unsigned int limit = buf_limit(sdp); /* 503 for 4k blocks */
496
497 gfs2_before_commit(sdp, limit, sdp->sd_log_num_buf,
498 &sdp->sd_log_le_buf, 0);
499}
500
Benjamin Marzinski16ca9412013-04-05 20:31:46 -0500501static void buf_lo_after_commit(struct gfs2_sbd *sdp, struct gfs2_trans *tr)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000502{
503 struct list_head *head = &sdp->sd_log_le_buf;
504 struct gfs2_bufdata *bd;
505
Benjamin Marzinski16ca9412013-04-05 20:31:46 -0500506 if (tr == NULL) {
507 gfs2_assert(sdp, list_empty(head));
508 return;
509 }
510
David Teiglandb3b94fa2006-01-16 16:50:04 +0000511 while (!list_empty(head)) {
Bob Petersonc0752aa2012-05-01 12:00:34 -0400512 bd = list_entry(head->next, struct gfs2_bufdata, bd_list);
513 list_del_init(&bd->bd_list);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000514 sdp->sd_log_num_buf--;
515
Benjamin Marzinski16ca9412013-04-05 20:31:46 -0500516 gfs2_unpin(sdp, bd->bd_bh, tr);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000517 }
518 gfs2_assert_warn(sdp, !sdp->sd_log_num_buf);
519}
520
521static void buf_lo_before_scan(struct gfs2_jdesc *jd,
Al Viro55167622006-10-13 21:47:13 -0400522 struct gfs2_log_header_host *head, int pass)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000523{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400524 struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000525
526 if (pass != 0)
527 return;
528
529 sdp->sd_found_blocks = 0;
530 sdp->sd_replayed_blocks = 0;
531}
532
533static int buf_lo_scan_elements(struct gfs2_jdesc *jd, unsigned int start,
534 struct gfs2_log_descriptor *ld, __be64 *ptr,
535 int pass)
536{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400537 struct gfs2_inode *ip = GFS2_I(jd->jd_inode);
538 struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode);
Steven Whitehouse5c676f62006-02-27 17:23:27 -0500539 struct gfs2_glock *gl = ip->i_gl;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000540 unsigned int blks = be32_to_cpu(ld->ld_data1);
541 struct buffer_head *bh_log, *bh_ip;
Steven Whitehousecd915492006-09-04 12:49:07 -0400542 u64 blkno;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000543 int error = 0;
544
545 if (pass != 1 || be32_to_cpu(ld->ld_type) != GFS2_LOG_DESC_METADATA)
546 return 0;
547
548 gfs2_replay_incr_blk(sdp, &start);
549
550 for (; blks; gfs2_replay_incr_blk(sdp, &start), blks--) {
551 blkno = be64_to_cpu(*ptr++);
552
553 sdp->sd_found_blocks++;
554
555 if (gfs2_revoke_check(sdp, blkno, start))
556 continue;
557
558 error = gfs2_replay_read_block(jd, start, &bh_log);
Steven Whitehouse82ffa512006-09-04 14:47:06 -0400559 if (error)
560 return error;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000561
562 bh_ip = gfs2_meta_new(gl, blkno);
563 memcpy(bh_ip->b_data, bh_log->b_data, bh_log->b_size);
564
565 if (gfs2_meta_check(sdp, bh_ip))
566 error = -EIO;
567 else
568 mark_buffer_dirty(bh_ip);
569
570 brelse(bh_log);
571 brelse(bh_ip);
572
573 if (error)
574 break;
575
576 sdp->sd_replayed_blocks++;
577 }
578
579 return error;
580}
581
582static void buf_lo_after_scan(struct gfs2_jdesc *jd, int error, int pass)
583{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400584 struct gfs2_inode *ip = GFS2_I(jd->jd_inode);
585 struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000586
587 if (error) {
Steven Whitehouse7276b3b2006-09-21 17:05:23 -0400588 gfs2_meta_sync(ip->i_gl);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000589 return;
590 }
591 if (pass != 1)
592 return;
593
Steven Whitehouse7276b3b2006-09-21 17:05:23 -0400594 gfs2_meta_sync(ip->i_gl);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000595
596 fs_info(sdp, "jid=%u: Replayed %u of %u blocks\n",
597 jd->jd_jid, sdp->sd_replayed_blocks, sdp->sd_found_blocks);
598}
599
David Teiglandb3b94fa2006-01-16 16:50:04 +0000600static void revoke_lo_before_commit(struct gfs2_sbd *sdp)
601{
David Teiglandb3b94fa2006-01-16 16:50:04 +0000602 struct gfs2_meta_header *mh;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000603 unsigned int offset;
604 struct list_head *head = &sdp->sd_log_le_revoke;
Steven Whitehouse82e86082007-09-02 15:39:43 +0100605 struct gfs2_bufdata *bd;
Steven Whitehousee8c92ed2012-04-16 09:28:31 +0100606 struct page *page;
Steven Whitehousedad30e92012-04-16 09:40:00 +0100607 unsigned int length;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000608
Benjamin Marzinski5d054962013-06-14 11:38:29 -0500609 gfs2_write_revokes(sdp);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000610 if (!sdp->sd_log_num_revoke)
611 return;
612
Steven Whitehousedad30e92012-04-16 09:40:00 +0100613 length = gfs2_struct2blk(sdp, sdp->sd_log_num_revoke, sizeof(u64));
614 page = gfs2_get_log_desc(sdp, GFS2_LOG_DESC_REVOKE, length, sdp->sd_log_num_revoke);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000615 offset = sizeof(struct gfs2_log_descriptor);
616
Bob Petersonc0752aa2012-05-01 12:00:34 -0400617 list_for_each_entry(bd, head, bd_list) {
David Teiglandb3b94fa2006-01-16 16:50:04 +0000618 sdp->sd_log_num_revoke--;
619
Steven Whitehousecd915492006-09-04 12:49:07 -0400620 if (offset + sizeof(u64) > sdp->sd_sb.sb_bsize) {
David Teiglandb3b94fa2006-01-16 16:50:04 +0000621
Steven Whitehousee8c92ed2012-04-16 09:28:31 +0100622 gfs2_log_write_page(sdp, page);
623 page = mempool_alloc(gfs2_page_pool, GFP_NOIO);
624 mh = page_address(page);
625 clear_page(mh);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000626 mh->mh_magic = cpu_to_be32(GFS2_MAGIC);
Steven Whitehousee3167de2006-03-30 15:46:23 -0500627 mh->mh_type = cpu_to_be32(GFS2_METATYPE_LB);
628 mh->mh_format = cpu_to_be32(GFS2_FORMAT_LB);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000629 offset = sizeof(struct gfs2_meta_header);
630 }
631
Steven Whitehousee8c92ed2012-04-16 09:28:31 +0100632 *(__be64 *)(page_address(page) + offset) = cpu_to_be64(bd->bd_blkno);
Steven Whitehousecd915492006-09-04 12:49:07 -0400633 offset += sizeof(u64);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000634 }
635 gfs2_assert_withdraw(sdp, !sdp->sd_log_num_revoke);
636
Steven Whitehousee8c92ed2012-04-16 09:28:31 +0100637 gfs2_log_write_page(sdp, page);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000638}
639
Benjamin Marzinski16ca9412013-04-05 20:31:46 -0500640static void revoke_lo_after_commit(struct gfs2_sbd *sdp, struct gfs2_trans *tr)
Steven Whitehousef42ab082011-04-14 16:50:31 +0100641{
642 struct list_head *head = &sdp->sd_log_le_revoke;
643 struct gfs2_bufdata *bd;
644 struct gfs2_glock *gl;
645
646 while (!list_empty(head)) {
Bob Petersonc0752aa2012-05-01 12:00:34 -0400647 bd = list_entry(head->next, struct gfs2_bufdata, bd_list);
648 list_del_init(&bd->bd_list);
Steven Whitehousef42ab082011-04-14 16:50:31 +0100649 gl = bd->bd_gl;
650 atomic_dec(&gl->gl_revokes);
651 clear_bit(GLF_LFLUSH, &gl->gl_flags);
652 kmem_cache_free(gfs2_bufdata_cachep, bd);
653 }
654}
655
David Teiglandb3b94fa2006-01-16 16:50:04 +0000656static void revoke_lo_before_scan(struct gfs2_jdesc *jd,
Al Viro55167622006-10-13 21:47:13 -0400657 struct gfs2_log_header_host *head, int pass)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000658{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400659 struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000660
661 if (pass != 0)
662 return;
663
664 sdp->sd_found_revokes = 0;
665 sdp->sd_replay_tail = head->lh_tail;
666}
667
668static int revoke_lo_scan_elements(struct gfs2_jdesc *jd, unsigned int start,
669 struct gfs2_log_descriptor *ld, __be64 *ptr,
670 int pass)
671{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400672 struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000673 unsigned int blks = be32_to_cpu(ld->ld_length);
674 unsigned int revokes = be32_to_cpu(ld->ld_data1);
675 struct buffer_head *bh;
676 unsigned int offset;
Steven Whitehousecd915492006-09-04 12:49:07 -0400677 u64 blkno;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000678 int first = 1;
679 int error;
680
681 if (pass != 0 || be32_to_cpu(ld->ld_type) != GFS2_LOG_DESC_REVOKE)
682 return 0;
683
684 offset = sizeof(struct gfs2_log_descriptor);
685
686 for (; blks; gfs2_replay_incr_blk(sdp, &start), blks--) {
687 error = gfs2_replay_read_block(jd, start, &bh);
688 if (error)
689 return error;
690
691 if (!first)
692 gfs2_metatype_check(sdp, bh, GFS2_METATYPE_LB);
693
Steven Whitehousecd915492006-09-04 12:49:07 -0400694 while (offset + sizeof(u64) <= sdp->sd_sb.sb_bsize) {
David Teiglandb3b94fa2006-01-16 16:50:04 +0000695 blkno = be64_to_cpu(*(__be64 *)(bh->b_data + offset));
696
697 error = gfs2_revoke_add(sdp, blkno, start);
Bob Peterson3ad62e82008-01-28 16:35:13 -0600698 if (error < 0) {
699 brelse(bh);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000700 return error;
Bob Peterson3ad62e82008-01-28 16:35:13 -0600701 }
David Teiglandb3b94fa2006-01-16 16:50:04 +0000702 else if (error)
703 sdp->sd_found_revokes++;
704
705 if (!--revokes)
706 break;
Steven Whitehousecd915492006-09-04 12:49:07 -0400707 offset += sizeof(u64);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000708 }
709
710 brelse(bh);
711 offset = sizeof(struct gfs2_meta_header);
712 first = 0;
713 }
714
715 return 0;
716}
717
718static void revoke_lo_after_scan(struct gfs2_jdesc *jd, int error, int pass)
719{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400720 struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000721
722 if (error) {
723 gfs2_revoke_clean(sdp);
724 return;
725 }
726 if (pass != 1)
727 return;
728
729 fs_info(sdp, "jid=%u: Found %u revoke tags\n",
730 jd->jd_jid, sdp->sd_found_revokes);
731
732 gfs2_revoke_clean(sdp);
733}
734
Steven Whitehouse18ec7d52006-02-08 11:50:51 +0000735/**
Steven Whitehouse18ec7d52006-02-08 11:50:51 +0000736 * databuf_lo_before_commit - Scan the data buffers, writing as we go
737 *
Steven Whitehouse18ec7d52006-02-08 11:50:51 +0000738 */
Steven Whitehoused7b616e2007-09-02 10:48:13 +0100739
David Teiglandb3b94fa2006-01-16 16:50:04 +0000740static void databuf_lo_before_commit(struct gfs2_sbd *sdp)
741{
Steven Whitehousedad30e92012-04-16 09:40:00 +0100742 unsigned int limit = buf_limit(sdp) / 2;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000743
Steven Whitehousedad30e92012-04-16 09:40:00 +0100744 gfs2_before_commit(sdp, limit, sdp->sd_log_num_databuf,
745 &sdp->sd_log_le_databuf, 1);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000746}
747
Steven Whitehouse18ec7d52006-02-08 11:50:51 +0000748static int databuf_lo_scan_elements(struct gfs2_jdesc *jd, unsigned int start,
749 struct gfs2_log_descriptor *ld,
750 __be64 *ptr, int pass)
751{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400752 struct gfs2_inode *ip = GFS2_I(jd->jd_inode);
753 struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode);
Steven Whitehouse5c676f62006-02-27 17:23:27 -0500754 struct gfs2_glock *gl = ip->i_gl;
Steven Whitehouse18ec7d52006-02-08 11:50:51 +0000755 unsigned int blks = be32_to_cpu(ld->ld_data1);
756 struct buffer_head *bh_log, *bh_ip;
Steven Whitehousecd915492006-09-04 12:49:07 -0400757 u64 blkno;
758 u64 esc;
Steven Whitehouse18ec7d52006-02-08 11:50:51 +0000759 int error = 0;
760
761 if (pass != 1 || be32_to_cpu(ld->ld_type) != GFS2_LOG_DESC_JDATA)
762 return 0;
763
764 gfs2_replay_incr_blk(sdp, &start);
765 for (; blks; gfs2_replay_incr_blk(sdp, &start), blks--) {
766 blkno = be64_to_cpu(*ptr++);
767 esc = be64_to_cpu(*ptr++);
768
769 sdp->sd_found_blocks++;
770
771 if (gfs2_revoke_check(sdp, blkno, start))
772 continue;
773
774 error = gfs2_replay_read_block(jd, start, &bh_log);
775 if (error)
776 return error;
777
778 bh_ip = gfs2_meta_new(gl, blkno);
779 memcpy(bh_ip->b_data, bh_log->b_data, bh_log->b_size);
780
781 /* Unescape */
782 if (esc) {
783 __be32 *eptr = (__be32 *)bh_ip->b_data;
784 *eptr = cpu_to_be32(GFS2_MAGIC);
785 }
786 mark_buffer_dirty(bh_ip);
787
788 brelse(bh_log);
789 brelse(bh_ip);
Steven Whitehouse18ec7d52006-02-08 11:50:51 +0000790
791 sdp->sd_replayed_blocks++;
792 }
793
794 return error;
795}
796
797/* FIXME: sort out accounting for log blocks etc. */
798
799static void databuf_lo_after_scan(struct gfs2_jdesc *jd, int error, int pass)
800{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400801 struct gfs2_inode *ip = GFS2_I(jd->jd_inode);
802 struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode);
Steven Whitehouse18ec7d52006-02-08 11:50:51 +0000803
804 if (error) {
Steven Whitehouse7276b3b2006-09-21 17:05:23 -0400805 gfs2_meta_sync(ip->i_gl);
Steven Whitehouse18ec7d52006-02-08 11:50:51 +0000806 return;
807 }
808 if (pass != 1)
809 return;
810
811 /* data sync? */
Steven Whitehouse7276b3b2006-09-21 17:05:23 -0400812 gfs2_meta_sync(ip->i_gl);
Steven Whitehouse18ec7d52006-02-08 11:50:51 +0000813
814 fs_info(sdp, "jid=%u: Replayed %u of %u data blocks\n",
815 jd->jd_jid, sdp->sd_replayed_blocks, sdp->sd_found_blocks);
816}
817
Benjamin Marzinski16ca9412013-04-05 20:31:46 -0500818static void databuf_lo_after_commit(struct gfs2_sbd *sdp, struct gfs2_trans *tr)
Steven Whitehouse18ec7d52006-02-08 11:50:51 +0000819{
820 struct list_head *head = &sdp->sd_log_le_databuf;
821 struct gfs2_bufdata *bd;
822
Benjamin Marzinski16ca9412013-04-05 20:31:46 -0500823 if (tr == NULL) {
824 gfs2_assert(sdp, list_empty(head));
825 return;
826 }
827
Steven Whitehouse18ec7d52006-02-08 11:50:51 +0000828 while (!list_empty(head)) {
Bob Petersonc0752aa2012-05-01 12:00:34 -0400829 bd = list_entry(head->next, struct gfs2_bufdata, bd_list);
830 list_del_init(&bd->bd_list);
Steven Whitehouse18ec7d52006-02-08 11:50:51 +0000831 sdp->sd_log_num_databuf--;
Benjamin Marzinski16ca9412013-04-05 20:31:46 -0500832 gfs2_unpin(sdp, bd->bd_bh, tr);
Steven Whitehouse18ec7d52006-02-08 11:50:51 +0000833 }
834 gfs2_assert_warn(sdp, !sdp->sd_log_num_databuf);
Steven Whitehouse18ec7d52006-02-08 11:50:51 +0000835}
836
837
Steven Whitehouseb09e5932006-04-07 11:17:32 -0400838const struct gfs2_log_operations gfs2_buf_lops = {
David Teiglandb3b94fa2006-01-16 16:50:04 +0000839 .lo_before_commit = buf_lo_before_commit,
840 .lo_after_commit = buf_lo_after_commit,
841 .lo_before_scan = buf_lo_before_scan,
842 .lo_scan_elements = buf_lo_scan_elements,
843 .lo_after_scan = buf_lo_after_scan,
Steven Whitehouseea67eed2006-09-05 10:53:09 -0400844 .lo_name = "buf",
David Teiglandb3b94fa2006-01-16 16:50:04 +0000845};
846
Steven Whitehouseb09e5932006-04-07 11:17:32 -0400847const struct gfs2_log_operations gfs2_revoke_lops = {
David Teiglandb3b94fa2006-01-16 16:50:04 +0000848 .lo_before_commit = revoke_lo_before_commit,
Steven Whitehousef42ab082011-04-14 16:50:31 +0100849 .lo_after_commit = revoke_lo_after_commit,
David Teiglandb3b94fa2006-01-16 16:50:04 +0000850 .lo_before_scan = revoke_lo_before_scan,
851 .lo_scan_elements = revoke_lo_scan_elements,
852 .lo_after_scan = revoke_lo_after_scan,
Steven Whitehouseea67eed2006-09-05 10:53:09 -0400853 .lo_name = "revoke",
David Teiglandb3b94fa2006-01-16 16:50:04 +0000854};
855
Steven Whitehouseb09e5932006-04-07 11:17:32 -0400856const struct gfs2_log_operations gfs2_databuf_lops = {
David Teiglandb3b94fa2006-01-16 16:50:04 +0000857 .lo_before_commit = databuf_lo_before_commit,
Steven Whitehouse18ec7d52006-02-08 11:50:51 +0000858 .lo_after_commit = databuf_lo_after_commit,
859 .lo_scan_elements = databuf_lo_scan_elements,
860 .lo_after_scan = databuf_lo_after_scan,
Steven Whitehouseea67eed2006-09-05 10:53:09 -0400861 .lo_name = "databuf",
David Teiglandb3b94fa2006-01-16 16:50:04 +0000862};
863
Steven Whitehouseb09e5932006-04-07 11:17:32 -0400864const struct gfs2_log_operations *gfs2_log_ops[] = {
David Teiglandb3b94fa2006-01-16 16:50:04 +0000865 &gfs2_databuf_lops,
Steven Whitehouse16615be2007-09-17 10:59:52 +0100866 &gfs2_buf_lops,
Steven Whitehouse16615be2007-09-17 10:59:52 +0100867 &gfs2_revoke_lops,
Steven Whitehouseea67eed2006-09-05 10:53:09 -0400868 NULL,
David Teiglandb3b94fa2006-01-16 16:50:04 +0000869};
870