Caller| Name | Describe |
|---|
| __radix_tree_preload | Load up this CPU's radix_tree_node buffer with sufficient objects to* ensure that the addition of a single element in the tree cannot fail |
| radix_tree_cpu_dead | |
| xas_destroy | xas_destroy() - Free any resources allocated during the XArray operation.*@xas: XArray operation state.* This function is now internal-only. |
| kmem_cache_oob | |
| memcg_accounted_kmem_cache | |
| kmem_cache_double_free | |
| kmem_cache_invalid_free | |
| do_kmem_cache_size | Test kmem_cache with given parameters: |
| do_kmem_cache_rcu_persistent | Check that the data written to an RCU-allocated object survives* reallocation. |
| btree_free | |
| free_obj_work | |
| debug_objects_replace_static_objects | Convert the statically allocated objects to dynamic ones: |
| lc_create | lc_create - prepares to track objects in an active set*@name: descriptive name only used in lc_seq_printf_stats and lc_seq_dump_details*@max_pending_changes: maximum changes to accumulate until a transaction is required*@e_count: number of elements |
| lc_free_by_index | |
| vm_area_free | |
| free_signal_struct | |
| __cleanup_sighand | |
| free_user | IRQs are disabled and uidhash_lock is held upon function entry.* IRQ state (as stored in flags) is restored and uidhash_lock released* upon function exit. |
| alloc_uid | |
| __sigqueue_free | |
| rcu_free_pwq | |
| put_pid | |
| alloc_pid | |
| 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. |
| free_nsproxy | |
| put_cred_rcu | The RCU callback to actually dispose of a set of credentials |
| alloc_posix_timer | |
| k_itimer_rcu_free | |
| clone_uts_ns | Clone a new ns copying an original utsname, setting refcount to 1*@old_ns: namespace to clone* Return ERR_PTR(-ENOMEM) on error (failure to allocate), new ns otherwise |
| free_uts_ns | |
| create_user_ns | Create a new user namespace, deriving the creator from the user in the* passed credentials, and replacing that user with the new root user for the* new namespace.* This is called by copy_creds(), which will finish setting the target task's* credentials. |
| free_user_ns | |
| create_pid_namespace | |
| delayed_free_pidns | |
| audit_buffer_free | |
| audit_tree_destroy_watch | |
| taskstats_tgid_alloc | |
| trace_destroy_fields | |
| remove_event_file_dir | |
| __kmem_cache_free_bulk | |
| create_cache | |
| slab_kmem_cache_release | |
| __put_nommu_region | lease a reference to a region* - the caller must hold the region semaphore for writing, which this releases* - the region may not have been added to the tree yet, in which case vm_top* will equal vm_start |
| do_mmap | handle mapping creation for uClinux |
| split_vma | split a vma into two pieces at address 'addr', a new vma is allocated either* for the first part or the tail. |
| ptlock_free | |
| anon_vma_free | |
| anon_vma_chain_free | |
| merge_or_add_vmap_area | Merge de-allocated chunk of VA memory with previous* and next free blocks. If coalesce is not done a new* free area is inserted. If VA has been merged, it is* freed. |
| adjust_va_to_fit_type | |
| alloc_vmap_area | Allocate a region of KVA of the specified size and alignment, within the* vstart and vend. |
| zswap_entry_cache_free | |
| __mpol_put | Slow path of a mpol destructor. |
| sp_free | |
| sp_alloc | |
| shared_policy_replace | Replace a policy range. |
| free_rmap_item | |
| free_stable_node | |
| free_mm_slot | |
| slab_destroy | slab_destroy - destroy and release all objects in a slab*@cachep: cache pointer being destroyed*@page: page pointer being destroyed* Destroy all the objs in a slab page, and release the mem back to the system. |
| free_kmem_cache_nodes | |
| slab_mem_offline_callback | |
| free_mm_slot | |
| mem_pool_free | Return the object to either the slab allocator or the memory pool. |
| free_object_rcu | RCU callback to free a kmemleak_object. |
| create_object | Create the metadata (struct kmemleak_object) corresponding to an allocated* memory block and add it to the object_list and object_tree_root. |
| add_scan_area | Add a scanning area to the object. If at least one such area is added,* kmemleak will only scan these ranges rather than the whole memory block. |
| cache_free_handle | |
| cache_free_zspage | |
| free_handle | |
| __release_z3fold_page | |
| blk_alloc_queue_node | lk_alloc_queue_node - allocate a request queue*@gfp_mask: memory allocation flags*@node_id: NUMA node to allocate memory from |
| blk_free_queue_rcu | |
| icq_free_icq_rcu | |
| ioc_release_fn | Slow path for ioc release in put_io_context(). Performs double-lock* dancing to unlink all icq's and then frees ioc. |
| put_io_context | put_io_context - put a reference of io_context*@ioc: io_context to put* Decrement reference count of @ioc and release it if the count reaches* zero. |
| create_task_io_context | |
| ioc_create_icq | _create_icq - create and link io_cq*@ioc: io_context of interest*@q: request_queue of interest*@gfp_mask: allocation mask* Make sure io_cq linking @ioc and @q exists |
| bfq_put_queue | Task holds one reference to the queue, dropped when task exits. Each rq* in-flight on this queue also holds a reference, dropped when rq is freed.* Scheduler lock must be held here. Recall not to use bfqq after calling* this function on it. |
| 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. |
| inode_free_by_rcu | |
| security_file_free | |
| avc_xperms_decision_free | |
| avc_xperms_free | |
| avc_node_free | |
| avc_node_kill | |
| smack_cred_free | smack_cred_free - "free" task-level security credentials*@cred: the credentials in question |
| iint_free | |
| fasync_free_rcu | |
| fasync_free | NOTE! This can be used only for unused fasync entries:* entries that actually got inserted on the fasync list* need to be released by rcu - see fasync_remove_entry. |
| __d_free | |
| __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_inode_nonrcu | |
| dup_fd | Allocate a new files structure and copy contents from the* passed in files structure.* errorp will be valid only when the returned files_struct is NULL. |
| put_files_struct | |
| alloc_vfsmnt | |
| free_vfsmnt | |
| seq_release | seq_release - free the structures associated with sequential file.*@file: file in question*@inode: its inode* Frees the structures associated with sequential file; can be used* as ->f_op->release() if you don't have private data to destroy. |
| free_fs_struct | |
| free_buffer_head | |
| bdev_free_inode | |
| dio_complete | dio_complete() - called when all DIO BIO I/O has been completed* This drops i_dio_count, lets interested parties know that a DIO operation* has completed, and calculates the resulting return code for the operation |
| do_blockdev_direct_IO | This is a library function for use by filesystem drivers |
| fsnotify_connector_destroy_workfn | |
| fsnotify_attach_connector_to_object | |
| dnotify_handle_event | Mains fsnotify call where events are delivered to dnotify.* Find the dnotify mark on the relevant inode, run the list of dnotify structs* on that mark and determine which of them has expressed interest in receiving* events of this type |
| dnotify_free_mark | |
| dnotify_flush | Called every time a file is closed. Looks first for a dnotify mark on the* inode. If one is found run all of the ->dn structures attached to that* mark for one relevant to this process closing the file and remove that* dnotify_struct |
| fcntl_dirnotify | When a process calls fcntl to attach a dnotify watch to a directory it ends* up here. Allocate both a mark for fsnotify to add and a dnotify_struct to be* attached to the fsnotify_mark. |
| inotify_free_mark | ding dong the mark is dead |
| fanotify_free_event | |
| fanotify_free_mark | |
| ep_unregister_pollwait | This function unregisters poll callbacks from the associated file* descriptor. Must be called with "mtx" held (or "epmutex" if called from* ep_free). |
| epi_rcu_free | |
| ep_insert | Must be called with "mtx" held. |
| userfaultfd_ctx_put | serfaultfd_ctx_put - Releases a reference to the internal userfaultfd* context.*@ctx: [in] Pointer to userfaultfd context.* The userfaultfd context reference must have been previously acquired either* with userfaultfd_ctx_get() or userfaultfd_ctx_fdget(). |
| SYSCALL_DEFINE1 | |
| free_ioctx | _ioctx() should be RCU delayed to synchronize against the RCU* protected lookup_ioctx() and also needs process context to call* aio_free_ring(). Use rcu_work. |
| ioctx_alloc | x_alloc* Allocates and initializes an ioctx. Returns an ERR_PTR if it failed. |
| aio_get_req | aio_get_req* Allocate a slot for an aio request.* Returns NULL if no requests are free.* The refcount is initialized to 2 - one for the async op completion,* one for the synchronous code that does this. |
| iocb_destroy | |
| io_ring_ctx_alloc | |
| __io_free_req | |
| io_ring_ctx_free | |
| put_crypt_info | |
| fsverity_free_info | |
| locks_get_lock_context | |
| locks_free_lock_context | |
| locks_free_lock | Free a lock which is not in use. |
| mb_cache_entry_create | mb_cache_entry_create - create entry in cache*@cache - cache where the entry should be created*@mask - gfp mask with which the entry should be allocated*@key - key of the entry*@value - value of the entry*@reusable - is the entry reusable by others? |
| __mb_cache_entry_free | |
| dquot_destroy | |
| free_dcookie | |
| reqsk_alloc | |
| __reqsk_free | |
| mempool_free_slab | |