Loading...
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * (C) 2001 Clemson University and The University of Chicago
4 *
5 * Changes by Acxiom Corporation to add protocol version to kernel
6 * communication, Copyright Acxiom Corporation, 2005.
7 *
8 * See COPYING in top-level directory.
9 */
10
11#include "protocol.h"
12#include "orangefs-kernel.h"
13#include "orangefs-dev-proto.h"
14#include "orangefs-bufmap.h"
15#include "orangefs-debugfs.h"
16
17#include <linux/debugfs.h>
18#include <linux/slab.h>
19
20/* this file implements the /dev/pvfs2-req device node */
21
22uint32_t orangefs_userspace_version;
23
24static int open_access_count;
25
26static DEFINE_MUTEX(devreq_mutex);
27
28#define DUMP_DEVICE_ERROR() \
29do { \
30 gossip_err("*****************************************************\n");\
31 gossip_err("ORANGEFS Device Error: You cannot open the device file "); \
32 gossip_err("\n/dev/%s more than once. Please make sure that\nthere " \
33 "are no ", ORANGEFS_REQDEVICE_NAME); \
34 gossip_err("instances of a program using this device\ncurrently " \
35 "running. (You must verify this!)\n"); \
36 gossip_err("For example, you can use the lsof program as follows:\n");\
37 gossip_err("'lsof | grep %s' (run this as root)\n", \
38 ORANGEFS_REQDEVICE_NAME); \
39 gossip_err(" open_access_count = %d\n", open_access_count); \
40 gossip_err("*****************************************************\n");\
41} while (0)
42
43static int hash_func(__u64 tag, int table_size)
44{
45 return do_div(tag, (unsigned int)table_size);
46}
47
48static void orangefs_devreq_add_op(struct orangefs_kernel_op_s *op)
49{
50 int index = hash_func(op->tag, hash_table_size);
51
52 list_add_tail(&op->list, &orangefs_htable_ops_in_progress[index]);
53}
54
55/*
56 * find the op with this tag and remove it from the in progress
57 * hash table.
58 */
59static struct orangefs_kernel_op_s *orangefs_devreq_remove_op(__u64 tag)
60{
61 struct orangefs_kernel_op_s *op, *next;
62 int index;
63
64 index = hash_func(tag, hash_table_size);
65
66 spin_lock(&orangefs_htable_ops_in_progress_lock);
67 list_for_each_entry_safe(op,
68 next,
69 &orangefs_htable_ops_in_progress[index],
70 list) {
71 if (op->tag == tag && !op_state_purged(op) &&
72 !op_state_given_up(op)) {
73 list_del_init(&op->list);
74 spin_unlock(&orangefs_htable_ops_in_progress_lock);
75 return op;
76 }
77 }
78
79 spin_unlock(&orangefs_htable_ops_in_progress_lock);
80 return NULL;
81}
82
83/* Returns whether any FS are still pending remounted */
84static int mark_all_pending_mounts(void)
85{
86 int unmounted = 1;
87 struct orangefs_sb_info_s *orangefs_sb = NULL;
88
89 spin_lock(&orangefs_superblocks_lock);
90 list_for_each_entry(orangefs_sb, &orangefs_superblocks, list) {
91 /* All of these file system require a remount */
92 orangefs_sb->mount_pending = 1;
93 unmounted = 0;
94 }
95 spin_unlock(&orangefs_superblocks_lock);
96 return unmounted;
97}
98
99/*
100 * Determine if a given file system needs to be remounted or not
101 * Returns -1 on error
102 * 0 if already mounted
103 * 1 if needs remount
104 */
105static int fs_mount_pending(__s32 fsid)
106{
107 int mount_pending = -1;
108 struct orangefs_sb_info_s *orangefs_sb = NULL;
109
110 spin_lock(&orangefs_superblocks_lock);
111 list_for_each_entry(orangefs_sb, &orangefs_superblocks, list) {
112 if (orangefs_sb->fs_id == fsid) {
113 mount_pending = orangefs_sb->mount_pending;
114 break;
115 }
116 }
117 spin_unlock(&orangefs_superblocks_lock);
118 return mount_pending;
119}
120
121static int orangefs_devreq_open(struct inode *inode, struct file *file)
122{
123 int ret = -EINVAL;
124
125 /* in order to ensure that the filesystem driver sees correct UIDs */
126 if (file->f_cred->user_ns != &init_user_ns) {
127 gossip_err("%s: device cannot be opened outside init_user_ns\n",
128 __func__);
129 goto out;
130 }
131
132 if (!(file->f_flags & O_NONBLOCK)) {
133 gossip_err("%s: device cannot be opened in blocking mode\n",
134 __func__);
135 goto out;
136 }
137 ret = -EACCES;
138 gossip_debug(GOSSIP_DEV_DEBUG, "client-core: opening device\n");
139 mutex_lock(&devreq_mutex);
140
141 if (open_access_count == 0) {
142 open_access_count = 1;
143 ret = 0;
144 } else {
145 DUMP_DEVICE_ERROR();
146 }
147 mutex_unlock(&devreq_mutex);
148
149out:
150
151 gossip_debug(GOSSIP_DEV_DEBUG,
152 "pvfs2-client-core: open device complete (ret = %d)\n",
153 ret);
154 return ret;
155}
156
157/* Function for read() callers into the device */
158static ssize_t orangefs_devreq_read(struct file *file,
159 char __user *buf,
160 size_t count, loff_t *offset)
161{
162 struct orangefs_kernel_op_s *op, *temp;
163 __s32 proto_ver = ORANGEFS_KERNEL_PROTO_VERSION;
164 static __s32 magic = ORANGEFS_DEVREQ_MAGIC;
165 struct orangefs_kernel_op_s *cur_op;
166 unsigned long ret;
167
168 /* We do not support blocking IO. */
169 if (!(file->f_flags & O_NONBLOCK)) {
170 gossip_err("%s: blocking read from client-core.\n",
171 __func__);
172 return -EINVAL;
173 }
174
175 /*
176 * The client will do an ioctl to find MAX_DEV_REQ_UPSIZE, then
177 * always read with that size buffer.
178 */
179 if (count != MAX_DEV_REQ_UPSIZE) {
180 gossip_err("orangefs: client-core tried to read wrong size\n");
181 return -EINVAL;
182 }
183
184 /* Check for an empty list before locking. */
185 if (list_empty(&orangefs_request_list))
186 return -EAGAIN;
187
188restart:
189 cur_op = NULL;
190 /* Get next op (if any) from top of list. */
191 spin_lock(&orangefs_request_list_lock);
192 list_for_each_entry_safe(op, temp, &orangefs_request_list, list) {
193 __s32 fsid;
194 /* This lock is held past the end of the loop when we break. */
195 spin_lock(&op->lock);
196 if (unlikely(op_state_purged(op) || op_state_given_up(op))) {
197 spin_unlock(&op->lock);
198 continue;
199 }
200
201 fsid = fsid_of_op(op);
202 if (fsid != ORANGEFS_FS_ID_NULL) {
203 int ret;
204 /* Skip ops whose filesystem needs to be mounted. */
205 ret = fs_mount_pending(fsid);
206 if (ret == 1) {
207 gossip_debug(GOSSIP_DEV_DEBUG,
208 "%s: mount pending, skipping op tag "
209 "%llu %s\n",
210 __func__,
211 llu(op->tag),
212 get_opname_string(op));
213 spin_unlock(&op->lock);
214 continue;
215 /*
216 * Skip ops whose filesystem we don't know about unless
217 * it is being mounted or unmounted. It is possible for
218 * a filesystem we don't know about to be unmounted if
219 * it fails to mount in the kernel after userspace has
220 * been sent the mount request.
221 */
222 /* XXX: is there a better way to detect this? */
223 } else if (ret == -1 &&
224 !(op->upcall.type ==
225 ORANGEFS_VFS_OP_FS_MOUNT ||
226 op->upcall.type ==
227 ORANGEFS_VFS_OP_GETATTR ||
228 op->upcall.type ==
229 ORANGEFS_VFS_OP_FS_UMOUNT)) {
230 gossip_debug(GOSSIP_DEV_DEBUG,
231 "orangefs: skipping op tag %llu %s\n",
232 llu(op->tag), get_opname_string(op));
233 gossip_err(
234 "orangefs: ERROR: fs_mount_pending %d\n",
235 fsid);
236 spin_unlock(&op->lock);
237 continue;
238 }
239 }
240 /*
241 * Either this op does not pertain to a filesystem, is mounting
242 * a filesystem, or pertains to a mounted filesystem. Let it
243 * through.
244 */
245 cur_op = op;
246 break;
247 }
248
249 /*
250 * At this point we either have a valid op and can continue or have not
251 * found an op and must ask the client to try again later.
252 */
253 if (!cur_op) {
254 spin_unlock(&orangefs_request_list_lock);
255 return -EAGAIN;
256 }
257
258 gossip_debug(GOSSIP_DEV_DEBUG, "%s: reading op tag %llu %s\n",
259 __func__,
260 llu(cur_op->tag),
261 get_opname_string(cur_op));
262
263 /*
264 * Such an op should never be on the list in the first place. If so, we
265 * will abort.
266 */
267 if (op_state_in_progress(cur_op) || op_state_serviced(cur_op)) {
268 gossip_err("orangefs: ERROR: Current op already queued.\n");
269 list_del_init(&cur_op->list);
270 spin_unlock(&cur_op->lock);
271 spin_unlock(&orangefs_request_list_lock);
272 return -EAGAIN;
273 }
274
275 list_del_init(&cur_op->list);
276 spin_unlock(&orangefs_request_list_lock);
277
278 spin_unlock(&cur_op->lock);
279
280 /* Push the upcall out. */
281 ret = copy_to_user(buf, &proto_ver, sizeof(__s32));
282 if (ret != 0)
283 goto error;
284 ret = copy_to_user(buf + sizeof(__s32), &magic, sizeof(__s32));
285 if (ret != 0)
286 goto error;
287 ret = copy_to_user(buf + 2 * sizeof(__s32),
288 &cur_op->tag,
289 sizeof(__u64));
290 if (ret != 0)
291 goto error;
292 ret = copy_to_user(buf + 2 * sizeof(__s32) + sizeof(__u64),
293 &cur_op->upcall,
294 sizeof(struct orangefs_upcall_s));
295 if (ret != 0)
296 goto error;
297
298 spin_lock(&orangefs_htable_ops_in_progress_lock);
299 spin_lock(&cur_op->lock);
300 if (unlikely(op_state_given_up(cur_op))) {
301 spin_unlock(&cur_op->lock);
302 spin_unlock(&orangefs_htable_ops_in_progress_lock);
303 complete(&cur_op->waitq);
304 goto restart;
305 }
306
307 /*
308 * Set the operation to be in progress and move it between lists since
309 * it has been sent to the client.
310 */
311 set_op_state_inprogress(cur_op);
312 gossip_debug(GOSSIP_DEV_DEBUG,
313 "%s: 1 op:%s: op_state:%d: process:%s:\n",
314 __func__,
315 get_opname_string(cur_op),
316 cur_op->op_state,
317 current->comm);
318 orangefs_devreq_add_op(cur_op);
319 spin_unlock(&cur_op->lock);
320 spin_unlock(&orangefs_htable_ops_in_progress_lock);
321
322 /* The client only asks to read one size buffer. */
323 return MAX_DEV_REQ_UPSIZE;
324error:
325 /*
326 * We were unable to copy the op data to the client. Put the op back in
327 * list. If client has crashed, the op will be purged later when the
328 * device is released.
329 */
330 gossip_err("orangefs: Failed to copy data to user space\n");
331 spin_lock(&orangefs_request_list_lock);
332 spin_lock(&cur_op->lock);
333 if (likely(!op_state_given_up(cur_op))) {
334 set_op_state_waiting(cur_op);
335 gossip_debug(GOSSIP_DEV_DEBUG,
336 "%s: 2 op:%s: op_state:%d: process:%s:\n",
337 __func__,
338 get_opname_string(cur_op),
339 cur_op->op_state,
340 current->comm);
341 list_add(&cur_op->list, &orangefs_request_list);
342 spin_unlock(&cur_op->lock);
343 } else {
344 spin_unlock(&cur_op->lock);
345 complete(&cur_op->waitq);
346 }
347 spin_unlock(&orangefs_request_list_lock);
348 return -EFAULT;
349}
350
351/*
352 * Function for writev() callers into the device.
353 *
354 * Userspace should have written:
355 * - __u32 version
356 * - __u32 magic
357 * - __u64 tag
358 * - struct orangefs_downcall_s
359 * - trailer buffer (in the case of READDIR operations)
360 */
361static ssize_t orangefs_devreq_write_iter(struct kiocb *iocb,
362 struct iov_iter *iter)
363{
364 ssize_t ret;
365 struct orangefs_kernel_op_s *op = NULL;
366 struct {
367 __u32 version;
368 __u32 magic;
369 __u64 tag;
370 } head;
371 int total = ret = iov_iter_count(iter);
372 int downcall_size = sizeof(struct orangefs_downcall_s);
373 int head_size = sizeof(head);
374
375 gossip_debug(GOSSIP_DEV_DEBUG, "%s: total:%d: ret:%zd:\n",
376 __func__,
377 total,
378 ret);
379
380 if (total < MAX_DEV_REQ_DOWNSIZE) {
381 gossip_err("%s: total:%d: must be at least:%u:\n",
382 __func__,
383 total,
384 (unsigned int) MAX_DEV_REQ_DOWNSIZE);
385 return -EFAULT;
386 }
387
388 if (!copy_from_iter_full(&head, head_size, iter)) {
389 gossip_err("%s: failed to copy head.\n", __func__);
390 return -EFAULT;
391 }
392
393 if (head.version < ORANGEFS_MINIMUM_USERSPACE_VERSION) {
394 gossip_err("%s: userspace claims version"
395 "%d, minimum version required: %d.\n",
396 __func__,
397 head.version,
398 ORANGEFS_MINIMUM_USERSPACE_VERSION);
399 return -EPROTO;
400 }
401
402 if (head.magic != ORANGEFS_DEVREQ_MAGIC) {
403 gossip_err("Error: Device magic number does not match.\n");
404 return -EPROTO;
405 }
406
407 if (!orangefs_userspace_version) {
408 orangefs_userspace_version = head.version;
409 } else if (orangefs_userspace_version != head.version) {
410 gossip_err("Error: userspace version changes\n");
411 return -EPROTO;
412 }
413
414 /* remove the op from the in progress hash table */
415 op = orangefs_devreq_remove_op(head.tag);
416 if (!op) {
417 gossip_debug(GOSSIP_DEV_DEBUG,
418 "%s: No one's waiting for tag %llu\n",
419 __func__, llu(head.tag));
420 return ret;
421 }
422
423 if (!copy_from_iter_full(&op->downcall, downcall_size, iter)) {
424 gossip_err("%s: failed to copy downcall.\n", __func__);
425 goto Efault;
426 }
427
428 if (op->downcall.status)
429 goto wakeup;
430
431 /*
432 * We've successfully peeled off the head and the downcall.
433 * Something has gone awry if total doesn't equal the
434 * sum of head_size, downcall_size and trailer_size.
435 */
436 if ((head_size + downcall_size + op->downcall.trailer_size) != total) {
437 gossip_err("%s: funky write, head_size:%d"
438 ": downcall_size:%d: trailer_size:%lld"
439 ": total size:%d:\n",
440 __func__,
441 head_size,
442 downcall_size,
443 op->downcall.trailer_size,
444 total);
445 goto Efault;
446 }
447
448 /* Only READDIR operations should have trailers. */
449 if ((op->downcall.type != ORANGEFS_VFS_OP_READDIR) &&
450 (op->downcall.trailer_size != 0)) {
451 gossip_err("%s: %x operation with trailer.",
452 __func__,
453 op->downcall.type);
454 goto Efault;
455 }
456
457 /* READDIR operations should always have trailers. */
458 if ((op->downcall.type == ORANGEFS_VFS_OP_READDIR) &&
459 (op->downcall.trailer_size == 0)) {
460 gossip_err("%s: %x operation with no trailer.",
461 __func__,
462 op->downcall.type);
463 goto Efault;
464 }
465
466 if (op->downcall.type != ORANGEFS_VFS_OP_READDIR)
467 goto wakeup;
468
469 op->downcall.trailer_buf = vzalloc(op->downcall.trailer_size);
470 if (!op->downcall.trailer_buf)
471 goto Enomem;
472
473 if (!copy_from_iter_full(op->downcall.trailer_buf,
474 op->downcall.trailer_size, iter)) {
475 gossip_err("%s: failed to copy trailer.\n", __func__);
476 vfree(op->downcall.trailer_buf);
477 goto Efault;
478 }
479
480wakeup:
481 /*
482 * Return to vfs waitqueue, and back to service_operation
483 * through wait_for_matching_downcall.
484 */
485 spin_lock(&op->lock);
486 if (unlikely(op_is_cancel(op))) {
487 spin_unlock(&op->lock);
488 put_cancel(op);
489 } else if (unlikely(op_state_given_up(op))) {
490 spin_unlock(&op->lock);
491 complete(&op->waitq);
492 } else {
493 set_op_state_serviced(op);
494 gossip_debug(GOSSIP_DEV_DEBUG,
495 "%s: op:%s: op_state:%d: process:%s:\n",
496 __func__,
497 get_opname_string(op),
498 op->op_state,
499 current->comm);
500 spin_unlock(&op->lock);
501 }
502 return ret;
503
504Efault:
505 op->downcall.status = -(ORANGEFS_ERROR_BIT | 9);
506 ret = -EFAULT;
507 goto wakeup;
508
509Enomem:
510 op->downcall.status = -(ORANGEFS_ERROR_BIT | 8);
511 ret = -ENOMEM;
512 goto wakeup;
513}
514
515/*
516 * NOTE: gets called when the last reference to this device is dropped.
517 * Using the open_access_count variable, we enforce a reference count
518 * on this file so that it can be opened by only one process at a time.
519 * the devreq_mutex is used to make sure all i/o has completed
520 * before we call orangefs_bufmap_finalize, and similar such tricky
521 * situations
522 */
523static int orangefs_devreq_release(struct inode *inode, struct file *file)
524{
525 int unmounted = 0;
526
527 gossip_debug(GOSSIP_DEV_DEBUG,
528 "%s:pvfs2-client-core: exiting, closing device\n",
529 __func__);
530
531 mutex_lock(&devreq_mutex);
532 orangefs_bufmap_finalize();
533
534 open_access_count = -1;
535
536 unmounted = mark_all_pending_mounts();
537 gossip_debug(GOSSIP_DEV_DEBUG, "ORANGEFS Device Close: Filesystem(s) %s\n",
538 (unmounted ? "UNMOUNTED" : "MOUNTED"));
539
540 purge_waiting_ops();
541 purge_inprogress_ops();
542
543 orangefs_bufmap_run_down();
544
545 gossip_debug(GOSSIP_DEV_DEBUG,
546 "pvfs2-client-core: device close complete\n");
547 open_access_count = 0;
548 orangefs_userspace_version = 0;
549 mutex_unlock(&devreq_mutex);
550 return 0;
551}
552
553int is_daemon_in_service(void)
554{
555 int in_service;
556
557 /*
558 * What this function does is checks if client-core is alive
559 * based on the access count we maintain on the device.
560 */
561 mutex_lock(&devreq_mutex);
562 in_service = open_access_count == 1 ? 0 : -EIO;
563 mutex_unlock(&devreq_mutex);
564 return in_service;
565}
566
567bool __is_daemon_in_service(void)
568{
569 return open_access_count == 1;
570}
571
572static inline long check_ioctl_command(unsigned int command)
573{
574 /* Check for valid ioctl codes */
575 if (_IOC_TYPE(command) != ORANGEFS_DEV_MAGIC) {
576 gossip_err("device ioctl magic numbers don't match! Did you rebuild pvfs2-client-core/libpvfs2? [cmd %x, magic %x != %x]\n",
577 command,
578 _IOC_TYPE(command),
579 ORANGEFS_DEV_MAGIC);
580 return -EINVAL;
581 }
582 /* and valid ioctl commands */
583 if (_IOC_NR(command) >= ORANGEFS_DEV_MAXNR || _IOC_NR(command) <= 0) {
584 gossip_err("Invalid ioctl command number [%d >= %d]\n",
585 _IOC_NR(command), ORANGEFS_DEV_MAXNR);
586 return -ENOIOCTLCMD;
587 }
588 return 0;
589}
590
591static long dispatch_ioctl_command(unsigned int command, unsigned long arg)
592{
593 static __s32 magic = ORANGEFS_DEVREQ_MAGIC;
594 static __s32 max_up_size = MAX_DEV_REQ_UPSIZE;
595 static __s32 max_down_size = MAX_DEV_REQ_DOWNSIZE;
596 struct ORANGEFS_dev_map_desc user_desc;
597 int ret = 0;
598 int upstream_kmod = 1;
599 struct orangefs_sb_info_s *orangefs_sb;
600
601 /* mtmoore: add locking here */
602
603 switch (command) {
604 case ORANGEFS_DEV_GET_MAGIC:
605 return ((put_user(magic, (__s32 __user *) arg) == -EFAULT) ?
606 -EIO :
607 0);
608 case ORANGEFS_DEV_GET_MAX_UPSIZE:
609 return ((put_user(max_up_size,
610 (__s32 __user *) arg) == -EFAULT) ?
611 -EIO :
612 0);
613 case ORANGEFS_DEV_GET_MAX_DOWNSIZE:
614 return ((put_user(max_down_size,
615 (__s32 __user *) arg) == -EFAULT) ?
616 -EIO :
617 0);
618 case ORANGEFS_DEV_MAP:
619 ret = copy_from_user(&user_desc,
620 (struct ORANGEFS_dev_map_desc __user *)
621 arg,
622 sizeof(struct ORANGEFS_dev_map_desc));
623 /* WTF -EIO and not -EFAULT? */
624 return ret ? -EIO : orangefs_bufmap_initialize(&user_desc);
625 case ORANGEFS_DEV_REMOUNT_ALL:
626 gossip_debug(GOSSIP_DEV_DEBUG,
627 "%s: got ORANGEFS_DEV_REMOUNT_ALL\n",
628 __func__);
629
630 /*
631 * remount all mounted orangefs volumes to regain the lost
632 * dynamic mount tables (if any) -- NOTE: this is done
633 * without keeping the superblock list locked due to the
634 * upcall/downcall waiting. also, the request mutex is
635 * used to ensure that no operations will be serviced until
636 * all of the remounts are serviced (to avoid ops between
637 * mounts to fail)
638 */
639 ret = mutex_lock_interruptible(&orangefs_request_mutex);
640 if (ret < 0)
641 return ret;
642 gossip_debug(GOSSIP_DEV_DEBUG,
643 "%s: priority remount in progress\n",
644 __func__);
645 spin_lock(&orangefs_superblocks_lock);
646 list_for_each_entry(orangefs_sb, &orangefs_superblocks, list) {
647 /*
648 * We have to drop the spinlock, so entries can be
649 * removed. They can't be freed, though, so we just
650 * keep the forward pointers and zero the back ones -
651 * that way we can get to the rest of the list.
652 */
653 if (!orangefs_sb->list.prev)
654 continue;
655 gossip_debug(GOSSIP_DEV_DEBUG,
656 "%s: Remounting SB %p\n",
657 __func__,
658 orangefs_sb);
659
660 spin_unlock(&orangefs_superblocks_lock);
661 ret = orangefs_remount(orangefs_sb);
662 spin_lock(&orangefs_superblocks_lock);
663 if (ret) {
664 gossip_debug(GOSSIP_DEV_DEBUG,
665 "SB %p remount failed\n",
666 orangefs_sb);
667 break;
668 }
669 }
670 spin_unlock(&orangefs_superblocks_lock);
671 gossip_debug(GOSSIP_DEV_DEBUG,
672 "%s: priority remount complete\n",
673 __func__);
674 mutex_unlock(&orangefs_request_mutex);
675 return ret;
676
677 case ORANGEFS_DEV_UPSTREAM:
678 ret = copy_to_user((void __user *)arg,
679 &upstream_kmod,
680 sizeof(upstream_kmod));
681
682 if (ret != 0)
683 return -EIO;
684 else
685 return ret;
686
687 case ORANGEFS_DEV_CLIENT_MASK:
688 return orangefs_debugfs_new_client_mask((void __user *)arg);
689 case ORANGEFS_DEV_CLIENT_STRING:
690 return orangefs_debugfs_new_client_string((void __user *)arg);
691 case ORANGEFS_DEV_DEBUG:
692 return orangefs_debugfs_new_debug((void __user *)arg);
693 default:
694 return -ENOIOCTLCMD;
695 }
696 return -ENOIOCTLCMD;
697}
698
699static long orangefs_devreq_ioctl(struct file *file,
700 unsigned int command, unsigned long arg)
701{
702 long ret;
703
704 /* Check for properly constructed commands */
705 ret = check_ioctl_command(command);
706 if (ret < 0)
707 return (int)ret;
708
709 return (int)dispatch_ioctl_command(command, arg);
710}
711
712#ifdef CONFIG_COMPAT /* CONFIG_COMPAT is in .config */
713
714/* Compat structure for the ORANGEFS_DEV_MAP ioctl */
715struct ORANGEFS_dev_map_desc32 {
716 compat_uptr_t ptr;
717 __s32 total_size;
718 __s32 size;
719 __s32 count;
720};
721
722/*
723 * 32 bit user-space apps' ioctl handlers when kernel modules
724 * is compiled as a 64 bit one
725 */
726static long orangefs_devreq_compat_ioctl(struct file *filp, unsigned int cmd,
727 unsigned long args)
728{
729 long ret;
730
731 /* Check for properly constructed commands */
732 ret = check_ioctl_command(cmd);
733 if (ret < 0)
734 return ret;
735 if (cmd == ORANGEFS_DEV_MAP) {
736 struct ORANGEFS_dev_map_desc desc;
737 struct ORANGEFS_dev_map_desc32 d32;
738
739 if (copy_from_user(&d32, (void __user *)args, sizeof(d32)))
740 return -EFAULT;
741
742 desc.ptr = compat_ptr(d32.ptr);
743 desc.total_size = d32.total_size;
744 desc.size = d32.size;
745 desc.count = d32.count;
746 return orangefs_bufmap_initialize(&desc);
747 }
748 /* no other ioctl requires translation */
749 return dispatch_ioctl_command(cmd, args);
750}
751
752#endif /* CONFIG_COMPAT is in .config */
753
754static __poll_t orangefs_devreq_poll(struct file *file,
755 struct poll_table_struct *poll_table)
756{
757 __poll_t poll_revent_mask = 0;
758
759 poll_wait(file, &orangefs_request_list_waitq, poll_table);
760
761 if (!list_empty(&orangefs_request_list))
762 poll_revent_mask |= EPOLLIN;
763 return poll_revent_mask;
764}
765
766/* the assigned character device major number */
767static int orangefs_dev_major;
768
769static const struct file_operations orangefs_devreq_file_operations = {
770 .owner = THIS_MODULE,
771 .read = orangefs_devreq_read,
772 .write_iter = orangefs_devreq_write_iter,
773 .open = orangefs_devreq_open,
774 .release = orangefs_devreq_release,
775 .unlocked_ioctl = orangefs_devreq_ioctl,
776
777#ifdef CONFIG_COMPAT /* CONFIG_COMPAT is in .config */
778 .compat_ioctl = orangefs_devreq_compat_ioctl,
779#endif
780 .poll = orangefs_devreq_poll
781};
782
783/*
784 * Initialize orangefs device specific state:
785 * Must be called at module load time only
786 */
787int orangefs_dev_init(void)
788{
789 /* register orangefs-req device */
790 orangefs_dev_major = register_chrdev(0,
791 ORANGEFS_REQDEVICE_NAME,
792 &orangefs_devreq_file_operations);
793 if (orangefs_dev_major < 0) {
794 gossip_debug(GOSSIP_DEV_DEBUG,
795 "Failed to register /dev/%s (error %d)\n",
796 ORANGEFS_REQDEVICE_NAME, orangefs_dev_major);
797 return orangefs_dev_major;
798 }
799
800 gossip_debug(GOSSIP_DEV_DEBUG,
801 "*** /dev/%s character device registered ***\n",
802 ORANGEFS_REQDEVICE_NAME);
803 gossip_debug(GOSSIP_DEV_DEBUG, "'mknod /dev/%s c %d 0'.\n",
804 ORANGEFS_REQDEVICE_NAME, orangefs_dev_major);
805 return 0;
806}
807
808void orangefs_dev_cleanup(void)
809{
810 unregister_chrdev(orangefs_dev_major, ORANGEFS_REQDEVICE_NAME);
811 gossip_debug(GOSSIP_DEV_DEBUG,
812 "*** /dev/%s character device unregistered ***\n",
813 ORANGEFS_REQDEVICE_NAME);
814}
1/*
2 * (C) 2001 Clemson University and The University of Chicago
3 *
4 * Changes by Acxiom Corporation to add protocol version to kernel
5 * communication, Copyright Acxiom Corporation, 2005.
6 *
7 * See COPYING in top-level directory.
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/* this file implements the /dev/pvfs2-req device node */
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 * find the op with this tag and remove it from the in progress
56 * hash table.
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/* Returns whether any FS are still pending remounted */
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 /* All of these file system require a remount */
91 orangefs_sb->mount_pending = 1;
92 unmounted = 0;
93 }
94 spin_unlock(&orangefs_superblocks_lock);
95 return unmounted;
96}
97
98/*
99 * Determine if a given file system needs to be remounted or not
100 * Returns -1 on error
101 * 0 if already mounted
102 * 1 if needs remount
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 /* 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",
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/* Function for read() callers into the device */
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 /* We do not support blocking IO. */
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 * The client will do an ioctl to find MAX_DEV_REQ_UPSIZE, then
176 * always read with that size buffer.
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 /* 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) {
187 __s32 fsid;
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);
192 continue;
193 }
194
195 fsid = fsid_of_op(op);
196 if (fsid != ORANGEFS_FS_ID_NULL) {
197 int ret;
198 /* Skip ops whose filesystem needs to be mounted. */
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 * Skip ops whose filesystem we don't know about unless
211 * it is being mounted.
212 */
213 /* XXX: is there a better way to detect this? */
214 } else if (ret == -1 &&
215 !(op->upcall.type ==
216 ORANGEFS_VFS_OP_FS_MOUNT ||
217 op->upcall.type ==
218 ORANGEFS_VFS_OP_GETATTR)) {
219 gossip_debug(GOSSIP_DEV_DEBUG,
220 "orangefs: skipping op tag %llu %s\n",
221 llu(op->tag), get_opname_string(op));
222 gossip_err(
223 "orangefs: ERROR: fs_mount_pending %d\n",
224 fsid);
225 spin_unlock(&op->lock);
226 continue;
227 }
228 }
229 /*
230 * Either this op does not pertain to a filesystem, is mounting
231 * a filesystem, or pertains to a mounted filesystem. Let it
232 * through.
233 */
234 cur_op = op;
235 break;
236 }
237
238 /*
239 * At this point we either have a valid op and can continue or have not
240 * found an op and must ask the client to try again later.
241 */
242 if (!cur_op) {
243 spin_unlock(&orangefs_request_list_lock);
244 return -EAGAIN;
245 }
246
247 gossip_debug(GOSSIP_DEV_DEBUG, "%s: reading op tag %llu %s\n",
248 __func__,
249 llu(cur_op->tag),
250 get_opname_string(cur_op));
251
252 /*
253 * Such an op should never be on the list in the first place. If so, we
254 * will abort.
255 */
256 if (op_state_in_progress(cur_op) || op_state_serviced(cur_op)) {
257 gossip_err("orangefs: ERROR: Current op already queued.\n");
258 list_del_init(&cur_op->list);
259 spin_unlock(&cur_op->lock);
260 spin_unlock(&orangefs_request_list_lock);
261 return -EAGAIN;
262 }
263
264 list_del_init(&cur_op->list);
265 spin_unlock(&orangefs_request_list_lock);
266
267 spin_unlock(&cur_op->lock);
268
269 /* Push the upcall out. */
270 ret = copy_to_user(buf, &proto_ver, sizeof(__s32));
271 if (ret != 0)
272 goto error;
273 ret = copy_to_user(buf+sizeof(__s32), &magic, sizeof(__s32));
274 if (ret != 0)
275 goto error;
276 ret = copy_to_user(buf+2 * sizeof(__s32), &cur_op->tag, sizeof(__u64));
277 if (ret != 0)
278 goto error;
279 ret = copy_to_user(buf+2*sizeof(__s32)+sizeof(__u64), &cur_op->upcall,
280 sizeof(struct orangefs_upcall_s));
281 if (ret != 0)
282 goto error;
283
284 spin_lock(&orangefs_htable_ops_in_progress_lock);
285 spin_lock(&cur_op->lock);
286 if (unlikely(op_state_given_up(cur_op))) {
287 spin_unlock(&cur_op->lock);
288 spin_unlock(&orangefs_htable_ops_in_progress_lock);
289 complete(&cur_op->waitq);
290 goto restart;
291 }
292
293 /*
294 * Set the operation to be in progress and move it between lists since
295 * it has been sent to the client.
296 */
297 set_op_state_inprogress(cur_op);
298 gossip_debug(GOSSIP_DEV_DEBUG,
299 "%s: 1 op:%s: op_state:%d: process:%s:\n",
300 __func__,
301 get_opname_string(cur_op),
302 cur_op->op_state,
303 current->comm);
304 orangefs_devreq_add_op(cur_op);
305 spin_unlock(&cur_op->lock);
306 spin_unlock(&orangefs_htable_ops_in_progress_lock);
307
308 /* The client only asks to read one size buffer. */
309 return MAX_DEV_REQ_UPSIZE;
310error:
311 /*
312 * We were unable to copy the op data to the client. Put the op back in
313 * list. If client has crashed, the op will be purged later when the
314 * device is released.
315 */
316 gossip_err("orangefs: Failed to copy data to user space\n");
317 spin_lock(&orangefs_request_list_lock);
318 spin_lock(&cur_op->lock);
319 if (likely(!op_state_given_up(cur_op))) {
320 set_op_state_waiting(cur_op);
321 gossip_debug(GOSSIP_DEV_DEBUG,
322 "%s: 2 op:%s: op_state:%d: process:%s:\n",
323 __func__,
324 get_opname_string(cur_op),
325 cur_op->op_state,
326 current->comm);
327 list_add(&cur_op->list, &orangefs_request_list);
328 spin_unlock(&cur_op->lock);
329 } else {
330 spin_unlock(&cur_op->lock);
331 complete(&cur_op->waitq);
332 }
333 spin_unlock(&orangefs_request_list_lock);
334 return -EFAULT;
335}
336
337/*
338 * Function for writev() callers into the device.
339 *
340 * Userspace should have written:
341 * - __u32 version
342 * - __u32 magic
343 * - __u64 tag
344 * - struct orangefs_downcall_s
345 * - trailer buffer (in the case of READDIR operations)
346 */
347static ssize_t orangefs_devreq_write_iter(struct kiocb *iocb,
348 struct iov_iter *iter)
349{
350 ssize_t ret;
351 struct orangefs_kernel_op_s *op = NULL;
352 struct {
353 __u32 version;
354 __u32 magic;
355 __u64 tag;
356 } head;
357 int total = ret = iov_iter_count(iter);
358 int downcall_size = sizeof(struct orangefs_downcall_s);
359 int head_size = sizeof(head);
360
361 gossip_debug(GOSSIP_DEV_DEBUG, "%s: total:%d: ret:%zd:\n",
362 __func__,
363 total,
364 ret);
365
366 if (total < MAX_DEV_REQ_DOWNSIZE) {
367 gossip_err("%s: total:%d: must be at least:%u:\n",
368 __func__,
369 total,
370 (unsigned int) MAX_DEV_REQ_DOWNSIZE);
371 return -EFAULT;
372 }
373
374 if (!copy_from_iter_full(&head, head_size, iter)) {
375 gossip_err("%s: failed to copy head.\n", __func__);
376 return -EFAULT;
377 }
378
379 if (head.version < ORANGEFS_MINIMUM_USERSPACE_VERSION) {
380 gossip_err("%s: userspace claims version"
381 "%d, minimum version required: %d.\n",
382 __func__,
383 head.version,
384 ORANGEFS_MINIMUM_USERSPACE_VERSION);
385 return -EPROTO;
386 }
387
388 if (head.magic != ORANGEFS_DEVREQ_MAGIC) {
389 gossip_err("Error: Device magic number does not match.\n");
390 return -EPROTO;
391 }
392
393 if (!orangefs_userspace_version) {
394 orangefs_userspace_version = head.version;
395 } else if (orangefs_userspace_version != head.version) {
396 gossip_err("Error: userspace version changes\n");
397 return -EPROTO;
398 }
399
400 /* remove the op from the in progress hash table */
401 op = orangefs_devreq_remove_op(head.tag);
402 if (!op) {
403 gossip_debug(GOSSIP_DEV_DEBUG,
404 "%s: No one's waiting for tag %llu\n",
405 __func__, llu(head.tag));
406 return ret;
407 }
408
409 if (!copy_from_iter_full(&op->downcall, downcall_size, iter)) {
410 gossip_err("%s: failed to copy downcall.\n", __func__);
411 goto Efault;
412 }
413
414 if (op->downcall.status)
415 goto wakeup;
416
417 /*
418 * We've successfully peeled off the head and the downcall.
419 * Something has gone awry if total doesn't equal the
420 * sum of head_size, downcall_size and trailer_size.
421 */
422 if ((head_size + downcall_size + op->downcall.trailer_size) != total) {
423 gossip_err("%s: funky write, head_size:%d"
424 ": downcall_size:%d: trailer_size:%lld"
425 ": total size:%d:\n",
426 __func__,
427 head_size,
428 downcall_size,
429 op->downcall.trailer_size,
430 total);
431 goto Efault;
432 }
433
434 /* Only READDIR operations should have trailers. */
435 if ((op->downcall.type != ORANGEFS_VFS_OP_READDIR) &&
436 (op->downcall.trailer_size != 0)) {
437 gossip_err("%s: %x operation with trailer.",
438 __func__,
439 op->downcall.type);
440 goto Efault;
441 }
442
443 /* READDIR operations should always have trailers. */
444 if ((op->downcall.type == ORANGEFS_VFS_OP_READDIR) &&
445 (op->downcall.trailer_size == 0)) {
446 gossip_err("%s: %x operation with no trailer.",
447 __func__,
448 op->downcall.type);
449 goto Efault;
450 }
451
452 if (op->downcall.type != ORANGEFS_VFS_OP_READDIR)
453 goto wakeup;
454
455 op->downcall.trailer_buf =
456 vmalloc(op->downcall.trailer_size);
457 if (op->downcall.trailer_buf == NULL) {
458 gossip_err("%s: failed trailer vmalloc.\n",
459 __func__);
460 goto Enomem;
461 }
462 memset(op->downcall.trailer_buf, 0, op->downcall.trailer_size);
463 if (!copy_from_iter_full(op->downcall.trailer_buf,
464 op->downcall.trailer_size, iter)) {
465 gossip_err("%s: failed to copy trailer.\n", __func__);
466 vfree(op->downcall.trailer_buf);
467 goto Efault;
468 }
469
470wakeup:
471 /*
472 * Return to vfs waitqueue, and back to service_operation
473 * through wait_for_matching_downcall.
474 */
475 spin_lock(&op->lock);
476 if (unlikely(op_is_cancel(op))) {
477 spin_unlock(&op->lock);
478 put_cancel(op);
479 } else if (unlikely(op_state_given_up(op))) {
480 spin_unlock(&op->lock);
481 complete(&op->waitq);
482 } else {
483 set_op_state_serviced(op);
484 gossip_debug(GOSSIP_DEV_DEBUG,
485 "%s: op:%s: op_state:%d: process:%s:\n",
486 __func__,
487 get_opname_string(op),
488 op->op_state,
489 current->comm);
490 spin_unlock(&op->lock);
491 }
492 return ret;
493
494Efault:
495 op->downcall.status = -(ORANGEFS_ERROR_BIT | 9);
496 ret = -EFAULT;
497 goto wakeup;
498
499Enomem:
500 op->downcall.status = -(ORANGEFS_ERROR_BIT | 8);
501 ret = -ENOMEM;
502 goto wakeup;
503}
504
505/*
506 * NOTE: gets called when the last reference to this device is dropped.
507 * Using the open_access_count variable, we enforce a reference count
508 * on this file so that it can be opened by only one process at a time.
509 * the devreq_mutex is used to make sure all i/o has completed
510 * before we call orangefs_bufmap_finalize, and similar such tricky
511 * situations
512 */
513static int orangefs_devreq_release(struct inode *inode, struct file *file)
514{
515 int unmounted = 0;
516
517 gossip_debug(GOSSIP_DEV_DEBUG,
518 "%s:pvfs2-client-core: exiting, closing device\n",
519 __func__);
520
521 mutex_lock(&devreq_mutex);
522 orangefs_bufmap_finalize();
523
524 open_access_count = -1;
525
526 unmounted = mark_all_pending_mounts();
527 gossip_debug(GOSSIP_DEV_DEBUG, "ORANGEFS Device Close: Filesystem(s) %s\n",
528 (unmounted ? "UNMOUNTED" : "MOUNTED"));
529
530 purge_waiting_ops();
531 purge_inprogress_ops();
532
533 orangefs_bufmap_run_down();
534
535 gossip_debug(GOSSIP_DEV_DEBUG,
536 "pvfs2-client-core: device close complete\n");
537 open_access_count = 0;
538 orangefs_userspace_version = 0;
539 mutex_unlock(&devreq_mutex);
540 return 0;
541}
542
543int is_daemon_in_service(void)
544{
545 int in_service;
546
547 /*
548 * What this function does is checks if client-core is alive
549 * based on the access count we maintain on the device.
550 */
551 mutex_lock(&devreq_mutex);
552 in_service = open_access_count == 1 ? 0 : -EIO;
553 mutex_unlock(&devreq_mutex);
554 return in_service;
555}
556
557bool __is_daemon_in_service(void)
558{
559 return open_access_count == 1;
560}
561
562static inline long check_ioctl_command(unsigned int command)
563{
564 /* Check for valid ioctl codes */
565 if (_IOC_TYPE(command) != ORANGEFS_DEV_MAGIC) {
566 gossip_err("device ioctl magic numbers don't match! Did you rebuild pvfs2-client-core/libpvfs2? [cmd %x, magic %x != %x]\n",
567 command,
568 _IOC_TYPE(command),
569 ORANGEFS_DEV_MAGIC);
570 return -EINVAL;
571 }
572 /* and valid ioctl commands */
573 if (_IOC_NR(command) >= ORANGEFS_DEV_MAXNR || _IOC_NR(command) <= 0) {
574 gossip_err("Invalid ioctl command number [%d >= %d]\n",
575 _IOC_NR(command), ORANGEFS_DEV_MAXNR);
576 return -ENOIOCTLCMD;
577 }
578 return 0;
579}
580
581static long dispatch_ioctl_command(unsigned int command, unsigned long arg)
582{
583 static __s32 magic = ORANGEFS_DEVREQ_MAGIC;
584 static __s32 max_up_size = MAX_DEV_REQ_UPSIZE;
585 static __s32 max_down_size = MAX_DEV_REQ_DOWNSIZE;
586 struct ORANGEFS_dev_map_desc user_desc;
587 int ret = 0;
588 int upstream_kmod = 1;
589 struct orangefs_sb_info_s *orangefs_sb;
590
591 /* mtmoore: add locking here */
592
593 switch (command) {
594 case ORANGEFS_DEV_GET_MAGIC:
595 return ((put_user(magic, (__s32 __user *) arg) == -EFAULT) ?
596 -EIO :
597 0);
598 case ORANGEFS_DEV_GET_MAX_UPSIZE:
599 return ((put_user(max_up_size,
600 (__s32 __user *) arg) == -EFAULT) ?
601 -EIO :
602 0);
603 case ORANGEFS_DEV_GET_MAX_DOWNSIZE:
604 return ((put_user(max_down_size,
605 (__s32 __user *) arg) == -EFAULT) ?
606 -EIO :
607 0);
608 case ORANGEFS_DEV_MAP:
609 ret = copy_from_user(&user_desc,
610 (struct ORANGEFS_dev_map_desc __user *)
611 arg,
612 sizeof(struct ORANGEFS_dev_map_desc));
613 /* WTF -EIO and not -EFAULT? */
614 return ret ? -EIO : orangefs_bufmap_initialize(&user_desc);
615 case ORANGEFS_DEV_REMOUNT_ALL:
616 gossip_debug(GOSSIP_DEV_DEBUG,
617 "%s: got ORANGEFS_DEV_REMOUNT_ALL\n",
618 __func__);
619
620 /*
621 * remount all mounted orangefs volumes to regain the lost
622 * dynamic mount tables (if any) -- NOTE: this is done
623 * without keeping the superblock list locked due to the
624 * upcall/downcall waiting. also, the request mutex is
625 * used to ensure that no operations will be serviced until
626 * all of the remounts are serviced (to avoid ops between
627 * mounts to fail)
628 */
629 ret = mutex_lock_interruptible(&orangefs_request_mutex);
630 if (ret < 0)
631 return ret;
632 gossip_debug(GOSSIP_DEV_DEBUG,
633 "%s: priority remount in progress\n",
634 __func__);
635 spin_lock(&orangefs_superblocks_lock);
636 list_for_each_entry(orangefs_sb, &orangefs_superblocks, list) {
637 /*
638 * We have to drop the spinlock, so entries can be
639 * removed. They can't be freed, though, so we just
640 * keep the forward pointers and zero the back ones -
641 * that way we can get to the rest of the list.
642 */
643 if (!orangefs_sb->list.prev)
644 continue;
645 gossip_debug(GOSSIP_DEV_DEBUG,
646 "%s: Remounting SB %p\n",
647 __func__,
648 orangefs_sb);
649
650 spin_unlock(&orangefs_superblocks_lock);
651 ret = orangefs_remount(orangefs_sb);
652 spin_lock(&orangefs_superblocks_lock);
653 if (ret) {
654 gossip_debug(GOSSIP_DEV_DEBUG,
655 "SB %p remount failed\n",
656 orangefs_sb);
657 break;
658 }
659 }
660 spin_unlock(&orangefs_superblocks_lock);
661 gossip_debug(GOSSIP_DEV_DEBUG,
662 "%s: priority remount complete\n",
663 __func__);
664 mutex_unlock(&orangefs_request_mutex);
665 return ret;
666
667 case ORANGEFS_DEV_UPSTREAM:
668 ret = copy_to_user((void __user *)arg,
669 &upstream_kmod,
670 sizeof(upstream_kmod));
671
672 if (ret != 0)
673 return -EIO;
674 else
675 return ret;
676
677 case ORANGEFS_DEV_CLIENT_MASK:
678 return orangefs_debugfs_new_client_mask((void __user *)arg);
679 case ORANGEFS_DEV_CLIENT_STRING:
680 return orangefs_debugfs_new_client_string((void __user *)arg);
681 case ORANGEFS_DEV_DEBUG:
682 return orangefs_debugfs_new_debug((void __user *)arg);
683 default:
684 return -ENOIOCTLCMD;
685 }
686 return -ENOIOCTLCMD;
687}
688
689static long orangefs_devreq_ioctl(struct file *file,
690 unsigned int command, unsigned long arg)
691{
692 long ret;
693
694 /* Check for properly constructed commands */
695 ret = check_ioctl_command(command);
696 if (ret < 0)
697 return (int)ret;
698
699 return (int)dispatch_ioctl_command(command, arg);
700}
701
702#ifdef CONFIG_COMPAT /* CONFIG_COMPAT is in .config */
703
704/* Compat structure for the ORANGEFS_DEV_MAP ioctl */
705struct ORANGEFS_dev_map_desc32 {
706 compat_uptr_t ptr;
707 __s32 total_size;
708 __s32 size;
709 __s32 count;
710};
711
712static unsigned long translate_dev_map26(unsigned long args, long *error)
713{
714 struct ORANGEFS_dev_map_desc32 __user *p32 = (void __user *)args;
715 /*
716 * Depending on the architecture, allocate some space on the
717 * user-call-stack based on our expected layout.
718 */
719 struct ORANGEFS_dev_map_desc __user *p =
720 compat_alloc_user_space(sizeof(*p));
721 compat_uptr_t addr;
722
723 *error = 0;
724 /* get the ptr from the 32 bit user-space */
725 if (get_user(addr, &p32->ptr))
726 goto err;
727 /* try to put that into a 64-bit layout */
728 if (put_user(compat_ptr(addr), &p->ptr))
729 goto err;
730 /* copy the remaining fields */
731 if (copy_in_user(&p->total_size, &p32->total_size, sizeof(__s32)))
732 goto err;
733 if (copy_in_user(&p->size, &p32->size, sizeof(__s32)))
734 goto err;
735 if (copy_in_user(&p->count, &p32->count, sizeof(__s32)))
736 goto err;
737 return (unsigned long)p;
738err:
739 *error = -EFAULT;
740 return 0;
741}
742
743/*
744 * 32 bit user-space apps' ioctl handlers when kernel modules
745 * is compiled as a 64 bit one
746 */
747static long orangefs_devreq_compat_ioctl(struct file *filp, unsigned int cmd,
748 unsigned long args)
749{
750 long ret;
751 unsigned long arg = args;
752
753 /* Check for properly constructed commands */
754 ret = check_ioctl_command(cmd);
755 if (ret < 0)
756 return ret;
757 if (cmd == ORANGEFS_DEV_MAP) {
758 /*
759 * convert the arguments to what we expect internally
760 * in kernel space
761 */
762 arg = translate_dev_map26(args, &ret);
763 if (ret < 0) {
764 gossip_err("Could not translate dev map\n");
765 return ret;
766 }
767 }
768 /* no other ioctl requires translation */
769 return dispatch_ioctl_command(cmd, arg);
770}
771
772#endif /* CONFIG_COMPAT is in .config */
773
774/* the assigned character device major number */
775static int orangefs_dev_major;
776
777/*
778 * Initialize orangefs device specific state:
779 * Must be called at module load time only
780 */
781int orangefs_dev_init(void)
782{
783 /* register orangefs-req device */
784 orangefs_dev_major = register_chrdev(0,
785 ORANGEFS_REQDEVICE_NAME,
786 &orangefs_devreq_file_operations);
787 if (orangefs_dev_major < 0) {
788 gossip_debug(GOSSIP_DEV_DEBUG,
789 "Failed to register /dev/%s (error %d)\n",
790 ORANGEFS_REQDEVICE_NAME, orangefs_dev_major);
791 return orangefs_dev_major;
792 }
793
794 gossip_debug(GOSSIP_DEV_DEBUG,
795 "*** /dev/%s character device registered ***\n",
796 ORANGEFS_REQDEVICE_NAME);
797 gossip_debug(GOSSIP_DEV_DEBUG, "'mknod /dev/%s c %d 0'.\n",
798 ORANGEFS_REQDEVICE_NAME, orangefs_dev_major);
799 return 0;
800}
801
802void orangefs_dev_cleanup(void)
803{
804 unregister_chrdev(orangefs_dev_major, ORANGEFS_REQDEVICE_NAME);
805 gossip_debug(GOSSIP_DEV_DEBUG,
806 "*** /dev/%s character device unregistered ***\n",
807 ORANGEFS_REQDEVICE_NAME);
808}
809
810static unsigned int orangefs_devreq_poll(struct file *file,
811 struct poll_table_struct *poll_table)
812{
813 int poll_revent_mask = 0;
814
815 poll_wait(file, &orangefs_request_list_waitq, poll_table);
816
817 if (!list_empty(&orangefs_request_list))
818 poll_revent_mask |= POLL_IN;
819 return poll_revent_mask;
820}
821
822const struct file_operations orangefs_devreq_file_operations = {
823 .owner = THIS_MODULE,
824 .read = orangefs_devreq_read,
825 .write_iter = orangefs_devreq_write_iter,
826 .open = orangefs_devreq_open,
827 .release = orangefs_devreq_release,
828 .unlocked_ioctl = orangefs_devreq_ioctl,
829
830#ifdef CONFIG_COMPAT /* CONFIG_COMPAT is in .config */
831 .compat_ioctl = orangefs_devreq_compat_ioctl,
832#endif
833 .poll = orangefs_devreq_poll
834};