10 files changed, 208 insertions, 35 deletions

diff --git a/lib/Kconfig.debug b/lib/Kconfig.debug
index 756a908c441d..d3679103a8e4 100644
--- a/lib/Kconfig.debug
+++ b/lib/Kconfig.debug
@@ -71,7 +71,7 @@ config LOG_BUF_SHIFT
 
 config DETECT_SOFTLOCKUP
         bool "Detect Soft Lockups"
-        depends on DEBUG_KERNEL
+        depends on DEBUG_KERNEL && !S390
         default y
         help
           Say Y here to enable the kernel to detect "soft lockups",
@@ -341,7 +341,7 @@ config FRAME_POINTER
 
 config UNWIND_INFO
         bool "Compile the kernel with frame unwind information"
-        depends on !IA64 && !PARISC
+        depends on !IA64 && !PARISC && !ARM
         depends on !MODULES || !(MIPS || PPC || SUPERH || V850)
         help
           If you say Y here the resulting kernel image will be slightly larger
@@ -371,6 +371,20 @@ config FORCED_INLINING
           become the default in the future, until then this option is there to
           test gcc for this.
 
+config HEADERS_CHECK
+        bool "Run 'make headers_check' when building vmlinux"
+        depends on !UML
+        help
+          This option will extract the user-visible kernel headers whenever
+          building the kernel, and will run basic sanity checks on them to
+          ensure that exported files do not attempt to include files which
+          were not exported, etc.
+
+          If you're making modifications to header files which are
+          relevant for userspace, say 'Y', and check the headers
+          exported to $(INSTALL_HDR_PATH) (usually 'usr/include' in
+          your build tree), to make sure they're suitable.
+
 config RCU_TORTURE_TEST
         tristate "torture tests for RCU"
         depends on DEBUG_KERNEL
diff --git a/lib/Makefile b/lib/Makefile
index 8e6662bb9c37..cf98fabaa549 100644
--- a/lib/Makefile
+++ b/lib/Makefile
@@ -12,7 +12,7 @@ lib-$(CONFIG_SMP) += cpumask.o
 
 lib-y   += kobject.o kref.o kobject_uevent.o klist.o
 
-obj-y += sort.o parser.o halfmd4.o iomap_copy.o debug_locks.o
+obj-y += sort.o parser.o halfmd4.o iomap_copy.o debug_locks.o random32.o
 
 ifeq ($(CONFIG_DEBUG_KOBJECT),y)
 CFLAGS_kobject.o += -DDEBUG
