~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/gfs2/lops.c

Version: ~ [ linux-5.8-rc4 ] ~ [ linux-5.7.7 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.50 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.131 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.187 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.229 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.229 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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/mempool.h>
 16 #include <linux/gfs2_ondisk.h>
 17 #include <linux/bio.h>
 18 #include <linux/fs.h>
 19 #include <linux/list_sort.h>
 20 
 21 #include "gfs2.h"
 22 #include "incore.h"
 23 #include "inode.h"
 24 #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"
 31 #include "util.h"
 32 #include "trace_gfs2.h"
 33 
 34 /**
 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  */
 41 void gfs2_pin(struct gfs2_sbd *sdp, struct buffer_head *bh)
 42 {
 43         struct gfs2_bufdata *bd;
 44 
 45         BUG_ON(!current->journal_info);
 46 
 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          */
 56         spin_lock(&sdp->sd_ail_lock);
 57         if (bd->bd_tr)
 58                 list_move(&bd->bd_ail_st_list, &bd->bd_tr->tr_ail2_list);
 59         spin_unlock(&sdp->sd_ail_lock);
 60         get_bh(bh);
 61         atomic_inc(&sdp->sd_log_pinned);
 62         trace_gfs2_pin(bd, 1);
 63 }
 64 
 65 static bool buffer_is_rgrp(const struct gfs2_bufdata *bd)
 66 {
 67         return bd->bd_gl->gl_name.ln_type == LM_TYPE_RGRP;
 68 }
 69 
 70 static 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)
 81                 gfs2_rgrp_send_discards(sdp, rgd->rd_data0, bd->bd_bh, bi, 1, NULL);
 82         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 
 88 /**
 89  * gfs2_unpin - Unpin a buffer
 90  * @sdp: the filesystem the buffer belongs to
 91  * @bh: The buffer to unpin
 92  * @ai:
 93  * @flags: The inode dirty flags
 94  *
 95  */
 96 
 97 static void gfs2_unpin(struct gfs2_sbd *sdp, struct buffer_head *bh,
 98                        struct gfs2_trans *tr)
 99 {
100         struct gfs2_bufdata *bd = bh->b_private;
101 
102         BUG_ON(!buffer_uptodate(bh));
103         BUG_ON(!buffer_pinned(bh));
104 
105         lock_buffer(bh);
106         mark_buffer_dirty(bh);
107         clear_buffer_pinned(bh);
108 
109         if (buffer_is_rgrp(bd))
110                 maybe_release_space(bd);
111 
112         spin_lock(&sdp->sd_ail_lock);
113         if (bd->bd_tr) {
114                 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         }
121         bd->bd_tr = tr;
122         list_add(&bd->bd_ail_st_list, &tr->tr_ail1_list);
123         spin_unlock(&sdp->sd_ail_lock);
124 
125         clear_bit(GLF_LFLUSH, &bd->bd_gl->gl_flags);
126         trace_gfs2_pin(bd, 0);
127         unlock_buffer(bh);
128         atomic_dec(&sdp->sd_log_pinned);
129 }
130 
131 static void gfs2_log_incr_head(struct gfs2_sbd *sdp)
132 {
133         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         }
140 }
141 
142 static u64 gfs2_log_bmap(struct gfs2_sbd *sdp)
143 {
144         unsigned int lbn = sdp->sd_log_flush_head;
145         struct gfs2_journal_extent *je;
146         u64 block;
147 
148         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;
157 }
158 
159 /**
160  * 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 
171 static 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.
201  *
202  */
203 
204 static void gfs2_end_log_write(struct bio *bio, int error)
205 {
206         struct gfs2_sbd *sdp = bio->bi_private;
207         struct bio_vec *bvec;
208         struct page *page;
209         int i;
210 
211         if (error) {
212                 sdp->sd_log_error = error;
213                 fs_err(sdp, "Error %d writing to log\n", error);
214         }
215 
216         bio_for_each_segment_all(bvec, bio, i) {
217                 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);
225         if (atomic_dec_and_test(&sdp->sd_log_in_flight))
226                 wake_up(&sdp->sd_log_flush_wait);
227 }
228 
229 /**
230  * gfs2_log_flush_bio - Submit any pending log bio
231  * @sdp: The superblock
232  * @rw: The rw flags
233  *
234  * 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.
236  */
237 
238 void gfs2_log_flush_bio(struct gfs2_sbd *sdp, int rw)
239 {
240         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         }
245 }
246 
247 /**
248  * 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
251  *
252  * 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
258  */
259 
260 static struct bio *gfs2_log_alloc_bio(struct gfs2_sbd *sdp, u64 blkno)
261 {
262         struct super_block *sb = sdp->sd_vfs;
263         unsigned nrvecs = bio_get_nr_vecs(sb->s_bdev);
264         struct bio *bio;
265 
266         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;
283 }
284 
285 /**
286  * 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 
298 static 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) {
304                 nblk = bio_end_sector(bio);
305                 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
317  * @sdp: the filesystem
318  * @page: the page to write
319  * @size: the size of the data to write
320  * @offset: the offset within the page 
321  *
322  * 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.
325  */
326 
327 static void gfs2_log_write(struct gfs2_sbd *sdp, struct page *page,
328                            unsigned size, unsigned offset)
329 {
330         u64 blkno = gfs2_log_bmap(sdp);
331         struct bio *bio;
332         int ret;
333 
334         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         }
342 }
343 
344 /**
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 
354 static void gfs2_log_write_bh(struct gfs2_sbd *sdp, struct buffer_head *bh)
355 {
356         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 
370 void 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 
376 static struct page *gfs2_get_log_desc(struct gfs2_sbd *sdp, u32 ld_type,
377                                       u32 ld_length, u32 ld_data1)
378 {
379         struct page *page = mempool_alloc(gfs2_page_pool, GFP_NOIO);
380         struct gfs2_log_descriptor *ld = page_address(page);
381         clear_page(ld);
382         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);
386         ld->ld_length = cpu_to_be32(ld_length);
387         ld->ld_data1 = cpu_to_be32(ld_data1);
388         ld->ld_data2 = 0;
389         return page;
390 }
391 
392 static 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 
405 static 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 
419 static void gfs2_before_commit(struct gfs2_sbd *sdp, unsigned int limit,
420                                 unsigned int total, struct list_head *blist,
421                                 bool is_databuf)
422 {
423         struct gfs2_log_descriptor *ld;
424         struct gfs2_bufdata *bd1 = NULL, *bd2;
425         struct page *page;
426         unsigned int num;
427         unsigned n;
428         __be64 *ptr;
429 
430         gfs2_log_lock(sdp);
431         list_sort(NULL, blist, blocknr_cmp);
432         bd1 = bd2 = list_prepare_entry(bd1, blist, bd_list);
433         while(total) {
434                 num = total;
435                 if (total > limit)
436                         num = limit;
437                 gfs2_log_unlock(sdp);
438                 page = gfs2_get_log_desc(sdp,
439                                          is_databuf ? GFS2_LOG_DESC_JDATA :
440                                          GFS2_LOG_DESC_METADATA, num + 1, num);
441                 ld = page_address(page);
442                 gfs2_log_lock(sdp);
443                 ptr = (__be64 *)(ld + 1);
444 
445                 n = 0;
446                 list_for_each_entry_continue(bd1, blist, bd_list) {
447                         *ptr++ = cpu_to_be64(bd1->bd_bh->b_blocknr);
448                         if (is_databuf) {
449                                 gfs2_check_magic(bd1->bd_bh);
450                                 *ptr++ = cpu_to_be64(buffer_escaped(bd1->bd_bh) ? 1 : 0);
451                         }
452                         if (++n >= num)
453                                 break;
454                 }
455 
456                 gfs2_log_unlock(sdp);
457                 gfs2_log_write_page(sdp, page);
458                 gfs2_log_lock(sdp);
459 
460                 n = 0;
461                 list_for_each_entry_continue(bd2, blist, bd_list) {
462                         get_bh(bd2->bd_bh);
463                         gfs2_log_unlock(sdp);
464                         lock_buffer(bd2->bd_bh);
465 
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                         }
482                         gfs2_log_lock(sdp);
483                         if (++n >= num)
484                                 break;
485                 }
486 
487                 BUG_ON(total < num);
488                 total -= num;
489         }
490         gfs2_log_unlock(sdp);
491 }
492 
493 static 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 
501 static void buf_lo_after_commit(struct gfs2_sbd *sdp, struct gfs2_trans *tr)
502 {
503         struct list_head *head = &sdp->sd_log_le_buf;
504         struct gfs2_bufdata *bd;
505 
506         if (tr == NULL) {
507                 gfs2_assert(sdp, list_empty(head));
508                 return;
509         }
510 
511         while (!list_empty(head)) {
512                 bd = list_entry(head->next, struct gfs2_bufdata, bd_list);
513                 list_del_init(&bd->bd_list);
514                 sdp->sd_log_num_buf--;
515 
516                 gfs2_unpin(sdp, bd->bd_bh, tr);
517         }
518         gfs2_assert_warn(sdp, !sdp->sd_log_num_buf);
519 }
520 
521 static void buf_lo_before_scan(struct gfs2_jdesc *jd,
522                                struct gfs2_log_header_host *head, int pass)
523 {
524         struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode);
525 
526         if (pass != 0)
527                 return;
528 
529         sdp->sd_found_blocks = 0;
530         sdp->sd_replayed_blocks = 0;
531 }
532 
533 static int buf_lo_scan_elements(struct gfs2_jdesc *jd, unsigned int start,
534                                 struct gfs2_log_descriptor *ld, __be64 *ptr,
535                                 int pass)
536 {
537         struct gfs2_inode *ip = GFS2_I(jd->jd_inode);
538         struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode);
539         struct gfs2_glock *gl = ip->i_gl;
540         unsigned int blks = be32_to_cpu(ld->ld_data1);
541         struct buffer_head *bh_log, *bh_ip;
542         u64 blkno;
543         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);
559                 if (error)
560                         return error;
561 
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 
582 /**
583  * gfs2_meta_sync - Sync all buffers associated with a glock
584  * @gl: The glock
585  *
586  */
587 
588 static void gfs2_meta_sync(struct gfs2_glock *gl)
589 {
590         struct address_space *mapping = gfs2_glock2aspace(gl);
591         int error;
592 
593         filemap_fdatawrite(mapping);
594         error = filemap_fdatawait(mapping);
595 
596         if (error)
597                 gfs2_io_error(gl->gl_sbd);
598 }
599 
600 static void buf_lo_after_scan(struct gfs2_jdesc *jd, int error, int pass)
601 {
602         struct gfs2_inode *ip = GFS2_I(jd->jd_inode);
603         struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode);
604 
605         if (error) {
606                 gfs2_meta_sync(ip->i_gl);
607                 return;
608         }
609         if (pass != 1)
610                 return;
611 
612         gfs2_meta_sync(ip->i_gl);
613 
614         fs_info(sdp, "jid=%u: Replayed %u of %u blocks\n",
615                 jd->jd_jid, sdp->sd_replayed_blocks, sdp->sd_found_blocks);
616 }
617 
618 static void revoke_lo_before_commit(struct gfs2_sbd *sdp)
619 {
620         struct gfs2_meta_header *mh;
621         unsigned int offset;
622         struct list_head *head = &sdp->sd_log_le_revoke;
623         struct gfs2_bufdata *bd;
624         struct page *page;
625         unsigned int length;
626 
627         gfs2_write_revokes(sdp);
628         if (!sdp->sd_log_num_revoke)
629                 return;
630 
631         length = gfs2_struct2blk(sdp, sdp->sd_log_num_revoke, sizeof(u64));
632         page = gfs2_get_log_desc(sdp, GFS2_LOG_DESC_REVOKE, length, sdp->sd_log_num_revoke);
633         offset = sizeof(struct gfs2_log_descriptor);
634 
635         list_for_each_entry(bd, head, bd_list) {
636                 sdp->sd_log_num_revoke--;
637 
638                 if (offset + sizeof(u64) > sdp->sd_sb.sb_bsize) {
639 
640                         gfs2_log_write_page(sdp, page);
641                         page = mempool_alloc(gfs2_page_pool, GFP_NOIO);
642                         mh = page_address(page);
643                         clear_page(mh);
644                         mh->mh_magic = cpu_to_be32(GFS2_MAGIC);
645                         mh->mh_type = cpu_to_be32(GFS2_METATYPE_LB);
646                         mh->mh_format = cpu_to_be32(GFS2_FORMAT_LB);
647                         offset = sizeof(struct gfs2_meta_header);
648                 }
649 
650                 *(__be64 *)(page_address(page) + offset) = cpu_to_be64(bd->bd_blkno);
651                 offset += sizeof(u64);
652         }
653         gfs2_assert_withdraw(sdp, !sdp->sd_log_num_revoke);
654 
655         gfs2_log_write_page(sdp, page);
656 }
657 
658 static void revoke_lo_after_commit(struct gfs2_sbd *sdp, struct gfs2_trans *tr)
659 {
660         struct list_head *head = &sdp->sd_log_le_revoke;
661         struct gfs2_bufdata *bd;
662         struct gfs2_glock *gl;
663 
664         while (!list_empty(head)) {
665                 bd = list_entry(head->next, struct gfs2_bufdata, bd_list);
666                 list_del_init(&bd->bd_list);
667                 gl = bd->bd_gl;
668                 atomic_dec(&gl->gl_revokes);
669                 clear_bit(GLF_LFLUSH, &gl->gl_flags);
670                 kmem_cache_free(gfs2_bufdata_cachep, bd);
671         }
672 }
673 
674 static void revoke_lo_before_scan(struct gfs2_jdesc *jd,
675                                   struct gfs2_log_header_host *head, int pass)
676 {
677         struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode);
678 
679         if (pass != 0)
680                 return;
681 
682         sdp->sd_found_revokes = 0;
683         sdp->sd_replay_tail = head->lh_tail;
684 }
685 
686 static int revoke_lo_scan_elements(struct gfs2_jdesc *jd, unsigned int start,
687                                    struct gfs2_log_descriptor *ld, __be64 *ptr,
688                                    int pass)
689 {
690         struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode);
691         unsigned int blks = be32_to_cpu(ld->ld_length);
692         unsigned int revokes = be32_to_cpu(ld->ld_data1);
693         struct buffer_head *bh;
694         unsigned int offset;
695         u64 blkno;
696         int first = 1;
697         int error;
698 
699         if (pass != 0 || be32_to_cpu(ld->ld_type) != GFS2_LOG_DESC_REVOKE)
700                 return 0;
701 
702         offset = sizeof(struct gfs2_log_descriptor);
703 
704         for (; blks; gfs2_replay_incr_blk(sdp, &start), blks--) {
705                 error = gfs2_replay_read_block(jd, start, &bh);
706                 if (error)
707                         return error;
708 
709                 if (!first)
710                         gfs2_metatype_check(sdp, bh, GFS2_METATYPE_LB);
711 
712                 while (offset + sizeof(u64) <= sdp->sd_sb.sb_bsize) {
713                         blkno = be64_to_cpu(*(__be64 *)(bh->b_data + offset));
714 
715                         error = gfs2_revoke_add(sdp, blkno, start);
716                         if (error < 0) {
717                                 brelse(bh);
718                                 return error;
719                         }
720                         else if (error)
721                                 sdp->sd_found_revokes++;
722 
723                         if (!--revokes)
724                                 break;
725                         offset += sizeof(u64);
726                 }
727 
728                 brelse(bh);
729                 offset = sizeof(struct gfs2_meta_header);
730                 first = 0;
731         }
732 
733         return 0;
734 }
735 
736 static void revoke_lo_after_scan(struct gfs2_jdesc *jd, int error, int pass)
737 {
738         struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode);
739 
740         if (error) {
741                 gfs2_revoke_clean(sdp);
742                 return;
743         }
744         if (pass != 1)
745                 return;
746 
747         fs_info(sdp, "jid=%u: Found %u revoke tags\n",
748                 jd->jd_jid, sdp->sd_found_revokes);
749 
750         gfs2_revoke_clean(sdp);
751 }
752 
753 /**
754  * databuf_lo_before_commit - Scan the data buffers, writing as we go
755  *
756  */
757 
758 static void databuf_lo_before_commit(struct gfs2_sbd *sdp)
759 {
760         unsigned int limit = buf_limit(sdp) / 2;
761 
762         gfs2_before_commit(sdp, limit, sdp->sd_log_num_databuf,
763                            &sdp->sd_log_le_databuf, 1);
764 }
765 
766 static int databuf_lo_scan_elements(struct gfs2_jdesc *jd, unsigned int start,
767                                     struct gfs2_log_descriptor *ld,
768                                     __be64 *ptr, int pass)
769 {
770         struct gfs2_inode *ip = GFS2_I(jd->jd_inode);
771         struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode);
772         struct gfs2_glock *gl = ip->i_gl;
773         unsigned int blks = be32_to_cpu(ld->ld_data1);
774         struct buffer_head *bh_log, *bh_ip;
775         u64 blkno;
776         u64 esc;
777         int error = 0;
778 
779         if (pass != 1 || be32_to_cpu(ld->ld_type) != GFS2_LOG_DESC_JDATA)
780                 return 0;
781 
782         gfs2_replay_incr_blk(sdp, &start);
783         for (; blks; gfs2_replay_incr_blk(sdp, &start), blks--) {
784                 blkno = be64_to_cpu(*ptr++);
785                 esc = be64_to_cpu(*ptr++);
786 
787                 sdp->sd_found_blocks++;
788 
789                 if (gfs2_revoke_check(sdp, blkno, start))
790                         continue;
791 
792                 error = gfs2_replay_read_block(jd, start, &bh_log);
793                 if (error)
794                         return error;
795 
796                 bh_ip = gfs2_meta_new(gl, blkno);
797                 memcpy(bh_ip->b_data, bh_log->b_data, bh_log->b_size);
798 
799                 /* Unescape */
800                 if (esc) {
801                         __be32 *eptr = (__be32 *)bh_ip->b_data;
802                         *eptr = cpu_to_be32(GFS2_MAGIC);
803                 }
804                 mark_buffer_dirty(bh_ip);
805 
806                 brelse(bh_log);
807                 brelse(bh_ip);
808 
809                 sdp->sd_replayed_blocks++;
810         }
811 
812         return error;
813 }
814 
815 /* FIXME: sort out accounting for log blocks etc. */
816 
817 static void databuf_lo_after_scan(struct gfs2_jdesc *jd, int error, int pass)
818 {
819         struct gfs2_inode *ip = GFS2_I(jd->jd_inode);
820         struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode);
821 
822         if (error) {
823                 gfs2_meta_sync(ip->i_gl);
824                 return;
825         }
826         if (pass != 1)
827                 return;
828 
829         /* data sync? */
830         gfs2_meta_sync(ip->i_gl);
831 
832         fs_info(sdp, "jid=%u: Replayed %u of %u data blocks\n",
833                 jd->jd_jid, sdp->sd_replayed_blocks, sdp->sd_found_blocks);
834 }
835 
836 static void databuf_lo_after_commit(struct gfs2_sbd *sdp, struct gfs2_trans *tr)
837 {
838         struct list_head *head = &sdp->sd_log_le_databuf;
839         struct gfs2_bufdata *bd;
840 
841         if (tr == NULL) {
842                 gfs2_assert(sdp, list_empty(head));
843                 return;
844         }
845 
846         while (!list_empty(head)) {
847                 bd = list_entry(head->next, struct gfs2_bufdata, bd_list);
848                 list_del_init(&bd->bd_list);
849                 sdp->sd_log_num_databuf--;
850                 gfs2_unpin(sdp, bd->bd_bh, tr);
851         }
852         gfs2_assert_warn(sdp, !sdp->sd_log_num_databuf);
853 }
854 
855 
856 const struct gfs2_log_operations gfs2_buf_lops = {
857         .lo_before_commit = buf_lo_before_commit,
858         .lo_after_commit = buf_lo_after_commit,
859         .lo_before_scan = buf_lo_before_scan,
860         .lo_scan_elements = buf_lo_scan_elements,
861         .lo_after_scan = buf_lo_after_scan,
862         .lo_name = "buf",
863 };
864 
865 const struct gfs2_log_operations gfs2_revoke_lops = {
866         .lo_before_commit = revoke_lo_before_commit,
867         .lo_after_commit = revoke_lo_after_commit,
868         .lo_before_scan = revoke_lo_before_scan,
869         .lo_scan_elements = revoke_lo_scan_elements,
870         .lo_after_scan = revoke_lo_after_scan,
871         .lo_name = "revoke",
872 };
873 
874 const struct gfs2_log_operations gfs2_databuf_lops = {
875         .lo_before_commit = databuf_lo_before_commit,
876         .lo_after_commit = databuf_lo_after_commit,
877         .lo_scan_elements = databuf_lo_scan_elements,
878         .lo_after_scan = databuf_lo_after_scan,
879         .lo_name = "databuf",
880 };
881 
882 const struct gfs2_log_operations *gfs2_log_ops[] = {
883         &gfs2_databuf_lops,
884         &gfs2_buf_lops,
885         &gfs2_revoke_lops,
886         NULL,
887 };
888 
889 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp