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 2009 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 */
25
26 #include <sys/zio.h>
27 #include <sys/spa.h>
28 #include <sys/zfs_acl.h>
29 #include <sys/zfs_ioctl.h>
30 #include <sys/fs/zfs.h>
31
32 #include "zfs_prop.h"
33
34 #if defined(_KERNEL)
35 #include <sys/systm.h>
36 #else
37 #include <stdlib.h>
38 #include <string.h>
39 #include <ctype.h>
40 #endif
41
42 static zprop_desc_t zpool_prop_table[ZPOOL_NUM_PROPS];
43
44 zprop_desc_t *
zpool_prop_get_table(void)45 zpool_prop_get_table(void)
46 {
47 return (zpool_prop_table);
48 }
49
50 void
zpool_prop_init(void)51 zpool_prop_init(void)
52 {
53 static zprop_index_t boolean_table[] = {
54 { "off", 0},
55 { "on", 1},
56 { NULL }
57 };
58
59 static zprop_index_t failuremode_table[] = {
60 { "wait", ZIO_FAILURE_MODE_WAIT },
61 { "continue", ZIO_FAILURE_MODE_CONTINUE },
62 { "panic", ZIO_FAILURE_MODE_PANIC },
63 { NULL }
64 };
65
66 /* string properties */
67 register_string(ZPOOL_PROP_ALTROOT, "altroot", NULL, PROP_DEFAULT,
68 ZFS_TYPE_POOL, "<path>", "ALTROOT");
69 register_string(ZPOOL_PROP_BOOTFS, "bootfs", NULL, PROP_DEFAULT,
70 ZFS_TYPE_POOL, "<filesystem>", "BOOTFS");
71 register_string(ZPOOL_PROP_CACHEFILE, "cachefile", NULL, PROP_DEFAULT,
72 ZFS_TYPE_POOL, "<file> | none", "CACHEFILE");
73
74 /* readonly number properties */
75 register_number(ZPOOL_PROP_SIZE, "size", 0, PROP_READONLY,
76 ZFS_TYPE_POOL, "<size>", "SIZE");
77 register_number(ZPOOL_PROP_FREE, "free", 0, PROP_READONLY,
78 ZFS_TYPE_POOL, "<size>", "FREE");
79 register_number(ZPOOL_PROP_ALLOCATED, "allocated", 0, PROP_READONLY,
80 ZFS_TYPE_POOL, "<size>", "ALLOC");
81 register_number(ZPOOL_PROP_CAPACITY, "capacity", 0, PROP_READONLY,
82 ZFS_TYPE_POOL, "<size>", "CAP");
83 register_number(ZPOOL_PROP_GUID, "guid", 0, PROP_READONLY,
84 ZFS_TYPE_POOL, "<guid>", "GUID");
85 register_number(ZPOOL_PROP_HEALTH, "health", 0, PROP_READONLY,
86 ZFS_TYPE_POOL, "<state>", "HEALTH");
87 register_number(ZPOOL_PROP_DEDUPRATIO, "dedupratio", 0, PROP_READONLY,
88 ZFS_TYPE_POOL, "<1.00x or higher if deduped>", "DEDUP");
89
90 /* default number properties */
91 register_number(ZPOOL_PROP_VERSION, "version", SPA_VERSION,
92 PROP_DEFAULT, ZFS_TYPE_POOL, "<version>", "VERSION");
93 register_number(ZPOOL_PROP_DEDUPDITTO, "dedupditto", 0,
94 PROP_DEFAULT, ZFS_TYPE_POOL, "<threshold (min 100)>", "DEDUPDITTO");
95
96 /* default index (boolean) properties */
97 register_index(ZPOOL_PROP_DELEGATION, "delegation", 1, PROP_DEFAULT,
98 ZFS_TYPE_POOL, "on | off", "DELEGATION", boolean_table);
99 register_index(ZPOOL_PROP_AUTOREPLACE, "autoreplace", 0, PROP_DEFAULT,
100 ZFS_TYPE_POOL, "on | off", "REPLACE", boolean_table);
101 register_index(ZPOOL_PROP_LISTSNAPS, "listsnapshots", 0, PROP_DEFAULT,
102 ZFS_TYPE_POOL, "on | off", "LISTSNAPS", boolean_table);
103 register_index(ZPOOL_PROP_AUTOEXPAND, "autoexpand", 0, PROP_DEFAULT,
104 ZFS_TYPE_POOL, "on | off", "EXPAND", boolean_table);
105
106 /* default index properties */
107 register_index(ZPOOL_PROP_FAILUREMODE, "failmode",
108 ZIO_FAILURE_MODE_WAIT, PROP_DEFAULT, ZFS_TYPE_POOL,
109 "wait | continue | panic", "FAILMODE", failuremode_table);
110
111 /* hidden properties */
112 register_hidden(ZPOOL_PROP_NAME, "name", PROP_TYPE_STRING,
113 PROP_READONLY, ZFS_TYPE_POOL, "NAME");
114 }
115
116 /*
117 * Given a property name and its type, returns the corresponding property ID.
118 */
119 zpool_prop_t
zpool_name_to_prop(const char * propname)120 zpool_name_to_prop(const char *propname)
121 {
122 return (zprop_name_to_prop(propname, ZFS_TYPE_POOL));
123 }
124
125 /*
126 * Given a pool property ID, returns the corresponding name.
127 * Assuming the pool propety ID is valid.
128 */
129 const char *
zpool_prop_to_name(zpool_prop_t prop)130 zpool_prop_to_name(zpool_prop_t prop)
131 {
132 return (zpool_prop_table[prop].pd_name);
133 }
134
135 zprop_type_t
zpool_prop_get_type(zpool_prop_t prop)136 zpool_prop_get_type(zpool_prop_t prop)
137 {
138 return (zpool_prop_table[prop].pd_proptype);
139 }
140
141 boolean_t
zpool_prop_readonly(zpool_prop_t prop)142 zpool_prop_readonly(zpool_prop_t prop)
143 {
144 return (zpool_prop_table[prop].pd_attr == PROP_READONLY);
145 }
146
147 const char *
zpool_prop_default_string(zpool_prop_t prop)148 zpool_prop_default_string(zpool_prop_t prop)
149 {
150 return (zpool_prop_table[prop].pd_strdefault);
151 }
152
153 uint64_t
zpool_prop_default_numeric(zpool_prop_t prop)154 zpool_prop_default_numeric(zpool_prop_t prop)
155 {
156 return (zpool_prop_table[prop].pd_numdefault);
157 }
158
159 int
zpool_prop_string_to_index(zpool_prop_t prop,const char * string,uint64_t * index)160 zpool_prop_string_to_index(zpool_prop_t prop, const char *string,
161 uint64_t *index)
162 {
163 return (zprop_string_to_index(prop, string, index, ZFS_TYPE_POOL));
164 }
165
166 int
zpool_prop_index_to_string(zpool_prop_t prop,uint64_t index,const char ** string)167 zpool_prop_index_to_string(zpool_prop_t prop, uint64_t index,
168 const char **string)
169 {
170 return (zprop_index_to_string(prop, index, string, ZFS_TYPE_POOL));
171 }
172
173 uint64_t
zpool_prop_random_value(zpool_prop_t prop,uint64_t seed)174 zpool_prop_random_value(zpool_prop_t prop, uint64_t seed)
175 {
176 return (zprop_random_value(prop, seed, ZFS_TYPE_POOL));
177 }
178
179 #ifndef _KERNEL
180
181 const char *
zpool_prop_values(zpool_prop_t prop)182 zpool_prop_values(zpool_prop_t prop)
183 {
184 return (zpool_prop_table[prop].pd_values);
185 }
186
187 const char *
zpool_prop_column_name(zpool_prop_t prop)188 zpool_prop_column_name(zpool_prop_t prop)
189 {
190 return (zpool_prop_table[prop].pd_colname);
191 }
192
193 boolean_t
zpool_prop_align_right(zpool_prop_t prop)194 zpool_prop_align_right(zpool_prop_t prop)
195 {
196 return (zpool_prop_table[prop].pd_rightalign);
197 }
198 #endif
199