1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46#include <linux/module.h>
47#include <linux/sysctl.h>
48#include <linux/device.h>
49#include <linux/delay.h>
50#include <linux/reboot.h>
51#include <linux/kdebug.h>
52#include <linux/kthread.h>
53#include "xpc.h"
54
55
56
57struct device_driver xpc_dbg_name = {
58 .name = "xpc"
59};
60
61struct device xpc_part_dbg_subname = {
62 .init_name = "",
63 .driver = &xpc_dbg_name
64};
65
66struct device xpc_chan_dbg_subname = {
67 .init_name = "",
68 .driver = &xpc_dbg_name
69};
70
71struct device *xpc_part = &xpc_part_dbg_subname;
72struct device *xpc_chan = &xpc_chan_dbg_subname;
73
74static int xpc_kdebug_ignore;
75
76
77
78static int xpc_hb_interval = XPC_HB_DEFAULT_INTERVAL;
79static int xpc_hb_min_interval = 1;
80static int xpc_hb_max_interval = 10;
81
82static int xpc_hb_check_interval = XPC_HB_CHECK_DEFAULT_INTERVAL;
83static int xpc_hb_check_min_interval = 10;
84static int xpc_hb_check_max_interval = 120;
85
86int xpc_disengage_timelimit = XPC_DISENGAGE_DEFAULT_TIMELIMIT;
87static int xpc_disengage_min_timelimit;
88static int xpc_disengage_max_timelimit = 120;
89
90static ctl_table xpc_sys_xpc_hb_dir[] = {
91 {
92 .ctl_name = CTL_UNNUMBERED,
93 .procname = "hb_interval",
94 .data = &xpc_hb_interval,
95 .maxlen = sizeof(int),
96 .mode = 0644,
97 .proc_handler = &proc_dointvec_minmax,
98 .strategy = &sysctl_intvec,
99 .extra1 = &xpc_hb_min_interval,
100 .extra2 = &xpc_hb_max_interval},
101 {
102 .ctl_name = CTL_UNNUMBERED,
103 .procname = "hb_check_interval",
104 .data = &xpc_hb_check_interval,
105 .maxlen = sizeof(int),
106 .mode = 0644,
107 .proc_handler = &proc_dointvec_minmax,
108 .strategy = &sysctl_intvec,
109 .extra1 = &xpc_hb_check_min_interval,
110 .extra2 = &xpc_hb_check_max_interval},
111 {}
112};
113static ctl_table xpc_sys_xpc_dir[] = {
114 {
115 .ctl_name = CTL_UNNUMBERED,
116 .procname = "hb",
117 .mode = 0555,
118 .child = xpc_sys_xpc_hb_dir},
119 {
120 .ctl_name = CTL_UNNUMBERED,
121 .procname = "disengage_timelimit",
122 .data = &xpc_disengage_timelimit,
123 .maxlen = sizeof(int),
124 .mode = 0644,
125 .proc_handler = &proc_dointvec_minmax,
126 .strategy = &sysctl_intvec,
127 .extra1 = &xpc_disengage_min_timelimit,
128 .extra2 = &xpc_disengage_max_timelimit},
129 {}
130};
131static ctl_table xpc_sys_dir[] = {
132 {
133 .ctl_name = CTL_UNNUMBERED,
134 .procname = "xpc",
135 .mode = 0555,
136 .child = xpc_sys_xpc_dir},
137 {}
138};
139static struct ctl_table_header *xpc_sysctl;
140
141
142int xpc_disengage_timedout;
143
144
145int xpc_activate_IRQ_rcvd;
146DEFINE_SPINLOCK(xpc_activate_IRQ_rcvd_lock);
147
148
149DECLARE_WAIT_QUEUE_HEAD(xpc_activate_IRQ_wq);
150
151static unsigned long xpc_hb_check_timeout;
152static struct timer_list xpc_hb_timer;
153
154
155static DECLARE_COMPLETION(xpc_hb_checker_exited);
156
157
158static DECLARE_COMPLETION(xpc_discovery_exited);
159
160static void xpc_kthread_waitmsgs(struct xpc_partition *, struct xpc_channel *);
161
162static int xpc_system_reboot(struct notifier_block *, unsigned long, void *);
163static struct notifier_block xpc_reboot_notifier = {
164 .notifier_call = xpc_system_reboot,
165};
166
167static int xpc_system_die(struct notifier_block *, unsigned long, void *);
168static struct notifier_block xpc_die_notifier = {
169 .notifier_call = xpc_system_die,
170};
171
172struct xpc_arch_operations xpc_arch_ops;
173
174
175
176
177static void
178xpc_timeout_partition_disengage(unsigned long data)
179{
180 struct xpc_partition *part = (struct xpc_partition *)data;
181
182 DBUG_ON(time_is_after_jiffies(part->disengage_timeout));
183
184 (void)xpc_partition_disengaged(part);
185
186 DBUG_ON(part->disengage_timeout != 0);
187 DBUG_ON(xpc_arch_ops.partition_engaged(XPC_PARTID(part)));
188}
189
190
191
192
193
194
195static void
196xpc_hb_beater(unsigned long dummy)
197{
198 xpc_arch_ops.increment_heartbeat();
199
200 if (time_is_before_eq_jiffies(xpc_hb_check_timeout))
201 wake_up_interruptible(&xpc_activate_IRQ_wq);
202
203 xpc_hb_timer.expires = jiffies + (xpc_hb_interval * HZ);
204 add_timer(&xpc_hb_timer);
205}
206
207static void
208xpc_start_hb_beater(void)
209{
210 xpc_arch_ops.heartbeat_init();
211 init_timer(&xpc_hb_timer);
212 xpc_hb_timer.function = xpc_hb_beater;
213 xpc_hb_beater(0);
214}
215
216static void
217xpc_stop_hb_beater(void)
218{
219 del_timer_sync(&xpc_hb_timer);
220 xpc_arch_ops.heartbeat_exit();
221}
222
223
224
225
226
227static void
228xpc_check_remote_hb(void)
229{
230 struct xpc_partition *part;
231 short partid;
232 enum xp_retval ret;
233
234 for (partid = 0; partid < xp_max_npartitions; partid++) {
235
236 if (xpc_exiting)
237 break;
238
239 if (partid == xp_partition_id)
240 continue;
241
242 part = &xpc_partitions[partid];
243
244 if (part->act_state == XPC_P_AS_INACTIVE ||
245 part->act_state == XPC_P_AS_DEACTIVATING) {
246 continue;
247 }
248
249 ret = xpc_arch_ops.get_remote_heartbeat(part);
250 if (ret != xpSuccess)
251 XPC_DEACTIVATE_PARTITION(part, ret);
252 }
253}
254
255
256
257
258
259static int
260xpc_hb_checker(void *ignore)
261{
262 int force_IRQ = 0;
263
264
265
266 set_cpus_allowed_ptr(current, cpumask_of(XPC_HB_CHECK_CPU));
267
268
269 xpc_hb_check_timeout = jiffies + (xpc_hb_check_interval * HZ);
270 xpc_start_hb_beater();
271
272 while (!xpc_exiting) {
273
274 dev_dbg(xpc_part, "woke up with %d ticks rem; %d IRQs have "
275 "been received\n",
276 (int)(xpc_hb_check_timeout - jiffies),
277 xpc_activate_IRQ_rcvd);
278
279
280 if (time_is_before_eq_jiffies(xpc_hb_check_timeout)) {
281 xpc_hb_check_timeout = jiffies +
282 (xpc_hb_check_interval * HZ);
283
284 dev_dbg(xpc_part, "checking remote heartbeats\n");
285 xpc_check_remote_hb();
286
287
288
289
290
291 if (is_shub())
292 force_IRQ = 1;
293 }
294
295
296 if (xpc_activate_IRQ_rcvd > 0 || force_IRQ != 0) {
297 force_IRQ = 0;
298 dev_dbg(xpc_part, "processing activate IRQs "
299 "received\n");
300 xpc_arch_ops.process_activate_IRQ_rcvd();
301 }
302
303
304 (void)wait_event_interruptible(xpc_activate_IRQ_wq,
305 (time_is_before_eq_jiffies(
306 xpc_hb_check_timeout) ||
307 xpc_activate_IRQ_rcvd > 0 ||
308 xpc_exiting));
309 }
310
311 xpc_stop_hb_beater();
312
313 dev_dbg(xpc_part, "heartbeat checker is exiting\n");
314
315
316 complete(&xpc_hb_checker_exited);
317 return 0;
318}
319
320
321
322
323
324
325static int
326xpc_initiate_discovery(void *ignore)
327{
328 xpc_discovery();
329
330 dev_dbg(xpc_part, "discovery thread is exiting\n");
331
332
333 complete(&xpc_discovery_exited);
334 return 0;
335}
336
337
338
339
340
341
342
343
344
345
346
347
348
349static void
350xpc_channel_mgr(struct xpc_partition *part)
351{
352 while (part->act_state != XPC_P_AS_DEACTIVATING ||
353 atomic_read(&part->nchannels_active) > 0 ||
354 !xpc_partition_disengaged(part)) {
355
356 xpc_process_sent_chctl_flags(part);
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371 atomic_dec(&part->channel_mgr_requests);
372 (void)wait_event_interruptible(part->channel_mgr_wq,
373 (atomic_read(&part->channel_mgr_requests) > 0 ||
374 part->chctl.all_flags != 0 ||
375 (part->act_state == XPC_P_AS_DEACTIVATING &&
376 atomic_read(&part->nchannels_active) == 0 &&
377 xpc_partition_disengaged(part))));
378 atomic_set(&part->channel_mgr_requests, 1);
379 }
380}
381
382
383
384
385void *
386xpc_kzalloc_cacheline_aligned(size_t size, gfp_t flags, void **base)
387{
388
389 *base = kzalloc(size, flags);
390 if (*base == NULL)
391 return NULL;
392
393 if ((u64)*base == L1_CACHE_ALIGN((u64)*base))
394 return *base;
395
396 kfree(*base);
397
398
399 *base = kzalloc(size + L1_CACHE_BYTES, flags);
400 if (*base == NULL)
401 return NULL;
402
403 return (void *)L1_CACHE_ALIGN((u64)*base);
404}
405
406
407
408
409
410static enum xp_retval
411xpc_setup_ch_structures(struct xpc_partition *part)
412{
413 enum xp_retval ret;
414 int ch_number;
415 struct xpc_channel *ch;
416 short partid = XPC_PARTID(part);
417
418
419
420
421
422 DBUG_ON(part->channels != NULL);
423 part->channels = kzalloc(sizeof(struct xpc_channel) * XPC_MAX_NCHANNELS,
424 GFP_KERNEL);
425 if (part->channels == NULL) {
426 dev_err(xpc_chan, "can't get memory for channels\n");
427 return xpNoMemory;
428 }
429
430
431
432 part->remote_openclose_args =
433 xpc_kzalloc_cacheline_aligned(XPC_OPENCLOSE_ARGS_SIZE,
434 GFP_KERNEL, &part->
435 remote_openclose_args_base);
436 if (part->remote_openclose_args == NULL) {
437 dev_err(xpc_chan, "can't get memory for remote connect args\n");
438 ret = xpNoMemory;
439 goto out_1;
440 }
441
442 part->chctl.all_flags = 0;
443 spin_lock_init(&part->chctl_lock);
444
445 atomic_set(&part->channel_mgr_requests, 1);
446 init_waitqueue_head(&part->channel_mgr_wq);
447
448 part->nchannels = XPC_MAX_NCHANNELS;
449
450 atomic_set(&part->nchannels_active, 0);
451 atomic_set(&part->nchannels_engaged, 0);
452
453 for (ch_number = 0; ch_number < part->nchannels; ch_number++) {
454 ch = &part->channels[ch_number];
455
456 ch->partid = partid;
457 ch->number = ch_number;
458 ch->flags = XPC_C_DISCONNECTED;
459
460 atomic_set(&ch->kthreads_assigned, 0);
461 atomic_set(&ch->kthreads_idle, 0);
462 atomic_set(&ch->kthreads_active, 0);
463
464 atomic_set(&ch->references, 0);
465 atomic_set(&ch->n_to_notify, 0);
466
467 spin_lock_init(&ch->lock);
468 init_completion(&ch->wdisconnect_wait);
469
470 atomic_set(&ch->n_on_msg_allocate_wq, 0);
471 init_waitqueue_head(&ch->msg_allocate_wq);
472 init_waitqueue_head(&ch->idle_wq);
473 }
474
475 ret = xpc_arch_ops.setup_ch_structures(part);
476 if (ret != xpSuccess)
477 goto out_2;
478
479
480
481
482
483 part->setup_state = XPC_P_SS_SETUP;
484
485 return xpSuccess;
486
487
488out_2:
489 kfree(part->remote_openclose_args_base);
490 part->remote_openclose_args = NULL;
491out_1:
492 kfree(part->channels);
493 part->channels = NULL;
494 return ret;
495}
496
497
498
499
500
501static void
502xpc_teardown_ch_structures(struct xpc_partition *part)
503{
504 DBUG_ON(atomic_read(&part->nchannels_engaged) != 0);
505 DBUG_ON(atomic_read(&part->nchannels_active) != 0);
506
507
508
509
510
511
512 DBUG_ON(part->setup_state != XPC_P_SS_SETUP);
513 part->setup_state = XPC_P_SS_WTEARDOWN;
514
515 wait_event(part->teardown_wq, (atomic_read(&part->references) == 0));
516
517
518
519 xpc_arch_ops.teardown_ch_structures(part);
520
521 kfree(part->remote_openclose_args_base);
522 part->remote_openclose_args = NULL;
523 kfree(part->channels);
524 part->channels = NULL;
525
526 part->setup_state = XPC_P_SS_TORNDOWN;
527}
528
529
530
531
532
533
534
535
536
537
538
539
540static int
541xpc_activating(void *__partid)
542{
543 short partid = (u64)__partid;
544 struct xpc_partition *part = &xpc_partitions[partid];
545 unsigned long irq_flags;
546
547 DBUG_ON(partid < 0 || partid >= xp_max_npartitions);
548
549 spin_lock_irqsave(&part->act_lock, irq_flags);
550
551 if (part->act_state == XPC_P_AS_DEACTIVATING) {
552 part->act_state = XPC_P_AS_INACTIVE;
553 spin_unlock_irqrestore(&part->act_lock, irq_flags);
554 part->remote_rp_pa = 0;
555 return 0;
556 }
557
558
559 DBUG_ON(part->act_state != XPC_P_AS_ACTIVATION_REQ);
560 part->act_state = XPC_P_AS_ACTIVATING;
561
562 XPC_SET_REASON(part, 0, 0);
563 spin_unlock_irqrestore(&part->act_lock, irq_flags);
564
565 dev_dbg(xpc_part, "activating partition %d\n", partid);
566
567 xpc_arch_ops.allow_hb(partid);
568
569 if (xpc_setup_ch_structures(part) == xpSuccess) {
570 (void)xpc_part_ref(part);
571
572 if (xpc_arch_ops.make_first_contact(part) == xpSuccess) {
573 xpc_mark_partition_active(part);
574 xpc_channel_mgr(part);
575
576 }
577
578 xpc_part_deref(part);
579 xpc_teardown_ch_structures(part);
580 }
581
582 xpc_arch_ops.disallow_hb(partid);
583 xpc_mark_partition_inactive(part);
584
585 if (part->reason == xpReactivating) {
586
587 xpc_arch_ops.request_partition_reactivation(part);
588 }
589
590 return 0;
591}
592
593void
594xpc_activate_partition(struct xpc_partition *part)
595{
596 short partid = XPC_PARTID(part);
597 unsigned long irq_flags;
598 struct task_struct *kthread;
599
600 spin_lock_irqsave(&part->act_lock, irq_flags);
601
602 DBUG_ON(part->act_state != XPC_P_AS_INACTIVE);
603
604 part->act_state = XPC_P_AS_ACTIVATION_REQ;
605 XPC_SET_REASON(part, xpCloneKThread, __LINE__);
606
607 spin_unlock_irqrestore(&part->act_lock, irq_flags);
608
609 kthread = kthread_run(xpc_activating, (void *)((u64)partid), "xpc%02d",
610 partid);
611 if (IS_ERR(kthread)) {
612 spin_lock_irqsave(&part->act_lock, irq_flags);
613 part->act_state = XPC_P_AS_INACTIVE;
614 XPC_SET_REASON(part, xpCloneKThreadFailed, __LINE__);
615 spin_unlock_irqrestore(&part->act_lock, irq_flags);
616 }
617}
618
619void
620xpc_activate_kthreads(struct xpc_channel *ch, int needed)
621{
622 int idle = atomic_read(&ch->kthreads_idle);
623 int assigned = atomic_read(&ch->kthreads_assigned);
624 int wakeup;
625
626 DBUG_ON(needed <= 0);
627
628 if (idle > 0) {
629 wakeup = (needed > idle) ? idle : needed;
630 needed -= wakeup;
631
632 dev_dbg(xpc_chan, "wakeup %d idle kthreads, partid=%d, "
633 "channel=%d\n", wakeup, ch->partid, ch->number);
634
635
636 wake_up_nr(&ch->idle_wq, wakeup);
637 }
638
639 if (needed <= 0)
640 return;
641
642 if (needed + assigned > ch->kthreads_assigned_limit) {
643 needed = ch->kthreads_assigned_limit - assigned;
644 if (needed <= 0)
645 return;
646 }
647
648 dev_dbg(xpc_chan, "create %d new kthreads, partid=%d, channel=%d\n",
649 needed, ch->partid, ch->number);
650
651 xpc_create_kthreads(ch, needed, 0);
652}
653
654
655
656
657static void
658xpc_kthread_waitmsgs(struct xpc_partition *part, struct xpc_channel *ch)
659{
660 int (*n_of_deliverable_payloads) (struct xpc_channel *) =
661 xpc_arch_ops.n_of_deliverable_payloads;
662
663 do {
664
665
666 while (n_of_deliverable_payloads(ch) > 0 &&
667 !(ch->flags & XPC_C_DISCONNECTING)) {
668 xpc_deliver_payload(ch);
669 }
670
671 if (atomic_inc_return(&ch->kthreads_idle) >
672 ch->kthreads_idle_limit) {
673
674 atomic_dec(&ch->kthreads_idle);
675 break;
676 }
677
678 dev_dbg(xpc_chan, "idle kthread calling "
679 "wait_event_interruptible_exclusive()\n");
680
681 (void)wait_event_interruptible_exclusive(ch->idle_wq,
682 (n_of_deliverable_payloads(ch) > 0 ||
683 (ch->flags & XPC_C_DISCONNECTING)));
684
685 atomic_dec(&ch->kthreads_idle);
686
687 } while (!(ch->flags & XPC_C_DISCONNECTING));
688}
689
690static int
691xpc_kthread_start(void *args)
692{
693 short partid = XPC_UNPACK_ARG1(args);
694 u16 ch_number = XPC_UNPACK_ARG2(args);
695 struct xpc_partition *part = &xpc_partitions[partid];
696 struct xpc_channel *ch;
697 int n_needed;
698 unsigned long irq_flags;
699 int (*n_of_deliverable_payloads) (struct xpc_channel *) =
700 xpc_arch_ops.n_of_deliverable_payloads;
701
702 dev_dbg(xpc_chan, "kthread starting, partid=%d, channel=%d\n",
703 partid, ch_number);
704
705 ch = &part->channels[ch_number];
706
707 if (!(ch->flags & XPC_C_DISCONNECTING)) {
708
709
710
711 spin_lock_irqsave(&ch->lock, irq_flags);
712 if (!(ch->flags & XPC_C_CONNECTEDCALLOUT)) {
713 ch->flags |= XPC_C_CONNECTEDCALLOUT;
714 spin_unlock_irqrestore(&ch->lock, irq_flags);
715
716 xpc_connected_callout(ch);
717
718 spin_lock_irqsave(&ch->lock, irq_flags);
719 ch->flags |= XPC_C_CONNECTEDCALLOUT_MADE;
720 spin_unlock_irqrestore(&ch->lock, irq_flags);
721
722
723
724
725
726
727
728
729 n_needed = n_of_deliverable_payloads(ch) - 1;
730 if (n_needed > 0 && !(ch->flags & XPC_C_DISCONNECTING))
731 xpc_activate_kthreads(ch, n_needed);
732
733 } else {
734 spin_unlock_irqrestore(&ch->lock, irq_flags);
735 }
736
737 xpc_kthread_waitmsgs(part, ch);
738 }
739
740
741
742 spin_lock_irqsave(&ch->lock, irq_flags);
743 if ((ch->flags & XPC_C_CONNECTEDCALLOUT_MADE) &&
744 !(ch->flags & XPC_C_DISCONNECTINGCALLOUT)) {
745 ch->flags |= XPC_C_DISCONNECTINGCALLOUT;
746 spin_unlock_irqrestore(&ch->lock, irq_flags);
747
748 xpc_disconnect_callout(ch, xpDisconnecting);
749
750 spin_lock_irqsave(&ch->lock, irq_flags);
751 ch->flags |= XPC_C_DISCONNECTINGCALLOUT_MADE;
752 }
753 spin_unlock_irqrestore(&ch->lock, irq_flags);
754
755 if (atomic_dec_return(&ch->kthreads_assigned) == 0 &&
756 atomic_dec_return(&part->nchannels_engaged) == 0) {
757 xpc_arch_ops.indicate_partition_disengaged(part);
758 }
759
760 xpc_msgqueue_deref(ch);
761
762 dev_dbg(xpc_chan, "kthread exiting, partid=%d, channel=%d\n",
763 partid, ch_number);
764
765 xpc_part_deref(part);
766 return 0;
767}
768
769
770
771
772
773
774
775
776
777
778
779
780
781void
782xpc_create_kthreads(struct xpc_channel *ch, int needed,
783 int ignore_disconnecting)
784{
785 unsigned long irq_flags;
786 u64 args = XPC_PACK_ARGS(ch->partid, ch->number);
787 struct xpc_partition *part = &xpc_partitions[ch->partid];
788 struct task_struct *kthread;
789 void (*indicate_partition_disengaged) (struct xpc_partition *) =
790 xpc_arch_ops.indicate_partition_disengaged;
791
792 while (needed-- > 0) {
793
794
795
796
797
798
799 if (ignore_disconnecting) {
800 if (!atomic_inc_not_zero(&ch->kthreads_assigned)) {
801
802 BUG_ON(!(ch->flags &
803 XPC_C_DISCONNECTINGCALLOUT_MADE));
804 break;
805 }
806
807 } else if (ch->flags & XPC_C_DISCONNECTING) {
808 break;
809
810 } else if (atomic_inc_return(&ch->kthreads_assigned) == 1 &&
811 atomic_inc_return(&part->nchannels_engaged) == 1) {
812 xpc_arch_ops.indicate_partition_engaged(part);
813 }
814 (void)xpc_part_ref(part);
815 xpc_msgqueue_ref(ch);
816
817 kthread = kthread_run(xpc_kthread_start, (void *)args,
818 "xpc%02dc%d", ch->partid, ch->number);
819 if (IS_ERR(kthread)) {
820
821
822
823
824
825
826
827
828
829
830
831
832 if (atomic_dec_return(&ch->kthreads_assigned) == 0 &&
833 atomic_dec_return(&part->nchannels_engaged) == 0) {
834 indicate_partition_disengaged(part);
835 }
836 xpc_msgqueue_deref(ch);
837 xpc_part_deref(part);
838
839 if (atomic_read(&ch->kthreads_assigned) <
840 ch->kthreads_idle_limit) {
841
842
843
844
845
846 spin_lock_irqsave(&ch->lock, irq_flags);
847 XPC_DISCONNECT_CHANNEL(ch, xpLackOfResources,
848 &irq_flags);
849 spin_unlock_irqrestore(&ch->lock, irq_flags);
850 }
851 break;
852 }
853 }
854}
855
856void
857xpc_disconnect_wait(int ch_number)
858{
859 unsigned long irq_flags;
860 short partid;
861 struct xpc_partition *part;
862 struct xpc_channel *ch;
863 int wakeup_channel_mgr;
864
865
866 for (partid = 0; partid < xp_max_npartitions; partid++) {
867 part = &xpc_partitions[partid];
868
869 if (!xpc_part_ref(part))
870 continue;
871
872 ch = &part->channels[ch_number];
873
874 if (!(ch->flags & XPC_C_WDISCONNECT)) {
875 xpc_part_deref(part);
876 continue;
877 }
878
879 wait_for_completion(&ch->wdisconnect_wait);
880
881 spin_lock_irqsave(&ch->lock, irq_flags);
882 DBUG_ON(!(ch->flags & XPC_C_DISCONNECTED));
883 wakeup_channel_mgr = 0;
884
885 if (ch->delayed_chctl_flags) {
886 if (part->act_state != XPC_P_AS_DEACTIVATING) {
887 spin_lock(&part->chctl_lock);
888 part->chctl.flags[ch->number] |=
889 ch->delayed_chctl_flags;
890 spin_unlock(&part->chctl_lock);
891 wakeup_channel_mgr = 1;
892 }
893 ch->delayed_chctl_flags = 0;
894 }
895
896 ch->flags &= ~XPC_C_WDISCONNECT;
897 spin_unlock_irqrestore(&ch->lock, irq_flags);
898
899 if (wakeup_channel_mgr)
900 xpc_wakeup_channel_mgr(part);
901
902 xpc_part_deref(part);
903 }
904}
905
906static int
907xpc_setup_partitions(void)
908{
909 short partid;
910 struct xpc_partition *part;
911
912 xpc_partitions = kzalloc(sizeof(struct xpc_partition) *
913 xp_max_npartitions, GFP_KERNEL);
914 if (xpc_partitions == NULL) {
915 dev_err(xpc_part, "can't get memory for partition structure\n");
916 return -ENOMEM;
917 }
918
919
920
921
922
923
924
925
926
927 for (partid = 0; partid < xp_max_npartitions; partid++) {
928 part = &xpc_partitions[partid];
929
930 DBUG_ON((u64)part != L1_CACHE_ALIGN((u64)part));
931
932 part->activate_IRQ_rcvd = 0;
933 spin_lock_init(&part->act_lock);
934 part->act_state = XPC_P_AS_INACTIVE;
935 XPC_SET_REASON(part, 0, 0);
936
937 init_timer(&part->disengage_timer);
938 part->disengage_timer.function =
939 xpc_timeout_partition_disengage;
940 part->disengage_timer.data = (unsigned long)part;
941
942 part->setup_state = XPC_P_SS_UNSET;
943 init_waitqueue_head(&part->teardown_wq);
944 atomic_set(&part->references, 0);
945 }
946
947 return xpc_arch_ops.setup_partitions();
948}
949
950static void
951xpc_teardown_partitions(void)
952{
953 xpc_arch_ops.teardown_partitions();
954 kfree(xpc_partitions);
955}
956
957static void
958xpc_do_exit(enum xp_retval reason)
959{
960 short partid;
961 int active_part_count, printed_waiting_msg = 0;
962 struct xpc_partition *part;
963 unsigned long printmsg_time, disengage_timeout = 0;
964
965
966 DBUG_ON(xpc_exiting == 1);
967
968
969
970
971
972
973 xpc_exiting = 1;
974 wake_up_interruptible(&xpc_activate_IRQ_wq);
975
976
977 wait_for_completion(&xpc_discovery_exited);
978
979
980 wait_for_completion(&xpc_hb_checker_exited);
981
982
983 (void)msleep_interruptible(300);
984
985
986
987 printmsg_time = jiffies + (XPC_DEACTIVATE_PRINTMSG_INTERVAL * HZ);
988 xpc_disengage_timedout = 0;
989
990 do {
991 active_part_count = 0;
992
993 for (partid = 0; partid < xp_max_npartitions; partid++) {
994 part = &xpc_partitions[partid];
995
996 if (xpc_partition_disengaged(part) &&
997 part->act_state == XPC_P_AS_INACTIVE) {
998 continue;
999 }
1000
1001 active_part_count++;
1002
1003 XPC_DEACTIVATE_PARTITION(part, reason);
1004
1005 if (part->disengage_timeout > disengage_timeout)
1006 disengage_timeout = part->disengage_timeout;
1007 }
1008
1009 if (xpc_arch_ops.any_partition_engaged()) {
1010 if (time_is_before_jiffies(printmsg_time)) {
1011 dev_info(xpc_part, "waiting for remote "
1012 "partitions to deactivate, timeout in "
1013 "%ld seconds\n", (disengage_timeout -
1014 jiffies) / HZ);
1015 printmsg_time = jiffies +
1016 (XPC_DEACTIVATE_PRINTMSG_INTERVAL * HZ);
1017 printed_waiting_msg = 1;
1018 }
1019
1020 } else if (active_part_count > 0) {
1021 if (printed_waiting_msg) {
1022 dev_info(xpc_part, "waiting for local partition"
1023 " to deactivate\n");
1024 printed_waiting_msg = 0;
1025 }
1026
1027 } else {
1028 if (!xpc_disengage_timedout) {
1029 dev_info(xpc_part, "all partitions have "
1030 "deactivated\n");
1031 }
1032 break;
1033 }
1034
1035
1036 (void)msleep_interruptible(300);
1037
1038 } while (1);
1039
1040 DBUG_ON(xpc_arch_ops.any_partition_engaged());
1041
1042 xpc_teardown_rsvd_page();
1043
1044 if (reason == xpUnloading) {
1045 (void)unregister_die_notifier(&xpc_die_notifier);
1046 (void)unregister_reboot_notifier(&xpc_reboot_notifier);
1047 }
1048
1049
1050 xpc_clear_interface();
1051
1052 if (xpc_sysctl)
1053 unregister_sysctl_table(xpc_sysctl);
1054
1055 xpc_teardown_partitions();
1056
1057 if (is_shub())
1058 xpc_exit_sn2();
1059 else if (is_uv())
1060 xpc_exit_uv();
1061}
1062
1063
1064
1065
1066static int
1067xpc_system_reboot(struct notifier_block *nb, unsigned long event, void *unused)
1068{
1069 enum xp_retval reason;
1070
1071 switch (event) {
1072 case SYS_RESTART:
1073 reason = xpSystemReboot;
1074 break;
1075 case SYS_HALT:
1076 reason = xpSystemHalt;
1077 break;
1078 case SYS_POWER_OFF:
1079 reason = xpSystemPoweroff;
1080 break;
1081 default:
1082 reason = xpSystemGoingDown;
1083 }
1084
1085 xpc_do_exit(reason);
1086 return NOTIFY_DONE;
1087}
1088
1089
1090
1091
1092
1093static void
1094xpc_die_deactivate(void)
1095{
1096 struct xpc_partition *part;
1097 short partid;
1098 int any_engaged;
1099 long keep_waiting;
1100 long wait_to_print;
1101
1102
1103 xpc_exiting = 1;
1104
1105 xpc_arch_ops.disallow_all_hbs();
1106
1107 for (partid = 0; partid < xp_max_npartitions; partid++) {
1108 part = &xpc_partitions[partid];
1109
1110 if (xpc_arch_ops.partition_engaged(partid) ||
1111 part->act_state != XPC_P_AS_INACTIVE) {
1112 xpc_arch_ops.request_partition_deactivation(part);
1113 xpc_arch_ops.indicate_partition_disengaged(part);
1114 }
1115 }
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126 keep_waiting = xpc_disengage_timelimit * 1000 * 5;
1127 wait_to_print = XPC_DEACTIVATE_PRINTMSG_INTERVAL * 1000 * 5;
1128
1129 while (1) {
1130 any_engaged = xpc_arch_ops.any_partition_engaged();
1131 if (!any_engaged) {
1132 dev_info(xpc_part, "all partitions have deactivated\n");
1133 break;
1134 }
1135
1136 if (!keep_waiting--) {
1137 for (partid = 0; partid < xp_max_npartitions;
1138 partid++) {
1139 if (xpc_arch_ops.partition_engaged(partid)) {
1140 dev_info(xpc_part, "deactivate from "
1141 "remote partition %d timed "
1142 "out\n", partid);
1143 }
1144 }
1145 break;
1146 }
1147
1148 if (!wait_to_print--) {
1149 dev_info(xpc_part, "waiting for remote partitions to "
1150 "deactivate, timeout in %ld seconds\n",
1151 keep_waiting / (1000 * 5));
1152 wait_to_print = XPC_DEACTIVATE_PRINTMSG_INTERVAL *
1153 1000 * 5;
1154 }
1155
1156 udelay(200);
1157 }
1158}
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168static int
1169xpc_system_die(struct notifier_block *nb, unsigned long event, void *unused)
1170{
1171#ifdef CONFIG_IA64
1172 switch (event) {
1173 case DIE_MACHINE_RESTART:
1174 case DIE_MACHINE_HALT:
1175 xpc_die_deactivate();
1176 break;
1177
1178 case DIE_KDEBUG_ENTER:
1179
1180 if (!xpc_kdebug_ignore)
1181 break;
1182
1183
1184 case DIE_MCA_MONARCH_ENTER:
1185 case DIE_INIT_MONARCH_ENTER:
1186 xpc_arch_ops.offline_heartbeat();
1187 break;
1188
1189 case DIE_KDEBUG_LEAVE:
1190
1191 if (!xpc_kdebug_ignore)
1192 break;
1193
1194
1195 case DIE_MCA_MONARCH_LEAVE:
1196 case DIE_INIT_MONARCH_LEAVE:
1197 xpc_arch_ops.online_heartbeat();
1198 break;
1199 }
1200#else
1201 xpc_die_deactivate();
1202#endif
1203
1204 return NOTIFY_DONE;
1205}
1206
1207int __init
1208xpc_init(void)
1209{
1210 int ret;
1211 struct task_struct *kthread;
1212
1213 dev_set_name(xpc_part, "part");
1214 dev_set_name(xpc_chan, "chan");
1215
1216 if (is_shub()) {
1217
1218
1219
1220
1221
1222
1223 if (xp_max_npartitions != 64) {
1224 dev_err(xpc_part, "max #of partitions not set to 64\n");
1225 ret = -EINVAL;
1226 } else {
1227 ret = xpc_init_sn2();
1228 }
1229
1230 } else if (is_uv()) {
1231 ret = xpc_init_uv();
1232
1233 } else {
1234 ret = -ENODEV;
1235 }
1236
1237 if (ret != 0)
1238 return ret;
1239
1240 ret = xpc_setup_partitions();
1241 if (ret != 0) {
1242 dev_err(xpc_part, "can't get memory for partition structure\n");
1243 goto out_1;
1244 }
1245
1246 xpc_sysctl = register_sysctl_table(xpc_sys_dir);
1247
1248
1249
1250
1251
1252
1253 ret = xpc_setup_rsvd_page();
1254 if (ret != 0) {
1255 dev_err(xpc_part, "can't setup our reserved page\n");
1256 goto out_2;
1257 }
1258
1259
1260 ret = register_reboot_notifier(&xpc_reboot_notifier);
1261 if (ret != 0)
1262 dev_warn(xpc_part, "can't register reboot notifier\n");
1263
1264
1265 ret = register_die_notifier(&xpc_die_notifier);
1266 if (ret != 0)
1267 dev_warn(xpc_part, "can't register die notifier\n");
1268
1269
1270
1271
1272
1273 kthread = kthread_run(xpc_hb_checker, NULL, XPC_HB_CHECK_THREAD_NAME);
1274 if (IS_ERR(kthread)) {
1275 dev_err(xpc_part, "failed while forking hb check thread\n");
1276 ret = -EBUSY;
1277 goto out_3;
1278 }
1279
1280
1281
1282
1283
1284
1285 kthread = kthread_run(xpc_initiate_discovery, NULL,
1286 XPC_DISCOVERY_THREAD_NAME);
1287 if (IS_ERR(kthread)) {
1288 dev_err(xpc_part, "failed while forking discovery thread\n");
1289
1290
1291 complete(&xpc_discovery_exited);
1292
1293 xpc_do_exit(xpUnloading);
1294 return -EBUSY;
1295 }
1296
1297
1298 xpc_set_interface(xpc_initiate_connect, xpc_initiate_disconnect,
1299 xpc_initiate_send, xpc_initiate_send_notify,
1300 xpc_initiate_received, xpc_initiate_partid_to_nasids);
1301
1302 return 0;
1303
1304
1305out_3:
1306 xpc_teardown_rsvd_page();
1307
1308 (void)unregister_die_notifier(&xpc_die_notifier);
1309 (void)unregister_reboot_notifier(&xpc_reboot_notifier);
1310out_2:
1311 if (xpc_sysctl)
1312 unregister_sysctl_table(xpc_sysctl);
1313
1314 xpc_teardown_partitions();
1315out_1:
1316 if (is_shub())
1317 xpc_exit_sn2();
1318 else if (is_uv())
1319 xpc_exit_uv();
1320 return ret;
1321}
1322
1323module_init(xpc_init);
1324
1325void __exit
1326xpc_exit(void)
1327{
1328 xpc_do_exit(xpUnloading);
1329}
1330
1331module_exit(xpc_exit);
1332
1333MODULE_AUTHOR("Silicon Graphics, Inc.");
1334MODULE_DESCRIPTION("Cross Partition Communication (XPC) support");
1335MODULE_LICENSE("GPL");
1336
1337module_param(xpc_hb_interval, int, 0);
1338MODULE_PARM_DESC(xpc_hb_interval, "Number of seconds between "
1339 "heartbeat increments.");
1340
1341module_param(xpc_hb_check_interval, int, 0);
1342MODULE_PARM_DESC(xpc_hb_check_interval, "Number of seconds between "
1343 "heartbeat checks.");
1344
1345module_param(xpc_disengage_timelimit, int, 0);
1346MODULE_PARM_DESC(xpc_disengage_timelimit, "Number of seconds to wait "
1347 "for disengage to complete.");
1348
1349module_param(xpc_kdebug_ignore, int, 0);
1350MODULE_PARM_DESC(xpc_kdebug_ignore, "Should lack of heartbeat be ignored by "
1351 "other partitions when dropping into kdebug.");
1352