2 * Copyright (c) 2010 The FreeBSD Foundation
5 * This software was developed by Edward Tomasz Napierala under sponsorship
6 * from the FreeBSD Foundation.
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32 #include <sys/cdefs.h>
33 __FBSDID("$FreeBSD$");
35 #include <sys/param.h>
37 #include <sys/malloc.h>
38 #include <sys/queue.h>
39 #include <sys/refcount.h>
41 #include <sys/kernel.h>
42 #include <sys/limits.h>
43 #include <sys/loginclass.h>
46 #include <sys/racct.h>
48 #include <sys/resourcevar.h>
50 #include <sys/sysent.h>
51 #include <sys/sysproto.h>
52 #include <sys/systm.h>
53 #include <sys/types.h>
54 #include <sys/eventhandler.h>
56 #include <sys/mutex.h>
57 #include <sys/rwlock.h>
59 #include <sys/taskqueue.h>
65 #error "The RCTL option requires the RACCT option"
68 FEATURE(rctl, "Resource Limits");
71 #define HRF_DONT_INHERIT 1
72 #define HRF_DONT_ACCUMULATE 2
74 /* Default buffer size for rctl_get_rules(2). */
75 #define RCTL_DEFAULT_BUFSIZE 4096
76 #define RCTL_LOG_BUFSIZE 128
79 * 'rctl_rule_link' connects a rule with every racct it's related to.
80 * For example, rule 'user:X:openfiles:deny=N/process' is linked
81 * with uidinfo for user X, and to each process of that user.
83 struct rctl_rule_link {
84 LIST_ENTRY(rctl_rule_link) rrl_next;
85 struct rctl_rule *rrl_rule;
94 static struct dict subjectnames[] = {
95 { "process", RCTL_SUBJECT_TYPE_PROCESS },
96 { "user", RCTL_SUBJECT_TYPE_USER },
97 { "loginclass", RCTL_SUBJECT_TYPE_LOGINCLASS },
98 { "jail", RCTL_SUBJECT_TYPE_JAIL },
101 static struct dict resourcenames[] = {
102 { "cputime", RACCT_CPU },
103 { "datasize", RACCT_DATA },
104 { "stacksize", RACCT_STACK },
105 { "coredumpsize", RACCT_CORE },
106 { "memoryuse", RACCT_RSS },
107 { "memorylocked", RACCT_MEMLOCK },
108 { "maxproc", RACCT_NPROC },
109 { "openfiles", RACCT_NOFILE },
110 { "vmemoryuse", RACCT_VMEM },
111 { "pseudoterminals", RACCT_NPTS },
112 { "swapuse", RACCT_SWAP },
113 { "nthr", RACCT_NTHR },
114 { "msgqqueued", RACCT_MSGQQUEUED },
115 { "msgqsize", RACCT_MSGQSIZE },
116 { "nmsgq", RACCT_NMSGQ },
117 { "nsem", RACCT_NSEM },
118 { "nsemop", RACCT_NSEMOP },
119 { "nshm", RACCT_NSHM },
120 { "shmsize", RACCT_SHMSIZE },
121 { "wallclock", RACCT_WALLCLOCK },
124 static struct dict actionnames[] = {
125 { "sighup", RCTL_ACTION_SIGHUP },
126 { "sigint", RCTL_ACTION_SIGINT },
127 { "sigquit", RCTL_ACTION_SIGQUIT },
128 { "sigill", RCTL_ACTION_SIGILL },
129 { "sigtrap", RCTL_ACTION_SIGTRAP },
130 { "sigabrt", RCTL_ACTION_SIGABRT },
131 { "sigemt", RCTL_ACTION_SIGEMT },
132 { "sigfpe", RCTL_ACTION_SIGFPE },
133 { "sigkill", RCTL_ACTION_SIGKILL },
134 { "sigbus", RCTL_ACTION_SIGBUS },
135 { "sigsegv", RCTL_ACTION_SIGSEGV },
136 { "sigsys", RCTL_ACTION_SIGSYS },
137 { "sigpipe", RCTL_ACTION_SIGPIPE },
138 { "sigalrm", RCTL_ACTION_SIGALRM },
139 { "sigterm", RCTL_ACTION_SIGTERM },
140 { "sigurg", RCTL_ACTION_SIGURG },
141 { "sigstop", RCTL_ACTION_SIGSTOP },
142 { "sigtstp", RCTL_ACTION_SIGTSTP },
143 { "sigchld", RCTL_ACTION_SIGCHLD },
144 { "sigttin", RCTL_ACTION_SIGTTIN },
145 { "sigttou", RCTL_ACTION_SIGTTOU },
146 { "sigio", RCTL_ACTION_SIGIO },
147 { "sigxcpu", RCTL_ACTION_SIGXCPU },
148 { "sigxfsz", RCTL_ACTION_SIGXFSZ },
149 { "sigvtalrm", RCTL_ACTION_SIGVTALRM },
150 { "sigprof", RCTL_ACTION_SIGPROF },
151 { "sigwinch", RCTL_ACTION_SIGWINCH },
152 { "siginfo", RCTL_ACTION_SIGINFO },
153 { "sigusr1", RCTL_ACTION_SIGUSR1 },
154 { "sigusr2", RCTL_ACTION_SIGUSR2 },
155 { "sigthr", RCTL_ACTION_SIGTHR },
156 { "deny", RCTL_ACTION_DENY },
157 { "log", RCTL_ACTION_LOG },
158 { "devctl", RCTL_ACTION_DEVCTL },
161 static void rctl_init(void);
162 SYSINIT(rctl, SI_SUB_RACCT, SI_ORDER_FIRST, rctl_init, NULL);
164 static uma_zone_t rctl_rule_link_zone;
165 static uma_zone_t rctl_rule_zone;
166 static struct rwlock rctl_lock;
167 RW_SYSINIT(rctl_lock, &rctl_lock, "RCTL lock");
169 static int rctl_rule_fully_specified(const struct rctl_rule *rule);
170 static void rctl_rule_to_sbuf(struct sbuf *sb, const struct rctl_rule *rule);
172 static MALLOC_DEFINE(M_RCTL, "rctl", "Resource Limits");
175 rctl_subject_type_name(int subject)
179 for (i = 0; subjectnames[i].d_name != NULL; i++) {
180 if (subjectnames[i].d_value == subject)
181 return (subjectnames[i].d_name);
184 panic("rctl_subject_type_name: unknown subject type %d", subject);
188 rctl_action_name(int action)
192 for (i = 0; actionnames[i].d_name != NULL; i++) {
193 if (actionnames[i].d_value == action)
194 return (actionnames[i].d_name);
197 panic("rctl_action_name: unknown action %d", action);
201 rctl_resource_name(int resource)
205 for (i = 0; resourcenames[i].d_name != NULL; i++) {
206 if (resourcenames[i].d_value == resource)
207 return (resourcenames[i].d_name);
210 panic("rctl_resource_name: unknown resource %d", resource);
214 * Return the amount of resource that can be allocated by 'p' before
218 rctl_available_resource(const struct proc *p, const struct rctl_rule *rule)
221 int64_t available = INT64_MAX;
222 struct ucred *cred = p->p_ucred;
224 rw_assert(&rctl_lock, RA_LOCKED);
226 resource = rule->rr_resource;
227 switch (rule->rr_per) {
228 case RCTL_SUBJECT_TYPE_PROCESS:
229 available = rule->rr_amount -
230 p->p_racct->r_resources[resource];
232 case RCTL_SUBJECT_TYPE_USER:
233 available = rule->rr_amount -
234 cred->cr_ruidinfo->ui_racct->r_resources[resource];
236 case RCTL_SUBJECT_TYPE_LOGINCLASS:
237 available = rule->rr_amount -
238 cred->cr_loginclass->lc_racct->r_resources[resource];
240 case RCTL_SUBJECT_TYPE_JAIL:
241 available = rule->rr_amount -
242 cred->cr_prison->pr_prison_racct->prr_racct->
243 r_resources[resource];
246 panic("rctl_compute_available: unknown per %d",
254 * Return non-zero if allocating 'amount' by proc 'p' would exceed
255 * resource limit specified by 'rule'.
258 rctl_would_exceed(const struct proc *p, const struct rctl_rule *rule,
263 rw_assert(&rctl_lock, RA_LOCKED);
265 available = rctl_available_resource(p, rule);
266 if (available >= amount)
273 * Check whether the proc 'p' can allocate 'amount' of 'resource' in addition
274 * to what it keeps allocated now. Returns non-zero if the allocation should
275 * be denied, 0 otherwise.
278 rctl_enforce(struct proc *p, int resource, uint64_t amount)
280 struct rctl_rule *rule;
281 struct rctl_rule_link *link;
285 static int curtime = 0;
286 static struct timeval lasttime;
288 rw_rlock(&rctl_lock);
291 * There may be more than one matching rule; go through all of them.
292 * Denial should be done last, after logging and sending signals.
294 LIST_FOREACH(link, &p->p_racct->r_rule_links, rrl_next) {
295 rule = link->rrl_rule;
296 if (rule->rr_resource != resource)
298 if (!rctl_would_exceed(p, rule, amount)) {
299 link->rrl_exceeded = 0;
303 switch (rule->rr_action) {
304 case RCTL_ACTION_DENY:
307 case RCTL_ACTION_LOG:
309 * If rrl_exceeded != 0, it means we've already
310 * logged a warning for this process.
312 if (link->rrl_exceeded != 0)
316 * If the process state is not fully initialized yet,
317 * we can't access most of the required fields, e.g.
318 * p->p_comm. This happens when called from fork1().
319 * Ignore this rule for now; it will be processed just
320 * after fork, when called from racct_proc_fork_done().
322 if (p->p_state != PRS_NORMAL)
325 if (!ppsratecheck(&lasttime, &curtime, 10))
328 buf = malloc(RCTL_LOG_BUFSIZE, M_RCTL, M_NOWAIT);
330 printf("rctl_enforce: out of memory\n");
333 sbuf_new(&sb, buf, RCTL_LOG_BUFSIZE, SBUF_FIXEDLEN);
334 rctl_rule_to_sbuf(&sb, rule);
336 printf("rctl: rule \"%s\" matched by pid %d "
337 "(%s), uid %d, jail %s\n", sbuf_data(&sb),
338 p->p_pid, p->p_comm, p->p_ucred->cr_uid,
339 p->p_ucred->cr_prison->pr_prison_racct->prr_name);
342 link->rrl_exceeded = 1;
344 case RCTL_ACTION_DEVCTL:
345 if (link->rrl_exceeded != 0)
348 if (p->p_state != PRS_NORMAL)
351 buf = malloc(RCTL_LOG_BUFSIZE, M_RCTL, M_NOWAIT);
353 printf("rctl_enforce: out of memory\n");
356 sbuf_new(&sb, buf, RCTL_LOG_BUFSIZE, SBUF_FIXEDLEN);
357 sbuf_printf(&sb, "rule=");
358 rctl_rule_to_sbuf(&sb, rule);
359 sbuf_printf(&sb, " pid=%d ruid=%d jail=%s",
360 p->p_pid, p->p_ucred->cr_ruid,
361 p->p_ucred->cr_prison->pr_prison_racct->prr_name);
363 devctl_notify_f("RCTL", "rule", "matched",
364 sbuf_data(&sb), M_NOWAIT);
367 link->rrl_exceeded = 1;
370 if (link->rrl_exceeded != 0)
373 if (p->p_state != PRS_NORMAL)
376 KASSERT(rule->rr_action > 0 &&
377 rule->rr_action <= RCTL_ACTION_SIGNAL_MAX,
378 ("rctl_enforce: unknown action %d",
382 * We're using the fact that RCTL_ACTION_SIG* values
383 * are equal to their counterparts from sys/signal.h.
385 kern_psignal(p, rule->rr_action);
386 link->rrl_exceeded = 1;
391 rw_runlock(&rctl_lock);
395 * Return fake error code; the caller should change it
396 * into one proper for the situation - EFSIZ, ENOMEM etc.
405 rctl_get_limit(struct proc *p, int resource)
407 struct rctl_rule *rule;
408 struct rctl_rule_link *link;
409 uint64_t amount = UINT64_MAX;
411 rw_rlock(&rctl_lock);
414 * There may be more than one matching rule; go through all of them.
415 * Denial should be done last, after logging and sending signals.
417 LIST_FOREACH(link, &p->p_racct->r_rule_links, rrl_next) {
418 rule = link->rrl_rule;
419 if (rule->rr_resource != resource)
421 if (rule->rr_action != RCTL_ACTION_DENY)
423 if (rule->rr_amount < amount)
424 amount = rule->rr_amount;
427 rw_runlock(&rctl_lock);
433 rctl_get_available(struct proc *p, int resource)
435 struct rctl_rule *rule;
436 struct rctl_rule_link *link;
437 int64_t available, minavailable, allocated;
439 minavailable = INT64_MAX;
441 rw_rlock(&rctl_lock);
444 * There may be more than one matching rule; go through all of them.
445 * Denial should be done last, after logging and sending signals.
447 LIST_FOREACH(link, &p->p_racct->r_rule_links, rrl_next) {
448 rule = link->rrl_rule;
449 if (rule->rr_resource != resource)
451 if (rule->rr_action != RCTL_ACTION_DENY)
453 available = rctl_available_resource(p, rule);
454 if (available < minavailable)
455 minavailable = available;
458 rw_runlock(&rctl_lock);
461 * XXX: Think about this _hard_.
463 allocated = p->p_racct->r_resources[resource];
464 if (minavailable < INT64_MAX - allocated)
465 minavailable += allocated;
466 if (minavailable < 0)
468 return (minavailable);
472 rctl_rule_matches(const struct rctl_rule *rule, const struct rctl_rule *filter)
475 if (filter->rr_subject_type != RCTL_SUBJECT_TYPE_UNDEFINED) {
476 if (rule->rr_subject_type != filter->rr_subject_type)
479 switch (filter->rr_subject_type) {
480 case RCTL_SUBJECT_TYPE_PROCESS:
481 if (filter->rr_subject.rs_proc != NULL &&
482 rule->rr_subject.rs_proc !=
483 filter->rr_subject.rs_proc)
486 case RCTL_SUBJECT_TYPE_USER:
487 if (filter->rr_subject.rs_uip != NULL &&
488 rule->rr_subject.rs_uip !=
489 filter->rr_subject.rs_uip)
492 case RCTL_SUBJECT_TYPE_LOGINCLASS:
493 if (filter->rr_subject.rs_loginclass != NULL &&
494 rule->rr_subject.rs_loginclass !=
495 filter->rr_subject.rs_loginclass)
498 case RCTL_SUBJECT_TYPE_JAIL:
499 if (filter->rr_subject.rs_prison_racct != NULL &&
500 rule->rr_subject.rs_prison_racct !=
501 filter->rr_subject.rs_prison_racct)
505 panic("rctl_rule_matches: unknown subject type %d",
506 filter->rr_subject_type);
510 if (filter->rr_resource != RACCT_UNDEFINED) {
511 if (rule->rr_resource != filter->rr_resource)
515 if (filter->rr_action != RCTL_ACTION_UNDEFINED) {
516 if (rule->rr_action != filter->rr_action)
520 if (filter->rr_amount != RCTL_AMOUNT_UNDEFINED) {
521 if (rule->rr_amount != filter->rr_amount)
525 if (filter->rr_per != RCTL_SUBJECT_TYPE_UNDEFINED) {
526 if (rule->rr_per != filter->rr_per)
534 str2value(const char *str, int *value, struct dict *table)
541 for (i = 0; table[i].d_name != NULL; i++) {
542 if (strcasecmp(table[i].d_name, str) == 0) {
543 *value = table[i].d_value;
552 str2id(const char *str, id_t *value)
559 *value = strtoul(str, &end, 10);
560 if ((size_t)(end - str) != strlen(str))
567 str2int64(const char *str, int64_t *value)
574 *value = strtoul(str, &end, 10);
575 if ((size_t)(end - str) != strlen(str))
582 * Connect the rule to the racct, increasing refcount for the rule.
585 rctl_racct_add_rule(struct racct *racct, struct rctl_rule *rule)
587 struct rctl_rule_link *link;
589 KASSERT(rctl_rule_fully_specified(rule), ("rule not fully specified"));
591 rctl_rule_acquire(rule);
592 link = uma_zalloc(rctl_rule_link_zone, M_WAITOK);
593 link->rrl_rule = rule;
594 link->rrl_exceeded = 0;
596 rw_wlock(&rctl_lock);
597 LIST_INSERT_HEAD(&racct->r_rule_links, link, rrl_next);
598 rw_wunlock(&rctl_lock);
602 rctl_racct_add_rule_locked(struct racct *racct, struct rctl_rule *rule)
604 struct rctl_rule_link *link;
606 KASSERT(rctl_rule_fully_specified(rule), ("rule not fully specified"));
607 rw_assert(&rctl_lock, RA_WLOCKED);
609 link = uma_zalloc(rctl_rule_link_zone, M_NOWAIT);
612 rctl_rule_acquire(rule);
613 link->rrl_rule = rule;
614 link->rrl_exceeded = 0;
616 LIST_INSERT_HEAD(&racct->r_rule_links, link, rrl_next);
621 * Remove limits for a rules matching the filter and release
622 * the refcounts for the rules, possibly freeing them. Returns
623 * the number of limit structures removed.
626 rctl_racct_remove_rules(struct racct *racct,
627 const struct rctl_rule *filter)
630 struct rctl_rule_link *link, *linktmp;
632 rw_assert(&rctl_lock, RA_WLOCKED);
634 LIST_FOREACH_SAFE(link, &racct->r_rule_links, rrl_next, linktmp) {
635 if (!rctl_rule_matches(link->rrl_rule, filter))
638 LIST_REMOVE(link, rrl_next);
639 rctl_rule_release(link->rrl_rule);
640 uma_zfree(rctl_rule_link_zone, link);
647 rctl_rule_acquire_subject(struct rctl_rule *rule)
650 switch (rule->rr_subject_type) {
651 case RCTL_SUBJECT_TYPE_UNDEFINED:
652 case RCTL_SUBJECT_TYPE_PROCESS:
654 case RCTL_SUBJECT_TYPE_JAIL:
655 if (rule->rr_subject.rs_prison_racct != NULL)
656 prison_racct_hold(rule->rr_subject.rs_prison_racct);
658 case RCTL_SUBJECT_TYPE_USER:
659 if (rule->rr_subject.rs_uip != NULL)
660 uihold(rule->rr_subject.rs_uip);
662 case RCTL_SUBJECT_TYPE_LOGINCLASS:
663 if (rule->rr_subject.rs_loginclass != NULL)
664 loginclass_hold(rule->rr_subject.rs_loginclass);
667 panic("rctl_rule_acquire_subject: unknown subject type %d",
668 rule->rr_subject_type);
673 rctl_rule_release_subject(struct rctl_rule *rule)
676 switch (rule->rr_subject_type) {
677 case RCTL_SUBJECT_TYPE_UNDEFINED:
678 case RCTL_SUBJECT_TYPE_PROCESS:
680 case RCTL_SUBJECT_TYPE_JAIL:
681 if (rule->rr_subject.rs_prison_racct != NULL)
682 prison_racct_free(rule->rr_subject.rs_prison_racct);
684 case RCTL_SUBJECT_TYPE_USER:
685 if (rule->rr_subject.rs_uip != NULL)
686 uifree(rule->rr_subject.rs_uip);
688 case RCTL_SUBJECT_TYPE_LOGINCLASS:
689 if (rule->rr_subject.rs_loginclass != NULL)
690 loginclass_free(rule->rr_subject.rs_loginclass);
693 panic("rctl_rule_release_subject: unknown subject type %d",
694 rule->rr_subject_type);
699 rctl_rule_alloc(int flags)
701 struct rctl_rule *rule;
703 rule = uma_zalloc(rctl_rule_zone, flags);
706 rule->rr_subject_type = RCTL_SUBJECT_TYPE_UNDEFINED;
707 rule->rr_subject.rs_proc = NULL;
708 rule->rr_subject.rs_uip = NULL;
709 rule->rr_subject.rs_loginclass = NULL;
710 rule->rr_subject.rs_prison_racct = NULL;
711 rule->rr_per = RCTL_SUBJECT_TYPE_UNDEFINED;
712 rule->rr_resource = RACCT_UNDEFINED;
713 rule->rr_action = RCTL_ACTION_UNDEFINED;
714 rule->rr_amount = RCTL_AMOUNT_UNDEFINED;
715 refcount_init(&rule->rr_refcount, 1);
721 rctl_rule_duplicate(const struct rctl_rule *rule, int flags)
723 struct rctl_rule *copy;
725 copy = uma_zalloc(rctl_rule_zone, flags);
728 copy->rr_subject_type = rule->rr_subject_type;
729 copy->rr_subject.rs_proc = rule->rr_subject.rs_proc;
730 copy->rr_subject.rs_uip = rule->rr_subject.rs_uip;
731 copy->rr_subject.rs_loginclass = rule->rr_subject.rs_loginclass;
732 copy->rr_subject.rs_prison_racct = rule->rr_subject.rs_prison_racct;
733 copy->rr_per = rule->rr_per;
734 copy->rr_resource = rule->rr_resource;
735 copy->rr_action = rule->rr_action;
736 copy->rr_amount = rule->rr_amount;
737 refcount_init(©->rr_refcount, 1);
738 rctl_rule_acquire_subject(copy);
744 rctl_rule_acquire(struct rctl_rule *rule)
747 KASSERT(rule->rr_refcount > 0, ("rule->rr_refcount <= 0"));
749 refcount_acquire(&rule->rr_refcount);
753 rctl_rule_free(void *context, int pending)
755 struct rctl_rule *rule;
757 rule = (struct rctl_rule *)context;
759 KASSERT(rule->rr_refcount == 0, ("rule->rr_refcount != 0"));
762 * We don't need locking here; rule is guaranteed to be inaccessible.
765 rctl_rule_release_subject(rule);
766 uma_zfree(rctl_rule_zone, rule);
770 rctl_rule_release(struct rctl_rule *rule)
773 KASSERT(rule->rr_refcount > 0, ("rule->rr_refcount <= 0"));
775 if (refcount_release(&rule->rr_refcount)) {
777 * rctl_rule_release() is often called when iterating
778 * over all the uidinfo structures in the system,
779 * holding uihashtbl_lock. Since rctl_rule_free()
780 * might end up calling uifree(), this would lead
781 * to lock recursion. Use taskqueue to avoid this.
783 TASK_INIT(&rule->rr_task, 0, rctl_rule_free, rule);
784 taskqueue_enqueue(taskqueue_thread, &rule->rr_task);
789 rctl_rule_fully_specified(const struct rctl_rule *rule)
792 switch (rule->rr_subject_type) {
793 case RCTL_SUBJECT_TYPE_UNDEFINED:
795 case RCTL_SUBJECT_TYPE_PROCESS:
796 if (rule->rr_subject.rs_proc == NULL)
799 case RCTL_SUBJECT_TYPE_USER:
800 if (rule->rr_subject.rs_uip == NULL)
803 case RCTL_SUBJECT_TYPE_LOGINCLASS:
804 if (rule->rr_subject.rs_loginclass == NULL)
807 case RCTL_SUBJECT_TYPE_JAIL:
808 if (rule->rr_subject.rs_prison_racct == NULL)
812 panic("rctl_rule_fully_specified: unknown subject type %d",
813 rule->rr_subject_type);
815 if (rule->rr_resource == RACCT_UNDEFINED)
817 if (rule->rr_action == RCTL_ACTION_UNDEFINED)
819 if (rule->rr_amount == RCTL_AMOUNT_UNDEFINED)
821 if (rule->rr_per == RCTL_SUBJECT_TYPE_UNDEFINED)
828 rctl_string_to_rule(char *rulestr, struct rctl_rule **rulep)
831 char *subjectstr, *subject_idstr, *resourcestr, *actionstr,
833 struct rctl_rule *rule;
836 rule = rctl_rule_alloc(M_WAITOK);
838 subjectstr = strsep(&rulestr, ":");
839 subject_idstr = strsep(&rulestr, ":");
840 resourcestr = strsep(&rulestr, ":");
841 actionstr = strsep(&rulestr, "=/");
842 amountstr = strsep(&rulestr, "/");
845 if (subjectstr == NULL || subjectstr[0] == '\0')
846 rule->rr_subject_type = RCTL_SUBJECT_TYPE_UNDEFINED;
848 error = str2value(subjectstr, &rule->rr_subject_type, subjectnames);
853 if (subject_idstr == NULL || subject_idstr[0] == '\0') {
854 rule->rr_subject.rs_proc = NULL;
855 rule->rr_subject.rs_uip = NULL;
856 rule->rr_subject.rs_loginclass = NULL;
857 rule->rr_subject.rs_prison_racct = NULL;
859 switch (rule->rr_subject_type) {
860 case RCTL_SUBJECT_TYPE_UNDEFINED:
863 case RCTL_SUBJECT_TYPE_PROCESS:
864 error = str2id(subject_idstr, &id);
867 sx_assert(&allproc_lock, SA_LOCKED);
868 rule->rr_subject.rs_proc = pfind(id);
869 if (rule->rr_subject.rs_proc == NULL) {
873 PROC_UNLOCK(rule->rr_subject.rs_proc);
875 case RCTL_SUBJECT_TYPE_USER:
876 error = str2id(subject_idstr, &id);
879 rule->rr_subject.rs_uip = uifind(id);
881 case RCTL_SUBJECT_TYPE_LOGINCLASS:
882 rule->rr_subject.rs_loginclass =
883 loginclass_find(subject_idstr);
884 if (rule->rr_subject.rs_loginclass == NULL) {
885 error = ENAMETOOLONG;
889 case RCTL_SUBJECT_TYPE_JAIL:
890 rule->rr_subject.rs_prison_racct =
891 prison_racct_find(subject_idstr);
892 if (rule->rr_subject.rs_prison_racct == NULL) {
893 error = ENAMETOOLONG;
898 panic("rctl_string_to_rule: unknown subject type %d",
899 rule->rr_subject_type);
903 if (resourcestr == NULL || resourcestr[0] == '\0')
904 rule->rr_resource = RACCT_UNDEFINED;
906 error = str2value(resourcestr, &rule->rr_resource,
912 if (actionstr == NULL || actionstr[0] == '\0')
913 rule->rr_action = RCTL_ACTION_UNDEFINED;
915 error = str2value(actionstr, &rule->rr_action, actionnames);
920 if (amountstr == NULL || amountstr[0] == '\0')
921 rule->rr_amount = RCTL_AMOUNT_UNDEFINED;
923 error = str2int64(amountstr, &rule->rr_amount);
926 if (RACCT_IS_IN_MILLIONS(rule->rr_resource))
927 rule->rr_amount *= 1000000;
930 if (perstr == NULL || perstr[0] == '\0')
931 rule->rr_per = RCTL_SUBJECT_TYPE_UNDEFINED;
933 error = str2value(perstr, &rule->rr_per, subjectnames);
942 rctl_rule_release(rule);
948 * Link a rule with all the subjects it applies to.
951 rctl_rule_add(struct rctl_rule *rule)
957 struct prison_racct *prr;
958 struct loginclass *lc;
959 struct rctl_rule *rule2;
962 KASSERT(rctl_rule_fully_specified(rule), ("rule not fully specified"));
965 * Some rules just don't make sense. Note that the one below
966 * cannot be rewritten using RACCT_IS_DENIABLE(); the RACCT_PCTCPU,
967 * for example, is not deniable in the racct sense, but the
968 * limit is enforced in a different way, so "deny" rules for %CPU
971 if (rule->rr_action == RCTL_ACTION_DENY &&
972 (rule->rr_resource == RACCT_CPU ||
973 rule->rr_resource == RACCT_WALLCLOCK))
976 if (rule->rr_per == RCTL_SUBJECT_TYPE_PROCESS &&
977 RACCT_IS_SLOPPY(rule->rr_resource))
981 * Make sure there are no duplicated rules. Also, for the "deny"
982 * rules, remove ones differing only by "amount".
984 if (rule->rr_action == RCTL_ACTION_DENY) {
985 rule2 = rctl_rule_duplicate(rule, M_WAITOK);
986 rule2->rr_amount = RCTL_AMOUNT_UNDEFINED;
987 rctl_rule_remove(rule2);
988 rctl_rule_release(rule2);
990 rctl_rule_remove(rule);
992 switch (rule->rr_subject_type) {
993 case RCTL_SUBJECT_TYPE_PROCESS:
994 p = rule->rr_subject.rs_proc;
995 KASSERT(p != NULL, ("rctl_rule_add: NULL proc"));
997 * No resource limits for system processes.
999 if (p->p_flag & P_SYSTEM)
1002 rctl_racct_add_rule(p->p_racct, rule);
1004 * In case of per-process rule, we don't have anything more
1009 case RCTL_SUBJECT_TYPE_USER:
1010 uip = rule->rr_subject.rs_uip;
1011 KASSERT(uip != NULL, ("rctl_rule_add: NULL uip"));
1012 rctl_racct_add_rule(uip->ui_racct, rule);
1015 case RCTL_SUBJECT_TYPE_LOGINCLASS:
1016 lc = rule->rr_subject.rs_loginclass;
1017 KASSERT(lc != NULL, ("rctl_rule_add: NULL loginclass"));
1018 rctl_racct_add_rule(lc->lc_racct, rule);
1021 case RCTL_SUBJECT_TYPE_JAIL:
1022 prr = rule->rr_subject.rs_prison_racct;
1023 KASSERT(prr != NULL, ("rctl_rule_add: NULL pr"));
1024 rctl_racct_add_rule(prr->prr_racct, rule);
1028 panic("rctl_rule_add: unknown subject type %d",
1029 rule->rr_subject_type);
1033 * Now go through all the processes and add the new rule to the ones
1036 sx_assert(&allproc_lock, SA_LOCKED);
1037 FOREACH_PROC_IN_SYSTEM(p) {
1038 if (p->p_flag & P_SYSTEM)
1041 switch (rule->rr_subject_type) {
1042 case RCTL_SUBJECT_TYPE_USER:
1043 if (cred->cr_uidinfo == rule->rr_subject.rs_uip ||
1044 cred->cr_ruidinfo == rule->rr_subject.rs_uip)
1047 case RCTL_SUBJECT_TYPE_LOGINCLASS:
1048 if (cred->cr_loginclass == rule->rr_subject.rs_loginclass)
1051 case RCTL_SUBJECT_TYPE_JAIL:
1053 for (pr = cred->cr_prison; pr != NULL; pr = pr->pr_parent) {
1054 if (pr->pr_prison_racct == rule->rr_subject.rs_prison_racct) {
1063 panic("rctl_rule_add: unknown subject type %d",
1064 rule->rr_subject_type);
1067 rctl_racct_add_rule(p->p_racct, rule);
1074 rctl_rule_remove_callback(struct racct *racct, void *arg2, void *arg3)
1076 struct rctl_rule *filter = (struct rctl_rule *)arg2;
1079 rw_wlock(&rctl_lock);
1080 found += rctl_racct_remove_rules(racct, filter);
1081 rw_wunlock(&rctl_lock);
1083 *((int *)arg3) += found;
1087 * Remove all rules that match the filter.
1090 rctl_rule_remove(struct rctl_rule *filter)
1095 if (filter->rr_subject_type == RCTL_SUBJECT_TYPE_PROCESS &&
1096 filter->rr_subject.rs_proc != NULL) {
1097 p = filter->rr_subject.rs_proc;
1098 rw_wlock(&rctl_lock);
1099 found = rctl_racct_remove_rules(p->p_racct, filter);
1100 rw_wunlock(&rctl_lock);
1106 loginclass_racct_foreach(rctl_rule_remove_callback, filter,
1108 ui_racct_foreach(rctl_rule_remove_callback, filter,
1110 prison_racct_foreach(rctl_rule_remove_callback, filter,
1113 sx_assert(&allproc_lock, SA_LOCKED);
1114 rw_wlock(&rctl_lock);
1115 FOREACH_PROC_IN_SYSTEM(p) {
1116 found += rctl_racct_remove_rules(p->p_racct, filter);
1118 rw_wunlock(&rctl_lock);
1126 * Appends a rule to the sbuf.
1129 rctl_rule_to_sbuf(struct sbuf *sb, const struct rctl_rule *rule)
1133 sbuf_printf(sb, "%s:", rctl_subject_type_name(rule->rr_subject_type));
1135 switch (rule->rr_subject_type) {
1136 case RCTL_SUBJECT_TYPE_PROCESS:
1137 if (rule->rr_subject.rs_proc == NULL)
1138 sbuf_printf(sb, ":");
1140 sbuf_printf(sb, "%d:",
1141 rule->rr_subject.rs_proc->p_pid);
1143 case RCTL_SUBJECT_TYPE_USER:
1144 if (rule->rr_subject.rs_uip == NULL)
1145 sbuf_printf(sb, ":");
1147 sbuf_printf(sb, "%d:",
1148 rule->rr_subject.rs_uip->ui_uid);
1150 case RCTL_SUBJECT_TYPE_LOGINCLASS:
1151 if (rule->rr_subject.rs_loginclass == NULL)
1152 sbuf_printf(sb, ":");
1154 sbuf_printf(sb, "%s:",
1155 rule->rr_subject.rs_loginclass->lc_name);
1157 case RCTL_SUBJECT_TYPE_JAIL:
1158 if (rule->rr_subject.rs_prison_racct == NULL)
1159 sbuf_printf(sb, ":");
1161 sbuf_printf(sb, "%s:",
1162 rule->rr_subject.rs_prison_racct->prr_name);
1165 panic("rctl_rule_to_sbuf: unknown subject type %d",
1166 rule->rr_subject_type);
1169 amount = rule->rr_amount;
1170 if (amount != RCTL_AMOUNT_UNDEFINED &&
1171 RACCT_IS_IN_MILLIONS(rule->rr_resource))
1174 sbuf_printf(sb, "%s:%s=%jd",
1175 rctl_resource_name(rule->rr_resource),
1176 rctl_action_name(rule->rr_action),
1179 if (rule->rr_per != rule->rr_subject_type)
1180 sbuf_printf(sb, "/%s", rctl_subject_type_name(rule->rr_per));
1184 * Routine used by RCTL syscalls to read in input string.
1187 rctl_read_inbuf(char **inputstr, const char *inbufp, size_t inbuflen)
1195 str = malloc(inbuflen + 1, M_RCTL, M_WAITOK);
1196 error = copyinstr(inbufp, str, inbuflen, NULL);
1208 * Routine used by RCTL syscalls to write out output string.
1211 rctl_write_outbuf(struct sbuf *outputsbuf, char *outbufp, size_t outbuflen)
1215 if (outputsbuf == NULL)
1218 sbuf_finish(outputsbuf);
1219 if (outbuflen < sbuf_len(outputsbuf) + 1) {
1220 sbuf_delete(outputsbuf);
1223 error = copyout(sbuf_data(outputsbuf), outbufp,
1224 sbuf_len(outputsbuf) + 1);
1225 sbuf_delete(outputsbuf);
1229 static struct sbuf *
1230 rctl_racct_to_sbuf(struct racct *racct, int sloppy)
1236 sb = sbuf_new_auto();
1237 for (i = 0; i <= RACCT_MAX; i++) {
1238 if (sloppy == 0 && RACCT_IS_SLOPPY(i))
1240 amount = racct->r_resources[i];
1241 if (RACCT_IS_IN_MILLIONS(i))
1243 sbuf_printf(sb, "%s=%jd,", rctl_resource_name(i), amount);
1245 sbuf_setpos(sb, sbuf_len(sb) - 1);
1250 sys_rctl_get_racct(struct thread *td, struct rctl_get_racct_args *uap)
1254 struct rctl_rule *filter;
1255 struct sbuf *outputsbuf = NULL;
1257 struct uidinfo *uip;
1258 struct loginclass *lc;
1259 struct prison_racct *prr;
1261 error = priv_check(td, PRIV_RCTL_GET_RACCT);
1265 error = rctl_read_inbuf(&inputstr, uap->inbufp, uap->inbuflen);
1269 sx_slock(&allproc_lock);
1270 error = rctl_string_to_rule(inputstr, &filter);
1271 free(inputstr, M_RCTL);
1273 sx_sunlock(&allproc_lock);
1277 switch (filter->rr_subject_type) {
1278 case RCTL_SUBJECT_TYPE_PROCESS:
1279 p = filter->rr_subject.rs_proc;
1284 if (p->p_flag & P_SYSTEM) {
1288 outputsbuf = rctl_racct_to_sbuf(p->p_racct, 0);
1290 case RCTL_SUBJECT_TYPE_USER:
1291 uip = filter->rr_subject.rs_uip;
1296 outputsbuf = rctl_racct_to_sbuf(uip->ui_racct, 1);
1298 case RCTL_SUBJECT_TYPE_LOGINCLASS:
1299 lc = filter->rr_subject.rs_loginclass;
1304 outputsbuf = rctl_racct_to_sbuf(lc->lc_racct, 1);
1306 case RCTL_SUBJECT_TYPE_JAIL:
1307 prr = filter->rr_subject.rs_prison_racct;
1312 outputsbuf = rctl_racct_to_sbuf(prr->prr_racct, 1);
1318 rctl_rule_release(filter);
1319 sx_sunlock(&allproc_lock);
1323 error = rctl_write_outbuf(outputsbuf, uap->outbufp, uap->outbuflen);
1329 rctl_get_rules_callback(struct racct *racct, void *arg2, void *arg3)
1331 struct rctl_rule *filter = (struct rctl_rule *)arg2;
1332 struct rctl_rule_link *link;
1333 struct sbuf *sb = (struct sbuf *)arg3;
1335 rw_rlock(&rctl_lock);
1336 LIST_FOREACH(link, &racct->r_rule_links, rrl_next) {
1337 if (!rctl_rule_matches(link->rrl_rule, filter))
1339 rctl_rule_to_sbuf(sb, link->rrl_rule);
1340 sbuf_printf(sb, ",");
1342 rw_runlock(&rctl_lock);
1346 sys_rctl_get_rules(struct thread *td, struct rctl_get_rules_args *uap)
1349 size_t bufsize = RCTL_DEFAULT_BUFSIZE;
1350 char *inputstr, *buf;
1352 struct rctl_rule *filter;
1353 struct rctl_rule_link *link;
1356 error = priv_check(td, PRIV_RCTL_GET_RULES);
1360 error = rctl_read_inbuf(&inputstr, uap->inbufp, uap->inbuflen);
1364 sx_slock(&allproc_lock);
1365 error = rctl_string_to_rule(inputstr, &filter);
1366 free(inputstr, M_RCTL);
1368 sx_sunlock(&allproc_lock);
1373 buf = malloc(bufsize, M_RCTL, M_WAITOK);
1374 sb = sbuf_new(NULL, buf, bufsize, SBUF_FIXEDLEN);
1375 KASSERT(sb != NULL, ("sbuf_new failed"));
1377 sx_assert(&allproc_lock, SA_LOCKED);
1378 FOREACH_PROC_IN_SYSTEM(p) {
1379 rw_rlock(&rctl_lock);
1380 LIST_FOREACH(link, &p->p_racct->r_rule_links, rrl_next) {
1382 * Non-process rules will be added to the buffer later.
1383 * Adding them here would result in duplicated output.
1385 if (link->rrl_rule->rr_subject_type !=
1386 RCTL_SUBJECT_TYPE_PROCESS)
1388 if (!rctl_rule_matches(link->rrl_rule, filter))
1390 rctl_rule_to_sbuf(sb, link->rrl_rule);
1391 sbuf_printf(sb, ",");
1393 rw_runlock(&rctl_lock);
1396 loginclass_racct_foreach(rctl_get_rules_callback, filter, sb);
1397 ui_racct_foreach(rctl_get_rules_callback, filter, sb);
1398 prison_racct_foreach(rctl_get_rules_callback, filter, sb);
1399 if (sbuf_error(sb) == ENOMEM) {
1407 * Remove trailing ",".
1409 if (sbuf_len(sb) > 0)
1410 sbuf_setpos(sb, sbuf_len(sb) - 1);
1412 error = rctl_write_outbuf(sb, uap->outbufp, uap->outbuflen);
1414 rctl_rule_release(filter);
1415 sx_sunlock(&allproc_lock);
1421 sys_rctl_get_limits(struct thread *td, struct rctl_get_limits_args *uap)
1424 size_t bufsize = RCTL_DEFAULT_BUFSIZE;
1425 char *inputstr, *buf;
1427 struct rctl_rule *filter;
1428 struct rctl_rule_link *link;
1430 error = priv_check(td, PRIV_RCTL_GET_LIMITS);
1434 error = rctl_read_inbuf(&inputstr, uap->inbufp, uap->inbuflen);
1438 sx_slock(&allproc_lock);
1439 error = rctl_string_to_rule(inputstr, &filter);
1440 free(inputstr, M_RCTL);
1442 sx_sunlock(&allproc_lock);
1446 if (filter->rr_subject_type == RCTL_SUBJECT_TYPE_UNDEFINED) {
1447 rctl_rule_release(filter);
1448 sx_sunlock(&allproc_lock);
1451 if (filter->rr_subject_type != RCTL_SUBJECT_TYPE_PROCESS) {
1452 rctl_rule_release(filter);
1453 sx_sunlock(&allproc_lock);
1454 return (EOPNOTSUPP);
1456 if (filter->rr_subject.rs_proc == NULL) {
1457 rctl_rule_release(filter);
1458 sx_sunlock(&allproc_lock);
1463 buf = malloc(bufsize, M_RCTL, M_WAITOK);
1464 sb = sbuf_new(NULL, buf, bufsize, SBUF_FIXEDLEN);
1465 KASSERT(sb != NULL, ("sbuf_new failed"));
1467 rw_rlock(&rctl_lock);
1468 LIST_FOREACH(link, &filter->rr_subject.rs_proc->p_racct->r_rule_links,
1470 rctl_rule_to_sbuf(sb, link->rrl_rule);
1471 sbuf_printf(sb, ",");
1473 rw_runlock(&rctl_lock);
1474 if (sbuf_error(sb) == ENOMEM) {
1482 * Remove trailing ",".
1484 if (sbuf_len(sb) > 0)
1485 sbuf_setpos(sb, sbuf_len(sb) - 1);
1487 error = rctl_write_outbuf(sb, uap->outbufp, uap->outbuflen);
1488 rctl_rule_release(filter);
1489 sx_sunlock(&allproc_lock);
1495 sys_rctl_add_rule(struct thread *td, struct rctl_add_rule_args *uap)
1498 struct rctl_rule *rule;
1501 error = priv_check(td, PRIV_RCTL_ADD_RULE);
1505 error = rctl_read_inbuf(&inputstr, uap->inbufp, uap->inbuflen);
1509 sx_slock(&allproc_lock);
1510 error = rctl_string_to_rule(inputstr, &rule);
1511 free(inputstr, M_RCTL);
1513 sx_sunlock(&allproc_lock);
1517 * The 'per' part of a rule is optional.
1519 if (rule->rr_per == RCTL_SUBJECT_TYPE_UNDEFINED &&
1520 rule->rr_subject_type != RCTL_SUBJECT_TYPE_UNDEFINED)
1521 rule->rr_per = rule->rr_subject_type;
1523 if (!rctl_rule_fully_specified(rule)) {
1528 error = rctl_rule_add(rule);
1531 rctl_rule_release(rule);
1532 sx_sunlock(&allproc_lock);
1537 sys_rctl_remove_rule(struct thread *td, struct rctl_remove_rule_args *uap)
1540 struct rctl_rule *filter;
1543 error = priv_check(td, PRIV_RCTL_REMOVE_RULE);
1547 error = rctl_read_inbuf(&inputstr, uap->inbufp, uap->inbuflen);
1551 sx_slock(&allproc_lock);
1552 error = rctl_string_to_rule(inputstr, &filter);
1553 free(inputstr, M_RCTL);
1555 sx_sunlock(&allproc_lock);
1559 error = rctl_rule_remove(filter);
1560 rctl_rule_release(filter);
1561 sx_sunlock(&allproc_lock);
1567 * Update RCTL rule list after credential change.
1570 rctl_proc_ucred_changed(struct proc *p, struct ucred *newcred)
1573 struct rctl_rule_link *link, *newlink;
1574 struct uidinfo *newuip;
1575 struct loginclass *newlc;
1576 struct prison_racct *newprr;
1577 LIST_HEAD(, rctl_rule_link) newrules;
1579 newuip = newcred->cr_ruidinfo;
1580 newlc = newcred->cr_loginclass;
1581 newprr = newcred->cr_prison->pr_prison_racct;
1583 LIST_INIT(&newrules);
1587 * First, count the rules that apply to the process with new
1591 rw_rlock(&rctl_lock);
1592 LIST_FOREACH(link, &p->p_racct->r_rule_links, rrl_next) {
1593 if (link->rrl_rule->rr_subject_type ==
1594 RCTL_SUBJECT_TYPE_PROCESS)
1597 LIST_FOREACH(link, &newuip->ui_racct->r_rule_links, rrl_next)
1599 LIST_FOREACH(link, &newlc->lc_racct->r_rule_links, rrl_next)
1601 LIST_FOREACH(link, &newprr->prr_racct->r_rule_links, rrl_next)
1603 rw_runlock(&rctl_lock);
1606 * Create temporary list. We've dropped the rctl_lock in order
1609 for (i = 0; i < rulecnt; i++) {
1610 newlink = uma_zalloc(rctl_rule_link_zone, M_WAITOK);
1611 newlink->rrl_rule = NULL;
1612 LIST_INSERT_HEAD(&newrules, newlink, rrl_next);
1615 newlink = LIST_FIRST(&newrules);
1618 * Assign rules to the newly allocated list entries.
1620 rw_wlock(&rctl_lock);
1621 LIST_FOREACH(link, &p->p_racct->r_rule_links, rrl_next) {
1622 if (link->rrl_rule->rr_subject_type ==
1623 RCTL_SUBJECT_TYPE_PROCESS) {
1624 if (newlink == NULL)
1626 rctl_rule_acquire(link->rrl_rule);
1627 newlink->rrl_rule = link->rrl_rule;
1628 newlink = LIST_NEXT(newlink, rrl_next);
1633 LIST_FOREACH(link, &newuip->ui_racct->r_rule_links, rrl_next) {
1634 if (newlink == NULL)
1636 rctl_rule_acquire(link->rrl_rule);
1637 newlink->rrl_rule = link->rrl_rule;
1638 newlink = LIST_NEXT(newlink, rrl_next);
1642 LIST_FOREACH(link, &newlc->lc_racct->r_rule_links, rrl_next) {
1643 if (newlink == NULL)
1645 rctl_rule_acquire(link->rrl_rule);
1646 newlink->rrl_rule = link->rrl_rule;
1647 newlink = LIST_NEXT(newlink, rrl_next);
1651 LIST_FOREACH(link, &newprr->prr_racct->r_rule_links, rrl_next) {
1652 if (newlink == NULL)
1654 rctl_rule_acquire(link->rrl_rule);
1655 newlink->rrl_rule = link->rrl_rule;
1656 newlink = LIST_NEXT(newlink, rrl_next);
1662 * Free the old rule list.
1664 while (!LIST_EMPTY(&p->p_racct->r_rule_links)) {
1665 link = LIST_FIRST(&p->p_racct->r_rule_links);
1666 LIST_REMOVE(link, rrl_next);
1667 rctl_rule_release(link->rrl_rule);
1668 uma_zfree(rctl_rule_link_zone, link);
1672 * Replace lists and we're done.
1674 * XXX: Is there any way to switch list heads instead
1675 * of iterating here?
1677 while (!LIST_EMPTY(&newrules)) {
1678 newlink = LIST_FIRST(&newrules);
1679 LIST_REMOVE(newlink, rrl_next);
1680 LIST_INSERT_HEAD(&p->p_racct->r_rule_links,
1684 rw_wunlock(&rctl_lock);
1690 rw_wunlock(&rctl_lock);
1693 * Rule list changed while we were not holding the rctl_lock.
1694 * Free the new list and try again.
1696 while (!LIST_EMPTY(&newrules)) {
1697 newlink = LIST_FIRST(&newrules);
1698 LIST_REMOVE(newlink, rrl_next);
1699 if (newlink->rrl_rule != NULL)
1700 rctl_rule_release(newlink->rrl_rule);
1701 uma_zfree(rctl_rule_link_zone, newlink);
1708 * Assign RCTL rules to the newly created process.
1711 rctl_proc_fork(struct proc *parent, struct proc *child)
1714 struct rctl_rule_link *link;
1715 struct rctl_rule *rule;
1717 LIST_INIT(&child->p_racct->r_rule_links);
1720 * No limits for kernel processes.
1722 if (child->p_flag & P_SYSTEM)
1726 * Nothing to inherit from P_SYSTEM parents.
1728 if (parent->p_racct == NULL) {
1729 KASSERT(parent->p_flag & P_SYSTEM,
1730 ("non-system process without racct; p = %p", parent));
1734 rw_wlock(&rctl_lock);
1737 * Go through limits applicable to the parent and assign them
1738 * to the child. Rules with 'process' subject have to be duplicated
1739 * in order to make their rr_subject point to the new process.
1741 LIST_FOREACH(link, &parent->p_racct->r_rule_links, rrl_next) {
1742 if (link->rrl_rule->rr_subject_type ==
1743 RCTL_SUBJECT_TYPE_PROCESS) {
1744 rule = rctl_rule_duplicate(link->rrl_rule, M_NOWAIT);
1747 KASSERT(rule->rr_subject.rs_proc == parent,
1748 ("rule->rr_subject.rs_proc != parent"));
1749 rule->rr_subject.rs_proc = child;
1750 error = rctl_racct_add_rule_locked(child->p_racct,
1752 rctl_rule_release(rule);
1756 error = rctl_racct_add_rule_locked(child->p_racct,
1763 rw_wunlock(&rctl_lock);
1767 while (!LIST_EMPTY(&child->p_racct->r_rule_links)) {
1768 link = LIST_FIRST(&child->p_racct->r_rule_links);
1769 LIST_REMOVE(link, rrl_next);
1770 rctl_rule_release(link->rrl_rule);
1771 uma_zfree(rctl_rule_link_zone, link);
1773 rw_wunlock(&rctl_lock);
1778 * Release rules attached to the racct.
1781 rctl_racct_release(struct racct *racct)
1783 struct rctl_rule_link *link;
1785 rw_wlock(&rctl_lock);
1786 while (!LIST_EMPTY(&racct->r_rule_links)) {
1787 link = LIST_FIRST(&racct->r_rule_links);
1788 LIST_REMOVE(link, rrl_next);
1789 rctl_rule_release(link->rrl_rule);
1790 uma_zfree(rctl_rule_link_zone, link);
1792 rw_wunlock(&rctl_lock);
1799 rctl_rule_link_zone = uma_zcreate("rctl_rule_link",
1800 sizeof(struct rctl_rule_link), NULL, NULL, NULL, NULL,
1801 UMA_ALIGN_PTR, UMA_ZONE_NOFREE);
1802 rctl_rule_zone = uma_zcreate("rctl_rule", sizeof(struct rctl_rule),
1803 NULL, NULL, NULL, NULL, UMA_ALIGN_PTR, UMA_ZONE_NOFREE);
1809 sys_rctl_get_racct(struct thread *td, struct rctl_get_racct_args *uap)
1816 sys_rctl_get_rules(struct thread *td, struct rctl_get_rules_args *uap)
1823 sys_rctl_get_limits(struct thread *td, struct rctl_get_limits_args *uap)
1830 sys_rctl_add_rule(struct thread *td, struct rctl_add_rule_args *uap)
1837 sys_rctl_remove_rule(struct thread *td, struct rctl_remove_rule_args *uap)