blob: 9341ca77bd88240741afbcbabed9019f247a7531 [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
Davi Arnaut96840aa2006-03-24 03:18:42 -0800132/*
133 * strndup_user - duplicate an existing string from user space
Davi Arnaut96840aa2006-03-24 03:18:42 -0800134 * @s: The string to duplicate
135 * @n: Maximum number of bytes to copy, including the trailing NUL.
136 */
137char *strndup_user(const char __user *s, long n)
138{
139 char *p;
140 long length;
141
142 length = strnlen_user(s, n);
143
144 if (!length)
145 return ERR_PTR(-EFAULT);
146
147 if (length > n)
148 return ERR_PTR(-EINVAL);
149
150 p = kmalloc(length, GFP_KERNEL);
151
152 if (!p)
153 return ERR_PTR(-ENOMEM);
154
155 if (copy_from_user(p, s, length)) {
156 kfree(p);
157 return ERR_PTR(-EFAULT);
158 }
159
160 p[length - 1] = '\0';
161
162 return p;
163}
164EXPORT_SYMBOL(strndup_user);
Andrew Morton16d69262008-07-25 19:44:36 -0700165
166#ifndef HAVE_ARCH_PICK_MMAP_LAYOUT
167void arch_pick_mmap_layout(struct mm_struct *mm)
168{
169 mm->mmap_base = TASK_UNMAPPED_BASE;
170 mm->get_unmapped_area = arch_get_unmapped_area;
171 mm->unmap_area = arch_unmap_area;
172}
173#endif