section 9 · Kernel routines 🧠

85608 pages · page 402 of 429

all 9 (85608)9freebsd (2304)9lua (4)9p (12)

V (continued)

vdo_drain_recovery_journal(9)Drain recovery journal I/O.✨
vdo_drain_slab_depot(9)Drain all slab depot I/O.✨
vdo_dump_flusher(9)Dump the flusher, in a thread-unsafe fashion.✨
vdo_dump_hash_zones(9)Dump information about the hash zones to the log for debugging.✨
vdo_dump_logical_zone(9)Dump information about a logical zone to the log for debugging.✨
vdo_dump_packer(9)Dump the packer.✨
vdo_dump_physical_zone(9)Dump information about a physical zone to the log for debugging.✨
vdo_dump_recovery_journal_statistics(9)Dump some current statistics and other debug info from the recovery journal.✨
vdo_dump_slab_depot(9)Dump the slab depot, in a thread-unsafe fashion.✨
vdo_dump_status(9)Dump status information about a vdo to the log for debugging.✨
vdo_enable_read_only_entry(9)Enable a vdo to enter read-only mode on errors.✨
vdo_encode_component_states(9)Encode the state of all vdo components in the super block.✨
vdo_encode_super_block(9)Encode a super block into its on-disk representation.✨
vdo_encode_volume_geometry(9)Encode the on-disk representation of a volume geometry into a buffer.✨
vdo_enqueue_clean_slab_waiter(9)Wait for a clean slab.✨
vdo_enter_read_only_mode(9)Put a VDO into read-only mode and save the read-only state in the super block.✨
vdo_enter_recovery_mode(9)Put the vdo into recovery mode.✨
vdo_entry_callback_fn(9)A function to be called for each allocated PBN when traversing the forest.✨
vdo_fail_completion(9)Set the result of a completion if it does not already have an error, then finish it.✨
vdo_fetch_statistics(9)Fetch statistics on the correct thread.✨
vdo_fetch_statistics_callback(9)Action to populate a vdo_statistics structure on the admin thread.✨
vdo_filter_fn(9)Method type for vdo matching methods.✨
vdo_find_block_map_slot(9)Find the block map slot in which the block map entry for a data_vio resides and cache that result in the data_vio.✨
vdo_find_matching(9)Find and return the first (if any) vdo matching a given filter function.✨
vdo_finish_draining(9)Finish a drain operation if one was in progress.✨
vdo_finish_draining_with_result(9)Finish a drain operation with a status code.✨
vdo_finish_loading(9)Finish a load operation if one was in progress.✨
vdo_finish_loading_with_result(9)Finish a load operation with a status code.✨
vdo_finish_operation(9)Finish the current operation.✨
vdo_finish_resuming(9)Finish a resume operation if one was in progress.✨
vdo_finish_resuming_with_result(9)Finish a resume operation with a status code.✨
vdo_flush_packer(9)Request that the packer flush asynchronously.✨
vdo_format(9)Format a block device to function as a new VDO.✨
vdo_free_flusher(9)Free a flusher.✨
vdo_free_hash_zones(9)Free the hash zones.✨
vdo_free_io_submitter(9)Free the io_submitter fields and structure as needed.✨
vdo_free_logical_zones(9)Free a set of logical zones.✨
vdo_free_packer(9)Free a block packer.✨
vdo_free_physical_zones(9)Destroy the physical zones.✨
vdo_free_priority_table(9)Free a priority_table.✨
vdo_free_recovery_journal(9)Free a recovery journal.✨
vdo_free_slab_depot(9)Destroy a slab depot.✨
vdo_get_admin_state(9)Get the admin state of the vdo.✨
vdo_get_backing_device(9)Get the block device object underlying a vdo.✨
vdo_get_cached_page(9)Get the block map page from a page completion.✨
vdo_get_callback_thread_id(9)Get the id of the callback thread on which a completion is currently running.✨
vdo_get_compressed_block_fragment(9)Get a reference to a compressed fragment from a compressed block.✨
vdo_get_compressing(9)Get whether compression is enabled in a vdo.✨
vdo_get_data_region_start(9)Get the start of the data region from a geometry.✨
vdo_get_dedupe_statistics(9)Tally the statistics from all the hash zones and the UDS index.✨
vdo_get_device_name(9)Get the device name associated with the vdo target.✨
vdo_get_duplicate_lock(9)Get the PBN lock on the duplicate data location for a data_vio from the hash_lock the data_vio holds (if there is one).✨
vdo_get_flusher_thread_id(9)Get the ID of the thread on which flusher functions should be called.✨
vdo_get_increment_limit(9)Determine how many new references a block can acquire.✨
vdo_get_index_region_size(9)Get the size of the index region from a geometry.✨
vdo_get_index_region_start(9)Get the start of the index region from a geometry.✨
vdo_get_journal_block_map_data_blocks_used(9)Get the number of block map pages, allocated from data blocks, currently in use.✨
vdo_get_journal_block_sector(9)Find the recovery journal sector from the block header and sector number.✨
vdo_get_journal_operation_name(9)Get the name of a journal operation.✨
vdo_get_known_partition(9)Get a partition by id from a validated layout.✨
vdo_get_packer_statistics(9)Get the current statistics from the packer.✨
vdo_get_page(9)Initialize a page completion and get a block map page.✨
vdo_get_partition(9)Get a partition by id.✨
vdo_get_physical_blocks_allocated(9)Get the number of physical blocks in use by user data.✨
vdo_get_physical_blocks_overhead(9)Get the number of physical blocks used by vdo metadata.✨
vdo_get_physical_zone(9)Get the physical zone responsible for a given physical block number.✨
vdo_get_physical_zone_pbn_lock(9)Get the lock on a PBN if one exists.✨
vdo_get_recovery_journal_block_number(9)Get the physical block number for a given sequence number.✨
vdo_get_recovery_journal_current_sequence_number(9)Obtain the recovery journal's current sequence number.✨
vdo_get_recovery_journal_length(9)Get the number of usable recovery journal blocks.✨
vdo_get_recovery_journal_logical_blocks_used(9)Get the number of logical blocks in use by the VDO.✨
vdo_get_recovery_journal_statistics(9)Get the current statistics from the recovery journal.✨
vdo_get_recovery_journal_thread_id(9)Get the ID of a recovery journal's thread.✨
vdo_get_saved_reference_count_size(9)Get the number of blocks required to save a reference counts state covering the specified number of data blocks.✨
vdo_get_slab(9)Get the slab object for the slab that contains a specified block.✨
vdo_get_slab_depot_allocated_blocks(9)Get the total number of data blocks allocated across all the slabs in the depot.✨
vdo_get_slab_depot_data_blocks(9)Get the total number of data blocks in all the slabs in the depot.✨
vdo_get_slab_depot_statistics(9)Get all the vdo_statistics fields that are properties of the slab depot.✨
vdo_get_slab_journal_start_block(9)Get the physical block number of the start of the slab journal relative to the start block allocator partition.✨
vdo_get_slab_summary_hint_shift(9)Compute the shift for slab summary hints.✨
vdo_get_state(9)Get the current state of the vdo.✨
vdo_get_work_queue_private_data(9)Returns the private data for the current thread's work queue, or NULL if none or if the current thread is not a work queue thread.✨
vdo_in_read_only_mode(9)Check whether a vdo is in read-only mode.✨
vdo_in_recovery_mode(9)Check whether the vdo is in recovery mode.✨
vdo_increment_logical_zone_flush_generation(9)Increment the flush generation in a logical zone.✨
vdo_increment_packer_flush_generation(9)Increment the flush generation in the packer.✨
vdo_initialize_component_states(9)Initialize the components so they can be written out.✨
vdo_initialize_device_registry_once(9)Initialize the necessary structures for the device registry.✨
vdo_initialize_layout(9)Lay out the partitions of a vdo.✨
vdo_initialize_recovery_journal_post_repair(9)Initialize the journal after a repair.✨
vdo_initialize_volume_geometry(9)Initialize the volume geometry so it can be written out.✨
vdo_int_map_create(9)Allocate and initialize an int_map.✨
vdo_int_map_free(9)Free an int_map.✨
vdo_int_map_get(9)Retrieve the value associated with a given key from the int_map.✨
vdo_int_map_put(9)Try to associate a value with an integer.✨
vdo_int_map_remove(9)Remove the mapping for a given key from the int_map.✨
vdo_int_map_size(9)Get the number of entries stored in an int_map.✨
vdo_invalidate_page_cache(9)Invalidate all entries in the VDO page cache.✨
vdo_is_pbn_read_lock(9)Check whether a pbn_lock is a read lock.✨
vdo_is_physical_data_block(9)Determine whether the given PBN refers to a data block.✨
vdo_is_priority_table_empty(9)Return whether the priority table is empty.✨
vdo_is_read_only(9)Check whether the VDO is read-only.✨
vdo_is_valid_recovery_journal_sector(9)Determine whether the header of the given sector could describe a valid sector for the given journal block header.✨
vdo_launch_bio(9)Acquire a data_vio from the pool, assign the bio to it, and launch it.✨
vdo_launch_completion(9)Launch a completion with default priority.✨
vdo_launch_completion_callback(9)Set the callback for a completion and launch it immediately.✨
vdo_launch_completion_with_priority(9)Run or enqueue a completion.✨
vdo_launch_flush(9)Function called to start processing a flush request.✨
vdo_load_slab_depot(9)Asynchronously load any slab depot state that isn't included in the super_block component.✨
vdo_load_super_block(9)Allocate a super block and read its contents from storage.✨
vdo_make(9)Allocate and initialize a vdo.✨
vdo_make_action_manager(9)Make an action manager.✨
vdo_make_flusher(9)Make a flusher for a vdo.✨
vdo_make_hash_zones(9)Create the hash zones.✨
vdo_make_io_submitter(9)Create an io_submitter structure.✨
vdo_make_logical_zones(9)Create a set of logical zones.✨
vdo_make_packer(9)Make a new block packer.✨
vdo_make_physical_zones(9)Make the physical zones for a vdo.✨
vdo_make_priority_table(9)Allocate and initialize a new priority_table.✨
vdo_make_thread(9)Construct a single vdo work_queue and its associated thread (or threads for round-robin queues).✨
vdo_make_work_queue(9)Create a work queue; if multiple threads are requested, completions will be distributed to them in round-robin fashion.✨
vdo_modify_reference_count(9)Modify the reference count of a block by first making a slab journal entry and then updating the reference counter.✨
vdo_notify_slab_journals_are_recovered(9)Inform a block allocator that its slab journals have been recovered from the recovery journal.✨
vdo_open_recovery_journal(9)Prepare the journal for new entries.✨
vdo_pack_header(9)Convert a component header to its packed on-disk representation.✨
vdo_pack_journal_point(9)Encode the journal location represented by a journal_point into a packed_journal_point.✨
vdo_pack_recovery_block_header(9)Generate the packed representation of a recovery block header.✨
vdo_pack_recovery_journal_entry(9)Return the packed, on-disk representation of a recovery journal entry.✨
vdo_pack_slab_journal_block_header(9)Generate the packed representation of a slab block header.✨
vdo_pack_slab_journal_entry(9)Generate the packed encoding of a slab journal entry.✨
vdo_pack_version_number(9)Convert a version_number to its packed on-disk representation.✨
vdo_parse_geometry_block(9)Decode and validate an encoded geometry block.✨
vdo_pbn_lock_has_provisional_reference(9)Check whether a PBN lock has a provisional reference.✨
vdo_prepare_completion(9)Prepare a completion for launch.✨
vdo_prepare_completion_for_requeue(9)Prepare a completion for launch ensuring that it will always be requeued.✨
vdo_prepare_slab_depot_to_allocate(9)Prepare the slab depot to come online and start allocating blocks.✨
vdo_prepare_to_grow_slab_depot(9)Allocate new memory needed for a resize of a slab depot to the given size.✨
vdo_priority_table_dequeue(9)Find the highest-priority entry in the table, remove it from the table, and return it.✨
vdo_priority_table_enqueue(9)Add a new entry to the priority table, appending it to the queue for entries with the specified priority.✨
vdo_priority_table_remove(9)Remove a specified entry from its priority table.✨
vdo_read_only_notification_fn(9)A function to notify a listener that the VDO has gone read-only.✨
vdo_record_recovery_journal(9)Record the state of a recovery journal for encoding in the super block.✨
vdo_record_slab_depot(9)Record the state of a slab depot for encoding into the super block.✨
vdo_register_read_only_listener(9)Register a listener to be notified when the VDO goes read-only.✨
vdo_register_status_codes(9)Register the VDO status codes.✨
vdo_release_flush_generation_lock(9)Release the shared lock on a flush generation held by a write data_vio.✨
vdo_release_hash_lock(9)Release a data_vio's share of a hash lock, if held, and null out the data_vio's reference to it.✨
vdo_release_journal_entry_lock(9)Release a single per-entry reference count for a recovery journal block.✨
vdo_release_page_completion(9)Release a VDO Page Completion.✨
vdo_release_physical_zone_pbn_lock(9)Release a physical block lock if it is held and return it to the lock pool.✨
vdo_release_recovery_journal_block_reference(9)Release a reference to a recovery journal block.✨
vdo_remove_lock_holder_from_packer(9)Remove a lock holder from the packer.✨
vdo_repair(9)Load the recovery journal and then recover or rebuild a vdo.✨
vdo_replay_into_slab_journals(9)Replay recovery journal entries in the slab journals of slabs owned by a given block_allocator.✨
vdo_request_page_write(9)Request that a VDO page be written out as soon as it is not busy.✨
vdo_requeue_completion_if_needed(9)Requeue a completion if not called on the specified thread.✨
vdo_reset_completion(9)Reset a completion to a clean state, while keeping the type, vdo and parent information.✨
vdo_reset_priority_table(9)Reset a priority table, leaving it in the same empty state as when newly constructed.✨
vdo_resume_flusher(9)Resume a flusher which has been suspended.✨
vdo_resume_hash_zones(9)Resume a set of hash zones.✨
vdo_resume_if_quiescent(9)Change the state to normal operation if the current state is quiescent.✨
vdo_resume_logical_zones(9)Resume a set of logical zones.✨
vdo_resume_packer(9)Resume a packer which has been suspended.✨
vdo_resume_recovery_journal(9)Resume a recovery journal which has been drained.✨
vdo_resume_slab_depot(9)Resume a suspended slab depot.✨
vdo_run_completion(9)Run a completion's callback or error handler on the current thread.✨
vdo_save_components(9)Copy the current state of the VDO to the states struct and save it to the super block asynchronously.✨
vdo_save_geometry_block(9)Encode the vdo and save the geometry block asynchronously.✨
vdo_save_super_block(9)Save the component states to the super block asynchronously.✨
vdo_schedule_action(9)Schedule an action to be applied to all zones.✨
vdo_schedule_default_action(9)Attempt to schedule the default action.✨
vdo_schedule_operation(9)Schedule an operation to be applied to all zones.✨
vdo_schedule_operation_with_context(9)Schedule an operation on all zones.✨
vdo_scrub_all_unrecovered_slabs(9)Scrub all unrecovered slabs.✨
vdo_select_hash_zone(9)Select the hash zone responsible for locking a given record name.✨
vdo_set_admin_state_code(9)Set the current admin state code.✨
vdo_set_completion_result(9)Set the result of a completion.✨
vdo_set_compressing(9)Turn compression on or off.✨
vdo_set_state(9)Set the current state of the vdo.✨
vdo_share_compressed_write_lock(9)Make a data_vio's hash lock a shared holder of the PBN lock on the compressed block to which its data was just written.✨
vdo_start_draining(9)Initiate a drain operation if the current state permits it.✨
vdo_start_loading(9)Initiate a load operation if the current state permits it.✨
vdo_start_operation(9)Attempt to start an operation.✨
vdo_start_operation_with_waiter(9)Attempt to start an operation.✨
vdo_start_resuming(9)Initiate a resume operation if the current state permits it.✨
vdo_state_requires_read_only_rebuild(9)Check whether a vdo_state indicates that a read-only rebuild is required.✨
vdo_state_requires_recovery(9)Check whether a vdo state indicates that recovery is needed.✨
vdo_status_to_errno(9)Given an error code, return a value we can return to the OS.✨
vdo_submit_data_vio(9)Submit I/O for a data_vio.✨
vdo_submit_metadata_vio_wait(9)Submit I/O for a metadata vio and wait for completion.✨
vdo_submit_vio(9)Submits a vio's bio to the underlying block device. May block if the device is busy. This callback should be used by vios which did not attempt to merge.✨
vdo_synchronous_flush(9)Issue a flush request and wait for it to complete.✨
vdo_traverse_forest(9)Walk the entire forest of a block map.✨
vdo_unassign_pbn_lock_provisional_reference(9)Inform a PBN lock that it is no longer responsible for a provisional reference.✨
vdo_uninitialize_layout(9)Clean up a layout.✨
vdo_unpack_header(9)Convert a packed_header to its native in-memory representation.✨
vdo_unpack_journal_point(9)Decode the journal location represented by a packed_journal_point into a journal_point.✨
vdo_unpack_recovery_block_header(9)Decode the packed representation of a recovery block header.✨
vdo_unpack_recovery_journal_entry(9)Unpack the on-disk representation of a recovery journal entry.✨
vdo_unpack_slab_journal_block_header(9)Decode the packed representation of a slab block header.✨