2 * Copyright (c) 2000-2005 Silicon Graphics, Inc.
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.
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.
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
25 #include "xfs_trans.h"
26 #include "xfs_dmapi.h"
27 #include "xfs_mount.h"
28 #include "xfs_bmap_btree.h"
29 #include "xfs_alloc_btree.h"
30 #include "xfs_ialloc_btree.h"
31 #include "xfs_alloc.h"
32 #include "xfs_btree.h"
33 #include "xfs_attr_sf.h"
34 #include "xfs_dir2_sf.h"
35 #include "xfs_dinode.h"
36 #include "xfs_inode.h"
37 #include "xfs_error.h"
39 #include "xfs_ioctl32.h"
41 #include <linux/dcache.h>
42 #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
;
57 struct iovec iov
= {buf
, count
};
58 struct file
*file
= iocb
->ki_filp
;
59 bhv_vnode_t
*vp
= vn_from_inode(file
->f_dentry
->d_inode
);
61 BUG_ON(iocb
->ki_pos
!= pos
);
62 if (unlikely(file
->f_flags
& O_DIRECT
))
63 ioflags
|= IO_ISDIRECT
;
64 return bhv_vop_read(vp
, iocb
, &iov
, 1, &iocb
->ki_pos
, ioflags
, NULL
);
74 return __xfs_file_read(iocb
, buf
, IO_ISAIO
, count
, pos
);
78 xfs_file_aio_read_invis(
84 return __xfs_file_read(iocb
, buf
, IO_ISAIO
|IO_INVIS
, count
, pos
);
90 const char __user
*buf
,
95 struct iovec iov
= {(void __user
*)buf
, count
};
96 struct file
*file
= iocb
->ki_filp
;
97 struct inode
*inode
= file
->f_mapping
->host
;
98 bhv_vnode_t
*vp
= vn_from_inode(inode
);
100 BUG_ON(iocb
->ki_pos
!= pos
);
101 if (unlikely(file
->f_flags
& O_DIRECT
))
102 ioflags
|= IO_ISDIRECT
;
103 return bhv_vop_write(vp
, iocb
, &iov
, 1, &iocb
->ki_pos
, ioflags
, NULL
);
109 const char __user
*buf
,
113 return __xfs_file_write(iocb
, buf
, IO_ISAIO
, count
, pos
);
117 xfs_file_aio_write_invis(
119 const char __user
*buf
,
123 return __xfs_file_write(iocb
, buf
, IO_ISAIO
|IO_INVIS
, count
, pos
);
126 STATIC
inline ssize_t
129 const struct iovec
*iov
,
131 unsigned long nr_segs
,
134 struct inode
*inode
= file
->f_mapping
->host
;
135 bhv_vnode_t
*vp
= vn_from_inode(inode
);
139 init_sync_kiocb(&kiocb
, file
);
140 kiocb
.ki_pos
= *ppos
;
142 if (unlikely(file
->f_flags
& O_DIRECT
))
143 ioflags
|= IO_ISDIRECT
;
144 rval
= bhv_vop_read(vp
, &kiocb
, iov
, nr_segs
,
145 &kiocb
.ki_pos
, ioflags
, NULL
);
147 *ppos
= kiocb
.ki_pos
;
154 const struct iovec
*iov
,
155 unsigned long nr_segs
,
158 return __xfs_file_readv(file
, iov
, 0, nr_segs
, ppos
);
162 xfs_file_readv_invis(
164 const struct iovec
*iov
,
165 unsigned long nr_segs
,
168 return __xfs_file_readv(file
, iov
, IO_INVIS
, nr_segs
, ppos
);
171 STATIC
inline ssize_t
174 const struct iovec
*iov
,
176 unsigned long nr_segs
,
179 struct inode
*inode
= file
->f_mapping
->host
;
180 bhv_vnode_t
*vp
= vn_from_inode(inode
);
184 init_sync_kiocb(&kiocb
, file
);
185 kiocb
.ki_pos
= *ppos
;
186 if (unlikely(file
->f_flags
& O_DIRECT
))
187 ioflags
|= IO_ISDIRECT
;
189 rval
= bhv_vop_write(vp
, &kiocb
, iov
, nr_segs
,
190 &kiocb
.ki_pos
, ioflags
, NULL
);
192 *ppos
= kiocb
.ki_pos
;
199 const struct iovec
*iov
,
200 unsigned long nr_segs
,
203 return __xfs_file_writev(file
, iov
, 0, nr_segs
, ppos
);
207 xfs_file_writev_invis(
209 const struct iovec
*iov
,
210 unsigned long nr_segs
,
213 return __xfs_file_writev(file
, iov
, IO_INVIS
, nr_segs
, ppos
);
224 return bhv_vop_sendfile(vn_from_inode(filp
->f_dentry
->d_inode
),
225 filp
, pos
, 0, count
, actor
, target
, NULL
);
229 xfs_file_sendfile_invis(
236 return bhv_vop_sendfile(vn_from_inode(filp
->f_dentry
->d_inode
),
237 filp
, pos
, IO_INVIS
, count
, actor
, target
, NULL
);
241 xfs_file_splice_read(
244 struct pipe_inode_info
*pipe
,
248 return bhv_vop_splice_read(vn_from_inode(infilp
->f_dentry
->d_inode
),
249 infilp
, ppos
, pipe
, len
, flags
, 0, NULL
);
253 xfs_file_splice_read_invis(
256 struct pipe_inode_info
*pipe
,
260 return bhv_vop_splice_read(vn_from_inode(infilp
->f_dentry
->d_inode
),
261 infilp
, ppos
, pipe
, len
, flags
, IO_INVIS
,
266 xfs_file_splice_write(
267 struct pipe_inode_info
*pipe
,
268 struct file
*outfilp
,
273 return bhv_vop_splice_write(vn_from_inode(outfilp
->f_dentry
->d_inode
),
274 pipe
, outfilp
, ppos
, len
, flags
, 0, NULL
);
278 xfs_file_splice_write_invis(
279 struct pipe_inode_info
*pipe
,
280 struct file
*outfilp
,
285 return bhv_vop_splice_write(vn_from_inode(outfilp
->f_dentry
->d_inode
),
286 pipe
, outfilp
, ppos
, len
, flags
, IO_INVIS
,
295 if (!(filp
->f_flags
& O_LARGEFILE
) && i_size_read(inode
) > MAX_NON_LFS
)
297 return -bhv_vop_open(vn_from_inode(inode
), NULL
);
304 return -bhv_vop_close(vn_from_inode(filp
->f_dentry
->d_inode
), 0,
305 file_count(filp
) > 1 ? L_FALSE
: L_TRUE
, NULL
);
313 bhv_vnode_t
*vp
= vn_from_inode(inode
);
316 return -bhv_vop_release(vp
);
323 struct dentry
*dentry
,
326 bhv_vnode_t
*vp
= vn_from_inode(dentry
->d_inode
);
327 int flags
= FSYNC_WAIT
;
333 return -bhv_vop_fsync(vp
, flags
, NULL
, (xfs_off_t
)0, (xfs_off_t
)-1);
336 #ifdef CONFIG_XFS_DMAPI
339 struct vm_area_struct
*area
,
340 unsigned long address
,
343 struct inode
*inode
= area
->vm_file
->f_dentry
->d_inode
;
344 bhv_vnode_t
*vp
= vn_from_inode(inode
);
346 ASSERT_ALWAYS(vp
->v_vfsp
->vfs_flag
& VFS_DMI
);
347 if (XFS_SEND_MMAP(XFS_VFSTOM(vp
->v_vfsp
), area
, 0))
349 return filemap_nopage(area
, address
, type
);
351 #endif /* CONFIG_XFS_DMAPI */
360 bhv_vnode_t
*vp
= vn_from_inode(filp
->f_dentry
->d_inode
);
365 int namelen
, size
= 0;
366 size_t rlen
= PAGE_CACHE_SIZE
;
367 xfs_off_t start_offset
, curr_offset
;
368 xfs_dirent_t
*dbp
= NULL
;
370 /* Try fairly hard to get memory */
372 if ((read_buf
= (caddr_t
)kmalloc(rlen
, GFP_KERNEL
)))
375 } while (rlen
>= 1024);
377 if (read_buf
== NULL
)
381 uio
.uio_segflg
= UIO_SYSSPACE
;
382 curr_offset
= filp
->f_pos
;
383 if (filp
->f_pos
!= 0x7fffffff)
384 uio
.uio_offset
= filp
->f_pos
;
386 uio
.uio_offset
= 0xffffffff;
389 uio
.uio_resid
= iov
.iov_len
= rlen
;
390 iov
.iov_base
= read_buf
;
393 start_offset
= uio
.uio_offset
;
395 error
= bhv_vop_readdir(vp
, &uio
, NULL
, &eof
);
396 if ((uio
.uio_offset
== start_offset
) || error
) {
401 size
= rlen
- uio
.uio_resid
;
402 dbp
= (xfs_dirent_t
*)read_buf
;
404 namelen
= strlen(dbp
->d_name
);
406 if (filldir(dirent
, dbp
->d_name
, namelen
,
407 (loff_t
) curr_offset
& 0x7fffffff,
412 size
-= dbp
->d_reclen
;
413 curr_offset
= (loff_t
)dbp
->d_off
/* & 0x7fffffff */;
414 dbp
= (xfs_dirent_t
*)((char *)dbp
+ dbp
->d_reclen
);
420 filp
->f_pos
= uio
.uio_offset
& 0x7fffffff;
422 filp
->f_pos
= curr_offset
;
432 struct vm_area_struct
*vma
)
434 vma
->vm_ops
= &xfs_file_vm_ops
;
436 #ifdef CONFIG_XFS_DMAPI
437 if (vn_from_inode(filp
->f_dentry
->d_inode
)->v_vfsp
->vfs_flag
& VFS_DMI
)
438 vma
->vm_ops
= &xfs_dmapi_file_vm_ops
;
439 #endif /* CONFIG_XFS_DMAPI */
452 struct inode
*inode
= filp
->f_dentry
->d_inode
;
453 bhv_vnode_t
*vp
= vn_from_inode(inode
);
455 error
= bhv_vop_ioctl(vp
, inode
, filp
, 0, cmd
, (void __user
*)p
);
458 /* NOTE: some of the ioctl's return positive #'s as a
459 * byte count indicating success, such as
460 * readlink_by_handle. So we don't "sign flip"
461 * like most other routines. This means true
462 * errors need to be returned as a negative value.
468 xfs_file_ioctl_invis(
474 struct inode
*inode
= filp
->f_dentry
->d_inode
;
475 bhv_vnode_t
*vp
= vn_from_inode(inode
);
477 error
= bhv_vop_ioctl(vp
, inode
, filp
, IO_INVIS
, cmd
, (void __user
*)p
);
480 /* NOTE: some of the ioctl's return positive #'s as a
481 * byte count indicating success, such as
482 * readlink_by_handle. So we don't "sign flip"
483 * like most other routines. This means true
484 * errors need to be returned as a negative value.
489 #ifdef CONFIG_XFS_DMAPI
490 #ifdef HAVE_VMOP_MPROTECT
493 struct vm_area_struct
*vma
,
494 unsigned int newflags
)
496 bhv_vnode_t
*vp
= vn_from_inode(vma
->vm_file
->f_dentry
->d_inode
);
499 if (vp
->v_vfsp
->vfs_flag
& VFS_DMI
) {
500 if ((vma
->vm_flags
& VM_MAYSHARE
) &&
501 (newflags
& VM_WRITE
) && !(vma
->vm_flags
& VM_WRITE
)) {
502 xfs_mount_t
*mp
= XFS_VFSTOM(vp
->v_vfsp
);
504 error
= XFS_SEND_MMAP(mp
, vma
, VM_WRITE
);
509 #endif /* HAVE_VMOP_MPROTECT */
510 #endif /* CONFIG_XFS_DMAPI */
512 #ifdef HAVE_FOP_OPEN_EXEC
513 /* If the user is attempting to execute a file that is offline then
514 * we have to trigger a DMAPI READ event before the file is marked as busy
515 * otherwise the invisible I/O will not be able to write to the file to bring
522 bhv_vnode_t
*vp
= vn_from_inode(inode
);
524 if (unlikely(vp
->v_vfsp
->vfs_flag
& VFS_DMI
)) {
525 xfs_mount_t
*mp
= XFS_VFSTOM(vp
->v_vfsp
);
526 xfs_inode_t
*ip
= xfs_vtoi(vp
);
530 if (DM_EVENT_ENABLED(vp
->v_vfsp
, ip
, DM_EVENT_READ
))
531 return -XFS_SEND_DATA(mp
, DM_EVENT_READ
, vp
,
536 #endif /* HAVE_FOP_OPEN_EXEC */
538 const struct file_operations xfs_file_operations
= {
539 .llseek
= generic_file_llseek
,
540 .read
= do_sync_read
,
541 .write
= do_sync_write
,
542 .readv
= xfs_file_readv
,
543 .writev
= xfs_file_writev
,
544 .aio_read
= xfs_file_aio_read
,
545 .aio_write
= xfs_file_aio_write
,
546 .sendfile
= xfs_file_sendfile
,
547 .splice_read
= xfs_file_splice_read
,
548 .splice_write
= xfs_file_splice_write
,
549 .unlocked_ioctl
= xfs_file_ioctl
,
551 .compat_ioctl
= xfs_file_compat_ioctl
,
553 .mmap
= xfs_file_mmap
,
554 .open
= xfs_file_open
,
555 .flush
= xfs_file_close
,
556 .release
= xfs_file_release
,
557 .fsync
= xfs_file_fsync
,
558 #ifdef HAVE_FOP_OPEN_EXEC
559 .open_exec
= xfs_file_open_exec
,
563 const struct file_operations xfs_invis_file_operations
= {
564 .llseek
= generic_file_llseek
,
565 .read
= do_sync_read
,
566 .write
= do_sync_write
,
567 .readv
= xfs_file_readv_invis
,
568 .writev
= xfs_file_writev_invis
,
569 .aio_read
= xfs_file_aio_read_invis
,
570 .aio_write
= xfs_file_aio_write_invis
,
571 .sendfile
= xfs_file_sendfile_invis
,
572 .splice_read
= xfs_file_splice_read_invis
,
573 .splice_write
= xfs_file_splice_write_invis
,
574 .unlocked_ioctl
= xfs_file_ioctl_invis
,
576 .compat_ioctl
= xfs_file_compat_invis_ioctl
,
578 .mmap
= xfs_file_mmap
,
579 .open
= xfs_file_open
,
580 .flush
= xfs_file_close
,
581 .release
= xfs_file_release
,
582 .fsync
= xfs_file_fsync
,
586 const struct file_operations xfs_dir_file_operations
= {
587 .read
= generic_read_dir
,
588 .readdir
= xfs_file_readdir
,
589 .unlocked_ioctl
= xfs_file_ioctl
,
591 .compat_ioctl
= xfs_file_compat_ioctl
,
593 .fsync
= xfs_file_fsync
,
596 static struct vm_operations_struct xfs_file_vm_ops
= {
597 .nopage
= filemap_nopage
,
598 .populate
= filemap_populate
,
601 #ifdef CONFIG_XFS_DMAPI
602 static struct vm_operations_struct xfs_dmapi_file_vm_ops
= {
603 .nopage
= xfs_vm_nopage
,
604 .populate
= filemap_populate
,
605 #ifdef HAVE_VMOP_MPROTECT
606 .mprotect
= xfs_vm_mprotect
,
609 #endif /* CONFIG_XFS_DMAPI */