Whamcloud - gitweb
d347d895c53c8b878d733cb8017d9966e36e3797
[fs/lustre-release.git] / lustre / utils / mount_utils_zfs.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,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License version 2 for more details.  A copy is
14  * included in the COPYING file that accompanied this code.
15
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19  *
20  * GPL HEADER END
21  */
22 /*
23  * Copyright (c) 2011, 2012 Whamcloud, Inc.
24  * Use is subject to license terms.
25  *
26  */
27 /*
28  * Author: Brian Behlendorf <behlendorf1@llnl.gov>
29  */
30 #include "mount_utils.h"
31 #include <stdio.h>
32 #include <string.h>
33 #include <libzfs.h>
34 #include <dlfcn.h>
35
36 /* Persistent mount data is stored in these user  attributes */
37 #define LDD_VERSION_PROP                "lustre:version"
38 #define LDD_FLAGS_PROP                  "lustre:flags"
39 #define LDD_INDEX_PROP                  "lustre:index"
40 #define LDD_FSNAME_PROP                 "lustre:fsname"
41 #define LDD_SVNAME_PROP                 "lustre:svname"
42 #define LDD_UUID_PROP                   "lustre:uuid"
43 #define LDD_USERDATA_PROP               "lustre:userdata"
44 #define LDD_MOUNTOPTS_PROP              "lustre:mountopts"
45 #define LDD_MGSNODE_PROP                "lustre:mgsnode"
46 #define LDD_FAILNODE_PROP               "lustre:failnode"
47 #define LDD_FAILMODE_PROP               "lustre:failmode"
48 #define LDD_IDENTITY_UPCALL_PROP        "lustre:identity_upcall"
49
50 /* indicate if the ZFS OSD has been successfully setup */
51 static int osd_zfs_setup = 0;
52
53 static libzfs_handle_t *g_zfs;
54
55 /* dynamic linking handles for libzfs & libnvpair */
56 static void *handle_libzfs;
57 static void *handle_nvpair;
58
59 /* symbol table looked up with dlsym */
60 struct zfs_symbols {
61         libzfs_handle_t *(*libzfs_init)(void);
62         void            (*libzfs_fini)(libzfs_handle_t *);
63         int             (*libzfs_load_module)(char *);
64         zfs_handle_t*   (*zfs_open)(libzfs_handle_t *, const char *, int);
65         int             (*zfs_destroy)(zfs_handle_t *, boolean_t);
66         void            (*zfs_close)(zfs_handle_t *);
67         int     (*zfs_prop_set)(zfs_handle_t*, const char*, const char*);
68         nvlist_t*       (*zfs_get_user_props)  (zfs_handle_t *);
69         int             (*zfs_name_valid)(const char *, zfs_type_t);
70         zpool_handle_t* (*zpool_open)(libzfs_handle_t *, const char *);
71         void            (*zpool_close)(zpool_handle_t *zhp);
72         int             (*nvlist_lookup_string)(nvlist_t*, const char*, char**);
73         int     (*nvlist_lookup_nvlist)(nvlist_t *, const char *, nvlist_t **);
74 };
75
76 static struct zfs_symbols sym;
77 void zfs_fini(void);
78
79 #define DLSYM(handle, func)                                        \
80         do {                                                       \
81                 sym.func = (typeof(sym.func))dlsym(handle, #func); \
82         } while(0)
83
84 /* populate the symbol table after a successful call to dlopen() */
85 static int zfs_populate_symbols(void)
86 {
87         char *error;
88
89         dlerror(); /* Clear any existing error */
90
91         DLSYM(handle_libzfs, libzfs_init);
92 #define libzfs_init (*sym.libzfs_init)
93         DLSYM(handle_libzfs, libzfs_fini);
94 #define libzfs_fini (*sym.libzfs_fini)
95         DLSYM(handle_libzfs, libzfs_load_module);
96 #define libzfs_load_module (*sym.libzfs_load_module)
97         DLSYM(handle_libzfs, zfs_open);
98 #define zfs_open (*sym.zfs_open)
99         DLSYM(handle_libzfs, zfs_destroy);
100 #define zfs_destroy (*sym.zfs_destroy)
101         DLSYM(handle_libzfs, zfs_close);
102 #define zfs_close (*sym.zfs_close)
103         DLSYM(handle_libzfs, zfs_prop_set);
104 #define zfs_prop_set (*sym.zfs_prop_set)
105         DLSYM(handle_libzfs, zfs_get_user_props);
106 #define zfs_get_user_props (*sym.zfs_get_user_props)
107         DLSYM(handle_libzfs, zfs_name_valid);
108 #define zfs_name_valid (*sym.zfs_name_valid)
109         DLSYM(handle_libzfs, zpool_open);
110 #define zpool_open (*sym.zpool_open)
111         DLSYM(handle_libzfs, zpool_close);
112 #define zpool_close (*sym.zpool_close)
113         DLSYM(handle_nvpair, nvlist_lookup_string);
114 #define nvlist_lookup_string (*sym.nvlist_lookup_string)
115         DLSYM(handle_nvpair, nvlist_lookup_nvlist);
116 #define nvlist_lookup_nvlist (*sym.nvlist_lookup_nvlist)
117
118         error = dlerror();
119         if (error != NULL) {
120                 fatal();
121                 fprintf(stderr, "%s\n", error);
122                 return EINVAL;
123         }
124         return 0;
125 }
126
127 static int zfs_set_prop_int(zfs_handle_t *zhp, char *prop, __u32 val)
128 {
129         char str[64];
130         int ret;
131
132         (void) snprintf(str, sizeof (str), "%lu", (unsigned long)val);
133         vprint("  %s=%s\n", prop, str);
134         ret = zfs_prop_set(zhp, prop, str);
135
136         return ret;
137 }
138
139 /*
140  * Write the zfs property string, note that properties with a NULL or
141  * zero-length value will not be written and 0 returned.
142  */
143 static int zfs_set_prop_str(zfs_handle_t *zhp, char *prop, char *val)
144 {
145         int ret = 0;
146
147         if (val && strlen(val) > 0) {
148                 vprint("  %s=%s\n", prop, val);
149                 ret = zfs_prop_set(zhp, prop, val);
150         }
151
152         return ret;
153 }
154
155 static int zfs_set_prop_param(zfs_handle_t *zhp, struct lustre_disk_data *ldd,
156                               char *param, char *prop)
157 {
158         char *str;
159         int ret = 0;
160
161         if (get_param(ldd->ldd_params, param, &str) == 0) {
162                 vprint("  %s=%s\n", prop, str);
163                 ret = zfs_prop_set(zhp, prop, str);
164                 free(str);
165         }
166
167         return ret;
168 }
169
170 static int osd_check_zfs_setup(void)
171 {
172         if (osd_zfs_setup == 0) {
173                 /* setup failed */
174                 fatal();
175                 fprintf(stderr, "Failed to initialize ZFS library. Are the ZFS "
176                         "packages and modules correctly installed?\n");
177         }
178         return osd_zfs_setup == 1;
179 }
180
181 /* Write the server config as properties associated with the dataset */
182 int zfs_write_ldd(struct mkfs_opts *mop)
183 {
184         struct lustre_disk_data *ldd = &mop->mo_ldd;
185         char *ds = mop->mo_device;
186         zfs_handle_t *zhp;
187         int ret = EINVAL;
188
189         if (osd_check_zfs_setup() == 0)
190                 return EINVAL;
191
192         zhp = zfs_open(g_zfs, ds, ZFS_TYPE_FILESYSTEM);
193         if (zhp == NULL) {
194                 fprintf(stderr, "Failed to open zfs dataset %s\n", ds);
195                 goto out;
196         }
197
198         vprint("Writing %s properties\n", ds);
199
200         ret = zfs_set_prop_int(zhp, LDD_VERSION_PROP, ldd->ldd_config_ver);
201         if (ret)
202                 goto out_close;
203
204         ret = zfs_set_prop_int(zhp, LDD_FLAGS_PROP, ldd->ldd_flags);
205         if (ret)
206                 goto out_close;
207
208         ret = zfs_set_prop_int(zhp, LDD_INDEX_PROP, ldd->ldd_svindex);
209         if (ret)
210                 goto out_close;
211
212         ret = zfs_set_prop_str(zhp, LDD_FSNAME_PROP, ldd->ldd_fsname);
213         if (ret)
214                 goto out_close;
215
216         ret = zfs_set_prop_str(zhp, LDD_SVNAME_PROP, ldd->ldd_svname);
217         if (ret)
218                 goto out_close;
219
220         ret = zfs_set_prop_str(zhp, LDD_UUID_PROP, (char *)ldd->ldd_uuid);
221         if (ret)
222                 goto out_close;
223
224         ret = zfs_set_prop_str(zhp, LDD_USERDATA_PROP, ldd->ldd_userdata);
225         if (ret)
226                 goto out_close;
227
228         ret = zfs_set_prop_str(zhp, LDD_MOUNTOPTS_PROP, ldd->ldd_mount_opts);
229         if (ret)
230                 goto out_close;
231
232         ret = zfs_set_prop_param(zhp, ldd, PARAM_MGSNODE, LDD_MGSNODE_PROP);
233         if (ret)
234                 goto out_close;
235
236         ret = zfs_set_prop_param(zhp, ldd, PARAM_FAILNODE, LDD_FAILNODE_PROP);
237         if (ret)
238                 goto out_close;
239
240         ret = zfs_set_prop_param(zhp, ldd, PARAM_FAILMODE, LDD_FAILMODE_PROP);
241         if (ret)
242                 goto out_close;
243
244         ret = zfs_set_prop_param(zhp, ldd, PARAM_MDT PARAM_ID_UPCALL,
245                                  LDD_IDENTITY_UPCALL_PROP);
246         if (ret)
247                 goto out_close;
248
249 out_close:
250         zfs_close(zhp);
251 out:
252         return ret;
253 }
254
255 static int zfs_get_prop_int(zfs_handle_t *zhp, char *prop, __u32 *val)
256 {
257         nvlist_t *propval;
258         char *propstr;
259         int ret;
260
261         ret = nvlist_lookup_nvlist(zfs_get_user_props(zhp), prop, &propval);
262         if (ret)
263                 return ret;
264
265         ret = nvlist_lookup_string(propval, ZPROP_VALUE, &propstr);
266         if (ret)
267                 return ret;
268
269         errno = 0;
270         *val = strtoul(propstr, NULL, 10);
271         if (errno)
272                 return errno;
273
274         return ret;
275 }
276
277 static int zfs_get_prop_str(zfs_handle_t *zhp, char *prop, char *val)
278 {
279         nvlist_t *propval;
280         char *propstr;
281         int ret;
282
283         ret = nvlist_lookup_nvlist(zfs_get_user_props(zhp), prop, &propval);
284         if (ret)
285                 return ret;
286
287         ret = nvlist_lookup_string(propval, ZPROP_VALUE, &propstr);
288         if (ret)
289                 return ret;
290
291         (void) strcpy(val, propstr);
292
293         return ret;
294 }
295
296 static int zfs_get_prop_param(zfs_handle_t *zhp, struct lustre_disk_data *ldd,
297                 char *param, char *prop)
298 {
299         nvlist_t *propval;
300         char *propstr;
301         int ret;
302
303         ret = nvlist_lookup_nvlist(zfs_get_user_props(zhp), prop, &propval);
304         if (ret)
305                 return ret;
306
307         ret = nvlist_lookup_string(propval, ZPROP_VALUE, &propstr);
308         if (ret)
309                 return ret;
310
311         ret = add_param(ldd->ldd_params, param, propstr);
312
313         return ret;
314 }
315
316 /*
317  * Read the server config as properties associated with the dataset.
318  * Missing entries as not treated error and are simply skipped.
319  */
320 int zfs_read_ldd(char *ds,  struct lustre_disk_data *ldd)
321 {
322         zfs_handle_t *zhp;
323         int ret = EINVAL;
324
325         if (osd_check_zfs_setup() == 0)
326                 return EINVAL;
327
328         zhp = zfs_open(g_zfs, ds, ZFS_TYPE_FILESYSTEM);
329         if (zhp == NULL)
330                 goto out;
331
332         ret = zfs_get_prop_int(zhp, LDD_VERSION_PROP, &ldd->ldd_config_ver);
333         if (ret && (ret != ENOENT))
334                 goto out_close;
335
336         ret = zfs_get_prop_int(zhp, LDD_FLAGS_PROP, &ldd->ldd_flags);
337         if (ret && (ret != ENOENT))
338                 goto out_close;
339
340         ret = zfs_get_prop_int(zhp, LDD_INDEX_PROP, &ldd->ldd_svindex);
341         if (ret && (ret != ENOENT))
342                 goto out_close;
343
344         ret = zfs_get_prop_str(zhp, LDD_FSNAME_PROP, ldd->ldd_fsname);
345         if (ret && (ret != ENOENT))
346                 goto out_close;
347
348         ret = zfs_get_prop_str(zhp, LDD_SVNAME_PROP, ldd->ldd_svname);
349         if (ret && (ret != ENOENT))
350                 goto out_close;
351
352         ret = zfs_get_prop_str(zhp, LDD_UUID_PROP, (char *)ldd->ldd_uuid);
353         if (ret && (ret != ENOENT))
354                 goto out_close;
355
356         ret = zfs_get_prop_str(zhp, LDD_USERDATA_PROP, ldd->ldd_userdata);
357         if (ret && (ret != ENOENT))
358                 goto out_close;
359
360         ret = zfs_get_prop_str(zhp, LDD_MOUNTOPTS_PROP, ldd->ldd_mount_opts);
361         if (ret && (ret != ENOENT))
362                 goto out_close;
363
364         ret = zfs_get_prop_param(zhp, ldd, PARAM_MGSNODE, LDD_MGSNODE_PROP);
365         if (ret && (ret != ENOENT))
366                 goto out_close;
367
368         ret = zfs_get_prop_param(zhp, ldd, PARAM_FAILNODE, LDD_FAILNODE_PROP);
369         if (ret && (ret != ENOENT))
370                 goto out_close;
371
372         ret = zfs_get_prop_param(zhp, ldd, PARAM_FAILMODE, LDD_FAILMODE_PROP);
373         if (ret && (ret != ENOENT))
374                 goto out_close;
375
376         ret = zfs_get_prop_param(zhp, ldd, PARAM_MDT PARAM_ID_UPCALL,
377                                  LDD_IDENTITY_UPCALL_PROP);
378         if (ret && (ret != ENOENT))
379                 goto out_close;
380
381         ldd->ldd_mount_type = LDD_MT_ZFS;
382         ret = 0;
383 out_close:
384         zfs_close(zhp);
385 out:
386         return ret;
387 }
388
389 int zfs_is_lustre(char *ds, unsigned *mount_type)
390 {
391         struct lustre_disk_data tmp_ldd;
392         int ret;
393
394         if (osd_zfs_setup == 0)
395                 return 0;
396
397         ret = zfs_read_ldd(ds, &tmp_ldd);
398         if ((ret == 0) && (tmp_ldd.ldd_config_ver > 0) &&
399             (strlen(tmp_ldd.ldd_fsname) > 0) &&
400             (strlen(tmp_ldd.ldd_svname) > 0)) {
401                 *mount_type = tmp_ldd.ldd_mount_type;
402                 return 1;
403         }
404
405         return 0;
406 }
407
408 static char *zfs_mkfs_opts(struct mkfs_opts *mop, char *str, int len)
409 {
410         memset(str, 0, len);
411
412         if (strlen(mop->mo_mkfsopts) != 0)
413                 snprintf(str, len, " -o %s", mop->mo_mkfsopts);
414
415         return str;
416 }
417
418 static int zfs_create_vdev(struct mkfs_opts *mop, char *vdev)
419 {
420         int ret = 0;
421
422         /* Silently ignore reserved vdev names */
423         if ((strncmp(vdev, "disk", 4) == 0) ||
424             (strncmp(vdev, "file", 4) == 0) ||
425             (strncmp(vdev, "mirror", 6) == 0) ||
426             (strncmp(vdev, "raidz", 5) == 0) ||
427             (strncmp(vdev, "spare", 5) == 0) ||
428             (strncmp(vdev, "log", 3) == 0) ||
429             (strncmp(vdev, "cache", 5) == 0))
430                 return ret;
431
432         /*
433          * Verify a file exists at the provided absolute path.  If it doesn't
434          * and mo_device_sz is set attempt to create a file vdev to be used.
435          * Relative paths will be passed directly to 'zpool create' which
436          * will check multiple multiple locations under /dev/.
437          */
438         if (vdev[0] == '/') {
439                 ret = access(vdev, F_OK);
440                 if (ret == 0)
441                         return ret;
442
443                 ret = errno;
444                 if (ret != ENOENT) {
445                         fatal();
446                         fprintf(stderr, "Unable to access required vdev "
447                                 "for pool %s (%d)\n", vdev, ret);
448                         return ret;
449                 }
450
451                 if (mop->mo_device_sz == 0) {
452                         fatal();
453                         fprintf(stderr, "Unable to create vdev due to "
454                                 "missing --device-size=#N(KB) parameter\n");
455                         return EINVAL;
456                 }
457
458                 ret = file_create(vdev, mop->mo_device_sz);
459                 if (ret) {
460                         fatal();
461                         fprintf(stderr, "Unable to create vdev %s (%d)\n",
462                                 vdev, ret);
463                         return ret;
464                 }
465         }
466
467         return ret;
468 }
469
470 int zfs_make_lustre(struct mkfs_opts *mop)
471 {
472         zfs_handle_t *zhp;
473         zpool_handle_t *php;
474         char *pool = NULL;
475         char *mkfs_cmd = NULL;
476         char *mkfs_tmp = NULL;
477         char *ds = mop->mo_device;
478         int pool_exists = 0, ret;
479
480         if (osd_check_zfs_setup() == 0)
481                 return EINVAL;
482
483         /* no automatic index with zfs backend */
484         if (mop->mo_ldd.ldd_flags & LDD_F_NEED_INDEX) {
485                 fatal();
486                 fprintf(stderr, "The target index must be specified with "
487                                 "--index\n");
488                 return EINVAL;
489         }
490
491         pool = strdup(ds);
492         if (pool == NULL)
493                 return ENOMEM;
494
495         mkfs_cmd = malloc(PATH_MAX);
496         if (mkfs_cmd == NULL) {
497                 ret = ENOMEM;
498                 goto out;
499         }
500
501         mkfs_tmp = malloc(PATH_MAX);
502         if (mkfs_tmp == NULL) {
503                 ret = ENOMEM;
504                 goto out;
505         }
506
507         /* Due to zfs_name_valid() check the '/' must exist */
508         strchr(pool, '/')[0] = '\0';
509
510         /* If --reformat was given attempt to destroy the previous dataset */
511         if ((mop->mo_flags & MO_FORCEFORMAT) &&
512             ((zhp = zfs_open(g_zfs, ds, ZFS_TYPE_FILESYSTEM)) != NULL)) {
513
514                 ret = zfs_destroy(zhp, 0);
515                 if (ret) {
516                         zfs_close(zhp);
517                         fprintf(stderr, "Failed destroy zfs dataset %s (%d)\n",
518                                 ds, ret);
519                         goto out;
520                 }
521
522                 zfs_close(zhp);
523         }
524
525         /*
526          * Create the zpool if the vdevs have been specified and the pool
527          * does not already exists.  The pool creation itself will be done
528          * with the zpool command rather than the zpool_create() library call
529          * so the existing zpool error handling can be leveraged.
530          */
531         php = zpool_open(g_zfs, pool);
532         if (php) {
533                 pool_exists = 1;
534                 zpool_close(php);
535         }
536
537         if ((mop->mo_pool_vdevs != NULL) && (pool_exists == 0)) {
538
539                 memset(mkfs_cmd, 0, PATH_MAX);
540                 snprintf(mkfs_cmd, PATH_MAX,
541                         "zpool create -f -O canmount=off %s", pool);
542
543                 /* Append the vdev config and create file vdevs as required */
544                 while (*mop->mo_pool_vdevs != NULL) {
545                         strscat(mkfs_cmd, " ", PATH_MAX);
546                         strscat(mkfs_cmd, *mop->mo_pool_vdevs, PATH_MAX);
547
548                         ret = zfs_create_vdev(mop, *mop->mo_pool_vdevs);
549                         if (ret)
550                                 goto out;
551
552                         mop->mo_pool_vdevs++;
553                 }
554
555                 vprint("mkfs_cmd = %s\n", mkfs_cmd);
556                 ret = run_command(mkfs_cmd, PATH_MAX);
557                 if (ret) {
558                         fatal();
559                         fprintf(stderr, "Unable to create pool %s (%d)\n",
560                                 pool, ret);
561                         goto out;
562                 }
563         }
564
565         /*
566          * Create the ZFS filesystem with any required mkfs options:
567          * - canmount=off is set to prevent zfs automounting
568          * - version=4 is set because SA are not yet handled by the osd
569          */
570         memset(mkfs_cmd, 0, PATH_MAX);
571         snprintf(mkfs_cmd, PATH_MAX,
572                  "zfs create -o canmount=off -o xattr=sa%s %s",
573                  zfs_mkfs_opts(mop, mkfs_tmp, PATH_MAX),
574                  ds);
575
576         vprint("mkfs_cmd = %s\n", mkfs_cmd);
577         ret = run_command(mkfs_cmd, PATH_MAX);
578         if (ret) {
579                 fatal();
580                 fprintf(stderr, "Unable to create filesystem %s (%d)\n",
581                         ds, ret);
582                 goto out;
583         }
584
585 out:
586         if (pool != NULL)
587                 free(pool);
588
589         if (mkfs_cmd != NULL)
590                 free(mkfs_cmd);
591
592         if (mkfs_tmp != NULL)
593                 free(mkfs_tmp);
594
595         return ret;
596 }
597
598 int zfs_prepare_lustre(struct mkfs_opts *mop,
599                 char *default_mountopts, int default_len,
600                 char *always_mountopts, int always_len)
601 {
602         int ret;
603
604         if (osd_check_zfs_setup() == 0)
605                 return EINVAL;
606
607         ret = zfs_name_valid(mop->mo_device, ZFS_TYPE_FILESYSTEM);
608         if (!ret) {
609                 fatal();
610                 fprintf(stderr, "Invalid filesystem name %s\n", mop->mo_device);
611                 return EINVAL;
612         }
613
614         return 0;
615 }
616
617 int zfs_tune_lustre(char *dev, struct mount_opts *mop)
618 {
619         if (osd_check_zfs_setup() == 0)
620                 return EINVAL;
621
622         return 0;
623 }
624
625 int zfs_label_lustre(struct mount_opts *mop)
626 {
627         zfs_handle_t *zhp;
628         int ret;
629
630         if (osd_check_zfs_setup() == 0)
631                 return EINVAL;
632
633         zhp = zfs_open(g_zfs, mop->mo_source, ZFS_TYPE_FILESYSTEM);
634         if (zhp == NULL)
635                 return EINVAL;
636
637         ret = zfs_set_prop_str(zhp, LDD_SVNAME_PROP, mop->mo_ldd.ldd_svname);
638         zfs_close(zhp);
639
640         return ret;
641 }
642
643 int zfs_init(void)
644 {
645         int ret = 0;
646
647         /* If the ZFS libs are not installed, don't print an error to avoid
648          * spamming ldiskfs users. An error message will still be printed if
649          * someone tries to do some real work involving a ZFS backend */
650
651         handle_libzfs = dlopen("libzfs.so", RTLD_LAZY);
652         if (handle_libzfs == NULL)
653                 return EINVAL;
654
655         handle_nvpair = dlopen("libnvpair.so", RTLD_LAZY);
656         if (handle_nvpair == NULL) {
657                 ret = EINVAL;
658                 goto out;
659         }
660
661         ret = zfs_populate_symbols();
662         if (ret)
663                 goto out;
664
665         if (libzfs_load_module("zfs") != 0) {
666                 /* The ZFS modules are not installed */
667                 ret = EINVAL;
668                 goto out;
669         }
670
671         g_zfs = libzfs_init();
672         if (g_zfs == NULL) {
673                 fprintf(stderr, "Failed to initialize ZFS library\n");
674                 ret = EINVAL;
675         }
676 out:
677         osd_zfs_setup = 1;
678         if (ret)
679                 zfs_fini();
680         return ret;
681 }
682
683 void zfs_fini(void)
684 {
685         if (g_zfs) {
686                 libzfs_fini(g_zfs);
687                 g_zfs = NULL;
688         }
689         if (handle_nvpair) {
690                 dlclose(handle_nvpair);
691                 handle_nvpair = NULL;
692         }
693         if (handle_libzfs) {
694                 dlclose(handle_libzfs);
695                 handle_libzfs = NULL;
696         }
697
698         osd_zfs_setup = 0;
699 }