Print this page
NEX-5795 Rename 'wrc' as 'wbc' in the source and in the tech docs
Reviewed by: Alex Aizman <alex.aizman@nexenta.com>
Reviewed by: Sanjay Nadkarni <sanjay.nadkarni@nexenta.com>
Reviewed by: Alek Pinchuk <alek.pinchuk@nexenta.com>
NEX-5265 zpool_prop and zfeature_common need a comment to update the test suites when a new feature or prop is added
Reviewed by: Alek Pinchuk <alek.pinchuk@nexenta.com>
6328 Fix cstyle errors in zfs codebase (fix studio)
6328 Fix cstyle errors in zfs codebase
Reviewed by: Matthew Ahrens <mahrens@delphix.com>
Reviewed by: Alex Reece <alex@delphix.com>
Reviewed by: Richard Elling <Richard.Elling@RichardElling.com>
Reviewed by: Jorgen Lundman <lundman@lundman.net>
Approved by: Robert Mustacchi <rm@joyent.com>
4185 add new cryptographic checksums to ZFS: SHA-512, Skein, Edon-R (fix studio build)
4185 add new cryptographic checksums to ZFS: SHA-512, Skein, Edon-R
Reviewed by: George Wilson <george.wilson@delphix.com>
Reviewed by: Prakash Surya <prakash.surya@delphix.com>
Reviewed by: Saso Kiselkov <saso.kiselkov@nexenta.com>
Reviewed by: Richard Lowe <richlowe@richlowe.net>
Approved by: Garrett D'Amore <garrett@damore.org>
6047 SPARC boot should support feature@embedded_data
Reviewed by: Igor Kozhukhov <ikozhukhov@gmail.com>
Approved by: Dan McDonald <danmcd@omniti.com>
5959 clean up per-dataset feature count code
Reviewed by: Toomas Soome <tsoome@me.com>
Reviewed by: George Wilson <george@delphix.com>
Reviewed by: Alex Reece <alex@delphix.com>
Approved by: Richard Lowe <richlowe@richlowe.net>
NEX-4476 WRC: Allow to use write back cache per tree of datasets
Reviewed by: Alek Pinchuk <alek.pinchuk@nexenta.com>
Reviewed by: Alex Aizman <alex.aizman@nexenta.com>
Revert "NEX-4476 WRC: Allow to use write back cache per tree of datasets"
This reverts commit fe97b74444278a6f36fec93179133641296312da.
NEX-4476 WRC: Allow to use write back cache per tree of datasets
Reviewed by: Alek Pinchuk <alek.pinchuk@nexenta.com>
Reviewed by: Alex Aizman <alex.aizman@nexenta.com>
NEX-4044 remove sha1crc32 in preparation with upstream merge of edon-r and skien
Reviewed by: Saso Kiselkov <saso.kiselkov@nexenta.com>
Reviewed by: Alek Pinchuk <alek@nexenta.com>
Conflicts:
usr/src/uts/common/fs/zfs/sys/zio_checksum.h
Revert "SUP-817 Removed references to special device"
This reverts commit f8970e28f0d8bd6b69711722f341e3e1d0e1babf.
SUP-817 Removed references to special device
4370 avoid transmitting holes during zfs send
4371 DMU code clean up
Reviewed by: Matthew Ahrens <mahrens@delphix.com>
Reviewed by: George Wilson <george.wilson@delphix.com>
Reviewed by: Christopher Siden <christopher.siden@delphix.com>
Reviewed by: Josef 'Jeff' Sipek <jeffpc@josefsipek.net>
Approved by: Garrett D'Amore <garrett@damore.org>
OS-80 support for vdev and CoS properties for the new I/O scheduler
OS-95 lint warning introduced by OS-61
Issue #34: Add feature flag for the compount checksum - sha1crc32
Contributors: Boris Protopopov
Issue #9: Support for persistent CoS/vdev attributes with feature flags
Support for feature flags for special tier
Contributors: Daniil Lunev, Boris Protopopov
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/common/zfs/zfeature_common.c
+++ new/usr/src/common/zfs/zfeature_common.c
1 1 /*
2 2 * CDDL HEADER START
3 3 *
4 4 * The contents of this file are subject to the terms of the
5 5 * Common Development and Distribution License (the "License").
6 6 * You may not use this file except in compliance with the License.
7 7 *
8 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 9 * or http://www.opensolaris.org/os/licensing.
10 10 * See the License for the specific language governing permissions
11 11 * and limitations under the License.
12 12 *
13 13 * When distributing Covered Code, include this CDDL HEADER in each
14 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 15 * If applicable, add the following below this CDDL HEADER, with the
|
↓ open down ↓ |
15 lines elided |
↑ open up ↑ |
16 16 * fields enclosed by brackets "[]" replaced with your own identifying
17 17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 18 *
19 19 * CDDL HEADER END
20 20 */
21 21
22 22 /*
23 23 * Copyright (c) 2011, 2015 by Delphix. All rights reserved.
24 24 * Copyright (c) 2013 by Saso Kiselkov. All rights reserved.
25 25 * Copyright (c) 2013, Joyent, Inc. All rights reserved.
26 - * Copyright (c) 2014, Nexenta Systems, Inc. All rights reserved.
27 26 * Copyright (c) 2014 Integros [integros.com]
27 + * Copyright 2016 Nexenta Systems, Inc. All rights reserved.
28 28 */
29 29
30 30 #ifdef _KERNEL
31 31 #include <sys/systm.h>
32 32 #else
33 33 #include <errno.h>
34 34 #include <string.h>
35 35 #endif
36 36 #include <sys/debug.h>
37 37 #include <sys/fs/zfs.h>
38 38 #include <sys/inttypes.h>
39 39 #include <sys/types.h>
40 40 #include "zfeature_common.h"
41 41
42 42 /*
43 43 * Set to disable all feature checks while opening pools, allowing pools with
44 44 * unsupported features to be opened. Set for testing only.
45 45 */
46 46 boolean_t zfeature_checks_disable = B_FALSE;
47 47
48 48 zfeature_info_t spa_feature_table[SPA_FEATURES];
49 49
50 50 /*
51 51 * Valid characters for feature guids. This list is mainly for aesthetic
52 52 * purposes and could be expanded in the future. There are different allowed
53 53 * characters in the guids reverse dns portion (before the colon) and its
54 54 * short name (after the colon).
55 55 */
56 56 static int
57 57 valid_char(char c, boolean_t after_colon)
58 58 {
59 59 return ((c >= 'a' && c <= 'z') ||
60 60 (c >= '0' && c <= '9') ||
61 61 (after_colon && c == '_') ||
62 62 (!after_colon && (c == '.' || c == '-')));
63 63 }
64 64
65 65 /*
66 66 * Every feature guid must contain exactly one colon which separates a reverse
67 67 * dns organization name from the feature's "short" name (e.g.
68 68 * "com.company:feature_name").
69 69 */
70 70 boolean_t
71 71 zfeature_is_valid_guid(const char *name)
72 72 {
73 73 int i;
74 74 boolean_t has_colon = B_FALSE;
75 75
76 76 i = 0;
77 77 while (name[i] != '\0') {
78 78 char c = name[i++];
79 79 if (c == ':') {
80 80 if (has_colon)
81 81 return (B_FALSE);
82 82 has_colon = B_TRUE;
83 83 continue;
84 84 }
85 85 if (!valid_char(c, has_colon))
86 86 return (B_FALSE);
87 87 }
88 88
89 89 return (has_colon);
90 90 }
91 91
92 92 boolean_t
93 93 zfeature_is_supported(const char *guid)
94 94 {
95 95 if (zfeature_checks_disable)
96 96 return (B_TRUE);
97 97
98 98 for (spa_feature_t i = 0; i < SPA_FEATURES; i++) {
99 99 zfeature_info_t *feature = &spa_feature_table[i];
100 100 if (strcmp(guid, feature->fi_guid) == 0)
101 101 return (B_TRUE);
102 102 }
103 103 return (B_FALSE);
104 104 }
105 105
106 106 int
107 107 zfeature_lookup_name(const char *name, spa_feature_t *res)
108 108 {
109 109 for (spa_feature_t i = 0; i < SPA_FEATURES; i++) {
110 110 zfeature_info_t *feature = &spa_feature_table[i];
111 111 if (strcmp(name, feature->fi_uname) == 0) {
112 112 if (res != NULL)
113 113 *res = i;
114 114 return (0);
115 115 }
116 116 }
117 117
118 118 return (ENOENT);
119 119 }
120 120
121 121 boolean_t
122 122 zfeature_depends_on(spa_feature_t fid, spa_feature_t check)
123 123 {
124 124 zfeature_info_t *feature = &spa_feature_table[fid];
125 125
126 126 for (int i = 0; feature->fi_depends[i] != SPA_FEATURE_NONE; i++) {
127 127 if (feature->fi_depends[i] == check)
128 128 return (B_TRUE);
129 129 }
130 130 return (B_FALSE);
131 131 }
132 132
133 133 static boolean_t
134 134 deps_contains_feature(const spa_feature_t *deps, const spa_feature_t feature)
135 135 {
136 136 for (int i = 0; deps[i] != SPA_FEATURE_NONE; i++)
137 137 if (deps[i] == feature)
138 138 return (B_TRUE);
139 139
140 140 return (B_FALSE);
141 141 }
142 142
143 143 static void
144 144 zfeature_register(spa_feature_t fid, const char *guid, const char *name,
145 145 const char *desc, zfeature_flags_t flags, const spa_feature_t *deps)
146 146 {
147 147 zfeature_info_t *feature = &spa_feature_table[fid];
148 148 static spa_feature_t nodeps[] = { SPA_FEATURE_NONE };
149 149
150 150 ASSERT(name != NULL);
151 151 ASSERT(desc != NULL);
152 152 ASSERT((flags & ZFEATURE_FLAG_READONLY_COMPAT) == 0 ||
153 153 (flags & ZFEATURE_FLAG_MOS) == 0);
154 154 ASSERT3U(fid, <, SPA_FEATURES);
155 155 ASSERT(zfeature_is_valid_guid(guid));
156 156
157 157 if (deps == NULL)
158 158 deps = nodeps;
159 159
160 160 VERIFY(((flags & ZFEATURE_FLAG_PER_DATASET) == 0) ||
|
↓ open down ↓ |
123 lines elided |
↑ open up ↑ |
161 161 (deps_contains_feature(deps, SPA_FEATURE_EXTENSIBLE_DATASET)));
162 162
163 163 feature->fi_feature = fid;
164 164 feature->fi_guid = guid;
165 165 feature->fi_uname = name;
166 166 feature->fi_desc = desc;
167 167 feature->fi_flags = flags;
168 168 feature->fi_depends = deps;
169 169 }
170 170
171 +spa_feature_t cos_deps[] = { SPA_FEATURE_VDEV_PROPS, SPA_FEATURE_NONE };
172 +
171 173 void
172 174 zpool_feature_init(void)
173 175 {
176 +
177 + /*
178 + * NOTE: When either adding or changing a feature make sure
179 + * to update the zfs-tests zpool_get configuration file
180 + * at usr/src/test/zfs-tests/tests/functional/cli_root/zpool_get/zpool_get.cfg
181 + */
174 182 zfeature_register(SPA_FEATURE_ASYNC_DESTROY,
175 183 "com.delphix:async_destroy", "async_destroy",
176 184 "Destroy filesystems asynchronously.",
177 185 ZFEATURE_FLAG_READONLY_COMPAT, NULL);
178 186
179 187 zfeature_register(SPA_FEATURE_EMPTY_BPOBJ,
180 188 "com.delphix:empty_bpobj", "empty_bpobj",
181 189 "Snapshots use less space.",
182 190 ZFEATURE_FLAG_READONLY_COMPAT, NULL);
183 191
184 192 zfeature_register(SPA_FEATURE_LZ4_COMPRESS,
185 193 "org.illumos:lz4_compress", "lz4_compress",
186 194 "LZ4 compression algorithm support.",
187 195 ZFEATURE_FLAG_ACTIVATE_ON_ENABLE, NULL);
188 196
189 197 zfeature_register(SPA_FEATURE_MULTI_VDEV_CRASH_DUMP,
190 198 "com.joyent:multi_vdev_crash_dump", "multi_vdev_crash_dump",
191 199 "Crash dumps to multiple vdev pools.",
192 200 0, NULL);
193 201
194 202 zfeature_register(SPA_FEATURE_SPACEMAP_HISTOGRAM,
195 203 "com.delphix:spacemap_histogram", "spacemap_histogram",
196 204 "Spacemaps maintain space histograms.",
197 205 ZFEATURE_FLAG_READONLY_COMPAT, NULL);
198 206
199 207 zfeature_register(SPA_FEATURE_ENABLED_TXG,
200 208 "com.delphix:enabled_txg", "enabled_txg",
201 209 "Record txg at which a feature is enabled",
202 210 ZFEATURE_FLAG_READONLY_COMPAT, NULL);
203 211
204 212 static spa_feature_t hole_birth_deps[] = {
205 213 SPA_FEATURE_ENABLED_TXG,
206 214 SPA_FEATURE_NONE
207 215 };
208 216 zfeature_register(SPA_FEATURE_HOLE_BIRTH,
209 217 "com.delphix:hole_birth", "hole_birth",
210 218 "Retain hole birth txg for more precise zfs send",
211 219 ZFEATURE_FLAG_MOS | ZFEATURE_FLAG_ACTIVATE_ON_ENABLE,
212 220 hole_birth_deps);
213 221
214 222 zfeature_register(SPA_FEATURE_EXTENSIBLE_DATASET,
215 223 "com.delphix:extensible_dataset", "extensible_dataset",
216 224 "Enhanced dataset functionality, used by other features.",
217 225 0, NULL);
218 226
219 227 static const spa_feature_t bookmarks_deps[] = {
220 228 SPA_FEATURE_EXTENSIBLE_DATASET,
221 229 SPA_FEATURE_NONE
222 230 };
223 231 zfeature_register(SPA_FEATURE_BOOKMARKS,
224 232 "com.delphix:bookmarks", "bookmarks",
225 233 "\"zfs bookmark\" command",
226 234 ZFEATURE_FLAG_READONLY_COMPAT, bookmarks_deps);
227 235
228 236 static const spa_feature_t filesystem_limits_deps[] = {
229 237 SPA_FEATURE_EXTENSIBLE_DATASET,
230 238 SPA_FEATURE_NONE
231 239 };
232 240 zfeature_register(SPA_FEATURE_FS_SS_LIMIT,
233 241 "com.joyent:filesystem_limits", "filesystem_limits",
234 242 "Filesystem and snapshot limits.",
235 243 ZFEATURE_FLAG_READONLY_COMPAT, filesystem_limits_deps);
236 244
237 245 zfeature_register(SPA_FEATURE_EMBEDDED_DATA,
238 246 "com.delphix:embedded_data", "embedded_data",
239 247 "Blocks which compress very well use even less space.",
240 248 ZFEATURE_FLAG_MOS | ZFEATURE_FLAG_ACTIVATE_ON_ENABLE,
241 249 NULL);
242 250
243 251 static const spa_feature_t large_blocks_deps[] = {
244 252 SPA_FEATURE_EXTENSIBLE_DATASET,
245 253 SPA_FEATURE_NONE
246 254 };
247 255 zfeature_register(SPA_FEATURE_LARGE_BLOCKS,
248 256 "org.open-zfs:large_blocks", "large_blocks",
249 257 "Support for blocks larger than 128KB.",
250 258 ZFEATURE_FLAG_PER_DATASET, large_blocks_deps);
251 259
252 260 static const spa_feature_t sha512_deps[] = {
253 261 SPA_FEATURE_EXTENSIBLE_DATASET,
254 262 SPA_FEATURE_NONE
255 263 };
256 264 zfeature_register(SPA_FEATURE_SHA512,
257 265 "org.illumos:sha512", "sha512",
258 266 "SHA-512/256 hash algorithm.",
259 267 ZFEATURE_FLAG_PER_DATASET, sha512_deps);
260 268
261 269 static const spa_feature_t skein_deps[] = {
262 270 SPA_FEATURE_EXTENSIBLE_DATASET,
263 271 SPA_FEATURE_NONE
264 272 };
265 273 zfeature_register(SPA_FEATURE_SKEIN,
266 274 "org.illumos:skein", "skein",
267 275 "Skein hash algorithm.",
268 276 ZFEATURE_FLAG_PER_DATASET, skein_deps);
|
↓ open down ↓ |
85 lines elided |
↑ open up ↑ |
269 277
270 278 static const spa_feature_t edonr_deps[] = {
271 279 SPA_FEATURE_EXTENSIBLE_DATASET,
272 280 SPA_FEATURE_NONE
273 281 };
274 282 zfeature_register(SPA_FEATURE_EDONR,
275 283 "org.illumos:edonr", "edonr",
276 284 "Edon-R hash algorithm.",
277 285 ZFEATURE_FLAG_PER_DATASET, edonr_deps);
278 286
279 - zfeature_register(SPA_FEATURE_DEVICE_REMOVAL,
280 - "com.delphix:device_removal", "device_removal",
281 - "Top-level vdevs can be removed, reducing logical pool size.",
282 - ZFEATURE_FLAG_MOS, NULL);
283 -
284 - static const spa_feature_t obsolete_counts_deps[] = {
285 - SPA_FEATURE_EXTENSIBLE_DATASET,
286 - SPA_FEATURE_DEVICE_REMOVAL,
287 - SPA_FEATURE_NONE
288 - };
289 - zfeature_register(SPA_FEATURE_OBSOLETE_COUNTS,
290 - "com.delphix:obsolete_counts", "obsolete_counts",
291 - "Reduce memory used by removed devices when their blocks are "
292 - "freed or remapped.",
293 - ZFEATURE_FLAG_READONLY_COMPAT, obsolete_counts_deps);
287 + zfeature_register(SPA_FEATURE_META_DEVICES,
288 + "com.nexenta:meta_devices", "meta_devices",
289 + "Dedicated devices for metadata.", ZFEATURE_FLAG_READONLY_COMPAT, NULL);
290 + zfeature_register(SPA_FEATURE_VDEV_PROPS,
291 + "com.nexenta:vdev_properties", "vdev_properties",
292 + "Vdev-specific properties.", ZFEATURE_FLAG_READONLY_COMPAT, NULL);
293 + zfeature_register(SPA_FEATURE_COS_PROPS,
294 + "com.nexenta:class_of_storage", "class_of_storage",
295 + "Properties for groups of vdevs.", ZFEATURE_FLAG_READONLY_COMPAT,
296 + cos_deps);
297 + zfeature_register(SPA_FEATURE_WBC,
298 + "com.nexenta:wbc", "wbc",
299 + "Write back cache support", 0, NULL);
294 300 }
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX