?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 4.19.133
[linux/fpc-iii.git] / fs / ceph / super.c
blob18e967089aeb0d56d4b14385ce4d4b2855e1bd01
1
2 #include <linux/ceph/ceph_debug.h>
3
4 #include <linux/backing-dev.h>
5 #include <linux/ctype.h>
6 #include <linux/fs.h>
7 #include <linux/inet.h>
8 #include <linux/in6.h>
9 #include <linux/module.h>
10 #include <linux/mount.h>
11 #include <linux/parser.h>
12 #include <linux/sched.h>
13 #include <linux/seq_file.h>
14 #include <linux/slab.h>
15 #include <linux/statfs.h>
16 #include <linux/string.h>
17
18 #include "super.h"
19 #include "mds_client.h"
20 #include "cache.h"
21
22 #include <linux/ceph/ceph_features.h>
23 #include <linux/ceph/decode.h>
24 #include <linux/ceph/mon_client.h>
25 #include <linux/ceph/auth.h>
26 #include <linux/ceph/debugfs.h>
27
28 /*
29 * Ceph superblock operations
30 *
31 * Handle the basics of mounting, unmounting.
32 */
33
34 /*
35 * super ops
36 */
37 static void ceph_put_super(struct super_block *s)
38 {
39 struct ceph_fs_client *fsc = ceph_sb_to_client(s);
40
41 dout("put_super\n");
42 ceph_mdsc_close_sessions(fsc->mdsc);
43 }
44
45 static int ceph_statfs(struct dentry *dentry, struct kstatfs *buf)
46 {
47 struct ceph_fs_client *fsc = ceph_inode_to_client(d_inode(dentry));
48 struct ceph_mon_client *monc = &fsc->client->monc;
49 struct ceph_statfs st;
50 u64 fsid;
51 int err;
52 u64 data_pool;
53
54 if (fsc->mdsc->mdsmap->m_num_data_pg_pools == 1) {
55 data_pool = fsc->mdsc->mdsmap->m_data_pg_pools[0];
56 } else {
57 data_pool = CEPH_NOPOOL;
58 }
59
60 dout("statfs\n");
61 err = ceph_monc_do_statfs(monc, data_pool, &st);
62 if (err < 0)
63 return err;
64
65 /* fill in kstatfs */
66 buf->f_type = CEPH_SUPER_MAGIC; /* ?? */
67
68 /*
69 * express utilization in terms of large blocks to avoid
70 * overflow on 32-bit machines.
71 *
72 * NOTE: for the time being, we make bsize == frsize to humor
73 * not-yet-ancient versions of glibc that are broken.
74 * Someday, we will probably want to report a real block
75 * size... whatever that may mean for a network file system!
76 */
77 buf->f_bsize = 1 << CEPH_BLOCK_SHIFT;
78 buf->f_frsize = 1 << CEPH_BLOCK_SHIFT;
79
80 /*
81 * By default use root quota for stats; fallback to overall filesystem
82 * usage if using 'noquotadf' mount option or if the root dir doesn't
83 * have max_bytes quota set.
84 */
85 if (ceph_test_mount_opt(fsc, NOQUOTADF) ||
86 !ceph_quota_update_statfs(fsc, buf)) {
87 buf->f_blocks = le64_to_cpu(st.kb) >> (CEPH_BLOCK_SHIFT-10);
88 buf->f_bfree = le64_to_cpu(st.kb_avail) >> (CEPH_BLOCK_SHIFT-10);
89 buf->f_bavail = le64_to_cpu(st.kb_avail) >> (CEPH_BLOCK_SHIFT-10);
90 }
91
92 buf->f_files = le64_to_cpu(st.num_objects);
93 buf->f_ffree = -1;
94 buf->f_namelen = NAME_MAX;
95
96 /* Must convert the fsid, for consistent values across arches */
97 mutex_lock(&monc->mutex);
98 fsid = le64_to_cpu(*(__le64 *)(&monc->monmap->fsid)) ^
99 le64_to_cpu(*((__le64 *)&monc->monmap->fsid + 1));
100 mutex_unlock(&monc->mutex);
101
102 buf->f_fsid.val[0] = fsid & 0xffffffff;
103 buf->f_fsid.val[1] = fsid >> 32;
104
105 return 0;
106 }
107
108 static int ceph_sync_fs(struct super_block *sb, int wait)
109 {
110 struct ceph_fs_client *fsc = ceph_sb_to_client(sb);
111
112 if (!wait) {
113 dout("sync_fs (non-blocking)\n");
114 ceph_flush_dirty_caps(fsc->mdsc);
115 dout("sync_fs (non-blocking) done\n");
116 return 0;
117 }
118
119 dout("sync_fs (blocking)\n");
120 ceph_osdc_sync(&fsc->client->osdc);
121 ceph_mdsc_sync(fsc->mdsc);
122 dout("sync_fs (blocking) done\n");
123 return 0;
124 }
125
126 /*
127 * mount options
128 */
129 enum {
130 Opt_wsize,
131 Opt_rsize,
132 Opt_rasize,
133 Opt_caps_wanted_delay_min,
134 Opt_caps_wanted_delay_max,
135 Opt_readdir_max_entries,
136 Opt_readdir_max_bytes,
137 Opt_congestion_kb,
138 Opt_last_int,
139 /* int args above */
140 Opt_snapdirname,
141 Opt_mds_namespace,
142 Opt_fscache_uniq,
143 Opt_last_string,
144 /* string args above */
145 Opt_dirstat,
146 Opt_nodirstat,
147 Opt_rbytes,
148 Opt_norbytes,
149 Opt_asyncreaddir,
150 Opt_noasyncreaddir,
151 Opt_dcache,
152 Opt_nodcache,
153 Opt_ino32,
154 Opt_noino32,
155 Opt_fscache,
156 Opt_nofscache,
157 Opt_poolperm,
158 Opt_nopoolperm,
159 Opt_require_active_mds,
160 Opt_norequire_active_mds,
161 #ifdef CONFIG_CEPH_FS_POSIX_ACL
162 Opt_acl,
163 #endif
164 Opt_noacl,
165 Opt_quotadf,
166 Opt_noquotadf,
167 };
168
169 static match_table_t fsopt_tokens = {
170 {Opt_wsize, "wsize=%d"},
171 {Opt_rsize, "rsize=%d"},
172 {Opt_rasize, "rasize=%d"},
173 {Opt_caps_wanted_delay_min, "caps_wanted_delay_min=%d"},
174 {Opt_caps_wanted_delay_max, "caps_wanted_delay_max=%d"},
175 {Opt_readdir_max_entries, "readdir_max_entries=%d"},
176 {Opt_readdir_max_bytes, "readdir_max_bytes=%d"},
177 {Opt_congestion_kb, "write_congestion_kb=%d"},
178 /* int args above */
179 {Opt_snapdirname, "snapdirname=%s"},
180 {Opt_mds_namespace, "mds_namespace=%s"},
181 {Opt_fscache_uniq, "fsc=%s"},
182 /* string args above */
183 {Opt_dirstat, "dirstat"},
184 {Opt_nodirstat, "nodirstat"},
185 {Opt_rbytes, "rbytes"},
186 {Opt_norbytes, "norbytes"},
187 {Opt_asyncreaddir, "asyncreaddir"},
188 {Opt_noasyncreaddir, "noasyncreaddir"},
189 {Opt_dcache, "dcache"},
190 {Opt_nodcache, "nodcache"},
191 {Opt_ino32, "ino32"},
192 {Opt_noino32, "noino32"},
193 {Opt_fscache, "fsc"},
194 {Opt_nofscache, "nofsc"},
195 {Opt_poolperm, "poolperm"},
196 {Opt_nopoolperm, "nopoolperm"},
197 {Opt_require_active_mds, "require_active_mds"},
198 {Opt_norequire_active_mds, "norequire_active_mds"},
199 #ifdef CONFIG_CEPH_FS_POSIX_ACL
200 {Opt_acl, "acl"},
201 #endif
202 {Opt_noacl, "noacl"},
203 {Opt_quotadf, "quotadf"},
204 {Opt_noquotadf, "noquotadf"},
205 {-1, NULL}
206 };
207
208 /*
209 * Remove adjacent slashes and then the trailing slash, unless it is
210 * the only remaining character.
211 *
212 * E.g. "//dir1////dir2///" --> "/dir1/dir2", "///" --> "/".
213 */
214 static void canonicalize_path(char *path)
215 {
216 int i, j = 0;
217
218 for (i = 0; path[i] != '\0'; i++) {
219 if (path[i] != '/' || j < 1 || path[j - 1] != '/')
220 path[j++] = path[i];
221 }
222
223 if (j > 1 && path[j - 1] == '/')
224 j--;
225 path[j] = '\0';
226 }
227
228 static int parse_fsopt_token(char *c, void *private)
229 {
230 struct ceph_mount_options *fsopt = private;
231 substring_t argstr[MAX_OPT_ARGS];
232 int token, intval, ret;
233
234 token = match_token((char *)c, fsopt_tokens, argstr);
235 if (token < 0)
236 return -EINVAL;
237
238 if (token < Opt_last_int) {
239 ret = match_int(&argstr[0], &intval);
240 if (ret < 0) {
241 pr_err("bad option arg (not int) at '%s'\n", c);
242 return ret;
243 }
244 dout("got int token %d val %d\n", token, intval);
245 } else if (token > Opt_last_int && token < Opt_last_string) {
246 dout("got string token %d val %s\n", token,
247 argstr[0].from);
248 } else {
249 dout("got token %d\n", token);
250 }
251
252 switch (token) {
253 case Opt_snapdirname:
254 kfree(fsopt->snapdir_name);
255 fsopt->snapdir_name = kstrndup(argstr[0].from,
256 argstr[0].to-argstr[0].from,
257 GFP_KERNEL);
258 if (!fsopt->snapdir_name)
259 return -ENOMEM;
260 break;
261 case Opt_mds_namespace:
262 kfree(fsopt->mds_namespace);
263 fsopt->mds_namespace = kstrndup(argstr[0].from,
264 argstr[0].to-argstr[0].from,
265 GFP_KERNEL);
266 if (!fsopt->mds_namespace)
267 return -ENOMEM;
268 break;
269 case Opt_fscache_uniq:
270 #ifdef CONFIG_CEPH_FSCACHE
271 kfree(fsopt->fscache_uniq);
272 fsopt->fscache_uniq = kstrndup(argstr[0].from,
273 argstr[0].to-argstr[0].from,
274 GFP_KERNEL);
275 if (!fsopt->fscache_uniq)
276 return -ENOMEM;
277 fsopt->flags |= CEPH_MOUNT_OPT_FSCACHE;
278 break;
279 #else
280 pr_err("fscache support is disabled\n");
281 return -EINVAL;
282 #endif
283 case Opt_wsize:
284 if (intval < (int)PAGE_SIZE || intval > CEPH_MAX_WRITE_SIZE)
285 return -EINVAL;
286 fsopt->wsize = ALIGN(intval, PAGE_SIZE);
287 break;
288 case Opt_rsize:
289 if (intval < (int)PAGE_SIZE || intval > CEPH_MAX_READ_SIZE)
290 return -EINVAL;
291 fsopt->rsize = ALIGN(intval, PAGE_SIZE);
292 break;
293 case Opt_rasize:
294 if (intval < 0)
295 return -EINVAL;
296 fsopt->rasize = ALIGN(intval, PAGE_SIZE);
297 break;
298 case Opt_caps_wanted_delay_min:
299 if (intval < 1)
300 return -EINVAL;
301 fsopt->caps_wanted_delay_min = intval;
302 break;
303 case Opt_caps_wanted_delay_max:
304 if (intval < 1)
305 return -EINVAL;
306 fsopt->caps_wanted_delay_max = intval;
307 break;
308 case Opt_readdir_max_entries:
309 if (intval < 1)
310 return -EINVAL;
311 fsopt->max_readdir = intval;
312 break;
313 case Opt_readdir_max_bytes:
314 if (intval < (int)PAGE_SIZE && intval != 0)
315 return -EINVAL;
316 fsopt->max_readdir_bytes = intval;
317 break;
318 case Opt_congestion_kb:
319 if (intval < 1024) /* at least 1M */
320 return -EINVAL;
321 fsopt->congestion_kb = intval;
322 break;
323 case Opt_dirstat:
324 fsopt->flags |= CEPH_MOUNT_OPT_DIRSTAT;
325 break;
326 case Opt_nodirstat:
327 fsopt->flags &= ~CEPH_MOUNT_OPT_DIRSTAT;
328 break;
329 case Opt_rbytes:
330 fsopt->flags |= CEPH_MOUNT_OPT_RBYTES;
331 break;
332 case Opt_norbytes:
333 fsopt->flags &= ~CEPH_MOUNT_OPT_RBYTES;
334 break;
335 case Opt_asyncreaddir:
336 fsopt->flags &= ~CEPH_MOUNT_OPT_NOASYNCREADDIR;
337 break;
338 case Opt_noasyncreaddir:
339 fsopt->flags |= CEPH_MOUNT_OPT_NOASYNCREADDIR;
340 break;
341 case Opt_dcache:
342 fsopt->flags |= CEPH_MOUNT_OPT_DCACHE;
343 break;
344 case Opt_nodcache:
345 fsopt->flags &= ~CEPH_MOUNT_OPT_DCACHE;
346 break;
347 case Opt_ino32:
348 fsopt->flags |= CEPH_MOUNT_OPT_INO32;
349 break;
350 case Opt_noino32:
351 fsopt->flags &= ~CEPH_MOUNT_OPT_INO32;
352 break;
353 case Opt_fscache:
354 #ifdef CONFIG_CEPH_FSCACHE
355 fsopt->flags |= CEPH_MOUNT_OPT_FSCACHE;
356 kfree(fsopt->fscache_uniq);
357 fsopt->fscache_uniq = NULL;
358 break;
359 #else
360 pr_err("fscache support is disabled\n");
361 return -EINVAL;
362 #endif
363 case Opt_nofscache:
364 fsopt->flags &= ~CEPH_MOUNT_OPT_FSCACHE;
365 kfree(fsopt->fscache_uniq);
366 fsopt->fscache_uniq = NULL;
367 break;
368 case Opt_poolperm:
369 fsopt->flags &= ~CEPH_MOUNT_OPT_NOPOOLPERM;
370 break;
371 case Opt_nopoolperm:
372 fsopt->flags |= CEPH_MOUNT_OPT_NOPOOLPERM;
373 break;
374 case Opt_require_active_mds:
375 fsopt->flags &= ~CEPH_MOUNT_OPT_MOUNTWAIT;
376 break;
377 case Opt_norequire_active_mds:
378 fsopt->flags |= CEPH_MOUNT_OPT_MOUNTWAIT;
379 break;
380 case Opt_quotadf:
381 fsopt->flags &= ~CEPH_MOUNT_OPT_NOQUOTADF;
382 break;
383 case Opt_noquotadf:
384 fsopt->flags |= CEPH_MOUNT_OPT_NOQUOTADF;
385 break;
386 #ifdef CONFIG_CEPH_FS_POSIX_ACL
387 case Opt_acl:
388 fsopt->sb_flags |= SB_POSIXACL;
389 break;
390 #endif
391 case Opt_noacl:
392 fsopt->sb_flags &= ~SB_POSIXACL;
393 break;
394 default:
395 BUG_ON(token);
396 }
397 return 0;
398 }
399
400 static void destroy_mount_options(struct ceph_mount_options *args)
401 {
402 dout("destroy_mount_options %p\n", args);
403 kfree(args->snapdir_name);
404 kfree(args->mds_namespace);
405 kfree(args->server_path);
406 kfree(args->fscache_uniq);
407 kfree(args);
408 }
409
410 static int strcmp_null(const char *s1, const char *s2)
411 {
412 if (!s1 && !s2)
413 return 0;
414 if (s1 && !s2)
415 return -1;
416 if (!s1 && s2)
417 return 1;
418 return strcmp(s1, s2);
419 }
420
421 static int compare_mount_options(struct ceph_mount_options *new_fsopt,
422 struct ceph_options *new_opt,
423 struct ceph_fs_client *fsc)
424 {
425 struct ceph_mount_options *fsopt1 = new_fsopt;
426 struct ceph_mount_options *fsopt2 = fsc->mount_options;
427 int ofs = offsetof(struct ceph_mount_options, snapdir_name);
428 int ret;
429
430 ret = memcmp(fsopt1, fsopt2, ofs);
431 if (ret)
432 return ret;
433
434 ret = strcmp_null(fsopt1->snapdir_name, fsopt2->snapdir_name);
435 if (ret)
436 return ret;
437
438 ret = strcmp_null(fsopt1->mds_namespace, fsopt2->mds_namespace);
439 if (ret)
440 return ret;
441
442 ret = strcmp_null(fsopt1->server_path, fsopt2->server_path);
443 if (ret)
444 return ret;
445
446 ret = strcmp_null(fsopt1->fscache_uniq, fsopt2->fscache_uniq);
447 if (ret)
448 return ret;
449
450 return ceph_compare_options(new_opt, fsc->client);
451 }
452
453 static int parse_mount_options(struct ceph_mount_options **pfsopt,
454 struct ceph_options **popt,
455 int flags, char *options,
456 const char *dev_name)
457 {
458 struct ceph_mount_options *fsopt;
459 const char *dev_name_end;
460 int err;
461
462 if (!dev_name || !*dev_name)
463 return -EINVAL;
464
465 fsopt = kzalloc(sizeof(*fsopt), GFP_KERNEL);
466 if (!fsopt)
467 return -ENOMEM;
468
469 dout("parse_mount_options %p, dev_name '%s'\n", fsopt, dev_name);
470
471 fsopt->sb_flags = flags;
472 fsopt->flags = CEPH_MOUNT_OPT_DEFAULT;
473
474 fsopt->wsize = CEPH_MAX_WRITE_SIZE;
475 fsopt->rsize = CEPH_MAX_READ_SIZE;
476 fsopt->rasize = CEPH_RASIZE_DEFAULT;
477 fsopt->snapdir_name = kstrdup(CEPH_SNAPDIRNAME_DEFAULT, GFP_KERNEL);
478 if (!fsopt->snapdir_name) {
479 err = -ENOMEM;
480 goto out;
481 }
482
483 fsopt->caps_wanted_delay_min = CEPH_CAPS_WANTED_DELAY_MIN_DEFAULT;
484 fsopt->caps_wanted_delay_max = CEPH_CAPS_WANTED_DELAY_MAX_DEFAULT;
485 fsopt->max_readdir = CEPH_MAX_READDIR_DEFAULT;
486 fsopt->max_readdir_bytes = CEPH_MAX_READDIR_BYTES_DEFAULT;
487 fsopt->congestion_kb = default_congestion_kb();
488
489 /*
490 * Distinguish the server list from the path in "dev_name".
491 * Internally we do not include the leading '/' in the path.
492 *
493 * "dev_name" will look like:
494 * <server_spec>[,<server_spec>...]:[<path>]
495 * where
496 * <server_spec> is <ip>[:<port>]
497 * <path> is optional, but if present must begin with '/'
498 */
499 dev_name_end = strchr(dev_name, '/');
500 if (dev_name_end) {
501 /*
502 * The server_path will include the whole chars from userland
503 * including the leading '/'.
504 */
505 fsopt->server_path = kstrdup(dev_name_end, GFP_KERNEL);
506 if (!fsopt->server_path) {
507 err = -ENOMEM;
508 goto out;
509 }
510
511 canonicalize_path(fsopt->server_path);
512 } else {
513 dev_name_end = dev_name + strlen(dev_name);
514 }
515 err = -EINVAL;
516 dev_name_end--; /* back up to ':' separator */
517 if (dev_name_end < dev_name || *dev_name_end != ':') {
518 pr_err("device name is missing path (no : separator in %s)\n",
519 dev_name);
520 goto out;
521 }
522 dout("device name '%.*s'\n", (int)(dev_name_end - dev_name), dev_name);
523 if (fsopt->server_path)
524 dout("server path '%s'\n", fsopt->server_path);
525
526 *popt = ceph_parse_options(options, dev_name, dev_name_end,
527 parse_fsopt_token, (void *)fsopt);
528 if (IS_ERR(*popt)) {
529 err = PTR_ERR(*popt);
530 goto out;
531 }
532
533 /* success */
534 *pfsopt = fsopt;
535 return 0;
536
537 out:
538 destroy_mount_options(fsopt);
539 return err;
540 }
541
542 /**
543 * ceph_show_options - Show mount options in /proc/mounts
544 * @m: seq_file to write to
545 * @root: root of that (sub)tree
546 */
547 static int ceph_show_options(struct seq_file *m, struct dentry *root)
548 {
549 struct ceph_fs_client *fsc = ceph_sb_to_client(root->d_sb);
550 struct ceph_mount_options *fsopt = fsc->mount_options;
551 size_t pos;
552 int ret;
553
554 /* a comma between MNT/MS and client options */
555 seq_putc(m, ',');
556 pos = m->count;
557
558 ret = ceph_print_client_options(m, fsc->client);
559 if (ret)
560 return ret;
561
562 /* retract our comma if no client options */
563 if (m->count == pos)
564 m->count--;
565
566 if (fsopt->flags & CEPH_MOUNT_OPT_DIRSTAT)
567 seq_puts(m, ",dirstat");
568 if ((fsopt->flags & CEPH_MOUNT_OPT_RBYTES))
569 seq_puts(m, ",rbytes");
570 if (fsopt->flags & CEPH_MOUNT_OPT_NOASYNCREADDIR)
571 seq_puts(m, ",noasyncreaddir");
572 if ((fsopt->flags & CEPH_MOUNT_OPT_DCACHE) == 0)
573 seq_puts(m, ",nodcache");
574 if (fsopt->flags & CEPH_MOUNT_OPT_INO32)
575 seq_puts(m, ",ino32");
576 if (fsopt->flags & CEPH_MOUNT_OPT_FSCACHE) {
577 seq_show_option(m, "fsc", fsopt->fscache_uniq);
578 }
579 if (fsopt->flags & CEPH_MOUNT_OPT_NOPOOLPERM)
580 seq_puts(m, ",nopoolperm");
581 if (fsopt->flags & CEPH_MOUNT_OPT_NOQUOTADF)
582 seq_puts(m, ",noquotadf");
583
584 #ifdef CONFIG_CEPH_FS_POSIX_ACL
585 if (fsopt->sb_flags & SB_POSIXACL)
586 seq_puts(m, ",acl");
587 else
588 seq_puts(m, ",noacl");
589 #endif
590
591 if (fsopt->mds_namespace)
592 seq_show_option(m, "mds_namespace", fsopt->mds_namespace);
593 if (fsopt->wsize != CEPH_MAX_WRITE_SIZE)
594 seq_printf(m, ",wsize=%d", fsopt->wsize);
595 if (fsopt->rsize != CEPH_MAX_READ_SIZE)
596 seq_printf(m, ",rsize=%d", fsopt->rsize);
597 if (fsopt->rasize != CEPH_RASIZE_DEFAULT)
598 seq_printf(m, ",rasize=%d", fsopt->rasize);
599 if (fsopt->congestion_kb != default_congestion_kb())
600 seq_printf(m, ",write_congestion_kb=%d", fsopt->congestion_kb);
601 if (fsopt->caps_wanted_delay_min != CEPH_CAPS_WANTED_DELAY_MIN_DEFAULT)
602 seq_printf(m, ",caps_wanted_delay_min=%d",
603 fsopt->caps_wanted_delay_min);
604 if (fsopt->caps_wanted_delay_max != CEPH_CAPS_WANTED_DELAY_MAX_DEFAULT)
605 seq_printf(m, ",caps_wanted_delay_max=%d",
606 fsopt->caps_wanted_delay_max);
607 if (fsopt->max_readdir != CEPH_MAX_READDIR_DEFAULT)
608 seq_printf(m, ",readdir_max_entries=%d", fsopt->max_readdir);
609 if (fsopt->max_readdir_bytes != CEPH_MAX_READDIR_BYTES_DEFAULT)
610 seq_printf(m, ",readdir_max_bytes=%d", fsopt->max_readdir_bytes);
611 if (strcmp(fsopt->snapdir_name, CEPH_SNAPDIRNAME_DEFAULT))
612 seq_show_option(m, "snapdirname", fsopt->snapdir_name);
613
614 return 0;
615 }
616
617 /*
618 * handle any mon messages the standard library doesn't understand.
619 * return error if we don't either.
620 */
621 static int extra_mon_dispatch(struct ceph_client *client, struct ceph_msg *msg)
622 {
623 struct ceph_fs_client *fsc = client->private;
624 int type = le16_to_cpu(msg->hdr.type);
625
626 switch (type) {
627 case CEPH_MSG_MDS_MAP:
628 ceph_mdsc_handle_mdsmap(fsc->mdsc, msg);
629 return 0;
630 case CEPH_MSG_FS_MAP_USER:
631 ceph_mdsc_handle_fsmap(fsc->mdsc, msg);
632 return 0;
633 default:
634 return -1;
635 }
636 }
637
638 /*
639 * create a new fs client
640 *
641 * Success or not, this function consumes @fsopt and @opt.
642 */
643 static struct ceph_fs_client *create_fs_client(struct ceph_mount_options *fsopt,
644 struct ceph_options *opt)
645 {
646 struct ceph_fs_client *fsc;
647 int page_count;
648 size_t size;
649 int err;
650
651 fsc = kzalloc(sizeof(*fsc), GFP_KERNEL);
652 if (!fsc) {
653 err = -ENOMEM;
654 goto fail;
655 }
656
657 fsc->client = ceph_create_client(opt, fsc);
658 if (IS_ERR(fsc->client)) {
659 err = PTR_ERR(fsc->client);
660 goto fail;
661 }
662 opt = NULL; /* fsc->client now owns this */
663
664 fsc->client->extra_mon_dispatch = extra_mon_dispatch;
665 fsc->client->osdc.abort_on_full = true;
666
667 if (!fsopt->mds_namespace) {
668 ceph_monc_want_map(&fsc->client->monc, CEPH_SUB_MDSMAP,
669 0, true);
670 } else {
671 ceph_monc_want_map(&fsc->client->monc, CEPH_SUB_FSMAP,
672 0, false);
673 }
674
675 fsc->mount_options = fsopt;
676
677 fsc->sb = NULL;
678 fsc->mount_state = CEPH_MOUNT_MOUNTING;
679
680 atomic_long_set(&fsc->writeback_count, 0);
681
682 err = -ENOMEM;
683 /*
684 * The number of concurrent works can be high but they don't need
685 * to be processed in parallel, limit concurrency.
686 */
687 fsc->wb_wq = alloc_workqueue("ceph-writeback", 0, 1);
688 if (!fsc->wb_wq)
689 goto fail_client;
690 fsc->pg_inv_wq = alloc_workqueue("ceph-pg-invalid", 0, 1);
691 if (!fsc->pg_inv_wq)
692 goto fail_wb_wq;
693 fsc->trunc_wq = alloc_workqueue("ceph-trunc", 0, 1);
694 if (!fsc->trunc_wq)
695 goto fail_pg_inv_wq;
696
697 /* set up mempools */
698 err = -ENOMEM;
699 page_count = fsc->mount_options->wsize >> PAGE_SHIFT;
700 size = sizeof (struct page *) * (page_count ? page_count : 1);
701 fsc->wb_pagevec_pool = mempool_create_kmalloc_pool(10, size);
702 if (!fsc->wb_pagevec_pool)
703 goto fail_trunc_wq;
704
705 /* caps */
706 fsc->min_caps = fsopt->max_readdir;
707
708 return fsc;
709
710 fail_trunc_wq:
711 destroy_workqueue(fsc->trunc_wq);
712 fail_pg_inv_wq:
713 destroy_workqueue(fsc->pg_inv_wq);
714 fail_wb_wq:
715 destroy_workqueue(fsc->wb_wq);
716 fail_client:
717 ceph_destroy_client(fsc->client);
718 fail:
719 kfree(fsc);
720 if (opt)
721 ceph_destroy_options(opt);
722 destroy_mount_options(fsopt);
723 return ERR_PTR(err);
724 }
725
726 static void flush_fs_workqueues(struct ceph_fs_client *fsc)
727 {
728 flush_workqueue(fsc->wb_wq);
729 flush_workqueue(fsc->pg_inv_wq);
730 flush_workqueue(fsc->trunc_wq);
731 }
732
733 static void destroy_fs_client(struct ceph_fs_client *fsc)
734 {
735 dout("destroy_fs_client %p\n", fsc);
736
737 destroy_workqueue(fsc->wb_wq);
738 destroy_workqueue(fsc->pg_inv_wq);
739 destroy_workqueue(fsc->trunc_wq);
740
741 mempool_destroy(fsc->wb_pagevec_pool);
742
743 destroy_mount_options(fsc->mount_options);
744
745 ceph_destroy_client(fsc->client);
746
747 kfree(fsc);
748 dout("destroy_fs_client %p done\n", fsc);
749 }
750
751 /*
752 * caches
753 */
754 struct kmem_cache *ceph_inode_cachep;
755 struct kmem_cache *ceph_cap_cachep;
756 struct kmem_cache *ceph_cap_flush_cachep;
757 struct kmem_cache *ceph_dentry_cachep;
758 struct kmem_cache *ceph_file_cachep;
759 struct kmem_cache *ceph_dir_file_cachep;
760
761 static void ceph_inode_init_once(void *foo)
762 {
763 struct ceph_inode_info *ci = foo;
764 inode_init_once(&ci->vfs_inode);
765 }
766
767 static int __init init_caches(void)
768 {
769 int error = -ENOMEM;
770
771 ceph_inode_cachep = kmem_cache_create("ceph_inode_info",
772 sizeof(struct ceph_inode_info),
773 __alignof__(struct ceph_inode_info),
774 SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD|
775 SLAB_ACCOUNT, ceph_inode_init_once);
776 if (!ceph_inode_cachep)
777 return -ENOMEM;
778
779 ceph_cap_cachep = KMEM_CACHE(ceph_cap, SLAB_MEM_SPREAD);
780 if (!ceph_cap_cachep)
781 goto bad_cap;
782 ceph_cap_flush_cachep = KMEM_CACHE(ceph_cap_flush,
783 SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD);
784 if (!ceph_cap_flush_cachep)
785 goto bad_cap_flush;
786
787 ceph_dentry_cachep = KMEM_CACHE(ceph_dentry_info,
788 SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD);
789 if (!ceph_dentry_cachep)
790 goto bad_dentry;
791
792 ceph_file_cachep = KMEM_CACHE(ceph_file_info, SLAB_MEM_SPREAD);
793 if (!ceph_file_cachep)
794 goto bad_file;
795
796 ceph_dir_file_cachep = KMEM_CACHE(ceph_dir_file_info, SLAB_MEM_SPREAD);
797 if (!ceph_dir_file_cachep)
798 goto bad_dir_file;
799
800 error = ceph_fscache_register();
801 if (error)
802 goto bad_fscache;
803
804 return 0;
805
806 bad_fscache:
807 kmem_cache_destroy(ceph_dir_file_cachep);
808 bad_dir_file:
809 kmem_cache_destroy(ceph_file_cachep);
810 bad_file:
811 kmem_cache_destroy(ceph_dentry_cachep);
812 bad_dentry:
813 kmem_cache_destroy(ceph_cap_flush_cachep);
814 bad_cap_flush:
815 kmem_cache_destroy(ceph_cap_cachep);
816 bad_cap:
817 kmem_cache_destroy(ceph_inode_cachep);
818 return error;
819 }
820
821 static void destroy_caches(void)
822 {
823 /*
824 * Make sure all delayed rcu free inodes are flushed before we
825 * destroy cache.
826 */
827 rcu_barrier();
828
829 kmem_cache_destroy(ceph_inode_cachep);
830 kmem_cache_destroy(ceph_cap_cachep);
831 kmem_cache_destroy(ceph_cap_flush_cachep);
832 kmem_cache_destroy(ceph_dentry_cachep);
833 kmem_cache_destroy(ceph_file_cachep);
834 kmem_cache_destroy(ceph_dir_file_cachep);
835
836 ceph_fscache_unregister();
837 }
838
839 /*
840 * ceph_umount_begin - initiate forced umount. Tear down down the
841 * mount, skipping steps that may hang while waiting for server(s).
842 */
843 static void ceph_umount_begin(struct super_block *sb)
844 {
845 struct ceph_fs_client *fsc = ceph_sb_to_client(sb);
846
847 dout("ceph_umount_begin - starting forced umount\n");
848 if (!fsc)
849 return;
850 fsc->mount_state = CEPH_MOUNT_SHUTDOWN;
851 ceph_osdc_abort_requests(&fsc->client->osdc, -EIO);
852 ceph_mdsc_force_umount(fsc->mdsc);
853 return;
854 }
855
856 static int ceph_remount(struct super_block *sb, int *flags, char *data)
857 {
858 sync_filesystem(sb);
859 return 0;
860 }
861
862 static const struct super_operations ceph_super_ops = {
863 .alloc_inode = ceph_alloc_inode,
864 .destroy_inode = ceph_destroy_inode,
865 .write_inode = ceph_write_inode,
866 .drop_inode = ceph_drop_inode,
867 .evict_inode = ceph_evict_inode,
868 .sync_fs = ceph_sync_fs,
869 .put_super = ceph_put_super,
870 .remount_fs = ceph_remount,
871 .show_options = ceph_show_options,
872 .statfs = ceph_statfs,
873 .umount_begin = ceph_umount_begin,
874 };
875
876 /*
877 * Bootstrap mount by opening the root directory. Note the mount
878 * @started time from caller, and time out if this takes too long.
879 */
880 static struct dentry *open_root_dentry(struct ceph_fs_client *fsc,
881 const char *path,
882 unsigned long started)
883 {
884 struct ceph_mds_client *mdsc = fsc->mdsc;
885 struct ceph_mds_request *req = NULL;
886 int err;
887 struct dentry *root;
888
889 /* open dir */
890 dout("open_root_inode opening '%s'\n", path);
891 req = ceph_mdsc_create_request(mdsc, CEPH_MDS_OP_GETATTR, USE_ANY_MDS);
892 if (IS_ERR(req))
893 return ERR_CAST(req);
894 req->r_path1 = kstrdup(path, GFP_NOFS);
895 if (!req->r_path1) {
896 root = ERR_PTR(-ENOMEM);
897 goto out;
898 }
899
900 req->r_ino1.ino = CEPH_INO_ROOT;
901 req->r_ino1.snap = CEPH_NOSNAP;
902 req->r_started = started;
903 req->r_timeout = fsc->client->options->mount_timeout;
904 req->r_args.getattr.mask = cpu_to_le32(CEPH_STAT_CAP_INODE);
905 req->r_num_caps = 2;
906 err = ceph_mdsc_do_request(mdsc, NULL, req);
907 if (err == 0) {
908 struct inode *inode = req->r_target_inode;
909 req->r_target_inode = NULL;
910 dout("open_root_inode success\n");
911 root = d_make_root(inode);
912 if (!root) {
913 root = ERR_PTR(-ENOMEM);
914 goto out;
915 }
916 dout("open_root_inode success, root dentry is %p\n", root);
917 } else {
918 root = ERR_PTR(err);
919 }
920 out:
921 ceph_mdsc_put_request(req);
922 return root;
923 }
924
925 /*
926 * mount: join the ceph cluster, and open root directory.
927 */
928 static struct dentry *ceph_real_mount(struct ceph_fs_client *fsc)
929 {
930 int err;
931 unsigned long started = jiffies; /* note the start time */
932 struct dentry *root;
933
934 dout("mount start %p\n", fsc);
935 mutex_lock(&fsc->client->mount_mutex);
936
937 if (!fsc->sb->s_root) {
938 const char *path = fsc->mount_options->server_path ?
939 fsc->mount_options->server_path + 1 : "";
940
941 err = __ceph_open_session(fsc->client, started);
942 if (err < 0)
943 goto out;
944
945 /* setup fscache */
946 if (fsc->mount_options->flags & CEPH_MOUNT_OPT_FSCACHE) {
947 err = ceph_fscache_register_fs(fsc);
948 if (err < 0)
949 goto out;
950 }
951
952 dout("mount opening path '%s'\n", path);
953
954 err = ceph_fs_debugfs_init(fsc);
955 if (err < 0)
956 goto out;
957
958 root = open_root_dentry(fsc, path, started);
959 if (IS_ERR(root)) {
960 err = PTR_ERR(root);
961 goto out;
962 }
963 fsc->sb->s_root = dget(root);
964 } else {
965 root = dget(fsc->sb->s_root);
966 }
967
968 fsc->mount_state = CEPH_MOUNT_MOUNTED;
969 dout("mount success\n");
970 mutex_unlock(&fsc->client->mount_mutex);
971 return root;
972
973 out:
974 mutex_unlock(&fsc->client->mount_mutex);
975 return ERR_PTR(err);
976 }
977
978 static int ceph_set_super(struct super_block *s, void *data)
979 {
980 struct ceph_fs_client *fsc = data;
981 int ret;
982
983 dout("set_super %p data %p\n", s, data);
984
985 s->s_flags = fsc->mount_options->sb_flags;
986 s->s_maxbytes = MAX_LFS_FILESIZE;
987
988 s->s_xattr = ceph_xattr_handlers;
989 s->s_fs_info = fsc;
990 fsc->sb = s;
991 fsc->max_file_size = 1ULL << 40; /* temp value until we get mdsmap */
992
993 s->s_op = &ceph_super_ops;
994 s->s_d_op = &ceph_dentry_ops;
995 s->s_export_op = &ceph_export_ops;
996
997 s->s_time_gran = 1000; /* 1000 ns == 1 us */
998
999 ret = set_anon_super(s, NULL); /* what is that second arg for? */
1000 if (ret != 0)
1001 goto fail;
1002
1003 return ret;
1004
1005 fail:
1006 s->s_fs_info = NULL;
1007 fsc->sb = NULL;
1008 return ret;
1009 }
1010
1011 /*
1012 * share superblock if same fs AND options
1013 */
1014 static int ceph_compare_super(struct super_block *sb, void *data)
1015 {
1016 struct ceph_fs_client *new = data;
1017 struct ceph_mount_options *fsopt = new->mount_options;
1018 struct ceph_options *opt = new->client->options;
1019 struct ceph_fs_client *other = ceph_sb_to_client(sb);
1020
1021 dout("ceph_compare_super %p\n", sb);
1022
1023 if (compare_mount_options(fsopt, opt, other)) {
1024 dout("monitor(s)/mount options don't match\n");
1025 return 0;
1026 }
1027 if ((opt->flags & CEPH_OPT_FSID) &&
1028 ceph_fsid_compare(&opt->fsid, &other->client->fsid)) {
1029 dout("fsid doesn't match\n");
1030 return 0;
1031 }
1032 if (fsopt->sb_flags != other->mount_options->sb_flags) {
1033 dout("flags differ\n");
1034 return 0;
1035 }
1036 return 1;
1037 }
1038
1039 /*
1040 * construct our own bdi so we can control readahead, etc.
1041 */
1042 static atomic_long_t bdi_seq = ATOMIC_LONG_INIT(0);
1043
1044 static int ceph_setup_bdi(struct super_block *sb, struct ceph_fs_client *fsc)
1045 {
1046 int err;
1047
1048 err = super_setup_bdi_name(sb, "ceph-%ld",
1049 atomic_long_inc_return(&bdi_seq));
1050 if (err)
1051 return err;
1052
1053 /* set ra_pages based on rasize mount option? */
1054 sb->s_bdi->ra_pages = fsc->mount_options->rasize >> PAGE_SHIFT;
1055
1056 /* set io_pages based on max osd read size */
1057 sb->s_bdi->io_pages = fsc->mount_options->rsize >> PAGE_SHIFT;
1058
1059 return 0;
1060 }
1061
1062 static struct dentry *ceph_mount(struct file_system_type *fs_type,
1063 int flags, const char *dev_name, void *data)
1064 {
1065 struct super_block *sb;
1066 struct ceph_fs_client *fsc;
1067 struct dentry *res;
1068 int err;
1069 int (*compare_super)(struct super_block *, void *) = ceph_compare_super;
1070 struct ceph_mount_options *fsopt = NULL;
1071 struct ceph_options *opt = NULL;
1072
1073 dout("ceph_mount\n");
1074
1075 #ifdef CONFIG_CEPH_FS_POSIX_ACL
1076 flags |= SB_POSIXACL;
1077 #endif
1078 err = parse_mount_options(&fsopt, &opt, flags, data, dev_name);
1079 if (err < 0) {
1080 res = ERR_PTR(err);
1081 goto out_final;
1082 }
1083
1084 /* create client (which we may/may not use) */
1085 fsc = create_fs_client(fsopt, opt);
1086 if (IS_ERR(fsc)) {
1087 res = ERR_CAST(fsc);
1088 goto out_final;
1089 }
1090
1091 err = ceph_mdsc_init(fsc);
1092 if (err < 0) {
1093 res = ERR_PTR(err);
1094 goto out;
1095 }
1096
1097 if (ceph_test_opt(fsc->client, NOSHARE))
1098 compare_super = NULL;
1099 sb = sget(fs_type, compare_super, ceph_set_super, flags, fsc);
1100 if (IS_ERR(sb)) {
1101 res = ERR_CAST(sb);
1102 goto out;
1103 }
1104
1105 if (ceph_sb_to_client(sb) != fsc) {
1106 ceph_mdsc_destroy(fsc);
1107 destroy_fs_client(fsc);
1108 fsc = ceph_sb_to_client(sb);
1109 dout("get_sb got existing client %p\n", fsc);
1110 } else {
1111 dout("get_sb using new client %p\n", fsc);
1112 err = ceph_setup_bdi(sb, fsc);
1113 if (err < 0) {
1114 res = ERR_PTR(err);
1115 goto out_splat;
1116 }
1117 }
1118
1119 res = ceph_real_mount(fsc);
1120 if (IS_ERR(res))
1121 goto out_splat;
1122 dout("root %p inode %p ino %llx.%llx\n", res,
1123 d_inode(res), ceph_vinop(d_inode(res)));
1124 return res;
1125
1126 out_splat:
1127 if (!ceph_mdsmap_is_cluster_available(fsc->mdsc->mdsmap)) {
1128 pr_info("No mds server is up or the cluster is laggy\n");
1129 err = -EHOSTUNREACH;
1130 }
1131
1132 ceph_mdsc_close_sessions(fsc->mdsc);
1133 deactivate_locked_super(sb);
1134 goto out_final;
1135
1136 out:
1137 ceph_mdsc_destroy(fsc);
1138 destroy_fs_client(fsc);
1139 out_final:
1140 dout("ceph_mount fail %ld\n", PTR_ERR(res));
1141 return res;
1142 }
1143
1144 static void ceph_kill_sb(struct super_block *s)
1145 {
1146 struct ceph_fs_client *fsc = ceph_sb_to_client(s);
1147 dev_t dev = s->s_dev;
1148
1149 dout("kill_sb %p\n", s);
1150
1151 ceph_mdsc_pre_umount(fsc->mdsc);
1152 flush_fs_workqueues(fsc);
1153
1154 generic_shutdown_super(s);
1155
1156 fsc->client->extra_mon_dispatch = NULL;
1157 ceph_fs_debugfs_cleanup(fsc);
1158
1159 ceph_fscache_unregister_fs(fsc);
1160
1161 ceph_mdsc_destroy(fsc);
1162
1163 destroy_fs_client(fsc);
1164 free_anon_bdev(dev);
1165 }
1166
1167 static struct file_system_type ceph_fs_type = {
1168 .owner = THIS_MODULE,
1169 .name = "ceph",
1170 .mount = ceph_mount,
1171 .kill_sb = ceph_kill_sb,
1172 .fs_flags = FS_RENAME_DOES_D_MOVE,
1173 };
1174 MODULE_ALIAS_FS("ceph");
1175
1176 static int __init init_ceph(void)
1177 {
1178 int ret = init_caches();
1179 if (ret)
1180 goto out;
1181
1182 ceph_flock_init();
1183 ceph_xattr_init();
1184 ret = register_filesystem(&ceph_fs_type);
1185 if (ret)
1186 goto out_xattr;
1187
1188 pr_info("loaded (mds proto %d)\n", CEPH_MDSC_PROTOCOL);
1189
1190 return 0;
1191
1192 out_xattr:
1193 ceph_xattr_exit();
1194 destroy_caches();
1195 out:
1196 return ret;
1197 }
1198
1199 static void __exit exit_ceph(void)
1200 {
1201 dout("exit_ceph\n");
1202 unregister_filesystem(&ceph_fs_type);
1203 ceph_xattr_exit();
1204 destroy_caches();
1205 }
1206
1207 module_init(init_ceph);
1208 module_exit(exit_ceph);
1209
1210 MODULE_AUTHOR("Sage Weil <sage@newdream.net>");
1211 MODULE_AUTHOR("Yehuda Sadeh <yehuda@hq.newdream.net>");
1212 MODULE_AUTHOR("Patience Warnick <patience@newdream.net>");
1213 MODULE_DESCRIPTION("Ceph filesystem for Linux");
1214 MODULE_LICENSE("GPL");
Linux with added FPC-III support