standard-readme compliant Donate with Bitcoin


OpenZFS v2.0.3-dragon (Based on original version 2.0.3-release)

OpenZFS is an outstanding storage platform that encompasses the functionality of traditional filesystems, volume managers, and more, with consistent reliability, functionality and performance.

Only for Dragon kernel v5.12+

Warning! Don't use GParted for kernels with ZFS active! GParted doesn't understand ZFS and makes disastrous changes to the partition table! Use GParted from Live disk only to modify or create partitions.
$ dmesg | egrep ZFS
[    4.639664] ZFS: Loaded module v2.0.3-dragon, ZFS pool version 5000, ZFS filesystem version 5

wip:~# zpool status -v
  pool: zdata
 state: ONLINE

        NAME        STATE     READ WRITE CKSUM
        zdata       ONLINE       0     0     0
          mirror0   ONLINE       0     0     0
          mirror1   ONLINE       0     0     0
          zfs-log   ONLINE       0     0     0

errors: No known data errors

# zfs list
zdata        24,8G  55,6G       96K  /zdata
zdata/build  4,10G  25,2G     4,10G  /home/trixy/BUILD
zdata/data   20,7G  55,6G     20,7G  /home/trixy/DATA

You can download OpenZFS libraries and utilities from the download area, tools only for Zol v2.


