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