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