1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21 /*
22 * Copyright 2008 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 */
25
26 #include <sys/param.h>
27 #include <sys/atomic.h>
28 #include <sys/kmem.h>
29 #include <sys/rwlock.h>
30 #include <sys/errno.h>
31 #include <sys/queue.h>
32 #include <inet/common.h>
33 #include <inet/led.h>
34 #include <inet/ip.h>
35 #include <sys/neti.h>
36 #include <sys/zone.h>
37
38 static net_handle_t net_find(const char *protocol, neti_stack_t *ns);
39
40 static net_handle_t
41 net_find(const char *protocol, neti_stack_t *nts)
42 {
43 struct net_data *n;
44
45 ASSERT(protocol != NULL);
46 ASSERT(nts != NULL);
47
48 LIST_FOREACH(n, &nts->nts_netd_head, netd_list) {
49 ASSERT(n->netd_info.netp_name != NULL);
50 /*
51 * If they're trying to find a protocol that is being
52 * shutdown, just ignore it..
53 */
54 if (n->netd_condemned != 0)
55 continue;
56 if (strcmp(n->netd_info.netp_name, protocol) == 0) {
57 break;
58 }
59 }
60
61 return (n);
62 }
63
64 net_handle_t
65 net_protocol_register(netid_t id, const net_protocol_t *info)
66 {
67 struct net_data *n, *new;
68 neti_stack_t *nts;
69
70 ASSERT(info != NULL);
71
72 nts = net_getnetistackbyid(id);
73 if (nts == NULL)
74 return (NULL);
75
76 new = kmem_alloc(sizeof (*new), KM_SLEEP);
77 new->netd_refcnt = 1;
78 new->netd_hooks = NULL;
79 new->netd_info = *info;
80 new->netd_stack = nts;
81 new->netd_condemned = 0;
82
83 mutex_enter(&nts->nts_lock);
84 n = net_find(info->netp_name, nts);
85 if (n != NULL) {
86 mutex_exit(&nts->nts_lock);
87 kmem_free(new, sizeof (*new));
88 return (NULL);
89 }
90
91 if (LIST_EMPTY(&nts->nts_netd_head)) {
92 LIST_INSERT_HEAD(&nts->nts_netd_head, new, netd_list);
93 } else {
94 LIST_INSERT_AFTER(LIST_FIRST(&nts->nts_netd_head),
95 new, netd_list);
96 }
97 mutex_exit(&nts->nts_lock);
98
99 return (new);
100 }
101
102 int
103 net_protocol_unregister(net_handle_t info)
104 {
105 neti_stack_t *nts;
106
107 ASSERT(info != NULL);
108
109 nts = info->netd_stack;
110 ASSERT(nts != NULL);
111
112 mutex_enter(&nts->nts_lock);
113 LIST_REMOVE(info, netd_list);
114 info->netd_stack = NULL;
115 mutex_exit(&nts->nts_lock);
116
117 (void) net_protocol_release(info);
118
119 return (0);
120 }
121
122 net_handle_t
123 net_protocol_lookup(netid_t netid, const char *protocol)
124 {
125 neti_stack_t *nts;
126 net_handle_t nd;
127
128 ASSERT(protocol != NULL);
129
130 nts = net_getnetistackbyid(netid);
131 if (nts == NULL)
132 return (NULL);
133
134 mutex_enter(&nts->nts_lock);
135 nd = net_find(protocol, nts);
136 if (nd != NULL)
137 atomic_inc_32((uint_t *)&nd->netd_refcnt);
138 mutex_exit(&nts->nts_lock);
139 return (nd);
140 }
141
142 /*
143 * Note: the man page specifies "returns -1 if the value passed in is unknown
144 * to this framework". We are not doing a lookup in this function, just a
145 * simply add to the netd_refcnt of the net_handle_t passed in, so -1 is never a
146 * return value.
147 */
148 int
149 net_protocol_release(net_handle_t info)
150 {
151
152 ASSERT(info->netd_refcnt > 0);
153 /*
154 * Is this safe? No hold on nts_lock? Consider that if the caller
155 * of net_protocol_release() is going to free this structure then
156 * it is now the only owner (refcnt==1) and it will have been
157 * removed from the nts_netd_head list on the neti_stack_t from a
158 * call to net_protocol_unregister already, so it is thus an orphan.
159 */
160 if (atomic_dec_32_nv((uint_t *)&info->netd_refcnt) == 0) {
161 ASSERT(info->netd_hooks == NULL);
162 ASSERT(info->netd_stack == NULL);
163 kmem_free(info, sizeof (struct net_data));
164 }
165
166 return (0);
167 }
168
169 net_handle_t
170 net_protocol_walk(netid_t netid, net_handle_t info)
171 {
172 struct net_data *n = NULL;
173 boolean_t found = B_FALSE;
174 neti_stack_t *nts;
175
176 nts = net_getnetistackbyid(netid);
177 ASSERT(nts != NULL);
178
179 if (info == NULL)
180 found = B_TRUE;
181
182 mutex_enter(&nts->nts_lock);
183 LIST_FOREACH(n, &nts->nts_netd_head, netd_list) {
184 if (found) {
185 /*
186 * We are only interested in finding protocols that
187 * are not in some sort of shutdown state. There is
188 * no need to check for netd_stack==NULL because
189 * that implies it is no longer on this list.
190 */
191 if (n->netd_condemned == 0)
192 continue;
193 break;
194 }
195
196 if (n == info)
197 found = B_TRUE;
198 }
199
200 if (info != NULL)
201 (void) net_protocol_release(info);
202
203 if (n != NULL)
204 atomic_inc_32((uint_t *)&n->netd_refcnt);
205
206 mutex_exit(&nts->nts_lock);
207
208 return (n);
209 }
210
211 /*
212 * Public accessor functions
213 */
214 int
215 net_getifname(net_handle_t info, phy_if_t nic, char *buffer,
216 const size_t buflen)
217 {
218
219 ASSERT(info != NULL);
220
221 if (info->netd_condemned != 0 || info->netd_stack == NULL)
222 return (-1);
223
224 return (info->netd_info.netp_getifname(info, nic, buffer, buflen));
225 }
226
227 int
228 net_getmtu(net_handle_t info, phy_if_t nic, lif_if_t ifdata)
229 {
230
231 ASSERT(info != NULL);
232
233 if (info->netd_condemned != 0 || info->netd_stack == NULL)
234 return (-1);
235
236 return (info->netd_info.netp_getmtu(info, nic, ifdata));
237 }
238
239 int
240 net_getpmtuenabled(net_handle_t info)
241 {
242
243 ASSERT(info != NULL);
244
245 if (info->netd_condemned != 0 || info->netd_stack == NULL)
246 return (-1);
247
248 return (info->netd_info.netp_getpmtuenabled(info));
249 }
250
251 int
252 net_getlifaddr(net_handle_t info, phy_if_t nic, lif_if_t ifdata,
253 int nelem, net_ifaddr_t type[], void *storage)
254 {
255
256 ASSERT(info != NULL);
257
258 if (info->netd_condemned != 0 || info->netd_stack == NULL)
259 return (-1);
260
261 return (info->netd_info.netp_getlifaddr(info, nic, ifdata,
262 nelem, type, storage));
263 }
264
265 int
266 net_getlifzone(net_handle_t info, phy_if_t phy_ifdata, lif_if_t ifdata,
267 zoneid_t *zoneid)
268 {
269 ASSERT(info != NULL);
270
271 if (info->netd_condemned != 0 || info->netd_stack == NULL)
272 return (-1);
273
274 return (info->netd_info.neti_getlifzone(info, phy_ifdata, ifdata,
275 zoneid));
276 }
277
278 int
279 net_getlifflags(net_handle_t info, phy_if_t phy_ifdata, lif_if_t ifdata,
280 uint64_t *flags)
281 {
282 ASSERT(info != NULL);
283
284 if (info->netd_condemned != 0 || info->netd_stack == NULL)
285 return (-1);
286
287 return (info->netd_info.neti_getlifflags(info, phy_ifdata, ifdata,
288 flags));
289 }
290
291 phy_if_t
292 net_phygetnext(net_handle_t info, phy_if_t nic)
293 {
294
295 ASSERT(info != NULL);
296
297 if (info->netd_condemned != 0 || info->netd_stack == NULL)
298 return ((phy_if_t)-1);
299
300 return (info->netd_info.netp_phygetnext(info, nic));
301 }
302
303 phy_if_t
304 net_phylookup(net_handle_t info, const char *name)
305 {
306
307 ASSERT(info != NULL);
308
309 if (info->netd_condemned != 0 || info->netd_stack == NULL)
310 return ((phy_if_t)-1);
311
312 return (info->netd_info.netp_phylookup(info, name));
313 }
314
315 lif_if_t
316 net_lifgetnext(net_handle_t info, phy_if_t ifidx, lif_if_t ifdata)
317 {
318
319 ASSERT(info != NULL);
320
321 if (info->netd_condemned != 0 || info->netd_stack == NULL)
322 return ((lif_if_t)-1);
323
324 return (info->netd_info.netp_lifgetnext(info, ifidx, ifdata));
325 }
326
327 int
328 net_inject(net_handle_t info, inject_t style, net_inject_t *packet)
329 {
330
331 ASSERT(info != NULL);
332
333 if (info->netd_condemned != 0 || info->netd_stack == NULL)
334 return (-1);
335
336 return (info->netd_info.netp_inject(info, style, packet));
337 }
338
339 phy_if_t
340 net_routeto(net_handle_t info, struct sockaddr *address, struct sockaddr *next)
341 {
342
343 ASSERT(info != NULL);
344
345 if (info->netd_condemned != 0 || info->netd_stack == NULL)
346 return ((phy_if_t)-1);
347
348 return (info->netd_info.netp_routeto(info, address, next));
349 }
350
351 int
352 net_ispartialchecksum(net_handle_t info, mblk_t *mp)
353 {
354
355 ASSERT(info != NULL);
356 ASSERT(mp != NULL);
357
358 if (info->netd_condemned != 0 || info->netd_stack == NULL)
359 return (-1);
360
361 return (info->netd_info.netp_ispartialchecksum(info, mp));
362 }
363
364 int
365 net_isvalidchecksum(net_handle_t info, mblk_t *mp)
366 {
367
368 ASSERT(info != NULL);
369 ASSERT(mp != NULL);
370
371 if (info->netd_condemned != 0 || info->netd_stack == NULL)
372 return (-1);
373
374 return (info->netd_info.netp_isvalidchecksum(info, mp));
375 }
376
377 /*
378 * Hooks related functions
379 */
380
381 /*
382 * Function: net_family_register
383 * Returns: int - 0 = Succ, Else = Fail
384 * Parameters: info(I) - protocol
385 * hf(I) - family pointer
386 *
387 * Call hook_family_add to register family
388 *
389 * There is no need to bump netd_refcnt in the two functions
390 * net_family_register and net_family_unregister because the caller of these
391 * two functions is assumed to "own" a reference on 'info' via an earlier
392 * call to net_protocol_register(). Thus the owner is expected to do a
393 * call to net_protocol_unregister() after having done a
394 * net_family_unregister() to make sure things are properly cleaned up.
395 * Passing a pointer to info->netd_hooks into hook_family_add is required
396 * so that this can be set before the notify functions are called. If this
397 * does not happen, the notify function may do something that seems fine,
398 * like add a notify function to the family but cause a panic because
399 * netd_hooks is NULL when we get to hook_family_notify_register.
400 */
401 int
402 net_family_register(net_handle_t info, hook_family_t *hf)
403 {
404 netstack_t *ns;
405
406 ASSERT(info != NULL);
407 ASSERT(hf != NULL);
408
409 if (info->netd_condemned != 0 || info->netd_stack == NULL)
410 return (ESHUTDOWN);
411
412 if (info->netd_hooks != NULL)
413 return (EEXIST);
414
415 ns = info->netd_stack->nts_netstack;
416 ASSERT(ns != NULL);
417 if (hook_family_add(hf, ns->netstack_hook,
418 (void **)&info->netd_hooks) == NULL)
419 return (EEXIST);
420
421 return (0);
422 }
423
424 /*
425 * Function: net_family_unregister
426 * Returns: int - transparent value, explained by caller
427 * Parameters: info(I) - protocol
428 * hf(I) - family pointer
429 *
430 * Call hook_family_remove to unregister family
431 */
432 int
433 net_family_unregister(net_handle_t info, hook_family_t *hf)
434 {
435 int ret;
436
437 ASSERT(info != NULL);
438 ASSERT(hf != NULL);
439
440 if (info->netd_hooks == NULL)
441 return (ENXIO);
442
443 if (strcmp(info->netd_hooks->hfi_family.hf_name,
444 hf->hf_name) != 0)
445 return (EINVAL);
446
447 ret = hook_family_remove(info->netd_hooks);
448 if (ret == 0)
449 info->netd_hooks = NULL;
450
451 return (ret);
452 }
453
454 int
455 net_family_shutdown(net_handle_t info, hook_family_t *hf)
456 {
457
458 ASSERT(info != NULL);
459 ASSERT(hf != NULL);
460
461 if (info->netd_hooks == NULL)
462 return (ENXIO);
463
464 if (strcmp(info->netd_hooks->hfi_family.hf_name,
465 hf->hf_name) != 0)
466 return (EINVAL);
467
468 return (hook_family_shutdown(info->netd_hooks));
469 }
470
471 /*
472 * Function: net_event_register
473 * Returns: internal event pointer - NULL = Fail
474 * Parameters: info(I) - protocol
475 * he(I) - event pointer
476 *
477 * Call hook_event_add to register event on specific family
478 * Internal event pointer is returned so caller can get
479 * handle to run hooks
480 */
481 hook_event_token_t
482 net_event_register(net_handle_t info, hook_event_t *he)
483 {
484 hook_event_int_t *hei;
485
486 ASSERT(info != NULL);
487 ASSERT(he != NULL);
488
489 if (info->netd_hooks == NULL || info->netd_condemned != 0 ||
490 info->netd_stack == NULL)
491 return (NULL);
492
493 hei = hook_event_add(info->netd_hooks, he);
494 return ((hook_event_token_t)hei);
495 }
496
497 /*
498 * Function: net_event_unregister
499 * Returns: int - transparent value, explained by caller
500 * Parameters: info(I) - protocol
501 * he(I) - event pointer
502 *
503 * Call hook_event_remove to unregister event on specific family
504 */
505 int
506 net_event_unregister(net_handle_t info, hook_event_t *he)
507 {
508
509 ASSERT(info != NULL);
510 ASSERT(he != NULL);
511
512 if (info->netd_hooks == NULL)
513 return (ENXIO);
514
515 return (hook_event_remove(info->netd_hooks, he));
516 }
517
518 int
519 net_event_shutdown(net_handle_t info, hook_event_t *he)
520 {
521
522 ASSERT(info != NULL);
523 ASSERT(he != NULL);
524
525 if (info->netd_hooks == NULL)
526 return (ENXIO);
527
528 return (hook_event_shutdown(info->netd_hooks, he));
529 }
530
531 /*
532 * Function: net_hook_register
533 * Returns: int - transparent value, explained by caller
534 * Parameters: info(I) - protocol
535 * event(I) - event name
536 * h(I) - hook pointer
537 *
538 * Call hook_register to add hook on specific family/event
539 */
540 int
541 net_hook_register(net_handle_t info, char *event, hook_t *h)
542 {
543
544 ASSERT(info != NULL);
545 ASSERT(event != NULL);
546 ASSERT(h != NULL);
547
548 if (info->netd_condemned != 0 || info->netd_stack == NULL)
549 return (ESHUTDOWN);
550
551 if (info->netd_hooks == NULL)
552 return (ENXIO);
553
554 return (hook_register(info->netd_hooks, event, h));
555 }
556
557 /*
558 * Function: net_hook_unregister
559 * Returns: int - transparent value, explained by caller
560 * Parameters: info(I) - protocol
561 * event(I) - event name
562 * h(I) - hook pointer
563 *
564 * Call hook_unregister to remove hook on specific family/event
565 */
566 int
567 net_hook_unregister(net_handle_t info, char *event, hook_t *h)
568 {
569
570 ASSERT(info != NULL);
571 ASSERT(event != NULL);
572 ASSERT(h != NULL);
573
574 if (info->netd_hooks == NULL)
575 return (ENXIO);
576
577 return (hook_unregister(info->netd_hooks, event, h));
578 }
579
580 netid_t
581 net_getnetid(net_handle_t netd)
582 {
583
584 if (netd->netd_stack == NULL)
585 return (-1);
586 return (netd->netd_stack->nts_id);
587 }
588
589 net_inject_t *
590 net_inject_alloc(const int version)
591 {
592 net_inject_t *ni;
593
594 ni = kmem_zalloc(sizeof (*ni), KM_NOSLEEP);
595 if (ni == NULL)
596 return (NULL);
597
598 ni->ni_version = version;
599 return (ni);
600 }
601
602 void
603 net_inject_free(net_inject_t *ni)
604 {
605 kmem_free(ni, sizeof (*ni));
606 }
607
608 kstat_t *
609 net_kstat_create(netid_t netid, char *module, int instance, char *name,
610 char *class, uchar_t type, ulong_t ndata, uchar_t ks_flag)
611 {
612 netstackid_t stackid = net_getnetstackidbynetid(netid);
613
614 if (stackid == -1)
615 return (NULL);
616
617 return (kstat_create_netstack(module, instance, name, class, type,
618 ndata, ks_flag, stackid));
619 }
620
621 void
622 net_kstat_delete(netid_t netid, kstat_t *ks)
623 {
624 netstackid_t stackid = net_getnetstackidbynetid(netid);
625
626 if (stackid != -1)
627 kstat_delete_netstack(ks, stackid);
628 }
629
630 int
631 net_event_notify_register(net_handle_t family, char *event,
632 hook_notify_fn_t callback, void *arg)
633 {
634 int error;
635
636 if (family->netd_condemned != 0 || family->netd_stack == NULL)
637 return (ESHUTDOWN);
638
639 error = hook_event_notify_register(family->netd_hooks, event,
640 callback, arg);
641
642 return (error);
643 }
644
645 int
646 net_event_notify_unregister(net_handle_t family, char *event,
647 hook_notify_fn_t callback)
648 {
649 int error;
650
651 error = hook_event_notify_unregister(family->netd_hooks, event,
652 callback);
653
654 return (error);
655 }
656
657 int
658 net_protocol_notify_register(net_handle_t family, hook_notify_fn_t callback,
659 void *arg)
660 {
661 int error;
662
663 if (family->netd_condemned != 0 || family->netd_stack == NULL)
664 return (ESHUTDOWN);
665
666 error = hook_family_notify_register(family->netd_hooks, callback,
667 arg);
668
669 return (error);
670 }
671
672 int
673 net_protocol_notify_unregister(net_handle_t family, hook_notify_fn_t callback)
674 {
675 int error;
676
677 error = hook_family_notify_unregister(family->netd_hooks, callback);
678
679 return (error);
680 }