Merge git://git.kernel.org/pub/scm/linux/kernel/git/cmetcalf/linux-tile

* git://git.kernel.org/pub/scm/linux/kernel/git/cmetcalf/linux-tile:
  arch/tile: fix memchr() not to dereference memory for zero length
  arch/tile: make glibc's sysconf(_SC_NPROCESSORS_CONF) work correctly
  arch/tile: fix rwlock so would-be write lockers don't block new readers

3 files changed, 38 insertions, 28 deletions

diff --git a/arch/tile/kernel/setup.c b/arch/tile/kernel/setup.c
index fb0b3cbeae1..f18573643ed 100644
--- a/arch/tile/kernel/setup.c
+++ b/arch/tile/kernel/setup.c
@@ -840,7 +840,7 @@ static int __init topology_init(void)
         for_each_online_node(i)
                 register_one_node(i);
 
-        for_each_present_cpu(i)
+        for (i = 0; i < smp_height * smp_width; ++i)
                 register_cpu(&cpu_devices[i], i);
 
         return 0;
diff --git a/arch/tile/lib/memchr_32.c b/arch/tile/lib/memchr_32.c
index 6235283b485..cc3d9badf03 100644
--- a/arch/tile/lib/memchr_32.c
+++ b/arch/tile/lib/memchr_32.c
@@ -18,12 +18,24 @@
 
 void *memchr(const void *s, int c, size_t n)
 {
+        const uint32_t *last_word_ptr;
+        const uint32_t *p;
+        const char *last_byte_ptr;
+        uintptr_t s_int;
+        uint32_t goal, before_mask, v, bits;
+        char *ret;
+
+        if (__builtin_expect(n == 0, 0)) {
+                /* Don't dereference any memory if the array is empty. */
+                return NULL;
+        }
+
         /* Get an aligned pointer. */
-        const uintptr_t s_int = (uintptr_t) s;
-        const uint32_t *p = (const uint32_t *)(s_int & -4);
+        s_int = (uintptr_t) s;
+        p = (const uint32_t *)(s_int & -4);
 
         /* Create four copies of the byte for which we are looking. */
-        const uint32_t goal = 0x01010101 * (uint8_t) c;
+        goal = 0x01010101 * (uint8_t) c;
 
         /* Read the first word, but munge it so that bytes before the array
          * will not match goal.
@@ -31,23 +43,14 @@ void *memchr(const void *s, int c, size_t n)
          * Note that this shift count expression works because we know
          * shift counts are taken mod 32.
          */
-        const uint32_t before_mask = (1 << (s_int << 3)) - 1;
-        uint32_t v = (*p | before_mask) ^ (goal & before_mask);
+        before_mask = (1 << (s_int << 3)) - 1;
+        v = (*p | before_mask) ^ (goal & before_mask);
 
         /* Compute the address of the last byte. */
-        const char *const last_byte_ptr = (const char *)s + n - 1;
+        last_byte_ptr = (const char *)s + n - 1;
 
         /* Compute the address of the word containing the last byte. */
-        const uint32_t *const last_word_ptr =
-            (const uint32_t *)((uintptr_t) last_byte_ptr & -4);
-
-        uint32_t bits;
-        char *ret;
-
-        if (__builtin_expect(n == 0, 0)) {
-                /* Don't dereference any memory if the array is empty. */
-                return NULL;
-        }
+        last_word_ptr = (const uint32_t *)((uintptr_t) last_byte_ptr & -4);
 
         while ((bits = __insn_seqb(v, goal)) == 0) {
                 if (__builtin_expect(p == last_word_ptr, 0)) {
diff --git a/arch/tile/lib/spinlock_32.c b/arch/tile/lib/spinlock_32.c
index 485e24d62c6..5cd1c4004ec 100644
--- a/arch/tile/lib/spinlock_32.c
+++ b/arch/tile/lib/spinlock_32.c
@@ -167,23 +167,30 @@ void arch_write_lock_slow(arch_rwlock_t *rwlock, u32 val)
          * when we compare them.
          */
         u32 my_ticket_;
+        u32 iterations = 0;
 
-        /* Take out the next ticket; this will also stop would-be readers. */
-        if (val & 1)
-                val = get_rwlock(rwlock);
-        rwlock->lock = __insn_addb(val, 1 << WR_NEXT_SHIFT);
+        /*
+         * Wait until there are no readers, then bump up the next
+         * field and capture the ticket value.
+         */
+        for (;;) {
+                if (!(val & 1)) {
+                        if ((val >> RD_COUNT_SHIFT) == 0)
+                                break;
+                        rwlock->lock = val;
+                }
+                delay_backoff(iterations++);
+                val = __insn_tns((int *)&rwlock->lock);
+        }
 
-        /* Extract my ticket value from the original word. */
+        /* Take out the next ticket and extract my ticket value. */
+        rwlock->lock = __insn_addb(val, 1 << WR_NEXT_SHIFT);
         my_ticket_ = val >> WR_NEXT_SHIFT;
 
-        /*
-         * Wait until the "current" field matches our ticket, and
-         * there are no remaining readers.
-         */
+        /* Wait until the "current" field matches our ticket. */
         for (;;) {
                 u32 curr_ = val >> WR_CURR_SHIFT;
-                u32 readers = val >> RD_COUNT_SHIFT;
-                u32 delta = ((my_ticket_ - curr_) & WR_MASK) + !!readers;
+                u32 delta = ((my_ticket_ - curr_) & WR_MASK);
                 if (likely(delta == 0))
                         break;