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_arc_max(SYSCTL_HANDLER_ARGS)174 param_set_arc_max(SYSCTL_HANDLER_ARGS)
175 {
176 unsigned long val;
177 int err;
178
179 val = zfs_arc_max;
180 err = sysctl_handle_64(oidp, &val, 0, req);
181 if (err != 0 || req->newptr == NULL)
182 return (SET_ERROR(err));
183
184 if (val != 0 && (val < MIN_ARC_MAX || val <= arc_c_min ||
185 val >= arc_all_memory()))
186 return (SET_ERROR(EINVAL));
187
188 zfs_arc_max = val;
189 arc_tuning_update(B_TRUE);
190
191 /* Update the sysctl to the tuned value */
192 if (val != 0)
193 zfs_arc_max = arc_c_max;
194
195 if (arg2 != 0)
196 warn_deprecated_sysctl("arc_max", "arc.max");
197
198 return (0);
199 }
200
201 SYSCTL_PROC(_vfs_zfs, OID_AUTO, arc_max,
202 CTLTYPE_ULONG | CTLFLAG_RWTUN | CTLFLAG_MPSAFE,
203 NULL, 1, param_set_arc_max, "LU",
204 "Maximum ARC size in bytes (LEGACY)");
205
206 int
param_set_arc_min(SYSCTL_HANDLER_ARGS)207 param_set_arc_min(SYSCTL_HANDLER_ARGS)
208 {
209 unsigned long val;
210 int err;
211
212 val = zfs_arc_min;
213 err = sysctl_handle_64(oidp, &val, 0, req);
214 if (err != 0 || req->newptr == NULL)
215 return (SET_ERROR(err));
216
217 if (val != 0 && (val < 2ULL << SPA_MAXBLOCKSHIFT || val > arc_c_max))
218 return (SET_ERROR(EINVAL));
219
220 zfs_arc_min = val;
221 arc_tuning_update(B_TRUE);
222
223 /* Update the sysctl to the tuned value */
224 if (val != 0)
225 zfs_arc_min = arc_c_min;
226
227 if (arg2 != 0)
228 warn_deprecated_sysctl("arc_min", "arc.min");
229
230 return (0);
231 }
232
233 SYSCTL_PROC(_vfs_zfs, OID_AUTO, arc_min,
234 CTLTYPE_ULONG | CTLFLAG_RWTUN | CTLFLAG_MPSAFE,
235 NULL, 1, param_set_arc_min, "LU",
236 "Minimum ARC size in bytes (LEGACY)");
237
238 extern uint_t zfs_arc_free_target;
239
240 int
param_set_arc_free_target(SYSCTL_HANDLER_ARGS)241 param_set_arc_free_target(SYSCTL_HANDLER_ARGS)
242 {
243 uint_t val;
244 int err;
245
246 val = zfs_arc_free_target;
247 err = sysctl_handle_int(oidp, &val, 0, req);
248 if (err != 0 || req->newptr == NULL)
249 return (err);
250
251 if (val < minfree)
252 return (EINVAL);
253 if (val > vm_cnt.v_page_count)
254 return (EINVAL);
255
256 zfs_arc_free_target = val;
257
258 if (arg2 != 0)
259 warn_deprecated_sysctl("arc_free_target", "arc.free_target");
260
261 return (0);
262 }
263
264 /*
265 * NOTE: This sysctl is CTLFLAG_RW not CTLFLAG_RWTUN due to its dependency on
266 * pagedaemon initialization.
267 */
268 SYSCTL_PROC(_vfs_zfs, OID_AUTO, arc_free_target,
269 CTLTYPE_UINT | CTLFLAG_RW | CTLFLAG_MPSAFE,
270 NULL, 1, param_set_arc_free_target, "IU",
271 "Desired number of free pages below which ARC triggers reclaim"
272 " (LEGACY)");
273
274 int
param_set_arc_no_grow_shift(SYSCTL_HANDLER_ARGS)275 param_set_arc_no_grow_shift(SYSCTL_HANDLER_ARGS)
276 {
277 int err, val;
278
279 val = arc_no_grow_shift;
280 err = sysctl_handle_int(oidp, &val, 0, req);
281 if (err != 0 || req->newptr == NULL)
282 return (err);
283
284 if (val < 0 || val >= arc_shrink_shift)
285 return (EINVAL);
286
287 arc_no_grow_shift = val;
288
289 if (arg2 != 0)
290 warn_deprecated_sysctl("arc_no_grow_shift", "arc.no_grow_shift");
291
292 return (0);
293 }
294
295 SYSCTL_PROC(_vfs_zfs, OID_AUTO, arc_no_grow_shift,
296 CTLTYPE_INT | CTLFLAG_RWTUN | CTLFLAG_MPSAFE,
297 NULL, 1, param_set_arc_no_grow_shift, "I",
298 "log2(fraction of ARC which must be free to allow growing) (LEGACY)");
299
300 extern uint64_t l2arc_write_max;
301
302 SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, l2arc_write_max,
303 CTLFLAG_RWTUN, &l2arc_write_max, 0,
304 "Max write bytes per interval (LEGACY)");
305
306 extern uint64_t l2arc_write_boost;
307
308 SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, l2arc_write_boost,
309 CTLFLAG_RWTUN, &l2arc_write_boost, 0,
310 "Extra write bytes during device warmup (LEGACY)");
311
312 extern uint64_t l2arc_headroom;
313
314 SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, l2arc_headroom,
315 CTLFLAG_RWTUN, &l2arc_headroom, 0,
316 "Number of max device writes to precache (LEGACY)");
317
318 extern uint64_t l2arc_headroom_boost;
319
320 SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, l2arc_headroom_boost,
321 CTLFLAG_RWTUN, &l2arc_headroom_boost, 0,
322 "Compressed l2arc_headroom multiplier (LEGACY)");
323
324 extern uint64_t l2arc_feed_secs;
325
326 SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, l2arc_feed_secs,
327 CTLFLAG_RWTUN, &l2arc_feed_secs, 0,
328 "Seconds between L2ARC writing (LEGACY)");
329
330 extern uint64_t l2arc_feed_min_ms;
331
332 SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, l2arc_feed_min_ms,
333 CTLFLAG_RWTUN, &l2arc_feed_min_ms, 0,
334 "Min feed interval in milliseconds (LEGACY)");
335
336 extern int l2arc_noprefetch;
337
338 SYSCTL_INT(_vfs_zfs, OID_AUTO, l2arc_noprefetch,
339 CTLFLAG_RWTUN, &l2arc_noprefetch, 0,
340 "Skip caching prefetched buffers (LEGACY)");
341
342 extern int l2arc_feed_again;
343
344 SYSCTL_INT(_vfs_zfs, OID_AUTO, l2arc_feed_again,
345 CTLFLAG_RWTUN, &l2arc_feed_again, 0,
346 "Turbo L2ARC warmup (LEGACY)");
347
348 extern int l2arc_norw;
349
350 SYSCTL_INT(_vfs_zfs, OID_AUTO, l2arc_norw,
351 CTLFLAG_RWTUN, &l2arc_norw, 0,
352 "No reads during writes (LEGACY)");
353
354 static int
param_get_arc_state_size(SYSCTL_HANDLER_ARGS)355 param_get_arc_state_size(SYSCTL_HANDLER_ARGS)
356 {
357 arc_state_t *state = (arc_state_t *)arg1;
358 int64_t val;
359
360 val = zfs_refcount_count(&state->arcs_size[ARC_BUFC_DATA]) +
361 zfs_refcount_count(&state->arcs_size[ARC_BUFC_METADATA]);
362 return (sysctl_handle_64(oidp, &val, 0, req));
363 }
364
365 extern arc_state_t ARC_anon;
366
367 SYSCTL_PROC(_vfs_zfs, OID_AUTO, anon_size,
368 CTLTYPE_S64 | CTLFLAG_RD | CTLFLAG_MPSAFE,
369 &ARC_anon, 0, param_get_arc_state_size, "Q",
370 "size of anonymous state");
371 SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, anon_metadata_esize, CTLFLAG_RD,
372 &ARC_anon.arcs_esize[ARC_BUFC_METADATA].rc_count, 0,
373 "size of evictable metadata in anonymous state");
374 SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, anon_data_esize, CTLFLAG_RD,
375 &ARC_anon.arcs_esize[ARC_BUFC_DATA].rc_count, 0,
376 "size of evictable data in anonymous state");
377
378 extern arc_state_t ARC_mru;
379
380 SYSCTL_PROC(_vfs_zfs, OID_AUTO, mru_size,
381 CTLTYPE_S64 | CTLFLAG_RD | CTLFLAG_MPSAFE,
382 &ARC_mru, 0, param_get_arc_state_size, "Q",
383 "size of mru state");
384 SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, mru_metadata_esize, CTLFLAG_RD,
385 &ARC_mru.arcs_esize[ARC_BUFC_METADATA].rc_count, 0,
386 "size of evictable metadata in mru state");
387 SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, mru_data_esize, CTLFLAG_RD,
388 &ARC_mru.arcs_esize[ARC_BUFC_DATA].rc_count, 0,
389 "size of evictable data in mru state");
390
391 extern arc_state_t ARC_mru_ghost;
392
393 SYSCTL_PROC(_vfs_zfs, OID_AUTO, mru_ghost_size,
394 CTLTYPE_S64 | CTLFLAG_RD | CTLFLAG_MPSAFE,
395 &ARC_mru_ghost, 0, param_get_arc_state_size, "Q",
396 "size of mru ghost state");
397 SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, mru_ghost_metadata_esize, CTLFLAG_RD,
398 &ARC_mru_ghost.arcs_esize[ARC_BUFC_METADATA].rc_count, 0,
399 "size of evictable metadata in mru ghost state");
400 SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, mru_ghost_data_esize, CTLFLAG_RD,
401 &ARC_mru_ghost.arcs_esize[ARC_BUFC_DATA].rc_count, 0,
402 "size of evictable data in mru ghost state");
403
404 extern arc_state_t ARC_mfu;
405
406 SYSCTL_PROC(_vfs_zfs, OID_AUTO, mfu_size,
407 CTLTYPE_S64 | CTLFLAG_RD | CTLFLAG_MPSAFE,
408 &ARC_mfu, 0, param_get_arc_state_size, "Q",
409 "size of mfu state");
410 SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, mfu_metadata_esize, CTLFLAG_RD,
411 &ARC_mfu.arcs_esize[ARC_BUFC_METADATA].rc_count, 0,
412 "size of evictable metadata in mfu state");
413 SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, mfu_data_esize, CTLFLAG_RD,
414 &ARC_mfu.arcs_esize[ARC_BUFC_DATA].rc_count, 0,
415 "size of evictable data in mfu state");
416
417 extern arc_state_t ARC_mfu_ghost;
418
419 SYSCTL_PROC(_vfs_zfs, OID_AUTO, mfu_ghost_size,
420 CTLTYPE_S64 | CTLFLAG_RD | CTLFLAG_MPSAFE,
421 &ARC_mfu_ghost, 0, param_get_arc_state_size, "Q",
422 "size of mfu ghost state");
423 SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, mfu_ghost_metadata_esize, CTLFLAG_RD,
424 &ARC_mfu_ghost.arcs_esize[ARC_BUFC_METADATA].rc_count, 0,
425 "size of evictable metadata in mfu ghost state");
426 SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, mfu_ghost_data_esize, CTLFLAG_RD,
427 &ARC_mfu_ghost.arcs_esize[ARC_BUFC_DATA].rc_count, 0,
428 "size of evictable data in mfu ghost state");
429
430 extern arc_state_t ARC_uncached;
431
432 SYSCTL_PROC(_vfs_zfs, OID_AUTO, uncached_size,
433 CTLTYPE_S64 | CTLFLAG_RD | CTLFLAG_MPSAFE,
434 &ARC_uncached, 0, param_get_arc_state_size, "Q",
435 "size of uncached state");
436 SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, uncached_metadata_esize, CTLFLAG_RD,
437 &ARC_uncached.arcs_esize[ARC_BUFC_METADATA].rc_count, 0,
438 "size of evictable metadata in uncached state");
439 SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, uncached_data_esize, CTLFLAG_RD,
440 &ARC_uncached.arcs_esize[ARC_BUFC_DATA].rc_count, 0,
441 "size of evictable data in uncached state");
442
443 extern arc_state_t ARC_l2c_only;
444
445 SYSCTL_PROC(_vfs_zfs, OID_AUTO, l2c_only_size,
446 CTLTYPE_S64 | CTLFLAG_RD | CTLFLAG_MPSAFE,
447 &ARC_l2c_only, 0, param_get_arc_state_size, "Q",
448 "size of l2c_only state");
449
450 /* dbuf.c */
451
452 /* dmu.c */
453
454 /* dmu_zfetch.c */
455
456 SYSCTL_NODE(_vfs_zfs, OID_AUTO, zfetch, CTLFLAG_RW, 0, "ZFS ZFETCH (LEGACY)");
457
458 extern uint32_t zfetch_max_distance;
459
460 SYSCTL_UINT(_vfs_zfs_zfetch, OID_AUTO, max_distance,
461 CTLFLAG_RWTUN, &zfetch_max_distance, 0,
462 "Max bytes to prefetch per stream (LEGACY)");
463
464 extern uint32_t zfetch_max_idistance;
465
466 SYSCTL_UINT(_vfs_zfs_zfetch, OID_AUTO, max_idistance,
467 CTLFLAG_RWTUN, &zfetch_max_idistance, 0,
468 "Max bytes to prefetch indirects for per stream (LEGACY)");
469
470 /* dsl_pool.c */
471
472 /* dnode.c */
473
474 /* dsl_scan.c */
475
476 /* metaslab.c */
477
478 int
param_set_active_allocator(SYSCTL_HANDLER_ARGS)479 param_set_active_allocator(SYSCTL_HANDLER_ARGS)
480 {
481 char buf[16];
482 int rc;
483
484 if (req->newptr == NULL)
485 strlcpy(buf, zfs_active_allocator, sizeof (buf));
486
487 rc = sysctl_handle_string(oidp, buf, sizeof (buf), req);
488 if (rc || req->newptr == NULL)
489 return (rc);
490 if (strcmp(buf, zfs_active_allocator) == 0)
491 return (0);
492
493 return (param_set_active_allocator_common(buf));
494 }
495
496 /*
497 * In pools where the log space map feature is not enabled we touch
498 * multiple metaslabs (and their respective space maps) with each
499 * transaction group. Thus, we benefit from having a small space map
500 * block size since it allows us to issue more I/O operations scattered
501 * around the disk. So a sane default for the space map block size
502 * is 8~16K.
503 */
504 extern int zfs_metaslab_sm_blksz_no_log;
505
506 SYSCTL_INT(_vfs_zfs_metaslab, OID_AUTO, sm_blksz_no_log,
507 CTLFLAG_RDTUN, &zfs_metaslab_sm_blksz_no_log, 0,
508 "Block size for space map in pools with log space map disabled. "
509 "Power of 2 greater than 4096.");
510
511 /*
512 * When the log space map feature is enabled, we accumulate a lot of
513 * changes per metaslab that are flushed once in a while so we benefit
514 * from a bigger block size like 128K for the metaslab space maps.
515 */
516 extern int zfs_metaslab_sm_blksz_with_log;
517
518 SYSCTL_INT(_vfs_zfs_metaslab, OID_AUTO, sm_blksz_with_log,
519 CTLFLAG_RDTUN, &zfs_metaslab_sm_blksz_with_log, 0,
520 "Block size for space map in pools with log space map enabled. "
521 "Power of 2 greater than 4096.");
522
523 /*
524 * The in-core space map representation is more compact than its on-disk form.
525 * The zfs_condense_pct determines how much more compact the in-core
526 * space map representation must be before we compact it on-disk.
527 * Values should be greater than or equal to 100.
528 */
529 extern uint_t zfs_condense_pct;
530
531 SYSCTL_UINT(_vfs_zfs, OID_AUTO, condense_pct,
532 CTLFLAG_RWTUN, &zfs_condense_pct, 0,
533 "Condense on-disk spacemap when it is more than this many percents"
534 " of in-memory counterpart");
535
536 extern uint_t zfs_remove_max_segment;
537
538 SYSCTL_UINT(_vfs_zfs, OID_AUTO, remove_max_segment,
539 CTLFLAG_RWTUN, &zfs_remove_max_segment, 0,
540 "Largest contiguous segment ZFS will attempt to allocate when removing"
541 " a device");
542
543 extern int zfs_removal_suspend_progress;
544
545 SYSCTL_INT(_vfs_zfs, OID_AUTO, removal_suspend_progress,
546 CTLFLAG_RWTUN, &zfs_removal_suspend_progress, 0,
547 "Ensures certain actions can happen while in the middle of a removal");
548
549 /*
550 * Minimum size which forces the dynamic allocator to change
551 * it's allocation strategy. Once the space map cannot satisfy
552 * an allocation of this size then it switches to using more
553 * aggressive strategy (i.e search by size rather than offset).
554 */
555 extern uint64_t metaslab_df_alloc_threshold;
556
557 SYSCTL_QUAD(_vfs_zfs_metaslab, OID_AUTO, df_alloc_threshold,
558 CTLFLAG_RWTUN, &metaslab_df_alloc_threshold, 0,
559 "Minimum size which forces the dynamic allocator to change its"
560 " allocation strategy");
561
562 /*
563 * The minimum free space, in percent, which must be available
564 * in a space map to continue allocations in a first-fit fashion.
565 * Once the space map's free space drops below this level we dynamically
566 * switch to using best-fit allocations.
567 */
568 extern uint_t metaslab_df_free_pct;
569
570 SYSCTL_UINT(_vfs_zfs_metaslab, OID_AUTO, df_free_pct,
571 CTLFLAG_RWTUN, &metaslab_df_free_pct, 0,
572 "The minimum free space, in percent, which must be available in a"
573 " space map to continue allocations in a first-fit fashion");
574
575 /* mmp.c */
576
577 int
param_set_multihost_interval(SYSCTL_HANDLER_ARGS)578 param_set_multihost_interval(SYSCTL_HANDLER_ARGS)
579 {
580 int err;
581
582 err = sysctl_handle_64(oidp, &zfs_multihost_interval, 0, req);
583 if (err != 0 || req->newptr == NULL)
584 return (err);
585
586 if (spa_mode_global != SPA_MODE_UNINIT)
587 mmp_signal_all_threads();
588
589 return (0);
590 }
591
592 /* spa.c */
593
594 extern int zfs_ccw_retry_interval;
595
596 SYSCTL_INT(_vfs_zfs, OID_AUTO, ccw_retry_interval,
597 CTLFLAG_RWTUN, &zfs_ccw_retry_interval, 0,
598 "Configuration cache file write, retry after failure, interval"
599 " (seconds)");
600
601 extern uint64_t zfs_max_missing_tvds_cachefile;
602
603 SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, max_missing_tvds_cachefile,
604 CTLFLAG_RWTUN, &zfs_max_missing_tvds_cachefile, 0,
605 "Allow importing pools with missing top-level vdevs in cache file");
606
607 extern uint64_t zfs_max_missing_tvds_scan;
608
609 SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, max_missing_tvds_scan,
610 CTLFLAG_RWTUN, &zfs_max_missing_tvds_scan, 0,
611 "Allow importing pools with missing top-level vdevs during scan");
612
613 /* spa_misc.c */
614
615 extern int zfs_flags;
616
617 static int
sysctl_vfs_zfs_debug_flags(SYSCTL_HANDLER_ARGS)618 sysctl_vfs_zfs_debug_flags(SYSCTL_HANDLER_ARGS)
619 {
620 int err, val;
621
622 val = zfs_flags;
623 err = sysctl_handle_int(oidp, &val, 0, req);
624 if (err != 0 || req->newptr == NULL)
625 return (err);
626
627 /*
628 * ZFS_DEBUG_MODIFY must be enabled prior to boot so all
629 * arc buffers in the system have the necessary additional
630 * checksum data. However, it is safe to disable at any
631 * time.
632 */
633 if (!(zfs_flags & ZFS_DEBUG_MODIFY))
634 val &= ~ZFS_DEBUG_MODIFY;
635 zfs_flags = val;
636
637 return (0);
638 }
639
640 SYSCTL_PROC(_vfs_zfs, OID_AUTO, debugflags,
641 CTLTYPE_UINT | CTLFLAG_MPSAFE | CTLFLAG_RWTUN, NULL, 0,
642 sysctl_vfs_zfs_debug_flags, "IU", "Debug flags for ZFS testing.");
643
644 int
param_set_deadman_synctime(SYSCTL_HANDLER_ARGS)645 param_set_deadman_synctime(SYSCTL_HANDLER_ARGS)
646 {
647 unsigned long val;
648 int err;
649
650 val = zfs_deadman_synctime_ms;
651 err = sysctl_handle_64(oidp, &val, 0, req);
652 if (err != 0 || req->newptr == NULL)
653 return (err);
654 zfs_deadman_synctime_ms = val;
655
656 spa_set_deadman_synctime(MSEC2NSEC(zfs_deadman_synctime_ms));
657
658 return (0);
659 }
660
661 int
param_set_deadman_ziotime(SYSCTL_HANDLER_ARGS)662 param_set_deadman_ziotime(SYSCTL_HANDLER_ARGS)
663 {
664 unsigned long val;
665 int err;
666
667 val = zfs_deadman_ziotime_ms;
668 err = sysctl_handle_64(oidp, &val, 0, req);
669 if (err != 0 || req->newptr == NULL)
670 return (err);
671 zfs_deadman_ziotime_ms = val;
672
673 spa_set_deadman_ziotime(MSEC2NSEC(zfs_deadman_synctime_ms));
674
675 return (0);
676 }
677
678 int
param_set_deadman_failmode(SYSCTL_HANDLER_ARGS)679 param_set_deadman_failmode(SYSCTL_HANDLER_ARGS)
680 {
681 char buf[16];
682 int rc;
683
684 if (req->newptr == NULL)
685 strlcpy(buf, zfs_deadman_failmode, sizeof (buf));
686
687 rc = sysctl_handle_string(oidp, buf, sizeof (buf), req);
688 if (rc || req->newptr == NULL)
689 return (rc);
690 if (strcmp(buf, zfs_deadman_failmode) == 0)
691 return (0);
692 if (strcmp(buf, "wait") == 0)
693 zfs_deadman_failmode = "wait";
694 if (strcmp(buf, "continue") == 0)
695 zfs_deadman_failmode = "continue";
696 if (strcmp(buf, "panic") == 0)
697 zfs_deadman_failmode = "panic";
698
699 return (-param_set_deadman_failmode_common(buf));
700 }
701
702 int
param_set_raidz_impl(SYSCTL_HANDLER_ARGS)703 param_set_raidz_impl(SYSCTL_HANDLER_ARGS)
704 {
705 const size_t bufsize = 128;
706 char *buf;
707 int rc;
708
709 buf = malloc(bufsize, M_SOLARIS, M_WAITOK | M_ZERO);
710 if (req->newptr == NULL)
711 vdev_raidz_impl_get(buf, bufsize);
712
713 rc = sysctl_handle_string(oidp, buf, bufsize, req);
714 if (rc || req->newptr == NULL) {
715 free(buf, M_SOLARIS);
716 return (rc);
717 }
718 rc = vdev_raidz_impl_set(buf);
719 free(buf, M_SOLARIS);
720 return (rc);
721 }
722
723 int
param_set_slop_shift(SYSCTL_HANDLER_ARGS)724 param_set_slop_shift(SYSCTL_HANDLER_ARGS)
725 {
726 int val;
727 int err;
728
729 val = spa_slop_shift;
730 err = sysctl_handle_int(oidp, &val, 0, req);
731 if (err != 0 || req->newptr == NULL)
732 return (err);
733
734 if (val < 1 || val > 31)
735 return (EINVAL);
736
737 spa_slop_shift = val;
738
739 return (0);
740 }
741
742 /* spacemap.c */
743
744 extern int space_map_ibs;
745
746 SYSCTL_INT(_vfs_zfs, OID_AUTO, space_map_ibs, CTLFLAG_RWTUN,
747 &space_map_ibs, 0, "Space map indirect block shift");
748
749
750 /* vdev.c */
751
752 int
param_set_min_auto_ashift(SYSCTL_HANDLER_ARGS)753 param_set_min_auto_ashift(SYSCTL_HANDLER_ARGS)
754 {
755 int val;
756 int err;
757
758 val = zfs_vdev_min_auto_ashift;
759 err = sysctl_handle_int(oidp, &val, 0, req);
760 if (err != 0 || req->newptr == NULL)
761 return (SET_ERROR(err));
762
763 if (val < ASHIFT_MIN || val > zfs_vdev_max_auto_ashift)
764 return (SET_ERROR(EINVAL));
765
766 zfs_vdev_min_auto_ashift = val;
767
768 if (arg2 != 0)
769 warn_deprecated_sysctl("min_auto_ashift",
770 "vdev.min_auto_ashift");
771
772 return (0);
773 }
774
775 SYSCTL_PROC(_vfs_zfs, OID_AUTO, min_auto_ashift,
776 CTLTYPE_UINT | CTLFLAG_RWTUN | CTLFLAG_MPSAFE, NULL, 1,
777 param_set_min_auto_ashift, "IU",
778 "Min ashift used when creating new top-level vdev. (LEGACY)");
779
780 int
param_set_max_auto_ashift(SYSCTL_HANDLER_ARGS)781 param_set_max_auto_ashift(SYSCTL_HANDLER_ARGS)
782 {
783 int val;
784 int err;
785
786 val = zfs_vdev_max_auto_ashift;
787 err = sysctl_handle_int(oidp, &val, 0, req);
788 if (err != 0 || req->newptr == NULL)
789 return (SET_ERROR(err));
790
791 if (val > ASHIFT_MAX || val < zfs_vdev_min_auto_ashift)
792 return (SET_ERROR(EINVAL));
793
794 zfs_vdev_max_auto_ashift = val;
795
796 if (arg2 != 0)
797 warn_deprecated_sysctl("max_auto_ashift",
798 "vdev.max_auto_ashift");
799
800 return (0);
801 }
802
803 SYSCTL_PROC(_vfs_zfs, OID_AUTO, max_auto_ashift,
804 CTLTYPE_UINT | CTLFLAG_RWTUN | CTLFLAG_MPSAFE, NULL, 1,
805 param_set_max_auto_ashift, "IU",
806 "Max ashift used when optimizing for logical -> physical sector size on"
807 " new top-level vdevs. (LEGACY)");
808
809 /*
810 * Since the DTL space map of a vdev is not expected to have a lot of
811 * entries, we default its block size to 4K.
812 */
813 extern int zfs_vdev_dtl_sm_blksz;
814
815 SYSCTL_INT(_vfs_zfs, OID_AUTO, dtl_sm_blksz,
816 CTLFLAG_RDTUN, &zfs_vdev_dtl_sm_blksz, 0,
817 "Block size for DTL space map. Power of 2 greater than 4096.");
818
819 /*
820 * vdev-wide space maps that have lots of entries written to them at
821 * the end of each transaction can benefit from a higher I/O bandwidth
822 * (e.g. vdev_obsolete_sm), thus we default their block size to 128K.
823 */
824 extern int zfs_vdev_standard_sm_blksz;
825
826 SYSCTL_INT(_vfs_zfs, OID_AUTO, standard_sm_blksz,
827 CTLFLAG_RDTUN, &zfs_vdev_standard_sm_blksz, 0,
828 "Block size for standard space map. Power of 2 greater than 4096.");
829
830 extern int vdev_validate_skip;
831
832 SYSCTL_INT(_vfs_zfs, OID_AUTO, validate_skip,
833 CTLFLAG_RDTUN, &vdev_validate_skip, 0,
834 "Enable to bypass vdev_validate().");
835
836 /* vdev_mirror.c */
837
838 /* vdev_queue.c */
839
840 extern uint_t zfs_vdev_max_active;
841
842 SYSCTL_UINT(_vfs_zfs, OID_AUTO, top_maxinflight,
843 CTLFLAG_RWTUN, &zfs_vdev_max_active, 0,
844 "The maximum number of I/Os of all types active for each device."
845 " (LEGACY)");
846
847 /* zio.c */
848
849 SYSCTL_INT(_vfs_zfs_zio, OID_AUTO, exclude_metadata,
850 CTLFLAG_RDTUN, &zio_exclude_metadata, 0,
851 "Exclude metadata buffers from dumps as well");
852