2 * (C) 2001 Clemson University and The University of Chicago
4 * Changes by Acxiom Corporation to add protocol version to kernel
5 * communication, Copyright Acxiom Corporation, 2005.
7 * See COPYING in top-level directory.
11 #include "orangefs-kernel.h"
12 #include "orangefs-dev-proto.h"
13 #include "orangefs-bufmap.h"
14 #include "orangefs-debugfs.h"
16 #include <linux/debugfs.h>
17 #include <linux/slab.h>
19 /* this file implements the /dev/pvfs2-req device node */
21 uint32_t orangefs_userspace_version
;
23 static int open_access_count
;
25 static DEFINE_MUTEX(devreq_mutex
);
27 #define DUMP_DEVICE_ERROR() \
29 gossip_err("*****************************************************\n");\
30 gossip_err("ORANGEFS Device Error: You cannot open the device file "); \
31 gossip_err("\n/dev/%s more than once. Please make sure that\nthere " \
32 "are no ", ORANGEFS_REQDEVICE_NAME); \
33 gossip_err("instances of a program using this device\ncurrently " \
34 "running. (You must verify this!)\n"); \
35 gossip_err("For example, you can use the lsof program as follows:\n");\
36 gossip_err("'lsof | grep %s' (run this as root)\n", \
37 ORANGEFS_REQDEVICE_NAME); \
38 gossip_err(" open_access_count = %d\n", open_access_count); \
39 gossip_err("*****************************************************\n");\
42 static int hash_func(__u64 tag
, int table_size
)
44 return do_div(tag
, (unsigned int)table_size
);
47 static void orangefs_devreq_add_op(struct orangefs_kernel_op_s
*op
)
49 int index
= hash_func(op
->tag
, hash_table_size
);
51 list_add_tail(&op
->list
, &orangefs_htable_ops_in_progress
[index
]);
55 * find the op with this tag and remove it from the in progress
58 static struct orangefs_kernel_op_s
*orangefs_devreq_remove_op(__u64 tag
)
60 struct orangefs_kernel_op_s
*op
, *next
;
63 index
= hash_func(tag
, hash_table_size
);
65 spin_lock(&orangefs_htable_ops_in_progress_lock
);
66 list_for_each_entry_safe(op
,
68 &orangefs_htable_ops_in_progress
[index
],
70 if (op
->tag
== tag
&& !op_state_purged(op
) &&
71 !op_state_given_up(op
)) {
72 list_del_init(&op
->list
);
73 spin_unlock(&orangefs_htable_ops_in_progress_lock
);
78 spin_unlock(&orangefs_htable_ops_in_progress_lock
);
82 /* Returns whether any FS are still pending remounted */
83 static int mark_all_pending_mounts(void)
86 struct orangefs_sb_info_s
*orangefs_sb
= NULL
;
88 spin_lock(&orangefs_superblocks_lock
);
89 list_for_each_entry(orangefs_sb
, &orangefs_superblocks
, list
) {
90 /* All of these file system require a remount */
91 orangefs_sb
->mount_pending
= 1;
94 spin_unlock(&orangefs_superblocks_lock
);
99 * Determine if a given file system needs to be remounted or not
100 * Returns -1 on error
101 * 0 if already mounted
104 static int fs_mount_pending(__s32 fsid
)
106 int mount_pending
= -1;
107 struct orangefs_sb_info_s
*orangefs_sb
= NULL
;
109 spin_lock(&orangefs_superblocks_lock
);
110 list_for_each_entry(orangefs_sb
, &orangefs_superblocks
, list
) {
111 if (orangefs_sb
->fs_id
== fsid
) {
112 mount_pending
= orangefs_sb
->mount_pending
;
116 spin_unlock(&orangefs_superblocks_lock
);
117 return mount_pending
;
120 static int orangefs_devreq_open(struct inode
*inode
, struct file
*file
)
124 /* in order to ensure that the filesystem driver sees correct UIDs */
125 if (file
->f_cred
->user_ns
!= &init_user_ns
) {
126 gossip_err("%s: device cannot be opened outside init_user_ns\n",
131 if (!(file
->f_flags
& O_NONBLOCK
)) {
132 gossip_err("%s: device cannot be opened in blocking mode\n",
137 gossip_debug(GOSSIP_DEV_DEBUG
, "client-core: opening device\n");
138 mutex_lock(&devreq_mutex
);
140 if (open_access_count
== 0) {
141 open_access_count
= 1;
146 mutex_unlock(&devreq_mutex
);
150 gossip_debug(GOSSIP_DEV_DEBUG
,
151 "pvfs2-client-core: open device complete (ret = %d)\n",
156 /* Function for read() callers into the device */
157 static ssize_t
orangefs_devreq_read(struct file
*file
,
159 size_t count
, loff_t
*offset
)
161 struct orangefs_kernel_op_s
*op
, *temp
;
162 __s32 proto_ver
= ORANGEFS_KERNEL_PROTO_VERSION
;
163 static __s32 magic
= ORANGEFS_DEVREQ_MAGIC
;
164 struct orangefs_kernel_op_s
*cur_op
= NULL
;
167 /* We do not support blocking IO. */
168 if (!(file
->f_flags
& O_NONBLOCK
)) {
169 gossip_err("%s: blocking read from client-core.\n",
175 * The client will do an ioctl to find MAX_DEV_REQ_UPSIZE, then
176 * always read with that size buffer.
178 if (count
!= MAX_DEV_REQ_UPSIZE
) {
179 gossip_err("orangefs: client-core tried to read wrong size\n");
184 /* Get next op (if any) from top of list. */
185 spin_lock(&orangefs_request_list_lock
);
186 list_for_each_entry_safe(op
, temp
, &orangefs_request_list
, list
) {
188 /* This lock is held past the end of the loop when we break. */
189 spin_lock(&op
->lock
);
190 if (unlikely(op_state_purged(op
) || op_state_given_up(op
))) {
191 spin_unlock(&op
->lock
);
195 fsid
= fsid_of_op(op
);
196 if (fsid
!= ORANGEFS_FS_ID_NULL
) {
198 /* Skip ops whose filesystem needs to be mounted. */
199 ret
= fs_mount_pending(fsid
);
201 gossip_debug(GOSSIP_DEV_DEBUG
,
202 "%s: mount pending, skipping op tag "
206 get_opname_string(op
));
207 spin_unlock(&op
->lock
);
210 * Skip ops whose filesystem we don't know about unless
211 * it is being mounted or unmounted. It is possible for
212 * a filesystem we don't know about to be unmounted if
213 * it fails to mount in the kernel after userspace has
214 * been sent the mount request.
216 /* XXX: is there a better way to detect this? */
217 } else if (ret
== -1 &&
219 ORANGEFS_VFS_OP_FS_MOUNT
||
221 ORANGEFS_VFS_OP_GETATTR
||
223 ORANGEFS_VFS_OP_FS_UMOUNT
)) {
224 gossip_debug(GOSSIP_DEV_DEBUG
,
225 "orangefs: skipping op tag %llu %s\n",
226 llu(op
->tag
), get_opname_string(op
));
228 "orangefs: ERROR: fs_mount_pending %d\n",
230 spin_unlock(&op
->lock
);
235 * Either this op does not pertain to a filesystem, is mounting
236 * a filesystem, or pertains to a mounted filesystem. Let it
244 * At this point we either have a valid op and can continue or have not
245 * found an op and must ask the client to try again later.
248 spin_unlock(&orangefs_request_list_lock
);
252 gossip_debug(GOSSIP_DEV_DEBUG
, "%s: reading op tag %llu %s\n",
255 get_opname_string(cur_op
));
258 * Such an op should never be on the list in the first place. If so, we
261 if (op_state_in_progress(cur_op
) || op_state_serviced(cur_op
)) {
262 gossip_err("orangefs: ERROR: Current op already queued.\n");
263 list_del_init(&cur_op
->list
);
264 spin_unlock(&cur_op
->lock
);
265 spin_unlock(&orangefs_request_list_lock
);
269 list_del_init(&cur_op
->list
);
270 spin_unlock(&orangefs_request_list_lock
);
272 spin_unlock(&cur_op
->lock
);
274 /* Push the upcall out. */
275 ret
= copy_to_user(buf
, &proto_ver
, sizeof(__s32
));
278 ret
= copy_to_user(buf
+sizeof(__s32
), &magic
, sizeof(__s32
));
281 ret
= copy_to_user(buf
+2 * sizeof(__s32
), &cur_op
->tag
, sizeof(__u64
));
284 ret
= copy_to_user(buf
+2*sizeof(__s32
)+sizeof(__u64
), &cur_op
->upcall
,
285 sizeof(struct orangefs_upcall_s
));
289 spin_lock(&orangefs_htable_ops_in_progress_lock
);
290 spin_lock(&cur_op
->lock
);
291 if (unlikely(op_state_given_up(cur_op
))) {
292 spin_unlock(&cur_op
->lock
);
293 spin_unlock(&orangefs_htable_ops_in_progress_lock
);
294 complete(&cur_op
->waitq
);
299 * Set the operation to be in progress and move it between lists since
300 * it has been sent to the client.
302 set_op_state_inprogress(cur_op
);
303 gossip_debug(GOSSIP_DEV_DEBUG
,
304 "%s: 1 op:%s: op_state:%d: process:%s:\n",
306 get_opname_string(cur_op
),
309 orangefs_devreq_add_op(cur_op
);
310 spin_unlock(&cur_op
->lock
);
311 spin_unlock(&orangefs_htable_ops_in_progress_lock
);
313 /* The client only asks to read one size buffer. */
314 return MAX_DEV_REQ_UPSIZE
;
317 * We were unable to copy the op data to the client. Put the op back in
318 * list. If client has crashed, the op will be purged later when the
319 * device is released.
321 gossip_err("orangefs: Failed to copy data to user space\n");
322 spin_lock(&orangefs_request_list_lock
);
323 spin_lock(&cur_op
->lock
);
324 if (likely(!op_state_given_up(cur_op
))) {
325 set_op_state_waiting(cur_op
);
326 gossip_debug(GOSSIP_DEV_DEBUG
,
327 "%s: 2 op:%s: op_state:%d: process:%s:\n",
329 get_opname_string(cur_op
),
332 list_add(&cur_op
->list
, &orangefs_request_list
);
333 spin_unlock(&cur_op
->lock
);
335 spin_unlock(&cur_op
->lock
);
336 complete(&cur_op
->waitq
);
338 spin_unlock(&orangefs_request_list_lock
);
343 * Function for writev() callers into the device.
345 * Userspace should have written:
349 * - struct orangefs_downcall_s
350 * - trailer buffer (in the case of READDIR operations)
352 static ssize_t
orangefs_devreq_write_iter(struct kiocb
*iocb
,
353 struct iov_iter
*iter
)
356 struct orangefs_kernel_op_s
*op
= NULL
;
362 int total
= ret
= iov_iter_count(iter
);
363 int downcall_size
= sizeof(struct orangefs_downcall_s
);
364 int head_size
= sizeof(head
);
366 gossip_debug(GOSSIP_DEV_DEBUG
, "%s: total:%d: ret:%zd:\n",
371 if (total
< MAX_DEV_REQ_DOWNSIZE
) {
372 gossip_err("%s: total:%d: must be at least:%u:\n",
375 (unsigned int) MAX_DEV_REQ_DOWNSIZE
);
379 if (!copy_from_iter_full(&head
, head_size
, iter
)) {
380 gossip_err("%s: failed to copy head.\n", __func__
);
384 if (head
.version
< ORANGEFS_MINIMUM_USERSPACE_VERSION
) {
385 gossip_err("%s: userspace claims version"
386 "%d, minimum version required: %d.\n",
389 ORANGEFS_MINIMUM_USERSPACE_VERSION
);
393 if (head
.magic
!= ORANGEFS_DEVREQ_MAGIC
) {
394 gossip_err("Error: Device magic number does not match.\n");
398 if (!orangefs_userspace_version
) {
399 orangefs_userspace_version
= head
.version
;
400 } else if (orangefs_userspace_version
!= head
.version
) {
401 gossip_err("Error: userspace version changes\n");
405 /* remove the op from the in progress hash table */
406 op
= orangefs_devreq_remove_op(head
.tag
);
408 gossip_debug(GOSSIP_DEV_DEBUG
,
409 "%s: No one's waiting for tag %llu\n",
410 __func__
, llu(head
.tag
));
414 if (!copy_from_iter_full(&op
->downcall
, downcall_size
, iter
)) {
415 gossip_err("%s: failed to copy downcall.\n", __func__
);
419 if (op
->downcall
.status
)
423 * We've successfully peeled off the head and the downcall.
424 * Something has gone awry if total doesn't equal the
425 * sum of head_size, downcall_size and trailer_size.
427 if ((head_size
+ downcall_size
+ op
->downcall
.trailer_size
) != total
) {
428 gossip_err("%s: funky write, head_size:%d"
429 ": downcall_size:%d: trailer_size:%lld"
430 ": total size:%d:\n",
434 op
->downcall
.trailer_size
,
439 /* Only READDIR operations should have trailers. */
440 if ((op
->downcall
.type
!= ORANGEFS_VFS_OP_READDIR
) &&
441 (op
->downcall
.trailer_size
!= 0)) {
442 gossip_err("%s: %x operation with trailer.",
448 /* READDIR operations should always have trailers. */
449 if ((op
->downcall
.type
== ORANGEFS_VFS_OP_READDIR
) &&
450 (op
->downcall
.trailer_size
== 0)) {
451 gossip_err("%s: %x operation with no trailer.",
457 if (op
->downcall
.type
!= ORANGEFS_VFS_OP_READDIR
)
460 op
->downcall
.trailer_buf
=
461 vmalloc(op
->downcall
.trailer_size
);
462 if (op
->downcall
.trailer_buf
== NULL
) {
463 gossip_err("%s: failed trailer vmalloc.\n",
467 memset(op
->downcall
.trailer_buf
, 0, op
->downcall
.trailer_size
);
468 if (!copy_from_iter_full(op
->downcall
.trailer_buf
,
469 op
->downcall
.trailer_size
, iter
)) {
470 gossip_err("%s: failed to copy trailer.\n", __func__
);
471 vfree(op
->downcall
.trailer_buf
);
477 * Return to vfs waitqueue, and back to service_operation
478 * through wait_for_matching_downcall.
480 spin_lock(&op
->lock
);
481 if (unlikely(op_is_cancel(op
))) {
482 spin_unlock(&op
->lock
);
484 } else if (unlikely(op_state_given_up(op
))) {
485 spin_unlock(&op
->lock
);
486 complete(&op
->waitq
);
488 set_op_state_serviced(op
);
489 gossip_debug(GOSSIP_DEV_DEBUG
,
490 "%s: op:%s: op_state:%d: process:%s:\n",
492 get_opname_string(op
),
495 spin_unlock(&op
->lock
);
500 op
->downcall
.status
= -(ORANGEFS_ERROR_BIT
| 9);
505 op
->downcall
.status
= -(ORANGEFS_ERROR_BIT
| 8);
511 * NOTE: gets called when the last reference to this device is dropped.
512 * Using the open_access_count variable, we enforce a reference count
513 * on this file so that it can be opened by only one process at a time.
514 * the devreq_mutex is used to make sure all i/o has completed
515 * before we call orangefs_bufmap_finalize, and similar such tricky
518 static int orangefs_devreq_release(struct inode
*inode
, struct file
*file
)
522 gossip_debug(GOSSIP_DEV_DEBUG
,
523 "%s:pvfs2-client-core: exiting, closing device\n",
526 mutex_lock(&devreq_mutex
);
527 orangefs_bufmap_finalize();
529 open_access_count
= -1;
531 unmounted
= mark_all_pending_mounts();
532 gossip_debug(GOSSIP_DEV_DEBUG
, "ORANGEFS Device Close: Filesystem(s) %s\n",
533 (unmounted
? "UNMOUNTED" : "MOUNTED"));
536 purge_inprogress_ops();
538 orangefs_bufmap_run_down();
540 gossip_debug(GOSSIP_DEV_DEBUG
,
541 "pvfs2-client-core: device close complete\n");
542 open_access_count
= 0;
543 orangefs_userspace_version
= 0;
544 mutex_unlock(&devreq_mutex
);
548 int is_daemon_in_service(void)
553 * What this function does is checks if client-core is alive
554 * based on the access count we maintain on the device.
556 mutex_lock(&devreq_mutex
);
557 in_service
= open_access_count
== 1 ? 0 : -EIO
;
558 mutex_unlock(&devreq_mutex
);
562 bool __is_daemon_in_service(void)
564 return open_access_count
== 1;
567 static inline long check_ioctl_command(unsigned int command
)
569 /* Check for valid ioctl codes */
570 if (_IOC_TYPE(command
) != ORANGEFS_DEV_MAGIC
) {
571 gossip_err("device ioctl magic numbers don't match! Did you rebuild pvfs2-client-core/libpvfs2? [cmd %x, magic %x != %x]\n",
577 /* and valid ioctl commands */
578 if (_IOC_NR(command
) >= ORANGEFS_DEV_MAXNR
|| _IOC_NR(command
) <= 0) {
579 gossip_err("Invalid ioctl command number [%d >= %d]\n",
580 _IOC_NR(command
), ORANGEFS_DEV_MAXNR
);
586 static long dispatch_ioctl_command(unsigned int command
, unsigned long arg
)
588 static __s32 magic
= ORANGEFS_DEVREQ_MAGIC
;
589 static __s32 max_up_size
= MAX_DEV_REQ_UPSIZE
;
590 static __s32 max_down_size
= MAX_DEV_REQ_DOWNSIZE
;
591 struct ORANGEFS_dev_map_desc user_desc
;
593 int upstream_kmod
= 1;
594 struct orangefs_sb_info_s
*orangefs_sb
;
596 /* mtmoore: add locking here */
599 case ORANGEFS_DEV_GET_MAGIC
:
600 return ((put_user(magic
, (__s32 __user
*) arg
) == -EFAULT
) ?
603 case ORANGEFS_DEV_GET_MAX_UPSIZE
:
604 return ((put_user(max_up_size
,
605 (__s32 __user
*) arg
) == -EFAULT
) ?
608 case ORANGEFS_DEV_GET_MAX_DOWNSIZE
:
609 return ((put_user(max_down_size
,
610 (__s32 __user
*) arg
) == -EFAULT
) ?
613 case ORANGEFS_DEV_MAP
:
614 ret
= copy_from_user(&user_desc
,
615 (struct ORANGEFS_dev_map_desc __user
*)
617 sizeof(struct ORANGEFS_dev_map_desc
));
618 /* WTF -EIO and not -EFAULT? */
619 return ret
? -EIO
: orangefs_bufmap_initialize(&user_desc
);
620 case ORANGEFS_DEV_REMOUNT_ALL
:
621 gossip_debug(GOSSIP_DEV_DEBUG
,
622 "%s: got ORANGEFS_DEV_REMOUNT_ALL\n",
626 * remount all mounted orangefs volumes to regain the lost
627 * dynamic mount tables (if any) -- NOTE: this is done
628 * without keeping the superblock list locked due to the
629 * upcall/downcall waiting. also, the request mutex is
630 * used to ensure that no operations will be serviced until
631 * all of the remounts are serviced (to avoid ops between
634 ret
= mutex_lock_interruptible(&orangefs_request_mutex
);
637 gossip_debug(GOSSIP_DEV_DEBUG
,
638 "%s: priority remount in progress\n",
640 spin_lock(&orangefs_superblocks_lock
);
641 list_for_each_entry(orangefs_sb
, &orangefs_superblocks
, list
) {
643 * We have to drop the spinlock, so entries can be
644 * removed. They can't be freed, though, so we just
645 * keep the forward pointers and zero the back ones -
646 * that way we can get to the rest of the list.
648 if (!orangefs_sb
->list
.prev
)
650 gossip_debug(GOSSIP_DEV_DEBUG
,
651 "%s: Remounting SB %p\n",
655 spin_unlock(&orangefs_superblocks_lock
);
656 ret
= orangefs_remount(orangefs_sb
);
657 spin_lock(&orangefs_superblocks_lock
);
659 gossip_debug(GOSSIP_DEV_DEBUG
,
660 "SB %p remount failed\n",
665 spin_unlock(&orangefs_superblocks_lock
);
666 gossip_debug(GOSSIP_DEV_DEBUG
,
667 "%s: priority remount complete\n",
669 mutex_unlock(&orangefs_request_mutex
);
672 case ORANGEFS_DEV_UPSTREAM
:
673 ret
= copy_to_user((void __user
*)arg
,
675 sizeof(upstream_kmod
));
682 case ORANGEFS_DEV_CLIENT_MASK
:
683 return orangefs_debugfs_new_client_mask((void __user
*)arg
);
684 case ORANGEFS_DEV_CLIENT_STRING
:
685 return orangefs_debugfs_new_client_string((void __user
*)arg
);
686 case ORANGEFS_DEV_DEBUG
:
687 return orangefs_debugfs_new_debug((void __user
*)arg
);
694 static long orangefs_devreq_ioctl(struct file
*file
,
695 unsigned int command
, unsigned long arg
)
699 /* Check for properly constructed commands */
700 ret
= check_ioctl_command(command
);
704 return (int)dispatch_ioctl_command(command
, arg
);
707 #ifdef CONFIG_COMPAT /* CONFIG_COMPAT is in .config */
709 /* Compat structure for the ORANGEFS_DEV_MAP ioctl */
710 struct ORANGEFS_dev_map_desc32
{
717 static unsigned long translate_dev_map26(unsigned long args
, long *error
)
719 struct ORANGEFS_dev_map_desc32 __user
*p32
= (void __user
*)args
;
721 * Depending on the architecture, allocate some space on the
722 * user-call-stack based on our expected layout.
724 struct ORANGEFS_dev_map_desc __user
*p
=
725 compat_alloc_user_space(sizeof(*p
));
729 /* get the ptr from the 32 bit user-space */
730 if (get_user(addr
, &p32
->ptr
))
732 /* try to put that into a 64-bit layout */
733 if (put_user(compat_ptr(addr
), &p
->ptr
))
735 /* copy the remaining fields */
736 if (copy_in_user(&p
->total_size
, &p32
->total_size
, sizeof(__s32
)))
738 if (copy_in_user(&p
->size
, &p32
->size
, sizeof(__s32
)))
740 if (copy_in_user(&p
->count
, &p32
->count
, sizeof(__s32
)))
742 return (unsigned long)p
;
749 * 32 bit user-space apps' ioctl handlers when kernel modules
750 * is compiled as a 64 bit one
752 static long orangefs_devreq_compat_ioctl(struct file
*filp
, unsigned int cmd
,
756 unsigned long arg
= args
;
758 /* Check for properly constructed commands */
759 ret
= check_ioctl_command(cmd
);
762 if (cmd
== ORANGEFS_DEV_MAP
) {
764 * convert the arguments to what we expect internally
767 arg
= translate_dev_map26(args
, &ret
);
769 gossip_err("Could not translate dev map\n");
773 /* no other ioctl requires translation */
774 return dispatch_ioctl_command(cmd
, arg
);
777 #endif /* CONFIG_COMPAT is in .config */
779 /* the assigned character device major number */
780 static int orangefs_dev_major
;
783 * Initialize orangefs device specific state:
784 * Must be called at module load time only
786 int orangefs_dev_init(void)
788 /* register orangefs-req device */
789 orangefs_dev_major
= register_chrdev(0,
790 ORANGEFS_REQDEVICE_NAME
,
791 &orangefs_devreq_file_operations
);
792 if (orangefs_dev_major
< 0) {
793 gossip_debug(GOSSIP_DEV_DEBUG
,
794 "Failed to register /dev/%s (error %d)\n",
795 ORANGEFS_REQDEVICE_NAME
, orangefs_dev_major
);
796 return orangefs_dev_major
;
799 gossip_debug(GOSSIP_DEV_DEBUG
,
800 "*** /dev/%s character device registered ***\n",
801 ORANGEFS_REQDEVICE_NAME
);
802 gossip_debug(GOSSIP_DEV_DEBUG
, "'mknod /dev/%s c %d 0'.\n",
803 ORANGEFS_REQDEVICE_NAME
, orangefs_dev_major
);
807 void orangefs_dev_cleanup(void)
809 unregister_chrdev(orangefs_dev_major
, ORANGEFS_REQDEVICE_NAME
);
810 gossip_debug(GOSSIP_DEV_DEBUG
,
811 "*** /dev/%s character device unregistered ***\n",
812 ORANGEFS_REQDEVICE_NAME
);
815 static unsigned int orangefs_devreq_poll(struct file
*file
,
816 struct poll_table_struct
*poll_table
)
818 int poll_revent_mask
= 0;
820 poll_wait(file
, &orangefs_request_list_waitq
, poll_table
);
822 if (!list_empty(&orangefs_request_list
))
823 poll_revent_mask
|= POLL_IN
;
824 return poll_revent_mask
;
827 const struct file_operations orangefs_devreq_file_operations
= {
828 .owner
= THIS_MODULE
,
829 .read
= orangefs_devreq_read
,
830 .write_iter
= orangefs_devreq_write_iter
,
831 .open
= orangefs_devreq_open
,
832 .release
= orangefs_devreq_release
,
833 .unlocked_ioctl
= orangefs_devreq_ioctl
,
835 #ifdef CONFIG_COMPAT /* CONFIG_COMPAT is in .config */
836 .compat_ioctl
= orangefs_devreq_compat_ioctl
,
838 .poll
= orangefs_devreq_poll