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