Version:  2.0.40 2.2.26 2.4.37 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17

Linux/drivers/staging/lustre/lustre/obdclass/obd_mount.c

  1 /*
  2  * GPL HEADER START
  3  *
  4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  5  *
  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.
  9  *
 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).
 15  *
 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
 19  *
 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
 22  * have any questions.
 23  *
 24  * GPL HEADER END
 25  */
 26 /*
 27  * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
 28  * Use is subject to license terms.
 29  *
 30  * Copyright (c) 2011, 2012, Intel Corporation.
 31  */
 32 /*
 33  * This file is part of Lustre, http://www.lustre.org/
 34  * Lustre is a trademark of Sun Microsystems, Inc.
 35  *
 36  * lustre/obdclass/obd_mount.c
 37  *
 38  * Client mount routines
 39  *
 40  * Author: Nathan Rutman <nathan@clusterfs.com>
 41  */
 42 
 43 
 44 #define DEBUG_SUBSYSTEM S_CLASS
 45 #define D_MOUNT (D_SUPER|D_CONFIG/*|D_WARNING */)
 46 #define PRINT_CMD CDEBUG
 47 
 48 #include "../include/obd.h"
 49 #include "../include/lvfs.h"
 50 #include "../include/obd_class.h"
 51 #include "../include/lustre/lustre_user.h"
 52 #include "../include/lustre_log.h"
 53 #include "../include/lustre_disk.h"
 54 #include "../include/lustre_param.h"
 55 
 56 static int (*client_fill_super)(struct super_block *sb,
 57                                 struct vfsmount *mnt);
 58 
 59 static void (*kill_super_cb)(struct super_block *sb);
 60 
 61 /**************** config llog ********************/
 62 
 63 /** Get a config log from the MGS and process it.
 64  * This func is called for both clients and servers.
 65  * Continue to process new statements appended to the logs
 66  * (whenever the config lock is revoked) until lustre_end_log
 67  * is called.
 68  * @param sb The superblock is used by the MGC to write to the local copy of
 69  *   the config log
 70  * @param logname The name of the llog to replicate from the MGS
 71  * @param cfg Since the same mgc may be used to follow multiple config logs
 72  *   (e.g. ost1, ost2, client), the config_llog_instance keeps the state for
 73  *   this log, and is added to the mgc's list of logs to follow.
 74  */
 75 int lustre_process_log(struct super_block *sb, char *logname,
 76                      struct config_llog_instance *cfg)
 77 {
 78         struct lustre_cfg *lcfg;
 79         struct lustre_cfg_bufs *bufs;
 80         struct lustre_sb_info *lsi = s2lsi(sb);
 81         struct obd_device *mgc = lsi->lsi_mgc;
 82         int rc;
 83 
 84         LASSERT(mgc);
 85         LASSERT(cfg);
 86 
 87         OBD_ALLOC_PTR(bufs);
 88         if (bufs == NULL)
 89                 return -ENOMEM;
 90 
 91         /* mgc_process_config */
 92         lustre_cfg_bufs_reset(bufs, mgc->obd_name);
 93         lustre_cfg_bufs_set_string(bufs, 1, logname);
 94         lustre_cfg_bufs_set(bufs, 2, cfg, sizeof(*cfg));
 95         lustre_cfg_bufs_set(bufs, 3, &sb, sizeof(sb));
 96         lcfg = lustre_cfg_new(LCFG_LOG_START, bufs);
 97         rc = obd_process_config(mgc, sizeof(*lcfg), lcfg);
 98         lustre_cfg_free(lcfg);
 99 
100         OBD_FREE_PTR(bufs);
101 
102         if (rc == -EINVAL)
103                 LCONSOLE_ERROR_MSG(0x15b, "%s: The configuration from log '%s'"
104                                    "failed from the MGS (%d).  Make sure this "
105                                    "client and the MGS are running compatible "
106                                    "versions of Lustre.\n",
107                                    mgc->obd_name, logname, rc);
108 
109         if (rc)
110                 LCONSOLE_ERROR_MSG(0x15c, "%s: The configuration from log '%s' "
111                                    "failed (%d). This may be the result of "
112                                    "communication errors between this node and "
113                                    "the MGS, a bad configuration, or other "
114                                    "errors. See the syslog for more "
115                                    "information.\n", mgc->obd_name, logname,
116                                    rc);
117 
118         /* class_obd_list(); */
119         return rc;
120 }
121 EXPORT_SYMBOL(lustre_process_log);
122 
123 /* Stop watching this config log for updates */
124 int lustre_end_log(struct super_block *sb, char *logname,
125                        struct config_llog_instance *cfg)
126 {
127         struct lustre_cfg *lcfg;
128         struct lustre_cfg_bufs bufs;
129         struct lustre_sb_info *lsi = s2lsi(sb);
130         struct obd_device *mgc = lsi->lsi_mgc;
131         int rc;
132 
133         if (!mgc)
134                 return -ENOENT;
135 
136         /* mgc_process_config */
137         lustre_cfg_bufs_reset(&bufs, mgc->obd_name);
138         lustre_cfg_bufs_set_string(&bufs, 1, logname);
139         if (cfg)
140                 lustre_cfg_bufs_set(&bufs, 2, cfg, sizeof(*cfg));
141         lcfg = lustre_cfg_new(LCFG_LOG_END, &bufs);
142         rc = obd_process_config(mgc, sizeof(*lcfg), lcfg);
143         lustre_cfg_free(lcfg);
144         return rc;
145 }
146 EXPORT_SYMBOL(lustre_end_log);
147 
148 /**************** obd start *******************/
149 
150 /** lustre_cfg_bufs are a holdover from 1.4; we can still set these up from
151  * lctl (and do for echo cli/srv.
152  */
153 int do_lcfg(char *cfgname, lnet_nid_t nid, int cmd,
154             char *s1, char *s2, char *s3, char *s4)
155 {
156         struct lustre_cfg_bufs bufs;
157         struct lustre_cfg    * lcfg = NULL;
158         int rc;
159 
160         CDEBUG(D_TRACE, "lcfg %s %#x %s %s %s %s\n", cfgname,
161                cmd, s1, s2, s3, s4);
162 
163         lustre_cfg_bufs_reset(&bufs, cfgname);
164         if (s1)
165                 lustre_cfg_bufs_set_string(&bufs, 1, s1);
166         if (s2)
167                 lustre_cfg_bufs_set_string(&bufs, 2, s2);
168         if (s3)
169                 lustre_cfg_bufs_set_string(&bufs, 3, s3);
170         if (s4)
171                 lustre_cfg_bufs_set_string(&bufs, 4, s4);
172 
173         lcfg = lustre_cfg_new(cmd, &bufs);
174         lcfg->lcfg_nid = nid;
175         rc = class_process_config(lcfg);
176         lustre_cfg_free(lcfg);
177         return(rc);
178 }
179 EXPORT_SYMBOL(do_lcfg);
180 
181 /** Call class_attach and class_setup.  These methods in turn call
182  * obd type-specific methods.
183  */
184 int lustre_start_simple(char *obdname, char *type, char *uuid,
185                         char *s1, char *s2, char *s3, char *s4)
186 {
187         int rc;
188         CDEBUG(D_MOUNT, "Starting obd %s (typ=%s)\n", obdname, type);
189 
190         rc = do_lcfg(obdname, 0, LCFG_ATTACH, type, uuid, NULL, NULL);
191         if (rc) {
192                 CERROR("%s attach error %d\n", obdname, rc);
193                 return rc;
194         }
195         rc = do_lcfg(obdname, 0, LCFG_SETUP, s1, s2, s3, s4);
196         if (rc) {
197                 CERROR("%s setup error %d\n", obdname, rc);
198                 do_lcfg(obdname, 0, LCFG_DETACH, NULL, NULL, NULL, NULL);
199         }
200         return rc;
201 }
202 
203 DEFINE_MUTEX(mgc_start_lock);
204 
205 /** Set up a mgc obd to process startup logs
206  *
207  * \param sb [in] super block of the mgc obd
208  *
209  * \retval 0 success, otherwise error code
210  */
211 int lustre_start_mgc(struct super_block *sb)
212 {
213         struct obd_connect_data *data = NULL;
214         struct lustre_sb_info *lsi = s2lsi(sb);
215         struct obd_device *obd;
216         struct obd_export *exp;
217         struct obd_uuid *uuid;
218         class_uuid_t uuidc;
219         lnet_nid_t nid;
220         char *mgcname = NULL, *niduuid = NULL, *mgssec = NULL;
221         char *ptr;
222         int rc = 0, i = 0, j, len;
223 
224         LASSERT(lsi->lsi_lmd);
225 
226         /* Find the first non-lo MGS nid for our MGC name */
227         if (IS_SERVER(lsi)) {
228                 /* mount -o mgsnode=nid */
229                 ptr = lsi->lsi_lmd->lmd_mgs;
230                 if (lsi->lsi_lmd->lmd_mgs &&
231                     (class_parse_nid(lsi->lsi_lmd->lmd_mgs, &nid, &ptr) == 0)) {
232                         i++;
233                 } else if (IS_MGS(lsi)) {
234                         lnet_process_id_t id;
235                         while ((rc = LNetGetId(i++, &id)) != -ENOENT) {
236                                 if (LNET_NETTYP(LNET_NIDNET(id.nid)) == LOLND)
237                                         continue;
238                                 nid = id.nid;
239                                 i++;
240                                 break;
241                         }
242                 }
243         } else { /* client */
244                 /* Use nids from mount line: uml1,1@elan:uml2,2@elan:/lustre */
245                 ptr = lsi->lsi_lmd->lmd_dev;
246                 if (class_parse_nid(ptr, &nid, &ptr) == 0)
247                         i++;
248         }
249         if (i == 0) {
250                 CERROR("No valid MGS nids found.\n");
251                 return -EINVAL;
252         }
253 
254         mutex_lock(&mgc_start_lock);
255 
256         len = strlen(LUSTRE_MGC_OBDNAME) + strlen(libcfs_nid2str(nid)) + 1;
257         OBD_ALLOC(mgcname, len);
258         OBD_ALLOC(niduuid, len + 2);
259         if (!mgcname || !niduuid)
260                 GOTO(out_free, rc = -ENOMEM);
261         sprintf(mgcname, "%s%s", LUSTRE_MGC_OBDNAME, libcfs_nid2str(nid));
262 
263         mgssec = lsi->lsi_lmd->lmd_mgssec ? lsi->lsi_lmd->lmd_mgssec : "";
264 
265         OBD_ALLOC_PTR(data);
266         if (data == NULL)
267                 GOTO(out_free, rc = -ENOMEM);
268 
269         obd = class_name2obd(mgcname);
270         if (obd && !obd->obd_stopping) {
271                 int recov_bk;
272 
273                 rc = obd_set_info_async(NULL, obd->obd_self_export,
274                                         strlen(KEY_MGSSEC), KEY_MGSSEC,
275                                         strlen(mgssec), mgssec, NULL);
276                 if (rc)
277                         GOTO(out_free, rc);
278 
279                 /* Re-using an existing MGC */
280                 atomic_inc(&obd->u.cli.cl_mgc_refcount);
281 
282                 /* IR compatibility check, only for clients */
283                 if (lmd_is_client(lsi->lsi_lmd)) {
284                         int has_ir;
285                         int vallen = sizeof(*data);
286                         __u32 *flags = &lsi->lsi_lmd->lmd_flags;
287 
288                         rc = obd_get_info(NULL, obd->obd_self_export,
289                                           strlen(KEY_CONN_DATA), KEY_CONN_DATA,
290                                           &vallen, data, NULL);
291                         LASSERT(rc == 0);
292                         has_ir = OCD_HAS_FLAG(data, IMP_RECOV);
293                         if (has_ir ^ !(*flags & LMD_FLG_NOIR)) {
294                                 /* LMD_FLG_NOIR is for test purpose only */
295                                 LCONSOLE_WARN(
296                                     "Trying to mount a client with IR setting "
297                                     "not compatible with current mgc. "
298                                     "Force to use current mgc setting that is "
299                                     "IR %s.\n",
300                                     has_ir ? "enabled" : "disabled");
301                                 if (has_ir)
302                                         *flags &= ~LMD_FLG_NOIR;
303                                 else
304                                         *flags |= LMD_FLG_NOIR;
305                         }
306                 }
307 
308                 recov_bk = 0;
309                 /* If we are restarting the MGS, don't try to keep the MGC's
310                    old connection, or registration will fail. */
311                 if (IS_MGS(lsi)) {
312                         CDEBUG(D_MOUNT, "New MGS with live MGC\n");
313                         recov_bk = 1;
314                 }
315 
316                 /* Try all connections, but only once (again).
317                    We don't want to block another target from starting
318                    (using its local copy of the log), but we do want to connect
319                    if at all possible. */
320                 recov_bk++;
321                 CDEBUG(D_MOUNT, "%s: Set MGC reconnect %d\n", mgcname,recov_bk);
322                 rc = obd_set_info_async(NULL, obd->obd_self_export,
323                                         sizeof(KEY_INIT_RECOV_BACKUP),
324                                         KEY_INIT_RECOV_BACKUP,
325                                         sizeof(recov_bk), &recov_bk, NULL);
326                 GOTO(out, rc = 0);
327         }
328 
329         CDEBUG(D_MOUNT, "Start MGC '%s'\n", mgcname);
330 
331         /* Add the primary nids for the MGS */
332         i = 0;
333         sprintf(niduuid, "%s_%x", mgcname, i);
334         if (IS_SERVER(lsi)) {
335                 ptr = lsi->lsi_lmd->lmd_mgs;
336                 if (IS_MGS(lsi)) {
337                         /* Use local nids (including LO) */
338                         lnet_process_id_t id;
339                         while ((rc = LNetGetId(i++, &id)) != -ENOENT) {
340                                 rc = do_lcfg(mgcname, id.nid,
341                                              LCFG_ADD_UUID, niduuid,
342                                              NULL, NULL, NULL);
343                         }
344                 } else {
345                         /* Use mgsnode= nids */
346                         /* mount -o mgsnode=nid */
347                         if (lsi->lsi_lmd->lmd_mgs) {
348                                 ptr = lsi->lsi_lmd->lmd_mgs;
349                         } else if (class_find_param(ptr, PARAM_MGSNODE,
350                                                     &ptr) != 0) {
351                                 CERROR("No MGS nids given.\n");
352                                 GOTO(out_free, rc = -EINVAL);
353                         }
354                         while (class_parse_nid(ptr, &nid, &ptr) == 0) {
355                                 rc = do_lcfg(mgcname, nid,
356                                              LCFG_ADD_UUID, niduuid,
357                                              NULL, NULL, NULL);
358                                 i++;
359                         }
360                 }
361         } else { /* client */
362                 /* Use nids from mount line: uml1,1@elan:uml2,2@elan:/lustre */
363                 ptr = lsi->lsi_lmd->lmd_dev;
364                 while (class_parse_nid(ptr, &nid, &ptr) == 0) {
365                         rc = do_lcfg(mgcname, nid,
366                                      LCFG_ADD_UUID, niduuid, NULL, NULL, NULL);
367                         i++;
368                         /* Stop at the first failover nid */
369                         if (*ptr == ':')
370                                 break;
371                 }
372         }
373         if (i == 0) {
374                 CERROR("No valid MGS nids found.\n");
375                 GOTO(out_free, rc = -EINVAL);
376         }
377         lsi->lsi_lmd->lmd_mgs_failnodes = 1;
378 
379         /* Random uuid for MGC allows easier reconnects */
380         OBD_ALLOC_PTR(uuid);
381         ll_generate_random_uuid(uuidc);
382         class_uuid_unparse(uuidc, uuid);
383 
384         /* Start the MGC */
385         rc = lustre_start_simple(mgcname, LUSTRE_MGC_NAME,
386                                  (char *)uuid->uuid, LUSTRE_MGS_OBDNAME,
387                                  niduuid, NULL, NULL);
388         OBD_FREE_PTR(uuid);
389         if (rc)
390                 GOTO(out_free, rc);
391 
392         /* Add any failover MGS nids */
393         i = 1;
394         while (ptr && ((*ptr == ':' ||
395                class_find_param(ptr, PARAM_MGSNODE, &ptr) == 0))) {
396                 /* New failover node */
397                 sprintf(niduuid, "%s_%x", mgcname, i);
398                 j = 0;
399                 while (class_parse_nid_quiet(ptr, &nid, &ptr) == 0) {
400                         j++;
401                         rc = do_lcfg(mgcname, nid,
402                                      LCFG_ADD_UUID, niduuid, NULL, NULL, NULL);
403                         if (*ptr == ':')
404                                 break;
405                 }
406                 if (j > 0) {
407                         rc = do_lcfg(mgcname, 0, LCFG_ADD_CONN,
408                                      niduuid, NULL, NULL, NULL);
409                         i++;
410                 } else {
411                         /* at ":/fsname" */
412                         break;
413                 }
414         }
415         lsi->lsi_lmd->lmd_mgs_failnodes = i;
416 
417         obd = class_name2obd(mgcname);
418         if (!obd) {
419                 CERROR("Can't find mgcobd %s\n", mgcname);
420                 GOTO(out_free, rc = -ENOTCONN);
421         }
422 
423         rc = obd_set_info_async(NULL, obd->obd_self_export,
424                                 strlen(KEY_MGSSEC), KEY_MGSSEC,
425                                 strlen(mgssec), mgssec, NULL);
426         if (rc)
427                 GOTO(out_free, rc);
428 
429         /* Keep a refcount of servers/clients who started with "mount",
430            so we know when we can get rid of the mgc. */
431         atomic_set(&obd->u.cli.cl_mgc_refcount, 1);
432 
433         /* We connect to the MGS at setup, and don't disconnect until cleanup */
434         data->ocd_connect_flags = OBD_CONNECT_VERSION | OBD_CONNECT_AT |
435                                   OBD_CONNECT_FULL20 | OBD_CONNECT_IMP_RECOV |
436                                   OBD_CONNECT_LVB_TYPE;
437 
438 #if LUSTRE_VERSION_CODE < OBD_OCD_VERSION(3, 2, 50, 0)
439         data->ocd_connect_flags |= OBD_CONNECT_MNE_SWAB;
440 #else
441 #warning "LU-1644: Remove old OBD_CONNECT_MNE_SWAB fixup and imp_need_mne_swab"
442 #endif
443 
444         if (lmd_is_client(lsi->lsi_lmd) &&
445             lsi->lsi_lmd->lmd_flags & LMD_FLG_NOIR)
446                 data->ocd_connect_flags &= ~OBD_CONNECT_IMP_RECOV;
447         data->ocd_version = LUSTRE_VERSION_CODE;
448         rc = obd_connect(NULL, &exp, obd, &(obd->obd_uuid), data, NULL);
449         if (rc) {
450                 CERROR("connect failed %d\n", rc);
451                 GOTO(out, rc);
452         }
453 
454         obd->u.cli.cl_mgc_mgsexp = exp;
455 
456 out:
457         /* Keep the mgc info in the sb. Note that many lsi's can point
458            to the same mgc.*/
459         lsi->lsi_mgc = obd;
460 out_free:
461         mutex_unlock(&mgc_start_lock);
462 
463         if (data)
464                 OBD_FREE_PTR(data);
465         if (mgcname)
466                 OBD_FREE(mgcname, len);
467         if (niduuid)
468                 OBD_FREE(niduuid, len + 2);
469         return rc;
470 }
471 
472 static int lustre_stop_mgc(struct super_block *sb)
473 {
474         struct lustre_sb_info *lsi = s2lsi(sb);
475         struct obd_device *obd;
476         char *niduuid = NULL, *ptr = NULL;
477         int i, rc = 0, len = 0;
478 
479         if (!lsi)
480                 return -ENOENT;
481         obd = lsi->lsi_mgc;
482         if (!obd)
483                 return -ENOENT;
484         lsi->lsi_mgc = NULL;
485 
486         mutex_lock(&mgc_start_lock);
487         LASSERT(atomic_read(&obd->u.cli.cl_mgc_refcount) > 0);
488         if (!atomic_dec_and_test(&obd->u.cli.cl_mgc_refcount)) {
489                 /* This is not fatal, every client that stops
490                    will call in here. */
491                 CDEBUG(D_MOUNT, "mgc still has %d references.\n",
492                        atomic_read(&obd->u.cli.cl_mgc_refcount));
493                 GOTO(out, rc = -EBUSY);
494         }
495 
496         /* The MGC has no recoverable data in any case.
497          * force shutdown set in umount_begin */
498         obd->obd_no_recov = 1;
499 
500         if (obd->u.cli.cl_mgc_mgsexp) {
501                 /* An error is not fatal, if we are unable to send the
502                    disconnect mgs ping evictor cleans up the export */
503                 rc = obd_disconnect(obd->u.cli.cl_mgc_mgsexp);
504                 if (rc)
505                         CDEBUG(D_MOUNT, "disconnect failed %d\n", rc);
506         }
507 
508         /* Save the obdname for cleaning the nid uuids, which are
509            obdname_XX */
510         len = strlen(obd->obd_name) + 6;
511         OBD_ALLOC(niduuid, len);
512         if (niduuid) {
513                 strcpy(niduuid, obd->obd_name);
514                 ptr = niduuid + strlen(niduuid);
515         }
516 
517         rc = class_manual_cleanup(obd);
518         if (rc)
519                 GOTO(out, rc);
520 
521         /* Clean the nid uuids */
522         if (!niduuid)
523                 GOTO(out, rc = -ENOMEM);
524 
525         for (i = 0; i < lsi->lsi_lmd->lmd_mgs_failnodes; i++) {
526                 sprintf(ptr, "_%x", i);
527                 rc = do_lcfg(LUSTRE_MGC_OBDNAME, 0, LCFG_DEL_UUID,
528                              niduuid, NULL, NULL, NULL);
529                 if (rc)
530                         CERROR("del MDC UUID %s failed: rc = %d\n",
531                                niduuid, rc);
532         }
533 out:
534         if (niduuid)
535                 OBD_FREE(niduuid, len);
536 
537         /* class_import_put will get rid of the additional connections */
538         mutex_unlock(&mgc_start_lock);
539         return rc;
540 }
541 
542 /***************** lustre superblock **************/
543 
544 struct lustre_sb_info *lustre_init_lsi(struct super_block *sb)
545 {
546         struct lustre_sb_info *lsi;
547 
548         OBD_ALLOC_PTR(lsi);
549         if (!lsi)
550                 return NULL;
551         OBD_ALLOC_PTR(lsi->lsi_lmd);
552         if (!lsi->lsi_lmd) {
553                 OBD_FREE_PTR(lsi);
554                 return NULL;
555         }
556 
557         lsi->lsi_lmd->lmd_exclude_count = 0;
558         lsi->lsi_lmd->lmd_recovery_time_soft = 0;
559         lsi->lsi_lmd->lmd_recovery_time_hard = 0;
560         s2lsi_nocast(sb) = lsi;
561         /* we take 1 extra ref for our setup */
562         atomic_set(&lsi->lsi_mounts, 1);
563 
564         /* Default umount style */
565         lsi->lsi_flags = LSI_UMOUNT_FAILOVER;
566 
567         return lsi;
568 }
569 
570 static int lustre_free_lsi(struct super_block *sb)
571 {
572         struct lustre_sb_info *lsi = s2lsi(sb);
573 
574         LASSERT(lsi != NULL);
575         CDEBUG(D_MOUNT, "Freeing lsi %p\n", lsi);
576 
577         /* someone didn't call server_put_mount. */
578         LASSERT(atomic_read(&lsi->lsi_mounts) == 0);
579 
580         if (lsi->lsi_lmd != NULL) {
581                 if (lsi->lsi_lmd->lmd_dev != NULL)
582                         OBD_FREE(lsi->lsi_lmd->lmd_dev,
583                                  strlen(lsi->lsi_lmd->lmd_dev) + 1);
584                 if (lsi->lsi_lmd->lmd_profile != NULL)
585                         OBD_FREE(lsi->lsi_lmd->lmd_profile,
586                                  strlen(lsi->lsi_lmd->lmd_profile) + 1);
587                 if (lsi->lsi_lmd->lmd_mgssec != NULL)
588                         OBD_FREE(lsi->lsi_lmd->lmd_mgssec,
589                                  strlen(lsi->lsi_lmd->lmd_mgssec) + 1);
590                 if (lsi->lsi_lmd->lmd_opts != NULL)
591                         OBD_FREE(lsi->lsi_lmd->lmd_opts,
592                                  strlen(lsi->lsi_lmd->lmd_opts) + 1);
593                 if (lsi->lsi_lmd->lmd_exclude_count)
594                         OBD_FREE(lsi->lsi_lmd->lmd_exclude,
595                                  sizeof(lsi->lsi_lmd->lmd_exclude[0]) *
596                                  lsi->lsi_lmd->lmd_exclude_count);
597                 if (lsi->lsi_lmd->lmd_mgs != NULL)
598                         OBD_FREE(lsi->lsi_lmd->lmd_mgs,
599                                  strlen(lsi->lsi_lmd->lmd_mgs) + 1);
600                 if (lsi->lsi_lmd->lmd_osd_type != NULL)
601                         OBD_FREE(lsi->lsi_lmd->lmd_osd_type,
602                                  strlen(lsi->lsi_lmd->lmd_osd_type) + 1);
603                 if (lsi->lsi_lmd->lmd_params != NULL)
604                         OBD_FREE(lsi->lsi_lmd->lmd_params, 4096);
605 
606                 OBD_FREE(lsi->lsi_lmd, sizeof(*lsi->lsi_lmd));
607         }
608 
609         LASSERT(lsi->lsi_llsbi == NULL);
610         OBD_FREE(lsi, sizeof(*lsi));
611         s2lsi_nocast(sb) = NULL;
612 
613         return 0;
614 }
615 
616 /* The lsi has one reference for every server that is using the disk -
617    e.g. MDT, MGS, and potentially MGC */
618 int lustre_put_lsi(struct super_block *sb)
619 {
620         struct lustre_sb_info *lsi = s2lsi(sb);
621 
622         LASSERT(lsi != NULL);
623 
624         CDEBUG(D_MOUNT, "put %p %d\n", sb, atomic_read(&lsi->lsi_mounts));
625         if (atomic_dec_and_test(&lsi->lsi_mounts)) {
626                 if (IS_SERVER(lsi) && lsi->lsi_osd_exp) {
627                         lu_device_put(&lsi->lsi_dt_dev->dd_lu_dev);
628                         lsi->lsi_osd_exp->exp_obd->obd_lvfs_ctxt.dt = NULL;
629                         lsi->lsi_dt_dev = NULL;
630                         obd_disconnect(lsi->lsi_osd_exp);
631                         /* wait till OSD is gone */
632                         obd_zombie_barrier();
633                 }
634                 lustre_free_lsi(sb);
635                 return 1;
636         }
637         return 0;
638 }
639 
640 /*** SERVER NAME ***
641  * <FSNAME><SEPERATOR><TYPE><INDEX>
642  * FSNAME is between 1 and 8 characters (inclusive).
643  *      Excluded characters are '/' and ':'
644  * SEPERATOR is either ':' or '-'
645  * TYPE: "OST", "MDT", etc.
646  * INDEX: Hex representation of the index
647  */
648 
649 /** Get the fsname ("lustre") from the server name ("lustre-OST003F").
650  * @param [in] svname server name including type and index
651  * @param [out] fsname Buffer to copy filesystem name prefix into.
652  *  Must have at least 'strlen(fsname) + 1' chars.
653  * @param [out] endptr if endptr isn't NULL it is set to end of fsname
654  * rc < 0  on error
655  */
656 int server_name2fsname(const char *svname, char *fsname, const char **endptr)
657 {
658         const char *dash;
659 
660         dash = svname + strnlen(svname, 8); /* max fsname length is 8 */
661         for (; dash > svname && *dash != '-' && *dash != ':'; dash--)
662                 ;
663         if (dash == svname)
664                 return -EINVAL;
665 
666         if (fsname != NULL) {
667                 strncpy(fsname, svname, dash - svname);
668                 fsname[dash - svname] = '\0';
669         }
670 
671         if (endptr != NULL)
672                 *endptr = dash;
673 
674         return 0;
675 }
676 EXPORT_SYMBOL(server_name2fsname);
677 
678 /**
679  * Get service name (svname) from string
680  * rc < 0 on error
681  * if endptr isn't NULL it is set to end of fsname *
682  */
683 int server_name2svname(const char *label, char *svname, const char **endptr,
684                        size_t svsize)
685 {
686         int rc;
687         const char *dash;
688 
689         /* We use server_name2fsname() just for parsing */
690         rc = server_name2fsname(label, NULL, &dash);
691         if (rc != 0)
692                 return rc;
693 
694         if (endptr != NULL)
695                 *endptr = dash;
696 
697         if (strlcpy(svname, dash + 1, svsize) >= svsize)
698                 return -E2BIG;
699 
700         return 0;
701 }
702 EXPORT_SYMBOL(server_name2svname);
703 
704 
705 /* Get the index from the obd name.
706    rc = server type, or
707    rc < 0  on error
708    if endptr isn't NULL it is set to end of name */
709 int server_name2index(const char *svname, __u32 *idx, const char **endptr)
710 {
711         unsigned long index;
712         int rc;
713         const char *dash;
714 
715         /* We use server_name2fsname() just for parsing */
716         rc = server_name2fsname(svname, NULL, &dash);
717         if (rc != 0)
718                 return rc;
719 
720         dash++;
721 
722         if (strncmp(dash, "MDT", 3) == 0)
723                 rc = LDD_F_SV_TYPE_MDT;
724         else if (strncmp(dash, "OST", 3) == 0)
725                 rc = LDD_F_SV_TYPE_OST;
726         else
727                 return -EINVAL;
728 
729         dash += 3;
730 
731         if (strncmp(dash, "all", 3) == 0) {
732                 if (endptr != NULL)
733                         *endptr = dash + 3;
734                 return rc | LDD_F_SV_ALL;
735         }
736 
737         index = simple_strtoul(dash, (char **)endptr, 16);
738         if (idx != NULL)
739                 *idx = index;
740 
741         /* Account for -mdc after index that is possible when specifying mdt */
742         if (endptr != NULL && strncmp(LUSTRE_MDC_NAME, *endptr + 1,
743                                       sizeof(LUSTRE_MDC_NAME)-1) == 0)
744                 *endptr += sizeof(LUSTRE_MDC_NAME);
745 
746         return rc;
747 }
748 EXPORT_SYMBOL(server_name2index);
749 
750 /*************** mount common between server and client ***************/
751 
752 /* Common umount */
753 int lustre_common_put_super(struct super_block *sb)
754 {
755         int rc;
756 
757         CDEBUG(D_MOUNT, "dropping sb %p\n", sb);
758 
759         /* Drop a ref to the MGC */
760         rc = lustre_stop_mgc(sb);
761         if (rc && (rc != -ENOENT)) {
762                 if (rc != -EBUSY) {
763                         CERROR("Can't stop MGC: %d\n", rc);
764                         return rc;
765                 }
766                 /* BUSY just means that there's some other obd that
767                    needs the mgc.  Let him clean it up. */
768                 CDEBUG(D_MOUNT, "MGC still in use\n");
769         }
770         /* Drop a ref to the mounted disk */
771         lustre_put_lsi(sb);
772         lu_types_stop();
773         return rc;
774 }
775 EXPORT_SYMBOL(lustre_common_put_super);
776 
777 static void lmd_print(struct lustre_mount_data *lmd)
778 {
779         int i;
780 
781         PRINT_CMD(D_MOUNT, "  mount data:\n");
782         if (lmd_is_client(lmd))
783                 PRINT_CMD(D_MOUNT, "profile: %s\n", lmd->lmd_profile);
784         PRINT_CMD(D_MOUNT, "device:  %s\n", lmd->lmd_dev);
785         PRINT_CMD(D_MOUNT, "flags:   %x\n", lmd->lmd_flags);
786 
787         if (lmd->lmd_opts)
788                 PRINT_CMD(D_MOUNT, "options: %s\n", lmd->lmd_opts);
789 
790         if (lmd->lmd_recovery_time_soft)
791                 PRINT_CMD(D_MOUNT, "recovery time soft: %d\n",
792                           lmd->lmd_recovery_time_soft);
793 
794         if (lmd->lmd_recovery_time_hard)
795                 PRINT_CMD(D_MOUNT, "recovery time hard: %d\n",
796                           lmd->lmd_recovery_time_hard);
797 
798         for (i = 0; i < lmd->lmd_exclude_count; i++) {
799                 PRINT_CMD(D_MOUNT, "exclude %d:  OST%04x\n", i,
800                           lmd->lmd_exclude[i]);
801         }
802 }
803 
804 /* Is this server on the exclusion list */
805 int lustre_check_exclusion(struct super_block *sb, char *svname)
806 {
807         struct lustre_sb_info *lsi = s2lsi(sb);
808         struct lustre_mount_data *lmd = lsi->lsi_lmd;
809         __u32 index;
810         int i, rc;
811 
812         rc = server_name2index(svname, &index, NULL);
813         if (rc != LDD_F_SV_TYPE_OST)
814                 /* Only exclude OSTs */
815                 return 0;
816 
817         CDEBUG(D_MOUNT, "Check exclusion %s (%d) in %d of %s\n", svname,
818                index, lmd->lmd_exclude_count, lmd->lmd_dev);
819 
820         for(i = 0; i < lmd->lmd_exclude_count; i++) {
821                 if (index == lmd->lmd_exclude[i]) {
822                         CWARN("Excluding %s (on exclusion list)\n", svname);
823                         return 1;
824                 }
825         }
826         return 0;
827 }
828 
829 /* mount -v  -o exclude=lustre-OST0001:lustre-OST0002 -t lustre ... */
830 static int lmd_make_exclusion(struct lustre_mount_data *lmd, const char *ptr)
831 {
832         const char *s1 = ptr, *s2;
833         __u32 index, *exclude_list;
834         int rc = 0, devmax;
835 
836         /* The shortest an ost name can be is 8 chars: -OST0000.
837            We don't actually know the fsname at this time, so in fact
838            a user could specify any fsname. */
839         devmax = strlen(ptr) / 8 + 1;
840 
841         /* temp storage until we figure out how many we have */
842         OBD_ALLOC(exclude_list, sizeof(index) * devmax);
843         if (!exclude_list)
844                 return -ENOMEM;
845 
846         /* we enter this fn pointing at the '=' */
847         while (*s1 && *s1 != ' ' && *s1 != ',') {
848                 s1++;
849                 rc = server_name2index(s1, &index, &s2);
850                 if (rc < 0) {
851                         CERROR("Can't parse server name '%s': rc = %d\n",
852                                s1, rc);
853                         break;
854                 }
855                 if (rc == LDD_F_SV_TYPE_OST)
856                         exclude_list[lmd->lmd_exclude_count++] = index;
857                 else
858                         CDEBUG(D_MOUNT, "ignoring exclude %.*s: type = %#x\n",
859                                (uint)(s2-s1), s1, rc);
860                 s1 = s2;
861                 /* now we are pointing at ':' (next exclude)
862                    or ',' (end of excludes) */
863                 if (lmd->lmd_exclude_count >= devmax)
864                         break;
865         }
866         if (rc >= 0) /* non-err */
867                 rc = 0;
868 
869         if (lmd->lmd_exclude_count) {
870                 /* permanent, freed in lustre_free_lsi */
871                 OBD_ALLOC(lmd->lmd_exclude, sizeof(index) *
872                           lmd->lmd_exclude_count);
873                 if (lmd->lmd_exclude) {
874                         memcpy(lmd->lmd_exclude, exclude_list,
875                                sizeof(index) * lmd->lmd_exclude_count);
876                 } else {
877                         rc = -ENOMEM;
878                         lmd->lmd_exclude_count = 0;
879                 }
880         }
881         OBD_FREE(exclude_list, sizeof(index) * devmax);
882         return rc;
883 }
884 
885 static int lmd_parse_mgssec(struct lustre_mount_data *lmd, char *ptr)
886 {
887         char   *tail;
888         int     length;
889 
890         if (lmd->lmd_mgssec != NULL) {
891                 OBD_FREE(lmd->lmd_mgssec, strlen(lmd->lmd_mgssec) + 1);
892                 lmd->lmd_mgssec = NULL;
893         }
894 
895         tail = strchr(ptr, ',');
896         if (tail == NULL)
897                 length = strlen(ptr);
898         else
899                 length = tail - ptr;
900 
901         OBD_ALLOC(lmd->lmd_mgssec, length + 1);
902         if (lmd->lmd_mgssec == NULL)
903                 return -ENOMEM;
904 
905         memcpy(lmd->lmd_mgssec, ptr, length);
906         lmd->lmd_mgssec[length] = '\0';
907         return 0;
908 }
909 
910 static int lmd_parse_string(char **handle, char *ptr)
911 {
912         char   *tail;
913         int     length;
914 
915         if ((handle == NULL) || (ptr == NULL))
916                 return -EINVAL;
917 
918         if (*handle != NULL) {
919                 OBD_FREE(*handle, strlen(*handle) + 1);
920                 *handle = NULL;
921         }
922 
923         tail = strchr(ptr, ',');
924         if (tail == NULL)
925                 length = strlen(ptr);
926         else
927                 length = tail - ptr;
928 
929         OBD_ALLOC(*handle, length + 1);
930         if (*handle == NULL)
931                 return -ENOMEM;
932 
933         memcpy(*handle, ptr, length);
934         (*handle)[length] = '\0';
935 
936         return 0;
937 }
938 
939 /* Collect multiple values for mgsnid specifiers */
940 static int lmd_parse_mgs(struct lustre_mount_data *lmd, char **ptr)
941 {
942         lnet_nid_t nid;
943         char *tail = *ptr;
944         char *mgsnid;
945         int   length;
946         int   oldlen = 0;
947 
948         /* Find end of nidlist */
949         while (class_parse_nid_quiet(tail, &nid, &tail) == 0) {}
950         length = tail - *ptr;
951         if (length == 0) {
952                 LCONSOLE_ERROR_MSG(0x159, "Can't parse NID '%s'\n", *ptr);
953                 return -EINVAL;
954         }
955 
956         if (lmd->lmd_mgs != NULL)
957                 oldlen = strlen(lmd->lmd_mgs) + 1;
958 
959         OBD_ALLOC(mgsnid, oldlen + length + 1);
960         if (mgsnid == NULL)
961                 return -ENOMEM;
962 
963         if (lmd->lmd_mgs != NULL) {
964                 /* Multiple mgsnid= are taken to mean failover locations */
965                 memcpy(mgsnid, lmd->lmd_mgs, oldlen);
966                 mgsnid[oldlen - 1] = ':';
967                 OBD_FREE(lmd->lmd_mgs, oldlen);
968         }
969         memcpy(mgsnid + oldlen, *ptr, length);
970         mgsnid[oldlen + length] = '\0';
971         lmd->lmd_mgs = mgsnid;
972         *ptr = tail;
973 
974         return 0;
975 }
976 
977 /** Parse mount line options
978  * e.g. mount -v -t lustre -o abort_recov uml1:uml2:/lustre-client /mnt/lustre
979  * dev is passed as device=uml1:/lustre by mount.lustre
980  */
981 static int lmd_parse(char *options, struct lustre_mount_data *lmd)
982 {
983         char *s1, *s2, *devname = NULL;
984         struct lustre_mount_data *raw = (struct lustre_mount_data *)options;
985         int rc = 0;
986 
987         LASSERT(lmd);
988         if (!options) {
989                 LCONSOLE_ERROR_MSG(0x162, "Missing mount data: check that "
990                                    "/sbin/mount.lustre is installed.\n");
991                 return -EINVAL;
992         }
993 
994         /* Options should be a string - try to detect old lmd data */
995         if ((raw->lmd_magic & 0xffffff00) == (LMD_MAGIC & 0xffffff00)) {
996                 LCONSOLE_ERROR_MSG(0x163, "You're using an old version of "
997                                    "/sbin/mount.lustre.  Please install "
998                                    "version %s\n", LUSTRE_VERSION_STRING);
999                 return -EINVAL;
1000         }
1001         lmd->lmd_magic = LMD_MAGIC;
1002 
1003         OBD_ALLOC(lmd->lmd_params, 4096);
1004         if (lmd->lmd_params == NULL)
1005                 return -ENOMEM;
1006         lmd->lmd_params[0] = '\0';
1007 
1008         /* Set default flags here */
1009 
1010         s1 = options;
1011         while (*s1) {
1012                 int clear = 0;
1013                 int time_min = OBD_RECOVERY_TIME_MIN;
1014 
1015                 /* Skip whitespace and extra commas */
1016                 while (*s1 == ' ' || *s1 == ',')
1017                         s1++;
1018 
1019                 /* Client options are parsed in ll_options: eg. flock,
1020                    user_xattr, acl */
1021 
1022                 /* Parse non-ldiskfs options here. Rather than modifying
1023                    ldiskfs, we just zero these out here */
1024                 if (strncmp(s1, "abort_recov", 11) == 0) {
1025                         lmd->lmd_flags |= LMD_FLG_ABORT_RECOV;
1026                         clear++;
1027                 } else if (strncmp(s1, "recovery_time_soft=", 19) == 0) {
1028                         lmd->lmd_recovery_time_soft = max_t(int,
1029                                 simple_strtoul(s1 + 19, NULL, 10), time_min);
1030                         clear++;
1031                 } else if (strncmp(s1, "recovery_time_hard=", 19) == 0) {
1032                         lmd->lmd_recovery_time_hard = max_t(int,
1033                                 simple_strtoul(s1 + 19, NULL, 10), time_min);
1034                         clear++;
1035                 } else if (strncmp(s1, "noir", 4) == 0) {
1036                         lmd->lmd_flags |= LMD_FLG_NOIR; /* test purpose only. */
1037                         clear++;
1038                 } else if (strncmp(s1, "nosvc", 5) == 0) {
1039                         lmd->lmd_flags |= LMD_FLG_NOSVC;
1040                         clear++;
1041                 } else if (strncmp(s1, "nomgs", 5) == 0) {
1042                         lmd->lmd_flags |= LMD_FLG_NOMGS;
1043                         clear++;
1044                 } else if (strncmp(s1, "noscrub", 7) == 0) {
1045                         lmd->lmd_flags |= LMD_FLG_NOSCRUB;
1046                         clear++;
1047                 } else if (strncmp(s1, PARAM_MGSNODE,
1048                                    sizeof(PARAM_MGSNODE) - 1) == 0) {
1049                         s2 = s1 + sizeof(PARAM_MGSNODE) - 1;
1050                         /* Assume the next mount opt is the first
1051                            invalid nid we get to. */
1052                         rc = lmd_parse_mgs(lmd, &s2);
1053                         if (rc)
1054                                 goto invalid;
1055                         clear++;
1056                 } else if (strncmp(s1, "writeconf", 9) == 0) {
1057                         lmd->lmd_flags |= LMD_FLG_WRITECONF;
1058                         clear++;
1059                 } else if (strncmp(s1, "update", 6) == 0) {
1060                         lmd->lmd_flags |= LMD_FLG_UPDATE;
1061                         clear++;
1062                 } else if (strncmp(s1, "virgin", 6) == 0) {
1063                         lmd->lmd_flags |= LMD_FLG_VIRGIN;
1064                         clear++;
1065                 } else if (strncmp(s1, "noprimnode", 10) == 0) {
1066                         lmd->lmd_flags |= LMD_FLG_NO_PRIMNODE;
1067                         clear++;
1068                 } else if (strncmp(s1, "mgssec=", 7) == 0) {
1069                         rc = lmd_parse_mgssec(lmd, s1 + 7);
1070                         if (rc)
1071                                 goto invalid;
1072                         clear++;
1073                 /* ost exclusion list */
1074                 } else if (strncmp(s1, "exclude=", 8) == 0) {
1075                         rc = lmd_make_exclusion(lmd, s1 + 7);
1076                         if (rc)
1077                                 goto invalid;
1078                         clear++;
1079                 } else if (strncmp(s1, "mgs", 3) == 0) {
1080                         /* We are an MGS */
1081                         lmd->lmd_flags |= LMD_FLG_MGS;
1082                         clear++;
1083                 } else if (strncmp(s1, "svname=", 7) == 0) {
1084                         rc = lmd_parse_string(&lmd->lmd_profile, s1 + 7);
1085                         if (rc)
1086                                 goto invalid;
1087                         clear++;
1088                 } else if (strncmp(s1, "param=", 6) == 0) {
1089                         int length;
1090                         char *tail = strchr(s1 + 6, ',');
1091                         if (tail == NULL)
1092                                 length = strlen(s1);
1093                         else
1094                                 length = tail - s1;
1095                         length -= 6;
1096                         strncat(lmd->lmd_params, s1 + 6, length);
1097                         strcat(lmd->lmd_params, " ");
1098                         clear++;
1099                 } else if (strncmp(s1, "osd=", 4) == 0) {
1100                         rc = lmd_parse_string(&lmd->lmd_osd_type, s1 + 4);
1101                         if (rc)
1102                                 goto invalid;
1103                         clear++;
1104                 }
1105                 /* Linux 2.4 doesn't pass the device, so we stuck it at the
1106                    end of the options. */
1107                 else if (strncmp(s1, "device=", 7) == 0) {
1108                         devname = s1 + 7;
1109                         /* terminate options right before device.  device
1110                            must be the last one. */
1111                         *s1 = '\0';
1112                         break;
1113                 }
1114 
1115                 /* Find next opt */
1116                 s2 = strchr(s1, ',');
1117                 if (s2 == NULL) {
1118                         if (clear)
1119                                 *s1 = '\0';
1120                         break;
1121                 }
1122                 s2++;
1123                 if (clear)
1124                         memmove(s1, s2, strlen(s2) + 1);
1125                 else
1126                         s1 = s2;
1127         }
1128 
1129         if (!devname) {
1130                 LCONSOLE_ERROR_MSG(0x164, "Can't find the device name "
1131                                    "(need mount option 'device=...')\n");
1132                 goto invalid;
1133         }
1134 
1135         s1 = strstr(devname, ":/");
1136         if (s1) {
1137                 ++s1;
1138                 lmd->lmd_flags |= LMD_FLG_CLIENT;
1139                 /* Remove leading /s from fsname */
1140                 while (*++s1 == '/') ;
1141                 /* Freed in lustre_free_lsi */
1142                 OBD_ALLOC(lmd->lmd_profile, strlen(s1) + 8);
1143                 if (!lmd->lmd_profile)
1144                         return -ENOMEM;
1145                 sprintf(lmd->lmd_profile, "%s-client", s1);
1146         }
1147 
1148         /* Freed in lustre_free_lsi */
1149         OBD_ALLOC(lmd->lmd_dev, strlen(devname) + 1);
1150         if (!lmd->lmd_dev)
1151                 return -ENOMEM;
1152         strcpy(lmd->lmd_dev, devname);
1153 
1154         /* Save mount options */
1155         s1 = options + strlen(options) - 1;
1156         while (s1 >= options && (*s1 == ',' || *s1 == ' '))
1157                 *s1-- = 0;
1158         if (*options != 0) {
1159                 /* Freed in lustre_free_lsi */
1160                 OBD_ALLOC(lmd->lmd_opts, strlen(options) + 1);
1161                 if (!lmd->lmd_opts)
1162                         return -ENOMEM;
1163                 strcpy(lmd->lmd_opts, options);
1164         }
1165 
1166         lmd_print(lmd);
1167         lmd->lmd_magic = LMD_MAGIC;
1168 
1169         return rc;
1170 
1171 invalid:
1172         CERROR("Bad mount options %s\n", options);
1173         return -EINVAL;
1174 }
1175 
1176 struct lustre_mount_data2 {
1177         void *lmd2_data;
1178         struct vfsmount *lmd2_mnt;
1179 };
1180 
1181 /** This is the entry point for the mount call into Lustre.
1182  * This is called when a server or client is mounted,
1183  * and this is where we start setting things up.
1184  * @param data Mount options (e.g. -o flock,abort_recov)
1185  */
1186 int lustre_fill_super(struct super_block *sb, void *data, int silent)
1187 {
1188         struct lustre_mount_data *lmd;
1189         struct lustre_mount_data2 *lmd2 = data;
1190         struct lustre_sb_info *lsi;
1191         int rc;
1192 
1193         CDEBUG(D_MOUNT|D_VFSTRACE, "VFS Op: sb %p\n", sb);
1194 
1195         lsi = lustre_init_lsi(sb);
1196         if (!lsi)
1197                 return -ENOMEM;
1198         lmd = lsi->lsi_lmd;
1199 
1200         /*
1201          * Disable lockdep during mount, because mount locking patterns are
1202          * `special'.
1203          */
1204         lockdep_off();
1205 
1206         /*
1207          * LU-639: the obd cleanup of last mount may not finish yet, wait here.
1208          */
1209         obd_zombie_barrier();
1210 
1211         /* Figure out the lmd from the mount options */
1212         if (lmd_parse((char *)(lmd2->lmd2_data), lmd)) {
1213                 lustre_put_lsi(sb);
1214                 GOTO(out, rc = -EINVAL);
1215         }
1216 
1217         if (lmd_is_client(lmd)) {
1218                 CDEBUG(D_MOUNT, "Mounting client %s\n", lmd->lmd_profile);
1219                 if (client_fill_super == NULL)
1220                         request_module("lustre");
1221                 if (client_fill_super == NULL) {
1222                         LCONSOLE_ERROR_MSG(0x165, "Nothing registered for "
1223                                            "client mount! Is the 'lustre' "
1224                                            "module loaded?\n");
1225                         lustre_put_lsi(sb);
1226                         rc = -ENODEV;
1227                 } else {
1228                         rc = lustre_start_mgc(sb);
1229                         if (rc) {
1230                                 lustre_put_lsi(sb);
1231                                 GOTO(out, rc);
1232                         }
1233                         /* Connect and start */
1234                         /* (should always be ll_fill_super) */
1235                         rc = (*client_fill_super)(sb, lmd2->lmd2_mnt);
1236                         /* c_f_s will call lustre_common_put_super on failure */
1237                 }
1238         } else {
1239                 CERROR("This is client-side-only module, "
1240                        "cannot handle server mount.\n");
1241                 rc = -EINVAL;
1242         }
1243 
1244         /* If error happens in fill_super() call, @lsi will be killed there.
1245          * This is why we do not put it here. */
1246         GOTO(out, rc);
1247 out:
1248         if (rc) {
1249                 CERROR("Unable to mount %s (%d)\n",
1250                        s2lsi(sb) ? lmd->lmd_dev : "", rc);
1251         } else {
1252                 CDEBUG(D_SUPER, "Mount %s complete\n",
1253                        lmd->lmd_dev);
1254         }
1255         lockdep_on();
1256         return rc;
1257 }
1258 
1259 
1260 /* We can't call ll_fill_super by name because it lives in a module that
1261    must be loaded after this one. */
1262 void lustre_register_client_fill_super(int (*cfs)(struct super_block *sb,
1263                                                   struct vfsmount *mnt))
1264 {
1265         client_fill_super = cfs;
1266 }
1267 EXPORT_SYMBOL(lustre_register_client_fill_super);
1268 
1269 void lustre_register_kill_super_cb(void (*cfs)(struct super_block *sb))
1270 {
1271         kill_super_cb = cfs;
1272 }
1273 EXPORT_SYMBOL(lustre_register_kill_super_cb);
1274 
1275 /***************** FS registration ******************/
1276 struct dentry *lustre_mount(struct file_system_type *fs_type, int flags,
1277                                 const char *devname, void *data)
1278 {
1279         struct lustre_mount_data2 lmd2 = { data, NULL };
1280 
1281         return mount_nodev(fs_type, flags, &lmd2, lustre_fill_super);
1282 }
1283 
1284 void lustre_kill_super(struct super_block *sb)
1285 {
1286         struct lustre_sb_info *lsi = s2lsi(sb);
1287 
1288         if (kill_super_cb && lsi && !IS_SERVER(lsi))
1289                 (*kill_super_cb)(sb);
1290 
1291         kill_anon_super(sb);
1292 }
1293 
1294 /** Register the "lustre" fs type
1295  */
1296 struct file_system_type lustre_fs_type = {
1297         .owner  = THIS_MODULE,
1298         .name    = "lustre",
1299         .mount  = lustre_mount,
1300         .kill_sb      = lustre_kill_super,
1301         .fs_flags     = FS_BINARY_MOUNTDATA | FS_REQUIRES_DEV |
1302                         FS_HAS_FIEMAP | FS_RENAME_DOES_D_MOVE,
1303 };
1304 MODULE_ALIAS_FS("lustre");
1305 
1306 int lustre_register_fs(void)
1307 {
1308         return register_filesystem(&lustre_fs_type);
1309 }
1310 
1311 int lustre_unregister_fs(void)
1312 {
1313         return unregister_filesystem(&lustre_fs_type);
1314 }
1315 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us