IS_ERR

Type	Parameter	Name
__force const void *	ptr

**Caller**
Name	Describe
pointer	Show a '%p' thing. A kernel extension is that the '%p' is followed* by an extra set of alphanumeric characters that are extended format* specifiers.* Please update scripts/checkpatch.pl when adding/removing conversion* characters
idr_alloc_u32
seq_buf_path	seq_buf_path - copy a path into the sequence buffer@s: seq_buf descriptor@path: path to write into the sequence buffer
bitmap_parse_region
bitmap_parselist	map_parselist - convert list format ASCII string to bitmap@buf: read user string from this buffer; must be terminated with a \0 or \n
bitmap_parselist_user	map_parselist_user()@ubuf: pointer to user buffer containing string.@ulen: buffer size in bytes. If string is smaller than this* then it must be terminated with a \0.*@maskp: pointer to bitmap array that will contain result.
kstrdup_quotable_file	Returns allocated NULL-terminated string containing pathname,* with special characters escaped, able to be safely logged. If* there is an error, the leading character will be "<".
test_skb_segment_single
trigger_batched_requests_store	We use a kthread as otherwise the kernel serializes all our sync requests* and we would not be able to mimic batched requests on a sync call. Batched* requests on a sync call can for instance happen on a device driver when
copy_user_test
do_concurrent_test
test_overflow_allocation	Allocator uses a trailing node argument --------+ (e.g. kmalloc_node())* Allocator uses the gfp_t argument -----------+ \| (e.g. kmalloc())* Allocator uses a special leading argument + \| \| (e.g. devm_kmalloc())* \| \| \|
test_bucket_stats
test_rht_init
errptr
test_parman_lsort
try_one_request
test_dev_kmod_stop_tests
world_obj_get
test_nodelta_obj_get
check_stats_zero
check_stats_nodelta
test_nodelta
check_expect_stats
test_delta_action_item
test_delta
pr_debug_stats
pr_debug_hints_stats
check_expect_hints_stats
test_hints_case
kunit_ptr_not_err_assert_format
kunit_try_catch_run
crc_t10dif_rehash
crc_t10dif_mod_init
textsearch_prepare	xtsearch_prepare - Prepare a search@algo: name of search algorithm@pattern: pattern data@len: length of pattern@gfp_mask: allocation mask@flags: search flags Looks up the search algorithm module and creates a new textsearch
kmp_init
bm_init
fsm_init
err_inject_init
netdev_err_inject_init
err_inject_init
err_inject_init
ddebug_proc_write
digsig_verify_rsa	RSA Signature verification with public key
digsig_verify	digsig_verify() - digital signature verification with public key@keyring: keyring to search key in@sig: digital signature@siglen: length of the signature@data: data@datalen: length of the data Returns 0 on success, -EINVAL otherwise
digsig_init
objagg_obj_parent_assign
objagg_obj_root_create
objagg_obj_init_with_hints
objagg_obj_get	bjagg_obj_get - gets an object within objagg instance@objagg: objagg instance@obj: user-specific private object pointer* Note: all locking must be provided by the caller
objagg_opt_simple_greedy_fillup_hints
ptrace_write_dr7	Handle ptrace writes to debug register 7.
ptrace_set_breakpoint_addr
microcode_init
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
rdtgroup_add_file
rdtgroup_mkdir_info_resdir
rdtgroup_create_info_dir
mongroup_create_dir
mon_addfile
mkdir_mondata_subdir
mkdir_rdt_prepare
rdtgroup_setup_root
measure_residency_fn
pseudo_lock_measure_cycles	pseudo_lock_measure_cycles - Trigger latency measure to pseudo-locked region* The measurement of latency to access a pseudo-locked region should be* done from a cpu that is associated with that pseudo-locked region
rdtgroup_pseudo_lock_create	dtgroup_pseudo_lock_create - Create a pseudo-locked region@rdtgrp: resource group to which pseudo-lock region belongs Called when a resource group in the pseudo-locksetup mode receives a* valid schemata that should be pseudo-locked
rdt_pseudo_lock_init
msr_init
cpuid_init
apm_init	Just start the APM thread. We do NOT want to do APM BIOS* calls from anything but the APM thread, if for no other reason* than the fact that we don't trust the APM BIOS. This way,* most common APM BIOS problems that lead to protection errors
bzImage64_load
kgdb_arch_late
copy_process	Create a new process
fork_idle
_do_fork	fork routine
pidfd_get_pid
kernel_waitid
__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
pidfd_to_pid
SYSCALL_DEFINE4	sys_pidfd_send_signal - Signal a process through a pidfd@pidfd: file descriptor of the process@sig: signal to send@info: signal info@flags: future flags* The syscall currently only signals via PIDTYPE_PID which covers* kill(,
fork_usermode_blob	rk_usermode_blob - fork a blob of bytes as a usermode process@data: a blob of bytes that can be do_execv-ed as a file@len: length of the blob@info: information about usermode process (shouldn't be NULL) If info->cmdline is set it will be used as
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.
__kthread_create_on_node
kthread_create_on_cpu	kthread_create_on_cpu - Create a cpu bound kthread@threadfn: the function to run until signal_pending(current).@data: data ptr for @threadfn.@cpu: The cpu on which the thread should be bound,@namefmt: printf-style name for the thread
__kthread_create_worker
create_new_namespaces	Create new nsproxy and all of its the associated namespaces.* Return the newly created nsproxy. Do not attach this to the task,* leave it to the caller to do proper locking and attach it to task.
copy_namespaces	This now handles copy for nsproxy and all namespaces therein
unshare_nsproxy_namespaces	Called from unshare. Unshare all the namespaces part of nsproxy.* On success, returns the new nsproxy.
SYSCALL_DEFINE2
__smpboot_create_thread
autogroup_create
sugov_kthread_create
psi_trigger_create
psi_write
__down_read_killable
__down_write_killable
snapshot_write_next	snapshot_write_next - Get the address to store the next image page.@handle: Snapshot handle structure to guide the writing. On the first call, @handle should point to a zeroed snapshot_handle* structure
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.
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.
swsusp_check	swsusp_check - Check for swsusp signature in the resume device
swsusp_close	swsusp_close - close swap device.
pm_wake_lock
pm_wake_unlock
setup_irq_thread
irq_get_domain_generic_chip	q_get_domain_generic_chip - Get a pointer to the generic chip of a hw_irq@d: irq domain pointer@hw_irq: Hardware interrupt number
irq_map_generic_chip	q_map_generic_chip - Map a generic chip for an irq domain
rcutorture_booster_init
rcu_spawn_gp_kthread	Spawn the kthreads that handle RCU's grace periods.
kcmp_epoll_target
resolve_symbol_wait
simplify_symbols	Change all symbols so that st_value encodes the pointer directly.
load_module	Allocate and load the module: note that size of section 0 is alwayszero, and we rely on this for optional sections.
acct_on
SYSCALL_DEFINE1	sys_acct - enable/disable process accounting@name: file name for accounting records or NULL to shutdown accounting Returns 0 for success or negative errno values for failure.* sys_acct() is the only system call needed to implement process* accounting
kimage_file_prepare_segments	In file mode list of segments is prepared by kernel. Copy relevant* data from user space, do error checking, prepare segment list
kexec_calculate_store_digests
cgroup_setup_root
cgroup_do_get_tree
cgroup_apply_control_enable	group_apply_control_enable - enable or show csses according to control@cgrp: root of the target subtree Walk @cgrp's subtree and create new csses or make the existing ones* visible. A css is created invisible if it's being implicitly enabled
cgroup_add_file
css_create
cgroup_create	The returned cgroup is fully initialized including its control mask, but* it isn't associated with its kernfs_node and doesn't have the control* mask applied.
cgroup_mkdir
cgroup_init_subsys
cgroup_get_from_fd	group_get_from_fd - get a cgroup pointer from a fd@fd: fd obtained by open(cgroup2_dir) Find the cgroup from a fd which should be obtained* by opening a cgroup directory. Returns a pointer to the* cgroup on success. ERR_PTR is returned if the cgroup
copy_cgroup_ns
rdmacg_try_charge	dmacg_try_charge - hierarchically try to charge the rdma resource@rdmacg: pointer to rdma cgroup which will own this resource@device: pointer to rdmacg device*@index: index of the resource to charge in cgroup (resource pool)
rdmacg_resource_set_max
map_write
audit_send_reply	audit_send_reply - send an audit reply message via netlink@request_skb: skb of request we are replying to (used to target the reply)@seq: sequence number@type: audit message type@done: done (last) flag@multi: multi-part message flag@payload: payload
audit_receive_msg
audit_init	Initialize audit support at boot time.
audit_log_d_path	This is a helper-function to print the escaped d_path
audit_data_to_entry	Translate struct audit_rule_data to kernel's rule representation.
audit_rule_change	audit_rule_change - apply all rules to the specified message type@type: audit message type@seq: netlink audit message sequence (serial) number@data: payload data@datasz: size of payload data
audit_list_rules_send	audit_list_rules_send - list the audit rules@request_skb: skb of request we are replying to (used to target the reply)@seq: netlink audit message sequence (serial) number
update_lsm_rule
audit_to_watch	Translate a watch string to kernel representation.
audit_dupe_watch	Duplicate the given audit watch. The new watch's rules list is initialized* to an empty list and wlist is undefined.
audit_update_watch	Update inode info in audit rules based on filesystem event.
audit_get_nd	Get path information necessary for adding watches.
audit_add_watch	Find a matching watch entry, or add this one.* Caller must hold audit_filter_mutex.
audit_watch_init
audit_dupe_exe
audit_alloc_mark
audit_fsnotify_init
audit_trim_trees
audit_launch_prune
audit_add_tree_rule	alled with audit_filter_mutex
audit_tag_tree
audit_tree_init
kcov_ioctl_locked
kcov_ioctl
register_kprobe
__unregister_kprobe_top	Unregister a kprobe without a scheduler synchronization.
disable_kprobe	Disable one kprobe
fei_debugfs_init
hardlockup_detector_event_create
relay_create_buf_file
tracepoint_add_func	Add the probe function to a tracepoint.
tracepoint_remove_func	Remove a probe function from a tracepoint.* Note: only waiting an RCU period after setting elem->call to the empty* function insures that the original callback is not used anymore. This insured* by preempt_disable around the call site.
read_page
ring_buffer_benchmark_init
tracing_open
tracing_buffers_read
tracing_buffers_splice_read
tracing_dentry_percpu
trace_options_init_dentry
trace_array_get_by_name	race_array_get_by_name - Create/Lookup a trace array, given its name
trace_automount
tracer_init_tracefs
tracing_stat_init
hold_module_trace_bprintk_format
init_trace_printk_function_export
tracing_map_alloc_elts
start_kthread	start_kthread - Kick off the hardware latency sampling/detector kthread* This starts the kernel thread that will sit and sample the CPU timestamp* counter (TSC or similar) and look for potential hardware latencies.
init_tracefs	_tracefs - A function to initialize the tracefs interface files* This function creates entries in tracefs for "hwlat_detector"
stack_trace_init
init_graph_tracefs
event_filter_write
subsystem_filter_write
event_trace_init
process_preds
event_trigger_regex_write
event_inject_write
register_synth_event
__create_synth_event
find_event_var
parse_atom
parse_unary
parse_expr
create_field_var_hist	reate_field_var_hist - Automatically create a histogram and var for a field@target_hist_data: The target hist trigger@subsys_name: Optional subsystem name@event_name: Optional event name@field_name: The name of the field (and the resulting variable)*
create_field_var
track_data_create
trace_action_create_field_var
action_create
onmatch_parse
__create_val_field
create_key_field
parse_actions
create_hist_data
event_hist_trigger_func
trace_events_hist_init
____bpf_perf_event_output_raw_tp
____bpf_get_stackid_raw_tp
____bpf_get_stack_raw_tp
trace_kprobe_create
init_kprobe_trace	Make a tracefs interface for controlling probe points
init_dynamic_event	Make a tracefs interface for controlling dynamic events
trace_uprobe_create
init_uprobe_trace	Make a trace interface for controling probe points
trace_benchmark_reg	When the benchmark tracepoint is enabled, it calls this* function and the thread that calls the tracepoint is created.
find_and_alloc_map
map_create	alled via syscall
bpf_map_get_with_uref
map_lookup_elem
map_update_elem
map_delete_elem
map_get_next_key
map_lookup_and_delete_elem
map_freeze
__bpf_prog_get
bpf_prog_load
bpf_raw_tracepoint_open
bpf_prog_attach
bpf_prog_test_run
bpf_prog_get_fd_by_id
bpf_map_get_fd_by_id
bpf_task_fd_query
check_btf_info
replace_map_fd_with_map_ptr	look for pseudo eBPF instructions that access map FDs and* replace them with actual map pointers
bpf_patch_insn_data
bpf_check
bpf_fd_probe_obj
bpf_mkdir
bpf_mkobj_ops
bpf_symlink
bpf_obj_do_pin
bpf_obj_pin_user
bpf_obj_do_get
bpf_obj_get_user
bpf_prog_get_type_path
htab_map_update_elem	Called from syscall or from eBPF program
__htab_percpu_map_update_elem
bpf_fd_htab_map_update_elem	ly called from syscall
htab_of_map_alloc
bpf_fd_array_map_update_elem	ly called from syscall
prog_fd_array_get_ptr
prog_array_map_alloc
perf_event_fd_array_get_ptr
array_of_map_alloc
bpf_map_meta_alloc
bpf_map_fd_get_ptr
btf_struct_access
__btf_resolve_helper_id
btf_new_fd
btf_get_fd_by_id
__dev_map_update_elem
__dev_map_hash_update_elem
__cpu_map_entry_alloc
xsk_map_update_elem
bpf_prog_offload_info_fill
bpf_map_offload_info_fill
__cgroup_bpf_attach	__cgroup_bpf_attach() - Attach the program to a cgroup, and* propagate the change to descendants@cgrp: The cgroup which descendants to traverse@prog: A program to attach@type: Type of attach operation@flags: Option flags
cgroup_bpf_prog_attach
cgroup_bpf_prog_detach
cgroup_bpf_prog_query
perf_event_mmap_event
perf_event_set_filter
perf_event_alloc	Allocate and initialize an event structure
perf_event_create_kernel_counter	perf_event_create_kernel_counter@attr: attributes of the counter to create@cpu: cpu in which the counter is bound*@task: task to profile (NULL for percpu)
inherit_event	Inherit an event from parent task to child task.* Returns:* - valid pointer on success* - NULL for orphaned events* - IS_ERR() on error
inherit_group	Inherits an event group.* This will quietly suppress orphaned events; !inherit_event() is not an error.* This matches with perf_event_release_kernel() removing all child events.* Returns:* - 0 on success* - <0 on error
register_wide_hw_breakpoint	a set of per_cpu pointers to perf events
__copy_insn
register_for_each_vma
__uprobe_register	__uprobe_register - register a probe*@inode: the file in which the probe has to be placed
xol_add_vma	Slot allocation for XOL
_torture_create_kthread	Create a generic torture kthread that is immediately runnable. If you* need the kthread to be stopped so that you can do something to it before* it starts, you will need to open-code your own.
wait_on_page_read
do_read_cache_page
dio_warn_stale_pagecache	Warn about a page cache invalidation failure during a direct I/O write.
kswapd_run	This kswapd start function will be called by init and node-hot-add.* On node-hot-add, kswapd will moved to proper cpus if cpus are hot-added.
shmem_init
__shmem_file_setup	mmon code
shmem_zero_setup	shmem_zero_setup - setup a shared anonymous mapping*@vma: the vma to be mmapped is prepared by do_mmap_pgoff
strndup_user	strndup_user - duplicate an existing string from user space@s: The string to duplicate@n: Maximum number of bytes to copy, including the trailing NUL.* Return: newly allocated copy of @s or an ERR_PTR() in case of error
bdi_class_init
bdi_register_va
kmem_cache_create_usercopy	kmem_cache_create_usercopy - Create a cache with a region suitable* for copying to userspace@name: A string which is used in /proc/slabinfo to identify this cache.@size: The size of objects to be created in this cache.
follow_page_mask	llow_page_mask - look up a page descriptor from a user-virtual address@vma: vm_area_struct mapping @address@address: virtual address to look up@flags: flags modifying lookup behaviour@ctx: contains dev_pagemap for %ZONE_DEVICE memory pinning and a*
__get_user_pages	__get_user_pages() - pin user pages in memory@tsk: task_struct of target task@mm: mm_struct of target mm@start: starting user address@nr_pages: number of pages from start to pin*@gup_flags: flags modifying pin behaviour
print_vma_addr	Print the name of a VMA.
munlock_vma_pages_range	munlock_vma_pages_range() - munlock all pages in the vma range.'@vma - vma containing range to be munlock()ed.@start - start address in @vma of the range@end - end of range in @vma. For mremap(), munmap() and exit().* Called with @vma VM_LOCKED.
ksys_mmap_pgoff
mremap_to
SYSCALL_DEFINE5	Expand (or shrink) an existing mapping, potentially moving it at the* same time (controlled by the MREMAP_MAYMOVE flag and available VM space)* MREMAP_FIXED option added 5-Dec-1999 by Benjamin LaHaise* This option implies MREMAP_MAYMOVE.
new_vmap_block	w_vmap_block - allocates new vmap_block and occupies 2^order pages in this* block
vm_map_ram	vm_map_ram - map pages linearly into kernel virtual address (vmalloc space)@pages: an array of pointers to the pages to be mapped@count: number of pages@node: prefer to allocate data structures on this node@prot: memory protection to use
__get_vm_area_node
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
numa_zonelist_order_handler	sysctl handler for numa_zonelist_order
SYSCALL_DEFINE1
SYSCALL_DEFINE2
hugetlb_cow	Hugetlb_cow() should be called with page lock of the original hugepage held.* Called with hugetlb_instantiation_mutex held and pte_page locked so we* cannot race with other handlers or page migration.
hugetlb_no_page
hugetlb_mcopy_atomic_pte	Used by userfaultfd UFFDIO_COPY. Based on mcopy_atomic_pte with* modifications for huge pages.
vma_replace_policy	Apply policy to a single VMA* This must be called with the mmap_sem held for writing.
do_set_mempolicy	Set the process memory policy
do_mbind
vma_dup_policy
sp_alloc
mpol_shared_policy_init	mpol_shared_policy_init - initialize shared policy for inode@sp: pointer to inode shared policy@mpol: struct mempolicy to install* Install non-NULL @mpol in inode's shared policy rb-tree.* On entry, the current task has a reference on a non-NULL @mpol.
sparse_add_section	sparse_add_section - add a memory section, or populate an existing one@nid: The node to add section on@start_pfn: start pfn of the memory range@nr_pages: number of pfns to add in the section@altmap: device page map* This is only intended for hotplug
mmu_notifier_get_locked	mmu_notifier_get_locked - Return the single struct mmu_notifier for* the mm & ops@ops: The operations struct being subscribe with@mm : The mm to attach notifiers too* This function either allocates a new mmu_notifier via* list
ksm_init
__add_memory	quires device_hotplug_lock, see add_memory_resource()
add_page_for_migration	Resolves the given address to a struct page, isolates it from the LRU and* puts it to the given pagelist
do_pages_stat_array	Determine the nodes of an array of pages and store it in an array of status.
khugepaged_prealloc_page
start_stop_khugepaged
memcg_write_event_control	DO NOT USE IN NEW FILES.* Parse input and register new cgroup event handler.* Input must be in format ' '.* Interpretation of args is defined by control file implementation.
kmemleak_alloc	kmemleak_alloc - register a newly allocated object@ptr: pointer to beginning of the object@size: size of the object@min_count: minimum number of references to this object. If during memory scanning a number of references less than @min_count is found,
kmemleak_alloc_percpu	kmemleak_alloc_percpu - register a newly allocated __percpu object@ptr: __percpu pointer to beginning of the object@size: size of the object@gfp: flags used for kmemleak internal memory allocations This function is called from the kernel percpu
kmemleak_free	kmemleak_free - unregister a previously registered object@ptr: pointer to beginning of the object This function is called from the kernel allocators when an object (memory* block) is freed (kmem_cache_free, kfree, vfree etc.).
kmemleak_free_part	kmemleak_free_part - partially unregister a previously registered object*@ptr: pointer to the beginning or inside the object
kmemleak_free_percpu	kmemleak_free_percpu - unregister a previously registered __percpu object@ptr: __percpu pointer to beginning of the object This function is called from the kernel percpu allocator when an object* (memory block) is freed (free_percpu).
kmemleak_not_leak	kmemleak_not_leak - mark an allocated object as false positive@ptr: pointer to beginning of the object Calling this function on an object will cause the memory block to no longer* be reported as leak and always be scanned.
kmemleak_ignore	kmemleak_ignore - ignore an allocated object@ptr: pointer to beginning of the object Calling this function on an object will cause the memory block to be* ignored (not scanned and not reported as a leak)
kmemleak_scan_area	kmemleak_scan_area - limit the range to be scanned in an allocated object*@ptr: pointer to beginning or inside the object
kmemleak_no_scan	kmemleak_no_scan - do not scan an allocated object@ptr: pointer to beginning of the object This function notifies kmemleak not to scan the given memory block. Useful* in situations where it is known that the given object does not contain any
start_scan_thread	Start the automatic memory scanning thread. This function must be called* with the scan_mutex held.
kmemleak_seq_stop	Decrement the use_count of the last object required, if any.
z3fold_mount
z3fold_register_migration
put_vaddr_frames	put_vaddr_frames() - drop references to pages if get_vaddr_frames() acquired* them@vec: frame vector to put Drop references to pages if get_vaddr_frames() acquired them. We also* invalidate the frame vector so that it is prepared for the next call into
ipc_obtain_object_check	pc_obtain_object_check@ids: ipc identifier set@id: ipc id to look for* Similar to ipc_obtain_object_idr() but also checks the ipc object* sequence number.* Call inside the RCU critical section.* The ipc object is not locked on exit.
ipcctl_obtain_check	pcctl_obtain_check - retrieve an ipc object and check permissions@ns: ipc namespace@ids: the table of ids where to look for the ipc@id: the id of the ipc to retrieve@cmd: the cmd to check@perm: the permission to set@extra_perm: one extra permission
msq_obtain_object
msq_obtain_object_check
msgctl_down	This function handles some msgctl commands which require the rwsem* to be held in write mode.* NOTE: no locks must be held, the rwsem is taken inside this function.
msgctl_stat
do_msgsnd
do_msgrcv
sem_obtain_object	sem_lock_(check_) routines are called in the paths where the rwsem* is not held.* The caller holds the RCU read lock.
sem_obtain_object_check
semctl_stat
semctl_setval
semctl_main
semctl_down	This function handles some semctl commands which require the rwsem* to be held in write mode.* NOTE: no locks must be held, the rwsem is taken inside this function.
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
do_semtimedop
exit_sem	add semadj values to semaphores, free undo structures
shm_obtain_object
shm_obtain_object_check
shm_lock	shm_lock_(check_) routines are called in the paths where the rwsem* is not necessarily held.
__shm_open
shm_close
newseg	wseg - Create a new shared memory segment@ns: namespace@params: ptr to the structure that contains key, size and shmflg* Called with shm_ids.rwsem held as a writer.
shmctl_down	This function handles some shmctl commands which require the rwsem* to be held in write mode.* NOTE: no locks must be held, the rwsem is taken inside this function.
shmctl_stat
shmctl_do_lock
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.
mqueue_fill_super
mq_create_mount
mqueue_create_attr
do_mq_open
SYSCALL_DEFINE1
do_mq_timedsend
do_mq_notify	Notes: the case when user wants us to deregister (with NULL as pointer)* and he isn't currently owner of notification, will be silently discarded.* It isn't explicitly defined in the POSIX.
mq_init_ns
blk_get_request	lk_get_request - allocate a request@q: request queue to allocate a request for@op: operation (REQ_OP_) and REQ_ flags, e.g. REQ_SYNC.@flags: BLK_MQ_REQ_ flags, e.g. BLK_MQ_REQ_NOWAIT.
__blk_rq_map_user_iov
blk_rq_map_kern	lk_rq_map_kern - map kernel data to a request, for passthrough requests@q: request queue where request should be inserted@rq: request to fill@kbuf: the kernel buffer@len: length of user data@gfp_mask: memory allocation flags Description:
blk_mq_init_queue
blk_mq_init_sq_queue	Helper for setting up a queue with mq ops, given queue depth, and* the passed in mq ops flags.
blk_add_partition
blk_add_partitions
read_dev_sector
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
__blk_send_generic	Send basic block requests
bsg_sg_io
bsg_open
bsg_register_queue
bsg_init
bsg_transport_fill_hdr
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_lookup_create	__blkg_lookup_create - lookup blkg, try to create one if not there@blkcg: blkcg of interest@q: request_queue of interest* Lookup blkg for the @blkcg - @q pair. If it doesn't exist, try to* create one
blkg_conf_prep	lkg_conf_prep - parse and prepare for per-blkg config update@blkcg: target block cgroup@pol: target policy@input: input string@ctx: blkg_conf_ctx to be filled* Parse per-blkg config update from @input and initialize @ctx with the* result
blkcg_init_queue	lkcg_init_queue - initialize blkcg part of request queue@q: request_queue to initialize Called from blk_alloc_queue_node(). Responsible for initializing blkcg* part of new request_queue @q.* RETURNS:* 0 on success, -errno on failure.
ioc_qos_write
ioc_cost_model_write
kyber_init_sched
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
bio_integrity_clone	_integrity_clone - Callback for cloning bios with integrity metadata@bio: New bio@bio_src: Original bio@gfp_mask: Memory allocation mask Description: Called to allocate a bip when cloning a bio
response_get_string
response_get_u64
response_token_matches
sed_ioctl
key_create_or_update	key_create_or_update - Update or create and instantiate a key.@keyring_ref: A pointer to the destination keyring with possession flag.@type: The type of key.*@description: The searchable description for the key.
keyring_alloc	Allocate a keyring and link into the destination keyring.
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
__key_link_begin	Preallocate memory so that a key can be linked into to a keyring.
__key_unlink_begin	Begin the process of unlinking a key from a keyring.
keyring_clear	keyring_clear - Clear a keyring@keyring: The keyring to clear. Clear the contents of the specified keyring.* Returns 0 if successful or -ENOTDIR if the keyring isn't a keyring.
keyring_revoke
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_get_keyring_ID	Get the ID of the specified process keyring.* The requested keyring must have search permission to be found.* If successful, the ID of the requested keyring will be returned.
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_update_key	Update a key's data payload from the given data.* The key must grant the caller Write permission and the key type must support* updating for this to work. A negative key can be positively instantiated* with this call.* If successful, 0 will be returned
keyctl_revoke_key	Revoke a key.* The key must be grant the caller Write or Setattr permission for this to* work. The key type should give up its quota claim when revoked. The key* and any links to the key will be automatically garbage collected after a
keyctl_invalidate_key	Invalidate a key.* The key must be grant the caller Invalidate permission for this to work.* The key and any links to the key will be automatically garbage collected* immediately.* Keys with KEY_FLAG_KEEP set should not be invalidated.
keyctl_keyring_clear	Clear the specified keyring, creating an empty process keyring if one of the* special keyring IDs is used.* The keyring must grant the caller Write permission and not have* KEY_FLAG_KEEP set for this to work. If successful, 0 will be returned.
keyctl_keyring_link	Create a link from a keyring to a key if there's no matching key in the* keyring, otherwise replace the link to the matching key with a link to the* new key.* The key must grant the caller Link permission and the the keyring must grant
keyctl_keyring_unlink	Unlink a key from a keyring.* The keyring must grant the caller Write permission for this to work; the key* itself need not grant the caller anything. If the last link to a key is* removed then that key will be scheduled for destruction.
keyctl_keyring_move	Move a link to a key from one keyring to another, displacing any matching* key from the destination keyring.* The key must grant the caller Link permission and both keyrings must grant* the caller Write permission
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_read_key	Read a key's payload
keyctl_chown_key	Change the ownership of a key* The key must grant the caller Setattr permission for this to work, though* the key need not be fully instantiated yet. For the UID to be changed, or* for the GID to be changed to a group the caller is not a member of, the
keyctl_setperm_key	Change the permission mask on a key.* The key must grant the caller Setattr permission for this to work, though* the key need not be fully instantiated yet. If the caller does not have
get_instantiation_keyring	Get the destination keyring for instantiation and check that the caller has* Write permission on it.
keyctl_set_timeout	Set or clear the timeout on a key.* Either the key must grant the caller Setattr permission or else the caller* must hold an instantiation authorisation token for the key.* The timeout is either 0 to clear the timeout, or a number of seconds from
keyctl_assume_authority	Assume (or clear) the authority to instantiate the specified key
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_session_to_parent	Attempt to install the calling process's session keyring on the process's* parent process.* The keyring must exist and must grant the caller LINK permission, and the* parent process must be single-threaded and must have the same effective
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.
get_user_register	Get or create a user register keyring.
look_up_user_keyrings	Look up the user and user session keyrings for the current process's UID,* creating them if they don't exist.
get_user_session_keyring_rcu	Get the user session keyring if it exists, but don't create it if it* doesn't.
install_thread_keyring_to_cred	Install a thread keyring to the given credentials struct if it didn't have* one already. This is allowed to overrun the quota.* Return: 0 if a thread keyring is now present; -errno on failure.
install_process_keyring_to_cred	Install a process keyring to the given credentials struct if it didn't have* one already. This is allowed to overrun the quota.* Return: 0 if a process keyring is now present; -errno on failure.
install_session_keyring_to_cred	Install the given keyring as the session keyring of the given credentials* struct, replacing the existing one if any. If the given keyring is NULL,* then install a new anonymous session keyring.*@cred can not be in use by any task yet.
search_cred_keyrings_rcu	Search the process keyrings attached to the supplied cred for the first* matching key under RCU conditions (the caller must be holding the RCU read* lock)
search_process_keyrings_rcu	Search the process keyrings attached to the supplied cred for the first* matching key in the manner of search_my_process_keyrings(), but also search* the keys attached to the assumed authorisation key using its credentials if* one is available.
lookup_user_key	Look up a key ID given us by userspace with a given permissions mask to get* the key it refers to.* Flags can be passed to request that special keyrings be created if referred* to directly, to permit partially constructed keys to be found and to skip
join_session_keyring	Join the named keyring as the session keyring if possible else attempt to* create a new one of that name and join that
call_sbin_request_key	Request userspace finish the construction of a key* - execute "/sbin/request-key "
construct_key	Call out to userspace for key construction.* Program failure is ignored in favour of key status.
construct_alloc_key	Allocate a new key in under-construction state and attempt to link it in to* the requested keyring.* May return a key that's already under construction instead if there was a* race between two thread calling request_key().
request_key_and_link	quest_key_and_link - Request a key and cache it in a keyring.@type: The type of key we want.@description: The searchable description of the key.*@domain_tag: The domain in which the key operates.
request_key_tag	quest_key_tag - Request a key and wait for construction*@type: Type of key
request_key_with_auxdata	quest_key_with_auxdata - Request a key with auxiliary data for the upcaller@type: The type of key we want.@description: The searchable description of the key.*@domain_tag: The domain in which the key operates.
request_key_rcu	quest_key_rcu - Request key from RCU-read-locked context@type: The type of key we want.@description: The name of the key we want.@domain_tag: The domain in which the key operates. Request a key from a context that we may not sleep in (such as RCU-mode
request_key_auth_new	Create an authorisation token for /sbin/request-key or whoever to gain* access to the caller's security data.
key_get_instantiation_authkey	Search the current process's keyrings for the authorisation key for* instantiation of a key.
proc_keys_show
key_create_persistent_register	Create the persistent keyring register for the current user namespace.* Called with the namespace's sem locked for writing.
key_create_persistent	Create the persistent keyring for the specified user.* Called with the namespace's sem locked for writing.
key_get_persistent	Get the persistent keyring for a specific UID and link it to the nominated* keyring.
keyctl_get_persistent	Get the persistent keyring for a specific UID and link it to the nominated* keyring.
dh_data_from_key
kdf_alloc
__keyctl_dh_compute
keyctl_pkey_params_get	Interpret parameters. Callers must always call the free function* on params, even if an error is returned.
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_preparse	Preparse a big key
big_key_read	ad the key data* - the key's semaphore is read-locked
big_key_init	Register key type
TSS_sha1
TSS_rawhmac
TSS_authhmac	alculate authorization info fields to send to TPM
TSS_checkhmac1	verify the AUTH1_COMMAND (Seal) result from TPM
TSS_checkhmac2	verify the AUTH2_COMMAND (unseal) result from TPM
trusted_shash_alloc
aes_get_sizes
request_user_key	quest_user_key - request the user key* Use a user provided key to encrypt/decrypt an encrypted-key.
calc_hmac
init_skcipher_req
request_master_key
derived_key_encrypt	Before returning data to userspace, encrypt decrypted data.
derived_key_decrypt
encrypted_key_decrypt
encrypted_instantiate	rypted_instantiate - instantiate an encrypted key* Decrypt an existing encrypted datablob or create a new encrypted key* based on a kernel random number.* On success, return 0. Otherwise return errno.
encrypted_update	rypted_update - update the master key description* Change the master key description for an existing encrypted key.* The next read will return an encrypted datablob using the new* master key description.* On success, return 0. Otherwise return errno.
encrypted_read	rypted_read - format and copy the encrypted data to userspace* The resulting datablob format is:* * On success, return to userspace the encrypted key datablob size.
init_encrypted
request_trusted_key	quest_trusted_key - request the trusted key* Trusted keys are sealed to PCRs and other metadata. Although userspace* manages both trusted/encrypted key-types, like the encrypted key type* data, trusted key type data is not visible decrypted from userspace.
securityfs_create_dentry	securityfs_create_dentry - create a dentry in the securityfs filesystem@name: a pointer to a string containing the name of the file to create.@mode: the permission that the file should have*@parent: a pointer to the parent dentry for this file
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
securityfs_remove	securityfs_remove - removes a file or directory from the securityfs filesystem*@dentry: a pointer to a the dentry of the file or directory to be removed
selinux_genfs_get_sid
flush_unauthorized_files	Derived from fs/exec.c:flush_old_files.
selinux_inode_follow_link
selinux_inode_permission
sel_write_checkreqprot
sel_write_validatetrans
selinux_transaction_write
sel_write_bool
sel_commit_bools_write
sel_write_avc_cache_threshold
sel_make_class_dir_entries
sel_make_classes
sel_fill_super
init_sel_fs
smack_set_mnt_opts	smack_set_mnt_opts - set Smack specific mount options@sb: the file system superblock@mnt_opts: Smack mount options@kern_flags: mount option from kernel space or user space@set_kern_flags: where to store converted mount opts* Returns 0 on success, an
smack_inode_setxattr	smack_inode_setxattr - Smack check for setting xattrs@dentry: the object@name: name of the attribute@value: value of the attribute@size: size of the value@flags: unused This protects the Smack attribute explicitly
smack_inode_post_setxattr	smack_inode_post_setxattr - Apply the Smack update approved above@dentry: object@name: attribute name@value: attribute value@size: attribute size@flags: unused Set the pointer in the inode blob to the entry found* in the master label list.
smack_inode_setsecurity	smack_inode_setsecurity - set smack xattrs@inode: the object@name: attribute name@value: attribute value@size: size of the attribute@flags: unused Sets the named attribute in the appropriate blob* Returns 0 on success, or an error code
smack_d_instantiate	smack_d_instantiate - Make sure the blob is correct on an inode@opt_dentry: dentry where inode will be attached@inode: the object* Set the inode's security blob if it hasn't been done already.
smack_setprocattr	smack_setprocattr - Smack process attribute setting*@name: the name of the attribute in /proc/
smack_audit_rule_init	smack_audit_rule_init - Initialize a smack audit rule@field: audit rule fields given from user-space (audit.h)@op: required testing operator (=, !=, >, <, ...)@rulestr: smack label to be audited@vrule: pointer to save our own audit rule representation
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_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_parse_label_list	smk_parse_label_list - parse list of Smack labels, separated by spaces@data: the string to parse@private: destination list* Returns zero on success or error code, as appropriate
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_user_access	smk_user_access - handle access check transaction@file: file pointer@buf: data from user space@count: bytes sent@ppos: where to start - must be 0
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
init_smk_fs	_smk_fs - get the smackfs superblock* register the smackfs* Do not register smackfs if Smack wasn't enabled* on boot
tomoyo_get_absolute_path	moyo_get_absolute_path - Get the path of a dentry but ignores chroot'ed root.@path: Pointer to "struct path".@buffer: Pointer to buffer to return value in.@buflen: Sizeof @buffer. Returns the buffer on success, an error code otherwise.
tomoyo_get_dentry_path	moyo_get_dentry_path - Get the path of a dentry.@dentry: Pointer to "struct dentry".@buffer: Pointer to buffer to return value in.@buflen: Sizeof @buffer. Returns the buffer on success, an error code otherwise.
tomoyo_get_local_path	moyo_get_local_path - Get the path of a dentry.@dentry: Pointer to "struct dentry".@buffer: Pointer to buffer to return value in.@buflen: Sizeof @buffer. Returns the buffer on success, an error code 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_create	aafs_create - create a dentry in the apparmorfs filesystem@name: name of dentry to create@mode: permissions the file should have@parent: parent directory for this dentry@data: data to store on 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
aafs_remove	aafs_remove - removes a file or directory from the apparmorfs filesystem*@dentry: dentry of the file/directory/symlink to removed.
aa_simple_write_to_buffer	aa_simple_write_to_buffer - common routine for getting policy from user@userbuf: user buffer to copy data from (NOT NULL)@alloc_size: size of user buffer (REQUIRES: @alloc_size >= @copy_size)@copy_size: size of data to copy from user buffer@pos:
policy_update
profile_remove	.remove file hook fn to remove loaded policy
query_data	query_data - queries a policy and writes its data to buf@buf: the resulting data is stored here (NOT NULL)@buf_len: size of buf@query: query string used to retrieve data@query_len: size of query including second NUL byte
query_label	query_label - queries a label and writes permissions to buf@buf: the resulting permissions string is stored here (NOT NULL)@buf_len: size of buf@query: binary query string to match against the dfa@query_len: size of query*@view_only: only compute for
aa_write_access	aa_write_access - generic permissions and data query@file: pointer to open apparmorfs/access file@ubuf: user buffer containing the complete query string (NOT NULL)@count: size of ubuf@ppos: position in the file (MUST BE ZERO)* Allows for one
rawdata_open
__aa_fs_create_rawdata
create_profile_file
rawdata_get_link_base
__aafs_profile_mkdir	Requires: @profile->ns->lock held
ns_mkdir_op
__aafs_ns_mkdir_entries	assumes cleanup in caller
__aafs_ns_mkdir	Requires: @ns->lock held
entry_create_file	ry_create_file - create a file entry in the apparmor securityfs@fs_file: aa_sfs_entry to build an entry for (NOT NULL)@parent: the parent dentry in the securityfs* Use entry_remove_file to remove entries created with this fn.
entry_create_dir	ry_create_dir - recursively create a directory entry in the securityfs@fs_dir: aa_sfs_entry (and all child entries) to build (NOT NULL)@parent: the parent dentry in the securityfs* Use entry_remove_dir to remove entries created with this fn.
aa_mk_null_file
aa_create_aafs	aa_create_aafs - create the apparmor security filesystem* dentries created here are released by aa_destroy_aafs* Returns: error on failure
aa_audit_rule_free
aa_audit_rule_init
aa_setup_dfa_engine
d_namespace_path	d_namespace_path - lookup a name associated with a given path@path: path to lookup (NOT NULL)@buf: buffer to store path to (NOT NULL)@name: Returns - pointer for start of path name with in @buf (NOT NULL)@flags: flags controlling path
x_table_lookup	x_table_lookup - lookup an x transition name via transition table@profile: current profile (NOT NULL)@xindex: index into x transition table@name: returns: name tested to find label (NOT NULL) Returns: refcounted label, or NULL on failure (MAYBE NULL)
x_to_label	x_to_label - get target label for a given xindex@profile: current profile (NOT NULL)@bprm: binprm structure of transitioning task@name: name to lookup (NOT NULL)@xindex: index into x transition table*@lookupname: returns: name used in lookup if one
apparmor_bprm_set_creds	apparmor_bprm_set_creds - set the new creds on the bprm struct@bprm: binprm for the exec (NOT NULL) Returns: %0 or error on failure* TODO: once the other paths are done see if we can't refactor into a fn
aa_change_hat	aa_change_hat - change hat to/from subprofile@hats: vector of hat names to try changing into (MAYBE NULL if @count == 0)@count: number of hat names in @hats@token: magic value to validate the hat change@flags: flags affecting behavior of the change
aa_change_profile	aa_change_profile - perform a one-way profile transition@fqname: name of profile may include namespace (NOT NULL)@onexec: whether this transition is to take place immediately or at exec*@flags: flags affecting change behavior
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
unpack_dfa	pack_dfa - unpack a file rule dfa@e: serialized data extent information (NOT NULL) returns dfa or ERR_PTR or NULL if no dfa
unpack_profile	pack_profile - unpack a serialized profile@e: serialized data extent information (NOT NULL) NOTE: unpack profile sets audit struct if there is a failure
aa_unpack	aa_unpack - unpack packed binary profile(s) data loaded from user space@udata: user data copied to kmem (NOT NULL)@lh: list to place unpacked profiles in a aa_repl_ws@ns: Returns namespace profile is in if specified else NULL (NOT NULL) Unpack user
aa_setprocattr_changehat	aa_setprocattr_chagnehat - handle procattr interface to change_hat@args: args received from writing to /proc//attr/current (NOT NULL)@size: size of the args@flags: set of flags governing behavior Returns: %0 or error code if change_hat fails
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
apparmor_secctx_to_secid
aa_inherit_files	ased on selinux's flush_unauthorized_files
match_mnt_path_str	match_mnt_path_str - handle path matching for mount@profile: the confining profile@mntpath: for the mntpnt (NOT NULL)@buffer: buffer to be used to lookup mntpath@devnme: string for the devname/src_name (MAY BE NULL OR ERRPTR)*@type: string for the dev
aa_pivotroot
init_profile_hash
handle_policy_update
safesetid_init_securityfs
lockdown_write
integrity_fs_init
integrity_keyring_from_id
integrity_digsig_verify
integrity_modsig_verify
__integrity_init_keyring
integrity_add_key
request_asymmetric_key	Request an asymmetric key.
asymmetric_verify
ima_write_policy
ima_fs_init
ima_init_crypto
ima_alloc_tfm
ima_alloc_atfm
ima_calc_file_ahash
ima_calc_file_shash
ima_calc_file_hash	ma_calc_file_hash - calculate file hash* Asynchronous hash (ahash) allows using HW acceleration for calculating* a hash. ahash performance varies for different data sizes on different* crypto accelerators
ima_calc_field_array_hash
calc_buffer_ahash
calc_buffer_shash
ima_calc_boot_aggregate
ima_d_path	ma_d_path - return a pointer to the full pathname* Attempt to return a pointer to the full pathname for use in the* IMA measurement list, IMA audit records, and auditing logs
ima_read_modsig	ma_read_modsig - Read modsig from buf.* Return: 0 on success, error code otherwise.
ima_mok_init	Allocate the IMA blacklist keyring
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_init_hmac
evm_init_key	Get the key from the TPM for the SHA1-HMAC
evm_init_secfs
dentry_open
open_with_fake_path
filp_open	lp_open - open file and return file pointer@filename: path to open@flags: open flags as per the open(2) second argument@mode: mode for the new file if O_CREAT is set, else ignored This is the helper to open a file from kernelspace if you really
do_sys_open
vfs_dedupe_get_page	Read a page's worth of file data into the page cache.
vfs_dedupe_file_range_compare	Compare extents of two files to see if they are the same.* Caller must have locked both inodes to prevent write races.
alloc_empty_file	Find an unused file structure and return a pointer to it
alloc_empty_file_noaccount	Variant of alloc_empty_file() that doesn't check and modify nr_files.* Should not be used unless there's a very good reason to do so.
alloc_file	alloc_file - allocate and initialize a 'struct file'@path: the (dentry, vfsmount) pair for the new file@flags: O_... flags with which the new file will be opened*@fop: the 'struct file_operations' for the new file
alloc_file_pseudo
alloc_file_clone
do_emergency_remount_callback
vfs_get_super	vfs_get_super - Get a superblock with a search key set in s_fs_info.@fc: The filesystem context holding the parameters@keying: How to distinguish superblocks*@fill_super: Helper to initialise a new superblock
get_tree_bdev	get_tree_bdev - Get a superblock based on a single block device@fc: The filesystem context holding the parameters@fill_super: Helper to initialise a new superblock
mount_bdev
mount_nodev
reconfigure_single
mount_single
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.
alloc_chrdev_region	alloc_chrdev_region() - register a range of char device numbers@dev: output parameter for first assigned number@baseminor: first of the requested range of minor numbers@count: the number of minor numbers required@name: the name of the associated
__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
count	() counts the number of strings in array ARGV.
copy_strings	'copy_strings()' copies argument/environment strings from the old* processes's memory to the new process's stack. The call to get_user_pages()* ensures the destination page is created and not swapped out.
do_open_execat
open_exec
kernel_read_file_from_path
__do_execve_file	sys_execve() executes a new program.
create_pipe_files
init_pipe_fs
check_acl
follow_automount	Perform an automount* - return -EISDIR to tell follow_managed() to stop and return the path we* were called with.
__lookup_slow	Fast lookup failed, do it the slow way
walk_component
link_path_walk	Name resolution.* This is the basic name resolution function, turning a pathname into* the final dentry. We expect 'base' to be positive and a directory.* Returns 0 and nd will have valid dentry and mnt on success.
path_lookupat	Returns 0 and nd will be valid on success; Retuns error, otherwise.
filename_lookup
filename_parentat
kern_path_locked	does lookup, returns the object with parent locked
lookup_positive_unlocked	Like lookup_one_len_unlocked(), except that it yields ERR_PTR(-ENOENT)* on negatives
filename_mountpoint
lookup_open	Look up and maybe create and open the last component
do_tmpfile
path_openat
do_file_open_root
filename_create
do_mknodat
do_mkdirat
do_rmdir
do_unlinkat	Make sure that the actual truncation of the file will occur outside its* directory's i_mutex. Truncate can take a long time if there is a lot of* writeout happening, and we don't want to prevent access to the directory* while waiting on the I/O.
do_symlinkat
do_linkat	Hardlinks are often used in delicate situations. We avoid* security-related surprises by not following symlinks on the* newname. --KAB* We don't follow them on the oldname either to be compatible* with linux 2.0, and to avoid hard-linking to directories
do_renameat2
readlink_copy
vfs_readlink	vfs_readlink - copy symlink body into userspace buffer@dentry: dentry on which to get symbolic link@buffer: user memory pointer@buflen: size of buffer Does not touch atime. That's up to the caller if necessary* Does not call security hook.
page_get_link	get the link contents into pagecache
ioctl_file_dedupe_range
__d_obtain_alias
d_add_ci	d_add_ci - lookup or allocate new dentry with case-exact name@inode: the inode case-insensitive lookup has found@dentry: the negative dentry that was passed to the parent's lookup func*@name: the case-exact name to be associated with the returned
d_splice_alias	splice a disconnected dentry into the tree if one exists
inode_insert5	de_insert5 - obtain an inode from a mounted file system@inode: pre-allocated inode to use for insert to cache@hashval: hash value (usually inode number) to get@test: callback used for comparisons between inodes@set: callback used to initialize a new
iget_locked	obtain an inode from a mounted file system
ilookup5_nowait	lookup5_nowait - search for an inode in the inode cache@sb: super block of file system to search@hashval: hash value (usually inode number) to search for@test: callback used for comparisons between inodes@data: opaque data pointer to pass to @test
ilookup	search for an inode in the inode cache
vfs_kern_mount
mnt_clone_internal
do_umount_root
copy_tree
collect_mounts	Caller should check returned pointer for errors
clone_private_mount	lone_private_mount - create a private clone of a path* This creates a new vfsmount, which will be the clone of @path. The new will* not be attached anywhere in the namespace and will be private (i.e. changes
attach_recursive_mnt	@source_mnt : mount tree to be attached@nd : place the mount tree @source_mnt is attached@parent_nd : if non-null, detach the source_mnt from its parent and* store the parent mount and mountpoint dentry
lock_mount
__do_loopback
do_loopback	do loopback mount.
open_detached_copy
SYSCALL_DEFINE3
do_remount	hange filesystem flags. dir should be a physical root of filesystem.* If you've mounted a non-root directory somewhere and want to do remount* on it - tough luck.
do_move_mount
do_add_mount	add a mount into a namespace's mount tree
do_new_mount_fc	Create a new mount using a superblock configuration and request it* be added to the namespace tree.
do_new_mount	reate a new mount for userspace and request it to be added into the* namespace's tree
copy_mnt_ns
mount_subtree
SYSCALL_DEFINE5
SYSCALL_DEFINE3	Create a kernel mount representation for a new, prepared superblock* (specified by fs_fd) and attach to an open_tree-like file descriptor.
SYSCALL_DEFINE2	pivot_root Semantics:* Moves the root file system of the current process to the directory put_old,* makes new_root as the new root file system of the current process, and sets* root/cwd of all processes which had them on the current root to new_root
init_mount_tree
kern_mount
traverse
seq_read	seq_read - ->read() method for sequential files.@file: the file to read from@buf: the buffer to read to@size: the maximum number of bytes to read@ppos: the current position in the file* Ready-made ->f_op->read()
seq_path	seq_path - seq_file interface to print a pathname@m: the seq_file handle@path: the struct path to print@esc: set of characters to escape in the output return the absolute path of 'path', as represented by the* dentry / mnt pair in the path parameter.
seq_path_root	Same as seq_path, but relative to supplied root.
seq_dentry	rns the path of the 'dentry' from the root of its filesystem.
__vfs_setxattr
vfs_getxattr_alloc	vfs_getxattr_alloc - allocate memory, if necessary, before calling getxattr* Allocate memory, if not already allocated, or re-allocate correct size,* before retrieving the extended attribute.
__vfs_getxattr
__vfs_removexattr
simple_pin_fs
propagate_one
dentry_path
open_related_ns
nsfs_init
legacy_get_tree	Get a mountable root with the legacy mount command.
fs_lookup_param	s_lookup_param - Look up a path referred to by a parameter@fc: The filesystem context to log errors through.@param: The parameter.@want_bdev: T if want a blockdev@_path: The result of the lookup
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
SYSCALL_DEFINE3	Pick a superblock into a context for reconfiguration.
bdev_cache_init
blkdev_get	lkdev_get - open a block device@bdev: block_device to open@mode: FMODE_* mask@holder: exclusive holder identifier Open @bdev with @mode. If @mode includes %FMODE_EXCL, @bdev is* open with exclusive access. Specifying %FMODE_EXCL with %NULL
blkdev_get_by_path	lkdev_get_by_path - open a block device by name@path: path to the block device to open@mode: FMODE_* mask@holder: exclusive holder identifier Open the blockdevice described by the device file at @path. @mode* and @holder are identical to blkdev_get().
do_direct_IO	Walk the user pages, and the file, mapping blocks to disk and generating* a sequence of (page,offset,len,block) mappings. These mappings are injected* into submit_page_section(), which takes care of the next stage of submission
dnotify_init
inotify_read
inotify_new_group
do_inotify_init	y syscalls
create_fd
fanotify_read
fanotify_add_mark
SYSCALL_DEFINE2	anotify syscalls
do_epoll_create	Open an eventpoll file descriptor.
anon_inode_getfile	anon_inode_getfile - creates a new file instance by hooking it up to an* anonymous inode, and a dentry that describe the "class"* of the file@name: [in] name of the "class" of the new file@fops: [in] file operations for the new file*@priv: [in] private
anon_inode_getfd	anon_inode_getfd - creates a new file instance by hooking it up to an* anonymous inode, and a dentry that describe the "class"* of the file@name: [in] name of the "class" of the new file@fops: [in] file operations for the new file*@priv: [in] private
anon_inode_init
aio_private_file
aio_setup	aio_setup* Creates the slab caches used by the aio routines, panic on* failure as this is done early during the boot sequence.
aio_setup_ring
SYSCALL_DEFINE2	sys_io_setup:* Create an aio_context capable of receiving at least nr_events
COMPAT_SYSCALL_DEFINE2
__io_submit_one
io_sq_offload_start
io_eventfd_register
io_uring_mmap
io_uring_get_fd	Allocate an anonymous fd, this is what constitutes the application* visible backing of an io_uring instance. The application mmaps this* fd to gain access to the SQ/CQ ring details. If UNIX sockets are enabled,
create_io_worker
io_wq_create
fscrypt_init_hkdf	Compute HKDF-Extract using the given master key as the input keying material,* and prepare an HMAC transform object keyed by the resulting pseudorandom key.* Afterwards, the keyed HMAC transform object can be used for HKDF-Expand many
search_fscrypt_keyring	Search ->s_master_keys or ->mk_users
allocate_filesystem_keyring	Create ->s_master_keys if needed. Synchronized by fscrypt_add_key_mutex.
allocate_master_key_users_keyring
add_master_key_user	Give the current user a "key" in ->mk_users. This charges the user's quota* and marks the master key as added by the current user, so that it cannot be* removed by another user with the key. Either the master key's key->sem must
remove_master_key_user	Remove the current user's "key" from ->mk_users.* The master key's key->sem must be held for write.* Returns 0 if removed, -ENOKEY if not found, or another -errno code.
add_new_master_key	Allocate a new fscrypt_master_key which contains the given secret, set it as* the payload of a new 'struct key' of type fscrypt, and link the 'struct key'* into the given keyring. Synchronized by fscrypt_add_key_mutex.
add_existing_master_key
add_master_key
fscrypt_verify_key_added	Verify that the current user has added a master key with the given identifier* (returns -ENOKEY if not)
do_remove_key	Try to remove an fscrypt master encryption key
fscrypt_ioctl_get_key_status	Retrieve the status of an fscrypt master encryption key
fscrypt_allocate_skcipher	Create a symmetric cipher object for the given encryption mode and key
fscrypt_set_derived_key	Given the per-file key, set up the file's crypto transform object
setup_per_mode_key
setup_file_encryption_key	Find the master key, then set up the inode's actual encryption key.* If the master key is found in the filesystem-level keyring, then the* corresponding 'struct key' is returned in master_key_ret with ->mk_secret_sem read-locked
fscrypt_get_encryption_info
derive_key_aes	v1 key derivation function
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.
fscrypt_get_direct_key	Prepare to encrypt directly using the master key in the given mode
setup_v1_file_key_direct	v1 policy, DIRECT_KEY: use the master key directly
fscrypt_setup_v1_file_key_via_subscribed_keyrings
build_merkle_tree_level
enable_verity
fsverity_get_hash_alg	sverity_get_hash_alg() - validate and prepare a hash algorithm@inode: optional inode for logging purposes@num: the hash algorithm number* Get the struct fsverity_hash_alg for the given hash algorithm number, and
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
ensure_verity_info	Ensure the inode has an ->i_verity_info
verify_page	Verify a single data page against the file's Merkle tree
fsverity_init_signature
__break_lease	revoke all outstanding leases on file
do_fcntl_add_lease
SYSCALL_DEFINE2	sys_flock: - flock() system call.@fd: the file descriptor to lock.@cmd: the type of lock to apply.* Apply a %FL_FLOCK style lock to an open file descriptor.* The @cmd can be one of:* - %LOCK_SH -- a shared lock.* - %LOCK_EX -- an exclusive lock.
COMPAT_SYSCALL_DEFINE5
load_em86
load_misc_binary	he loader itself
bm_register_write	/register
load_script
load_elf_binary
load_elf_fdpic_binary	load an fdpic binary into various bits of memory
get_acl
posix_acl_create
posix_acl_xattr_get
posix_acl_xattr_set
cn_print_exe_file
do_coredump
do_handle_to_path
do_handle_open
__dquot_initialize
dquot_transfer	Wrapper for transferring ownership of an inode for uid/gid only* Called from FSXXX_setattr()
dquot_quota_on_mount	This function is used when filesystem needs to initialize quotas* during mount time.
dquot_get_dqblk
dquot_get_next_dqblk
dquot_set_dqblk
quota_quotaon
quotactl_block	look up a superblock on which quota ops will be performed* - use the name of a block device to find the superblock thereon
kernel_quotactl	This is the system call interface. This communicates with* the user-level programs. Currently this only supports diskquota* calls. Maybe we need to add the process quotas etc. in the future,* but we probably should use rlimits for that.
do_lookup_dcookie	And here is where the userspace process can look up the cookie value* to retrieve the path.
PTR_ERR_OR_ZERO

Function report