Merge branch 'generic-string-functions'

This makes <asm/word-at-a-time.h> actually live up to its promise of
allowing architectures to help tune the string functions that do their
work a word at a time.

David had already taken the x86 strncpy_from_user() function, modified
it to work on sparc, and then done the extra work to make it generically
useful.  This then expands on that work by making x86 use that generic
version, completing the circle.

But more importantly, it fixes up the word-at-a-time interfaces so that
it's now easy to also support things like strnlen_user(), and pretty
much most random string functions.

David reports that it all works fine on sparc, and Jonas Bonn reported
that an earlier version of this worked on OpenRISC too.  It's pretty
easy for architectures to add support for this and just replace their
private versions with the generic code.

* generic-string-functions:
  sparc: use the new generic strnlen_user() function
  x86: use the new generic strnlen_user() function
  lib: add generic strnlen_user() function
  word-at-a-time: make the interfaces truly generic
  x86: use generic strncpy_from_user routine

4 files changed, 149 insertions, 40 deletions

diff --git a/lib/Kconfig b/lib/Kconfig
index 3e63af089082..a9e15403434e 100644
--- a/lib/Kconfig
+++ b/lib/Kconfig
@@ -19,6 +19,9 @@ config RATIONAL
 config GENERIC_STRNCPY_FROM_USER
         bool
 
+config GENERIC_STRNLEN_USER
+        bool
+
 config GENERIC_FIND_FIRST_BIT
         bool
 
diff --git a/lib/Makefile b/lib/Makefile
index 2a1d7f9d39a2..8c31a0cb75e9 100644
--- a/lib/Makefile
+++ b/lib/Makefile
@@ -126,6 +126,7 @@ obj-$(CONFIG_CLZ_TAB) += clz_tab.o
 obj-$(CONFIG_DDR) += jedec_ddr_data.o
 
 obj-$(CONFIG_GENERIC_STRNCPY_FROM_USER) += strncpy_from_user.o
+obj-$(CONFIG_GENERIC_STRNLEN_USER) += strnlen_user.o
 
 obj-$(CONFIG_STMP_DEVICE) += stmp_device.o
 
diff --git a/lib/strncpy_from_user.c b/lib/strncpy_from_user.c
index c4c09b0e96ba..bb2b201d6ad0 100644
--- a/lib/strncpy_from_user.c
+++ b/lib/strncpy_from_user.c
@@ -4,37 +4,7 @@
 #include <linux/errno.h>
 
 #include <asm/byteorder.h>
-
-static inline long find_zero(unsigned long mask)
-{
-        long byte = 0;
-
-#ifdef __BIG_ENDIAN
-#ifdef CONFIG_64BIT
-        if (mask >> 32)
-                mask >>= 32;
-        else
-                byte = 4;
-#endif
-        if (mask >> 16)
-                mask >>= 16;
-        else
-                byte += 2;
-        return (mask >> 8) ? byte : byte + 1;
-#else
-#ifdef CONFIG_64BIT
-        if (!((unsigned int) mask)) {
-                mask >>= 32;
-                byte = 4;
-        }
-#endif
-        if (!(mask & 0xffff)) {
-                mask >>= 16;
-                byte += 2;
-        }
-        return (mask & 0xff) ? byte : byte + 1;
-#endif
-}
+#include <asm/word-at-a-time.h>
 
 #ifdef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
 #define IS_UNALIGNED(src, dst)  0
