7a23c81342
When zfs_kobj_init() is called with an attr_cnt of 0 only the kobj->zko_default_attrs is allocated. It subsequently won't get freed in zfs_kobj_release since the free is wrapped in a kobj->zko_attr_count != 0 conditional. Split the block in zfs_kobj_release() to make sure the kobj->zko_default_attrs are freed in this case. Additionally, fix a minor spelling mistake and typo in zfs_kobj_init() which could also cause a leak but in practice is almost certain not to fail. Reviewed-by: Richard Elling <Richard.Elling@RichardElling.com> Reviewed-by: Tim Chase <tim@chase2k.com> Reviewed-by: John Gallagher <john.gallagher@delphix.com> Reviewed-by: Don Brady <don.brady@delphix.com> Reviewed-by: George Melikov <mail@gmelikov.ru> Signed-off-by: Brian Behlendorf <behlendorf1@llnl.gov> Closes #7957
630 lines
16 KiB
C
630 lines
16 KiB
C
/*
|
|
* CDDL HEADER START
|
|
*
|
|
* The contents of this file are subject to the terms of the
|
|
* Common Development and Distribution License (the "License").
|
|
* You may not use this file except in compliance with the License.
|
|
*
|
|
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
|
|
* or http://www.opensolaris.org/os/licensing.
|
|
* See the License for the specific language governing permissions
|
|
* and limitations under the License.
|
|
*
|
|
* When distributing Covered Code, include this CDDL HEADER in each
|
|
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
|
|
* If applicable, add the following below this CDDL HEADER, with the
|
|
* fields enclosed by brackets "[]" replaced with your own identifying
|
|
* information: Portions Copyright [yyyy] [name of copyright owner]
|
|
*
|
|
* CDDL HEADER END
|
|
*/
|
|
/*
|
|
* Copyright (c) 2018 by Delphix. All rights reserved.
|
|
*/
|
|
|
|
#include <sys/types.h>
|
|
#include <sys/param.h>
|
|
#include <sys/zfeature.h>
|
|
#include <sys/zfs_ioctl.h>
|
|
#include <sys/zfs_sysfs.h>
|
|
#include <sys/kmem.h>
|
|
#include <sys/fs/zfs.h>
|
|
#include <linux/kobject.h>
|
|
|
|
#include "zfs_prop.h"
|
|
|
|
#if !defined(_KERNEL)
|
|
#error kernel builds only
|
|
#endif
|
|
|
|
/*
|
|
* ZFS Module sysfs support
|
|
*
|
|
* This extends our sysfs '/sys/module/zfs' entry to include feature
|
|
* and property attributes. The primary consumer of this information
|
|
* is user processes, like the zfs CLI, that need to know what the
|
|
* current loaded ZFS module supports. The libzfs binary will consult
|
|
* this information when instantiating the zfs|zpool property tables
|
|
* and the pool features table.
|
|
*
|
|
* The added top-level directories are:
|
|
* /sys/module/zfs
|
|
* ├── features.kernel
|
|
* ├── features.pool
|
|
* ├── properties.dataset
|
|
* └── properties.pool
|
|
*
|
|
* The local interface for the zfs kobjects includes:
|
|
* zfs_kobj_init()
|
|
* zfs_kobj_add()
|
|
* zfs_kobj_release()
|
|
* zfs_kobj_add_attr()
|
|
* zfs_kobj_fini()
|
|
*/
|
|
|
|
/*
|
|
* A zfs_mod_kobj_t represents a zfs kobject under '/sys/module/zfs'
|
|
*/
|
|
struct zfs_mod_kobj;
|
|
typedef struct zfs_mod_kobj zfs_mod_kobj_t;
|
|
|
|
struct zfs_mod_kobj {
|
|
struct kobject zko_kobj;
|
|
struct kobj_type zko_kobj_type;
|
|
struct sysfs_ops zko_sysfs_ops;
|
|
size_t zko_attr_count;
|
|
struct attribute *zko_attr_list; /* allocated */
|
|
struct attribute **zko_default_attrs; /* allocated */
|
|
size_t zko_child_count;
|
|
zfs_mod_kobj_t *zko_children; /* allocated */
|
|
};
|
|
|
|
#define ATTR_TABLE_SIZE(cnt) (sizeof (struct attribute) * (cnt))
|
|
/* Note +1 for NULL terminator slot */
|
|
#define DEFAULT_ATTR_SIZE(cnt) (sizeof (struct attribute *) * (cnt + 1))
|
|
#define CHILD_TABLE_SIZE(cnt) (sizeof (zfs_mod_kobj_t) * (cnt))
|
|
|
|
/*
|
|
* These are the top-level kobjects under '/sys/module/zfs/'
|
|
*/
|
|
static zfs_mod_kobj_t kernel_features_kobj;
|
|
static zfs_mod_kobj_t pool_features_kobj;
|
|
static zfs_mod_kobj_t dataset_props_kobj;
|
|
static zfs_mod_kobj_t pool_props_kobj;
|
|
|
|
/*
|
|
* The show function is used to provide the content
|
|
* of an attribute into a PAGE_SIZE buffer.
|
|
*/
|
|
typedef ssize_t (*sysfs_show_func)(struct kobject *, struct attribute *,
|
|
char *);
|
|
|
|
static void
|
|
zfs_kobj_fini(zfs_mod_kobj_t *zkobj)
|
|
{
|
|
/* finalize any child kobjects */
|
|
if (zkobj->zko_child_count != 0) {
|
|
ASSERT(zkobj->zko_children);
|
|
for (int i = 0; i < zkobj->zko_child_count; i++)
|
|
zfs_kobj_fini(&zkobj->zko_children[i]);
|
|
}
|
|
|
|
/* kobject_put() will call zfs_kobj_release() to release memory */
|
|
kobject_del(&zkobj->zko_kobj);
|
|
kobject_put(&zkobj->zko_kobj);
|
|
}
|
|
|
|
static void
|
|
zfs_kobj_release(struct kobject *kobj)
|
|
{
|
|
zfs_mod_kobj_t *zkobj = container_of(kobj, zfs_mod_kobj_t, zko_kobj);
|
|
|
|
if (zkobj->zko_attr_list != NULL) {
|
|
ASSERT3S(zkobj->zko_attr_count, !=, 0);
|
|
kmem_free(zkobj->zko_attr_list,
|
|
ATTR_TABLE_SIZE(zkobj->zko_attr_count));
|
|
zkobj->zko_attr_list = NULL;
|
|
}
|
|
|
|
if (zkobj->zko_default_attrs != NULL) {
|
|
kmem_free(zkobj->zko_default_attrs,
|
|
DEFAULT_ATTR_SIZE(zkobj->zko_attr_count));
|
|
zkobj->zko_default_attrs = NULL;
|
|
}
|
|
|
|
if (zkobj->zko_child_count != 0) {
|
|
ASSERT(zkobj->zko_children);
|
|
|
|
kmem_free(zkobj->zko_children,
|
|
CHILD_TABLE_SIZE(zkobj->zko_child_count));
|
|
zkobj->zko_child_count = 0;
|
|
zkobj->zko_children = NULL;
|
|
}
|
|
|
|
zkobj->zko_attr_count = 0;
|
|
}
|
|
|
|
static void
|
|
zfs_kobj_add_attr(zfs_mod_kobj_t *zkobj, int attr_num, const char *attr_name)
|
|
{
|
|
VERIFY3U(attr_num, <, zkobj->zko_attr_count);
|
|
ASSERT(zkobj->zko_attr_list);
|
|
ASSERT(zkobj->zko_default_attrs);
|
|
|
|
zkobj->zko_attr_list[attr_num].name = attr_name;
|
|
zkobj->zko_attr_list[attr_num].mode = 0444;
|
|
zkobj->zko_default_attrs[attr_num] = &zkobj->zko_attr_list[attr_num];
|
|
}
|
|
|
|
static int
|
|
zfs_kobj_init(zfs_mod_kobj_t *zkobj, int attr_cnt, int child_cnt,
|
|
sysfs_show_func show_func)
|
|
{
|
|
/*
|
|
* Initialize object's attributes. Count can be zero.
|
|
*/
|
|
if (attr_cnt > 0) {
|
|
zkobj->zko_attr_list = kmem_zalloc(ATTR_TABLE_SIZE(attr_cnt),
|
|
KM_SLEEP);
|
|
if (zkobj->zko_attr_list == NULL)
|
|
return (ENOMEM);
|
|
}
|
|
/* this will always have at least one slot for NULL termination */
|
|
zkobj->zko_default_attrs = kmem_zalloc(DEFAULT_ATTR_SIZE(attr_cnt),
|
|
KM_SLEEP);
|
|
if (zkobj->zko_default_attrs == NULL) {
|
|
if (zkobj->zko_attr_list != NULL) {
|
|
kmem_free(zkobj->zko_attr_list,
|
|
ATTR_TABLE_SIZE(attr_cnt));
|
|
}
|
|
return (ENOMEM);
|
|
}
|
|
zkobj->zko_attr_count = attr_cnt;
|
|
zkobj->zko_kobj_type.default_attrs = zkobj->zko_default_attrs;
|
|
|
|
if (child_cnt > 0) {
|
|
zkobj->zko_children = kmem_zalloc(CHILD_TABLE_SIZE(child_cnt),
|
|
KM_SLEEP);
|
|
if (zkobj->zko_children == NULL) {
|
|
if (zkobj->zko_default_attrs != NULL) {
|
|
kmem_free(zkobj->zko_default_attrs,
|
|
DEFAULT_ATTR_SIZE(attr_cnt));
|
|
}
|
|
if (zkobj->zko_attr_list != NULL) {
|
|
kmem_free(zkobj->zko_attr_list,
|
|
ATTR_TABLE_SIZE(attr_cnt));
|
|
}
|
|
return (ENOMEM);
|
|
}
|
|
zkobj->zko_child_count = child_cnt;
|
|
}
|
|
|
|
zkobj->zko_sysfs_ops.show = show_func;
|
|
zkobj->zko_kobj_type.sysfs_ops = &zkobj->zko_sysfs_ops;
|
|
zkobj->zko_kobj_type.release = zfs_kobj_release;
|
|
|
|
return (0);
|
|
}
|
|
|
|
static int
|
|
zfs_kobj_add(zfs_mod_kobj_t *zkobj, struct kobject *parent, const char *name)
|
|
{
|
|
/* zko_default_attrs must be NULL terminated */
|
|
ASSERT(zkobj->zko_default_attrs != NULL);
|
|
ASSERT(zkobj->zko_default_attrs[zkobj->zko_attr_count] == NULL);
|
|
|
|
kobject_init(&zkobj->zko_kobj, &zkobj->zko_kobj_type);
|
|
return (kobject_add(&zkobj->zko_kobj, parent, name));
|
|
}
|
|
|
|
/*
|
|
* Each zfs property has these common attributes
|
|
*/
|
|
static const char *zprop_attrs[] = {
|
|
"type",
|
|
"readonly",
|
|
"setonce",
|
|
"visible",
|
|
"values",
|
|
"default",
|
|
"datasets" /* zfs properties only */
|
|
};
|
|
|
|
#define ZFS_PROP_ATTR_COUNT ARRAY_SIZE(zprop_attrs)
|
|
#define ZPOOL_PROP_ATTR_COUNT (ZFS_PROP_ATTR_COUNT - 1)
|
|
|
|
static const char *zprop_types[] = {
|
|
"number",
|
|
"string",
|
|
"index",
|
|
};
|
|
|
|
typedef struct zfs_type_map {
|
|
zfs_type_t ztm_type;
|
|
const char *ztm_name;
|
|
} zfs_type_map_t;
|
|
|
|
static zfs_type_map_t type_map[] = {
|
|
{ZFS_TYPE_FILESYSTEM, "filesystem"},
|
|
{ZFS_TYPE_SNAPSHOT, "snapshot"},
|
|
{ZFS_TYPE_VOLUME, "volume"},
|
|
{ZFS_TYPE_BOOKMARK, "bookmark"}
|
|
};
|
|
|
|
/*
|
|
* Show the content for a zfs property attribute
|
|
*/
|
|
static ssize_t
|
|
zprop_sysfs_show(const char *attr_name, const zprop_desc_t *property,
|
|
char *buf, size_t buflen)
|
|
{
|
|
const char *show_str;
|
|
|
|
/* For dataset properties list the dataset types that apply */
|
|
if (strcmp(attr_name, "datasets") == 0 &&
|
|
property->pd_types != ZFS_TYPE_POOL) {
|
|
int len = 0;
|
|
|
|
for (int i = 0; i < ARRAY_SIZE(type_map); i++) {
|
|
if (type_map[i].ztm_type & property->pd_types) {
|
|
len += snprintf(buf + len, buflen - len, "%s ",
|
|
type_map[i].ztm_name);
|
|
}
|
|
}
|
|
len += snprintf(buf + len, buflen - len, "\n");
|
|
return (len);
|
|
}
|
|
|
|
if (strcmp(attr_name, "type") == 0) {
|
|
show_str = zprop_types[property->pd_proptype];
|
|
} else if (strcmp(attr_name, "readonly") == 0) {
|
|
show_str = property->pd_attr == PROP_READONLY ? "1" : "0";
|
|
} else if (strcmp(attr_name, "setonce") == 0) {
|
|
show_str = property->pd_attr == PROP_ONETIME ? "1" : "0";
|
|
} else if (strcmp(attr_name, "visible") == 0) {
|
|
show_str = property->pd_visible ? "1" : "0";
|
|
} else if (strcmp(attr_name, "values") == 0) {
|
|
show_str = property->pd_values ? property->pd_values : "";
|
|
} else if (strcmp(attr_name, "default") == 0) {
|
|
char number[32];
|
|
|
|
switch (property->pd_proptype) {
|
|
case PROP_TYPE_NUMBER:
|
|
(void) snprintf(number, sizeof (number), "%llu",
|
|
(u_longlong_t)property->pd_numdefault);
|
|
show_str = number;
|
|
break;
|
|
case PROP_TYPE_STRING:
|
|
show_str = property->pd_strdefault ?
|
|
property->pd_strdefault : "";
|
|
break;
|
|
case PROP_TYPE_INDEX:
|
|
if (zprop_index_to_string(property->pd_propnum,
|
|
property->pd_numdefault, &show_str,
|
|
property->pd_types) != 0) {
|
|
show_str = "";
|
|
}
|
|
break;
|
|
default:
|
|
return (0);
|
|
}
|
|
} else {
|
|
return (0);
|
|
}
|
|
|
|
return (snprintf(buf, buflen, "%s\n", show_str));
|
|
}
|
|
|
|
static ssize_t
|
|
dataset_property_show(struct kobject *kobj, struct attribute *attr, char *buf)
|
|
{
|
|
zfs_prop_t prop = zfs_name_to_prop(kobject_name(kobj));
|
|
zprop_desc_t *prop_tbl = zfs_prop_get_table();
|
|
ssize_t len;
|
|
|
|
ASSERT3U(prop, <, ZFS_NUM_PROPS);
|
|
|
|
len = zprop_sysfs_show(attr->name, &prop_tbl[prop], buf, PAGE_SIZE);
|
|
|
|
return (len);
|
|
}
|
|
|
|
static ssize_t
|
|
pool_property_show(struct kobject *kobj, struct attribute *attr, char *buf)
|
|
{
|
|
zpool_prop_t prop = zpool_name_to_prop(kobject_name(kobj));
|
|
zprop_desc_t *prop_tbl = zpool_prop_get_table();
|
|
ssize_t len;
|
|
|
|
ASSERT3U(prop, <, ZPOOL_NUM_PROPS);
|
|
|
|
len = zprop_sysfs_show(attr->name, &prop_tbl[prop], buf, PAGE_SIZE);
|
|
|
|
return (len);
|
|
}
|
|
|
|
/*
|
|
* ZFS kernel feature attributes for '/sys/module/zfs/features.kernel'
|
|
*
|
|
* This list is intended for kernel features that don't have a pool feature
|
|
* association or that extend existing user kernel interfaces.
|
|
*
|
|
* A user processes can easily check if the running zfs kernel module
|
|
* supports the new feature.
|
|
*
|
|
* For example, the initial channel_program feature was extended to support
|
|
* async calls (i.e. a sync flag). If this mechanism were in place at that
|
|
* time, we could have added a 'channel_program_async' to this list.
|
|
*/
|
|
static const char *zfs_features[] = {
|
|
/* --> Add new kernel features here (post ZoL 0.8.0) */
|
|
};
|
|
|
|
#define ZFS_FEATURE_COUNT ARRAY_SIZE(zfs_features)
|
|
|
|
static ssize_t
|
|
kernel_feature_show(struct kobject *kobj, struct attribute *attr, char *buf)
|
|
{
|
|
return (snprintf(buf, PAGE_SIZE, "supported\n"));
|
|
}
|
|
|
|
static int
|
|
zfs_kernel_features_init(zfs_mod_kobj_t *zfs_kobj, struct kobject *parent)
|
|
{
|
|
int err;
|
|
|
|
err = zfs_kobj_init(zfs_kobj, ZFS_FEATURE_COUNT, 0,
|
|
kernel_feature_show);
|
|
if (err)
|
|
return (err);
|
|
|
|
for (int f = 0; f < ZFS_FEATURE_COUNT; f++)
|
|
zfs_kobj_add_attr(zfs_kobj, f, zfs_features[f]);
|
|
|
|
err = zfs_kobj_add(zfs_kobj, parent, ZFS_SYSFS_KERNEL_FEATURES);
|
|
if (err)
|
|
zfs_kobj_release(&zfs_kobj->zko_kobj);
|
|
|
|
return (err);
|
|
}
|
|
|
|
/*
|
|
* Each pool feature has these common attributes
|
|
*/
|
|
static const char *pool_feature_attrs[] = {
|
|
"description",
|
|
"guid",
|
|
"uname",
|
|
"readonly_compatible",
|
|
"required_for_mos",
|
|
"activate_on_enable",
|
|
"per_dataset"
|
|
};
|
|
|
|
#define ZPOOL_FEATURE_ATTR_COUNT ARRAY_SIZE(pool_feature_attrs)
|
|
|
|
/*
|
|
* Show the content for the given zfs pool feature attribute
|
|
*/
|
|
static ssize_t
|
|
pool_feature_show(struct kobject *kobj, struct attribute *attr, char *buf)
|
|
{
|
|
spa_feature_t fid;
|
|
|
|
if (zfeature_lookup_guid(kobject_name(kobj), &fid) != 0)
|
|
return (0);
|
|
|
|
ASSERT3U(fid, <, SPA_FEATURES);
|
|
|
|
zfeature_flags_t flags = spa_feature_table[fid].fi_flags;
|
|
const char *show_str = NULL;
|
|
|
|
if (strcmp(attr->name, "description") == 0) {
|
|
show_str = spa_feature_table[fid].fi_desc;
|
|
} else if (strcmp(attr->name, "guid") == 0) {
|
|
show_str = spa_feature_table[fid].fi_guid;
|
|
} else if (strcmp(attr->name, "uname") == 0) {
|
|
show_str = spa_feature_table[fid].fi_uname;
|
|
} else if (strcmp(attr->name, "readonly_compatible") == 0) {
|
|
show_str = flags & ZFEATURE_FLAG_READONLY_COMPAT ? "1" : "0";
|
|
} else if (strcmp(attr->name, "required_for_mos") == 0) {
|
|
show_str = flags & ZFEATURE_FLAG_MOS ? "1" : "0";
|
|
} else if (strcmp(attr->name, "activate_on_enable") == 0) {
|
|
show_str = flags & ZFEATURE_FLAG_ACTIVATE_ON_ENABLE ? "1" : "0";
|
|
} else if (strcmp(attr->name, "per_dataset") == 0) {
|
|
show_str = flags & ZFEATURE_FLAG_PER_DATASET ? "1" : "0";
|
|
}
|
|
if (show_str == NULL)
|
|
return (0);
|
|
|
|
return (snprintf(buf, PAGE_SIZE, "%s\n", show_str));
|
|
}
|
|
|
|
static void
|
|
pool_feature_to_kobj(zfs_mod_kobj_t *parent, spa_feature_t fid,
|
|
const char *name)
|
|
{
|
|
zfs_mod_kobj_t *zfs_kobj = &parent->zko_children[fid];
|
|
|
|
ASSERT3U(fid, <, SPA_FEATURES);
|
|
ASSERT(name);
|
|
|
|
int err = zfs_kobj_init(zfs_kobj, ZPOOL_FEATURE_ATTR_COUNT, 0,
|
|
pool_feature_show);
|
|
if (err)
|
|
return;
|
|
|
|
for (int i = 0; i < ZPOOL_FEATURE_ATTR_COUNT; i++)
|
|
zfs_kobj_add_attr(zfs_kobj, i, pool_feature_attrs[i]);
|
|
|
|
err = zfs_kobj_add(zfs_kobj, &parent->zko_kobj, name);
|
|
if (err)
|
|
zfs_kobj_release(&zfs_kobj->zko_kobj);
|
|
}
|
|
|
|
static int
|
|
zfs_pool_features_init(zfs_mod_kobj_t *zfs_kobj, struct kobject *parent)
|
|
{
|
|
/*
|
|
* Create a parent kobject to host pool features.
|
|
*
|
|
* '/sys/module/zfs/features.pool'
|
|
*/
|
|
int err = zfs_kobj_init(zfs_kobj, 0, SPA_FEATURES, pool_feature_show);
|
|
if (err)
|
|
return (err);
|
|
err = zfs_kobj_add(zfs_kobj, parent, ZFS_SYSFS_POOL_FEATURES);
|
|
if (err) {
|
|
zfs_kobj_release(&zfs_kobj->zko_kobj);
|
|
return (err);
|
|
}
|
|
|
|
/*
|
|
* Now create a kobject for each feature.
|
|
*
|
|
* '/sys/module/zfs/features.pool/<feature>'
|
|
*/
|
|
for (spa_feature_t i = 0; i < SPA_FEATURES; i++)
|
|
pool_feature_to_kobj(zfs_kobj, i, spa_feature_table[i].fi_guid);
|
|
|
|
return (0);
|
|
}
|
|
|
|
typedef struct prop_to_kobj_arg {
|
|
zprop_desc_t *p2k_table;
|
|
zfs_mod_kobj_t *p2k_parent;
|
|
sysfs_show_func p2k_show_func;
|
|
int p2k_attr_count;
|
|
} prop_to_kobj_arg_t;
|
|
|
|
static int
|
|
zprop_to_kobj(int prop, void *args)
|
|
{
|
|
prop_to_kobj_arg_t *data = args;
|
|
zfs_mod_kobj_t *parent = data->p2k_parent;
|
|
zfs_mod_kobj_t *zfs_kobj = &parent->zko_children[prop];
|
|
const char *name = data->p2k_table[prop].pd_name;
|
|
int err;
|
|
|
|
ASSERT(name);
|
|
|
|
err = zfs_kobj_init(zfs_kobj, data->p2k_attr_count, 0,
|
|
data->p2k_show_func);
|
|
if (err)
|
|
return (ZPROP_CONT);
|
|
|
|
for (int i = 0; i < data->p2k_attr_count; i++)
|
|
zfs_kobj_add_attr(zfs_kobj, i, zprop_attrs[i]);
|
|
|
|
err = zfs_kobj_add(zfs_kobj, &parent->zko_kobj, name);
|
|
if (err)
|
|
zfs_kobj_release(&zfs_kobj->zko_kobj);
|
|
|
|
return (ZPROP_CONT);
|
|
}
|
|
|
|
static int
|
|
zfs_sysfs_properties_init(zfs_mod_kobj_t *zfs_kobj, struct kobject *parent,
|
|
zfs_type_t type)
|
|
{
|
|
prop_to_kobj_arg_t context;
|
|
const char *name;
|
|
int err;
|
|
|
|
/*
|
|
* Create a parent kobject to host properties.
|
|
*
|
|
* '/sys/module/zfs/properties.<type>'
|
|
*/
|
|
if (type == ZFS_TYPE_POOL) {
|
|
name = ZFS_SYSFS_POOL_PROPERTIES;
|
|
context.p2k_table = zpool_prop_get_table();
|
|
context.p2k_attr_count = ZPOOL_PROP_ATTR_COUNT;
|
|
context.p2k_parent = zfs_kobj;
|
|
context.p2k_show_func = pool_property_show;
|
|
err = zfs_kobj_init(zfs_kobj, 0, ZPOOL_NUM_PROPS,
|
|
pool_property_show);
|
|
} else {
|
|
name = ZFS_SYSFS_DATASET_PROPERTIES;
|
|
context.p2k_table = zfs_prop_get_table();
|
|
context.p2k_attr_count = ZFS_PROP_ATTR_COUNT;
|
|
context.p2k_parent = zfs_kobj;
|
|
context.p2k_show_func = dataset_property_show;
|
|
err = zfs_kobj_init(zfs_kobj, 0, ZFS_NUM_PROPS,
|
|
dataset_property_show);
|
|
}
|
|
|
|
if (err)
|
|
return (err);
|
|
|
|
err = zfs_kobj_add(zfs_kobj, parent, name);
|
|
if (err) {
|
|
zfs_kobj_release(&zfs_kobj->zko_kobj);
|
|
return (err);
|
|
}
|
|
|
|
/*
|
|
* Create a kobject for each property.
|
|
*
|
|
* '/sys/module/zfs/properties.<type>/<property>'
|
|
*/
|
|
(void) zprop_iter_common(zprop_to_kobj, &context, B_TRUE,
|
|
B_FALSE, type);
|
|
|
|
return (err);
|
|
}
|
|
|
|
void
|
|
zfs_sysfs_init(void)
|
|
{
|
|
struct kobject *parent;
|
|
#if defined(CONFIG_ZFS) && !defined(CONFIG_ZFS_MODULE)
|
|
parent = kobject_create_and_add("zfs", fs_kobj);
|
|
#else
|
|
parent = &(((struct module *)(THIS_MODULE))->mkobj).kobj;
|
|
#endif
|
|
int err;
|
|
|
|
if (parent == NULL)
|
|
return;
|
|
|
|
err = zfs_kernel_features_init(&kernel_features_kobj, parent);
|
|
if (err)
|
|
return;
|
|
|
|
err = zfs_pool_features_init(&pool_features_kobj, parent);
|
|
if (err) {
|
|
zfs_kobj_fini(&kernel_features_kobj);
|
|
return;
|
|
}
|
|
|
|
err = zfs_sysfs_properties_init(&pool_props_kobj, parent,
|
|
ZFS_TYPE_POOL);
|
|
if (err) {
|
|
zfs_kobj_fini(&kernel_features_kobj);
|
|
zfs_kobj_fini(&pool_features_kobj);
|
|
return;
|
|
}
|
|
|
|
err = zfs_sysfs_properties_init(&dataset_props_kobj, parent,
|
|
ZFS_TYPE_FILESYSTEM);
|
|
if (err) {
|
|
zfs_kobj_fini(&kernel_features_kobj);
|
|
zfs_kobj_fini(&pool_features_kobj);
|
|
zfs_kobj_fini(&pool_props_kobj);
|
|
return;
|
|
}
|
|
}
|
|
|
|
void
|
|
zfs_sysfs_fini(void)
|
|
{
|
|
/*
|
|
* Remove top-level kobjects; each will remove any children kobjects
|
|
*/
|
|
zfs_kobj_fini(&kernel_features_kobj);
|
|
zfs_kobj_fini(&pool_features_kobj);
|
|
zfs_kobj_fini(&dataset_props_kobj);
|
|
zfs_kobj_fini(&pool_props_kobj);
|
|
}
|