blob: 7ec0e6d03d1038be079d1a1894d40e12b7d1f18c [file] [log] [blame]
Thomas Gleixner09c434b2019-05-19 13:08:20 +01001// SPDX-License-Identifier: GPL-2.0-only
Sage Weil16725b92009-10-06 11:31:07 -07002
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -07003#include <linux/ceph/ceph_debug.h>
Sage Weil16725b92009-10-06 11:31:07 -07004
5#include <linux/backing-dev.h>
Sage Weilc309f0a2010-06-30 21:34:01 -07006#include <linux/ctype.h>
Sage Weil16725b92009-10-06 11:31:07 -07007#include <linux/fs.h>
8#include <linux/inet.h>
9#include <linux/in6.h>
10#include <linux/module.h>
11#include <linux/mount.h>
David Howells82995cc2019-03-25 16:38:32 +000012#include <linux/fs_context.h>
13#include <linux/fs_parser.h>
Sage Weil16725b92009-10-06 11:31:07 -070014#include <linux/sched.h>
15#include <linux/seq_file.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090016#include <linux/slab.h>
Sage Weil16725b92009-10-06 11:31:07 -070017#include <linux/statfs.h>
18#include <linux/string.h>
Sage Weil16725b92009-10-06 11:31:07 -070019
Sage Weil16725b92009-10-06 11:31:07 -070020#include "super.h"
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -070021#include "mds_client.h"
Milosz Tanski99ccbd22013-08-21 17:29:54 -040022#include "cache.h"
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -070023
Sage Weil1fe60e52012-07-30 16:23:22 -070024#include <linux/ceph/ceph_features.h>
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -070025#include <linux/ceph/decode.h>
26#include <linux/ceph/mon_client.h>
27#include <linux/ceph/auth.h>
28#include <linux/ceph/debugfs.h>
Sage Weil16725b92009-10-06 11:31:07 -070029
Xiubo Li18f473b2020-07-16 10:05:57 -040030static DEFINE_SPINLOCK(ceph_fsc_lock);
31static LIST_HEAD(ceph_fsc_list);
32
Sage Weil16725b92009-10-06 11:31:07 -070033/*
34 * Ceph superblock operations
35 *
36 * Handle the basics of mounting, unmounting.
37 */
38
Sage Weil16725b92009-10-06 11:31:07 -070039/*
40 * super ops
41 */
42static void ceph_put_super(struct super_block *s)
43{
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -070044 struct ceph_fs_client *fsc = ceph_sb_to_client(s);
Sage Weil16725b92009-10-06 11:31:07 -070045
46 dout("put_super\n");
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -070047 ceph_mdsc_close_sessions(fsc->mdsc);
Sage Weil16725b92009-10-06 11:31:07 -070048}
49
50static int ceph_statfs(struct dentry *dentry, struct kstatfs *buf)
51{
David Howells2b0143b2015-03-17 22:25:59 +000052 struct ceph_fs_client *fsc = ceph_inode_to_client(d_inode(dentry));
Luis Henriques73fb0942018-05-28 18:37:40 +010053 struct ceph_mon_client *monc = &fsc->client->monc;
Sage Weil16725b92009-10-06 11:31:07 -070054 struct ceph_statfs st;
55 u64 fsid;
56 int err;
Douglas Fuller06d74372017-08-16 10:19:27 -040057 u64 data_pool;
58
59 if (fsc->mdsc->mdsmap->m_num_data_pg_pools == 1) {
60 data_pool = fsc->mdsc->mdsmap->m_data_pg_pools[0];
61 } else {
62 data_pool = CEPH_NOPOOL;
63 }
Sage Weil16725b92009-10-06 11:31:07 -070064
65 dout("statfs\n");
Luis Henriques73fb0942018-05-28 18:37:40 +010066 err = ceph_monc_do_statfs(monc, data_pool, &st);
Sage Weil16725b92009-10-06 11:31:07 -070067 if (err < 0)
68 return err;
69
70 /* fill in kstatfs */
71 buf->f_type = CEPH_SUPER_MAGIC; /* ?? */
72
73 /*
74 * express utilization in terms of large blocks to avoid
75 * overflow on 32-bit machines.
Sage Weil92a49fb2013-02-22 15:31:00 -080076 *
77 * NOTE: for the time being, we make bsize == frsize to humor
78 * not-yet-ancient versions of glibc that are broken.
79 * Someday, we will probably want to report a real block
80 * size... whatever that may mean for a network file system!
Sage Weil16725b92009-10-06 11:31:07 -070081 */
82 buf->f_bsize = 1 << CEPH_BLOCK_SHIFT;
Sage Weil92a49fb2013-02-22 15:31:00 -080083 buf->f_frsize = 1 << CEPH_BLOCK_SHIFT;
Luis Henriques9122eed2018-01-31 10:53:13 +000084
85 /*
86 * By default use root quota for stats; fallback to overall filesystem
87 * usage if using 'noquotadf' mount option or if the root dir doesn't
88 * have max_bytes quota set.
89 */
90 if (ceph_test_mount_opt(fsc, NOQUOTADF) ||
91 !ceph_quota_update_statfs(fsc, buf)) {
92 buf->f_blocks = le64_to_cpu(st.kb) >> (CEPH_BLOCK_SHIFT-10);
93 buf->f_bfree = le64_to_cpu(st.kb_avail) >> (CEPH_BLOCK_SHIFT-10);
94 buf->f_bavail = le64_to_cpu(st.kb_avail) >> (CEPH_BLOCK_SHIFT-10);
95 }
Sage Weil16725b92009-10-06 11:31:07 -070096
97 buf->f_files = le64_to_cpu(st.num_objects);
98 buf->f_ffree = -1;
Sage Weil558d3492010-06-01 12:51:12 -070099 buf->f_namelen = NAME_MAX;
Sage Weil16725b92009-10-06 11:31:07 -0700100
Jeff Layton080a3302017-10-23 10:58:40 -0400101 /* Must convert the fsid, for consistent values across arches */
Luis Henriques73fb0942018-05-28 18:37:40 +0100102 mutex_lock(&monc->mutex);
103 fsid = le64_to_cpu(*(__le64 *)(&monc->monmap->fsid)) ^
104 le64_to_cpu(*((__le64 *)&monc->monmap->fsid + 1));
105 mutex_unlock(&monc->mutex);
106
Sage Weil16725b92009-10-06 11:31:07 -0700107 buf->f_fsid.val[0] = fsid & 0xffffffff;
108 buf->f_fsid.val[1] = fsid >> 32;
109
110 return 0;
111}
112
Sage Weil2d9c98a2010-07-30 09:38:13 -0700113static int ceph_sync_fs(struct super_block *sb, int wait)
Sage Weil16725b92009-10-06 11:31:07 -0700114{
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700115 struct ceph_fs_client *fsc = ceph_sb_to_client(sb);
Sage Weil2d9c98a2010-07-30 09:38:13 -0700116
117 if (!wait) {
118 dout("sync_fs (non-blocking)\n");
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700119 ceph_flush_dirty_caps(fsc->mdsc);
Sage Weil2d9c98a2010-07-30 09:38:13 -0700120 dout("sync_fs (non-blocking) done\n");
121 return 0;
122 }
123
124 dout("sync_fs (blocking)\n");
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700125 ceph_osdc_sync(&fsc->client->osdc);
126 ceph_mdsc_sync(fsc->mdsc);
Sage Weil2d9c98a2010-07-30 09:38:13 -0700127 dout("sync_fs (blocking) done\n");
Sage Weil16725b92009-10-06 11:31:07 -0700128 return 0;
129}
130
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700131/*
132 * mount options
133 */
134enum {
135 Opt_wsize,
136 Opt_rsize,
Sage Weil83817e32011-08-04 08:03:44 -0700137 Opt_rasize,
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700138 Opt_caps_wanted_delay_min,
139 Opt_caps_wanted_delay_max,
Yan, Zhengfe330322019-02-01 14:57:15 +0800140 Opt_caps_max,
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700141 Opt_readdir_max_entries,
142 Opt_readdir_max_bytes,
143 Opt_congestion_kb,
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700144 /* int args above */
145 Opt_snapdirname,
Yan, Zheng430afba2016-07-08 11:25:38 +0800146 Opt_mds_namespace,
Yan, Zheng131d7eb2019-07-25 20:16:47 +0800147 Opt_recover_session,
David Howells82995cc2019-03-25 16:38:32 +0000148 Opt_source,
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700149 /* string args above */
150 Opt_dirstat,
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700151 Opt_rbytes,
Alex Eldercffaba12012-02-15 07:43:54 -0600152 Opt_asyncreaddir,
Sage Weila40dc6c2012-01-10 09:12:55 -0800153 Opt_dcache,
Yehuda Sadehad1fee92011-01-21 16:44:03 -0800154 Opt_ino32,
Milosz Tanski99ccbd22013-08-21 17:29:54 -0400155 Opt_fscache,
Yan, Zheng10183a62015-04-27 15:33:28 +0800156 Opt_poolperm,
Yan, Zhenge9e427f2016-11-10 16:02:06 +0800157 Opt_require_active_mds,
Sage Weil45195e42014-02-16 10:05:29 -0800158 Opt_acl,
Luis Henriques9122eed2018-01-31 10:53:13 +0000159 Opt_quotadf,
Luis Henriquesea4cdc52018-10-15 16:46:00 +0100160 Opt_copyfrom,
Jeff Layton2ccb4542019-04-02 15:35:56 -0400161 Opt_wsync,
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700162};
163
David Howells82995cc2019-03-25 16:38:32 +0000164enum ceph_recover_session_mode {
165 ceph_recover_session_no,
166 ceph_recover_session_clean
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700167};
168
Al Viro5eede622019-12-16 13:33:32 -0500169static const struct constant_table ceph_param_recover[] = {
Al Viro2710c957a2019-09-06 22:12:08 -0400170 { "no", ceph_recover_session_no },
171 { "clean", ceph_recover_session_clean },
David Howells82995cc2019-03-25 16:38:32 +0000172 {}
173};
174
Al Virod7167b12019-09-07 07:23:15 -0400175static const struct fs_parameter_spec ceph_mount_parameters[] = {
David Howells82995cc2019-03-25 16:38:32 +0000176 fsparam_flag_no ("acl", Opt_acl),
177 fsparam_flag_no ("asyncreaddir", Opt_asyncreaddir),
Jeff Laytonad8c28a2019-09-09 15:58:55 -0400178 fsparam_s32 ("caps_max", Opt_caps_max),
David Howells82995cc2019-03-25 16:38:32 +0000179 fsparam_u32 ("caps_wanted_delay_max", Opt_caps_wanted_delay_max),
180 fsparam_u32 ("caps_wanted_delay_min", Opt_caps_wanted_delay_min),
Jeff Laytonad8c28a2019-09-09 15:58:55 -0400181 fsparam_u32 ("write_congestion_kb", Opt_congestion_kb),
David Howells82995cc2019-03-25 16:38:32 +0000182 fsparam_flag_no ("copyfrom", Opt_copyfrom),
183 fsparam_flag_no ("dcache", Opt_dcache),
184 fsparam_flag_no ("dirstat", Opt_dirstat),
Al Viro48ce73b2019-12-17 20:03:59 -0500185 fsparam_flag_no ("fsc", Opt_fscache), // fsc|nofsc
186 fsparam_string ("fsc", Opt_fscache), // fsc=...
David Howells82995cc2019-03-25 16:38:32 +0000187 fsparam_flag_no ("ino32", Opt_ino32),
188 fsparam_string ("mds_namespace", Opt_mds_namespace),
189 fsparam_flag_no ("poolperm", Opt_poolperm),
190 fsparam_flag_no ("quotadf", Opt_quotadf),
191 fsparam_u32 ("rasize", Opt_rasize),
192 fsparam_flag_no ("rbytes", Opt_rbytes),
Jeff Laytonad8c28a2019-09-09 15:58:55 -0400193 fsparam_u32 ("readdir_max_bytes", Opt_readdir_max_bytes),
194 fsparam_u32 ("readdir_max_entries", Opt_readdir_max_entries),
Al Viro2710c957a2019-09-06 22:12:08 -0400195 fsparam_enum ("recover_session", Opt_recover_session, ceph_param_recover),
David Howells82995cc2019-03-25 16:38:32 +0000196 fsparam_flag_no ("require_active_mds", Opt_require_active_mds),
197 fsparam_u32 ("rsize", Opt_rsize),
198 fsparam_string ("snapdirname", Opt_snapdirname),
199 fsparam_string ("source", Opt_source),
200 fsparam_u32 ("wsize", Opt_wsize),
Jeff Layton2ccb4542019-04-02 15:35:56 -0400201 fsparam_flag_no ("wsync", Opt_wsync),
David Howells82995cc2019-03-25 16:38:32 +0000202 {}
203};
204
David Howells82995cc2019-03-25 16:38:32 +0000205struct ceph_parse_opts_ctx {
206 struct ceph_options *copts;
207 struct ceph_mount_options *opts;
208};
209
210/*
Ilya Dryomovb27a9392020-02-10 22:51:08 +0100211 * Remove adjacent slashes and then the trailing slash, unless it is
212 * the only remaining character.
213 *
214 * E.g. "//dir1////dir2///" --> "/dir1/dir2", "///" --> "/".
215 */
216static void canonicalize_path(char *path)
217{
218 int i, j = 0;
219
220 for (i = 0; path[i] != '\0'; i++) {
221 if (path[i] != '/' || j < 1 || path[j - 1] != '/')
222 path[j++] = path[i];
223 }
224
225 if (j > 1 && path[j - 1] == '/')
226 j--;
227 path[j] = '\0';
228}
229
230/*
David Howells82995cc2019-03-25 16:38:32 +0000231 * Parse the source parameter. Distinguish the server list from the path.
David Howells82995cc2019-03-25 16:38:32 +0000232 *
233 * The source will look like:
234 * <server_spec>[,<server_spec>...]:[<path>]
235 * where
236 * <server_spec> is <ip>[:<port>]
237 * <path> is optional, but if present must begin with '/'
238 */
239static int ceph_parse_source(struct fs_parameter *param, struct fs_context *fc)
Yehuda Sadeh2baba252009-12-18 13:51:57 -0800240{
David Howells82995cc2019-03-25 16:38:32 +0000241 struct ceph_parse_opts_ctx *pctx = fc->fs_private;
242 struct ceph_mount_options *fsopt = pctx->opts;
243 char *dev_name = param->string, *dev_name_end;
244 int ret;
Yehuda Sadeh2baba252009-12-18 13:51:57 -0800245
David Howells82995cc2019-03-25 16:38:32 +0000246 dout("%s '%s'\n", __func__, dev_name);
247 if (!dev_name || !*dev_name)
Al Virod53d0f72019-12-21 21:31:52 -0500248 return invalfc(fc, "Empty source");
Yehuda Sadeh2baba252009-12-18 13:51:57 -0800249
David Howells82995cc2019-03-25 16:38:32 +0000250 dev_name_end = strchr(dev_name, '/');
251 if (dev_name_end) {
Xiubo Li4fbc0c72019-12-20 09:34:04 -0500252 /*
253 * The server_path will include the whole chars from userland
254 * including the leading '/'.
255 */
Ilya Dryomovb27a9392020-02-10 22:51:08 +0100256 kfree(fsopt->server_path);
Xiubo Li4fbc0c72019-12-20 09:34:04 -0500257 fsopt->server_path = kstrdup(dev_name_end, GFP_KERNEL);
258 if (!fsopt->server_path)
259 return -ENOMEM;
Ilya Dryomovb27a9392020-02-10 22:51:08 +0100260
261 canonicalize_path(fsopt->server_path);
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700262 } else {
David Howells82995cc2019-03-25 16:38:32 +0000263 dev_name_end = dev_name + strlen(dev_name);
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700264 }
265
David Howells82995cc2019-03-25 16:38:32 +0000266 dev_name_end--; /* back up to ':' separator */
267 if (dev_name_end < dev_name || *dev_name_end != ':')
Al Virod53d0f72019-12-21 21:31:52 -0500268 return invalfc(fc, "No path or : separator in source");
David Howells82995cc2019-03-25 16:38:32 +0000269
270 dout("device name '%.*s'\n", (int)(dev_name_end - dev_name), dev_name);
271 if (fsopt->server_path)
272 dout("server path '%s'\n", fsopt->server_path);
273
274 ret = ceph_parse_mon_ips(param->string, dev_name_end - dev_name,
Al Virocc3c0b52019-12-21 00:16:49 -0500275 pctx->copts, fc->log.log);
David Howells82995cc2019-03-25 16:38:32 +0000276 if (ret)
277 return ret;
278
279 fc->source = param->string;
280 param->string = NULL;
281 return 0;
282}
283
284static int ceph_parse_mount_param(struct fs_context *fc,
285 struct fs_parameter *param)
286{
287 struct ceph_parse_opts_ctx *pctx = fc->fs_private;
288 struct ceph_mount_options *fsopt = pctx->opts;
289 struct fs_parse_result result;
290 unsigned int mode;
291 int token, ret;
292
Al Virocc3c0b52019-12-21 00:16:49 -0500293 ret = ceph_parse_param(param, pctx->copts, fc->log.log);
David Howells82995cc2019-03-25 16:38:32 +0000294 if (ret != -ENOPARAM)
295 return ret;
296
Al Virod7167b12019-09-07 07:23:15 -0400297 token = fs_parse(fc, ceph_mount_parameters, param, &result);
David Howells82995cc2019-03-25 16:38:32 +0000298 dout("%s fs_parse '%s' token %d\n", __func__, param->key, token);
299 if (token < 0)
300 return token;
301
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700302 switch (token) {
303 case Opt_snapdirname:
304 kfree(fsopt->snapdir_name);
David Howells82995cc2019-03-25 16:38:32 +0000305 fsopt->snapdir_name = param->string;
306 param->string = NULL;
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700307 break;
Yan, Zheng235a0982016-03-30 17:18:34 +0800308 case Opt_mds_namespace:
Chengguang Xu937441f2018-02-06 08:25:55 +0800309 kfree(fsopt->mds_namespace);
David Howells82995cc2019-03-25 16:38:32 +0000310 fsopt->mds_namespace = param->string;
311 param->string = NULL;
Yan, Zheng235a0982016-03-30 17:18:34 +0800312 break;
Yan, Zheng131d7eb2019-07-25 20:16:47 +0800313 case Opt_recover_session:
David Howells82995cc2019-03-25 16:38:32 +0000314 mode = result.uint_32;
315 if (mode == ceph_recover_session_no)
Yan, Zheng131d7eb2019-07-25 20:16:47 +0800316 fsopt->flags &= ~CEPH_MOUNT_OPT_CLEANRECOVER;
David Howells82995cc2019-03-25 16:38:32 +0000317 else if (mode == ceph_recover_session_clean)
Yan, Zheng131d7eb2019-07-25 20:16:47 +0800318 fsopt->flags |= CEPH_MOUNT_OPT_CLEANRECOVER;
David Howells82995cc2019-03-25 16:38:32 +0000319 else
320 BUG();
Yan, Zheng131d7eb2019-07-25 20:16:47 +0800321 break;
David Howells82995cc2019-03-25 16:38:32 +0000322 case Opt_source:
323 if (fc->source)
Al Virod53d0f72019-12-21 21:31:52 -0500324 return invalfc(fc, "Multiple sources specified");
David Howells82995cc2019-03-25 16:38:32 +0000325 return ceph_parse_source(param, fc);
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700326 case Opt_wsize:
David Howells82995cc2019-03-25 16:38:32 +0000327 if (result.uint_32 < PAGE_SIZE ||
328 result.uint_32 > CEPH_MAX_WRITE_SIZE)
329 goto out_of_range;
330 fsopt->wsize = ALIGN(result.uint_32, PAGE_SIZE);
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700331 break;
332 case Opt_rsize:
David Howells82995cc2019-03-25 16:38:32 +0000333 if (result.uint_32 < PAGE_SIZE ||
334 result.uint_32 > CEPH_MAX_READ_SIZE)
335 goto out_of_range;
336 fsopt->rsize = ALIGN(result.uint_32, PAGE_SIZE);
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700337 break;
Sage Weil83817e32011-08-04 08:03:44 -0700338 case Opt_rasize:
David Howells82995cc2019-03-25 16:38:32 +0000339 fsopt->rasize = ALIGN(result.uint_32, PAGE_SIZE);
Sage Weil83817e32011-08-04 08:03:44 -0700340 break;
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700341 case Opt_caps_wanted_delay_min:
David Howells82995cc2019-03-25 16:38:32 +0000342 if (result.uint_32 < 1)
343 goto out_of_range;
344 fsopt->caps_wanted_delay_min = result.uint_32;
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700345 break;
346 case Opt_caps_wanted_delay_max:
David Howells82995cc2019-03-25 16:38:32 +0000347 if (result.uint_32 < 1)
348 goto out_of_range;
349 fsopt->caps_wanted_delay_max = result.uint_32;
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700350 break;
Yan, Zhengfe330322019-02-01 14:57:15 +0800351 case Opt_caps_max:
Jeff Laytonad8c28a2019-09-09 15:58:55 -0400352 if (result.int_32 < 0)
353 goto out_of_range;
354 fsopt->caps_max = result.int_32;
Yan, Zhengfe330322019-02-01 14:57:15 +0800355 break;
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700356 case Opt_readdir_max_entries:
David Howells82995cc2019-03-25 16:38:32 +0000357 if (result.uint_32 < 1)
358 goto out_of_range;
359 fsopt->max_readdir = result.uint_32;
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700360 break;
361 case Opt_readdir_max_bytes:
David Howells82995cc2019-03-25 16:38:32 +0000362 if (result.uint_32 < PAGE_SIZE && result.uint_32 != 0)
363 goto out_of_range;
364 fsopt->max_readdir_bytes = result.uint_32;
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700365 break;
366 case Opt_congestion_kb:
David Howells82995cc2019-03-25 16:38:32 +0000367 if (result.uint_32 < 1024) /* at least 1M */
368 goto out_of_range;
369 fsopt->congestion_kb = result.uint_32;
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700370 break;
371 case Opt_dirstat:
David Howells82995cc2019-03-25 16:38:32 +0000372 if (!result.negated)
373 fsopt->flags |= CEPH_MOUNT_OPT_DIRSTAT;
374 else
375 fsopt->flags &= ~CEPH_MOUNT_OPT_DIRSTAT;
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700376 break;
377 case Opt_rbytes:
David Howells82995cc2019-03-25 16:38:32 +0000378 if (!result.negated)
379 fsopt->flags |= CEPH_MOUNT_OPT_RBYTES;
380 else
381 fsopt->flags &= ~CEPH_MOUNT_OPT_RBYTES;
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700382 break;
Alex Eldercffaba12012-02-15 07:43:54 -0600383 case Opt_asyncreaddir:
David Howells82995cc2019-03-25 16:38:32 +0000384 if (!result.negated)
385 fsopt->flags &= ~CEPH_MOUNT_OPT_NOASYNCREADDIR;
386 else
387 fsopt->flags |= CEPH_MOUNT_OPT_NOASYNCREADDIR;
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700388 break;
Sage Weila40dc6c2012-01-10 09:12:55 -0800389 case Opt_dcache:
David Howells82995cc2019-03-25 16:38:32 +0000390 if (!result.negated)
391 fsopt->flags |= CEPH_MOUNT_OPT_DCACHE;
392 else
393 fsopt->flags &= ~CEPH_MOUNT_OPT_DCACHE;
Sage Weila40dc6c2012-01-10 09:12:55 -0800394 break;
Yehuda Sadehad1fee92011-01-21 16:44:03 -0800395 case Opt_ino32:
David Howells82995cc2019-03-25 16:38:32 +0000396 if (!result.negated)
397 fsopt->flags |= CEPH_MOUNT_OPT_INO32;
398 else
399 fsopt->flags &= ~CEPH_MOUNT_OPT_INO32;
Yehuda Sadehad1fee92011-01-21 16:44:03 -0800400 break;
David Howells82995cc2019-03-25 16:38:32 +0000401
Milosz Tanski99ccbd22013-08-21 17:29:54 -0400402 case Opt_fscache:
Jeff Laytonff29fde2019-11-07 09:39:32 -0500403#ifdef CONFIG_CEPH_FSCACHE
Chengguang Xu7ae7a822018-02-07 10:27:06 +0800404 kfree(fsopt->fscache_uniq);
405 fsopt->fscache_uniq = NULL;
David Howells82995cc2019-03-25 16:38:32 +0000406 if (result.negated) {
407 fsopt->flags &= ~CEPH_MOUNT_OPT_FSCACHE;
408 } else {
409 fsopt->flags |= CEPH_MOUNT_OPT_FSCACHE;
410 fsopt->fscache_uniq = param->string;
411 param->string = NULL;
412 }
Milosz Tanski99ccbd22013-08-21 17:29:54 -0400413 break;
Jeff Laytonff29fde2019-11-07 09:39:32 -0500414#else
Al Virod53d0f72019-12-21 21:31:52 -0500415 return invalfc(fc, "fscache support is disabled");
Jeff Laytonff29fde2019-11-07 09:39:32 -0500416#endif
Yan, Zheng10183a62015-04-27 15:33:28 +0800417 case Opt_poolperm:
David Howells82995cc2019-03-25 16:38:32 +0000418 if (!result.negated)
419 fsopt->flags &= ~CEPH_MOUNT_OPT_NOPOOLPERM;
420 else
421 fsopt->flags |= CEPH_MOUNT_OPT_NOPOOLPERM;
Yan, Zheng10183a62015-04-27 15:33:28 +0800422 break;
Yan, Zhenge9e427f2016-11-10 16:02:06 +0800423 case Opt_require_active_mds:
David Howells82995cc2019-03-25 16:38:32 +0000424 if (!result.negated)
425 fsopt->flags &= ~CEPH_MOUNT_OPT_MOUNTWAIT;
426 else
427 fsopt->flags |= CEPH_MOUNT_OPT_MOUNTWAIT;
Yan, Zhenge9e427f2016-11-10 16:02:06 +0800428 break;
Luis Henriques9122eed2018-01-31 10:53:13 +0000429 case Opt_quotadf:
David Howells82995cc2019-03-25 16:38:32 +0000430 if (!result.negated)
431 fsopt->flags &= ~CEPH_MOUNT_OPT_NOQUOTADF;
432 else
433 fsopt->flags |= CEPH_MOUNT_OPT_NOQUOTADF;
Luis Henriques9122eed2018-01-31 10:53:13 +0000434 break;
Luis Henriquesea4cdc52018-10-15 16:46:00 +0100435 case Opt_copyfrom:
David Howells82995cc2019-03-25 16:38:32 +0000436 if (!result.negated)
437 fsopt->flags &= ~CEPH_MOUNT_OPT_NOCOPYFROM;
438 else
439 fsopt->flags |= CEPH_MOUNT_OPT_NOCOPYFROM;
Luis Henriquesea4cdc52018-10-15 16:46:00 +0100440 break;
Sage Weil45195e42014-02-16 10:05:29 -0800441 case Opt_acl:
David Howells82995cc2019-03-25 16:38:32 +0000442 if (!result.negated) {
443#ifdef CONFIG_CEPH_FS_POSIX_ACL
444 fc->sb_flags |= SB_POSIXACL;
445#else
Al Virod53d0f72019-12-21 21:31:52 -0500446 return invalfc(fc, "POSIX ACL support is disabled");
Sage Weil45195e42014-02-16 10:05:29 -0800447#endif
David Howells82995cc2019-03-25 16:38:32 +0000448 } else {
449 fc->sb_flags &= ~SB_POSIXACL;
450 }
Sage Weil45195e42014-02-16 10:05:29 -0800451 break;
Jeff Layton2ccb4542019-04-02 15:35:56 -0400452 case Opt_wsync:
453 if (!result.negated)
454 fsopt->flags &= ~CEPH_MOUNT_OPT_ASYNC_DIROPS;
455 else
456 fsopt->flags |= CEPH_MOUNT_OPT_ASYNC_DIROPS;
457 break;
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700458 default:
David Howells82995cc2019-03-25 16:38:32 +0000459 BUG();
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700460 }
461 return 0;
David Howells82995cc2019-03-25 16:38:32 +0000462
463out_of_range:
Al Virod53d0f72019-12-21 21:31:52 -0500464 return invalfc(fc, "%s out of range", param->key);
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700465}
466
467static void destroy_mount_options(struct ceph_mount_options *args)
468{
469 dout("destroy_mount_options %p\n", args);
David Howells82995cc2019-03-25 16:38:32 +0000470 if (!args)
471 return;
472
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700473 kfree(args->snapdir_name);
Yan, Zheng430afba2016-07-08 11:25:38 +0800474 kfree(args->mds_namespace);
Yan, Zheng3f384952016-04-21 11:09:55 +0800475 kfree(args->server_path);
Yan, Zheng1d8f8362017-06-27 11:57:56 +0800476 kfree(args->fscache_uniq);
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700477 kfree(args);
478}
479
480static int strcmp_null(const char *s1, const char *s2)
481{
482 if (!s1 && !s2)
483 return 0;
484 if (s1 && !s2)
485 return -1;
486 if (!s1 && s2)
487 return 1;
488 return strcmp(s1, s2);
489}
490
491static int compare_mount_options(struct ceph_mount_options *new_fsopt,
492 struct ceph_options *new_opt,
493 struct ceph_fs_client *fsc)
494{
495 struct ceph_mount_options *fsopt1 = new_fsopt;
496 struct ceph_mount_options *fsopt2 = fsc->mount_options;
497 int ofs = offsetof(struct ceph_mount_options, snapdir_name);
498 int ret;
499
500 ret = memcmp(fsopt1, fsopt2, ofs);
501 if (ret)
502 return ret;
503
504 ret = strcmp_null(fsopt1->snapdir_name, fsopt2->snapdir_name);
505 if (ret)
506 return ret;
Ilya Dryomovb27a9392020-02-10 22:51:08 +0100507
Yan, Zheng430afba2016-07-08 11:25:38 +0800508 ret = strcmp_null(fsopt1->mds_namespace, fsopt2->mds_namespace);
509 if (ret)
510 return ret;
Xiubo Li4fbc0c72019-12-20 09:34:04 -0500511
Ilya Dryomovb27a9392020-02-10 22:51:08 +0100512 ret = strcmp_null(fsopt1->server_path, fsopt2->server_path);
Yan, Zheng3f384952016-04-21 11:09:55 +0800513 if (ret)
514 return ret;
Xiubo Li4fbc0c72019-12-20 09:34:04 -0500515
Yan, Zheng1d8f8362017-06-27 11:57:56 +0800516 ret = strcmp_null(fsopt1->fscache_uniq, fsopt2->fscache_uniq);
517 if (ret)
518 return ret;
Yan, Zheng3f384952016-04-21 11:09:55 +0800519
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700520 return ceph_compare_options(new_opt, fsc->client);
521}
522
Sage Weil6e19a162010-04-29 16:38:32 -0700523/**
524 * ceph_show_options - Show mount options in /proc/mounts
525 * @m: seq_file to write to
Al Viro34c80b12011-12-08 21:32:45 -0500526 * @root: root of that (sub)tree
Sage Weil6e19a162010-04-29 16:38:32 -0700527 */
Al Viro34c80b12011-12-08 21:32:45 -0500528static int ceph_show_options(struct seq_file *m, struct dentry *root)
Sage Weil6e19a162010-04-29 16:38:32 -0700529{
Al Viro34c80b12011-12-08 21:32:45 -0500530 struct ceph_fs_client *fsc = ceph_sb_to_client(root->d_sb);
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700531 struct ceph_mount_options *fsopt = fsc->mount_options;
Ilya Dryomovff40f9a2015-03-25 21:02:16 +0300532 size_t pos;
533 int ret;
Sage Weil6e19a162010-04-29 16:38:32 -0700534
Ilya Dryomovff40f9a2015-03-25 21:02:16 +0300535 /* a comma between MNT/MS and client options */
536 seq_putc(m, ',');
537 pos = m->count;
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700538
Dongsheng Yang02b2f542018-12-18 04:31:48 -0500539 ret = ceph_print_client_options(m, fsc->client, false);
Ilya Dryomovff40f9a2015-03-25 21:02:16 +0300540 if (ret)
541 return ret;
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700542
Ilya Dryomovff40f9a2015-03-25 21:02:16 +0300543 /* retract our comma if no client options */
544 if (m->count == pos)
545 m->count--;
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700546
547 if (fsopt->flags & CEPH_MOUNT_OPT_DIRSTAT)
548 seq_puts(m, ",dirstat");
Yan, Zheng133e9152016-01-25 10:44:33 +0800549 if ((fsopt->flags & CEPH_MOUNT_OPT_RBYTES))
550 seq_puts(m, ",rbytes");
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700551 if (fsopt->flags & CEPH_MOUNT_OPT_NOASYNCREADDIR)
Sage Weil6e19a162010-04-29 16:38:32 -0700552 seq_puts(m, ",noasyncreaddir");
Ilya Dryomovff7eeb82015-03-25 21:10:09 +0300553 if ((fsopt->flags & CEPH_MOUNT_OPT_DCACHE) == 0)
Sage Weila40dc6c2012-01-10 09:12:55 -0800554 seq_puts(m, ",nodcache");
Chengguang Xu3619aa82018-06-04 16:03:51 +0800555 if (fsopt->flags & CEPH_MOUNT_OPT_INO32)
556 seq_puts(m, ",ino32");
Yan, Zheng1d8f8362017-06-27 11:57:56 +0800557 if (fsopt->flags & CEPH_MOUNT_OPT_FSCACHE) {
Chengguang Xu4d8969a2018-02-15 15:39:05 +0800558 seq_show_option(m, "fsc", fsopt->fscache_uniq);
Yan, Zheng1d8f8362017-06-27 11:57:56 +0800559 }
Yan, Zheng10183a62015-04-27 15:33:28 +0800560 if (fsopt->flags & CEPH_MOUNT_OPT_NOPOOLPERM)
561 seq_puts(m, ",nopoolperm");
Luis Henriques9122eed2018-01-31 10:53:13 +0000562 if (fsopt->flags & CEPH_MOUNT_OPT_NOQUOTADF)
563 seq_puts(m, ",noquotadf");
Sage Weil6e19a162010-04-29 16:38:32 -0700564
Sage Weil45195e42014-02-16 10:05:29 -0800565#ifdef CONFIG_CEPH_FS_POSIX_ACL
David Howells82995cc2019-03-25 16:38:32 +0000566 if (root->d_sb->s_flags & SB_POSIXACL)
Sage Weil45195e42014-02-16 10:05:29 -0800567 seq_puts(m, ",acl");
568 else
569 seq_puts(m, ",noacl");
570#endif
571
Luis Henriques6f9718f2018-12-10 10:23:12 +0000572 if ((fsopt->flags & CEPH_MOUNT_OPT_NOCOPYFROM) == 0)
573 seq_puts(m, ",copyfrom");
Luis Henriquesea4cdc52018-10-15 16:46:00 +0100574
Yan, Zheng430afba2016-07-08 11:25:38 +0800575 if (fsopt->mds_namespace)
Chengguang Xu4d8969a2018-02-15 15:39:05 +0800576 seq_show_option(m, "mds_namespace", fsopt->mds_namespace);
Yan, Zheng131d7eb2019-07-25 20:16:47 +0800577
578 if (fsopt->flags & CEPH_MOUNT_OPT_CLEANRECOVER)
579 seq_show_option(m, "recover_session", "clean");
580
Jeff Layton2ccb4542019-04-02 15:35:56 -0400581 if (fsopt->flags & CEPH_MOUNT_OPT_ASYNC_DIROPS)
582 seq_puts(m, ",nowsync");
583
Ilya Dryomov6dd49402018-05-03 16:26:55 +0200584 if (fsopt->wsize != CEPH_MAX_WRITE_SIZE)
Jeff Laytonad8c28a2019-09-09 15:58:55 -0400585 seq_printf(m, ",wsize=%u", fsopt->wsize);
Yan, Zhengaa187922017-07-11 15:56:09 +0800586 if (fsopt->rsize != CEPH_MAX_READ_SIZE)
Jeff Laytonad8c28a2019-09-09 15:58:55 -0400587 seq_printf(m, ",rsize=%u", fsopt->rsize);
Sage Weil83817e32011-08-04 08:03:44 -0700588 if (fsopt->rasize != CEPH_RASIZE_DEFAULT)
Jeff Laytonad8c28a2019-09-09 15:58:55 -0400589 seq_printf(m, ",rasize=%u", fsopt->rasize);
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700590 if (fsopt->congestion_kb != default_congestion_kb())
Jeff Laytonad8c28a2019-09-09 15:58:55 -0400591 seq_printf(m, ",write_congestion_kb=%u", fsopt->congestion_kb);
Yan, Zhengfe330322019-02-01 14:57:15 +0800592 if (fsopt->caps_max)
593 seq_printf(m, ",caps_max=%d", fsopt->caps_max);
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700594 if (fsopt->caps_wanted_delay_min != CEPH_CAPS_WANTED_DELAY_MIN_DEFAULT)
Jeff Laytonad8c28a2019-09-09 15:58:55 -0400595 seq_printf(m, ",caps_wanted_delay_min=%u",
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700596 fsopt->caps_wanted_delay_min);
597 if (fsopt->caps_wanted_delay_max != CEPH_CAPS_WANTED_DELAY_MAX_DEFAULT)
Jeff Laytonad8c28a2019-09-09 15:58:55 -0400598 seq_printf(m, ",caps_wanted_delay_max=%u",
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700599 fsopt->caps_wanted_delay_max);
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700600 if (fsopt->max_readdir != CEPH_MAX_READDIR_DEFAULT)
Jeff Laytonad8c28a2019-09-09 15:58:55 -0400601 seq_printf(m, ",readdir_max_entries=%u", fsopt->max_readdir);
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700602 if (fsopt->max_readdir_bytes != CEPH_MAX_READDIR_BYTES_DEFAULT)
Jeff Laytonad8c28a2019-09-09 15:58:55 -0400603 seq_printf(m, ",readdir_max_bytes=%u", fsopt->max_readdir_bytes);
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700604 if (strcmp(fsopt->snapdir_name, CEPH_SNAPDIRNAME_DEFAULT))
Kees Cooka068acf2015-09-04 15:44:57 -0700605 seq_show_option(m, "snapdirname", fsopt->snapdir_name);
Ilya Dryomovff40f9a2015-03-25 21:02:16 +0300606
Sage Weil6e19a162010-04-29 16:38:32 -0700607 return 0;
608}
609
610/*
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700611 * handle any mon messages the standard library doesn't understand.
612 * return error if we don't either.
613 */
614static int extra_mon_dispatch(struct ceph_client *client, struct ceph_msg *msg)
615{
616 struct ceph_fs_client *fsc = client->private;
617 int type = le16_to_cpu(msg->hdr.type);
618
619 switch (type) {
620 case CEPH_MSG_MDS_MAP:
Yan, Zheng430afba2016-07-08 11:25:38 +0800621 ceph_mdsc_handle_mdsmap(fsc->mdsc, msg);
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700622 return 0;
Yan, Zheng430afba2016-07-08 11:25:38 +0800623 case CEPH_MSG_FS_MAP_USER:
624 ceph_mdsc_handle_fsmap(fsc->mdsc, msg);
625 return 0;
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700626 default:
627 return -1;
628 }
629}
630
631/*
632 * create a new fs client
Ilya Dryomov8aaff152018-08-24 15:32:43 +0200633 *
634 * Success or not, this function consumes @fsopt and @opt.
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700635 */
H Hartley Sweeten0c6d4b4e22011-09-23 11:53:30 -0700636static struct ceph_fs_client *create_fs_client(struct ceph_mount_options *fsopt,
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700637 struct ceph_options *opt)
638{
639 struct ceph_fs_client *fsc;
Ilya Dryomov8aaff152018-08-24 15:32:43 +0200640 int err;
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700641
642 fsc = kzalloc(sizeof(*fsc), GFP_KERNEL);
Ilya Dryomov8aaff152018-08-24 15:32:43 +0200643 if (!fsc) {
644 err = -ENOMEM;
645 goto fail;
646 }
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700647
Ilya Dryomov74da4a0f2017-03-03 18:16:07 +0100648 fsc->client = ceph_create_client(opt, fsc);
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700649 if (IS_ERR(fsc->client)) {
650 err = PTR_ERR(fsc->client);
651 goto fail;
652 }
Ilya Dryomov8aaff152018-08-24 15:32:43 +0200653 opt = NULL; /* fsc->client now owns this */
Ilya Dryomovc843d132018-05-30 16:29:14 +0200654
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700655 fsc->client->extra_mon_dispatch = extra_mon_dispatch;
Dongsheng Yang02b2f542018-12-18 04:31:48 -0500656 ceph_set_opt(fsc->client, ABORT_ON_FULL);
Yan, Zheng430afba2016-07-08 11:25:38 +0800657
Markus Elfringd37b1d92017-08-20 20:22:02 +0200658 if (!fsopt->mds_namespace) {
Yan, Zheng430afba2016-07-08 11:25:38 +0800659 ceph_monc_want_map(&fsc->client->monc, CEPH_SUB_MDSMAP,
660 0, true);
661 } else {
662 ceph_monc_want_map(&fsc->client->monc, CEPH_SUB_FSMAP,
663 0, false);
664 }
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700665
666 fsc->mount_options = fsopt;
667
668 fsc->sb = NULL;
669 fsc->mount_state = CEPH_MOUNT_MOUNTING;
Yan, Zheng81f148a2019-07-25 20:16:46 +0800670 fsc->filp_gen = 1;
Luis Henriques78beb0f2020-01-08 10:03:53 +0000671 fsc->have_copy_from2 = true;
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700672
673 atomic_long_set(&fsc->writeback_count, 0);
674
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700675 err = -ENOMEM;
Tejun Heo01e6acc2011-01-03 14:49:45 +0100676 /*
677 * The number of concurrent works can be high but they don't need
678 * to be processed in parallel, limit concurrency.
679 */
Yan, Zheng1cf89a82019-05-18 11:18:44 +0800680 fsc->inode_wq = alloc_workqueue("ceph-inode", WQ_UNBOUND, 0);
681 if (!fsc->inode_wq)
Jan Kara09dc9fc2017-04-12 12:24:33 +0200682 goto fail_client;
Yan, Zhenge3ec8d62019-01-14 17:21:19 +0800683 fsc->cap_wq = alloc_workqueue("ceph-cap", 0, 1);
684 if (!fsc->cap_wq)
Yan, Zheng1cf89a82019-05-18 11:18:44 +0800685 goto fail_inode_wq;
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700686
Xiubo Li18f473b2020-07-16 10:05:57 -0400687 spin_lock(&ceph_fsc_lock);
688 list_add_tail(&fsc->metric_wakeup, &ceph_fsc_list);
689 spin_unlock(&ceph_fsc_lock);
690
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700691 return fsc;
692
Yan, Zheng1cf89a82019-05-18 11:18:44 +0800693fail_inode_wq:
694 destroy_workqueue(fsc->inode_wq);
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700695fail_client:
696 ceph_destroy_client(fsc->client);
697fail:
698 kfree(fsc);
Ilya Dryomov8aaff152018-08-24 15:32:43 +0200699 if (opt)
700 ceph_destroy_options(opt);
701 destroy_mount_options(fsopt);
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700702 return ERR_PTR(err);
703}
704
Yan, Zhenga57d9062018-05-18 16:05:51 +0800705static void flush_fs_workqueues(struct ceph_fs_client *fsc)
706{
Yan, Zheng1cf89a82019-05-18 11:18:44 +0800707 flush_workqueue(fsc->inode_wq);
Yan, Zhenge3ec8d62019-01-14 17:21:19 +0800708 flush_workqueue(fsc->cap_wq);
Yan, Zhenga57d9062018-05-18 16:05:51 +0800709}
710
H Hartley Sweeten0c6d4b4e22011-09-23 11:53:30 -0700711static void destroy_fs_client(struct ceph_fs_client *fsc)
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700712{
713 dout("destroy_fs_client %p\n", fsc);
714
Xiubo Li18f473b2020-07-16 10:05:57 -0400715 spin_lock(&ceph_fsc_lock);
716 list_del(&fsc->metric_wakeup);
717 spin_unlock(&ceph_fsc_lock);
718
Jeff Layton3ee5a702019-09-12 08:07:56 -0400719 ceph_mdsc_destroy(fsc);
Yan, Zheng1cf89a82019-05-18 11:18:44 +0800720 destroy_workqueue(fsc->inode_wq);
Yan, Zhenge3ec8d62019-01-14 17:21:19 +0800721 destroy_workqueue(fsc->cap_wq);
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700722
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700723 destroy_mount_options(fsc->mount_options);
724
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700725 ceph_destroy_client(fsc->client);
726
727 kfree(fsc);
728 dout("destroy_fs_client %p done\n", fsc);
729}
730
731/*
Sage Weil6e19a162010-04-29 16:38:32 -0700732 * caches
733 */
734struct kmem_cache *ceph_inode_cachep;
735struct kmem_cache *ceph_cap_cachep;
Yan, Zhengf66fd9f2015-06-10 17:26:13 +0800736struct kmem_cache *ceph_cap_flush_cachep;
Sage Weil6e19a162010-04-29 16:38:32 -0700737struct kmem_cache *ceph_dentry_cachep;
738struct kmem_cache *ceph_file_cachep;
Chengguang Xubb48bd42018-03-13 10:42:44 +0800739struct kmem_cache *ceph_dir_file_cachep;
Jeff Layton058daab2020-02-17 18:38:37 -0500740struct kmem_cache *ceph_mds_request_cachep;
Jeff Laytona0102bd2020-07-30 11:03:55 -0400741mempool_t *ceph_wb_pagevec_pool;
Sage Weil6e19a162010-04-29 16:38:32 -0700742
743static void ceph_inode_init_once(void *foo)
744{
745 struct ceph_inode_info *ci = foo;
746 inode_init_once(&ci->vfs_inode);
747}
748
Sage Weil16725b92009-10-06 11:31:07 -0700749static int __init init_caches(void)
750{
Milosz Tanski99ccbd22013-08-21 17:29:54 -0400751 int error = -ENOMEM;
752
Sage Weil16725b92009-10-06 11:31:07 -0700753 ceph_inode_cachep = kmem_cache_create("ceph_inode_info",
754 sizeof(struct ceph_inode_info),
755 __alignof__(struct ceph_inode_info),
Vladimir Davydov5d097052016-01-14 15:18:21 -0800756 SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD|
757 SLAB_ACCOUNT, ceph_inode_init_once);
Markus Elfringd37b1d92017-08-20 20:22:02 +0200758 if (!ceph_inode_cachep)
Sage Weil16725b92009-10-06 11:31:07 -0700759 return -ENOMEM;
760
Chengguang Xubc4b5ad2018-02-27 13:49:44 +0800761 ceph_cap_cachep = KMEM_CACHE(ceph_cap, SLAB_MEM_SPREAD);
Markus Elfringd37b1d92017-08-20 20:22:02 +0200762 if (!ceph_cap_cachep)
Sage Weil16725b92009-10-06 11:31:07 -0700763 goto bad_cap;
Yan, Zhengf66fd9f2015-06-10 17:26:13 +0800764 ceph_cap_flush_cachep = KMEM_CACHE(ceph_cap_flush,
765 SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD);
Markus Elfringd37b1d92017-08-20 20:22:02 +0200766 if (!ceph_cap_flush_cachep)
Yan, Zhengf66fd9f2015-06-10 17:26:13 +0800767 goto bad_cap_flush;
Sage Weil16725b92009-10-06 11:31:07 -0700768
769 ceph_dentry_cachep = KMEM_CACHE(ceph_dentry_info,
770 SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD);
Markus Elfringd37b1d92017-08-20 20:22:02 +0200771 if (!ceph_dentry_cachep)
Sage Weil16725b92009-10-06 11:31:07 -0700772 goto bad_dentry;
773
Nikolay Borisov6b1a9a62016-07-25 20:12:13 +0300774 ceph_file_cachep = KMEM_CACHE(ceph_file_info, SLAB_MEM_SPREAD);
Markus Elfringd37b1d92017-08-20 20:22:02 +0200775 if (!ceph_file_cachep)
Sage Weil16725b92009-10-06 11:31:07 -0700776 goto bad_file;
777
Chengguang Xubb48bd42018-03-13 10:42:44 +0800778 ceph_dir_file_cachep = KMEM_CACHE(ceph_dir_file_info, SLAB_MEM_SPREAD);
779 if (!ceph_dir_file_cachep)
780 goto bad_dir_file;
781
Jeff Layton058daab2020-02-17 18:38:37 -0500782 ceph_mds_request_cachep = KMEM_CACHE(ceph_mds_request, SLAB_MEM_SPREAD);
783 if (!ceph_mds_request_cachep)
784 goto bad_mds_req;
785
Jeff Laytona0102bd2020-07-30 11:03:55 -0400786 ceph_wb_pagevec_pool = mempool_create_kmalloc_pool(10, CEPH_MAX_WRITE_SIZE >> PAGE_SHIFT);
787 if (!ceph_wb_pagevec_pool)
788 goto bad_pagevec_pool;
789
Chengguang Xu1c789242018-03-01 14:24:51 +0800790 error = ceph_fscache_register();
791 if (error)
792 goto bad_fscache;
Sage Weil16725b92009-10-06 11:31:07 -0700793
Milosz Tanski99ccbd22013-08-21 17:29:54 -0400794 return 0;
Chengguang Xu1c789242018-03-01 14:24:51 +0800795
796bad_fscache:
Jeff Layton058daab2020-02-17 18:38:37 -0500797 kmem_cache_destroy(ceph_mds_request_cachep);
Jeff Laytona0102bd2020-07-30 11:03:55 -0400798bad_pagevec_pool:
799 mempool_destroy(ceph_wb_pagevec_pool);
Jeff Layton058daab2020-02-17 18:38:37 -0500800bad_mds_req:
Chengguang Xubb48bd42018-03-13 10:42:44 +0800801 kmem_cache_destroy(ceph_dir_file_cachep);
802bad_dir_file:
Chengguang Xu1c789242018-03-01 14:24:51 +0800803 kmem_cache_destroy(ceph_file_cachep);
Sage Weil16725b92009-10-06 11:31:07 -0700804bad_file:
805 kmem_cache_destroy(ceph_dentry_cachep);
806bad_dentry:
Yan, Zhengf66fd9f2015-06-10 17:26:13 +0800807 kmem_cache_destroy(ceph_cap_flush_cachep);
808bad_cap_flush:
Sage Weil16725b92009-10-06 11:31:07 -0700809 kmem_cache_destroy(ceph_cap_cachep);
810bad_cap:
811 kmem_cache_destroy(ceph_inode_cachep);
Milosz Tanski99ccbd22013-08-21 17:29:54 -0400812 return error;
Sage Weil16725b92009-10-06 11:31:07 -0700813}
814
815static void destroy_caches(void)
816{
Kirill A. Shutemov8c0a8532012-09-26 11:33:07 +1000817 /*
818 * Make sure all delayed rcu free inodes are flushed before we
819 * destroy cache.
820 */
821 rcu_barrier();
Milosz Tanski99ccbd22013-08-21 17:29:54 -0400822
Sage Weil16725b92009-10-06 11:31:07 -0700823 kmem_cache_destroy(ceph_inode_cachep);
824 kmem_cache_destroy(ceph_cap_cachep);
Yan, Zhengf66fd9f2015-06-10 17:26:13 +0800825 kmem_cache_destroy(ceph_cap_flush_cachep);
Sage Weil16725b92009-10-06 11:31:07 -0700826 kmem_cache_destroy(ceph_dentry_cachep);
827 kmem_cache_destroy(ceph_file_cachep);
Chengguang Xubb48bd42018-03-13 10:42:44 +0800828 kmem_cache_destroy(ceph_dir_file_cachep);
Jeff Layton058daab2020-02-17 18:38:37 -0500829 kmem_cache_destroy(ceph_mds_request_cachep);
Jeff Laytona0102bd2020-07-30 11:03:55 -0400830 mempool_destroy(ceph_wb_pagevec_pool);
Milosz Tanski99ccbd22013-08-21 17:29:54 -0400831
832 ceph_fscache_unregister();
Sage Weil16725b92009-10-06 11:31:07 -0700833}
834
Sage Weil16725b92009-10-06 11:31:07 -0700835/*
Randy Dunlapf1f565a2020-07-17 16:36:04 -0700836 * ceph_umount_begin - initiate forced umount. Tear down the
Sage Weil16725b92009-10-06 11:31:07 -0700837 * mount, skipping steps that may hang while waiting for server(s).
838 */
839static void ceph_umount_begin(struct super_block *sb)
840{
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700841 struct ceph_fs_client *fsc = ceph_sb_to_client(sb);
Sage Weil16725b92009-10-06 11:31:07 -0700842
843 dout("ceph_umount_begin - starting forced umount\n");
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700844 if (!fsc)
Sage Weil16725b92009-10-06 11:31:07 -0700845 return;
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700846 fsc->mount_state = CEPH_MOUNT_SHUTDOWN;
Yan, Zheng12b69d52018-05-11 17:12:02 +0800847 ceph_osdc_abort_requests(&fsc->client->osdc, -EIO);
Yan, Zheng48fec5d2015-07-01 16:27:46 +0800848 ceph_mdsc_force_umount(fsc->mdsc);
Yan, Zheng81f148a2019-07-25 20:16:46 +0800849 fsc->filp_gen++; // invalidate open files
Sage Weil16725b92009-10-06 11:31:07 -0700850}
851
852static const struct super_operations ceph_super_ops = {
853 .alloc_inode = ceph_alloc_inode,
Al Virocfa6d412019-04-10 15:18:50 -0400854 .free_inode = ceph_free_inode,
Sage Weil16725b92009-10-06 11:31:07 -0700855 .write_inode = ceph_write_inode,
Luis Henriques52dd0f12019-07-05 17:14:56 +0100856 .drop_inode = generic_delete_inode,
Yan, Zheng87bc5b82019-06-02 09:45:38 +0800857 .evict_inode = ceph_evict_inode,
Sage Weil2d9c98a2010-07-30 09:38:13 -0700858 .sync_fs = ceph_sync_fs,
Sage Weil16725b92009-10-06 11:31:07 -0700859 .put_super = ceph_put_super,
860 .show_options = ceph_show_options,
861 .statfs = ceph_statfs,
862 .umount_begin = ceph_umount_begin,
863};
864
Sage Weil16725b92009-10-06 11:31:07 -0700865/*
866 * Bootstrap mount by opening the root directory. Note the mount
867 * @started time from caller, and time out if this takes too long.
868 */
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700869static struct dentry *open_root_dentry(struct ceph_fs_client *fsc,
Sage Weil16725b92009-10-06 11:31:07 -0700870 const char *path,
871 unsigned long started)
872{
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700873 struct ceph_mds_client *mdsc = fsc->mdsc;
Sage Weil16725b92009-10-06 11:31:07 -0700874 struct ceph_mds_request *req = NULL;
875 int err;
876 struct dentry *root;
877
878 /* open dir */
879 dout("open_root_inode opening '%s'\n", path);
880 req = ceph_mdsc_create_request(mdsc, CEPH_MDS_OP_GETATTR, USE_ANY_MDS);
881 if (IS_ERR(req))
Julia Lawall7e34bc52010-05-22 12:01:14 +0200882 return ERR_CAST(req);
Sage Weil16725b92009-10-06 11:31:07 -0700883 req->r_path1 = kstrdup(path, GFP_NOFS);
Sanidhya Kashyapa149bb92015-03-21 12:54:58 -0400884 if (!req->r_path1) {
885 root = ERR_PTR(-ENOMEM);
886 goto out;
887 }
888
Sage Weil16725b92009-10-06 11:31:07 -0700889 req->r_ino1.ino = CEPH_INO_ROOT;
890 req->r_ino1.snap = CEPH_NOSNAP;
891 req->r_started = started;
Ilya Dryomova319bf52015-05-15 12:02:17 +0300892 req->r_timeout = fsc->client->options->mount_timeout;
Sage Weil16725b92009-10-06 11:31:07 -0700893 req->r_args.getattr.mask = cpu_to_le32(CEPH_STAT_CAP_INODE);
894 req->r_num_caps = 2;
895 err = ceph_mdsc_do_request(mdsc, NULL, req);
896 if (err == 0) {
Al Viro3c5184e2012-01-09 16:34:32 -0500897 struct inode *inode = req->r_target_inode;
898 req->r_target_inode = NULL;
Sage Weil16725b92009-10-06 11:31:07 -0700899 dout("open_root_inode success\n");
Yan, Zhengce2728a2016-09-14 14:53:05 +0800900 root = d_make_root(inode);
901 if (!root) {
902 root = ERR_PTR(-ENOMEM);
903 goto out;
Sage Weil774ac212011-11-11 09:48:08 -0800904 }
Sage Weil16725b92009-10-06 11:31:07 -0700905 dout("open_root_inode success, root dentry is %p\n", root);
906 } else {
907 root = ERR_PTR(err);
908 }
Al Viro3c5184e2012-01-09 16:34:32 -0500909out:
Sage Weil16725b92009-10-06 11:31:07 -0700910 ceph_mdsc_put_request(req);
911 return root;
912}
913
914/*
915 * mount: join the ceph cluster, and open root directory.
916 */
David Howells82995cc2019-03-25 16:38:32 +0000917static struct dentry *ceph_real_mount(struct ceph_fs_client *fsc,
918 struct fs_context *fc)
Sage Weil16725b92009-10-06 11:31:07 -0700919{
Sage Weil16725b92009-10-06 11:31:07 -0700920 int err;
Sage Weil16725b92009-10-06 11:31:07 -0700921 unsigned long started = jiffies; /* note the start time */
922 struct dentry *root;
923
Yan, Zheng132ca7e2016-03-12 13:20:48 +0800924 dout("mount start %p\n", fsc);
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700925 mutex_lock(&fsc->client->mount_mutex);
Sage Weil16725b92009-10-06 11:31:07 -0700926
Yan, Zheng132ca7e2016-03-12 13:20:48 +0800927 if (!fsc->sb->s_root) {
Ilya Dryomovb27a9392020-02-10 22:51:08 +0100928 const char *path = fsc->mount_options->server_path ?
929 fsc->mount_options->server_path + 1 : "";
930
Yan, Zheng132ca7e2016-03-12 13:20:48 +0800931 err = __ceph_open_session(fsc->client, started);
932 if (err < 0)
933 goto out;
Sage Weil16725b92009-10-06 11:31:07 -0700934
Yan, Zheng1d8f8362017-06-27 11:57:56 +0800935 /* setup fscache */
936 if (fsc->mount_options->flags & CEPH_MOUNT_OPT_FSCACHE) {
David Howells82995cc2019-03-25 16:38:32 +0000937 err = ceph_fscache_register_fs(fsc, fc);
Yan, Zheng1d8f8362017-06-27 11:57:56 +0800938 if (err < 0)
939 goto out;
940 }
941
Xiubo Li4fbc0c72019-12-20 09:34:04 -0500942 dout("mount opening path '%s'\n", path);
Chengguang Xu18106732018-02-09 20:40:59 +0800943
Greg Kroah-Hartman1a829ff2019-06-12 16:55:38 +0200944 ceph_fs_debugfs_init(fsc);
Chengguang Xu18106732018-02-09 20:40:59 +0800945
Yan, Zhengce2728a2016-09-14 14:53:05 +0800946 root = open_root_dentry(fsc, path, started);
Yan, Zheng132ca7e2016-03-12 13:20:48 +0800947 if (IS_ERR(root)) {
948 err = PTR_ERR(root);
949 goto out;
950 }
Yan, Zhengce2728a2016-09-14 14:53:05 +0800951 fsc->sb->s_root = dget(root);
Geert Uytterhoeven31ca5872016-10-13 17:15:37 +0200952 } else {
953 root = dget(fsc->sb->s_root);
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700954 }
Sage Weil16725b92009-10-06 11:31:07 -0700955
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700956 fsc->mount_state = CEPH_MOUNT_MOUNTED;
Sage Weil16725b92009-10-06 11:31:07 -0700957 dout("mount success\n");
Al Viroa7f9fb22010-07-26 16:17:55 +0400958 mutex_unlock(&fsc->client->mount_mutex);
959 return root;
Sage Weil16725b92009-10-06 11:31:07 -0700960
Yan, Zheng132ca7e2016-03-12 13:20:48 +0800961out:
962 mutex_unlock(&fsc->client->mount_mutex);
963 return ERR_PTR(err);
Sage Weil16725b92009-10-06 11:31:07 -0700964}
965
David Howells82995cc2019-03-25 16:38:32 +0000966static int ceph_set_super(struct super_block *s, struct fs_context *fc)
Sage Weil16725b92009-10-06 11:31:07 -0700967{
David Howells82995cc2019-03-25 16:38:32 +0000968 struct ceph_fs_client *fsc = s->s_fs_info;
Sage Weil16725b92009-10-06 11:31:07 -0700969 int ret;
970
David Howells82995cc2019-03-25 16:38:32 +0000971 dout("set_super %p\n", s);
Sage Weil16725b92009-10-06 11:31:07 -0700972
Chengguang Xu719784b2018-07-19 22:15:24 +0800973 s->s_maxbytes = MAX_LFS_FILESIZE;
Sage Weil16725b92009-10-06 11:31:07 -0700974
Guangliang Zhao7221fe42013-11-11 15:18:03 +0800975 s->s_xattr = ceph_xattr_handlers;
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700976 fsc->sb = s;
Chengguang Xu719784b2018-07-19 22:15:24 +0800977 fsc->max_file_size = 1ULL << 40; /* temp value until we get mdsmap */
Sage Weil16725b92009-10-06 11:31:07 -0700978
979 s->s_op = &ceph_super_ops;
Al Viro18fc8ab2016-10-28 21:52:50 -0400980 s->s_d_op = &ceph_dentry_ops;
Sage Weil16725b92009-10-06 11:31:07 -0700981 s->s_export_op = &ceph_export_ops;
982
Luis Henriques0f7cf802019-06-27 14:51:22 +0100983 s->s_time_gran = 1;
Deepa Dinamani028ca4d2019-03-21 14:34:38 -0700984 s->s_time_min = 0;
985 s->s_time_max = U32_MAX;
Sage Weil16725b92009-10-06 11:31:07 -0700986
David Howells82995cc2019-03-25 16:38:32 +0000987 ret = set_anon_super_fc(s, fc);
Sage Weil16725b92009-10-06 11:31:07 -0700988 if (ret != 0)
David Howells82995cc2019-03-25 16:38:32 +0000989 fsc->sb = NULL;
Sage Weil16725b92009-10-06 11:31:07 -0700990 return ret;
991}
992
993/*
994 * share superblock if same fs AND options
995 */
David Howells82995cc2019-03-25 16:38:32 +0000996static int ceph_compare_super(struct super_block *sb, struct fs_context *fc)
Sage Weil16725b92009-10-06 11:31:07 -0700997{
David Howells82995cc2019-03-25 16:38:32 +0000998 struct ceph_fs_client *new = fc->s_fs_info;
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700999 struct ceph_mount_options *fsopt = new->mount_options;
1000 struct ceph_options *opt = new->client->options;
1001 struct ceph_fs_client *other = ceph_sb_to_client(sb);
Sage Weil16725b92009-10-06 11:31:07 -07001002
1003 dout("ceph_compare_super %p\n", sb);
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -07001004
1005 if (compare_mount_options(fsopt, opt, other)) {
1006 dout("monitor(s)/mount options don't match\n");
1007 return 0;
Sage Weil16725b92009-10-06 11:31:07 -07001008 }
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -07001009 if ((opt->flags & CEPH_OPT_FSID) &&
1010 ceph_fsid_compare(&opt->fsid, &other->client->fsid)) {
1011 dout("fsid doesn't match\n");
1012 return 0;
1013 }
David Howells82995cc2019-03-25 16:38:32 +00001014 if (fc->sb_flags != (sb->s_flags & ~SB_BORN)) {
Sage Weil16725b92009-10-06 11:31:07 -07001015 dout("flags differ\n");
1016 return 0;
1017 }
1018 return 1;
1019}
1020
1021/*
1022 * construct our own bdi so we can control readahead, etc.
1023 */
Jeff Mahoney00d56432010-06-10 11:13:58 -04001024static atomic_long_t bdi_seq = ATOMIC_LONG_INIT(0);
Sage Weil31e0cf82010-05-04 16:39:35 -07001025
Jan Kara09dc9fc2017-04-12 12:24:33 +02001026static int ceph_setup_bdi(struct super_block *sb, struct ceph_fs_client *fsc)
Sage Weil16725b92009-10-06 11:31:07 -07001027{
1028 int err;
1029
Jan Kara09dc9fc2017-04-12 12:24:33 +02001030 err = super_setup_bdi_name(sb, "ceph-%ld",
1031 atomic_long_inc_return(&bdi_seq));
1032 if (err)
1033 return err;
1034
Sage Weil83817e32011-08-04 08:03:44 -07001035 /* set ra_pages based on rasize mount option? */
Yan, Zheng4214fb12017-07-11 18:49:44 +08001036 sb->s_bdi->ra_pages = fsc->mount_options->rasize >> PAGE_SHIFT;
Yehuda Sadehe9852222011-07-22 11:12:28 -07001037
Yan, Zhengaa187922017-07-11 15:56:09 +08001038 /* set io_pages based on max osd read size */
1039 sb->s_bdi->io_pages = fsc->mount_options->rsize >> PAGE_SHIFT;
Andreas Gerstmayr7c94ba22017-01-10 14:17:56 +01001040
Jan Kara09dc9fc2017-04-12 12:24:33 +02001041 return 0;
Sage Weil16725b92009-10-06 11:31:07 -07001042}
1043
David Howells82995cc2019-03-25 16:38:32 +00001044static int ceph_get_tree(struct fs_context *fc)
Sage Weil16725b92009-10-06 11:31:07 -07001045{
David Howells82995cc2019-03-25 16:38:32 +00001046 struct ceph_parse_opts_ctx *pctx = fc->fs_private;
Sage Weil16725b92009-10-06 11:31:07 -07001047 struct super_block *sb;
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -07001048 struct ceph_fs_client *fsc;
Al Viroa7f9fb22010-07-26 16:17:55 +04001049 struct dentry *res;
David Howells82995cc2019-03-25 16:38:32 +00001050 int (*compare_super)(struct super_block *, struct fs_context *) =
1051 ceph_compare_super;
Sage Weil16725b92009-10-06 11:31:07 -07001052 int err;
Sage Weil16725b92009-10-06 11:31:07 -07001053
David Howells82995cc2019-03-25 16:38:32 +00001054 dout("ceph_get_tree\n");
1055
1056 if (!fc->source)
Al Virod53d0f72019-12-21 21:31:52 -05001057 return invalfc(fc, "No source");
Sage Weil45195e42014-02-16 10:05:29 -08001058
Sage Weil16725b92009-10-06 11:31:07 -07001059 /* create client (which we may/may not use) */
David Howells82995cc2019-03-25 16:38:32 +00001060 fsc = create_fs_client(pctx->opts, pctx->copts);
1061 pctx->opts = NULL;
1062 pctx->copts = NULL;
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -07001063 if (IS_ERR(fsc)) {
David Howells82995cc2019-03-25 16:38:32 +00001064 err = PTR_ERR(fsc);
Sage Weil6b805182009-10-27 11:50:50 -07001065 goto out_final;
1066 }
Sage Weil16725b92009-10-06 11:31:07 -07001067
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -07001068 err = ceph_mdsc_init(fsc);
David Howells82995cc2019-03-25 16:38:32 +00001069 if (err < 0)
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -07001070 goto out;
1071
1072 if (ceph_test_opt(fsc->client, NOSHARE))
Sage Weil16725b92009-10-06 11:31:07 -07001073 compare_super = NULL;
David Howells82995cc2019-03-25 16:38:32 +00001074
1075 fc->s_fs_info = fsc;
1076 sb = sget_fc(fc, compare_super, ceph_set_super);
1077 fc->s_fs_info = NULL;
Sage Weil16725b92009-10-06 11:31:07 -07001078 if (IS_ERR(sb)) {
David Howells82995cc2019-03-25 16:38:32 +00001079 err = PTR_ERR(sb);
Sage Weil16725b92009-10-06 11:31:07 -07001080 goto out;
1081 }
1082
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -07001083 if (ceph_sb_to_client(sb) != fsc) {
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -07001084 destroy_fs_client(fsc);
1085 fsc = ceph_sb_to_client(sb);
1086 dout("get_sb got existing client %p\n", fsc);
Sage Weil16725b92009-10-06 11:31:07 -07001087 } else {
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -07001088 dout("get_sb using new client %p\n", fsc);
Jan Kara09dc9fc2017-04-12 12:24:33 +02001089 err = ceph_setup_bdi(sb, fsc);
David Howells82995cc2019-03-25 16:38:32 +00001090 if (err < 0)
Sage Weil16725b92009-10-06 11:31:07 -07001091 goto out_splat;
1092 }
1093
David Howells82995cc2019-03-25 16:38:32 +00001094 res = ceph_real_mount(fsc, fc);
1095 if (IS_ERR(res)) {
1096 err = PTR_ERR(res);
Sage Weil16725b92009-10-06 11:31:07 -07001097 goto out_splat;
David Howells82995cc2019-03-25 16:38:32 +00001098 }
Al Viroa7f9fb22010-07-26 16:17:55 +04001099 dout("root %p inode %p ino %llx.%llx\n", res,
David Howells2b0143b2015-03-17 22:25:59 +00001100 d_inode(res), ceph_vinop(d_inode(res)));
David Howells82995cc2019-03-25 16:38:32 +00001101 fc->root = fsc->sb->s_root;
1102 return 0;
Sage Weil16725b92009-10-06 11:31:07 -07001103
1104out_splat:
Xiubo Li97820052019-12-10 20:29:40 -05001105 if (!ceph_mdsmap_is_cluster_available(fsc->mdsc->mdsmap)) {
1106 pr_info("No mds server is up or the cluster is laggy\n");
1107 err = -EHOSTUNREACH;
1108 }
1109
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -07001110 ceph_mdsc_close_sessions(fsc->mdsc);
Al Viro3981f2e2010-03-21 19:22:29 -04001111 deactivate_locked_super(sb);
Sage Weil16725b92009-10-06 11:31:07 -07001112 goto out_final;
1113
1114out:
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -07001115 destroy_fs_client(fsc);
Sage Weil16725b92009-10-06 11:31:07 -07001116out_final:
David Howells82995cc2019-03-25 16:38:32 +00001117 dout("ceph_get_tree fail %d\n", err);
1118 return err;
1119}
1120
1121static void ceph_free_fc(struct fs_context *fc)
1122{
1123 struct ceph_parse_opts_ctx *pctx = fc->fs_private;
1124
1125 if (pctx) {
1126 destroy_mount_options(pctx->opts);
1127 ceph_destroy_options(pctx->copts);
1128 kfree(pctx);
1129 }
1130}
1131
1132static int ceph_reconfigure_fc(struct fs_context *fc)
1133{
Jeff Layton2ccb4542019-04-02 15:35:56 -04001134 struct ceph_parse_opts_ctx *pctx = fc->fs_private;
1135 struct ceph_mount_options *fsopt = pctx->opts;
1136 struct ceph_fs_client *fsc = ceph_sb_to_client(fc->root->d_sb);
1137
1138 if (fsopt->flags & CEPH_MOUNT_OPT_ASYNC_DIROPS)
1139 ceph_set_mount_opt(fsc, ASYNC_DIROPS);
1140 else
1141 ceph_clear_mount_opt(fsc, ASYNC_DIROPS);
1142
David Howells82995cc2019-03-25 16:38:32 +00001143 sync_filesystem(fc->root->d_sb);
1144 return 0;
1145}
1146
1147static const struct fs_context_operations ceph_context_ops = {
1148 .free = ceph_free_fc,
1149 .parse_param = ceph_parse_mount_param,
1150 .get_tree = ceph_get_tree,
1151 .reconfigure = ceph_reconfigure_fc,
1152};
1153
1154/*
1155 * Set up the filesystem mount context.
1156 */
1157static int ceph_init_fs_context(struct fs_context *fc)
1158{
1159 struct ceph_parse_opts_ctx *pctx;
1160 struct ceph_mount_options *fsopt;
1161
1162 pctx = kzalloc(sizeof(*pctx), GFP_KERNEL);
1163 if (!pctx)
1164 return -ENOMEM;
1165
1166 pctx->copts = ceph_alloc_options();
1167 if (!pctx->copts)
1168 goto nomem;
1169
1170 pctx->opts = kzalloc(sizeof(*pctx->opts), GFP_KERNEL);
1171 if (!pctx->opts)
1172 goto nomem;
1173
1174 fsopt = pctx->opts;
1175 fsopt->flags = CEPH_MOUNT_OPT_DEFAULT;
1176
1177 fsopt->wsize = CEPH_MAX_WRITE_SIZE;
1178 fsopt->rsize = CEPH_MAX_READ_SIZE;
1179 fsopt->rasize = CEPH_RASIZE_DEFAULT;
1180 fsopt->snapdir_name = kstrdup(CEPH_SNAPDIRNAME_DEFAULT, GFP_KERNEL);
1181 if (!fsopt->snapdir_name)
1182 goto nomem;
1183
1184 fsopt->caps_wanted_delay_min = CEPH_CAPS_WANTED_DELAY_MIN_DEFAULT;
1185 fsopt->caps_wanted_delay_max = CEPH_CAPS_WANTED_DELAY_MAX_DEFAULT;
1186 fsopt->max_readdir = CEPH_MAX_READDIR_DEFAULT;
1187 fsopt->max_readdir_bytes = CEPH_MAX_READDIR_BYTES_DEFAULT;
1188 fsopt->congestion_kb = default_congestion_kb();
1189
Xiubo Li3b20bc22020-02-11 01:53:16 -05001190#ifdef CONFIG_CEPH_FS_POSIX_ACL
1191 fc->sb_flags |= SB_POSIXACL;
1192#endif
1193
David Howells82995cc2019-03-25 16:38:32 +00001194 fc->fs_private = pctx;
1195 fc->ops = &ceph_context_ops;
1196 return 0;
1197
1198nomem:
1199 destroy_mount_options(pctx->opts);
1200 ceph_destroy_options(pctx->copts);
1201 kfree(pctx);
1202 return -ENOMEM;
Sage Weil16725b92009-10-06 11:31:07 -07001203}
1204
1205static void ceph_kill_sb(struct super_block *s)
1206{
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -07001207 struct ceph_fs_client *fsc = ceph_sb_to_client(s);
Christoph Hellwige4d27502015-01-14 10:42:38 +01001208 dev_t dev = s->s_dev;
1209
Sage Weil16725b92009-10-06 11:31:07 -07001210 dout("kill_sb %p\n", s);
Christoph Hellwige4d27502015-01-14 10:42:38 +01001211
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -07001212 ceph_mdsc_pre_umount(fsc->mdsc);
Yan, Zhenga57d9062018-05-18 16:05:51 +08001213 flush_fs_workqueues(fsc);
1214
Christoph Hellwige4d27502015-01-14 10:42:38 +01001215 generic_shutdown_super(s);
Yan, Zheng62a65f32017-06-22 16:26:34 +08001216
1217 fsc->client->extra_mon_dispatch = NULL;
1218 ceph_fs_debugfs_cleanup(fsc);
1219
Yan, Zheng1d8f8362017-06-27 11:57:56 +08001220 ceph_fscache_unregister_fs(fsc);
1221
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -07001222 destroy_fs_client(fsc);
Christoph Hellwige4d27502015-01-14 10:42:38 +01001223 free_anon_bdev(dev);
Sage Weil16725b92009-10-06 11:31:07 -07001224}
1225
1226static struct file_system_type ceph_fs_type = {
1227 .owner = THIS_MODULE,
1228 .name = "ceph",
David Howells82995cc2019-03-25 16:38:32 +00001229 .init_fs_context = ceph_init_fs_context,
Sage Weil16725b92009-10-06 11:31:07 -07001230 .kill_sb = ceph_kill_sb,
1231 .fs_flags = FS_RENAME_DOES_D_MOVE,
1232};
Eric W. Biederman7f78e032013-03-02 19:39:14 -08001233MODULE_ALIAS_FS("ceph");
Sage Weil16725b92009-10-06 11:31:07 -07001234
Yan, Zhengd468e722019-07-25 20:16:44 +08001235int ceph_force_reconnect(struct super_block *sb)
1236{
1237 struct ceph_fs_client *fsc = ceph_sb_to_client(sb);
1238 int err = 0;
1239
1240 ceph_umount_begin(sb);
1241
1242 /* Make sure all page caches get invalidated.
1243 * see remove_session_caps_cb() */
1244 flush_workqueue(fsc->inode_wq);
1245
1246 /* In case that we were blacklisted. This also reset
1247 * all mon/osd connections */
1248 ceph_reset_client_addr(fsc->client);
1249
1250 ceph_osdc_clear_abort_err(&fsc->client->osdc);
Yan, Zheng131d7eb2019-07-25 20:16:47 +08001251
1252 fsc->blacklisted = false;
Yan, Zhengd468e722019-07-25 20:16:44 +08001253 fsc->mount_state = CEPH_MOUNT_MOUNTED;
1254
1255 if (sb->s_root) {
1256 err = __ceph_do_getattr(d_inode(sb->s_root), NULL,
1257 CEPH_STAT_CAP_INODE, true);
1258 }
1259 return err;
1260}
1261
Sage Weil16725b92009-10-06 11:31:07 -07001262static int __init init_ceph(void)
1263{
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -07001264 int ret = init_caches();
Sage Weil16725b92009-10-06 11:31:07 -07001265 if (ret)
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -07001266 goto out;
Sage Weil16725b92009-10-06 11:31:07 -07001267
Yan, Zhengeb13e832014-03-09 23:16:40 +08001268 ceph_flock_init();
Sage Weil16725b92009-10-06 11:31:07 -07001269 ret = register_filesystem(&ceph_fs_type);
1270 if (ret)
David Disseldorpd0f191d2019-04-18 14:15:49 +02001271 goto out_caches;
Sage Weil16725b92009-10-06 11:31:07 -07001272
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -07001273 pr_info("loaded (mds proto %d)\n", CEPH_MDSC_PROTOCOL);
1274
Sage Weil16725b92009-10-06 11:31:07 -07001275 return 0;
1276
David Disseldorpd0f191d2019-04-18 14:15:49 +02001277out_caches:
Sage Weil16725b92009-10-06 11:31:07 -07001278 destroy_caches();
Sage Weil16725b92009-10-06 11:31:07 -07001279out:
1280 return ret;
1281}
1282
1283static void __exit exit_ceph(void)
1284{
1285 dout("exit_ceph\n");
1286 unregister_filesystem(&ceph_fs_type);
Sage Weil16725b92009-10-06 11:31:07 -07001287 destroy_caches();
Sage Weil16725b92009-10-06 11:31:07 -07001288}
1289
Xiubo Li18f473b2020-07-16 10:05:57 -04001290static int param_set_metrics(const char *val, const struct kernel_param *kp)
1291{
1292 struct ceph_fs_client *fsc;
1293 int ret;
1294
1295 ret = param_set_bool(val, kp);
1296 if (ret) {
1297 pr_err("Failed to parse sending metrics switch value '%s'\n",
1298 val);
1299 return ret;
1300 } else if (!disable_send_metrics) {
1301 // wake up all the mds clients
1302 spin_lock(&ceph_fsc_lock);
1303 list_for_each_entry(fsc, &ceph_fsc_list, metric_wakeup) {
1304 metric_schedule_delayed(&fsc->mdsc->metric);
1305 }
1306 spin_unlock(&ceph_fsc_lock);
1307 }
1308
1309 return 0;
1310}
1311
1312static const struct kernel_param_ops param_ops_metrics = {
1313 .set = param_set_metrics,
1314 .get = param_get_bool,
1315};
1316
1317bool disable_send_metrics = false;
1318module_param_cb(disable_send_metrics, &param_ops_metrics, &disable_send_metrics, 0644);
1319MODULE_PARM_DESC(disable_send_metrics, "Enable sending perf metrics to ceph cluster (default: on)");
1320
Sage Weil16725b92009-10-06 11:31:07 -07001321module_init(init_ceph);
1322module_exit(exit_ceph);
1323
1324MODULE_AUTHOR("Sage Weil <sage@newdream.net>");
1325MODULE_AUTHOR("Yehuda Sadeh <yehuda@hq.newdream.net>");
1326MODULE_AUTHOR("Patience Warnick <patience@newdream.net>");
1327MODULE_DESCRIPTION("Ceph filesystem for Linux");
1328MODULE_LICENSE("GPL");