1// SPDX-License-Identifier: GPL-2.0-or-later 2/* 3 * IUCV base infrastructure. 4 * 5 * Copyright IBM Corp. 2001, 2009 6 * 7 * Author(s): 8 * Original source: 9 * Alan Altmark (Alan_Altmark@us.ibm.com) Sept. 2000 10 * Xenia Tkatschow (xenia@us.ibm.com) 11 * 2Gb awareness and general cleanup: 12 * Fritz Elfert (elfert@de.ibm.com, felfert@millenux.com) 13 * Rewritten for af_iucv: 14 * Martin Schwidefsky <schwidefsky@de.ibm.com> 15 * PM functions: 16 * Ursula Braun (ursula.braun@de.ibm.com) 17 * 18 * Documentation used: 19 * The original source 20 * CP Programming Service, IBM document # SC24-5760 21 */ 22 23#define KMSG_COMPONENT "iucv" 24#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt 25 26#include <linux/kernel_stat.h> 27#include <linux/module.h> 28#include <linux/moduleparam.h> 29#include <linux/spinlock.h> 30#include <linux/kernel.h> 31#include <linux/slab.h> 32#include <linux/init.h> 33#include <linux/interrupt.h> 34#include <linux/list.h> 35#include <linux/errno.h> 36#include <linux/err.h> 37#include <linux/device.h> 38#include <linux/cpu.h> 39#include <linux/reboot.h> 40#include <net/iucv/iucv.h> 41#include <linux/atomic.h> 42#include <asm/ebcdic.h> 43#include <asm/io.h> 44#include <asm/irq.h> 45#include <asm/smp.h> 46 47/* 48 * FLAGS: 49 * All flags are defined in the field IPFLAGS1 of each function 50 * and can be found in CP Programming Services. 51 * IPSRCCLS - Indicates you have specified a source class. 52 * IPTRGCLS - Indicates you have specified a target class. 53 * IPFGPID - Indicates you have specified a pathid. 54 * IPFGMID - Indicates you have specified a message ID. 55 * IPNORPY - Indicates a one-way message. No reply expected. 56 * IPALL - Indicates that all paths are affected. 57 */ 58#define IUCV_IPSRCCLS 0x01 59#define IUCV_IPTRGCLS 0x01 60#define IUCV_IPFGPID 0x02 61#define IUCV_IPFGMID 0x04 62#define IUCV_IPNORPY 0x10 63#define IUCV_IPALL 0x80 64 65static int iucv_bus_match(struct device *dev, struct device_driver *drv) 66{ 67 return 0; 68} 69 70struct bus_type iucv_bus = { 71 .name = "iucv", 72 .match = iucv_bus_match, 73}; 74EXPORT_SYMBOL(iucv_bus); 75 76struct device *iucv_root; 77EXPORT_SYMBOL(iucv_root); 78 79static int iucv_available; 80 81/* General IUCV interrupt structure */ 82struct iucv_irq_data { 83 u16 ippathid; 84 u8 ipflags1; 85 u8 iptype; 86 u32 res2[9]; 87}; 88 89struct iucv_irq_list { 90 struct list_head list; 91 struct iucv_irq_data data; 92}; 93 94static struct iucv_irq_data *iucv_irq_data[NR_CPUS]; 95static cpumask_t iucv_buffer_cpumask = { CPU_BITS_NONE }; 96static cpumask_t iucv_irq_cpumask = { CPU_BITS_NONE }; 97 98/* 99 * Queue of interrupt buffers lock for delivery via the tasklet 100 * (fast but can't call smp_call_function). 101 */ 102static LIST_HEAD(iucv_task_queue); 103 104/* 105 * The tasklet for fast delivery of iucv interrupts. 106 */ 107static void iucv_tasklet_fn(unsigned long); 108static DECLARE_TASKLET_OLD(iucv_tasklet, iucv_tasklet_fn); 109 110/* 111 * Queue of interrupt buffers for delivery via a work queue 112 * (slower but can call smp_call_function). 113 */ 114static LIST_HEAD(iucv_work_queue); 115 116/* 117 * The work element to deliver path pending interrupts. 118 */ 119static void iucv_work_fn(struct work_struct *work); 120static DECLARE_WORK(iucv_work, iucv_work_fn); 121 122/* 123 * Spinlock protecting task and work queue. 124 */ 125static DEFINE_SPINLOCK(iucv_queue_lock); 126 127enum iucv_command_codes { 128 IUCV_QUERY = 0, 129 IUCV_RETRIEVE_BUFFER = 2, 130 IUCV_SEND = 4, 131 IUCV_RECEIVE = 5, 132 IUCV_REPLY = 6, 133 IUCV_REJECT = 8, 134 IUCV_PURGE = 9, 135 IUCV_ACCEPT = 10, 136 IUCV_CONNECT = 11, 137 IUCV_DECLARE_BUFFER = 12, 138 IUCV_QUIESCE = 13, 139 IUCV_RESUME = 14, 140 IUCV_SEVER = 15, 141 IUCV_SETMASK = 16, 142 IUCV_SETCONTROLMASK = 17, 143}; 144 145/* 146 * Error messages that are used with the iucv_sever function. They get 147 * converted to EBCDIC. 148 */ 149static char iucv_error_no_listener[16] = "NO LISTENER"; 150static char iucv_error_no_memory[16] = "NO MEMORY"; 151static char iucv_error_pathid[16] = "INVALID PATHID"; 152 153/* 154 * iucv_handler_list: List of registered handlers. 155 */ 156static LIST_HEAD(iucv_handler_list); 157 158/* 159 * iucv_path_table: an array of iucv_path structures. 160 */ 161static struct iucv_path **iucv_path_table; 162static unsigned long iucv_max_pathid; 163 164/* 165 * iucv_lock: spinlock protecting iucv_handler_list and iucv_pathid_table 166 */ 167static DEFINE_SPINLOCK(iucv_table_lock); 168 169/* 170 * iucv_active_cpu: contains the number of the cpu executing the tasklet 171 * or the work handler. Needed for iucv_path_sever called from tasklet. 172 */ 173static int iucv_active_cpu = -1; 174 175/* 176 * Mutex and wait queue for iucv_register/iucv_unregister. 177 */ 178static DEFINE_MUTEX(iucv_register_mutex); 179 180/* 181 * Counter for number of non-smp capable handlers. 182 */ 183static int iucv_nonsmp_handler; 184 185/* 186 * IUCV control data structure. Used by iucv_path_accept, iucv_path_connect, 187 * iucv_path_quiesce and iucv_path_sever. 188 */ 189struct iucv_cmd_control { 190 u16 ippathid; 191 u8 ipflags1; 192 u8 iprcode; 193 u16 ipmsglim; 194 u16 res1; 195 u8 ipvmid[8]; 196 u8 ipuser[16]; 197 u8 iptarget[8]; 198} __attribute__ ((packed,aligned(8))); 199 200/* 201 * Data in parameter list iucv structure. Used by iucv_message_send, 202 * iucv_message_send2way and iucv_message_reply. 203 */ 204struct iucv_cmd_dpl { 205 u16 ippathid; 206 u8 ipflags1; 207 u8 iprcode; 208 u32 ipmsgid; 209 u32 iptrgcls; 210 u8 iprmmsg[8]; 211 u32 ipsrccls; 212 u32 ipmsgtag; 213 u32 ipbfadr2; 214 u32 ipbfln2f; 215 u32 res; 216} __attribute__ ((packed,aligned(8))); 217 218/* 219 * Data in buffer iucv structure. Used by iucv_message_receive, 220 * iucv_message_reject, iucv_message_send, iucv_message_send2way 221 * and iucv_declare_cpu. 222 */ 223struct iucv_cmd_db { 224 u16 ippathid; 225 u8 ipflags1; 226 u8 iprcode; 227 u32 ipmsgid; 228 u32 iptrgcls; 229 u32 ipbfadr1; 230 u32 ipbfln1f; 231 u32 ipsrccls; 232 u32 ipmsgtag; 233 u32 ipbfadr2; 234 u32 ipbfln2f; 235 u32 res; 236} __attribute__ ((packed,aligned(8))); 237 238/* 239 * Purge message iucv structure. Used by iucv_message_purge. 240 */ 241struct iucv_cmd_purge { 242 u16 ippathid; 243 u8 ipflags1; 244 u8 iprcode; 245 u32 ipmsgid; 246 u8 ipaudit[3]; 247 u8 res1[5]; 248 u32 res2; 249 u32 ipsrccls; 250 u32 ipmsgtag; 251 u32 res3[3]; 252} __attribute__ ((packed,aligned(8))); 253 254/* 255 * Set mask iucv structure. Used by iucv_enable_cpu. 256 */ 257struct iucv_cmd_set_mask { 258 u8 ipmask; 259 u8 res1[2]; 260 u8 iprcode; 261 u32 res2[9]; 262} __attribute__ ((packed,aligned(8))); 263 264union iucv_param { 265 struct iucv_cmd_control ctrl; 266 struct iucv_cmd_dpl dpl; 267 struct iucv_cmd_db db; 268 struct iucv_cmd_purge purge; 269 struct iucv_cmd_set_mask set_mask; 270}; 271 272/* 273 * Anchor for per-cpu IUCV command parameter block. 274 */ 275static union iucv_param *iucv_param[NR_CPUS]; 276static union iucv_param *iucv_param_irq[NR_CPUS]; 277 278/** 279 * iucv_call_b2f0 280 * @code: identifier of IUCV call to CP. 281 * @parm: pointer to a struct iucv_parm block 282 * 283 * Calls CP to execute IUCV commands. 284 * 285 * Returns the result of the CP IUCV call. 286 */ 287static inline int __iucv_call_b2f0(int command, union iucv_param *parm) 288{ 289 register unsigned long reg0 asm ("0"); 290 register unsigned long reg1 asm ("1"); 291 int ccode; 292 293 reg0 = command; 294 reg1 = (unsigned long)parm; 295 asm volatile( 296 " .long 0xb2f01000\n" 297 " ipm %0\n" 298 " srl %0,28\n" 299 : "=d" (ccode), "=m" (*parm), "+d" (reg0), "+a" (reg1) 300 : "m" (*parm) : "cc"); 301 return ccode; 302} 303 304static inline int iucv_call_b2f0(int command, union iucv_param *parm) 305{ 306 int ccode; 307 308 ccode = __iucv_call_b2f0(command, parm); 309 return ccode == 1 ? parm->ctrl.iprcode : ccode; 310} 311 312/** 313 * iucv_query_maxconn 314 * 315 * Determines the maximum number of connections that may be established. 316 * 317 * Returns the maximum number of connections or -EPERM is IUCV is not 318 * available. 319 */ 320static int __iucv_query_maxconn(void *param, unsigned long *max_pathid) 321{ 322 register unsigned long reg0 asm ("0"); 323 register unsigned long reg1 asm ("1"); 324 int ccode; 325 326 reg0 = IUCV_QUERY; 327 reg1 = (unsigned long) param; 328 asm volatile ( 329 " .long 0xb2f01000\n" 330 " ipm %0\n" 331 " srl %0,28\n" 332 : "=d" (ccode), "+d" (reg0), "+d" (reg1) : : "cc"); 333 *max_pathid = reg1; 334 return ccode; 335} 336 337static int iucv_query_maxconn(void) 338{ 339 unsigned long max_pathid; 340 void *param; 341 int ccode; 342 343 param = kzalloc(sizeof(union iucv_param), GFP_KERNEL | GFP_DMA); 344 if (!param) 345 return -ENOMEM; 346 ccode = __iucv_query_maxconn(param, &max_pathid); 347 if (ccode == 0) 348 iucv_max_pathid = max_pathid; 349 kfree(param); 350 return ccode ? -EPERM : 0; 351} 352 353/** 354 * iucv_allow_cpu 355 * @data: unused 356 * 357 * Allow iucv interrupts on this cpu. 358 */ 359static void iucv_allow_cpu(void *data) 360{ 361 int cpu = smp_processor_id(); 362 union iucv_param *parm; 363 364 /* 365 * Enable all iucv interrupts. 366 * ipmask contains bits for the different interrupts 367 * 0x80 - Flag to allow nonpriority message pending interrupts 368 * 0x40 - Flag to allow priority message pending interrupts 369 * 0x20 - Flag to allow nonpriority message completion interrupts 370 * 0x10 - Flag to allow priority message completion interrupts 371 * 0x08 - Flag to allow IUCV control interrupts 372 */ 373 parm = iucv_param_irq[cpu]; 374 memset(parm, 0, sizeof(union iucv_param)); 375 parm->set_mask.ipmask = 0xf8; 376 iucv_call_b2f0(IUCV_SETMASK, parm); 377 378 /* 379 * Enable all iucv control interrupts. 380 * ipmask contains bits for the different interrupts 381 * 0x80 - Flag to allow pending connections interrupts 382 * 0x40 - Flag to allow connection complete interrupts 383 * 0x20 - Flag to allow connection severed interrupts 384 * 0x10 - Flag to allow connection quiesced interrupts 385 * 0x08 - Flag to allow connection resumed interrupts 386 */ 387 memset(parm, 0, sizeof(union iucv_param)); 388 parm->set_mask.ipmask = 0xf8; 389 iucv_call_b2f0(IUCV_SETCONTROLMASK, parm); 390 /* Set indication that iucv interrupts are allowed for this cpu. */ 391 cpumask_set_cpu(cpu, &iucv_irq_cpumask); 392} 393 394/** 395 * iucv_block_cpu 396 * @data: unused 397 * 398 * Block iucv interrupts on this cpu. 399 */ 400static void iucv_block_cpu(void *data) 401{ 402 int cpu = smp_processor_id(); 403 union iucv_param *parm; 404 405 /* Disable all iucv interrupts. */ 406 parm = iucv_param_irq[cpu]; 407 memset(parm, 0, sizeof(union iucv_param)); 408 iucv_call_b2f0(IUCV_SETMASK, parm); 409 410 /* Clear indication that iucv interrupts are allowed for this cpu. */ 411 cpumask_clear_cpu(cpu, &iucv_irq_cpumask); 412} 413 414/** 415 * iucv_declare_cpu 416 * @data: unused 417 * 418 * Declare a interrupt buffer on this cpu. 419 */ 420static void iucv_declare_cpu(void *data) 421{ 422 int cpu = smp_processor_id(); 423 union iucv_param *parm; 424 int rc; 425 426 if (cpumask_test_cpu(cpu, &iucv_buffer_cpumask)) 427 return; 428 429 /* Declare interrupt buffer. */ 430 parm = iucv_param_irq[cpu]; 431 memset(parm, 0, sizeof(union iucv_param)); 432 parm->db.ipbfadr1 = virt_to_phys(iucv_irq_data[cpu]); 433 rc = iucv_call_b2f0(IUCV_DECLARE_BUFFER, parm); 434 if (rc) { 435 char *err = "Unknown"; 436 switch (rc) { 437 case 0x03: 438 err = "Directory error"; 439 break; 440 case 0x0a: 441 err = "Invalid length"; 442 break; 443 case 0x13: 444 err = "Buffer already exists"; 445 break; 446 case 0x3e: 447 err = "Buffer overlap"; 448 break; 449 case 0x5c: 450 err = "Paging or storage error"; 451 break; 452 } 453 pr_warn("Defining an interrupt buffer on CPU %i failed with 0x%02x (%s)\n", 454 cpu, rc, err); 455 return; 456 } 457 458 /* Set indication that an iucv buffer exists for this cpu. */ 459 cpumask_set_cpu(cpu, &iucv_buffer_cpumask); 460 461 if (iucv_nonsmp_handler == 0 || cpumask_empty(&iucv_irq_cpumask)) 462 /* Enable iucv interrupts on this cpu. */ 463 iucv_allow_cpu(NULL); 464 else 465 /* Disable iucv interrupts on this cpu. */ 466 iucv_block_cpu(NULL); 467} 468 469/** 470 * iucv_retrieve_cpu 471 * @data: unused 472 * 473 * Retrieve interrupt buffer on this cpu. 474 */ 475static void iucv_retrieve_cpu(void *data) 476{ 477 int cpu = smp_processor_id(); 478 union iucv_param *parm; 479 480 if (!cpumask_test_cpu(cpu, &iucv_buffer_cpumask)) 481 return; 482 483 /* Block iucv interrupts. */ 484 iucv_block_cpu(NULL); 485 486 /* Retrieve interrupt buffer. */ 487 parm = iucv_param_irq[cpu]; 488 iucv_call_b2f0(IUCV_RETRIEVE_BUFFER, parm); 489 490 /* Clear indication that an iucv buffer exists for this cpu. */ 491 cpumask_clear_cpu(cpu, &iucv_buffer_cpumask); 492} 493 494/** 495 * iucv_setmask_smp 496 * 497 * Allow iucv interrupts on all cpus. 498 */ 499static void iucv_setmask_mp(void) 500{ 501 int cpu; 502 503 get_online_cpus(); 504 for_each_online_cpu(cpu) 505 /* Enable all cpus with a declared buffer. */ 506 if (cpumask_test_cpu(cpu, &iucv_buffer_cpumask) && 507 !cpumask_test_cpu(cpu, &iucv_irq_cpumask)) 508 smp_call_function_single(cpu, iucv_allow_cpu, 509 NULL, 1); 510 put_online_cpus(); 511} 512 513/** 514 * iucv_setmask_up 515 * 516 * Allow iucv interrupts on a single cpu. 517 */ 518static void iucv_setmask_up(void) 519{ 520 cpumask_t cpumask; 521 int cpu; 522 523 /* Disable all cpu but the first in cpu_irq_cpumask. */ 524 cpumask_copy(&cpumask, &iucv_irq_cpumask); 525 cpumask_clear_cpu(cpumask_first(&iucv_irq_cpumask), &cpumask); 526 for_each_cpu(cpu, &cpumask) 527 smp_call_function_single(cpu, iucv_block_cpu, NULL, 1); 528} 529 530/** 531 * iucv_enable 532 * 533 * This function makes iucv ready for use. It allocates the pathid 534 * table, declares an iucv interrupt buffer and enables the iucv 535 * interrupts. Called when the first user has registered an iucv 536 * handler. 537 */ 538static int iucv_enable(void) 539{ 540 size_t alloc_size; 541 int cpu, rc; 542 543 get_online_cpus(); 544 rc = -ENOMEM; 545 alloc_size = iucv_max_pathid * sizeof(struct iucv_path); 546 iucv_path_table = kzalloc(alloc_size, GFP_KERNEL); 547 if (!iucv_path_table) 548 goto out; 549 /* Declare per cpu buffers. */ 550 rc = -EIO; 551 for_each_online_cpu(cpu) 552 smp_call_function_single(cpu, iucv_declare_cpu, NULL, 1); 553 if (cpumask_empty(&iucv_buffer_cpumask)) 554 /* No cpu could declare an iucv buffer. */ 555 goto out; 556 put_online_cpus(); 557 return 0; 558out: 559 kfree(iucv_path_table); 560 iucv_path_table = NULL; 561 put_online_cpus(); 562 return rc; 563} 564 565/** 566 * iucv_disable 567 * 568 * This function shuts down iucv. It disables iucv interrupts, retrieves 569 * the iucv interrupt buffer and frees the pathid table. Called after the 570 * last user unregister its iucv handler. 571 */ 572static void iucv_disable(void) 573{ 574 get_online_cpus(); 575 on_each_cpu(iucv_retrieve_cpu, NULL, 1); 576 kfree(iucv_path_table); 577 iucv_path_table = NULL; 578 put_online_cpus(); 579} 580 581static int iucv_cpu_dead(unsigned int cpu) 582{ 583 kfree(iucv_param_irq[cpu]); 584 iucv_param_irq[cpu] = NULL; 585 kfree(iucv_param[cpu]); 586 iucv_param[cpu] = NULL; 587 kfree(iucv_irq_data[cpu]); 588 iucv_irq_data[cpu] = NULL; 589 return 0; 590} 591 592static int iucv_cpu_prepare(unsigned int cpu) 593{ 594 /* Note: GFP_DMA used to get memory below 2G */ 595 iucv_irq_data[cpu] = kmalloc_node(sizeof(struct iucv_irq_data), 596 GFP_KERNEL|GFP_DMA, cpu_to_node(cpu)); 597 if (!iucv_irq_data[cpu]) 598 goto out_free; 599 600 /* Allocate parameter blocks. */ 601 iucv_param[cpu] = kmalloc_node(sizeof(union iucv_param), 602 GFP_KERNEL|GFP_DMA, cpu_to_node(cpu)); 603 if (!iucv_param[cpu]) 604 goto out_free; 605 606 iucv_param_irq[cpu] = kmalloc_node(sizeof(union iucv_param), 607 GFP_KERNEL|GFP_DMA, cpu_to_node(cpu)); 608 if (!iucv_param_irq[cpu]) 609 goto out_free; 610 611 return 0; 612 613out_free: 614 iucv_cpu_dead(cpu); 615 return -ENOMEM; 616} 617 618static int iucv_cpu_online(unsigned int cpu) 619{ 620 if (!iucv_path_table) 621 return 0; 622 iucv_declare_cpu(NULL); 623 return 0; 624} 625 626static int iucv_cpu_down_prep(unsigned int cpu) 627{ 628 cpumask_t cpumask; 629 630 if (!iucv_path_table) 631 return 0; 632 633 cpumask_copy(&cpumask, &iucv_buffer_cpumask); 634 cpumask_clear_cpu(cpu, &cpumask); 635 if (cpumask_empty(&cpumask)) 636 /* Can't offline last IUCV enabled cpu. */ 637 return -EINVAL; 638 639 iucv_retrieve_cpu(NULL); 640 if (!cpumask_empty(&iucv_irq_cpumask)) 641 return 0; 642 smp_call_function_single(cpumask_first(&iucv_buffer_cpumask), 643 iucv_allow_cpu, NULL, 1); 644 return 0; 645} 646 647/** 648 * iucv_sever_pathid 649 * @pathid: path identification number. 650 * @userdata: 16-bytes of user data. 651 * 652 * Sever an iucv path to free up the pathid. Used internally. 653 */ 654static int iucv_sever_pathid(u16 pathid, u8 *userdata) 655{ 656 union iucv_param *parm; 657 658 parm = iucv_param_irq[smp_processor_id()]; 659 memset(parm, 0, sizeof(union iucv_param)); 660 if (userdata) 661 memcpy(parm->ctrl.ipuser, userdata, sizeof(parm->ctrl.ipuser)); 662 parm->ctrl.ippathid = pathid; 663 return iucv_call_b2f0(IUCV_SEVER, parm); 664} 665 666/** 667 * __iucv_cleanup_queue 668 * @dummy: unused dummy argument 669 * 670 * Nop function called via smp_call_function to force work items from 671 * pending external iucv interrupts to the work queue. 672 */ 673static void __iucv_cleanup_queue(void *dummy) 674{ 675} 676 677/** 678 * iucv_cleanup_queue 679 * 680 * Function called after a path has been severed to find all remaining 681 * work items for the now stale pathid. The caller needs to hold the 682 * iucv_table_lock. 683 */ 684static void iucv_cleanup_queue(void) 685{ 686 struct iucv_irq_list *p, *n; 687 688 /* 689 * When a path is severed, the pathid can be reused immediately 690 * on a iucv connect or a connection pending interrupt. Remove 691 * all entries from the task queue that refer to a stale pathid 692 * (iucv_path_table[ix] == NULL). Only then do the iucv connect 693 * or deliver the connection pending interrupt. To get all the 694 * pending interrupts force them to the work queue by calling 695 * an empty function on all cpus. 696 */ 697 smp_call_function(__iucv_cleanup_queue, NULL, 1); 698 spin_lock_irq(&iucv_queue_lock); 699 list_for_each_entry_safe(p, n, &iucv_task_queue, list) { 700 /* Remove stale work items from the task queue. */ 701 if (iucv_path_table[p->data.ippathid] == NULL) { 702 list_del(&p->list); 703 kfree(p); 704 } 705 } 706 spin_unlock_irq(&iucv_queue_lock); 707} 708 709/** 710 * iucv_register: 711 * @handler: address of iucv handler structure 712 * @smp: != 0 indicates that the handler can deal with out of order messages 713 * 714 * Registers a driver with IUCV. 715 * 716 * Returns 0 on success, -ENOMEM if the memory allocation for the pathid 717 * table failed, or -EIO if IUCV_DECLARE_BUFFER failed on all cpus. 718 */ 719int iucv_register(struct iucv_handler *handler, int smp) 720{ 721 int rc; 722 723 if (!iucv_available) 724 return -ENOSYS; 725 mutex_lock(&iucv_register_mutex); 726 if (!smp) 727 iucv_nonsmp_handler++; 728 if (list_empty(&iucv_handler_list)) { 729 rc = iucv_enable(); 730 if (rc) 731 goto out_mutex; 732 } else if (!smp && iucv_nonsmp_handler == 1) 733 iucv_setmask_up(); 734 INIT_LIST_HEAD(&handler->paths); 735 736 spin_lock_bh(&iucv_table_lock); 737 list_add_tail(&handler->list, &iucv_handler_list); 738 spin_unlock_bh(&iucv_table_lock); 739 rc = 0; 740out_mutex: 741 mutex_unlock(&iucv_register_mutex); 742 return rc; 743} 744EXPORT_SYMBOL(iucv_register); 745 746/** 747 * iucv_unregister 748 * @handler: address of iucv handler structure 749 * @smp: != 0 indicates that the handler can deal with out of order messages 750 * 751 * Unregister driver from IUCV. 752 */ 753void iucv_unregister(struct iucv_handler *handler, int smp) 754{ 755 struct iucv_path *p, *n; 756 757 mutex_lock(&iucv_register_mutex); 758 spin_lock_bh(&iucv_table_lock); 759 /* Remove handler from the iucv_handler_list. */ 760 list_del_init(&handler->list); 761 /* Sever all pathids still referring to the handler. */ 762 list_for_each_entry_safe(p, n, &handler->paths, list) { 763 iucv_sever_pathid(p->pathid, NULL); 764 iucv_path_table[p->pathid] = NULL; 765 list_del(&p->list); 766 iucv_path_free(p); 767 } 768 spin_unlock_bh(&iucv_table_lock); 769 if (!smp) 770 iucv_nonsmp_handler--; 771 if (list_empty(&iucv_handler_list)) 772 iucv_disable(); 773 else if (!smp && iucv_nonsmp_handler == 0) 774 iucv_setmask_mp(); 775 mutex_unlock(&iucv_register_mutex); 776} 777EXPORT_SYMBOL(iucv_unregister); 778 779static int iucv_reboot_event(struct notifier_block *this, 780 unsigned long event, void *ptr) 781{ 782 int i; 783 784 if (cpumask_empty(&iucv_irq_cpumask)) 785 return NOTIFY_DONE; 786 787 get_online_cpus(); 788 on_each_cpu_mask(&iucv_irq_cpumask, iucv_block_cpu, NULL, 1); 789 preempt_disable(); 790 for (i = 0; i < iucv_max_pathid; i++) { 791 if (iucv_path_table[i]) 792 iucv_sever_pathid(i, NULL); 793 } 794 preempt_enable(); 795 put_online_cpus(); 796 iucv_disable(); 797 return NOTIFY_DONE; 798} 799 800static struct notifier_block iucv_reboot_notifier = { 801 .notifier_call = iucv_reboot_event, 802}; 803 804/** 805 * iucv_path_accept 806 * @path: address of iucv path structure 807 * @handler: address of iucv handler structure 808 * @userdata: 16 bytes of data reflected to the communication partner 809 * @private: private data passed to interrupt handlers for this path 810 * 811 * This function is issued after the user received a connection pending 812 * external interrupt and now wishes to complete the IUCV communication path. 813 * 814 * Returns the result of the CP IUCV call. 815 */ 816int iucv_path_accept(struct iucv_path *path, struct iucv_handler *handler, 817 u8 *userdata, void *private) 818{ 819 union iucv_param *parm; 820 int rc; 821 822 local_bh_disable(); 823 if (cpumask_empty(&iucv_buffer_cpumask)) { 824 rc = -EIO; 825 goto out; 826 } 827 /* Prepare parameter block. */ 828 parm = iucv_param[smp_processor_id()]; 829 memset(parm, 0, sizeof(union iucv_param)); 830 parm->ctrl.ippathid = path->pathid; 831 parm->ctrl.ipmsglim = path->msglim; 832 if (userdata) 833 memcpy(parm->ctrl.ipuser, userdata, sizeof(parm->ctrl.ipuser)); 834 parm->ctrl.ipflags1 = path->flags; 835 836 rc = iucv_call_b2f0(IUCV_ACCEPT, parm); 837 if (!rc) { 838 path->private = private; 839 path->msglim = parm->ctrl.ipmsglim; 840 path->flags = parm->ctrl.ipflags1; 841 } 842out: 843 local_bh_enable(); 844 return rc; 845} 846EXPORT_SYMBOL(iucv_path_accept); 847 848/** 849 * iucv_path_connect 850 * @path: address of iucv path structure 851 * @handler: address of iucv handler structure 852 * @userid: 8-byte user identification 853 * @system: 8-byte target system identification 854 * @userdata: 16 bytes of data reflected to the communication partner 855 * @private: private data passed to interrupt handlers for this path 856 * 857 * This function establishes an IUCV path. Although the connect may complete 858 * successfully, you are not able to use the path until you receive an IUCV 859 * Connection Complete external interrupt. 860 * 861 * Returns the result of the CP IUCV call. 862 */ 863int iucv_path_connect(struct iucv_path *path, struct iucv_handler *handler, 864 u8 *userid, u8 *system, u8 *userdata, 865 void *private) 866{ 867 union iucv_param *parm; 868 int rc; 869 870 spin_lock_bh(&iucv_table_lock); 871 iucv_cleanup_queue(); 872 if (cpumask_empty(&iucv_buffer_cpumask)) { 873 rc = -EIO; 874 goto out; 875 } 876 parm = iucv_param[smp_processor_id()]; 877 memset(parm, 0, sizeof(union iucv_param)); 878 parm->ctrl.ipmsglim = path->msglim; 879 parm->ctrl.ipflags1 = path->flags; 880 if (userid) { 881 memcpy(parm->ctrl.ipvmid, userid, sizeof(parm->ctrl.ipvmid)); 882 ASCEBC(parm->ctrl.ipvmid, sizeof(parm->ctrl.ipvmid)); 883 EBC_TOUPPER(parm->ctrl.ipvmid, sizeof(parm->ctrl.ipvmid)); 884 } 885 if (system) { 886 memcpy(parm->ctrl.iptarget, system, 887 sizeof(parm->ctrl.iptarget)); 888 ASCEBC(parm->ctrl.iptarget, sizeof(parm->ctrl.iptarget)); 889 EBC_TOUPPER(parm->ctrl.iptarget, sizeof(parm->ctrl.iptarget)); 890 } 891 if (userdata) 892 memcpy(parm->ctrl.ipuser, userdata, sizeof(parm->ctrl.ipuser)); 893 894 rc = iucv_call_b2f0(IUCV_CONNECT, parm); 895 if (!rc) { 896 if (parm->ctrl.ippathid < iucv_max_pathid) { 897 path->pathid = parm->ctrl.ippathid; 898 path->msglim = parm->ctrl.ipmsglim; 899 path->flags = parm->ctrl.ipflags1; 900 path->handler = handler; 901 path->private = private; 902 list_add_tail(&path->list, &handler->paths); 903 iucv_path_table[path->pathid] = path; 904 } else { 905 iucv_sever_pathid(parm->ctrl.ippathid, 906 iucv_error_pathid); 907 rc = -EIO; 908 } 909 } 910out: 911 spin_unlock_bh(&iucv_table_lock); 912 return rc; 913} 914EXPORT_SYMBOL(iucv_path_connect); 915 916/** 917 * iucv_path_quiesce: 918 * @path: address of iucv path structure 919 * @userdata: 16 bytes of data reflected to the communication partner 920 * 921 * This function temporarily suspends incoming messages on an IUCV path. 922 * You can later reactivate the path by invoking the iucv_resume function. 923 * 924 * Returns the result from the CP IUCV call. 925 */ 926int iucv_path_quiesce(struct iucv_path *path, u8 *userdata) 927{ 928 union iucv_param *parm; 929 int rc; 930 931 local_bh_disable(); 932 if (cpumask_empty(&iucv_buffer_cpumask)) { 933 rc = -EIO; 934 goto out; 935 } 936 parm = iucv_param[smp_processor_id()]; 937 memset(parm, 0, sizeof(union iucv_param)); 938 if (userdata) 939 memcpy(parm->ctrl.ipuser, userdata, sizeof(parm->ctrl.ipuser)); 940 parm->ctrl.ippathid = path->pathid; 941 rc = iucv_call_b2f0(IUCV_QUIESCE, parm); 942out: 943 local_bh_enable(); 944 return rc; 945} 946EXPORT_SYMBOL(iucv_path_quiesce); 947 948/** 949 * iucv_path_resume: 950 * @path: address of iucv path structure 951 * @userdata: 16 bytes of data reflected to the communication partner 952 * 953 * This function resumes incoming messages on an IUCV path that has 954 * been stopped with iucv_path_quiesce. 955 * 956 * Returns the result from the CP IUCV call. 957 */ 958int iucv_path_resume(struct iucv_path *path, u8 *userdata) 959{ 960 union iucv_param *parm; 961 int rc; 962 963 local_bh_disable(); 964 if (cpumask_empty(&iucv_buffer_cpumask)) { 965 rc = -EIO; 966 goto out; 967 } 968 parm = iucv_param[smp_processor_id()]; 969 memset(parm, 0, sizeof(union iucv_param)); 970 if (userdata) 971 memcpy(parm->ctrl.ipuser, userdata, sizeof(parm->ctrl.ipuser)); 972 parm->ctrl.ippathid = path->pathid; 973 rc = iucv_call_b2f0(IUCV_RESUME, parm); 974out: 975 local_bh_enable(); 976 return rc; 977} 978 979/** 980 * iucv_path_sever 981 * @path: address of iucv path structure 982 * @userdata: 16 bytes of data reflected to the communication partner 983 * 984 * This function terminates an IUCV path. 985 * 986 * Returns the result from the CP IUCV call. 987 */ 988int iucv_path_sever(struct iucv_path *path, u8 *userdata) 989{ 990 int rc; 991 992 preempt_disable(); 993 if (cpumask_empty(&iucv_buffer_cpumask)) { 994 rc = -EIO; 995 goto out; 996 } 997 if (iucv_active_cpu != smp_processor_id()) 998 spin_lock_bh(&iucv_table_lock); 999 rc = iucv_sever_pathid(path->pathid, userdata); 1000 iucv_path_table[path->pathid] = NULL; 1001 list_del_init(&path->list); 1002 if (iucv_active_cpu != smp_processor_id()) 1003 spin_unlock_bh(&iucv_table_lock); 1004out: 1005 preempt_enable(); 1006 return rc; 1007} 1008EXPORT_SYMBOL(iucv_path_sever); 1009 1010/** 1011 * iucv_message_purge 1012 * @path: address of iucv path structure 1013 * @msg: address of iucv msg structure 1014 * @srccls: source class of message 1015 * 1016 * Cancels a message you have sent. 1017 * 1018 * Returns the result from the CP IUCV call. 1019 */ 1020int iucv_message_purge(struct iucv_path *path, struct iucv_message *msg, 1021 u32 srccls) 1022{ 1023 union iucv_param *parm; 1024 int rc; 1025 1026 local_bh_disable(); 1027 if (cpumask_empty(&iucv_buffer_cpumask)) { 1028 rc = -EIO; 1029 goto out; 1030 } 1031 parm = iucv_param[smp_processor_id()]; 1032 memset(parm, 0, sizeof(union iucv_param)); 1033 parm->purge.ippathid = path->pathid; 1034 parm->purge.ipmsgid = msg->id; 1035 parm->purge.ipsrccls = srccls; 1036 parm->purge.ipflags1 = IUCV_IPSRCCLS | IUCV_IPFGMID | IUCV_IPFGPID; 1037 rc = iucv_call_b2f0(IUCV_PURGE, parm); 1038 if (!rc) { 1039 msg->audit = (*(u32 *) &parm->purge.ipaudit) >> 8; 1040 msg->tag = parm->purge.ipmsgtag; 1041 } 1042out: 1043 local_bh_enable(); 1044 return rc; 1045} 1046EXPORT_SYMBOL(iucv_message_purge); 1047 1048/** 1049 * iucv_message_receive_iprmdata 1050 * @path: address of iucv path structure 1051 * @msg: address of iucv msg structure 1052 * @flags: how the message is received (IUCV_IPBUFLST) 1053 * @buffer: address of data buffer or address of struct iucv_array 1054 * @size: length of data buffer 1055 * @residual: 1056 * 1057 * Internal function used by iucv_message_receive and __iucv_message_receive 1058 * to receive RMDATA data stored in struct iucv_message. 1059 */ 1060static int iucv_message_receive_iprmdata(struct iucv_path *path, 1061 struct iucv_message *msg, 1062 u8 flags, void *buffer, 1063 size_t size, size_t *residual) 1064{ 1065 struct iucv_array *array; 1066 u8 *rmmsg; 1067 size_t copy; 1068 1069 /* 1070 * Message is 8 bytes long and has been stored to the 1071 * message descriptor itself. 1072 */ 1073 if (residual) 1074 *residual = abs(size - 8); 1075 rmmsg = msg->rmmsg; 1076 if (flags & IUCV_IPBUFLST) { 1077 /* Copy to struct iucv_array. */ 1078 size = (size < 8) ? size : 8; 1079 for (array = buffer; size > 0; array++) { 1080 copy = min_t(size_t, size, array->length); 1081 memcpy((u8 *)(addr_t) array->address, 1082 rmmsg, copy); 1083 rmmsg += copy; 1084 size -= copy; 1085 } 1086 } else { 1087 /* Copy to direct buffer. */ 1088 memcpy(buffer, rmmsg, min_t(size_t, size, 8)); 1089 } 1090 return 0; 1091} 1092 1093/** 1094 * __iucv_message_receive 1095 * @path: address of iucv path structure 1096 * @msg: address of iucv msg structure 1097 * @flags: how the message is received (IUCV_IPBUFLST) 1098 * @buffer: address of data buffer or address of struct iucv_array 1099 * @size: length of data buffer 1100 * @residual: 1101 * 1102 * This function receives messages that are being sent to you over 1103 * established paths. This function will deal with RMDATA messages 1104 * embedded in struct iucv_message as well. 1105 * 1106 * Locking: no locking 1107 * 1108 * Returns the result from the CP IUCV call. 1109 */ 1110int __iucv_message_receive(struct iucv_path *path, struct iucv_message *msg, 1111 u8 flags, void *buffer, size_t size, size_t *residual) 1112{ 1113 union iucv_param *parm; 1114 int rc; 1115 1116 if (msg->flags & IUCV_IPRMDATA) 1117 return iucv_message_receive_iprmdata(path, msg, flags, 1118 buffer, size, residual); 1119 if (cpumask_empty(&iucv_buffer_cpumask)) 1120 return -EIO; 1121 1122 parm = iucv_param[smp_processor_id()]; 1123 memset(parm, 0, sizeof(union iucv_param)); 1124 parm->db.ipbfadr1 = (u32)(addr_t) buffer; 1125 parm->db.ipbfln1f = (u32) size; 1126 parm->db.ipmsgid = msg->id; 1127 parm->db.ippathid = path->pathid; 1128 parm->db.iptrgcls = msg->class; 1129 parm->db.ipflags1 = (flags | IUCV_IPFGPID | 1130 IUCV_IPFGMID | IUCV_IPTRGCLS); 1131 rc = iucv_call_b2f0(IUCV_RECEIVE, parm); 1132 if (!rc || rc == 5) { 1133 msg->flags = parm->db.ipflags1; 1134 if (residual) 1135 *residual = parm->db.ipbfln1f; 1136 } 1137 return rc; 1138} 1139EXPORT_SYMBOL(__iucv_message_receive); 1140 1141/** 1142 * iucv_message_receive 1143 * @path: address of iucv path structure 1144 * @msg: address of iucv msg structure 1145 * @flags: how the message is received (IUCV_IPBUFLST) 1146 * @buffer: address of data buffer or address of struct iucv_array 1147 * @size: length of data buffer 1148 * @residual: 1149 * 1150 * This function receives messages that are being sent to you over 1151 * established paths. This function will deal with RMDATA messages 1152 * embedded in struct iucv_message as well. 1153 * 1154 * Locking: local_bh_enable/local_bh_disable 1155 * 1156 * Returns the result from the CP IUCV call. 1157 */ 1158int iucv_message_receive(struct iucv_path *path, struct iucv_message *msg, 1159 u8 flags, void *buffer, size_t size, size_t *residual) 1160{ 1161 int rc; 1162 1163 if (msg->flags & IUCV_IPRMDATA) 1164 return iucv_message_receive_iprmdata(path, msg, flags, 1165 buffer, size, residual); 1166 local_bh_disable(); 1167 rc = __iucv_message_receive(path, msg, flags, buffer, size, residual); 1168 local_bh_enable(); 1169 return rc; 1170} 1171EXPORT_SYMBOL(iucv_message_receive); 1172 1173/** 1174 * iucv_message_reject 1175 * @path: address of iucv path structure 1176 * @msg: address of iucv msg structure 1177 * 1178 * The reject function refuses a specified message. Between the time you 1179 * are notified of a message and the time that you complete the message, 1180 * the message may be rejected. 1181 * 1182 * Returns the result from the CP IUCV call. 1183 */ 1184int iucv_message_reject(struct iucv_path *path, struct iucv_message *msg) 1185{ 1186 union iucv_param *parm; 1187 int rc; 1188 1189 local_bh_disable(); 1190 if (cpumask_empty(&iucv_buffer_cpumask)) { 1191 rc = -EIO; 1192 goto out; 1193 } 1194 parm = iucv_param[smp_processor_id()]; 1195 memset(parm, 0, sizeof(union iucv_param)); 1196 parm->db.ippathid = path->pathid; 1197 parm->db.ipmsgid = msg->id; 1198 parm->db.iptrgcls = msg->class; 1199 parm->db.ipflags1 = (IUCV_IPTRGCLS | IUCV_IPFGMID | IUCV_IPFGPID); 1200 rc = iucv_call_b2f0(IUCV_REJECT, parm); 1201out: 1202 local_bh_enable(); 1203 return rc; 1204} 1205EXPORT_SYMBOL(iucv_message_reject); 1206 1207/** 1208 * iucv_message_reply 1209 * @path: address of iucv path structure 1210 * @msg: address of iucv msg structure 1211 * @flags: how the reply is sent (IUCV_IPRMDATA, IUCV_IPPRTY, IUCV_IPBUFLST) 1212 * @reply: address of reply data buffer or address of struct iucv_array 1213 * @size: length of reply data buffer 1214 * 1215 * This function responds to the two-way messages that you receive. You 1216 * must identify completely the message to which you wish to reply. ie, 1217 * pathid, msgid, and trgcls. Prmmsg signifies the data is moved into 1218 * the parameter list. 1219 * 1220 * Returns the result from the CP IUCV call. 1221 */ 1222int iucv_message_reply(struct iucv_path *path, struct iucv_message *msg, 1223 u8 flags, void *reply, size_t size) 1224{ 1225 union iucv_param *parm; 1226 int rc; 1227 1228 local_bh_disable(); 1229 if (cpumask_empty(&iucv_buffer_cpumask)) { 1230 rc = -EIO; 1231 goto out; 1232 } 1233 parm = iucv_param[smp_processor_id()]; 1234 memset(parm, 0, sizeof(union iucv_param)); 1235 if (flags & IUCV_IPRMDATA) { 1236 parm->dpl.ippathid = path->pathid; 1237 parm->dpl.ipflags1 = flags; 1238 parm->dpl.ipmsgid = msg->id; 1239 parm->dpl.iptrgcls = msg->class; 1240 memcpy(parm->dpl.iprmmsg, reply, min_t(size_t, size, 8)); 1241 } else { 1242 parm->db.ipbfadr1 = (u32)(addr_t) reply; 1243 parm->db.ipbfln1f = (u32) size; 1244 parm->db.ippathid = path->pathid; 1245 parm->db.ipflags1 = flags; 1246 parm->db.ipmsgid = msg->id; 1247 parm->db.iptrgcls = msg->class; 1248 } 1249 rc = iucv_call_b2f0(IUCV_REPLY, parm); 1250out: 1251 local_bh_enable(); 1252 return rc; 1253} 1254EXPORT_SYMBOL(iucv_message_reply); 1255 1256/** 1257 * __iucv_message_send 1258 * @path: address of iucv path structure 1259 * @msg: address of iucv msg structure 1260 * @flags: how the message is sent (IUCV_IPRMDATA, IUCV_IPPRTY, IUCV_IPBUFLST) 1261 * @srccls: source class of message 1262 * @buffer: address of send buffer or address of struct iucv_array 1263 * @size: length of send buffer 1264 * 1265 * This function transmits data to another application. Data to be 1266 * transmitted is in a buffer and this is a one-way message and the 1267 * receiver will not reply to the message. 1268 * 1269 * Locking: no locking 1270 * 1271 * Returns the result from the CP IUCV call. 1272 */ 1273int __iucv_message_send(struct iucv_path *path, struct iucv_message *msg, 1274 u8 flags, u32 srccls, void *buffer, size_t size) 1275{ 1276 union iucv_param *parm; 1277 int rc; 1278 1279 if (cpumask_empty(&iucv_buffer_cpumask)) { 1280 rc = -EIO; 1281 goto out; 1282 } 1283 parm = iucv_param[smp_processor_id()]; 1284 memset(parm, 0, sizeof(union iucv_param)); 1285 if (flags & IUCV_IPRMDATA) { 1286 /* Message of 8 bytes can be placed into the parameter list. */ 1287 parm->dpl.ippathid = path->pathid; 1288 parm->dpl.ipflags1 = flags | IUCV_IPNORPY; 1289 parm->dpl.iptrgcls = msg->class; 1290 parm->dpl.ipsrccls = srccls; 1291 parm->dpl.ipmsgtag = msg->tag; 1292 memcpy(parm->dpl.iprmmsg, buffer, 8); 1293 } else { 1294 parm->db.ipbfadr1 = (u32)(addr_t) buffer; 1295 parm->db.ipbfln1f = (u32) size; 1296 parm->db.ippathid = path->pathid; 1297 parm->db.ipflags1 = flags | IUCV_IPNORPY; 1298 parm->db.iptrgcls = msg->class; 1299 parm->db.ipsrccls = srccls; 1300 parm->db.ipmsgtag = msg->tag; 1301 } 1302 rc = iucv_call_b2f0(IUCV_SEND, parm); 1303 if (!rc) 1304 msg->id = parm->db.ipmsgid; 1305out: 1306 return rc; 1307} 1308EXPORT_SYMBOL(__iucv_message_send); 1309 1310/** 1311 * iucv_message_send 1312 * @path: address of iucv path structure 1313 * @msg: address of iucv msg structure 1314 * @flags: how the message is sent (IUCV_IPRMDATA, IUCV_IPPRTY, IUCV_IPBUFLST) 1315 * @srccls: source class of message 1316 * @buffer: address of send buffer or address of struct iucv_array 1317 * @size: length of send buffer 1318 * 1319 * This function transmits data to another application. Data to be 1320 * transmitted is in a buffer and this is a one-way message and the 1321 * receiver will not reply to the message. 1322 * 1323 * Locking: local_bh_enable/local_bh_disable 1324 * 1325 * Returns the result from the CP IUCV call. 1326 */ 1327int iucv_message_send(struct iucv_path *path, struct iucv_message *msg, 1328 u8 flags, u32 srccls, void *buffer, size_t size) 1329{ 1330 int rc; 1331 1332 local_bh_disable(); 1333 rc = __iucv_message_send(path, msg, flags, srccls, buffer, size); 1334 local_bh_enable(); 1335 return rc; 1336} 1337EXPORT_SYMBOL(iucv_message_send); 1338 1339/** 1340 * iucv_message_send2way 1341 * @path: address of iucv path structure 1342 * @msg: address of iucv msg structure 1343 * @flags: how the message is sent and the reply is received 1344 * (IUCV_IPRMDATA, IUCV_IPBUFLST, IUCV_IPPRTY, IUCV_ANSLST) 1345 * @srccls: source class of message 1346 * @buffer: address of send buffer or address of struct iucv_array 1347 * @size: length of send buffer 1348 * @ansbuf: address of answer buffer or address of struct iucv_array 1349 * @asize: size of reply buffer 1350 * 1351 * This function transmits data to another application. Data to be 1352 * transmitted is in a buffer. The receiver of the send is expected to 1353 * reply to the message and a buffer is provided into which IUCV moves 1354 * the reply to this message. 1355 * 1356 * Returns the result from the CP IUCV call. 1357 */ 1358int iucv_message_send2way(struct iucv_path *path, struct iucv_message *msg, 1359 u8 flags, u32 srccls, void *buffer, size_t size, 1360 void *answer, size_t asize, size_t *residual) 1361{ 1362 union iucv_param *parm; 1363 int rc; 1364 1365 local_bh_disable(); 1366 if (cpumask_empty(&iucv_buffer_cpumask)) { 1367 rc = -EIO; 1368 goto out; 1369 } 1370 parm = iucv_param[smp_processor_id()]; 1371 memset(parm, 0, sizeof(union iucv_param)); 1372 if (flags & IUCV_IPRMDATA) { 1373 parm->dpl.ippathid = path->pathid; 1374 parm->dpl.ipflags1 = path->flags; /* priority message */ 1375 parm->dpl.iptrgcls = msg->class; 1376 parm->dpl.ipsrccls = srccls; 1377 parm->dpl.ipmsgtag = msg->tag; 1378 parm->dpl.ipbfadr2 = (u32)(addr_t) answer; 1379 parm->dpl.ipbfln2f = (u32) asize; 1380 memcpy(parm->dpl.iprmmsg, buffer, 8); 1381 } else { 1382 parm->db.ippathid = path->pathid; 1383 parm->db.ipflags1 = path->flags; /* priority message */ 1384 parm->db.iptrgcls = msg->class; 1385 parm->db.ipsrccls = srccls; 1386 parm->db.ipmsgtag = msg->tag; 1387 parm->db.ipbfadr1 = (u32)(addr_t) buffer; 1388 parm->db.ipbfln1f = (u32) size; 1389 parm->db.ipbfadr2 = (u32)(addr_t) answer; 1390 parm->db.ipbfln2f = (u32) asize; 1391 } 1392 rc = iucv_call_b2f0(IUCV_SEND, parm); 1393 if (!rc) 1394 msg->id = parm->db.ipmsgid; 1395out: 1396 local_bh_enable(); 1397 return rc; 1398} 1399EXPORT_SYMBOL(iucv_message_send2way); 1400 1401/** 1402 * iucv_path_pending 1403 * @data: Pointer to external interrupt buffer 1404 * 1405 * Process connection pending work item. Called from tasklet while holding 1406 * iucv_table_lock. 1407 */ 1408struct iucv_path_pending { 1409 u16 ippathid; 1410 u8 ipflags1; 1411 u8 iptype; 1412 u16 ipmsglim; 1413 u16 res1; 1414 u8 ipvmid[8]; 1415 u8 ipuser[16]; 1416 u32 res3; 1417 u8 ippollfg; 1418 u8 res4[3]; 1419} __packed; 1420 1421static void iucv_path_pending(struct iucv_irq_data *data) 1422{ 1423 struct iucv_path_pending *ipp = (void *) data; 1424 struct iucv_handler *handler; 1425 struct iucv_path *path; 1426 char *error; 1427 1428 BUG_ON(iucv_path_table[ipp->ippathid]); 1429 /* New pathid, handler found. Create a new path struct. */ 1430 error = iucv_error_no_memory; 1431 path = iucv_path_alloc(ipp->ipmsglim, ipp->ipflags1, GFP_ATOMIC); 1432 if (!path) 1433 goto out_sever; 1434 path->pathid = ipp->ippathid; 1435 iucv_path_table[path->pathid] = path; 1436 EBCASC(ipp->ipvmid, 8); 1437 1438 /* Call registered handler until one is found that wants the path. */ 1439 list_for_each_entry(handler, &iucv_handler_list, list) { 1440 if (!handler->path_pending) 1441 continue; 1442 /* 1443 * Add path to handler to allow a call to iucv_path_sever 1444 * inside the path_pending function. If the handler returns 1445 * an error remove the path from the handler again. 1446 */ 1447 list_add(&path->list, &handler->paths); 1448 path->handler = handler; 1449 if (!handler->path_pending(path, ipp->ipvmid, ipp->ipuser)) 1450 return; 1451 list_del(&path->list); 1452 path->handler = NULL; 1453 } 1454 /* No handler wanted the path. */ 1455 iucv_path_table[path->pathid] = NULL; 1456 iucv_path_free(path); 1457 error = iucv_error_no_listener; 1458out_sever: 1459 iucv_sever_pathid(ipp->ippathid, error); 1460} 1461 1462/** 1463 * iucv_path_complete 1464 * @data: Pointer to external interrupt buffer 1465 * 1466 * Process connection complete work item. Called from tasklet while holding 1467 * iucv_table_lock. 1468 */ 1469struct iucv_path_complete { 1470 u16 ippathid; 1471 u8 ipflags1; 1472 u8 iptype; 1473 u16 ipmsglim; 1474 u16 res1; 1475 u8 res2[8]; 1476 u8 ipuser[16]; 1477 u32 res3; 1478 u8 ippollfg; 1479 u8 res4[3]; 1480} __packed; 1481 1482static void iucv_path_complete(struct iucv_irq_data *data) 1483{ 1484 struct iucv_path_complete *ipc = (void *) data; 1485 struct iucv_path *path = iucv_path_table[ipc->ippathid]; 1486 1487 if (path) 1488 path->flags = ipc->ipflags1; 1489 if (path && path->handler && path->handler->path_complete) 1490 path->handler->path_complete(path, ipc->ipuser); 1491} 1492 1493/** 1494 * iucv_path_severed 1495 * @data: Pointer to external interrupt buffer 1496 * 1497 * Process connection severed work item. Called from tasklet while holding 1498 * iucv_table_lock. 1499 */ 1500struct iucv_path_severed { 1501 u16 ippathid; 1502 u8 res1; 1503 u8 iptype; 1504 u32 res2; 1505 u8 res3[8]; 1506 u8 ipuser[16]; 1507 u32 res4; 1508 u8 ippollfg; 1509 u8 res5[3]; 1510} __packed; 1511 1512static void iucv_path_severed(struct iucv_irq_data *data) 1513{ 1514 struct iucv_path_severed *ips = (void *) data; 1515 struct iucv_path *path = iucv_path_table[ips->ippathid]; 1516 1517 if (!path || !path->handler) /* Already severed */ 1518 return; 1519 if (path->handler->path_severed) 1520 path->handler->path_severed(path, ips->ipuser); 1521 else { 1522 iucv_sever_pathid(path->pathid, NULL); 1523 iucv_path_table[path->pathid] = NULL; 1524 list_del(&path->list); 1525 iucv_path_free(path); 1526 } 1527} 1528 1529/** 1530 * iucv_path_quiesced 1531 * @data: Pointer to external interrupt buffer 1532 * 1533 * Process connection quiesced work item. Called from tasklet while holding 1534 * iucv_table_lock. 1535 */ 1536struct iucv_path_quiesced { 1537 u16 ippathid; 1538 u8 res1; 1539 u8 iptype; 1540 u32 res2; 1541 u8 res3[8]; 1542 u8 ipuser[16]; 1543 u32 res4; 1544 u8 ippollfg; 1545 u8 res5[3]; 1546} __packed; 1547 1548static void iucv_path_quiesced(struct iucv_irq_data *data) 1549{ 1550 struct iucv_path_quiesced *ipq = (void *) data; 1551 struct iucv_path *path = iucv_path_table[ipq->ippathid]; 1552 1553 if (path && path->handler && path->handler->path_quiesced) 1554 path->handler->path_quiesced(path, ipq->ipuser); 1555} 1556 1557/** 1558 * iucv_path_resumed 1559 * @data: Pointer to external interrupt buffer 1560 * 1561 * Process connection resumed work item. Called from tasklet while holding 1562 * iucv_table_lock. 1563 */ 1564struct iucv_path_resumed { 1565 u16 ippathid; 1566 u8 res1; 1567 u8 iptype; 1568 u32 res2; 1569 u8 res3[8]; 1570 u8 ipuser[16]; 1571 u32 res4; 1572 u8 ippollfg; 1573 u8 res5[3]; 1574} __packed; 1575 1576static void iucv_path_resumed(struct iucv_irq_data *data) 1577{ 1578 struct iucv_path_resumed *ipr = (void *) data; 1579 struct iucv_path *path = iucv_path_table[ipr->ippathid]; 1580 1581 if (path && path->handler && path->handler->path_resumed) 1582 path->handler->path_resumed(path, ipr->ipuser); 1583} 1584 1585/** 1586 * iucv_message_complete 1587 * @data: Pointer to external interrupt buffer 1588 * 1589 * Process message complete work item. Called from tasklet while holding 1590 * iucv_table_lock. 1591 */ 1592struct iucv_message_complete { 1593 u16 ippathid; 1594 u8 ipflags1; 1595 u8 iptype; 1596 u32 ipmsgid; 1597 u32 ipaudit; 1598 u8 iprmmsg[8]; 1599 u32 ipsrccls; 1600 u32 ipmsgtag; 1601 u32 res; 1602 u32 ipbfln2f; 1603 u8 ippollfg; 1604 u8 res2[3]; 1605} __packed; 1606 1607static void iucv_message_complete(struct iucv_irq_data *data) 1608{ 1609 struct iucv_message_complete *imc = (void *) data; 1610 struct iucv_path *path = iucv_path_table[imc->ippathid]; 1611 struct iucv_message msg; 1612 1613 if (path && path->handler && path->handler->message_complete) { 1614 msg.flags = imc->ipflags1; 1615 msg.id = imc->ipmsgid; 1616 msg.audit = imc->ipaudit; 1617 memcpy(msg.rmmsg, imc->iprmmsg, 8); 1618 msg.class = imc->ipsrccls; 1619 msg.tag = imc->ipmsgtag; 1620 msg.length = imc->ipbfln2f; 1621 path->handler->message_complete(path, &msg); 1622 } 1623} 1624 1625/** 1626 * iucv_message_pending 1627 * @data: Pointer to external interrupt buffer 1628 * 1629 * Process message pending work item. Called from tasklet while holding 1630 * iucv_table_lock. 1631 */ 1632struct iucv_message_pending { 1633 u16 ippathid; 1634 u8 ipflags1; 1635 u8 iptype; 1636 u32 ipmsgid; 1637 u32 iptrgcls; 1638 union { 1639 u32 iprmmsg1_u32; 1640 u8 iprmmsg1[4]; 1641 } ln1msg1; 1642 union { 1643 u32 ipbfln1f; 1644 u8 iprmmsg2[4]; 1645 } ln1msg2; 1646 u32 res1[3]; 1647 u32 ipbfln2f; 1648 u8 ippollfg; 1649 u8 res2[3]; 1650} __packed; 1651 1652static void iucv_message_pending(struct iucv_irq_data *data) 1653{ 1654 struct iucv_message_pending *imp = (void *) data; 1655 struct iucv_path *path = iucv_path_table[imp->ippathid]; 1656 struct iucv_message msg; 1657 1658 if (path && path->handler && path->handler->message_pending) { 1659 msg.flags = imp->ipflags1; 1660 msg.id = imp->ipmsgid; 1661 msg.class = imp->iptrgcls; 1662 if (imp->ipflags1 & IUCV_IPRMDATA) { 1663 memcpy(msg.rmmsg, imp->ln1msg1.iprmmsg1, 8); 1664 msg.length = 8; 1665 } else 1666 msg.length = imp->ln1msg2.ipbfln1f; 1667 msg.reply_size = imp->ipbfln2f; 1668 path->handler->message_pending(path, &msg); 1669 } 1670} 1671 1672/** 1673 * iucv_tasklet_fn: 1674 * 1675 * This tasklet loops over the queue of irq buffers created by 1676 * iucv_external_interrupt, calls the appropriate action handler 1677 * and then frees the buffer. 1678 */ 1679static void iucv_tasklet_fn(unsigned long ignored) 1680{ 1681 typedef void iucv_irq_fn(struct iucv_irq_data *); 1682 static iucv_irq_fn *irq_fn[] = { 1683 [0x02] = iucv_path_complete, 1684 [0x03] = iucv_path_severed, 1685 [0x04] = iucv_path_quiesced, 1686 [0x05] = iucv_path_resumed, 1687 [0x06] = iucv_message_complete, 1688 [0x07] = iucv_message_complete, 1689 [0x08] = iucv_message_pending, 1690 [0x09] = iucv_message_pending, 1691 }; 1692 LIST_HEAD(task_queue); 1693 struct iucv_irq_list *p, *n; 1694 1695 /* Serialize tasklet, iucv_path_sever and iucv_path_connect. */ 1696 if (!spin_trylock(&iucv_table_lock)) { 1697 tasklet_schedule(&iucv_tasklet); 1698 return; 1699 } 1700 iucv_active_cpu = smp_processor_id(); 1701 1702 spin_lock_irq(&iucv_queue_lock); 1703 list_splice_init(&iucv_task_queue, &task_queue); 1704 spin_unlock_irq(&iucv_queue_lock); 1705 1706 list_for_each_entry_safe(p, n, &task_queue, list) { 1707 list_del_init(&p->list); 1708 irq_fn[p->data.iptype](&p->data); 1709 kfree(p); 1710 } 1711 1712 iucv_active_cpu = -1; 1713 spin_unlock(&iucv_table_lock); 1714} 1715 1716/** 1717 * iucv_work_fn: 1718 * 1719 * This work function loops over the queue of path pending irq blocks 1720 * created by iucv_external_interrupt, calls the appropriate action 1721 * handler and then frees the buffer. 1722 */ 1723static void iucv_work_fn(struct work_struct *work) 1724{ 1725 LIST_HEAD(work_queue); 1726 struct iucv_irq_list *p, *n; 1727 1728 /* Serialize tasklet, iucv_path_sever and iucv_path_connect. */ 1729 spin_lock_bh(&iucv_table_lock); 1730 iucv_active_cpu = smp_processor_id(); 1731 1732 spin_lock_irq(&iucv_queue_lock); 1733 list_splice_init(&iucv_work_queue, &work_queue); 1734 spin_unlock_irq(&iucv_queue_lock); 1735 1736 iucv_cleanup_queue(); 1737 list_for_each_entry_safe(p, n, &work_queue, list) { 1738 list_del_init(&p->list); 1739 iucv_path_pending(&p->data); 1740 kfree(p); 1741 } 1742 1743 iucv_active_cpu = -1; 1744 spin_unlock_bh(&iucv_table_lock); 1745} 1746 1747/** 1748 * iucv_external_interrupt 1749 * @code: irq code 1750 * 1751 * Handles external interrupts coming in from CP. 1752 * Places the interrupt buffer on a queue and schedules iucv_tasklet_fn(). 1753 */ 1754static void iucv_external_interrupt(struct ext_code ext_code, 1755 unsigned int param32, unsigned long param64) 1756{ 1757 struct iucv_irq_data *p; 1758 struct iucv_irq_list *work; 1759 1760 inc_irq_stat(IRQEXT_IUC); 1761 p = iucv_irq_data[smp_processor_id()]; 1762 if (p->ippathid >= iucv_max_pathid) { 1763 WARN_ON(p->ippathid >= iucv_max_pathid); 1764 iucv_sever_pathid(p->ippathid, iucv_error_no_listener); 1765 return; 1766 } 1767 BUG_ON(p->iptype < 0x01 || p->iptype > 0x09); 1768 work = kmalloc(sizeof(struct iucv_irq_list), GFP_ATOMIC); 1769 if (!work) { 1770 pr_warn("iucv_external_interrupt: out of memory\n"); 1771 return; 1772 } 1773 memcpy(&work->data, p, sizeof(work->data)); 1774 spin_lock(&iucv_queue_lock); 1775 if (p->iptype == 0x01) { 1776 /* Path pending interrupt. */ 1777 list_add_tail(&work->list, &iucv_work_queue); 1778 schedule_work(&iucv_work); 1779 } else { 1780 /* The other interrupts. */ 1781 list_add_tail(&work->list, &iucv_task_queue); 1782 tasklet_schedule(&iucv_tasklet); 1783 } 1784 spin_unlock(&iucv_queue_lock); 1785} 1786 1787struct iucv_interface iucv_if = { 1788 .message_receive = iucv_message_receive, 1789 .__message_receive = __iucv_message_receive, 1790 .message_reply = iucv_message_reply, 1791 .message_reject = iucv_message_reject, 1792 .message_send = iucv_message_send, 1793 .__message_send = __iucv_message_send, 1794 .message_send2way = iucv_message_send2way, 1795 .message_purge = iucv_message_purge, 1796 .path_accept = iucv_path_accept, 1797 .path_connect = iucv_path_connect, 1798 .path_quiesce = iucv_path_quiesce, 1799 .path_resume = iucv_path_resume, 1800 .path_sever = iucv_path_sever, 1801 .iucv_register = iucv_register, 1802 .iucv_unregister = iucv_unregister, 1803 .bus = NULL, 1804 .root = NULL, 1805}; 1806EXPORT_SYMBOL(iucv_if); 1807 1808static enum cpuhp_state iucv_online; 1809/** 1810 * iucv_init 1811 * 1812 * Allocates and initializes various data structures. 1813 */ 1814static int __init iucv_init(void) 1815{ 1816 int rc; 1817 1818 if (!MACHINE_IS_VM) { 1819 rc = -EPROTONOSUPPORT; 1820 goto out; 1821 } 1822 ctl_set_bit(0, 1); 1823 rc = iucv_query_maxconn(); 1824 if (rc) 1825 goto out_ctl; 1826 rc = register_external_irq(EXT_IRQ_IUCV, iucv_external_interrupt); 1827 if (rc) 1828 goto out_ctl; 1829 iucv_root = root_device_register("iucv"); 1830 if (IS_ERR(iucv_root)) { 1831 rc = PTR_ERR(iucv_root); 1832 goto out_int; 1833 } 1834 1835 rc = cpuhp_setup_state(CPUHP_NET_IUCV_PREPARE, "net/iucv:prepare", 1836 iucv_cpu_prepare, iucv_cpu_dead); 1837 if (rc) 1838 goto out_dev; 1839 rc = cpuhp_setup_state(CPUHP_AP_ONLINE_DYN, "net/iucv:online", 1840 iucv_cpu_online, iucv_cpu_down_prep); 1841 if (rc < 0) 1842 goto out_prep; 1843 iucv_online = rc; 1844 1845 rc = register_reboot_notifier(&iucv_reboot_notifier); 1846 if (rc) 1847 goto out_remove_hp; 1848 ASCEBC(iucv_error_no_listener, 16); 1849 ASCEBC(iucv_error_no_memory, 16); 1850 ASCEBC(iucv_error_pathid, 16); 1851 iucv_available = 1; 1852 rc = bus_register(&iucv_bus); 1853 if (rc) 1854 goto out_reboot; 1855 iucv_if.root = iucv_root; 1856 iucv_if.bus = &iucv_bus; 1857 return 0; 1858 1859out_reboot: 1860 unregister_reboot_notifier(&iucv_reboot_notifier); 1861out_remove_hp: 1862 cpuhp_remove_state(iucv_online); 1863out_prep: 1864 cpuhp_remove_state(CPUHP_NET_IUCV_PREPARE); 1865out_dev: 1866 root_device_unregister(iucv_root); 1867out_int: 1868 unregister_external_irq(EXT_IRQ_IUCV, iucv_external_interrupt); 1869out_ctl: 1870 ctl_clear_bit(0, 1); 1871out: 1872 return rc; 1873} 1874 1875/** 1876 * iucv_exit 1877 * 1878 * Frees everything allocated from iucv_init. 1879 */ 1880static void __exit iucv_exit(void) 1881{ 1882 struct iucv_irq_list *p, *n; 1883 1884 spin_lock_irq(&iucv_queue_lock); 1885 list_for_each_entry_safe(p, n, &iucv_task_queue, list) 1886 kfree(p); 1887 list_for_each_entry_safe(p, n, &iucv_work_queue, list) 1888 kfree(p); 1889 spin_unlock_irq(&iucv_queue_lock); 1890 unregister_reboot_notifier(&iucv_reboot_notifier); 1891 1892 cpuhp_remove_state_nocalls(iucv_online); 1893 cpuhp_remove_state(CPUHP_NET_IUCV_PREPARE); 1894 root_device_unregister(iucv_root); 1895 bus_unregister(&iucv_bus); 1896 unregister_external_irq(EXT_IRQ_IUCV, iucv_external_interrupt); 1897} 1898 1899subsys_initcall(iucv_init); 1900module_exit(iucv_exit); 1901 1902MODULE_AUTHOR("(C) 2001 IBM Corp. by Fritz Elfert (felfert@millenux.com)"); 1903MODULE_DESCRIPTION("Linux for S/390 IUCV lowlevel driver"); 1904MODULE_LICENSE("GPL"); 1905