fs/stat.c

   1 /*
   2  *  linux/fs/stat.c
   3  *
   4  *  Copyright (C) 1991, 1992  Linus Torvalds
   5  */
   6
   7 #include <linux/config.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
  17 #include <asm/uaccess.h>
  18
  19 void generic_fillattr(struct inode *inode, struct kstat *stat)
  20 {
  21         stat->dev = inode->i_sb->s_dev;
  22         stat->ino = inode->i_ino;
  23         stat->mode = inode->i_mode;
  24         stat->nlink = inode->i_nlink;
  25         stat->uid = inode->i_uid;
  26         stat->gid = inode->i_gid;
  27         stat->rdev = kdev_t_to_nr(inode->i_rdev);
  28         stat->atime = inode->i_atime;
  29         stat->mtime = inode->i_mtime;
  30         stat->ctime = inode->i_ctime;
  31         stat->size = i_size_read(inode);
  32         stat->blocks = inode->i_blocks;
  33         stat->blksize = inode->i_blksize;
  34 }
  35
  36 int vfs_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
  37 {
  38         struct inode *inode = dentry->d_inode;
  39         int retval;
  40
  41         retval = security_inode_getattr(mnt, dentry);
  42         if (retval)
  43                 return retval;
  44
  45         if (inode->i_op->getattr)
  46                 return inode->i_op->getattr(mnt, dentry, stat);
  47
  48         generic_fillattr(inode, stat);
  49         if (!stat->blksize) {
  50                 struct super_block *s = inode->i_sb;
  51                 unsigned blocks;
  52                 blocks = (stat->size+s->s_blocksize-1) >> s->s_blocksize_bits;
  53                 stat->blocks = (s->s_blocksize / 512) * blocks;
  54                 stat->blksize = s->s_blocksize;
  55         }
  56         return 0;
  57 }
  58
  59 int vfs_stat(char __user *name, struct kstat *stat)
  60 {
  61         struct nameidata nd;
  62         int error;
  63
  64         error = user_path_walk(name, &nd);
  65         if (!error) {
  66                 error = vfs_getattr(nd.mnt, nd.dentry, stat);
  67                 path_release(&nd);
  68         }
  69         return error;
  70 }
  71
  72 int vfs_lstat(char __user *name, struct kstat *stat)
  73 {
  74         struct nameidata nd;
  75         int error;
  76
  77         error = user_path_walk_link(name, &nd);
  78         if (!error) {
  79                 error = vfs_getattr(nd.mnt, nd.dentry, stat);
  80                 path_release(&nd);
  81         }
  82         return error;
  83 }
  84
  85 int vfs_fstat(unsigned int fd, struct kstat *stat)
  86 {
  87         struct file *f = fget(fd);
  88         int error = -EBADF;
  89
  90         if (f) {
  91                 error = vfs_getattr(f->f_vfsmnt, f->f_dentry, stat);
  92                 fput(f);
  93         }
  94         return error;
  95 }
  96
  97 #if !defined(__alpha__) && !defined(__sparc__) && !defined(__ia64__) \
  98   && !defined(CONFIG_ARCH_S390) && !defined(__hppa__) && !defined(__x86_64__) \
  99   && !defined(__arm__) && !defined(CONFIG_V850) && !defined(__powerpc64__)
 100
 101 /*
 102  * For backward compatibility?  Maybe this should be moved
 103  * into arch/i386 instead?
 104  */
 105 static int cp_old_stat(struct kstat *stat, struct __old_kernel_stat __user * statbuf)
 106 {
 107         static int warncount = 5;
 108         struct __old_kernel_stat tmp;
 109
 110         if (warncount > 0) {
 111                 warncount--;
 112                 printk(KERN_WARNING "VFS: Warning: %s using old stat() call. Recompile your binary.\n",
 113                         current->comm);
 114         } else if (warncount < 0) {
 115                 /* it's laughable, but... */
 116                 warncount = 0;
 117         }
 118
 119         tmp.st_dev = stat->dev;
 120         tmp.st_ino = stat->ino;
 121         tmp.st_mode = stat->mode;
 122         tmp.st_nlink = stat->nlink;
 123         SET_OLDSTAT_UID(tmp, stat->uid);
 124         SET_OLDSTAT_GID(tmp, stat->gid);
 125         tmp.st_rdev = stat->rdev;
 126 #if BITS_PER_LONG == 32
 127         if (stat->size > MAX_NON_LFS)
 128                 return -EOVERFLOW;
 129 #endif
 130         tmp.st_size = stat->size;
 131         tmp.st_atime = stat->atime.tv_sec;
 132         tmp.st_mtime = stat->mtime.tv_sec;
 133         tmp.st_ctime = stat->ctime.tv_sec;
 134         return copy_to_user(statbuf,&tmp,sizeof(tmp)) ? -EFAULT : 0;
 135 }
 136
 137 asmlinkage long sys_stat(char __user * filename, struct __old_kernel_stat __user * statbuf)
 138 {
 139         struct kstat stat;
 140         int error = vfs_stat(filename, &stat);
 141
 142         if (!error)
 143                 error = cp_old_stat(&stat, statbuf);
 144
 145         return error;
 146 }
 147 asmlinkage long sys_lstat(char __user * filename, struct __old_kernel_stat __user * statbuf)
 148 {
 149         struct kstat stat;
 150         int error = vfs_lstat(filename, &stat);
 151
 152         if (!error)
 153                 error = cp_old_stat(&stat, statbuf);
 154
 155         return error;
 156 }
 157 asmlinkage long sys_fstat(unsigned int fd, struct __old_kernel_stat __user * statbuf)
 158 {
 159         struct kstat stat;
 160         int error = vfs_fstat(fd, &stat);
 161
 162         if (!error)
 163                 error = cp_old_stat(&stat, statbuf);
 164
 165         return error;
 166 }
 167
 168 #endif
 169
 170 static int cp_new_stat(struct kstat *stat, struct stat __user *statbuf)
 171 {
 172         struct stat tmp;
 173
 174         memset(&tmp, 0, sizeof(tmp));
 175         tmp.st_dev = stat->dev;
 176         tmp.st_ino = stat->ino;
 177         tmp.st_mode = stat->mode;
 178         tmp.st_nlink = stat->nlink;
 179         SET_STAT_UID(tmp, stat->uid);
 180         SET_STAT_GID(tmp, stat->gid);
 181         tmp.st_rdev = stat->rdev;
 182 #if BITS_PER_LONG == 32
 183         if (stat->size > MAX_NON_LFS)
 184                 return -EOVERFLOW;
 185 #endif
 186         tmp.st_size = stat->size;
 187         tmp.st_atime = stat->atime.tv_sec;
 188         tmp.st_mtime = stat->mtime.tv_sec;
 189         tmp.st_ctime = stat->ctime.tv_sec;
 190 #ifdef STAT_HAVE_NSEC
 191         tmp.st_atime_nsec = stat->atime.tv_nsec;
 192         tmp.st_mtime_nsec = stat->mtime.tv_nsec;
 193         tmp.st_ctime_nsec = stat->ctime.tv_nsec;
 194 #endif
 195         tmp.st_blocks = stat->blocks;
 196         tmp.st_blksize = stat->blksize;
 197         return copy_to_user(statbuf,&tmp,sizeof(tmp)) ? -EFAULT : 0;
 198 }
 199
 200 asmlinkage long sys_newstat(char __user * filename, struct stat __user * statbuf)
 201 {
 202         struct kstat stat;
 203         int error = vfs_stat(filename, &stat);
 204
 205         if (!error)
 206                 error = cp_new_stat(&stat, statbuf);
 207
 208         return error;
 209 }
 210 asmlinkage long sys_newlstat(char __user * filename, struct stat __user * statbuf)
 211 {
 212         struct kstat stat;
 213         int error = vfs_lstat(filename, &stat);
 214
 215         if (!error)
 216                 error = cp_new_stat(&stat, statbuf);
 217
 218         return error;
 219 }
 220 asmlinkage long sys_newfstat(unsigned int fd, struct stat __user * statbuf)
 221 {
 222         struct kstat stat;
 223         int error = vfs_fstat(fd, &stat);
 224
 225         if (!error)
 226                 error = cp_new_stat(&stat, statbuf);
 227
 228         return error;
 229 }
 230
 231 asmlinkage long sys_readlink(const char __user * path, char __user * buf, int bufsiz)
 232 {
 233         struct nameidata nd;
 234         int error;
 235
 236         if (bufsiz <= 0)
 237                 return -EINVAL;
 238
 239         error = user_path_walk_link(path, &nd);
 240         if (!error) {
 241                 struct inode * inode = nd.dentry->d_inode;
 242
 243                 error = -EINVAL;
 244                 if (inode->i_op && inode->i_op->readlink) {
 245                         error = security_inode_readlink(nd.dentry);
 246                         if (!error) {
 247                                 update_atime(inode);
 248                                 error = inode->i_op->readlink(nd.dentry, buf, bufsiz);
 249                         }
 250                 }
 251                 path_release(&nd);
 252         }
 253         return error;
 254 }
 255
 256
 257 /* ---------- LFS-64 ----------- */
 258 #if !defined(__alpha__) && !defined(__ia64__) && !defined(__mips64) && !defined(__x86_64__) && !defined(CONFIG_ARCH_S390X)
 259
 260 static long cp_new_stat64(struct kstat *stat, struct stat64 __user *statbuf)
 261 {
 262         struct stat64 tmp;
 263
 264         memset(&tmp, 0, sizeof(struct stat64));
 265         tmp.st_dev = stat->dev;
 266         tmp.st_ino = stat->ino;
 267 #ifdef STAT64_HAS_BROKEN_ST_INO
 268         tmp.__st_ino = stat->ino;
 269 #endif
 270         tmp.st_mode = stat->mode;
 271         tmp.st_nlink = stat->nlink;
 272         tmp.st_uid = stat->uid;
 273         tmp.st_gid = stat->gid;
 274         tmp.st_rdev = stat->rdev;
 275         tmp.st_atime = stat->atime.tv_sec;
 276         tmp.st_atime_nsec = stat->atime.tv_nsec;
 277         tmp.st_mtime = stat->mtime.tv_sec;
 278         tmp.st_mtime_nsec = stat->mtime.tv_nsec;
 279         tmp.st_ctime = stat->ctime.tv_sec;
 280         tmp.st_ctime_nsec = stat->ctime.tv_nsec;
 281         tmp.st_size = stat->size;
 282         tmp.st_blocks = stat->blocks;
 283         tmp.st_blksize = stat->blksize;
 284         return copy_to_user(statbuf,&tmp,sizeof(tmp)) ? -EFAULT : 0;
 285 }
 286
 287 asmlinkage long sys_stat64(char __user * filename, struct stat64 __user * statbuf, long flags)
 288 {
 289         struct kstat stat;
 290         int error = vfs_stat(filename, &stat);
 291
 292         if (!error)
 293                 error = cp_new_stat64(&stat, statbuf);
 294
 295         return error;
 296 }
 297 asmlinkage long sys_lstat64(char __user * filename, struct stat64 __user * statbuf, long flags)
 298 {
 299         struct kstat stat;
 300         int error = vfs_lstat(filename, &stat);
 301
 302         if (!error)
 303                 error = cp_new_stat64(&stat, statbuf);
 304
 305         return error;
 306 }
 307 asmlinkage long sys_fstat64(unsigned long fd, struct stat64 __user * statbuf, long flags)
 308 {
 309         struct kstat stat;
 310         int error = vfs_fstat(fd, &stat);
 311
 312         if (!error)
 313                 error = cp_new_stat64(&stat, statbuf);
 314
 315         return error;
 316 }
 317
 318 #endif /* LFS-64 */
 319
 320 void inode_add_bytes(struct inode *inode, loff_t bytes)
 321 {
 322         spin_lock(&inode->i_lock);
 323         inode->i_blocks += bytes >> 9;
 324         bytes &= 511;
 325         inode->i_bytes += bytes;
 326         if (inode->i_bytes >= 512) {
 327                 inode->i_blocks++;
 328                 inode->i_bytes -= 512;
 329         }
 330         spin_unlock(&inode->i_lock);
 331 }
 332
 333 void inode_sub_bytes(struct inode *inode, loff_t bytes)
 334 {
 335         spin_lock(&inode->i_lock);
 336         inode->i_blocks -= bytes >> 9;
 337         bytes &= 511;
 338         if (inode->i_bytes < bytes) {
 339                 inode->i_blocks--;
 340                 inode->i_bytes += 512;
 341         }
 342         inode->i_bytes -= bytes;
 343         spin_unlock(&inode->i_lock);
 344 }
 345
 346 loff_t inode_get_bytes(struct inode *inode)
 347 {
 348         loff_t ret;
 349
 350         spin_lock(&inode->i_lock);
 351         ret = (((loff_t)inode->i_blocks) << 9) + inode->i_bytes;
 352         spin_unlock(&inode->i_lock);
 353         return ret;
 354 }
 355
 356 void inode_set_bytes(struct inode *inode, loff_t bytes)
 357 {
 358         inode->i_blocks = bytes >> 9;
 359         inode->i_bytes = bytes & 511;
 360 }