arch/ia64/sn/kernel/xpc_partition.c

   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-2006 Silicon Graphics, Inc.  All Rights Reserved.
   7  */
   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
  20 #include <linux/kernel.h>
  21 #include <linux/sysctl.h>
  22 #include <linux/cache.h>
  23 #include <linux/mmzone.h>
  24 #include <linux/nodemask.h>
  25 #include <asm/uncached.h>
  26 #include <asm/sn/bte.h>
  27 #include <asm/sn/intr.h>
  28 #include <asm/sn/sn_sal.h>
  29 #include <asm/sn/nodepda.h>
  30 #include <asm/sn/addrs.h>
  31 #include <asm/sn/xpc.h>
  32
  33
  34 /* XPC is exiting flag */
  35 int xpc_exiting;
  36
  37
  38 /* SH_IPI_ACCESS shub register value on startup */
  39 static u64 xpc_sh1_IPI_access;
  40 static u64 xpc_sh2_IPI_access0;
  41 static u64 xpc_sh2_IPI_access1;
  42 static u64 xpc_sh2_IPI_access2;
  43 static u64 xpc_sh2_IPI_access3;
  44
  45
  46 /* original protection values for each node */
  47 u64 xpc_prot_vec[MAX_NUMNODES];
  48
  49
  50 /* this partition's reserved page pointers */
  51 struct xpc_rsvd_page *xpc_rsvd_page;
  52 static u64 *xpc_part_nasids;
  53 static u64 *xpc_mach_nasids;
  54 struct xpc_vars *xpc_vars;
  55 struct xpc_vars_part *xpc_vars_part;
  56
  57 static int xp_nasid_mask_bytes; /* actual size in bytes of nasid mask */
  58 static int xp_nasid_mask_words; /* actual size in words of nasid mask */
  59
  60
  61 /*
  62  * For performance reasons, each entry of xpc_partitions[] is cacheline
  63  * aligned. And xpc_partitions[] is padded with an additional entry at the
  64  * end so that the last legitimate entry doesn't share its cacheline with
  65  * another variable.
  66  */
  67 struct xpc_partition xpc_partitions[XP_MAX_PARTITIONS + 1];
  68
  69
  70 /*
  71  * Generic buffer used to store a local copy of portions of a remote
  72  * partition's reserved page (either its header and part_nasids mask,
  73  * or its vars).
  74  *
  75  * xpc_discovery runs only once and is a seperate thread that is
  76  * very likely going to be processing in parallel with receiving
  77  * interrupts.
  78  */
  79 char ____cacheline_aligned xpc_remote_copy_buffer[XPC_RP_HEADER_SIZE +
  80                                                         XP_NASID_MASK_BYTES];
  81
  82
  83 /*
  84  * Guarantee that the kmalloc'd memory is cacheline aligned.
  85  */
  86 static void *
  87 xpc_kmalloc_cacheline_aligned(size_t size, gfp_t flags, void **base)
  88 {
  89         /* see if kmalloc will give us cachline aligned memory by default */
  90         *base = kmalloc(size, flags);
  91         if (*base == NULL) {
  92                 return NULL;
  93         }
  94         if ((u64) *base == L1_CACHE_ALIGN((u64) *base)) {
  95                 return *base;
  96         }
  97         kfree(*base);
  98
  99         /* nope, we'll have to do it ourselves */
 100         *base = kmalloc(size + L1_CACHE_BYTES, flags);
 101         if (*base == NULL) {
 102                 return NULL;
 103         }
 104         return (void *) L1_CACHE_ALIGN((u64) *base);
 105 }
 106
 107
 108 /*
 109  * Given a nasid, get the physical address of the  partition's reserved page
 110  * for that nasid. This function returns 0 on any error.
 111  */
 112 static u64
 113 xpc_get_rsvd_page_pa(int nasid)
 114 {
 115         bte_result_t bte_res;
 116         s64 status;
 117         u64 cookie = 0;
 118         u64 rp_pa = nasid;      /* seed with nasid */
 119         u64 len = 0;
 120         u64 buf = buf;
 121         u64 buf_len = 0;
 122         void *buf_base = NULL;
 123
 124
 125         while (1) {
 126
 127                 status = sn_partition_reserved_page_pa(buf, &cookie, &rp_pa,
 128                                                                 &len);
 129
 130                 dev_dbg(xpc_part, "SAL returned with status=%li, cookie="
 131                         "0x%016lx, address=0x%016lx, len=0x%016lx\n",
 132                         status, cookie, rp_pa, len);
 133
 134                 if (status != SALRET_MORE_PASSES) {
 135                         break;
 136                 }
 137
 138                 if (L1_CACHE_ALIGN(len) > buf_len) {
 139                         kfree(buf_base);
 140                         buf_len = L1_CACHE_ALIGN(len);
 141                         buf = (u64) xpc_kmalloc_cacheline_aligned(buf_len,
 142                                                         GFP_KERNEL, &buf_base);
 143                         if (buf_base == NULL) {
 144                                 dev_err(xpc_part, "unable to kmalloc "
 145                                         "len=0x%016lx\n", buf_len);
 146                                 status = SALRET_ERROR;
 147                                 break;
 148                         }
 149                 }
 150
 151                 bte_res = xp_bte_copy(rp_pa, ia64_tpa(buf), buf_len,
 152                                         (BTE_NOTIFY | BTE_WACQUIRE), NULL);
 153                 if (bte_res != BTE_SUCCESS) {
 154                         dev_dbg(xpc_part, "xp_bte_copy failed %i\n", bte_res);
 155                         status = SALRET_ERROR;
 156                         break;
 157                 }
 158         }
 159
 160         kfree(buf_base);
 161
 162         if (status != SALRET_OK) {
 163                 rp_pa = 0;
 164         }
 165         dev_dbg(xpc_part, "reserved page at phys address 0x%016lx\n", rp_pa);
 166         return rp_pa;
 167 }
 168
 169
 170 /*
 171  * Fill the partition reserved page with the information needed by
 172  * other partitions to discover we are alive and establish initial
 173  * communications.
 174  */
 175 struct xpc_rsvd_page *
 176 xpc_rsvd_page_init(void)
 177 {
 178         struct xpc_rsvd_page *rp;
 179         AMO_t *amos_page;
 180         u64 rp_pa, nasid_array = 0;
 181         int i, ret;
 182
 183
 184         /* get the local reserved page's address */
 185
 186         preempt_disable();
 187         rp_pa = xpc_get_rsvd_page_pa(cpuid_to_nasid(smp_processor_id()));
 188         preempt_enable();
 189         if (rp_pa == 0) {
 190                 dev_err(xpc_part, "SAL failed to locate the reserved page\n");
 191                 return NULL;
 192         }
 193         rp = (struct xpc_rsvd_page *) __va(rp_pa);
 194
 195         if (rp->partid != sn_partition_id) {
 196                 dev_err(xpc_part, "the reserved page's partid of %d should be "
 197                         "%d\n", rp->partid, sn_partition_id);
 198                 return NULL;
 199         }
 200
 201         rp->version = XPC_RP_VERSION;
 202
 203         /* establish the actual sizes of the nasid masks */
 204         if (rp->SAL_version == 1) {
 205                 /* SAL_version 1 didn't set the nasids_size field */
 206                 rp->nasids_size = 128;
 207         }
 208         xp_nasid_mask_bytes = rp->nasids_size;
 209         xp_nasid_mask_words = xp_nasid_mask_bytes / 8;
 210
 211         /* setup the pointers to the various items in the reserved page */
 212         xpc_part_nasids = XPC_RP_PART_NASIDS(rp);
 213         xpc_mach_nasids = XPC_RP_MACH_NASIDS(rp);
 214         xpc_vars = XPC_RP_VARS(rp);
 215         xpc_vars_part = XPC_RP_VARS_PART(rp);
 216
 217         /*
 218          * Before clearing xpc_vars, see if a page of AMOs had been previously
 219          * allocated. If not we'll need to allocate one and set permissions
 220          * so that cross-partition AMOs are allowed.
 221          *
 222          * The allocated AMO page needs MCA reporting to remain disabled after
 223          * XPC has unloaded.  To make this work, we keep a copy of the pointer
 224          * to this page (i.e., amos_page) in the struct xpc_vars structure,
 225          * which is pointed to by the reserved page, and re-use that saved copy
 226          * on subsequent loads of XPC. This AMO page is never freed, and its
 227          * memory protections are never restricted.
 228          */
 229         if ((amos_page = xpc_vars->amos_page) == NULL) {
 230                 amos_page = (AMO_t *) TO_AMO(uncached_alloc_page(0));
 231                 if (amos_page == NULL) {
 232                         dev_err(xpc_part, "can't allocate page of AMOs\n");
 233                         return NULL;
 234                 }
 235
 236                 /*
 237                  * Open up AMO-R/W to cpu.  This is done for Shub 1.1 systems
 238                  * when xpc_allow_IPI_ops() is called via xpc_hb_init().
 239                  */
 240                 if (!enable_shub_wars_1_1()) {
 241                         ret = sn_change_memprotect(ia64_tpa((u64) amos_page),
 242                                         PAGE_SIZE, SN_MEMPROT_ACCESS_CLASS_1,
 243                                         &nasid_array);
 244                         if (ret != 0) {
 245                                 dev_err(xpc_part, "can't change memory "
 246                                         "protections\n");
 247                                 uncached_free_page(__IA64_UNCACHED_OFFSET |
 248                                                    TO_PHYS((u64) amos_page));
 249                                 return NULL;
 250                         }
 251                 }
 252         } else if (!IS_AMO_ADDRESS((u64) amos_page)) {
 253                 /*
 254                  * EFI's XPBOOT can also set amos_page in the reserved page,
 255                  * but it happens to leave it as an uncached physical address
 256                  * and we need it to be an uncached virtual, so we'll have to
 257                  * convert it.
 258                  */
 259                 if (!IS_AMO_PHYS_ADDRESS((u64) amos_page)) {
 260                         dev_err(xpc_part, "previously used amos_page address "
 261                                 "is bad = 0x%p\n", (void *) amos_page);
 262                         return NULL;
 263                 }
 264                 amos_page = (AMO_t *) TO_AMO((u64) amos_page);
 265         }
 266
 267         /* clear xpc_vars */
 268         memset(xpc_vars, 0, sizeof(struct xpc_vars));
 269
 270         xpc_vars->version = XPC_V_VERSION;
 271         xpc_vars->act_nasid = cpuid_to_nasid(0);
 272         xpc_vars->act_phys_cpuid = cpu_physical_id(0);
 273         xpc_vars->vars_part_pa = __pa(xpc_vars_part);
 274         xpc_vars->amos_page_pa = ia64_tpa((u64) amos_page);
 275         xpc_vars->amos_page = amos_page;  /* save for next load of XPC */
 276
 277
 278         /* clear xpc_vars_part */
 279         memset((u64 *) xpc_vars_part, 0, sizeof(struct xpc_vars_part) *
 280                                                         XP_MAX_PARTITIONS);
 281
 282         /* initialize the activate IRQ related AMO variables */
 283         for (i = 0; i < xp_nasid_mask_words; i++) {
 284                 (void) xpc_IPI_init(XPC_ACTIVATE_IRQ_AMOS + i);
 285         }
 286
 287         /* initialize the engaged remote partitions related AMO variables */
 288         (void) xpc_IPI_init(XPC_ENGAGED_PARTITIONS_AMO);
 289         (void) xpc_IPI_init(XPC_DISENGAGE_REQUEST_AMO);
 290
 291         /* timestamp of when reserved page was setup by XPC */
 292         rp->stamp = CURRENT_TIME;
 293
 294         /*
 295          * This signifies to the remote partition that our reserved
 296          * page is initialized.
 297          */
 298         rp->vars_pa = __pa(xpc_vars);
 299
 300         return rp;
 301 }
 302
 303
 304 /*
 305  * Change protections to allow IPI operations (and AMO operations on
 306  * Shub 1.1 systems).
 307  */
 308 void
 309 xpc_allow_IPI_ops(void)
 310 {
 311         int node;
 312         int nasid;
 313
 314
 315         // >>> Change SH_IPI_ACCESS code to use SAL call once it is available.
 316
 317         if (is_shub2()) {
 318                 xpc_sh2_IPI_access0 =
 319                         (u64) HUB_L((u64 *) LOCAL_MMR_ADDR(SH2_IPI_ACCESS0));
 320                 xpc_sh2_IPI_access1 =
 321                         (u64) HUB_L((u64 *) LOCAL_MMR_ADDR(SH2_IPI_ACCESS1));
 322                 xpc_sh2_IPI_access2 =
 323                         (u64) HUB_L((u64 *) LOCAL_MMR_ADDR(SH2_IPI_ACCESS2));
 324                 xpc_sh2_IPI_access3 =
 325                         (u64) HUB_L((u64 *) LOCAL_MMR_ADDR(SH2_IPI_ACCESS3));
 326
 327                 for_each_online_node(node) {
 328                         nasid = cnodeid_to_nasid(node);
 329                         HUB_S((u64 *) GLOBAL_MMR_ADDR(nasid, SH2_IPI_ACCESS0),
 330                                                                 -1UL);
 331                         HUB_S((u64 *) GLOBAL_MMR_ADDR(nasid, SH2_IPI_ACCESS1),
 332                                                                 -1UL);
 333                         HUB_S((u64 *) GLOBAL_MMR_ADDR(nasid, SH2_IPI_ACCESS2),
 334                                                                 -1UL);
 335                         HUB_S((u64 *) GLOBAL_MMR_ADDR(nasid, SH2_IPI_ACCESS3),
 336                                                                 -1UL);
 337                 }
 338
 339         } else {
 340                 xpc_sh1_IPI_access =
 341                         (u64) HUB_L((u64 *) LOCAL_MMR_ADDR(SH1_IPI_ACCESS));
 342
 343                 for_each_online_node(node) {
 344                         nasid = cnodeid_to_nasid(node);
 345                         HUB_S((u64 *) GLOBAL_MMR_ADDR(nasid, SH1_IPI_ACCESS),
 346                                                                 -1UL);
 347
 348                         /*
 349                          * Since the BIST collides with memory operations on
 350                          * SHUB 1.1 sn_change_memprotect() cannot be used.
 351                          */
 352                         if (enable_shub_wars_1_1()) {
 353                                 /* open up everything */
 354                                 xpc_prot_vec[node] = (u64) HUB_L((u64 *)
 355                                                 GLOBAL_MMR_ADDR(nasid,
 356                                                 SH1_MD_DQLP_MMR_DIR_PRIVEC0));
 357                                 HUB_S((u64 *) GLOBAL_MMR_ADDR(nasid,
 358                                                 SH1_MD_DQLP_MMR_DIR_PRIVEC0),
 359                                                                 -1UL);
 360                                 HUB_S((u64 *) GLOBAL_MMR_ADDR(nasid,
 361                                                 SH1_MD_DQRP_MMR_DIR_PRIVEC0),
 362                                                                 -1UL);
 363                         }
 364                 }
 365         }
 366 }
 367
 368
 369 /*
 370  * Restrict protections to disallow IPI operations (and AMO operations on
 371  * Shub 1.1 systems).
 372  */
 373 void
 374 xpc_restrict_IPI_ops(void)
 375 {
 376         int node;
 377         int nasid;
 378
 379
 380         // >>> Change SH_IPI_ACCESS code to use SAL call once it is available.
 381
 382         if (is_shub2()) {
 383
 384                 for_each_online_node(node) {
 385                         nasid = cnodeid_to_nasid(node);
 386                         HUB_S((u64 *) GLOBAL_MMR_ADDR(nasid, SH2_IPI_ACCESS0),
 387                                                         xpc_sh2_IPI_access0);
 388                         HUB_S((u64 *) GLOBAL_MMR_ADDR(nasid, SH2_IPI_ACCESS1),
 389                                                         xpc_sh2_IPI_access1);
 390                         HUB_S((u64 *) GLOBAL_MMR_ADDR(nasid, SH2_IPI_ACCESS2),
 391                                                         xpc_sh2_IPI_access2);
 392                         HUB_S((u64 *) GLOBAL_MMR_ADDR(nasid, SH2_IPI_ACCESS3),
 393                                                         xpc_sh2_IPI_access3);
 394                 }
 395
 396         } else {
 397
 398                 for_each_online_node(node) {
 399                         nasid = cnodeid_to_nasid(node);
 400                         HUB_S((u64 *) GLOBAL_MMR_ADDR(nasid, SH1_IPI_ACCESS),
 401                                                         xpc_sh1_IPI_access);
 402
 403                         if (enable_shub_wars_1_1()) {
 404                                 HUB_S((u64 *) GLOBAL_MMR_ADDR(nasid,
 405                                                 SH1_MD_DQLP_MMR_DIR_PRIVEC0),
 406                                                         xpc_prot_vec[node]);
 407                                 HUB_S((u64 *) GLOBAL_MMR_ADDR(nasid,
 408                                                 SH1_MD_DQRP_MMR_DIR_PRIVEC0),
 409                                                         xpc_prot_vec[node]);
 410                         }
 411                 }
 412         }
 413 }
 414
 415
 416 /*
 417  * At periodic intervals, scan through all active partitions and ensure
 418  * their heartbeat is still active.  If not, the partition is deactivated.
 419  */
 420 void
 421 xpc_check_remote_hb(void)
 422 {
 423         struct xpc_vars *remote_vars;
 424         struct xpc_partition *part;
 425         partid_t partid;
 426         bte_result_t bres;
 427
 428
 429         remote_vars = (struct xpc_vars *) xpc_remote_copy_buffer;
 430
 431         for (partid = 1; partid < XP_MAX_PARTITIONS; partid++) {
 432
 433                 if (xpc_exiting) {
 434                         break;
 435                 }
 436
 437                 if (partid == sn_partition_id) {
 438                         continue;
 439                 }
 440
 441                 part = &xpc_partitions[partid];
 442
 443                 if (part->act_state == XPC_P_INACTIVE ||
 444                                 part->act_state == XPC_P_DEACTIVATING) {
 445                         continue;
 446                 }
 447
 448                 /* pull the remote_hb cache line */
 449                 bres = xp_bte_copy(part->remote_vars_pa,
 450                                         ia64_tpa((u64) remote_vars),
 451                                         XPC_RP_VARS_SIZE,
 452                                         (BTE_NOTIFY | BTE_WACQUIRE), NULL);
 453                 if (bres != BTE_SUCCESS) {
 454                         XPC_DEACTIVATE_PARTITION(part,
 455                                                 xpc_map_bte_errors(bres));
 456                         continue;
 457                 }
 458
 459                 dev_dbg(xpc_part, "partid = %d, heartbeat = %ld, last_heartbeat"
 460                         " = %ld, heartbeat_offline = %ld, HB_mask = 0x%lx\n",
 461                         partid, remote_vars->heartbeat, part->last_heartbeat,
 462                         remote_vars->heartbeat_offline,
 463                         remote_vars->heartbeating_to_mask);
 464
 465                 if (((remote_vars->heartbeat == part->last_heartbeat) &&
 466                         (remote_vars->heartbeat_offline == 0)) ||
 467                              !xpc_hb_allowed(sn_partition_id, remote_vars)) {
 468
 469                         XPC_DEACTIVATE_PARTITION(part, xpcNoHeartbeat);
 470                         continue;
 471                 }
 472
 473                 part->last_heartbeat = remote_vars->heartbeat;
 474         }
 475 }
 476
 477
 478 /*
 479  * Get a copy of a portion of the remote partition's rsvd page.
 480  *
 481  * remote_rp points to a buffer that is cacheline aligned for BTE copies and
 482  * is large enough to contain a copy of their reserved page header and
 483  * part_nasids mask.
 484  */
 485 static enum xpc_retval
 486 xpc_get_remote_rp(int nasid, u64 *discovered_nasids,
 487                 struct xpc_rsvd_page *remote_rp, u64 *remote_rp_pa)
 488 {
 489         int bres, i;
 490
 491
 492         /* get the reserved page's physical address */
 493
 494         *remote_rp_pa = xpc_get_rsvd_page_pa(nasid);
 495         if (*remote_rp_pa == 0) {
 496                 return xpcNoRsvdPageAddr;
 497         }
 498
 499
 500         /* pull over the reserved page header and part_nasids mask */
 501
 502         bres = xp_bte_copy(*remote_rp_pa, ia64_tpa((u64) remote_rp),
 503                                 XPC_RP_HEADER_SIZE + xp_nasid_mask_bytes,
 504                                 (BTE_NOTIFY | BTE_WACQUIRE), NULL);
 505         if (bres != BTE_SUCCESS) {
 506                 return xpc_map_bte_errors(bres);
 507         }
 508
 509
 510         if (discovered_nasids != NULL) {
 511                 u64 *remote_part_nasids = XPC_RP_PART_NASIDS(remote_rp);
 512
 513
 514                 for (i = 0; i < xp_nasid_mask_words; i++) {
 515                         discovered_nasids[i] |= remote_part_nasids[i];
 516                 }
 517         }
 518
 519
 520         /* check that the partid is for another partition */
 521
 522         if (remote_rp->partid < 1 ||
 523                                 remote_rp->partid > (XP_MAX_PARTITIONS - 1)) {
 524                 return xpcInvalidPartid;
 525         }
 526
 527         if (remote_rp->partid == sn_partition_id) {
 528                 return xpcLocalPartid;
 529         }
 530
 531
 532         if (XPC_VERSION_MAJOR(remote_rp->version) !=
 533                                         XPC_VERSION_MAJOR(XPC_RP_VERSION)) {
 534                 return xpcBadVersion;
 535         }
 536
 537         return xpcSuccess;
 538 }
 539
 540
 541 /*
 542  * Get a copy of the remote partition's XPC variables from the reserved page.
 543  *
 544  * remote_vars points to a buffer that is cacheline aligned for BTE copies and
 545  * assumed to be of size XPC_RP_VARS_SIZE.
 546  */
 547 static enum xpc_retval
 548 xpc_get_remote_vars(u64 remote_vars_pa, struct xpc_vars *remote_vars)
 549 {
 550         int bres;
 551
 552
 553         if (remote_vars_pa == 0) {
 554                 return xpcVarsNotSet;
 555         }
 556
 557
 558         /* pull over the cross partition variables */
 559
 560         bres = xp_bte_copy(remote_vars_pa, ia64_tpa((u64) remote_vars),
 561                                 XPC_RP_VARS_SIZE,
 562                                 (BTE_NOTIFY | BTE_WACQUIRE), NULL);
 563         if (bres != BTE_SUCCESS) {
 564                 return xpc_map_bte_errors(bres);
 565         }
 566
 567         if (XPC_VERSION_MAJOR(remote_vars->version) !=
 568                                         XPC_VERSION_MAJOR(XPC_V_VERSION)) {
 569                 return xpcBadVersion;
 570         }
 571
 572         return xpcSuccess;
 573 }
 574
 575
 576 /*
 577  * Update the remote partition's info.
 578  */
 579 static void
 580 xpc_update_partition_info(struct xpc_partition *part, u8 remote_rp_version,
 581                 struct timespec *remote_rp_stamp, u64 remote_rp_pa,
 582                 u64 remote_vars_pa, struct xpc_vars *remote_vars)
 583 {
 584         part->remote_rp_version = remote_rp_version;
 585         dev_dbg(xpc_part, "  remote_rp_version = 0x%016lx\n",
 586                 part->remote_rp_version);
 587
 588         part->remote_rp_stamp = *remote_rp_stamp;
 589         dev_dbg(xpc_part, "  remote_rp_stamp (tv_sec = 0x%lx tv_nsec = 0x%lx\n",
 590                 part->remote_rp_stamp.tv_sec, part->remote_rp_stamp.tv_nsec);
 591
 592         part->remote_rp_pa = remote_rp_pa;
 593         dev_dbg(xpc_part, "  remote_rp_pa = 0x%016lx\n", part->remote_rp_pa);
 594
 595         part->remote_vars_pa = remote_vars_pa;
 596         dev_dbg(xpc_part, "  remote_vars_pa = 0x%016lx\n",
 597                 part->remote_vars_pa);
 598
 599         part->last_heartbeat = remote_vars->heartbeat;
 600         dev_dbg(xpc_part, "  last_heartbeat = 0x%016lx\n",
 601                 part->last_heartbeat);
 602
 603         part->remote_vars_part_pa = remote_vars->vars_part_pa;
 604         dev_dbg(xpc_part, "  remote_vars_part_pa = 0x%016lx\n",
 605                 part->remote_vars_part_pa);
 606
 607         part->remote_act_nasid = remote_vars->act_nasid;
 608         dev_dbg(xpc_part, "  remote_act_nasid = 0x%x\n",
 609                 part->remote_act_nasid);
 610
 611         part->remote_act_phys_cpuid = remote_vars->act_phys_cpuid;
 612         dev_dbg(xpc_part, "  remote_act_phys_cpuid = 0x%x\n",
 613                 part->remote_act_phys_cpuid);
 614
 615         part->remote_amos_page_pa = remote_vars->amos_page_pa;
 616         dev_dbg(xpc_part, "  remote_amos_page_pa = 0x%lx\n",
 617                 part->remote_amos_page_pa);
 618
 619         part->remote_vars_version = remote_vars->version;
 620         dev_dbg(xpc_part, "  remote_vars_version = 0x%x\n",
 621                 part->remote_vars_version);
 622 }
 623
 624
 625 /*
 626  * Prior code has determined the nasid which generated an IPI.  Inspect
 627  * that nasid to determine if its partition needs to be activated or
 628  * deactivated.
 629  *
 630  * A partition is consider "awaiting activation" if our partition
 631  * flags indicate it is not active and it has a heartbeat.  A
 632  * partition is considered "awaiting deactivation" if our partition
 633  * flags indicate it is active but it has no heartbeat or it is not
 634  * sending its heartbeat to us.
 635  *
 636  * To determine the heartbeat, the remote nasid must have a properly
 637  * initialized reserved page.
 638  */
 639 static void
 640 xpc_identify_act_IRQ_req(int nasid)
 641 {
 642         struct xpc_rsvd_page *remote_rp;
 643         struct xpc_vars *remote_vars;
 644         u64 remote_rp_pa;
 645         u64 remote_vars_pa;
 646         int remote_rp_version;
 647         int reactivate = 0;
 648         int stamp_diff;
 649         struct timespec remote_rp_stamp = { 0, 0 };
 650         partid_t partid;
 651         struct xpc_partition *part;
 652         enum xpc_retval ret;
 653
 654
 655         /* pull over the reserved page structure */
 656
 657         remote_rp = (struct xpc_rsvd_page *) xpc_remote_copy_buffer;
 658
 659         ret = xpc_get_remote_rp(nasid, NULL, remote_rp, &remote_rp_pa);
 660         if (ret != xpcSuccess) {
 661                 dev_warn(xpc_part, "unable to get reserved page from nasid %d, "
 662                         "which sent interrupt, reason=%d\n", nasid, ret);
 663                 return;
 664         }
 665
 666         remote_vars_pa = remote_rp->vars_pa;
 667         remote_rp_version = remote_rp->version;
 668         if (XPC_SUPPORTS_RP_STAMP(remote_rp_version)) {
 669                 remote_rp_stamp = remote_rp->stamp;
 670         }
 671         partid = remote_rp->partid;
 672         part = &xpc_partitions[partid];
 673
 674
 675         /* pull over the cross partition variables */
 676
 677         remote_vars = (struct xpc_vars *) xpc_remote_copy_buffer;
 678
 679         ret = xpc_get_remote_vars(remote_vars_pa, remote_vars);
 680         if (ret != xpcSuccess) {
 681
 682                 dev_warn(xpc_part, "unable to get XPC variables from nasid %d, "
 683                         "which sent interrupt, reason=%d\n", nasid, ret);
 684
 685                 XPC_DEACTIVATE_PARTITION(part, ret);
 686                 return;
 687         }
 688
 689
 690         part->act_IRQ_rcvd++;
 691
 692         dev_dbg(xpc_part, "partid for nasid %d is %d; IRQs = %d; HB = "
 693                 "%ld:0x%lx\n", (int) nasid, (int) partid, part->act_IRQ_rcvd,
 694                 remote_vars->heartbeat, remote_vars->heartbeating_to_mask);
 695
 696         if (xpc_partition_disengaged(part) &&
 697                                         part->act_state == XPC_P_INACTIVE) {
 698
 699                 xpc_update_partition_info(part, remote_rp_version,
 700                                         &remote_rp_stamp, remote_rp_pa,
 701                                         remote_vars_pa, remote_vars);
 702
 703                 if (XPC_SUPPORTS_DISENGAGE_REQUEST(part->remote_vars_version)) {
 704                         if (xpc_partition_disengage_requested(1UL << partid)) {
 705                                 /*
 706                                  * Other side is waiting on us to disengage,
 707                                  * even though we already have.
 708                                  */
 709                                 return;
 710                         }
 711                 } else {
 712                         /* other side doesn't support disengage requests */
 713                         xpc_clear_partition_disengage_request(1UL << partid);
 714                 }
 715
 716                 xpc_activate_partition(part);
 717                 return;
 718         }
 719
 720         DBUG_ON(part->remote_rp_version == 0);
 721         DBUG_ON(part->remote_vars_version == 0);
 722
 723         if (!XPC_SUPPORTS_RP_STAMP(part->remote_rp_version)) {
 724                 DBUG_ON(XPC_SUPPORTS_DISENGAGE_REQUEST(part->
 725                                                         remote_vars_version));
 726
 727                 if (!XPC_SUPPORTS_RP_STAMP(remote_rp_version)) {
 728                         DBUG_ON(XPC_SUPPORTS_DISENGAGE_REQUEST(remote_vars->
 729                                                                 version));
 730                         /* see if the other side rebooted */
 731                         if (part->remote_amos_page_pa ==
 732                                 remote_vars->amos_page_pa &&
 733                                         xpc_hb_allowed(sn_partition_id,
 734                                                                 remote_vars)) {
 735                                 /* doesn't look that way, so ignore the IPI */
 736                                 return;
 737                         }
 738                 }
 739
 740                 /*
 741                  * Other side rebooted and previous XPC didn't support the
 742                  * disengage request, so we don't need to do anything special.
 743                  */
 744
 745                 xpc_update_partition_info(part, remote_rp_version,
 746                                                 &remote_rp_stamp, remote_rp_pa,
 747                                                 remote_vars_pa, remote_vars);
 748                 part->reactivate_nasid = nasid;
 749                 XPC_DEACTIVATE_PARTITION(part, xpcReactivating);
 750                 return;
 751         }
 752
 753         DBUG_ON(!XPC_SUPPORTS_DISENGAGE_REQUEST(part->remote_vars_version));
 754
 755         if (!XPC_SUPPORTS_RP_STAMP(remote_rp_version)) {
 756                 DBUG_ON(!XPC_SUPPORTS_DISENGAGE_REQUEST(remote_vars->version));
 757
 758                 /*
 759                  * Other side rebooted and previous XPC did support the
 760                  * disengage request, but the new one doesn't.
 761                  */
 762
 763                 xpc_clear_partition_engaged(1UL << partid);
 764                 xpc_clear_partition_disengage_request(1UL << partid);
 765
 766                 xpc_update_partition_info(part, remote_rp_version,
 767                                                 &remote_rp_stamp, remote_rp_pa,
 768                                                 remote_vars_pa, remote_vars);
 769                 reactivate = 1;
 770
 771         } else {
 772                 DBUG_ON(!XPC_SUPPORTS_DISENGAGE_REQUEST(remote_vars->version));
 773
 774                 stamp_diff = xpc_compare_stamps(&part->remote_rp_stamp,
 775                                                         &remote_rp_stamp);
 776                 if (stamp_diff != 0) {
 777                         DBUG_ON(stamp_diff >= 0);
 778
 779                         /*
 780                          * Other side rebooted and the previous XPC did support
 781                          * the disengage request, as does the new one.
 782                          */
 783
 784                         DBUG_ON(xpc_partition_engaged(1UL << partid));
 785                         DBUG_ON(xpc_partition_disengage_requested(1UL <<
 786                                                                 partid));
 787
 788                         xpc_update_partition_info(part, remote_rp_version,
 789                                                 &remote_rp_stamp, remote_rp_pa,
 790                                                 remote_vars_pa, remote_vars);
 791                         reactivate = 1;
 792                 }
 793         }
 794
 795         if (part->disengage_request_timeout > 0 &&
 796                                         !xpc_partition_disengaged(part)) {
 797                 /* still waiting on other side to disengage from us */
 798                 return;
 799         }
 800
 801         if (reactivate) {
 802                 part->reactivate_nasid = nasid;
 803                 XPC_DEACTIVATE_PARTITION(part, xpcReactivating);
 804
 805         } else if (XPC_SUPPORTS_DISENGAGE_REQUEST(part->remote_vars_version) &&
 806                         xpc_partition_disengage_requested(1UL << partid)) {
 807                 XPC_DEACTIVATE_PARTITION(part, xpcOtherGoingDown);
 808         }
 809 }
 810
 811
 812 /*
 813  * Loop through the activation AMO variables and process any bits
 814  * which are set.  Each bit indicates a nasid sending a partition
 815  * activation or deactivation request.
 816  *
 817  * Return #of IRQs detected.
 818  */
 819 int
 820 xpc_identify_act_IRQ_sender(void)
 821 {
 822         int word, bit;
 823         u64 nasid_mask;
 824         u64 nasid;                      /* remote nasid */
 825         int n_IRQs_detected = 0;
 826         AMO_t *act_amos;
 827
 828
 829         act_amos = xpc_vars->amos_page + XPC_ACTIVATE_IRQ_AMOS;
 830
 831
 832         /* scan through act AMO variable looking for non-zero entries */
 833         for (word = 0; word < xp_nasid_mask_words; word++) {
 834
 835                 if (xpc_exiting) {
 836                         break;
 837                 }
 838
 839                 nasid_mask = xpc_IPI_receive(&act_amos[word]);
 840                 if (nasid_mask == 0) {
 841                         /* no IRQs from nasids in this variable */
 842                         continue;
 843                 }
 844
 845                 dev_dbg(xpc_part, "AMO[%d] gave back 0x%lx\n", word,
 846                         nasid_mask);
 847
 848
 849                 /*
 850                  * If this nasid has been added to the machine since
 851                  * our partition was reset, this will retain the
 852                  * remote nasid in our reserved pages machine mask.
 853                  * This is used in the event of module reload.
 854                  */
 855                 xpc_mach_nasids[word] |= nasid_mask;
 856
 857
 858                 /* locate the nasid(s) which sent interrupts */
 859
 860                 for (bit = 0; bit < (8 * sizeof(u64)); bit++) {
 861                         if (nasid_mask & (1UL << bit)) {
 862                                 n_IRQs_detected++;
 863                                 nasid = XPC_NASID_FROM_W_B(word, bit);
 864                                 dev_dbg(xpc_part, "interrupt from nasid %ld\n",
 865                                         nasid);
 866                                 xpc_identify_act_IRQ_req(nasid);
 867                         }
 868                 }
 869         }
 870         return n_IRQs_detected;
 871 }
 872
 873
 874 /*
 875  * See if the other side has responded to a partition disengage request
 876  * from us.
 877  */
 878 int
 879 xpc_partition_disengaged(struct xpc_partition *part)
 880 {
 881         partid_t partid = XPC_PARTID(part);
 882         int disengaged;
 883
 884
 885         disengaged = (xpc_partition_engaged(1UL << partid) == 0);
 886         if (part->disengage_request_timeout) {
 887                 if (!disengaged) {
 888                         if (jiffies < part->disengage_request_timeout) {
 889                                 /* timelimit hasn't been reached yet */
 890                                 return 0;
 891                         }
 892
 893                         /*
 894                          * Other side hasn't responded to our disengage
 895                          * request in a timely fashion, so assume it's dead.
 896                          */
 897
 898                         dev_info(xpc_part, "disengage from remote partition %d "
 899                                 "timed out\n", partid);
 900                         xpc_disengage_request_timedout = 1;
 901                         xpc_clear_partition_engaged(1UL << partid);
 902                         disengaged = 1;
 903                 }
 904                 part->disengage_request_timeout = 0;
 905
 906                 /* cancel the timer function, provided it's not us */
 907                 if (!in_interrupt()) {
 908                         del_singleshot_timer_sync(&part->
 909                                                       disengage_request_timer);
 910                 }
 911
 912                 DBUG_ON(part->act_state != XPC_P_DEACTIVATING &&
 913                                         part->act_state != XPC_P_INACTIVE);
 914                 if (part->act_state != XPC_P_INACTIVE) {
 915                         xpc_wakeup_channel_mgr(part);
 916                 }
 917
 918                 if (XPC_SUPPORTS_DISENGAGE_REQUEST(part->remote_vars_version)) {
 919                         xpc_cancel_partition_disengage_request(part);
 920                 }
 921         }
 922         return disengaged;
 923 }
 924
 925
 926 /*
 927  * Mark specified partition as active.
 928  */
 929 enum xpc_retval
 930 xpc_mark_partition_active(struct xpc_partition *part)
 931 {
 932         unsigned long irq_flags;
 933         enum xpc_retval ret;
 934
 935
 936         dev_dbg(xpc_part, "setting partition %d to ACTIVE\n", XPC_PARTID(part));
 937
 938         spin_lock_irqsave(&part->act_lock, irq_flags);
 939         if (part->act_state == XPC_P_ACTIVATING) {
 940                 part->act_state = XPC_P_ACTIVE;
 941                 ret = xpcSuccess;
 942         } else {
 943                 DBUG_ON(part->reason == xpcSuccess);
 944                 ret = part->reason;
 945         }
 946         spin_unlock_irqrestore(&part->act_lock, irq_flags);
 947
 948         return ret;
 949 }
 950
 951
 952 /*
 953  * Notify XPC that the partition is down.
 954  */
 955 void
 956 xpc_deactivate_partition(const int line, struct xpc_partition *part,
 957                                 enum xpc_retval reason)
 958 {
 959         unsigned long irq_flags;
 960
 961
 962         spin_lock_irqsave(&part->act_lock, irq_flags);
 963
 964         if (part->act_state == XPC_P_INACTIVE) {
 965                 XPC_SET_REASON(part, reason, line);
 966                 spin_unlock_irqrestore(&part->act_lock, irq_flags);
 967                 if (reason == xpcReactivating) {
 968                         /* we interrupt ourselves to reactivate partition */
 969                         xpc_IPI_send_reactivate(part);
 970                 }
 971                 return;
 972         }
 973         if (part->act_state == XPC_P_DEACTIVATING) {
 974                 if ((part->reason == xpcUnloading && reason != xpcUnloading) ||
 975                                         reason == xpcReactivating) {
 976                         XPC_SET_REASON(part, reason, line);
 977                 }
 978                 spin_unlock_irqrestore(&part->act_lock, irq_flags);
 979                 return;
 980         }
 981
 982         part->act_state = XPC_P_DEACTIVATING;
 983         XPC_SET_REASON(part, reason, line);
 984
 985         spin_unlock_irqrestore(&part->act_lock, irq_flags);
 986
 987         if (XPC_SUPPORTS_DISENGAGE_REQUEST(part->remote_vars_version)) {
 988                 xpc_request_partition_disengage(part);
 989                 xpc_IPI_send_disengage(part);
 990
 991                 /* set a timelimit on the disengage request */
 992                 part->disengage_request_timeout = jiffies +
 993                                         (xpc_disengage_request_timelimit * HZ);
 994                 part->disengage_request_timer.expires =
 995                                         part->disengage_request_timeout;
 996                 add_timer(&part->disengage_request_timer);
 997         }
 998
 999         dev_dbg(xpc_part, "bringing partition %d down, reason = %d\n",
1000                 XPC_PARTID(part), reason);
1001
1002         xpc_partition_going_down(part, reason);
1003 }
1004
1005
1006 /*
1007  * Mark specified partition as inactive.
1008  */
1009 void
1010 xpc_mark_partition_inactive(struct xpc_partition *part)
1011 {
1012         unsigned long irq_flags;
1013
1014
1015         dev_dbg(xpc_part, "setting partition %d to INACTIVE\n",
1016                 XPC_PARTID(part));
1017
1018         spin_lock_irqsave(&part->act_lock, irq_flags);
1019         part->act_state = XPC_P_INACTIVE;
1020         spin_unlock_irqrestore(&part->act_lock, irq_flags);
1021         part->remote_rp_pa = 0;
1022 }
1023
1024
1025 /*
1026  * SAL has provided a partition and machine mask.  The partition mask
1027  * contains a bit for each even nasid in our partition.  The machine
1028  * mask contains a bit for each even nasid in the entire machine.
1029  *
1030  * Using those two bit arrays, we can determine which nasids are
1031  * known in the machine.  Each should also have a reserved page
1032  * initialized if they are available for partitioning.
1033  */
1034 void
1035 xpc_discovery(void)
1036 {
1037         void *remote_rp_base;
1038         struct xpc_rsvd_page *remote_rp;
1039         struct xpc_vars *remote_vars;
1040         u64 remote_rp_pa;
1041         u64 remote_vars_pa;
1042         int region;
1043         int region_size;
1044         int max_regions;
1045         int nasid;
1046         struct xpc_rsvd_page *rp;
1047         partid_t partid;
1048         struct xpc_partition *part;
1049         u64 *discovered_nasids;
1050         enum xpc_retval ret;
1051
1052
1053         remote_rp = xpc_kmalloc_cacheline_aligned(XPC_RP_HEADER_SIZE +
1054                                                 xp_nasid_mask_bytes,
1055                                                 GFP_KERNEL, &remote_rp_base);
1056         if (remote_rp == NULL) {
1057                 return;
1058         }
1059         remote_vars = (struct xpc_vars *) remote_rp;
1060
1061
1062         discovered_nasids = kzalloc(sizeof(u64) * xp_nasid_mask_words,
1063                                                         GFP_KERNEL);
1064         if (discovered_nasids == NULL) {
1065                 kfree(remote_rp_base);
1066                 return;
1067         }
1068
1069         rp = (struct xpc_rsvd_page *) xpc_rsvd_page;
1070
1071         /*
1072          * The term 'region' in this context refers to the minimum number of
1073          * nodes that can comprise an access protection grouping. The access
1074          * protection is in regards to memory, IOI and IPI.
1075          */
1076         max_regions = 64;
1077         region_size = sn_region_size;
1078
1079         switch (region_size) {
1080         case 128:
1081                 max_regions *= 2;
1082         case 64:
1083                 max_regions *= 2;
1084         case 32:
1085                 max_regions *= 2;
1086                 region_size = 16;
1087                 DBUG_ON(!is_shub2());
1088         }
1089
1090         for (region = 0; region < max_regions; region++) {
1091
1092                 if ((volatile int) xpc_exiting) {
1093                         break;
1094                 }
1095
1096                 dev_dbg(xpc_part, "searching region %d\n", region);
1097
1098                 for (nasid = (region * region_size * 2);
1099                      nasid < ((region + 1) * region_size * 2);
1100                      nasid += 2) {
1101
1102                         if ((volatile int) xpc_exiting) {
1103                                 break;
1104                         }
1105
1106                         dev_dbg(xpc_part, "checking nasid %d\n", nasid);
1107
1108
1109                         if (XPC_NASID_IN_ARRAY(nasid, xpc_part_nasids)) {
1110                                 dev_dbg(xpc_part, "PROM indicates Nasid %d is "
1111                                         "part of the local partition; skipping "
1112                                         "region\n", nasid);
1113                                 break;
1114                         }
1115
1116                         if (!(XPC_NASID_IN_ARRAY(nasid, xpc_mach_nasids))) {
1117                                 dev_dbg(xpc_part, "PROM indicates Nasid %d was "
1118                                         "not on Numa-Link network at reset\n",
1119                                         nasid);
1120                                 continue;
1121                         }
1122
1123                         if (XPC_NASID_IN_ARRAY(nasid, discovered_nasids)) {
1124                                 dev_dbg(xpc_part, "Nasid %d is part of a "
1125                                         "partition which was previously "
1126                                         "discovered\n", nasid);
1127                                 continue;
1128                         }
1129
1130
1131                         /* pull over the reserved page structure */
1132
1133                         ret = xpc_get_remote_rp(nasid, discovered_nasids,
1134                                               remote_rp, &remote_rp_pa);
1135                         if (ret != xpcSuccess) {
1136                                 dev_dbg(xpc_part, "unable to get reserved page "
1137                                         "from nasid %d, reason=%d\n", nasid,
1138                                         ret);
1139
1140                                 if (ret == xpcLocalPartid) {
1141                                         break;
1142                                 }
1143                                 continue;
1144                         }
1145
1146                         remote_vars_pa = remote_rp->vars_pa;
1147
1148                         partid = remote_rp->partid;
1149                         part = &xpc_partitions[partid];
1150
1151
1152                         /* pull over the cross partition variables */
1153
1154                         ret = xpc_get_remote_vars(remote_vars_pa, remote_vars);
1155                         if (ret != xpcSuccess) {
1156                                 dev_dbg(xpc_part, "unable to get XPC variables "
1157                                         "from nasid %d, reason=%d\n", nasid,
1158                                         ret);
1159
1160                                 XPC_DEACTIVATE_PARTITION(part, ret);
1161                                 continue;
1162                         }
1163
1164                         if (part->act_state != XPC_P_INACTIVE) {
1165                                 dev_dbg(xpc_part, "partition %d on nasid %d is "
1166                                         "already activating\n", partid, nasid);
1167                                 break;
1168                         }
1169
1170                         /*
1171                          * Register the remote partition's AMOs with SAL so it
1172                          * can handle and cleanup errors within that address
1173                          * range should the remote partition go down. We don't
1174                          * unregister this range because it is difficult to
1175                          * tell when outstanding writes to the remote partition
1176                          * are finished and thus when it is thus safe to
1177                          * unregister. This should not result in wasted space
1178                          * in the SAL xp_addr_region table because we should
1179                          * get the same page for remote_act_amos_pa after
1180                          * module reloads and system reboots.
1181                          */
1182                         if (sn_register_xp_addr_region(
1183                                             remote_vars->amos_page_pa,
1184                                                         PAGE_SIZE, 1) < 0) {
1185                                 dev_dbg(xpc_part, "partition %d failed to "
1186                                         "register xp_addr region 0x%016lx\n",
1187                                         partid, remote_vars->amos_page_pa);
1188
1189                                 XPC_SET_REASON(part, xpcPhysAddrRegFailed,
1190                                                 __LINE__);
1191                                 break;
1192                         }
1193
1194                         /*
1195                          * The remote nasid is valid and available.
1196                          * Send an interrupt to that nasid to notify
1197                          * it that we are ready to begin activation.
1198                          */
1199                         dev_dbg(xpc_part, "sending an interrupt to AMO 0x%lx, "
1200                                 "nasid %d, phys_cpuid 0x%x\n",
1201                                 remote_vars->amos_page_pa,
1202                                 remote_vars->act_nasid,
1203                                 remote_vars->act_phys_cpuid);
1204
1205                         if (XPC_SUPPORTS_DISENGAGE_REQUEST(remote_vars->
1206                                                                 version)) {
1207                                 part->remote_amos_page_pa =
1208                                                 remote_vars->amos_page_pa;
1209                                 xpc_mark_partition_disengaged(part);
1210                                 xpc_cancel_partition_disengage_request(part);
1211                         }
1212                         xpc_IPI_send_activate(remote_vars);
1213                 }
1214         }
1215
1216         kfree(discovered_nasids);
1217         kfree(remote_rp_base);
1218 }
1219
1220
1221 /*
1222  * Given a partid, get the nasids owned by that partition from the
1223  * remote partition's reserved page.
1224  */
1225 enum xpc_retval
1226 xpc_initiate_partid_to_nasids(partid_t partid, void *nasid_mask)
1227 {
1228         struct xpc_partition *part;
1229         u64 part_nasid_pa;
1230         int bte_res;
1231
1232
1233         part = &xpc_partitions[partid];
1234         if (part->remote_rp_pa == 0) {
1235                 return xpcPartitionDown;
1236         }
1237
1238         memset(nasid_mask, 0, XP_NASID_MASK_BYTES);
1239
1240         part_nasid_pa = (u64) XPC_RP_PART_NASIDS(part->remote_rp_pa);
1241
1242         bte_res = xp_bte_copy(part_nasid_pa, ia64_tpa((u64) nasid_mask),
1243                         xp_nasid_mask_bytes, (BTE_NOTIFY | BTE_WACQUIRE), NULL);
1244
1245         return xpc_map_bte_errors(bte_res);
1246 }
1247