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.
49     have a reasonable fallback should be using ``GFP_NOWARN``.
51     will be stressed unless allocation succeeds, you may use ``GFP_ATOMIC``.
52   * Untrusted allocations triggered from userspace should be a subject
55     allocations that should be accounted.
61     will be directly accessible by the kernel and implies that the
65     but it is not required to be directly accessible by the kernel. An
66     example may be a hardware allocation that maps data directly into
70     must be directly accessible by the kernel.
95     doesn't kick the background reclaim. Should be used carefully because it
102     the low watermark. Can be used from either atomic contexts or when
114     that behavior so failures have to be checked properly by callers
125     won't be triggered.
129     This might be really dangerous especially for larger orders.
135 from the kmalloc() family. And, to be on the safe side it's best to use
139 be used to safely calculate object sizes without overflowing.
141 The maximal size of a chunk that can be allocated with `kmalloc` is
148 alignment is also guaranteed to be at least the respective size.
150 Chunks allocated with kmalloc() can be resized with krealloc(). Similarly
161 will be retried with `vmalloc`. There are restrictions on which GFP
162 flags can be used with `kvmalloc`; please see kvmalloc_node() reference
167 cache allocator. The cache should be set up with kmem_cache_create() or
168 kmem_cache_create_usercopy() before it can be used. The second function
169 should be used if a part of the cache might be copied to the userspace.
173 When the allocated memory is no longer needed it must be freed.
175 Objects allocated by `kmalloc` can be freed by `kfree` or `kvfree`. Objects
176 allocated by `kmem_cache_alloc` can be freed with `kmem_cache_free`, `kfree`
177 or `kvfree`, where the latter two might be more convenient thanks to not
182 Memory allocated by `vmalloc` can be freed with `vfree` or `kvfree`.
183 Memory allocated by `kvmalloc` can be freed with `kvfree`.
184 Caches created by `kmem_cache_create` should be freed with