fs/stat.c

   1 /*
   2  *  linux/fs/stat.c
   3  *
   4  *  Copyright (C) 1991, 1992  Linus Torvalds
   5  */
   6
   7 #include <linux/errno.h>
   8 #include <linux/string.h>
   9 #include <linux/stat.h>
  10 #include <linux/fs.h>
  11 #include <linux/sched.h>
  12 #include <linux/kernel.h>
  13 #include <linux/mm.h>
  14 #include <linux/smp.h>
  15 #include <linux/smp_lock.h>
  16
  17 #include <asm/uaccess.h>
  18
  19 /*
  20  * Revalidate the inode. This is required for proper NFS attribute caching.
  21  */
  22 static __inline__ int
  23 do_revalidate(struct inode *inode)
  24 {
  25         if (inode->i_op && inode->i_op->revalidate)
  26                 return inode->i_op->revalidate(inode);
  27         return 0;
  28 }
  29
  30
  31 #if !defined(__alpha__) && !defined(__sparc__)
  32
  33 /*
  34  * For backward compatibility?  Maybe this should be moved
  35  * into arch/i386 instead?
  36  */
  37 static int cp_old_stat(struct inode * inode, struct __old_kernel_stat * statbuf)
  38 {
  39         struct __old_kernel_stat tmp;
  40
  41         printk("VFS: Warning: %s using old stat() call. Recompile your binary.\n",
  42                 current->comm);
  43         tmp.st_dev = kdev_t_to_nr(inode->i_dev);
  44         tmp.st_ino = inode->i_ino;
  45         tmp.st_mode = inode->i_mode;
  46         tmp.st_nlink = inode->i_nlink;
  47         tmp.st_uid = inode->i_uid;
  48         tmp.st_gid = inode->i_gid;
  49         tmp.st_rdev = kdev_t_to_nr(inode->i_rdev);
  50         tmp.st_size = inode->i_size;
  51         tmp.st_atime = inode->i_atime;
  52         tmp.st_mtime = inode->i_mtime;
  53         tmp.st_ctime = inode->i_ctime;
  54         return copy_to_user(statbuf,&tmp,sizeof(tmp)) ? -EFAULT : 0;
  55 }
  56
  57 #endif
  58
  59 static int cp_new_stat(struct inode * inode, struct stat * statbuf)
  60 {
  61         struct stat tmp;
  62         unsigned int blocks, indirect;
  63
  64         memset(&tmp, 0, sizeof(tmp));
  65         tmp.st_dev = kdev_t_to_nr(inode->i_dev);
  66         tmp.st_ino = inode->i_ino;
  67         tmp.st_mode = inode->i_mode;
  68         tmp.st_nlink = inode->i_nlink;
  69         tmp.st_uid = inode->i_uid;
  70         tmp.st_gid = inode->i_gid;
  71         tmp.st_rdev = kdev_t_to_nr(inode->i_rdev);
  72         tmp.st_size = inode->i_size;
  73         tmp.st_atime = inode->i_atime;
  74         tmp.st_mtime = inode->i_mtime;
  75         tmp.st_ctime = inode->i_ctime;
  76 /*
  77  * st_blocks and st_blksize are approximated with a simple algorithm if
  78  * they aren't supported directly by the filesystem. The minix and msdos
  79  * filesystems don't keep track of blocks, so they would either have to
  80  * be counted explicitly (by delving into the file itself), or by using
  81  * this simple algorithm to get a reasonable (although not 100% accurate)
  82  * value.
  83  */
  84
  85 /*
  86  * Use minix fs values for the number of direct and indirect blocks.  The
  87  * count is now exact for the minix fs except that it counts zero blocks.
  88  * Everything is in BLOCK_SIZE'd units until the assignment to
  89  * tmp.st_blksize.
  90  */
  91 #define D_B   7
  92 #define I_B   (BLOCK_SIZE / sizeof(unsigned short))
  93
  94         if (!inode->i_blksize) {
  95                 blocks = (tmp.st_size + BLOCK_SIZE - 1) / BLOCK_SIZE;
  96                 if (blocks > D_B) {
  97                         indirect = (blocks - D_B + I_B - 1) / I_B;
  98                         blocks += indirect;
  99                         if (indirect > 1) {
 100                                 indirect = (indirect - 1 + I_B - 1) / I_B;
 101                                 blocks += indirect;
 102                                 if (indirect > 1)
 103                                         blocks++;
 104                         }
 105                 }
 106                 tmp.st_blocks = (BLOCK_SIZE / 512) * blocks;
 107                 tmp.st_blksize = BLOCK_SIZE;
 108         } else {
 109                 tmp.st_blocks = inode->i_blocks;
 110                 tmp.st_blksize = inode->i_blksize;
 111         }
 112         return copy_to_user(statbuf,&tmp,sizeof(tmp)) ? -EFAULT : 0;
 113 }
 114
 115
 116 #if !defined(__alpha__) && !defined(__sparc__)
 117 /*
 118  * For backward compatibility?  Maybe this should be moved
 119  * into arch/i386 instead?
 120  */
 121 asmlinkage int sys_stat(char * filename, struct __old_kernel_stat * statbuf)
 122 {
 123         struct dentry * dentry;
 124         int error;
 125
 126         lock_kernel();
 127         dentry = namei(filename);
 128
 129         error = PTR_ERR(dentry);
 130         if (!IS_ERR(dentry)) {
 131                 struct inode * inode = dentry->d_inode;
 132                 error = do_revalidate(inode);
 133                 if (!error)
 134                         error = cp_old_stat(inode, statbuf);
 135
 136                 dput(dentry);
 137         }
 138         unlock_kernel();
 139         return error;
 140 }
 141 #endif
 142
 143 asmlinkage int sys_newstat(char * filename, struct stat * statbuf)
 144 {
 145         struct dentry * dentry;
 146         int error;
 147
 148         lock_kernel();
 149         dentry = namei(filename);
 150
 151         error = PTR_ERR(dentry);
 152         if (!IS_ERR(dentry)) {
 153                 struct inode * inode = dentry->d_inode;
 154                 error = do_revalidate(inode);
 155                 if (!error)
 156                         error = cp_new_stat(inode,statbuf);
 157
 158                 dput(dentry);
 159         }
 160         unlock_kernel();
 161         return error;
 162 }
 163
 164 #if !defined(__alpha__) && !defined(__sparc__)
 165
 166 /*
 167  * For backward compatibility?  Maybe this should be moved
 168  * into arch/i386 instead?
 169  */
 170 asmlinkage int sys_lstat(char * filename, struct __old_kernel_stat * statbuf)
 171 {
 172         struct dentry * dentry;
 173         int error;
 174
 175         lock_kernel();
 176         dentry = lnamei(filename);
 177
 178         error = PTR_ERR(dentry);
 179         if (!IS_ERR(dentry)) {
 180                 struct inode * inode = dentry->d_inode;
 181                 error = do_revalidate(inode);
 182                 if (!error)
 183                         error = cp_old_stat(inode, statbuf);
 184
 185                 dput(dentry);
 186         }
 187         unlock_kernel();
 188         return error;
 189 }
 190
 191 #endif
 192
 193 asmlinkage int sys_newlstat(char * filename, struct stat * statbuf)
 194 {
 195         struct dentry * dentry;
 196         int error;
 197
 198         lock_kernel();
 199         dentry = lnamei(filename);
 200
 201         error = PTR_ERR(dentry);
 202         if (!IS_ERR(dentry)) {
 203                 struct inode * inode = dentry->d_inode;
 204                 error = do_revalidate(inode);
 205                 if (!error)
 206                         error = cp_new_stat(inode,statbuf);
 207
 208                 dput(dentry);
 209         }
 210         unlock_kernel();
 211         return error;
 212 }
 213
 214 #if !defined(__alpha__) && !defined(__sparc__)
 215
 216 /*
 217  * For backward compatibility?  Maybe this should be moved
 218  * into arch/i386 instead?
 219  */
 220 asmlinkage int sys_fstat(unsigned int fd, struct __old_kernel_stat * statbuf)
 221 {
 222         struct file * f;
 223         int err = -EBADF;
 224
 225         lock_kernel();
 226         if (fd < NR_OPEN && (f = current->files->fd[fd]) != NULL) {
 227                 struct dentry * dentry = f->f_dentry;
 228                 struct inode * inode = dentry->d_inode;
 229
 230                 err = do_revalidate(inode);
 231                 if (!err)
 232                         err = cp_old_stat(inode,statbuf);
 233         }
 234         unlock_kernel();
 235         return err;
 236 }
 237
 238 #endif
 239
 240 asmlinkage int sys_newfstat(unsigned int fd, struct stat * statbuf)
 241 {
 242         struct file * f;
 243         int err = -EBADF;
 244
 245         lock_kernel();
 246         if (fd < NR_OPEN && (f = current->files->fd[fd]) != NULL) {
 247                 struct dentry * dentry = f->f_dentry;
 248                 struct inode * inode = dentry->d_inode;
 249
 250                 err = do_revalidate(inode);
 251                 if (!err)
 252                         err = cp_new_stat(inode,statbuf);
 253         }
 254         unlock_kernel();
 255         return err;
 256 }
 257
 258 asmlinkage int sys_readlink(const char * path, char * buf, int bufsiz)
 259 {
 260         struct dentry * dentry;
 261         int error;
 262
 263         if (bufsiz <= 0)
 264                 return -EINVAL;
 265
 266         lock_kernel();
 267         dentry = lnamei(path);
 268
 269         error = PTR_ERR(dentry);
 270         if (!IS_ERR(dentry)) {
 271                 struct inode * inode = dentry->d_inode;
 272
 273                 error = -EINVAL;
 274                 if (inode->i_op && inode->i_op->readlink && !(error = do_revalidate(inode))) {
 275                         UPDATE_ATIME(inode);
 276                         error = inode->i_op->readlink(inode,buf,bufsiz);
 277                 }
 278                 dput(dentry);
 279         }
 280         unlock_kernel();
 281         return error;
 282 }