linux-imx

// SPDX-License-Identifier: GPL-2.0

#include <linux/compiler.h>

#include <linux/export.h>

#include <linux/kasan-checks.h>

#include <linux/thread_info.h>

#include <linux/uaccess.h>

#include <linux/kernel.h>

#include <linux/errno.h>

​

#include <asm/byteorder.h>

#include <asm/word-at-a-time.h>

​

#ifdef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS

#define IS_UNALIGNED(src, dst)  0

#else

#define IS_UNALIGNED(src, dst)  \

    (((long) dst | (long) src) & (sizeof(long) - 1))

#endif

​

/*

 * Do a strncpy, return length of string without final '\0'.

 * 'count' is the user-supplied count (return 'count' if we

 * hit it), 'max' is the address space maximum (and we return

 * -EFAULT if we hit it).

 */

static inline long do_strncpy_from_user(char *dst, const char __user *src, long count, unsigned long max)

{

    const struct word_at_a_time constants = WORD_AT_A_TIME_CONSTANTS;

    long res = 0;

​

    /*

     * Truncate 'max' to the user-specified limit, so that

     * we only have one limit we need to check in the loop

     */

    if (max > count)

        max = count;

​

    if (IS_UNALIGNED(src, dst))

        goto byte_at_a_time;

​

    while (max >= sizeof(unsigned long)) {

        unsigned long c, data;

​

        /* Fall back to byte-at-a-time if we get a page fault */

        unsafe_get_user(c, (unsigned long __user *)(src+res), byte_at_a_time);

​

        *(unsigned long *)(dst+res) = c;

        if (has_zero(c, &data, &constants)) {

            data = prep_zero_mask(c, data, &constants);

            data = create_zero_mask(data);

            return res + find_zero(data);

        }

        res += sizeof(unsigned long);

        max -= sizeof(unsigned long);

    }

​

byte_at_a_time:

    while (max) {

        char c;

​

        unsafe_get_user(c,src+res, efault);

        dst[res] = c;

        if (!c)