staging: lustre: remove LPX64 define

[deliverable/linux.git] / drivers / staging / lustre / lustre / obdclass / class_obd.c

diff --git a/drivers/staging/lustre/lustre/obdclass/class_obd.c b/drivers/staging/lustre/lustre/obdclass/class_obd.c
index dde04b767a6d5a2ec331574ff66c153e2c4f8657..df6a72fc24d0ff3e32ed4502096c78522a8d563e 100644 (file)
--- a/drivers/staging/lustre/lustre/obdclass/class_obd.c
+++ b/drivers/staging/lustre/lustre/obdclass/class_obd.c
@@ -37,14 +37,14 @@
 #define DEBUG_SUBSYSTEM S_CLASS
 # include <asm/atomic.h>
 
-#include <obd_support.h>
-#include <obd_class.h>
-#include <linux/lnet/lnetctl.h>
-#include <lustre_debug.h>
-#include <lprocfs_status.h>
-#include <lustre/lustre_build_version.h>
+#include "../include/obd_support.h"
+#include "../include/obd_class.h"
+#include "../../include/linux/lnet/lnetctl.h"
+#include "../include/lustre_debug.h"
+#include "../include/lprocfs_status.h"
+#include "../include/lustre/lustre_build_version.h"
 #include <linux/list.h>
-#include <cl_object.h>
+#include "../include/cl_object.h"
 #include "llog_internal.h"
 
 
@@ -141,11 +141,11 @@ int obd_alloc_fail(const void *ptr, const char *name, const char *type,
 {
        if (ptr == NULL ||
            (cfs_rand() & OBD_ALLOC_FAIL_MASK) < obd_alloc_fail_rate) {
-               CERROR("%s%salloc of %s ("LPU64" bytes) failed at %s:%d\n",
+               CERROR("%s%salloc of %s (%llu bytes) failed at %s:%d\n",
                       ptr ? "force " :"", type, name, (__u64)size, file,
                       line);
-               CERROR(LPU64" total bytes and "LPU64" total pages "
-                      "("LPU64" bytes) allocated by Lustre, "
+               CERROR("%llu total bytes and %llu total pages "
+                      "(%llu bytes) allocated by Lustre, "
                       "%d total bytes by LNET\n",
                       obd_memory_sum(),
                       obd_pages_sum() << PAGE_CACHE_SHIFT,
@@ -420,61 +420,61 @@ int obd_init_checks(void)
        char buf[64];
        int len, ret = 0;
 
-       CDEBUG(D_INFO, "LPU64=%s, LPD64=%s, LPX64=%s\n", LPU64, LPD64, LPX64);
+       CDEBUG(D_INFO, "LPU64=%s, LPD64=%s, LPX64=%s\n", "%llu", "%lld", "%#llx");
 
-       CDEBUG(D_INFO, "OBD_OBJECT_EOF = "LPX64"\n", (__u64)OBD_OBJECT_EOF);
+       CDEBUG(D_INFO, "OBD_OBJECT_EOF = %#llx\n", (__u64)OBD_OBJECT_EOF);
 
        u64val = OBD_OBJECT_EOF;
-       CDEBUG(D_INFO, "u64val OBD_OBJECT_EOF = "LPX64"\n", u64val);
+       CDEBUG(D_INFO, "u64val OBD_OBJECT_EOF = %#llx\n", u64val);
        if (u64val != OBD_OBJECT_EOF) {
-               CERROR("__u64 "LPX64"(%d) != 0xffffffffffffffff\n",
+               CERROR("__u64 %#llx(%d) != 0xffffffffffffffff\n",
                       u64val, (int)sizeof(u64val));
                ret = -EINVAL;
        }
-       len = snprintf(buf, sizeof(buf), LPX64, u64val);
+       len = snprintf(buf, sizeof(buf), "%#llx", u64val);
        if (len != 18) {
                CWARN("LPX64 wrong length! strlen(%s)=%d != 18\n", buf, len);
                ret = -EINVAL;
        }
 
        div64val = OBD_OBJECT_EOF;
-       CDEBUG(D_INFO, "u64val OBD_OBJECT_EOF = "LPX64"\n", u64val);
+       CDEBUG(D_INFO, "u64val OBD_OBJECT_EOF = %#llx\n", u64val);
        if (u64val != OBD_OBJECT_EOF) {
-               CERROR("__u64 "LPX64"(%d) != 0xffffffffffffffff\n",
+               CERROR("__u64 %#llx(%d) != 0xffffffffffffffff\n",
                       u64val, (int)sizeof(u64val));
                ret = -EOVERFLOW;
        }
        if (u64val >> 8 != OBD_OBJECT_EOF >> 8) {
-               CERROR("__u64 "LPX64"(%d) != 0xffffffffffffffff\n",
+               CERROR("__u64 %#llx(%d) != 0xffffffffffffffff\n",
                       u64val, (int)sizeof(u64val));
                return -EOVERFLOW;
        }
        if (do_div(div64val, 256) != (u64val & 255)) {
-               CERROR("do_div("LPX64",256) != "LPU64"\n", u64val, u64val &255);
+               CERROR("do_div(%#llx,256) != %llu\n", u64val, u64val &255);
                return -EOVERFLOW;
        }
        if (u64val >> 8 != div64val) {
-               CERROR("do_div("LPX64",256) "LPU64" != "LPU64"\n",
+               CERROR("do_div(%#llx,256) %llu != %llu\n",
                       u64val, div64val, u64val >> 8);
                return -EOVERFLOW;
        }
-       len = snprintf(buf, sizeof(buf), LPX64, u64val);
+       len = snprintf(buf, sizeof(buf), "%#llx", u64val);
        if (len != 18) {
                CWARN("LPX64 wrong length! strlen(%s)=%d != 18\n", buf, len);
                ret = -EINVAL;
        }
-       len = snprintf(buf, sizeof(buf), LPU64, u64val);
+       len = snprintf(buf, sizeof(buf), "%llu", u64val);
        if (len != 20) {
                CWARN("LPU64 wrong length! strlen(%s)=%d != 20\n", buf, len);
                ret = -EINVAL;
        }
-       len = snprintf(buf, sizeof(buf), LPD64, u64val);
+       len = snprintf(buf, sizeof(buf), "%lld", u64val);
        if (len != 2) {
                CWARN("LPD64 wrong length! strlen(%s)=%d != 2\n", buf, len);
                ret = -EINVAL;
        }
        if ((u64val & ~CFS_PAGE_MASK) >= PAGE_CACHE_SIZE) {
-               CWARN("mask failed: u64val "LPU64" >= "LPU64"\n", u64val,
+               CWARN("mask failed: u64val %llu >= %llu\n", u64val,
                      (__u64)PAGE_CACHE_SIZE);
                ret = -EINVAL;
        }
@@ -662,10 +662,10 @@ static void cleanup_obdclass(void)
 
        lprocfs_free_stats(&obd_memory);
        CDEBUG((memory_leaked) ? D_ERROR : D_INFO,
-              "obd_memory max: "LPU64", leaked: "LPU64"\n",
+              "obd_memory max: %llu, leaked: %llu\n",
               memory_max, memory_leaked);
        CDEBUG((pages_leaked) ? D_ERROR : D_INFO,
-              "obd_memory_pages max: "LPU64", leaked: "LPU64"\n",
+              "obd_memory_pages max: %llu, leaked: %llu\n",
               pages_max, pages_leaked);
 }