Lines Matching full:be

15 memory should be allocated. The GFP acronym stands for "get free
27 flags must be used.
33 zones can be used, how hard the allocator should try to find free
34 memory, whether the memory can be accessed by the userspace etc. The
43     direct reclaim may be triggered under memory pressure; the calling
44     context must be allowed to sleep.
52     will be stressed unless allocation succeeds, you may use ``GFP_ATOMIC``.
53   * Untrusted allocations triggered from userspace should be a subject
56     allocations that should be accounted.
62     will be directly accessible by the kernel and implies that the
66     but it is not required to be directly accessible by the kernel. An
67     example may be a hardware allocation that maps data directly into
71     must be directly accessible by the kernel.
96     doesn't kick the background reclaim. Should be used carefully because it
103     the low watermark. Can be used from either atomic contexts or when
115     that behavior so failures have to be checked properly by callers
126     won't be triggered.
130     This might be really dangerous especially for larger orders.
136 from the kmalloc() family. And, to be on the safe side it's best to use
140 be used to safely calculate object sizes without overflowing.
142 The maximal size of a chunk that can be allocated with `kmalloc` is
149 alignment is also guaranteed to be at least the respective size. For other
150 sizes, the alignment is guaranteed to be at least the largest power-of-two
153 Chunks allocated with kmalloc() can be resized with krealloc(). Similarly
164 will be retried with `vmalloc`. There are restrictions on which GFP
165 flags can be used with `kvmalloc`; please see kvmalloc_node() reference
170 cache allocator. The cache should be set up with kmem_cache_create() or
171 kmem_cache_create_usercopy() before it can be used. The second function
172 should be used if a part of the cache might be copied to the userspace.
176 When the allocated memory is no longer needed it must be freed.
178 Objects allocated by `kmalloc` can be freed by `kfree` or `kvfree`. Objects
179 allocated by `kmem_cache_alloc` can be freed with `kmem_cache_free`, `kfree`
180 or `kvfree`, where the latter two might be more convenient thanks to not
185 Memory allocated by `vmalloc` can be freed with `vfree` or `kvfree`.
186 Memory allocated by `kvmalloc` can be freed with `kvfree`.
187 Caches created by `kmem_cache_create` should be freed with