Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
tjh.dev
kernel
os
linux
1/*
2 * linux/fs/stat.c
3 *
4 * Copyright (C) 1991, 1992 Linus Torvalds
5 */
6
7#include <linux/module.h>
8#include <linux/mm.h>
9#include <linux/errno.h>
10#include <linux/file.h>
11#include <linux/smp_lock.h>
12#include <linux/highuid.h>
13#include <linux/fs.h>
14#include <linux/namei.h>
15#include <linux/security.h>
16#include <linux/syscalls.h>
17
18#include <asm/uaccess.h>
19#include <asm/unistd.h>
20
21void generic_fillattr(struct inode *inode, struct kstat *stat)
22{
23 stat->dev = inode->i_sb->s_dev;
24 stat->ino = inode->i_ino;
25 stat->mode = inode->i_mode;
26 stat->nlink = inode->i_nlink;
27 stat->uid = inode->i_uid;
28 stat->gid = inode->i_gid;
29 stat->rdev = inode->i_rdev;
30 stat->atime = inode->i_atime;
31 stat->mtime = inode->i_mtime;
32 stat->ctime = inode->i_ctime;
33 stat->size = i_size_read(inode);
34 stat->blocks = inode->i_blocks;
35 stat->blksize = inode->i_blksize;
36}
37
38EXPORT_SYMBOL(generic_fillattr);
39
40int vfs_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
41{
42 struct inode *inode = dentry->d_inode;
43 int retval;
44
45 retval = security_inode_getattr(mnt, dentry);
46 if (retval)
47 return retval;
48
49 if (inode->i_op->getattr)
50 return inode->i_op->getattr(mnt, dentry, stat);
51
52 generic_fillattr(inode, stat);
53 if (!stat->blksize) {
54 struct super_block *s = inode->i_sb;
55 unsigned blocks;
56 blocks = (stat->size+s->s_blocksize-1) >> s->s_blocksize_bits;
57 stat->blocks = (s->s_blocksize / 512) * blocks;
58 stat->blksize = s->s_blocksize;
59 }
60 return 0;
61}
62
63EXPORT_SYMBOL(vfs_getattr);
64
65int vfs_stat_fd(int dfd, char __user *name, struct kstat *stat)
66{
67 struct nameidata nd;
68 int error;
69
70 error = __user_walk_fd(dfd, name, LOOKUP_FOLLOW, &nd);
71 if (!error) {
72 error = vfs_getattr(nd.mnt, nd.dentry, stat);
73 path_release(&nd);
74 }
75 return error;
76}
77
78int vfs_stat(char __user *name, struct kstat *stat)
79{
80 return vfs_stat_fd(AT_FDCWD, name, stat);
81}
82
83EXPORT_SYMBOL(vfs_stat);
84
85int vfs_lstat_fd(int dfd, char __user *name, struct kstat *stat)
86{
87 struct nameidata nd;
88 int error;
89
90 error = __user_walk_fd(dfd, name, 0, &nd);
91 if (!error) {
92 error = vfs_getattr(nd.mnt, nd.dentry, stat);
93 path_release(&nd);
94 }
95 return error;
96}
97
98int vfs_lstat(char __user *name, struct kstat *stat)
99{
100 return vfs_lstat_fd(AT_FDCWD, name, stat);
101}
102
103EXPORT_SYMBOL(vfs_lstat);
104
105int vfs_fstat(unsigned int fd, struct kstat *stat)
106{
107 struct file *f = fget(fd);
108 int error = -EBADF;
109
110 if (f) {
111 error = vfs_getattr(f->f_vfsmnt, f->f_dentry, stat);
112 fput(f);
113 }
114 return error;
115}
116
117EXPORT_SYMBOL(vfs_fstat);
118
119#ifdef __ARCH_WANT_OLD_STAT
120
121/*
122 * For backward compatibility? Maybe this should be moved
123 * into arch/i386 instead?
124 */
125static int cp_old_stat(struct kstat *stat, struct __old_kernel_stat __user * statbuf)
126{
127 static int warncount = 5;
128 struct __old_kernel_stat tmp;
129
130 if (warncount > 0) {
131 warncount--;
132 printk(KERN_WARNING "VFS: Warning: %s using old stat() call. Recompile your binary.\n",
133 current->comm);
134 } else if (warncount < 0) {
135 /* it's laughable, but... */
136 warncount = 0;
137 }
138
139 memset(&tmp, 0, sizeof(struct __old_kernel_stat));
140 tmp.st_dev = old_encode_dev(stat->dev);
141 tmp.st_ino = stat->ino;
142 tmp.st_mode = stat->mode;
143 tmp.st_nlink = stat->nlink;
144 if (tmp.st_nlink != stat->nlink)
145 return -EOVERFLOW;
146 SET_UID(tmp.st_uid, stat->uid);
147 SET_GID(tmp.st_gid, stat->gid);
148 tmp.st_rdev = old_encode_dev(stat->rdev);
149#if BITS_PER_LONG == 32
150 if (stat->size > MAX_NON_LFS)
151 return -EOVERFLOW;
152#endif
153 tmp.st_size = stat->size;
154 tmp.st_atime = stat->atime.tv_sec;
155 tmp.st_mtime = stat->mtime.tv_sec;
156 tmp.st_ctime = stat->ctime.tv_sec;
157 return copy_to_user(statbuf,&tmp,sizeof(tmp)) ? -EFAULT : 0;
158}
159
160asmlinkage long sys_stat(char __user * filename, struct __old_kernel_stat __user * statbuf)
161{
162 struct kstat stat;
163 int error = vfs_stat_fd(AT_FDCWD, filename, &stat);
164
165 if (!error)
166 error = cp_old_stat(&stat, statbuf);
167
168 return error;
169}
170asmlinkage long sys_lstat(char __user * filename, struct __old_kernel_stat __user * statbuf)
171{
172 struct kstat stat;
173 int error = vfs_lstat_fd(AT_FDCWD, filename, &stat);
174
175 if (!error)
176 error = cp_old_stat(&stat, statbuf);
177
178 return error;
179}
180asmlinkage long sys_fstat(unsigned int fd, struct __old_kernel_stat __user * statbuf)
181{
182 struct kstat stat;
183 int error = vfs_fstat(fd, &stat);
184
185 if (!error)
186 error = cp_old_stat(&stat, statbuf);
187
188 return error;
189}
190
191#endif /* __ARCH_WANT_OLD_STAT */
192
193static int cp_new_stat(struct kstat *stat, struct stat __user *statbuf)
194{
195 struct stat tmp;
196
197#if BITS_PER_LONG == 32
198 if (!old_valid_dev(stat->dev) || !old_valid_dev(stat->rdev))
199 return -EOVERFLOW;
200#else
201 if (!new_valid_dev(stat->dev) || !new_valid_dev(stat->rdev))
202 return -EOVERFLOW;
203#endif
204
205 memset(&tmp, 0, sizeof(tmp));
206#if BITS_PER_LONG == 32
207 tmp.st_dev = old_encode_dev(stat->dev);
208#else
209 tmp.st_dev = new_encode_dev(stat->dev);
210#endif
211 tmp.st_ino = stat->ino;
212 tmp.st_mode = stat->mode;
213 tmp.st_nlink = stat->nlink;
214 if (tmp.st_nlink != stat->nlink)
215 return -EOVERFLOW;
216 SET_UID(tmp.st_uid, stat->uid);
217 SET_GID(tmp.st_gid, stat->gid);
218#if BITS_PER_LONG == 32
219 tmp.st_rdev = old_encode_dev(stat->rdev);
220#else
221 tmp.st_rdev = new_encode_dev(stat->rdev);
222#endif
223#if BITS_PER_LONG == 32
224 if (stat->size > MAX_NON_LFS)
225 return -EOVERFLOW;
226#endif
227 tmp.st_size = stat->size;
228 tmp.st_atime = stat->atime.tv_sec;
229 tmp.st_mtime = stat->mtime.tv_sec;
230 tmp.st_ctime = stat->ctime.tv_sec;
231#ifdef STAT_HAVE_NSEC
232 tmp.st_atime_nsec = stat->atime.tv_nsec;
233 tmp.st_mtime_nsec = stat->mtime.tv_nsec;
234 tmp.st_ctime_nsec = stat->ctime.tv_nsec;
235#endif
236 tmp.st_blocks = stat->blocks;
237 tmp.st_blksize = stat->blksize;
238 return copy_to_user(statbuf,&tmp,sizeof(tmp)) ? -EFAULT : 0;
239}
240
241asmlinkage long sys_newstat(char __user *filename, struct stat __user *statbuf)
242{
243 struct kstat stat;
244 int error = vfs_stat_fd(AT_FDCWD, filename, &stat);
245
246 if (!error)
247 error = cp_new_stat(&stat, statbuf);
248
249 return error;
250}
251
252asmlinkage long sys_newlstat(char __user *filename, struct stat __user *statbuf)
253{
254 struct kstat stat;
255 int error = vfs_lstat_fd(AT_FDCWD, filename, &stat);
256
257 if (!error)
258 error = cp_new_stat(&stat, statbuf);
259
260 return error;
261}
262
263#if !defined(__ARCH_WANT_STAT64) || defined(__ARCH_WANT_SYS_NEWFSTATAT)
264asmlinkage long sys_newfstatat(int dfd, char __user *filename,
265 struct stat __user *statbuf, int flag)
266{
267 struct kstat stat;
268 int error = -EINVAL;
269
270 if ((flag & ~AT_SYMLINK_NOFOLLOW) != 0)
271 goto out;
272
273 if (flag & AT_SYMLINK_NOFOLLOW)
274 error = vfs_lstat_fd(dfd, filename, &stat);
275 else
276 error = vfs_stat_fd(dfd, filename, &stat);
277
278 if (!error)
279 error = cp_new_stat(&stat, statbuf);
280
281out:
282 return error;
283}
284#endif
285
286asmlinkage long sys_newfstat(unsigned int fd, struct stat __user *statbuf)
287{
288 struct kstat stat;
289 int error = vfs_fstat(fd, &stat);
290
291 if (!error)
292 error = cp_new_stat(&stat, statbuf);
293
294 return error;
295}
296
297asmlinkage long sys_readlinkat(int dfd, const char __user *path,
298 char __user *buf, int bufsiz)
299{
300 struct nameidata nd;
301 int error;
302
303 if (bufsiz <= 0)
304 return -EINVAL;
305
306 error = __user_walk_fd(dfd, path, 0, &nd);
307 if (!error) {
308 struct inode * inode = nd.dentry->d_inode;
309
310 error = -EINVAL;
311 if (inode->i_op && inode->i_op->readlink) {
312 error = security_inode_readlink(nd.dentry);
313 if (!error) {
314 touch_atime(nd.mnt, nd.dentry);
315 error = inode->i_op->readlink(nd.dentry, buf, bufsiz);
316 }
317 }
318 path_release(&nd);
319 }
320 return error;
321}
322
323asmlinkage long sys_readlink(const char __user *path, char __user *buf,
324 int bufsiz)
325{
326 return sys_readlinkat(AT_FDCWD, path, buf, bufsiz);
327}
328
329
330/* ---------- LFS-64 ----------- */
331#ifdef __ARCH_WANT_STAT64
332
333static long cp_new_stat64(struct kstat *stat, struct stat64 __user *statbuf)
334{
335 struct stat64 tmp;
336
337 memset(&tmp, 0, sizeof(struct stat64));
338#ifdef CONFIG_MIPS
339 /* mips has weird padding, so we don't get 64 bits there */
340 if (!new_valid_dev(stat->dev) || !new_valid_dev(stat->rdev))
341 return -EOVERFLOW;
342 tmp.st_dev = new_encode_dev(stat->dev);
343 tmp.st_rdev = new_encode_dev(stat->rdev);
344#else
345 tmp.st_dev = huge_encode_dev(stat->dev);
346 tmp.st_rdev = huge_encode_dev(stat->rdev);
347#endif
348 tmp.st_ino = stat->ino;
349#ifdef STAT64_HAS_BROKEN_ST_INO
350 tmp.__st_ino = stat->ino;
351#endif
352 tmp.st_mode = stat->mode;
353 tmp.st_nlink = stat->nlink;
354 tmp.st_uid = stat->uid;
355 tmp.st_gid = stat->gid;
356 tmp.st_atime = stat->atime.tv_sec;
357 tmp.st_atime_nsec = stat->atime.tv_nsec;
358 tmp.st_mtime = stat->mtime.tv_sec;
359 tmp.st_mtime_nsec = stat->mtime.tv_nsec;
360 tmp.st_ctime = stat->ctime.tv_sec;
361 tmp.st_ctime_nsec = stat->ctime.tv_nsec;
362 tmp.st_size = stat->size;
363 tmp.st_blocks = stat->blocks;
364 tmp.st_blksize = stat->blksize;
365 return copy_to_user(statbuf,&tmp,sizeof(tmp)) ? -EFAULT : 0;
366}
367
368asmlinkage long sys_stat64(char __user * filename, struct stat64 __user * statbuf)
369{
370 struct kstat stat;
371 int error = vfs_stat(filename, &stat);
372
373 if (!error)
374 error = cp_new_stat64(&stat, statbuf);
375
376 return error;
377}
378asmlinkage long sys_lstat64(char __user * filename, struct stat64 __user * statbuf)
379{
380 struct kstat stat;
381 int error = vfs_lstat(filename, &stat);
382
383 if (!error)
384 error = cp_new_stat64(&stat, statbuf);
385
386 return error;
387}
388asmlinkage long sys_fstat64(unsigned long fd, struct stat64 __user * statbuf)
389{
390 struct kstat stat;
391 int error = vfs_fstat(fd, &stat);
392
393 if (!error)
394 error = cp_new_stat64(&stat, statbuf);
395
396 return error;
397}
398
399asmlinkage long sys_fstatat64(int dfd, char __user *filename,
400 struct stat64 __user *statbuf, int flag)
401{
402 struct kstat stat;
403 int error = -EINVAL;
404
405 if ((flag & ~AT_SYMLINK_NOFOLLOW) != 0)
406 goto out;
407
408 if (flag & AT_SYMLINK_NOFOLLOW)
409 error = vfs_lstat_fd(dfd, filename, &stat);
410 else
411 error = vfs_stat_fd(dfd, filename, &stat);
412
413 if (!error)
414 error = cp_new_stat64(&stat, statbuf);
415
416out:
417 return error;
418}
419#endif /* __ARCH_WANT_STAT64 */
420
421void inode_add_bytes(struct inode *inode, loff_t bytes)
422{
423 spin_lock(&inode->i_lock);
424 inode->i_blocks += bytes >> 9;
425 bytes &= 511;
426 inode->i_bytes += bytes;
427 if (inode->i_bytes >= 512) {
428 inode->i_blocks++;
429 inode->i_bytes -= 512;
430 }
431 spin_unlock(&inode->i_lock);
432}
433
434EXPORT_SYMBOL(inode_add_bytes);
435
436void inode_sub_bytes(struct inode *inode, loff_t bytes)
437{
438 spin_lock(&inode->i_lock);
439 inode->i_blocks -= bytes >> 9;
440 bytes &= 511;
441 if (inode->i_bytes < bytes) {
442 inode->i_blocks--;
443 inode->i_bytes += 512;
444 }
445 inode->i_bytes -= bytes;
446 spin_unlock(&inode->i_lock);
447}
448
449EXPORT_SYMBOL(inode_sub_bytes);
450
451loff_t inode_get_bytes(struct inode *inode)
452{
453 loff_t ret;
454
455 spin_lock(&inode->i_lock);
456 ret = (((loff_t)inode->i_blocks) << 9) + inode->i_bytes;
457 spin_unlock(&inode->i_lock);
458 return ret;
459}
460
461EXPORT_SYMBOL(inode_get_bytes);
462
463void inode_set_bytes(struct inode *inode, loff_t bytes)
464{
465 /* Caller is here responsible for sufficient locking
466 * (ie. inode->i_lock) */
467 inode->i_blocks = bytes >> 9;
468 inode->i_bytes = bytes & 511;
469}
470
471EXPORT_SYMBOL(inode_set_bytes);