Caller| Name | Describe |
|---|
| ida_free | da_free() - Release an allocated ID.*@ida: IDA handle.*@id: Previously allocated ID.* Context: Any context. |
| ida_destroy | da_destroy() - Free all IDs.*@ida: IDA handle.* Calling this function frees all IDs and releases all resources used* by an IDA. When this call returns, the IDA is empty and can be reused* or freed. If the IDA is already empty, there is no need to call this |
| argv_free | argv_free - free an argv*@argv - the argument vector to be freed* Frees an argv and the strings it points to. |
| argv_split | argv_split - split a string at whitespace, returning an argv*@gfp: the GFP mask used to allocate memory*@str: the string to be split*@argcp: returned argument count* Returns an array of pointers to strings which are split out from*@str |
| kobject_action_args | |
| kobject_synth_uevent | kobject_synth_uevent - send synthetic uevent with arguments*@kobj: struct kobject for which synthetic uevent is to be generated*@buf: buffer containing action type and action args, newline is ignored*@count: length of buffer* Returns 0 if |
| kobject_uevent_env | kobject_uevent_env - send an uevent with environmental data*@kobj: struct kobject that the action is happening to*@action: action that is happening*@envp_ext: pointer to environmental data* Returns 0 if kobject_uevent_env() is completed with success or the |
| uevent_net_init | |
| uevent_net_exit | |
| kobject_rename | kobject_rename() - Change the name of an object |
| kobject_move | kobject_move() - Move object to another parent.*@kobj: object in question.*@new_parent: object's new parent (can be NULL) |
| dynamic_kobj_release | |
| kset_release | |
| kset_create | kset_create() - Create a struct kset dynamically |
| kset_create_and_add | kset_create_and_add() - Create a struct kset dynamically and add it to sysfs |
| free_ldt_struct | |
| create_setup_data_nodes | |
| mce_device_release | |
| allocate_threshold_blocks | |
| threshold_create_bank | |
| threshold_block_release | |
| threshold_remove_bank | |
| mce_threshold_remove_device | |
| mtrr_close | |
| memdup_patch | |
| save_microcode_patch | |
| update_cache | |
| free_cache | |
| verify_and_add_patch | Return a non-negative value even if some of the checks failed so that* we can skip over the next patch. If we return a negative value, we* signal a grave error like a memory allocation has failed and the* driver cannot continue functioning normally |
| domain_setup_ctrlval | |
| domain_setup_mon_state | |
| domain_add_cpu | domain_add_cpu - Add a cpu to a resource's domain list.* If an existing domain in the resource r's domain list matches the cpu's* resource id, add the cpu in the domain.* Otherwise, a new domain is allocated and inserted into the right position |
| domain_remove_cpu | |
| move_myself | |
| __rdtgroup_move_task | |
| rdtgroup_kn_unlock | |
| rdt_fs_context_free | |
| free_all_child_rdtgrp | |
| rmdir_all_sub | Forcibly remove all of subdirectories under root. |
| mkdir_rdt_prepare | |
| mkdir_rdt_prepare_clean | |
| pseudo_lock_cstates_relax | |
| pseudo_lock_cstates_constrain | pseudo_lock_cstates_constrain - Restrict cores from entering C6* To prevent the cache from being affected by power management entering* C6 has to be avoided |
| pseudo_lock_region_clear | pseudo_lock_region_clear - Reset pseudo-lock region data*@plr: pseudo-lock region* All content of the pseudo-locked region is reset - any memory allocated* freed.* Return: void |
| pseudo_lock_free | pseudo_lock_free - Free a pseudo-locked region*@rdtgrp: resource group to which pseudo-locked region belonged* The pseudo-locked region's resources have already been released, or not* yet created at this point |
| do_release | |
| free_apic_chip_data | |
| free_ioapic_saved_registers | |
| __remove_pin_from_irq | |
| mp_irqdomain_alloc | |
| mp_irqdomain_free | |
| build_socket_tables | |
| alloc_clustermask | |
| bzImage64_load | |
| bzImage64_cleanup | This cleanup function is called after various segments have been loaded |
| trampoline_handler | Called from kretprobe_trampoline |
| arch_prepare_optimized_kprobe | Copy replacing target instructions* Target instructions MUST be relocatable (checked inside)* This is called when new aggr(opt)probe is allocated or reused. |
| hpet_enable | hpet_enable - Try to setup the HPET timer. Returns 1 on success. |
| kvm_async_pf_task_wait | @interrupt_kernel: Is this called from a routine which interrupts the kernel* (other than user space)? |
| __do_proc_dointvec | |
| do_proc_douintvec_w | |
| __do_proc_doulongvec_minmax | |
| proc_do_large_bitmap | proc_do_large_bitmap - read/write from/to a large bitmap*@table: the sysctl table*@write: %TRUE if this is a write to the sysctl file*@buffer: the user buffer*@lenp: the size of the user buffer*@ppos: file position* The bitmap is stored at table->data and |
| call_usermodehelper_freeinfo | |
| call_usermodehelper_setup_file | |
| create_worker | reate_worker - create a new workqueue worker*@pool: pool the new worker will belong to* Create and start a new worker which is attached to @pool.* CONTEXT:* Might sleep. Does GFP_KERNEL allocations.* Return:* Pointer to the newly created worker. |
| worker_thread | |
| free_workqueue_attrs | _workqueue_attrs - free a workqueue_attrs*@attrs: workqueue_attrs to free* Undo alloc_workqueue_attrs(). |
| rcu_free_wq | |
| rcu_free_pool | |
| apply_wqattrs_cleanup | the resources after success or abort |
| init_rescuer | Workqueues which may be used during memory reclaim should have a rescuer* to guarantee forward progress. |
| alloc_workqueue | |
| destroy_workqueue | destroy_workqueue - safely terminate a workqueue*@wq: target workqueue* Safely destroy a workqueue. All work currently pending will be done first. |
| maybe_kfree_parameter | Does nothing if parameter wasn't kmalloced above. |
| free_kthread_struct | |
| kthread | |
| create_kthread | |
| __kthread_create_on_node | |
| __kthread_create_worker | |
| kthread_destroy_worker | kthread_destroy_worker - destroy a kthread worker*@worker: worker to be destroyed* Flush and destroy @worker. The simple flush is enough because the kthread* worker API is used only in trivial scenarios. There are no multi-step state* machines needed. |
| async_run_entry_fn | pick the first pending entry and run it |
| async_schedule_node_domain | async_schedule_node_domain - NUMA specific version of async_schedule_domain*@func: function to execute asynchronously*@data: data pointer to pass to the function*@node: NUMA node that we want to schedule this on or close to*@domain: the domain |
| smpboot_thread_fn | smpboot_thread_fn - percpu hotplug thread loop function*@data: thread data pointer* Checks for thread stop and park conditions. Calls the necessary* setup, cleanup, park and unpark functions for the registered* thread. |
| __smpboot_create_thread | |
| setup_userns_sysctls | |
| retire_userns_sysctls | |
| get_ucounts | |
| put_ucounts | |
| free_modprobe_argv | |
| call_modprobe | |
| cpupri_cleanup | pupri_cleanup - clean up the cpupri structure*@cp: The cpupri context |
| cpudl_init | pudl_init - initialize the cpudl structure*@cp: the cpudl max-heap context |
| cpudl_cleanup | pudl_cleanup - clean up the cpudl structure*@cp: the cpudl max-heap context |
| free_rootdomain | |
| alloc_rootdomain | |
| free_sched_groups | |
| destroy_sched_domain | |
| __sdt_free | |
| free_sched_domains | |
| partition_sched_domains_locked | Partition sched domains as specified by the 'ndoms_new'* cpumasks in the array doms_new[] of cpumasks. This compares* doms_new[] to the current sched domain partitioning, doms_cur[].* It destroys each deleted domain and builds each new domain. |
| autogroup_free | |
| autogroup_create | |
| cpuacct_css_alloc | Create a new CPU accounting group |
| cpuacct_css_free | Destroy an existing CPU accounting group |
| sugov_policy_free | |
| sugov_tunables_free | |
| psi_trigger_create | |
| psi_trigger_destroy | |
| lock_torture_stats_print | Print torture statistics |
| lock_torture_cleanup | Forward reference. |
| lock_torture_init | |
| __test_cycle | |
| stress_inorder_work | |
| stress_reorder_work | |
| stress_one_work | |
| stress | |
| pm_qos_power_release | |
| pm_vt_switch_unregister | pm_vt_switch_unregister - stop tracking a device's VT switching needs*@dev: device* Remove @dev from the vt switch list. |
| resume_store | |
| free_mem_extents | _mem_extents - Free a list of memory extents.*@list: List of extents to free. |
| create_mem_extents | reate_mem_extents - Create a list of memory extents.*@list: List to put the extents into.*@gfp_mask: Mask to use for memory allocations.* The extents represent contiguous ranges of PFNs. |
| create_basic_memory_bitmaps | reate_basic_memory_bitmaps - Create bitmaps to hold basic page information |
| free_basic_memory_bitmaps | _basic_memory_bitmaps - Free memory bitmaps holding basic information.* Free memory bitmaps allocated by create_basic_memory_bitmaps(). The* auxiliary pointers are necessary so that the bitmaps themselves are not* referred to while they are being freed. |
| free_all_swap_pages | _all_swap_pages - free swap pages allocated for saving image data.* It also frees the extents used to register which swap entries had been* allocated. |
| save_image_lzo | save_image_lzo - Save the suspend image data compressed with LZO.*@handle: Swap map handle to use for saving the image.*@snapshot: Image to read data from.*@nr_to_write: Number of pages to save. |
| release_swap_reader | The following functions allow us to read data using a swap map* in a file-alike way |
| swap_read_page | |
| load_image_lzo | load_image_lzo - Load compressed image data and decompress them with LZO.*@handle: Swap map handle to use for loading data.*@snapshot: Image to copy uncompressed data into.*@nr_to_read: Number of pages to load. |
| wakelock_lookup_add | |
| em_create_pd | |
| devkmsg_write | |
| devkmsg_release | |
| syslog_print | |
| syslog_print_all | |
| __free_irq | Internal function to unregister an irqaction - used to free* regular and special interrupts that are part of the architecture. |
| free_irq | _irq - free an interrupt allocated with request_irq*@irq: Interrupt line to free*@dev_id: Device identity to free* Remove an interrupt handler |
| __cleanup_nmi | This function must be called with desc->lock held |
| request_threaded_irq | quest_threaded_irq - allocate an interrupt line*@irq: Interrupt line to allocate*@handler: Function to be called when the IRQ occurs |
| request_nmi | quest_nmi - allocate an interrupt line for NMI delivery*@irq: Interrupt line to allocate*@handler: Function to be called when the IRQ occurs |
| free_percpu_irq | _percpu_irq - free an interrupt allocated with request_percpu_irq*@irq: Interrupt line to free*@dev_id: Device identity to free* Remove a percpu interrupt handler. The handler is removed, but* the interrupt line is not disabled. This must be done on each |
| free_percpu_nmi | |
| __request_percpu_irq | __request_percpu_irq - allocate a percpu interrupt line*@irq: Interrupt line to allocate*@handler: Function to be called when the IRQ occurs |
| request_percpu_nmi | quest_percpu_nmi - allocate a percpu interrupt line for NMI delivery*@irq: Interrupt line to allocate*@handler: Function to be called when the IRQ occurs |
| __irq_domain_alloc_fwnode | q_domain_alloc_fwnode - Allocate a fwnode_handle suitable for* identifying an irq domain*@type: Type of irqchip_fwnode |
| irq_domain_free_fwnode | q_domain_free_fwnode - Free a non-OF-backed fwnode_handle* Free a fwnode_handle allocated with irq_domain_alloc_fwnode. |
| __irq_domain_add | __irq_domain_add() - Allocate a new irq_domain data structure*@fwnode: firmware node for the interrupt controller*@size: Size of linear map; 0 for radix mapping only*@hwirq_max: Maximum number of interrupts supported by controller*@direct_max: Maximum |
| irq_domain_remove | q_domain_remove() - Remove an irq domain.*@domain: domain to remove* This routine is used to remove an irq domain. The caller must ensure* that all mappings within the domain have been disposed of prior to* use, depending on the revmap type. |
| irq_domain_update_bus_token | |
| irq_sim_init | q_sim_init - Initialize the interrupt simulator: allocate a range of* dummy interrupts.*@sim: The interrupt simulator object to initialize.*@num_irqs: Number of interrupts to allocate* On success: return the base of the allocated interrupt range. |
| irq_sim_fini | q_sim_fini - Deinitialize the interrupt simulator: free the interrupt* descriptors and allocated memory.*@sim: The interrupt simulator to tear down. |
| alloc_msi_entry | alloc_msi_entry - Allocate an initialize msi_entry*@dev: Pointer to the device for which this is allocated*@nvec: The number of vectors used in this entry*@affinity: Optional pointer to an affinity mask array size of @nvec* If @affinity is not NULL then |
| free_msi_entry | |
| alloc_node_to_cpumask | |
| free_node_to_cpumask | |
| __irq_build_affinity_masks | |
| irq_create_affinity_masks | q_create_affinity_masks - Create affinity masks for multiqueue spreading*@nvecs: The total number of vectors*@affd: Description of the affinity requirements* Returns the irq_affinity_desc pointer or NULL if allocation failed. |
| irq_alloc_matrix | q_alloc_matrix - Allocate a irq_matrix structure and initialize it*@matrix_bits: Number of matrix bits must be <= IRQ_MATRIX_BITS*@alloc_start: From which bit the allocation search starts*@alloc_end: At which bit the allocation search ends, i |
| rcu_torture_timer_cb | |
| rcu_torture_fwd_prog_cbfree | Free all callbacks on the rcu_fwd_cb_head list, either because the* test is over or because we hit an OOM event. |
| rcu_torture_barrier_cleanup | Clean up after RCU barrier testing. |
| rcu_torture_cleanup | |
| rcu_perf_async_cb | Callback function for asynchronous grace periods from rcu_perf_writer(). |
| rcu_perf_writer | RCU perf writer kthread. Repeatedly does a grace period. |
| rcu_perf_cleanup | |
| klp_free_object_dynamic | |
| klp_alloc_object_dynamic | |
| klp_free_func_nop | |
| klp_alloc_func_nop | |
| klp_unpatch_func | |
| klp_patch_func | |
| __klp_shadow_get_or_alloc | |
| dma_init_coherent_memory | |
| dma_release_coherent_memory | |
| dma_common_contiguous_remap | Remaps an allocated contiguous region into another vm_area.* Cannot be used in non-sleeping contexts |
| put_pi_state | Drops a reference to the pi_state object and frees or caches it* when the last reference is gone. |
| dir_utime | |
| do_copy | |
| unpack_to_rootfs | |
| identify_ramdisk_image | This routine tries to find a RAM disk image to load, and returns the* number of blocks to read for a non-compressed image, 0 if the image* is a compressed image, and -1 if an image with the right magic* numbers could not be found |
| rd_load_image | |
| mempool_destroy | mempool_destroy - deallocate a memory pool*@pool: pointer to the memory pool which was allocated via* mempool_create().* Free all reserved elements in @pool and @pool itself. This function* only sleeps if the free_fn() function sleeps. |
| mempool_create_node | |
| mempool_resize | mempool_resize - resize an existing memory pool*@pool: pointer to the memory pool which was allocated via* mempool_create().*@new_min_nr: the new minimum number of elements guaranteed to be* allocated for this pool.* This function shrinks/grows the pool |
| mempool_kfree | |
| prealloc_shrinker | Add a shrinker callback to be called from the vm. |
| free_prealloced_shrinker | |
| unregister_shrinker | Remove one |
| kfree_const | kfree_const - conditionally free memory*@x: pointer to the memory* Function calls kfree only if @x is not in .rodata section. |
| memdup_user | memdup_user - duplicate memory region from user space*@src: source address in user space*@len: number of bytes to copy* Return: an ERR_PTR() on failure. Result is physically* contiguous, to be freed by kfree(). |
| memdup_user_nul | memdup_user_nul - duplicate memory region from user space and NUL-terminate*@src: source address in user space*@len: number of bytes to copy* Return: an ERR_PTR() on failure. |
| kvfree | kvfree() - Free memory.*@addr: Pointer to allocated memory.* kvfree frees memory allocated by any of vmalloc(), kmalloc() or kvmalloc().* It is slightly more efficient to use kfree() or vfree() if you are certain* that you know which one to use. |
| vmstat_stop | |
| bdi_alloc_node | |
| release_bdi | |
| __kmem_cache_free_bulk | |
| krealloc | krealloc - reallocate memory. The contents will remain unchanged.*@p: object to reallocate memory for.*@new_size: how many bytes of memory are required.*@flags: the type of memory to allocate.* The contents of the object pointed to are preserved up to the |
| kzfree | kzfree - like kfree but zero memory*@p: object to free memory of* The memory of the object @p points to is zeroed before freed.* If @p is %NULL, kzfree() does nothing.* Note: this function zeroes the whole allocated buffer which can be a good |
| __list_lru_init | |
| list_lru_destroy | |
| __gup_longterm_locked | __gup_longterm_locked() is a wrapper for __get_user_pages_locked which* allows us to process the FOLL_LONGTERM flag. |
| vfree | |
| new_vmap_block | w_vmap_block - allocates new vmap_block and occupies 2^order pages in this* block |
| __get_vm_area_node | |
| __vunmap | |
| __vmalloc_area_node | |
| free_vm_area | |
| process_vm_rw_core | process_vm_rw_core - core of reading/writing pages from task specified*@pid: PID of process to read/write from/to*@iter: where to copy to/from locally*@rvec: iovec array specifying where to copy to/from in the other process*@riovcnt: size of rvec |
| process_vm_rw | process_vm_rw - check iovecs before calling core routine*@pid: PID of process to read/write from/to*@lvec: iovec array specifying where to copy to/from locally*@liovcnt: size of lvec array*@rvec: iovec array specifying where to copy to/from in the other |
| compat_process_vm_rw | |
| numa_zonelist_order_handler | sysctl handler for numa_zonelist_order |
| memblock_double_array | |
| destroy_swap_extents | Free all of a swapdev's extent information |
| zswap_dstmem_dead | |
| zswap_pool_create | |
| zswap_pool_destroy | |
| zswap_frontswap_invalidate_area | s all zswap entries for the given swap type |
| dma_pool_create | dma_pool_create - Creates a pool of consistent memory blocks, for dma |
| pool_alloc_page | |
| pool_free_page | |
| dma_pool_destroy | dma_pool_destroy - destroys a pool of dma memory blocks.*@pool: dma pool that will be destroyed* Context: !in_interrupt()* Caller guarantees that no more memory from the pool is in use,* and that nothing will try to use the pool after this call. |
| unlock_or_release_subpool | |
| hugepage_new_subpool | |
| add_reservation_in_range | Must be called with resv->lock held. Calling this with count_only == true* will count the number of pages to be added but will not modify the linked* list. |
| region_del | Delete the specified range [f, t) from the reserve map. If the* t parameter is LONG_MAX, this indicates that ALL regions after f* should be deleted. Locate the regions which intersect [f, t)* and either trim, delete or split the existing regions. |
| resv_map_alloc | |
| resv_map_release | |
| hugetlb_hstate_alloc_pages | |
| section_deactivate | |
| section_activate | |
| free_msg | |
| find_alloc_undo | d_alloc_undo - lookup (and if not present create) undo array*@ns: namespace*@semid: semaphore array id* The function looks up (and if not present creates) the undo structure.* The size of the undo structure depends on the size of the semaphore |
| exit_sem | add semadj values to semaphores, free undo structures |
| shm_release | |
| do_shmat | Fix shmaddr, allocate descriptor, map shm, add attach descriptor to lists.* NOTE! Despite the name, this is NOT a direct system call entrypoint. The* "raddr" thing points to kernel space, and there has to be a wrapper around* this. |
| msg_tree_erase | |
| mqueue_fs_context_free | |
| mqueue_evict_inode | |
| do_mq_timedsend | |
| do_mq_timedreceive | |
| create_ipc_ns | |
| free_ipc_ns | |
| bio_uncopy_user | _uncopy_user - finish previously mapped bio*@bio: bio being terminated* Free pages allocated from bio_copy_user_iov() and write back data* to user space in case of a read. |
| bio_copy_user_iov | _copy_user_iov - copy user data to bio*@q: destination block queue*@map_data: pointer to the rq_map_data holding pages (if necessary)*@iter: iovec iterator*@gfp_mask: memory allocation flags* Prepares and returns a bio for indirect user io, bouncing data |
| elevator_release | |
| blk_alloc_flush_queue | |
| blk_free_flush_queue | |
| blk_mq_free_rq_map | |
| blk_mq_alloc_rq_map | |
| blk_mq_alloc_hctx | |
| blk_mq_alloc_ctxs | All allocations will be freed in release handler of q->mq_kobj |
| blk_mq_release | It is the actual release handler for mq, but we do it from* request queue's release handler for avoiding use-after-free* and headache because q->mq_kobj shouldn't have been introduced,* but we can't group ctx/kctx kobj without it. |
| blk_mq_realloc_hw_ctxs | |
| blk_mq_init_allocated_queue | |
| blk_mq_realloc_tag_set_tags | |
| blk_mq_alloc_tag_set | Alloc a tag set to be associated with one or more request queues.* May fail with EINVAL for various error conditions. May adjust the* requested depth down, if it's too large. In that case, the set* value will be stored in set->queue_depth. |
| blk_mq_free_tag_set | |
| blk_mq_elv_switch_back | |
| blk_mq_init_bitmap_tags | |
| blk_mq_free_tags | |
| blk_stat_alloc_callback | |
| blk_stat_free_callback_rcu | |
| blk_free_queue_stats | |
| blk_mq_sysfs_release | |
| blk_mq_hw_sysfs_release | |
| blk_mq_sched_free_hctx_data | |
| register_blkdev | gister_blkdev - register a new block device*@major: the requested major device number [1..BLKDEV_MAJOR_MAX-1]. If*@major = 0, try to allocate any unused major number.*@name: the name of the new block device as a zero terminated string |
| unregister_blkdev | |
| disk_seqf_stop | |
| disk_release | |
| __alloc_disk_node | |
| disk_release_events | |
| part_release | |
| add_partition | Must be called either with bd_mutex held, before a disk can be opened or* after all disk users are gone. |
| badblocks_exit | adblocks_exit() - free the badblocks structure*@bb: the badblocks structure that holds all badblock information |
| allocate_partitions | |
| free_partitions | |
| alloc_pvd | alloc_pvd(): reads physical volume descriptor*@state*@lba* Description: Returns pvd on success, NULL on error.* Allocates space for pvd and fill it with disk blocks at @lba* Notes: remember to free pvd when you're done! |
| alloc_lvn | alloc_lvn(): reads logical volume names*@state*@lba* Description: Returns lvn on success, NULL on error.* Allocates space for lvn and fill it with disk blocks at @lba* Notes: remember to free lvn when you're done! |
| aix_partition | |
| ldm_validate_privheads | ldm_validate_privheads - Compare the primary privhead with its backups*@state: Partition check state including device holding the LDM Database*@ph1: Memory struct to fill with ph contents* Read and compare all three privheads from disk |
| ldm_validate_tocblocks | ldm_validate_tocblocks - Validate the table of contents and its backups*@state: Partition check state including device holding the LDM Database*@base: Offset, into @state->bdev, of the database*@ldb: Cache of the database structures* Find and compare the |
| ldm_ldmdb_add | ldm_ldmdb_add - Adds a raw VBLK entry to the ldmdb database*@data: Raw VBLK to add to the database*@len: Size of the raw VBLK*@ldb: Cache of the database structures* The VBLKs are sorted into categories. Partitions are also sorted by offset.* N |
| ldm_frag_free | ldm_frag_free - Free a linked list of VBLK fragments*@list: Linked list of fragments* Free a linked list of VBLK fragments* Return: none |
| ldm_free_vblks | ldm_free_vblks - Free a linked list of vblk's*@lh: Head of a linked list of struct vblk* Free a list of vblk's and free the memory used to maintain the list.* Return: none |
| ldm_partition | ldm_partition - Find out whether a device is a dynamic disk and handle it*@state: Partition check state including device holding the LDM Database* This determines whether the device @bdev is a dynamic disk and if so creates |
| ibm_partition | This is the main function, called by check.c |
| alloc_read_gpt_entries | alloc_read_gpt_entries(): reads partition entries from disk*@state: disk parsed partitions*@gpt: GPT header* Description: Returns ptes on success, NULL on error |
| alloc_read_gpt_header | alloc_read_gpt_header(): Allocates GPT header, reads into it from disk*@state: disk parsed partitions*@lba: the Logical Block Address of the partition table* Description: returns GPT header on success, NULL on error. Allocates |
| is_gpt_valid | s_gpt_valid() - tests one GPT header and PTEs for validity*@state: disk parsed partitions*@lba: logical block address of the GPT header to test*@gpt: GPT header ptr, filled on return.*@ptes: PTEs ptr, filled on return. |
| find_valid_gpt | d_valid_gpt() - Search disk for valid GPT headers and PTEs*@state: disk parsed partitions*@gpt: GPT header ptr, filled on return.*@ptes: PTEs ptr, filled on return.* Description: Returns 1 if valid, 0 on error. |
| efi_partition | _partition(struct parsed_partitions *state)*@state: disk parsed partitions* Description: called from check.c, if the disk contains GPT* partitions, sets up partition entries in the kernel.* If the first block on the disk is a legacy MBR, |
| sg_io | |
| sg_scsi_ioctl | sg_scsi_ioctl -- handle deprecated SCSI_IOCTL_SEND_COMMAND ioctl*@q: request queue to send scsi commands down*@disk: gendisk to operate on (option)*@mode: mode used to open the file through which the ioctl has been* submitted*@sic: userspace structure |
| bsg_put_device | |
| bsg_transport_fill_hdr | |
| bsg_transport_free_rq | |
| bsg_teardown_job | sg_teardown_job - routine to teardown a bsg job*@kref: kref inside bsg_job that is to be torn down |
| bsg_prepare_job | sg_prepare_job - create the bsg_job structure for the bsg request*@dev: device that is being sent the bsg request*@req: BSG request that needs a job structure |
| bsg_exit_rq | |
| bsg_remove_queue | |
| bsg_setup_queue | sg_setup_queue - Create and add the bsg hooks so we can receive requests*@dev: device to attach bsg device to*@name: device to give bsg device*@job_fn: bsg job handler*@timeout: timeout handler function pointer*@dd_job_size: size of LLD data needed for |
| blkg_free | lkg_free - free a blkg*@blkg: blkg to free* Free @blkg which may be partially allocated. |
| blkcg_css_free | |
| blkcg_css_alloc | |
| throtl_pd_alloc | |
| throtl_pd_free | |
| blk_throtl_init | |
| blk_throtl_exit | |
| blkcg_iolatency_exit | |
| blk_iolatency_init | |
| iolatency_pd_alloc | |
| iolatency_pd_free | |
| ioc_rqos_exit | |
| blk_iocost_init | |
| ioc_cpd_free | |
| ioc_pd_free | |
| dd_exit_queue | |
| kyber_queue_data_alloc | |
| kyber_exit_sched | |
| kyber_init_hctx | |
| kyber_exit_hctx | |
| __bfq_weights_tree_remove | Decrement the weight counter associated with the queue, and, if the* counter reaches 0, remove the counter from the tree.* See the comments to the function bfq_weights_tree_add() for considerations* about overhead. |
| bfq_exit_queue | |
| bfq_init_queue | |
| parse_subpart | |
| free_subpart | |
| parse_parts | |
| cmdline_parts_free | |
| cmdline_parts_parse | |
| bio_integrity_free | _integrity_free - Free bio integrity payload*@bio: bio containing bip to be freed* Description: Used to free the integrity portion of a bio. Usually* called from bio_free(). |
| bio_integrity_prep | _integrity_prep - Prepare bio for integrity I/O*@bio: bio to prepare* Description: Checks if the bio already has an integrity payload attached.* If it does, the payload has been generated by another kernel subsystem,* and we just pass it through |
| blk_queue_free_zone_bitmaps | |
| blk_revalidate_disk_zones | lk_revalidate_disk_zones - (re)allocate and initialize zone bitmaps*@disk: Target disk* Helper function for low-level device drivers to (re) allocate and initialize* a disk request queue zone bitmaps. This functions should normally be called |
| wbt_exit | |
| wbt_init | |
| add_suspend_info | |
| gen_key | |
| start_SIDASP_opal_session | |
| clean_opal_dev | |
| free_opal_dev | |
| init_opal_dev | |
| sed_ioctl | |
| key_user_lookup | Get the key quota record for a user, allocating a new record if one doesn't* already exist. |
| key_user_put | Dispose of a user structure |
| key_alloc | key_alloc - Allocate a key of the specified type.*@type: The type of key to allocate.*@desc: The key description to allow the key to be searched out.*@uid: The owner of the new key.*@gid: The group ID for the new key's group permissions. |
| keyring_destroy | |
| keyring_restrict | keyring_restrict - Look up and apply a restriction to a keyring*@keyring_ref: The keyring to be restricted*@type: The key type that will provide the restriction checker.*@restriction: The restriction options to apply to the keyring |
| SYSCALL_DEFINE5 | Extract the description of a new key from userspace and either add it as a* new key to the specified keyring or update a matching key in that keyring.* If the description is NULL or an empty string, the key type is asked to* generate one from the payload. |
| SYSCALL_DEFINE4 | Search the process keyrings and keyring trees linked from those for a* matching key. Keyrings must have appropriate Search permission to be* searched.* If a key is found, it will be attached to the destination keyring if there's |
| keyctl_join_session_keyring | Join a (named) session keyring.* Create and join an anonymous session keyring or join a named session* keyring, creating it if necessary. A named session keyring must have Search* permission for it to be joined. Session keyrings without this permit will |
| keyctl_describe_key | Return a description of a key to userspace |
| keyctl_keyring_search | Search the specified keyring and any keyrings it links to for a matching* key |
| keyctl_instantiate_key_iov | Instantiate a key with the specified multipart payload and link the key into* the destination keyring if one is given.* The caller must have the appropriate instantiation permit set for this to* work (see keyctl_assume_authority) |
| keyctl_get_security | Get a key's the LSM security label.* The key must grant the caller View permission for this to work.* If there's a buffer, then up to buflen bytes of data will be placed into it.* If successful, the amount of information available will be returned, |
| keyctl_restrict_keyring | Apply a restriction to a given keyring.* The caller must have Setattr permission to change keyring restrictions.* The requested type name may be a NULL pointer to reject all attempts* to link to the keyring. In this case, _restriction must also be NULL. |
| free_request_key_auth | |
| compat_keyctl_instantiate_key_iov | Instantiate a key with the specified compatibility multipart payload and* link the key into the destination keyring if one is given.* The caller must have the appropriate instantiation permit set for this to* work (see keyctl_assume_authority) |
| __keyctl_dh_compute | |
| keyctl_pkey_params_free | |
| keyctl_pkey_e_d_s | Encrypt/decrypt/sign* Encrypt data, decrypt data or sign data using a public key |
| keyctl_pkey_verify | Verify a signature |
| big_key_free_buffer | Free up the buffer. |
| init_trusted | |
| cleanup_trusted | |
| derived_key_decrypt | |
| cap_inode_getsecurity | getsecurity: We are called for security |
| ordered_lsm_parse | Populate ordered LSMs list from comma-separated LSM name list. |
| ordered_lsm_init | |
| lsm_append | |
| security_inode_init_security | |
| security_task_free | |
| security_cred_free | |
| security_msg_msg_free | |
| security_msg_queue_free | |
| security_shm_free | |
| security_sem_free | |
| securityfs_free_inode | |
| securityfs_create_symlink | securityfs_create_symlink - create a symlink in the securityfs filesystem*@name: a pointer to a string containing the name of the symlink to* create.*@parent: a pointer to the parent dentry for the symlink. This should be a* directory dentry if set |
| avc_audit_post_callback | avc_audit_post_callback - SELinux specific information* will be called by generic audit code*@ab: the audit buffer*@a: audit_data |
| superblock_free_security | |
| selinux_free_mnt_opts | |
| selinux_add_mnt_opt | |
| show_sid | |
| inode_doinit_use_xattr | |
| selinux_sb_eat_lsm_opts | |
| selinux_inode_getsecurity | Copy the inode security context value to the user.* Permission check is handled by selinux_inode_getxattr hook. |
| selinux_kernfs_init_security | kernfs node operations |
| selinux_socket_getpeersec_stream | |
| selinux_sk_free_security | |
| selinux_tun_dev_free_security | |
| selinux_release_secctx | |
| selinux_key_free | |
| selinux_fs_info_free | |
| sel_open_policy | |
| sel_release_policy | |
| sel_write_context | |
| sel_write_checkreqprot | |
| sel_write_validatetrans | |
| sel_write_access | Remaining nodes use transaction based IO methods like nfsd/nfsctl.c |
| sel_write_create | |
| sel_write_relabel | |
| sel_write_user | |
| sel_write_member | |
| sel_write_bool | |
| sel_commit_bools_write | |
| sel_make_bools | declaration for sel_write_load |
| sel_write_avc_cache_threshold | |
| sel_read_initcon | |
| sel_make_perm_files | |
| sel_make_classes | |
| sel_netif_sid_slow | sel_netif_sid_slow - Lookup the SID of a network interface using the policy*@ns: the network namespace*@ifindex: the network interface*@sid: interface SID* Description:* This function determines the SID of a network interface by quering the |
| sel_netnode_sid_slow | sel_netnode_sid_slow - Lookup the SID of a network address using the policy*@addr: the IP address*@family: the address family*@sid: node SID* Description:* This function determines the SID of a network address by quering the* security policy |
| selinux_xfrm_alloc_user | Allocates a xfrm_sec_state and populates it using the supplied security* xfrm_user_sec_ctx context. |
| selinux_xfrm_free | Free the xfrm_sec_ctx structure. |
| selinux_xfrm_state_alloc_acquire | LSM hook implementation that allocates a xfrm_sec_state and populates based* on a secid. |
| smk_fetch | smk_fetch - Fetch the smack label from a file.*@name: type of the label (attribute)*@ip: a pointer to the inode*@dp: a pointer to the dentry* Returns a pointer to the master list entry for the Smack label, |
| smack_sb_free_security | smack_sb_free_security - free a superblock blob*@sb: the superblock getting the blob |
| smack_free_mnt_opts | |
| smack_sb_eat_lsm_opts | |
| smack_sk_free_security | smack_sk_free_security - Free a socket blob*@sk: the socket* Clears the blob pointer |
| smk_import_entry | smk_import_entry - import a label, return the list entry*@string: a text string that might be a Smack label*@len: the maximum size, or zero if it is NULL terminated |
| smk_fill_rule | smk_fill_rule - Fill Smack rule from strings*@subject: subject label string*@object: object label string*@access1: access string*@access2: string with permissions to be removed*@rule: Smack rule*@import: if non-zero, import labels*@len: label length limit |
| smk_write_rules_list | smk_write_rules_list - write() for any /smack rule file*@file: file pointer, not actually used*@buf: where to get the data from*@count: bytes sent*@ppos: where to start - must be 0*@rule_list: the list of rules to write to*@rule_lock: lock for the rule |
| smk_cipso_doi | smk_cipso_doi - initialize the CIPSO domain |
| smk_set_cipso | smk_set_cipso - do the work for write() for cipso and cipso2*@file: file pointer, not actually used*@buf: where to get the data from*@count: bytes sent*@ppos: where to start*@format: /smack/cipso or /smack/cipso2 |
| smk_write_net4addr | smk_write_net4addr - write() for /smack/netlabel*@file: file pointer, not actually used*@buf: where to get the data from*@count: bytes sent*@ppos: where to start* Accepts only one net4addr per write call |
| smk_write_net6addr | smk_write_net6addr - write() for /smack/netlabel*@file: file pointer, not actually used*@buf: where to get the data from*@count: bytes sent*@ppos: where to start* Accepts only one net6addr per write call |
| smk_write_ambient | smk_write_ambient - write() for /smack/ambient*@file: file pointer, not actually used*@buf: where to get the data from*@count: bytes sent*@ppos: where to start* Returns number of bytes written or error code, as appropriate |
| smk_destroy_label_list | smk_destroy_label_list - destroy a list of smack_known_list_elem*@head: header pointer of the list to destroy |
| smk_write_onlycap | smk_write_onlycap - write() for smackfs/onlycap*@file: file pointer, not actually used*@buf: where to get the data from*@count: bytes sent*@ppos: where to start* Returns number of bytes written or error code, as appropriate |
| smk_write_revoke_subj | smk_write_revoke_subj - write() for /smack/revoke-subject*@file: file pointer*@buf: data from user space*@count: bytes sent*@ppos: where to start - must be 0 |
| smk_write_syslog | smk_write_syslog - write() for smackfs/syslog*@file: file pointer, not actually used*@buf: where to get the data from*@count: bytes sent*@ppos: where to start* Returns number of bytes written or error code, as appropriate |
| smk_write_relabel_self | smk_write_relabel_self - write() for /smack/relabel-self*@file: file pointer, not actually used*@buf: where to get the data from*@count: bytes sent*@ppos: where to start - must be 0 |
| tomoyo_print_header | moyo_print_header - Get header line of audit log.*@r: Pointer to "struct tomoyo_request_info".* Returns string representation.* This function uses kmalloc(), so caller must kfree() if this function* didn't return NULL. |
| tomoyo_init_log | moyo_init_log - Allocate buffer for audit logs |
| tomoyo_write_log2 | moyo_write_log2 - Write an audit log.*@r: Pointer to "struct tomoyo_request_info".*@len: Buffer size needed for @fmt and @args.*@fmt: The printf()'s format string.*@args: va_list structure for @fmt.* Returns nothing. |
| tomoyo_read_log | moyo_read_log - Read an audit log.*@head: Pointer to "struct tomoyo_io_buffer".* Returns nothing. |
| tomoyo_assign_profile | moyo_assign_profile - Create a new profile.*@ns: Pointer to "struct tomoyo_policy_namespace".*@profile: Profile number to create.* Returns pointer to "struct tomoyo_profile" on success, NULL otherwise. |
| tomoyo_manager | moyo_manager - Check whether the current process is a policy manager.* Returns true if the current process is permitted to modify policy* via /sys/kernel/security/tomoyo/ interface.* Caller holds tomoyo_read_lock(). |
| tomoyo_add_entry | moyo_add_entry - Add an ACL to current thread's domain. Used by learning mode.*@domain: Pointer to "struct tomoyo_domain_info".*@header: Lines containing ACL.* Returns nothing. |
| tomoyo_supervisor | moyo_supervisor - Ask for the supervisor's decision |
| tomoyo_read_query | moyo_read_query - Read access requests which violated policy in enforcing mode.*@head: Pointer to "struct tomoyo_io_buffer". |
| tomoyo_open_control | moyo_open_control - open() for /sys/kernel/security/tomoyo/ interface.*@type: Type of interface.*@file: Pointer to "struct file".* Returns 0 on success, negative value otherwise. |
| tomoyo_write_control | moyo_write_control - write() for /sys/kernel/security/tomoyo/ interface.*@head: Pointer to "struct tomoyo_io_buffer".*@buffer: Pointer to buffer to read from.*@buffer_len: Size of @buffer.* Returns @buffer_len on success, negative value otherwise. |
| tomoyo_scan_bprm | moyo_scan_bprm - Scan "struct linux_binprm".*@ee: Pointer to "struct tomoyo_execve".*@argc: Length of @argc.*@argv: Pointer to "struct tomoyo_argv".*@envc: Length of @envp.*@envp: Poiner to "struct tomoyo_envp".* Returns true on success, false otherwise. |
| tomoyo_scan_exec_realpath | moyo_scan_exec_realpath - Check "exec.realpath" parameter of "struct tomoyo_condition".*@file: Pointer to "struct file".*@ptr: Pointer to "struct tomoyo_name_union".*@match: True if "exec.realpath=", false if "exec.realpath!=". |
| tomoyo_commit_condition | moyo_commit_condition - Commit "struct tomoyo_condition".*@entry: Pointer to "struct tomoyo_condition".* Returns pointer to "struct tomoyo_condition" on success, NULL otherwise.* This function merges duplicated entries. This function returns NULL if |
| tomoyo_get_condition | moyo_get_condition - Parse condition part.*@param: Pointer to "struct tomoyo_acl_param".* Returns pointer to "struct tomoyo_condition" on success, NULL otherwise. |
| tomoyo_assign_namespace | moyo_assign_namespace - Create a new namespace.*@domainname: Name of namespace to create.* Returns pointer to "struct tomoyo_policy_namespace" on success,* NULL otherwise.* Caller holds tomoyo_read_lock(). |
| tomoyo_environ | moyo_environ - Check permission for environment variable names.*@ee: Pointer to "struct tomoyo_execve".* Returns 0 on success, negative value otherwise. |
| tomoyo_find_next_domain | moyo_find_next_domain - Find a domain.*@bprm: Pointer to "struct linux_binprm".* Returns 0 on success, negative value otherwise.* Caller holds tomoyo_read_lock(). |
| tomoyo_path_number_perm | moyo_path_number_perm - Check permission for "create", "mkdir", "mkfifo", "mksock", "ioctl", "chmod", "chown", "chgrp".*@type: Type of operation.*@path: Pointer to "struct path".*@number: Number.* Returns 0 on success, negative value otherwise. |
| tomoyo_check_open_permission | moyo_check_open_permission - Check permission for "read" and "write".*@domain: Pointer to "struct tomoyo_domain_info".*@path: Pointer to "struct path".*@flag: Flags for open().* Returns 0 on success, negative value otherwise. |
| tomoyo_path_perm | moyo_path_perm - Check permission for "unlink", "rmdir", "truncate", "symlink", "append", "chroot" and "unmount".*@operation: Type of operation.*@path: Pointer to "struct path".*@target: Symlink's target if @operation is TOMOYO_TYPE_SYMLINK, |
| tomoyo_mkdev_perm | moyo_mkdev_perm - Check permission for "mkblock" and "mkchar".*@operation: Type of operation. (TOMOYO_TYPE_MKCHAR or TOMOYO_TYPE_MKBLOCK)*@path: Pointer to "struct path".*@mode: Create mode.*@dev: Device number. |
| tomoyo_path2_perm | moyo_path2_perm - Check permission for "rename", "link" and "pivot_root".*@operation: Type of operation.*@path1: Pointer to "struct path".*@path2: Pointer to "struct path".* Returns 0 on success, negative value otherwise. |
| tomoyo_memory_free | moyo_memory_free - Free memory for elements.*@ptr: Pointer to allocated memory.* Returns nothing.* Caller holds tomoyo_policy_lock mutex. |
| tomoyo_gc_thread | moyo_gc_thread - Garbage collector thread function.*@unused: Unused.* Returns 0. |
| tomoyo_notify_gc | moyo_notify_gc - Register/unregister /sys/kernel/security/tomoyo/ users.*@head: Pointer to "struct tomoyo_io_buffer".*@is_register: True if register, false if unregister.* Returns nothing. |
| tomoyo_commit_ok | moyo_commit_ok - Check memory quota.*@data: Data to copy from.*@size: Size in byte.* Returns pointer to allocated memory on success, NULL otherwise.*@data is zero-cleared on success.* Caller holds tomoyo_policy_lock mutex. |
| tomoyo_get_name | moyo_get_name - Allocate permanent memory for string data.*@name: The string to store into the permernent memory.* Returns pointer to "struct tomoyo_path_info" on success, NULL otherwise. |
| tomoyo_mount_acl | moyo_mount_acl - Check permission for mount() operation.*@r: Pointer to "struct tomoyo_request_info".*@dev_name: Name of device file. Maybe NULL.*@dir: Pointer to "struct path".*@type: Name of filesystem type.*@flags: Mount options. |
| tomoyo_unix_entry | moyo_unix_entry - Check permission for UNIX network operation.*@address: Pointer to "struct tomoyo_addr_info".* Returns 0 on success, negative value otherwise. |
| tomoyo_realpath_from_path | moyo_realpath_from_path - Returns realpath(3) of the given pathname but ignores chroot'ed root |
| tomoyo_write_self | moyo_write_self - write() for /sys/kernel/security/tomoyo/self_domain interface |
| aafs_free_inode | |
| aafs_create_symlink | aafs_create_symlink - create a symlink in the apparmorfs filesystem*@name: name of dentry to create*@parent: parent directory for this dentry*@target: if symlink, symlink target string*@private: private data*@iops: struct of inode_operations that should |
| ns_revision_release | vision file hook fn for policy loads |
| gen_symlink_name | |
| rawdata_link_cb | |
| aa_audit_rule_free | |
| aa_str_kref | |
| dfa_free | dfa_free - free a dfa allocated by aa_dfa_unpack*@dfa: the dfa to free (MAYBE NULL)* Requires: reference count to dfa == 0 |
| aa_xattrs_match | aa_xattrs_match - check whether a file matches the xattrs defined in profile*@bprm: binprm struct for the process to validate*@profile: profile to match against (NOT NULL)*@state: state to start match in* Returns: number of extended attributes that |
| aa_new_null_profile | aa_new_null_profile - create or find a null-X learning profile*@parent: profile that caused this profile to be created (NOT NULL)*@hat: true if the null- learning profile is a hat*@base: name to base the null profile off of*@gfp: type of allocation |
| aa_replace_profiles | aa_replace_profiles - replace profile(s) on the profile list*@policy_ns: namespace load is occurring on*@label: label that is attempting to load/replace policy*@mask: permission mask*@udata: serialized data stream (NOT NULL)* unpack and replace a profile |
| aa_loaddata_alloc | |
| unpack_secmark | |
| aa_load_ent_free | |
| apparmor_setprocattr | |
| apparmor_sk_free_security | apparmor_sk_free_security - free the sk_security field |
| apparmor_socket_getpeersec_stream | apparmor_socket_getpeersec_stream - get security context of peer* Note: for tcp only valid if using ipsec or cipso on lan |
| destroy_buffers | |
| apparmor_release_secctx | |
| free_proxy | |
| aa_label_free | |
| aa_label_alloc | aa_label_alloc - allocate a label with a profile vector of @size length*@size: size of profile vector in the label*@proxy: proxy to use OR null if to allocate a new one*@gfp: memory allocation type* Returns: new label* else NULL if failed |
| aa_label_xaudit | |
| aa_label_seq_xprint | |
| aa_label_xprintk | |
| aa_calc_hash | |
| aa_calc_profile_hash | |
| __report_access | |
| report_access | defers execution because cmdline access can sleep |
| report_load | |
| __release_ruleset | |
| handle_policy_update | |
| lockdown_write | |
| dev_exceptions_copy | alled under devcgroup_mutex |
| dev_exception_add | alled under devcgroup_mutex |
| devcgroup_css_free | |
| iint_free | |
| get_cert_list | Get a certificate list blob from the named EFI variable. |
| load_uefi_certs | Load the certs contained in the UEFI databases into the platform trusted* keyring and the UEFI blacklisted X.509 cert SHA256 hashes into the blacklist* keyring. |
| uefi_blacklist_hash | Blacklist a hash. |
| get_cert_list | Get a certificate list blob from the named secure variable. |
| load_powerpc_certs | Load the certs contained in the keys databases into the platform trusted* keyring and the blacklisted X.509 cert SHA256 hashes into the blacklist* keyring. |
| ima_write_policy | |
| process_measurement | |
| ima_calc_file_hash_tfm | |
| ima_free_template_entry | ma_free_template_entry - free an existing template entry |
| ima_audit_measurement | |
| ima_lsm_free_rule | |
| ima_update_policy | ma_update_policy - update default_rules with new measure rules* Called on file .release to update the default rules with a complete new* policy. What we do here is to splice ima_policy_rules and ima_temp_rules so* they make a queue |
| ima_lsm_rule_init | |
| ima_parse_add_rule | ma_parse_add_rule - add a rule to ima_policy_rules*@rule - ima measurement policy rule* Avoid locking by allowing just one writer at a time in ima_write_policy()* Returns the length of the rule parsed, an error code on failure |
| ima_delete_rules | ma_delete_rules() called to cleanup invalid in-flight policy.* We don't need locking as we operate on the temp list, which is* different from the active one. There is also only one user of* ima_delete_rules() at a time. |
| ima_restore_template_data | |
| ima_read_modsig | ma_read_modsig - Read modsig from buf.* Return: 0 on success, error code otherwise. |
| ima_free_modsig | |
| evm_verify_hmac | vm_verify_hmac - calculate and compare the HMAC with the EVM xattr* Compute the HMAC on the dentry's protected set of extended attributes* and compare it against the stored security |
| evm_inode_init_security | vm_inode_init_security - initializes security.evm |
| init_desc | |
| evm_calc_hmac_or_hash | Calculate the HMAC value across the set of protected security xattrs.* Instead of retrieving the requested xattr, for performance, calculate* the hmac using the requested xattr value. Don't alloc/free memory for |
| evm_is_immutable | |
| evm_init_hmac | |
| vfs_writev | |
| compat_readv | |
| compat_writev | |
| destroy_super_work | |
| destroy_unused_super | Free a superblock that has never been seen by anyone |
| __put_super | Drop a superblock's refcount. The caller must hold sb_lock. |
| do_emergency_remount | |
| do_thaw_all | |
| __register_chrdev_region | Register a single major with a specified minor range.* If major == 0 this function will dynamically allocate an unused major.* If major > 0 this function will attempt to reserve the range of minors* with given major. |
| register_chrdev_region | gister_chrdev_region() - register a range of device numbers*@from: the first in the desired range of device numbers; must include* the major number.*@count: the number of consecutive device numbers required*@name: the name of the device or driver. |
| __register_chrdev | __register_chrdev() - create and register a cdev occupying a range of minors*@major: major device number or 0 for dynamic allocation*@baseminor: first of the requested range of minor numbers*@count: the number of minor numbers required*@name: name of this |
| unregister_chrdev_region | register_chrdev_region() - unregister a range of device numbers*@from: the first in the range of numbers to unregister*@count: the number of device numbers to unregister* This function will unregister a range of @count device numbers,* starting with @from |
| __unregister_chrdev | __unregister_chrdev - unregister and destroy a cdev*@major: major device number*@baseminor: first of the range of minor numbers*@count: the number of minor numbers this cdev is occupying*@name: name of this range of devices* Unregister and destroy the |
| cdev_dynamic_release | |
| free_bprm | |
| bprm_change_interp | |
| __do_execve_file | sys_execve() executes a new program. |
| alloc_pipe_info | |
| free_pipe_info | |
| pipe_set_size | Allocate a new array of pipe buffers and copy the info over. Returns the* pipe size if successful, or return -ERROR on error. |
| getname_flags | |
| putname | |
| restore_nameidata | |
| ioctl_file_dedupe_range | |
| do_sys_poll | |
| compat_core_sys_select | We can actually return ERESTARTSYS instead of EINTR, but I'd* like to be certain this leads to no problems. So I return* EINTR just for safety.* Update: ERESTARTSYS breaks at least the xview clock binary, so |
| __d_free_external | |
| __d_alloc | __d_alloc - allocate a dcache entry*@sb: filesystem it will belong to*@name: qstr of the name* Allocates a dentry. It returns %NULL if there is insufficient memory* available. On a success the dentry is returned. The name passed in is |
| __free_fdtable | |
| alloc_fdtable | |
| get_mountpoint | |
| __put_mountpoint | vfsmount lock must be held. Additionally, the caller is responsible* for serializing calls for given disposal list. |
| copy_mount_options | |
| free_mnt_ns | |
| alloc_mnt_ns | |
| SYSCALL_DEFINE5 | |
| single_open | |
| single_release | |
| seq_release_private | |
| __seq_open_private | |
| xattr_getsecurity | |
| simple_xattr_set | simple_xattr_set - xattr SET operation for in-memory/pseudo filesystems*@xattrs: target simple_xattr list*@name: name of the extended attribute*@value: value of the xattr |
| pseudo_fs_free | |
| simple_attr_release | |
| kfree_link | Because kfree isn't assignment-compatible with void(void*) ;-/ |
| finish_writeback_work | |
| splice_grow_spd | Check if we need to grow the arrays holding pages and partial page* descriptions. |
| splice_shrink_spd | |
| default_file_splice_read | |
| iter_file_splice_write | r_file_splice_write - splice data from a pipe to a file*@pipe: pipe info*@out: file to write to*@ppos: position in @out*@len: number of bytes to splice*@flags: splice modifier flags* Description:* Will either move or copy pages (determined by @flags |
| SYSCALL_DEFINE4 | |
| COMPAT_SYSCALL_DEFINE4 | |
| do_sync_work | |
| vfs_parse_fs_string | vfs_parse_fs_string - Convenience function to just parse a string. |
| logfc | logfc - Log a message to a filesystem context*@fc: The filesystem context to log to.*@fmt: The format of the buffer. |
| put_fc_log | Free a logging structure. |
| put_fs_context | put_fs_context - Dispose of a superblock configuration context.*@fc: The context to dispose of. |
| legacy_fs_context_free | |
| legacy_fs_context_dup | Duplicate a legacy config. |
| vfs_clean_context | Clean up a context after performing an action on it and put it into a state* from where it can be used to reconfigure a superblock |
| fscontext_read | Allow the user to read back any error, warning or informational messages. |
| SYSCALL_DEFINE2 | Open a filesystem by name so that it can be configured for mounting.* We are allowed to specify a container in which the filesystem will be* opened, thereby indicating which namespaces will be used (notably, which |
| decrypt_bh | |
| __blkdev_direct_IO_simple | |
| fsnotify_final_destroy_group | Final freeing of a group |
| inotify_free_event | |
| fanotify_encode_fid | |
| fanotify_free_event | |
| ep_free | |
| signalfd_release | |
| do_signalfd4 | |
| SYSCALL_DEFINE2 | |
| eventfd_free_ctx | |
| dup_userfaultfd | |
| dup_userfaultfd_complete | |
| userfaultfd_unmap_complete | |
| aio_free_ring | |
| ioctx_add_table | |
| exit_aio | xit_aio: called when the last user of mm goes away. At this point, there is* no way for any new requests to be submited or any of the io_* syscalls to be* called on the context.* There may be outstanding kiocbs, but free_ioctx() will explicitly wait on |
| aio_read | |
| aio_write | |
| io_ring_ctx_alloc | |
| __io_free_req | |
| io_read | |
| io_write | |
| io_sendmsg | |
| io_recvmsg | |
| io_sqe_files_unregister | |
| io_sqe_alloc_file_tables | |
| io_sqe_files_register | |
| io_sqe_buffer_unregister | |
| io_sqe_buffer_register | |
| io_ring_ctx_free | |
| create_io_worker | |
| io_wq_create | |
| io_wq_destroy | |
| fscrypt_fname_free_buffer | scrypt_fname_free_buffer - free the buffer for presented filenames* Free the buffer allocated by fscrypt_fname_alloc_buffer(). |
| fscrypt_setup_filename | scrypt_setup_filename() - prepare to search a possibly encrypted directory*@dir: the directory that will be searched*@iname: the user-provided filename being searched for*@lookup: 1 if we're allowed to proceed without the key because it's* ->lookup() or |
| __fscrypt_encrypt_symlink | |
| fscrypt_get_symlink | scrypt_get_symlink - get the target of an encrypted symlink*@inode: the symlink inode*@caddr: the on-disk contents of the symlink*@max_size: size of @caddr buffer*@done: if successful, will be set up to free the returned target if needed |
| fscrypt_free_inode | scrypt_free_inode - free an inode's fscrypt data requiring RCU delay* Free the inode's cached decrypted symlink target, if any. Filesystems must* call this after an RCU grace period, just before they free the inode. |
| find_and_lock_process_key | Search the current task's subscribed keyrings for a "logon" key with* description prefix:descriptor, and if found acquire a read lock on it and* return a pointer to its validated payload in *payload_ret. |
| build_merkle_tree | Build the Merkle tree for the given inode using the given parameters, and* return the root hash in @root_hash.* The tree is written to a filesystem-specific location as determined by the* ->write_merkle_tree_block() method |
| enable_verity | |
| fsverity_prepare_hash_state | sverity_prepare_hash_state() - precompute the initial hash state*@alg: hash algorithm*@salt: a salt which is to be prepended to all data to be hashed*@salt_size: salt size in bytes, possibly 0* Return: NULL if the salt is empty, otherwise the kmalloc()'ed |
| fsverity_init_merkle_tree_params | sverity_init_merkle_tree_params() - initialize Merkle tree parameters*@params: the parameters struct to initialize*@inode: the inode for which the Merkle tree is being built*@hash_algorithm: number of hash algorithm to use*@log_blocksize: log base 2 of |
| fsverity_free_info | |
| ensure_verity_info | Ensure the inode has an ->i_verity_info |
| fsverity_verify_signature | sverity_verify_signature() - check a verity file's signature* If the file's fs-verity descriptor includes a signature of the file* measurement, verify it against the certificates in the fs-verity keyring |
| COMPAT_SYSCALL_DEFINE5 | |
| create_entry | This registers a new binary format, it recognises the syntax* ':name:type:offset:magic:mask:interpreter:flags'* where the ':' is the IFS, that can be chosen with the first char |
| bm_evict_inode | |
| bm_register_write | /register |
| load_elf_phdrs | load_elf_phdrs() - load ELF program headers*@elf_ex: ELF header of the binary whose program headers should be loaded*@elf_file: the opened ELF binary file* Loads ELF program headers from the binary file elf_file, which has the ELF |
| load_elf_binary | |
| load_elf_fdpic_binary | load an fdpic binary into various bits of memory |
| mb_cache_create | mb_cache_create - create cache*@bucket_bits: log2 of the hash table size* Create cache for keys with 2^bucket_bits hash entries. |
| mb_cache_destroy | mb_cache_destroy - destroy cache*@cache: the cache to destroy* Free all entries in cache and cache itself. Caller must make sure nobody* (except shrinker) can reach @cache when calling this. |
| cn_print_exe_file | |
| do_coredump | |
| do_sys_name_to_handle | |
| handle_to_path | |
| iomap_page_release | |
| iomap_dio_complete | |
| iomap_dio_rw | map_dio_rw() always completes O_[D]SYNC writes regardless of whether the IO* is being issued as AIO or not. This allows us to optimise pure data writes* to use REQ_FUA rather than requiring generic_write_sync() to issue a* REQ_FLUSH post write |
| v2_free_file_info | |
| get_free_dqblk | Remove empty block from list and return it |
| remove_free_dqentry | Remove given block from the list of blocks with free entries |
| insert_free_dqentry | Insert given block to the beginning of list with free entries |
| find_free_dqentry | Find space for dquot |
| do_insert_tree | Insert reference to structure into the trie |
| qtree_write_dquot | We don't have to be afraid of deadlocks as we never have quotas on quota* files... |
| free_dqentry | Free dquot entry in data block |
| remove_tree | Remove reference to dquot from tree |
| find_block_dqentry | Find entry in block |
| find_tree_dqentry | Find entry for given id in the tree |
| qtree_read_dquot | |
| find_next_id | |
| devpts_kill_sb | |
| do_lookup_dcookie | And here is where the userspace process can look up the cookie value* to retrieve the path. |
| dcookie_exit | |
| dcookie_register | |
| dcookie_unregister | |
| ramfs_free_fc | |
| ramfs_kill_sb | |
| ramfs_nommu_get_unmapped_area | |
| __mmu_notifier_register | Same as mmu_notifier_register but here the caller must hold the mmap_sem in* write mode. A NULL mn signals the notifier is being registered for itree* mode. |
| __mmu_notifier_mm_destroy | his is called after the last mmu_notifier_unregister() returned |
| alloc_alien_cache | |
| free_alien_cache | |
| setup_kmem_cache_node | |
| __kmem_cache_release | |
| setup_kmem_cache_nodes | This initializes kmem_cache_node or resizes various caches for all nodes. |