1 // SPDX-License-Identifier: BSD-2-Clause
2 /*
3 * Copyright (c) 2020 iXsystems, Inc.
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND
16 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE
19 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25 * SUCH DAMAGE.
26 *
27 */
28
29 #include <sys/types.h>
30 #include <sys/param.h>
31 #include <sys/systm.h>
32 #include <sys/conf.h>
33 #include <sys/kernel.h>
34 #include <sys/lock.h>
35 #include <sys/malloc.h>
36 #include <sys/mutex.h>
37 #include <sys/proc.h>
38 #include <sys/errno.h>
39 #include <sys/uio.h>
40 #include <sys/buf.h>
41 #include <sys/file.h>
42 #include <sys/kmem.h>
43 #include <sys/conf.h>
44 #include <sys/cmn_err.h>
45 #include <sys/stat.h>
46 #include <sys/zfs_ioctl.h>
47 #include <sys/zfs_vfsops.h>
48 #include <sys/zfs_znode.h>
49 #include <sys/zap.h>
50 #include <sys/spa.h>
51 #include <sys/spa_impl.h>
52 #include <sys/vdev.h>
53 #include <sys/vdev_impl.h>
54 #include <sys/arc_os.h>
55 #include <sys/dmu.h>
56 #include <sys/dsl_dir.h>
57 #include <sys/dsl_dataset.h>
58 #include <sys/dsl_prop.h>
59 #include <sys/dsl_deleg.h>
60 #include <sys/dmu_objset.h>
61 #include <sys/dmu_impl.h>
62 #include <sys/dmu_tx.h>
63 #include <sys/sunddi.h>
64 #include <sys/policy.h>
65 #include <sys/zone.h>
66 #include <sys/nvpair.h>
67 #include <sys/mount.h>
68 #include <sys/taskqueue.h>
69 #include <sys/sdt.h>
70 #include <sys/fs/zfs.h>
71 #include <sys/zfs_ctldir.h>
72 #include <sys/zfs_dir.h>
73 #include <sys/zfs_onexit.h>
74 #include <sys/zvol.h>
75 #include <sys/dsl_scan.h>
76 #include <sys/dmu_objset.h>
77 #include <sys/dmu_send.h>
78 #include <sys/dsl_destroy.h>
79 #include <sys/dsl_bookmark.h>
80 #include <sys/dsl_userhold.h>
81 #include <sys/zfeature.h>
82 #include <sys/zcp.h>
83 #include <sys/zio_checksum.h>
84 #include <sys/vdev_removal.h>
85 #include <sys/dsl_crypt.h>
86
87 #include <sys/zfs_ioctl_compat.h>
88 #include <sys/zfs_context.h>
89
90 #include <sys/arc_impl.h>
91 #include <sys/dsl_pool.h>
92
93 #include <sys/vmmeter.h>
94
95 SYSCTL_DECL(_vfs_zfs);
96 SYSCTL_NODE(_vfs_zfs, OID_AUTO, arc, CTLFLAG_RW, 0,
97 "ZFS adaptive replacement cache");
98 SYSCTL_NODE(_vfs_zfs, OID_AUTO, brt, CTLFLAG_RW, 0,
99 "ZFS Block Reference Table");
100 SYSCTL_NODE(_vfs_zfs, OID_AUTO, condense, CTLFLAG_RW, 0, "ZFS condense");
101 SYSCTL_NODE(_vfs_zfs, OID_AUTO, dbuf, CTLFLAG_RW, 0, "ZFS disk buf cache");
102 SYSCTL_NODE(_vfs_zfs, OID_AUTO, dbuf_cache, CTLFLAG_RW, 0,
103 "ZFS disk buf cache");
104 SYSCTL_NODE(_vfs_zfs, OID_AUTO, deadman, CTLFLAG_RW, 0, "ZFS deadman");
105 SYSCTL_NODE(_vfs_zfs, OID_AUTO, dedup, CTLFLAG_RW, 0, "ZFS dedup");
106 SYSCTL_NODE(_vfs_zfs, OID_AUTO, l2arc, CTLFLAG_RW, 0, "ZFS l2arc");
107 SYSCTL_NODE(_vfs_zfs, OID_AUTO, livelist, CTLFLAG_RW, 0, "ZFS livelist");
108 SYSCTL_NODE(_vfs_zfs, OID_AUTO, lua, CTLFLAG_RW, 0, "ZFS lua");
109 SYSCTL_NODE(_vfs_zfs, OID_AUTO, metaslab, CTLFLAG_RW, 0, "ZFS metaslab");
110 SYSCTL_NODE(_vfs_zfs, OID_AUTO, mg, CTLFLAG_RW, 0, "ZFS metaslab group");
111 SYSCTL_NODE(_vfs_zfs, OID_AUTO, multihost, CTLFLAG_RW, 0,
112 "ZFS multihost protection");
113 SYSCTL_NODE(_vfs_zfs, OID_AUTO, prefetch, CTLFLAG_RW, 0, "ZFS prefetch");
114 SYSCTL_NODE(_vfs_zfs, OID_AUTO, reconstruct, CTLFLAG_RW, 0, "ZFS reconstruct");
115 SYSCTL_NODE(_vfs_zfs, OID_AUTO, recv, CTLFLAG_RW, 0, "ZFS receive");
116 SYSCTL_NODE(_vfs_zfs, OID_AUTO, send, CTLFLAG_RW, 0, "ZFS send");
117 SYSCTL_NODE(_vfs_zfs, OID_AUTO, spa, CTLFLAG_RW, 0, "ZFS space allocation");
118 SYSCTL_NODE(_vfs_zfs, OID_AUTO, trim, CTLFLAG_RW, 0, "ZFS TRIM");
119 SYSCTL_NODE(_vfs_zfs, OID_AUTO, txg, CTLFLAG_RW, 0, "ZFS transaction group");
120 SYSCTL_NODE(_vfs_zfs, OID_AUTO, vdev, CTLFLAG_RW, 0, "ZFS VDEV");
121 SYSCTL_NODE(_vfs_zfs, OID_AUTO, vnops, CTLFLAG_RW, 0, "ZFS VNOPS");
122 SYSCTL_NODE(_vfs_zfs, OID_AUTO, zevent, CTLFLAG_RW, 0, "ZFS event");
123 SYSCTL_NODE(_vfs_zfs, OID_AUTO, zil, CTLFLAG_RW, 0, "ZFS ZIL");
124 SYSCTL_NODE(_vfs_zfs, OID_AUTO, zio, CTLFLAG_RW, 0, "ZFS ZIO");
125
126 SYSCTL_NODE(_vfs_zfs_livelist, OID_AUTO, condense, CTLFLAG_RW, 0,
127 "ZFS livelist condense");
128 SYSCTL_NODE(_vfs_zfs_vdev, OID_AUTO, file, CTLFLAG_RW, 0, "ZFS VDEV file");
129 SYSCTL_NODE(_vfs_zfs_vdev, OID_AUTO, mirror, CTLFLAG_RD, 0,
130 "ZFS VDEV mirror");
131
132 SYSCTL_DECL(_vfs_zfs_version);
133 SYSCTL_CONST_STRING(_vfs_zfs_version, OID_AUTO, module, CTLFLAG_RD,
134 (ZFS_META_VERSION "-" ZFS_META_RELEASE), "OpenZFS module version");
135
136 /* arc.c */
137
138 int
param_set_arc_u64(SYSCTL_HANDLER_ARGS)139 param_set_arc_u64(SYSCTL_HANDLER_ARGS)
140 {
141 int err;
142
143 err = sysctl_handle_64(oidp, arg1, 0, req);
144 if (err != 0 || req->newptr == NULL)
145 return (err);
146
147 arc_tuning_update(B_TRUE);
148
149 return (0);
150 }
151
152 int
param_set_arc_int(SYSCTL_HANDLER_ARGS)153 param_set_arc_int(SYSCTL_HANDLER_ARGS)
154 {
155 int err;
156
157 err = sysctl_handle_int(oidp, arg1, 0, req);
158 if (err != 0 || req->newptr == NULL)
159 return (err);
160
161 arc_tuning_update(B_TRUE);
162
163 return (0);
164 }
165
166 static void
warn_deprecated_sysctl(const char * old,const char * new)167 warn_deprecated_sysctl(const char *old, const char *new)
168 {
169 printf("WARNING: sysctl vfs.zfs.%s is deprecated. Use vfs.zfs.%s instead.\n",
170 old, new);
171 }
172
173 int
param_set_l2arc_dwpd_limit(SYSCTL_HANDLER_ARGS)174 param_set_l2arc_dwpd_limit(SYSCTL_HANDLER_ARGS)
175 {
176 uint64_t old_val = l2arc_dwpd_limit;
177 int err;
178
179 err = sysctl_handle_64(oidp, arg1, 0, req);
180 if (err != 0 || req->newptr == NULL)
181 return (err);
182
183 if (l2arc_dwpd_limit != old_val)
184 l2arc_dwpd_bump_reset();
185
186 return (0);
187 }
188
189 int
param_set_arc_max(SYSCTL_HANDLER_ARGS)190 param_set_arc_max(SYSCTL_HANDLER_ARGS)
191 {
192 unsigned long val;
193 int err;
194
195 val = zfs_arc_max;
196 err = sysctl_handle_64(oidp, &val, 0, req);
197 if (err != 0 || req->newptr == NULL)
198 return (SET_ERROR(err));
199
200 if (val != 0 && (val < MIN_ARC_MAX || val <= arc_c_min ||
201 val >= arc_all_memory()))
202 return (SET_ERROR(EINVAL));
203
204 zfs_arc_max = val;
205 arc_tuning_update(B_TRUE);
206
207 /* Update the sysctl to the tuned value */
208 if (val != 0)
209 zfs_arc_max = arc_c_max;
210
211 if (arg2 != 0)
212 warn_deprecated_sysctl("arc_max", "arc.max");
213
214 return (0);
215 }
216
217 SYSCTL_PROC(_vfs_zfs, OID_AUTO, arc_max,
218 CTLTYPE_ULONG | CTLFLAG_RWTUN | CTLFLAG_MPSAFE,
219 NULL, 1, param_set_arc_max, "LU",
220 "Maximum ARC size in bytes (LEGACY)");
221
222 int
param_set_arc_min(SYSCTL_HANDLER_ARGS)223 param_set_arc_min(SYSCTL_HANDLER_ARGS)
224 {
225 unsigned long val;
226 int err;
227
228 val = zfs_arc_min;
229 err = sysctl_handle_64(oidp, &val, 0, req);
230 if (err != 0 || req->newptr == NULL)
231 return (SET_ERROR(err));
232
233 if (val != 0 && (val < 2ULL << SPA_MAXBLOCKSHIFT || val > arc_c_max))
234 return (SET_ERROR(EINVAL));
235
236 zfs_arc_min = val;
237 arc_tuning_update(B_TRUE);
238
239 /* Update the sysctl to the tuned value */
240 if (val != 0)
241 zfs_arc_min = arc_c_min;
242
243 if (arg2 != 0)
244 warn_deprecated_sysctl("arc_min", "arc.min");
245
246 return (0);
247 }
248
249 SYSCTL_PROC(_vfs_zfs, OID_AUTO, arc_min,
250 CTLTYPE_ULONG | CTLFLAG_RWTUN | CTLFLAG_MPSAFE,
251 NULL, 1, param_set_arc_min, "LU",
252 "Minimum ARC size in bytes (LEGACY)");
253
254 extern uint_t zfs_arc_free_target;
255
256 int
param_set_arc_free_target(SYSCTL_HANDLER_ARGS)257 param_set_arc_free_target(SYSCTL_HANDLER_ARGS)
258 {
259 uint_t val;
260 int err;
261
262 val = zfs_arc_free_target;
263 err = sysctl_handle_int(oidp, &val, 0, req);
264 if (err != 0 || req->newptr == NULL)
265 return (err);
266
267 if (val < minfree)
268 return (EINVAL);
269 if (val > vm_cnt.v_page_count)
270 return (EINVAL);
271
272 zfs_arc_free_target = val;
273
274 if (arg2 != 0)
275 warn_deprecated_sysctl("arc_free_target", "arc.free_target");
276
277 return (0);
278 }
279
280 /*
281 * NOTE: This sysctl is CTLFLAG_RW not CTLFLAG_RWTUN due to its dependency on
282 * pagedaemon initialization.
283 */
284 SYSCTL_PROC(_vfs_zfs, OID_AUTO, arc_free_target,
285 CTLTYPE_UINT | CTLFLAG_RW | CTLFLAG_MPSAFE,
286 NULL, 1, param_set_arc_free_target, "IU",
287 "Desired number of free pages below which ARC triggers reclaim"
288 " (LEGACY)");
289
290 int
param_set_arc_no_grow_shift(SYSCTL_HANDLER_ARGS)291 param_set_arc_no_grow_shift(SYSCTL_HANDLER_ARGS)
292 {
293 int err, val;
294
295 val = zfs_arc_no_grow_shift;
296 err = sysctl_handle_int(oidp, &val, 0, req);
297 if (err != 0 || req->newptr == NULL)
298 return (err);
299
300 if (val < 0 || val >= arc_shrink_shift)
301 return (EINVAL);
302
303 zfs_arc_no_grow_shift = val;
304
305 if (arg2 != 0)
306 warn_deprecated_sysctl("arc_no_grow_shift", "arc.no_grow_shift");
307
308 return (0);
309 }
310
311 SYSCTL_PROC(_vfs_zfs, OID_AUTO, arc_no_grow_shift,
312 CTLTYPE_INT | CTLFLAG_RWTUN | CTLFLAG_MPSAFE,
313 NULL, 1, param_set_arc_no_grow_shift, "I",
314 "log2(fraction of ARC which must be free to allow growing) (LEGACY)");
315
316 #if 0
317 extern uint64_t l2arc_write_max;
318
319 SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, l2arc_write_max,
320 CTLFLAG_RWTUN, &l2arc_write_max, 0,
321 "Max write bytes per interval (LEGACY)");
322
323 extern uint64_t l2arc_write_boost;
324
325 SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, l2arc_write_boost,
326 CTLFLAG_RWTUN, &l2arc_write_boost, 0,
327 "Extra write bytes during device warmup (LEGACY)");
328
329 extern uint64_t l2arc_headroom;
330
331 SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, l2arc_headroom,
332 CTLFLAG_RWTUN, &l2arc_headroom, 0,
333 "Number of max device writes to precache (LEGACY)");
334
335 extern uint64_t l2arc_headroom_boost;
336
337 SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, l2arc_headroom_boost,
338 CTLFLAG_RWTUN, &l2arc_headroom_boost, 0,
339 "Compressed l2arc_headroom multiplier (LEGACY)");
340
341 extern uint64_t l2arc_feed_secs;
342
343 SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, l2arc_feed_secs,
344 CTLFLAG_RWTUN, &l2arc_feed_secs, 0,
345 "Seconds between L2ARC writing (LEGACY)");
346
347 extern uint64_t l2arc_feed_min_ms;
348
349 SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, l2arc_feed_min_ms,
350 CTLFLAG_RWTUN, &l2arc_feed_min_ms, 0,
351 "Min feed interval in milliseconds (LEGACY)");
352
353 extern int l2arc_noprefetch;
354
355 SYSCTL_INT(_vfs_zfs, OID_AUTO, l2arc_noprefetch,
356 CTLFLAG_RWTUN, &l2arc_noprefetch, 0,
357 "Skip caching prefetched buffers (LEGACY)");
358
359 extern int l2arc_feed_again;
360
361 SYSCTL_INT(_vfs_zfs, OID_AUTO, l2arc_feed_again,
362 CTLFLAG_RWTUN, &l2arc_feed_again, 0,
363 "Turbo L2ARC warmup (LEGACY)");
364
365 extern int l2arc_norw;
366
367 SYSCTL_INT(_vfs_zfs, OID_AUTO, l2arc_norw,
368 CTLFLAG_RWTUN, &l2arc_norw, 0,
369 "No reads during writes (LEGACY)");
370
371 #endif
372
373 static int
param_get_arc_state_size(SYSCTL_HANDLER_ARGS)374 param_get_arc_state_size(SYSCTL_HANDLER_ARGS)
375 {
376 arc_state_t *state = (arc_state_t *)arg1;
377 int64_t val;
378
379 val = zfs_refcount_count(&state->arcs_size[ARC_BUFC_DATA]) +
380 zfs_refcount_count(&state->arcs_size[ARC_BUFC_METADATA]);
381 return (sysctl_handle_64(oidp, &val, 0, req));
382 }
383
384 extern arc_state_t ARC_anon;
385
386 SYSCTL_PROC(_vfs_zfs, OID_AUTO, anon_size,
387 CTLTYPE_S64 | CTLFLAG_RD | CTLFLAG_MPSAFE,
388 &ARC_anon, 0, param_get_arc_state_size, "Q",
389 "size of anonymous state");
390 SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, anon_metadata_esize, CTLFLAG_RD,
391 &ARC_anon.arcs_esize[ARC_BUFC_METADATA].rc_count, 0,
392 "size of evictable metadata in anonymous state");
393 SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, anon_data_esize, CTLFLAG_RD,
394 &ARC_anon.arcs_esize[ARC_BUFC_DATA].rc_count, 0,
395 "size of evictable data in anonymous state");
396
397 extern arc_state_t ARC_mru;
398
399 SYSCTL_PROC(_vfs_zfs, OID_AUTO, mru_size,
400 CTLTYPE_S64 | CTLFLAG_RD | CTLFLAG_MPSAFE,
401 &ARC_mru, 0, param_get_arc_state_size, "Q",
402 "size of mru state");
403 SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, mru_metadata_esize, CTLFLAG_RD,
404 &ARC_mru.arcs_esize[ARC_BUFC_METADATA].rc_count, 0,
405 "size of evictable metadata in mru state");
406 SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, mru_data_esize, CTLFLAG_RD,
407 &ARC_mru.arcs_esize[ARC_BUFC_DATA].rc_count, 0,
408 "size of evictable data in mru state");
409
410 extern arc_state_t ARC_mru_ghost;
411
412 SYSCTL_PROC(_vfs_zfs, OID_AUTO, mru_ghost_size,
413 CTLTYPE_S64 | CTLFLAG_RD | CTLFLAG_MPSAFE,
414 &ARC_mru_ghost, 0, param_get_arc_state_size, "Q",
415 "size of mru ghost state");
416 SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, mru_ghost_metadata_esize, CTLFLAG_RD,
417 &ARC_mru_ghost.arcs_esize[ARC_BUFC_METADATA].rc_count, 0,
418 "size of evictable metadata in mru ghost state");
419 SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, mru_ghost_data_esize, CTLFLAG_RD,
420 &ARC_mru_ghost.arcs_esize[ARC_BUFC_DATA].rc_count, 0,
421 "size of evictable data in mru ghost state");
422
423 extern arc_state_t ARC_mfu;
424
425 SYSCTL_PROC(_vfs_zfs, OID_AUTO, mfu_size,
426 CTLTYPE_S64 | CTLFLAG_RD | CTLFLAG_MPSAFE,
427 &ARC_mfu, 0, param_get_arc_state_size, "Q",
428 "size of mfu state");
429 SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, mfu_metadata_esize, CTLFLAG_RD,
430 &ARC_mfu.arcs_esize[ARC_BUFC_METADATA].rc_count, 0,
431 "size of evictable metadata in mfu state");
432 SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, mfu_data_esize, CTLFLAG_RD,
433 &ARC_mfu.arcs_esize[ARC_BUFC_DATA].rc_count, 0,
434 "size of evictable data in mfu state");
435
436 extern arc_state_t ARC_mfu_ghost;
437
438 SYSCTL_PROC(_vfs_zfs, OID_AUTO, mfu_ghost_size,
439 CTLTYPE_S64 | CTLFLAG_RD | CTLFLAG_MPSAFE,
440 &ARC_mfu_ghost, 0, param_get_arc_state_size, "Q",
441 "size of mfu ghost state");
442 SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, mfu_ghost_metadata_esize, CTLFLAG_RD,
443 &ARC_mfu_ghost.arcs_esize[ARC_BUFC_METADATA].rc_count, 0,
444 "size of evictable metadata in mfu ghost state");
445 SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, mfu_ghost_data_esize, CTLFLAG_RD,
446 &ARC_mfu_ghost.arcs_esize[ARC_BUFC_DATA].rc_count, 0,
447 "size of evictable data in mfu ghost state");
448
449 extern arc_state_t ARC_uncached;
450
451 SYSCTL_PROC(_vfs_zfs, OID_AUTO, uncached_size,
452 CTLTYPE_S64 | CTLFLAG_RD | CTLFLAG_MPSAFE,
453 &ARC_uncached, 0, param_get_arc_state_size, "Q",
454 "size of uncached state");
455 SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, uncached_metadata_esize, CTLFLAG_RD,
456 &ARC_uncached.arcs_esize[ARC_BUFC_METADATA].rc_count, 0,
457 "size of evictable metadata in uncached state");
458 SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, uncached_data_esize, CTLFLAG_RD,
459 &ARC_uncached.arcs_esize[ARC_BUFC_DATA].rc_count, 0,
460 "size of evictable data in uncached state");
461
462 extern arc_state_t ARC_l2c_only;
463
464 SYSCTL_PROC(_vfs_zfs, OID_AUTO, l2c_only_size,
465 CTLTYPE_S64 | CTLFLAG_RD | CTLFLAG_MPSAFE,
466 &ARC_l2c_only, 0, param_get_arc_state_size, "Q",
467 "size of l2c_only state");
468
469 /* dbuf.c */
470
471 /* dmu.c */
472
473 /* dmu_zfetch.c */
474
475 SYSCTL_NODE(_vfs_zfs, OID_AUTO, zfetch, CTLFLAG_RW, 0, "ZFS ZFETCH (LEGACY)");
476
477 extern uint32_t zfetch_max_distance;
478
479 SYSCTL_UINT(_vfs_zfs_zfetch, OID_AUTO, max_distance,
480 CTLFLAG_RWTUN, &zfetch_max_distance, 0,
481 "Max bytes to prefetch per stream (LEGACY)");
482
483 extern uint32_t zfetch_max_idistance;
484
485 SYSCTL_UINT(_vfs_zfs_zfetch, OID_AUTO, max_idistance,
486 CTLFLAG_RWTUN, &zfetch_max_idistance, 0,
487 "Max bytes to prefetch indirects for per stream (LEGACY)");
488
489 /* dsl_pool.c */
490
491 /* dnode.c */
492
493 /* dsl_scan.c */
494
495 /* metaslab.c */
496
497 int
param_set_active_allocator(SYSCTL_HANDLER_ARGS)498 param_set_active_allocator(SYSCTL_HANDLER_ARGS)
499 {
500 char buf[16];
501 int rc;
502
503 if (req->newptr == NULL)
504 strlcpy(buf, zfs_active_allocator, sizeof (buf));
505
506 rc = sysctl_handle_string(oidp, buf, sizeof (buf), req);
507 if (rc || req->newptr == NULL)
508 return (rc);
509 if (strcmp(buf, zfs_active_allocator) == 0)
510 return (0);
511
512 return (param_set_active_allocator_common(buf));
513 }
514
515 /*
516 * The in-core space map representation is more compact than its on-disk form.
517 * The zfs_metaslab_condense_pct determines how much more compact the in-core
518 * space map representation must be before we compact it on-disk.
519 * Values should be greater than or equal to 100.
520 */
521 extern uint_t zfs_metaslab_condense_pct;
522
523 SYSCTL_UINT(_vfs_zfs_metaslab, OID_AUTO, condense_pct,
524 CTLFLAG_RWTUN, &zfs_metaslab_condense_pct, 0,
525 "Condense on-disk spacemap when it is more than this many percents"
526 " of in-memory counterpart");
527
528 extern uint_t zfs_remove_max_segment;
529
530 SYSCTL_UINT(_vfs_zfs, OID_AUTO, remove_max_segment,
531 CTLFLAG_RWTUN, &zfs_remove_max_segment, 0,
532 "Largest contiguous segment ZFS will attempt to allocate when removing"
533 " a device");
534
535 extern int zfs_removal_suspend_progress;
536
537 SYSCTL_INT(_vfs_zfs, OID_AUTO, removal_suspend_progress,
538 CTLFLAG_RWTUN, &zfs_removal_suspend_progress, 0,
539 "Ensures certain actions can happen while in the middle of a removal");
540
541 /* mmp.c */
542
543 int
param_set_multihost_interval(SYSCTL_HANDLER_ARGS)544 param_set_multihost_interval(SYSCTL_HANDLER_ARGS)
545 {
546 int err;
547
548 err = sysctl_handle_64(oidp, &zfs_multihost_interval, 0, req);
549 if (err != 0 || req->newptr == NULL)
550 return (err);
551
552 if (spa_mode_global != SPA_MODE_UNINIT)
553 mmp_signal_all_threads();
554
555 return (0);
556 }
557
558 /* spa_misc.c */
559
560 extern int zfs_flags;
561
562 static int
sysctl_vfs_zfs_debug_flags(SYSCTL_HANDLER_ARGS)563 sysctl_vfs_zfs_debug_flags(SYSCTL_HANDLER_ARGS)
564 {
565 int err, val;
566
567 val = zfs_flags;
568 err = sysctl_handle_int(oidp, &val, 0, req);
569 if (err != 0 || req->newptr == NULL)
570 return (err);
571
572 /*
573 * ZFS_DEBUG_MODIFY must be enabled prior to boot so all
574 * arc buffers in the system have the necessary additional
575 * checksum data. However, it is safe to disable at any
576 * time.
577 */
578 if (!(zfs_flags & ZFS_DEBUG_MODIFY))
579 val &= ~ZFS_DEBUG_MODIFY;
580 zfs_flags = val;
581
582 return (0);
583 }
584
585 SYSCTL_PROC(_vfs_zfs, OID_AUTO, debugflags,
586 CTLTYPE_UINT | CTLFLAG_MPSAFE | CTLFLAG_RWTUN, NULL, 0,
587 sysctl_vfs_zfs_debug_flags, "IU", "Debug flags for ZFS testing.");
588
589 int
param_set_deadman_synctime(SYSCTL_HANDLER_ARGS)590 param_set_deadman_synctime(SYSCTL_HANDLER_ARGS)
591 {
592 unsigned long val;
593 int err;
594
595 val = zfs_deadman_synctime_ms;
596 err = sysctl_handle_64(oidp, &val, 0, req);
597 if (err != 0 || req->newptr == NULL)
598 return (err);
599 zfs_deadman_synctime_ms = val;
600
601 spa_set_deadman_synctime(MSEC2NSEC(zfs_deadman_synctime_ms));
602
603 return (0);
604 }
605
606 int
param_set_deadman_ziotime(SYSCTL_HANDLER_ARGS)607 param_set_deadman_ziotime(SYSCTL_HANDLER_ARGS)
608 {
609 unsigned long val;
610 int err;
611
612 val = zfs_deadman_ziotime_ms;
613 err = sysctl_handle_64(oidp, &val, 0, req);
614 if (err != 0 || req->newptr == NULL)
615 return (err);
616 zfs_deadman_ziotime_ms = val;
617
618 spa_set_deadman_ziotime(MSEC2NSEC(zfs_deadman_synctime_ms));
619
620 return (0);
621 }
622
623 int
param_set_deadman_failmode(SYSCTL_HANDLER_ARGS)624 param_set_deadman_failmode(SYSCTL_HANDLER_ARGS)
625 {
626 char buf[16];
627 int rc;
628
629 if (req->newptr == NULL)
630 strlcpy(buf, zfs_deadman_failmode, sizeof (buf));
631
632 rc = sysctl_handle_string(oidp, buf, sizeof (buf), req);
633 if (rc || req->newptr == NULL)
634 return (rc);
635 if (strcmp(buf, zfs_deadman_failmode) == 0)
636 return (0);
637 if (strcmp(buf, "wait") == 0)
638 zfs_deadman_failmode = "wait";
639 if (strcmp(buf, "continue") == 0)
640 zfs_deadman_failmode = "continue";
641 if (strcmp(buf, "panic") == 0)
642 zfs_deadman_failmode = "panic";
643
644 return (-param_set_deadman_failmode_common(buf));
645 }
646
647 int
param_set_raidz_impl(SYSCTL_HANDLER_ARGS)648 param_set_raidz_impl(SYSCTL_HANDLER_ARGS)
649 {
650 const size_t bufsize = 128;
651 char *buf;
652 int rc;
653
654 buf = malloc(bufsize, M_SOLARIS, M_WAITOK | M_ZERO);
655 if (req->newptr == NULL)
656 vdev_raidz_impl_get(buf, bufsize);
657
658 rc = sysctl_handle_string(oidp, buf, bufsize, req);
659 if (rc || req->newptr == NULL) {
660 free(buf, M_SOLARIS);
661 return (rc);
662 }
663 rc = vdev_raidz_impl_set(buf);
664 free(buf, M_SOLARIS);
665 return (rc);
666 }
667
668 int
param_set_slop_shift(SYSCTL_HANDLER_ARGS)669 param_set_slop_shift(SYSCTL_HANDLER_ARGS)
670 {
671 int val;
672 int err;
673
674 val = spa_slop_shift;
675 err = sysctl_handle_int(oidp, &val, 0, req);
676 if (err != 0 || req->newptr == NULL)
677 return (err);
678
679 if (val < 1 || val > 31)
680 return (EINVAL);
681
682 spa_slop_shift = val;
683
684 return (0);
685 }
686
687 /* spacemap.c */
688
689 extern int space_map_ibs;
690
691 SYSCTL_INT(_vfs_zfs, OID_AUTO, space_map_ibs, CTLFLAG_RWTUN,
692 &space_map_ibs, 0, "Space map indirect block shift");
693
694
695 /* vdev.c */
696
697 int
param_set_min_auto_ashift(SYSCTL_HANDLER_ARGS)698 param_set_min_auto_ashift(SYSCTL_HANDLER_ARGS)
699 {
700 int val;
701 int err;
702
703 val = zfs_vdev_min_auto_ashift;
704 err = sysctl_handle_int(oidp, &val, 0, req);
705 if (err != 0 || req->newptr == NULL)
706 return (SET_ERROR(err));
707
708 if (val < ASHIFT_MIN || val > zfs_vdev_max_auto_ashift)
709 return (SET_ERROR(EINVAL));
710
711 zfs_vdev_min_auto_ashift = val;
712
713 if (arg2 != 0)
714 warn_deprecated_sysctl("min_auto_ashift",
715 "vdev.min_auto_ashift");
716
717 return (0);
718 }
719
720 SYSCTL_PROC(_vfs_zfs, OID_AUTO, min_auto_ashift,
721 CTLTYPE_UINT | CTLFLAG_RWTUN | CTLFLAG_MPSAFE, NULL, 1,
722 param_set_min_auto_ashift, "IU",
723 "Min ashift used when creating new top-level vdev. (LEGACY)");
724
725 int
param_set_max_auto_ashift(SYSCTL_HANDLER_ARGS)726 param_set_max_auto_ashift(SYSCTL_HANDLER_ARGS)
727 {
728 int val;
729 int err;
730
731 val = zfs_vdev_max_auto_ashift;
732 err = sysctl_handle_int(oidp, &val, 0, req);
733 if (err != 0 || req->newptr == NULL)
734 return (SET_ERROR(err));
735
736 if (val > ASHIFT_MAX || val < zfs_vdev_min_auto_ashift)
737 return (SET_ERROR(EINVAL));
738
739 zfs_vdev_max_auto_ashift = val;
740
741 if (arg2 != 0)
742 warn_deprecated_sysctl("max_auto_ashift",
743 "vdev.max_auto_ashift");
744
745 return (0);
746 }
747
748 extern int vdev_validate_skip;
749
750 SYSCTL_INT(_vfs_zfs, OID_AUTO, validate_skip,
751 CTLFLAG_RDTUN, &vdev_validate_skip, 0,
752 "Enable to bypass vdev_validate().");
753
754 /* vdev_mirror.c */
755
756 /* vdev_queue.c */
757
758 extern uint_t zfs_vdev_max_active;
759
760 SYSCTL_UINT(_vfs_zfs, OID_AUTO, top_maxinflight,
761 CTLFLAG_RWTUN, &zfs_vdev_max_active, 0,
762 "The maximum number of I/Os of all types active for each device."
763 " (LEGACY)");
764
765 /* zio.c */
766
767 SYSCTL_INT(_vfs_zfs_zio, OID_AUTO, exclude_metadata,
768 CTLFLAG_RDTUN, &zio_exclude_metadata, 0,
769 "Exclude metadata buffers from dumps as well");
770