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