![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to packet.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / ntddk / src / network / tdi|
Return to packet.c CVS log | Up to [WindowsNT SDKs] / ntddk / src / network / tdi |
1.1 root 1: /*++
2:
3: Copyright (c) 1989-1993 Microsoft Corporation
4:
5: Module Name:
6:
7: packet.c
8:
9: Abstract:
10:
11: This module contains code that implements the TP_PACKET object, which
12: describes an NDIS packet.
13:
14: Environment:
15:
16: Kernel mode
17:
18: Revision History:
19:
20: --*/
21:
22: #include "st.h"
23:
24: //
25: // This is temporary; this is the quota that we charge for a receive
26: // packet for now, until we fix the problem with token-ring needing
27: // big packets and using all the memory. The number is the actual
28: // value for Ethernet.
29: //
30:
31: #if 1
32: #define RECEIVE_BUFFER_QUOTA(_DeviceContext) 1533
33: #else
34: #define RECEIVE_BUFFER_QUOTA(_DeviceContext) (_DeviceContext)->ReceiveBufferLength
35: #endif
36:
37:
38:
39:
40: VOID
41: StAllocateSendPacket(
42: IN PDEVICE_CONTEXT DeviceContext,
43: OUT PTP_PACKET *TransportSendPacket
44: )
45:
46: /*++
47:
48: Routine Description:
49:
50: This routine allocates storage for a send packet. Some initialization
51: is done here.
52:
53: NOTE: This routine is called with the device context spinlock
54: held, or at such a time as synchronization is unnecessary.
55:
56: Arguments:
57:
58: DeviceContext - Pointer to our device context to charge the packet to.
59:
60: TransportSendPacket - Returns a pointer to the packet, or NULL if no
61: storage can be allocated.
62:
63: Return Value:
64:
65: None.
66:
67: --*/
68:
69: {
70:
71: PTP_PACKET Packet;
72: NDIS_STATUS NdisStatus;
73: PNDIS_PACKET NdisPacket;
74: PSEND_PACKET_TAG SendTag;
75: PNDIS_BUFFER NdisBuffer;
76:
77: if ((DeviceContext->MemoryLimit != 0) &&
78: ((DeviceContext->MemoryUsage + DeviceContext->PacketLength) >
79: DeviceContext->MemoryLimit)) {
80: PANIC("ST: Could not allocate send packet: limit\n");
81: StWriteResourceErrorLog (DeviceContext, DeviceContext->PacketLength, 107);
82: *TransportSendPacket = NULL;
83: return;
84: }
85:
86: Packet = (PTP_PACKET)ExAllocatePool (NonPagedPool, DeviceContext->PacketLength);
87: if (Packet == NULL) {
88: PANIC("ST: Could not allocate send packet: no pool\n");
89: StWriteResourceErrorLog (DeviceContext, DeviceContext->PacketLength, 207);
90: *TransportSendPacket = NULL;
91: return;
92: }
93: RtlZeroMemory (Packet, DeviceContext->PacketLength);
94:
95: DeviceContext->MemoryUsage += DeviceContext->PacketLength;
96:
97: NdisAllocatePacket (
98: &NdisStatus,
99: &NdisPacket,
100: DeviceContext->SendPacketPoolHandle);
101:
102: if (NdisStatus != NDIS_STATUS_SUCCESS) {
103: ExFreePool (Packet);
104: StWriteResourceErrorLog (DeviceContext, 0, 307);
105: *TransportSendPacket = NULL;
106: return;
107: }
108:
109: NdisAllocateBuffer(
110: &NdisStatus,
111: &NdisBuffer,
112: DeviceContext->NdisBufferPoolHandle,
113: Packet->Header,
114: DeviceContext->PacketHeaderLength);
115:
116: if (NdisStatus != NDIS_STATUS_SUCCESS) {
117: NdisFreePacket (NdisPacket);
118: ExFreePool (Packet);
119: *TransportSendPacket = NULL;
120: return;
121: }
122:
123: NdisChainBufferAtFront (NdisPacket, NdisBuffer);
124:
125: Packet->NdisPacket = NdisPacket;
126: SendTag = (PSEND_PACKET_TAG)NdisPacket->ProtocolReserved;
127: SendTag->Type = TYPE_I_FRAME;
128: SendTag->Packet = Packet;
129: SendTag->Owner = NULL;
130:
131: Packet->Type = ST_PACKET_SIGNATURE;
132: Packet->Size = sizeof (TP_PACKET);
133: Packet->Provider = DeviceContext;
134:
135: ++DeviceContext->PacketAllocated;
136:
137: *TransportSendPacket = Packet;
138:
139: } /* StAllocateSendPacket */
140:
141:
142: VOID
143: StDeallocateSendPacket(
144: IN PDEVICE_CONTEXT DeviceContext,
145: IN PTP_PACKET TransportSendPacket
146: )
147:
148: /*++
149:
150: Routine Description:
151:
152: This routine frees storage for a send packet.
153:
154: NOTE: This routine is called with the device context spinlock
155: held, or at such a time as synchronization is unnecessary.
156:
157: Arguments:
158:
159: DeviceContext - Pointer to our device context to charge the packet to.
160:
161: TransportSendPacket - A pointer to the send packet.
162:
163: Return Value:
164:
165: None.
166:
167: --*/
168:
169: {
170: PNDIS_PACKET NdisPacket = TransportSendPacket->NdisPacket;
171: PNDIS_BUFFER NdisBuffer;
172:
173: NdisUnchainBufferAtFront (NdisPacket, &NdisBuffer);
174: if (NdisBuffer != NULL) {
175: NdisFreeBuffer (NdisBuffer);
176: }
177:
178: NdisFreePacket (NdisPacket);
179: ExFreePool (TransportSendPacket);
180:
181: --DeviceContext->PacketAllocated;
182: DeviceContext->MemoryUsage -= DeviceContext->PacketLength;
183:
184: } /* StDeallocateSendPacket */
185:
186:
187: VOID
188: StAllocateReceivePacket(
189: IN PDEVICE_CONTEXT DeviceContext,
190: OUT PNDIS_PACKET *TransportReceivePacket
191: )
192:
193: /*++
194:
195: Routine Description:
196:
197: This routine allocates storage for a receive packet. Some initialization
198: is done here.
199:
200: NOTE: This routine is called with the device context spinlock
201: held, or at such a time as synchronization is unnecessary.
202:
203: Arguments:
204:
205: DeviceContext - Pointer to our device context to charge the packet to.
206:
207: TransportReceivePacket - Returns a pointer to the packet, or NULL if no
208: storage can be allocated.
209:
210: Return Value:
211:
212: None.
213:
214: --*/
215:
216: {
217: NDIS_STATUS NdisStatus;
218: PNDIS_PACKET NdisPacket;
219: PRECEIVE_PACKET_TAG ReceiveTag;
220:
221: //
222: // This does not count in DeviceContext->MemoryUsage because
223: // the storage is allocated when we allocate the packet pool.
224: //
225:
226: NdisAllocatePacket (
227: &NdisStatus,
228: &NdisPacket,
229: DeviceContext->ReceivePacketPoolHandle);
230:
231: if (NdisStatus != NDIS_STATUS_SUCCESS) {
232: StWriteResourceErrorLog (DeviceContext, 0, 309);
233: *TransportReceivePacket = NULL;
234: return;
235: }
236:
237: ReceiveTag = (PRECEIVE_PACKET_TAG)(NdisPacket->ProtocolReserved);
238: ReceiveTag->PacketType = TYPE_AT_INDICATE;
239:
240: ++DeviceContext->ReceivePacketAllocated;
241:
242: *TransportReceivePacket = NdisPacket;
243:
244: } /* StAllocateReceivePacket */
245:
246:
247: VOID
248: StDeallocateReceivePacket(
249: IN PDEVICE_CONTEXT DeviceContext,
250: IN PNDIS_PACKET TransportReceivePacket
251: )
252:
253: /*++
254:
255: Routine Description:
256:
257: This routine frees storage for a receive packet.
258:
259: NOTE: This routine is called with the device context spinlock
260: held, or at such a time as synchronization is unnecessary.
261:
262: Arguments:
263:
264: DeviceContext - Pointer to our device context to charge the packet to.
265:
266: TransportReceivePacket - A pointer to the packet.
267:
268: Return Value:
269:
270: None.
271:
272: --*/
273:
274: {
275:
276: NdisFreePacket (TransportReceivePacket);
277:
278: --DeviceContext->ReceivePacketAllocated;
279:
280: } /* StDeallocateReceivePacket */
281:
282:
283: VOID
284: StAllocateReceiveBuffer(
285: IN PDEVICE_CONTEXT DeviceContext,
286: OUT PBUFFER_TAG *TransportReceiveBuffer
287: )
288:
289: /*++
290:
291: Routine Description:
292:
293: This routine allocates storage for a receive buffer. Some initialization
294: is done here.
295:
296: NOTE: This routine is called with the device context spinlock
297: held, or at such a time as synchronization is unnecessary.
298:
299: Arguments:
300:
301: DeviceContext - Pointer to our device context to charge the packet to.
302:
303: TransportReceiveBuffer - Returns a pointer to the buffer, or NULL if no
304: storage can be allocated.
305:
306: Return Value:
307:
308: None.
309:
310: --*/
311:
312: {
313: PBUFFER_TAG BufferTag;
314: NDIS_STATUS NdisStatus;
315: PNDIS_BUFFER NdisBuffer;
316:
317:
318: if ((DeviceContext->MemoryLimit != 0) &&
319: ((DeviceContext->MemoryUsage + RECEIVE_BUFFER_QUOTA(DeviceContext)) >
320: DeviceContext->MemoryLimit)) {
321: PANIC("ST: Could not allocate receive buffer: limit\n");
322: StWriteResourceErrorLog (DeviceContext, RECEIVE_BUFFER_QUOTA(DeviceContext), 108);
323: *TransportReceiveBuffer = NULL;
324: return;
325: }
326:
327: BufferTag = (PBUFFER_TAG)ExAllocatePool (
328: NonPagedPoolCacheAligned,
329: DeviceContext->ReceiveBufferLength);
330:
331: if (BufferTag == NULL) {
332: PANIC("ST: Could not allocate receive buffer: no pool\n");
333: StWriteResourceErrorLog (DeviceContext, DeviceContext->ReceiveBufferLength, 208);
334: *TransportReceiveBuffer = NULL;
335: return;
336: }
337:
338: DeviceContext->MemoryUsage += RECEIVE_BUFFER_QUOTA(DeviceContext);
339:
340: //
341: // point to the buffer for NDIS
342: //
343:
344: NdisAllocateBuffer(
345: &NdisStatus,
346: &NdisBuffer,
347: DeviceContext->NdisBufferPoolHandle,
348: BufferTag->Buffer,
349: DeviceContext->MaxReceivePacketSize);
350:
351: if (NdisStatus != NDIS_STATUS_SUCCESS) {
352: ExFreePool (BufferTag);
353: *TransportReceiveBuffer = NULL;
354: return;
355: }
356:
357: BufferTag->Length = DeviceContext->MaxReceivePacketSize;
358: BufferTag->NdisBuffer = NdisBuffer;
359:
360: ++DeviceContext->ReceiveBufferAllocated;
361:
362: *TransportReceiveBuffer = BufferTag;
363:
364: } /* StAllocateReceiveBuffer */
365:
366:
367: VOID
368: StDeallocateReceiveBuffer(
369: IN PDEVICE_CONTEXT DeviceContext,
370: IN PBUFFER_TAG TransportReceiveBuffer
371: )
372:
373: /*++
374:
375: Routine Description:
376:
377: This routine frees storage for a receive buffer.
378:
379: NOTE: This routine is called with the device context spinlock
380: held, or at such a time as synchronization is unnecessary.
381:
382: Arguments:
383:
384: DeviceContext - Pointer to our device context to charge the packet to.
385:
386: TransportReceiveBuffer - A pointer to the buffer.
387:
388: Return Value:
389:
390: None.
391:
392: --*/
393:
394: {
395:
396: NdisFreeBuffer (TransportReceiveBuffer->NdisBuffer);
397: ExFreePool (TransportReceiveBuffer);
398:
399: --DeviceContext->ReceiveBufferAllocated;
400: DeviceContext->MemoryUsage -= RECEIVE_BUFFER_QUOTA(DeviceContext);
401:
402: } /* StDeallocateReceiveBuffer */
403:
404:
405: NTSTATUS
406: StCreatePacket(
407: PDEVICE_CONTEXT DeviceContext,
408: PTP_PACKET *Packet
409: )
410:
411: /*++
412:
413: Routine Description:
414:
415: This routine allocates a packet from the device context's pool,
416: and prepares the MAC and DLC headers for use by the connection.
417:
418: Arguments:
419:
420: DeviceContext - Pointer to our device context to charge the packet to.
421:
422: Packet - Pointer to a place where we will return a pointer to the
423: allocated packet.
424:
425: Return Value:
426:
427: NTSTATUS - status of operation.
428:
429: --*/
430:
431: {
432: KIRQL oldirql;
433: PSINGLE_LIST_ENTRY s;
434: PTP_PACKET ThePacket;
435:
436: s = ExInterlockedPopEntryList (
437: &DeviceContext->PacketPool,
438: &DeviceContext->Interlock);
439:
440: if (s == NULL) {
441: ACQUIRE_SPIN_LOCK (&DeviceContext->SpinLock, &oldirql);
442: ++DeviceContext->PacketExhausted;
443: RELEASE_SPIN_LOCK (&DeviceContext->SpinLock, oldirql);
444: return STATUS_INSUFFICIENT_RESOURCES;
445: }
446:
447: ThePacket = CONTAINING_RECORD (s, TP_PACKET, Linkage);
448:
449: ThePacket->Provider = DeviceContext; // who owns this packet
450: ThePacket->PacketSent = FALSE;
451: ThePacket->PacketNoNdisBuffer = FALSE;
452:
453: *Packet = ThePacket; // return pointer to the packet.
454: return STATUS_SUCCESS;
455: } /* StCreatePacket */
456:
457:
458: VOID
459: StDestroyPacket(
460: PTP_PACKET Packet
461: )
462:
463: /*++
464:
465: Routine Description:
466:
467: This routine destroys a packet, thereby returning it to the pool. If
468: it is determined that there is at least one connection waiting for a
469: packet to become available (and it just has), then the connection is
470: removed from the device context's list and AdvanceSend is called to
471: prep the connection further.
472:
473: Arguments:
474:
475: Packet - Pointer to a packet to be returned to the pool.
476:
477: Return Value:
478:
479: none.
480:
481: --*/
482:
483: {
484: KIRQL oldirql1;
485: PDEVICE_CONTEXT DeviceContext;
486: PTP_CONNECTION Connection;
487: PLIST_ENTRY p;
488: PNDIS_BUFFER HeaderBuffer;
489: PNDIS_BUFFER NdisBuffer;
490:
491:
492: //
493: // Strip off and unmap the buffers describing data and header.
494: //
495:
496: NdisUnchainBufferAtFront (Packet->NdisPacket, &HeaderBuffer);
497:
498: // data buffers get thrown away
499:
500: if (Packet->PacketNoNdisBuffer) {
501:
502: //
503: // If the NDIS_BUFFER chain is not ours, then we can't
504: // start unchaining since that would mess up the queue;
505: // instead we just drop the rest of the chain.
506: //
507:
508: NdisReinitializePacket (Packet->NdisPacket);
509:
510: } else {
511:
512: //
513: // Return all the NDIS_BUFFERs to the system.
514: //
515:
516: NdisUnchainBufferAtFront (Packet->NdisPacket, &NdisBuffer);
517: while (NdisBuffer != NULL) {
518: NdisFreeBuffer (NdisBuffer);
519: NdisUnchainBufferAtFront (Packet->NdisPacket, &NdisBuffer);
520: }
521:
522: }
523:
524: ASSERT (HeaderBuffer != NULL);
525: NDIS_BUFFER_LINKAGE(HeaderBuffer) = (PNDIS_BUFFER)NULL;
526:
527: NdisChainBufferAtFront (Packet->NdisPacket, HeaderBuffer);
528:
529:
530: //
531: // Put the packet back for use again.
532: //
533:
534: DeviceContext = Packet->Provider;
535:
536: ExInterlockedPushEntryList (
537: &DeviceContext->PacketPool,
538: (PSINGLE_LIST_ENTRY)&Packet->Linkage,
539: &DeviceContext->Interlock);
540:
541: //
542: // If there is a connection waiting to ship out more packets, then
543: // wake it up and start packetizing again.
544: //
545: // We do a quick check without the lock; there is a small
546: // window where we may not take someone off, but this
547: // window exists anyway and we assume that more packets
548: // will be freed in the future.
549: //
550:
551: if (IsListEmpty (&DeviceContext->PacketWaitQueue)) {
552: return;
553: }
554:
555: p = ExInterlockedRemoveHeadList(
556: &DeviceContext->PacketWaitQueue,
557: &DeviceContext->SpinLock);
558:
559: if (p != NULL) {
560:
561: //
562: // Remove a connection from the "packet starved" queue.
563: //
564:
565: Connection = CONTAINING_RECORD (p, TP_CONNECTION, PacketWaitLinkage);
566: ACQUIRE_SPIN_LOCK (&Connection->SpinLock, &oldirql1);
567: Connection->Flags &= ~CONNECTION_FLAGS_SUSPENDED;
568:
569: //
570: // Place the connection on the packetize queue and start
571: // packetizing the next connection to be serviced. If he
572: // is already on the packetize queue for some reason, then
573: // don't do this.
574: //
575:
576: Connection->SendState = CONNECTION_SENDSTATE_PACKETIZE;
577:
578: if (!(Connection->Flags & CONNECTION_FLAGS_STOPPING) &&
579: !(Connection->Flags & CONNECTION_FLAGS_PACKETIZE)) {
580:
581: Connection->Flags |= CONNECTION_FLAGS_PACKETIZE;
582:
583: StReferenceConnection ("Packet available", Connection);
584:
585: ExInterlockedInsertTailList(
586: &DeviceContext->PacketizeQueue,
587: &Connection->PacketizeLinkage,
588: &DeviceContext->SpinLock);
589: }
590:
591: RELEASE_SPIN_LOCK (&Connection->SpinLock, oldirql1);
592: PacketizeConnections (DeviceContext);
593:
594: }
595:
596: } /* StDestroyPacket */
597:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.