1 | // SPDX-License-Identifier: GPL-2.0+ |
2 | /* |
3 | * IUCV special message driver |
4 | * |
5 | * Copyright IBM Corp. 2003, 2009 |
6 | * |
7 | * Author(s): Martin Schwidefsky (schwidefsky@de.ibm.com) |
8 | */ |
9 | |
10 | #include <linux/module.h> |
11 | #include <linux/init.h> |
12 | #include <linux/errno.h> |
13 | #include <linux/device.h> |
14 | #include <linux/slab.h> |
15 | #include <net/iucv/iucv.h> |
16 | #include <asm/cpcmd.h> |
17 | #include <asm/ebcdic.h> |
18 | #include "smsgiucv.h" |
19 | |
20 | struct smsg_callback { |
21 | struct list_head list; |
22 | const char *prefix; |
23 | int len; |
24 | void (*callback)(const char *from, char *str); |
25 | }; |
26 | |
27 | MODULE_AUTHOR |
28 | ("(C) 2003 IBM Corporation by Martin Schwidefsky (schwidefsky@de.ibm.com)" ); |
29 | MODULE_DESCRIPTION ("Linux for S/390 IUCV special message driver" ); |
30 | |
31 | static struct iucv_path *smsg_path; |
32 | |
33 | static DEFINE_SPINLOCK(smsg_list_lock); |
34 | static LIST_HEAD(smsg_list); |
35 | |
36 | static int smsg_path_pending(struct iucv_path *, u8 *, u8 *); |
37 | static void smsg_message_pending(struct iucv_path *, struct iucv_message *); |
38 | |
39 | static struct iucv_handler smsg_handler = { |
40 | .path_pending = smsg_path_pending, |
41 | .message_pending = smsg_message_pending, |
42 | }; |
43 | |
44 | static int smsg_path_pending(struct iucv_path *path, u8 *ipvmid, u8 *ipuser) |
45 | { |
46 | if (strncmp(ipvmid, "*MSG " , 8) != 0) |
47 | return -EINVAL; |
48 | /* Path pending from *MSG. */ |
49 | return iucv_path_accept(path, handler: &smsg_handler, userdata: "SMSGIUCV " , NULL); |
50 | } |
51 | |
52 | static void smsg_message_pending(struct iucv_path *path, |
53 | struct iucv_message *msg) |
54 | { |
55 | struct smsg_callback *cb; |
56 | unsigned char *buffer; |
57 | unsigned char sender[9]; |
58 | int rc, i; |
59 | |
60 | buffer = kmalloc(size: msg->length + 1, GFP_ATOMIC | GFP_DMA); |
61 | if (!buffer) { |
62 | iucv_message_reject(path, msg); |
63 | return; |
64 | } |
65 | rc = iucv_message_receive(path, msg, flags: 0, buffer, size: msg->length, NULL); |
66 | if (rc == 0) { |
67 | buffer[msg->length] = 0; |
68 | EBCASC(buffer, msg->length); |
69 | memcpy(sender, buffer, 8); |
70 | sender[8] = 0; |
71 | /* Remove trailing whitespace from the sender name. */ |
72 | for (i = 7; i >= 0; i--) { |
73 | if (sender[i] != ' ' && sender[i] != '\t') |
74 | break; |
75 | sender[i] = 0; |
76 | } |
77 | spin_lock(lock: &smsg_list_lock); |
78 | list_for_each_entry(cb, &smsg_list, list) |
79 | if (strncmp(buffer + 8, cb->prefix, cb->len) == 0) { |
80 | cb->callback(sender, buffer + 8); |
81 | break; |
82 | } |
83 | spin_unlock(lock: &smsg_list_lock); |
84 | } |
85 | kfree(objp: buffer); |
86 | } |
87 | |
88 | int smsg_register_callback(const char *prefix, |
89 | void (*callback)(const char *from, char *str)) |
90 | { |
91 | struct smsg_callback *cb; |
92 | |
93 | cb = kmalloc(size: sizeof(struct smsg_callback), GFP_KERNEL); |
94 | if (!cb) |
95 | return -ENOMEM; |
96 | cb->prefix = prefix; |
97 | cb->len = strlen(prefix); |
98 | cb->callback = callback; |
99 | spin_lock_bh(lock: &smsg_list_lock); |
100 | list_add_tail(new: &cb->list, head: &smsg_list); |
101 | spin_unlock_bh(lock: &smsg_list_lock); |
102 | return 0; |
103 | } |
104 | |
105 | void smsg_unregister_callback(const char *prefix, |
106 | void (*callback)(const char *from, |
107 | char *str)) |
108 | { |
109 | struct smsg_callback *cb, *tmp; |
110 | |
111 | spin_lock_bh(lock: &smsg_list_lock); |
112 | cb = NULL; |
113 | list_for_each_entry(tmp, &smsg_list, list) |
114 | if (tmp->callback == callback && |
115 | strcmp(tmp->prefix, prefix) == 0) { |
116 | cb = tmp; |
117 | list_del(entry: &cb->list); |
118 | break; |
119 | } |
120 | spin_unlock_bh(lock: &smsg_list_lock); |
121 | kfree(objp: cb); |
122 | } |
123 | |
124 | static struct device_driver smsg_driver = { |
125 | .owner = THIS_MODULE, |
126 | .name = SMSGIUCV_DRV_NAME, |
127 | .bus = &iucv_bus, |
128 | }; |
129 | |
130 | static void __exit smsg_exit(void) |
131 | { |
132 | cpcmd("SET SMSG OFF" , NULL, 0, NULL); |
133 | iucv_unregister(handle: &smsg_handler, smp: 1); |
134 | driver_unregister(drv: &smsg_driver); |
135 | } |
136 | |
137 | static int __init smsg_init(void) |
138 | { |
139 | int rc; |
140 | |
141 | if (!MACHINE_IS_VM) { |
142 | rc = -EPROTONOSUPPORT; |
143 | goto out; |
144 | } |
145 | rc = driver_register(drv: &smsg_driver); |
146 | if (rc != 0) |
147 | goto out; |
148 | rc = iucv_register(handler: &smsg_handler, smp: 1); |
149 | if (rc) |
150 | goto out_driver; |
151 | smsg_path = iucv_path_alloc(msglim: 255, flags: 0, GFP_KERNEL); |
152 | if (!smsg_path) { |
153 | rc = -ENOMEM; |
154 | goto out_register; |
155 | } |
156 | rc = iucv_path_connect(path: smsg_path, handler: &smsg_handler, userid: "*MSG " , |
157 | NULL, NULL, NULL); |
158 | if (rc) |
159 | goto out_free_path; |
160 | |
161 | cpcmd("SET SMSG IUCV" , NULL, 0, NULL); |
162 | return 0; |
163 | |
164 | out_free_path: |
165 | iucv_path_free(path: smsg_path); |
166 | smsg_path = NULL; |
167 | out_register: |
168 | iucv_unregister(handle: &smsg_handler, smp: 1); |
169 | out_driver: |
170 | driver_unregister(drv: &smsg_driver); |
171 | out: |
172 | return rc; |
173 | } |
174 | |
175 | module_init(smsg_init); |
176 | module_exit(smsg_exit); |
177 | MODULE_LICENSE("GPL" ); |
178 | |
179 | EXPORT_SYMBOL(smsg_register_callback); |
180 | EXPORT_SYMBOL(smsg_unregister_callback); |
181 | |