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