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