Annotation of embedaddon/ntp/lib/isc/unix/resource.c, revision 1.1.1.1
1.1 misho 1: /*
2: * Copyright (C) 2004, 2007-2009 Internet Systems Consortium, Inc. ("ISC")
3: * Copyright (C) 2000, 2001 Internet Software Consortium.
4: *
5: * Permission to use, copy, modify, and/or distribute this software for any
6: * purpose with or without fee is hereby granted, provided that the above
7: * copyright notice and this permission notice appear in all copies.
8: *
9: * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
10: * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
11: * AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
12: * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
13: * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
14: * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
15: * PERFORMANCE OF THIS SOFTWARE.
16: */
17:
18: /* $Id: resource.c,v 1.21.66.2 2009/02/13 23:47:39 tbox Exp $ */
19:
20: #include <config.h>
21:
22: #include <sys/types.h>
23: #include <sys/time.h> /* Required on some systems for <sys/resource.h>. */
24: #include <sys/resource.h>
25:
26: #include <isc/platform.h>
27: #include <isc/resource.h>
28: #include <isc/result.h>
29: #include <isc/util.h>
30:
31: #ifdef __linux__
32: #include <linux/fs.h> /* To get the large NR_OPEN. */
33: #endif
34:
35: #if defined(__hpux) && defined(HAVE_SYS_DYNTUNE_H)
36: #include <sys/dyntune.h>
37: #endif
38:
39: #include "errno2result.h"
40:
41: static isc_result_t
42: resource2rlim(isc_resource_t resource, int *rlim_resource) {
43: isc_result_t result = ISC_R_SUCCESS;
44:
45: switch (resource) {
46: case isc_resource_coresize:
47: *rlim_resource = RLIMIT_CORE;
48: break;
49: case isc_resource_cputime:
50: *rlim_resource = RLIMIT_CPU;
51: break;
52: case isc_resource_datasize:
53: *rlim_resource = RLIMIT_DATA;
54: break;
55: case isc_resource_filesize:
56: *rlim_resource = RLIMIT_FSIZE;
57: break;
58: case isc_resource_lockedmemory:
59: #ifdef RLIMIT_MEMLOCK
60: *rlim_resource = RLIMIT_MEMLOCK;
61: #else
62: result = ISC_R_NOTIMPLEMENTED;
63: #endif
64: break;
65: case isc_resource_openfiles:
66: #ifdef RLIMIT_NOFILE
67: *rlim_resource = RLIMIT_NOFILE;
68: #else
69: result = ISC_R_NOTIMPLEMENTED;
70: #endif
71: break;
72: case isc_resource_processes:
73: #ifdef RLIMIT_NPROC
74: *rlim_resource = RLIMIT_NPROC;
75: #else
76: result = ISC_R_NOTIMPLEMENTED;
77: #endif
78: break;
79: case isc_resource_residentsize:
80: #ifdef RLIMIT_RSS
81: *rlim_resource = RLIMIT_RSS;
82: #else
83: result = ISC_R_NOTIMPLEMENTED;
84: #endif
85: break;
86: case isc_resource_stacksize:
87: *rlim_resource = RLIMIT_STACK;
88: break;
89: default:
90: /*
91: * This test is not very robust if isc_resource_t
92: * changes, but generates a clear assertion message.
93: */
94: REQUIRE(resource >= isc_resource_coresize &&
95: resource <= isc_resource_stacksize);
96:
97: result = ISC_R_RANGE;
98: break;
99: }
100:
101: return (result);
102: }
103:
104: isc_result_t
105: isc_resource_setlimit(isc_resource_t resource, isc_resourcevalue_t value) {
106: struct rlimit rl;
107: ISC_PLATFORM_RLIMITTYPE rlim_value;
108: int unixresult;
109: int unixresource;
110: isc_result_t result;
111:
112: result = resource2rlim(resource, &unixresource);
113: if (result != ISC_R_SUCCESS)
114: return (result);
115:
116: if (value == ISC_RESOURCE_UNLIMITED)
117: rlim_value = RLIM_INFINITY;
118:
119: else {
120: /*
121: * isc_resourcevalue_t was chosen as an unsigned 64 bit
122: * integer so that it could contain the maximum range of
123: * reasonable values. Unfortunately, this exceeds the typical
124: * range on Unix systems. Ensure the range of
125: * ISC_PLATFORM_RLIMITTYPE is not overflowed.
126: */
127: isc_resourcevalue_t rlim_max;
128: isc_boolean_t rlim_t_is_signed =
129: ISC_TF(((double)(ISC_PLATFORM_RLIMITTYPE)-1) < 0);
130:
131: if (rlim_t_is_signed)
132: rlim_max = ~((ISC_PLATFORM_RLIMITTYPE)1 <<
133: (sizeof(ISC_PLATFORM_RLIMITTYPE) * 8 - 1));
134: else
135: rlim_max = (ISC_PLATFORM_RLIMITTYPE)-1;
136:
137: if (value > rlim_max)
138: value = rlim_max;
139:
140: rlim_value = value;
141: }
142:
143: rl.rlim_cur = rl.rlim_max = rlim_value;
144: unixresult = setrlimit(unixresource, &rl);
145:
146: if (unixresult == 0)
147: return (ISC_R_SUCCESS);
148:
149: #if defined(OPEN_MAX) && defined(__APPLE__)
150: /*
151: * The Darwin kernel doesn't accept RLIM_INFINITY for rlim_cur; the
152: * maximum possible value is OPEN_MAX. BIND8 used to use
153: * sysconf(_SC_OPEN_MAX) for such a case, but this value is much
154: * smaller than OPEN_MAX and is not really effective.
155: */
156: if (resource == isc_resource_openfiles && rlim_value == RLIM_INFINITY) {
157: rl.rlim_cur = OPEN_MAX;
158: unixresult = setrlimit(unixresource, &rl);
159: if (unixresult == 0)
160: return (ISC_R_SUCCESS);
161: }
162: #elif defined(__linux__)
163: #ifndef NR_OPEN
164: #define NR_OPEN (1024*1024)
165: #endif
166:
167: /*
168: * Some Linux kernels don't accept RLIM_INFINIT; the maximum
169: * possible value is the NR_OPEN defined in linux/fs.h.
170: */
171: if (resource == isc_resource_openfiles && rlim_value == RLIM_INFINITY) {
172: rl.rlim_cur = rl.rlim_max = NR_OPEN;
173: unixresult = setrlimit(unixresource, &rl);
174: if (unixresult == 0)
175: return (ISC_R_SUCCESS);
176: }
177: #elif defined(__hpux) && defined(HAVE_SYS_DYNTUNE_H)
178: if (resource == isc_resource_openfiles && rlim_value == RLIM_INFINITY) {
179: uint64_t maxfiles;
180: if (gettune("maxfiles_lim", &maxfiles) == 0) {
181: rl.rlim_cur = rl.rlim_max = maxfiles;
182: unixresult = setrlimit(unixresource, &rl);
183: if (unixresult == 0)
184: return (ISC_R_SUCCESS);
185: }
186: }
187: #endif
188: if (resource == isc_resource_openfiles && rlim_value == RLIM_INFINITY) {
189: if (getrlimit(unixresource, &rl) == 0) {
190: rl.rlim_cur = rl.rlim_max;
191: unixresult = setrlimit(unixresource, &rl);
192: if (unixresult == 0)
193: return (ISC_R_SUCCESS);
194: }
195: }
196: return (isc__errno2result(errno));
197: }
198:
199: isc_result_t
200: isc_resource_getlimit(isc_resource_t resource, isc_resourcevalue_t *value) {
201: int unixresult;
202: int unixresource;
203: struct rlimit rl;
204: isc_result_t result;
205:
206: result = resource2rlim(resource, &unixresource);
207: if (result == ISC_R_SUCCESS) {
208: unixresult = getrlimit(unixresource, &rl);
209: INSIST(unixresult == 0);
210: *value = rl.rlim_max;
211: }
212:
213: return (result);
214: }
215:
216: isc_result_t
217: isc_resource_getcurlimit(isc_resource_t resource, isc_resourcevalue_t *value) {
218: int unixresult;
219: int unixresource;
220: struct rlimit rl;
221: isc_result_t result;
222:
223: result = resource2rlim(resource, &unixresource);
224: if (result == ISC_R_SUCCESS) {
225: unixresult = getrlimit(unixresource, &rl);
226: INSIST(unixresult == 0);
227: *value = rl.rlim_cur;
228: }
229:
230: return (result);
231: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to resource.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / ntp / lib / isc / unix