1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * Copyright IBM Corp. 2007, 2009
4 * Author(s): Utz Bacher <utz.bacher@de.ibm.com>,
5 * Frank Pavlic <fpavlic@de.ibm.com>,
6 * Thomas Spatzier <tspat@de.ibm.com>,
7 * Frank Blaschka <frank.blaschka@de.ibm.com>
8 */
9
10 #define KMSG_COMPONENT "qeth"
11 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
12
13 #include <linux/export.h>
14 #include <linux/module.h>
15 #include <linux/moduleparam.h>
16 #include <linux/bitops.h>
17 #include <linux/string.h>
18 #include <linux/errno.h>
19 #include <linux/kernel.h>
20 #include <linux/etherdevice.h>
21 #include <linux/ip.h>
22 #include <linux/in.h>
23 #include <linux/inet.h>
24 #include <linux/ipv6.h>
25 #include <linux/inetdevice.h>
26 #include <linux/igmp.h>
27 #include <linux/slab.h>
28 #include <linux/if_ether.h>
29 #include <linux/if_vlan.h>
30 #include <linux/skbuff.h>
31
32 #include <net/ip.h>
33 #include <net/arp.h>
34 #include <net/route.h>
35 #include <net/ipv6.h>
36 #include <net/ip6_route.h>
37 #include <net/iucv/af_iucv.h>
38 #include <linux/hashtable.h>
39
40 #include "qeth_l3.h"
41
42 static int qeth_l3_register_addr_entry(struct qeth_card *,
43 struct qeth_ipaddr *);
44 static int qeth_l3_deregister_addr_entry(struct qeth_card *,
45 struct qeth_ipaddr *);
46
qeth_l3_ipaddr_to_string(enum qeth_prot_versions proto,const u8 * addr,char * buf)47 int qeth_l3_ipaddr_to_string(enum qeth_prot_versions proto, const u8 *addr,
48 char *buf)
49 {
50 if (proto == QETH_PROT_IPV4)
51 return scnprintf(buf, INET_ADDRSTRLEN, "%pI4", addr);
52 else
53 return scnprintf(buf, INET6_ADDRSTRLEN, "%pI6", addr);
54 }
55
qeth_l3_find_addr_by_ip(struct qeth_card * card,struct qeth_ipaddr * query)56 static struct qeth_ipaddr *qeth_l3_find_addr_by_ip(struct qeth_card *card,
57 struct qeth_ipaddr *query)
58 {
59 u32 key = qeth_l3_ipaddr_hash(query);
60 struct qeth_ipaddr *addr;
61
62 if (query->is_multicast) {
63 hash_for_each_possible(card->rx_mode_addrs, addr, hnode, key)
64 if (qeth_l3_addr_match_ip(addr, query))
65 return addr;
66 } else {
67 hash_for_each_possible(card->ip_htable, addr, hnode, key)
68 if (qeth_l3_addr_match_ip(addr, query))
69 return addr;
70 }
71 return NULL;
72 }
73
qeth_l3_convert_addr_to_bits(u8 * addr,u8 * bits,int len)74 static void qeth_l3_convert_addr_to_bits(u8 *addr, u8 *bits, int len)
75 {
76 int i, j;
77 u8 octet;
78
79 for (i = 0; i < len; ++i) {
80 octet = addr[i];
81 for (j = 7; j >= 0; --j) {
82 bits[i*8 + j] = octet & 1;
83 octet >>= 1;
84 }
85 }
86 }
87
qeth_l3_is_addr_covered_by_ipato(struct qeth_card * card,struct qeth_ipaddr * addr)88 static bool qeth_l3_is_addr_covered_by_ipato(struct qeth_card *card,
89 struct qeth_ipaddr *addr)
90 {
91 struct qeth_ipato_entry *ipatoe;
92 u8 addr_bits[128] = {0, };
93 u8 ipatoe_bits[128] = {0, };
94 int rc = 0;
95
96 if (!card->ipato.enabled)
97 return false;
98 if (addr->type != QETH_IP_TYPE_NORMAL)
99 return false;
100
101 qeth_l3_convert_addr_to_bits((u8 *) &addr->u, addr_bits,
102 (addr->proto == QETH_PROT_IPV4) ? 4 : 16);
103 list_for_each_entry(ipatoe, &card->ipato.entries, entry) {
104 if (addr->proto != ipatoe->proto)
105 continue;
106 qeth_l3_convert_addr_to_bits(ipatoe->addr, ipatoe_bits,
107 (ipatoe->proto == QETH_PROT_IPV4) ?
108 4 : 16);
109 rc = !memcmp(addr_bits, ipatoe_bits, ipatoe->mask_bits);
110 if (rc)
111 break;
112 }
113 /* invert? */
114 if ((addr->proto == QETH_PROT_IPV4) && card->ipato.invert4)
115 rc = !rc;
116 else if ((addr->proto == QETH_PROT_IPV6) && card->ipato.invert6)
117 rc = !rc;
118
119 return rc;
120 }
121
qeth_l3_delete_ip(struct qeth_card * card,struct qeth_ipaddr * tmp_addr)122 static int qeth_l3_delete_ip(struct qeth_card *card,
123 struct qeth_ipaddr *tmp_addr)
124 {
125 int rc = 0;
126 struct qeth_ipaddr *addr;
127
128 if (tmp_addr->type == QETH_IP_TYPE_RXIP)
129 QETH_CARD_TEXT(card, 2, "delrxip");
130 else if (tmp_addr->type == QETH_IP_TYPE_VIPA)
131 QETH_CARD_TEXT(card, 2, "delvipa");
132 else
133 QETH_CARD_TEXT(card, 2, "delip");
134
135 if (tmp_addr->proto == QETH_PROT_IPV4)
136 QETH_CARD_HEX(card, 4, &tmp_addr->u.a4.addr, 4);
137 else {
138 QETH_CARD_HEX(card, 4, &tmp_addr->u.a6.addr, 8);
139 QETH_CARD_HEX(card, 4, ((char *)&tmp_addr->u.a6.addr) + 8, 8);
140 }
141
142 addr = qeth_l3_find_addr_by_ip(card, tmp_addr);
143 if (!addr || !qeth_l3_addr_match_all(addr, tmp_addr))
144 return -ENOENT;
145
146 addr->ref_counter--;
147 if (addr->type == QETH_IP_TYPE_NORMAL && addr->ref_counter > 0)
148 return rc;
149
150 if (qeth_card_hw_is_reachable(card))
151 rc = qeth_l3_deregister_addr_entry(card, addr);
152
153 hash_del(&addr->hnode);
154 kfree(addr);
155
156 return rc;
157 }
158
qeth_l3_add_ip(struct qeth_card * card,struct qeth_ipaddr * tmp_addr)159 static int qeth_l3_add_ip(struct qeth_card *card, struct qeth_ipaddr *tmp_addr)
160 {
161 int rc = 0;
162 struct qeth_ipaddr *addr;
163 char buf[INET6_ADDRSTRLEN];
164
165 if (tmp_addr->type == QETH_IP_TYPE_RXIP)
166 QETH_CARD_TEXT(card, 2, "addrxip");
167 else if (tmp_addr->type == QETH_IP_TYPE_VIPA)
168 QETH_CARD_TEXT(card, 2, "addvipa");
169 else
170 QETH_CARD_TEXT(card, 2, "addip");
171
172 if (tmp_addr->proto == QETH_PROT_IPV4)
173 QETH_CARD_HEX(card, 4, &tmp_addr->u.a4.addr, 4);
174 else {
175 QETH_CARD_HEX(card, 4, &tmp_addr->u.a6.addr, 8);
176 QETH_CARD_HEX(card, 4, ((char *)&tmp_addr->u.a6.addr) + 8, 8);
177 }
178
179 addr = qeth_l3_find_addr_by_ip(card, tmp_addr);
180 if (addr) {
181 if (tmp_addr->type != QETH_IP_TYPE_NORMAL)
182 return -EADDRINUSE;
183 if (qeth_l3_addr_match_all(addr, tmp_addr)) {
184 addr->ref_counter++;
185 return 0;
186 }
187 qeth_l3_ipaddr_to_string(tmp_addr->proto, (u8 *)&tmp_addr->u,
188 buf);
189 dev_warn(&card->gdev->dev,
190 "Registering IP address %s failed\n", buf);
191 return -EADDRINUSE;
192 } else {
193 addr = kmemdup(tmp_addr, sizeof(*tmp_addr), GFP_KERNEL);
194 if (!addr)
195 return -ENOMEM;
196
197 if (qeth_l3_is_addr_covered_by_ipato(card, addr)) {
198 QETH_CARD_TEXT(card, 2, "tkovaddr");
199 addr->ipato = 1;
200 }
201 hash_add(card->ip_htable, &addr->hnode,
202 qeth_l3_ipaddr_hash(addr));
203
204 if (!qeth_card_hw_is_reachable(card)) {
205 addr->disp_flag = QETH_DISP_ADDR_ADD;
206 return 0;
207 }
208
209 rc = qeth_l3_register_addr_entry(card, addr);
210
211 if (!rc || rc == -EADDRINUSE || rc == -ENETDOWN) {
212 addr->disp_flag = QETH_DISP_ADDR_DO_NOTHING;
213 } else {
214 hash_del(&addr->hnode);
215 kfree(addr);
216 }
217 }
218 return rc;
219 }
220
qeth_l3_modify_ip(struct qeth_card * card,struct qeth_ipaddr * addr,bool add)221 static int qeth_l3_modify_ip(struct qeth_card *card, struct qeth_ipaddr *addr,
222 bool add)
223 {
224 int rc;
225
226 mutex_lock(&card->ip_lock);
227 rc = add ? qeth_l3_add_ip(card, addr) : qeth_l3_delete_ip(card, addr);
228 mutex_unlock(&card->ip_lock);
229
230 return rc;
231 }
232
qeth_l3_drain_rx_mode_cache(struct qeth_card * card)233 static void qeth_l3_drain_rx_mode_cache(struct qeth_card *card)
234 {
235 struct qeth_ipaddr *addr;
236 struct hlist_node *tmp;
237 int i;
238
239 hash_for_each_safe(card->rx_mode_addrs, i, tmp, addr, hnode) {
240 hash_del(&addr->hnode);
241 kfree(addr);
242 }
243 }
244
qeth_l3_clear_ip_htable(struct qeth_card * card,int recover)245 static void qeth_l3_clear_ip_htable(struct qeth_card *card, int recover)
246 {
247 struct qeth_ipaddr *addr;
248 struct hlist_node *tmp;
249 int i;
250
251 QETH_CARD_TEXT(card, 4, "clearip");
252
253 mutex_lock(&card->ip_lock);
254
255 hash_for_each_safe(card->ip_htable, i, tmp, addr, hnode) {
256 if (!recover) {
257 hash_del(&addr->hnode);
258 kfree(addr);
259 } else {
260 /* prepare for recovery */
261 addr->disp_flag = QETH_DISP_ADDR_ADD;
262 }
263 }
264
265 mutex_unlock(&card->ip_lock);
266 }
267
qeth_l3_recover_ip(struct qeth_card * card)268 static void qeth_l3_recover_ip(struct qeth_card *card)
269 {
270 struct qeth_ipaddr *addr;
271 struct hlist_node *tmp;
272 int i;
273 int rc;
274
275 QETH_CARD_TEXT(card, 4, "recovrip");
276
277 mutex_lock(&card->ip_lock);
278
279 hash_for_each_safe(card->ip_htable, i, tmp, addr, hnode) {
280 if (addr->disp_flag == QETH_DISP_ADDR_ADD) {
281 rc = qeth_l3_register_addr_entry(card, addr);
282
283 if (!rc || rc == -EADDRINUSE || rc == -ENETDOWN) {
284 /* keep it in the records */
285 addr->disp_flag = QETH_DISP_ADDR_DO_NOTHING;
286 } else {
287 /* bad address */
288 hash_del(&addr->hnode);
289 kfree(addr);
290 }
291 }
292 }
293
294 mutex_unlock(&card->ip_lock);
295 }
296
qeth_l3_setdelip_cb(struct qeth_card * card,struct qeth_reply * reply,unsigned long data)297 static int qeth_l3_setdelip_cb(struct qeth_card *card, struct qeth_reply *reply,
298 unsigned long data)
299 {
300 struct qeth_ipa_cmd *cmd = (struct qeth_ipa_cmd *) data;
301
302 switch (cmd->hdr.return_code) {
303 case IPA_RC_SUCCESS:
304 return 0;
305 case IPA_RC_DUPLICATE_IP_ADDRESS:
306 return -EADDRINUSE;
307 case IPA_RC_MC_ADDR_NOT_FOUND:
308 return -ENOENT;
309 case IPA_RC_LAN_OFFLINE:
310 return -ENETDOWN;
311 default:
312 return -EIO;
313 }
314 }
315
qeth_l3_send_setdelmc(struct qeth_card * card,struct qeth_ipaddr * addr,enum qeth_ipa_cmds ipacmd)316 static int qeth_l3_send_setdelmc(struct qeth_card *card,
317 struct qeth_ipaddr *addr,
318 enum qeth_ipa_cmds ipacmd)
319 {
320 struct qeth_cmd_buffer *iob;
321 struct qeth_ipa_cmd *cmd;
322
323 QETH_CARD_TEXT(card, 4, "setdelmc");
324
325 iob = qeth_ipa_alloc_cmd(card, ipacmd, addr->proto,
326 IPA_DATA_SIZEOF(setdelipm));
327 if (!iob)
328 return -ENOMEM;
329 cmd = __ipa_cmd(iob);
330 if (addr->proto == QETH_PROT_IPV6) {
331 cmd->data.setdelipm.ip = addr->u.a6.addr;
332 ipv6_eth_mc_map(&addr->u.a6.addr, cmd->data.setdelipm.mac);
333 } else {
334 cmd->data.setdelipm.ip.s6_addr32[3] = addr->u.a4.addr;
335 ip_eth_mc_map(addr->u.a4.addr, cmd->data.setdelipm.mac);
336 }
337
338 return qeth_send_ipa_cmd(card, iob, qeth_l3_setdelip_cb, NULL);
339 }
340
qeth_l3_set_ipv6_prefix(struct in6_addr * prefix,unsigned int len)341 static void qeth_l3_set_ipv6_prefix(struct in6_addr *prefix, unsigned int len)
342 {
343 unsigned int i = 0;
344
345 while (len && i < 4) {
346 int mask_len = min_t(int, len, 32);
347
348 prefix->s6_addr32[i] = inet_make_mask(mask_len);
349 len -= mask_len;
350 i++;
351 }
352 }
353
qeth_l3_get_setdelip_flags(struct qeth_ipaddr * addr,bool set)354 static u32 qeth_l3_get_setdelip_flags(struct qeth_ipaddr *addr, bool set)
355 {
356 switch (addr->type) {
357 case QETH_IP_TYPE_RXIP:
358 return (set) ? QETH_IPA_SETIP_TAKEOVER_FLAG : 0;
359 case QETH_IP_TYPE_VIPA:
360 return (set) ? QETH_IPA_SETIP_VIPA_FLAG :
361 QETH_IPA_DELIP_VIPA_FLAG;
362 default:
363 return (set && addr->ipato) ? QETH_IPA_SETIP_TAKEOVER_FLAG : 0;
364 }
365 }
366
qeth_l3_send_setdelip(struct qeth_card * card,struct qeth_ipaddr * addr,enum qeth_ipa_cmds ipacmd)367 static int qeth_l3_send_setdelip(struct qeth_card *card,
368 struct qeth_ipaddr *addr,
369 enum qeth_ipa_cmds ipacmd)
370 {
371 struct qeth_cmd_buffer *iob;
372 struct qeth_ipa_cmd *cmd;
373 u32 flags;
374
375 QETH_CARD_TEXT(card, 4, "setdelip");
376
377 iob = qeth_ipa_alloc_cmd(card, ipacmd, addr->proto,
378 IPA_DATA_SIZEOF(setdelip6));
379 if (!iob)
380 return -ENOMEM;
381 cmd = __ipa_cmd(iob);
382
383 flags = qeth_l3_get_setdelip_flags(addr, ipacmd == IPA_CMD_SETIP);
384 QETH_CARD_TEXT_(card, 4, "flags%02X", flags);
385
386 if (addr->proto == QETH_PROT_IPV6) {
387 cmd->data.setdelip6.addr = addr->u.a6.addr;
388 qeth_l3_set_ipv6_prefix(&cmd->data.setdelip6.prefix,
389 addr->u.a6.pfxlen);
390 cmd->data.setdelip6.flags = flags;
391 } else {
392 cmd->data.setdelip4.addr = addr->u.a4.addr;
393 cmd->data.setdelip4.mask = addr->u.a4.mask;
394 cmd->data.setdelip4.flags = flags;
395 }
396
397 return qeth_send_ipa_cmd(card, iob, qeth_l3_setdelip_cb, NULL);
398 }
399
qeth_l3_send_setrouting(struct qeth_card * card,enum qeth_routing_types type,enum qeth_prot_versions prot)400 static int qeth_l3_send_setrouting(struct qeth_card *card,
401 enum qeth_routing_types type, enum qeth_prot_versions prot)
402 {
403 int rc;
404 struct qeth_ipa_cmd *cmd;
405 struct qeth_cmd_buffer *iob;
406
407 QETH_CARD_TEXT(card, 4, "setroutg");
408 iob = qeth_ipa_alloc_cmd(card, IPA_CMD_SETRTG, prot,
409 IPA_DATA_SIZEOF(setrtg));
410 if (!iob)
411 return -ENOMEM;
412 cmd = __ipa_cmd(iob);
413 cmd->data.setrtg.type = (type);
414 rc = qeth_send_ipa_cmd(card, iob, NULL, NULL);
415
416 return rc;
417 }
418
qeth_l3_correct_routing_type(struct qeth_card * card,enum qeth_routing_types * type,enum qeth_prot_versions prot)419 static int qeth_l3_correct_routing_type(struct qeth_card *card,
420 enum qeth_routing_types *type, enum qeth_prot_versions prot)
421 {
422 if (IS_IQD(card)) {
423 switch (*type) {
424 case NO_ROUTER:
425 case PRIMARY_CONNECTOR:
426 case SECONDARY_CONNECTOR:
427 case MULTICAST_ROUTER:
428 return 0;
429 default:
430 goto out_inval;
431 }
432 } else {
433 switch (*type) {
434 case NO_ROUTER:
435 case PRIMARY_ROUTER:
436 case SECONDARY_ROUTER:
437 return 0;
438 case MULTICAST_ROUTER:
439 if (qeth_is_ipafunc_supported(card, prot,
440 IPA_OSA_MC_ROUTER))
441 return 0;
442 goto out_inval;
443 default:
444 goto out_inval;
445 }
446 }
447 out_inval:
448 *type = NO_ROUTER;
449 return -EINVAL;
450 }
451
qeth_l3_setrouting_v4(struct qeth_card * card)452 int qeth_l3_setrouting_v4(struct qeth_card *card)
453 {
454 int rc;
455
456 QETH_CARD_TEXT(card, 3, "setrtg4");
457
458 rc = qeth_l3_correct_routing_type(card, &card->options.route4.type,
459 QETH_PROT_IPV4);
460 if (rc)
461 return rc;
462
463 rc = qeth_l3_send_setrouting(card, card->options.route4.type,
464 QETH_PROT_IPV4);
465 if (rc) {
466 card->options.route4.type = NO_ROUTER;
467 QETH_DBF_MESSAGE(2, "Error (%#06x) while setting routing type on device %x. Type set to 'no router'.\n",
468 rc, CARD_DEVID(card));
469 }
470 return rc;
471 }
472
qeth_l3_setrouting_v6(struct qeth_card * card)473 int qeth_l3_setrouting_v6(struct qeth_card *card)
474 {
475 int rc = 0;
476
477 QETH_CARD_TEXT(card, 3, "setrtg6");
478
479 if (!qeth_is_supported(card, IPA_IPV6))
480 return 0;
481 rc = qeth_l3_correct_routing_type(card, &card->options.route6.type,
482 QETH_PROT_IPV6);
483 if (rc)
484 return rc;
485
486 rc = qeth_l3_send_setrouting(card, card->options.route6.type,
487 QETH_PROT_IPV6);
488 if (rc) {
489 card->options.route6.type = NO_ROUTER;
490 QETH_DBF_MESSAGE(2, "Error (%#06x) while setting routing type on device %x. Type set to 'no router'.\n",
491 rc, CARD_DEVID(card));
492 }
493 return rc;
494 }
495
496 /*
497 * IP address takeover related functions
498 */
499
500 /*
501 * qeth_l3_update_ipato() - Update 'takeover' property, for all NORMAL IPs.
502 *
503 * Caller must hold ip_lock.
504 */
qeth_l3_update_ipato(struct qeth_card * card)505 void qeth_l3_update_ipato(struct qeth_card *card)
506 {
507 struct qeth_ipaddr *addr;
508 unsigned int i;
509
510 hash_for_each(card->ip_htable, i, addr, hnode) {
511 if (addr->type != QETH_IP_TYPE_NORMAL)
512 continue;
513 addr->ipato = qeth_l3_is_addr_covered_by_ipato(card, addr);
514 }
515 }
516
qeth_l3_clear_ipato_list(struct qeth_card * card)517 static void qeth_l3_clear_ipato_list(struct qeth_card *card)
518 {
519 struct qeth_ipato_entry *ipatoe, *tmp;
520
521 mutex_lock(&card->ip_lock);
522
523 list_for_each_entry_safe(ipatoe, tmp, &card->ipato.entries, entry) {
524 list_del(&ipatoe->entry);
525 kfree(ipatoe);
526 }
527
528 qeth_l3_update_ipato(card);
529 mutex_unlock(&card->ip_lock);
530 }
531
qeth_l3_add_ipato_entry(struct qeth_card * card,struct qeth_ipato_entry * new)532 int qeth_l3_add_ipato_entry(struct qeth_card *card,
533 struct qeth_ipato_entry *new)
534 {
535 struct qeth_ipato_entry *ipatoe;
536 int rc = 0;
537
538 QETH_CARD_TEXT(card, 2, "addipato");
539
540 mutex_lock(&card->ip_lock);
541
542 list_for_each_entry(ipatoe, &card->ipato.entries, entry) {
543 if (ipatoe->proto != new->proto)
544 continue;
545 if (!memcmp(ipatoe->addr, new->addr,
546 (ipatoe->proto == QETH_PROT_IPV4) ? 4 : 16) &&
547 (ipatoe->mask_bits == new->mask_bits)) {
548 rc = -EEXIST;
549 break;
550 }
551 }
552
553 if (!rc) {
554 list_add_tail(&new->entry, &card->ipato.entries);
555 qeth_l3_update_ipato(card);
556 }
557
558 mutex_unlock(&card->ip_lock);
559
560 return rc;
561 }
562
qeth_l3_del_ipato_entry(struct qeth_card * card,enum qeth_prot_versions proto,u8 * addr,unsigned int mask_bits)563 int qeth_l3_del_ipato_entry(struct qeth_card *card,
564 enum qeth_prot_versions proto, u8 *addr,
565 unsigned int mask_bits)
566 {
567 struct qeth_ipato_entry *ipatoe, *tmp;
568 int rc = -ENOENT;
569
570 QETH_CARD_TEXT(card, 2, "delipato");
571
572 mutex_lock(&card->ip_lock);
573
574 list_for_each_entry_safe(ipatoe, tmp, &card->ipato.entries, entry) {
575 if (ipatoe->proto != proto)
576 continue;
577 if (!memcmp(ipatoe->addr, addr,
578 (proto == QETH_PROT_IPV4) ? 4 : 16) &&
579 (ipatoe->mask_bits == mask_bits)) {
580 list_del(&ipatoe->entry);
581 qeth_l3_update_ipato(card);
582 kfree(ipatoe);
583 rc = 0;
584 }
585 }
586
587 mutex_unlock(&card->ip_lock);
588
589 return rc;
590 }
591
qeth_l3_modify_rxip_vipa(struct qeth_card * card,bool add,const u8 * ip,enum qeth_ip_types type,enum qeth_prot_versions proto)592 int qeth_l3_modify_rxip_vipa(struct qeth_card *card, bool add, const u8 *ip,
593 enum qeth_ip_types type,
594 enum qeth_prot_versions proto)
595 {
596 struct qeth_ipaddr addr;
597
598 qeth_l3_init_ipaddr(&addr, type, proto);
599 if (proto == QETH_PROT_IPV4)
600 memcpy(&addr.u.a4.addr, ip, 4);
601 else
602 memcpy(&addr.u.a6.addr, ip, 16);
603
604 return qeth_l3_modify_ip(card, &addr, add);
605 }
606
qeth_l3_modify_hsuid(struct qeth_card * card,bool add)607 int qeth_l3_modify_hsuid(struct qeth_card *card, bool add)
608 {
609 struct qeth_ipaddr addr;
610 unsigned int i;
611
612 qeth_l3_init_ipaddr(&addr, QETH_IP_TYPE_NORMAL, QETH_PROT_IPV6);
613 addr.u.a6.addr.s6_addr[0] = 0xfe;
614 addr.u.a6.addr.s6_addr[1] = 0x80;
615 for (i = 0; i < 8; i++)
616 addr.u.a6.addr.s6_addr[8+i] = card->options.hsuid[i];
617
618 return qeth_l3_modify_ip(card, &addr, add);
619 }
620
qeth_l3_register_addr_entry(struct qeth_card * card,struct qeth_ipaddr * addr)621 static int qeth_l3_register_addr_entry(struct qeth_card *card,
622 struct qeth_ipaddr *addr)
623 {
624 char buf[50];
625 int rc = 0;
626 int cnt = 3;
627
628 if (card->options.sniffer)
629 return 0;
630
631 if (addr->proto == QETH_PROT_IPV4) {
632 QETH_CARD_TEXT(card, 2, "setaddr4");
633 QETH_CARD_HEX(card, 3, &addr->u.a4.addr, sizeof(int));
634 } else if (addr->proto == QETH_PROT_IPV6) {
635 QETH_CARD_TEXT(card, 2, "setaddr6");
636 QETH_CARD_HEX(card, 3, &addr->u.a6.addr, 8);
637 QETH_CARD_HEX(card, 3, ((char *)&addr->u.a6.addr) + 8, 8);
638 } else {
639 QETH_CARD_TEXT(card, 2, "setaddr?");
640 QETH_CARD_HEX(card, 3, addr, sizeof(struct qeth_ipaddr));
641 }
642 do {
643 if (addr->is_multicast)
644 rc = qeth_l3_send_setdelmc(card, addr, IPA_CMD_SETIPM);
645 else
646 rc = qeth_l3_send_setdelip(card, addr, IPA_CMD_SETIP);
647 if (rc)
648 QETH_CARD_TEXT(card, 2, "failed");
649 } while ((--cnt > 0) && rc);
650 if (rc) {
651 QETH_CARD_TEXT(card, 2, "FAILED");
652 qeth_l3_ipaddr_to_string(addr->proto, (u8 *)&addr->u, buf);
653 dev_warn(&card->gdev->dev,
654 "Registering IP address %s failed\n", buf);
655 }
656 return rc;
657 }
658
qeth_l3_deregister_addr_entry(struct qeth_card * card,struct qeth_ipaddr * addr)659 static int qeth_l3_deregister_addr_entry(struct qeth_card *card,
660 struct qeth_ipaddr *addr)
661 {
662 int rc = 0;
663
664 if (card->options.sniffer)
665 return 0;
666
667 if (addr->proto == QETH_PROT_IPV4) {
668 QETH_CARD_TEXT(card, 2, "deladdr4");
669 QETH_CARD_HEX(card, 3, &addr->u.a4.addr, sizeof(int));
670 } else if (addr->proto == QETH_PROT_IPV6) {
671 QETH_CARD_TEXT(card, 2, "deladdr6");
672 QETH_CARD_HEX(card, 3, &addr->u.a6.addr, 8);
673 QETH_CARD_HEX(card, 3, ((char *)&addr->u.a6.addr) + 8, 8);
674 } else {
675 QETH_CARD_TEXT(card, 2, "deladdr?");
676 QETH_CARD_HEX(card, 3, addr, sizeof(struct qeth_ipaddr));
677 }
678 if (addr->is_multicast)
679 rc = qeth_l3_send_setdelmc(card, addr, IPA_CMD_DELIPM);
680 else
681 rc = qeth_l3_send_setdelip(card, addr, IPA_CMD_DELIP);
682 if (rc)
683 QETH_CARD_TEXT(card, 2, "failed");
684
685 return rc;
686 }
687
qeth_l3_setadapter_parms(struct qeth_card * card)688 static int qeth_l3_setadapter_parms(struct qeth_card *card)
689 {
690 int rc = 0;
691
692 QETH_CARD_TEXT(card, 2, "setadprm");
693
694 if (qeth_adp_supported(card, IPA_SETADP_ALTER_MAC_ADDRESS)) {
695 rc = qeth_setadpparms_change_macaddr(card);
696 if (rc)
697 dev_warn(&card->gdev->dev, "Reading the adapter MAC"
698 " address failed\n");
699 }
700
701 return rc;
702 }
703
qeth_l3_start_ipa_arp_processing(struct qeth_card * card)704 static int qeth_l3_start_ipa_arp_processing(struct qeth_card *card)
705 {
706 int rc;
707
708 QETH_CARD_TEXT(card, 3, "ipaarp");
709
710 if (!qeth_is_supported(card, IPA_ARP_PROCESSING)) {
711 dev_info(&card->gdev->dev,
712 "ARP processing not supported on %s!\n",
713 netdev_name(card->dev));
714 return 0;
715 }
716 rc = qeth_send_simple_setassparms(card, IPA_ARP_PROCESSING,
717 IPA_CMD_ASS_START, NULL);
718 if (rc) {
719 dev_warn(&card->gdev->dev,
720 "Starting ARP processing support for %s failed\n",
721 netdev_name(card->dev));
722 }
723 return rc;
724 }
725
qeth_l3_start_ipa_source_mac(struct qeth_card * card)726 static int qeth_l3_start_ipa_source_mac(struct qeth_card *card)
727 {
728 int rc;
729
730 QETH_CARD_TEXT(card, 3, "stsrcmac");
731
732 if (!qeth_is_supported(card, IPA_SOURCE_MAC)) {
733 dev_info(&card->gdev->dev,
734 "Inbound source MAC-address not supported on %s\n",
735 netdev_name(card->dev));
736 return -EOPNOTSUPP;
737 }
738
739 rc = qeth_send_simple_setassparms(card, IPA_SOURCE_MAC,
740 IPA_CMD_ASS_START, NULL);
741 if (rc)
742 dev_warn(&card->gdev->dev,
743 "Starting source MAC-address support for %s failed\n",
744 netdev_name(card->dev));
745 return rc;
746 }
747
qeth_l3_start_ipa_vlan(struct qeth_card * card)748 static int qeth_l3_start_ipa_vlan(struct qeth_card *card)
749 {
750 int rc = 0;
751
752 QETH_CARD_TEXT(card, 3, "strtvlan");
753
754 if (!qeth_is_supported(card, IPA_FULL_VLAN)) {
755 dev_info(&card->gdev->dev,
756 "VLAN not supported on %s\n", netdev_name(card->dev));
757 return -EOPNOTSUPP;
758 }
759
760 rc = qeth_send_simple_setassparms(card, IPA_VLAN_PRIO,
761 IPA_CMD_ASS_START, NULL);
762 if (rc) {
763 dev_warn(&card->gdev->dev,
764 "Starting VLAN support for %s failed\n",
765 netdev_name(card->dev));
766 } else {
767 dev_info(&card->gdev->dev, "VLAN enabled\n");
768 }
769 return rc;
770 }
771
qeth_l3_start_ipa_multicast(struct qeth_card * card)772 static int qeth_l3_start_ipa_multicast(struct qeth_card *card)
773 {
774 int rc;
775
776 QETH_CARD_TEXT(card, 3, "stmcast");
777
778 if (!qeth_is_supported(card, IPA_MULTICASTING)) {
779 dev_info(&card->gdev->dev,
780 "Multicast not supported on %s\n",
781 netdev_name(card->dev));
782 return -EOPNOTSUPP;
783 }
784
785 rc = qeth_send_simple_setassparms(card, IPA_MULTICASTING,
786 IPA_CMD_ASS_START, NULL);
787 if (rc) {
788 dev_warn(&card->gdev->dev,
789 "Starting multicast support for %s failed\n",
790 netdev_name(card->dev));
791 } else {
792 dev_info(&card->gdev->dev, "Multicast enabled\n");
793 card->dev->flags |= IFF_MULTICAST;
794 }
795 return rc;
796 }
797
qeth_l3_softsetup_ipv6(struct qeth_card * card)798 static int qeth_l3_softsetup_ipv6(struct qeth_card *card)
799 {
800 u32 ipv6_data = 3;
801 int rc;
802
803 QETH_CARD_TEXT(card, 3, "softipv6");
804
805 if (IS_IQD(card))
806 goto out;
807
808 rc = qeth_send_simple_setassparms(card, IPA_IPV6, IPA_CMD_ASS_START,
809 &ipv6_data);
810 if (rc) {
811 dev_err(&card->gdev->dev,
812 "Activating IPv6 support for %s failed\n",
813 netdev_name(card->dev));
814 return rc;
815 }
816 rc = qeth_send_simple_setassparms_v6(card, IPA_IPV6, IPA_CMD_ASS_START,
817 NULL);
818 if (rc) {
819 dev_err(&card->gdev->dev,
820 "Activating IPv6 support for %s failed\n",
821 netdev_name(card->dev));
822 return rc;
823 }
824 rc = qeth_send_simple_setassparms_v6(card, IPA_PASSTHRU,
825 IPA_CMD_ASS_START, NULL);
826 if (rc) {
827 dev_warn(&card->gdev->dev,
828 "Enabling the passthrough mode for %s failed\n",
829 netdev_name(card->dev));
830 return rc;
831 }
832 out:
833 dev_info(&card->gdev->dev, "IPV6 enabled\n");
834 return 0;
835 }
836
qeth_l3_start_ipa_ipv6(struct qeth_card * card)837 static int qeth_l3_start_ipa_ipv6(struct qeth_card *card)
838 {
839 QETH_CARD_TEXT(card, 3, "strtipv6");
840
841 if (!qeth_is_supported(card, IPA_IPV6)) {
842 dev_info(&card->gdev->dev,
843 "IPv6 not supported on %s\n", netdev_name(card->dev));
844 return 0;
845 }
846 return qeth_l3_softsetup_ipv6(card);
847 }
848
qeth_l3_start_ipa_broadcast(struct qeth_card * card)849 static int qeth_l3_start_ipa_broadcast(struct qeth_card *card)
850 {
851 u32 filter_data = 1;
852 int rc;
853
854 QETH_CARD_TEXT(card, 3, "stbrdcst");
855 card->info.broadcast_capable = 0;
856 if (!qeth_is_supported(card, IPA_FILTERING)) {
857 dev_info(&card->gdev->dev,
858 "Broadcast not supported on %s\n",
859 netdev_name(card->dev));
860 rc = -EOPNOTSUPP;
861 goto out;
862 }
863 rc = qeth_send_simple_setassparms(card, IPA_FILTERING,
864 IPA_CMD_ASS_START, NULL);
865 if (rc) {
866 dev_warn(&card->gdev->dev,
867 "Enabling broadcast filtering for %s failed\n",
868 netdev_name(card->dev));
869 goto out;
870 }
871
872 rc = qeth_send_simple_setassparms(card, IPA_FILTERING,
873 IPA_CMD_ASS_CONFIGURE, &filter_data);
874 if (rc) {
875 dev_warn(&card->gdev->dev,
876 "Setting up broadcast filtering for %s failed\n",
877 netdev_name(card->dev));
878 goto out;
879 }
880 card->info.broadcast_capable = QETH_BROADCAST_WITH_ECHO;
881 dev_info(&card->gdev->dev, "Broadcast enabled\n");
882 rc = qeth_send_simple_setassparms(card, IPA_FILTERING,
883 IPA_CMD_ASS_ENABLE, &filter_data);
884 if (rc) {
885 dev_warn(&card->gdev->dev,
886 "Setting up broadcast echo filtering for %s failed\n",
887 netdev_name(card->dev));
888 goto out;
889 }
890 card->info.broadcast_capable = QETH_BROADCAST_WITHOUT_ECHO;
891 out:
892 if (card->info.broadcast_capable)
893 card->dev->flags |= IFF_BROADCAST;
894 else
895 card->dev->flags &= ~IFF_BROADCAST;
896 return rc;
897 }
898
qeth_l3_start_ipassists(struct qeth_card * card)899 static void qeth_l3_start_ipassists(struct qeth_card *card)
900 {
901 QETH_CARD_TEXT(card, 3, "strtipas");
902
903 qeth_l3_start_ipa_arp_processing(card); /* go on*/
904 qeth_l3_start_ipa_source_mac(card); /* go on*/
905 qeth_l3_start_ipa_vlan(card); /* go on*/
906 qeth_l3_start_ipa_multicast(card); /* go on*/
907 qeth_l3_start_ipa_ipv6(card); /* go on*/
908 qeth_l3_start_ipa_broadcast(card); /* go on*/
909 }
910
qeth_l3_iqd_read_initial_mac_cb(struct qeth_card * card,struct qeth_reply * reply,unsigned long data)911 static int qeth_l3_iqd_read_initial_mac_cb(struct qeth_card *card,
912 struct qeth_reply *reply, unsigned long data)
913 {
914 struct qeth_ipa_cmd *cmd = (struct qeth_ipa_cmd *) data;
915
916 if (cmd->hdr.return_code)
917 return -EIO;
918 if (!is_valid_ether_addr(cmd->data.create_destroy_addr.mac_addr))
919 return -EADDRNOTAVAIL;
920
921 eth_hw_addr_set(card->dev, cmd->data.create_destroy_addr.mac_addr);
922 return 0;
923 }
924
qeth_l3_iqd_read_initial_mac(struct qeth_card * card)925 static int qeth_l3_iqd_read_initial_mac(struct qeth_card *card)
926 {
927 int rc = 0;
928 struct qeth_cmd_buffer *iob;
929
930 QETH_CARD_TEXT(card, 2, "hsrmac");
931
932 iob = qeth_ipa_alloc_cmd(card, IPA_CMD_CREATE_ADDR, QETH_PROT_IPV6,
933 IPA_DATA_SIZEOF(create_destroy_addr));
934 if (!iob)
935 return -ENOMEM;
936
937 rc = qeth_send_ipa_cmd(card, iob, qeth_l3_iqd_read_initial_mac_cb,
938 NULL);
939 return rc;
940 }
941
qeth_l3_get_unique_id_cb(struct qeth_card * card,struct qeth_reply * reply,unsigned long data)942 static int qeth_l3_get_unique_id_cb(struct qeth_card *card,
943 struct qeth_reply *reply, unsigned long data)
944 {
945 struct qeth_ipa_cmd *cmd = (struct qeth_ipa_cmd *) data;
946 u16 *uid = reply->param;
947
948 if (cmd->hdr.return_code == 0) {
949 *uid = cmd->data.create_destroy_addr.uid;
950 return 0;
951 }
952
953 dev_warn(&card->gdev->dev, "The network adapter failed to generate a unique ID\n");
954 return -EIO;
955 }
956
qeth_l3_get_unique_id(struct qeth_card * card,u16 uid)957 static u16 qeth_l3_get_unique_id(struct qeth_card *card, u16 uid)
958 {
959 struct qeth_cmd_buffer *iob;
960
961 QETH_CARD_TEXT(card, 2, "guniqeid");
962
963 if (!qeth_is_supported(card, IPA_IPV6))
964 goto out;
965
966 iob = qeth_ipa_alloc_cmd(card, IPA_CMD_CREATE_ADDR, QETH_PROT_IPV6,
967 IPA_DATA_SIZEOF(create_destroy_addr));
968 if (!iob)
969 goto out;
970
971 __ipa_cmd(iob)->data.create_destroy_addr.uid = uid;
972 qeth_send_ipa_cmd(card, iob, qeth_l3_get_unique_id_cb, &uid);
973
974 out:
975 return uid;
976 }
977
978 static int
qeth_diags_trace_cb(struct qeth_card * card,struct qeth_reply * reply,unsigned long data)979 qeth_diags_trace_cb(struct qeth_card *card, struct qeth_reply *reply,
980 unsigned long data)
981 {
982 struct qeth_ipa_cmd *cmd;
983 __u16 rc;
984
985 QETH_CARD_TEXT(card, 2, "diastrcb");
986
987 cmd = (struct qeth_ipa_cmd *)data;
988 rc = cmd->hdr.return_code;
989 if (rc)
990 QETH_CARD_TEXT_(card, 2, "dxter%x", rc);
991 switch (cmd->data.diagass.action) {
992 case QETH_DIAGS_CMD_TRACE_QUERY:
993 break;
994 case QETH_DIAGS_CMD_TRACE_DISABLE:
995 switch (rc) {
996 case 0:
997 case IPA_RC_INVALID_SUBCMD:
998 card->info.promisc_mode = SET_PROMISC_MODE_OFF;
999 dev_info(&card->gdev->dev, "The HiperSockets network "
1000 "traffic analyzer is deactivated\n");
1001 break;
1002 default:
1003 break;
1004 }
1005 break;
1006 case QETH_DIAGS_CMD_TRACE_ENABLE:
1007 switch (rc) {
1008 case 0:
1009 card->info.promisc_mode = SET_PROMISC_MODE_ON;
1010 dev_info(&card->gdev->dev, "The HiperSockets network "
1011 "traffic analyzer is activated\n");
1012 break;
1013 case IPA_RC_HARDWARE_AUTH_ERROR:
1014 dev_warn(&card->gdev->dev, "The device is not "
1015 "authorized to run as a HiperSockets network "
1016 "traffic analyzer\n");
1017 break;
1018 case IPA_RC_TRACE_ALREADY_ACTIVE:
1019 dev_warn(&card->gdev->dev, "A HiperSockets "
1020 "network traffic analyzer is already "
1021 "active in the HiperSockets LAN\n");
1022 break;
1023 default:
1024 break;
1025 }
1026 break;
1027 default:
1028 QETH_DBF_MESSAGE(2, "Unknown sniffer action (%#06x) on device %x\n",
1029 cmd->data.diagass.action, CARD_DEVID(card));
1030 }
1031
1032 return rc ? -EIO : 0;
1033 }
1034
1035 static int
qeth_diags_trace(struct qeth_card * card,enum qeth_diags_trace_cmds diags_cmd)1036 qeth_diags_trace(struct qeth_card *card, enum qeth_diags_trace_cmds diags_cmd)
1037 {
1038 struct qeth_cmd_buffer *iob;
1039 struct qeth_ipa_cmd *cmd;
1040
1041 QETH_CARD_TEXT(card, 2, "diagtrac");
1042
1043 iob = qeth_get_diag_cmd(card, QETH_DIAGS_CMD_TRACE, 0);
1044 if (!iob)
1045 return -ENOMEM;
1046 cmd = __ipa_cmd(iob);
1047 cmd->data.diagass.type = QETH_DIAGS_TYPE_HIPERSOCKET;
1048 cmd->data.diagass.action = diags_cmd;
1049 return qeth_send_ipa_cmd(card, iob, qeth_diags_trace_cb, NULL);
1050 }
1051
qeth_l3_add_mcast_rtnl(struct net_device * dev,int vid,void * arg)1052 static int qeth_l3_add_mcast_rtnl(struct net_device *dev, int vid, void *arg)
1053 {
1054 struct qeth_card *card = arg;
1055 struct inet6_dev *in6_dev;
1056 struct in_device *in4_dev;
1057 struct qeth_ipaddr *ipm;
1058 struct qeth_ipaddr tmp;
1059 struct ip_mc_list *im4;
1060 struct ifmcaddr6 *im6;
1061
1062 QETH_CARD_TEXT(card, 4, "addmc");
1063
1064 if (!dev || !(dev->flags & IFF_UP))
1065 goto out;
1066
1067 in4_dev = __in_dev_get_rtnl(dev);
1068 if (!in4_dev)
1069 goto walk_ipv6;
1070
1071 qeth_l3_init_ipaddr(&tmp, QETH_IP_TYPE_NORMAL, QETH_PROT_IPV4);
1072 tmp.disp_flag = QETH_DISP_ADDR_ADD;
1073 tmp.is_multicast = 1;
1074
1075 for (im4 = rtnl_dereference(in4_dev->mc_list); im4 != NULL;
1076 im4 = rtnl_dereference(im4->next_rcu)) {
1077 tmp.u.a4.addr = im4->multiaddr;
1078
1079 ipm = qeth_l3_find_addr_by_ip(card, &tmp);
1080 if (ipm) {
1081 /* for mcast, by-IP match means full match */
1082 ipm->disp_flag = QETH_DISP_ADDR_DO_NOTHING;
1083 continue;
1084 }
1085
1086 ipm = kmemdup(&tmp, sizeof(tmp), GFP_KERNEL);
1087 if (!ipm)
1088 continue;
1089
1090 hash_add(card->rx_mode_addrs, &ipm->hnode,
1091 qeth_l3_ipaddr_hash(ipm));
1092 }
1093
1094 walk_ipv6:
1095 if (!qeth_is_supported(card, IPA_IPV6))
1096 goto out;
1097
1098 in6_dev = __in6_dev_get(dev);
1099 if (!in6_dev)
1100 goto out;
1101
1102 qeth_l3_init_ipaddr(&tmp, QETH_IP_TYPE_NORMAL, QETH_PROT_IPV6);
1103 tmp.disp_flag = QETH_DISP_ADDR_ADD;
1104 tmp.is_multicast = 1;
1105
1106 for (im6 = rtnl_dereference(in6_dev->mc_list);
1107 im6;
1108 im6 = rtnl_dereference(im6->next)) {
1109 tmp.u.a6.addr = im6->mca_addr;
1110
1111 ipm = qeth_l3_find_addr_by_ip(card, &tmp);
1112 if (ipm) {
1113 /* for mcast, by-IP match means full match */
1114 ipm->disp_flag = QETH_DISP_ADDR_DO_NOTHING;
1115 continue;
1116 }
1117
1118 ipm = kmemdup(&tmp, sizeof(tmp), GFP_ATOMIC);
1119 if (!ipm)
1120 continue;
1121
1122 hash_add(card->rx_mode_addrs, &ipm->hnode,
1123 qeth_l3_ipaddr_hash(ipm));
1124
1125 }
1126
1127 out:
1128 return 0;
1129 }
1130
qeth_l3_set_promisc_mode(struct qeth_card * card)1131 static void qeth_l3_set_promisc_mode(struct qeth_card *card)
1132 {
1133 bool enable = card->dev->flags & IFF_PROMISC;
1134
1135 if (card->info.promisc_mode == enable)
1136 return;
1137
1138 if (IS_VM_NIC(card)) { /* Guestlan trace */
1139 if (qeth_adp_supported(card, IPA_SETADP_SET_PROMISC_MODE))
1140 qeth_setadp_promisc_mode(card, enable);
1141 } else if (card->options.sniffer && /* HiperSockets trace */
1142 qeth_adp_supported(card, IPA_SETADP_SET_DIAG_ASSIST)) {
1143 if (enable) {
1144 QETH_CARD_TEXT(card, 3, "+promisc");
1145 qeth_diags_trace(card, QETH_DIAGS_CMD_TRACE_ENABLE);
1146 } else {
1147 QETH_CARD_TEXT(card, 3, "-promisc");
1148 qeth_diags_trace(card, QETH_DIAGS_CMD_TRACE_DISABLE);
1149 }
1150 }
1151 }
1152
qeth_l3_rx_mode_work(struct work_struct * work)1153 static void qeth_l3_rx_mode_work(struct work_struct *work)
1154 {
1155 struct qeth_card *card = container_of(work, struct qeth_card,
1156 rx_mode_work);
1157 struct qeth_ipaddr *addr;
1158 struct hlist_node *tmp;
1159 int i, rc;
1160
1161 QETH_CARD_TEXT(card, 3, "setmulti");
1162
1163 if (!card->options.sniffer) {
1164 rtnl_lock();
1165 qeth_l3_add_mcast_rtnl(card->dev, 0, card);
1166 if (qeth_is_supported(card, IPA_FULL_VLAN))
1167 vlan_for_each(card->dev, qeth_l3_add_mcast_rtnl, card);
1168 rtnl_unlock();
1169
1170 hash_for_each_safe(card->rx_mode_addrs, i, tmp, addr, hnode) {
1171 switch (addr->disp_flag) {
1172 case QETH_DISP_ADDR_DELETE:
1173 rc = qeth_l3_deregister_addr_entry(card, addr);
1174 if (!rc || rc == -ENOENT) {
1175 hash_del(&addr->hnode);
1176 kfree(addr);
1177 }
1178 break;
1179 case QETH_DISP_ADDR_ADD:
1180 rc = qeth_l3_register_addr_entry(card, addr);
1181 if (rc && rc != -ENETDOWN) {
1182 hash_del(&addr->hnode);
1183 kfree(addr);
1184 break;
1185 }
1186 fallthrough;
1187 default:
1188 /* for next call to set_rx_mode(): */
1189 addr->disp_flag = QETH_DISP_ADDR_DELETE;
1190 }
1191 }
1192 }
1193
1194 qeth_l3_set_promisc_mode(card);
1195 }
1196
qeth_l3_arp_makerc(u16 rc)1197 static int qeth_l3_arp_makerc(u16 rc)
1198 {
1199 switch (rc) {
1200 case IPA_RC_SUCCESS:
1201 return 0;
1202 case QETH_IPA_ARP_RC_NOTSUPP:
1203 case QETH_IPA_ARP_RC_Q_NOTSUPP:
1204 return -EOPNOTSUPP;
1205 case QETH_IPA_ARP_RC_OUT_OF_RANGE:
1206 return -EINVAL;
1207 case QETH_IPA_ARP_RC_Q_NO_DATA:
1208 return -ENOENT;
1209 default:
1210 return -EIO;
1211 }
1212 }
1213
qeth_l3_arp_cmd_cb(struct qeth_card * card,struct qeth_reply * reply,unsigned long data)1214 static int qeth_l3_arp_cmd_cb(struct qeth_card *card, struct qeth_reply *reply,
1215 unsigned long data)
1216 {
1217 struct qeth_ipa_cmd *cmd = (struct qeth_ipa_cmd *) data;
1218
1219 qeth_setassparms_cb(card, reply, data);
1220 return qeth_l3_arp_makerc(cmd->hdr.return_code);
1221 }
1222
qeth_l3_arp_set_no_entries(struct qeth_card * card,int no_entries)1223 static int qeth_l3_arp_set_no_entries(struct qeth_card *card, int no_entries)
1224 {
1225 struct qeth_cmd_buffer *iob;
1226 int rc;
1227
1228 QETH_CARD_TEXT(card, 3, "arpstnoe");
1229
1230 /*
1231 * currently GuestLAN only supports the ARP assist function
1232 * IPA_CMD_ASS_ARP_QUERY_INFO, but not IPA_CMD_ASS_ARP_SET_NO_ENTRIES;
1233 * thus we say EOPNOTSUPP for this ARP function
1234 */
1235 if (IS_VM_NIC(card))
1236 return -EOPNOTSUPP;
1237 if (!qeth_is_supported(card, IPA_ARP_PROCESSING)) {
1238 return -EOPNOTSUPP;
1239 }
1240
1241 iob = qeth_get_setassparms_cmd(card, IPA_ARP_PROCESSING,
1242 IPA_CMD_ASS_ARP_SET_NO_ENTRIES,
1243 SETASS_DATA_SIZEOF(flags_32bit),
1244 QETH_PROT_IPV4);
1245 if (!iob)
1246 return -ENOMEM;
1247
1248 __ipa_cmd(iob)->data.setassparms.data.flags_32bit = (u32) no_entries;
1249 rc = qeth_send_ipa_cmd(card, iob, qeth_l3_arp_cmd_cb, NULL);
1250 if (rc)
1251 QETH_DBF_MESSAGE(2, "Could not set number of ARP entries on device %x: %#x\n",
1252 CARD_DEVID(card), rc);
1253 return rc;
1254 }
1255
get_arp_entry_size(struct qeth_card * card,struct qeth_arp_query_data * qdata,struct qeth_arp_entrytype * type,__u8 strip_entries)1256 static __u32 get_arp_entry_size(struct qeth_card *card,
1257 struct qeth_arp_query_data *qdata,
1258 struct qeth_arp_entrytype *type, __u8 strip_entries)
1259 {
1260 __u32 rc;
1261 __u8 is_hsi;
1262
1263 is_hsi = qdata->reply_bits == 5;
1264 if (type->ip == QETHARP_IP_ADDR_V4) {
1265 QETH_CARD_TEXT(card, 4, "arpev4");
1266 if (strip_entries) {
1267 rc = is_hsi ? sizeof(struct qeth_arp_qi_entry5_short) :
1268 sizeof(struct qeth_arp_qi_entry7_short);
1269 } else {
1270 rc = is_hsi ? sizeof(struct qeth_arp_qi_entry5) :
1271 sizeof(struct qeth_arp_qi_entry7);
1272 }
1273 } else if (type->ip == QETHARP_IP_ADDR_V6) {
1274 QETH_CARD_TEXT(card, 4, "arpev6");
1275 if (strip_entries) {
1276 rc = is_hsi ?
1277 sizeof(struct qeth_arp_qi_entry5_short_ipv6) :
1278 sizeof(struct qeth_arp_qi_entry7_short_ipv6);
1279 } else {
1280 rc = is_hsi ?
1281 sizeof(struct qeth_arp_qi_entry5_ipv6) :
1282 sizeof(struct qeth_arp_qi_entry7_ipv6);
1283 }
1284 } else {
1285 QETH_CARD_TEXT(card, 4, "arpinv");
1286 rc = 0;
1287 }
1288
1289 return rc;
1290 }
1291
arpentry_matches_prot(struct qeth_arp_entrytype * type,__u16 prot)1292 static int arpentry_matches_prot(struct qeth_arp_entrytype *type, __u16 prot)
1293 {
1294 return (type->ip == QETHARP_IP_ADDR_V4 && prot == QETH_PROT_IPV4) ||
1295 (type->ip == QETHARP_IP_ADDR_V6 && prot == QETH_PROT_IPV6);
1296 }
1297
qeth_l3_arp_query_cb(struct qeth_card * card,struct qeth_reply * reply,unsigned long data)1298 static int qeth_l3_arp_query_cb(struct qeth_card *card,
1299 struct qeth_reply *reply, unsigned long data)
1300 {
1301 struct qeth_ipa_cmd *cmd;
1302 struct qeth_arp_query_data *qdata;
1303 struct qeth_arp_query_info *qinfo;
1304 int e;
1305 int entrybytes_done;
1306 int stripped_bytes;
1307 __u8 do_strip_entries;
1308
1309 QETH_CARD_TEXT(card, 3, "arpquecb");
1310
1311 qinfo = (struct qeth_arp_query_info *) reply->param;
1312 cmd = (struct qeth_ipa_cmd *) data;
1313 QETH_CARD_TEXT_(card, 4, "%i", cmd->hdr.prot_version);
1314 if (cmd->hdr.return_code) {
1315 QETH_CARD_TEXT(card, 4, "arpcberr");
1316 QETH_CARD_TEXT_(card, 4, "%i", cmd->hdr.return_code);
1317 return qeth_l3_arp_makerc(cmd->hdr.return_code);
1318 }
1319 if (cmd->data.setassparms.hdr.return_code) {
1320 cmd->hdr.return_code = cmd->data.setassparms.hdr.return_code;
1321 QETH_CARD_TEXT(card, 4, "setaperr");
1322 QETH_CARD_TEXT_(card, 4, "%i", cmd->hdr.return_code);
1323 return qeth_l3_arp_makerc(cmd->hdr.return_code);
1324 }
1325 qdata = &cmd->data.setassparms.data.query_arp;
1326 QETH_CARD_TEXT_(card, 4, "anoen%i", qdata->no_entries);
1327
1328 do_strip_entries = (qinfo->mask_bits & QETH_QARP_STRIP_ENTRIES) > 0;
1329 stripped_bytes = do_strip_entries ? QETH_QARP_MEDIASPECIFIC_BYTES : 0;
1330 entrybytes_done = 0;
1331 for (e = 0; e < qdata->no_entries; ++e) {
1332 char *cur_entry;
1333 __u32 esize;
1334 struct qeth_arp_entrytype *etype;
1335
1336 cur_entry = &qdata->data + entrybytes_done;
1337 etype = &((struct qeth_arp_qi_entry5 *) cur_entry)->type;
1338 if (!arpentry_matches_prot(etype, cmd->hdr.prot_version)) {
1339 QETH_CARD_TEXT(card, 4, "pmis");
1340 QETH_CARD_TEXT_(card, 4, "%i", etype->ip);
1341 break;
1342 }
1343 esize = get_arp_entry_size(card, qdata, etype,
1344 do_strip_entries);
1345 QETH_CARD_TEXT_(card, 5, "esz%i", esize);
1346 if (!esize)
1347 break;
1348
1349 if ((qinfo->udata_len - qinfo->udata_offset) < esize) {
1350 QETH_CARD_TEXT_(card, 4, "qaer3%i", -ENOSPC);
1351 memset(qinfo->udata, 0, 4);
1352 return -ENOSPC;
1353 }
1354
1355 memcpy(qinfo->udata + qinfo->udata_offset,
1356 &qdata->data + entrybytes_done + stripped_bytes,
1357 esize);
1358 entrybytes_done += esize + stripped_bytes;
1359 qinfo->udata_offset += esize;
1360 ++qinfo->no_entries;
1361 }
1362 /* check if all replies received ... */
1363 if (cmd->data.setassparms.hdr.seq_no <
1364 cmd->data.setassparms.hdr.number_of_replies)
1365 return 1;
1366 QETH_CARD_TEXT_(card, 4, "nove%i", qinfo->no_entries);
1367 memcpy(qinfo->udata, &qinfo->no_entries, 4);
1368 /* keep STRIP_ENTRIES flag so the user program can distinguish
1369 * stripped entries from normal ones */
1370 if (qinfo->mask_bits & QETH_QARP_STRIP_ENTRIES)
1371 qdata->reply_bits |= QETH_QARP_STRIP_ENTRIES;
1372 memcpy(qinfo->udata + QETH_QARP_MASK_OFFSET, &qdata->reply_bits, 2);
1373 QETH_CARD_TEXT_(card, 4, "rc%i", 0);
1374 return 0;
1375 }
1376
qeth_l3_query_arp_cache_info(struct qeth_card * card,enum qeth_prot_versions prot,struct qeth_arp_query_info * qinfo)1377 static int qeth_l3_query_arp_cache_info(struct qeth_card *card,
1378 enum qeth_prot_versions prot,
1379 struct qeth_arp_query_info *qinfo)
1380 {
1381 struct qeth_cmd_buffer *iob;
1382 struct qeth_ipa_cmd *cmd;
1383 int rc;
1384
1385 QETH_CARD_TEXT_(card, 3, "qarpipv%i", prot);
1386
1387 iob = qeth_get_setassparms_cmd(card, IPA_ARP_PROCESSING,
1388 IPA_CMD_ASS_ARP_QUERY_INFO,
1389 SETASS_DATA_SIZEOF(query_arp), prot);
1390 if (!iob)
1391 return -ENOMEM;
1392 cmd = __ipa_cmd(iob);
1393 cmd->data.setassparms.data.query_arp.request_bits = 0x000F;
1394 rc = qeth_send_ipa_cmd(card, iob, qeth_l3_arp_query_cb, qinfo);
1395 if (rc)
1396 QETH_DBF_MESSAGE(2, "Error while querying ARP cache on device %x: %#x\n",
1397 CARD_DEVID(card), rc);
1398 return rc;
1399 }
1400
qeth_l3_arp_query(struct qeth_card * card,char __user * udata)1401 static int qeth_l3_arp_query(struct qeth_card *card, char __user *udata)
1402 {
1403 struct qeth_arp_query_info qinfo = {0, };
1404 int rc;
1405
1406 QETH_CARD_TEXT(card, 3, "arpquery");
1407
1408 if (!qeth_is_supported(card,/*IPA_QUERY_ARP_ADDR_INFO*/
1409 IPA_ARP_PROCESSING)) {
1410 QETH_CARD_TEXT(card, 3, "arpqnsup");
1411 rc = -EOPNOTSUPP;
1412 goto out;
1413 }
1414 /* get size of userspace buffer and mask_bits -> 6 bytes */
1415 if (copy_from_user(&qinfo, udata, 6)) {
1416 rc = -EFAULT;
1417 goto out;
1418 }
1419 qinfo.udata = kzalloc(qinfo.udata_len, GFP_KERNEL);
1420 if (!qinfo.udata) {
1421 rc = -ENOMEM;
1422 goto out;
1423 }
1424 qinfo.udata_offset = QETH_QARP_ENTRIES_OFFSET;
1425 rc = qeth_l3_query_arp_cache_info(card, QETH_PROT_IPV4, &qinfo);
1426 if (rc) {
1427 if (copy_to_user(udata, qinfo.udata, 4))
1428 rc = -EFAULT;
1429 goto free_and_out;
1430 }
1431 if (qinfo.mask_bits & QETH_QARP_WITH_IPV6) {
1432 /* fails in case of GuestLAN QDIO mode */
1433 qeth_l3_query_arp_cache_info(card, QETH_PROT_IPV6, &qinfo);
1434 }
1435 if (copy_to_user(udata, qinfo.udata, qinfo.udata_len)) {
1436 QETH_CARD_TEXT(card, 4, "qactf");
1437 rc = -EFAULT;
1438 goto free_and_out;
1439 }
1440 QETH_CARD_TEXT(card, 4, "qacts");
1441
1442 free_and_out:
1443 kfree(qinfo.udata);
1444 out:
1445 return rc;
1446 }
1447
qeth_l3_arp_modify_entry(struct qeth_card * card,struct qeth_arp_cache_entry * entry,enum qeth_arp_process_subcmds arp_cmd)1448 static int qeth_l3_arp_modify_entry(struct qeth_card *card,
1449 struct qeth_arp_cache_entry *entry,
1450 enum qeth_arp_process_subcmds arp_cmd)
1451 {
1452 struct qeth_arp_cache_entry *cmd_entry;
1453 struct qeth_cmd_buffer *iob;
1454 int rc;
1455
1456 if (arp_cmd == IPA_CMD_ASS_ARP_ADD_ENTRY)
1457 QETH_CARD_TEXT(card, 3, "arpadd");
1458 else
1459 QETH_CARD_TEXT(card, 3, "arpdel");
1460
1461 /*
1462 * currently GuestLAN only supports the ARP assist function
1463 * IPA_CMD_ASS_ARP_QUERY_INFO, but not IPA_CMD_ASS_ARP_ADD_ENTRY;
1464 * thus we say EOPNOTSUPP for this ARP function
1465 */
1466 if (IS_VM_NIC(card))
1467 return -EOPNOTSUPP;
1468 if (!qeth_is_supported(card, IPA_ARP_PROCESSING)) {
1469 return -EOPNOTSUPP;
1470 }
1471
1472 iob = qeth_get_setassparms_cmd(card, IPA_ARP_PROCESSING, arp_cmd,
1473 SETASS_DATA_SIZEOF(arp_entry),
1474 QETH_PROT_IPV4);
1475 if (!iob)
1476 return -ENOMEM;
1477
1478 cmd_entry = &__ipa_cmd(iob)->data.setassparms.data.arp_entry;
1479 ether_addr_copy(cmd_entry->macaddr, entry->macaddr);
1480 memcpy(cmd_entry->ipaddr, entry->ipaddr, 4);
1481 rc = qeth_send_ipa_cmd(card, iob, qeth_l3_arp_cmd_cb, NULL);
1482 if (rc)
1483 QETH_DBF_MESSAGE(2, "Could not modify (cmd: %#x) ARP entry on device %x: %#x\n",
1484 arp_cmd, CARD_DEVID(card), rc);
1485 return rc;
1486 }
1487
qeth_l3_arp_flush_cache(struct qeth_card * card)1488 static int qeth_l3_arp_flush_cache(struct qeth_card *card)
1489 {
1490 struct qeth_cmd_buffer *iob;
1491 int rc;
1492
1493 QETH_CARD_TEXT(card, 3, "arpflush");
1494
1495 /*
1496 * currently GuestLAN only supports the ARP assist function
1497 * IPA_CMD_ASS_ARP_QUERY_INFO, but not IPA_CMD_ASS_ARP_FLUSH_CACHE;
1498 * thus we say EOPNOTSUPP for this ARP function
1499 */
1500 if (IS_VM_NIC(card) || IS_IQD(card))
1501 return -EOPNOTSUPP;
1502 if (!qeth_is_supported(card, IPA_ARP_PROCESSING)) {
1503 return -EOPNOTSUPP;
1504 }
1505
1506 iob = qeth_get_setassparms_cmd(card, IPA_ARP_PROCESSING,
1507 IPA_CMD_ASS_ARP_FLUSH_CACHE, 0,
1508 QETH_PROT_IPV4);
1509 if (!iob)
1510 return -ENOMEM;
1511
1512 rc = qeth_send_ipa_cmd(card, iob, qeth_l3_arp_cmd_cb, NULL);
1513 if (rc)
1514 QETH_DBF_MESSAGE(2, "Could not flush ARP cache on device %x: %#x\n",
1515 CARD_DEVID(card), rc);
1516 return rc;
1517 }
1518
qeth_l3_ndo_siocdevprivate(struct net_device * dev,struct ifreq * rq,void __user * data,int cmd)1519 static int qeth_l3_ndo_siocdevprivate(struct net_device *dev, struct ifreq *rq,
1520 void __user *data, int cmd)
1521 {
1522 struct qeth_card *card = dev->ml_priv;
1523 struct qeth_arp_cache_entry arp_entry;
1524 enum qeth_arp_process_subcmds arp_cmd;
1525 int rc = 0;
1526
1527 switch (cmd) {
1528 case SIOC_QETH_ARP_SET_NO_ENTRIES:
1529 if (!capable(CAP_NET_ADMIN)) {
1530 rc = -EPERM;
1531 break;
1532 }
1533 rc = qeth_l3_arp_set_no_entries(card, rq->ifr_ifru.ifru_ivalue);
1534 break;
1535 case SIOC_QETH_ARP_QUERY_INFO:
1536 if (!capable(CAP_NET_ADMIN)) {
1537 rc = -EPERM;
1538 break;
1539 }
1540 rc = qeth_l3_arp_query(card, data);
1541 break;
1542 case SIOC_QETH_ARP_ADD_ENTRY:
1543 case SIOC_QETH_ARP_REMOVE_ENTRY:
1544 if (!capable(CAP_NET_ADMIN))
1545 return -EPERM;
1546 if (copy_from_user(&arp_entry, data, sizeof(arp_entry)))
1547 return -EFAULT;
1548
1549 arp_cmd = (cmd == SIOC_QETH_ARP_ADD_ENTRY) ?
1550 IPA_CMD_ASS_ARP_ADD_ENTRY :
1551 IPA_CMD_ASS_ARP_REMOVE_ENTRY;
1552 return qeth_l3_arp_modify_entry(card, &arp_entry, arp_cmd);
1553 case SIOC_QETH_ARP_FLUSH_CACHE:
1554 if (!capable(CAP_NET_ADMIN)) {
1555 rc = -EPERM;
1556 break;
1557 }
1558 rc = qeth_l3_arp_flush_cache(card);
1559 break;
1560 default:
1561 rc = qeth_siocdevprivate(dev, rq, data, cmd);
1562 }
1563 return rc;
1564 }
1565
qeth_l3_get_cast_type_rcu(struct sk_buff * skb,struct dst_entry * dst,__be16 proto)1566 static int qeth_l3_get_cast_type_rcu(struct sk_buff *skb, struct dst_entry *dst,
1567 __be16 proto)
1568 {
1569 struct neighbour *n = NULL;
1570
1571 if (dst)
1572 n = dst_neigh_lookup_skb(dst, skb);
1573
1574 if (n) {
1575 int cast_type = n->type;
1576
1577 neigh_release(n);
1578 if ((cast_type == RTN_BROADCAST) ||
1579 (cast_type == RTN_MULTICAST) ||
1580 (cast_type == RTN_ANYCAST))
1581 return cast_type;
1582 return RTN_UNICAST;
1583 }
1584
1585 /* no neighbour (eg AF_PACKET), fall back to target's IP address ... */
1586 switch (proto) {
1587 case htons(ETH_P_IP):
1588 if (ipv4_is_lbcast(ip_hdr(skb)->daddr))
1589 return RTN_BROADCAST;
1590 return ipv4_is_multicast(ip_hdr(skb)->daddr) ?
1591 RTN_MULTICAST : RTN_UNICAST;
1592 case htons(ETH_P_IPV6):
1593 return ipv6_addr_is_multicast(&ipv6_hdr(skb)->daddr) ?
1594 RTN_MULTICAST : RTN_UNICAST;
1595 case htons(ETH_P_AF_IUCV):
1596 return RTN_UNICAST;
1597 default:
1598 /* OSA only: ... and MAC address */
1599 return qeth_get_ether_cast_type(skb);
1600 }
1601 }
1602
qeth_l3_get_cast_type(struct sk_buff * skb,__be16 proto)1603 static int qeth_l3_get_cast_type(struct sk_buff *skb, __be16 proto)
1604 {
1605 struct dst_entry *dst;
1606 int cast_type;
1607
1608 rcu_read_lock();
1609 dst = qeth_dst_check_rcu(skb, proto);
1610 cast_type = qeth_l3_get_cast_type_rcu(skb, dst, proto);
1611 rcu_read_unlock();
1612
1613 return cast_type;
1614 }
1615
qeth_l3_cast_type_to_flag(int cast_type)1616 static u8 qeth_l3_cast_type_to_flag(int cast_type)
1617 {
1618 if (cast_type == RTN_MULTICAST)
1619 return QETH_CAST_MULTICAST;
1620 if (cast_type == RTN_ANYCAST)
1621 return QETH_CAST_ANYCAST;
1622 if (cast_type == RTN_BROADCAST)
1623 return QETH_CAST_BROADCAST;
1624 return QETH_CAST_UNICAST;
1625 }
1626
qeth_l3_fill_header(struct qeth_qdio_out_q * queue,struct qeth_hdr * hdr,struct sk_buff * skb,__be16 proto,unsigned int data_len)1627 static void qeth_l3_fill_header(struct qeth_qdio_out_q *queue,
1628 struct qeth_hdr *hdr, struct sk_buff *skb,
1629 __be16 proto, unsigned int data_len)
1630 {
1631 struct qeth_hdr_layer3 *l3_hdr = &hdr->hdr.l3;
1632 struct vlan_ethhdr *veth = vlan_eth_hdr(skb);
1633 struct qeth_card *card = queue->card;
1634 struct dst_entry *dst;
1635 int cast_type;
1636
1637 hdr->hdr.l3.length = data_len;
1638
1639 if (skb_is_gso(skb)) {
1640 hdr->hdr.l3.id = QETH_HEADER_TYPE_L3_TSO;
1641 } else {
1642 hdr->hdr.l3.id = QETH_HEADER_TYPE_LAYER3;
1643
1644 if (skb->ip_summed == CHECKSUM_PARTIAL) {
1645 qeth_tx_csum(skb, &hdr->hdr.l3.ext_flags, proto);
1646 /* some HW requires combined L3+L4 csum offload: */
1647 if (proto == htons(ETH_P_IP))
1648 hdr->hdr.l3.ext_flags |= QETH_HDR_EXT_CSUM_HDR_REQ;
1649 }
1650 }
1651
1652 if (proto == htons(ETH_P_IP) || IS_IQD(card)) {
1653 /* NETIF_F_HW_VLAN_CTAG_TX */
1654 if (skb_vlan_tag_present(skb)) {
1655 hdr->hdr.l3.ext_flags |= QETH_HDR_EXT_VLAN_FRAME;
1656 hdr->hdr.l3.vlan_id = skb_vlan_tag_get(skb);
1657 }
1658 } else if (veth->h_vlan_proto == htons(ETH_P_8021Q)) {
1659 hdr->hdr.l3.ext_flags |= QETH_HDR_EXT_INCLUDE_VLAN_TAG;
1660 hdr->hdr.l3.vlan_id = ntohs(veth->h_vlan_TCI);
1661 }
1662
1663 rcu_read_lock();
1664 dst = qeth_dst_check_rcu(skb, proto);
1665
1666 if (IS_IQD(card) && skb_get_queue_mapping(skb) != QETH_IQD_MCAST_TXQ)
1667 cast_type = RTN_UNICAST;
1668 else
1669 cast_type = qeth_l3_get_cast_type_rcu(skb, dst, proto);
1670 l3_hdr->flags |= qeth_l3_cast_type_to_flag(cast_type);
1671
1672 switch (proto) {
1673 case htons(ETH_P_IP):
1674 l3_hdr->next_hop.addr.s6_addr32[3] =
1675 qeth_next_hop_v4_rcu(skb, dst);
1676 break;
1677 case htons(ETH_P_IPV6):
1678 l3_hdr->next_hop.addr = *qeth_next_hop_v6_rcu(skb, dst);
1679
1680 hdr->hdr.l3.flags |= QETH_HDR_IPV6;
1681 if (!IS_IQD(card))
1682 hdr->hdr.l3.flags |= QETH_HDR_PASSTHRU;
1683 break;
1684 case htons(ETH_P_AF_IUCV):
1685 l3_hdr->next_hop.addr.s6_addr16[0] = htons(0xfe80);
1686 memcpy(&l3_hdr->next_hop.addr.s6_addr32[2],
1687 iucv_trans_hdr(skb)->destUserID, 8);
1688 l3_hdr->flags |= QETH_HDR_IPV6;
1689 break;
1690 default:
1691 /* OSA only: */
1692 l3_hdr->flags |= QETH_HDR_PASSTHRU;
1693 }
1694 rcu_read_unlock();
1695 }
1696
qeth_l3_fixup_headers(struct sk_buff * skb)1697 static void qeth_l3_fixup_headers(struct sk_buff *skb)
1698 {
1699 struct iphdr *iph = ip_hdr(skb);
1700
1701 /* this is safe, IPv6 traffic takes a different path */
1702 if (skb->ip_summed == CHECKSUM_PARTIAL)
1703 iph->check = 0;
1704 if (skb_is_gso(skb)) {
1705 iph->tot_len = 0;
1706 tcp_hdr(skb)->check = ~tcp_v4_check(0, iph->saddr,
1707 iph->daddr, 0);
1708 }
1709 }
1710
qeth_l3_xmit(struct qeth_card * card,struct sk_buff * skb,struct qeth_qdio_out_q * queue,__be16 proto)1711 static int qeth_l3_xmit(struct qeth_card *card, struct sk_buff *skb,
1712 struct qeth_qdio_out_q *queue, __be16 proto)
1713 {
1714 unsigned int hw_hdr_len;
1715 int rc;
1716
1717 /* re-use the L2 header area for the HW header: */
1718 hw_hdr_len = skb_is_gso(skb) ? sizeof(struct qeth_hdr_tso) :
1719 sizeof(struct qeth_hdr);
1720 rc = skb_cow_head(skb, hw_hdr_len - ETH_HLEN);
1721 if (rc)
1722 return rc;
1723 skb_pull(skb, ETH_HLEN);
1724
1725 qeth_l3_fixup_headers(skb);
1726 return qeth_xmit(card, skb, queue, proto, qeth_l3_fill_header);
1727 }
1728
qeth_l3_hard_start_xmit(struct sk_buff * skb,struct net_device * dev)1729 static netdev_tx_t qeth_l3_hard_start_xmit(struct sk_buff *skb,
1730 struct net_device *dev)
1731 {
1732 struct qeth_card *card = dev->ml_priv;
1733 __be16 proto = vlan_get_protocol(skb);
1734 u16 txq = skb_get_queue_mapping(skb);
1735 struct qeth_qdio_out_q *queue;
1736 int rc;
1737
1738 if (!skb_is_gso(skb))
1739 qdisc_skb_cb(skb)->pkt_len = skb->len;
1740 if (IS_IQD(card)) {
1741 queue = card->qdio.out_qs[qeth_iqd_translate_txq(dev, txq)];
1742
1743 if (card->options.sniffer)
1744 goto tx_drop;
1745
1746 switch (proto) {
1747 case htons(ETH_P_AF_IUCV):
1748 if (card->options.cq != QETH_CQ_ENABLED)
1749 goto tx_drop;
1750 break;
1751 case htons(ETH_P_IP):
1752 case htons(ETH_P_IPV6):
1753 if (card->options.cq == QETH_CQ_ENABLED)
1754 goto tx_drop;
1755 break;
1756 default:
1757 goto tx_drop;
1758 }
1759 } else {
1760 queue = card->qdio.out_qs[txq];
1761 }
1762
1763 if (!(dev->flags & IFF_BROADCAST) &&
1764 qeth_l3_get_cast_type(skb, proto) == RTN_BROADCAST)
1765 goto tx_drop;
1766
1767 if (proto == htons(ETH_P_IP) || IS_IQD(card))
1768 rc = qeth_l3_xmit(card, skb, queue, proto);
1769 else
1770 rc = qeth_xmit(card, skb, queue, proto, qeth_l3_fill_header);
1771
1772 if (!rc)
1773 return NETDEV_TX_OK;
1774
1775 tx_drop:
1776 QETH_TXQ_STAT_INC(queue, tx_dropped);
1777 kfree_skb(skb);
1778 return NETDEV_TX_OK;
1779 }
1780
qeth_l3_set_rx_mode(struct net_device * dev)1781 static void qeth_l3_set_rx_mode(struct net_device *dev)
1782 {
1783 struct qeth_card *card = dev->ml_priv;
1784
1785 schedule_work(&card->rx_mode_work);
1786 }
1787
1788 /*
1789 * we need NOARP for IPv4 but we want neighbor solicitation for IPv6. Setting
1790 * NOARP on the netdevice is no option because it also turns off neighbor
1791 * solicitation. For IPv4 we install a neighbor_setup function. We don't want
1792 * arp resolution but we want the hard header (packet socket will work
1793 * e.g. tcpdump)
1794 */
qeth_l3_neigh_setup_noarp(struct neighbour * n)1795 static int qeth_l3_neigh_setup_noarp(struct neighbour *n)
1796 {
1797 n->nud_state = NUD_NOARP;
1798 memcpy(n->ha, "FAKELL", 6);
1799 n->output = n->ops->connected_output;
1800 return 0;
1801 }
1802
1803 static int
qeth_l3_neigh_setup(struct net_device * dev,struct neigh_parms * np)1804 qeth_l3_neigh_setup(struct net_device *dev, struct neigh_parms *np)
1805 {
1806 if (np->tbl->family == AF_INET)
1807 np->neigh_setup = qeth_l3_neigh_setup_noarp;
1808
1809 return 0;
1810 }
1811
qeth_l3_osa_features_check(struct sk_buff * skb,struct net_device * dev,netdev_features_t features)1812 static netdev_features_t qeth_l3_osa_features_check(struct sk_buff *skb,
1813 struct net_device *dev,
1814 netdev_features_t features)
1815 {
1816 if (vlan_get_protocol(skb) != htons(ETH_P_IP))
1817 features &= ~NETIF_F_HW_VLAN_CTAG_TX;
1818 return qeth_features_check(skb, dev, features);
1819 }
1820
qeth_l3_iqd_select_queue(struct net_device * dev,struct sk_buff * skb,struct net_device * sb_dev)1821 static u16 qeth_l3_iqd_select_queue(struct net_device *dev, struct sk_buff *skb,
1822 struct net_device *sb_dev)
1823 {
1824 __be16 proto = vlan_get_protocol(skb);
1825
1826 return qeth_iqd_select_queue(dev, skb,
1827 qeth_l3_get_cast_type(skb, proto), sb_dev);
1828 }
1829
1830 static const struct net_device_ops qeth_l3_netdev_ops = {
1831 .ndo_open = qeth_open,
1832 .ndo_stop = qeth_stop,
1833 .ndo_get_stats64 = qeth_get_stats64,
1834 .ndo_start_xmit = qeth_l3_hard_start_xmit,
1835 .ndo_select_queue = qeth_l3_iqd_select_queue,
1836 .ndo_validate_addr = eth_validate_addr,
1837 .ndo_set_rx_mode = qeth_l3_set_rx_mode,
1838 .ndo_eth_ioctl = qeth_do_ioctl,
1839 .ndo_siocdevprivate = qeth_l3_ndo_siocdevprivate,
1840 .ndo_fix_features = qeth_fix_features,
1841 .ndo_set_features = qeth_set_features,
1842 .ndo_tx_timeout = qeth_tx_timeout,
1843 };
1844
1845 static const struct net_device_ops qeth_l3_osa_netdev_ops = {
1846 .ndo_open = qeth_open,
1847 .ndo_stop = qeth_stop,
1848 .ndo_get_stats64 = qeth_get_stats64,
1849 .ndo_start_xmit = qeth_l3_hard_start_xmit,
1850 .ndo_features_check = qeth_l3_osa_features_check,
1851 .ndo_select_queue = qeth_osa_select_queue,
1852 .ndo_validate_addr = eth_validate_addr,
1853 .ndo_set_rx_mode = qeth_l3_set_rx_mode,
1854 .ndo_eth_ioctl = qeth_do_ioctl,
1855 .ndo_siocdevprivate = qeth_l3_ndo_siocdevprivate,
1856 .ndo_fix_features = qeth_fix_features,
1857 .ndo_set_features = qeth_set_features,
1858 .ndo_tx_timeout = qeth_tx_timeout,
1859 .ndo_neigh_setup = qeth_l3_neigh_setup,
1860 };
1861
qeth_l3_setup_netdev(struct qeth_card * card)1862 static int qeth_l3_setup_netdev(struct qeth_card *card)
1863 {
1864 struct net_device *dev = card->dev;
1865 unsigned int headroom;
1866 int rc;
1867
1868 if (IS_OSD(card) || IS_OSX(card)) {
1869 card->dev->netdev_ops = &qeth_l3_osa_netdev_ops;
1870
1871 /*IPv6 address autoconfiguration stuff*/
1872 dev->dev_id = qeth_l3_get_unique_id(card, dev->dev_id);
1873
1874 if (!IS_VM_NIC(card)) {
1875 card->dev->features |= NETIF_F_SG;
1876 card->dev->hw_features |= NETIF_F_TSO |
1877 NETIF_F_RXCSUM | NETIF_F_IP_CSUM;
1878 card->dev->vlan_features |= NETIF_F_TSO |
1879 NETIF_F_RXCSUM | NETIF_F_IP_CSUM;
1880 }
1881
1882 if (qeth_is_supported6(card, IPA_OUTBOUND_CHECKSUM_V6)) {
1883 card->dev->hw_features |= NETIF_F_IPV6_CSUM;
1884 card->dev->vlan_features |= NETIF_F_IPV6_CSUM;
1885 }
1886 if (qeth_is_supported6(card, IPA_OUTBOUND_TSO)) {
1887 card->dev->hw_features |= NETIF_F_TSO6;
1888 card->dev->vlan_features |= NETIF_F_TSO6;
1889 }
1890
1891 /* allow for de-acceleration of NETIF_F_HW_VLAN_CTAG_TX: */
1892 if (card->dev->hw_features & NETIF_F_TSO6)
1893 headroom = sizeof(struct qeth_hdr_tso) + VLAN_HLEN;
1894 else if (card->dev->hw_features & NETIF_F_TSO)
1895 headroom = sizeof(struct qeth_hdr_tso);
1896 else
1897 headroom = sizeof(struct qeth_hdr) + VLAN_HLEN;
1898 } else if (IS_IQD(card)) {
1899 card->dev->flags |= IFF_NOARP;
1900 card->dev->netdev_ops = &qeth_l3_netdev_ops;
1901 headroom = sizeof(struct qeth_hdr) - ETH_HLEN;
1902
1903 rc = qeth_l3_iqd_read_initial_mac(card);
1904 if (rc)
1905 return rc;
1906 } else
1907 return -ENODEV;
1908
1909 card->dev->needed_headroom = headroom;
1910 card->dev->features |= NETIF_F_HW_VLAN_CTAG_TX |
1911 NETIF_F_HW_VLAN_CTAG_RX;
1912
1913 netif_keep_dst(card->dev);
1914 if (card->dev->hw_features & (NETIF_F_TSO | NETIF_F_TSO6))
1915 netif_set_tso_max_size(card->dev,
1916 PAGE_SIZE * (QETH_MAX_BUFFER_ELEMENTS(card) - 1));
1917
1918 netif_napi_add(card->dev, &card->napi, qeth_poll);
1919 return register_netdev(card->dev);
1920 }
1921
1922 static const struct device_type qeth_l3_devtype = {
1923 .name = "qeth_layer3",
1924 .groups = qeth_l3_attr_groups,
1925 };
1926
qeth_l3_probe_device(struct ccwgroup_device * gdev)1927 static int qeth_l3_probe_device(struct ccwgroup_device *gdev)
1928 {
1929 struct qeth_card *card = dev_get_drvdata(&gdev->dev);
1930 int rc;
1931
1932 hash_init(card->ip_htable);
1933 mutex_init(&card->ip_lock);
1934 card->cmd_wq = alloc_ordered_workqueue("%s_cmd", 0,
1935 dev_name(&gdev->dev));
1936 if (!card->cmd_wq)
1937 return -ENOMEM;
1938
1939 if (gdev->dev.type) {
1940 rc = device_add_groups(&gdev->dev, qeth_l3_attr_groups);
1941 if (rc) {
1942 destroy_workqueue(card->cmd_wq);
1943 return rc;
1944 }
1945 } else {
1946 gdev->dev.type = &qeth_l3_devtype;
1947 }
1948
1949 INIT_WORK(&card->rx_mode_work, qeth_l3_rx_mode_work);
1950 return 0;
1951 }
1952
qeth_l3_remove_device(struct ccwgroup_device * cgdev)1953 static void qeth_l3_remove_device(struct ccwgroup_device *cgdev)
1954 {
1955 struct qeth_card *card = dev_get_drvdata(&cgdev->dev);
1956
1957 if (cgdev->dev.type != &qeth_l3_devtype)
1958 device_remove_groups(&cgdev->dev, qeth_l3_attr_groups);
1959
1960 qeth_set_allowed_threads(card, 0, 1);
1961 wait_event(card->wait_q, qeth_threads_running(card, 0xffffffff) == 0);
1962
1963 if (cgdev->state == CCWGROUP_ONLINE)
1964 qeth_set_offline(card, card->discipline, false);
1965
1966 if (card->dev->reg_state == NETREG_REGISTERED)
1967 unregister_netdev(card->dev);
1968
1969 destroy_workqueue(card->cmd_wq);
1970 qeth_l3_clear_ip_htable(card, 0);
1971 qeth_l3_clear_ipato_list(card);
1972 }
1973
qeth_l3_set_online(struct qeth_card * card,bool carrier_ok)1974 static int qeth_l3_set_online(struct qeth_card *card, bool carrier_ok)
1975 {
1976 struct net_device *dev = card->dev;
1977 int rc = 0;
1978
1979 /* softsetup */
1980 QETH_CARD_TEXT(card, 2, "softsetp");
1981
1982 rc = qeth_l3_setadapter_parms(card);
1983 if (rc)
1984 QETH_CARD_TEXT_(card, 2, "2err%04x", rc);
1985 if (!card->options.sniffer) {
1986 qeth_l3_start_ipassists(card);
1987
1988 rc = qeth_l3_setrouting_v4(card);
1989 if (rc)
1990 QETH_CARD_TEXT_(card, 2, "4err%04x", rc);
1991 rc = qeth_l3_setrouting_v6(card);
1992 if (rc)
1993 QETH_CARD_TEXT_(card, 2, "5err%04x", rc);
1994 }
1995
1996 card->state = CARD_STATE_SOFTSETUP;
1997
1998 qeth_set_allowed_threads(card, 0xffffffff, 0);
1999 qeth_l3_recover_ip(card);
2000
2001 if (dev->reg_state != NETREG_REGISTERED) {
2002 rc = qeth_l3_setup_netdev(card);
2003 if (rc)
2004 goto err_setup;
2005
2006 if (carrier_ok)
2007 netif_carrier_on(dev);
2008 } else {
2009 rtnl_lock();
2010 rc = qeth_set_real_num_tx_queues(card,
2011 qeth_tx_actual_queues(card));
2012 if (rc) {
2013 rtnl_unlock();
2014 goto err_set_queues;
2015 }
2016
2017 if (carrier_ok)
2018 netif_carrier_on(dev);
2019 else
2020 netif_carrier_off(dev);
2021
2022 netif_device_attach(dev);
2023 qeth_enable_hw_features(dev);
2024
2025 if (netif_running(dev)) {
2026 local_bh_disable();
2027 napi_schedule(&card->napi);
2028 /* kick-start the NAPI softirq: */
2029 local_bh_enable();
2030 }
2031 rtnl_unlock();
2032 }
2033 return 0;
2034
2035 err_set_queues:
2036 err_setup:
2037 qeth_set_allowed_threads(card, 0, 1);
2038 card->state = CARD_STATE_DOWN;
2039 qeth_l3_clear_ip_htable(card, 1);
2040 return rc;
2041 }
2042
qeth_l3_set_offline(struct qeth_card * card)2043 static void qeth_l3_set_offline(struct qeth_card *card)
2044 {
2045 qeth_set_allowed_threads(card, 0, 1);
2046 qeth_l3_drain_rx_mode_cache(card);
2047
2048 if (card->options.sniffer &&
2049 (card->info.promisc_mode == SET_PROMISC_MODE_ON))
2050 qeth_diags_trace(card, QETH_DIAGS_CMD_TRACE_DISABLE);
2051
2052 if (card->state == CARD_STATE_SOFTSETUP) {
2053 card->state = CARD_STATE_DOWN;
2054 qeth_l3_clear_ip_htable(card, 1);
2055 }
2056 }
2057
2058 /* Returns zero if the command is successfully "consumed" */
qeth_l3_control_event(struct qeth_card * card,struct qeth_ipa_cmd * cmd)2059 static int qeth_l3_control_event(struct qeth_card *card,
2060 struct qeth_ipa_cmd *cmd)
2061 {
2062 return 1;
2063 }
2064
2065 const struct qeth_discipline qeth_l3_discipline = {
2066 .setup = qeth_l3_probe_device,
2067 .remove = qeth_l3_remove_device,
2068 .set_online = qeth_l3_set_online,
2069 .set_offline = qeth_l3_set_offline,
2070 .control_event_handler = qeth_l3_control_event,
2071 };
2072 EXPORT_SYMBOL_GPL(qeth_l3_discipline);
2073
qeth_l3_handle_ip_event(struct qeth_card * card,struct qeth_ipaddr * addr,unsigned long event)2074 static int qeth_l3_handle_ip_event(struct qeth_card *card,
2075 struct qeth_ipaddr *addr,
2076 unsigned long event)
2077 {
2078 switch (event) {
2079 case NETDEV_UP:
2080 qeth_l3_modify_ip(card, addr, true);
2081 return NOTIFY_OK;
2082 case NETDEV_DOWN:
2083 qeth_l3_modify_ip(card, addr, false);
2084 return NOTIFY_OK;
2085 default:
2086 return NOTIFY_DONE;
2087 }
2088 }
2089
2090 struct qeth_l3_ip_event_work {
2091 struct work_struct work;
2092 struct qeth_card *card;
2093 struct qeth_ipaddr addr;
2094 };
2095
2096 #define to_ip_work(w) container_of((w), struct qeth_l3_ip_event_work, work)
2097
qeth_l3_add_ip_worker(struct work_struct * work)2098 static void qeth_l3_add_ip_worker(struct work_struct *work)
2099 {
2100 struct qeth_l3_ip_event_work *ip_work = to_ip_work(work);
2101
2102 qeth_l3_modify_ip(ip_work->card, &ip_work->addr, true);
2103 kfree(work);
2104 }
2105
qeth_l3_delete_ip_worker(struct work_struct * work)2106 static void qeth_l3_delete_ip_worker(struct work_struct *work)
2107 {
2108 struct qeth_l3_ip_event_work *ip_work = to_ip_work(work);
2109
2110 qeth_l3_modify_ip(ip_work->card, &ip_work->addr, false);
2111 kfree(work);
2112 }
2113
qeth_l3_get_card_from_dev(struct net_device * dev)2114 static struct qeth_card *qeth_l3_get_card_from_dev(struct net_device *dev)
2115 {
2116 if (is_vlan_dev(dev))
2117 dev = vlan_dev_real_dev(dev);
2118 if (dev->netdev_ops == &qeth_l3_osa_netdev_ops ||
2119 dev->netdev_ops == &qeth_l3_netdev_ops)
2120 return (struct qeth_card *) dev->ml_priv;
2121 return NULL;
2122 }
2123
qeth_l3_ip_event(struct notifier_block * this,unsigned long event,void * ptr)2124 static int qeth_l3_ip_event(struct notifier_block *this,
2125 unsigned long event, void *ptr)
2126 {
2127 struct in_ifaddr *ifa = (struct in_ifaddr *)ptr;
2128 struct net_device *dev = ifa->ifa_dev->dev;
2129 struct qeth_ipaddr addr;
2130 struct qeth_card *card;
2131
2132 card = qeth_l3_get_card_from_dev(dev);
2133 if (!card)
2134 return NOTIFY_DONE;
2135 QETH_CARD_TEXT(card, 3, "ipevent");
2136
2137 qeth_l3_init_ipaddr(&addr, QETH_IP_TYPE_NORMAL, QETH_PROT_IPV4);
2138 addr.u.a4.addr = ifa->ifa_address;
2139 addr.u.a4.mask = ifa->ifa_mask;
2140
2141 return qeth_l3_handle_ip_event(card, &addr, event);
2142 }
2143
2144 static struct notifier_block qeth_l3_ip_notifier = {
2145 qeth_l3_ip_event,
2146 NULL,
2147 };
2148
qeth_l3_ip6_event(struct notifier_block * this,unsigned long event,void * ptr)2149 static int qeth_l3_ip6_event(struct notifier_block *this,
2150 unsigned long event, void *ptr)
2151 {
2152 struct inet6_ifaddr *ifa = (struct inet6_ifaddr *)ptr;
2153 struct net_device *dev = ifa->idev->dev;
2154 struct qeth_l3_ip_event_work *ip_work;
2155 struct qeth_card *card;
2156
2157 if (event != NETDEV_UP && event != NETDEV_DOWN)
2158 return NOTIFY_DONE;
2159
2160 card = qeth_l3_get_card_from_dev(dev);
2161 if (!card)
2162 return NOTIFY_DONE;
2163 QETH_CARD_TEXT(card, 3, "ip6event");
2164 if (!qeth_is_supported(card, IPA_IPV6))
2165 return NOTIFY_DONE;
2166
2167 ip_work = kmalloc(sizeof(*ip_work), GFP_ATOMIC);
2168 if (!ip_work)
2169 return NOTIFY_DONE;
2170
2171 if (event == NETDEV_UP)
2172 INIT_WORK(&ip_work->work, qeth_l3_add_ip_worker);
2173 else
2174 INIT_WORK(&ip_work->work, qeth_l3_delete_ip_worker);
2175
2176 ip_work->card = card;
2177 qeth_l3_init_ipaddr(&ip_work->addr, QETH_IP_TYPE_NORMAL,
2178 QETH_PROT_IPV6);
2179 ip_work->addr.u.a6.addr = ifa->addr;
2180 ip_work->addr.u.a6.pfxlen = ifa->prefix_len;
2181
2182 queue_work(card->cmd_wq, &ip_work->work);
2183 return NOTIFY_OK;
2184 }
2185
2186 static struct notifier_block qeth_l3_ip6_notifier = {
2187 qeth_l3_ip6_event,
2188 NULL,
2189 };
2190
qeth_l3_register_notifiers(void)2191 static int qeth_l3_register_notifiers(void)
2192 {
2193 int rc;
2194
2195 QETH_DBF_TEXT(SETUP, 5, "regnotif");
2196 rc = register_inetaddr_notifier(&qeth_l3_ip_notifier);
2197 if (rc)
2198 return rc;
2199 rc = register_inet6addr_notifier(&qeth_l3_ip6_notifier);
2200 if (rc) {
2201 unregister_inetaddr_notifier(&qeth_l3_ip_notifier);
2202 return rc;
2203 }
2204 return 0;
2205 }
2206
qeth_l3_unregister_notifiers(void)2207 static void qeth_l3_unregister_notifiers(void)
2208 {
2209 QETH_DBF_TEXT(SETUP, 5, "unregnot");
2210 WARN_ON(unregister_inetaddr_notifier(&qeth_l3_ip_notifier));
2211 WARN_ON(unregister_inet6addr_notifier(&qeth_l3_ip6_notifier));
2212 }
2213
qeth_l3_init(void)2214 static int __init qeth_l3_init(void)
2215 {
2216 pr_info("register layer 3 discipline\n");
2217 return qeth_l3_register_notifiers();
2218 }
2219
qeth_l3_exit(void)2220 static void __exit qeth_l3_exit(void)
2221 {
2222 qeth_l3_unregister_notifiers();
2223 pr_info("unregister layer 3 discipline\n");
2224 }
2225
2226 module_init(qeth_l3_init);
2227 module_exit(qeth_l3_exit);
2228 MODULE_AUTHOR("Frank Blaschka <frank.blaschka@de.ibm.com>");
2229 MODULE_DESCRIPTION("qeth layer 3 discipline");
2230 MODULE_LICENSE("GPL");
2231