1
2
3
4
5
6
7
8
9
10#include "protocol.h"
11#include "orangefs-kernel.h"
12#include "orangefs-dev-proto.h"
13#include "orangefs-bufmap.h"
14#include "orangefs-debugfs.h"
15
16#include <linux/debugfs.h>
17#include <linux/slab.h>
18
19
20
21uint32_t orangefs_userspace_version;
22
23static int open_access_count;
24
25static DEFINE_MUTEX(devreq_mutex);
26
27#define DUMP_DEVICE_ERROR() \
28do { \
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");\
40} while (0)
41
42static int hash_func(__u64 tag, int table_size)
43{
44 return do_div(tag, (unsigned int)table_size);
45}
46
47static void orangefs_devreq_add_op(struct orangefs_kernel_op_s *op)
48{
49 int index = hash_func(op->tag, hash_table_size);
50
51 list_add_tail(&op->list, &orangefs_htable_ops_in_progress[index]);
52}
53
54
55
56
57
58static struct orangefs_kernel_op_s *orangefs_devreq_remove_op(__u64 tag)
59{
60 struct orangefs_kernel_op_s *op, *next;
61 int index;
62
63 index = hash_func(tag, hash_table_size);
64
65 spin_lock(&orangefs_htable_ops_in_progress_lock);
66 list_for_each_entry_safe(op,
67 next,
68 &orangefs_htable_ops_in_progress[index],
69 list) {
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);
74 return op;
75 }
76 }
77
78 spin_unlock(&orangefs_htable_ops_in_progress_lock);
79 return NULL;
80}
81
82
83static int mark_all_pending_mounts(void)
84{
85 int unmounted = 1;
86 struct orangefs_sb_info_s *orangefs_sb = NULL;
87
88 spin_lock(&orangefs_superblocks_lock);
89 list_for_each_entry(orangefs_sb, &orangefs_superblocks, list) {
90
91 orangefs_sb->mount_pending = 1;
92 unmounted = 0;
93 }
94 spin_unlock(&orangefs_superblocks_lock);
95 return unmounted;
96}
97
98
99
100
101
102
103
104static int fs_mount_pending(__s32 fsid)
105{
106 int mount_pending = -1;
107 struct orangefs_sb_info_s *orangefs_sb = NULL;
108
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;
113 break;
114 }
115 }
116 spin_unlock(&orangefs_superblocks_lock);
117 return mount_pending;
118}
119
120static int orangefs_devreq_open(struct inode *inode, struct file *file)
121{
122 int ret = -EINVAL;
123
124
125 if (file->f_cred->user_ns != &init_user_ns) {
126 gossip_err("%s: device cannot be opened outside init_user_ns\n",
127 __func__);
128 goto out;
129 }
130
131 if (!(file->f_flags & O_NONBLOCK)) {
132 gossip_err("%s: device cannot be opened in blocking mode\n",
133 __func__);
134 goto out;
135 }
136 ret = -EACCES;
137 gossip_debug(GOSSIP_DEV_DEBUG, "client-core: opening device\n");
138 mutex_lock(&devreq_mutex);
139
140 if (open_access_count == 0) {
141 open_access_count = 1;
142 ret = 0;
143 } else {
144 DUMP_DEVICE_ERROR();
145 }
146 mutex_unlock(&devreq_mutex);
147
148out:
149
150 gossip_debug(GOSSIP_DEV_DEBUG,
151 "pvfs2-client-core: open device complete (ret = %d)\n",
152 ret);
153 return ret;
154}
155
156
157static ssize_t orangefs_devreq_read(struct file *file,
158 char __user *buf,
159 size_t count, loff_t *offset)
160{
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;
165 unsigned long ret;
166
167
168 if (!(file->f_flags & O_NONBLOCK)) {
169 gossip_err("%s: blocking read from client-core.\n",
170 __func__);
171 return -EINVAL;
172 }
173
174
175
176
177
178 if (count != MAX_DEV_REQ_UPSIZE) {
179 gossip_err("orangefs: client-core tried to read wrong size\n");
180 return -EINVAL;
181 }
182
183restart:
184
185 spin_lock(&orangefs_request_list_lock);
186 list_for_each_entry_safe(op, temp, &orangefs_request_list, list) {
187 __s32 fsid;
188
189 spin_lock(&op->lock);
190 if (unlikely(op_state_purged(op) || op_state_given_up(op))) {
191 spin_unlock(&op->lock);
192 continue;
193 }
194
195 fsid = fsid_of_op(op);
196 if (fsid != ORANGEFS_FS_ID_NULL) {
197 int ret;
198
199 ret = fs_mount_pending(fsid);
200 if (ret == 1) {
201 gossip_debug(GOSSIP_DEV_DEBUG,
202 "%s: mount pending, skipping op tag "
203 "%llu %s\n",
204 __func__,
205 llu(op->tag),
206 get_opname_string(op));
207 spin_unlock(&op->lock);
208 continue;
209
210
211
212
213
214
215
216
217 } else if (ret == -1 &&
218 !(op->upcall.type ==
219 ORANGEFS_VFS_OP_FS_MOUNT ||
220 op->upcall.type ==
221 ORANGEFS_VFS_OP_GETATTR ||
222 op->upcall.type ==
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));
227 gossip_err(
228 "orangefs: ERROR: fs_mount_pending %d\n",
229 fsid);
230 spin_unlock(&op->lock);
231 continue;
232 }
233 }
234
235
236
237
238
239 cur_op = op;
240 break;
241 }
242
243
244
245
246
247 if (!cur_op) {
248 spin_unlock(&orangefs_request_list_lock);
249 return -EAGAIN;
250 }
251
252 gossip_debug(GOSSIP_DEV_DEBUG, "%s: reading op tag %llu %s\n",
253 __func__,
254 llu(cur_op->tag),
255 get_opname_string(cur_op));
256
257
258
259
260
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);
266 return -EAGAIN;
267 }
268
269 list_del_init(&cur_op->list);
270 spin_unlock(&orangefs_request_list_lock);
271
272 spin_unlock(&cur_op->lock);
273
274
275 ret = copy_to_user(buf, &proto_ver, sizeof(__s32));
276 if (ret != 0)
277 goto error;
278 ret = copy_to_user(buf+sizeof(__s32), &magic, sizeof(__s32));
279 if (ret != 0)
280 goto error;
281 ret = copy_to_user(buf+2 * sizeof(__s32), &cur_op->tag, sizeof(__u64));
282 if (ret != 0)
283 goto error;
284 ret = copy_to_user(buf+2*sizeof(__s32)+sizeof(__u64), &cur_op->upcall,
285 sizeof(struct orangefs_upcall_s));
286 if (ret != 0)
287 goto error;
288
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);
295 goto restart;
296 }
297
298
299
300
301
302 set_op_state_inprogress(cur_op);
303 gossip_debug(GOSSIP_DEV_DEBUG,
304 "%s: 1 op:%s: op_state:%d: process:%s:\n",
305 __func__,
306 get_opname_string(cur_op),
307 cur_op->op_state,
308 current->comm);
309 orangefs_devreq_add_op(cur_op);
310 spin_unlock(&cur_op->lock);
311 spin_unlock(&orangefs_htable_ops_in_progress_lock);
312
313
314 return MAX_DEV_REQ_UPSIZE;
315error:
316
317
318
319
320
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",
328 __func__,
329 get_opname_string(cur_op),
330 cur_op->op_state,
331 current->comm);
332 list_add(&cur_op->list, &orangefs_request_list);
333 spin_unlock(&cur_op->lock);
334 } else {
335 spin_unlock(&cur_op->lock);
336 complete(&cur_op->waitq);
337 }
338 spin_unlock(&orangefs_request_list_lock);
339 return -EFAULT;
340}
341
342
343
344
345
346
347
348
349
350
351
352static ssize_t orangefs_devreq_write_iter(struct kiocb *iocb,
353 struct iov_iter *iter)
354{
355 ssize_t ret;
356 struct orangefs_kernel_op_s *op = NULL;
357 struct {
358 __u32 version;
359 __u32 magic;
360 __u64 tag;
361 } head;
362 int total = ret = iov_iter_count(iter);
363 int downcall_size = sizeof(struct orangefs_downcall_s);
364 int head_size = sizeof(head);
365
366 gossip_debug(GOSSIP_DEV_DEBUG, "%s: total:%d: ret:%zd:\n",
367 __func__,
368 total,
369 ret);
370
371 if (total < MAX_DEV_REQ_DOWNSIZE) {
372 gossip_err("%s: total:%d: must be at least:%u:\n",
373 __func__,
374 total,
375 (unsigned int) MAX_DEV_REQ_DOWNSIZE);
376 return -EFAULT;
377 }
378
379 if (!copy_from_iter_full(&head, head_size, iter)) {
380 gossip_err("%s: failed to copy head.\n", __func__);
381 return -EFAULT;
382 }
383
384 if (head.version < ORANGEFS_MINIMUM_USERSPACE_VERSION) {
385 gossip_err("%s: userspace claims version"
386 "%d, minimum version required: %d.\n",
387 __func__,
388 head.version,
389 ORANGEFS_MINIMUM_USERSPACE_VERSION);
390 return -EPROTO;
391 }
392
393 if (head.magic != ORANGEFS_DEVREQ_MAGIC) {
394 gossip_err("Error: Device magic number does not match.\n");
395 return -EPROTO;
396 }
397
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");
402 return -EPROTO;
403 }
404
405
406 op = orangefs_devreq_remove_op(head.tag);
407 if (!op) {
408 gossip_debug(GOSSIP_DEV_DEBUG,
409 "%s: No one's waiting for tag %llu\n",
410 __func__, llu(head.tag));
411 return ret;
412 }
413
414 if (!copy_from_iter_full(&op->downcall, downcall_size, iter)) {
415 gossip_err("%s: failed to copy downcall.\n", __func__);
416 goto Efault;
417 }
418
419 if (op->downcall.status)
420 goto wakeup;
421
422
423
424
425
426
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",
431 __func__,
432 head_size,
433 downcall_size,
434 op->downcall.trailer_size,
435 total);
436 goto Efault;
437 }
438
439
440 if ((op->downcall.type != ORANGEFS_VFS_OP_READDIR) &&
441 (op->downcall.trailer_size != 0)) {
442 gossip_err("%s: %x operation with trailer.",
443 __func__,
444 op->downcall.type);
445 goto Efault;
446 }
447
448
449 if ((op->downcall.type == ORANGEFS_VFS_OP_READDIR) &&
450 (op->downcall.trailer_size == 0)) {
451 gossip_err("%s: %x operation with no trailer.",
452 __func__,
453 op->downcall.type);
454 goto Efault;
455 }
456
457 if (op->downcall.type != ORANGEFS_VFS_OP_READDIR)
458 goto wakeup;
459
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",
464 __func__);
465 goto Enomem;
466 }
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);
472 goto Efault;
473 }
474
475wakeup:
476
477
478
479
480 spin_lock(&op->lock);
481 if (unlikely(op_is_cancel(op))) {
482 spin_unlock(&op->lock);
483 put_cancel(op);
484 } else if (unlikely(op_state_given_up(op))) {
485 spin_unlock(&op->lock);
486 complete(&op->waitq);
487 } else {
488 set_op_state_serviced(op);
489 gossip_debug(GOSSIP_DEV_DEBUG,
490 "%s: op:%s: op_state:%d: process:%s:\n",
491 __func__,
492 get_opname_string(op),
493 op->op_state,
494 current->comm);
495 spin_unlock(&op->lock);
496 }
497 return ret;
498
499Efault:
500 op->downcall.status = -(ORANGEFS_ERROR_BIT | 9);
501 ret = -EFAULT;
502 goto wakeup;
503
504Enomem:
505 op->downcall.status = -(ORANGEFS_ERROR_BIT | 8);
506 ret = -ENOMEM;
507 goto wakeup;
508}
509
510
511
512
513
514
515
516
517
518static int orangefs_devreq_release(struct inode *inode, struct file *file)
519{
520 int unmounted = 0;
521
522 gossip_debug(GOSSIP_DEV_DEBUG,
523 "%s:pvfs2-client-core: exiting, closing device\n",
524 __func__);
525
526 mutex_lock(&devreq_mutex);
527 orangefs_bufmap_finalize();
528
529 open_access_count = -1;
530
531 unmounted = mark_all_pending_mounts();
532 gossip_debug(GOSSIP_DEV_DEBUG, "ORANGEFS Device Close: Filesystem(s) %s\n",
533 (unmounted ? "UNMOUNTED" : "MOUNTED"));
534
535 purge_waiting_ops();
536 purge_inprogress_ops();
537
538 orangefs_bufmap_run_down();
539
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);
545 return 0;
546}
547
548int is_daemon_in_service(void)
549{
550 int in_service;
551
552
553
554
555
556 mutex_lock(&devreq_mutex);
557 in_service = open_access_count == 1 ? 0 : -EIO;
558 mutex_unlock(&devreq_mutex);
559 return in_service;
560}
561
562bool __is_daemon_in_service(void)
563{
564 return open_access_count == 1;
565}
566
567static inline long check_ioctl_command(unsigned int command)
568{
569
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",
572 command,
573 _IOC_TYPE(command),
574 ORANGEFS_DEV_MAGIC);
575 return -EINVAL;
576 }
577
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);
581 return -ENOIOCTLCMD;
582 }
583 return 0;
584}
585
586static long dispatch_ioctl_command(unsigned int command, unsigned long arg)
587{
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;
592 int ret = 0;
593 int upstream_kmod = 1;
594 struct orangefs_sb_info_s *orangefs_sb;
595
596
597
598 switch (command) {
599 case ORANGEFS_DEV_GET_MAGIC:
600 return ((put_user(magic, (__s32 __user *) arg) == -EFAULT) ?
601 -EIO :
602 0);
603 case ORANGEFS_DEV_GET_MAX_UPSIZE:
604 return ((put_user(max_up_size,
605 (__s32 __user *) arg) == -EFAULT) ?
606 -EIO :
607 0);
608 case ORANGEFS_DEV_GET_MAX_DOWNSIZE:
609 return ((put_user(max_down_size,
610 (__s32 __user *) arg) == -EFAULT) ?
611 -EIO :
612 0);
613 case ORANGEFS_DEV_MAP:
614 ret = copy_from_user(&user_desc,
615 (struct ORANGEFS_dev_map_desc __user *)
616 arg,
617 sizeof(struct ORANGEFS_dev_map_desc));
618
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",
623 __func__);
624
625
626
627
628
629
630
631
632
633
634 ret = mutex_lock_interruptible(&orangefs_request_mutex);
635 if (ret < 0)
636 return ret;
637 gossip_debug(GOSSIP_DEV_DEBUG,
638 "%s: priority remount in progress\n",
639 __func__);
640 spin_lock(&orangefs_superblocks_lock);
641 list_for_each_entry(orangefs_sb, &orangefs_superblocks, list) {
642
643
644
645
646
647
648 if (!orangefs_sb->list.prev)
649 continue;
650 gossip_debug(GOSSIP_DEV_DEBUG,
651 "%s: Remounting SB %p\n",
652 __func__,
653 orangefs_sb);
654
655 spin_unlock(&orangefs_superblocks_lock);
656 ret = orangefs_remount(orangefs_sb);
657 spin_lock(&orangefs_superblocks_lock);
658 if (ret) {
659 gossip_debug(GOSSIP_DEV_DEBUG,
660 "SB %p remount failed\n",
661 orangefs_sb);
662 break;
663 }
664 }
665 spin_unlock(&orangefs_superblocks_lock);
666 gossip_debug(GOSSIP_DEV_DEBUG,
667 "%s: priority remount complete\n",
668 __func__);
669 mutex_unlock(&orangefs_request_mutex);
670 return ret;
671
672 case ORANGEFS_DEV_UPSTREAM:
673 ret = copy_to_user((void __user *)arg,
674 &upstream_kmod,
675 sizeof(upstream_kmod));
676
677 if (ret != 0)
678 return -EIO;
679 else
680 return ret;
681
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);
688 default:
689 return -ENOIOCTLCMD;
690 }
691 return -ENOIOCTLCMD;
692}
693
694static long orangefs_devreq_ioctl(struct file *file,
695 unsigned int command, unsigned long arg)
696{
697 long ret;
698
699
700 ret = check_ioctl_command(command);
701 if (ret < 0)
702 return (int)ret;
703
704 return (int)dispatch_ioctl_command(command, arg);
705}
706
707#ifdef CONFIG_COMPAT
708
709
710struct ORANGEFS_dev_map_desc32 {
711 compat_uptr_t ptr;
712 __s32 total_size;
713 __s32 size;
714 __s32 count;
715};
716
717static unsigned long translate_dev_map26(unsigned long args, long *error)
718{
719 struct ORANGEFS_dev_map_desc32 __user *p32 = (void __user *)args;
720
721
722
723
724 struct ORANGEFS_dev_map_desc __user *p =
725 compat_alloc_user_space(sizeof(*p));
726 compat_uptr_t addr;
727
728 *error = 0;
729
730 if (get_user(addr, &p32->ptr))
731 goto err;
732
733 if (put_user(compat_ptr(addr), &p->ptr))
734 goto err;
735
736 if (copy_in_user(&p->total_size, &p32->total_size, sizeof(__s32)))
737 goto err;
738 if (copy_in_user(&p->size, &p32->size, sizeof(__s32)))
739 goto err;
740 if (copy_in_user(&p->count, &p32->count, sizeof(__s32)))
741 goto err;
742 return (unsigned long)p;
743err:
744 *error = -EFAULT;
745 return 0;
746}
747
748
749
750
751
752static long orangefs_devreq_compat_ioctl(struct file *filp, unsigned int cmd,
753 unsigned long args)
754{
755 long ret;
756 unsigned long arg = args;
757
758
759 ret = check_ioctl_command(cmd);
760 if (ret < 0)
761 return ret;
762 if (cmd == ORANGEFS_DEV_MAP) {
763
764
765
766
767 arg = translate_dev_map26(args, &ret);
768 if (ret < 0) {
769 gossip_err("Could not translate dev map\n");
770 return ret;
771 }
772 }
773
774 return dispatch_ioctl_command(cmd, arg);
775}
776
777#endif
778
779
780static int orangefs_dev_major;
781
782
783
784
785
786int orangefs_dev_init(void)
787{
788
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;
797 }
798
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);
804 return 0;
805}
806
807void orangefs_dev_cleanup(void)
808{
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);
813}
814
815static unsigned int orangefs_devreq_poll(struct file *file,
816 struct poll_table_struct *poll_table)
817{
818 int poll_revent_mask = 0;
819
820 poll_wait(file, &orangefs_request_list_waitq, poll_table);
821
822 if (!list_empty(&orangefs_request_list))
823 poll_revent_mask |= POLL_IN;
824 return poll_revent_mask;
825}
826
827const 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,
834
835#ifdef CONFIG_COMPAT
836 .compat_ioctl = orangefs_devreq_compat_ioctl,
837#endif
838 .poll = orangefs_devreq_poll
839};
840