module/zcommon/zprop_common.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 http://www.opensolaris.org/os/licensing.
  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 2010 Sun Microsystems, Inc.  All rights reserved.
  23  * Use is subject to license terms.
  24  */
  25 /*
  26  * Copyright (c) 2012 by Delphix. All rights reserved.
  27  */
  28
  29 /*
  30  * Common routines used by zfs and zpool property management.
  31  */
  32
  33 #include <sys/zio.h>
  34 #include <sys/spa.h>
  35 #include <sys/zfs_acl.h>
  36 #include <sys/zfs_ioctl.h>
  37 #include <sys/zfs_znode.h>
  38 #include <sys/fs/zfs.h>
  39
  40 #include "zfs_prop.h"
  41 #include "zfs_deleg.h"
  42
  43 #if defined(_KERNEL)
  44 #include <sys/systm.h>
  45 #include <util/qsort.h>
  46 #else
  47 #include <stdlib.h>
  48 #include <string.h>
  49 #include <ctype.h>
  50 #endif
  51
  52 static zprop_desc_t *
  53 zprop_get_proptable(zfs_type_t type)
  54 {
  55         if (type == ZFS_TYPE_POOL)
  56                 return (zpool_prop_get_table());
  57         else
  58                 return (zfs_prop_get_table());
  59 }
  60
  61 static int
  62 zprop_get_numprops(zfs_type_t type)
  63 {
  64         if (type == ZFS_TYPE_POOL)
  65                 return (ZPOOL_NUM_PROPS);
  66         else
  67                 return (ZFS_NUM_PROPS);
  68 }
  69
  70 void
  71 zprop_register_impl(int prop, const char *name, zprop_type_t type,
  72     uint64_t numdefault, const char *strdefault, zprop_attr_t attr,
  73     int objset_types, const char *values, const char *colname,
  74     boolean_t rightalign, boolean_t visible, const zprop_index_t *idx_tbl)
  75 {
  76         zprop_desc_t *prop_tbl = zprop_get_proptable(objset_types);
  77         zprop_desc_t *pd;
  78
  79         pd = &prop_tbl[prop];
  80
  81         ASSERT(pd->pd_name == NULL || pd->pd_name == name);
  82         ASSERT(name != NULL);
  83         ASSERT(colname != NULL);
  84
  85         pd->pd_name = name;
  86         pd->pd_propnum = prop;
  87         pd->pd_proptype = type;
  88         pd->pd_numdefault = numdefault;
  89         pd->pd_strdefault = strdefault;
  90         pd->pd_attr = attr;
  91         pd->pd_types = objset_types;
  92         pd->pd_values = values;
  93         pd->pd_colname = colname;
  94         pd->pd_rightalign = rightalign;
  95         pd->pd_visible = visible;
  96         pd->pd_table = idx_tbl;
  97         pd->pd_table_size = 0;
  98         while (idx_tbl && (idx_tbl++)->pi_name != NULL)
  99                 pd->pd_table_size++;
 100 }
 101
 102 void
 103 zprop_register_string(int prop, const char *name, const char *def,
 104     zprop_attr_t attr, int objset_types, const char *values,
 105     const char *colname)
 106 {
 107         zprop_register_impl(prop, name, PROP_TYPE_STRING, 0, def, attr,
 108             objset_types, values, colname, B_FALSE, B_TRUE, NULL);
 109
 110 }
 111
 112 void
 113 zprop_register_number(int prop, const char *name, uint64_t def,
 114     zprop_attr_t attr, int objset_types, const char *values,
 115     const char *colname)
 116 {
 117         zprop_register_impl(prop, name, PROP_TYPE_NUMBER, def, NULL, attr,
 118             objset_types, values, colname, B_TRUE, B_TRUE, NULL);
 119 }
 120
 121 void
 122 zprop_register_index(int prop, const char *name, uint64_t def,
 123     zprop_attr_t attr, int objset_types, const char *values,
 124     const char *colname, const zprop_index_t *idx_tbl)
 125 {
 126         zprop_register_impl(prop, name, PROP_TYPE_INDEX, def, NULL, attr,
 127             objset_types, values, colname, B_TRUE, B_TRUE, idx_tbl);
 128 }
 129
 130 void
 131 zprop_register_hidden(int prop, const char *name, zprop_type_t type,
 132     zprop_attr_t attr, int objset_types, const char *colname)
 133 {
 134         zprop_register_impl(prop, name, type, 0, NULL, attr,
 135             objset_types, NULL, colname,
 136             type == PROP_TYPE_NUMBER, B_FALSE, NULL);
 137 }
 138
 139
 140 /*
 141  * A comparison function we can use to order indexes into property tables.
 142  */
 143 static int
 144 zprop_compare(const void *arg1, const void *arg2)
 145 {
 146         const zprop_desc_t *p1 = *((zprop_desc_t **)arg1);
 147         const zprop_desc_t *p2 = *((zprop_desc_t **)arg2);
 148         boolean_t p1ro, p2ro;
 149
 150         p1ro = (p1->pd_attr == PROP_READONLY);
 151         p2ro = (p2->pd_attr == PROP_READONLY);
 152
 153         if (p1ro == p2ro)
 154                 return (strcmp(p1->pd_name, p2->pd_name));
 155
 156         return (p1ro ? -1 : 1);
 157 }
 158
 159 /*
 160  * Iterate over all properties in the given property table, calling back
 161  * into the specified function for each property. We will continue to
 162  * iterate until we either reach the end or the callback function returns
 163  * something other than ZPROP_CONT.
 164  */
 165 int
 166 zprop_iter_common(zprop_func func, void *cb, boolean_t show_all,
 167     boolean_t ordered, zfs_type_t type)
 168 {
 169         int i, num_props, size, prop;
 170         zprop_desc_t *prop_tbl;
 171         zprop_desc_t **order;
 172
 173         prop_tbl = zprop_get_proptable(type);
 174         num_props = zprop_get_numprops(type);
 175         size = num_props * sizeof (zprop_desc_t *);
 176
 177 #if defined(_KERNEL)
 178         order = kmem_alloc(size, KM_SLEEP);
 179 #else
 180         if ((order = malloc(size)) == NULL)
 181                 return (ZPROP_CONT);
 182 #endif
 183
 184         for (int j = 0; j < num_props; j++)
 185                 order[j] = &prop_tbl[j];
 186
 187         if (ordered) {
 188                 qsort((void *)order, num_props, sizeof (zprop_desc_t *),
 189                     zprop_compare);
 190         }
 191
 192         prop = ZPROP_CONT;
 193         for (i = 0; i < num_props; i++) {
 194                 if ((order[i]->pd_visible || show_all) &&
 195                     (func(order[i]->pd_propnum, cb) != ZPROP_CONT)) {
 196                         prop = order[i]->pd_propnum;
 197                         break;
 198                 }
 199         }
 200
 201 #if defined(_KERNEL)
 202         kmem_free(order, size);
 203 #else
 204         free(order);
 205 #endif
 206         return (prop);
 207 }
 208
 209 static boolean_t
 210 propname_match(const char *p, size_t len, zprop_desc_t *prop_entry)
 211 {
 212         const char *propname = prop_entry->pd_name;
 213 #ifndef _KERNEL
 214         const char *colname = prop_entry->pd_colname;
 215         int c;
 216 #endif
 217
 218         if (len == strlen(propname) &&
 219             strncmp(p, propname, len) == 0)
 220                 return (B_TRUE);
 221
 222 #ifndef _KERNEL
 223         if (colname == NULL || len != strlen(colname))
 224                 return (B_FALSE);
 225
 226         for (c = 0; c < len; c++)
 227                 if (p[c] != tolower(colname[c]))
 228                         break;
 229
 230         return (colname[c] == '\0');
 231 #else
 232         return (B_FALSE);
 233 #endif
 234 }
 235
 236 typedef struct name_to_prop_cb {
 237         const char *propname;
 238         zprop_desc_t *prop_tbl;
 239 } name_to_prop_cb_t;
 240
 241 static int
 242 zprop_name_to_prop_cb(int prop, void *cb_data)
 243 {
 244         name_to_prop_cb_t *data = cb_data;
 245
 246         if (propname_match(data->propname, strlen(data->propname),
 247             &data->prop_tbl[prop]))
 248                 return (prop);
 249
 250         return (ZPROP_CONT);
 251 }
 252
 253 int
 254 zprop_name_to_prop(const char *propname, zfs_type_t type)
 255 {
 256         int prop;
 257         name_to_prop_cb_t cb_data;
 258
 259         cb_data.propname = propname;
 260         cb_data.prop_tbl = zprop_get_proptable(type);
 261
 262         prop = zprop_iter_common(zprop_name_to_prop_cb, &cb_data,
 263             B_TRUE, B_FALSE, type);
 264
 265         return (prop == ZPROP_CONT ? ZPROP_INVAL : prop);
 266 }
 267
 268 int
 269 zprop_string_to_index(int prop, const char *string, uint64_t *index,
 270     zfs_type_t type)
 271 {
 272         zprop_desc_t *prop_tbl;
 273         const zprop_index_t *idx_tbl;
 274         int i;
 275
 276         if (prop == ZPROP_INVAL || prop == ZPROP_CONT)
 277                 return (-1);
 278
 279         ASSERT(prop < zprop_get_numprops(type));
 280         prop_tbl = zprop_get_proptable(type);
 281         if ((idx_tbl = prop_tbl[prop].pd_table) == NULL)
 282                 return (-1);
 283
 284         for (i = 0; idx_tbl[i].pi_name != NULL; i++) {
 285                 if (strcmp(string, idx_tbl[i].pi_name) == 0) {
 286                         *index = idx_tbl[i].pi_value;
 287                         return (0);
 288                 }
 289         }
 290
 291         return (-1);
 292 }
 293
 294 int
 295 zprop_index_to_string(int prop, uint64_t index, const char **string,
 296     zfs_type_t type)
 297 {
 298         zprop_desc_t *prop_tbl;
 299         const zprop_index_t *idx_tbl;
 300         int i;
 301
 302         if (prop == ZPROP_INVAL || prop == ZPROP_CONT)
 303                 return (-1);
 304
 305         ASSERT(prop < zprop_get_numprops(type));
 306         prop_tbl = zprop_get_proptable(type);
 307         if ((idx_tbl = prop_tbl[prop].pd_table) == NULL)
 308                 return (-1);
 309
 310         for (i = 0; idx_tbl[i].pi_name != NULL; i++) {
 311                 if (idx_tbl[i].pi_value == index) {
 312                         *string = idx_tbl[i].pi_name;
 313                         return (0);
 314                 }
 315         }
 316
 317         return (-1);
 318 }
 319
 320 /*
 321  * Return a random valid property value.  Used by ztest.
 322  */
 323 uint64_t
 324 zprop_random_value(int prop, uint64_t seed, zfs_type_t type)
 325 {
 326         zprop_desc_t *prop_tbl;
 327         const zprop_index_t *idx_tbl;
 328
 329         ASSERT((uint_t)prop < zprop_get_numprops(type));
 330         prop_tbl = zprop_get_proptable(type);
 331         idx_tbl = prop_tbl[prop].pd_table;
 332
 333         if (idx_tbl == NULL)
 334                 return (seed);
 335
 336         return (idx_tbl[seed % prop_tbl[prop].pd_table_size].pi_value);
 337 }
 338
 339 const char *
 340 zprop_values(int prop, zfs_type_t type)
 341 {
 342         zprop_desc_t *prop_tbl;
 343
 344         ASSERT(prop != ZPROP_INVAL && prop != ZPROP_CONT);
 345         ASSERT(prop < zprop_get_numprops(type));
 346
 347         prop_tbl = zprop_get_proptable(type);
 348
 349         return (prop_tbl[prop].pd_values);
 350 }
 351
 352 /*
 353  * Returns TRUE if the property applies to any of the given dataset types.
 354  *
 355  * If headcheck is set, the check is being made against the head dataset
 356  * type of a snapshot which requires to return B_TRUE when the property
 357  * is only valid for snapshots.
 358  */
 359 boolean_t
 360 zprop_valid_for_type(int prop, zfs_type_t type, boolean_t headcheck)
 361 {
 362         zprop_desc_t *prop_tbl;
 363
 364         if (prop == ZPROP_INVAL || prop == ZPROP_CONT)
 365                 return (B_FALSE);
 366
 367         ASSERT(prop < zprop_get_numprops(type));
 368         prop_tbl = zprop_get_proptable(type);
 369         if (headcheck && prop_tbl[prop].pd_types == ZFS_TYPE_SNAPSHOT)
 370                 return (B_TRUE);
 371         return ((prop_tbl[prop].pd_types & type) != 0);
 372 }
 373
 374 #ifndef _KERNEL
 375
 376 /*
 377  * Determines the minimum width for the column, and indicates whether it's fixed
 378  * or not.  Only string columns are non-fixed.
 379  */
 380 size_t
 381 zprop_width(int prop, boolean_t *fixed, zfs_type_t type)
 382 {
 383         zprop_desc_t *prop_tbl, *pd;
 384         const zprop_index_t *idx;
 385         size_t ret;
 386         int i;
 387
 388         ASSERT(prop != ZPROP_INVAL && prop != ZPROP_CONT);
 389         ASSERT(prop < zprop_get_numprops(type));
 390
 391         prop_tbl = zprop_get_proptable(type);
 392         pd = &prop_tbl[prop];
 393
 394         *fixed = B_TRUE;
 395
 396         /*
 397          * Start with the width of the column name.
 398          */
 399         ret = strlen(pd->pd_colname);
 400
 401         /*
 402          * For fixed-width values, make sure the width is large enough to hold
 403          * any possible value.
 404          */
 405         switch (pd->pd_proptype) {
 406         case PROP_TYPE_NUMBER:
 407                 /*
 408                  * The maximum length of a human-readable number is 5 characters
 409                  * ("20.4M", for example).
 410                  */
 411                 if (ret < 5)
 412                         ret = 5;
 413                 /*
 414                  * 'creation' is handled specially because it's a number
 415                  * internally, but displayed as a date string.
 416                  */
 417                 if (prop == ZFS_PROP_CREATION)
 418                         *fixed = B_FALSE;
 419                 break;
 420         case PROP_TYPE_INDEX:
 421                 idx = prop_tbl[prop].pd_table;
 422                 for (i = 0; idx[i].pi_name != NULL; i++) {
 423                         if (strlen(idx[i].pi_name) > ret)
 424                                 ret = strlen(idx[i].pi_name);
 425                 }
 426                 break;
 427
 428         case PROP_TYPE_STRING:
 429                 *fixed = B_FALSE;
 430                 break;
 431         }
 432
 433         return (ret);
 434 }
 435
 436 #endif
 437
 438 #if defined(_KERNEL) && defined(HAVE_SPL)
 439 /* Common routines to initialize property tables */
 440 EXPORT_SYMBOL(zprop_register_impl);
 441 EXPORT_SYMBOL(zprop_register_string);
 442 EXPORT_SYMBOL(zprop_register_number);
 443 EXPORT_SYMBOL(zprop_register_index);
 444 EXPORT_SYMBOL(zprop_register_hidden);
 445
 446 /* Common routines for zfs and zpool property management */
 447 EXPORT_SYMBOL(zprop_iter_common);
 448 EXPORT_SYMBOL(zprop_name_to_prop);
 449 EXPORT_SYMBOL(zprop_string_to_index);
 450 EXPORT_SYMBOL(zprop_index_to_string);
 451 EXPORT_SYMBOL(zprop_random_value);
 452 EXPORT_SYMBOL(zprop_values);
 453 EXPORT_SYMBOL(zprop_valid_for_type);
 454 #endif