module/os/linux/zfs/zfs_sysfs.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 (c) 2018, 2019 by Delphix. All rights reserved.
  23  */
  24
  25 #include <sys/types.h>
  26 #include <sys/param.h>
  27 #include <sys/zfeature.h>
  28 #include <sys/zfs_ioctl.h>
  29 #include <sys/zfs_sysfs.h>
  30 #include <sys/kmem.h>
  31 #include <sys/fs/zfs.h>
  32 #include <linux/kobject.h>
  33
  34 #include "zfs_prop.h"
  35
  36 #if !defined(_KERNEL)
  37 #error kernel builds only
  38 #endif
  39
  40 /*
  41  * ZFS Module sysfs support
  42  *
  43  * This extends our sysfs '/sys/module/zfs' entry to include feature
  44  * and property attributes. The primary consumer of this information
  45  * is user processes, like the zfs CLI, that need to know what the
  46  * current loaded ZFS module supports. The libzfs binary will consult
  47  * this information when instantiating the zfs|zpool property tables
  48  * and the pool features table.
  49  *
  50  * The added top-level directories are:
  51  * /sys/module/zfs
  52  *              ├── features.kernel
  53  *              ├── features.pool
  54  *              ├── properties.dataset
  55  *              └── properties.pool
  56  *
  57  * The local interface for the zfs kobjects includes:
  58  *      zfs_kobj_init()
  59  *      zfs_kobj_add()
  60  *      zfs_kobj_release()
  61  *      zfs_kobj_add_attr()
  62  *      zfs_kobj_fini()
  63  */
  64
  65 /*
  66  * A zfs_mod_kobj_t represents a zfs kobject under '/sys/module/zfs'
  67  */
  68 typedef struct zfs_mod_kobj zfs_mod_kobj_t;
  69 struct zfs_mod_kobj {
  70         struct kobject          zko_kobj;
  71         struct kobj_type        zko_kobj_type;
  72         struct sysfs_ops        zko_sysfs_ops;
  73         size_t                  zko_attr_count;
  74         struct attribute        *zko_attr_list;         /* allocated */
  75         struct attribute_group  zko_default_group;      /* .attrs allocated */
  76         const struct attribute_group    *zko_default_groups[2];
  77         size_t                  zko_child_count;
  78         zfs_mod_kobj_t          *zko_children;          /* allocated */
  79 };
  80
  81 #define ATTR_TABLE_SIZE(cnt)    (sizeof (struct attribute) * (cnt))
  82 /* Note +1 for NULL terminator slot */
  83 #define DEFAULT_ATTR_SIZE(cnt)  (sizeof (struct attribute *) * (cnt + 1))
  84 #define CHILD_TABLE_SIZE(cnt)   (sizeof (zfs_mod_kobj_t) * (cnt))
  85
  86 /*
  87  * These are the top-level kobjects under '/sys/module/zfs/'
  88  */
  89 static zfs_mod_kobj_t kernel_features_kobj;
  90 static zfs_mod_kobj_t pool_features_kobj;
  91 static zfs_mod_kobj_t dataset_props_kobj;
  92 static zfs_mod_kobj_t vdev_props_kobj;
  93 static zfs_mod_kobj_t pool_props_kobj;
  94
  95 /*
  96  * The show function is used to provide the content
  97  * of an attribute into a PAGE_SIZE buffer.
  98  */
  99 typedef ssize_t (*sysfs_show_func)(struct kobject *, struct attribute *,
 100     char *);
 101
 102 static void
 103 zfs_kobj_fini(zfs_mod_kobj_t *zkobj)
 104 {
 105         /* finalize any child kobjects */
 106         if (zkobj->zko_child_count != 0) {
 107                 ASSERT(zkobj->zko_children);
 108                 for (int i = 0; i < zkobj->zko_child_count; i++)
 109                         zfs_kobj_fini(&zkobj->zko_children[i]);
 110         }
 111
 112         /* kobject_put() will call zfs_kobj_release() to release memory */
 113         kobject_del(&zkobj->zko_kobj);
 114         kobject_put(&zkobj->zko_kobj);
 115 }
 116
 117 static void
 118 zfs_kobj_release(struct kobject *kobj)
 119 {
 120         zfs_mod_kobj_t *zkobj = container_of(kobj, zfs_mod_kobj_t, zko_kobj);
 121
 122         if (zkobj->zko_attr_list != NULL) {
 123                 ASSERT3S(zkobj->zko_attr_count, !=, 0);
 124                 kmem_free(zkobj->zko_attr_list,
 125                     ATTR_TABLE_SIZE(zkobj->zko_attr_count));
 126                 zkobj->zko_attr_list = NULL;
 127         }
 128
 129         if (zkobj->zko_default_group.attrs != NULL) {
 130                 kmem_free(zkobj->zko_default_group.attrs,
 131                     DEFAULT_ATTR_SIZE(zkobj->zko_attr_count));
 132                 zkobj->zko_default_group.attrs = NULL;
 133         }
 134
 135         if (zkobj->zko_child_count != 0) {
 136                 ASSERT(zkobj->zko_children);
 137
 138                 kmem_free(zkobj->zko_children,
 139                     CHILD_TABLE_SIZE(zkobj->zko_child_count));
 140                 zkobj->zko_child_count = 0;
 141                 zkobj->zko_children = NULL;
 142         }
 143
 144         zkobj->zko_attr_count = 0;
 145 }
 146
 147 #ifndef sysfs_attr_init
 148 #define sysfs_attr_init(attr) do {} while (0)
 149 #endif
 150
 151 static void
 152 zfs_kobj_add_attr(zfs_mod_kobj_t *zkobj, int attr_num, const char *attr_name)
 153 {
 154         VERIFY3U(attr_num, <, zkobj->zko_attr_count);
 155         ASSERT(zkobj->zko_attr_list);
 156         ASSERT(zkobj->zko_default_group.attrs);
 157
 158         zkobj->zko_attr_list[attr_num].name = attr_name;
 159         zkobj->zko_attr_list[attr_num].mode = 0444;
 160         zkobj->zko_default_group.attrs[attr_num] =
 161             &zkobj->zko_attr_list[attr_num];
 162         sysfs_attr_init(&zkobj->zko_attr_list[attr_num]);
 163 }
 164
 165 static int
 166 zfs_kobj_init(zfs_mod_kobj_t *zkobj, int attr_cnt, int child_cnt,
 167     sysfs_show_func show_func)
 168 {
 169         /*
 170          * Initialize object's attributes. Count can be zero.
 171          */
 172         if (attr_cnt > 0) {
 173                 zkobj->zko_attr_list = kmem_zalloc(ATTR_TABLE_SIZE(attr_cnt),
 174                     KM_SLEEP);
 175                 if (zkobj->zko_attr_list == NULL)
 176                         return (ENOMEM);
 177         }
 178         /* this will always have at least one slot for NULL termination */
 179         zkobj->zko_default_group.attrs =
 180             kmem_zalloc(DEFAULT_ATTR_SIZE(attr_cnt), KM_SLEEP);
 181         if (zkobj->zko_default_group.attrs == NULL) {
 182                 if (zkobj->zko_attr_list != NULL) {
 183                         kmem_free(zkobj->zko_attr_list,
 184                             ATTR_TABLE_SIZE(attr_cnt));
 185                 }
 186                 return (ENOMEM);
 187         }
 188         zkobj->zko_attr_count = attr_cnt;
 189         zkobj->zko_default_groups[0] = &zkobj->zko_default_group;
 190 #ifdef HAVE_SYSFS_DEFAULT_GROUPS
 191         zkobj->zko_kobj_type.default_groups = zkobj->zko_default_groups;
 192 #else
 193         zkobj->zko_kobj_type.default_attrs = zkobj->zko_default_group.attrs;
 194 #endif
 195
 196         if (child_cnt > 0) {
 197                 zkobj->zko_children = kmem_zalloc(CHILD_TABLE_SIZE(child_cnt),
 198                     KM_SLEEP);
 199                 if (zkobj->zko_children == NULL) {
 200                         if (zkobj->zko_default_group.attrs != NULL) {
 201                                 kmem_free(zkobj->zko_default_group.attrs,
 202                                     DEFAULT_ATTR_SIZE(attr_cnt));
 203                         }
 204                         if (zkobj->zko_attr_list != NULL) {
 205                                 kmem_free(zkobj->zko_attr_list,
 206                                     ATTR_TABLE_SIZE(attr_cnt));
 207                         }
 208                         return (ENOMEM);
 209                 }
 210                 zkobj->zko_child_count = child_cnt;
 211         }
 212
 213         zkobj->zko_sysfs_ops.show = show_func;
 214         zkobj->zko_kobj_type.sysfs_ops = &zkobj->zko_sysfs_ops;
 215         zkobj->zko_kobj_type.release = zfs_kobj_release;
 216
 217         return (0);
 218 }
 219
 220 static int
 221 zfs_kobj_add(zfs_mod_kobj_t *zkobj, struct kobject *parent, const char *name)
 222 {
 223         /* zko_default_group.attrs must be NULL terminated */
 224         ASSERT(zkobj->zko_default_group.attrs != NULL);
 225         ASSERT(zkobj->zko_default_group.attrs[zkobj->zko_attr_count] == NULL);
 226
 227         kobject_init(&zkobj->zko_kobj, &zkobj->zko_kobj_type);
 228         return (kobject_add(&zkobj->zko_kobj, parent, name));
 229 }
 230
 231 /*
 232  * Each zfs property has these common attributes
 233  */
 234 static const char *const zprop_attrs[]  = {
 235         "type",
 236         "readonly",
 237         "setonce",
 238         "visible",
 239         "values",
 240         "default",
 241         "datasets"      /* zfs properties only */
 242 };
 243
 244 #define ZFS_PROP_ATTR_COUNT     ARRAY_SIZE(zprop_attrs)
 245 #define ZPOOL_PROP_ATTR_COUNT   (ZFS_PROP_ATTR_COUNT - 1)
 246
 247 static const char *const zprop_types[]  = {
 248         "number",
 249         "string",
 250         "index",
 251 };
 252
 253 typedef struct zfs_type_map {
 254         zfs_type_t      ztm_type;
 255         const char      *ztm_name;
 256 } zfs_type_map_t;
 257
 258 static const zfs_type_map_t type_map[] = {
 259         {ZFS_TYPE_FILESYSTEM,   "filesystem"},
 260         {ZFS_TYPE_SNAPSHOT,     "snapshot"},
 261         {ZFS_TYPE_VOLUME,       "volume"},
 262         {ZFS_TYPE_BOOKMARK,     "bookmark"}
 263 };
 264
 265 /*
 266  * Show the content for a zfs property attribute
 267  */
 268 static ssize_t
 269 zprop_sysfs_show(const char *attr_name, const zprop_desc_t *property,
 270     char *buf, size_t buflen)
 271 {
 272         const char *show_str;
 273         char number[32];
 274
 275         /* For dataset properties list the dataset types that apply */
 276         if (strcmp(attr_name, "datasets") == 0 &&
 277             property->pd_types != ZFS_TYPE_POOL) {
 278                 int len = 0;
 279
 280                 for (int i = 0; i < ARRAY_SIZE(type_map); i++) {
 281                         if (type_map[i].ztm_type & property->pd_types)  {
 282                                 len += snprintf(buf + len, buflen - len, "%s ",
 283                                     type_map[i].ztm_name);
 284                         }
 285                 }
 286                 len += snprintf(buf + len, buflen - len, "\n");
 287                 return (len);
 288         }
 289
 290         if (strcmp(attr_name, "type") == 0) {
 291                 show_str = zprop_types[property->pd_proptype];
 292         } else if (strcmp(attr_name, "readonly") == 0) {
 293                 show_str = property->pd_attr == PROP_READONLY ? "1" : "0";
 294         } else if (strcmp(attr_name, "setonce") == 0) {
 295                 show_str = property->pd_attr == PROP_ONETIME ? "1" : "0";
 296         } else if (strcmp(attr_name, "visible") == 0) {
 297                 show_str = property->pd_visible ? "1" : "0";
 298         } else if (strcmp(attr_name, "values") == 0) {
 299                 show_str = property->pd_values ? property->pd_values : "";
 300         } else if (strcmp(attr_name, "default") == 0) {
 301                 switch (property->pd_proptype) {
 302                 case PROP_TYPE_NUMBER:
 303                         (void) snprintf(number, sizeof (number), "%llu",
 304                             (u_longlong_t)property->pd_numdefault);
 305                         show_str = number;
 306                         break;
 307                 case PROP_TYPE_STRING:
 308                         show_str = property->pd_strdefault ?
 309                             property->pd_strdefault : "";
 310                         break;
 311                 case PROP_TYPE_INDEX:
 312                         if (zprop_index_to_string(property->pd_propnum,
 313                             property->pd_numdefault, &show_str,
 314                             property->pd_types) != 0) {
 315                                 show_str = "";
 316                         }
 317                         break;
 318                 default:
 319                         return (0);
 320                 }
 321         } else {
 322                 return (0);
 323         }
 324
 325         return (snprintf(buf, buflen, "%s\n", show_str));
 326 }
 327
 328 static ssize_t
 329 dataset_property_show(struct kobject *kobj, struct attribute *attr, char *buf)
 330 {
 331         zfs_prop_t prop = zfs_name_to_prop(kobject_name(kobj));
 332         zprop_desc_t *prop_tbl = zfs_prop_get_table();
 333         ssize_t len;
 334
 335         ASSERT3U(prop, <, ZFS_NUM_PROPS);
 336
 337         len = zprop_sysfs_show(attr->name, &prop_tbl[prop], buf, PAGE_SIZE);
 338
 339         return (len);
 340 }
 341
 342 static ssize_t
 343 vdev_property_show(struct kobject *kobj, struct attribute *attr, char *buf)
 344 {
 345         vdev_prop_t prop = vdev_name_to_prop(kobject_name(kobj));
 346         zprop_desc_t *prop_tbl = vdev_prop_get_table();
 347         ssize_t len;
 348
 349         ASSERT3U(prop, <, VDEV_NUM_PROPS);
 350
 351         len = zprop_sysfs_show(attr->name, &prop_tbl[prop], buf, PAGE_SIZE);
 352
 353         return (len);
 354 }
 355
 356 static ssize_t
 357 pool_property_show(struct kobject *kobj, struct attribute *attr, char *buf)
 358 {
 359         zpool_prop_t prop = zpool_name_to_prop(kobject_name(kobj));
 360         zprop_desc_t *prop_tbl = zpool_prop_get_table();
 361         ssize_t len;
 362
 363         ASSERT3U(prop, <, ZPOOL_NUM_PROPS);
 364
 365         len = zprop_sysfs_show(attr->name, &prop_tbl[prop], buf, PAGE_SIZE);
 366
 367         return (len);
 368 }
 369
 370 /*
 371  * ZFS kernel feature attributes for '/sys/module/zfs/features.kernel'
 372  *
 373  * This list is intended for kernel features that don't have a pool feature
 374  * association or that extend existing user kernel interfaces.
 375  *
 376  * A user process can easily check if the running zfs kernel module
 377  * supports the new feature.
 378  */
 379 static const char *const zfs_kernel_features[] = {
 380         /* --> Add new kernel features here */
 381         "com.delphix:vdev_initialize",
 382         "org.zfsonlinux:vdev_trim",
 383         "org.openzfs:l2arc_persistent",
 384 };
 385
 386 #define KERNEL_FEATURE_COUNT    ARRAY_SIZE(zfs_kernel_features)
 387
 388 static ssize_t
 389 kernel_feature_show(struct kobject *kobj, struct attribute *attr, char *buf)
 390 {
 391         if (strcmp(attr->name, "supported") == 0)
 392                 return (snprintf(buf, PAGE_SIZE, "yes\n"));
 393         return (0);
 394 }
 395
 396 static void
 397 kernel_feature_to_kobj(zfs_mod_kobj_t *parent, int slot, const char *name)
 398 {
 399         zfs_mod_kobj_t *zfs_kobj = &parent->zko_children[slot];
 400
 401         ASSERT3U(slot, <, KERNEL_FEATURE_COUNT);
 402         ASSERT(name);
 403
 404         int err = zfs_kobj_init(zfs_kobj, 1, 0, kernel_feature_show);
 405         if (err)
 406                 return;
 407
 408         zfs_kobj_add_attr(zfs_kobj, 0, "supported");
 409
 410         err = zfs_kobj_add(zfs_kobj, &parent->zko_kobj, name);
 411         if (err)
 412                 zfs_kobj_release(&zfs_kobj->zko_kobj);
 413 }
 414
 415 static int
 416 zfs_kernel_features_init(zfs_mod_kobj_t *zfs_kobj, struct kobject *parent)
 417 {
 418         /*
 419          * Create a parent kobject to host kernel features.
 420          *
 421          * '/sys/module/zfs/features.kernel'
 422          */
 423         int err = zfs_kobj_init(zfs_kobj, 0, KERNEL_FEATURE_COUNT,
 424             kernel_feature_show);
 425         if (err)
 426                 return (err);
 427         err = zfs_kobj_add(zfs_kobj, parent, ZFS_SYSFS_KERNEL_FEATURES);
 428         if (err) {
 429                 zfs_kobj_release(&zfs_kobj->zko_kobj);
 430                 return (err);
 431         }
 432
 433         /*
 434          * Now create a kobject for each feature.
 435          *
 436          * '/sys/module/zfs/features.kernel/<feature>'
 437          */
 438         for (int f = 0; f < KERNEL_FEATURE_COUNT; f++)
 439                 kernel_feature_to_kobj(zfs_kobj, f, zfs_kernel_features[f]);
 440
 441         return (0);
 442 }
 443
 444 /*
 445  * Each pool feature has these common attributes
 446  */
 447 static const char *const pool_feature_attrs[]  = {
 448         "description",
 449         "guid",
 450         "uname",
 451         "readonly_compatible",
 452         "required_for_mos",
 453         "activate_on_enable",
 454         "per_dataset"
 455 };
 456
 457 #define ZPOOL_FEATURE_ATTR_COUNT        ARRAY_SIZE(pool_feature_attrs)
 458
 459 /*
 460  * Show the content for the given zfs pool feature attribute
 461  */
 462 static ssize_t
 463 pool_feature_show(struct kobject *kobj, struct attribute *attr, char *buf)
 464 {
 465         spa_feature_t fid;
 466
 467         if (zfeature_lookup_guid(kobject_name(kobj), &fid) != 0)
 468                 return (0);
 469
 470         ASSERT3U(fid, <, SPA_FEATURES);
 471
 472         zfeature_flags_t flags = spa_feature_table[fid].fi_flags;
 473         const char *show_str = NULL;
 474
 475         if (strcmp(attr->name, "description") == 0) {
 476                 show_str = spa_feature_table[fid].fi_desc;
 477         } else if (strcmp(attr->name, "guid") == 0) {
 478                 show_str = spa_feature_table[fid].fi_guid;
 479         } else if (strcmp(attr->name, "uname") == 0) {
 480                 show_str = spa_feature_table[fid].fi_uname;
 481         } else if (strcmp(attr->name, "readonly_compatible") == 0) {
 482                 show_str = flags & ZFEATURE_FLAG_READONLY_COMPAT ? "1" : "0";
 483         } else if (strcmp(attr->name, "required_for_mos") == 0) {
 484                 show_str = flags & ZFEATURE_FLAG_MOS ? "1" : "0";
 485         } else if (strcmp(attr->name, "activate_on_enable") == 0) {
 486                 show_str = flags & ZFEATURE_FLAG_ACTIVATE_ON_ENABLE ? "1" : "0";
 487         } else if (strcmp(attr->name, "per_dataset") == 0) {
 488                 show_str = flags & ZFEATURE_FLAG_PER_DATASET ? "1" : "0";
 489         }
 490         if (show_str == NULL)
 491                 return (0);
 492
 493         return (snprintf(buf, PAGE_SIZE, "%s\n", show_str));
 494 }
 495
 496 static void
 497 pool_feature_to_kobj(zfs_mod_kobj_t *parent, spa_feature_t fid,
 498     const char *name)
 499 {
 500         zfs_mod_kobj_t *zfs_kobj = &parent->zko_children[fid];
 501
 502         ASSERT3U(fid, <, SPA_FEATURES);
 503         ASSERT(name);
 504
 505         int err = zfs_kobj_init(zfs_kobj, ZPOOL_FEATURE_ATTR_COUNT, 0,
 506             pool_feature_show);
 507         if (err)
 508                 return;
 509
 510         for (int i = 0; i < ZPOOL_FEATURE_ATTR_COUNT; i++)
 511                 zfs_kobj_add_attr(zfs_kobj, i, pool_feature_attrs[i]);
 512
 513         err = zfs_kobj_add(zfs_kobj, &parent->zko_kobj, name);
 514         if (err)
 515                 zfs_kobj_release(&zfs_kobj->zko_kobj);
 516 }
 517
 518 static int
 519 zfs_pool_features_init(zfs_mod_kobj_t *zfs_kobj, struct kobject *parent)
 520 {
 521         /*
 522          * Create a parent kobject to host pool features.
 523          *
 524          * '/sys/module/zfs/features.pool'
 525          */
 526         int err = zfs_kobj_init(zfs_kobj, 0, SPA_FEATURES, pool_feature_show);
 527         if (err)
 528                 return (err);
 529         err = zfs_kobj_add(zfs_kobj, parent, ZFS_SYSFS_POOL_FEATURES);
 530         if (err) {
 531                 zfs_kobj_release(&zfs_kobj->zko_kobj);
 532                 return (err);
 533         }
 534
 535         /*
 536          * Now create a kobject for each feature.
 537          *
 538          * '/sys/module/zfs/features.pool/<feature>'
 539          */
 540         for (spa_feature_t i = 0; i < SPA_FEATURES; i++)
 541                 pool_feature_to_kobj(zfs_kobj, i, spa_feature_table[i].fi_guid);
 542
 543         return (0);
 544 }
 545
 546 typedef struct prop_to_kobj_arg {
 547         zprop_desc_t    *p2k_table;
 548         zfs_mod_kobj_t  *p2k_parent;
 549         sysfs_show_func p2k_show_func;
 550         int             p2k_attr_count;
 551 } prop_to_kobj_arg_t;
 552
 553 static int
 554 zprop_to_kobj(int prop, void *args)
 555 {
 556         prop_to_kobj_arg_t *data = args;
 557         zfs_mod_kobj_t *parent = data->p2k_parent;
 558         zfs_mod_kobj_t *zfs_kobj = &parent->zko_children[prop];
 559         const char *name = data->p2k_table[prop].pd_name;
 560         int err;
 561
 562         ASSERT(name);
 563
 564         err = zfs_kobj_init(zfs_kobj, data->p2k_attr_count, 0,
 565             data->p2k_show_func);
 566         if (err)
 567                 return (ZPROP_CONT);
 568
 569         for (int i = 0; i < data->p2k_attr_count; i++)
 570                 zfs_kobj_add_attr(zfs_kobj, i, zprop_attrs[i]);
 571
 572         err = zfs_kobj_add(zfs_kobj, &parent->zko_kobj, name);
 573         if (err)
 574                 zfs_kobj_release(&zfs_kobj->zko_kobj);
 575
 576         return (ZPROP_CONT);
 577 }
 578
 579 static int
 580 zfs_sysfs_properties_init(zfs_mod_kobj_t *zfs_kobj, struct kobject *parent,
 581     zfs_type_t type)
 582 {
 583         prop_to_kobj_arg_t context;
 584         const char *name;
 585         int err;
 586
 587         /*
 588          * Create a parent kobject to host properties.
 589          *
 590          * '/sys/module/zfs/properties.<type>'
 591          */
 592         if (type == ZFS_TYPE_POOL) {
 593                 name = ZFS_SYSFS_POOL_PROPERTIES;
 594                 context.p2k_table = zpool_prop_get_table();
 595                 context.p2k_attr_count = ZPOOL_PROP_ATTR_COUNT;
 596                 context.p2k_parent = zfs_kobj;
 597                 context.p2k_show_func = pool_property_show;
 598                 err = zfs_kobj_init(zfs_kobj, 0, ZPOOL_NUM_PROPS,
 599                     pool_property_show);
 600         } else if (type == ZFS_TYPE_VDEV) {
 601                 name = ZFS_SYSFS_VDEV_PROPERTIES;
 602                 context.p2k_table = vdev_prop_get_table();
 603                 context.p2k_attr_count = ZPOOL_PROP_ATTR_COUNT;
 604                 context.p2k_parent = zfs_kobj;
 605                 context.p2k_show_func = vdev_property_show;
 606                 err = zfs_kobj_init(zfs_kobj, 0, VDEV_NUM_PROPS,
 607                     vdev_property_show);
 608         } else {
 609                 name = ZFS_SYSFS_DATASET_PROPERTIES;
 610                 context.p2k_table = zfs_prop_get_table();
 611                 context.p2k_attr_count = ZFS_PROP_ATTR_COUNT;
 612                 context.p2k_parent = zfs_kobj;
 613                 context.p2k_show_func = dataset_property_show;
 614                 err = zfs_kobj_init(zfs_kobj, 0, ZFS_NUM_PROPS,
 615                     dataset_property_show);
 616         }
 617
 618         if (err)
 619                 return (err);
 620
 621         err = zfs_kobj_add(zfs_kobj, parent, name);
 622         if (err) {
 623                 zfs_kobj_release(&zfs_kobj->zko_kobj);
 624                 return (err);
 625         }
 626
 627         /*
 628          * Create a kobject for each property.
 629          *
 630          * '/sys/module/zfs/properties.<type>/<property>'
 631          */
 632         (void) zprop_iter_common(zprop_to_kobj, &context, B_TRUE,
 633             B_FALSE, type);
 634
 635         return (err);
 636 }
 637
 638 void
 639 zfs_sysfs_init(void)
 640 {
 641         struct kobject *parent;
 642 #if defined(CONFIG_ZFS) && !defined(CONFIG_ZFS_MODULE)
 643         parent = kobject_create_and_add("zfs", fs_kobj);
 644 #else
 645         parent = &(((struct module *)(THIS_MODULE))->mkobj).kobj;
 646 #endif
 647         int err;
 648
 649         if (parent == NULL)
 650                 return;
 651
 652         err = zfs_kernel_features_init(&kernel_features_kobj, parent);
 653         if (err)
 654                 return;
 655
 656         err = zfs_pool_features_init(&pool_features_kobj, parent);
 657         if (err) {
 658                 zfs_kobj_fini(&kernel_features_kobj);
 659                 return;
 660         }
 661
 662         err = zfs_sysfs_properties_init(&pool_props_kobj, parent,
 663             ZFS_TYPE_POOL);
 664         if (err) {
 665                 zfs_kobj_fini(&kernel_features_kobj);
 666                 zfs_kobj_fini(&pool_features_kobj);
 667                 return;
 668         }
 669
 670         err = zfs_sysfs_properties_init(&vdev_props_kobj, parent,
 671             ZFS_TYPE_VDEV);
 672         if (err) {
 673                 zfs_kobj_fini(&kernel_features_kobj);
 674                 zfs_kobj_fini(&pool_features_kobj);
 675                 zfs_kobj_fini(&pool_props_kobj);
 676                 return;
 677         }
 678
 679         err = zfs_sysfs_properties_init(&dataset_props_kobj, parent,
 680             ZFS_TYPE_FILESYSTEM);
 681         if (err) {
 682                 zfs_kobj_fini(&kernel_features_kobj);
 683                 zfs_kobj_fini(&pool_features_kobj);
 684                 zfs_kobj_fini(&pool_props_kobj);
 685                 zfs_kobj_fini(&vdev_props_kobj);
 686                 return;
 687         }
 688 }
 689
 690 void
 691 zfs_sysfs_fini(void)
 692 {
 693         /*
 694          * Remove top-level kobjects; each will remove any children kobjects
 695          */
 696         zfs_kobj_fini(&kernel_features_kobj);
 697         zfs_kobj_fini(&pool_features_kobj);
 698         zfs_kobj_fini(&pool_props_kobj);
 699         zfs_kobj_fini(&vdev_props_kobj);
 700         zfs_kobj_fini(&dataset_props_kobj);
 701 }