[PATCH 0/4] Use 64-bit inode numbers internally in the kernel

[PATCH 0/4] Use 64-bit inode numbers internally in the kernel

[David Howells]

These patches make the kernel use 64-bit inode numbers internally, even on a
32-bit system.  They are required because some filesystems have intrinsic
64-bit inode numbers: NFS and XFS for example.  The 64-bit inode numbers are
then propagated to userspace automatically where the arch supports it.

Problems have been seen with userspace (eg: ld.so) using the 64-bit inode
number returned by stat64() or getdents64() to differentiate files, and failing
because the 64-bit inode number space was compressed to 32-bits, and so
overlaps occur.


There are four patches:

 (1) Supply __udivdi3() and __umoddi3() so that the compiler can do 64-bit
     division and modulus.  __udivmoddi4() is also supplied as the other two
     are wrappers around that.

 (2) Make __kernel_ino_t consistently typedef'd to "unsigned long long" on all
     archs.

     Where ino_t has been used in userspace facing structures (such as struct
     stat), it has been replaced with whatever ino_t used to be defined as on
     that arch.

     struct inode::i_ino and struct kstat::ino are changed to ino_t type.

 (3) Fix print format warnings in general code due to the change in type of
     i_ino.  These should now all carry an "ll" modifier.

 (4) As for (3), but fix the CacheFiles code.

David

[RHEL5 PATCH 1/4] Provide fallback full 64-bit divide/modulus ops for gcc

[David Howells]

Provide simple, reasonably quick full 64-bit divide and modulus ops for gcc to
call behind the scenes as:

	__udivmoddi4
	__udivdi3
	__umoddi3

The algorithm is a really simple binary long division that doesn't require
usage of multiply and divide instructions.  It shortcuts the long division at
the beginning by not bothering to consider any steps below the divisor
threshold.

The algorithm is placed in lib/ so that it can easily be replaced with an arch
specific version.  It will be dragged in by stuff in the fs/ directory once the
64-bit ino_t patch is applied unless an alternative is supplied, or unless the
CPU provides full 64-bit native instructions that the compiler can use.

Signed-Off-By: David Howells <dhowells@redhat.com>
---

 include/linux/kernel.h |    4 ++
 lib/Makefile           |    2 -
 lib/__udivdi3.c        |   23 +++++++++++
 lib/__udivmoddi4.c     |   99 ++++++++++++++++++++++++++++++++++++++++++++++++
 lib/__umoddi3.c        |   25 ++++++++++++
 5 files changed, 152 insertions(+), 1 deletions(-)

