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