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