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