Apply two nice improvements caught by Ricardo,

spl-05-div64.patch
This is a much less intrusive fix for undefined 64-bit division symbols
when compiling the DMU in 32-bit kernels.

* spl-06-atomic64.patch
This is a workaround for 32-bit kernels that don't have atomic64_t.



git-svn-id: https://outreach.scidac.gov/svn/spl/trunk@162 7e1ea52c-4ff2-0310-8f11-9dd32ca42a1c

modules/spl/spl-generic.c

@@ -88,12 +88,15 @@ highbit(unsigned long i)
 EXPORT_SYMBOL(highbit);
 
 /*
- * Implementation of div64_64(), for kernels that don't have it.
- *
- * Taken from a 2.6.24 kernel.
+ * Implementation of 64 bit division for 32-bit machines.
  */
-uint64_t spl_div64_64(uint64_t dividend, uint64_t divisor)
+#if BITS_PER_LONG == 32
+uint64_t __udivdi3(uint64_t dividend, uint64_t divisor)
 {
+#ifdef HAVE_DIV64_64
+	return div64_64(dividend, divisor);
+#else
+	/* Taken from a 2.6.24 kernel. */
 	uint32_t high, d;
 
 	high = divisor >> 32;
@@ -108,8 +111,19 @@ uint64_t spl_div64_64(uint64_t dividend, uint64_t divisor)
 	do_div(dividend, d);
 
 	return dividend;
+#endif
 }
-EXPORT_SYMBOL(spl_div64_64);
+EXPORT_SYMBOL(__udivdi3);
+
+/*
+ * Implementation of 64 bit modulo for 32-bit machines.
+ */
+uint64_t __umoddi3(uint64_t dividend, uint64_t divisor)
+{
+	return dividend - divisor * (dividend / divisor);
+}
+EXPORT_SYMBOL(__umoddi3);
+#endif
 
 int
 ddi_strtoul(const char *str, char **nptr, int base, unsigned long *result)

modules/spl/spl-kmem.c

@@ -43,9 +43,9 @@
  */
 #ifdef DEBUG_KMEM
 /* Shim layer memory accounting */
-atomic64_t kmem_alloc_used;
+atomic64_t kmem_alloc_used = ATOMIC64_INIT(0);
 unsigned long kmem_alloc_max = 0;
-atomic64_t vmem_alloc_used;
+atomic64_t vmem_alloc_used = ATOMIC64_INIT(0);
 unsigned long vmem_alloc_max = 0;
 int kmem_warning_flag = 1;
 
@@ -1031,12 +1031,12 @@ spl_kmem_fini(void)
 	 * a serious concern here since it is module unload time. */
 	if (atomic64_read(&kmem_alloc_used) != 0)
 		CWARN("kmem leaked %ld/%ld bytes\n",
-		      atomic_read(&kmem_alloc_used), kmem_alloc_max);
+		      atomic64_read(&kmem_alloc_used), kmem_alloc_max);
 
 
 	if (atomic64_read(&vmem_alloc_used) != 0)
 		CWARN("vmem leaked %ld/%ld bytes\n",
-		      atomic_read(&vmem_alloc_used), vmem_alloc_max);
+		      atomic64_read(&vmem_alloc_used), vmem_alloc_max);
 
 	spl_kmem_fini_tracking(&kmem_list, &kmem_lock);
 	spl_kmem_fini_tracking(&vmem_list, &vmem_lock);

modules/spl/spl-proc.c

@@ -415,7 +415,7 @@ proc_doatomic64(struct ctl_table *table, int write, struct file *filp,
         if (write) {
                 *ppos += *lenp;
         } else {
-                val = atomic_read((atomic64_t *)table->data);
+                val = atomic64_read((atomic64_t *)table->data);
                 rc = proc_doulongvec_minmax(&dummy, write, filp,
                                             buffer, lenp, ppos);
         }