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");
183 /* Check for an empty list before locking. */
184 if (list_empty(&orangefs_request_list))
188 /* Get next op (if any) from top of list. */
189 spin_lock(&orangefs_request_list_lock);
190 list_for_each_entry_safe(op, temp, &orangefs_request_list, list) {
192 /* This lock is held past the end of the loop when we break. */
193 spin_lock(&op->lock);
194 if (unlikely(op_state_purged(op) || op_state_given_up(op))) {
195 spin_unlock(&op->lock);
199 fsid = fsid_of_op(op);
200 if (fsid != ORANGEFS_FS_ID_NULL) {
202 /* Skip ops whose filesystem needs to be mounted. */
203 ret = fs_mount_pending(fsid);
205 gossip_debug(GOSSIP_DEV_DEBUG,
206 "%s: mount pending, skipping op tag "
210 get_opname_string(op));
211 spin_unlock(&op->lock);
214 * Skip ops whose filesystem we don't know about unless
215 * it is being mounted or unmounted. It is possible for
216 * a filesystem we don't know about to be unmounted if
217 * it fails to mount in the kernel after userspace has
218 * been sent the mount request.
220 /* XXX: is there a better way to detect this? */
221 } else if (ret == -1 &&
223 ORANGEFS_VFS_OP_FS_MOUNT ||
225 ORANGEFS_VFS_OP_GETATTR ||
227 ORANGEFS_VFS_OP_FS_UMOUNT)) {
228 gossip_debug(GOSSIP_DEV_DEBUG,
229 "orangefs: skipping op tag %llu %s\n",
230 llu(op->tag), get_opname_string(op));
232 "orangefs: ERROR: fs_mount_pending %d\n",
234 spin_unlock(&op->lock);
239 * Either this op does not pertain to a filesystem, is mounting
240 * a filesystem, or pertains to a mounted filesystem. Let it
248 * At this point we either have a valid op and can continue or have not
249 * found an op and must ask the client to try again later.
252 spin_unlock(&orangefs_request_list_lock);
256 gossip_debug(GOSSIP_DEV_DEBUG, "%s: reading op tag %llu %s\n",
259 get_opname_string(cur_op));
262 * Such an op should never be on the list in the first place. If so, we
265 if (op_state_in_progress(cur_op) || op_state_serviced(cur_op)) {
266 gossip_err("orangefs: ERROR: Current op already queued.\n");
267 list_del_init(&cur_op->list);
268 spin_unlock(&cur_op->lock);
269 spin_unlock(&orangefs_request_list_lock);
273 list_del_init(&cur_op->list);
274 spin_unlock(&orangefs_request_list_lock);
276 spin_unlock(&cur_op->lock);
278 /* Push the upcall out. */
279 ret = copy_to_user(buf, &proto_ver, sizeof(__s32));
282 ret = copy_to_user(buf+sizeof(__s32), &magic, sizeof(__s32));
285 ret = copy_to_user(buf+2 * sizeof(__s32), &cur_op->tag, sizeof(__u64));
288 ret = copy_to_user(buf+2*sizeof(__s32)+sizeof(__u64), &cur_op->upcall,
289 sizeof(struct orangefs_upcall_s));
293 spin_lock(&orangefs_htable_ops_in_progress_lock);
294 spin_lock(&cur_op->lock);
295 if (unlikely(op_state_given_up(cur_op))) {
296 spin_unlock(&cur_op->lock);
297 spin_unlock(&orangefs_htable_ops_in_progress_lock);
298 complete(&cur_op->waitq);
303 * Set the operation to be in progress and move it between lists since
304 * it has been sent to the client.
306 set_op_state_inprogress(cur_op);
307 gossip_debug(GOSSIP_DEV_DEBUG,
308 "%s: 1 op:%s: op_state:%d: process:%s:\n",
310 get_opname_string(cur_op),
313 orangefs_devreq_add_op(cur_op);
314 spin_unlock(&cur_op->lock);
315 spin_unlock(&orangefs_htable_ops_in_progress_lock);
317 /* The client only asks to read one size buffer. */
318 return MAX_DEV_REQ_UPSIZE;
321 * We were unable to copy the op data to the client. Put the op back in
322 * list. If client has crashed, the op will be purged later when the
323 * device is released.
325 gossip_err("orangefs: Failed to copy data to user space\n");
326 spin_lock(&orangefs_request_list_lock);
327 spin_lock(&cur_op->lock);
328 if (likely(!op_state_given_up(cur_op))) {
329 set_op_state_waiting(cur_op);
330 gossip_debug(GOSSIP_DEV_DEBUG,
331 "%s: 2 op:%s: op_state:%d: process:%s:\n",
333 get_opname_string(cur_op),
336 list_add(&cur_op->list, &orangefs_request_list);
337 spin_unlock(&cur_op->lock);
339 spin_unlock(&cur_op->lock);
340 complete(&cur_op->waitq);
342 spin_unlock(&orangefs_request_list_lock);
347 * Function for writev() callers into the device.
349 * Userspace should have written:
353 * - struct orangefs_downcall_s
354 * - trailer buffer (in the case of READDIR operations)
356 static ssize_t orangefs_devreq_write_iter(struct kiocb *iocb,
357 struct iov_iter *iter)
360 struct orangefs_kernel_op_s *op = NULL;
366 int total = ret = iov_iter_count(iter);
367 int downcall_size = sizeof(struct orangefs_downcall_s);
368 int head_size = sizeof(head);
370 gossip_debug(GOSSIP_DEV_DEBUG, "%s: total:%d: ret:%zd:\n",
375 if (total < MAX_DEV_REQ_DOWNSIZE) {
376 gossip_err("%s: total:%d: must be at least:%u:\n",
379 (unsigned int) MAX_DEV_REQ_DOWNSIZE);
383 if (!copy_from_iter_full(&head, head_size, iter)) {
384 gossip_err("%s: failed to copy head.\n", __func__);
388 if (head.version < ORANGEFS_MINIMUM_USERSPACE_VERSION) {
389 gossip_err("%s: userspace claims version"
390 "%d, minimum version required: %d.\n",
393 ORANGEFS_MINIMUM_USERSPACE_VERSION);
397 if (head.magic != ORANGEFS_DEVREQ_MAGIC) {
398 gossip_err("Error: Device magic number does not match.\n");
402 if (!orangefs_userspace_version) {
403 orangefs_userspace_version = head.version;
404 } else if (orangefs_userspace_version != head.version) {
405 gossip_err("Error: userspace version changes\n");
409 /* remove the op from the in progress hash table */
410 op = orangefs_devreq_remove_op(head.tag);
412 gossip_debug(GOSSIP_DEV_DEBUG,
413 "%s: No one's waiting for tag %llu\n",
414 __func__, llu(head.tag));
418 if (!copy_from_iter_full(&op->downcall, downcall_size, iter)) {
419 gossip_err("%s: failed to copy downcall.\n", __func__);
423 if (op->downcall.status)
427 * We've successfully peeled off the head and the downcall.
428 * Something has gone awry if total doesn't equal the
429 * sum of head_size, downcall_size and trailer_size.
431 if ((head_size + downcall_size + op->downcall.trailer_size) != total) {
432 gossip_err("%s: funky write, head_size:%d"
433 ": downcall_size:%d: trailer_size:%lld"
434 ": total size:%d:\n",
438 op->downcall.trailer_size,
443 /* Only READDIR operations should have trailers. */
444 if ((op->downcall.type != ORANGEFS_VFS_OP_READDIR) &&
445 (op->downcall.trailer_size != 0)) {
446 gossip_err("%s: %x operation with trailer.",
452 /* READDIR operations should always have trailers. */
453 if ((op->downcall.type == ORANGEFS_VFS_OP_READDIR) &&
454 (op->downcall.trailer_size == 0)) {
455 gossip_err("%s: %x operation with no trailer.",
461 if (op->downcall.type != ORANGEFS_VFS_OP_READDIR)
464 op->downcall.trailer_buf =
465 vmalloc(op->downcall.trailer_size);
466 if (op->downcall.trailer_buf == NULL) {
467 gossip_err("%s: failed trailer vmalloc.\n",
471 memset(op->downcall.trailer_buf, 0, op->downcall.trailer_size);
472 if (!copy_from_iter_full(op->downcall.trailer_buf,
473 op->downcall.trailer_size, iter)) {
474 gossip_err("%s: failed to copy trailer.\n", __func__);
475 vfree(op->downcall.trailer_buf);
481 * Return to vfs waitqueue, and back to service_operation
482 * through wait_for_matching_downcall.
484 spin_lock(&op->lock);
485 if (unlikely(op_is_cancel(op))) {
486 spin_unlock(&op->lock);
488 } else if (unlikely(op_state_given_up(op))) {
489 spin_unlock(&op->lock);
490 complete(&op->waitq);
492 set_op_state_serviced(op);
493 gossip_debug(GOSSIP_DEV_DEBUG,
494 "%s: op:%s: op_state:%d: process:%s:\n",
496 get_opname_string(op),
499 spin_unlock(&op->lock);
504 op->downcall.status = -(ORANGEFS_ERROR_BIT | 9);
509 op->downcall.status = -(ORANGEFS_ERROR_BIT | 8);
515 * NOTE: gets called when the last reference to this device is dropped.
516 * Using the open_access_count variable, we enforce a reference count
517 * on this file so that it can be opened by only one process at a time.
518 * the devreq_mutex is used to make sure all i/o has completed
519 * before we call orangefs_bufmap_finalize, and similar such tricky
522 static int orangefs_devreq_release(struct inode *inode, struct file *file)
526 gossip_debug(GOSSIP_DEV_DEBUG,
527 "%s:pvfs2-client-core: exiting, closing device\n",
530 mutex_lock(&devreq_mutex);
531 orangefs_bufmap_finalize();
533 open_access_count = -1;
535 unmounted = mark_all_pending_mounts();
536 gossip_debug(GOSSIP_DEV_DEBUG, "ORANGEFS Device Close: Filesystem(s) %s\n",
537 (unmounted ? "UNMOUNTED" : "MOUNTED"));
540 purge_inprogress_ops();
542 orangefs_bufmap_run_down();
544 gossip_debug(GOSSIP_DEV_DEBUG,
545 "pvfs2-client-core: device close complete\n");
546 open_access_count = 0;
547 orangefs_userspace_version = 0;
548 mutex_unlock(&devreq_mutex);
552 int is_daemon_in_service(void)
557 * What this function does is checks if client-core is alive
558 * based on the access count we maintain on the device.
560 mutex_lock(&devreq_mutex);
561 in_service = open_access_count == 1 ? 0 : -EIO;
562 mutex_unlock(&devreq_mutex);
566 bool __is_daemon_in_service(void)
568 return open_access_count == 1;
571 static inline long check_ioctl_command(unsigned int command)
573 /* Check for valid ioctl codes */
574 if (_IOC_TYPE(command) != ORANGEFS_DEV_MAGIC) {
575 gossip_err("device ioctl magic numbers don't match! Did you rebuild pvfs2-client-core/libpvfs2? [cmd %x, magic %x != %x]\n",
581 /* and valid ioctl commands */
582 if (_IOC_NR(command) >= ORANGEFS_DEV_MAXNR || _IOC_NR(command) <= 0) {
583 gossip_err("Invalid ioctl command number [%d >= %d]\n",
584 _IOC_NR(command), ORANGEFS_DEV_MAXNR);
590 static long dispatch_ioctl_command(unsigned int command, unsigned long arg)
592 static __s32 magic = ORANGEFS_DEVREQ_MAGIC;
593 static __s32 max_up_size = MAX_DEV_REQ_UPSIZE;
594 static __s32 max_down_size = MAX_DEV_REQ_DOWNSIZE;
595 struct ORANGEFS_dev_map_desc user_desc;
597 int upstream_kmod = 1;
598 struct orangefs_sb_info_s *orangefs_sb;
600 /* mtmoore: add locking here */
603 case ORANGEFS_DEV_GET_MAGIC:
604 return ((put_user(magic, (__s32 __user *) arg) == -EFAULT) ?
607 case ORANGEFS_DEV_GET_MAX_UPSIZE:
608 return ((put_user(max_up_size,
609 (__s32 __user *) arg) == -EFAULT) ?
612 case ORANGEFS_DEV_GET_MAX_DOWNSIZE:
613 return ((put_user(max_down_size,
614 (__s32 __user *) arg) == -EFAULT) ?
617 case ORANGEFS_DEV_MAP:
618 ret = copy_from_user(&user_desc,
619 (struct ORANGEFS_dev_map_desc __user *)
621 sizeof(struct ORANGEFS_dev_map_desc));
622 /* WTF -EIO and not -EFAULT? */
623 return ret ? -EIO : orangefs_bufmap_initialize(&user_desc);
624 case ORANGEFS_DEV_REMOUNT_ALL:
625 gossip_debug(GOSSIP_DEV_DEBUG,
626 "%s: got ORANGEFS_DEV_REMOUNT_ALL\n",
630 * remount all mounted orangefs volumes to regain the lost
631 * dynamic mount tables (if any) -- NOTE: this is done
632 * without keeping the superblock list locked due to the
633 * upcall/downcall waiting. also, the request mutex is
634 * used to ensure that no operations will be serviced until
635 * all of the remounts are serviced (to avoid ops between
638 ret = mutex_lock_interruptible(&orangefs_request_mutex);
641 gossip_debug(GOSSIP_DEV_DEBUG,
642 "%s: priority remount in progress\n",
644 spin_lock(&orangefs_superblocks_lock);
645 list_for_each_entry(orangefs_sb, &orangefs_superblocks, list) {
647 * We have to drop the spinlock, so entries can be
648 * removed. They can't be freed, though, so we just
649 * keep the forward pointers and zero the back ones -
650 * that way we can get to the rest of the list.
652 if (!orangefs_sb->list.prev)
654 gossip_debug(GOSSIP_DEV_DEBUG,
655 "%s: Remounting SB %p\n",
659 spin_unlock(&orangefs_superblocks_lock);
660 ret = orangefs_remount(orangefs_sb);
661 spin_lock(&orangefs_superblocks_lock);
663 gossip_debug(GOSSIP_DEV_DEBUG,
664 "SB %p remount failed\n",
669 spin_unlock(&orangefs_superblocks_lock);
670 gossip_debug(GOSSIP_DEV_DEBUG,
671 "%s: priority remount complete\n",
673 mutex_unlock(&orangefs_request_mutex);
676 case ORANGEFS_DEV_UPSTREAM:
677 ret = copy_to_user((void __user *)arg,
679 sizeof(upstream_kmod));
686 case ORANGEFS_DEV_CLIENT_MASK:
687 return orangefs_debugfs_new_client_mask((void __user *)arg);
688 case ORANGEFS_DEV_CLIENT_STRING:
689 return orangefs_debugfs_new_client_string((void __user *)arg);
690 case ORANGEFS_DEV_DEBUG:
691 return orangefs_debugfs_new_debug((void __user *)arg);
698 static long orangefs_devreq_ioctl(struct file *file,
699 unsigned int command, unsigned long arg)
703 /* Check for properly constructed commands */
704 ret = check_ioctl_command(command);
708 return (int)dispatch_ioctl_command(command, arg);
711 #ifdef CONFIG_COMPAT /* CONFIG_COMPAT is in .config */
713 /* Compat structure for the ORANGEFS_DEV_MAP ioctl */
714 struct ORANGEFS_dev_map_desc32 {
721 static unsigned long translate_dev_map26(unsigned long args, long *error)
723 struct ORANGEFS_dev_map_desc32 __user *p32 = (void __user *)args;
725 * Depending on the architecture, allocate some space on the
726 * user-call-stack based on our expected layout.
728 struct ORANGEFS_dev_map_desc __user *p =
729 compat_alloc_user_space(sizeof(*p));
733 /* get the ptr from the 32 bit user-space */
734 if (get_user(addr, &p32->ptr))
736 /* try to put that into a 64-bit layout */
737 if (put_user(compat_ptr(addr), &p->ptr))
739 /* copy the remaining fields */
740 if (copy_in_user(&p->total_size, &p32->total_size, sizeof(__s32)))
742 if (copy_in_user(&p->size, &p32->size, sizeof(__s32)))
744 if (copy_in_user(&p->count, &p32->count, sizeof(__s32)))
746 return (unsigned long)p;
753 * 32 bit user-space apps' ioctl handlers when kernel modules
754 * is compiled as a 64 bit one
756 static long orangefs_devreq_compat_ioctl(struct file *filp, unsigned int cmd,
760 unsigned long arg = args;
762 /* Check for properly constructed commands */
763 ret = check_ioctl_command(cmd);
766 if (cmd == ORANGEFS_DEV_MAP) {
768 * convert the arguments to what we expect internally
771 arg = translate_dev_map26(args, &ret);
773 gossip_err("Could not translate dev map\n");
777 /* no other ioctl requires translation */
778 return dispatch_ioctl_command(cmd, arg);
781 #endif /* CONFIG_COMPAT is in .config */
783 /* the assigned character device major number */
784 static int orangefs_dev_major;
787 * Initialize orangefs device specific state:
788 * Must be called at module load time only
790 int orangefs_dev_init(void)
792 /* register orangefs-req device */
793 orangefs_dev_major = register_chrdev(0,
794 ORANGEFS_REQDEVICE_NAME,
795 &orangefs_devreq_file_operations);
796 if (orangefs_dev_major < 0) {
797 gossip_debug(GOSSIP_DEV_DEBUG,
798 "Failed to register /dev/%s (error %d)\n",
799 ORANGEFS_REQDEVICE_NAME, orangefs_dev_major);
800 return orangefs_dev_major;
803 gossip_debug(GOSSIP_DEV_DEBUG,
804 "*** /dev/%s character device registered ***\n",
805 ORANGEFS_REQDEVICE_NAME);
806 gossip_debug(GOSSIP_DEV_DEBUG, "'mknod /dev/%s c %d 0'.\n",
807 ORANGEFS_REQDEVICE_NAME, orangefs_dev_major);
811 void orangefs_dev_cleanup(void)
813 unregister_chrdev(orangefs_dev_major, ORANGEFS_REQDEVICE_NAME);
814 gossip_debug(GOSSIP_DEV_DEBUG,
815 "*** /dev/%s character device unregistered ***\n",
816 ORANGEFS_REQDEVICE_NAME);
819 static unsigned int orangefs_devreq_poll(struct file *file,
820 struct poll_table_struct *poll_table)
822 int poll_revent_mask = 0;
824 poll_wait(file, &orangefs_request_list_waitq, poll_table);
826 if (!list_empty(&orangefs_request_list))
827 poll_revent_mask |= POLL_IN;
828 return poll_revent_mask;
831 const struct file_operations orangefs_devreq_file_operations = {
832 .owner = THIS_MODULE,
833 .read = orangefs_devreq_read,
834 .write_iter = orangefs_devreq_write_iter,
835 .open = orangefs_devreq_open,
836 .release = orangefs_devreq_release,
837 .unlocked_ioctl = orangefs_devreq_ioctl,
839 #ifdef CONFIG_COMPAT /* CONFIG_COMPAT is in .config */
840 .compat_ioctl = orangefs_devreq_compat_ioctl,
842 .poll = orangefs_devreq_poll