Commit | Line | Data |
---|---|---|
09c434b8 | 1 | // SPDX-License-Identifier: GPL-2.0-only |
16725b9d | 2 | |
3d14c5d2 | 3 | #include <linux/ceph/ceph_debug.h> |
16725b9d SW |
4 | |
5 | #include <linux/backing-dev.h> | |
c309f0ab | 6 | #include <linux/ctype.h> |
16725b9d SW |
7 | #include <linux/fs.h> |
8 | #include <linux/inet.h> | |
9 | #include <linux/in6.h> | |
10 | #include <linux/module.h> | |
11 | #include <linux/mount.h> | |
82995cc6 DH |
12 | #include <linux/fs_context.h> |
13 | #include <linux/fs_parser.h> | |
16725b9d SW |
14 | #include <linux/sched.h> |
15 | #include <linux/seq_file.h> | |
5a0e3ad6 | 16 | #include <linux/slab.h> |
16725b9d SW |
17 | #include <linux/statfs.h> |
18 | #include <linux/string.h> | |
16725b9d | 19 | |
16725b9d | 20 | #include "super.h" |
3d14c5d2 | 21 | #include "mds_client.h" |
99ccbd22 | 22 | #include "cache.h" |
2d332d5b | 23 | #include "crypto.h" |
3d14c5d2 | 24 | |
1fe60e51 | 25 | #include <linux/ceph/ceph_features.h> |
3d14c5d2 YS |
26 | #include <linux/ceph/decode.h> |
27 | #include <linux/ceph/mon_client.h> | |
28 | #include <linux/ceph/auth.h> | |
29 | #include <linux/ceph/debugfs.h> | |
16725b9d | 30 | |
a0b3a15e JL |
31 | #include <uapi/linux/magic.h> |
32 | ||
18f473b3 XL |
33 | static DEFINE_SPINLOCK(ceph_fsc_lock); |
34 | static LIST_HEAD(ceph_fsc_list); | |
35 | ||
16725b9d SW |
36 | /* |
37 | * Ceph superblock operations | |
38 | * | |
39 | * Handle the basics of mounting, unmounting. | |
40 | */ | |
41 | ||
16725b9d SW |
42 | /* |
43 | * super ops | |
44 | */ | |
45 | static void ceph_put_super(struct super_block *s) | |
46 | { | |
5995d90d | 47 | struct ceph_fs_client *fsc = ceph_sb_to_fs_client(s); |
16725b9d | 48 | |
38d46409 | 49 | doutc(fsc->client, "begin\n"); |
6b5717bd | 50 | ceph_fscrypt_free_dummy_policy(fsc); |
3d14c5d2 | 51 | ceph_mdsc_close_sessions(fsc->mdsc); |
38d46409 | 52 | doutc(fsc->client, "done\n"); |
16725b9d SW |
53 | } |
54 | ||
55 | static int ceph_statfs(struct dentry *dentry, struct kstatfs *buf) | |
56 | { | |
5995d90d | 57 | struct ceph_fs_client *fsc = ceph_inode_to_fs_client(d_inode(dentry)); |
73fb0949 | 58 | struct ceph_mon_client *monc = &fsc->client->monc; |
16725b9d | 59 | struct ceph_statfs st; |
8cfc0c7e | 60 | int i, err; |
06d74376 DF |
61 | u64 data_pool; |
62 | ||
38d46409 | 63 | doutc(fsc->client, "begin\n"); |
06d74376 DF |
64 | if (fsc->mdsc->mdsmap->m_num_data_pg_pools == 1) { |
65 | data_pool = fsc->mdsc->mdsmap->m_data_pg_pools[0]; | |
66 | } else { | |
67 | data_pool = CEPH_NOPOOL; | |
68 | } | |
16725b9d | 69 | |
73fb0949 | 70 | err = ceph_monc_do_statfs(monc, data_pool, &st); |
16725b9d SW |
71 | if (err < 0) |
72 | return err; | |
73 | ||
74 | /* fill in kstatfs */ | |
75 | buf->f_type = CEPH_SUPER_MAGIC; /* ?? */ | |
76 | ||
77 | /* | |
0c04a117 | 78 | * Express utilization in terms of large blocks to avoid |
16725b9d SW |
79 | * overflow on 32-bit machines. |
80 | */ | |
92a49fb0 | 81 | buf->f_frsize = 1 << CEPH_BLOCK_SHIFT; |
9122eed5 LH |
82 | |
83 | /* | |
84 | * By default use root quota for stats; fallback to overall filesystem | |
85 | * usage if using 'noquotadf' mount option or if the root dir doesn't | |
86 | * have max_bytes quota set. | |
87 | */ | |
88 | if (ceph_test_mount_opt(fsc, NOQUOTADF) || | |
89 | !ceph_quota_update_statfs(fsc, buf)) { | |
90 | buf->f_blocks = le64_to_cpu(st.kb) >> (CEPH_BLOCK_SHIFT-10); | |
91 | buf->f_bfree = le64_to_cpu(st.kb_avail) >> (CEPH_BLOCK_SHIFT-10); | |
92 | buf->f_bavail = le64_to_cpu(st.kb_avail) >> (CEPH_BLOCK_SHIFT-10); | |
93 | } | |
16725b9d | 94 | |
0c04a117 XL |
95 | /* |
96 | * NOTE: for the time being, we make bsize == frsize to humor | |
97 | * not-yet-ancient versions of glibc that are broken. | |
98 | * Someday, we will probably want to report a real block | |
99 | * size... whatever that may mean for a network file system! | |
100 | */ | |
101 | buf->f_bsize = buf->f_frsize; | |
102 | ||
16725b9d SW |
103 | buf->f_files = le64_to_cpu(st.num_objects); |
104 | buf->f_ffree = -1; | |
558d3499 | 105 | buf->f_namelen = NAME_MAX; |
16725b9d | 106 | |
080a330e | 107 | /* Must convert the fsid, for consistent values across arches */ |
8cfc0c7e | 108 | buf->f_fsid.val[0] = 0; |
73fb0949 | 109 | mutex_lock(&monc->mutex); |
8cfc0c7e JL |
110 | for (i = 0 ; i < sizeof(monc->monmap->fsid) / sizeof(__le32) ; ++i) |
111 | buf->f_fsid.val[0] ^= le32_to_cpu(((__le32 *)&monc->monmap->fsid)[i]); | |
73fb0949 LH |
112 | mutex_unlock(&monc->mutex); |
113 | ||
8cfc0c7e JL |
114 | /* fold the fs_cluster_id into the upper bits */ |
115 | buf->f_fsid.val[1] = monc->fs_cluster_id; | |
16725b9d | 116 | |
38d46409 | 117 | doutc(fsc->client, "done\n"); |
16725b9d SW |
118 | return 0; |
119 | } | |
120 | ||
2d9c98ae | 121 | static int ceph_sync_fs(struct super_block *sb, int wait) |
16725b9d | 122 | { |
5995d90d | 123 | struct ceph_fs_client *fsc = ceph_sb_to_fs_client(sb); |
38d46409 | 124 | struct ceph_client *cl = fsc->client; |
2d9c98ae SW |
125 | |
126 | if (!wait) { | |
38d46409 | 127 | doutc(cl, "(non-blocking)\n"); |
3d14c5d2 | 128 | ceph_flush_dirty_caps(fsc->mdsc); |
38d46409 | 129 | doutc(cl, "(non-blocking) done\n"); |
2d9c98ae SW |
130 | return 0; |
131 | } | |
132 | ||
38d46409 | 133 | doutc(cl, "(blocking)\n"); |
3d14c5d2 YS |
134 | ceph_osdc_sync(&fsc->client->osdc); |
135 | ceph_mdsc_sync(fsc->mdsc); | |
38d46409 | 136 | doutc(cl, "(blocking) done\n"); |
16725b9d SW |
137 | return 0; |
138 | } | |
139 | ||
16725b9d SW |
140 | /* |
141 | * mount options | |
142 | */ | |
143 | enum { | |
16725b9d SW |
144 | Opt_wsize, |
145 | Opt_rsize, | |
83817e35 | 146 | Opt_rasize, |
16725b9d SW |
147 | Opt_caps_wanted_delay_min, |
148 | Opt_caps_wanted_delay_max, | |
fe33032d | 149 | Opt_caps_max, |
16725b9d | 150 | Opt_readdir_max_entries, |
23804d91 | 151 | Opt_readdir_max_bytes, |
2baba250 | 152 | Opt_congestion_kb, |
16725b9d SW |
153 | /* int args above */ |
154 | Opt_snapdirname, | |
430afbad | 155 | Opt_mds_namespace, |
131d7eb4 | 156 | Opt_recover_session, |
82995cc6 | 157 | Opt_source, |
7b19b4db | 158 | Opt_mon_addr, |
6b5717bd | 159 | Opt_test_dummy_encryption, |
16725b9d | 160 | /* string args above */ |
16725b9d | 161 | Opt_dirstat, |
16725b9d | 162 | Opt_rbytes, |
cffaba15 | 163 | Opt_asyncreaddir, |
a40dc6cc | 164 | Opt_dcache, |
ad1fee96 | 165 | Opt_ino32, |
99ccbd22 | 166 | Opt_fscache, |
10183a69 | 167 | Opt_poolperm, |
e9e427f0 | 168 | Opt_require_active_mds, |
45195e42 | 169 | Opt_acl, |
9122eed5 | 170 | Opt_quotadf, |
ea4cdc54 | 171 | Opt_copyfrom, |
2ccb4546 | 172 | Opt_wsync, |
94cc0877 | 173 | Opt_pagecache, |
03bc06c7 | 174 | Opt_sparseread, |
16725b9d SW |
175 | }; |
176 | ||
82995cc6 DH |
177 | enum ceph_recover_session_mode { |
178 | ceph_recover_session_no, | |
179 | ceph_recover_session_clean | |
180 | }; | |
181 | ||
5eede625 | 182 | static const struct constant_table ceph_param_recover[] = { |
2710c957 AV |
183 | { "no", ceph_recover_session_no }, |
184 | { "clean", ceph_recover_session_clean }, | |
82995cc6 DH |
185 | {} |
186 | }; | |
187 | ||
d7167b14 | 188 | static const struct fs_parameter_spec ceph_mount_parameters[] = { |
82995cc6 DH |
189 | fsparam_flag_no ("acl", Opt_acl), |
190 | fsparam_flag_no ("asyncreaddir", Opt_asyncreaddir), | |
ad8c28a9 | 191 | fsparam_s32 ("caps_max", Opt_caps_max), |
82995cc6 DH |
192 | fsparam_u32 ("caps_wanted_delay_max", Opt_caps_wanted_delay_max), |
193 | fsparam_u32 ("caps_wanted_delay_min", Opt_caps_wanted_delay_min), | |
ad8c28a9 | 194 | fsparam_u32 ("write_congestion_kb", Opt_congestion_kb), |
82995cc6 DH |
195 | fsparam_flag_no ("copyfrom", Opt_copyfrom), |
196 | fsparam_flag_no ("dcache", Opt_dcache), | |
197 | fsparam_flag_no ("dirstat", Opt_dirstat), | |
48ce73b1 AV |
198 | fsparam_flag_no ("fsc", Opt_fscache), // fsc|nofsc |
199 | fsparam_string ("fsc", Opt_fscache), // fsc=... | |
82995cc6 DH |
200 | fsparam_flag_no ("ino32", Opt_ino32), |
201 | fsparam_string ("mds_namespace", Opt_mds_namespace), | |
6b5717bd | 202 | fsparam_string ("mon_addr", Opt_mon_addr), |
82995cc6 DH |
203 | fsparam_flag_no ("poolperm", Opt_poolperm), |
204 | fsparam_flag_no ("quotadf", Opt_quotadf), | |
205 | fsparam_u32 ("rasize", Opt_rasize), | |
206 | fsparam_flag_no ("rbytes", Opt_rbytes), | |
ad8c28a9 JL |
207 | fsparam_u32 ("readdir_max_bytes", Opt_readdir_max_bytes), |
208 | fsparam_u32 ("readdir_max_entries", Opt_readdir_max_entries), | |
2710c957 | 209 | fsparam_enum ("recover_session", Opt_recover_session, ceph_param_recover), |
82995cc6 DH |
210 | fsparam_flag_no ("require_active_mds", Opt_require_active_mds), |
211 | fsparam_u32 ("rsize", Opt_rsize), | |
212 | fsparam_string ("snapdirname", Opt_snapdirname), | |
213 | fsparam_string ("source", Opt_source), | |
6b5717bd JL |
214 | fsparam_flag ("test_dummy_encryption", Opt_test_dummy_encryption), |
215 | fsparam_string ("test_dummy_encryption", Opt_test_dummy_encryption), | |
82995cc6 | 216 | fsparam_u32 ("wsize", Opt_wsize), |
2ccb4546 | 217 | fsparam_flag_no ("wsync", Opt_wsync), |
94cc0877 | 218 | fsparam_flag_no ("pagecache", Opt_pagecache), |
03bc06c7 | 219 | fsparam_flag_no ("sparseread", Opt_sparseread), |
82995cc6 DH |
220 | {} |
221 | }; | |
222 | ||
82995cc6 DH |
223 | struct ceph_parse_opts_ctx { |
224 | struct ceph_options *copts; | |
225 | struct ceph_mount_options *opts; | |
226 | }; | |
227 | ||
b27a939e ID |
228 | /* |
229 | * Remove adjacent slashes and then the trailing slash, unless it is | |
230 | * the only remaining character. | |
231 | * | |
232 | * E.g. "//dir1////dir2///" --> "/dir1/dir2", "///" --> "/". | |
233 | */ | |
234 | static void canonicalize_path(char *path) | |
235 | { | |
236 | int i, j = 0; | |
237 | ||
238 | for (i = 0; path[i] != '\0'; i++) { | |
239 | if (path[i] != '/' || j < 1 || path[j - 1] != '/') | |
240 | path[j++] = path[i]; | |
241 | } | |
242 | ||
243 | if (j > 1 && path[j - 1] == '/') | |
244 | j--; | |
245 | path[j] = '\0'; | |
246 | } | |
247 | ||
82995cc6 | 248 | /* |
7b19b4db VS |
249 | * Check if the mds namespace in ceph_mount_options matches |
250 | * the passed in namespace string. First time match (when | |
251 | * ->mds_namespace is NULL) is treated specially, since | |
252 | * ->mds_namespace needs to be initialized by the caller. | |
253 | */ | |
254 | static int namespace_equals(struct ceph_mount_options *fsopt, | |
255 | const char *namespace, size_t len) | |
256 | { | |
257 | return !(fsopt->mds_namespace && | |
258 | (strlen(fsopt->mds_namespace) != len || | |
259 | strncmp(fsopt->mds_namespace, namespace, len))); | |
260 | } | |
261 | ||
262 | static int ceph_parse_old_source(const char *dev_name, const char *dev_name_end, | |
263 | struct fs_context *fc) | |
264 | { | |
265 | int r; | |
266 | struct ceph_parse_opts_ctx *pctx = fc->fs_private; | |
267 | struct ceph_mount_options *fsopt = pctx->opts; | |
268 | ||
269 | if (*dev_name_end != ':') | |
270 | return invalfc(fc, "separator ':' missing in source"); | |
271 | ||
272 | r = ceph_parse_mon_ips(dev_name, dev_name_end - dev_name, | |
273 | pctx->copts, fc->log.log, ','); | |
274 | if (r) | |
275 | return r; | |
276 | ||
277 | fsopt->new_dev_syntax = false; | |
278 | return 0; | |
279 | } | |
280 | ||
281 | static int ceph_parse_new_source(const char *dev_name, const char *dev_name_end, | |
282 | struct fs_context *fc) | |
283 | { | |
284 | size_t len; | |
285 | struct ceph_fsid fsid; | |
286 | struct ceph_parse_opts_ctx *pctx = fc->fs_private; | |
287 | struct ceph_mount_options *fsopt = pctx->opts; | |
288 | char *fsid_start, *fs_name_start; | |
289 | ||
290 | if (*dev_name_end != '=') { | |
291 | dout("separator '=' missing in source"); | |
292 | return -EINVAL; | |
293 | } | |
294 | ||
295 | fsid_start = strchr(dev_name, '@'); | |
296 | if (!fsid_start) | |
297 | return invalfc(fc, "missing cluster fsid"); | |
298 | ++fsid_start; /* start of cluster fsid */ | |
299 | ||
300 | fs_name_start = strchr(fsid_start, '.'); | |
301 | if (!fs_name_start) | |
302 | return invalfc(fc, "missing file system name"); | |
303 | ||
304 | if (ceph_parse_fsid(fsid_start, &fsid)) | |
305 | return invalfc(fc, "Invalid FSID"); | |
306 | ||
307 | ++fs_name_start; /* start of file system name */ | |
308 | len = dev_name_end - fs_name_start; | |
309 | ||
310 | if (!namespace_equals(fsopt, fs_name_start, len)) | |
311 | return invalfc(fc, "Mismatching mds_namespace"); | |
312 | kfree(fsopt->mds_namespace); | |
313 | fsopt->mds_namespace = kstrndup(fs_name_start, len, GFP_KERNEL); | |
314 | if (!fsopt->mds_namespace) | |
315 | return -ENOMEM; | |
316 | dout("file system (mds namespace) '%s'\n", fsopt->mds_namespace); | |
317 | ||
318 | fsopt->new_dev_syntax = true; | |
319 | return 0; | |
320 | } | |
321 | ||
322 | /* | |
323 | * Parse the source parameter for new device format. Distinguish the device | |
324 | * spec from the path. Try parsing new device format and fallback to old | |
325 | * format if needed. | |
326 | * | |
327 | * New device syntax will looks like: | |
328 | * <device_spec>=/<path> | |
329 | * where | |
330 | * <device_spec> is name@fsid.fsname | |
331 | * <path> is optional, but if present must begin with '/' | |
332 | * (monitor addresses are passed via mount option) | |
82995cc6 | 333 | * |
7b19b4db | 334 | * Old device syntax is: |
82995cc6 DH |
335 | * <server_spec>[,<server_spec>...]:[<path>] |
336 | * where | |
337 | * <server_spec> is <ip>[:<port>] | |
338 | * <path> is optional, but if present must begin with '/' | |
339 | */ | |
340 | static int ceph_parse_source(struct fs_parameter *param, struct fs_context *fc) | |
c309f0ab | 341 | { |
82995cc6 DH |
342 | struct ceph_parse_opts_ctx *pctx = fc->fs_private; |
343 | struct ceph_mount_options *fsopt = pctx->opts; | |
344 | char *dev_name = param->string, *dev_name_end; | |
345 | int ret; | |
3d14c5d2 | 346 | |
38d46409 | 347 | dout("'%s'\n", dev_name); |
82995cc6 | 348 | if (!dev_name || !*dev_name) |
d53d0f74 | 349 | return invalfc(fc, "Empty source"); |
3d14c5d2 | 350 | |
82995cc6 DH |
351 | dev_name_end = strchr(dev_name, '/'); |
352 | if (dev_name_end) { | |
4fbc0c71 XL |
353 | /* |
354 | * The server_path will include the whole chars from userland | |
355 | * including the leading '/'. | |
356 | */ | |
b27a939e | 357 | kfree(fsopt->server_path); |
4fbc0c71 XL |
358 | fsopt->server_path = kstrdup(dev_name_end, GFP_KERNEL); |
359 | if (!fsopt->server_path) | |
360 | return -ENOMEM; | |
b27a939e ID |
361 | |
362 | canonicalize_path(fsopt->server_path); | |
3d14c5d2 | 363 | } else { |
82995cc6 | 364 | dev_name_end = dev_name + strlen(dev_name); |
c309f0ab SW |
365 | } |
366 | ||
7b19b4db VS |
367 | dev_name_end--; /* back up to separator */ |
368 | if (dev_name_end < dev_name) | |
369 | return invalfc(fc, "Path missing in source"); | |
82995cc6 DH |
370 | |
371 | dout("device name '%.*s'\n", (int)(dev_name_end - dev_name), dev_name); | |
372 | if (fsopt->server_path) | |
373 | dout("server path '%s'\n", fsopt->server_path); | |
374 | ||
7b19b4db VS |
375 | dout("trying new device syntax"); |
376 | ret = ceph_parse_new_source(dev_name, dev_name_end, fc); | |
377 | if (ret) { | |
378 | if (ret != -EINVAL) | |
379 | return ret; | |
380 | dout("trying old device syntax"); | |
381 | ret = ceph_parse_old_source(dev_name, dev_name_end, fc); | |
382 | if (ret) | |
383 | return ret; | |
384 | } | |
82995cc6 DH |
385 | |
386 | fc->source = param->string; | |
387 | param->string = NULL; | |
388 | return 0; | |
389 | } | |
390 | ||
7b19b4db VS |
391 | static int ceph_parse_mon_addr(struct fs_parameter *param, |
392 | struct fs_context *fc) | |
393 | { | |
394 | struct ceph_parse_opts_ctx *pctx = fc->fs_private; | |
395 | struct ceph_mount_options *fsopt = pctx->opts; | |
396 | ||
397 | kfree(fsopt->mon_addr); | |
398 | fsopt->mon_addr = param->string; | |
399 | param->string = NULL; | |
400 | ||
401 | return ceph_parse_mon_ips(fsopt->mon_addr, strlen(fsopt->mon_addr), | |
402 | pctx->copts, fc->log.log, '/'); | |
403 | } | |
404 | ||
82995cc6 DH |
405 | static int ceph_parse_mount_param(struct fs_context *fc, |
406 | struct fs_parameter *param) | |
407 | { | |
408 | struct ceph_parse_opts_ctx *pctx = fc->fs_private; | |
409 | struct ceph_mount_options *fsopt = pctx->opts; | |
410 | struct fs_parse_result result; | |
411 | unsigned int mode; | |
412 | int token, ret; | |
413 | ||
cc3c0b53 | 414 | ret = ceph_parse_param(param, pctx->copts, fc->log.log); |
82995cc6 DH |
415 | if (ret != -ENOPARAM) |
416 | return ret; | |
417 | ||
d7167b14 | 418 | token = fs_parse(fc, ceph_mount_parameters, param, &result); |
38d46409 | 419 | dout("%s: fs_parse '%s' token %d\n",__func__, param->key, token); |
82995cc6 DH |
420 | if (token < 0) |
421 | return token; | |
422 | ||
3d14c5d2 YS |
423 | switch (token) { |
424 | case Opt_snapdirname: | |
425 | kfree(fsopt->snapdir_name); | |
82995cc6 DH |
426 | fsopt->snapdir_name = param->string; |
427 | param->string = NULL; | |
3d14c5d2 | 428 | break; |
235a0982 | 429 | case Opt_mds_namespace: |
7b19b4db VS |
430 | if (!namespace_equals(fsopt, param->string, strlen(param->string))) |
431 | return invalfc(fc, "Mismatching mds_namespace"); | |
937441f3 | 432 | kfree(fsopt->mds_namespace); |
82995cc6 DH |
433 | fsopt->mds_namespace = param->string; |
434 | param->string = NULL; | |
235a0982 | 435 | break; |
131d7eb4 | 436 | case Opt_recover_session: |
82995cc6 DH |
437 | mode = result.uint_32; |
438 | if (mode == ceph_recover_session_no) | |
131d7eb4 | 439 | fsopt->flags &= ~CEPH_MOUNT_OPT_CLEANRECOVER; |
82995cc6 | 440 | else if (mode == ceph_recover_session_clean) |
131d7eb4 | 441 | fsopt->flags |= CEPH_MOUNT_OPT_CLEANRECOVER; |
82995cc6 DH |
442 | else |
443 | BUG(); | |
1d8f8360 | 444 | break; |
82995cc6 DH |
445 | case Opt_source: |
446 | if (fc->source) | |
d53d0f74 | 447 | return invalfc(fc, "Multiple sources specified"); |
82995cc6 | 448 | return ceph_parse_source(param, fc); |
7b19b4db VS |
449 | case Opt_mon_addr: |
450 | return ceph_parse_mon_addr(param, fc); | |
3d14c5d2 | 451 | case Opt_wsize: |
82995cc6 DH |
452 | if (result.uint_32 < PAGE_SIZE || |
453 | result.uint_32 > CEPH_MAX_WRITE_SIZE) | |
454 | goto out_of_range; | |
455 | fsopt->wsize = ALIGN(result.uint_32, PAGE_SIZE); | |
3d14c5d2 YS |
456 | break; |
457 | case Opt_rsize: | |
82995cc6 DH |
458 | if (result.uint_32 < PAGE_SIZE || |
459 | result.uint_32 > CEPH_MAX_READ_SIZE) | |
460 | goto out_of_range; | |
461 | fsopt->rsize = ALIGN(result.uint_32, PAGE_SIZE); | |
3d14c5d2 | 462 | break; |
83817e35 | 463 | case Opt_rasize: |
82995cc6 | 464 | fsopt->rasize = ALIGN(result.uint_32, PAGE_SIZE); |
83817e35 | 465 | break; |
3d14c5d2 | 466 | case Opt_caps_wanted_delay_min: |
82995cc6 DH |
467 | if (result.uint_32 < 1) |
468 | goto out_of_range; | |
469 | fsopt->caps_wanted_delay_min = result.uint_32; | |
3d14c5d2 YS |
470 | break; |
471 | case Opt_caps_wanted_delay_max: | |
82995cc6 DH |
472 | if (result.uint_32 < 1) |
473 | goto out_of_range; | |
474 | fsopt->caps_wanted_delay_max = result.uint_32; | |
3d14c5d2 | 475 | break; |
fe33032d | 476 | case Opt_caps_max: |
ad8c28a9 JL |
477 | if (result.int_32 < 0) |
478 | goto out_of_range; | |
479 | fsopt->caps_max = result.int_32; | |
fe33032d | 480 | break; |
3d14c5d2 | 481 | case Opt_readdir_max_entries: |
82995cc6 DH |
482 | if (result.uint_32 < 1) |
483 | goto out_of_range; | |
484 | fsopt->max_readdir = result.uint_32; | |
3d14c5d2 YS |
485 | break; |
486 | case Opt_readdir_max_bytes: | |
82995cc6 DH |
487 | if (result.uint_32 < PAGE_SIZE && result.uint_32 != 0) |
488 | goto out_of_range; | |
489 | fsopt->max_readdir_bytes = result.uint_32; | |
3d14c5d2 YS |
490 | break; |
491 | case Opt_congestion_kb: | |
82995cc6 DH |
492 | if (result.uint_32 < 1024) /* at least 1M */ |
493 | goto out_of_range; | |
494 | fsopt->congestion_kb = result.uint_32; | |
3d14c5d2 YS |
495 | break; |
496 | case Opt_dirstat: | |
82995cc6 DH |
497 | if (!result.negated) |
498 | fsopt->flags |= CEPH_MOUNT_OPT_DIRSTAT; | |
499 | else | |
500 | fsopt->flags &= ~CEPH_MOUNT_OPT_DIRSTAT; | |
3d14c5d2 YS |
501 | break; |
502 | case Opt_rbytes: | |
82995cc6 DH |
503 | if (!result.negated) |
504 | fsopt->flags |= CEPH_MOUNT_OPT_RBYTES; | |
505 | else | |
506 | fsopt->flags &= ~CEPH_MOUNT_OPT_RBYTES; | |
3d14c5d2 | 507 | break; |
cffaba15 | 508 | case Opt_asyncreaddir: |
82995cc6 DH |
509 | if (!result.negated) |
510 | fsopt->flags &= ~CEPH_MOUNT_OPT_NOASYNCREADDIR; | |
511 | else | |
512 | fsopt->flags |= CEPH_MOUNT_OPT_NOASYNCREADDIR; | |
3d14c5d2 | 513 | break; |
a40dc6cc | 514 | case Opt_dcache: |
82995cc6 DH |
515 | if (!result.negated) |
516 | fsopt->flags |= CEPH_MOUNT_OPT_DCACHE; | |
517 | else | |
518 | fsopt->flags &= ~CEPH_MOUNT_OPT_DCACHE; | |
a40dc6cc | 519 | break; |
ad1fee96 | 520 | case Opt_ino32: |
82995cc6 DH |
521 | if (!result.negated) |
522 | fsopt->flags |= CEPH_MOUNT_OPT_INO32; | |
523 | else | |
524 | fsopt->flags &= ~CEPH_MOUNT_OPT_INO32; | |
cffaba15 | 525 | break; |
82995cc6 | 526 | |
99ccbd22 | 527 | case Opt_fscache: |
ff29fde8 | 528 | #ifdef CONFIG_CEPH_FSCACHE |
7ae7a828 CX |
529 | kfree(fsopt->fscache_uniq); |
530 | fsopt->fscache_uniq = NULL; | |
82995cc6 DH |
531 | if (result.negated) { |
532 | fsopt->flags &= ~CEPH_MOUNT_OPT_FSCACHE; | |
533 | } else { | |
534 | fsopt->flags |= CEPH_MOUNT_OPT_FSCACHE; | |
535 | fsopt->fscache_uniq = param->string; | |
536 | param->string = NULL; | |
537 | } | |
99ccbd22 | 538 | break; |
ff29fde8 | 539 | #else |
d53d0f74 | 540 | return invalfc(fc, "fscache support is disabled"); |
ff29fde8 | 541 | #endif |
10183a69 | 542 | case Opt_poolperm: |
82995cc6 DH |
543 | if (!result.negated) |
544 | fsopt->flags &= ~CEPH_MOUNT_OPT_NOPOOLPERM; | |
545 | else | |
546 | fsopt->flags |= CEPH_MOUNT_OPT_NOPOOLPERM; | |
10183a69 | 547 | break; |
e9e427f0 | 548 | case Opt_require_active_mds: |
82995cc6 DH |
549 | if (!result.negated) |
550 | fsopt->flags &= ~CEPH_MOUNT_OPT_MOUNTWAIT; | |
551 | else | |
552 | fsopt->flags |= CEPH_MOUNT_OPT_MOUNTWAIT; | |
e9e427f0 | 553 | break; |
9122eed5 | 554 | case Opt_quotadf: |
82995cc6 DH |
555 | if (!result.negated) |
556 | fsopt->flags &= ~CEPH_MOUNT_OPT_NOQUOTADF; | |
557 | else | |
558 | fsopt->flags |= CEPH_MOUNT_OPT_NOQUOTADF; | |
9122eed5 | 559 | break; |
ea4cdc54 | 560 | case Opt_copyfrom: |
82995cc6 DH |
561 | if (!result.negated) |
562 | fsopt->flags &= ~CEPH_MOUNT_OPT_NOCOPYFROM; | |
563 | else | |
564 | fsopt->flags |= CEPH_MOUNT_OPT_NOCOPYFROM; | |
ea4cdc54 | 565 | break; |
45195e42 | 566 | case Opt_acl: |
82995cc6 DH |
567 | if (!result.negated) { |
568 | #ifdef CONFIG_CEPH_FS_POSIX_ACL | |
569 | fc->sb_flags |= SB_POSIXACL; | |
570 | #else | |
d53d0f74 | 571 | return invalfc(fc, "POSIX ACL support is disabled"); |
45195e42 | 572 | #endif |
82995cc6 DH |
573 | } else { |
574 | fc->sb_flags &= ~SB_POSIXACL; | |
575 | } | |
45195e42 | 576 | break; |
2ccb4546 JL |
577 | case Opt_wsync: |
578 | if (!result.negated) | |
579 | fsopt->flags &= ~CEPH_MOUNT_OPT_ASYNC_DIROPS; | |
580 | else | |
581 | fsopt->flags |= CEPH_MOUNT_OPT_ASYNC_DIROPS; | |
582 | break; | |
94cc0877 JL |
583 | case Opt_pagecache: |
584 | if (result.negated) | |
585 | fsopt->flags |= CEPH_MOUNT_OPT_NOPAGECACHE; | |
586 | else | |
587 | fsopt->flags &= ~CEPH_MOUNT_OPT_NOPAGECACHE; | |
588 | break; | |
03bc06c7 JL |
589 | case Opt_sparseread: |
590 | if (result.negated) | |
591 | fsopt->flags &= ~CEPH_MOUNT_OPT_SPARSEREAD; | |
592 | else | |
593 | fsopt->flags |= CEPH_MOUNT_OPT_SPARSEREAD; | |
594 | break; | |
6b5717bd JL |
595 | case Opt_test_dummy_encryption: |
596 | #ifdef CONFIG_FS_ENCRYPTION | |
597 | fscrypt_free_dummy_policy(&fsopt->dummy_enc_policy); | |
598 | ret = fscrypt_parse_test_dummy_encryption(param, | |
599 | &fsopt->dummy_enc_policy); | |
600 | if (ret == -EINVAL) { | |
601 | warnfc(fc, "Value of option \"%s\" is unrecognized", | |
602 | param->key); | |
603 | } else if (ret == -EEXIST) { | |
604 | warnfc(fc, "Conflicting test_dummy_encryption options"); | |
605 | ret = -EINVAL; | |
606 | } | |
607 | #else | |
608 | warnfc(fc, | |
609 | "FS encryption not supported: test_dummy_encryption mount option ignored"); | |
610 | #endif | |
611 | break; | |
3d14c5d2 | 612 | default: |
82995cc6 | 613 | BUG(); |
3d14c5d2 YS |
614 | } |
615 | return 0; | |
82995cc6 DH |
616 | |
617 | out_of_range: | |
d53d0f74 | 618 | return invalfc(fc, "%s out of range", param->key); |
c309f0ab | 619 | } |
16725b9d | 620 | |
3d14c5d2 | 621 | static void destroy_mount_options(struct ceph_mount_options *args) |
16725b9d | 622 | { |
3d14c5d2 | 623 | dout("destroy_mount_options %p\n", args); |
82995cc6 DH |
624 | if (!args) |
625 | return; | |
626 | ||
3d14c5d2 | 627 | kfree(args->snapdir_name); |
430afbad | 628 | kfree(args->mds_namespace); |
3f384954 | 629 | kfree(args->server_path); |
1d8f8360 | 630 | kfree(args->fscache_uniq); |
7b19b4db | 631 | kfree(args->mon_addr); |
6b5717bd | 632 | fscrypt_free_dummy_policy(&args->dummy_enc_policy); |
3d14c5d2 YS |
633 | kfree(args); |
634 | } | |
16725b9d | 635 | |
3d14c5d2 YS |
636 | static int strcmp_null(const char *s1, const char *s2) |
637 | { | |
638 | if (!s1 && !s2) | |
639 | return 0; | |
640 | if (s1 && !s2) | |
641 | return -1; | |
642 | if (!s1 && s2) | |
643 | return 1; | |
644 | return strcmp(s1, s2); | |
645 | } | |
16725b9d | 646 | |
3d14c5d2 YS |
647 | static int compare_mount_options(struct ceph_mount_options *new_fsopt, |
648 | struct ceph_options *new_opt, | |
649 | struct ceph_fs_client *fsc) | |
650 | { | |
651 | struct ceph_mount_options *fsopt1 = new_fsopt; | |
652 | struct ceph_mount_options *fsopt2 = fsc->mount_options; | |
653 | int ofs = offsetof(struct ceph_mount_options, snapdir_name); | |
654 | int ret; | |
16725b9d | 655 | |
3d14c5d2 YS |
656 | ret = memcmp(fsopt1, fsopt2, ofs); |
657 | if (ret) | |
658 | return ret; | |
659 | ||
660 | ret = strcmp_null(fsopt1->snapdir_name, fsopt2->snapdir_name); | |
430afbad YZ |
661 | if (ret) |
662 | return ret; | |
b27a939e | 663 | |
430afbad | 664 | ret = strcmp_null(fsopt1->mds_namespace, fsopt2->mds_namespace); |
3d14c5d2 YS |
665 | if (ret) |
666 | return ret; | |
4fbc0c71 | 667 | |
b27a939e | 668 | ret = strcmp_null(fsopt1->server_path, fsopt2->server_path); |
1d8f8360 YZ |
669 | if (ret) |
670 | return ret; | |
4fbc0c71 | 671 | |
1d8f8360 | 672 | ret = strcmp_null(fsopt1->fscache_uniq, fsopt2->fscache_uniq); |
3f384954 YZ |
673 | if (ret) |
674 | return ret; | |
675 | ||
7b19b4db VS |
676 | ret = strcmp_null(fsopt1->mon_addr, fsopt2->mon_addr); |
677 | if (ret) | |
678 | return ret; | |
679 | ||
3d14c5d2 YS |
680 | return ceph_compare_options(new_opt, fsc->client); |
681 | } | |
682 | ||
3d14c5d2 YS |
683 | /** |
684 | * ceph_show_options - Show mount options in /proc/mounts | |
685 | * @m: seq_file to write to | |
34c80b1d | 686 | * @root: root of that (sub)tree |
3d14c5d2 | 687 | */ |
34c80b1d | 688 | static int ceph_show_options(struct seq_file *m, struct dentry *root) |
16725b9d | 689 | { |
5995d90d | 690 | struct ceph_fs_client *fsc = ceph_sb_to_fs_client(root->d_sb); |
3d14c5d2 | 691 | struct ceph_mount_options *fsopt = fsc->mount_options; |
ff40f9ae ID |
692 | size_t pos; |
693 | int ret; | |
694 | ||
695 | /* a comma between MNT/MS and client options */ | |
696 | seq_putc(m, ','); | |
697 | pos = m->count; | |
698 | ||
02b2f549 | 699 | ret = ceph_print_client_options(m, fsc->client, false); |
ff40f9ae ID |
700 | if (ret) |
701 | return ret; | |
702 | ||
703 | /* retract our comma if no client options */ | |
704 | if (m->count == pos) | |
705 | m->count--; | |
3d14c5d2 YS |
706 | |
707 | if (fsopt->flags & CEPH_MOUNT_OPT_DIRSTAT) | |
708 | seq_puts(m, ",dirstat"); | |
133e9156 YZ |
709 | if ((fsopt->flags & CEPH_MOUNT_OPT_RBYTES)) |
710 | seq_puts(m, ",rbytes"); | |
3d14c5d2 YS |
711 | if (fsopt->flags & CEPH_MOUNT_OPT_NOASYNCREADDIR) |
712 | seq_puts(m, ",noasyncreaddir"); | |
ff7eeb82 | 713 | if ((fsopt->flags & CEPH_MOUNT_OPT_DCACHE) == 0) |
a40dc6cc | 714 | seq_puts(m, ",nodcache"); |
3619aa8b CX |
715 | if (fsopt->flags & CEPH_MOUNT_OPT_INO32) |
716 | seq_puts(m, ",ino32"); | |
1d8f8360 | 717 | if (fsopt->flags & CEPH_MOUNT_OPT_FSCACHE) { |
4d8969af | 718 | seq_show_option(m, "fsc", fsopt->fscache_uniq); |
1d8f8360 | 719 | } |
10183a69 YZ |
720 | if (fsopt->flags & CEPH_MOUNT_OPT_NOPOOLPERM) |
721 | seq_puts(m, ",nopoolperm"); | |
9122eed5 LH |
722 | if (fsopt->flags & CEPH_MOUNT_OPT_NOQUOTADF) |
723 | seq_puts(m, ",noquotadf"); | |
3d14c5d2 | 724 | |
45195e42 | 725 | #ifdef CONFIG_CEPH_FS_POSIX_ACL |
82995cc6 | 726 | if (root->d_sb->s_flags & SB_POSIXACL) |
45195e42 SW |
727 | seq_puts(m, ",acl"); |
728 | else | |
729 | seq_puts(m, ",noacl"); | |
730 | #endif | |
731 | ||
6f9718fe LH |
732 | if ((fsopt->flags & CEPH_MOUNT_OPT_NOCOPYFROM) == 0) |
733 | seq_puts(m, ",copyfrom"); | |
ea4cdc54 | 734 | |
7b19b4db VS |
735 | /* dump mds_namespace when old device syntax is in use */ |
736 | if (fsopt->mds_namespace && !fsopt->new_dev_syntax) | |
4d8969af | 737 | seq_show_option(m, "mds_namespace", fsopt->mds_namespace); |
131d7eb4 | 738 | |
7b19b4db VS |
739 | if (fsopt->mon_addr) |
740 | seq_printf(m, ",mon_addr=%s", fsopt->mon_addr); | |
741 | ||
131d7eb4 YZ |
742 | if (fsopt->flags & CEPH_MOUNT_OPT_CLEANRECOVER) |
743 | seq_show_option(m, "recover_session", "clean"); | |
744 | ||
f7a67b46 JL |
745 | if (!(fsopt->flags & CEPH_MOUNT_OPT_ASYNC_DIROPS)) |
746 | seq_puts(m, ",wsync"); | |
94cc0877 JL |
747 | if (fsopt->flags & CEPH_MOUNT_OPT_NOPAGECACHE) |
748 | seq_puts(m, ",nopagecache"); | |
03bc06c7 JL |
749 | if (fsopt->flags & CEPH_MOUNT_OPT_SPARSEREAD) |
750 | seq_puts(m, ",sparseread"); | |
94cc0877 | 751 | |
6b5717bd JL |
752 | fscrypt_show_test_dummy_encryption(m, ',', root->d_sb); |
753 | ||
6dd4940b | 754 | if (fsopt->wsize != CEPH_MAX_WRITE_SIZE) |
ad8c28a9 | 755 | seq_printf(m, ",wsize=%u", fsopt->wsize); |
aa187926 | 756 | if (fsopt->rsize != CEPH_MAX_READ_SIZE) |
ad8c28a9 | 757 | seq_printf(m, ",rsize=%u", fsopt->rsize); |
83817e35 | 758 | if (fsopt->rasize != CEPH_RASIZE_DEFAULT) |
ad8c28a9 | 759 | seq_printf(m, ",rasize=%u", fsopt->rasize); |
3d14c5d2 | 760 | if (fsopt->congestion_kb != default_congestion_kb()) |
ad8c28a9 | 761 | seq_printf(m, ",write_congestion_kb=%u", fsopt->congestion_kb); |
fe33032d YZ |
762 | if (fsopt->caps_max) |
763 | seq_printf(m, ",caps_max=%d", fsopt->caps_max); | |
3d14c5d2 | 764 | if (fsopt->caps_wanted_delay_min != CEPH_CAPS_WANTED_DELAY_MIN_DEFAULT) |
ad8c28a9 | 765 | seq_printf(m, ",caps_wanted_delay_min=%u", |
3d14c5d2 YS |
766 | fsopt->caps_wanted_delay_min); |
767 | if (fsopt->caps_wanted_delay_max != CEPH_CAPS_WANTED_DELAY_MAX_DEFAULT) | |
ad8c28a9 | 768 | seq_printf(m, ",caps_wanted_delay_max=%u", |
3d14c5d2 | 769 | fsopt->caps_wanted_delay_max); |
3d14c5d2 | 770 | if (fsopt->max_readdir != CEPH_MAX_READDIR_DEFAULT) |
ad8c28a9 | 771 | seq_printf(m, ",readdir_max_entries=%u", fsopt->max_readdir); |
3d14c5d2 | 772 | if (fsopt->max_readdir_bytes != CEPH_MAX_READDIR_BYTES_DEFAULT) |
ad8c28a9 | 773 | seq_printf(m, ",readdir_max_bytes=%u", fsopt->max_readdir_bytes); |
3d14c5d2 | 774 | if (strcmp(fsopt->snapdir_name, CEPH_SNAPDIRNAME_DEFAULT)) |
a068acf2 | 775 | seq_show_option(m, "snapdirname", fsopt->snapdir_name); |
ff40f9ae | 776 | |
3d14c5d2 | 777 | return 0; |
16725b9d SW |
778 | } |
779 | ||
780 | /* | |
3d14c5d2 YS |
781 | * handle any mon messages the standard library doesn't understand. |
782 | * return error if we don't either. | |
16725b9d | 783 | */ |
3d14c5d2 | 784 | static int extra_mon_dispatch(struct ceph_client *client, struct ceph_msg *msg) |
16725b9d | 785 | { |
3d14c5d2 YS |
786 | struct ceph_fs_client *fsc = client->private; |
787 | int type = le16_to_cpu(msg->hdr.type); | |
788 | ||
789 | switch (type) { | |
790 | case CEPH_MSG_MDS_MAP: | |
430afbad YZ |
791 | ceph_mdsc_handle_mdsmap(fsc->mdsc, msg); |
792 | return 0; | |
793 | case CEPH_MSG_FS_MAP_USER: | |
794 | ceph_mdsc_handle_fsmap(fsc->mdsc, msg); | |
3d14c5d2 | 795 | return 0; |
3d14c5d2 YS |
796 | default: |
797 | return -1; | |
798 | } | |
799 | } | |
800 | ||
801 | /* | |
802 | * create a new fs client | |
8aaff151 ID |
803 | * |
804 | * Success or not, this function consumes @fsopt and @opt. | |
3d14c5d2 | 805 | */ |
0c6d4b4e | 806 | static struct ceph_fs_client *create_fs_client(struct ceph_mount_options *fsopt, |
3d14c5d2 YS |
807 | struct ceph_options *opt) |
808 | { | |
809 | struct ceph_fs_client *fsc; | |
8aaff151 | 810 | int err; |
16725b9d | 811 | |
3d14c5d2 | 812 | fsc = kzalloc(sizeof(*fsc), GFP_KERNEL); |
8aaff151 ID |
813 | if (!fsc) { |
814 | err = -ENOMEM; | |
815 | goto fail; | |
816 | } | |
16725b9d | 817 | |
74da4a0f | 818 | fsc->client = ceph_create_client(opt, fsc); |
3d14c5d2 YS |
819 | if (IS_ERR(fsc->client)) { |
820 | err = PTR_ERR(fsc->client); | |
821 | goto fail; | |
822 | } | |
8aaff151 | 823 | opt = NULL; /* fsc->client now owns this */ |
c843d13c | 824 | |
3d14c5d2 | 825 | fsc->client->extra_mon_dispatch = extra_mon_dispatch; |
02b2f549 | 826 | ceph_set_opt(fsc->client, ABORT_ON_FULL); |
430afbad | 827 | |
d37b1d99 | 828 | if (!fsopt->mds_namespace) { |
430afbad YZ |
829 | ceph_monc_want_map(&fsc->client->monc, CEPH_SUB_MDSMAP, |
830 | 0, true); | |
831 | } else { | |
832 | ceph_monc_want_map(&fsc->client->monc, CEPH_SUB_FSMAP, | |
833 | 0, false); | |
834 | } | |
16725b9d | 835 | |
3d14c5d2 | 836 | fsc->mount_options = fsopt; |
16725b9d | 837 | |
3d14c5d2 YS |
838 | fsc->sb = NULL; |
839 | fsc->mount_state = CEPH_MOUNT_MOUNTING; | |
81f148a9 | 840 | fsc->filp_gen = 1; |
78beb0ff | 841 | fsc->have_copy_from2 = true; |
16725b9d | 842 | |
3d14c5d2 | 843 | atomic_long_set(&fsc->writeback_count, 0); |
503d4fa6 | 844 | fsc->write_congested = false; |
16725b9d SW |
845 | |
846 | err = -ENOMEM; | |
01e6acc4 TH |
847 | /* |
848 | * The number of concurrent works can be high but they don't need | |
849 | * to be processed in parallel, limit concurrency. | |
850 | */ | |
1cf89a8d YZ |
851 | fsc->inode_wq = alloc_workqueue("ceph-inode", WQ_UNBOUND, 0); |
852 | if (!fsc->inode_wq) | |
09dc9fc2 | 853 | goto fail_client; |
e3ec8d68 YZ |
854 | fsc->cap_wq = alloc_workqueue("ceph-cap", 0, 1); |
855 | if (!fsc->cap_wq) | |
1cf89a8d | 856 | goto fail_inode_wq; |
16725b9d | 857 | |
4868e537 XL |
858 | hash_init(fsc->async_unlink_conflict); |
859 | spin_lock_init(&fsc->async_unlink_conflict_lock); | |
860 | ||
18f473b3 XL |
861 | spin_lock(&ceph_fsc_lock); |
862 | list_add_tail(&fsc->metric_wakeup, &ceph_fsc_list); | |
863 | spin_unlock(&ceph_fsc_lock); | |
864 | ||
3d14c5d2 | 865 | return fsc; |
b9bfb93c | 866 | |
1cf89a8d YZ |
867 | fail_inode_wq: |
868 | destroy_workqueue(fsc->inode_wq); | |
3d14c5d2 YS |
869 | fail_client: |
870 | ceph_destroy_client(fsc->client); | |
16725b9d | 871 | fail: |
3d14c5d2 | 872 | kfree(fsc); |
8aaff151 ID |
873 | if (opt) |
874 | ceph_destroy_options(opt); | |
875 | destroy_mount_options(fsopt); | |
16725b9d SW |
876 | return ERR_PTR(err); |
877 | } | |
878 | ||
a57d9064 YZ |
879 | static void flush_fs_workqueues(struct ceph_fs_client *fsc) |
880 | { | |
1cf89a8d | 881 | flush_workqueue(fsc->inode_wq); |
e3ec8d68 | 882 | flush_workqueue(fsc->cap_wq); |
a57d9064 YZ |
883 | } |
884 | ||
0c6d4b4e | 885 | static void destroy_fs_client(struct ceph_fs_client *fsc) |
16725b9d | 886 | { |
38d46409 | 887 | doutc(fsc->client, "%p\n", fsc); |
16725b9d | 888 | |
18f473b3 XL |
889 | spin_lock(&ceph_fsc_lock); |
890 | list_del(&fsc->metric_wakeup); | |
891 | spin_unlock(&ceph_fsc_lock); | |
892 | ||
3ee5a701 | 893 | ceph_mdsc_destroy(fsc); |
1cf89a8d | 894 | destroy_workqueue(fsc->inode_wq); |
e3ec8d68 | 895 | destroy_workqueue(fsc->cap_wq); |
16725b9d | 896 | |
3d14c5d2 | 897 | destroy_mount_options(fsc->mount_options); |
5dfc589a | 898 | |
3d14c5d2 | 899 | ceph_destroy_client(fsc->client); |
16725b9d | 900 | |
3d14c5d2 | 901 | kfree(fsc); |
38d46409 | 902 | dout("%s: %p done\n", __func__, fsc); |
16725b9d SW |
903 | } |
904 | ||
0743304d | 905 | /* |
3d14c5d2 | 906 | * caches |
0743304d | 907 | */ |
3d14c5d2 YS |
908 | struct kmem_cache *ceph_inode_cachep; |
909 | struct kmem_cache *ceph_cap_cachep; | |
ab58a5a1 | 910 | struct kmem_cache *ceph_cap_snap_cachep; |
f66fd9f0 | 911 | struct kmem_cache *ceph_cap_flush_cachep; |
3d14c5d2 YS |
912 | struct kmem_cache *ceph_dentry_cachep; |
913 | struct kmem_cache *ceph_file_cachep; | |
bb48bd4d | 914 | struct kmem_cache *ceph_dir_file_cachep; |
058daab7 | 915 | struct kmem_cache *ceph_mds_request_cachep; |
a0102bda | 916 | mempool_t *ceph_wb_pagevec_pool; |
3d14c5d2 YS |
917 | |
918 | static void ceph_inode_init_once(void *foo) | |
0743304d | 919 | { |
3d14c5d2 | 920 | struct ceph_inode_info *ci = foo; |
874c8ca1 | 921 | inode_init_once(&ci->netfs.inode); |
3d14c5d2 YS |
922 | } |
923 | ||
924 | static int __init init_caches(void) | |
925 | { | |
99ccbd22 MT |
926 | int error = -ENOMEM; |
927 | ||
3d14c5d2 YS |
928 | ceph_inode_cachep = kmem_cache_create("ceph_inode_info", |
929 | sizeof(struct ceph_inode_info), | |
930 | __alignof__(struct ceph_inode_info), | |
a8922f79 CZ |
931 | SLAB_RECLAIM_ACCOUNT|SLAB_ACCOUNT, |
932 | ceph_inode_init_once); | |
d37b1d99 | 933 | if (!ceph_inode_cachep) |
3d14c5d2 YS |
934 | return -ENOMEM; |
935 | ||
a8922f79 | 936 | ceph_cap_cachep = KMEM_CACHE(ceph_cap, 0); |
d37b1d99 | 937 | if (!ceph_cap_cachep) |
3d14c5d2 | 938 | goto bad_cap; |
a8922f79 | 939 | ceph_cap_snap_cachep = KMEM_CACHE(ceph_cap_snap, 0); |
ab58a5a1 XL |
940 | if (!ceph_cap_snap_cachep) |
941 | goto bad_cap_snap; | |
f66fd9f0 | 942 | ceph_cap_flush_cachep = KMEM_CACHE(ceph_cap_flush, |
a8922f79 | 943 | SLAB_RECLAIM_ACCOUNT); |
d37b1d99 | 944 | if (!ceph_cap_flush_cachep) |
f66fd9f0 | 945 | goto bad_cap_flush; |
3d14c5d2 YS |
946 | |
947 | ceph_dentry_cachep = KMEM_CACHE(ceph_dentry_info, | |
a8922f79 | 948 | SLAB_RECLAIM_ACCOUNT); |
d37b1d99 | 949 | if (!ceph_dentry_cachep) |
3d14c5d2 YS |
950 | goto bad_dentry; |
951 | ||
a8922f79 | 952 | ceph_file_cachep = KMEM_CACHE(ceph_file_info, 0); |
d37b1d99 | 953 | if (!ceph_file_cachep) |
3d14c5d2 YS |
954 | goto bad_file; |
955 | ||
a8922f79 | 956 | ceph_dir_file_cachep = KMEM_CACHE(ceph_dir_file_info, 0); |
bb48bd4d CX |
957 | if (!ceph_dir_file_cachep) |
958 | goto bad_dir_file; | |
959 | ||
a8922f79 | 960 | ceph_mds_request_cachep = KMEM_CACHE(ceph_mds_request, 0); |
058daab7 JL |
961 | if (!ceph_mds_request_cachep) |
962 | goto bad_mds_req; | |
963 | ||
a0102bda JL |
964 | ceph_wb_pagevec_pool = mempool_create_kmalloc_pool(10, CEPH_MAX_WRITE_SIZE >> PAGE_SHIFT); |
965 | if (!ceph_wb_pagevec_pool) | |
966 | goto bad_pagevec_pool; | |
967 | ||
99ccbd22 | 968 | return 0; |
1c789249 | 969 | |
a0102bda | 970 | bad_pagevec_pool: |
400e1286 | 971 | kmem_cache_destroy(ceph_mds_request_cachep); |
058daab7 | 972 | bad_mds_req: |
bb48bd4d CX |
973 | kmem_cache_destroy(ceph_dir_file_cachep); |
974 | bad_dir_file: | |
1c789249 | 975 | kmem_cache_destroy(ceph_file_cachep); |
3d14c5d2 YS |
976 | bad_file: |
977 | kmem_cache_destroy(ceph_dentry_cachep); | |
978 | bad_dentry: | |
f66fd9f0 YZ |
979 | kmem_cache_destroy(ceph_cap_flush_cachep); |
980 | bad_cap_flush: | |
ab58a5a1 XL |
981 | kmem_cache_destroy(ceph_cap_snap_cachep); |
982 | bad_cap_snap: | |
3d14c5d2 YS |
983 | kmem_cache_destroy(ceph_cap_cachep); |
984 | bad_cap: | |
985 | kmem_cache_destroy(ceph_inode_cachep); | |
99ccbd22 | 986 | return error; |
0743304d SW |
987 | } |
988 | ||
3d14c5d2 YS |
989 | static void destroy_caches(void) |
990 | { | |
8c0a8537 KS |
991 | /* |
992 | * Make sure all delayed rcu free inodes are flushed before we | |
993 | * destroy cache. | |
994 | */ | |
995 | rcu_barrier(); | |
99ccbd22 | 996 | |
3d14c5d2 YS |
997 | kmem_cache_destroy(ceph_inode_cachep); |
998 | kmem_cache_destroy(ceph_cap_cachep); | |
ab58a5a1 | 999 | kmem_cache_destroy(ceph_cap_snap_cachep); |
f66fd9f0 | 1000 | kmem_cache_destroy(ceph_cap_flush_cachep); |
3d14c5d2 YS |
1001 | kmem_cache_destroy(ceph_dentry_cachep); |
1002 | kmem_cache_destroy(ceph_file_cachep); | |
bb48bd4d | 1003 | kmem_cache_destroy(ceph_dir_file_cachep); |
058daab7 | 1004 | kmem_cache_destroy(ceph_mds_request_cachep); |
a0102bda | 1005 | mempool_destroy(ceph_wb_pagevec_pool); |
3d14c5d2 YS |
1006 | } |
1007 | ||
50c9132d JL |
1008 | static void __ceph_umount_begin(struct ceph_fs_client *fsc) |
1009 | { | |
1010 | ceph_osdc_abort_requests(&fsc->client->osdc, -EIO); | |
1011 | ceph_mdsc_force_umount(fsc->mdsc); | |
1012 | fsc->filp_gen++; // invalidate open files | |
1013 | } | |
1014 | ||
16725b9d | 1015 | /* |
f1f565a2 | 1016 | * ceph_umount_begin - initiate forced umount. Tear down the |
3d14c5d2 | 1017 | * mount, skipping steps that may hang while waiting for server(s). |
16725b9d | 1018 | */ |
631ed4b0 | 1019 | void ceph_umount_begin(struct super_block *sb) |
16725b9d | 1020 | { |
5995d90d | 1021 | struct ceph_fs_client *fsc = ceph_sb_to_fs_client(sb); |
3d14c5d2 | 1022 | |
38d46409 | 1023 | doutc(fsc->client, "starting forced umount\n"); |
3d14c5d2 YS |
1024 | if (!fsc) |
1025 | return; | |
1026 | fsc->mount_state = CEPH_MOUNT_SHUTDOWN; | |
50c9132d | 1027 | __ceph_umount_begin(fsc); |
16725b9d SW |
1028 | } |
1029 | ||
3d14c5d2 YS |
1030 | static const struct super_operations ceph_super_ops = { |
1031 | .alloc_inode = ceph_alloc_inode, | |
cfa6d412 | 1032 | .free_inode = ceph_free_inode, |
3d14c5d2 | 1033 | .write_inode = ceph_write_inode, |
52dd0f1b | 1034 | .drop_inode = generic_delete_inode, |
87bc5b89 | 1035 | .evict_inode = ceph_evict_inode, |
3d14c5d2 YS |
1036 | .sync_fs = ceph_sync_fs, |
1037 | .put_super = ceph_put_super, | |
1038 | .show_options = ceph_show_options, | |
1039 | .statfs = ceph_statfs, | |
1040 | .umount_begin = ceph_umount_begin, | |
1041 | }; | |
1042 | ||
16725b9d SW |
1043 | /* |
1044 | * Bootstrap mount by opening the root directory. Note the mount | |
1045 | * @started time from caller, and time out if this takes too long. | |
1046 | */ | |
3d14c5d2 | 1047 | static struct dentry *open_root_dentry(struct ceph_fs_client *fsc, |
16725b9d SW |
1048 | const char *path, |
1049 | unsigned long started) | |
1050 | { | |
38d46409 | 1051 | struct ceph_client *cl = fsc->client; |
3d14c5d2 | 1052 | struct ceph_mds_client *mdsc = fsc->mdsc; |
16725b9d SW |
1053 | struct ceph_mds_request *req = NULL; |
1054 | int err; | |
1055 | struct dentry *root; | |
1056 | ||
1057 | /* open dir */ | |
38d46409 | 1058 | doutc(cl, "opening '%s'\n", path); |
16725b9d SW |
1059 | req = ceph_mdsc_create_request(mdsc, CEPH_MDS_OP_GETATTR, USE_ANY_MDS); |
1060 | if (IS_ERR(req)) | |
7e34bc52 | 1061 | return ERR_CAST(req); |
16725b9d | 1062 | req->r_path1 = kstrdup(path, GFP_NOFS); |
a149bb9a SK |
1063 | if (!req->r_path1) { |
1064 | root = ERR_PTR(-ENOMEM); | |
1065 | goto out; | |
1066 | } | |
1067 | ||
16725b9d SW |
1068 | req->r_ino1.ino = CEPH_INO_ROOT; |
1069 | req->r_ino1.snap = CEPH_NOSNAP; | |
1070 | req->r_started = started; | |
a319bf56 | 1071 | req->r_timeout = fsc->client->options->mount_timeout; |
16725b9d SW |
1072 | req->r_args.getattr.mask = cpu_to_le32(CEPH_STAT_CAP_INODE); |
1073 | req->r_num_caps = 2; | |
1074 | err = ceph_mdsc_do_request(mdsc, NULL, req); | |
1075 | if (err == 0) { | |
3c5184ef AV |
1076 | struct inode *inode = req->r_target_inode; |
1077 | req->r_target_inode = NULL; | |
38d46409 | 1078 | doutc(cl, "success\n"); |
ce2728aa YZ |
1079 | root = d_make_root(inode); |
1080 | if (!root) { | |
1081 | root = ERR_PTR(-ENOMEM); | |
1082 | goto out; | |
774ac21d | 1083 | } |
38d46409 | 1084 | doutc(cl, "success, root dentry is %p\n", root); |
16725b9d SW |
1085 | } else { |
1086 | root = ERR_PTR(err); | |
1087 | } | |
3c5184ef | 1088 | out: |
16725b9d SW |
1089 | ceph_mdsc_put_request(req); |
1090 | return root; | |
1091 | } | |
1092 | ||
6b5717bd JL |
1093 | #ifdef CONFIG_FS_ENCRYPTION |
1094 | static int ceph_apply_test_dummy_encryption(struct super_block *sb, | |
1095 | struct fs_context *fc, | |
1096 | struct ceph_mount_options *fsopt) | |
1097 | { | |
1098 | struct ceph_fs_client *fsc = sb->s_fs_info; | |
1099 | ||
1100 | if (!fscrypt_is_dummy_policy_set(&fsopt->dummy_enc_policy)) | |
1101 | return 0; | |
1102 | ||
1103 | /* No changing encryption context on remount. */ | |
1104 | if (fc->purpose == FS_CONTEXT_FOR_RECONFIGURE && | |
1105 | !fscrypt_is_dummy_policy_set(&fsc->fsc_dummy_enc_policy)) { | |
1106 | if (fscrypt_dummy_policies_equal(&fsopt->dummy_enc_policy, | |
1107 | &fsc->fsc_dummy_enc_policy)) | |
1108 | return 0; | |
1109 | errorfc(fc, "Can't set test_dummy_encryption on remount"); | |
1110 | return -EINVAL; | |
1111 | } | |
1112 | ||
1113 | /* Also make sure fsopt doesn't contain a conflicting value. */ | |
1114 | if (fscrypt_is_dummy_policy_set(&fsc->fsc_dummy_enc_policy)) { | |
1115 | if (fscrypt_dummy_policies_equal(&fsopt->dummy_enc_policy, | |
1116 | &fsc->fsc_dummy_enc_policy)) | |
1117 | return 0; | |
1118 | errorfc(fc, "Conflicting test_dummy_encryption options"); | |
1119 | return -EINVAL; | |
1120 | } | |
1121 | ||
1122 | fsc->fsc_dummy_enc_policy = fsopt->dummy_enc_policy; | |
1123 | memset(&fsopt->dummy_enc_policy, 0, sizeof(fsopt->dummy_enc_policy)); | |
1124 | ||
1125 | warnfc(fc, "test_dummy_encryption mode enabled"); | |
1126 | return 0; | |
1127 | } | |
1128 | #else | |
1129 | static int ceph_apply_test_dummy_encryption(struct super_block *sb, | |
1130 | struct fs_context *fc, | |
1131 | struct ceph_mount_options *fsopt) | |
1132 | { | |
1133 | return 0; | |
1134 | } | |
1135 | #endif | |
1136 | ||
16725b9d SW |
1137 | /* |
1138 | * mount: join the ceph cluster, and open root directory. | |
1139 | */ | |
82995cc6 DH |
1140 | static struct dentry *ceph_real_mount(struct ceph_fs_client *fsc, |
1141 | struct fs_context *fc) | |
16725b9d | 1142 | { |
38d46409 | 1143 | struct ceph_client *cl = fsc->client; |
16725b9d | 1144 | int err; |
16725b9d SW |
1145 | unsigned long started = jiffies; /* note the start time */ |
1146 | struct dentry *root; | |
1147 | ||
38d46409 | 1148 | doutc(cl, "mount start %p\n", fsc); |
3d14c5d2 | 1149 | mutex_lock(&fsc->client->mount_mutex); |
16725b9d | 1150 | |
132ca7e1 | 1151 | if (!fsc->sb->s_root) { |
b27a939e ID |
1152 | const char *path = fsc->mount_options->server_path ? |
1153 | fsc->mount_options->server_path + 1 : ""; | |
1154 | ||
132ca7e1 YZ |
1155 | err = __ceph_open_session(fsc->client, started); |
1156 | if (err < 0) | |
1157 | goto out; | |
16725b9d | 1158 | |
1d8f8360 YZ |
1159 | /* setup fscache */ |
1160 | if (fsc->mount_options->flags & CEPH_MOUNT_OPT_FSCACHE) { | |
82995cc6 | 1161 | err = ceph_fscache_register_fs(fsc, fc); |
1d8f8360 YZ |
1162 | if (err < 0) |
1163 | goto out; | |
1164 | } | |
1165 | ||
6b5717bd JL |
1166 | err = ceph_apply_test_dummy_encryption(fsc->sb, fc, |
1167 | fsc->mount_options); | |
1168 | if (err) | |
1169 | goto out; | |
1170 | ||
38d46409 | 1171 | doutc(cl, "mount opening path '%s'\n", path); |
18106734 | 1172 | |
1a829ff2 | 1173 | ceph_fs_debugfs_init(fsc); |
18106734 | 1174 | |
ce2728aa | 1175 | root = open_root_dentry(fsc, path, started); |
132ca7e1 YZ |
1176 | if (IS_ERR(root)) { |
1177 | err = PTR_ERR(root); | |
1178 | goto out; | |
1179 | } | |
ce2728aa | 1180 | fsc->sb->s_root = dget(root); |
31ca5878 GU |
1181 | } else { |
1182 | root = dget(fsc->sb->s_root); | |
3d14c5d2 | 1183 | } |
16725b9d | 1184 | |
3d14c5d2 | 1185 | fsc->mount_state = CEPH_MOUNT_MOUNTED; |
38d46409 | 1186 | doutc(cl, "mount success\n"); |
a7f9fb20 AV |
1187 | mutex_unlock(&fsc->client->mount_mutex); |
1188 | return root; | |
16725b9d | 1189 | |
132ca7e1 YZ |
1190 | out: |
1191 | mutex_unlock(&fsc->client->mount_mutex); | |
6b5717bd | 1192 | ceph_fscrypt_free_dummy_policy(fsc); |
132ca7e1 | 1193 | return ERR_PTR(err); |
16725b9d SW |
1194 | } |
1195 | ||
82995cc6 | 1196 | static int ceph_set_super(struct super_block *s, struct fs_context *fc) |
16725b9d | 1197 | { |
82995cc6 | 1198 | struct ceph_fs_client *fsc = s->s_fs_info; |
38d46409 | 1199 | struct ceph_client *cl = fsc->client; |
16725b9d SW |
1200 | int ret; |
1201 | ||
38d46409 | 1202 | doutc(cl, "%p\n", s); |
16725b9d | 1203 | |
719784ba | 1204 | s->s_maxbytes = MAX_LFS_FILESIZE; |
16725b9d | 1205 | |
7221fe4c | 1206 | s->s_xattr = ceph_xattr_handlers; |
3d14c5d2 | 1207 | fsc->sb = s; |
719784ba | 1208 | fsc->max_file_size = 1ULL << 40; /* temp value until we get mdsmap */ |
16725b9d SW |
1209 | |
1210 | s->s_op = &ceph_super_ops; | |
18fc8abd | 1211 | s->s_d_op = &ceph_dentry_ops; |
16725b9d SW |
1212 | s->s_export_op = &ceph_export_ops; |
1213 | ||
0f7cf80a | 1214 | s->s_time_gran = 1; |
028ca4db DD |
1215 | s->s_time_min = 0; |
1216 | s->s_time_max = U32_MAX; | |
f7a2d068 | 1217 | s->s_flags |= SB_NODIRATIME | SB_NOATIME; |
16725b9d | 1218 | |
2d332d5b JL |
1219 | ceph_fscrypt_set_ops(s); |
1220 | ||
82995cc6 | 1221 | ret = set_anon_super_fc(s, fc); |
16725b9d | 1222 | if (ret != 0) |
82995cc6 | 1223 | fsc->sb = NULL; |
16725b9d SW |
1224 | return ret; |
1225 | } | |
1226 | ||
1227 | /* | |
1228 | * share superblock if same fs AND options | |
1229 | */ | |
82995cc6 | 1230 | static int ceph_compare_super(struct super_block *sb, struct fs_context *fc) |
16725b9d | 1231 | { |
82995cc6 | 1232 | struct ceph_fs_client *new = fc->s_fs_info; |
3d14c5d2 YS |
1233 | struct ceph_mount_options *fsopt = new->mount_options; |
1234 | struct ceph_options *opt = new->client->options; | |
5995d90d | 1235 | struct ceph_fs_client *fsc = ceph_sb_to_fs_client(sb); |
38d46409 | 1236 | struct ceph_client *cl = fsc->client; |
16725b9d | 1237 | |
38d46409 | 1238 | doutc(cl, "%p\n", sb); |
3d14c5d2 | 1239 | |
98d0a6fb | 1240 | if (compare_mount_options(fsopt, opt, fsc)) { |
38d46409 | 1241 | doutc(cl, "monitor(s)/mount options don't match\n"); |
3d14c5d2 | 1242 | return 0; |
16725b9d | 1243 | } |
3d14c5d2 | 1244 | if ((opt->flags & CEPH_OPT_FSID) && |
98d0a6fb | 1245 | ceph_fsid_compare(&opt->fsid, &fsc->client->fsid)) { |
38d46409 | 1246 | doutc(cl, "fsid doesn't match\n"); |
3d14c5d2 YS |
1247 | return 0; |
1248 | } | |
82995cc6 | 1249 | if (fc->sb_flags != (sb->s_flags & ~SB_BORN)) { |
38d46409 | 1250 | doutc(cl, "flags differ\n"); |
16725b9d SW |
1251 | return 0; |
1252 | } | |
98d0a6fb JL |
1253 | |
1254 | if (fsc->blocklisted && !ceph_test_mount_opt(fsc, CLEANRECOVER)) { | |
38d46409 | 1255 | doutc(cl, "client is blocklisted (and CLEANRECOVER is not set)\n"); |
98d0a6fb JL |
1256 | return 0; |
1257 | } | |
1258 | ||
1259 | if (fsc->mount_state == CEPH_MOUNT_SHUTDOWN) { | |
38d46409 | 1260 | doutc(cl, "client has been forcibly unmounted\n"); |
98d0a6fb JL |
1261 | return 0; |
1262 | } | |
1263 | ||
16725b9d SW |
1264 | return 1; |
1265 | } | |
1266 | ||
1267 | /* | |
1268 | * construct our own bdi so we can control readahead, etc. | |
1269 | */ | |
00d5643e | 1270 | static atomic_long_t bdi_seq = ATOMIC_LONG_INIT(0); |
31e0cf8f | 1271 | |
09dc9fc2 | 1272 | static int ceph_setup_bdi(struct super_block *sb, struct ceph_fs_client *fsc) |
16725b9d SW |
1273 | { |
1274 | int err; | |
1275 | ||
09dc9fc2 JK |
1276 | err = super_setup_bdi_name(sb, "ceph-%ld", |
1277 | atomic_long_inc_return(&bdi_seq)); | |
1278 | if (err) | |
1279 | return err; | |
1280 | ||
83817e35 | 1281 | /* set ra_pages based on rasize mount option? */ |
4214fb15 | 1282 | sb->s_bdi->ra_pages = fsc->mount_options->rasize >> PAGE_SHIFT; |
e9852227 | 1283 | |
aa187926 YZ |
1284 | /* set io_pages based on max osd read size */ |
1285 | sb->s_bdi->io_pages = fsc->mount_options->rsize >> PAGE_SHIFT; | |
7c94ba27 | 1286 | |
09dc9fc2 | 1287 | return 0; |
16725b9d SW |
1288 | } |
1289 | ||
82995cc6 | 1290 | static int ceph_get_tree(struct fs_context *fc) |
16725b9d | 1291 | { |
82995cc6 | 1292 | struct ceph_parse_opts_ctx *pctx = fc->fs_private; |
7b19b4db | 1293 | struct ceph_mount_options *fsopt = pctx->opts; |
16725b9d | 1294 | struct super_block *sb; |
3d14c5d2 | 1295 | struct ceph_fs_client *fsc; |
a7f9fb20 | 1296 | struct dentry *res; |
82995cc6 DH |
1297 | int (*compare_super)(struct super_block *, struct fs_context *) = |
1298 | ceph_compare_super; | |
16725b9d | 1299 | int err; |
16725b9d | 1300 | |
82995cc6 DH |
1301 | dout("ceph_get_tree\n"); |
1302 | ||
1303 | if (!fc->source) | |
d53d0f74 | 1304 | return invalfc(fc, "No source"); |
7b19b4db VS |
1305 | if (fsopt->new_dev_syntax && !fsopt->mon_addr) |
1306 | return invalfc(fc, "No monitor address"); | |
45195e42 | 1307 | |
16725b9d | 1308 | /* create client (which we may/may not use) */ |
82995cc6 DH |
1309 | fsc = create_fs_client(pctx->opts, pctx->copts); |
1310 | pctx->opts = NULL; | |
1311 | pctx->copts = NULL; | |
3d14c5d2 | 1312 | if (IS_ERR(fsc)) { |
82995cc6 | 1313 | err = PTR_ERR(fsc); |
6b805185 SW |
1314 | goto out_final; |
1315 | } | |
16725b9d | 1316 | |
3d14c5d2 | 1317 | err = ceph_mdsc_init(fsc); |
82995cc6 | 1318 | if (err < 0) |
3d14c5d2 YS |
1319 | goto out; |
1320 | ||
1321 | if (ceph_test_opt(fsc->client, NOSHARE)) | |
16725b9d | 1322 | compare_super = NULL; |
82995cc6 DH |
1323 | |
1324 | fc->s_fs_info = fsc; | |
1325 | sb = sget_fc(fc, compare_super, ceph_set_super); | |
1326 | fc->s_fs_info = NULL; | |
16725b9d | 1327 | if (IS_ERR(sb)) { |
82995cc6 | 1328 | err = PTR_ERR(sb); |
16725b9d SW |
1329 | goto out; |
1330 | } | |
1331 | ||
5995d90d | 1332 | if (ceph_sb_to_fs_client(sb) != fsc) { |
3d14c5d2 | 1333 | destroy_fs_client(fsc); |
5995d90d | 1334 | fsc = ceph_sb_to_fs_client(sb); |
3d14c5d2 | 1335 | dout("get_sb got existing client %p\n", fsc); |
16725b9d | 1336 | } else { |
3d14c5d2 | 1337 | dout("get_sb using new client %p\n", fsc); |
09dc9fc2 | 1338 | err = ceph_setup_bdi(sb, fsc); |
82995cc6 | 1339 | if (err < 0) |
16725b9d SW |
1340 | goto out_splat; |
1341 | } | |
1342 | ||
82995cc6 DH |
1343 | res = ceph_real_mount(fsc, fc); |
1344 | if (IS_ERR(res)) { | |
1345 | err = PTR_ERR(res); | |
16725b9d | 1346 | goto out_splat; |
82995cc6 | 1347 | } |
38d46409 XL |
1348 | |
1349 | doutc(fsc->client, "root %p inode %p ino %llx.%llx\n", res, | |
1350 | d_inode(res), ceph_vinop(d_inode(res))); | |
82995cc6 DH |
1351 | fc->root = fsc->sb->s_root; |
1352 | return 0; | |
16725b9d SW |
1353 | |
1354 | out_splat: | |
97820058 XL |
1355 | if (!ceph_mdsmap_is_cluster_available(fsc->mdsc->mdsmap)) { |
1356 | pr_info("No mds server is up or the cluster is laggy\n"); | |
1357 | err = -EHOSTUNREACH; | |
1358 | } | |
1359 | ||
3d14c5d2 | 1360 | ceph_mdsc_close_sessions(fsc->mdsc); |
3981f2e2 | 1361 | deactivate_locked_super(sb); |
16725b9d SW |
1362 | goto out_final; |
1363 | ||
1364 | out: | |
3d14c5d2 | 1365 | destroy_fs_client(fsc); |
16725b9d | 1366 | out_final: |
82995cc6 DH |
1367 | dout("ceph_get_tree fail %d\n", err); |
1368 | return err; | |
1369 | } | |
1370 | ||
1371 | static void ceph_free_fc(struct fs_context *fc) | |
1372 | { | |
1373 | struct ceph_parse_opts_ctx *pctx = fc->fs_private; | |
1374 | ||
1375 | if (pctx) { | |
1376 | destroy_mount_options(pctx->opts); | |
1377 | ceph_destroy_options(pctx->copts); | |
1378 | kfree(pctx); | |
1379 | } | |
1380 | } | |
1381 | ||
1382 | static int ceph_reconfigure_fc(struct fs_context *fc) | |
1383 | { | |
6b5717bd | 1384 | int err; |
2ccb4546 JL |
1385 | struct ceph_parse_opts_ctx *pctx = fc->fs_private; |
1386 | struct ceph_mount_options *fsopt = pctx->opts; | |
6b5717bd | 1387 | struct super_block *sb = fc->root->d_sb; |
5995d90d | 1388 | struct ceph_fs_client *fsc = ceph_sb_to_fs_client(sb); |
6b5717bd JL |
1389 | |
1390 | err = ceph_apply_test_dummy_encryption(sb, fc, fsopt); | |
1391 | if (err) | |
1392 | return err; | |
2ccb4546 JL |
1393 | |
1394 | if (fsopt->flags & CEPH_MOUNT_OPT_ASYNC_DIROPS) | |
1395 | ceph_set_mount_opt(fsc, ASYNC_DIROPS); | |
1396 | else | |
1397 | ceph_clear_mount_opt(fsc, ASYNC_DIROPS); | |
1398 | ||
03bc06c7 JL |
1399 | if (fsopt->flags & CEPH_MOUNT_OPT_SPARSEREAD) |
1400 | ceph_set_mount_opt(fsc, SPARSEREAD); | |
1401 | else | |
1402 | ceph_clear_mount_opt(fsc, SPARSEREAD); | |
1403 | ||
2167f2cc VS |
1404 | if (strcmp_null(fsc->mount_options->mon_addr, fsopt->mon_addr)) { |
1405 | kfree(fsc->mount_options->mon_addr); | |
1406 | fsc->mount_options->mon_addr = fsopt->mon_addr; | |
1407 | fsopt->mon_addr = NULL; | |
38d46409 XL |
1408 | pr_notice_client(fsc->client, |
1409 | "monitor addresses recorded, but not used for reconnection"); | |
2167f2cc VS |
1410 | } |
1411 | ||
6b5717bd | 1412 | sync_filesystem(sb); |
82995cc6 DH |
1413 | return 0; |
1414 | } | |
1415 | ||
1416 | static const struct fs_context_operations ceph_context_ops = { | |
1417 | .free = ceph_free_fc, | |
1418 | .parse_param = ceph_parse_mount_param, | |
1419 | .get_tree = ceph_get_tree, | |
1420 | .reconfigure = ceph_reconfigure_fc, | |
1421 | }; | |
1422 | ||
1423 | /* | |
1424 | * Set up the filesystem mount context. | |
1425 | */ | |
1426 | static int ceph_init_fs_context(struct fs_context *fc) | |
1427 | { | |
1428 | struct ceph_parse_opts_ctx *pctx; | |
1429 | struct ceph_mount_options *fsopt; | |
1430 | ||
1431 | pctx = kzalloc(sizeof(*pctx), GFP_KERNEL); | |
1432 | if (!pctx) | |
1433 | return -ENOMEM; | |
1434 | ||
1435 | pctx->copts = ceph_alloc_options(); | |
1436 | if (!pctx->copts) | |
1437 | goto nomem; | |
1438 | ||
1439 | pctx->opts = kzalloc(sizeof(*pctx->opts), GFP_KERNEL); | |
1440 | if (!pctx->opts) | |
1441 | goto nomem; | |
1442 | ||
1443 | fsopt = pctx->opts; | |
1444 | fsopt->flags = CEPH_MOUNT_OPT_DEFAULT; | |
1445 | ||
1446 | fsopt->wsize = CEPH_MAX_WRITE_SIZE; | |
1447 | fsopt->rsize = CEPH_MAX_READ_SIZE; | |
1448 | fsopt->rasize = CEPH_RASIZE_DEFAULT; | |
1449 | fsopt->snapdir_name = kstrdup(CEPH_SNAPDIRNAME_DEFAULT, GFP_KERNEL); | |
1450 | if (!fsopt->snapdir_name) | |
1451 | goto nomem; | |
1452 | ||
1453 | fsopt->caps_wanted_delay_min = CEPH_CAPS_WANTED_DELAY_MIN_DEFAULT; | |
1454 | fsopt->caps_wanted_delay_max = CEPH_CAPS_WANTED_DELAY_MAX_DEFAULT; | |
1455 | fsopt->max_readdir = CEPH_MAX_READDIR_DEFAULT; | |
1456 | fsopt->max_readdir_bytes = CEPH_MAX_READDIR_BYTES_DEFAULT; | |
1457 | fsopt->congestion_kb = default_congestion_kb(); | |
1458 | ||
3b20bc2f XL |
1459 | #ifdef CONFIG_CEPH_FS_POSIX_ACL |
1460 | fc->sb_flags |= SB_POSIXACL; | |
1461 | #endif | |
1462 | ||
82995cc6 DH |
1463 | fc->fs_private = pctx; |
1464 | fc->ops = &ceph_context_ops; | |
1465 | return 0; | |
1466 | ||
1467 | nomem: | |
1468 | destroy_mount_options(pctx->opts); | |
1469 | ceph_destroy_options(pctx->copts); | |
1470 | kfree(pctx); | |
1471 | return -ENOMEM; | |
16725b9d SW |
1472 | } |
1473 | ||
e3dfcab2 XL |
1474 | /* |
1475 | * Return true if it successfully increases the blocker counter, | |
1476 | * or false if the mdsc is in stopping and flushed state. | |
1477 | */ | |
1478 | static bool __inc_stopping_blocker(struct ceph_mds_client *mdsc) | |
1479 | { | |
1480 | spin_lock(&mdsc->stopping_lock); | |
1481 | if (mdsc->stopping >= CEPH_MDSC_STOPPING_FLUSHING) { | |
1482 | spin_unlock(&mdsc->stopping_lock); | |
1483 | return false; | |
1484 | } | |
1485 | atomic_inc(&mdsc->stopping_blockers); | |
1486 | spin_unlock(&mdsc->stopping_lock); | |
1487 | return true; | |
1488 | } | |
1489 | ||
1490 | static void __dec_stopping_blocker(struct ceph_mds_client *mdsc) | |
1491 | { | |
1492 | spin_lock(&mdsc->stopping_lock); | |
1493 | if (!atomic_dec_return(&mdsc->stopping_blockers) && | |
1494 | mdsc->stopping >= CEPH_MDSC_STOPPING_FLUSHING) | |
1495 | complete_all(&mdsc->stopping_waiter); | |
1496 | spin_unlock(&mdsc->stopping_lock); | |
1497 | } | |
1498 | ||
1499 | /* For metadata IO requests */ | |
1500 | bool ceph_inc_mds_stopping_blocker(struct ceph_mds_client *mdsc, | |
1501 | struct ceph_mds_session *session) | |
1502 | { | |
1503 | mutex_lock(&session->s_mutex); | |
1504 | inc_session_sequence(session); | |
1505 | mutex_unlock(&session->s_mutex); | |
1506 | ||
1507 | return __inc_stopping_blocker(mdsc); | |
1508 | } | |
1509 | ||
1510 | void ceph_dec_mds_stopping_blocker(struct ceph_mds_client *mdsc) | |
1511 | { | |
1512 | __dec_stopping_blocker(mdsc); | |
1513 | } | |
1514 | ||
1464de9f XL |
1515 | /* For data IO requests */ |
1516 | bool ceph_inc_osd_stopping_blocker(struct ceph_mds_client *mdsc) | |
1517 | { | |
1518 | return __inc_stopping_blocker(mdsc); | |
1519 | } | |
1520 | ||
1521 | void ceph_dec_osd_stopping_blocker(struct ceph_mds_client *mdsc) | |
1522 | { | |
1523 | __dec_stopping_blocker(mdsc); | |
1524 | } | |
1525 | ||
16725b9d SW |
1526 | static void ceph_kill_sb(struct super_block *s) |
1527 | { | |
5995d90d | 1528 | struct ceph_fs_client *fsc = ceph_sb_to_fs_client(s); |
38d46409 | 1529 | struct ceph_client *cl = fsc->client; |
e3dfcab2 XL |
1530 | struct ceph_mds_client *mdsc = fsc->mdsc; |
1531 | bool wait; | |
e4d27509 | 1532 | |
38d46409 | 1533 | doutc(cl, "%p\n", s); |
e4d27509 | 1534 | |
e3dfcab2 | 1535 | ceph_mdsc_pre_umount(mdsc); |
a57d9064 YZ |
1536 | flush_fs_workqueues(fsc); |
1537 | ||
e7e607bd XL |
1538 | /* |
1539 | * Though the kill_anon_super() will finally trigger the | |
e3dfcab2 XL |
1540 | * sync_filesystem() anyway, we still need to do it here and |
1541 | * then bump the stage of shutdown. This will allow us to | |
1542 | * drop any further message, which will increase the inodes' | |
1543 | * i_count reference counters but makes no sense any more, | |
1544 | * from MDSs. | |
1545 | * | |
1546 | * Without this when evicting the inodes it may fail in the | |
1547 | * kill_anon_super(), which will trigger a warning when | |
1548 | * destroying the fscrypt keyring and then possibly trigger | |
1549 | * a further crash in ceph module when the iput() tries to | |
1550 | * evict the inodes later. | |
e7e607bd XL |
1551 | */ |
1552 | sync_filesystem(s); | |
1553 | ||
e3dfcab2 XL |
1554 | spin_lock(&mdsc->stopping_lock); |
1555 | mdsc->stopping = CEPH_MDSC_STOPPING_FLUSHING; | |
1556 | wait = !!atomic_read(&mdsc->stopping_blockers); | |
1557 | spin_unlock(&mdsc->stopping_lock); | |
1558 | ||
1559 | if (wait && atomic_read(&mdsc->stopping_blockers)) { | |
1560 | long timeleft = wait_for_completion_killable_timeout( | |
1561 | &mdsc->stopping_waiter, | |
1562 | fsc->client->options->mount_timeout); | |
1563 | if (!timeleft) /* timed out */ | |
38d46409 | 1564 | pr_warn_client(cl, "umount timed out, %ld\n", timeleft); |
e3dfcab2 | 1565 | else if (timeleft < 0) /* killed */ |
38d46409 | 1566 | pr_warn_client(cl, "umount was killed, %ld\n", timeleft); |
e3dfcab2 | 1567 | } |
e7e607bd | 1568 | |
e3dfcab2 | 1569 | mdsc->stopping = CEPH_MDSC_STOPPING_FLUSHED; |
470a5c77 | 1570 | kill_anon_super(s); |
62a65f36 YZ |
1571 | |
1572 | fsc->client->extra_mon_dispatch = NULL; | |
1573 | ceph_fs_debugfs_cleanup(fsc); | |
1574 | ||
1d8f8360 YZ |
1575 | ceph_fscache_unregister_fs(fsc); |
1576 | ||
3d14c5d2 | 1577 | destroy_fs_client(fsc); |
16725b9d SW |
1578 | } |
1579 | ||
1580 | static struct file_system_type ceph_fs_type = { | |
1581 | .owner = THIS_MODULE, | |
1582 | .name = "ceph", | |
82995cc6 | 1583 | .init_fs_context = ceph_init_fs_context, |
16725b9d | 1584 | .kill_sb = ceph_kill_sb, |
56d2e2cf | 1585 | .fs_flags = FS_RENAME_DOES_D_MOVE | FS_ALLOW_IDMAP, |
16725b9d | 1586 | }; |
7f78e035 | 1587 | MODULE_ALIAS_FS("ceph"); |
16725b9d | 1588 | |
d468e729 YZ |
1589 | int ceph_force_reconnect(struct super_block *sb) |
1590 | { | |
5995d90d | 1591 | struct ceph_fs_client *fsc = ceph_sb_to_fs_client(sb); |
d468e729 YZ |
1592 | int err = 0; |
1593 | ||
50c9132d JL |
1594 | fsc->mount_state = CEPH_MOUNT_RECOVER; |
1595 | __ceph_umount_begin(fsc); | |
d468e729 YZ |
1596 | |
1597 | /* Make sure all page caches get invalidated. | |
1598 | * see remove_session_caps_cb() */ | |
1599 | flush_workqueue(fsc->inode_wq); | |
1600 | ||
0b98acd6 | 1601 | /* In case that we were blocklisted. This also reset |
d468e729 YZ |
1602 | * all mon/osd connections */ |
1603 | ceph_reset_client_addr(fsc->client); | |
1604 | ||
1605 | ceph_osdc_clear_abort_err(&fsc->client->osdc); | |
131d7eb4 | 1606 | |
0b98acd6 | 1607 | fsc->blocklisted = false; |
d468e729 YZ |
1608 | fsc->mount_state = CEPH_MOUNT_MOUNTED; |
1609 | ||
1610 | if (sb->s_root) { | |
1611 | err = __ceph_do_getattr(d_inode(sb->s_root), NULL, | |
1612 | CEPH_STAT_CAP_INODE, true); | |
1613 | } | |
1614 | return err; | |
1615 | } | |
1616 | ||
16725b9d SW |
1617 | static int __init init_ceph(void) |
1618 | { | |
3d14c5d2 | 1619 | int ret = init_caches(); |
16725b9d | 1620 | if (ret) |
3d14c5d2 | 1621 | goto out; |
16725b9d | 1622 | |
eb13e832 | 1623 | ceph_flock_init(); |
16725b9d SW |
1624 | ret = register_filesystem(&ceph_fs_type); |
1625 | if (ret) | |
d0f191d2 | 1626 | goto out_caches; |
16725b9d | 1627 | |
3d14c5d2 YS |
1628 | pr_info("loaded (mds proto %d)\n", CEPH_MDSC_PROTOCOL); |
1629 | ||
16725b9d SW |
1630 | return 0; |
1631 | ||
d0f191d2 | 1632 | out_caches: |
16725b9d | 1633 | destroy_caches(); |
16725b9d SW |
1634 | out: |
1635 | return ret; | |
1636 | } | |
1637 | ||
1638 | static void __exit exit_ceph(void) | |
1639 | { | |
1640 | dout("exit_ceph\n"); | |
1641 | unregister_filesystem(&ceph_fs_type); | |
16725b9d | 1642 | destroy_caches(); |
16725b9d SW |
1643 | } |
1644 | ||
18f473b3 XL |
1645 | static int param_set_metrics(const char *val, const struct kernel_param *kp) |
1646 | { | |
1647 | struct ceph_fs_client *fsc; | |
1648 | int ret; | |
1649 | ||
1650 | ret = param_set_bool(val, kp); | |
1651 | if (ret) { | |
1652 | pr_err("Failed to parse sending metrics switch value '%s'\n", | |
1653 | val); | |
1654 | return ret; | |
1655 | } else if (!disable_send_metrics) { | |
1656 | // wake up all the mds clients | |
1657 | spin_lock(&ceph_fsc_lock); | |
1658 | list_for_each_entry(fsc, &ceph_fsc_list, metric_wakeup) { | |
1659 | metric_schedule_delayed(&fsc->mdsc->metric); | |
1660 | } | |
1661 | spin_unlock(&ceph_fsc_lock); | |
1662 | } | |
1663 | ||
1664 | return 0; | |
1665 | } | |
1666 | ||
1667 | static const struct kernel_param_ops param_ops_metrics = { | |
1668 | .set = param_set_metrics, | |
1669 | .get = param_get_bool, | |
1670 | }; | |
1671 | ||
1672 | bool disable_send_metrics = false; | |
1673 | module_param_cb(disable_send_metrics, ¶m_ops_metrics, &disable_send_metrics, 0644); | |
1674 | MODULE_PARM_DESC(disable_send_metrics, "Enable sending perf metrics to ceph cluster (default: on)"); | |
1675 | ||
adbed05e VS |
1676 | /* for both v1 and v2 syntax */ |
1677 | static bool mount_support = true; | |
1678 | static const struct kernel_param_ops param_ops_mount_syntax = { | |
1679 | .get = param_get_bool, | |
1680 | }; | |
1681 | module_param_cb(mount_syntax_v1, ¶m_ops_mount_syntax, &mount_support, 0444); | |
1682 | module_param_cb(mount_syntax_v2, ¶m_ops_mount_syntax, &mount_support, 0444); | |
1683 | ||
673478b6 AM |
1684 | bool enable_unsafe_idmap = false; |
1685 | module_param(enable_unsafe_idmap, bool, 0644); | |
1686 | MODULE_PARM_DESC(enable_unsafe_idmap, | |
1687 | "Allow to use idmapped mounts with MDS without CEPHFS_FEATURE_HAS_OWNER_UIDGID"); | |
1688 | ||
16725b9d SW |
1689 | module_init(init_ceph); |
1690 | module_exit(exit_ceph); | |
1691 | ||
1692 | MODULE_AUTHOR("Sage Weil <sage@newdream.net>"); | |
1693 | MODULE_AUTHOR("Yehuda Sadeh <yehuda@hq.newdream.net>"); | |
1694 | MODULE_AUTHOR("Patience Warnick <patience@newdream.net>"); | |
1695 | MODULE_DESCRIPTION("Ceph filesystem for Linux"); | |
1696 | MODULE_LICENSE("GPL"); |