4 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 only,
8 * as published by the Free Software Foundation.
10 * This program is distributed in the hope that it will be useful, but
11 * WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * General Public License version 2 for more details (a copy is included
14 * in the LICENSE file that accompanied this code).
16 * You should have received a copy of the GNU General Public License
17 * version 2 along with this program; If not, see
18 * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
20 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
21 * CA 95054 USA or visit www.sun.com if you need additional information or
27 * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
28 * Use is subject to license terms.
30 * Copyright (c) 2011, 2012, Whamcloud, Inc.
33 * This file is part of Lustre, http://www.lustre.org/
34 * Lustre is a trademark of Sun Microsystems, Inc.
36 * lustre/obdclass/obd_mount.c
38 * Client/server mount routines
40 * Author: Nathan Rutman <nathan@clusterfs.com>
44 #define DEBUG_SUBSYSTEM S_CLASS
45 #define D_MOUNT D_SUPER|D_CONFIG /*|D_WARNING */
46 #define PRINT_CMD CDEBUG
47 #define PRINT_MASK D_SUPER|D_CONFIG
51 #include <lustre_fsfilt.h>
52 #include <obd_class.h>
53 #include <lustre/lustre_user.h>
54 #include <linux/version.h>
55 #include <lustre_log.h>
56 #include <lustre_disk.h>
57 #include <lustre_param.h>
58 #ifdef HAVE_KERNEL_LOCKED
59 #include <linux/smp_lock.h>
62 static int (*client_fill_super)(struct super_block *sb,
63 struct vfsmount *mnt) = NULL;
64 static void (*kill_super_cb)(struct super_block *sb) = NULL;
66 /*********** mount lookup *********/
68 CFS_DEFINE_MUTEX(lustre_mount_info_lock);
69 static CFS_LIST_HEAD(server_mount_info_list);
71 static struct lustre_mount_info *server_find_mount(const char *name)
74 struct lustre_mount_info *lmi;
77 cfs_list_for_each(tmp, &server_mount_info_list) {
78 lmi = cfs_list_entry(tmp, struct lustre_mount_info,
80 if (strcmp(name, lmi->lmi_name) == 0)
86 /* we must register an obd for a mount before we call the setup routine.
87 *_setup will call lustre_get_mount to get the mnt struct
88 by obd_name, since we can't pass the pointer to setup. */
89 static int server_register_mount(const char *name, struct super_block *sb,
92 struct lustre_mount_info *lmi;
98 OBD_ALLOC(lmi, sizeof(*lmi));
101 OBD_ALLOC(name_cp, strlen(name) + 1);
103 OBD_FREE(lmi, sizeof(*lmi));
106 strcpy(name_cp, name);
108 cfs_mutex_lock(&lustre_mount_info_lock);
110 if (server_find_mount(name)) {
111 cfs_mutex_unlock(&lustre_mount_info_lock);
112 OBD_FREE(lmi, sizeof(*lmi));
113 OBD_FREE(name_cp, strlen(name) + 1);
114 CERROR("Already registered %s\n", name);
117 lmi->lmi_name = name_cp;
120 cfs_list_add(&lmi->lmi_list_chain, &server_mount_info_list);
122 cfs_mutex_unlock(&lustre_mount_info_lock);
124 CDEBUG(D_MOUNT, "reg_mnt %p from %s, vfscount=%d\n",
126 lmi->lmi_mnt ? mnt_get_count(lmi->lmi_mnt) : -1);
131 /* when an obd no longer needs a mount */
132 static int server_deregister_mount(const char *name)
134 struct lustre_mount_info *lmi;
137 cfs_mutex_lock(&lustre_mount_info_lock);
138 lmi = server_find_mount(name);
140 cfs_mutex_unlock(&lustre_mount_info_lock);
141 CERROR("%s not registered\n", name);
145 CDEBUG(D_MOUNT, "dereg_mnt %p from %s, vfscount=%d\n",
147 lmi->lmi_mnt ? mnt_get_count(lmi->lmi_mnt) : -1);
149 OBD_FREE(lmi->lmi_name, strlen(lmi->lmi_name) + 1);
150 cfs_list_del(&lmi->lmi_list_chain);
151 OBD_FREE(lmi, sizeof(*lmi));
152 cfs_mutex_unlock(&lustre_mount_info_lock);
157 /* obd's look up a registered mount using their obdname. This is just
158 for initial obd setup to find the mount struct. It should not be
159 called every time you want to mntget. */
160 struct lustre_mount_info *server_get_mount(const char *name)
162 struct lustre_mount_info *lmi;
163 struct lustre_sb_info *lsi;
166 cfs_mutex_lock(&lustre_mount_info_lock);
167 lmi = server_find_mount(name);
168 cfs_mutex_unlock(&lustre_mount_info_lock);
170 CERROR("Can't find mount for %s\n", name);
173 lsi = s2lsi(lmi->lmi_sb);
175 cfs_atomic_inc(&lsi->lsi_mounts);
177 CDEBUG(D_MOUNT, "get_mnt %p from %s, refs=%d, vfscount=%d\n",
178 lmi->lmi_mnt, name, cfs_atomic_read(&lsi->lsi_mounts),
179 lmi->lmi_mnt ? mnt_get_count(lmi->lmi_mnt) - 1 : -1);
183 EXPORT_SYMBOL(server_get_mount);
186 * Used by mdt to get mount_info from obdname.
187 * There are no blocking when using the mount_info.
188 * Do not use server_get_mount for this purpose.
190 struct lustre_mount_info *server_get_mount_2(const char *name)
192 struct lustre_mount_info *lmi;
195 cfs_mutex_lock(&lustre_mount_info_lock);
196 lmi = server_find_mount(name);
197 cfs_mutex_unlock(&lustre_mount_info_lock);
199 CERROR("Can't find mount for %s\n", name);
203 EXPORT_SYMBOL(server_get_mount_2);
205 static int lustre_put_lsi(struct super_block *sb);
207 /* to be called from obd_cleanup methods */
208 int server_put_mount(const char *name, struct vfsmount *mnt)
210 struct lustre_mount_info *lmi;
211 struct lustre_sb_info *lsi;
215 cfs_mutex_lock(&lustre_mount_info_lock);
216 lmi = server_find_mount(name);
217 cfs_mutex_unlock(&lustre_mount_info_lock);
219 CERROR("Can't find mount for %s\n", name);
222 lsi = s2lsi(lmi->lmi_sb);
224 CDEBUG(D_MOUNT, "put_mnt %p from %s, refs=%d, vfscount=%d\n",
225 lmi->lmi_mnt, name, cfs_atomic_read(&lsi->lsi_mounts), count);
227 if (lustre_put_lsi(lmi->lmi_sb)) {
228 CDEBUG(D_MOUNT, "Last put of mnt %p from %s, vfscount=%d\n",
229 lmi->lmi_mnt, name, count);
230 /* last mount is the One True Mount */
232 CERROR("%s: mount busy, vfscount=%d!\n", name, count);
235 /* this obd should never need the mount again */
236 server_deregister_mount(name);
240 EXPORT_SYMBOL(server_put_mount);
242 /* Corresponding to server_get_mount_2 */
243 int server_put_mount_2(const char *name, struct vfsmount *mnt)
248 EXPORT_SYMBOL(server_put_mount_2);
250 /**************** config llog ********************/
252 /** Get a config log from the MGS and process it.
253 * This func is called for both clients and servers.
254 * Continue to process new statements appended to the logs
255 * (whenever the config lock is revoked) until lustre_end_log
257 * @param sb The superblock is used by the MGC to write to the local copy of
259 * @param logname The name of the llog to replicate from the MGS
260 * @param cfg Since the same mgc may be used to follow multiple config logs
261 * (e.g. ost1, ost2, client), the config_llog_instance keeps the state for
262 * this log, and is added to the mgc's list of logs to follow.
264 int lustre_process_log(struct super_block *sb, char *logname,
265 struct config_llog_instance *cfg)
267 struct lustre_cfg *lcfg;
268 struct lustre_cfg_bufs *bufs;
269 struct lustre_sb_info *lsi = s2lsi(sb);
270 struct obd_device *mgc = lsi->lsi_mgc;
281 /* mgc_process_config */
282 lustre_cfg_bufs_reset(bufs, mgc->obd_name);
283 lustre_cfg_bufs_set_string(bufs, 1, logname);
284 lustre_cfg_bufs_set(bufs, 2, cfg, sizeof(*cfg));
285 lustre_cfg_bufs_set(bufs, 3, &sb, sizeof(sb));
286 lcfg = lustre_cfg_new(LCFG_LOG_START, bufs);
287 rc = obd_process_config(mgc, sizeof(*lcfg), lcfg);
288 lustre_cfg_free(lcfg);
293 LCONSOLE_ERROR_MSG(0x15b, "%s: The configuration from log '%s'"
294 "failed from the MGS (%d). Make sure this "
295 "client and the MGS are running compatible "
296 "versions of Lustre.\n",
297 mgc->obd_name, logname, rc);
300 LCONSOLE_ERROR_MSG(0x15c, "%s: The configuration from log '%s' "
301 "failed (%d). This may be the result of "
302 "communication errors between this node and "
303 "the MGS, a bad configuration, or other "
304 "errors. See the syslog for more "
305 "information.\n", mgc->obd_name, logname,
308 /* class_obd_list(); */
311 EXPORT_SYMBOL(lustre_process_log);
313 /* Stop watching this config log for updates */
314 int lustre_end_log(struct super_block *sb, char *logname,
315 struct config_llog_instance *cfg)
317 struct lustre_cfg *lcfg;
318 struct lustre_cfg_bufs bufs;
319 struct lustre_sb_info *lsi = s2lsi(sb);
320 struct obd_device *mgc = lsi->lsi_mgc;
327 /* mgc_process_config */
328 lustre_cfg_bufs_reset(&bufs, mgc->obd_name);
329 lustre_cfg_bufs_set_string(&bufs, 1, logname);
331 lustre_cfg_bufs_set(&bufs, 2, cfg, sizeof(*cfg));
332 lcfg = lustre_cfg_new(LCFG_LOG_END, &bufs);
333 rc = obd_process_config(mgc, sizeof(*lcfg), lcfg);
334 lustre_cfg_free(lcfg);
337 EXPORT_SYMBOL(lustre_end_log);
339 /**************** obd start *******************/
341 /** lustre_cfg_bufs are a holdover from 1.4; we can still set these up from
342 * lctl (and do for echo cli/srv.
344 int do_lcfg(char *cfgname, lnet_nid_t nid, int cmd,
345 char *s1, char *s2, char *s3, char *s4)
347 struct lustre_cfg_bufs bufs;
348 struct lustre_cfg * lcfg = NULL;
351 CDEBUG(D_TRACE, "lcfg %s %#x %s %s %s %s\n", cfgname,
352 cmd, s1, s2, s3, s4);
354 lustre_cfg_bufs_reset(&bufs, cfgname);
356 lustre_cfg_bufs_set_string(&bufs, 1, s1);
358 lustre_cfg_bufs_set_string(&bufs, 2, s2);
360 lustre_cfg_bufs_set_string(&bufs, 3, s3);
362 lustre_cfg_bufs_set_string(&bufs, 4, s4);
364 lcfg = lustre_cfg_new(cmd, &bufs);
365 lcfg->lcfg_nid = nid;
366 rc = class_process_config(lcfg);
367 lustre_cfg_free(lcfg);
370 EXPORT_SYMBOL(do_lcfg);
372 /** Call class_attach and class_setup. These methods in turn call
373 * obd type-specific methods.
375 static int lustre_start_simple(char *obdname, char *type, char *uuid,
376 char *s1, char *s2, char *s3, char *s4)
379 CDEBUG(D_MOUNT, "Starting obd %s (typ=%s)\n", obdname, type);
381 rc = do_lcfg(obdname, 0, LCFG_ATTACH, type, uuid, 0, 0);
383 CERROR("%s attach error %d\n", obdname, rc);
386 rc = do_lcfg(obdname, 0, LCFG_SETUP, s1, s2, s3, s4);
388 CERROR("%s setup error %d\n", obdname, rc);
389 do_lcfg(obdname, 0, LCFG_DETACH, 0, 0, 0, 0);
394 /* Set up a MGS to serve startup logs */
395 static int server_start_mgs(struct super_block *sb)
397 struct lustre_sb_info *lsi = s2lsi(sb);
398 struct vfsmount *mnt = lsi->lsi_srv_mnt;
399 struct lustre_mount_info *lmi;
404 /* It is impossible to have more than 1 MGS per node, since
405 MGC wouldn't know which to connect to */
406 lmi = server_find_mount(LUSTRE_MGS_OBDNAME);
408 lsi = s2lsi(lmi->lmi_sb);
409 LCONSOLE_ERROR_MSG(0x15d, "The MGS service was already started"
414 CDEBUG(D_CONFIG, "Start MGS service %s\n", LUSTRE_MGS_OBDNAME);
416 rc = server_register_mount(LUSTRE_MGS_OBDNAME, sb, mnt);
419 rc = lustre_start_simple(LUSTRE_MGS_OBDNAME, LUSTRE_MGS_NAME,
420 LUSTRE_MGS_OBDNAME, 0, 0, 0, 0);
421 /* Do NOT call server_deregister_mount() here. This leads to
422 * inability cleanup cleanly and free lsi and other stuff when
423 * mgs calls server_put_mount() in error handling case. -umka */
427 LCONSOLE_ERROR_MSG(0x15e, "Failed to start MGS '%s' (%d). "
428 "Is the 'mgs' module loaded?\n",
429 LUSTRE_MGS_OBDNAME, rc);
433 static int server_stop_mgs(struct super_block *sb)
435 struct obd_device *obd;
439 CDEBUG(D_MOUNT, "Stop MGS service %s\n", LUSTRE_MGS_OBDNAME);
441 /* There better be only one MGS */
442 obd = class_name2obd(LUSTRE_MGS_OBDNAME);
444 CDEBUG(D_CONFIG, "mgs %s not running\n", LUSTRE_MGS_OBDNAME);
448 /* The MGS should always stop when we say so */
450 rc = class_manual_cleanup(obd);
454 CFS_DEFINE_MUTEX(mgc_start_lock);
456 /** Set up a mgc obd to process startup logs
458 * \param sb [in] super block of the mgc obd
460 * \retval 0 success, otherwise error code
462 static int lustre_start_mgc(struct super_block *sb)
464 struct obd_connect_data *data = NULL;
465 struct lustre_sb_info *lsi = s2lsi(sb);
466 struct obd_device *obd;
467 struct obd_export *exp;
468 struct obd_uuid *uuid;
471 char *mgcname = NULL, *niduuid = NULL, *mgssec = NULL;
474 int rc = 0, i = 0, j, len;
477 LASSERT(lsi->lsi_lmd);
479 /* Find the first non-lo MGS nid for our MGC name */
480 if (IS_SERVER(lsi)) {
481 /* mount -o mgsnode=nid */
482 ptr = lsi->lsi_lmd->lmd_mgs;
483 if (lsi->lsi_lmd->lmd_mgs &&
484 (class_parse_nid(lsi->lsi_lmd->lmd_mgs, &nid, &ptr) == 0)) {
486 } else if (IS_MGS(lsi)) {
487 lnet_process_id_t id;
488 while ((rc = LNetGetId(i++, &id)) != -ENOENT) {
489 if (LNET_NETTYP(LNET_NIDNET(id.nid)) == LOLND)
496 } else { /* client */
497 /* Use nids from mount line: uml1,1@elan:uml2,2@elan:/lustre */
498 ptr = lsi->lsi_lmd->lmd_dev;
499 if (class_parse_nid(ptr, &nid, &ptr) == 0)
503 CERROR("No valid MGS nids found.\n");
507 cfs_mutex_lock(&mgc_start_lock);
509 len = strlen(LUSTRE_MGC_OBDNAME) + strlen(libcfs_nid2str(nid)) + 1;
510 OBD_ALLOC(mgcname, len);
511 OBD_ALLOC(niduuid, len + 2);
512 if (!mgcname || !niduuid)
513 GOTO(out_free, rc = -ENOMEM);
514 sprintf(mgcname, "%s%s", LUSTRE_MGC_OBDNAME, libcfs_nid2str(nid));
516 mgssec = lsi->lsi_lmd->lmd_mgssec ? lsi->lsi_lmd->lmd_mgssec : "";
520 GOTO(out_free, rc = -ENOMEM);
522 obd = class_name2obd(mgcname);
523 if (obd && !obd->obd_stopping) {
524 rc = obd_set_info_async(NULL, obd->obd_self_export,
525 strlen(KEY_MGSSEC), KEY_MGSSEC,
526 strlen(mgssec), mgssec, NULL);
530 /* Re-using an existing MGC */
531 cfs_atomic_inc(&obd->u.cli.cl_mgc_refcount);
533 /* IR compatibility check, only for clients */
534 if (lmd_is_client(lsi->lsi_lmd)) {
536 int vallen = sizeof(*data);
537 __u32 *flags = &lsi->lsi_lmd->lmd_flags;
539 rc = obd_get_info(NULL, obd->obd_self_export,
540 strlen(KEY_CONN_DATA), KEY_CONN_DATA,
541 &vallen, data, NULL);
543 has_ir = OCD_HAS_FLAG(data, IMP_RECOV);
544 if (has_ir ^ !(*flags & LMD_FLG_NOIR)) {
545 /* LMD_FLG_NOIR is for test purpose only */
547 "Trying to mount a client with IR setting "
548 "not compatible with current mgc. "
549 "Force to use current mgc setting that is "
551 has_ir ? "enabled" : "disabled");
553 *flags &= ~LMD_FLG_NOIR;
555 *flags |= LMD_FLG_NOIR;
560 /* If we are restarting the MGS, don't try to keep the MGC's
561 old connection, or registration will fail. */
563 CDEBUG(D_MOUNT, "New MGS with live MGC\n");
567 /* Try all connections, but only once (again).
568 We don't want to block another target from starting
569 (using its local copy of the log), but we do want to connect
570 if at all possible. */
572 CDEBUG(D_MOUNT, "%s: Set MGC reconnect %d\n", mgcname,recov_bk);
573 rc = obd_set_info_async(NULL, obd->obd_self_export,
574 sizeof(KEY_INIT_RECOV_BACKUP),
575 KEY_INIT_RECOV_BACKUP,
576 sizeof(recov_bk), &recov_bk, NULL);
580 CDEBUG(D_MOUNT, "Start MGC '%s'\n", mgcname);
582 /* Add the primary nids for the MGS */
584 sprintf(niduuid, "%s_%x", mgcname, i);
585 if (IS_SERVER(lsi)) {
586 ptr = lsi->lsi_lmd->lmd_mgs;
588 /* Use local nids (including LO) */
589 lnet_process_id_t id;
590 while ((rc = LNetGetId(i++, &id)) != -ENOENT) {
591 rc = do_lcfg(mgcname, id.nid,
592 LCFG_ADD_UUID, niduuid, 0,0,0);
595 /* Use mgsnode= nids */
596 /* mount -o mgsnode=nid */
597 if (lsi->lsi_lmd->lmd_mgs) {
598 ptr = lsi->lsi_lmd->lmd_mgs;
599 } else if (class_find_param(ptr, PARAM_MGSNODE,
601 CERROR("No MGS nids given.\n");
602 GOTO(out_free, rc = -EINVAL);
604 while (class_parse_nid(ptr, &nid, &ptr) == 0) {
605 rc = do_lcfg(mgcname, nid,
606 LCFG_ADD_UUID, niduuid, 0,0,0);
610 } else { /* client */
611 /* Use nids from mount line: uml1,1@elan:uml2,2@elan:/lustre */
612 ptr = lsi->lsi_lmd->lmd_dev;
613 while (class_parse_nid(ptr, &nid, &ptr) == 0) {
614 rc = do_lcfg(mgcname, nid,
615 LCFG_ADD_UUID, niduuid, 0,0,0);
617 /* Stop at the first failover nid */
623 CERROR("No valid MGS nids found.\n");
624 GOTO(out_free, rc = -EINVAL);
626 lsi->lsi_lmd->lmd_mgs_failnodes = 1;
628 /* Random uuid for MGC allows easier reconnects */
630 ll_generate_random_uuid(uuidc);
631 class_uuid_unparse(uuidc, uuid);
634 rc = lustre_start_simple(mgcname, LUSTRE_MGC_NAME,
635 (char *)uuid->uuid, LUSTRE_MGS_OBDNAME,
641 /* Add any failover MGS nids */
643 while (ptr && ((*ptr == ':' ||
644 class_find_param(ptr, PARAM_MGSNODE, &ptr) == 0))) {
645 /* New failover node */
646 sprintf(niduuid, "%s_%x", mgcname, i);
648 while (class_parse_nid(ptr, &nid, &ptr) == 0) {
650 rc = do_lcfg(mgcname, nid,
651 LCFG_ADD_UUID, niduuid, 0,0,0);
656 rc = do_lcfg(mgcname, 0, LCFG_ADD_CONN,
664 lsi->lsi_lmd->lmd_mgs_failnodes = i;
666 obd = class_name2obd(mgcname);
668 CERROR("Can't find mgcobd %s\n", mgcname);
669 GOTO(out_free, rc = -ENOTCONN);
672 rc = obd_set_info_async(NULL, obd->obd_self_export,
673 strlen(KEY_MGSSEC), KEY_MGSSEC,
674 strlen(mgssec), mgssec, NULL);
678 /* Keep a refcount of servers/clients who started with "mount",
679 so we know when we can get rid of the mgc. */
680 cfs_atomic_set(&obd->u.cli.cl_mgc_refcount, 1);
682 /* Try all connections, but only once. */
684 rc = obd_set_info_async(NULL, obd->obd_self_export,
685 sizeof(KEY_INIT_RECOV_BACKUP),
686 KEY_INIT_RECOV_BACKUP,
687 sizeof(recov_bk), &recov_bk, NULL);
690 CWARN("can't set %s %d\n", KEY_INIT_RECOV_BACKUP, rc);
692 /* We connect to the MGS at setup, and don't disconnect until cleanup */
693 data->ocd_connect_flags = OBD_CONNECT_VERSION | OBD_CONNECT_AT |
694 OBD_CONNECT_FULL20 | OBD_CONNECT_IMP_RECOV |
695 OBD_CONNECT_MNE_SWAB;
696 if (lmd_is_client(lsi->lsi_lmd) &&
697 lsi->lsi_lmd->lmd_flags & LMD_FLG_NOIR)
698 data->ocd_connect_flags &= ~OBD_CONNECT_IMP_RECOV;
699 data->ocd_version = LUSTRE_VERSION_CODE;
700 rc = obd_connect(NULL, &exp, obd, &(obd->obd_uuid), data, NULL);
702 CERROR("connect failed %d\n", rc);
706 obd->u.cli.cl_mgc_mgsexp = exp;
709 /* Keep the mgc info in the sb. Note that many lsi's can point
713 cfs_mutex_unlock(&mgc_start_lock);
718 OBD_FREE(mgcname, len);
720 OBD_FREE(niduuid, len + 2);
724 static int lustre_stop_mgc(struct super_block *sb)
726 struct lustre_sb_info *lsi = s2lsi(sb);
727 struct obd_device *obd;
728 char *niduuid = 0, *ptr = 0;
729 int i, rc = 0, len = 0;
739 cfs_mutex_lock(&mgc_start_lock);
740 LASSERT(cfs_atomic_read(&obd->u.cli.cl_mgc_refcount) > 0);
741 if (!cfs_atomic_dec_and_test(&obd->u.cli.cl_mgc_refcount)) {
742 /* This is not fatal, every client that stops
743 will call in here. */
744 CDEBUG(D_MOUNT, "mgc still has %d references.\n",
745 cfs_atomic_read(&obd->u.cli.cl_mgc_refcount));
746 GOTO(out, rc = -EBUSY);
749 /* The MGC has no recoverable data in any case.
750 * force shotdown set in umount_begin */
751 obd->obd_no_recov = 1;
753 if (obd->u.cli.cl_mgc_mgsexp) {
754 /* An error is not fatal, if we are unable to send the
755 disconnect mgs ping evictor cleans up the export */
756 rc = obd_disconnect(obd->u.cli.cl_mgc_mgsexp);
758 CDEBUG(D_MOUNT, "disconnect failed %d\n", rc);
761 /* Save the obdname for cleaning the nid uuids, which are
763 len = strlen(obd->obd_name) + 6;
764 OBD_ALLOC(niduuid, len);
766 strcpy(niduuid, obd->obd_name);
767 ptr = niduuid + strlen(niduuid);
770 rc = class_manual_cleanup(obd);
774 /* Clean the nid uuids */
776 GOTO(out, rc = -ENOMEM);
778 for (i = 0; i < lsi->lsi_lmd->lmd_mgs_failnodes; i++) {
779 sprintf(ptr, "_%x", i);
780 rc = do_lcfg(LUSTRE_MGC_OBDNAME, 0, LCFG_DEL_UUID,
783 CERROR("del MDC UUID %s failed: rc = %d\n",
788 OBD_FREE(niduuid, len);
790 /* class_import_put will get rid of the additional connections */
791 cfs_mutex_unlock(&mgc_start_lock);
795 /* Since there's only one mgc per node, we have to change it's fs to get
796 access to the right disk. */
797 static int server_mgc_set_fs(struct obd_device *mgc, struct super_block *sb)
799 struct lustre_sb_info *lsi = s2lsi(sb);
803 CDEBUG(D_MOUNT, "Set mgc disk for %s\n", lsi->lsi_lmd->lmd_dev);
805 /* cl_mgc_sem in mgc insures we sleep if the mgc_fs is busy */
806 rc = obd_set_info_async(NULL, mgc->obd_self_export,
807 sizeof(KEY_SET_FS), KEY_SET_FS,
808 sizeof(*sb), sb, NULL);
810 CERROR("can't set_fs %d\n", rc);
816 static int server_mgc_clear_fs(struct obd_device *mgc)
821 CDEBUG(D_MOUNT, "Unassign mgc disk\n");
823 rc = obd_set_info_async(NULL, mgc->obd_self_export,
824 sizeof(KEY_CLEAR_FS), KEY_CLEAR_FS,
829 CFS_DEFINE_MUTEX(server_start_lock);
831 /* Stop MDS/OSS if nobody is using them */
832 static int server_stop_servers(int lsiflags)
834 struct obd_device *obd = NULL;
835 struct obd_type *type = NULL;
839 cfs_mutex_lock(&server_start_lock);
841 /* Either an MDT or an OST or neither */
842 /* if this was an MDT, and there are no more MDT's, clean up the MDS */
843 if ((lsiflags & LDD_F_SV_TYPE_MDT) &&
844 (obd = class_name2obd(LUSTRE_MDS_OBDNAME))) {
845 /*FIXME pre-rename, should eventually be LUSTRE_MDT_NAME*/
846 type = class_search_type(LUSTRE_MDS_NAME);
848 /* if this was an OST, and there are no more OST's, clean up the OSS */
849 if ((lsiflags & LDD_F_SV_TYPE_OST) &&
850 (obd = class_name2obd(LUSTRE_OSS_OBDNAME))) {
851 type = class_search_type(LUSTRE_OST_NAME);
854 if (obd && (!type || !type->typ_refcnt)) {
857 /* obd_fail doesn't mean much on a server obd */
858 err = class_manual_cleanup(obd);
863 cfs_mutex_unlock(&server_start_lock);
868 int server_mti_print(char *title, struct mgs_target_info *mti)
870 PRINT_CMD(PRINT_MASK, "mti %s\n", title);
871 PRINT_CMD(PRINT_MASK, "server: %s\n", mti->mti_svname);
872 PRINT_CMD(PRINT_MASK, "fs: %s\n", mti->mti_fsname);
873 PRINT_CMD(PRINT_MASK, "uuid: %s\n", mti->mti_uuid);
874 PRINT_CMD(PRINT_MASK, "ver: %d flags: %#x\n",
875 mti->mti_config_ver, mti->mti_flags);
879 /** Get the fsname ("lustre") from the server name ("lustre-OST003F").
880 * @param [in] svname server name including type and index
881 * @param [out] fsname Buffer to copy filesystem name prefix into.
882 * Must have at least 'strlen(fsname) + 1' chars.
883 * @param [out] endptr if endptr isn't NULL it is set to end of fsname
886 static int server_name2fsname(char *svname, char *fsname, char **endptr)
890 p = strstr(svname, "-OST");
892 p = strstr(svname, "-MDT");
897 strncpy(fsname, svname, p - svname);
898 fsname[p - svname] = '\0';
908 * Get service name (svname) from string
910 * if endptr isn't NULL it is set to end of fsname *
912 int server_name2svname(char *label, char *svname, char **endptr)
917 /* We use server_name2fsname() just for parsing */
918 rc = server_name2fsname(label, NULL, &dash);
925 strncpy(svname, dash + 1, MTI_NAME_MAXLEN);
929 EXPORT_SYMBOL(server_name2svname);
932 /* Get the index from the obd name.
935 if endptr isn't NULL it is set to end of name */
936 int server_name2index(char *svname, __u32 *idx, char **endptr)
942 /* We use server_name2fsname() just for parsing */
943 rc = server_name2fsname(svname, NULL, &dash);
952 if (strncmp(dash, "MDT", 3) == 0)
953 rc = LDD_F_SV_TYPE_MDT;
954 else if (strncmp(dash, "OST", 3) == 0)
955 rc = LDD_F_SV_TYPE_OST;
961 if (strcmp(dash, "all") == 0)
962 return rc | LDD_F_SV_ALL;
964 index = simple_strtoul(dash, endptr, 16);
969 EXPORT_SYMBOL(server_name2index);
971 /* Generate data for registration */
972 static int server_lsi2mti(struct lustre_sb_info *lsi,
973 struct mgs_target_info *mti)
975 lnet_process_id_t id;
982 strncpy(mti->mti_svname, lsi->lsi_svname, sizeof(mti->mti_svname));
984 mti->mti_nid_count = 0;
985 while (LNetGetId(i++, &id) != -ENOENT) {
986 if (LNET_NETTYP(LNET_NIDNET(id.nid)) == LOLND)
989 /* server use --servicenode param, only allow specified
990 * nids be registered */
991 if ((lsi->lsi_lmd->lmd_flags & LMD_FLG_NO_PRIMNODE) != 0 &&
992 class_match_nid(lsi->lsi_lmd->lmd_params,
993 PARAM_FAILNODE, id.nid) < 1)
996 /* match specified network */
997 if (!class_match_net(lsi->lsi_lmd->lmd_params,
998 PARAM_NETWORK, LNET_NIDNET(id.nid)))
1001 mti->mti_nids[mti->mti_nid_count] = id.nid;
1002 mti->mti_nid_count++;
1003 if (mti->mti_nid_count >= MTI_NIDS_MAX) {
1004 CWARN("Only using first %d nids for %s\n",
1005 mti->mti_nid_count, mti->mti_svname);
1010 mti->mti_lustre_ver = LUSTRE_VERSION_CODE;
1011 mti->mti_config_ver = 0;
1013 rc = server_name2fsname(lsi->lsi_svname, mti->mti_fsname, NULL);
1017 rc = server_name2index(lsi->lsi_svname, &mti->mti_stripe_index, NULL);
1020 /* Orion requires index to be set */
1021 LASSERT(!(rc & LDD_F_NEED_INDEX));
1022 /* keep only LDD flags */
1023 mti->mti_flags = lsi->lsi_flags & LDD_F_MASK;
1024 mti->mti_flags |= LDD_F_UPDATE;
1025 strncpy(mti->mti_params, lsi->lsi_lmd->lmd_params,
1026 sizeof(mti->mti_params));
1030 /* Register an old or new target with the MGS. If needed MGS will construct
1031 startup logs and assign index */
1032 static int server_register_target(struct lustre_sb_info *lsi)
1034 struct obd_device *mgc = lsi->lsi_mgc;
1035 struct mgs_target_info *mti = NULL;
1042 if (!IS_SERVER(lsi))
1049 rc = server_lsi2mti(lsi, mti);
1053 CDEBUG(D_MOUNT, "Registration %s, fs=%s, %s, index=%04x, flags=%#x\n",
1054 mti->mti_svname, mti->mti_fsname,
1055 libcfs_nid2str(mti->mti_nids[0]), mti->mti_stripe_index,
1058 /* if write_conf is true, the registration must succeed */
1059 writeconf = !!(lsi->lsi_flags & (LDD_F_NEED_INDEX | LDD_F_UPDATE));
1060 mti->mti_flags |= LDD_F_OPC_REG;
1062 /* Register the target */
1063 /* FIXME use mgc_process_config instead */
1064 rc = obd_set_info_async(NULL, mgc->u.cli.cl_mgc_mgsexp,
1065 sizeof(KEY_REGISTER_TARGET), KEY_REGISTER_TARGET,
1066 sizeof(*mti), mti, NULL);
1068 if (mti->mti_flags & LDD_F_ERROR) {
1069 LCONSOLE_ERROR_MSG(0x160,
1070 "The MGS is refusing to allow this "
1071 "server (%s) to start. Please see messages"
1072 " on the MGS node.\n", lsi->lsi_svname);
1073 } else if (writeconf) {
1074 LCONSOLE_ERROR_MSG(0x15f,
1075 "Communication to the MGS return error %d. "
1076 "Is the MGS running?\n", rc);
1078 CERROR("Cannot talk to the MGS: %d, not fatal\n", rc);
1079 /* reset the error code for non-fatal error. */
1092 * Notify the MGS that this target is ready.
1093 * Used by IR - if the MGS receives this message, it will notify clients.
1095 static int server_notify_target(struct super_block *sb, struct obd_device *obd)
1097 struct lustre_sb_info *lsi = s2lsi(sb);
1098 struct obd_device *mgc = lsi->lsi_mgc;
1099 struct mgs_target_info *mti = NULL;
1105 if (!(IS_SERVER(lsi)))
1111 rc = server_lsi2mti(lsi, mti);
1115 mti->mti_instance = obd->u.obt.obt_instance;
1116 mti->mti_flags |= LDD_F_OPC_READY;
1118 /* FIXME use mgc_process_config instead */
1119 rc = obd_set_info_async(NULL, mgc->u.cli.cl_mgc_mgsexp,
1120 sizeof(KEY_REGISTER_TARGET),
1121 KEY_REGISTER_TARGET,
1122 sizeof(*mti), mti, NULL);
1124 /* Imperative recovery: if the mgs informs us to use IR? */
1125 if (!rc && !(mti->mti_flags & LDD_F_ERROR) &&
1126 (mti->mti_flags & LDD_F_IR_CAPABLE))
1127 lsi->lsi_flags |= LDD_F_IR_CAPABLE;
1136 /** Start server targets: MDTs and OSTs
1138 static int server_start_targets(struct super_block *sb, struct vfsmount *mnt)
1140 struct obd_device *obd;
1141 struct lustre_sb_info *lsi = s2lsi(sb);
1142 struct config_llog_instance cfg;
1146 CDEBUG(D_MOUNT, "starting target %s\n", lsi->lsi_svname);
1149 /* If we're an MDT, make sure the global MDS is running */
1150 if (lsi->lsi_ldd->ldd_flags & LDD_F_SV_TYPE_MDT) {
1151 /* make sure the MDS is started */
1152 cfs_mutex_lock(&server_start_lock);
1153 obd = class_name2obd(LUSTRE_MDS_OBDNAME);
1155 rc = lustre_start_simple(LUSTRE_MDS_OBDNAME,
1156 /* FIXME pre-rename, should eventually be LUSTRE_MDS_NAME */
1158 LUSTRE_MDS_OBDNAME"_uuid",
1161 cfs_mutex_unlock(&server_start_lock);
1162 CERROR("failed to start MDS: %d\n", rc);
1166 cfs_mutex_unlock(&server_start_lock);
1170 /* If we're an OST, make sure the global OSS is running */
1172 /* make sure OSS is started */
1173 cfs_mutex_lock(&server_start_lock);
1174 obd = class_name2obd(LUSTRE_OSS_OBDNAME);
1176 rc = lustre_start_simple(LUSTRE_OSS_OBDNAME,
1178 LUSTRE_OSS_OBDNAME"_uuid",
1181 cfs_mutex_unlock(&server_start_lock);
1182 CERROR("failed to start OSS: %d\n", rc);
1186 cfs_mutex_unlock(&server_start_lock);
1189 /* Set the mgc fs to our server disk. This allows the MGC to
1190 * read and write configs locally, in case it can't talk to the MGS. */
1191 if (lsi->lsi_srv_mnt) {
1192 rc = server_mgc_set_fs(lsi->lsi_mgc, sb);
1197 /* Register with MGS */
1198 rc = server_register_target(lsi);
1202 /* Let the target look up the mount using the target's name
1203 (we can't pass the sb or mnt through class_process_config.) */
1204 rc = server_register_mount(lsi->lsi_svname, sb, mnt);
1208 /* Start targets using the llog named for the target */
1209 memset(&cfg, 0, sizeof(cfg));
1210 rc = lustre_process_log(sb, lsi->lsi_svname, &cfg);
1212 CERROR("failed to start server %s: %d\n",
1213 lsi->lsi_svname, rc);
1214 /* Do NOT call server_deregister_mount() here. This makes it
1215 * impossible to find mount later in cleanup time and leaves
1216 * @lsi and othder stuff leaked. -umka */
1221 /* Release the mgc fs for others to use */
1222 if (lsi->lsi_srv_mnt)
1223 server_mgc_clear_fs(lsi->lsi_mgc);
1226 obd = class_name2obd(lsi->lsi_svname);
1228 CERROR("no server named %s was started\n",
1233 if ((lsi->lsi_lmd->lmd_flags & LMD_FLG_ABORT_RECOV) &&
1234 (OBP(obd, iocontrol))) {
1235 obd_iocontrol(OBD_IOC_ABORT_RECOVERY,
1236 obd->obd_self_export, 0, NULL, NULL);
1239 server_notify_target(sb, obd);
1241 /* calculate recovery timeout, do it after lustre_process_log */
1242 server_calc_timeout(lsi, obd);
1244 /* log has been fully processed */
1245 obd_notify(obd, NULL, OBD_NOTIFY_CONFIG, (void *)CONFIG_LOG);
1251 /***************** lustre superblock **************/
1253 struct lustre_sb_info *lustre_init_lsi(struct super_block *sb)
1255 struct lustre_sb_info *lsi;
1261 OBD_ALLOC_PTR(lsi->lsi_lmd);
1262 if (!lsi->lsi_lmd) {
1267 lsi->lsi_lmd->lmd_exclude_count = 0;
1268 lsi->lsi_lmd->lmd_recovery_time_soft = 0;
1269 lsi->lsi_lmd->lmd_recovery_time_hard = 0;
1270 s2lsi_nocast(sb) = lsi;
1271 /* we take 1 extra ref for our setup */
1272 cfs_atomic_set(&lsi->lsi_mounts, 1);
1274 /* Default umount style */
1275 lsi->lsi_flags = LSI_UMOUNT_FAILOVER;
1280 static int lustre_free_lsi(struct super_block *sb)
1282 struct lustre_sb_info *lsi = s2lsi(sb);
1285 LASSERT(lsi != NULL);
1286 CDEBUG(D_MOUNT, "Freeing lsi %p\n", lsi);
1288 /* someone didn't call server_put_mount. */
1289 LASSERT(cfs_atomic_read(&lsi->lsi_mounts) == 0);
1291 if (lsi->lsi_lmd != NULL) {
1292 if (lsi->lsi_lmd->lmd_dev != NULL)
1293 OBD_FREE(lsi->lsi_lmd->lmd_dev,
1294 strlen(lsi->lsi_lmd->lmd_dev) + 1);
1295 if (lsi->lsi_lmd->lmd_profile != NULL)
1296 OBD_FREE(lsi->lsi_lmd->lmd_profile,
1297 strlen(lsi->lsi_lmd->lmd_profile) + 1);
1298 if (lsi->lsi_lmd->lmd_mgssec != NULL)
1299 OBD_FREE(lsi->lsi_lmd->lmd_mgssec,
1300 strlen(lsi->lsi_lmd->lmd_mgssec) + 1);
1301 if (lsi->lsi_lmd->lmd_opts != NULL)
1302 OBD_FREE(lsi->lsi_lmd->lmd_opts,
1303 strlen(lsi->lsi_lmd->lmd_opts) + 1);
1304 if (lsi->lsi_lmd->lmd_exclude_count)
1305 OBD_FREE(lsi->lsi_lmd->lmd_exclude,
1306 sizeof(lsi->lsi_lmd->lmd_exclude[0]) *
1307 lsi->lsi_lmd->lmd_exclude_count);
1308 if (lsi->lsi_lmd->lmd_mgs != NULL)
1309 OBD_FREE(lsi->lsi_lmd->lmd_mgs,
1310 strlen(lsi->lsi_lmd->lmd_mgs) + 1);
1311 if (lsi->lsi_lmd->lmd_osd_type != NULL)
1312 OBD_FREE(lsi->lsi_lmd->lmd_osd_type,
1313 strlen(lsi->lsi_lmd->lmd_osd_type) + 1);
1314 if (lsi->lsi_lmd->lmd_params != NULL)
1315 OBD_FREE(lsi->lsi_lmd->lmd_params, 4096);
1317 OBD_FREE(lsi->lsi_lmd, sizeof(*lsi->lsi_lmd));
1320 LASSERT(lsi->lsi_llsbi == NULL);
1321 OBD_FREE(lsi, sizeof(*lsi));
1322 s2lsi_nocast(sb) = NULL;
1327 /* The lsi has one reference for every server that is using the disk -
1328 e.g. MDT, MGS, and potentially MGC */
1329 static int lustre_put_lsi(struct super_block *sb)
1331 struct lustre_sb_info *lsi = s2lsi(sb);
1334 LASSERT(lsi != NULL);
1336 CDEBUG(D_MOUNT, "put %p %d\n", sb, cfs_atomic_read(&lsi->lsi_mounts));
1337 if (cfs_atomic_dec_and_test(&lsi->lsi_mounts)) {
1338 if (IS_SERVER(lsi) && lsi->lsi_osd_exp) {
1339 obd_disconnect(lsi->lsi_osd_exp);
1340 /* wait till OSD is gone */
1341 obd_zombie_barrier();
1343 lustre_free_lsi(sb);
1349 static int lsi_prepare(struct lustre_sb_info *lsi)
1356 LASSERT(lsi->lsi_lmd);
1358 /* The server name is given as a mount line option */
1359 if (lsi->lsi_lmd->lmd_profile == NULL) {
1360 LCONSOLE_ERROR("Can't determine server name\n");
1364 if (strlen(lsi->lsi_lmd->lmd_profile) >= sizeof(lsi->lsi_svname))
1365 RETURN(-ENAMETOOLONG);
1367 strcpy(lsi->lsi_svname, lsi->lsi_lmd->lmd_profile);
1369 /* Determine osd type */
1370 if (lsi->lsi_lmd->lmd_osd_type != NULL) {
1371 if (strlen(lsi->lsi_lmd->lmd_osd_type) >=
1372 sizeof(lsi->lsi_osd_type))
1373 RETURN(-ENAMETOOLONG);
1375 strcpy(lsi->lsi_osd_type, lsi->lsi_lmd->lmd_osd_type);
1377 strcpy(lsi->lsi_osd_type, LUSTRE_OSD_LDISKFS_NAME);
1380 /* XXX: a temp. solution for components using fsfilt
1381 * to be removed in one of the subsequent patches */
1382 if (!strcmp(lsi->lsi_lmd->lmd_osd_type, "osd-ldiskfs")) {
1383 strcpy(lsi->lsi_fstype, "ldiskfs");
1385 strcpy(lsi->lsi_fstype, lsi->lsi_lmd->lmd_osd_type);
1388 /* Determine server type */
1389 rc = server_name2index(lsi->lsi_svname, &index, NULL);
1391 if (lsi->lsi_lmd->lmd_flags & LMD_FLG_MGS) {
1392 /* Assume we're a bare MGS */
1394 lsi->lsi_lmd->lmd_flags |= LMD_FLG_NOSVC;
1396 LCONSOLE_ERROR("Can't determine server type of '%s'\n",
1401 lsi->lsi_flags |= rc;
1403 /* Add mount line flags that used to be in ldd:
1404 * writeconf, mgs, iam, anything else?
1406 lsi->lsi_flags |= (lsi->lsi_lmd->lmd_flags & LMD_FLG_WRITECONF) ?
1407 LDD_F_WRITECONF : 0;
1408 lsi->lsi_flags |= (lsi->lsi_lmd->lmd_flags & LMD_FLG_VIRGIN) ?
1410 lsi->lsi_flags |= (lsi->lsi_lmd->lmd_flags & LMD_FLG_MGS) ?
1411 LDD_F_SV_TYPE_MGS : 0;
1412 lsi->lsi_flags |= (lsi->lsi_lmd->lmd_flags & LMD_FLG_IAM) ?
1414 lsi->lsi_flags |= (lsi->lsi_lmd->lmd_flags & LMD_FLG_NO_PRIMNODE) ?
1415 LDD_F_NO_PRIMNODE : 0;
1420 /*************** server mount ******************/
1422 /** Start the shutdown of servers at umount.
1424 static void server_put_super(struct super_block *sb)
1426 struct lustre_sb_info *lsi = s2lsi(sb);
1427 struct obd_device *obd;
1428 char *tmpname, *extraname = NULL;
1430 int lsiflags = lsi->lsi_flags;
1433 LASSERT(IS_SERVER(lsi));
1435 tmpname_sz = strlen(lsi->lsi_svname) + 1;
1436 OBD_ALLOC(tmpname, tmpname_sz);
1437 memcpy(tmpname, lsi->lsi_svname, tmpname_sz);
1438 CDEBUG(D_MOUNT, "server put_super %s\n", tmpname);
1439 if (IS_MDT(lsi) && (lsi->lsi_lmd->lmd_flags & LMD_FLG_NOSVC))
1440 snprintf(tmpname, tmpname_sz, "MGS");
1442 /* Stop the target */
1443 if (!(lsi->lsi_lmd->lmd_flags & LMD_FLG_NOSVC) &&
1444 (IS_MDT(lsi) || IS_OST(lsi))) {
1445 struct lustre_profile *lprof = NULL;
1447 /* tell the mgc to drop the config log */
1448 lustre_end_log(sb, lsi->lsi_svname, NULL);
1450 /* COMPAT_146 - profile may get deleted in mgc_cleanup.
1451 If there are any setup/cleanup errors, save the lov
1452 name for safety cleanup later. */
1453 lprof = class_get_profile(lsi->lsi_svname);
1454 if (lprof && lprof->lp_dt) {
1455 OBD_ALLOC(extraname, strlen(lprof->lp_dt) + 1);
1456 strcpy(extraname, lprof->lp_dt);
1459 obd = class_name2obd(lsi->lsi_svname);
1461 CDEBUG(D_MOUNT, "stopping %s\n", obd->obd_name);
1462 if (lsi->lsi_flags & LSI_UMOUNT_FAILOVER)
1464 /* We can't seem to give an error return code
1465 * to .put_super, so we better make sure we clean up! */
1467 class_manual_cleanup(obd);
1469 CERROR("no obd %s\n", lsi->lsi_svname);
1470 server_deregister_mount(lsi->lsi_svname);
1474 /* If they wanted the mgs to stop separately from the mdt, they
1475 should have put it on a different device. */
1477 /* if MDS start with --nomgs, don't stop MGS then */
1478 if (!(lsi->lsi_lmd->lmd_flags & LMD_FLG_NOMGS))
1479 server_stop_mgs(sb);
1482 /* Clean the mgc and sb */
1483 lustre_common_put_super(sb);
1485 /* wait till all in-progress cleanups are done
1486 * specifically we're interested in ofd cleanup
1488 obd_zombie_barrier();
1490 /* Stop the servers (MDS, OSS) if no longer needed. We must wait
1491 until the target is really gone so that our type refcount check
1493 server_stop_servers(lsiflags);
1495 /* In case of startup or cleanup err, stop related obds */
1497 obd = class_name2obd(extraname);
1499 CWARN("Cleaning orphaned obd %s\n", extraname);
1501 class_manual_cleanup(obd);
1503 OBD_FREE(extraname, strlen(extraname) + 1);
1506 LCONSOLE_WARN("server umount %s complete\n", tmpname);
1507 OBD_FREE(tmpname, tmpname_sz);
1511 /** Called only for 'umount -f'
1513 #ifdef HAVE_UMOUNTBEGIN_VFSMOUNT
1514 static void server_umount_begin(struct vfsmount *vfsmnt, int flags)
1516 struct super_block *sb = vfsmnt->mnt_sb;
1518 static void server_umount_begin(struct super_block *sb)
1521 struct lustre_sb_info *lsi = s2lsi(sb);
1524 #ifdef HAVE_UMOUNTBEGIN_VFSMOUNT
1525 if (!(flags & MNT_FORCE)) {
1531 CDEBUG(D_MOUNT, "umount -f\n");
1532 /* umount = failover
1534 no third way to do non-force, non-failover */
1535 lsi->lsi_flags &= ~LSI_UMOUNT_FAILOVER;
1539 static int server_statfs (struct dentry *dentry, cfs_kstatfs_t *buf)
1541 struct super_block *sb = dentry->d_sb;
1542 struct lustre_sb_info *lsi = s2lsi(sb);
1543 struct obd_statfs statfs;
1547 if (lsi->lsi_dt_dev) {
1548 rc = dt_statfs(NULL, lsi->lsi_dt_dev, &statfs);
1550 statfs_unpack(buf, &statfs);
1551 buf->f_type = sb->s_magic;
1557 buf->f_type = sb->s_magic;
1558 buf->f_bsize = sb->s_blocksize;
1564 buf->f_namelen = NAME_MAX;
1568 /** The operations we support directly on the superblock:
1569 * mount, umount, and df.
1571 static struct super_operations server_ops =
1573 .put_super = server_put_super,
1574 .umount_begin = server_umount_begin, /* umount -f */
1575 .statfs = server_statfs,
1578 #define log2(n) cfs_ffz(~(n))
1579 #define LUSTRE_SUPER_MAGIC 0x0BD00BD1
1581 static int server_fill_super_common(struct super_block *sb)
1583 struct inode *root = 0;
1586 CDEBUG(D_MOUNT, "Server sb, dev=%d\n", (int)sb->s_dev);
1588 sb->s_blocksize = 4096;
1589 sb->s_blocksize_bits = log2(sb->s_blocksize);
1590 sb->s_magic = LUSTRE_SUPER_MAGIC;
1591 sb->s_maxbytes = 0; /* we don't allow file IO on server mountpoints */
1592 sb->s_flags |= MS_RDONLY;
1593 sb->s_op = &server_ops;
1595 root = new_inode(sb);
1597 CERROR("Can't make root inode\n");
1601 /* returns -EIO for every operation */
1602 /* make_bad_inode(root); -- badness - can't umount */
1603 /* apparently we need to be a directory for the mount to finish */
1604 root->i_mode = S_IFDIR;
1606 sb->s_root = d_alloc_root(root);
1608 CERROR("Can't make root dentry\n");
1616 static int osd_start(struct lustre_sb_info *lsi, unsigned long mflags)
1618 struct lustre_mount_data *lmd = lsi->lsi_lmd;
1619 struct obd_device *obd;
1620 struct dt_device_param p;
1626 "Attempting to start %s, type=%s, lsifl=%x, mountfl=%lx\n",
1627 lsi->lsi_svname, lsi->lsi_osd_type, lsi->lsi_flags, mflags);
1629 sprintf(lsi->lsi_osd_obdname, "%s-osd", lsi->lsi_svname);
1630 strcpy(lsi->lsi_osd_uuid, lsi->lsi_osd_obdname);
1631 strcat(lsi->lsi_osd_uuid, "_UUID");
1632 sprintf(flagstr, "%lu:%lu", mflags, (unsigned long) lmd->lmd_flags);
1634 obd = class_name2obd(lsi->lsi_osd_obdname);
1636 rc = lustre_start_simple(lsi->lsi_osd_obdname,
1638 lsi->lsi_osd_uuid, lmd->lmd_dev,
1639 flagstr, lsi->lsi_lmd->lmd_opts,
1643 obd = class_name2obd(lsi->lsi_osd_obdname);
1647 rc = obd_connect(NULL, &lsi->lsi_osd_exp, obd, &obd->obd_uuid, NULL, NULL);
1650 class_manual_cleanup(obd);
1651 lsi->lsi_dt_dev = NULL;
1654 /* XXX: to keep support old components relying on lsi_srv_mnt
1655 * we get this info from OSD just started */
1656 LASSERT(obd->obd_lu_dev);
1657 lsi->lsi_dt_dev = lu2dt_dev(obd->obd_lu_dev);
1658 LASSERT(lsi->lsi_dt_dev);
1660 dt_conf_get(NULL, lsi->lsi_dt_dev, &p);
1662 lsi->lsi_srv_mnt = p.ddp_mnt;
1668 /** Fill in the superblock info for a Lustre server.
1669 * Mount the device with the correct options.
1670 * Read the on-disk config file.
1671 * Start the services.
1673 static int server_fill_super(struct super_block *sb)
1675 struct lustre_sb_info *lsi = s2lsi(sb);
1679 rc = lsi_prepare(lsi);
1683 /* Start low level OSD */
1684 rc = osd_start(lsi, sb->s_flags);
1686 CERROR("Unable to start osd on %s: %d\n",
1687 lsi->lsi_lmd->lmd_dev, rc);
1692 CDEBUG(D_MOUNT, "Found service %s on device %s\n",
1693 lsi->lsi_svname, lsi->lsi_lmd->lmd_dev);
1695 if (class_name2obd(lsi->lsi_svname)) {
1696 LCONSOLE_ERROR_MSG(0x161, "The target named %s is already "
1697 "running. Double-mount may have compromised"
1698 " the disk journal.\n",
1704 /* Start MGS before MGC */
1705 if (IS_MGS(lsi) && !(lsi->lsi_lmd->lmd_flags & LMD_FLG_NOMGS)){
1706 rc = server_start_mgs(sb);
1711 /* Start MGC before servers */
1712 rc = lustre_start_mgc(sb);
1716 /* Set up all obd devices for service */
1717 if (!(lsi->lsi_lmd->lmd_flags & LMD_FLG_NOSVC) &&
1718 (IS_OST(lsi) || IS_MDT(lsi))) {
1719 rc = server_start_targets(sb, lsi->lsi_srv_mnt);
1721 CERROR("Unable to start targets: %d\n", rc);
1724 /* FIXME overmount client here,
1725 or can we just start a client log and client_fill_super on this sb?
1726 We need to make sure server_put_super gets called too - ll_put_super
1727 calls lustre_common_put_super; check there for LSI_SERVER flag,
1729 Probably should start client from new thread so we can return.
1730 Client will not finish until all servers are connected.
1731 Note - MGS-only server does NOT get a client, since there is no
1732 lustre fs associated - the MGS is for all lustre fs's */
1735 rc = server_fill_super_common(sb);
1741 /* We jump here in case of failure while starting targets or MGS.
1742 * In this case we can't just put @mnt and have to do real cleanup
1743 * with stoping targets, etc. */
1744 server_put_super(sb);
1749 * Calculate timeout value for a target.
1751 void server_calc_timeout(struct lustre_sb_info *lsi, struct obd_device *obd)
1753 struct lustre_mount_data *lmd;
1757 bool has_ir = !!(lsi->lsi_flags & LDD_F_IR_CAPABLE);
1758 int min = OBD_RECOVERY_TIME_MIN;
1760 LASSERT(IS_SERVER(lsi));
1764 soft = lmd->lmd_recovery_time_soft;
1765 hard = lmd->lmd_recovery_time_hard;
1766 has_ir = has_ir && !(lmd->lmd_flags & LMD_FLG_NOIR);
1767 obd->obd_no_ir = !has_ir;
1771 soft = OBD_RECOVERY_TIME_SOFT;
1773 hard = OBD_RECOVERY_TIME_HARD;
1775 /* target may have ir_factor configured. */
1776 factor = OBD_IR_FACTOR_DEFAULT;
1777 if (obd->obd_recovery_ir_factor)
1778 factor = obd->obd_recovery_ir_factor;
1781 int new_soft = soft;
1782 int new_hard = hard;
1784 /* adjust timeout value by imperative recovery */
1786 new_soft = (soft * factor) / OBD_IR_FACTOR_MAX;
1787 new_hard = (hard * factor) / OBD_IR_FACTOR_MAX;
1789 /* make sure the timeout is not too short */
1790 new_soft = max(min, new_soft);
1791 new_hard = max(new_soft, new_hard);
1793 LCONSOLE_INFO("%s: Imperative Recovery enabled, recovery "
1794 "window shrunk from %d-%d down to %d-%d\n",
1795 obd->obd_name, soft, hard, new_soft, new_hard);
1802 obd->obd_recovery_timeout = max(obd->obd_recovery_timeout, soft);
1803 obd->obd_recovery_time_hard = hard;
1804 obd->obd_recovery_ir_factor = factor;
1806 EXPORT_SYMBOL(server_calc_timeout);
1808 /*************** mount common betweeen server and client ***************/
1811 int lustre_common_put_super(struct super_block *sb)
1816 CDEBUG(D_MOUNT, "dropping sb %p\n", sb);
1818 /* Drop a ref to the MGC */
1819 rc = lustre_stop_mgc(sb);
1820 if (rc && (rc != -ENOENT)) {
1822 CERROR("Can't stop MGC: %d\n", rc);
1825 /* BUSY just means that there's some other obd that
1826 needs the mgc. Let him clean it up. */
1827 CDEBUG(D_MOUNT, "MGC still in use\n");
1829 /* Drop a ref to the mounted disk */
1834 EXPORT_SYMBOL(lustre_common_put_super);
1836 static void lmd_print(struct lustre_mount_data *lmd)
1840 PRINT_CMD(PRINT_MASK, " mount data:\n");
1841 if (lmd_is_client(lmd))
1842 PRINT_CMD(PRINT_MASK, "profile: %s\n", lmd->lmd_profile);
1843 PRINT_CMD(PRINT_MASK, "device: %s\n", lmd->lmd_dev);
1844 PRINT_CMD(PRINT_MASK, "flags: %x\n", lmd->lmd_flags);
1847 PRINT_CMD(PRINT_MASK, "options: %s\n", lmd->lmd_opts);
1849 if (lmd->lmd_recovery_time_soft)
1850 PRINT_CMD(PRINT_MASK, "recovery time soft: %d\n",
1851 lmd->lmd_recovery_time_soft);
1853 if (lmd->lmd_recovery_time_hard)
1854 PRINT_CMD(PRINT_MASK, "recovery time hard: %d\n",
1855 lmd->lmd_recovery_time_hard);
1857 for (i = 0; i < lmd->lmd_exclude_count; i++) {
1858 PRINT_CMD(PRINT_MASK, "exclude %d: OST%04x\n", i,
1859 lmd->lmd_exclude[i]);
1863 /* Is this server on the exclusion list */
1864 int lustre_check_exclusion(struct super_block *sb, char *svname)
1866 struct lustre_sb_info *lsi = s2lsi(sb);
1867 struct lustre_mount_data *lmd = lsi->lsi_lmd;
1872 rc = server_name2index(svname, &index, NULL);
1873 if (rc != LDD_F_SV_TYPE_OST)
1874 /* Only exclude OSTs */
1877 CDEBUG(D_MOUNT, "Check exclusion %s (%d) in %d of %s\n", svname,
1878 index, lmd->lmd_exclude_count, lmd->lmd_dev);
1880 for(i = 0; i < lmd->lmd_exclude_count; i++) {
1881 if (index == lmd->lmd_exclude[i]) {
1882 CWARN("Excluding %s (on exclusion list)\n", svname);
1889 /* mount -v -o exclude=lustre-OST0001:lustre-OST0002 -t lustre ... */
1890 static int lmd_make_exclusion(struct lustre_mount_data *lmd, char *ptr)
1892 char *s1 = ptr, *s2;
1893 __u32 index, *exclude_list;
1897 /* The shortest an ost name can be is 8 chars: -OST0000.
1898 We don't actually know the fsname at this time, so in fact
1899 a user could specify any fsname. */
1900 devmax = strlen(ptr) / 8 + 1;
1902 /* temp storage until we figure out how many we have */
1903 OBD_ALLOC(exclude_list, sizeof(index) * devmax);
1907 /* we enter this fn pointing at the '=' */
1908 while (*s1 && *s1 != ' ' && *s1 != ',') {
1910 rc = server_name2index(s1, &index, &s2);
1912 CERROR("Can't parse server name '%s'\n", s1);
1915 if (rc == LDD_F_SV_TYPE_OST)
1916 exclude_list[lmd->lmd_exclude_count++] = index;
1918 CDEBUG(D_MOUNT, "ignoring exclude %.7s\n", s1);
1920 /* now we are pointing at ':' (next exclude)
1921 or ',' (end of excludes) */
1922 if (lmd->lmd_exclude_count >= devmax)
1925 if (rc >= 0) /* non-err */
1928 if (lmd->lmd_exclude_count) {
1929 /* permanent, freed in lustre_free_lsi */
1930 OBD_ALLOC(lmd->lmd_exclude, sizeof(index) *
1931 lmd->lmd_exclude_count);
1932 if (lmd->lmd_exclude) {
1933 memcpy(lmd->lmd_exclude, exclude_list,
1934 sizeof(index) * lmd->lmd_exclude_count);
1937 lmd->lmd_exclude_count = 0;
1940 OBD_FREE(exclude_list, sizeof(index) * devmax);
1944 static int lmd_parse_mgssec(struct lustre_mount_data *lmd, char *ptr)
1949 if (lmd->lmd_mgssec != NULL) {
1950 OBD_FREE(lmd->lmd_mgssec, strlen(lmd->lmd_mgssec) + 1);
1951 lmd->lmd_mgssec = NULL;
1954 tail = strchr(ptr, ',');
1956 length = strlen(ptr);
1958 length = tail - ptr;
1960 OBD_ALLOC(lmd->lmd_mgssec, length + 1);
1961 if (lmd->lmd_mgssec == NULL)
1964 memcpy(lmd->lmd_mgssec, ptr, length);
1965 lmd->lmd_mgssec[length] = '\0';
1969 static int lmd_parse_string(char **handle, char *ptr)
1974 if ((handle == NULL) || (ptr == NULL))
1977 if (*handle != NULL) {
1978 OBD_FREE(*handle, strlen(*handle) + 1);
1982 tail = strchr(ptr, ',');
1984 length = strlen(ptr);
1986 length = tail - ptr;
1988 OBD_ALLOC(*handle, length + 1);
1989 if (*handle == NULL)
1992 memcpy(*handle, ptr, length);
1993 (*handle)[length] = '\0';
1998 /* Collect multiple values for mgsnid specifiers */
1999 static int lmd_parse_mgs(struct lustre_mount_data *lmd, char **ptr)
2007 /* Find end of nidlist */
2008 while (class_parse_nid(tail, &nid, &tail) == 0) {}
2009 length = tail - *ptr;
2011 LCONSOLE_ERROR_MSG(0x159, "Can't parse NID '%s'\n", *ptr);
2015 if (lmd->lmd_mgs != NULL)
2016 oldlen = strlen(lmd->lmd_mgs) + 1;
2018 OBD_ALLOC(mgsnid, oldlen + length + 1);
2022 if (lmd->lmd_mgs != NULL) {
2023 /* Multiple mgsnid= are taken to mean failover locations */
2024 memcpy(mgsnid, lmd->lmd_mgs, oldlen);
2025 mgsnid[oldlen - 1] = ':';
2026 OBD_FREE(lmd->lmd_mgs, oldlen);
2028 memcpy(mgsnid + oldlen, *ptr, length);
2029 mgsnid[oldlen + length] = '\0';
2030 lmd->lmd_mgs = mgsnid;
2036 /** Parse mount line options
2037 * e.g. mount -v -t lustre -o abort_recov uml1:uml2:/lustre-client /mnt/lustre
2038 * dev is passed as device=uml1:/lustre by mount.lustre
2040 static int lmd_parse(char *options, struct lustre_mount_data *lmd)
2042 char *s1, *s2, *devname = NULL;
2043 struct lustre_mount_data *raw = (struct lustre_mount_data *)options;
2049 LCONSOLE_ERROR_MSG(0x162, "Missing mount data: check that "
2050 "/sbin/mount.lustre is installed.\n");
2054 /* Options should be a string - try to detect old lmd data */
2055 if ((raw->lmd_magic & 0xffffff00) == (LMD_MAGIC & 0xffffff00)) {
2056 LCONSOLE_ERROR_MSG(0x163, "You're using an old version of "
2057 "/sbin/mount.lustre. Please install "
2058 "version %s\n", LUSTRE_VERSION_STRING);
2061 lmd->lmd_magic = LMD_MAGIC;
2063 OBD_ALLOC(lmd->lmd_params, 4096);
2064 if (lmd->lmd_params == NULL)
2066 lmd->lmd_params[0] = '\0';
2068 /* Set default flags here */
2073 int time_min = OBD_RECOVERY_TIME_MIN;
2075 /* Skip whitespace and extra commas */
2076 while (*s1 == ' ' || *s1 == ',')
2079 /* Client options are parsed in ll_options: eg. flock,
2082 /* Parse non-ldiskfs options here. Rather than modifying
2083 ldiskfs, we just zero these out here */
2084 if (strncmp(s1, "abort_recov", 11) == 0) {
2085 lmd->lmd_flags |= LMD_FLG_ABORT_RECOV;
2087 } else if (strncmp(s1, "recovery_time_soft=", 19) == 0) {
2088 lmd->lmd_recovery_time_soft = max_t(int,
2089 simple_strtoul(s1 + 19, NULL, 10), time_min);
2091 } else if (strncmp(s1, "recovery_time_hard=", 19) == 0) {
2092 lmd->lmd_recovery_time_hard = max_t(int,
2093 simple_strtoul(s1 + 19, NULL, 10), time_min);
2095 } else if (strncmp(s1, "noir", 4) == 0) {
2096 lmd->lmd_flags |= LMD_FLG_NOIR; /* test purpose only. */
2098 } else if (strncmp(s1, "nosvc", 5) == 0) {
2099 lmd->lmd_flags |= LMD_FLG_NOSVC;
2101 } else if (strncmp(s1, "nomgs", 5) == 0) {
2102 lmd->lmd_flags |= LMD_FLG_NOMGS;
2104 } else if (strncmp(s1, "noscrub", 7) == 0) {
2105 lmd->lmd_flags |= LMD_FLG_NOSCRUB;
2107 } else if (strncmp(s1, PARAM_MGSNODE,
2108 sizeof(PARAM_MGSNODE) - 1) == 0) {
2109 s2 = s1 + sizeof(PARAM_MGSNODE) - 1;
2110 /* Assume the next mount opt is the first
2111 invalid nid we get to. */
2112 rc = lmd_parse_mgs(lmd, &s2);
2116 } else if (strncmp(s1, "writeconf", 9) == 0) {
2117 lmd->lmd_flags |= LMD_FLG_WRITECONF;
2119 } else if (strncmp(s1, "virgin", 6) == 0) {
2120 lmd->lmd_flags |= LMD_FLG_VIRGIN;
2122 } else if (strncmp(s1, "noprimnode", 10) == 0) {
2123 lmd->lmd_flags |= LMD_FLG_NO_PRIMNODE;
2125 } else if (strncmp(s1, "mgssec=", 7) == 0) {
2126 rc = lmd_parse_mgssec(lmd, s1 + 7);
2130 /* ost exclusion list */
2131 } else if (strncmp(s1, "exclude=", 8) == 0) {
2132 rc = lmd_make_exclusion(lmd, s1 + 7);
2136 } else if (strncmp(s1, "mgs", 3) == 0) {
2138 lmd->lmd_flags |= LMD_FLG_MGS;
2140 } else if (strncmp(s1, "svname=", 7) == 0) {
2141 rc = lmd_parse_string(&lmd->lmd_profile, s1 + 7);
2145 } else if (strncmp(s1, "param=", 6) == 0) {
2147 char *tail = strchr(s1 + 6, ',');
2149 length = strlen(s1);
2153 strncat(lmd->lmd_params, s1 + 6, length);
2154 strcat(lmd->lmd_params, " ");
2156 } else if (strncmp(s1, "osd=", 4) == 0) {
2157 rc = lmd_parse_string(&lmd->lmd_osd_type, s1 + 4);
2162 /* Linux 2.4 doesn't pass the device, so we stuck it at the
2163 end of the options. */
2164 else if (strncmp(s1, "device=", 7) == 0) {
2166 /* terminate options right before device. device
2167 must be the last one. */
2173 s2 = strchr(s1, ',');
2181 memmove(s1, s2, strlen(s2) + 1);
2187 LCONSOLE_ERROR_MSG(0x164, "Can't find the device name "
2188 "(need mount option 'device=...')\n");
2192 s1 = strstr(devname, ":/");
2195 lmd->lmd_flags |= LMD_FLG_CLIENT;
2196 /* Remove leading /s from fsname */
2197 while (*++s1 == '/') ;
2198 /* Freed in lustre_free_lsi */
2199 OBD_ALLOC(lmd->lmd_profile, strlen(s1) + 8);
2200 if (!lmd->lmd_profile)
2202 sprintf(lmd->lmd_profile, "%s-client", s1);
2205 /* Freed in lustre_free_lsi */
2206 OBD_ALLOC(lmd->lmd_dev, strlen(devname) + 1);
2209 strcpy(lmd->lmd_dev, devname);
2211 /* Save mount options */
2212 s1 = options + strlen(options) - 1;
2213 while (s1 >= options && (*s1 == ',' || *s1 == ' '))
2215 if (*options != 0) {
2216 /* Freed in lustre_free_lsi */
2217 OBD_ALLOC(lmd->lmd_opts, strlen(options) + 1);
2220 strcpy(lmd->lmd_opts, options);
2224 lmd->lmd_magic = LMD_MAGIC;
2229 CERROR("Bad mount options %s\n", options);
2233 struct lustre_mount_data2 {
2235 struct vfsmount *lmd2_mnt;
2238 /** This is the entry point for the mount call into Lustre.
2239 * This is called when a server or client is mounted,
2240 * and this is where we start setting things up.
2241 * @param data Mount options (e.g. -o flock,abort_recov)
2243 int lustre_fill_super(struct super_block *sb, void *data, int silent)
2245 struct lustre_mount_data *lmd;
2246 struct lustre_mount_data2 *lmd2 = data;
2247 struct lustre_sb_info *lsi;
2251 CDEBUG(D_MOUNT|D_VFSTRACE, "VFS Op: sb %p\n", sb);
2253 lsi = lustre_init_lsi(sb);
2259 * Disable lockdep during mount, because mount locking patterns are
2265 * LU-639: the obd cleanup of last mount may not finish yet, wait here.
2267 obd_zombie_barrier();
2269 /* Figure out the lmd from the mount options */
2270 if (lmd_parse((char *)(lmd2->lmd2_data), lmd)) {
2272 GOTO(out, rc = -EINVAL);
2275 if (lmd_is_client(lmd)) {
2276 CDEBUG(D_MOUNT, "Mounting client %s\n", lmd->lmd_profile);
2277 if (!client_fill_super) {
2278 LCONSOLE_ERROR_MSG(0x165, "Nothing registered for "
2279 "client mount! Is the 'lustre' "
2280 "module loaded?\n");
2284 rc = lustre_start_mgc(sb);
2289 /* Connect and start */
2290 /* (should always be ll_fill_super) */
2291 rc = (*client_fill_super)(sb, lmd2->lmd2_mnt);
2292 /* c_f_s will call lustre_common_put_super on failure */
2295 CDEBUG(D_MOUNT, "Mounting server from %s\n", lmd->lmd_dev);
2296 rc = server_fill_super(sb);
2297 /* s_f_s calls lustre_start_mgc after the mount because we need
2298 the MGS nids which are stored on disk. Plus, we may
2299 need to start the MGS first. */
2300 /* s_f_s will call server_put_super on failure */
2303 /* If error happens in fill_super() call, @lsi will be killed there.
2304 * This is why we do not put it here. */
2308 CERROR("Unable to mount %s (%d)\n",
2309 s2lsi(sb) ? lmd->lmd_dev : "", rc);
2311 CDEBUG(D_SUPER, "Mount %s complete\n",
2319 /* We can't call ll_fill_super by name because it lives in a module that
2320 must be loaded after this one. */
2321 void lustre_register_client_fill_super(int (*cfs)(struct super_block *sb,
2322 struct vfsmount *mnt))
2324 client_fill_super = cfs;
2326 EXPORT_SYMBOL(lustre_register_client_fill_super);
2328 void lustre_register_kill_super_cb(void (*cfs)(struct super_block *sb))
2330 kill_super_cb = cfs;
2332 EXPORT_SYMBOL(lustre_register_kill_super_cb);
2334 /***************** FS registration ******************/
2335 #ifdef HAVE_FSTYPE_MOUNT
2336 struct dentry *lustre_mount(struct file_system_type *fs_type, int flags,
2337 const char *devname, void *data)
2339 struct lustre_mount_data2 lmd2 = { data, NULL };
2341 return mount_nodev(fs_type, flags, &lmd2, lustre_fill_super);
2344 int lustre_get_sb(struct file_system_type *fs_type, int flags,
2345 const char *devname, void * data, struct vfsmount *mnt)
2347 struct lustre_mount_data2 lmd2 = { data, mnt };
2349 return get_sb_nodev(fs_type, flags, &lmd2, lustre_fill_super, mnt);
2353 void lustre_kill_super(struct super_block *sb)
2355 struct lustre_sb_info *lsi = s2lsi(sb);
2357 if (kill_super_cb && lsi && !IS_SERVER(lsi))
2358 (*kill_super_cb)(sb);
2360 kill_anon_super(sb);
2363 /** Register the "lustre" fs type
2365 struct file_system_type lustre_fs_type = {
2366 .owner = THIS_MODULE,
2368 #ifdef HAVE_FSTYPE_MOUNT
2369 .mount = lustre_mount,
2371 .get_sb = lustre_get_sb,
2373 .kill_sb = lustre_kill_super,
2374 .fs_flags = FS_BINARY_MOUNTDATA | FS_REQUIRES_DEV |
2375 #ifdef FS_HAS_FIEMAP
2378 LL_RENAME_DOES_D_MOVE,
2381 int lustre_register_fs(void)
2383 return register_filesystem(&lustre_fs_type);
2386 int lustre_unregister_fs(void)
2388 return unregister_filesystem(&lustre_fs_type);
2391 EXPORT_SYMBOL(server_mti_print);