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