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