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 = 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         memset(&tmp, 0, sizeof(struct __old_kernel_stat));
 120         tmp.st_dev = stat->dev;
 121         tmp.st_ino = stat->ino;
 122         tmp.st_mode = stat->mode;
 123         tmp.st_nlink = stat->nlink;
 124         SET_OLDSTAT_UID(tmp, stat->uid);
 125         SET_OLDSTAT_GID(tmp, stat->gid);
 126         tmp.st_rdev = stat->rdev;
 127 #if BITS_PER_LONG == 32
 128         if (stat->size > MAX_NON_LFS)
 129                 return -EOVERFLOW;
 130 #endif
 131         tmp.st_size = stat->size;
 132         tmp.st_atime = stat->atime.tv_sec;
 133         tmp.st_mtime = stat->mtime.tv_sec;
 134         tmp.st_ctime = stat->ctime.tv_sec;
 135         return copy_to_user(statbuf,&tmp,sizeof(tmp)) ? -EFAULT : 0;
 136 }
 137
 138 asmlinkage long sys_stat(char __user * filename, struct __old_kernel_stat __user * statbuf)
 139 {
 140         struct kstat stat;
 141         int error = vfs_stat(filename, &stat);
 142
 143         if (!error)
 144                 error = cp_old_stat(&stat, statbuf);
 145
 146         return error;
 147 }
 148 asmlinkage long sys_lstat(char __user * filename, struct __old_kernel_stat __user * statbuf)
 149 {
 150         struct kstat stat;
 151         int error = vfs_lstat(filename, &stat);
 152
 153         if (!error)
 154                 error = cp_old_stat(&stat, statbuf);
 155
 156         return error;
 157 }
 158 asmlinkage long sys_fstat(unsigned int fd, struct __old_kernel_stat __user * statbuf)
 159 {
 160         struct kstat stat;
 161         int error = vfs_fstat(fd, &stat);
 162
 163         if (!error)
 164                 error = cp_old_stat(&stat, statbuf);
 165
 166         return error;
 167 }
 168
 169 #endif
 170
 171 static int cp_new_stat(struct kstat *stat, struct stat __user *statbuf)
 172 {
 173         struct stat tmp;
 174
 175         memset(&tmp, 0, sizeof(tmp));
 176         tmp.st_dev = stat->dev;
 177         tmp.st_ino = stat->ino;
 178         tmp.st_mode = stat->mode;
 179         tmp.st_nlink = stat->nlink;
 180         SET_STAT_UID(tmp, stat->uid);
 181         SET_STAT_GID(tmp, stat->gid);
 182         tmp.st_rdev = stat->rdev;
 183 #if BITS_PER_LONG == 32
 184         if (stat->size > MAX_NON_LFS)
 185                 return -EOVERFLOW;
 186 #endif
 187         tmp.st_size = stat->size;
 188         tmp.st_atime = stat->atime.tv_sec;
 189         tmp.st_mtime = stat->mtime.tv_sec;
 190         tmp.st_ctime = stat->ctime.tv_sec;
 191 #ifdef STAT_HAVE_NSEC
 192         tmp.st_atime_nsec = stat->atime.tv_nsec;
 193         tmp.st_mtime_nsec = stat->mtime.tv_nsec;
 194         tmp.st_ctime_nsec = stat->ctime.tv_nsec;
 195 #endif
 196         tmp.st_blocks = stat->blocks;
 197         tmp.st_blksize = stat->blksize;
 198         return copy_to_user(statbuf,&tmp,sizeof(tmp)) ? -EFAULT : 0;
 199 }
 200
 201 asmlinkage long sys_newstat(char __user * filename, struct stat __user * statbuf)
 202 {
 203         struct kstat stat;
 204         int error = vfs_stat(filename, &stat);
 205
 206         if (!error)
 207                 error = cp_new_stat(&stat, statbuf);
 208
 209         return error;
 210 }
 211 asmlinkage long sys_newlstat(char __user * filename, struct stat __user * statbuf)
 212 {
 213         struct kstat stat;
 214         int error = vfs_lstat(filename, &stat);
 215
 216         if (!error)
 217                 error = cp_new_stat(&stat, statbuf);
 218
 219         return error;
 220 }
 221 asmlinkage long sys_newfstat(unsigned int fd, struct stat __user * statbuf)
 222 {
 223         struct kstat stat;
 224         int error = vfs_fstat(fd, &stat);
 225
 226         if (!error)
 227                 error = cp_new_stat(&stat, statbuf);
 228
 229         return error;
 230 }
 231
 232 asmlinkage long sys_readlink(const char __user * path, char __user * buf, int bufsiz)
 233 {
 234         struct nameidata nd;
 235         int error;
 236
 237         if (bufsiz <= 0)
 238                 return -EINVAL;
 239
 240         error = user_path_walk_link(path, &nd);
 241         if (!error) {
 242                 struct inode * inode = nd.dentry->d_inode;
 243
 244                 error = -EINVAL;
 245                 if (inode->i_op && inode->i_op->readlink) {
 246                         error = security_inode_readlink(nd.dentry);
 247                         if (!error) {
 248                                 update_atime(inode);
 249                                 error = inode->i_op->readlink(nd.dentry, buf, bufsiz);
 250                         }
 251                 }
 252                 path_release(&nd);
 253         }
 254         return error;
 255 }
 256
 257
 258 /* ---------- LFS-64 ----------- */
 259 #if !defined(__alpha__) && !defined(__ia64__) && !defined(__mips64) && !defined(__x86_64__) && !defined(CONFIG_ARCH_S390X)
 260
 261 static long cp_new_stat64(struct kstat *stat, struct stat64 __user *statbuf)
 262 {
 263         struct stat64 tmp;
 264
 265         memset(&tmp, 0, sizeof(struct stat64));
 266         tmp.st_dev = stat->dev;
 267         tmp.st_ino = stat->ino;
 268 #ifdef STAT64_HAS_BROKEN_ST_INO
 269         tmp.__st_ino = stat->ino;
 270 #endif
 271         tmp.st_mode = stat->mode;
 272         tmp.st_nlink = stat->nlink;
 273         tmp.st_uid = stat->uid;
 274         tmp.st_gid = stat->gid;
 275         tmp.st_rdev = stat->rdev;
 276         tmp.st_atime = stat->atime.tv_sec;
 277         tmp.st_atime_nsec = stat->atime.tv_nsec;
 278         tmp.st_mtime = stat->mtime.tv_sec;
 279         tmp.st_mtime_nsec = stat->mtime.tv_nsec;
 280         tmp.st_ctime = stat->ctime.tv_sec;
 281         tmp.st_ctime_nsec = stat->ctime.tv_nsec;
 282         tmp.st_size = stat->size;
 283         tmp.st_blocks = stat->blocks;
 284         tmp.st_blksize = stat->blksize;
 285         return copy_to_user(statbuf,&tmp,sizeof(tmp)) ? -EFAULT : 0;
 286 }
 287
 288 asmlinkage long sys_stat64(char __user * filename, struct stat64 __user * statbuf, long flags)
 289 {
 290         struct kstat stat;
 291         int error = vfs_stat(filename, &stat);
 292
 293         if (!error)
 294                 error = cp_new_stat64(&stat, statbuf);
 295
 296         return error;
 297 }
 298 asmlinkage long sys_lstat64(char __user * filename, struct stat64 __user * statbuf, long flags)
 299 {
 300         struct kstat stat;
 301         int error = vfs_lstat(filename, &stat);
 302
 303         if (!error)
 304                 error = cp_new_stat64(&stat, statbuf);
 305
 306         return error;
 307 }
 308 asmlinkage long sys_fstat64(unsigned long fd, struct stat64 __user * statbuf, long flags)
 309 {
 310         struct kstat stat;
 311         int error = vfs_fstat(fd, &stat);
 312
 313         if (!error)
 314                 error = cp_new_stat64(&stat, statbuf);
 315
 316         return error;
 317 }
 318
 319 #endif /* LFS-64 */
 320
 321 void inode_add_bytes(struct inode *inode, loff_t bytes)
 322 {
 323         spin_lock(&inode->i_lock);
 324         inode->i_blocks += bytes >> 9;
 325         bytes &= 511;
 326         inode->i_bytes += bytes;
 327         if (inode->i_bytes >= 512) {
 328                 inode->i_blocks++;
 329                 inode->i_bytes -= 512;
 330         }
 331         spin_unlock(&inode->i_lock);
 332 }
 333
 334 void inode_sub_bytes(struct inode *inode, loff_t bytes)
 335 {
 336         spin_lock(&inode->i_lock);
 337         inode->i_blocks -= bytes >> 9;
 338         bytes &= 511;
 339         if (inode->i_bytes < bytes) {
 340                 inode->i_blocks--;
 341                 inode->i_bytes += 512;
 342         }
 343         inode->i_bytes -= bytes;
 344         spin_unlock(&inode->i_lock);
 345 }
 346
 347 loff_t inode_get_bytes(struct inode *inode)
 348 {
 349         loff_t ret;
 350
 351         spin_lock(&inode->i_lock);
 352         ret = (((loff_t)inode->i_blocks) << 9) + inode->i_bytes;
 353         spin_unlock(&inode->i_lock);
 354         return ret;
 355 }
 356
 357 void inode_set_bytes(struct inode *inode, loff_t bytes)
 358 {
 359         inode->i_blocks = bytes >> 9;
 360         inode->i_bytes = bytes & 511;
 361 }