Open up libzfs_run_process/libzfs_load_module

[zfs.git] / lib / libzfs / libzfs_util.c

diff --git a/lib/libzfs/libzfs_util.c b/lib/libzfs/libzfs_util.c
index 8277bdb..37dba8d 100644 (file)
--- a/lib/libzfs/libzfs_util.c
+++ b/lib/libzfs/libzfs_util.c
@@ -36,9 +36,11 @@
 #include <unistd.h>
 #include <ctype.h>
 #include <math.h>
+#include <sys/stat.h>
 #include <sys/mnttab.h>
 #include <sys/mntent.h>
 #include <sys/types.h>
+#include <wait.h>
 
 #include <libzfs.h>
 
@@ -603,21 +605,102 @@ libzfs_print_on_error(libzfs_handle_t *hdl, boolean_t printerr)
        hdl->libzfs_printerr = printerr;
 }
 
+static int
+libzfs_module_loaded(const char *module)
+{
+       FILE *f;
+       int result = 0;
+       char name[256];
+
+       f = fopen("/proc/modules", "r");
+       if (f == NULL)
+               return -1;
+
+       while (fgets(name, sizeof(name), f)) {
+               char *c = strchr(name, ' ');
+               if (!c)
+                       continue;
+               *c = 0;
+               if (strcmp(module, name) == 0) {
+                       result = 1;
+                       break;
+               }
+       }
+       fclose(f);
+
+       return result;
+}
+
+int
+libzfs_run_process(const char *path, char *argv[])
+{
+       pid_t pid;
+       int rc;
+
+       pid = vfork();
+       if (pid == 0) {
+               close(1);
+               close(2);
+               (void) execvp(path, argv);
+               _exit(-1);
+       } else if (pid > 0) {
+               int status;
+
+               while ((rc = waitpid(pid, &status, 0)) == -1 &&
+                       errno == EINTR);
+               if (rc < 0 || !WIFEXITED(status))
+                       return -1;
+
+               return WEXITSTATUS(status);
+       }
+
+       return -1;
+}
+
+int
+libzfs_load_module(const char *module)
+{
+       char *argv[4] = {"/sbin/modprobe", "-q", (char *)module, (char *)0};
+
+       if (libzfs_module_loaded(module))
+               return 0;
+
+       return libzfs_run_process("/sbin/modprobe", argv);
+}
+
 libzfs_handle_t *
 libzfs_init(void)
 {
        libzfs_handle_t *hdl;
 
+       if (libzfs_load_module("zfs") != 0) {
+               (void) fprintf(stderr, gettext("Failed to load ZFS module "
+                              "stack.\nLoad the module manually by running "
+                              "'insmod <location>/zfs.ko' as root.\n"));
+               return (NULL);
+       }
+
        if ((hdl = calloc(1, sizeof (libzfs_handle_t))) == NULL) {
                return (NULL);
        }
 
        if ((hdl->libzfs_fd = open(ZFS_DEV, O_RDWR)) < 0) {
+               (void) fprintf(stderr, gettext("Unable to open %s: %s.\n"),
+                              ZFS_DEV, strerror(errno));
+               if (errno == ENOENT)
+                       (void) fprintf(stderr,
+                            gettext("Verify the ZFS module stack is "
+                            "loaded by running '/sbin/modprobe zfs'.\n"));
+
                free(hdl);
                return (NULL);
        }
 
+#ifdef HAVE_SETMNTENT
+       if ((hdl->libzfs_mnttab = setmntent(MNTTAB, "r")) == NULL) {
+#else
        if ((hdl->libzfs_mnttab = fopen(MNTTAB, "r")) == NULL) {
+#endif
                (void) close(hdl->libzfs_fd);
                free(hdl);
                return (NULL);
@@ -637,10 +720,16 @@ libzfs_fini(libzfs_handle_t *hdl)
 {
        (void) close(hdl->libzfs_fd);
        if (hdl->libzfs_mnttab)
+#ifdef HAVE_SETMNTENT
+               (void) endmntent(hdl->libzfs_mnttab);
+#else
                (void) fclose(hdl->libzfs_mnttab);
+#endif
        if (hdl->libzfs_sharetab)
                (void) fclose(hdl->libzfs_sharetab);
+#ifdef HAVE_ZPL
        zfs_uninit_libshare(hdl);
+#endif
        if (hdl->libzfs_log_str)
                (void) free(hdl->libzfs_log_str);
        zpool_free_handles(hdl);
@@ -714,6 +803,46 @@ zfs_path_to_zhandle(libzfs_handle_t *hdl, char *path, zfs_type_t argtype)
 }
 
 /*
+ * Given a shorthand device name, check if a file by that name exists in a list
+ * of directories under /dev.  If one is found, store its full path in the
+ * buffer pointed to by the path argument and return 0, else return -1.  The
+ * path buffer must be allocated by the caller.
+ */
+int
+zfs_resolve_shortname(const char *name, char *path, size_t pathlen)
+{
+       int i, err;
+       char dirs[5][9] = {"by-id", "by-label", "by-path", "by-uuid", "zpool"};
+
+       (void) snprintf(path, pathlen, "%s/%s", DISK_ROOT, name);
+       err = access(path, F_OK);
+       for (i = 0; i < 5 && err < 0; i++) {
+               (void) snprintf(path, pathlen, "%s/%s/%s",
+                   UDISK_ROOT, dirs[i], name);
+               err = access(path, F_OK);
+       }
+       return err;
+}
+
+/*
+ * Append partition suffix to a device path.  This should be used to generate
+ * the name of a whole disk as it is stored in the vdev label.  The
+ * user-visible names of whole disks do not contain the partition information.
+ * Modifies buf which must be allocated by the caller.
+ */
+void
+zfs_append_partition(const char *path, char *buf, size_t buflen)
+{
+       if (strncmp(path, UDISK_ROOT, strlen(UDISK_ROOT)) == 0)
+               (void) snprintf(buf, buflen, "%s%s%s", path, "-part",
+                       FIRST_SLICE);
+       else
+               (void) snprintf(buf, buflen, "%s%s%s", path,
+                       isdigit(path[strlen(path)-1]) ?  "p" : "",
+                       FIRST_SLICE);
+}
+
+/*
  * Initialize the zc_nvlist_dst member to prepare for receiving an nvlist from
  * an ioctl().
  */