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