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
52static zprop_desc_t *
53zprop_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
61static int
62zprop_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
70void
71zprop_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
102void
103zprop_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
112void
113zprop_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
121void
122zprop_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
130void
131zprop_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 */
143static int
144zprop_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 */
165int
166zprop_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
209static boolean_t
210propname_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
236typedef struct name_to_prop_cb {
237	const char *propname;
238	zprop_desc_t *prop_tbl;
239} name_to_prop_cb_t;
240
241static int
242zprop_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
253int
254zprop_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
268int
269zprop_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
294int
295zprop_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 */
323uint64_t
324zprop_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
339const char *
340zprop_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 */
355boolean_t
356zprop_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 */
374size_t
375zprop_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