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