[linux-2.6-block.git] / mm / util.c

#include <linux/slab.h>
#include <linux/string.h>
#include <linux/module.h>
#include <linux/err.h>
#include <asm/uaccess.h>

/**
 * __kzalloc - allocate memory. The memory is set to zero.
 * @size: how many bytes of memory are required.
 * @flags: the type of memory to allocate.
 */
void *__kzalloc(size_t size, gfp_t flags)
{
	void *ret = ____kmalloc(size, flags);
	if (ret)
		memset(ret, 0, size);
	return ret;
}
EXPORT_SYMBOL(__kzalloc);

/*
 * kstrdup - allocate space for and copy an existing string
 *
 * @s: the string to duplicate
 * @gfp: the GFP mask used in the kmalloc() call when allocating memory
 */
char *kstrdup(const char *s, gfp_t gfp)
{
	size_t len;
	char *buf;

	if (!s)
		return NULL;

	len = strlen(s) + 1;
	buf = ____kmalloc(len, gfp);
	if (buf)
		memcpy(buf, s, len);
	return buf;
}
EXPORT_SYMBOL(kstrdup);

/*
 * strndup_user - duplicate an existing string from user space
 *
 * @s: The string to duplicate
 * @n: Maximum number of bytes to copy, including the trailing NUL.
 */
char *strndup_user(const char __user *s, long n)
{
	char *p;
	long length;

	length = strnlen_user(s, n);

	if (!length)
		return ERR_PTR(-EFAULT);

	if (length > n)
		return ERR_PTR(-EINVAL);

	p = kmalloc(length, GFP_KERNEL);

	if (!p)
		return ERR_PTR(-ENOMEM);

	if (copy_from_user(p, s, length)) {
		kfree(p);
		return ERR_PTR(-EFAULT);
	}

	p[length - 1] = '\0';

	return p;
}
EXPORT_SYMBOL(strndup_user);
Commit	Line	Data
30992c97 MM	1	#include <linux/slab.h>
	2	#include <linux/string.h>
	3	#include <linux/module.h>
96840aa0 DA	4	#include <linux/err.h>
96840aa0 DA	5	#include <asm/uaccess.h>
30992c97 MM	6
30992c97 MM	7	/**
40c07ae8	8	* __kzalloc - allocate memory. The memory is set to zero.
30992c97 MM	9	* @size: how many bytes of memory are required.
	10	* @flags: the type of memory to allocate.
	11	*/
40c07ae8	12	void *__kzalloc(size_t size, gfp_t flags)
30992c97	13	{
871751e2	14	void *ret = ____kmalloc(size, flags);
30992c97 MM	15	if (ret)
	16	memset(ret, 0, size);
	17	return ret;
	18	}
40c07ae8	19	EXPORT_SYMBOL(__kzalloc);
30992c97 MM	20
	21	/*
	22	* kstrdup - allocate space for and copy an existing string
	23	*
	24	* @s: the string to duplicate
	25	* @gfp: the GFP mask used in the kmalloc() call when allocating memory
	26	*/
	27	char kstrdup(const char s, gfp_t gfp)
	28	{
	29	size_t len;
	30	char *buf;
	31
	32	if (!s)
	33	return NULL;
	34
	35	len = strlen(s) + 1;
871751e2	36	buf = ____kmalloc(len, gfp);
30992c97 MM	37	if (buf)
	38	memcpy(buf, s, len);
	39	return buf;
	40	}
	41	EXPORT_SYMBOL(kstrdup);
96840aa0 DA	42
	43	/*
	44	* strndup_user - duplicate an existing string from user space
	45	*
	46	* @s: The string to duplicate
	47	* @n: Maximum number of bytes to copy, including the trailing NUL.
	48	*/
	49	char strndup_user(const char __user s, long n)
	50	{
	51	char *p;
	52	long length;
	53
	54	length = strnlen_user(s, n);
	55
	56	if (!length)
	57	return ERR_PTR(-EFAULT);
	58
	59	if (length > n)
	60	return ERR_PTR(-EINVAL);
	61
	62	p = kmalloc(length, GFP_KERNEL);
	63
	64	if (!p)
	65	return ERR_PTR(-ENOMEM);
	66
	67	if (copy_from_user(p, s, length)) {
	68	kfree(p);
	69	return ERR_PTR(-EFAULT);
	70	}
	71
	72	p[length - 1] = '\0';
	73
	74	return p;
	75	}
	76	EXPORT_SYMBOL(strndup_user);