xref: /illumos-gate/usr/src/common/zfs/zprop_common.c (revision 4445fffb)
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 *
zprop_get_proptable(zfs_type_t type)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
zprop_get_numprops(zfs_type_t type)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
zprop_register_impl(int prop,const char * name,zprop_type_t type,uint64_t numdefault,const char * strdefault,zprop_attr_t attr,int objset_types,const char * values,const char * colname,boolean_t rightalign,boolean_t visible,const zprop_index_t * idx_tbl)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
zprop_register_string(int prop,const char * name,const char * def,zprop_attr_t attr,int objset_types,const char * values,const char * colname)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
zprop_register_number(int prop,const char * name,uint64_t def,zprop_attr_t attr,int objset_types,const char * values,const char * colname)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
zprop_register_index(int prop,const char * name,uint64_t def,zprop_attr_t attr,int objset_types,const char * values,const char * colname,const zprop_index_t * idx_tbl)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
zprop_register_hidden(int prop,const char * name,zprop_type_t type,zprop_attr_t attr,int objset_types,const char * colname)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
zprop_compare(const void * arg1,const void * arg2)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
zprop_iter_common(zprop_func func,void * cb,boolean_t show_all,boolean_t ordered,zfs_type_t type)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
propname_match(const char * p,size_t len,zprop_desc_t * prop_entry)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
zprop_name_to_prop_cb(int prop,void * cb_data)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
zprop_name_to_prop(const char * propname,zfs_type_t type)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
zprop_string_to_index(int prop,const char * string,uint64_t * index,zfs_type_t type)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
zprop_index_to_string(int prop,uint64_t index,const char ** string,zfs_type_t type)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
zprop_random_value(int prop,uint64_t seed,zfs_type_t type)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 *
zprop_values(int prop,zfs_type_t type)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 boolean_t
zprop_valid_for_type(int prop,zfs_type_t type)356 zprop_valid_for_type(int prop, zfs_type_t type)
357 {
358 	zprop_desc_t *prop_tbl;
359 
360 	if (prop == ZPROP_INVAL || prop == ZPROP_CONT)
361 		return (B_FALSE);
362 
363 	ASSERT(prop < zprop_get_numprops(type));
364 	prop_tbl = zprop_get_proptable(type);
365 	return ((prop_tbl[prop].pd_types & type) != 0);
366 }
367 
368 #ifndef _KERNEL
369 
370 /*
371  * Determines the minimum width for the column, and indicates whether it's fixed
372  * or not.  Only string columns are non-fixed.
373  */
374 size_t
zprop_width(int prop,boolean_t * fixed,zfs_type_t type)375 zprop_width(int prop, boolean_t *fixed, zfs_type_t type)
376 {
377 	zprop_desc_t *prop_tbl, *pd;
378 	const zprop_index_t *idx;
379 	size_t ret;
380 	int i;
381 
382 	ASSERT(prop != ZPROP_INVAL && prop != ZPROP_CONT);
383 	ASSERT(prop < zprop_get_numprops(type));
384 
385 	prop_tbl = zprop_get_proptable(type);
386 	pd = &prop_tbl[prop];
387 
388 	*fixed = B_TRUE;
389 
390 	/*
391 	 * Start with the width of the column name.
392 	 */
393 	ret = strlen(pd->pd_colname);
394 
395 	/*
396 	 * For fixed-width values, make sure the width is large enough to hold
397 	 * any possible value.
398 	 */
399 	switch (pd->pd_proptype) {
400 	case PROP_TYPE_NUMBER:
401 		/*
402 		 * The maximum length of a human-readable number is 5 characters
403 		 * ("20.4M", for example).
404 		 */
405 		if (ret < 5)
406 			ret = 5;
407 		/*
408 		 * 'creation' is handled specially because it's a number
409 		 * internally, but displayed as a date string.
410 		 */
411 		if (prop == ZFS_PROP_CREATION)
412 			*fixed = B_FALSE;
413 		break;
414 	case PROP_TYPE_INDEX:
415 		idx = prop_tbl[prop].pd_table;
416 		for (i = 0; idx[i].pi_name != NULL; i++) {
417 			if (strlen(idx[i].pi_name) > ret)
418 				ret = strlen(idx[i].pi_name);
419 		}
420 		break;
421 
422 	case PROP_TYPE_STRING:
423 		*fixed = B_FALSE;
424 		break;
425 	}
426 
427 	return (ret);
428 }
429 
430 #endif
431