fs/stat.c

   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 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->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;
  36 }
  37
  38 EXPORT_SYMBOL(generic_fillattr);
  39
  40 int vfs_getattr(struct path *path, struct kstat *stat)
  41 {
  42         struct inode *inode = path->dentry->d_inode;
  43         int retval;
  44
  45         retval = security_inode_getattr(path->mnt, path->dentry);
  46         if (retval)
  47                 return retval;
  48
  49         if (inode->i_op->getattr)
  50                 return inode->i_op->getattr(path->mnt, path->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 fd f = fdget_raw(fd);
  61         int error = -EBADF;
  62
  63         if (f.file) {
  64                 error = vfs_getattr(&f.file->f_path, stat);
  65                 fdput(f);
  66         }
  67         return error;
  68 }
  69 EXPORT_SYMBOL(vfs_fstat);
  70
  71 int vfs_fstatat(int dfd, const char __user *filename, struct kstat *stat,
  72                 int flag)
  73 {
  74         struct path path;
  75         int error = -EINVAL;
  76         unsigned int lookup_flags = 0;
  77
  78         if ((flag & ~(AT_SYMLINK_NOFOLLOW | AT_NO_AUTOMOUNT |
  79                       AT_EMPTY_PATH)) != 0)
  80                 goto out;
  81
  82         if (!(flag & AT_SYMLINK_NOFOLLOW))
  83                 lookup_flags |= LOOKUP_FOLLOW;
  84         if (flag & AT_EMPTY_PATH)
  85                 lookup_flags |= LOOKUP_EMPTY;
  86 retry:
  87         error = user_path_at(dfd, filename, lookup_flags, &path);
  88         if (error)
  89                 goto out;
  90
  91         error = vfs_getattr(&path, stat);
  92         path_put(&path);
  93         if (retry_estale(error, lookup_flags)) {
  94                 lookup_flags |= LOOKUP_REVAL;
  95                 goto retry;
  96         }
  97 out:
  98         return error;
  99 }
 100 EXPORT_SYMBOL(vfs_fstatat);
 101
 102 int vfs_stat(const char __user *name, struct kstat *stat)
 103 {
 104         return vfs_fstatat(AT_FDCWD, name, stat, 0);
 105 }
 106 EXPORT_SYMBOL(vfs_stat);
 107
 108 int vfs_lstat(const char __user *name, struct kstat *stat)
 109 {
 110         return vfs_fstatat(AT_FDCWD, name, stat, AT_SYMLINK_NOFOLLOW);
 111 }
 112 EXPORT_SYMBOL(vfs_lstat);
 113
 114
 115 #ifdef __ARCH_WANT_OLD_STAT
 116
 117 /*
 118  * For backward compatibility?  Maybe this should be moved
 119  * into arch/i386 instead?
 120  */
 121 static int cp_old_stat(struct kstat *stat, struct __old_kernel_stat __user * statbuf)
 122 {
 123         static int warncount = 5;
 124         struct __old_kernel_stat tmp;
 125
 126         if (warncount > 0) {
 127                 warncount--;
 128                 printk(KERN_WARNING "VFS: Warning: %s using old stat() call. Recompile your binary.\n",
 129                         current->comm);
 130         } else if (warncount < 0) {
 131                 /* it's laughable, but... */
 132                 warncount = 0;
 133         }
 134
 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)
 139                 return -EOVERFLOW;
 140         tmp.st_mode = stat->mode;
 141         tmp.st_nlink = stat->nlink;
 142         if (tmp.st_nlink != stat->nlink)
 143                 return -EOVERFLOW;
 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)
 149                 return -EOVERFLOW;
 150 #endif
 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;
 156 }
 157
 158 SYSCALL_DEFINE2(stat, const char __user *, filename,
 159                 struct __old_kernel_stat __user *, statbuf)
 160 {
 161         struct kstat stat;
 162         int error;
 163
 164         error = vfs_stat(filename, &stat);
 165         if (error)
 166                 return error;
 167
 168         return cp_old_stat(&stat, statbuf);
 169 }
 170
 171 SYSCALL_DEFINE2(lstat, const char __user *, filename,
 172                 struct __old_kernel_stat __user *, statbuf)
 173 {
 174         struct kstat stat;
 175         int error;
 176
 177         error = vfs_lstat(filename, &stat);
 178         if (error)
 179                 return error;
 180
 181         return cp_old_stat(&stat, statbuf);
 182 }
 183
 184 SYSCALL_DEFINE2(fstat, unsigned int, fd, struct __old_kernel_stat __user *, statbuf)
 185 {
 186         struct kstat stat;
 187         int error = vfs_fstat(fd, &stat);
 188
 189         if (!error)
 190                 error = cp_old_stat(&stat, statbuf);
 191
 192         return error;
 193 }
 194
 195 #endif /* __ARCH_WANT_OLD_STAT */
 196
 197 #if BITS_PER_LONG == 32
 198 #  define choose_32_64(a,b) a
 199 #else
 200 #  define choose_32_64(a,b) b
 201 #endif
 202
 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)
 205
 206 #ifndef INIT_STRUCT_STAT_PADDING
 207 #  define INIT_STRUCT_STAT_PADDING(st) memset(&st, 0, sizeof(st))
 208 #endif
 209
 210 static int cp_new_stat(struct kstat *stat, struct stat __user *statbuf)
 211 {
 212         struct stat tmp;
 213
 214         if (!valid_dev(stat->dev) || !valid_dev(stat->rdev))
 215                 return -EOVERFLOW;
 216 #if BITS_PER_LONG == 32
 217         if (stat->size > MAX_NON_LFS)
 218                 return -EOVERFLOW;
 219 #endif
 220
 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)
 225                 return -EOVERFLOW;
 226         tmp.st_mode = stat->mode;
 227         tmp.st_nlink = stat->nlink;
 228         if (tmp.st_nlink != stat->nlink)
 229                 return -EOVERFLOW;
 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;
 241 #endif
 242         tmp.st_blocks = stat->blocks;
 243         tmp.st_blksize = stat->blksize;
 244         return copy_to_user(statbuf,&tmp,sizeof(tmp)) ? -EFAULT : 0;
 245 }
 246
 247 SYSCALL_DEFINE2(newstat, const char __user *, filename,
 248                 struct stat __user *, statbuf)
 249 {
 250         struct kstat stat;
 251         int error = vfs_stat(filename, &stat);
 252
 253         if (error)
 254                 return error;
 255         return cp_new_stat(&stat, statbuf);
 256 }
 257
 258 SYSCALL_DEFINE2(newlstat, const char __user *, filename,
 259                 struct stat __user *, statbuf)
 260 {
 261         struct kstat stat;
 262         int error;
 263
 264         error = vfs_lstat(filename, &stat);
 265         if (error)
 266                 return error;
 267
 268         return cp_new_stat(&stat, statbuf);
 269 }
 270
 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)
 274 {
 275         struct kstat stat;
 276         int error;
 277
 278         error = vfs_fstatat(dfd, filename, &stat, flag);
 279         if (error)
 280                 return error;
 281         return cp_new_stat(&stat, statbuf);
 282 }
 283 #endif
 284
 285 SYSCALL_DEFINE2(newfstat, unsigned int, fd, struct stat __user *, statbuf)
 286 {
 287         struct kstat stat;
 288         int error = vfs_fstat(fd, &stat);
 289
 290         if (!error)
 291                 error = cp_new_stat(&stat, statbuf);
 292
 293         return error;
 294 }
 295
 296 SYSCALL_DEFINE4(readlinkat, int, dfd, const char __user *, pathname,
 297                 char __user *, buf, int, bufsiz)
 298 {
 299         struct path path;
 300         int error;
 301         int empty = 0;
 302         unsigned int lookup_flags = LOOKUP_EMPTY;
 303
 304         if (bufsiz <= 0)
 305                 return -EINVAL;
 306
 307 retry:
 308         error = user_path_at_empty(dfd, pathname, lookup_flags, &path, &empty);
 309         if (!error) {
 310                 struct inode *inode = path.dentry->d_inode;
 311
 312                 error = empty ? -ENOENT : -EINVAL;
 313                 if (inode->i_op->readlink) {
 314                         error = security_inode_readlink(path.dentry);
 315                         if (!error) {
 316                                 touch_atime(&path);
 317                                 error = inode->i_op->readlink(path.dentry,
 318                                                               buf, bufsiz);
 319                         }
 320                 }
 321                 path_put(&path);
 322                 if (retry_estale(error, lookup_flags)) {
 323                         lookup_flags |= LOOKUP_REVAL;
 324                         goto retry;
 325                 }
 326         }
 327         return error;
 328 }
 329
 330 SYSCALL_DEFINE3(readlink, const char __user *, path, char __user *, buf,
 331                 int, bufsiz)
 332 {
 333         return sys_readlinkat(AT_FDCWD, path, buf, bufsiz);
 334 }
 335
 336
 337 /* ---------- LFS-64 ----------- */
 338 #if defined(__ARCH_WANT_STAT64) || defined(__ARCH_WANT_COMPAT_STAT64)
 339
 340 #ifndef INIT_STRUCT_STAT64_PADDING
 341 #  define INIT_STRUCT_STAT64_PADDING(st) memset(&st, 0, sizeof(st))
 342 #endif
 343
 344 static long cp_new_stat64(struct kstat *stat, struct stat64 __user *statbuf)
 345 {
 346         struct stat64 tmp;
 347
 348         INIT_STRUCT_STAT64_PADDING(tmp);
 349 #ifdef CONFIG_MIPS
 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))
 352                 return -EOVERFLOW;
 353         tmp.st_dev = new_encode_dev(stat->dev);
 354         tmp.st_rdev = new_encode_dev(stat->rdev);
 355 #else
 356         tmp.st_dev = huge_encode_dev(stat->dev);
 357         tmp.st_rdev = huge_encode_dev(stat->rdev);
 358 #endif
 359         tmp.st_ino = stat->ino;
 360         if (sizeof(tmp.st_ino) < sizeof(stat->ino) && tmp.st_ino != stat->ino)
 361                 return -EOVERFLOW;
 362 #ifdef STAT64_HAS_BROKEN_ST_INO
 363         tmp.__st_ino = stat->ino;
 364 #endif
 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;
 379 }
 380
 381 SYSCALL_DEFINE2(stat64, const char __user *, filename,
 382                 struct stat64 __user *, statbuf)
 383 {
 384         struct kstat stat;
 385         int error = vfs_stat(filename, &stat);
 386
 387         if (!error)
 388                 error = cp_new_stat64(&stat, statbuf);
 389
 390         return error;
 391 }
 392
 393 SYSCALL_DEFINE2(lstat64, const char __user *, filename,
 394                 struct stat64 __user *, statbuf)
 395 {
 396         struct kstat stat;
 397         int error = vfs_lstat(filename, &stat);
 398
 399         if (!error)
 400                 error = cp_new_stat64(&stat, statbuf);
 401
 402         return error;
 403 }
 404
 405 SYSCALL_DEFINE2(fstat64, unsigned long, fd, struct stat64 __user *, statbuf)
 406 {
 407         struct kstat stat;
 408         int error = vfs_fstat(fd, &stat);
 409
 410         if (!error)
 411                 error = cp_new_stat64(&stat, statbuf);
 412
 413         return error;
 414 }
 415
 416 SYSCALL_DEFINE4(fstatat64, int, dfd, const char __user *, filename,
 417                 struct stat64 __user *, statbuf, int, flag)
 418 {
 419         struct kstat stat;
 420         int error;
 421
 422         error = vfs_fstatat(dfd, filename, &stat, flag);
 423         if (error)
 424                 return error;
 425         return cp_new_stat64(&stat, statbuf);
 426 }
 427 #endif /* __ARCH_WANT_STAT64 || __ARCH_WANT_COMPAT_STAT64 */
 428
 429 /* Caller is here responsible for sufficient locking (ie. inode->i_lock) */
 430 void __inode_add_bytes(struct inode *inode, loff_t bytes)
 431 {
 432         inode->i_blocks += bytes >> 9;
 433         bytes &= 511;
 434         inode->i_bytes += bytes;
 435         if (inode->i_bytes >= 512) {
 436                 inode->i_blocks++;
 437                 inode->i_bytes -= 512;
 438         }
 439 }
 440
 441 void inode_add_bytes(struct inode *inode, loff_t bytes)
 442 {
 443         spin_lock(&inode->i_lock);
 444         __inode_add_bytes(inode, bytes);
 445         spin_unlock(&inode->i_lock);
 446 }
 447
 448 EXPORT_SYMBOL(inode_add_bytes);
 449
 450 void __inode_sub_bytes(struct inode *inode, loff_t bytes)
 451 {
 452         inode->i_blocks -= bytes >> 9;
 453         bytes &= 511;
 454         if (inode->i_bytes < bytes) {
 455                 inode->i_blocks--;
 456                 inode->i_bytes += 512;
 457         }
 458         inode->i_bytes -= bytes;
 459 }
 460
 461 EXPORT_SYMBOL(__inode_sub_bytes);
 462
 463 void inode_sub_bytes(struct inode *inode, loff_t bytes)
 464 {
 465         spin_lock(&inode->i_lock);
 466         __inode_sub_bytes(inode, bytes);
 467         spin_unlock(&inode->i_lock);
 468 }
 469
 470 EXPORT_SYMBOL(inode_sub_bytes);
 471
 472 loff_t inode_get_bytes(struct inode *inode)
 473 {
 474         loff_t ret;
 475
 476         spin_lock(&inode->i_lock);
 477         ret = (((loff_t)inode->i_blocks) << 9) + inode->i_bytes;
 478         spin_unlock(&inode->i_lock);
 479         return ret;
 480 }
 481
 482 EXPORT_SYMBOL(inode_get_bytes);
 483
 484 void inode_set_bytes(struct inode *inode, loff_t bytes)
 485 {
 486         /* Caller is here responsible for sufficient locking
 487          * (ie. inode->i_lock) */
 488         inode->i_blocks = bytes >> 9;
 489         inode->i_bytes = bytes & 511;
 490 }
 491
 492 EXPORT_SYMBOL(inode_set_bytes);