Whamcloud - gitweb
LU-8551 test: Use mds1 rather than mds to operate on MDT0000
[fs/lustre-release.git] / lustre / utils / mount_utils.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) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
28  * Use is subject to license terms.
29  *
30  * Copyright (c) 2012, 2014, 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
37 #if HAVE_CONFIG_H
38 #  include "config.h"
39 #endif /* HAVE_CONFIG_H */
40
41 #include <inttypes.h>
42 #include <limits.h>
43 #include <mntent.h>
44 #include <stdio.h>
45 #include <errno.h>
46 #include <string.h>
47 #include <unistd.h>
48 #include <config.h>
49 #include <lustre_disk.h>
50 #include <lustre_ver.h>
51 #include <sys/mount.h>
52 #include <sys/stat.h>
53 #include <sys/utsname.h>
54 #include <linux/loop.h>
55 #include <sys/types.h>
56 #include <dirent.h>
57 #include <dlfcn.h>
58
59 #ifdef HAVE_GSS
60 #include <keyutils.h>
61 #include <lustre/utils/gss/sk_utils.h>
62 #endif
63
64 #include "mount_utils.h"
65
66 extern char *progname;
67 extern int verbose;
68
69 #define vprint(fmt, arg...) if (verbose > 0) printf(fmt, ##arg)
70 #define verrprint(fmt, arg...) if (verbose >= 0) fprintf(stderr, fmt, ##arg)
71
72 static struct module_backfs_ops *backfs_ops[LDD_MT_LAST];
73
74 void fatal(void)
75 {
76         verbose = 0;
77         fprintf(stderr, "\n%s FATAL: ", progname);
78 }
79
80 int run_command(char *cmd, int cmdsz)
81 {
82         char log[] = "/tmp/run_command_logXXXXXX";
83         int fd = -1, rc;
84
85         if ((cmdsz - strlen(cmd)) < 6) {
86                 fatal();
87                 fprintf(stderr, "Command buffer overflow: %.*s...\n",
88                         cmdsz, cmd);
89                 return ENOMEM;
90         }
91
92         if (verbose > 1) {
93                 printf("cmd: %s\n", cmd);
94         } else {
95                 if ((fd = mkstemp(log)) >= 0) {
96                         close(fd);
97                         strcat(cmd, " >");
98                         strcat(cmd, log);
99                 }
100         }
101         strcat(cmd, " 2>&1");
102
103         /* Can't use popen because we need the rv of the command */
104         rc = system(cmd);
105         if (rc && (fd >= 0)) {
106                 char buf[128];
107                 FILE *fp;
108                 fp = fopen(log, "r");
109                 if (fp) {
110                         while (fgets(buf, sizeof(buf), fp) != NULL) {
111                                 printf("   %s", buf);
112                         }
113                         fclose(fp);
114                 }
115         }
116         if (fd >= 0)
117                 remove(log);
118         return rc;
119 }
120
121 int add_param(char *buf, char *key, char *val)
122 {
123         int end = sizeof(((struct lustre_disk_data *)0)->ldd_params);
124         int start = strlen(buf);
125         int keylen = 0;
126
127         if (key)
128                 keylen = strlen(key);
129         if (start + 1 + keylen + strlen(val) >= end) {
130                 fprintf(stderr, "%s: params are too long-\n%s %s%s\n",
131                         progname, buf, key ? key : "", val);
132                 return 1;
133         }
134
135         sprintf(buf + start, " %s%s", key ? key : "", val);
136         return 0;
137 }
138
139 int get_param(char *buf, char *key, char **val)
140 {
141         int i, key_len = strlen(key);
142         char *ptr;
143
144         ptr = strstr(buf, key);
145         if (ptr) {
146                 *val = strdup(ptr + key_len);
147                 if (*val == NULL)
148                         return ENOMEM;
149
150                 for (i = 0; i < strlen(*val); i++)
151                         if (((*val)[i] == ' ') || ((*val)[i] == '\0'))
152                                 break;
153
154                 (*val)[i] = '\0';
155                 return 0;
156         }
157
158         return ENOENT;
159 }
160
161 int append_param(char *buf, char *key, char *val, char sep)
162 {
163         int key_len, i, offset, old_val_len;
164         char *ptr = NULL, str[1024];
165
166         if (key)
167                 ptr = strstr(buf, key);
168
169         /* key doesn't exist yet, so just add it */
170         if (ptr == NULL)
171                 return add_param(buf, key, val);
172
173         key_len = strlen(key);
174
175         /* Copy previous values to str */
176         for (i = 0; i < sizeof(str); ++i) {
177                 if ((ptr[i+key_len] == ' ') || (ptr[i+key_len] == '\0'))
178                         break;
179                 str[i] = ptr[i+key_len];
180         }
181         if (i == sizeof(str))
182                 return E2BIG;
183         old_val_len = i;
184
185         offset = old_val_len+key_len;
186
187         /* Move rest of buf to overwrite previous key and value */
188         for (i = 0; ptr[i+offset] != '\0'; ++i)
189                 ptr[i] = ptr[i+offset];
190
191         ptr[i] = '\0';
192
193         snprintf(str+old_val_len, sizeof(str)-old_val_len, "%c%s", sep, val);
194
195         return add_param(buf, key, str);
196 }
197
198 char *strscat(char *dst, char *src, int buflen)
199 {
200         dst[buflen - 1] = 0;
201         if (strlen(dst) + strlen(src) >= buflen) {
202                 fprintf(stderr, "string buffer overflow (max %d): '%s' + '%s'"
203                         "\n", buflen, dst, src);
204                 exit(EOVERFLOW);
205         }
206         return strcat(dst, src);
207 }
208
209 char *strscpy(char *dst, char *src, int buflen)
210 {
211         dst[0] = 0;
212         return strscat(dst, src, buflen);
213 }
214
215 int check_mtab_entry(char *spec1, char *spec2, char *mtpt, char *type)
216 {
217         FILE *fp;
218         struct mntent *mnt;
219
220         fp = setmntent(MOUNTED, "r");
221         if (fp == NULL)
222                 return 0;
223
224         while ((mnt = getmntent(fp)) != NULL) {
225                 if ((strcmp(mnt->mnt_fsname, spec1) == 0 ||
226                      strcmp(mnt->mnt_fsname, spec2) == 0) &&
227                     (mtpt == NULL || strcmp(mnt->mnt_dir, mtpt) == 0) &&
228                     (type == NULL || strcmp(mnt->mnt_type, type) == 0)) {
229                         endmntent(fp);
230                         return(EEXIST);
231                 }
232         }
233         endmntent(fp);
234
235         return 0;
236 }
237
238 #include <sys/vfs.h>
239 #include <linux/magic.h>
240
241 static int mtab_is_proc(const char *mtab)
242 {
243         struct statfs s;
244         if (statfs(mtab, &s) < 0)
245                 return 0;
246
247         return (s.f_type == PROC_SUPER_MAGIC);
248 }
249
250 #ifdef HAVE_LIBMOUNT
251
252 # include <libmount/libmount.h>
253
254 /*
255  * The libmount is part of util-linux since 2.18.
256  * We use it to update utab to avoid umount would
257  * blocked in some rare case.
258  */
259 int update_utab_entry(struct mount_opts *mop)
260 {
261         struct libmnt_fs *fs = mnt_new_fs();
262         struct libmnt_update *upd;
263         int rc;
264
265         mnt_fs_set_source(fs, mop->mo_source);
266         mnt_fs_set_target(fs, mop->mo_target);
267         mnt_fs_set_fstype(fs, "lustre");
268         mnt_fs_set_attributes(fs, "lustre");
269
270         upd = mnt_new_update();
271         if (!upd)
272                 return -ENOMEM;
273
274         rc = mnt_update_set_fs(upd, mop->mo_nomtab ? MS_REMOUNT : 0, NULL, fs);
275         if (rc == 1) /* update is unnecessary */
276                 rc = 0;
277         if (rc) {
278                 fprintf(stderr,
279                         "error: failed to save utab entry: rc = %d\n", rc);
280         } else {
281                 rc = mnt_update_table(upd, NULL);
282         }
283
284         mnt_free_update(upd);
285         mnt_free_fs(fs);
286
287         return rc;
288 }
289 #else
290 int update_utab_entry(struct mount_opts *mop)
291 {
292         return 0;
293 }
294 #endif /* HAVE_LIBMOUNT */
295
296 int update_mtab_entry(char *spec, char *mtpt, char *type, char *opts,
297                 int flags, int freq, int pass)
298 {
299         FILE *fp;
300         struct mntent mnt;
301         int rc = 0;
302
303         /* Don't update mtab if it is linked to any file in /proc direcotry.*/
304         if (mtab_is_proc(MOUNTED))
305                 return 0;
306
307         mnt.mnt_fsname = spec;
308         mnt.mnt_dir = mtpt;
309         mnt.mnt_type = type;
310         mnt.mnt_opts = opts ? opts : "";
311         mnt.mnt_freq = freq;
312         mnt.mnt_passno = pass;
313
314         fp = setmntent(MOUNTED, "a+");
315         if (fp == NULL) {
316                 fprintf(stderr, "%s: setmntent(%s): %s\n",
317                         progname, MOUNTED, strerror (errno));
318                 rc = 16;
319         } else {
320                 if ((addmntent(fp, &mnt)) == 1) {
321                         fprintf(stderr, "%s: addmntent: %s\n",
322                                 progname, strerror (errno));
323                         rc = 16;
324                 }
325                 endmntent(fp);
326         }
327
328         return rc;
329 }
330
331 /* Search for opt in mntlist, returning true if found.
332  */
333 static int in_mntlist(char *opt, char *mntlist)
334 {
335         char *ml, *mlp, *item, *ctx = NULL;
336
337         if (!(ml = strdup(mntlist))) {
338                 fprintf(stderr, "%s: out of memory\n", progname);
339                 exit(1);
340         }
341         mlp = ml;
342         while ((item = strtok_r(mlp, ",", &ctx))) {
343                 if (!strcmp(opt, item))
344                         break;
345                 mlp = NULL;
346         }
347         free(ml);
348         return (item != NULL);
349 }
350
351 /* Issue a message on stderr for every item in wanted_mountopts that is not
352  * present in mountopts.  The justwarn boolean toggles between error and
353  * warning message.  Return an error count.
354  */
355 int check_mountfsoptions(char *mountopts, char *wanted_mountopts)
356 {
357         char *ml, *mlp, *item, *ctx = NULL;
358         int errors = 0;
359
360         if (!(ml = strdup(wanted_mountopts))) {
361                 fprintf(stderr, "%s: out of memory\n", progname);
362                 exit(1);
363         }
364         mlp = ml;
365         while ((item = strtok_r(mlp, ",", &ctx))) {
366                 if (!in_mntlist(item, mountopts)) {
367                         fprintf(stderr, "%s: Error: mandatory mount option"
368                                 " '%s' is missing\n", progname, item);
369                         errors++;
370                 }
371                 mlp = NULL;
372         }
373         free(ml);
374         return errors;
375 }
376
377 /* Trim embedded white space, leading and trailing commas from string s.
378  */
379 void trim_mountfsoptions(char *s)
380 {
381         char *p;
382
383         for (p = s; *p; ) {
384                 if (isspace(*p)) {
385                         memmove(p, p + 1, strlen(p + 1) + 1);
386                         continue;
387                 }
388                 p++;
389         }
390
391         while (s[0] == ',')
392                 memmove(&s[0], &s[1], strlen(&s[1]) + 1);
393
394         p = s + strlen(s) - 1;
395         while (p >= s && *p == ',')
396                 *p-- = '\0';
397 }
398
399 /* Setup a file in the first unused loop_device */
400 int loop_setup(struct mkfs_opts *mop)
401 {
402         char loop_base[20];
403         char l_device[64];
404         int i, ret = 0;
405
406         /* Figure out the loop device names */
407         if (!access("/dev/loop0", F_OK | R_OK) ||
408             !access("/dev/loop-control", F_OK | R_OK)) {
409                 strcpy(loop_base, "/dev/loop\0");
410         } else if (!access("/dev/loop/0", F_OK | R_OK)) {
411                 strcpy(loop_base, "/dev/loop/\0");
412         } else {
413                 fprintf(stderr, "%s: can't access loop devices\n", progname);
414                 return EACCES;
415         }
416
417         /* Find unused loop device */
418         for (i = 0; i < MAX_LOOP_DEVICES; i++) {
419                 char cmd[PATH_MAX];
420                 int cmdsz = sizeof(cmd);
421
422 #ifdef HAVE_LOOP_CTL_GET_FREE
423                 ret = open("/dev/loop-control", O_RDWR);
424                 if (ret < 0) {
425                         fprintf(stderr, "%s: can't access loop control\n", progname);
426                         return EACCES;
427                 }
428                 /* find or allocate a free loop device to use */
429                 i = ioctl(ret, LOOP_CTL_GET_FREE);
430                 close(ret);
431                 if (i < 0) {
432                         fprintf(stderr, "%s: access loop control error\n", progname);
433                         return EACCES;
434                 }
435                 sprintf(l_device, "%s%d", loop_base, i);
436 #else
437                 sprintf(l_device, "%s%d", loop_base, i);
438                 if (access(l_device, F_OK | R_OK))
439                         break;
440 #endif
441                 snprintf(cmd, cmdsz, "losetup %s > /dev/null 2>&1", l_device);
442                 ret = system(cmd);
443
444                 /* losetup gets 1 (ret=256) for non-set-up device */
445                 if (ret) {
446                         /* Set up a loopback device to our file */
447                         snprintf(cmd, cmdsz, "losetup %s %s", l_device,
448                                  mop->mo_device);
449                         ret = run_command(cmd, cmdsz);
450                         if (ret == 256)
451                                 /* someone else picked up this loop device
452                                  * behind our back */
453                                 continue;
454                         if (ret) {
455                                 fprintf(stderr, "%s: error %d on losetup: %s\n",
456                                         progname, ret,
457                                         ret >= 0 ? strerror(ret) : "");
458                                 return ret;
459                         }
460                         strscpy(mop->mo_loopdev, l_device,
461                                 sizeof(mop->mo_loopdev));
462                         return ret;
463                 }
464         }
465
466         fprintf(stderr, "%s: out of loop devices!\n", progname);
467         return EMFILE;
468 }
469
470 int loop_cleanup(struct mkfs_opts *mop)
471 {
472         char cmd[150];
473         int ret = 0;
474
475         if ((mop->mo_flags & MO_IS_LOOP) && *mop->mo_loopdev) {
476                 int tries;
477
478                 sprintf(cmd, "losetup -d %s", mop->mo_loopdev);
479                 for (tries = 0; tries < 3; tries++) {
480                         ret = run_command(cmd, sizeof(cmd));
481                         if (ret == 0)
482                                 break;
483                         sleep(1);
484                 }
485         }
486
487         if (ret != 0)
488                 fprintf(stderr, "cannot cleanup %s: rc = %d\n",
489                         mop->mo_loopdev, ret);
490         return ret;
491 }
492
493 int loop_format(struct mkfs_opts *mop)
494 {
495         int fd;
496
497         if (mop->mo_device_kb == 0) {
498                 fatal();
499                 fprintf(stderr, "loop device requires a --device-size= "
500                         "param\n");
501                 return EINVAL;
502         }
503
504         fd = creat(mop->mo_device, S_IRUSR|S_IWUSR);
505         if (fd < 0) {
506                 fatal();
507                 fprintf(stderr, "%s: Unable to create backing store: %s\n",
508                         progname, strerror(errno));
509                 return errno;
510         }
511
512         if (ftruncate(fd, mop->mo_device_kb * 1024) != 0) {
513                 close(fd);
514                 fatal();
515                 fprintf(stderr, "%s: Unable to truncate backing store: %s\n",
516                         progname, strerror(errno));
517                 return errno;
518         }
519
520         close(fd);
521         return 0;
522 }
523
524 #define DLSYM(prefix, sym, func)                                        \
525         do {                                                            \
526                 char _fname[64];                                        \
527                 snprintf(_fname, sizeof(_fname), "%s_%s", prefix, #func); \
528                 sym->func = (typeof(sym->func))dlsym(sym->dl_handle, _fname); \
529         } while (0)
530
531 /**
532  * Load plugin for a given mount_type from ${pkglibdir}/mount_osd_FSTYPE.so and
533  * return struct of function pointers (will be freed in unloack_backfs_module).
534  *
535  * \param[in] mount_type        Mount type to load module for.
536  * \retval Value of backfs_ops struct
537  * \retval NULL if no module exists
538  */
539 struct module_backfs_ops *load_backfs_module(enum ldd_mount_type mount_type)
540 {
541         void *handle;
542         char *error, filename[512], fsname[512], *name;
543         struct module_backfs_ops *ops;
544
545         /* This deals with duplicate ldd_mount_types resolving to same OSD layer
546          * plugin (e.g. ext3/ldiskfs/ldiskfs2 all being ldiskfs) */
547         strncpy(fsname, mt_type(mount_type), sizeof(fsname));
548         name = fsname + sizeof("osd-") - 1;
549
550         /* change osd- to osd_ */
551         fsname[sizeof("osd-") - 2] = '_';
552
553         snprintf(filename, sizeof(filename), PLUGIN_DIR"/mount_%s.so", fsname);
554
555         handle = dlopen(filename, RTLD_LAZY);
556
557         /* Check for $LUSTRE environment variable from test-framework.
558          * This allows using locally built modules to be used.
559          */
560         if (handle == NULL) {
561                 char *dirname;
562                 dirname = getenv("LUSTRE");
563                 if (dirname) {
564                         snprintf(filename, sizeof(filename),
565                                  "%s/utils/.libs/mount_%s.so",
566                                  dirname, fsname);
567                         handle = dlopen(filename, RTLD_LAZY);
568                 }
569         }
570
571         /* Do not clutter up console with missing types */
572         if (handle == NULL)
573                 return NULL;
574
575         ops = malloc(sizeof(*ops));
576         if (ops == NULL) {
577                 dlclose(handle);
578                 return NULL;
579         }
580
581         ops->dl_handle = handle;
582         dlerror(); /* Clear any existing error */
583
584         DLSYM(name, ops, init);
585         DLSYM(name, ops, fini);
586         DLSYM(name, ops, read_ldd);
587         DLSYM(name, ops, write_ldd);
588         DLSYM(name, ops, is_lustre);
589         DLSYM(name, ops, make_lustre);
590         DLSYM(name, ops, prepare_lustre);
591         DLSYM(name, ops, tune_lustre);
592         DLSYM(name, ops, label_lustre);
593         DLSYM(name, ops, enable_quota);
594
595         error = dlerror();
596         if (error != NULL) {
597                 fatal();
598                 fprintf(stderr, "%s\n", error);
599                 dlclose(handle);
600                 free(ops);
601                 return NULL;
602         }
603
604         /* optional methods */
605         DLSYM(name, ops, fix_mountopts);
606
607         return ops;
608 }
609
610 /**
611  * Unload plugin and free backfs_ops structure. Must be called the same number
612  * of times as load_backfs_module is.
613  */
614 void unload_backfs_module(struct module_backfs_ops *ops)
615 {
616         if (ops == NULL)
617                 return;
618
619         dlclose(ops->dl_handle);
620         free(ops);
621 }
622
623 /* Return true if backfs_ops has operations for the given mount_type. */
624 int backfs_mount_type_okay(enum ldd_mount_type mount_type)
625 {
626         if (unlikely(mount_type >= LDD_MT_LAST || mount_type < 0)) {
627                 fatal();
628                 fprintf(stderr, "fs type out of range %d\n", mount_type);
629                 return 0;
630         }
631         if (backfs_ops[mount_type] == NULL) {
632                 fatal();
633                 fprintf(stderr, "unhandled/unloaded fs type %d '%s'\n",
634                         mount_type, mt_str(mount_type));
635                 return 0;
636         }
637         return 1;
638 }
639
640 /* Write the server config files */
641 int osd_write_ldd(struct mkfs_opts *mop)
642 {
643         struct lustre_disk_data *ldd = &mop->mo_ldd;
644         int ret;
645
646         if (backfs_mount_type_okay(ldd->ldd_mount_type))
647                 ret = backfs_ops[ldd->ldd_mount_type]->write_ldd(mop);
648         else
649                 ret = EINVAL;
650
651         return ret;
652 }
653
654 /* Read the server config files */
655 int osd_read_ldd(char *dev, struct lustre_disk_data *ldd)
656 {
657         int ret;
658
659         if (backfs_mount_type_okay(ldd->ldd_mount_type))
660                 ret = backfs_ops[ldd->ldd_mount_type]->read_ldd(dev, ldd);
661         else
662                 ret = EINVAL;
663
664         return ret;
665 }
666
667 /* Was this device formatted for Lustre */
668 int osd_is_lustre(char *dev, unsigned *mount_type)
669 {
670         int i;
671
672         vprint("checking for existing Lustre data: ");
673
674         for (i = 0; i < LDD_MT_LAST; ++i) {
675                 if (backfs_ops[i] != NULL &&
676                     backfs_ops[i]->is_lustre(dev, mount_type)) {
677                         vprint("found\n");
678                         return 1;
679                 }
680         }
681
682         vprint("not found\n");
683         return 0;
684 }
685
686 /* Build fs according to type */
687 int osd_make_lustre(struct mkfs_opts *mop)
688 {
689         struct lustre_disk_data *ldd = &mop->mo_ldd;
690         int ret;
691
692         if (backfs_mount_type_okay(ldd->ldd_mount_type))
693                 ret = backfs_ops[ldd->ldd_mount_type]->make_lustre(mop);
694         else
695                 ret = EINVAL;
696
697         return ret;
698 }
699
700 int osd_prepare_lustre(struct mkfs_opts *mop,
701                        char *wanted_mountopts, size_t len)
702 {
703         struct lustre_disk_data *ldd = &mop->mo_ldd;
704         int ret;
705
706         if (backfs_mount_type_okay(ldd->ldd_mount_type))
707                 ret = backfs_ops[ldd->ldd_mount_type]->prepare_lustre(mop,
708                                                         wanted_mountopts, len);
709         else
710                 ret = EINVAL;
711
712         return ret;
713 }
714
715 int osd_fix_mountopts(struct mkfs_opts *mop, char *mountopts, size_t len)
716 {
717         struct lustre_disk_data *ldd = &mop->mo_ldd;
718
719         if (!backfs_mount_type_okay(ldd->ldd_mount_type))
720                 return EINVAL;
721
722         if (backfs_ops[ldd->ldd_mount_type]->fix_mountopts == NULL)
723                 return 0;
724
725         return backfs_ops[ldd->ldd_mount_type]->fix_mountopts(mop, mountopts,
726                                                               len);
727 }
728
729 int osd_tune_lustre(char *dev, struct mount_opts *mop)
730 {
731         struct lustre_disk_data *ldd = &mop->mo_ldd;
732         int ret;
733
734         if (backfs_mount_type_okay(ldd->ldd_mount_type))
735                 ret = backfs_ops[ldd->ldd_mount_type]->tune_lustre(dev, mop);
736         else
737                 ret = EINVAL;
738
739         return ret;
740 }
741
742 int osd_label_lustre(struct mount_opts *mop)
743 {
744         struct lustre_disk_data *ldd = &mop->mo_ldd;
745         int ret;
746
747         if (backfs_mount_type_okay(ldd->ldd_mount_type))
748                 ret = backfs_ops[ldd->ldd_mount_type]->label_lustre(mop);
749         else
750                 ret = EINVAL;
751
752         return ret;
753 }
754
755 /* Enable quota accounting */
756 int osd_enable_quota(struct mkfs_opts *mop)
757 {
758         struct lustre_disk_data *ldd = &mop->mo_ldd;
759         int ret;
760
761         if (backfs_mount_type_okay(ldd->ldd_mount_type))
762                 ret = backfs_ops[ldd->ldd_mount_type]->enable_quota(mop);
763         else
764                 ret = EINVAL;
765
766         return ret;
767 }
768
769 int osd_init(void)
770 {
771         int i, rc, ret = EINVAL;
772
773         for (i = 0; i < LDD_MT_LAST; ++i) {
774                 rc = 0;
775                 backfs_ops[i] = load_backfs_module(i);
776                 if (backfs_ops[i] != NULL)
777                         rc = backfs_ops[i]->init();
778                 if (rc != 0) {
779                         backfs_ops[i]->fini();
780                         unload_backfs_module(backfs_ops[i]);
781                         backfs_ops[i] = NULL;
782                 } else
783                         ret = 0;
784         }
785
786         return ret;
787 }
788
789 void osd_fini(void)
790 {
791         int i;
792
793         for (i = 0; i < LDD_MT_LAST; ++i) {
794                 if (backfs_ops[i] != NULL) {
795                         backfs_ops[i]->fini();
796                         unload_backfs_module(backfs_ops[i]);
797                         backfs_ops[i] = NULL;
798                 }
799         }
800 }
801
802 __u64 get_device_size(char* device)
803 {
804         int ret, fd;
805         __u64 size = 0;
806
807         fd = open(device, O_RDONLY);
808         if (fd < 0) {
809                 fprintf(stderr, "%s: cannot open %s: %s\n",
810                         progname, device, strerror(errno));
811                 return 0;
812         }
813
814 #ifdef BLKGETSIZE64
815         /* size in bytes. bz5831 */
816         ret = ioctl(fd, BLKGETSIZE64, (void*)&size);
817 #else
818         {
819                 __u32 lsize = 0;
820                 /* size in blocks */
821                 ret = ioctl(fd, BLKGETSIZE, (void*)&lsize);
822                 size = (__u64)lsize * 512;
823         }
824 #endif
825         close(fd);
826         if (ret < 0) {
827                 fprintf(stderr, "%s: size ioctl failed: %s\n",
828                         progname, strerror(errno));
829                 return 0;
830         }
831
832         vprint("device size = %juMB\n", (uintmax_t)(size >> 20));
833         /* return value in KB */
834         return size >> 10;
835 }
836
837 int file_create(char *path, __u64 size)
838 {
839         __u64 size_max;
840         int ret;
841         int fd;
842
843         /*
844          * Since "size" is in KB, the file offset it represents could overflow
845          * off_t.
846          */
847         size_max = (off_t)1 << (_FILE_OFFSET_BITS - 1 - 10);
848         if (size >= size_max) {
849                 fprintf(stderr, "%s: %ju KB: Backing store size must be "
850                         "smaller than %ju KB\n", progname, (uintmax_t) size,
851                         (uintmax_t)size_max);
852                 return EFBIG;
853         }
854
855         ret = access(path, F_OK);
856         if (ret == 0) {
857                 ret = unlink(path);
858                 if (ret != 0)
859                         return errno;
860         }
861
862         fd = creat(path, S_IRUSR|S_IWUSR);
863         if (fd < 0) {
864                 fatal();
865                 fprintf(stderr, "%s: Unable to create backing store: %s\n",
866                         progname, strerror(errno));
867                 return errno;
868         }
869
870         ret = ftruncate(fd, size * 1024);
871         close(fd);
872         if (ret != 0) {
873                 fatal();
874                 fprintf(stderr, "%s: Unable to truncate backing store: %s\n",
875                         progname, strerror(errno));
876                 return errno;
877         }
878
879         return 0;
880 }
881
882 #ifdef HAVE_GSS
883 int load_shared_keys(struct mount_opts *mop)
884 {
885         DIR *dir;
886         struct dirent *dentry;
887         struct stat sbuf;
888         char fullpath[PATH_MAX];
889         char *path = mop->mo_skpath;
890         int type = 0;
891         int rc;
892
893         if (IS_SERVER(&mop->mo_ldd)) {
894                 if (IS_MGS(&mop->mo_ldd))
895                         type |= SK_TYPE_MGS;
896                 if (IS_MDT(&mop->mo_ldd) || IS_OST(&mop->mo_ldd))
897                         type |= SK_TYPE_SERVER | SK_TYPE_CLIENT;
898         } else {
899                 type |= SK_TYPE_CLIENT;
900         }
901
902         /* init logging */
903         sk_init_logging(NULL, 1, 1);
904
905         rc = stat(path, &sbuf);
906         if (rc < 0) {
907                 fprintf(stderr, "stat() failed for key %s: %s\n", path,
908                         strerror(errno));
909                 return -errno;
910         }
911
912         /* Load individual keys or a directory of them */
913         if (S_ISREG(sbuf.st_mode)) {
914                 return sk_load_keyfile(path, type);
915         } else if (!S_ISDIR(sbuf.st_mode)) {
916                 fprintf(stderr, "Invalid shared key path: %s\n", path);
917                 return -ENOKEY;
918         }
919
920         dir = opendir(path);
921         if (dir == NULL) {
922                 fprintf(stderr, "Unable to open shared key directory: %s\n",
923                         path);
924                 return -ENOENT;
925         }
926
927         /* Loop through the files in the directory attempting to load them.
928          * Any issue with loading the keyfile is treated as an error although
929          * the loop continues until all files have been attempted.  This will
930          * allow all errors be reported at once rather then requiring
931          * incremental corrections to fix each one and try again. */
932         while ((dentry = readdir(dir)) != NULL) {
933                 if (strcmp(".", dentry->d_name) == 0 ||
934                     strcmp("..", dentry->d_name) == 0)
935                         continue;
936
937                 rc = snprintf(fullpath, PATH_MAX, "%s/%s", path,
938                               dentry->d_name);
939                 if (rc >= PATH_MAX) {
940                         fprintf(stderr, "Path too long for %s/%s\n",
941                                 path, dentry->d_name);
942                         rc = -ENAMETOOLONG;
943                         continue;
944                 }
945
946                 rc = stat(fullpath, &sbuf);
947                 if (rc < 0) {
948                         fprintf(stderr, "Unable to stat %s: %s\n", fullpath,
949                                 strerror(errno));
950                         rc = -errno;
951                         continue;
952                 }
953
954                 if (!S_ISREG(sbuf.st_mode))
955                         continue;
956
957                 rc = sk_load_keyfile(fullpath, type);
958                 if (rc) {
959                         fprintf(stderr, "Failed to load key %s\n", fullpath);
960                 }
961         }
962         closedir(dir);
963
964         return rc;
965 }
966 #endif