xref: /openbmc/linux/fs/orangefs/devorangefs-req.c (revision 5d0e4d78)
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 
21 uint32_t orangefs_userspace_version;
22 
23 static int open_access_count;
24 
25 static DEFINE_MUTEX(devreq_mutex);
26 
27 #define DUMP_DEVICE_ERROR()                                                   \
28 do {                                                                          \
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 
42 static int hash_func(__u64 tag, int table_size)
43 {
44 	return do_div(tag, (unsigned int)table_size);
45 }
46 
47 static 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  */
58 static 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 */
83 static 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  */
104 static 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 
120 static 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 
148 out:
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 */
157 static 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 
183 	/* Check for an empty list before locking. */
184 	if (list_empty(&orangefs_request_list))
185 		return -EAGAIN;
186 
187 restart:
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) {
191 		__s32 fsid;
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);
196 			continue;
197 		}
198 
199 		fsid = fsid_of_op(op);
200 		if (fsid != ORANGEFS_FS_ID_NULL) {
201 			int ret;
202 			/* Skip ops whose filesystem needs to be mounted. */
203 			ret = fs_mount_pending(fsid);
204 			if (ret == 1) {
205 				gossip_debug(GOSSIP_DEV_DEBUG,
206 				    "%s: mount pending, skipping op tag "
207 				    "%llu %s\n",
208 				    __func__,
209 				    llu(op->tag),
210 				    get_opname_string(op));
211 				spin_unlock(&op->lock);
212 				continue;
213 			/*
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.
219 			 */
220 			/* XXX: is there a better way to detect this? */
221 			} else if (ret == -1 &&
222 				   !(op->upcall.type ==
223 					ORANGEFS_VFS_OP_FS_MOUNT ||
224 				     op->upcall.type ==
225 					ORANGEFS_VFS_OP_GETATTR ||
226 				     op->upcall.type ==
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));
231 				gossip_err(
232 				    "orangefs: ERROR: fs_mount_pending %d\n",
233 				    fsid);
234 				spin_unlock(&op->lock);
235 				continue;
236 			}
237 		}
238 		/*
239 		 * Either this op does not pertain to a filesystem, is mounting
240 		 * a filesystem, or pertains to a mounted filesystem. Let it
241 		 * through.
242 		 */
243 		cur_op = op;
244 		break;
245 	}
246 
247 	/*
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.
250 	 */
251 	if (!cur_op) {
252 		spin_unlock(&orangefs_request_list_lock);
253 		return -EAGAIN;
254 	}
255 
256 	gossip_debug(GOSSIP_DEV_DEBUG, "%s: reading op tag %llu %s\n",
257 		     __func__,
258 		     llu(cur_op->tag),
259 		     get_opname_string(cur_op));
260 
261 	/*
262 	 * Such an op should never be on the list in the first place. If so, we
263 	 * will abort.
264 	 */
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);
270 		return -EAGAIN;
271 	}
272 
273 	list_del_init(&cur_op->list);
274 	spin_unlock(&orangefs_request_list_lock);
275 
276 	spin_unlock(&cur_op->lock);
277 
278 	/* Push the upcall out. */
279 	ret = copy_to_user(buf, &proto_ver, sizeof(__s32));
280 	if (ret != 0)
281 		goto error;
282 	ret = copy_to_user(buf+sizeof(__s32), &magic, sizeof(__s32));
283 	if (ret != 0)
284 		goto error;
285 	ret = copy_to_user(buf+2 * sizeof(__s32), &cur_op->tag, sizeof(__u64));
286 	if (ret != 0)
287 		goto error;
288 	ret = copy_to_user(buf+2*sizeof(__s32)+sizeof(__u64), &cur_op->upcall,
289 			   sizeof(struct orangefs_upcall_s));
290 	if (ret != 0)
291 		goto error;
292 
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);
299 		goto restart;
300 	}
301 
302 	/*
303 	 * Set the operation to be in progress and move it between lists since
304 	 * it has been sent to the client.
305 	 */
306 	set_op_state_inprogress(cur_op);
307 	gossip_debug(GOSSIP_DEV_DEBUG,
308 		     "%s: 1 op:%s: op_state:%d: process:%s:\n",
309 		     __func__,
310 		     get_opname_string(cur_op),
311 		     cur_op->op_state,
312 		     current->comm);
313 	orangefs_devreq_add_op(cur_op);
314 	spin_unlock(&cur_op->lock);
315 	spin_unlock(&orangefs_htable_ops_in_progress_lock);
316 
317 	/* The client only asks to read one size buffer. */
318 	return MAX_DEV_REQ_UPSIZE;
319 error:
320 	/*
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.
324 	 */
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",
332 			     __func__,
333 			     get_opname_string(cur_op),
334 			     cur_op->op_state,
335 			     current->comm);
336 		list_add(&cur_op->list, &orangefs_request_list);
337 		spin_unlock(&cur_op->lock);
338 	} else {
339 		spin_unlock(&cur_op->lock);
340 		complete(&cur_op->waitq);
341 	}
342 	spin_unlock(&orangefs_request_list_lock);
343 	return -EFAULT;
344 }
345 
346 /*
347  * Function for writev() callers into the device.
348  *
349  * Userspace should have written:
350  *  - __u32 version
351  *  - __u32 magic
352  *  - __u64 tag
353  *  - struct orangefs_downcall_s
354  *  - trailer buffer (in the case of READDIR operations)
355  */
356 static ssize_t orangefs_devreq_write_iter(struct kiocb *iocb,
357 				      struct iov_iter *iter)
358 {
359 	ssize_t ret;
360 	struct orangefs_kernel_op_s *op = NULL;
361 	struct {
362 		__u32 version;
363 		__u32 magic;
364 		__u64 tag;
365 	} head;
366 	int total = ret = iov_iter_count(iter);
367 	int downcall_size = sizeof(struct orangefs_downcall_s);
368 	int head_size = sizeof(head);
369 
370 	gossip_debug(GOSSIP_DEV_DEBUG, "%s: total:%d: ret:%zd:\n",
371 		     __func__,
372 		     total,
373 		     ret);
374 
375         if (total < MAX_DEV_REQ_DOWNSIZE) {
376 		gossip_err("%s: total:%d: must be at least:%u:\n",
377 			   __func__,
378 			   total,
379 			   (unsigned int) MAX_DEV_REQ_DOWNSIZE);
380 		return -EFAULT;
381 	}
382 
383 	if (!copy_from_iter_full(&head, head_size, iter)) {
384 		gossip_err("%s: failed to copy head.\n", __func__);
385 		return -EFAULT;
386 	}
387 
388 	if (head.version < ORANGEFS_MINIMUM_USERSPACE_VERSION) {
389 		gossip_err("%s: userspace claims version"
390 			   "%d, minimum version required: %d.\n",
391 			   __func__,
392 			   head.version,
393 			   ORANGEFS_MINIMUM_USERSPACE_VERSION);
394 		return -EPROTO;
395 	}
396 
397 	if (head.magic != ORANGEFS_DEVREQ_MAGIC) {
398 		gossip_err("Error: Device magic number does not match.\n");
399 		return -EPROTO;
400 	}
401 
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");
406 		return -EPROTO;
407 	}
408 
409 	/* remove the op from the in progress hash table */
410 	op = orangefs_devreq_remove_op(head.tag);
411 	if (!op) {
412 		gossip_debug(GOSSIP_DEV_DEBUG,
413 			     "%s: No one's waiting for tag %llu\n",
414 			     __func__, llu(head.tag));
415 		return ret;
416 	}
417 
418 	if (!copy_from_iter_full(&op->downcall, downcall_size, iter)) {
419 		gossip_err("%s: failed to copy downcall.\n", __func__);
420 		goto Efault;
421 	}
422 
423 	if (op->downcall.status)
424 		goto wakeup;
425 
426 	/*
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.
430 	 */
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",
435 			   __func__,
436 			   head_size,
437 			   downcall_size,
438 			   op->downcall.trailer_size,
439 			   total);
440 		goto Efault;
441 	}
442 
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.",
447 			   __func__,
448 			   op->downcall.type);
449 		goto Efault;
450 	}
451 
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.",
456 			   __func__,
457 			   op->downcall.type);
458 		goto Efault;
459 	}
460 
461 	if (op->downcall.type != ORANGEFS_VFS_OP_READDIR)
462 		goto wakeup;
463 
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",
468 			   __func__);
469 		goto Enomem;
470 	}
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);
476 		goto Efault;
477 	}
478 
479 wakeup:
480 	/*
481 	 * Return to vfs waitqueue, and back to service_operation
482 	 * through wait_for_matching_downcall.
483 	 */
484 	spin_lock(&op->lock);
485 	if (unlikely(op_is_cancel(op))) {
486 		spin_unlock(&op->lock);
487 		put_cancel(op);
488 	} else if (unlikely(op_state_given_up(op))) {
489 		spin_unlock(&op->lock);
490 		complete(&op->waitq);
491 	} else {
492 		set_op_state_serviced(op);
493 		gossip_debug(GOSSIP_DEV_DEBUG,
494 			     "%s: op:%s: op_state:%d: process:%s:\n",
495 			     __func__,
496 			     get_opname_string(op),
497 			     op->op_state,
498 			     current->comm);
499 		spin_unlock(&op->lock);
500 	}
501 	return ret;
502 
503 Efault:
504 	op->downcall.status = -(ORANGEFS_ERROR_BIT | 9);
505 	ret = -EFAULT;
506 	goto wakeup;
507 
508 Enomem:
509 	op->downcall.status = -(ORANGEFS_ERROR_BIT | 8);
510 	ret = -ENOMEM;
511 	goto wakeup;
512 }
513 
514 /*
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
520  * situations
521  */
522 static int orangefs_devreq_release(struct inode *inode, struct file *file)
523 {
524 	int unmounted = 0;
525 
526 	gossip_debug(GOSSIP_DEV_DEBUG,
527 		     "%s:pvfs2-client-core: exiting, closing device\n",
528 		     __func__);
529 
530 	mutex_lock(&devreq_mutex);
531 	orangefs_bufmap_finalize();
532 
533 	open_access_count = -1;
534 
535 	unmounted = mark_all_pending_mounts();
536 	gossip_debug(GOSSIP_DEV_DEBUG, "ORANGEFS Device Close: Filesystem(s) %s\n",
537 		     (unmounted ? "UNMOUNTED" : "MOUNTED"));
538 
539 	purge_waiting_ops();
540 	purge_inprogress_ops();
541 
542 	orangefs_bufmap_run_down();
543 
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);
549 	return 0;
550 }
551 
552 int is_daemon_in_service(void)
553 {
554 	int in_service;
555 
556 	/*
557 	 * What this function does is checks if client-core is alive
558 	 * based on the access count we maintain on the device.
559 	 */
560 	mutex_lock(&devreq_mutex);
561 	in_service = open_access_count == 1 ? 0 : -EIO;
562 	mutex_unlock(&devreq_mutex);
563 	return in_service;
564 }
565 
566 bool __is_daemon_in_service(void)
567 {
568 	return open_access_count == 1;
569 }
570 
571 static inline long check_ioctl_command(unsigned int command)
572 {
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",
576 			command,
577 			_IOC_TYPE(command),
578 			ORANGEFS_DEV_MAGIC);
579 		return -EINVAL;
580 	}
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);
585 		return -ENOIOCTLCMD;
586 	}
587 	return 0;
588 }
589 
590 static long dispatch_ioctl_command(unsigned int command, unsigned long arg)
591 {
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;
596 	int ret = 0;
597 	int upstream_kmod = 1;
598 	struct orangefs_sb_info_s *orangefs_sb;
599 
600 	/* mtmoore: add locking here */
601 
602 	switch (command) {
603 	case ORANGEFS_DEV_GET_MAGIC:
604 		return ((put_user(magic, (__s32 __user *) arg) == -EFAULT) ?
605 			-EIO :
606 			0);
607 	case ORANGEFS_DEV_GET_MAX_UPSIZE:
608 		return ((put_user(max_up_size,
609 				  (__s32 __user *) arg) == -EFAULT) ?
610 					-EIO :
611 					0);
612 	case ORANGEFS_DEV_GET_MAX_DOWNSIZE:
613 		return ((put_user(max_down_size,
614 				  (__s32 __user *) arg) == -EFAULT) ?
615 					-EIO :
616 					0);
617 	case ORANGEFS_DEV_MAP:
618 		ret = copy_from_user(&user_desc,
619 				     (struct ORANGEFS_dev_map_desc __user *)
620 				     arg,
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",
627 			     __func__);
628 
629 		/*
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
636 		 * mounts to fail)
637 		 */
638 		ret = mutex_lock_interruptible(&orangefs_request_mutex);
639 		if (ret < 0)
640 			return ret;
641 		gossip_debug(GOSSIP_DEV_DEBUG,
642 			     "%s: priority remount in progress\n",
643 			     __func__);
644 		spin_lock(&orangefs_superblocks_lock);
645 		list_for_each_entry(orangefs_sb, &orangefs_superblocks, list) {
646 			/*
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.
651 			 */
652 			if (!orangefs_sb->list.prev)
653 				continue;
654 			gossip_debug(GOSSIP_DEV_DEBUG,
655 				     "%s: Remounting SB %p\n",
656 				     __func__,
657 				     orangefs_sb);
658 
659 			spin_unlock(&orangefs_superblocks_lock);
660 			ret = orangefs_remount(orangefs_sb);
661 			spin_lock(&orangefs_superblocks_lock);
662 			if (ret) {
663 				gossip_debug(GOSSIP_DEV_DEBUG,
664 					     "SB %p remount failed\n",
665 					     orangefs_sb);
666 				break;
667 			}
668 		}
669 		spin_unlock(&orangefs_superblocks_lock);
670 		gossip_debug(GOSSIP_DEV_DEBUG,
671 			     "%s: priority remount complete\n",
672 			     __func__);
673 		mutex_unlock(&orangefs_request_mutex);
674 		return ret;
675 
676 	case ORANGEFS_DEV_UPSTREAM:
677 		ret = copy_to_user((void __user *)arg,
678 				    &upstream_kmod,
679 				    sizeof(upstream_kmod));
680 
681 		if (ret != 0)
682 			return -EIO;
683 		else
684 			return ret;
685 
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);
692 	default:
693 		return -ENOIOCTLCMD;
694 	}
695 	return -ENOIOCTLCMD;
696 }
697 
698 static long orangefs_devreq_ioctl(struct file *file,
699 			       unsigned int command, unsigned long arg)
700 {
701 	long ret;
702 
703 	/* Check for properly constructed commands */
704 	ret = check_ioctl_command(command);
705 	if (ret < 0)
706 		return (int)ret;
707 
708 	return (int)dispatch_ioctl_command(command, arg);
709 }
710 
711 #ifdef CONFIG_COMPAT		/* CONFIG_COMPAT is in .config */
712 
713 /*  Compat structure for the ORANGEFS_DEV_MAP ioctl */
714 struct ORANGEFS_dev_map_desc32 {
715 	compat_uptr_t ptr;
716 	__s32 total_size;
717 	__s32 size;
718 	__s32 count;
719 };
720 
721 static unsigned long translate_dev_map26(unsigned long args, long *error)
722 {
723 	struct ORANGEFS_dev_map_desc32 __user *p32 = (void __user *)args;
724 	/*
725 	 * Depending on the architecture, allocate some space on the
726 	 * user-call-stack based on our expected layout.
727 	 */
728 	struct ORANGEFS_dev_map_desc __user *p =
729 	    compat_alloc_user_space(sizeof(*p));
730 	compat_uptr_t addr;
731 
732 	*error = 0;
733 	/* get the ptr from the 32 bit user-space */
734 	if (get_user(addr, &p32->ptr))
735 		goto err;
736 	/* try to put that into a 64-bit layout */
737 	if (put_user(compat_ptr(addr), &p->ptr))
738 		goto err;
739 	/* copy the remaining fields */
740 	if (copy_in_user(&p->total_size, &p32->total_size, sizeof(__s32)))
741 		goto err;
742 	if (copy_in_user(&p->size, &p32->size, sizeof(__s32)))
743 		goto err;
744 	if (copy_in_user(&p->count, &p32->count, sizeof(__s32)))
745 		goto err;
746 	return (unsigned long)p;
747 err:
748 	*error = -EFAULT;
749 	return 0;
750 }
751 
752 /*
753  * 32 bit user-space apps' ioctl handlers when kernel modules
754  * is compiled as a 64 bit one
755  */
756 static long orangefs_devreq_compat_ioctl(struct file *filp, unsigned int cmd,
757 				      unsigned long args)
758 {
759 	long ret;
760 	unsigned long arg = args;
761 
762 	/* Check for properly constructed commands */
763 	ret = check_ioctl_command(cmd);
764 	if (ret < 0)
765 		return ret;
766 	if (cmd == ORANGEFS_DEV_MAP) {
767 		/*
768 		 * convert the arguments to what we expect internally
769 		 * in kernel space
770 		 */
771 		arg = translate_dev_map26(args, &ret);
772 		if (ret < 0) {
773 			gossip_err("Could not translate dev map\n");
774 			return ret;
775 		}
776 	}
777 	/* no other ioctl requires translation */
778 	return dispatch_ioctl_command(cmd, arg);
779 }
780 
781 #endif /* CONFIG_COMPAT is in .config */
782 
783 /* the assigned character device major number */
784 static int orangefs_dev_major;
785 
786 /*
787  * Initialize orangefs device specific state:
788  * Must be called at module load time only
789  */
790 int orangefs_dev_init(void)
791 {
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;
801 	}
802 
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);
808 	return 0;
809 }
810 
811 void orangefs_dev_cleanup(void)
812 {
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);
817 }
818 
819 static unsigned int orangefs_devreq_poll(struct file *file,
820 				      struct poll_table_struct *poll_table)
821 {
822 	int poll_revent_mask = 0;
823 
824 	poll_wait(file, &orangefs_request_list_waitq, poll_table);
825 
826 	if (!list_empty(&orangefs_request_list))
827 		poll_revent_mask |= POLL_IN;
828 	return poll_revent_mask;
829 }
830 
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,
838 
839 #ifdef CONFIG_COMPAT		/* CONFIG_COMPAT is in .config */
840 	.compat_ioctl = orangefs_devreq_compat_ioctl,
841 #endif
842 	.poll = orangefs_devreq_poll
843 };
844