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