lib/libzfs/os/freebsd/libzfs_compat.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or https://opensource.org/licenses/CDDL-1.0.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21
  22 /*
  23  * Copyright (c) 2013 Martin Matuska <mm@FreeBSD.org>. All rights reserved.
  24  */
  25 #include "../../libzfs_impl.h"
  26 #include <libzfs.h>
  27 #include <libzutil.h>
  28 #include <sys/sysctl.h>
  29 #include <libintl.h>
  30 #include <sys/linker.h>
  31 #include <sys/module.h>
  32 #include <sys/stat.h>
  33 #include <sys/param.h>
  34
  35 #ifdef IN_BASE
  36 #define ZFS_KMOD        "zfs"
  37 #else
  38 #define ZFS_KMOD        "openzfs"
  39 #endif
  40
  41 #ifndef HAVE_EXECVPE
  42 /* FreeBSD prior to 15 lacks execvpe */
  43 static int
  44 execvPe(const char *name, const char *path, char * const *argv,
  45     char * const *envp)
  46 {
  47         const char **memp;
  48         size_t cnt, lp, ln;
  49         int eacces, save_errno;
  50         char buf[MAXPATHLEN];
  51         const char *bp, *np, *op, *p;
  52         struct stat sb;
  53
  54         eacces = 0;
  55
  56         /* If it's an absolute or relative path name, it's easy. */
  57         if (strchr(name, '/')) {
  58                 bp = name;
  59                 op = NULL;
  60                 goto retry;
  61         }
  62         bp = buf;
  63
  64         /* If it's an empty path name, fail in the usual POSIX way. */
  65         if (*name == '\0') {
  66                 errno = ENOENT;
  67                 return (-1);
  68         }
  69
  70         op = path;
  71         ln = strlen(name);
  72         while (op != NULL) {
  73                 np = strchrnul(op, ':');
  74
  75                 /*
  76                  * It's a SHELL path -- double, leading and trailing colons
  77                  * mean the current directory.
  78                  */
  79                 if (np == op) {
  80                         /* Empty component. */
  81                         p = ".";
  82                         lp = 1;
  83                 } else {
  84                         /* Non-empty component. */
  85                         p = op;
  86                         lp = np - op;
  87                 }
  88
  89                 /* Advance to the next component or terminate after this. */
  90                 if (*np == '\0')
  91                         op = NULL;
  92                 else
  93                         op = np + 1;
  94
  95                 /*
  96                  * If the path is too long complain.  This is a possible
  97                  * security issue; given a way to make the path too long
  98                  * the user may execute the wrong program.
  99                  */
 100                 if (lp + ln + 2 > sizeof (buf)) {
 101                         (void) write(STDERR_FILENO, "execvP: ", 8);
 102                         (void) write(STDERR_FILENO, p, lp);
 103                         (void) write(STDERR_FILENO, ": path too long\n",
 104                             16);
 105                         continue;
 106                 }
 107                 memcpy(buf, p, lp);
 108                 buf[lp] = '/';
 109                 memcpy(buf + lp + 1, name, ln);
 110                 buf[lp + ln + 1] = '\0';
 111
 112 retry:          (void) execve(bp, argv, envp);
 113                 switch (errno) {
 114                 case E2BIG:
 115                         goto done;
 116                 case ELOOP:
 117                 case ENAMETOOLONG:
 118                 case ENOENT:
 119                         break;
 120                 case ENOEXEC:
 121                         for (cnt = 0; argv[cnt]; ++cnt)
 122                                 ;
 123
 124                         /*
 125                          * cnt may be 0 above; always allocate at least
 126                          * 3 entries so that we can at least fit "sh", bp, and
 127                          * the NULL terminator.  We can rely on cnt to take into
 128                          * account the NULL terminator in all other scenarios,
 129                          * as we drop argv[0].
 130                          */
 131                         memp = alloca(MAX(3, cnt + 2) * sizeof (char *));
 132                         if (memp == NULL) {
 133                                 /* errno = ENOMEM; XXX override ENOEXEC? */
 134                                 goto done;
 135                         }
 136                         if (cnt > 0) {
 137                                 memp[0] = argv[0];
 138                                 memp[1] = bp;
 139                                 memcpy(memp + 2, argv + 1,
 140                                     cnt * sizeof (char *));
 141                         } else {
 142                                 memp[0] = "sh";
 143                                 memp[1] = bp;
 144                                 memp[2] = NULL;
 145                         }
 146                         (void) execve(_PATH_BSHELL,
 147                             __DECONST(char **, memp), envp);
 148                         goto done;
 149                 case ENOMEM:
 150                         goto done;
 151                 case ENOTDIR:
 152                         break;
 153                 case ETXTBSY:
 154                         /*
 155                          * We used to retry here, but sh(1) doesn't.
 156                          */
 157                         goto done;
 158                 default:
 159                         /*
 160                          * EACCES may be for an inaccessible directory or
 161                          * a non-executable file.  Call stat() to decide
 162                          * which.  This also handles ambiguities for EFAULT
 163                          * and EIO, and undocumented errors like ESTALE.
 164                          * We hope that the race for a stat() is unimportant.
 165                          */
 166                         save_errno = errno;
 167                         if (stat(bp, &sb) != 0)
 168                                 break;
 169                         if (save_errno == EACCES) {
 170                                 eacces = 1;
 171                                 continue;
 172                         }
 173                         errno = save_errno;
 174                         goto done;
 175                 }
 176         }
 177         if (eacces)
 178                 errno = EACCES;
 179         else
 180                 errno = ENOENT;
 181 done:
 182         return (-1);
 183 }
 184
 185 int
 186 execvpe(const char *name, char * const argv[], char * const envp[])
 187 {
 188         const char *path;
 189
 190         /* Get the path we're searching. */
 191         if ((path = getenv("PATH")) == NULL)
 192                 path = _PATH_DEFPATH;
 193
 194         return (execvPe(name, path, argv, envp));
 195 }
 196 #endif /* !HAVE_EXECVPE */
 197
 198 static __thread char errbuf[ERRBUFLEN];
 199
 200 const char *
 201 libzfs_error_init(int error)
 202 {
 203         char *msg = errbuf;
 204         size_t msglen = sizeof (errbuf);
 205
 206         if (modfind("zfs") < 0) {
 207                 size_t len = snprintf(msg, msglen, dgettext(TEXT_DOMAIN,
 208                     "Failed to load %s module: "), ZFS_KMOD);
 209                 if (len >= msglen)
 210                         len = msglen - 1;
 211                 msg += len;
 212                 msglen -= len;
 213         }
 214
 215         (void) snprintf(msg, msglen, "%s", zfs_strerror(error));
 216
 217         return (errbuf);
 218 }
 219
 220 int
 221 zfs_ioctl(libzfs_handle_t *hdl, int request, zfs_cmd_t *zc)
 222 {
 223         return (lzc_ioctl_fd(hdl->libzfs_fd, request, zc));
 224 }
 225
 226 /*
 227  * Verify the required ZFS_DEV device is available and optionally attempt
 228  * to load the ZFS modules.  Under normal circumstances the modules
 229  * should already have been loaded by some external mechanism.
 230  */
 231 int
 232 libzfs_load_module(void)
 233 {
 234         /*
 235          * XXX: kldfind(ZFS_KMOD) would be nice here, but we retain
 236          * modfind("zfs") so out-of-base openzfs userland works with the
 237          * in-base module.
 238          */
 239         if (modfind("zfs") < 0) {
 240                 /* Not present in kernel, try loading it. */
 241                 if (kldload(ZFS_KMOD) < 0 && errno != EEXIST) {
 242                         return (errno);
 243                 }
 244         }
 245         return (0);
 246 }
 247
 248 int
 249 zpool_relabel_disk(libzfs_handle_t *hdl, const char *path, const char *msg)
 250 {
 251         (void) hdl, (void) path, (void) msg;
 252         return (0);
 253 }
 254
 255 int
 256 zpool_label_disk(libzfs_handle_t *hdl, zpool_handle_t *zhp, const char *name)
 257 {
 258         (void) hdl, (void) zhp, (void) name;
 259         return (0);
 260 }
 261
 262 int
 263 find_shares_object(differ_info_t *di)
 264 {
 265         (void) di;
 266         return (0);
 267 }
 268
 269 int
 270 zfs_destroy_snaps_nvl_os(libzfs_handle_t *hdl, nvlist_t *snaps)
 271 {
 272         (void) hdl, (void) snaps;
 273         return (0);
 274 }
 275
 276 /*
 277  * Attach/detach the given filesystem to/from the given jail.
 278  */
 279 int
 280 zfs_jail(zfs_handle_t *zhp, int jailid, int attach)
 281 {
 282         libzfs_handle_t *hdl = zhp->zfs_hdl;
 283         zfs_cmd_t zc = {"\0"};
 284         unsigned long cmd;
 285         int ret;
 286
 287         if (attach) {
 288                 (void) snprintf(errbuf, sizeof (errbuf),
 289                     dgettext(TEXT_DOMAIN, "cannot jail '%s'"), zhp->zfs_name);
 290         } else {
 291                 (void) snprintf(errbuf, sizeof (errbuf),
 292                     dgettext(TEXT_DOMAIN, "cannot unjail '%s'"), zhp->zfs_name);
 293         }
 294
 295         switch (zhp->zfs_type) {
 296         case ZFS_TYPE_VOLUME:
 297                 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
 298                     "volumes can not be jailed"));
 299                 return (zfs_error(hdl, EZFS_BADTYPE, errbuf));
 300         case ZFS_TYPE_SNAPSHOT:
 301                 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
 302                     "snapshots can not be jailed"));
 303                 return (zfs_error(hdl, EZFS_BADTYPE, errbuf));
 304         case ZFS_TYPE_BOOKMARK:
 305                 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
 306                     "bookmarks can not be jailed"));
 307                 return (zfs_error(hdl, EZFS_BADTYPE, errbuf));
 308         case ZFS_TYPE_VDEV:
 309                 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
 310                     "vdevs can not be jailed"));
 311                 return (zfs_error(hdl, EZFS_BADTYPE, errbuf));
 312         case ZFS_TYPE_INVALID:
 313                 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
 314                     "invalid zfs_type_t: ZFS_TYPE_INVALID"));
 315                 return (zfs_error(hdl, EZFS_BADTYPE, errbuf));
 316         case ZFS_TYPE_POOL:
 317         case ZFS_TYPE_FILESYSTEM:
 318                 /* OK */
 319                 ;
 320         }
 321         assert(zhp->zfs_type == ZFS_TYPE_FILESYSTEM);
 322
 323         (void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name));
 324         zc.zc_objset_type = DMU_OST_ZFS;
 325         zc.zc_zoneid = jailid;
 326
 327         cmd = attach ? ZFS_IOC_JAIL : ZFS_IOC_UNJAIL;
 328         if ((ret = zfs_ioctl(hdl, cmd, &zc)) != 0)
 329                 zfs_standard_error(hdl, errno, errbuf);
 330
 331         return (ret);
 332 }
 333
 334 /*
 335  * Set loader options for next boot.
 336  */
 337 int
 338 zpool_nextboot(libzfs_handle_t *hdl, uint64_t pool_guid, uint64_t dev_guid,
 339     const char *command)
 340 {
 341         zfs_cmd_t zc = {"\0"};
 342         nvlist_t *args;
 343
 344         args = fnvlist_alloc();
 345         fnvlist_add_uint64(args, ZPOOL_CONFIG_POOL_GUID, pool_guid);
 346         fnvlist_add_uint64(args, ZPOOL_CONFIG_GUID, dev_guid);
 347         fnvlist_add_string(args, "command", command);
 348         zcmd_write_src_nvlist(hdl, &zc, args);
 349         int error = zfs_ioctl(hdl, ZFS_IOC_NEXTBOOT, &zc);
 350         zcmd_free_nvlists(&zc);
 351         nvlist_free(args);
 352         return (error);
 353 }
 354
 355 /*
 356  * Return allocated loaded module version, or NULL on error (with errno set)
 357  */
 358 char *
 359 zfs_version_kernel(void)
 360 {
 361         size_t l;
 362         if (sysctlbyname("vfs.zfs.version.module",
 363             NULL, &l, NULL, 0) == -1)
 364                 return (NULL);
 365         char *version = malloc(l);
 366         if (version == NULL)
 367                 return (NULL);
 368         if (sysctlbyname("vfs.zfs.version.module",
 369             version, &l, NULL, 0) == -1) {
 370                 free(version);
 371                 return (NULL);
 372         }
 373         return (version);
 374 }