x86/mce: Recover from poison found while copying from user space
[linux-2.6-microblaze.git] / fs / stat.c
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  *  linux/fs/stat.c
4  *
5  *  Copyright (C) 1991, 1992  Linus Torvalds
6  */
7
8 #include <linux/export.h>
9 #include <linux/mm.h>
10 #include <linux/errno.h>
11 #include <linux/file.h>
12 #include <linux/highuid.h>
13 #include <linux/fs.h>
14 #include <linux/namei.h>
15 #include <linux/security.h>
16 #include <linux/cred.h>
17 #include <linux/syscalls.h>
18 #include <linux/pagemap.h>
19 #include <linux/compat.h>
20
21 #include <linux/uaccess.h>
22 #include <asm/unistd.h>
23
24 #include "internal.h"
25 #include "mount.h"
26
27 /**
28  * generic_fillattr - Fill in the basic attributes from the inode struct
29  * @inode: Inode to use as the source
30  * @stat: Where to fill in the attributes
31  *
32  * Fill in the basic attributes in the kstat structure from data that's to be
33  * found on the VFS inode structure.  This is the default if no getattr inode
34  * operation is supplied.
35  */
36 void generic_fillattr(struct inode *inode, struct kstat *stat)
37 {
38         stat->dev = inode->i_sb->s_dev;
39         stat->ino = inode->i_ino;
40         stat->mode = inode->i_mode;
41         stat->nlink = inode->i_nlink;
42         stat->uid = inode->i_uid;
43         stat->gid = inode->i_gid;
44         stat->rdev = inode->i_rdev;
45         stat->size = i_size_read(inode);
46         stat->atime = inode->i_atime;
47         stat->mtime = inode->i_mtime;
48         stat->ctime = inode->i_ctime;
49         stat->blksize = i_blocksize(inode);
50         stat->blocks = inode->i_blocks;
51 }
52 EXPORT_SYMBOL(generic_fillattr);
53
54 /**
55  * vfs_getattr_nosec - getattr without security checks
56  * @path: file to get attributes from
57  * @stat: structure to return attributes in
58  * @request_mask: STATX_xxx flags indicating what the caller wants
59  * @query_flags: Query mode (KSTAT_QUERY_FLAGS)
60  *
61  * Get attributes without calling security_inode_getattr.
62  *
63  * Currently the only caller other than vfs_getattr is internal to the
64  * filehandle lookup code, which uses only the inode number and returns no
65  * attributes to any user.  Any other code probably wants vfs_getattr.
66  */
67 int vfs_getattr_nosec(const struct path *path, struct kstat *stat,
68                       u32 request_mask, unsigned int query_flags)
69 {
70         struct inode *inode = d_backing_inode(path->dentry);
71
72         memset(stat, 0, sizeof(*stat));
73         stat->result_mask |= STATX_BASIC_STATS;
74         query_flags &= KSTAT_QUERY_FLAGS;
75
76         /* allow the fs to override these if it really wants to */
77         /* SB_NOATIME means filesystem supplies dummy atime value */
78         if (inode->i_sb->s_flags & SB_NOATIME)
79                 stat->result_mask &= ~STATX_ATIME;
80         if (IS_AUTOMOUNT(inode))
81                 stat->attributes |= STATX_ATTR_AUTOMOUNT;
82
83         if (IS_DAX(inode))
84                 stat->attributes |= STATX_ATTR_DAX;
85
86         if (inode->i_op->getattr)
87                 return inode->i_op->getattr(path, stat, request_mask,
88                                             query_flags);
89
90         generic_fillattr(inode, stat);
91         return 0;
92 }
93 EXPORT_SYMBOL(vfs_getattr_nosec);
94
95 /*
96  * vfs_getattr - Get the enhanced basic attributes of a file
97  * @path: The file of interest
98  * @stat: Where to return the statistics
99  * @request_mask: STATX_xxx flags indicating what the caller wants
100  * @query_flags: Query mode (KSTAT_QUERY_FLAGS)
101  *
102  * Ask the filesystem for a file's attributes.  The caller must indicate in
103  * request_mask and query_flags to indicate what they want.
104  *
105  * If the file is remote, the filesystem can be forced to update the attributes
106  * from the backing store by passing AT_STATX_FORCE_SYNC in query_flags or can
107  * suppress the update by passing AT_STATX_DONT_SYNC.
108  *
109  * Bits must have been set in request_mask to indicate which attributes the
110  * caller wants retrieving.  Any such attribute not requested may be returned
111  * anyway, but the value may be approximate, and, if remote, may not have been
112  * synchronised with the server.
113  *
114  * 0 will be returned on success, and a -ve error code if unsuccessful.
115  */
116 int vfs_getattr(const struct path *path, struct kstat *stat,
117                 u32 request_mask, unsigned int query_flags)
118 {
119         int retval;
120
121         retval = security_inode_getattr(path);
122         if (retval)
123                 return retval;
124         return vfs_getattr_nosec(path, stat, request_mask, query_flags);
125 }
126 EXPORT_SYMBOL(vfs_getattr);
127
128 /**
129  * vfs_statx_fd - Get the enhanced basic attributes by file descriptor
130  * @fd: The file descriptor referring to the file of interest
131  * @stat: The result structure to fill in.
132  * @request_mask: STATX_xxx flags indicating what the caller wants
133  * @query_flags: Query mode (KSTAT_QUERY_FLAGS)
134  *
135  * This function is a wrapper around vfs_getattr().  The main difference is
136  * that it uses a file descriptor to determine the file location.
137  *
138  * 0 will be returned on success, and a -ve error code if unsuccessful.
139  */
140 int vfs_statx_fd(unsigned int fd, struct kstat *stat,
141                  u32 request_mask, unsigned int query_flags)
142 {
143         struct fd f;
144         int error = -EBADF;
145
146         if (query_flags & ~KSTAT_QUERY_FLAGS)
147                 return -EINVAL;
148
149         f = fdget_raw(fd);
150         if (f.file) {
151                 error = vfs_getattr(&f.file->f_path, stat,
152                                     request_mask, query_flags);
153                 fdput(f);
154         }
155         return error;
156 }
157 EXPORT_SYMBOL(vfs_statx_fd);
158
159 static inline unsigned vfs_stat_set_lookup_flags(unsigned *lookup_flags,
160                                                  int flags)
161 {
162         if ((flags & ~(AT_SYMLINK_NOFOLLOW | AT_NO_AUTOMOUNT |
163                        AT_EMPTY_PATH | KSTAT_QUERY_FLAGS)) != 0)
164                 return -EINVAL;
165
166         *lookup_flags = LOOKUP_FOLLOW | LOOKUP_AUTOMOUNT;
167         if (flags & AT_SYMLINK_NOFOLLOW)
168                 *lookup_flags &= ~LOOKUP_FOLLOW;
169         if (flags & AT_NO_AUTOMOUNT)
170                 *lookup_flags &= ~LOOKUP_AUTOMOUNT;
171         if (flags & AT_EMPTY_PATH)
172                 *lookup_flags |= LOOKUP_EMPTY;
173
174         return 0;
175 }
176
177 /**
178  * vfs_statx - Get basic and extra attributes by filename
179  * @dfd: A file descriptor representing the base dir for a relative filename
180  * @filename: The name of the file of interest
181  * @flags: Flags to control the query
182  * @stat: The result structure to fill in.
183  * @request_mask: STATX_xxx flags indicating what the caller wants
184  *
185  * This function is a wrapper around vfs_getattr().  The main difference is
186  * that it uses a filename and base directory to determine the file location.
187  * Additionally, the use of AT_SYMLINK_NOFOLLOW in flags will prevent a symlink
188  * at the given name from being referenced.
189  *
190  * 0 will be returned on success, and a -ve error code if unsuccessful.
191  */
192 int vfs_statx(int dfd, const char __user *filename, int flags,
193               struct kstat *stat, u32 request_mask)
194 {
195         struct path path;
196         int error = -EINVAL;
197         unsigned lookup_flags;
198
199         if (vfs_stat_set_lookup_flags(&lookup_flags, flags))
200                 return -EINVAL;
201 retry:
202         error = user_path_at(dfd, filename, lookup_flags, &path);
203         if (error)
204                 goto out;
205
206         error = vfs_getattr(&path, stat, request_mask, flags);
207         stat->mnt_id = real_mount(path.mnt)->mnt_id;
208         stat->result_mask |= STATX_MNT_ID;
209         if (path.mnt->mnt_root == path.dentry)
210                 stat->attributes |= STATX_ATTR_MOUNT_ROOT;
211         stat->attributes_mask |= STATX_ATTR_MOUNT_ROOT;
212         path_put(&path);
213         if (retry_estale(error, lookup_flags)) {
214                 lookup_flags |= LOOKUP_REVAL;
215                 goto retry;
216         }
217 out:
218         return error;
219 }
220 EXPORT_SYMBOL(vfs_statx);
221
222
223 #ifdef __ARCH_WANT_OLD_STAT
224
225 /*
226  * For backward compatibility?  Maybe this should be moved
227  * into arch/i386 instead?
228  */
229 static int cp_old_stat(struct kstat *stat, struct __old_kernel_stat __user * statbuf)
230 {
231         static int warncount = 5;
232         struct __old_kernel_stat tmp;
233
234         if (warncount > 0) {
235                 warncount--;
236                 printk(KERN_WARNING "VFS: Warning: %s using old stat() call. Recompile your binary.\n",
237                         current->comm);
238         } else if (warncount < 0) {
239                 /* it's laughable, but... */
240                 warncount = 0;
241         }
242
243         memset(&tmp, 0, sizeof(struct __old_kernel_stat));
244         tmp.st_dev = old_encode_dev(stat->dev);
245         tmp.st_ino = stat->ino;
246         if (sizeof(tmp.st_ino) < sizeof(stat->ino) && tmp.st_ino != stat->ino)
247                 return -EOVERFLOW;
248         tmp.st_mode = stat->mode;
249         tmp.st_nlink = stat->nlink;
250         if (tmp.st_nlink != stat->nlink)
251                 return -EOVERFLOW;
252         SET_UID(tmp.st_uid, from_kuid_munged(current_user_ns(), stat->uid));
253         SET_GID(tmp.st_gid, from_kgid_munged(current_user_ns(), stat->gid));
254         tmp.st_rdev = old_encode_dev(stat->rdev);
255 #if BITS_PER_LONG == 32
256         if (stat->size > MAX_NON_LFS)
257                 return -EOVERFLOW;
258 #endif
259         tmp.st_size = stat->size;
260         tmp.st_atime = stat->atime.tv_sec;
261         tmp.st_mtime = stat->mtime.tv_sec;
262         tmp.st_ctime = stat->ctime.tv_sec;
263         return copy_to_user(statbuf,&tmp,sizeof(tmp)) ? -EFAULT : 0;
264 }
265
266 SYSCALL_DEFINE2(stat, const char __user *, filename,
267                 struct __old_kernel_stat __user *, statbuf)
268 {
269         struct kstat stat;
270         int error;
271
272         error = vfs_stat(filename, &stat);
273         if (error)
274                 return error;
275
276         return cp_old_stat(&stat, statbuf);
277 }
278
279 SYSCALL_DEFINE2(lstat, const char __user *, filename,
280                 struct __old_kernel_stat __user *, statbuf)
281 {
282         struct kstat stat;
283         int error;
284
285         error = vfs_lstat(filename, &stat);
286         if (error)
287                 return error;
288
289         return cp_old_stat(&stat, statbuf);
290 }
291
292 SYSCALL_DEFINE2(fstat, unsigned int, fd, struct __old_kernel_stat __user *, statbuf)
293 {
294         struct kstat stat;
295         int error = vfs_fstat(fd, &stat);
296
297         if (!error)
298                 error = cp_old_stat(&stat, statbuf);
299
300         return error;
301 }
302
303 #endif /* __ARCH_WANT_OLD_STAT */
304
305 #ifdef __ARCH_WANT_NEW_STAT
306
307 #if BITS_PER_LONG == 32
308 #  define choose_32_64(a,b) a
309 #else
310 #  define choose_32_64(a,b) b
311 #endif
312
313 #define valid_dev(x)  choose_32_64(old_valid_dev(x),true)
314 #define encode_dev(x) choose_32_64(old_encode_dev,new_encode_dev)(x)
315
316 #ifndef INIT_STRUCT_STAT_PADDING
317 #  define INIT_STRUCT_STAT_PADDING(st) memset(&st, 0, sizeof(st))
318 #endif
319
320 static int cp_new_stat(struct kstat *stat, struct stat __user *statbuf)
321 {
322         struct stat tmp;
323
324         if (!valid_dev(stat->dev) || !valid_dev(stat->rdev))
325                 return -EOVERFLOW;
326 #if BITS_PER_LONG == 32
327         if (stat->size > MAX_NON_LFS)
328                 return -EOVERFLOW;
329 #endif
330
331         INIT_STRUCT_STAT_PADDING(tmp);
332         tmp.st_dev = encode_dev(stat->dev);
333         tmp.st_ino = stat->ino;
334         if (sizeof(tmp.st_ino) < sizeof(stat->ino) && tmp.st_ino != stat->ino)
335                 return -EOVERFLOW;
336         tmp.st_mode = stat->mode;
337         tmp.st_nlink = stat->nlink;
338         if (tmp.st_nlink != stat->nlink)
339                 return -EOVERFLOW;
340         SET_UID(tmp.st_uid, from_kuid_munged(current_user_ns(), stat->uid));
341         SET_GID(tmp.st_gid, from_kgid_munged(current_user_ns(), stat->gid));
342         tmp.st_rdev = encode_dev(stat->rdev);
343         tmp.st_size = stat->size;
344         tmp.st_atime = stat->atime.tv_sec;
345         tmp.st_mtime = stat->mtime.tv_sec;
346         tmp.st_ctime = stat->ctime.tv_sec;
347 #ifdef STAT_HAVE_NSEC
348         tmp.st_atime_nsec = stat->atime.tv_nsec;
349         tmp.st_mtime_nsec = stat->mtime.tv_nsec;
350         tmp.st_ctime_nsec = stat->ctime.tv_nsec;
351 #endif
352         tmp.st_blocks = stat->blocks;
353         tmp.st_blksize = stat->blksize;
354         return copy_to_user(statbuf,&tmp,sizeof(tmp)) ? -EFAULT : 0;
355 }
356
357 SYSCALL_DEFINE2(newstat, const char __user *, filename,
358                 struct stat __user *, statbuf)
359 {
360         struct kstat stat;
361         int error = vfs_stat(filename, &stat);
362
363         if (error)
364                 return error;
365         return cp_new_stat(&stat, statbuf);
366 }
367
368 SYSCALL_DEFINE2(newlstat, const char __user *, filename,
369                 struct stat __user *, statbuf)
370 {
371         struct kstat stat;
372         int error;
373
374         error = vfs_lstat(filename, &stat);
375         if (error)
376                 return error;
377
378         return cp_new_stat(&stat, statbuf);
379 }
380
381 #if !defined(__ARCH_WANT_STAT64) || defined(__ARCH_WANT_SYS_NEWFSTATAT)
382 SYSCALL_DEFINE4(newfstatat, int, dfd, const char __user *, filename,
383                 struct stat __user *, statbuf, int, flag)
384 {
385         struct kstat stat;
386         int error;
387
388         error = vfs_fstatat(dfd, filename, &stat, flag);
389         if (error)
390                 return error;
391         return cp_new_stat(&stat, statbuf);
392 }
393 #endif
394
395 SYSCALL_DEFINE2(newfstat, unsigned int, fd, struct stat __user *, statbuf)
396 {
397         struct kstat stat;
398         int error = vfs_fstat(fd, &stat);
399
400         if (!error)
401                 error = cp_new_stat(&stat, statbuf);
402
403         return error;
404 }
405 #endif
406
407 static int do_readlinkat(int dfd, const char __user *pathname,
408                          char __user *buf, int bufsiz)
409 {
410         struct path path;
411         int error;
412         int empty = 0;
413         unsigned int lookup_flags = LOOKUP_EMPTY;
414
415         if (bufsiz <= 0)
416                 return -EINVAL;
417
418 retry:
419         error = user_path_at_empty(dfd, pathname, lookup_flags, &path, &empty);
420         if (!error) {
421                 struct inode *inode = d_backing_inode(path.dentry);
422
423                 error = empty ? -ENOENT : -EINVAL;
424                 /*
425                  * AFS mountpoints allow readlink(2) but are not symlinks
426                  */
427                 if (d_is_symlink(path.dentry) || inode->i_op->readlink) {
428                         error = security_inode_readlink(path.dentry);
429                         if (!error) {
430                                 touch_atime(&path);
431                                 error = vfs_readlink(path.dentry, buf, bufsiz);
432                         }
433                 }
434                 path_put(&path);
435                 if (retry_estale(error, lookup_flags)) {
436                         lookup_flags |= LOOKUP_REVAL;
437                         goto retry;
438                 }
439         }
440         return error;
441 }
442
443 SYSCALL_DEFINE4(readlinkat, int, dfd, const char __user *, pathname,
444                 char __user *, buf, int, bufsiz)
445 {
446         return do_readlinkat(dfd, pathname, buf, bufsiz);
447 }
448
449 SYSCALL_DEFINE3(readlink, const char __user *, path, char __user *, buf,
450                 int, bufsiz)
451 {
452         return do_readlinkat(AT_FDCWD, path, buf, bufsiz);
453 }
454
455
456 /* ---------- LFS-64 ----------- */
457 #if defined(__ARCH_WANT_STAT64) || defined(__ARCH_WANT_COMPAT_STAT64)
458
459 #ifndef INIT_STRUCT_STAT64_PADDING
460 #  define INIT_STRUCT_STAT64_PADDING(st) memset(&st, 0, sizeof(st))
461 #endif
462
463 static long cp_new_stat64(struct kstat *stat, struct stat64 __user *statbuf)
464 {
465         struct stat64 tmp;
466
467         INIT_STRUCT_STAT64_PADDING(tmp);
468 #ifdef CONFIG_MIPS
469         /* mips has weird padding, so we don't get 64 bits there */
470         tmp.st_dev = new_encode_dev(stat->dev);
471         tmp.st_rdev = new_encode_dev(stat->rdev);
472 #else
473         tmp.st_dev = huge_encode_dev(stat->dev);
474         tmp.st_rdev = huge_encode_dev(stat->rdev);
475 #endif
476         tmp.st_ino = stat->ino;
477         if (sizeof(tmp.st_ino) < sizeof(stat->ino) && tmp.st_ino != stat->ino)
478                 return -EOVERFLOW;
479 #ifdef STAT64_HAS_BROKEN_ST_INO
480         tmp.__st_ino = stat->ino;
481 #endif
482         tmp.st_mode = stat->mode;
483         tmp.st_nlink = stat->nlink;
484         tmp.st_uid = from_kuid_munged(current_user_ns(), stat->uid);
485         tmp.st_gid = from_kgid_munged(current_user_ns(), stat->gid);
486         tmp.st_atime = stat->atime.tv_sec;
487         tmp.st_atime_nsec = stat->atime.tv_nsec;
488         tmp.st_mtime = stat->mtime.tv_sec;
489         tmp.st_mtime_nsec = stat->mtime.tv_nsec;
490         tmp.st_ctime = stat->ctime.tv_sec;
491         tmp.st_ctime_nsec = stat->ctime.tv_nsec;
492         tmp.st_size = stat->size;
493         tmp.st_blocks = stat->blocks;
494         tmp.st_blksize = stat->blksize;
495         return copy_to_user(statbuf,&tmp,sizeof(tmp)) ? -EFAULT : 0;
496 }
497
498 SYSCALL_DEFINE2(stat64, const char __user *, filename,
499                 struct stat64 __user *, statbuf)
500 {
501         struct kstat stat;
502         int error = vfs_stat(filename, &stat);
503
504         if (!error)
505                 error = cp_new_stat64(&stat, statbuf);
506
507         return error;
508 }
509
510 SYSCALL_DEFINE2(lstat64, const char __user *, filename,
511                 struct stat64 __user *, statbuf)
512 {
513         struct kstat stat;
514         int error = vfs_lstat(filename, &stat);
515
516         if (!error)
517                 error = cp_new_stat64(&stat, statbuf);
518
519         return error;
520 }
521
522 SYSCALL_DEFINE2(fstat64, unsigned long, fd, struct stat64 __user *, statbuf)
523 {
524         struct kstat stat;
525         int error = vfs_fstat(fd, &stat);
526
527         if (!error)
528                 error = cp_new_stat64(&stat, statbuf);
529
530         return error;
531 }
532
533 SYSCALL_DEFINE4(fstatat64, int, dfd, const char __user *, filename,
534                 struct stat64 __user *, statbuf, int, flag)
535 {
536         struct kstat stat;
537         int error;
538
539         error = vfs_fstatat(dfd, filename, &stat, flag);
540         if (error)
541                 return error;
542         return cp_new_stat64(&stat, statbuf);
543 }
544 #endif /* __ARCH_WANT_STAT64 || __ARCH_WANT_COMPAT_STAT64 */
545
546 static noinline_for_stack int
547 cp_statx(const struct kstat *stat, struct statx __user *buffer)
548 {
549         struct statx tmp;
550
551         memset(&tmp, 0, sizeof(tmp));
552
553         tmp.stx_mask = stat->result_mask;
554         tmp.stx_blksize = stat->blksize;
555         tmp.stx_attributes = stat->attributes;
556         tmp.stx_nlink = stat->nlink;
557         tmp.stx_uid = from_kuid_munged(current_user_ns(), stat->uid);
558         tmp.stx_gid = from_kgid_munged(current_user_ns(), stat->gid);
559         tmp.stx_mode = stat->mode;
560         tmp.stx_ino = stat->ino;
561         tmp.stx_size = stat->size;
562         tmp.stx_blocks = stat->blocks;
563         tmp.stx_attributes_mask = stat->attributes_mask;
564         tmp.stx_atime.tv_sec = stat->atime.tv_sec;
565         tmp.stx_atime.tv_nsec = stat->atime.tv_nsec;
566         tmp.stx_btime.tv_sec = stat->btime.tv_sec;
567         tmp.stx_btime.tv_nsec = stat->btime.tv_nsec;
568         tmp.stx_ctime.tv_sec = stat->ctime.tv_sec;
569         tmp.stx_ctime.tv_nsec = stat->ctime.tv_nsec;
570         tmp.stx_mtime.tv_sec = stat->mtime.tv_sec;
571         tmp.stx_mtime.tv_nsec = stat->mtime.tv_nsec;
572         tmp.stx_rdev_major = MAJOR(stat->rdev);
573         tmp.stx_rdev_minor = MINOR(stat->rdev);
574         tmp.stx_dev_major = MAJOR(stat->dev);
575         tmp.stx_dev_minor = MINOR(stat->dev);
576         tmp.stx_mnt_id = stat->mnt_id;
577
578         return copy_to_user(buffer, &tmp, sizeof(tmp)) ? -EFAULT : 0;
579 }
580
581 int do_statx(int dfd, const char __user *filename, unsigned flags,
582              unsigned int mask, struct statx __user *buffer)
583 {
584         struct kstat stat;
585         int error;
586
587         if (mask & STATX__RESERVED)
588                 return -EINVAL;
589         if ((flags & AT_STATX_SYNC_TYPE) == AT_STATX_SYNC_TYPE)
590                 return -EINVAL;
591
592         error = vfs_statx(dfd, filename, flags, &stat, mask);
593         if (error)
594                 return error;
595
596         return cp_statx(&stat, buffer);
597 }
598
599 /**
600  * sys_statx - System call to get enhanced stats
601  * @dfd: Base directory to pathwalk from *or* fd to stat.
602  * @filename: File to stat or "" with AT_EMPTY_PATH
603  * @flags: AT_* flags to control pathwalk.
604  * @mask: Parts of statx struct actually required.
605  * @buffer: Result buffer.
606  *
607  * Note that fstat() can be emulated by setting dfd to the fd of interest,
608  * supplying "" as the filename and setting AT_EMPTY_PATH in the flags.
609  */
610 SYSCALL_DEFINE5(statx,
611                 int, dfd, const char __user *, filename, unsigned, flags,
612                 unsigned int, mask,
613                 struct statx __user *, buffer)
614 {
615         return do_statx(dfd, filename, flags, mask, buffer);
616 }
617
618 #ifdef CONFIG_COMPAT
619 static int cp_compat_stat(struct kstat *stat, struct compat_stat __user *ubuf)
620 {
621         struct compat_stat tmp;
622
623         if (!old_valid_dev(stat->dev) || !old_valid_dev(stat->rdev))
624                 return -EOVERFLOW;
625
626         memset(&tmp, 0, sizeof(tmp));
627         tmp.st_dev = old_encode_dev(stat->dev);
628         tmp.st_ino = stat->ino;
629         if (sizeof(tmp.st_ino) < sizeof(stat->ino) && tmp.st_ino != stat->ino)
630                 return -EOVERFLOW;
631         tmp.st_mode = stat->mode;
632         tmp.st_nlink = stat->nlink;
633         if (tmp.st_nlink != stat->nlink)
634                 return -EOVERFLOW;
635         SET_UID(tmp.st_uid, from_kuid_munged(current_user_ns(), stat->uid));
636         SET_GID(tmp.st_gid, from_kgid_munged(current_user_ns(), stat->gid));
637         tmp.st_rdev = old_encode_dev(stat->rdev);
638         if ((u64) stat->size > MAX_NON_LFS)
639                 return -EOVERFLOW;
640         tmp.st_size = stat->size;
641         tmp.st_atime = stat->atime.tv_sec;
642         tmp.st_atime_nsec = stat->atime.tv_nsec;
643         tmp.st_mtime = stat->mtime.tv_sec;
644         tmp.st_mtime_nsec = stat->mtime.tv_nsec;
645         tmp.st_ctime = stat->ctime.tv_sec;
646         tmp.st_ctime_nsec = stat->ctime.tv_nsec;
647         tmp.st_blocks = stat->blocks;
648         tmp.st_blksize = stat->blksize;
649         return copy_to_user(ubuf, &tmp, sizeof(tmp)) ? -EFAULT : 0;
650 }
651
652 COMPAT_SYSCALL_DEFINE2(newstat, const char __user *, filename,
653                        struct compat_stat __user *, statbuf)
654 {
655         struct kstat stat;
656         int error;
657
658         error = vfs_stat(filename, &stat);
659         if (error)
660                 return error;
661         return cp_compat_stat(&stat, statbuf);
662 }
663
664 COMPAT_SYSCALL_DEFINE2(newlstat, const char __user *, filename,
665                        struct compat_stat __user *, statbuf)
666 {
667         struct kstat stat;
668         int error;
669
670         error = vfs_lstat(filename, &stat);
671         if (error)
672                 return error;
673         return cp_compat_stat(&stat, statbuf);
674 }
675
676 #ifndef __ARCH_WANT_STAT64
677 COMPAT_SYSCALL_DEFINE4(newfstatat, unsigned int, dfd,
678                        const char __user *, filename,
679                        struct compat_stat __user *, statbuf, int, flag)
680 {
681         struct kstat stat;
682         int error;
683
684         error = vfs_fstatat(dfd, filename, &stat, flag);
685         if (error)
686                 return error;
687         return cp_compat_stat(&stat, statbuf);
688 }
689 #endif
690
691 COMPAT_SYSCALL_DEFINE2(newfstat, unsigned int, fd,
692                        struct compat_stat __user *, statbuf)
693 {
694         struct kstat stat;
695         int error = vfs_fstat(fd, &stat);
696
697         if (!error)
698                 error = cp_compat_stat(&stat, statbuf);
699         return error;
700 }
701 #endif
702
703 /* Caller is here responsible for sufficient locking (ie. inode->i_lock) */
704 void __inode_add_bytes(struct inode *inode, loff_t bytes)
705 {
706         inode->i_blocks += bytes >> 9;
707         bytes &= 511;
708         inode->i_bytes += bytes;
709         if (inode->i_bytes >= 512) {
710                 inode->i_blocks++;
711                 inode->i_bytes -= 512;
712         }
713 }
714 EXPORT_SYMBOL(__inode_add_bytes);
715
716 void inode_add_bytes(struct inode *inode, loff_t bytes)
717 {
718         spin_lock(&inode->i_lock);
719         __inode_add_bytes(inode, bytes);
720         spin_unlock(&inode->i_lock);
721 }
722
723 EXPORT_SYMBOL(inode_add_bytes);
724
725 void __inode_sub_bytes(struct inode *inode, loff_t bytes)
726 {
727         inode->i_blocks -= bytes >> 9;
728         bytes &= 511;
729         if (inode->i_bytes < bytes) {
730                 inode->i_blocks--;
731                 inode->i_bytes += 512;
732         }
733         inode->i_bytes -= bytes;
734 }
735
736 EXPORT_SYMBOL(__inode_sub_bytes);
737
738 void inode_sub_bytes(struct inode *inode, loff_t bytes)
739 {
740         spin_lock(&inode->i_lock);
741         __inode_sub_bytes(inode, bytes);
742         spin_unlock(&inode->i_lock);
743 }
744
745 EXPORT_SYMBOL(inode_sub_bytes);
746
747 loff_t inode_get_bytes(struct inode *inode)
748 {
749         loff_t ret;
750
751         spin_lock(&inode->i_lock);
752         ret = __inode_get_bytes(inode);
753         spin_unlock(&inode->i_lock);
754         return ret;
755 }
756
757 EXPORT_SYMBOL(inode_get_bytes);
758
759 void inode_set_bytes(struct inode *inode, loff_t bytes)
760 {
761         /* Caller is here responsible for sufficient locking
762          * (ie. inode->i_lock) */
763         inode->i_blocks = bytes >> 9;
764         inode->i_bytes = bytes & 511;
765 }
766
767 EXPORT_SYMBOL(inode_set_bytes);