xref: /illumos-gate/usr/src/common/zfs/zprop_common.c (revision 4c2bdae2)
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  * 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
zprop_valid_for_type(int prop,zfs_type_t type,boolean_t headcheck)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
zprop_width(int prop,boolean_t * fixed,zfs_type_t type)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 		/*
420 		 * 'health' is handled specially because it's a number
421 		 * internally, but displayed as a fixed 8 character string.
422 		 */
423 		if (prop == ZPOOL_PROP_HEALTH)
424 			ret = 8;
425 		break;
426 	case PROP_TYPE_INDEX:
427 		idx = prop_tbl[prop].pd_table;
428 		for (i = 0; idx[i].pi_name != NULL; i++) {
429 			if (strlen(idx[i].pi_name) > ret)
430 				ret = strlen(idx[i].pi_name);
431 		}
432 		break;
433 
434 	case PROP_TYPE_STRING:
435 		*fixed = B_FALSE;
436 		break;
437 	}
438 
439 	return (ret);
440 }
441 
442 #endif
443