@@ -51,8 +21,7 @@ static inline long find_zero(unsigned long mask)
  */
 static inline long do_strncpy_from_user(char *dst, const char __user *src, long count, unsigned long max)
 {
-        const unsigned long high_bits = REPEAT_BYTE(0xfe) + 1;
-        const unsigned long low_bits = REPEAT_BYTE(0x7f);
+        const struct word_at_a_time constants = WORD_AT_A_TIME_CONSTANTS;
         long res = 0;
 
         /*
@@ -66,18 +35,16 @@ static inline long do_strncpy_from_user(char *dst, const char __user *src, long
                 goto byte_at_a_time;
 
         while (max >= sizeof(unsigned long)) {
-                unsigned long c, v, rhs;
+                unsigned long c, data;
 
                 /* Fall back to byte-at-a-time if we get a page fault */
                 if (unlikely(__get_user(c,(unsigned long __user *)(src+res))))
                         break;
-                rhs = c | low_bits;
-                v = (c + high_bits) & ~rhs;
                 *(unsigned long *)(dst+res) = c;
-                if (v) {
-                        v = (c & low_bits) + low_bits;
-                        v = ~(v | rhs);
-                        return res + find_zero(v);
+                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);
diff --git a/lib/strnlen_user.c b/lib/strnlen_user.c
new file mode 100644
index 000000000000..90900ecfeb54
--- /dev/null
+++ b/lib/strnlen_user.c
@@ -0,0 +1,138 @@
+#include <linux/kernel.h>
+#include <linux/export.h>
+#include <linux/uaccess.h>
+
+#include <asm/word-at-a-time.h>
+
+/* Set bits in the first 'n' bytes when loaded from memory */
+#ifdef __LITTLE_ENDIAN
+#  define aligned_byte_mask(n) ((1ul << 8*(n))-1)
+#else
+#  define aligned_byte_mask(n) (~0xfful << 8*(7-(n)))
+#endif
+
+/*
+ * Do a strnlen, return length of string *with* final '\0'.
+ * 'count' is the user-supplied count, while 'max' is the
+ * address space maximum.
+ *
+ * Return 0 for exceptions (which includes hitting the address
+ * space maximum), or 'count+1' if hitting the user-supplied
+ * maximum count.
+ *
+ * NOTE! We can sometimes overshoot the user-supplied maximum
+ * if it fits in a aligned 'long'. The caller needs to check
+ * the return value against "> max".
+ */
+static inline long do_strnlen_user(const char __user *src, unsigned long count, unsigned long max)
+{
+        const struct word_at_a_time constants = WORD_AT_A_TIME_CONSTANTS;
+        long align, res = 0;
+        unsigned long c;
+
+        /*
+         * 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;
+
+        /*
+         * Do everything aligned. But that means that we
+         * need to also expand the maximum..
+         */
+        align = (sizeof(long) - 1) & (unsigned long)src;
+        src -= align;
+        max += align;
+
+        if (unlikely(__get_user(c,(unsigned long __user *)src)))
+                return 0;
+        c |= aligned_byte_mask(align);
+
+        for (;;) {
+                unsigned long data;
+                if (has_zero(c, &data, &constants)) {
+                        data = prep_zero_mask(c, data, &constants);
+                        data = create_zero_mask(data);
+                        return res + find_zero(data) + 1 - align;
+                }
+                res += sizeof(unsigned long);
+                if (unlikely(max < sizeof(unsigned long)))
+                        break;
+                max -= sizeof(unsigned long);
+                if (unlikely(__get_user(c,(unsigned long __user *)(src+res))))
+                        return 0;
+        }
+        res -= align;
+
+        /*
+         * Uhhuh. We hit 'max'. But was that the user-specified maximum
+         * too? If so, return the marker for "too long".
+         */
+        if (res >= count)
+                return count+1;
+
+        /*
+         * Nope: we hit the address space limit, and we still had more
+         * characters the caller would have wanted. That's 0.
+         */
+        return 0;
+}
+
+/**
+ * strnlen_user: - Get the size of a user string INCLUDING final NUL.
+ * @str: The string to measure.
+ * @count: Maximum count (including NUL character)
+ *
+ * Context: User context only.  This function may sleep.
+ *
+ * Get the size of a NUL-terminated string in user space.
+ *
+ * Returns the size of the string INCLUDING the terminating NUL.
+ * If the string is too long, returns 'count+1'.
+ * On exception (or invalid count), returns 0.
+ */
+long strnlen_user(const char __user *str, long count)
+{
+        unsigned long max_addr, src_addr;
+
+        if (unlikely(count <= 0))
+                return 0;
+
+        max_addr = user_addr_max();
+        src_addr = (unsigned long)str;
+        if (likely(src_addr < max_addr)) {
+                unsigned long max = max_addr - src_addr;
+                return do_strnlen_user(str, count, max);
+        }
+        return 0;
+}
+EXPORT_SYMBOL(strnlen_user);
+
+/**
+ * strlen_user: - Get the size of a user string INCLUDING final NUL.
+ * @str: The string to measure.
+ *
+ * Context: User context only.  This function may sleep.
+ *
+ * Get the size of a NUL-terminated string in user space.
+ *
+ * Returns the size of the string INCLUDING the terminating NUL.
+ * On exception, returns 0.
+ *
+ * If there is a limit on the length of a valid string, you may wish to
+ * consider using strnlen_user() instead.
+ */
+long strlen_user(const char __user *str)
+{
+        unsigned long max_addr, src_addr;
+
+        max_addr = user_addr_max();
+        src_addr = (unsigned long)str;
+        if (likely(src_addr < max_addr)) {
+                unsigned long max = max_addr - src_addr;
+                return do_strnlen_user(str, ~0ul, max);
+        }
+        return 0;
+}
+EXPORT_SYMBOL(strlen_user);