xref: /openbmc/linux/fs/gfs2/ops_fstype.c (revision b181f7029bd71238ac2754ce7052dffd69432085)
1  // SPDX-License-Identifier: GPL-2.0-only
2  /*
3   * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
4   * Copyright (C) 2004-2008 Red Hat, Inc.  All rights reserved.
5   */
6  
7  #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
8  
9  #include <linux/sched.h>
10  #include <linux/slab.h>
11  #include <linux/spinlock.h>
12  #include <linux/completion.h>
13  #include <linux/buffer_head.h>
14  #include <linux/blkdev.h>
15  #include <linux/kthread.h>
16  #include <linux/export.h>
17  #include <linux/namei.h>
18  #include <linux/mount.h>
19  #include <linux/gfs2_ondisk.h>
20  #include <linux/quotaops.h>
21  #include <linux/lockdep.h>
22  #include <linux/module.h>
23  #include <linux/backing-dev.h>
24  #include <linux/fs_parser.h>
25  
26  #include "gfs2.h"
27  #include "incore.h"
28  #include "bmap.h"
29  #include "glock.h"
30  #include "glops.h"
31  #include "inode.h"
32  #include "recovery.h"
33  #include "rgrp.h"
34  #include "super.h"
35  #include "sys.h"
36  #include "util.h"
37  #include "log.h"
38  #include "quota.h"
39  #include "dir.h"
40  #include "meta_io.h"
41  #include "trace_gfs2.h"
42  #include "lops.h"
43  
44  #define DO 0
45  #define UNDO 1
46  
47  /**
48   * gfs2_tune_init - Fill a gfs2_tune structure with default values
49   * @gt: tune
50   *
51   */
52  
gfs2_tune_init(struct gfs2_tune * gt)53  static void gfs2_tune_init(struct gfs2_tune *gt)
54  {
55  	spin_lock_init(&gt->gt_spin);
56  
57  	gt->gt_quota_warn_period = 10;
58  	gt->gt_quota_scale_num = 1;
59  	gt->gt_quota_scale_den = 1;
60  	gt->gt_new_files_jdata = 0;
61  	gt->gt_max_readahead = BIT(18);
62  	gt->gt_complain_secs = 10;
63  }
64  
free_sbd(struct gfs2_sbd * sdp)65  void free_sbd(struct gfs2_sbd *sdp)
66  {
67  	if (sdp->sd_lkstats)
68  		free_percpu(sdp->sd_lkstats);
69  	kfree(sdp);
70  }
71  
init_sbd(struct super_block * sb)72  static struct gfs2_sbd *init_sbd(struct super_block *sb)
73  {
74  	struct gfs2_sbd *sdp;
75  	struct address_space *mapping;
76  
77  	sdp = kzalloc(sizeof(struct gfs2_sbd), GFP_KERNEL);
78  	if (!sdp)
79  		return NULL;
80  
81  	sdp->sd_vfs = sb;
82  	sdp->sd_lkstats = alloc_percpu(struct gfs2_pcpu_lkstats);
83  	if (!sdp->sd_lkstats)
84  		goto fail;
85  	sb->s_fs_info = sdp;
86  
87  	set_bit(SDF_NOJOURNALID, &sdp->sd_flags);
88  	gfs2_tune_init(&sdp->sd_tune);
89  
90  	init_waitqueue_head(&sdp->sd_kill_wait);
91  	init_waitqueue_head(&sdp->sd_async_glock_wait);
92  	atomic_set(&sdp->sd_glock_disposal, 0);
93  	init_completion(&sdp->sd_locking_init);
94  	init_completion(&sdp->sd_wdack);
95  	spin_lock_init(&sdp->sd_statfs_spin);
96  
97  	spin_lock_init(&sdp->sd_rindex_spin);
98  	sdp->sd_rindex_tree.rb_node = NULL;
99  
100  	INIT_LIST_HEAD(&sdp->sd_jindex_list);
101  	spin_lock_init(&sdp->sd_jindex_spin);
102  	mutex_init(&sdp->sd_jindex_mutex);
103  	init_completion(&sdp->sd_journal_ready);
104  
105  	INIT_LIST_HEAD(&sdp->sd_quota_list);
106  	mutex_init(&sdp->sd_quota_mutex);
107  	mutex_init(&sdp->sd_quota_sync_mutex);
108  	init_waitqueue_head(&sdp->sd_quota_wait);
109  	spin_lock_init(&sdp->sd_bitmap_lock);
110  
111  	INIT_LIST_HEAD(&sdp->sd_sc_inodes_list);
112  
113  	mapping = &sdp->sd_aspace;
114  
115  	address_space_init_once(mapping);
116  	mapping->a_ops = &gfs2_rgrp_aops;
117  	mapping->host = sb->s_bdev->bd_inode;
118  	mapping->flags = 0;
119  	mapping_set_gfp_mask(mapping, GFP_NOFS);
120  	mapping->private_data = NULL;
121  	mapping->writeback_index = 0;
122  
123  	spin_lock_init(&sdp->sd_log_lock);
124  	atomic_set(&sdp->sd_log_pinned, 0);
125  	INIT_LIST_HEAD(&sdp->sd_log_revokes);
126  	INIT_LIST_HEAD(&sdp->sd_log_ordered);
127  	spin_lock_init(&sdp->sd_ordered_lock);
128  
129  	init_waitqueue_head(&sdp->sd_log_waitq);
130  	init_waitqueue_head(&sdp->sd_logd_waitq);
131  	spin_lock_init(&sdp->sd_ail_lock);
132  	INIT_LIST_HEAD(&sdp->sd_ail1_list);
133  	INIT_LIST_HEAD(&sdp->sd_ail2_list);
134  
135  	init_rwsem(&sdp->sd_log_flush_lock);
136  	atomic_set(&sdp->sd_log_in_flight, 0);
137  	init_waitqueue_head(&sdp->sd_log_flush_wait);
138  	mutex_init(&sdp->sd_freeze_mutex);
139  	INIT_LIST_HEAD(&sdp->sd_dead_glocks);
140  
141  	return sdp;
142  
143  fail:
144  	free_sbd(sdp);
145  	return NULL;
146  }
147  
148  /**
149   * gfs2_check_sb - Check superblock
150   * @sdp: the filesystem
151   * @silent: Don't print a message if the check fails
152   *
153   * Checks the version code of the FS is one that we understand how to
154   * read and that the sizes of the various on-disk structures have not
155   * changed.
156   */
157  
gfs2_check_sb(struct gfs2_sbd * sdp,int silent)158  static int gfs2_check_sb(struct gfs2_sbd *sdp, int silent)
159  {
160  	struct gfs2_sb_host *sb = &sdp->sd_sb;
161  
162  	if (sb->sb_magic != GFS2_MAGIC ||
163  	    sb->sb_type != GFS2_METATYPE_SB) {
164  		if (!silent)
165  			pr_warn("not a GFS2 filesystem\n");
166  		return -EINVAL;
167  	}
168  
169  	if (sb->sb_fs_format < GFS2_FS_FORMAT_MIN ||
170  	    sb->sb_fs_format > GFS2_FS_FORMAT_MAX ||
171  	    sb->sb_multihost_format != GFS2_FORMAT_MULTI) {
172  		fs_warn(sdp, "Unknown on-disk format, unable to mount\n");
173  		return -EINVAL;
174  	}
175  
176  	if (sb->sb_bsize < 512 || sb->sb_bsize > PAGE_SIZE ||
177  	    (sb->sb_bsize & (sb->sb_bsize - 1))) {
178  		pr_warn("Invalid block size\n");
179  		return -EINVAL;
180  	}
181  	if (sb->sb_bsize_shift != ffs(sb->sb_bsize) - 1) {
182  		pr_warn("Invalid block size shift\n");
183  		return -EINVAL;
184  	}
185  	return 0;
186  }
187  
end_bio_io_page(struct bio * bio)188  static void end_bio_io_page(struct bio *bio)
189  {
190  	struct page *page = bio->bi_private;
191  
192  	if (!bio->bi_status)
193  		SetPageUptodate(page);
194  	else
195  		pr_warn("error %d reading superblock\n", bio->bi_status);
196  	unlock_page(page);
197  }
198  
gfs2_sb_in(struct gfs2_sbd * sdp,const void * buf)199  static void gfs2_sb_in(struct gfs2_sbd *sdp, const void *buf)
200  {
201  	struct gfs2_sb_host *sb = &sdp->sd_sb;
202  	struct super_block *s = sdp->sd_vfs;
203  	const struct gfs2_sb *str = buf;
204  
205  	sb->sb_magic = be32_to_cpu(str->sb_header.mh_magic);
206  	sb->sb_type = be32_to_cpu(str->sb_header.mh_type);
207  	sb->sb_fs_format = be32_to_cpu(str->sb_fs_format);
208  	sb->sb_multihost_format = be32_to_cpu(str->sb_multihost_format);
209  	sb->sb_bsize = be32_to_cpu(str->sb_bsize);
210  	sb->sb_bsize_shift = be32_to_cpu(str->sb_bsize_shift);
211  	sb->sb_master_dir.no_addr = be64_to_cpu(str->sb_master_dir.no_addr);
212  	sb->sb_master_dir.no_formal_ino = be64_to_cpu(str->sb_master_dir.no_formal_ino);
213  	sb->sb_root_dir.no_addr = be64_to_cpu(str->sb_root_dir.no_addr);
214  	sb->sb_root_dir.no_formal_ino = be64_to_cpu(str->sb_root_dir.no_formal_ino);
215  
216  	memcpy(sb->sb_lockproto, str->sb_lockproto, GFS2_LOCKNAME_LEN);
217  	memcpy(sb->sb_locktable, str->sb_locktable, GFS2_LOCKNAME_LEN);
218  	memcpy(&s->s_uuid, str->sb_uuid, 16);
219  }
220  
221  /**
222   * gfs2_read_super - Read the gfs2 super block from disk
223   * @sdp: The GFS2 super block
224   * @sector: The location of the super block
225   * @silent: Don't print a message if the check fails
226   *
227   * This uses the bio functions to read the super block from disk
228   * because we want to be 100% sure that we never read cached data.
229   * A super block is read twice only during each GFS2 mount and is
230   * never written to by the filesystem. The first time its read no
231   * locks are held, and the only details which are looked at are those
232   * relating to the locking protocol. Once locking is up and working,
233   * the sb is read again under the lock to establish the location of
234   * the master directory (contains pointers to journals etc) and the
235   * root directory.
236   *
237   * Returns: 0 on success or error
238   */
239  
gfs2_read_super(struct gfs2_sbd * sdp,sector_t sector,int silent)240  static int gfs2_read_super(struct gfs2_sbd *sdp, sector_t sector, int silent)
241  {
242  	struct super_block *sb = sdp->sd_vfs;
243  	struct gfs2_sb *p;
244  	struct page *page;
245  	struct bio *bio;
246  
247  	page = alloc_page(GFP_NOFS);
248  	if (unlikely(!page))
249  		return -ENOMEM;
250  
251  	ClearPageUptodate(page);
252  	ClearPageDirty(page);
253  	lock_page(page);
254  
255  	bio = bio_alloc(sb->s_bdev, 1, REQ_OP_READ | REQ_META, GFP_NOFS);
256  	bio->bi_iter.bi_sector = sector * (sb->s_blocksize >> 9);
257  	__bio_add_page(bio, page, PAGE_SIZE, 0);
258  
259  	bio->bi_end_io = end_bio_io_page;
260  	bio->bi_private = page;
261  	submit_bio(bio);
262  	wait_on_page_locked(page);
263  	bio_put(bio);
264  	if (!PageUptodate(page)) {
265  		__free_page(page);
266  		return -EIO;
267  	}
268  	p = kmap(page);
269  	gfs2_sb_in(sdp, p);
270  	kunmap(page);
271  	__free_page(page);
272  	return gfs2_check_sb(sdp, silent);
273  }
274  
275  /**
276   * gfs2_read_sb - Read super block
277   * @sdp: The GFS2 superblock
278   * @silent: Don't print message if mount fails
279   *
280   */
281  
gfs2_read_sb(struct gfs2_sbd * sdp,int silent)282  static int gfs2_read_sb(struct gfs2_sbd *sdp, int silent)
283  {
284  	u32 hash_blocks, ind_blocks, leaf_blocks;
285  	u32 tmp_blocks;
286  	unsigned int x;
287  	int error;
288  
289  	error = gfs2_read_super(sdp, GFS2_SB_ADDR >> sdp->sd_fsb2bb_shift, silent);
290  	if (error) {
291  		if (!silent)
292  			fs_err(sdp, "can't read superblock\n");
293  		return error;
294  	}
295  
296  	sdp->sd_fsb2bb_shift = sdp->sd_sb.sb_bsize_shift -
297  			       GFS2_BASIC_BLOCK_SHIFT;
298  	sdp->sd_fsb2bb = BIT(sdp->sd_fsb2bb_shift);
299  	sdp->sd_diptrs = (sdp->sd_sb.sb_bsize -
300  			  sizeof(struct gfs2_dinode)) / sizeof(u64);
301  	sdp->sd_inptrs = (sdp->sd_sb.sb_bsize -
302  			  sizeof(struct gfs2_meta_header)) / sizeof(u64);
303  	sdp->sd_ldptrs = (sdp->sd_sb.sb_bsize -
304  			  sizeof(struct gfs2_log_descriptor)) / sizeof(u64);
305  	sdp->sd_jbsize = sdp->sd_sb.sb_bsize - sizeof(struct gfs2_meta_header);
306  	sdp->sd_hash_bsize = sdp->sd_sb.sb_bsize / 2;
307  	sdp->sd_hash_bsize_shift = sdp->sd_sb.sb_bsize_shift - 1;
308  	sdp->sd_hash_ptrs = sdp->sd_hash_bsize / sizeof(u64);
309  	sdp->sd_qc_per_block = (sdp->sd_sb.sb_bsize -
310  				sizeof(struct gfs2_meta_header)) /
311  			        sizeof(struct gfs2_quota_change);
312  	sdp->sd_blocks_per_bitmap = (sdp->sd_sb.sb_bsize -
313  				     sizeof(struct gfs2_meta_header))
314  		* GFS2_NBBY; /* not the rgrp bitmap, subsequent bitmaps only */
315  
316  	/*
317  	 * We always keep at least one block reserved for revokes in
318  	 * transactions.  This greatly simplifies allocating additional
319  	 * revoke blocks.
320  	 */
321  	atomic_set(&sdp->sd_log_revokes_available, sdp->sd_ldptrs);
322  
323  	/* Compute maximum reservation required to add a entry to a directory */
324  
325  	hash_blocks = DIV_ROUND_UP(sizeof(u64) * BIT(GFS2_DIR_MAX_DEPTH),
326  			     sdp->sd_jbsize);
327  
328  	ind_blocks = 0;
329  	for (tmp_blocks = hash_blocks; tmp_blocks > sdp->sd_diptrs;) {
330  		tmp_blocks = DIV_ROUND_UP(tmp_blocks, sdp->sd_inptrs);
331  		ind_blocks += tmp_blocks;
332  	}
333  
334  	leaf_blocks = 2 + GFS2_DIR_MAX_DEPTH;
335  
336  	sdp->sd_max_dirres = hash_blocks + ind_blocks + leaf_blocks;
337  
338  	sdp->sd_heightsize[0] = sdp->sd_sb.sb_bsize -
339  				sizeof(struct gfs2_dinode);
340  	sdp->sd_heightsize[1] = sdp->sd_sb.sb_bsize * sdp->sd_diptrs;
341  	for (x = 2;; x++) {
342  		u64 space, d;
343  		u32 m;
344  
345  		space = sdp->sd_heightsize[x - 1] * sdp->sd_inptrs;
346  		d = space;
347  		m = do_div(d, sdp->sd_inptrs);
348  
349  		if (d != sdp->sd_heightsize[x - 1] || m)
350  			break;
351  		sdp->sd_heightsize[x] = space;
352  	}
353  	sdp->sd_max_height = x;
354  	sdp->sd_heightsize[x] = ~0;
355  	gfs2_assert(sdp, sdp->sd_max_height <= GFS2_MAX_META_HEIGHT);
356  
357  	sdp->sd_max_dents_per_leaf = (sdp->sd_sb.sb_bsize -
358  				      sizeof(struct gfs2_leaf)) /
359  				     GFS2_MIN_DIRENT_SIZE;
360  	return 0;
361  }
362  
init_names(struct gfs2_sbd * sdp,int silent)363  static int init_names(struct gfs2_sbd *sdp, int silent)
364  {
365  	char *proto, *table;
366  	int error = 0;
367  
368  	proto = sdp->sd_args.ar_lockproto;
369  	table = sdp->sd_args.ar_locktable;
370  
371  	/*  Try to autodetect  */
372  
373  	if (!proto[0] || !table[0]) {
374  		error = gfs2_read_super(sdp, GFS2_SB_ADDR >> sdp->sd_fsb2bb_shift, silent);
375  		if (error)
376  			return error;
377  
378  		if (!proto[0])
379  			proto = sdp->sd_sb.sb_lockproto;
380  		if (!table[0])
381  			table = sdp->sd_sb.sb_locktable;
382  	}
383  
384  	if (!table[0])
385  		table = sdp->sd_vfs->s_id;
386  
387  	BUILD_BUG_ON(GFS2_LOCKNAME_LEN > GFS2_FSNAME_LEN);
388  
389  	strscpy(sdp->sd_proto_name, proto, GFS2_LOCKNAME_LEN);
390  	strscpy(sdp->sd_table_name, table, GFS2_LOCKNAME_LEN);
391  
392  	table = sdp->sd_table_name;
393  	while ((table = strchr(table, '/')))
394  		*table = '_';
395  
396  	return error;
397  }
398  
init_locking(struct gfs2_sbd * sdp,struct gfs2_holder * mount_gh,int undo)399  static int init_locking(struct gfs2_sbd *sdp, struct gfs2_holder *mount_gh,
400  			int undo)
401  {
402  	int error = 0;
403  
404  	if (undo)
405  		goto fail_trans;
406  
407  	error = gfs2_glock_nq_num(sdp,
408  				  GFS2_MOUNT_LOCK, &gfs2_nondisk_glops,
409  				  LM_ST_EXCLUSIVE,
410  				  LM_FLAG_NOEXP | GL_NOCACHE | GL_NOPID,
411  				  mount_gh);
412  	if (error) {
413  		fs_err(sdp, "can't acquire mount glock: %d\n", error);
414  		goto fail;
415  	}
416  
417  	error = gfs2_glock_nq_num(sdp,
418  				  GFS2_LIVE_LOCK, &gfs2_nondisk_glops,
419  				  LM_ST_SHARED,
420  				  LM_FLAG_NOEXP | GL_EXACT | GL_NOPID,
421  				  &sdp->sd_live_gh);
422  	if (error) {
423  		fs_err(sdp, "can't acquire live glock: %d\n", error);
424  		goto fail_mount;
425  	}
426  
427  	error = gfs2_glock_get(sdp, GFS2_RENAME_LOCK, &gfs2_nondisk_glops,
428  			       CREATE, &sdp->sd_rename_gl);
429  	if (error) {
430  		fs_err(sdp, "can't create rename glock: %d\n", error);
431  		goto fail_live;
432  	}
433  
434  	error = gfs2_glock_get(sdp, GFS2_FREEZE_LOCK, &gfs2_freeze_glops,
435  			       CREATE, &sdp->sd_freeze_gl);
436  	if (error) {
437  		fs_err(sdp, "can't create freeze glock: %d\n", error);
438  		goto fail_rename;
439  	}
440  
441  	return 0;
442  
443  fail_trans:
444  	gfs2_glock_put(sdp->sd_freeze_gl);
445  fail_rename:
446  	gfs2_glock_put(sdp->sd_rename_gl);
447  fail_live:
448  	gfs2_glock_dq_uninit(&sdp->sd_live_gh);
449  fail_mount:
450  	gfs2_glock_dq_uninit(mount_gh);
451  fail:
452  	return error;
453  }
454  
gfs2_lookup_root(struct super_block * sb,struct dentry ** dptr,u64 no_addr,const char * name)455  static int gfs2_lookup_root(struct super_block *sb, struct dentry **dptr,
456  			    u64 no_addr, const char *name)
457  {
458  	struct gfs2_sbd *sdp = sb->s_fs_info;
459  	struct dentry *dentry;
460  	struct inode *inode;
461  
462  	inode = gfs2_inode_lookup(sb, DT_DIR, no_addr, 0,
463  				  GFS2_BLKST_FREE /* ignore */);
464  	if (IS_ERR(inode)) {
465  		fs_err(sdp, "can't read in %s inode: %ld\n", name, PTR_ERR(inode));
466  		return PTR_ERR(inode);
467  	}
468  	dentry = d_make_root(inode);
469  	if (!dentry) {
470  		fs_err(sdp, "can't alloc %s dentry\n", name);
471  		return -ENOMEM;
472  	}
473  	*dptr = dentry;
474  	return 0;
475  }
476  
init_sb(struct gfs2_sbd * sdp,int silent)477  static int init_sb(struct gfs2_sbd *sdp, int silent)
478  {
479  	struct super_block *sb = sdp->sd_vfs;
480  	struct gfs2_holder sb_gh;
481  	u64 no_addr;
482  	int ret;
483  
484  	ret = gfs2_glock_nq_num(sdp, GFS2_SB_LOCK, &gfs2_meta_glops,
485  				LM_ST_SHARED, 0, &sb_gh);
486  	if (ret) {
487  		fs_err(sdp, "can't acquire superblock glock: %d\n", ret);
488  		return ret;
489  	}
490  
491  	ret = gfs2_read_sb(sdp, silent);
492  	if (ret) {
493  		fs_err(sdp, "can't read superblock: %d\n", ret);
494  		goto out;
495  	}
496  
497  	switch(sdp->sd_sb.sb_fs_format) {
498  	case GFS2_FS_FORMAT_MAX:
499  		sb->s_xattr = gfs2_xattr_handlers_max;
500  		break;
501  
502  	case GFS2_FS_FORMAT_MIN:
503  		sb->s_xattr = gfs2_xattr_handlers_min;
504  		break;
505  
506  	default:
507  		BUG();
508  	}
509  
510  	/* Set up the buffer cache and SB for real */
511  	if (sdp->sd_sb.sb_bsize < bdev_logical_block_size(sb->s_bdev)) {
512  		ret = -EINVAL;
513  		fs_err(sdp, "FS block size (%u) is too small for device "
514  		       "block size (%u)\n",
515  		       sdp->sd_sb.sb_bsize, bdev_logical_block_size(sb->s_bdev));
516  		goto out;
517  	}
518  	if (sdp->sd_sb.sb_bsize > PAGE_SIZE) {
519  		ret = -EINVAL;
520  		fs_err(sdp, "FS block size (%u) is too big for machine "
521  		       "page size (%u)\n",
522  		       sdp->sd_sb.sb_bsize, (unsigned int)PAGE_SIZE);
523  		goto out;
524  	}
525  	sb_set_blocksize(sb, sdp->sd_sb.sb_bsize);
526  
527  	/* Get the root inode */
528  	no_addr = sdp->sd_sb.sb_root_dir.no_addr;
529  	ret = gfs2_lookup_root(sb, &sdp->sd_root_dir, no_addr, "root");
530  	if (ret)
531  		goto out;
532  
533  	/* Get the master inode */
534  	no_addr = sdp->sd_sb.sb_master_dir.no_addr;
535  	ret = gfs2_lookup_root(sb, &sdp->sd_master_dir, no_addr, "master");
536  	if (ret) {
537  		dput(sdp->sd_root_dir);
538  		goto out;
539  	}
540  	sb->s_root = dget(sdp->sd_args.ar_meta ? sdp->sd_master_dir : sdp->sd_root_dir);
541  out:
542  	gfs2_glock_dq_uninit(&sb_gh);
543  	return ret;
544  }
545  
gfs2_others_may_mount(struct gfs2_sbd * sdp)546  static void gfs2_others_may_mount(struct gfs2_sbd *sdp)
547  {
548  	char *message = "FIRSTMOUNT=Done";
549  	char *envp[] = { message, NULL };
550  
551  	fs_info(sdp, "first mount done, others may mount\n");
552  
553  	if (sdp->sd_lockstruct.ls_ops->lm_first_done)
554  		sdp->sd_lockstruct.ls_ops->lm_first_done(sdp);
555  
556  	kobject_uevent_env(&sdp->sd_kobj, KOBJ_CHANGE, envp);
557  }
558  
559  /**
560   * gfs2_jindex_hold - Grab a lock on the jindex
561   * @sdp: The GFS2 superblock
562   * @ji_gh: the holder for the jindex glock
563   *
564   * Returns: errno
565   */
566  
gfs2_jindex_hold(struct gfs2_sbd * sdp,struct gfs2_holder * ji_gh)567  static int gfs2_jindex_hold(struct gfs2_sbd *sdp, struct gfs2_holder *ji_gh)
568  {
569  	struct gfs2_inode *dip = GFS2_I(sdp->sd_jindex);
570  	struct qstr name;
571  	char buf[20];
572  	struct gfs2_jdesc *jd;
573  	int error;
574  
575  	name.name = buf;
576  
577  	mutex_lock(&sdp->sd_jindex_mutex);
578  
579  	for (;;) {
580  		struct gfs2_inode *jip;
581  
582  		error = gfs2_glock_nq_init(dip->i_gl, LM_ST_SHARED, 0, ji_gh);
583  		if (error)
584  			break;
585  
586  		name.len = sprintf(buf, "journal%u", sdp->sd_journals);
587  		name.hash = gfs2_disk_hash(name.name, name.len);
588  
589  		error = gfs2_dir_check(sdp->sd_jindex, &name, NULL);
590  		if (error == -ENOENT) {
591  			error = 0;
592  			break;
593  		}
594  
595  		gfs2_glock_dq_uninit(ji_gh);
596  
597  		if (error)
598  			break;
599  
600  		error = -ENOMEM;
601  		jd = kzalloc(sizeof(struct gfs2_jdesc), GFP_KERNEL);
602  		if (!jd)
603  			break;
604  
605  		INIT_LIST_HEAD(&jd->extent_list);
606  		INIT_LIST_HEAD(&jd->jd_revoke_list);
607  
608  		INIT_WORK(&jd->jd_work, gfs2_recover_func);
609  		jd->jd_inode = gfs2_lookupi(sdp->sd_jindex, &name, 1);
610  		if (IS_ERR_OR_NULL(jd->jd_inode)) {
611  			if (!jd->jd_inode)
612  				error = -ENOENT;
613  			else
614  				error = PTR_ERR(jd->jd_inode);
615  			kfree(jd);
616  			break;
617  		}
618  
619  		d_mark_dontcache(jd->jd_inode);
620  		spin_lock(&sdp->sd_jindex_spin);
621  		jd->jd_jid = sdp->sd_journals++;
622  		jip = GFS2_I(jd->jd_inode);
623  		jd->jd_no_addr = jip->i_no_addr;
624  		list_add_tail(&jd->jd_list, &sdp->sd_jindex_list);
625  		spin_unlock(&sdp->sd_jindex_spin);
626  	}
627  
628  	mutex_unlock(&sdp->sd_jindex_mutex);
629  
630  	return error;
631  }
632  
633  /**
634   * init_statfs - look up and initialize master and local (per node) statfs inodes
635   * @sdp: The GFS2 superblock
636   *
637   * This should be called after the jindex is initialized in init_journal() and
638   * before gfs2_journal_recovery() is called because we need to be able to write
639   * to these inodes during recovery.
640   *
641   * Returns: errno
642   */
init_statfs(struct gfs2_sbd * sdp)643  static int init_statfs(struct gfs2_sbd *sdp)
644  {
645  	int error = 0;
646  	struct inode *master = d_inode(sdp->sd_master_dir);
647  	struct inode *pn = NULL;
648  	char buf[30];
649  	struct gfs2_jdesc *jd;
650  	struct gfs2_inode *ip;
651  
652  	sdp->sd_statfs_inode = gfs2_lookup_meta(master, "statfs");
653  	if (IS_ERR(sdp->sd_statfs_inode)) {
654  		error = PTR_ERR(sdp->sd_statfs_inode);
655  		fs_err(sdp, "can't read in statfs inode: %d\n", error);
656  		goto out;
657  	}
658  	if (sdp->sd_args.ar_spectator)
659  		goto out;
660  
661  	pn = gfs2_lookup_meta(master, "per_node");
662  	if (IS_ERR(pn)) {
663  		error = PTR_ERR(pn);
664  		fs_err(sdp, "can't find per_node directory: %d\n", error);
665  		goto put_statfs;
666  	}
667  
668  	/* For each jid, lookup the corresponding local statfs inode in the
669  	 * per_node metafs directory and save it in the sdp->sd_sc_inodes_list. */
670  	list_for_each_entry(jd, &sdp->sd_jindex_list, jd_list) {
671  		struct local_statfs_inode *lsi =
672  			kmalloc(sizeof(struct local_statfs_inode), GFP_NOFS);
673  		if (!lsi) {
674  			error = -ENOMEM;
675  			goto free_local;
676  		}
677  		sprintf(buf, "statfs_change%u", jd->jd_jid);
678  		lsi->si_sc_inode = gfs2_lookup_meta(pn, buf);
679  		if (IS_ERR(lsi->si_sc_inode)) {
680  			error = PTR_ERR(lsi->si_sc_inode);
681  			fs_err(sdp, "can't find local \"sc\" file#%u: %d\n",
682  			       jd->jd_jid, error);
683  			kfree(lsi);
684  			goto free_local;
685  		}
686  		lsi->si_jid = jd->jd_jid;
687  		if (jd->jd_jid == sdp->sd_jdesc->jd_jid)
688  			sdp->sd_sc_inode = lsi->si_sc_inode;
689  
690  		list_add_tail(&lsi->si_list, &sdp->sd_sc_inodes_list);
691  	}
692  
693  	iput(pn);
694  	pn = NULL;
695  	ip = GFS2_I(sdp->sd_sc_inode);
696  	error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, GL_NOPID,
697  				   &sdp->sd_sc_gh);
698  	if (error) {
699  		fs_err(sdp, "can't lock local \"sc\" file: %d\n", error);
700  		goto free_local;
701  	}
702  	/* read in the local statfs buffer - other nodes don't change it. */
703  	error = gfs2_meta_inode_buffer(ip, &sdp->sd_sc_bh);
704  	if (error) {
705  		fs_err(sdp, "Cannot read in local statfs: %d\n", error);
706  		goto unlock_sd_gh;
707  	}
708  	return 0;
709  
710  unlock_sd_gh:
711  	gfs2_glock_dq_uninit(&sdp->sd_sc_gh);
712  free_local:
713  	free_local_statfs_inodes(sdp);
714  	iput(pn);
715  put_statfs:
716  	iput(sdp->sd_statfs_inode);
717  out:
718  	return error;
719  }
720  
721  /* Uninitialize and free up memory used by the list of statfs inodes */
uninit_statfs(struct gfs2_sbd * sdp)722  static void uninit_statfs(struct gfs2_sbd *sdp)
723  {
724  	if (!sdp->sd_args.ar_spectator) {
725  		brelse(sdp->sd_sc_bh);
726  		gfs2_glock_dq_uninit(&sdp->sd_sc_gh);
727  		free_local_statfs_inodes(sdp);
728  	}
729  	iput(sdp->sd_statfs_inode);
730  }
731  
init_journal(struct gfs2_sbd * sdp,int undo)732  static int init_journal(struct gfs2_sbd *sdp, int undo)
733  {
734  	struct inode *master = d_inode(sdp->sd_master_dir);
735  	struct gfs2_holder ji_gh;
736  	struct gfs2_inode *ip;
737  	int error = 0;
738  
739  	gfs2_holder_mark_uninitialized(&ji_gh);
740  	if (undo)
741  		goto fail_statfs;
742  
743  	sdp->sd_jindex = gfs2_lookup_meta(master, "jindex");
744  	if (IS_ERR(sdp->sd_jindex)) {
745  		fs_err(sdp, "can't lookup journal index: %d\n", error);
746  		return PTR_ERR(sdp->sd_jindex);
747  	}
748  
749  	/* Load in the journal index special file */
750  
751  	error = gfs2_jindex_hold(sdp, &ji_gh);
752  	if (error) {
753  		fs_err(sdp, "can't read journal index: %d\n", error);
754  		goto fail;
755  	}
756  
757  	error = -EUSERS;
758  	if (!gfs2_jindex_size(sdp)) {
759  		fs_err(sdp, "no journals!\n");
760  		goto fail_jindex;
761  	}
762  
763  	atomic_set(&sdp->sd_log_blks_needed, 0);
764  	if (sdp->sd_args.ar_spectator) {
765  		sdp->sd_jdesc = gfs2_jdesc_find(sdp, 0);
766  		atomic_set(&sdp->sd_log_blks_free, sdp->sd_jdesc->jd_blocks);
767  		atomic_set(&sdp->sd_log_thresh1, 2*sdp->sd_jdesc->jd_blocks/5);
768  		atomic_set(&sdp->sd_log_thresh2, 4*sdp->sd_jdesc->jd_blocks/5);
769  	} else {
770  		if (sdp->sd_lockstruct.ls_jid >= gfs2_jindex_size(sdp)) {
771  			fs_err(sdp, "can't mount journal #%u\n",
772  			       sdp->sd_lockstruct.ls_jid);
773  			fs_err(sdp, "there are only %u journals (0 - %u)\n",
774  			       gfs2_jindex_size(sdp),
775  			       gfs2_jindex_size(sdp) - 1);
776  			goto fail_jindex;
777  		}
778  		sdp->sd_jdesc = gfs2_jdesc_find(sdp, sdp->sd_lockstruct.ls_jid);
779  
780  		error = gfs2_glock_nq_num(sdp, sdp->sd_lockstruct.ls_jid,
781  					  &gfs2_journal_glops,
782  					  LM_ST_EXCLUSIVE,
783  					  LM_FLAG_NOEXP | GL_NOCACHE | GL_NOPID,
784  					  &sdp->sd_journal_gh);
785  		if (error) {
786  			fs_err(sdp, "can't acquire journal glock: %d\n", error);
787  			goto fail_jindex;
788  		}
789  
790  		ip = GFS2_I(sdp->sd_jdesc->jd_inode);
791  		sdp->sd_jinode_gl = ip->i_gl;
792  		error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED,
793  					   LM_FLAG_NOEXP | GL_EXACT |
794  					   GL_NOCACHE | GL_NOPID,
795  					   &sdp->sd_jinode_gh);
796  		if (error) {
797  			fs_err(sdp, "can't acquire journal inode glock: %d\n",
798  			       error);
799  			goto fail_journal_gh;
800  		}
801  
802  		error = gfs2_jdesc_check(sdp->sd_jdesc);
803  		if (error) {
804  			fs_err(sdp, "my journal (%u) is bad: %d\n",
805  			       sdp->sd_jdesc->jd_jid, error);
806  			goto fail_jinode_gh;
807  		}
808  		atomic_set(&sdp->sd_log_blks_free, sdp->sd_jdesc->jd_blocks);
809  		atomic_set(&sdp->sd_log_thresh1, 2*sdp->sd_jdesc->jd_blocks/5);
810  		atomic_set(&sdp->sd_log_thresh2, 4*sdp->sd_jdesc->jd_blocks/5);
811  
812  		/* Map the extents for this journal's blocks */
813  		gfs2_map_journal_extents(sdp, sdp->sd_jdesc);
814  	}
815  	trace_gfs2_log_blocks(sdp, atomic_read(&sdp->sd_log_blks_free));
816  
817  	/* Lookup statfs inodes here so journal recovery can use them. */
818  	error = init_statfs(sdp);
819  	if (error)
820  		goto fail_jinode_gh;
821  
822  	if (sdp->sd_lockstruct.ls_first) {
823  		unsigned int x;
824  		for (x = 0; x < sdp->sd_journals; x++) {
825  			struct gfs2_jdesc *jd = gfs2_jdesc_find(sdp, x);
826  
827  			if (sdp->sd_args.ar_spectator) {
828  				error = check_journal_clean(sdp, jd, true);
829  				if (error)
830  					goto fail_statfs;
831  				continue;
832  			}
833  			error = gfs2_recover_journal(jd, true);
834  			if (error) {
835  				fs_err(sdp, "error recovering journal %u: %d\n",
836  				       x, error);
837  				goto fail_statfs;
838  			}
839  		}
840  
841  		gfs2_others_may_mount(sdp);
842  	} else if (!sdp->sd_args.ar_spectator) {
843  		error = gfs2_recover_journal(sdp->sd_jdesc, true);
844  		if (error) {
845  			fs_err(sdp, "error recovering my journal: %d\n", error);
846  			goto fail_statfs;
847  		}
848  	}
849  
850  	sdp->sd_log_idle = 1;
851  	set_bit(SDF_JOURNAL_CHECKED, &sdp->sd_flags);
852  	gfs2_glock_dq_uninit(&ji_gh);
853  	INIT_WORK(&sdp->sd_freeze_work, gfs2_freeze_func);
854  	return 0;
855  
856  fail_statfs:
857  	uninit_statfs(sdp);
858  fail_jinode_gh:
859  	/* A withdraw may have done dq/uninit so now we need to check it */
860  	if (!sdp->sd_args.ar_spectator &&
861  	    gfs2_holder_initialized(&sdp->sd_jinode_gh))
862  		gfs2_glock_dq_uninit(&sdp->sd_jinode_gh);
863  fail_journal_gh:
864  	if (!sdp->sd_args.ar_spectator &&
865  	    gfs2_holder_initialized(&sdp->sd_journal_gh))
866  		gfs2_glock_dq_uninit(&sdp->sd_journal_gh);
867  fail_jindex:
868  	gfs2_jindex_free(sdp);
869  	if (gfs2_holder_initialized(&ji_gh))
870  		gfs2_glock_dq_uninit(&ji_gh);
871  fail:
872  	iput(sdp->sd_jindex);
873  	return error;
874  }
875  
876  static struct lock_class_key gfs2_quota_imutex_key;
877  
init_inodes(struct gfs2_sbd * sdp,int undo)878  static int init_inodes(struct gfs2_sbd *sdp, int undo)
879  {
880  	int error = 0;
881  	struct inode *master = d_inode(sdp->sd_master_dir);
882  
883  	if (undo)
884  		goto fail_qinode;
885  
886  	error = init_journal(sdp, undo);
887  	complete_all(&sdp->sd_journal_ready);
888  	if (error)
889  		goto fail;
890  
891  	/* Read in the resource index inode */
892  	sdp->sd_rindex = gfs2_lookup_meta(master, "rindex");
893  	if (IS_ERR(sdp->sd_rindex)) {
894  		error = PTR_ERR(sdp->sd_rindex);
895  		fs_err(sdp, "can't get resource index inode: %d\n", error);
896  		goto fail_journal;
897  	}
898  	sdp->sd_rindex_uptodate = 0;
899  
900  	/* Read in the quota inode */
901  	sdp->sd_quota_inode = gfs2_lookup_meta(master, "quota");
902  	if (IS_ERR(sdp->sd_quota_inode)) {
903  		error = PTR_ERR(sdp->sd_quota_inode);
904  		fs_err(sdp, "can't get quota file inode: %d\n", error);
905  		goto fail_rindex;
906  	}
907  	/*
908  	 * i_rwsem on quota files is special. Since this inode is hidden system
909  	 * file, we are safe to define locking ourselves.
910  	 */
911  	lockdep_set_class(&sdp->sd_quota_inode->i_rwsem,
912  			  &gfs2_quota_imutex_key);
913  
914  	error = gfs2_rindex_update(sdp);
915  	if (error)
916  		goto fail_qinode;
917  
918  	return 0;
919  
920  fail_qinode:
921  	iput(sdp->sd_quota_inode);
922  fail_rindex:
923  	gfs2_clear_rgrpd(sdp);
924  	iput(sdp->sd_rindex);
925  fail_journal:
926  	init_journal(sdp, UNDO);
927  fail:
928  	return error;
929  }
930  
init_per_node(struct gfs2_sbd * sdp,int undo)931  static int init_per_node(struct gfs2_sbd *sdp, int undo)
932  {
933  	struct inode *pn = NULL;
934  	char buf[30];
935  	int error = 0;
936  	struct gfs2_inode *ip;
937  	struct inode *master = d_inode(sdp->sd_master_dir);
938  
939  	if (sdp->sd_args.ar_spectator)
940  		return 0;
941  
942  	if (undo)
943  		goto fail_qc_gh;
944  
945  	pn = gfs2_lookup_meta(master, "per_node");
946  	if (IS_ERR(pn)) {
947  		error = PTR_ERR(pn);
948  		fs_err(sdp, "can't find per_node directory: %d\n", error);
949  		return error;
950  	}
951  
952  	sprintf(buf, "quota_change%u", sdp->sd_jdesc->jd_jid);
953  	sdp->sd_qc_inode = gfs2_lookup_meta(pn, buf);
954  	if (IS_ERR(sdp->sd_qc_inode)) {
955  		error = PTR_ERR(sdp->sd_qc_inode);
956  		fs_err(sdp, "can't find local \"qc\" file: %d\n", error);
957  		goto fail_ut_i;
958  	}
959  
960  	iput(pn);
961  	pn = NULL;
962  
963  	ip = GFS2_I(sdp->sd_qc_inode);
964  	error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, GL_NOPID,
965  				   &sdp->sd_qc_gh);
966  	if (error) {
967  		fs_err(sdp, "can't lock local \"qc\" file: %d\n", error);
968  		goto fail_qc_i;
969  	}
970  
971  	return 0;
972  
973  fail_qc_gh:
974  	gfs2_glock_dq_uninit(&sdp->sd_qc_gh);
975  fail_qc_i:
976  	iput(sdp->sd_qc_inode);
977  fail_ut_i:
978  	iput(pn);
979  	return error;
980  }
981  
982  static const match_table_t nolock_tokens = {
983  	{ Opt_jid, "jid=%d", },
984  	{ Opt_err, NULL },
985  };
986  
987  static const struct lm_lockops nolock_ops = {
988  	.lm_proto_name = "lock_nolock",
989  	.lm_put_lock = gfs2_glock_free,
990  	.lm_tokens = &nolock_tokens,
991  };
992  
993  /**
994   * gfs2_lm_mount - mount a locking protocol
995   * @sdp: the filesystem
996   * @silent: if 1, don't complain if the FS isn't a GFS2 fs
997   *
998   * Returns: errno
999   */
1000  
gfs2_lm_mount(struct gfs2_sbd * sdp,int silent)1001  static int gfs2_lm_mount(struct gfs2_sbd *sdp, int silent)
1002  {
1003  	const struct lm_lockops *lm;
1004  	struct lm_lockstruct *ls = &sdp->sd_lockstruct;
1005  	struct gfs2_args *args = &sdp->sd_args;
1006  	const char *proto = sdp->sd_proto_name;
1007  	const char *table = sdp->sd_table_name;
1008  	char *o, *options;
1009  	int ret;
1010  
1011  	if (!strcmp("lock_nolock", proto)) {
1012  		lm = &nolock_ops;
1013  		sdp->sd_args.ar_localflocks = 1;
1014  #ifdef CONFIG_GFS2_FS_LOCKING_DLM
1015  	} else if (!strcmp("lock_dlm", proto)) {
1016  		lm = &gfs2_dlm_ops;
1017  #endif
1018  	} else {
1019  		pr_info("can't find protocol %s\n", proto);
1020  		return -ENOENT;
1021  	}
1022  
1023  	fs_info(sdp, "Trying to join cluster \"%s\", \"%s\"\n", proto, table);
1024  
1025  	ls->ls_ops = lm;
1026  	ls->ls_first = 1;
1027  
1028  	for (options = args->ar_hostdata; (o = strsep(&options, ":")); ) {
1029  		substring_t tmp[MAX_OPT_ARGS];
1030  		int token, option;
1031  
1032  		if (!o || !*o)
1033  			continue;
1034  
1035  		token = match_token(o, *lm->lm_tokens, tmp);
1036  		switch (token) {
1037  		case Opt_jid:
1038  			ret = match_int(&tmp[0], &option);
1039  			if (ret || option < 0)
1040  				goto hostdata_error;
1041  			if (test_and_clear_bit(SDF_NOJOURNALID, &sdp->sd_flags))
1042  				ls->ls_jid = option;
1043  			break;
1044  		case Opt_id:
1045  		case Opt_nodir:
1046  			/* Obsolete, but left for backward compat purposes */
1047  			break;
1048  		case Opt_first:
1049  			ret = match_int(&tmp[0], &option);
1050  			if (ret || (option != 0 && option != 1))
1051  				goto hostdata_error;
1052  			ls->ls_first = option;
1053  			break;
1054  		case Opt_err:
1055  		default:
1056  hostdata_error:
1057  			fs_info(sdp, "unknown hostdata (%s)\n", o);
1058  			return -EINVAL;
1059  		}
1060  	}
1061  
1062  	if (lm->lm_mount == NULL) {
1063  		fs_info(sdp, "Now mounting FS (format %u)...\n", sdp->sd_sb.sb_fs_format);
1064  		complete_all(&sdp->sd_locking_init);
1065  		return 0;
1066  	}
1067  	ret = lm->lm_mount(sdp, table);
1068  	if (ret == 0)
1069  		fs_info(sdp, "Joined cluster. Now mounting FS (format %u)...\n",
1070  		        sdp->sd_sb.sb_fs_format);
1071  	complete_all(&sdp->sd_locking_init);
1072  	return ret;
1073  }
1074  
gfs2_lm_unmount(struct gfs2_sbd * sdp)1075  void gfs2_lm_unmount(struct gfs2_sbd *sdp)
1076  {
1077  	const struct lm_lockops *lm = sdp->sd_lockstruct.ls_ops;
1078  	if (!gfs2_withdrawing_or_withdrawn(sdp) && lm->lm_unmount)
1079  		lm->lm_unmount(sdp);
1080  }
1081  
wait_on_journal(struct gfs2_sbd * sdp)1082  static int wait_on_journal(struct gfs2_sbd *sdp)
1083  {
1084  	if (sdp->sd_lockstruct.ls_ops->lm_mount == NULL)
1085  		return 0;
1086  
1087  	return wait_on_bit(&sdp->sd_flags, SDF_NOJOURNALID, TASK_INTERRUPTIBLE)
1088  		? -EINTR : 0;
1089  }
1090  
gfs2_online_uevent(struct gfs2_sbd * sdp)1091  void gfs2_online_uevent(struct gfs2_sbd *sdp)
1092  {
1093  	struct super_block *sb = sdp->sd_vfs;
1094  	char ro[20];
1095  	char spectator[20];
1096  	char *envp[] = { ro, spectator, NULL };
1097  	sprintf(ro, "RDONLY=%d", sb_rdonly(sb));
1098  	sprintf(spectator, "SPECTATOR=%d", sdp->sd_args.ar_spectator ? 1 : 0);
1099  	kobject_uevent_env(&sdp->sd_kobj, KOBJ_ONLINE, envp);
1100  }
1101  
init_threads(struct gfs2_sbd * sdp)1102  static int init_threads(struct gfs2_sbd *sdp)
1103  {
1104  	struct task_struct *p;
1105  	int error = 0;
1106  
1107  	p = kthread_create(gfs2_logd, sdp, "gfs2_logd/%s", sdp->sd_fsname);
1108  	if (IS_ERR(p)) {
1109  		error = PTR_ERR(p);
1110  		fs_err(sdp, "can't create logd thread: %d\n", error);
1111  		return error;
1112  	}
1113  	get_task_struct(p);
1114  	sdp->sd_logd_process = p;
1115  
1116  	p = kthread_create(gfs2_quotad, sdp, "gfs2_quotad/%s", sdp->sd_fsname);
1117  	if (IS_ERR(p)) {
1118  		error = PTR_ERR(p);
1119  		fs_err(sdp, "can't create quotad thread: %d\n", error);
1120  		goto fail;
1121  	}
1122  	get_task_struct(p);
1123  	sdp->sd_quotad_process = p;
1124  
1125  	wake_up_process(sdp->sd_logd_process);
1126  	wake_up_process(sdp->sd_quotad_process);
1127  	return 0;
1128  
1129  fail:
1130  	kthread_stop_put(sdp->sd_logd_process);
1131  	sdp->sd_logd_process = NULL;
1132  	return error;
1133  }
1134  
gfs2_destroy_threads(struct gfs2_sbd * sdp)1135  void gfs2_destroy_threads(struct gfs2_sbd *sdp)
1136  {
1137  	if (sdp->sd_logd_process) {
1138  		kthread_stop_put(sdp->sd_logd_process);
1139  		sdp->sd_logd_process = NULL;
1140  	}
1141  	if (sdp->sd_quotad_process) {
1142  		kthread_stop_put(sdp->sd_quotad_process);
1143  		sdp->sd_quotad_process = NULL;
1144  	}
1145  }
1146  
1147  /**
1148   * gfs2_fill_super - Read in superblock
1149   * @sb: The VFS superblock
1150   * @fc: Mount options and flags
1151   *
1152   * Returns: -errno
1153   */
gfs2_fill_super(struct super_block * sb,struct fs_context * fc)1154  static int gfs2_fill_super(struct super_block *sb, struct fs_context *fc)
1155  {
1156  	struct gfs2_args *args = fc->fs_private;
1157  	int silent = fc->sb_flags & SB_SILENT;
1158  	struct gfs2_sbd *sdp;
1159  	struct gfs2_holder mount_gh;
1160  	int error;
1161  
1162  	sdp = init_sbd(sb);
1163  	if (!sdp) {
1164  		pr_warn("can't alloc struct gfs2_sbd\n");
1165  		return -ENOMEM;
1166  	}
1167  	sdp->sd_args = *args;
1168  
1169  	if (sdp->sd_args.ar_spectator) {
1170                  sb->s_flags |= SB_RDONLY;
1171  		set_bit(SDF_RORECOVERY, &sdp->sd_flags);
1172  	}
1173  	if (sdp->sd_args.ar_posix_acl)
1174  		sb->s_flags |= SB_POSIXACL;
1175  	if (sdp->sd_args.ar_nobarrier)
1176  		set_bit(SDF_NOBARRIERS, &sdp->sd_flags);
1177  
1178  	sb->s_flags |= SB_NOSEC;
1179  	sb->s_magic = GFS2_MAGIC;
1180  	sb->s_op = &gfs2_super_ops;
1181  	sb->s_d_op = &gfs2_dops;
1182  	sb->s_export_op = &gfs2_export_ops;
1183  	sb->s_qcop = &gfs2_quotactl_ops;
1184  	sb->s_quota_types = QTYPE_MASK_USR | QTYPE_MASK_GRP;
1185  	sb_dqopt(sb)->flags |= DQUOT_QUOTA_SYS_FILE;
1186  	sb->s_time_gran = 1;
1187  	sb->s_maxbytes = MAX_LFS_FILESIZE;
1188  
1189  	/* Set up the buffer cache and fill in some fake block size values
1190  	   to allow us to read-in the on-disk superblock. */
1191  	sdp->sd_sb.sb_bsize = sb_min_blocksize(sb, GFS2_BASIC_BLOCK);
1192  	sdp->sd_sb.sb_bsize_shift = sb->s_blocksize_bits;
1193  	sdp->sd_fsb2bb_shift = sdp->sd_sb.sb_bsize_shift -
1194                                 GFS2_BASIC_BLOCK_SHIFT;
1195  	sdp->sd_fsb2bb = BIT(sdp->sd_fsb2bb_shift);
1196  
1197  	sdp->sd_tune.gt_logd_secs = sdp->sd_args.ar_commit;
1198  	sdp->sd_tune.gt_quota_quantum = sdp->sd_args.ar_quota_quantum;
1199  	if (sdp->sd_args.ar_statfs_quantum) {
1200  		sdp->sd_tune.gt_statfs_slow = 0;
1201  		sdp->sd_tune.gt_statfs_quantum = sdp->sd_args.ar_statfs_quantum;
1202  	} else {
1203  		sdp->sd_tune.gt_statfs_slow = 1;
1204  		sdp->sd_tune.gt_statfs_quantum = 30;
1205  	}
1206  
1207  	error = init_names(sdp, silent);
1208  	if (error)
1209  		goto fail_free;
1210  
1211  	snprintf(sdp->sd_fsname, sizeof(sdp->sd_fsname), "%s", sdp->sd_table_name);
1212  
1213  	sdp->sd_delete_wq = alloc_workqueue("gfs2-delete/%s",
1214  			WQ_MEM_RECLAIM | WQ_FREEZABLE, 0, sdp->sd_fsname);
1215  	error = -ENOMEM;
1216  	if (!sdp->sd_delete_wq)
1217  		goto fail_free;
1218  
1219  	error = gfs2_sys_fs_add(sdp);
1220  	if (error)
1221  		goto fail_delete_wq;
1222  
1223  	gfs2_create_debugfs_file(sdp);
1224  
1225  	error = gfs2_lm_mount(sdp, silent);
1226  	if (error)
1227  		goto fail_debug;
1228  
1229  	error = init_locking(sdp, &mount_gh, DO);
1230  	if (error)
1231  		goto fail_lm;
1232  
1233  	error = init_sb(sdp, silent);
1234  	if (error)
1235  		goto fail_locking;
1236  
1237  	/* Turn rgrplvb on by default if fs format is recent enough */
1238  	if (!sdp->sd_args.ar_got_rgrplvb && sdp->sd_sb.sb_fs_format > 1801)
1239  		sdp->sd_args.ar_rgrplvb = 1;
1240  
1241  	error = wait_on_journal(sdp);
1242  	if (error)
1243  		goto fail_sb;
1244  
1245  	/*
1246  	 * If user space has failed to join the cluster or some similar
1247  	 * failure has occurred, then the journal id will contain a
1248  	 * negative (error) number. This will then be returned to the
1249  	 * caller (of the mount syscall). We do this even for spectator
1250  	 * mounts (which just write a jid of 0 to indicate "ok" even though
1251  	 * the jid is unused in the spectator case)
1252  	 */
1253  	if (sdp->sd_lockstruct.ls_jid < 0) {
1254  		error = sdp->sd_lockstruct.ls_jid;
1255  		sdp->sd_lockstruct.ls_jid = 0;
1256  		goto fail_sb;
1257  	}
1258  
1259  	if (sdp->sd_args.ar_spectator)
1260  		snprintf(sdp->sd_fsname, sizeof(sdp->sd_fsname), "%s.s",
1261  			 sdp->sd_table_name);
1262  	else
1263  		snprintf(sdp->sd_fsname, sizeof(sdp->sd_fsname), "%s.%u",
1264  			 sdp->sd_table_name, sdp->sd_lockstruct.ls_jid);
1265  
1266  	error = init_inodes(sdp, DO);
1267  	if (error)
1268  		goto fail_sb;
1269  
1270  	error = init_per_node(sdp, DO);
1271  	if (error)
1272  		goto fail_inodes;
1273  
1274  	error = gfs2_statfs_init(sdp);
1275  	if (error) {
1276  		fs_err(sdp, "can't initialize statfs subsystem: %d\n", error);
1277  		goto fail_per_node;
1278  	}
1279  
1280  	if (!sb_rdonly(sb)) {
1281  		error = init_threads(sdp);
1282  		if (error)
1283  			goto fail_per_node;
1284  	}
1285  
1286  	error = gfs2_freeze_lock_shared(sdp);
1287  	if (error)
1288  		goto fail_per_node;
1289  
1290  	if (!sb_rdonly(sb))
1291  		error = gfs2_make_fs_rw(sdp);
1292  
1293  	if (error) {
1294  		gfs2_freeze_unlock(&sdp->sd_freeze_gh);
1295  		gfs2_destroy_threads(sdp);
1296  		fs_err(sdp, "can't make FS RW: %d\n", error);
1297  		goto fail_per_node;
1298  	}
1299  	gfs2_glock_dq_uninit(&mount_gh);
1300  	gfs2_online_uevent(sdp);
1301  	return 0;
1302  
1303  fail_per_node:
1304  	init_per_node(sdp, UNDO);
1305  fail_inodes:
1306  	init_inodes(sdp, UNDO);
1307  fail_sb:
1308  	if (sdp->sd_root_dir)
1309  		dput(sdp->sd_root_dir);
1310  	if (sdp->sd_master_dir)
1311  		dput(sdp->sd_master_dir);
1312  	if (sb->s_root)
1313  		dput(sb->s_root);
1314  	sb->s_root = NULL;
1315  fail_locking:
1316  	init_locking(sdp, &mount_gh, UNDO);
1317  fail_lm:
1318  	complete_all(&sdp->sd_journal_ready);
1319  	gfs2_gl_hash_clear(sdp);
1320  	gfs2_lm_unmount(sdp);
1321  fail_debug:
1322  	gfs2_delete_debugfs_file(sdp);
1323  	gfs2_sys_fs_del(sdp);
1324  fail_delete_wq:
1325  	destroy_workqueue(sdp->sd_delete_wq);
1326  fail_free:
1327  	free_sbd(sdp);
1328  	sb->s_fs_info = NULL;
1329  	return error;
1330  }
1331  
1332  /**
1333   * gfs2_get_tree - Get the GFS2 superblock and root directory
1334   * @fc: The filesystem context
1335   *
1336   * Returns: 0 or -errno on error
1337   */
gfs2_get_tree(struct fs_context * fc)1338  static int gfs2_get_tree(struct fs_context *fc)
1339  {
1340  	struct gfs2_args *args = fc->fs_private;
1341  	struct gfs2_sbd *sdp;
1342  	int error;
1343  
1344  	error = get_tree_bdev(fc, gfs2_fill_super);
1345  	if (error)
1346  		return error;
1347  
1348  	sdp = fc->root->d_sb->s_fs_info;
1349  	dput(fc->root);
1350  	if (args->ar_meta)
1351  		fc->root = dget(sdp->sd_master_dir);
1352  	else
1353  		fc->root = dget(sdp->sd_root_dir);
1354  	return 0;
1355  }
1356  
gfs2_fc_free(struct fs_context * fc)1357  static void gfs2_fc_free(struct fs_context *fc)
1358  {
1359  	struct gfs2_args *args = fc->fs_private;
1360  
1361  	kfree(args);
1362  }
1363  
1364  enum gfs2_param {
1365  	Opt_lockproto,
1366  	Opt_locktable,
1367  	Opt_hostdata,
1368  	Opt_spectator,
1369  	Opt_ignore_local_fs,
1370  	Opt_localflocks,
1371  	Opt_localcaching,
1372  	Opt_debug,
1373  	Opt_upgrade,
1374  	Opt_acl,
1375  	Opt_quota,
1376  	Opt_quota_flag,
1377  	Opt_suiddir,
1378  	Opt_data,
1379  	Opt_meta,
1380  	Opt_discard,
1381  	Opt_commit,
1382  	Opt_errors,
1383  	Opt_statfs_quantum,
1384  	Opt_statfs_percent,
1385  	Opt_quota_quantum,
1386  	Opt_barrier,
1387  	Opt_rgrplvb,
1388  	Opt_loccookie,
1389  };
1390  
1391  static const struct constant_table gfs2_param_quota[] = {
1392  	{"off",        GFS2_QUOTA_OFF},
1393  	{"account",    GFS2_QUOTA_ACCOUNT},
1394  	{"on",         GFS2_QUOTA_ON},
1395  	{"quiet",      GFS2_QUOTA_QUIET},
1396  	{}
1397  };
1398  
1399  enum opt_data {
1400  	Opt_data_writeback = GFS2_DATA_WRITEBACK,
1401  	Opt_data_ordered   = GFS2_DATA_ORDERED,
1402  };
1403  
1404  static const struct constant_table gfs2_param_data[] = {
1405  	{"writeback",  Opt_data_writeback },
1406  	{"ordered",    Opt_data_ordered },
1407  	{}
1408  };
1409  
1410  enum opt_errors {
1411  	Opt_errors_withdraw = GFS2_ERRORS_WITHDRAW,
1412  	Opt_errors_panic    = GFS2_ERRORS_PANIC,
1413  };
1414  
1415  static const struct constant_table gfs2_param_errors[] = {
1416  	{"withdraw",   Opt_errors_withdraw },
1417  	{"panic",      Opt_errors_panic },
1418  	{}
1419  };
1420  
1421  static const struct fs_parameter_spec gfs2_fs_parameters[] = {
1422  	fsparam_string ("lockproto",          Opt_lockproto),
1423  	fsparam_string ("locktable",          Opt_locktable),
1424  	fsparam_string ("hostdata",           Opt_hostdata),
1425  	fsparam_flag   ("spectator",          Opt_spectator),
1426  	fsparam_flag   ("norecovery",         Opt_spectator),
1427  	fsparam_flag   ("ignore_local_fs",    Opt_ignore_local_fs),
1428  	fsparam_flag   ("localflocks",        Opt_localflocks),
1429  	fsparam_flag   ("localcaching",       Opt_localcaching),
1430  	fsparam_flag_no("debug",              Opt_debug),
1431  	fsparam_flag   ("upgrade",            Opt_upgrade),
1432  	fsparam_flag_no("acl",                Opt_acl),
1433  	fsparam_flag_no("suiddir",            Opt_suiddir),
1434  	fsparam_enum   ("data",               Opt_data, gfs2_param_data),
1435  	fsparam_flag   ("meta",               Opt_meta),
1436  	fsparam_flag_no("discard",            Opt_discard),
1437  	fsparam_s32    ("commit",             Opt_commit),
1438  	fsparam_enum   ("errors",             Opt_errors, gfs2_param_errors),
1439  	fsparam_s32    ("statfs_quantum",     Opt_statfs_quantum),
1440  	fsparam_s32    ("statfs_percent",     Opt_statfs_percent),
1441  	fsparam_s32    ("quota_quantum",      Opt_quota_quantum),
1442  	fsparam_flag_no("barrier",            Opt_barrier),
1443  	fsparam_flag_no("rgrplvb",            Opt_rgrplvb),
1444  	fsparam_flag_no("loccookie",          Opt_loccookie),
1445  	/* quota can be a flag or an enum so it gets special treatment */
1446  	fsparam_flag_no("quota",	      Opt_quota_flag),
1447  	fsparam_enum("quota",		      Opt_quota, gfs2_param_quota),
1448  	{}
1449  };
1450  
1451  /* Parse a single mount parameter */
gfs2_parse_param(struct fs_context * fc,struct fs_parameter * param)1452  static int gfs2_parse_param(struct fs_context *fc, struct fs_parameter *param)
1453  {
1454  	struct gfs2_args *args = fc->fs_private;
1455  	struct fs_parse_result result;
1456  	int o;
1457  
1458  	o = fs_parse(fc, gfs2_fs_parameters, param, &result);
1459  	if (o < 0)
1460  		return o;
1461  
1462  	switch (o) {
1463  	case Opt_lockproto:
1464  		strscpy(args->ar_lockproto, param->string, GFS2_LOCKNAME_LEN);
1465  		break;
1466  	case Opt_locktable:
1467  		strscpy(args->ar_locktable, param->string, GFS2_LOCKNAME_LEN);
1468  		break;
1469  	case Opt_hostdata:
1470  		strscpy(args->ar_hostdata, param->string, GFS2_LOCKNAME_LEN);
1471  		break;
1472  	case Opt_spectator:
1473  		args->ar_spectator = 1;
1474  		break;
1475  	case Opt_ignore_local_fs:
1476  		/* Retained for backwards compat only */
1477  		break;
1478  	case Opt_localflocks:
1479  		args->ar_localflocks = 1;
1480  		break;
1481  	case Opt_localcaching:
1482  		/* Retained for backwards compat only */
1483  		break;
1484  	case Opt_debug:
1485  		if (result.boolean && args->ar_errors == GFS2_ERRORS_PANIC)
1486  			return invalfc(fc, "-o debug and -o errors=panic are mutually exclusive");
1487  		args->ar_debug = result.boolean;
1488  		break;
1489  	case Opt_upgrade:
1490  		/* Retained for backwards compat only */
1491  		break;
1492  	case Opt_acl:
1493  		args->ar_posix_acl = result.boolean;
1494  		break;
1495  	case Opt_quota_flag:
1496  		args->ar_quota = result.negated ? GFS2_QUOTA_OFF : GFS2_QUOTA_ON;
1497  		break;
1498  	case Opt_quota:
1499  		args->ar_quota = result.int_32;
1500  		break;
1501  	case Opt_suiddir:
1502  		args->ar_suiddir = result.boolean;
1503  		break;
1504  	case Opt_data:
1505  		/* The uint_32 result maps directly to GFS2_DATA_* */
1506  		args->ar_data = result.uint_32;
1507  		break;
1508  	case Opt_meta:
1509  		args->ar_meta = 1;
1510  		break;
1511  	case Opt_discard:
1512  		args->ar_discard = result.boolean;
1513  		break;
1514  	case Opt_commit:
1515  		if (result.int_32 <= 0)
1516  			return invalfc(fc, "commit mount option requires a positive numeric argument");
1517  		args->ar_commit = result.int_32;
1518  		break;
1519  	case Opt_statfs_quantum:
1520  		if (result.int_32 < 0)
1521  			return invalfc(fc, "statfs_quantum mount option requires a non-negative numeric argument");
1522  		args->ar_statfs_quantum = result.int_32;
1523  		break;
1524  	case Opt_quota_quantum:
1525  		if (result.int_32 <= 0)
1526  			return invalfc(fc, "quota_quantum mount option requires a positive numeric argument");
1527  		args->ar_quota_quantum = result.int_32;
1528  		break;
1529  	case Opt_statfs_percent:
1530  		if (result.int_32 < 0 || result.int_32 > 100)
1531  			return invalfc(fc, "statfs_percent mount option requires a numeric argument between 0 and 100");
1532  		args->ar_statfs_percent = result.int_32;
1533  		break;
1534  	case Opt_errors:
1535  		if (args->ar_debug && result.uint_32 == GFS2_ERRORS_PANIC)
1536  			return invalfc(fc, "-o debug and -o errors=panic are mutually exclusive");
1537  		args->ar_errors = result.uint_32;
1538  		break;
1539  	case Opt_barrier:
1540  		args->ar_nobarrier = result.boolean;
1541  		break;
1542  	case Opt_rgrplvb:
1543  		args->ar_rgrplvb = result.boolean;
1544  		args->ar_got_rgrplvb = 1;
1545  		break;
1546  	case Opt_loccookie:
1547  		args->ar_loccookie = result.boolean;
1548  		break;
1549  	default:
1550  		return invalfc(fc, "invalid mount option: %s", param->key);
1551  	}
1552  	return 0;
1553  }
1554  
gfs2_reconfigure(struct fs_context * fc)1555  static int gfs2_reconfigure(struct fs_context *fc)
1556  {
1557  	struct super_block *sb = fc->root->d_sb;
1558  	struct gfs2_sbd *sdp = sb->s_fs_info;
1559  	struct gfs2_args *oldargs = &sdp->sd_args;
1560  	struct gfs2_args *newargs = fc->fs_private;
1561  	struct gfs2_tune *gt = &sdp->sd_tune;
1562  	int error = 0;
1563  
1564  	sync_filesystem(sb);
1565  
1566  	spin_lock(&gt->gt_spin);
1567  	oldargs->ar_commit = gt->gt_logd_secs;
1568  	oldargs->ar_quota_quantum = gt->gt_quota_quantum;
1569  	if (gt->gt_statfs_slow)
1570  		oldargs->ar_statfs_quantum = 0;
1571  	else
1572  		oldargs->ar_statfs_quantum = gt->gt_statfs_quantum;
1573  	spin_unlock(&gt->gt_spin);
1574  
1575  	if (strcmp(newargs->ar_lockproto, oldargs->ar_lockproto)) {
1576  		errorfc(fc, "reconfiguration of locking protocol not allowed");
1577  		return -EINVAL;
1578  	}
1579  	if (strcmp(newargs->ar_locktable, oldargs->ar_locktable)) {
1580  		errorfc(fc, "reconfiguration of lock table not allowed");
1581  		return -EINVAL;
1582  	}
1583  	if (strcmp(newargs->ar_hostdata, oldargs->ar_hostdata)) {
1584  		errorfc(fc, "reconfiguration of host data not allowed");
1585  		return -EINVAL;
1586  	}
1587  	if (newargs->ar_spectator != oldargs->ar_spectator) {
1588  		errorfc(fc, "reconfiguration of spectator mode not allowed");
1589  		return -EINVAL;
1590  	}
1591  	if (newargs->ar_localflocks != oldargs->ar_localflocks) {
1592  		errorfc(fc, "reconfiguration of localflocks not allowed");
1593  		return -EINVAL;
1594  	}
1595  	if (newargs->ar_meta != oldargs->ar_meta) {
1596  		errorfc(fc, "switching between gfs2 and gfs2meta not allowed");
1597  		return -EINVAL;
1598  	}
1599  	if (oldargs->ar_spectator)
1600  		fc->sb_flags |= SB_RDONLY;
1601  
1602  	if ((sb->s_flags ^ fc->sb_flags) & SB_RDONLY) {
1603  		if (fc->sb_flags & SB_RDONLY) {
1604  			gfs2_make_fs_ro(sdp);
1605  		} else {
1606  			error = gfs2_make_fs_rw(sdp);
1607  			if (error)
1608  				errorfc(fc, "unable to remount read-write");
1609  		}
1610  	}
1611  	sdp->sd_args = *newargs;
1612  
1613  	if (sdp->sd_args.ar_posix_acl)
1614  		sb->s_flags |= SB_POSIXACL;
1615  	else
1616  		sb->s_flags &= ~SB_POSIXACL;
1617  	if (sdp->sd_args.ar_nobarrier)
1618  		set_bit(SDF_NOBARRIERS, &sdp->sd_flags);
1619  	else
1620  		clear_bit(SDF_NOBARRIERS, &sdp->sd_flags);
1621  	spin_lock(&gt->gt_spin);
1622  	gt->gt_logd_secs = newargs->ar_commit;
1623  	gt->gt_quota_quantum = newargs->ar_quota_quantum;
1624  	if (newargs->ar_statfs_quantum) {
1625  		gt->gt_statfs_slow = 0;
1626  		gt->gt_statfs_quantum = newargs->ar_statfs_quantum;
1627  	}
1628  	else {
1629  		gt->gt_statfs_slow = 1;
1630  		gt->gt_statfs_quantum = 30;
1631  	}
1632  	spin_unlock(&gt->gt_spin);
1633  
1634  	gfs2_online_uevent(sdp);
1635  	return error;
1636  }
1637  
1638  static const struct fs_context_operations gfs2_context_ops = {
1639  	.free        = gfs2_fc_free,
1640  	.parse_param = gfs2_parse_param,
1641  	.get_tree    = gfs2_get_tree,
1642  	.reconfigure = gfs2_reconfigure,
1643  };
1644  
1645  /* Set up the filesystem mount context */
gfs2_init_fs_context(struct fs_context * fc)1646  static int gfs2_init_fs_context(struct fs_context *fc)
1647  {
1648  	struct gfs2_args *args;
1649  
1650  	args = kmalloc(sizeof(*args), GFP_KERNEL);
1651  	if (args == NULL)
1652  		return -ENOMEM;
1653  
1654  	if (fc->purpose == FS_CONTEXT_FOR_RECONFIGURE) {
1655  		struct gfs2_sbd *sdp = fc->root->d_sb->s_fs_info;
1656  
1657  		*args = sdp->sd_args;
1658  	} else {
1659  		memset(args, 0, sizeof(*args));
1660  		args->ar_quota = GFS2_QUOTA_DEFAULT;
1661  		args->ar_data = GFS2_DATA_DEFAULT;
1662  		args->ar_commit = 30;
1663  		args->ar_statfs_quantum = 30;
1664  		args->ar_quota_quantum = 60;
1665  		args->ar_errors = GFS2_ERRORS_DEFAULT;
1666  	}
1667  	fc->fs_private = args;
1668  	fc->ops = &gfs2_context_ops;
1669  	return 0;
1670  }
1671  
set_meta_super(struct super_block * s,struct fs_context * fc)1672  static int set_meta_super(struct super_block *s, struct fs_context *fc)
1673  {
1674  	return -EINVAL;
1675  }
1676  
test_meta_super(struct super_block * s,struct fs_context * fc)1677  static int test_meta_super(struct super_block *s, struct fs_context *fc)
1678  {
1679  	return (fc->sget_key == s->s_bdev);
1680  }
1681  
gfs2_meta_get_tree(struct fs_context * fc)1682  static int gfs2_meta_get_tree(struct fs_context *fc)
1683  {
1684  	struct super_block *s;
1685  	struct gfs2_sbd *sdp;
1686  	struct path path;
1687  	int error;
1688  
1689  	if (!fc->source || !*fc->source)
1690  		return -EINVAL;
1691  
1692  	error = kern_path(fc->source, LOOKUP_FOLLOW, &path);
1693  	if (error) {
1694  		pr_warn("path_lookup on %s returned error %d\n",
1695  		        fc->source, error);
1696  		return error;
1697  	}
1698  	fc->fs_type = &gfs2_fs_type;
1699  	fc->sget_key = path.dentry->d_sb->s_bdev;
1700  	s = sget_fc(fc, test_meta_super, set_meta_super);
1701  	path_put(&path);
1702  	if (IS_ERR(s)) {
1703  		pr_warn("gfs2 mount does not exist\n");
1704  		return PTR_ERR(s);
1705  	}
1706  	if ((fc->sb_flags ^ s->s_flags) & SB_RDONLY) {
1707  		deactivate_locked_super(s);
1708  		return -EBUSY;
1709  	}
1710  	sdp = s->s_fs_info;
1711  	fc->root = dget(sdp->sd_master_dir);
1712  	return 0;
1713  }
1714  
1715  static const struct fs_context_operations gfs2_meta_context_ops = {
1716  	.free        = gfs2_fc_free,
1717  	.get_tree    = gfs2_meta_get_tree,
1718  };
1719  
gfs2_meta_init_fs_context(struct fs_context * fc)1720  static int gfs2_meta_init_fs_context(struct fs_context *fc)
1721  {
1722  	int ret = gfs2_init_fs_context(fc);
1723  
1724  	if (ret)
1725  		return ret;
1726  
1727  	fc->ops = &gfs2_meta_context_ops;
1728  	return 0;
1729  }
1730  
1731  /**
1732   * gfs2_evict_inodes - evict inodes cooperatively
1733   * @sb: the superblock
1734   *
1735   * When evicting an inode with a zero link count, we are trying to upgrade the
1736   * inode's iopen glock from SH to EX mode in order to determine if we can
1737   * delete the inode.  The other nodes are supposed to evict the inode from
1738   * their caches if they can, and to poke the inode's inode glock if they cannot
1739   * do so.  Either behavior allows gfs2_upgrade_iopen_glock() to proceed
1740   * quickly, but if the other nodes are not cooperating, the lock upgrading
1741   * attempt will time out.  Since inodes are evicted sequentially, this can add
1742   * up quickly.
1743   *
1744   * Function evict_inodes() tries to keep the s_inode_list_lock list locked over
1745   * a long time, which prevents other inodes from being evicted concurrently.
1746   * This precludes the cooperative behavior we are looking for.  This special
1747   * version of evict_inodes() avoids that.
1748   *
1749   * Modeled after drop_pagecache_sb().
1750   */
gfs2_evict_inodes(struct super_block * sb)1751  static void gfs2_evict_inodes(struct super_block *sb)
1752  {
1753  	struct inode *inode, *toput_inode = NULL;
1754  	struct gfs2_sbd *sdp = sb->s_fs_info;
1755  
1756  	set_bit(SDF_EVICTING, &sdp->sd_flags);
1757  
1758  	spin_lock(&sb->s_inode_list_lock);
1759  	list_for_each_entry(inode, &sb->s_inodes, i_sb_list) {
1760  		spin_lock(&inode->i_lock);
1761  		if ((inode->i_state & (I_FREEING|I_WILL_FREE|I_NEW)) &&
1762  		    !need_resched()) {
1763  			spin_unlock(&inode->i_lock);
1764  			continue;
1765  		}
1766  		atomic_inc(&inode->i_count);
1767  		spin_unlock(&inode->i_lock);
1768  		spin_unlock(&sb->s_inode_list_lock);
1769  
1770  		iput(toput_inode);
1771  		toput_inode = inode;
1772  
1773  		cond_resched();
1774  		spin_lock(&sb->s_inode_list_lock);
1775  	}
1776  	spin_unlock(&sb->s_inode_list_lock);
1777  	iput(toput_inode);
1778  }
1779  
gfs2_kill_sb(struct super_block * sb)1780  static void gfs2_kill_sb(struct super_block *sb)
1781  {
1782  	struct gfs2_sbd *sdp = sb->s_fs_info;
1783  
1784  	if (sdp == NULL) {
1785  		kill_block_super(sb);
1786  		return;
1787  	}
1788  
1789  	gfs2_log_flush(sdp, NULL, GFS2_LOG_HEAD_FLUSH_SYNC | GFS2_LFC_KILL_SB);
1790  	dput(sdp->sd_root_dir);
1791  	dput(sdp->sd_master_dir);
1792  	sdp->sd_root_dir = NULL;
1793  	sdp->sd_master_dir = NULL;
1794  	shrink_dcache_sb(sb);
1795  
1796  	gfs2_evict_inodes(sb);
1797  
1798  	/*
1799  	 * Flush and then drain the delete workqueue here (via
1800  	 * destroy_workqueue()) to ensure that any delete work that
1801  	 * may be running will also see the SDF_KILL flag.
1802  	 */
1803  	set_bit(SDF_KILL, &sdp->sd_flags);
1804  	gfs2_flush_delete_work(sdp);
1805  	destroy_workqueue(sdp->sd_delete_wq);
1806  
1807  	kill_block_super(sb);
1808  }
1809  
1810  struct file_system_type gfs2_fs_type = {
1811  	.name = "gfs2",
1812  	.fs_flags = FS_REQUIRES_DEV,
1813  	.init_fs_context = gfs2_init_fs_context,
1814  	.parameters = gfs2_fs_parameters,
1815  	.kill_sb = gfs2_kill_sb,
1816  	.owner = THIS_MODULE,
1817  };
1818  MODULE_ALIAS_FS("gfs2");
1819  
1820  struct file_system_type gfs2meta_fs_type = {
1821  	.name = "gfs2meta",
1822  	.fs_flags = FS_REQUIRES_DEV,
1823  	.init_fs_context = gfs2_meta_init_fs_context,
1824  	.owner = THIS_MODULE,
1825  };
1826  MODULE_ALIAS_FS("gfs2meta");
1827