bsd/net/kpi_protocol.c

   1 /*
   2  * Copyright (c) 2004-2013 Apple Inc. All rights reserved.
   3  *
   4  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
   5  *
   6  * This file contains Original Code and/or Modifications of Original Code
   7  * as defined in and that are subject to the Apple Public Source License
   8  * Version 2.0 (the 'License'). You may not use this file except in
   9  * compliance with the License. The rights granted to you under the License
  10  * may not be used to create, or enable the creation or redistribution of,
  11  * unlawful or unlicensed copies of an Apple operating system, or to
  12  * circumvent, violate, or enable the circumvention or violation of, any
  13  * terms of an Apple operating system software license agreement.
  14  *
  15  * Please obtain a copy of the License at
  16  * http://www.opensource.apple.com/apsl/ and read it before using this file.
  17  *
  18  * The Original Code and all software distributed under the License are
  19  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  20  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  21  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  22  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  23  * Please see the License for the specific language governing rights and
  24  * limitations under the License.
  25  *
  26  * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
  27  */
  28
  29 #include "kpi_protocol.h"
  30
  31 #include <sys/param.h>
  32 #include <sys/malloc.h>
  33 #include <sys/socket.h>
  34 #include <sys/systm.h>
  35 #include <sys/kpi_mbuf.h>
  36 #include <sys/domain.h>
  37 #include <net/if.h>
  38 #include <net/dlil.h>
  39 #include <libkern/OSAtomic.h>
  40
  41 void proto_input_run(void);
  42
  43 typedef int (*attach_t)(struct ifnet *ifp, uint32_t protocol_family);
  44 typedef int (*detach_t)(struct ifnet *ifp, uint32_t protocol_family);
  45
  46 struct proto_input_entry {
  47         struct proto_input_entry        *next;
  48         int                             detach;
  49         struct domain                   *domain;
  50         int                             hash;
  51         int                             chain;
  52
  53         protocol_family_t               protocol;
  54         proto_input_handler             input;
  55         proto_input_detached_handler    detached;
  56
  57         mbuf_t                          inject_first;
  58         mbuf_t                          inject_last;
  59
  60         struct proto_input_entry        *input_next;
  61         mbuf_t                          input_first;
  62         mbuf_t                          input_last;
  63 };
  64
  65
  66 struct proto_family_str {
  67         TAILQ_ENTRY(proto_family_str)   proto_fam_next;
  68         protocol_family_t               proto_family;
  69         ifnet_family_t                  if_family;
  70         proto_plumb_handler             attach_proto;
  71         proto_unplumb_handler           detach_proto;
  72 };
  73
  74 static struct proto_input_entry *proto_hash[PROTO_HASH_SLOTS];
  75 static int proto_total_waiting = 0;
  76 static struct proto_input_entry *proto_input_add_list = NULL;
  77 decl_lck_mtx_data(static, proto_family_mutex_data);
  78 static lck_mtx_t *proto_family_mutex = &proto_family_mutex_data;
  79 static TAILQ_HEAD(, proto_family_str) proto_family_head =
  80     TAILQ_HEAD_INITIALIZER(proto_family_head);
  81
  82 __private_extern__ void
  83 proto_kpi_init(void)
  84 {
  85         lck_grp_attr_t  *grp_attrib = NULL;
  86         lck_attr_t      *lck_attrib = NULL;
  87         lck_grp_t       *lck_group = NULL;
  88
  89         /* Allocate a mtx lock */
  90         grp_attrib = lck_grp_attr_alloc_init();
  91         lck_group = lck_grp_alloc_init("protocol kpi", grp_attrib);
  92         lck_grp_attr_free(grp_attrib);
  93         lck_attrib = lck_attr_alloc_init();
  94         lck_mtx_init(proto_family_mutex, lck_group, lck_attrib);
  95         lck_grp_free(lck_group);
  96         lck_attr_free(lck_attrib);
  97
  98         bzero(proto_hash, sizeof (proto_hash));
  99 }
 100
 101 __private_extern__ errno_t
 102 proto_register_input(protocol_family_t protocol, proto_input_handler input,
 103     proto_input_detached_handler detached, int  chains)
 104 {
 105         struct proto_input_entry *entry;
 106         struct dlil_threading_info *inp = dlil_main_input_thread;
 107         struct domain *dp;
 108         domain_guard_t guard;
 109
 110         entry = _MALLOC(sizeof (*entry), M_IFADDR, M_WAITOK | M_ZERO);
 111         if (entry == NULL)
 112                 return (ENOMEM);
 113
 114         entry->protocol = protocol;
 115         entry->input = input;
 116         entry->detached = detached;
 117         entry->hash = proto_hash_value(protocol);
 118         entry->chain = chains;
 119
 120         guard = domain_guard_deploy();
 121         TAILQ_FOREACH(dp, &domains, dom_entry) {
 122                 if (dp->dom_family == (int)protocol)
 123                         break;
 124         }
 125         domain_guard_release(guard);
 126         if (dp == NULL)
 127                 return (EINVAL);
 128
 129         entry->domain = dp;
 130
 131         lck_mtx_lock(&inp->input_lck);
 132         entry->next = proto_input_add_list;
 133         proto_input_add_list = entry;
 134
 135         inp->input_waiting |= DLIL_PROTO_REGISTER;
 136         if ((inp->input_waiting & DLIL_INPUT_RUNNING) == 0)
 137                 wakeup((caddr_t)&inp->input_waiting);
 138         lck_mtx_unlock(&inp->input_lck);
 139
 140         return (0);
 141 }
 142
 143 __private_extern__ void
 144 proto_unregister_input(protocol_family_t protocol)
 145 {
 146         struct proto_input_entry *entry = NULL;
 147
 148         for (entry = proto_hash[proto_hash_value(protocol)]; entry != NULL;
 149             entry = entry->next) {
 150                 if (entry->protocol == protocol)
 151                         break;
 152         }
 153
 154         if (entry != NULL)
 155                 entry->detach = 1;
 156 }
 157
 158 static void
 159 proto_delayed_attach(struct proto_input_entry *entry)
 160 {
 161         struct proto_input_entry *next_entry;
 162
 163         for (next_entry = entry->next; entry != NULL; entry = next_entry) {
 164                 struct proto_input_entry *exist;
 165                 int hash_slot;
 166
 167                 hash_slot = proto_hash_value(entry->protocol);
 168                 next_entry = entry->next;
 169
 170                 for (exist = proto_hash[hash_slot]; exist != NULL;
 171                     exist = exist->next) {
 172                         if (exist->protocol == entry->protocol)
 173                                 break;
 174                 }
 175
 176                 /* If the entry already exists, call detached and dispose */
 177                 if (exist != NULL) {
 178                         if (entry->detached)
 179                                 entry->detached(entry->protocol);
 180                         FREE(entry, M_IFADDR);
 181                 } else {
 182                         entry->next = proto_hash[hash_slot];
 183                         proto_hash[hash_slot] = entry;
 184                 }
 185         }
 186 }
 187
 188 __private_extern__ void
 189 proto_input_run(void)
 190 {
 191         struct proto_input_entry *entry;
 192         struct dlil_threading_info *inp = dlil_main_input_thread;
 193         mbuf_t packet_list;
 194         int i, locked = 0;
 195
 196         lck_mtx_assert(&inp->input_lck, LCK_MTX_ASSERT_NOTOWNED);
 197
 198         if (inp->input_waiting & DLIL_PROTO_REGISTER) {
 199                 lck_mtx_lock_spin(&inp->input_lck);
 200                 entry = proto_input_add_list;
 201                 proto_input_add_list = NULL;
 202                 inp->input_waiting &= ~DLIL_PROTO_REGISTER;
 203                 lck_mtx_unlock(&inp->input_lck);
 204                 proto_delayed_attach(entry);
 205         }
 206
 207         /*
 208          * Move everything from the lock protected list to the thread
 209          * specific list.
 210          */
 211         for (i = 0; proto_total_waiting != 0 && i < PROTO_HASH_SLOTS; i++) {
 212                 for (entry = proto_hash[i];
 213                     entry != NULL && proto_total_waiting; entry = entry->next) {
 214                         if (entry->inject_first != NULL) {
 215                                 lck_mtx_lock_spin(&inp->input_lck);
 216                                 inp->input_waiting &= ~DLIL_PROTO_WAITING;
 217
 218                                 packet_list = entry->inject_first;
 219
 220                                 entry->inject_first = NULL;
 221                                 entry->inject_last = NULL;
 222                                 proto_total_waiting--;
 223
 224                                 lck_mtx_unlock(&inp->input_lck);
 225
 226                                 if (entry->domain != NULL && !(entry->domain->
 227                                     dom_flags & DOM_REENTRANT)) {
 228                                         lck_mtx_lock(entry->domain->dom_mtx);
 229                                         locked = 1;
 230                                 }
 231
 232                                 if (entry->chain) {
 233                                         entry->input(entry->protocol,
 234                                             packet_list);
 235                                 } else {
 236                                         mbuf_t  packet;
 237
 238                                         for (packet = packet_list;
 239                                             packet != NULL;
 240                                             packet = packet_list) {
 241                                                 packet_list =
 242                                                     mbuf_nextpkt(packet);
 243                                                 mbuf_setnextpkt(packet, NULL);
 244                                                 entry->input(entry->protocol,
 245                                                     packet);
 246                                         }
 247                                 }
 248                                 if (locked) {
 249                                         locked = 0;
 250                                         lck_mtx_unlock(entry->domain->dom_mtx);
 251                                 }
 252                         }
 253                 }
 254         }
 255 }
 256
 257 errno_t
 258 proto_input(protocol_family_t protocol, mbuf_t packet_list)
 259 {
 260         struct proto_input_entry *entry;
 261         errno_t locked = 0, result = 0;
 262
 263         for (entry = proto_hash[proto_hash_value(protocol)]; entry != NULL;
 264             entry = entry->next) {
 265                 if (entry->protocol == protocol)
 266                         break;
 267         }
 268
 269         if (entry->domain && !(entry->domain->dom_flags & DOM_REENTRANT)) {
 270                 lck_mtx_lock(entry->domain->dom_mtx);
 271                 locked = 1;
 272         }
 273
 274         if (entry->chain) {
 275                 entry->input(entry->protocol, packet_list);
 276         } else {
 277                 mbuf_t  packet;
 278
 279                 for (packet = packet_list; packet != NULL;
 280                     packet = packet_list) {
 281                         packet_list = mbuf_nextpkt(packet);
 282                         mbuf_setnextpkt(packet, NULL);
 283                         entry->input(entry->protocol, packet);
 284                 }
 285         }
 286
 287         if (locked) {
 288                 lck_mtx_unlock(entry->domain->dom_mtx);
 289         }
 290         return (result);
 291 }
 292
 293 errno_t
 294 proto_inject(protocol_family_t protocol, mbuf_t packet_list)
 295 {
 296         struct proto_input_entry *entry;
 297         mbuf_t last_packet;
 298         int hash_slot = proto_hash_value(protocol);
 299         struct dlil_threading_info *inp = dlil_main_input_thread;
 300
 301         for (last_packet = packet_list; mbuf_nextpkt(last_packet) != NULL;
 302             last_packet = mbuf_nextpkt(last_packet))
 303                 /* find the last packet */;
 304
 305         for (entry = proto_hash[hash_slot]; entry != NULL;
 306             entry = entry->next) {
 307                 if (entry->protocol == protocol)
 308                         break;
 309         }
 310
 311         if (entry != NULL) {
 312                 lck_mtx_lock(&inp->input_lck);
 313                 if (entry->inject_first == NULL) {
 314                         proto_total_waiting++;
 315                         inp->input_waiting |= DLIL_PROTO_WAITING;
 316                         entry->inject_first = packet_list;
 317                 } else {
 318                         mbuf_setnextpkt(entry->inject_last, packet_list);
 319                 }
 320                 entry->inject_last = last_packet;
 321                 if ((inp->input_waiting & DLIL_INPUT_RUNNING) == 0) {
 322                         wakeup((caddr_t)&inp->input_waiting);
 323                 }
 324                 lck_mtx_unlock(&inp->input_lck);
 325         } else {
 326                 return (ENOENT);
 327         }
 328
 329         return (0);
 330 }
 331
 332 static struct proto_family_str *
 333 proto_plumber_find(protocol_family_t proto_family, ifnet_family_t if_family)
 334 {
 335         struct proto_family_str  *mod = NULL;
 336
 337         TAILQ_FOREACH(mod, &proto_family_head, proto_fam_next) {
 338                 if ((mod->proto_family == (proto_family & 0xffff)) &&
 339                     (mod->if_family == (if_family & 0xffff)))
 340                         break;
 341         }
 342
 343         return (mod);
 344 }
 345
 346 errno_t
 347 proto_register_plumber(protocol_family_t protocol_family,
 348     ifnet_family_t interface_family, proto_plumb_handler attach,
 349     proto_unplumb_handler detach)
 350 {
 351         struct proto_family_str *proto_family;
 352
 353         if (attach == NULL)
 354                 return (EINVAL);
 355
 356         lck_mtx_lock(proto_family_mutex);
 357
 358         TAILQ_FOREACH(proto_family, &proto_family_head, proto_fam_next) {
 359                 if (proto_family->proto_family == protocol_family &&
 360                     proto_family->if_family == interface_family) {
 361                         lck_mtx_unlock(proto_family_mutex);
 362                         return (EEXIST);
 363                 }
 364         }
 365
 366         proto_family = (struct proto_family_str *)
 367             _MALLOC(sizeof (struct proto_family_str), M_IFADDR,
 368             M_WAITOK | M_ZERO);
 369         if (!proto_family) {
 370                 lck_mtx_unlock(proto_family_mutex);
 371                 return (ENOMEM);
 372         }
 373
 374         proto_family->proto_family      = protocol_family;
 375         proto_family->if_family         = interface_family & 0xffff;
 376         proto_family->attach_proto      = attach;
 377         proto_family->detach_proto      = detach;
 378
 379         TAILQ_INSERT_TAIL(&proto_family_head, proto_family, proto_fam_next);
 380         lck_mtx_unlock(proto_family_mutex);
 381         return (0);
 382 }
 383
 384 void
 385 proto_unregister_plumber(protocol_family_t protocol_family,
 386     ifnet_family_t interface_family)
 387 {
 388         struct proto_family_str  *proto_family;
 389
 390         lck_mtx_lock(proto_family_mutex);
 391
 392         proto_family = proto_plumber_find(protocol_family, interface_family);
 393         if (proto_family == NULL) {
 394                 lck_mtx_unlock(proto_family_mutex);
 395                 return;
 396         }
 397
 398         TAILQ_REMOVE(&proto_family_head, proto_family, proto_fam_next);
 399         FREE(proto_family, M_IFADDR);
 400
 401         lck_mtx_unlock(proto_family_mutex);
 402 }
 403
 404 __private_extern__ errno_t
 405 proto_plumb(protocol_family_t protocol_family, ifnet_t ifp)
 406 {
 407         struct proto_family_str  *proto_family;
 408         int ret = 0;
 409
 410         lck_mtx_lock(proto_family_mutex);
 411         proto_family = proto_plumber_find(protocol_family, ifp->if_family);
 412         if (proto_family == NULL) {
 413                 lck_mtx_unlock(proto_family_mutex);
 414                 return (ENXIO);
 415         }
 416
 417         ret = proto_family->attach_proto(ifp, protocol_family);
 418
 419         lck_mtx_unlock(proto_family_mutex);
 420         return (ret);
 421 }
 422
 423
 424 __private_extern__ errno_t
 425 proto_unplumb(protocol_family_t protocol_family, ifnet_t ifp)
 426 {
 427         struct proto_family_str  *proto_family;
 428         int ret = 0;
 429
 430         lck_mtx_lock(proto_family_mutex);
 431
 432         proto_family = proto_plumber_find(protocol_family, ifp->if_family);
 433         if (proto_family != NULL && proto_family->detach_proto)
 434                 proto_family->detach_proto(ifp, protocol_family);
 435         else
 436                 ret = ifnet_detach_protocol(ifp, protocol_family);
 437
 438         lck_mtx_unlock(proto_family_mutex);
 439         return (ret);
 440 }