blob: 37eaccdf3054e13d60cd83cf5c6cb9869731aec1 [file] [log] [blame]
Andrew Morton16d69262008-07-25 19:44:36 -07001#include <linux/mm.h>
Matt Mackall30992c92006-01-08 01:01:43 -08002#include <linux/slab.h>
3#include <linux/string.h>
4#include <linux/module.h>
Davi Arnaut96840aa2006-03-24 03:18:42 -08005#include <linux/err.h>
Adrian Bunk3b8f14b2008-07-26 15:22:28 -07006#include <linux/sched.h>
Davi Arnaut96840aa2006-03-24 03:18:42 -08007#include <asm/uaccess.h>
Matt Mackall30992c92006-01-08 01:01:43 -08008
9/**
Matt Mackall30992c92006-01-08 01:01:43 -080010 * kstrdup - allocate space for and copy an existing string
Matt Mackall30992c92006-01-08 01:01:43 -080011 * @s: the string to duplicate
12 * @gfp: the GFP mask used in the kmalloc() call when allocating memory
13 */
14char *kstrdup(const char *s, gfp_t gfp)
15{
16 size_t len;
17 char *buf;
18
19 if (!s)
20 return NULL;
21
22 len = strlen(s) + 1;
Christoph Hellwig1d2c8ee2006-10-04 02:15:25 -070023 buf = kmalloc_track_caller(len, gfp);
Matt Mackall30992c92006-01-08 01:01:43 -080024 if (buf)
25 memcpy(buf, s, len);
26 return buf;
27}
28EXPORT_SYMBOL(kstrdup);
Davi Arnaut96840aa2006-03-24 03:18:42 -080029
Alexey Dobriyan1a2f67b2006-09-30 23:27:20 -070030/**
Jeremy Fitzhardinge1e66df32007-07-17 18:37:02 -070031 * kstrndup - allocate space for and copy an existing string
32 * @s: the string to duplicate
33 * @max: read at most @max chars from @s
34 * @gfp: the GFP mask used in the kmalloc() call when allocating memory
35 */
36char *kstrndup(const char *s, size_t max, gfp_t gfp)
37{
38 size_t len;
39 char *buf;
40
41 if (!s)
42 return NULL;
43
44 len = strnlen(s, max);
45 buf = kmalloc_track_caller(len+1, gfp);
46 if (buf) {
47 memcpy(buf, s, len);
48 buf[len] = '\0';
49 }
50 return buf;
51}
52EXPORT_SYMBOL(kstrndup);
53
54/**
Alexey Dobriyan1a2f67b2006-09-30 23:27:20 -070055 * kmemdup - duplicate region of memory
56 *
57 * @src: memory region to duplicate
58 * @len: memory region length
59 * @gfp: GFP mask to use
60 */
61void *kmemdup(const void *src, size_t len, gfp_t gfp)
62{
63 void *p;
64
Christoph Hellwig1d2c8ee2006-10-04 02:15:25 -070065 p = kmalloc_track_caller(len, gfp);
Alexey Dobriyan1a2f67b2006-09-30 23:27:20 -070066 if (p)
67 memcpy(p, src, len);
68 return p;
69}
70EXPORT_SYMBOL(kmemdup);
71
Christoph Lameteref2ad802007-07-17 04:03:21 -070072/**
Pekka Enberg93bc4e82008-07-26 17:49:33 -070073 * __krealloc - like krealloc() but don't free @p.
74 * @p: object to reallocate memory for.
75 * @new_size: how many bytes of memory are required.
76 * @flags: the type of memory to allocate.
77 *
78 * This function is like krealloc() except it never frees the originally
79 * allocated buffer. Use this if you don't want to free the buffer immediately
80 * like, for example, with RCU.
81 */
82void *__krealloc(const void *p, size_t new_size, gfp_t flags)
83{
84 void *ret;
85 size_t ks = 0;
86
87 if (unlikely(!new_size))
88 return ZERO_SIZE_PTR;
89
90 if (p)
91 ks = ksize(p);
92
93 if (ks >= new_size)
94 return (void *)p;
95
96 ret = kmalloc_track_caller(new_size, flags);
97 if (ret && p)
98 memcpy(ret, p, ks);
99
100 return ret;
101}
102EXPORT_SYMBOL(__krealloc);
103
104/**
Christoph Lameteref2ad802007-07-17 04:03:21 -0700105 * krealloc - reallocate memory. The contents will remain unchanged.
106 * @p: object to reallocate memory for.
107 * @new_size: how many bytes of memory are required.
108 * @flags: the type of memory to allocate.
109 *
110 * The contents of the object pointed to are preserved up to the
111 * lesser of the new and old sizes. If @p is %NULL, krealloc()
112 * behaves exactly like kmalloc(). If @size is 0 and @p is not a
113 * %NULL pointer, the object pointed to is freed.
114 */
115void *krealloc(const void *p, size_t new_size, gfp_t flags)
116{
117 void *ret;
Christoph Lameteref2ad802007-07-17 04:03:21 -0700118
119 if (unlikely(!new_size)) {
120 kfree(p);
Christoph Lameter6cb8f912007-07-17 04:03:22 -0700121 return ZERO_SIZE_PTR;
Christoph Lameteref2ad802007-07-17 04:03:21 -0700122 }
123
Pekka Enberg93bc4e82008-07-26 17:49:33 -0700124 ret = __krealloc(p, new_size, flags);
125 if (ret && p != ret)
Christoph Lameteref2ad802007-07-17 04:03:21 -0700126 kfree(p);
Pekka Enberg93bc4e82008-07-26 17:49:33 -0700127
Christoph Lameteref2ad802007-07-17 04:03:21 -0700128 return ret;
129}
130EXPORT_SYMBOL(krealloc);
131
Johannes Weiner3ef0e5b2009-02-20 15:38:41 -0800132/**
133 * kzfree - like kfree but zero memory
134 * @p: object to free memory of
135 *
136 * The memory of the object @p points to is zeroed before freed.
137 * If @p is %NULL, kzfree() does nothing.
138 */
139void kzfree(const void *p)
140{
141 size_t ks;
142 void *mem = (void *)p;
143
144 if (unlikely(ZERO_OR_NULL_PTR(mem)))
145 return;
146 ks = ksize(mem);
147 memset(mem, 0, ks);
148 kfree(mem);
149}
150EXPORT_SYMBOL(kzfree);
151
Davi Arnaut96840aa2006-03-24 03:18:42 -0800152/*
153 * strndup_user - duplicate an existing string from user space
Davi Arnaut96840aa2006-03-24 03:18:42 -0800154 * @s: The string to duplicate
155 * @n: Maximum number of bytes to copy, including the trailing NUL.
156 */
157char *strndup_user(const char __user *s, long n)
158{
159 char *p;
160 long length;
161
162 length = strnlen_user(s, n);
163
164 if (!length)
165 return ERR_PTR(-EFAULT);
166
167 if (length > n)
168 return ERR_PTR(-EINVAL);
169
170 p = kmalloc(length, GFP_KERNEL);
171
172 if (!p)
173 return ERR_PTR(-ENOMEM);
174
175 if (copy_from_user(p, s, length)) {
176 kfree(p);
177 return ERR_PTR(-EFAULT);
178 }
179
180 p[length - 1] = '\0';
181
182 return p;
183}
184EXPORT_SYMBOL(strndup_user);
Andrew Morton16d69262008-07-25 19:44:36 -0700185
186#ifndef HAVE_ARCH_PICK_MMAP_LAYOUT
187void arch_pick_mmap_layout(struct mm_struct *mm)
188{
189 mm->mmap_base = TASK_UNMAPPED_BASE;
190 mm->get_unmapped_area = arch_get_unmapped_area;
191 mm->unmap_area = arch_unmap_area;
192}
193#endif
Rusty Russell912985d2008-08-12 17:52:52 -0500194
195int __attribute__((weak)) get_user_pages_fast(unsigned long start,
196 int nr_pages, int write, struct page **pages)
197{
198 struct mm_struct *mm = current->mm;
199 int ret;
200
201 down_read(&mm->mmap_sem);
202 ret = get_user_pages(current, mm, start, nr_pages,
203 write, 0, pages, NULL);
204 up_read(&mm->mmap_sem);
205
206 return ret;
207}
208EXPORT_SYMBOL_GPL(get_user_pages_fast);