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