hostap: pad the skb->cb usage in lieu of a proper fix
[linux-2.6/sactl.git] / mm / util.c
blobcb00b748ce47886446975d96466c2154f4d52fa3
1 #include <linux/mm.h>
2 #include <linux/slab.h>
3 #include <linux/string.h>
4 #include <linux/module.h>
5 #include <linux/err.h>
6 #include <linux/sched.h>
7 #include <asm/uaccess.h>
9 /**
10 * kstrdup - allocate space for and copy an existing string
11 * @s: the string to duplicate
12 * @gfp: the GFP mask used in the kmalloc() call when allocating memory
14 char *kstrdup(const char *s, gfp_t gfp)
16 size_t len;
17 char *buf;
19 if (!s)
20 return NULL;
22 len = strlen(s) + 1;
23 buf = kmalloc_track_caller(len, gfp);
24 if (buf)
25 memcpy(buf, s, len);
26 return buf;
28 EXPORT_SYMBOL(kstrdup);
30 /**
31 * 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
36 char *kstrndup(const char *s, size_t max, gfp_t gfp)
38 size_t len;
39 char *buf;
41 if (!s)
42 return NULL;
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';
50 return buf;
52 EXPORT_SYMBOL(kstrndup);
54 /**
55 * kmemdup - duplicate region of memory
57 * @src: memory region to duplicate
58 * @len: memory region length
59 * @gfp: GFP mask to use
61 void *kmemdup(const void *src, size_t len, gfp_t gfp)
63 void *p;
65 p = kmalloc_track_caller(len, gfp);
66 if (p)
67 memcpy(p, src, len);
68 return p;
70 EXPORT_SYMBOL(kmemdup);
72 /**
73 * __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.
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.
82 void *__krealloc(const void *p, size_t new_size, gfp_t flags)
84 void *ret;
85 size_t ks = 0;
87 if (unlikely(!new_size))
88 return ZERO_SIZE_PTR;
90 if (p)
91 ks = ksize(p);
93 if (ks >= new_size)
94 return (void *)p;
96 ret = kmalloc_track_caller(new_size, flags);
97 if (ret && p)
98 memcpy(ret, p, ks);
100 return ret;
102 EXPORT_SYMBOL(__krealloc);
105 * 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.
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.
115 void *krealloc(const void *p, size_t new_size, gfp_t flags)
117 void *ret;
119 if (unlikely(!new_size)) {
120 kfree(p);
121 return ZERO_SIZE_PTR;
124 ret = __krealloc(p, new_size, flags);
125 if (ret && p != ret)
126 kfree(p);
128 return ret;
130 EXPORT_SYMBOL(krealloc);
133 * strndup_user - duplicate an existing string from user space
134 * @s: The string to duplicate
135 * @n: Maximum number of bytes to copy, including the trailing NUL.
137 char *strndup_user(const char __user *s, long n)
139 char *p;
140 long length;
142 length = strnlen_user(s, n);
144 if (!length)
145 return ERR_PTR(-EFAULT);
147 if (length > n)
148 return ERR_PTR(-EINVAL);
150 p = kmalloc(length, GFP_KERNEL);
152 if (!p)
153 return ERR_PTR(-ENOMEM);
155 if (copy_from_user(p, s, length)) {
156 kfree(p);
157 return ERR_PTR(-EFAULT);
160 p[length - 1] = '\0';
162 return p;
164 EXPORT_SYMBOL(strndup_user);
166 #ifndef HAVE_ARCH_PICK_MMAP_LAYOUT
167 void arch_pick_mmap_layout(struct mm_struct *mm)
169 mm->mmap_base = TASK_UNMAPPED_BASE;
170 mm->get_unmapped_area = arch_get_unmapped_area;
171 mm->unmap_area = arch_unmap_area;
173 #endif
175 int __attribute__((weak)) get_user_pages_fast(unsigned long start,
176 int nr_pages, int write, struct page **pages)
178 struct mm_struct *mm = current->mm;
179 int ret;
181 down_read(&mm->mmap_sem);
182 ret = get_user_pages(current, mm, start, nr_pages,
183 write, 0, pages, NULL);
184 up_read(&mm->mmap_sem);
186 return ret;
188 EXPORT_SYMBOL_GPL(get_user_pages_fast);