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