2 * Copyright 1998 Massachusetts Institute of Technology
4 * Permission to use, copy, modify, and distribute this software and
5 * its documentation for any purpose and without fee is hereby
6 * granted, provided that both the above copyright notice and this
7 * permission notice appear in all copies, that both the above
8 * copyright notice and this permission notice appear in all
9 * supporting documentation, and that the name of M.I.T. not be used
10 * in advertising or publicity pertaining to distribution of the
11 * software without specific, written prior permission. M.I.T. makes
12 * no representations about the suitability of this software for any
13 * purpose. It is provided "as is" without express or implied
16 * THIS SOFTWARE IS PROVIDED BY M.I.T. ``AS IS''. M.I.T. DISCLAIMS
17 * ALL EXPRESS OR IMPLIED WARRANTIES WITH REGARD TO THIS SOFTWARE,
18 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
19 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT
20 * SHALL M.I.T. BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
21 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
22 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
23 * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
24 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
25 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
26 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29 * $FreeBSD: src/sys/kern/subr_rman.c,v 1.10.2.1 2001/06/05 08:06:08 imp Exp $
30 * $DragonFly: src/sys/kern/subr_rman.c,v 1.15 2008/09/30 12:20:29 hasso Exp $
34 * The kernel resource manager. This code is responsible for keeping track
35 * of hardware resources which are apportioned out to various drivers.
36 * It does not actually assign those resources, and it is not expected
37 * that end-device drivers will call into this code directly. Rather,
38 * the code which implements the buses that those devices are attached to,
39 * and the code which manages CPU resources, will call this code, and the
40 * end-device drivers will make upcalls to that code to actually perform
43 * There are two sorts of resources managed by this code. The first is
44 * the more familiar array (RMAN_ARRAY) type; resources in this class
45 * consist of a sequence of individually-allocatable objects which have
46 * been numbered in some well-defined order. Most of the resources
47 * are of this type, as it is the most familiar. The second type is
48 * called a gauge (RMAN_GAUGE), and models fungible resources (i.e.,
49 * resources in which each instance is indistinguishable from every
50 * other instance). The principal anticipated application of gauges
51 * is in the context of power consumption, where a bus may have a specific
52 * power budget which all attached devices share. RMAN_GAUGE is not
55 * For array resources, we make one simplifying assumption: two clients
56 * sharing the same resource must use the same range of indices. That
57 * is to say, sharing of overlapping-but-not-identical regions is not
61 #include <sys/param.h>
62 #include <sys/systm.h>
63 #include <sys/kernel.h>
65 #include <sys/malloc.h>
66 #include <sys/bus.h> /* XXX debugging */
68 #include <sys/sysctl.h>
71 TUNABLE_INT("debug.rman_debug", &rman_debug
);
72 SYSCTL_INT(_debug
, OID_AUTO
, rman_debug
, CTLFLAG_RW
,
73 &rman_debug
, 0, "rman debug");
75 #define DPRINTF(params) if (rman_debug) kprintf params
77 static MALLOC_DEFINE(M_RMAN
, "rman", "Resource manager");
79 struct rman_head rman_head
;
80 static struct lwkt_token rman_tok
; /* mutex to protect rman_head */
81 static int int_rman_activate_resource(struct rman
*rm
, struct resource
*r
,
82 struct resource
**whohas
);
83 static int int_rman_deactivate_resource(struct resource
*r
);
84 static int int_rman_release_resource(struct rman
*rm
, struct resource
*r
);
87 rman_init(struct rman
*rm
, int cpuid
)
93 TAILQ_INIT(&rman_head
);
94 lwkt_token_init(&rman_tok
, "rman");
97 if (rm
->rm_type
== RMAN_UNINIT
)
99 if (rm
->rm_type
== RMAN_GAUGE
)
100 panic("implement RMAN_GAUGE");
102 TAILQ_INIT(&rm
->rm_list
);
103 rm
->rm_slock
= kmalloc(sizeof *rm
->rm_slock
, M_RMAN
, M_NOWAIT
);
104 if (rm
->rm_slock
== NULL
)
106 lwkt_token_init(rm
->rm_slock
, "rmanslock");
108 rm
->rm_cpuid
= cpuid
;
110 lwkt_gettoken(&rman_tok
);
111 TAILQ_INSERT_TAIL(&rman_head
, rm
, rm_link
);
112 lwkt_reltoken(&rman_tok
);
117 * NB: this interface is not robust against programming errors which
118 * add multiple copies of the same region.
121 rman_manage_region(struct rman
*rm
, u_long start
, u_long end
)
123 struct resource
*r
, *s
;
125 DPRINTF(("rman_manage_region: <%s> request: start %#lx, end %#lx\n",
126 rm
->rm_descr
, start
, end
));
127 r
= kmalloc(sizeof *r
, M_RMAN
, M_NOWAIT
| M_ZERO
);
137 lwkt_gettoken(rm
->rm_slock
);
138 for (s
= TAILQ_FIRST(&rm
->rm_list
);
139 s
&& s
->r_end
< r
->r_start
;
140 s
= TAILQ_NEXT(s
, r_link
))
144 TAILQ_INSERT_TAIL(&rm
->rm_list
, r
, r_link
);
146 TAILQ_INSERT_BEFORE(s
, r
, r_link
);
148 lwkt_reltoken(rm
->rm_slock
);
153 rman_fini(struct rman
*rm
)
157 lwkt_gettoken(rm
->rm_slock
);
158 TAILQ_FOREACH(r
, &rm
->rm_list
, r_link
) {
159 if (r
->r_flags
& RF_ALLOCATED
) {
160 lwkt_reltoken(rm
->rm_slock
);
166 * There really should only be one of these if we are in this
167 * state and the code is working properly, but it can't hurt.
169 while (!TAILQ_EMPTY(&rm
->rm_list
)) {
170 r
= TAILQ_FIRST(&rm
->rm_list
);
171 TAILQ_REMOVE(&rm
->rm_list
, r
, r_link
);
174 lwkt_reltoken(rm
->rm_slock
);
176 /* XXX what's the point of this if we are going to free the struct? */
177 lwkt_gettoken(&rman_tok
);
178 TAILQ_REMOVE(&rman_head
, rm
, rm_link
);
179 lwkt_reltoken(&rman_tok
);
180 kfree(rm
->rm_slock
, M_RMAN
);
186 rman_reserve_resource(struct rman
*rm
, u_long start
, u_long end
, u_long count
,
187 u_int flags
, struct device
*dev
)
190 struct resource
*r
, *s
, *rv
;
195 DPRINTF(("rman_reserve_resource: <%s> request: [%#lx, %#lx], length "
196 "%#lx, flags %u, device %s\n", rm
->rm_descr
, start
, end
,
198 dev
== NULL
? "<null>" : device_get_nameunit(dev
)));
199 want_activate
= (flags
& RF_ACTIVE
);
202 lwkt_gettoken(rm
->rm_slock
);
204 for (r
= TAILQ_FIRST(&rm
->rm_list
);
205 r
&& r
->r_end
< start
;
206 r
= TAILQ_NEXT(r
, r_link
))
210 DPRINTF(("could not find a region\n"));
215 * First try to find an acceptable totally-unshared region.
217 for (s
= r
; s
; s
= TAILQ_NEXT(s
, r_link
)) {
218 DPRINTF(("considering [%#lx, %#lx]\n", s
->r_start
, s
->r_end
));
219 if (s
->r_start
> end
) {
220 DPRINTF(("s->r_start (%#lx) > end (%#lx)\n",
224 if (s
->r_flags
& RF_ALLOCATED
) {
225 DPRINTF(("region is allocated\n"));
228 rstart
= max(s
->r_start
, start
);
229 rstart
= (rstart
+ ((1ul << RF_ALIGNMENT(flags
))) - 1) &
230 ~((1ul << RF_ALIGNMENT(flags
)) - 1);
231 rend
= min(s
->r_end
, max(start
+ count
, end
));
232 DPRINTF(("truncated region: [%#lx, %#lx]; size %#lx (requested %#lx)\n",
233 rstart
, rend
, (rend
- rstart
+ 1), count
));
235 if ((rend
- rstart
+ 1) >= count
) {
236 DPRINTF(("candidate region: [%#lx, %#lx], size %#lx\n",
237 rstart
, rend
, (rend
- rstart
+ 1)));
238 if ((s
->r_end
- s
->r_start
+ 1) == count
) {
239 DPRINTF(("candidate region is entire chunk\n"));
241 rv
->r_flags
|= RF_ALLOCATED
| flags
;
247 * If s->r_start < rstart and
248 * s->r_end > rstart + count - 1, then
249 * we need to split the region into three pieces
250 * (the middle one will get returned to the user).
251 * Otherwise, we are allocating at either the
252 * beginning or the end of s, so we only need to
253 * split it in two. The first case requires
254 * two new allocations; the second requires but one.
256 rv
= kmalloc(sizeof *rv
, M_RMAN
, M_NOWAIT
| M_ZERO
);
259 rv
->r_start
= rstart
;
260 rv
->r_end
= rstart
+ count
- 1;
261 rv
->r_flags
= flags
| RF_ALLOCATED
;
266 if (s
->r_start
< rv
->r_start
&& s
->r_end
> rv
->r_end
) {
267 DPRINTF(("splitting region in three parts: "
268 "[%#lx, %#lx]; [%#lx, %#lx]; [%#lx, %#lx]\n",
269 s
->r_start
, rv
->r_start
- 1,
270 rv
->r_start
, rv
->r_end
,
271 rv
->r_end
+ 1, s
->r_end
));
273 * We are allocating in the middle.
275 r
= kmalloc(sizeof *r
, M_RMAN
,
282 r
->r_start
= rv
->r_end
+ 1;
284 r
->r_flags
= s
->r_flags
;
288 s
->r_end
= rv
->r_start
- 1;
289 TAILQ_INSERT_AFTER(&rm
->rm_list
, s
, rv
,
291 TAILQ_INSERT_AFTER(&rm
->rm_list
, rv
, r
,
293 } else if (s
->r_start
== rv
->r_start
) {
294 DPRINTF(("allocating from the beginning\n"));
296 * We are allocating at the beginning.
298 s
->r_start
= rv
->r_end
+ 1;
299 TAILQ_INSERT_BEFORE(s
, rv
, r_link
);
301 DPRINTF(("allocating at the end\n"));
303 * We are allocating at the end.
305 s
->r_end
= rv
->r_start
- 1;
306 TAILQ_INSERT_AFTER(&rm
->rm_list
, s
, rv
,
314 * Now find an acceptable shared region, if the client's requirements
315 * allow sharing. By our implementation restriction, a candidate
316 * region must match exactly by both size and sharing type in order
317 * to be considered compatible with the client's request. (The
318 * former restriction could probably be lifted without too much
319 * additional work, but this does not seem warranted.)
321 DPRINTF(("no unshared regions found\n"));
322 if ((flags
& (RF_SHAREABLE
| RF_TIMESHARE
)) == 0)
325 for (s
= r
; s
; s
= TAILQ_NEXT(s
, r_link
)) {
326 if (s
->r_start
> end
)
328 if ((s
->r_flags
& flags
) != flags
)
330 rstart
= max(s
->r_start
, start
);
331 rend
= min(s
->r_end
, max(start
+ count
, end
));
332 if (s
->r_start
>= start
&& s
->r_end
<= end
333 && (s
->r_end
- s
->r_start
+ 1) == count
) {
334 rv
= kmalloc(sizeof *rv
, M_RMAN
, M_NOWAIT
| M_ZERO
);
337 rv
->r_start
= s
->r_start
;
338 rv
->r_end
= s
->r_end
;
339 rv
->r_flags
= s
->r_flags
&
340 (RF_ALLOCATED
| RF_SHAREABLE
| RF_TIMESHARE
);
343 if (s
->r_sharehead
== 0) {
344 s
->r_sharehead
= kmalloc(sizeof *s
->r_sharehead
,
347 if (s
->r_sharehead
== 0) {
352 LIST_INIT(s
->r_sharehead
);
353 LIST_INSERT_HEAD(s
->r_sharehead
, s
,
355 s
->r_flags
|= RF_FIRSTSHARE
;
357 rv
->r_sharehead
= s
->r_sharehead
;
358 LIST_INSERT_HEAD(s
->r_sharehead
, rv
, r_sharelink
);
364 * We couldn't find anything.
368 * If the user specified RF_ACTIVE in the initial flags,
369 * which is reflected in `want_activate', we attempt to atomically
370 * activate the resource. If this fails, we release the resource
371 * and indicate overall failure. (This behavior probably doesn't
372 * make sense for RF_TIMESHARE-type resources.)
374 if (rv
&& want_activate
) {
375 struct resource
*whohas
;
376 if (int_rman_activate_resource(rm
, rv
, &whohas
)) {
377 int_rman_release_resource(rm
, rv
);
381 lwkt_reltoken(rm
->rm_slock
);
386 int_rman_activate_resource(struct rman
*rm
, struct resource
*r
,
387 struct resource
**whohas
)
393 * If we are not timesharing, then there is nothing much to do.
394 * If we already have the resource, then there is nothing at all to do.
395 * If we are not on a sharing list with anybody else, then there is
398 if ((r
->r_flags
& RF_TIMESHARE
) == 0
399 || (r
->r_flags
& RF_ACTIVE
) != 0
400 || r
->r_sharehead
== 0) {
401 r
->r_flags
|= RF_ACTIVE
;
406 for (s
= LIST_FIRST(r
->r_sharehead
); s
&& ok
;
407 s
= LIST_NEXT(s
, r_sharelink
)) {
408 if ((s
->r_flags
& RF_ACTIVE
) != 0) {
414 r
->r_flags
|= RF_ACTIVE
;
421 rman_activate_resource(struct resource
*r
)
424 struct resource
*whohas
;
428 lwkt_gettoken(rm
->rm_slock
);
429 rv
= int_rman_activate_resource(rm
, r
, &whohas
);
430 lwkt_reltoken(rm
->rm_slock
);
438 rman_await_resource(struct resource
*r
, int slpflags
, int timo
)
441 struct resource
*whohas
;
446 lwkt_gettoken(rm
->rm_slock
);
447 rv
= int_rman_activate_resource(rm
, r
, &whohas
);
449 return (rv
); /* returns with ilock held */
451 if (r
->r_sharehead
== 0)
452 panic("rman_await_resource");
454 * A critical section will hopefully will prevent a race
455 * between lwkt_reltoken and tsleep where a process
456 * could conceivably get in and release the resource
457 * before we have a chance to sleep on it. YYY
460 whohas
->r_flags
|= RF_WANTED
;
461 rv
= tsleep(r
->r_sharehead
, slpflags
, "rmwait", timo
);
463 lwkt_reltoken(rm
->rm_slock
);
474 int_rman_deactivate_resource(struct resource
*r
)
479 r
->r_flags
&= ~RF_ACTIVE
;
480 if (r
->r_flags
& RF_WANTED
) {
481 r
->r_flags
&= ~RF_WANTED
;
482 wakeup(r
->r_sharehead
);
488 rman_deactivate_resource(struct resource
*r
)
493 lwkt_gettoken(rm
->rm_slock
);
494 int_rman_deactivate_resource(r
);
495 lwkt_reltoken(rm
->rm_slock
);
500 int_rman_release_resource(struct rman
*rm
, struct resource
*r
)
502 struct resource
*s
, *t
;
504 if (r
->r_flags
& RF_ACTIVE
)
505 int_rman_deactivate_resource(r
);
508 * Check for a sharing list first. If there is one, then we don't
509 * have to think as hard.
511 if (r
->r_sharehead
) {
513 * If a sharing list exists, then we know there are at
516 * If we are in the main circleq, appoint someone else.
518 LIST_REMOVE(r
, r_sharelink
);
519 s
= LIST_FIRST(r
->r_sharehead
);
520 if (r
->r_flags
& RF_FIRSTSHARE
) {
521 s
->r_flags
|= RF_FIRSTSHARE
;
522 TAILQ_INSERT_BEFORE(r
, s
, r_link
);
523 TAILQ_REMOVE(&rm
->rm_list
, r
, r_link
);
527 * Make sure that the sharing list goes away completely
528 * if the resource is no longer being shared at all.
530 if (LIST_NEXT(s
, r_sharelink
) == 0) {
531 kfree(s
->r_sharehead
, M_RMAN
);
533 s
->r_flags
&= ~RF_FIRSTSHARE
;
539 * Look at the adjacent resources in the list and see if our
540 * segment can be merged with any of them.
542 s
= TAILQ_PREV(r
, resource_head
, r_link
);
543 t
= TAILQ_NEXT(r
, r_link
);
545 if (s
!= NULL
&& (s
->r_flags
& RF_ALLOCATED
) == 0
546 && t
!= NULL
&& (t
->r_flags
& RF_ALLOCATED
) == 0) {
548 * Merge all three segments.
551 TAILQ_REMOVE(&rm
->rm_list
, r
, r_link
);
552 TAILQ_REMOVE(&rm
->rm_list
, t
, r_link
);
554 } else if (s
!= NULL
&& (s
->r_flags
& RF_ALLOCATED
) == 0) {
556 * Merge previous segment with ours.
559 TAILQ_REMOVE(&rm
->rm_list
, r
, r_link
);
560 } else if (t
!= NULL
&& (t
->r_flags
& RF_ALLOCATED
) == 0) {
562 * Merge next segment with ours.
564 t
->r_start
= r
->r_start
;
565 TAILQ_REMOVE(&rm
->rm_list
, r
, r_link
);
568 * At this point, we know there is nothing we
569 * can potentially merge with, because on each
570 * side, there is either nothing there or what is
571 * there is still allocated. In that case, we don't
572 * want to remove r from the list; we simply want to
573 * change it to an unallocated region and return
574 * without freeing anything.
576 r
->r_flags
&= ~RF_ALLOCATED
;
586 rman_release_resource(struct resource
*r
)
588 struct rman
*rm
= r
->r_rm
;
591 lwkt_gettoken(rm
->rm_slock
);
592 rv
= int_rman_release_resource(rm
, r
);
593 lwkt_reltoken(rm
->rm_slock
);
598 rman_make_alignment_flags(uint32_t size
)
603 * Find the hightest bit set, and add one if more than one bit
604 * set. We're effectively computing the ceil(log2(size)) here.
606 for (i
= 32; i
> 0; i
--)
609 if (~(1 << i
) & size
)
612 return(RF_ALIGNMENT_LOG2(i
));
616 * Sysctl interface for scanning the resource lists.
618 * We take two input parameters; the index into the list of resource
619 * managers, and the resource offset into the list.
622 sysctl_rman(SYSCTL_HANDLER_ARGS
)
624 int *name
= (int *)arg1
;
625 u_int namelen
= arg2
;
626 int rman_idx
, res_idx
;
628 struct resource
*res
;
630 struct u_resource ures
;
636 if (bus_data_generation_check(name
[0]))
642 * Find the indexed resource manager
644 TAILQ_FOREACH(rm
, &rman_head
, rm_link
) {
652 * If the resource index is -1, we want details on the
656 urm
.rm_handle
= (uintptr_t)rm
;
657 strlcpy(urm
.rm_descr
, rm
->rm_descr
, RM_TEXTLEN
);
658 urm
.rm_start
= rm
->rm_start
;
659 urm
.rm_size
= rm
->rm_end
- rm
->rm_start
+ 1;
660 urm
.rm_type
= rm
->rm_type
;
662 error
= SYSCTL_OUT(req
, &urm
, sizeof(urm
));
667 * Find the indexed resource and return it.
669 TAILQ_FOREACH(res
, &rm
->rm_list
, r_link
) {
670 if (res_idx
-- == 0) {
671 ures
.r_handle
= (uintptr_t)res
;
672 ures
.r_parent
= (uintptr_t)res
->r_rm
;
673 ures
.r_device
= (uintptr_t)res
->r_dev
;
674 if (res
->r_dev
!= NULL
) {
675 if (device_get_name(res
->r_dev
) != NULL
) {
676 ksnprintf(ures
.r_devname
, RM_TEXTLEN
,
678 device_get_name(res
->r_dev
),
679 device_get_unit(res
->r_dev
));
681 strlcpy(ures
.r_devname
, "nomatch",
685 ures
.r_devname
[0] = '\0';
687 ures
.r_start
= res
->r_start
;
688 ures
.r_size
= res
->r_end
- res
->r_start
+ 1;
689 ures
.r_flags
= res
->r_flags
;
691 error
= SYSCTL_OUT(req
, &ures
, sizeof(ures
));
698 SYSCTL_NODE(_hw_bus
, OID_AUTO
, rman
, CTLFLAG_RD
, sysctl_rman
,
699 "kernel resource manager");