1d7f687fcSJeff Roberson /*- 2d7f687fcSJeff Roberson * Copyright (c) 2008, Jeffrey Roberson <jeff@freebsd.org> 3d7f687fcSJeff Roberson * All rights reserved. 4d7f687fcSJeff Roberson * 53bc8c68dSJeff Roberson * Copyright (c) 2008 Nokia Corporation 63bc8c68dSJeff Roberson * All rights reserved. 73bc8c68dSJeff Roberson * 8d7f687fcSJeff Roberson * Redistribution and use in source and binary forms, with or without 9d7f687fcSJeff Roberson * modification, are permitted provided that the following conditions 10d7f687fcSJeff Roberson * are met: 11d7f687fcSJeff Roberson * 1. Redistributions of source code must retain the above copyright 12d7f687fcSJeff Roberson * notice unmodified, this list of conditions, and the following 13d7f687fcSJeff Roberson * disclaimer. 14d7f687fcSJeff Roberson * 2. Redistributions in binary form must reproduce the above copyright 15d7f687fcSJeff Roberson * notice, this list of conditions and the following disclaimer in the 16d7f687fcSJeff Roberson * documentation and/or other materials provided with the distribution. 17d7f687fcSJeff Roberson * 18d7f687fcSJeff Roberson * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 19d7f687fcSJeff Roberson * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 20d7f687fcSJeff Roberson * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 21d7f687fcSJeff Roberson * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 22d7f687fcSJeff Roberson * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 23d7f687fcSJeff Roberson * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 24d7f687fcSJeff Roberson * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 25d7f687fcSJeff Roberson * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 26d7f687fcSJeff Roberson * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 27d7f687fcSJeff Roberson * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 28d7f687fcSJeff Roberson * 29d7f687fcSJeff Roberson */ 30d7f687fcSJeff Roberson 31d7f687fcSJeff Roberson #include <sys/cdefs.h> 32d7f687fcSJeff Roberson __FBSDID("$FreeBSD$"); 33d7f687fcSJeff Roberson 34dea0ed66SBjoern A. Zeeb #include "opt_ddb.h" 35dea0ed66SBjoern A. Zeeb 36d7f687fcSJeff Roberson #include <sys/param.h> 37d7f687fcSJeff Roberson #include <sys/systm.h> 38d7f687fcSJeff Roberson #include <sys/sysproto.h> 390304c731SJamie Gritton #include <sys/jail.h> 40d7f687fcSJeff Roberson #include <sys/kernel.h> 41d7f687fcSJeff Roberson #include <sys/lock.h> 42d7f687fcSJeff Roberson #include <sys/malloc.h> 43d7f687fcSJeff Roberson #include <sys/mutex.h> 44d7f687fcSJeff Roberson #include <sys/priv.h> 45d7f687fcSJeff Roberson #include <sys/proc.h> 46d7f687fcSJeff Roberson #include <sys/refcount.h> 47d7f687fcSJeff Roberson #include <sys/sched.h> 48d7f687fcSJeff Roberson #include <sys/smp.h> 49d7f687fcSJeff Roberson #include <sys/syscallsubr.h> 50d7f687fcSJeff Roberson #include <sys/cpuset.h> 51d7f687fcSJeff Roberson #include <sys/sx.h> 52d7f687fcSJeff Roberson #include <sys/queue.h> 53e3709597SAttilio Rao #include <sys/libkern.h> 54d7f687fcSJeff Roberson #include <sys/limits.h> 55a03ee000SJeff Roberson #include <sys/bus.h> 56a03ee000SJeff Roberson #include <sys/interrupt.h> 57d7f687fcSJeff Roberson 58d7f687fcSJeff Roberson #include <vm/uma.h> 59d7f687fcSJeff Roberson 60dea0ed66SBjoern A. Zeeb #ifdef DDB 61dea0ed66SBjoern A. Zeeb #include <ddb/ddb.h> 62dea0ed66SBjoern A. Zeeb #endif /* DDB */ 63dea0ed66SBjoern A. Zeeb 64d7f687fcSJeff Roberson /* 65d7f687fcSJeff Roberson * cpusets provide a mechanism for creating and manipulating sets of 66d7f687fcSJeff Roberson * processors for the purpose of constraining the scheduling of threads to 67d7f687fcSJeff Roberson * specific processors. 68d7f687fcSJeff Roberson * 69d7f687fcSJeff Roberson * Each process belongs to an identified set, by default this is set 1. Each 70d7f687fcSJeff Roberson * thread may further restrict the cpus it may run on to a subset of this 71d7f687fcSJeff Roberson * named set. This creates an anonymous set which other threads and processes 72d7f687fcSJeff Roberson * may not join by number. 73d7f687fcSJeff Roberson * 74d7f687fcSJeff Roberson * The named set is referred to herein as the 'base' set to avoid ambiguity. 75d7f687fcSJeff Roberson * This set is usually a child of a 'root' set while the anonymous set may 76d7f687fcSJeff Roberson * simply be referred to as a mask. In the syscall api these are referred to 77d7f687fcSJeff Roberson * as the ROOT, CPUSET, and MASK levels where CPUSET is called 'base' here. 78d7f687fcSJeff Roberson * 79d7f687fcSJeff Roberson * Threads inherit their set from their creator whether it be anonymous or 80d7f687fcSJeff Roberson * not. This means that anonymous sets are immutable because they may be 81d7f687fcSJeff Roberson * shared. To modify an anonymous set a new set is created with the desired 82d7f687fcSJeff Roberson * mask and the same parent as the existing anonymous set. This gives the 8393902625SJohn Baldwin * illusion of each thread having a private mask. 84d7f687fcSJeff Roberson * 85d7f687fcSJeff Roberson * Via the syscall apis a user may ask to retrieve or modify the root, base, 86d7f687fcSJeff Roberson * or mask that is discovered via a pid, tid, or setid. Modifying a set 87d7f687fcSJeff Roberson * modifies all numbered and anonymous child sets to comply with the new mask. 88d7f687fcSJeff Roberson * Modifying a pid or tid's mask applies only to that tid but must still 89d7f687fcSJeff Roberson * exist within the assigned parent set. 90d7f687fcSJeff Roberson * 9186855bf5SJohn Baldwin * A thread may not be assigned to a group separate from other threads in 92d7f687fcSJeff Roberson * the process. This is to remove ambiguity when the setid is queried with 93d7f687fcSJeff Roberson * a pid argument. There is no other technical limitation. 94d7f687fcSJeff Roberson * 95d7f687fcSJeff Roberson * This somewhat complex arrangement is intended to make it easy for 96d7f687fcSJeff Roberson * applications to query available processors and bind their threads to 97d7f687fcSJeff Roberson * specific processors while also allowing administrators to dynamically 98d7f687fcSJeff Roberson * reprovision by changing sets which apply to groups of processes. 99d7f687fcSJeff Roberson * 100d7f687fcSJeff Roberson * A simple application should not concern itself with sets at all and 101d7f687fcSJeff Roberson * rather apply masks to its own threads via CPU_WHICH_TID and a -1 id 10293902625SJohn Baldwin * meaning 'curthread'. It may query available cpus for that tid with a 103d7f687fcSJeff Roberson * getaffinity call using (CPU_LEVEL_CPUSET, CPU_WHICH_PID, -1, ...). 104d7f687fcSJeff Roberson */ 105d7f687fcSJeff Roberson static uma_zone_t cpuset_zone; 106d7f687fcSJeff Roberson static struct mtx cpuset_lock; 107d7f687fcSJeff Roberson static struct setlist cpuset_ids; 108d7f687fcSJeff Roberson static struct unrhdr *cpuset_unr; 109a03ee000SJeff Roberson static struct cpuset *cpuset_zero; 110a03ee000SJeff Roberson 111444528c0SDavid Xu /* Return the size of cpuset_t at the kernel level */ 112444528c0SDavid Xu SYSCTL_INT(_kern_sched, OID_AUTO, cpusetsize, CTLFLAG_RD, 113444528c0SDavid Xu 0, sizeof(cpuset_t), "sizeof(cpuset_t)"); 114444528c0SDavid Xu 115a03ee000SJeff Roberson cpuset_t *cpuset_root; 116d7f687fcSJeff Roberson 117d7f687fcSJeff Roberson /* 118d7f687fcSJeff Roberson * Acquire a reference to a cpuset, all pointers must be tracked with refs. 119d7f687fcSJeff Roberson */ 120d7f687fcSJeff Roberson struct cpuset * 121d7f687fcSJeff Roberson cpuset_ref(struct cpuset *set) 122d7f687fcSJeff Roberson { 123d7f687fcSJeff Roberson 124d7f687fcSJeff Roberson refcount_acquire(&set->cs_ref); 125d7f687fcSJeff Roberson return (set); 126d7f687fcSJeff Roberson } 127d7f687fcSJeff Roberson 128d7f687fcSJeff Roberson /* 1297a8f695aSBjoern A. Zeeb * Walks up the tree from 'set' to find the root. Returns the root 1307a8f695aSBjoern A. Zeeb * referenced. 1317a8f695aSBjoern A. Zeeb */ 1327a8f695aSBjoern A. Zeeb static struct cpuset * 1337a8f695aSBjoern A. Zeeb cpuset_refroot(struct cpuset *set) 1347a8f695aSBjoern A. Zeeb { 1357a8f695aSBjoern A. Zeeb 1367a8f695aSBjoern A. Zeeb for (; set->cs_parent != NULL; set = set->cs_parent) 1377a8f695aSBjoern A. Zeeb if (set->cs_flags & CPU_SET_ROOT) 1387a8f695aSBjoern A. Zeeb break; 1397a8f695aSBjoern A. Zeeb cpuset_ref(set); 1407a8f695aSBjoern A. Zeeb 1417a8f695aSBjoern A. Zeeb return (set); 1427a8f695aSBjoern A. Zeeb } 1437a8f695aSBjoern A. Zeeb 1447a8f695aSBjoern A. Zeeb /* 1457a8f695aSBjoern A. Zeeb * Find the first non-anonymous set starting from 'set'. Returns this set 1467a8f695aSBjoern A. Zeeb * referenced. May return the passed in set with an extra ref if it is 1477a8f695aSBjoern A. Zeeb * not anonymous. 1487a8f695aSBjoern A. Zeeb */ 1497a8f695aSBjoern A. Zeeb static struct cpuset * 1507a8f695aSBjoern A. Zeeb cpuset_refbase(struct cpuset *set) 1517a8f695aSBjoern A. Zeeb { 1527a8f695aSBjoern A. Zeeb 1537a8f695aSBjoern A. Zeeb if (set->cs_id == CPUSET_INVALID) 1547a8f695aSBjoern A. Zeeb set = set->cs_parent; 1557a8f695aSBjoern A. Zeeb cpuset_ref(set); 1567a8f695aSBjoern A. Zeeb 1577a8f695aSBjoern A. Zeeb return (set); 1587a8f695aSBjoern A. Zeeb } 1597a8f695aSBjoern A. Zeeb 1607a8f695aSBjoern A. Zeeb /* 16193902625SJohn Baldwin * Release a reference in a context where it is safe to allocate. 162d7f687fcSJeff Roberson */ 163d7f687fcSJeff Roberson void 164d7f687fcSJeff Roberson cpuset_rel(struct cpuset *set) 165d7f687fcSJeff Roberson { 166d7f687fcSJeff Roberson cpusetid_t id; 167d7f687fcSJeff Roberson 168d7f687fcSJeff Roberson if (refcount_release(&set->cs_ref) == 0) 169d7f687fcSJeff Roberson return; 170d7f687fcSJeff Roberson mtx_lock_spin(&cpuset_lock); 171d7f687fcSJeff Roberson LIST_REMOVE(set, cs_siblings); 172d7f687fcSJeff Roberson id = set->cs_id; 173d7f687fcSJeff Roberson if (id != CPUSET_INVALID) 174d7f687fcSJeff Roberson LIST_REMOVE(set, cs_link); 175d7f687fcSJeff Roberson mtx_unlock_spin(&cpuset_lock); 176d7f687fcSJeff Roberson cpuset_rel(set->cs_parent); 177d7f687fcSJeff Roberson uma_zfree(cpuset_zone, set); 178d7f687fcSJeff Roberson if (id != CPUSET_INVALID) 179d7f687fcSJeff Roberson free_unr(cpuset_unr, id); 180d7f687fcSJeff Roberson } 181d7f687fcSJeff Roberson 182d7f687fcSJeff Roberson /* 183d7f687fcSJeff Roberson * Deferred release must be used when in a context that is not safe to 184d7f687fcSJeff Roberson * allocate/free. This places any unreferenced sets on the list 'head'. 185d7f687fcSJeff Roberson */ 186d7f687fcSJeff Roberson static void 187d7f687fcSJeff Roberson cpuset_rel_defer(struct setlist *head, struct cpuset *set) 188d7f687fcSJeff Roberson { 189d7f687fcSJeff Roberson 190d7f687fcSJeff Roberson if (refcount_release(&set->cs_ref) == 0) 191d7f687fcSJeff Roberson return; 192d7f687fcSJeff Roberson mtx_lock_spin(&cpuset_lock); 193d7f687fcSJeff Roberson LIST_REMOVE(set, cs_siblings); 194d7f687fcSJeff Roberson if (set->cs_id != CPUSET_INVALID) 195d7f687fcSJeff Roberson LIST_REMOVE(set, cs_link); 196d7f687fcSJeff Roberson LIST_INSERT_HEAD(head, set, cs_link); 197d7f687fcSJeff Roberson mtx_unlock_spin(&cpuset_lock); 198d7f687fcSJeff Roberson } 199d7f687fcSJeff Roberson 200d7f687fcSJeff Roberson /* 201d7f687fcSJeff Roberson * Complete a deferred release. Removes the set from the list provided to 202d7f687fcSJeff Roberson * cpuset_rel_defer. 203d7f687fcSJeff Roberson */ 204d7f687fcSJeff Roberson static void 205d7f687fcSJeff Roberson cpuset_rel_complete(struct cpuset *set) 206d7f687fcSJeff Roberson { 207d7f687fcSJeff Roberson LIST_REMOVE(set, cs_link); 208d7f687fcSJeff Roberson cpuset_rel(set->cs_parent); 209d7f687fcSJeff Roberson uma_zfree(cpuset_zone, set); 210d7f687fcSJeff Roberson } 211d7f687fcSJeff Roberson 212d7f687fcSJeff Roberson /* 213d7f687fcSJeff Roberson * Find a set based on an id. Returns it with a ref. 214d7f687fcSJeff Roberson */ 215d7f687fcSJeff Roberson static struct cpuset * 216413628a7SBjoern A. Zeeb cpuset_lookup(cpusetid_t setid, struct thread *td) 217d7f687fcSJeff Roberson { 218d7f687fcSJeff Roberson struct cpuset *set; 219d7f687fcSJeff Roberson 220d7f687fcSJeff Roberson if (setid == CPUSET_INVALID) 221d7f687fcSJeff Roberson return (NULL); 222d7f687fcSJeff Roberson mtx_lock_spin(&cpuset_lock); 223d7f687fcSJeff Roberson LIST_FOREACH(set, &cpuset_ids, cs_link) 224d7f687fcSJeff Roberson if (set->cs_id == setid) 225d7f687fcSJeff Roberson break; 226d7f687fcSJeff Roberson if (set) 227d7f687fcSJeff Roberson cpuset_ref(set); 228d7f687fcSJeff Roberson mtx_unlock_spin(&cpuset_lock); 229413628a7SBjoern A. Zeeb 230413628a7SBjoern A. Zeeb KASSERT(td != NULL, ("[%s:%d] td is NULL", __func__, __LINE__)); 231413628a7SBjoern A. Zeeb if (set != NULL && jailed(td->td_ucred)) { 2320304c731SJamie Gritton struct cpuset *jset, *tset; 233413628a7SBjoern A. Zeeb 2340304c731SJamie Gritton jset = td->td_ucred->cr_prison->pr_cpuset; 2350304c731SJamie Gritton for (tset = set; tset != NULL; tset = tset->cs_parent) 2360304c731SJamie Gritton if (tset == jset) 2370304c731SJamie Gritton break; 2380304c731SJamie Gritton if (tset == NULL) { 239413628a7SBjoern A. Zeeb cpuset_rel(set); 240413628a7SBjoern A. Zeeb set = NULL; 241413628a7SBjoern A. Zeeb } 242413628a7SBjoern A. Zeeb } 243413628a7SBjoern A. Zeeb 244d7f687fcSJeff Roberson return (set); 245d7f687fcSJeff Roberson } 246d7f687fcSJeff Roberson 247d7f687fcSJeff Roberson /* 248d7f687fcSJeff Roberson * Create a set in the space provided in 'set' with the provided parameters. 249d7f687fcSJeff Roberson * The set is returned with a single ref. May return EDEADLK if the set 250d7f687fcSJeff Roberson * will have no valid cpu based on restrictions from the parent. 251d7f687fcSJeff Roberson */ 252d7f687fcSJeff Roberson static int 253e84c2db1SJohn Baldwin _cpuset_create(struct cpuset *set, struct cpuset *parent, const cpuset_t *mask, 254d7f687fcSJeff Roberson cpusetid_t id) 255d7f687fcSJeff Roberson { 256d7f687fcSJeff Roberson 25773c40187SJeff Roberson if (!CPU_OVERLAP(&parent->cs_mask, mask)) 25873c40187SJeff Roberson return (EDEADLK); 259d7f687fcSJeff Roberson CPU_COPY(mask, &set->cs_mask); 260d7f687fcSJeff Roberson LIST_INIT(&set->cs_children); 261d7f687fcSJeff Roberson refcount_init(&set->cs_ref, 1); 262d7f687fcSJeff Roberson set->cs_flags = 0; 263d7f687fcSJeff Roberson mtx_lock_spin(&cpuset_lock); 264e84c2db1SJohn Baldwin CPU_AND(&set->cs_mask, &parent->cs_mask); 265d7f687fcSJeff Roberson set->cs_id = id; 266d7f687fcSJeff Roberson set->cs_parent = cpuset_ref(parent); 267d7f687fcSJeff Roberson LIST_INSERT_HEAD(&parent->cs_children, set, cs_siblings); 268d7f687fcSJeff Roberson if (set->cs_id != CPUSET_INVALID) 269d7f687fcSJeff Roberson LIST_INSERT_HEAD(&cpuset_ids, set, cs_link); 270d7f687fcSJeff Roberson mtx_unlock_spin(&cpuset_lock); 271d7f687fcSJeff Roberson 27273c40187SJeff Roberson return (0); 273d7f687fcSJeff Roberson } 274d7f687fcSJeff Roberson 275d7f687fcSJeff Roberson /* 276d7f687fcSJeff Roberson * Create a new non-anonymous set with the requested parent and mask. May 277d7f687fcSJeff Roberson * return failures if the mask is invalid or a new number can not be 278d7f687fcSJeff Roberson * allocated. 279d7f687fcSJeff Roberson */ 280d7f687fcSJeff Roberson static int 281e84c2db1SJohn Baldwin cpuset_create(struct cpuset **setp, struct cpuset *parent, const cpuset_t *mask) 282d7f687fcSJeff Roberson { 283d7f687fcSJeff Roberson struct cpuset *set; 284d7f687fcSJeff Roberson cpusetid_t id; 285d7f687fcSJeff Roberson int error; 286d7f687fcSJeff Roberson 287d7f687fcSJeff Roberson id = alloc_unr(cpuset_unr); 288d7f687fcSJeff Roberson if (id == -1) 289d7f687fcSJeff Roberson return (ENFILE); 290d7f687fcSJeff Roberson *setp = set = uma_zalloc(cpuset_zone, M_WAITOK); 291d7f687fcSJeff Roberson error = _cpuset_create(set, parent, mask, id); 292d7f687fcSJeff Roberson if (error == 0) 293d7f687fcSJeff Roberson return (0); 294d7f687fcSJeff Roberson free_unr(cpuset_unr, id); 295d7f687fcSJeff Roberson uma_zfree(cpuset_zone, set); 296d7f687fcSJeff Roberson 297d7f687fcSJeff Roberson return (error); 298d7f687fcSJeff Roberson } 299d7f687fcSJeff Roberson 300d7f687fcSJeff Roberson /* 301d7f687fcSJeff Roberson * Recursively check for errors that would occur from applying mask to 302d7f687fcSJeff Roberson * the tree of sets starting at 'set'. Checks for sets that would become 303d7f687fcSJeff Roberson * empty as well as RDONLY flags. 304d7f687fcSJeff Roberson */ 305d7f687fcSJeff Roberson static int 306d7f687fcSJeff Roberson cpuset_testupdate(struct cpuset *set, cpuset_t *mask) 307d7f687fcSJeff Roberson { 308d7f687fcSJeff Roberson struct cpuset *nset; 309d7f687fcSJeff Roberson cpuset_t newmask; 310d7f687fcSJeff Roberson int error; 311d7f687fcSJeff Roberson 312d7f687fcSJeff Roberson mtx_assert(&cpuset_lock, MA_OWNED); 313d7f687fcSJeff Roberson if (set->cs_flags & CPU_SET_RDONLY) 314d7f687fcSJeff Roberson return (EPERM); 31573c40187SJeff Roberson if (!CPU_OVERLAP(&set->cs_mask, mask)) 31673c40187SJeff Roberson return (EDEADLK); 317d7f687fcSJeff Roberson CPU_COPY(&set->cs_mask, &newmask); 318d7f687fcSJeff Roberson CPU_AND(&newmask, mask); 31973c40187SJeff Roberson error = 0; 320d7f687fcSJeff Roberson LIST_FOREACH(nset, &set->cs_children, cs_siblings) 321d7f687fcSJeff Roberson if ((error = cpuset_testupdate(nset, &newmask)) != 0) 322d7f687fcSJeff Roberson break; 323d7f687fcSJeff Roberson return (error); 324d7f687fcSJeff Roberson } 325d7f687fcSJeff Roberson 326d7f687fcSJeff Roberson /* 327d7f687fcSJeff Roberson * Applies the mask 'mask' without checking for empty sets or permissions. 328d7f687fcSJeff Roberson */ 329d7f687fcSJeff Roberson static void 330d7f687fcSJeff Roberson cpuset_update(struct cpuset *set, cpuset_t *mask) 331d7f687fcSJeff Roberson { 332d7f687fcSJeff Roberson struct cpuset *nset; 333d7f687fcSJeff Roberson 334d7f687fcSJeff Roberson mtx_assert(&cpuset_lock, MA_OWNED); 335d7f687fcSJeff Roberson CPU_AND(&set->cs_mask, mask); 336d7f687fcSJeff Roberson LIST_FOREACH(nset, &set->cs_children, cs_siblings) 337d7f687fcSJeff Roberson cpuset_update(nset, &set->cs_mask); 338d7f687fcSJeff Roberson 339d7f687fcSJeff Roberson return; 340d7f687fcSJeff Roberson } 341d7f687fcSJeff Roberson 342d7f687fcSJeff Roberson /* 343d7f687fcSJeff Roberson * Modify the set 'set' to use a copy of the mask provided. Apply this new 344d7f687fcSJeff Roberson * mask to restrict all children in the tree. Checks for validity before 345d7f687fcSJeff Roberson * applying the changes. 346d7f687fcSJeff Roberson */ 347d7f687fcSJeff Roberson static int 348d7f687fcSJeff Roberson cpuset_modify(struct cpuset *set, cpuset_t *mask) 349d7f687fcSJeff Roberson { 35073c40187SJeff Roberson struct cpuset *root; 351d7f687fcSJeff Roberson int error; 352d7f687fcSJeff Roberson 353ba931c08SBjoern A. Zeeb error = priv_check(curthread, PRIV_SCHED_CPUSET); 354d7f687fcSJeff Roberson if (error) 355d7f687fcSJeff Roberson return (error); 35673c40187SJeff Roberson /* 3576aaa0b3cSBjoern A. Zeeb * In case we are called from within the jail 3586aaa0b3cSBjoern A. Zeeb * we do not allow modifying the dedicated root 3596aaa0b3cSBjoern A. Zeeb * cpuset of the jail but may still allow to 3606aaa0b3cSBjoern A. Zeeb * change child sets. 3616aaa0b3cSBjoern A. Zeeb */ 3626aaa0b3cSBjoern A. Zeeb if (jailed(curthread->td_ucred) && 3636aaa0b3cSBjoern A. Zeeb set->cs_flags & CPU_SET_ROOT) 3646aaa0b3cSBjoern A. Zeeb return (EPERM); 3656aaa0b3cSBjoern A. Zeeb /* 36673c40187SJeff Roberson * Verify that we have access to this set of 36773c40187SJeff Roberson * cpus. 36873c40187SJeff Roberson */ 36973c40187SJeff Roberson root = set->cs_parent; 37073c40187SJeff Roberson if (root && !CPU_SUBSET(&root->cs_mask, mask)) 37173c40187SJeff Roberson return (EINVAL); 372d7f687fcSJeff Roberson mtx_lock_spin(&cpuset_lock); 373d7f687fcSJeff Roberson error = cpuset_testupdate(set, mask); 374d7f687fcSJeff Roberson if (error) 375d7f687fcSJeff Roberson goto out; 376d7f687fcSJeff Roberson cpuset_update(set, mask); 377d7f687fcSJeff Roberson CPU_COPY(mask, &set->cs_mask); 378d7f687fcSJeff Roberson out: 379d7f687fcSJeff Roberson mtx_unlock_spin(&cpuset_lock); 380d7f687fcSJeff Roberson 381d7f687fcSJeff Roberson return (error); 382d7f687fcSJeff Roberson } 383d7f687fcSJeff Roberson 384d7f687fcSJeff Roberson /* 385d7f687fcSJeff Roberson * Resolve the 'which' parameter of several cpuset apis. 386d7f687fcSJeff Roberson * 387d7f687fcSJeff Roberson * For WHICH_PID and WHICH_TID return a locked proc and valid proc/tid. Also 388d7f687fcSJeff Roberson * checks for permission via p_cansched(). 389d7f687fcSJeff Roberson * 390d7f687fcSJeff Roberson * For WHICH_SET returns a valid set with a new reference. 391d7f687fcSJeff Roberson * 392d7f687fcSJeff Roberson * -1 may be supplied for any argument to mean the current proc/thread or 393d7f687fcSJeff Roberson * the base set of the current thread. May fail with ESRCH/EPERM. 394d7f687fcSJeff Roberson */ 395d7f687fcSJeff Roberson static int 396d7f687fcSJeff Roberson cpuset_which(cpuwhich_t which, id_t id, struct proc **pp, struct thread **tdp, 397d7f687fcSJeff Roberson struct cpuset **setp) 398d7f687fcSJeff Roberson { 399d7f687fcSJeff Roberson struct cpuset *set; 400d7f687fcSJeff Roberson struct thread *td; 401d7f687fcSJeff Roberson struct proc *p; 402d7f687fcSJeff Roberson int error; 403d7f687fcSJeff Roberson 404d7f687fcSJeff Roberson *pp = p = NULL; 405d7f687fcSJeff Roberson *tdp = td = NULL; 406d7f687fcSJeff Roberson *setp = set = NULL; 407d7f687fcSJeff Roberson switch (which) { 408d7f687fcSJeff Roberson case CPU_WHICH_PID: 409d7f687fcSJeff Roberson if (id == -1) { 410d7f687fcSJeff Roberson PROC_LOCK(curproc); 411d7f687fcSJeff Roberson p = curproc; 412d7f687fcSJeff Roberson break; 413d7f687fcSJeff Roberson } 414d7f687fcSJeff Roberson if ((p = pfind(id)) == NULL) 415d7f687fcSJeff Roberson return (ESRCH); 416d7f687fcSJeff Roberson break; 417d7f687fcSJeff Roberson case CPU_WHICH_TID: 418d7f687fcSJeff Roberson if (id == -1) { 419d7f687fcSJeff Roberson PROC_LOCK(curproc); 420d7f687fcSJeff Roberson p = curproc; 421d7f687fcSJeff Roberson td = curthread; 422d7f687fcSJeff Roberson break; 423d7f687fcSJeff Roberson } 42442fe684cSDavid Xu td = tdfind(id, -1); 425d7f687fcSJeff Roberson if (td == NULL) 426d7f687fcSJeff Roberson return (ESRCH); 42742fe684cSDavid Xu p = td->td_proc; 428d7f687fcSJeff Roberson break; 429d7f687fcSJeff Roberson case CPU_WHICH_CPUSET: 430d7f687fcSJeff Roberson if (id == -1) { 431d7f687fcSJeff Roberson thread_lock(curthread); 432a03ee000SJeff Roberson set = cpuset_refbase(curthread->td_cpuset); 433d7f687fcSJeff Roberson thread_unlock(curthread); 434d7f687fcSJeff Roberson } else 435413628a7SBjoern A. Zeeb set = cpuset_lookup(id, curthread); 436d7f687fcSJeff Roberson if (set) { 437d7f687fcSJeff Roberson *setp = set; 438d7f687fcSJeff Roberson return (0); 439d7f687fcSJeff Roberson } 440d7f687fcSJeff Roberson return (ESRCH); 441413628a7SBjoern A. Zeeb case CPU_WHICH_JAIL: 442413628a7SBjoern A. Zeeb { 443413628a7SBjoern A. Zeeb /* Find `set' for prison with given id. */ 444413628a7SBjoern A. Zeeb struct prison *pr; 445413628a7SBjoern A. Zeeb 446413628a7SBjoern A. Zeeb sx_slock(&allprison_lock); 4470304c731SJamie Gritton pr = prison_find_child(curthread->td_ucred->cr_prison, id); 448413628a7SBjoern A. Zeeb sx_sunlock(&allprison_lock); 449413628a7SBjoern A. Zeeb if (pr == NULL) 450413628a7SBjoern A. Zeeb return (ESRCH); 451413628a7SBjoern A. Zeeb cpuset_ref(pr->pr_cpuset); 4520304c731SJamie Gritton *setp = pr->pr_cpuset; 453413628a7SBjoern A. Zeeb mtx_unlock(&pr->pr_mtx); 454413628a7SBjoern A. Zeeb return (0); 455413628a7SBjoern A. Zeeb } 4569b33b154SJeff Roberson case CPU_WHICH_IRQ: 4579b33b154SJeff Roberson return (0); 458d7f687fcSJeff Roberson default: 459d7f687fcSJeff Roberson return (EINVAL); 460d7f687fcSJeff Roberson } 461d7f687fcSJeff Roberson error = p_cansched(curthread, p); 462d7f687fcSJeff Roberson if (error) { 463d7f687fcSJeff Roberson PROC_UNLOCK(p); 464d7f687fcSJeff Roberson return (error); 465d7f687fcSJeff Roberson } 466d7f687fcSJeff Roberson if (td == NULL) 467d7f687fcSJeff Roberson td = FIRST_THREAD_IN_PROC(p); 468d7f687fcSJeff Roberson *pp = p; 469d7f687fcSJeff Roberson *tdp = td; 470d7f687fcSJeff Roberson return (0); 471d7f687fcSJeff Roberson } 472d7f687fcSJeff Roberson 473d7f687fcSJeff Roberson /* 474d7f687fcSJeff Roberson * Create an anonymous set with the provided mask in the space provided by 475d7f687fcSJeff Roberson * 'fset'. If the passed in set is anonymous we use its parent otherwise 476d7f687fcSJeff Roberson * the new set is a child of 'set'. 477d7f687fcSJeff Roberson */ 478d7f687fcSJeff Roberson static int 479e84c2db1SJohn Baldwin cpuset_shadow(struct cpuset *set, struct cpuset *fset, const cpuset_t *mask) 480d7f687fcSJeff Roberson { 481d7f687fcSJeff Roberson struct cpuset *parent; 482d7f687fcSJeff Roberson 483d7f687fcSJeff Roberson if (set->cs_id == CPUSET_INVALID) 484d7f687fcSJeff Roberson parent = set->cs_parent; 485d7f687fcSJeff Roberson else 486d7f687fcSJeff Roberson parent = set; 48773c40187SJeff Roberson if (!CPU_SUBSET(&parent->cs_mask, mask)) 488a03ee000SJeff Roberson return (EDEADLK); 489d7f687fcSJeff Roberson return (_cpuset_create(fset, parent, mask, CPUSET_INVALID)); 490d7f687fcSJeff Roberson } 491d7f687fcSJeff Roberson 492d7f687fcSJeff Roberson /* 493d7f687fcSJeff Roberson * Handle two cases for replacing the base set or mask of an entire process. 494d7f687fcSJeff Roberson * 495d7f687fcSJeff Roberson * 1) Set is non-null and mask is null. This reparents all anonymous sets 496d7f687fcSJeff Roberson * to the provided set and replaces all non-anonymous td_cpusets with the 497d7f687fcSJeff Roberson * provided set. 498d7f687fcSJeff Roberson * 2) Mask is non-null and set is null. This replaces or creates anonymous 499d7f687fcSJeff Roberson * sets for every thread with the existing base as a parent. 500d7f687fcSJeff Roberson * 501d7f687fcSJeff Roberson * This is overly complicated because we can't allocate while holding a 502d7f687fcSJeff Roberson * spinlock and spinlocks must be held while changing and examining thread 503d7f687fcSJeff Roberson * state. 504d7f687fcSJeff Roberson */ 505d7f687fcSJeff Roberson static int 506d7f687fcSJeff Roberson cpuset_setproc(pid_t pid, struct cpuset *set, cpuset_t *mask) 507d7f687fcSJeff Roberson { 508d7f687fcSJeff Roberson struct setlist freelist; 509d7f687fcSJeff Roberson struct setlist droplist; 51073c40187SJeff Roberson struct cpuset *tdset; 511d7f687fcSJeff Roberson struct cpuset *nset; 512d7f687fcSJeff Roberson struct thread *td; 513d7f687fcSJeff Roberson struct proc *p; 514d7f687fcSJeff Roberson int threads; 515d7f687fcSJeff Roberson int nfree; 516d7f687fcSJeff Roberson int error; 517d7f687fcSJeff Roberson /* 518d7f687fcSJeff Roberson * The algorithm requires two passes due to locking considerations. 519d7f687fcSJeff Roberson * 520d7f687fcSJeff Roberson * 1) Lookup the process and acquire the locks in the required order. 521d7f687fcSJeff Roberson * 2) If enough cpusets have not been allocated release the locks and 522d7f687fcSJeff Roberson * allocate them. Loop. 523d7f687fcSJeff Roberson */ 524d7f687fcSJeff Roberson LIST_INIT(&freelist); 525d7f687fcSJeff Roberson LIST_INIT(&droplist); 526d7f687fcSJeff Roberson nfree = 0; 527d7f687fcSJeff Roberson for (;;) { 528d7f687fcSJeff Roberson error = cpuset_which(CPU_WHICH_PID, pid, &p, &td, &nset); 529d7f687fcSJeff Roberson if (error) 530d7f687fcSJeff Roberson goto out; 531d7f687fcSJeff Roberson if (nfree >= p->p_numthreads) 532d7f687fcSJeff Roberson break; 533d7f687fcSJeff Roberson threads = p->p_numthreads; 534d7f687fcSJeff Roberson PROC_UNLOCK(p); 535d7f687fcSJeff Roberson for (; nfree < threads; nfree++) { 536d7f687fcSJeff Roberson nset = uma_zalloc(cpuset_zone, M_WAITOK); 537d7f687fcSJeff Roberson LIST_INSERT_HEAD(&freelist, nset, cs_link); 538d7f687fcSJeff Roberson } 539d7f687fcSJeff Roberson } 540d7f687fcSJeff Roberson PROC_LOCK_ASSERT(p, MA_OWNED); 541d7f687fcSJeff Roberson /* 542d7f687fcSJeff Roberson * Now that the appropriate locks are held and we have enough cpusets, 54373c40187SJeff Roberson * make sure the operation will succeed before applying changes. The 54473c40187SJeff Roberson * proc lock prevents td_cpuset from changing between calls. 545d7f687fcSJeff Roberson */ 546d7f687fcSJeff Roberson error = 0; 547d7f687fcSJeff Roberson FOREACH_THREAD_IN_PROC(p, td) { 54873c40187SJeff Roberson thread_lock(td); 54973c40187SJeff Roberson tdset = td->td_cpuset; 55073c40187SJeff Roberson /* 55173c40187SJeff Roberson * Verify that a new mask doesn't specify cpus outside of 55273c40187SJeff Roberson * the set the thread is a member of. 55373c40187SJeff Roberson */ 55473c40187SJeff Roberson if (mask) { 55573c40187SJeff Roberson if (tdset->cs_id == CPUSET_INVALID) 55673c40187SJeff Roberson tdset = tdset->cs_parent; 55773c40187SJeff Roberson if (!CPU_SUBSET(&tdset->cs_mask, mask)) 558a03ee000SJeff Roberson error = EDEADLK; 55973c40187SJeff Roberson /* 56073c40187SJeff Roberson * Verify that a new set won't leave an existing thread 56173c40187SJeff Roberson * mask without a cpu to run on. It can, however, restrict 56273c40187SJeff Roberson * the set. 56373c40187SJeff Roberson */ 56473c40187SJeff Roberson } else if (tdset->cs_id == CPUSET_INVALID) { 56573c40187SJeff Roberson if (!CPU_OVERLAP(&set->cs_mask, &tdset->cs_mask)) 566a03ee000SJeff Roberson error = EDEADLK; 56773c40187SJeff Roberson } 56873c40187SJeff Roberson thread_unlock(td); 56973c40187SJeff Roberson if (error) 57073c40187SJeff Roberson goto unlock_out; 57173c40187SJeff Roberson } 57273c40187SJeff Roberson /* 57373c40187SJeff Roberson * Replace each thread's cpuset while using deferred release. We 574374ae2a3SJeff Roberson * must do this because the thread lock must be held while operating 575374ae2a3SJeff Roberson * on the thread and this limits the type of operations allowed. 57673c40187SJeff Roberson */ 57773c40187SJeff Roberson FOREACH_THREAD_IN_PROC(p, td) { 578d7f687fcSJeff Roberson thread_lock(td); 579d7f687fcSJeff Roberson /* 580d7f687fcSJeff Roberson * If we presently have an anonymous set or are applying a 581d7f687fcSJeff Roberson * mask we must create an anonymous shadow set. That is 582d7f687fcSJeff Roberson * either parented to our existing base or the supplied set. 583d7f687fcSJeff Roberson * 584d7f687fcSJeff Roberson * If we have a base set with no anonymous shadow we simply 585d7f687fcSJeff Roberson * replace it outright. 586d7f687fcSJeff Roberson */ 587d7f687fcSJeff Roberson tdset = td->td_cpuset; 588d7f687fcSJeff Roberson if (tdset->cs_id == CPUSET_INVALID || mask) { 589d7f687fcSJeff Roberson nset = LIST_FIRST(&freelist); 590d7f687fcSJeff Roberson LIST_REMOVE(nset, cs_link); 591d7f687fcSJeff Roberson if (mask) 592d7f687fcSJeff Roberson error = cpuset_shadow(tdset, nset, mask); 593d7f687fcSJeff Roberson else 594d7f687fcSJeff Roberson error = _cpuset_create(nset, set, 595d7f687fcSJeff Roberson &tdset->cs_mask, CPUSET_INVALID); 596d7f687fcSJeff Roberson if (error) { 597d7f687fcSJeff Roberson LIST_INSERT_HEAD(&freelist, nset, cs_link); 598d7f687fcSJeff Roberson thread_unlock(td); 599d7f687fcSJeff Roberson break; 600d7f687fcSJeff Roberson } 601d7f687fcSJeff Roberson } else 602d7f687fcSJeff Roberson nset = cpuset_ref(set); 603d7f687fcSJeff Roberson cpuset_rel_defer(&droplist, tdset); 604d7f687fcSJeff Roberson td->td_cpuset = nset; 605d7f687fcSJeff Roberson sched_affinity(td); 606d7f687fcSJeff Roberson thread_unlock(td); 607d7f687fcSJeff Roberson } 60873c40187SJeff Roberson unlock_out: 609d7f687fcSJeff Roberson PROC_UNLOCK(p); 610d7f687fcSJeff Roberson out: 611d7f687fcSJeff Roberson while ((nset = LIST_FIRST(&droplist)) != NULL) 612d7f687fcSJeff Roberson cpuset_rel_complete(nset); 613d7f687fcSJeff Roberson while ((nset = LIST_FIRST(&freelist)) != NULL) { 614d7f687fcSJeff Roberson LIST_REMOVE(nset, cs_link); 615d7f687fcSJeff Roberson uma_zfree(cpuset_zone, nset); 616d7f687fcSJeff Roberson } 617d7f687fcSJeff Roberson return (error); 618d7f687fcSJeff Roberson } 619d7f687fcSJeff Roberson 620d7f687fcSJeff Roberson /* 62171a19bdcSAttilio Rao * Calculate the ffs() of the cpuset. 62271a19bdcSAttilio Rao */ 62371a19bdcSAttilio Rao int 62471a19bdcSAttilio Rao cpusetobj_ffs(const cpuset_t *set) 62571a19bdcSAttilio Rao { 62671a19bdcSAttilio Rao size_t i; 62771a19bdcSAttilio Rao int cbit; 62871a19bdcSAttilio Rao 62971a19bdcSAttilio Rao cbit = 0; 63071a19bdcSAttilio Rao for (i = 0; i < _NCPUWORDS; i++) { 63171a19bdcSAttilio Rao if (set->__bits[i] != 0) { 63271a19bdcSAttilio Rao cbit = ffsl(set->__bits[i]); 63371a19bdcSAttilio Rao cbit += i * _NCPUBITS; 63471a19bdcSAttilio Rao break; 63571a19bdcSAttilio Rao } 63671a19bdcSAttilio Rao } 63771a19bdcSAttilio Rao return (cbit); 63871a19bdcSAttilio Rao } 63971a19bdcSAttilio Rao 64071a19bdcSAttilio Rao /* 64171a19bdcSAttilio Rao * Return a string representing a valid layout for a cpuset_t object. 64271a19bdcSAttilio Rao * It expects an incoming buffer at least sized as CPUSETBUFSIZ. 64371a19bdcSAttilio Rao */ 64471a19bdcSAttilio Rao char * 64571a19bdcSAttilio Rao cpusetobj_strprint(char *buf, const cpuset_t *set) 64671a19bdcSAttilio Rao { 64771a19bdcSAttilio Rao char *tbuf; 64871a19bdcSAttilio Rao size_t i, bytesp, bufsiz; 64971a19bdcSAttilio Rao 65071a19bdcSAttilio Rao tbuf = buf; 65171a19bdcSAttilio Rao bytesp = 0; 65271a19bdcSAttilio Rao bufsiz = CPUSETBUFSIZ; 65371a19bdcSAttilio Rao 65434a1e065SAttilio Rao for (i = _NCPUWORDS - 1; i > 0; i--) { 65571a19bdcSAttilio Rao bytesp = snprintf(tbuf, bufsiz, "%lx, ", set->__bits[i]); 65671a19bdcSAttilio Rao bufsiz -= bytesp; 65771a19bdcSAttilio Rao tbuf += bytesp; 65871a19bdcSAttilio Rao } 65934a1e065SAttilio Rao snprintf(tbuf, bufsiz, "%lx", set->__bits[0]); 66071a19bdcSAttilio Rao return (buf); 66171a19bdcSAttilio Rao } 66271a19bdcSAttilio Rao 66371a19bdcSAttilio Rao /* 664e3709597SAttilio Rao * Build a valid cpuset_t object from a string representation. 665e3709597SAttilio Rao * It expects an incoming buffer at least sized as CPUSETBUFSIZ. 666e3709597SAttilio Rao */ 667e3709597SAttilio Rao int 668e3709597SAttilio Rao cpusetobj_strscan(cpuset_t *set, const char *buf) 669e3709597SAttilio Rao { 670e3709597SAttilio Rao u_int nwords; 671e3709597SAttilio Rao int i, ret; 672e3709597SAttilio Rao 673e3709597SAttilio Rao if (strlen(buf) > CPUSETBUFSIZ - 1) 674e3709597SAttilio Rao return (-1); 675e3709597SAttilio Rao 676e3709597SAttilio Rao /* Allow to pass a shorter version of the mask when necessary. */ 677e3709597SAttilio Rao nwords = 1; 678e3709597SAttilio Rao for (i = 0; buf[i] != '\0'; i++) 679e3709597SAttilio Rao if (buf[i] == ',') 680e3709597SAttilio Rao nwords++; 681e3709597SAttilio Rao if (nwords > _NCPUWORDS) 682e3709597SAttilio Rao return (-1); 683e3709597SAttilio Rao 684e3709597SAttilio Rao CPU_ZERO(set); 685e3709597SAttilio Rao for (i = nwords - 1; i > 0; i--) { 686e3709597SAttilio Rao ret = sscanf(buf, "%lx, ", &set->__bits[i]); 687e3709597SAttilio Rao if (ret == 0 || ret == -1) 688e3709597SAttilio Rao return (-1); 689e3709597SAttilio Rao buf = strstr(buf, " "); 690e3709597SAttilio Rao if (buf == NULL) 691e3709597SAttilio Rao return (-1); 692e3709597SAttilio Rao buf++; 693e3709597SAttilio Rao } 694e3709597SAttilio Rao ret = sscanf(buf, "%lx", &set->__bits[0]); 695e3709597SAttilio Rao if (ret == 0 || ret == -1) 696e3709597SAttilio Rao return (-1); 697e3709597SAttilio Rao return (0); 698e3709597SAttilio Rao } 699e3709597SAttilio Rao 700e3709597SAttilio Rao /* 701d7f687fcSJeff Roberson * Apply an anonymous mask to a single thread. 702d7f687fcSJeff Roberson */ 703a03ee000SJeff Roberson int 704d7f687fcSJeff Roberson cpuset_setthread(lwpid_t id, cpuset_t *mask) 705d7f687fcSJeff Roberson { 706d7f687fcSJeff Roberson struct cpuset *nset; 707d7f687fcSJeff Roberson struct cpuset *set; 708d7f687fcSJeff Roberson struct thread *td; 709d7f687fcSJeff Roberson struct proc *p; 710d7f687fcSJeff Roberson int error; 711d7f687fcSJeff Roberson 712d7f687fcSJeff Roberson nset = uma_zalloc(cpuset_zone, M_WAITOK); 7138bd75bddSJeff Roberson error = cpuset_which(CPU_WHICH_TID, id, &p, &td, &set); 714d7f687fcSJeff Roberson if (error) 715d7f687fcSJeff Roberson goto out; 716a03ee000SJeff Roberson set = NULL; 717d7f687fcSJeff Roberson thread_lock(td); 718a03ee000SJeff Roberson error = cpuset_shadow(td->td_cpuset, nset, mask); 719d7f687fcSJeff Roberson if (error == 0) { 720a03ee000SJeff Roberson set = td->td_cpuset; 721d7f687fcSJeff Roberson td->td_cpuset = nset; 722d7f687fcSJeff Roberson sched_affinity(td); 723d7f687fcSJeff Roberson nset = NULL; 724d7f687fcSJeff Roberson } 725d7f687fcSJeff Roberson thread_unlock(td); 726d7f687fcSJeff Roberson PROC_UNLOCK(p); 727a03ee000SJeff Roberson if (set) 728a03ee000SJeff Roberson cpuset_rel(set); 729d7f687fcSJeff Roberson out: 730d7f687fcSJeff Roberson if (nset) 731d7f687fcSJeff Roberson uma_zfree(cpuset_zone, nset); 732d7f687fcSJeff Roberson return (error); 733d7f687fcSJeff Roberson } 734d7f687fcSJeff Roberson 735d7f687fcSJeff Roberson /* 736d7f687fcSJeff Roberson * Creates the cpuset for thread0. We make two sets: 737d7f687fcSJeff Roberson * 738d7f687fcSJeff Roberson * 0 - The root set which should represent all valid processors in the 739d7f687fcSJeff Roberson * system. It is initially created with a mask of all processors 740d7f687fcSJeff Roberson * because we don't know what processors are valid until cpuset_init() 741d7f687fcSJeff Roberson * runs. This set is immutable. 742d7f687fcSJeff Roberson * 1 - The default set which all processes are a member of until changed. 743d7f687fcSJeff Roberson * This allows an administrator to move all threads off of given cpus to 744d7f687fcSJeff Roberson * dedicate them to high priority tasks or save power etc. 745d7f687fcSJeff Roberson */ 746d7f687fcSJeff Roberson struct cpuset * 747d7f687fcSJeff Roberson cpuset_thread0(void) 748d7f687fcSJeff Roberson { 749d7f687fcSJeff Roberson struct cpuset *set; 750d7f687fcSJeff Roberson int error; 751d7f687fcSJeff Roberson 752d7f687fcSJeff Roberson cpuset_zone = uma_zcreate("cpuset", sizeof(struct cpuset), NULL, NULL, 753d7f687fcSJeff Roberson NULL, NULL, UMA_ALIGN_PTR, 0); 754d7f687fcSJeff Roberson mtx_init(&cpuset_lock, "cpuset", NULL, MTX_SPIN | MTX_RECURSE); 755d7f687fcSJeff Roberson /* 756d7f687fcSJeff Roberson * Create the root system set for the whole machine. Doesn't use 757d7f687fcSJeff Roberson * cpuset_create() due to NULL parent. 758d7f687fcSJeff Roberson */ 759d7f687fcSJeff Roberson set = uma_zalloc(cpuset_zone, M_WAITOK | M_ZERO); 760f27aed53SAttilio Rao CPU_FILL(&set->cs_mask); 761d7f687fcSJeff Roberson LIST_INIT(&set->cs_children); 762d7f687fcSJeff Roberson LIST_INSERT_HEAD(&cpuset_ids, set, cs_link); 763d7f687fcSJeff Roberson set->cs_ref = 1; 764d7f687fcSJeff Roberson set->cs_flags = CPU_SET_ROOT; 765d7f687fcSJeff Roberson cpuset_zero = set; 766a03ee000SJeff Roberson cpuset_root = &set->cs_mask; 767d7f687fcSJeff Roberson /* 768d7f687fcSJeff Roberson * Now derive a default, modifiable set from that to give out. 769d7f687fcSJeff Roberson */ 770d7f687fcSJeff Roberson set = uma_zalloc(cpuset_zone, M_WAITOK); 771d7f687fcSJeff Roberson error = _cpuset_create(set, cpuset_zero, &cpuset_zero->cs_mask, 1); 772d7f687fcSJeff Roberson KASSERT(error == 0, ("Error creating default set: %d\n", error)); 773d7f687fcSJeff Roberson /* 774d7f687fcSJeff Roberson * Initialize the unit allocator. 0 and 1 are allocated above. 775d7f687fcSJeff Roberson */ 776d7f687fcSJeff Roberson cpuset_unr = new_unrhdr(2, INT_MAX, NULL); 777d7f687fcSJeff Roberson 778d7f687fcSJeff Roberson return (set); 779d7f687fcSJeff Roberson } 780d7f687fcSJeff Roberson 781d7f687fcSJeff Roberson /* 782413628a7SBjoern A. Zeeb * Create a cpuset, which would be cpuset_create() but 783413628a7SBjoern A. Zeeb * mark the new 'set' as root. 784413628a7SBjoern A. Zeeb * 78547479a8cSBjoern A. Zeeb * We are not going to reparent the td to it. Use cpuset_setproc_update_set() 78647479a8cSBjoern A. Zeeb * for that. 787413628a7SBjoern A. Zeeb * 788413628a7SBjoern A. Zeeb * In case of no error, returns the set in *setp locked with a reference. 789413628a7SBjoern A. Zeeb */ 790413628a7SBjoern A. Zeeb int 7910304c731SJamie Gritton cpuset_create_root(struct prison *pr, struct cpuset **setp) 792413628a7SBjoern A. Zeeb { 793413628a7SBjoern A. Zeeb struct cpuset *set; 794413628a7SBjoern A. Zeeb int error; 795413628a7SBjoern A. Zeeb 7960304c731SJamie Gritton KASSERT(pr != NULL, ("[%s:%d] invalid pr", __func__, __LINE__)); 797413628a7SBjoern A. Zeeb KASSERT(setp != NULL, ("[%s:%d] invalid setp", __func__, __LINE__)); 798413628a7SBjoern A. Zeeb 7990304c731SJamie Gritton error = cpuset_create(setp, pr->pr_cpuset, &pr->pr_cpuset->cs_mask); 800413628a7SBjoern A. Zeeb if (error) 801413628a7SBjoern A. Zeeb return (error); 802413628a7SBjoern A. Zeeb 803413628a7SBjoern A. Zeeb KASSERT(*setp != NULL, ("[%s:%d] cpuset_create returned invalid data", 804413628a7SBjoern A. Zeeb __func__, __LINE__)); 805413628a7SBjoern A. Zeeb 806413628a7SBjoern A. Zeeb /* Mark the set as root. */ 807413628a7SBjoern A. Zeeb set = *setp; 808413628a7SBjoern A. Zeeb set->cs_flags |= CPU_SET_ROOT; 809413628a7SBjoern A. Zeeb 810413628a7SBjoern A. Zeeb return (0); 811413628a7SBjoern A. Zeeb } 812413628a7SBjoern A. Zeeb 813413628a7SBjoern A. Zeeb int 814413628a7SBjoern A. Zeeb cpuset_setproc_update_set(struct proc *p, struct cpuset *set) 815413628a7SBjoern A. Zeeb { 816413628a7SBjoern A. Zeeb int error; 817413628a7SBjoern A. Zeeb 818413628a7SBjoern A. Zeeb KASSERT(p != NULL, ("[%s:%d] invalid proc", __func__, __LINE__)); 819413628a7SBjoern A. Zeeb KASSERT(set != NULL, ("[%s:%d] invalid set", __func__, __LINE__)); 820413628a7SBjoern A. Zeeb 821413628a7SBjoern A. Zeeb cpuset_ref(set); 822413628a7SBjoern A. Zeeb error = cpuset_setproc(p->p_pid, set, NULL); 823413628a7SBjoern A. Zeeb if (error) 824413628a7SBjoern A. Zeeb return (error); 825413628a7SBjoern A. Zeeb cpuset_rel(set); 826413628a7SBjoern A. Zeeb return (0); 827413628a7SBjoern A. Zeeb } 828413628a7SBjoern A. Zeeb 829413628a7SBjoern A. Zeeb /* 830d7f687fcSJeff Roberson * This is called once the final set of system cpus is known. Modifies 83193902625SJohn Baldwin * the root set and all children and mark the root read-only. 832d7f687fcSJeff Roberson */ 833d7f687fcSJeff Roberson static void 834d7f687fcSJeff Roberson cpuset_init(void *arg) 835d7f687fcSJeff Roberson { 836d7f687fcSJeff Roberson cpuset_t mask; 837d7f687fcSJeff Roberson 83871a19bdcSAttilio Rao mask = all_cpus; 839d7f687fcSJeff Roberson if (cpuset_modify(cpuset_zero, &mask)) 840d7f687fcSJeff Roberson panic("Can't set initial cpuset mask.\n"); 841d7f687fcSJeff Roberson cpuset_zero->cs_flags |= CPU_SET_RDONLY; 842d7f687fcSJeff Roberson } 843d7f687fcSJeff Roberson SYSINIT(cpuset, SI_SUB_SMP, SI_ORDER_ANY, cpuset_init, NULL); 844d7f687fcSJeff Roberson 845d7f687fcSJeff Roberson #ifndef _SYS_SYSPROTO_H_ 846d7f687fcSJeff Roberson struct cpuset_args { 847d7f687fcSJeff Roberson cpusetid_t *setid; 848d7f687fcSJeff Roberson }; 849d7f687fcSJeff Roberson #endif 850d7f687fcSJeff Roberson int 8518451d0ddSKip Macy sys_cpuset(struct thread *td, struct cpuset_args *uap) 852d7f687fcSJeff Roberson { 853d7f687fcSJeff Roberson struct cpuset *root; 854d7f687fcSJeff Roberson struct cpuset *set; 855d7f687fcSJeff Roberson int error; 856d7f687fcSJeff Roberson 857d7f687fcSJeff Roberson thread_lock(td); 858a03ee000SJeff Roberson root = cpuset_refroot(td->td_cpuset); 859d7f687fcSJeff Roberson thread_unlock(td); 860d7f687fcSJeff Roberson error = cpuset_create(&set, root, &root->cs_mask); 861d7f687fcSJeff Roberson cpuset_rel(root); 862d7f687fcSJeff Roberson if (error) 863d7f687fcSJeff Roberson return (error); 864d7f687fcSJeff Roberson error = copyout(&set->cs_id, uap->setid, sizeof(set->cs_id)); 865a03ee000SJeff Roberson if (error == 0) 866a03ee000SJeff Roberson error = cpuset_setproc(-1, set, NULL); 867d7f687fcSJeff Roberson cpuset_rel(set); 868d7f687fcSJeff Roberson return (error); 869d7f687fcSJeff Roberson } 870d7f687fcSJeff Roberson 871d7f687fcSJeff Roberson #ifndef _SYS_SYSPROTO_H_ 872d7f687fcSJeff Roberson struct cpuset_setid_args { 873d7f687fcSJeff Roberson cpuwhich_t which; 874d7f687fcSJeff Roberson id_t id; 875d7f687fcSJeff Roberson cpusetid_t setid; 876d7f687fcSJeff Roberson }; 877d7f687fcSJeff Roberson #endif 878d7f687fcSJeff Roberson int 8798451d0ddSKip Macy sys_cpuset_setid(struct thread *td, struct cpuset_setid_args *uap) 880d7f687fcSJeff Roberson { 881d7f687fcSJeff Roberson struct cpuset *set; 882d7f687fcSJeff Roberson int error; 883d7f687fcSJeff Roberson 884d7f687fcSJeff Roberson /* 885d7f687fcSJeff Roberson * Presently we only support per-process sets. 886d7f687fcSJeff Roberson */ 887d7f687fcSJeff Roberson if (uap->which != CPU_WHICH_PID) 888d7f687fcSJeff Roberson return (EINVAL); 889413628a7SBjoern A. Zeeb set = cpuset_lookup(uap->setid, td); 890d7f687fcSJeff Roberson if (set == NULL) 891d7f687fcSJeff Roberson return (ESRCH); 892d7f687fcSJeff Roberson error = cpuset_setproc(uap->id, set, NULL); 893d7f687fcSJeff Roberson cpuset_rel(set); 894d7f687fcSJeff Roberson return (error); 895d7f687fcSJeff Roberson } 896d7f687fcSJeff Roberson 897d7f687fcSJeff Roberson #ifndef _SYS_SYSPROTO_H_ 898d7f687fcSJeff Roberson struct cpuset_getid_args { 899d7f687fcSJeff Roberson cpulevel_t level; 900d7f687fcSJeff Roberson cpuwhich_t which; 901d7f687fcSJeff Roberson id_t id; 902d7f687fcSJeff Roberson cpusetid_t *setid; 903d7f687fcSJeff Roberson #endif 904d7f687fcSJeff Roberson int 9058451d0ddSKip Macy sys_cpuset_getid(struct thread *td, struct cpuset_getid_args *uap) 906d7f687fcSJeff Roberson { 907d7f687fcSJeff Roberson struct cpuset *nset; 908d7f687fcSJeff Roberson struct cpuset *set; 909d7f687fcSJeff Roberson struct thread *ttd; 910d7f687fcSJeff Roberson struct proc *p; 911d7f687fcSJeff Roberson cpusetid_t id; 912d7f687fcSJeff Roberson int error; 913d7f687fcSJeff Roberson 914d7f687fcSJeff Roberson if (uap->level == CPU_LEVEL_WHICH && uap->which != CPU_WHICH_CPUSET) 915d7f687fcSJeff Roberson return (EINVAL); 916d7f687fcSJeff Roberson error = cpuset_which(uap->which, uap->id, &p, &ttd, &set); 917d7f687fcSJeff Roberson if (error) 918d7f687fcSJeff Roberson return (error); 919d7f687fcSJeff Roberson switch (uap->which) { 920d7f687fcSJeff Roberson case CPU_WHICH_TID: 921d7f687fcSJeff Roberson case CPU_WHICH_PID: 922d7f687fcSJeff Roberson thread_lock(ttd); 923a03ee000SJeff Roberson set = cpuset_refbase(ttd->td_cpuset); 924d7f687fcSJeff Roberson thread_unlock(ttd); 925d7f687fcSJeff Roberson PROC_UNLOCK(p); 926d7f687fcSJeff Roberson break; 927d7f687fcSJeff Roberson case CPU_WHICH_CPUSET: 928413628a7SBjoern A. Zeeb case CPU_WHICH_JAIL: 929d7f687fcSJeff Roberson break; 9309b33b154SJeff Roberson case CPU_WHICH_IRQ: 9319b33b154SJeff Roberson return (EINVAL); 932d7f687fcSJeff Roberson } 933d7f687fcSJeff Roberson switch (uap->level) { 934d7f687fcSJeff Roberson case CPU_LEVEL_ROOT: 935a03ee000SJeff Roberson nset = cpuset_refroot(set); 936d7f687fcSJeff Roberson cpuset_rel(set); 937d7f687fcSJeff Roberson set = nset; 938d7f687fcSJeff Roberson break; 939d7f687fcSJeff Roberson case CPU_LEVEL_CPUSET: 940d7f687fcSJeff Roberson break; 941d7f687fcSJeff Roberson case CPU_LEVEL_WHICH: 942d7f687fcSJeff Roberson break; 943d7f687fcSJeff Roberson } 944d7f687fcSJeff Roberson id = set->cs_id; 945d7f687fcSJeff Roberson cpuset_rel(set); 946d7f687fcSJeff Roberson if (error == 0) 947d7f687fcSJeff Roberson error = copyout(&id, uap->setid, sizeof(id)); 948d7f687fcSJeff Roberson 949d7f687fcSJeff Roberson return (error); 950d7f687fcSJeff Roberson } 951d7f687fcSJeff Roberson 952d7f687fcSJeff Roberson #ifndef _SYS_SYSPROTO_H_ 953d7f687fcSJeff Roberson struct cpuset_getaffinity_args { 954d7f687fcSJeff Roberson cpulevel_t level; 955d7f687fcSJeff Roberson cpuwhich_t which; 9567f64829aSRuslan Ermilov id_t id; 9577f64829aSRuslan Ermilov size_t cpusetsize; 9587f64829aSRuslan Ermilov cpuset_t *mask; 959d7f687fcSJeff Roberson }; 960d7f687fcSJeff Roberson #endif 961d7f687fcSJeff Roberson int 9628451d0ddSKip Macy sys_cpuset_getaffinity(struct thread *td, struct cpuset_getaffinity_args *uap) 963d7f687fcSJeff Roberson { 964d7f687fcSJeff Roberson struct thread *ttd; 965d7f687fcSJeff Roberson struct cpuset *nset; 966d7f687fcSJeff Roberson struct cpuset *set; 967d7f687fcSJeff Roberson struct proc *p; 968d7f687fcSJeff Roberson cpuset_t *mask; 969d7f687fcSJeff Roberson int error; 9707f64829aSRuslan Ermilov size_t size; 971d7f687fcSJeff Roberson 97273c40187SJeff Roberson if (uap->cpusetsize < sizeof(cpuset_t) || 973887aedc6SKonstantin Belousov uap->cpusetsize > CPU_MAXSIZE / NBBY) 974d7f687fcSJeff Roberson return (ERANGE); 97573c40187SJeff Roberson size = uap->cpusetsize; 976d7f687fcSJeff Roberson mask = malloc(size, M_TEMP, M_WAITOK | M_ZERO); 977d7f687fcSJeff Roberson error = cpuset_which(uap->which, uap->id, &p, &ttd, &set); 978d7f687fcSJeff Roberson if (error) 979d7f687fcSJeff Roberson goto out; 980d7f687fcSJeff Roberson switch (uap->level) { 981d7f687fcSJeff Roberson case CPU_LEVEL_ROOT: 982d7f687fcSJeff Roberson case CPU_LEVEL_CPUSET: 983d7f687fcSJeff Roberson switch (uap->which) { 984d7f687fcSJeff Roberson case CPU_WHICH_TID: 985d7f687fcSJeff Roberson case CPU_WHICH_PID: 986d7f687fcSJeff Roberson thread_lock(ttd); 987d7f687fcSJeff Roberson set = cpuset_ref(ttd->td_cpuset); 988d7f687fcSJeff Roberson thread_unlock(ttd); 989d7f687fcSJeff Roberson break; 990d7f687fcSJeff Roberson case CPU_WHICH_CPUSET: 991413628a7SBjoern A. Zeeb case CPU_WHICH_JAIL: 992d7f687fcSJeff Roberson break; 9939b33b154SJeff Roberson case CPU_WHICH_IRQ: 9949b33b154SJeff Roberson error = EINVAL; 9959b33b154SJeff Roberson goto out; 996d7f687fcSJeff Roberson } 997d7f687fcSJeff Roberson if (uap->level == CPU_LEVEL_ROOT) 998a03ee000SJeff Roberson nset = cpuset_refroot(set); 999d7f687fcSJeff Roberson else 1000a03ee000SJeff Roberson nset = cpuset_refbase(set); 1001d7f687fcSJeff Roberson CPU_COPY(&nset->cs_mask, mask); 1002d7f687fcSJeff Roberson cpuset_rel(nset); 1003d7f687fcSJeff Roberson break; 1004d7f687fcSJeff Roberson case CPU_LEVEL_WHICH: 1005d7f687fcSJeff Roberson switch (uap->which) { 1006d7f687fcSJeff Roberson case CPU_WHICH_TID: 1007d7f687fcSJeff Roberson thread_lock(ttd); 1008d7f687fcSJeff Roberson CPU_COPY(&ttd->td_cpuset->cs_mask, mask); 1009d7f687fcSJeff Roberson thread_unlock(ttd); 1010d7f687fcSJeff Roberson break; 1011d7f687fcSJeff Roberson case CPU_WHICH_PID: 1012d7f687fcSJeff Roberson FOREACH_THREAD_IN_PROC(p, ttd) { 1013d7f687fcSJeff Roberson thread_lock(ttd); 1014d7f687fcSJeff Roberson CPU_OR(mask, &ttd->td_cpuset->cs_mask); 1015d7f687fcSJeff Roberson thread_unlock(ttd); 1016d7f687fcSJeff Roberson } 1017d7f687fcSJeff Roberson break; 1018d7f687fcSJeff Roberson case CPU_WHICH_CPUSET: 1019413628a7SBjoern A. Zeeb case CPU_WHICH_JAIL: 1020d7f687fcSJeff Roberson CPU_COPY(&set->cs_mask, mask); 1021d7f687fcSJeff Roberson break; 10229b33b154SJeff Roberson case CPU_WHICH_IRQ: 10239b33b154SJeff Roberson error = intr_getaffinity(uap->id, mask); 10249b33b154SJeff Roberson break; 1025d7f687fcSJeff Roberson } 1026d7f687fcSJeff Roberson break; 1027d7f687fcSJeff Roberson default: 1028d7f687fcSJeff Roberson error = EINVAL; 1029d7f687fcSJeff Roberson break; 1030d7f687fcSJeff Roberson } 1031d7f687fcSJeff Roberson if (set) 1032d7f687fcSJeff Roberson cpuset_rel(set); 1033d7f687fcSJeff Roberson if (p) 1034d7f687fcSJeff Roberson PROC_UNLOCK(p); 1035d7f687fcSJeff Roberson if (error == 0) 1036d7f687fcSJeff Roberson error = copyout(mask, uap->mask, size); 1037d7f687fcSJeff Roberson out: 1038d7f687fcSJeff Roberson free(mask, M_TEMP); 1039d7f687fcSJeff Roberson return (error); 1040d7f687fcSJeff Roberson } 1041d7f687fcSJeff Roberson 1042d7f687fcSJeff Roberson #ifndef _SYS_SYSPROTO_H_ 1043d7f687fcSJeff Roberson struct cpuset_setaffinity_args { 1044d7f687fcSJeff Roberson cpulevel_t level; 1045d7f687fcSJeff Roberson cpuwhich_t which; 10467f64829aSRuslan Ermilov id_t id; 10477f64829aSRuslan Ermilov size_t cpusetsize; 10487f64829aSRuslan Ermilov const cpuset_t *mask; 1049d7f687fcSJeff Roberson }; 1050d7f687fcSJeff Roberson #endif 1051d7f687fcSJeff Roberson int 10528451d0ddSKip Macy sys_cpuset_setaffinity(struct thread *td, struct cpuset_setaffinity_args *uap) 1053d7f687fcSJeff Roberson { 1054d7f687fcSJeff Roberson struct cpuset *nset; 1055d7f687fcSJeff Roberson struct cpuset *set; 1056d7f687fcSJeff Roberson struct thread *ttd; 1057d7f687fcSJeff Roberson struct proc *p; 1058d7f687fcSJeff Roberson cpuset_t *mask; 1059d7f687fcSJeff Roberson int error; 1060d7f687fcSJeff Roberson 106173c40187SJeff Roberson if (uap->cpusetsize < sizeof(cpuset_t) || 1062887aedc6SKonstantin Belousov uap->cpusetsize > CPU_MAXSIZE / NBBY) 1063d7f687fcSJeff Roberson return (ERANGE); 106473c40187SJeff Roberson mask = malloc(uap->cpusetsize, M_TEMP, M_WAITOK | M_ZERO); 106573c40187SJeff Roberson error = copyin(uap->mask, mask, uap->cpusetsize); 1066d7f687fcSJeff Roberson if (error) 1067d7f687fcSJeff Roberson goto out; 106873c40187SJeff Roberson /* 106973c40187SJeff Roberson * Verify that no high bits are set. 107073c40187SJeff Roberson */ 107173c40187SJeff Roberson if (uap->cpusetsize > sizeof(cpuset_t)) { 107273c40187SJeff Roberson char *end; 107373c40187SJeff Roberson char *cp; 107473c40187SJeff Roberson 107573c40187SJeff Roberson end = cp = (char *)&mask->__bits; 107673c40187SJeff Roberson end += uap->cpusetsize; 107773c40187SJeff Roberson cp += sizeof(cpuset_t); 107873c40187SJeff Roberson while (cp != end) 107973c40187SJeff Roberson if (*cp++ != 0) { 108073c40187SJeff Roberson error = EINVAL; 108173c40187SJeff Roberson goto out; 108273c40187SJeff Roberson } 108373c40187SJeff Roberson 108473c40187SJeff Roberson } 1085d7f687fcSJeff Roberson switch (uap->level) { 1086d7f687fcSJeff Roberson case CPU_LEVEL_ROOT: 1087d7f687fcSJeff Roberson case CPU_LEVEL_CPUSET: 1088d7f687fcSJeff Roberson error = cpuset_which(uap->which, uap->id, &p, &ttd, &set); 1089d7f687fcSJeff Roberson if (error) 1090d7f687fcSJeff Roberson break; 1091d7f687fcSJeff Roberson switch (uap->which) { 1092d7f687fcSJeff Roberson case CPU_WHICH_TID: 1093d7f687fcSJeff Roberson case CPU_WHICH_PID: 1094d7f687fcSJeff Roberson thread_lock(ttd); 1095d7f687fcSJeff Roberson set = cpuset_ref(ttd->td_cpuset); 1096d7f687fcSJeff Roberson thread_unlock(ttd); 1097c6440f72SJeff Roberson PROC_UNLOCK(p); 1098d7f687fcSJeff Roberson break; 1099d7f687fcSJeff Roberson case CPU_WHICH_CPUSET: 1100413628a7SBjoern A. Zeeb case CPU_WHICH_JAIL: 1101d7f687fcSJeff Roberson break; 11029b33b154SJeff Roberson case CPU_WHICH_IRQ: 11039b33b154SJeff Roberson error = EINVAL; 11049b33b154SJeff Roberson goto out; 1105d7f687fcSJeff Roberson } 1106d7f687fcSJeff Roberson if (uap->level == CPU_LEVEL_ROOT) 1107a03ee000SJeff Roberson nset = cpuset_refroot(set); 1108d7f687fcSJeff Roberson else 1109a03ee000SJeff Roberson nset = cpuset_refbase(set); 1110d7f687fcSJeff Roberson error = cpuset_modify(nset, mask); 1111d7f687fcSJeff Roberson cpuset_rel(nset); 1112d7f687fcSJeff Roberson cpuset_rel(set); 1113d7f687fcSJeff Roberson break; 1114d7f687fcSJeff Roberson case CPU_LEVEL_WHICH: 1115d7f687fcSJeff Roberson switch (uap->which) { 1116d7f687fcSJeff Roberson case CPU_WHICH_TID: 1117d7f687fcSJeff Roberson error = cpuset_setthread(uap->id, mask); 1118d7f687fcSJeff Roberson break; 1119d7f687fcSJeff Roberson case CPU_WHICH_PID: 1120d7f687fcSJeff Roberson error = cpuset_setproc(uap->id, NULL, mask); 1121d7f687fcSJeff Roberson break; 1122d7f687fcSJeff Roberson case CPU_WHICH_CPUSET: 1123413628a7SBjoern A. Zeeb case CPU_WHICH_JAIL: 1124413628a7SBjoern A. Zeeb error = cpuset_which(uap->which, uap->id, &p, 1125d7f687fcSJeff Roberson &ttd, &set); 1126d7f687fcSJeff Roberson if (error == 0) { 1127d7f687fcSJeff Roberson error = cpuset_modify(set, mask); 1128d7f687fcSJeff Roberson cpuset_rel(set); 1129d7f687fcSJeff Roberson } 1130d7f687fcSJeff Roberson break; 11319b33b154SJeff Roberson case CPU_WHICH_IRQ: 11329b33b154SJeff Roberson error = intr_setaffinity(uap->id, mask); 11339b33b154SJeff Roberson break; 1134d7f687fcSJeff Roberson default: 1135d7f687fcSJeff Roberson error = EINVAL; 1136d7f687fcSJeff Roberson break; 1137d7f687fcSJeff Roberson } 1138d7f687fcSJeff Roberson break; 1139d7f687fcSJeff Roberson default: 1140d7f687fcSJeff Roberson error = EINVAL; 1141d7f687fcSJeff Roberson break; 1142d7f687fcSJeff Roberson } 1143d7f687fcSJeff Roberson out: 1144d7f687fcSJeff Roberson free(mask, M_TEMP); 1145d7f687fcSJeff Roberson return (error); 1146d7f687fcSJeff Roberson } 1147dea0ed66SBjoern A. Zeeb 1148dea0ed66SBjoern A. Zeeb #ifdef DDB 1149dea0ed66SBjoern A. Zeeb DB_SHOW_COMMAND(cpusets, db_show_cpusets) 1150dea0ed66SBjoern A. Zeeb { 1151dea0ed66SBjoern A. Zeeb struct cpuset *set; 1152dea0ed66SBjoern A. Zeeb int cpu, once; 1153dea0ed66SBjoern A. Zeeb 1154dea0ed66SBjoern A. Zeeb LIST_FOREACH(set, &cpuset_ids, cs_link) { 1155dea0ed66SBjoern A. Zeeb db_printf("set=%p id=%-6u ref=%-6d flags=0x%04x parent id=%d\n", 1156dea0ed66SBjoern A. Zeeb set, set->cs_id, set->cs_ref, set->cs_flags, 1157dea0ed66SBjoern A. Zeeb (set->cs_parent != NULL) ? set->cs_parent->cs_id : 0); 1158dea0ed66SBjoern A. Zeeb db_printf(" mask="); 1159dea0ed66SBjoern A. Zeeb for (once = 0, cpu = 0; cpu < CPU_SETSIZE; cpu++) { 1160dea0ed66SBjoern A. Zeeb if (CPU_ISSET(cpu, &set->cs_mask)) { 1161dea0ed66SBjoern A. Zeeb if (once == 0) { 1162dea0ed66SBjoern A. Zeeb db_printf("%d", cpu); 1163dea0ed66SBjoern A. Zeeb once = 1; 1164dea0ed66SBjoern A. Zeeb } else 1165dea0ed66SBjoern A. Zeeb db_printf(",%d", cpu); 1166dea0ed66SBjoern A. Zeeb } 1167dea0ed66SBjoern A. Zeeb } 1168dea0ed66SBjoern A. Zeeb db_printf("\n"); 1169dea0ed66SBjoern A. Zeeb if (db_pager_quit) 1170dea0ed66SBjoern A. Zeeb break; 1171dea0ed66SBjoern A. Zeeb } 1172dea0ed66SBjoern A. Zeeb } 1173dea0ed66SBjoern A. Zeeb #endif /* DDB */ 1174