1 // SPDX-License-Identifier: GPL-2.0-only
3 * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
4 * Copyright (C) 2004-2007 Red Hat, Inc. All rights reserved.
7 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
10 #include <linux/sched/signal.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/statfs.h>
16 #include <linux/seq_file.h>
17 #include <linux/mount.h>
18 #include <linux/kthread.h>
19 #include <linux/delay.h>
20 #include <linux/gfs2_ondisk.h>
21 #include <linux/crc32.h>
22 #include <linux/time.h>
23 #include <linux/wait.h>
24 #include <linux/writeback.h>
25 #include <linux/backing-dev.h>
26 #include <linux/kernel.h>
49 SHOULD_NOT_DELETE_DINODE
,
50 SHOULD_DEFER_EVICTION
,
54 * gfs2_jindex_free - Clear all the journal index information
55 * @sdp: The GFS2 superblock
59 void gfs2_jindex_free(struct gfs2_sbd
*sdp
)
61 struct list_head list
;
62 struct gfs2_jdesc
*jd
;
64 spin_lock(&sdp
->sd_jindex_spin
);
65 list_add(&list
, &sdp
->sd_jindex_list
);
66 list_del_init(&sdp
->sd_jindex_list
);
68 spin_unlock(&sdp
->sd_jindex_spin
);
71 while (!list_empty(&list
)) {
72 jd
= list_first_entry(&list
, struct gfs2_jdesc
, jd_list
);
73 gfs2_free_journal_extents(jd
);
74 list_del(&jd
->jd_list
);
81 static struct gfs2_jdesc
*jdesc_find_i(struct list_head
*head
, unsigned int jid
)
83 struct gfs2_jdesc
*jd
;
85 list_for_each_entry(jd
, head
, jd_list
) {
86 if (jd
->jd_jid
== jid
)
92 struct gfs2_jdesc
*gfs2_jdesc_find(struct gfs2_sbd
*sdp
, unsigned int jid
)
94 struct gfs2_jdesc
*jd
;
96 spin_lock(&sdp
->sd_jindex_spin
);
97 jd
= jdesc_find_i(&sdp
->sd_jindex_list
, jid
);
98 spin_unlock(&sdp
->sd_jindex_spin
);
103 int gfs2_jdesc_check(struct gfs2_jdesc
*jd
)
105 struct gfs2_inode
*ip
= GFS2_I(jd
->jd_inode
);
106 struct gfs2_sbd
*sdp
= GFS2_SB(jd
->jd_inode
);
107 u64 size
= i_size_read(jd
->jd_inode
);
109 if (gfs2_check_internal_file_size(jd
->jd_inode
, 8 << 20, BIT(30)))
112 jd
->jd_blocks
= size
>> sdp
->sd_sb
.sb_bsize_shift
;
114 if (gfs2_write_alloc_required(ip
, 0, size
)) {
115 gfs2_consist_inode(ip
);
123 * gfs2_make_fs_rw - Turn a Read-Only FS into a Read-Write one
124 * @sdp: the filesystem
129 int gfs2_make_fs_rw(struct gfs2_sbd
*sdp
)
131 struct gfs2_inode
*ip
= GFS2_I(sdp
->sd_jdesc
->jd_inode
);
132 struct gfs2_glock
*j_gl
= ip
->i_gl
;
133 struct gfs2_log_header_host head
;
136 j_gl
->gl_ops
->go_inval(j_gl
, DIO_METADATA
);
137 if (gfs2_withdrawn(sdp
))
140 error
= gfs2_find_jhead(sdp
->sd_jdesc
, &head
, false);
141 if (error
|| gfs2_withdrawn(sdp
))
144 if (!(head
.lh_flags
& GFS2_LOG_HEAD_UNMOUNT
)) {
149 /* Initialize some head of the log stuff */
150 sdp
->sd_log_sequence
= head
.lh_sequence
+ 1;
151 gfs2_log_pointers_init(sdp
, head
.lh_blkno
);
153 error
= gfs2_quota_init(sdp
);
154 if (!error
&& !gfs2_withdrawn(sdp
))
155 set_bit(SDF_JOURNAL_LIVE
, &sdp
->sd_flags
);
159 void gfs2_statfs_change_in(struct gfs2_statfs_change_host
*sc
, const void *buf
)
161 const struct gfs2_statfs_change
*str
= buf
;
163 sc
->sc_total
= be64_to_cpu(str
->sc_total
);
164 sc
->sc_free
= be64_to_cpu(str
->sc_free
);
165 sc
->sc_dinodes
= be64_to_cpu(str
->sc_dinodes
);
168 void gfs2_statfs_change_out(const struct gfs2_statfs_change_host
*sc
, void *buf
)
170 struct gfs2_statfs_change
*str
= buf
;
172 str
->sc_total
= cpu_to_be64(sc
->sc_total
);
173 str
->sc_free
= cpu_to_be64(sc
->sc_free
);
174 str
->sc_dinodes
= cpu_to_be64(sc
->sc_dinodes
);
177 int gfs2_statfs_init(struct gfs2_sbd
*sdp
)
179 struct gfs2_inode
*m_ip
= GFS2_I(sdp
->sd_statfs_inode
);
180 struct gfs2_statfs_change_host
*m_sc
= &sdp
->sd_statfs_master
;
181 struct gfs2_statfs_change_host
*l_sc
= &sdp
->sd_statfs_local
;
182 struct buffer_head
*m_bh
;
183 struct gfs2_holder gh
;
186 error
= gfs2_glock_nq_init(m_ip
->i_gl
, LM_ST_EXCLUSIVE
, GL_NOCACHE
,
191 error
= gfs2_meta_inode_buffer(m_ip
, &m_bh
);
195 if (sdp
->sd_args
.ar_spectator
) {
196 spin_lock(&sdp
->sd_statfs_spin
);
197 gfs2_statfs_change_in(m_sc
, m_bh
->b_data
+
198 sizeof(struct gfs2_dinode
));
199 spin_unlock(&sdp
->sd_statfs_spin
);
201 spin_lock(&sdp
->sd_statfs_spin
);
202 gfs2_statfs_change_in(m_sc
, m_bh
->b_data
+
203 sizeof(struct gfs2_dinode
));
204 gfs2_statfs_change_in(l_sc
, sdp
->sd_sc_bh
->b_data
+
205 sizeof(struct gfs2_dinode
));
206 spin_unlock(&sdp
->sd_statfs_spin
);
212 gfs2_glock_dq_uninit(&gh
);
216 void gfs2_statfs_change(struct gfs2_sbd
*sdp
, s64 total
, s64 free
,
219 struct gfs2_inode
*l_ip
= GFS2_I(sdp
->sd_sc_inode
);
220 struct gfs2_statfs_change_host
*l_sc
= &sdp
->sd_statfs_local
;
221 struct gfs2_statfs_change_host
*m_sc
= &sdp
->sd_statfs_master
;
225 gfs2_trans_add_meta(l_ip
->i_gl
, sdp
->sd_sc_bh
);
227 spin_lock(&sdp
->sd_statfs_spin
);
228 l_sc
->sc_total
+= total
;
229 l_sc
->sc_free
+= free
;
230 l_sc
->sc_dinodes
+= dinodes
;
231 gfs2_statfs_change_out(l_sc
, sdp
->sd_sc_bh
->b_data
+
232 sizeof(struct gfs2_dinode
));
233 if (sdp
->sd_args
.ar_statfs_percent
) {
234 x
= 100 * l_sc
->sc_free
;
235 y
= m_sc
->sc_free
* sdp
->sd_args
.ar_statfs_percent
;
236 if (x
>= y
|| x
<= -y
)
239 spin_unlock(&sdp
->sd_statfs_spin
);
242 gfs2_wake_up_statfs(sdp
);
245 void update_statfs(struct gfs2_sbd
*sdp
, struct buffer_head
*m_bh
)
247 struct gfs2_inode
*m_ip
= GFS2_I(sdp
->sd_statfs_inode
);
248 struct gfs2_inode
*l_ip
= GFS2_I(sdp
->sd_sc_inode
);
249 struct gfs2_statfs_change_host
*m_sc
= &sdp
->sd_statfs_master
;
250 struct gfs2_statfs_change_host
*l_sc
= &sdp
->sd_statfs_local
;
252 gfs2_trans_add_meta(l_ip
->i_gl
, sdp
->sd_sc_bh
);
253 gfs2_trans_add_meta(m_ip
->i_gl
, m_bh
);
255 spin_lock(&sdp
->sd_statfs_spin
);
256 m_sc
->sc_total
+= l_sc
->sc_total
;
257 m_sc
->sc_free
+= l_sc
->sc_free
;
258 m_sc
->sc_dinodes
+= l_sc
->sc_dinodes
;
259 memset(l_sc
, 0, sizeof(struct gfs2_statfs_change
));
260 memset(sdp
->sd_sc_bh
->b_data
+ sizeof(struct gfs2_dinode
),
261 0, sizeof(struct gfs2_statfs_change
));
262 gfs2_statfs_change_out(m_sc
, m_bh
->b_data
+ sizeof(struct gfs2_dinode
));
263 spin_unlock(&sdp
->sd_statfs_spin
);
266 int gfs2_statfs_sync(struct super_block
*sb
, int type
)
268 struct gfs2_sbd
*sdp
= sb
->s_fs_info
;
269 struct gfs2_inode
*m_ip
= GFS2_I(sdp
->sd_statfs_inode
);
270 struct gfs2_statfs_change_host
*m_sc
= &sdp
->sd_statfs_master
;
271 struct gfs2_statfs_change_host
*l_sc
= &sdp
->sd_statfs_local
;
272 struct gfs2_holder gh
;
273 struct buffer_head
*m_bh
;
276 error
= gfs2_glock_nq_init(m_ip
->i_gl
, LM_ST_EXCLUSIVE
, GL_NOCACHE
,
281 error
= gfs2_meta_inode_buffer(m_ip
, &m_bh
);
285 spin_lock(&sdp
->sd_statfs_spin
);
286 gfs2_statfs_change_in(m_sc
, m_bh
->b_data
+
287 sizeof(struct gfs2_dinode
));
288 if (!l_sc
->sc_total
&& !l_sc
->sc_free
&& !l_sc
->sc_dinodes
) {
289 spin_unlock(&sdp
->sd_statfs_spin
);
292 spin_unlock(&sdp
->sd_statfs_spin
);
294 error
= gfs2_trans_begin(sdp
, 2 * RES_DINODE
, 0);
298 update_statfs(sdp
, m_bh
);
299 sdp
->sd_statfs_force_sync
= 0;
306 gfs2_glock_dq_uninit(&gh
);
312 struct list_head list
;
313 struct gfs2_holder gh
;
317 * gfs2_lock_fs_check_clean - Stop all writes to the FS and check that all
319 * @sdp: the file system
324 static int gfs2_lock_fs_check_clean(struct gfs2_sbd
*sdp
)
326 struct gfs2_inode
*ip
;
327 struct gfs2_jdesc
*jd
;
330 struct gfs2_log_header_host lh
;
333 list_for_each_entry(jd
, &sdp
->sd_jindex_list
, jd_list
) {
334 lfcc
= kmalloc(sizeof(struct lfcc
), GFP_KERNEL
);
339 ip
= GFS2_I(jd
->jd_inode
);
340 error
= gfs2_glock_nq_init(ip
->i_gl
, LM_ST_SHARED
, 0, &lfcc
->gh
);
345 list_add(&lfcc
->list
, &list
);
348 error
= gfs2_glock_nq_init(sdp
->sd_freeze_gl
, LM_ST_EXCLUSIVE
,
349 LM_FLAG_NOEXP
, &sdp
->sd_freeze_gh
);
353 list_for_each_entry(jd
, &sdp
->sd_jindex_list
, jd_list
) {
354 error
= gfs2_jdesc_check(jd
);
357 error
= gfs2_find_jhead(jd
, &lh
, false);
360 if (!(lh
.lh_flags
& GFS2_LOG_HEAD_UNMOUNT
)) {
367 gfs2_freeze_unlock(&sdp
->sd_freeze_gh
);
370 while (!list_empty(&list
)) {
371 lfcc
= list_first_entry(&list
, struct lfcc
, list
);
372 list_del(&lfcc
->list
);
373 gfs2_glock_dq_uninit(&lfcc
->gh
);
379 void gfs2_dinode_out(const struct gfs2_inode
*ip
, void *buf
)
381 struct gfs2_dinode
*str
= buf
;
383 str
->di_header
.mh_magic
= cpu_to_be32(GFS2_MAGIC
);
384 str
->di_header
.mh_type
= cpu_to_be32(GFS2_METATYPE_DI
);
385 str
->di_header
.mh_format
= cpu_to_be32(GFS2_FORMAT_DI
);
386 str
->di_num
.no_addr
= cpu_to_be64(ip
->i_no_addr
);
387 str
->di_num
.no_formal_ino
= cpu_to_be64(ip
->i_no_formal_ino
);
388 str
->di_mode
= cpu_to_be32(ip
->i_inode
.i_mode
);
389 str
->di_uid
= cpu_to_be32(i_uid_read(&ip
->i_inode
));
390 str
->di_gid
= cpu_to_be32(i_gid_read(&ip
->i_inode
));
391 str
->di_nlink
= cpu_to_be32(ip
->i_inode
.i_nlink
);
392 str
->di_size
= cpu_to_be64(i_size_read(&ip
->i_inode
));
393 str
->di_blocks
= cpu_to_be64(gfs2_get_inode_blocks(&ip
->i_inode
));
394 str
->di_atime
= cpu_to_be64(ip
->i_inode
.i_atime
.tv_sec
);
395 str
->di_mtime
= cpu_to_be64(ip
->i_inode
.i_mtime
.tv_sec
);
396 str
->di_ctime
= cpu_to_be64(ip
->i_inode
.i_ctime
.tv_sec
);
398 str
->di_goal_meta
= cpu_to_be64(ip
->i_goal
);
399 str
->di_goal_data
= cpu_to_be64(ip
->i_goal
);
400 str
->di_generation
= cpu_to_be64(ip
->i_generation
);
402 str
->di_flags
= cpu_to_be32(ip
->i_diskflags
);
403 str
->di_height
= cpu_to_be16(ip
->i_height
);
404 str
->di_payload_format
= cpu_to_be32(S_ISDIR(ip
->i_inode
.i_mode
) &&
405 !(ip
->i_diskflags
& GFS2_DIF_EXHASH
) ?
407 str
->di_depth
= cpu_to_be16(ip
->i_depth
);
408 str
->di_entries
= cpu_to_be32(ip
->i_entries
);
410 str
->di_eattr
= cpu_to_be64(ip
->i_eattr
);
411 str
->di_atime_nsec
= cpu_to_be32(ip
->i_inode
.i_atime
.tv_nsec
);
412 str
->di_mtime_nsec
= cpu_to_be32(ip
->i_inode
.i_mtime
.tv_nsec
);
413 str
->di_ctime_nsec
= cpu_to_be32(ip
->i_inode
.i_ctime
.tv_nsec
);
417 * gfs2_write_inode - Make sure the inode is stable on the disk
419 * @wbc: The writeback control structure
424 static int gfs2_write_inode(struct inode
*inode
, struct writeback_control
*wbc
)
426 struct gfs2_inode
*ip
= GFS2_I(inode
);
427 struct gfs2_sbd
*sdp
= GFS2_SB(inode
);
428 struct address_space
*metamapping
= gfs2_glock2aspace(ip
->i_gl
);
429 struct backing_dev_info
*bdi
= inode_to_bdi(metamapping
->host
);
431 bool flush_all
= (wbc
->sync_mode
== WB_SYNC_ALL
|| gfs2_is_jdata(ip
));
434 gfs2_log_flush(GFS2_SB(inode
), ip
->i_gl
,
435 GFS2_LOG_HEAD_FLUSH_NORMAL
|
436 GFS2_LFC_WRITE_INODE
);
437 if (bdi
->wb
.dirty_exceeded
)
438 gfs2_ail1_flush(sdp
, wbc
);
440 filemap_fdatawrite(metamapping
);
442 ret
= filemap_fdatawait(metamapping
);
444 mark_inode_dirty_sync(inode
);
446 spin_lock(&inode
->i_lock
);
447 if (!(inode
->i_flags
& I_DIRTY
))
448 gfs2_ordered_del_inode(ip
);
449 spin_unlock(&inode
->i_lock
);
455 * gfs2_dirty_inode - check for atime updates
456 * @inode: The inode in question
457 * @flags: The type of dirty
459 * Unfortunately it can be called under any combination of inode
460 * glock and transaction lock, so we have to check carefully.
462 * At the moment this deals only with atime - it should be possible
463 * to expand that role in future, once a review of the locking has
467 static void gfs2_dirty_inode(struct inode
*inode
, int flags
)
469 struct gfs2_inode
*ip
= GFS2_I(inode
);
470 struct gfs2_sbd
*sdp
= GFS2_SB(inode
);
471 struct buffer_head
*bh
;
472 struct gfs2_holder gh
;
474 int need_endtrans
= 0;
477 if (unlikely(gfs2_withdrawn(sdp
)))
479 if (!gfs2_glock_is_locked_by_me(ip
->i_gl
)) {
480 ret
= gfs2_glock_nq_init(ip
->i_gl
, LM_ST_EXCLUSIVE
, 0, &gh
);
482 fs_err(sdp
, "dirty_inode: glock %d\n", ret
);
483 gfs2_dump_glock(NULL
, ip
->i_gl
, true);
487 } else if (WARN_ON_ONCE(ip
->i_gl
->gl_state
!= LM_ST_EXCLUSIVE
))
490 if (current
->journal_info
== NULL
) {
491 ret
= gfs2_trans_begin(sdp
, RES_DINODE
, 0);
493 fs_err(sdp
, "dirty_inode: gfs2_trans_begin %d\n", ret
);
499 ret
= gfs2_meta_inode_buffer(ip
, &bh
);
501 gfs2_trans_add_meta(ip
->i_gl
, bh
);
502 gfs2_dinode_out(ip
, bh
->b_data
);
510 gfs2_glock_dq_uninit(&gh
);
514 * gfs2_make_fs_ro - Turn a Read-Write FS into a Read-Only one
515 * @sdp: the filesystem
520 void gfs2_make_fs_ro(struct gfs2_sbd
*sdp
)
522 int log_write_allowed
= test_bit(SDF_JOURNAL_LIVE
, &sdp
->sd_flags
);
524 gfs2_flush_delete_work(sdp
);
525 if (!log_write_allowed
&& current
== sdp
->sd_quotad_process
)
526 fs_warn(sdp
, "The quotad daemon is withdrawing.\n");
527 else if (sdp
->sd_quotad_process
)
528 kthread_stop(sdp
->sd_quotad_process
);
529 sdp
->sd_quotad_process
= NULL
;
531 if (!log_write_allowed
&& current
== sdp
->sd_logd_process
)
532 fs_warn(sdp
, "The logd daemon is withdrawing.\n");
533 else if (sdp
->sd_logd_process
)
534 kthread_stop(sdp
->sd_logd_process
);
535 sdp
->sd_logd_process
= NULL
;
537 if (log_write_allowed
) {
538 gfs2_quota_sync(sdp
->sd_vfs
, 0);
539 gfs2_statfs_sync(sdp
->sd_vfs
, 0);
541 gfs2_log_flush(sdp
, NULL
, GFS2_LOG_HEAD_FLUSH_SHUTDOWN
|
542 GFS2_LFC_MAKE_FS_RO
);
543 wait_event_timeout(sdp
->sd_log_waitq
,
544 gfs2_log_is_empty(sdp
),
546 gfs2_assert_warn(sdp
, gfs2_log_is_empty(sdp
));
548 wait_event_timeout(sdp
->sd_log_waitq
,
549 gfs2_log_is_empty(sdp
),
552 gfs2_quota_cleanup(sdp
);
554 if (!log_write_allowed
)
555 sdp
->sd_vfs
->s_flags
|= SB_RDONLY
;
559 * gfs2_put_super - Unmount the filesystem
560 * @sb: The VFS superblock
564 static void gfs2_put_super(struct super_block
*sb
)
566 struct gfs2_sbd
*sdp
= sb
->s_fs_info
;
567 struct gfs2_jdesc
*jd
;
569 /* No more recovery requests */
570 set_bit(SDF_NORECOVERY
, &sdp
->sd_flags
);
573 /* Wait on outstanding recovery */
575 spin_lock(&sdp
->sd_jindex_spin
);
576 list_for_each_entry(jd
, &sdp
->sd_jindex_list
, jd_list
) {
577 if (!test_bit(JDF_RECOVERY
, &jd
->jd_flags
))
579 spin_unlock(&sdp
->sd_jindex_spin
);
580 wait_on_bit(&jd
->jd_flags
, JDF_RECOVERY
,
581 TASK_UNINTERRUPTIBLE
);
584 spin_unlock(&sdp
->sd_jindex_spin
);
586 if (!sb_rdonly(sb
)) {
587 gfs2_make_fs_ro(sdp
);
589 WARN_ON(gfs2_withdrawing(sdp
));
591 /* At this point, we're through modifying the disk */
595 iput(sdp
->sd_jindex
);
596 iput(sdp
->sd_statfs_inode
);
597 iput(sdp
->sd_rindex
);
598 iput(sdp
->sd_quota_inode
);
600 gfs2_glock_put(sdp
->sd_rename_gl
);
601 gfs2_glock_put(sdp
->sd_freeze_gl
);
603 if (!sdp
->sd_args
.ar_spectator
) {
604 if (gfs2_holder_initialized(&sdp
->sd_journal_gh
))
605 gfs2_glock_dq_uninit(&sdp
->sd_journal_gh
);
606 if (gfs2_holder_initialized(&sdp
->sd_jinode_gh
))
607 gfs2_glock_dq_uninit(&sdp
->sd_jinode_gh
);
608 brelse(sdp
->sd_sc_bh
);
609 gfs2_glock_dq_uninit(&sdp
->sd_sc_gh
);
610 gfs2_glock_dq_uninit(&sdp
->sd_qc_gh
);
611 free_local_statfs_inodes(sdp
);
612 iput(sdp
->sd_qc_inode
);
615 gfs2_glock_dq_uninit(&sdp
->sd_live_gh
);
616 gfs2_clear_rgrpd(sdp
);
617 gfs2_jindex_free(sdp
);
618 /* Take apart glock structures and buffer lists */
619 gfs2_gl_hash_clear(sdp
);
620 truncate_inode_pages_final(&sdp
->sd_aspace
);
621 gfs2_delete_debugfs_file(sdp
);
622 /* Unmount the locking protocol */
623 gfs2_lm_unmount(sdp
);
625 /* At this point, we're through participating in the lockspace */
626 gfs2_sys_fs_del(sdp
);
631 * gfs2_sync_fs - sync the filesystem
632 * @sb: the superblock
633 * @wait: true to wait for completion
635 * Flushes the log to disk.
638 static int gfs2_sync_fs(struct super_block
*sb
, int wait
)
640 struct gfs2_sbd
*sdp
= sb
->s_fs_info
;
642 gfs2_quota_sync(sb
, -1);
644 gfs2_log_flush(sdp
, NULL
, GFS2_LOG_HEAD_FLUSH_NORMAL
|
646 return sdp
->sd_log_error
;
649 void gfs2_freeze_func(struct work_struct
*work
)
652 struct gfs2_holder freeze_gh
;
653 struct gfs2_sbd
*sdp
= container_of(work
, struct gfs2_sbd
, sd_freeze_work
);
654 struct super_block
*sb
= sdp
->sd_vfs
;
656 atomic_inc(&sb
->s_active
);
657 error
= gfs2_freeze_lock(sdp
, &freeze_gh
, 0);
659 gfs2_assert_withdraw(sdp
, 0);
661 atomic_set(&sdp
->sd_freeze_state
, SFS_UNFROZEN
);
662 error
= thaw_super(sb
);
664 fs_info(sdp
, "GFS2: couldn't thaw filesystem: %d\n",
666 gfs2_assert_withdraw(sdp
, 0);
668 gfs2_freeze_unlock(&freeze_gh
);
670 deactivate_super(sb
);
671 clear_bit_unlock(SDF_FS_FROZEN
, &sdp
->sd_flags
);
672 wake_up_bit(&sdp
->sd_flags
, SDF_FS_FROZEN
);
677 * gfs2_freeze - prevent further writes to the filesystem
678 * @sb: the VFS structure for the filesystem
682 static int gfs2_freeze(struct super_block
*sb
)
684 struct gfs2_sbd
*sdp
= sb
->s_fs_info
;
687 mutex_lock(&sdp
->sd_freeze_mutex
);
688 if (atomic_read(&sdp
->sd_freeze_state
) != SFS_UNFROZEN
) {
694 if (gfs2_withdrawn(sdp
)) {
699 error
= gfs2_lock_fs_check_clean(sdp
);
704 fs_err(sdp
, "waiting for recovery before freeze\n");
705 else if (error
== -EIO
) {
706 fs_err(sdp
, "Fatal IO error: cannot freeze gfs2 due "
707 "to recovery error.\n");
710 fs_err(sdp
, "error freezing FS: %d\n", error
);
712 fs_err(sdp
, "retrying...\n");
715 set_bit(SDF_FS_FROZEN
, &sdp
->sd_flags
);
717 mutex_unlock(&sdp
->sd_freeze_mutex
);
722 * gfs2_unfreeze - reallow writes to the filesystem
723 * @sb: the VFS structure for the filesystem
727 static int gfs2_unfreeze(struct super_block
*sb
)
729 struct gfs2_sbd
*sdp
= sb
->s_fs_info
;
731 mutex_lock(&sdp
->sd_freeze_mutex
);
732 if (atomic_read(&sdp
->sd_freeze_state
) != SFS_FROZEN
||
733 !gfs2_holder_initialized(&sdp
->sd_freeze_gh
)) {
734 mutex_unlock(&sdp
->sd_freeze_mutex
);
738 gfs2_freeze_unlock(&sdp
->sd_freeze_gh
);
739 mutex_unlock(&sdp
->sd_freeze_mutex
);
740 return wait_on_bit(&sdp
->sd_flags
, SDF_FS_FROZEN
, TASK_INTERRUPTIBLE
);
744 * statfs_slow_fill - fill in the sg for a given RG
746 * @sc: the sc structure
748 * Returns: 0 on success, -ESTALE if the LVB is invalid
751 static int statfs_slow_fill(struct gfs2_rgrpd
*rgd
,
752 struct gfs2_statfs_change_host
*sc
)
754 gfs2_rgrp_verify(rgd
);
755 sc
->sc_total
+= rgd
->rd_data
;
756 sc
->sc_free
+= rgd
->rd_free
;
757 sc
->sc_dinodes
+= rgd
->rd_dinodes
;
762 * gfs2_statfs_slow - Stat a filesystem using asynchronous locking
763 * @sdp: the filesystem
764 * @sc: the sc info that will be returned
766 * Any error (other than a signal) will cause this routine to fall back
767 * to the synchronous version.
769 * FIXME: This really shouldn't busy wait like this.
774 static int gfs2_statfs_slow(struct gfs2_sbd
*sdp
, struct gfs2_statfs_change_host
*sc
)
776 struct gfs2_rgrpd
*rgd_next
;
777 struct gfs2_holder
*gha
, *gh
;
778 unsigned int slots
= 64;
783 memset(sc
, 0, sizeof(struct gfs2_statfs_change_host
));
784 gha
= kmalloc_array(slots
, sizeof(struct gfs2_holder
), GFP_KERNEL
);
787 for (x
= 0; x
< slots
; x
++)
788 gfs2_holder_mark_uninitialized(gha
+ x
);
790 rgd_next
= gfs2_rgrpd_get_first(sdp
);
795 for (x
= 0; x
< slots
; x
++) {
798 if (gfs2_holder_initialized(gh
) && gfs2_glock_poll(gh
)) {
799 err
= gfs2_glock_wait(gh
);
801 gfs2_holder_uninit(gh
);
805 struct gfs2_rgrpd
*rgd
=
806 gfs2_glock2rgrp(gh
->gh_gl
);
808 error
= statfs_slow_fill(rgd
, sc
);
810 gfs2_glock_dq_uninit(gh
);
814 if (gfs2_holder_initialized(gh
))
816 else if (rgd_next
&& !error
) {
817 error
= gfs2_glock_nq_init(rgd_next
->rd_gl
,
821 rgd_next
= gfs2_rgrpd_get_next(rgd_next
);
825 if (signal_pending(current
))
826 error
= -ERESTARTSYS
;
840 * gfs2_statfs_i - Do a statfs
841 * @sdp: the filesystem
842 * @sc: the sc structure
847 static int gfs2_statfs_i(struct gfs2_sbd
*sdp
, struct gfs2_statfs_change_host
*sc
)
849 struct gfs2_statfs_change_host
*m_sc
= &sdp
->sd_statfs_master
;
850 struct gfs2_statfs_change_host
*l_sc
= &sdp
->sd_statfs_local
;
852 spin_lock(&sdp
->sd_statfs_spin
);
855 sc
->sc_total
+= l_sc
->sc_total
;
856 sc
->sc_free
+= l_sc
->sc_free
;
857 sc
->sc_dinodes
+= l_sc
->sc_dinodes
;
859 spin_unlock(&sdp
->sd_statfs_spin
);
863 if (sc
->sc_free
> sc
->sc_total
)
864 sc
->sc_free
= sc
->sc_total
;
865 if (sc
->sc_dinodes
< 0)
872 * gfs2_statfs - Gather and return stats about the filesystem
873 * @dentry: The name of the link
876 * Returns: 0 on success or error code
879 static int gfs2_statfs(struct dentry
*dentry
, struct kstatfs
*buf
)
881 struct super_block
*sb
= dentry
->d_sb
;
882 struct gfs2_sbd
*sdp
= sb
->s_fs_info
;
883 struct gfs2_statfs_change_host sc
;
886 error
= gfs2_rindex_update(sdp
);
890 if (gfs2_tune_get(sdp
, gt_statfs_slow
))
891 error
= gfs2_statfs_slow(sdp
, &sc
);
893 error
= gfs2_statfs_i(sdp
, &sc
);
898 buf
->f_type
= GFS2_MAGIC
;
899 buf
->f_bsize
= sdp
->sd_sb
.sb_bsize
;
900 buf
->f_blocks
= sc
.sc_total
;
901 buf
->f_bfree
= sc
.sc_free
;
902 buf
->f_bavail
= sc
.sc_free
;
903 buf
->f_files
= sc
.sc_dinodes
+ sc
.sc_free
;
904 buf
->f_ffree
= sc
.sc_free
;
905 buf
->f_namelen
= GFS2_FNAMESIZE
;
911 * gfs2_drop_inode - Drop an inode (test for remote unlink)
912 * @inode: The inode to drop
914 * If we've received a callback on an iopen lock then it's because a
915 * remote node tried to deallocate the inode but failed due to this node
916 * still having the inode open. Here we mark the link count zero
917 * since we know that it must have reached zero if the GLF_DEMOTE flag
918 * is set on the iopen glock. If we didn't do a disk read since the
919 * remote node removed the final link then we might otherwise miss
920 * this event. This check ensures that this node will deallocate the
921 * inode's blocks, or alternatively pass the baton on to another
922 * node for later deallocation.
925 static int gfs2_drop_inode(struct inode
*inode
)
927 struct gfs2_inode
*ip
= GFS2_I(inode
);
929 if (!test_bit(GIF_FREE_VFS_INODE
, &ip
->i_flags
) &&
931 gfs2_holder_initialized(&ip
->i_iopen_gh
)) {
932 struct gfs2_glock
*gl
= ip
->i_iopen_gh
.gh_gl
;
933 if (test_bit(GLF_DEMOTE
, &gl
->gl_flags
))
938 * When under memory pressure when an inode's link count has dropped to
939 * zero, defer deleting the inode to the delete workqueue. This avoids
940 * calling into DLM under memory pressure, which can deadlock.
942 if (!inode
->i_nlink
&&
943 unlikely(current
->flags
& PF_MEMALLOC
) &&
944 gfs2_holder_initialized(&ip
->i_iopen_gh
)) {
945 struct gfs2_glock
*gl
= ip
->i_iopen_gh
.gh_gl
;
948 if (!gfs2_queue_delete_work(gl
, 0))
949 gfs2_glock_queue_put(gl
);
953 return generic_drop_inode(inode
);
956 static int is_ancestor(const struct dentry
*d1
, const struct dentry
*d2
)
962 } while (!IS_ROOT(d1
));
967 * gfs2_show_options - Show mount options for /proc/mounts
968 * @s: seq_file structure
969 * @root: root of this (sub)tree
971 * Returns: 0 on success or error code
974 static int gfs2_show_options(struct seq_file
*s
, struct dentry
*root
)
976 struct gfs2_sbd
*sdp
= root
->d_sb
->s_fs_info
;
977 struct gfs2_args
*args
= &sdp
->sd_args
;
980 if (is_ancestor(root
, sdp
->sd_master_dir
))
981 seq_puts(s
, ",meta");
982 if (args
->ar_lockproto
[0])
983 seq_show_option(s
, "lockproto", args
->ar_lockproto
);
984 if (args
->ar_locktable
[0])
985 seq_show_option(s
, "locktable", args
->ar_locktable
);
986 if (args
->ar_hostdata
[0])
987 seq_show_option(s
, "hostdata", args
->ar_hostdata
);
988 if (args
->ar_spectator
)
989 seq_puts(s
, ",spectator");
990 if (args
->ar_localflocks
)
991 seq_puts(s
, ",localflocks");
993 seq_puts(s
, ",debug");
994 if (args
->ar_posix_acl
)
996 if (args
->ar_quota
!= GFS2_QUOTA_DEFAULT
) {
998 switch (args
->ar_quota
) {
1002 case GFS2_QUOTA_ACCOUNT
:
1012 seq_printf(s
, ",quota=%s", state
);
1014 if (args
->ar_suiddir
)
1015 seq_puts(s
, ",suiddir");
1016 if (args
->ar_data
!= GFS2_DATA_DEFAULT
) {
1018 switch (args
->ar_data
) {
1019 case GFS2_DATA_WRITEBACK
:
1020 state
= "writeback";
1022 case GFS2_DATA_ORDERED
:
1029 seq_printf(s
, ",data=%s", state
);
1031 if (args
->ar_discard
)
1032 seq_puts(s
, ",discard");
1033 val
= sdp
->sd_tune
.gt_logd_secs
;
1035 seq_printf(s
, ",commit=%d", val
);
1036 val
= sdp
->sd_tune
.gt_statfs_quantum
;
1038 seq_printf(s
, ",statfs_quantum=%d", val
);
1039 else if (sdp
->sd_tune
.gt_statfs_slow
)
1040 seq_puts(s
, ",statfs_quantum=0");
1041 val
= sdp
->sd_tune
.gt_quota_quantum
;
1043 seq_printf(s
, ",quota_quantum=%d", val
);
1044 if (args
->ar_statfs_percent
)
1045 seq_printf(s
, ",statfs_percent=%d", args
->ar_statfs_percent
);
1046 if (args
->ar_errors
!= GFS2_ERRORS_DEFAULT
) {
1049 switch (args
->ar_errors
) {
1050 case GFS2_ERRORS_WITHDRAW
:
1053 case GFS2_ERRORS_PANIC
:
1060 seq_printf(s
, ",errors=%s", state
);
1062 if (test_bit(SDF_NOBARRIERS
, &sdp
->sd_flags
))
1063 seq_puts(s
, ",nobarrier");
1064 if (test_bit(SDF_DEMOTE
, &sdp
->sd_flags
))
1065 seq_puts(s
, ",demote_interface_used");
1066 if (args
->ar_rgrplvb
)
1067 seq_puts(s
, ",rgrplvb");
1068 if (args
->ar_loccookie
)
1069 seq_puts(s
, ",loccookie");
1073 static void gfs2_final_release_pages(struct gfs2_inode
*ip
)
1075 struct inode
*inode
= &ip
->i_inode
;
1076 struct gfs2_glock
*gl
= ip
->i_gl
;
1078 truncate_inode_pages(gfs2_glock2aspace(ip
->i_gl
), 0);
1079 truncate_inode_pages(&inode
->i_data
, 0);
1081 if (atomic_read(&gl
->gl_revokes
) == 0) {
1082 clear_bit(GLF_LFLUSH
, &gl
->gl_flags
);
1083 clear_bit(GLF_DIRTY
, &gl
->gl_flags
);
1087 static int gfs2_dinode_dealloc(struct gfs2_inode
*ip
)
1089 struct gfs2_sbd
*sdp
= GFS2_SB(&ip
->i_inode
);
1090 struct gfs2_rgrpd
*rgd
;
1091 struct gfs2_holder gh
;
1094 if (gfs2_get_inode_blocks(&ip
->i_inode
) != 1) {
1095 gfs2_consist_inode(ip
);
1099 error
= gfs2_rindex_update(sdp
);
1103 error
= gfs2_quota_hold(ip
, NO_UID_QUOTA_CHANGE
, NO_GID_QUOTA_CHANGE
);
1107 rgd
= gfs2_blk2rgrpd(sdp
, ip
->i_no_addr
, 1);
1109 gfs2_consist_inode(ip
);
1114 error
= gfs2_glock_nq_init(rgd
->rd_gl
, LM_ST_EXCLUSIVE
,
1115 LM_FLAG_NODE_SCOPE
, &gh
);
1119 error
= gfs2_trans_begin(sdp
, RES_RG_BIT
+ RES_STATFS
+ RES_QUOTA
,
1120 sdp
->sd_jdesc
->jd_blocks
);
1122 goto out_rg_gunlock
;
1124 gfs2_free_di(rgd
, ip
);
1126 gfs2_final_release_pages(ip
);
1128 gfs2_trans_end(sdp
);
1131 gfs2_glock_dq_uninit(&gh
);
1133 gfs2_quota_unhold(ip
);
1138 * gfs2_glock_put_eventually
1139 * @gl: The glock to put
1141 * When under memory pressure, trigger a deferred glock put to make sure we
1142 * won't call into DLM and deadlock. Otherwise, put the glock directly.
1145 static void gfs2_glock_put_eventually(struct gfs2_glock
*gl
)
1147 if (current
->flags
& PF_MEMALLOC
)
1148 gfs2_glock_queue_put(gl
);
1153 static bool gfs2_upgrade_iopen_glock(struct inode
*inode
)
1155 struct gfs2_inode
*ip
= GFS2_I(inode
);
1156 struct gfs2_sbd
*sdp
= GFS2_SB(inode
);
1157 struct gfs2_holder
*gh
= &ip
->i_iopen_gh
;
1158 long timeout
= 5 * HZ
;
1161 gh
->gh_flags
|= GL_NOCACHE
;
1162 gfs2_glock_dq_wait(gh
);
1165 * If there are no other lock holders, we'll get the lock immediately.
1166 * Otherwise, the other nodes holding the lock will be notified about
1167 * our locking request. If they don't have the inode open, they'll
1168 * evict the cached inode and release the lock. Otherwise, if they
1169 * poke the inode glock, we'll take this as an indication that they
1170 * still need the iopen glock and that they'll take care of deleting
1171 * the inode when they're done. As a last resort, if another node
1172 * keeps holding the iopen glock without showing any activity on the
1173 * inode glock, we'll eventually time out.
1175 * Note that we're passing the LM_FLAG_TRY_1CB flag to the first
1176 * locking request as an optimization to notify lock holders as soon as
1177 * possible. Without that flag, they'd be notified implicitly by the
1178 * second locking request.
1181 gfs2_holder_reinit(LM_ST_EXCLUSIVE
, LM_FLAG_TRY_1CB
| GL_NOCACHE
, gh
);
1182 error
= gfs2_glock_nq(gh
);
1183 if (error
!= GLR_TRYFAILED
)
1186 gfs2_holder_reinit(LM_ST_EXCLUSIVE
, GL_ASYNC
| GL_NOCACHE
, gh
);
1187 error
= gfs2_glock_nq(gh
);
1191 timeout
= wait_event_interruptible_timeout(sdp
->sd_async_glock_wait
,
1192 !test_bit(HIF_WAIT
, &gh
->gh_iflags
) ||
1193 test_bit(GLF_DEMOTE
, &ip
->i_gl
->gl_flags
),
1195 if (!test_bit(HIF_HOLDER
, &gh
->gh_iflags
)) {
1199 return gfs2_glock_holder_ready(gh
) == 0;
1203 * evict_should_delete - determine whether the inode is eligible for deletion
1204 * @inode: The inode to evict
1205 * @gh: The glock holder structure
1207 * This function determines whether the evicted inode is eligible to be deleted
1208 * and locks the inode glock.
1210 * Returns: the fate of the dinode
1212 static enum dinode_demise
evict_should_delete(struct inode
*inode
,
1213 struct gfs2_holder
*gh
)
1215 struct gfs2_inode
*ip
= GFS2_I(inode
);
1216 struct super_block
*sb
= inode
->i_sb
;
1217 struct gfs2_sbd
*sdp
= sb
->s_fs_info
;
1220 if (test_bit(GIF_ALLOC_FAILED
, &ip
->i_flags
)) {
1221 BUG_ON(!gfs2_glock_is_locked_by_me(ip
->i_gl
));
1225 if (test_bit(GIF_DEFERRED_DELETE
, &ip
->i_flags
))
1226 return SHOULD_DEFER_EVICTION
;
1228 /* Deletes should never happen under memory pressure anymore. */
1229 if (WARN_ON_ONCE(current
->flags
& PF_MEMALLOC
))
1230 return SHOULD_DEFER_EVICTION
;
1232 /* Must not read inode block until block type has been verified */
1233 ret
= gfs2_glock_nq_init(ip
->i_gl
, LM_ST_EXCLUSIVE
, GL_SKIP
, gh
);
1234 if (unlikely(ret
)) {
1235 glock_clear_object(ip
->i_iopen_gh
.gh_gl
, ip
);
1236 ip
->i_iopen_gh
.gh_flags
|= GL_NOCACHE
;
1237 gfs2_glock_dq_uninit(&ip
->i_iopen_gh
);
1238 return SHOULD_DEFER_EVICTION
;
1241 if (gfs2_inode_already_deleted(ip
->i_gl
, ip
->i_no_formal_ino
))
1242 return SHOULD_NOT_DELETE_DINODE
;
1243 ret
= gfs2_check_blk_type(sdp
, ip
->i_no_addr
, GFS2_BLKST_UNLINKED
);
1245 return SHOULD_NOT_DELETE_DINODE
;
1247 ret
= gfs2_instantiate(gh
);
1249 return SHOULD_NOT_DELETE_DINODE
;
1252 * The inode may have been recreated in the meantime.
1255 return SHOULD_NOT_DELETE_DINODE
;
1258 if (gfs2_holder_initialized(&ip
->i_iopen_gh
) &&
1259 test_bit(HIF_HOLDER
, &ip
->i_iopen_gh
.gh_iflags
)) {
1260 if (!gfs2_upgrade_iopen_glock(inode
)) {
1261 gfs2_holder_uninit(&ip
->i_iopen_gh
);
1262 return SHOULD_NOT_DELETE_DINODE
;
1265 return SHOULD_DELETE_DINODE
;
1269 * evict_unlinked_inode - delete the pieces of an unlinked evicted inode
1270 * @inode: The inode to evict
1272 static int evict_unlinked_inode(struct inode
*inode
)
1274 struct gfs2_inode
*ip
= GFS2_I(inode
);
1277 if (S_ISDIR(inode
->i_mode
) &&
1278 (ip
->i_diskflags
& GFS2_DIF_EXHASH
)) {
1279 ret
= gfs2_dir_exhash_dealloc(ip
);
1285 ret
= gfs2_ea_dealloc(ip
);
1290 if (!gfs2_is_stuffed(ip
)) {
1291 ret
= gfs2_file_dealloc(ip
);
1296 /* We're about to clear the bitmap for the dinode, but as soon as we
1297 do, gfs2_create_inode can create another inode at the same block
1298 location and try to set gl_object again. We clear gl_object here so
1299 that subsequent inode creates don't see an old gl_object. */
1300 glock_clear_object(ip
->i_gl
, ip
);
1301 ret
= gfs2_dinode_dealloc(ip
);
1302 gfs2_inode_remember_delete(ip
->i_gl
, ip
->i_no_formal_ino
);
1308 * evict_linked_inode - evict an inode whose dinode has not been unlinked
1309 * @inode: The inode to evict
1311 static int evict_linked_inode(struct inode
*inode
)
1313 struct super_block
*sb
= inode
->i_sb
;
1314 struct gfs2_sbd
*sdp
= sb
->s_fs_info
;
1315 struct gfs2_inode
*ip
= GFS2_I(inode
);
1316 struct address_space
*metamapping
;
1319 gfs2_log_flush(sdp
, ip
->i_gl
, GFS2_LOG_HEAD_FLUSH_NORMAL
|
1320 GFS2_LFC_EVICT_INODE
);
1321 metamapping
= gfs2_glock2aspace(ip
->i_gl
);
1322 if (test_bit(GLF_DIRTY
, &ip
->i_gl
->gl_flags
)) {
1323 filemap_fdatawrite(metamapping
);
1324 filemap_fdatawait(metamapping
);
1326 write_inode_now(inode
, 1);
1327 gfs2_ail_flush(ip
->i_gl
, 0);
1329 ret
= gfs2_trans_begin(sdp
, 0, sdp
->sd_jdesc
->jd_blocks
);
1333 /* Needs to be done before glock release & also in a transaction */
1334 truncate_inode_pages(&inode
->i_data
, 0);
1335 truncate_inode_pages(metamapping
, 0);
1336 gfs2_trans_end(sdp
);
1341 * gfs2_evict_inode - Remove an inode from cache
1342 * @inode: The inode to evict
1344 * There are three cases to consider:
1345 * 1. i_nlink == 0, we are final opener (and must deallocate)
1346 * 2. i_nlink == 0, we are not the final opener (and cannot deallocate)
1349 * If the fs is read only, then we have to treat all cases as per #3
1350 * since we are unable to do any deallocation. The inode will be
1351 * deallocated by the next read/write node to attempt an allocation
1352 * in the same resource group
1354 * We have to (at the moment) hold the inodes main lock to cover
1355 * the gap between unlocking the shared lock on the iopen lock and
1356 * taking the exclusive lock. I'd rather do a shared -> exclusive
1357 * conversion on the iopen lock, but we can change that later. This
1358 * is safe, just less efficient.
1361 static void gfs2_evict_inode(struct inode
*inode
)
1363 struct super_block
*sb
= inode
->i_sb
;
1364 struct gfs2_sbd
*sdp
= sb
->s_fs_info
;
1365 struct gfs2_inode
*ip
= GFS2_I(inode
);
1366 struct gfs2_holder gh
;
1369 if (test_bit(GIF_FREE_VFS_INODE
, &ip
->i_flags
)) {
1374 if (inode
->i_nlink
|| sb_rdonly(sb
))
1377 gfs2_holder_mark_uninitialized(&gh
);
1378 ret
= evict_should_delete(inode
, &gh
);
1379 if (ret
== SHOULD_DEFER_EVICTION
)
1381 if (ret
== SHOULD_DELETE_DINODE
)
1382 ret
= evict_unlinked_inode(inode
);
1384 ret
= evict_linked_inode(inode
);
1386 if (gfs2_rs_active(&ip
->i_res
))
1387 gfs2_rs_deltree(&ip
->i_res
);
1389 if (gfs2_holder_initialized(&gh
)) {
1390 glock_clear_object(ip
->i_gl
, ip
);
1391 gfs2_glock_dq_uninit(&gh
);
1393 if (ret
&& ret
!= GLR_TRYFAILED
&& ret
!= -EROFS
)
1394 fs_warn(sdp
, "gfs2_evict_inode: %d\n", ret
);
1396 truncate_inode_pages_final(&inode
->i_data
);
1398 gfs2_assert_warn(sdp
, ip
->i_qadata
->qa_ref
== 0);
1399 gfs2_rs_deltree(&ip
->i_res
);
1400 gfs2_ordered_del_inode(ip
);
1402 gfs2_dir_hash_inval(ip
);
1403 if (gfs2_holder_initialized(&ip
->i_iopen_gh
)) {
1404 struct gfs2_glock
*gl
= ip
->i_iopen_gh
.gh_gl
;
1406 glock_clear_object(gl
, ip
);
1407 if (test_bit(HIF_HOLDER
, &ip
->i_iopen_gh
.gh_iflags
)) {
1408 ip
->i_iopen_gh
.gh_flags
|= GL_NOCACHE
;
1409 gfs2_glock_dq(&ip
->i_iopen_gh
);
1411 gfs2_glock_hold(gl
);
1412 gfs2_holder_uninit(&ip
->i_iopen_gh
);
1413 gfs2_glock_put_eventually(gl
);
1416 glock_clear_object(ip
->i_gl
, ip
);
1417 wait_on_bit_io(&ip
->i_flags
, GIF_GLOP_PENDING
, TASK_UNINTERRUPTIBLE
);
1418 gfs2_glock_add_to_lru(ip
->i_gl
);
1419 gfs2_glock_put_eventually(ip
->i_gl
);
1424 static struct inode
*gfs2_alloc_inode(struct super_block
*sb
)
1426 struct gfs2_inode
*ip
;
1428 ip
= alloc_inode_sb(sb
, gfs2_inode_cachep
, GFP_KERNEL
);
1433 gfs2_holder_mark_uninitialized(&ip
->i_iopen_gh
);
1434 memset(&ip
->i_res
, 0, sizeof(ip
->i_res
));
1435 RB_CLEAR_NODE(&ip
->i_res
.rs_node
);
1437 return &ip
->i_inode
;
1440 static void gfs2_free_inode(struct inode
*inode
)
1442 kmem_cache_free(gfs2_inode_cachep
, GFS2_I(inode
));
1445 extern void free_local_statfs_inodes(struct gfs2_sbd
*sdp
)
1447 struct local_statfs_inode
*lsi
, *safe
;
1449 /* Run through the statfs inodes list to iput and free memory */
1450 list_for_each_entry_safe(lsi
, safe
, &sdp
->sd_sc_inodes_list
, si_list
) {
1451 if (lsi
->si_jid
== sdp
->sd_jdesc
->jd_jid
)
1452 sdp
->sd_sc_inode
= NULL
; /* belongs to this node */
1453 if (lsi
->si_sc_inode
)
1454 iput(lsi
->si_sc_inode
);
1455 list_del(&lsi
->si_list
);
1460 extern struct inode
*find_local_statfs_inode(struct gfs2_sbd
*sdp
,
1463 struct local_statfs_inode
*lsi
;
1465 /* Return the local (per node) statfs inode in the
1466 * sdp->sd_sc_inodes_list corresponding to the 'index'. */
1467 list_for_each_entry(lsi
, &sdp
->sd_sc_inodes_list
, si_list
) {
1468 if (lsi
->si_jid
== index
)
1469 return lsi
->si_sc_inode
;
1474 const struct super_operations gfs2_super_ops
= {
1475 .alloc_inode
= gfs2_alloc_inode
,
1476 .free_inode
= gfs2_free_inode
,
1477 .write_inode
= gfs2_write_inode
,
1478 .dirty_inode
= gfs2_dirty_inode
,
1479 .evict_inode
= gfs2_evict_inode
,
1480 .put_super
= gfs2_put_super
,
1481 .sync_fs
= gfs2_sync_fs
,
1482 .freeze_super
= gfs2_freeze
,
1483 .thaw_super
= gfs2_unfreeze
,
1484 .statfs
= gfs2_statfs
,
1485 .drop_inode
= gfs2_drop_inode
,
1486 .show_options
= gfs2_show_options
,