1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21 /*
22 * Copyright 2006 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 */
25
26 #include <sys/types.h>
27 #include <sys/cmn_err.h>
28 #include <sys/sysmacros.h>
29 #include <sys/proc.h>
30 #include <sys/rctl.h>
31 #include <sys/rctl_impl.h>
32 #include <sys/port_kernel.h>
33 #include <sys/signal.h>
34
35 #include <sys/vmparam.h>
36 #include <sys/machparam.h>
37
38 /*
39 * Process-based resource controls
40 * The structure of the kernel leaves us no particular place where the process
41 * abstraction can be declared--it is intertwined with the growth of the Unix
42 * kernel. Accordingly, we place all of the resource control logic associated
43 * with processes, both existing and future, in this file.
44 */
45
46 rctl_hndl_t rctlproc_legacy[RLIM_NLIMITS];
47 uint_t rctlproc_flags[RLIM_NLIMITS] = {
48 RCTL_LOCAL_SIGNAL, /* RLIMIT_CPU */
49 RCTL_LOCAL_DENY | RCTL_LOCAL_SIGNAL, /* RLIMIT_FSIZE */
50 RCTL_LOCAL_DENY, /* RLIMIT_DATA */
51 RCTL_LOCAL_DENY, /* RLIMIT_STACK */
52 RCTL_LOCAL_DENY, /* RLIMIT_CORE */
53 RCTL_LOCAL_DENY, /* RLIMIT_NOFILE */
54 RCTL_LOCAL_DENY /* RLIMIT_VMEM */
55 };
56 int rctlproc_signals[RLIM_NLIMITS] = {
57 SIGXCPU, /* RLIMIT_CPU */
58 SIGXFSZ, /* RLIMIT_FSIZE */
59 0, 0, 0, 0, 0 /* remainder do not signal */
60 };
61
62 rctl_hndl_t rc_process_msgmnb;
63 rctl_hndl_t rc_process_msgtql;
64 rctl_hndl_t rc_process_semmsl;
65 rctl_hndl_t rc_process_semopm;
66 rctl_hndl_t rc_process_portev;
67 rctl_hndl_t rc_process_sigqueue;
68
69 /*
70 * process.max-cpu-time / RLIMIT_CPU
71 */
72 /*ARGSUSED*/
73 static int
74 proc_cpu_time_test(struct rctl *rctl, struct proc *p, rctl_entity_p_t *e,
75 rctl_val_t *rval, rctl_qty_t inc, uint_t flags)
76 {
77 return (inc >= rval->rcv_value);
78 }
79
80 static rctl_ops_t proc_cpu_time_ops = {
81 rcop_no_action,
82 rcop_no_usage,
83 rcop_no_set,
84 proc_cpu_time_test
85 };
86
87 /*
88 * process.max-file-size / RLIMIT_FSIZE
89 */
90 static int
91 proc_filesize_set(rctl_t *rctl, struct proc *p, rctl_entity_p_t *e,
92 rctl_qty_t nv)
93 {
94 if (p->p_model == DATAMODEL_NATIVE)
95 nv = MIN(nv, rctl->rc_dict_entry->rcd_max_native);
96 else
97 nv = MIN(nv, rctl->rc_dict_entry->rcd_max_ilp32);
98
99 ASSERT(e->rcep_t == RCENTITY_PROCESS);
100 e->rcep_p.proc->p_fsz_ctl = nv;
101
102 return (0);
103 }
104
105 static rctl_ops_t proc_filesize_ops = {
106 rcop_no_action,
107 rcop_no_usage,
108 proc_filesize_set,
109 rcop_no_test
110 };
111
112 /*
113 * process.max-data / RLIMIT_DATA
114 */
115
116 /*
117 * process.max-stack-size / RLIMIT_STACK
118 */
119 static int
120 proc_stack_set(rctl_t *rctl, struct proc *p, rctl_entity_p_t *e,
121 rctl_qty_t nv)
122 {
123 klwp_t *lwp = ttolwp(curthread);
124
125 if (p->p_model == DATAMODEL_NATIVE)
126 nv = MIN(nv, rctl->rc_dict_entry->rcd_max_native);
127 else
128 nv = MIN(nv, rctl->rc_dict_entry->rcd_max_ilp32);
129
130 /*
131 * In the process of changing the rlimit, this function actually
132 * gets called a number of times. We only want to save the current
133 * rlimit the first time we come through here. In post_syscall(),
134 * we copyin() the lwp's ustack, and compare it to the rlimit we
135 * save here; if the two match, we adjust the ustack to reflect
136 * the new stack bounds.
137 *
138 * We check to make sure that we're changing the rlimit of our
139 * own process rather than on behalf of some other process. The
140 * notion of changing this resource limit on behalf of another
141 * process is problematic at best, and changing the amount of stack
142 * space a process is allowed to consume is a rather antiquated
143 * notion that has limited applicability in our multithreaded
144 * process model.
145 */
146 ASSERT(e->rcep_t == RCENTITY_PROCESS);
147 if (lwp != NULL && lwp->lwp_procp == e->rcep_p.proc &&
148 lwp->lwp_ustack && lwp->lwp_old_stk_ctl == 0) {
149 lwp->lwp_old_stk_ctl = (size_t)e->rcep_p.proc->p_stk_ctl;
150 curthread->t_post_sys = 1;
151 }
152
153 e->rcep_p.proc->p_stk_ctl = nv;
154
155 return (0);
156 }
157
158 static rctl_ops_t proc_stack_ops = {
159 rcop_no_action,
160 rcop_no_usage,
161 proc_stack_set,
162 rcop_no_test
163 };
164
165 /*
166 * process.max-file-descriptors / RLIMIT_NOFILE
167 */
168 static int
169 proc_nofile_set(rctl_t *rctl, struct proc *p, rctl_entity_p_t *e, rctl_qty_t nv)
170 {
171 ASSERT(e->rcep_t == RCENTITY_PROCESS);
172 if (p->p_model == DATAMODEL_NATIVE)
173 nv = MIN(nv, rctl->rc_dict_entry->rcd_max_native);
174 else
175 nv = MIN(nv, rctl->rc_dict_entry->rcd_max_ilp32);
176
177 e->rcep_p.proc->p_fno_ctl = nv;
178
179 return (0);
180 }
181
182 static rctl_ops_t proc_nofile_ops = {
183 rcop_no_action,
184 rcop_no_usage,
185 proc_nofile_set,
186 rcop_absolute_test
187 };
188
189 /*
190 * process.max-address-space / RLIMIT_VMEM
191 */
192 static int
193 proc_vmem_set(rctl_t *rctl, struct proc *p, rctl_entity_p_t *e, rctl_qty_t nv)
194 {
195 ASSERT(e->rcep_t == RCENTITY_PROCESS);
196 if (p->p_model == DATAMODEL_ILP32)
197 nv = MIN(nv, rctl->rc_dict_entry->rcd_max_ilp32);
198 else
199 nv = MIN(nv, rctl->rc_dict_entry->rcd_max_native);
200
201 e->rcep_p.proc->p_vmem_ctl = nv;
202
203 return (0);
204 }
205
206 static rctl_ops_t proc_vmem_ops = {
207 rcop_no_action,
208 rcop_no_usage,
209 proc_vmem_set,
210 rcop_no_test
211 };
212
213 /*
214 * void rctlproc_default_init()
215 *
216 * Overview
217 * Establish default basic and privileged control values on the init process.
218 * These correspond to the soft and hard limits, respectively.
219 */
220 void
221 rctlproc_default_init(struct proc *initp, rctl_alloc_gp_t *gp)
222 {
223 struct rlimit64 rlp64;
224
225 /*
226 * RLIMIT_CPU: deny never, sigtoproc(pp, NULL, SIGXCPU).
227 */
228 rlp64.rlim_cur = rlp64.rlim_max = RLIM64_INFINITY;
229 (void) rctl_rlimit_set(rctlproc_legacy[RLIMIT_CPU], initp, &rlp64, gp,
230 RCTL_LOCAL_SIGNAL, SIGXCPU, kcred);
231
232 /*
233 * RLIMIT_FSIZE: deny always, sigtoproc(pp, NULL, SIGXFSZ).
234 */
235 rlp64.rlim_cur = rlp64.rlim_max = RLIM64_INFINITY;
236 (void) rctl_rlimit_set(rctlproc_legacy[RLIMIT_FSIZE], initp, &rlp64, gp,
237 RCTL_LOCAL_SIGNAL | RCTL_LOCAL_DENY, SIGXFSZ, kcred);
238
239 /*
240 * RLIMIT_DATA: deny always, no default action.
241 */
242 rlp64.rlim_cur = rlp64.rlim_max = RLIM64_INFINITY;
243 (void) rctl_rlimit_set(rctlproc_legacy[RLIMIT_DATA], initp, &rlp64, gp,
244 RCTL_LOCAL_DENY, 0, kcred);
245
246 /*
247 * RLIMIT_STACK: deny always, no default action.
248 */
249 #ifdef __sparc
250 rlp64.rlim_cur = DFLSSIZ;
251 rlp64.rlim_max = LONG_MAX;
252 #else
253 rlp64.rlim_cur = DFLSSIZ;
254 rlp64.rlim_max = MAXSSIZ;
255 #endif
256 (void) rctl_rlimit_set(rctlproc_legacy[RLIMIT_STACK], initp, &rlp64, gp,
257 RCTL_LOCAL_DENY, 0, kcred);
258
259 /*
260 * RLIMIT_CORE: deny always, no default action.
261 */
262 rlp64.rlim_cur = rlp64.rlim_max = RLIM64_INFINITY;
263 (void) rctl_rlimit_set(rctlproc_legacy[RLIMIT_CORE], initp, &rlp64, gp,
264 RCTL_LOCAL_DENY, 0, kcred);
265
266 /*
267 * RLIMIT_NOFILE: deny always, no action.
268 */
269 rlp64.rlim_cur = rlim_fd_cur;
270 rlp64.rlim_max = rlim_fd_max;
271 (void) rctl_rlimit_set(rctlproc_legacy[RLIMIT_NOFILE], initp, &rlp64,
272 gp, RCTL_LOCAL_DENY, 0, kcred);
273
274 /*
275 * RLIMIT_VMEM
276 */
277 rlp64.rlim_cur = rlp64.rlim_max = RLIM64_INFINITY;
278 (void) rctl_rlimit_set(rctlproc_legacy[RLIMIT_VMEM], initp, &rlp64, gp,
279 RCTL_LOCAL_DENY, 0, kcred);
280 }
281
282 /*
283 * void rctlproc_init()
284 *
285 * Overview
286 * Register the various resource controls associated with process entities.
287 * The historical rlim_infinity_map and rlim_infinity32_map are now encoded
288 * here as the native and ILP32 infinite values for each resource control.
289 */
290 void
291 rctlproc_init(void)
292 {
293 rctl_set_t *set;
294 rctl_alloc_gp_t *gp;
295 rctl_entity_p_t e;
296
297 rctlproc_legacy[RLIMIT_CPU] = rctl_register("process.max-cpu-time",
298 RCENTITY_PROCESS, RCTL_GLOBAL_LOWERABLE | RCTL_GLOBAL_DENY_NEVER |
299 RCTL_GLOBAL_CPU_TIME | RCTL_GLOBAL_INFINITE | RCTL_GLOBAL_SECONDS,
300 UINT64_MAX, UINT64_MAX, &proc_cpu_time_ops);
301 rctlproc_legacy[RLIMIT_FSIZE] = rctl_register("process.max-file-size",
302 RCENTITY_PROCESS, RCTL_GLOBAL_LOWERABLE | RCTL_GLOBAL_DENY_ALWAYS |
303 RCTL_GLOBAL_FILE_SIZE | RCTL_GLOBAL_BYTES,
304 MAXOFFSET_T, MAXOFFSET_T, &proc_filesize_ops);
305 rctlproc_legacy[RLIMIT_DATA] = rctl_register("process.max-data-size",
306 RCENTITY_PROCESS, RCTL_GLOBAL_LOWERABLE | RCTL_GLOBAL_DENY_ALWAYS |
307 RCTL_GLOBAL_SIGNAL_NEVER | RCTL_GLOBAL_BYTES,
308 ULONG_MAX, UINT32_MAX, &rctl_default_ops);
309 #ifdef _LP64
310 #ifdef __sparc
311 rctlproc_legacy[RLIMIT_STACK] = rctl_register("process.max-stack-size",
312 RCENTITY_PROCESS, RCTL_GLOBAL_LOWERABLE | RCTL_GLOBAL_DENY_ALWAYS |
313 RCTL_GLOBAL_SIGNAL_NEVER | RCTL_GLOBAL_BYTES,
314 LONG_MAX, INT32_MAX, &proc_stack_ops);
315 #else /* __sparc */
316 rctlproc_legacy[RLIMIT_STACK] = rctl_register("process.max-stack-size",
317 RCENTITY_PROCESS, RCTL_GLOBAL_LOWERABLE | RCTL_GLOBAL_DENY_ALWAYS |
318 RCTL_GLOBAL_SIGNAL_NEVER | RCTL_GLOBAL_BYTES,
319 MAXSSIZ, USRSTACK32 - PAGESIZE, &proc_stack_ops);
320 #endif /* __sparc */
321 #else /* _LP64 */
322 rctlproc_legacy[RLIMIT_STACK] = rctl_register("process.max-stack-size",
323 RCENTITY_PROCESS, RCTL_GLOBAL_LOWERABLE | RCTL_GLOBAL_DENY_ALWAYS |
324 RCTL_GLOBAL_SIGNAL_NEVER | RCTL_GLOBAL_BYTES,
325 USRSTACK - PAGESIZE, USRSTACK - PAGESIZE, &proc_stack_ops);
326 #endif
327 rctlproc_legacy[RLIMIT_CORE] = rctl_register("process.max-core-size",
328 RCENTITY_PROCESS, RCTL_GLOBAL_LOWERABLE | RCTL_GLOBAL_DENY_ALWAYS |
329 RCTL_GLOBAL_SIGNAL_NEVER | RCTL_GLOBAL_BYTES,
330 MIN(MAXOFFSET_T, ULONG_MAX), UINT32_MAX, &rctl_default_ops);
331 rctlproc_legacy[RLIMIT_NOFILE] = rctl_register(
332 "process.max-file-descriptor", RCENTITY_PROCESS,
333 RCTL_GLOBAL_LOWERABLE | RCTL_GLOBAL_DENY_ALWAYS |
334 RCTL_GLOBAL_COUNT, INT32_MAX, INT32_MAX, &proc_nofile_ops);
335 rctlproc_legacy[RLIMIT_VMEM] =
336 rctl_register("process.max-address-space", RCENTITY_PROCESS,
337 RCTL_GLOBAL_LOWERABLE | RCTL_GLOBAL_DENY_ALWAYS |
338 RCTL_GLOBAL_SIGNAL_NEVER | RCTL_GLOBAL_BYTES,
339 ULONG_MAX, UINT32_MAX, &proc_vmem_ops);
340
341 rc_process_semmsl = rctl_register("process.max-sem-nsems",
342 RCENTITY_PROCESS, RCTL_GLOBAL_DENY_ALWAYS | RCTL_GLOBAL_COUNT,
343 SHRT_MAX, SHRT_MAX, &rctl_absolute_ops);
344 rctl_add_legacy_limit("process.max-sem-nsems", "semsys",
345 "seminfo_semmsl", 512, SHRT_MAX);
346
347 rc_process_semopm = rctl_register("process.max-sem-ops",
348 RCENTITY_PROCESS, RCTL_GLOBAL_DENY_ALWAYS | RCTL_GLOBAL_COUNT,
349 INT_MAX, INT_MAX, &rctl_absolute_ops);
350 rctl_add_legacy_limit("process.max-sem-ops", "semsys",
351 "seminfo_semopm", 512, INT_MAX);
352
353 rc_process_msgmnb = rctl_register("process.max-msg-qbytes",
354 RCENTITY_PROCESS, RCTL_GLOBAL_DENY_ALWAYS | RCTL_GLOBAL_BYTES,
355 ULONG_MAX, ULONG_MAX, &rctl_absolute_ops);
356 rctl_add_legacy_limit("process.max-msg-qbytes", "msgsys",
357 "msginfo_msgmnb", 65536, ULONG_MAX);
358
359 rc_process_msgtql = rctl_register("process.max-msg-messages",
360 RCENTITY_PROCESS, RCTL_GLOBAL_DENY_ALWAYS | RCTL_GLOBAL_COUNT,
361 UINT_MAX, UINT_MAX, &rctl_absolute_ops);
362 rctl_add_legacy_limit("process.max-msg-messages", "msgsys",
363 "msginfo_msgtql", 8192, UINT_MAX);
364
365 rc_process_portev = rctl_register("process.max-port-events",
366 RCENTITY_PROCESS, RCTL_GLOBAL_DENY_ALWAYS | RCTL_GLOBAL_COUNT,
367 PORT_MAX_EVENTS, PORT_MAX_EVENTS, &rctl_absolute_ops);
368 rctl_add_default_limit("process.max-port-events", PORT_DEFAULT_EVENTS,
369 RCPRIV_PRIVILEGED, RCTL_LOCAL_DENY);
370
371 rc_process_sigqueue = rctl_register("process.max-sigqueue-size",
372 RCENTITY_PROCESS, RCTL_GLOBAL_LOWERABLE | RCTL_GLOBAL_DENY_ALWAYS |
373 RCTL_GLOBAL_COUNT, _SIGQUEUE_SIZE_MAX, _SIGQUEUE_SIZE_MAX,
374 &rctl_absolute_ops);
375 rctl_add_default_limit("process.max-sigqueue-size",
376 _SIGQUEUE_SIZE_BASIC, RCPRIV_BASIC, RCTL_LOCAL_DENY);
377 rctl_add_default_limit("process.max-sigqueue-size",
378 _SIGQUEUE_SIZE_PRIVILEGED, RCPRIV_PRIVILEGED, RCTL_LOCAL_DENY);
379
380 /*
381 * Place minimal set of controls on "sched" process for inheritance by
382 * processes created via newproc().
383 */
384 set = rctl_set_create();
385 gp = rctl_set_init_prealloc(RCENTITY_PROCESS);
386 mutex_enter(&curproc->p_lock);
387 e.rcep_p.proc = curproc;
388 e.rcep_t = RCENTITY_PROCESS;
389 curproc->p_rctls = rctl_set_init(RCENTITY_PROCESS, curproc, &e,
390 set, gp);
391 mutex_exit(&curproc->p_lock);
392 rctl_prealloc_destroy(gp);
393 }