2 * Copyright (c) 2015 Adrian Chadd <adrian@FreeBSD.org>.
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer,
10 * without modification.
11 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
12 * similar to the "NO WARRANTY" disclaimer below ("Disclaimer") and any
13 * redistribution must be conditioned upon including a substantially
14 * similar Disclaimer requirement for further binary redistribution.
17 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
18 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
19 * LIMITED TO, THE IMPLIED WARRANTIES OF NONINFRINGEMENT, MERCHANTIBILITY
20 * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
21 * THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY,
22 * OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
23 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
24 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
25 * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
26 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
27 * THE POSSIBILITY OF SUCH DAMAGES.
30 #include <sys/cdefs.h>
31 __FBSDID("$FreeBSD$");
36 #include <sys/param.h>
37 #include <sys/systm.h>
39 #include <sys/kernel.h>
40 #include <sys/malloc.h>
41 #include <sys/mutex.h>
45 #include <sys/queue.h>
46 #include <sys/rwlock.h>
48 #include <sys/sysctl.h>
50 #include <sys/vmmeter.h>
56 #include <vm/vm_param.h>
57 #include <vm/vm_kern.h>
58 #include <vm/vm_object.h>
59 #include <vm/vm_page.h>
60 #include <vm/vm_phys.h>
62 #include <vm/vm_domain.h>
66 vm_domain_rr_selectdomain(int skip_domain)
73 td->td_dom_rr_idx %= vm_ndomains;
76 * If skip_domain is provided then skip over that
77 * domain. This is intended for round robin variants
78 * which first try a fixed domain.
80 if ((skip_domain > -1) && (td->td_dom_rr_idx == skip_domain)) {
82 td->td_dom_rr_idx %= vm_ndomains;
84 return (td->td_dom_rr_idx);
89 * This implements a very simple set of VM domain memory allocation
90 * policies and iterators.
94 * A VM domain policy represents a desired VM domain policy.
95 * Iterators implement searching through VM domains in a specific
100 * When setting a policy, the caller must establish their own
101 * exclusive write protection for the contents of the domain
105 vm_domain_policy_init(struct vm_domain_policy *vp)
108 bzero(vp, sizeof(*vp));
109 vp->p.policy = VM_POLICY_NONE;
115 vm_domain_policy_set(struct vm_domain_policy *vp,
116 vm_domain_policy_type_t vt, int domain)
119 seq_write_begin(&vp->seq);
121 vp->p.domain = domain;
122 seq_write_end(&vp->seq);
127 * Take a local copy of a policy.
129 * The destination policy isn't write-barriered; this is used
130 * for doing local copies into something that isn't shared.
133 vm_domain_policy_localcopy(struct vm_domain_policy *dst,
134 const struct vm_domain_policy *src)
139 seq = seq_read(&src->seq);
141 if (seq_consistent(&src->seq, seq))
147 * Take a write-barrier copy of a policy.
149 * The destination policy is write -barriered; this is used
150 * for doing copies into policies that may be read by other
154 vm_domain_policy_copy(struct vm_domain_policy *dst,
155 const struct vm_domain_policy *src)
158 struct vm_domain_policy d;
161 seq = seq_read(&src->seq);
163 if (seq_consistent(&src->seq, seq)) {
164 seq_write_begin(&dst->seq);
165 dst->p.domain = d.p.domain;
166 dst->p.policy = d.p.policy;
167 seq_write_end(&dst->seq);
174 vm_domain_policy_validate(const struct vm_domain_policy *vp)
177 switch (vp->p.policy) {
179 case VM_POLICY_ROUND_ROBIN:
180 case VM_POLICY_FIRST_TOUCH:
181 case VM_POLICY_FIRST_TOUCH_ROUND_ROBIN:
182 if (vp->p.domain == -1)
185 case VM_POLICY_FIXED_DOMAIN:
186 case VM_POLICY_FIXED_DOMAIN_ROUND_ROBIN:
188 if (vp->p.domain >= 0 && vp->p.domain < vm_ndomains)
191 if (vp->p.domain == 0)
202 vm_domain_policy_cleanup(struct vm_domain_policy *vp)
210 vm_domain_iterator_init(struct vm_domain_iterator *vi)
213 /* Nothing to do for now */
218 * Manually setup an iterator with the given details.
221 vm_domain_iterator_set(struct vm_domain_iterator *vi,
222 vm_domain_policy_type_t vt, int domain)
227 case VM_POLICY_FIXED_DOMAIN:
228 vi->policy = VM_POLICY_FIXED_DOMAIN;
232 case VM_POLICY_FIXED_DOMAIN_ROUND_ROBIN:
233 vi->policy = VM_POLICY_FIXED_DOMAIN_ROUND_ROBIN;
237 case VM_POLICY_FIRST_TOUCH:
238 vi->policy = VM_POLICY_FIRST_TOUCH;
239 vi->domain = PCPU_GET(domain);
242 case VM_POLICY_FIRST_TOUCH_ROUND_ROBIN:
243 vi->policy = VM_POLICY_FIRST_TOUCH_ROUND_ROBIN;
244 vi->domain = PCPU_GET(domain);
247 case VM_POLICY_ROUND_ROBIN:
249 vi->policy = VM_POLICY_ROUND_ROBIN;
262 * Setup an iterator based on the given policy.
265 _vm_domain_iterator_set_policy(struct vm_domain_iterator *vi,
266 const struct vm_domain_policy *vt)
271 * Initialise the iterator.
273 * For first-touch, the initial domain is set
274 * via the current thread CPU domain.
276 * For fixed-domain, it's assumed that the
277 * caller has initialised the specific domain
280 switch (vt->p.policy) {
281 case VM_POLICY_FIXED_DOMAIN:
282 vi->policy = vt->p.policy;
283 vi->domain = vt->p.domain;
286 case VM_POLICY_FIXED_DOMAIN_ROUND_ROBIN:
287 vi->policy = vt->p.policy;
288 vi->domain = vt->p.domain;
291 case VM_POLICY_FIRST_TOUCH:
292 vi->policy = vt->p.policy;
293 vi->domain = PCPU_GET(domain);
296 case VM_POLICY_FIRST_TOUCH_ROUND_ROBIN:
297 vi->policy = vt->p.policy;
298 vi->domain = PCPU_GET(domain);
301 case VM_POLICY_ROUND_ROBIN:
304 * Default to round-robin policy.
306 vi->policy = VM_POLICY_ROUND_ROBIN;
318 vm_domain_iterator_set_policy(struct vm_domain_iterator *vi,
319 const struct vm_domain_policy *vt)
322 struct vm_domain_policy vt_lcl;
325 seq = seq_read(&vt->seq);
327 if (seq_consistent(&vt->seq, seq)) {
328 _vm_domain_iterator_set_policy(vi, &vt_lcl);
335 * Return the next VM domain to use.
337 * Returns 0 w/ domain set to the next domain to use, or
338 * -1 to indicate no more domains are available.
341 vm_domain_iterator_run(struct vm_domain_iterator *vi, int *domain)
344 /* General catch-all */
349 switch (vi->policy) {
350 case VM_POLICY_FIXED_DOMAIN:
351 case VM_POLICY_FIRST_TOUCH:
352 *domain = vi->domain;
355 case VM_POLICY_FIXED_DOMAIN_ROUND_ROBIN:
356 case VM_POLICY_FIRST_TOUCH_ROUND_ROBIN:
358 * XXX TODO: skip over the rr'ed domain
359 * if it equals the one we started with.
361 if (vi->n == vm_ndomains)
362 *domain = vi->domain;
364 *domain = vm_domain_rr_selectdomain(vi->domain);
367 case VM_POLICY_ROUND_ROBIN:
369 *domain = vm_domain_rr_selectdomain(-1);
382 * Returns 1 if the iteration is done, or 0 if it has not.
384 * This can only be called after at least one loop through
385 * the iterator. Ie, it's designed to be used as a tail
386 * check of a loop, not the head check of a loop.
389 vm_domain_iterator_isdone(struct vm_domain_iterator *vi)
396 vm_domain_iterator_cleanup(struct vm_domain_iterator *vi)