4 * Copyright (C) 1991, 1992 Linus Torvalds
7 #include <linux/export.h>
9 #include <linux/errno.h>
10 #include <linux/file.h>
11 #include <linux/highuid.h>
13 #include <linux/namei.h>
14 #include <linux/security.h>
15 #include <linux/syscalls.h>
16 #include <linux/pagemap.h>
18 #include <asm/uaccess.h>
19 #include <asm/unistd.h>
21 void generic_fillattr(struct inode *inode, struct kstat *stat)
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->size = i_size_read(inode);
31 stat->atime = inode->i_atime;
32 stat->mtime = inode->i_mtime;
33 stat->ctime = inode->i_ctime;
34 stat->blksize = (1 << inode->i_blkbits);
35 stat->blocks = inode->i_blocks;
38 EXPORT_SYMBOL(generic_fillattr);
40 int vfs_getattr(struct path *path, struct kstat *stat)
42 struct inode *inode = path->dentry->d_inode;
45 retval = security_inode_getattr(path->mnt, path->dentry);
49 if (inode->i_op->getattr)
50 return inode->i_op->getattr(path->mnt, path->dentry, stat);
52 generic_fillattr(inode, stat);
56 EXPORT_SYMBOL(vfs_getattr);
58 int vfs_fstat(unsigned int fd, struct kstat *stat)
60 struct fd f = fdget_raw(fd);
64 error = vfs_getattr(&f.file->f_path, stat);
69 EXPORT_SYMBOL(vfs_fstat);
71 int vfs_fstatat(int dfd, const char __user *filename, struct kstat *stat,
76 unsigned int lookup_flags = 0;
78 if ((flag & ~(AT_SYMLINK_NOFOLLOW | AT_NO_AUTOMOUNT |
82 if (!(flag & AT_SYMLINK_NOFOLLOW))
83 lookup_flags |= LOOKUP_FOLLOW;
84 if (flag & AT_EMPTY_PATH)
85 lookup_flags |= LOOKUP_EMPTY;
87 error = user_path_at(dfd, filename, lookup_flags, &path);
91 error = vfs_getattr(&path, stat);
93 if (retry_estale(error, lookup_flags)) {
94 lookup_flags |= LOOKUP_REVAL;
100 EXPORT_SYMBOL(vfs_fstatat);
102 int vfs_stat(const char __user *name, struct kstat *stat)
104 return vfs_fstatat(AT_FDCWD, name, stat, 0);
106 EXPORT_SYMBOL(vfs_stat);
108 int vfs_lstat(const char __user *name, struct kstat *stat)
110 return vfs_fstatat(AT_FDCWD, name, stat, AT_SYMLINK_NOFOLLOW);
112 EXPORT_SYMBOL(vfs_lstat);
115 #ifdef __ARCH_WANT_OLD_STAT
118 * For backward compatibility? Maybe this should be moved
119 * into arch/i386 instead?
121 static int cp_old_stat(struct kstat *stat, struct __old_kernel_stat __user * statbuf)
123 static int warncount = 5;
124 struct __old_kernel_stat tmp;
128 printk(KERN_WARNING "VFS: Warning: %s using old stat() call. Recompile your binary.\n",
130 } else if (warncount < 0) {
131 /* it's laughable, but... */
135 memset(&tmp, 0, sizeof(struct __old_kernel_stat));
136 tmp.st_dev = old_encode_dev(stat->dev);
137 tmp.st_ino = stat->ino;
138 if (sizeof(tmp.st_ino) < sizeof(stat->ino) && tmp.st_ino != stat->ino)
140 tmp.st_mode = stat->mode;
141 tmp.st_nlink = stat->nlink;
142 if (tmp.st_nlink != stat->nlink)
144 SET_UID(tmp.st_uid, from_kuid_munged(current_user_ns(), stat->uid));
145 SET_GID(tmp.st_gid, from_kgid_munged(current_user_ns(), stat->gid));
146 tmp.st_rdev = old_encode_dev(stat->rdev);
147 #if BITS_PER_LONG == 32
148 if (stat->size > MAX_NON_LFS)
151 tmp.st_size = stat->size;
152 tmp.st_atime = stat->atime.tv_sec;
153 tmp.st_mtime = stat->mtime.tv_sec;
154 tmp.st_ctime = stat->ctime.tv_sec;
155 return copy_to_user(statbuf,&tmp,sizeof(tmp)) ? -EFAULT : 0;
158 SYSCALL_DEFINE2(stat, const char __user *, filename,
159 struct __old_kernel_stat __user *, statbuf)
164 error = vfs_stat(filename, &stat);
168 return cp_old_stat(&stat, statbuf);
171 SYSCALL_DEFINE2(lstat, const char __user *, filename,
172 struct __old_kernel_stat __user *, statbuf)
177 error = vfs_lstat(filename, &stat);
181 return cp_old_stat(&stat, statbuf);
184 SYSCALL_DEFINE2(fstat, unsigned int, fd, struct __old_kernel_stat __user *, statbuf)
187 int error = vfs_fstat(fd, &stat);
190 error = cp_old_stat(&stat, statbuf);
195 #endif /* __ARCH_WANT_OLD_STAT */
197 #if BITS_PER_LONG == 32
198 # define choose_32_64(a,b) a
200 # define choose_32_64(a,b) b
203 #define valid_dev(x) choose_32_64(old_valid_dev,new_valid_dev)(x)
204 #define encode_dev(x) choose_32_64(old_encode_dev,new_encode_dev)(x)
206 #ifndef INIT_STRUCT_STAT_PADDING
207 # define INIT_STRUCT_STAT_PADDING(st) memset(&st, 0, sizeof(st))
210 static int cp_new_stat(struct kstat *stat, struct stat __user *statbuf)
214 if (!valid_dev(stat->dev) || !valid_dev(stat->rdev))
216 #if BITS_PER_LONG == 32
217 if (stat->size > MAX_NON_LFS)
221 INIT_STRUCT_STAT_PADDING(tmp);
222 tmp.st_dev = encode_dev(stat->dev);
223 tmp.st_ino = stat->ino;
224 if (sizeof(tmp.st_ino) < sizeof(stat->ino) && tmp.st_ino != stat->ino)
226 tmp.st_mode = stat->mode;
227 tmp.st_nlink = stat->nlink;
228 if (tmp.st_nlink != stat->nlink)
230 SET_UID(tmp.st_uid, from_kuid_munged(current_user_ns(), stat->uid));
231 SET_GID(tmp.st_gid, from_kgid_munged(current_user_ns(), stat->gid));
232 tmp.st_rdev = encode_dev(stat->rdev);
233 tmp.st_size = stat->size;
234 tmp.st_atime = stat->atime.tv_sec;
235 tmp.st_mtime = stat->mtime.tv_sec;
236 tmp.st_ctime = stat->ctime.tv_sec;
237 #ifdef STAT_HAVE_NSEC
238 tmp.st_atime_nsec = stat->atime.tv_nsec;
239 tmp.st_mtime_nsec = stat->mtime.tv_nsec;
240 tmp.st_ctime_nsec = stat->ctime.tv_nsec;
242 tmp.st_blocks = stat->blocks;
243 tmp.st_blksize = stat->blksize;
244 return copy_to_user(statbuf,&tmp,sizeof(tmp)) ? -EFAULT : 0;
247 SYSCALL_DEFINE2(newstat, const char __user *, filename,
248 struct stat __user *, statbuf)
251 int error = vfs_stat(filename, &stat);
255 return cp_new_stat(&stat, statbuf);
258 SYSCALL_DEFINE2(newlstat, const char __user *, filename,
259 struct stat __user *, statbuf)
264 error = vfs_lstat(filename, &stat);
268 return cp_new_stat(&stat, statbuf);
271 #if !defined(__ARCH_WANT_STAT64) || defined(__ARCH_WANT_SYS_NEWFSTATAT)
272 SYSCALL_DEFINE4(newfstatat, int, dfd, const char __user *, filename,
273 struct stat __user *, statbuf, int, flag)
278 error = vfs_fstatat(dfd, filename, &stat, flag);
281 return cp_new_stat(&stat, statbuf);
285 SYSCALL_DEFINE2(newfstat, unsigned int, fd, struct stat __user *, statbuf)
288 int error = vfs_fstat(fd, &stat);
291 error = cp_new_stat(&stat, statbuf);
296 SYSCALL_DEFINE4(readlinkat, int, dfd, const char __user *, pathname,
297 char __user *, buf, int, bufsiz)
302 unsigned int lookup_flags = LOOKUP_EMPTY;
308 error = user_path_at_empty(dfd, pathname, lookup_flags, &path, &empty);
310 struct inode *inode = path.dentry->d_inode;
312 error = empty ? -ENOENT : -EINVAL;
313 if (inode->i_op->readlink) {
314 error = security_inode_readlink(path.dentry);
317 error = inode->i_op->readlink(path.dentry,
322 if (retry_estale(error, lookup_flags)) {
323 lookup_flags |= LOOKUP_REVAL;
330 SYSCALL_DEFINE3(readlink, const char __user *, path, char __user *, buf,
333 return sys_readlinkat(AT_FDCWD, path, buf, bufsiz);
337 /* ---------- LFS-64 ----------- */
338 #if defined(__ARCH_WANT_STAT64) || defined(__ARCH_WANT_COMPAT_STAT64)
340 #ifndef INIT_STRUCT_STAT64_PADDING
341 # define INIT_STRUCT_STAT64_PADDING(st) memset(&st, 0, sizeof(st))
344 static long cp_new_stat64(struct kstat *stat, struct stat64 __user *statbuf)
348 INIT_STRUCT_STAT64_PADDING(tmp);
350 /* mips has weird padding, so we don't get 64 bits there */
351 if (!new_valid_dev(stat->dev) || !new_valid_dev(stat->rdev))
353 tmp.st_dev = new_encode_dev(stat->dev);
354 tmp.st_rdev = new_encode_dev(stat->rdev);
356 tmp.st_dev = huge_encode_dev(stat->dev);
357 tmp.st_rdev = huge_encode_dev(stat->rdev);
359 tmp.st_ino = stat->ino;
360 if (sizeof(tmp.st_ino) < sizeof(stat->ino) && tmp.st_ino != stat->ino)
362 #ifdef STAT64_HAS_BROKEN_ST_INO
363 tmp.__st_ino = stat->ino;
365 tmp.st_mode = stat->mode;
366 tmp.st_nlink = stat->nlink;
367 tmp.st_uid = from_kuid_munged(current_user_ns(), stat->uid);
368 tmp.st_gid = from_kgid_munged(current_user_ns(), stat->gid);
369 tmp.st_atime = stat->atime.tv_sec;
370 tmp.st_atime_nsec = stat->atime.tv_nsec;
371 tmp.st_mtime = stat->mtime.tv_sec;
372 tmp.st_mtime_nsec = stat->mtime.tv_nsec;
373 tmp.st_ctime = stat->ctime.tv_sec;
374 tmp.st_ctime_nsec = stat->ctime.tv_nsec;
375 tmp.st_size = stat->size;
376 tmp.st_blocks = stat->blocks;
377 tmp.st_blksize = stat->blksize;
378 return copy_to_user(statbuf,&tmp,sizeof(tmp)) ? -EFAULT : 0;
381 SYSCALL_DEFINE2(stat64, const char __user *, filename,
382 struct stat64 __user *, statbuf)
385 int error = vfs_stat(filename, &stat);
388 error = cp_new_stat64(&stat, statbuf);
393 SYSCALL_DEFINE2(lstat64, const char __user *, filename,
394 struct stat64 __user *, statbuf)
397 int error = vfs_lstat(filename, &stat);
400 error = cp_new_stat64(&stat, statbuf);
405 SYSCALL_DEFINE2(fstat64, unsigned long, fd, struct stat64 __user *, statbuf)
408 int error = vfs_fstat(fd, &stat);
411 error = cp_new_stat64(&stat, statbuf);
416 SYSCALL_DEFINE4(fstatat64, int, dfd, const char __user *, filename,
417 struct stat64 __user *, statbuf, int, flag)
422 error = vfs_fstatat(dfd, filename, &stat, flag);
425 return cp_new_stat64(&stat, statbuf);
427 #endif /* __ARCH_WANT_STAT64 || __ARCH_WANT_COMPAT_STAT64 */
429 /* Caller is here responsible for sufficient locking (ie. inode->i_lock) */
430 void __inode_add_bytes(struct inode *inode, loff_t bytes)
432 inode->i_blocks += bytes >> 9;
434 inode->i_bytes += bytes;
435 if (inode->i_bytes >= 512) {
437 inode->i_bytes -= 512;
441 void inode_add_bytes(struct inode *inode, loff_t bytes)
443 spin_lock(&inode->i_lock);
444 __inode_add_bytes(inode, bytes);
445 spin_unlock(&inode->i_lock);
448 EXPORT_SYMBOL(inode_add_bytes);
450 void inode_sub_bytes(struct inode *inode, loff_t bytes)
452 spin_lock(&inode->i_lock);
453 inode->i_blocks -= bytes >> 9;
455 if (inode->i_bytes < bytes) {
457 inode->i_bytes += 512;
459 inode->i_bytes -= bytes;
460 spin_unlock(&inode->i_lock);
463 EXPORT_SYMBOL(inode_sub_bytes);
465 loff_t inode_get_bytes(struct inode *inode)
469 spin_lock(&inode->i_lock);
470 ret = (((loff_t)inode->i_blocks) << 9) + inode->i_bytes;
471 spin_unlock(&inode->i_lock);
475 EXPORT_SYMBOL(inode_get_bytes);
477 void inode_set_bytes(struct inode *inode, loff_t bytes)
479 /* Caller is here responsible for sufficient locking
480 * (ie. inode->i_lock) */
481 inode->i_blocks = bytes >> 9;
482 inode->i_bytes = bytes & 511;
485 EXPORT_SYMBOL(inode_set_bytes);