Whamcloud - gitweb
b2acd97cd22476f9a7b59a409469f0eabcf6f1c9
[fs/lustre-release.git] / lustre / obdclass / obd_mount.c
1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
2  * vim:expandtab:shiftwidth=8:tabstop=8:
3  *
4  * GPL HEADER START
5  *
6  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License version 2 only,
10  * as published by the Free Software Foundation.
11  *
12  * This program is distributed in the hope that it will be useful, but
13  * WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * General Public License version 2 for more details (a copy is included
16  * in the LICENSE file that accompanied this code).
17  *
18  * You should have received a copy of the GNU General Public License
19  * version 2 along with this program; If not, see
20  * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
21  *
22  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
23  * CA 95054 USA or visit www.sun.com if you need additional information or
24  * have any questions.
25  *
26  * GPL HEADER END
27  */
28 /*
29  * Copyright  2008 Sun Microsystems, Inc. All rights reserved
30  * Use is subject to license terms.
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/server 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 #define PRINT_MASK D_SUPER|D_CONFIG
48
49 #include <obd.h>
50 #include <lvfs.h>
51 #include <lustre_fsfilt.h>
52 #include <obd_class.h>
53 #include <lustre/lustre_user.h>
54 #include <linux/version.h>
55 #include <lustre_log.h>
56 #include <lustre_disk.h>
57 #include <lustre_param.h>
58
59 static int (*client_fill_super)(struct super_block *sb) = NULL;
60 static void (*kill_super_cb)(struct super_block *sb) = NULL;
61
62 /*********** mount lookup *********/
63
64 CFS_DECLARE_MUTEX(lustre_mount_info_lock);
65 static CFS_LIST_HEAD(server_mount_info_list);
66
67 static struct lustre_mount_info *server_find_mount(const char *name)
68 {
69         cfs_list_t *tmp;
70         struct lustre_mount_info *lmi;
71         ENTRY;
72
73         cfs_list_for_each(tmp, &server_mount_info_list) {
74                 lmi = cfs_list_entry(tmp, struct lustre_mount_info,
75                                      lmi_list_chain);
76                 if (strcmp(name, lmi->lmi_name) == 0)
77                         RETURN(lmi);
78         }
79         RETURN(NULL);
80 }
81
82 /* we must register an obd for a mount before we call the setup routine.
83    *_setup will call lustre_get_mount to get the mnt struct
84    by obd_name, since we can't pass the pointer to setup. */
85 static int server_register_mount(const char *name, struct super_block *sb,
86                           struct vfsmount *mnt)
87 {
88         struct lustre_mount_info *lmi;
89         char *name_cp;
90         ENTRY;
91
92         LASSERT(mnt);
93         LASSERT(sb);
94
95         OBD_ALLOC(lmi, sizeof(*lmi));
96         if (!lmi)
97                 RETURN(-ENOMEM);
98         OBD_ALLOC(name_cp, strlen(name) + 1);
99         if (!name_cp) {
100                 OBD_FREE(lmi, sizeof(*lmi));
101                 RETURN(-ENOMEM);
102         }
103         strcpy(name_cp, name);
104
105         cfs_down(&lustre_mount_info_lock);
106
107         if (server_find_mount(name)) {
108                 cfs_up(&lustre_mount_info_lock);
109                 OBD_FREE(lmi, sizeof(*lmi));
110                 OBD_FREE(name_cp, strlen(name) + 1);
111                 CERROR("Already registered %s\n", name);
112                 RETURN(-EEXIST);
113         }
114         lmi->lmi_name = name_cp;
115         lmi->lmi_sb = sb;
116         lmi->lmi_mnt = mnt;
117         cfs_list_add(&lmi->lmi_list_chain, &server_mount_info_list);
118
119         cfs_up(&lustre_mount_info_lock);
120
121         CDEBUG(D_MOUNT, "reg_mnt %p from %s, vfscount=%d\n",
122                lmi->lmi_mnt, name, cfs_atomic_read(&lmi->lmi_mnt->mnt_count));
123
124         RETURN(0);
125 }
126
127 /* when an obd no longer needs a mount */
128 static int server_deregister_mount(const char *name)
129 {
130         struct lustre_mount_info *lmi;
131         ENTRY;
132
133         cfs_down(&lustre_mount_info_lock);
134         lmi = server_find_mount(name);
135         if (!lmi) {
136                 cfs_up(&lustre_mount_info_lock);
137                 CERROR("%s not registered\n", name);
138                 RETURN(-ENOENT);
139         }
140
141         CDEBUG(D_MOUNT, "dereg_mnt %p from %s, vfscount=%d\n",
142                lmi->lmi_mnt, name, cfs_atomic_read(&lmi->lmi_mnt->mnt_count));
143
144         OBD_FREE(lmi->lmi_name, strlen(lmi->lmi_name) + 1);
145         cfs_list_del(&lmi->lmi_list_chain);
146         OBD_FREE(lmi, sizeof(*lmi));
147         cfs_up(&lustre_mount_info_lock);
148
149         RETURN(0);
150 }
151
152 /* obd's look up a registered mount using their obdname. This is just
153    for initial obd setup to find the mount struct.  It should not be
154    called every time you want to mntget. */
155 struct lustre_mount_info *server_get_mount(const char *name)
156 {
157         struct lustre_mount_info *lmi;
158         struct lustre_sb_info *lsi;
159         ENTRY;
160
161         cfs_down(&lustre_mount_info_lock);
162         lmi = server_find_mount(name);
163         cfs_up(&lustre_mount_info_lock);
164         if (!lmi) {
165                 CERROR("Can't find mount for %s\n", name);
166                 RETURN(NULL);
167         }
168         lsi = s2lsi(lmi->lmi_sb);
169         mntget(lmi->lmi_mnt);
170         cfs_atomic_inc(&lsi->lsi_mounts);
171
172         CDEBUG(D_MOUNT, "get_mnt %p from %s, refs=%d, vfscount=%d\n",
173                lmi->lmi_mnt, name, cfs_atomic_read(&lsi->lsi_mounts),
174                cfs_atomic_read(&lmi->lmi_mnt->mnt_count));
175
176         RETURN(lmi);
177 }
178
179 /*
180  * Used by mdt to get mount_info from obdname.
181  * There are no blocking when using the mount_info.
182  * Do not use server_get_mount for this purpose.
183  */
184 struct lustre_mount_info *server_get_mount_2(const char *name)
185 {
186         struct lustre_mount_info *lmi;
187         ENTRY;
188
189         cfs_down(&lustre_mount_info_lock);
190         lmi = server_find_mount(name);
191         cfs_up(&lustre_mount_info_lock);
192         if (!lmi)
193                 CERROR("Can't find mount for %s\n", name);
194
195         RETURN(lmi);
196 }
197
198 static void unlock_mntput(struct vfsmount *mnt)
199 {
200         if (kernel_locked()) {
201                 cfs_unlock_kernel();
202                 mntput(mnt);
203                 cfs_lock_kernel();
204         } else {
205                 mntput(mnt);
206         }
207 }
208
209 static int lustre_put_lsi(struct super_block *sb);
210
211 /* to be called from obd_cleanup methods */
212 int server_put_mount(const char *name, struct vfsmount *mnt)
213 {
214         struct lustre_mount_info *lmi;
215         struct lustre_sb_info *lsi;
216         int count = atomic_read(&mnt->mnt_count) - 1;
217         ENTRY;
218
219         /* This might be the last one, can't deref after this */
220         unlock_mntput(mnt);
221
222         cfs_down(&lustre_mount_info_lock);
223         lmi = server_find_mount(name);
224         cfs_up(&lustre_mount_info_lock);
225         if (!lmi) {
226                 CERROR("Can't find mount for %s\n", name);
227                 RETURN(-ENOENT);
228         }
229         lsi = s2lsi(lmi->lmi_sb);
230         LASSERT(lmi->lmi_mnt == mnt);
231
232         CDEBUG(D_MOUNT, "put_mnt %p from %s, refs=%d, vfscount=%d\n",
233                lmi->lmi_mnt, name, cfs_atomic_read(&lsi->lsi_mounts), count);
234
235         if (lustre_put_lsi(lmi->lmi_sb)) {
236                 CDEBUG(D_MOUNT, "Last put of mnt %p from %s, vfscount=%d\n",
237                        lmi->lmi_mnt, name, count);
238                 /* last mount is the One True Mount */
239                 if (count > 1)
240                         CERROR("%s: mount busy, vfscount=%d!\n", name, count);
241         }
242
243         /* this obd should never need the mount again */
244         server_deregister_mount(name);
245
246         RETURN(0);
247 }
248
249 /* Corresponding to server_get_mount_2 */
250 int server_put_mount_2(const char *name, struct vfsmount *mnt)
251 {
252         ENTRY;
253         RETURN(0);
254 }
255
256 /******* mount helper utilities *********/
257
258 #if 0
259 static void ldd_print(struct lustre_disk_data *ldd)
260 {
261         PRINT_CMD(PRINT_MASK, "  disk data:\n");
262         PRINT_CMD(PRINT_MASK, "server:  %s\n", ldd->ldd_svname);
263         PRINT_CMD(PRINT_MASK, "uuid:    %s\n", (char *)ldd->ldd_uuid);
264         PRINT_CMD(PRINT_MASK, "fs:      %s\n", ldd->ldd_fsname);
265         PRINT_CMD(PRINT_MASK, "index:   %04x\n", ldd->ldd_svindex);
266         PRINT_CMD(PRINT_MASK, "config:  %d\n", ldd->ldd_config_ver);
267         PRINT_CMD(PRINT_MASK, "flags:   %#x\n", ldd->ldd_flags);
268         PRINT_CMD(PRINT_MASK, "diskfs:  %s\n", MT_STR(ldd));
269         PRINT_CMD(PRINT_MASK, "options: %s\n", ldd->ldd_mount_opts);
270         PRINT_CMD(PRINT_MASK, "params:  %s\n", ldd->ldd_params);
271         PRINT_CMD(PRINT_MASK, "comment: %s\n", ldd->ldd_userdata);
272 }
273 #endif
274
275 static int ldd_parse(struct lvfs_run_ctxt *mount_ctxt,
276                            struct lustre_disk_data *ldd)
277 {
278         struct lvfs_run_ctxt saved;
279         struct file *file;
280         loff_t off = 0;
281         unsigned long len;
282         int rc;
283         ENTRY;
284
285         push_ctxt(&saved, mount_ctxt, NULL);
286
287         file = filp_open(MOUNT_DATA_FILE, O_RDONLY, 0644);
288         if (IS_ERR(file)) {
289                 rc = PTR_ERR(file);
290                 CERROR("cannot open %s: rc = %d\n", MOUNT_DATA_FILE, rc);
291                 GOTO(out, rc);
292         }
293
294         len = i_size_read(file->f_dentry->d_inode);
295         CDEBUG(D_MOUNT, "Have %s, size %lu\n", MOUNT_DATA_FILE, len);
296         if (len != sizeof(*ldd)) {
297                 CERROR("disk data size does not match: see %lu expect %u\n",
298                        len, (int)sizeof(*ldd));
299                 GOTO(out_close, rc = -EINVAL);
300         }
301
302         rc = lustre_fread(file, ldd, len, &off);
303         if (rc != len) {
304                 CERROR("error reading %s: read %d of %lu\n",
305                        MOUNT_DATA_FILE, rc, len);
306                 GOTO(out_close, rc = -EINVAL);
307         }
308         rc = 0;
309
310         if (ldd->ldd_magic != LDD_MAGIC) {
311                 /* FIXME add swabbing support */
312                 CERROR("Bad magic in %s: %x!=%x\n", MOUNT_DATA_FILE,
313                        ldd->ldd_magic, LDD_MAGIC);
314                 GOTO(out_close, rc = -EINVAL);
315         }
316
317         if (ldd->ldd_feature_incompat & ~LDD_INCOMPAT_SUPP) {
318                 CERROR("%s: unsupported incompat filesystem feature(s) %x\n",
319                        ldd->ldd_svname,
320                        ldd->ldd_feature_incompat & ~LDD_INCOMPAT_SUPP);
321                 GOTO(out_close, rc = -EINVAL);
322         }
323         if (ldd->ldd_feature_rocompat & ~LDD_ROCOMPAT_SUPP) {
324                 CERROR("%s: unsupported read-only filesystem feature(s) %x\n",
325                        ldd->ldd_svname,
326                        ldd->ldd_feature_rocompat & ~LDD_ROCOMPAT_SUPP);
327                 /* Do something like remount filesystem read-only */
328                 GOTO(out_close, rc = -EINVAL);
329         }
330
331 out_close:
332         filp_close(file, 0);
333 out:
334         pop_ctxt(&saved, mount_ctxt, NULL);
335         RETURN(rc);
336 }
337
338 static int ldd_write(struct lvfs_run_ctxt *mount_ctxt,
339                      struct lustre_disk_data *ldd)
340 {
341         struct lvfs_run_ctxt saved;
342         struct file *file;
343         loff_t off = 0;
344         unsigned long len = sizeof(struct lustre_disk_data);
345         int rc = 0;
346         ENTRY;
347
348         LASSERT(ldd->ldd_magic == LDD_MAGIC);
349
350         ldd->ldd_config_ver++;
351
352         push_ctxt(&saved, mount_ctxt, NULL);
353
354         file = filp_open(MOUNT_DATA_FILE, O_RDWR, 0644);
355         if (IS_ERR(file)) {
356                 rc = PTR_ERR(file);
357                 CERROR("cannot open %s: rc = %d\n", MOUNT_DATA_FILE, rc);
358                 GOTO(out, rc);
359         }
360
361         rc = lustre_fwrite(file, ldd, len, &off);
362         if (rc != len) {
363                 CERROR("error writing %s: read %d of %lu\n",
364                        MOUNT_DATA_FILE, rc, len);
365                 GOTO(out_close, rc = -EINVAL);
366         }
367
368         rc = 0;
369
370 out_close:
371         filp_close(file, 0);
372 out:
373         pop_ctxt(&saved, mount_ctxt, NULL);
374         RETURN(rc);
375 }
376
377
378 /**************** config llog ********************/
379
380 /* Get a config log from the MGS and process it.
381    This func is called for both clients and servers.
382    Continue to process new statements appended to the logs
383    (whenever the config lock is revoked) until lustre_end_log
384    is called. */
385 int lustre_process_log(struct super_block *sb, char *logname,
386                      struct config_llog_instance *cfg)
387 {
388         struct lustre_cfg *lcfg;
389         struct lustre_cfg_bufs bufs;
390         struct lustre_sb_info *lsi = s2lsi(sb);
391         struct obd_device *mgc = lsi->lsi_mgc;
392         int rc;
393         ENTRY;
394
395         LASSERT(mgc);
396         LASSERT(cfg);
397
398         /* mgc_process_config */
399         lustre_cfg_bufs_reset(&bufs, mgc->obd_name);
400         lustre_cfg_bufs_set_string(&bufs, 1, logname);
401         lustre_cfg_bufs_set(&bufs, 2, cfg, sizeof(*cfg));
402         lustre_cfg_bufs_set(&bufs, 3, &sb, sizeof(sb));
403         lcfg = lustre_cfg_new(LCFG_LOG_START, &bufs);
404         rc = obd_process_config(mgc, sizeof(*lcfg), lcfg);
405         lustre_cfg_free(lcfg);
406
407         if (rc == -EINVAL)
408                 LCONSOLE_ERROR_MSG(0x15b, "%s: The configuration from log '%s'"
409                                    "failed from the MGS (%d).  Make sure this "
410                                    "client and the MGS are running compatible "
411                                    "versions of Lustre.\n",
412                                    mgc->obd_name, logname, rc);
413
414         if (rc)
415                 LCONSOLE_ERROR_MSG(0x15c, "%s: The configuration from log '%s' "
416                                    "failed (%d). This may be the result of "
417                                    "communication errors between this node and "
418                                    "the MGS, a bad configuration, or other "
419                                    "errors. See the syslog for more "
420                                    "information.\n", mgc->obd_name, logname,
421                                    rc);
422
423         /* class_obd_list(); */
424         RETURN(rc);
425 }
426
427 /* Stop watching this config log for updates */
428 int lustre_end_log(struct super_block *sb, char *logname,
429                        struct config_llog_instance *cfg)
430 {
431         struct lustre_cfg *lcfg;
432         struct lustre_cfg_bufs bufs;
433         struct lustre_sb_info *lsi = s2lsi(sb);
434         struct obd_device *mgc = lsi->lsi_mgc;
435         int rc;
436         ENTRY;
437
438         if (!mgc)
439                 RETURN(-ENOENT);
440
441         /* mgc_process_config */
442         lustre_cfg_bufs_reset(&bufs, mgc->obd_name);
443         lustre_cfg_bufs_set_string(&bufs, 1, logname);
444         if (cfg)
445                 lustre_cfg_bufs_set(&bufs, 2, cfg, sizeof(*cfg));
446         lcfg = lustre_cfg_new(LCFG_LOG_END, &bufs);
447         rc = obd_process_config(mgc, sizeof(*lcfg), lcfg);
448         lustre_cfg_free(lcfg);
449         RETURN(rc);
450 }
451
452 /**************** obd start *******************/
453
454 int do_lcfg(char *cfgname, lnet_nid_t nid, int cmd,
455             char *s1, char *s2, char *s3, char *s4)
456 {
457         struct lustre_cfg_bufs bufs;
458         struct lustre_cfg    * lcfg = NULL;
459         int rc;
460
461         CDEBUG(D_TRACE, "lcfg %s %#x %s %s %s %s\n", cfgname,
462                cmd, s1, s2, s3, s4);
463
464         lustre_cfg_bufs_reset(&bufs, cfgname);
465         if (s1)
466                 lustre_cfg_bufs_set_string(&bufs, 1, s1);
467         if (s2)
468                 lustre_cfg_bufs_set_string(&bufs, 2, s2);
469         if (s3)
470                 lustre_cfg_bufs_set_string(&bufs, 3, s3);
471         if (s4)
472                 lustre_cfg_bufs_set_string(&bufs, 4, s4);
473
474         lcfg = lustre_cfg_new(cmd, &bufs);
475         lcfg->lcfg_nid = nid;
476         rc = class_process_config(lcfg);
477         lustre_cfg_free(lcfg);
478         return(rc);
479 }
480
481 static int lustre_start_simple(char *obdname, char *type, char *uuid,
482                                char *s1, char *s2)
483 {
484         int rc;
485         CDEBUG(D_MOUNT, "Starting obd %s (typ=%s)\n", obdname, type);
486
487         rc = do_lcfg(obdname, 0, LCFG_ATTACH, type, uuid, 0, 0);
488         if (rc) {
489                 CERROR("%s attach error %d\n", obdname, rc);
490                 return(rc);
491         }
492         rc = do_lcfg(obdname, 0, LCFG_SETUP, s1, s2, 0, 0);
493         if (rc) {
494                 CERROR("%s setup error %d\n", obdname, rc);
495                 do_lcfg(obdname, 0, LCFG_DETACH, 0, 0, 0, 0);
496         }
497         return rc;
498 }
499
500 /* Set up a MGS to serve startup logs */
501 static int server_start_mgs(struct super_block *sb)
502 {
503         struct lustre_sb_info    *lsi = s2lsi(sb);
504         struct vfsmount          *mnt = lsi->lsi_srv_mnt;
505         struct lustre_mount_info *lmi;
506         int    rc = 0;
507         ENTRY;
508         LASSERT(mnt);
509
510         /* It is impossible to have more than 1 MGS per node, since
511            MGC wouldn't know which to connect to */
512         lmi = server_find_mount(LUSTRE_MGS_OBDNAME);
513         if (lmi) {
514                 lsi = s2lsi(lmi->lmi_sb);
515                 LCONSOLE_ERROR_MSG(0x15d, "The MGS service was already started"
516                                    " from server %s\n",
517                                    lsi->lsi_ldd->ldd_svname);
518                 RETURN(-EALREADY);
519         }
520
521         CDEBUG(D_CONFIG, "Start MGS service %s\n", LUSTRE_MGS_OBDNAME);
522
523         rc = server_register_mount(LUSTRE_MGS_OBDNAME, sb, mnt);
524
525         if (!rc) {
526                 rc = lustre_start_simple(LUSTRE_MGS_OBDNAME, LUSTRE_MGS_NAME,
527                                          LUSTRE_MGS_OBDNAME, 0, 0);
528                 /* Do NOT call server_deregister_mount() here. This leads to
529                  * inability cleanup cleanly and free lsi and other stuff when
530                  * mgs calls server_put_mount() in error handling case. -umka */
531         }
532
533         if (rc)
534                 LCONSOLE_ERROR_MSG(0x15e, "Failed to start MGS '%s' (%d). "
535                                    "Is the 'mgs' module loaded?\n",
536                                    LUSTRE_MGS_OBDNAME, rc);
537         RETURN(rc);
538 }
539
540 static int server_stop_mgs(struct super_block *sb)
541 {
542         struct obd_device *obd;
543         int rc;
544         ENTRY;
545
546         CDEBUG(D_MOUNT, "Stop MGS service %s\n", LUSTRE_MGS_OBDNAME);
547
548         /* There better be only one MGS */
549         obd = class_name2obd(LUSTRE_MGS_OBDNAME);
550         if (!obd) {
551                 CDEBUG(D_CONFIG, "mgs %s not running\n", LUSTRE_MGS_OBDNAME);
552                 RETURN(-EALREADY);
553         }
554
555         /* The MGS should always stop when we say so */
556         obd->obd_force = 1;
557         rc = class_manual_cleanup(obd);
558         RETURN(rc);
559 }
560
561 CFS_DECLARE_MUTEX(mgc_start_lock);
562
563 /** Set up a mgc obd to process startup logs
564  *
565  * \param sb [in] super block of the mgc obd
566  *
567  * \retval 0 success, otherwise error code
568  */
569 static int lustre_start_mgc(struct super_block *sb)
570 {
571         struct obd_connect_data *data = NULL;
572         struct lustre_sb_info *lsi = s2lsi(sb);
573         struct obd_device *obd;
574         struct obd_export *exp;
575         struct obd_uuid *uuid;
576         class_uuid_t uuidc;
577         lnet_nid_t nid;
578         char *mgcname, *niduuid, *mgssec;
579         char *ptr;
580         int recov_bk;
581         int rc = 0, i = 0, j, len;
582         ENTRY;
583
584         LASSERT(lsi->lsi_lmd);
585
586         /* Find the first non-lo MGS nid for our MGC name */
587         if (lsi->lsi_flags & LSI_SERVER) {
588                 ptr = lsi->lsi_ldd->ldd_params;
589                 /* Use mgsnode= nids */
590                 if ((class_find_param(ptr, PARAM_MGSNODE, &ptr) == 0) &&
591                     (class_parse_nid(ptr, &nid, &ptr) == 0)) {
592                         i++;
593                 } else if (IS_MGS(lsi->lsi_ldd)) {
594                         lnet_process_id_t id;
595                         while ((rc = LNetGetId(i++, &id)) != -ENOENT) {
596                                 if (LNET_NETTYP(LNET_NIDNET(id.nid)) == LOLND)
597                                         continue;
598                                 nid = id.nid;
599                                 i++;
600                                 break;
601                         }
602                 }
603         } else { /* client */
604                 /* Use nids from mount line: uml1,1@elan:uml2,2@elan:/lustre */
605                 ptr = lsi->lsi_lmd->lmd_dev;
606                 if (class_parse_nid(ptr, &nid, &ptr) == 0)
607                         i++;
608         }
609         if (i == 0) {
610                 CERROR("No valid MGS nids found.\n");
611                 RETURN(-EINVAL);
612         }
613
614         len = strlen(LUSTRE_MGC_OBDNAME) + strlen(libcfs_nid2str(nid)) + 1;
615         OBD_ALLOC(mgcname, len);
616         OBD_ALLOC(niduuid, len + 2);
617         if (!mgcname || !niduuid)
618                 GOTO(out_free, rc = -ENOMEM);
619         sprintf(mgcname, "%s%s", LUSTRE_MGC_OBDNAME, libcfs_nid2str(nid));
620
621         mgssec = lsi->lsi_lmd->lmd_mgssec ? lsi->lsi_lmd->lmd_mgssec : "";
622
623         cfs_mutex_down(&mgc_start_lock);
624
625         obd = class_name2obd(mgcname);
626         if (obd && !obd->obd_stopping) {
627                 rc = obd_set_info_async(obd->obd_self_export,
628                                         strlen(KEY_MGSSEC), KEY_MGSSEC,
629                                         strlen(mgssec), mgssec, NULL);
630                 if (rc)
631                         GOTO(out_free, rc);
632
633                 /* Re-using an existing MGC */
634                 cfs_atomic_inc(&obd->u.cli.cl_mgc_refcount);
635
636                 recov_bk = 0;
637                 /* If we are restarting the MGS, don't try to keep the MGC's
638                    old connection, or registration will fail. */
639                 if ((lsi->lsi_flags & LSI_SERVER) && IS_MGS(lsi->lsi_ldd)) {
640                         CDEBUG(D_MOUNT, "New MGS with live MGC\n");
641                         recov_bk = 1;
642                 }
643
644                 /* Try all connections, but only once (again).
645                    We don't want to block another target from starting
646                    (using its local copy of the log), but we do want to connect
647                    if at all possible. */
648                 recov_bk++;
649                 CDEBUG(D_MOUNT, "%s: Set MGC reconnect %d\n", mgcname,recov_bk);
650                 rc = obd_set_info_async(obd->obd_self_export,
651                                         sizeof(KEY_INIT_RECOV_BACKUP),
652                                         KEY_INIT_RECOV_BACKUP,
653                                         sizeof(recov_bk), &recov_bk, NULL);
654                 GOTO(out, rc = 0);
655         }
656
657         CDEBUG(D_MOUNT, "Start MGC '%s'\n", mgcname);
658
659         /* Add the primary nids for the MGS */
660         i = 0;
661         sprintf(niduuid, "%s_%x", mgcname, i);
662         if (lsi->lsi_flags & LSI_SERVER) {
663                 ptr = lsi->lsi_ldd->ldd_params;
664                 if (IS_MGS(lsi->lsi_ldd)) {
665                         /* Use local nids (including LO) */
666                         lnet_process_id_t id;
667                         while ((rc = LNetGetId(i++, &id)) != -ENOENT) {
668                                 rc = do_lcfg(mgcname, id.nid,
669                                              LCFG_ADD_UUID, niduuid, 0,0,0);
670                         }
671                 } else {
672                         /* Use mgsnode= nids */
673                         if (class_find_param(ptr, PARAM_MGSNODE, &ptr) != 0) {
674                                 CERROR("No MGS nids given.\n");
675                                 GOTO(out_free, rc = -EINVAL);
676                         }
677                         while (class_parse_nid(ptr, &nid, &ptr) == 0) {
678                                 rc = do_lcfg(mgcname, nid,
679                                              LCFG_ADD_UUID, niduuid, 0,0,0);
680                                 i++;
681                         }
682                 }
683         } else { /* client */
684                 /* Use nids from mount line: uml1,1@elan:uml2,2@elan:/lustre */
685                 ptr = lsi->lsi_lmd->lmd_dev;
686                 while (class_parse_nid(ptr, &nid, &ptr) == 0) {
687                         rc = do_lcfg(mgcname, nid,
688                                      LCFG_ADD_UUID, niduuid, 0,0,0);
689                         i++;
690                         /* Stop at the first failover nid */
691                         if (*ptr == ':')
692                                 break;
693                 }
694         }
695         if (i == 0) {
696                 CERROR("No valid MGS nids found.\n");
697                 GOTO(out_free, rc = -EINVAL);
698         }
699         lsi->lsi_lmd->lmd_mgs_failnodes = 1;
700
701         /* Random uuid for MGC allows easier reconnects */
702         OBD_ALLOC_PTR(uuid);
703         ll_generate_random_uuid(uuidc);
704         class_uuid_unparse(uuidc, uuid);
705
706         /* Start the MGC */
707         rc = lustre_start_simple(mgcname, LUSTRE_MGC_NAME,
708                                  (char *)uuid->uuid, LUSTRE_MGS_OBDNAME,
709                                  niduuid);
710         OBD_FREE_PTR(uuid);
711         if (rc)
712                 GOTO(out_free, rc);
713
714         /* Add any failover MGS nids */
715         i = 1;
716         while ((*ptr == ':' ||
717                 class_find_param(ptr, PARAM_MGSNODE, &ptr) == 0)) {
718                 /* New failover node */
719                 sprintf(niduuid, "%s_%x", mgcname, i);
720                 j = 0;
721                 while (class_parse_nid(ptr, &nid, &ptr) == 0) {
722                         j++;
723                         rc = do_lcfg(mgcname, nid,
724                                      LCFG_ADD_UUID, niduuid, 0,0,0);
725                         if (*ptr == ':')
726                                 break;
727                 }
728                 if (j > 0) {
729                         rc = do_lcfg(mgcname, 0, LCFG_ADD_CONN,
730                                      niduuid, 0, 0, 0);
731                         i++;
732                 } else {
733                         /* at ":/fsname" */
734                         break;
735                 }
736         }
737         lsi->lsi_lmd->lmd_mgs_failnodes = i;
738
739         obd = class_name2obd(mgcname);
740         if (!obd) {
741                 CERROR("Can't find mgcobd %s\n", mgcname);
742                 GOTO(out_free, rc = -ENOTCONN);
743         }
744
745         rc = obd_set_info_async(obd->obd_self_export,
746                                 strlen(KEY_MGSSEC), KEY_MGSSEC,
747                                 strlen(mgssec), mgssec, NULL);
748         if (rc)
749                 GOTO(out_free, rc);
750
751         /* Keep a refcount of servers/clients who started with "mount",
752            so we know when we can get rid of the mgc. */
753         cfs_atomic_set(&obd->u.cli.cl_mgc_refcount, 1);
754
755         /* Try all connections, but only once. */
756         recov_bk = 1;
757         rc = obd_set_info_async(obd->obd_self_export,
758                                 sizeof(KEY_INIT_RECOV_BACKUP),
759                                 KEY_INIT_RECOV_BACKUP,
760                                 sizeof(recov_bk), &recov_bk, NULL);
761         if (rc)
762                 /* nonfatal */
763                 CWARN("can't set %s %d\n", KEY_INIT_RECOV_BACKUP, rc);
764         /* We connect to the MGS at setup, and don't disconnect until cleanup */
765         OBD_ALLOC_PTR(data);
766         if (data == NULL)
767                 GOTO(out, rc = -ENOMEM);
768         data->ocd_connect_flags = OBD_CONNECT_VERSION | OBD_CONNECT_FID |
769                                   OBD_CONNECT_AT | OBD_CONNECT_FULL20;
770         data->ocd_version = LUSTRE_VERSION_CODE;
771         rc = obd_connect(NULL, &exp, obd, &(obd->obd_uuid), data, NULL);
772         OBD_FREE_PTR(data);
773         if (rc) {
774                 CERROR("connect failed %d\n", rc);
775                 GOTO(out, rc);
776         }
777
778         obd->u.cli.cl_mgc_mgsexp = exp;
779
780 out:
781         /* Keep the mgc info in the sb. Note that many lsi's can point
782            to the same mgc.*/
783         lsi->lsi_mgc = obd;
784 out_free:
785         cfs_mutex_up(&mgc_start_lock);
786
787         if (mgcname)
788                 OBD_FREE(mgcname, len);
789         if (niduuid)
790                 OBD_FREE(niduuid, len + 2);
791         RETURN(rc);
792 }
793
794 static int lustre_stop_mgc(struct super_block *sb)
795 {
796         struct lustre_sb_info *lsi = s2lsi(sb);
797         struct obd_device *obd;
798         char *niduuid = 0, *ptr = 0;
799         int i, rc = 0, len = 0;
800         ENTRY;
801
802         if (!lsi)
803                 RETURN(-ENOENT);
804         obd = lsi->lsi_mgc;
805         if (!obd)
806                 RETURN(-ENOENT);
807         lsi->lsi_mgc = NULL;
808
809         cfs_mutex_down(&mgc_start_lock);
810         LASSERT(cfs_atomic_read(&obd->u.cli.cl_mgc_refcount) > 0);
811         if (!cfs_atomic_dec_and_test(&obd->u.cli.cl_mgc_refcount)) {
812                 /* This is not fatal, every client that stops
813                    will call in here. */
814                 CDEBUG(D_MOUNT, "mgc still has %d references.\n",
815                        cfs_atomic_read(&obd->u.cli.cl_mgc_refcount));
816                 GOTO(out, rc = -EBUSY);
817         }
818
819         /* The MGC has no recoverable data in any case.
820          * force shotdown set in umount_begin */
821         obd->obd_no_recov = 1;
822
823         if (obd->u.cli.cl_mgc_mgsexp) {
824                 /* An error is not fatal, if we are unable to send the
825                    disconnect mgs ping evictor cleans up the export */
826                 rc = obd_disconnect(obd->u.cli.cl_mgc_mgsexp);
827                 if (rc)
828                         CDEBUG(D_MOUNT, "disconnect failed %d\n", rc);
829         }
830
831         /* Save the obdname for cleaning the nid uuids, which are
832            obdname_XX */
833         len = strlen(obd->obd_name) + 6;
834         OBD_ALLOC(niduuid, len);
835         if (niduuid) {
836                 strcpy(niduuid, obd->obd_name);
837                 ptr = niduuid + strlen(niduuid);
838         }
839
840         rc = class_manual_cleanup(obd);
841         if (rc)
842                 GOTO(out, rc);
843
844         /* Clean the nid uuids */
845         if (!niduuid)
846                 GOTO(out, rc = -ENOMEM);
847
848         for (i = 0; i < lsi->lsi_lmd->lmd_mgs_failnodes; i++) {
849                 sprintf(ptr, "_%x", i);
850                 rc = do_lcfg(LUSTRE_MGC_OBDNAME, 0, LCFG_DEL_UUID,
851                              niduuid, 0, 0, 0);
852                 if (rc)
853                         CERROR("del MDC UUID %s failed: rc = %d\n",
854                                niduuid, rc);
855         }
856 out:
857         if (niduuid)
858                 OBD_FREE(niduuid, len);
859
860         /* class_import_put will get rid of the additional connections */
861         cfs_mutex_up(&mgc_start_lock);
862         RETURN(rc);
863 }
864
865 /* Since there's only one mgc per node, we have to change it's fs to get
866    access to the right disk. */
867 static int server_mgc_set_fs(struct obd_device *mgc, struct super_block *sb)
868 {
869         struct lustre_sb_info *lsi = s2lsi(sb);
870         int rc;
871         ENTRY;
872
873         CDEBUG(D_MOUNT, "Set mgc disk for %s\n", lsi->lsi_lmd->lmd_dev);
874
875         /* cl_mgc_sem in mgc insures we sleep if the mgc_fs is busy */
876         rc = obd_set_info_async(mgc->obd_self_export,
877                                 sizeof(KEY_SET_FS), KEY_SET_FS,
878                                 sizeof(*sb), sb, NULL);
879         if (rc) {
880                 CERROR("can't set_fs %d\n", rc);
881         }
882
883         RETURN(rc);
884 }
885
886 static int server_mgc_clear_fs(struct obd_device *mgc)
887 {
888         int rc;
889         ENTRY;
890
891         CDEBUG(D_MOUNT, "Unassign mgc disk\n");
892
893         rc = obd_set_info_async(mgc->obd_self_export,
894                                 sizeof(KEY_CLEAR_FS), KEY_CLEAR_FS,
895                                 0, NULL, NULL);
896         RETURN(rc);
897 }
898
899 CFS_DECLARE_MUTEX(server_start_lock);
900
901 /* Stop MDS/OSS if nobody is using them */
902 static int server_stop_servers(int lddflags, int lsiflags)
903 {
904         struct obd_device *obd = NULL;
905         struct obd_type *type = NULL;
906         int rc = 0;
907         ENTRY;
908
909         cfs_mutex_down(&server_start_lock);
910
911         /* Either an MDT or an OST or neither  */
912         /* if this was an MDT, and there are no more MDT's, clean up the MDS */
913         if ((lddflags & LDD_F_SV_TYPE_MDT) &&
914             (obd = class_name2obd(LUSTRE_MDS_OBDNAME))) {
915                 /*FIXME pre-rename, should eventually be LUSTRE_MDT_NAME*/
916                 type = class_search_type(LUSTRE_MDS_NAME);
917         }
918         /* if this was an OST, and there are no more OST's, clean up the OSS */
919         if ((lddflags & LDD_F_SV_TYPE_OST) &&
920             (obd = class_name2obd(LUSTRE_OSS_OBDNAME))) {
921                 type = class_search_type(LUSTRE_OST_NAME);
922         }
923
924         if (obd && (!type || !type->typ_refcnt)) {
925                 int err;
926                 obd->obd_force = 1;
927                 /* obd_fail doesn't mean much on a server obd */
928                 err = class_manual_cleanup(obd);
929                 if (!rc)
930                         rc = err;
931         }
932
933         cfs_mutex_up(&server_start_lock);
934
935         RETURN(rc);
936 }
937
938 int server_mti_print(char *title, struct mgs_target_info *mti)
939 {
940         PRINT_CMD(PRINT_MASK, "mti %s\n", title);
941         PRINT_CMD(PRINT_MASK, "server: %s\n", mti->mti_svname);
942         PRINT_CMD(PRINT_MASK, "fs:     %s\n", mti->mti_fsname);
943         PRINT_CMD(PRINT_MASK, "uuid:   %s\n", mti->mti_uuid);
944         PRINT_CMD(PRINT_MASK, "ver: %d  flags: %#x\n",
945                   mti->mti_config_ver, mti->mti_flags);
946         return(0);
947 }
948
949 static int server_sb2mti(struct super_block *sb, struct mgs_target_info *mti)
950 {
951         struct lustre_sb_info    *lsi = s2lsi(sb);
952         struct lustre_disk_data  *ldd = lsi->lsi_ldd;
953         lnet_process_id_t         id;
954         int i = 0;
955         ENTRY;
956
957         if (!(lsi->lsi_flags & LSI_SERVER))
958                 RETURN(-EINVAL);
959
960         strncpy(mti->mti_fsname, ldd->ldd_fsname,
961                 sizeof(mti->mti_fsname));
962         strncpy(mti->mti_svname, ldd->ldd_svname,
963                 sizeof(mti->mti_svname));
964
965         mti->mti_nid_count = 0;
966         while (LNetGetId(i++, &id) != -ENOENT) {
967                 if (LNET_NETTYP(LNET_NIDNET(id.nid)) == LOLND)
968                         continue;
969                 mti->mti_nids[mti->mti_nid_count] = id.nid;
970                 mti->mti_nid_count++;
971                 if (mti->mti_nid_count >= MTI_NIDS_MAX) {
972                         CWARN("Only using first %d nids for %s\n",
973                               mti->mti_nid_count, mti->mti_svname);
974                         break;
975                 }
976         }
977
978         mti->mti_lustre_ver = LUSTRE_VERSION_CODE;
979         mti->mti_config_ver = 0;
980         mti->mti_flags = ldd->ldd_flags;
981         mti->mti_stripe_index = ldd->ldd_svindex;
982         memcpy(mti->mti_uuid, ldd->ldd_uuid, sizeof(mti->mti_uuid));
983         if (strlen(ldd->ldd_params) > sizeof(mti->mti_params)) {
984                 CERROR("params too big for mti\n");
985                 RETURN(-ENOMEM);
986         }
987         memcpy(mti->mti_params, ldd->ldd_params, sizeof(mti->mti_params));
988         RETURN(0);
989 }
990
991 /* Register an old or new target with the MGS. If needed MGS will construct
992    startup logs and assign index */
993 int server_register_target(struct super_block *sb)
994 {
995         struct lustre_sb_info *lsi = s2lsi(sb);
996         struct obd_device *mgc = lsi->lsi_mgc;
997         struct lustre_disk_data *ldd = lsi->lsi_ldd;
998         struct mgs_target_info *mti = NULL;
999         int rc;
1000         ENTRY;
1001
1002         LASSERT(mgc);
1003
1004         if (!(lsi->lsi_flags & LSI_SERVER))
1005                 RETURN(-EINVAL);
1006
1007         OBD_ALLOC_PTR(mti);
1008         if (!mti)
1009                 RETURN(-ENOMEM);
1010         rc = server_sb2mti(sb, mti);
1011         if (rc)
1012                 GOTO(out, rc);
1013
1014         CDEBUG(D_MOUNT, "Registration %s, fs=%s, %s, index=%04x, flags=%#x\n",
1015                mti->mti_svname, mti->mti_fsname,
1016                libcfs_nid2str(mti->mti_nids[0]), mti->mti_stripe_index,
1017                mti->mti_flags);
1018
1019         /* Register the target */
1020         /* FIXME use mgc_process_config instead */
1021         rc = obd_set_info_async(mgc->u.cli.cl_mgc_mgsexp,
1022                                 sizeof(KEY_REGISTER_TARGET), KEY_REGISTER_TARGET,
1023                                 sizeof(*mti), mti, NULL);
1024         if (rc)
1025                 GOTO(out, rc);
1026
1027         /* Always update our flags */
1028         ldd->ldd_flags = mti->mti_flags & ~LDD_F_REWRITE_LDD;
1029
1030         /* If this flag is set, it means the MGS wants us to change our
1031            on-disk data. (So far this means just the index.) */
1032         if (mti->mti_flags & LDD_F_REWRITE_LDD) {
1033                 char *label;
1034                 int err;
1035                 CDEBUG(D_MOUNT, "Changing on-disk index from %#x to %#x "
1036                        "for %s\n", ldd->ldd_svindex, mti->mti_stripe_index,
1037                        mti->mti_svname);
1038                 ldd->ldd_svindex = mti->mti_stripe_index;
1039                 strncpy(ldd->ldd_svname, mti->mti_svname,
1040                         sizeof(ldd->ldd_svname));
1041                 /* or ldd_make_sv_name(ldd); */
1042                 ldd_write(&mgc->obd_lvfs_ctxt, ldd);
1043                 err = fsfilt_set_label(mgc, lsi->lsi_srv_mnt->mnt_sb,
1044                                        mti->mti_svname);
1045                 if (err)
1046                         CERROR("Label set error %d\n", err);
1047                 label = fsfilt_get_label(mgc, lsi->lsi_srv_mnt->mnt_sb);
1048                 if (label)
1049                         CDEBUG(D_MOUNT, "Disk label changed to %s\n", label);
1050
1051                 /* Flush the new ldd to disk */
1052                 fsfilt_sync(mgc, lsi->lsi_srv_mnt->mnt_sb);
1053         }
1054
1055 out:
1056         if (mti)
1057                 OBD_FREE_PTR(mti);
1058         RETURN(rc);
1059 }
1060
1061 /* Start targets */
1062 static int server_start_targets(struct super_block *sb, struct vfsmount *mnt)
1063 {
1064         struct obd_device *obd;
1065         struct lustre_sb_info *lsi = s2lsi(sb);
1066         struct config_llog_instance cfg;
1067         int rc;
1068         ENTRY;
1069
1070         CDEBUG(D_MOUNT, "starting target %s\n", lsi->lsi_ldd->ldd_svname);
1071
1072 #if 0
1073         /* If we're an MDT, make sure the global MDS is running */
1074         if (lsi->lsi_ldd->ldd_flags & LDD_F_SV_TYPE_MDT) {
1075                 /* make sure the MDS is started */
1076                 cfs_mutex_down(&server_start_lock);
1077                 obd = class_name2obd(LUSTRE_MDS_OBDNAME);
1078                 if (!obd) {
1079                         rc = lustre_start_simple(LUSTRE_MDS_OBDNAME,
1080                     /* FIXME pre-rename, should eventually be LUSTRE_MDS_NAME */
1081                                                  LUSTRE_MDT_NAME,
1082                                                  LUSTRE_MDS_OBDNAME"_uuid",
1083                                                  0, 0);
1084                         if (rc) {
1085                                 cfs_mutex_up(&server_start_lock);
1086                                 CERROR("failed to start MDS: %d\n", rc);
1087                                 RETURN(rc);
1088                         }
1089                 }
1090                 cfs_mutex_up(&server_start_lock);
1091         }
1092 #endif
1093
1094         /* If we're an OST, make sure the global OSS is running */
1095         if (lsi->lsi_ldd->ldd_flags & LDD_F_SV_TYPE_OST) {
1096                 /* make sure OSS is started */
1097                 cfs_mutex_down(&server_start_lock);
1098                 obd = class_name2obd(LUSTRE_OSS_OBDNAME);
1099                 if (!obd) {
1100                         rc = lustre_start_simple(LUSTRE_OSS_OBDNAME,
1101                                                  LUSTRE_OSS_NAME,
1102                                                  LUSTRE_OSS_OBDNAME"_uuid",
1103                                                  0, 0);
1104                         if (rc) {
1105                                 cfs_mutex_up(&server_start_lock);
1106                                 CERROR("failed to start OSS: %d\n", rc);
1107                                 RETURN(rc);
1108                         }
1109                 }
1110                 cfs_mutex_up(&server_start_lock);
1111         }
1112
1113         /* Set the mgc fs to our server disk.  This allows the MGC
1114            to read and write configs locally. */
1115         rc = server_mgc_set_fs(lsi->lsi_mgc, sb);
1116         if (rc)
1117                 RETURN(rc);
1118
1119         /* Register with MGS */
1120         rc = server_register_target(sb);
1121         if (rc && (lsi->lsi_ldd->ldd_flags &
1122                    (LDD_F_NEED_INDEX | LDD_F_UPDATE | LDD_F_UPGRADE14))){
1123                 CERROR("Required registration failed for %s: %d\n",
1124                        lsi->lsi_ldd->ldd_svname, rc);
1125                 if (rc == -EIO) {
1126                         LCONSOLE_ERROR_MSG(0x15f, "Communication error with "
1127                                            "the MGS.  Is the MGS running?\n");
1128                 }
1129                 GOTO(out_mgc, rc);
1130         }
1131         if (rc == -EINVAL) {
1132                 LCONSOLE_ERROR_MSG(0x160, "The MGS is refusing to allow this "
1133                                    "server (%s) to start. Please see messages"
1134                                    " on the MGS node.\n",
1135                                    lsi->lsi_ldd->ldd_svname);
1136                 GOTO(out_mgc, rc);
1137         }
1138         /* non-fatal error of registeration with MGS */
1139         if (rc)
1140                 CDEBUG(D_MOUNT, "Cannot register with MGS: %d\n", rc);
1141
1142         /* Let the target look up the mount using the target's name
1143            (we can't pass the sb or mnt through class_process_config.) */
1144         rc = server_register_mount(lsi->lsi_ldd->ldd_svname, sb, mnt);
1145         if (rc)
1146                 GOTO(out_mgc, rc);
1147
1148         /* Start targets using the llog named for the target */
1149         memset(&cfg, 0, sizeof(cfg));
1150         rc = lustre_process_log(sb, lsi->lsi_ldd->ldd_svname, &cfg);
1151         if (rc) {
1152                 CERROR("failed to start server %s: %d\n",
1153                        lsi->lsi_ldd->ldd_svname, rc);
1154                 /* Do NOT call server_deregister_mount() here. This makes it
1155                  * impossible to find mount later in cleanup time and leaves
1156                  * @lsi and othder stuff leaked. -umka */
1157                 GOTO(out_mgc, rc);
1158         }
1159
1160 out_mgc:
1161         /* Release the mgc fs for others to use */
1162         server_mgc_clear_fs(lsi->lsi_mgc);
1163
1164         if (!rc) {
1165                 obd = class_name2obd(lsi->lsi_ldd->ldd_svname);
1166                 if (!obd) {
1167                         CERROR("no server named %s was started\n",
1168                                lsi->lsi_ldd->ldd_svname);
1169                         RETURN(-ENXIO);
1170                 }
1171
1172                 if ((lsi->lsi_lmd->lmd_flags & LMD_FLG_ABORT_RECOV) &&
1173                     (OBP(obd, iocontrol))) {
1174                         obd_iocontrol(OBD_IOC_ABORT_RECOVERY,
1175                                       obd->obd_self_export, 0, NULL, NULL);
1176                 }
1177
1178                 /* log has been fully processed */
1179                 obd_notify(obd, NULL, OBD_NOTIFY_CONFIG, (void *)CONFIG_LOG);
1180         }
1181
1182         RETURN(rc);
1183 }
1184
1185 /***************** lustre superblock **************/
1186
1187 struct lustre_sb_info *lustre_init_lsi(struct super_block *sb)
1188 {
1189         struct lustre_sb_info *lsi;
1190         ENTRY;
1191
1192         OBD_ALLOC_PTR(lsi);
1193         if (!lsi)
1194                 RETURN(NULL);
1195         OBD_ALLOC_PTR(lsi->lsi_lmd);
1196         if (!lsi->lsi_lmd) {
1197                 OBD_FREE_PTR(lsi);
1198                 RETURN(NULL);
1199         }
1200
1201         lsi->lsi_lmd->lmd_exclude_count = 0;
1202         lsi->lsi_lmd->lmd_recovery_time_soft = 0;
1203         lsi->lsi_lmd->lmd_recovery_time_hard = 0;
1204         s2lsi_nocast(sb) = lsi;
1205         /* we take 1 extra ref for our setup */
1206         cfs_atomic_set(&lsi->lsi_mounts, 1);
1207
1208         /* Default umount style */
1209         lsi->lsi_flags = LSI_UMOUNT_FAILOVER;
1210
1211         RETURN(lsi);
1212 }
1213
1214 static int lustre_free_lsi(struct super_block *sb)
1215 {
1216         struct lustre_sb_info *lsi = s2lsi(sb);
1217         ENTRY;
1218
1219         LASSERT(lsi != NULL);
1220         CDEBUG(D_MOUNT, "Freeing lsi %p\n", lsi);
1221
1222         /* someone didn't call server_put_mount. */
1223         LASSERT(cfs_atomic_read(&lsi->lsi_mounts) == 0);
1224
1225         if (lsi->lsi_ldd != NULL)
1226                 OBD_FREE(lsi->lsi_ldd, sizeof(*lsi->lsi_ldd));
1227
1228         if (lsi->lsi_lmd != NULL) {
1229                 if (lsi->lsi_lmd->lmd_dev != NULL)
1230                         OBD_FREE(lsi->lsi_lmd->lmd_dev,
1231                                  strlen(lsi->lsi_lmd->lmd_dev) + 1);
1232                 if (lsi->lsi_lmd->lmd_profile != NULL)
1233                         OBD_FREE(lsi->lsi_lmd->lmd_profile,
1234                                  strlen(lsi->lsi_lmd->lmd_profile) + 1);
1235                 if (lsi->lsi_lmd->lmd_mgssec != NULL)
1236                         OBD_FREE(lsi->lsi_lmd->lmd_mgssec,
1237                                  strlen(lsi->lsi_lmd->lmd_mgssec) + 1);
1238                 if (lsi->lsi_lmd->lmd_opts != NULL)
1239                         OBD_FREE(lsi->lsi_lmd->lmd_opts,
1240                                  strlen(lsi->lsi_lmd->lmd_opts) + 1);
1241                 if (lsi->lsi_lmd->lmd_exclude_count)
1242                         OBD_FREE(lsi->lsi_lmd->lmd_exclude,
1243                                  sizeof(lsi->lsi_lmd->lmd_exclude[0]) *
1244                                  lsi->lsi_lmd->lmd_exclude_count);
1245                 OBD_FREE(lsi->lsi_lmd, sizeof(*lsi->lsi_lmd));
1246         }
1247
1248         LASSERT(lsi->lsi_llsbi == NULL);
1249         OBD_FREE(lsi, sizeof(*lsi));
1250         s2lsi_nocast(sb) = NULL;
1251
1252         RETURN(0);
1253 }
1254
1255 /* The lsi has one reference for every server that is using the disk -
1256    e.g. MDT, MGS, and potentially MGC */
1257 static int lustre_put_lsi(struct super_block *sb)
1258 {
1259         struct lustre_sb_info *lsi = s2lsi(sb);
1260         ENTRY;
1261
1262         LASSERT(lsi != NULL);
1263
1264         CDEBUG(D_MOUNT, "put %p %d\n", sb, cfs_atomic_read(&lsi->lsi_mounts));
1265         if (cfs_atomic_dec_and_test(&lsi->lsi_mounts)) {
1266                 lustre_free_lsi(sb);
1267                 RETURN(1);
1268         }
1269         RETURN(0);
1270 }
1271
1272 /*************** server mount ******************/
1273
1274 /* Kernel mount using mount options in MOUNT_DATA_FILE */
1275 static struct vfsmount *server_kernel_mount(struct super_block *sb)
1276 {
1277         struct lvfs_run_ctxt mount_ctxt;
1278         struct lustre_sb_info *lsi = s2lsi(sb);
1279         struct lustre_disk_data *ldd;
1280         struct lustre_mount_data *lmd = lsi->lsi_lmd;
1281         struct vfsmount *mnt;
1282         char *options = NULL;
1283         unsigned long page, s_flags;
1284         struct page *__page;
1285         int rc;
1286         ENTRY;
1287
1288         OBD_ALLOC(ldd, sizeof(*ldd));
1289         if (!ldd)
1290                 RETURN(ERR_PTR(-ENOMEM));
1291
1292         /* In the past, we have always used flags = 0.
1293            Note ext3/ldiskfs can't be mounted ro. */
1294         s_flags = sb->s_flags;
1295
1296         /* allocate memory for options */
1297         OBD_PAGE_ALLOC(__page, CFS_ALLOC_STD);
1298         if (!__page)
1299                 GOTO(out_free, rc = -ENOMEM);
1300         page = (unsigned long)cfs_page_address(__page);
1301         options = (char *)page;
1302         memset(options, 0, CFS_PAGE_SIZE);
1303
1304         /* mount-line options must be added for pre-mount because it may
1305          * contain mount options such as journal_dev which are required
1306          * to mount successfuly the underlying filesystem */
1307         if (lmd->lmd_opts && (*(lmd->lmd_opts) != 0))
1308                 strncat(options, lmd->lmd_opts, CFS_PAGE_SIZE - 1);
1309
1310         /* Pre-mount ldiskfs to read the MOUNT_DATA_FILE */
1311         CDEBUG(D_MOUNT, "Pre-mount ldiskfs %s\n", lmd->lmd_dev);
1312         mnt = ll_kern_mount("ldiskfs", s_flags, lmd->lmd_dev, (void *)options);
1313         if (IS_ERR(mnt)) {
1314                 rc = PTR_ERR(mnt);
1315                 CERROR("premount %s:%#lx ldiskfs failed: %d "
1316                         "Is the ldiskfs module available?\n",
1317                         lmd->lmd_dev, s_flags, rc );
1318                 GOTO(out_free, rc);
1319         }
1320
1321         OBD_SET_CTXT_MAGIC(&mount_ctxt);
1322         mount_ctxt.pwdmnt = mnt;
1323         mount_ctxt.pwd = mnt->mnt_root;
1324         mount_ctxt.fs = get_ds();
1325
1326         rc = ldd_parse(&mount_ctxt, ldd);
1327         unlock_mntput(mnt);
1328
1329         if (rc) {
1330                 CERROR("premount parse options failed: rc = %d\n", rc);
1331                 GOTO(out_free, rc);
1332         }
1333
1334         /* Done with our pre-mount, now do the real mount. */
1335
1336         /* Glom up mount options */
1337         memset(options, 0, CFS_PAGE_SIZE);
1338         strncpy(options, ldd->ldd_mount_opts, CFS_PAGE_SIZE - 2);
1339
1340         /* Add in any mount-line options */
1341         if (lmd->lmd_opts && (*(lmd->lmd_opts) != 0)) {
1342                 int len = CFS_PAGE_SIZE - strlen(options) - 2;
1343                 if (*options != 0)
1344                         strcat(options, ",");
1345                 strncat(options, lmd->lmd_opts, len);
1346         }
1347
1348         /* Special permanent mount flags */
1349         if (IS_OST(ldd))
1350             s_flags |= MS_NOATIME | MS_NODIRATIME;
1351
1352         CDEBUG(D_MOUNT, "kern_mount: %s %s %s\n",
1353                MT_STR(ldd), lmd->lmd_dev, options);
1354         mnt = ll_kern_mount(MT_STR(ldd), s_flags, lmd->lmd_dev,
1355                             (void *)options);
1356         if (IS_ERR(mnt)) {
1357                 rc = PTR_ERR(mnt);
1358                 CERROR("ll_kern_mount failed: rc = %d\n", rc);
1359                 GOTO(out_free, rc);
1360         }
1361
1362         if (lmd->lmd_flags & LMD_FLG_ABORT_RECOV)
1363                 simple_truncate(mnt->mnt_sb->s_root, mnt, LAST_RCVD,
1364                                 LR_CLIENT_START);
1365
1366         OBD_PAGE_FREE(__page);
1367         lsi->lsi_ldd = ldd;   /* freed at lsi cleanup */
1368         CDEBUG(D_SUPER, "%s: mnt = %p\n", lmd->lmd_dev, mnt);
1369         RETURN(mnt);
1370
1371 out_free:
1372         if (__page)
1373                 OBD_PAGE_FREE(__page);
1374         OBD_FREE(ldd, sizeof(*ldd));
1375         lsi->lsi_ldd = NULL;
1376         RETURN(ERR_PTR(rc));
1377 }
1378
1379 /* Wait here forever until the mount refcount is 0 before completing umount,
1380  * else we risk dereferencing a null pointer.
1381  * LNET may take e.g. 165s before killing zombies.
1382  */
1383 static void server_wait_finished(struct vfsmount *mnt)
1384 {
1385        cfs_waitq_t             waitq;
1386        int                     rc, waited = 0;
1387        cfs_sigset_t            blocked;
1388
1389        cfs_waitq_init(&waitq);
1390
1391        while (atomic_read(&mnt->mnt_count) > 1) {
1392                if (waited && (waited % 30 == 0))
1393                        LCONSOLE_WARN("Mount still busy with %d refs after "
1394                                       "%d secs.\n",
1395                                       atomic_read(&mnt->mnt_count),
1396                                       waited);
1397                /* Cannot use l_event_wait() for an interruptible sleep. */
1398                waited += 3;
1399                blocked = l_w_e_set_sigs(sigmask(SIGKILL));
1400                cfs_waitq_wait_event_interruptible_timeout(
1401                        waitq,
1402                        (atomic_read(&mnt->mnt_count) == 1),
1403                        cfs_time_seconds(3),
1404                        rc);
1405                cfs_block_sigs(blocked);
1406                if (rc < 0) {
1407                        LCONSOLE_EMERG("Danger: interrupted umount %s with "
1408                                       "%d refs!\n",
1409                                       mnt->mnt_devname,
1410                                       atomic_read(&mnt->mnt_count));
1411                        break;
1412                }
1413
1414        }
1415 }
1416
1417 static void server_put_super(struct super_block *sb)
1418 {
1419         struct lustre_sb_info *lsi = s2lsi(sb);
1420         struct obd_device     *obd;
1421         struct vfsmount       *mnt = lsi->lsi_srv_mnt;
1422         char *tmpname, *extraname = NULL;
1423         int tmpname_sz;
1424         int lddflags = lsi->lsi_ldd->ldd_flags;
1425         int lsiflags = lsi->lsi_flags;
1426         ENTRY;
1427
1428         LASSERT(lsiflags & LSI_SERVER);
1429
1430         tmpname_sz = strlen(lsi->lsi_ldd->ldd_svname) + 1;
1431         OBD_ALLOC(tmpname, tmpname_sz);
1432         memcpy(tmpname, lsi->lsi_ldd->ldd_svname, tmpname_sz);
1433         CDEBUG(D_MOUNT, "server put_super %s\n", tmpname);
1434         if (IS_MDT(lsi->lsi_ldd) && (lsi->lsi_lmd->lmd_flags & LMD_FLG_NOSVC))
1435                 snprintf(tmpname, tmpname_sz, "MGS");
1436
1437         /* Stop the target */
1438         if (!(lsi->lsi_lmd->lmd_flags & LMD_FLG_NOSVC) &&
1439             (IS_MDT(lsi->lsi_ldd) || IS_OST(lsi->lsi_ldd))) {
1440                 struct lustre_profile *lprof = NULL;
1441
1442                 /* tell the mgc to drop the config log */
1443                 lustre_end_log(sb, lsi->lsi_ldd->ldd_svname, NULL);
1444
1445                 /* COMPAT_146 - profile may get deleted in mgc_cleanup.
1446                    If there are any setup/cleanup errors, save the lov
1447                    name for safety cleanup later. */
1448                 lprof = class_get_profile(lsi->lsi_ldd->ldd_svname);
1449                 if (lprof && lprof->lp_dt) {
1450                         OBD_ALLOC(extraname, strlen(lprof->lp_dt) + 1);
1451                         strcpy(extraname, lprof->lp_dt);
1452                 }
1453
1454                 obd = class_name2obd(lsi->lsi_ldd->ldd_svname);
1455                 if (obd) {
1456                         CDEBUG(D_MOUNT, "stopping %s\n", obd->obd_name);
1457                         if (lsi->lsi_flags & LSI_UMOUNT_FAILOVER)
1458                                 obd->obd_fail = 1;
1459                         /* We can't seem to give an error return code
1460                          * to .put_super, so we better make sure we clean up! */
1461                         obd->obd_force = 1;
1462                         class_manual_cleanup(obd);
1463                 } else {
1464                         CERROR("no obd %s\n", lsi->lsi_ldd->ldd_svname);
1465                         server_deregister_mount(lsi->lsi_ldd->ldd_svname);
1466                 }
1467         }
1468
1469         /* If they wanted the mgs to stop separately from the mdt, they
1470            should have put it on a different device. */
1471         if (IS_MGS(lsi->lsi_ldd)) {
1472                 /* if MDS start with --nomgs, don't stop MGS then */
1473                 if (!(lsi->lsi_lmd->lmd_flags & LMD_FLG_NOMGS))
1474                         server_stop_mgs(sb);
1475         }
1476
1477         /* Clean the mgc and sb */
1478         lustre_common_put_super(sb);
1479
1480         /* Wait for the targets to really clean up - can't exit (and let the
1481            sb get destroyed) while the mount is still in use */
1482         server_wait_finished(mnt);
1483
1484         /* drop the One True Mount */
1485         unlock_mntput(mnt);
1486
1487         /* Stop the servers (MDS, OSS) if no longer needed.  We must wait
1488            until the target is really gone so that our type refcount check
1489            is right. */
1490         server_stop_servers(lddflags, lsiflags);
1491
1492         /* In case of startup or cleanup err, stop related obds */
1493         if (extraname) {
1494                 obd = class_name2obd(extraname);
1495                 if (obd) {
1496                         CWARN("Cleaning orphaned obd %s\n", extraname);
1497                         obd->obd_force = 1;
1498                         class_manual_cleanup(obd);
1499                 }
1500                 OBD_FREE(extraname, strlen(extraname) + 1);
1501         }
1502
1503         LCONSOLE_WARN("server umount %s complete\n", tmpname);
1504         OBD_FREE(tmpname, tmpname_sz);
1505         EXIT;
1506 }
1507
1508 #ifdef HAVE_UMOUNTBEGIN_VFSMOUNT
1509 static void server_umount_begin(struct vfsmount *vfsmnt, int flags)
1510 {
1511         struct super_block *sb = vfsmnt->mnt_sb;
1512 #else
1513 static void server_umount_begin(struct super_block *sb)
1514 {
1515 #endif
1516         struct lustre_sb_info *lsi = s2lsi(sb);
1517         ENTRY;
1518
1519 #ifdef HAVE_UMOUNTBEGIN_VFSMOUNT
1520         if (!(flags & MNT_FORCE)) {
1521                 EXIT;
1522                 return;
1523         }
1524 #endif
1525
1526         CDEBUG(D_MOUNT, "umount -f\n");
1527         /* umount = failover
1528            umount -f = force
1529            no third way to do non-force, non-failover */
1530         lsi->lsi_flags &= ~LSI_UMOUNT_FAILOVER;
1531         lsi->lsi_flags |= LSI_UMOUNT_FORCE;
1532         EXIT;
1533 }
1534
1535 #ifndef HAVE_STATFS_DENTRY_PARAM
1536 static int server_statfs (struct super_block *sb, cfs_kstatfs_t *buf)
1537 {
1538 #else
1539 static int server_statfs (struct dentry *dentry, cfs_kstatfs_t *buf)
1540 {
1541         struct super_block *sb = dentry->d_sb;
1542 #endif
1543         struct vfsmount *mnt = s2lsi(sb)->lsi_srv_mnt;
1544         ENTRY;
1545
1546         if (mnt && mnt->mnt_sb && mnt->mnt_sb->s_op->statfs) {
1547 #ifdef HAVE_STATFS_DENTRY_PARAM
1548                 int rc = mnt->mnt_sb->s_op->statfs(mnt->mnt_root, buf);
1549 #else
1550                 int rc = mnt->mnt_sb->s_op->statfs(mnt->mnt_sb, buf);
1551 #endif
1552                 if (!rc) {
1553                         buf->f_type = sb->s_magic;
1554                         RETURN(0);
1555                 }
1556         }
1557
1558         /* just return 0 */
1559         buf->f_type = sb->s_magic;
1560         buf->f_bsize = sb->s_blocksize;
1561         buf->f_blocks = 1;
1562         buf->f_bfree = 0;
1563         buf->f_bavail = 0;
1564         buf->f_files = 1;
1565         buf->f_ffree = 0;
1566         buf->f_namelen = NAME_MAX;
1567         RETURN(0);
1568 }
1569
1570 static struct super_operations server_ops =
1571 {
1572         .put_super      = server_put_super,
1573         .umount_begin   = server_umount_begin, /* umount -f */
1574         .statfs         = server_statfs,
1575 };
1576
1577 #define log2(n) cfs_ffz(~(n))
1578 #define LUSTRE_SUPER_MAGIC 0x0BD00BD1
1579
1580 static int server_fill_super_common(struct super_block *sb)
1581 {
1582         struct inode *root = 0;
1583         ENTRY;
1584
1585         CDEBUG(D_MOUNT, "Server sb, dev=%d\n", (int)sb->s_dev);
1586
1587         sb->s_blocksize = 4096;
1588         sb->s_blocksize_bits = log2(sb->s_blocksize);
1589         sb->s_magic = LUSTRE_SUPER_MAGIC;
1590         sb->s_maxbytes = 0; //PAGE_CACHE_MAXBYTES;
1591         sb->s_flags |= MS_RDONLY;
1592         sb->s_op = &server_ops;
1593
1594         root = new_inode(sb);
1595         if (!root) {
1596                 CERROR("Can't make root inode\n");
1597                 RETURN(-EIO);
1598         }
1599
1600         /* returns -EIO for every operation */
1601         /* make_bad_inode(root); -- badness - can't umount */
1602         /* apparently we need to be a directory for the mount to finish */
1603         root->i_mode = S_IFDIR;
1604
1605         sb->s_root = d_alloc_root(root);
1606         if (!sb->s_root) {
1607                 CERROR("Can't make root dentry\n");
1608                 iput(root);
1609                 RETURN(-EIO);
1610         }
1611
1612         RETURN(0);
1613 }
1614
1615 static int server_fill_super(struct super_block *sb)
1616 {
1617         struct lustre_sb_info *lsi = s2lsi(sb);
1618         struct vfsmount *mnt;
1619         int rc;
1620         ENTRY;
1621
1622         /* the One True Mount */
1623         mnt = server_kernel_mount(sb);
1624         if (IS_ERR(mnt)) {
1625                 rc = PTR_ERR(mnt);
1626                 CERROR("Unable to mount device %s: %d\n",
1627                        lsi->lsi_lmd->lmd_dev, rc);
1628                 lustre_put_lsi(sb);
1629                 RETURN(rc);
1630         }
1631         lsi->lsi_srv_mnt = mnt;
1632
1633         LASSERT(lsi->lsi_ldd);
1634         CDEBUG(D_MOUNT, "Found service %s for fs '%s' on device %s\n",
1635                lsi->lsi_ldd->ldd_svname, lsi->lsi_ldd->ldd_fsname,
1636                lsi->lsi_lmd->lmd_dev);
1637
1638         if (class_name2obd(lsi->lsi_ldd->ldd_svname)) {
1639                 LCONSOLE_ERROR_MSG(0x161, "The target named %s is already "
1640                                    "running. Double-mount may have compromised"
1641                                    " the disk journal.\n",
1642                                    lsi->lsi_ldd->ldd_svname);
1643                 lustre_put_lsi(sb);
1644                 unlock_mntput(mnt);
1645                 RETURN(-EALREADY);
1646         }
1647
1648         /* Start MGS before MGC */
1649         if (IS_MGS(lsi->lsi_ldd) && !(lsi->lsi_lmd->lmd_flags & LMD_FLG_NOMGS)){
1650                 rc = server_start_mgs(sb);
1651                 if (rc)
1652                         GOTO(out_mnt, rc);
1653         }
1654
1655         rc = lustre_start_mgc(sb);
1656         if (rc)
1657                 GOTO(out_mnt, rc);
1658
1659         /* Set up all obd devices for service */
1660         if (!(lsi->lsi_lmd->lmd_flags & LMD_FLG_NOSVC) &&
1661                 (IS_OST(lsi->lsi_ldd) || IS_MDT(lsi->lsi_ldd))) {
1662                 rc = server_start_targets(sb, mnt);
1663                 if (rc < 0) {
1664                         CERROR("Unable to start targets: %d\n", rc);
1665                         GOTO(out_mnt, rc);
1666                 }
1667         /* FIXME overmount client here,
1668            or can we just start a client log and client_fill_super on this sb?
1669            We need to make sure server_put_super gets called too - ll_put_super
1670            calls lustre_common_put_super; check there for LSI_SERVER flag,
1671            call s_p_s if so.
1672            Probably should start client from new thread so we can return.
1673            Client will not finish until all servers are connected.
1674            Note - MGS-only server does NOT get a client, since there is no
1675            lustre fs associated - the MGS is for all lustre fs's */
1676         }
1677
1678         rc = server_fill_super_common(sb);
1679         if (rc)
1680                 GOTO(out_mnt, rc);
1681
1682         RETURN(0);
1683 out_mnt:
1684         /* We jump here in case of failure while starting targets or MGS.
1685          * In this case we can't just put @mnt and have to do real cleanup
1686          * with stoping targets, etc. */
1687         server_put_super(sb);
1688         return rc;
1689 }
1690
1691 /* Get the index from the obd name.
1692    rc = server type, or
1693    rc < 0  on error
1694    if endptr isn't NULL it is set to end of name */
1695 int server_name2index(char *svname, __u32 *idx, char **endptr)
1696 {
1697         unsigned long index;
1698         int rc;
1699         char *dash = strrchr(svname, '-');
1700         if (!dash)
1701                 return(-EINVAL);
1702
1703         /* intepret <fsname>-MDTXXXXX-mdc as mdt, the better way is to pass
1704          * in the fsname, then determine the server index */
1705         if (!strcmp(LUSTRE_MDC_NAME, dash + 1)) {
1706                 dash--;
1707                 for (; dash > svname && *dash != '-'; dash--);
1708                 if (dash == svname)
1709                         return(-EINVAL);
1710         }
1711
1712         if (strncmp(dash + 1, "MDT", 3) == 0)
1713                 rc = LDD_F_SV_TYPE_MDT;
1714         else if (strncmp(dash + 1, "OST", 3) == 0)
1715                 rc = LDD_F_SV_TYPE_OST;
1716         else
1717                 return(-EINVAL);
1718         if (strcmp(dash + 4, "all") == 0)
1719                 return rc | LDD_F_SV_ALL;
1720
1721         index = simple_strtoul(dash + 4, endptr, 16);
1722         *idx = index;
1723         return rc;
1724 }
1725
1726 /*************** mount common betweeen server and client ***************/
1727
1728 /* Common umount */
1729 int lustre_common_put_super(struct super_block *sb)
1730 {
1731         int rc;
1732         ENTRY;
1733
1734         CDEBUG(D_MOUNT, "dropping sb %p\n", sb);
1735
1736         /* Drop a ref to the MGC */
1737         rc = lustre_stop_mgc(sb);
1738         if (rc && (rc != -ENOENT)) {
1739                 if (rc != -EBUSY) {
1740                         CERROR("Can't stop MGC: %d\n", rc);
1741                         RETURN(rc);
1742                 }
1743                 /* BUSY just means that there's some other obd that
1744                    needs the mgc.  Let him clean it up. */
1745                 CDEBUG(D_MOUNT, "MGC still in use\n");
1746         }
1747         /* Drop a ref to the mounted disk */
1748         lustre_put_lsi(sb);
1749         lu_types_stop();
1750         RETURN(rc);
1751 }
1752
1753 static void lmd_print(struct lustre_mount_data *lmd)
1754 {
1755         int i;
1756
1757         PRINT_CMD(PRINT_MASK, "  mount data:\n");
1758         if (lmd_is_client(lmd))
1759                 PRINT_CMD(PRINT_MASK, "profile: %s\n", lmd->lmd_profile);
1760         PRINT_CMD(PRINT_MASK, "device:  %s\n", lmd->lmd_dev);
1761         PRINT_CMD(PRINT_MASK, "flags:   %x\n", lmd->lmd_flags);
1762
1763         if (lmd->lmd_opts)
1764                 PRINT_CMD(PRINT_MASK, "options: %s\n", lmd->lmd_opts);
1765
1766         if (lmd->lmd_recovery_time_soft)
1767                 PRINT_CMD(PRINT_MASK, "recovery time soft: %d\n",
1768                           lmd->lmd_recovery_time_soft);
1769
1770         if (lmd->lmd_recovery_time_hard)
1771                 PRINT_CMD(PRINT_MASK, "recovery time hard: %d\n",
1772                           lmd->lmd_recovery_time_hard);
1773
1774         for (i = 0; i < lmd->lmd_exclude_count; i++) {
1775                 PRINT_CMD(PRINT_MASK, "exclude %d:  OST%04x\n", i,
1776                           lmd->lmd_exclude[i]);
1777         }
1778 }
1779
1780 /* Is this server on the exclusion list */
1781 int lustre_check_exclusion(struct super_block *sb, char *svname)
1782 {
1783         struct lustre_sb_info *lsi = s2lsi(sb);
1784         struct lustre_mount_data *lmd = lsi->lsi_lmd;
1785         __u32 index;
1786         int i, rc;
1787         ENTRY;
1788
1789         rc = server_name2index(svname, &index, NULL);
1790         if (rc != LDD_F_SV_TYPE_OST)
1791                 /* Only exclude OSTs */
1792                 RETURN(0);
1793
1794         CDEBUG(D_MOUNT, "Check exclusion %s (%d) in %d of %s\n", svname,
1795                index, lmd->lmd_exclude_count, lmd->lmd_dev);
1796
1797         for(i = 0; i < lmd->lmd_exclude_count; i++) {
1798                 if (index == lmd->lmd_exclude[i]) {
1799                         CWARN("Excluding %s (on exclusion list)\n", svname);
1800                         RETURN(1);
1801                 }
1802         }
1803         RETURN(0);
1804 }
1805
1806 /* mount -v  -o exclude=lustre-OST0001:lustre-OST0002 -t lustre ... */
1807 static int lmd_make_exclusion(struct lustre_mount_data *lmd, char *ptr)
1808 {
1809         char *s1 = ptr, *s2;
1810         __u32 index, *exclude_list;
1811         int rc = 0, devmax;
1812         ENTRY;
1813
1814         /* The shortest an ost name can be is 8 chars: -OST0000.
1815            We don't actually know the fsname at this time, so in fact
1816            a user could specify any fsname. */
1817         devmax = strlen(ptr) / 8 + 1;
1818
1819         /* temp storage until we figure out how many we have */
1820         OBD_ALLOC(exclude_list, sizeof(index) * devmax);
1821         if (!exclude_list)
1822                 RETURN(-ENOMEM);
1823
1824         /* we enter this fn pointing at the '=' */
1825         while (*s1 && *s1 != ' ' && *s1 != ',') {
1826                 s1++;
1827                 rc = server_name2index(s1, &index, &s2);
1828                 if (rc < 0) {
1829                         CERROR("Can't parse server name '%s'\n", s1);
1830                         break;
1831                 }
1832                 if (rc == LDD_F_SV_TYPE_OST)
1833                         exclude_list[lmd->lmd_exclude_count++] = index;
1834                 else
1835                         CDEBUG(D_MOUNT, "ignoring exclude %.7s\n", s1);
1836                 s1 = s2;
1837                 /* now we are pointing at ':' (next exclude)
1838                    or ',' (end of excludes) */
1839                 if (lmd->lmd_exclude_count >= devmax)
1840                         break;
1841         }
1842         if (rc >= 0) /* non-err */
1843                 rc = 0;
1844
1845         if (lmd->lmd_exclude_count) {
1846                 /* permanent, freed in lustre_free_lsi */
1847                 OBD_ALLOC(lmd->lmd_exclude, sizeof(index) *
1848                           lmd->lmd_exclude_count);
1849                 if (lmd->lmd_exclude) {
1850                         memcpy(lmd->lmd_exclude, exclude_list,
1851                                sizeof(index) * lmd->lmd_exclude_count);
1852                 } else {
1853                         rc = -ENOMEM;
1854                         lmd->lmd_exclude_count = 0;
1855                 }
1856         }
1857         OBD_FREE(exclude_list, sizeof(index) * devmax);
1858         RETURN(rc);
1859 }
1860
1861 static int lmd_parse_mgssec(struct lustre_mount_data *lmd, char *ptr)
1862 {
1863         char   *tail;
1864         int     length;
1865
1866         if (lmd->lmd_mgssec != NULL) {
1867                 OBD_FREE(lmd->lmd_mgssec, strlen(lmd->lmd_mgssec) + 1);
1868                 lmd->lmd_mgssec = NULL;
1869         }
1870
1871         tail = strchr(ptr, ',');
1872         if (tail == NULL)
1873                 length = strlen(ptr);
1874         else
1875                 length = tail - ptr;
1876
1877         OBD_ALLOC(lmd->lmd_mgssec, length + 1);
1878         if (lmd->lmd_mgssec == NULL)
1879                 return -ENOMEM;
1880
1881         memcpy(lmd->lmd_mgssec, ptr, length);
1882         lmd->lmd_mgssec[length] = '\0';
1883         return 0;
1884 }
1885
1886 /* mount -v -t lustre uml1:uml2:/lustre-client /mnt/lustre */
1887 static int lmd_parse(char *options, struct lustre_mount_data *lmd)
1888 {
1889         char *s1, *s2, *devname = NULL;
1890         struct lustre_mount_data *raw = (struct lustre_mount_data *)options;
1891         int rc = 0;
1892         ENTRY;
1893
1894         LASSERT(lmd);
1895         if (!options) {
1896                 LCONSOLE_ERROR_MSG(0x162, "Missing mount data: check that "
1897                                    "/sbin/mount.lustre is installed.\n");
1898                 RETURN(-EINVAL);
1899         }
1900
1901         /* Options should be a string - try to detect old lmd data */
1902         if ((raw->lmd_magic & 0xffffff00) == (LMD_MAGIC & 0xffffff00)) {
1903                 LCONSOLE_ERROR_MSG(0x163, "You're using an old version of "
1904                                    "/sbin/mount.lustre.  Please install "
1905                                    "version %s\n", LUSTRE_VERSION_STRING);
1906                 RETURN(-EINVAL);
1907         }
1908         lmd->lmd_magic = LMD_MAGIC;
1909
1910         /* Set default flags here */
1911
1912         s1 = options;
1913         while (*s1) {
1914                 int clear = 0;
1915                 int time_min = 2 * (CONNECTION_SWITCH_MAX +
1916                                2 * INITIAL_CONNECT_TIMEOUT);
1917
1918                 /* Skip whitespace and extra commas */
1919                 while (*s1 == ' ' || *s1 == ',')
1920                         s1++;
1921
1922                 /* Client options are parsed in ll_options: eg. flock,
1923                    user_xattr, acl */
1924
1925                 /* Parse non-ldiskfs options here. Rather than modifying
1926                    ldiskfs, we just zero these out here */
1927                 if (strncmp(s1, "abort_recov", 11) == 0) {
1928                         lmd->lmd_flags |= LMD_FLG_ABORT_RECOV;
1929                         clear++;
1930                 } else if (strncmp(s1, "recovery_time_soft=", 19) == 0) {
1931                         lmd->lmd_recovery_time_soft = max_t(int,
1932                                 simple_strtoul(s1 + 19, NULL, 10), time_min);
1933                         clear++;
1934                 } else if (strncmp(s1, "recovery_time_hard=", 19) == 0) {
1935                         lmd->lmd_recovery_time_hard = max_t(int,
1936                                 simple_strtoul(s1 + 19, NULL, 10), time_min);
1937                         clear++;
1938                 } else if (strncmp(s1, "nosvc", 5) == 0) {
1939                         lmd->lmd_flags |= LMD_FLG_NOSVC;
1940                         clear++;
1941                 } else if (strncmp(s1, "nomgs", 5) == 0) {
1942                         lmd->lmd_flags |= LMD_FLG_NOMGS;
1943                         clear++;
1944                 } else if (strncmp(s1, "mgssec=", 7) == 0) {
1945                         rc = lmd_parse_mgssec(lmd, s1 + 7);
1946                         if (rc)
1947                                 goto invalid;
1948                         clear++;
1949                 /* ost exclusion list */
1950                 } else if (strncmp(s1, "exclude=", 8) == 0) {
1951                         rc = lmd_make_exclusion(lmd, s1 + 7);
1952                         if (rc)
1953                                 goto invalid;
1954                         clear++;
1955                 }
1956                 /* Linux 2.4 doesn't pass the device, so we stuck it at the
1957                    end of the options. */
1958                 else if (strncmp(s1, "device=", 7) == 0) {
1959                         devname = s1 + 7;
1960                         /* terminate options right before device.  device
1961                            must be the last one. */
1962                         *s1 = '\0';
1963                         break;
1964                 }
1965
1966                 /* Find next opt */
1967                 s2 = strchr(s1, ',');
1968                 if (s2 == NULL) {
1969                         if (clear)
1970                                 *s1 = '\0';
1971                         break;
1972                 }
1973                 s2++;
1974                 if (clear)
1975                         memmove(s1, s2, strlen(s2) + 1);
1976                 else
1977                         s1 = s2;
1978         }
1979
1980         if (!devname) {
1981                 LCONSOLE_ERROR_MSG(0x164, "Can't find the device name "
1982                                    "(need mount option 'device=...')\n");
1983                 goto invalid;
1984         }
1985
1986         s1 = strstr(devname, ":/");
1987         if (s1) {
1988                 ++s1;
1989                 lmd->lmd_flags = LMD_FLG_CLIENT;
1990                 /* Remove leading /s from fsname */
1991                 while (*++s1 == '/') ;
1992                 /* Freed in lustre_free_lsi */
1993                 OBD_ALLOC(lmd->lmd_profile, strlen(s1) + 8);
1994                 if (!lmd->lmd_profile)
1995                         RETURN(-ENOMEM);
1996                 sprintf(lmd->lmd_profile, "%s-client", s1);
1997         }
1998
1999         /* Freed in lustre_free_lsi */
2000         OBD_ALLOC(lmd->lmd_dev, strlen(devname) + 1);
2001         if (!lmd->lmd_dev)
2002                 RETURN(-ENOMEM);
2003         strcpy(lmd->lmd_dev, devname);
2004
2005         /* Save mount options */
2006         s1 = options + strlen(options) - 1;
2007         while (s1 >= options && (*s1 == ',' || *s1 == ' '))
2008                 *s1-- = 0;
2009         if (*options != 0) {
2010                 /* Freed in lustre_free_lsi */
2011                 OBD_ALLOC(lmd->lmd_opts, strlen(options) + 1);
2012                 if (!lmd->lmd_opts)
2013                         RETURN(-ENOMEM);
2014                 strcpy(lmd->lmd_opts, options);
2015         }
2016
2017         lmd_print(lmd);
2018         lmd->lmd_magic = LMD_MAGIC;
2019
2020         RETURN(rc);
2021
2022 invalid:
2023         CERROR("Bad mount options %s\n", options);
2024         RETURN(-EINVAL);
2025 }
2026
2027
2028 /* Common mount */
2029 int lustre_fill_super(struct super_block *sb, void *data, int silent)
2030 {
2031         struct lustre_mount_data *lmd;
2032         struct lustre_sb_info *lsi;
2033         int rc;
2034         ENTRY;
2035
2036         CDEBUG(D_MOUNT|D_VFSTRACE, "VFS Op: sb %p\n", sb);
2037
2038         lsi = lustre_init_lsi(sb);
2039         if (!lsi)
2040                 RETURN(-ENOMEM);
2041         lmd = lsi->lsi_lmd;
2042
2043         /*
2044          * Disable lockdep during mount, because mount locking patterns are
2045          * `special'.
2046          */
2047         cfs_lockdep_off();
2048
2049         /* Figure out the lmd from the mount options */
2050         if (lmd_parse((char *)data, lmd)) {
2051                 lustre_put_lsi(sb);
2052                 GOTO(out, rc = -EINVAL);
2053         }
2054
2055         if (lmd_is_client(lmd)) {
2056                 CDEBUG(D_MOUNT, "Mounting client %s\n", lmd->lmd_profile);
2057                 if (!client_fill_super) {
2058                         LCONSOLE_ERROR_MSG(0x165, "Nothing registered for "
2059                                            "client mount! Is the 'lustre' "
2060                                            "module loaded?\n");
2061                         lustre_put_lsi(sb);
2062                         rc = -ENODEV;
2063                 } else {
2064                         rc = lustre_start_mgc(sb);
2065                         if (rc) {
2066                                 lustre_put_lsi(sb);
2067                                 GOTO(out, rc);
2068                         }
2069                         /* Connect and start */
2070                         /* (should always be ll_fill_super) */
2071                         rc = (*client_fill_super)(sb);
2072                         /* c_f_s will call lustre_common_put_super on failure */
2073                 }
2074         } else {
2075                 CDEBUG(D_MOUNT, "Mounting server from %s\n", lmd->lmd_dev);
2076                 lsi->lsi_flags |= LSI_SERVER;
2077                 rc = server_fill_super(sb);
2078                 /* s_f_s calls lustre_start_mgc after the mount because we need
2079                    the MGS nids which are stored on disk.  Plus, we may
2080                    need to start the MGS first. */
2081                 /* s_f_s will call server_put_super on failure */
2082         }
2083
2084         /* If error happens in fill_super() call, @lsi will be killed there.
2085          * This is why we do not put it here. */
2086         GOTO(out, rc);
2087 out:
2088         if (rc) {
2089                 CERROR("Unable to mount %s (%d)\n",
2090                        s2lsi(sb) ? lmd->lmd_dev : "", rc);
2091         } else {
2092                 CDEBUG(D_SUPER, "Mount %s complete\n",
2093                        lmd->lmd_dev);
2094         }
2095         cfs_lockdep_on();
2096         return rc;
2097 }
2098
2099
2100 /* We can't call ll_fill_super by name because it lives in a module that
2101    must be loaded after this one. */
2102 void lustre_register_client_fill_super(int (*cfs)(struct super_block *sb))
2103 {
2104         client_fill_super = cfs;
2105 }
2106
2107 void lustre_register_kill_super_cb(void (*cfs)(struct super_block *sb))
2108 {
2109         kill_super_cb = cfs;
2110 }
2111
2112 /***************** FS registration ******************/
2113
2114 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,18))
2115 struct super_block * lustre_get_sb(struct file_system_type *fs_type,
2116                                int flags, const char *devname, void * data)
2117 {
2118         return get_sb_nodev(fs_type, flags, data, lustre_fill_super);
2119 }
2120 #else
2121 int lustre_get_sb(struct file_system_type *fs_type,
2122                                int flags, const char *devname, void * data,
2123                                struct vfsmount *mnt)
2124 {
2125         return get_sb_nodev(fs_type, flags, data, lustre_fill_super, mnt);
2126 }
2127 #endif
2128
2129 void lustre_kill_super(struct super_block *sb)
2130 {
2131         struct lustre_sb_info *lsi = s2lsi(sb);
2132
2133         if (kill_super_cb && lsi && !(lsi->lsi_flags & LSI_SERVER))
2134                 (*kill_super_cb)(sb);
2135
2136         kill_anon_super(sb);
2137 }
2138
2139 struct file_system_type lustre_fs_type = {
2140         .owner        = THIS_MODULE,
2141         .name         = "lustre",
2142         .get_sb       = lustre_get_sb,
2143         .kill_sb      = lustre_kill_super,
2144         .fs_flags     = FS_BINARY_MOUNTDATA | FS_REQUIRES_DEV |
2145 #ifdef FS_HAS_FIEMAP
2146                         FS_HAS_FIEMAP |
2147 #endif
2148                         LL_RENAME_DOES_D_MOVE,
2149 };
2150
2151 int lustre_register_fs(void)
2152 {
2153         return register_filesystem(&lustre_fs_type);
2154 }
2155
2156 int lustre_unregister_fs(void)
2157 {
2158         return unregister_filesystem(&lustre_fs_type);
2159 }
2160
2161 EXPORT_SYMBOL(lustre_register_client_fill_super);
2162 EXPORT_SYMBOL(lustre_register_kill_super_cb);
2163 EXPORT_SYMBOL(lustre_common_put_super);
2164 EXPORT_SYMBOL(lustre_process_log);
2165 EXPORT_SYMBOL(lustre_end_log);
2166 EXPORT_SYMBOL(server_get_mount);
2167 EXPORT_SYMBOL(server_get_mount_2);
2168 EXPORT_SYMBOL(server_put_mount);
2169 EXPORT_SYMBOL(server_put_mount_2);
2170 EXPORT_SYMBOL(server_register_target);
2171 EXPORT_SYMBOL(server_name2index);
2172 EXPORT_SYMBOL(server_mti_print);
2173 EXPORT_SYMBOL(do_lcfg);