op public repos

Blob

Date:: Fri Jan 10 14:54:30 2020 UTC
Message:: Trivial changes: whitespace and modes. Remote whitespace at the ends of lines. Remove blank lines from the ends of files. Change modes on source files so that they are not executable. Signed-off-by: Dan Cross <cross@gajendra.net>
Actions:: History | Blame | Raw File
1 #include <u.h>
2 #include <libc.h>
3 #include <venti.h>
4 #include <libsec.h>
5 
6 typedef struct Mem Mem;
7 typedef struct Frag Frag;
8 
9 enum {
10 	BigMemSize = MaxFragSize,
11 	SmallMemSize = BigMemSize/8,
12 	NLocalFrag = 2
13 };
14 
15 /* position to carve out of a Mem */
16 enum {
17 	PFront,
18 	PMiddle,
19 	PEnd
20 };
21 
22 struct Mem
23 {
24 	Lock lk;
25 	int ref;
26 	uchar *bp;
27 	uchar *ep;
28 	uchar *rp;
29 	uchar *wp;
30 	Mem *next;
31 };
32 
33 enum {
34 	FragLocalFree,
35 	FragLocalAlloc,
36 	FragGlobal
37 };
38 
39 struct Frag
40 {
41 	int state;
42 	Mem *mem;
43 	uchar *rp;
44 	uchar *wp;
45 	Frag *next;
46 	void (*free)(void*);
47 	void *a;
48 	Packet *p;	/* parent packet, for debugging only */
49 };
50 
51 struct Packet
52 {
53 	int size;
54 	int asize;  /* allocated memory - greater than size unless foreign frags */
55 	ulong pc;
56 
57 	Packet *next;
58 
59 	Frag *first;
60 	Frag *last;
61 
62 	Frag local[NLocalFrag];
63 };
64 
65 static Frag *fragalloc(Packet*, int n, int pos, Frag *next);
66 static Frag *fragdup(Packet*, Frag*);
67 static void fragfree(Frag*);
68 
69 static Mem *memalloc(int, int);
70 static void memfree(Mem*);
71 static int memhead(Mem *m, uchar *rp, int n);
72 static int memtail(Mem *m, uchar *wp, int n);
73 
74 static char EPacketSize[] = "bad packet size";
75 static char EPacketOffset[] = "bad packet offset";
76 static char EBadSize[] = "bad size";
77 
78 #ifdef NOTDEF
79 static void checkpacket(Packet*);
80 #endif
81 
82 /*
83  * the free list is primarily for speed, but it is
84  * also necessary for packetsplit that packets
85  * are never freed -- a packet can contain a different
86  * packet's local fragments, thanks to packetsplit!
87  */
88 static struct {
89 	Lock lk;
90 	Packet *packet;
91 	int npacket;
92 	Frag *frag;
93 	int nfrag;
94 	Mem *bigmem;
95 	int nbigmem;
96 	Mem *smallmem;
97 	int nsmallmem;
98 } freelist;
99 
100 #define FRAGSIZE(f) ((f)->wp - (f)->rp)
101 #define FRAGASIZE(f) ((f)->mem ? (f)->mem->ep - (f)->mem->bp : 0)
102 
103 #define NOTFREE(p) assert((p)->size>=0)/*; checkpacket(p)*/
104 
105 Packet *
106 packetalloc(void)
107 {
108 	Packet *p;
109 
110 	lock(&freelist.lk);
111 	p = freelist.packet;
112 	if(p != nil)
113 		freelist.packet = p->next;
114 	else
115 		freelist.npacket++;
116 	unlock(&freelist.lk);
117 
118 	if(p == nil)
119 		p = vtbrk(sizeof(Packet));
120 	else
121 		assert(p->size == -1);
122 	p->size = 0;
123 	p->asize = 0;
124 	p->first = nil;
125 	p->last = nil;
126 	p->next = nil;
127 	p->pc = getcallerpc((char*)&p+8);	/* might not work, but fine */
128 
129 	NOTFREE(p);
130 	return p;
131 }
132 
133 void
134 packetfree(Packet *p)
135 {
136 	Frag *f, *ff;
137 
138 	if(p == nil)
139 		return;
140 
141 	NOTFREE(p);
142 	p->pc = getcallerpc(&p);
143 
144 	for(f=p->first; f!=nil; f=ff) {
145 		ff = f->next;
146 		fragfree(f);
147 	}
148 	p->first = (void*)0xDeadBeef;
149 	p->last = (void*)0xDeadBeef;
150 	p->size = -1;
151 
152 	lock(&freelist.lk);
153 	p->next = freelist.packet;
154 	freelist.packet = p;
155 	unlock(&freelist.lk);
156 }
157 
158 Packet *
159 packetdup(Packet *p, int offset, int n)
160 {
161 	Frag *f, *ff;
162 	Packet *pp;
163 
164 	NOTFREE(p);
165 	if(offset < 0 || n < 0 || offset+n > p->size) {
166 		werrstr(EBadSize);
167 		return nil;
168 	}
169 
170 	pp = packetalloc();
171 	pp->pc = getcallerpc(&p);
172 	if(n == 0){
173 		NOTFREE(pp);
174 		return pp;
175 	}
176 
177 	pp->size = n;
178 
179 	/* skip offset */
180 	for(f=p->first; offset >= FRAGSIZE(f); f=f->next)
181 		offset -= FRAGSIZE(f);
182 
183 	/* first frag */
184 	ff = fragdup(pp, f);
185 	ff->rp += offset;
186 	pp->first = ff;
187 	n -= FRAGSIZE(ff);
188 	pp->asize += FRAGASIZE(ff);
189 
190 	/* the remaining */
191 	while(n > 0) {
192 		f = f->next;
193 		ff->next = fragdup(pp, f);
194 		ff = ff->next;
195 		n -= FRAGSIZE(ff);
196 		pp->asize += FRAGASIZE(ff);
197 	}
198 
199 	/* fix up last frag: note n <= 0 */
200 	ff->wp += n;
201 	ff->next = nil;
202 	pp->last = ff;
203 
204 	NOTFREE(pp);
205 	NOTFREE(p);
206 	return pp;
207 }
208 
209 Packet *
210 packetsplit(Packet *p, int n)
211 {
212 	Packet *pp;
213 	Frag *f, *ff;
214 
215 	NOTFREE(p);
216 	if(n < 0 || n > p->size) {
217 		werrstr(EPacketSize);
218 		return nil;
219 	}
220 
221 	pp = packetalloc();
222 	pp->pc = getcallerpc(&p);
223 	if(n == 0){
224 		NOTFREE(pp);
225 		return pp;
226 	}
227 
228 	pp->size = n;
229 	p->size -= n;
230 	ff = nil;
231 	for(f=p->first; n > 0 && n >= FRAGSIZE(f); f=f->next) {
232 		n -= FRAGSIZE(f);
233 		p->asize -= FRAGASIZE(f);
234 		pp->asize += FRAGASIZE(f);
235 		f->p = pp;
236 		ff = f;
237 	}
238 
239 	/* split shared frag */
240 	if(n > 0) {
241 		f->p = pp;
242 		ff = f;
243 		f = fragdup(p, ff);
244 		pp->asize += FRAGASIZE(ff);
245 		ff->wp = ff->rp + n;
246 		f->rp += n;
247 	}
248 
249 	pp->first = p->first;
250 	pp->last = ff;
251 	ff->next = nil;
252 	p->first = f;
253 	if(f == nil || f->next == nil)
254 		p->last = f;
255 	NOTFREE(pp);
256 	NOTFREE(p);
257 	return pp;
258 }
259 
260 int
261 packetconsume(Packet *p, uchar *buf, int n)
262 {
263 	NOTFREE(p);
264 	if(buf && packetcopy(p, buf, 0, n) < 0)
265 		return -1;
266 	return packettrim(p, n, p->size-n);
267 }
268 
269 int
270 packettrim(Packet *p, int offset, int n)
271 {
272 	Frag *f, *ff;
273 
274 	NOTFREE(p);
275 	if(offset < 0 || offset > p->size) {
276 		werrstr(EPacketOffset);
277 		return -1;
278 	}
279 
280 	if(n < 0 || offset + n > p->size) {
281 		werrstr(EPacketOffset);
282 		return -1;
283 	}
284 
285 	p->size = n;
286 
287 	/* easy case */
288 	if(n == 0) {
289 		for(f=p->first; f != nil; f=ff) {
290 			ff = f->next;
291 			fragfree(f);
292 		}
293 		p->first = p->last = nil;
294 		p->asize = 0;
295 		NOTFREE(p);
296 		return 0;
297 	}
298 
299 	/* free before offset */
300 	for(f=p->first; offset >= FRAGSIZE(f); f=ff) {
301 		p->asize -= FRAGASIZE(f);
302 		offset -= FRAGSIZE(f);
303 		ff = f->next;
304 		fragfree(f);
305 	}
306 
307 	/* adjust frag */
308 	f->rp += offset;
309 	p->first = f;
310 
311 	/* skip middle */
312 	for(; n > 0 && n > FRAGSIZE(f); f=f->next)
313 		n -= FRAGSIZE(f);
314 
315 	/* adjust end */
316 	f->wp = f->rp + n;
317 	p->last = f;
318 	ff = f->next;
319 	f->next = nil;
320 
321 	/* free after */
322 	for(f=ff; f != nil; f=ff) {
323 		p->asize -= FRAGASIZE(f);
324 		ff = f->next;
325 		fragfree(f);
326 	}
327 	NOTFREE(p);
328 	return 0;
329 }
330 
331 uchar *
332 packetheader(Packet *p, int n)
333 {
334 	Frag *f;
335 	Mem *m;
336 
337 	NOTFREE(p);
338 	if(n <= 0 || n > MaxFragSize) {
339 		werrstr(EPacketSize);
340 		return nil;
341 	}
342 
343 	p->size += n;
344 
345 	/* try and fix in current frag */
346 	f = p->first;
347 	if(f != nil) {
348 		m = f->mem;
349 		if(n <= f->rp - m->bp)
350 		if(m->ref == 1 || memhead(m, f->rp, n) >= 0) {
351 			f->rp -= n;
352 			NOTFREE(p);
353 			return f->rp;
354 		}
355 	}
356 
357 	/* add frag to front */
358 	f = fragalloc(p, n, PEnd, p->first);
359 	p->asize += FRAGASIZE(f);
360 	if(p->first == nil)
361 		p->last = f;
362 	p->first = f;
363 	NOTFREE(p);
364 	return f->rp;
365 }
366 
367 uchar *
368 packettrailer(Packet *p, int n)
369 {
370 	Mem *m;
371 	Frag *f;
372 
373 	NOTFREE(p);
374 	if(n <= 0 || n > MaxFragSize) {
375 		werrstr(EPacketSize);
376 		return nil;
377 	}
378 
379 	p->size += n;
380 
381 	/* try and fix in current frag */
382 	if(p->first != nil) {
383 		f = p->last;
384 		m = f->mem;
385 		if(n <= m->ep - f->wp)
386 		if(m->ref == 1 || memtail(m, f->wp, n) >= 0) {
387 			f->wp += n;
388 			NOTFREE(p);
389 			return f->wp - n;
390 		}
391 	}
392 
393 	/* add frag to end */
394 	f = fragalloc(p, n, (p->first == nil)?PMiddle:PFront, nil);
395 	p->asize += FRAGASIZE(f);
396 	if(p->first == nil)
397 		p->first = f;
398 	else
399 		p->last->next = f;
400 	p->last = f;
401 	NOTFREE(p);
402 	return f->rp;
403 }
404 
405 void
406 packetprefix(Packet *p, uchar *buf, int n)
407 {
408 	Frag *f;
409 	int nn;
410 	Mem *m;
411 
412 	NOTFREE(p);
413 	if(n <= 0)
414 		return;
415 
416 	p->size += n;
417 
418 	/* try and fix in current frag */
419 	f = p->first;
420 	if(f != nil) {
421 		m = f->mem;
422 		nn = f->rp - m->bp;
423 		if(nn > n)
424 			nn = n;
425 		if(m->ref == 1 || memhead(m, f->rp, nn) >= 0) {
426 			f->rp -= nn;
427 			n -= nn;
428 			memmove(f->rp, buf+n, nn);
429 		}
430 	}
431 
432 	while(n > 0) {
433 		nn = n;
434 		if(nn > MaxFragSize)
435 			nn = MaxFragSize;
436 		f = fragalloc(p, nn, PEnd, p->first);
437 		p->asize += FRAGASIZE(f);
438 		if(p->first == nil)
439 			p->last = f;
440 		p->first = f;
441 		n -= nn;
442 		memmove(f->rp, buf+n, nn);
443 	}
444 	NOTFREE(p);
445 }
446 
447 void
448 packetappend(Packet *p, uchar *buf, int n)
449 {
450 	Frag *f;
451 	int nn;
452 	Mem *m;
453 
454 	NOTFREE(p);
455 	if(n <= 0)
456 		return;
457 
458 	p->size += n;
459 	/* try and fix in current frag */
460 	if(p->first != nil) {
461 		f = p->last;
462 		m = f->mem;
463 		nn = m->ep - f->wp;
464 		if(nn > n)
465 			nn = n;
466 		if(m->ref == 1 || memtail(m, f->wp, nn) >= 0) {
467 			memmove(f->wp, buf, nn);
468 			f->wp += nn;
469 			buf += nn;
470 			n -= nn;
471 		}
472 	}
473 
474 	while(n > 0) {
475 		nn = n;
476 		if(nn > MaxFragSize)
477 			nn = MaxFragSize;
478 		f = fragalloc(p, nn, (p->first == nil)?PMiddle:PFront, nil);
479 		p->asize += FRAGASIZE(f);
480 		if(p->first == nil)
481 			p->first = f;
482 		else
483 			p->last->next = f;
484 		p->last = f;
485 		memmove(f->rp, buf, nn);
486 		buf += nn;
487 		n -= nn;
488 	}
489 	NOTFREE(p);
490 }
491 
492 void
493 packetconcat(Packet *p, Packet *pp)
494 {
495 	Frag *f;
496 
497 	NOTFREE(p);
498 	NOTFREE(pp);
499 	if(pp->size == 0)
500 		return;
501 	p->size += pp->size;
502 	p->asize += pp->asize;
503 	for(f=pp->first; f; f=f->next)
504 		f->p = p;
505 
506 	if(p->first != nil)
507 		p->last->next = pp->first;
508 	else
509 		p->first = pp->first;
510 
511 	p->last = pp->last;
512 	pp->size = 0;
513 	pp->asize = 0;
514 	pp->first = nil;
515 	pp->last = nil;
516 	NOTFREE(p);
517 	NOTFREE(pp);
518 }
519 
520 uchar *
521 packetpeek(Packet *p, uchar *buf, int offset, int n)
522 {
523 	Frag *f;
524 	int nn;
525 	uchar *b;
526 
527 	NOTFREE(p);
528 	if(n == 0)
529 		return buf;
530 
531 	if(offset < 0 || offset >= p->size) {
532 		werrstr(EPacketOffset);
533 		return nil;
534 	}
535 
536 	if(n < 0 || offset + n > p->size) {
537 		werrstr(EPacketSize);
538 		return nil;
539 	}
540 
541 	/* skip up to offset */
542 	for(f=p->first; offset >= FRAGSIZE(f); f=f->next)
543 		offset -= FRAGSIZE(f);
544 
545 	/* easy case */
546 	if(offset + n <= FRAGSIZE(f)){
547 		NOTFREE(p);
548 		return f->rp + offset;
549 	}
550 
551 	for(b=buf; n>0; n -= nn) {
552 		nn = FRAGSIZE(f) - offset;
553 		if(nn > n)
554 			nn = n;
555 		memmove(b, f->rp+offset, nn);
556 		offset = 0;
557 		f = f->next;
558 		b += nn;
559 	}
560 
561 	NOTFREE(p);
562 	return buf;
563 }
564 
565 int
566 packetcopy(Packet *p, uchar *buf, int offset, int n)
567 {
568 	uchar *b;
569 
570 	NOTFREE(p);
571 	b = packetpeek(p, buf, offset, n);
572 	if(b == nil)
573 		return -1;
574 	if(b != buf)
575 		memmove(buf, b, n);
576 	return 0;
577 }
578 
579 int
580 packetfragments(Packet *p, IOchunk *io, int nio, int offset)
581 {
582 	Frag *f;
583 	int size;
584 	IOchunk *eio;
585 
586 	NOTFREE(p);
587 	if(p->size == 0 || nio <= 0)
588 		return 0;
589 
590 	if(offset < 0 || offset > p->size) {
591 		werrstr(EPacketOffset);
592 		return -1;
593 	}
594 
595 	for(f=p->first; offset >= FRAGSIZE(f); f=f->next)
596 		offset -= FRAGSIZE(f);
597 
598 	size = 0;
599 	eio = io + nio;
600 	for(; f != nil && io < eio; f=f->next) {
601 		io->addr = f->rp + offset;
602 		io->len = f->wp - (f->rp + offset);
603 		offset = 0;
604 		size += io->len;
605 		io++;
606 	}
607 	for(; io < eio; io++){
608 		io->addr = nil;
609 		io->len = 0;
610 	}
611 	return size;
612 }
613 
614 void
615 packetstats(void)
616 {
617 	Packet *p;
618 	Frag *f;
619 	Mem *m;
620 
621 	int np, nf, nsm, nbm;
622 
623 	lock(&freelist.lk);
624 	np = 0;
625 	for(p=freelist.packet; p; p=p->next)
626 		np++;
627 	nf = 0;
628 	for(f=freelist.frag; f; f=f->next)
629 		nf++;
630 	nsm = 0;
631 	for(m=freelist.smallmem; m; m=m->next)
632 		nsm++;
633 	nbm = 0;
634 	for(m=freelist.bigmem; m; m=m->next)
635 		nbm++;
636 
637 	fprint(2, "packet: %d/%d frag: %d/%d small mem: %d/%d big mem: %d/%d\n",
638 		np, freelist.npacket,
639 		nf, freelist.nfrag,
640 		nsm, freelist.nsmallmem,
641 		nbm, freelist.nbigmem);
642 
643 	unlock(&freelist.lk);
644 }
645 
646 
647 uint
648 packetsize(Packet *p)
649 {
650 	NOTFREE(p);
651 	if(1) {
652 		Frag *f;
653 		int size = 0;
654 
655 		for(f=p->first; f; f=f->next)
656 			size += FRAGSIZE(f);
657 		if(size != p->size)
658 			fprint(2, "packetsize %d %d\n", size, p->size);
659 		assert(size == p->size);
660 	}
661 	return p->size;
662 }
663 
664 uint
665 packetasize(Packet *p)
666 {
667 	NOTFREE(p);
668 	if(0) {
669 		Frag *f;
670 		int asize = 0;
671 
672 		for(f=p->first; f; f=f->next)
673 			asize += FRAGASIZE(f);
674 		if(asize != p->asize)
675 			fprint(2, "packetasize %d %d\n", asize, p->asize);
676 		assert(asize == p->asize);
677 	}
678 	return p->asize;
679 }
680 
681 void
682 packetsha1(Packet *p, uchar digest[VtScoreSize])
683 {
684 	DigestState ds;
685 	Frag *f;
686 	int size;
687 
688 	NOTFREE(p);
689 	memset(&ds, 0, sizeof ds);
690 	size = p->size;
691 	for(f=p->first; f; f=f->next) {
692 		sha1(f->rp, FRAGSIZE(f), nil, &ds);
693 		size -= FRAGSIZE(f);
694 	}
695 	assert(size == 0);
696 	sha1(nil, 0, digest, &ds);
697 }
698 
699 int
700 packetcmp(Packet *pkt0, Packet *pkt1)
701 {
702 	Frag *f0, *f1;
703 	int n0, n1, x;
704 
705 	NOTFREE(pkt0);
706 	NOTFREE(pkt1);
707 	f0 = pkt0->first;
708 	f1 = pkt1->first;
709 
710 	if(f0 == nil)
711 		return (f1 == nil)?0:-1;
712 	if(f1 == nil)
713 		return 1;
714 	n0 = FRAGSIZE(f0);
715 	n1 = FRAGSIZE(f1);
716 
717 	for(;;) {
718 		if(n0 < n1) {
719 			x = memcmp(f0->wp - n0, f1->wp - n1, n0);
720 			if(x != 0)
721 				return x;
722 			n1 -= n0;
723 			f0 = f0->next;
724 			if(f0 == nil)
725 				return -1;
726 			n0 = FRAGSIZE(f0);
727 		} else if (n0 > n1) {
728 			x = memcmp(f0->wp - n0, f1->wp - n1, n1);
729 			if(x != 0)
730 				return x;
731 			n0 -= n1;
732 			f1 = f1->next;
733 			if(f1 == nil)
734 				return 1;
735 			n1 = FRAGSIZE(f1);
736 		} else { /* n0 == n1 */
737 			x = memcmp(f0->wp - n0, f1->wp - n1, n0);
738 			if(x != 0)
739 				return x;
740 			f0 = f0->next;
741 			f1 = f1->next;
742 			if(f0 == nil)
743 				return (f1 == nil)?0:-1;
744 			if(f1 == nil)
745 				return 1;
746 			n0 = FRAGSIZE(f0);
747 			n1 = FRAGSIZE(f1);
748 		}
749 	}
750 }
751 
752 static Frag *
753 fragalloc(Packet *p, int n, int pos, Frag *next)
754 {
755 	Frag *f, *ef;
756 	Mem *m;
757 
758 	/* look for local frag */
759 	f = &p->local[0];
760 	ef = &p->local[NLocalFrag];
761 	for(;f<ef; f++) {
762 		if(f->state == FragLocalFree) {
763 			f->state = FragLocalAlloc;
764 			goto Found;
765 		}
766 	}
767 	lock(&freelist.lk);
768 	f = freelist.frag;
769 	if(f != nil)
770 		freelist.frag = f->next;
771 	else
772 		freelist.nfrag++;
773 	unlock(&freelist.lk);
774 
775 	if(f == nil) {
776 		f = vtbrk(sizeof(Frag));
777 		f->state = FragGlobal;
778 	}
779 
780 Found:
781 	f->next = next;
782 	f->p = p;
783 
784 	if(n == 0){
785 		f->mem = 0;
786 		f->rp = 0;
787 		f->wp = 0;
788 		return f;
789 	}
790 
791 	if(pos == PEnd && next == nil)
792 		pos = PMiddle;
793 	m = memalloc(n, pos);
794 	f->mem = m;
795 	f->rp = m->rp;
796 	f->wp = m->wp;
797 	return f;
798 }
799 
800 Packet*
801 packetforeign(uchar *buf, int n, void (*free)(void *a), void *a)
802 {
803 	Packet *p;
804 	Frag *f;
805 
806 	p = packetalloc();
807 	p->pc = getcallerpc(&buf);
808 	f = fragalloc(p, 0, 0, nil);
809 	f->free = free;
810 	f->a = a;
811 	f->next = nil;
812 	f->rp = buf;
813 	f->wp = buf+n;
814 
815 	p->first = f;
816 	p->last = f;
817 	p->size = n;
818 	NOTFREE(p);
819 	return p;
820 }
821 
822 static Frag *
823 fragdup(Packet *p, Frag *f)
824 {
825 	Frag *ff;
826 	Mem *m;
827 
828 	m = f->mem;
829 
830 	/*
831 	 * m->rp && m->wp can be out of date when ref == 1
832 	 * also, potentially reclaims space from previous frags
833 	 */
834 	if(m && m->ref == 1) {
835 		m->rp = f->rp;
836 		m->wp = f->wp;
837 	}
838 
839 	ff = fragalloc(p, 0, 0, nil);
840 	ff->mem = f->mem;
841 	ff->rp = f->rp;
842 	ff->wp = f->wp;
843 	ff->next = f->next;
844 
845 	/*
846 	 * We can't duplicate these -- there's no dup function.
847 	 */
848 	assert(f->free==nil && f->a==nil);
849 
850 	if(m){
851 		lock(&m->lk);
852 		m->ref++;
853 		unlock(&m->lk);
854 	}
855 
856 
857 	return ff;
858 }
859 
860 
861 static void
862 fragfree(Frag *f)
863 {
864 	if(f->mem == nil){
865 		if(f->free)
866 			(*f->free)(f->a);
867 	}else{
868 		memfree(f->mem);
869 		f->mem = 0;
870 	}
871 
872 	if(f->state == FragLocalAlloc) {
873 		f->state = FragLocalFree;
874 		return;
875 	}
876 
877 	lock(&freelist.lk);
878 	f->next = freelist.frag;
879 	freelist.frag = f;
880 	unlock(&freelist.lk);
881 }
882 
883 static Mem *
884 memalloc(int n, int pos)
885 {
886 	Mem *m;
887 	int nn;
888 
889 	if(n < 0 || n > MaxFragSize) {
890 		werrstr(EPacketSize);
891 		return nil;
892 	}
893 	if(n <= SmallMemSize) {
894 		lock(&freelist.lk);
895 		m = freelist.smallmem;
896 		if(m != nil)
897 			freelist.smallmem = m->next;
898 		else
899 			freelist.nsmallmem++;
900 		unlock(&freelist.lk);
901 		nn = SmallMemSize;
902 	} else {
903 		lock(&freelist.lk);
904 		m = freelist.bigmem;
905 		if(m != nil)
906 			freelist.bigmem = m->next;
907 		else
908 			freelist.nbigmem++;
909 		unlock(&freelist.lk);
910 		nn = BigMemSize;
911 	}
912 
913 	if(m == nil) {
914 		m = vtbrk(sizeof(Mem));
915 		m->bp = vtbrk(nn);
916 		m->ep = m->bp + nn;
917 	}
918 	assert(m->ref == 0);
919 	m->ref = 1;
920 
921 	switch(pos) {
922 	default:
923 		assert(0);
924 	case PFront:
925 		m->rp = m->bp;
926 		break;
927 	case PMiddle:
928 		/* leave a little bit at end */
929 		m->rp = m->ep - n - 32;
930 		break;
931 	case PEnd:
932 		m->rp = m->ep - n;
933 		break;
934 	}
935 	/* check we did not blow it */
936 	if(m->rp < m->bp)
937 		m->rp = m->bp;
938 	m->wp = m->rp + n;
939 	assert(m->rp >= m->bp && m->wp <= m->ep);
940 	return m;
941 }
942 
943 static void
944 memfree(Mem *m)
945 {
946 	lock(&m->lk);
947 	m->ref--;
948 	if(m->ref > 0) {
949 		unlock(&m->lk);
950 		return;
951 	}
952 	unlock(&m->lk);
953 	assert(m->ref == 0);
954 
955 /*	memset(m->bp, 0xEF, m->ep-m->bp); */
956 	switch(m->ep - m->bp) {
957 	default:
958 		assert(0);
959 	case SmallMemSize:
960 		lock(&freelist.lk);
961 		m->next = freelist.smallmem;
962 		freelist.smallmem = m;
963 		unlock(&freelist.lk);
964 		break;
965 	case BigMemSize:
966 		lock(&freelist.lk);
967 		m->next = freelist.bigmem;
968 		freelist.bigmem = m;
969 		unlock(&freelist.lk);
970 		break;
971 	}
972 }
973 
974 static int
975 memhead(Mem *m, uchar *rp, int n)
976 {
977 	fprint(2, "memhead called\n");
978 	abort();
979 	lock(&m->lk);
980 	if(m->rp != rp) {
981 		unlock(&m->lk);
982 		return -1;
983 	}
984 	m->rp -= n;
985 	unlock(&m->lk);
986 	return 0;
987 }
988 
989 static int
990 memtail(Mem *m, uchar *wp, int n)
991 {
992 	fprint(2, "memtail called\n");
993 	abort();
994 	lock(&m->lk);
995 	if(m->wp != wp) {
996 		unlock(&m->lk);
997 		return -1;
998 	}
999 	m->wp += n;
1000 	unlock(&m->lk);
1001 	return 0;
1002 }
1003 
1004 #ifdef NOTDEF
1005 static void
1006 checkpacket(Packet *p)
1007 {
1008 	int s, as;
1009 	Frag *f;
1010 	Frag *ff;
1011 
1012 	s = 0;
1013 	as = 0;
1014 	ff=p->first;
1015 	for(f=p->first; f; ff=f,f=f->next){
1016 		assert(f->p == p);
1017 		s += FRAGSIZE(f);
1018 		as += FRAGASIZE(f);
1019 	}
1020 	assert(s == p->size);
1021 	assert(as == p->asize);
1022 	if(p->first)
1023 		assert(ff==p->last);
1024 }
1025 #endif