1 /*
2 * Copyright (c) 2020 iXsystems, Inc.
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 *
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND
15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE
18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24 * SUCH DAMAGE.
25 *
26 */
27
28 #include <sys/cdefs.h>
29 __FBSDID("$FreeBSD$");
30
31 #include <sys/types.h>
32 #include <sys/param.h>
33 #include <sys/systm.h>
34 #include <sys/conf.h>
35 #include <sys/kernel.h>
36 #include <sys/lock.h>
37 #include <sys/malloc.h>
38 #include <sys/mutex.h>
39 #include <sys/proc.h>
40 #include <sys/errno.h>
41 #include <sys/uio.h>
42 #include <sys/buf.h>
43 #include <sys/file.h>
44 #include <sys/kmem.h>
45 #include <sys/conf.h>
46 #include <sys/cmn_err.h>
47 #include <sys/stat.h>
48 #include <sys/zfs_ioctl.h>
49 #include <sys/zfs_vfsops.h>
50 #include <sys/zfs_znode.h>
51 #include <sys/zap.h>
52 #include <sys/spa.h>
53 #include <sys/spa_impl.h>
54 #include <sys/vdev.h>
55 #include <sys/vdev_impl.h>
56 #include <sys/dmu.h>
57 #include <sys/dsl_dir.h>
58 #include <sys/dsl_dataset.h>
59 #include <sys/dsl_prop.h>
60 #include <sys/dsl_deleg.h>
61 #include <sys/dmu_objset.h>
62 #include <sys/dmu_impl.h>
63 #include <sys/dmu_tx.h>
64 #include <sys/sunddi.h>
65 #include <sys/policy.h>
66 #include <sys/zone.h>
67 #include <sys/nvpair.h>
68 #include <sys/mount.h>
69 #include <sys/taskqueue.h>
70 #include <sys/sdt.h>
71 #include <sys/fs/zfs.h>
72 #include <sys/zfs_ctldir.h>
73 #include <sys/zfs_dir.h>
74 #include <sys/zfs_onexit.h>
75 #include <sys/zvol.h>
76 #include <sys/dsl_scan.h>
77 #include <sys/dmu_objset.h>
78 #include <sys/dmu_send.h>
79 #include <sys/dsl_destroy.h>
80 #include <sys/dsl_bookmark.h>
81 #include <sys/dsl_userhold.h>
82 #include <sys/zfeature.h>
83 #include <sys/zcp.h>
84 #include <sys/zio_checksum.h>
85 #include <sys/vdev_removal.h>
86 #include <sys/dsl_crypt.h>
87
88 #include <sys/zfs_ioctl_compat.h>
89 #include <sys/zfs_context.h>
90
91 #include <sys/arc_impl.h>
92 #include <sys/dsl_pool.h>
93
94
95 /* BEGIN CSTYLED */
96 SYSCTL_DECL(_vfs_zfs);
97 SYSCTL_NODE(_vfs_zfs, OID_AUTO, arc, CTLFLAG_RW, 0, "ZFS adaptive replacement cache");
98 SYSCTL_NODE(_vfs_zfs, OID_AUTO, condense, CTLFLAG_RW, 0, "ZFS condense");
99 SYSCTL_NODE(_vfs_zfs, OID_AUTO, dbuf, CTLFLAG_RW, 0, "ZFS disk buf cache");
100 SYSCTL_NODE(_vfs_zfs, OID_AUTO, dbuf_cache, CTLFLAG_RW, 0, "ZFS disk buf cache");
101 SYSCTL_NODE(_vfs_zfs, OID_AUTO, deadman, CTLFLAG_RW, 0, "ZFS deadman");
102 SYSCTL_NODE(_vfs_zfs, OID_AUTO, dedup, CTLFLAG_RW, 0, "ZFS dedup");
103 SYSCTL_NODE(_vfs_zfs, OID_AUTO, l2arc, CTLFLAG_RW, 0, "ZFS l2arc");
104 SYSCTL_NODE(_vfs_zfs, OID_AUTO, livelist, CTLFLAG_RW, 0, "ZFS livelist");
105 SYSCTL_NODE(_vfs_zfs, OID_AUTO, lua, CTLFLAG_RW, 0, "ZFS lua");
106 SYSCTL_NODE(_vfs_zfs, OID_AUTO, metaslab, CTLFLAG_RW, 0, "ZFS metaslab");
107 SYSCTL_NODE(_vfs_zfs, OID_AUTO, mg, CTLFLAG_RW, 0, "ZFS metaslab group");
108 SYSCTL_NODE(_vfs_zfs, OID_AUTO, multihost, CTLFLAG_RW, 0, "ZFS multihost protection");
109 SYSCTL_NODE(_vfs_zfs, OID_AUTO, prefetch, CTLFLAG_RW, 0, "ZFS prefetch");
110 SYSCTL_NODE(_vfs_zfs, OID_AUTO, reconstruct, CTLFLAG_RW, 0, "ZFS reconstruct");
111 SYSCTL_NODE(_vfs_zfs, OID_AUTO, recv, CTLFLAG_RW, 0, "ZFS receive");
112 SYSCTL_NODE(_vfs_zfs, OID_AUTO, send, CTLFLAG_RW, 0, "ZFS send");
113 SYSCTL_NODE(_vfs_zfs, OID_AUTO, spa, CTLFLAG_RW, 0, "ZFS space allocation");
114 SYSCTL_NODE(_vfs_zfs, OID_AUTO, trim, CTLFLAG_RW, 0, "ZFS TRIM");
115 SYSCTL_NODE(_vfs_zfs, OID_AUTO, txg, CTLFLAG_RW, 0, "ZFS transaction group");
116 SYSCTL_NODE(_vfs_zfs, OID_AUTO, vdev, CTLFLAG_RW, 0, "ZFS VDEV");
117 SYSCTL_NODE(_vfs_zfs, OID_AUTO, vnops, CTLFLAG_RW, 0, "ZFS VNOPS");
118 SYSCTL_NODE(_vfs_zfs, OID_AUTO, zevent, CTLFLAG_RW, 0, "ZFS event");
119 SYSCTL_NODE(_vfs_zfs, OID_AUTO, zil, CTLFLAG_RW, 0, "ZFS ZIL");
120 SYSCTL_NODE(_vfs_zfs, OID_AUTO, zio, CTLFLAG_RW, 0, "ZFS ZIO");
121
122 SYSCTL_NODE(_vfs_zfs_livelist, OID_AUTO, condense, CTLFLAG_RW, 0,
123 "ZFS livelist condense");
124 SYSCTL_NODE(_vfs_zfs_vdev, OID_AUTO, cache, CTLFLAG_RW, 0, "ZFS VDEV Cache");
125 SYSCTL_NODE(_vfs_zfs_vdev, OID_AUTO, file, CTLFLAG_RW, 0, "ZFS VDEV file");
126 SYSCTL_NODE(_vfs_zfs_vdev, OID_AUTO, mirror, CTLFLAG_RD, 0,
127 "ZFS VDEV mirror");
128
129 SYSCTL_DECL(_vfs_zfs_version);
130 SYSCTL_CONST_STRING(_vfs_zfs_version, OID_AUTO, module, CTLFLAG_RD,
131 (ZFS_META_VERSION "-" ZFS_META_RELEASE), "OpenZFS module version");
132
133 extern arc_state_t ARC_anon;
134 extern arc_state_t ARC_mru;
135 extern arc_state_t ARC_mru_ghost;
136 extern arc_state_t ARC_mfu;
137 extern arc_state_t ARC_mfu_ghost;
138 extern arc_state_t ARC_l2c_only;
139
140 /*
141 * minimum lifespan of a prefetch block in clock ticks
142 * (initialized in arc_init())
143 */
144
145 /* arc.c */
146
147 int
param_set_arc_max(SYSCTL_HANDLER_ARGS)148 param_set_arc_max(SYSCTL_HANDLER_ARGS)
149 {
150 uint64_t val;
151 int err;
152
153 val = zfs_arc_max;
154 err = sysctl_handle_long(oidp, &val, 0, req);
155 if (err != 0 || req->newptr == NULL)
156 return (SET_ERROR(err));
157
158 if (val != 0 && (val < MIN_ARC_MAX || val <= arc_c_min ||
159 val >= arc_all_memory()))
160 return (SET_ERROR(EINVAL));
161
162 zfs_arc_max = val;
163 arc_tuning_update(B_TRUE);
164
165 /* Update the sysctl to the tuned value */
166 if (val != 0)
167 zfs_arc_max = arc_c_max;
168
169 return (0);
170 }
171
172 int
param_set_arc_min(SYSCTL_HANDLER_ARGS)173 param_set_arc_min(SYSCTL_HANDLER_ARGS)
174 {
175 uint64_t val;
176 int err;
177
178 val = zfs_arc_min;
179 err = sysctl_handle_64(oidp, &val, 0, req);
180 if (err != 0 || req->newptr == NULL)
181 return (SET_ERROR(err));
182
183 if (val != 0 && (val < 2ULL << SPA_MAXBLOCKSHIFT || val > arc_c_max))
184 return (SET_ERROR(EINVAL));
185
186 zfs_arc_min = val;
187 arc_tuning_update(B_TRUE);
188
189 /* Update the sysctl to the tuned value */
190 if (val != 0)
191 zfs_arc_min = arc_c_min;
192
193 return (0);
194 }
195
196 /* legacy compat */
197 extern uint64_t l2arc_write_max; /* def max write size */
198 extern uint64_t l2arc_write_boost; /* extra warmup write */
199 extern uint64_t l2arc_headroom; /* # of dev writes */
200 extern uint64_t l2arc_headroom_boost;
201 extern uint64_t l2arc_feed_secs; /* interval seconds */
202 extern uint64_t l2arc_feed_min_ms; /* min interval msecs */
203 extern int l2arc_noprefetch; /* don't cache prefetch bufs */
204 extern int l2arc_feed_again; /* turbo warmup */
205 extern int l2arc_norw; /* no reads during writes */
206
207 SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, l2arc_write_max, CTLFLAG_RW,
208 &l2arc_write_max, 0, "max write size (LEGACY)");
209 SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, l2arc_write_boost, CTLFLAG_RW,
210 &l2arc_write_boost, 0, "extra write during warmup (LEGACY)");
211 SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, l2arc_headroom, CTLFLAG_RW,
212 &l2arc_headroom, 0, "number of dev writes (LEGACY)");
213 SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, l2arc_feed_secs, CTLFLAG_RW,
214 &l2arc_feed_secs, 0, "interval seconds (LEGACY)");
215 SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, l2arc_feed_min_ms, CTLFLAG_RW,
216 &l2arc_feed_min_ms, 0, "min interval milliseconds (LEGACY)");
217
218 SYSCTL_INT(_vfs_zfs, OID_AUTO, l2arc_noprefetch, CTLFLAG_RW,
219 &l2arc_noprefetch, 0, "don't cache prefetch bufs (LEGACY)");
220 SYSCTL_INT(_vfs_zfs, OID_AUTO, l2arc_feed_again, CTLFLAG_RW,
221 &l2arc_feed_again, 0, "turbo warmup (LEGACY)");
222 SYSCTL_INT(_vfs_zfs, OID_AUTO, l2arc_norw, CTLFLAG_RW,
223 &l2arc_norw, 0, "no reads during writes (LEGACY)");
224 #if 0
225 extern int zfs_compressed_arc_enabled;
226 SYSCTL_INT(_vfs_zfs, OID_AUTO, compressed_arc_enabled, CTLFLAG_RW,
227 &zfs_compressed_arc_enabled, 1, "compressed arc buffers (LEGACY)");
228 #endif
229
230 SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, anon_size, CTLFLAG_RD,
231 &ARC_anon.arcs_size.rc_count, 0, "size of anonymous state");
232 SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, anon_metadata_esize, CTLFLAG_RD,
233 &ARC_anon.arcs_esize[ARC_BUFC_METADATA].rc_count, 0,
234 "size of anonymous state");
235 SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, anon_data_esize, CTLFLAG_RD,
236 &ARC_anon.arcs_esize[ARC_BUFC_DATA].rc_count, 0,
237 "size of anonymous state");
238
239 SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, mru_size, CTLFLAG_RD,
240 &ARC_mru.arcs_size.rc_count, 0, "size of mru state");
241 SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, mru_metadata_esize, CTLFLAG_RD,
242 &ARC_mru.arcs_esize[ARC_BUFC_METADATA].rc_count, 0,
243 "size of metadata in mru state");
244 SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, mru_data_esize, CTLFLAG_RD,
245 &ARC_mru.arcs_esize[ARC_BUFC_DATA].rc_count, 0,
246 "size of data in mru state");
247
248 SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, mru_ghost_size, CTLFLAG_RD,
249 &ARC_mru_ghost.arcs_size.rc_count, 0, "size of mru ghost state");
250 SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, mru_ghost_metadata_esize, CTLFLAG_RD,
251 &ARC_mru_ghost.arcs_esize[ARC_BUFC_METADATA].rc_count, 0,
252 "size of metadata in mru ghost state");
253 SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, mru_ghost_data_esize, CTLFLAG_RD,
254 &ARC_mru_ghost.arcs_esize[ARC_BUFC_DATA].rc_count, 0,
255 "size of data in mru ghost state");
256
257 SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, mfu_size, CTLFLAG_RD,
258 &ARC_mfu.arcs_size.rc_count, 0, "size of mfu state");
259 SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, mfu_metadata_esize, CTLFLAG_RD,
260 &ARC_mfu.arcs_esize[ARC_BUFC_METADATA].rc_count, 0,
261 "size of metadata in mfu state");
262 SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, mfu_data_esize, CTLFLAG_RD,
263 &ARC_mfu.arcs_esize[ARC_BUFC_DATA].rc_count, 0,
264 "size of data in mfu state");
265
266 SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, mfu_ghost_size, CTLFLAG_RD,
267 &ARC_mfu_ghost.arcs_size.rc_count, 0, "size of mfu ghost state");
268 SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, mfu_ghost_metadata_esize, CTLFLAG_RD,
269 &ARC_mfu_ghost.arcs_esize[ARC_BUFC_METADATA].rc_count, 0,
270 "size of metadata in mfu ghost state");
271 SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, mfu_ghost_data_esize, CTLFLAG_RD,
272 &ARC_mfu_ghost.arcs_esize[ARC_BUFC_DATA].rc_count, 0,
273 "size of data in mfu ghost state");
274
275 SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, l2c_only_size, CTLFLAG_RD,
276 &ARC_l2c_only.arcs_size.rc_count, 0, "size of mru state");
277
278 static int
sysctl_vfs_zfs_arc_no_grow_shift(SYSCTL_HANDLER_ARGS)279 sysctl_vfs_zfs_arc_no_grow_shift(SYSCTL_HANDLER_ARGS)
280 {
281 int err, val;
282
283 val = arc_no_grow_shift;
284 err = sysctl_handle_int(oidp, &val, 0, req);
285 if (err != 0 || req->newptr == NULL)
286 return (err);
287
288 if (val < 0 || val >= arc_shrink_shift)
289 return (EINVAL);
290
291 arc_no_grow_shift = val;
292 return (0);
293 }
294
295 SYSCTL_PROC(_vfs_zfs, OID_AUTO, arc_no_grow_shift,
296 CTLTYPE_INT | CTLFLAG_RWTUN | CTLFLAG_MPSAFE, NULL, sizeof (int),
297 sysctl_vfs_zfs_arc_no_grow_shift, "I",
298 "log2(fraction of ARC which must be free to allow growing)");
299
300 int
param_set_arc_long(SYSCTL_HANDLER_ARGS)301 param_set_arc_long(SYSCTL_HANDLER_ARGS)
302 {
303 int err;
304
305 err = sysctl_handle_long(oidp, arg1, 0, req);
306 if (err != 0 || req->newptr == NULL)
307 return (err);
308
309 arc_tuning_update(B_TRUE);
310
311 return (0);
312 }
313
314 int
param_set_arc_int(SYSCTL_HANDLER_ARGS)315 param_set_arc_int(SYSCTL_HANDLER_ARGS)
316 {
317 int err;
318
319 err = sysctl_handle_int(oidp, arg1, 0, req);
320 if (err != 0 || req->newptr == NULL)
321 return (err);
322
323 arc_tuning_update(B_TRUE);
324
325 return (0);
326 }
327
328 SYSCTL_PROC(_vfs_zfs, OID_AUTO, arc_min,
329 CTLTYPE_ULONG | CTLFLAG_RWTUN | CTLFLAG_MPSAFE,
330 &zfs_arc_min, sizeof (zfs_arc_min), param_set_arc_min, "LU",
331 "min arc size (LEGACY)");
332 SYSCTL_PROC(_vfs_zfs, OID_AUTO, arc_max,
333 CTLTYPE_ULONG | CTLFLAG_RWTUN | CTLFLAG_MPSAFE,
334 &zfs_arc_max, sizeof (zfs_arc_max), param_set_arc_max, "LU",
335 "max arc size (LEGACY)");
336
337 /* dbuf.c */
338
339
340 /* dmu.c */
341
342 /* dmu_zfetch.c */
343 SYSCTL_NODE(_vfs_zfs, OID_AUTO, zfetch, CTLFLAG_RW, 0, "ZFS ZFETCH (LEGACY)");
344
345 /* max bytes to prefetch per stream (default 8MB) */
346 extern uint32_t zfetch_max_distance;
347 SYSCTL_UINT(_vfs_zfs_zfetch, OID_AUTO, max_distance, CTLFLAG_RWTUN,
348 &zfetch_max_distance, 0, "Max bytes to prefetch per stream (LEGACY)");
349
350 /* max bytes to prefetch indirects for per stream (default 64MB) */
351 extern uint32_t zfetch_max_idistance;
352 SYSCTL_UINT(_vfs_zfs_zfetch, OID_AUTO, max_idistance, CTLFLAG_RWTUN,
353 &zfetch_max_idistance, 0,
354 "Max bytes to prefetch indirects for per stream (LEGACY)");
355
356 /* dsl_pool.c */
357
358 /* dnode.c */
359 extern int zfs_default_bs;
360 SYSCTL_INT(_vfs_zfs, OID_AUTO, default_bs, CTLFLAG_RWTUN,
361 &zfs_default_bs, 0, "Default dnode block shift");
362
363 extern int zfs_default_ibs;
364 SYSCTL_INT(_vfs_zfs, OID_AUTO, default_ibs, CTLFLAG_RWTUN,
365 &zfs_default_ibs, 0, "Default dnode indirect block shift");
366
367
368 /* dsl_scan.c */
369
370 /* metaslab.c */
371
372 /*
373 * In pools where the log space map feature is not enabled we touch
374 * multiple metaslabs (and their respective space maps) with each
375 * transaction group. Thus, we benefit from having a small space map
376 * block size since it allows us to issue more I/O operations scattered
377 * around the disk. So a sane default for the space map block size
378 * is 8~16K.
379 */
380 extern int zfs_metaslab_sm_blksz_no_log;
381 SYSCTL_INT(_vfs_zfs_metaslab, OID_AUTO, sm_blksz_no_log, CTLFLAG_RDTUN,
382 &zfs_metaslab_sm_blksz_no_log, 0,
383 "Block size for space map in pools with log space map disabled. "
384 "Power of 2 and greater than 4096.");
385
386 /*
387 * When the log space map feature is enabled, we accumulate a lot of
388 * changes per metaslab that are flushed once in a while so we benefit
389 * from a bigger block size like 128K for the metaslab space maps.
390 */
391 extern int zfs_metaslab_sm_blksz_with_log;
392 SYSCTL_INT(_vfs_zfs_metaslab, OID_AUTO, sm_blksz_with_log, CTLFLAG_RDTUN,
393 &zfs_metaslab_sm_blksz_with_log, 0,
394 "Block size for space map in pools with log space map enabled. "
395 "Power of 2 and greater than 4096.");
396
397 /*
398 * The in-core space map representation is more compact than its on-disk form.
399 * The zfs_condense_pct determines how much more compact the in-core
400 * space map representation must be before we compact it on-disk.
401 * Values should be greater than or equal to 100.
402 */
403 extern int zfs_condense_pct;
404 SYSCTL_INT(_vfs_zfs, OID_AUTO, condense_pct, CTLFLAG_RWTUN,
405 &zfs_condense_pct, 0,
406 "Condense on-disk spacemap when it is more than this many percents"
407 " of in-memory counterpart");
408
409 extern int zfs_remove_max_segment;
410 SYSCTL_INT(_vfs_zfs, OID_AUTO, remove_max_segment, CTLFLAG_RWTUN,
411 &zfs_remove_max_segment, 0, "Largest contiguous segment ZFS will attempt to"
412 " allocate when removing a device");
413
414 extern int zfs_removal_suspend_progress;
415 SYSCTL_INT(_vfs_zfs, OID_AUTO, removal_suspend_progress, CTLFLAG_RWTUN,
416 &zfs_removal_suspend_progress, 0, "Ensures certain actions can happen while"
417 " in the middle of a removal");
418
419
420 /*
421 * Minimum size which forces the dynamic allocator to change
422 * it's allocation strategy. Once the space map cannot satisfy
423 * an allocation of this size then it switches to using more
424 * aggressive strategy (i.e search by size rather than offset).
425 */
426 extern uint64_t metaslab_df_alloc_threshold;
427 SYSCTL_QUAD(_vfs_zfs_metaslab, OID_AUTO, df_alloc_threshold, CTLFLAG_RWTUN,
428 &metaslab_df_alloc_threshold, 0,
429 "Minimum size which forces the dynamic allocator to change it's allocation strategy");
430
431 /*
432 * The minimum free space, in percent, which must be available
433 * in a space map to continue allocations in a first-fit fashion.
434 * Once the space map's free space drops below this level we dynamically
435 * switch to using best-fit allocations.
436 */
437 extern int metaslab_df_free_pct;
438 SYSCTL_INT(_vfs_zfs_metaslab, OID_AUTO, df_free_pct, CTLFLAG_RWTUN,
439 &metaslab_df_free_pct, 0,
440 "The minimum free space, in percent, which must be available in a "
441 "space map to continue allocations in a first-fit fashion");
442
443 /*
444 * Percentage of all cpus that can be used by the metaslab taskq.
445 */
446 extern int metaslab_load_pct;
447 SYSCTL_INT(_vfs_zfs_metaslab, OID_AUTO, load_pct, CTLFLAG_RWTUN,
448 &metaslab_load_pct, 0,
449 "Percentage of cpus that can be used by the metaslab taskq");
450
451 /*
452 * Max number of metaslabs per group to preload.
453 */
454 extern int metaslab_preload_limit;
455 SYSCTL_INT(_vfs_zfs_metaslab, OID_AUTO, preload_limit, CTLFLAG_RWTUN,
456 &metaslab_preload_limit, 0,
457 "Max number of metaslabs per group to preload");
458
459 /* spa.c */
460 extern int zfs_ccw_retry_interval;
461 SYSCTL_INT(_vfs_zfs, OID_AUTO, ccw_retry_interval, CTLFLAG_RWTUN,
462 &zfs_ccw_retry_interval, 0,
463 "Configuration cache file write, retry after failure, interval (seconds)");
464
465 extern uint64_t zfs_max_missing_tvds_cachefile;
466 SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, max_missing_tvds_cachefile, CTLFLAG_RWTUN,
467 &zfs_max_missing_tvds_cachefile, 0,
468 "allow importing pools with missing top-level vdevs in cache file");
469
470 extern uint64_t zfs_max_missing_tvds_scan;
471 SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, max_missing_tvds_scan, CTLFLAG_RWTUN,
472 &zfs_max_missing_tvds_scan, 0,
473 "allow importing pools with missing top-level vdevs during scan");
474
475 /* spa_misc.c */
476 extern int zfs_flags;
477 static int
sysctl_vfs_zfs_debug_flags(SYSCTL_HANDLER_ARGS)478 sysctl_vfs_zfs_debug_flags(SYSCTL_HANDLER_ARGS)
479 {
480 int err, val;
481
482 val = zfs_flags;
483 err = sysctl_handle_int(oidp, &val, 0, req);
484 if (err != 0 || req->newptr == NULL)
485 return (err);
486
487 /*
488 * ZFS_DEBUG_MODIFY must be enabled prior to boot so all
489 * arc buffers in the system have the necessary additional
490 * checksum data. However, it is safe to disable at any
491 * time.
492 */
493 if (!(zfs_flags & ZFS_DEBUG_MODIFY))
494 val &= ~ZFS_DEBUG_MODIFY;
495 zfs_flags = val;
496
497 return (0);
498 }
499
500 SYSCTL_PROC(_vfs_zfs, OID_AUTO, debugflags,
501 CTLTYPE_UINT | CTLFLAG_MPSAFE | CTLFLAG_RWTUN, NULL, 0,
502 sysctl_vfs_zfs_debug_flags, "IU", "Debug flags for ZFS testing.");
503
504 int
param_set_deadman_synctime(SYSCTL_HANDLER_ARGS)505 param_set_deadman_synctime(SYSCTL_HANDLER_ARGS)
506 {
507 unsigned long val;
508 int err;
509
510 val = zfs_deadman_synctime_ms;
511 err = sysctl_handle_long(oidp, &val, 0, req);
512 if (err != 0 || req->newptr == NULL)
513 return (err);
514 zfs_deadman_synctime_ms = val;
515
516 spa_set_deadman_synctime(MSEC2NSEC(zfs_deadman_synctime_ms));
517
518 return (0);
519 }
520
521 int
param_set_deadman_ziotime(SYSCTL_HANDLER_ARGS)522 param_set_deadman_ziotime(SYSCTL_HANDLER_ARGS)
523 {
524 unsigned long val;
525 int err;
526
527 val = zfs_deadman_ziotime_ms;
528 err = sysctl_handle_long(oidp, &val, 0, req);
529 if (err != 0 || req->newptr == NULL)
530 return (err);
531 zfs_deadman_ziotime_ms = val;
532
533 spa_set_deadman_ziotime(MSEC2NSEC(zfs_deadman_synctime_ms));
534
535 return (0);
536 }
537
538 int
param_set_deadman_failmode(SYSCTL_HANDLER_ARGS)539 param_set_deadman_failmode(SYSCTL_HANDLER_ARGS)
540 {
541 char buf[16];
542 int rc;
543
544 if (req->newptr == NULL)
545 strlcpy(buf, zfs_deadman_failmode, sizeof (buf));
546
547 rc = sysctl_handle_string(oidp, buf, sizeof (buf), req);
548 if (rc || req->newptr == NULL)
549 return (rc);
550 if (strcmp(buf, zfs_deadman_failmode) == 0)
551 return (0);
552 if (!strcmp(buf, "wait"))
553 zfs_deadman_failmode = "wait";
554 if (!strcmp(buf, "continue"))
555 zfs_deadman_failmode = "continue";
556 if (!strcmp(buf, "panic"))
557 zfs_deadman_failmode = "panic";
558
559 return (-param_set_deadman_failmode_common(buf));
560 }
561
562
563 /* spacemap.c */
564 extern int space_map_ibs;
565 SYSCTL_INT(_vfs_zfs, OID_AUTO, space_map_ibs, CTLFLAG_RWTUN,
566 &space_map_ibs, 0, "Space map indirect block shift");
567
568
569 /* vdev.c */
570 int
param_set_min_auto_ashift(SYSCTL_HANDLER_ARGS)571 param_set_min_auto_ashift(SYSCTL_HANDLER_ARGS)
572 {
573 uint64_t val;
574 int err;
575
576 val = zfs_vdev_min_auto_ashift;
577 err = sysctl_handle_64(oidp, &val, 0, req);
578 if (err != 0 || req->newptr == NULL)
579 return (SET_ERROR(err));
580
581 if (val < ASHIFT_MIN || val > zfs_vdev_max_auto_ashift)
582 return (SET_ERROR(EINVAL));
583
584 zfs_vdev_min_auto_ashift = val;
585
586 return (0);
587 }
588
589 int
param_set_max_auto_ashift(SYSCTL_HANDLER_ARGS)590 param_set_max_auto_ashift(SYSCTL_HANDLER_ARGS)
591 {
592 uint64_t val;
593 int err;
594
595 val = zfs_vdev_max_auto_ashift;
596 err = sysctl_handle_64(oidp, &val, 0, req);
597 if (err != 0 || req->newptr == NULL)
598 return (SET_ERROR(err));
599
600 if (val > ASHIFT_MAX || val < zfs_vdev_min_auto_ashift)
601 return (SET_ERROR(EINVAL));
602
603 zfs_vdev_max_auto_ashift = val;
604
605 return (0);
606 }
607
608 SYSCTL_PROC(_vfs_zfs, OID_AUTO, min_auto_ashift,
609 CTLTYPE_U64 | CTLFLAG_RWTUN | CTLFLAG_MPSAFE,
610 &zfs_vdev_min_auto_ashift, sizeof (zfs_vdev_min_auto_ashift),
611 param_set_min_auto_ashift, "QU",
612 "Min ashift used when creating new top-level vdev. (LEGACY)");
613 SYSCTL_PROC(_vfs_zfs, OID_AUTO, max_auto_ashift,
614 CTLTYPE_U64 | CTLFLAG_RWTUN | CTLFLAG_MPSAFE,
615 &zfs_vdev_max_auto_ashift, sizeof (zfs_vdev_max_auto_ashift),
616 param_set_max_auto_ashift, "QU",
617 "Max ashift used when optimizing for logical -> physical sector size on "
618 "new top-level vdevs. (LEGACY)");
619
620 /*
621 * Since the DTL space map of a vdev is not expected to have a lot of
622 * entries, we default its block size to 4K.
623 */
624 extern int zfs_vdev_dtl_sm_blksz;
625 SYSCTL_INT(_vfs_zfs, OID_AUTO, dtl_sm_blksz, CTLFLAG_RDTUN,
626 &zfs_vdev_dtl_sm_blksz, 0,
627 "Block size for DTL space map. Power of 2 and greater than 4096.");
628
629 /*
630 * vdev-wide space maps that have lots of entries written to them at
631 * the end of each transaction can benefit from a higher I/O bandwidth
632 * (e.g. vdev_obsolete_sm), thus we default their block size to 128K.
633 */
634 extern int zfs_vdev_standard_sm_blksz;
635 SYSCTL_INT(_vfs_zfs, OID_AUTO, standard_sm_blksz, CTLFLAG_RDTUN,
636 &zfs_vdev_standard_sm_blksz, 0,
637 "Block size for standard space map. Power of 2 and greater than 4096.");
638
639 extern int vdev_validate_skip;
640 SYSCTL_INT(_vfs_zfs, OID_AUTO, validate_skip, CTLFLAG_RDTUN,
641 &vdev_validate_skip, 0,
642 "Enable to bypass vdev_validate().");
643
644
645 /* vdev_cache.c */
646
647 /* vdev_mirror.c */
648 /*
649 * The load configuration settings below are tuned by default for
650 * the case where all devices are of the same rotational type.
651 *
652 * If there is a mixture of rotating and non-rotating media, setting
653 * non_rotating_seek_inc to 0 may well provide better results as it
654 * will direct more reads to the non-rotating vdevs which are more
655 * likely to have a higher performance.
656 */
657
658
659 /* vdev_queue.c */
660 #define ZFS_VDEV_QUEUE_KNOB_MIN(name) \
661 extern uint32_t zfs_vdev_ ## name ## _min_active; \
662 SYSCTL_UINT(_vfs_zfs_vdev, OID_AUTO, name ## _min_active, CTLFLAG_RWTUN,\
663 &zfs_vdev_ ## name ## _min_active, 0, \
664 "Initial number of I/O requests of type " #name \
665 " active for each device");
666
667 #define ZFS_VDEV_QUEUE_KNOB_MAX(name) \
668 extern uint32_t zfs_vdev_ ## name ## _max_active; \
669 SYSCTL_UINT(_vfs_zfs_vdev, OID_AUTO, name ## _max_active, CTLFLAG_RWTUN, \
670 &zfs_vdev_ ## name ## _max_active, 0, \
671 "Maximum number of I/O requests of type " #name \
672 " active for each device");
673
674
675 #undef ZFS_VDEV_QUEUE_KNOB
676
677 extern uint32_t zfs_vdev_max_active;
678 SYSCTL_UINT(_vfs_zfs, OID_AUTO, top_maxinflight, CTLFLAG_RWTUN,
679 &zfs_vdev_max_active, 0,
680 "The maximum number of I/Os of all types active for each device. (LEGACY)");
681
682 extern int zfs_vdev_def_queue_depth;
683 SYSCTL_INT(_vfs_zfs_vdev, OID_AUTO, def_queue_depth, CTLFLAG_RWTUN,
684 &zfs_vdev_def_queue_depth, 0,
685 "Default queue depth for each allocator");
686
687 /*extern uint64_t zfs_multihost_history;
688 SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, multihost_history, CTLFLAG_RWTUN,
689 &zfs_multihost_history, 0,
690 "Historical staticists for the last N multihost updates");*/
691
692 #ifdef notyet
693 SYSCTL_INT(_vfs_zfs_vdev, OID_AUTO, trim_on_init, CTLFLAG_RW,
694 &vdev_trim_on_init, 0, "Enable/disable full vdev trim on initialisation");
695 #endif
696
697
698 /* zio.c */
699 #if defined(__LP64__)
700 int zio_use_uma = 1;
701 #else
702 int zio_use_uma = 0;
703 #endif
704
705 SYSCTL_INT(_vfs_zfs_zio, OID_AUTO, use_uma, CTLFLAG_RDTUN, &zio_use_uma, 0,
706 "Use uma(9) for ZIO allocations");
707 SYSCTL_INT(_vfs_zfs_zio, OID_AUTO, exclude_metadata, CTLFLAG_RDTUN, &zio_exclude_metadata, 0,
708 "Exclude metadata buffers from dumps as well");
709
710 int
param_set_slop_shift(SYSCTL_HANDLER_ARGS)711 param_set_slop_shift(SYSCTL_HANDLER_ARGS)
712 {
713 int val;
714 int err;
715
716 val = *(int *)arg1;
717
718 err = sysctl_handle_int(oidp, &val, 0, req);
719 if (err != 0 || req->newptr == NULL)
720 return (err);
721
722 if (val < 1 || val > 31)
723 return (EINVAL);
724
725 *(int *)arg1 = val;
726
727 return (0);
728 }
729
730 int
param_set_multihost_interval(SYSCTL_HANDLER_ARGS)731 param_set_multihost_interval(SYSCTL_HANDLER_ARGS)
732 {
733 int err;
734
735 err = sysctl_handle_long(oidp, arg1, 0, req);
736 if (err != 0 || req->newptr == NULL)
737 return (err);
738
739 if (spa_mode_global != SPA_MODE_UNINIT)
740 mmp_signal_all_threads();
741
742 return (0);
743 }
744