1 /* 2 * This file is subject to the terms and conditions of the GNU General Public 3 * License. See the file "COPYING" in the main directory of this archive 4 * for more details. 5 * 6 * Copyright (c) 2004-2009 Silicon Graphics, Inc. All Rights Reserved. 7 */ 8 9 /* 10 * Cross Partition Communication (XPC) structures and macros. 11 */ 12 13 #ifndef _DRIVERS_MISC_SGIXP_XPC_H 14 #define _DRIVERS_MISC_SGIXP_XPC_H 15 16 #include <linux/wait.h> 17 #include <linux/completion.h> 18 #include <linux/timer.h> 19 #include <linux/sched.h> 20 #include "xp.h" 21 22 /* 23 * XPC Version numbers consist of a major and minor number. XPC can always 24 * talk to versions with same major #, and never talk to versions with a 25 * different major #. 26 */ 27 #define _XPC_VERSION(_maj, _min) (((_maj) << 4) | ((_min) & 0xf)) 28 #define XPC_VERSION_MAJOR(_v) ((_v) >> 4) 29 #define XPC_VERSION_MINOR(_v) ((_v) & 0xf) 30 31 /* define frequency of the heartbeat and frequency how often it's checked */ 32 #define XPC_HB_DEFAULT_INTERVAL 5 /* incr HB every x secs */ 33 #define XPC_HB_CHECK_DEFAULT_INTERVAL 20 /* check HB every x secs */ 34 35 /* define the process name of HB checker and the CPU it is pinned to */ 36 #define XPC_HB_CHECK_THREAD_NAME "xpc_hb" 37 #define XPC_HB_CHECK_CPU 0 38 39 /* define the process name of the discovery thread */ 40 #define XPC_DISCOVERY_THREAD_NAME "xpc_discovery" 41 42 /* 43 * the reserved page 44 * 45 * SAL reserves one page of memory per partition for XPC. Though a full page 46 * in length (16384 bytes), its starting address is not page aligned, but it 47 * is cacheline aligned. The reserved page consists of the following: 48 * 49 * reserved page header 50 * 51 * The first two 64-byte cachelines of the reserved page contain the 52 * header (struct xpc_rsvd_page). Before SAL initialization has completed, 53 * SAL has set up the following fields of the reserved page header: 54 * SAL_signature, SAL_version, SAL_partid, and SAL_nasids_size. The 55 * other fields are set up by XPC. (xpc_rsvd_page points to the local 56 * partition's reserved page.) 57 * 58 * part_nasids mask 59 * mach_nasids mask 60 * 61 * SAL also sets up two bitmaps (or masks), one that reflects the actual 62 * nasids in this partition (part_nasids), and the other that reflects 63 * the actual nasids in the entire machine (mach_nasids). We're only 64 * interested in the even numbered nasids (which contain the processors 65 * and/or memory), so we only need half as many bits to represent the 66 * nasids. When mapping nasid to bit in a mask (or bit to nasid) be sure 67 * to either divide or multiply by 2. The part_nasids mask is located 68 * starting at the first cacheline following the reserved page header. The 69 * mach_nasids mask follows right after the part_nasids mask. The size in 70 * bytes of each mask is reflected by the reserved page header field 71 * 'SAL_nasids_size'. (Local partition's mask pointers are xpc_part_nasids 72 * and xpc_mach_nasids.) 73 * 74 * vars (ia64-sn2 only) 75 * vars part (ia64-sn2 only) 76 * 77 * Immediately following the mach_nasids mask are the XPC variables 78 * required by other partitions. First are those that are generic to all 79 * partitions (vars), followed on the next available cacheline by those 80 * which are partition specific (vars part). These are setup by XPC. 81 * (Local partition's vars pointers are xpc_vars and xpc_vars_part.) 82 * 83 * Note: Until 'ts_jiffies' is set non-zero, the partition XPC code has not been 84 * initialized. 85 */ 86 struct xpc_rsvd_page { 87 u64 SAL_signature; /* SAL: unique signature */ 88 u64 SAL_version; /* SAL: version */ 89 short SAL_partid; /* SAL: partition ID */ 90 short max_npartitions; /* value of XPC_MAX_PARTITIONS */ 91 u8 version; 92 u8 pad1[3]; /* align to next u64 in 1st 64-byte cacheline */ 93 unsigned long ts_jiffies; /* timestamp when rsvd pg was setup by XPC */ 94 union { 95 struct { 96 unsigned long vars_pa; /* phys addr */ 97 } sn2; 98 struct { 99 unsigned long heartbeat_gpa; /* phys addr */ 100 unsigned long activate_gru_mq_desc_gpa; /* phys addr */ 101 } uv; 102 } sn; 103 u64 pad2[9]; /* align to last u64 in 2nd 64-byte cacheline */ 104 u64 SAL_nasids_size; /* SAL: size of each nasid mask in bytes */ 105 }; 106 107 #define XPC_RP_VERSION _XPC_VERSION(3, 0) /* version 3.0 of the reserved page */ 108 109 /* 110 * Define the structures by which XPC variables can be exported to other 111 * partitions. (There are two: struct xpc_vars and struct xpc_vars_part) 112 */ 113 114 /* 115 * The following structure describes the partition generic variables 116 * needed by other partitions in order to properly initialize. 117 * 118 * struct xpc_vars version number also applies to struct xpc_vars_part. 119 * Changes to either structure and/or related functionality should be 120 * reflected by incrementing either the major or minor version numbers 121 * of struct xpc_vars. 122 */ 123 struct xpc_vars_sn2 { 124 u8 version; 125 u64 heartbeat; 126 DECLARE_BITMAP(heartbeating_to_mask, XP_MAX_NPARTITIONS_SN2); 127 u64 heartbeat_offline; /* if 0, heartbeat should be changing */ 128 int activate_IRQ_nasid; 129 int activate_IRQ_phys_cpuid; 130 unsigned long vars_part_pa; 131 unsigned long amos_page_pa;/* paddr of page of amos from MSPEC driver */ 132 struct amo *amos_page; /* vaddr of page of amos from MSPEC driver */ 133 }; 134 135 #define XPC_V_VERSION _XPC_VERSION(3, 1) /* version 3.1 of the cross vars */ 136 137 /* 138 * The following structure describes the per partition specific variables. 139 * 140 * An array of these structures, one per partition, will be defined. As a 141 * partition becomes active XPC will copy the array entry corresponding to 142 * itself from that partition. It is desirable that the size of this structure 143 * evenly divides into a 128-byte cacheline, such that none of the entries in 144 * this array crosses a 128-byte cacheline boundary. As it is now, each entry 145 * occupies 64-bytes. 146 */ 147 struct xpc_vars_part_sn2 { 148 u64 magic; 149 150 unsigned long openclose_args_pa; /* phys addr of open and close args */ 151 unsigned long GPs_pa; /* physical address of Get/Put values */ 152 153 unsigned long chctl_amo_pa; /* physical address of chctl flags' amo */ 154 155 int notify_IRQ_nasid; /* nasid of where to send notify IRQs */ 156 int notify_IRQ_phys_cpuid; /* CPUID of where to send notify IRQs */ 157 158 u8 nchannels; /* #of defined channels supported */ 159 160 u8 reserved[23]; /* pad to a full 64 bytes */ 161 }; 162 163 /* 164 * The vars_part MAGIC numbers play a part in the first contact protocol. 165 * 166 * MAGIC1 indicates that the per partition specific variables for a remote 167 * partition have been initialized by this partition. 168 * 169 * MAGIC2 indicates that this partition has pulled the remote partititions 170 * per partition variables that pertain to this partition. 171 */ 172 #define XPC_VP_MAGIC1_SN2 0x0053524156435058L /* 'XPCVARS\0'L (little endian) */ 173 #define XPC_VP_MAGIC2_SN2 0x0073726176435058L /* 'XPCvars\0'L (little endian) */ 174 175 /* the reserved page sizes and offsets */ 176 177 #define XPC_RP_HEADER_SIZE L1_CACHE_ALIGN(sizeof(struct xpc_rsvd_page)) 178 #define XPC_RP_VARS_SIZE L1_CACHE_ALIGN(sizeof(struct xpc_vars_sn2)) 179 180 #define XPC_RP_PART_NASIDS(_rp) ((unsigned long *)((u8 *)(_rp) + \ 181 XPC_RP_HEADER_SIZE)) 182 #define XPC_RP_MACH_NASIDS(_rp) (XPC_RP_PART_NASIDS(_rp) + \ 183 xpc_nasid_mask_nlongs) 184 #define XPC_RP_VARS(_rp) ((struct xpc_vars_sn2 *) \ 185 (XPC_RP_MACH_NASIDS(_rp) + \ 186 xpc_nasid_mask_nlongs)) 187 188 189 /* 190 * The following structure describes the partition's heartbeat info which 191 * will be periodically read by other partitions to determine whether this 192 * XPC is still 'alive'. 193 */ 194 struct xpc_heartbeat_uv { 195 unsigned long value; 196 unsigned long offline; /* if 0, heartbeat should be changing */ 197 }; 198 199 /* 200 * Info pertinent to a GRU message queue using a watch list for irq generation. 201 */ 202 struct xpc_gru_mq_uv { 203 void *address; /* address of GRU message queue */ 204 unsigned int order; /* size of GRU message queue as a power of 2 */ 205 int irq; /* irq raised when message is received in mq */ 206 int mmr_blade; /* blade where watchlist was allocated from */ 207 unsigned long mmr_offset; /* offset of irq mmr located on mmr_blade */ 208 unsigned long mmr_value; /* value of irq mmr located on mmr_blade */ 209 int watchlist_num; /* number of watchlist allocatd by BIOS */ 210 void *gru_mq_desc; /* opaque structure used by the GRU driver */ 211 }; 212 213 /* 214 * The activate_mq is used to send/receive GRU messages that affect XPC's 215 * partition active state and channel state. This is uv only. 216 */ 217 struct xpc_activate_mq_msghdr_uv { 218 unsigned int gru_msg_hdr; /* FOR GRU INTERNAL USE ONLY */ 219 short partid; /* sender's partid */ 220 u8 act_state; /* sender's act_state at time msg sent */ 221 u8 type; /* message's type */ 222 unsigned long rp_ts_jiffies; /* timestamp of sender's rp setup by XPC */ 223 }; 224 225 /* activate_mq defined message types */ 226 #define XPC_ACTIVATE_MQ_MSG_SYNC_ACT_STATE_UV 0 227 228 #define XPC_ACTIVATE_MQ_MSG_ACTIVATE_REQ_UV 1 229 #define XPC_ACTIVATE_MQ_MSG_DEACTIVATE_REQ_UV 2 230 231 #define XPC_ACTIVATE_MQ_MSG_CHCTL_CLOSEREQUEST_UV 3 232 #define XPC_ACTIVATE_MQ_MSG_CHCTL_CLOSEREPLY_UV 4 233 #define XPC_ACTIVATE_MQ_MSG_CHCTL_OPENREQUEST_UV 5 234 #define XPC_ACTIVATE_MQ_MSG_CHCTL_OPENREPLY_UV 6 235 #define XPC_ACTIVATE_MQ_MSG_CHCTL_OPENCOMPLETE_UV 7 236 237 #define XPC_ACTIVATE_MQ_MSG_MARK_ENGAGED_UV 8 238 #define XPC_ACTIVATE_MQ_MSG_MARK_DISENGAGED_UV 9 239 240 struct xpc_activate_mq_msg_uv { 241 struct xpc_activate_mq_msghdr_uv hdr; 242 }; 243 244 struct xpc_activate_mq_msg_activate_req_uv { 245 struct xpc_activate_mq_msghdr_uv hdr; 246 unsigned long rp_gpa; 247 unsigned long heartbeat_gpa; 248 unsigned long activate_gru_mq_desc_gpa; 249 }; 250 251 struct xpc_activate_mq_msg_deactivate_req_uv { 252 struct xpc_activate_mq_msghdr_uv hdr; 253 enum xp_retval reason; 254 }; 255 256 struct xpc_activate_mq_msg_chctl_closerequest_uv { 257 struct xpc_activate_mq_msghdr_uv hdr; 258 short ch_number; 259 enum xp_retval reason; 260 }; 261 262 struct xpc_activate_mq_msg_chctl_closereply_uv { 263 struct xpc_activate_mq_msghdr_uv hdr; 264 short ch_number; 265 }; 266 267 struct xpc_activate_mq_msg_chctl_openrequest_uv { 268 struct xpc_activate_mq_msghdr_uv hdr; 269 short ch_number; 270 short entry_size; /* size of notify_mq's GRU messages */ 271 short local_nentries; /* ??? Is this needed? What is? */ 272 }; 273 274 struct xpc_activate_mq_msg_chctl_openreply_uv { 275 struct xpc_activate_mq_msghdr_uv hdr; 276 short ch_number; 277 short remote_nentries; /* ??? Is this needed? What is? */ 278 short local_nentries; /* ??? Is this needed? What is? */ 279 unsigned long notify_gru_mq_desc_gpa; 280 }; 281 282 struct xpc_activate_mq_msg_chctl_opencomplete_uv { 283 struct xpc_activate_mq_msghdr_uv hdr; 284 short ch_number; 285 }; 286 287 /* 288 * Functions registered by add_timer() or called by kernel_thread() only 289 * allow for a single 64-bit argument. The following macros can be used to 290 * pack and unpack two (32-bit, 16-bit or 8-bit) arguments into or out from 291 * the passed argument. 292 */ 293 #define XPC_PACK_ARGS(_arg1, _arg2) \ 294 ((((u64)_arg1) & 0xffffffff) | \ 295 ((((u64)_arg2) & 0xffffffff) << 32)) 296 297 #define XPC_UNPACK_ARG1(_args) (((u64)_args) & 0xffffffff) 298 #define XPC_UNPACK_ARG2(_args) ((((u64)_args) >> 32) & 0xffffffff) 299 300 /* 301 * Define a Get/Put value pair (pointers) used with a message queue. 302 */ 303 struct xpc_gp_sn2 { 304 s64 get; /* Get value */ 305 s64 put; /* Put value */ 306 }; 307 308 #define XPC_GP_SIZE \ 309 L1_CACHE_ALIGN(sizeof(struct xpc_gp_sn2) * XPC_MAX_NCHANNELS) 310 311 /* 312 * Define a structure that contains arguments associated with opening and 313 * closing a channel. 314 */ 315 struct xpc_openclose_args { 316 u16 reason; /* reason why channel is closing */ 317 u16 entry_size; /* sizeof each message entry */ 318 u16 remote_nentries; /* #of message entries in remote msg queue */ 319 u16 local_nentries; /* #of message entries in local msg queue */ 320 unsigned long local_msgqueue_pa; /* phys addr of local message queue */ 321 }; 322 323 #define XPC_OPENCLOSE_ARGS_SIZE \ 324 L1_CACHE_ALIGN(sizeof(struct xpc_openclose_args) * \ 325 XPC_MAX_NCHANNELS) 326 327 328 /* 329 * Structures to define a fifo singly-linked list. 330 */ 331 332 struct xpc_fifo_entry_uv { 333 struct xpc_fifo_entry_uv *next; 334 }; 335 336 struct xpc_fifo_head_uv { 337 struct xpc_fifo_entry_uv *first; 338 struct xpc_fifo_entry_uv *last; 339 spinlock_t lock; 340 int n_entries; 341 }; 342 343 /* 344 * Define a sn2 styled message. 345 * 346 * A user-defined message resides in the payload area. The max size of the 347 * payload is defined by the user via xpc_connect(). 348 * 349 * The size of a message entry (within a message queue) must be a 128-byte 350 * cacheline sized multiple in order to facilitate the BTE transfer of messages 351 * from one message queue to another. 352 */ 353 struct xpc_msg_sn2 { 354 u8 flags; /* FOR XPC INTERNAL USE ONLY */ 355 u8 reserved[7]; /* FOR XPC INTERNAL USE ONLY */ 356 s64 number; /* FOR XPC INTERNAL USE ONLY */ 357 358 u64 payload; /* user defined portion of message */ 359 }; 360 361 /* struct xpc_msg_sn2 flags */ 362 363 #define XPC_M_SN2_DONE 0x01 /* msg has been received/consumed */ 364 #define XPC_M_SN2_READY 0x02 /* msg is ready to be sent */ 365 #define XPC_M_SN2_INTERRUPT 0x04 /* send interrupt when msg consumed */ 366 367 /* 368 * The format of a uv XPC notify_mq GRU message is as follows: 369 * 370 * A user-defined message resides in the payload area. The max size of the 371 * payload is defined by the user via xpc_connect(). 372 * 373 * The size of a message (payload and header) sent via the GRU must be either 1 374 * or 2 GRU_CACHE_LINE_BYTES in length. 375 */ 376 377 struct xpc_notify_mq_msghdr_uv { 378 union { 379 unsigned int gru_msg_hdr; /* FOR GRU INTERNAL USE ONLY */ 380 struct xpc_fifo_entry_uv next; /* FOR XPC INTERNAL USE ONLY */ 381 } u; 382 short partid; /* FOR XPC INTERNAL USE ONLY */ 383 u8 ch_number; /* FOR XPC INTERNAL USE ONLY */ 384 u8 size; /* FOR XPC INTERNAL USE ONLY */ 385 unsigned int msg_slot_number; /* FOR XPC INTERNAL USE ONLY */ 386 }; 387 388 struct xpc_notify_mq_msg_uv { 389 struct xpc_notify_mq_msghdr_uv hdr; 390 unsigned long payload; 391 }; 392 393 /* 394 * Define sn2's notify entry. 395 * 396 * This is used to notify a message's sender that their message was received 397 * and consumed by the intended recipient. 398 */ 399 struct xpc_notify_sn2 { 400 u8 type; /* type of notification */ 401 402 /* the following two fields are only used if type == XPC_N_CALL */ 403 xpc_notify_func func; /* user's notify function */ 404 void *key; /* pointer to user's key */ 405 }; 406 407 /* struct xpc_notify_sn2 type of notification */ 408 409 #define XPC_N_CALL 0x01 /* notify function provided by user */ 410 411 /* 412 * Define uv's version of the notify entry. It additionally is used to allocate 413 * a msg slot on the remote partition into which is copied a sent message. 414 */ 415 struct xpc_send_msg_slot_uv { 416 struct xpc_fifo_entry_uv next; 417 unsigned int msg_slot_number; 418 xpc_notify_func func; /* user's notify function */ 419 void *key; /* pointer to user's key */ 420 }; 421 422 /* 423 * Define the structure that manages all the stuff required by a channel. In 424 * particular, they are used to manage the messages sent across the channel. 425 * 426 * This structure is private to a partition, and is NOT shared across the 427 * partition boundary. 428 * 429 * There is an array of these structures for each remote partition. It is 430 * allocated at the time a partition becomes active. The array contains one 431 * of these structures for each potential channel connection to that partition. 432 */ 433 434 /* 435 * The following is sn2 only. 436 * 437 * Each channel structure manages two message queues (circular buffers). 438 * They are allocated at the time a channel connection is made. One of 439 * these message queues (local_msgqueue) holds the locally created messages 440 * that are destined for the remote partition. The other of these message 441 * queues (remote_msgqueue) is a locally cached copy of the remote partition's 442 * own local_msgqueue. 443 * 444 * The following is a description of the Get/Put pointers used to manage these 445 * two message queues. Consider the local_msgqueue to be on one partition 446 * and the remote_msgqueue to be its cached copy on another partition. A 447 * description of what each of the lettered areas contains is included. 448 * 449 * 450 * local_msgqueue remote_msgqueue 451 * 452 * |/////////| |/////////| 453 * w_remote_GP.get --> +---------+ |/////////| 454 * | F | |/////////| 455 * remote_GP.get --> +---------+ +---------+ <-- local_GP->get 456 * | | | | 457 * | | | E | 458 * | | | | 459 * | | +---------+ <-- w_local_GP.get 460 * | B | |/////////| 461 * | | |////D////| 462 * | | |/////////| 463 * | | +---------+ <-- w_remote_GP.put 464 * | | |////C////| 465 * local_GP->put --> +---------+ +---------+ <-- remote_GP.put 466 * | | |/////////| 467 * | A | |/////////| 468 * | | |/////////| 469 * w_local_GP.put --> +---------+ |/////////| 470 * |/////////| |/////////| 471 * 472 * 473 * ( remote_GP.[get|put] are cached copies of the remote 474 * partition's local_GP->[get|put], and thus their values can 475 * lag behind their counterparts on the remote partition. ) 476 * 477 * 478 * A - Messages that have been allocated, but have not yet been sent to the 479 * remote partition. 480 * 481 * B - Messages that have been sent, but have not yet been acknowledged by the 482 * remote partition as having been received. 483 * 484 * C - Area that needs to be prepared for the copying of sent messages, by 485 * the clearing of the message flags of any previously received messages. 486 * 487 * D - Area into which sent messages are to be copied from the remote 488 * partition's local_msgqueue and then delivered to their intended 489 * recipients. [ To allow for a multi-message copy, another pointer 490 * (next_msg_to_pull) has been added to keep track of the next message 491 * number needing to be copied (pulled). It chases after w_remote_GP.put. 492 * Any messages lying between w_local_GP.get and next_msg_to_pull have 493 * been copied and are ready to be delivered. ] 494 * 495 * E - Messages that have been copied and delivered, but have not yet been 496 * acknowledged by the recipient as having been received. 497 * 498 * F - Messages that have been acknowledged, but XPC has not yet notified the 499 * sender that the message was received by its intended recipient. 500 * This is also an area that needs to be prepared for the allocating of 501 * new messages, by the clearing of the message flags of the acknowledged 502 * messages. 503 */ 504 505 struct xpc_channel_sn2 { 506 struct xpc_openclose_args *local_openclose_args; /* args passed on */ 507 /* opening or closing of channel */ 508 509 void *local_msgqueue_base; /* base address of kmalloc'd space */ 510 struct xpc_msg_sn2 *local_msgqueue; /* local message queue */ 511 void *remote_msgqueue_base; /* base address of kmalloc'd space */ 512 struct xpc_msg_sn2 *remote_msgqueue; /* cached copy of remote */ 513 /* partition's local message queue */ 514 unsigned long remote_msgqueue_pa; /* phys addr of remote partition's */ 515 /* local message queue */ 516 517 struct xpc_notify_sn2 *notify_queue;/* notify queue for messages sent */ 518 519 /* various flavors of local and remote Get/Put values */ 520 521 struct xpc_gp_sn2 *local_GP; /* local Get/Put values */ 522 struct xpc_gp_sn2 remote_GP; /* remote Get/Put values */ 523 struct xpc_gp_sn2 w_local_GP; /* working local Get/Put values */ 524 struct xpc_gp_sn2 w_remote_GP; /* working remote Get/Put values */ 525 s64 next_msg_to_pull; /* Put value of next msg to pull */ 526 527 struct mutex msg_to_pull_mutex; /* next msg to pull serialization */ 528 }; 529 530 struct xpc_channel_uv { 531 void *cached_notify_gru_mq_desc; /* remote partition's notify mq's */ 532 /* gru mq descriptor */ 533 534 struct xpc_send_msg_slot_uv *send_msg_slots; 535 void *recv_msg_slots; /* each slot will hold a xpc_notify_mq_msg_uv */ 536 /* structure plus the user's payload */ 537 538 struct xpc_fifo_head_uv msg_slot_free_list; 539 struct xpc_fifo_head_uv recv_msg_list; /* deliverable payloads */ 540 }; 541 542 struct xpc_channel { 543 short partid; /* ID of remote partition connected */ 544 spinlock_t lock; /* lock for updating this structure */ 545 unsigned int flags; /* general flags */ 546 547 enum xp_retval reason; /* reason why channel is disconnect'g */ 548 int reason_line; /* line# disconnect initiated from */ 549 550 u16 number; /* channel # */ 551 552 u16 entry_size; /* sizeof each msg entry */ 553 u16 local_nentries; /* #of msg entries in local msg queue */ 554 u16 remote_nentries; /* #of msg entries in remote msg queue */ 555 556 atomic_t references; /* #of external references to queues */ 557 558 atomic_t n_on_msg_allocate_wq; /* #on msg allocation wait queue */ 559 wait_queue_head_t msg_allocate_wq; /* msg allocation wait queue */ 560 561 u8 delayed_chctl_flags; /* chctl flags received, but delayed */ 562 /* action until channel disconnected */ 563 564 atomic_t n_to_notify; /* #of msg senders to notify */ 565 566 xpc_channel_func func; /* user's channel function */ 567 void *key; /* pointer to user's key */ 568 569 struct completion wdisconnect_wait; /* wait for channel disconnect */ 570 571 /* kthread management related fields */ 572 573 atomic_t kthreads_assigned; /* #of kthreads assigned to channel */ 574 u32 kthreads_assigned_limit; /* limit on #of kthreads assigned */ 575 atomic_t kthreads_idle; /* #of kthreads idle waiting for work */ 576 u32 kthreads_idle_limit; /* limit on #of kthreads idle */ 577 atomic_t kthreads_active; /* #of kthreads actively working */ 578 579 wait_queue_head_t idle_wq; /* idle kthread wait queue */ 580 581 union { 582 struct xpc_channel_sn2 sn2; 583 struct xpc_channel_uv uv; 584 } sn; 585 586 } ____cacheline_aligned; 587 588 /* struct xpc_channel flags */ 589 590 #define XPC_C_WASCONNECTED 0x00000001 /* channel was connected */ 591 592 #define XPC_C_ROPENCOMPLETE 0x00000002 /* remote open channel complete */ 593 #define XPC_C_OPENCOMPLETE 0x00000004 /* local open channel complete */ 594 #define XPC_C_ROPENREPLY 0x00000008 /* remote open channel reply */ 595 #define XPC_C_OPENREPLY 0x00000010 /* local open channel reply */ 596 #define XPC_C_ROPENREQUEST 0x00000020 /* remote open channel request */ 597 #define XPC_C_OPENREQUEST 0x00000040 /* local open channel request */ 598 599 #define XPC_C_SETUP 0x00000080 /* channel's msgqueues are alloc'd */ 600 #define XPC_C_CONNECTEDCALLOUT 0x00000100 /* connected callout initiated */ 601 #define XPC_C_CONNECTEDCALLOUT_MADE \ 602 0x00000200 /* connected callout completed */ 603 #define XPC_C_CONNECTED 0x00000400 /* local channel is connected */ 604 #define XPC_C_CONNECTING 0x00000800 /* channel is being connected */ 605 606 #define XPC_C_RCLOSEREPLY 0x00001000 /* remote close channel reply */ 607 #define XPC_C_CLOSEREPLY 0x00002000 /* local close channel reply */ 608 #define XPC_C_RCLOSEREQUEST 0x00004000 /* remote close channel request */ 609 #define XPC_C_CLOSEREQUEST 0x00008000 /* local close channel request */ 610 611 #define XPC_C_DISCONNECTED 0x00010000 /* channel is disconnected */ 612 #define XPC_C_DISCONNECTING 0x00020000 /* channel is being disconnected */ 613 #define XPC_C_DISCONNECTINGCALLOUT \ 614 0x00040000 /* disconnecting callout initiated */ 615 #define XPC_C_DISCONNECTINGCALLOUT_MADE \ 616 0x00080000 /* disconnecting callout completed */ 617 #define XPC_C_WDISCONNECT 0x00100000 /* waiting for channel disconnect */ 618 619 /* 620 * The channel control flags (chctl) union consists of a 64-bit variable which 621 * is divided up into eight bytes, ordered from right to left. Byte zero 622 * pertains to channel 0, byte one to channel 1, and so on. Each channel's byte 623 * can have one or more of the chctl flags set in it. 624 */ 625 626 union xpc_channel_ctl_flags { 627 u64 all_flags; 628 u8 flags[XPC_MAX_NCHANNELS]; 629 }; 630 631 /* chctl flags */ 632 #define XPC_CHCTL_CLOSEREQUEST 0x01 633 #define XPC_CHCTL_CLOSEREPLY 0x02 634 #define XPC_CHCTL_OPENREQUEST 0x04 635 #define XPC_CHCTL_OPENREPLY 0x08 636 #define XPC_CHCTL_OPENCOMPLETE 0x10 637 #define XPC_CHCTL_MSGREQUEST 0x20 638 639 #define XPC_OPENCLOSE_CHCTL_FLAGS \ 640 (XPC_CHCTL_CLOSEREQUEST | XPC_CHCTL_CLOSEREPLY | \ 641 XPC_CHCTL_OPENREQUEST | XPC_CHCTL_OPENREPLY | \ 642 XPC_CHCTL_OPENCOMPLETE) 643 #define XPC_MSG_CHCTL_FLAGS XPC_CHCTL_MSGREQUEST 644 645 static inline int 646 xpc_any_openclose_chctl_flags_set(union xpc_channel_ctl_flags *chctl) 647 { 648 int ch_number; 649 650 for (ch_number = 0; ch_number < XPC_MAX_NCHANNELS; ch_number++) { 651 if (chctl->flags[ch_number] & XPC_OPENCLOSE_CHCTL_FLAGS) 652 return 1; 653 } 654 return 0; 655 } 656 657 static inline int 658 xpc_any_msg_chctl_flags_set(union xpc_channel_ctl_flags *chctl) 659 { 660 int ch_number; 661 662 for (ch_number = 0; ch_number < XPC_MAX_NCHANNELS; ch_number++) { 663 if (chctl->flags[ch_number] & XPC_MSG_CHCTL_FLAGS) 664 return 1; 665 } 666 return 0; 667 } 668 669 /* 670 * Manage channels on a partition basis. There is one of these structures 671 * for each partition (a partition will never utilize the structure that 672 * represents itself). 673 */ 674 675 struct xpc_partition_sn2 { 676 unsigned long remote_amos_page_pa; /* paddr of partition's amos page */ 677 int activate_IRQ_nasid; /* active partition's act/deact nasid */ 678 int activate_IRQ_phys_cpuid; /* active part's act/deact phys cpuid */ 679 680 unsigned long remote_vars_pa; /* phys addr of partition's vars */ 681 unsigned long remote_vars_part_pa; /* paddr of partition's vars part */ 682 u8 remote_vars_version; /* version# of partition's vars */ 683 684 void *local_GPs_base; /* base address of kmalloc'd space */ 685 struct xpc_gp_sn2 *local_GPs; /* local Get/Put values */ 686 void *remote_GPs_base; /* base address of kmalloc'd space */ 687 struct xpc_gp_sn2 *remote_GPs; /* copy of remote partition's local */ 688 /* Get/Put values */ 689 unsigned long remote_GPs_pa; /* phys addr of remote partition's local */ 690 /* Get/Put values */ 691 692 void *local_openclose_args_base; /* base address of kmalloc'd space */ 693 struct xpc_openclose_args *local_openclose_args; /* local's args */ 694 unsigned long remote_openclose_args_pa; /* phys addr of remote's args */ 695 696 int notify_IRQ_nasid; /* nasid of where to send notify IRQs */ 697 int notify_IRQ_phys_cpuid; /* CPUID of where to send notify IRQs */ 698 char notify_IRQ_owner[8]; /* notify IRQ's owner's name */ 699 700 struct amo *remote_chctl_amo_va; /* addr of remote chctl flags' amo */ 701 struct amo *local_chctl_amo_va; /* address of chctl flags' amo */ 702 703 struct timer_list dropped_notify_IRQ_timer; /* dropped IRQ timer */ 704 }; 705 706 struct xpc_partition_uv { 707 unsigned long heartbeat_gpa; /* phys addr of partition's heartbeat */ 708 struct xpc_heartbeat_uv cached_heartbeat; /* cached copy of */ 709 /* partition's heartbeat */ 710 unsigned long activate_gru_mq_desc_gpa; /* phys addr of parititon's */ 711 /* activate mq's gru mq */ 712 /* descriptor */ 713 void *cached_activate_gru_mq_desc; /* cached copy of partition's */ 714 /* activate mq's gru mq descriptor */ 715 struct mutex cached_activate_gru_mq_desc_mutex; 716 spinlock_t flags_lock; /* protect updating of flags */ 717 unsigned int flags; /* general flags */ 718 u8 remote_act_state; /* remote partition's act_state */ 719 u8 act_state_req; /* act_state request from remote partition */ 720 enum xp_retval reason; /* reason for deactivate act_state request */ 721 }; 722 723 /* struct xpc_partition_uv flags */ 724 725 #define XPC_P_CACHED_ACTIVATE_GRU_MQ_DESC_UV 0x00000001 726 #define XPC_P_ENGAGED_UV 0x00000002 727 728 /* struct xpc_partition_uv act_state change requests */ 729 730 #define XPC_P_ASR_ACTIVATE_UV 0x01 731 #define XPC_P_ASR_REACTIVATE_UV 0x02 732 #define XPC_P_ASR_DEACTIVATE_UV 0x03 733 734 struct xpc_partition { 735 736 /* XPC HB infrastructure */ 737 738 u8 remote_rp_version; /* version# of partition's rsvd pg */ 739 unsigned long remote_rp_ts_jiffies; /* timestamp when rsvd pg setup */ 740 unsigned long remote_rp_pa; /* phys addr of partition's rsvd pg */ 741 u64 last_heartbeat; /* HB at last read */ 742 u32 activate_IRQ_rcvd; /* IRQs since activation */ 743 spinlock_t act_lock; /* protect updating of act_state */ 744 u8 act_state; /* from XPC HB viewpoint */ 745 enum xp_retval reason; /* reason partition is deactivating */ 746 int reason_line; /* line# deactivation initiated from */ 747 748 unsigned long disengage_timeout; /* timeout in jiffies */ 749 struct timer_list disengage_timer; 750 751 /* XPC infrastructure referencing and teardown control */ 752 753 u8 setup_state; /* infrastructure setup state */ 754 wait_queue_head_t teardown_wq; /* kthread waiting to teardown infra */ 755 atomic_t references; /* #of references to infrastructure */ 756 757 u8 nchannels; /* #of defined channels supported */ 758 atomic_t nchannels_active; /* #of channels that are not DISCONNECTED */ 759 atomic_t nchannels_engaged; /* #of channels engaged with remote part */ 760 struct xpc_channel *channels; /* array of channel structures */ 761 762 /* fields used for managing channel avialability and activity */ 763 764 union xpc_channel_ctl_flags chctl; /* chctl flags yet to be processed */ 765 spinlock_t chctl_lock; /* chctl flags lock */ 766 767 void *remote_openclose_args_base; /* base address of kmalloc'd space */ 768 struct xpc_openclose_args *remote_openclose_args; /* copy of remote's */ 769 /* args */ 770 771 /* channel manager related fields */ 772 773 atomic_t channel_mgr_requests; /* #of requests to activate chan mgr */ 774 wait_queue_head_t channel_mgr_wq; /* channel mgr's wait queue */ 775 776 union { 777 struct xpc_partition_sn2 sn2; 778 struct xpc_partition_uv uv; 779 } sn; 780 781 } ____cacheline_aligned; 782 783 struct xpc_arch_operations { 784 int (*setup_partitions) (void); 785 void (*teardown_partitions) (void); 786 void (*process_activate_IRQ_rcvd) (void); 787 enum xp_retval (*get_partition_rsvd_page_pa) 788 (void *, u64 *, unsigned long *, size_t *); 789 int (*setup_rsvd_page) (struct xpc_rsvd_page *); 790 791 void (*allow_hb) (short); 792 void (*disallow_hb) (short); 793 void (*disallow_all_hbs) (void); 794 void (*increment_heartbeat) (void); 795 void (*offline_heartbeat) (void); 796 void (*online_heartbeat) (void); 797 void (*heartbeat_init) (void); 798 void (*heartbeat_exit) (void); 799 enum xp_retval (*get_remote_heartbeat) (struct xpc_partition *); 800 801 void (*request_partition_activation) (struct xpc_rsvd_page *, 802 unsigned long, int); 803 void (*request_partition_reactivation) (struct xpc_partition *); 804 void (*request_partition_deactivation) (struct xpc_partition *); 805 void (*cancel_partition_deactivation_request) (struct xpc_partition *); 806 enum xp_retval (*setup_ch_structures) (struct xpc_partition *); 807 void (*teardown_ch_structures) (struct xpc_partition *); 808 809 enum xp_retval (*make_first_contact) (struct xpc_partition *); 810 811 u64 (*get_chctl_all_flags) (struct xpc_partition *); 812 void (*send_chctl_closerequest) (struct xpc_channel *, unsigned long *); 813 void (*send_chctl_closereply) (struct xpc_channel *, unsigned long *); 814 void (*send_chctl_openrequest) (struct xpc_channel *, unsigned long *); 815 void (*send_chctl_openreply) (struct xpc_channel *, unsigned long *); 816 void (*send_chctl_opencomplete) (struct xpc_channel *, unsigned long *); 817 void (*process_msg_chctl_flags) (struct xpc_partition *, int); 818 819 enum xp_retval (*save_remote_msgqueue_pa) (struct xpc_channel *, 820 unsigned long); 821 822 enum xp_retval (*setup_msg_structures) (struct xpc_channel *); 823 void (*teardown_msg_structures) (struct xpc_channel *); 824 825 void (*indicate_partition_engaged) (struct xpc_partition *); 826 void (*indicate_partition_disengaged) (struct xpc_partition *); 827 void (*assume_partition_disengaged) (short); 828 int (*partition_engaged) (short); 829 int (*any_partition_engaged) (void); 830 831 int (*n_of_deliverable_payloads) (struct xpc_channel *); 832 enum xp_retval (*send_payload) (struct xpc_channel *, u32, void *, 833 u16, u8, xpc_notify_func, void *); 834 void *(*get_deliverable_payload) (struct xpc_channel *); 835 void (*received_payload) (struct xpc_channel *, void *); 836 void (*notify_senders_of_disconnect) (struct xpc_channel *); 837 }; 838 839 /* struct xpc_partition act_state values (for XPC HB) */ 840 841 #define XPC_P_AS_INACTIVE 0x00 /* partition is not active */ 842 #define XPC_P_AS_ACTIVATION_REQ 0x01 /* created thread to activate */ 843 #define XPC_P_AS_ACTIVATING 0x02 /* activation thread started */ 844 #define XPC_P_AS_ACTIVE 0x03 /* xpc_partition_up() was called */ 845 #define XPC_P_AS_DEACTIVATING 0x04 /* partition deactivation initiated */ 846 847 #define XPC_DEACTIVATE_PARTITION(_p, _reason) \ 848 xpc_deactivate_partition(__LINE__, (_p), (_reason)) 849 850 /* struct xpc_partition setup_state values */ 851 852 #define XPC_P_SS_UNSET 0x00 /* infrastructure was never setup */ 853 #define XPC_P_SS_SETUP 0x01 /* infrastructure is setup */ 854 #define XPC_P_SS_WTEARDOWN 0x02 /* waiting to teardown infrastructure */ 855 #define XPC_P_SS_TORNDOWN 0x03 /* infrastructure is torndown */ 856 857 /* 858 * struct xpc_partition_sn2's dropped notify IRQ timer is set to wait the 859 * following interval #of seconds before checking for dropped notify IRQs. 860 * These can occur whenever an IRQ's associated amo write doesn't complete 861 * until after the IRQ was received. 862 */ 863 #define XPC_DROPPED_NOTIFY_IRQ_WAIT_INTERVAL (0.25 * HZ) 864 865 /* number of seconds to wait for other partitions to disengage */ 866 #define XPC_DISENGAGE_DEFAULT_TIMELIMIT 90 867 868 /* interval in seconds to print 'waiting deactivation' messages */ 869 #define XPC_DEACTIVATE_PRINTMSG_INTERVAL 10 870 871 #define XPC_PARTID(_p) ((short)((_p) - &xpc_partitions[0])) 872 873 /* found in xp_main.c */ 874 extern struct xpc_registration xpc_registrations[]; 875 876 /* found in xpc_main.c */ 877 extern struct device *xpc_part; 878 extern struct device *xpc_chan; 879 extern struct xpc_arch_operations xpc_arch_ops; 880 extern int xpc_disengage_timelimit; 881 extern int xpc_disengage_timedout; 882 extern int xpc_activate_IRQ_rcvd; 883 extern spinlock_t xpc_activate_IRQ_rcvd_lock; 884 extern wait_queue_head_t xpc_activate_IRQ_wq; 885 extern void *xpc_kzalloc_cacheline_aligned(size_t, gfp_t, void **); 886 extern void xpc_activate_partition(struct xpc_partition *); 887 extern void xpc_activate_kthreads(struct xpc_channel *, int); 888 extern void xpc_create_kthreads(struct xpc_channel *, int, int); 889 extern void xpc_disconnect_wait(int); 890 891 /* found in xpc_sn2.c */ 892 extern int xpc_init_sn2(void); 893 extern void xpc_exit_sn2(void); 894 895 /* found in xpc_uv.c */ 896 extern int xpc_init_uv(void); 897 extern void xpc_exit_uv(void); 898 899 /* found in xpc_partition.c */ 900 extern int xpc_exiting; 901 extern int xpc_nasid_mask_nlongs; 902 extern struct xpc_rsvd_page *xpc_rsvd_page; 903 extern unsigned long *xpc_mach_nasids; 904 extern struct xpc_partition *xpc_partitions; 905 extern void *xpc_kmalloc_cacheline_aligned(size_t, gfp_t, void **); 906 extern int xpc_setup_rsvd_page(void); 907 extern void xpc_teardown_rsvd_page(void); 908 extern int xpc_identify_activate_IRQ_sender(void); 909 extern int xpc_partition_disengaged(struct xpc_partition *); 910 extern enum xp_retval xpc_mark_partition_active(struct xpc_partition *); 911 extern void xpc_mark_partition_inactive(struct xpc_partition *); 912 extern void xpc_discovery(void); 913 extern enum xp_retval xpc_get_remote_rp(int, unsigned long *, 914 struct xpc_rsvd_page *, 915 unsigned long *); 916 extern void xpc_deactivate_partition(const int, struct xpc_partition *, 917 enum xp_retval); 918 extern enum xp_retval xpc_initiate_partid_to_nasids(short, void *); 919 920 /* found in xpc_channel.c */ 921 extern void xpc_initiate_connect(int); 922 extern void xpc_initiate_disconnect(int); 923 extern enum xp_retval xpc_allocate_msg_wait(struct xpc_channel *); 924 extern enum xp_retval xpc_initiate_send(short, int, u32, void *, u16); 925 extern enum xp_retval xpc_initiate_send_notify(short, int, u32, void *, u16, 926 xpc_notify_func, void *); 927 extern void xpc_initiate_received(short, int, void *); 928 extern void xpc_process_sent_chctl_flags(struct xpc_partition *); 929 extern void xpc_connected_callout(struct xpc_channel *); 930 extern void xpc_deliver_payload(struct xpc_channel *); 931 extern void xpc_disconnect_channel(const int, struct xpc_channel *, 932 enum xp_retval, unsigned long *); 933 extern void xpc_disconnect_callout(struct xpc_channel *, enum xp_retval); 934 extern void xpc_partition_going_down(struct xpc_partition *, enum xp_retval); 935 936 static inline void 937 xpc_wakeup_channel_mgr(struct xpc_partition *part) 938 { 939 if (atomic_inc_return(&part->channel_mgr_requests) == 1) 940 wake_up(&part->channel_mgr_wq); 941 } 942 943 /* 944 * These next two inlines are used to keep us from tearing down a channel's 945 * msg queues while a thread may be referencing them. 946 */ 947 static inline void 948 xpc_msgqueue_ref(struct xpc_channel *ch) 949 { 950 atomic_inc(&ch->references); 951 } 952 953 static inline void 954 xpc_msgqueue_deref(struct xpc_channel *ch) 955 { 956 s32 refs = atomic_dec_return(&ch->references); 957 958 DBUG_ON(refs < 0); 959 if (refs == 0) 960 xpc_wakeup_channel_mgr(&xpc_partitions[ch->partid]); 961 } 962 963 #define XPC_DISCONNECT_CHANNEL(_ch, _reason, _irqflgs) \ 964 xpc_disconnect_channel(__LINE__, _ch, _reason, _irqflgs) 965 966 /* 967 * These two inlines are used to keep us from tearing down a partition's 968 * setup infrastructure while a thread may be referencing it. 969 */ 970 static inline void 971 xpc_part_deref(struct xpc_partition *part) 972 { 973 s32 refs = atomic_dec_return(&part->references); 974 975 DBUG_ON(refs < 0); 976 if (refs == 0 && part->setup_state == XPC_P_SS_WTEARDOWN) 977 wake_up(&part->teardown_wq); 978 } 979 980 static inline int 981 xpc_part_ref(struct xpc_partition *part) 982 { 983 int setup; 984 985 atomic_inc(&part->references); 986 setup = (part->setup_state == XPC_P_SS_SETUP); 987 if (!setup) 988 xpc_part_deref(part); 989 990 return setup; 991 } 992 993 /* 994 * The following macro is to be used for the setting of the reason and 995 * reason_line fields in both the struct xpc_channel and struct xpc_partition 996 * structures. 997 */ 998 #define XPC_SET_REASON(_p, _reason, _line) \ 999 { \ 1000 (_p)->reason = _reason; \ 1001 (_p)->reason_line = _line; \ 1002 } 1003 1004 #endif /* _DRIVERS_MISC_SGIXP_XPC_H */ 1005