2 * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
3 * Copyright (C) 2004-2006 Red Hat, Inc. All rights reserved.
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.
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/crc32.h>
16 #include <linux/gfs2_ondisk.h>
17 #include <linux/bio.h>
18 #include <linux/lm_interface.h>
36 static const u32 gfs2_old_fs_formats
[] = {
40 static const u32 gfs2_old_multihost_formats
[] = {
45 * gfs2_tune_init - Fill a gfs2_tune structure with default values
50 void gfs2_tune_init(struct gfs2_tune
*gt
)
52 spin_lock_init(>
->gt_spin
);
55 gt
->gt_ilimit_tries
= 3;
56 gt
->gt_ilimit_min
= 1;
57 gt
->gt_demote_secs
= 300;
58 gt
->gt_incore_log_blocks
= 1024;
59 gt
->gt_log_flush_secs
= 60;
60 gt
->gt_jindex_refresh_secs
= 60;
61 gt
->gt_recoverd_secs
= 60;
63 gt
->gt_quotad_secs
= 5;
64 gt
->gt_quota_simul_sync
= 64;
65 gt
->gt_quota_warn_period
= 10;
66 gt
->gt_quota_scale_num
= 1;
67 gt
->gt_quota_scale_den
= 1;
68 gt
->gt_quota_cache_secs
= 300;
69 gt
->gt_quota_quantum
= 60;
70 gt
->gt_atime_quantum
= 3600;
71 gt
->gt_new_files_jdata
= 0;
72 gt
->gt_new_files_directio
= 0;
73 gt
->gt_max_readahead
= 1 << 18;
74 gt
->gt_lockdump_size
= 131072;
75 gt
->gt_stall_secs
= 600;
76 gt
->gt_complain_secs
= 10;
77 gt
->gt_reclaim_limit
= 5000;
78 gt
->gt_statfs_quantum
= 30;
79 gt
->gt_statfs_slow
= 0;
83 * gfs2_check_sb - Check superblock
84 * @sdp: the filesystem
86 * @silent: Don't print a message if the check fails
88 * Checks the version code of the FS is one that we understand how to
89 * read and that the sizes of the various on-disk structures have not
93 int gfs2_check_sb(struct gfs2_sbd
*sdp
, struct gfs2_sb_host
*sb
, int silent
)
97 if (sb
->sb_magic
!= GFS2_MAGIC
||
98 sb
->sb_type
!= GFS2_METATYPE_SB
) {
100 printk(KERN_WARNING
"GFS2: not a GFS2 filesystem\n");
104 /* If format numbers match exactly, we're done. */
106 if (sb
->sb_fs_format
== GFS2_FORMAT_FS
&&
107 sb
->sb_multihost_format
== GFS2_FORMAT_MULTI
)
110 if (sb
->sb_fs_format
!= GFS2_FORMAT_FS
) {
111 for (x
= 0; gfs2_old_fs_formats
[x
]; x
++)
112 if (gfs2_old_fs_formats
[x
] == sb
->sb_fs_format
)
115 if (!gfs2_old_fs_formats
[x
]) {
117 "GFS2: code version (%u, %u) is incompatible "
118 "with ondisk format (%u, %u)\n",
119 GFS2_FORMAT_FS
, GFS2_FORMAT_MULTI
,
120 sb
->sb_fs_format
, sb
->sb_multihost_format
);
122 "GFS2: I don't know how to upgrade this FS\n");
127 if (sb
->sb_multihost_format
!= GFS2_FORMAT_MULTI
) {
128 for (x
= 0; gfs2_old_multihost_formats
[x
]; x
++)
129 if (gfs2_old_multihost_formats
[x
] ==
130 sb
->sb_multihost_format
)
133 if (!gfs2_old_multihost_formats
[x
]) {
135 "GFS2: code version (%u, %u) is incompatible "
136 "with ondisk format (%u, %u)\n",
137 GFS2_FORMAT_FS
, GFS2_FORMAT_MULTI
,
138 sb
->sb_fs_format
, sb
->sb_multihost_format
);
140 "GFS2: I don't know how to upgrade this FS\n");
145 if (!sdp
->sd_args
.ar_upgrade
) {
147 "GFS2: code version (%u, %u) is incompatible "
148 "with ondisk format (%u, %u)\n",
149 GFS2_FORMAT_FS
, GFS2_FORMAT_MULTI
,
150 sb
->sb_fs_format
, sb
->sb_multihost_format
);
152 "GFS2: Use the \"upgrade\" mount option to upgrade "
154 printk(KERN_INFO
"GFS2: See the manual for more details\n");
162 static int end_bio_io_page(struct bio
*bio
, unsigned int bytes_done
, int error
)
164 struct page
*page
= bio
->bi_private
;
169 SetPageUptodate(page
);
171 printk(KERN_WARNING
"gfs2: error %d reading superblock\n", error
);
176 static void gfs2_sb_in(struct gfs2_sb_host
*sb
, const void *buf
)
178 const struct gfs2_sb
*str
= buf
;
180 sb
->sb_magic
= be32_to_cpu(str
->sb_header
.mh_magic
);
181 sb
->sb_type
= be32_to_cpu(str
->sb_header
.mh_type
);
182 sb
->sb_format
= be32_to_cpu(str
->sb_header
.mh_format
);
183 sb
->sb_fs_format
= be32_to_cpu(str
->sb_fs_format
);
184 sb
->sb_multihost_format
= be32_to_cpu(str
->sb_multihost_format
);
185 sb
->sb_bsize
= be32_to_cpu(str
->sb_bsize
);
186 sb
->sb_bsize_shift
= be32_to_cpu(str
->sb_bsize_shift
);
187 sb
->sb_master_dir
.no_addr
= be64_to_cpu(str
->sb_master_dir
.no_addr
);
188 sb
->sb_master_dir
.no_formal_ino
= be64_to_cpu(str
->sb_master_dir
.no_formal_ino
);
189 sb
->sb_root_dir
.no_addr
= be64_to_cpu(str
->sb_root_dir
.no_addr
);
190 sb
->sb_root_dir
.no_formal_ino
= be64_to_cpu(str
->sb_root_dir
.no_formal_ino
);
192 memcpy(sb
->sb_lockproto
, str
->sb_lockproto
, GFS2_LOCKNAME_LEN
);
193 memcpy(sb
->sb_locktable
, str
->sb_locktable
, GFS2_LOCKNAME_LEN
);
197 * gfs2_read_super - Read the gfs2 super block from disk
198 * @sdp: The GFS2 super block
199 * @sector: The location of the super block
200 * @error: The error code to return
202 * This uses the bio functions to read the super block from disk
203 * because we want to be 100% sure that we never read cached data.
204 * A super block is read twice only during each GFS2 mount and is
205 * never written to by the filesystem. The first time its read no
206 * locks are held, and the only details which are looked at are those
207 * relating to the locking protocol. Once locking is up and working,
208 * the sb is read again under the lock to establish the location of
209 * the master directory (contains pointers to journals etc) and the
212 * Returns: 0 on success or error
215 int gfs2_read_super(struct gfs2_sbd
*sdp
, sector_t sector
)
217 struct super_block
*sb
= sdp
->sd_vfs
;
222 page
= alloc_page(GFP_KERNEL
);
226 ClearPageUptodate(page
);
227 ClearPageDirty(page
);
230 bio
= bio_alloc(GFP_KERNEL
, 1);
231 if (unlikely(!bio
)) {
236 bio
->bi_sector
= sector
* (sb
->s_blocksize
>> 9);
237 bio
->bi_bdev
= sb
->s_bdev
;
238 bio_add_page(bio
, page
, PAGE_SIZE
, 0);
240 bio
->bi_end_io
= end_bio_io_page
;
241 bio
->bi_private
= page
;
242 submit_bio(READ_SYNC
| (1 << BIO_RW_META
), bio
);
243 wait_on_page_locked(page
);
245 if (!PageUptodate(page
)) {
250 gfs2_sb_in(&sdp
->sd_sb
, p
);
257 * gfs2_read_sb - Read super block
258 * @sdp: The GFS2 superblock
259 * @gl: the glock for the superblock (assumed to be held)
260 * @silent: Don't print message if mount fails
264 int gfs2_read_sb(struct gfs2_sbd
*sdp
, struct gfs2_glock
*gl
, int silent
)
266 u32 hash_blocks
, ind_blocks
, leaf_blocks
;
271 error
= gfs2_read_super(sdp
, GFS2_SB_ADDR
>> sdp
->sd_fsb2bb_shift
);
274 fs_err(sdp
, "can't read superblock\n");
278 error
= gfs2_check_sb(sdp
, &sdp
->sd_sb
, silent
);
282 sdp
->sd_fsb2bb_shift
= sdp
->sd_sb
.sb_bsize_shift
-
283 GFS2_BASIC_BLOCK_SHIFT
;
284 sdp
->sd_fsb2bb
= 1 << sdp
->sd_fsb2bb_shift
;
285 sdp
->sd_diptrs
= (sdp
->sd_sb
.sb_bsize
-
286 sizeof(struct gfs2_dinode
)) / sizeof(u64
);
287 sdp
->sd_inptrs
= (sdp
->sd_sb
.sb_bsize
-
288 sizeof(struct gfs2_meta_header
)) / sizeof(u64
);
289 sdp
->sd_jbsize
= sdp
->sd_sb
.sb_bsize
- sizeof(struct gfs2_meta_header
);
290 sdp
->sd_hash_bsize
= sdp
->sd_sb
.sb_bsize
/ 2;
291 sdp
->sd_hash_bsize_shift
= sdp
->sd_sb
.sb_bsize_shift
- 1;
292 sdp
->sd_hash_ptrs
= sdp
->sd_hash_bsize
/ sizeof(u64
);
293 sdp
->sd_qc_per_block
= (sdp
->sd_sb
.sb_bsize
-
294 sizeof(struct gfs2_meta_header
)) /
295 sizeof(struct gfs2_quota_change
);
297 /* Compute maximum reservation required to add a entry to a directory */
299 hash_blocks
= DIV_ROUND_UP(sizeof(u64
) * (1 << GFS2_DIR_MAX_DEPTH
),
303 for (tmp_blocks
= hash_blocks
; tmp_blocks
> sdp
->sd_diptrs
;) {
304 tmp_blocks
= DIV_ROUND_UP(tmp_blocks
, sdp
->sd_inptrs
);
305 ind_blocks
+= tmp_blocks
;
308 leaf_blocks
= 2 + GFS2_DIR_MAX_DEPTH
;
310 sdp
->sd_max_dirres
= hash_blocks
+ ind_blocks
+ leaf_blocks
;
312 sdp
->sd_heightsize
[0] = sdp
->sd_sb
.sb_bsize
-
313 sizeof(struct gfs2_dinode
);
314 sdp
->sd_heightsize
[1] = sdp
->sd_sb
.sb_bsize
* sdp
->sd_diptrs
;
319 space
= sdp
->sd_heightsize
[x
- 1] * sdp
->sd_inptrs
;
321 m
= do_div(d
, sdp
->sd_inptrs
);
323 if (d
!= sdp
->sd_heightsize
[x
- 1] || m
)
325 sdp
->sd_heightsize
[x
] = space
;
327 sdp
->sd_max_height
= x
;
328 gfs2_assert(sdp
, sdp
->sd_max_height
<= GFS2_MAX_META_HEIGHT
);
330 sdp
->sd_jheightsize
[0] = sdp
->sd_sb
.sb_bsize
-
331 sizeof(struct gfs2_dinode
);
332 sdp
->sd_jheightsize
[1] = sdp
->sd_jbsize
* sdp
->sd_diptrs
;
337 space
= sdp
->sd_jheightsize
[x
- 1] * sdp
->sd_inptrs
;
339 m
= do_div(d
, sdp
->sd_inptrs
);
341 if (d
!= sdp
->sd_jheightsize
[x
- 1] || m
)
343 sdp
->sd_jheightsize
[x
] = space
;
345 sdp
->sd_max_jheight
= x
;
346 gfs2_assert(sdp
, sdp
->sd_max_jheight
<= GFS2_MAX_META_HEIGHT
);
352 * gfs2_jindex_hold - Grab a lock on the jindex
353 * @sdp: The GFS2 superblock
354 * @ji_gh: the holder for the jindex glock
356 * This is very similar to the gfs2_rindex_hold() function, except that
357 * in general we hold the jindex lock for longer periods of time and
358 * we grab it far less frequently (in general) then the rgrp lock.
363 int gfs2_jindex_hold(struct gfs2_sbd
*sdp
, struct gfs2_holder
*ji_gh
)
365 struct gfs2_inode
*dip
= GFS2_I(sdp
->sd_jindex
);
368 struct gfs2_jdesc
*jd
;
373 mutex_lock(&sdp
->sd_jindex_mutex
);
376 error
= gfs2_glock_nq_init(dip
->i_gl
, LM_ST_SHARED
, 0, ji_gh
);
380 name
.len
= sprintf(buf
, "journal%u", sdp
->sd_journals
);
381 name
.hash
= gfs2_disk_hash(name
.name
, name
.len
);
383 error
= gfs2_dir_check(sdp
->sd_jindex
, &name
, NULL
);
384 if (error
== -ENOENT
) {
389 gfs2_glock_dq_uninit(ji_gh
);
395 jd
= kzalloc(sizeof(struct gfs2_jdesc
), GFP_KERNEL
);
399 jd
->jd_inode
= gfs2_lookupi(sdp
->sd_jindex
, &name
, 1, NULL
);
400 if (!jd
->jd_inode
|| IS_ERR(jd
->jd_inode
)) {
404 error
= PTR_ERR(jd
->jd_inode
);
409 spin_lock(&sdp
->sd_jindex_spin
);
410 jd
->jd_jid
= sdp
->sd_journals
++;
411 list_add_tail(&jd
->jd_list
, &sdp
->sd_jindex_list
);
412 spin_unlock(&sdp
->sd_jindex_spin
);
415 mutex_unlock(&sdp
->sd_jindex_mutex
);
421 * gfs2_jindex_free - Clear all the journal index information
422 * @sdp: The GFS2 superblock
426 void gfs2_jindex_free(struct gfs2_sbd
*sdp
)
428 struct list_head list
;
429 struct gfs2_jdesc
*jd
;
431 spin_lock(&sdp
->sd_jindex_spin
);
432 list_add(&list
, &sdp
->sd_jindex_list
);
433 list_del_init(&sdp
->sd_jindex_list
);
434 sdp
->sd_journals
= 0;
435 spin_unlock(&sdp
->sd_jindex_spin
);
437 while (!list_empty(&list
)) {
438 jd
= list_entry(list
.next
, struct gfs2_jdesc
, jd_list
);
439 list_del(&jd
->jd_list
);
445 static struct gfs2_jdesc
*jdesc_find_i(struct list_head
*head
, unsigned int jid
)
447 struct gfs2_jdesc
*jd
;
450 list_for_each_entry(jd
, head
, jd_list
) {
451 if (jd
->jd_jid
== jid
) {
463 struct gfs2_jdesc
*gfs2_jdesc_find(struct gfs2_sbd
*sdp
, unsigned int jid
)
465 struct gfs2_jdesc
*jd
;
467 spin_lock(&sdp
->sd_jindex_spin
);
468 jd
= jdesc_find_i(&sdp
->sd_jindex_list
, jid
);
469 spin_unlock(&sdp
->sd_jindex_spin
);
474 void gfs2_jdesc_make_dirty(struct gfs2_sbd
*sdp
, unsigned int jid
)
476 struct gfs2_jdesc
*jd
;
478 spin_lock(&sdp
->sd_jindex_spin
);
479 jd
= jdesc_find_i(&sdp
->sd_jindex_list
, jid
);
482 spin_unlock(&sdp
->sd_jindex_spin
);
485 struct gfs2_jdesc
*gfs2_jdesc_find_dirty(struct gfs2_sbd
*sdp
)
487 struct gfs2_jdesc
*jd
;
490 spin_lock(&sdp
->sd_jindex_spin
);
492 list_for_each_entry(jd
, &sdp
->sd_jindex_list
, jd_list
) {
499 spin_unlock(&sdp
->sd_jindex_spin
);
507 int gfs2_jdesc_check(struct gfs2_jdesc
*jd
)
509 struct gfs2_inode
*ip
= GFS2_I(jd
->jd_inode
);
510 struct gfs2_sbd
*sdp
= GFS2_SB(jd
->jd_inode
);
514 if (ip
->i_di
.di_size
< (8 << 20) || ip
->i_di
.di_size
> (1 << 30) ||
515 (ip
->i_di
.di_size
& (sdp
->sd_sb
.sb_bsize
- 1))) {
516 gfs2_consist_inode(ip
);
519 jd
->jd_blocks
= ip
->i_di
.di_size
>> sdp
->sd_sb
.sb_bsize_shift
;
521 error
= gfs2_write_alloc_required(ip
, 0, ip
->i_di
.di_size
, &ar
);
523 gfs2_consist_inode(ip
);
531 * gfs2_make_fs_rw - Turn a Read-Only FS into a Read-Write one
532 * @sdp: the filesystem
537 int gfs2_make_fs_rw(struct gfs2_sbd
*sdp
)
539 struct gfs2_inode
*ip
= GFS2_I(sdp
->sd_jdesc
->jd_inode
);
540 struct gfs2_glock
*j_gl
= ip
->i_gl
;
541 struct gfs2_holder t_gh
;
542 struct gfs2_log_header_host head
;
545 error
= gfs2_glock_nq_init(sdp
->sd_trans_gl
, LM_ST_SHARED
, 0, &t_gh
);
549 gfs2_meta_cache_flush(ip
);
550 j_gl
->gl_ops
->go_inval(j_gl
, DIO_METADATA
);
552 error
= gfs2_find_jhead(sdp
->sd_jdesc
, &head
);
556 if (!(head
.lh_flags
& GFS2_LOG_HEAD_UNMOUNT
)) {
562 /* Initialize some head of the log stuff */
563 sdp
->sd_log_sequence
= head
.lh_sequence
+ 1;
564 gfs2_log_pointers_init(sdp
, head
.lh_blkno
);
566 error
= gfs2_quota_init(sdp
);
570 set_bit(SDF_JOURNAL_LIVE
, &sdp
->sd_flags
);
572 gfs2_glock_dq_uninit(&t_gh
);
577 t_gh
.gh_flags
|= GL_NOCACHE
;
578 gfs2_glock_dq_uninit(&t_gh
);
584 * gfs2_make_fs_ro - Turn a Read-Write FS into a Read-Only one
585 * @sdp: the filesystem
590 int gfs2_make_fs_ro(struct gfs2_sbd
*sdp
)
592 struct gfs2_holder t_gh
;
595 gfs2_quota_sync(sdp
);
596 gfs2_statfs_sync(sdp
);
598 error
= gfs2_glock_nq_init(sdp
->sd_trans_gl
, LM_ST_SHARED
, GL_NOCACHE
,
600 if (error
&& !test_bit(SDF_SHUTDOWN
, &sdp
->sd_flags
))
603 gfs2_meta_syncfs(sdp
);
604 gfs2_log_shutdown(sdp
);
606 clear_bit(SDF_JOURNAL_LIVE
, &sdp
->sd_flags
);
609 gfs2_glock_dq_uninit(&t_gh
);
611 gfs2_quota_cleanup(sdp
);
616 static void gfs2_statfs_change_in(struct gfs2_statfs_change_host
*sc
, const void *buf
)
618 const struct gfs2_statfs_change
*str
= buf
;
620 sc
->sc_total
= be64_to_cpu(str
->sc_total
);
621 sc
->sc_free
= be64_to_cpu(str
->sc_free
);
622 sc
->sc_dinodes
= be64_to_cpu(str
->sc_dinodes
);
625 static void gfs2_statfs_change_out(const struct gfs2_statfs_change_host
*sc
, void *buf
)
627 struct gfs2_statfs_change
*str
= buf
;
629 str
->sc_total
= cpu_to_be64(sc
->sc_total
);
630 str
->sc_free
= cpu_to_be64(sc
->sc_free
);
631 str
->sc_dinodes
= cpu_to_be64(sc
->sc_dinodes
);
634 int gfs2_statfs_init(struct gfs2_sbd
*sdp
)
636 struct gfs2_inode
*m_ip
= GFS2_I(sdp
->sd_statfs_inode
);
637 struct gfs2_statfs_change_host
*m_sc
= &sdp
->sd_statfs_master
;
638 struct gfs2_inode
*l_ip
= GFS2_I(sdp
->sd_sc_inode
);
639 struct gfs2_statfs_change_host
*l_sc
= &sdp
->sd_statfs_local
;
640 struct buffer_head
*m_bh
, *l_bh
;
641 struct gfs2_holder gh
;
644 error
= gfs2_glock_nq_init(m_ip
->i_gl
, LM_ST_EXCLUSIVE
, GL_NOCACHE
,
649 error
= gfs2_meta_inode_buffer(m_ip
, &m_bh
);
653 if (sdp
->sd_args
.ar_spectator
) {
654 spin_lock(&sdp
->sd_statfs_spin
);
655 gfs2_statfs_change_in(m_sc
, m_bh
->b_data
+
656 sizeof(struct gfs2_dinode
));
657 spin_unlock(&sdp
->sd_statfs_spin
);
659 error
= gfs2_meta_inode_buffer(l_ip
, &l_bh
);
663 spin_lock(&sdp
->sd_statfs_spin
);
664 gfs2_statfs_change_in(m_sc
, m_bh
->b_data
+
665 sizeof(struct gfs2_dinode
));
666 gfs2_statfs_change_in(l_sc
, l_bh
->b_data
+
667 sizeof(struct gfs2_dinode
));
668 spin_unlock(&sdp
->sd_statfs_spin
);
676 gfs2_glock_dq_uninit(&gh
);
680 void gfs2_statfs_change(struct gfs2_sbd
*sdp
, s64 total
, s64 free
,
683 struct gfs2_inode
*l_ip
= GFS2_I(sdp
->sd_sc_inode
);
684 struct gfs2_statfs_change_host
*l_sc
= &sdp
->sd_statfs_local
;
685 struct buffer_head
*l_bh
;
688 error
= gfs2_meta_inode_buffer(l_ip
, &l_bh
);
692 mutex_lock(&sdp
->sd_statfs_mutex
);
693 gfs2_trans_add_bh(l_ip
->i_gl
, l_bh
, 1);
694 mutex_unlock(&sdp
->sd_statfs_mutex
);
696 spin_lock(&sdp
->sd_statfs_spin
);
697 l_sc
->sc_total
+= total
;
698 l_sc
->sc_free
+= free
;
699 l_sc
->sc_dinodes
+= dinodes
;
700 gfs2_statfs_change_out(l_sc
, l_bh
->b_data
+ sizeof(struct gfs2_dinode
));
701 spin_unlock(&sdp
->sd_statfs_spin
);
706 int gfs2_statfs_sync(struct gfs2_sbd
*sdp
)
708 struct gfs2_inode
*m_ip
= GFS2_I(sdp
->sd_statfs_inode
);
709 struct gfs2_inode
*l_ip
= GFS2_I(sdp
->sd_sc_inode
);
710 struct gfs2_statfs_change_host
*m_sc
= &sdp
->sd_statfs_master
;
711 struct gfs2_statfs_change_host
*l_sc
= &sdp
->sd_statfs_local
;
712 struct gfs2_holder gh
;
713 struct buffer_head
*m_bh
, *l_bh
;
716 error
= gfs2_glock_nq_init(m_ip
->i_gl
, LM_ST_EXCLUSIVE
, GL_NOCACHE
,
721 error
= gfs2_meta_inode_buffer(m_ip
, &m_bh
);
725 spin_lock(&sdp
->sd_statfs_spin
);
726 gfs2_statfs_change_in(m_sc
, m_bh
->b_data
+
727 sizeof(struct gfs2_dinode
));
728 if (!l_sc
->sc_total
&& !l_sc
->sc_free
&& !l_sc
->sc_dinodes
) {
729 spin_unlock(&sdp
->sd_statfs_spin
);
732 spin_unlock(&sdp
->sd_statfs_spin
);
734 error
= gfs2_meta_inode_buffer(l_ip
, &l_bh
);
738 error
= gfs2_trans_begin(sdp
, 2 * RES_DINODE
, 0);
742 mutex_lock(&sdp
->sd_statfs_mutex
);
743 gfs2_trans_add_bh(l_ip
->i_gl
, l_bh
, 1);
744 mutex_unlock(&sdp
->sd_statfs_mutex
);
746 spin_lock(&sdp
->sd_statfs_spin
);
747 m_sc
->sc_total
+= l_sc
->sc_total
;
748 m_sc
->sc_free
+= l_sc
->sc_free
;
749 m_sc
->sc_dinodes
+= l_sc
->sc_dinodes
;
750 memset(l_sc
, 0, sizeof(struct gfs2_statfs_change
));
751 memset(l_bh
->b_data
+ sizeof(struct gfs2_dinode
),
752 0, sizeof(struct gfs2_statfs_change
));
753 spin_unlock(&sdp
->sd_statfs_spin
);
755 gfs2_trans_add_bh(m_ip
->i_gl
, m_bh
, 1);
756 gfs2_statfs_change_out(m_sc
, m_bh
->b_data
+ sizeof(struct gfs2_dinode
));
765 gfs2_glock_dq_uninit(&gh
);
770 * gfs2_statfs_i - Do a statfs
771 * @sdp: the filesystem
772 * @sg: the sg structure
777 int gfs2_statfs_i(struct gfs2_sbd
*sdp
, struct gfs2_statfs_change_host
*sc
)
779 struct gfs2_statfs_change_host
*m_sc
= &sdp
->sd_statfs_master
;
780 struct gfs2_statfs_change_host
*l_sc
= &sdp
->sd_statfs_local
;
782 spin_lock(&sdp
->sd_statfs_spin
);
785 sc
->sc_total
+= l_sc
->sc_total
;
786 sc
->sc_free
+= l_sc
->sc_free
;
787 sc
->sc_dinodes
+= l_sc
->sc_dinodes
;
789 spin_unlock(&sdp
->sd_statfs_spin
);
793 if (sc
->sc_free
> sc
->sc_total
)
794 sc
->sc_free
= sc
->sc_total
;
795 if (sc
->sc_dinodes
< 0)
802 * statfs_fill - fill in the sg for a given RG
804 * @sc: the sc structure
806 * Returns: 0 on success, -ESTALE if the LVB is invalid
809 static int statfs_slow_fill(struct gfs2_rgrpd
*rgd
,
810 struct gfs2_statfs_change_host
*sc
)
812 gfs2_rgrp_verify(rgd
);
813 sc
->sc_total
+= rgd
->rd_data
;
814 sc
->sc_free
+= rgd
->rd_rg
.rg_free
;
815 sc
->sc_dinodes
+= rgd
->rd_rg
.rg_dinodes
;
820 * gfs2_statfs_slow - Stat a filesystem using asynchronous locking
821 * @sdp: the filesystem
822 * @sc: the sc info that will be returned
824 * Any error (other than a signal) will cause this routine to fall back
825 * to the synchronous version.
827 * FIXME: This really shouldn't busy wait like this.
832 int gfs2_statfs_slow(struct gfs2_sbd
*sdp
, struct gfs2_statfs_change_host
*sc
)
834 struct gfs2_holder ri_gh
;
835 struct gfs2_rgrpd
*rgd_next
;
836 struct gfs2_holder
*gha
, *gh
;
837 unsigned int slots
= 64;
842 memset(sc
, 0, sizeof(struct gfs2_statfs_change_host
));
843 gha
= kcalloc(slots
, sizeof(struct gfs2_holder
), GFP_KERNEL
);
847 error
= gfs2_rindex_hold(sdp
, &ri_gh
);
851 rgd_next
= gfs2_rgrpd_get_first(sdp
);
856 for (x
= 0; x
< slots
; x
++) {
859 if (gh
->gh_gl
&& gfs2_glock_poll(gh
)) {
860 err
= gfs2_glock_wait(gh
);
862 gfs2_holder_uninit(gh
);
866 error
= statfs_slow_fill(
867 gh
->gh_gl
->gl_object
, sc
);
868 gfs2_glock_dq_uninit(gh
);
874 else if (rgd_next
&& !error
) {
875 error
= gfs2_glock_nq_init(rgd_next
->rd_gl
,
879 rgd_next
= gfs2_rgrpd_get_next(rgd_next
);
883 if (signal_pending(current
))
884 error
= -ERESTARTSYS
;
893 gfs2_glock_dq_uninit(&ri_gh
);
901 struct list_head list
;
902 struct gfs2_holder gh
;
906 * gfs2_lock_fs_check_clean - Stop all writes to the FS and check that all
908 * @sdp: the file system
909 * @state: the state to put the transaction lock into
910 * @t_gh: the hold on the transaction lock
915 static int gfs2_lock_fs_check_clean(struct gfs2_sbd
*sdp
,
916 struct gfs2_holder
*t_gh
)
918 struct gfs2_inode
*ip
;
919 struct gfs2_holder ji_gh
;
920 struct gfs2_jdesc
*jd
;
923 struct gfs2_log_header_host lh
;
926 error
= gfs2_jindex_hold(sdp
, &ji_gh
);
930 list_for_each_entry(jd
, &sdp
->sd_jindex_list
, jd_list
) {
931 lfcc
= kmalloc(sizeof(struct lfcc
), GFP_KERNEL
);
936 ip
= GFS2_I(jd
->jd_inode
);
937 error
= gfs2_glock_nq_init(ip
->i_gl
, LM_ST_SHARED
, 0, &lfcc
->gh
);
942 list_add(&lfcc
->list
, &list
);
945 error
= gfs2_glock_nq_init(sdp
->sd_trans_gl
, LM_ST_DEFERRED
,
946 LM_FLAG_PRIORITY
| GL_NOCACHE
,
949 list_for_each_entry(jd
, &sdp
->sd_jindex_list
, jd_list
) {
950 error
= gfs2_jdesc_check(jd
);
953 error
= gfs2_find_jhead(jd
, &lh
);
956 if (!(lh
.lh_flags
& GFS2_LOG_HEAD_UNMOUNT
)) {
963 gfs2_glock_dq_uninit(t_gh
);
966 while (!list_empty(&list
)) {
967 lfcc
= list_entry(list
.next
, struct lfcc
, list
);
968 list_del(&lfcc
->list
);
969 gfs2_glock_dq_uninit(&lfcc
->gh
);
972 gfs2_glock_dq_uninit(&ji_gh
);
977 * gfs2_freeze_fs - freezes the file system
978 * @sdp: the file system
980 * This function flushes data and meta data for all machines by
981 * aquiring the transaction log exclusively. All journals are
982 * ensured to be in a clean state as well.
987 int gfs2_freeze_fs(struct gfs2_sbd
*sdp
)
991 mutex_lock(&sdp
->sd_freeze_lock
);
993 if (!sdp
->sd_freeze_count
++) {
994 error
= gfs2_lock_fs_check_clean(sdp
, &sdp
->sd_freeze_gh
);
996 sdp
->sd_freeze_count
--;
999 mutex_unlock(&sdp
->sd_freeze_lock
);
1005 * gfs2_unfreeze_fs - unfreezes the file system
1006 * @sdp: the file system
1008 * This function allows the file system to proceed by unlocking
1009 * the exclusively held transaction lock. Other GFS2 nodes are
1010 * now free to acquire the lock shared and go on with their lives.
1014 void gfs2_unfreeze_fs(struct gfs2_sbd
*sdp
)
1016 mutex_lock(&sdp
->sd_freeze_lock
);
1018 if (sdp
->sd_freeze_count
&& !--sdp
->sd_freeze_count
)
1019 gfs2_glock_dq_uninit(&sdp
->sd_freeze_gh
);
1021 mutex_unlock(&sdp
->sd_freeze_lock
);