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