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