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
  14 #include <asm/uaccess.h>
  15
  16 /*
  17  * Revalidate the inode. This is required for proper NFS attribute caching.
  18  */
  19 static __inline__ int
  20 do_revalidate(struct dentry *dentry)
  21 {
  22         struct inode * inode = dentry->d_inode;
  23         if (inode->i_op && inode->i_op->revalidate)
  24                 return inode->i_op->revalidate(dentry);
  25         return 0;
  26 }
  27
  28
  29 #if !defined(__alpha__) && !defined(__sparc__) && !defined(__ia64__) && !defined(CONFIG_ARCH_S390) && !defined(__hppa__) && !defined(__x86_64__)
  30
  31 /*
  32  * For backward compatibility?  Maybe this should be moved
  33  * into arch/i386 instead?
  34  */
  35 static int cp_old_stat(struct inode * inode, struct __old_kernel_stat * statbuf)
  36 {
  37         static int warncount = 5;
  38         struct __old_kernel_stat tmp;
  39
  40         if (warncount > 0) {
  41                 warncount--;
  42                 printk(KERN_WARNING "VFS: Warning: %s using old stat() call. Recompile your binary.\n",
  43                         current->comm);
  44         } else if (warncount < 0) {
  45                 /* it's laughable, but... */
  46                 warncount = 0;
  47         }
  48
  49         tmp.st_dev = kdev_t_to_nr(inode->i_dev);
  50         tmp.st_ino = inode->i_ino;
  51         tmp.st_mode = inode->i_mode;
  52         tmp.st_nlink = inode->i_nlink;
  53         SET_OLDSTAT_UID(tmp, inode->i_uid);
  54         SET_OLDSTAT_GID(tmp, inode->i_gid);
  55         tmp.st_rdev = kdev_t_to_nr(inode->i_rdev);
  56 #if BITS_PER_LONG == 32
  57         if (inode->i_size > MAX_NON_LFS)
  58                 return -EOVERFLOW;
  59 #endif
  60         tmp.st_size = inode->i_size;
  61         tmp.st_atime = inode->i_atime;
  62         tmp.st_mtime = inode->i_mtime;
  63         tmp.st_ctime = inode->i_ctime;
  64         return copy_to_user(statbuf,&tmp,sizeof(tmp)) ? -EFAULT : 0;
  65 }
  66
  67 #endif
  68
  69 static int cp_new_stat(struct inode * inode, struct stat * statbuf)
  70 {
  71         struct stat tmp;
  72         unsigned int blocks, indirect;
  73
  74         memset(&tmp, 0, sizeof(tmp));
  75         tmp.st_dev = kdev_t_to_nr(inode->i_dev);
  76         tmp.st_ino = inode->i_ino;
  77         tmp.st_mode = inode->i_mode;
  78         tmp.st_nlink = inode->i_nlink;
  79         SET_STAT_UID(tmp, inode->i_uid);
  80         SET_STAT_GID(tmp, inode->i_gid);
  81         tmp.st_rdev = kdev_t_to_nr(inode->i_rdev);
  82 #if BITS_PER_LONG == 32
  83         if (inode->i_size > MAX_NON_LFS)
  84                 return -EOVERFLOW;
  85 #endif
  86         tmp.st_size = inode->i_size;
  87         tmp.st_atime = inode->i_atime;
  88         tmp.st_mtime = inode->i_mtime;
  89         tmp.st_ctime = inode->i_ctime;
  90 /*
  91  * st_blocks and st_blksize are approximated with a simple algorithm if
  92  * they aren't supported directly by the filesystem. The minix and msdos
  93  * filesystems don't keep track of blocks, so they would either have to
  94  * be counted explicitly (by delving into the file itself), or by using
  95  * this simple algorithm to get a reasonable (although not 100% accurate)
  96  * value.
  97  */
  98
  99 /*
 100  * Use minix fs values for the number of direct and indirect blocks.  The
 101  * count is now exact for the minix fs except that it counts zero blocks.
 102  * Everything is in units of BLOCK_SIZE until the assignment to
 103  * tmp.st_blksize.
 104  */
 105 #define D_B   7
 106 #define I_B   (BLOCK_SIZE / sizeof(unsigned short))
 107
 108         if (!inode->i_blksize) {
 109                 blocks = (tmp.st_size + BLOCK_SIZE - 1) / BLOCK_SIZE;
 110                 if (blocks > D_B) {
 111                         indirect = (blocks - D_B + I_B - 1) / I_B;
 112                         blocks += indirect;
 113                         if (indirect > 1) {
 114                                 indirect = (indirect - 1 + I_B - 1) / I_B;
 115                                 blocks += indirect;
 116                                 if (indirect > 1)
 117                                         blocks++;
 118                         }
 119                 }
 120                 tmp.st_blocks = (BLOCK_SIZE / 512) * blocks;
 121                 tmp.st_blksize = BLOCK_SIZE;
 122         } else {
 123                 tmp.st_blocks = inode->i_blocks;
 124                 tmp.st_blksize = inode->i_blksize;
 125         }
 126         return copy_to_user(statbuf,&tmp,sizeof(tmp)) ? -EFAULT : 0;
 127 }
 128
 129
 130 #if !defined(__alpha__) && !defined(__sparc__) && !defined(__ia64__) && !defined(CONFIG_ARCH_S390) && !defined(__hppa__) && !defined(__x86_64__)
 131 /*
 132  * For backward compatibility?  Maybe this should be moved
 133  * into arch/i386 instead?
 134  */
 135 asmlinkage long sys_stat(char * filename, struct __old_kernel_stat * statbuf)
 136 {
 137         struct nameidata nd;
 138         int error;
 139
 140         error = user_path_walk(filename, &nd);
 141         if (!error) {
 142                 error = do_revalidate(nd.dentry);
 143                 if (!error)
 144                         error = cp_old_stat(nd.dentry->d_inode, statbuf);
 145                 path_release(&nd);
 146         }
 147         return error;
 148 }
 149 #endif
 150
 151 asmlinkage long sys_newstat(char * filename, struct stat * statbuf)
 152 {
 153         struct nameidata nd;
 154         int error;
 155
 156         error = user_path_walk(filename, &nd);
 157         if (!error) {
 158                 error = do_revalidate(nd.dentry);
 159                 if (!error)
 160                         error = cp_new_stat(nd.dentry->d_inode, statbuf);
 161                 path_release(&nd);
 162         }
 163         return error;
 164 }
 165
 166 #if !defined(__alpha__) && !defined(__sparc__) && !defined(__ia64__) && !defined(CONFIG_ARCH_S390) && !defined(__hppa__) && !defined(__x86_64__)
 167
 168 /*
 169  * For backward compatibility?  Maybe this should be moved
 170  * into arch/i386 instead?
 171  */
 172 asmlinkage long sys_lstat(char * filename, struct __old_kernel_stat * statbuf)
 173 {
 174         struct nameidata nd;
 175         int error;
 176
 177         error = user_path_walk_link(filename, &nd);
 178         if (!error) {
 179                 error = do_revalidate(nd.dentry);
 180                 if (!error)
 181                         error = cp_old_stat(nd.dentry->d_inode, statbuf);
 182                 path_release(&nd);
 183         }
 184         return error;
 185 }
 186
 187 #endif
 188
 189 asmlinkage long sys_newlstat(char * filename, struct stat * statbuf)
 190 {
 191         struct nameidata nd;
 192         int error;
 193
 194         error = user_path_walk_link(filename, &nd);
 195         if (!error) {
 196                 error = do_revalidate(nd.dentry);
 197                 if (!error)
 198                         error = cp_new_stat(nd.dentry->d_inode, statbuf);
 199                 path_release(&nd);
 200         }
 201         return error;
 202 }
 203
 204 #if !defined(__alpha__) && !defined(__sparc__) && !defined(__ia64__) && !defined(CONFIG_ARCH_S390) && !defined(__hppa__) && !defined(__x86_64__)
 205
 206 /*
 207  * For backward compatibility?  Maybe this should be moved
 208  * into arch/i386 instead?
 209  */
 210 asmlinkage long sys_fstat(unsigned int fd, struct __old_kernel_stat * statbuf)
 211 {
 212         struct file * f;
 213         int err = -EBADF;
 214
 215         f = fget(fd);
 216         if (f) {
 217                 struct dentry * dentry = f->f_dentry;
 218
 219                 err = do_revalidate(dentry);
 220                 if (!err)
 221                         err = cp_old_stat(dentry->d_inode, statbuf);
 222                 fput(f);
 223         }
 224         return err;
 225 }
 226
 227 #endif
 228
 229 asmlinkage long sys_newfstat(unsigned int fd, struct stat * statbuf)
 230 {
 231         struct file * f;
 232         int err = -EBADF;
 233
 234         f = fget(fd);
 235         if (f) {
 236                 struct dentry * dentry = f->f_dentry;
 237
 238                 err = do_revalidate(dentry);
 239                 if (!err)
 240                         err = cp_new_stat(dentry->d_inode, statbuf);
 241                 fput(f);
 242         }
 243         return err;
 244 }
 245
 246 asmlinkage long sys_readlink(const char * path, char * buf, int bufsiz)
 247 {
 248         struct nameidata nd;
 249         int error;
 250
 251         if (bufsiz <= 0)
 252                 return -EINVAL;
 253
 254         error = user_path_walk_link(path, &nd);
 255         if (!error) {
 256                 struct inode * inode = nd.dentry->d_inode;
 257
 258                 error = -EINVAL;
 259                 if (inode->i_op && inode->i_op->readlink &&
 260                     !(error = do_revalidate(nd.dentry))) {
 261                         UPDATE_ATIME(inode);
 262                         error = inode->i_op->readlink(nd.dentry, buf, bufsiz);
 263                 }
 264                 path_release(&nd);
 265         }
 266         return error;
 267 }
 268
 269
 270 /* ---------- LFS-64 ----------- */
 271 #if !defined(__alpha__) && !defined(__ia64__) && !defined(__mips64) && !defined(__x86_64__) && !defined(CONFIG_ARCH_S390X)
 272
 273 static long cp_new_stat64(struct inode * inode, struct stat64 * statbuf)
 274 {
 275         struct stat64 tmp;
 276         unsigned int blocks, indirect;
 277
 278         memset(&tmp, 0, sizeof(tmp));
 279         tmp.st_dev = kdev_t_to_nr(inode->i_dev);
 280         tmp.st_ino = inode->i_ino;
 281 #ifdef STAT64_HAS_BROKEN_ST_INO
 282         tmp.__st_ino = inode->i_ino;
 283 #endif
 284         tmp.st_mode = inode->i_mode;
 285         tmp.st_nlink = inode->i_nlink;
 286         tmp.st_uid = inode->i_uid;
 287         tmp.st_gid = inode->i_gid;
 288         tmp.st_rdev = kdev_t_to_nr(inode->i_rdev);
 289         tmp.st_atime = inode->i_atime;
 290         tmp.st_mtime = inode->i_mtime;
 291         tmp.st_ctime = inode->i_ctime;
 292         tmp.st_size = inode->i_size;
 293 /*
 294  * st_blocks and st_blksize are approximated with a simple algorithm if
 295  * they aren't supported directly by the filesystem. The minix and msdos
 296  * filesystems don't keep track of blocks, so they would either have to
 297  * be counted explicitly (by delving into the file itself), or by using
 298  * this simple algorithm to get a reasonable (although not 100% accurate)
 299  * value.
 300  */
 301
 302 /*
 303  * Use minix fs values for the number of direct and indirect blocks.  The
 304  * count is now exact for the minix fs except that it counts zero blocks.
 305  * Everything is in units of BLOCK_SIZE until the assignment to
 306  * tmp.st_blksize.
 307  */
 308 #define D_B   7
 309 #define I_B   (BLOCK_SIZE / sizeof(unsigned short))
 310
 311         if (!inode->i_blksize) {
 312                 blocks = (tmp.st_size + BLOCK_SIZE - 1) >> BLOCK_SIZE_BITS;
 313                 if (blocks > D_B) {
 314                         indirect = (blocks - D_B + I_B - 1) / I_B;
 315                         blocks += indirect;
 316                         if (indirect > 1) {
 317                                 indirect = (indirect - 1 + I_B - 1) / I_B;
 318                                 blocks += indirect;
 319                                 if (indirect > 1)
 320                                         blocks++;
 321                         }
 322                 }
 323                 tmp.st_blocks = (BLOCK_SIZE / 512) * blocks;
 324                 tmp.st_blksize = BLOCK_SIZE;
 325         } else {
 326                 tmp.st_blocks = inode->i_blocks;
 327                 tmp.st_blksize = inode->i_blksize;
 328         }
 329         return copy_to_user(statbuf,&tmp,sizeof(tmp)) ? -EFAULT : 0;
 330 }
 331
 332 asmlinkage long sys_stat64(char * filename, struct stat64 * statbuf, long flags)
 333 {
 334         struct nameidata nd;
 335         int error;
 336
 337         error = user_path_walk(filename, &nd);
 338         if (!error) {
 339                 error = do_revalidate(nd.dentry);
 340                 if (!error)
 341                         error = cp_new_stat64(nd.dentry->d_inode, statbuf);
 342                 path_release(&nd);
 343         }
 344         return error;
 345 }
 346
 347 asmlinkage long sys_lstat64(char * filename, struct stat64 * statbuf, long flags)
 348 {
 349         struct nameidata nd;
 350         int error;
 351
 352         error = user_path_walk_link(filename, &nd);
 353         if (!error) {
 354                 error = do_revalidate(nd.dentry);
 355                 if (!error)
 356                         error = cp_new_stat64(nd.dentry->d_inode, statbuf);
 357                 path_release(&nd);
 358         }
 359         return error;
 360 }
 361
 362 asmlinkage long sys_fstat64(unsigned long fd, struct stat64 * statbuf, long flags)
 363 {
 364         struct file * f;
 365         int err = -EBADF;
 366
 367         f = fget(fd);
 368         if (f) {
 369                 struct dentry * dentry = f->f_dentry;
 370
 371                 err = do_revalidate(dentry);
 372                 if (!err)
 373                         err = cp_new_stat64(dentry->d_inode, statbuf);
 374                 fput(f);
 375         }
 376         return err;
 377 }
 378
 379 #endif /* LFS-64 */