xfs_file.c 14 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643
  1. /*
  2. * Copyright (c) 2000-2005 Silicon Graphics, Inc.
  3. * All Rights Reserved.
  4. *
  5. * This program is free software; you can redistribute it and/or
  6. * modify it under the terms of the GNU General Public License as
  7. * published by the Free Software Foundation.
  8. *
  9. * This program is distributed in the hope that it would be useful,
  10. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  12. * GNU General Public License for more details.
  13. *
  14. * You should have received a copy of the GNU General Public License
  15. * along with this program; if not, write the Free Software Foundation,
  16. * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  17. */
  18. #include "xfs.h"
  19. #include "xfs_bit.h"
  20. #include "xfs_log.h"
  21. #include "xfs_inum.h"
  22. #include "xfs_sb.h"
  23. #include "xfs_ag.h"
  24. #include "xfs_dir.h"
  25. #include "xfs_dir2.h"
  26. #include "xfs_trans.h"
  27. #include "xfs_dmapi.h"
  28. #include "xfs_mount.h"
  29. #include "xfs_bmap_btree.h"
  30. #include "xfs_alloc_btree.h"
  31. #include "xfs_ialloc_btree.h"
  32. #include "xfs_alloc.h"
  33. #include "xfs_btree.h"
  34. #include "xfs_attr_sf.h"
  35. #include "xfs_dir_sf.h"
  36. #include "xfs_dir2_sf.h"
  37. #include "xfs_dinode.h"
  38. #include "xfs_inode.h"
  39. #include "xfs_error.h"
  40. #include "xfs_rw.h"
  41. #include "xfs_ioctl32.h"
  42. #include <linux/dcache.h>
  43. #include <linux/smp_lock.h>
  44. static struct vm_operations_struct xfs_file_vm_ops;
  45. #ifdef CONFIG_XFS_DMAPI
  46. static struct vm_operations_struct xfs_dmapi_file_vm_ops;
  47. #endif
  48. STATIC inline ssize_t
  49. __xfs_file_read(
  50. struct kiocb *iocb,
  51. char __user *buf,
  52. int ioflags,
  53. size_t count,
  54. loff_t pos)
  55. {
  56. struct iovec iov = {buf, count};
  57. struct file *file = iocb->ki_filp;
  58. vnode_t *vp = vn_from_inode(file->f_dentry->d_inode);
  59. ssize_t rval;
  60. BUG_ON(iocb->ki_pos != pos);
  61. if (unlikely(file->f_flags & O_DIRECT))
  62. ioflags |= IO_ISDIRECT;
  63. VOP_READ(vp, iocb, &iov, 1, &iocb->ki_pos, ioflags, NULL, rval);
  64. return rval;
  65. }
  66. STATIC ssize_t
  67. xfs_file_aio_read(
  68. struct kiocb *iocb,
  69. char __user *buf,
  70. size_t count,
  71. loff_t pos)
  72. {
  73. return __xfs_file_read(iocb, buf, IO_ISAIO, count, pos);
  74. }
  75. STATIC ssize_t
  76. xfs_file_aio_read_invis(
  77. struct kiocb *iocb,
  78. char __user *buf,
  79. size_t count,
  80. loff_t pos)
  81. {
  82. return __xfs_file_read(iocb, buf, IO_ISAIO|IO_INVIS, count, pos);
  83. }
  84. STATIC inline ssize_t
  85. __xfs_file_write(
  86. struct kiocb *iocb,
  87. const char __user *buf,
  88. int ioflags,
  89. size_t count,
  90. loff_t pos)
  91. {
  92. struct iovec iov = {(void __user *)buf, count};
  93. struct file *file = iocb->ki_filp;
  94. struct inode *inode = file->f_mapping->host;
  95. vnode_t *vp = vn_from_inode(inode);
  96. ssize_t rval;
  97. BUG_ON(iocb->ki_pos != pos);
  98. if (unlikely(file->f_flags & O_DIRECT))
  99. ioflags |= IO_ISDIRECT;
  100. VOP_WRITE(vp, iocb, &iov, 1, &iocb->ki_pos, ioflags, NULL, rval);
  101. return rval;
  102. }
  103. STATIC ssize_t
  104. xfs_file_aio_write(
  105. struct kiocb *iocb,
  106. const char __user *buf,
  107. size_t count,
  108. loff_t pos)
  109. {
  110. return __xfs_file_write(iocb, buf, IO_ISAIO, count, pos);
  111. }
  112. STATIC ssize_t
  113. xfs_file_aio_write_invis(
  114. struct kiocb *iocb,
  115. const char __user *buf,
  116. size_t count,
  117. loff_t pos)
  118. {
  119. return __xfs_file_write(iocb, buf, IO_ISAIO|IO_INVIS, count, pos);
  120. }
  121. STATIC inline ssize_t
  122. __xfs_file_readv(
  123. struct file *file,
  124. const struct iovec *iov,
  125. int ioflags,
  126. unsigned long nr_segs,
  127. loff_t *ppos)
  128. {
  129. struct inode *inode = file->f_mapping->host;
  130. vnode_t *vp = vn_from_inode(inode);
  131. struct kiocb kiocb;
  132. ssize_t rval;
  133. init_sync_kiocb(&kiocb, file);
  134. kiocb.ki_pos = *ppos;
  135. if (unlikely(file->f_flags & O_DIRECT))
  136. ioflags |= IO_ISDIRECT;
  137. VOP_READ(vp, &kiocb, iov, nr_segs, &kiocb.ki_pos, ioflags, NULL, rval);
  138. *ppos = kiocb.ki_pos;
  139. return rval;
  140. }
  141. STATIC ssize_t
  142. xfs_file_readv(
  143. struct file *file,
  144. const struct iovec *iov,
  145. unsigned long nr_segs,
  146. loff_t *ppos)
  147. {
  148. return __xfs_file_readv(file, iov, 0, nr_segs, ppos);
  149. }
  150. STATIC ssize_t
  151. xfs_file_readv_invis(
  152. struct file *file,
  153. const struct iovec *iov,
  154. unsigned long nr_segs,
  155. loff_t *ppos)
  156. {
  157. return __xfs_file_readv(file, iov, IO_INVIS, nr_segs, ppos);
  158. }
  159. STATIC inline ssize_t
  160. __xfs_file_writev(
  161. struct file *file,
  162. const struct iovec *iov,
  163. int ioflags,
  164. unsigned long nr_segs,
  165. loff_t *ppos)
  166. {
  167. struct inode *inode = file->f_mapping->host;
  168. vnode_t *vp = vn_from_inode(inode);
  169. struct kiocb kiocb;
  170. ssize_t rval;
  171. init_sync_kiocb(&kiocb, file);
  172. kiocb.ki_pos = *ppos;
  173. if (unlikely(file->f_flags & O_DIRECT))
  174. ioflags |= IO_ISDIRECT;
  175. VOP_WRITE(vp, &kiocb, iov, nr_segs, &kiocb.ki_pos, ioflags, NULL, rval);
  176. *ppos = kiocb.ki_pos;
  177. return rval;
  178. }
  179. STATIC ssize_t
  180. xfs_file_writev(
  181. struct file *file,
  182. const struct iovec *iov,
  183. unsigned long nr_segs,
  184. loff_t *ppos)
  185. {
  186. return __xfs_file_writev(file, iov, 0, nr_segs, ppos);
  187. }
  188. STATIC ssize_t
  189. xfs_file_writev_invis(
  190. struct file *file,
  191. const struct iovec *iov,
  192. unsigned long nr_segs,
  193. loff_t *ppos)
  194. {
  195. return __xfs_file_writev(file, iov, IO_INVIS, nr_segs, ppos);
  196. }
  197. STATIC ssize_t
  198. xfs_file_sendfile(
  199. struct file *filp,
  200. loff_t *pos,
  201. size_t count,
  202. read_actor_t actor,
  203. void *target)
  204. {
  205. vnode_t *vp = vn_from_inode(filp->f_dentry->d_inode);
  206. ssize_t rval;
  207. VOP_SENDFILE(vp, filp, pos, 0, count, actor, target, NULL, rval);
  208. return rval;
  209. }
  210. STATIC ssize_t
  211. xfs_file_sendfile_invis(
  212. struct file *filp,
  213. loff_t *pos,
  214. size_t count,
  215. read_actor_t actor,
  216. void *target)
  217. {
  218. vnode_t *vp = vn_from_inode(filp->f_dentry->d_inode);
  219. ssize_t rval;
  220. VOP_SENDFILE(vp, filp, pos, IO_INVIS, count, actor, target, NULL, rval);
  221. return rval;
  222. }
  223. STATIC ssize_t
  224. xfs_file_splice_read(
  225. struct file *infilp,
  226. struct inode *pipe,
  227. size_t len,
  228. unsigned int flags)
  229. {
  230. vnode_t *vp = vn_from_inode(infilp->f_dentry->d_inode);
  231. ssize_t rval;
  232. VOP_SPLICE_READ(vp, infilp, pipe, len, flags, 0, NULL, rval);
  233. return rval;
  234. }
  235. STATIC ssize_t
  236. xfs_file_splice_read_invis(
  237. struct file *infilp,
  238. struct inode *pipe,
  239. size_t len,
  240. unsigned int flags)
  241. {
  242. vnode_t *vp = vn_from_inode(infilp->f_dentry->d_inode);
  243. ssize_t rval;
  244. VOP_SPLICE_READ(vp, infilp, pipe, len, flags, IO_INVIS, NULL, rval);
  245. return rval;
  246. }
  247. STATIC ssize_t
  248. xfs_file_splice_write(
  249. struct inode *pipe,
  250. struct file *outfilp,
  251. size_t len,
  252. unsigned int flags)
  253. {
  254. vnode_t *vp = vn_from_inode(outfilp->f_dentry->d_inode);
  255. ssize_t rval;
  256. VOP_SPLICE_WRITE(vp, pipe, outfilp, len, flags, 0, NULL, rval);
  257. return rval;
  258. }
  259. STATIC ssize_t
  260. xfs_file_splice_write_invis(
  261. struct inode *pipe,
  262. struct file *outfilp,
  263. size_t len,
  264. unsigned int flags)
  265. {
  266. vnode_t *vp = vn_from_inode(outfilp->f_dentry->d_inode);
  267. ssize_t rval;
  268. VOP_SPLICE_WRITE(vp, pipe, outfilp, len, flags, IO_INVIS, NULL, rval);
  269. return rval;
  270. }
  271. STATIC int
  272. xfs_file_open(
  273. struct inode *inode,
  274. struct file *filp)
  275. {
  276. vnode_t *vp = vn_from_inode(inode);
  277. int error;
  278. if (!(filp->f_flags & O_LARGEFILE) && i_size_read(inode) > MAX_NON_LFS)
  279. return -EFBIG;
  280. VOP_OPEN(vp, NULL, error);
  281. return -error;
  282. }
  283. STATIC int
  284. xfs_file_release(
  285. struct inode *inode,
  286. struct file *filp)
  287. {
  288. vnode_t *vp = vn_from_inode(inode);
  289. int error = 0;
  290. if (vp)
  291. VOP_RELEASE(vp, error);
  292. return -error;
  293. }
  294. STATIC int
  295. xfs_file_fsync(
  296. struct file *filp,
  297. struct dentry *dentry,
  298. int datasync)
  299. {
  300. struct inode *inode = dentry->d_inode;
  301. vnode_t *vp = vn_from_inode(inode);
  302. int error;
  303. int flags = FSYNC_WAIT;
  304. if (datasync)
  305. flags |= FSYNC_DATA;
  306. VOP_FSYNC(vp, flags, NULL, (xfs_off_t)0, (xfs_off_t)-1, error);
  307. return -error;
  308. }
  309. #ifdef CONFIG_XFS_DMAPI
  310. STATIC struct page *
  311. xfs_vm_nopage(
  312. struct vm_area_struct *area,
  313. unsigned long address,
  314. int *type)
  315. {
  316. struct inode *inode = area->vm_file->f_dentry->d_inode;
  317. vnode_t *vp = vn_from_inode(inode);
  318. xfs_mount_t *mp = XFS_VFSTOM(vp->v_vfsp);
  319. int error;
  320. ASSERT_ALWAYS(vp->v_vfsp->vfs_flag & VFS_DMI);
  321. error = XFS_SEND_MMAP(mp, area, 0);
  322. if (error)
  323. return NULL;
  324. return filemap_nopage(area, address, type);
  325. }
  326. #endif /* CONFIG_XFS_DMAPI */
  327. STATIC int
  328. xfs_file_readdir(
  329. struct file *filp,
  330. void *dirent,
  331. filldir_t filldir)
  332. {
  333. int error = 0;
  334. vnode_t *vp = vn_from_inode(filp->f_dentry->d_inode);
  335. uio_t uio;
  336. iovec_t iov;
  337. int eof = 0;
  338. caddr_t read_buf;
  339. int namelen, size = 0;
  340. size_t rlen = PAGE_CACHE_SIZE;
  341. xfs_off_t start_offset, curr_offset;
  342. xfs_dirent_t *dbp = NULL;
  343. /* Try fairly hard to get memory */
  344. do {
  345. if ((read_buf = (caddr_t)kmalloc(rlen, GFP_KERNEL)))
  346. break;
  347. rlen >>= 1;
  348. } while (rlen >= 1024);
  349. if (read_buf == NULL)
  350. return -ENOMEM;
  351. uio.uio_iov = &iov;
  352. uio.uio_segflg = UIO_SYSSPACE;
  353. curr_offset = filp->f_pos;
  354. if (filp->f_pos != 0x7fffffff)
  355. uio.uio_offset = filp->f_pos;
  356. else
  357. uio.uio_offset = 0xffffffff;
  358. while (!eof) {
  359. uio.uio_resid = iov.iov_len = rlen;
  360. iov.iov_base = read_buf;
  361. uio.uio_iovcnt = 1;
  362. start_offset = uio.uio_offset;
  363. VOP_READDIR(vp, &uio, NULL, &eof, error);
  364. if ((uio.uio_offset == start_offset) || error) {
  365. size = 0;
  366. break;
  367. }
  368. size = rlen - uio.uio_resid;
  369. dbp = (xfs_dirent_t *)read_buf;
  370. while (size > 0) {
  371. namelen = strlen(dbp->d_name);
  372. if (filldir(dirent, dbp->d_name, namelen,
  373. (loff_t) curr_offset & 0x7fffffff,
  374. (ino_t) dbp->d_ino,
  375. DT_UNKNOWN)) {
  376. goto done;
  377. }
  378. size -= dbp->d_reclen;
  379. curr_offset = (loff_t)dbp->d_off /* & 0x7fffffff */;
  380. dbp = (xfs_dirent_t *)((char *)dbp + dbp->d_reclen);
  381. }
  382. }
  383. done:
  384. if (!error) {
  385. if (size == 0)
  386. filp->f_pos = uio.uio_offset & 0x7fffffff;
  387. else if (dbp)
  388. filp->f_pos = curr_offset;
  389. }
  390. kfree(read_buf);
  391. return -error;
  392. }
  393. STATIC int
  394. xfs_file_mmap(
  395. struct file *filp,
  396. struct vm_area_struct *vma)
  397. {
  398. struct inode *ip = filp->f_dentry->d_inode;
  399. vnode_t *vp = vn_from_inode(ip);
  400. vattr_t vattr;
  401. int error;
  402. vma->vm_ops = &xfs_file_vm_ops;
  403. #ifdef CONFIG_XFS_DMAPI
  404. if (vp->v_vfsp->vfs_flag & VFS_DMI) {
  405. vma->vm_ops = &xfs_dmapi_file_vm_ops;
  406. }
  407. #endif /* CONFIG_XFS_DMAPI */
  408. vattr.va_mask = XFS_AT_UPDATIME;
  409. VOP_SETATTR(vp, &vattr, XFS_AT_UPDATIME, NULL, error);
  410. if (likely(!error))
  411. __vn_revalidate(vp, &vattr); /* update flags */
  412. return 0;
  413. }
  414. STATIC long
  415. xfs_file_ioctl(
  416. struct file *filp,
  417. unsigned int cmd,
  418. unsigned long arg)
  419. {
  420. int error;
  421. struct inode *inode = filp->f_dentry->d_inode;
  422. vnode_t *vp = vn_from_inode(inode);
  423. VOP_IOCTL(vp, inode, filp, 0, cmd, (void __user *)arg, error);
  424. VMODIFY(vp);
  425. /* NOTE: some of the ioctl's return positive #'s as a
  426. * byte count indicating success, such as
  427. * readlink_by_handle. So we don't "sign flip"
  428. * like most other routines. This means true
  429. * errors need to be returned as a negative value.
  430. */
  431. return error;
  432. }
  433. STATIC long
  434. xfs_file_ioctl_invis(
  435. struct file *filp,
  436. unsigned int cmd,
  437. unsigned long arg)
  438. {
  439. struct inode *inode = filp->f_dentry->d_inode;
  440. vnode_t *vp = vn_from_inode(inode);
  441. int error;
  442. VOP_IOCTL(vp, inode, filp, IO_INVIS, cmd, (void __user *)arg, error);
  443. VMODIFY(vp);
  444. /* NOTE: some of the ioctl's return positive #'s as a
  445. * byte count indicating success, such as
  446. * readlink_by_handle. So we don't "sign flip"
  447. * like most other routines. This means true
  448. * errors need to be returned as a negative value.
  449. */
  450. return error;
  451. }
  452. #ifdef CONFIG_XFS_DMAPI
  453. #ifdef HAVE_VMOP_MPROTECT
  454. STATIC int
  455. xfs_vm_mprotect(
  456. struct vm_area_struct *vma,
  457. unsigned int newflags)
  458. {
  459. vnode_t *vp = vn_from_inode(vma->vm_file->f_dentry->d_inode);
  460. int error = 0;
  461. if (vp->v_vfsp->vfs_flag & VFS_DMI) {
  462. if ((vma->vm_flags & VM_MAYSHARE) &&
  463. (newflags & VM_WRITE) && !(vma->vm_flags & VM_WRITE)) {
  464. xfs_mount_t *mp = XFS_VFSTOM(vp->v_vfsp);
  465. error = XFS_SEND_MMAP(mp, vma, VM_WRITE);
  466. }
  467. }
  468. return error;
  469. }
  470. #endif /* HAVE_VMOP_MPROTECT */
  471. #endif /* CONFIG_XFS_DMAPI */
  472. #ifdef HAVE_FOP_OPEN_EXEC
  473. /* If the user is attempting to execute a file that is offline then
  474. * we have to trigger a DMAPI READ event before the file is marked as busy
  475. * otherwise the invisible I/O will not be able to write to the file to bring
  476. * it back online.
  477. */
  478. STATIC int
  479. xfs_file_open_exec(
  480. struct inode *inode)
  481. {
  482. vnode_t *vp = vn_from_inode(inode);
  483. xfs_mount_t *mp = XFS_VFSTOM(vp->v_vfsp);
  484. int error = 0;
  485. xfs_inode_t *ip;
  486. if (vp->v_vfsp->vfs_flag & VFS_DMI) {
  487. ip = xfs_vtoi(vp);
  488. if (!ip) {
  489. error = -EINVAL;
  490. goto open_exec_out;
  491. }
  492. if (DM_EVENT_ENABLED(vp->v_vfsp, ip, DM_EVENT_READ)) {
  493. error = -XFS_SEND_DATA(mp, DM_EVENT_READ, vp,
  494. 0, 0, 0, NULL);
  495. }
  496. }
  497. open_exec_out:
  498. return error;
  499. }
  500. #endif /* HAVE_FOP_OPEN_EXEC */
  501. const struct file_operations xfs_file_operations = {
  502. .llseek = generic_file_llseek,
  503. .read = do_sync_read,
  504. .write = do_sync_write,
  505. .readv = xfs_file_readv,
  506. .writev = xfs_file_writev,
  507. .aio_read = xfs_file_aio_read,
  508. .aio_write = xfs_file_aio_write,
  509. .sendfile = xfs_file_sendfile,
  510. .splice_read = xfs_file_splice_read,
  511. .splice_write = xfs_file_splice_write,
  512. .unlocked_ioctl = xfs_file_ioctl,
  513. #ifdef CONFIG_COMPAT
  514. .compat_ioctl = xfs_file_compat_ioctl,
  515. #endif
  516. .mmap = xfs_file_mmap,
  517. .open = xfs_file_open,
  518. .release = xfs_file_release,
  519. .fsync = xfs_file_fsync,
  520. #ifdef HAVE_FOP_OPEN_EXEC
  521. .open_exec = xfs_file_open_exec,
  522. #endif
  523. };
  524. const struct file_operations xfs_invis_file_operations = {
  525. .llseek = generic_file_llseek,
  526. .read = do_sync_read,
  527. .write = do_sync_write,
  528. .readv = xfs_file_readv_invis,
  529. .writev = xfs_file_writev_invis,
  530. .aio_read = xfs_file_aio_read_invis,
  531. .aio_write = xfs_file_aio_write_invis,
  532. .sendfile = xfs_file_sendfile_invis,
  533. .splice_read = xfs_file_splice_read_invis,
  534. .splice_write = xfs_file_splice_write_invis,
  535. .unlocked_ioctl = xfs_file_ioctl_invis,
  536. #ifdef CONFIG_COMPAT
  537. .compat_ioctl = xfs_file_compat_invis_ioctl,
  538. #endif
  539. .mmap = xfs_file_mmap,
  540. .open = xfs_file_open,
  541. .release = xfs_file_release,
  542. .fsync = xfs_file_fsync,
  543. };
  544. const struct file_operations xfs_dir_file_operations = {
  545. .read = generic_read_dir,
  546. .readdir = xfs_file_readdir,
  547. .unlocked_ioctl = xfs_file_ioctl,
  548. #ifdef CONFIG_COMPAT
  549. .compat_ioctl = xfs_file_compat_ioctl,
  550. #endif
  551. .fsync = xfs_file_fsync,
  552. };
  553. static struct vm_operations_struct xfs_file_vm_ops = {
  554. .nopage = filemap_nopage,
  555. .populate = filemap_populate,
  556. };
  557. #ifdef CONFIG_XFS_DMAPI
  558. static struct vm_operations_struct xfs_dmapi_file_vm_ops = {
  559. .nopage = xfs_vm_nopage,
  560. .populate = filemap_populate,
  561. #ifdef HAVE_VMOP_MPROTECT
  562. .mprotect = xfs_vm_mprotect,
  563. #endif
  564. };
  565. #endif /* CONFIG_XFS_DMAPI */