# modinfo zfs
name:           zfs
filename:       (builtin)
alias:          char-major-10-249
alias:          devname:zfs
description:    ZFS
author:         OpenZFS
file:           fs/zfs/zfs/zfs
license:        CDDL
version:        2.0.3-dragon
parm:           zvol_volmode:Default volmode property value (uint)
parm:           zvol_prefetch_bytes:Prefetch N bytes at zvol start+end (uint)
parm:           zvol_max_discard_blocks:Max number of blocks to discard (ulong)
parm:           zvol_request_sync:Synchronously handle bio requests (uint)
parm:           zvol_threads:Max number of threads to handle I/O requests (uint)
parm:           zvol_major:Major number for zvol device (uint)
parm:           zvol_inhibit_dev:Do not create zvol device nodes (uint)
parm:           zfs_fallocate_reserve_percent:Percentage of length to use for the available capacity check (uint)
parm:           zfs_key_max_salt_uses:Max number of times a salt value can be used for generating encryption keys before it is rotated (ulong)
parm:           zfs_unlink_suspend_progress:Set to prevent async unlinks (debug - leaks space into the unlinked set) (int)
parm:           zfs_object_mutex_size:Size of znode hold array (uint)
parm:           zfs_delete_blocks:Delete files larger than N blocks async (ulong)
parm:           zfs_dbgmsg_maxsize:Maximum ZFS debug log size (int)
parm:           zfs_dbgmsg_enable:Enable ZFS debug message log (int)
parm:           zfs_expire_snapshot:Seconds to expire .zfs/snapshot (int)
parm:           zfs_admin_snapshot:Enable mkdir/rmdir/mv in .zfs/snapshot (int)
parm:           vdev_file_physical_ashift:Physical ashift for file-based devices (ulong)
parm:           vdev_file_logical_ashift:Logical ashift for file-based devices (ulong)
parm:           zfs_vdev_scheduler:I/O scheduler
parm:           zfs_arc_shrinker_limit:Limit on number of pages that ARC shrinker can reclaim at once (int)
parm:           zfs_abd_scatter_max_order:Maximum order allocation used for a scatter ABD. (uint)
parm:           zfs_abd_scatter_min_size:Minimum size of scatter allocations. (int)
parm:           zfs_abd_scatter_enabled:Toggle whether ABD allocations must be linear. (int)
parm:           zio_deadman_log_all:Log all slow ZIOs, not just those with vdevs (int)
parm:           zio_dva_throttle_enabled:Throttle block allocations in the ZIO pipeline (int)
parm:           zfs_sync_pass_rewrite:Rewrite new bps starting in this pass (int)
parm:           zfs_sync_pass_dont_compress:Don't compress starting in this pass (int)
parm:           zfs_sync_pass_deferred_free:Defer frees starting in this pass (int)
parm:           zio_requeue_io_start_cut_in_line:Prioritize requeued I/O (int)
parm:           zio_slow_io_ms:Max I/O completion time (milliseconds) before marking it as slow (int)
parm:           zil_maxblocksize:Limit in bytes of ZIL log block size (int)
parm:           zil_slog_bulk:Limit in bytes slog sync writes per commit (ulong)
parm:           zil_nocacheflush:Disable ZIL cache flushes (int)
parm:           zil_replay_disable:Disable intent logging replay (int)
parm:           zfs_commit_timeout_pct:ZIL block open timeout percentage (int)
parm:           zfs_vnops_read_chunk_size:Bytes to read per chunk (ulong)
parm:           zfs_immediate_write_sz:Largest data block to write to zil (long)
parm:           zfs_history_output_max:Maximum size in bytes of ZFS ioctl output that will be logged (ulong)
parm:           zfs_max_nvlist_src_size:Maximum size in bytes allowed for src nvlist passed with ZFS ioctls (ulong)
parm:           zfs_zevent_retain_expire_secs:Expiration time for recent zevents records (uint)
parm:           zfs_zevent_retain_max:Maximum recent zevents records to retain for duplicate checking (uint)
parm:           zfs_lua_max_memlimit:Max memory limit that can be specified for a channel program (ulong)
parm:           zfs_lua_max_instrlimit:Max instruction limit that can be specified for a channel program (ulong)
parm:           zap_iterate_prefetch:When iterating ZAP object, prefetch it (int)
parm:           zfs_trim_queue_limit:Max queued TRIMs outstanding per leaf vdev (uint)
parm:           zfs_trim_txg_batch:Min number of txgs to aggregate frees before issuing TRIM (uint)
parm:           zfs_trim_metaslab_skip:Skip metaslabs which have never been initialized (uint)
parm:           zfs_trim_extent_bytes_min:Min size of TRIM commands, smaller will be skipped (uint)
parm:           zfs_trim_extent_bytes_max:Max size of TRIM commands, larger will be split (uint)
parm:           zfs_removal_suspend_progress:Pause device removal after this many bytes are copied (debug use only - causes removal to hang) (int)
parm:           vdev_removal_max_span:Largest span of free chunks a remap segment can span (int)
parm:           zfs_remove_max_segment:Largest contiguous segment to allocate when removing device (int)
parm:           zfs_removal_ignore_errors:Ignore hard IO errors when removing device (int)
parm:           zfs_rebuild_scrub_enabled:Automatically scrub after sequential resilver completes (int)
parm:           zfs_rebuild_vdev_limit:Max bytes in flight per leaf vdev for sequential resilvers (ulong)
parm:           zfs_rebuild_max_segment:Max segment size in bytes of rebuild reads (ulong)
parm:           zfs_vdev_raidz_impl:Select raidz implementation.
parm:           zfs_vdev_queue_depth_pct:Queue depth percentage for each top-level vdev (int)
parm:           zfs_vdev_nia_delay:Number of non-interactive I/Os before _max_active (int)
parm:           zfs_vdev_nia_credit:Number of non-interactive I/Os to allow in sequence (int)
parm:           zfs_vdev_rebuild_min_active:Min active rebuild I/Os per vdev (int)
parm:           zfs_vdev_rebuild_max_active:Max active rebuild I/Os per vdev (int)
parm:           zfs_vdev_trim_min_active:Min active trim/discard I/Os per vdev (int)
parm:           zfs_vdev_trim_max_active:Max active trim/discard I/Os per vdev (int)
parm:           zfs_vdev_sync_write_min_active:Min active sync write I/Os per vdev (int)
parm:           zfs_vdev_sync_write_max_active:Max active sync write I/Os per vdev (int)
parm:           zfs_vdev_sync_read_min_active:Min active sync read I/Os per vdev (int)
parm:           zfs_vdev_sync_read_max_active:Max active sync read I/Os per vdev (int)
parm:           zfs_vdev_scrub_min_active:Min active scrub I/Os per vdev (int)
parm:           zfs_vdev_scrub_max_active:Max active scrub I/Os per vdev (int)
parm:           zfs_vdev_removal_min_active:Min active removal I/Os per vdev (int)
parm:           zfs_vdev_removal_max_active:Max active removal I/Os per vdev (int)
parm:           zfs_vdev_initializing_min_active:Min active initializing I/Os per vdev (int)
parm:           zfs_vdev_initializing_max_active:Max active initializing I/Os per vdev (int)
parm:           zfs_vdev_async_write_min_active:Min active async write I/Os per vdev (int)
parm:           zfs_vdev_async_write_max_active:Max active async write I/Os per vdev (int)
parm:           zfs_vdev_async_read_min_active:Min active async read I/Os per vdev (int)
parm:           zfs_vdev_async_read_max_active:Max active async read I/Os per vdev (int)
parm:           zfs_vdev_async_write_active_min_dirty_percent:Async write concurrency min threshold (int)
parm:           zfs_vdev_async_write_active_max_dirty_percent:Async write concurrency max threshold (int)
parm:           zfs_vdev_max_active:Maximum number of active I/Os per vdev (int)
parm:           zfs_vdev_write_gap_limit:Aggregate write I/O over gap (int)
parm:           zfs_vdev_read_gap_limit:Aggregate read I/O over gap (int)
parm:           zfs_vdev_aggregate_trim:Allow TRIM I/O to be aggregated (int)
parm:           zfs_vdev_aggregation_limit_non_rotating:Max vdev I/O aggregation size for non-rotating media (int)
parm:           zfs_vdev_aggregation_limit:Max vdev I/O aggregation size (int)
parm:           zfs_vdev_mirror_non_rotating_seek_inc:Non-rotating media load increment for seeking I/O's (int)
parm:           zfs_vdev_mirror_non_rotating_inc:Non-rotating media load increment for non-seeking I/O's (int)
parm:           zfs_vdev_mirror_rotating_seek_offset:Offset in bytes from the last I/O which triggers a reduced rotating media seek increment (int)
parm:           zfs_vdev_mirror_rotating_seek_inc:Rotating media load increment for seeking I/O's (int)
parm:           zfs_vdev_mirror_rotating_inc:Rotating media load increment for non-seeking I/O's (int)
parm:           zfs_initialize_chunk_size:Size in bytes of writes by zpool initialize (ulong)
parm:           zfs_initialize_value:Value written during zpool initialize (ulong)
parm:           zfs_reconstruct_indirect_combinations_max:Maximum number of combinations when reconstructing split segments (int)
parm:           zfs_condense_indirect_commit_entry_delay_ms:Used by tests to ensure certain actions happen in the middle of a condense. A maximum value of 1 should be sufficient. (int)
parm:           zfs_condense_max_obsolete_bytes:Minimum size obsolete spacemap to attempt condensing (ulong)
parm:           zfs_condense_min_mapping_bytes:Don't bother condensing if the mapping uses less than this amount of memory (ulong)
parm:           zfs_condense_indirect_vdevs_enable:Whether to attempt condensing indirect vdev mappings (int)
parm:           zfs_vdev_cache_bshift:Shift size to inflate reads too (int)
parm:           zfs_vdev_cache_size:Total size of the per-disk cache (int)
parm:           zfs_vdev_cache_max:Inflate reads small than max (int)
parm:           zfs_vdev_max_auto_ashift:Maximum ashift used when optimizing for logical -> physical sector size on new top-level vdevs
parm:           zfs_vdev_min_auto_ashift:Minimum ashift used when creating new top-level vdevs
parm:           zfs_embedded_slog_min_ms:Minimum number of metaslabs required to dedicate one for log blocks (int)
parm:           zfs_nocacheflush:Disable cache flushes (int)
parm:           vdev_validate_skip:Bypass vdev_validate() (int)
parm:           zfs_scan_ignore_errors:Ignore errors during resilver/scrub (int)
parm:           zfs_checksum_events_per_second:Rate limit checksum events to this many checksum errors per second (do not set below zed threshold). (uint)
parm:           zfs_slow_io_events_per_second:Rate limit slow IO (delay) events to this many per second (uint)
parm:           zfs_vdev_ms_count_limit:Practical upper limit of total metaslabs per top-level vdev (int)
parm:           zfs_vdev_min_ms_count:Minimum number of metaslabs per top-level vdev (int)
parm:           zfs_vdev_default_ms_shift:Default limit for metaslab size (int)
parm:           zfs_vdev_default_ms_count:Target number of metaslabs per top-level vdev (int)
parm:           zfs_txg_timeout:Max seconds worth of delta per txg (int)
parm:           zfs_multihost_history:Historical statistics for last N multihost writes (int)
parm:           zfs_txg_history:Historical statistics for the last N txgs (int)
parm:           zfs_read_history_hits:Include cache hits in read history (int)
parm:           zfs_read_history:Historical statistics for the last N reads (int)
parm:           spa_slop_shift:Reserved free space in pool
parm:           zfs_special_class_metadata_reserve_pct:Small file blocks in special vdevs depends on this much free space available (int)
parm:           zfs_deadman_ziotime_ms:IO expiration time in milliseconds
parm:           zfs_deadman_synctime_ms:Pool sync expiration time in milliseconds
parm:           zfs_deadman_failmode:Failmode for deadman timer
parm:           zfs_user_indirect_is_special:Place user data indirect blocks into the special class (int)
parm:           zfs_ddt_data_is_special:Place DDT data into the special class (int)
parm:           spa_asize_inflation:SPA size estimate multiplication factor (int)
parm:           zfs_deadman_enabled:Enable deadman timer (int)
parm:           zfs_deadman_checktime_ms:Dead I/O check interval in milliseconds (ulong)
parm:           zfs_free_leak_on_eio:Set to ignore IO errors during free and permanently leak the space (int)
parm:           zfs_recover:Set to attempt to recover from fatal errors (int)
parm:           zfs_flags:Set additional debugging flags (uint)
parm:           zfs_keep_log_spacemaps_at_export:Prevent the log spacemaps from being flushed and destroyed during pool export/destroy (int)
parm:           zfs_min_metaslabs_to_flush:Minimum number of metaslabs to flush per dirty TXG (ulong)
parm:           zfs_max_logsm_summary_length:Maximum number of rows allowed in the summary of the spacemap log (ulong)
parm:           zfs_max_log_walking:The number of past TXGs that the flushing algorithm of the log spacemap feature uses to estimate incoming log blocks (ulong)
parm:           zfs_unflushed_log_block_pct:Tunable used to determine the number of blocks that can be used for the spacemap log, expressed as a percentage of the total number of metaslabs in the pool (e.g. 400 means the number of log blocks is capped at 4 times the number of metaslabs) (ulong)
parm:           zfs_unflushed_log_block_min:Lower-bound limit for the maximum amount of blocks allowed in log spacemap (see zfs_unflushed_log_block_max) (ulong)
parm:           zfs_unflushed_log_block_max:Hard limit (upper-bound) in the size of the space map log in terms of blocks. (ulong)
parm:           zfs_unflushed_max_mem_ppm:Percentage of the overall system memory that ZFS allows to be used for unflushed changes (value is calculated over 1000000 for finer granularity (ulong)
parm:           zfs_unflushed_max_mem_amt:Specific hard-limit in memory that ZFS allows to be used for unflushed changes (ulong)
parm:           zfs_autoimport_disable:Disable pool import at module load (int)
parm:           spa_config_path:SPA config file (/etc/zfs/zpool.cache) (charp)
parm:           zfs_spa_discard_memory_limit:Limit for memory used in prefetching the checkpoint space map done on each vdev while discarding the checkpoint (ulong)
parm:           zfs_livelist_condense_new_alloc:Whether extra ALLOC blkptrs were added to a livelist entry while it was being condensed (int)
parm:           zfs_livelist_condense_zthr_cancel:Whether livelist condensing was canceled in the zthr function (int)
parm:           zfs_livelist_condense_sync_cancel:Whether livelist condensing was canceled in the synctask (int)
parm:           zfs_livelist_condense_sync_pause:Set the livelist condense synctask to pause (int)
parm:           zfs_livelist_condense_zthr_pause:Set the livelist condense zthr to pause (int)
parm:           zfs_max_missing_tvds:Allow importing pool with up to this number of missing top-level vdevs (in read-only mode) (ulong)
parm:           zio_taskq_batch_pct:Percentage of CPUs to run an IO worker thread (uint)
parm:           spa_load_print_vdev_tree:Print vdev tree to zfs_dbgmsg during pool import (int)
parm:           spa_load_verify_data:Set to traverse data on pool import (int)
parm:           spa_load_verify_metadata:Set to traverse metadata on pool import (int)
parm:           spa_load_verify_shift:log2(fraction of arc that can be used by inflight I/Os when verifying pool during import (int)
parm:           zfs_multilist_num_sublists:Number of sublists used in each multilist (int)
parm:           zfs_multihost_import_intervals:Number of zfs_multihost_interval periods to wait for activity (uint)
parm:           zfs_multihost_fail_intervals:Max allowed period without a successful mmp write (uint)
parm:           zfs_multihost_interval:Milliseconds between mmp writes to each leaf
parm:           zfs_metaslab_find_max_tries:Normally only consider this many of the best metaslabs in each vdev (int)
parm:           zfs_metaslab_try_hard_before_gang:Try hard to allocate before ganging (int)
parm:           zfs_metaslab_mem_limit:Percentage of memory that can be used to store metaslab range trees (int)
parm:           zfs_metaslab_max_size_cache_sec:How long to trust the cached max chunk size of a metaslab (ulong)
parm:           metaslab_df_use_largest_segment:When looking in size tree, use largest segment instead of exact fit (int)
parm:           metaslab_df_max_search:Max distance (bytes) to search forward before using size tree (int)
parm:           metaslab_force_ganging:Blocks larger than this size are forced to be gang blocks (ulong)
parm:           zfs_metaslab_switch_threshold:Segment-based metaslab selection maximum buckets before switching (int)
parm:           zfs_metaslab_segment_weight_enabled:Enable segment-based metaslab selection (int)
parm:           metaslab_bias_enabled:Enable metaslab group biasing (int)
parm:           metaslab_lba_weighting_enabled:Prefer metaslabs with lower LBAs (int)
parm:           metaslab_fragmentation_factor_enabled:Use the fragmentation metric to prefer less fragmented metaslabs (int)
parm:           zfs_metaslab_fragmentation_threshold:Fragmentation for metaslab to allow allocation (int)
parm:           zfs_mg_fragmentation_threshold:Percentage of metaslab group size that should be considered eligible for allocations unless all metaslab groups within the metaslab class have also crossed this threshold (int)
parm:           zfs_mg_noalloc_threshold:Percentage of metaslab group size that should be free to make it eligible for allocation (int)
parm:           metaslab_unload_delay_ms:Delay in milliseconds after metaslab was last used before unloading (int)
parm:           metaslab_unload_delay:Delay in txgs after metaslab was last used before unloading (int)
parm:           metaslab_preload_enabled:Preload potential metaslabs during reassessment (int)
parm:           metaslab_debug_unload:Prevent metaslabs from being unloaded (int)
parm:           metaslab_debug_load:Load all metaslabs when pool is first opened (int)
parm:           metaslab_aliquot:Allocation granularity (a.k.a. stripe size) (ulong)
parm:           zfs_zevent_console:Log events to the console (int)
parm:           zfs_zevent_cols:Max event column width (int)
parm:           zfs_zevent_len_max:Max event queue length (int)
parm:           zfs_resilver_disable_defer:Process all resilvers immediately (int)
parm:           zfs_scan_fill_weight:Tunable to adjust bias towards more filled segments during scans (int)
parm:           zfs_scan_strict_mem_lim:Tunable to attempt to reduce lock contention (int)
parm:           zfs_scan_mem_lim_soft_fact:Fraction of hard limit used as soft limit (int)
parm:           zfs_scan_max_ext_gap:Max gap in bytes between sequential scrub / resilver I/Os (ulong)
parm:           zfs_scan_checkpoint_intval:Scan progress on-disk checkpointing interval (int)
parm:           zfs_scan_legacy:Scrub using legacy non-sequential method (int)
parm:           zfs_scan_issue_strategy:IO issuing strategy during scrubbing. 0 = default, 1 = LBA, 2 = size (int)
parm:           zfs_scan_mem_lim_fact:Fraction of RAM for scan hard limit (int)
parm:           zfs_free_bpobj_enabled:Enable processing of the free_bpobj (int)
parm:           zfs_max_async_dedup_frees:Max number of dedup blocks freed in one txg (ulong)
parm:           zfs_async_block_max_blocks:Max number of blocks freed in one txg (ulong)
parm:           zfs_no_scrub_prefetch:Set to disable scrub prefetching (int)
parm:           zfs_no_scrub_io:Set to disable scrub I/O (int)
parm:           zfs_scan_suspend_progress:Set to prevent scans from progressing (int)
parm:           zfs_resilver_min_time_ms:Min millisecs to resilver per txg (int)
parm:           zfs_free_min_time_ms:Min millisecs to free per txg (int)
parm:           zfs_obsolete_min_time_ms:Min millisecs to obsolete per txg (int)
parm:           zfs_scrub_min_time_ms:Min millisecs to scrub per txg (int)
parm:           zfs_scan_vdev_limit:Max bytes in flight per leaf vdev for scrubs and resilvers (ulong)
parm:           zfs_zil_clean_taskq_maxalloc:Max number of taskq entries that are cached (int)
parm:           zfs_zil_clean_taskq_minalloc:Number of taskq entries that are pre-populated (int)
parm:           zfs_zil_clean_taskq_nthr_pct:Max percent of CPUs that are used per dp_sync_taskq (int)
parm:           zfs_sync_taskq_batch_pct:Max percent of CPUs that are used to sync dirty data (int)
parm:           zfs_delay_scale:How quickly delay approaches infinity (ulong)
parm:           zfs_dirty_data_sync_percent:Dirty data txg sync threshold as a percentage of zfs_dirty_data_max (int)
parm:           zfs_dirty_data_max_max:zfs_dirty_data_max upper bound in bytes (ulong)
parm:           zfs_dirty_data_max:Determines the dirty space limit (ulong)
parm:           zfs_delay_min_dirty_percent:Transaction delay threshold (int)
parm:           zfs_dirty_data_max_max_percent:zfs_dirty_data_max upper bound as % of RAM (int)
parm:           zfs_dirty_data_max_percent:Max percent of RAM allowed to be dirty (int)
parm:           zfs_livelist_min_percent_shared:Threshold at which livelist is disabled (int)
parm:           zfs_livelist_max_entries:Size to start the next sub-livelist in a livelist (ulong)
parm:           zfs_allow_redacted_dataset_mount:Allow mounting of redacted datasets (int)
parm:           zfs_max_recordsize:Max allowed record size (int)
parm:           zfs_disable_ivset_guid_check:Set to allow raw receives without IVset guids (int)
parm:           zfetch_array_rd_sz:Number of bytes in a array_read (ulong)
parm:           zfetch_max_idistance:Max bytes to prefetch indirects for per stream (uint)
parm:           zfetch_max_distance:Max bytes to prefetch per stream (uint)
parm:           zfetch_min_sec_reap:Min time before stream reclaim (uint)
parm:           zfetch_max_streams:Max number of streams per zfetch (uint)
parm:           zfs_prefetch_disable:Disable all ZFS prefetching (int)
parm:           send_holes_without_birth_time:Ignore hole_birth txg for zfs send (int)
parm:           ignore_hole_birth:Alias for send_holes_without_birth_time (int)
parm:           zfs_pd_bytes_max:Max number of bytes to prefetch (int)
parm:           zfs_override_estimate_recordsize:Override block size estimate with fixed size (int)
parm:           zfs_send_no_prefetch_queue_ff:Send queue fill fraction for non-prefetch queues (int)
parm:           zfs_send_queue_ff:Send queue fill fraction (int)
parm:           zfs_send_no_prefetch_queue_length:Maximum send queue length for non-prefetch queues (int)
parm:           zfs_send_unmodified_spill_blocks:Send unmodified spill blocks (int)
parm:           zfs_send_queue_length:Maximum send queue length (int)
parm:           zfs_send_corrupt_data:Allow sending corrupt data (int)
parm:           zfs_recv_write_batch_size:Maximum amount of writes to batch into one transaction (int)
parm:           zfs_recv_queue_ff:Receive queue fill fraction (int)
parm:           zfs_recv_queue_length:Maximum receive queue length (int)
parm:           dmu_object_alloc_chunk_shift:CPU-specific allocator grabs 2^N objects at once (int)
parm:           dmu_prefetch_max:Limit one prefetch call to this size (int)
parm:           zfs_dmu_offset_next_sync:Enable forcing txg sync to find holes (int)
parm:           zfs_per_txg_dirty_frees_percent:Percentage of dirtied blocks from frees in one TXG (ulong)
parm:           zfs_nopwrite_enabled:Enable NOP writes (int)
parm:           zfs_dedup_prefetch:Enable prefetching dedup-ed blks (int)
parm:           zfs_dbuf_state_index:Calculate arc header index (int)
parm:           dbuf_metadata_cache_shift:Set the size of the dbuf metadata cache to a log2 fraction of arc size. (int)
parm:           dbuf_cache_shift:Set the size of the dbuf cache to a log2 fraction of arc size. (int)
parm:           dbuf_metadata_cache_max_bytes:Maximum size in bytes of the dbuf metadata cache. (ulong)
parm:           dbuf_cache_lowater_pct:Percentage below dbuf_cache_max_bytes when the evict thread stops evicting dbufs. (uint)
parm:           dbuf_cache_hiwater_pct:Percentage over dbuf_cache_max_bytes when dbufs must be evicted directly. (uint)
parm:           dbuf_cache_max_bytes:Maximum size in bytes of the dbuf cache. (ulong)
parm:           zfs_arc_evict_batch_limit:The number of headers to evict per sublist before moving to the next (int)
parm:           zfs_arc_eviction_pct:When full, ARC allocation waits for eviction of this % of alloc size (int)
parm:           zfs_arc_dnode_reduce_percent:Percentage of excess dnodes to try to unpin (ulong)
parm:           zfs_arc_dnode_limit_percent:Percent of ARC meta buffers for dnodes
parm:           zfs_arc_dnode_limit:Minimum bytes of dnodes in arc
parm:           zfs_arc_sys_free:System free memory target size in bytes
parm:           zfs_arc_lotsfree_percent:System free memory I/O throttle in bytes
parm:           l2arc_mfuonly:Cache only MFU data from ARC into L2ARC (int)
parm:           l2arc_rebuild_blocks_min_l2size:Min size in bytes to write rebuild log blocks in L2ARC (ulong)
parm:           l2arc_rebuild_enabled:Rebuild the L2ARC when importing a pool (int)
parm:           l2arc_meta_percent:Percent of ARC size allowed for L2ARC-only headers (int)
parm:           l2arc_norw:No reads during writes (int)
parm:           l2arc_feed_again:Turbo L2ARC warmup (int)
parm:           l2arc_noprefetch:Skip caching prefetched buffers (int)
parm:           l2arc_feed_min_ms:Min feed interval in milliseconds (ulong)
parm:           l2arc_feed_secs:Seconds between L2ARC writing (ulong)
parm:           l2arc_trim_ahead:TRIM ahead L2ARC write size multiplier (ulong)
parm:           l2arc_headroom_boost:Compressed l2arc_headroom multiplier (ulong)
parm:           l2arc_headroom:Number of max device writes to precache (ulong)
parm:           l2arc_write_boost:Extra write bytes during device warmup (ulong)
parm:           l2arc_write_max:Max write bytes per interval (ulong)
parm:           zfs_arc_min_prescient_prefetch_ms:Min life of prescient prefetched block in ms
parm:           zfs_arc_min_prefetch_ms:Min life of prefetch block in ms
parm:           zfs_compressed_arc_enabled:Disable compressed arc buffers (int)
parm:           zfs_arc_average_blocksize:Target average block size (int)
parm:           zfs_arc_p_min_shift:arc_c shift to calc min/max arc_p
parm:           zfs_arc_pc_percent:Percent of pagecache to reclaim arc to (uint)
parm:           zfs_arc_shrink_shift:log2(fraction of arc to reclaim)
parm:           zfs_arc_p_dampener_disable:Disable arc_p adapt dampener (int)
parm:           zfs_arc_grow_retry:Seconds before growing arc size
parm:           zfs_arc_meta_strategy:Meta reclaim strategy (int)
parm:           zfs_arc_meta_adjust_restarts:Limit number of restarts in arc_evict_meta (int)
parm:           zfs_arc_meta_prune:Meta objects to scan for prune (int)
parm:           zfs_arc_meta_min:Min arc metadata
parm:           zfs_arc_meta_limit_percent:Percent of arc size for arc meta limit
parm:           zfs_arc_meta_limit:Metadata limit for arc size
parm:           zfs_arc_max:Max arc size
parm:           zfs_arc_min:Min arc size


# modinfo spl
name:           spl
filename:       (builtin)
description:    Solaris Porting Layer
author:         OpenZFS
file:           fs/zfs/spl/spl
license:        GPL
version:        2.0.3-dragon
parm:           spl_taskq_kick:Write nonzero to kick stuck taskqs to spawn more threads
parm:           spl_taskq_thread_sequential:Create new taskq threads after N sequential tasks (int)
parm:           spl_taskq_thread_priority:Allow non-default priority for taskq threads (int)
parm:           spl_taskq_thread_dynamic:Allow dynamic taskq threads (int)
parm:           spl_taskq_thread_bind:Bind taskq thread to CPU by default (int)
parm:           spl_max_show_tasks:Max number of tasks shown in taskq proc (uint)
parm:           spl_kmem_cache_kmem_threads:Number of spl_kmem_cache threads (uint)
parm:           spl_kmem_cache_slab_limit:Objects less than N bytes use the Linux slab (uint)
parm:           spl_kmem_cache_max_size:Maximum size of slab in MB (uint)
parm:           spl_kmem_cache_obj_per_slab:Number of objects per slab (uint)
parm:           spl_kmem_cache_reclaim:Single reclaim pass (0x1) (uint)
parm:           spl_kmem_cache_magazine_size:Default magazine size (2-256), set automatically (0) (uint)
parm:           spl_kmem_alloc_max:Maximum size in bytes for a kmem_alloc() (uint)
parm:           spl_kmem_alloc_warn:Warning threshold in bytes for a kmem_alloc() (uint)
parm:           spl_hostid_path:The system hostid file (/etc/hostid) (charp)
parm:           spl_hostid:The system hostid. (ulong)
parm:           spl_panic_halt:Cause kernel panic on assertion failures (uint)
parm:           spl_schedule_hrtimeout_slack_us:schedule_hrtimeout_range() delta/slack value in us, default(0)


# modinfo icp
name:           icp
filename:       (builtin)
author:         OpenZFS
file:           fs/zfs/icp/icp
license:        CDDL
version:        2.0.3-dragon
parm:           icp_aes_impl:Select aes implementation.
parm:           icp_gcm_avx_chunk_size:How many bytes to process while owning the FPU
parm:           icp_gcm_impl:Select gcm implementation.


# modinfo zlua
name:           zlua
filename:       (builtin)
description:    Lua Interpreter for ZFS
file:           fs/zfs/lua/zlua
license:        Dual MIT/GPL
version:        2.0.3-dragon


Reiser5 (Software Framework Release: 5.1.3).

Enable Reiser5 support

Note: that by Linux kernel and GNU utilities the testing stuff is still recognized as “Reiser4”. Make sure there is the following message in kernel logs: “Loading Reiser4 (Software Framework Release: 5.X.Y)”

Wiki Reiser5

Documentation Reiser5

$ dmesg | egrep Reiser
[  100.533437] Loading Reiser4 (Software Framework Release: 5.1.3). See for a description of Reiser4.

# modinfo reiser4
filename:       /lib/modules/5.12.8-dragon-sandybridge/kernel/fs/reiser4/reiser4.ko
alias:          char-major-10-243
alias:          devname:reiser4-control
alias:          fs-reiser4
description:    Reiser4 filesystem
author:         Hans Reiser <Reiser@Namesys.COM>
license:        GPL
vermagic:       5.12.8-dragon-sandybridge SMP mod_unload modversions 
name:           reiser4
intree:         Y
retpoline:      Y
srcversion:     266ACD4150AD966E625A526
sig_id:         PKCS#7
signer:         Build time autogenerated kernel key
sig_key:        49:7C:67:CF:04:09:39:CD:A5:EF:CE:6C:C7:10:A1:7A:6A:68:63:0E
sig_hashalgo:   sha512
signature:      7F:F6:46:BB:FD:9C:EB:6D:25:B7:1C:C9:12:80:68:C3:7A:91:0A:DC:

or built-in variant

$ modinfo reiser4
name:           reiser4
filename:       (builtin)
alias:          char-major-10-243
alias:          devname:reiser4-control
alias:          fs-reiser4
description:    Reiser4 filesystem
author:         Hans Reiser <Reiser@Namesys.COM>
file:           fs/reiser4/reiser4
license:        GPL

It is recommended and also the default to use the zstd1 plugin by formatting with the following options:

# DEV_REISER=/dev/sdd1
# VOL_ID=`uuid -v4`
# echo "Using uuid $VOL_ID"
# mkfs.reiser4 -U $VOL_ID -o compress=zstd1 -t 512K $DEV_REISER
Package Version: 2.0.3
Software Framework Release: 5.1.3
Copyright (C) 2001-2005 by Hans Reiser, licensing governed by reiser4progs/COPYING. 
Overriding the plugin profile by "compress=zstd1".
Block size 4096 will be used.
Linux 5.12.8-dragon-sandybridge is detected.
Volume uuid bb09160e-1b19-4eba-9b36-204c247014b2 will be used.
Reiser4 is going to be created on /dev/sdd1.
(Yes/No): Yes
Discarding /dev/sdd1 ... done
Creating reiser4 on /dev/sdd1 ... done

# mount -t reiser4 -o rw,nosuid,nodev,noexec,relatime,noauto,users,onerror=remount-ro,tmgr.atom_max_size=100000 0 2 $DEV_REISER /mnt/reiser4

or add to /etc/fstab

UUID=<disk uuid> /mnt/reiser4  reiser4 rw,nosuid,nodev,noexec,relatime,noauto,users,onerror=remount-ro,tmgr.atom_max_size=100000 0 2
# volume.reiser4 -l
Package Version: 2.0.3
Software Framework Release: 5.1.3
Volume ID: 0a59084c-9042-4757-9ee3-4abb2b2cc95e (Active)
Brick ID: 459bf92c-666d-46a9-b756-5d0927e6ca25, Device name: /dev/sdd1

# dmesg | egrep reiser4
[  490.917275] reiser4[mount(4752)]: reiser4_register_subvol (fs/reiser4/init_volume.c:221)[edward-1932]:
[  490.919499] reiser4 (sdd1): found disk format 5.1.3.
[  502.297983] reiser4 (/dev/sdd1): using Hybrid Transaction Model.
[  502.297990] reiser4: brick /dev/sdd1 activated

Reiser5 Tools for kernel v5.12+

You can download Raiser5 libraries and utilities from the download area.


Enable AMDGPU+OpenCL driver for AMD Saturn XT FirePro M6100

AMD Radeon chipsets: BONAIRE

OpenCL for all Bonaire chipsets only works on Dragon Kernel!

$ apt search mesa-opencl-icd 

mesa-opencl-icd/hirsute-proposed,now 20.3.4-1 amd64
  free implementation of the OpenCL API -- ICD runtime

$ apt install mesa-opencl-icd
# cat /etc/OpenCL/vendors/mesa.icd

Number of platforms                               1
  Platform Name                                   Clover
  Platform Vendor                                 Mesa
  Platform Version                                OpenCL 1.1 Mesa 20.3.4
  Platform Profile                                FULL_PROFILE
  Platform Extensions                             cl_khr_icd
  Platform Extensions function suffix             MESA

  Platform Name                                   Clover
Number of devices                                 1
  Device Name                                     AMD Radeon HD 8950 (BONAIRE, DRM 3.40.0, 5.12.8-dragon-sandybridge, LLVM 13.0.0)
  Device Vendor                                   AMD
  Device Vendor ID                                0x1002
  Device Version                                  OpenCL 1.1 Mesa 20.3.4
  Driver Version                                  20.3.4
  Device OpenCL C Version                         OpenCL C 1.1 
  Device Type                                     GPU
  Device Profile                                  FULL_PROFILE
  Device Available                                Yes
  Compiler Available                              Yes
  Max compute units                               12
  Max clock frequency                             1075MHz
  Max work item dimensions                        3
  Max work item sizes                             256x256x256
  Max work group size                             256
  Preferred work group size multiple (kernel)     64
  Preferred / native vector sizes                 
    char                                                16 / 16      
    short                                                8 / 8       
    int                                                  4 / 4       
    long                                                 2 / 2       
    half                                                 0 / 0        (n/a)
    float                                                4 / 4       
    double                                               2 / 2        (cl_khr_fp64)
  Half-precision Floating-point support           (n/a)
  Single-precision Floating-point support         (core)
    Denormals                                     No
    Infinity and NANs                             Yes
    Round to nearest                              Yes
    Round to zero                                 No
    Round to infinity                             No
    IEEE754-2008 fused multiply-add               No
    Support is emulated in software               No
    Correctly-rounded divide and sqrt operations  No
  Double-precision Floating-point support         (cl_khr_fp64)
    Denormals                                     Yes
    Infinity and NANs                             Yes
    Round to nearest                              Yes
    Round to zero                                 Yes
    Round to infinity                             Yes
    IEEE754-2008 fused multiply-add               Yes
    Support is emulated in software               No
  Address bits                                    64, Little-Endian
  Global memory size                              3221225472 (3GiB)
  Error Correction support                        No
  Max memory allocation                           1717986918 (1.6GiB)
  Unified memory for Host and Device              No
  Minimum alignment for any data type             128 bytes
  Alignment of base address                       32768 bits (4096 bytes)
  Global Memory cache type                        None
  Image support                                   No
  Local memory type                               Local
  Local memory size                               32768 (32KiB)
  Max number of constant args                     16
  Max constant buffer size                        67108864 (64MiB)
  Max size of kernel argument                     1024
  Queue properties
    Out-of-order execution                        No
    Profiling                                     Yes
  Profiling timer resolution                      0ns
  Execution capabilities
    Run OpenCL kernels                            Yes
    Run native kernels                            No
  Device Extensions                               cl_khr_byte_addressable_store cl_khr_global_int32_base_atomics
                                                  cl_khr_global_int32_extended_atomics cl_khr_local_int32_base_atomics
                                                  cl_khr_local_int32_extended_atomics cl_khr_int64_base_atomics
                                                  cl_khr_int64_extended_atomics cl_khr_fp64

NULL platform behavior
  clGetPlatformInfo(NULL, CL_PLATFORM_NAME, ...)  Clover
  clGetDeviceIDs(NULL, CL_DEVICE_TYPE_ALL, ...)   Success [MESA]
  clCreateContext(NULL, ...) [default]            Success [MESA]
  clCreateContextFromType(NULL, CL_DEVICE_TYPE_DEFAULT)  Success (1)
    Platform Name                                 Clover
    Device Name                                   AMD Radeon HD 8950 (BONAIRE, DRM 3.40.0, 5.12.8-dragon-sandybridge, LLVM 13.0.0)
  clCreateContextFromType(NULL, CL_DEVICE_TYPE_CPU)  No devices found in platform
  clCreateContextFromType(NULL, CL_DEVICE_TYPE_GPU)  Success (1)
    Platform Name                                 Clover
    Device Name                                   AMD Radeon HD 8950 (BONAIRE, DRM 3.40.0, 5.12.8-dragon-sandybridge, LLVM 13.0.0)
  clCreateContextFromType(NULL, CL_DEVICE_TYPE_ACCELERATOR)  No devices found in platform
  clCreateContextFromType(NULL, CL_DEVICE_TYPE_CUSTOM)  No devices found in platform
  clCreateContextFromType(NULL, CL_DEVICE_TYPE_ALL)  Success (1)
    Platform Name                                 Clover
    Device Name                                   AMD Radeon HD 8950 (BONAIRE, DRM 3.40.0, 5.12.8-dragon-sandybridge, LLVM 13.0.0)

ICD loader properties
  ICD loader Name                                 OpenCL ICD Loader
  ICD loader Vendor                               OCL Icd free software
  ICD loader Version                              2.2.14
  ICD loader Profile                              OpenCL 3.0


[    3.745223] [drm] amdgpu kernel modesetting enabled.
[    3.749588] fb0: switching to amdgpudrmfb from EFI VGA
[    3.750924] [drm] initializing kernel modesetting (BONAIRE 0x1002:0x6640 0x1028:0x04A4 0x00).
[    3.751332] [drm] register mmio base: 0xE4000000
[    3.751335] [drm] register mmio size: 262144
[    3.751338] [drm] PCIE atomic ops is not supported
[    3.751343] [drm] add ip block number 0 <cik_common>
[    3.751346] [drm] add ip block number 1 <gmc_v7_0>
[    3.751348] [drm] add ip block number 2 <cik_ih>
[    3.751350] [drm] add ip block number 3 <gfx_v7_0>
[    3.751352] [drm] add ip block number 4 <cik_sdma>
[    3.751354] [drm] add ip block number 5 <powerplay>
[    3.751356] [drm] add ip block number 6 <dce_v8_0>
[    3.751358] [drm] add ip block number 7 <uvd_v4_2>
[    3.751360] [drm] add ip block number 8 <vce_v2_0>
[    3.752461] [drm] vm size is 64 GB, 2 levels, block size is 10-bit, fragment size is 9-bit
[    3.752523] [drm] Detected VRAM RAM=2048M, BAR=256M
[    3.752525] [drm] RAM width 128bits GDDR5
[    3.752648] [drm] amdgpu: 2048M of VRAM memory ready
[    3.752652] [drm] amdgpu: 3072M of GTT memory ready.
[    3.752664] [drm] GART: num cpu pages 262144, num gpu pages 262144
[    3.753145] [drm] PCIE GART of 1024M enabled (table at 0x000000F4007E9000).
[    4.286236] [drm] amdgpu atom DIG backlight initialized
[    4.286243] [drm] AMDGPU Display Connectors
[    4.286245] [drm] Connector 0:
[    4.286247] [drm]   LVDS-1
[    4.286249] [drm]   DDC: 0x195c 0x195c 0x195d 0x195d 0x195e 0x195e 0x195f 0x195f
[    4.286252] [drm]   Encoders:
[    4.286254] [drm]     LCD1: INTERNAL_UNIPHY
[    4.286256] [drm] Connector 1:
[    4.286257] [drm]   DP-1
[    4.286258] [drm]   HPD1
[    4.286260] [drm]   DDC: 0x194c 0x194c 0x194d 0x194d 0x194e 0x194e 0x194f 0x194f
[    4.286263] [drm]   Encoders:
[    4.286264] [drm]     DFP1: INTERNAL_UNIPHY1
[    4.286266] [drm] Connector 2:
[    4.286267] [drm]   DP-2
[    4.286268] [drm]   HPD2
[    4.286270] [drm]   DDC: 0x1950 0x1950 0x1951 0x1951 0x1952 0x1952 0x1953 0x1953
[    4.286273] [drm]   Encoders:
[    4.286274] [drm]     DFP2: INTERNAL_UNIPHY1
[    4.286275] [drm] Connector 3:
[    4.286277] [drm]   DP-3
[    4.286278] [drm]   HPD3
[    4.286279] [drm]   DDC: 0x1954 0x1954 0x1955 0x1955 0x1956 0x1956 0x1957 0x1957
[    4.286282] [drm]   Encoders:
[    4.286283] [drm]     DFP3: INTERNAL_UNIPHY2
[    4.286285] [drm] Connector 4:
[    4.286287] [drm]   VGA-1
[    4.286288] [drm]   DDC: 0x1970 0x1970 0x1971 0x1971 0x1972 0x1972 0x1973 0x1973
[    4.286291] [drm]   Encoders:
[    4.286292] [drm]     CRT1: INTERNAL_KLDSCP_DAC1
[    4.286358] [drm] Found UVD firmware Version: 1.64 Family ID: 9
[    4.286816] [drm] Found VCE firmware Version: 50.10 Binary ID: 2
[    4.287277] [drm] PCIE gen 2 link speeds already enabled
[    4.329871] [drm] UVD initialized successfully.
[    4.449908] [drm] VCE initialized successfully.
[    5.829247] [drm] fb mappable at 0xD0BD4000
[    5.829263] [drm] vram apper at 0xD0000000
[    5.829265] [drm] size 8294400
[    5.829267] [drm] fb depth is 24
[    5.829268] [drm]    pitch is 7680
[    5.829351] fbcon: amdgpudrmfb (fb0) is primary device
[    6.382724] amdgpu 0000:01:00.0: [drm] fb0: amdgpudrmfb frame buffer device
[    6.392542] [drm] Initialized amdgpu 3.40.0 20150101 for 0000:01:00.0 on minor 0
[    7.410652] systemd[1]: Starting Load Kernel Module drm...
[    7.481621] systemd[1]: modprobe@drm.service: Succeeded.
[    7.483335] systemd[1]: Finished Load Kernel Module drm.

$ dmesg | egrep kfd
[    5.768149] kfd kfd: Allocated 3969056 bytes on gart
[    5.769620] kfd kfd: added device 1002:6640
$ clinfo -l
Platform #0: Clover
 `-- Device #0: AMD Radeon HD 8950 (BONAIRE, DRM 3.40.0, 5.12.8-dragon-sandybridge, LLVM 13.0.0)

$ clinfo | egrep -i opencl
  Platform Version                                OpenCL 1.1 Mesa 20.3.4
  Device Version                                  OpenCL 1.1 Mesa 20.3.4
  Device OpenCL C Version                         OpenCL C 1.1 
    Run OpenCL kernels                            Yes
  ICD loader Name                                 OpenCL ICD Loader
  ICD loader Profile                              OpenCL 3.0
$ glxinfo | egrep -i opengl
OpenGL vendor string: AMD
OpenGL renderer string: AMD Radeon HD 8950 (BONAIRE, DRM 3.40.0, 5.12.8-dragon-sandybridge, LLVM 13.0.0)
OpenGL core profile version string: 4.6 (Core Profile) Mesa 20.3.4
OpenGL core profile shading language version string: 4.60
OpenGL core profile context flags: (none)
OpenGL core profile profile mask: core profile
OpenGL core profile extensions:
OpenGL version string: 4.6 (Compatibility Profile) Mesa 20.3.4
OpenGL shading language version string: 4.60
OpenGL context flags: (none)
OpenGL profile mask: compatibility profile
OpenGL extensions:
OpenGL ES profile version string: OpenGL ES 3.2 Mesa 20.3.4
OpenGL ES profile shading language version string: OpenGL ES GLSL ES 3.20
OpenGL ES profile extensions:
# lspci | egrep -i VGA
01:00.0 VGA compatible controller: Advanced Micro Devices, Inc. [AMD/ATI] Saturn XT [FirePro M6100]

# lspci -knn | egrep -iA2 vga
01:00.0 VGA compatible controller [0300]: Advanced Micro Devices, Inc. [AMD/ATI] Saturn XT [FirePro M6100] [1002:6640]
        Subsystem: Dell Saturn XT [FirePro M6100] [1028:04a4]
        Kernel driver in use: amdgpu
GRUB_CMDLINE_LINUX="modprobe.blacklist=radeon amdgpu.si_support=0 amdgpu.cik_support=1 amdgpu.vm_fragment_size=9 amdgpu.ppfeaturemask=0"
chip "amdgpu-pci-*"
    ignore fan1

    # powerplay
    ignore in0
    ignore power1

I recommend using the following utilities to monitor the device:

Daemon for radeon-profile GUI

Application to read current clocks of ATi Radeon cards


Enable BTRFS async discard

UUID=<uuid> / btrfs defaults,ssd,relatime,space_cache=v2,discard=async,compress=zstd,subvol=@ 0 1

BTRFS Tools for kernel v5.12+

Package version (download from Dragon support site):


Kernel verification can be done without IMA security subsystem enabled.

On x86, a signature is embedded into a PE file (MS format) header of binary. Since arm64’s “Image” can also be seen as a PE file as far as CONFIG_EFI is enabled, we adopt this format for kernel signing.

You can create a signed kernel image with:

$ sbsign --key ${KEY} --cert ${CERT} Image

For signing Dragon Kernel for EFI Boot with your MOK

$ openssl x509 -in /var/lib/shim-signed/mok/MOK.der -inform DER -outform PEM -out ~/MOK.pem
$ sudo sbsign --key /var/lib/shim-signed/mok/MOK.priv --cert ~/MOK.pem /boot/vmlinuz-5.12.8-dragon-generic --output /boot/vmlinuz-5.12.8-dragon-generic.signed
$ sudo cp /boot/initrd.img-5.12.8-dragon-generic{,.signed}
$ sudo update-grub
$ reboot
$ sudo rm /boot/vmlinuz-5.12.8-dragon-generic
$ sudo rm /boot/initrd.img-5.12.8-dragon-generic
$ sudo update-grub
$ reboot

Thanks Edgard Pineda “epineda”


Fixes booting kernel for i915 video chipset

If kernel starting and boot screen black or boot process stop then:

From boot grub menu enter “e” key and edit kernel boot line and press F10 for boot.

Disable the initramfs

Rationale: To load additional storage controller and filesystem drivers after the kernel has initialised, which may be required to mount the root filesystem, we need an initial ramdisk filesystem ("initramfs") that contains the modules and can load those that are required.

Since this is userspace code, it is much easier to provide flexibility here than in the kernel. The Ubuntu default mount-by-UUID and mount-by-LABEL support are supplied by the initramfs, as well as support for resuming from a hibernated disk image.

The initramfs may also contain the mechanism for network boot, as well as support for Software RAID, Logical Volume Management (LVM) and disk encryption.

Advantage: Disabling the initramfs provides a massive performance advantage since it does not need to be uncompressed or unpacked while the kernel initialises (by far the longest part) and does not need to be run before mounting the root filesystem.

Disadvantage: You will lose support for mounting by UUID, mounting by LABEL, resuming from hibernate, Software RAID, Logical Volume Management and disk encryption. You will need to reapply this change for each kernel update.

Method: First ensure that your storage controller and filesystem drivers are compiled into the kernel as detailed above. At this point you can test booting without an initramfs by pressing Escape at the GRUB menu and editing the option: delete the "initrd" stanza, and edit the kernel stanza to change the "root" option from a UUID to the actual path of your disk (e.g. /dev/sda1).

If this is successful, you can make the changes permanent on your system for your kernel:

remove the /boot/initrd.img-* for your new kernel
edit /boot/grub/grub.cfg, locate the stanza for your new kernel, remove the "initrd" line and modify the "kernel" line as detailed above.

If your system uses the default Intel ATA PIIX storage controller and ext2/3/4 filesystem family, you can make this change in a way that applies to each subsequent kernel update.

Follow the steps above, and additionally:

While editing /boot/grub/grub.cfg, locate the "# kopt=root=" line and make the same change as you did for the "kernel" line.

Remove packages: $ sudo apt purge cryptsetup-initramfs* initramfs-tools* initramfs-tools-devices*

Detecting available microcode update:

It is possible to find out if the intel-ucode.img contains a microcode image for the running CPU with iucode-tool.

Load the cpuid kernel module:

# modprobe cpuid

Extract microcode image and search it for your cpuid:

# bsdtar -Oxf ./initrd.img-5.12.8-dragon-sandybridge  | iucode_tool -tb -lS -
iucode_tool: system has processor(s) with signature 0x000206a7
microcode bundle 1: (stdin)
selected microcodes:
  001/001: sig 0x000206a7, pf_mask 0x12, 2019-02-17, rev 0x002f, size 12288

To manually generate the microcode cpio archive use iucode_tool:

root #iucode_tool -S --write-earlyfw=/boot/initrd.img-5.12.8-dragon-sandybridge /lib/firmware/intel-ucode/*
iucode_tool: system has processor(s) with signature 0x000206a7
iucode_tool: Writing selected microcodes to: /boot/initrd.img-5.12.8-dragon-sandybridge

run "upgrade-grub"

Always keep a distribution kernel with an initramfs to recover from errors, otherwise you'll need to use a LiveCD to rescue your system.

New method without initram-fs/disk (efistub compatible)


This will only work on a 64-bit kernel and will have no effect otherwise. 32-bit systems need to use an initramfs.


This method should be preferable, especially for EFI-Stub systems (some motherboard firmware might have issues with parsing/passing custom boot command line options), since these changes are less likely to leave the system unbootable (and possibly unrepairable without an EFI compatible rescue disk which can be very tricky on headless machines) the way a broken firmware boot entry and/or incorrect initram-fs/disk would, while it also works on BIOS systems or EFI systems with custom bootloaders on disk.


$ sudo apt install intel-microcode amd64-microcode iucode-tool microcode.ctl

$ iucode_tool -S
iucode_tool: system has processor(s) with signature 0x000206a7

$ iucode_tool -S -l /lib/firmware/intel-ucode/*
iucode_tool: system has processor(s) with signature 0x000206a7


microcode bundle 19: /lib/firmware/intel-ucode/06-2a-07


selected microcodes:
  019/001: sig 0x000206a7, pf_mask 0x12, 2019-02-17, rev 0x002f, size 12288

The signature is found in microcode bundle 19, so the filename to use is /lib/firmware/intel-ucode/06-2a-07

Kernel config



Every option must be set as built into the kernel, not as a kernel module.

KERNEL Enabling Microcode Loading Support
Processor type and features  --->
    <*> CPU microcode loading support
    [*]   Intel microcode loading support

Device Drivers  --->
  Generic Driver Options  --->
    Firmware Loader  --->
      -*-   Firmware loading facility 
      (intel-ucode/06-2a-07) Build named firmware blobs into the kernel binary 
      (/lib/firmware) Firmware blobs root directory (NEW)


The CONFIG_EXTRA_FIRMWARE and CONFIG_EXTRA_FIRMWARE_DIR options need to be set to the values identified by iucode_tool. In this example for an Intel i7-2920XM processor, CONFIG_EXTRA_FIRMWARE is set to intel-ucode/06-2a-07 and CONFIG_EXTRA_FIRMWARE_DIR is set to /lib/firmware.
The CONFIG_EXTRA_FIRMWARE option allows specifying multiple firmware files by listing them space-separated.


After the next reboot, the loaded microcode revision can be verified by running:

$grep microcode /proc/cpuinfo
microcode       : 0x2f
microcode       : 0x2f
microcode       : 0x2f
microcode       : 0x2f
microcode       : 0x2f
microcode       : 0x2f
microcode       : 0x2f
microcode       : 0x2f

The dmesg output should include:

#dmesg | grep microcode
[    0.000000] microcode: microcode updated early to revision 0x2f, date = 2019-02-17
[    2.582941] microcode: sig=0x206a7, pf=0x10, revision=0x2f
[    2.584164] microcode: Microcode Update Driver: v2.2.

Rebuild and install the kernel as usual.


Be aware that injecting the microcode update directly into the motherboard firmware (which might sounds tempting) might result in CPU0 being updated but the rest of the CPUs (or CPU cores in a multi-core system) being left at their initial revision (which might cause more problems than running them all at the same initial version). And, since most stock motherboard firmware has some microcode updates (even in their initial release versions), it's probably a good enough reason for everybody to make sure their kernel tries to update all CPUs (and cores) to the same version (so, let this update driver running even if the kernel has the same version which is stored in the motherboard firmware). Injecting the microcode into the firmware might be desirable still (to make sure it's loaded for the boot CPU before the kernel is loaded and able to update the rest of the microcode).

Example config files for Intel i5 Westmere, 4Gb RAM

If use cgroup v1

GRUB_CMDLINE_LINUX_DEFAULT="rootfstype=xfs root=/dev/sda3 noresume spectre_v2_user_ibpb_mode=enter systemd.gpt_auto=0 net.ifnames=0 biosdevname=0 mds=full ipv6.disable=1 iommu=force intel_iommu=on systemd.legacy_systemd_cgroup_controller=1"
GRUB_CMDLINE_LINUX="amdgpu.si_support=0 amdgpu.cik_support=1 amdgpu.vm_fragment_size=9 amdgpu.ppfeaturemask=0 clocksource=hpet trace_clock=global modprobe.blacklist=radeon randomize_vmalloc=1"

GRUB_CMDLINE_LINUX_DEFAULT="rootfstype=xfs root=/dev/sda3 noresume spectre_v2_user_ibpb_mode=enter systemd.gpt_auto=0 net.ifnames=0 biosdevname=0 mds=full ipv6.disable=1 iommu=force intel_iommu=on systemd.legacy_systemd_cgroup_controller=1"
GRUB_CMDLINE_LINUX="clocksource=hpet trace_clock=global modprobe.blacklist=amdgpu randomize_vmalloc=1"

*If use cgroup v2**

GRUB_CMDLINE_LINUX_DEFAULT="rootfstype=xfs root=/dev/sda3 noresume spectre_v2_user_ibpb_mode=enter systemd.gpt_auto=0 net.ifnames=0 biosdevname=0 mds=full ipv6.disable=1 iommu=force intel_iommu=on systemd.unified_cgroup_hierarchy=1 cgroup_no_v1="all""
GRUB_CMDLINE_LINUX="amdgpu.si_support=0 amdgpu.cik_support=1 amdgpu.vm_fragment_size=9 amdgpu.ppfeaturemask=0 clocksource=hpet trace_clock=global modprobe.blacklist=radeon randomize_vmalloc=1"

GRUB_CMDLINE_LINUX_DEFAULT="rootfstype=xfs root=/dev/sda3 noresume spectre_v2_user_ibpb_mode=enter systemd.gpt_auto=0 net.ifnames=0 biosdevname=0 mds=full ipv6.disable=1 iommu=force intel_iommu=on systemd.unified_cgroup_hierarchy=1 cgroup_no_v1="all""
GRUB_CMDLINE_LINUX="clocksource=hpet trace_clock=global modprobe.blacklist=amdgpu randomize_vmalloc=1"

Enable ZSWAP

Zswap is a kernel feature that provides a compressed RAM cache for swap pages

  • Add to grub.cfg
GRUB_CMDLINE_LINUX="zswap.compressor=lz4 zswap.max_pool_percent=15"

Tune IO scheduler

For now, add file /etc/udev/rules.d/60-ssd-scheduler.rules.

You can also add this to file 60-ssd-scheduler.rules:

For BFQ scheduler:

# Set BFQ scheduler for non-rotating disks
ACTION=="add|change", KERNEL=="sd[a-z]", TEST!="queue/rotational", ATTR{queue/scheduler}="bfq"
ACTION=="add|change", KERNEL=="sd[a-z]", ATTR{queue/rotational}=="0", ATTR{queue/scheduler}="bfq"
# Set BFQ scheduler for rotating disks
ACTION=="add|change", KERNEL=="sd[a-z]", ATTR{queue/rotational}=="1", ATTR{queue/scheduler}="bfq"

For Kyber scheduler:

# Set Kyber scheduler for non-rotating disks
ACTION=="add|change", KERNEL=="sd[a-z]", TEST!="queue/rotational", ATTR{queue/scheduler}="kyber"
ACTION=="add|change", KERNEL=="sd[a-z]", ATTR{queue/rotational}=="0", ATTR{queue/scheduler}="kyber"
# Set Kyber scheduler for rotating disks
ACTION=="add|change", KERNEL=="sd[a-z]", ATTR{queue/rotational}=="1", ATTR{queue/scheduler}="kyber"

and run a command:

# sudo udevadm control --reload && sudo udevadm trigger

Add to .bashrc file:

# Tune glibc memory allocation, optimize for low fragmentation
# limit the number of arenas

# Disable dynamic mmap threshold, see M_MMAP_THRESHOLD in "man mallopt"
export MALLOC_TOP_PAD_=131072
export MALLOC_MMAP_MAX_=65536

  • /etc/sysctl.conf
vm.laptop_mode = 0
# Core dump suidsafe
kernel.core_uses_pid = 1
kernel.core_pattern = /tmp/core-%e-%s-%u-%g-%p-%t
fs.suid_dumpable = 2
kernel.printk = 4 4 1 7
kernel.sysrq = 0
# Network
# For 1Gbps link speed
net.ipv4.udp_mem=8388608 12582912 16777216
net.ipv4.tcp_rmem=4096 87380 8388608
net.ipv4.tcp_wmem=4096 65536 8388608
net.ipv4.ip_local_port_range=1024 65535
fs.inotify.max_user_watches = 16777216
#kernel.perf_cpu_time_max_percent = 100
# Huge Page
# Memory
# 0 - IO_DELAY_TYPE_0X80
# Security

  • /etc/network/interfaces
wireless-power off

  • /etc/NetworkManager/conf.d/default-wifi-powersave-on.conf
wifi.powersave = 2

  • /etc/NetworkManager/NetworkManager.conf
wifi.powersave = 2


Copyright © 2020 Dragon Team All rights reserved.