Branch data Line data Source code
1 : : /*
2 : : * linux/fs/stat.c
3 : : *
4 : : * Copyright (C) 1991, 1992 Linus Torvalds
5 : : */
6 : :
7 : : #include <linux/export.h>
8 : : #include <linux/mm.h>
9 : : #include <linux/errno.h>
10 : : #include <linux/file.h>
11 : : #include <linux/highuid.h>
12 : : #include <linux/fs.h>
13 : : #include <linux/namei.h>
14 : : #include <linux/security.h>
15 : : #include <linux/syscalls.h>
16 : : #include <linux/pagemap.h>
17 : :
18 : : #include <asm/uaccess.h>
19 : : #include <asm/unistd.h>
20 : :
21 : 0 : void generic_fillattr(struct inode *inode, struct kstat *stat)
22 : : {
23 : 6405156 : stat->dev = inode->i_sb->s_dev;
24 : 6405156 : stat->ino = inode->i_ino;
25 : 6405156 : stat->mode = inode->i_mode;
26 : 6405156 : stat->nlink = inode->i_nlink;
27 : 6405156 : stat->uid = inode->i_uid;
28 : 6405156 : stat->gid = inode->i_gid;
29 : 6405156 : stat->rdev = inode->i_rdev;
30 : 6405193 : stat->size = i_size_read(inode);
31 : 6405193 : stat->atime = inode->i_atime;
32 : 6405193 : stat->mtime = inode->i_mtime;
33 : 6405193 : stat->ctime = inode->i_ctime;
34 : 6405193 : stat->blksize = (1 << inode->i_blkbits);
35 : 6405193 : stat->blocks = inode->i_blocks;
36 : 6405193 : }
37 : :
38 : : EXPORT_SYMBOL(generic_fillattr);
39 : :
40 : : /**
41 : : * vfs_getattr_nosec - getattr without security checks
42 : : * @path: file to get attributes from
43 : : * @stat: structure to return attributes in
44 : : *
45 : : * Get attributes without calling security_inode_getattr.
46 : : *
47 : : * Currently the only caller other than vfs_getattr is internal to the
48 : : * filehandle lookup code, which uses only the inode number and returns
49 : : * no attributes to any user. Any other code probably wants
50 : : * vfs_getattr.
51 : : */
52 : 0 : int vfs_getattr_nosec(struct path *path, struct kstat *stat)
53 : : {
54 : 6405242 : struct inode *inode = path->dentry->d_inode;
55 : :
56 [ + + ]: 6405242 : if (inode->i_op->getattr)
57 : 4703393 : return inode->i_op->getattr(path->mnt, path->dentry, stat);
58 : :
59 : 1701849 : generic_fillattr(inode, stat);
60 : 1701849 : return 0;
61 : : }
62 : :
63 : : EXPORT_SYMBOL(vfs_getattr_nosec);
64 : :
65 : 0 : int vfs_getattr(struct path *path, struct kstat *stat)
66 : : {
67 : : int retval;
68 : :
69 : 6405131 : retval = security_inode_getattr(path->mnt, path->dentry);
70 [ + ]: 6405224 : if (retval)
71 : : return retval;
72 : 6405237 : return vfs_getattr_nosec(path, stat);
73 : : }
74 : :
75 : : EXPORT_SYMBOL(vfs_getattr);
76 : :
77 : 0 : int vfs_fstat(unsigned int fd, struct kstat *stat)
78 : : {
79 : : struct fd f = fdget_raw(fd);
80 : : int error = -EBADF;
81 : :
82 [ + ]: 5847624 : if (f.file) {
83 : 5847691 : error = vfs_getattr(&f.file->f_path, stat);
84 : : fdput(f);
85 : : }
86 : 0 : return error;
87 : : }
88 : : EXPORT_SYMBOL(vfs_fstat);
89 : :
90 : 0 : int vfs_fstatat(int dfd, const char __user *filename, struct kstat *stat,
91 : : int flag)
92 : : {
93 : : struct path path;
94 : : int error = -EINVAL;
95 : : unsigned int lookup_flags = 0;
96 : :
97 [ + ]: 902381 : if ((flag & ~(AT_SYMLINK_NOFOLLOW | AT_NO_AUTOMOUNT |
98 : : AT_EMPTY_PATH)) != 0)
99 : : goto out;
100 : :
101 [ + + ]: 1804757 : if (!(flag & AT_SYMLINK_NOFOLLOW))
102 : : lookup_flags |= LOOKUP_FOLLOW;
103 [ - + ]: 902376 : if (flag & AT_EMPTY_PATH)
104 : 902376 : lookup_flags |= LOOKUP_EMPTY;
105 : : retry:
106 : 902376 : error = user_path_at(dfd, filename, lookup_flags, &path);
107 [ + + ]: 902414 : if (error)
108 : : goto out;
109 : :
110 : 557600 : error = vfs_getattr(&path, stat);
111 : 557571 : path_put(&path);
112 [ - + ]: 557599 : if (retry_estale(error, lookup_flags)) {
113 : 0 : lookup_flags |= LOOKUP_REVAL;
114 : 0 : goto retry;
115 : : }
116 : : out:
117 : 37 : return error;
118 : : }
119 : : EXPORT_SYMBOL(vfs_fstatat);
120 : :
121 : 0 : int vfs_stat(const char __user *name, struct kstat *stat)
122 : : {
123 : 702384 : return vfs_fstatat(AT_FDCWD, name, stat, 0);
124 : : }
125 : : EXPORT_SYMBOL(vfs_stat);
126 : :
127 : 0 : int vfs_lstat(const char __user *name, struct kstat *stat)
128 : : {
129 : 180156 : return vfs_fstatat(AT_FDCWD, name, stat, AT_SYMLINK_NOFOLLOW);
130 : : }
131 : : EXPORT_SYMBOL(vfs_lstat);
132 : :
133 : :
134 : : #ifdef __ARCH_WANT_OLD_STAT
135 : :
136 : : /*
137 : : * For backward compatibility? Maybe this should be moved
138 : : * into arch/i386 instead?
139 : : */
140 : : static int cp_old_stat(struct kstat *stat, struct __old_kernel_stat __user * statbuf)
141 : : {
142 : : static int warncount = 5;
143 : : struct __old_kernel_stat tmp;
144 : :
145 : : if (warncount > 0) {
146 : : warncount--;
147 : : printk(KERN_WARNING "VFS: Warning: %s using old stat() call. Recompile your binary.\n",
148 : : current->comm);
149 : : } else if (warncount < 0) {
150 : : /* it's laughable, but... */
151 : : warncount = 0;
152 : : }
153 : :
154 : : memset(&tmp, 0, sizeof(struct __old_kernel_stat));
155 : : tmp.st_dev = old_encode_dev(stat->dev);
156 : : tmp.st_ino = stat->ino;
157 : : if (sizeof(tmp.st_ino) < sizeof(stat->ino) && tmp.st_ino != stat->ino)
158 : : return -EOVERFLOW;
159 : : tmp.st_mode = stat->mode;
160 : : tmp.st_nlink = stat->nlink;
161 : : if (tmp.st_nlink != stat->nlink)
162 : : return -EOVERFLOW;
163 : : SET_UID(tmp.st_uid, from_kuid_munged(current_user_ns(), stat->uid));
164 : : SET_GID(tmp.st_gid, from_kgid_munged(current_user_ns(), stat->gid));
165 : : tmp.st_rdev = old_encode_dev(stat->rdev);
166 : : #if BITS_PER_LONG == 32
167 : : if (stat->size > MAX_NON_LFS)
168 : : return -EOVERFLOW;
169 : : #endif
170 : : tmp.st_size = stat->size;
171 : : tmp.st_atime = stat->atime.tv_sec;
172 : : tmp.st_mtime = stat->mtime.tv_sec;
173 : : tmp.st_ctime = stat->ctime.tv_sec;
174 : : return copy_to_user(statbuf,&tmp,sizeof(tmp)) ? -EFAULT : 0;
175 : : }
176 : :
177 : : SYSCALL_DEFINE2(stat, const char __user *, filename,
178 : : struct __old_kernel_stat __user *, statbuf)
179 : : {
180 : : struct kstat stat;
181 : : int error;
182 : :
183 : : error = vfs_stat(filename, &stat);
184 : : if (error)
185 : : return error;
186 : :
187 : : return cp_old_stat(&stat, statbuf);
188 : : }
189 : :
190 : : SYSCALL_DEFINE2(lstat, const char __user *, filename,
191 : : struct __old_kernel_stat __user *, statbuf)
192 : : {
193 : : struct kstat stat;
194 : : int error;
195 : :
196 : : error = vfs_lstat(filename, &stat);
197 : : if (error)
198 : : return error;
199 : :
200 : : return cp_old_stat(&stat, statbuf);
201 : : }
202 : :
203 : : SYSCALL_DEFINE2(fstat, unsigned int, fd, struct __old_kernel_stat __user *, statbuf)
204 : : {
205 : : struct kstat stat;
206 : : int error = vfs_fstat(fd, &stat);
207 : :
208 : : if (!error)
209 : : error = cp_old_stat(&stat, statbuf);
210 : :
211 : : return error;
212 : : }
213 : :
214 : : #endif /* __ARCH_WANT_OLD_STAT */
215 : :
216 : : #if BITS_PER_LONG == 32
217 : : # define choose_32_64(a,b) a
218 : : #else
219 : : # define choose_32_64(a,b) b
220 : : #endif
221 : :
222 : : #define valid_dev(x) choose_32_64(old_valid_dev,new_valid_dev)(x)
223 : : #define encode_dev(x) choose_32_64(old_encode_dev,new_encode_dev)(x)
224 : :
225 : : #ifndef INIT_STRUCT_STAT_PADDING
226 : : # define INIT_STRUCT_STAT_PADDING(st) memset(&st, 0, sizeof(st))
227 : : #endif
228 : :
229 : 0 : static int cp_new_stat(struct kstat *stat, struct stat __user *statbuf)
230 : : {
231 : : struct stat tmp;
232 : :
233 [ # # ][ # # ]: 0 : if (!valid_dev(stat->dev) || !valid_dev(stat->rdev))
234 : : return -EOVERFLOW;
235 : : #if BITS_PER_LONG == 32
236 [ # # ]: 0 : if (stat->size > MAX_NON_LFS)
237 : : return -EOVERFLOW;
238 : : #endif
239 : :
240 : 0 : INIT_STRUCT_STAT_PADDING(tmp);
241 : 0 : tmp.st_dev = encode_dev(stat->dev);
242 : 0 : tmp.st_ino = stat->ino;
243 [ # # ]: 0 : if (sizeof(tmp.st_ino) < sizeof(stat->ino) && tmp.st_ino != stat->ino)
244 : : return -EOVERFLOW;
245 : 0 : tmp.st_mode = stat->mode;
246 : 0 : tmp.st_nlink = stat->nlink;
247 [ # # ]: 0 : if (tmp.st_nlink != stat->nlink)
248 : : return -EOVERFLOW;
249 [ # # ]: 0 : SET_UID(tmp.st_uid, from_kuid_munged(current_user_ns(), stat->uid));
250 [ # # ]: 0 : SET_GID(tmp.st_gid, from_kgid_munged(current_user_ns(), stat->gid));
251 : 0 : tmp.st_rdev = encode_dev(stat->rdev);
252 : 0 : tmp.st_size = stat->size;
253 : 0 : tmp.st_atime = stat->atime.tv_sec;
254 : 0 : tmp.st_mtime = stat->mtime.tv_sec;
255 : 0 : tmp.st_ctime = stat->ctime.tv_sec;
256 : : #ifdef STAT_HAVE_NSEC
257 : 0 : tmp.st_atime_nsec = stat->atime.tv_nsec;
258 : 0 : tmp.st_mtime_nsec = stat->mtime.tv_nsec;
259 : 0 : tmp.st_ctime_nsec = stat->ctime.tv_nsec;
260 : : #endif
261 : 0 : tmp.st_blocks = stat->blocks;
262 : 0 : tmp.st_blksize = stat->blksize;
263 [ # # ]: 0 : return copy_to_user(statbuf,&tmp,sizeof(tmp)) ? -EFAULT : 0;
264 : : }
265 : :
266 : 0 : SYSCALL_DEFINE2(newstat, const char __user *, filename,
267 : : struct stat __user *, statbuf)
268 : : {
269 : : struct kstat stat;
270 : 0 : int error = vfs_stat(filename, &stat);
271 : :
272 [ # # ]: 0 : if (error)
273 : : return error;
274 : 0 : return cp_new_stat(&stat, statbuf);
275 : : }
276 : :
277 : 0 : SYSCALL_DEFINE2(newlstat, const char __user *, filename,
278 : : struct stat __user *, statbuf)
279 : : {
280 : : struct kstat stat;
281 : : int error;
282 : :
283 : 0 : error = vfs_lstat(filename, &stat);
284 [ # # ]: 0 : if (error)
285 : : return error;
286 : :
287 : 0 : return cp_new_stat(&stat, statbuf);
288 : : }
289 : :
290 : : #if !defined(__ARCH_WANT_STAT64) || defined(__ARCH_WANT_SYS_NEWFSTATAT)
291 : : SYSCALL_DEFINE4(newfstatat, int, dfd, const char __user *, filename,
292 : : struct stat __user *, statbuf, int, flag)
293 : : {
294 : : struct kstat stat;
295 : : int error;
296 : :
297 : : error = vfs_fstatat(dfd, filename, &stat, flag);
298 : : if (error)
299 : : return error;
300 : : return cp_new_stat(&stat, statbuf);
301 : : }
302 : : #endif
303 : :
304 : 0 : SYSCALL_DEFINE2(newfstat, unsigned int, fd, struct stat __user *, statbuf)
305 : : {
306 : : struct kstat stat;
307 : 0 : int error = vfs_fstat(fd, &stat);
308 : :
309 [ # # ]: 0 : if (!error)
310 : 0 : error = cp_new_stat(&stat, statbuf);
311 : :
312 : : return error;
313 : : }
314 : :
315 : 0 : SYSCALL_DEFINE4(readlinkat, int, dfd, const char __user *, pathname,
316 : : char __user *, buf, int, bufsiz)
317 : : {
318 : : struct path path;
319 : : int error;
320 : 63638 : int empty = 0;
321 : : unsigned int lookup_flags = LOOKUP_EMPTY;
322 : :
323 [ + + ]: 63638 : if (bufsiz <= 0)
324 : : return -EINVAL;
325 : :
326 : : retry:
327 : 63637 : error = user_path_at_empty(dfd, pathname, lookup_flags, &path, &empty);
328 [ + + ]: 63634 : if (!error) {
329 : 53338 : struct inode *inode = path.dentry->d_inode;
330 : :
331 [ + + ]: 53338 : error = empty ? -ENOENT : -EINVAL;
332 [ + + ]: 53338 : if (inode->i_op->readlink) {
333 : 18081 : error = security_inode_readlink(path.dentry);
334 [ + - ]: 18081 : if (!error) {
335 : 18081 : touch_atime(&path);
336 : 18081 : error = inode->i_op->readlink(path.dentry,
337 : : buf, bufsiz);
338 : : }
339 : : }
340 : 53338 : path_put(&path);
341 [ - + ]: 53341 : if (retry_estale(error, lookup_flags)) {
342 : : lookup_flags |= LOOKUP_REVAL;
343 : : goto retry;
344 : : }
345 : : }
346 : : return error;
347 : : }
348 : :
349 : 0 : SYSCALL_DEFINE3(readlink, const char __user *, path, char __user *, buf,
350 : : int, bufsiz)
351 : : {
352 : 63633 : return sys_readlinkat(AT_FDCWD, path, buf, bufsiz);
353 : : }
354 : :
355 : :
356 : : /* ---------- LFS-64 ----------- */
357 : : #if defined(__ARCH_WANT_STAT64) || defined(__ARCH_WANT_COMPAT_STAT64)
358 : :
359 : : #ifndef INIT_STRUCT_STAT64_PADDING
360 : : # define INIT_STRUCT_STAT64_PADDING(st) memset(&st, 0, sizeof(st))
361 : : #endif
362 : :
363 : 0 : static long cp_new_stat64(struct kstat *stat, struct stat64 __user *statbuf)
364 : : {
365 : : struct stat64 tmp;
366 : :
367 : 6405276 : INIT_STRUCT_STAT64_PADDING(tmp);
368 : : #ifdef CONFIG_MIPS
369 : : /* mips has weird padding, so we don't get 64 bits there */
370 : : if (!new_valid_dev(stat->dev) || !new_valid_dev(stat->rdev))
371 : : return -EOVERFLOW;
372 : : tmp.st_dev = new_encode_dev(stat->dev);
373 : : tmp.st_rdev = new_encode_dev(stat->rdev);
374 : : #else
375 : 12810260 : tmp.st_dev = huge_encode_dev(stat->dev);
376 : 12810260 : tmp.st_rdev = huge_encode_dev(stat->rdev);
377 : : #endif
378 : 6405130 : tmp.st_ino = stat->ino;
379 : : if (sizeof(tmp.st_ino) < sizeof(stat->ino) && tmp.st_ino != stat->ino)
380 : : return -EOVERFLOW;
381 : : #ifdef STAT64_HAS_BROKEN_ST_INO
382 : 6405130 : tmp.__st_ino = stat->ino;
383 : : #endif
384 : 6405130 : tmp.st_mode = stat->mode;
385 : 6405130 : tmp.st_nlink = stat->nlink;
386 : 12810260 : tmp.st_uid = from_kuid_munged(current_user_ns(), stat->uid);
387 : 6404984 : tmp.st_gid = from_kgid_munged(current_user_ns(), stat->gid);
388 : 0 : tmp.st_atime = stat->atime.tv_sec;
389 : 0 : tmp.st_atime_nsec = stat->atime.tv_nsec;
390 : 0 : tmp.st_mtime = stat->mtime.tv_sec;
391 : 0 : tmp.st_mtime_nsec = stat->mtime.tv_nsec;
392 : 0 : tmp.st_ctime = stat->ctime.tv_sec;
393 : 0 : tmp.st_ctime_nsec = stat->ctime.tv_nsec;
394 : 0 : tmp.st_size = stat->size;
395 : 0 : tmp.st_blocks = stat->blocks;
396 : 0 : tmp.st_blksize = stat->blksize;
397 [ + + ]: 6405217 : return copy_to_user(statbuf,&tmp,sizeof(tmp)) ? -EFAULT : 0;
398 : : }
399 : :
400 : 0 : SYSCALL_DEFINE2(stat64, const char __user *, filename,
401 : : struct stat64 __user *, statbuf)
402 : : {
403 : : struct kstat stat;
404 : 702383 : int error = vfs_stat(filename, &stat);
405 : :
406 [ + + ]: 702386 : if (!error)
407 : 362248 : error = cp_new_stat64(&stat, statbuf);
408 : :
409 : : return error;
410 : : }
411 : :
412 : 0 : SYSCALL_DEFINE2(lstat64, const char __user *, filename,
413 : : struct stat64 __user *, statbuf)
414 : : {
415 : : struct kstat stat;
416 : 180145 : int error = vfs_lstat(filename, &stat);
417 : :
418 [ + + ]: 180162 : if (!error)
419 : 176602 : error = cp_new_stat64(&stat, statbuf);
420 : :
421 : : return error;
422 : : }
423 : :
424 : 0 : SYSCALL_DEFINE2(fstat64, unsigned long, fd, struct stat64 __user *, statbuf)
425 : : {
426 : : struct kstat stat;
427 : 5847716 : int error = vfs_fstat(fd, &stat);
428 : :
429 [ + + ]: 5847646 : if (!error)
430 : 5847596 : error = cp_new_stat64(&stat, statbuf);
431 : :
432 : : return error;
433 : : }
434 : :
435 : 0 : SYSCALL_DEFINE4(fstatat64, int, dfd, const char __user *, filename,
436 : : struct stat64 __user *, statbuf, int, flag)
437 : : {
438 : : struct kstat stat;
439 : : int error;
440 : :
441 : 19865 : error = vfs_fstatat(dfd, filename, &stat, flag);
442 [ + + ]: 19865 : if (error)
443 : : return error;
444 : 18749 : return cp_new_stat64(&stat, statbuf);
445 : : }
446 : : #endif /* __ARCH_WANT_STAT64 || __ARCH_WANT_COMPAT_STAT64 */
447 : :
448 : : /* Caller is here responsible for sufficient locking (ie. inode->i_lock) */
449 : 0 : void __inode_add_bytes(struct inode *inode, loff_t bytes)
450 : : {
451 : 217368 : inode->i_blocks += bytes >> 9;
452 : 217368 : bytes &= 511;
453 : 217368 : inode->i_bytes += bytes;
454 [ - + ][ - + ]: 217368 : if (inode->i_bytes >= 512) {
455 : 0 : inode->i_blocks++;
456 : 0 : inode->i_bytes -= 512;
457 : : }
458 : 0 : }
459 : :
460 : 0 : void inode_add_bytes(struct inode *inode, loff_t bytes)
461 : : {
462 : : spin_lock(&inode->i_lock);
463 : : __inode_add_bytes(inode, bytes);
464 : : spin_unlock(&inode->i_lock);
465 : 119661 : }
466 : :
467 : : EXPORT_SYMBOL(inode_add_bytes);
468 : :
469 : 0 : void __inode_sub_bytes(struct inode *inode, loff_t bytes)
470 : : {
471 : 127594 : inode->i_blocks -= bytes >> 9;
472 : 127594 : bytes &= 511;
473 [ - + ][ - + ]: 127594 : if (inode->i_bytes < bytes) {
474 : 0 : inode->i_blocks--;
475 : 0 : inode->i_bytes += 512;
476 : : }
477 : 0 : inode->i_bytes -= bytes;
478 : 0 : }
479 : :
480 : : EXPORT_SYMBOL(__inode_sub_bytes);
481 : :
482 : 0 : void inode_sub_bytes(struct inode *inode, loff_t bytes)
483 : : {
484 : : spin_lock(&inode->i_lock);
485 : : __inode_sub_bytes(inode, bytes);
486 : : spin_unlock(&inode->i_lock);
487 : 127429 : }
488 : :
489 : : EXPORT_SYMBOL(inode_sub_bytes);
490 : :
491 : 0 : loff_t inode_get_bytes(struct inode *inode)
492 : : {
493 : : loff_t ret;
494 : :
495 : : spin_lock(&inode->i_lock);
496 : 0 : ret = (((loff_t)inode->i_blocks) << 9) + inode->i_bytes;
497 : : spin_unlock(&inode->i_lock);
498 : 0 : return ret;
499 : : }
500 : :
501 : : EXPORT_SYMBOL(inode_get_bytes);
502 : :
503 : 0 : void inode_set_bytes(struct inode *inode, loff_t bytes)
504 : : {
505 : : /* Caller is here responsible for sufficient locking
506 : : * (ie. inode->i_lock) */
507 : 0 : inode->i_blocks = bytes >> 9;
508 : 0 : inode->i_bytes = bytes & 511;
509 : 0 : }
510 : :
511 : : EXPORT_SYMBOL(inode_set_bytes);
|
