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