blob: 7e2d4e692b50624cf99c094fb4cfaafc387fcbcb [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 Whitehouse5c676f62006-02-27 17:23:27 -050015#include <linux/gfs2_ondisk.h>
Fabio Massimo Di Nitto7d308592006-09-19 07:56:29 +020016#include <linux/lm_interface.h>
David Teiglandb3b94fa2006-01-16 16:50:04 +000017
18#include "gfs2.h"
Steven Whitehouse5c676f62006-02-27 17:23:27 -050019#include "incore.h"
Robert Peterson2332c442007-06-18 14:50:20 -050020#include "inode.h"
David Teiglandb3b94fa2006-01-16 16:50:04 +000021#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"
Steven Whitehouse5c676f62006-02-27 17:23:27 -050028#include "util.h"
David Teiglandb3b94fa2006-01-16 16:50:04 +000029
Steven Whitehouse9b9107a2007-08-27 13:54:05 +010030/**
31 * gfs2_pin - Pin a buffer in memory
32 * @sdp: The superblock
33 * @bh: The buffer to be pinned
34 *
35 * The log lock must be held when calling this function
36 */
37static void gfs2_pin(struct gfs2_sbd *sdp, struct buffer_head *bh)
38{
39 struct gfs2_bufdata *bd;
40
41 gfs2_assert_withdraw(sdp, test_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags));
42
43 clear_buffer_dirty(bh);
44 if (test_set_buffer_pinned(bh))
45 gfs2_assert_withdraw(sdp, 0);
46 if (!buffer_uptodate(bh))
47 gfs2_io_error_bh(sdp, bh);
48 bd = bh->b_private;
49 /* If this buffer is in the AIL and it has already been written
50 * to in-place disk block, remove it from the AIL.
51 */
52 if (bd->bd_ail)
53 list_move(&bd->bd_ail_st_list, &bd->bd_ail->ai_ail2_list);
54 get_bh(bh);
55}
56
57/**
58 * gfs2_unpin - Unpin a buffer
59 * @sdp: the filesystem the buffer belongs to
60 * @bh: The buffer to unpin
61 * @ai:
62 *
63 */
64
65static void gfs2_unpin(struct gfs2_sbd *sdp, struct buffer_head *bh,
66 struct gfs2_ail *ai)
67{
68 struct gfs2_bufdata *bd = bh->b_private;
69
70 gfs2_assert_withdraw(sdp, buffer_uptodate(bh));
71
72 if (!buffer_pinned(bh))
73 gfs2_assert_withdraw(sdp, 0);
74
75 lock_buffer(bh);
76 mark_buffer_dirty(bh);
77 clear_buffer_pinned(bh);
78
79 gfs2_log_lock(sdp);
80 if (bd->bd_ail) {
81 list_del(&bd->bd_ail_st_list);
82 brelse(bh);
83 } else {
84 struct gfs2_glock *gl = bd->bd_gl;
85 list_add(&bd->bd_ail_gl_list, &gl->gl_ail_list);
86 atomic_inc(&gl->gl_ail_count);
87 }
88 bd->bd_ail = ai;
89 list_add(&bd->bd_ail_st_list, &ai->ai_ail1_list);
90 gfs2_log_unlock(sdp);
91 unlock_buffer(bh);
92}
93
94static void __glock_lo_add(struct gfs2_sbd *sdp, struct gfs2_log_element *le)
David Teiglandb3b94fa2006-01-16 16:50:04 +000095{
96 struct gfs2_glock *gl;
Steven Whitehouse5c676f62006-02-27 17:23:27 -050097 struct gfs2_trans *tr = current->journal_info;
David Teiglandb3b94fa2006-01-16 16:50:04 +000098
Steven Whitehouse5c676f62006-02-27 17:23:27 -050099 tr->tr_touched = 1;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000100
David Teiglandb3b94fa2006-01-16 16:50:04 +0000101 gl = container_of(le, struct gfs2_glock, gl_le);
102 if (gfs2_assert_withdraw(sdp, gfs2_glock_is_held_excl(gl)))
103 return;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000104
Steven Whitehouse9b9107a2007-08-27 13:54:05 +0100105 if (!list_empty(&le->le_list))
Benjamin Marzinski68835622007-03-23 09:05:12 +0000106 return;
Steven Whitehouse9b9107a2007-08-27 13:54:05 +0100107
Benjamin Marzinski68835622007-03-23 09:05:12 +0000108 gfs2_glock_hold(gl);
109 set_bit(GLF_DIRTY, &gl->gl_flags);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000110 sdp->sd_log_num_gl++;
111 list_add(&le->le_list, &sdp->sd_log_le_gl);
Steven Whitehouse9b9107a2007-08-27 13:54:05 +0100112}
113
114static void glock_lo_add(struct gfs2_sbd *sdp, struct gfs2_log_element *le)
115{
116 gfs2_log_lock(sdp);
117 __glock_lo_add(sdp, le);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000118 gfs2_log_unlock(sdp);
119}
120
121static void glock_lo_after_commit(struct gfs2_sbd *sdp, struct gfs2_ail *ai)
122{
123 struct list_head *head = &sdp->sd_log_le_gl;
124 struct gfs2_glock *gl;
125
126 while (!list_empty(head)) {
127 gl = list_entry(head->next, struct gfs2_glock, gl_le.le_list);
128 list_del_init(&gl->gl_le.le_list);
129 sdp->sd_log_num_gl--;
130
131 gfs2_assert_withdraw(sdp, gfs2_glock_is_held_excl(gl));
132 gfs2_glock_put(gl);
133 }
134 gfs2_assert_warn(sdp, !sdp->sd_log_num_gl);
135}
136
137static void buf_lo_add(struct gfs2_sbd *sdp, struct gfs2_log_element *le)
138{
139 struct gfs2_bufdata *bd = container_of(le, struct gfs2_bufdata, bd_le);
140 struct gfs2_trans *tr;
141
Steven Whitehouse9b9107a2007-08-27 13:54:05 +0100142 lock_buffer(bd->bd_bh);
Steven Whitehouse8bd95722007-01-25 10:04:20 +0000143 gfs2_log_lock(sdp);
Steven Whitehouse9b9107a2007-08-27 13:54:05 +0100144 if (!list_empty(&bd->bd_list_tr))
145 goto out;
Steven Whitehouse5c676f62006-02-27 17:23:27 -0500146 tr = current->journal_info;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000147 tr->tr_touched = 1;
148 tr->tr_num_buf++;
149 list_add(&bd->bd_list_tr, &tr->tr_list_buf);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000150 if (!list_empty(&le->le_list))
Steven Whitehouse9b9107a2007-08-27 13:54:05 +0100151 goto out;
152 __glock_lo_add(sdp, &bd->bd_gl->gl_le);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000153 gfs2_meta_check(sdp, bd->bd_bh);
Steven Whitehousea98ab222006-01-18 13:38:44 +0000154 gfs2_pin(sdp, bd->bd_bh);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000155 sdp->sd_log_num_buf++;
156 list_add(&le->le_list, &sdp->sd_log_le_buf);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000157 tr->tr_num_buf_new++;
Steven Whitehouse9b9107a2007-08-27 13:54:05 +0100158out:
159 gfs2_log_unlock(sdp);
160 unlock_buffer(bd->bd_bh);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000161}
162
163static void buf_lo_incore_commit(struct gfs2_sbd *sdp, struct gfs2_trans *tr)
164{
165 struct list_head *head = &tr->tr_list_buf;
166 struct gfs2_bufdata *bd;
167
Steven Whitehouse8bd95722007-01-25 10:04:20 +0000168 gfs2_log_lock(sdp);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000169 while (!list_empty(head)) {
170 bd = list_entry(head->next, struct gfs2_bufdata, bd_list_tr);
171 list_del_init(&bd->bd_list_tr);
172 tr->tr_num_buf--;
173 }
Steven Whitehouse8bd95722007-01-25 10:04:20 +0000174 gfs2_log_unlock(sdp);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000175 gfs2_assert_warn(sdp, !tr->tr_num_buf);
176}
177
178static void buf_lo_before_commit(struct gfs2_sbd *sdp)
179{
180 struct buffer_head *bh;
181 struct gfs2_log_descriptor *ld;
182 struct gfs2_bufdata *bd1 = NULL, *bd2;
Bob Peterson905d2ae2007-07-24 14:05:31 -0500183 unsigned int total;
Robert Peterson2332c442007-06-18 14:50:20 -0500184 unsigned int offset = BUF_OFFSET;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000185 unsigned int limit;
186 unsigned int num;
187 unsigned n;
188 __be64 *ptr;
189
Robert Peterson2332c442007-06-18 14:50:20 -0500190 limit = buf_limit(sdp);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000191 /* for 4k blocks, limit = 503 */
192
Bob Peterson905d2ae2007-07-24 14:05:31 -0500193 gfs2_log_lock(sdp);
194 total = sdp->sd_log_num_buf;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000195 bd1 = bd2 = list_prepare_entry(bd1, &sdp->sd_log_le_buf, bd_le.le_list);
196 while(total) {
197 num = total;
198 if (total > limit)
199 num = limit;
Bob Peterson905d2ae2007-07-24 14:05:31 -0500200 gfs2_log_unlock(sdp);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000201 bh = gfs2_log_get_buf(sdp);
Bob Peterson905d2ae2007-07-24 14:05:31 -0500202 gfs2_log_lock(sdp);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000203 ld = (struct gfs2_log_descriptor *)bh->b_data;
204 ptr = (__be64 *)(bh->b_data + offset);
205 ld->ld_header.mh_magic = cpu_to_be32(GFS2_MAGIC);
Steven Whitehousee3167de2006-03-30 15:46:23 -0500206 ld->ld_header.mh_type = cpu_to_be32(GFS2_METATYPE_LD);
207 ld->ld_header.mh_format = cpu_to_be32(GFS2_FORMAT_LD);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000208 ld->ld_type = cpu_to_be32(GFS2_LOG_DESC_METADATA);
209 ld->ld_length = cpu_to_be32(num + 1);
210 ld->ld_data1 = cpu_to_be32(num);
211 ld->ld_data2 = cpu_to_be32(0);
212 memset(ld->ld_reserved, 0, sizeof(ld->ld_reserved));
213
214 n = 0;
Steven Whitehouse568f4c92006-02-27 12:00:42 -0500215 list_for_each_entry_continue(bd1, &sdp->sd_log_le_buf,
216 bd_le.le_list) {
David Teiglandb3b94fa2006-01-16 16:50:04 +0000217 *ptr++ = cpu_to_be64(bd1->bd_bh->b_blocknr);
218 if (++n >= num)
219 break;
220 }
221
Bob Peterson905d2ae2007-07-24 14:05:31 -0500222 gfs2_log_unlock(sdp);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000223 set_buffer_dirty(bh);
224 ll_rw_block(WRITE, 1, &bh);
Bob Peterson905d2ae2007-07-24 14:05:31 -0500225 gfs2_log_lock(sdp);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000226
227 n = 0;
Steven Whitehouse568f4c92006-02-27 12:00:42 -0500228 list_for_each_entry_continue(bd2, &sdp->sd_log_le_buf,
229 bd_le.le_list) {
Bob Peterson905d2ae2007-07-24 14:05:31 -0500230 gfs2_log_unlock(sdp);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000231 bh = gfs2_log_fake_buf(sdp, bd2->bd_bh);
232 set_buffer_dirty(bh);
233 ll_rw_block(WRITE, 1, &bh);
Bob Peterson905d2ae2007-07-24 14:05:31 -0500234 gfs2_log_lock(sdp);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000235 if (++n >= num)
236 break;
237 }
238
Bob Peterson905d2ae2007-07-24 14:05:31 -0500239 BUG_ON(total < num);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000240 total -= num;
241 }
Bob Peterson905d2ae2007-07-24 14:05:31 -0500242 gfs2_log_unlock(sdp);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000243}
244
245static void buf_lo_after_commit(struct gfs2_sbd *sdp, struct gfs2_ail *ai)
246{
247 struct list_head *head = &sdp->sd_log_le_buf;
248 struct gfs2_bufdata *bd;
249
250 while (!list_empty(head)) {
251 bd = list_entry(head->next, struct gfs2_bufdata, bd_le.le_list);
252 list_del_init(&bd->bd_le.le_list);
253 sdp->sd_log_num_buf--;
254
Steven Whitehousea98ab222006-01-18 13:38:44 +0000255 gfs2_unpin(sdp, bd->bd_bh, ai);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000256 }
257 gfs2_assert_warn(sdp, !sdp->sd_log_num_buf);
258}
259
260static void buf_lo_before_scan(struct gfs2_jdesc *jd,
Al Viro55167622006-10-13 21:47:13 -0400261 struct gfs2_log_header_host *head, int pass)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000262{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400263 struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000264
265 if (pass != 0)
266 return;
267
268 sdp->sd_found_blocks = 0;
269 sdp->sd_replayed_blocks = 0;
270}
271
272static int buf_lo_scan_elements(struct gfs2_jdesc *jd, unsigned int start,
273 struct gfs2_log_descriptor *ld, __be64 *ptr,
274 int pass)
275{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400276 struct gfs2_inode *ip = GFS2_I(jd->jd_inode);
277 struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode);
Steven Whitehouse5c676f62006-02-27 17:23:27 -0500278 struct gfs2_glock *gl = ip->i_gl;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000279 unsigned int blks = be32_to_cpu(ld->ld_data1);
280 struct buffer_head *bh_log, *bh_ip;
Steven Whitehousecd915492006-09-04 12:49:07 -0400281 u64 blkno;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000282 int error = 0;
283
284 if (pass != 1 || be32_to_cpu(ld->ld_type) != GFS2_LOG_DESC_METADATA)
285 return 0;
286
287 gfs2_replay_incr_blk(sdp, &start);
288
289 for (; blks; gfs2_replay_incr_blk(sdp, &start), blks--) {
290 blkno = be64_to_cpu(*ptr++);
291
292 sdp->sd_found_blocks++;
293
294 if (gfs2_revoke_check(sdp, blkno, start))
295 continue;
296
297 error = gfs2_replay_read_block(jd, start, &bh_log);
Steven Whitehouse82ffa512006-09-04 14:47:06 -0400298 if (error)
299 return error;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000300
301 bh_ip = gfs2_meta_new(gl, blkno);
302 memcpy(bh_ip->b_data, bh_log->b_data, bh_log->b_size);
303
304 if (gfs2_meta_check(sdp, bh_ip))
305 error = -EIO;
306 else
307 mark_buffer_dirty(bh_ip);
308
309 brelse(bh_log);
310 brelse(bh_ip);
311
312 if (error)
313 break;
314
315 sdp->sd_replayed_blocks++;
316 }
317
318 return error;
319}
320
321static void buf_lo_after_scan(struct gfs2_jdesc *jd, int error, int pass)
322{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400323 struct gfs2_inode *ip = GFS2_I(jd->jd_inode);
324 struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000325
326 if (error) {
Steven Whitehouse7276b3b2006-09-21 17:05:23 -0400327 gfs2_meta_sync(ip->i_gl);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000328 return;
329 }
330 if (pass != 1)
331 return;
332
Steven Whitehouse7276b3b2006-09-21 17:05:23 -0400333 gfs2_meta_sync(ip->i_gl);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000334
335 fs_info(sdp, "jid=%u: Replayed %u of %u blocks\n",
336 jd->jd_jid, sdp->sd_replayed_blocks, sdp->sd_found_blocks);
337}
338
339static void revoke_lo_add(struct gfs2_sbd *sdp, struct gfs2_log_element *le)
340{
341 struct gfs2_trans *tr;
342
Steven Whitehouse5c676f62006-02-27 17:23:27 -0500343 tr = current->journal_info;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000344 tr->tr_touched = 1;
345 tr->tr_num_revoke++;
346
347 gfs2_log_lock(sdp);
348 sdp->sd_log_num_revoke++;
349 list_add(&le->le_list, &sdp->sd_log_le_revoke);
350 gfs2_log_unlock(sdp);
351}
352
353static void revoke_lo_before_commit(struct gfs2_sbd *sdp)
354{
355 struct gfs2_log_descriptor *ld;
356 struct gfs2_meta_header *mh;
357 struct buffer_head *bh;
358 unsigned int offset;
359 struct list_head *head = &sdp->sd_log_le_revoke;
360 struct gfs2_revoke *rv;
361
362 if (!sdp->sd_log_num_revoke)
363 return;
364
365 bh = gfs2_log_get_buf(sdp);
366 ld = (struct gfs2_log_descriptor *)bh->b_data;
367 ld->ld_header.mh_magic = cpu_to_be32(GFS2_MAGIC);
Steven Whitehousee3167de2006-03-30 15:46:23 -0500368 ld->ld_header.mh_type = cpu_to_be32(GFS2_METATYPE_LD);
369 ld->ld_header.mh_format = cpu_to_be32(GFS2_FORMAT_LD);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000370 ld->ld_type = cpu_to_be32(GFS2_LOG_DESC_REVOKE);
Steven Whitehouse568f4c92006-02-27 12:00:42 -0500371 ld->ld_length = cpu_to_be32(gfs2_struct2blk(sdp, sdp->sd_log_num_revoke,
Steven Whitehousecd915492006-09-04 12:49:07 -0400372 sizeof(u64)));
David Teiglandb3b94fa2006-01-16 16:50:04 +0000373 ld->ld_data1 = cpu_to_be32(sdp->sd_log_num_revoke);
374 ld->ld_data2 = cpu_to_be32(0);
375 memset(ld->ld_reserved, 0, sizeof(ld->ld_reserved));
376 offset = sizeof(struct gfs2_log_descriptor);
377
378 while (!list_empty(head)) {
379 rv = list_entry(head->next, struct gfs2_revoke, rv_le.le_list);
Steven Whitehouse13538b82006-02-22 11:15:03 +0000380 list_del_init(&rv->rv_le.le_list);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000381 sdp->sd_log_num_revoke--;
382
Steven Whitehousecd915492006-09-04 12:49:07 -0400383 if (offset + sizeof(u64) > sdp->sd_sb.sb_bsize) {
David Teiglandb3b94fa2006-01-16 16:50:04 +0000384 set_buffer_dirty(bh);
385 ll_rw_block(WRITE, 1, &bh);
386
387 bh = gfs2_log_get_buf(sdp);
388 mh = (struct gfs2_meta_header *)bh->b_data;
389 mh->mh_magic = cpu_to_be32(GFS2_MAGIC);
Steven Whitehousee3167de2006-03-30 15:46:23 -0500390 mh->mh_type = cpu_to_be32(GFS2_METATYPE_LB);
391 mh->mh_format = cpu_to_be32(GFS2_FORMAT_LB);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000392 offset = sizeof(struct gfs2_meta_header);
393 }
394
395 *(__be64 *)(bh->b_data + offset) = cpu_to_be64(rv->rv_blkno);
396 kfree(rv);
397
Steven Whitehousecd915492006-09-04 12:49:07 -0400398 offset += sizeof(u64);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000399 }
400 gfs2_assert_withdraw(sdp, !sdp->sd_log_num_revoke);
401
402 set_buffer_dirty(bh);
403 ll_rw_block(WRITE, 1, &bh);
404}
405
406static void revoke_lo_before_scan(struct gfs2_jdesc *jd,
Al Viro55167622006-10-13 21:47:13 -0400407 struct gfs2_log_header_host *head, int pass)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000408{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400409 struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000410
411 if (pass != 0)
412 return;
413
414 sdp->sd_found_revokes = 0;
415 sdp->sd_replay_tail = head->lh_tail;
416}
417
418static int revoke_lo_scan_elements(struct gfs2_jdesc *jd, unsigned int start,
419 struct gfs2_log_descriptor *ld, __be64 *ptr,
420 int pass)
421{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400422 struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000423 unsigned int blks = be32_to_cpu(ld->ld_length);
424 unsigned int revokes = be32_to_cpu(ld->ld_data1);
425 struct buffer_head *bh;
426 unsigned int offset;
Steven Whitehousecd915492006-09-04 12:49:07 -0400427 u64 blkno;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000428 int first = 1;
429 int error;
430
431 if (pass != 0 || be32_to_cpu(ld->ld_type) != GFS2_LOG_DESC_REVOKE)
432 return 0;
433
434 offset = sizeof(struct gfs2_log_descriptor);
435
436 for (; blks; gfs2_replay_incr_blk(sdp, &start), blks--) {
437 error = gfs2_replay_read_block(jd, start, &bh);
438 if (error)
439 return error;
440
441 if (!first)
442 gfs2_metatype_check(sdp, bh, GFS2_METATYPE_LB);
443
Steven Whitehousecd915492006-09-04 12:49:07 -0400444 while (offset + sizeof(u64) <= sdp->sd_sb.sb_bsize) {
David Teiglandb3b94fa2006-01-16 16:50:04 +0000445 blkno = be64_to_cpu(*(__be64 *)(bh->b_data + offset));
446
447 error = gfs2_revoke_add(sdp, blkno, start);
448 if (error < 0)
449 return error;
450 else if (error)
451 sdp->sd_found_revokes++;
452
453 if (!--revokes)
454 break;
Steven Whitehousecd915492006-09-04 12:49:07 -0400455 offset += sizeof(u64);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000456 }
457
458 brelse(bh);
459 offset = sizeof(struct gfs2_meta_header);
460 first = 0;
461 }
462
463 return 0;
464}
465
466static void revoke_lo_after_scan(struct gfs2_jdesc *jd, int error, int pass)
467{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400468 struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000469
470 if (error) {
471 gfs2_revoke_clean(sdp);
472 return;
473 }
474 if (pass != 1)
475 return;
476
477 fs_info(sdp, "jid=%u: Found %u revoke tags\n",
478 jd->jd_jid, sdp->sd_found_revokes);
479
480 gfs2_revoke_clean(sdp);
481}
482
483static void rg_lo_add(struct gfs2_sbd *sdp, struct gfs2_log_element *le)
484{
485 struct gfs2_rgrpd *rgd;
Steven Whitehouse5c676f62006-02-27 17:23:27 -0500486 struct gfs2_trans *tr = current->journal_info;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000487
Steven Whitehouse5c676f62006-02-27 17:23:27 -0500488 tr->tr_touched = 1;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000489
David Teiglandb3b94fa2006-01-16 16:50:04 +0000490 rgd = container_of(le, struct gfs2_rgrpd, rd_le);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000491
492 gfs2_log_lock(sdp);
Benjamin Marzinski68835622007-03-23 09:05:12 +0000493 if (!list_empty(&le->le_list)){
494 gfs2_log_unlock(sdp);
495 return;
496 }
497 gfs2_rgrp_bh_hold(rgd);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000498 sdp->sd_log_num_rg++;
499 list_add(&le->le_list, &sdp->sd_log_le_rg);
Steven Whitehouse907b9bc2006-09-25 09:26:04 -0400500 gfs2_log_unlock(sdp);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000501}
502
503static void rg_lo_after_commit(struct gfs2_sbd *sdp, struct gfs2_ail *ai)
504{
505 struct list_head *head = &sdp->sd_log_le_rg;
506 struct gfs2_rgrpd *rgd;
507
508 while (!list_empty(head)) {
509 rgd = list_entry(head->next, struct gfs2_rgrpd, rd_le.le_list);
510 list_del_init(&rgd->rd_le.le_list);
511 sdp->sd_log_num_rg--;
512
513 gfs2_rgrp_repolish_clones(rgd);
514 gfs2_rgrp_bh_put(rgd);
515 }
516 gfs2_assert_warn(sdp, !sdp->sd_log_num_rg);
517}
518
Steven Whitehouse18ec7d52006-02-08 11:50:51 +0000519/**
520 * databuf_lo_add - Add a databuf to the transaction.
521 *
522 * This is used in two distinct cases:
523 * i) In ordered write mode
524 * We put the data buffer on a list so that we can ensure that its
525 * synced to disk at the right time
526 * ii) In journaled data mode
527 * We need to journal the data block in the same way as metadata in
528 * the functions above. The difference is that here we have a tag
529 * which is two __be64's being the block number (as per meta data)
530 * and a flag which says whether the data block needs escaping or
531 * not. This means we need a new log entry for each 251 or so data
532 * blocks, which isn't an enormous overhead but twice as much as
533 * for normal metadata blocks.
534 */
David Teiglandb3b94fa2006-01-16 16:50:04 +0000535static void databuf_lo_add(struct gfs2_sbd *sdp, struct gfs2_log_element *le)
536{
Steven Whitehouse18ec7d52006-02-08 11:50:51 +0000537 struct gfs2_bufdata *bd = container_of(le, struct gfs2_bufdata, bd_le);
Steven Whitehouse5c676f62006-02-27 17:23:27 -0500538 struct gfs2_trans *tr = current->journal_info;
Steven Whitehouse18ec7d52006-02-08 11:50:51 +0000539 struct address_space *mapping = bd->bd_bh->b_page->mapping;
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400540 struct gfs2_inode *ip = GFS2_I(mapping->host);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000541
Steven Whitehouse9b9107a2007-08-27 13:54:05 +0100542 lock_buffer(bd->bd_bh);
Steven Whitehouse8bd95722007-01-25 10:04:20 +0000543 gfs2_log_lock(sdp);
Steven Whitehouse9b9107a2007-08-27 13:54:05 +0100544 if (!list_empty(&bd->bd_list_tr))
545 goto out;
Steven Whitehouse18ec7d52006-02-08 11:50:51 +0000546 tr->tr_touched = 1;
Robert Peterson773ed1a2007-06-20 08:34:06 -0500547 if (gfs2_is_jdata(ip)) {
548 tr->tr_num_buf++;
549 list_add(&bd->bd_list_tr, &tr->tr_list_buf);
550 }
Robert Peterson2332c442007-06-18 14:50:20 -0500551 if (!list_empty(&le->le_list))
Steven Whitehouse9b9107a2007-08-27 13:54:05 +0100552 goto out;
Robert Peterson2332c442007-06-18 14:50:20 -0500553
Steven Whitehouse9b9107a2007-08-27 13:54:05 +0100554 __glock_lo_add(sdp, &bd->bd_gl->gl_le);
Robert Peterson2332c442007-06-18 14:50:20 -0500555 if (gfs2_is_jdata(ip)) {
Robert Peterson2332c442007-06-18 14:50:20 -0500556 gfs2_pin(sdp, bd->bd_bh);
557 tr->tr_num_databuf_new++;
Steven Whitehoused7b616e2007-09-02 10:48:13 +0100558 sdp->sd_log_num_databuf++;
559 list_add(&le->le_list, &sdp->sd_log_le_databuf);
560 } else {
561 list_add(&le->le_list, &sdp->sd_log_le_ordered);
Steven Whitehouse9b9107a2007-08-27 13:54:05 +0100562 }
Steven Whitehouse9b9107a2007-08-27 13:54:05 +0100563out:
David Teiglandb3b94fa2006-01-16 16:50:04 +0000564 gfs2_log_unlock(sdp);
Steven Whitehouse9b9107a2007-08-27 13:54:05 +0100565 unlock_buffer(bd->bd_bh);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000566}
567
Steven Whitehouse18ec7d52006-02-08 11:50:51 +0000568static int gfs2_check_magic(struct buffer_head *bh)
569{
570 struct page *page = bh->b_page;
571 void *kaddr;
572 __be32 *ptr;
573 int rv = 0;
574
575 kaddr = kmap_atomic(page, KM_USER0);
576 ptr = kaddr + bh_offset(bh);
577 if (*ptr == cpu_to_be32(GFS2_MAGIC))
578 rv = 1;
Russell Cattelanc312c4f2006-10-12 09:23:41 -0400579 kunmap_atomic(kaddr, KM_USER0);
Steven Whitehouse18ec7d52006-02-08 11:50:51 +0000580
581 return rv;
582}
583
584/**
585 * databuf_lo_before_commit - Scan the data buffers, writing as we go
586 *
Steven Whitehouse18ec7d52006-02-08 11:50:51 +0000587 */
Steven Whitehoused7b616e2007-09-02 10:48:13 +0100588
David Teiglandb3b94fa2006-01-16 16:50:04 +0000589static void databuf_lo_before_commit(struct gfs2_sbd *sdp)
590{
Steven Whitehoused7b616e2007-09-02 10:48:13 +0100591 struct gfs2_bufdata *bd1 = NULL, *bd2;
Russell Cattelan70209332006-11-09 11:28:08 -0500592 struct buffer_head *bh = NULL,*bh1 = NULL;
Steven Whitehouse18ec7d52006-02-08 11:50:51 +0000593 struct gfs2_log_descriptor *ld;
594 unsigned int limit;
Steven Whitehoused7b616e2007-09-02 10:48:13 +0100595 unsigned int total;
Steven Whitehouse18ec7d52006-02-08 11:50:51 +0000596 unsigned int num, n;
Steven Whitehousef55ab262006-02-21 12:51:39 +0000597 __be64 *ptr = NULL;
Steven Whitehoused7b616e2007-09-02 10:48:13 +0100598 int magic;
599
David Teiglandb3b94fa2006-01-16 16:50:04 +0000600
Robert Peterson2332c442007-06-18 14:50:20 -0500601 limit = databuf_limit(sdp);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000602
Steven Whitehousef55ab262006-02-21 12:51:39 +0000603 gfs2_log_lock(sdp);
Steven Whitehoused7b616e2007-09-02 10:48:13 +0100604 total = sdp->sd_log_num_databuf;
Steven Whitehouse568f4c92006-02-27 12:00:42 -0500605 bd2 = bd1 = list_prepare_entry(bd1, &sdp->sd_log_le_databuf,
606 bd_le.le_list);
Steven Whitehoused7b616e2007-09-02 10:48:13 +0100607 while(total) {
608 num = total;
Steven Whitehouse18ec7d52006-02-08 11:50:51 +0000609 if (num > limit)
610 num = limit;
Steven Whitehoused7b616e2007-09-02 10:48:13 +0100611
612 gfs2_log_unlock(sdp);
613 bh = gfs2_log_get_buf(sdp);
614 gfs2_log_lock(sdp);
615
616 ld = (struct gfs2_log_descriptor *)bh->b_data;
617 ptr = (__be64 *)(bh->b_data + DATABUF_OFFSET);
618 ld->ld_header.mh_magic = cpu_to_be32(GFS2_MAGIC);
619 ld->ld_header.mh_type = cpu_to_be32(GFS2_METATYPE_LD);
620 ld->ld_header.mh_format = cpu_to_be32(GFS2_FORMAT_LD);
621 ld->ld_type = cpu_to_be32(GFS2_LOG_DESC_JDATA);
622 ld->ld_length = cpu_to_be32(num + 1);
623 ld->ld_data1 = cpu_to_be32(num);
624 ld->ld_data2 = cpu_to_be32(0);
625 memset(ld->ld_reserved, 0, sizeof(ld->ld_reserved));
626
Steven Whitehouse18ec7d52006-02-08 11:50:51 +0000627 n = 0;
Steven Whitehoused7b616e2007-09-02 10:48:13 +0100628 list_for_each_entry_continue(bd1, &sdp->sd_log_le_databuf,
629 bd_le.le_list) {
Russell Cattelan70209332006-11-09 11:28:08 -0500630 bh1 = bd1->bd_bh;
631
Steven Whitehoused7b616e2007-09-02 10:48:13 +0100632 magic = gfs2_check_magic(bh1);
633 *ptr++ = cpu_to_be64(bh1->b_blocknr);
634 *ptr++ = cpu_to_be64((__u64)magic);
635 clear_buffer_escaped(bh1);
636 if (unlikely(magic != 0))
637 set_buffer_escaped(bh1);
638 if (++n >= num)
639 break;
Steven Whitehouse18ec7d52006-02-08 11:50:51 +0000640 }
Steven Whitehousef55ab262006-02-21 12:51:39 +0000641 gfs2_log_unlock(sdp);
Steven Whitehouse18ec7d52006-02-08 11:50:51 +0000642 if (bh) {
643 set_buffer_dirty(bh);
644 ll_rw_block(WRITE, 1, &bh);
645 bh = NULL;
Bob Peterson905d2ae2007-07-24 14:05:31 -0500646 ptr = NULL;
Steven Whitehouse18ec7d52006-02-08 11:50:51 +0000647 }
648 n = 0;
Steven Whitehousef55ab262006-02-21 12:51:39 +0000649 gfs2_log_lock(sdp);
Steven Whitehouse568f4c92006-02-27 12:00:42 -0500650 list_for_each_entry_continue(bd2, &sdp->sd_log_le_databuf,
651 bd_le.le_list) {
Steven Whitehouse18ec7d52006-02-08 11:50:51 +0000652 if (!bd2->bd_bh)
653 continue;
654 /* copy buffer if it needs escaping */
Steven Whitehousef55ab262006-02-21 12:51:39 +0000655 gfs2_log_unlock(sdp);
Steven Whitehouse18ec7d52006-02-08 11:50:51 +0000656 if (unlikely(buffer_escaped(bd2->bd_bh))) {
657 void *kaddr;
658 struct page *page = bd2->bd_bh->b_page;
659 bh = gfs2_log_get_buf(sdp);
660 kaddr = kmap_atomic(page, KM_USER0);
Steven Whitehouse568f4c92006-02-27 12:00:42 -0500661 memcpy(bh->b_data,
662 kaddr + bh_offset(bd2->bd_bh),
663 sdp->sd_sb.sb_bsize);
Russell Cattelanc312c4f2006-10-12 09:23:41 -0400664 kunmap_atomic(kaddr, KM_USER0);
Steven Whitehouse18ec7d52006-02-08 11:50:51 +0000665 *(__be32 *)bh->b_data = 0;
666 } else {
667 bh = gfs2_log_fake_buf(sdp, bd2->bd_bh);
668 }
669 set_buffer_dirty(bh);
670 ll_rw_block(WRITE, 1, &bh);
Steven Whitehousef55ab262006-02-21 12:51:39 +0000671 gfs2_log_lock(sdp);
Steven Whitehouse18ec7d52006-02-08 11:50:51 +0000672 if (++n >= num)
673 break;
674 }
675 bh = NULL;
Steven Whitehoused7b616e2007-09-02 10:48:13 +0100676 BUG_ON(total < num);
677 total -= num;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000678 }
Steven Whitehousef55ab262006-02-21 12:51:39 +0000679 gfs2_log_unlock(sdp);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000680}
681
Steven Whitehouse18ec7d52006-02-08 11:50:51 +0000682static int databuf_lo_scan_elements(struct gfs2_jdesc *jd, unsigned int start,
683 struct gfs2_log_descriptor *ld,
684 __be64 *ptr, int pass)
685{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400686 struct gfs2_inode *ip = GFS2_I(jd->jd_inode);
687 struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode);
Steven Whitehouse5c676f62006-02-27 17:23:27 -0500688 struct gfs2_glock *gl = ip->i_gl;
Steven Whitehouse18ec7d52006-02-08 11:50:51 +0000689 unsigned int blks = be32_to_cpu(ld->ld_data1);
690 struct buffer_head *bh_log, *bh_ip;
Steven Whitehousecd915492006-09-04 12:49:07 -0400691 u64 blkno;
692 u64 esc;
Steven Whitehouse18ec7d52006-02-08 11:50:51 +0000693 int error = 0;
694
695 if (pass != 1 || be32_to_cpu(ld->ld_type) != GFS2_LOG_DESC_JDATA)
696 return 0;
697
698 gfs2_replay_incr_blk(sdp, &start);
699 for (; blks; gfs2_replay_incr_blk(sdp, &start), blks--) {
700 blkno = be64_to_cpu(*ptr++);
701 esc = be64_to_cpu(*ptr++);
702
703 sdp->sd_found_blocks++;
704
705 if (gfs2_revoke_check(sdp, blkno, start))
706 continue;
707
708 error = gfs2_replay_read_block(jd, start, &bh_log);
709 if (error)
710 return error;
711
712 bh_ip = gfs2_meta_new(gl, blkno);
713 memcpy(bh_ip->b_data, bh_log->b_data, bh_log->b_size);
714
715 /* Unescape */
716 if (esc) {
717 __be32 *eptr = (__be32 *)bh_ip->b_data;
718 *eptr = cpu_to_be32(GFS2_MAGIC);
719 }
720 mark_buffer_dirty(bh_ip);
721
722 brelse(bh_log);
723 brelse(bh_ip);
724 if (error)
725 break;
726
727 sdp->sd_replayed_blocks++;
728 }
729
730 return error;
731}
732
733/* FIXME: sort out accounting for log blocks etc. */
734
735static void databuf_lo_after_scan(struct gfs2_jdesc *jd, int error, int pass)
736{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400737 struct gfs2_inode *ip = GFS2_I(jd->jd_inode);
738 struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode);
Steven Whitehouse18ec7d52006-02-08 11:50:51 +0000739
740 if (error) {
Steven Whitehouse7276b3b2006-09-21 17:05:23 -0400741 gfs2_meta_sync(ip->i_gl);
Steven Whitehouse18ec7d52006-02-08 11:50:51 +0000742 return;
743 }
744 if (pass != 1)
745 return;
746
747 /* data sync? */
Steven Whitehouse7276b3b2006-09-21 17:05:23 -0400748 gfs2_meta_sync(ip->i_gl);
Steven Whitehouse18ec7d52006-02-08 11:50:51 +0000749
750 fs_info(sdp, "jid=%u: Replayed %u of %u data blocks\n",
751 jd->jd_jid, sdp->sd_replayed_blocks, sdp->sd_found_blocks);
752}
753
754static void databuf_lo_after_commit(struct gfs2_sbd *sdp, struct gfs2_ail *ai)
755{
756 struct list_head *head = &sdp->sd_log_le_databuf;
757 struct gfs2_bufdata *bd;
758
759 while (!list_empty(head)) {
760 bd = list_entry(head->next, struct gfs2_bufdata, bd_le.le_list);
Steven Whitehouseb8e1aab2006-08-22 16:25:50 -0400761 list_del_init(&bd->bd_le.le_list);
Steven Whitehouse18ec7d52006-02-08 11:50:51 +0000762 sdp->sd_log_num_databuf--;
Steven Whitehouse18ec7d52006-02-08 11:50:51 +0000763 gfs2_unpin(sdp, bd->bd_bh, ai);
Steven Whitehouse18ec7d52006-02-08 11:50:51 +0000764 }
765 gfs2_assert_warn(sdp, !sdp->sd_log_num_databuf);
Steven Whitehouse18ec7d52006-02-08 11:50:51 +0000766}
767
768
Steven Whitehouseb09e5932006-04-07 11:17:32 -0400769const struct gfs2_log_operations gfs2_glock_lops = {
David Teiglandb3b94fa2006-01-16 16:50:04 +0000770 .lo_add = glock_lo_add,
771 .lo_after_commit = glock_lo_after_commit,
Steven Whitehouseea67eed2006-09-05 10:53:09 -0400772 .lo_name = "glock",
David Teiglandb3b94fa2006-01-16 16:50:04 +0000773};
774
Steven Whitehouseb09e5932006-04-07 11:17:32 -0400775const struct gfs2_log_operations gfs2_buf_lops = {
David Teiglandb3b94fa2006-01-16 16:50:04 +0000776 .lo_add = buf_lo_add,
777 .lo_incore_commit = buf_lo_incore_commit,
778 .lo_before_commit = buf_lo_before_commit,
779 .lo_after_commit = buf_lo_after_commit,
780 .lo_before_scan = buf_lo_before_scan,
781 .lo_scan_elements = buf_lo_scan_elements,
782 .lo_after_scan = buf_lo_after_scan,
Steven Whitehouseea67eed2006-09-05 10:53:09 -0400783 .lo_name = "buf",
David Teiglandb3b94fa2006-01-16 16:50:04 +0000784};
785
Steven Whitehouseb09e5932006-04-07 11:17:32 -0400786const struct gfs2_log_operations gfs2_revoke_lops = {
David Teiglandb3b94fa2006-01-16 16:50:04 +0000787 .lo_add = revoke_lo_add,
788 .lo_before_commit = revoke_lo_before_commit,
789 .lo_before_scan = revoke_lo_before_scan,
790 .lo_scan_elements = revoke_lo_scan_elements,
791 .lo_after_scan = revoke_lo_after_scan,
Steven Whitehouseea67eed2006-09-05 10:53:09 -0400792 .lo_name = "revoke",
David Teiglandb3b94fa2006-01-16 16:50:04 +0000793};
794
Steven Whitehouseb09e5932006-04-07 11:17:32 -0400795const struct gfs2_log_operations gfs2_rg_lops = {
David Teiglandb3b94fa2006-01-16 16:50:04 +0000796 .lo_add = rg_lo_add,
797 .lo_after_commit = rg_lo_after_commit,
Steven Whitehouseea67eed2006-09-05 10:53:09 -0400798 .lo_name = "rg",
David Teiglandb3b94fa2006-01-16 16:50:04 +0000799};
800
Steven Whitehouseb09e5932006-04-07 11:17:32 -0400801const struct gfs2_log_operations gfs2_databuf_lops = {
David Teiglandb3b94fa2006-01-16 16:50:04 +0000802 .lo_add = databuf_lo_add,
Steven Whitehouse18ec7d52006-02-08 11:50:51 +0000803 .lo_incore_commit = buf_lo_incore_commit,
David Teiglandb3b94fa2006-01-16 16:50:04 +0000804 .lo_before_commit = databuf_lo_before_commit,
Steven Whitehouse18ec7d52006-02-08 11:50:51 +0000805 .lo_after_commit = databuf_lo_after_commit,
806 .lo_scan_elements = databuf_lo_scan_elements,
807 .lo_after_scan = databuf_lo_after_scan,
Steven Whitehouseea67eed2006-09-05 10:53:09 -0400808 .lo_name = "databuf",
David Teiglandb3b94fa2006-01-16 16:50:04 +0000809};
810
Steven Whitehouseb09e5932006-04-07 11:17:32 -0400811const struct gfs2_log_operations *gfs2_log_ops[] = {
David Teiglandb3b94fa2006-01-16 16:50:04 +0000812 &gfs2_glock_lops,
813 &gfs2_buf_lops,
814 &gfs2_revoke_lops,
815 &gfs2_rg_lops,
816 &gfs2_databuf_lops,
Steven Whitehouseea67eed2006-09-05 10:53:09 -0400817 NULL,
David Teiglandb3b94fa2006-01-16 16:50:04 +0000818};
819