![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to IONetworkStack.cpp CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / iokit / Families / IONetworking|
Return to IONetworkStack.cpp CVS log | Up to [Apple XNU] / XNU / iokit / Families / IONetworking |
1.1 root 1: /*
2: * Copyright (c) 1998-2000 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * The contents of this file constitute Original Code as defined in and
7: * are subject to the Apple Public Source License Version 1.1 (the
8: * "License"). You may not use this file except in compliance with the
9: * License. Please obtain a copy of the License at
10: * http://www.apple.com/publicsource and read it before using this file.
11: *
12: * This Original Code and all software distributed under the License are
13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
17: * License for the specific language governing rights and limitations
18: * under the License.
19: *
20: * @APPLE_LICENSE_HEADER_END@
21: */
22: /*
23: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
24: *
25: * IONetworkStack.cpp - An IOKit proxy for the BSD network stack.
26: *
27: * HISTORY
28: *
29: * IONetworkStack abstracts certain essential network stack services.
30: * Those services include attaching/detaching network interfaces, and
31: * interface naming. Note that although BSD network stack does not assign
32: * interface names, it is the responsibility of this object to manage the
33: * interface name space.
34: *
35: * IONetworkStack is a client of IONetworkInterface. This object uses the
36: * standard IOKit matching mechanism to discover and attach to interface
37: * objects. Each interface object is expected to have only a single
38: * IONetworkStack client. Under IOKit, the stack object initiates the
39: * action to attach to an interface. And subsequently, detaches from an
40: * interface when signaled to do so.
41: *
42: * The packet flow bypasses this object for efficiency sake. The interface
43: * object interact directly with the 'real' network stack to send and
44: * receive packets.
45: */
46:
47: #include <IOKit/assert.h>
48: #include <IOKit/IOLib.h>
49: #include <IOKit/IOBSD.h>
50: #include <IOKit/IOMessage.h>
51: #include <IOKit/network/IONetworkInterface.h>
52: #include <IOKit/network/IONetworkController.h>
53: #include "IONetworkStack.h"
54:
55: extern "C" {
56: #include <sys/param.h>
57: #include <sys/mbuf.h>
58: #include <sys/socket.h>
59: #include <net/bpf.h>
60: #include <net/if.h>
61: #include <netinet/if_ether.h>
62: }
63:
64: #define super IOService
65:
66: OSDefineMetaClassAndStructorsWithInit( IONetworkStack,
67: IOService,
68: IONetworkStack::initialize())
69:
70: #ifdef DEBUG
71: #define DLOG(fmt, args...) IOLog(fmt, ## args)
72: #else
73: #define DLOG
74: #endif
75:
76: // Maintain a linked list of network interfaces.
77: // Each time a new interface is added, an unit number is assigned,
78: // and an interface entry is added to the list. When the interface
79: // goes away, the entry is removed from the list and deallocated.
80: //
81: static queue_head_t netifTable;
82: static IOLock * netifTableLock;
83:
84: typedef struct {
85: IONetworkInterface * netif;
86: const char * name;
87: short unit;
88: queue_chain_t link;
89: } netifEntry;
90:
91: #define BSD_IFNET_ENTRY ((IONetworkInterface *) 0)
92: #define NETIF_LOCK IOTakeLock(netifTableLock)
93: #define NETIF_UNLOCK IOUnlock(netifTableLock)
94:
95: #define LOCK IOTakeLock(_lock);
96: #define UNLOCK IOUnlock(_lock);
97:
98: // --------------------------------------------------------------------------
99: //
100: // Add a new entry to the netifTable for the interface 'netif'.
101: // Return true if the entry was added successfully, otherwise
102: // returns false.
103: //
104: // The table lock must be held by the caller of this function.
105: //
106: static bool addNetworkInterfaceEntry(IONetworkInterface * netif,
107: const char * name,
108: short unit)
109: {
110: if (!netif || !name || (unit < 0)) return false;
111:
112: netifEntry * entry = (netifEntry *) IOMalloc(sizeof(netifEntry));
113: if (!entry)
114: return false;
115: bzero(entry, sizeof(*entry));
116:
117: entry->netif = netif;
118: entry->unit = unit;
119: entry->name = name;
120:
121: queue_enter(&netifTable, entry, netifEntry *, link);
122:
123: return true;
124: }
125:
126: // --------------------------------------------------------------------------
127: //
128: // Release the table entry occupied by the 'netif' instance.
129: // Returns true if an entry was found and removed, otherwise
130: // return false.
131: //
132: static bool releaseNetworkInterfaceEntry(IONetworkInterface * netif)
133: {
134: netifEntry * foundEntry = 0;
135:
136: if (!netif) return false;
137:
138: NETIF_LOCK;
139: if (!queue_empty(&netifTable)) {
140: netifEntry * entry;
141: queue_iterate(&netifTable, entry, netifEntry *, link) {
142: if (entry->netif == netif) {
143: foundEntry = entry;
144: break;
145: }
146: }
147: }
148: if (foundEntry) {
149: queue_remove(&netifTable, foundEntry, netifEntry *, link);
150: IOFree(foundEntry, sizeof(*foundEntry));
151: }
152: NETIF_UNLOCK;
153:
154: return (foundEntry ? true : false);
155: }
156:
157: // --------------------------------------------------------------------------
158: //
159: // Initialize the table, and preload it with any existing BSD network
160: // interfaces.
161: //
162: static void initNetifTable()
163: {
164: netifTableLock = IOLockAlloc();
165: assert(netifTableLock);
166:
167: IOLockInitWithState(netifTableLock, kIOLockStateUnlocked);
168:
169: queue_init(&netifTable);
170:
171: // Insert entries for all existing 'BSD' network interfaces into the
172: // netifTable. Hopefully only lo0 will be found.
173: //
174: #if 1 // FreeBSD 3.2
175: for (struct ifnet * ifp = ifnet.tqh_first;
176: ifp;
177: ifp = ifp->if_link.tqe_next)
178: addNetworkInterfaceEntry(BSD_IFNET_ENTRY, ifp->if_name, ifp->if_unit);
179: #else
180: for (struct ifnet * ifp = ifnet; ifp; ifp = ifp->if_next)
181: addNetworkInterfaceEntry(BSD_IFNET_ENTRY, ifp->if_name, ifp->if_unit);
182: #endif
183: }
184:
185: // --------------------------------------------------------------------------
186: //
187: // Add a entry for the interface object 'netif', with name prefix 'name'.
188: // The chosen unit number is returned in 'unit'. Returns true on success.
189: //
190: static bool reserveNetworkInterfaceEntry(IONetworkInterface * netif,
191: const char * name,
192: short * unit)
193: {
194: bool ret = true;
195: bool addEntry = true; // add new entry to list.
196: bool error = false;
197:
198: if (!netif || !name || !unit || (*unit < 0)) return false;
199:
200: NETIF_LOCK;
201:
202: if (!queue_empty(&netifTable)) {
203: bool rescan;
204: netifEntry * entry;
205:
206: do {
207: rescan = false;
208:
209: // Scan through the interface list and search for duplicates
210: // and conflicts. If a conflict is found, increment the unit
211: // number and rescan.
212: //
213: queue_iterate(&netifTable, entry, netifEntry *, link) {
214: if (entry->netif == netif) { // can't have duplicates
215: addEntry = false; // re-use existing entry
216: *unit = entry->unit;
217: break;
218: }
219: if ((entry->unit == *unit) && !strcmp(entry->name, name)) {
220: // name conflict detected.
221: if (++(*unit) > 0)
222: rescan = true;
223: else
224: error = true;
225: break;
226: }
227: }
228: } while (rescan);
229: }
230:
231: if (error)
232: ret = false;
233: else if (addEntry)
234: ret = addNetworkInterfaceEntry(netif, name, *unit);
235:
236: NETIF_UNLOCK;
237:
238: return ret;
239: }
240:
241: // --------------------------------------------------------------------------
242: //
243: // IONetworkStack class initializer.
244:
245: void IONetworkStack::initialize()
246: {
247: initNetifTable();
248: }
249:
250: // --------------------------------------------------------------------------
251: //
252: // init method.
253:
254: bool IONetworkStack::init(OSDictionary * properties)
255: {
256: _netif = 0; // IONetworkInterface instance (provider).
257: _ifp = 0; // ifnet struct for the interface.
258: _lock = 0; // big serialization lock.
259: _state = kIONetworkStackStateInit; // default state.
260:
261: if (!super::init())
262: return false;
263:
264: // Allocate a lock which will protect all accesses to this object.
265: //
266: _lock = IOLockAlloc();
267: if (!_lock)
268: return false;
269:
270: return true;
271: }
272:
273: // --------------------------------------------------------------------------
274: //
275: // probe. the score forces the probe and start in IONetworkStack to occur
276: // before the notification from IONetworkInterface is sent. We need to delay
277: // that until the network stack object has assigned a BSD name to the
278: // interface.
279:
280: IOService * IONetworkStack::probe(IOService * provider,
281: SInt32 * score)
282: {
283: if (!super::probe(provider, score))
284: return 0;
285:
286: // We are not picky about our provider, but it must be an
287: // IONetworkInterface instance.
288: //
289: IONetworkInterface * netif = OSDynamicCast(IONetworkInterface, provider);
290: if (!netif)
291: return 0;
292:
293: *score = 32; // must be larger than notification score.
294:
295: // Query interface for any requirements before qualifying the probe.
296: // For now, there is nothing that needs to be done. Return 'this' to
297: // indicate successful probe.
298:
299: return this;
300: }
301:
302: // --------------------------------------------------------------------------
303: //
304: // start method. We have attached to our provider, now start ourselve up.
305:
306: bool IONetworkStack::start(IOService * provider)
307: {
308: IONetworkInterface * netif = OSDynamicCast(IONetworkInterface, provider);
309: bool ret = false;
310: bool opened = false;
311:
312: if (!netif) return false;
313:
314: LOCK;
315:
316: do {
317: // Catch illegal state transitions.
318: //
319: if (_state != kIONetworkStackStateInit)
320: break;
321:
322: // Our provider must reveal its ifnet structure.
323: //
324: _netif = netif;
325: _ifp = _netif->getIfnet();
326: if (!_ifp || (_netif != (IONetworkInterface *) _ifp->if_private))
327: break;
328:
329: // Pass start() to our superclass.
330: //
331: if (!super::start(provider))
332: break;
333:
334: // Open our provider.
335: //
336: if (!_netif->open(this))
337: break;
338: opened = true;
339:
340: // Assign a name for the interface. Must do this before the
341: // if_attach() call. Remember to release the OSString object
342: // obtained through this call.
343: //
344: OSString * ifname = _assignInterfaceName(_netif);
345: if (!ifname) {
346: releaseNetworkInterfaceEntry(_netif);
347: break;
348: }
349: ifname->release();
350:
351: // When IONetworkStack gets probed, we assume that BSD is already
352: // up and running. So it is safe to call BSD to attach the network
353: // interface.
354: //
355: // FIXME: This will only work with Ethernet interfaces. Switch to
356: // new DLIL API once that is available.
357: //
358: _netif->lock();
359:
360: // Set the if_free() function pointer in the ifnet to point to our
361: // detachCallBack() static function.
362: //
363: // _ifp->if_free = detachCallBackHandler;
364: // _netif->_stack = this;
365:
366: #if 1 // FreeBSD 3.2
367: bpfattach(_ifp, DLT_EN10MB,sizeof(struct ether_header));
368: #else
369: bpfattach(&_ifp->if_bpf, _ifp, DLT_EN10MB,sizeof(struct ether_header));
370: #endif
371:
372: ether_ifattach(_ifp);
373:
374: _netif->unlock();
375:
376: // Network stack is now attached to the interface.
377: //
378: _state = kIONetworkStackStateAttached;
379:
380: ret = true;
381: }
382: while (0);
383:
384: if (!ret)
385: {
386: // start failed, undo any actions performed.
387: //
388: if (opened)
389: _netif->close(this);
390:
391: _netif = 0;
392: _ifp = 0;
393: }
394:
395: UNLOCK;
396:
397: return ret;
398: }
399:
400: // --------------------------------------------------------------------------
401: //
402: // stop method.
403:
404: void IONetworkStack::stop(IOService * provider)
405: {
406: LOCK;
407:
408: // Catch an illegal stop.
409: //
410: assert((_state == kIONetworkStackStateInit) ||
411: (_state == kIONetworkStackStateDetached));
412:
413: // Remove the interface from linked list.
414: //
415: if (_netif) {
416: assert(_netif == (IONetworkInterface *) provider);
417: releaseNetworkInterfaceEntry(_netif);
418: }
419:
420: _netif = 0;
421: _ifp = 0;
422: _state = kIONetworkStackStateInit;
423:
424: UNLOCK;
425:
426: super::stop(provider);
427: }
428:
429: // --------------------------------------------------------------------------
430: //
431: // sendIfDetachRequest
432: //
433: // Handle a detach request from our provider and signal to the network stack
434: // that the interface wishes to detach. The network stack will callback when
435: // the interface is allowed to proceed with the detach. There is no hard
436: // limit on how soon the callback will occur.
437: //
438: // Returns true if the request was handled. Otherwise, returns false.
439:
440: bool IONetworkStack::sendIfDetachRequest()
441: {
442: bool ret = false;
443:
444: DLOG("IONetworkStack::sendIfDetachRequest() called state = %d\n", _state);
445:
446: LOCK;
447:
448: if (_state == kIONetworkStackStateAttached) {
449:
450: // Send a detach request to the network stack and wait for
451: // a callback indicating detach operation complete.
452: //
453: // if_detach() is a new proposed DLIL call and does not exist yet.
454:
455: _state = kIONetworkStackStateDetaching;
456:
457: ret = true; // detach request handled.
458: }
459:
460: UNLOCK;
461:
462: return ret;
463: }
464:
465: // --------------------------------------------------------------------------
466: //
467: // ifDetachCallback method.
468:
469: void IONetworkStack::ifDetachCallback()
470: {
471: LOCK;
472:
473: if (_state == kIONetworkStackStateDetaching) {
474:
475: // We previously sent a detach request, the network stack is now
476: // calling back to indicate detach completion.
477: //
478: assert(_netif && _ifp);
479:
480: // Close our provider.
481: //
482: _netif->close(this);
483:
484: // Detach is now complete.
485: //
486: _state = kIONetworkStackStateDetached;
487: }
488: else {
489: DLOG("%s: Unexpected detach callback\n", getName());
490: }
491:
492: UNLOCK;
493: }
494:
495: // --------------------------------------------------------------------------
496: //
497: // This static member function is registered as the if_free() handler in
498: // the ifnet structure of our provider. The IONetworkStack instance is
499: // discovered and its ifFreeCallback() method is called.
500:
501: void IONetworkStack::ifDetachCallbackHandler(struct ifnet * ifp)
502: {
503: IONetworkInterface * netif;
504: IONetworkStack * stack;
505:
506: netif = OSDynamicCast(IONetworkInterface,
507: (IONetworkInterface *) ifp->if_private);
508: assert(netif);
509:
510: netif->lockForArbitration();
511:
512: stack = (IONetworkStack *) netif->_client;
513: if (stack)
514: stack->ifDetachCallback();
515: else
516: DLOG("IONetworkStack: No target for ifDetachCallback\n");
517:
518: netif->unlockForArbitration();
519: }
520:
521: // --------------------------------------------------------------------------
522: //
523: // Release allocated resources.
524:
525: void IONetworkStack::free()
526: {
527: assert(_state == kIONetworkStackStateInit);
528:
529: if (_lock)
530: IOLockFree(_lock);
531: }
532:
533: // --------------------------------------------------------------------------
534: //
535: // Facility provided by IOService for general purpose provider-to-client
536: // notification. We catch the kIOMessageServiceIsTerminated message.
537:
538: IOReturn IONetworkStack::message(UInt32 type, IOService * provider,
539: void * argument = 0)
540: {
541: // Our provider has gone into an inactive state, we should begin the
542: // tear-down process by signalling the network stack to unregister
543: // and detach the network interface.
544: //
545: // We do not look at the argument, which contains the options given
546: // to the terminate() method.
547: //
548: if (type == kIOMessageServiceIsTerminated) {
549: sendIfDetachRequest();
550: return kIOReturnSuccess;
551: }
552:
553: return kIOReturnUnsupported;
554: }
555:
556: // --------------------------------------------------------------------------
557: //
558: // Assign a BSD friendly name to the network interface. The interface
559: // object has to assist in this process by returning its name prefix,
560: // i.e. "en". This routine will pick an unit number that does not
561: // conflict with any existing interface.
562:
563: OSString * IONetworkStack::_assignInterfaceName(IONetworkInterface * netif)
564: {
565: SInt16 unit = 0;
566: UInt32 index = 0;
567: const char * namePrefix = netif->getNamePrefix();
568: char nameBuf[40];
569: OSString * nameString;
570: IONetworkController * ctlr = OSDynamicCast(IONetworkController,
571: netif->getProvider());
572:
573: if (!ctlr || !namePrefix || !*namePrefix)
574: return 0;
575:
576: // First, we need to determine the initial interface unit number.
577: // The current scheme needs a lot of work. Currently, motherboard
578: // devices gets unit 0, while add-on PCI cards are assigned
579: // unit 1 and up. Here, we need to determine whether this is an
580: // onboard or a PCI network controller.
581: //
582: if (ctlr->getProvider()) {
583: OSObject * propObject = ctlr->getProvider()->getProperty("built-in");
584:
585: if (!propObject) {
586: propObject = ctlr->getProvider()->getProperty("AAPL,slot-name");
587: if (propObject) {
588: unit = 1; // PCI add-on card
589:
590: // If we have an index number, increment
591: // the unit by the index number.
592: // (for multiport PCI cards).
593: ctlr->doGetControllerIndex(this, &index);
594: unit += index;
595: }
596: }
597: }
598:
599: // "unit" is now the initial unit number requested by the interface.
600: // If this unit number is already taken by an existing interface, we
601: // will automatically increment the unit number until there are no
602: // conflicts. We don't want to confuse BSD with identical names.
603: //
604: // Now try to reserve the chosen name.
605: //
606: if (!reserveNetworkInterfaceEntry(netif, namePrefix, &unit))
607: return 0;
608:
609: // Update the interface object with its assigned name.
610: //
611: sprintf(nameBuf, "%s%d", namePrefix, unit);
612: nameString = OSString::withCString(nameBuf);
613: if (nameString) {
614: //
615: // Now fill in the ifnet name fields.
616: //
617: netif->setInterfaceNameInt(namePrefix);
618: netif->setUnitNumberInt(unit);
619:
620: // Set the interface's kIOBSDName property.
621: //
622: netif->setProperty(kIOBSDName, nameString);
623: }
624:
625: return nameString;
626: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.