include/libzutil.h

   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  * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
  23  * Copyright (c) 2018, 2024 by Delphix. All rights reserved.
  24  */
  25
  26 #ifndef _LIBZUTIL_H
  27 #define _LIBZUTIL_H extern __attribute__((visibility("default")))
  28
  29 #include <string.h>
  30 #include <locale.h>
  31 #include <sys/nvpair.h>
  32 #include <sys/fs/zfs.h>
  33
  34 #ifdef  __cplusplus
  35 extern "C" {
  36 #endif
  37
  38 /*
  39  * Default wait time in milliseconds for a device name to be created.
  40  */
  41 #define DISK_LABEL_WAIT         (30 * 1000)  /* 30 seconds */
  42
  43
  44 /*
  45  * Pool Config Operations
  46  *
  47  * These are specific to the library libzfs or libzpool instance.
  48  */
  49 typedef nvlist_t *refresh_config_func_t(void *, nvlist_t *);
  50
  51 typedef int pool_active_func_t(void *, const char *, uint64_t, boolean_t *);
  52
  53 typedef const struct pool_config_ops {
  54         refresh_config_func_t   *pco_refresh_config;
  55         pool_active_func_t      *pco_pool_active;
  56 } pool_config_ops_t;
  57
  58 /*
  59  * An instance of pool_config_ops_t is expected in the caller's binary.
  60  */
  61 _LIBZUTIL_H pool_config_ops_t libzfs_config_ops;
  62 _LIBZUTIL_H pool_config_ops_t libzpool_config_ops;
  63
  64 typedef enum lpc_error {
  65         LPC_SUCCESS = 0,        /* no error -- success */
  66         LPC_BADCACHE = 2000,    /* out of memory */
  67         LPC_BADPATH,    /* must be an absolute path */
  68         LPC_NOMEM,      /* out of memory */
  69         LPC_EACCESS,    /* some devices require root privileges */
  70         LPC_UNKNOWN
  71 } lpc_error_t;
  72
  73 typedef struct importargs {
  74         char **path;            /* a list of paths to search            */
  75         int paths;              /* number of paths to search            */
  76         const char *poolname;   /* name of a pool to find               */
  77         uint64_t guid;          /* guid of a pool to find               */
  78         const char *cachefile;  /* cachefile to use for import          */
  79         boolean_t can_be_active; /* can the pool be active?             */
  80         boolean_t scan;         /* prefer scanning to libblkid cache    */
  81         nvlist_t *policy;       /* load policy (max txg, rewind, etc.)  */
  82         boolean_t do_destroyed;
  83         boolean_t do_all;
  84 } importargs_t;
  85
  86 typedef struct libpc_handle {
  87         int lpc_error;
  88         boolean_t lpc_printerr;
  89         boolean_t lpc_open_access_error;
  90         boolean_t lpc_desc_active;
  91         char lpc_desc[1024];
  92         pool_config_ops_t *lpc_ops;
  93         void *lpc_lib_handle;
  94 } libpc_handle_t;
  95
  96 _LIBZUTIL_H const char *libpc_error_description(libpc_handle_t *);
  97 _LIBZUTIL_H nvlist_t *zpool_search_import(libpc_handle_t *, importargs_t *);
  98 _LIBZUTIL_H int zpool_find_config(libpc_handle_t *, const char *, nvlist_t **,
  99     importargs_t *);
 100
 101 _LIBZUTIL_H const char * const * zpool_default_search_paths(size_t *count);
 102 _LIBZUTIL_H int zpool_read_label(int, nvlist_t **, int *);
 103 _LIBZUTIL_H int zpool_label_disk_wait(const char *, int);
 104 _LIBZUTIL_H int zpool_disk_wait(const char *);
 105
 106 struct udev_device;
 107
 108 _LIBZUTIL_H int zfs_device_get_devid(struct udev_device *, char *, size_t);
 109 _LIBZUTIL_H int zfs_device_get_physical(struct udev_device *, char *, size_t);
 110
 111 _LIBZUTIL_H void update_vdev_config_dev_strs(nvlist_t *);
 112
 113 /*
 114  * Default device paths
 115  */
 116 #define DISK_ROOT       "/dev"
 117 #define UDISK_ROOT      "/dev/disk"
 118 #define ZVOL_ROOT       "/dev/zvol"
 119
 120 _LIBZUTIL_H int zfs_append_partition(char *path, size_t max_len);
 121 _LIBZUTIL_H int zfs_resolve_shortname(const char *name, char *path,
 122     size_t pathlen);
 123
 124 _LIBZUTIL_H char *zfs_strip_partition(const char *);
 125 _LIBZUTIL_H const char *zfs_strip_path(const char *);
 126
 127 _LIBZUTIL_H int zfs_strcmp_pathname(const char *, const char *, int);
 128
 129 _LIBZUTIL_H boolean_t zfs_dev_is_dm(const char *);
 130 _LIBZUTIL_H boolean_t zfs_dev_is_whole_disk(const char *);
 131 _LIBZUTIL_H int zfs_dev_flush(int);
 132 _LIBZUTIL_H char *zfs_get_underlying_path(const char *);
 133 _LIBZUTIL_H char *zfs_get_enclosure_sysfs_path(const char *);
 134
 135 _LIBZUTIL_H boolean_t is_mpath_whole_disk(const char *);
 136
 137 _LIBZUTIL_H boolean_t zfs_isnumber(const char *);
 138
 139 /*
 140  * Formats for iostat numbers.  Examples: "12K", "30ms", "4B", "2321234", "-".
 141  *
 142  * ZFS_NICENUM_1024:    Print kilo, mega, tera, peta, exa..
 143  * ZFS_NICENUM_BYTES:   Print single bytes ("13B"), kilo, mega, tera...
 144  * ZFS_NICENUM_TIME:    Print nanosecs, microsecs, millisecs, seconds...
 145  * ZFS_NICENUM_RAW:     Print the raw number without any formatting
 146  * ZFS_NICENUM_RAWTIME: Same as RAW, but print dashes ('-') for zero.
 147  */
 148 enum zfs_nicenum_format {
 149         ZFS_NICENUM_1024 = 0,
 150         ZFS_NICENUM_BYTES = 1,
 151         ZFS_NICENUM_TIME = 2,
 152         ZFS_NICENUM_RAW = 3,
 153         ZFS_NICENUM_RAWTIME = 4
 154 };
 155
 156 /*
 157  * Convert a number to a human-readable form.
 158  */
 159 _LIBZUTIL_H void zfs_nicebytes(uint64_t, char *, size_t);
 160 _LIBZUTIL_H void zfs_nicenum(uint64_t, char *, size_t);
 161 _LIBZUTIL_H void zfs_nicenum_format(uint64_t, char *, size_t,
 162     enum zfs_nicenum_format);
 163 _LIBZUTIL_H void zfs_nicetime(uint64_t, char *, size_t);
 164 _LIBZUTIL_H void zfs_niceraw(uint64_t, char *, size_t);
 165
 166 #define nicenum(num, buf, size) zfs_nicenum(num, buf, size)
 167
 168 _LIBZUTIL_H void zpool_dump_ddt(const ddt_stat_t *, const ddt_histogram_t *);
 169 _LIBZUTIL_H int zpool_history_unpack(char *, uint64_t, uint64_t *, nvlist_t ***,
 170     uint_t *);
 171 _LIBZUTIL_H void fsleep(float sec);
 172 _LIBZUTIL_H int zpool_getenv_int(const char *env, int default_val);
 173
 174 struct zfs_cmd;
 175
 176 /*
 177  * List of colors to use
 178  */
 179 #define ANSI_BLACK      "\033[0;30m"
 180 #define ANSI_RED        "\033[0;31m"
 181 #define ANSI_GREEN      "\033[0;32m"
 182 #define ANSI_YELLOW     "\033[0;33m"
 183 #define ANSI_BLUE       "\033[0;34m"
 184 #define ANSI_BOLD_BLUE  "\033[1;34m" /* light blue */
 185 #define ANSI_MAGENTA    "\033[0;35m"
 186 #define ANSI_CYAN       "\033[0;36m"
 187 #define ANSI_GRAY       "\033[0;37m"
 188
 189 #define ANSI_RESET      "\033[0m"
 190 #define ANSI_BOLD       "\033[1m"
 191
 192 _LIBZUTIL_H int use_color(void);
 193 _LIBZUTIL_H void color_start(const char *color);
 194 _LIBZUTIL_H void color_end(void);
 195 _LIBZUTIL_H int printf_color(const char *color, const char *format, ...);
 196
 197 _LIBZUTIL_H const char *zfs_basename(const char *path);
 198 _LIBZUTIL_H ssize_t zfs_dirnamelen(const char *path);
 199 #ifdef __linux__
 200 extern char **environ;
 201 _LIBZUTIL_H void zfs_setproctitle_init(int argc, char *argv[], char *envp[]);
 202 _LIBZUTIL_H void zfs_setproctitle(const char *fmt, ...);
 203 #else
 204 #define zfs_setproctitle(fmt, ...)      setproctitle(fmt, ##__VA_ARGS__)
 205 #define zfs_setproctitle_init(x, y, z)  ((void)0)
 206 #endif
 207
 208 /*
 209  * These functions are used by the ZFS libraries and cmd/zpool code, but are
 210  * not exported in the ABI.
 211  */
 212 typedef int (*pool_vdev_iter_f)(void *, nvlist_t *, void *);
 213 int for_each_vdev_cb(void *zhp, nvlist_t *nv, pool_vdev_iter_f func,
 214     void *data);
 215 int for_each_vdev_macro_helper_func(void *zhp_data, nvlist_t *nv, void *data);
 216 int for_each_real_leaf_vdev_macro_helper_func(void *zhp_data, nvlist_t *nv,
 217     void *data);
 218 /*
 219  * Often you'll want to iterate over all the vdevs in the pool, but don't want
 220  * to use for_each_vdev() since it requires a callback function.
 221  *
 222  * Instead you can use FOR_EACH_VDEV():
 223  *
 224  *     zpool_handle_t *zhp      // Assume this is initialized
 225  *     nvlist_t *nv
 226  *     ...
 227  *     FOR_EACH_VDEV(zhp, nv) {
 228  *       const char *path = NULL;
 229  *       nvlist_lookup_string(nv, ZPOOL_CONFIG_PATH, &path);
 230  *       printf("Looking at vdev %s\n", path);
 231  *     }
 232  *
 233  * Note: FOR_EACH_VDEV runs in O(n^2) time where n = number of vdevs.  However,
 234  * there's an upper limit of 256 vdevs per dRAID top-level vdevs (TLDs), 255 for
 235  * raidz2 TLDs, a real world limit of ~500 vdevs for mirrors, so this shouldn't
 236  * really be an issue.
 237  *
 238  * Here are some micro-benchmarks of a complete FOR_EACH_VDEV loop on a RAID0
 239  * pool:
 240  *
 241  * 100  vdevs = 0.7ms
 242  * 500  vdevs = 17ms
 243  * 750  vdevs = 40ms
 244  * 1000 vdevs = 82ms
 245  *
 246  * The '__nv += 0' at the end of the for() loop gets around a "comma or
 247  * semicolon followed by non-blank" checkstyle error.  Note on most compliers
 248  * the '__nv += 0' can just be replaced with 'NULL', but gcc on Centos 7
 249  * will give a 'warning: statement with no effect' error if you do that.
 250  */
 251 #define __FOR_EACH_VDEV(__zhp, __nv, __func) { \
 252         __nv = zpool_get_config(__zhp, NULL); \
 253         VERIFY0(nvlist_lookup_nvlist(__nv, ZPOOL_CONFIG_VDEV_TREE, &__nv)); \
 254         } \
 255         for (nvlist_t *__root_nv = __nv, *__state = (nvlist_t *)0; \
 256             for_each_vdev_cb(&__state, __root_nv, __func, &__nv) == 1; \
 257             __nv += 0)
 258
 259 #define FOR_EACH_VDEV(__zhp, __nv) \
 260         __FOR_EACH_VDEV(__zhp, __nv, for_each_vdev_macro_helper_func)
 261
 262 /*
 263  * "real leaf" vdevs are leaf vdevs that are real devices (disks or files).
 264  * This excludes leaf vdevs like like draid spares.
 265  */
 266 #define FOR_EACH_REAL_LEAF_VDEV(__zhp, __nv) \
 267         __FOR_EACH_VDEV(__zhp, __nv, for_each_real_leaf_vdev_macro_helper_func)
 268
 269 int for_each_vdev_in_nvlist(nvlist_t *nvroot, pool_vdev_iter_f func,
 270     void *data);
 271 void update_vdevs_config_dev_sysfs_path(nvlist_t *config);
 272 _LIBZUTIL_H void update_vdev_config_dev_sysfs_path(nvlist_t *nv,
 273     const char *path, const char *key);
 274
 275 /*
 276  * Thread-safe strerror() for use in ZFS libraries
 277  */
 278 static inline char *zfs_strerror(int errnum) {
 279         return (strerror_l(errnum, uselocale(0)));
 280 }
 281
 282 #ifdef  __cplusplus
 283 }
 284 #endif
 285
 286 #endif  /* _LIBZUTIL_H */