]> git.pld-linux.org Git - packages/kernel.git/blame - 40_lfs-2.2.20pre10aa1-28
projects / packages / kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
- fixed for PLD
[packages/kernel.git] / 40_lfs-2.2.20pre10aa1-28
CommitLineData
82f1c7ea
KT		 1diff -urN lfs-ref/arch/alpha/kernel/entry.S lfs/arch/alpha/kernel/entry.S
2--- lfs-ref/arch/alpha/kernel/entry.S Wed Sep 12 02:39:56 2001
3+++ lfs/arch/alpha/kernel/entry.S Wed Sep 12 02:42:14 2001
4@@ -8,7 +8,7 @@
5
6 #define SIGCHLD 20
7
8-#define NR_SYSCALLS 377
9+#define NR_SYSCALLS 378
10
11 /*
12 * These offsets must match with alpha_mv in <asm/machvec.h>.
13@@ -1162,3 +1162,4 @@
14 .quad sys_ni_syscall
15 .quad sys_ni_syscall /* 375 */
16 .quad sys_pciconfig_iobase
17+ .quad sys_getdents64
18diff -urN lfs-ref/arch/alpha/kernel/osf_sys.c lfs/arch/alpha/kernel/osf_sys.c
19--- lfs-ref/arch/alpha/kernel/osf_sys.c Fri Apr 20 22:31:15 2001
20+++ lfs/arch/alpha/kernel/osf_sys.c Wed Sep 12 02:42:14 2001
21@@ -110,7 +110,7 @@
22 int error;
23 };
24
25-static int osf_filldir(void *__buf, const char *name, int namlen, off_t offset, ino_t ino)
26+static int osf_filldir(void *__buf, const char *name, int namlen, off_t offset, ino_t ino, unsigned int d_type)
27 {
28 struct osf_dirent *dirent;
29 struct osf_dirent_callback *buf = (struct osf_dirent_callback *) __buf;
30diff -urN lfs-ref/arch/i386/kernel/entry.S lfs/arch/i386/kernel/entry.S
31--- lfs-ref/arch/i386/kernel/entry.S Wed Sep 12 02:39:56 2001
32+++ lfs/arch/i386/kernel/entry.S Wed Sep 12 02:42:14 2001
33@@ -572,6 +572,18 @@
34 .long SYMBOL_NAME(sys_ni_syscall) /* streams1 */
35 .long SYMBOL_NAME(sys_ni_syscall) /* streams2 */
36 .long SYMBOL_NAME(sys_vfork) /* 190 */
37+ .long SYMBOL_NAME(sys_ni_syscall) /* getrlimit */
38+ .long SYMBOL_NAME(sys_mmap2) /* 192 */
39+ .long SYMBOL_NAME(sys_truncate64) /* 193 */
40+ .long SYMBOL_NAME(sys_ftruncate64) /* 194 */
41+ .long SYMBOL_NAME(sys_stat64) /* 195 */
42+ .long SYMBOL_NAME(sys_lstat64) /* 196 */
43+ .long SYMBOL_NAME(sys_fstat64) /* 197 */
44+ .rept 22
45+ .long SYMBOL_NAME(sys_ni_syscall)
46+ .endr
47+ .long SYMBOL_NAME(sys_getdents64) /* 220 */
48+ .long SYMBOL_NAME(sys_fcntl64) /* 221 */
49
50 /*
51 * NOTE!! This doesn't have to be exact - we just have
52@@ -579,6 +591,6 @@
53 * entries. Don't panic if you notice that this hasn't
54 * been shrunk every time we add a new system call.
55 */
56- .rept NR_syscalls-190
57+ .rept NR_syscalls-221
58 .long SYMBOL_NAME(sys_ni_syscall)
59 .endr
60diff -urN lfs-ref/arch/i386/kernel/sys_i386.c lfs/arch/i386/kernel/sys_i386.c
61--- lfs-ref/arch/i386/kernel/sys_i386.c Mon Jan 17 16:44:33 2000
62+++ lfs/arch/i386/kernel/sys_i386.c Wed Sep 12 02:42:14 2001
63@@ -41,6 +41,42 @@
64 return error;
65 }
66
67+/* common code for old and new mmaps */
68+static inline long do_mmap2(
69+ unsigned long addr, unsigned long len,
70+ unsigned long prot, unsigned long flags,
71+ unsigned long fd, unsigned long pgoff)
72+{
73+ int error = -EBADF;
74+ struct file * file = NULL;
75+
76+ down(&current->mm->mmap_sem);
77+ lock_kernel();
78+
79+ flags &= ~(MAP_EXECUTABLE | MAP_DENYWRITE);
80+ if (!(flags & MAP_ANONYMOUS)) {
81+ file = fget(fd);
82+ if (!file)
83+ goto out;
84+ }
85+
86+ error = do_mmap_pgoff(file, addr, len, prot, flags, pgoff);
87+
88+ if (file)
89+ fput(file);
90+out:
91+ unlock_kernel();
92+ up(&current->mm->mmap_sem);
93+ return error;
94+}
95+
96+asmlinkage long sys_mmap2(unsigned long addr, unsigned long len,
97+ unsigned long prot, unsigned long flags,
98+ unsigned long fd, unsigned long pgoff)
99+{
100+ return do_mmap2(addr, len, prot, flags, fd, pgoff);
101+}
102+
103 /*
104 * Perform the select(nd, in, out, ex, tv) and mmap() system
105 * calls. Linux/i386 didn't use to be able to handle more than
106@@ -59,30 +95,19 @@
107
108 asmlinkage int old_mmap(struct mmap_arg_struct *arg)
109 {
110- int error = -EFAULT;
111- struct file * file = NULL;
112 struct mmap_arg_struct a;
113+ int err = -EFAULT;
114
115 if (copy_from_user(&a, arg, sizeof(a)))
116- return -EFAULT;
117+ goto out;
118
119- down(&current->mm->mmap_sem);
120- lock_kernel();
121- if (!(a.flags & MAP_ANONYMOUS)) {
122- error = -EBADF;
123- file = fget(a.fd);
124- if (!file)
125- goto out;
126- }
127- a.flags &= ~(MAP_EXECUTABLE | MAP_DENYWRITE);
128+ err = -EINVAL;
129+ if (a.offset & ~PAGE_MASK)
130+ goto out;
131
132- error = do_mmap(file, a.addr, a.len, a.prot, a.flags, a.offset);
133- if (file)
134- fput(file);
135+ err = do_mmap2(a.addr, a.len, a.prot, a.flags, a.fd, a.offset >> PAGE_SHIFT);
136 out:
137- unlock_kernel();
138- up(&current->mm->mmap_sem);
139- return error;
140+ return err;
141 }
142
143 extern asmlinkage int sys_select(int, fd_set *, fd_set *, fd_set *, struct timeval *);
144diff -urN lfs-ref/arch/mips/kernel/sysirix.c lfs/arch/mips/kernel/sysirix.c
145--- lfs-ref/arch/mips/kernel/sysirix.c Mon Jan 17 16:44:34 2000
146+++ lfs/arch/mips/kernel/sysirix.c Wed Sep 12 02:42:14 2001
147@@ -1984,7 +1984,7 @@
148 #define ROUND_UP32(x) (((x)+sizeof(u32)-1) & ~(sizeof(u32)-1))
149
150 static int irix_filldir32(void *__buf, const char *name, int namlen,
151- off_t offset, ino_t ino)
152+ off_t offset, ino_t ino, unsigned int d_type)
153 {
154 struct irix_dirent32 *dirent;
155 struct irix_dirent32_callback *buf =
156@@ -2097,7 +2097,7 @@
157 #define ROUND_UP64(x) (((x)+sizeof(u64)-1) & ~(sizeof(u64)-1))
158
159 static int irix_filldir64(void * __buf, const char * name, int namlen,
160- off_t offset, ino_t ino)
161+ off_t offset, ino_t ino, unsigned int d_type)
162 {
163 struct irix_dirent64 *dirent;
164 struct irix_dirent64_callback * buf =
165diff -urN lfs-ref/arch/ppc/kernel/misc.S lfs/arch/ppc/kernel/misc.S
166--- lfs-ref/arch/ppc/kernel/misc.S Fri Apr 20 22:31:15 2001
167+++ lfs/arch/ppc/kernel/misc.S Wed Sep 12 02:42:14 2001
168@@ -958,7 +958,7 @@
169 .long sys_swapon
170 .long sys_reboot
171 .long old_readdir
172- .long sys_mmap /* 90 */
173+ .long old_mmap /* 90 */
174 .long sys_munmap
175 .long sys_truncate
176 .long sys_ftruncate
177@@ -1058,18 +1058,20 @@
178 .long sys_ni_syscall /* streams1 */
179 .long sys_ni_syscall /* streams2 */
180 .long sys_vfork
181- .long sys_ni_syscall /* 190 */ /* MacOnLinux - old */
182+ .long sys_ni_syscall /* 190 getrlimit */
183 .long sys_ni_syscall /* 191 */ /* Unused */
184- .long sys_ni_syscall /* 192 - reserved - mmap2 */
185- .long sys_ni_syscall /* 193 - reserved - truncate64 */
186- .long sys_ni_syscall /* 194 - reserved - ftruncate64 */
187- .long sys_ni_syscall /* 195 - reserved - stat64 */
188- .long sys_ni_syscall /* 196 - reserved - lstat64 */
189- .long sys_ni_syscall /* 197 - reserved - fstat64 */
190+ .long sys_mmap2 /* 192 */
191+ .long sys_truncate64 /* 193 */
192+ .long sys_ftruncate64 /* 194 */
193+ .long sys_stat64 /* 195 */
194+ .long sys_lstat64 /* 196 */
195+ .long sys_fstat64 /* 197 */
196 .long sys_pciconfig_read /* 198 */
197 .long sys_pciconfig_write /* 199 */
198 .long sys_pciconfig_iobase /* 200 */
199 .long sys_ni_syscall /* 201 - reserved - MacOnLinux - new */
200- .rept NR_syscalls-201
201+ .long sys_getdents64 /* 202 */
202+ .long sys_fcntl64 /* 203 */
203+ .rept NR_syscalls-203
204 .long sys_ni_syscall
205 .endr
206diff -urN lfs-ref/arch/ppc/kernel/syscalls.c lfs/arch/ppc/kernel/syscalls.c
207--- lfs-ref/arch/ppc/kernel/syscalls.c Mon Dec 11 16:57:46 2000
208+++ lfs/arch/ppc/kernel/syscalls.c Wed Sep 12 02:42:14 2001
209@@ -33,6 +33,7 @@
210 #include <linux/sys.h>
211 #include <linux/ipc.h>
212 #include <linux/utsname.h>
213+#include <linux/file.h>
214
215 #include <asm/uaccess.h>
216 #include <asm/ipc.h>
217@@ -192,25 +193,55 @@
218 return error;
219 }
220
221-asmlinkage unsigned long sys_mmap(unsigned long addr, size_t len,
222- unsigned long prot, unsigned long flags,
223- unsigned long fd, off_t offset)
224+/* common code for old and new mmaps */
225+static inline long do_mmap2(
226+ unsigned long addr, unsigned long len,
227+ unsigned long prot, unsigned long flags,
228+ unsigned long fd, unsigned long pgoff)
229 {
230 struct file * file = NULL;
231 int ret = -EBADF;
232
233 down(&current->mm->mmap_sem);
234- lock_kernel();
235+
236 if (!(flags & MAP_ANONYMOUS)) {
237- if (fd >= NR_OPEN || !(file = current->files->fd[fd]))
238+ file = fget(fd);
239+ if (!file)
240 goto out;
241 }
242-
243+
244 flags &= ~(MAP_EXECUTABLE | MAP_DENYWRITE);
245- ret = do_mmap(file, addr, len, prot, flags, offset);
246-out:
247+ ret = do_mmap_pgoff(file, addr, len, prot, flags, pgoff);
248+
249+ if (file)
250+ fput(file);
251+ out:
252 unlock_kernel();
253 up(&current->mm->mmap_sem);
254+ return ret;
255+
256+}
257+
258+asmlinkage long sys_mmap2(unsigned long addr, unsigned long len,
259+ unsigned long prot, unsigned long flags,
260+ unsigned long fd, unsigned long pgoff)
261+{
262+ return do_mmap2(addr, len, prot, flags, fd, pgoff);
263+}
264+
265+asmlinkage unsigned long old_mmap(unsigned long addr, size_t len,
266+ unsigned long prot, unsigned long flags,
267+ unsigned long fd, off_t offset)
268+{
269+ int ret;
270+
271+ ret = -EINVAL;
272+ if (offset & ~PAGE_MASK)
273+ goto out;
274+
275+ ret = do_mmap2(addr, len, prot, flags, fd, offset >> PAGE_SHIFT);
276+
277+ out:
278 return ret;
279 }
280
281diff -urN lfs-ref/arch/sparc/kernel/sys_sparc.c lfs/arch/sparc/kernel/sys_sparc.c
282--- lfs-ref/arch/sparc/kernel/sys_sparc.c Thu May 4 13:00:36 2000
283+++ lfs/arch/sparc/kernel/sys_sparc.c Wed Sep 12 02:42:14 2001
284@@ -176,9 +176,9 @@
285 }
286
287 /* Linux version of mmap */
288-asmlinkage unsigned long sys_mmap(unsigned long addr, unsigned long len,
289+asmlinkage unsigned long do_mmap2(unsigned long addr, unsigned long len,
290 unsigned long prot, unsigned long flags, unsigned long fd,
291- unsigned long off)
292+ unsigned long pgoff)
293 {
294 struct file * file = NULL;
295 unsigned long retval = -EBADF;
296@@ -211,7 +211,7 @@
297 goto out_putf;
298
299 flags &= ~(MAP_EXECUTABLE | MAP_DENYWRITE);
300- retval = do_mmap(file, addr, len, prot, flags, off);
301+ retval = do_mmap_pgoff(file, addr, len, prot, flags, pgoff);
302
303 out_putf:
304 if (file)
305@@ -220,6 +220,22 @@
306 unlock_kernel();
307 up(&current->mm->mmap_sem);
308 return retval;
309+}
310+
311+asmlinkage unsigned long sys_mmap2(unsigned long addr, unsigned long len,
312+ unsigned long prot, unsigned long flags, unsigned long fd,
313+ unsigned long pgoff)
314+{
315+ /* Make sure the shift for mmap2 is constant (12), no matter what PAGE_SIZE
316+ we have. */
317+ return do_mmap2(addr, len, prot, flags, fd, pgoff >> (PAGE_SHIFT - 12));
318+}
319+
320+asmlinkage unsigned long sys_mmap(unsigned long addr, unsigned long len,
321+ unsigned long prot, unsigned long flags, unsigned long fd,
322+ unsigned long off)
323+{
324+ return do_mmap2(addr, len, prot, flags, fd, off >> PAGE_SHIFT);
325 }
326
327 /* we come to here via sys_nis_syscall so it can setup the regs argument */
328diff -urN lfs-ref/arch/sparc/kernel/sys_sunos.c lfs/arch/sparc/kernel/sys_sunos.c
329--- lfs-ref/arch/sparc/kernel/sys_sunos.c Wed Sep 12 02:39:57 2001
330+++ lfs/arch/sparc/kernel/sys_sunos.c Wed Sep 12 02:42:14 2001
331@@ -409,7 +409,7 @@
332 #define ROUND_UP(x) (((x)+sizeof(long)-1) & ~(sizeof(long)-1))
333
334 static int sunos_filldir(void * __buf, const char * name, int namlen,
335- off_t offset, ino_t ino)
336+ off_t offset, ino_t ino, unsigned int d_type)
337 {
338 struct sunos_dirent * dirent;
339 struct sunos_dirent_callback * buf = (struct sunos_dirent_callback *) __buf;
340@@ -500,7 +500,7 @@
341 };
342
343 static int sunos_filldirentry(void * __buf, const char * name, int namlen,
344- off_t offset, ino_t ino)
345+ off_t offset, ino_t ino, unsigned int d_type)
346 {
347 struct sunos_direntry * dirent;
348 struct sunos_direntry_callback * buf = (struct sunos_direntry_callback *) __buf;
349diff -urN lfs-ref/arch/sparc/kernel/systbls.S lfs/arch/sparc/kernel/systbls.S
350--- lfs-ref/arch/sparc/kernel/systbls.S Fri Apr 20 22:31:15 2001
351+++ lfs/arch/sparc/kernel/systbls.S Wed Sep 12 02:42:14 2001
352@@ -29,12 +29,12 @@
353 /*40*/ .long sys_newlstat, sys_dup, sys_pipe, sys_times, sys_lfs_syscall
354 /*45*/ .long sys_umount, sys_setgid, sys_getgid, sys_signal, sys_geteuid
355 /*50*/ .long sys_getegid, sys_acct, sys_nis_syscall, sys_nis_syscall, sys_ioctl
356-/*55*/ .long sys_reboot, sys_lfs_syscall, sys_symlink, sys_readlink, sys_execve
357-/*60*/ .long sys_umask, sys_chroot, sys_newfstat, sys_lfs_syscall, sys_getpagesize
358+/*55*/ .long sys_reboot, sys_mmap2, sys_symlink, sys_readlink, sys_execve
359+/*60*/ .long sys_umask, sys_chroot, sys_newfstat, sys_fstat64, sys_getpagesize
360 /*65*/ .long sys_msync, sys_vfork, sys_pread, sys_pwrite, sys_nis_syscall
361 /*70*/ .long sys_nis_syscall, sys_mmap, sys_nis_syscall, sys_munmap, sys_mprotect
362-/*75*/ .long sys_nis_syscall, sys_vhangup, sys_lfs_syscall, sys_nis_syscall, sys_getgroups
363-/*80*/ .long sys_setgroups, sys_getpgrp, sys_nis_syscall, sys_setitimer, sys_lfs_syscall
364+/*75*/ .long sys_nis_syscall, sys_vhangup, sys_truncate64, sys_nis_syscall, sys_getgroups
365+/*80*/ .long sys_setgroups, sys_getpgrp, sys_nis_syscall, sys_setitimer, sys_ftruncate64
366 /*85*/ .long sys_swapon, sys_getitimer, sys_nis_syscall, sys_sethostname, sys_nis_syscall
367 /*90*/ .long sys_dup2, sys_nis_syscall, sys_fcntl, sys_select, sys_nis_syscall
368 /*95*/ .long sys_fsync, sys_setpriority, sys_nis_syscall, sys_nis_syscall, sys_nis_syscall
369@@ -44,12 +44,12 @@
370 /*115*/ .long sys_nis_syscall, sys_gettimeofday, sys_getrusage, sys_nis_syscall, sys_getcwd
371 /*120*/ .long sys_readv, sys_writev, sys_settimeofday, sys_fchown, sys_fchmod
372 /*125*/ .long sys_nis_syscall, sys_setreuid, sys_setregid, sys_rename, sys_truncate
373-/*130*/ .long sys_ftruncate, sys_flock, sys_lfs_syscall, sys_nis_syscall, sys_nis_syscall
374-/*135*/ .long sys_nis_syscall, sys_mkdir, sys_rmdir, sys_utimes, sys_lfs_syscall
375+/*130*/ .long sys_ftruncate, sys_flock, sys_lstat64, sys_nis_syscall, sys_nis_syscall
376+/*135*/ .long sys_nis_syscall, sys_mkdir, sys_rmdir, sys_utimes, sys_stat64
377 /*140*/ .long sys_nis_syscall, sys_nis_syscall, sys_nis_syscall, sys_nis_syscall, sys_getrlimit
378 /*145*/ .long sys_setrlimit, sys_nis_syscall, sys_prctl, sys_pciconfig_read, sys_pciconfig_write
379-/*150*/ .long sys_nis_syscall, sys_nis_syscall, sys_nis_syscall, sys_poll, sys_lfs_syscall
380-/*155*/ .long sys_lfs_syscall, sys_nis_syscall, sys_statfs, sys_fstatfs, sys_oldumount
381+/*150*/ .long sys_nis_syscall, sys_nis_syscall, sys_nis_syscall, sys_poll, sys_getdents64
382+/*155*/ .long sys_fcntl64, sys_nis_syscall, sys_statfs, sys_fstatfs, sys_oldumount
383 /*160*/ .long sys_nis_syscall, sys_nis_syscall, sys_getdomainname, sys_setdomainname, sys_nis_syscall
384 /*165*/ .long sys_quotactl, sys_nis_syscall, sys_mount, sys_ustat, sys_nis_syscall
385 /*170*/ .long sys_nis_syscall, sys_nis_syscall, sys_nis_syscall, sys_nis_syscall, sys_getdents
386diff -urN lfs-ref/arch/sparc64/kernel/sparc64_ksyms.c lfs/arch/sparc64/kernel/sparc64_ksyms.c
387--- lfs-ref/arch/sparc64/kernel/sparc64_ksyms.c Wed Sep 12 02:05:39 2001
388+++ lfs/arch/sparc64/kernel/sparc64_ksyms.c Wed Sep 12 02:42:14 2001
389@@ -84,6 +84,7 @@
390 extern int sys32_ioctl(unsigned int fd, unsigned int cmd, u32 arg);
391 extern int (*handle_mathemu)(struct pt_regs *, struct fpustate *);
392 extern void VISenter(void);
393+extern long sparc32_open(const char * filename, int flags, int mode);
394 extern int io_remap_page_range(unsigned long from, unsigned long offset, unsigned long size, pgprot_t prot, int space);
395
396 extern void bcopy (const char *, char *, int);
397@@ -283,6 +284,7 @@
398 EXPORT_SYMBOL(prom_cpu_nodes);
399 EXPORT_SYMBOL(sys_ioctl);
400 EXPORT_SYMBOL(sys32_ioctl);
401+EXPORT_SYMBOL(sparc32_open);
402 EXPORT_SYMBOL(move_addr_to_kernel);
403 EXPORT_SYMBOL(move_addr_to_user);
404 #endif
405diff -urN lfs-ref/arch/sparc64/kernel/sys32.S lfs/arch/sparc64/kernel/sys32.S
406--- lfs-ref/arch/sparc64/kernel/sys32.S Thu May 4 13:00:36 2000
407+++ lfs/arch/sparc64/kernel/sys32.S Wed Sep 12 02:42:14 2001
408@@ -60,3 +60,12 @@
409 sethi %hi(sys_bdflush), %g1
410 jmpl %g1 + %lo(sys_bdflush), %g0
411 sra %o1, 0, %o1
412+
413+ .align 32
414+ .globl sys32_mmap2
415+sys32_mmap2:
416+ srl %o4, 0, %o4
417+ sethi %hi(sys_mmap), %g1
418+ srl %o5, 0, %o5
419+ jmpl %g1 + %lo(sys_mmap), %g0
420+ sllx %o5, 12, %o5
421diff -urN lfs-ref/arch/sparc64/kernel/sys_sparc32.c lfs/arch/sparc64/kernel/sys_sparc32.c
422--- lfs-ref/arch/sparc64/kernel/sys_sparc32.c Wed Sep 12 02:05:39 2001
423+++ lfs/arch/sparc64/kernel/sys_sparc32.c Wed Sep 12 02:42:14 2001
424@@ -600,15 +600,27 @@
425 old_fs = get_fs(); set_fs (KERNEL_DS);
426 ret = sys_fcntl(fd, cmd, (unsigned long)&f);
427 set_fs (old_fs);
428+ if (ret) return ret;
429+ if (f.l_start >= 0x7fffffffUL ||
430+ f.l_len >= 0x7fffffffUL ||
431+ f.l_start + f.l_len >= 0x7fffffffUL)
432+ return -EOVERFLOW;
433 if(put_flock(&f, (struct flock32 *)arg))
434 return -EFAULT;
435- return ret;
436+ return 0;
437 }
438 default:
439 return sys_fcntl(fd, cmd, (unsigned long)arg);
440 }
441 }
442
443+asmlinkage long sys32_fcntl64(unsigned int fd, unsigned int cmd, unsigned long arg)
444+{
445+ if (cmd >= F_GETLK64 && cmd <= F_SETLKW64)
446+ return sys_fcntl(fd, cmd + F_GETLK - F_GETLK64, arg);
447+ return sys32_fcntl(fd, cmd, arg);
448+}
449+
450 struct dqblk32 {
451 __u32 dqb_bhardlimit;
452 __u32 dqb_bsoftlimit;
453@@ -720,6 +732,25 @@
454 return ret;
455 }
456
457+extern asmlinkage long sys_truncate(const char * path, unsigned long length);
458+extern asmlinkage long sys_ftruncate(unsigned int fd, unsigned long length);
459+
460+asmlinkage int sys32_truncate64(const char * path, unsigned long high, unsigned long low)
461+{
462+ if ((int)high < 0)
463+ return -EINVAL;
464+ else
465+ return sys_truncate(path, (high << 32) | low);
466+}
467+
468+asmlinkage int sys32_ftruncate64(unsigned int fd, unsigned long high, unsigned long low)
469+{
470+ if ((int)high < 0)
471+ return -EINVAL;
472+ else
473+ return sys_ftruncate(fd, (high << 32) | low);
474+}
475+
476 extern asmlinkage int sys_utime(char * filename, struct utimbuf * times);
477
478 struct utimbuf32 {
479@@ -917,7 +948,7 @@
480 };
481
482 static int fillonedir(void * __buf, const char * name, int namlen,
483- off_t offset, ino_t ino)
484+ off_t offset, ino_t ino, unsigned int d_type)
485 {
486 struct readdir_callback32 * buf = (struct readdir_callback32 *) __buf;
487 struct old_linux_dirent32 * dirent;
488@@ -982,7 +1013,8 @@
489 int error;
490 };
491
492-static int filldir(void * __buf, const char * name, int namlen, off_t offset, ino_t ino)
493+static int filldir(void * __buf, const char * name, int namlen, off_t offset, ino_t ino,
494+ unsigned int d_type)
495 {
496 struct linux_dirent32 * dirent;
497 struct getdents_callback32 * buf = (struct getdents_callback32 *) __buf;
498@@ -4049,6 +4081,39 @@
499 return -EFAULT;
500
501 return ret;
502+}
503+
504+/* This is just a version for 32-bit applications which does
505+ * not force O_LARGEFILE on.
506+ */
507+
508+asmlinkage long sparc32_open(const char * filename, int flags, int mode)
509+{
510+ char * tmp;
511+ int fd, error;
512+
513+ tmp = getname(filename);
514+ fd = PTR_ERR(tmp);
515+ if (!IS_ERR(tmp)) {
516+ lock_kernel();
517+ fd = get_unused_fd();
518+ if (fd >= 0) {
519+ struct file * f = filp_open(tmp, flags, mode);
520+ error = PTR_ERR(f);
521+ if (IS_ERR(f))
522+ goto out_error;
523+ fd_install(fd, f);
524+ }
525+out:
526+ unlock_kernel();
527+ putname(tmp);
528+ }
529+ return fd;
530+
531+out_error:
532+ put_unused_fd(fd);
533+ fd = error;
534+ goto out;
535 }
536
537 /* Handle adjtimex compatability. */
538diff -urN lfs-ref/arch/sparc64/kernel/sys_sunos32.c lfs/arch/sparc64/kernel/sys_sunos32.c
539--- lfs-ref/arch/sparc64/kernel/sys_sunos32.c Fri Apr 20 22:31:15 2001
540+++ lfs/arch/sparc64/kernel/sys_sunos32.c Wed Sep 12 02:42:14 2001
541@@ -366,7 +366,7 @@
542 #define ROUND_UP(x) (((x)+sizeof(s32)-1) & ~(sizeof(s32)-1))
543
544 static int sunos_filldir(void * __buf, const char * name, int namlen,
545- off_t offset, ino_t ino)
546+ off_t offset, ino_t ino, unsigned int d_type)
547 {
548 struct sunos_dirent * dirent;
549 struct sunos_dirent_callback * buf = (struct sunos_dirent_callback *) __buf;
550@@ -458,7 +458,7 @@
551 };
552
553 static int sunos_filldirentry(void * __buf, const char * name, int namlen,
554- off_t offset, ino_t ino)
555+ off_t offset, ino_t ino, unsigned int d_type)
556 {
557 struct sunos_direntry * dirent;
558 struct sunos_direntry_callback * buf = (struct sunos_direntry_callback *) __buf;
559@@ -1297,13 +1297,15 @@
560 return rval;
561 }
562
563+extern asmlinkage long sparc32_open(const char * filename, int flags, int mode);
564+
565 asmlinkage int sunos_open(u32 filename, int flags, int mode)
566 {
567 int ret;
568
569 lock_kernel();
570 current->personality |= PER_BSD;
571- ret = sys_open ((char *)A(filename), flags, mode);
572+ ret = sparc32_open ((char *)A(filename), flags, mode);
573 unlock_kernel();
574 return ret;
575 }
576diff -urN lfs-ref/arch/sparc64/kernel/systbls.S lfs/arch/sparc64/kernel/systbls.S
577--- lfs-ref/arch/sparc64/kernel/systbls.S Fri Apr 20 22:31:15 2001
578+++ lfs/arch/sparc64/kernel/systbls.S Wed Sep 12 02:42:14 2001
579@@ -20,7 +20,7 @@
580 .globl sys_call_table32
581 sys_call_table32:
582 /*0*/ .word sys_nis_syscall, sparc_exit, sys_fork, sys_read, sys_write
583-/*5*/ .word sys_open, sys_close, sys32_wait4, sys_creat, sys_link
584+/*5*/ .word sparc32_open, sys_close, sys32_wait4, sys_creat, sys_link
585 /*10*/ .word sys_unlink, sunos_execv, sys_chdir, sys32_chown16, sys32_mknod
586 /*15*/ .word sys32_chmod, sys32_lchown16, sparc_brk, sys_perfctr, sys32_lseek
587 /*20*/ .word sys_getpid, sys_capget, sys_capset, sys_setuid, sys_getuid
588@@ -30,12 +30,12 @@
589 /*40*/ .word sys32_newlstat, sys_dup, sys_pipe, sys32_times, sys_lfs_syscall
590 .word sys_umount, sys_setgid, sys_getgid, sys_signal, sys_geteuid
591 /*50*/ .word sys_getegid, sys_acct, sys_nis_syscall, sys_nis_syscall, sys32_ioctl
592- .word sys_reboot, sys_lfs_syscall, sys_symlink, sys_readlink, sys32_execve
593-/*60*/ .word sys_umask, sys_chroot, sys32_newfstat, sys_lfs_syscall, sys_getpagesize
594+ .word sys_reboot, sys32_mmap2, sys_symlink, sys_readlink, sys32_execve
595+/*60*/ .word sys_umask, sys_chroot, sys32_newfstat, sys_fstat64, sys_getpagesize
596 .word sys_msync, sys_vfork, sys32_pread, sys32_pwrite, sys_nis_syscall
597 /*70*/ .word sys_nis_syscall, sys32_mmap, sys_nis_syscall, sys_munmap, sys_mprotect
598- .word sys_nis_syscall, sys_vhangup, sys_lfs_syscall, sys_nis_syscall, sys32_getgroups
599-/*80*/ .word sys32_setgroups, sys_getpgrp, sys_nis_syscall, sys32_setitimer, sys_lfs_syscall
600+ .word sys_nis_syscall, sys_vhangup, sys32_truncate64, sys_nis_syscall, sys32_getgroups
601+/*80*/ .word sys32_setgroups, sys_getpgrp, sys_nis_syscall, sys32_setitimer, sys32_ftruncate64
602 .word sys_swapon, sys32_getitimer, sys_nis_syscall, sys_sethostname, sys_nis_syscall
603 /*90*/ .word sys_dup2, sys_nis_syscall, sys32_fcntl, sys32_select, sys_nis_syscall
604 .word sys_fsync, sys_setpriority, sys_nis_syscall, sys_nis_syscall, sys_nis_syscall
605@@ -45,12 +45,12 @@
606 .word sys_nis_syscall, sys32_gettimeofday, sys32_getrusage, sys_nis_syscall, sys_getcwd
607 /*120*/ .word sys32_readv, sys32_writev, sys32_settimeofday, sys32_fchown16, sys_fchmod
608 .word sys_nis_syscall, sys32_setreuid, sys32_setregid, sys_rename, sys_truncate
609-/*130*/ .word sys_ftruncate, sys_flock, sys_lfs_syscall, sys_nis_syscall, sys_nis_syscall
610- .word sys_nis_syscall, sys_mkdir, sys_rmdir, sys32_utimes, sys_lfs_syscall
611+/*130*/ .word sys_ftruncate, sys_flock, sys_lstat64, sys_nis_syscall, sys_nis_syscall
612+ .word sys_nis_syscall, sys_mkdir, sys_rmdir, sys32_utimes, sys_stat64
613 /*140*/ .word sys_nis_syscall, sys_nis_syscall, sys_nis_syscall, sys_nis_syscall, sys32_getrlimit
614 .word sys32_setrlimit, sys_nis_syscall, sys32_prctl, sys32_pciconfig_read, sys32_pciconfig_write
615-/*150*/ .word sys_nis_syscall, sys_nis_syscall, sys_nis_syscall, sys_poll, sys_lfs_syscall
616- .word sys_lfs_syscall, sys_nis_syscall, sys32_statfs, sys32_fstatfs, sys_oldumount
617+/*150*/ .word sys_nis_syscall, sys_nis_syscall, sys_nis_syscall, sys_poll, sys_getdents64
618+ .word sys32_fcntl64, sys_nis_syscall, sys32_statfs, sys32_fstatfs, sys_oldumount
619 /*160*/ .word sys_nis_syscall, sys_nis_syscall, sys_getdomainname, sys_setdomainname, sys_nis_syscall
620 .word sys32_quotactl, sys_nis_syscall, sys32_mount, sys_ustat, sys_nis_syscall
621 /*170*/ .word sys_nis_syscall, sys_nis_syscall, sys_nis_syscall, sys_nis_syscall, sys32_getdents
622@@ -108,7 +108,7 @@
623 .word sys_socketpair, sys_mkdir, sys_rmdir, sys_utimes, sys_nis_syscall
624 /*140*/ .word sys_nis_syscall, sys_getpeername, sys_nis_syscall, sys_nis_syscall, sys_getrlimit
625 .word sys_setrlimit, sys_nis_syscall, sys_prctl, sys_pciconfig_read, sys_pciconfig_write
626-/*150*/ .word sys_getsockname, sys_nis_syscall, sys_nis_syscall, sys_poll, sys_nis_syscall
627+/*150*/ .word sys_getsockname, sys_nis_syscall, sys_nis_syscall, sys_poll, sys_getdents64
628 .word sys_nis_syscall, sys_nis_syscall, sys_statfs, sys_fstatfs, sys_oldumount
629 /*160*/ .word sys_nis_syscall, sys_nis_syscall, sys_getdomainname, sys_setdomainname, sys_utrap_install
630 .word sys_quotactl, sys_nis_syscall, sys_mount, sys_ustat, sys_nis_syscall
631diff -urN lfs-ref/arch/sparc64/solaris/fs.c lfs/arch/sparc64/solaris/fs.c
632--- lfs-ref/arch/sparc64/solaris/fs.c Mon Jan 17 16:44:36 2000
633+++ lfs/arch/sparc64/solaris/fs.c Wed Sep 12 02:42:14 2001
634@@ -572,20 +572,20 @@
635 return error;
636 }
637
638+extern asmlinkage long sparc32_open(const char * filename, int flags, int mode);
639+
640 asmlinkage int solaris_open(u32 filename, int flags, u32 mode)
641 {
642- int (*sys_open)(const char *,int,int) =
643- (int (*)(const char *,int,int))SYS(open);
644 int fl = flags & 0xf;
645
646-/* if (flags & 0x2000) - allow LFS */
647+ if (flags & 0x2000) fl |= O_LARGEFILE;
648 if (flags & 0x8050) fl |= O_SYNC;
649 if (flags & 0x80) fl |= O_NONBLOCK;
650 if (flags & 0x100) fl |= O_CREAT;
651 if (flags & 0x200) fl |= O_TRUNC;
652 if (flags & 0x400) fl |= O_EXCL;
653 if (flags & 0x800) fl |= O_NOCTTY;
654- return sys_open((const char *)A(filename), fl, mode);
655+ return sparc32_open((const char *)A(filename), fl, mode);
656 }
657
658 #define SOL_F_SETLK 6
659diff -urN lfs-ref/drivers/block/loop.c lfs/drivers/block/loop.c
660--- lfs-ref/drivers/block/loop.c Wed Sep 12 02:39:57 2001
661+++ lfs/drivers/block/loop.c Wed Sep 12 02:42:14 2001
662@@ -143,12 +143,12 @@
663 int size;
664
665 if (S_ISREG(lo->lo_dentry->d_inode->i_mode))
666- size = (lo->lo_dentry->d_inode->i_size - lo->lo_offset) / BLOCK_SIZE;
667+ size = (lo->lo_dentry->d_inode->i_size - lo->lo_offset) >> BLOCK_SIZE_BITS;
668 else {
669 kdev_t lodev = lo->lo_device;
670 if (blk_size[MAJOR(lodev)])
671 size = blk_size[MAJOR(lodev)][MINOR(lodev)] -
672- lo->lo_offset / BLOCK_SIZE;
673+ (lo->lo_offset >> BLOCK_SIZE_BITS);
674 else
675 size = MAX_DISK_SIZE;
676 }
677diff -urN lfs-ref/drivers/usb/inode.c lfs/drivers/usb/inode.c
678--- lfs-ref/drivers/usb/inode.c Mon Dec 11 16:57:58 2000
679+++ lfs/drivers/usb/inode.c Wed Sep 12 02:42:14 2001
680@@ -302,14 +302,14 @@
681 i = filp->f_pos;
682 switch (i) {
683 case 0:
684- if (filldir(dirent, ".", 1, i, IROOT) < 0)
685+ if (filldir(dirent, ".", 1, i, IROOT, DT_DIR) < 0)
686 return 0;
687 filp->f_pos++;
688 i++;
689 /* fall through */
690
691 case 1:
692- if (filldir(dirent, "..", 2, i, IROOT) < 0)
693+ if (filldir(dirent, "..", 2, i, IROOT, DT_DIR) < 0)
694 return 0;
695 filp->f_pos++;
696 i++;
697@@ -319,7 +319,7 @@
698
699 while (i >= 2 && i < 2+NRSPECIAL) {
700 spec = &special[filp->f_pos-2];
701- if (filldir(dirent, spec->name, strlen(spec->name), i, ISPECIAL | (filp->f_pos-2+IROOT)) < 0)
702+ if (filldir(dirent, spec->name, strlen(spec->name), i, ISPECIAL | (filp->f_pos-2+IROOT), DT_UNKNOWN) < 0)
703 return 0;
704 filp->f_pos++;
705 i++;
706@@ -335,7 +335,7 @@
707 }
708 bus = list_entry(list, struct usb_bus, bus_list);
709 sprintf(numbuf, "%03d", bus->busnum);
710- if (filldir(dirent, numbuf, 3, filp->f_pos, IBUS | ((bus->busnum & 0xff) << 8)) < 0)
711+ if (filldir(dirent, numbuf, 3, filp->f_pos, IBUS | ((bus->busnum & 0xff) << 8), DT_UNKNOWN) < 0)
712 break;
713 filp->f_pos++;
714 }
715@@ -355,7 +355,7 @@
716 if (pos > 0)
717 pos--;
718 else {
719- if (filldir(dirent, numbuf, 3, filp->f_pos, ino | (dev->devnum & 0xff)) < 0)
720+ if (filldir(dirent, numbuf, 3, filp->f_pos, ino | (dev->devnum & 0xff), DT_UNKNOWN) < 0)
721 return -1;
722 filp->f_pos++;
723 }
724@@ -380,13 +380,13 @@
725 return -EINVAL;
726 switch ((unsigned int)filp->f_pos) {
727 case 0:
728- if (filldir(dirent, ".", 1, filp->f_pos, ino) < 0)
729+ if (filldir(dirent, ".", 1, filp->f_pos, ino, DT_DIR) < 0)
730 return 0;
731 filp->f_pos++;
732 /* fall through */
733
734 case 1:
735- if (filldir(dirent, "..", 2, filp->f_pos, IROOT) < 0)
736+ if (filldir(dirent, "..", 2, filp->f_pos, IROOT, DT_DIR) < 0)
737 return 0;
738 filp->f_pos++;
739 /* fall through */
740diff -urN lfs-ref/fs/adfs/dir.c lfs/fs/adfs/dir.c
741--- lfs-ref/fs/adfs/dir.c Mon Dec 11 16:58:00 2000
742+++ lfs/fs/adfs/dir.c Wed Sep 12 02:42:14 2001
743@@ -40,12 +40,12 @@
744
745 switch ((unsigned long)filp->f_pos) {
746 case 0:
747- if (filldir(dirent, ".", 1, 0, inode->i_ino) < 0)
748+ if (filldir(dirent, ".", 1, 0, inode->i_ino, DT_DIR) < 0)
749 goto free_out;
750 filp->f_pos += 1;
751
752 case 1:
753- if (filldir(dirent, "..", 2, 1, dir.parent_id) < 0)
754+ if (filldir(dirent, "..", 2, 1, dir.parent_id, DT_DIR) < 0)
755 goto free_out;
756 filp->f_pos += 1;
757
758@@ -60,7 +60,7 @@
759 goto unlock_out;
760 while (ops->getnext(&dir, &obj) == 0) {
761 if (filldir(dirent, obj.name, obj.name_len,
762- filp->f_pos, obj.file_id) < 0)
763+ filp->f_pos, obj.file_id, DT_UNKNOWN) < 0)
764 goto unlock_out;
765 filp->f_pos += 1;
766 }
767diff -urN lfs-ref/fs/affs/dir.c lfs/fs/affs/dir.c
768--- lfs-ref/fs/affs/dir.c Mon Jan 17 16:44:41 2000
769+++ lfs/fs/affs/dir.c Wed Sep 12 02:42:14 2001
770@@ -98,14 +98,14 @@
771
772 if (filp->f_pos == 0) {
773 filp->private_data = (void *)0;
774- if (filldir(dirent,".",1,filp->f_pos,inode->i_ino) < 0) {
775+ if (filldir(dirent,".",1,filp->f_pos,inode->i_ino, DT_DIR) < 0) {
776 return 0;
777 }
778 ++filp->f_pos;
779 stored++;
780 }
781 if (filp->f_pos == 1) {
782- if (filldir(dirent,"..",2,filp->f_pos,affs_parent_ino(inode)) < 0) {
783+ if (filldir(dirent,"..",2,filp->f_pos,affs_parent_ino(inode), DT_DIR) < 0) {
784 return stored;
785 }
786 filp->f_pos = 2;
787@@ -161,7 +161,7 @@
788 pr_debug("AFFS: readdir(): filldir(\"%.*s\",ino=%lu), i=%d\n",
789 namelen,name,ino,i);
790 filp->private_data = (void *)ino;
791- if (filldir(dirent,name,namelen,filp->f_pos,ino) < 0)
792+ if (filldir(dirent,name,namelen,filp->f_pos,ino, DT_UNKNOWN) < 0)
793 goto readdir_done;
794 filp->private_data = (void *)i;
795 affs_brelse(fh_bh);
796diff -urN lfs-ref/fs/affs/file.c lfs/fs/affs/file.c
797--- lfs-ref/fs/affs/file.c Tue Sep 5 02:28:47 2000
798+++ lfs/fs/affs/file.c Wed Sep 12 02:42:14 2001
799@@ -582,17 +582,17 @@
800 affs_file_write(struct file *filp, const char *buf, size_t count, loff_t *ppos)
801 {
802 struct inode *inode = filp->f_dentry->d_inode;
803- off_t pos;
804+ loff_t pos;
805 ssize_t written;
806 ssize_t c;
807- ssize_t blocksize;
808+ ssize_t blocksize, blockshift;
809 struct buffer_head *bh;
810 char *p;
811
812 if (!count)
813 return 0;
814- pr_debug("AFFS: file_write(ino=%lu,pos=%lu,count=%d)\n",inode->i_ino,
815- (unsigned long)*ppos,count);
816+ pr_debug("AFFS: file_write(ino=%lu,pos=%Lu,count=%d)\n",inode->i_ino,
817+ *ppos,count);
818
819 if (!inode) {
820 affs_error(inode->i_sb,"file_write","Inode = NULL");
821@@ -611,16 +611,22 @@
822 else
823 pos = *ppos;
824 written = 0;
825- blocksize = AFFS_I2BSIZE(inode);
826+ blocksize = AFFS_I2BSIZE(inode);
827+ blockshift = AFFS_I2BITS(inode);
828+
829+ if (pos >= 0x7fffffff) /* Max size: 2G-1 */
830+ return -EFBIG;
831+ if ((pos + count) > 0x7fffffff)
832+ count = 0x7fffffff - pos;
833
834 while (written < count) {
835- bh = affs_getblock(inode,pos / blocksize);
836+ bh = affs_getblock(inode, pos >> blockshift);
837 if (!bh) {
838 if (!written)
839 written = -ENOSPC;
840 break;
841 }
842- c = blocksize - (pos % blocksize);
843+ c = blocksize - (pos & (blocksize -1));
844 if (c > count - written)
845 c = count - written;
846 if (c != blocksize && !buffer_uptodate(bh)) {
847@@ -633,7 +639,7 @@
848 break;
849 }
850 }
851- p = (pos % blocksize) + bh->b_data;
852+ p = (pos & (blocksize -1)) + bh->b_data;
853 c -= copy_from_user(p,buf,c);
854 if (!c) {
855 affs_brelse(bh);
856@@ -664,7 +670,7 @@
857 off_t pos;
858 ssize_t written;
859 ssize_t c;
860- ssize_t blocksize;
861+ ssize_t blocksize, blockshift;
862 struct buffer_head *bh;
863 char *p;
864
865@@ -692,15 +698,16 @@
866
867 bh = NULL;
868 blocksize = AFFS_I2BSIZE(inode) - 24;
869+ blockshift = AFFS_I2BITS(inode);
870 written = 0;
871 while (written < count) {
872- bh = affs_getblock(inode,pos / blocksize);
873+ bh = affs_getblock(inode,pos >> blockshift);
874 if (!bh) {
875 if (!written)
876 written = -ENOSPC;
877 break;
878 }
879- c = blocksize - (pos % blocksize);
880+ c = blocksize - (pos & (blocksize -1));
881 if (c > count - written)
882 c = count - written;
883 if (c != blocksize && !buffer_uptodate(bh)) {
884@@ -713,7 +720,7 @@
885 break;
886 }
887 }
888- p = (pos % blocksize) + bh->b_data + 24;
889+ p = (pos & (blocksize -1)) + bh->b_data + 24;
890 c -= copy_from_user(p,buf,c);
891 if (!c) {
892 affs_brelse(bh);
893@@ -782,10 +789,10 @@
894 int rem;
895 int ext;
896
897- pr_debug("AFFS: truncate(inode=%ld,size=%lu)\n",inode->i_ino,inode->i_size);
898+ pr_debug("AFFS: truncate(inode=%ld,size=%Lu)\n",inode->i_ino,inode->i_size);
899
900 net_blocksize = blocksize - ((inode->i_sb->u.affs_sb.s_flags & SF_OFS) ? 24 : 0);
901- first = (inode->i_size + net_blocksize - 1) / net_blocksize;
902+ first = (u_long)(inode->i_size + net_blocksize - 1) / net_blocksize;
903 if (inode->u.affs_i.i_lastblock < first - 1) {
904 /* There has to be at least one new block to be allocated */
905 if (!inode->u.affs_i.i_ec && alloc_ext_cache(inode)) {
906@@ -795,9 +802,9 @@
907 bh = affs_getblock(inode,first - 1);
908 if (!bh) {
909 affs_warning(inode->i_sb,"truncate","Cannot extend file");
910- inode->i_size = net_blocksize * (inode->u.affs_i.i_lastblock + 1);
911+ inode->i_size = (inode->u.affs_i.i_lastblock + 1) * net_blocksize;
912 } else if (inode->i_sb->u.affs_sb.s_flags & SF_OFS) {
913- rem = inode->i_size % net_blocksize;
914+ rem = ((u_long)inode->i_size) & (net_blocksize -1);
915 DATA_FRONT(bh)->data_size = cpu_to_be32(rem ? rem : net_blocksize);
916 affs_fix_checksum(blocksize,bh->b_data,5);
917 mark_buffer_dirty(bh,0);
918@@ -864,7 +871,7 @@
919 affs_free_block(inode->i_sb,ekey);
920 ekey = key;
921 }
922- block = ((inode->i_size + net_blocksize - 1) / net_blocksize) - 1;
923+ block = (((u_long)inode->i_size + net_blocksize - 1) / net_blocksize) - 1;
924 inode->u.affs_i.i_lastblock = block;
925
926 /* If the file is not truncated to a block boundary,
927@@ -872,7 +879,7 @@
928 * so it cannot become accessible again.
929 */
930
931- rem = inode->i_size % net_blocksize;
932+ rem = inode->i_size & (net_blocksize -1);
933 if (rem) {
934 if ((inode->i_sb->u.affs_sb.s_flags & SF_OFS))
935 rem += 24;
936diff -urN lfs-ref/fs/affs/inode.c lfs/fs/affs/inode.c
937--- lfs-ref/fs/affs/inode.c Sun Apr 2 21:07:49 2000
938+++ lfs/fs/affs/inode.c Wed Sep 12 02:42:14 2001
939@@ -146,7 +146,7 @@
940 block = AFFS_I2BSIZE(inode) - 24;
941 else
942 block = AFFS_I2BSIZE(inode);
943- inode->u.affs_i.i_lastblock = ((inode->i_size + block - 1) / block) - 1;
944+ inode->u.affs_i.i_lastblock = (((u_long)inode->i_size + block - 1) / block) - 1;
945 break;
946 case ST_SOFTLINK:
947 inode->i_mode |= S_IFLNK;
948diff -urN lfs-ref/fs/autofs/dir.c lfs/fs/autofs/dir.c
949--- lfs-ref/fs/autofs/dir.c Mon Jan 17 16:44:41 2000
950+++ lfs/fs/autofs/dir.c Wed Sep 12 02:42:14 2001
951@@ -20,12 +20,12 @@
952 switch((unsigned long) filp->f_pos)
953 {
954 case 0:
955- if (filldir(dirent, ".", 1, 0, inode->i_ino) < 0)
956+ if (filldir(dirent, ".", 1, 0, inode->i_ino, DT_DIR) < 0)
957 return 0;
958 filp->f_pos++;
959 /* fall through */
960 case 1:
961- if (filldir(dirent, "..", 2, 1, AUTOFS_ROOT_INO) < 0)
962+ if (filldir(dirent, "..", 2, 1, AUTOFS_ROOT_INO, DT_DIR) < 0)
963 return 0;
964 filp->f_pos++;
965 /* fall through */
966diff -urN lfs-ref/fs/autofs/root.c lfs/fs/autofs/root.c
967--- lfs-ref/fs/autofs/root.c Mon Jan 17 16:44:41 2000
968+++ lfs/fs/autofs/root.c Wed Sep 12 02:42:14 2001
969@@ -79,19 +79,19 @@
970 switch(nr)
971 {
972 case 0:
973- if (filldir(dirent, ".", 1, nr, inode->i_ino) < 0)
974+ if (filldir(dirent, ".", 1, nr, inode->i_ino, DT_DIR) < 0)
975 return 0;
976 filp->f_pos = ++nr;
977 /* fall through */
978 case 1:
979- if (filldir(dirent, "..", 2, nr, inode->i_ino) < 0)
980+ if (filldir(dirent, "..", 2, nr, inode->i_ino, DT_DIR) < 0)
981 return 0;
982 filp->f_pos = ++nr;
983 /* fall through */
984 default:
985 while ( onr = nr, ent = autofs_hash_enum(dirhash,&nr,ent) ) {
986 if ( !ent->dentry || ent->dentry->d_mounts != ent->dentry ) {
987- if (filldir(dirent,ent->name,ent->len,onr,ent->ino) < 0)
988+ if (filldir(dirent,ent->name,ent->len,onr,ent->ino, DT_UNKNOWN) < 0)
989 return 0;
990 filp->f_pos = nr;
991 }
992diff -urN lfs-ref/fs/binfmt_aout.c lfs/fs/binfmt_aout.c
993--- lfs-ref/fs/binfmt_aout.c Wed Sep 12 02:05:57 2001
994+++ lfs/fs/binfmt_aout.c Wed Sep 12 02:42:14 2001
995@@ -369,7 +369,11 @@
996 file = fget(fd);
997
998 if (!file->f_op || !file->f_op->mmap ||
999+#if 0
1000 fd_offset & (bprm->dentry->d_inode->i_sb->s_blocksize-1)) {
1001+#else /* LFS enforces PAGE_SIZE file offset granularity in mmap */
1002+ fd_offset & ~PAGE_MASK) {
1003+#endif
1004 if (warnings++<10)
1005 printk(KERN_NOTICE
1006 "fd_offset is not blocksize aligned. Loading %s in anonymous memory.\n",
1007@@ -467,7 +471,11 @@
1008
1009 start_addr = ex.a_entry & 0xfffff000;
1010
1011+#if 0
1012 if (N_TXTOFF(ex) & (inode->i_sb->s_blocksize-1)) {
1013+#else /* LFS enforces PAGE_SIZE file offset granularity in mmap */
1014+ if (N_TXTOFF(ex) & ~PAGE_MASK) {
1015+#endif
1016 if (warnings++<10)
1017 printk(KERN_NOTICE
1018 "N_TXTOFF is not blocksize aligned. Loading library %s in anonymous memory.\n",
1019diff -urN lfs-ref/fs/buffer.c lfs/fs/buffer.c
1020--- lfs-ref/fs/buffer.c Wed Sep 12 02:39:58 2001
1021+++ lfs/fs/buffer.c Wed Sep 12 02:42:15 2001
1022@@ -1219,7 +1219,7 @@
1023 #endif
1024 }
1025 if (test_and_clear_bit(PG_swap_unlock_after, &page->flags))
1026- swap_after_unlock_page(page->offset);
1027+ swap_after_unlock_page(pgoff2ulong(page->index));
1028 if (test_and_clear_bit(PG_free_after, &page->flags))
1029 __free_page(page);
1030 }
1031@@ -1682,15 +1682,46 @@
1032 set_bit(PG_locked, &page->flags);
1033 set_bit(PG_free_after, &page->flags);
1034
1035+ /* Blocks within a page */
1036 i = PAGE_SIZE >> inode->i_sb->s_blocksize_bits;
1037- block = page->offset >> inode->i_sb->s_blocksize_bits;
1038- p = nr;
1039- do {
1040- *p = inode->i_op->bmap(inode, block);
1041- i--;
1042- block++;
1043- p++;
1044- } while (i > 0);
1045+
1046+ block = pgoff2ulong(page->index);
1047+ /* Scaled already by PAGE_SHIFT, which said shift should
1048+ be same or larger, than that of any filesystem in
1049+ this system -- that is, at i386 with 4k pages one
1050+ can't use 8k (primitive) blocks at the filesystems... */
1051+
1052+ if (i > 0) {
1053+ /* Filesystem blocksize is same, or smaller than CPU
1054+ page size, we can easily process this.. */
1055+
1056+ if (i > 1)
1057+ block *= i;
1058+ /* Scale by FS blocks per page, presuming FS-blocks are smaller
1059+ than the processor page... */
1060+
1061+ p = nr;
1062+ do {
1063+ *p = inode->i_op->bmap(inode, block);
1064+ i--;
1065+ block++;
1066+ p++;
1067+ } while (i > 0);
1068+ } else {
1069+ /* Filesystem blocksize is larger than CPU page size,
1070+ but if the underlying storage system block size is
1071+ smaller than CPU page size, all is well, else we
1072+ are in deep trouble -- for direct paging in at least.. */
1073+ /* Nobody needs such monsterous fs block sizes ?
1074+ Well, it is the only way to get files in terabyte
1075+ range.. Nobody needs them ? You are for a surprise..
1076+ However EXT2 (at least) needs access to internal
1077+ blocks and there it needs allocations of 8k/16k (or
1078+ whatever the block size is) for internal uses..
1079+ Fixing this function alone isn't enough, although
1080+ perhaps fairly trivial.. */
1081+ /* FIXME: WRITE THE CODE HERE !!! */
1082+ }
1083
1084 /* IO start */
1085 brw_page(READ, page, inode->i_dev, nr, inode->i_sb->s_blocksize, 1);
1086diff -urN lfs-ref/fs/coda/dir.c lfs/fs/coda/dir.c
1087--- lfs-ref/fs/coda/dir.c Tue Sep 5 02:28:47 2000
1088+++ lfs/fs/coda/dir.c Wed Sep 12 02:42:15 2001
1089@@ -749,7 +749,7 @@
1090 char *name = vdirent->d_name;
1091
1092 errfill = filldir(getdent, name, namlen,
1093- offs, ino);
1094+ offs, ino, DT_UNKNOWN);
1095 CDEBUG(D_FILE, "entry %d: ino %ld, namlen %d, reclen %d, type %d, pos %d, string_offs %d, name %*s, offset %d, result: %d, errfill: %d.\n", i,vdirent->d_fileno, vdirent->d_namlen, vdirent->d_reclen, vdirent->d_type, pos, string_offset, vdirent->d_namlen, vdirent->d_name, (u_int) offs, result, errfill);
1096 /* errfill means no space for filling in this round */
1097 if ( errfill < 0 ) {
1098diff -urN lfs-ref/fs/coda/file.c lfs/fs/coda/file.c
1099--- lfs-ref/fs/coda/file.c Fri Apr 20 22:31:20 2001
1100+++ lfs/fs/coda/file.c Wed Sep 12 02:42:15 2001
1101@@ -99,7 +99,7 @@
1102 &cont_file, &cont_dentry);
1103
1104 CDEBUG(D_INODE, "coda ino: %ld, cached ino %ld, page offset: %lx\n",
1105- coda_inode->i_ino, cii->c_ovp->i_ino, page->offset);
1106+ coda_inode->i_ino, cii->c_ovp->i_ino, pgoff2ulong(page->index));
1107
1108 generic_readpage(&cont_file, page);
1109 EXIT;
1110diff -urN lfs-ref/fs/devpts/root.c lfs/fs/devpts/root.c
1111--- lfs-ref/fs/devpts/root.c Mon Jan 17 16:44:41 2000
1112+++ lfs/fs/devpts/root.c Wed Sep 12 02:42:15 2001
1113@@ -86,12 +86,12 @@
1114 switch(nr)
1115 {
1116 case 0:
1117- if (filldir(dirent, ".", 1, nr, inode->i_ino) < 0)
1118+ if (filldir(dirent, ".", 1, nr, inode->i_ino, DT_DIR) < 0)
1119 return 0;
1120 filp->f_pos = ++nr;
1121 /* fall through */
1122 case 1:
1123- if (filldir(dirent, "..", 2, nr, inode->i_ino) < 0)
1124+ if (filldir(dirent, "..", 2, nr, inode->i_ino, DT_DIR) < 0)
1125 return 0;
1126 filp->f_pos = ++nr;
1127 /* fall through */
1128@@ -100,7 +100,7 @@
1129 int ptynr = nr - 2;
1130 if ( sbi->inodes[ptynr] ) {
1131 genptsname(numbuf, ptynr);
1132- if ( filldir(dirent, numbuf, strlen(numbuf), nr, nr) < 0 )
1133+ if ( filldir(dirent, numbuf, strlen(numbuf), nr, nr, DT_CHR) < 0 )
1134 return 0;
1135 }
1136 filp->f_pos = ++nr;
1137diff -urN lfs-ref/fs/dquot.c lfs/fs/dquot.c
1138--- lfs-ref/fs/dquot.c Wed Sep 12 02:05:57 2001
1139+++ lfs/fs/dquot.c Wed Sep 12 02:42:15 2001
1140@@ -1529,7 +1529,7 @@
1141 if (!S_ISREG(inode->i_mode))
1142 goto out_f;
1143 error = -EINVAL;
1144- if (inode->i_size == 0 || (inode->i_size % sizeof(struct dqblk)) != 0)
1145+ if (inode->i_size == 0 || ((off_t)inode->i_size % sizeof(struct dqblk)) != 0)
1146 goto out_f;
1147 dquot_drop(inode); /* We don't want quota on quota files */
1148
1149diff -urN lfs-ref/fs/efs/dir.c lfs/fs/efs/dir.c
1150--- lfs-ref/fs/efs/dir.c Mon Jan 17 16:44:41 2000
1151+++ lfs/fs/efs/dir.c Wed Sep 12 02:42:15 2001
1152@@ -107,7 +107,7 @@
1153 filp->f_pos = (block << EFS_DIRBSIZE_BITS) | slot;
1154
1155 /* copy filename and data in dirslot */
1156- filldir(dirent, nameptr, namelen, filp->f_pos, inodenum);
1157+ filldir(dirent, nameptr, namelen, filp->f_pos, inodenum, DT_UNKNOWN);
1158
1159 /* sanity check */
1160 if (nameptr - (char *) dirblock + namelen > EFS_DIRBSIZE) {
1161diff -urN lfs-ref/fs/ext2/dir.c lfs/fs/ext2/dir.c
1162--- lfs-ref/fs/ext2/dir.c Thu May 4 13:00:39 2000
1163+++ lfs/fs/ext2/dir.c Wed Sep 12 02:42:15 2001
1164@@ -32,6 +32,10 @@
1165 return -EISDIR;
1166 }
1167
1168+static unsigned char ext2_filetype_table[] = {
1169+ DT_UNKNOWN, DT_REG, DT_DIR, DT_CHR, DT_BLK, DT_FIFO, DT_SOCK, DT_LNK
1170+};
1171+
1172 static int ext2_readdir(struct file *, void *, filldir_t);
1173
1174 static struct file_operations ext2_dir_operations = {
1175@@ -201,10 +205,14 @@
1176 * the descriptor.
1177 */
1178 unsigned long version = filp->f_version;
1179+ unsigned char d_type = DT_UNKNOWN;
1180
1181+ if (EXT2_HAS_INCOMPAT_FEATURE(sb, EXT2_FEATURE_INCOMPAT_FILETYPE)
1182+ && de->file_type < EXT2_FT_MAX)
1183+ d_type = ext2_filetype_table[de->file_type];
1184 error = filldir(dirent, de->name,
1185 de->name_len,
1186- filp->f_pos, le32_to_cpu(de->inode));
1187+ filp->f_pos, le32_to_cpu(de->inode), d_type);
1188 if (error)
1189 break;
1190 if (version != filp->f_version)
1191diff -urN lfs-ref/fs/ext2/file.c lfs/fs/ext2/file.c
1192--- lfs-ref/fs/ext2/file.c Wed Sep 12 02:39:57 2001
1193+++ lfs/fs/ext2/file.c Wed Sep 12 02:42:15 2001
1194@@ -39,10 +39,6 @@
1195 static long long ext2_file_lseek(struct file *, long long, int);
1196 static ssize_t ext2_file_write (struct file *, const char *, size_t, loff_t *);
1197 static int ext2_release_file (struct inode *, struct file *);
1198-#if BITS_PER_LONG < 64
1199-static int ext2_open_file (struct inode *, struct file *);
1200-
1201-#else
1202
1203 #define EXT2_MAX_SIZE(bits) \
1204 (((EXT2_NDIR_BLOCKS + (1LL << (bits - 2)) + \
1205@@ -55,8 +51,6 @@
1206 EXT2_MAX_SIZE(10), EXT2_MAX_SIZE(11), EXT2_MAX_SIZE(12), EXT2_MAX_SIZE(13)
1207 };
1208
1209-#endif
1210-
1211 /*
1212 * We have mostly NULL's here: the current defaults are ok for
1213 * the ext2 filesystem.
1214@@ -69,11 +63,7 @@
1215 NULL, /* poll - default */
1216 ext2_ioctl, /* ioctl */
1217 generic_file_mmap, /* mmap */
1218-#if BITS_PER_LONG == 64
1219 NULL, /* no special open is needed */
1220-#else
1221- ext2_open_file,
1222-#endif
1223 NULL, /* flush */
1224 ext2_release_file, /* release */
1225 ext2_sync_file, /* fsync */
1226@@ -120,14 +110,9 @@
1227 case 1:
1228 offset += file->f_pos;
1229 }
1230-#if BITS_PER_LONG < 64
1231- if (offset >> 31)
1232- return -EINVAL;
1233-#else
1234 if (offset < 0 ||
1235 offset > ext2_max_sizes[EXT2_BLOCK_SIZE_BITS(inode->i_sb)])
1236 return -EINVAL;
1237-#endif
1238 if (offset != file->f_pos) {
1239 file->f_pos = offset;
1240 file->f_reada = 0;
1241@@ -155,7 +140,7 @@
1242 size_t count, loff_t *ppos)
1243 {
1244 struct inode * inode = filp->f_dentry->d_inode;
1245- off_t pos;
1246+ loff_t pos;
1247 long block;
1248 int offset;
1249 size_t written, c;
1250@@ -202,24 +187,17 @@
1251
1252 /* Check for overflow.. */
1253
1254-#if BITS_PER_LONG < 64
1255- /* If the fd's pos is already greater than or equal to the file
1256- * descriptor's offset maximum, then we need to return EFBIG for
1257- * any non-zero count (and we already tested for zero above). */
1258- if (((unsigned long) pos) >= 0x7FFFFFFFUL)
1259- return -EFBIG;
1260-
1261- /* If we are about to overflow the maximum file size, we also
1262- * need to return the error, but only if no bytes can be written
1263- * successfully. */
1264- if (((unsigned long) pos + count) > 0x7FFFFFFFUL) {
1265- count = 0x7FFFFFFFL - pos;
1266- if (((ssize_t) count) < 0)
1267+ /* L-F-S spec 2.2.1.27: */
1268+ if (!(filp->f_flags & O_LARGEFILE)) {
1269+ if (pos >= 0x7fffffffULL) /* pos@2G forbidden */
1270 return -EFBIG;
1271 }
1272-#else
1273+
1274+ if (pos + count > 0x7fffffffULL)
1275+ /* Write only until end of allowed region */
1276+ count = 0x7fffffffULL - pos;
1277 {
1278- off_t max = ext2_max_sizes[EXT2_BLOCK_SIZE_BITS(sb)];
1279+ loff_t max = ext2_max_sizes[EXT2_BLOCK_SIZE_BITS(sb)];
1280
1281 if (pos >= max)
1282 return -EFBIG;
1283@@ -239,20 +217,18 @@
1284 mark_buffer_dirty(sb->u.ext2_sb.s_sbh, 1);
1285 }
1286 }
1287-#endif
1288
1289 /* From SUS: We must generate a SIGXFSZ for file size overflow
1290 * only if no bytes were actually written to the file. --sct */
1291
1292 limit = current->rlim[RLIMIT_FSIZE].rlim_cur;
1293- if (limit < RLIM_INFINITY) {
1294- if (((size_t) pos+count) >= limit) {
1295- count = limit - pos;
1296- if (((ssize_t) count) <= 0) {
1297- send_sig(SIGXFSZ, current, 0);
1298- return -EFBIG;
1299- }
1300+ if (limit != RLIM_INFINITY) {
1301+ if (pos >= limit) {
1302+ send_sig(SIGXFSZ, current, 0);
1303+ return -EFBIG;
1304 }
1305+ if (pos+count > limit)
1306+ count = limit - pos;
1307 }
1308
1309 /*
1310@@ -382,15 +358,3 @@
1311 return 0;
1312 }
1313
1314-#if BITS_PER_LONG < 64
1315-/*
1316- * Called when an inode is about to be open.
1317- * We use this to disallow opening RW large files on 32bit systems.
1318- */
1319-static int ext2_open_file (struct inode * inode, struct file * filp)
1320-{
1321- if (inode->u.ext2_i.i_high_size && (filp->f_mode & FMODE_WRITE))
1322- return -EFBIG;
1323- return 0;
1324-}
1325-#endif
1326diff -urN lfs-ref/fs/ext2/inode.c lfs/fs/ext2/inode.c
1327--- lfs-ref/fs/ext2/inode.c Wed Sep 12 02:39:57 2001
1328+++ lfs/fs/ext2/inode.c Wed Sep 12 02:42:15 2001
1329@@ -537,15 +537,8 @@
1330 inode->u.ext2_i.i_dir_acl = le32_to_cpu(raw_inode->i_dir_acl);
1331 else {
1332 inode->u.ext2_i.i_dir_acl = 0;
1333- inode->u.ext2_i.i_high_size =
1334- le32_to_cpu(raw_inode->i_size_high);
1335-#if BITS_PER_LONG < 64
1336- if (raw_inode->i_size_high)
1337- inode->i_size = (__u32)-1;
1338-#else
1339- inode->i_size |= ((__u64)le32_to_cpu(raw_inode->i_size_high))
1340- << 32;
1341-#endif
1342+ inode->i_size = ((__u64)(inode->i_size & 0xFFFFFFFFUL)) |
1343+ (((__u64)le32_to_cpu(raw_inode->i_size_high)) << 32);
1344 }
1345 inode->u.ext2_i.i_block_group = block_group;
1346 inode->u.ext2_i.i_next_alloc_block = 0;
1347@@ -667,12 +660,7 @@
1348 if (S_ISDIR(inode->i_mode))
1349 raw_inode->i_dir_acl = cpu_to_le32(inode->u.ext2_i.i_dir_acl);
1350 else {
1351-#if BITS_PER_LONG < 64
1352- raw_inode->i_size_high =
1353- cpu_to_le32(inode->u.ext2_i.i_high_size);
1354-#else
1355 raw_inode->i_size_high = cpu_to_le32(inode->i_size >> 32);
1356-#endif
1357 }
1358 if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
1359 raw_inode->i_block[0] = cpu_to_le32(kdev_t_to_nr(inode->i_rdev));
1360@@ -724,21 +712,18 @@
1361 }
1362
1363 if (iattr->ia_valid & ATTR_SIZE) {
1364- off_t size = iattr->ia_size;
1365+ loff_t size = iattr->ia_size;
1366 unsigned long limit = current->rlim[RLIMIT_FSIZE].rlim_cur;
1367
1368 if (size < 0)
1369 return -EINVAL;
1370-#if BITS_PER_LONG == 64
1371 if (size > ext2_max_sizes[EXT2_BLOCK_SIZE_BITS(inode->i_sb)])
1372 return -EFBIG;
1373-#endif
1374- if (limit < RLIM_INFINITY && size > limit) {
1375+ if (limit != RLIM_INFINITY && size > limit) {
1376 send_sig(SIGXFSZ, current, 0);
1377 return -EFBIG;
1378 }
1379
1380-#if BITS_PER_LONG == 64
1381 if (size >> 31) {
1382 struct super_block *sb = inode->i_sb;
1383 struct ext2_super_block *es = sb->u.ext2_sb.s_es;
1384@@ -751,7 +736,6 @@
1385 mark_buffer_dirty(sb->u.ext2_sb.s_sbh, 1);
1386 }
1387 }
1388-#endif
1389 }
1390
1391 retval = inode_change_ok(inode, iattr);
1392diff -urN lfs-ref/fs/ext2/truncate.c lfs/fs/ext2/truncate.c
1393--- lfs-ref/fs/ext2/truncate.c Mon Dec 11 16:58:00 2000
1394+++ lfs/fs/ext2/truncate.c Wed Sep 12 02:42:15 2001
1395@@ -53,9 +53,10 @@
1396 * Currently we always hold the inode semaphore during truncate, so
1397 * there's no need to test for changes during the operation.
1398 */
1399-#define DIRECT_BLOCK(inode) \
1400- ((inode->i_size + inode->i_sb->s_blocksize - 1) / \
1401- inode->i_sb->s_blocksize)
1402+#define DIRECT_BLOCK(inode) \
1403+ ((long) \
1404+ ((inode->i_size + inode->i_sb->s_blocksize - 1) >> \
1405+ inode->i_sb->s_blocksize_bits))
1406 #define INDIRECT_BLOCK(inode,offset) ((int)DIRECT_BLOCK(inode) - offset)
1407 #define DINDIRECT_BLOCK(inode,offset) \
1408 (INDIRECT_BLOCK(inode,offset) / addr_per_block)
1409diff -urN lfs-ref/fs/fat/dir.c lfs/fs/fat/dir.c
1410--- lfs-ref/fs/fat/dir.c Mon Dec 11 16:58:00 2000
1411+++ lfs/fs/fat/dir.c Wed Sep 12 02:42:15 2001
1412@@ -315,7 +315,7 @@
1413 /* Fake . and .. for the root directory. */
1414 if (inode->i_ino == MSDOS_ROOT_INO) {
1415 while (cpos < 2) {
1416- if (filldir(dirent, "..", cpos+1, cpos, MSDOS_ROOT_INO) < 0)
1417+ if (filldir(dirent, "..", cpos+1, cpos, MSDOS_ROOT_INO, DT_DIR) < 0)
1418 return 0;
1419 cpos++;
1420 filp->f_pos++;
1421@@ -458,7 +458,8 @@
1422 if (!long_slots||shortnames) {
1423 if (both)
1424 bufname[i] = '\0';
1425- if (filldir(dirent, bufname, i, *furrfu, inum) < 0)
1426+ if (filldir(dirent, bufname, i, *furrfu, inum,
1427+ (de->attr & ATTR_DIR) ? DT_DIR : DT_REG) < 0)
1428 goto FillFailed;
1429 } else {
1430 char longname[275];
1431@@ -469,7 +470,8 @@
1432 memcpy(&longname[long_len+1], bufname, i);
1433 long_len += i;
1434 }
1435- if (filldir(dirent, longname, long_len, *furrfu, inum) < 0)
1436+ if (filldir(dirent, longname, long_len, *furrfu, inum,
1437+ (de->attr & ATTR_DIR) ? DT_DIR : DT_REG) < 0)
1438 goto FillFailed;
1439 }
1440
1441@@ -499,7 +501,8 @@
1442 const char * name,
1443 int name_len,
1444 off_t offset,
1445- ino_t ino)
1446+ ino_t ino,
1447+ unsigned int d_type)
1448 {
1449 struct dirent *d1 = (struct dirent *)buf;
1450 struct dirent *d2 = d1 + 1;
1451diff -urN lfs-ref/fs/fat/file.c lfs/fs/fat/file.c
1452--- lfs-ref/fs/fat/file.c Mon Jan 17 16:44:42 2000
1453+++ lfs/fs/fat/file.c Wed Sep 12 02:42:15 2001
1454@@ -227,7 +227,7 @@
1455 Each time we process one block in bhlist, we replace
1456 it by a new prefetch block if needed.
1457 */
1458- PRINTK (("#### ino %ld pos %ld size %ld count %d\n",inode->i_ino,*ppos,inode->i_size,count));
1459+ PRINTK (("#### ino %ld pos %ld size %ld count %d\n",inode->i_ino,*ppos,(u_long)inode->i_size,count));
1460 {
1461 /*
1462 We must prefetch complete block, so we must
1463@@ -253,7 +253,7 @@
1464 }
1465 pre.nolist = 0;
1466 PRINTK (("count %d ahead %d nblist %d\n",count,read_ahead[MAJOR(inode->i_dev)],pre.nblist));
1467- while ((left_in_file = inode->i_size - *ppos) > 0
1468+ while ((left_in_file = (u_long)inode->i_size - *ppos) > 0
1469 && buf < end){
1470 struct buffer_head *bh = pre.bhlist[pre.nolist];
1471 char *data;
1472@@ -451,7 +451,7 @@
1473
1474 void fat_truncate(struct inode *inode)
1475 {
1476- int cluster;
1477+ int cluster_bytes, cluster_shift;
1478
1479 /* Why no return value? Surely the disk could fail... */
1480 if (IS_IMMUTABLE(inode))
1481@@ -460,8 +460,10 @@
1482 printk("FAT: fat_truncate called though fs is read-only, uhh...\n");
1483 return /* -EROFS */;
1484 }
1485- cluster = SECTOR_SIZE*MSDOS_SB(inode->i_sb)->cluster_size;
1486- (void) fat_free(inode,(inode->i_size+(cluster-1))/cluster);
1487+ cluster_bytes = SECTOR_SIZE * MSDOS_SB(inode->i_sb)->cluster_size;
1488+ cluster_shift = fslog2(cluster_bytes);
1489+ (void) fat_free(inode,
1490+ (inode->i_size+(cluster_bytes-1)) >> cluster_shift);
1491 MSDOS_I(inode)->i_attrs |= ATTR_ARCH;
1492 mark_inode_dirty(inode);
1493 }
1494diff -urN lfs-ref/fs/fat/inode.c lfs/fs/fat/inode.c
1495--- lfs-ref/fs/fat/inode.c Mon Dec 11 16:58:00 2000
1496+++ lfs/fs/fat/inode.c Wed Sep 12 02:42:15 2001
1497@@ -399,8 +399,9 @@
1498 sizeof(struct msdos_dir_entry);
1499 }
1500 inode->i_blksize = MSDOS_SB(sb)->cluster_size* SECTOR_SIZE;
1501- inode->i_blocks = (inode->i_size+inode->i_blksize-1)/
1502- inode->i_blksize*MSDOS_SB(sb)->cluster_size;
1503+ inode->i_blocks = (((inode->i_size+inode->i_blksize-1) >>
1504+ fslog2(inode->i_blksize)) *
1505+ MSDOS_SB(sb)->cluster_size);
1506 MSDOS_I(inode)->i_logstart = 0;
1507
1508 MSDOS_I(inode)->i_attrs = 0;
1509@@ -830,8 +831,9 @@
1510 MSDOS_I(inode)->i_attrs = de->attr & ATTR_UNUSED;
1511 /* this is as close to the truth as we can get ... */
1512 inode->i_blksize = MSDOS_SB(sb)->cluster_size*SECTOR_SIZE;
1513- inode->i_blocks = (inode->i_size+inode->i_blksize-1)/
1514- inode->i_blksize*MSDOS_SB(sb)->cluster_size;
1515+ inode->i_blocks = (((inode->i_size+inode->i_blksize-1) >>
1516+ fslog2(inode->i_blksize)) *
1517+ MSDOS_SB(sb)->cluster_size);
1518 inode->i_mtime = inode->i_atime =
1519 date_dos2unix(CF_LE_W(de->time),CF_LE_W(de->date));
1520 inode->i_ctime =
1521diff -urN lfs-ref/fs/fcntl.c lfs/fs/fcntl.c
1522--- lfs-ref/fs/fcntl.c Wed Sep 12 02:39:56 2001
1523+++ lfs/fs/fcntl.c Wed Sep 12 02:42:15 2001
1524@@ -145,17 +145,11 @@
1525 return 0;
1526 }
1527
1528-asmlinkage long sys_fcntl(unsigned int fd, unsigned int cmd, unsigned long arg)
1529-{
1530- struct file * filp;
1531- long err = -EBADF;
1532-
1533- lock_kernel();
1534- filp = fget(fd);
1535- if (!filp)
1536- goto out;
1537+static long do_fcntl(unsigned int fd, unsigned int cmd,
1538+ unsigned long arg, struct file * filp)
1539+{
1540+ long err = 0;
1541
1542- err = 0;
1543 switch (cmd) {
1544 case F_DUPFD:
1545 err = dupfd(fd, arg);
1546@@ -219,11 +213,60 @@
1547 err = sock_fcntl (filp, cmd, arg);
1548 break;
1549 }
1550+
1551+ return err;
1552+}
1553+
1554+asmlinkage long sys_fcntl(unsigned int fd, unsigned int cmd, unsigned long arg)
1555+{
1556+ struct file * filp;
1557+ long err = -EBADF;
1558+
1559+ lock_kernel();
1560+ filp = fget(fd);
1561+ if (!filp)
1562+ goto out;
1563+
1564+ err = do_fcntl(fd, cmd, arg, filp);
1565+
1566+ fput(filp);
1567+out:
1568+ unlock_kernel();
1569+ return err;
1570+}
1571+
1572+#if BITS_PER_LONG == 32
1573+asmlinkage long sys_fcntl64(unsigned int fd, unsigned int cmd, unsigned long arg)
1574+{
1575+ struct file * filp;
1576+ long err = -EBADF;
1577+
1578+ lock_kernel();
1579+ filp = fget(fd);
1580+ if (!filp)
1581+ goto out;
1582+
1583+ switch (cmd) {
1584+ case F_GETLK64:
1585+ err = fcntl_getlk64(fd, (struct flock64 *) arg);
1586+ break;
1587+ case F_SETLK64:
1588+ err = fcntl_setlk64(fd, cmd, (struct flock64 *) arg);
1589+ break;
1590+ case F_SETLKW64:
1591+ err = fcntl_setlk64(fd, cmd, (struct flock64 *) arg);
1592+ break;
1593+ default:
1594+ err = do_fcntl(fd, cmd, arg, filp);
1595+ break;
1596+ }
1597+
1598 fput(filp);
1599 out:
1600 unlock_kernel();
1601 return err;
1602 }
1603+#endif
1604
1605 /* Table to convert sigio signal codes into poll band bitmaps */
1606
1607diff -urN lfs-ref/fs/hfs/dir_cap.c lfs/fs/hfs/dir_cap.c
1608--- lfs-ref/fs/hfs/dir_cap.c Mon Jan 17 16:44:42 2000
1609+++ lfs/fs/hfs/dir_cap.c Wed Sep 12 02:42:15 2001
1610@@ -243,7 +243,7 @@
1611
1612 if (filp->f_pos == 0) {
1613 /* Entry 0 is for "." */
1614- if (filldir(dirent, DOT->Name, DOT_LEN, 0, dir->i_ino)) {
1615+ if (filldir(dirent, DOT->Name, DOT_LEN, 0, dir->i_ino, DT_DIR)) {
1616 return 0;
1617 }
1618 filp->f_pos = 1;
1619@@ -260,7 +260,7 @@
1620 }
1621
1622 if (filldir(dirent, DOT_DOT->Name,
1623- DOT_DOT_LEN, 1, ntohl(cnid))) {
1624+ DOT_DOT_LEN, 1, ntohl(cnid), DT_DIR)) {
1625 return 0;
1626 }
1627 filp->f_pos = 2;
1628@@ -287,7 +287,7 @@
1629 len = hfs_namein(dir, tmp_name,
1630 &((struct hfs_cat_key *)brec.key)->CName);
1631 if (filldir(dirent, tmp_name, len,
1632- filp->f_pos, ino)) {
1633+ filp->f_pos, ino, DT_UNKNOWN)) {
1634 hfs_cat_close(entry, &brec);
1635 return 0;
1636 }
1637@@ -303,7 +303,7 @@
1638 /* In root dir last-2 entry is for ".rootinfo" */
1639 if (filldir(dirent, DOT_ROOTINFO->Name,
1640 DOT_ROOTINFO_LEN, filp->f_pos,
1641- ntohl(entry->cnid) | HFS_CAP_FNDR)) {
1642+ ntohl(entry->cnid) | HFS_CAP_FNDR, DT_UNKNOWN)) {
1643 return 0;
1644 }
1645 }
1646@@ -315,7 +315,7 @@
1647 /* In normal dirs last-1 entry is for ".finderinfo" */
1648 if (filldir(dirent, DOT_FINDERINFO->Name,
1649 DOT_FINDERINFO_LEN, filp->f_pos,
1650- ntohl(entry->cnid) | HFS_CAP_FDIR)) {
1651+ ntohl(entry->cnid) | HFS_CAP_FDIR, DT_UNKNOWN)) {
1652 return 0;
1653 }
1654 }
1655@@ -327,7 +327,7 @@
1656 /* In normal dirs last entry is for ".resource" */
1657 if (filldir(dirent, DOT_RESOURCE->Name,
1658 DOT_RESOURCE_LEN, filp->f_pos,
1659- ntohl(entry->cnid) | HFS_CAP_RDIR)) {
1660+ ntohl(entry->cnid) | HFS_CAP_RDIR, DT_UNKNOWN)) {
1661 return 0;
1662 }
1663 }
1664diff -urN lfs-ref/fs/hfs/dir_dbl.c lfs/fs/hfs/dir_dbl.c
1665--- lfs-ref/fs/hfs/dir_dbl.c Mon Jan 17 16:44:42 2000
1666+++ lfs/fs/hfs/dir_dbl.c Wed Sep 12 02:42:15 2001
1667@@ -206,7 +206,7 @@
1668
1669 if (filp->f_pos == 0) {
1670 /* Entry 0 is for "." */
1671- if (filldir(dirent, DOT->Name, DOT_LEN, 0, dir->i_ino)) {
1672+ if (filldir(dirent, DOT->Name, DOT_LEN, 0, dir->i_ino, DT_DIR)) {
1673 return 0;
1674 }
1675 filp->f_pos = 1;
1676@@ -215,7 +215,7 @@
1677 if (filp->f_pos == 1) {
1678 /* Entry 1 is for ".." */
1679 if (filldir(dirent, DOT_DOT->Name, DOT_DOT_LEN, 1,
1680- hfs_get_hl(entry->key.ParID))) {
1681+ hfs_get_hl(entry->key.ParID), DT_DIR)) {
1682 return 0;
1683 }
1684 filp->f_pos = 2;
1685@@ -252,7 +252,7 @@
1686 &((struct hfs_cat_key *)brec.key)->CName);
1687 }
1688
1689- if (filldir(dirent, tmp_name, len, filp->f_pos, ino)) {
1690+ if (filldir(dirent, tmp_name, len, filp->f_pos, ino, DT_UNKNOWN)) {
1691 hfs_cat_close(entry, &brec);
1692 return 0;
1693 }
1694@@ -266,7 +266,7 @@
1695 /* In root dir last entry is for "%RootInfo" */
1696 if (filldir(dirent, PCNT_ROOTINFO->Name,
1697 PCNT_ROOTINFO_LEN, filp->f_pos,
1698- ntohl(entry->cnid) | HFS_DBL_HDR)) {
1699+ ntohl(entry->cnid) | HFS_DBL_HDR, DT_UNKNOWN)) {
1700 return 0;
1701 }
1702 }
1703diff -urN lfs-ref/fs/hfs/dir_nat.c lfs/fs/hfs/dir_nat.c
1704--- lfs-ref/fs/hfs/dir_nat.c Mon Jan 17 16:44:42 2000
1705+++ lfs/fs/hfs/dir_nat.c Wed Sep 12 02:42:15 2001
1706@@ -231,7 +231,7 @@
1707
1708 if (filp->f_pos == 0) {
1709 /* Entry 0 is for "." */
1710- if (filldir(dirent, DOT->Name, DOT_LEN, 0, dir->i_ino)) {
1711+ if (filldir(dirent, DOT->Name, DOT_LEN, 0, dir->i_ino, DT_DIR)) {
1712 return 0;
1713 }
1714 filp->f_pos = 1;
1715@@ -248,7 +248,7 @@
1716 }
1717
1718 if (filldir(dirent, DOT_DOT->Name,
1719- DOT_DOT_LEN, 1, ntohl(cnid))) {
1720+ DOT_DOT_LEN, 1, ntohl(cnid), DT_DIR)) {
1721 return 0;
1722 }
1723 filp->f_pos = 2;
1724@@ -275,7 +275,7 @@
1725 len = hfs_namein(dir, tmp_name,
1726 &((struct hfs_cat_key *)brec.key)->CName);
1727 if (filldir(dirent, tmp_name, len,
1728- filp->f_pos, ino)) {
1729+ filp->f_pos, ino, DT_UNKNOWN)) {
1730 hfs_cat_close(entry, &brec);
1731 return 0;
1732 }
1733@@ -290,14 +290,14 @@
1734 /* In normal dirs entry 2 is for ".AppleDouble" */
1735 if (filldir(dirent, DOT_APPLEDOUBLE->Name,
1736 DOT_APPLEDOUBLE_LEN, filp->f_pos,
1737- ntohl(entry->cnid) | HFS_NAT_HDIR)) {
1738+ ntohl(entry->cnid) | HFS_NAT_HDIR, DT_UNKNOWN)) {
1739 return 0;
1740 }
1741 } else if (type == HFS_NAT_HDIR) {
1742 /* In .AppleDouble entry 2 is for ".Parent" */
1743 if (filldir(dirent, DOT_PARENT->Name,
1744 DOT_PARENT_LEN, filp->f_pos,
1745- ntohl(entry->cnid) | HFS_NAT_HDR)) {
1746+ ntohl(entry->cnid) | HFS_NAT_HDR, DT_UNKNOWN)) {
1747 return 0;
1748 }
1749 }
1750@@ -310,7 +310,7 @@
1751 (type == HFS_NAT_HDIR)) {
1752 if (filldir(dirent, ROOTINFO->Name,
1753 ROOTINFO_LEN, filp->f_pos,
1754- ntohl(entry->cnid) | HFS_NAT_HDR)) {
1755+ ntohl(entry->cnid) | HFS_NAT_HDR, DT_UNKNOWN)) {
1756 return 0;
1757 }
1758 }
1759diff -urN lfs-ref/fs/hpfs/hpfs_fs.c lfs/fs/hpfs/hpfs_fs.c
1760--- lfs-ref/fs/hpfs/hpfs_fs.c Mon Jan 17 16:44:42 2000
1761+++ lfs/fs/hpfs/hpfs_fs.c Wed Sep 12 02:42:15 2001
1762@@ -1376,13 +1376,13 @@
1763 break;
1764
1765 case 0:
1766- if (filldir(dirent, ".", 1, filp->f_pos, inode->i_ino) < 0)
1767+ if (filldir(dirent, ".", 1, filp->f_pos, inode->i_ino, DT_DIR) < 0)
1768 break;
1769 filp->f_pos = -1;
1770 /* fall through */
1771
1772 case -1:
1773- if (filldir(dirent, "..", 2, filp->f_pos, inode->i_hpfs_parent_dir) < 0)
1774+ if (filldir(dirent, "..", 2, filp->f_pos, inode->i_hpfs_parent_dir, DT_DIR) < 0)
1775 break;
1776 filp->f_pos = 1;
1777 /* fall through */
1778@@ -1402,7 +1402,7 @@
1779 else
1780 ino = file_ino(de->fnode);
1781 brelse4(&qbh);
1782- if (filldir(dirent, tempname, namelen, old_pos, ino) < 0) {
1783+ if (filldir(dirent, tempname, namelen, old_pos, ino, DT_UNKNOWN) < 0) {
1784 filp->f_pos = old_pos;
1785 break;
1786 }
1787diff -urN lfs-ref/fs/isofs/dir.c lfs/fs/isofs/dir.c
1788--- lfs-ref/fs/isofs/dir.c Fri Apr 20 22:31:20 2001
1789+++ lfs/fs/isofs/dir.c Wed Sep 12 02:42:15 2001
1790@@ -206,7 +206,7 @@
1791
1792 /* Handle the case of the '.' directory */
1793 if (de->name_len[0] == 1 && de->name[0] == 0) {
1794- if (filldir(dirent, ".", 1, filp->f_pos, inode->i_ino) < 0)
1795+ if (filldir(dirent, ".", 1, filp->f_pos, inode->i_ino, DT_DIR) < 0)
1796 break;
1797 filp->f_pos += de_len;
1798 continue;
1799@@ -217,7 +217,7 @@
1800 /* Handle the case of the '..' directory */
1801 if (de->name_len[0] == 1 && de->name[0] == 1) {
1802 inode_number = filp->f_dentry->d_parent->d_inode->i_ino;
1803- if (filldir(dirent, "..", 2, filp->f_pos, inode_number) < 0)
1804+ if (filldir(dirent, "..", 2, filp->f_pos, inode_number, DT_DIR) < 0)
1805 break;
1806 filp->f_pos += de_len;
1807 continue;
1808@@ -261,7 +261,7 @@
1809 }
1810 }
1811 if (len > 0) {
1812- if (filldir(dirent, p, len, filp->f_pos, inode_number) < 0)
1813+ if (filldir(dirent, p, len, filp->f_pos, inode_number, DT_UNKNOWN) < 0)
1814 break;
1815 }
1816 filp->f_pos += de_len;
1817diff -urN lfs-ref/fs/isofs/inode.c lfs/fs/isofs/inode.c
1818--- lfs-ref/fs/isofs/inode.c Fri Apr 20 22:31:20 2001
1819+++ lfs/fs/isofs/inode.c Wed Sep 12 02:42:15 2001
1820@@ -908,7 +908,8 @@
1821
1822 int isofs_bmap(struct inode * inode,int block)
1823 {
1824- off_t b_off, offset, size;
1825+ loff_t b_off;
1826+ unsigned offset, size;
1827 struct inode *ino;
1828 unsigned int firstext;
1829 unsigned long nextino;
1830@@ -919,7 +920,7 @@
1831 return 0;
1832 }
1833
1834- b_off = block << ISOFS_BUFFER_BITS(inode);
1835+ b_off = (loff_t)block << ISOFS_BUFFER_BITS(inode);
1836
1837 /*
1838 * If we are beyond the end of this file, don't give out any
1839@@ -927,7 +928,7 @@
1840 */
1841 if( b_off >= inode->i_size )
1842 {
1843- off_t max_legal_read_offset;
1844+ loff_t max_legal_read_offset;
1845
1846 /*
1847 * If we are *way* beyond the end of the file, print a message.
1848@@ -942,7 +943,7 @@
1849 if( b_off >= max_legal_read_offset )
1850 {
1851
1852- printk("_isofs_bmap: block>= EOF(%d, %ld)\n", block,
1853+ printk("_isofs_bmap: block>= EOF(%d, %Ld)\n", block,
1854 inode->i_size);
1855 }
1856 return 0;
1857@@ -1209,7 +1210,7 @@
1858
1859 #ifdef DEBUG
1860 printk("Get inode %x: %d %d: %d\n",inode->i_ino, block,
1861- ((int)pnt) & 0x3ff, inode->i_size);
1862+ ((int)pnt) & 0x3ff, (u_long)inode->i_size);
1863 #endif
1864
1865 inode->i_mtime = inode->i_atime = inode->i_ctime =
1866diff -urN lfs-ref/fs/lockd/svclock.c lfs/fs/lockd/svclock.c
1867--- lfs-ref/fs/lockd/svclock.c Fri Apr 20 22:31:20 2001
1868+++ lfs/fs/lockd/svclock.c Wed Sep 12 02:42:15 2001
1869@@ -100,14 +100,18 @@
1870 struct nlm_block **head, *block;
1871 struct file_lock *fl;
1872
1873- dprintk("lockd: nlmsvc_lookup_block f=%p pd=%d %ld-%ld ty=%d\n",
1874- file, lock->fl.fl_pid, lock->fl.fl_start,
1875- lock->fl.fl_end, lock->fl.fl_type);
1876+ dprintk("lockd: nlmsvc_lookup_block f=%p pd=%d %Ld-%Ld ty=%d\n",
1877+ file, lock->fl.fl_pid,
1878+ (long long)lock->fl.fl_start,
1879+ (long long)lock->fl.fl_end,
1880+ lock->fl.fl_type);
1881 for (head = &nlm_blocked; (block = *head); head = &block->b_next) {
1882 fl = &block->b_call.a_args.lock.fl;
1883- dprintk("lockd: check f=%p pd=%d %ld-%ld ty=%d cookie=%x\n",
1884- block->b_file, fl->fl_pid, fl->fl_start,
1885- fl->fl_end, fl->fl_type,
1886+ dprintk("lockd: check f=%p pd=%d %Ld-%Ld ty=%d cookie=%x\n",
1887+ block->b_file, fl->fl_pid,
1888+ (long long)lock->fl.fl_start,
1889+ (long long)lock->fl.fl_end,
1890+ fl->fl_type,
1891 *(u32 *)(&block->b_call.a_args.cookie.data));
1892 if (block->b_file == file && nlm_compare_locks(fl, &lock->fl)) {
1893 if (remove)
1894@@ -293,12 +297,12 @@
1895 struct inode *inode = file->f_file.f_dentry->d_inode;
1896 int error;
1897
1898- dprintk("lockd: nlmsvc_lock(%04x/%ld, ty=%d, pi=%d, %ld-%ld, bl=%d)\n",
1899+ dprintk("lockd: nlmsvc_lock(%04x/%ld, ty=%d, pi=%d, %Ld-%Ld, bl=%d)\n",
1900 file->f_file.f_dentry->d_inode->i_dev,
1901 file->f_file.f_dentry->d_inode->i_ino,
1902 lock->fl.fl_type, lock->fl.fl_pid,
1903- lock->fl.fl_start,
1904- lock->fl.fl_end,
1905+ (long long)lock->fl.fl_start,
1906+ (long long)lock->fl.fl_end,
1907 wait);
1908
1909 /* Checking for read only file system */
1910@@ -371,16 +375,18 @@
1911 {
1912 struct file_lock *fl;
1913
1914- dprintk("lockd: nlmsvc_testlock(%04x/%ld, ty=%d, %ld-%ld)\n",
1915+ dprintk("lockd: nlmsvc_testlock(%04x/%ld, ty=%d, %Ld-%Ld)\n",
1916 file->f_file.f_dentry->d_inode->i_dev,
1917 file->f_file.f_dentry->d_inode->i_ino,
1918 lock->fl.fl_type,
1919- lock->fl.fl_start,
1920- lock->fl.fl_end);
1921+ (long long)lock->fl.fl_start,
1922+ (long long)lock->fl.fl_end);
1923
1924 if ((fl = posix_test_lock(&file->f_file, &lock->fl)) != NULL) {
1925- dprintk("lockd: conflicting lock(ty=%d, %ld-%ld)\n",
1926- fl->fl_type, fl->fl_start, fl->fl_end );
1927+ dprintk("lockd: conflicting lock(ty=%d, %Ld-%Ld)\n",
1928+ fl->fl_type,
1929+ (long long)lock->fl.fl_start,
1930+ (long long)lock->fl.fl_end);
1931
1932 conflock->caller = "somehost"; /* FIXME */
1933 conflock->oh.len = 0; /* don't return OH info */
1934@@ -403,12 +409,12 @@
1935 {
1936 int error;
1937
1938- dprintk("lockd: nlmsvc_unlock(%04x/%ld, pi=%d, %ld-%ld)\n",
1939+ dprintk("lockd: nlmsvc_unlock(%04x/%ld, pi=%d, %Ld-%Ld)\n",
1940 file->f_file.f_dentry->d_inode->i_dev,
1941 file->f_file.f_dentry->d_inode->i_ino,
1942 lock->fl.fl_pid,
1943- lock->fl.fl_start,
1944- lock->fl.fl_end);
1945+ (long long)lock->fl.fl_start,
1946+ (long long)lock->fl.fl_end);
1947
1948 /* First, cancel any lock that might be there */
1949 nlmsvc_cancel_blocked(file, lock);
1950@@ -431,12 +437,12 @@
1951 {
1952 struct nlm_block *block;
1953
1954- dprintk("lockd: nlmsvc_cancel(%04x/%ld, pi=%d, %ld-%ld)\n",
1955+ dprintk("lockd: nlmsvc_cancel(%04x/%ld, pi=%d, %Ld-%Ld)\n",
1956 file->f_file.f_dentry->d_inode->i_dev,
1957 file->f_file.f_dentry->d_inode->i_ino,
1958 lock->fl.fl_pid,
1959- lock->fl.fl_start,
1960- lock->fl.fl_end);
1961+ (long long)lock->fl.fl_start,
1962+ (long long)lock->fl.fl_end);
1963
1964 down(&file->f_sema);
1965 if ((block = nlmsvc_lookup_block(file, lock, 1)) != NULL)
1966diff -urN lfs-ref/fs/lockd/xdr.c lfs/fs/lockd/xdr.c
1967--- lfs-ref/fs/lockd/xdr.c Mon Dec 11 16:58:00 2000
1968+++ lfs/fs/lockd/xdr.c Wed Sep 12 02:42:15 2001
1969@@ -24,7 +24,6 @@
1970
1971 #define NLMDBG_FACILITY NLMDBG_XDR
1972 #define NLM_MAXSTRLEN 1024
1973-#define OFFSET_MAX LONG_MAX
1974
1975 #define QUADLEN(len) (((len) + 3) >> 2)
1976
1977@@ -37,6 +36,25 @@
1978 static void nlm_register_stats(void);
1979 static void nlm_unregister_stats(void);
1980
1981+static inline loff_t
1982+s32_to_loff_t(__s32 offset)
1983+{
1984+ return (loff_t)offset;
1985+}
1986+
1987+static inline __s32
1988+loff_t_to_s32(loff_t offset)
1989+{
1990+ __s32 res;
1991+ if (offset >= NLM_OFFSET_MAX)
1992+ res = NLM_OFFSET_MAX;
1993+ else if (offset <= -NLM_OFFSET_MAX)
1994+ res = -NLM_OFFSET_MAX;
1995+ else
1996+ res = offset;
1997+ return res;
1998+}
1999+
2000 /*
2001 * Initialization of NFS status variables
2002 */
2003@@ -157,7 +175,7 @@
2004 nlm_decode_lock(u32 *p, struct nlm_lock *lock)
2005 {
2006 struct file_lock *fl = &lock->fl;
2007- int len;
2008+ s32 start, len, end;
2009
2010 if (!(p = xdr_decode_string(p, &lock->caller, &len, NLM_MAXSTRLEN))
2011 || !(p = nlm_decode_fh(p, &lock->fh))
2012@@ -169,10 +187,16 @@
2013 fl->fl_pid = ntohl(*p++);
2014 fl->fl_flags = FL_POSIX;
2015 fl->fl_type = F_RDLCK; /* as good as anything else */
2016- fl->fl_start = ntohl(*p++);
2017+ start = ntohl(*p++);
2018 len = ntohl(*p++);
2019- if (len == 0 || (fl->fl_end = fl->fl_start + len - 1) < 0)
2020+ end = start + len - 1;
2021+
2022+ fl->fl_start = s32_to_loff_t(start);
2023+
2024+ if (len == 0 || end < 0)
2025 fl->fl_end = OFFSET_MAX;
2026+ else
2027+ fl->fl_end = s32_to_loff_t(end);
2028 return p;
2029 }
2030
2031@@ -183,6 +207,7 @@
2032 nlm_encode_lock(u32 *p, struct nlm_lock *lock)
2033 {
2034 struct file_lock *fl = &lock->fl;
2035+ __s32 start, len;
2036
2037 if (!(p = xdr_encode_string(p, lock->caller, -1))
2038 || !(p = nlm_encode_fh(p, &lock->fh))
2039@@ -193,12 +218,15 @@
2040 || (fl->fl_end > NLM_OFFSET_MAX && fl->fl_end != OFFSET_MAX))
2041 return NULL;
2042
2043- *p++ = htonl(fl->fl_pid);
2044- *p++ = htonl(fl->fl_start);
2045+ start = loff_t_to_s32(fl->fl_start);
2046 if (fl->fl_end == OFFSET_MAX)
2047- *p++ = xdr_zero;
2048+ len = 0;
2049 else
2050- *p++ = htonl(fl->fl_end - fl->fl_start + 1);
2051+ len = loff_t_to_s32(fl->fl_end - fl->fl_start + 1);
2052+
2053+ *p++ = htonl(fl->fl_pid);
2054+ *p++ = htonl(start);
2055+ *p++ = htonl(len);
2056
2057 return p;
2058 }
2059@@ -209,6 +237,8 @@
2060 static u32 *
2061 nlm_encode_testres(u32 *p, struct nlm_res *resp)
2062 {
2063+ s32 start, len;
2064+
2065 if (!(p = nlm_encode_cookie(p, &resp->cookie)))
2066 return 0;
2067 *p++ = resp->status;
2068@@ -223,11 +253,14 @@
2069 if (!(p = xdr_encode_netobj(p, &resp->lock.oh)))
2070 return 0;
2071
2072- *p++ = htonl(fl->fl_start);
2073+ start = loff_t_to_s32(fl->fl_start);
2074 if (fl->fl_end == OFFSET_MAX)
2075- *p++ = xdr_zero;
2076+ len = xdr_zero;
2077 else
2078- *p++ = htonl(fl->fl_end - fl->fl_start + 1);
2079+ len = loff_t_to_s32(fl->fl_end - fl->fl_start + 1);
2080+
2081+ *p++ = htonl(start);
2082+ *p++ = htonl(len);
2083 }
2084
2085 return p;
2086@@ -446,7 +479,8 @@
2087 resp->status = ntohl(*p++);
2088 if (resp->status == NLM_LCK_DENIED) {
2089 struct file_lock *fl = &resp->lock.fl;
2090- u32 excl, len;
2091+ u32 excl;
2092+ s32 start, len, end;
2093
2094 memset(&resp->lock, 0, sizeof(resp->lock));
2095 excl = ntohl(*p++);
2096@@ -456,10 +490,15 @@
2097
2098 fl->fl_flags = FL_POSIX;
2099 fl->fl_type = excl? F_WRLCK : F_RDLCK;
2100- fl->fl_start = ntohl(*p++);
2101+ start = ntohl(*p++);
2102 len = ntohl(*p++);
2103- if (len == 0 || (fl->fl_end = fl->fl_start + len - 1) < 0)
2104+ end = start + len - 1;
2105+
2106+ fl->fl_start = s32_to_loff_t(start);
2107+ if (len == 0 || end < 0)
2108 fl->fl_end = OFFSET_MAX;
2109+ else
2110+ fl->fl_end = s32_to_loff_t(end);
2111 }
2112 return 0;
2113 }
2114diff -urN lfs-ref/fs/lockd/xdr4.c lfs/fs/lockd/xdr4.c
2115--- lfs-ref/fs/lockd/xdr4.c Mon Dec 11 16:58:00 2000
2116+++ lfs/fs/lockd/xdr4.c Wed Sep 12 02:42:15 2001
2117@@ -23,7 +23,6 @@
2118
2119 #define NLMDBG_FACILITY NLMDBG_XDR
2120 #define NLM_MAXSTRLEN 1024
2121-#define OFFSET_MAX ((off_t)LONG_MAX)
2122
2123 #define QUADLEN(len) (((len) + 3) >> 2)
2124
2125@@ -34,11 +33,23 @@
2126
2127 typedef struct nlm_args nlm_args;
2128
2129-static inline off_t
2130-size_to_off_t(__s64 size)
2131+static inline loff_t
2132+s64_to_loff_t(__s64 offset)
2133 {
2134- size = (size > (__s64)LONG_MAX) ? (off_t)LONG_MAX : (off_t) size;
2135- return (size < (__s64)-LONG_MAX) ? (off_t)-LONG_MAX : (off_t) size;
2136+ return (loff_t)offset;
2137+}
2138+
2139+static inline s64
2140+loff_t_to_s64(loff_t offset)
2141+{
2142+ s64 res;
2143+ if (offset > NLM4_OFFSET_MAX)
2144+ res = NLM4_OFFSET_MAX;
2145+ else if (offset < -NLM4_OFFSET_MAX)
2146+ res = -NLM4_OFFSET_MAX;
2147+ else
2148+ res = offset;
2149+ return res;
2150 }
2151
2152 /*
2153@@ -139,11 +150,12 @@
2154 p = xdr_decode_hyper(p, &len);
2155 end = start + len - 1;
2156
2157- fl->fl_start = size_to_off_t(start);
2158- fl->fl_end = size_to_off_t(end);
2159+ fl->fl_start = s64_to_loff_t(start);
2160
2161- if (len == 0 || fl->fl_end < 0)
2162+ if (len == 0 || end < 0)
2163 fl->fl_end = OFFSET_MAX;
2164+ else
2165+ fl->fl_end = s64_to_loff_t(end);
2166 return p;
2167 }
2168
2169@@ -154,18 +166,26 @@
2170 nlm4_encode_lock(u32 *p, struct nlm_lock *lock)
2171 {
2172 struct file_lock *fl = &lock->fl;
2173+ __s64 start, len;
2174
2175 if (!(p = xdr_encode_string(p, lock->caller, -1))
2176 || !(p = nlm4_encode_fh(p, &lock->fh))
2177 || !(p = nlm4_encode_oh(p, &lock->oh)))
2178 return NULL;
2179
2180- *p++ = htonl(fl->fl_pid);
2181- p = xdr_encode_hyper(p, fl->fl_start);
2182+ if (fl->fl_start > NLM4_OFFSET_MAX
2183+ || (fl->fl_end > NLM4_OFFSET_MAX && fl->fl_end != OFFSET_MAX))
2184+ return NULL;
2185+
2186+ start = loff_t_to_s64(fl->fl_start);
2187 if (fl->fl_end == OFFSET_MAX)
2188- p = xdr_encode_hyper(p, 0);
2189+ len = 0;
2190 else
2191- p = xdr_encode_hyper(p, fl->fl_end - fl->fl_start + 1);
2192+ len = loff_t_to_s64(fl->fl_end - fl->fl_start + 1);
2193+
2194+ *p++ = htonl(fl->fl_pid);
2195+ p = xdr_encode_hyper(p, start);
2196+ p = xdr_encode_hyper(p, len);
2197
2198 return p;
2199 }
2200@@ -176,6 +196,7 @@
2201 static u32 *
2202 nlm4_encode_testres(u32 *p, struct nlm_res *resp)
2203 {
2204+ s64 start, len;
2205
2206 dprintk("xdr: before encode_testres (p %p resp %p)\n", p, resp);
2207 if (!(p = nlm4_encode_cookie(p, &resp->cookie)))
2208@@ -192,14 +213,17 @@
2209 if (!(p = xdr_encode_netobj(p, &resp->lock.oh)))
2210 return 0;
2211
2212- p = xdr_encode_hyper(p, fl->fl_start);
2213+ start = loff_t_to_s64(fl->fl_start);
2214 if (fl->fl_end == OFFSET_MAX)
2215- p = xdr_encode_hyper(p, 0);
2216+ len = 0;
2217 else
2218- p = xdr_encode_hyper(p, fl->fl_end - fl->fl_start + 1);
2219- dprintk("xdr: encode_testres (status %d pid %d type %d start %ld end %ld)\n", resp->status, fl->fl_pid, fl->fl_type, fl->fl_start, fl->fl_end);
2220-
2221-
2222+ len = loff_t_to_s64(fl->fl_end - fl->fl_start + 1);
2223+
2224+ p = xdr_encode_hyper(p, start);
2225+ p = xdr_encode_hyper(p, len);
2226+ dprintk("xdr: encode_testres (status %d pid %d type %d start %Ld end %Ld)\n",
2227+ resp->status, fl->fl_pid, fl->fl_type,
2228+ fl->fl_start, fl->fl_end);
2229 }
2230
2231 dprintk("xdr: after encode_testres (p %p resp %p)\n", p, resp);
2232@@ -435,10 +459,11 @@
2233 p = xdr_decode_hyper(p, &len);
2234 end = start + len - 1;
2235
2236- fl->fl_start = size_to_off_t(start);
2237- fl->fl_end = size_to_off_t(end);
2238- if (len == 0 || fl->fl_end < 0)
2239+ fl->fl_start = s64_to_loff_t(start);
2240+ if (len == 0 || end < 0)
2241 fl->fl_end = OFFSET_MAX;
2242+ else
2243+ fl->fl_end = s64_to_loff_t(end);
2244 }
2245 return 0;
2246 }
2247diff -urN lfs-ref/fs/locks.c lfs/fs/locks.c
2248--- lfs-ref/fs/locks.c Wed Sep 12 02:05:57 2001
2249+++ lfs/fs/locks.c Wed Sep 12 02:42:15 2001
2250@@ -111,12 +111,12 @@
2251
2252 #include <asm/uaccess.h>
2253
2254-#define OFFSET_MAX ((off_t)LONG_MAX) /* FIXME: move elsewhere? */
2255-
2256 static int flock_make_lock(struct file *filp, struct file_lock *fl,
2257 unsigned int cmd);
2258-static int posix_make_lock(struct file *filp, struct file_lock *fl,
2259+static int flock_to_posix_lock(struct file *filp, struct file_lock *fl,
2260 struct flock *l);
2261+static int flock64_to_posix_lock(struct file *filp, struct file_lock *fl,
2262+ struct flock64 *l);
2263 static int flock_locks_conflict(struct file_lock *caller_fl,
2264 struct file_lock *sys_fl);
2265 static int posix_locks_conflict(struct file_lock *caller_fl,
2266@@ -195,7 +195,7 @@
2267
2268 if (waiter->fl_prevblock) {
2269 printk(KERN_ERR "locks_insert_block: remove duplicated lock "
2270- "(pid=%d %ld-%ld type=%d)\n",
2271+ "(pid=%d %Ld-%Ld type=%d)\n",
2272 waiter->fl_pid, waiter->fl_start,
2273 waiter->fl_end, waiter->fl_type);
2274 locks_delete_block(waiter->fl_prevblock, waiter);
2275@@ -344,9 +344,10 @@
2276 if (!filp->f_dentry || !filp->f_dentry->d_inode || !filp->f_op)
2277 goto out_putf;
2278
2279- if (!posix_make_lock(filp, &file_lock, &flock))
2280+ if ((error = flock_to_posix_lock(filp, &file_lock, &flock)))
2281 goto out_putf;
2282
2283+ error = -EINVAL;
2284 if (filp->f_op->lock) {
2285 error = filp->f_op->lock(filp, F_GETLK, &file_lock);
2286 if (error < 0)
2287@@ -363,6 +364,18 @@
2288 flock.l_type = F_UNLCK;
2289 if (fl != NULL) {
2290 flock.l_pid = fl->fl_pid;
2291+#if BITS_PER_LONG == 32
2292+ /*
2293+ * Make sure we can represent the posix lock via
2294+ * legacy 32bit flock.
2295+ */
2296+ error = -EOVERFLOW;
2297+ if (fl->fl_start > OFFT_OFFSET_MAX)
2298+ goto out_putf;
2299+ if ((fl->fl_end != OFFSET_MAX)
2300+ && (fl->fl_end > OFFT_OFFSET_MAX))
2301+ goto out_putf;
2302+#endif
2303 flock.l_start = fl->fl_start;
2304 flock.l_len = fl->fl_end == OFFSET_MAX ? 0 :
2305 fl->fl_end - fl->fl_start + 1;
2306@@ -424,8 +437,7 @@
2307 goto out_putf;
2308 }
2309
2310- error = -EINVAL;
2311- if (!posix_make_lock(filp, &file_lock, &flock))
2312+ if ((error = flock_to_posix_lock(filp, &file_lock, &flock)))
2313 goto out_putf;
2314
2315 error = -EBADF;
2316@@ -475,6 +487,169 @@
2317 return error;
2318 }
2319
2320+#if BITS_PER_LONG == 32
2321+/* Report the first existing lock that would conflict with l.
2322+ * This implements the F_GETLK command of fcntl().
2323+ */
2324+int fcntl_getlk64(unsigned int fd, struct flock64 *l)
2325+{
2326+ struct file *filp;
2327+ struct file_lock *fl,file_lock;
2328+ struct flock64 flock;
2329+ int error;
2330+
2331+ error = -EFAULT;
2332+ if (copy_from_user(&flock, l, sizeof(flock)))
2333+ goto out;
2334+ error = -EINVAL;
2335+ if ((flock.l_type != F_RDLCK) && (flock.l_type != F_WRLCK))
2336+ goto out;
2337+
2338+ error = -EBADF;
2339+ filp = fget(fd);
2340+ if (!filp)
2341+ goto out;
2342+
2343+ error = -EINVAL;
2344+ if (!filp->f_dentry || !filp->f_dentry->d_inode || !filp->f_op)
2345+ goto out_putf;
2346+
2347+ if (!flock64_to_posix_lock(filp, &file_lock, &flock))
2348+ goto out_putf;
2349+
2350+ if (filp->f_op->lock) {
2351+ error = filp->f_op->lock(filp, F_GETLK, &file_lock);
2352+ if (error < 0)
2353+ goto out_putf;
2354+ else if (error == LOCK_USE_CLNT)
2355+ /* Bypass for NFS with no locking - 2.0.36 compat */
2356+ fl = posix_test_lock(filp, &file_lock);
2357+ else
2358+ fl = (file_lock.fl_type == F_UNLCK ? NULL : &file_lock);
2359+ } else {
2360+ fl = posix_test_lock(filp, &file_lock);
2361+ }
2362+
2363+ flock.l_type = F_UNLCK;
2364+ if (fl != NULL) {
2365+ flock.l_pid = fl->fl_pid;
2366+ flock.l_start = fl->fl_start;
2367+ flock.l_len = fl->fl_end == OFFSET_MAX ? 0 :
2368+ fl->fl_end - fl->fl_start + 1;
2369+ flock.l_whence = 0;
2370+ flock.l_type = fl->fl_type;
2371+ }
2372+ error = -EFAULT;
2373+ if (!copy_to_user(l, &flock, sizeof(flock)))
2374+ error = 0;
2375+
2376+out_putf:
2377+ fput(filp);
2378+out:
2379+ return error;
2380+}
2381+
2382+/* Apply the lock described by l to an open file descriptor.
2383+ * This implements both the F_SETLK and F_SETLKW commands of fcntl().
2384+ */
2385+int fcntl_setlk64(unsigned int fd, unsigned int cmd, struct flock64 *l)
2386+{
2387+ struct file *filp;
2388+ struct file_lock file_lock;
2389+ struct flock64 flock;
2390+ struct dentry * dentry;
2391+ struct inode *inode;
2392+ int error;
2393+
2394+ /*
2395+ * This might block, so we do it before checking the inode.
2396+ */
2397+ error = -EFAULT;
2398+ if (copy_from_user(&flock, l, sizeof(flock)))
2399+ goto out;
2400+
2401+ /* Get arguments and validate them ...
2402+ */
2403+
2404+ error = -EBADF;
2405+ filp = fget(fd);
2406+ if (!filp)
2407+ goto out;
2408+
2409+ error = -EINVAL;
2410+ if (!(dentry = filp->f_dentry))
2411+ goto out_putf;
2412+ if (!(inode = dentry->d_inode))
2413+ goto out_putf;
2414+ if (!filp->f_op)
2415+ goto out_putf;
2416+
2417+ /* Don't allow mandatory locks on files that may be memory mapped
2418+ * and shared.
2419+ */
2420+ if (IS_MANDLOCK(inode) &&
2421+ (inode->i_mode & (S_ISGID | S_IXGRP)) == S_ISGID &&
2422+ inode->i_mmap) {
2423+ struct vm_area_struct *vma = inode->i_mmap;
2424+ error = -EAGAIN;
2425+ do {
2426+ if (vma->vm_flags & VM_MAYSHARE)
2427+ goto out_putf;
2428+ } while ((vma = vma->vm_next_share) != NULL);
2429+ }
2430+
2431+ error = -EINVAL;
2432+ if (!flock64_to_posix_lock(filp, &file_lock, &flock))
2433+ goto out_putf;
2434+
2435+ error = -EBADF;
2436+ switch (flock.l_type) {
2437+ case F_RDLCK:
2438+ if (!(filp->f_mode & FMODE_READ))
2439+ goto out_putf;
2440+ break;
2441+ case F_WRLCK:
2442+ if (!(filp->f_mode & FMODE_WRITE))
2443+ goto out_putf;
2444+ break;
2445+ case F_UNLCK:
2446+ break;
2447+ case F_SHLCK:
2448+ case F_EXLCK:
2449+#ifdef __sparc__
2450+/* warn a bit for now, but don't overdo it */
2451+{
2452+ static int count = 0;
2453+ if (!count) {
2454+ count=1;
2455+ printk(KERN_WARNING
2456+ "fcntl_setlk() called by process %d (%s) with broken flock() emulation\n",
2457+ current->pid, current->comm);
2458+ }
2459+}
2460+ if (!(filp->f_mode & 3))
2461+ goto out_putf;
2462+ break;
2463+#endif
2464+ default:
2465+ error = -EINVAL;
2466+ goto out_putf;
2467+ }
2468+
2469+ if (filp->f_op->lock != NULL) {
2470+ error = filp->f_op->lock(filp, cmd, &file_lock);
2471+ if (error < 0)
2472+ goto out_putf;
2473+ }
2474+ error = posix_lock_file(filp, &file_lock, cmd == F_SETLKW64);
2475+
2476+out_putf:
2477+ fput(filp);
2478+out:
2479+ return error;
2480+}
2481+#endif /* BITS_PER_LONG == 32 */
2482+
2483 /*
2484 * This function is called when the file is being removed
2485 * from the task's fd array.
2486@@ -655,10 +830,70 @@
2487 /* Verify a "struct flock" and copy it to a "struct file_lock" as a POSIX
2488 * style lock.
2489 */
2490-static int posix_make_lock(struct file *filp, struct file_lock *fl,
2491- struct flock *l)
2492+static int flock_to_posix_lock(struct file *filp, struct file_lock *fl,
2493+ struct flock *l)
2494+{
2495+ loff_t start;
2496+ int ret = -EINVAL;
2497+
2498+ memset(fl, 0, sizeof(*fl));
2499+
2500+ fl->fl_flags = FL_POSIX;
2501+
2502+ switch (l->l_type) {
2503+ case F_RDLCK:
2504+ case F_WRLCK:
2505+ case F_UNLCK:
2506+ fl->fl_type = l->l_type;
2507+ break;
2508+ default:
2509+ goto out;
2510+ }
2511+
2512+ switch (l->l_whence) {
2513+ case 0: /*SEEK_SET*/
2514+ start = 0;
2515+ break;
2516+ case 1: /*SEEK_CUR*/
2517+ start = filp->f_pos;
2518+ break;
2519+ case 2: /*SEEK_END*/
2520+ start = filp->f_dentry->d_inode->i_size;
2521+ break;
2522+ default:
2523+ goto out;
2524+ }
2525+
2526+ if (((start += l->l_start) < 0) || (l->l_len < 0))
2527+ goto out;
2528+ fl->fl_end = start + l->l_len - 1;
2529+ if (l->l_len > 0 && fl->fl_end < 0)
2530+ goto out;
2531+ fl->fl_start = start; /* we record the absolute position */
2532+ if (l->l_len != 0) {
2533+ start = fl->fl_end;
2534+ } else {
2535+ start = fl->fl_start;
2536+ fl->fl_end = OFFSET_MAX;
2537+ }
2538+ ret = -EOVERFLOW;
2539+ if (start > OFFT_OFFSET_MAX)
2540+ goto out;
2541+
2542+ fl->fl_file = filp;
2543+ fl->fl_owner = current->files;
2544+ fl->fl_pid = current->pid;
2545+
2546+ ret = 0;
2547+ out:
2548+ return ret;
2549+}
2550+
2551+#if BITS_PER_LONG == 32
2552+static int flock64_to_posix_lock(struct file *filp, struct file_lock *fl,
2553+ struct flock64 *l)
2554 {
2555- off_t start;
2556+ loff_t start;
2557
2558 memset(fl, 0, sizeof(*fl));
2559
2560@@ -703,6 +938,7 @@
2561
2562 return (1);
2563 }
2564+#endif
2565
2566 /* Verify a call to flock() and fill in a file_lock structure with
2567 * an appropriate FLOCK lock.
2568@@ -1218,7 +1454,7 @@
2569 p += sprintf(p, "FLOCK ADVISORY ");
2570 }
2571 p += sprintf(p, "%s ", (fl->fl_type == F_RDLCK) ? "READ " : "WRITE");
2572- p += sprintf(p, "%d %s:%ld %ld %ld ",
2573+ p += sprintf(p, "%d %s:%ld %Ld %Ld ",
2574 fl->fl_pid,
2575 kdevname(inode->i_dev), inode->i_ino, fl->fl_start,
2576 fl->fl_end);
2577@@ -1282,6 +1518,3 @@
2578 *start = buffer;
2579 return (q - buffer);
2580 }
2581-
2582-
2583-
2584diff -urN lfs-ref/fs/minix/dir.c lfs/fs/minix/dir.c
2585--- lfs-ref/fs/minix/dir.c Mon Jan 17 16:44:42 2000
2586+++ lfs/fs/minix/dir.c Wed Sep 12 02:42:15 2001
2587@@ -82,7 +82,7 @@
2588 de = (struct minix_dir_entry *) (offset + bh->b_data);
2589 if (de->inode) {
2590 int size = strnlen(de->name, info->s_namelen);
2591- if (filldir(dirent, de->name, size, filp->f_pos, de->inode) < 0) {
2592+ if (filldir(dirent, de->name, size, filp->f_pos, de->inode, DT_UNKNOWN) < 0) {
2593 brelse(bh);
2594 return 0;
2595 }
2596diff -urN lfs-ref/fs/minix/file.c lfs/fs/minix/file.c
2597--- lfs-ref/fs/minix/file.c Mon Jan 17 16:44:42 2000
2598+++ lfs/fs/minix/file.c Wed Sep 12 02:42:15 2001
2599@@ -70,8 +70,8 @@
2600 size_t count, loff_t *ppos)
2601 {
2602 struct inode * inode = filp->f_dentry->d_inode;
2603- off_t pos;
2604- ssize_t written, c;
2605+ loff_t pos;
2606+ ssize_t written, c, m;
2607 struct buffer_head * bh;
2608 char * p;
2609
2610@@ -87,15 +87,34 @@
2611 pos = inode->i_size;
2612 else
2613 pos = *ppos;
2614+
2615+ /* L-F-S spec 2.2.1.27: */
2616+ if (!(filp->f_flags & O_LARGEFILE)) {
2617+ if (pos >= 0x7fffffffULL) /* pos@2G forbidden */
2618+ return -EFBIG;
2619+
2620+ if (pos + count > 0x7fffffffULL)
2621+ /* Write only until end of allowed region */
2622+ count = 0x7fffffffULL - pos;
2623+ }
2624+ /* MINIX i-node file-size can't exceed 4G-1 */
2625+ /* With 1k blocks and triple indirection MINIX can have files
2626+ up to 16 GB in size -- filesystem maximum is then 4G*1k = 4T */
2627+ if (pos >= 0xffffffffULL)
2628+ return -EFBIG; /* Absolutely too much! */
2629+ if ((pos + count) >= 0x100000000ULL) /* too much to write! */
2630+ count = 0xffffffffULL - pos;
2631+
2632 written = 0;
2633 while (written < count) {
2634- bh = minix_getblk(inode,pos/BLOCK_SIZE,1);
2635+ bh = minix_getblk(inode, pos >> BLOCK_SIZE_BITS, 1);
2636 if (!bh) {
2637 if (!written)
2638 written = -ENOSPC;
2639 break;
2640 }
2641- c = BLOCK_SIZE - (pos % BLOCK_SIZE);
2642+ m = pos & (BLOCK_SIZE - 1);
2643+ c = BLOCK_SIZE - m;
2644 if (c > count-written)
2645 c = count-written;
2646 if (c != BLOCK_SIZE && !buffer_uptodate(bh)) {
2647@@ -108,7 +127,7 @@
2648 break;
2649 }
2650 }
2651- p = (pos % BLOCK_SIZE) + bh->b_data;
2652+ p = bh->b_data + m;
2653 c -= copy_from_user(p,buf,c);
2654 if (!c) {
2655 brelse(bh);
2656diff -urN lfs-ref/fs/ncpfs/dir.c lfs/fs/ncpfs/dir.c
2657--- lfs-ref/fs/ncpfs/dir.c Mon Dec 11 16:58:00 2000
2658+++ lfs/fs/ncpfs/dir.c Wed Sep 12 02:42:15 2001
2659@@ -449,14 +449,14 @@
2660 result = 0;
2661 if (filp->f_pos == 0) {
2662 ncp_invalid_dir_cache(inode);
2663- if (filldir(dirent, ".", 1, 0, inode->i_ino) < 0) {
2664+ if (filldir(dirent, ".", 1, 0, inode->i_ino, DT_DIR) < 0) {
2665 goto finished;
2666 }
2667 filp->f_pos = 1;
2668 }
2669 if (filp->f_pos == 1) {
2670 if (filldir(dirent, "..", 2, 1,
2671- dentry->d_parent->d_inode->i_ino) < 0) {
2672+ dentry->d_parent->d_inode->i_ino, DT_DIR) < 0) {
2673 goto finished;
2674 }
2675 filp->f_pos = 2;
2676@@ -537,7 +537,7 @@
2677 ino = ncp_invent_inos(1);
2678
2679 if (filldir(dirent, entry->i.entryName, entry->i.nameLen,
2680- entry->f_pos, ino) < 0) {
2681+ entry->f_pos, ino, DT_UNKNOWN) < 0) {
2682 break;
2683 }
2684 if ((inode->i_dev != c_dev)
2685diff -urN lfs-ref/fs/ncpfs/file.c lfs/fs/ncpfs/file.c
2686--- lfs-ref/fs/ncpfs/file.c Mon Dec 11 16:58:00 2000
2687+++ lfs/fs/ncpfs/file.c Wed Sep 12 02:42:15 2001
2688@@ -17,6 +17,7 @@
2689 #include <linux/mm.h>
2690 #include <linux/locks.h>
2691 #include <linux/malloc.h>
2692+#include <linux/unistd.h>
2693
2694 #include <linux/ncp_fs.h>
2695 #include "ncplib_kernel.h"
2696@@ -161,7 +162,7 @@
2697 /* First read in as much as possible for each bufsize. */
2698 while (already_read < count) {
2699 int read_this_time;
2700- size_t to_read = min(bufsize - (pos % bufsize),
2701+ size_t to_read = min(bufsize - (pos & (bufsize-1)),
2702 count - already_read);
2703
2704 error = ncp_read_bounce(NCP_SERVER(inode),
2705@@ -201,7 +202,7 @@
2706 struct dentry *dentry = file->f_dentry;
2707 struct inode *inode = dentry->d_inode;
2708 size_t already_written = 0;
2709- off_t pos;
2710+ loff_t pos;
2711 size_t bufsize;
2712 int errno;
2713 void* bouncebuffer;
2714@@ -238,12 +239,18 @@
2715
2716 already_written = 0;
2717
2718+ /* Maximum file size: 2G-1 */
2719+ if (pos >= 0x7fffffffULL)
2720+ return -EFBIG;
2721+ if ((pos + count) >= 0x7fffffffULL)
2722+ count = 0x7fffffffULL - pos;
2723+
2724 bouncebuffer = kmalloc(bufsize, GFP_NFS);
2725 if (!bouncebuffer)
2726 return -EIO; /* -ENOMEM */
2727 while (already_written < count) {
2728 int written_this_time;
2729- size_t to_write = min(bufsize - (pos % bufsize),
2730+ size_t to_write = min(bufsize - (pos & (bufsize-1)),
2731 count - already_written);
2732
2733 if (copy_from_user(bouncebuffer, buf, to_write)) {
2734diff -urN lfs-ref/fs/ncpfs/inode.c lfs/fs/ncpfs/inode.c
2735--- lfs-ref/fs/ncpfs/inode.c Tue Jun 13 03:48:14 2000
2736+++ lfs/fs/ncpfs/inode.c Wed Sep 12 02:42:15 2001
2737@@ -131,7 +131,7 @@
2738 }
2739 inode->i_blocks = 0;
2740 if ((inode->i_size)&&(inode->i_blksize)) {
2741- inode->i_blocks = (inode->i_size-1)/(inode->i_blksize)+1;
2742+ inode->i_blocks = ((inode->i_size-1) >> fslog2(inode->i_blksize)) +1;
2743 }
2744
2745 inode->i_mtime = ncp_date_dos2unix(le16_to_cpu(nwi->modifyTime),
2746@@ -201,8 +201,7 @@
2747
2748 inode->i_blocks = 0;
2749 if ((inode->i_blksize != 0) && (inode->i_size != 0)) {
2750- inode->i_blocks =
2751- (inode->i_size - 1) / inode->i_blksize + 1;
2752+ inode->i_blocks = ((inode->i_size - 1) >> fslog2(inode->i_blksize)) + 1;
2753 }
2754
2755 inode->i_mtime = ncp_date_dos2unix(le16_to_cpu(nwi->modifyTime),
2756diff -urN lfs-ref/fs/nfs/dir.c lfs/fs/nfs/dir.c
2757--- lfs-ref/fs/nfs/dir.c Wed Sep 12 02:05:57 2001
2758+++ lfs/fs/nfs/dir.c Wed Sep 12 02:42:15 2001
2759@@ -137,7 +137,7 @@
2760 int plus = NFS_USE_READDIRPLUS(inode);
2761 int error;
2762
2763- dfprintk(VFS, "NFS: nfs_readdir_filler() reading cookie %Lu into page %lu.\n", (long long)desc->entry->cookie, page->offset);
2764+ dfprintk(VFS, "NFS: nfs_readdir_filler() reading cookie %Lu into page %Lu.\n", (long long)desc->entry->cookie, (long long) nfs_page_offset(page));
2765
2766 again:
2767 error = NFS_PROTO(inode)->readdir(inode, cred,
2768@@ -158,7 +158,7 @@
2769 * Note: assumes we have exclusive access to this inode either
2770 * throught inode->i_sem or some other mechanism.
2771 */
2772- if (page->offset == 0)
2773+ if (page_index(page) == 0)
2774 invalidate_inode_pages(inode);
2775 nfs_unlock_page(page);
2776 return 0;
2777@@ -294,7 +294,7 @@
2778 * retrieving the current dirent on the server */
2779 fileid = nfs_fileid_to_ino_t(entry->ino);
2780 res = filldir(dirent, entry->name, entry->len,
2781- entry->prev_cookie, fileid);
2782+ entry->prev_cookie, fileid, DT_UNKNOWN);
2783 if (res < 0)
2784 break;
2785 file->f_pos = desc->target = entry->cookie;
2786diff -urN lfs-ref/fs/nfs/file.c lfs/fs/nfs/file.c
2787--- lfs-ref/fs/nfs/file.c Fri Apr 20 22:31:20 2001
2788+++ lfs/fs/nfs/file.c Wed Sep 12 02:42:15 2001
2789@@ -164,6 +164,9 @@
2790
2791 static int nfs_prepare_write(struct file *file, struct page *page, unsigned offset, unsigned to)
2792 {
2793+ if (!NFS_PROTO(file->f_dentry->d_inode)->bigfiles &&
2794+ page_index(page) > (0x7fffffff>>PAGE_SHIFT))
2795+ return -EFBIG;
2796 return nfs_flush_incompatible(file, page);
2797 }
2798
2799@@ -232,10 +235,10 @@
2800 struct inode * inode = dentry->d_inode;
2801 int status = 0;
2802
2803- dprintk("NFS: nfs_lock(f=%4x/%ld, t=%x, fl=%x, r=%ld:%ld)\n",
2804+ dprintk("NFS: nfs_lock(f=%4x/%ld, t=%x, fl=%x, r=%Ld:%Ld)\n",
2805 inode->i_dev, inode->i_ino,
2806 fl->fl_type, fl->fl_flags,
2807- fl->fl_start, fl->fl_end);
2808+ (long long)fl->fl_start, (long long)fl->fl_end);
2809
2810 if (!inode)
2811 return -EINVAL;
2812diff -urN lfs-ref/fs/nfs/inode.c lfs/fs/nfs/inode.c
2813--- lfs-ref/fs/nfs/inode.c Wed Sep 12 02:05:57 2001
2814+++ lfs/fs/nfs/inode.c Wed Sep 12 02:42:15 2001
2815@@ -639,7 +639,7 @@
2816 * Preset the size and mtime, as there's no need
2817 * to invalidate the caches.
2818 */
2819- inode->i_size = nfs_size_to_off_t(fattr->size);
2820+ inode->i_size = nfs_size_to_loff_t(fattr->size);
2821 inode->i_mtime = nfs_time_to_secs(fattr->mtime);
2822 inode->i_atime = nfs_time_to_secs(fattr->atime);
2823 inode->i_ctime = nfs_time_to_secs(fattr->ctime);
2824@@ -773,6 +773,11 @@
2825 if (!S_ISREG(inode->i_mode))
2826 attr->ia_valid &= ~ATTR_SIZE;
2827
2828+ error = -EFBIG;
2829+ if ((attr->ia_valid & ATTR_SIZE) && !NFS_PROTO(inode)->bigfiles &&
2830+ attr->ia_size > 0x7fffffff)
2831+ goto out;
2832+
2833 error = nfs_wb_all(inode);
2834 if (error < 0)
2835 goto out;
2836@@ -831,6 +836,10 @@
2837 struct rpc_cred *cred = rpcauth_lookupcred(auth, 0);
2838
2839 filp->private_data = cred;
2840+
2841+ if (!NFS_PROTO(filp->f_dentry->d_inode)->bigfiles)
2842+ filp->f_flags &= ~O_LARGEFILE;
2843+
2844 return 0;
2845 }
2846
2847@@ -912,8 +921,8 @@
2848 int
2849 nfs_refresh_inode(struct inode *inode, struct nfs_fattr *fattr)
2850 {
2851- off_t new_size, new_isize;
2852- __u64 new_mtime;
2853+ __u64 new_size, new_mtime;
2854+ loff_t new_isize;
2855 int invalid = 0;
2856 int error = -EIO;
2857
2858@@ -960,7 +969,7 @@
2859
2860 new_mtime = fattr->mtime;
2861 new_size = fattr->size;
2862- new_isize = nfs_size_to_off_t(fattr->size);
2863+ new_isize = nfs_size_to_loff_t(fattr->size);
2864
2865 error = 0;
2866
2867diff -urN lfs-ref/fs/nfs/nfs3proc.c lfs/fs/nfs/nfs3proc.c
2868--- lfs-ref/fs/nfs/nfs3proc.c Fri Apr 20 22:31:20 2001
2869+++ lfs/fs/nfs/nfs3proc.c Wed Sep 12 02:42:15 2001
2870@@ -145,7 +145,7 @@
2871 static int
2872 nfs3_proc_read(struct inode *inode, struct rpc_cred *cred,
2873 struct nfs_fattr *fattr, int flags,
2874- unsigned long offset, unsigned int count,
2875+ loff_t offset, unsigned int count,
2876 void *buffer, int *eofp)
2877 {
2878 struct nfs_readargs arg = { NFS_FH(inode), offset, count, 1,
2879@@ -155,7 +155,7 @@
2880 struct rpc_message msg = { NFS3PROC_READ, &arg, &res, cred };
2881 int status;
2882
2883- dprintk("NFS call read %d @ %ld\n", count, offset);
2884+ dprintk("NFS call read %d @ %Ld\n", count, (long long) offset);
2885 fattr->valid = 0;
2886 status = rpc_call_sync(NFS_CLIENT(inode), &msg, flags);
2887 dprintk("NFS reply read: %d\n", status);
2888@@ -166,7 +166,7 @@
2889 static int
2890 nfs3_proc_write(struct inode *inode, struct rpc_cred *cred,
2891 struct nfs_fattr *fattr, int flags,
2892- unsigned long offset, unsigned int count,
2893+ loff_t offset, unsigned int count,
2894 void *buffer, struct nfs_writeverf *verf)
2895 {
2896 struct nfs_writeargs arg = { NFS_FH(inode), offset, count,
2897@@ -177,7 +177,7 @@
2898 struct rpc_message msg = { NFS3PROC_WRITE, &arg, &res, cred };
2899 int status, rpcflags = 0;
2900
2901- dprintk("NFS call write %d @ %ld\n", count, offset);
2902+ dprintk("NFS call write %d @ %Ld\n", count, (long long) offset);
2903 fattr->valid = 0;
2904 if (flags & NFS_RW_SWAP)
2905 rpcflags |= NFS_RPC_SWAPFLAGS;
2906@@ -517,4 +517,6 @@
2907 nfs3_proc_statfs,
2908
2909 nfs3_decode_dirent,
2910+
2911+ 1,
2912 };
2913diff -urN lfs-ref/fs/nfs/proc.c lfs/fs/nfs/proc.c
2914--- lfs-ref/fs/nfs/proc.c Fri Apr 20 22:31:20 2001
2915+++ lfs/fs/nfs/proc.c Wed Sep 12 02:42:15 2001
2916@@ -134,7 +134,7 @@
2917
2918 static int
2919 nfs_proc_read(struct inode *inode, struct rpc_cred *cred, fattr *fattr,
2920- int flags, unsigned long offset, unsigned int count,
2921+ int flags, loff_t offset, unsigned int count,
2922 void *buffer, int *eofp)
2923 {
2924 struct nfs_readargs arg = { NFS_FH(inode), offset, count, 1,
2925@@ -144,7 +144,7 @@
2926 struct rpc_message msg = { NFSPROC_READ, &arg, &res, cred };
2927 int status;
2928
2929- dprintk("NFS call read %d @ %ld\n", count, offset);
2930+ dprintk("NFS call read %d @ %Ld\n", count, (long long) offset);
2931 fattr->valid = 0;
2932 status = rpc_call_sync(NFS_CLIENT(inode), &msg, flags);
2933
2934@@ -155,7 +155,7 @@
2935
2936 static int
2937 nfs_proc_write(struct inode *inode, struct rpc_cred *cred, fattr *fattr,
2938- int how, unsigned long offset, unsigned int count,
2939+ int how, loff_t offset, unsigned int count,
2940 void *buffer, struct nfs_writeverf *verf)
2941 {
2942 struct nfs_writeargs arg = {NFS_FH(inode), offset, count,
2943@@ -166,7 +166,7 @@
2944 struct rpc_message msg = { NFSPROC_WRITE, &arg, &res, cred };
2945 int status, flags = 0;
2946
2947- dprintk("NFS call write %d @ %ld\n", count, offset);
2948+ dprintk("NFS call write %d @ %Ld\n", count, (long long) offset);
2949 fattr->valid = 0;
2950 if (how & NFS_RW_SWAP)
2951 flags |= NFS_RPC_SWAPFLAGS;
2952@@ -407,4 +407,5 @@
2953 nfs_proc_mknod,
2954 nfs_proc_statfs,
2955 nfs_decode_dirent,
2956+ 0,
2957 };
2958diff -urN lfs-ref/fs/nfs/read.c lfs/fs/nfs/read.c
2959--- lfs-ref/fs/nfs/read.c Fri Apr 20 22:31:20 2001
2960+++ lfs/fs/nfs/read.c Wed Sep 12 02:42:15 2001
2961@@ -91,7 +91,7 @@
2962 {
2963 struct rpc_cred *cred = NULL;
2964 struct nfs_fattr fattr;
2965- unsigned long offset = nfs_page_offset(page);
2966+ loff_t offset = nfs_page_offset(page);
2967 char *buffer = (char *) page_address(page);
2968 int rsize = NFS_SERVER(inode)->rsize;
2969 int result, refresh = 0;
2970@@ -112,10 +112,10 @@
2971 if ((chunk = rsize) > count)
2972 chunk = count;
2973
2974- dprintk("NFS: nfs_proc_read(%s, (%x/%Ld), %ld, %d, %p)\n",
2975+ dprintk("NFS: nfs_proc_read(%s, (%x/%Ld), %Ld, %d, %p)\n",
2976 NFS_SERVER(inode)->hostname,
2977 inode->i_dev, (long long)NFS_FILEID(inode),
2978- offset, chunk, buffer);
2979+ (long long) offset, chunk, buffer);
2980
2981 result = NFS_PROTO(inode)->read(inode, cred, &fattr, flags,
2982 offset, chunk, buffer, &eof);
2983@@ -439,11 +439,11 @@
2984 set_bit(PG_error, &page->flags);
2985 nfs_unlock_page(page);
2986
2987- dprintk("NFS: read (%x/%Ld %d@%ld)\n",
2988+ dprintk("NFS: read (%x/%Ld %d@%Ld)\n",
2989 req->wb_inode->i_dev,
2990 (long long)NFS_FILEID(req->wb_inode),
2991 req->wb_bytes,
2992- (nfs_page_offset(page) + req->wb_offset));
2993+ (long long)(nfs_page_offset(page) + req->wb_offset));
2994 nfs_unlock_request(req);
2995 nfs_release_request(req);
2996 }
2997@@ -475,8 +475,8 @@
2998 else
2999 inode = file->f_dentry->d_inode;
3000
3001- dprintk("NFS: nfs_readpage (%p %ld@%lu)\n",
3002- page, PAGE_CACHE_SIZE, page->offset);
3003+ dprintk("NFS: nfs_readpage (%p %ld@%Lu)\n",
3004+ page, PAGE_CACHE_SIZE, (long long) nfs_page_offset(page));
3005
3006 /*
3007 * Try to flush any pending writes to the file
3008diff -urN lfs-ref/fs/nfs/write.c lfs/fs/nfs/write.c
3009--- lfs-ref/fs/nfs/write.c Fri Apr 20 22:31:20 2001
3010+++ lfs/fs/nfs/write.c Wed Sep 12 02:42:15 2001
3011@@ -144,7 +144,7 @@
3012 */
3013 static int
3014 nfs_writepage_sync(struct file *file, struct inode *inode, struct page *page,
3015- unsigned long offset, unsigned int count)
3016+ unsigned int offset, unsigned int count)
3017 {
3018 struct rpc_cred *cred = NULL;
3019 unsigned int wsize = NFS_SERVER(inode)->wsize;
3020@@ -152,16 +152,17 @@
3021 u8 *buffer;
3022 struct nfs_fattr fattr;
3023 struct nfs_writeverf verifier;
3024+ loff_t base;
3025
3026 if (file)
3027 cred = nfs_file_cred(file);
3028
3029- dprintk("NFS: nfs_writepage_sync(%x/%Ld %d@%ld)\n",
3030+ dprintk("NFS: nfs_writepage_sync(%x/%Ld %d@%Ld)\n",
3031 inode->i_dev, (long long)NFS_FILEID(inode),
3032- count, nfs_page_offset(page) + offset);
3033+ count, (long long) (nfs_page_offset(page) + offset));
3034
3035 buffer = (u8 *) page_address(page) + offset;
3036- offset += nfs_page_offset(page);
3037+ base = nfs_page_offset(page) + offset;
3038
3039 flags = ((IS_SWAPFILE(inode)) ? NFS_RW_SWAP : 0) | NFS_RW_SYNC;
3040
3041@@ -170,7 +171,7 @@
3042 wsize = count;
3043
3044 result = NFS_PROTO(inode)->write(inode, cred, &fattr, flags,
3045- offset, wsize, buffer,
3046+ base, wsize, buffer,
3047 &verifier);
3048 nfs_write_attributes(inode, &fattr);
3049
3050@@ -184,15 +185,15 @@
3051 wsize, result);
3052 refresh = 1;
3053 buffer += wsize;
3054- offset += wsize;
3055+ base += wsize;
3056 written += wsize;
3057 count -= wsize;
3058 /*
3059 * If we've extended the file, update the inode
3060 * now so we don't invalidate the cache.
3061 */
3062- if (offset > inode->i_size)
3063- inode->i_size = offset;
3064+ if (base > inode->i_size)
3065+ inode->i_size = base;
3066 } while (count);
3067
3068 io_error:
3069@@ -213,9 +214,9 @@
3070 inode = page->inode;
3071 else
3072 inode = file->f_dentry->d_inode;
3073- if (page->offset >= inode->i_size)
3074+ if (nfs_page_offset(page) >= inode->i_size)
3075 return -EIO;
3076- if (page->offset + offset > inode->i_size)
3077+ if (nfs_page_offset(page) + offset > inode->i_size)
3078 offset = inode->i_size & (PAGE_CACHE_SIZE-1);
3079 return nfs_writepage_sync(file, inode, page, 0, offset);
3080 }
3081@@ -228,7 +229,7 @@
3082 region_locked(struct inode *inode, struct nfs_page *req)
3083 {
3084 struct file_lock *fl;
3085- unsigned long rqstart, rqend;
3086+ loff_t rqstart, rqend;
3087
3088 /* Don't optimize writes if we don't use NLM */
3089 if (NFS_SERVER(inode)->flags & NFS_MOUNT_NONLM)
3090@@ -895,9 +896,9 @@
3091 struct nfs_page *req;
3092 int status = 0;
3093
3094- dprintk("NFS: nfs_updatepage(%s/%s %d@%ld, sync=%d)\n",
3095+ dprintk("NFS: nfs_updatepage(%s/%s %d@%Ld, sync=%d)\n",
3096 dentry->d_parent->d_name.name, dentry->d_name.name,
3097- count, nfs_page_offset(page)+offset, sync);
3098+ count, (long long) (nfs_page_offset(page)+offset), sync);
3099
3100 /*
3101 * If wsize is smaller than page size, update and write
3102@@ -947,8 +948,8 @@
3103 }
3104 nfs_release_request(req);
3105 done:
3106- dprintk("NFS: nfs_updatepage returns %d (isize %ld)\n",
3107- status, inode->i_size);
3108+ dprintk("NFS: nfs_updatepage returns %d (isize %Ld)\n",
3109+ status, (long long) inode->i_size);
3110 if (status < 0)
3111 clear_bit(PG_uptodate, &page->flags);
3112 return status;
3113@@ -1193,18 +1194,18 @@
3114 {
3115 struct nfs_page *req;
3116 struct inode *inode;
3117- unsigned long start, end, len;
3118+ loff_t start, end, len;
3119
3120 /* Set up the RPC argument and reply structs
3121 * NB: take care not to mess about with data->commit et al. */
3122
3123 end = 0;
3124- start = ~0;
3125+ start = NFS_OFFSET_MAX;
3126 req = nfs_list_entry(head->next);
3127 inode = req->wb_inode;
3128 while (!list_empty(head)) {
3129 struct nfs_page *req;
3130- unsigned long rqstart, rqend;
3131+ loff_t rqstart, rqend;
3132 req = nfs_list_entry(head->next);
3133 nfs_list_remove_request(req);
3134 nfs_list_add_request(req, &data->pages);
3135@@ -1220,7 +1221,7 @@
3136 data->args.fh = NFS_FH(inode);
3137 data->args.offset = start;
3138 len = end - start;
3139- if (end >= inode->i_size || len > (~((u32)0) >> 1))
3140+ if (end >= inode->i_size || len < 0 || len > (~((u32)0) >> 1))
3141 len = 0;
3142 data->res.count = data->args.count = (u32)len;
3143 data->res.fattr = &data->fattr;
3144@@ -1298,11 +1299,11 @@
3145 req = nfs_list_entry(data->pages.next);
3146 nfs_list_remove_request(req);
3147
3148- dprintk("NFS: commit (%x/%Ld %d@%ld)",
3149+ dprintk("NFS: commit (%x/%Ld %d@%Ld)",
3150 req->wb_inode->i_dev,
3151 (long long)NFS_FILEID(req->wb_inode),
3152 req->wb_bytes,
3153- nfs_page_offset(req->wb_page) + req->wb_offset);
3154+ (long long) (nfs_page_offset(req->wb_page) + req->wb_offset));
3155 if (task->tk_status < 0) {
3156 if (req->wb_file)
3157 req->wb_file->f_error = task->tk_status;
3158diff -urN lfs-ref/fs/nfsd/nfs3xdr.c lfs/fs/nfsd/nfs3xdr.c
3159--- lfs-ref/fs/nfsd/nfs3xdr.c Fri Apr 20 22:31:20 2001
3160+++ lfs/fs/nfsd/nfs3xdr.c Wed Sep 12 02:42:15 2001
3161@@ -131,9 +131,9 @@
3162 iap->ia_valid |= ATTR_SIZE;
3163 p = xdr_decode_hyper(p, &newsize);
3164 if (newsize <= NFS_OFFSET_MAX)
3165- iap->ia_size = (u32) newsize;
3166+ iap->ia_size = newsize;
3167 else
3168- iap->ia_size = ~(size_t) 0;
3169+ iap->ia_size = NFS_OFFSET_MAX;
3170 }
3171 if ((tmp = ntohl(*p++)) == 1) { /* set to server time */
3172 iap->ia_valid |= ATTR_ATIME;
3173@@ -678,11 +678,6 @@
3174 if (name == 0)
3175 return 0;
3176
3177- /*
3178- dprintk("encode_entry(%.*s @%ld%s)\n",
3179- namlen, name, (long) offset, plus? " plus" : "");
3180- */
3181-
3182 /* truncate filename if too long */
3183 if (namlen > NFS3_MAXNAMLEN)
3184 namlen = NFS3_MAXNAMLEN;
3185@@ -727,14 +722,14 @@
3186
3187 int
3188 nfs3svc_encode_entry(struct readdir_cd *cd, const char *name,
3189- int namlen, off_t offset, ino_t ino)
3190+ int namlen, off_t offset, ino_t ino, unsigned int d_type)
3191 {
3192 return encode_entry(cd, name, namlen, offset, ino, 0);
3193 }
3194
3195 int
3196 nfs3svc_encode_entry_plus(struct readdir_cd *cd, const char *name,
3197- int namlen, off_t offset, ino_t ino)
3198+ int namlen, off_t offset, ino_t ino, unsigned int d_type)
3199 {
3200 return encode_entry(cd, name, namlen, offset, ino, 1);
3201 }
3202diff -urN lfs-ref/fs/nfsd/nfsfh.c lfs/fs/nfsd/nfsfh.c
3203--- lfs-ref/fs/nfsd/nfsfh.c Fri Apr 20 22:31:20 2001
3204+++ lfs/fs/nfsd/nfsfh.c Wed Sep 12 02:42:15 2001
3205@@ -41,7 +41,7 @@
3206 * the name matching the specified inode number.
3207 */
3208 static int filldir_one(void * __buf, const char * name, int len,
3209- off_t pos, ino_t ino)
3210+ off_t pos, ino_t ino, unsigned int d_type)
3211 {
3212 struct nfsd_getdents_callback *buf = __buf;
3213 struct qstr *qs = buf->name;
3214diff -urN lfs-ref/fs/nfsd/nfssvc.c lfs/fs/nfsd/nfssvc.c
3215--- lfs-ref/fs/nfsd/nfssvc.c Wed Sep 12 02:05:57 2001
3216+++ lfs/fs/nfsd/nfssvc.c Wed Sep 12 02:42:15 2001
3217@@ -123,6 +123,7 @@
3218 current->session = 1;
3219 current->pgrp = 1;
3220 current->fs->umask = 0;
3221+ current->rlim[RLIMIT_FSIZE].rlim_cur = RLIM_INFINITY;
3222
3223 /* Count active threads */
3224 atomic_inc(&nfsd_active);
3225diff -urN lfs-ref/fs/nfsd/nfsxdr.c lfs/fs/nfsd/nfsxdr.c
3226--- lfs-ref/fs/nfsd/nfsxdr.c Fri Apr 20 22:31:20 2001
3227+++ lfs/fs/nfsd/nfsxdr.c Wed Sep 12 02:42:15 2001
3228@@ -394,7 +394,7 @@
3229
3230 int
3231 nfssvc_encode_entry(struct readdir_cd *cd, const char *name,
3232- int namlen, off_t offset, ino_t ino)
3233+ int namlen, off_t offset, ino_t ino, unsigned int d_type)
3234 {
3235 u32 *p = cd->buffer;
3236 int buflen, slen;
3237diff -urN lfs-ref/fs/nfsd/vfs.c lfs/fs/nfsd/vfs.c
3238--- lfs-ref/fs/nfsd/vfs.c Fri Apr 20 22:31:20 2001
3239+++ lfs/fs/nfsd/vfs.c Wed Sep 12 02:42:15 2001
3240@@ -513,11 +513,11 @@
3241 filp->f_count = 1;
3242 filp->f_dentry = dentry;
3243 if (access & MAY_WRITE) {
3244- filp->f_flags = O_WRONLY;
3245+ filp->f_flags = O_WRONLY | O_LARGEFILE;
3246 filp->f_mode = FMODE_WRITE;
3247 DQUOT_INIT(inode);
3248 } else {
3249- filp->f_flags = O_RDONLY;
3250+ filp->f_flags = O_RDONLY | O_LARGEFILE;
3251 filp->f_mode = FMODE_READ;
3252 }
3253
3254@@ -658,8 +658,9 @@
3255 /* Write back readahead params */
3256 if (ra != NULL) {
3257 dprintk("nfsd: raparms %ld %ld %ld %ld %ld\n",
3258- file.f_reada, file.f_ramax, file.f_raend,
3259- file.f_ralen, file.f_rawin);
3260+ (u_long)file.f_reada, (u_long)file.f_ramax,
3261+ (u_long)file.f_raend, (u_long)file.f_ralen,
3262+ (u_long)file.f_rawin);
3263 ra->p_reada = file.f_reada;
3264 ra->p_ramax = file.f_ramax;
3265 ra->p_raend = file.f_raend;
3266diff -urN lfs-ref/fs/ntfs/fs.c lfs/fs/ntfs/fs.c
3267--- lfs-ref/fs/ntfs/fs.c Wed Sep 12 02:05:57 2001
3268+++ lfs/fs/ntfs/fs.c Wed Sep 12 02:42:15 2001
3269@@ -200,7 +200,7 @@
3270 /* filldir expects an off_t rather than an loff_t.
3271 Hope we don't have more than 65535 index records */
3272 error=nf->filldir(nf->dirent,nf->name,nf->namelen,
3273- (nf->ph<<16)|nf->pl,inum);
3274+ (nf->ph<<16)|nf->pl,inum,DT_UNKNOWN);
3275 ntfs_free(nf->name);
3276 /* Linux filldir errors are negative, other errors positive */
3277 return error;
3278@@ -226,11 +226,11 @@
3279 if(cb.ph==0xFFFF){
3280 /* FIXME: Maybe we can return those with the previous call */
3281 switch(cb.pl){
3282- case 0: filldir(dirent,".",1,filp->f_pos,dir->i_ino);
3283+ case 0: filldir(dirent,".",1,filp->f_pos,dir->i_ino,DT_DIR);
3284 filp->f_pos=0xFFFF0001;
3285 return 0;
3286 /* FIXME: parent directory */
3287- case 1: filldir(dirent,"..",2,filp->f_pos,0);
3288+ case 1: filldir(dirent,"..",2,filp->f_pos,0,DT_DIR);
3289 filp->f_pos=0xFFFF0002;
3290 return 0;
3291 }
3292@@ -823,6 +823,7 @@
3293 struct statfs fs;
3294 struct inode *mft;
3295 ntfs_volume *vol;
3296+ ntfs_u64 size;
3297 int error;
3298
3299 ntfs_debug(DEBUG_OTHER, "ntfs_statfs\n");
3300@@ -831,16 +832,17 @@
3301 fs.f_type=NTFS_SUPER_MAGIC;
3302 fs.f_bsize=vol->clustersize;
3303
3304- error = ntfs_get_volumesize( NTFS_SB2VOL( sb ), &fs.f_blocks );
3305+ error = ntfs_get_volumesize( NTFS_SB2VOL( sb ), &size );
3306 if( error )
3307 return -error;
3308+ fs.f_blocks = size;
3309 fs.f_bfree=ntfs_get_free_cluster_count(vol->bitmap);
3310 fs.f_bavail=fs.f_bfree;
3311
3312 /* Number of files is limited by free space only, so we lie here */
3313 fs.f_ffree=0;
3314 mft=iget(sb,FILE_MFT);
3315- fs.f_files=mft->i_size/vol->mft_recordsize;
3316+ fs.f_files = (long)mft->i_size / vol->mft_recordsize;
3317 iput(mft);
3318
3319 /* should be read from volume */
3320diff -urN lfs-ref/fs/ntfs/super.c lfs/fs/ntfs/super.c
3321--- lfs-ref/fs/ntfs/super.c Mon Dec 11 16:58:03 2000
3322+++ lfs/fs/ntfs/super.c Wed Sep 12 02:42:15 2001
3323@@ -304,7 +304,7 @@
3324 * Writes the volume size into vol_size. Returns 0 if successful
3325 * or error.
3326 */
3327-int ntfs_get_volumesize(ntfs_volume *vol, long *vol_size )
3328+int ntfs_get_volumesize(ntfs_volume *vol, ntfs_u64 *vol_size )
3329 {
3330 ntfs_io io;
3331 ntfs_u64 size;
3332@@ -325,9 +325,7 @@
3333 ntfs_getput_clusters(vol,0,0,&io);
3334 size=NTFS_GETU64(cluster0+0x28);
3335 ntfs_free(cluster0);
3336- /* FIXME: more than 2**32 cluster */
3337- /* FIXME: gcc will emit udivdi3 if we don't truncate it */
3338- *vol_size = ((unsigned long)size)/vol->clusterfactor;
3339+ *vol_size = size;
3340 return 0;
3341 }
3342
3343diff -urN lfs-ref/fs/ntfs/super.h lfs/fs/ntfs/super.h
3344--- lfs-ref/fs/ntfs/super.h Mon Jan 17 16:44:42 2000
3345+++ lfs/fs/ntfs/super.h Wed Sep 12 02:42:15 2001
3346@@ -10,7 +10,7 @@
3347 #define ALLOC_REQUIRE_SIZE 2
3348
3349 int ntfs_get_free_cluster_count(ntfs_inode *bitmap);
3350-int ntfs_get_volumesize(ntfs_volume *vol, long *vol_size );
3351+int ntfs_get_volumesize(ntfs_volume *vol, ntfs_u64 *vol_size );
3352 int ntfs_init_volume(ntfs_volume *vol,char *boot);
3353 int ntfs_load_special_files(ntfs_volume *vol);
3354 int ntfs_release_volume(ntfs_volume *vol);
3355diff -urN lfs-ref/fs/open.c lfs/fs/open.c
3356--- lfs-ref/fs/open.c Wed Sep 12 02:05:57 2001
3357+++ lfs/fs/open.c Wed Sep 12 02:42:15 2001
3358@@ -12,7 +12,7 @@
3359
3360 #include <asm/uaccess.h>
3361
3362-asmlinkage int sys_statfs(const char * path, struct statfs * buf)
3363+asmlinkage long sys_statfs(const char * path, struct statfs * buf)
3364 {
3365 struct dentry * dentry;
3366 int error;
3367@@ -34,7 +34,7 @@
3368 return error;
3369 }
3370
3371-asmlinkage int sys_fstatfs(unsigned int fd, struct statfs * buf)
3372+asmlinkage long sys_fstatfs(unsigned int fd, struct statfs * buf)
3373 {
3374 struct file * file;
3375 struct inode * inode;
3376@@ -63,15 +63,16 @@
3377 return error;
3378 }
3379
3380-int do_truncate(struct dentry *dentry, unsigned long length)
3381+int do_truncate(struct dentry *dentry, loff_t length)
3382 {
3383 struct inode *inode = dentry->d_inode;
3384 int error;
3385 struct iattr newattrs;
3386
3387- /* Not pretty: "inode->i_size" shouldn't really be "off_t". But it is. */
3388- if ((off_t) length < 0)
3389- return -EINVAL;
3390+ /* Not pretty: "inode->i_size" shouldn't really be signed. But it is. */
3391+ error = -EINVAL;
3392+ if (length < 0)
3393+ goto out;
3394
3395 fs_down(&inode->i_sem);
3396 newattrs.ia_size = length;
3397@@ -84,10 +85,11 @@
3398 inode->i_op->truncate(inode);
3399 }
3400 fs_up(&inode->i_sem);
3401+out:
3402 return error;
3403 }
3404
3405-asmlinkage int sys_truncate(const char * path, unsigned long length)
3406+static inline long do_sys_truncate(const char * path, loff_t length)
3407 {
3408 struct dentry * dentry;
3409 struct inode * inode;
3410@@ -136,7 +138,12 @@
3411 return error;
3412 }
3413
3414-asmlinkage int sys_ftruncate(unsigned int fd, unsigned long length)
3415+asmlinkage long sys_truncate(const char * path, unsigned long length)
3416+{
3417+ return do_sys_truncate(path, length);
3418+}
3419+
3420+static inline long do_sys_ftruncate(unsigned int fd, loff_t length)
3421 {
3422 struct inode * inode;
3423 struct dentry *dentry;
3424@@ -171,6 +178,24 @@
3425 return error;
3426 }
3427
3428+asmlinkage long sys_ftruncate(unsigned int fd, unsigned long length)
3429+{
3430+ return do_sys_ftruncate(fd, length);
3431+}
3432+
3433+/* LFS versions of truncate are only needed on 32 bit machines */
3434+#if BITS_PER_LONG == 32
3435+asmlinkage long sys_truncate64(const char * path, loff_t length)
3436+{
3437+ return do_sys_truncate(path, length);
3438+}
3439+
3440+asmlinkage long sys_ftruncate64(unsigned int fd, loff_t length)
3441+{
3442+ return do_sys_ftruncate(fd, length);
3443+}
3444+#endif
3445+
3446 #ifndef __alpha__
3447
3448 /*
3449@@ -184,7 +209,7 @@
3450 * must be owner or have write permission.
3451 * Else, update from *times, must be owner or super user.
3452 */
3453-asmlinkage int sys_utime(char * filename, struct utimbuf * times)
3454+asmlinkage long sys_utime(char * filename, struct utimbuf * times)
3455 {
3456 int error;
3457 struct dentry * dentry;
3458@@ -232,7 +257,7 @@
3459 * must be owner or have write permission.
3460 * Else, update from *times, must be owner or super user.
3461 */
3462-asmlinkage int sys_utimes(char * filename, struct timeval * utimes)
3463+asmlinkage long sys_utimes(char * filename, struct timeval * utimes)
3464 {
3465 int error;
3466 struct dentry * dentry;
3467@@ -278,7 +303,7 @@
3468 * We do this by temporarily clearing all FS-related capabilities and
3469 * switching the fsuid/fsgid around to the real ones.
3470 */
3471-asmlinkage int sys_access(const char * filename, int mode)
3472+asmlinkage long sys_access(const char * filename, int mode)
3473 {
3474 struct dentry * dentry;
3475 int old_fsuid, old_fsgid;
3476@@ -325,7 +350,7 @@
3477 return res;
3478 }
3479
3480-asmlinkage int sys_chdir(const char * filename)
3481+asmlinkage long sys_chdir(const char * filename)
3482 {
3483 int error;
3484 struct inode *inode;
3485@@ -360,7 +385,7 @@
3486 return error;
3487 }
3488
3489-asmlinkage int sys_fchdir(unsigned int fd)
3490+asmlinkage long sys_fchdir(unsigned int fd)
3491 {
3492 struct file *file;
3493 struct dentry *dentry;
3494@@ -397,7 +422,7 @@
3495 return error;
3496 }
3497
3498-asmlinkage int sys_chroot(const char * filename)
3499+asmlinkage long sys_chroot(const char * filename)
3500 {
3501 int error;
3502 struct inode *inode;
3503@@ -437,7 +462,7 @@
3504 return error;
3505 }
3506
3507-asmlinkage int sys_fchmod(unsigned int fd, mode_t mode)
3508+asmlinkage long sys_fchmod(unsigned int fd, mode_t mode)
3509 {
3510 struct inode * inode;
3511 struct dentry * dentry;
3512@@ -475,7 +500,7 @@
3513 return err;
3514 }
3515
3516-asmlinkage int sys_chmod(const char * filename, mode_t mode)
3517+asmlinkage long sys_chmod(const char * filename, mode_t mode)
3518 {
3519 struct dentry * dentry;
3520 struct inode * inode;
3521@@ -571,7 +596,7 @@
3522 return error;
3523 }
3524
3525-asmlinkage int sys_chown(const char * filename, uid_t user, gid_t group)
3526+asmlinkage long sys_chown(const char * filename, uid_t user, gid_t group)
3527 {
3528 struct dentry * dentry;
3529 int error;
3530@@ -588,7 +613,7 @@
3531 return error;
3532 }
3533
3534-asmlinkage int sys_lchown(const char * filename, uid_t user, gid_t group)
3535+asmlinkage long sys_lchown(const char * filename, uid_t user, gid_t group)
3536 {
3537 struct dentry * dentry;
3538 int error;
3539@@ -606,7 +631,7 @@
3540 }
3541
3542
3543-asmlinkage int sys_fchown(unsigned int fd, uid_t user, gid_t group)
3544+asmlinkage long sys_fchown(unsigned int fd, uid_t user, gid_t group)
3545 {
3546 struct dentry * dentry;
3547 struct file * file;
3548@@ -651,6 +676,9 @@
3549 f = get_empty_filp();
3550 if (!f)
3551 goto out;
3552+#if BITS_PER_LONG != 32
3553+ flags |= O_LARGEFILE;
3554+#endif
3555 f->f_flags = flag = flags;
3556 f->f_mode = (flag+1) & O_ACCMODE;
3557 if (f->f_mode)
3558@@ -789,7 +817,7 @@
3559 * For backward compatibility? Maybe this should be moved
3560 * into arch/i386 instead?
3561 */
3562-asmlinkage int sys_creat(const char * pathname, int mode)
3563+asmlinkage long sys_creat(const char * pathname, int mode)
3564 {
3565 return sys_open(pathname, O_CREAT | O_WRONLY | O_TRUNC, mode);
3566 }
3567@@ -862,7 +890,7 @@
3568 * This routine simulates a hangup on the tty, to arrange that users
3569 * are given clean terminals at login time.
3570 */
3571-asmlinkage int sys_vhangup(void)
3572+asmlinkage long sys_vhangup(void)
3573 {
3574 int ret = -EPERM;
3575
3576diff -urN lfs-ref/fs/proc/array.c lfs/fs/proc/array.c
3577--- lfs-ref/fs/proc/array.c Wed Sep 12 02:39:57 2001
3578+++ lfs/fs/proc/array.c Wed Sep 12 02:42:15 2001
3579@@ -1173,11 +1173,11 @@
3580 * + (index into the line)
3581 */
3582 /* for systems with sizeof(void*) == 4: */
3583-#define MAPS_LINE_FORMAT4 "%08lx-%08lx %s %08lx %s %lu"
3584-#define MAPS_LINE_MAX4 49 /* sum of 8 1 8 1 4 1 8 1 5 1 10 1 */
3585+#define MAPS_LINE_FORMAT4 "%08lx-%08lx %s %016Lx %s %lu"
3586+#define MAPS_LINE_MAX4 57 /* sum of 8 1 8 1 4 1 16 1 5 1 10 1 */
3587
3588 /* for systems with sizeof(void*) == 8: */
3589-#define MAPS_LINE_FORMAT8 "%016lx-%016lx %s %016lx %s %lu"
3590+#define MAPS_LINE_FORMAT8 "%016lx-%016lx %s %016Lx %s %lu"
3591 #define MAPS_LINE_MAX8 73 /* sum of 16 1 16 1 4 1 16 1 5 1 10 1 */
3592
3593 #define MAPS_LINE_MAX MAPS_LINE_MAX8
3594diff -urN lfs-ref/fs/proc/fd.c lfs/fs/proc/fd.c
3595--- lfs-ref/fs/proc/fd.c Wed Sep 12 02:39:56 2001
3596+++ lfs/fs/proc/fd.c Wed Sep 12 02:42:15 2001
3597@@ -146,7 +146,7 @@
3598 ino = inode->i_ino;
3599 if (fd)
3600 ino = (ino & 0xffff0000) | PROC_PID_INO;
3601- if (filldir(dirent, "..", fd+1, fd, ino) < 0)
3602+ if (filldir(dirent, "..", fd+1, fd, ino, DT_DIR) < 0)
3603 goto out;
3604 }
3605
3606@@ -176,7 +176,7 @@
3607 read_unlock(&tasklist_lock);
3608
3609 ino = (pid << 16) + PROC_PID_FD_DIR + fd;
3610- if (filldir(dirent, buf+j, NUMBUF-j, fd+2, ino) < 0)
3611+ if (filldir(dirent, buf+j, NUMBUF-j, fd+2, ino, DT_LNK) < 0)
3612 goto out;
3613
3614 read_lock(&tasklist_lock);
3615diff -urN lfs-ref/fs/proc/openpromfs.c lfs/fs/proc/openpromfs.c
3616--- lfs-ref/fs/proc/openpromfs.c Mon Jan 17 16:44:43 2000
3617+++ lfs/fs/proc/openpromfs.c Wed Sep 12 02:42:15 2001
3618@@ -846,14 +846,14 @@
3619 i = filp->f_pos;
3620 switch (i) {
3621 case 0:
3622- if (filldir(dirent, ".", 1, i, ino) < 0) return 0;
3623+ if (filldir(dirent, ".", 1, i, ino, DT_DIR) < 0) return 0;
3624 i++;
3625 filp->f_pos++;
3626 /* fall thru */
3627 case 1:
3628 if (filldir(dirent, "..", 2, i,
3629 (NODE(ino).parent == 0xffff) ?
3630- PROC_ROOT_INO : NODE2INO(NODE(ino).parent)) < 0)
3631+ PROC_ROOT_INO : NODE2INO(NODE(ino).parent), DT_DIR) < 0)
3632 return 0;
3633 i++;
3634 filp->f_pos++;
3635@@ -869,14 +869,14 @@
3636 if (prom_getname (nodes[node].node, buffer, 128) < 0)
3637 return 0;
3638 if (filldir(dirent, buffer, strlen(buffer),
3639- filp->f_pos, NODE2INO(node)) < 0)
3640+ filp->f_pos, NODE2INO(node), DT_DIR) < 0)
3641 return 0;
3642 filp->f_pos++;
3643 node = nodes[node].next;
3644 }
3645 j = NODEP2INO(NODE(ino).first_prop);
3646 if (!i) {
3647- if (filldir(dirent, ".node", 5, filp->f_pos, j) < 0)
3648+ if (filldir(dirent, ".node", 5, filp->f_pos, j, DT_REG) < 0)
3649 return 0;
3650 filp->f_pos++;
3651 } else
3652@@ -887,7 +887,7 @@
3653 if (alias_names [i]) {
3654 if (filldir (dirent, alias_names [i],
3655 strlen (alias_names [i]),
3656- filp->f_pos, j) < 0) return 0;
3657+ filp->f_pos, j, DT_REG) < 0) return 0;
3658 filp->f_pos++;
3659 }
3660 }
3661@@ -899,7 +899,7 @@
3662 if (i) i--;
3663 else {
3664 if (filldir(dirent, p, strlen(p),
3665- filp->f_pos, j) < 0)
3666+ filp->f_pos, j, DT_REG) < 0)
3667 return 0;
3668 filp->f_pos++;
3669 }
3670@@ -911,7 +911,7 @@
3671 else {
3672 if (filldir(dirent, d->name,
3673 strlen(d->name),
3674- filp->f_pos, d->inode) < 0)
3675+ filp->f_pos, d->inode, d->mode >> 12) < 0)
3676 return 0;
3677 filp->f_pos++;
3678 }
3679diff -urN lfs-ref/fs/proc/root.c lfs/fs/proc/root.c
3680--- lfs-ref/fs/proc/root.c Wed Sep 12 02:39:56 2001
3681+++ lfs/fs/proc/root.c Wed Sep 12 02:42:15 2001
3682@@ -890,13 +890,13 @@
3683 i = filp->f_pos;
3684 switch (i) {
3685 case 0:
3686- if (filldir(dirent, ".", 1, i, ino) < 0)
3687+ if (filldir(dirent, ".", 1, i, ino, DT_DIR) < 0)
3688 return 0;
3689 i++;
3690 filp->f_pos++;
3691 /* fall through */
3692 case 1:
3693- if (filldir(dirent, "..", 2, i, de->parent->low_ino) < 0)
3694+ if (filldir(dirent, "..", 2, i, de->parent->low_ino, DT_DIR) < 0)
3695 return 0;
3696 i++;
3697 filp->f_pos++;
3698@@ -915,7 +915,7 @@
3699 }
3700
3701 do {
3702- if (filldir(dirent, de->name, de->namelen, filp->f_pos, ino | de->low_ino) < 0)
3703+ if (filldir(dirent, de->name, de->namelen, filp->f_pos, ino | de->low_ino, de->mode >> 12) < 0)
3704 return 0;
3705 filp->f_pos++;
3706 de = de->next;
3707@@ -982,7 +982,7 @@
3708 pid /= 10;
3709 } while (pid);
3710
3711- if (filldir(dirent, buf+j, PROC_NUMBUF-j, filp->f_pos, ino) < 0)
3712+ if (filldir(dirent, buf+j, PROC_NUMBUF-j, filp->f_pos, ino, DT_DIR) < 0)
3713 break;
3714 filp->f_pos++;
3715 }
3716diff -urN lfs-ref/fs/qnx4/dir.c lfs/fs/qnx4/dir.c
3717--- lfs-ref/fs/qnx4/dir.c Thu May 4 13:00:40 2000
3718+++ lfs/fs/qnx4/dir.c Wed Sep 12 02:42:15 2001
3719@@ -61,7 +61,7 @@
3720 QNX4_INODES_PER_BLOCK +
3721 le->dl_inode_ndx;
3722 }
3723- if (filldir(dirent, de->di_fname, size, filp->f_pos, ino) < 0) {
3724+ if (filldir(dirent, de->di_fname, size, filp->f_pos, ino, DT_UNKNOWN) < 0) {
3725 brelse(bh);
3726 return 0;
3727 }
3728diff -urN lfs-ref/fs/read_write.c lfs/fs/read_write.c
3729--- lfs-ref/fs/read_write.c Fri Apr 20 22:31:20 2001
3730+++ lfs/fs/read_write.c Wed Sep 12 02:42:15 2001
3731@@ -48,7 +48,7 @@
3732
3733 asmlinkage off_t sys_lseek(unsigned int fd, off_t offset, unsigned int origin)
3734 {
3735- off_t retval;
3736+ off_t retval, oldpos;
3737 struct file * file;
3738 struct dentry * dentry;
3739 struct inode * inode;
3740@@ -62,9 +62,19 @@
3741 if (!(dentry = file->f_dentry) ||
3742 !(inode = dentry->d_inode))
3743 goto out_putf;
3744+ oldpos = file->f_pos;
3745 retval = -EINVAL;
3746 if (origin <= 2)
3747 retval = llseek(file, offset, origin);
3748+
3749+ /* Demand L-F-S compliance only from normal files,
3750+ thus raw devices can do whatever they please.. */
3751+ if (!(file->f_flags & O_LARGEFILE) &&
3752+ retval >= 0 && S_ISREG(inode->i_mode) &&
3753+ file->f_pos > 0x7fffffff) {
3754+ file->f_pos = oldpos;
3755+ retval = -EOVERFLOW;
3756+ }
3757 out_putf:
3758 fput(file);
3759 bad:
3760@@ -81,7 +91,7 @@
3761 struct file * file;
3762 struct dentry * dentry;
3763 struct inode * inode;
3764- loff_t offset;
3765+ loff_t offset, oldpos;
3766
3767 lock_kernel();
3768 retval = -EBADF;
3769@@ -96,6 +106,7 @@
3770 if (origin > 2)
3771 goto out_putf;
3772
3773+ oldpos = file->f_pos;
3774 offset = llseek(file, ((loff_t) offset_high << 32) | offset_low,
3775 origin);
3776
3777@@ -105,6 +116,14 @@
3778 if (!copy_to_user(result, &offset, sizeof(offset)))
3779 retval = 0;
3780 }
3781+ if (!(file->f_flags & O_LARGEFILE) && S_ISREG(inode->i_mode) &&
3782+ file->f_pos > 0x7fffffff) {
3783+ /* The target position isn't presentable without
3784+ O_LARGEFILE flag being set --> yield error, and
3785+ restore the file position. */
3786+ file->f_pos = oldpos;
3787+ retval = -EOVERFLOW;
3788+ }
3789 out_putf:
3790 fput(file);
3791 bad:
3792@@ -335,6 +354,7 @@
3793 ssize_t ret;
3794 struct file * file;
3795 ssize_t (*read)(struct file *, char *, size_t, loff_t *);
3796+ struct inode * inode;
3797
3798 lock_kernel();
3799
3800@@ -342,10 +362,13 @@
3801 file = fget(fd);
3802 if (!file)
3803 goto bad_file;
3804+
3805+ inode = file->f_dentry->d_inode;
3806+
3807 if (!(file->f_mode & FMODE_READ))
3808 goto out;
3809- ret = locks_verify_area(FLOCK_VERIFY_READ, file->f_dentry->d_inode,
3810- file, pos, count);
3811+
3812+ ret = locks_verify_area(FLOCK_VERIFY_READ, inode, file, pos, count);
3813 if (ret)
3814 goto out;
3815 ret = -EINVAL;
3816@@ -367,6 +390,7 @@
3817 ssize_t ret;
3818 struct file * file;
3819 ssize_t (*write)(struct file *, const char *, size_t, loff_t *);
3820+ struct inode * inode;
3821
3822 lock_kernel();
3823
3824@@ -376,8 +400,10 @@
3825 goto bad_file;
3826 if (!(file->f_mode & FMODE_WRITE))
3827 goto out;
3828- ret = locks_verify_area(FLOCK_VERIFY_WRITE, file->f_dentry->d_inode,
3829- file, pos, count);
3830+
3831+ inode = file->f_dentry->d_inode;
3832+
3833+ ret = locks_verify_area(FLOCK_VERIFY_WRITE, inode, file, pos, count);
3834 if (ret)
3835 goto out;
3836 ret = -EINVAL;
3837@@ -386,9 +412,9 @@
3838 if (pos < 0)
3839 goto out;
3840
3841- fs_down(&file->f_dentry->d_inode->i_sem);
3842+ fs_down(&inode->i_sem);
3843 ret = write(file, buf, count, &pos);
3844- fs_up(&file->f_dentry->d_inode->i_sem);
3845+ fs_up(&inode->i_sem);
3846
3847 out:
3848 fput(file);
3849diff -urN lfs-ref/fs/readdir.c lfs/fs/readdir.c
3850--- lfs-ref/fs/readdir.c Mon Jan 17 16:44:43 2000
3851+++ lfs/fs/readdir.c Wed Sep 12 02:42:15 2001
3852@@ -36,7 +36,7 @@
3853 int count;
3854 };
3855
3856-static int fillonedir(void * __buf, const char * name, int namlen, off_t offset, ino_t ino)
3857+static int fillonedir(void * __buf, const char * name, int namlen, off_t offset, ino_t ino, unsigned int d_type)
3858 {
3859 struct readdir_callback * buf = (struct readdir_callback *) __buf;
3860 struct old_linux_dirent * dirent;
3861@@ -118,7 +118,7 @@
3862 int error;
3863 };
3864
3865-static int filldir(void * __buf, const char * name, int namlen, off_t offset, ino_t ino)
3866+static int filldir(void * __buf, const char * name, int namlen, off_t offset, ino_t ino, unsigned int d_type)
3867 {
3868 struct linux_dirent * dirent;
3869 struct getdents_callback * buf = (struct getdents_callback *) __buf;
3870@@ -187,6 +187,123 @@
3871 lastdirent = buf.previous;
3872 if (lastdirent) {
3873 put_user(file->f_pos, &lastdirent->d_off);
3874+ error = count - buf.count;
3875+ }
3876+
3877+out_putf:
3878+ fput(file);
3879+out:
3880+ unlock_kernel();
3881+ return error;
3882+}
3883+
3884+
3885+/*
3886+ * And even better one including d_type field and 64bit d_ino and d_off.
3887+ */
3888+struct linux_dirent64 {
3889+ u64 d_ino;
3890+ s64 d_off;
3891+ unsigned short d_reclen;
3892+ unsigned char d_type;
3893+ char d_name[0];
3894+};
3895+
3896+#define ROUND_UP64(x) (((x)+sizeof(u64)-1) & ~(sizeof(u64)-1))
3897+
3898+struct getdents_callback64 {
3899+ struct linux_dirent64 * current_dir;
3900+ struct linux_dirent64 * previous;
3901+ int count;
3902+ int error;
3903+};
3904+
3905+static int filldir64(void * __buf, const char * name, int namlen, off_t offset,
3906+ ino_t ino, unsigned int d_type)
3907+{
3908+ struct linux_dirent64 * dirent, d;
3909+ struct getdents_callback64 * buf = (struct getdents_callback64 *) __buf;
3910+ int reclen = ROUND_UP64(NAME_OFFSET(dirent) + namlen + 1);
3911+
3912+ buf->error = -EINVAL; /* only used if we fail.. */
3913+ if (reclen > buf->count)
3914+ return -EINVAL;
3915+ dirent = buf->previous;
3916+ if (dirent) {
3917+#if BITS_PER_LONG < 64
3918+ d.d_off = offset;
3919+ copy_to_user(&dirent->d_off, &d.d_off, sizeof(d.d_off));
3920+#else
3921+ put_user(offset, &dirent->d_off);
3922+#endif
3923+ }
3924+ dirent = buf->current_dir;
3925+ buf->previous = dirent;
3926+ memset(&d, 0, NAME_OFFSET(&d));
3927+ d.d_ino = ino;
3928+ d.d_reclen = reclen;
3929+ d.d_type = d_type;
3930+ copy_to_user(dirent, &d, NAME_OFFSET(&d));
3931+ copy_to_user(dirent->d_name, name, namlen);
3932+ put_user(0, dirent->d_name + namlen);
3933+ ((char *) dirent) += reclen;
3934+ buf->current_dir = dirent;
3935+ buf->count -= reclen;
3936+ return 0;
3937+}
3938+
3939+asmlinkage int sys_getdents64(unsigned int fd, void * dirent, unsigned int count)
3940+{
3941+ struct file * file;
3942+ struct dentry * dentry;
3943+ struct inode * inode;
3944+ struct linux_dirent64 * lastdirent;
3945+ struct getdents_callback64 buf;
3946+ int error;
3947+
3948+ lock_kernel();
3949+ error = -EBADF;
3950+ file = fget(fd);
3951+ if (!file)
3952+ goto out;
3953+
3954+ dentry = file->f_dentry;
3955+ if (!dentry)
3956+ goto out_putf;
3957+
3958+ inode = dentry->d_inode;
3959+ if (!inode)
3960+ goto out_putf;
3961+
3962+ buf.current_dir = (struct linux_dirent64 *) dirent;
3963+ buf.previous = NULL;
3964+ buf.count = count;
3965+ buf.error = 0;
3966+
3967+ error = -ENOTDIR;
3968+ if (!file->f_op || !file->f_op->readdir)
3969+ goto out_putf;
3970+
3971+
3972+ /*
3973+ * Get the inode's semaphore to prevent changes
3974+ * to the directory while we read it.
3975+ */
3976+ down(&inode->i_sem);
3977+ error = file->f_op->readdir(file, &buf, filldir64);
3978+ up(&inode->i_sem);
3979+ if (error < 0)
3980+ goto out_putf;
3981+ error = buf.error;
3982+ lastdirent = buf.previous;
3983+ if (lastdirent) {
3984+#if BITS_PER_LONG < 64
3985+ s64 d_off;
3986+ d_off = file->f_pos;
3987+ copy_to_user(&lastdirent->d_off, &d_off, sizeof(d_off));
3988+#else
3989+ put_user(file->f_pos, &lastdirent->d_off);
3990+#endif
3991 error = count - buf.count;
3992 }
3993
3994diff -urN lfs-ref/fs/romfs/inode.c lfs/fs/romfs/inode.c
3995--- lfs-ref/fs/romfs/inode.c Thu May 4 13:00:40 2000
3996+++ lfs/fs/romfs/inode.c Wed Sep 12 02:42:15 2001
3997@@ -258,6 +258,10 @@
3998 return res;
3999 }
4000
4001+static unsigned char romfs_dtype_table[] = {
4002+ DT_UNKNOWN, DT_DIR, DT_REG, DT_LNK, DT_BLK, DT_CHR, DT_SOCK, DT_FIFO
4003+};
4004+
4005 static int
4006 romfs_readdir(struct file *filp, void *dirent, filldir_t filldir)
4007 {
4008@@ -302,7 +306,8 @@
4009 nextfh = ntohl(ri.next);
4010 if ((nextfh & ROMFH_TYPE) == ROMFH_HRD)
4011 ino = ntohl(ri.spec);
4012- if (filldir(dirent, fsname, j, offset, ino) < 0) {
4013+ if (filldir(dirent, fsname, j, offset, ino,
4014+ romfs_dtype_table[nextfh & ROMFH_TYPE]) < 0) {
4015 return stored;
4016 }
4017 stored++;
4018@@ -396,7 +401,7 @@
4019 buf = page_address(page);
4020 clear_bit(PG_uptodate, &page->flags);
4021 clear_bit(PG_error, &page->flags);
4022- offset = page->offset;
4023+ offset = pgoff2loff(page->index);
4024 if (offset < inode->i_size) {
4025 avail = inode->i_size-offset;
4026 readlen = min(avail, PAGE_SIZE);
4027diff -urN lfs-ref/fs/smbfs/cache.c lfs/fs/smbfs/cache.c
4028--- lfs-ref/fs/smbfs/cache.c Tue Sep 5 02:28:49 2000
4029+++ lfs/fs/smbfs/cache.c Wed Sep 12 02:42:15 2001
4030@@ -40,7 +40,7 @@
4031 struct cache_head * cachep;
4032
4033 VERBOSE("finding cache for %s/%s\n", DENTRY_PATH(dentry));
4034- cachep = (struct cache_head *) get_cached_page(inode, 0, 1);
4035+ cachep = (struct cache_head *) get_cached_page(inode, ulong2pgoff(0), 1);
4036 if (!cachep)
4037 goto out;
4038 if (cachep->valid)
4039@@ -61,9 +61,10 @@
4040 PARANOIA("cache %s/%s has existing block!\n",
4041 DENTRY_PATH(dentry));
4042 #endif
4043- offset = PAGE_SIZE + (i << PAGE_SHIFT);
4044- block = (struct cache_block *) get_cached_page(inode,
4045- offset, 0);
4046+ /* byte_offset = PAGE_SIZE + (i << PAGE_SHIFT); */
4047+ /* --> page_offset = 1 + i */
4048+ block = (struct cache_block *)
4049+ get_cached_page(inode, ulong2pgoff(i+1), 0);
4050 if (!block)
4051 goto out;
4052 index->block = block;
4053@@ -128,7 +129,7 @@
4054 struct inode * inode = get_cache_inode(cachep);
4055 struct cache_index * index;
4056 struct cache_block * block;
4057- unsigned long page_off;
4058+ pgoff_t page_off;
4059 unsigned int nent, offset, len = entry->len;
4060 unsigned int needed = len + sizeof(struct cache_entry);
4061
4062@@ -180,14 +181,15 @@
4063 */
4064 get_block:
4065 cachep->pages++;
4066- page_off = PAGE_SIZE + (cachep->idx << PAGE_SHIFT);
4067+ /* page_byte_off = PAGE_SIZE + (cachep->idx << PAGE_SHIFT); */
4068+ page_off = ulong2pgoff(1 + cachep->idx);
4069 block = (struct cache_block *) get_cached_page(inode, page_off, 1);
4070 if (block)
4071 {
4072 index->block = block;
4073 index->space = PAGE_SIZE;
4074 VERBOSE("inode=%p, pages=%d, block at %ld\n",
4075- inode, cachep->pages, page_off);
4076+ inode, cachep->pages, (u_long)pgoff2loff(page_off));
4077 goto add_entry;
4078 }
4079 /*
4080diff -urN lfs-ref/fs/smbfs/dir.c lfs/fs/smbfs/dir.c
4081--- lfs-ref/fs/smbfs/dir.c Mon Dec 11 16:58:03 2000
4082+++ lfs/fs/smbfs/dir.c Wed Sep 12 02:42:15 2001
4083@@ -91,12 +91,12 @@
4084 switch ((unsigned int) filp->f_pos)
4085 {
4086 case 0:
4087- if (filldir(dirent, ".", 1, 0, dir->i_ino) < 0)
4088+ if (filldir(dirent, ".", 1, 0, dir->i_ino, DT_DIR) < 0)
4089 goto out;
4090 filp->f_pos = 1;
4091 case 1:
4092 if (filldir(dirent, "..", 2, 1,
4093- dentry->d_parent->d_inode->i_ino) < 0)
4094+ dentry->d_parent->d_inode->i_ino, DT_DIR) < 0)
4095 goto out;
4096 filp->f_pos = 2;
4097 }
4098@@ -151,7 +151,7 @@
4099 }
4100
4101 if (filldir(dirent, entry->name, entry->len,
4102- filp->f_pos, entry->ino) < 0)
4103+ filp->f_pos, entry->ino, DT_UNKNOWN) < 0)
4104 break;
4105 filp->f_pos += 1;
4106 }
4107diff -urN lfs-ref/fs/smbfs/file.c lfs/fs/smbfs/file.c
4108--- lfs-ref/fs/smbfs/file.c Tue Sep 5 02:28:49 2000
4109+++ lfs/fs/smbfs/file.c Wed Sep 12 02:42:15 2001
4110@@ -15,6 +15,7 @@
4111 #include <linux/mm.h>
4112 #include <linux/malloc.h>
4113 #include <linux/pagemap.h>
4114+#include <linux/unistd.h>
4115
4116 #include <asm/uaccess.h>
4117 #include <asm/system.h>
4118@@ -47,15 +48,15 @@
4119 smb_readpage_sync(struct dentry *dentry, struct page *page)
4120 {
4121 char *buffer = (char *) page_address(page);
4122- unsigned long offset = page->offset;
4123+ loff_t loffset = pgoff2loff(page->index);
4124 int rsize = smb_get_rsize(server_from_dentry(dentry));
4125 int count = PAGE_SIZE;
4126 int result;
4127
4128 clear_bit(PG_error, &page->flags);
4129
4130- VERBOSE("file %s/%s, count=%d@%ld, rsize=%d\n",
4131- DENTRY_PATH(dentry), count, offset, rsize);
4132+ VERBOSE("file %s/%s, count=%d@%Ld, rsize=%d\n",
4133+ DENTRY_PATH(dentry), count, loffset, rsize);
4134 result = smb_open(dentry, SMB_O_RDONLY);
4135 if (result < 0)
4136 {
4137@@ -68,12 +69,12 @@
4138 if (count < rsize)
4139 rsize = count;
4140
4141- result = smb_proc_read(dentry, offset, rsize, buffer);
4142+ result = smb_proc_read(dentry, loffset, rsize, buffer);
4143 if (result < 0)
4144 goto io_error;
4145
4146 count -= result;
4147- offset += result;
4148+ loffset += result;
4149 buffer += result;
4150 dentry->d_inode->i_atime = CURRENT_TIME;
4151 if (result < rsize)
4152@@ -113,23 +114,36 @@
4153 * Offset is the data offset within the page.
4154 */
4155 static int
4156-smb_writepage_sync(struct dentry *dentry, struct page *page,
4157+smb_writepage_sync(struct file *file, struct page *page,
4158 unsigned long offset, unsigned int count)
4159 {
4160+ struct dentry * dentry = file->f_dentry;
4161 struct inode *inode = dentry->d_inode;
4162 u8 *buffer = (u8 *) page_address(page) + offset;
4163 int wsize = smb_get_wsize(server_from_dentry(dentry));
4164 int result, written = 0;
4165+ loff_t loffset = pgoff2loff(page->index) + offset;
4166+
4167+ VERBOSE("file %s/%s, count=%d@%Ld, wsize=%d\n",
4168+ DENTRY_PATH(dentry), count, loffset, wsize);
4169
4170- offset += page->offset;
4171- VERBOSE("file %s/%s, count=%d@%ld, wsize=%d\n",
4172- DENTRY_PATH(dentry), count, offset, wsize);
4173+ if (!(file->f_flags & O_LARGEFILE)) {
4174+ if (loffset >= 0x7fffffffULL)
4175+ return -EFBIG;
4176+ if (loffset + count > 0x7fffffffULL)
4177+ count = 0x7fffffff - loffset;
4178+ }
4179+
4180+ if (loffset >= 0xffffffffULL) /* 4G-1 ??? Or 2G-1 ??? */
4181+ return -EFBIG;
4182+ if ((loffset + count) > 0xffffffffULL)
4183+ count = 0xffffffffULL - loffset;
4184
4185 do {
4186 if (count < wsize)
4187 wsize = count;
4188
4189- result = smb_proc_write(dentry, offset, wsize, buffer);
4190+ result = smb_proc_write(dentry, loffset, wsize, buffer);
4191 if (result < 0)
4192 break;
4193 /* N.B. what if result < wsize?? */
4194@@ -138,29 +152,27 @@
4195 printk(KERN_DEBUG "short write, wsize=%d, result=%d\n",
4196 wsize, result);
4197 #endif
4198- buffer += wsize;
4199- offset += wsize;
4200+ buffer += wsize;
4201+ loffset += wsize;
4202 written += wsize;
4203- count -= wsize;
4204+ count -= wsize;
4205 /*
4206 * Update the inode now rather than waiting for a refresh.
4207 */
4208 inode->i_mtime = inode->i_atime = CURRENT_TIME;
4209- if (offset > inode->i_size)
4210- inode->i_size = offset;
4211+ if (loffset > inode->i_size)
4212+ inode->i_size = loffset;
4213 inode->u.smbfs_i.cache_valid |= SMB_F_LOCALWRITE;
4214 } while (count);
4215 return written ? written : result;
4216 }
4217
4218 /*
4219- * Write a page to the server. This will be used for NFS swapping only
4220- * (for now), and we currently do this synchronously only.
4221+ * Write a page to the server.
4222 */
4223 static int
4224 smb_writepage(struct file *file, struct page *page)
4225 {
4226- struct dentry *dentry = file->f_dentry;
4227 int result;
4228
4229 #ifdef SMBFS_PARANOIA
4230@@ -169,7 +181,7 @@
4231 #endif
4232 set_bit(PG_locked, &page->flags);
4233 atomic_inc(&page->count);
4234- result = smb_writepage_sync(dentry, page, 0, PAGE_SIZE);
4235+ result = smb_writepage_sync(file, page, 0, PAGE_SIZE);
4236 smb_unlock_page(page);
4237 free_page(page_address(page));
4238 return result;
4239@@ -180,10 +192,10 @@
4240 {
4241 struct dentry *dentry = file->f_dentry;
4242
4243- DEBUG1("(%s/%s %d@%ld, sync=%d)\n",
4244- DENTRY_PATH(dentry), count, page->offset+offset, sync);
4245+ DEBUG1("(%s/%s %d@%Ld, sync=%d)\n",
4246+ DENTRY_PATH(dentry), count, pgoff2loff(page->index)+offset, sync);
4247
4248- return smb_writepage_sync(dentry, page, offset, count);
4249+ return smb_writepage_sync(file, page, offset, count);
4250 }
4251
4252 static ssize_t
4253@@ -192,8 +204,8 @@
4254 struct dentry * dentry = file->f_dentry;
4255 ssize_t status;
4256
4257- VERBOSE("file %s/%s, count=%lu@%lu\n", DENTRY_PATH(dentry),
4258- (unsigned long) count, (unsigned long) *ppos);
4259+ VERBOSE("file %s/%s, count=%lu@%Lu\n", DENTRY_PATH(dentry),
4260+ (unsigned long) count, *ppos);
4261
4262 status = smb_revalidate_inode(dentry);
4263 if (status)
4264@@ -242,8 +254,8 @@
4265 struct dentry * dentry = file->f_dentry;
4266 ssize_t result;
4267
4268- VERBOSE("file %s/%s, count=%lu@%lu, pages=%ld\n", DENTRY_PATH(dentry),
4269- (unsigned long) count, (unsigned long) *ppos,
4270+ VERBOSE("file %s/%s, count=%lu@%Lu, pages=%ld\n", DENTRY_PATH(dentry),
4271+ (unsigned long) count, *ppos,
4272 dentry->d_inode->i_nrpages);
4273
4274 result = smb_revalidate_inode(dentry);
4275@@ -261,8 +273,8 @@
4276 if (count > 0)
4277 {
4278 result = generic_file_write(file, buf, count, ppos);
4279- VERBOSE("pos=%ld, size=%ld, mtime=%ld, atime=%ld\n",
4280- (long) file->f_pos, dentry->d_inode->i_size,
4281+ VERBOSE("pos=%Ld, size=%Ld, mtime=%ld, atime=%ld\n",
4282+ file->f_pos, dentry->d_inode->i_size,
4283 dentry->d_inode->i_mtime, dentry->d_inode->i_atime);
4284 }
4285 out:
4286diff -urN lfs-ref/fs/smbfs/proc.c lfs/fs/smbfs/proc.c
4287--- lfs-ref/fs/smbfs/proc.c Wed Sep 12 02:05:57 2001
4288+++ lfs/fs/smbfs/proc.c Wed Sep 12 02:42:15 2001
4289@@ -1084,13 +1084,16 @@
4290 file-id would not be valid after a reconnection. */
4291
4292 int
4293-smb_proc_read(struct dentry *dentry, off_t offset, int count, char *data)
4294+smb_proc_read(struct dentry *dentry, loff_t offset, int count, char *data)
4295 {
4296 struct smb_sb_info *server = server_from_dentry(dentry);
4297 __u16 returned_count, data_len;
4298 unsigned char *buf;
4299 int result;
4300
4301+ if (offset > 0xffffffff)
4302+ return -EIO;
4303+
4304 smb_lock_server(server);
4305 smb_setup_header(server, SMBread, 5, 0);
4306 buf = server->packet;
4307@@ -1133,13 +1136,16 @@
4308 }
4309
4310 int
4311-smb_proc_write(struct dentry *dentry, off_t offset, int count, const char *data)
4312+smb_proc_write(struct dentry *dentry, loff_t offset, int count, const char *data)
4313 {
4314 struct smb_sb_info *server = server_from_dentry(dentry);
4315 int result;
4316 __u8 *p;
4317
4318- VERBOSE("file %s/%s, count=%d@%ld, packet_size=%d\n",
4319+ if (offset > 0xffffffff)
4320+ return -EIO;
4321+
4322+ VERBOSE("file %s/%s, count=%d@%Ld, packet_size=%d\n",
4323 DENTRY_PATH(dentry), count, offset, server->packet_size);
4324
4325 smb_lock_server(server);
4326diff -urN lfs-ref/fs/stat.c lfs/fs/stat.c
4327--- lfs-ref/fs/stat.c Mon Jan 17 16:44:43 2000
4328+++ lfs/fs/stat.c Wed Sep 12 02:42:15 2001
4329@@ -48,6 +48,10 @@
4330 tmp.st_uid = inode->i_uid;
4331 tmp.st_gid = inode->i_gid;
4332 tmp.st_rdev = kdev_t_to_nr(inode->i_rdev);
4333+#if BITS_PER_LONG == 32
4334+ if (inode->i_size > 0x7fffffff)
4335+ return -EOVERFLOW;
4336+#endif
4337 tmp.st_size = inode->i_size;
4338 tmp.st_atime = inode->i_atime;
4339 tmp.st_mtime = inode->i_mtime;
4340@@ -70,6 +74,10 @@
4341 tmp.st_uid = inode->i_uid;
4342 tmp.st_gid = inode->i_gid;
4343 tmp.st_rdev = kdev_t_to_nr(inode->i_rdev);
4344+#if BITS_PER_LONG == 32
4345+ if (inode->i_size > 0x7fffffff)
4346+ return -EOVERFLOW;
4347+#endif
4348 tmp.st_size = inode->i_size;
4349 tmp.st_atime = inode->i_atime;
4350 tmp.st_mtime = inode->i_mtime;
4351@@ -280,3 +288,127 @@
4352 unlock_kernel();
4353 return error;
4354 }
4355+
4356+
4357+/* ---------- LFS-64 ----------- */
4358+#if !defined(__alpha__)
4359+
4360+static long cp_new_stat64(struct inode * inode, struct stat64 * statbuf)
4361+{
4362+ struct stat64 tmp;
4363+ unsigned int blocks, indirect;
4364+
4365+ memset(&tmp, 0, sizeof(tmp));
4366+ tmp.st_dev = kdev_t_to_nr(inode->i_dev);
4367+ tmp.st_ino = inode->i_ino;
4368+#ifdef STAT64_HAS_BROKEN_ST_INO
4369+ tmp.__st_ino = inode->i_ino;
4370+#endif
4371+ tmp.st_mode = inode->i_mode;
4372+ tmp.st_nlink = inode->i_nlink;
4373+ tmp.st_uid = inode->i_uid;
4374+ tmp.st_gid = inode->i_gid;
4375+ tmp.st_rdev = kdev_t_to_nr(inode->i_rdev);
4376+ tmp.st_atime = inode->i_atime;
4377+ tmp.st_mtime = inode->i_mtime;
4378+ tmp.st_ctime = inode->i_ctime;
4379+ tmp.st_size = inode->i_size;
4380+/*
4381+ * st_blocks and st_blksize are approximated with a simple algorithm if
4382+ * they aren't supported directly by the filesystem. The minix and msdos
4383+ * filesystems don't keep track of blocks, so they would either have to
4384+ * be counted explicitly (by delving into the file itself), or by using
4385+ * this simple algorithm to get a reasonable (although not 100% accurate)
4386+ * value.
4387+ */
4388+
4389+/*
4390+ * Use minix fs values for the number of direct and indirect blocks. The
4391+ * count is now exact for the minix fs except that it counts zero blocks.
4392+ * Everything is in units of BLOCK_SIZE until the assignment to
4393+ * tmp.st_blksize.
4394+ */
4395+#define D_B 7
4396+#define I_B (BLOCK_SIZE / sizeof(unsigned short))
4397+
4398+ if (!inode->i_blksize) {
4399+ blocks = (tmp.st_size + BLOCK_SIZE - 1) >> BLOCK_SIZE_BITS;
4400+ if (blocks > D_B) {
4401+ indirect = (blocks - D_B + I_B - 1) / I_B;
4402+ blocks += indirect;
4403+ if (indirect > 1) {
4404+ indirect = (indirect - 1 + I_B - 1) / I_B;
4405+ blocks += indirect;
4406+ if (indirect > 1)
4407+ blocks++;
4408+ }
4409+ }
4410+ tmp.st_blocks = (BLOCK_SIZE / 512) * blocks;
4411+ tmp.st_blksize = BLOCK_SIZE;
4412+ } else {
4413+ tmp.st_blocks = inode->i_blocks;
4414+ tmp.st_blksize = inode->i_blksize;
4415+ }
4416+ return copy_to_user(statbuf,&tmp,sizeof(tmp)) ? -EFAULT : 0;
4417+}
4418+
4419+asmlinkage long sys_stat64(char * filename, struct stat64 * statbuf, long flags)
4420+{
4421+ struct dentry * dentry;
4422+ int error;
4423+
4424+ lock_kernel();
4425+ dentry = namei(filename);
4426+
4427+ error = PTR_ERR(dentry);
4428+ if (!IS_ERR(dentry)) {
4429+ error = do_revalidate(dentry);
4430+ if (!error)
4431+ error = cp_new_stat64(dentry->d_inode, statbuf);
4432+
4433+ dput(dentry);
4434+ }
4435+ unlock_kernel();
4436+ return error;
4437+}
4438+
4439+asmlinkage long sys_lstat64(char * filename, struct stat64 * statbuf, long flags)
4440+{
4441+ struct dentry * dentry;
4442+ int error;
4443+
4444+ lock_kernel();
4445+ dentry = lnamei(filename);
4446+
4447+ error = PTR_ERR(dentry);
4448+ if (!IS_ERR(dentry)) {
4449+ error = do_revalidate(dentry);
4450+ if (!error)
4451+ error = cp_new_stat64(dentry->d_inode, statbuf);
4452+
4453+ dput(dentry);
4454+ }
4455+ unlock_kernel();
4456+ return error;
4457+}
4458+
4459+asmlinkage long sys_fstat64(unsigned long fd, struct stat64 * statbuf, long flags)
4460+{
4461+ struct file * f;
4462+ int err = -EBADF;
4463+
4464+ lock_kernel();
4465+ f = fget(fd);
4466+ if (f) {
4467+ struct dentry * dentry = f->f_dentry;
4468+
4469+ err = do_revalidate(dentry);
4470+ if (!err)
4471+ err = cp_new_stat64(dentry->d_inode, statbuf);
4472+ fput(f);
4473+ }
4474+ unlock_kernel();
4475+ return err;
4476+}
4477+
4478+#endif /* LFS-64 */
4479diff -urN lfs-ref/fs/sysv/dir.c lfs/fs/sysv/dir.c
4480--- lfs-ref/fs/sysv/dir.c Mon Jan 17 16:44:43 2000
4481+++ lfs/fs/sysv/dir.c Wed Sep 12 02:42:15 2001
4482@@ -100,7 +100,7 @@
4483 inode->i_ino, (off_t) filp->f_pos, sde.inode);
4484
4485 i = strnlen(sde.name, SYSV_NAMELEN);
4486- if (filldir(dirent, sde.name, i, filp->f_pos, sde.inode) < 0) {
4487+ if (filldir(dirent, sde.name, i, filp->f_pos, sde.inode, DT_UNKNOWN) < 0) {
4488 brelse(bh);
4489 return 0;
4490 }
4491diff -urN lfs-ref/fs/sysv/file.c lfs/fs/sysv/file.c
4492--- lfs-ref/fs/sysv/file.c Mon Jan 17 16:44:43 2000
4493+++ lfs/fs/sysv/file.c Wed Sep 12 02:42:15 2001
4494@@ -207,7 +207,7 @@
4495 {
4496 struct inode * inode = filp->f_dentry->d_inode;
4497 struct super_block * sb = inode->i_sb;
4498- off_t pos;
4499+ loff_t pos;
4500 ssize_t written, c;
4501 struct buffer_head * bh;
4502 char * p;
4503@@ -232,6 +232,21 @@
4504 else
4505 pos = *ppos;
4506 written = 0;
4507+
4508+ /* L-F-S spec 2.2.1.27: */
4509+ if (!(filp->f_flags & O_LARGEFILE)) {
4510+ if (pos >= 0x7fffffffULL) /* pos@2G forbidden */
4511+ return -EFBIG;
4512+
4513+ if (pos + count > 0x7fffffffULL)
4514+ /* Write only until end of allowed region */
4515+ count = 0x7fffffffULL - pos;
4516+ }
4517+ if (pos >= 0xffffffffULL)
4518+ return -EFBIG; /* Only up to 4G-1! */
4519+ if ((pos + count) > 0xffffffffULL)
4520+ count = 0xffffffffULL - pos;
4521+
4522 while (written<count) {
4523 bh = sysv_getblk (inode, pos >> sb->sv_block_size_bits, 1);
4524 if (!bh) {
4525diff -urN lfs-ref/fs/ufs/balloc.c lfs/fs/ufs/balloc.c
4526--- lfs-ref/fs/ufs/balloc.c Mon Jan 17 16:44:43 2000
4527+++ lfs/fs/ufs/balloc.c Wed Sep 12 02:42:15 2001
4528@@ -660,9 +660,9 @@
4529 struct ufs_sb_private_info * uspi;
4530 struct ufs_super_block_first * usb1;
4531 struct ufs_cylinder_group * ucg;
4532- unsigned start, length, location, result;
4533- unsigned possition, fragsize, blockmap, mask;
4534- unsigned swab;
4535+ unsigned int start, length, location, result;
4536+ unsigned int possition, fragsize, blockmap, mask;
4537+ unsigned int swab;
4538
4539 UFSD(("ENTER, cg %u, goal %u, count %u\n", ucpi->c_cgx, goal, count))
4540
4541@@ -676,7 +676,7 @@
4542 else
4543 start = ucpi->c_frotor >> 3;
4544
4545- length = howmany(uspi->s_fpg, 8) - start;
4546+ length = ((uspi->s_fpg + 7) >> 3) - start;
4547 location = ubh_scanc(UCPI_UBH, ucpi->c_freeoff + start, length,
4548 (uspi->s_fpb == 8) ? ufs_fragtable_8fpb : ufs_fragtable_other,
4549 1 << (count - 1 + (uspi->s_fpb & 7)));
4550diff -urN lfs-ref/fs/ufs/dir.c lfs/fs/ufs/dir.c
4551--- lfs-ref/fs/ufs/dir.c Thu May 4 13:00:40 2000
4552+++ lfs/fs/ufs/dir.c Wed Sep 12 02:42:15 2001
4553@@ -15,6 +15,7 @@
4554
4555 #include <linux/fs.h>
4556 #include <linux/ufs_fs.h>
4557+#include <linux/unistd.h>
4558
4559 #include "swab.h"
4560 #include "util.h"
4561@@ -124,11 +125,14 @@
4562 * not the directory has been modified
4563 * during the copy operation. */
4564 unsigned long version = inode->i_version;
4565+ unsigned char d_type = DT_UNKNOWN;
4566
4567 UFSD(("filldir(%s,%u)\n", de->d_name, SWAB32(de->d_ino)))
4568 UFSD(("namlen %u\n", ufs_get_de_namlen(de)))
4569+ if ((flags & UFS_DE_MASK) == UFS_DE_44BSD)
4570+ d_type = de->d_u.d_44.d_type;
4571 error = filldir(dirent, de->d_name, ufs_get_de_namlen(de),
4572- filp->f_pos, SWAB32(de->d_ino));
4573+ filp->f_pos, SWAB32(de->d_ino), d_type);
4574 if (error)
4575 break;
4576 if (version != inode->i_version)
4577@@ -170,7 +174,7 @@
4578 error_msg = "inode out of bounds";
4579
4580 if (error_msg != NULL)
4581- ufs_error (sb, function, "bad entry in directory #%lu, size %lu: %s - "
4582+ ufs_error (sb, function, "bad entry in directory #%lu, size %Lu: %s - "
4583 "offset=%lu, inode=%lu, reclen=%d, namlen=%d",
4584 dir->i_ino, dir->i_size, error_msg, offset,
4585 (unsigned long) SWAB32(de->d_ino),
4586diff -urN lfs-ref/fs/ufs/file.c lfs/fs/ufs/file.c
4587--- lfs-ref/fs/ufs/file.c Sun Apr 2 21:07:49 2000
4588+++ lfs/fs/ufs/file.c Wed Sep 12 02:42:15 2001
4589@@ -140,7 +140,7 @@
4590 loff_t *ppos )
4591 {
4592 struct inode * inode = filp->f_dentry->d_inode;
4593- __u32 pos;
4594+ loff_t pos;
4595 long block;
4596 int offset;
4597 int written, c;
4598@@ -177,11 +177,14 @@
4599 return -EINVAL;
4600 }
4601
4602- /* Check for overflow.. */
4603- if (pos > (__u32) (pos + count)) {
4604- count = ~pos; /* == 0xFFFFFFFF - pos */
4605- if (!count)
4606+ /* L-F-S spec 2.2.1.27: */
4607+ if (!(filp->f_flags & O_LARGEFILE)) {
4608+ if (pos >= 0x7fffffffULL) /* pos@2G forbidden */
4609 return -EFBIG;
4610+
4611+ if (pos + count > 0x7fffffffULL)
4612+ /* Write only until end of allowed region */
4613+ count = 0x7fffffffULL - pos;
4614 }
4615
4616 /*
4617diff -urN lfs-ref/fs/ufs/inode.c lfs/fs/ufs/inode.c
4618--- lfs-ref/fs/ufs/inode.c Tue Jun 13 03:48:15 2000
4619+++ lfs/fs/ufs/inode.c Wed Sep 12 02:42:15 2001
4620@@ -54,7 +54,7 @@
4621 {
4622 unsigned swab = inode->i_sb->u.ufs_sb.s_swab;
4623 printk("ino %lu mode 0%6.6o nlink %d uid %d uid32 %u"
4624- " gid %d gid32 %u size %lu blocks %lu\n",
4625+ " gid %d gid32 %u size %Lu blocks %lu\n",
4626 inode->i_ino, inode->i_mode, inode->i_nlink,
4627 inode->i_uid, inode->u.ufs_i.i_uid, inode->i_gid,
4628 inode->u.ufs_i.i_gid, inode->i_size, inode->i_blocks);
4629@@ -213,13 +213,14 @@
4630 if (!create)
4631 return NULL;
4632 limit = current->rlim[RLIMIT_FSIZE].rlim_cur;
4633- if (limit < RLIM_INFINITY) {
4634+ if (limit != RLIM_INFINITY) {
4635 limit >>= sb->s_blocksize_bits;
4636 if (new_fragment >= limit) {
4637 send_sig(SIGXFSZ, current, 0);
4638 return NULL;
4639 }
4640 }
4641+
4642 lastblock = ufs_fragstoblks (lastfrag);
4643 lastblockoff = ufs_fragnum (lastfrag);
4644 /*
4645@@ -321,7 +322,8 @@
4646 brelse (result);
4647 goto repeat;
4648 }
4649- if (!create || new_fragment >= (current->rlim[RLIMIT_FSIZE].rlim_cur >> sb->s_blocksize)) {
4650+ if (!create || (current->rlim[RLIMIT_FSIZE].rlim_cur != RLIM_INFINITY &&
4651+ new_fragment >= (current->rlim[RLIMIT_FSIZE].rlim_cur >> sb->s_blocksize))) {
4652 brelse (bh);
4653 *err = -EFBIG;
4654 return NULL;
4655@@ -497,13 +499,10 @@
4656 }
4657
4658 /*
4659- * Linux i_size can be 32 on some architectures. We will mark
4660- * big files as read only and let user access first 32 bits.
4661+ * Linux i_size used to be 32 bits on some architectures.
4662+ * These days we allow access to the entire file as is..
4663 */
4664- inode->u.ufs_i.i_size = SWAB64(ufs_inode->ui_size);
4665- inode->i_size = (off_t) inode->u.ufs_i.i_size;
4666- if (sizeof(off_t) == 4 && (inode->u.ufs_i.i_size >> 32))
4667- inode->i_size = (__u32)-1;
4668+ inode->i_size = SWAB64(ufs_inode->ui_size);
4669
4670 inode->i_atime = SWAB32(ufs_inode->ui_atime.tv_sec);
4671 inode->i_ctime = SWAB32(ufs_inode->ui_ctime.tv_sec);
4672@@ -516,7 +515,7 @@
4673 inode->u.ufs_i.i_gen = SWAB32(ufs_inode->ui_gen);
4674 inode->u.ufs_i.i_shadow = SWAB32(ufs_inode->ui_u3.ui_sun.ui_shadow);
4675 inode->u.ufs_i.i_oeftflag = SWAB32(ufs_inode->ui_u3.ui_sun.ui_oeftflag);
4676- inode->u.ufs_i.i_lastfrag = howmany (inode->i_size, uspi->s_fsize);
4677+ inode->u.ufs_i.i_lastfrag = (inode->i_size + uspi->s_fsize -1) >> uspi->s_fshift;
4678
4679 if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
4680 inode->i_rdev = to_kdev_t(SWAB32(ufs_inode->ui_u2.ui_addr.ui_db[0]));
4681diff -urN lfs-ref/fs/ufs/super.c lfs/fs/ufs/super.c
4682--- lfs-ref/fs/ufs/super.c Mon Jan 17 16:44:43 2000
4683+++ lfs/fs/ufs/super.c Wed Sep 12 02:42:15 2001
4684@@ -328,7 +328,7 @@
4685 * on the device.
4686 */
4687 size = uspi->s_cssize;
4688- blks = howmany(size, uspi->s_fsize);
4689+ blks = (size + uspi->s_fsize-1) >> uspi->s_fshift;
4690 base = space = kmalloc(size, GFP_KERNEL);
4691 if (!base)
4692 goto failed;
4693@@ -405,7 +405,7 @@
4694 uspi = sb->u.ufs_sb.s_uspi;
4695
4696 size = uspi->s_cssize;
4697- blks = howmany(size, uspi->s_fsize);
4698+ blks = (size + uspi->s_fsize-1) >> uspi->s_fshift;
4699 base = space = (char*) sb->u.ufs_sb.s_csp[0];
4700 for (i = 0; i < blks; i += uspi->s_fpb) {
4701 size = uspi->s_bsize;
4702diff -urN lfs-ref/fs/ufs/truncate.c lfs/fs/ufs/truncate.c
4703--- lfs-ref/fs/ufs/truncate.c Mon Jan 17 16:44:43 2000
4704+++ lfs/fs/ufs/truncate.c Wed Sep 12 02:42:15 2001
4705@@ -59,8 +59,8 @@
4706 * Linus
4707 */
4708
4709-#define DIRECT_BLOCK howmany (inode->i_size, uspi->s_bsize)
4710-#define DIRECT_FRAGMENT howmany (inode->i_size, uspi->s_fsize)
4711+#define DIRECT_BLOCK ((inode->i_size + uspi->s_bsize -1) >> uspi->s_bshift)
4712+#define DIRECT_FRAGMENT ((inode->i_size + uspi->s_fsize -1) >> uspi->s_fshift)
4713
4714 static int ufs_trunc_direct (struct inode * inode)
4715 {
4716@@ -194,7 +194,7 @@
4717 }
4718
4719
4720-static int ufs_trunc_indirect (struct inode * inode, unsigned offset, u32 * p)
4721+static int ufs_trunc_indirect (struct inode * inode, u_long offset, u32 * p)
4722 {
4723 struct super_block * sb;
4724 struct ufs_sb_private_info * uspi;
4725@@ -297,7 +297,7 @@
4726 struct super_block * sb;
4727 struct ufs_sb_private_info * uspi;
4728 struct ufs_buffer_head * dind_bh;
4729- unsigned i, tmp, dindirect_block;
4730+ unsigned int i, tmp, dindirect_block;
4731 u32 * dind;
4732 int retry = 0;
4733 unsigned swab;
4734@@ -308,8 +308,8 @@
4735 swab = sb->u.ufs_sb.s_swab;
4736 uspi = sb->u.ufs_sb.s_uspi;
4737
4738- dindirect_block = (DIRECT_BLOCK > offset)
4739- ? ((DIRECT_BLOCK - offset) / uspi->s_apb) : 0;
4740+ dindirect_block = ((DIRECT_BLOCK > offset) ?
4741+ ((DIRECT_BLOCK - offset) >> uspi->s_apbshift) : 0);
4742 retry = 0;
4743
4744 tmp = SWAB32(*p);
4745@@ -379,7 +379,7 @@
4746 retry = 0;
4747
4748 tindirect_block = (DIRECT_BLOCK > (UFS_NDADDR + uspi->s_apb + uspi->s_2apb))
4749- ? ((DIRECT_BLOCK - UFS_NDADDR - uspi->s_apb - uspi->s_2apb) / uspi->s_2apb) : 0;
4750+ ? ((DIRECT_BLOCK - UFS_NDADDR - uspi->s_apb - uspi->s_2apb) >> uspi->s_2apbshift) : 0;
4751 p = inode->u.ufs_i.i_u1.i_data + UFS_TIND_BLOCK;
4752 if (!(tmp = SWAB32(*p)))
4753 return 0;
4754@@ -467,7 +467,8 @@
4755 }
4756 }
4757 inode->i_mtime = inode->i_ctime = CURRENT_TIME;
4758- inode->u.ufs_i.i_lastfrag = howmany (inode->i_size, uspi->s_fsize);
4759+ inode->u.ufs_i.i_lastfrag =
4760+ (inode->i_size + uspi->s_fsize -1) >> uspi->s_fshift;
4761 mark_inode_dirty(inode);
4762 UFSD(("EXIT\n"))
4763 }
4764diff -urN lfs-ref/fs/ufs/util.h lfs/fs/ufs/util.h
4765--- lfs-ref/fs/ufs/util.h Sat May 20 00:06:21 2000
4766+++ lfs/fs/ufs/util.h Wed Sep 12 02:42:15 2001
4767@@ -14,7 +14,6 @@
4768 * some useful macros
4769 */
4770 #define in_range(b,first,len) ((b)>=(first)&&(b)<(first)+(len))
4771-#define howmany(x,y) (((x)+(y)-1)/(y))
4772 #define min(x,y) ((x)<(y)?(x):(y))
4773 #define max(x,y) ((x)>(y)?(x):(y))
4774
4775diff -urN lfs-ref/fs/umsdos/dir.c lfs/fs/umsdos/dir.c
4776--- lfs-ref/fs/umsdos/dir.c Thu May 4 13:00:40 2000
4777+++ lfs/fs/umsdos/dir.c Wed Sep 12 02:42:15 2001
4778@@ -90,7 +90,7 @@
4779 if (d->count == 0) {
4780 PRINTK ((KERN_DEBUG "dir_once :%.*s: offset %Ld\n",
4781 len, name, offset));
4782- ret = d->filldir (d->dirbuf, name, len, offset, ino);
4783+ ret = d->filldir (d->dirbuf, name, len, offset, ino, DT_UNKNOWN);
4784 d->stop = ret < 0;
4785 d->count = 1;
4786 }
4787@@ -136,7 +136,7 @@
4788
4789 Printk ((KERN_WARNING "umsdos_readdir_x: pseudo_root thing UMSDOS_SPECIAL_DIRFPOS\n"));
4790 if (filldir (dirbuf, "DOS", 3,
4791- UMSDOS_SPECIAL_DIRFPOS, UMSDOS_ROOT_INO) == 0) {
4792+ UMSDOS_SPECIAL_DIRFPOS, UMSDOS_ROOT_INO, DT_DIR) == 0) {
4793 filp->f_pos++;
4794 }
4795 goto out_end;
4796@@ -255,7 +255,7 @@
4797 if (inode != pseudo_root &&
4798 (internal_read || !(entry.flags & UMSDOS_HIDDEN))) {
4799 if (filldir (dirbuf, entry.name, entry.name_len,
4800- cur_f_pos, inode->i_ino) < 0) {
4801+ cur_f_pos, inode->i_ino, DT_UNKNOWN) < 0) {
4802 new_filp.f_pos = cur_f_pos;
4803 }
4804 Printk(("umsdos_readdir_x: got %s/%s, ino=%ld\n",
4805diff -urN lfs-ref/fs/umsdos/rdir.c lfs/fs/umsdos/rdir.c
4806--- lfs-ref/fs/umsdos/rdir.c Thu May 4 13:00:40 2000
4807+++ lfs/fs/umsdos/rdir.c Wed Sep 12 02:42:15 2001
4808@@ -33,7 +33,8 @@
4809 const char *name,
4810 int name_len,
4811 off_t offset,
4812- ino_t ino)
4813+ ino_t ino,
4814+ unsigned int d_type)
4815 {
4816 int ret = 0;
4817 struct RDIR_FILLDIR *d = (struct RDIR_FILLDIR *) buf;
4818@@ -48,11 +49,11 @@
4819 /* Make sure the .. entry points back to the pseudo_root */
4820 ino = pseudo_root->i_ino;
4821 }
4822- ret = d->filldir (d->dirbuf, name, name_len, offset, ino);
4823+ ret = d->filldir (d->dirbuf, name, name_len, offset, ino, DT_UNKNOWN);
4824 }
4825 } else {
4826 /* Any DOS directory */
4827- ret = d->filldir (d->dirbuf, name, name_len, offset, ino);
4828+ ret = d->filldir (d->dirbuf, name, name_len, offset, ino, DT_UNKNOWN);
4829 }
4830 return ret;
4831 }
4832diff -urN lfs-ref/include/asm-alpha/fcntl.h lfs/include/asm-alpha/fcntl.h
4833--- lfs-ref/include/asm-alpha/fcntl.h Mon Jan 17 16:44:43 2000
4834+++ lfs/include/asm-alpha/fcntl.h Wed Sep 12 02:42:15 2001
4835@@ -20,6 +20,7 @@
4836 #define O_DIRECT 040000 /* direct disk access - should check with OSF/1 */
4837 #define O_DIRECTORY 0100000 /* must be a directory */
4838 #define O_NOFOLLOW 0200000 /* don't follow links */
4839+#define O_LARGEFILE 0400000 /* will be set by the kernel on every open */
4840
4841 #define F_DUPFD 0 /* dup */
4842 #define F_GETFD 1 /* get f_flags */
4843@@ -61,5 +62,9 @@
4844 __kernel_off_t l_len;
4845 __kernel_pid_t l_pid;
4846 };
4847+
4848+#ifdef __KERNEL__
4849+#define flock64 flock
4850+#endif
4851
4852 #endif
4853diff -urN lfs-ref/include/asm-alpha/unistd.h lfs/include/asm-alpha/unistd.h
4854--- lfs-ref/include/asm-alpha/unistd.h Mon Dec 11 16:58:03 2000
4855+++ lfs/include/asm-alpha/unistd.h Wed Sep 12 02:42:15 2001
4856@@ -314,6 +314,7 @@
4857 #define __NR_pivot_root 374 /* implemented in 2.3 */
4858 #define __NR_mincore 375 /* implemented in 2.3 */
4859 #define __NR_pciconfig_iobase 376
4860+#define __NR_getdents64 377
4861
4862 #if defined(__GNUC__)
4863
4864diff -urN lfs-ref/include/asm-arm/fcntl.h lfs/include/asm-arm/fcntl.h
4865--- lfs-ref/include/asm-arm/fcntl.h Mon Jan 17 16:44:44 2000
4866+++ lfs/include/asm-arm/fcntl.h Wed Sep 12 02:42:15 2001
4867@@ -18,6 +18,8 @@
4868 #define FASYNC 020000 /* fcntl, for BSD compatibility */
4869 #define O_DIRECTORY 040000 /* must be a directory */
4870 #define O_NOFOLLOW 0100000 /* don't follow links */
4871+#define O_DIRECT 0200000 /* direct disk access hint - currently ignored */
4872+#define O_LARGEFILE 0400000
4873
4874 #define F_DUPFD 0 /* dup */
4875 #define F_GETFD 1 /* get f_flags */
4876@@ -33,6 +35,10 @@
4877 #define F_SETSIG 10 /* for sockets. */
4878 #define F_GETSIG 11 /* for sockets. */
4879
4880+#define F_GETLK64 12 /* using 'struct flock64' */
4881+#define F_SETLK64 13
4882+#define F_SETLKW64 14
4883+
4884 /* for F_[GET|SET]FL */
4885 #define FD_CLOEXEC 1 /* actually anything with low bit set goes */
4886
4887@@ -58,6 +64,14 @@
4888 off_t l_start;
4889 off_t l_len;
4890 pid_t l_pid;
4891+};
4892+
4893+struct flock64 {
4894+ short l_type;
4895+ short l_whence;
4896+ loff_t l_start;
4897+ loff_t l_len;
4898+ pid_t l_pid;
4899 };
4900
4901 #endif
4902diff -urN lfs-ref/include/asm-arm/stat.h lfs/include/asm-arm/stat.h
4903--- lfs-ref/include/asm-arm/stat.h Mon Jan 17 16:44:44 2000
4904+++ lfs/include/asm-arm/stat.h Wed Sep 12 02:42:15 2001
4905@@ -38,4 +38,5 @@
4906 unsigned long __unused5;
4907 };
4908
4909+/* Someone please add a glibc/arm compatible stat64 struct here. */
4910 #endif
4911diff -urN lfs-ref/include/asm-arm/unistd.h lfs/include/asm-arm/unistd.h
4912--- lfs-ref/include/asm-arm/unistd.h Mon Dec 11 16:58:04 2000
4913+++ lfs/include/asm-arm/unistd.h Wed Sep 12 02:42:15 2001
4914@@ -198,6 +198,13 @@
4915 /* 188 reserved */
4916 /* 189 reserved */
4917 #define __NR_vfork (__NR_SYSCALL_BASE+190)
4918+/* #define __NR_getrlimit (__NR_SYSCALL_BASE+191) */
4919+#define __NR_mmap2 (__NR_SYSCALL_BASE+192)
4920+#define __NR_truncate64 (__NR_SYSCALL_BASE+193)
4921+#define __NR_ftruncate64 (__NR_SYSCALL_BASE+194)
4922+#define __NR_stat64 (__NR_SYSCALL_BASE+195)
4923+#define __NR_lstat64 (__NR_SYSCALL_BASE+196)
4924+#define __NR_fstat64 (__NR_SYSCALL_BASE+197)
4925
4926 #define __sys2(x) #x
4927 #define __sys1(x) __sys2(x)
4928diff -urN lfs-ref/include/asm-i386/fcntl.h lfs/include/asm-i386/fcntl.h
4929--- lfs-ref/include/asm-i386/fcntl.h Mon Jan 17 16:44:44 2000
4930+++ lfs/include/asm-i386/fcntl.h Wed Sep 12 02:42:15 2001
4931@@ -35,6 +35,10 @@
4932 #define F_SETSIG 10 /* for sockets. */
4933 #define F_GETSIG 11 /* for sockets. */
4934
4935+#define F_GETLK64 12 /* using 'struct flock64' */
4936+#define F_SETLK64 13
4937+#define F_SETLKW64 14
4938+
4939 /* for F_[GET|SET]FL */
4940 #define FD_CLOEXEC 1 /* actually anything with low bit set goes */
4941
4942@@ -60,6 +64,14 @@
4943 off_t l_start;
4944 off_t l_len;
4945 pid_t l_pid;
4946+};
4947+
4948+struct flock64 {
4949+ short l_type;
4950+ short l_whence;
4951+ loff_t l_start;
4952+ loff_t l_len;
4953+ pid_t l_pid;
4954 };
4955
4956 #endif
4957diff -urN lfs-ref/include/asm-i386/stat.h lfs/include/asm-i386/stat.h
4958--- lfs-ref/include/asm-i386/stat.h Mon Jan 17 16:44:44 2000
4959+++ lfs/include/asm-i386/stat.h Wed Sep 12 02:42:15 2001
4960@@ -38,4 +38,41 @@
4961 unsigned long __unused5;
4962 };
4963
4964+/* This matches struct stat64 in glibc2.1, hence the absolutely
4965+ * insane amounts of padding around dev_t's.
4966+ */
4967+struct stat64 {
4968+ unsigned short st_dev;
4969+ unsigned char __pad0[10];
4970+
4971+#define STAT64_HAS_BROKEN_ST_INO 1
4972+ unsigned long __st_ino;
4973+
4974+ unsigned int st_mode;
4975+ unsigned int st_nlink;
4976+
4977+ unsigned long st_uid;
4978+ unsigned long st_gid;
4979+
4980+ unsigned short st_rdev;
4981+ unsigned char __pad3[10];
4982+
4983+ long long st_size;
4984+ unsigned long st_blksize;
4985+
4986+ unsigned long st_blocks; /* Number 512-byte blocks allocated. */
4987+ unsigned long __pad4; /* future possible st_blocks high bits */
4988+
4989+ unsigned long st_atime;
4990+ unsigned long __pad5;
4991+
4992+ unsigned long st_mtime;
4993+ unsigned long __pad6;
4994+
4995+ unsigned long st_ctime;
4996+ unsigned long __pad7; /* will be high 32 bits of ctime someday */
4997+
4998+ unsigned long long st_ino;
4999+};
5000+
5001 #endif
5002diff -urN lfs-ref/include/asm-i386/unistd.h lfs/include/asm-i386/unistd.h
5003--- lfs-ref/include/asm-i386/unistd.h Mon Jan 17 16:44:44 2000
5004+++ lfs/include/asm-i386/unistd.h Wed Sep 12 02:42:15 2001
5005@@ -80,7 +80,7 @@
5006 #define __NR_sigpending 73
5007 #define __NR_sethostname 74
5008 #define __NR_setrlimit 75
5009-#define __NR_getrlimit 76
5010+#define __NR_getrlimit 76 /* Back compatible 2Gig limited rlimit */
5011 #define __NR_getrusage 77
5012 #define __NR_gettimeofday 78
5013 #define __NR_settimeofday 79
5014@@ -195,8 +195,42 @@
5015 #define __NR_getpmsg 188 /* some people actually want streams */
5016 #define __NR_putpmsg 189 /* some people actually want streams */
5017 #define __NR_vfork 190
5018+/* #define __NR_ugetrlimit 191 SuS compliant getrlimit */
5019+#define __NR_mmap2 192
5020+#define __NR_truncate64 193
5021+#define __NR_ftruncate64 194
5022+#define __NR_stat64 195
5023+#define __NR_lstat64 196
5024+#define __NR_fstat64 197
5025+#if 0 /* 2.3.x */
5026+#define __NR_lchown32 198
5027+#define __NR_getuid32 199
5028+#define __NR_getgid32 200
5029+#define __NR_geteuid32 201
5030+#define __NR_getegid32 202
5031+#define __NR_setreuid32 203
5032+#define __NR_setregid32 204
5033+#define __NR_getgroups32 205
5034+#define __NR_setgroups32 206
5035+#define __NR_fchown32 207
5036+#define __NR_setresuid32 208
5037+#define __NR_getresuid32 209
5038+#define __NR_setresgid32 210
5039+#define __NR_getresgid32 211
5040+#define __NR_chown32 212
5041+#define __NR_setuid32 213
5042+#define __NR_setgid32 214
5043+#define __NR_setfsuid32 215
5044+#define __NR_setfsgid32 216
5045+#define __NR_pivot_root 217
5046+#define __NR_mincore 218
5047+#define __NR_madvise 219
5048+#define __NR_madvise1 219 /* delete when C lib stub is removed */
5049+#endif
5050+#define __NR_getdents64 220
5051+#define __NR_fcntl64 221
5052
5053-/* user-visible error numbers are in the range -1 - -122: see <asm-i386/errno.h> */
5054+/* user-visible error numbers are in the range -1 - -124: see <asm-i386/errno.h> */
5055
5056 #define __syscall_return(type, res) \
5057 do { \
5058@@ -269,6 +303,19 @@
5059 : "=a" (__res) \
5060 : "0" (__NR_##name),"b" ((long)(arg1)),"c" ((long)(arg2)), \
5061 "d" ((long)(arg3)),"S" ((long)(arg4)),"D" ((long)(arg5))); \
5062+__syscall_return(type,__res); \
5063+}
5064+
5065+#define _syscall6(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4, \
5066+ type5,arg5,type6,arg6) \
5067+type name (type1 arg1,type2 arg2,type3 arg3,type4 arg4,type5 arg5,type6 arg6) \
5068+{ \
5069+long __res; \
5070+__asm__ volatile ("push %%ebp ; movl %%eax,%%ebp ; movl %1,%%eax ; int $0x80 ; pop %%ebp" \
5071+ : "=a" (__res) \
5072+ : "i" (__NR_##name),"b" ((long)(arg1)),"c" ((long)(arg2)), \
5073+ "d" ((long)(arg3)),"S" ((long)(arg4)),"D" ((long)(arg5)), \
5074+ "0" ((long)(arg6))); \
5075 __syscall_return(type,__res); \
5076 }
5077
5078diff -urN lfs-ref/include/asm-m68k/fcntl.h lfs/include/asm-m68k/fcntl.h
5079--- lfs-ref/include/asm-m68k/fcntl.h Mon Jan 17 16:44:44 2000
5080+++ lfs/include/asm-m68k/fcntl.h Wed Sep 12 02:42:15 2001
5081@@ -33,6 +33,10 @@
5082 #define F_SETSIG 10 /* for sockets. */
5083 #define F_GETSIG 11 /* for sockets. */
5084
5085+#define F_GETLK64 12 /* using 'struct flock64' */
5086+#define F_SETLK64 13
5087+#define F_SETLKW64 14
5088+
5089 /* for F_[GET|SET]FL */
5090 #define FD_CLOEXEC 1 /* actually anything with low bit set goes */
5091
5092@@ -58,6 +62,14 @@
5093 off_t l_start;
5094 off_t l_len;
5095 pid_t l_pid;
5096+};
5097+
5098+struct flock64 {
5099+ short l_type;
5100+ short l_whence;
5101+ loff_t l_start;
5102+ loff_t l_len;
5103+ pid_t l_pid;
5104 };
5105
5106 #endif /* _M68K_FCNTL_H */
5107diff -urN lfs-ref/include/asm-m68k/stat.h lfs/include/asm-m68k/stat.h
5108--- lfs-ref/include/asm-m68k/stat.h Mon Jan 17 16:44:45 2000
5109+++ lfs/include/asm-m68k/stat.h Wed Sep 12 02:42:15 2001
5110@@ -38,4 +38,8 @@
5111 unsigned long __unused5;
5112 };
5113
5114+/* stat64 struct goes here -- someone please make
5115+ * it mesh with whatever glibc does in userland on
5116+ * m68k's.
5117+ */
5118 #endif /* _M68K_STAT_H */
5119diff -urN lfs-ref/include/asm-m68k/unistd.h lfs/include/asm-m68k/unistd.h
5120--- lfs-ref/include/asm-m68k/unistd.h Mon Jan 17 16:44:45 2000
5121+++ lfs/include/asm-m68k/unistd.h Wed Sep 12 02:42:15 2001
5122@@ -80,7 +80,7 @@
5123 #define __NR_sigpending 73
5124 #define __NR_sethostname 74
5125 #define __NR_setrlimit 75
5126-#define __NR_getrlimit 76
5127+#define __NR_getrlimit 76
5128 #define __NR_getrusage 77
5129 #define __NR_gettimeofday 78
5130 #define __NR_settimeofday 79
5131@@ -194,6 +194,13 @@
5132 #define __NR_getpmsg 188 /* some people actually want streams */
5133 #define __NR_putpmsg 189 /* some people actually want streams */
5134 #define __NR_vfork 190
5135+/* #define __NR_getrlimit 191 */
5136+#define __NR_mmap2 192
5137+#define __NR_truncate64 193
5138+#define __NR_ftruncate64 194
5139+#define __NR_stat64 195
5140+#define __NR_lstat64 196
5141+#define __NR_fstat64 197
5142
5143 /* user-visible error numbers are in the range -1 - -122: see
5144 <asm-m68k/errno.h> */
5145diff -urN lfs-ref/include/asm-mips/fcntl.h lfs/include/asm-mips/fcntl.h
5146--- lfs-ref/include/asm-mips/fcntl.h Mon Jan 17 16:44:45 2000
5147+++ lfs/include/asm-mips/fcntl.h Wed Sep 12 02:42:15 2001
5148@@ -44,6 +44,10 @@
5149 #define F_SETSIG 10 /* for sockets. */
5150 #define F_GETSIG 11 /* for sockets. */
5151
5152+#define F_GETLK64 33 /* using 'struct flock64' */
5153+#define F_SETLK64 34
5154+#define F_SETLKW64 35
5155+
5156 /* for F_[GET|SET]FL */
5157 #define FD_CLOEXEC 1 /* actually anything with low bit set goes */
5158
5159@@ -72,5 +76,13 @@
5160 __kernel_pid_t l_pid;
5161 long pad[4]; /* ZZZZZZZZZZZZZZZZZZZZZZZZZZ */
5162 } flock_t;
5163+
5164+typedef struct flock64 {
5165+ short l_type;
5166+ short l_whence;
5167+ loff_t l_start;
5168+ loff_t l_len;
5169+ pid_t l_pid;
5170+} flock64_t;
5171
5172 #endif /* __ASM_MIPS_FCNTL_H */
5173diff -urN lfs-ref/include/asm-ppc/fcntl.h lfs/include/asm-ppc/fcntl.h
5174--- lfs-ref/include/asm-ppc/fcntl.h Mon Jan 17 16:44:45 2000
5175+++ lfs/include/asm-ppc/fcntl.h Wed Sep 12 02:42:15 2001
5176@@ -18,6 +18,8 @@
5177 #define FASYNC 020000 /* fcntl, for BSD compatibility */
5178 #define O_DIRECTORY 040000 /* must be a directory */
5179 #define O_NOFOLLOW 0100000 /* don't follow links */
5180+#define O_LARGEFILE 0200000
5181+#define O_DIRECT 0400000 /* direct disk access hint - currently ignored */
5182
5183 #define F_DUPFD 0 /* dup */
5184 #define F_GETFD 1 /* get f_flags */
5185@@ -33,6 +35,10 @@
5186 #define F_SETSIG 10 /* for sockets. */
5187 #define F_GETSIG 11 /* for sockets. */
5188
5189+#define F_GETLK64 12 /* using 'struct flock64' */
5190+#define F_SETLK64 13
5191+#define F_SETLKW64 14
5192+
5193 /* for F_[GET|SET]FL */
5194 #define FD_CLOEXEC 1 /* actually anything with low bit set goes */
5195
5196@@ -64,6 +70,14 @@
5197 off_t l_start;
5198 off_t l_len;
5199 pid_t l_pid;
5200+};
5201+
5202+struct flock64 {
5203+ short l_type;
5204+ short l_whence;
5205+ loff_t l_start;
5206+ loff_t l_len;
5207+ pid_t l_pid;
5208 };
5209
5210 #endif
5211diff -urN lfs-ref/include/asm-ppc/stat.h lfs/include/asm-ppc/stat.h
5212--- lfs-ref/include/asm-ppc/stat.h Mon Jan 17 16:44:45 2000
5213+++ lfs/include/asm-ppc/stat.h Wed Sep 12 02:42:15 2001
5214@@ -37,4 +37,29 @@
5215 unsigned long __unused5;
5216 };
5217
5218+/* This matches struct stat64 in glibc2.1.
5219+ */
5220+struct stat64 {
5221+ unsigned long long st_dev; /* Device. */
5222+ unsigned long long st_ino; /* File serial number. */
5223+ unsigned int st_mode; /* File mode. */
5224+ unsigned int st_nlink; /* Link count. */
5225+ unsigned int st_uid; /* User ID of the file's owner. */
5226+ unsigned int st_gid; /* Group ID of the file's group. */
5227+ unsigned long long st_rdev; /* Device number, if device. */
5228+ unsigned short int __pad2;
5229+ long long st_size; /* Size of file, in bytes. */
5230+ long st_blksize; /* Optimal block size for I/O. */
5231+
5232+ long long st_blocks; /* Number 512-byte blocks allocated. */
5233+ long st_atime; /* Time of last access. */
5234+ unsigned long int __unused1;
5235+ long st_mtime; /* Time of last modification. */
5236+ unsigned long int __unused2;
5237+ long st_ctime; /* Time of last status change. */
5238+ unsigned long int __unused3;
5239+ unsigned long int __unused4;
5240+ unsigned long int __unused5;
5241+};
5242+
5243 #endif
5244diff -urN lfs-ref/include/asm-ppc/unistd.h lfs/include/asm-ppc/unistd.h
5245--- lfs-ref/include/asm-ppc/unistd.h Mon Dec 11 16:58:05 2000
5246+++ lfs/include/asm-ppc/unistd.h Wed Sep 12 02:42:15 2001
5247@@ -194,11 +194,18 @@
5248 #define __NR_getpmsg 187 /* some people actually want streams */
5249 #define __NR_putpmsg 188 /* some people actually want streams */
5250 #define __NR_vfork 189
5251-
5252+#define __NR_mmap2 192
5253+#define __NR_truncate64 193
5254+#define __NR_ftruncate64 194
5255+#define __NR_stat64 195
5256+#define __NR_lstat64 196
5257+#define __NR_fstat64 197
5258 #define __NR_pciconfig_read 198
5259 #define __NR_pciconfig_write 199
5260 #define __NR_pciconfig_iobase 200
5261 #define __NR_multiplexer 201
5262+#define __NR_getdents64 202
5263+#define __NR_fcntl64 203
5264
5265 #define __NR(n) #n
5266
5267diff -urN lfs-ref/include/asm-sparc/fcntl.h lfs/include/asm-sparc/fcntl.h
5268--- lfs-ref/include/asm-sparc/fcntl.h Mon Jan 17 16:44:46 2000
5269+++ lfs/include/asm-sparc/fcntl.h Wed Sep 12 02:42:15 2001
5270@@ -19,6 +19,7 @@
5271 #define O_NOCTTY 0x8000 /* not fcntl */
5272 #define O_DIRECTORY 0x10000 /* must be a directory */
5273 #define O_NOFOLLOW 0x20000 /* don't follow links */
5274+#define O_LARGEFILE 0x40000 /* LFS */
5275
5276 #define F_DUPFD 0 /* dup */
5277 #define F_GETFD 1 /* get f_flags */
5278@@ -32,6 +33,9 @@
5279 #define F_SETLKW 9
5280 #define F_SETSIG 10 /* for sockets. */
5281 #define F_GETSIG 11 /* for sockets. */
5282+#define F_GETLK64 12
5283+#define F_SETLK64 13
5284+#define F_SETLKW64 14
5285
5286 /* for F_[GET|SET]FL */
5287 #define FD_CLOEXEC 1 /* actually anything with low bit set goes */
5288@@ -57,6 +61,15 @@
5289 short l_whence;
5290 off_t l_start;
5291 off_t l_len;
5292+ pid_t l_pid;
5293+ short __unused;
5294+};
5295+
5296+struct flock64 {
5297+ short l_type;
5298+ short l_whence;
5299+ loff_t l_start;
5300+ loff_t l_len;
5301 pid_t l_pid;
5302 short __unused;
5303 };
5304diff -urN lfs-ref/include/asm-sparc/stat.h lfs/include/asm-sparc/stat.h
5305--- lfs-ref/include/asm-sparc/stat.h Mon Jan 17 16:44:46 2000
5306+++ lfs/include/asm-sparc/stat.h Wed Sep 12 02:42:15 2001
5307@@ -1,4 +1,4 @@
5308-/* $Id$ */
5309+/* $Id$ */
5310 #ifndef _SPARC_STAT_H
5311 #define _SPARC_STAT_H
5312
5313@@ -36,6 +36,42 @@
5314 off_t st_blksize;
5315 off_t st_blocks;
5316 unsigned long __unused4[2];
5317+};
5318+
5319+struct stat64 {
5320+ unsigned char __pad0[6];
5321+ unsigned short st_dev;
5322+
5323+ unsigned long long st_ino;
5324+
5325+ unsigned int st_mode;
5326+ unsigned int st_nlink;
5327+
5328+ unsigned int st_uid;
5329+ unsigned int st_gid;
5330+
5331+ unsigned char __pad2[6];
5332+ unsigned short st_rdev;
5333+
5334+ unsigned char __pad3[8];
5335+
5336+ long long st_size;
5337+ unsigned int st_blksize;
5338+
5339+ unsigned char __pad4[8];
5340+ unsigned int st_blocks;
5341+
5342+ unsigned int st_atime;
5343+ unsigned int __unused1;
5344+
5345+ unsigned int st_mtime;
5346+ unsigned int __unused2;
5347+
5348+ unsigned int st_ctime;
5349+ unsigned int __unused3;
5350+
5351+ unsigned int __unused4;
5352+ unsigned int __unused5;
5353 };
5354
5355 #endif
5356diff -urN lfs-ref/include/asm-sparc/unistd.h lfs/include/asm-sparc/unistd.h
5357--- lfs-ref/include/asm-sparc/unistd.h Fri Apr 20 22:31:20 2001
5358+++ lfs/include/asm-sparc/unistd.h Wed Sep 12 02:42:15 2001
5359@@ -71,14 +71,14 @@
5360 /* #define __NR_mctl 53 SunOS specific */
5361 #define __NR_ioctl 54 /* Common */
5362 #define __NR_reboot 55 /* Common */
5363-/* #define __NR_ni_syscall 56 ENOSYS under SunOS */
5364+#define __NR_mmap2 56 /* Linux sparc32 Specific */
5365 #define __NR_symlink 57 /* Common */
5366 #define __NR_readlink 58 /* Common */
5367 #define __NR_execve 59 /* Common */
5368 #define __NR_umask 60 /* Common */
5369 #define __NR_chroot 61 /* Common */
5370 #define __NR_fstat 62 /* Common */
5371-/* #define __NR_ni_syscall 63 ENOSYS under SunOS */
5372+#define __NR_fstat64 63 /* Linux sparc32 Specific */
5373 #define __NR_getpagesize 64 /* Common */
5374 #define __NR_msync 65 /* Common in newer 1.3.x revs... */
5375 #define __NR_vfork 66 /* Common */
5376@@ -92,14 +92,14 @@
5377 #define __NR_mprotect 74 /* Common */
5378 /* #define __NR_madvise 75 SunOS Specific */
5379 #define __NR_vhangup 76 /* Common */
5380-/* #define __NR_ni_syscall 77 ENOSYS under SunOS */
5381+#define __NR_truncate64 77 /* Linux sparc32 Specific */
5382 /* #define __NR_mincore 78 SunOS Specific */
5383 #define __NR_getgroups 79 /* Common */
5384 #define __NR_setgroups 80 /* Common */
5385 #define __NR_getpgrp 81 /* Common */
5386 /* #define __NR_setpgrp 82 setpgid, same difference... */
5387 #define __NR_setitimer 83 /* Common */
5388-/* #define __NR_ni_syscall 84 ENOSYS under SunOS */
5389+#define __NR_ftruncate64 84 /* Linux sparc32 Specific */
5390 #define __NR_swapon 85 /* Common */
5391 #define __NR_getitimer 86 /* Common */
5392 /* #define __NR_gethostname 87 SunOS Specific */
5393@@ -147,14 +147,14 @@
5394 #define __NR_truncate 129 /* Common */
5395 #define __NR_ftruncate 130 /* Common */
5396 #define __NR_flock 131 /* Common */
5397-/* #define __NR_ni_syscall 132 ENOSYS under SunOS */
5398+#define __NR_lstat64 132 /* Linux sparc32 Specific */
5399 #define __NR_sendto 133 /* Common */
5400 #define __NR_shutdown 134 /* Common */
5401 #define __NR_socketpair 135 /* Common */
5402 #define __NR_mkdir 136 /* Common */
5403 #define __NR_rmdir 137 /* Common */
5404 #define __NR_utimes 138 /* SunOS Specific */
5405-/* #define __NR_ni_syscall 139 ENOSYS under SunOS */
5406+#define __NR_stat64 139 /* Linux sparc32 Specific */
5407 /* #define __NR_adjtime 140 SunOS Specific */
5408 #define __NR_getpeername 141 /* Common */
5409 /* #define __NR_gethostid 142 SunOS Specific */
5410@@ -169,8 +169,8 @@
5411 /* #define __NR_getmsg 151 SunOS Specific */
5412 /* #define __NR_putmsg 152 SunOS Specific */
5413 #define __NR_poll 153 /* Common */
5414-/* #define __NR_getdents64 154 Linux Sparc32 Specific */
5415-/* #define __NR_fcntl64 155 Linux Sparc32 Specific */
5416+#define __NR_getdents64 154 /* Linux Sparc32 Specific */
5417+#define __NR_fcntl64 155 /* Linux Sparc32 Specific */
5418 /* #define __NR_getdirentries 156 SunOS Specific */
5419 #define __NR_statfs 157 /* Common */
5420 #define __NR_fstatfs 158 /* Common */
5421diff -urN lfs-ref/include/asm-sparc64/fcntl.h lfs/include/asm-sparc64/fcntl.h
5422--- lfs-ref/include/asm-sparc64/fcntl.h Mon Jan 17 16:44:46 2000
5423+++ lfs/include/asm-sparc64/fcntl.h Wed Sep 12 02:42:15 2001
5424@@ -19,6 +19,7 @@
5425 #define O_NOCTTY 0x8000 /* not fcntl */
5426 #define O_DIRECTORY 0x10000 /* must be a directory */
5427 #define O_NOFOLLOW 0x20000 /* don't follow links */
5428+#define O_LARGEFILE 0x40000
5429
5430 #define F_DUPFD 0 /* dup */
5431 #define F_GETFD 1 /* get f_flags */
5432@@ -32,6 +33,11 @@
5433 #define F_SETLKW 9
5434 #define F_SETSIG 10 /* for sockets. */
5435 #define F_GETSIG 11 /* for sockets. */
5436+#ifdef __KERNEL__
5437+#define F_GETLK64 12
5438+#define F_SETLK64 13
5439+#define F_SETLKW64 14
5440+#endif
5441
5442 /* for F_[GET|SET]FL */
5443 #define FD_CLOEXEC 1 /* actually anything with low bit set goes */
5444@@ -58,7 +64,6 @@
5445 off_t l_start;
5446 off_t l_len;
5447 pid_t l_pid;
5448- short __unused;
5449 };
5450
5451 #ifdef __KERNEL__
5452@@ -70,6 +75,17 @@
5453 __kernel_pid_t32 l_pid;
5454 short __unused;
5455 };
5456+
5457+struct flock32_64 {
5458+ short l_type;
5459+ short l_whence;
5460+ __kernel_loff_t32 l_start;
5461+ __kernel_loff_t32 l_len;
5462+ __kernel_pid_t32 l_pid;
5463+ short __unused;
5464+};
5465+
5466+#define flock64 flock
5467 #endif
5468
5469 #endif /* !(_SPARC64_FCNTL_H) */
5470diff -urN lfs-ref/include/asm-sparc64/stat.h lfs/include/asm-sparc64/stat.h
5471--- lfs-ref/include/asm-sparc64/stat.h Fri Dec 22 17:22:30 2000
5472+++ lfs/include/asm-sparc64/stat.h Wed Sep 12 02:42:15 2001
5473@@ -1,4 +1,4 @@
5474-/* $Id$ */
5475+/* $Id$ */
5476 #ifndef _SPARC64_STAT_H
5477 #define _SPARC64_STAT_H
5478
5479@@ -41,5 +41,46 @@
5480 off_t st_blocks;
5481 unsigned long __unused4[2];
5482 };
5483+
5484+#ifdef __KERNEL__
5485+/* This is sparc32 stat64 structure. */
5486+
5487+struct stat64 {
5488+ unsigned char __pad0[6];
5489+ unsigned short st_dev;
5490+
5491+ unsigned long long st_ino;
5492+
5493+ unsigned int st_mode;
5494+ unsigned int st_nlink;
5495+
5496+ unsigned int st_uid;
5497+ unsigned int st_gid;
5498+
5499+ unsigned char __pad2[6];
5500+ unsigned short st_rdev;
5501+
5502+ unsigned char __pad3[8];
5503+
5504+ long long st_size;
5505+ unsigned int st_blksize;
5506+
5507+ unsigned char __pad4[8];
5508+ unsigned int st_blocks;
5509+
5510+ unsigned int st_atime;
5511+ unsigned int __unused1;
5512+
5513+ unsigned int st_mtime;
5514+ unsigned int __unused2;
5515+
5516+ unsigned int st_ctime;
5517+ unsigned int __unused3;
5518+
5519+ unsigned int __unused4;
5520+ unsigned int __unused5;
5521+};
5522+
5523+#endif
5524
5525 #endif
5526diff -urN lfs-ref/include/asm-sparc64/unistd.h lfs/include/asm-sparc64/unistd.h
5527--- lfs-ref/include/asm-sparc64/unistd.h Fri Apr 20 22:31:20 2001
5528+++ lfs/include/asm-sparc64/unistd.h Wed Sep 12 02:42:15 2001
5529@@ -71,14 +71,14 @@
5530 /* #define __NR_mctl 53 SunOS specific */
5531 #define __NR_ioctl 54 /* Common */
5532 #define __NR_reboot 55 /* Common */
5533-/* #define __NR_ni_syscall 56 ENOSYS under SunOS */
5534+/* #define __NR_mmap2 56 Linux sparc32 Specific */
5535 #define __NR_symlink 57 /* Common */
5536 #define __NR_readlink 58 /* Common */
5537 #define __NR_execve 59 /* Common */
5538 #define __NR_umask 60 /* Common */
5539 #define __NR_chroot 61 /* Common */
5540 #define __NR_fstat 62 /* Common */
5541-/* #define __NR_ni_syscall 63 ENOSYS under SunOS */
5542+/* #define __NR_fstat64 63 Linux sparc32 Specific */
5543 #define __NR_getpagesize 64 /* Common */
5544 #define __NR_msync 65 /* Common in newer 1.3.x revs... */
5545 #define __NR_vfork 66 /* Common */
5546@@ -92,14 +92,14 @@
5547 #define __NR_mprotect 74 /* Common */
5548 /* #define __NR_madvise 75 SunOS Specific */
5549 #define __NR_vhangup 76 /* Common */
5550-/* #define __NR_ni_syscall 77 ENOSYS under SunOS */
5551+/* #define __NR_truncate64 77 Linux sparc32 Specific */
5552 /* #define __NR_mincore 78 SunOS Specific */
5553 #define __NR_getgroups 79 /* Common */
5554 #define __NR_setgroups 80 /* Common */
5555 #define __NR_getpgrp 81 /* Common */
5556 /* #define __NR_setpgrp 82 setpgid, same difference... */
5557 #define __NR_setitimer 83 /* Common */
5558-/* #define __NR_ni_syscall 84 ENOSYS under SunOS */
5559+/* #define __NR_ftruncate64 84 Linux sparc32 Specific */
5560 #define __NR_swapon 85 /* Common */
5561 #define __NR_getitimer 86 /* Common */
5562 /* #define __NR_gethostname 87 SunOS Specific */
5563@@ -147,19 +147,19 @@
5564 #define __NR_truncate 129 /* Common */
5565 #define __NR_ftruncate 130 /* Common */
5566 #define __NR_flock 131 /* Common */
5567-/* #define __NR_ni_syscall 132 ENOSYS under SunOS */
5568+/* #define __NR_lstat64 132 Linux sparc32 Specific */
5569 #define __NR_sendto 133 /* Common */
5570 #define __NR_shutdown 134 /* Common */
5571 #define __NR_socketpair 135 /* Common */
5572 #define __NR_mkdir 136 /* Common */
5573 #define __NR_rmdir 137 /* Common */
5574 #define __NR_utimes 138 /* SunOS Specific */
5575-/* #define __NR_ni_syscall 139 ENOSYS under SunOS */
5576+/* #define __NR_stat64 139 Linux sparc32 Specific */
5577 /* #define __NR_adjtime 140 SunOS Specific */
5578 #define __NR_getpeername 141 /* Common */
5579 /* #define __NR_gethostid 142 SunOS Specific */
5580 /* #define __NR_ni_syscall 143 ENOSYS under SunOS */
5581-#define __NR_getrlimit 144 /* Common */
5582+#define __NR_getrlimit 144 /* Common */
5583 #define __NR_setrlimit 145 /* Common */
5584 /* #define __NR_killpg 146 SunOS Specific */
5585 #define __NR_prctl 147 /* ENOSYS under SunOS */
5586diff -urN lfs-ref/include/linux/dirent.h lfs/include/linux/dirent.h
5587--- lfs-ref/include/linux/dirent.h Tue May 25 00:49:30 1999
5588+++ lfs/include/linux/dirent.h Wed Sep 12 02:42:15 2001
5589@@ -8,4 +8,12 @@
5590 char d_name[256]; /* We must not include limits.h! */
5591 };
5592
5593+struct dirent64 {
5594+ __u64 d_ino;
5595+ __s64 d_off;
5596+ unsigned short d_reclen;
5597+ unsigned char d_type;
5598+ char d_name[256];
5599+};
5600+
5601 #endif
5602diff -urN lfs-ref/include/linux/ext2_fs_i.h lfs/include/linux/ext2_fs_i.h
5603--- lfs-ref/include/linux/ext2_fs_i.h Mon Dec 11 16:58:05 2000
5604+++ lfs/include/linux/ext2_fs_i.h Wed Sep 12 02:42:15 2001
5605@@ -35,7 +35,6 @@
5606 __u32 i_next_alloc_goal;
5607 __u32 i_prealloc_block;
5608 __u32 i_prealloc_count;
5609- __u32 i_high_size;
5610 int i_new_inode:1; /* Is a freshly allocated inode */
5611 };
5612
5613diff -urN lfs-ref/include/linux/fs.h lfs/include/linux/fs.h
5614--- lfs-ref/include/linux/fs.h Wed Sep 12 02:39:58 2001
5615+++ lfs/include/linux/fs.h Wed Sep 12 02:42:15 2001
5616@@ -266,6 +266,25 @@
5617 #define buffer_page(bh) (mem_map + MAP_NR((bh)->b_data))
5618 #define touch_buffer(bh) set_bit(PG_referenced, &buffer_page(bh)->flags)
5619
5620+/* log of base-2 for filesystem uses, in case their super-blocks
5621+ don't have the shift counts readily calculated.. -- presuming
5622+ the divisors in question are power-of-two values! */
5623+static int fslog2(unsigned long val) __attribute__ ((const));
5624+static __inline__ int fslog2(unsigned long val)
5625+{
5626+ int i;
5627+ for (i = 0; val != 0; ++i, val >>= 1) {
5628+ if (val & 1) return i;
5629+ }
5630+ return 0;
5631+}
5632+
5633+static int off_t_presentable(loff_t) __attribute((const));
5634+static __inline__ int off_t_presentable(loff_t loff)
5635+{
5636+ return loff >= 0 && loff <= (~0UL >> 1);
5637+}
5638+
5639 #include <linux/pipe_fs_i.h>
5640 #include <linux/minix_fs_i.h>
5641 #include <linux/ext2_fs_i.h>
5642@@ -317,7 +336,7 @@
5643 umode_t ia_mode;
5644 uid_t ia_uid;
5645 gid_t ia_gid;
5646- off_t ia_size;
5647+ loff_t ia_size;
5648 time_t ia_atime;
5649 time_t ia_mtime;
5650 time_t ia_ctime;
5651@@ -352,7 +371,7 @@
5652 uid_t i_uid;
5653 gid_t i_gid;
5654 kdev_t i_rdev;
5655- off_t i_size;
5656+ loff_t i_size;
5657 time_t i_atime;
5658 time_t i_mtime;
5659 time_t i_ctime;
5660@@ -431,7 +450,7 @@
5661 mode_t f_mode;
5662 loff_t f_pos;
5663 unsigned int f_count, f_flags;
5664- unsigned long f_reada, f_ramax, f_raend, f_ralen, f_rawin;
5665+ loff_t f_reada, f_ramax, f_raend, f_ralen, f_rawin;
5666 struct fown_struct f_owner;
5667 unsigned int f_uid, f_gid;
5668 int f_error;
5669@@ -471,8 +490,8 @@
5670 struct file *fl_file;
5671 unsigned char fl_flags;
5672 unsigned char fl_type;
5673- off_t fl_start;
5674- off_t fl_end;
5675+ loff_t fl_start;
5676+ loff_t fl_end;
5677
5678 void (*fl_notify)(struct file_lock *); /* unblock callback */
5679 void (*fl_insert)(struct file_lock *); /* lock insertion callback */
5680@@ -483,6 +502,9 @@
5681 } fl_u;
5682 };
5683
5684+#define OFFSET_MAX ((loff_t)((~0ULL)>>1))
5685+#define OFFT_OFFSET_MAX ((off_t)((~0UL)>>1))
5686+
5687 extern struct file_lock *file_lock_table;
5688
5689 #include <linux/fcntl.h>
5690@@ -490,6 +512,9 @@
5691 extern int fcntl_getlk(unsigned int fd, struct flock *l);
5692 extern int fcntl_setlk(unsigned int fd, unsigned int cmd, struct flock *l);
5693
5694+extern int fcntl_getlk64(unsigned int fd, struct flock64 *l);
5695+extern int fcntl_setlk64(unsigned int fd, unsigned int cmd, struct flock64 *l);
5696+
5697 /* fs/locks.c */
5698 extern void locks_remove_posix(struct file *, fl_owner_t id);
5699 extern void locks_remove_flock(struct file *);
5700@@ -596,12 +621,25 @@
5701 extern int vfs_rename(struct inode *, struct dentry *, struct inode *, struct dentry *);
5702
5703 /*
5704+ * File types
5705+ */
5706+#define DT_UNKNOWN 0
5707+#define DT_FIFO 1
5708+#define DT_CHR 2
5709+#define DT_DIR 4
5710+#define DT_BLK 6
5711+#define DT_REG 8
5712+#define DT_LNK 10
5713+#define DT_SOCK 12
5714+#define DT_WHT 14
5715+
5716+/*
5717 * This is the "filldir" function type, used by readdir() to let
5718 * the kernel specify what kind of dirent layout it wants to have.
5719 * This allows the kernel to read directories into kernel space or
5720 * to have different dirent layouts depending on the binary type.
5721 */
5722-typedef int (*filldir_t)(void *, const char *, int, off_t, ino_t);
5723+typedef int (*filldir_t)(void *, const char *, int, off_t, ino_t, unsigned);
5724
5725 struct file_operations {
5726 loff_t (*llseek) (struct file *, loff_t, int);
5727@@ -733,7 +771,7 @@
5728
5729 asmlinkage int sys_open(const char *, int, int);
5730 asmlinkage int sys_close(unsigned int); /* yes, it's really unsigned */
5731-extern int do_truncate(struct dentry *, unsigned long);
5732+extern int do_truncate(struct dentry *, loff_t);
5733
5734 extern struct file *filp_open(const char *, int, int);
5735 extern int filp_close(struct file *, fl_owner_t id);
5736diff -urN lfs-ref/include/linux/mm.h lfs/include/linux/mm.h
5737--- lfs-ref/include/linux/mm.h Wed Sep 12 02:39:57 2001
5738+++ lfs/include/linux/mm.h Wed Sep 12 02:42:15 2001
5739@@ -54,7 +54,7 @@
5740 struct vm_area_struct **vm_pprev_share;
5741
5742 struct vm_operations_struct * vm_ops;
5743- unsigned long vm_offset;
5744+ loff_t vm_offset;
5745 struct file * vm_file;
5746 unsigned long vm_pte; /* shared mem */
5747 };
5748@@ -108,9 +108,46 @@
5749 unsigned long (*wppage)(struct vm_area_struct * area, unsigned long address,
5750 unsigned long page);
5751 int (*swapout)(struct vm_area_struct *, struct page *);
5752- pte_t (*swapin)(struct vm_area_struct *, unsigned long, unsigned long);
5753+ pte_t (*swapin)(struct vm_area_struct *, loff_t, unsigned long);
5754 };
5755
5756+
5757+/*
5758+ * pgoff_t type -- a complex one, and its simple alternate.
5759+ * The complex one has type that compiler can trap at compile
5760+ * time, but the simple one does simpler code (?)
5761+ */
5762+
5763+#if 0
5764+typedef struct pgoff_t {
5765+ unsigned long pgoff;
5766+} pgoff_t;
5767+
5768+#define pgoff2ulong(pgof) ((pgof).pgoff)
5769+extern __inline__ pgoff_t ulong2pgoff(unsigned long ul) {
5770+ pgoff_t up;
5771+ up.pgoff = ul;
5772+ return up;
5773+}
5774+
5775+#define pgoff2loff(pgof) (((loff_t)(pgof).pgoff) << PAGE_SHIFT)
5776+#define loff2pgoff(loff) ulong2pgoff((loff) >> PAGE_SHIFT)
5777+
5778+#else /* Integer scalars -- simpler code.. */
5779+
5780+typedef unsigned long pgoff_t;
5781+
5782+#define pgoff2ulong(pgof) (pgof)
5783+#define ulong2pgoff(pgof) (pgof)
5784+
5785+#define pgoff2loff(pgof) (((loff_t)(pgof)) << PAGE_SHIFT)
5786+#define loff2pgoff(loff) ulong2pgoff((loff) >> PAGE_SHIFT)
5787+
5788+#endif
5789+
5790+#define PAGE_MASK_loff ((loff_t)(long)(PAGE_MASK))
5791+
5792+
5793 /*
5794 * Try to keep the most commonly accessed fields in single cache lines
5795 * here (16 bytes or greater). This ordering should be particularly
5796@@ -119,12 +156,13 @@
5797 * The first line is data used in page cache lookup, the second line
5798 * is used for linear searches (eg. clock algorithm scans).
5799 */
5800+
5801 typedef struct page {
5802 /* these must be first (free area handling) */
5803 struct page *next;
5804 struct page *prev;
5805+ pgoff_t index;
5806 struct inode *inode;
5807- unsigned long offset;
5808 struct page *next_hash;
5809 atomic_t count;
5810 unsigned long flags; /* atomic flags, some possibly updated asynchronously */
5811@@ -299,7 +337,7 @@
5812 extern int remap_page_range(unsigned long from, unsigned long to, unsigned long size, pgprot_t prot);
5813 extern int zeromap_page_range(unsigned long from, unsigned long size, pgprot_t prot);
5814
5815-extern void vmtruncate(struct inode * inode, unsigned long offset);
5816+extern void vmtruncate(struct inode * inode, loff_t offset);
5817 extern int handle_mm_fault(struct task_struct *tsk,struct vm_area_struct *vma, unsigned long address, int write_access);
5818 extern int make_pages_present(unsigned long addr, unsigned long end);
5819
5820@@ -319,16 +357,22 @@
5821 extern void exit_mmap(struct mm_struct *);
5822 extern unsigned long get_unmapped_area(unsigned long, unsigned long);
5823
5824-extern unsigned long do_mmap(struct file *, unsigned long, unsigned long,
5825- unsigned long, unsigned long, unsigned long);
5826+extern unsigned long do_mmap_pgoff(struct file *file, unsigned long addr,
5827+ unsigned long len, unsigned long prot,
5828+ unsigned long flag, unsigned long pgoff);
5829+
5830+extern unsigned long do_mmap(struct file *, unsigned long,
5831+ unsigned long, unsigned long,
5832+ unsigned long, unsigned long);
5833+
5834 extern int do_munmap(unsigned long, size_t);
5835
5836 /* filemap.c */
5837 extern void remove_inode_page(struct page *);
5838 extern unsigned long page_unuse(struct page *);
5839 extern int shrink_mmap(int, int);
5840-extern void truncate_inode_pages(struct inode *, unsigned long);
5841-extern unsigned long get_cached_page(struct inode *, unsigned long, int);
5842+extern void truncate_inode_pages(struct inode *, loff_t);
5843+extern unsigned long get_cached_page(struct inode *, pgoff_t, int);
5844 extern void put_cached_page(unsigned long);
5845
5846 /*
5847diff -urN lfs-ref/include/linux/nfs.h lfs/include/linux/nfs.h
5848--- lfs-ref/include/linux/nfs.h Fri Apr 20 22:31:21 2001
5849+++ lfs/include/linux/nfs.h Wed Sep 12 02:42:15 2001
5850@@ -78,11 +78,7 @@
5851 #define NFS_MNTPROC_MNT 1
5852 #define NFS_MNTPROC_UMNT 3
5853
5854-/*
5855- * This is really a general kernel constant, but since nothing like
5856- * this is defined in the kernel headers, I have to do it here.
5857- */
5858-#define NFS_OFFSET_MAX LONG_MAX
5859+#define NFS_OFFSET_MAX ((__s64)((~(__u64)0) >> 1))
5860
5861 /*
5862 * These data types are used exlusively by the NFS client implementation.
5863diff -urN lfs-ref/include/linux/nfs_fs.h lfs/include/linux/nfs_fs.h
5864--- lfs-ref/include/linux/nfs_fs.h Wed Sep 12 02:05:58 2001
5865+++ lfs/include/linux/nfs_fs.h Wed Sep 12 02:42:15 2001
5866@@ -113,15 +113,15 @@
5867
5868
5869 static inline
5870-unsigned long nfs_page_offset(struct page *page)
5871+loff_t nfs_page_offset(struct page *page)
5872 {
5873- return page->offset;
5874+ return ((loff_t)page->index) << PAGE_CACHE_SHIFT;
5875 }
5876
5877 static inline
5878 unsigned long page_index(struct page *page)
5879 {
5880- return page->offset >> PAGE_CACHE_SHIFT;
5881+ return page->index;
5882 }
5883
5884 /*
5885@@ -284,6 +284,15 @@
5886 nfs_size_to_off_t(__u64 size)
5887 {
5888 return (size > (__u64)LONG_MAX) ? (off_t)LONG_MAX : (off_t) size;
5889+}
5890+
5891+static inline loff_t
5892+nfs_size_to_loff_t(__u64 size)
5893+{
5894+ loff_t maxsz = (((loff_t) ULONG_MAX) << PAGE_CACHE_SHIFT) + PAGE_CACHE_SIZE - 1;
5895+ if (size > maxsz)
5896+ return maxsz;
5897+ return (loff_t) size;
5898 }
5899
5900 static inline ino_t
5901diff -urN lfs-ref/include/linux/nfs_xdr.h lfs/include/linux/nfs_xdr.h
5902--- lfs-ref/include/linux/nfs_xdr.h Wed Sep 12 02:05:59 2001
5903+++ lfs/include/linux/nfs_xdr.h Wed Sep 12 02:42:15 2001
5904@@ -329,11 +329,11 @@
5905 int (*readlink)(struct inode *, void *buffer, unsigned int buflen);
5906 int (*read)(struct inode *, struct rpc_cred *,
5907 struct nfs_fattr *,
5908- int flags, unsigned long offset,
5909+ int flags, loff_t offset,
5910 unsigned int count, void *buffer, int *eofp);
5911 int (*write)(struct inode *, struct rpc_cred *,
5912 struct nfs_fattr *,
5913- int flags, unsigned long offset,
5914+ int flags, loff_t offset,
5915 unsigned int count, void *buffer,
5916 struct nfs_writeverf *verfp);
5917 int (*commit)(struct inode *, struct nfs_fattr *,
5918@@ -361,6 +361,7 @@
5919 int (*statfs)(struct nfs_server *, struct nfs_fh *,
5920 struct nfs_fsinfo *);
5921 __u32 * (*decode_dirent)(__u32 *, struct nfs_entry *, int plus);
5922+ int bigfiles;
5923 };
5924
5925 /*
5926diff -urN lfs-ref/include/linux/nfsd/nfsd.h lfs/include/linux/nfsd/nfsd.h
5927--- lfs-ref/include/linux/nfsd/nfsd.h Sat Apr 21 18:21:21 2001
5928+++ lfs/include/linux/nfsd/nfsd.h Wed Sep 12 02:42:15 2001
5929@@ -57,7 +57,7 @@
5930 char dotonly;
5931 };
5932 typedef int (*encode_dent_fn)(struct readdir_cd *, const char *,
5933- int, off_t, ino_t);
5934+ int, off_t, ino_t, unsigned int);
5935 typedef int (*nfsd_dirop_t)(struct inode *, struct dentry *, int, int);
5936
5937 /*
5938diff -urN lfs-ref/include/linux/nfsd/xdr.h lfs/include/linux/nfsd/xdr.h
5939--- lfs-ref/include/linux/nfsd/xdr.h Sat Apr 21 18:21:21 2001
5940+++ lfs/include/linux/nfsd/xdr.h Wed Sep 12 02:42:15 2001
5941@@ -152,7 +152,7 @@
5942 int nfssvc_encode_readdirres(struct svc_rqst *, u32 *, struct nfsd_readdirres *);
5943
5944 int nfssvc_encode_entry(struct readdir_cd *, const char *name,
5945- int namlen, off_t offset, ino_t ino);
5946+ int namlen, off_t offset, ino_t ino, unsigned int d_type);
5947
5948 int nfssvc_release_fhandle(struct svc_rqst *, u32 *, struct nfsd_fhandle *);
5949
5950diff -urN lfs-ref/include/linux/nfsd/xdr3.h lfs/include/linux/nfsd/xdr3.h
5951--- lfs-ref/include/linux/nfsd/xdr3.h Sat Apr 21 18:21:24 2001
5952+++ lfs/include/linux/nfsd/xdr3.h Wed Sep 12 02:42:15 2001
5953@@ -292,9 +292,9 @@
5954 int nfs3svc_release_fhandle2(struct svc_rqst *, u32 *,
5955 struct nfsd3_fhandle_pair *);
5956 int nfs3svc_encode_entry(struct readdir_cd *, const char *name,
5957- int namlen, off_t offset, ino_t ino);
5958+ int namlen, off_t offset, ino_t ino, unsigned int d_type);
5959 int nfs3svc_encode_entry_plus(struct readdir_cd *, const char *name,
5960- int namlen, off_t offset, ino_t ino);
5961+ int namlen, off_t offset, ino_t ino, unsigned int d_type);
5962
5963
5964 #endif /* _LINUX_NFSD_XDR3_H */
5965diff -urN lfs-ref/include/linux/pagemap.h lfs/include/linux/pagemap.h
5966--- lfs-ref/include/linux/pagemap.h Sat Apr 21 18:19:44 2001
5967+++ lfs/include/linux/pagemap.h Wed Sep 12 02:42:15 2001
5968@@ -28,6 +28,7 @@
5969 #define PAGE_CACHE_SHIFT PAGE_SHIFT
5970 #define PAGE_CACHE_SIZE PAGE_SIZE
5971 #define PAGE_CACHE_MASK PAGE_MASK
5972+#define PAGE_CACHE_MASK_loff PAGE_MASK_loff
5973
5974 #define page_cache_alloc() __get_free_page(GFP_USER)
5975 #define page_cache_free(x) free_page(x)
5976@@ -54,10 +55,10 @@
5977 * inode pointer and offsets are distributed (ie, we
5978 * roughly know which bits are "significant")
5979 */
5980-static inline unsigned long _page_hashfn(struct inode * inode, unsigned long offset)
5981+static inline unsigned long _page_hashfn(struct inode * inode, pgoff_t index)
5982 {
5983 #define i (((unsigned long) inode)/(sizeof(struct inode) & ~ (sizeof(struct inode) - 1)))
5984-#define o ((offset >> PAGE_SHIFT) + (offset & ~PAGE_MASK))
5985+#define o (index + (index >> PAGE_HASH_BITS))
5986 return ((i+o) & PAGE_HASH_MASK);
5987 #undef i
5988 #undef o
5989@@ -65,7 +66,7 @@
5990
5991 #define page_hash(inode,offset) (page_hash_table+_page_hashfn(inode,offset))
5992
5993-static inline struct page * __find_page(struct inode * inode, unsigned long offset, struct page *page)
5994+static inline struct page * __find_page(struct inode * inode, pgoff_t index, struct page *page)
5995 {
5996 goto inside;
5997 for (;;) {
5998@@ -75,7 +76,7 @@
5999 goto not_found;
6000 if (page->inode != inode)
6001 continue;
6002- if (page->offset == offset)
6003+ if (pgoff2ulong(page->index) == pgoff2ulong(index))
6004 break;
6005 }
6006 /* Found the page. */
6007@@ -85,9 +86,9 @@
6008 return page;
6009 }
6010
6011-static inline struct page *find_page(struct inode * inode, unsigned long offset)
6012+static inline struct page *find_page(struct inode * inode, pgoff_t poffset)
6013 {
6014- return __find_page(inode, offset, *page_hash(inode, offset));
6015+ return __find_page(inode, poffset, *page_hash(inode, poffset));
6016 }
6017
6018 static inline void remove_page_from_hash_queue(struct page * page)
6019@@ -110,9 +111,9 @@
6020 page->pprev_hash = p;
6021 }
6022
6023-static inline void add_page_to_hash_queue(struct page * page, struct inode * inode, unsigned long offset)
6024+static inline void add_page_to_hash_queue(struct page * page, struct inode * inode, pgoff_t poffset)
6025 {
6026- __add_page_to_hash_queue(page, page_hash(inode,offset));
6027+ __add_page_to_hash_queue(page, page_hash(inode,poffset));
6028 }
6029
6030 static inline void remove_page_from_inode_queue(struct page * page)
6031@@ -150,8 +151,8 @@
6032 __wait_on_page(page);
6033 }
6034
6035-extern void update_vm_cache_conditional(struct inode *, unsigned long, const char *, int, unsigned long);
6036-extern void update_vm_cache(struct inode *, unsigned long, const char *, int);
6037+extern void update_vm_cache_conditional(struct inode *, loff_t, const char *, int, unsigned long);
6038+extern void update_vm_cache(struct inode *, loff_t, const char *, int);
6039
6040 typedef int filler_t(void *, struct page*);
6041
6042diff -urN lfs-ref/include/linux/sched.h lfs/include/linux/sched.h
6043--- lfs-ref/include/linux/sched.h Wed Sep 12 02:39:57 2001
6044+++ lfs/include/linux/sched.h Wed Sep 12 02:42:15 2001
6045@@ -317,7 +317,7 @@
6046 int keep_capabilities:1;
6047 struct user_struct *user;
6048 /* limits */
6049- struct rlimit rlim[RLIM_NLIMITS];
6050+ struct rlimit rlim[RLIM_NLIMITS];
6051 unsigned short used_math;
6052 char comm[16];
6053 /* file system info */
6054diff -urN lfs-ref/include/linux/smb_fs.h lfs/include/linux/smb_fs.h
6055--- lfs-ref/include/linux/smb_fs.h Sat Apr 21 18:48:37 2001
6056+++ lfs/include/linux/smb_fs.h Wed Sep 12 02:42:15 2001
6057@@ -121,8 +121,8 @@
6058 void smb_close_dentry(struct dentry *);
6059 int smb_close_fileid(struct dentry *, __u16);
6060 int smb_open(struct dentry *, int);
6061-int smb_proc_read(struct dentry *, off_t, int, char *);
6062-int smb_proc_write(struct dentry *, off_t, int, const char *);
6063+int smb_proc_read(struct dentry *, loff_t, int, char *);
6064+int smb_proc_write(struct dentry *, loff_t, int, const char *);
6065 int smb_proc_create(struct dentry *, __u16, time_t, __u16 *);
6066 int smb_proc_mv(struct dentry *, struct dentry *);
6067 int smb_proc_mkdir(struct dentry *);
6068diff -urN lfs-ref/include/linux/swap.h lfs/include/linux/swap.h
6069--- lfs-ref/include/linux/swap.h Sat Apr 21 18:19:44 2001
6070+++ lfs/include/linux/swap.h Wed Sep 12 02:42:15 2001
6071@@ -114,7 +114,7 @@
6072 extern unsigned int nr_swapfiles;
6073 extern struct swap_info_struct swap_info[];
6074 void si_swapinfo(struct sysinfo *);
6075-unsigned long get_swap_page(void);
6076+extern unsigned long get_swap_page(void);
6077 extern void FASTCALL(swap_free(unsigned long));
6078 struct swap_list_t {
6079 int head; /* head of priority-ordered swapfile list */
6080@@ -147,7 +147,7 @@
6081 extern inline unsigned long in_swap_cache(struct page *page)
6082 {
6083 if (PageSwapCache(page))
6084- return page->offset;
6085+ return pgoff2ulong(page->index);
6086 return 0;
6087 }
6088
6089@@ -164,7 +164,7 @@
6090 return 1;
6091 count = atomic_read(&page->count);
6092 if (PageSwapCache(page))
6093- count += swap_count(page->offset) - 2;
6094+ count += swap_count(pgoff2ulong(page->index)) - 2;
6095 if (PageFreeAfter(page))
6096 count--;
6097 return count > 1;
6098diff -urN lfs-ref/include/linux/ufs_fs_i.h lfs/include/linux/ufs_fs_i.h
6099--- lfs-ref/include/linux/ufs_fs_i.h Tue Feb 1 18:24:19 2000
6100+++ lfs/include/linux/ufs_fs_i.h Wed Sep 12 02:42:15 2001
6101@@ -18,7 +18,6 @@
6102 __u32 i_data[15];
6103 __u8 i_symlink[4*15];
6104 } i_u1;
6105- __u64 i_size;
6106 __u32 i_flags;
6107 __u32 i_gen;
6108 __u32 i_shadow;
6109diff -urN lfs-ref/kernel/ksyms.c lfs/kernel/ksyms.c
6110--- lfs-ref/kernel/ksyms.c Wed Sep 12 02:39:58 2001
6111+++ lfs/kernel/ksyms.c Wed Sep 12 02:42:15 2001
6112@@ -96,6 +96,7 @@
6113
6114 /* process memory management */
6115 EXPORT_SYMBOL(do_mmap);
6116+EXPORT_SYMBOL(do_mmap_pgoff);
6117 EXPORT_SYMBOL(do_munmap);
6118 EXPORT_SYMBOL(exit_mm);
6119 EXPORT_SYMBOL(exit_files);
6120diff -urN lfs-ref/lib/vsprintf.c lfs/lib/vsprintf.c
6121--- lfs-ref/lib/vsprintf.c Mon Jan 17 16:44:50 2000
6122+++ lfs/lib/vsprintf.c Wed Sep 12 02:42:15 2001
6123@@ -67,10 +67,106 @@
6124 #define LARGE 64 /* use 'ABCDEF' instead of 'abcdef' */
6125
6126 #define do_div(n,base) ({ \
6127-int __res; \
6128-__res = ((unsigned long) n) % (unsigned) base; \
6129-n = ((unsigned long) n) / (unsigned) base; \
6130-__res; })
6131+ int __res; \
6132+ __res = ((unsigned long) n) % (unsigned) base; \
6133+ n = ((unsigned long) n) / (unsigned) base; \
6134+ __res; })
6135+
6136+#if BITS_PER_LONG < 64
6137+
6138+/* Note: do_ldiv assumes that unsigned long long is a 64 bit long
6139+ * and unsigned long is at least a 32 bits long.
6140+ */
6141+#define do_ldiv(n, base) \
6142+({ \
6143+ unsigned long long value = n; \
6144+ unsigned long long leftover; \
6145+ unsigned long temp; \
6146+ unsigned long result_div1, result_div2, result_div3, result_mod; \
6147+\
6148+ temp = value >> 32; \
6149+ result_div1 = temp/(base); \
6150+ result_mod = temp%(base); \
6151+\
6152+ temp = (result_mod << 24) | ((value >> 8) & 0xFFFFFF); \
6153+ result_div2 = temp/(base); \
6154+ result_mod = temp%(base); \
6155+\
6156+ temp = (result_mod << 8) | (value & 0xFF); \
6157+ result_div3 = temp/(base); \
6158+ result_mod = temp%(base);\
6159+\
6160+ leftover = ((unsigned long long)result_div1 << 32) | \
6161+ ((unsigned long long)result_div2 << 8) | (result_div3); \
6162+\
6163+ n = leftover; \
6164+ result_mod; \
6165+})
6166+
6167+
6168+static char * lnumber(char * str, long long num, int base, int size,
6169+ int precision, int type)
6170+{
6171+ char c,sign,tmp[66];
6172+ const char *digits="0123456789abcdef";
6173+ int i;
6174+
6175+ if (type & LARGE)
6176+ digits = "0123456789ABCDEF";
6177+ if (type & LEFT)
6178+ type &= ~ZEROPAD;
6179+ if (base < 2 || base > 36)
6180+ return 0;
6181+ c = (type & ZEROPAD) ? '0' : ' ';
6182+ sign = 0;
6183+ if (type & SIGN) {
6184+ if (num < 0) {
6185+ sign = '-';
6186+ num = -num;
6187+ size--;
6188+ } else if (type & PLUS) {
6189+ sign = '+';
6190+ size--;
6191+ } else if (type & SPACE) {
6192+ sign = ' ';
6193+ size--;
6194+ }
6195+ }
6196+ if (type & SPECIAL) {
6197+ if (base == 16)
6198+ size -= 2;
6199+ }
6200+ i = 0;
6201+ if (num == 0)
6202+ tmp[i++]='0';
6203+ else while (num != 0)
6204+ tmp[i++] = digits[do_ldiv(num,base)];
6205+ if (i > precision)
6206+ precision = i;
6207+ size -= precision;
6208+ if (!(type&(ZEROPAD+LEFT)))
6209+ while(size-->0)
6210+ *str++ = ' ';
6211+ if (sign)
6212+ *str++ = sign;
6213+ if (type & SPECIAL) {
6214+ if (base==16) {
6215+ *str++ = '0';
6216+ *str++ = digits[33];
6217+ }
6218+ }
6219+ if (!(type & LEFT))
6220+ while (size-- > 0)
6221+ *str++ = c;
6222+ while (i < precision--)
6223+ *str++ = '0';
6224+ while (i-- > 0)
6225+ *str++ = tmp[i];
6226+ while (size-- > 0)
6227+ *str++ = ' ';
6228+ return str;
6229+}
6230+#endif
6231
6232 static char * number(char * str, long num, int base, int size, int precision
6233 ,int type)
6234@@ -207,7 +303,10 @@
6235 /* get the conversion qualifier */
6236 qualifier = -1;
6237 if (*fmt == 'h' || *fmt == 'l' || *fmt == 'L') {
6238- qualifier = *fmt;
6239+ if (*fmt == 'l' && qualifier == 'l')
6240+ qualifier = 'L';
6241+ else
6242+ qualifier = *fmt;
6243 ++fmt;
6244 }
6245
6246@@ -290,7 +389,22 @@
6247 --fmt;
6248 continue;
6249 }
6250- if (qualifier == 'l')
6251+ if (qualifier == 'L') {
6252+
6253+#if BITS_PER_LONG < 64
6254+ /* 64-bit printout in 32-bit systems !!
6255+ Needed at some point for 64-bit file offsets and
6256+ mmap() reporting functions. */
6257+
6258+ unsigned long long lnum;
6259+ lnum = va_arg(args, unsigned long long);
6260+ str = lnumber(str, lnum, base, field_width,
6261+ precision, flags);
6262+ continue;
6263+#else
6264+ num = va_arg(args, unsigned long); /* 64-bit longs..*/
6265+#endif
6266+ } else if (qualifier == 'l')
6267 num = va_arg(args, unsigned long);
6268 else if (qualifier == 'h') {
6269 num = (unsigned short) va_arg(args, int);
6270diff -urN lfs-ref/mm/filemap.c lfs/mm/filemap.c
6271--- lfs-ref/mm/filemap.c Wed Sep 12 02:39:57 2001
6272+++ lfs/mm/filemap.c Wed Sep 12 02:42:15 2001
6273@@ -78,7 +78,7 @@
6274 * Truncate the page cache at a set offset, removing the pages
6275 * that are beyond that offset (and zeroing out partial pages).
6276 */
6277-void truncate_inode_pages(struct inode * inode, unsigned long start)
6278+void truncate_inode_pages(struct inode * inode, loff_t start)
6279 {
6280 struct page ** p;
6281 struct page * page;
6282@@ -86,10 +86,10 @@
6283 repeat:
6284 p = &inode->i_pages;
6285 while ((page = *p) != NULL) {
6286- unsigned long offset = page->offset;
6287+ loff_t loffset = pgoff2loff(page->index);
6288
6289 /* page wholly truncated - free it */
6290- if (offset >= start) {
6291+ if (loffset >= start) {
6292 if (PageLocked(page)) {
6293 wait_on_page(page);
6294 goto repeat;
6295@@ -105,9 +105,10 @@
6296 continue;
6297 }
6298 p = &page->next;
6299- offset = start - offset;
6300+ loffset = start - loffset;
6301 /* partial truncate, clear end of page */
6302- if (offset < PAGE_CACHE_SIZE) {
6303+ if (loffset < PAGE_CACHE_SIZE) {
6304+ unsigned int offset = loffset; /* truncate ok */
6305 unsigned long address = page_address(page);
6306 memset((void *) (offset + address), 0, PAGE_CACHE_SIZE - offset);
6307 flush_page_to_ram(address);
6308@@ -195,7 +196,8 @@
6309 * were to be marked referenced..
6310 */
6311 if (PageSwapCache(page)) {
6312- if (referenced && swap_count(page->offset) != 1)
6313+ if (referenced &&
6314+ swap_count(pgoff2ulong(page->index)) != 1)
6315 continue;
6316 delete_from_swap_cache(page);
6317 return 1;
6318@@ -250,11 +252,12 @@
6319 * memory maps. --sct
6320 */
6321
6322-void update_vm_cache_conditional(struct inode * inode, unsigned long pos, const char * buf, int count, unsigned long source_address)
6323+void update_vm_cache_conditional(struct inode * inode, loff_t pos, const char * buf, int count, unsigned long source_address)
6324 {
6325 unsigned long offset, len;
6326+ pgoff_t pgoff = loff2pgoff(pos);
6327
6328- offset = (pos & ~PAGE_CACHE_MASK);
6329+ offset = ((unsigned long)pos & ~PAGE_CACHE_MASK);
6330 pos = pos & PAGE_CACHE_MASK;
6331 len = PAGE_CACHE_SIZE - offset;
6332 do {
6333@@ -262,7 +265,7 @@
6334
6335 if (len > count)
6336 len = count;
6337- page = find_page(inode, pos);
6338+ page = find_page(inode, pgoff);
6339 if (page) {
6340 char *dest = (char*) (offset + page_address(page));
6341
6342@@ -282,19 +285,20 @@
6343 } while (count);
6344 }
6345
6346-void update_vm_cache(struct inode * inode, unsigned long pos, const char * buf, int count)
6347+void update_vm_cache(struct inode * inode, loff_t pos, const char * buf, int count)
6348 {
6349 update_vm_cache_conditional(inode, pos, buf, count, 0);
6350 }
6351
6352
6353 static inline void add_to_page_cache(struct page * page,
6354- struct inode * inode, unsigned long offset,
6355- struct page **hash)
6356+ struct inode * inode,
6357+ pgoff_t pgoff,
6358+ struct page **hash)
6359 {
6360 atomic_inc(&page->count);
6361 page->flags = page->flags & ~((1 << PG_uptodate) | (1 << PG_error) | (1 << PG_referenced));
6362- page->offset = offset;
6363+ page->index = pgoff;
6364 add_page_to_inode_queue(inode, page);
6365 __add_page_to_hash_queue(page, hash);
6366 }
6367@@ -305,29 +309,32 @@
6368 * this is all overlapped with the IO on the previous page finishing anyway)
6369 */
6370 static unsigned long try_to_read_ahead(struct file * file,
6371- unsigned long offset, unsigned long page_cache)
6372+ pgoff_t pgoff, unsigned long page_cache)
6373 {
6374 struct inode *inode = file->f_dentry->d_inode;
6375- struct page * page;
6376- struct page ** hash;
6377+ pgoff_t pg_size;
6378
6379- offset &= PAGE_CACHE_MASK;
6380- switch (page_cache) {
6381- case 0:
6382+ /* Calculate file size in 'pages' -- if even one byte (according to
6383+ the 'i_size') exceeds the final page-size block, round up. */
6384+ pg_size = loff2pgoff(inode->i_size+(PAGE_SIZE-1));
6385+
6386+ if (!page_cache) {
6387 page_cache = page_cache_alloc();
6388 if (!page_cache)
6389- break;
6390- default:
6391- if (offset >= inode->i_size)
6392- break;
6393- hash = page_hash(inode, offset);
6394- page = __find_page(inode, offset, *hash);
6395+ return 0; /* Can't allocate! */
6396+ }
6397+ /* Ok, we have a page, make sure it is in the page cache */
6398+ if (pgoff2ulong(pgoff) < pgoff2ulong(pg_size)) {
6399+ struct page * page;
6400+ struct page ** hash;
6401+ hash = page_hash(inode, pgoff);
6402+ page = __find_page(inode, pgoff, *hash);
6403 if (!page) {
6404 /*
6405 * Ok, add the new page to the hash-queues...
6406 */
6407 page = page_cache_entry(page_cache);
6408- add_to_page_cache(page, inode, offset, hash);
6409+ add_to_page_cache(page, inode, pgoff, hash);
6410 inode->i_op->readpage(file, page);
6411 page_cache = 0;
6412 }
6413@@ -381,11 +388,11 @@
6414
6415 #define PROFILE_MAXREADCOUNT 1000
6416
6417-static unsigned long total_reada;
6418-static unsigned long total_async;
6419-static unsigned long total_ramax;
6420-static unsigned long total_ralen;
6421-static unsigned long total_rawin;
6422+static u_long total_reada;
6423+static u_long total_async;
6424+static u_long total_ramax;
6425+static u_long total_ralen;
6426+static u_long total_rawin;
6427
6428 static void profile_readahead(int async, struct file *filp)
6429 {
6430@@ -493,13 +500,13 @@
6431
6432 static inline unsigned long generic_file_readahead(int reada_ok,
6433 struct file * filp, struct inode * inode,
6434- unsigned long ppos, struct page * page, unsigned long page_cache)
6435+ loff_t ppos, struct page * page, unsigned long page_cache)
6436 {
6437- unsigned long max_ahead, ahead;
6438- unsigned long raend;
6439+ loff_t max_ahead, ahead;
6440+ loff_t raend;
6441 int max_readahead = get_max_readahead(inode);
6442
6443- raend = filp->f_raend & PAGE_CACHE_MASK;
6444+ raend = filp->f_raend & PAGE_CACHE_MASK_loff;
6445 max_ahead = 0;
6446
6447 /*
6448@@ -557,7 +564,7 @@
6449 ahead = 0;
6450 while (ahead < max_ahead) {
6451 ahead += PAGE_CACHE_SIZE;
6452- page_cache = try_to_read_ahead(filp, raend + ahead,
6453+ page_cache = try_to_read_ahead(filp, loff2pgoff(raend + ahead),
6454 page_cache);
6455 }
6456 /*
6457@@ -626,14 +633,14 @@
6458 struct dentry *dentry = filp->f_dentry;
6459 struct inode *inode = dentry->d_inode;
6460 unsigned long page_cache;
6461- size_t pos, pgpos;
6462+ loff_t pos, posp;
6463 int reada_ok;
6464 int max_readahead = get_max_readahead(inode);
6465
6466 page_cache = 0;
6467
6468 pos = *ppos;
6469- pgpos = pos & PAGE_CACHE_MASK;
6470+ posp = pos & PAGE_CACHE_MASK_loff;
6471 /*
6472 * If the current position is outside the previous read-ahead window,
6473 * we reset the current read-ahead context and set read ahead max to zero
6474@@ -641,7 +648,7 @@
6475 * otherwise, we assume that the file accesses are sequential enough to
6476 * continue read-ahead.
6477 */
6478- if (pgpos > filp->f_raend || pgpos + filp->f_rawin < filp->f_raend) {
6479+ if (posp > filp->f_raend || posp + filp->f_rawin < filp->f_raend) {
6480 reada_ok = 0;
6481 filp->f_raend = 0;
6482 filp->f_ralen = 0;
6483@@ -657,12 +664,12 @@
6484 * Then, at least MIN_READAHEAD if read ahead is ok,
6485 * and at most MAX_READAHEAD in all cases.
6486 */
6487- if (pos + desc->count <= (PAGE_CACHE_SIZE >> 1)) {
6488+ if (pos + desc->count <= (loff_t)(PAGE_CACHE_SIZE >> 1)) {
6489 filp->f_ramax = 0;
6490 } else {
6491- unsigned long needed;
6492+ loff_t needed;
6493
6494- needed = ((pos + desc->count) & PAGE_CACHE_MASK) - pgpos;
6495+ needed = ((pos + desc->count) & PAGE_CACHE_MASK) - posp;
6496
6497 if (filp->f_ramax < needed)
6498 filp->f_ramax = needed;
6499@@ -675,6 +682,7 @@
6500
6501 for (;;) {
6502 struct page *page, **hash;
6503+ pgoff_t pgoff;
6504
6505 if (pos >= inode->i_size)
6506 break;
6507@@ -682,8 +690,9 @@
6508 /*
6509 * Try to find the data in the page cache..
6510 */
6511- hash = page_hash(inode, pos & PAGE_CACHE_MASK);
6512- page = __find_page(inode, pos & PAGE_CACHE_MASK, *hash);
6513+ pgoff = loff2pgoff(pos);
6514+ hash = page_hash(inode, pgoff);
6515+ page = __find_page(inode, pgoff, *hash);
6516 if (!page)
6517 goto no_cached_page;
6518
6519@@ -696,7 +705,7 @@
6520 * the page has been rewritten.
6521 */
6522 if (PageUptodate(page) || PageLocked(page))
6523- page_cache = generic_file_readahead(reada_ok, filp, inode, pos & PAGE_CACHE_MASK, page, page_cache);
6524+ page_cache = generic_file_readahead(reada_ok, filp, inode, pos & PAGE_CACHE_MASK_loff, page, page_cache);
6525 else if (reada_ok && filp->f_ramax > MIN_READAHEAD)
6526 filp->f_ramax = MIN_READAHEAD;
6527
6528@@ -721,8 +730,8 @@
6529 flush_dcache_page(page_address(page));
6530
6531 offset = pos & ~PAGE_CACHE_MASK;
6532- nr = PAGE_CACHE_SIZE - offset;
6533- if (nr > inode->i_size - pos)
6534+ nr = PAGE_CACHE_SIZE - offset; /* small value */
6535+ if ((loff_t)nr > (inode->i_size - pos))
6536 nr = inode->i_size - pos;
6537
6538 /*
6539@@ -762,7 +771,7 @@
6540 */
6541 page = page_cache_entry(page_cache);
6542 page_cache = 0;
6543- add_to_page_cache(page, inode, pos & PAGE_CACHE_MASK, hash);
6544+ add_to_page_cache(page, inode, pgoff, hash);
6545
6546 /*
6547 * Error handling is tricky. If we get a read error,
6548@@ -843,10 +852,26 @@
6549 ssize_t generic_file_read(struct file * filp, char * buf, size_t count, loff_t *ppos)
6550 {
6551 ssize_t retval;
6552+ struct inode *inode = filp->f_dentry->d_inode;
6553+
6554+ if (((ssize_t) count) < 0)
6555+ return -EINVAL;
6556
6557 retval = -EFAULT;
6558 if (access_ok(VERIFY_WRITE, buf, count)) {
6559 retval = 0;
6560+
6561+ /* L-F-S spec 2.2.1.25: */
6562+ if (!(filp->f_flags & O_LARGEFILE) &&
6563+ S_ISREG(inode->i_mode) &&
6564+ (*ppos < inode->i_size) && count) {
6565+ if (*ppos >= 0x7fffffff) /* pos@2G forbidden */
6566+ return -EOVERFLOW;
6567+ if (*ppos + count > 0x7fffffff)
6568+ /* Read only until end of allowed region */
6569+ count = 0x7fffffff - *ppos;
6570+ }
6571+
6572 if (count) {
6573 read_descriptor_t desc;
6574
6575@@ -895,6 +920,9 @@
6576 struct file * in_file, * out_file;
6577 struct inode * in_inode, * out_inode;
6578
6579+ if (((ssize_t) count) < 0)
6580+ return -EINVAL;
6581+
6582 lock_kernel();
6583
6584 /*
6585@@ -988,20 +1016,25 @@
6586 struct file * file = area->vm_file;
6587 struct dentry * dentry = file->f_dentry;
6588 struct inode * inode = dentry->d_inode;
6589- unsigned long offset, reada, i;
6590+ loff_t offset;
6591+ pgoff_t pgoff, reada;
6592+ int i;
6593 struct page * page, **hash;
6594 unsigned long old_page, new_page;
6595
6596 new_page = 0;
6597- offset = (address & PAGE_MASK) - area->vm_start + area->vm_offset;
6598+ offset = ((loff_t)((address & PAGE_MASK) - area->vm_start) +
6599+ area->vm_offset);
6600+
6601 if (offset >= inode->i_size && (area->vm_flags & VM_SHARED) && area->vm_mm == current->mm)
6602 goto no_page;
6603
6604 /*
6605 * Do we have something in the page cache already?
6606 */
6607- hash = page_hash(inode, offset);
6608- page = __find_page(inode, offset, *hash);
6609+ pgoff = loff2pgoff(offset);
6610+ hash = page_hash(inode, pgoff);
6611+ page = __find_page(inode, pgoff, *hash);
6612 if (!page)
6613 goto no_cached_page;
6614
6615@@ -1052,11 +1085,12 @@
6616 /*
6617 * Try to read in an entire cluster at once.
6618 */
6619- reada = offset;
6620- reada >>= PAGE_CACHE_SHIFT + page_cluster;
6621- reada <<= PAGE_CACHE_SHIFT + page_cluster;
6622+ reada = loff2pgoff(offset);
6623+ /* Mask lowest 'page_cluster' worth of the lowest bits */
6624+ reada = ulong2pgoff(pgoff2ulong(reada) & ((~(0UL)) << page_cluster));
6625
6626- for (i = 1 << page_cluster; i > 0; --i, reada += PAGE_CACHE_SIZE)
6627+ for (i = 1 << page_cluster; i > 0;
6628+ --i, reada = ulong2pgoff(pgoff2ulong(reada)+1))
6629 new_page = try_to_read_ahead(file, reada, new_page);
6630
6631 if (!new_page)
6632@@ -1070,7 +1104,7 @@
6633 * cache.. The page we just got may be useful if we
6634 * can't share, so don't get rid of it here.
6635 */
6636- page = find_page(inode, offset);
6637+ page = find_page(inode, pgoff);
6638 if (page)
6639 goto found_page;
6640
6641@@ -1079,7 +1113,7 @@
6642 */
6643 page = page_cache_entry(new_page);
6644 new_page = 0;
6645- add_to_page_cache(page, inode, offset, hash);
6646+ add_to_page_cache(page, inode, pgoff, hash);
6647
6648 if (inode->i_op->readpage(file, page) != 0)
6649 goto failure;
6650@@ -1128,10 +1162,10 @@
6651 * if the disk is full.
6652 */
6653 static inline int do_write_page(struct inode * inode, struct file * file,
6654- const char * page, unsigned long offset)
6655+ const char * page, loff_t offset)
6656 {
6657 int retval;
6658- unsigned long size;
6659+ loff_t size;
6660 loff_t loff = offset;
6661 mm_segment_t old_fs;
6662
6663@@ -1155,7 +1189,7 @@
6664 }
6665
6666 static int filemap_write_page(struct vm_area_struct * vma,
6667- unsigned long offset,
6668+ loff_t offset,
6669 unsigned long page)
6670 {
6671 int result;
6672@@ -1189,7 +1223,7 @@
6673 */
6674 int filemap_swapout(struct vm_area_struct * vma, struct page * page)
6675 {
6676- return filemap_write_page(vma, page->offset, page_address(page));
6677+ return filemap_write_page(vma, pgoff2loff(page->index), page_address(page));
6678 }
6679
6680 static inline int filemap_sync_pte(pte_t * ptep, struct vm_area_struct *vma,
6681@@ -1553,7 +1587,7 @@
6682 {
6683 struct dentry *dentry = file->f_dentry;
6684 struct inode *inode = dentry->d_inode;
6685- unsigned long pos = *ppos;
6686+ loff_t pos = *ppos;
6687 unsigned long limit = current->rlim[RLIMIT_FSIZE].rlim_cur;
6688 struct page *page, **hash;
6689 unsigned long page_cache = 0;
6690@@ -1569,6 +1603,9 @@
6691 return error;
6692 }
6693
6694+ if (((ssize_t) count) < 0)
6695+ return -EINVAL;
6696+
6697 sync = file->f_flags & O_SYNC;
6698 written = 0;
6699
6700@@ -1579,31 +1616,39 @@
6701 * Check whether we've reached the file size limit.
6702 */
6703 status = -EFBIG;
6704- if (pos >= limit) {
6705+ if (limit != RLIM_INFINITY && pos >= limit) {
6706 send_sig(SIGXFSZ, current, 0);
6707 goto out;
6708 }
6709
6710+ /* L-F-S */
6711+ if (!(file->f_flags & O_LARGEFILE) &&
6712+ S_ISREG(inode->i_mode) && count) {
6713+ if (pos >= 0x7fffffff) /* pos@2G forbidden */
6714+ goto out;
6715+
6716+ if (pos + count > 0x7fffffff)
6717+ count = 0x7fffffff - pos;
6718+ }
6719+
6720 status = 0;
6721 /*
6722 * Check whether to truncate the write,
6723 * and send the signal if we do.
6724 */
6725- if (count > limit - pos) {
6726- send_sig(SIGXFSZ, current, 0);
6727+ if (limit != RLIM_INFINITY && count > limit - pos)
6728 count = limit - pos;
6729- }
6730
6731 while (count) {
6732- unsigned long bytes, pgpos, offset;
6733+ unsigned long bytes, offset;
6734+ pgoff_t pgpos = loff2pgoff(pos);
6735 char * dest;
6736
6737 /*
6738 * Try to find the page in the cache. If it isn't there,
6739 * allocate a free page.
6740 */
6741- offset = (pos & ~PAGE_CACHE_MASK);
6742- pgpos = pos & PAGE_CACHE_MASK;
6743+ offset = ((unsigned long)pos & ~PAGE_CACHE_MASK);
6744 bytes = PAGE_CACHE_SIZE - offset;
6745 if (bytes > count)
6746 bytes = count;
6747@@ -1681,15 +1726,14 @@
6748 * Note: we don't have to worry about races here, as the caller
6749 * is holding the inode semaphore.
6750 */
6751-unsigned long get_cached_page(struct inode * inode, unsigned long offset,
6752- int new)
6753+unsigned long get_cached_page(struct inode * inode, pgoff_t pgoff, int new)
6754 {
6755 struct page * page;
6756 struct page ** hash;
6757 unsigned long page_cache = 0;
6758
6759- hash = page_hash(inode, offset);
6760- page = __find_page(inode, offset, *hash);
6761+ hash = page_hash(inode, pgoff);
6762+ page = __find_page(inode, pgoff, *hash);
6763 if (!page) {
6764 if (!new)
6765 goto out;
6766@@ -1698,7 +1742,7 @@
6767 goto out;
6768 clear_page(page_cache);
6769 page = page_cache_entry(page_cache);
6770- add_to_page_cache(page, inode, offset, hash);
6771+ add_to_page_cache(page, inode, pgoff, hash);
6772 }
6773 if (atomic_read(&page->count) != 2)
6774 printk(KERN_ERR "get_cached_page: page count=%d\n",
6775diff -urN lfs-ref/mm/memory.c lfs/mm/memory.c
6776--- lfs-ref/mm/memory.c Wed Sep 12 02:39:58 2001
6777+++ lfs/mm/memory.c Wed Sep 12 02:42:15 2001
6778@@ -862,7 +862,7 @@
6779 case 2:
6780 if (!PageSwapCache(page_map))
6781 break;
6782- if (swap_count(page_map->offset) != 1)
6783+ if (swap_count(pgoff2ulong(page_map->index)) != 1)
6784 break;
6785 delete_from_swap_cache(page_map);
6786 /* FallThrough */
6787@@ -986,7 +986,7 @@
6788 * between the file and the memory map for a potential last
6789 * incomplete page. Ugly, but necessary.
6790 */
6791-void vmtruncate(struct inode * inode, unsigned long offset)
6792+void vmtruncate(struct inode * inode, loff_t offset)
6793 {
6794 truncate_inode_pages(inode, offset);
6795 if (inode->i_mmap)
6796diff -urN lfs-ref/mm/mmap.c lfs/mm/mmap.c
6797--- lfs-ref/mm/mmap.c Wed Sep 12 02:39:57 2001
6798+++ lfs/mm/mmap.c Wed Sep 12 02:42:15 2001
6799@@ -169,11 +169,25 @@
6800 #undef _trans
6801 }
6802
6803-unsigned long do_mmap(struct file * file, unsigned long addr, unsigned long len,
6804- unsigned long prot, unsigned long flags, unsigned long off)
6805+unsigned long do_mmap(struct file *file, unsigned long addr,
6806+ unsigned long len, unsigned long prot,
6807+ unsigned long flag, unsigned long offset)
6808+{
6809+ unsigned long ret = -EINVAL;
6810+ if ((offset + PAGE_ALIGN(len)) < offset)
6811+ goto out;
6812+ if (!(offset & ~PAGE_MASK))
6813+ ret = do_mmap_pgoff(file, addr, len, prot, flag, offset >> PAGE_SHIFT);
6814+out:
6815+ return ret;
6816+}
6817+
6818+unsigned long do_mmap_pgoff(struct file * file, unsigned long addr, unsigned long len,
6819+ unsigned long prot, unsigned long flags, unsigned long pg_off)
6820 {
6821 struct mm_struct * mm = current->mm;
6822 struct vm_area_struct * vma;
6823+ loff_t off = (loff_t)pg_off << PAGE_SHIFT;
6824 int error;
6825
6826 if (file && (!file->f_op || !file->f_op->mmap))
6827@@ -847,7 +861,8 @@
6828 * the offsets must be contiguous..
6829 */
6830 if ((mpnt->vm_file != NULL) || (mpnt->vm_flags & VM_SHM)) {
6831- unsigned long off = prev->vm_offset+prev->vm_end-prev->vm_start;
6832+ loff_t off = (prev->vm_offset +
6833+ (loff_t)(prev->vm_end - prev->vm_start));
6834 if (off != mpnt->vm_offset)
6835 continue;
6836 }
6837diff -urN lfs-ref/mm/page_alloc.c lfs/mm/page_alloc.c
6838--- lfs-ref/mm/page_alloc.c Wed Sep 12 02:39:57 2001
6839+++ lfs/mm/page_alloc.c Wed Sep 12 02:42:15 2001
6840@@ -115,7 +115,7 @@
6841 add_mem_queue(area, list(map_nr));
6842
6843 static void free_local_pages(struct page * page) {
6844- unsigned long order = page->offset;
6845+ unsigned long order = page->index;
6846 unsigned int type = PageDMA(page) ? 1 : 0;
6847 struct free_area_struct *area;
6848 unsigned long map_nr = page - mem_map;
6849@@ -172,7 +172,7 @@
6850
6851 page = mem_map + map_nr;
6852 list_add((struct list_head *) page, &current->local_pages);
6853- page->offset = order;
6854+ page->index = order;
6855 current->nr_local_pages++;
6856 }
6857
6858diff -urN lfs-ref/mm/page_io.c lfs/mm/page_io.c
6859--- lfs-ref/mm/page_io.c Tue Jun 13 03:48:15 2000
6860+++ lfs/mm/page_io.c Wed Sep 12 02:42:15 2001
6861@@ -112,7 +112,7 @@
6862 * as if it were: we are not allowed to manipulate the inode
6863 * hashing for locked pages.
6864 */
6865- if (page->offset != entry) {
6866+ if (pgoff2ulong(page->index) != entry) {
6867 printk ("swap entry mismatch");
6868 return;
6869 }
6870@@ -265,8 +265,8 @@
6871 printk("VM: swap page is not in swap cache\n");
6872 return;
6873 }
6874- if (page->offset != entry) {
6875- printk ("swap entry mismatch");
6876+ if (pgoff2ulong(page->index) != entry) {
6877+ printk ("VM: swap entry mismatch");
6878 return;
6879 }
6880 rw_swap_page_base(rw, entry, page, wait);
6881@@ -291,12 +291,12 @@
6882 printk ("VM: read_swap_page: page already in page cache!\n");
6883 return;
6884 }
6885- page->inode = &swapper_inode;
6886- page->offset = entry;
6887+ page->inode = &swapper_inode;
6888+ page->index = ulong2pgoff(entry);
6889 atomic_inc(&page->count); /* Protect from shrink_mmap() */
6890 rw_swap_page(rw, entry, buffer, 1);
6891 atomic_dec(&page->count);
6892- page->inode = 0;
6893+ page->inode = 0;
6894 clear_bit(PG_swap_cache, &page->flags);
6895 }
6896
6897diff -urN lfs-ref/mm/swap_state.c lfs/mm/swap_state.c
6898--- lfs-ref/mm/swap_state.c Fri Apr 20 22:31:21 2001
6899+++ lfs/mm/swap_state.c Wed Sep 12 02:42:15 2001
6900@@ -54,7 +54,7 @@
6901 if (PageTestandSetSwapCache(page)) {
6902 printk(KERN_ERR "swap_cache: replacing non-empty entry %08lx "
6903 "on page %08lx\n",
6904- page->offset, page_address(page));
6905+ pgoff2ulong(page->index), page_address(page));
6906 return 0;
6907 }
6908 if (page->inode) {
6909@@ -65,8 +65,8 @@
6910 atomic_inc(&page->count);
6911 page->flags = page->flags & ~((1 << PG_uptodate) | (1 << PG_error) | (1 << PG_referenced));
6912 page->inode = &swapper_inode;
6913- page->offset = entry;
6914- add_page_to_hash_queue(page, &swapper_inode, entry);
6915+ page->index = ulong2pgoff(entry);
6916+ add_page_to_hash_queue(page, &swapper_inode, ulong2pgoff(entry));
6917 add_page_to_inode_queue(&swapper_inode, page);
6918 return 1;
6919 }
6920@@ -204,7 +204,7 @@
6921 */
6922 void delete_from_swap_cache(struct page *page)
6923 {
6924- long entry = page->offset;
6925+ long entry = pgoff2ulong(page->index);
6926
6927 #ifdef SWAP_CACHE_INFO
6928 swap_cache_del_total++;
6929@@ -252,7 +252,7 @@
6930 swap_cache_find_total++;
6931 #endif
6932 while (1) {
6933- found = find_page(&swapper_inode, entry);
6934+ found = find_page(&swapper_inode, ulong2pgoff(entry));
6935 if (!found)
6936 return 0;
6937 if (found->inode != &swapper_inode || !PageSwapCache(found))
6938diff -urN lfs-ref/mm/vmscan.c lfs/mm/vmscan.c
6939--- lfs-ref/mm/vmscan.c Wed Sep 12 02:39:57 2001
6940+++ lfs/mm/vmscan.c Wed Sep 12 02:42:15 2001
6941@@ -74,7 +74,7 @@
6942 * memory, and we should just continue our scan.
6943 */
6944 if (PageSwapCache(page_map)) {
6945- entry = page_map->offset;
6946+ entry = pgoff2ulong(page_map->index);
6947 swap_duplicate(entry);
6948 set_pte(page_table, __pte(entry));
6949 drop_pte:
The Linux kernel (the core of the Linux operating system)
This page took 0.930783 seconds and 4 git commands to generate.