linux/fs/stat.c
<<
>>
Prefs
   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
  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->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
  38EXPORT_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 */
  52int vfs_getattr_nosec(struct path *path, struct kstat *stat)
  53{
  54        struct inode *inode = path->dentry->d_inode;
  55
  56        if (inode->i_op->getattr)
  57                return inode->i_op->getattr(path->mnt, path->dentry, stat);
  58
  59        generic_fillattr(inode, stat);
  60        return 0;
  61}
  62
  63EXPORT_SYMBOL(vfs_getattr_nosec);
  64
  65int vfs_getattr(struct path *path, struct kstat *stat)
  66{
  67        int retval;
  68
  69        retval = security_inode_getattr(path->mnt, path->dentry);
  70        if (retval)
  71                return retval;
  72        return vfs_getattr_nosec(path, stat);
  73}
  74
  75EXPORT_SYMBOL(vfs_getattr);
  76
  77int vfs_fstat(unsigned int fd, struct kstat *stat)
  78{
  79        struct fd f = fdget_raw(fd);
  80        int error = -EBADF;
  81
  82        if (f.file) {
  83                error = vfs_getattr(&f.file->f_path, stat);
  84                fdput(f);
  85        }
  86        return error;
  87}
  88EXPORT_SYMBOL(vfs_fstat);
  89
  90int 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        if ((flag & ~(AT_SYMLINK_NOFOLLOW | AT_NO_AUTOMOUNT |
  98                      AT_EMPTY_PATH)) != 0)
  99                goto out;
 100
 101        if (!(flag & AT_SYMLINK_NOFOLLOW))
 102                lookup_flags |= LOOKUP_FOLLOW;
 103        if (flag & AT_EMPTY_PATH)
 104                lookup_flags |= LOOKUP_EMPTY;
 105retry:
 106        error = user_path_at(dfd, filename, lookup_flags, &path);
 107        if (error)
 108                goto out;
 109
 110        error = vfs_getattr(&path, stat);
 111        path_put(&path);
 112        if (retry_estale(error, lookup_flags)) {
 113                lookup_flags |= LOOKUP_REVAL;
 114                goto retry;
 115        }
 116out:
 117        return error;
 118}
 119EXPORT_SYMBOL(vfs_fstatat);
 120
 121int vfs_stat(const char __user *name, struct kstat *stat)
 122{
 123        return vfs_fstatat(AT_FDCWD, name, stat, 0);
 124}
 125EXPORT_SYMBOL(vfs_stat);
 126
 127int vfs_lstat(const char __user *name, struct kstat *stat)
 128{
 129        return vfs_fstatat(AT_FDCWD, name, stat, AT_SYMLINK_NOFOLLOW);
 130}
 131EXPORT_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 */
 140static 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
 177SYSCALL_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
 190SYSCALL_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
 203SYSCALL_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
 229static int cp_new_stat(struct kstat *stat, struct stat __user *statbuf)
 230{
 231        struct stat tmp;
 232
 233        if (!valid_dev(stat->dev) || !valid_dev(stat->rdev))
 234                return -EOVERFLOW;
 235#if BITS_PER_LONG == 32
 236        if (stat->size > MAX_NON_LFS)
 237                return -EOVERFLOW;
 238#endif
 239
 240        INIT_STRUCT_STAT_PADDING(tmp);
 241        tmp.st_dev = encode_dev(stat->dev);
 242        tmp.st_ino = stat->ino;
 243        if (sizeof(tmp.st_ino) < sizeof(stat->ino) && tmp.st_ino != stat->ino)
 244                return -EOVERFLOW;
 245        tmp.st_mode = stat->mode;
 246        tmp.st_nlink = stat->nlink;
 247        if (tmp.st_nlink != stat->nlink)
 248                return -EOVERFLOW;
 249        SET_UID(tmp.st_uid, from_kuid_munged(current_user_ns(), stat->uid));
 250        SET_GID(tmp.st_gid, from_kgid_munged(current_user_ns(), stat->gid));
 251        tmp.st_rdev = encode_dev(stat->rdev);
 252        tmp.st_size = stat->size;
 253        tmp.st_atime = stat->atime.tv_sec;
 254        tmp.st_mtime = stat->mtime.tv_sec;
 255        tmp.st_ctime = stat->ctime.tv_sec;
 256#ifdef STAT_HAVE_NSEC
 257        tmp.st_atime_nsec = stat->atime.tv_nsec;
 258        tmp.st_mtime_nsec = stat->mtime.tv_nsec;
 259        tmp.st_ctime_nsec = stat->ctime.tv_nsec;
 260#endif
 261        tmp.st_blocks = stat->blocks;
 262        tmp.st_blksize = stat->blksize;
 263        return copy_to_user(statbuf,&tmp,sizeof(tmp)) ? -EFAULT : 0;
 264}
 265
 266SYSCALL_DEFINE2(newstat, const char __user *, filename,
 267                struct stat __user *, statbuf)
 268{
 269        struct kstat stat;
 270        int error = vfs_stat(filename, &stat);
 271
 272        if (error)
 273                return error;
 274        return cp_new_stat(&stat, statbuf);
 275}
 276
 277SYSCALL_DEFINE2(newlstat, const char __user *, filename,
 278                struct stat __user *, statbuf)
 279{
 280        struct kstat stat;
 281        int error;
 282
 283        error = vfs_lstat(filename, &stat);
 284        if (error)
 285                return error;
 286
 287        return cp_new_stat(&stat, statbuf);
 288}
 289
 290#if !defined(__ARCH_WANT_STAT64) || defined(__ARCH_WANT_SYS_NEWFSTATAT)
 291SYSCALL_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
 304SYSCALL_DEFINE2(newfstat, unsigned int, fd, struct stat __user *, statbuf)
 305{
 306        struct kstat stat;
 307        int error = vfs_fstat(fd, &stat);
 308
 309        if (!error)
 310                error = cp_new_stat(&stat, statbuf);
 311
 312        return error;
 313}
 314
 315SYSCALL_DEFINE4(readlinkat, int, dfd, const char __user *, pathname,
 316                char __user *, buf, int, bufsiz)
 317{
 318        struct path path;
 319        int error;
 320        int empty = 0;
 321        unsigned int lookup_flags = LOOKUP_EMPTY;
 322
 323        if (bufsiz <= 0)
 324                return -EINVAL;
 325
 326retry:
 327        error = user_path_at_empty(dfd, pathname, lookup_flags, &path, &empty);
 328        if (!error) {
 329                struct inode *inode = path.dentry->d_inode;
 330
 331                error = empty ? -ENOENT : -EINVAL;
 332                if (inode->i_op->readlink) {
 333                        error = security_inode_readlink(path.dentry);
 334                        if (!error) {
 335                                touch_atime(&path);
 336                                error = inode->i_op->readlink(path.dentry,
 337                                                              buf, bufsiz);
 338                        }
 339                }
 340                path_put(&path);
 341                if (retry_estale(error, lookup_flags)) {
 342                        lookup_flags |= LOOKUP_REVAL;
 343                        goto retry;
 344                }
 345        }
 346        return error;
 347}
 348
 349SYSCALL_DEFINE3(readlink, const char __user *, path, char __user *, buf,
 350                int, bufsiz)
 351{
 352        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
 363static long cp_new_stat64(struct kstat *stat, struct stat64 __user *statbuf)
 364{
 365        struct stat64 tmp;
 366
 367        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        tmp.st_dev = huge_encode_dev(stat->dev);
 376        tmp.st_rdev = huge_encode_dev(stat->rdev);
 377#endif
 378        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        tmp.__st_ino = stat->ino;
 383#endif
 384        tmp.st_mode = stat->mode;
 385        tmp.st_nlink = stat->nlink;
 386        tmp.st_uid = from_kuid_munged(current_user_ns(), stat->uid);
 387        tmp.st_gid = from_kgid_munged(current_user_ns(), stat->gid);
 388        tmp.st_atime = stat->atime.tv_sec;
 389        tmp.st_atime_nsec = stat->atime.tv_nsec;
 390        tmp.st_mtime = stat->mtime.tv_sec;
 391        tmp.st_mtime_nsec = stat->mtime.tv_nsec;
 392        tmp.st_ctime = stat->ctime.tv_sec;
 393        tmp.st_ctime_nsec = stat->ctime.tv_nsec;
 394        tmp.st_size = stat->size;
 395        tmp.st_blocks = stat->blocks;
 396        tmp.st_blksize = stat->blksize;
 397        return copy_to_user(statbuf,&tmp,sizeof(tmp)) ? -EFAULT : 0;
 398}
 399
 400SYSCALL_DEFINE2(stat64, const char __user *, filename,
 401                struct stat64 __user *, statbuf)
 402{
 403        struct kstat stat;
 404        int error = vfs_stat(filename, &stat);
 405
 406        if (!error)
 407                error = cp_new_stat64(&stat, statbuf);
 408
 409        return error;
 410}
 411
 412SYSCALL_DEFINE2(lstat64, const char __user *, filename,
 413                struct stat64 __user *, statbuf)
 414{
 415        struct kstat stat;
 416        int error = vfs_lstat(filename, &stat);
 417
 418        if (!error)
 419                error = cp_new_stat64(&stat, statbuf);
 420
 421        return error;
 422}
 423
 424SYSCALL_DEFINE2(fstat64, unsigned long, fd, struct stat64 __user *, statbuf)
 425{
 426        struct kstat stat;
 427        int error = vfs_fstat(fd, &stat);
 428
 429        if (!error)
 430                error = cp_new_stat64(&stat, statbuf);
 431
 432        return error;
 433}
 434
 435SYSCALL_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        error = vfs_fstatat(dfd, filename, &stat, flag);
 442        if (error)
 443                return error;
 444        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) */
 449void __inode_add_bytes(struct inode *inode, loff_t bytes)
 450{
 451        inode->i_blocks += bytes >> 9;
 452        bytes &= 511;
 453        inode->i_bytes += bytes;
 454        if (inode->i_bytes >= 512) {
 455                inode->i_blocks++;
 456                inode->i_bytes -= 512;
 457        }
 458}
 459
 460void 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}
 466
 467EXPORT_SYMBOL(inode_add_bytes);
 468
 469void __inode_sub_bytes(struct inode *inode, loff_t bytes)
 470{
 471        inode->i_blocks -= bytes >> 9;
 472        bytes &= 511;
 473        if (inode->i_bytes < bytes) {
 474                inode->i_blocks--;
 475                inode->i_bytes += 512;
 476        }
 477        inode->i_bytes -= bytes;
 478}
 479
 480EXPORT_SYMBOL(__inode_sub_bytes);
 481
 482void 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}
 488
 489EXPORT_SYMBOL(inode_sub_bytes);
 490
 491loff_t inode_get_bytes(struct inode *inode)
 492{
 493        loff_t ret;
 494
 495        spin_lock(&inode->i_lock);
 496        ret = (((loff_t)inode->i_blocks) << 9) + inode->i_bytes;
 497        spin_unlock(&inode->i_lock);
 498        return ret;
 499}
 500
 501EXPORT_SYMBOL(inode_get_bytes);
 502
 503void inode_set_bytes(struct inode *inode, loff_t bytes)
 504{
 505        /* Caller is here responsible for sufficient locking
 506         * (ie. inode->i_lock) */
 507        inode->i_blocks = bytes >> 9;
 508        inode->i_bytes = bytes & 511;
 509}
 510
 511EXPORT_SYMBOL(inode_set_bytes);
 512