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  * (C) Copyright 2020 Hewlett Packard Enterprise Development LP
7  * Copyright (c) 2004-2008 Silicon Graphics, Inc.  All Rights Reserved.
8  */
9 
10 /*
11  * Cross Partition Communication (XPC) partition support.
12  *
13  *	This is the part of XPC that detects the presence/absence of
14  *	other partitions. It provides a heartbeat and monitors the
15  *	heartbeats of other partitions.
16  *
17  */
18 
19 #include <linux/device.h>
20 #include <linux/hardirq.h>
21 #include <linux/slab.h>
22 #include "xpc.h"
23 #include <asm/uv/uv_hub.h>
24 
25 /* XPC is exiting flag */
26 int xpc_exiting;
27 
28 /* this partition's reserved page pointers */
29 struct xpc_rsvd_page *xpc_rsvd_page;
30 static unsigned long *xpc_part_nasids;
31 unsigned long *xpc_mach_nasids;
32 
33 static int xpc_nasid_mask_nbytes;	/* #of bytes in nasid mask */
34 int xpc_nasid_mask_nlongs;	/* #of longs in nasid mask */
35 
36 struct xpc_partition *xpc_partitions;
37 
38 /*
39  * Guarantee that the kmalloc'd memory is cacheline aligned.
40  */
41 void *
42 xpc_kmalloc_cacheline_aligned(size_t size, gfp_t flags, void **base)
43 {
44 	/* see if kmalloc will give us cachline aligned memory by default */
45 	*base = kmalloc(size, flags);
46 	if (*base == NULL)
47 		return NULL;
48 
49 	if ((u64)*base == L1_CACHE_ALIGN((u64)*base))
50 		return *base;
51 
52 	kfree(*base);
53 
54 	/* nope, we'll have to do it ourselves */
55 	*base = kmalloc(size + L1_CACHE_BYTES, flags);
56 	if (*base == NULL)
57 		return NULL;
58 
59 	return (void *)L1_CACHE_ALIGN((u64)*base);
60 }
61 
62 /*
63  * Given a nasid, get the physical address of the  partition's reserved page
64  * for that nasid. This function returns 0 on any error.
65  */
66 static unsigned long
67 xpc_get_rsvd_page_pa(int nasid)
68 {
69 	enum xp_retval ret;
70 	u64 cookie = 0;
71 	unsigned long rp_pa = nasid;	/* seed with nasid */
72 	size_t len = 0;
73 	size_t buf_len = 0;
74 	void *buf = NULL;
75 	void *buf_base = NULL;
76 	enum xp_retval (*get_partition_rsvd_page_pa)
77 		(void *, u64 *, unsigned long *, size_t *) =
78 		xpc_arch_ops.get_partition_rsvd_page_pa;
79 
80 	while (1) {
81 
82 		/* !!! rp_pa will need to be _gpa on UV.
83 		 * ??? So do we save it into the architecture specific parts
84 		 * ??? of the xpc_partition structure? Do we rename this
85 		 * ??? function or have two versions? Rename rp_pa for UV to
86 		 * ??? rp_gpa?
87 		 */
88 		ret = get_partition_rsvd_page_pa(buf, &cookie, &rp_pa, &len);
89 
90 		dev_dbg(xpc_part, "SAL returned with ret=%d, cookie=0x%016lx, "
91 			"address=0x%016lx, len=0x%016lx\n", ret,
92 			(unsigned long)cookie, rp_pa, len);
93 
94 		if (ret != xpNeedMoreInfo)
95 			break;
96 
97 		if (len > buf_len) {
98 			kfree(buf_base);
99 			buf_len = L1_CACHE_ALIGN(len);
100 			buf = xpc_kmalloc_cacheline_aligned(buf_len, GFP_KERNEL,
101 							    &buf_base);
102 			if (buf_base == NULL) {
103 				dev_err(xpc_part, "unable to kmalloc "
104 					"len=0x%016lx\n", buf_len);
105 				ret = xpNoMemory;
106 				break;
107 			}
108 		}
109 
110 		ret = xp_remote_memcpy(xp_pa(buf), rp_pa, len);
111 		if (ret != xpSuccess) {
112 			dev_dbg(xpc_part, "xp_remote_memcpy failed %d\n", ret);
113 			break;
114 		}
115 	}
116 
117 	kfree(buf_base);
118 
119 	if (ret != xpSuccess)
120 		rp_pa = 0;
121 
122 	dev_dbg(xpc_part, "reserved page at phys address 0x%016lx\n", rp_pa);
123 	return rp_pa;
124 }
125 
126 /*
127  * Fill the partition reserved page with the information needed by
128  * other partitions to discover we are alive and establish initial
129  * communications.
130  */
131 int
132 xpc_setup_rsvd_page(void)
133 {
134 	int ret;
135 	struct xpc_rsvd_page *rp;
136 	unsigned long rp_pa;
137 	unsigned long new_ts_jiffies;
138 
139 	/* get the local reserved page's address */
140 
141 	preempt_disable();
142 	rp_pa = xpc_get_rsvd_page_pa(xp_cpu_to_nasid(smp_processor_id()));
143 	preempt_enable();
144 	if (rp_pa == 0) {
145 		dev_err(xpc_part, "SAL failed to locate the reserved page\n");
146 		return -ESRCH;
147 	}
148 	rp = (struct xpc_rsvd_page *)__va(xp_socket_pa(rp_pa));
149 
150 	if (rp->SAL_version < 3) {
151 		/* SAL_versions < 3 had a SAL_partid defined as a u8 */
152 		rp->SAL_partid &= 0xff;
153 	}
154 	BUG_ON(rp->SAL_partid != xp_partition_id);
155 
156 	if (rp->SAL_partid < 0 || rp->SAL_partid >= xp_max_npartitions) {
157 		dev_err(xpc_part, "the reserved page's partid of %d is outside "
158 			"supported range (< 0 || >= %d)\n", rp->SAL_partid,
159 			xp_max_npartitions);
160 		return -EINVAL;
161 	}
162 
163 	rp->version = XPC_RP_VERSION;
164 	rp->max_npartitions = xp_max_npartitions;
165 
166 	/* establish the actual sizes of the nasid masks */
167 	if (rp->SAL_version == 1) {
168 		/* SAL_version 1 didn't set the nasids_size field */
169 		rp->SAL_nasids_size = 128;
170 	}
171 	xpc_nasid_mask_nbytes = rp->SAL_nasids_size;
172 	xpc_nasid_mask_nlongs = BITS_TO_LONGS(rp->SAL_nasids_size *
173 					      BITS_PER_BYTE);
174 
175 	/* setup the pointers to the various items in the reserved page */
176 	xpc_part_nasids = XPC_RP_PART_NASIDS(rp);
177 	xpc_mach_nasids = XPC_RP_MACH_NASIDS(rp);
178 
179 	ret = xpc_arch_ops.setup_rsvd_page(rp);
180 	if (ret != 0)
181 		return ret;
182 
183 	/*
184 	 * Set timestamp of when reserved page was setup by XPC.
185 	 * This signifies to the remote partition that our reserved
186 	 * page is initialized.
187 	 */
188 	new_ts_jiffies = jiffies;
189 	if (new_ts_jiffies == 0 || new_ts_jiffies == rp->ts_jiffies)
190 		new_ts_jiffies++;
191 	rp->ts_jiffies = new_ts_jiffies;
192 
193 	xpc_rsvd_page = rp;
194 	return 0;
195 }
196 
197 void
198 xpc_teardown_rsvd_page(void)
199 {
200 	/* a zero timestamp indicates our rsvd page is not initialized */
201 	xpc_rsvd_page->ts_jiffies = 0;
202 }
203 
204 /*
205  * Get a copy of a portion of the remote partition's rsvd page.
206  *
207  * remote_rp points to a buffer that is cacheline aligned for BTE copies and
208  * is large enough to contain a copy of their reserved page header and
209  * part_nasids mask.
210  */
211 enum xp_retval
212 xpc_get_remote_rp(int nasid, unsigned long *discovered_nasids,
213 		  struct xpc_rsvd_page *remote_rp, unsigned long *remote_rp_pa)
214 {
215 	int l;
216 	enum xp_retval ret;
217 
218 	/* get the reserved page's physical address */
219 
220 	*remote_rp_pa = xpc_get_rsvd_page_pa(nasid);
221 	if (*remote_rp_pa == 0)
222 		return xpNoRsvdPageAddr;
223 
224 	/* pull over the reserved page header and part_nasids mask */
225 	ret = xp_remote_memcpy(xp_pa(remote_rp), *remote_rp_pa,
226 			       XPC_RP_HEADER_SIZE + xpc_nasid_mask_nbytes);
227 	if (ret != xpSuccess)
228 		return ret;
229 
230 	if (discovered_nasids != NULL) {
231 		unsigned long *remote_part_nasids =
232 		    XPC_RP_PART_NASIDS(remote_rp);
233 
234 		for (l = 0; l < xpc_nasid_mask_nlongs; l++)
235 			discovered_nasids[l] |= remote_part_nasids[l];
236 	}
237 
238 	/* zero timestamp indicates the reserved page has not been setup */
239 	if (remote_rp->ts_jiffies == 0)
240 		return xpRsvdPageNotSet;
241 
242 	if (XPC_VERSION_MAJOR(remote_rp->version) !=
243 	    XPC_VERSION_MAJOR(XPC_RP_VERSION)) {
244 		return xpBadVersion;
245 	}
246 
247 	/* check that both remote and local partids are valid for each side */
248 	if (remote_rp->SAL_partid < 0 ||
249 	    remote_rp->SAL_partid >= xp_max_npartitions ||
250 	    remote_rp->max_npartitions <= xp_partition_id) {
251 		return xpInvalidPartid;
252 	}
253 
254 	if (remote_rp->SAL_partid == xp_partition_id)
255 		return xpLocalPartid;
256 
257 	return xpSuccess;
258 }
259 
260 /*
261  * See if the other side has responded to a partition deactivate request
262  * from us. Though we requested the remote partition to deactivate with regard
263  * to us, we really only need to wait for the other side to disengage from us.
264  */
265 static int __xpc_partition_disengaged(struct xpc_partition *part,
266 				      bool from_timer)
267 {
268 	short partid = XPC_PARTID(part);
269 	int disengaged;
270 
271 	disengaged = !xpc_arch_ops.partition_engaged(partid);
272 	if (part->disengage_timeout) {
273 		if (!disengaged) {
274 			if (time_is_after_jiffies(part->disengage_timeout)) {
275 				/* timelimit hasn't been reached yet */
276 				return 0;
277 			}
278 
279 			/*
280 			 * Other side hasn't responded to our deactivate
281 			 * request in a timely fashion, so assume it's dead.
282 			 */
283 
284 			dev_info(xpc_part, "deactivate request to remote "
285 				 "partition %d timed out\n", partid);
286 			xpc_disengage_timedout = 1;
287 			xpc_arch_ops.assume_partition_disengaged(partid);
288 			disengaged = 1;
289 		}
290 		part->disengage_timeout = 0;
291 
292 		/* Cancel the timer function if not called from it */
293 		if (!from_timer)
294 			del_timer_sync(&part->disengage_timer);
295 
296 		DBUG_ON(part->act_state != XPC_P_AS_DEACTIVATING &&
297 			part->act_state != XPC_P_AS_INACTIVE);
298 		if (part->act_state != XPC_P_AS_INACTIVE)
299 			xpc_wakeup_channel_mgr(part);
300 
301 		xpc_arch_ops.cancel_partition_deactivation_request(part);
302 	}
303 	return disengaged;
304 }
305 
306 int xpc_partition_disengaged(struct xpc_partition *part)
307 {
308 	return __xpc_partition_disengaged(part, false);
309 }
310 
311 int xpc_partition_disengaged_from_timer(struct xpc_partition *part)
312 {
313 	return __xpc_partition_disengaged(part, true);
314 }
315 
316 /*
317  * Mark specified partition as active.
318  */
319 enum xp_retval
320 xpc_mark_partition_active(struct xpc_partition *part)
321 {
322 	unsigned long irq_flags;
323 	enum xp_retval ret;
324 
325 	dev_dbg(xpc_part, "setting partition %d to ACTIVE\n", XPC_PARTID(part));
326 
327 	spin_lock_irqsave(&part->act_lock, irq_flags);
328 	if (part->act_state == XPC_P_AS_ACTIVATING) {
329 		part->act_state = XPC_P_AS_ACTIVE;
330 		ret = xpSuccess;
331 	} else {
332 		DBUG_ON(part->reason == xpSuccess);
333 		ret = part->reason;
334 	}
335 	spin_unlock_irqrestore(&part->act_lock, irq_flags);
336 
337 	return ret;
338 }
339 
340 /*
341  * Start the process of deactivating the specified partition.
342  */
343 void
344 xpc_deactivate_partition(const int line, struct xpc_partition *part,
345 			 enum xp_retval reason)
346 {
347 	unsigned long irq_flags;
348 
349 	spin_lock_irqsave(&part->act_lock, irq_flags);
350 
351 	if (part->act_state == XPC_P_AS_INACTIVE) {
352 		XPC_SET_REASON(part, reason, line);
353 		spin_unlock_irqrestore(&part->act_lock, irq_flags);
354 		if (reason == xpReactivating) {
355 			/* we interrupt ourselves to reactivate partition */
356 			xpc_arch_ops.request_partition_reactivation(part);
357 		}
358 		return;
359 	}
360 	if (part->act_state == XPC_P_AS_DEACTIVATING) {
361 		if ((part->reason == xpUnloading && reason != xpUnloading) ||
362 		    reason == xpReactivating) {
363 			XPC_SET_REASON(part, reason, line);
364 		}
365 		spin_unlock_irqrestore(&part->act_lock, irq_flags);
366 		return;
367 	}
368 
369 	part->act_state = XPC_P_AS_DEACTIVATING;
370 	XPC_SET_REASON(part, reason, line);
371 
372 	spin_unlock_irqrestore(&part->act_lock, irq_flags);
373 
374 	/* ask remote partition to deactivate with regard to us */
375 	xpc_arch_ops.request_partition_deactivation(part);
376 
377 	/* set a timelimit on the disengage phase of the deactivation request */
378 	part->disengage_timeout = jiffies + (xpc_disengage_timelimit * HZ);
379 	part->disengage_timer.expires = part->disengage_timeout;
380 	add_timer(&part->disengage_timer);
381 
382 	dev_dbg(xpc_part, "bringing partition %d down, reason = %d\n",
383 		XPC_PARTID(part), reason);
384 
385 	xpc_partition_going_down(part, reason);
386 }
387 
388 /*
389  * Mark specified partition as inactive.
390  */
391 void
392 xpc_mark_partition_inactive(struct xpc_partition *part)
393 {
394 	unsigned long irq_flags;
395 
396 	dev_dbg(xpc_part, "setting partition %d to INACTIVE\n",
397 		XPC_PARTID(part));
398 
399 	spin_lock_irqsave(&part->act_lock, irq_flags);
400 	part->act_state = XPC_P_AS_INACTIVE;
401 	spin_unlock_irqrestore(&part->act_lock, irq_flags);
402 	part->remote_rp_pa = 0;
403 }
404 
405 /*
406  * SAL has provided a partition and machine mask.  The partition mask
407  * contains a bit for each even nasid in our partition.  The machine
408  * mask contains a bit for each even nasid in the entire machine.
409  *
410  * Using those two bit arrays, we can determine which nasids are
411  * known in the machine.  Each should also have a reserved page
412  * initialized if they are available for partitioning.
413  */
414 void
415 xpc_discovery(void)
416 {
417 	void *remote_rp_base;
418 	struct xpc_rsvd_page *remote_rp;
419 	unsigned long remote_rp_pa;
420 	int region;
421 	int region_size;
422 	int max_regions;
423 	int nasid;
424 	unsigned long *discovered_nasids;
425 	enum xp_retval ret;
426 
427 	remote_rp = xpc_kmalloc_cacheline_aligned(XPC_RP_HEADER_SIZE +
428 						  xpc_nasid_mask_nbytes,
429 						  GFP_KERNEL, &remote_rp_base);
430 	if (remote_rp == NULL)
431 		return;
432 
433 	discovered_nasids = kcalloc(xpc_nasid_mask_nlongs, sizeof(long),
434 				    GFP_KERNEL);
435 	if (discovered_nasids == NULL) {
436 		kfree(remote_rp_base);
437 		return;
438 	}
439 
440 	/*
441 	 * The term 'region' in this context refers to the minimum number of
442 	 * nodes that can comprise an access protection grouping. The access
443 	 * protection is in regards to memory, IOI and IPI.
444 	 */
445 	region_size = xp_region_size;
446 
447 	if (is_uv_system())
448 		max_regions = 256;
449 	else {
450 		max_regions = 64;
451 
452 		switch (region_size) {
453 		case 128:
454 			max_regions *= 2;
455 			fallthrough;
456 		case 64:
457 			max_regions *= 2;
458 			fallthrough;
459 		case 32:
460 			max_regions *= 2;
461 			region_size = 16;
462 		}
463 	}
464 
465 	for (region = 0; region < max_regions; region++) {
466 
467 		if (xpc_exiting)
468 			break;
469 
470 		dev_dbg(xpc_part, "searching region %d\n", region);
471 
472 		for (nasid = (region * region_size * 2);
473 		     nasid < ((region + 1) * region_size * 2); nasid += 2) {
474 
475 			if (xpc_exiting)
476 				break;
477 
478 			dev_dbg(xpc_part, "checking nasid %d\n", nasid);
479 
480 			if (test_bit(nasid / 2, xpc_part_nasids)) {
481 				dev_dbg(xpc_part, "PROM indicates Nasid %d is "
482 					"part of the local partition; skipping "
483 					"region\n", nasid);
484 				break;
485 			}
486 
487 			if (!(test_bit(nasid / 2, xpc_mach_nasids))) {
488 				dev_dbg(xpc_part, "PROM indicates Nasid %d was "
489 					"not on Numa-Link network at reset\n",
490 					nasid);
491 				continue;
492 			}
493 
494 			if (test_bit(nasid / 2, discovered_nasids)) {
495 				dev_dbg(xpc_part, "Nasid %d is part of a "
496 					"partition which was previously "
497 					"discovered\n", nasid);
498 				continue;
499 			}
500 
501 			/* pull over the rsvd page header & part_nasids mask */
502 
503 			ret = xpc_get_remote_rp(nasid, discovered_nasids,
504 						remote_rp, &remote_rp_pa);
505 			if (ret != xpSuccess) {
506 				dev_dbg(xpc_part, "unable to get reserved page "
507 					"from nasid %d, reason=%d\n", nasid,
508 					ret);
509 
510 				if (ret == xpLocalPartid)
511 					break;
512 
513 				continue;
514 			}
515 
516 			xpc_arch_ops.request_partition_activation(remote_rp,
517 							 remote_rp_pa, nasid);
518 		}
519 	}
520 
521 	kfree(discovered_nasids);
522 	kfree(remote_rp_base);
523 }
524 
525 /*
526  * Given a partid, get the nasids owned by that partition from the
527  * remote partition's reserved page.
528  */
529 enum xp_retval
530 xpc_initiate_partid_to_nasids(short partid, void *nasid_mask)
531 {
532 	struct xpc_partition *part;
533 	unsigned long part_nasid_pa;
534 
535 	part = &xpc_partitions[partid];
536 	if (part->remote_rp_pa == 0)
537 		return xpPartitionDown;
538 
539 	memset(nasid_mask, 0, xpc_nasid_mask_nbytes);
540 
541 	part_nasid_pa = (unsigned long)XPC_RP_PART_NASIDS(part->remote_rp_pa);
542 
543 	return xp_remote_memcpy(xp_pa(nasid_mask), part_nasid_pa,
544 				xpc_nasid_mask_nbytes);
545 }
546