fs/stat.c

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