1#include <linux/module.h>
 
 
 
 
  2#include <linux/uaccess.h>
  3#include <linux/kernel.h>
  4#include <linux/errno.h>
 
  5
  6#include <asm/byteorder.h>
  7#include <asm/word-at-a-time.h>
  8
  9#ifdef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
 10#define IS_UNALIGNED(src, dst)	0
 11#else
 12#define IS_UNALIGNED(src, dst)	\
 13	(((long) dst | (long) src) & (sizeof(long) - 1))
 14#endif
 15
 16/*
 17 * Do a strncpy, return length of string without final '\0'.
 18 * 'count' is the user-supplied count (return 'count' if we
 19 * hit it), 'max' is the address space maximum (and we return
 20 * -EFAULT if we hit it).
 21 */
 22static inline long do_strncpy_from_user(char *dst, const char __user *src, long count, unsigned long max)
 
 23{
 24	const struct word_at_a_time constants = WORD_AT_A_TIME_CONSTANTS;
 25	long res = 0;
 26
 27	/*
 28	 * Truncate 'max' to the user-specified limit, so that
 29	 * we only have one limit we need to check in the loop
 30	 */
 31	if (max > count)
 32		max = count;
 33
 34	if (IS_UNALIGNED(src, dst))
 35		goto byte_at_a_time;
 36
 37	while (max >= sizeof(unsigned long)) {
 38		unsigned long c, data;
 39
 40		/* Fall back to byte-at-a-time if we get a page fault */
 41		if (unlikely(__get_user(c,(unsigned long __user *)(src+res))))
 42			break;
 43		*(unsigned long *)(dst+res) = c;
 44		if (has_zero(c, &data, &constants)) {
 45			data = prep_zero_mask(c, data, &constants);
 46			data = create_zero_mask(data);
 47			return res + find_zero(data);
 48		}
 49		res += sizeof(unsigned long);
 50		max -= sizeof(unsigned long);
 51	}
 52
 53byte_at_a_time:
 54	while (max) {
 55		char c;
 56
 57		if (unlikely(__get_user(c,src+res)))
 58			return -EFAULT;
 59		dst[res] = c;
 60		if (!c)
 61			return res;
 62		res++;
 63		max--;
 64	}
 65
 66	/*
 67	 * Uhhuh. We hit 'max'. But was that the user-specified maximum
 68	 * too? If so, that's ok - we got as much as the user asked for.
 69	 */
 70	if (res >= count)
 71		return res;
 72
 73	/*
 74	 * Nope: we hit the address space limit, and we still had more
 75	 * characters the caller would have wanted. That's an EFAULT.
 76	 */
 
 77	return -EFAULT;
 78}
 79
 80/**
 81 * strncpy_from_user: - Copy a NUL terminated string from userspace.
 82 * @dst:   Destination address, in kernel space.  This buffer must be at
 83 *         least @count bytes long.
 84 * @src:   Source address, in user space.
 85 * @count: Maximum number of bytes to copy, including the trailing NUL.
 86 *
 87 * Copies a NUL-terminated string from userspace to kernel space.
 88 *
 89 * On success, returns the length of the string (not including the trailing
 90 * NUL).
 91 *
 92 * If access to userspace fails, returns -EFAULT (some data may have been
 93 * copied).
 94 *
 95 * If @count is smaller than the length of the string, copies @count bytes
 96 * and returns @count.
 97 */
 98long strncpy_from_user(char *dst, const char __user *src, long count)
 99{
100	unsigned long max_addr, src_addr;
101
102	if (unlikely(count <= 0))
103		return 0;
104
105	max_addr = user_addr_max();
106	src_addr = (unsigned long)src;
107	if (likely(src_addr < max_addr)) {
108		unsigned long max = max_addr - src_addr;
109		return do_strncpy_from_user(dst, src, count, max);
 
 
 
 
 
 
 
 
110	}
111	return -EFAULT;
112}
113EXPORT_SYMBOL(strncpy_from_user);

  1// SPDX-License-Identifier: GPL-2.0
  2#include <linux/compiler.h>
  3#include <linux/export.h>
  4#include <linux/kasan-checks.h>
  5#include <linux/thread_info.h>
  6#include <linux/uaccess.h>
  7#include <linux/kernel.h>
  8#include <linux/errno.h>
  9#include <linux/mm.h>
 10
 11#include <asm/byteorder.h>
 12#include <asm/word-at-a-time.h>
 13
 14#ifdef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
 15#define IS_UNALIGNED(src, dst)	0
 16#else
 17#define IS_UNALIGNED(src, dst)	\
 18	(((long) dst | (long) src) & (sizeof(long) - 1))
 19#endif
 20
 21/*
 22 * Do a strncpy, return length of string without final '\0'.
 23 * 'count' is the user-supplied count (return 'count' if we
 24 * hit it), 'max' is the address space maximum (and we return
 25 * -EFAULT if we hit it).
 26 */
 27static inline long do_strncpy_from_user(char *dst, const char __user *src,
 28					unsigned long count, unsigned long max)
 29{
 30	const struct word_at_a_time constants = WORD_AT_A_TIME_CONSTANTS;
 31	unsigned long res = 0;
 32
 33	/*
 34	 * Truncate 'max' to the user-specified limit, so that
 35	 * we only have one limit we need to check in the loop
 36	 */
 37	if (max > count)
 38		max = count;
 39
 40	if (IS_UNALIGNED(src, dst))
 41		goto byte_at_a_time;
 42
 43	while (max >= sizeof(unsigned long)) {
 44		unsigned long c, data;
 45
 46		/* Fall back to byte-at-a-time if we get a page fault */
 47		unsafe_get_user(c, (unsigned long __user *)(src+res), byte_at_a_time);
 48
 49		*(unsigned long *)(dst+res) = c;
 50		if (has_zero(c, &data, &constants)) {
 51			data = prep_zero_mask(c, data, &constants);
 52			data = create_zero_mask(data);
 53			return res + find_zero(data);
 54		}
 55		res += sizeof(unsigned long);
 56		max -= sizeof(unsigned long);
 57	}
 58
 59byte_at_a_time:
 60	while (max) {
 61		char c;
 62
 63		unsafe_get_user(c,src+res, efault);
 
 64		dst[res] = c;
 65		if (!c)
 66			return res;
 67		res++;
 68		max--;
 69	}
 70
 71	/*
 72	 * Uhhuh. We hit 'max'. But was that the user-specified maximum
 73	 * too? If so, that's ok - we got as much as the user asked for.
 74	 */
 75	if (res >= count)
 76		return res;
 77
 78	/*
 79	 * Nope: we hit the address space limit, and we still had more
 80	 * characters the caller would have wanted. That's an EFAULT.
 81	 */
 82efault:
 83	return -EFAULT;
 84}
 85
 86/**
 87 * strncpy_from_user: - Copy a NUL terminated string from userspace.
 88 * @dst:   Destination address, in kernel space.  This buffer must be at
 89 *         least @count bytes long.
 90 * @src:   Source address, in user space.
 91 * @count: Maximum number of bytes to copy, including the trailing NUL.
 92 *
 93 * Copies a NUL-terminated string from userspace to kernel space.
 94 *
 95 * On success, returns the length of the string (not including the trailing
 96 * NUL).
 97 *
 98 * If access to userspace fails, returns -EFAULT (some data may have been
 99 * copied).
100 *
101 * If @count is smaller than the length of the string, copies @count bytes
102 * and returns @count.
103 */
104long strncpy_from_user(char *dst, const char __user *src, long count)
105{
106	unsigned long max_addr, src_addr;
107
108	if (unlikely(count <= 0))
109		return 0;
110
111	max_addr = user_addr_max();
112	src_addr = (unsigned long)untagged_addr(src);
113	if (likely(src_addr < max_addr)) {
114		unsigned long max = max_addr - src_addr;
115		long retval;
116
117		kasan_check_write(dst, count);
118		check_object_size(dst, count, false);
119		if (user_access_begin(src, max)) {
120			retval = do_strncpy_from_user(dst, src, count, max);
121			user_access_end();
122			return retval;
123		}
124	}
125	return -EFAULT;
126}
127EXPORT_SYMBOL(strncpy_from_user);