FreeBSD/Linux Kernel Cross Reference
sys/dev/sound/clone.c
1 /*-
2 * Copyright (c) 2007 Ariff Abdullah <ariff@FreeBSD.org>
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 *
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24 * SUCH DAMAGE.
25 *
26 * $FreeBSD: releng/9.0/sys/dev/sound/clone.c 193640 2009-06-07 19:12:08Z ariff $
27 */
28
29 #include <sys/param.h>
30 #include <sys/systm.h>
31 #include <sys/conf.h>
32 #include <sys/kernel.h>
33 #include <sys/malloc.h>
34 #include <sys/proc.h>
35
36 #ifdef HAVE_KERNEL_OPTION_HEADERS
37 #include "opt_snd.h"
38 #endif
39
40 #if defined(SND_DIAGNOSTIC) || defined(SND_DEBUG)
41 #include <dev/sound/pcm/sound.h>
42 #endif
43
44 #include <dev/sound/clone.h>
45
46 /*
47 * So here we go again, another clonedevs manager. Unlike default clonedevs,
48 * this clone manager is designed to withstand various abusive behavior
49 * (such as 'while : ; do ls /dev/whatever ; done', etc.), reusable object
50 * after reaching certain expiration threshold, aggressive garbage collector,
51 * transparent device allocator and concurrency handling across multiple
52 * thread/proc. Due to limited information given by dev_clone EVENTHANDLER,
53 * we don't have much clues whether the caller wants a real open() or simply
54 * making fun of us with things like stat(), mtime() etc. Assuming that:
55 * 1) Time window between dev_clone EH <-> real open() should be small
56 * enough and 2) mtime()/stat() etc. always looks like a half way / stalled
57 * operation, we can decide whether a new cdev must be created, old
58 * (expired) cdev can be reused or an existing cdev can be shared.
59 *
60 * Most of the operations and logics are generic enough and can be applied
61 * on other places (such as if_tap, snp, etc). Perhaps this can be
62 * rearranged to complement clone_*(). However, due to this still being
63 * specific to the sound driver (and as a proof of concept on how it can be
64 * done), si_drv2 is used to keep the pointer of the clone list entry to
65 * avoid expensive lookup.
66 */
67
68 /* clone entry */
69 struct snd_clone_entry {
70 TAILQ_ENTRY(snd_clone_entry) link;
71 struct snd_clone *parent;
72 struct cdev *devt;
73 struct timespec tsp;
74 uint32_t flags;
75 pid_t pid;
76 int unit;
77 };
78
79 /* clone manager */
80 struct snd_clone {
81 TAILQ_HEAD(link_head, snd_clone_entry) head;
82 struct timespec tsp;
83 int refcount;
84 int size;
85 int typemask;
86 int maxunit;
87 int deadline;
88 uint32_t flags;
89 };
90
91 #ifdef SND_DIAGNOSTIC
92 #define SND_CLONE_ASSERT(x, y) do { \
93 if (!(x)) \
94 panic y; \
95 } while (0)
96 #else
97 #define SND_CLONE_ASSERT(...) KASSERT(__VA_ARGS__)
98 #endif
99
100 /*
101 * Shamelessly ripped off from vfs_subr.c
102 * We need at least 1/HZ precision as default timestamping.
103 */
104 enum { SND_TSP_SEC, SND_TSP_HZ, SND_TSP_USEC, SND_TSP_NSEC };
105
106 static int snd_timestamp_precision = SND_TSP_HZ;
107 TUNABLE_INT("hw.snd.timestamp_precision", &snd_timestamp_precision);
108
109 void
110 snd_timestamp(struct timespec *tsp)
111 {
112 struct timeval tv;
113
114 switch (snd_timestamp_precision) {
115 case SND_TSP_SEC:
116 tsp->tv_sec = time_second;
117 tsp->tv_nsec = 0;
118 break;
119 case SND_TSP_HZ:
120 getnanouptime(tsp);
121 break;
122 case SND_TSP_USEC:
123 microuptime(&tv);
124 TIMEVAL_TO_TIMESPEC(&tv, tsp);
125 break;
126 case SND_TSP_NSEC:
127 nanouptime(tsp);
128 break;
129 default:
130 snd_timestamp_precision = SND_TSP_HZ;
131 getnanouptime(tsp);
132 break;
133 }
134 }
135
136 #if defined(SND_DIAGNOSTIC) || defined(SND_DEBUG)
137 static int
138 sysctl_hw_snd_timestamp_precision(SYSCTL_HANDLER_ARGS)
139 {
140 int err, val;
141
142 val = snd_timestamp_precision;
143 err = sysctl_handle_int(oidp, &val, 0, req);
144 if (err == 0 && req->newptr != NULL) {
145 switch (val) {
146 case SND_TSP_SEC:
147 case SND_TSP_HZ:
148 case SND_TSP_USEC:
149 case SND_TSP_NSEC:
150 snd_timestamp_precision = val;
151 break;
152 default:
153 break;
154 }
155 }
156
157 return (err);
158 }
159 SYSCTL_PROC(_hw_snd, OID_AUTO, timestamp_precision, CTLTYPE_INT | CTLFLAG_RW,
160 0, sizeof(int), sysctl_hw_snd_timestamp_precision, "I",
161 "timestamp precision (0=s 1=hz 2=us 3=ns)");
162 #endif
163
164 /*
165 * snd_clone_create() : Return opaque allocated clone manager.
166 */
167 struct snd_clone *
168 snd_clone_create(int typemask, int maxunit, int deadline, uint32_t flags)
169 {
170 struct snd_clone *c;
171
172 SND_CLONE_ASSERT(!(typemask & ~SND_CLONE_MAXUNIT),
173 ("invalid typemask: 0x%08x", typemask));
174 SND_CLONE_ASSERT(maxunit == -1 ||
175 !(maxunit & ~(~typemask & SND_CLONE_MAXUNIT)),
176 ("maxunit overflow: typemask=0x%08x maxunit=%d",
177 typemask, maxunit));
178 SND_CLONE_ASSERT(!(flags & ~SND_CLONE_MASK),
179 ("invalid clone flags=0x%08x", flags));
180
181 c = malloc(sizeof(*c), M_DEVBUF, M_WAITOK | M_ZERO);
182 c->refcount = 0;
183 c->size = 0;
184 c->typemask = typemask;
185 c->maxunit = (maxunit == -1) ? (~typemask & SND_CLONE_MAXUNIT) :
186 maxunit;
187 c->deadline = deadline;
188 c->flags = flags;
189 snd_timestamp(&c->tsp);
190 TAILQ_INIT(&c->head);
191
192 return (c);
193 }
194
195 int
196 snd_clone_busy(struct snd_clone *c)
197 {
198 struct snd_clone_entry *ce;
199
200 SND_CLONE_ASSERT(c != NULL, ("NULL snd_clone"));
201
202 if (c->size == 0)
203 return (0);
204
205 TAILQ_FOREACH(ce, &c->head, link) {
206 if ((ce->flags & SND_CLONE_BUSY) ||
207 (ce->devt != NULL && ce->devt->si_threadcount != 0))
208 return (EBUSY);
209 }
210
211 return (0);
212 }
213
214 /*
215 * snd_clone_enable()/disable() : Suspend/resume clone allocation through
216 * snd_clone_alloc(). Everything else will not be affected by this.
217 */
218 int
219 snd_clone_enable(struct snd_clone *c)
220 {
221 SND_CLONE_ASSERT(c != NULL, ("NULL snd_clone"));
222
223 if (c->flags & SND_CLONE_ENABLE)
224 return (EINVAL);
225
226 c->flags |= SND_CLONE_ENABLE;
227
228 return (0);
229 }
230
231 int
232 snd_clone_disable(struct snd_clone *c)
233 {
234 SND_CLONE_ASSERT(c != NULL, ("NULL snd_clone"));
235
236 if (!(c->flags & SND_CLONE_ENABLE))
237 return (EINVAL);
238
239 c->flags &= ~SND_CLONE_ENABLE;
240
241 return (0);
242 }
243
244 /*
245 * Getters / Setters. Not worth explaining :)
246 */
247 int
248 snd_clone_getsize(struct snd_clone *c)
249 {
250 SND_CLONE_ASSERT(c != NULL, ("NULL snd_clone"));
251
252 return (c->size);
253 }
254
255 int
256 snd_clone_getmaxunit(struct snd_clone *c)
257 {
258 SND_CLONE_ASSERT(c != NULL, ("NULL snd_clone"));
259
260 return (c->maxunit);
261 }
262
263 int
264 snd_clone_setmaxunit(struct snd_clone *c, int maxunit)
265 {
266 SND_CLONE_ASSERT(c != NULL, ("NULL snd_clone"));
267 SND_CLONE_ASSERT(maxunit == -1 ||
268 !(maxunit & ~(~c->typemask & SND_CLONE_MAXUNIT)),
269 ("maxunit overflow: typemask=0x%08x maxunit=%d",
270 c->typemask, maxunit));
271
272 c->maxunit = (maxunit == -1) ? (~c->typemask & SND_CLONE_MAXUNIT) :
273 maxunit;
274
275 return (c->maxunit);
276 }
277
278 int
279 snd_clone_getdeadline(struct snd_clone *c)
280 {
281 SND_CLONE_ASSERT(c != NULL, ("NULL snd_clone"));
282
283 return (c->deadline);
284 }
285
286 int
287 snd_clone_setdeadline(struct snd_clone *c, int deadline)
288 {
289 SND_CLONE_ASSERT(c != NULL, ("NULL snd_clone"));
290
291 c->deadline = deadline;
292
293 return (c->deadline);
294 }
295
296 int
297 snd_clone_gettime(struct snd_clone *c, struct timespec *tsp)
298 {
299 SND_CLONE_ASSERT(c != NULL, ("NULL snd_clone"));
300 SND_CLONE_ASSERT(tsp != NULL, ("NULL timespec"));
301
302 *tsp = c->tsp;
303
304 return (0);
305 }
306
307 uint32_t
308 snd_clone_getflags(struct snd_clone *c)
309 {
310 SND_CLONE_ASSERT(c != NULL, ("NULL snd_clone"));
311
312 return (c->flags);
313 }
314
315 uint32_t
316 snd_clone_setflags(struct snd_clone *c, uint32_t flags)
317 {
318 SND_CLONE_ASSERT(c != NULL, ("NULL snd_clone"));
319 SND_CLONE_ASSERT(!(flags & ~SND_CLONE_MASK),
320 ("invalid clone flags=0x%08x", flags));
321
322 c->flags = flags;
323
324 return (c->flags);
325 }
326
327 int
328 snd_clone_getdevtime(struct cdev *dev, struct timespec *tsp)
329 {
330 struct snd_clone_entry *ce;
331
332 SND_CLONE_ASSERT(dev != NULL, ("NULL dev"));
333 SND_CLONE_ASSERT(tsp != NULL, ("NULL timespec"));
334
335 ce = dev->si_drv2;
336 if (ce == NULL)
337 return (ENODEV);
338
339 SND_CLONE_ASSERT(ce->parent != NULL, ("NULL parent"));
340
341 *tsp = ce->tsp;
342
343 return (0);
344 }
345
346 uint32_t
347 snd_clone_getdevflags(struct cdev *dev)
348 {
349 struct snd_clone_entry *ce;
350
351 SND_CLONE_ASSERT(dev != NULL, ("NULL dev"));
352
353 ce = dev->si_drv2;
354 if (ce == NULL)
355 return (0xffffffff);
356
357 SND_CLONE_ASSERT(ce->parent != NULL, ("NULL parent"));
358
359 return (ce->flags);
360 }
361
362 uint32_t
363 snd_clone_setdevflags(struct cdev *dev, uint32_t flags)
364 {
365 struct snd_clone_entry *ce;
366
367 SND_CLONE_ASSERT(dev != NULL, ("NULL dev"));
368 SND_CLONE_ASSERT(!(flags & ~SND_CLONE_DEVMASK),
369 ("invalid clone dev flags=0x%08x", flags));
370
371 ce = dev->si_drv2;
372 if (ce == NULL)
373 return (0xffffffff);
374
375 SND_CLONE_ASSERT(ce->parent != NULL, ("NULL parent"));
376
377 ce->flags = flags;
378
379 return (ce->flags);
380 }
381
382 /* Elapsed time conversion to ms */
383 #define SND_CLONE_ELAPSED(x, y) \
384 ((((x)->tv_sec - (y)->tv_sec) * 1000) + \
385 (((y)->tv_nsec > (x)->tv_nsec) ? \
386 (((1000000000L + (x)->tv_nsec - \
387 (y)->tv_nsec) / 1000000) - 1000) : \
388 (((x)->tv_nsec - (y)->tv_nsec) / 1000000)))
389
390 #define SND_CLONE_EXPIRED(x, y, z) \
391 ((x)->deadline < 1 || \
392 ((y)->tv_sec - (z)->tv_sec) > ((x)->deadline / 1000) || \
393 SND_CLONE_ELAPSED(y, z) > (x)->deadline)
394
395 /*
396 * snd_clone_gc() : Garbage collector for stalled, expired objects. Refer to
397 * clone.h for explanations on GC settings.
398 */
399 int
400 snd_clone_gc(struct snd_clone *c)
401 {
402 struct snd_clone_entry *ce, *tce;
403 struct timespec now;
404 int pruned;
405
406 SND_CLONE_ASSERT(c != NULL, ("NULL snd_clone"));
407
408 if (!(c->flags & SND_CLONE_GC_ENABLE) || c->size == 0)
409 return (0);
410
411 snd_timestamp(&now);
412
413 /*
414 * Bail out if the last clone handler was invoked below the deadline
415 * threshold.
416 */
417 if ((c->flags & SND_CLONE_GC_EXPIRED) &&
418 !SND_CLONE_EXPIRED(c, &now, &c->tsp))
419 return (0);
420
421 pruned = 0;
422
423 /*
424 * Visit each object in reverse order. If the object is still being
425 * referenced by a valid open(), skip it. Look for expired objects
426 * and either revoke its clone invocation status or mercilessly
427 * throw it away.
428 */
429 TAILQ_FOREACH_REVERSE_SAFE(ce, &c->head, link_head, link, tce) {
430 if (!(ce->flags & SND_CLONE_BUSY) &&
431 (!(ce->flags & SND_CLONE_INVOKE) ||
432 SND_CLONE_EXPIRED(c, &now, &ce->tsp))) {
433 if ((c->flags & SND_CLONE_GC_REVOKE) ||
434 ce->devt->si_threadcount != 0) {
435 ce->flags &= ~SND_CLONE_INVOKE;
436 ce->pid = -1;
437 } else {
438 TAILQ_REMOVE(&c->head, ce, link);
439 destroy_dev(ce->devt);
440 free(ce, M_DEVBUF);
441 c->size--;
442 }
443 pruned++;
444 }
445 }
446
447 /* return total pruned objects */
448 return (pruned);
449 }
450
451 void
452 snd_clone_destroy(struct snd_clone *c)
453 {
454 struct snd_clone_entry *ce, *tmp;
455
456 SND_CLONE_ASSERT(c != NULL, ("NULL snd_clone"));
457
458 ce = TAILQ_FIRST(&c->head);
459 while (ce != NULL) {
460 tmp = TAILQ_NEXT(ce, link);
461 if (ce->devt != NULL)
462 destroy_dev(ce->devt);
463 free(ce, M_DEVBUF);
464 ce = tmp;
465 }
466
467 free(c, M_DEVBUF);
468 }
469
470 /*
471 * snd_clone_acquire() : The vital part of concurrency management. Must be
472 * called somewhere at the beginning of open() handler. ENODEV is not really
473 * fatal since it just tell the caller that this is not cloned stuff.
474 * EBUSY is *real*, don't forget that!
475 */
476 int
477 snd_clone_acquire(struct cdev *dev)
478 {
479 struct snd_clone_entry *ce;
480
481 SND_CLONE_ASSERT(dev != NULL, ("NULL dev"));
482
483 ce = dev->si_drv2;
484 if (ce == NULL)
485 return (ENODEV);
486
487 SND_CLONE_ASSERT(ce->parent != NULL, ("NULL parent"));
488
489 ce->flags &= ~SND_CLONE_INVOKE;
490
491 if (ce->flags & SND_CLONE_BUSY)
492 return (EBUSY);
493
494 ce->flags |= SND_CLONE_BUSY;
495
496 return (0);
497 }
498
499 /*
500 * snd_clone_release() : Release busy status. Must be called somewhere at
501 * the end of close() handler, or somewhere after fail open().
502 */
503 int
504 snd_clone_release(struct cdev *dev)
505 {
506 struct snd_clone_entry *ce;
507
508 SND_CLONE_ASSERT(dev != NULL, ("NULL dev"));
509
510 ce = dev->si_drv2;
511 if (ce == NULL)
512 return (ENODEV);
513
514 SND_CLONE_ASSERT(ce->parent != NULL, ("NULL parent"));
515
516 ce->flags &= ~SND_CLONE_INVOKE;
517
518 if (!(ce->flags & SND_CLONE_BUSY))
519 return (EBADF);
520
521 ce->flags &= ~SND_CLONE_BUSY;
522 ce->pid = -1;
523
524 return (0);
525 }
526
527 /*
528 * snd_clone_ref/unref() : Garbage collector reference counter. To make
529 * garbage collector run automatically, the sequence must be something like
530 * this (both in open() and close() handlers):
531 *
532 * open() - 1) snd_clone_acquire()
533 * 2) .... check check ... if failed, snd_clone_release()
534 * 3) Success. Call snd_clone_ref()
535 *
536 * close() - 1) .... check check check ....
537 * 2) Success. snd_clone_release()
538 * 3) snd_clone_unref() . Garbage collector will run at this point
539 * if this is the last referenced object.
540 */
541 int
542 snd_clone_ref(struct cdev *dev)
543 {
544 struct snd_clone_entry *ce;
545 struct snd_clone *c;
546
547 SND_CLONE_ASSERT(dev != NULL, ("NULL dev"));
548
549 ce = dev->si_drv2;
550 if (ce == NULL)
551 return (0);
552
553 c = ce->parent;
554 SND_CLONE_ASSERT(c != NULL, ("NULL parent"));
555 SND_CLONE_ASSERT(c->refcount >= 0, ("refcount < 0"));
556
557 return (++c->refcount);
558 }
559
560 int
561 snd_clone_unref(struct cdev *dev)
562 {
563 struct snd_clone_entry *ce;
564 struct snd_clone *c;
565
566 SND_CLONE_ASSERT(dev != NULL, ("NULL dev"));
567
568 ce = dev->si_drv2;
569 if (ce == NULL)
570 return (0);
571
572 c = ce->parent;
573 SND_CLONE_ASSERT(c != NULL, ("NULL parent"));
574 SND_CLONE_ASSERT(c->refcount > 0, ("refcount <= 0"));
575
576 c->refcount--;
577
578 /*
579 * Run automatic garbage collector, if needed.
580 */
581 if ((c->flags & SND_CLONE_GC_UNREF) &&
582 (!(c->flags & SND_CLONE_GC_LASTREF) ||
583 (c->refcount == 0 && (c->flags & SND_CLONE_GC_LASTREF))))
584 (void)snd_clone_gc(c);
585
586 return (c->refcount);
587 }
588
589 void
590 snd_clone_register(struct snd_clone_entry *ce, struct cdev *dev)
591 {
592 SND_CLONE_ASSERT(ce != NULL, ("NULL snd_clone_entry"));
593 SND_CLONE_ASSERT(dev != NULL, ("NULL dev"));
594 SND_CLONE_ASSERT(dev->si_drv2 == NULL, ("dev->si_drv2 not NULL"));
595 SND_CLONE_ASSERT((ce->flags & SND_CLONE_ALLOC) == SND_CLONE_ALLOC,
596 ("invalid clone alloc flags=0x%08x", ce->flags));
597 SND_CLONE_ASSERT(ce->devt == NULL, ("ce->devt not NULL"));
598 SND_CLONE_ASSERT(ce->unit == dev2unit(dev),
599 ("invalid unit ce->unit=0x%08x dev2unit=0x%08x",
600 ce->unit, dev2unit(dev)));
601
602 SND_CLONE_ASSERT(ce->parent != NULL, ("NULL parent"));
603
604 dev->si_drv2 = ce;
605 ce->devt = dev;
606 ce->flags &= ~SND_CLONE_ALLOC;
607 ce->flags |= SND_CLONE_INVOKE;
608 }
609
610 struct snd_clone_entry *
611 snd_clone_alloc(struct snd_clone *c, struct cdev **dev, int *unit, int tmask)
612 {
613 struct snd_clone_entry *ce, *after, *bce, *cce, *nce, *tce;
614 struct timespec now;
615 int cunit, allocunit;
616 pid_t curpid;
617
618 SND_CLONE_ASSERT(c != NULL, ("NULL snd_clone"));
619 SND_CLONE_ASSERT(dev != NULL, ("NULL dev pointer"));
620 SND_CLONE_ASSERT((c->typemask & tmask) == tmask,
621 ("invalid tmask: typemask=0x%08x tmask=0x%08x",
622 c->typemask, tmask));
623 SND_CLONE_ASSERT(unit != NULL, ("NULL unit pointer"));
624 SND_CLONE_ASSERT(*unit == -1 || !(*unit & (c->typemask | tmask)),
625 ("typemask collision: typemask=0x%08x tmask=0x%08x *unit=%d",
626 c->typemask, tmask, *unit));
627
628 if (!(c->flags & SND_CLONE_ENABLE) ||
629 (*unit != -1 && *unit > c->maxunit))
630 return (NULL);
631
632 ce = NULL;
633 after = NULL;
634 bce = NULL; /* "b"usy candidate */
635 cce = NULL; /* "c"urthread/proc candidate */
636 nce = NULL; /* "n"ull, totally unbusy candidate */
637 tce = NULL; /* Last "t"ry candidate */
638 cunit = 0;
639 allocunit = (*unit == -1) ? 0 : *unit;
640 curpid = curthread->td_proc->p_pid;
641
642 snd_timestamp(&now);
643
644 TAILQ_FOREACH(ce, &c->head, link) {
645 /*
646 * Sort incrementally according to device type.
647 */
648 if (tmask > (ce->unit & c->typemask)) {
649 if (cunit == 0)
650 after = ce;
651 continue;
652 } else if (tmask < (ce->unit & c->typemask))
653 break;
654
655 /*
656 * Shoot.. this is where the grumpiness begin. Just
657 * return immediately.
658 */
659 if (*unit != -1 && *unit == (ce->unit & ~tmask))
660 goto snd_clone_alloc_out;
661
662 cunit++;
663 /*
664 * Simmilar device type. Sort incrementally according
665 * to allocation unit. While here, look for free slot
666 * and possible collision for new / future allocation.
667 */
668 if (*unit == -1 && (ce->unit & ~tmask) == allocunit)
669 allocunit++;
670 if ((ce->unit & ~tmask) < allocunit)
671 after = ce;
672 /*
673 * Clone logic:
674 * 1. Look for non busy, but keep track of the best
675 * possible busy cdev.
676 * 2. Look for the best (oldest referenced) entry that is
677 * in a same process / thread.
678 * 3. Look for the best (oldest referenced), absolute free
679 * entry.
680 * 4. Lastly, look for the best (oldest referenced)
681 * any entries that doesn't fit with anything above.
682 */
683 if (ce->flags & SND_CLONE_BUSY) {
684 if (ce->devt != NULL && (bce == NULL ||
685 timespeccmp(&ce->tsp, &bce->tsp, <)))
686 bce = ce;
687 continue;
688 }
689 if (ce->pid == curpid &&
690 (cce == NULL || timespeccmp(&ce->tsp, &cce->tsp, <)))
691 cce = ce;
692 else if (!(ce->flags & SND_CLONE_INVOKE) &&
693 (nce == NULL || timespeccmp(&ce->tsp, &nce->tsp, <)))
694 nce = ce;
695 else if (tce == NULL || timespeccmp(&ce->tsp, &tce->tsp, <))
696 tce = ce;
697 }
698 if (*unit != -1)
699 goto snd_clone_alloc_new;
700 else if (cce != NULL) {
701 /* Same proc entry found, go for it */
702 ce = cce;
703 goto snd_clone_alloc_out;
704 } else if (nce != NULL) {
705 /*
706 * Next, try absolute free entry. If the calculated
707 * allocunit is smaller, create new entry instead.
708 */
709 if (allocunit < (nce->unit & ~tmask))
710 goto snd_clone_alloc_new;
711 ce = nce;
712 goto snd_clone_alloc_out;
713 } else if (allocunit > c->maxunit) {
714 /*
715 * Maximum allowable unit reached. Try returning any
716 * available cdev and hope for the best. If the lookup is
717 * done for things like stat(), mtime() etc. , things should
718 * be ok. Otherwise, open() handler should do further checks
719 * and decide whether to return correct error code or not.
720 */
721 if (tce != NULL) {
722 ce = tce;
723 goto snd_clone_alloc_out;
724 } else if (bce != NULL) {
725 ce = bce;
726 goto snd_clone_alloc_out;
727 }
728 return (NULL);
729 }
730
731 snd_clone_alloc_new:
732 /*
733 * No free entries found, and we still haven't reached maximum
734 * allowable units. Allocate, setup a minimal unique entry with busy
735 * status so nobody will monkey on this new entry. Unit magic is set
736 * right here to avoid collision with other contesting handler.
737 * The caller must be carefull here to maintain its own
738 * synchronization, as long as it will not conflict with malloc(9)
739 * operations.
740 *
741 * That said, go figure.
742 */
743 ce = malloc(sizeof(*ce), M_DEVBUF,
744 ((c->flags & SND_CLONE_WAITOK) ? M_WAITOK : M_NOWAIT) | M_ZERO);
745 if (ce == NULL) {
746 if (*unit != -1)
747 return (NULL);
748 /*
749 * We're being dense, ignorance is bliss,
750 * Super Regulatory Measure (TM).. TRY AGAIN!
751 */
752 if (nce != NULL) {
753 ce = nce;
754 goto snd_clone_alloc_out;
755 } else if (tce != NULL) {
756 ce = tce;
757 goto snd_clone_alloc_out;
758 } else if (bce != NULL) {
759 ce = bce;
760 goto snd_clone_alloc_out;
761 }
762 return (NULL);
763 }
764 /* Setup new entry */
765 ce->parent = c;
766 ce->unit = tmask | allocunit;
767 ce->pid = curpid;
768 ce->tsp = now;
769 ce->flags |= SND_CLONE_ALLOC;
770 if (after != NULL) {
771 TAILQ_INSERT_AFTER(&c->head, after, ce, link);
772 } else {
773 TAILQ_INSERT_HEAD(&c->head, ce, link);
774 }
775 c->size++;
776 c->tsp = now;
777 /*
778 * Save new allocation unit for caller which will be used
779 * by make_dev().
780 */
781 *unit = allocunit;
782
783 return (ce);
784
785 snd_clone_alloc_out:
786 /*
787 * Set, mark, timestamp the entry if this is a truly free entry.
788 * Leave busy entry alone.
789 */
790 if (!(ce->flags & SND_CLONE_BUSY)) {
791 ce->pid = curpid;
792 ce->tsp = now;
793 ce->flags |= SND_CLONE_INVOKE;
794 }
795 c->tsp = now;
796 *dev = ce->devt;
797
798 return (NULL);
799 }
Cache object: 56cc266ed5e4339e72f122e10a834fa9
|