NAME

       spl — parameters of the SPL kernel module

DESCRIPTION

       spl_kmem_cache_kmem_threads=4 (uint)
               The  number of threads created for the spl_kmem_cache task queue.  This task queue is responsible
               for allocating new slabs for use by the kmem caches.  For the majority of systems  and  workloads
               only a small number of threads are required.

       spl_kmem_cache_reclaim=0 (uint)
               When  this is set it prevents Linux from being able to rapidly reclaim all the memory held by the
               kmem caches.  This may be useful in circumstances where it's preferable that Linux reclaim memory
               from some other subsystem first.  Setting this will increase the likelihood out of memory  events
               on a memory constrained system.

       spl_kmem_cache_obj_per_slab=8 (uint)
               The  preferred number of objects per slab in the cache.  In general, a larger value will increase
               the caches memory footprint  while  decreasing  the  time  required  to  perform  an  allocation.
               Conversely,  a  smaller  value  will  minimize  the  footprint and improve cache reclaim time but
               individual allocations may take longer.

       spl_kmem_cache_max_size=32 (64-bit) or 4 (32-bit) (uint)
               The maximum size of a kmem cache slab in MiB.  This effectively limits the maximum  cache  object
               size to spl_kmem_cache_max_size/spl_kmem_cache_obj_per_slab.

               Caches may not be created with object sized larger than this limit.

       spl_kmem_cache_slab_limit=16384 (uint)
               For  small  objects the Linux slab allocator should be used to make the most efficient use of the
               memory.  However, large objects are not supported  by  the  Linux  slab  and  therefore  the  SPL
               implementation  is  preferred.   This  value  is used to determine the cutoff between a small and
               large object.

               Objects of size spl_kmem_cache_slab_limit or smaller will  be  allocated  using  the  Linux  slab
               allocator, large objects use the SPL allocator.  A cutoff of 16K was determined to be optimal for
               architectures using 4K pages.

       spl_kmem_alloc_warn=32768 (uint)
               As  a  general  rule kmem_alloc() allocations should be small, preferably just a few pages, since
               they must by physically contiguous.  Therefore, a rate limited warning will  be  printed  to  the
               console for any kmem_alloc() which exceeds a reasonable threshold.

               The  default  warning  threshold  is  set to eight pages but capped at 32K to accommodate systems
               using large pages.  This value was selected to be small enough to ensure the largest  allocations
               are  quickly noticed and fixed.  But large enough to avoid logging any warnings when a allocation
               size is larger than optimal but not a serious concern.  Since this value is  tunable,  developers
               are  encouraged  to  set it lower when testing so any new largish allocations are quickly caught.
               These warnings may be disabled by setting the threshold to zero.

       spl_kmem_alloc_max=KMALLOC_MAX_SIZE/4 (uint)
               Large kmem_alloc() allocations will fail if they exceed KMALLOC_MAX_SIZE.  Allocations which  are
               marginally  smaller than this limit may succeed but should still be avoided due to the expense of
               locating a contiguous range of free pages.  Therefore, a maximum kmem size with reasonable safely
               margin of 4x is set.  kmem_alloc() allocations  larger  than  this  maximum  will  quickly  fail.
               vmem_alloc()  allocations  less  than  or  equal  to  this value will use kmalloc(), but shift to
               vmalloc() when exceeding this value.

       spl_kmem_cache_magazine_size=0 (uint)
               Cache magazines are an optimization designed to minimize the cost of allocating memory.  They  do
               this  by keeping a per-cpu cache of recently freed objects, which can then be reallocated without
               taking a lock.  This can improve  performance  on  highly  contended  caches.   However,  because
               objects  in magazines will prevent otherwise empty slabs from being immediately released this may
               not be ideal for low memory machines.

               For this reason, spl_kmem_cache_magazine_size can be used to set a maximum magazine  size.   When
               this  value  is  set  to 0 the magazine size will be automatically determined based on the object
               size.  Otherwise magazines will  be  limited  to  2-256  objects  per  magazine  (i.e  per  cpu).
               Magazines may never be entirely disabled in this implementation.

       spl_hostid=0 (ulong)
               The  system  hostid,  when  set  this can be used to uniquely identify a system.  By default this
               value is set to zero which indicates the hostid is disabled.  It can  be  explicitly  enabled  by
               placing a unique non-zero value in /etc/hostid.

       spl_hostid_path=/etc/hostid (charp)
               The  expected  path to locate the system hostid when specified.  This value may be overridden for
               non-standard configurations.

       spl_panic_halt=0 (uint)
               Cause a kernel panic on assertion failures.  When not enabled, the thread is halted to facilitate
               further debugging.

               Set to a non-zero value to enable.

       spl_taskq_kick=0 (uint)
               Kick stuck taskq to spawn threads.  When writing a non-zero value to it, it  will  scan  all  the
               taskqs.   If  any  of  them have a pending task more than 5 seconds old, it will kick it to spawn
               more threads.  This can be used if you find a rare deadlock occurs because  one  or  more  taskqs
               didn't spawn a thread when it should.

       spl_taskq_thread_bind=0 (int)
               Bind  taskq  threads to specific CPUs.  When enabled all taskq threads will be distributed evenly
               across the available CPUs.  By default, this behavior is disabled to allow  the  Linux  scheduler
               the maximum flexibility to determine where a thread should run.

       spl_taskq_thread_dynamic=1 (int)
               Allow  dynamic  taskqs.   When  enabled  taskqs  which set the TASKQ_DYNAMIC flag will by default
               create only a single thread.  New threads will be created on  demand  up  to  a  maximum  allowed
               number  to  facilitate  the  completion of outstanding tasks.  Threads which are no longer needed
               will be promptly destroyed.  By default this behavior is enabled but it can be  disabled  to  aid
               performance analysis or troubleshooting.

       spl_taskq_thread_priority=1 (int)
               Allow  newly  created  taskq  threads to set a non-default scheduler priority.  When enabled, the
               priority specified when a taskq is created will be applied to all threads created by that  taskq.
               When  disabled  all  threads will use the default Linux kernel thread priority.  By default, this
               behavior is enabled.

       spl_taskq_thread_sequential=4 (int)
               The number of items a taskq worker thread must handle without interruption  before  requesting  a
               new  worker  thread be spawned.  This is used to control how quickly taskqs ramp up the number of
               threads processing the queue.  Because Linux  thread  creation  and  destruction  are  relatively
               inexpensive  a  small  default value has been selected.  This means that normally threads will be
               created aggressively which is desirable.  Increasing this value will result in  a  slower  thread
               creation rate which may be preferable for some configurations.

       spl_max_show_tasks=512 (uint)
               The  maximum  number  of  tasks  per  pending list in each taskq shown in /proc/spl/taskq{,-all}.
               Write 0 to turn off the limit.  The proc file will walk the lists  with  lock  held,  reading  it
               could cause a lock-up if the list grow too large without limiting the output.  "(truncated)" will
               be shown if the list is larger than the limit.

OpenZFS                                          August 24, 2020                                          SPL(4)