diff --git a/lib/bitmap.c b/lib/bitmap.c
index d71e38c54ea5..037fa9aa2ed7 100644
--- a/lib/bitmap.c
+++ b/lib/bitmap.c
@@ -316,10 +316,11 @@ int bitmap_scnprintf(char *buf, unsigned int buflen,
 EXPORT_SYMBOL(bitmap_scnprintf);
 
 /**
- * bitmap_parse - convert an ASCII hex string into a bitmap.
- * @ubuf: pointer to buffer in user space containing string.
- * @ubuflen: buffer size in bytes.  If string is smaller than this
+ * __bitmap_parse - convert an ASCII hex string into a bitmap.
+ * @buf: pointer to buffer containing string.
+ * @buflen: buffer size in bytes.  If string is smaller than this
  *    then it must be terminated with a \0.
+ * @is_user: location of buffer, 0 indicates kernel space
  * @maskp: pointer to bitmap array that will contain result.
  * @nmaskbits: size of bitmap, in bits.
  *
@@ -330,11 +331,13 @@ EXPORT_SYMBOL(bitmap_scnprintf);
  * characters and for grouping errors such as "1,,5", ",44", "," and "".
  * Leading and trailing whitespace accepted, but not embedded whitespace.
  */
-int bitmap_parse(const char __user *ubuf, unsigned int ubuflen,
-        unsigned long *maskp, int nmaskbits)
+int __bitmap_parse(const char *buf, unsigned int buflen,
+                int is_user, unsigned long *maskp,
+                int nmaskbits)
 {
         int c, old_c, totaldigits, ndigits, nchunks, nbits;
         u32 chunk;
+        const char __user *ubuf = buf;
 
         bitmap_zero(maskp, nmaskbits);
 
@@ -343,11 +346,15 @@ int bitmap_parse(const char __user *ubuf, unsigned int ubuflen,
                 chunk = ndigits = 0;
 
                 /* Get the next chunk of the bitmap */
-                while (ubuflen) {
+                while (buflen) {
                         old_c = c;
-                        if (get_user(c, ubuf++))
-                                return -EFAULT;
-                        ubuflen--;
+                        if (is_user) {
+                                if (__get_user(c, ubuf++))
+                                        return -EFAULT;
+                        }
+                        else
+                                c = *buf++;
+                        buflen--;
                         if (isspace(c))
                                 continue;
 
@@ -388,11 +395,36 @@ int bitmap_parse(const char __user *ubuf, unsigned int ubuflen,
                 nbits += (nchunks == 1) ? nbits_to_hold_value(chunk) : CHUNKSZ;
                 if (nbits > nmaskbits)
                         return -EOVERFLOW;
-        } while (ubuflen && c == ',');
+        } while (buflen && c == ',');
 
         return 0;
 }
-EXPORT_SYMBOL(bitmap_parse);
+EXPORT_SYMBOL(__bitmap_parse);
+
+/**
+ * bitmap_parse_user()
+ *
+ * @ubuf: pointer to user buffer containing string.
+ * @ulen: buffer size in bytes.  If string is smaller than this
+ *    then it must be terminated with a \0.
+ * @maskp: pointer to bitmap array that will contain result.
+ * @nmaskbits: size of bitmap, in bits.
+ *
+ * Wrapper for __bitmap_parse(), providing it with user buffer.
+ *
+ * We cannot have this as an inline function in bitmap.h because it needs
+ * linux/uaccess.h to get the access_ok() declaration and this causes
+ * cyclic dependencies.
+ */
+int bitmap_parse_user(const char __user *ubuf,
+                        unsigned int ulen, unsigned long *maskp,
+                        int nmaskbits)
+{
+        if (!access_ok(VERIFY_READ, ubuf, ulen))
+                return -EFAULT;
+        return __bitmap_parse((const char *)ubuf, ulen, 1, maskp, nmaskbits);
+}
+EXPORT_SYMBOL(bitmap_parse_user);
 
 /*
  * bscnl_emit(buf, buflen, rbot, rtop, bp)
diff --git a/lib/cpumask.c b/lib/cpumask.c
index 7a2a73f88d59..3a67dc5ada7d 100644
--- a/lib/cpumask.c
+++ b/lib/cpumask.c
@@ -43,19 +43,3 @@ int __any_online_cpu(const cpumask_t *mask)
         return cpu;
 }
 EXPORT_SYMBOL(__any_online_cpu);
-
-#if MAX_NUMNODES > 1
-/*
- * Find the highest possible node id.
- */
-int highest_possible_node_id(void)
-{
-        unsigned int node;
-        unsigned int highest = 0;
-
-        for_each_node_mask(node, node_possible_map)
-                highest = node;
-        return highest;
-}
-EXPORT_SYMBOL(highest_possible_node_id);
-#endif
diff --git a/lib/kobject.c b/lib/kobject.c
index 1699eb9161f3..7dd5c0e9d996 100644
--- a/lib/kobject.c
+++ b/lib/kobject.c
@@ -119,6 +119,7 @@ char *kobject_get_path(struct kobject *kobj, gfp_t gfp_mask)
 
         return path;
 }
+EXPORT_SYMBOL_GPL(kobject_get_path);
 
 /**
  *      kobject_init - initialize object.
diff --git a/lib/random32.c b/lib/random32.c
new file mode 100644
index 000000000000..4a15ce51cea7
--- /dev/null
+++ b/lib/random32.c
@@ -0,0 +1,142 @@
+/*
+  This is a maximally equidistributed combined Tausworthe generator
+  based on code from GNU Scientific Library 1.5 (30 Jun 2004)
+
+   x_n = (s1_n ^ s2_n ^ s3_n)
+
+   s1_{n+1} = (((s1_n & 4294967294) <<12) ^ (((s1_n <<13) ^ s1_n) >>19))
+   s2_{n+1} = (((s2_n & 4294967288) << 4) ^ (((s2_n << 2) ^ s2_n) >>25))
+   s3_{n+1} = (((s3_n & 4294967280) <<17) ^ (((s3_n << 3) ^ s3_n) >>11))
+
+   The period of this generator is about 2^88.
+
+   From: P. L'Ecuyer, "Maximally Equidistributed Combined Tausworthe
+   Generators", Mathematics of Computation, 65, 213 (1996), 203--213.
+
+   This is available on the net from L'Ecuyer's home page,
+
+   http://www.iro.umontreal.ca/~lecuyer/myftp/papers/tausme.ps
+   ftp://ftp.iro.umontreal.ca/pub/simulation/lecuyer/papers/tausme.ps
+
+   There is an erratum in the paper "Tables of Maximally
+   Equidistributed Combined LFSR Generators", Mathematics of
+   Computation, 68, 225 (1999), 261--269:
+   http://www.iro.umontreal.ca/~lecuyer/myftp/papers/tausme2.ps
+
+        ... the k_j most significant bits of z_j must be non-
+        zero, for each j. (Note: this restriction also applies to the
+        computer code given in [4], but was mistakenly not mentioned in
+        that paper.)
+
+   This affects the seeding procedure by imposing the requirement
+   s1 > 1, s2 > 7, s3 > 15.
+
+*/
+
+#include <linux/types.h>
+#include <linux/percpu.h>
+#include <linux/module.h>
+#include <linux/random.h>
+
+struct rnd_state {
+        u32 s1, s2, s3;
+};
+
+static DEFINE_PER_CPU(struct rnd_state, net_rand_state);
+
+static u32 __random32(struct rnd_state *state)
+{
+#define TAUSWORTHE(s,a,b,c,d) ((s&c)<<d) ^ (((s <<a) ^ s)>>b)
+
+        state->s1 = TAUSWORTHE(state->s1, 13, 19, 4294967294UL, 12);
+        state->s2 = TAUSWORTHE(state->s2, 2, 25, 4294967288UL, 4);
+        state->s3 = TAUSWORTHE(state->s3, 3, 11, 4294967280UL, 17);
+
+        return (state->s1 ^ state->s2 ^ state->s3);
+}
+
+static void __set_random32(struct rnd_state *state, unsigned long s)
+{
+        if (s == 0)
+                s = 1;      /* default seed is 1 */
+
+#define LCG(n) (69069 * n)
+        state->s1 = LCG(s);
+        state->s2 = LCG(state->s1);
+        state->s3 = LCG(state->s2);
+
+        /* "warm it up" */
+        __random32(state);
+        __random32(state);
+        __random32(state);
+        __random32(state);
+        __random32(state);
+        __random32(state);
+}
+
+/**
+ *      random32 - pseudo random number generator
+ *
+ *      A 32 bit pseudo-random number is generated using a fast
+ *      algorithm suitable for simulation. This algorithm is NOT
+ *      considered safe for cryptographic use.
+ */
+u32 random32(void)
+{
+        unsigned long r;
+        struct rnd_state *state = &get_cpu_var(net_rand_state);
+        r = __random32(state);
+        put_cpu_var(state);
+        return r;
+}
+EXPORT_SYMBOL(random32);
+
+/**
+ *      srandom32 - add entropy to pseudo random number generator
+ *      @seed: seed value
+ *
+ *      Add some additional seeding to the random32() pool.
+ *      Note: this pool is per cpu so it only affects current CPU.
+ */
+void srandom32(u32 entropy)
+{
+        struct rnd_state *state = &get_cpu_var(net_rand_state);
+        __set_random32(state, state->s1 ^ entropy);
+        put_cpu_var(state);
+}
+EXPORT_SYMBOL(srandom32);
+
+/*
+ *      Generate some initially weak seeding values to allow
+ *      to start the random32() engine.
+ */
+static int __init random32_init(void)
+{
+        int i;
+
+        for_each_possible_cpu(i) {
+                struct rnd_state *state = &per_cpu(net_rand_state,i);
+                __set_random32(state, i + jiffies);
+        }
+        return 0;
+}
+core_initcall(random32_init);
+
+/*
+ *      Generate better values after random number generator
+ *      is fully initalized.
+ */
+static int __init random32_reseed(void)
+{
+        int i;
+        unsigned long seed;
+
+        for_each_possible_cpu(i) {
+                struct rnd_state *state = &per_cpu(net_rand_state,i);
+
+                get_random_bytes(&seed, sizeof(seed));
+                __set_random32(state, seed);
+        }
+        return 0;
+}
+late_initcall(random32_reseed);
diff --git a/lib/rwsem-spinlock.c b/lib/rwsem-spinlock.c
index db4fed74b940..c4cfd6c0342f 100644
--- a/lib/rwsem-spinlock.c
+++ b/lib/rwsem-spinlock.c
@@ -28,7 +28,7 @@ void __init_rwsem(struct rw_semaphore *sem, const char *name,
          * Make sure we are not reinitializing a held semaphore:
          */
         debug_check_no_locks_freed((void *)sem, sizeof(*sem));
-        lockdep_init_map(&sem->dep_map, name, key);
+        lockdep_init_map(&sem->dep_map, name, key, 0);
 #endif
         sem->activity = 0;
         spin_lock_init(&sem->wait_lock);
diff --git a/lib/rwsem.c b/lib/rwsem.c
index 901d0e7da892..cdb4e3d05607 100644
--- a/lib/rwsem.c
+++ b/lib/rwsem.c
@@ -19,7 +19,7 @@ void __init_rwsem(struct rw_semaphore *sem, const char *name,
          * Make sure we are not reinitializing a held semaphore:
          */
         debug_check_no_locks_freed((void *)sem, sizeof(*sem));
-        lockdep_init_map(&sem->dep_map, name, key);
+        lockdep_init_map(&sem->dep_map, name, key, 0);
 #endif
         sem->count = RWSEM_UNLOCKED_VALUE;
         spin_lock_init(&sem->wait_lock);
diff --git a/lib/spinlock_debug.c b/lib/spinlock_debug.c
index dafaf1de2491..b6c4f898197c 100644
--- a/lib/spinlock_debug.c
+++ b/lib/spinlock_debug.c
@@ -20,7 +20,7 @@ void __spin_lock_init(spinlock_t *lock, const char *name,
          * Make sure we are not reinitializing a held lock:
          */
         debug_check_no_locks_freed((void *)lock, sizeof(*lock));
-        lockdep_init_map(&lock->dep_map, name, key);
+        lockdep_init_map(&lock->dep_map, name, key, 0);
 #endif
         lock->raw_lock = (raw_spinlock_t)__RAW_SPIN_LOCK_UNLOCKED;
         lock->magic = SPINLOCK_MAGIC;
@@ -38,7 +38,7 @@ void __rwlock_init(rwlock_t *lock, const char *name,
          * Make sure we are not reinitializing a held lock:
          */
         debug_check_no_locks_freed((void *)lock, sizeof(*lock));
-        lockdep_init_map(&lock->dep_map, name, key);
+        lockdep_init_map(&lock->dep_map, name, key, 0);
 #endif
         lock->raw_lock = (raw_rwlock_t) __RAW_RW_LOCK_UNLOCKED;
         lock->magic = RWLOCK_MAGIC;
diff --git a/lib/string.c b/lib/string.c
index 63077267367e..a485d75962af 100644
--- a/lib/string.c
+++ b/lib/string.c
@@ -320,7 +320,7 @@ char *strstrip(char *s)
                 return s;
 
         end = s + size - 1;
-        while (end != s && isspace(*end))
+        while (end >= s && isspace(*end))
                 end--;
         *(end + 1) = '\0';