stat.c 11 KB

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