1 /*
2  * This file is subject to the terms and conditions of the GNU General Public
3  * License.  See the file "COPYING" in the main directory of this archive
4  * for more details.
5  *
6  * Copyright (c) 2004-2009 Silicon Graphics, Inc.  All Rights Reserved.
7  */
8 
9 /*
10  * Cross Partition Communication (XPC) channel support.
11  *
12  *	This is the part of XPC that manages the channels and
13  *	sends/receives messages across them to/from other partitions.
14  *
15  */
16 
17 #include <linux/device.h>
18 #include "xpc.h"
19 
20 /*
21  * Process a connect message from a remote partition.
22  *
23  * Note: xpc_process_connect() is expecting to be called with the
24  * spin_lock_irqsave held and will leave it locked upon return.
25  */
26 static void
27 xpc_process_connect(struct xpc_channel *ch, unsigned long *irq_flags)
28 {
29 	enum xp_retval ret;
30 
31 	DBUG_ON(!spin_is_locked(&ch->lock));
32 
33 	if (!(ch->flags & XPC_C_OPENREQUEST) ||
34 	    !(ch->flags & XPC_C_ROPENREQUEST)) {
35 		/* nothing more to do for now */
36 		return;
37 	}
38 	DBUG_ON(!(ch->flags & XPC_C_CONNECTING));
39 
40 	if (!(ch->flags & XPC_C_SETUP)) {
41 		spin_unlock_irqrestore(&ch->lock, *irq_flags);
42 		ret = xpc_arch_ops.setup_msg_structures(ch);
43 		spin_lock_irqsave(&ch->lock, *irq_flags);
44 
45 		if (ret != xpSuccess)
46 			XPC_DISCONNECT_CHANNEL(ch, ret, irq_flags);
47 		else
48 			ch->flags |= XPC_C_SETUP;
49 
50 		if (ch->flags & XPC_C_DISCONNECTING)
51 			return;
52 	}
53 
54 	if (!(ch->flags & XPC_C_OPENREPLY)) {
55 		ch->flags |= XPC_C_OPENREPLY;
56 		xpc_arch_ops.send_chctl_openreply(ch, irq_flags);
57 	}
58 
59 	if (!(ch->flags & XPC_C_ROPENREPLY))
60 		return;
61 
62 	if (!(ch->flags & XPC_C_OPENCOMPLETE)) {
63 		ch->flags |= (XPC_C_OPENCOMPLETE | XPC_C_CONNECTED);
64 		xpc_arch_ops.send_chctl_opencomplete(ch, irq_flags);
65 	}
66 
67 	if (!(ch->flags & XPC_C_ROPENCOMPLETE))
68 		return;
69 
70 	dev_info(xpc_chan, "channel %d to partition %d connected\n",
71 		 ch->number, ch->partid);
72 
73 	ch->flags = (XPC_C_CONNECTED | XPC_C_SETUP);	/* clear all else */
74 }
75 
76 /*
77  * spin_lock_irqsave() is expected to be held on entry.
78  */
79 static void
80 xpc_process_disconnect(struct xpc_channel *ch, unsigned long *irq_flags)
81 {
82 	struct xpc_partition *part = &xpc_partitions[ch->partid];
83 	u32 channel_was_connected = (ch->flags & XPC_C_WASCONNECTED);
84 
85 	DBUG_ON(!spin_is_locked(&ch->lock));
86 
87 	if (!(ch->flags & XPC_C_DISCONNECTING))
88 		return;
89 
90 	DBUG_ON(!(ch->flags & XPC_C_CLOSEREQUEST));
91 
92 	/* make sure all activity has settled down first */
93 
94 	if (atomic_read(&ch->kthreads_assigned) > 0 ||
95 	    atomic_read(&ch->references) > 0) {
96 		return;
97 	}
98 	DBUG_ON((ch->flags & XPC_C_CONNECTEDCALLOUT_MADE) &&
99 		!(ch->flags & XPC_C_DISCONNECTINGCALLOUT_MADE));
100 
101 	if (part->act_state == XPC_P_AS_DEACTIVATING) {
102 		/* can't proceed until the other side disengages from us */
103 		if (xpc_arch_ops.partition_engaged(ch->partid))
104 			return;
105 
106 	} else {
107 
108 		/* as long as the other side is up do the full protocol */
109 
110 		if (!(ch->flags & XPC_C_RCLOSEREQUEST))
111 			return;
112 
113 		if (!(ch->flags & XPC_C_CLOSEREPLY)) {
114 			ch->flags |= XPC_C_CLOSEREPLY;
115 			xpc_arch_ops.send_chctl_closereply(ch, irq_flags);
116 		}
117 
118 		if (!(ch->flags & XPC_C_RCLOSEREPLY))
119 			return;
120 	}
121 
122 	/* wake those waiting for notify completion */
123 	if (atomic_read(&ch->n_to_notify) > 0) {
124 		/* we do callout while holding ch->lock, callout can't block */
125 		xpc_arch_ops.notify_senders_of_disconnect(ch);
126 	}
127 
128 	/* both sides are disconnected now */
129 
130 	if (ch->flags & XPC_C_DISCONNECTINGCALLOUT_MADE) {
131 		spin_unlock_irqrestore(&ch->lock, *irq_flags);
132 		xpc_disconnect_callout(ch, xpDisconnected);
133 		spin_lock_irqsave(&ch->lock, *irq_flags);
134 	}
135 
136 	DBUG_ON(atomic_read(&ch->n_to_notify) != 0);
137 
138 	/* it's now safe to free the channel's message queues */
139 	xpc_arch_ops.teardown_msg_structures(ch);
140 
141 	ch->func = NULL;
142 	ch->key = NULL;
143 	ch->entry_size = 0;
144 	ch->local_nentries = 0;
145 	ch->remote_nentries = 0;
146 	ch->kthreads_assigned_limit = 0;
147 	ch->kthreads_idle_limit = 0;
148 
149 	/*
150 	 * Mark the channel disconnected and clear all other flags, including
151 	 * XPC_C_SETUP (because of call to
152 	 * xpc_arch_ops.teardown_msg_structures()) but not including
153 	 * XPC_C_WDISCONNECT (if it was set).
154 	 */
155 	ch->flags = (XPC_C_DISCONNECTED | (ch->flags & XPC_C_WDISCONNECT));
156 
157 	atomic_dec(&part->nchannels_active);
158 
159 	if (channel_was_connected) {
160 		dev_info(xpc_chan, "channel %d to partition %d disconnected, "
161 			 "reason=%d\n", ch->number, ch->partid, ch->reason);
162 	}
163 
164 	if (ch->flags & XPC_C_WDISCONNECT) {
165 		/* we won't lose the CPU since we're holding ch->lock */
166 		complete(&ch->wdisconnect_wait);
167 	} else if (ch->delayed_chctl_flags) {
168 		if (part->act_state != XPC_P_AS_DEACTIVATING) {
169 			/* time to take action on any delayed chctl flags */
170 			spin_lock(&part->chctl_lock);
171 			part->chctl.flags[ch->number] |=
172 			    ch->delayed_chctl_flags;
173 			spin_unlock(&part->chctl_lock);
174 		}
175 		ch->delayed_chctl_flags = 0;
176 	}
177 }
178 
179 /*
180  * Process a change in the channel's remote connection state.
181  */
182 static void
183 xpc_process_openclose_chctl_flags(struct xpc_partition *part, int ch_number,
184 				  u8 chctl_flags)
185 {
186 	unsigned long irq_flags;
187 	struct xpc_openclose_args *args =
188 	    &part->remote_openclose_args[ch_number];
189 	struct xpc_channel *ch = &part->channels[ch_number];
190 	enum xp_retval reason;
191 	enum xp_retval ret;
192 	int create_kthread = 0;
193 
194 	spin_lock_irqsave(&ch->lock, irq_flags);
195 
196 again:
197 
198 	if ((ch->flags & XPC_C_DISCONNECTED) &&
199 	    (ch->flags & XPC_C_WDISCONNECT)) {
200 		/*
201 		 * Delay processing chctl flags until thread waiting disconnect
202 		 * has had a chance to see that the channel is disconnected.
203 		 */
204 		ch->delayed_chctl_flags |= chctl_flags;
205 		goto out;
206 	}
207 
208 	if (chctl_flags & XPC_CHCTL_CLOSEREQUEST) {
209 
210 		dev_dbg(xpc_chan, "XPC_CHCTL_CLOSEREQUEST (reason=%d) received "
211 			"from partid=%d, channel=%d\n", args->reason,
212 			ch->partid, ch->number);
213 
214 		/*
215 		 * If RCLOSEREQUEST is set, we're probably waiting for
216 		 * RCLOSEREPLY. We should find it and a ROPENREQUEST packed
217 		 * with this RCLOSEREQUEST in the chctl_flags.
218 		 */
219 
220 		if (ch->flags & XPC_C_RCLOSEREQUEST) {
221 			DBUG_ON(!(ch->flags & XPC_C_DISCONNECTING));
222 			DBUG_ON(!(ch->flags & XPC_C_CLOSEREQUEST));
223 			DBUG_ON(!(ch->flags & XPC_C_CLOSEREPLY));
224 			DBUG_ON(ch->flags & XPC_C_RCLOSEREPLY);
225 
226 			DBUG_ON(!(chctl_flags & XPC_CHCTL_CLOSEREPLY));
227 			chctl_flags &= ~XPC_CHCTL_CLOSEREPLY;
228 			ch->flags |= XPC_C_RCLOSEREPLY;
229 
230 			/* both sides have finished disconnecting */
231 			xpc_process_disconnect(ch, &irq_flags);
232 			DBUG_ON(!(ch->flags & XPC_C_DISCONNECTED));
233 			goto again;
234 		}
235 
236 		if (ch->flags & XPC_C_DISCONNECTED) {
237 			if (!(chctl_flags & XPC_CHCTL_OPENREQUEST)) {
238 				if (part->chctl.flags[ch_number] &
239 				    XPC_CHCTL_OPENREQUEST) {
240 
241 					DBUG_ON(ch->delayed_chctl_flags != 0);
242 					spin_lock(&part->chctl_lock);
243 					part->chctl.flags[ch_number] |=
244 					    XPC_CHCTL_CLOSEREQUEST;
245 					spin_unlock(&part->chctl_lock);
246 				}
247 				goto out;
248 			}
249 
250 			XPC_SET_REASON(ch, 0, 0);
251 			ch->flags &= ~XPC_C_DISCONNECTED;
252 
253 			atomic_inc(&part->nchannels_active);
254 			ch->flags |= (XPC_C_CONNECTING | XPC_C_ROPENREQUEST);
255 		}
256 
257 		chctl_flags &= ~(XPC_CHCTL_OPENREQUEST | XPC_CHCTL_OPENREPLY |
258 		    XPC_CHCTL_OPENCOMPLETE);
259 
260 		/*
261 		 * The meaningful CLOSEREQUEST connection state fields are:
262 		 *      reason = reason connection is to be closed
263 		 */
264 
265 		ch->flags |= XPC_C_RCLOSEREQUEST;
266 
267 		if (!(ch->flags & XPC_C_DISCONNECTING)) {
268 			reason = args->reason;
269 			if (reason <= xpSuccess || reason > xpUnknownReason)
270 				reason = xpUnknownReason;
271 			else if (reason == xpUnregistering)
272 				reason = xpOtherUnregistering;
273 
274 			XPC_DISCONNECT_CHANNEL(ch, reason, &irq_flags);
275 
276 			DBUG_ON(chctl_flags & XPC_CHCTL_CLOSEREPLY);
277 			goto out;
278 		}
279 
280 		xpc_process_disconnect(ch, &irq_flags);
281 	}
282 
283 	if (chctl_flags & XPC_CHCTL_CLOSEREPLY) {
284 
285 		dev_dbg(xpc_chan, "XPC_CHCTL_CLOSEREPLY received from partid="
286 			"%d, channel=%d\n", ch->partid, ch->number);
287 
288 		if (ch->flags & XPC_C_DISCONNECTED) {
289 			DBUG_ON(part->act_state != XPC_P_AS_DEACTIVATING);
290 			goto out;
291 		}
292 
293 		DBUG_ON(!(ch->flags & XPC_C_CLOSEREQUEST));
294 
295 		if (!(ch->flags & XPC_C_RCLOSEREQUEST)) {
296 			if (part->chctl.flags[ch_number] &
297 			    XPC_CHCTL_CLOSEREQUEST) {
298 
299 				DBUG_ON(ch->delayed_chctl_flags != 0);
300 				spin_lock(&part->chctl_lock);
301 				part->chctl.flags[ch_number] |=
302 				    XPC_CHCTL_CLOSEREPLY;
303 				spin_unlock(&part->chctl_lock);
304 			}
305 			goto out;
306 		}
307 
308 		ch->flags |= XPC_C_RCLOSEREPLY;
309 
310 		if (ch->flags & XPC_C_CLOSEREPLY) {
311 			/* both sides have finished disconnecting */
312 			xpc_process_disconnect(ch, &irq_flags);
313 		}
314 	}
315 
316 	if (chctl_flags & XPC_CHCTL_OPENREQUEST) {
317 
318 		dev_dbg(xpc_chan, "XPC_CHCTL_OPENREQUEST (entry_size=%d, "
319 			"local_nentries=%d) received from partid=%d, "
320 			"channel=%d\n", args->entry_size, args->local_nentries,
321 			ch->partid, ch->number);
322 
323 		if (part->act_state == XPC_P_AS_DEACTIVATING ||
324 		    (ch->flags & XPC_C_ROPENREQUEST)) {
325 			goto out;
326 		}
327 
328 		if (ch->flags & (XPC_C_DISCONNECTING | XPC_C_WDISCONNECT)) {
329 			ch->delayed_chctl_flags |= XPC_CHCTL_OPENREQUEST;
330 			goto out;
331 		}
332 		DBUG_ON(!(ch->flags & (XPC_C_DISCONNECTED |
333 				       XPC_C_OPENREQUEST)));
334 		DBUG_ON(ch->flags & (XPC_C_ROPENREQUEST | XPC_C_ROPENREPLY |
335 				     XPC_C_OPENREPLY | XPC_C_CONNECTED));
336 
337 		/*
338 		 * The meaningful OPENREQUEST connection state fields are:
339 		 *      entry_size = size of channel's messages in bytes
340 		 *      local_nentries = remote partition's local_nentries
341 		 */
342 		if (args->entry_size == 0 || args->local_nentries == 0) {
343 			/* assume OPENREQUEST was delayed by mistake */
344 			goto out;
345 		}
346 
347 		ch->flags |= (XPC_C_ROPENREQUEST | XPC_C_CONNECTING);
348 		ch->remote_nentries = args->local_nentries;
349 
350 		if (ch->flags & XPC_C_OPENREQUEST) {
351 			if (args->entry_size != ch->entry_size) {
352 				XPC_DISCONNECT_CHANNEL(ch, xpUnequalMsgSizes,
353 						       &irq_flags);
354 				goto out;
355 			}
356 		} else {
357 			ch->entry_size = args->entry_size;
358 
359 			XPC_SET_REASON(ch, 0, 0);
360 			ch->flags &= ~XPC_C_DISCONNECTED;
361 
362 			atomic_inc(&part->nchannels_active);
363 		}
364 
365 		xpc_process_connect(ch, &irq_flags);
366 	}
367 
368 	if (chctl_flags & XPC_CHCTL_OPENREPLY) {
369 
370 		dev_dbg(xpc_chan, "XPC_CHCTL_OPENREPLY (local_msgqueue_pa="
371 			"0x%lx, local_nentries=%d, remote_nentries=%d) "
372 			"received from partid=%d, channel=%d\n",
373 			args->local_msgqueue_pa, args->local_nentries,
374 			args->remote_nentries, ch->partid, ch->number);
375 
376 		if (ch->flags & (XPC_C_DISCONNECTING | XPC_C_DISCONNECTED))
377 			goto out;
378 
379 		if (!(ch->flags & XPC_C_OPENREQUEST)) {
380 			XPC_DISCONNECT_CHANNEL(ch, xpOpenCloseError,
381 					       &irq_flags);
382 			goto out;
383 		}
384 
385 		DBUG_ON(!(ch->flags & XPC_C_ROPENREQUEST));
386 		DBUG_ON(ch->flags & XPC_C_CONNECTED);
387 
388 		/*
389 		 * The meaningful OPENREPLY connection state fields are:
390 		 *      local_msgqueue_pa = physical address of remote
391 		 *                          partition's local_msgqueue
392 		 *      local_nentries = remote partition's local_nentries
393 		 *      remote_nentries = remote partition's remote_nentries
394 		 */
395 		DBUG_ON(args->local_msgqueue_pa == 0);
396 		DBUG_ON(args->local_nentries == 0);
397 		DBUG_ON(args->remote_nentries == 0);
398 
399 		ret = xpc_arch_ops.save_remote_msgqueue_pa(ch,
400 						      args->local_msgqueue_pa);
401 		if (ret != xpSuccess) {
402 			XPC_DISCONNECT_CHANNEL(ch, ret, &irq_flags);
403 			goto out;
404 		}
405 		ch->flags |= XPC_C_ROPENREPLY;
406 
407 		if (args->local_nentries < ch->remote_nentries) {
408 			dev_dbg(xpc_chan, "XPC_CHCTL_OPENREPLY: new "
409 				"remote_nentries=%d, old remote_nentries=%d, "
410 				"partid=%d, channel=%d\n",
411 				args->local_nentries, ch->remote_nentries,
412 				ch->partid, ch->number);
413 
414 			ch->remote_nentries = args->local_nentries;
415 		}
416 		if (args->remote_nentries < ch->local_nentries) {
417 			dev_dbg(xpc_chan, "XPC_CHCTL_OPENREPLY: new "
418 				"local_nentries=%d, old local_nentries=%d, "
419 				"partid=%d, channel=%d\n",
420 				args->remote_nentries, ch->local_nentries,
421 				ch->partid, ch->number);
422 
423 			ch->local_nentries = args->remote_nentries;
424 		}
425 
426 		xpc_process_connect(ch, &irq_flags);
427 	}
428 
429 	if (chctl_flags & XPC_CHCTL_OPENCOMPLETE) {
430 
431 		dev_dbg(xpc_chan, "XPC_CHCTL_OPENCOMPLETE received from "
432 			"partid=%d, channel=%d\n", ch->partid, ch->number);
433 
434 		if (ch->flags & (XPC_C_DISCONNECTING | XPC_C_DISCONNECTED))
435 			goto out;
436 
437 		if (!(ch->flags & XPC_C_OPENREQUEST) ||
438 		    !(ch->flags & XPC_C_OPENREPLY)) {
439 			XPC_DISCONNECT_CHANNEL(ch, xpOpenCloseError,
440 					       &irq_flags);
441 			goto out;
442 		}
443 
444 		DBUG_ON(!(ch->flags & XPC_C_ROPENREQUEST));
445 		DBUG_ON(!(ch->flags & XPC_C_ROPENREPLY));
446 		DBUG_ON(!(ch->flags & XPC_C_CONNECTED));
447 
448 		ch->flags |= XPC_C_ROPENCOMPLETE;
449 
450 		xpc_process_connect(ch, &irq_flags);
451 		create_kthread = 1;
452 	}
453 
454 out:
455 	spin_unlock_irqrestore(&ch->lock, irq_flags);
456 
457 	if (create_kthread)
458 		xpc_create_kthreads(ch, 1, 0);
459 }
460 
461 /*
462  * Attempt to establish a channel connection to a remote partition.
463  */
464 static enum xp_retval
465 xpc_connect_channel(struct xpc_channel *ch)
466 {
467 	unsigned long irq_flags;
468 	struct xpc_registration *registration = &xpc_registrations[ch->number];
469 
470 	if (mutex_trylock(&registration->mutex) == 0)
471 		return xpRetry;
472 
473 	if (!XPC_CHANNEL_REGISTERED(ch->number)) {
474 		mutex_unlock(&registration->mutex);
475 		return xpUnregistered;
476 	}
477 
478 	spin_lock_irqsave(&ch->lock, irq_flags);
479 
480 	DBUG_ON(ch->flags & XPC_C_CONNECTED);
481 	DBUG_ON(ch->flags & XPC_C_OPENREQUEST);
482 
483 	if (ch->flags & XPC_C_DISCONNECTING) {
484 		spin_unlock_irqrestore(&ch->lock, irq_flags);
485 		mutex_unlock(&registration->mutex);
486 		return ch->reason;
487 	}
488 
489 	/* add info from the channel connect registration to the channel */
490 
491 	ch->kthreads_assigned_limit = registration->assigned_limit;
492 	ch->kthreads_idle_limit = registration->idle_limit;
493 	DBUG_ON(atomic_read(&ch->kthreads_assigned) != 0);
494 	DBUG_ON(atomic_read(&ch->kthreads_idle) != 0);
495 	DBUG_ON(atomic_read(&ch->kthreads_active) != 0);
496 
497 	ch->func = registration->func;
498 	DBUG_ON(registration->func == NULL);
499 	ch->key = registration->key;
500 
501 	ch->local_nentries = registration->nentries;
502 
503 	if (ch->flags & XPC_C_ROPENREQUEST) {
504 		if (registration->entry_size != ch->entry_size) {
505 			/* the local and remote sides aren't the same */
506 
507 			/*
508 			 * Because XPC_DISCONNECT_CHANNEL() can block we're
509 			 * forced to up the registration sema before we unlock
510 			 * the channel lock. But that's okay here because we're
511 			 * done with the part that required the registration
512 			 * sema. XPC_DISCONNECT_CHANNEL() requires that the
513 			 * channel lock be locked and will unlock and relock
514 			 * the channel lock as needed.
515 			 */
516 			mutex_unlock(&registration->mutex);
517 			XPC_DISCONNECT_CHANNEL(ch, xpUnequalMsgSizes,
518 					       &irq_flags);
519 			spin_unlock_irqrestore(&ch->lock, irq_flags);
520 			return xpUnequalMsgSizes;
521 		}
522 	} else {
523 		ch->entry_size = registration->entry_size;
524 
525 		XPC_SET_REASON(ch, 0, 0);
526 		ch->flags &= ~XPC_C_DISCONNECTED;
527 
528 		atomic_inc(&xpc_partitions[ch->partid].nchannels_active);
529 	}
530 
531 	mutex_unlock(&registration->mutex);
532 
533 	/* initiate the connection */
534 
535 	ch->flags |= (XPC_C_OPENREQUEST | XPC_C_CONNECTING);
536 	xpc_arch_ops.send_chctl_openrequest(ch, &irq_flags);
537 
538 	xpc_process_connect(ch, &irq_flags);
539 
540 	spin_unlock_irqrestore(&ch->lock, irq_flags);
541 
542 	return xpSuccess;
543 }
544 
545 void
546 xpc_process_sent_chctl_flags(struct xpc_partition *part)
547 {
548 	unsigned long irq_flags;
549 	union xpc_channel_ctl_flags chctl;
550 	struct xpc_channel *ch;
551 	int ch_number;
552 	u32 ch_flags;
553 
554 	chctl.all_flags = xpc_arch_ops.get_chctl_all_flags(part);
555 
556 	/*
557 	 * Initiate channel connections for registered channels.
558 	 *
559 	 * For each connected channel that has pending messages activate idle
560 	 * kthreads and/or create new kthreads as needed.
561 	 */
562 
563 	for (ch_number = 0; ch_number < part->nchannels; ch_number++) {
564 		ch = &part->channels[ch_number];
565 
566 		/*
567 		 * Process any open or close related chctl flags, and then deal
568 		 * with connecting or disconnecting the channel as required.
569 		 */
570 
571 		if (chctl.flags[ch_number] & XPC_OPENCLOSE_CHCTL_FLAGS) {
572 			xpc_process_openclose_chctl_flags(part, ch_number,
573 							chctl.flags[ch_number]);
574 		}
575 
576 		ch_flags = ch->flags;	/* need an atomic snapshot of flags */
577 
578 		if (ch_flags & XPC_C_DISCONNECTING) {
579 			spin_lock_irqsave(&ch->lock, irq_flags);
580 			xpc_process_disconnect(ch, &irq_flags);
581 			spin_unlock_irqrestore(&ch->lock, irq_flags);
582 			continue;
583 		}
584 
585 		if (part->act_state == XPC_P_AS_DEACTIVATING)
586 			continue;
587 
588 		if (!(ch_flags & XPC_C_CONNECTED)) {
589 			if (!(ch_flags & XPC_C_OPENREQUEST)) {
590 				DBUG_ON(ch_flags & XPC_C_SETUP);
591 				(void)xpc_connect_channel(ch);
592 			}
593 			continue;
594 		}
595 
596 		/*
597 		 * Process any message related chctl flags, this may involve
598 		 * the activation of kthreads to deliver any pending messages
599 		 * sent from the other partition.
600 		 */
601 
602 		if (chctl.flags[ch_number] & XPC_MSG_CHCTL_FLAGS)
603 			xpc_arch_ops.process_msg_chctl_flags(part, ch_number);
604 	}
605 }
606 
607 /*
608  * XPC's heartbeat code calls this function to inform XPC that a partition is
609  * going down.  XPC responds by tearing down the XPartition Communication
610  * infrastructure used for the just downed partition.
611  *
612  * XPC's heartbeat code will never call this function and xpc_partition_up()
613  * at the same time. Nor will it ever make multiple calls to either function
614  * at the same time.
615  */
616 void
617 xpc_partition_going_down(struct xpc_partition *part, enum xp_retval reason)
618 {
619 	unsigned long irq_flags;
620 	int ch_number;
621 	struct xpc_channel *ch;
622 
623 	dev_dbg(xpc_chan, "deactivating partition %d, reason=%d\n",
624 		XPC_PARTID(part), reason);
625 
626 	if (!xpc_part_ref(part)) {
627 		/* infrastructure for this partition isn't currently set up */
628 		return;
629 	}
630 
631 	/* disconnect channels associated with the partition going down */
632 
633 	for (ch_number = 0; ch_number < part->nchannels; ch_number++) {
634 		ch = &part->channels[ch_number];
635 
636 		xpc_msgqueue_ref(ch);
637 		spin_lock_irqsave(&ch->lock, irq_flags);
638 
639 		XPC_DISCONNECT_CHANNEL(ch, reason, &irq_flags);
640 
641 		spin_unlock_irqrestore(&ch->lock, irq_flags);
642 		xpc_msgqueue_deref(ch);
643 	}
644 
645 	xpc_wakeup_channel_mgr(part);
646 
647 	xpc_part_deref(part);
648 }
649 
650 /*
651  * Called by XP at the time of channel connection registration to cause
652  * XPC to establish connections to all currently active partitions.
653  */
654 void
655 xpc_initiate_connect(int ch_number)
656 {
657 	short partid;
658 	struct xpc_partition *part;
659 	struct xpc_channel *ch;
660 
661 	DBUG_ON(ch_number < 0 || ch_number >= XPC_MAX_NCHANNELS);
662 
663 	for (partid = 0; partid < xp_max_npartitions; partid++) {
664 		part = &xpc_partitions[partid];
665 
666 		if (xpc_part_ref(part)) {
667 			ch = &part->channels[ch_number];
668 
669 			/*
670 			 * Initiate the establishment of a connection on the
671 			 * newly registered channel to the remote partition.
672 			 */
673 			xpc_wakeup_channel_mgr(part);
674 			xpc_part_deref(part);
675 		}
676 	}
677 }
678 
679 void
680 xpc_connected_callout(struct xpc_channel *ch)
681 {
682 	/* let the registerer know that a connection has been established */
683 
684 	if (ch->func != NULL) {
685 		dev_dbg(xpc_chan, "ch->func() called, reason=xpConnected, "
686 			"partid=%d, channel=%d\n", ch->partid, ch->number);
687 
688 		ch->func(xpConnected, ch->partid, ch->number,
689 			 (void *)(u64)ch->local_nentries, ch->key);
690 
691 		dev_dbg(xpc_chan, "ch->func() returned, reason=xpConnected, "
692 			"partid=%d, channel=%d\n", ch->partid, ch->number);
693 	}
694 }
695 
696 /*
697  * Called by XP at the time of channel connection unregistration to cause
698  * XPC to teardown all current connections for the specified channel.
699  *
700  * Before returning xpc_initiate_disconnect() will wait until all connections
701  * on the specified channel have been closed/torndown. So the caller can be
702  * assured that they will not be receiving any more callouts from XPC to the
703  * function they registered via xpc_connect().
704  *
705  * Arguments:
706  *
707  *	ch_number - channel # to unregister.
708  */
709 void
710 xpc_initiate_disconnect(int ch_number)
711 {
712 	unsigned long irq_flags;
713 	short partid;
714 	struct xpc_partition *part;
715 	struct xpc_channel *ch;
716 
717 	DBUG_ON(ch_number < 0 || ch_number >= XPC_MAX_NCHANNELS);
718 
719 	/* initiate the channel disconnect for every active partition */
720 	for (partid = 0; partid < xp_max_npartitions; partid++) {
721 		part = &xpc_partitions[partid];
722 
723 		if (xpc_part_ref(part)) {
724 			ch = &part->channels[ch_number];
725 			xpc_msgqueue_ref(ch);
726 
727 			spin_lock_irqsave(&ch->lock, irq_flags);
728 
729 			if (!(ch->flags & XPC_C_DISCONNECTED)) {
730 				ch->flags |= XPC_C_WDISCONNECT;
731 
732 				XPC_DISCONNECT_CHANNEL(ch, xpUnregistering,
733 						       &irq_flags);
734 			}
735 
736 			spin_unlock_irqrestore(&ch->lock, irq_flags);
737 
738 			xpc_msgqueue_deref(ch);
739 			xpc_part_deref(part);
740 		}
741 	}
742 
743 	xpc_disconnect_wait(ch_number);
744 }
745 
746 /*
747  * To disconnect a channel, and reflect it back to all who may be waiting.
748  *
749  * An OPEN is not allowed until XPC_C_DISCONNECTING is cleared by
750  * xpc_process_disconnect(), and if set, XPC_C_WDISCONNECT is cleared by
751  * xpc_disconnect_wait().
752  *
753  * THE CHANNEL IS TO BE LOCKED BY THE CALLER AND WILL REMAIN LOCKED UPON RETURN.
754  */
755 void
756 xpc_disconnect_channel(const int line, struct xpc_channel *ch,
757 		       enum xp_retval reason, unsigned long *irq_flags)
758 {
759 	u32 channel_was_connected = (ch->flags & XPC_C_CONNECTED);
760 
761 	DBUG_ON(!spin_is_locked(&ch->lock));
762 
763 	if (ch->flags & (XPC_C_DISCONNECTING | XPC_C_DISCONNECTED))
764 		return;
765 
766 	DBUG_ON(!(ch->flags & (XPC_C_CONNECTING | XPC_C_CONNECTED)));
767 
768 	dev_dbg(xpc_chan, "reason=%d, line=%d, partid=%d, channel=%d\n",
769 		reason, line, ch->partid, ch->number);
770 
771 	XPC_SET_REASON(ch, reason, line);
772 
773 	ch->flags |= (XPC_C_CLOSEREQUEST | XPC_C_DISCONNECTING);
774 	/* some of these may not have been set */
775 	ch->flags &= ~(XPC_C_OPENREQUEST | XPC_C_OPENREPLY |
776 		       XPC_C_ROPENREQUEST | XPC_C_ROPENREPLY |
777 		       XPC_C_CONNECTING | XPC_C_CONNECTED);
778 
779 	xpc_arch_ops.send_chctl_closerequest(ch, irq_flags);
780 
781 	if (channel_was_connected)
782 		ch->flags |= XPC_C_WASCONNECTED;
783 
784 	spin_unlock_irqrestore(&ch->lock, *irq_flags);
785 
786 	/* wake all idle kthreads so they can exit */
787 	if (atomic_read(&ch->kthreads_idle) > 0) {
788 		wake_up_all(&ch->idle_wq);
789 
790 	} else if ((ch->flags & XPC_C_CONNECTEDCALLOUT_MADE) &&
791 		   !(ch->flags & XPC_C_DISCONNECTINGCALLOUT)) {
792 		/* start a kthread that will do the xpDisconnecting callout */
793 		xpc_create_kthreads(ch, 1, 1);
794 	}
795 
796 	/* wake those waiting to allocate an entry from the local msg queue */
797 	if (atomic_read(&ch->n_on_msg_allocate_wq) > 0)
798 		wake_up(&ch->msg_allocate_wq);
799 
800 	spin_lock_irqsave(&ch->lock, *irq_flags);
801 }
802 
803 void
804 xpc_disconnect_callout(struct xpc_channel *ch, enum xp_retval reason)
805 {
806 	/*
807 	 * Let the channel's registerer know that the channel is being
808 	 * disconnected. We don't want to do this if the registerer was never
809 	 * informed of a connection being made.
810 	 */
811 
812 	if (ch->func != NULL) {
813 		dev_dbg(xpc_chan, "ch->func() called, reason=%d, partid=%d, "
814 			"channel=%d\n", reason, ch->partid, ch->number);
815 
816 		ch->func(reason, ch->partid, ch->number, NULL, ch->key);
817 
818 		dev_dbg(xpc_chan, "ch->func() returned, reason=%d, partid=%d, "
819 			"channel=%d\n", reason, ch->partid, ch->number);
820 	}
821 }
822 
823 /*
824  * Wait for a message entry to become available for the specified channel,
825  * but don't wait any longer than 1 jiffy.
826  */
827 enum xp_retval
828 xpc_allocate_msg_wait(struct xpc_channel *ch)
829 {
830 	enum xp_retval ret;
831 	DEFINE_WAIT(wait);
832 
833 	if (ch->flags & XPC_C_DISCONNECTING) {
834 		DBUG_ON(ch->reason == xpInterrupted);
835 		return ch->reason;
836 	}
837 
838 	atomic_inc(&ch->n_on_msg_allocate_wq);
839 	prepare_to_wait(&ch->msg_allocate_wq, &wait, TASK_INTERRUPTIBLE);
840 	ret = schedule_timeout(1);
841 	finish_wait(&ch->msg_allocate_wq, &wait);
842 	atomic_dec(&ch->n_on_msg_allocate_wq);
843 
844 	if (ch->flags & XPC_C_DISCONNECTING) {
845 		ret = ch->reason;
846 		DBUG_ON(ch->reason == xpInterrupted);
847 	} else if (ret == 0) {
848 		ret = xpTimeout;
849 	} else {
850 		ret = xpInterrupted;
851 	}
852 
853 	return ret;
854 }
855 
856 /*
857  * Send a message that contains the user's payload on the specified channel
858  * connected to the specified partition.
859  *
860  * NOTE that this routine can sleep waiting for a message entry to become
861  * available. To not sleep, pass in the XPC_NOWAIT flag.
862  *
863  * Once sent, this routine will not wait for the message to be received, nor
864  * will notification be given when it does happen.
865  *
866  * Arguments:
867  *
868  *	partid - ID of partition to which the channel is connected.
869  *	ch_number - channel # to send message on.
870  *	flags - see xp.h for valid flags.
871  *	payload - pointer to the payload which is to be sent.
872  *	payload_size - size of the payload in bytes.
873  */
874 enum xp_retval
875 xpc_initiate_send(short partid, int ch_number, u32 flags, void *payload,
876 		  u16 payload_size)
877 {
878 	struct xpc_partition *part = &xpc_partitions[partid];
879 	enum xp_retval ret = xpUnknownReason;
880 
881 	dev_dbg(xpc_chan, "payload=0x%p, partid=%d, channel=%d\n", payload,
882 		partid, ch_number);
883 
884 	DBUG_ON(partid < 0 || partid >= xp_max_npartitions);
885 	DBUG_ON(ch_number < 0 || ch_number >= part->nchannels);
886 	DBUG_ON(payload == NULL);
887 
888 	if (xpc_part_ref(part)) {
889 		ret = xpc_arch_ops.send_payload(&part->channels[ch_number],
890 				  flags, payload, payload_size, 0, NULL, NULL);
891 		xpc_part_deref(part);
892 	}
893 
894 	return ret;
895 }
896 
897 /*
898  * Send a message that contains the user's payload on the specified channel
899  * connected to the specified partition.
900  *
901  * NOTE that this routine can sleep waiting for a message entry to become
902  * available. To not sleep, pass in the XPC_NOWAIT flag.
903  *
904  * This routine will not wait for the message to be sent or received.
905  *
906  * Once the remote end of the channel has received the message, the function
907  * passed as an argument to xpc_initiate_send_notify() will be called. This
908  * allows the sender to free up or re-use any buffers referenced by the
909  * message, but does NOT mean the message has been processed at the remote
910  * end by a receiver.
911  *
912  * If this routine returns an error, the caller's function will NOT be called.
913  *
914  * Arguments:
915  *
916  *	partid - ID of partition to which the channel is connected.
917  *	ch_number - channel # to send message on.
918  *	flags - see xp.h for valid flags.
919  *	payload - pointer to the payload which is to be sent.
920  *	payload_size - size of the payload in bytes.
921  *	func - function to call with asynchronous notification of message
922  *		  receipt. THIS FUNCTION MUST BE NON-BLOCKING.
923  *	key - user-defined key to be passed to the function when it's called.
924  */
925 enum xp_retval
926 xpc_initiate_send_notify(short partid, int ch_number, u32 flags, void *payload,
927 			 u16 payload_size, xpc_notify_func func, void *key)
928 {
929 	struct xpc_partition *part = &xpc_partitions[partid];
930 	enum xp_retval ret = xpUnknownReason;
931 
932 	dev_dbg(xpc_chan, "payload=0x%p, partid=%d, channel=%d\n", payload,
933 		partid, ch_number);
934 
935 	DBUG_ON(partid < 0 || partid >= xp_max_npartitions);
936 	DBUG_ON(ch_number < 0 || ch_number >= part->nchannels);
937 	DBUG_ON(payload == NULL);
938 	DBUG_ON(func == NULL);
939 
940 	if (xpc_part_ref(part)) {
941 		ret = xpc_arch_ops.send_payload(&part->channels[ch_number],
942 			  flags, payload, payload_size, XPC_N_CALL, func, key);
943 		xpc_part_deref(part);
944 	}
945 	return ret;
946 }
947 
948 /*
949  * Deliver a message's payload to its intended recipient.
950  */
951 void
952 xpc_deliver_payload(struct xpc_channel *ch)
953 {
954 	void *payload;
955 
956 	payload = xpc_arch_ops.get_deliverable_payload(ch);
957 	if (payload != NULL) {
958 
959 		/*
960 		 * This ref is taken to protect the payload itself from being
961 		 * freed before the user is finished with it, which the user
962 		 * indicates by calling xpc_initiate_received().
963 		 */
964 		xpc_msgqueue_ref(ch);
965 
966 		atomic_inc(&ch->kthreads_active);
967 
968 		if (ch->func != NULL) {
969 			dev_dbg(xpc_chan, "ch->func() called, payload=0x%p "
970 				"partid=%d channel=%d\n", payload, ch->partid,
971 				ch->number);
972 
973 			/* deliver the message to its intended recipient */
974 			ch->func(xpMsgReceived, ch->partid, ch->number, payload,
975 				 ch->key);
976 
977 			dev_dbg(xpc_chan, "ch->func() returned, payload=0x%p "
978 				"partid=%d channel=%d\n", payload, ch->partid,
979 				ch->number);
980 		}
981 
982 		atomic_dec(&ch->kthreads_active);
983 	}
984 }
985 
986 /*
987  * Acknowledge receipt of a delivered message's payload.
988  *
989  * This function, although called by users, does not call xpc_part_ref() to
990  * ensure that the partition infrastructure is in place. It relies on the
991  * fact that we called xpc_msgqueue_ref() in xpc_deliver_payload().
992  *
993  * Arguments:
994  *
995  *	partid - ID of partition to which the channel is connected.
996  *	ch_number - channel # message received on.
997  *	payload - pointer to the payload area allocated via
998  *			xpc_initiate_send() or xpc_initiate_send_notify().
999  */
1000 void
1001 xpc_initiate_received(short partid, int ch_number, void *payload)
1002 {
1003 	struct xpc_partition *part = &xpc_partitions[partid];
1004 	struct xpc_channel *ch;
1005 
1006 	DBUG_ON(partid < 0 || partid >= xp_max_npartitions);
1007 	DBUG_ON(ch_number < 0 || ch_number >= part->nchannels);
1008 
1009 	ch = &part->channels[ch_number];
1010 	xpc_arch_ops.received_payload(ch, payload);
1011 
1012 	/* the call to xpc_msgqueue_ref() was done by xpc_deliver_payload()  */
1013 	xpc_msgqueue_deref(ch);
1014 }
1015