![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to kmem.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / b / STREAMS / conf_79 / streams|
Return to kmem.c CVS log | Up to [MW Coherent from dump] / coherent / b / STREAMS / conf_79 / streams |
1.1 root 1: #define _DDI_DKI 1
2: #define _SYSV4 1
3:
4: /*
5: * STREAMS memory management code.
6: *
7: * This is layered on top of the fast first-fit heap allocator whose
8: * implementation is described in <sys/st_alloc.h>. The particulars of how
9: * STREAMS memory is allocated (including synchronisation and watermarks)
10: * is kept here so that the generic allocator is just that, generic.
11: */
12:
13: /*
14: *-IMPORTS:
15: * <common/ccompat.h>
16: * __USE_PROTO__
17: * __ARGS ()
18: * <common/ccompat.h>
19: * __LOCAL__
20: * <sys/debug.h>
21: * ASSERT ()
22: * <sys/types.h>
23: * _VOID
24: * size_t
25: * <sys/ksynch.h>
26: * lock_t
27: * LOCK_ALLOC ()
28: * LOCK ()
29: * UNLOCK ()
30: * <sys/cmn_err.h>
31: * CE_WARN
32: * cmn_err ()
33: */
34:
35: #include <common/ccompat.h>
36: #include <kernel/ddi_lock.h>
37: #include <sys/types.h>
38: #include <sys/debug.h>
39: #include <sys/ksynch.h>
40: #include <sys/cmn_err.h>
41:
42: #include <sys/kmem.h>
43: #include <kernel/strmlib.h>
44: #include <string.h>
45:
46:
47: /*
48: * Number of segments in the streams memory heap.
49: *
50: * For now, we'll just specify 256 segments, but this should probably be based
51: * on the log of the total number of words available.
52: */
53:
54: enum { str_segments = 256 };
55:
56:
57: /*
58: * Here we'll define the actual instance of the streams memory control
59: * structure.
60: */
61:
62: struct streams_mem str_mem [1];
63:
64:
65: /*
66: * We need to define information structures for the various locks and
67: * synchronization variables used in the above.
68: */
69:
70: __LOCAL__ lkinfo_t _stream_heap_lkinfo = {
71: "STREAMS message memory lock", INTERNAL_LOCK
72: };
73:
74: __LOCAL__ lkinfo_t _stream_seq_lkinfo = {
75: "STREAMS log sequence-number lock", INTERNAL_LOCK
76: };
77:
78: __LOCAL__ lkinfo_t _stream_proc_lkinfo = {
79: "STREAMS qprocsoff () lock", INTERNAL_LOCK
80: };
81:
82: __LOCAL__ lkinfo_t _stream_dir_lkinfo = {
83: "STREAM directory read/write lock", INTERNAL_LOCK
84: };
85:
86:
87: /*
88: * This local function gathers some of the aspects of streams message memory
89: * allocation into a single place (message blocks are allocated in allocb (),
90: * dupb (), and esballoc ()). We leave the initialization of the newly
91: * allocated memory up to the caller.
92: */
93:
94: #if __USE_PROTO__
95: mblk_t * (STRMEM_ALLOC) (size_t size, int pri, int flag)
96: #else
97: mblk_t *
98: STRMEM_ALLOC __ARGS ((size, pri, flag))
99: size_t size;
100: int pri;
101: int flag;
102: #endif
103: {
104: pl_t prev_pl;
105: mblk_t * mblkp;
106:
107: ASSERT (size > 0);
108: ASSERT (flag == KM_SLEEP || flag == KM_NOSLEEP);
109:
110: /*
111: * Note that if the size is one such that it cannot possibly ever be
112: * satisfied given the allocation watermarks we have set, then we just
113: * return failure now.
114: */
115:
116: pri = MAP_PRI_LEVEL (pri);
117:
118: if (size > str_mem->sm_max [pri])
119: return NULL;
120:
121:
122: for (;;) {
123: /*
124: * Lock the basic lock protecting access to the memory pool
125: * and attempt to acquire the memory we desire.
126: */
127:
128: prev_pl = LOCK (str_mem->sm_msg_lock, str_msg_pl);
129:
130:
131: /*
132: * Before allocating any memory, we check to see that it makes
133: * sense to give out that memory to the given priority level.
134: */
135:
136: if (str_mem->sm_used + size <= str_mem->sm_max [pri]) {
137: /*
138: * Try to get the memory, and if we do update the
139: * priority bookkeeping information to record the
140: * amount of memory that we have allowed out.
141: */
142:
143: mblkp = (mblk_t *) st_alloc (str_mem->sm_msg_heap,
144: size);
145:
146: if (mblkp != NULL) {
147:
148: str_mem->sm_used += size;
149: break;
150: }
151: }
152:
153:
154: /*
155: * Depending on the caller, we may sleep waiting for memory
156: * to become available.
157: */
158:
159: if (flag == KM_NOSLEEP) {
160:
161: mblkp = NULL;
162: break;
163: }
164:
165:
166: /*
167: * RESEARCH NOTE: This policy is a guess, no more. We need to
168: * do some profiling to find out what effect other policies
169: * might have. In particular, the wakeup heuristic could be
170: * altered to broadcast when we can satisfy the largest
171: * request.
172: */
173:
174: if (str_mem->sm_msg_needed == 0 ||
175: str_mem->sm_msg_needed > size)
176: str_mem->sm_msg_needed = size;
177:
178: SV_WAIT (str_mem->sm_msg_sv, prilo, str_mem->sm_msg_lock);
179: }
180:
181: UNLOCK (str_mem->sm_msg_lock, prev_pl);
182:
183: return mblkp;
184: }
185:
186:
187: /*
188: * This simple function factors out some common code from different calls to
189: * st_free () inside freeb (). This just reduces some of the cost of all the
190: * error checking that is my custom, and consolidates the interface to the
191: * bookkeeping for callback events and so forth.
192: *
193: * The streams heap must be locked on entry to this function.
194: */
195:
196: #if __USE_PROTO__
197: void (STRMEM_FREE) (mblk_t * bp, size_t size)
198: #else
199: void
200: STRMEM_FREE __ARGS ((bp, size))
201: mblk_t * bp;
202: size_t size;
203: #endif
204: {
205: int free_ok;
206:
207: ASSERT (TRYLOCK (str_mem->sm_msg_lock, str_msg_pl) == invpl);
208:
209: free_ok = st_free (str_mem->sm_msg_heap, bp, size);
210:
211: if (free_ok != 0) {
212: /*
213: * The heap manager has a problem with freeing the block that
214: * was passed to it, display a console diagnostic. For
215: * simplicity we display addresses as longs.
216: */
217:
218: cmn_err (CE_WARN,
219: "MSGB_FREE : st_free () complained with %d freeing %d bytes at %lx",
220: free_ok, size, (long) bp);
221: } else {
222: /*
223: * Update the allocation bookkeeping, and request that the
224: * routine that processes bufcall () events be run. This other
225: * procedure also has responsibility for waking up message and
226: * possibly "other" allocations if there is sufficient memory
227: * available.
228: */
229:
230: str_mem->sm_used -= size;
231:
232: SCHEDULE_BUFCALLS ();
233: }
234: }
235:
236:
237: /*
238: *-STATUS:
239: * DDI/DKI
240: *
241: *-NAME:
242: * kmem_alloc () Allocate space from kernel free memory.
243: *
244: *-SYNOPSIS:
245: * #include <sys/types.h>
246: * #include <sys/kmem.h>
247: *
248: * void * kmem_alloc (size_t size, int flag);
249: *
250: *-ARGUMENTS:
251: * size Number of bytes to allocate.
252: *
253: * flag Specifies whether the caller is willing to sleep
254: * waiting for memory. If "flag" is set to KM_SLEEP, the
255: * caller will sleep if necessary until the specified
256: * amount of memory is available. If "flag" is set to
257: * KM_NOSLEEP, the caller will not sleep, but
258: * kmem_alloc () will return NULL if the specified amount
259: * of memory is not immediately available.
260: *
261: *-DESCRIPTION:
262: * kmem_alloc () allocates "size" bytes of kernel memory and returns a
263: * pointer to the allocated memory.
264: *
265: *-RETURN VALUE:
266: * Upon successful completion, kmem_alloc () returns a pointer to the
267: * allocated memory. If KM_NOSLEEP is specified and sufficient memory is
268: * not immediately available, kmem_alloc () returns a NULL pointer. If
269: * "size" is set to 0, kmem_alloc () always returns NULL regardless of
270: * the value of "flag".
271: *
272: *-LEVEL:
273: * Base only if "flag" is set to KM_SLEEP. Base or interrupt if "flag" is
274: * set to KM_NOSLEEP.
275: *
276: *-NOTES:
277: * May sleep if "flag" is set to KM_SLEEP.
278: *
279: * Driver-defined basic locks and read/write locks may be held across
280: * calls to this function if "flag" is KM_NOSLEEP but may not be held if
281: * "flag" is KM_SLEEP.
282: *
283: * Driver-defined sleep locks may be held across calls to this function
284: * regardless of the value of "flag".
285: *
286: * Kernel memory is a limited resource and should be used judiciously.
287: * Memory allocated using kmem_alloc () should be freed as soon as
288: * possible. Drivers should not use local freelists for memory or similar
289: * schemes that cause the memory to be held for longer than necessary.
290: *
291: * The address returned by a successful call to kmem_alloc () is word-
292: * aligned.
293: *
294: *-SEE ALSO:
295: * kmem_free (), kmem_zalloc ()
296: */
297:
298: #if __USE_PROTO__
299: _VOID * (kmem_alloc) (size_t size, int flag)
300: #else
301: _VOID *
302: kmem_alloc __ARGS ((size, flag))
303: size_t size;
304: int flag;
305: #endif
306: {
307: _VOID * mem;
308: pl_t prev_pl;
309:
310: ASSERT (flag == KM_SLEEP || flag == KM_NOSLEEP);
311:
312: ASSERT (ATOMIC_FETCH_UCHAR (str_mem->sm_init) ||
313: str_mem->sm_other_lock != NULL);
314:
315: if (size == 0)
316: return NULL;
317:
318: for (;;) {
319: /*
320: * Lock the basic lock protecting access to the memory pool
321: * and attempt to acquire the memory we desire.
322: */
323:
324: if (str_mem->sm_other_lock != NULL)
325: prev_pl = LOCK (str_mem->sm_other_lock, str_other_pl);
326:
327: if ((mem = st_alloc (str_mem->sm_other_heap, size)) != NULL ||
328: flag == KM_NOSLEEP) {
329: OTHER_ALLOCED (size);
330: break;
331: }
332:
333: /*
334: * Since we cannot acquire the memory, but the caller is
335: * willing to wait, we wait on a synchronization variable
336: * for sufficient memory to be available. We record the
337: * minimum amount that will satisfy any outstanding wait so
338: * that kmem_free () need not perform broadcasts in a
339: * totally needless fashion.
340: *
341: * We have arbitrarily chosen a low scheduling priority for
342: * SV_WAIT ().
343: */
344: /*
345: * RESEARCH NOTE: This policy is a guess, no more. We need to
346: * do some profiling to find out what effect other policies
347: * might have. In particular, the wakeup heuristic could be
348: * altered to broadcast when we can satisfy the largest
349: * request.
350: */
351:
352: if (str_mem->sm_other_needed == 0 ||
353: str_mem->sm_other_needed > size)
354: str_mem->sm_other_needed = size;
355:
356: SV_WAIT (str_mem->sm_other_sv, prilo, str_mem->sm_other_lock);
357: }
358:
359: if (str_mem->sm_other_lock != NULL)
360: UNLOCK (str_mem->sm_other_lock, prev_pl);
361:
362: return mem;
363: }
364:
365:
366:
367: /*
368: *-STATUS:
369: * DDI/DKI
370: *
371: *-NAME:
372: * kmem_free () Free previously allocated kernel memory.
373: *
374: *-SYNOPSIS:
375: * #include <sys/types.h>
376: * #include <sys/kmem.h>
377: *
378: * void kmem_free (void * addr, size_t size);
379: *
380: *-ARGUMENTS:
381: * addr Address of the allocated memory to be returned. "addr"
382: * must specify the same address that was returned by the
383: * corresponding call to kmem_alloc () or kmem_zalloc ()
384: * which allocated the memory.
385: *
386: * size Number of bytes to free. The "size" parameter must
387: * specify the same number of bytes as was allocated by
388: * the corresponding call to kmem_alloc () or\
389: * kmem_zalloc ().
390: *
391: *-DESCRIPTION:
392: * kmem_free () returns "size" bytes of previously allocated kernel
393: * memory to the free pool. The "addr" and "size" arguments must specify
394: * exactly one complete area of memory that was allocated by a call to
395: * kmem_alloc () or kmem_zalloc () (that is, the memory cannot be freed
396: * piecemeal).
397: *
398: *-RETURN VALUE:
399: * None.
400: *
401: *-LEVEL:
402: * Base or Interrupt.
403: *
404: *-NOTES:
405: * Does not sleep.
406: *
407: * Driver-defined basic locks, read/write locks and sleep locks may be
408: * held across calls to this function.
409: *
410: *-SEE ALSO:
411: * kmem_alloc (), kmem_zalloc ()
412: */
413:
414: #if __USE_PROTO__
415: void (kmem_free) (_VOID * addr, size_t size)
416: #else
417: void
418: kmem_free __ARGS ((addr, size))
419: _VOID * addr;
420: size_t size;
421: #endif
422: {
423: pl_t prev_pl;
424: int free_ok;
425:
426: ASSERT (addr != NULL);
427: ASSERT (size > 0);
428:
429: ASSERT (ATOMIC_FETCH_UCHAR (str_mem->sm_init) ||
430: str_mem->sm_other_lock != NULL);
431:
432: /*
433: * Acquire the basic lock protecting access to the memory and free
434: * the caller's area. If there are processes waiting on memory
435: * becoming available, wake them up via a synchronization variable
436: * broadcast.
437: */
438:
439: if (str_mem->sm_other_lock != NULL)
440: prev_pl = LOCK (str_mem->sm_other_lock, str_other_pl);
441:
442: OTHER_FREED (size);
443:
444: free_ok = st_free (str_mem->sm_other_heap, addr, size);
445:
446: if (str_mem->sm_other_needed > 0 &&
447: str_mem->sm_other_needed <= st_maxavail (str_mem->sm_other_heap)) {
448: /*
449: * Wake up *all* the waiting processes and clear the marker
450: * to indicate that there are no waiting processes.
451: */
452:
453: SV_BROADCAST (str_mem->sm_other_sv, 0);
454: str_mem->sm_other_needed = 0;
455: }
456:
457: if (str_mem->sm_other_lock != NULL)
458: UNLOCK (str_mem->sm_other_lock, prev_pl);
459:
460: if (free_ok != 0) {
461: /*
462: * The heap manager has a problem with freeing the block that
463: * was passed to it, display a console diagnostic. For
464: * simplicity we display addresses as longs.
465: */
466:
467: cmn_err (CE_WARN,
468: "kmem_free : st_free () complained with %d freeing %d bytes at %lx",
469: free_ok, size, (long) addr);
470: }
471: }
472:
473:
474:
475: /*
476: *-STATUS:
477: * DDI/DKI
478: *
479: *-NAME:
480: * kmem_zalloc () Allocate and clear space from kernel free memory.
481: *
482: *-SYNOPSIS:
483: * #include <sys/types.h>
484: * #include <sys/kmem.h>
485: *
486: * void * kmem_zalloc (size_t size, int flag);
487: *
488: *-ARGUMENTS:
489: * size Number of bytes to allocate.
490: *
491: * flag Specifies whether the caller is willing to sleep
492: * waiting for memory. If "flag" is set to KM_SLEEP, the
493: * caller will sleep if necessary until the specified
494: * amount of memory is available. If "flag" is set to
495: * KM_NOSLEEP, the caller will not sleep, but
496: * kmem_zalloc () will return NULL if the specified
497: * amount of memory is not immediately available.
498: *
499: *-DESCRIPTION:
500: * kmem_zalloc () allocates "size" bytes of kernel memory, clears the
501: * memory by filling it with zeros, and returns a pointer to the
502: * allocated memory.
503: *
504: *-RETURN VALUE:
505: * Upon successful completion, kmem_zalloc () returns a pointer to the
506: * allocated memory. If KM_NOSLEEP is specified and sufficient memory is
507: * not immediately available, kmem_zalloc () returns a NULL pointer. If
508: * "size" is set to 0, kmem_zalloc () always returns NULL regardless of
509: * the value of "flag".
510: *
511: *-LEVEL:
512: * Base only if "flag" is set to KM_SLEEP. Base or interrupt if "flag" is
513: * set to KM_NOSLEEP.
514: *
515: *-NOTES:
516: * May sleep if "flag" is set to KM_SLEEP.
517: *
518: * Driver-defined basic locks and read/write locks may be held across
519: * calls to this function if "flag" is KM_NOSLEEP but may not be held if
520: * "flag" is KM_SLEEP.
521: *
522: * Driver-defined sleep locks may be held across calls to this function
523: * regardless of the value of "flag".
524: *
525: * Kernel memory is a limited resource and should be used judiciously.
526: * Memory allocated using kmem_zalloc () should be freed as soon as
527: * possible. Drivers should not use local freelists for memory or similar
528: * schemes that cause the memory to be held for longer than necessary.
529: *
530: * The address returned by a successful call to kmem_zalloc () is word-
531: * aligned.
532: *
533: *-SEE ALSO:
534: * kmem_alloc (), kmem_free ()
535: */
536:
537: #if __USE_PROTO__
538: _VOID * (kmem_zalloc) (size_t size, int flag)
539: #else
540: _VOID *
541: kmem_zalloc __ARGS ((size, flag))
542: size_t size;
543: int flag;
544: #endif
545: {
546: _VOID * mem;
547:
548: if ((mem = kmem_alloc (size, flag)) != NULL)
549: memset (mem, 0, size);
550: return mem;
551: }
552:
553:
554: /*
555: *-STATUS:
556: * Initialisation
557: *
558: *-DESCRIPTION:
559: * This function initializes the memory subsystem given a region of
560: * kernel virtual memory space to manage.
561: */
562:
563: __EXTERN_C__
564: #if __USE_PROTO__
565: int (STRMEM_INIT) (_VOID * addr, size_t size)
566: #else
567: int
568: STRMEM_INIT __ARGS ((addr, size))
569: _VOID * addr;
570: size_t size;
571: #endif
572: {
573: int i;
574:
575: /*
576: * We use a test-and-set lock operation on the streams memory
577: * structure so that the initialisation process is multiprocessor-
578: * safe. We don't use a basic lock since we don't know whether basic
579: * locks exist yet.
580: */
581:
582: if (ATOMIC_TEST_AND_SET_UCHAR (str_mem->sm_init) != 0) {
583: /*
584: * Presumably we are on a separate processor waiting for the
585: * initialization to be completed by someone else. To make
586: * this processor's call to STRMEM_INIT () behave with the
587: * right semantics, we wait for the other instance to complete
588: * the setup process.
589: */
590:
591: while (ATOMIC_FETCH_UCHAR (str_mem->sm_init) != 0) {
592: #ifdef __UNIPROCESSOR__
593: cmn_err (CE_PANIC, "Init startup deadlock???");
594: #endif
595: }
596: return 0;
597: }
598:
599: if (str_mem->sm_other_lock != NULL) {
600: /*
601: * The init has already been done, thanks!
602: */
603:
604: ATOMIC_CLEAR_UCHAR (str_mem->sm_init);
605: return 0;
606: }
607:
608: #ifdef SPLIT_STREAMS_MEMORY
609: #endif
610:
611: /*
612: * Now initialize the fast-first-fit heap manager.
613: *
614: * For now, we'll just specify 256 segments, but this
615: * should probably be based on the log of the total
616: * number of words available.
617: */
618:
619: str_mem->sm_msg_heap = (_ST_HEAP_CONTROL_P) addr;
620:
621: addr = (_VOID *) ((char *) addr +
622: _ST_HEAP_CONTROL_SIZE (str_segments));
623:
624: size -= _ST_HEAP_CONTROL_SIZE (str_segments);
625:
626: st_ctor (str_mem->sm_msg_heap, str_segments,
627: size / sizeof (_ST_WORD_T), (_ST_ADDR_T) addr);
628:
629: str_mem->sm_msg_lock =
630: LOCK_ALLOC (stream_heap_hierarchy, str_other_pl,
631: & _stream_heap_lkinfo, KM_NOSLEEP);
632:
633: str_mem->sm_msg_sv = SV_ALLOC (KM_NOSLEEP);
634:
635:
636: /*
637: * If either of the above allocations failed, we have some kind of
638: * major problem, so we exit without unlocking the initialization flag
639: * with an error indication.
640: */
641:
642: if (str_mem->sm_msg_lock == NULL || str_mem->sm_msg_sv == NULL) {
643:
644: init_error:
645: cmn_err (CE_PANIC, "Could not initialize STREAMS subsystem");
646: return -1;
647: }
648:
649:
650: /*
651: * Now we can calculate the watermarks... start at the
652: * top and make each lower one some percentage of the
653: * next higher one (say, 15/16 or 93%, so that it's
654: * easy to calculate).
655: */
656:
657: for (i = N_PRI_LEVELS ; i -- > 0 ;) {
658:
659: str_mem->sm_max [i] = size;
660:
661: size -= size >> 4; /* - 1/16 */
662: }
663:
664:
665: /*
666: * Do other kinds of initialization for the "str_mem" structure.
667: */
668:
669: for (i = N_PRI_LEVELS ; i -- > 0 ; ) {
670:
671: if (SELIST_INIT (& str_mem->sm_bcevents [i],
672: KM_SLEEP) == NULL)
673:
674: goto init_error;
675: }
676:
677:
678: str_mem->sm_seq_lock = LOCK_ALLOC (stream_seq_hierarchy, plstr,
679: & _stream_seq_lkinfo, KM_SLEEP);
680:
681: str_mem->sm_head_lock = RW_ALLOC (stream_dir_hierarchy, plstr,
682: & _stream_dir_lkinfo, KM_SLEEP);
683:
684: str_mem->sm_proc_lock = LOCK_ALLOC (stream_proc_hierarchy, plstr,
685: & _stream_proc_lkinfo, KM_SLEEP);
686:
687: str_mem->sm_proc_sv = SV_ALLOC (KM_SLEEP);
688:
689: if (SCHED_INIT (str_mem->sm_sched, KM_SLEEP) == NULL ||
690: str_mem->sm_seq_lock == NULL || str_mem->sm_head_lock == NULL ||
691: str_mem->sm_proc_lock == NULL || str_mem->sm_proc_sv == NULL)
692: goto init_error;
693:
694: /*
695: * All OK, let other CPUs proceed and return success to the caller.
696: */
697:
698: ATOMIC_CLEAR_UCHAR (str_mem->sm_init);
699:
700: return 0; /* all OK */
701: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.