Version:  2.0.40 2.2.26 2.4.37 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 3.18 3.19 4.0

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

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