diff --git a/include/linux/kernel.h b/include/linux/kernel.h
index 181c69c..ab69416 100644
--- a/include/linux/kernel.h
+++ b/include/linux/kernel.h
@@ -152,6 +152,10 @@ static inline int printk(const char *s, 
 static inline int printk(const char *s, ...) { return 0; }
 #endif
 
+extern u64 __udivmoddi4(u64 dividend, u64 divisor, u64 *_remainder);
+extern u64 __udivdi3(u64 dividend, u64 divisor);
+extern u64 __umoddi3(u64 dividend, u64 divisor);
+
 unsigned long int_sqrt(unsigned long);
 
 static inline int __attribute_pure__ long_log2(unsigned long x)
diff --git a/lib/Makefile b/lib/Makefile
index be9719a..41428d3 100644
--- a/lib/Makefile
+++ b/lib/Makefile
@@ -5,7 +5,7 @@ #
 lib-y := errno.o ctype.o string.o vsprintf.o cmdline.o \
 	 bust_spinlocks.o rbtree.o radix-tree.o dump_stack.o \
 	 idr.o div64.o int_sqrt.o bitmap.o extable.o prio_tree.o \
-	 sha1.o
+	 sha1.o __udivdi3.o __umoddi3.o __udivmoddi4.o
 
 lib-$(CONFIG_SMP) += cpumask.o
 
diff --git a/lib/__udivdi3.c b/lib/__udivdi3.c
new file mode 100644
index 0000000..6541aef
--- /dev/null
+++ b/lib/__udivdi3.c
@@ -0,0 +1,23 @@
+/* __udivdi3.c: unsigned 64-bit by 64-bit division yielding 64-bit result
+ *
+ * Copyright (C) 2006 Red Hat, Inc. All Rights Reserved.
+ * Written by David Howells (dhowells@redhat.com)
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
+ */
+
+#include <linux/module.h>
+#include <linux/kernel.h>
+
+/*
+ * return a / b
+ */
+u64 __udivdi3(u64 a, u64 b)
+{
+	return __udivmoddi4(a, b, NULL);
+}
+
+EXPORT_SYMBOL(__udivdi3);
diff --git a/lib/__udivmoddi4.c b/lib/__udivmoddi4.c
new file mode 100644
index 0000000..b9a9f2a
--- /dev/null
+++ b/lib/__udivmoddi4.c
@@ -0,0 +1,99 @@
+/* __udivmoddi4.c: unsigned 64-bit by 64-bit division yielding 64-bit results
+ *
+ * Copyright (C) 2006 Red Hat, Inc. All Rights Reserved.
+ * Written by David Howells (dhowells@redhat.com)
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
+ */
+
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/bitops.h>
+#include <asm/div64.h>
+
+#define log2(n) (fls(n) - 1)
+
+/*
+ * calculate:
+ *	Q = a / b
+ *	R = a % b
+ * by long division (repeated shift and conditional subtract)
+ * - base2 long division does not require any usage of actual division or
+ *   multiplication instructions
+ */
+u64 __udivmoddi4(u64 a, u64 b, u64 *_r)
+{
+	u64 acc, Q;
+	u32 A;
+	int M;
+
+	/* dispose of trivialities first */
+	if (b >= a) {
+		if (b == a) {
+			if (_r)
+				*_r = 0;
+			return 1;
+		}
+		if (_r)
+			*_r = a;
+		return 0;
+	}
+
+	/* divide by two until at least one argument is odd */
+	while (!((a | b) & 1)) {
+		a >>= 1;
+		b >>= 1;
+	}
+
+	/* handle it as 64-bit divide by 32-bit if we can */
+	if (b <= 0xffffffffULL) {
+		acc = do_div(a, b);
+		if (_r)
+			*_r = acc;
+		return a;
+	}
+
+	/* skip any steps that don't need to be done given the magnitude of the
+	 * divisor:
+	 * - the divisor is at least 33 bits in size (log2(b) >= 32)
+	 * - load the accumulator with as many bits of the dividend as we can
+	 * - decant the remainder into a 32-bit variable since we will have
+	 *   fewer than 32-bits remaining
+	 */
+	M = log2(b >> 32) + 32;
+	acc = a >> (63 - M);
+	A = a;
+	A <<= M - 31;
+
+	Q = 0;
+
+	for (;;) {
+		if (acc >= b) {
+			/* reduce the accumulator if we can */
+			acc -= b;
+			Q |= 1ULL;
+		}
+
+		if (M >= 63)
+			break;
+
+		/* shift next-MSB from dividend into LSB of accumulator */
+		acc = acc << 1;
+		if (A & 0x80000000U)
+			acc |= 1ULL;
+		A <<= 1;
+		Q <<= 1;
+		M++;
+	}
+
+	/* the accumulator is left holding the remainder */
+	if (_r)
+		*_r = acc;
+
+	return Q;
+}
+
+EXPORT_SYMBOL(__udivmoddi4);
diff --git a/lib/__umoddi3.c b/lib/__umoddi3.c
new file mode 100644
index 0000000..7b99757
--- /dev/null
+++ b/lib/__umoddi3.c
@@ -0,0 +1,25 @@
+/* __umoddi3.c: unsigned 64-bit by 64-bit modulus yielding 64-bit result
+ *
+ * Copyright (C) 2006 Red Hat, Inc. All Rights Reserved.
+ * Written by David Howells (dhowells@redhat.com)
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
+ */
+
+#include <linux/module.h>
+#include <linux/kernel.h>
+
+/*
+ * return a % b
+ */
+u64 __umoddi3(u64 a, u64 b)
+{
+	u64 r;
+	__udivmoddi4(a, b, &r);
+	return r;
+}
+
+EXPORT_SYMBOL(__umoddi3);

Re: [RHEL5 PATCH 1/4] Provide fallback full 64-bit divide/modulus ops for gcc

[Jan Engelhardt]

> include/linux/kernel.h |    4 ++
> lib/Makefile           |    2 -
> lib/__udivdi3.c        |   23 +++++++++++
> lib/__udivmoddi4.c     |   99 ++++++++++++++++++++++++++++++++++++++++++++++++
> lib/__umoddi3.c        |   25 ++++++++++++

Umm, can we drop the __? Neither glibc nor gcc has underscores in the 
filenames of their udiv files.



Jan Engelhardt
-- 

Re: [RHEL5 PATCH 1/4] Provide fallback full 64-bit divide/modulus ops for gcc

[Andi Kleen]

David Howells <dhowells@redhat.com> writes:

> Provide simple, reasonably quick full 64-bit divide and modulus ops for gcc to
> call behind the scenes as:
> 
> 	__udivmoddi4
> 	__udivdi3
> 	__umoddi3

At least Linus' traditional argument against this is that it's better
to open code these (do_div) so that it's clear to the coder that they
are really costly.

-Andi

Re: [RHEL5 PATCH 1/4] Provide fallback full 64-bit divide/modulus ops for gcc

[David Howells]

Andi Kleen <ak@suse.de> wrote:

> At least Linus' traditional argument against this is that it's better
> to open code these (do_div) so that it's clear to the coder that they
> are really costly.

do_div() is not a full replacement for __udivdi3(), __umoddi3() or
__udivmoddi4(), though I suspect we don't need divisor >= 2^32 anywhere atm.

There are places where the compiler emits these that aren't entirely obvious,
one of which IIRC is in ext2 inode allocation.

David

Re: [RHEL5 PATCH 1/4] Provide fallback full 64-bit divide/modulus ops for gcc

[Pavel Machek]

On Tue 15-08-06 09:29:57, David Howells wrote:
> Andi Kleen <ak@suse.de> wrote:
> 
> > At least Linus' traditional argument against this is that it's better
> > to open code these (do_div) so that it's clear to the coder that they
> > are really costly.
> 
> do_div() is not a full replacement for __udivdi3(), __umoddi3() or
> __udivmoddi4(), though I suspect we don't need divisor >= 2^32 anywhere atm.
> 
> There are places where the compiler emits these that aren't entirely obvious,
> one of which IIRC is in ext2 inode allocation.

Well -- but that is good reason to keep that open-coded, right?

-- 
Thanks for all the (sleeping) penguins.

Re: [RHEL5 PATCH 1/4] Provide fallback full 64-bit divide/modulus ops for gcc

[David Howells]

Pavel Machek <pavel@suse.cz> wrote:

> > There are places where the compiler emits these that aren't entirely
> > obvious, one of which IIRC is in ext2 inode allocation.
> 
> Well -- but that is good reason to keep that open-coded, right?

Maybe.  I'm not sure I agree, but Linus is permitted to have differing
opinions.

Anyway, that set of patches has been superseded since Al didn't want it done
that way.

David

[RHEL5 PATCH 2/4] VFS: Make inode numbers 64-bits

[David Howells]

Make the in-kernel representations of inode number 64-bit in size at a minimum
as some network filesystems (eg: NFS) and local filesystems (eg: XFS) provide
such.

The 64-bit inode number will be returned through stat64() and getdents64() on
archs that are currently set up to do so.

This patch changes __kernel_ino_t to be "unsigned long long" on all archs, but
changes usages of that in struct stat to be the old type so that the userspace
interface does not change.  The 64-bit division patch is required to get this
to link on some archs.

struct inode::i_ino and struct kstat::ino have been converted to ino_t.
Neither needs moving within the bounds of its parent structure to make sure
that they reside on a 64-bit boundary if the structure itself does so.

Without this patch, on 32-bit archs, 64-bit inode numbers are rendered as
32-bit values, zero-extended to 64-bits for return through stat64() and
getdents64().  This can cause problems in userspace as programs such as ld.so
attempt to distinguish files based on their device and inode numbers.

Signed-Off-By: David Howells <dhowells@redhat.com>
---

 include/asm-alpha/posix_types.h   |    2 +-
 include/asm-arm/posix_types.h     |    2 +-
 include/asm-arm26/posix_types.h   |    2 +-
 include/asm-cris/posix_types.h    |    2 +-
 include/asm-frv/posix_types.h     |    2 +-
 include/asm-h8300/posix_types.h   |    2 +-
 include/asm-i386/posix_types.h    |    2 +-
 include/asm-ia64/posix_types.h    |    2 +-
 include/asm-m32r/posix_types.h    |    2 +-
 include/asm-m68k/posix_types.h    |    2 +-
 include/asm-mips/posix_types.h    |    2 +-
 include/asm-mips/stat.h           |    2 +-
 include/asm-parisc/posix_types.h  |    2 +-
 include/asm-parisc/stat.h         |    2 +-
 include/asm-powerpc/posix_types.h |    2 +-
 include/asm-powerpc/stat.h        |    2 +-
 include/asm-s390/posix_types.h    |    4 ++--
 include/asm-sh/posix_types.h      |    2 +-
 include/asm-sh64/posix_types.h    |    2 +-
 include/asm-sparc/posix_types.h   |    2 +-
 include/asm-sparc64/posix_types.h |    2 +-
 include/asm-sparc64/stat.h        |    2 +-
 include/asm-v850/posix_types.h    |    2 +-
 include/asm-x86_64/posix_types.h  |    2 +-
 include/asm-xtensa/posix_types.h  |    2 +-
 include/linux/fs.h                |    2 +-
 include/linux/stat.h              |    2 +-
 27 files changed, 28 insertions(+), 28 deletions(-)

diff --git a/include/asm-alpha/posix_types.h b/include/asm-alpha/posix_types.h
index c78c04a..bbc5a0f 100644
--- a/include/asm-alpha/posix_types.h
+++ b/include/asm-alpha/posix_types.h
@@ -7,7 +7,7 @@ #define _ALPHA_POSIX_TYPES_H
  * assume GCC is being used.
  */
 
-typedef unsigned int	__kernel_ino_t;
+typedef unsigned long long	__kernel_ino_t;
 typedef unsigned int	__kernel_mode_t;
 typedef unsigned int	__kernel_nlink_t;
 typedef long		__kernel_off_t;
diff --git a/include/asm-arm/posix_types.h b/include/asm-arm/posix_types.h
index e142a2a..708f9a1 100644
--- a/include/asm-arm/posix_types.h
+++ b/include/asm-arm/posix_types.h
@@ -19,7 +19,7 @@ #define __ARCH_ARM_POSIX_TYPES_H
  * assume GCC is being used.
  */
 
-typedef unsigned long		__kernel_ino_t;
+typedef unsigned long long	__kernel_ino_t;
 typedef unsigned short		__kernel_mode_t;
 typedef unsigned short		__kernel_nlink_t;
 typedef long			__kernel_off_t;
diff --git a/include/asm-arm26/posix_types.h b/include/asm-arm26/posix_types.h
index f8d1eb4..25b05b0 100644
--- a/include/asm-arm26/posix_types.h
+++ b/include/asm-arm26/posix_types.h
@@ -19,7 +19,7 @@ #define __ARCH_ARM_POSIX_TYPES_H
  * assume GCC is being used.
  */
 
-typedef unsigned long		__kernel_ino_t;
+typedef unsigned long long	__kernel_ino_t;
 typedef unsigned short		__kernel_mode_t;
 typedef unsigned short		__kernel_nlink_t;
 typedef long			__kernel_off_t;
diff --git a/include/asm-cris/posix_types.h b/include/asm-cris/posix_types.h
index 6d26fee..c1ce6f3 100644
--- a/include/asm-cris/posix_types.h
+++ b/include/asm-cris/posix_types.h
@@ -14,7 +14,7 @@ #include <asm/bitops.h>
  * assume GCC is being used.
  */
 
-typedef unsigned long	__kernel_ino_t;
+typedef unsigned long long __kernel_ino_t;
 typedef unsigned short	__kernel_mode_t;
 typedef unsigned short	__kernel_nlink_t;
 typedef long		__kernel_off_t;
diff --git a/include/asm-frv/posix_types.h b/include/asm-frv/posix_types.h
index 73c2ba8..1522ea9 100644
--- a/include/asm-frv/posix_types.h
+++ b/include/asm-frv/posix_types.h
@@ -7,7 +7,7 @@ #define _ASM_POSIX_TYPES_H
  * assume GCC is being used.
  */
 
-typedef unsigned long	__kernel_ino_t;
+typedef unsigned long long	__kernel_ino_t;
 typedef unsigned short	__kernel_mode_t;
 typedef unsigned short	__kernel_nlink_t;
 typedef long		__kernel_off_t;
diff --git a/include/asm-h8300/posix_types.h b/include/asm-h8300/posix_types.h
index 7de94b1..0122b26 100644
--- a/include/asm-h8300/posix_types.h
+++ b/include/asm-h8300/posix_types.h
@@ -7,7 +7,7 @@ #define __ARCH_H8300_POSIX_TYPES_H
  * assume GCC is being used.
  */
 
-typedef unsigned long	__kernel_ino_t;
+typedef unsigned long long	__kernel_ino_t;
 typedef unsigned short	__kernel_mode_t;
 typedef unsigned short	__kernel_nlink_t;
 typedef long		__kernel_off_t;
diff --git a/include/asm-i386/posix_types.h b/include/asm-i386/posix_types.h
index 133e31e..1c4d743 100644
--- a/include/asm-i386/posix_types.h
+++ b/include/asm-i386/posix_types.h
@@ -7,7 +7,7 @@ #define __ARCH_I386_POSIX_TYPES_H
  * assume GCC is being used.
  */
 
-typedef unsigned long	__kernel_ino_t;
+typedef unsigned long long	__kernel_ino_t;
 typedef unsigned short	__kernel_mode_t;
 typedef unsigned short	__kernel_nlink_t;
 typedef long		__kernel_off_t;
diff --git a/include/asm-ia64/posix_types.h b/include/asm-ia64/posix_types.h
index adb6227..37169ee 100644
--- a/include/asm-ia64/posix_types.h
+++ b/include/asm-ia64/posix_types.h
@@ -12,7 +12,7 @@ #define _ASM_IA64_POSIX_TYPES_H
  *	David Mosberger-Tang <davidm@hpl.hp.com>, Hewlett-Packard Co
  */
 
-typedef unsigned long	__kernel_ino_t;
+typedef unsigned long long	__kernel_ino_t;
 typedef unsigned int	__kernel_mode_t;
 typedef unsigned int	__kernel_nlink_t;
 typedef long		__kernel_off_t;
diff --git a/include/asm-m32r/posix_types.h b/include/asm-m32r/posix_types.h
index 47e7e85..46e0a65 100644
--- a/include/asm-m32r/posix_types.h
+++ b/include/asm-m32r/posix_types.h
@@ -11,7 +11,7 @@ #define _ASM_M32R_POSIX_TYPES_H
  * assume GCC is being used.
  */
 
-typedef unsigned long	__kernel_ino_t;
+typedef unsigned long long	__kernel_ino_t;
 typedef unsigned short	__kernel_mode_t;
 typedef unsigned short	__kernel_nlink_t;
 typedef long		__kernel_off_t;
diff --git a/include/asm-m68k/posix_types.h b/include/asm-m68k/posix_types.h
index fa166ee..6152981 100644
--- a/include/asm-m68k/posix_types.h
+++ b/include/asm-m68k/posix_types.h
@@ -7,7 +7,7 @@ #define __ARCH_M68K_POSIX_TYPES_H
  * assume GCC is being used.
  */
 
-typedef unsigned long	__kernel_ino_t;
+typedef unsigned long long	__kernel_ino_t;
 typedef unsigned short	__kernel_mode_t;
 typedef unsigned short	__kernel_nlink_t;
 typedef long		__kernel_off_t;
diff --git a/include/asm-mips/posix_types.h b/include/asm-mips/posix_types.h
index c2e8a00..8e3e3f5 100644
--- a/include/asm-mips/posix_types.h
+++ b/include/asm-mips/posix_types.h
@@ -17,7 +17,7 @@ #include <asm/sgidefs.h>
  * assume GCC is being used.
  */
 
-typedef unsigned long	__kernel_ino_t;
+typedef unsigned long long	__kernel_ino_t;
 typedef unsigned int	__kernel_mode_t;
 #if (_MIPS_SZLONG == 32)
 typedef unsigned long	__kernel_nlink_t;
diff --git a/include/asm-mips/stat.h b/include/asm-mips/stat.h
index 6e00f75..32e5c45 100644
--- a/include/asm-mips/stat.h
+++ b/include/asm-mips/stat.h
@@ -18,7 +18,7 @@ #if (_MIPS_SIM == _MIPS_SIM_ABI32) || (_
 struct stat {
 	unsigned	st_dev;
 	long		st_pad1[3];		/* Reserved for network id */
-	ino_t		st_ino;
+	unsigned long	st_ino;
 	mode_t		st_mode;
 	nlink_t		st_nlink;
 	uid_t		st_uid;
diff --git a/include/asm-parisc/posix_types.h b/include/asm-parisc/posix_types.h
index 9b19970..1e63cdf 100644
--- a/include/asm-parisc/posix_types.h
+++ b/include/asm-parisc/posix_types.h
@@ -6,7 +6,7 @@ #define __ARCH_PARISC_POSIX_TYPES_H
  * be a little careful about namespace pollution etc.  Also, we cannot
  * assume GCC is being used.
  */
-typedef unsigned long		__kernel_ino_t;
+typedef unsigned long long	__kernel_ino_t;
 typedef unsigned short		__kernel_mode_t;
 typedef unsigned short		__kernel_nlink_t;
 typedef long			__kernel_off_t;
diff --git a/include/asm-parisc/stat.h b/include/asm-parisc/stat.h
index 9d5fbbc..399a109 100644
--- a/include/asm-parisc/stat.h
+++ b/include/asm-parisc/stat.h
@@ -40,7 +40,7 @@ typedef __kernel_off64_t	off64_t;
 
 struct hpux_stat64 {
 	unsigned int	st_dev;		/* dev_t is 32 bits on parisc */
-	ino_t           st_ino;         /* 32 bits */
+	unsigned long   st_ino;         /* 32 bits */
 	mode_t		st_mode;	/* 16 bits */
 	nlink_t		st_nlink;	/* 16 bits */
 	unsigned short	st_reserved1;	/* old st_uid */
diff --git a/include/asm-powerpc/posix_types.h b/include/asm-powerpc/posix_types.h
index c639107..72d5047 100644
--- a/include/asm-powerpc/posix_types.h
+++ b/include/asm-powerpc/posix_types.h
@@ -7,7 +7,7 @@ #define _ASM_POWERPC_POSIX_TYPES_H
  * assume GCC is being used.
  */
 
-typedef unsigned long	__kernel_ino_t;
+typedef unsigned long long	__kernel_ino_t;
 typedef unsigned int	__kernel_mode_t;
 typedef long		__kernel_off_t;
 typedef int		__kernel_pid_t;
diff --git a/include/asm-powerpc/stat.h b/include/asm-powerpc/stat.h
index e4edc51..02dd186 100644
--- a/include/asm-powerpc/stat.h
+++ b/include/asm-powerpc/stat.h
@@ -28,7 +28,7 @@ #endif /* !__powerpc64__ */
 
 struct stat {
 	unsigned long	st_dev;
-	ino_t		st_ino;
+	unsigned long	st_ino;
 #ifdef __powerpc64__
 	nlink_t		st_nlink;
 	mode_t		st_mode;
diff --git a/include/asm-s390/posix_types.h b/include/asm-s390/posix_types.h
index b94c988..c853731 100644
--- a/include/asm-s390/posix_types.h
+++ b/include/asm-s390/posix_types.h
@@ -34,7 +34,7 @@ #endif
 
 #ifndef __s390x__
 
-typedef unsigned long   __kernel_ino_t;
+typedef unsigned long long   __kernel_ino_t;
 typedef unsigned short  __kernel_mode_t;
 typedef unsigned short  __kernel_nlink_t;
 typedef unsigned short  __kernel_ipc_pid_t;
@@ -50,7 +50,7 @@ typedef unsigned short	__kernel_old_dev_
 
 #else /* __s390x__ */
 
-typedef unsigned int    __kernel_ino_t;
+typedef unsigned long long    __kernel_ino_t;
 typedef unsigned int    __kernel_mode_t;
 typedef unsigned int    __kernel_nlink_t;
 typedef int             __kernel_ipc_pid_t;
diff --git a/include/asm-sh/posix_types.h b/include/asm-sh/posix_types.h
index 0a3d2f5..7a2d0b7 100644
--- a/include/asm-sh/posix_types.h
+++ b/include/asm-sh/posix_types.h
@@ -7,7 +7,7 @@ #define __ASM_SH_POSIX_TYPES_H
  * assume GCC is being used.
  */
 
-typedef unsigned long	__kernel_ino_t;
+typedef unsigned long long	__kernel_ino_t;
 typedef unsigned short	__kernel_mode_t;
 typedef unsigned short	__kernel_nlink_t;
 typedef long		__kernel_off_t;
diff --git a/include/asm-sh64/posix_types.h b/include/asm-sh64/posix_types.h
index 0620317..affa4b7 100644
--- a/include/asm-sh64/posix_types.h
+++ b/include/asm-sh64/posix_types.h
@@ -16,7 +16,7 @@ #define __ASM_SH64_POSIX_TYPES_H
  * assume GCC is being used.
  */
 
-typedef unsigned long	__kernel_ino_t;
+typedef unsigned long long	__kernel_ino_t;
 typedef unsigned short	__kernel_mode_t;
 typedef unsigned short	__kernel_nlink_t;
 typedef long		__kernel_off_t;
diff --git a/include/asm-sparc/posix_types.h b/include/asm-sparc/posix_types.h
index 9ef1b3d..0d4a5fe 100644
--- a/include/asm-sparc/posix_types.h
+++ b/include/asm-sparc/posix_types.h
@@ -17,7 +17,7 @@ typedef int                    __kernel_
 typedef unsigned short         __kernel_ipc_pid_t;
 typedef unsigned short         __kernel_uid_t;
 typedef unsigned short         __kernel_gid_t;
-typedef unsigned long          __kernel_ino_t;
+typedef unsigned long long     __kernel_ino_t;
 typedef unsigned short         __kernel_mode_t;
 typedef unsigned short         __kernel_umode_t;
 typedef short                  __kernel_nlink_t;
diff --git a/include/asm-sparc64/posix_types.h b/include/asm-sparc64/posix_types.h
index c86b945..3cbba61 100644
--- a/include/asm-sparc64/posix_types.h
+++ b/include/asm-sparc64/posix_types.h
@@ -16,7 +16,7 @@ typedef int                    __kernel_
 typedef int                    __kernel_ipc_pid_t;
 typedef unsigned int           __kernel_uid_t;
 typedef unsigned int           __kernel_gid_t;
-typedef unsigned long          __kernel_ino_t;
+typedef unsigned long long     __kernel_ino_t;
 typedef unsigned int           __kernel_mode_t;
 typedef unsigned short         __kernel_umode_t;
 typedef unsigned int           __kernel_nlink_t;
diff --git a/include/asm-sparc64/stat.h b/include/asm-sparc64/stat.h
index 128c27e..644dc4d 100644
--- a/include/asm-sparc64/stat.h
+++ b/include/asm-sparc64/stat.h
@@ -6,7 +6,7 @@ #include <linux/types.h>
 
 struct stat {
 	unsigned   st_dev;
-	ino_t   st_ino;
+	unsigned long   st_ino;
 	mode_t  st_mode;
 	short   st_nlink;
 	uid_t   st_uid;
diff --git a/include/asm-v850/posix_types.h b/include/asm-v850/posix_types.h
index ccb7297..ea6ccb6 100644
--- a/include/asm-v850/posix_types.h
+++ b/include/asm-v850/posix_types.h
@@ -14,7 +14,7 @@
 #ifndef __V850_POSIX_TYPES_H__
 #define __V850_POSIX_TYPES_H__
 
-typedef unsigned long	__kernel_ino_t;
+typedef unsigned long long __kernel_ino_t;
 typedef unsigned long long __kernel_ino64_t;
 typedef unsigned int	__kernel_mode_t;
 typedef unsigned int	__kernel_nlink_t;
diff --git a/include/asm-x86_64/posix_types.h b/include/asm-x86_64/posix_types.h
index 9926aa4..c287564 100644
--- a/include/asm-x86_64/posix_types.h
+++ b/include/asm-x86_64/posix_types.h
@@ -7,7 +7,7 @@ #define _ASM_X86_64_POSIX_TYPES_H
  * assume GCC is being used.
  */
 
-typedef unsigned long	__kernel_ino_t;
+typedef unsigned long long	__kernel_ino_t;
 typedef unsigned int	__kernel_mode_t;
 typedef unsigned long	__kernel_nlink_t;
 typedef long		__kernel_off_t;
diff --git a/include/asm-xtensa/posix_types.h b/include/asm-xtensa/posix_types.h
index 2c816b0..30b8ca4 100644
--- a/include/asm-xtensa/posix_types.h
+++ b/include/asm-xtensa/posix_types.h
@@ -19,7 +19,7 @@ #define _XTENSA_POSIX_TYPES_H
  * assume GCC is being used.
  */
 
-typedef unsigned long	__kernel_ino_t;
+typedef unsigned long long	__kernel_ino_t;
 typedef unsigned int	__kernel_mode_t;
 typedef unsigned short	__kernel_nlink_t;
 typedef long		__kernel_off_t;
diff --git a/include/linux/fs.h b/include/linux/fs.h
index 3cc9657..caa9182 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -499,7 +499,7 @@ struct inode {
 	struct list_head	i_list;
 	struct list_head	i_sb_list;
 	struct list_head	i_dentry;
-	unsigned long		i_ino;
+	ino_t			i_ino;
 	atomic_t		i_count;
 	umode_t			i_mode;
 	unsigned int		i_nlink;
diff --git a/include/linux/stat.h b/include/linux/stat.h
index 8669291..967cfbe 100644
--- a/include/linux/stat.h
+++ b/include/linux/stat.h
@@ -57,7 +57,7 @@ #include <linux/types.h>
 #include <linux/time.h>
 
 struct kstat {
-	unsigned long	ino;
+	ino_t		ino;
 	dev_t		dev;
 	umode_t		mode;
 	unsigned int	nlink;

Re: [RHEL5 PATCH 2/4] VFS: Make inode numbers 64-bits

[Al Viro]

On Mon, Aug 14, 2006 at 10:15:09PM +0100, David Howells wrote:
> Make the in-kernel representations of inode number 64-bit in size at a minimum
> as some network filesystems (eg: NFS) and local filesystems (eg: XFS) provide
> such.
> 
> The 64-bit inode number will be returned through stat64() and getdents64() on
> archs that are currently set up to do so.
> 
> This patch changes __kernel_ino_t to be "unsigned long long" on all archs, but
> changes usages of that in struct stat to be the old type so that the userspace
> interface does not change.  The 64-bit division patch is required to get this
> to link on some archs.
> 
> struct inode::i_ino and struct kstat::ino have been converted to ino_t.
> Neither needs moving within the bounds of its parent structure to make sure
> that they reside on a 64-bit boundary if the structure itself does so.

NAK.  There's no need to touch i_ino and a lot of reasons for not doing
that.  ->getattr() can fill 64bit field just fine without that and there's
zero need to touch every fs out there *and* add cycles on icache lookups.
WTF for?

Filesystems that want 64bit values in st_ino are welcome to
	* set it in ->getattr() and
	* use iget5()

Less PITA for everyone and less intrusive patch that way.

Re: [RHEL5 PATCH 2/4] VFS: Make inode numbers 64-bits

[David Howells]

Al Viro <viro@ftp.linux.org.uk> wrote:

> NAK.  There's no need to touch i_ino and a lot of reasons for not doing
> that.  ->getattr() can fill 64bit field just fine without that and there's
> zero need to touch every fs out there *and* add cycles on icache lookups.
> WTF for?

That doesn't fix getdents64() though...

David

Re: [RHEL5 PATCH 2/4] VFS: Make inode numbers 64-bits

[Al Viro]

On Tue, Aug 15, 2006 at 09:21:11AM +0100, David Howells wrote:
> Al Viro <viro@ftp.linux.org.uk> wrote:
> 
> > NAK.  There's no need to touch i_ino and a lot of reasons for not doing
> > that.  ->getattr() can fill 64bit field just fine without that and there's
> > zero need to touch every fs out there *and* add cycles on icache lookups.
> > WTF for?
> 
> That doesn't fix getdents64() though...

Good grief...  Make filldir() eat u64 explicitly and fix all of a dozen
instances.  End of story.

Re: [RHEL5 PATCH 2/4] VFS: Make inode numbers 64-bits

[David Howells]

Al Viro <viro@ftp.linux.org.uk> wrote:

> NAK.  There's no need to touch i_ino and a lot of reasons for not doing
> that.

Like all those printks that write ambiguous messages because they can't report
the full inode number?  I'm not so worried about those because they're for the
most part debugging messages, but still, they *can* report invalid information
because i_ino is not big enough in error and warning messages.

David

Re: [RHEL5 PATCH 2/4] VFS: Make inode numbers 64-bits

[Al Viro]

On Tue, Aug 15, 2006 at 09:32:57AM +0100, David Howells wrote:
> Al Viro <viro@ftp.linux.org.uk> wrote:
> 
> > NAK.  There's no need to touch i_ino and a lot of reasons for not doing
> > that.
> 
> Like all those printks that write ambiguous messages because they can't report
> the full inode number?  I'm not so worried about those because they're for the
> most part debugging messages, but still, they *can* report invalid information
> because i_ino is not big enough in error and warning messages.

In fs-independent code?  How many of those do we actually have?

Re: [RHEL5 PATCH 2/4] VFS: Make inode numbers 64-bits

[David Howells]

Al Viro <viro@ftp.linux.org.uk> wrote:

> In fs-independent code?  How many of those do we actually have?

At most about half a dozen.  Depends whether you include pipes and eventpoll
in that.  There's an instance in fs/dcache.c and one in fs/fs-writeback.c

find_inode_number() is also a potential problem, though I suppose we have to
say you may not use it if 0 is a valid thing to have in i_ino.

Interestingly, one of these also touches userspace: /proc/locks passes the
inode number out, but will pass the wrong one if i_ino is too short.  Does
anything in userspace actually use that?

David

Re: [RHEL5 PATCH 2/4] VFS: Make inode numbers 64-bits

[Stephen Rothwell]

[-- Attachment #1: Type: text/plain, Size: 471 bytes --]

On Tue, 15 Aug 2006 10:25:47 +0100 David Howells <dhowells@redhat.com> wrote:
>
> Interestingly, one of these also touches userspace: /proc/locks passes the
> inode number out, but will pass the wrong one if i_ino is too short.  Does
> anything in userspace actually use that?

As far as I know, /proc/locks is just useful for debugging the locking code.

-- 
Cheers,
Stephen Rothwell                    sfr@canb.auug.org.au
http://www.canb.auug.org.au/~sfr/

[-- Attachment #2: Type: application/pgp-signature, Size: 189 bytes --]

Re: [RHEL5 PATCH 2/4] VFS: Make inode numbers 64-bits

[Jan Engelhardt]

>This patch changes __kernel_ino_t to be "unsigned long long" on all

Why not "uint64_t" (or u64)?


>--- a/include/asm-mips/stat.h
>+++ b/include/asm-mips/stat.h
>@@ -18,7 +18,7 @@ #if (_MIPS_SIM == _MIPS_SIM_ABI32) || (_
> struct stat {
> 	unsigned	st_dev;
> 	long		st_pad1[3];		/* Reserved for network id */
>-	ino_t		st_ino;
>+	unsigned long	st_ino;
> 	mode_t		st_mode;
> 	nlink_t		st_nlink;
> 	uid_t		st_uid;

Will the kernel still fold 64-bit inums to 32-bit for stat[32]()?


Jan Engelhardt
-- 

[RHEL5 PATCH 3/4] VFS: Clear up u-long-long ino_t print format warnings

[David Howells]

Clear up the warnings generated by -Wformat when converting ino_t to 64-bits.

Signed-Off-By: David Howells <dhowells@redhat.com>
---

 fs/9p/vfs_inode.c        |   12 ++++++-----
 fs/afs/dir.c             |    2 +-
 fs/bfs/dir.c             |    4 ++--
 fs/coda/dir.c            |    6 +++---
 fs/coda/inode.c          |    2 +-
 fs/dcache.c              |    2 +-
 fs/efs/inode.c           |    4 ++--
 fs/eventpoll.c           |    2 +-
 fs/ext2/dir.c            |    9 +++++---
 fs/ext2/inode.c          |    2 +-
 fs/ext2/xattr.c          |   12 ++++++-----
 fs/ext3/dir.c            |    4 ++--
 fs/ext3/inode.c          |    6 +++---
 fs/ext3/namei.c          |   24 +++++++++++-----------
 fs/ext3/super.c          |   10 +++++----
 fs/ext3/xattr.c          |   14 ++++++-------
 fs/freevxfs/vxfs_bmap.c  |    4 ++--
 fs/fs-writeback.c        |    2 +-
 fs/hfs/catalog.c         |    2 +-
 fs/hfs/extent.c          |    4 ++--
 fs/hfs/inode.c           |    4 ++--
 fs/hfsplus/catalog.c     |    2 +-
 fs/hfsplus/dir.c         |    2 +-
 fs/hfsplus/extents.c     |    6 +++---
 fs/hfsplus/super.c       |    4 ++--
 fs/isofs/compress.c      |    8 ++++---
 fs/isofs/inode.c         |    4 ++--
 fs/jbd/journal.c         |    2 +-
 fs/jffs/inode-v23.c      |    4 ++--
 fs/jfs/jfs_imap.c        |    2 +-
 fs/jfs/jfs_metapage.c    |    2 +-
 fs/lockd/svclock.c       |    8 ++++---
 fs/lockd/svcsubs.c       |    2 +-
 fs/locks.c               |    2 +-
 fs/minix/inode.c         |    2 +-
 fs/nfs/dir.c             |   20 +++++++++---------
 fs/nfs/file.c            |   10 +++++----
 fs/nfs/inode.c           |   10 +++++----
 fs/nfs/nfs3acl.c         |    6 +++---
 fs/nfsd/export.c         |    2 +-
 fs/nfsd/nfsfh.c          |    4 ++--
 fs/ntfs/aops.c           |    6 +++---
 fs/ntfs/attrib.c         |   20 +++++++++---------
 fs/ntfs/bitmap.c         |    2 +-
 fs/ntfs/dir.c            |   24 +++++++++++-----------
 fs/ntfs/file.c           |   26 ++++++++++++------------
 fs/ntfs/inode.c          |   50 +++++++++++++++++++++++-----------------------
 fs/ntfs/namei.c          |   12 ++++++-----
 fs/ocfs2/aops.c          |    4 ++--
 fs/ocfs2/dlm/dlmfs.c     |   12 ++++++-----
 fs/ocfs2/inode.c         |   20 +++++++++---------
 fs/ocfs2/namei.c         |    8 ++++---
 fs/ocfs2/vote.c          |    2 +-
 fs/pipe.c                |    2 +-
 fs/smbfs/inode.c         |    2 +-
 fs/sysv/inode.c          |    2 +-
 fs/udf/inode.c           |    8 ++++---
 fs/ufs/balloc.c          |    6 +++---
 fs/ufs/dir.c             |   10 +++++----
 fs/ufs/ialloc.c          |    4 ++--
 fs/ufs/inode.c           |   26 ++++++++++++------------
 fs/ufs/util.c            |    4 ++--
 net/ax25/af_ax25.c       |    4 ++--
 net/netrom/af_netrom.c   |    4 ++--
 net/rose/af_rose.c       |    4 ++--
 net/socket.c             |    2 +-
 net/x25/x25_proc.c       |    4 ++--
 security/selinux/avc.c   |    2 +-
 security/selinux/hooks.c |    8 ++++---
 69 files changed, 256 insertions(+), 255 deletions(-)

diff --git a/fs/9p/vfs_inode.c b/fs/9p/vfs_inode.c
index eae50c9..5e4a891 100644
--- a/fs/9p/vfs_inode.c
+++ b/fs/9p/vfs_inode.c
@@ -426,7 +426,7 @@ static int v9fs_remove(struct inode *dir
 
 	fid = v9fid->fid;
 	if (fid < 0) {
-		dprintk(DEBUG_ERROR, "inode #%lu, no fid!\n",
+		dprintk(DEBUG_ERROR, "inode #%llu, no fid!\n",
 			file_inode->i_ino);
 		return -EBADF;
 	}
@@ -631,7 +631,7 @@ static struct dentry *v9fs_vfs_lookup(st
 	dirfidnum = dirfid->fid;
 
 	if (dirfidnum < 0) {
-		dprintk(DEBUG_ERROR, "no dirfid for inode %p, #%lu\n",
+		dprintk(DEBUG_ERROR, "no dirfid for inode %p, #%llu\n",
 			dir, dir->i_ino);
 		return ERR_PTR(-EBADF);
 	}
@@ -777,7 +777,7 @@ v9fs_vfs_rename(struct inode *old_dir, s
 	newdirfidnum = newdirfid->fid;
 
 	if (fid < 0) {
-		dprintk(DEBUG_ERROR, "no fid for old file #%lu\n",
+		dprintk(DEBUG_ERROR, "no fid for old file #%llu\n",
 			old_inode->i_ino);
 		retval = -EBADF;
 		goto FreeFcallnBail;
@@ -1188,7 +1188,7 @@ error:
 static int
 v9fs_vfs_symlink(struct inode *dir, struct dentry *dentry, const char *symname)
 {
-	dprintk(DEBUG_VFS, " %lu,%s,%s\n", dir->i_ino, dentry->d_name.name,
+	dprintk(DEBUG_VFS, " %llu,%s,%s\n", dir->i_ino, dentry->d_name.name,
 		symname);
 
 	return v9fs_vfs_mkspecial(dir, dentry, S_IFLNK, symname);
@@ -1214,7 +1214,7 @@ v9fs_vfs_link(struct dentry *old_dentry,
 	struct v9fs_fid *oldfid;
 	char *name;
 
-	dprintk(DEBUG_VFS, " %lu,%s,%s\n", dir->i_ino, dentry->d_name.name,
+	dprintk(DEBUG_VFS, " %llu,%s,%s\n", dir->i_ino, dentry->d_name.name,
 		old_dentry->d_name.name);
 
 	oldfid = v9fs_fid_lookup(old_dentry);
@@ -1249,7 +1249,7 @@ v9fs_vfs_mknod(struct inode *dir, struct
 	int retval;
 	char *name;
 
-	dprintk(DEBUG_VFS, " %lu,%s mode: %x MAJOR: %u MINOR: %u\n", dir->i_ino,
+	dprintk(DEBUG_VFS, " %llu,%s mode: %x MAJOR: %u MINOR: %u\n", dir->i_ino,
 		dentry->d_name.name, mode, MAJOR(rdev), MINOR(rdev));
 
 	if (!new_valid_dev(rdev))
diff --git a/fs/afs/dir.c b/fs/afs/dir.c
index 9800a07..e7da8a1 100644
--- a/fs/afs/dir.c
+++ b/fs/afs/dir.c
@@ -148,7 +148,7 @@ #endif
 	dbuf = kmap_atomic(page, KM_USER0);
 	for (tmp = 0; tmp < qty; tmp++) {
 		if (dbuf->blocks[tmp].pagehdr.magic != AFS_DIR_MAGIC) {
-			printk("kAFS: %s(%lu): bad magic %d/%d is %04hx\n",
+			printk("kAFS: %s(%llu): bad magic %d/%d is %04hx\n",
 			       __FUNCTION__, dir->i_ino, tmp, qty,
 			       ntohs(dbuf->blocks[tmp].pagehdr.magic));
 			goto error;
diff --git a/fs/bfs/dir.c b/fs/bfs/dir.c
index 26fad96..03539ad 100644
--- a/fs/bfs/dir.c
+++ b/fs/bfs/dir.c
@@ -36,7 +36,7 @@ static int bfs_readdir(struct file * f, 
 	lock_kernel();
 
 	if (f->f_pos & (BFS_DIRENT_SIZE-1)) {
-		printf("Bad f_pos=%08lx for %s:%08lx\n", (unsigned long)f->f_pos, 
+		printf("Bad f_pos=%08lx for %s:%08llx\n", (unsigned long)f->f_pos, 
 			dir->i_sb->s_id, dir->i_ino);
 		unlock_kernel();
 		return -EBADF;
@@ -188,7 +188,7 @@ static int bfs_unlink(struct inode * dir
 		goto out_brelse;
 
 	if (!inode->i_nlink) {
-		printf("unlinking non-existent file %s:%lu (nlink=%d)\n", inode->i_sb->s_id, 
+		printf("unlinking non-existent file %s:%llu (nlink=%d)\n", inode->i_sb->s_id, 
 				inode->i_ino, inode->i_nlink);
 		inode->i_nlink = 1;
 	}
diff --git a/fs/coda/dir.c b/fs/coda/dir.c
index 71f2ea6..62d2028 100644
--- a/fs/coda/dir.c
+++ b/fs/coda/dir.c
@@ -543,14 +543,14 @@ static int coda_venus_readdir(struct fil
 
 		/* catch truncated reads */
 		if (ret < vdir_size || ret < vdir_size + vdir->d_namlen) {
-			printk("coda_venus_readdir: short read: %ld\n",
+			printk("coda_venus_readdir: short read: %lld\n",
 			       filp->f_dentry->d_inode->i_ino);
 			ret = -EBADF;
 			break;
 		}
 		/* validate whether the directory file actually makes sense */
 		if (vdir->d_reclen < vdir_size + vdir->d_namlen) {
-			printk("coda_venus_readdir: Invalid dir: %ld\n",
+			printk("coda_venus_readdir: Invalid dir: %lld\n",
 			       filp->f_dentry->d_inode->i_ino);
 			ret = -EBADF;
 			break;
@@ -682,7 +682,7 @@ int coda_revalidate_inode(struct dentry 
 		coda_vattr_to_iattr(inode, &attr);
 
 		if ((old_mode & S_IFMT) != (inode->i_mode & S_IFMT)) {
-			printk("Coda: inode %ld, fid %s changed type!\n",
+			printk("Coda: inode %lld, fid %s changed type!\n",
 			       inode->i_ino, coda_f2s(&(cii->c_fid)));
 		}
 
diff --git a/fs/coda/inode.c b/fs/coda/inode.c
index 87f1dc8..f781325 100644
--- a/fs/coda/inode.c
+++ b/fs/coda/inode.c
@@ -202,7 +202,7 @@ static int coda_fill_super(struct super_
 	    goto error;
 	} 
 
-	printk("coda_read_super: rootinode is %ld dev %s\n", 
+	printk("coda_read_super: rootinode is %lld dev %s\n", 
 	       root->i_ino, root->i_sb->s_id);
 	sb->s_root = d_alloc_root(root);
 	if (!sb->s_root)
diff --git a/fs/dcache.c b/fs/dcache.c
index 7579b87..9dee659 100644
--- a/fs/dcache.c
+++ b/fs/dcache.c
@@ -598,7 +598,7 @@ static void shrink_dcache_for_umount_sub
 
 			if (atomic_read(&dentry->d_count) != 0) {
 				printk(KERN_ERR
-				       "BUG: Dentry %p{i=%lx,n=%s}"
+				       "BUG: Dentry %p{i=%llx,n=%s}"
 				       " still in use (%d)"
 				       " [unmount of %s %s]\n",
 				       dentry,
diff --git a/fs/efs/inode.c b/fs/efs/inode.c
index 174696f..a17f8c5 100644
--- a/fs/efs/inode.c
+++ b/fs/efs/inode.c
@@ -122,7 +122,7 @@ void efs_read_inode(struct inode *inode)
 	for(i = 0; i < EFS_DIRECTEXTENTS; i++) {
 		extent_copy(&(efs_inode->di_u.di_extents[i]), &(in->extents[i]));
 		if (i < in->numextents && in->extents[i].cooked.ex_magic != 0) {
-			printk(KERN_WARNING "EFS: extent %d has bad magic number in inode %lu\n", i, inode->i_ino);
+			printk(KERN_WARNING "EFS: extent %d has bad magic number in inode %llu\n", i, inode->i_ino);
 			brelse(bh);
 			goto read_inode_error;
 		}
@@ -162,7 +162,7 @@ #endif
 	return;
         
 read_inode_error:
-	printk(KERN_WARNING "EFS: failed to read inode %lu\n", inode->i_ino);
+	printk(KERN_WARNING "EFS: failed to read inode %llu\n", inode->i_ino);
 	make_bad_inode(inode);
 
 	return;
diff --git a/fs/eventpoll.c b/fs/eventpoll.c
index 19ffb04..9f7011a 100644
--- a/fs/eventpoll.c
+++ b/fs/eventpoll.c
@@ -735,7 +735,7 @@ static int ep_getfd(int *efd, struct ino
 	 * using the inode number.
 	 */
 	error = -ENOMEM;
-	sprintf(name, "[%lu]", inode->i_ino);
+	sprintf(name, "[%llu]", inode->i_ino);
 	this.name = name;
 	this.len = strlen(name);
 	this.hash = inode->i_ino;
diff --git a/fs/ext2/dir.c b/fs/ext2/dir.c
index b0e7d9f..1cfe560 100644
--- a/fs/ext2/dir.c
+++ b/fs/ext2/dir.c
@@ -119,7 +119,7 @@ out:
 
 Ebadsize:
 	ext2_error(sb, "ext2_check_page",
-		"size of directory #%lu is not a multiple of chunk size",
+		"size of directory #%llu is not a multiple of chunk size",
 		dir->i_ino
 	);
 	goto fail;
@@ -138,7 +138,8 @@ Espan:
 Einumber:
 	error = "inode out of bounds";
 bad_entry:
-	ext2_error (sb, "ext2_check_page", "bad entry in directory #%lu: %s - "
+	ext2_error (sb, "ext2_check_page",
+		"bad entry in directory #%llu: %s - "
 		"offset=%lu, inode=%lu, rec_len=%d, name_len=%d",
 		dir->i_ino, error, (page->index<<PAGE_CACHE_SHIFT)+offs,
 		(unsigned long) le32_to_cpu(p->inode),
@@ -147,7 +148,7 @@ bad_entry:
 Eend:
 	p = (ext2_dirent *)(kaddr + offs);
 	ext2_error (sb, "ext2_check_page",
-		"entry in directory #%lu spans the page boundary"
+		"entry in directory #%llu spans the page boundary"
 		"offset=%lu, inode=%lu",
 		dir->i_ino, (page->index<<PAGE_CACHE_SHIFT)+offs,
 		(unsigned long) le32_to_cpu(p->inode));
@@ -270,7 +271,7 @@ ext2_readdir (struct file * filp, void *
 
 		if (IS_ERR(page)) {
 			ext2_error(sb, __FUNCTION__,
-				   "bad page in #%lu",
+				   "bad page in #%llu",
 				   inode->i_ino);
 			filp->f_pos += PAGE_CACHE_SIZE - offset;
 			return -EIO;
diff --git a/fs/ext2/inode.c b/fs/ext2/inode.c
index fb4d322..da3d2df 100644
--- a/fs/ext2/inode.c
+++ b/fs/ext2/inode.c
@@ -880,7 +880,7 @@ static void ext2_free_branches(struct in
 			 */ 
 			if (!bh) {
 				ext2_error(inode->i_sb, "ext2_free_branches",
-					"Read failure, inode=%ld, block=%ld",
+					"Read failure, inode=%lld, block=%ld",
 					inode->i_ino, nr);
 				continue;
 			}
diff --git a/fs/ext2/xattr.c b/fs/ext2/xattr.c
index 86ae8e9..aa90c6f 100644
--- a/fs/ext2/xattr.c
+++ b/fs/ext2/xattr.c
@@ -175,7 +175,7 @@ ext2_xattr_get(struct inode *inode, int 
 	if (HDR(bh)->h_magic != cpu_to_le32(EXT2_XATTR_MAGIC) ||
 	    HDR(bh)->h_blocks != cpu_to_le32(1)) {
 bad_block:	ext2_error(inode->i_sb, "ext2_xattr_get",
-			"inode %ld: bad block %d", inode->i_ino,
+			"inode %lld: bad block %d", inode->i_ino,
 			EXT2_I(inode)->i_file_acl);
 		error = -EIO;
 		goto cleanup;
@@ -275,7 +275,7 @@ ext2_xattr_list(struct inode *inode, cha
 	if (HDR(bh)->h_magic != cpu_to_le32(EXT2_XATTR_MAGIC) ||
 	    HDR(bh)->h_blocks != cpu_to_le32(1)) {
 bad_block:	ext2_error(inode->i_sb, "ext2_xattr_list",
-			"inode %ld: bad block %d", inode->i_ino,
+			"inode %lld: bad block %d", inode->i_ino,
 			EXT2_I(inode)->i_file_acl);
 		error = -EIO;
 		goto cleanup;
@@ -411,7 +411,7 @@ ext2_xattr_set(struct inode *inode, int 
 		if (header->h_magic != cpu_to_le32(EXT2_XATTR_MAGIC) ||
 		    header->h_blocks != cpu_to_le32(1)) {
 bad_block:		ext2_error(sb, "ext2_xattr_set",
-				"inode %ld: bad block %d", inode->i_ino, 
+				"inode %lld: bad block %d", inode->i_ino, 
 				   EXT2_I(inode)->i_file_acl);
 			error = -EIO;
 			goto cleanup;
@@ -772,7 +772,7 @@ ext2_xattr_delete_inode(struct inode *in
 	bh = sb_bread(inode->i_sb, EXT2_I(inode)->i_file_acl);
 	if (!bh) {
 		ext2_error(inode->i_sb, "ext2_xattr_delete_inode",
-			"inode %ld: block %d read error", inode->i_ino,
+			"inode %lld: block %d read error", inode->i_ino,
 			EXT2_I(inode)->i_file_acl);
 		goto cleanup;
 	}
@@ -780,7 +780,7 @@ ext2_xattr_delete_inode(struct inode *in
 	if (HDR(bh)->h_magic != cpu_to_le32(EXT2_XATTR_MAGIC) ||
 	    HDR(bh)->h_blocks != cpu_to_le32(1)) {
 		ext2_error(inode->i_sb, "ext2_xattr_delete_inode",
-			"inode %ld: bad block %d", inode->i_ino,
+			"inode %lld: bad block %d", inode->i_ino,
 			EXT2_I(inode)->i_file_acl);
 		goto cleanup;
 	}
@@ -931,7 +931,7 @@ again:
 		bh = sb_bread(inode->i_sb, ce->e_block);
 		if (!bh) {
 			ext2_error(inode->i_sb, "ext2_xattr_cache_find",
-				"inode %ld: block %ld read error",
+				"inode %lld: block %ld read error",
 				inode->i_ino, (unsigned long) ce->e_block);
 		} else {
 			lock_buffer(bh);
diff --git a/fs/ext3/dir.c b/fs/ext3/dir.c
index fbb0d4e..8617602 100644
--- a/fs/ext3/dir.c
+++ b/fs/ext3/dir.c
@@ -83,7 +83,7 @@ int ext3_check_dir_entry (const char * f
 
 	if (error_msg != NULL)
 		ext3_error (dir->i_sb, function,
-			"bad entry in directory #%lu: %s - "
+			"bad entry in directory #%llu: %s - "
 			"offset=%lu, inode=%lu, rec_len=%d, name_len=%d",
 			dir->i_ino, error_msg, offset,
 			(unsigned long) le32_to_cpu(de->inode),
@@ -149,7 +149,7 @@ #endif
 		 */
 		if (!bh) {
 			ext3_error (sb, "ext3_readdir",
-				"directory #%lu contains a hole at offset %lu",
+				"directory #%llu contains a hole at offset %lu",
 				inode->i_ino, (unsigned long)filp->f_pos);
 			filp->f_pos += sb->s_blocksize - offset;
 			continue;
diff --git a/fs/ext3/inode.c b/fs/ext3/inode.c
index 81ebf9b..f520d7c 100644
--- a/fs/ext3/inode.c
+++ b/fs/ext3/inode.c
@@ -2112,7 +2112,7 @@ static void ext3_free_branches(handle_t 
 			 */
 			if (!bh) {
 				ext3_error(inode->i_sb, "ext3_free_branches",
-					   "Read failure, inode=%ld, block="E3FSBLK,
+					   "Read failure, inode=%lld, block="E3FSBLK,
 					   inode->i_ino, nr);
 				continue;
 			}
@@ -2460,7 +2460,7 @@ static int __ext3_get_inode_loc(struct i
 	if (!bh) {
 		ext3_error (inode->i_sb, "ext3_get_inode_loc",
 				"unable to read inode block - "
-				"inode=%lu, block="E3FSBLK,
+				"inode=%llu, block="E3FSBLK,
 				 inode->i_ino, block);
 		return -EIO;
 	}
@@ -2542,7 +2542,7 @@ make_io:
 		if (!buffer_uptodate(bh)) {
 			ext3_error(inode->i_sb, "ext3_get_inode_loc",
 					"unable to read inode block - "
-					"inode=%lu, block="E3FSBLK,
+					"inode=%llu, block="E3FSBLK,
 					inode->i_ino, block);
 			brelse(bh);
 			return -EIO;
diff --git a/fs/ext3/namei.c b/fs/ext3/namei.c
index 2aa7101..3965049 100644
--- a/fs/ext3/namei.c
+++ b/fs/ext3/namei.c
@@ -878,7 +878,7 @@ restart:
 		wait_on_buffer(bh);
 		if (!buffer_uptodate(bh)) {
 			/* read error, skip block & hope for the best */
-			ext3_error(sb, __FUNCTION__, "reading directory #%lu "
+			ext3_error(sb, __FUNCTION__, "reading directory #%llu "
 				   "offset %lu", dir->i_ino, block);
 			brelse(bh);
 			goto next;
@@ -971,7 +971,7 @@ static struct buffer_head * ext3_dx_find
 					       frames, NULL);
 		if (retval < 0) {
 			ext3_warning(sb, __FUNCTION__,
-			     "error reading index page in directory #%lu",
+			     "error reading index page in directory #%llu",
 			     dir->i_ino);
 			*err = retval;
 			goto errout;
@@ -1801,11 +1801,11 @@ static int empty_dir (struct inode * ino
 	    !(bh = ext3_bread (NULL, inode, 0, 0, &err))) {
 		if (err)
 			ext3_error(inode->i_sb, __FUNCTION__,
-				   "error %d reading directory #%lu offset 0",
+				   "error %d reading directory #%llu offset 0",
 				   err, inode->i_ino);
 		else
 			ext3_warning(inode->i_sb, __FUNCTION__,
-				     "bad directory (dir #%lu) - no data block",
+				     "bad directory (dir #%llu) - no data block",
 				     inode->i_ino);
 		return 1;
 	}
@@ -1817,7 +1817,7 @@ static int empty_dir (struct inode * ino
 			strcmp (".", de->name) ||
 			strcmp ("..", de1->name)) {
 	    	ext3_warning (inode->i_sb, "empty_dir",
-			      "bad directory (dir #%lu) - no `.' or `..'",
+			      "bad directory (dir #%llu) - no `.' or `..'",
 			      inode->i_ino);
 		brelse (bh);
 		return 1;
@@ -1836,7 +1836,7 @@ static int empty_dir (struct inode * ino
 				if (err)
 					ext3_error(sb, __FUNCTION__,
 						   "error %d reading directory"
-						   " #%lu offset %lu",
+						   " #%llu offset %lu",
 						   err, inode->i_ino, offset);
 				offset += sb->s_blocksize;
 				continue;
@@ -1919,8 +1919,8 @@ int ext3_orphan_add(handle_t *handle, st
 	if (!err)
 		list_add(&EXT3_I(inode)->i_orphan, &EXT3_SB(sb)->s_orphan);
 
-	jbd_debug(4, "superblock will point to %ld\n", inode->i_ino);
-	jbd_debug(4, "orphan inode %ld will point to %d\n",
+	jbd_debug(4, "superblock will point to %lld\n", inode->i_ino);
+	jbd_debug(4, "orphan inode %lld will point to %d\n",
 			inode->i_ino, NEXT_ORPHAN(inode));
 out_unlock:
 	unlock_super(sb);
@@ -1951,7 +1951,7 @@ int ext3_orphan_del(handle_t *handle, st
 	prev = ei->i_orphan.prev;
 	sbi = EXT3_SB(inode->i_sb);
 
-	jbd_debug(4, "remove inode %lu from orphan list\n", inode->i_ino);
+	jbd_debug(4, "remove inode %llu from orphan list\n", inode->i_ino);
 
 	list_del_init(&ei->i_orphan);
 
@@ -1979,7 +1979,7 @@ int ext3_orphan_del(handle_t *handle, st
 		struct inode *i_prev =
 			&list_entry(prev, struct ext3_inode_info, i_orphan)->vfs_inode;
 
-		jbd_debug(4, "orphan inode %lu will point to %lu\n",
+		jbd_debug(4, "orphan inode %llu will point to %lu\n",
 			  i_prev->i_ino, ino_next);
 		err = ext3_reserve_inode_write(handle, i_prev, &iloc2);
 		if (err)
@@ -2093,7 +2093,7 @@ static int ext3_unlink(struct inode * di
 
 	if (!inode->i_nlink) {
 		ext3_warning (inode->i_sb, "ext3_unlink",
-			      "Deleting nonexistent file (%lu), %d",
+			      "Deleting nonexistent file (%llu), %d",
 			      inode->i_ino, inode->i_nlink);
 		inode->i_nlink = 1;
 	}
@@ -2320,7 +2320,7 @@ static int ext3_rename (struct inode * o
 	}
 	if (retval) {
 		ext3_warning(old_dir->i_sb, "ext3_rename",
-				"Deleting old file (%lu), %d, error=%d",
+				"Deleting old file (%llu), %d, error=%d",
 				old_dir->i_ino, old_dir->i_nlink, retval);
 	}
 
diff --git a/fs/ext3/super.c b/fs/ext3/super.c
index 813d589..037e11b 100644
--- a/fs/ext3/super.c
+++ b/fs/ext3/super.c
@@ -376,7 +376,7 @@ static void dump_orphan_list(struct supe
 	list_for_each(l, &sbi->s_orphan) {
 		struct inode *inode = orphan_list_entry(l);
 		printk(KERN_ERR "  "
-		       "inode %s:%ld at %p: mode %o, nlink %d, next %d\n",
+		       "inode %s:%lld at %p: mode %o, nlink %d, next %d\n",
 		       inode->i_sb->s_id, inode->i_ino, inode,
 		       inode->i_mode, inode->i_nlink, 
 		       NEXT_ORPHAN(inode));
@@ -1259,17 +1259,17 @@ #endif
 		DQUOT_INIT(inode);
 		if (inode->i_nlink) {
 			printk(KERN_DEBUG
-				"%s: truncating inode %ld to %Ld bytes\n",
+				"%s: truncating inode %lld to %Ld bytes\n",
 				__FUNCTION__, inode->i_ino, inode->i_size);
-			jbd_debug(2, "truncating inode %ld to %Ld bytes\n",
+			jbd_debug(2, "truncating inode %lld to %Ld bytes\n",
 				  inode->i_ino, inode->i_size);
 			ext3_truncate(inode);
 			nr_truncates++;
 		} else {
 			printk(KERN_DEBUG
-				"%s: deleting unreferenced inode %ld\n",
+				"%s: deleting unreferenced inode %lld\n",
 				__FUNCTION__, inode->i_ino);
-			jbd_debug(2, "deleting unreferenced inode %ld\n",
+			jbd_debug(2, "deleting unreferenced inode %lld\n",
 				  inode->i_ino);
 			nr_orphans++;
 		}
diff --git a/fs/ext3/xattr.c b/fs/ext3/xattr.c
index a44a056..a5817cd 100644
--- a/fs/ext3/xattr.c
+++ b/fs/ext3/xattr.c
@@ -233,7 +233,7 @@ ext3_xattr_block_get(struct inode *inode
 		atomic_read(&(bh->b_count)), le32_to_cpu(BHDR(bh)->h_refcount));
 	if (ext3_xattr_check_block(bh)) {
 bad_block:	ext3_error(inode->i_sb, __FUNCTION__,
-			   "inode %ld: bad block "E3FSBLK, inode->i_ino,
+			   "inode %lld: bad block "E3FSBLK, inode->i_ino,
 			   EXT3_I(inode)->i_file_acl);
 		error = -EIO;
 		goto cleanup;
@@ -375,7 +375,7 @@ ext3_xattr_block_list(struct inode *inod
 		atomic_read(&(bh->b_count)), le32_to_cpu(BHDR(bh)->h_refcount));
 	if (ext3_xattr_check_block(bh)) {
 		ext3_error(inode->i_sb, __FUNCTION__,
-			   "inode %ld: bad block "E3FSBLK, inode->i_ino,
+			   "inode %lld: bad block "E3FSBLK, inode->i_ino,
 			   EXT3_I(inode)->i_file_acl);
 		error = -EIO;
 		goto cleanup;
@@ -647,7 +647,7 @@ ext3_xattr_block_find(struct inode *inod
 			le32_to_cpu(BHDR(bs->bh)->h_refcount));
 		if (ext3_xattr_check_block(bs->bh)) {
 			ext3_error(sb, __FUNCTION__,
-				"inode %ld: bad block "E3FSBLK, inode->i_ino,
+				"inode %lld: bad block "E3FSBLK, inode->i_ino,
 				EXT3_I(inode)->i_file_acl);
 			error = -EIO;
 			goto cleanup;
@@ -848,7 +848,7 @@ cleanup_dquot:
 
 bad_block:
 	ext3_error(inode->i_sb, __FUNCTION__,
-		   "inode %ld: bad block "E3FSBLK, inode->i_ino,
+		   "inode %lld: bad block "E3FSBLK, inode->i_ino,
 		   EXT3_I(inode)->i_file_acl);
 	goto cleanup;
 
@@ -1077,14 +1077,14 @@ ext3_xattr_delete_inode(handle_t *handle
 	bh = sb_bread(inode->i_sb, EXT3_I(inode)->i_file_acl);
 	if (!bh) {
 		ext3_error(inode->i_sb, __FUNCTION__,
-			"inode %ld: block "E3FSBLK" read error", inode->i_ino,
+			"inode %lld: block "E3FSBLK" read error", inode->i_ino,
 			EXT3_I(inode)->i_file_acl);
 		goto cleanup;
 	}
 	if (BHDR(bh)->h_magic != cpu_to_le32(EXT3_XATTR_MAGIC) ||
 	    BHDR(bh)->h_blocks != cpu_to_le32(1)) {
 		ext3_error(inode->i_sb, __FUNCTION__,
-			"inode %ld: bad block "E3FSBLK, inode->i_ino,
+			"inode %lld: bad block "E3FSBLK, inode->i_ino,
 			EXT3_I(inode)->i_file_acl);
 		goto cleanup;
 	}
@@ -1211,7 +1211,7 @@ again:
 		bh = sb_bread(inode->i_sb, ce->e_block);
 		if (!bh) {
 			ext3_error(inode->i_sb, __FUNCTION__,
-				"inode %ld: block %lu read error",
+				"inode %lld: block %lu read error",
 				inode->i_ino, (unsigned long) ce->e_block);
 		} else if (le32_to_cpu(BHDR(bh)->h_refcount) >=
 				EXT3_XATTR_REFCOUNT_MAX) {
diff --git a/fs/freevxfs/vxfs_bmap.c b/fs/freevxfs/vxfs_bmap.c
index 2d71128..0bd5039 100644
--- a/fs/freevxfs/vxfs_bmap.c
+++ b/fs/freevxfs/vxfs_bmap.c
@@ -270,12 +270,12 @@ vxfs_bmap1(struct inode *ip, long iblock
 	if (VXFS_ISIMMED(vip))
 		goto unsupp;
 
-	printk(KERN_WARNING "vxfs: inode %ld has no valid orgtype (%x)\n",
+	printk(KERN_WARNING "vxfs: inode %lld has no valid orgtype (%x)\n",
 			ip->i_ino, vip->vii_orgtype);
 	BUG();
 
 unsupp:
-	printk(KERN_WARNING "vxfs: inode %ld has an unsupported orgtype (%x)\n",
+	printk(KERN_WARNING "vxfs: inode %lld has an unsupported orgtype (%x)\n",
 			ip->i_ino, vip->vii_orgtype);
 	return 0;
 }
diff --git a/fs/fs-writeback.c b/fs/fs-writeback.c
index 892643d..ec4be76 100644
--- a/fs/fs-writeback.c
+++ b/fs/fs-writeback.c
@@ -88,7 +88,7 @@ void __mark_inode_dirty(struct inode *in
 
 		if (inode->i_ino || strcmp(inode->i_sb->s_id, "bdev"))
 			printk(KERN_DEBUG
-			       "%s(%d): dirtied inode %lu (%s) on %s\n",
+			       "%s(%d): dirtied inode %llu (%s) on %s\n",
 			       current->comm, current->pid, inode->i_ino,
 			       name, inode->i_sb->s_id);
 	}
diff --git a/fs/hfs/catalog.c b/fs/hfs/catalog.c
index ba85157..2aa6ffb 100644
--- a/fs/hfs/catalog.c
+++ b/fs/hfs/catalog.c
@@ -274,7 +274,7 @@ int hfs_cat_move(u32 cnid, struct inode 
 	int entry_size, type;
 	int err;
 
-	dprint(DBG_CAT_MOD, "rename_cat: %u - %lu,%s - %lu,%s\n", cnid, src_dir->i_ino, src_name->name,
+	dprint(DBG_CAT_MOD, "rename_cat: %u - %llu,%s - %llu,%s\n", cnid, src_dir->i_ino, src_name->name,
 		dst_dir->i_ino, dst_name->name);
 	sb = src_dir->i_sb;
 	hfs_find_init(HFS_SB(sb)->cat_tree, &src_fd);
diff --git a/fs/hfs/extent.c b/fs/hfs/extent.c
index 5ea6b3d..6be0f62 100644
--- a/fs/hfs/extent.c
+++ b/fs/hfs/extent.c
@@ -392,7 +392,7 @@ int hfs_extend_file(struct inode *inode)
 		goto out;
 	}
 
-	dprint(DBG_EXTENT, "extend %lu: %u,%u\n", inode->i_ino, start, len);
+	dprint(DBG_EXTENT, "extend %llu: %u,%u\n", inode->i_ino, start, len);
 	if (HFS_I(inode)->alloc_blocks == HFS_I(inode)->first_blocks) {
 		if (!HFS_I(inode)->first_blocks) {
 			dprint(DBG_EXTENT, "first extents\n");
@@ -460,7 +460,7 @@ void hfs_file_truncate(struct inode *ino
 	u32 size;
 	int res;
 
-	dprint(DBG_INODE, "truncate: %lu, %Lu -> %Lu\n", inode->i_ino,
+	dprint(DBG_INODE, "truncate: %llu, %Lu -> %Lu\n", inode->i_ino,
 	       (long long)HFS_I(inode)->phys_size, inode->i_size);
 	if (inode->i_size > HFS_I(inode)->phys_size) {
 		struct address_space *mapping = inode->i_mapping;
diff --git a/fs/hfs/inode.c b/fs/hfs/inode.c
index 315cf44..7d011db 100644
--- a/fs/hfs/inode.c
+++ b/fs/hfs/inode.c
@@ -199,7 +199,7 @@ void hfs_delete_inode(struct inode *inod
 {
 	struct super_block *sb = inode->i_sb;
 
-	dprint(DBG_INODE, "delete_inode: %lu\n", inode->i_ino);
+	dprint(DBG_INODE, "delete_inode: %llu\n", inode->i_ino);
 	if (S_ISDIR(inode->i_mode)) {
 		HFS_SB(sb)->folder_count--;
 		if (HFS_I(inode)->cat_key.ParID == cpu_to_be32(HFS_ROOT_CNID))
@@ -380,7 +380,7 @@ int hfs_write_inode(struct inode *inode,
 	struct hfs_find_data fd;
 	hfs_cat_rec rec;
 
-	dprint(DBG_INODE, "hfs_write_inode: %lu\n", inode->i_ino);
+	dprint(DBG_INODE, "hfs_write_inode: %llu\n", inode->i_ino);
 	hfs_ext_write_extent(inode);
 
 	if (inode->i_ino < HFS_FIRSTUSER_CNID) {
diff --git a/fs/hfsplus/catalog.c b/fs/hfsplus/catalog.c
index f2d7c49..ba431e5 100644
--- a/fs/hfsplus/catalog.c
+++ b/fs/hfsplus/catalog.c
@@ -314,7 +314,7 @@ int hfsplus_rename_cat(u32 cnid,
 	int entry_size, type;
 	int err = 0;
 
-	dprint(DBG_CAT_MOD, "rename_cat: %u - %lu,%s - %lu,%s\n", cnid, src_dir->i_ino, src_name->name,
+	dprint(DBG_CAT_MOD, "rename_cat: %u - %llu,%s - %llu,%s\n", cnid, src_dir->i_ino, src_name->name,
 		dst_dir->i_ino, dst_name->name);
 	sb = src_dir->i_sb;
 	hfs_find_init(HFSPLUS_SB(sb).cat_tree, &src_fd);
diff --git a/fs/hfsplus/dir.c b/fs/hfsplus/dir.c
index 1f9ece0..5739bab 100644
--- a/fs/hfsplus/dir.c
+++ b/fs/hfsplus/dir.c
@@ -325,7 +325,7 @@ static int hfsplus_unlink(struct inode *
 	if (inode->i_ino == cnid &&
 	    atomic_read(&HFSPLUS_I(inode).opencnt)) {
 		str.name = name;
-		str.len = sprintf(name, "temp%lu", inode->i_ino);
+		str.len = sprintf(name, "temp%llu", inode->i_ino);
 		res = hfsplus_rename_cat(inode->i_ino,
 					 dir, &dentry->d_name,
 					 HFSPLUS_SB(sb).hidden_dir, &str);
diff --git a/fs/hfsplus/extents.c b/fs/hfsplus/extents.c
index 1a74800..4e42611 100644
--- a/fs/hfsplus/extents.c
+++ b/fs/hfsplus/extents.c
@@ -211,7 +211,7 @@ int hfsplus_get_block(struct inode *inod
 	up(&HFSPLUS_I(inode).extents_lock);
 
 done:
-	dprint(DBG_EXTENT, "get_block(%lu): %llu - %u\n", inode->i_ino, (long long)iblock, dblock);
+	dprint(DBG_EXTENT, "get_block(%llu): %llu - %u\n", inode->i_ino, (long long)iblock, dblock);
 	mask = (1 << HFSPLUS_SB(sb).fs_shift) - 1;
 	map_bh(bh_result, sb, (dblock << HFSPLUS_SB(sb).fs_shift) + HFSPLUS_SB(sb).blockoffset + (iblock & mask));
 	if (create) {
@@ -375,7 +375,7 @@ int hfsplus_file_extend(struct inode *in
 		}
 	}
 
-	dprint(DBG_EXTENT, "extend %lu: %u,%u\n", inode->i_ino, start, len);
+	dprint(DBG_EXTENT, "extend %llu: %u,%u\n", inode->i_ino, start, len);
 	if (HFSPLUS_I(inode).alloc_blocks <= HFSPLUS_I(inode).first_blocks) {
 		if (!HFSPLUS_I(inode).first_blocks) {
 			dprint(DBG_EXTENT, "first extents\n");
@@ -438,7 +438,7 @@ void hfsplus_file_truncate(struct inode 
 	u32 alloc_cnt, blk_cnt, start;
 	int res;
 
-	dprint(DBG_INODE, "truncate: %lu, %Lu -> %Lu\n", inode->i_ino,
+	dprint(DBG_INODE, "truncate: %llu, %Lu -> %Lu\n", inode->i_ino,
 	       (long long)HFSPLUS_I(inode).phys_size, inode->i_size);
 	if (inode->i_size > HFSPLUS_I(inode).phys_size) {
 		struct address_space *mapping = inode->i_mapping;
diff --git a/fs/hfsplus/super.c b/fs/hfsplus/super.c
index d279d59..105d63f 100644
--- a/fs/hfsplus/super.c
+++ b/fs/hfsplus/super.c
@@ -82,7 +82,7 @@ static int hfsplus_write_inode(struct in
 	struct hfsplus_vh *vhdr;
 	int ret = 0;
 
-	dprint(DBG_INODE, "hfsplus_write_inode: %lu\n", inode->i_ino);
+	dprint(DBG_INODE, "hfsplus_write_inode: %llu\n", inode->i_ino);
 	hfsplus_ext_write_extent(inode);
 	if (inode->i_ino >= HFSPLUS_FIRSTUSER_CNID) {
 		return hfsplus_cat_write_inode(inode);
@@ -136,7 +136,7 @@ static int hfsplus_write_inode(struct in
 
 static void hfsplus_clear_inode(struct inode *inode)
 {
-	dprint(DBG_INODE, "hfsplus_clear_inode: %lu\n", inode->i_ino);
+	dprint(DBG_INODE, "hfsplus_clear_inode: %llu\n", inode->i_ino);
 	if (HFSPLUS_IS_RSRC(inode)) {
 		HFSPLUS_I(HFSPLUS_I(inode).rsrc_inode).rsrc_inode = NULL;
 		iput(HFSPLUS_I(inode).rsrc_inode);
diff --git a/fs/isofs/compress.c b/fs/isofs/compress.c
index 7318163..a9209ca 100644
--- a/fs/isofs/compress.c
+++ b/fs/isofs/compress.c
@@ -99,7 +99,7 @@ static int zisofs_readpage(struct file *
 
 	if ( isofs_get_blocks(inode, blockptr >> bufshift, ptrbh, indexblocks) != indexblocks ) {
 		if ( ptrbh[0] ) brelse(ptrbh[0]);
-		printk(KERN_DEBUG "zisofs: Null buffer on reading block table, inode = %lu, block = %lu\n",
+		printk(KERN_DEBUG "zisofs: Null buffer on reading block table, inode = %llu, block = %lu\n",
 		       inode->i_ino, blockptr >> bufshift);
 		goto eio;
 	}
@@ -107,7 +107,7 @@ static int zisofs_readpage(struct file *
 
 	bh = ptrbh[0];
 	if ( !bh || (wait_on_buffer(bh), !buffer_uptodate(bh)) ) {
-		printk(KERN_DEBUG "zisofs: Failed to read block table, inode = %lu, block = %lu\n",
+		printk(KERN_DEBUG "zisofs: Failed to read block table, inode = %llu, block = %lu\n",
 		       inode->i_ino, blockptr >> bufshift);
 		if ( ptrbh[1] )
 			brelse(ptrbh[1]);
@@ -120,7 +120,7 @@ static int zisofs_readpage(struct file *
 		brelse(bh);
 		bh = ptrbh[1];
 		if ( !bh || (wait_on_buffer(bh), !buffer_uptodate(bh)) ) {
-			printk(KERN_DEBUG "zisofs: Failed to read block table, inode = %lu, block = %lu\n",
+			printk(KERN_DEBUG "zisofs: Failed to read block table, inode = %llu, block = %lu\n",
 			       inode->i_ino, blockendptr >> bufshift);
 			goto eio;
 		}
@@ -246,7 +246,7 @@ static int zisofs_readpage(struct file *
 					if ( err && zerr == Z_MEM_ERROR )
 						err = -ENOMEM;
 					if ( zerr != Z_STREAM_END )
-						printk(KERN_DEBUG "zisofs: zisofs_inflate returned %d, inode = %lu, index = %lu, fpage = %d, xpage = %d, avail_in = %d, avail_out = %d, ai = %d, ao = %d\n",
+						printk(KERN_DEBUG "zisofs: zisofs_inflate returned %d, inode = %llu, index = %lu, fpage = %d, xpage = %d, avail_in = %d, avail_out = %d, ai = %d, ao = %d\n",
 						       zerr, inode->i_ino, index,
 						       fpage, xpage,
 						       stream.avail_in, stream.avail_out,
diff --git a/fs/isofs/inode.c b/fs/isofs/inode.c
index 1439136..397829c 100644
--- a/fs/isofs/inode.c
+++ b/fs/isofs/inode.c
@@ -1170,7 +1170,7 @@ out_noread:
 out_toomany:
 	printk(KERN_INFO "isofs_read_level3_size: "
 		"More than 100 file sections ?!?, aborting...\n"
-	  	"isofs_read_level3_size: inode=%lu\n",
+	  	"isofs_read_level3_size: inode=%llu\n",
 		inode->i_ino);
 	goto out;
 }
@@ -1270,7 +1270,7 @@ static void isofs_read_inode(struct inod
 	/* I have no idea what file_unit_size is used for, so
 	   we will flag it for now */
 	if (de->file_unit_size[0] != 0) {
-		printk("File unit size != 0 for ISO file (%ld).\n",
+		printk("File unit size != 0 for ISO file (%lld).\n",
 		       inode->i_ino);
 	}
 
diff --git a/fs/jbd/journal.c b/fs/jbd/journal.c
index 8c9b28d..6e72935 100644
--- a/fs/jbd/journal.c
+++ b/fs/jbd/journal.c
@@ -761,7 +761,7 @@ journal_t * journal_init_inode (struct i
 	journal->j_dev = journal->j_fs_dev = inode->i_sb->s_bdev;
 	journal->j_inode = inode;
 	jbd_debug(1,
-		  "journal %p: inode %s/%ld, size %Ld, bits %d, blksize %ld\n",
+		  "journal %p: inode %s/%lld, size %Ld, bits %d, blksize %ld\n",
 		  journal, inode->i_sb->s_id, inode->i_ino, 
 		  (long long) inode->i_size,
 		  inode->i_sb->s_blocksize_bits, inode->i_sb->s_blocksize);
diff --git a/fs/jffs/inode-v23.c b/fs/jffs/inode-v23.c
index 9306869..245234e 100644
--- a/fs/jffs/inode-v23.c
+++ b/fs/jffs/inode-v23.c
@@ -208,7 +208,7 @@ jffs_setattr(struct dentry *dentry, stru
 	f = jffs_find_file(c, inode->i_ino);
 
 	ASSERT(if (!f) {
-		printk("jffs_setattr(): Invalid inode number: %lu\n",
+		printk("jffs_setattr(): Invalid inode number: %llu\n",
 		       inode->i_ino);
 		D3(printk (KERN_NOTICE "notify_change(): up biglock\n"));
 		mutex_unlock(&fmc->biglock);
@@ -1006,7 +1006,7 @@ jffs_remove(struct inode *dir, struct de
 		goto jffs_remove_end;
 
 	if (!inode->i_nlink) {
-		printk("Deleting nonexistent file inode: %lu, nlink: %d\n",
+		printk("Deleting nonexistent file inode: %llu, nlink: %d\n",
 		       inode->i_ino, inode->i_nlink);
 		inode->i_nlink=1;
 	}
diff --git a/fs/jfs/jfs_imap.c b/fs/jfs/jfs_imap.c
index ccbe60a..456aa79 100644
--- a/fs/jfs/jfs_imap.c
+++ b/fs/jfs/jfs_imap.c
@@ -321,7 +321,7 @@ int diRead(struct inode *ip)
 	uint pageno;
 	int rel_inode;
 
-	jfs_info("diRead: ino = %ld", ip->i_ino);
+	jfs_info("diRead: ino = %lld", ip->i_ino);
 
 	ipimap = sbi->ipimap;
 	JFS_IP(ip)->ipimap = ipimap;
diff --git a/fs/jfs/jfs_metapage.c b/fs/jfs/jfs_metapage.c
index e1e0a6e..7631102 100644
--- a/fs/jfs/jfs_metapage.c
+++ b/fs/jfs/jfs_metapage.c
@@ -598,7 +598,7 @@ struct metapage *__get_metapage(struct i
 	unsigned long page_index;
 	unsigned long page_offset;
 
-	jfs_info("__get_metapage: ino = %ld, lblock = 0x%lx, abs=%d",
+	jfs_info("__get_metapage: ino = %lld, lblock = 0x%lx, abs=%d",
 		 inode->i_ino, lblock, absolute);
 
 	l2bsize = inode->i_blkbits;
diff --git a/fs/lockd/svclock.c b/fs/lockd/svclock.c
index c9d4197..e66b6c2 100644
--- a/fs/lockd/svclock.c
+++ b/fs/lockd/svclock.c
@@ -361,7 +361,7 @@ nlmsvc_lock(struct svc_rqst *rqstp, stru
 	int			error;
 	u32			ret;
 
-	dprintk("lockd: nlmsvc_lock(%s/%ld, ty=%d, pi=%d, %Ld-%Ld, bl=%d)\n",
+	dprintk("lockd: nlmsvc_lock(%s/%lld, ty=%d, pi=%d, %Ld-%Ld, bl=%d)\n",
 				file->f_file->f_dentry->d_inode->i_sb->s_id,
 				file->f_file->f_dentry->d_inode->i_ino,
 				lock->fl.fl_type, lock->fl.fl_pid,
@@ -438,7 +438,7 @@ u32
 nlmsvc_testlock(struct nlm_file *file, struct nlm_lock *lock,
 				       struct nlm_lock *conflock)
 {
-	dprintk("lockd: nlmsvc_testlock(%s/%ld, ty=%d, %Ld-%Ld)\n",
+	dprintk("lockd: nlmsvc_testlock(%s/%lld, ty=%d, %Ld-%Ld)\n",
 				file->f_file->f_dentry->d_inode->i_sb->s_id,
 				file->f_file->f_dentry->d_inode->i_ino,
 				lock->fl.fl_type,
@@ -471,7 +471,7 @@ nlmsvc_unlock(struct nlm_file *file, str
 {
 	int	error;
 
-	dprintk("lockd: nlmsvc_unlock(%s/%ld, pi=%d, %Ld-%Ld)\n",
+	dprintk("lockd: nlmsvc_unlock(%s/%lld, pi=%d, %Ld-%Ld)\n",
 				file->f_file->f_dentry->d_inode->i_sb->s_id,
 				file->f_file->f_dentry->d_inode->i_ino,
 				lock->fl.fl_pid,
@@ -500,7 +500,7 @@ nlmsvc_cancel_blocked(struct nlm_file *f
 	struct nlm_block	*block;
 	int status = 0;
 
-	dprintk("lockd: nlmsvc_cancel(%s/%ld, pi=%d, %Ld-%Ld)\n",
+	dprintk("lockd: nlmsvc_cancel(%s/%lld, pi=%d, %Ld-%Ld)\n",
 				file->f_file->f_dentry->d_inode->i_sb->s_id,
 				file->f_file->f_dentry->d_inode->i_ino,
 				lock->fl.fl_pid,
diff --git a/fs/lockd/svcsubs.c b/fs/lockd/svcsubs.c
index 2a4df9b..2e07478 100644
--- a/fs/lockd/svcsubs.c
+++ b/fs/lockd/svcsubs.c
@@ -45,7 +45,7 @@ static inline void nlm_debug_print_file(
 {
 	struct inode *inode = file->f_file->f_dentry->d_inode;
 
-	dprintk("lockd: %s %s/%ld\n",
+	dprintk("lockd: %s %s/%lld\n",
 		msg, inode->i_sb->s_id, inode->i_ino);
 }
 #else
diff --git a/fs/locks.c b/fs/locks.c
index b0b41a6..953e15d 100644
--- a/fs/locks.c
+++ b/fs/locks.c
@@ -2062,7 +2062,7 @@ #ifdef WE_CAN_BREAK_LSLK_NOW
 				inode->i_sb->s_id, inode->i_ino);
 #else
 		/* userspace relies on this representation of dev_t ;-( */
-		out += sprintf(out, "%d %02x:%02x:%ld ", fl->fl_pid,
+		out += sprintf(out, "%d %02x:%02x:%lld ", fl->fl_pid,
 				MAJOR(inode->i_sb->s_dev),
 				MINOR(inode->i_sb->s_dev), inode->i_ino);
 #endif
diff --git a/fs/minix/inode.c b/fs/minix/inode.c
index 9ea91c5..17abb8f 100644
--- a/fs/minix/inode.c
+++ b/fs/minix/inode.c
@@ -524,7 +524,7 @@ int minix_sync_inode(struct inode * inod
 		sync_dirty_buffer(bh);
 		if (buffer_req(bh) && !buffer_uptodate(bh))
 		{
-			printk("IO error syncing minix inode [%s:%08lx]\n",
+			printk("IO error syncing minix inode [%s:%08llx]\n",
 				inode->i_sb->s_id, inode->i_ino);
 			err = -1;
 		}
diff --git a/fs/nfs/dir.c b/fs/nfs/dir.c
index 9b496ef..7a9a54f 100644
--- a/fs/nfs/dir.c
+++ b/fs/nfs/dir.c
@@ -131,7 +131,7 @@ nfs_opendir(struct inode *inode, struct 
 {
 	int res;
 
-	dfprintk(VFS, "NFS: opendir(%s/%ld)\n",
+	dfprintk(VFS, "NFS: opendir(%s/%lld)\n",
 			inode->i_sb->s_id, inode->i_ino);
 
 	lock_kernel();
@@ -967,7 +967,7 @@ static struct dentry *nfs_atomic_lookup(
 	struct dentry *res = NULL;
 	int error;
 
-	dfprintk(VFS, "NFS: atomic_lookup(%s/%ld), %s\n",
+	dfprintk(VFS, "NFS: atomic_lookup(%s/%lld), %s\n",
 			dir->i_sb->s_id, dir->i_ino, dentry->d_name.name);
 
 	/* Check that we are indeed trying to open this file */
@@ -1179,7 +1179,7 @@ static int nfs_create(struct inode *dir,
 	int error;
 	int open_flags = 0;
 
-	dfprintk(VFS, "NFS: create(%s/%ld), %s\n",
+	dfprintk(VFS, "NFS: create(%s/%lld), %s\n",
 			dir->i_sb->s_id, dir->i_ino, dentry->d_name.name);
 
 	attr.ia_mode = mode;
@@ -1213,7 +1213,7 @@ nfs_mknod(struct inode *dir, struct dent
 	struct iattr attr;
 	int status;
 
-	dfprintk(VFS, "NFS: mknod(%s/%ld), %s\n",
+	dfprintk(VFS, "NFS: mknod(%s/%lld), %s\n",
 			dir->i_sb->s_id, dir->i_ino, dentry->d_name.name);
 
 	if (!new_valid_dev(rdev))
@@ -1246,7 +1246,7 @@ static int nfs_mkdir(struct inode *dir, 
 	struct iattr attr;
 	int error;
 
-	dfprintk(VFS, "NFS: mkdir(%s/%ld), %s\n",
+	dfprintk(VFS, "NFS: mkdir(%s/%lld), %s\n",
 			dir->i_sb->s_id, dir->i_ino, dentry->d_name.name);
 
 	attr.ia_valid = ATTR_MODE;
@@ -1272,7 +1272,7 @@ static int nfs_rmdir(struct inode *dir, 
 {
 	int error;
 
-	dfprintk(VFS, "NFS: rmdir(%s/%ld), %s\n",
+	dfprintk(VFS, "NFS: rmdir(%s/%lld), %s\n",
 			dir->i_sb->s_id, dir->i_ino, dentry->d_name.name);
 
 	lock_kernel();
@@ -1315,7 +1315,7 @@ #endif
 	if (dentry->d_flags & DCACHE_NFSFS_RENAMED)
 		goto out;
 
-	sprintf(silly, ".nfs%*.*lx",
+	sprintf(silly, ".nfs%*.*llx",
 		i_inosize, i_inosize, dentry->d_inode->i_ino);
 
 	/* Return delegation in anticipation of the rename */
@@ -1415,7 +1415,7 @@ static int nfs_unlink(struct inode *dir,
 	int error;
 	int need_rehash = 0;
 
-	dfprintk(VFS, "NFS: unlink(%s/%ld, %s)\n", dir->i_sb->s_id,
+	dfprintk(VFS, "NFS: unlink(%s/%lld, %s)\n", dir->i_sb->s_id,
 		dir->i_ino, dentry->d_name.name);
 
 	lock_kernel();
@@ -1453,7 +1453,7 @@ nfs_symlink(struct inode *dir, struct de
 	struct qstr qsymname;
 	int error;
 
-	dfprintk(VFS, "NFS: symlink(%s/%ld, %s, %s)\n", dir->i_sb->s_id,
+	dfprintk(VFS, "NFS: symlink(%s/%lld, %s, %s)\n", dir->i_sb->s_id,
 		dir->i_ino, dentry->d_name.name, symname);
 
 #ifdef NFS_PARANOIA
@@ -1918,7 +1918,7 @@ force_lookup:
 		res = PTR_ERR(cred);
 	unlock_kernel();
 out:
-	dfprintk(VFS, "NFS: permission(%s/%ld), mask=0x%x, res=%d\n",
+	dfprintk(VFS, "NFS: permission(%s/%lld), mask=0x%x, res=%d\n",
 		inode->i_sb->s_id, inode->i_ino, mask, res);
 	return res;
 out_notsup:
diff --git a/fs/nfs/file.c b/fs/nfs/file.c
index 855bb97..0d95feb 100644
--- a/fs/nfs/file.c
+++ b/fs/nfs/file.c
@@ -179,7 +179,7 @@ nfs_file_flush(struct file *file, fl_own
 	struct inode	*inode = file->f_dentry->d_inode;
 	int		status;
 
-	dfprintk(VFS, "nfs: flush(%s/%ld)\n", inode->i_sb->s_id, inode->i_ino);
+	dfprintk(VFS, "nfs: flush(%s/%lld)\n", inode->i_sb->s_id, inode->i_ino);
 
 	if ((file->f_mode & FMODE_WRITE) == 0)
 		return 0;
@@ -270,7 +270,7 @@ nfs_fsync(struct file *file, struct dent
 	struct inode *inode = dentry->d_inode;
 	int status;
 
-	dfprintk(VFS, "nfs: fsync(%s/%ld)\n", inode->i_sb->s_id, inode->i_ino);
+	dfprintk(VFS, "nfs: fsync(%s/%lld)\n", inode->i_sb->s_id, inode->i_ino);
 
 	nfs_inc_stats(inode, NFSIOS_VFSFSYNC);
 	lock_kernel();
@@ -376,7 +376,7 @@ #ifdef CONFIG_NFS_DIRECTIO
 		return nfs_file_direct_write(iocb, buf, count, pos);
 #endif
 
-	dfprintk(VFS, "nfs: write(%s/%s(%ld), %lu@%lu)\n",
+	dfprintk(VFS, "nfs: write(%s/%s(%lld), %lu@%lu)\n",
 		dentry->d_parent->d_name.name, dentry->d_name.name,
 		inode->i_ino, (unsigned long) count, (unsigned long) pos);
 
@@ -528,7 +528,7 @@ static int nfs_lock(struct file *filp, i
 {
 	struct inode * inode = filp->f_mapping->host;
 
-	dprintk("NFS: nfs_lock(f=%s/%ld, t=%x, fl=%x, r=%Ld:%Ld)\n",
+	dprintk("NFS: nfs_lock(f=%s/%lld, t=%x, fl=%x, r=%Ld:%Ld)\n",
 			inode->i_sb->s_id, inode->i_ino,
 			fl->fl_type, fl->fl_flags,
 			(long long)fl->fl_start, (long long)fl->fl_end);
@@ -551,7 +551,7 @@ static int nfs_lock(struct file *filp, i
  */
 static int nfs_flock(struct file *filp, int cmd, struct file_lock *fl)
 {
-	dprintk("NFS: nfs_flock(f=%s/%ld, t=%x, fl=%x)\n",
+	dprintk("NFS: nfs_flock(f=%s/%lld, t=%x, fl=%x)\n",
 			filp->f_dentry->d_inode->i_sb->s_id,
 			filp->f_dentry->d_inode->i_ino,
 			fl->fl_type, fl->fl_flags);
diff --git a/fs/nfs/inode.c b/fs/nfs/inode.c
index eaa254b..b42759a 100644
--- a/fs/nfs/inode.c
+++ b/fs/nfs/inode.c
@@ -891,7 +891,7 @@ static int nfs_update_inode(struct inode
 	unsigned int	invalid = 0;
 	int data_stable;
 
-	dfprintk(VFS, "NFS: %s(%s/%ld ct=%d info=0x%x)\n",
+	dfprintk(VFS, "NFS: %s(%s/%lld ct=%d info=0x%x)\n",
 			__FUNCTION__, inode->i_sb->s_id, inode->i_ino,
 			atomic_read(&inode->i_count), fattr->valid);
 
@@ -943,14 +943,14 @@ static int nfs_update_inode(struct inode
 			nfs_fscache_set_size(NFS_SERVER(inode), nfsi, inode->i_size);
 		}
 		nfsi->cache_change_attribute = jiffies;
-		dprintk("NFS: isize change on server for file %s/%ld\n",
+		dprintk("NFS: isize change on server for file %s/%lld\n",
 				inode->i_sb->s_id, inode->i_ino);
 	}
 
 	/* Check if the mtime agrees */
 	if (!timespec_equal(&inode->i_mtime, &fattr->mtime)) {
 		memcpy(&inode->i_mtime, &fattr->mtime, sizeof(inode->i_mtime));
-		dprintk("NFS: mtime change on server for file %s/%ld\n",
+		dprintk("NFS: mtime change on server for file %s/%lld\n",
 				inode->i_sb->s_id, inode->i_ino);
 		invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA;
 		nfsi->cache_change_attribute = jiffies;
@@ -987,7 +987,7 @@ static int nfs_update_inode(struct inode
 
 	if ((fattr->valid & NFS_ATTR_FATTR_V4) != 0 &&
 			nfsi->change_attr != fattr->change_attr) {
-		dprintk("NFS: change_attr change on server for file %s/%ld\n",
+		dprintk("NFS: change_attr change on server for file %s/%lld\n",
 				inode->i_sb->s_id, inode->i_ino);
 		nfsi->change_attr = fattr->change_attr;
 		invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL;
@@ -1019,7 +1019,7 @@ static int nfs_update_inode(struct inode
 	 * Big trouble! The inode has become a different object.
 	 */
 #ifdef NFS_PARANOIA
-	printk(KERN_DEBUG "%s: inode %ld mode changed, %07o to %07o\n",
+	printk(KERN_DEBUG "%s: inode %lld mode changed, %07o to %07o\n",
 			__FUNCTION__, inode->i_ino, inode->i_mode, fattr->mode);
 #endif
  out_err:
diff --git a/fs/nfs/nfs3acl.c b/fs/nfs/nfs3acl.c
index 7322da4..d1f507b 100644
--- a/fs/nfs/nfs3acl.c
+++ b/fs/nfs/nfs3acl.c
@@ -127,7 +127,7 @@ static void __nfs3_forget_cached_acls(st
 
 void nfs3_forget_cached_acls(struct inode *inode)
 {
-	dprintk("NFS: nfs3_forget_cached_acls(%s/%ld)\n", inode->i_sb->s_id,
+	dprintk("NFS: nfs3_forget_cached_acls(%s/%lld)\n", inode->i_sb->s_id,
 		inode->i_ino);
 	spin_lock(&inode->i_lock);
 	__nfs3_forget_cached_acls(NFS_I(inode));
@@ -158,7 +158,7 @@ static struct posix_acl *nfs3_get_cached
 		acl = posix_acl_dup(acl);
 out:
 	spin_unlock(&inode->i_lock);
-	dprintk("NFS: nfs3_get_cached_acl(%s/%ld, %d) = %p\n", inode->i_sb->s_id,
+	dprintk("NFS: nfs3_get_cached_acl(%s/%lld, %d) = %p\n", inode->i_sb->s_id,
 		inode->i_ino, type, acl);
 	return acl;
 }
@@ -168,7 +168,7 @@ static void nfs3_cache_acls(struct inode
 {
 	struct nfs_inode *nfsi = NFS_I(inode);
 
-	dprintk("nfs3_cache_acls(%s/%ld, %p, %p)\n", inode->i_sb->s_id,
+	dprintk("nfs3_cache_acls(%s/%lld, %p, %p)\n", inode->i_sb->s_id,
 		inode->i_ino, acl, dfacl);
 	spin_lock(&inode->i_lock);
 	__nfs3_forget_cached_acls(NFS_I(inode));
diff --git a/fs/nfsd/export.c b/fs/nfsd/export.c
index 01bc68c..6986d09 100644
--- a/fs/nfsd/export.c
+++ b/fs/nfsd/export.c
@@ -996,7 +996,7 @@ exp_rootfh(svc_client *clp, char *path, 
 	}
 	inode = nd.dentry->d_inode;
 
-	dprintk("nfsd: exp_rootfh(%s [%p] %s:%s/%ld)\n",
+	dprintk("nfsd: exp_rootfh(%s [%p] %s:%s/%lld)\n",
 		 path, nd.dentry, clp->name,
 		 inode->i_sb->s_id, inode->i_ino);
 	exp = exp_parent(clp, nd.mnt, nd.dentry, NULL);
diff --git a/fs/nfsd/nfsfh.c b/fs/nfsd/nfsfh.c
index 501d838..c6e7e89 100644
--- a/fs/nfsd/nfsfh.c
+++ b/fs/nfsd/nfsfh.c
@@ -333,9 +333,9 @@ fh_compose(struct svc_fh *fhp, struct sv
 	__u32 *datap;
 	dev_t ex_dev = exp->ex_dentry->d_inode->i_sb->s_dev;
 
-	dprintk("nfsd: fh_compose(exp %02x:%02x/%ld %s/%s, ino=%ld)\n",
+	dprintk("nfsd: fh_compose(exp %02x:%02x/%lld %s/%s, ino=%lld)\n",
 		MAJOR(ex_dev), MINOR(ex_dev),
-		(long) exp->ex_dentry->d_inode->i_ino,
+		exp->ex_dentry->d_inode->i_ino,
 		parent->d_name.name, dentry->d_name.name,
 		(inode ? inode->i_ino : 0));
 
diff --git a/fs/ntfs/aops.c b/fs/ntfs/aops.c
index bc579bf..4f7293e 100644
--- a/fs/ntfs/aops.c
+++ b/fs/ntfs/aops.c
@@ -935,7 +935,7 @@ static int ntfs_write_mst_block(struct p
 	BOOL sync, is_mft, page_is_dirty, rec_is_dirty;
 	unsigned char bh_size_bits;
 
-	ntfs_debug("Entering for inode 0x%lx, attribute type 0x%x, page index "
+	ntfs_debug("Entering for inode 0x%llx, attribute type 0x%x, page index "
 			"0x%lx.", vi->i_ino, ni->type, page->index);
 	BUG_ON(!NInoNonResident(ni));
 	BUG_ON(!NInoMstProtected(ni));
@@ -1170,7 +1170,7 @@ lock_retry_remap:
 			if (!err || err == -ENOMEM)
 				err = -EIO;
 			ntfs_error(vol->sb, "Failed to apply mst fixups "
-					"(inode 0x%lx, attribute type 0x%x, "
+					"(inode 0x%llx, attribute type 0x%x, "
 					"page index 0x%lx, page offset 0x%x)!"
 					"  Unmount and run chkdsk.", vi->i_ino,
 					ni->type, page->index, ofs);
@@ -1217,7 +1217,7 @@ do_wait:
 		wait_on_buffer(tbh);
 		if (unlikely(!buffer_uptodate(tbh))) {
 			ntfs_error(vol->sb, "I/O error while writing ntfs "
-					"record buffer (inode 0x%lx, "
+					"record buffer (inode 0x%llx, "
 					"attribute type 0x%x, page index "
 					"0x%lx, page offset 0x%lx)!  Unmount "
 					"and run chkdsk.", vi->i_ino, ni->type,
diff --git a/fs/ntfs/attrib.c b/fs/ntfs/attrib.c
index 6708e1d..e4d638b 100644
--- a/fs/ntfs/attrib.c
+++ b/fs/ntfs/attrib.c
@@ -1784,7 +1784,7 @@ undo_err_out:
 			attr_size = arec_size - mp_ofs;
 			ntfs_error(vol->sb, "Failed to undo partial resident "
 					"to non-resident attribute "
-					"conversion.  Truncating inode 0x%lx, "
+					"conversion.  Truncating inode 0x%llx, "
 					"attribute type 0x%x from %i bytes to "
 					"%i bytes to maintain metadata "
 					"consistency.  THIS MEANS YOU ARE "
@@ -1957,7 +1957,7 @@ retry_extend:
 		if (start < 0 || start >= allocated_size) {
 			if (err == -ERANGE) {
 				ntfs_error(vol->sb, "Cannot extend allocation "
-						"of inode 0x%lx, attribute "
+						"of inode 0x%llx, attribute "
 						"type 0x%x, because the new "
 						"allocation would exceed the "
 						"maximum allowed size for "
@@ -1966,7 +1966,7 @@ retry_extend:
 						le32_to_cpu(ni->type));
 			} else {
 				ntfs_error(vol->sb, "Cannot extend allocation "
-						"of inode 0x%lx, attribute "
+						"of inode 0x%llx, attribute "
 						"type 0x%x, because this "
 						"attribute type is not "
 						"defined on the NTFS volume.  "
@@ -2096,7 +2096,7 @@ retry_extend:
 		read_unlock_irqrestore(&ni->size_lock, flags);
 		if (start < 0 || start >= allocated_size)
 			ntfs_error(vol->sb, "Cannot extend allocation of "
-					"inode 0x%lx, attribute type 0x%x, "
+					"inode 0x%llx, attribute type 0x%x, "
 					"because the conversion from resident "
 					"to non-resident attribute failed "
 					"with error code %i.", vi->i_ino,
@@ -2189,7 +2189,7 @@ skip_sparse:
 			err = PTR_ERR(rl);
 			if (start < 0 || start >= allocated_size)
 				ntfs_error(vol->sb, "Cannot extend allocation "
-						"of inode 0x%lx, attribute "
+						"of inode 0x%llx, attribute "
 						"type 0x%x, because the "
 						"mapping of a runlist "
 						"fragment failed with error "
@@ -2227,7 +2227,7 @@ first_alloc:
 		err = PTR_ERR(rl2);
 		if (start < 0 || start >= allocated_size)
 			ntfs_error(vol->sb, "Cannot extend allocation of "
-					"inode 0x%lx, attribute type 0x%x, "
+					"inode 0x%llx, attribute type 0x%x, "
 					"because the allocation of clusters "
 					"failed with error code %i.", vi->i_ino,
 					(unsigned)le32_to_cpu(ni->type), err);
@@ -2240,7 +2240,7 @@ first_alloc:
 		err = PTR_ERR(rl);
 		if (start < 0 || start >= allocated_size)
 			ntfs_error(vol->sb, "Cannot extend allocation of "
-					"inode 0x%lx, attribute type 0x%x, "
+					"inode 0x%llx, attribute type 0x%x, "
 					"because the runlist merge failed "
 					"with error code %i.", vi->i_ino,
 					(unsigned)le32_to_cpu(ni->type), err);
@@ -2272,7 +2272,7 @@ first_alloc:
 		err = mp_size;
 		if (start < 0 || start >= allocated_size)
 			ntfs_error(vol->sb, "Cannot extend allocation of "
-					"inode 0x%lx, attribute type 0x%x, "
+					"inode 0x%llx, attribute type 0x%x, "
 					"because determining the size for the "
 					"mapping pairs failed with error code "
 					"%i.", vi->i_ino,
@@ -2308,7 +2308,7 @@ first_alloc:
 	if (unlikely(err)) {
 		if (start < 0 || start >= allocated_size)
 			ntfs_error(vol->sb, "Cannot extend allocation of "
-					"inode 0x%lx, attribute type 0x%x, "
+					"inode 0x%llx, attribute type 0x%x, "
 					"because building the mapping pairs "
 					"failed with error code %i.", vi->i_ino,
 					(unsigned)le32_to_cpu(ni->type), err);
@@ -2378,7 +2378,7 @@ done:
 restore_undo_alloc:
 	if (start < 0 || start >= allocated_size)
 		ntfs_error(vol->sb, "Cannot complete extension of allocation "
-				"of inode 0x%lx, attribute type 0x%x, because "
+				"of inode 0x%llx, attribute type 0x%x, because "
 				"lookup of first attribute extent failed with "
 				"error code %i.", vi->i_ino,
 				(unsigned)le32_to_cpu(ni->type), err);
diff --git a/fs/ntfs/bitmap.c b/fs/ntfs/bitmap.c
index 7a190cd..f56b812 100644
--- a/fs/ntfs/bitmap.c
+++ b/fs/ntfs/bitmap.c
@@ -56,7 +56,7 @@ int __ntfs_bitmap_set_bits_in_run(struct
 	u8 bit;
 
 	BUG_ON(!vi);
-	ntfs_debug("Entering for i_ino 0x%lx, start_bit 0x%llx, count 0x%llx, "
+	ntfs_debug("Entering for i_ino 0x%llx, start_bit 0x%llx, count 0x%llx, "
 			"value %u.%s", vi->i_ino, (unsigned long long)start_bit,
 			(unsigned long long)cnt, (unsigned int)value,
 			is_rollback ? " (rollback)" : "");
diff --git a/fs/ntfs/dir.c b/fs/ntfs/dir.c
index d1e2c6f..ba4ae09 100644
--- a/fs/ntfs/dir.c
+++ b/fs/ntfs/dir.c
@@ -1117,7 +1117,7 @@ static int ntfs_readdir(struct file *fil
 	ntfs_attr_search_ctx *ctx;
 
 	fpos = filp->f_pos;
-	ntfs_debug("Entering for inode 0x%lx, fpos 0x%llx.",
+	ntfs_debug("Entering for inode 0x%llx, fpos 0x%llx.",
 			vdir->i_ino, fpos);
 	rc = err = 0;
 	/* Are we at end of dir yet? */
@@ -1127,7 +1127,7 @@ static int ntfs_readdir(struct file *fil
 	/* Emulate . and .. for all directories. */
 	if (!fpos) {
 		ntfs_debug("Calling filldir for . with len 1, fpos 0x0, "
-				"inode 0x%lx, DT_DIR.", vdir->i_ino);
+				"inode 0x%llx, DT_DIR.", vdir->i_ino);
 		rc = filldir(dirent, ".", 1, fpos, vdir->i_ino, DT_DIR);
 		if (rc)
 			goto done;
@@ -1177,7 +1177,7 @@ static int ntfs_readdir(struct file *fil
 			0, ctx);
 	if (unlikely(err)) {
 		ntfs_error(sb, "Index root attribute missing in directory "
-				"inode 0x%lx.", vdir->i_ino);
+				"inode 0x%llx.", vdir->i_ino);
 		goto err_out;
 	}
 	/*
@@ -1252,7 +1252,7 @@ skip_index_root:
 	ia_mapping = vdir->i_mapping;
 	bmp_vi = ndir->itype.index.bmp_ino;
 	if (unlikely(!bmp_vi)) {
-		ntfs_debug("Inode 0x%lx, regetting index bitmap.", vdir->i_ino);
+		ntfs_debug("Inode 0x%llx, regetting index bitmap.", vdir->i_ino);
 		bmp_vi = ntfs_attr_iget(vdir, AT_BITMAP, I30, 4);
 		if (IS_ERR(bmp_vi)) {
 			ntfs_error(sb, "Failed to get bitmap attribute.");
@@ -1336,13 +1336,13 @@ find_next_index_buffer:
 	/* Bounds checks. */
 	if (unlikely((u8*)ia < kaddr || (u8*)ia > kaddr + PAGE_CACHE_SIZE)) {
 		ntfs_error(sb, "Out of bounds check failed. Corrupt directory "
-				"inode 0x%lx or driver bug.", vdir->i_ino);
+				"inode 0x%llx or driver bug.", vdir->i_ino);
 		goto err_out;
 	}
 	/* Catch multi sector transfer fixup errors. */
 	if (unlikely(!ntfs_is_indx_record(ia->magic))) {
 		ntfs_error(sb, "Directory index record with vcn 0x%llx is "
-				"corrupt.  Corrupt inode 0x%lx.  Run chkdsk.",
+				"corrupt.  Corrupt inode 0x%llx.  Run chkdsk.",
 				(unsigned long long)ia_pos >>
 				ndir->itype.index.vcn_size_bits, vdir->i_ino);
 		goto err_out;
@@ -1352,7 +1352,7 @@ find_next_index_buffer:
 			ndir->itype.index.vcn_size_bits)) {
 		ntfs_error(sb, "Actual VCN (0x%llx) of index buffer is "
 				"different from expected VCN (0x%llx). "
-				"Directory inode 0x%lx is corrupt or driver "
+				"Directory inode 0x%llx is corrupt or driver "
 				"bug. ", (unsigned long long)
 				sle64_to_cpu(ia->index_block_vcn),
 				(unsigned long long)ia_pos >>
@@ -1362,7 +1362,7 @@ find_next_index_buffer:
 	if (unlikely(le32_to_cpu(ia->index.allocated_size) + 0x18 !=
 			ndir->itype.index.block_size)) {
 		ntfs_error(sb, "Index buffer (VCN 0x%llx) of directory inode "
-				"0x%lx has a size (%u) differing from the "
+				"0x%llx has a size (%u) differing from the "
 				"directory specified size (%u). Directory "
 				"inode is corrupt or driver bug.",
 				(unsigned long long)ia_pos >>
@@ -1374,7 +1374,7 @@ find_next_index_buffer:
 	index_end = (u8*)ia + ndir->itype.index.block_size;
 	if (unlikely(index_end > kaddr + PAGE_CACHE_SIZE)) {
 		ntfs_error(sb, "Index buffer (VCN 0x%llx) of directory inode "
-				"0x%lx crosses page boundary. Impossible! "
+				"0x%llx crosses page boundary. Impossible! "
 				"Cannot access! This is probably a bug in the "
 				"driver.", (unsigned long long)ia_pos >>
 				ndir->itype.index.vcn_size_bits, vdir->i_ino);
@@ -1384,7 +1384,7 @@ find_next_index_buffer:
 	index_end = (u8*)&ia->index + le32_to_cpu(ia->index.index_length);
 	if (unlikely(index_end > (u8*)ia + ndir->itype.index.block_size)) {
 		ntfs_error(sb, "Size of index buffer (VCN 0x%llx) of directory "
-				"inode 0x%lx exceeds maximum size.",
+				"inode 0x%llx exceeds maximum size.",
 				(unsigned long long)ia_pos >>
 				ndir->itype.index.vcn_size_bits, vdir->i_ino);
 		goto err_out;
@@ -1534,7 +1534,7 @@ static int ntfs_dir_fsync(struct file *f
 	ntfs_inode *ni = NTFS_I(vi);
 	int err, ret;
 
-	ntfs_debug("Entering for inode 0x%lx.", vi->i_ino);
+	ntfs_debug("Entering for inode 0x%llx.", vi->i_ino);
 	BUG_ON(!S_ISDIR(vi->i_mode));
 	if (NInoIndexAllocPresent(ni) && ni->itype.index.bmp_ino)
 		write_inode_now(ni->itype.index.bmp_ino, !datasync);
@@ -1546,7 +1546,7 @@ static int ntfs_dir_fsync(struct file *f
 	if (likely(!ret))
 		ntfs_debug("Done.");
 	else
-		ntfs_warning(vi->i_sb, "Failed to f%ssync inode 0x%lx.  Error "
+		ntfs_warning(vi->i_sb, "Failed to f%ssync inode 0x%llx.  Error "
 				"%u.", datasync ? "data" : "", vi->i_ino, -ret);
 	return ret;
 }
diff --git a/fs/ntfs/file.c b/fs/ntfs/file.c
index 2e42c2d..4716b42 100644
--- a/fs/ntfs/file.c
+++ b/fs/ntfs/file.c
@@ -132,7 +132,7 @@ static int ntfs_attr_extend_initialized(
 	old_i_size = i_size_read(vi);
 	BUG_ON(new_init_size > ni->allocated_size);
 	read_unlock_irqrestore(&ni->size_lock, flags);
-	ntfs_debug("Entering for i_ino 0x%lx, attribute type 0x%x, "
+	ntfs_debug("Entering for i_ino 0x%llx, attribute type 0x%x, "
 			"old_initialized_size 0x%llx, "
 			"new_initialized_size 0x%llx, i_size 0x%llx.",
 			vi->i_ino, (unsigned)le32_to_cpu(ni->type),
@@ -524,7 +524,7 @@ static int ntfs_prepare_pages_for_non_re
 	vi = pages[0]->mapping->host;
 	ni = NTFS_I(vi);
 	vol = ni->vol;
-	ntfs_debug("Entering for inode 0x%lx, attribute type 0x%x, start page "
+	ntfs_debug("Entering for inode 0x%llx, attribute type 0x%x, start page "
 			"index 0x%lx, nr_pages 0x%x, pos 0x%llx, bytes 0x%zx.",
 			vi->i_ino, ni->type, pages[0]->index, nr_pages,
 			(long long)pos, bytes);
@@ -1041,7 +1041,7 @@ rl_not_mapped_enoent:
 				a->data.non_resident.mapping_pairs_offset),
 				mp_size, rl2, vcn, highest_vcn, NULL);
 		if (unlikely(err)) {
-			ntfs_error(vol->sb, "Cannot fill hole in inode 0x%lx, "
+			ntfs_error(vol->sb, "Cannot fill hole in inode 0x%llx, "
 					"attribute type 0x%x, because building "
 					"the mapping pairs failed with error "
 					"code %i.", vi->i_ino,
@@ -1682,7 +1682,7 @@ static int ntfs_commit_pages_after_write
 	BUG_ON(!page);
 	vi = page->mapping->host;
 	ni = NTFS_I(vi);
-	ntfs_debug("Entering for inode 0x%lx, attribute type 0x%x, start page "
+	ntfs_debug("Entering for inode 0x%llx, attribute type 0x%x, start page "
 			"index 0x%lx, nr_pages 0x%x, pos 0x%llx, bytes 0x%zx.",
 			vi->i_ino, ni->type, page->index, nr_pages,
 			(long long)pos, bytes);
@@ -1830,7 +1830,7 @@ static ssize_t ntfs_file_buffered_write(
 	int err;
 	struct pagevec lru_pvec;
 
-	ntfs_debug("Entering for i_ino 0x%lx, attribute type 0x%x, "
+	ntfs_debug("Entering for i_ino 0x%llx, attribute type 0x%x, "
 			"pos 0x%llx, count 0x%lx.",
 			vi->i_ino, (unsigned)le32_to_cpu(ni->type),
 			(unsigned long long)pos, (unsigned long)count);
@@ -1881,7 +1881,7 @@ static ssize_t ntfs_file_buffered_write(
 			if (!err)
 				err = -EIO;
 			ntfs_error(vol->sb, "Cannot perform write to inode "
-					"0x%lx, attribute type 0x%x, because "
+					"0x%llx, attribute type 0x%x, because "
 					"ntfs_truncate() failed (error code "
 					"%i).", vi->i_ino,
 					(unsigned)le32_to_cpu(ni->type), err);
@@ -1904,7 +1904,7 @@ static ssize_t ntfs_file_buffered_write(
 			BUG_ON(pos >= ll);
 			/* If the extension was partial truncate the write. */
 			if (end > ll) {
-				ntfs_debug("Truncating write to inode 0x%lx, "
+				ntfs_debug("Truncating write to inode 0x%llx, "
 						"attribute type 0x%x, because "
 						"the allocation was only "
 						"partially extended.",
@@ -1920,7 +1920,7 @@ static ssize_t ntfs_file_buffered_write(
 			read_unlock_irqrestore(&ni->size_lock, flags);
 			/* Perform a partial write if possible or fail. */
 			if (pos < ll) {
-				ntfs_debug("Truncating write to inode 0x%lx, "
+				ntfs_debug("Truncating write to inode 0x%llx, "
 						"attribute type 0x%x, because "
 						"extending the allocation "
 						"failed (error code %i).",
@@ -1930,7 +1930,7 @@ static ssize_t ntfs_file_buffered_write(
 				count = ll - pos;
 			} else {
 				ntfs_error(vol->sb, "Cannot perform write to "
-						"inode 0x%lx, attribute type "
+						"inode 0x%llx, attribute type "
 						"0x%x, because extending the "
 						"allocation failed (error "
 						"code %i).", vi->i_ino,
@@ -1957,7 +1957,7 @@ static ssize_t ntfs_file_buffered_write(
 				&lru_pvec);
 		if (err < 0) {
 			ntfs_error(vol->sb, "Cannot perform write to inode "
-					"0x%lx, attribute type 0x%x, because "
+					"0x%llx, attribute type 0x%x, because "
 					"extending the initialized size "
 					"failed (error code %i).", vi->i_ino,
 					(unsigned)le32_to_cpu(ni->type), err);
@@ -2006,7 +2006,7 @@ static ssize_t ntfs_file_buffered_write(
 					else
 						ntfs_error(vol->sb, "Cannot "
 							"perform write to "
-							"inode 0x%lx, "
+							"inode 0x%llx, "
 							"attribute type 0x%x, "
 							"because the attribute "
 							"is corrupt.",
@@ -2273,7 +2273,7 @@ static int ntfs_file_fsync(struct file *
 	struct inode *vi = dentry->d_inode;
 	int err, ret = 0;
 
-	ntfs_debug("Entering for inode 0x%lx.", vi->i_ino);
+	ntfs_debug("Entering for inode 0x%llx.", vi->i_ino);
 	BUG_ON(S_ISDIR(vi->i_mode));
 	if (!datasync || !NInoNonResident(NTFS_I(vi)))
 		ret = ntfs_write_inode(vi, 1);
@@ -2289,7 +2289,7 @@ static int ntfs_file_fsync(struct file *
 	if (likely(!ret))
 		ntfs_debug("Done.");
 	else
-		ntfs_warning(vi->i_sb, "Failed to f%ssync inode 0x%lx.  Error "
+		ntfs_warning(vi->i_sb, "Failed to f%ssync inode 0x%llx.  Error "
 				"%u.", datasync ? "data" : "", vi->i_ino, -ret);
 	return ret;
 }
diff --git a/fs/ntfs/inode.c b/fs/ntfs/inode.c
index d313f35..0bce771 100644
--- a/fs/ntfs/inode.c
+++ b/fs/ntfs/inode.c
@@ -552,7 +552,7 @@ static int ntfs_read_locked_inode(struct
 	ntfs_attr_search_ctx *ctx;
 	int err = 0;
 
-	ntfs_debug("Entering for i_ino 0x%lx.", vi->i_ino);
+	ntfs_debug("Entering for i_ino 0x%llx.", vi->i_ino);
 
 	/* Setup the generic vfs inode parts now. */
 
@@ -696,7 +696,7 @@ static int ntfs_read_locked_inode(struct
 	} else /* if (!err) */ {
 		if (vi->i_ino == FILE_MFT)
 			goto skip_attr_list_load;
-		ntfs_debug("Attribute list found in inode 0x%lx.", vi->i_ino);
+		ntfs_debug("Attribute list found in inode 0x%llx.", vi->i_ino);
 		NInoSetAttrList(ni);
 		a = ctx->attr;
 		if (a->flags & ATTR_COMPRESSION_MASK) {
@@ -713,7 +713,7 @@ static int ntfs_read_locked_inode(struct
 				goto unm_err_out;
 			}
 			ntfs_warning(vi->i_sb, "Resident attribute list "
-					"attribute in inode 0x%lx is marked "
+					"attribute in inode 0x%llx is marked "
 					"encrypted/sparse which is not true.  "
 					"However, Windows allows this and "
 					"chkdsk does not detect or correct it "
@@ -1188,7 +1188,7 @@ unm_err_out:
 		unmap_mft_record(ni);
 err_out:
 	ntfs_error(vol->sb, "Failed with error code %i.  Marking corrupt "
-			"inode 0x%lx as bad.  Run chkdsk.", err, vi->i_ino);
+			"inode 0x%llx as bad.  Run chkdsk.", err, vi->i_ino);
 	make_bad_inode(vi);
 	if (err != -EOPNOTSUPP && err != -ENOMEM)
 		NVolSetErrors(vol);
@@ -1226,7 +1226,7 @@ static int ntfs_read_locked_attr_inode(s
 	ntfs_attr_search_ctx *ctx;
 	int err = 0;
 
-	ntfs_debug("Entering for i_ino 0x%lx.", vi->i_ino);
+	ntfs_debug("Entering for i_ino 0x%llx.", vi->i_ino);
 
 	ntfs_init_big_inode(vi);
 
@@ -1443,8 +1443,8 @@ unm_err_out:
 	unmap_mft_record(base_ni);
 err_out:
 	ntfs_error(vol->sb, "Failed with error code %i while reading attribute "
-			"inode (mft_no 0x%lx, type 0x%x, name_len %i).  "
-			"Marking corrupt inode and base inode 0x%lx as bad.  "
+			"inode (mft_no 0x%llx, type 0x%x, name_len %i).  "
+			"Marking corrupt inode and base inode 0x%llx as bad.  "
 			"Run chkdsk.", err, vi->i_ino, ni->type, ni->name_len,
 			base_vi->i_ino);
 	make_bad_inode(vi);
@@ -1499,7 +1499,7 @@ static int ntfs_read_locked_index_inode(
 	u8 *ir_end, *index_end;
 	int err = 0;
 
-	ntfs_debug("Entering for i_ino 0x%lx.", vi->i_ino);
+	ntfs_debug("Entering for i_ino 0x%llx.", vi->i_ino);
 	ntfs_init_big_inode(vi);
 	ni	= NTFS_I(vi);
 	base_ni = NTFS_I(base_vi);
@@ -1730,7 +1730,7 @@ unm_err_out:
 		unmap_mft_record(base_ni);
 err_out:
 	ntfs_error(vi->i_sb, "Failed with error code %i while reading index "
-			"inode (mft_no 0x%lx, name_len %i.", err, vi->i_ino,
+			"inode (mft_no 0x%llx, name_len %i.", err, vi->i_ino,
 			ni->name_len);
 	make_bad_inode(vi);
 	if (err != -EOPNOTSUPP && err != -ENOMEM)
@@ -2312,7 +2312,7 @@ #ifdef NTFS_RW
 
 		if (!was_bad && (is_bad_inode(vi) || NInoDirty(ni))) {
 			ntfs_error(vi->i_sb, "Failed to commit dirty inode "
-					"0x%lx.  Losing data!", vi->i_ino);
+					"0x%llx.  Losing data!", vi->i_ino);
 			// FIXME:  Do something!!!
 		}
 	}
@@ -2420,7 +2420,7 @@ int ntfs_truncate(struct inode *vi)
 	int err, mp_size, size_change, alloc_change;
 	u32 attr_len;
 
-	ntfs_debug("Entering for inode 0x%lx.", vi->i_ino);
+	ntfs_debug("Entering for inode 0x%llx.", vi->i_ino);
 	BUG_ON(NInoAttr(ni));
 	BUG_ON(S_ISDIR(vi->i_mode));
 	BUG_ON(NInoMstProtected(ni));
@@ -2438,7 +2438,7 @@ retry_truncate:
 	m = map_mft_record(base_ni);
 	if (IS_ERR(m)) {
 		err = PTR_ERR(m);
-		ntfs_error(vi->i_sb, "Failed to map mft record for inode 0x%lx "
+		ntfs_error(vi->i_sb, "Failed to map mft record for inode 0x%llx "
 				"(error code %d).%s", vi->i_ino, err, te);
 		ctx = NULL;
 		m = NULL;
@@ -2447,7 +2447,7 @@ retry_truncate:
 	ctx = ntfs_attr_get_search_ctx(base_ni, m);
 	if (unlikely(!ctx)) {
 		ntfs_error(vi->i_sb, "Failed to allocate a search context for "
-				"inode 0x%lx (not enough memory).%s",
+				"inode 0x%llx (not enough memory).%s",
 				vi->i_ino, te);
 		err = -ENOMEM;
 		goto old_bad_out;
@@ -2457,12 +2457,12 @@ retry_truncate:
 	if (unlikely(err)) {
 		if (err == -ENOENT) {
 			ntfs_error(vi->i_sb, "Open attribute is missing from "
-					"mft record.  Inode 0x%lx is corrupt.  "
+					"mft record.  Inode 0x%llx is corrupt.  "
 					"Run chkdsk.%s", vi->i_ino, te);
 			err = -EIO;
 		} else
 			ntfs_error(vi->i_sb, "Failed to lookup attribute in "
-					"inode 0x%lx (error code %d).%s",
+					"inode 0x%llx (error code %d).%s",
 					vi->i_ino, err, te);
 		goto old_bad_out;
 	}
@@ -2513,7 +2513,7 @@ retry_truncate:
 		if (unlikely(err)) {
 			if (err == -ERANGE) {
 				ntfs_error(vol->sb, "Truncate would cause the "
-						"inode 0x%lx to %simum size "
+						"inode 0x%llx to %simum size "
 						"for its attribute type "
 						"(0x%x).  Aborting truncate.",
 						vi->i_ino,
@@ -2522,7 +2522,7 @@ retry_truncate:
 						le32_to_cpu(ni->type));
 				err = -EFBIG;
 			} else {
-				ntfs_error(vol->sb, "Inode 0x%lx has unknown "
+				ntfs_error(vol->sb, "Inode 0x%llx has unknown "
 						"attribute type 0x%x.  "
 						"Aborting truncate.",
 						vi->i_ino,
@@ -2616,7 +2616,7 @@ retry_truncate:
 	 * try to make other attributes non-resident.  Otherwise fail.
 	 */
 	if (unlikely(err != -EPERM && err != -ENOSPC)) {
-		ntfs_error(vol->sb, "Cannot truncate inode 0x%lx, attribute "
+		ntfs_error(vol->sb, "Cannot truncate inode 0x%llx, attribute "
 				"type 0x%x, because the conversion from "
 				"resident to non-resident attribute failed "
 				"with error code %i.", vi->i_ino,
@@ -2675,7 +2675,7 @@ do_non_resident_truncate:
 			 * This attribute has multiple extents.  Not yet
 			 * supported.
 			 */
-			ntfs_error(vol->sb, "Cannot truncate inode 0x%lx, "
+			ntfs_error(vol->sb, "Cannot truncate inode 0x%llx, "
 					"attribute type 0x%x, because the "
 					"attribute is highly fragmented (it "
 					"consists of multiple extents) and "
@@ -2781,7 +2781,7 @@ do_non_resident_truncate:
 	/* Get the size for the shrunk mapping pairs array for the runlist. */
 	mp_size = ntfs_get_size_for_mapping_pairs(vol, ni->runlist.rl, 0, -1);
 	if (unlikely(mp_size <= 0)) {
-		ntfs_error(vol->sb, "Cannot shrink allocation of inode 0x%lx, "
+		ntfs_error(vol->sb, "Cannot shrink allocation of inode 0x%llx, "
 				"attribute type 0x%x, because determining the "
 				"size for the mapping pairs failed with error "
 				"code %i.%s", vi->i_ino,
@@ -2805,7 +2805,7 @@ do_non_resident_truncate:
 			le16_to_cpu(a->data.non_resident.mapping_pairs_offset),
 			mp_size, ni->runlist.rl, 0, -1, NULL);
 	if (unlikely(err)) {
-		ntfs_error(vol->sb, "Cannot shrink allocation of inode 0x%lx, "
+		ntfs_error(vol->sb, "Cannot shrink allocation of inode 0x%llx, "
 				"attribute type 0x%x, because building the "
 				"mapping pairs failed with error code %i.%s",
 				vi->i_ino, (unsigned)le32_to_cpu(ni->type),
@@ -3021,7 +3021,7 @@ int ntfs_write_inode(struct inode *vi, i
 	int err = 0;
 	BOOL modified = FALSE;
 
-	ntfs_debug("Entering for %sinode 0x%lx.", NInoAttr(ni) ? "attr " : "",
+	ntfs_debug("Entering for %sinode 0x%llx.", NInoAttr(ni) ? "attr " : "",
 			vi->i_ino);
 	/*
 	 * Dirty attribute inodes are written via their real inodes so just
@@ -3056,7 +3056,7 @@ int ntfs_write_inode(struct inode *vi, i
 	/* Update the access times if they have changed. */
 	nt = utc2ntfs(vi->i_mtime);
 	if (si->last_data_change_time != nt) {
-		ntfs_debug("Updating mtime for inode 0x%lx: old = 0x%llx, "
+		ntfs_debug("Updating mtime for inode 0x%llx: old = 0x%llx, "
 				"new = 0x%llx", vi->i_ino, (long long)
 				sle64_to_cpu(si->last_data_change_time),
 				(long long)sle64_to_cpu(nt));
@@ -3065,7 +3065,7 @@ int ntfs_write_inode(struct inode *vi, i
 	}
 	nt = utc2ntfs(vi->i_ctime);
 	if (si->last_mft_change_time != nt) {
-		ntfs_debug("Updating ctime for inode 0x%lx: old = 0x%llx, "
+		ntfs_debug("Updating ctime for inode 0x%llx: old = 0x%llx, "
 				"new = 0x%llx", vi->i_ino, (long long)
 				sle64_to_cpu(si->last_mft_change_time),
 				(long long)sle64_to_cpu(nt));
@@ -3074,7 +3074,7 @@ int ntfs_write_inode(struct inode *vi, i
 	}
 	nt = utc2ntfs(vi->i_atime);
 	if (si->last_access_time != nt) {
-		ntfs_debug("Updating atime for inode 0x%lx: old = 0x%llx, "
+		ntfs_debug("Updating atime for inode 0x%llx: old = 0x%llx, "
 				"new = 0x%llx", vi->i_ino,
 				(long long)sle64_to_cpu(si->last_access_time),
 				(long long)sle64_to_cpu(nt));
diff --git a/fs/ntfs/namei.c b/fs/ntfs/namei.c
index eddb224..3a40545 100644
--- a/fs/ntfs/namei.c
+++ b/fs/ntfs/namei.c
@@ -109,7 +109,7 @@ static struct dentry *ntfs_lookup(struct
 	unsigned long dent_ino;
 	int uname_len;
 
-	ntfs_debug("Looking up %s in directory inode 0x%lx.",
+	ntfs_debug("Looking up %s in directory inode 0x%llx.",
 			dent->d_name.name, dir_ino->i_ino);
 	/* Convert the name of the dentry to Unicode. */
 	uname_len = ntfs_nlstoucs(vol, dent->d_name.name, dent->d_name.len,
@@ -393,7 +393,7 @@ static struct dentry *ntfs_get_parent(st
 	unsigned long parent_ino;
 	int err;
 
-	ntfs_debug("Entering for inode 0x%lx.", vi->i_ino);
+	ntfs_debug("Entering for inode 0x%llx.", vi->i_ino);
 	/* Get the mft record of the inode belonging to the child dentry. */
 	mrec = map_mft_record(ni);
 	if (IS_ERR(mrec))
@@ -411,7 +411,7 @@ try_next:
 		ntfs_attr_put_search_ctx(ctx);
 		unmap_mft_record(ni);
 		if (err == -ENOENT)
-			ntfs_error(vi->i_sb, "Inode 0x%lx does not have a "
+			ntfs_error(vi->i_sb, "Inode 0x%llx does not have a "
 					"file name attribute.  Run chkdsk.",
 					vi->i_ino);
 		return ERR_PTR(err);
@@ -435,7 +435,7 @@ try_next:
 		if (!IS_ERR(parent_vi))
 			iput(parent_vi);
 		ntfs_error(vi->i_sb, "Failed to get parent directory inode "
-				"0x%lx of child inode 0x%lx.", parent_ino,
+				"0x%lx of child inode 0x%llx.", parent_ino,
 				vi->i_ino);
 		return ERR_PTR(-EACCES);
 	}
@@ -445,7 +445,7 @@ try_next:
 		iput(parent_vi);
 		return ERR_PTR(-ENOMEM);
 	}
-	ntfs_debug("Done for inode 0x%lx.", vi->i_ino);
+	ntfs_debug("Done for inode 0x%llx.", vi->i_ino);
 	return parent_dent;
 }
 
@@ -480,7 +480,7 @@ static struct dentry *ntfs_get_dentry(st
 	}
 	if (unlikely(is_bad_inode(vi) || vi->i_generation != gen)) {
 		/* We didn't find the right inode. */
-		ntfs_error(sb, "Inode 0x%lx, bad count: %d %d or version 0x%x "
+		ntfs_error(sb, "Inode 0x%llx, bad count: %d %d or version 0x%x "
 				"0x%x.", vi->i_ino, vi->i_nlink,
 				atomic_read(&vi->i_count), vi->i_generation,
 				gen);
diff --git a/fs/ocfs2/aops.c b/fs/ocfs2/aops.c
index f1d1c34..3954512 100644
--- a/fs/ocfs2/aops.c
+++ b/fs/ocfs2/aops.c
@@ -140,7 +140,7 @@ static int ocfs2_get_block(struct inode 
 		   (unsigned long long)iblock, bh_result, create);
 
 	if (OCFS2_I(inode)->ip_flags & OCFS2_INODE_SYSTEM_FILE)
-		mlog(ML_NOTICE, "get_block on system inode 0x%p (%lu)\n",
+		mlog(ML_NOTICE, "get_block on system inode 0x%p (%llu)\n",
 		     inode, inode->i_ino);
 
 	if (S_ISLNK(inode->i_mode)) {
@@ -178,7 +178,7 @@ static int ocfs2_get_block(struct inode 
 	}
 
 	past_eof = ocfs2_blocks_for_bytes(inode->i_sb, i_size_read(inode));
-	mlog(0, "Inode %lu, past_eof = %llu\n", inode->i_ino,
+	mlog(0, "Inode %llu, past_eof = %llu\n", inode->i_ino,
 	     (unsigned long long)past_eof);
 
 	if (create && (iblock >= past_eof))
diff --git a/fs/ocfs2/dlm/dlmfs.c b/fs/ocfs2/dlm/dlmfs.c
index 033ad17..1956f05 100644
--- a/fs/ocfs2/dlm/dlmfs.c
+++ b/fs/ocfs2/dlm/dlmfs.c
@@ -105,7 +105,7 @@ static int dlmfs_file_open(struct inode 
 	if (S_ISDIR(inode->i_mode))
 		BUG();
 
-	mlog(0, "open called on inode %lu, flags 0x%x\n", inode->i_ino,
+	mlog(0, "open called on inode %llu, flags 0x%x\n", inode->i_ino,
 		file->f_flags);
 
 	status = dlmfs_decode_open_flags(file->f_flags, &level, &flags);
@@ -153,7 +153,7 @@ static int dlmfs_file_release(struct ino
 	if (S_ISDIR(inode->i_mode))
 		BUG();
 
-	mlog(0, "close called on inode %lu\n", inode->i_ino);
+	mlog(0, "close called on inode %llu\n", inode->i_ino);
 
 	status = 0;
 	if (fp) {
@@ -178,7 +178,7 @@ static ssize_t dlmfs_file_read(struct fi
 	char *lvb_buf;
 	struct inode *inode = filp->f_dentry->d_inode;
 
-	mlog(0, "inode %lu, count = %zu, *ppos = %llu\n",
+	mlog(0, "inode %llu, count = %zu, *ppos = %llu\n",
 		inode->i_ino, count, *ppos);
 
 	if (*ppos >= i_size_read(inode))
@@ -222,7 +222,7 @@ static ssize_t dlmfs_file_write(struct f
 	char *lvb_buf;
 	struct inode *inode = filp->f_dentry->d_inode;
 
-	mlog(0, "inode %lu, count = %zu, *ppos = %llu\n",
+	mlog(0, "inode %llu, count = %zu, *ppos = %llu\n",
 		inode->i_ino, count, *ppos);
 
 	if (*ppos >= i_size_read(inode))
@@ -296,7 +296,7 @@ static void dlmfs_clear_inode(struct ino
 	if (!inode)
 		return;
 
-	mlog(0, "inode %lu\n", inode->i_ino);
+	mlog(0, "inode %llu\n", inode->i_ino);
 
 	ip = DLMFS_I(inode);
 
@@ -502,7 +502,7 @@ static int dlmfs_unlink(struct inode *di
 	int status;
 	struct inode *inode = dentry->d_inode;
 
-	mlog(0, "unlink inode %lu\n", inode->i_ino);
+	mlog(0, "unlink inode %llu\n", inode->i_ino);
 
 	/* if there are no current holders, or none that are waiting
 	 * to acquire a lock, this basically destroys our lockres. */
diff --git a/fs/ocfs2/inode.c b/fs/ocfs2/inode.c
index 327a5b7..6fac016 100644
--- a/fs/ocfs2/inode.c
+++ b/fs/ocfs2/inode.c
@@ -157,7 +157,7 @@ static int ocfs2_find_actor(struct inode
 	struct ocfs2_inode_info *oi = OCFS2_I(inode);
 	int ret = 0;
 
-	mlog_entry("(0x%p, %lu, 0x%p)\n", inode, inode->i_ino, opaque);
+	mlog_entry("(0x%p, %llu, 0x%p)\n", inode, inode->i_ino, opaque);
 
 	args = opaque;
 
@@ -229,7 +229,7 @@ int ocfs2_populate_inode(struct inode *i
 	 * today.  change if needed. */
 	if (!OCFS2_IS_VALID_DINODE(fe) ||
 	    !(fe->i_flags & cpu_to_le32(OCFS2_VALID_FL))) {
-		mlog(ML_ERROR, "Invalid dinode: i_ino=%lu, i_blkno=%llu, "
+		mlog(ML_ERROR, "Invalid dinode: i_ino=%llu, i_blkno=%llu, "
 		     "signature = %.*s, flags = 0x%x\n",
 		     inode->i_ino,
 		     (unsigned long long)le64_to_cpu(fe->i_blkno), 7,
@@ -281,18 +281,18 @@ int ocfs2_populate_inode(struct inode *i
 		inode->i_ino = ino_from_blkno(inode->i_sb,
 			       le64_to_cpu(fe->i_blkno));
 
-	mlog(0, "blkno = %llu, ino = %lu, create_ino = %s\n",
+	mlog(0, "blkno = %llu, ino = %llu, create_ino = %s\n",
 	     (unsigned long long)fe->i_blkno, inode->i_ino, create_ino ? "true" : "false");
 
 	inode->i_nlink = le16_to_cpu(fe->i_links_count);
 
 	if (fe->i_flags & cpu_to_le32(OCFS2_LOCAL_ALLOC_FL)) {
 		OCFS2_I(inode)->ip_flags |= OCFS2_INODE_BITMAP;
-		mlog(0, "local alloc inode: i_ino=%lu\n", inode->i_ino);
+		mlog(0, "local alloc inode: i_ino=%llu\n", inode->i_ino);
 	} else if (fe->i_flags & cpu_to_le32(OCFS2_BITMAP_FL)) {
 		OCFS2_I(inode)->ip_flags |= OCFS2_INODE_BITMAP;
 	} else if (fe->i_flags & cpu_to_le32(OCFS2_SUPER_BLOCK_FL)) {
-		mlog(0, "superblock inode: i_ino=%lu\n", inode->i_ino);
+		mlog(0, "superblock inode: i_ino=%llu\n", inode->i_ino);
 		/* we can't actually hit this as read_inode can't
 		 * handle superblocks today ;-) */
 		BUG();
@@ -389,7 +389,7 @@ static int ocfs2_read_locked_inode(struc
 
 	status = -EINVAL;
 	if (ocfs2_populate_inode(inode, fe, 0) < 0) {
-		mlog(ML_ERROR, "populate failed! i_blkno=%llu, i_ino=%lu\n",
+		mlog(ML_ERROR, "populate failed! i_blkno=%llu, i_ino=%llu\n",
 		     (unsigned long long)fe->i_blkno, inode->i_ino);
 		make_bad_inode(inode);
 		goto bail;
@@ -668,7 +668,7 @@ static int ocfs2_inode_is_valid_to_delet
 	 * the node who's doing the actual deleting should handle it
 	 * anyway. */
 	if (current == osb->vote_task) {
-		mlog(0, "Skipping delete of %lu because we're currently "
+		mlog(0, "Skipping delete of %llu because we're currently "
 		     "in process_vote\n", inode->i_ino);
 		goto bail;
 	}
@@ -688,7 +688,7 @@ static int ocfs2_inode_is_valid_to_delet
 	 * it. Recovery will cleanup any inodes we might inadvertantly
 	 * skip here. */
 	if (oi->ip_flags & OCFS2_INODE_SKIP_DELETE) {
-		mlog(0, "Skipping delete of %lu because another node "
+		mlog(0, "Skipping delete of %llu because another node "
 		     "has done this for us.\n", inode->i_ino);
 		goto bail_unlock;
 	}
@@ -806,7 +806,7 @@ void ocfs2_delete_inode(struct inode *in
 	sigset_t blocked, oldset;
 	struct buffer_head *di_bh = NULL;
 
-	mlog_entry("(inode->i_ino = %lu)\n", inode->i_ino);
+	mlog_entry("(inode->i_ino = %llu)\n", inode->i_ino);
 
 	if (is_bad_inode(inode)) {
 		mlog(0, "Skipping delete of bad inode\n");
@@ -906,7 +906,7 @@ void ocfs2_clear_inode(struct inode *ino
 	     (unsigned long long)OCFS2_I(inode)->ip_blkno, inode->i_nlink);
 
 	mlog_bug_on_msg(OCFS2_SB(inode->i_sb) == NULL,
-			"Inode=%lu\n", inode->i_ino);
+			"Inode=%llu\n", inode->i_ino);
 
 	/* Do these before all the other work so that we don't bounce
 	 * the vote thread while waiting to destroy the locks. */
diff --git a/fs/ocfs2/namei.c b/fs/ocfs2/namei.c
index 0673862..9f40cbc 100644
--- a/fs/ocfs2/namei.c
+++ b/fs/ocfs2/namei.c
@@ -563,7 +563,7 @@ static int ocfs2_mknod_locked(struct ocf
 
 	if (ocfs2_populate_inode(inode, fe, 1) < 0) {
 		mlog(ML_ERROR, "populate inode failed! bh->b_blocknr=%llu, "
-		     "i_blkno=%llu, i_ino=%lu\n",
+		     "i_blkno=%llu, i_ino=%llu\n",
 		     (unsigned long long) (*new_fe_bh)->b_blocknr,
 		     (unsigned long long)fe->i_blkno, inode->i_ino);
 		BUG();
@@ -634,7 +634,7 @@ static int ocfs2_link(struct dentry *old
 	struct ocfs2_dinode *fe = NULL;
 	struct ocfs2_super *osb = OCFS2_SB(dir->i_sb);
 
-	mlog_entry("(inode=%lu, old='%.*s' new='%.*s')\n", inode->i_ino,
+	mlog_entry("(inode=%llu, old='%.*s' new='%.*s')\n", inode->i_ino,
 		   old_dentry->d_name.len, old_dentry->d_name.name,
 		   dentry->d_name.len, dentry->d_name.name);
 
@@ -1166,7 +1166,7 @@ static int ocfs2_rename(struct inode *ol
 	}
 
 	if (!new_de && new_inode)
-		mlog(ML_ERROR, "inode %lu does not exist in it's parent "
+		mlog(ML_ERROR, "inode %llu does not exist in it's parent "
 		     "directory!", new_inode->i_ino);
 
 	/* In case we need to overwrite an existing file, we blow it
@@ -2112,7 +2112,7 @@ static int ocfs2_orphan_add(struct ocfs2
 	int status = 0;
 	struct ocfs2_dinode *orphan_fe;
 
-	mlog_entry("(inode->i_ino = %lu)\n", inode->i_ino);
+	mlog_entry("(inode->i_ino = %llu)\n", inode->i_ino);
 
 	orphan_dir_inode = ocfs2_get_system_file_inode(osb,
 						       ORPHAN_DIR_SYSTEM_INODE,
diff --git a/fs/ocfs2/vote.c b/fs/ocfs2/vote.c
index cf70fe2..b35741d 100644
--- a/fs/ocfs2/vote.c
+++ b/fs/ocfs2/vote.c
@@ -174,7 +174,7 @@ static int ocfs2_process_delete_request(
 {
 	int response = OCFS2_RESPONSE_BUSY;
 
-	mlog(0, "DELETE vote on inode %lu, read lnk_cnt = %u, slot = %d\n",
+	mlog(0, "DELETE vote on inode %llu, read lnk_cnt = %u, slot = %d\n",
 	     inode->i_ino, inode->i_nlink, *orphaned_slot);
 
 	spin_lock(&OCFS2_I(inode)->ip_lock);
diff --git a/fs/pipe.c b/fs/pipe.c
index 2035257..c53db14 100644
--- a/fs/pipe.c
+++ b/fs/pipe.c
@@ -924,7 +924,7 @@ int do_pipe(int *fd)
 	j = error;
 
 	error = -ENOMEM;
-	sprintf(name, "[%lu]", inode->i_ino);
+	sprintf(name, "[%llu]", inode->i_ino);
 	this.name = name;
 	this.len = strlen(name);
 	this.hash = inode->i_ino; /* will go */
diff --git a/fs/smbfs/inode.c b/fs/smbfs/inode.c
index a1ed657..3674651 100644
--- a/fs/smbfs/inode.c
+++ b/fs/smbfs/inode.c
@@ -334,7 +334,7 @@ smb_delete_inode(struct inode *ino)
 	truncate_inode_pages(&ino->i_data, 0);
 	lock_kernel();
 	if (smb_close(ino))
-		PARANOIA("could not close inode %ld\n", ino->i_ino);
+		PARANOIA("could not close inode %lld\n", ino->i_ino);
 	unlock_kernel();
 	clear_inode(ino);
 }
diff --git a/fs/sysv/inode.c b/fs/sysv/inode.c
index 58b2d22..e0cfa83 100644
--- a/fs/sysv/inode.c
+++ b/fs/sysv/inode.c
@@ -280,7 +280,7 @@ int sysv_sync_inode(struct inode * inode
         if (bh && buffer_dirty(bh)) {
                 sync_dirty_buffer(bh);
                 if (buffer_req(bh) && !buffer_uptodate(bh)) {
-                        printk ("IO error syncing sysv inode [%s:%08lx]\n",
+                        printk ("IO error syncing sysv inode [%s:%08llx]\n",
                                 inode->i_sb->s_id, inode->i_ino);
                         err = -1;
                 }
diff --git a/fs/udf/inode.c b/fs/udf/inode.c
index 605f511..9812416 100644
--- a/fs/udf/inode.c
+++ b/fs/udf/inode.c
@@ -922,7 +922,7 @@ __udf_read_inode(struct inode *inode)
 
 	if (!bh)
 	{
-		printk(KERN_ERR "udf: udf_read_inode(ino %ld) failed !bh\n",
+		printk(KERN_ERR "udf: udf_read_inode(ino %lld) failed !bh\n",
 			inode->i_ino);
 		make_bad_inode(inode);
 		return;
@@ -931,7 +931,7 @@ __udf_read_inode(struct inode *inode)
 	if (ident != TAG_IDENT_FE && ident != TAG_IDENT_EFE &&
 		ident != TAG_IDENT_USE)
 	{
-		printk(KERN_ERR "udf: udf_read_inode(ino %ld) failed ident=%d\n",
+		printk(KERN_ERR "udf: udf_read_inode(ino %lld) failed ident=%d\n",
 			inode->i_ino, ident);
 		udf_release_data(bh);
 		make_bad_inode(inode);
@@ -1212,7 +1212,7 @@ static void udf_fill_inode(struct inode 
 		}
 		default:
 		{
-			printk(KERN_ERR "udf: udf_fill_inode(ino %ld) failed unknown file type=%d\n",
+			printk(KERN_ERR "udf: udf_fill_inode(ino %lld) failed unknown file type=%d\n",
 				inode->i_ino, fe->icbTag.fileType);
 			make_bad_inode(inode);
 			return;
@@ -1517,7 +1517,7 @@ udf_update_inode(struct inode *inode, in
 		sync_dirty_buffer(bh);
 		if (buffer_req(bh) && !buffer_uptodate(bh))
 		{
-			printk("IO error syncing udf inode [%s:%08lx]\n",
+			printk("IO error syncing udf inode [%s:%08llx]\n",
 				inode->i_sb->s_id, inode->i_ino);
 			err = -EIO;
 		}
diff --git a/fs/ufs/balloc.c b/fs/ufs/balloc.c
index b823814..0bb98ba 100644
--- a/fs/ufs/balloc.c
+++ b/fs/ufs/balloc.c
@@ -238,7 +238,7 @@ static void ufs_change_blocknr(struct in
 	struct page *page;
 	struct buffer_head *head, *bh;
 
-	UFSD("ENTER, ino %lu, count %u, oldb %u, newb %u\n",
+	UFSD("ENTER, ino %llu, count %u, oldb %u, newb %u\n",
 	      inode->i_ino, count, oldb, newb);
 
 	BUG_ON(!PageLocked(locked_page));
@@ -283,7 +283,7 @@ unsigned ufs_new_fragments(struct inode 
 	struct ufs_super_block_first * usb1;
 	unsigned cgno, oldcount, newcount, tmp, request, result;
 	
-	UFSD("ENTER, ino %lu, fragment %u, goal %u, count %u\n", inode->i_ino, fragment, goal, count);
+	UFSD("ENTER, ino %llu, fragment %u, goal %u, count %u\n", inode->i_ino, fragment, goal, count);
 	
 	sb = inode->i_sb;
 	uspi = UFS_SB(sb)->s_uspi;
@@ -505,7 +505,7 @@ static unsigned ufs_alloc_fragments (str
 	struct ufs_cylinder_group * ucg;
 	unsigned oldcg, i, j, k, result, allocsize;
 	
-	UFSD("ENTER, ino %lu, cgno %u, goal %u, count %u\n", inode->i_ino, cgno, goal, count);
+	UFSD("ENTER, ino %llu, cgno %u, goal %u, count %u\n", inode->i_ino, cgno, goal, count);
 
 	sb = inode->i_sb;
 	uspi = UFS_SB(sb)->s_uspi;
diff --git a/fs/ufs/dir.c b/fs/ufs/dir.c
index e04327c..5d04d61 100644
--- a/fs/ufs/dir.c
+++ b/fs/ufs/dir.c
@@ -142,7 +142,7 @@ out:
 
 Ebadsize:
 	ufs_error(sb, "ufs_check_page",
-		  "size of directory #%lu is not a multiple of chunk size",
+		  "size of directory #%llu is not a multiple of chunk size",
 		  dir->i_ino
 	);
 	goto fail;
@@ -161,7 +161,7 @@ Espan:
 Einumber:
 	error = "inode out of bounds";
 bad_entry:
-	ufs_error (sb, "ufs_check_page", "bad entry in directory #%lu: %s - "
+	ufs_error (sb, "ufs_check_page", "bad entry in directory #%llu: %s - "
 		   "offset=%lu, rec_len=%d, name_len=%d",
 		   dir->i_ino, error, (page->index<<PAGE_CACHE_SHIFT)+offs,
 		   rec_len, ufs_get_de_namlen(sb, p));
@@ -169,7 +169,7 @@ bad_entry:
 Eend:
 	p = (struct ufs_dir_entry *)(kaddr + offs);
 	ufs_error (sb, "ext2_check_page",
-		   "entry in directory #%lu spans the page boundary"
+		   "entry in directory #%llu spans the page boundary"
 		   "offset=%lu",
 		   dir->i_ino, (page->index<<PAGE_CACHE_SHIFT)+offs);
 fail:
@@ -255,7 +255,7 @@ struct ufs_dir_entry *ufs_find_entry(str
 	struct ufs_inode_info *ui = UFS_I(dir);
 	struct ufs_dir_entry *de;
 
-	UFSD("ENTER, dir_ino %lu, name %s, namlen %u\n", dir->i_ino, name, namelen);
+	UFSD("ENTER, dir_ino %llu, name %s, namlen %u\n", dir->i_ino, name, namelen);
 
 	if (npages == 0 || namelen > UFS_MAXNAMLEN)
 		goto out;
@@ -448,7 +448,7 @@ ufs_readdir(struct file *filp, void *dir
 
 		if (IS_ERR(page)) {
 			ufs_error(sb, __FUNCTION__,
-				  "bad page in #%lu",
+				  "bad page in #%llu",
 				  inode->i_ino);
 			filp->f_pos += PAGE_CACHE_SIZE - offset;
 			return -EIO;
diff --git a/fs/ufs/ialloc.c b/fs/ufs/ialloc.c
index 9501dcd..00be8fa 100644
--- a/fs/ufs/ialloc.c
+++ b/fs/ufs/ialloc.c
@@ -60,7 +60,7 @@ void ufs_free_inode (struct inode * inod
 	int is_directory;
 	unsigned ino, cg, bit;
 	
-	UFSD("ENTER, ino %lu\n", inode->i_ino);
+	UFSD("ENTER, ino %llu\n", inode->i_ino);
 
 	sb = inode->i_sb;
 	uspi = UFS_SB(sb)->s_uspi;
@@ -280,7 +280,7 @@ cg_found:
 		return ERR_PTR(-EDQUOT);
 	}
 
-	UFSD("allocating inode %lu\n", inode->i_ino);
+	UFSD("allocating inode %llu\n", inode->i_ino);
 	UFSD("EXIT\n");
 	return inode;
 
diff --git a/fs/ufs/inode.c b/fs/ufs/inode.c
index e7c8615..8842c0b 100644
--- a/fs/ufs/inode.c
+++ b/fs/ufs/inode.c
@@ -210,7 +210,7 @@ ufs_inode_getfrag(struct inode *inode, u
 	unsigned tmp, goal;
 	__fs32 * p, * p2;
 
-	UFSD("ENTER, ino %lu, fragment %u, new_fragment %llu, required %u, "
+	UFSD("ENTER, ino %llu, fragment %u, new_fragment %llu, required %u, "
 	     "metadata %d\n", inode->i_ino, fragment,
 	     (unsigned long long)new_fragment, required, !phys);
 
@@ -354,7 +354,7 @@ ufs_inode_getblock(struct inode *inode, 
 	block = ufs_fragstoblks (fragment);
 	blockoff = ufs_fragnum (fragment);
 
-	UFSD("ENTER, ino %lu, fragment %u, new_fragment %llu, metadata %d\n",
+	UFSD("ENTER, ino %llu, fragment %u, new_fragment %llu, metadata %d\n",
 	     inode->i_ino, fragment, (unsigned long long)new_fragment, !phys);
 
 	result = NULL;
@@ -446,7 +446,7 @@ int ufs_getfrag_block(struct inode *inod
 
 	lock_kernel();
 
-	UFSD("ENTER, ino %lu, fragment %llu\n", inode->i_ino, (unsigned long long)fragment);
+	UFSD("ENTER, ino %llu, fragment %llu\n", inode->i_ino, (unsigned long long)fragment);
 	if (fragment < 0)
 		goto abort_negative;
 	if (fragment >
@@ -547,7 +547,7 @@ struct buffer_head * ufs_bread (struct i
 {
 	struct buffer_head * bh;
 
-	UFSD("ENTER, ino %lu, fragment %u\n", inode->i_ino, fragment);
+	UFSD("ENTER, ino %llu, fragment %u\n", inode->i_ino, fragment);
 	bh = ufs_getfrag (inode, fragment, create, err);
 	if (!bh || buffer_uptodate(bh)) 		
 		return bh;
@@ -620,7 +620,7 @@ static void ufs1_read_inode(struct inode
 	inode->i_mode = mode = fs16_to_cpu(sb, ufs_inode->ui_mode);
 	inode->i_nlink = fs16_to_cpu(sb, ufs_inode->ui_nlink);
 	if (inode->i_nlink == 0)
-		ufs_error (sb, "ufs_read_inode", "inode %lu has zero nlink\n", inode->i_ino);
+		ufs_error (sb, "ufs_read_inode", "inode %llu has zero nlink\n", inode->i_ino);
 	
 	/*
 	 * Linux now has 32-bit uid and gid, so we can support EFT.
@@ -658,14 +658,14 @@ static void ufs2_read_inode(struct inode
 	mode_t mode;
 	unsigned i;
 
-	UFSD("Reading ufs2 inode, ino %lu\n", inode->i_ino);
+	UFSD("Reading ufs2 inode, ino %llu\n", inode->i_ino);
 	/*
 	 * Copy data to the in-core inode.
 	 */
 	inode->i_mode = mode = fs16_to_cpu(sb, ufs2_inode->ui_mode);
 	inode->i_nlink = fs16_to_cpu(sb, ufs2_inode->ui_nlink);
 	if (inode->i_nlink == 0)
-		ufs_error (sb, "ufs_read_inode", "inode %lu has zero nlink\n", inode->i_ino);
+		ufs_error (sb, "ufs_read_inode", "inode %llu has zero nlink\n", inode->i_ino);
 
         /*
          * Linux now has 32-bit uid and gid, so we can support EFT.
@@ -705,21 +705,21 @@ void ufs_read_inode(struct inode * inode
 	struct ufs_sb_private_info * uspi;
 	struct buffer_head * bh;
 
-	UFSD("ENTER, ino %lu\n", inode->i_ino);
+	UFSD("ENTER, ino %llu\n", inode->i_ino);
 
 	sb = inode->i_sb;
 	uspi = UFS_SB(sb)->s_uspi;
 
 	if (inode->i_ino < UFS_ROOTINO ||
 	    inode->i_ino > (uspi->s_ncg * uspi->s_ipg)) {
-		ufs_warning(sb, "ufs_read_inode", "bad inode number (%lu)\n",
+		ufs_warning(sb, "ufs_read_inode", "bad inode number (%llu)\n",
 			    inode->i_ino);
 		goto bad_inode;
 	}
 
 	bh = sb_bread(sb, uspi->s_sbbase + ufs_inotofsba(inode->i_ino));
 	if (!bh) {
-		ufs_warning(sb, "ufs_read_inode", "unable to read inode %lu\n",
+		ufs_warning(sb, "ufs_read_inode", "unable to read inode %llu\n",
 			    inode->i_ino);
 		goto bad_inode;
 	}
@@ -762,7 +762,7 @@ static int ufs_update_inode(struct inode
 	unsigned i;
 	unsigned flags;
 
-	UFSD("ENTER, ino %lu\n", inode->i_ino);
+	UFSD("ENTER, ino %llu\n", inode->i_ino);
 
 	sb = inode->i_sb;
 	uspi = UFS_SB(sb)->s_uspi;
@@ -770,13 +770,13 @@ static int ufs_update_inode(struct inode
 
 	if (inode->i_ino < UFS_ROOTINO || 
 	    inode->i_ino > (uspi->s_ncg * uspi->s_ipg)) {
-		ufs_warning (sb, "ufs_read_inode", "bad inode number (%lu)\n", inode->i_ino);
+		ufs_warning (sb, "ufs_read_inode", "bad inode number (%llu)\n", inode->i_ino);
 		return -1;
 	}
 
 	bh = sb_bread(sb, ufs_inotofsba(inode->i_ino));
 	if (!bh) {
-		ufs_warning (sb, "ufs_read_inode", "unable to read inode %lu\n", inode->i_ino);
+		ufs_warning (sb, "ufs_read_inode", "unable to read inode %llu\n", inode->i_ino);
 		return -1;
 	}
 	ufs_inode = (struct ufs_inode *) (bh->b_data + ufs_inotofsbo(inode->i_ino) * sizeof(struct ufs_inode));
diff --git a/fs/ufs/util.c b/fs/ufs/util.c
index 22f820a..0af8107 100644
--- a/fs/ufs/util.c
+++ b/fs/ufs/util.c
@@ -259,7 +259,7 @@ struct page *ufs_get_locked_page(struct 
 
 		if (IS_ERR(page)) {
 			printk(KERN_ERR "ufs_change_blocknr: "
-			       "read_cache_page error: ino %lu, index: %lu\n",
+			       "read_cache_page error: ino %llu, index: %lu\n",
 			       mapping->host->i_ino, index);
 			goto out;
 		}
@@ -279,7 +279,7 @@ struct page *ufs_get_locked_page(struct 
 			page_cache_release(page);
 
 			printk(KERN_ERR "ufs_change_blocknr: "
-			       "can not read page: ino %lu, index: %lu\n",
+			       "can not read page: ino %llu, index: %lu\n",
 			       mapping->host->i_ino, index);
 
 			page = ERR_PTR(-EIO);
diff --git a/net/ax25/af_ax25.c b/net/ax25/af_ax25.c
index 000695c..4fd147e 100644
--- a/net/ax25/af_ax25.c
+++ b/net/ax25/af_ax25.c
@@ -1915,10 +1915,10 @@ static int ax25_info_show(struct seq_fil
 
 	if (ax25->sk != NULL) {
 		bh_lock_sock(ax25->sk);
-		seq_printf(seq," %d %d %ld\n",
+		seq_printf(seq," %d %d %lld\n",
 			   atomic_read(&ax25->sk->sk_wmem_alloc),
 			   atomic_read(&ax25->sk->sk_rmem_alloc),
-			   ax25->sk->sk_socket != NULL ? SOCK_INODE(ax25->sk->sk_socket)->i_ino : 0L);
+			   ax25->sk->sk_socket != NULL ? SOCK_INODE(ax25->sk->sk_socket)->i_ino : 0LL);
 		bh_unlock_sock(ax25->sk);
 	} else {
 		seq_puts(seq, " * * *\n");
diff --git a/net/netrom/af_netrom.c b/net/netrom/af_netrom.c
index 1d50f80..50528c8 100644
--- a/net/netrom/af_netrom.c
+++ b/net/netrom/af_netrom.c
@@ -1292,7 +1292,7 @@ static int nr_info_show(struct seq_file 
 		seq_printf(seq, "%-9s ", ax2asc(buf, &nr->user_addr));
 		seq_printf(seq, "%-9s ", ax2asc(buf, &nr->dest_addr));
 		seq_printf(seq, 
-"%-9s %-3s  %02X/%02X %02X/%02X %2d %3d %3d %3d %3lu/%03lu %2lu/%02lu %3lu/%03lu %3lu/%03lu %2d/%02d %3d %5d %5d %ld\n",
+"%-9s %-3s  %02X/%02X %02X/%02X %2d %3d %3d %3d %3lu/%03lu %2lu/%02lu %3lu/%03lu %3lu/%03lu %2d/%02d %3d %5d %5d %lld\n",
 			ax2asc(buf, &nr->source_addr),
 			devname,
 			nr->my_index,
@@ -1316,7 +1316,7 @@ static int nr_info_show(struct seq_file 
 			nr->window,
 			atomic_read(&s->sk_wmem_alloc),
 			atomic_read(&s->sk_rmem_alloc),
-			s->sk_socket ? SOCK_INODE(s->sk_socket)->i_ino : 0L);
+			s->sk_socket ? SOCK_INODE(s->sk_socket)->i_ino : 0LL);
 
 		bh_unlock_sock(s);
 	}
diff --git a/net/rose/af_rose.c b/net/rose/af_rose.c
index 08a5428..81387c3 100644
--- a/net/rose/af_rose.c
+++ b/net/rose/af_rose.c
@@ -1402,7 +1402,7 @@ static int rose_info_show(struct seq_fil
 			callsign = ax2asc(buf, &rose->source_call);
 
 		seq_printf(seq,
-			   "%-10s %-9s %-5s %3.3X %05d  %d  %d  %d  %d %3lu %3lu %3lu %3lu %3lu %3lu/%03lu %5d %5d %ld\n",
+			   "%-10s %-9s %-5s %3.3X %05d  %d  %d  %d  %d %3lu %3lu %3lu %3lu %3lu %3lu/%03lu %5d %5d %lld\n",
 			rose2asc(&rose->source_addr),
 			callsign,
 			devname,
@@ -1421,7 +1421,7 @@ static int rose_info_show(struct seq_fil
 			rose->idle / (60 * HZ),
 			atomic_read(&s->sk_wmem_alloc),
 			atomic_read(&s->sk_rmem_alloc),
-			s->sk_socket ? SOCK_INODE(s->sk_socket)->i_ino : 0L);
+			s->sk_socket ? SOCK_INODE(s->sk_socket)->i_ino : 0LL);
 	}
 
 	return 0;
diff --git a/net/socket.c b/net/socket.c
index b4848ce..750f0b2 100644
--- a/net/socket.c
+++ b/net/socket.c
@@ -396,7 +396,7 @@ static int sock_attach_fd(struct socket 
 	struct qstr this;
 	char name[32];
 
-	this.len = sprintf(name, "[%lu]", SOCK_INODE(sock)->i_ino);
+	this.len = sprintf(name, "[%llu]", SOCK_INODE(sock)->i_ino);
 	this.name = name;
 	this.hash = SOCK_INODE(sock)->i_ino;
 
diff --git a/net/x25/x25_proc.c b/net/x25/x25_proc.c
index a11837d..56cca24 100644
--- a/net/x25/x25_proc.c
+++ b/net/x25/x25_proc.c
@@ -152,7 +152,7 @@ static int x25_seq_socket_show(struct se
 		devname = x25->neighbour->dev->name;
 
 	seq_printf(seq, "%-10s %-10s %-5s %3.3X  %d  %d  %d  %d %3lu %3lu "
-			"%3lu %3lu %3lu %5d %5d %ld\n",
+			"%3lu %3lu %3lu %5d %5d %lld\n",
 		   !x25->dest_addr.x25_addr[0] ? "*" : x25->dest_addr.x25_addr,
 		   !x25->source_addr.x25_addr[0] ? "*" : x25->source_addr.x25_addr,
 		   devname, x25->lci & 0x0FFF, x25->state, x25->vs, x25->vr,
@@ -160,7 +160,7 @@ static int x25_seq_socket_show(struct se
 		   x25->t21 / HZ, x25->t22 / HZ, x25->t23 / HZ,
 		   atomic_read(&s->sk_wmem_alloc),
 		   atomic_read(&s->sk_rmem_alloc),
-		   s->sk_socket ? SOCK_INODE(s->sk_socket)->i_ino : 0L);
+		   s->sk_socket ? SOCK_INODE(s->sk_socket)->i_ino : 0LL);
 out:
 	return 0;
 } 
diff --git a/security/selinux/avc.c b/security/selinux/avc.c
index a300702..b19264b 100644
--- a/security/selinux/avc.c
+++ b/security/selinux/avc.c
@@ -586,7 +586,7 @@ void avc_audit(u32 ssid, u32 tsid,
 				}
 			}
 			if (inode)
-				audit_log_format(ab, " dev=%s ino=%ld",
+				audit_log_format(ab, " dev=%s ino=%lld",
 						 inode->i_sb->s_id,
 						 inode->i_ino);
 			break;
diff --git a/security/selinux/hooks.c b/security/selinux/hooks.c
index 5d1b8c7..3d9a5c7 100644
--- a/security/selinux/hooks.c
+++ b/security/selinux/hooks.c
@@ -883,7 +883,7 @@ #define INITCONTEXTLEN 255
 		}
 		if (!dentry) {
 			printk(KERN_WARNING "%s:  no dentry for dev=%s "
-			       "ino=%ld\n", __FUNCTION__, inode->i_sb->s_id,
+			       "ino=%lld\n", __FUNCTION__, inode->i_sb->s_id,
 			       inode->i_ino);
 			goto out;
 		}
@@ -921,7 +921,7 @@ #define INITCONTEXTLEN 255
 		if (rc < 0) {
 			if (rc != -ENODATA) {
 				printk(KERN_WARNING "%s:  getxattr returned "
-				       "%d for dev=%s ino=%ld\n", __FUNCTION__,
+				       "%d for dev=%s ino=%lld\n", __FUNCTION__,
 				       -rc, inode->i_sb->s_id, inode->i_ino);
 				kfree(context);
 				goto out;
@@ -934,7 +934,7 @@ #define INITCONTEXTLEN 255
 			                                     sbsec->def_sid);
 			if (rc) {
 				printk(KERN_WARNING "%s:  context_to_sid(%s) "
-				       "returned %d for dev=%s ino=%ld\n",
+				       "returned %d for dev=%s ino=%lld\n",
 				       __FUNCTION__, context, -rc,
 				       inode->i_sb->s_id, inode->i_ino);
 				kfree(context);
@@ -2084,7 +2084,7 @@ static int selinux_inode_init_security(s
 		if (rc) {
 			printk(KERN_WARNING "%s:  "
 			       "security_transition_sid failed, rc=%d (dev=%s "
-			       "ino=%ld)\n",
+			       "ino=%lld)\n",
 			       __FUNCTION__,
 			       -rc, inode->i_sb->s_id, inode->i_ino);
 			return rc;

[RHEL5 PATCH 4/4] VFS: Fix 64-bit ino_t warning in CacheFiles facility

[David Howells]

Fix the print format warnings that occur in CacheFiles when ino_t is made
unsigned long long.

Signed-Off-By: David Howells <dhowells@redhat.com>
---

 fs/cachefiles/cf-interface.c |    2 +-
 fs/cachefiles/cf-namei.c     |   14 +++++++-------
 fs/cachefiles/cf-xattr.c     |   16 ++++++++--------
 3 files changed, 16 insertions(+), 16 deletions(-)

diff --git a/fs/cachefiles/cf-interface.c b/fs/cachefiles/cf-interface.c
index b5ca30f..37d8973 100644
--- a/fs/cachefiles/cf-interface.c
+++ b/fs/cachefiles/cf-interface.c
@@ -428,7 +428,7 @@ void cachefiles_read_copier_work(void *_
 	struct pagevec pagevec;
 	int error, max;
 
-	_enter("{ino=%lu}", object->backer->d_inode->i_ino);
+	_enter("{ino=%llu}", object->backer->d_inode->i_ino);
 
 	pagevec_init(&pagevec, 0);
 
diff --git a/fs/cachefiles/cf-namei.c b/fs/cachefiles/cf-namei.c
index 20db88a..76bf637 100644
--- a/fs/cachefiles/cf-namei.c
+++ b/fs/cachefiles/cf-namei.c
@@ -382,11 +382,11 @@ lookup_again:
 
 			fsnotify_mkdir(dir->d_inode, next);
 
-			_debug("mkdir -> %p{%p{ino=%lu}}",
+			_debug("mkdir -> %p{%p{ino=%llu}}",
 			       next, next->d_inode, next->d_inode->i_ino);
 
 		} else if (!S_ISDIR(next->d_inode->i_mode)) {
-			kerror("inode %lu is not a directory",
+			kerror("inode %llu is not a directory",
 			       next->d_inode->i_ino);
 			ret = -ENOBUFS;
 			goto error;
@@ -405,13 +405,13 @@ lookup_again:
 
 			fsnotify_create(dir->d_inode, next);
 
-			_debug("create -> %p{%p{ino=%lu}}",
+			_debug("create -> %p{%p{ino=%llu}}",
 			       next, next->d_inode, next->d_inode->i_ino);
 
 		} else if (!S_ISDIR(next->d_inode->i_mode) &&
 			   !S_ISREG(next->d_inode->i_mode)
 			   ) {
-			kerror("inode %lu is not a file or directory",
+			kerror("inode %llu is not a file or directory",
 			       next->d_inode->i_ino);
 			ret = -ENOBUFS;
 			goto error;
@@ -497,7 +497,7 @@ lookup_again:
 	current->fsgid = fsgid;
 	object->new = 0;
 
-	_leave(" = 0 [%lu]", object->dentry->d_inode->i_ino);
+	_leave(" = 0 [%llu]", object->dentry->d_inode->i_ino);
 	return 0;
 
 create_error:
@@ -615,7 +615,7 @@ struct dentry *cachefiles_get_directory(
 
 		fsnotify_mkdir(dir->d_inode, subdir);
 
-		_debug("mkdir -> %p{%p{ino=%lu}}",
+		_debug("mkdir -> %p{%p{ino=%llu}}",
 		       subdir,
 		       subdir->d_inode,
 		       subdir->d_inode->i_ino);
@@ -647,7 +647,7 @@ struct dentry *cachefiles_get_directory(
 	    !subdir->d_inode->i_op->unlink)
 		goto check_error;
 
-	_leave(" = [%lu]", subdir->d_inode->i_ino);
+	_leave(" = [%llu]", subdir->d_inode->i_ino);
 	return subdir;
 
 check_error:
diff --git a/fs/cachefiles/cf-xattr.c b/fs/cachefiles/cf-xattr.c
index 8952bf0..1baf4c8 100644
--- a/fs/cachefiles/cf-xattr.c
+++ b/fs/cachefiles/cf-xattr.c
@@ -57,7 +57,7 @@ int cachefiles_check_object_type(struct 
 	}
 
 	if (ret != -EEXIST) {
-		kerror("Can't set xattr on %*.*s [%lu] (err %d)",
+		kerror("Can't set xattr on %*.*s [%llu] (err %d)",
 		       dentry->d_name.len, dentry->d_name.len,
 		       dentry->d_name.name, dentry->d_inode->i_ino,
 		       -ret);
@@ -71,7 +71,7 @@ int cachefiles_check_object_type(struct 
 		if (ret == -ERANGE)
 			goto bad_type_length;
 
-		kerror("Can't read xattr on %*.*s [%lu] (err %d)",
+		kerror("Can't read xattr on %*.*s [%llu] (err %d)",
 		       dentry->d_name.len, dentry->d_name.len,
 		       dentry->d_name.name, dentry->d_inode->i_ino,
 		       -ret);
@@ -93,14 +93,14 @@ error:
 	return ret;
 
 bad_type_length:
-	kerror("Cache object %lu type xattr length incorrect",
+	kerror("Cache object %llu type xattr length incorrect",
 	       dentry->d_inode->i_ino);
 	ret = -EIO;
 	goto error;
 
 bad_type:
 	xtype[2] = 0;
-	kerror("Cache object %*.*s [%lu] type %s not %s",
+	kerror("Cache object %*.*s [%llu] type %s not %s",
 	       dentry->d_name.len, dentry->d_name.len,
 	       dentry->d_name.name, dentry->d_inode->i_ino,
 	       xtype, type);
@@ -184,7 +184,7 @@ int cachefiles_check_object_xattr(struct
 			goto bad_type_length;
 
 		cachefiles_io_error_obj(object,
-					"can't read xattr on %lu (err %d)",
+					"can't read xattr on %llu (err %d)",
 					dentry->d_inode->i_ino, -ret);
 		goto error;
 	}
@@ -237,7 +237,7 @@ int cachefiles_check_object_xattr(struct
 						      XATTR_REPLACE);
 		if (ret < 0) {
 			cachefiles_io_error_obj(object,
-						"Can't update xattr on %lu"
+						"Can't update xattr on %llu"
 						" (error %d)",
 						dentry->d_inode->i_ino, -ret);
 			goto error;
@@ -254,7 +254,7 @@ error:
 	return ret;
 
 bad_type_length:
-	kerror("Cache object %lu xattr length incorrect",
+	kerror("Cache object %llu xattr length incorrect",
 	       dentry->d_inode->i_ino);
 	ret = -EIO;
 	goto error;
@@ -285,7 +285,7 @@ int cachefiles_remove_object_xattr(struc
 			ret = 0;
 		else if (ret != -ENOMEM)
 			cachefiles_io_error(cache,
-					    "Can't remove xattr from %lu"
+					    "Can't remove xattr from %llu"
 					    " (error %d)",
 					    dentry->d_inode->i_ino, -ret);
 	}

Re: [PATCH 0/4] Use 64-bit inode numbers internally in the kernel

[Josh Boyer]

On 8/14/06, David Howells <dhowells@redhat.com> wrote:
>
> These patches make the kernel use 64-bit inode numbers internally, even on a
> 32-bit system.  They are required because some filesystems have intrinsic
> 64-bit inode numbers: NFS and XFS for example.  The 64-bit inode numbers are
> then propagated to userspace automatically where the arch supports it.

Out of curiosity, is there a performance hit for 32-bit systems?  Have
you done any minimal benchmarks to see?

josh

Re: [PATCH 0/4] Use 64-bit inode numbers internally in the kernel

[David Howells]

Josh Boyer <jwboyer@gmail.com> wrote:

> Out of curiosity, is there a performance hit for 32-bit systems?  Have
> you done any minimal benchmarks to see?

Yes, I'm sure there is, but we're talking performance vs correctness.

David

Re: [PATCH 0/4] Use 64-bit inode numbers internally in the kernel

[Al Viro]

On Tue, Aug 15, 2006 at 09:21:53AM +0100, David Howells wrote:
> Josh Boyer <jwboyer@gmail.com> wrote:
> 
> > Out of curiosity, is there a performance hit for 32-bit systems?  Have
> > you done any minimal benchmarks to see?
> 
> Yes, I'm sure there is, but we're talking performance vs correctness.

ITYM performance vs. slightly different patch.  Let me put all pieces
in one place:
	* kstat gets u64 ino
	* filesystems that want to report 64bit st_ino do it in their
->getattr(); the rest is unchanged.
	* ino_t is left as-is
	* filldir() callbacks get u64 ino in arguments.  Filesystem may
pass 64bit value if it cares to; otherwise it's left unchanged.
	* filesystem that wants unusual search key can use iget5() (as
it can do right now)
	* filesystem that wants to use the values it'd put into st_ino in
its printks should use appropriate format
	* any printk in generic code that happens to use i_ino should
be hunted down and shot for utter uselessness for too many filesystems
(not sure if we actually _have_ any such printk these days).