[apple/xnu.git] / tests / proc_rlimit.c

/*
 * cd $XNU/tests
 * xcrun -sdk macosx.internal/iphoneos.internal make proc_rlimit LDFLAGS="-ldarwintest"
 */
#include <stdio.h>
#include <unistd.h>
#include <sys/resource.h>
#include <errno.h>
#include <sys/sysctl.h>
#include <darwintest.h>

/* Defined in <sys/resource.h> but not visible to user space */
#define RLIMIT_NLIMITS 9

/* Defined in <sys/resource.h> and visible to user space */
static const char *RESOURCE_STRING[] = {
	"RLIMIT_CPU",     /* #define RLIMIT_CPU      0 */
	"RLIMIT_FSIZE",   /* #define RLIMIT_FSIZE    1 */
	"RLIMIT_DATA",    /* #define RLIMIT_DATA     2 */
	"RLIMIT_STACK",   /* #define RLIMIT_STACK    3 */
	"RLIMIT_CORE",    /* #define RLIMIT_CORE     4 */
	"RLIMIT_AS/RSS",  /* #define RLIMIT_AS       5 */
	/* #define RLIMIT_RSS      RLIMIT_AS */
	"RLIMIT_MEMLOCK", /* #define RLIMIT_MEMLOCK  6 */
	"RLIMIT_NPROC",   /* #define RLIMIT_NPROC    7 */
	"RLIMIT_NOFILE"   /* #define RLIMIT_NOFILE   8 */
};

/* Change limit values by this arbitrary amount */
#define LIMIT_DIFF 64

/* Limit type */
#define SOFT_LIMIT 0
#define HARD_LIMIT 1

/* Action on changing limit values */
#define LOWER 0
#define RAISE 1

static struct rlimit orig_rlimit[RLIMIT_NLIMITS];

/* Maximum number of open files allowed by normal user */
static rlim_t maxfilesperproc;
static size_t maxfilesperproc_size = sizeof(maxfilesperproc);

/* Maximum number of open files allowed by super user */
static rlim_t maxfiles;
static size_t maxfiles_size = sizeof(maxfiles);

/* Maximum number of simultaneous processes allowed by normal user */
static rlim_t maxprocperuid;
static size_t maxprocperuid_size = sizeof(maxprocperuid);

/* Maximum number of simultaneous processes allowed by super user */
static rlim_t maxproc;
static size_t maxproc_size = sizeof(maxproc);

static bool superuser = FALSE;

static int
get_initial_rlimits(void)
{
	int err = -1;
	int i;

	for (i = 0; i < RLIMIT_NLIMITS; i++) {
		err = getrlimit(i, &orig_rlimit[i]);
		T_QUIET; T_EXPECT_EQ(0, err, "getrlimit(%15s, soft: 0x%16llx, hard 0x%16llx) %s", RESOURCE_STRING[i], orig_rlimit[i].rlim_cur, orig_rlimit[i].rlim_max, err == 0 ? "" : strerror(errno));
	}
	return err;
}

static void
print_rlimits(bool initial_limits)
{
	int err;
	int i;

	for (i = 0; i < RLIMIT_NLIMITS; i++) {
		struct rlimit lim;

		if (initial_limits) {
			lim = orig_rlimit[i];
		} else {
			err = getrlimit(i, &lim);
			T_QUIET; T_EXPECT_EQ(0, err, "getrlimit(%15s, soft: 0x%16llx, hard 0x%16llx) %s", RESOURCE_STRING[i], lim.rlim_cur, lim.rlim_max, err == 0 ? "" : strerror(errno));
		}
		T_LOG("%35s soft: 0x%16llx hard 0x%16llx", RESOURCE_STRING[i], lim.rlim_cur, lim.rlim_max);
	}
}

/*
 * Change "limit_type" of all of the process's "rlimit" by amount
 *
 * limit_type: SOFT_LIMIT/HARD_LIMIT
 * amount:     rlim_t
 * action:     RAISE/LOWER
 */
static void
change_rlimits(int limit_type, rlim_t amount, int action)
{
	int err = -1;
	int i;

	for (i = 0; i < RLIMIT_NLIMITS; i++) {
		struct rlimit newlim;     // for setrlimit
		struct rlimit verifylim;  // for getrlimit
		bool expect_failure = FALSE;
		int expect_errno = 0;

		/* Get the current limit values */
		err = getrlimit(i, &newlim);
		T_EXPECT_EQ(0, err, "getrlimit(%15s, soft: 0x%16llx, hard 0x%16llx) %s", RESOURCE_STRING[i], newlim.rlim_cur, newlim.rlim_max, err == 0 ? "" : strerror(errno));

		/* Changing soft limit */
		if (limit_type == SOFT_LIMIT) {
			if (action == RAISE) {
				/* Raising soft limits to exceed hard limits is not allowed and we expect to see failure on setrlimit call later */
				if (newlim.rlim_cur + amount > newlim.rlim_max) {
					expect_failure = TRUE;
					expect_errno = EINVAL;
				}
				newlim.rlim_cur += amount;
			} else if (action == LOWER) {
				if (newlim.rlim_cur == 0) {
					/* Soft limit might be 0 already, if so skip lowering it */
				} else {
					newlim.rlim_cur -= amount;
				}
			} else {
				T_FAIL("Unknown action on soft limit: %d", action);
			}
		}
		/* Changing hard limit */
		else if (limit_type == HARD_LIMIT) {
			if (action == RAISE) {
				newlim.rlim_max += amount;

				/* Raising hard limits is not allowed for normal user and we expect to see failure on setrlimit call later */
				expect_failure = TRUE;
				expect_errno = EPERM;
			} else if (action == LOWER) {
				if (newlim.rlim_max == 0) {
					/* Hard limit might be 0 already, if so skip lowering it (e.g., RLIMIT_CORE on iOS) */
				} else {
					newlim.rlim_max -= amount;
				}
				/* Soft limit might need to be changed as well since soft cannot be greater than hard  */
				if (newlim.rlim_cur > newlim.rlim_max) {
					newlim.rlim_cur = newlim.rlim_max;
				}
			} else {
				T_FAIL("Unknown action on hard limit: %d", action);
			}
		}
		/* Changing unknown limit type */
		else {
			T_FAIL("Unknown limit type: %d", limit_type);
		}

		/* Request the kernel to change limit values */
		err = setrlimit(i, &newlim);

		if (expect_failure) {
			/* We expect the setrlimit call to fail */
			T_EXPECT_EQ(-1, err, "setrlimit(%15s, soft: 0x%16llx, hard 0x%16llx) failed as expected: %s", RESOURCE_STRING[i], newlim.rlim_cur, newlim.rlim_max, strerror(errno));
			T_EXPECT_EQ(expect_errno, errno, "Expect errno %d, errno returned %d", expect_errno, errno);
			continue;
		} else {
			T_EXPECT_EQ(0, err, "setrlimit(%15s, soft: 0x%16llx, hard 0x%16llx) %s", RESOURCE_STRING[i], newlim.rlim_cur, newlim.rlim_max, err == 0 ? "" : strerror(errno));
		}

		/* Verify the kernel correctly changed the limit values */
		err = getrlimit(i, &verifylim);
		T_EXPECT_EQ(0, err, "getrlimit(%15s, soft: 0x%16llx, hard 0x%16llx) %s", RESOURCE_STRING[i], verifylim.rlim_cur, verifylim.rlim_max, err == 0 ? "" : strerror(errno));

		/* The kernel forces the hard limit of RLIMIT_NOFILE to be at most maxfileperproc for normal user when changing the hard limit with setrlimit */
		if (i == RLIMIT_NOFILE && limit_type == HARD_LIMIT && newlim.rlim_max > maxfilesperproc) {
			if (newlim.rlim_cur != verifylim.rlim_cur ||
			    maxfilesperproc != verifylim.rlim_max) {
				T_FAIL("Mismatch limit values %s despite a successful setrlimit call (setrlimit'd soft 0x%16llx hard 0x%16llx but getrlimit'd soft 0x%16llx hard 0x%16llx)",
				    RESOURCE_STRING[i], newlim.rlim_cur, newlim.rlim_max, verifylim.rlim_cur, verifylim.rlim_max);
			}
		}
		/* The kernel forces the hard limit of RLIMIT_NPROC to be at most maxproc for normal user when changing either soft/hard limit with setrlimit */
		else if (i == RLIMIT_NPROC && newlim.rlim_max > maxprocperuid) {
			if (newlim.rlim_cur != verifylim.rlim_cur ||
			    maxprocperuid != verifylim.rlim_max) {
				T_FAIL("Mismatch limit values %s despite a successful setrlimit call (setrlimit'd soft 0x%16llx hard 0x%16llx but getrlimit'd soft 0x%16llx hard 0x%16llx)",
				    RESOURCE_STRING[i], newlim.rlim_cur, newlim.rlim_max, verifylim.rlim_cur, verifylim.rlim_max);
			}
		} else {
			if (newlim.rlim_cur != verifylim.rlim_cur ||
			    newlim.rlim_max != verifylim.rlim_max) {
				T_FAIL("Mismatch limit values %s despite a successful setrlimit call (setrlimit'd soft 0x%16llx hard 0x%16llx but getrlimit'd soft 0x%16llx hard 0x%16llx)",
				    RESOURCE_STRING[i], newlim.rlim_cur, newlim.rlim_max, verifylim.rlim_cur, verifylim.rlim_max);
			}
		}
	}
}

T_DECL(proc_rlimit,
    "Test basic functionalities of the getrlimit and setrlimit")
{
	int err;
	struct rlimit lim;

	T_SETUPBEGIN;

	if (geteuid() == 0) {
		superuser = TRUE;
		T_SKIP("This test should not be run as super user.");
	}

	/* Use sysctl to query the real limits of RLIMIT_NOFILE/RLIMIT_NPROC for normal user on Apple's systems */
	err = sysctlbyname("kern.maxfilesperproc", &maxfilesperproc, &maxfilesperproc_size, NULL, 0);
	T_EXPECT_EQ_INT(0, err, "maxfilesperproc: %llu", maxfilesperproc);

	err = sysctlbyname("kern.maxprocperuid", &maxprocperuid, &maxprocperuid_size, NULL, 0);
	T_EXPECT_EQ_INT(0, err, "maxprocperuid: %llu", maxprocperuid);

	/* Use sysctl to query the real limits of RLIMIT_NOFILE/RLIMIT_NPROC for super user on Apple's systems (placeholder for adding super user tests) */
	err = sysctlbyname("kern.maxfiles", &maxfiles, &maxfiles_size, NULL, 0);
	T_EXPECT_EQ_INT(0, err, "maxfiles: %llu", maxfiles);

	err = sysctlbyname("kern.maxproc", &maxproc, &maxproc_size, NULL, 0);
	T_EXPECT_EQ_INT(0, err, "maxproc: %llu", maxproc);

	/* Issue getrlimit syscall to retrieve the initial resource limit values before calling setrlimit */
	err = get_initial_rlimits();
	T_EXPECT_EQ(0, err, "Obtained initial resource values.");

	/* Print out resource limit values to stdout for less-painful triage in case needed */
	T_LOG("Resource limits before the test:");
	print_rlimits(TRUE);

	T_SETUPEND;

	/* Lower soft limits by arbitrary amount */
	T_LOG("---------Lowering soft limits by 0x%x---------:\n", LIMIT_DIFF);
	change_rlimits(SOFT_LIMIT, LIMIT_DIFF, LOWER);

	/* Raise soft limits back to the orginal values */
	T_LOG("---------Raising soft limits by 0x%x---------:\n", LIMIT_DIFF);
	change_rlimits(SOFT_LIMIT, LIMIT_DIFF, RAISE);

	/* Lower hard limits */
	T_LOG("---------Lowering hard limits by 0x%x---------:", LIMIT_DIFF);
	change_rlimits(HARD_LIMIT, LIMIT_DIFF, LOWER);

	/* Raise soft limits to exceed hard limits (setrlimit should fail, but the darwintest should pass) */
	T_LOG("---------Attempting to raised soft limits by 0x%x to exceed hard limits---------:", LIMIT_DIFF);
	change_rlimits(SOFT_LIMIT, LIMIT_DIFF, RAISE);

	/* Raise hard limits (setrlimit should fail, but the darwintest should pass) */
	T_LOG("---------Attempting to raise hard limits by 0x%x---------:", LIMIT_DIFF);
	change_rlimits(HARD_LIMIT, LIMIT_DIFF, RAISE);

	/* Get and set a non-existing resource limit */
	T_LOG("---------Accessing a non-existing resource---------:");
	err = getrlimit(RLIMIT_NLIMITS + 1, &lim);
	T_EXPECT_EQ(-1, err, "Expect getrlimit to fail when accessing a non-existing resource: %s\n", strerror(errno));
	T_EXPECT_EQ(EINVAL, errno, "Expect errno %d, errno returned %d", EINVAL, errno);

	err = setrlimit(RLIMIT_NLIMITS + 1, &lim);
	T_EXPECT_EQ(-1, err, "Expect setrlimit to fail when accessing a non-existing resource: %s\n", strerror(errno));
	T_EXPECT_EQ(EINVAL, errno, "Expect errno %d, errno returned %d", EINVAL, errno);

	T_LOG("Resource limits after the test:");
	print_rlimits(FALSE);
}
Commit	Line	Data
f427ee49 A	1	/*
	2	* cd $XNU/tests
	3	* xcrun -sdk macosx.internal/iphoneos.internal make proc_rlimit LDFLAGS="-ldarwintest"
	4	*/
	5	#include <stdio.h>
	6	#include <unistd.h>
	7	#include <sys/resource.h>
	8	#include <errno.h>
	9	#include <sys/sysctl.h>
	10	#include <darwintest.h>
	11
	12	/* Defined in <sys/resource.h> but not visible to user space */
	13	#define RLIMIT_NLIMITS 9
	14
	15	/* Defined in <sys/resource.h> and visible to user space */
	16	static const char *RESOURCE_STRING[] = {
	17	"RLIMIT_CPU", /* #define RLIMIT_CPU 0 */
	18	"RLIMIT_FSIZE", /* #define RLIMIT_FSIZE 1 */
	19	"RLIMIT_DATA", /* #define RLIMIT_DATA 2 */
	20	"RLIMIT_STACK", /* #define RLIMIT_STACK 3 */
	21	"RLIMIT_CORE", /* #define RLIMIT_CORE 4 */
	22	"RLIMIT_AS/RSS", /* #define RLIMIT_AS 5 */
	23	/* #define RLIMIT_RSS RLIMIT_AS */
	24	"RLIMIT_MEMLOCK", /* #define RLIMIT_MEMLOCK 6 */
	25	"RLIMIT_NPROC", /* #define RLIMIT_NPROC 7 */
	26	"RLIMIT_NOFILE" /* #define RLIMIT_NOFILE 8 */
	27	};
	28
	29	/* Change limit values by this arbitrary amount */
	30	#define LIMIT_DIFF 64
	31
	32	/* Limit type */
	33	#define SOFT_LIMIT 0
	34	#define HARD_LIMIT 1
	35
	36	/* Action on changing limit values */
	37	#define LOWER 0
	38	#define RAISE 1
	39
	40	static struct rlimit orig_rlimit[RLIMIT_NLIMITS];
	41
	42	/* Maximum number of open files allowed by normal user */
	43	static rlim_t maxfilesperproc;
	44	static size_t maxfilesperproc_size = sizeof(maxfilesperproc);
	45
	46	/* Maximum number of open files allowed by super user */
	47	static rlim_t maxfiles;
	48	static size_t maxfiles_size = sizeof(maxfiles);
	49
	50	/* Maximum number of simultaneous processes allowed by normal user */
	51	static rlim_t maxprocperuid;
	52	static size_t maxprocperuid_size = sizeof(maxprocperuid);
	53
	54	/* Maximum number of simultaneous processes allowed by super user */
	55	static rlim_t maxproc;
	56	static size_t maxproc_size = sizeof(maxproc);
	57
	58	static bool superuser = FALSE;
	59
	60	static int
	61	get_initial_rlimits(void)
	62	{
	63	int err = -1;
	64	int i;
65
66	for (i = 0; i < RLIMIT_NLIMITS; i++) {
67	err = getrlimit(i, &orig_rlimit[i]);
68	T_QUIET; T_EXPECT_EQ(0, err, "getrlimit(%15s, soft: 0x%16llx, hard 0x%16llx) %s", RESOURCE_STRING[i], orig_rlimit[i].rlim_cur, orig_rlimit[i].rlim_max, err == 0 ? "" : strerror(errno));
69	}
70	return err;
71	}
72
73	static void
74	print_rlimits(bool initial_limits)
75	{
76	int err;
77	int i;
78
79	for (i = 0; i < RLIMIT_NLIMITS; i++) {
80	struct rlimit lim;
81
82	if (initial_limits) {
83	lim = orig_rlimit[i];
84	} else {
85	err = getrlimit(i, &lim);
86	T_QUIET; T_EXPECT_EQ(0, err, "getrlimit(%15s, soft: 0x%16llx, hard 0x%16llx) %s", RESOURCE_STRING[i], lim.rlim_cur, lim.rlim_max, err == 0 ? "" : strerror(errno));
87	}
88	T_LOG("%35s soft: 0x%16llx hard 0x%16llx", RESOURCE_STRING[i], lim.rlim_cur, lim.rlim_max);
89	}
90	}
91
92	/*
93	* Change "limit_type" of all of the process's "rlimit" by amount
94	*
95	* limit_type: SOFT_LIMIT/HARD_LIMIT
96	* amount: rlim_t
97	* action: RAISE/LOWER
98	*/
99	static void
100	change_rlimits(int limit_type, rlim_t amount, int action)
101	{
102	int err = -1;
103	int i;
104
105	for (i = 0; i < RLIMIT_NLIMITS; i++) {
106	struct rlimit newlim; // for setrlimit
107	struct rlimit verifylim; // for getrlimit
108	bool expect_failure = FALSE;
109	int expect_errno = 0;
110
111	/* Get the current limit values */
112	err = getrlimit(i, &newlim);
113	T_EXPECT_EQ(0, err, "getrlimit(%15s, soft: 0x%16llx, hard 0x%16llx) %s", RESOURCE_STRING[i], newlim.rlim_cur, newlim.rlim_max, err == 0 ? "" : strerror(errno));
114
115	/* Changing soft limit */
116	if (limit_type == SOFT_LIMIT) {
117	if (action == RAISE) {
118	/* Raising soft limits to exceed hard limits is not allowed and we expect to see failure on setrlimit call later */
119	if (newlim.rlim_cur + amount > newlim.rlim_max) {
120	expect_failure = TRUE;
121	expect_errno = EINVAL;
122	}
123	newlim.rlim_cur += amount;
124	} else if (action == LOWER) {
125	if (newlim.rlim_cur == 0) {
126	/* Soft limit might be 0 already, if so skip lowering it */
127	} else {
128	newlim.rlim_cur -= amount;
129	}
130	} else {
131	T_FAIL("Unknown action on soft limit: %d", action);
132	}
133	}
134	/* Changing hard limit */
135	else if (limit_type == HARD_LIMIT) {
136	if (action == RAISE) {
137	newlim.rlim_max += amount;
138
139	/* Raising hard limits is not allowed for normal user and we expect to see failure on setrlimit call later */
140	expect_failure = TRUE;
141	expect_errno = EPERM;
142	} else if (action == LOWER) {
143	if (newlim.rlim_max == 0) {
144	/* Hard limit might be 0 already, if so skip lowering it (e.g., RLIMIT_CORE on iOS) */
145	} else {
146	newlim.rlim_max -= amount;
147	}
148	/* Soft limit might need to be changed as well since soft cannot be greater than hard */
149	if (newlim.rlim_cur > newlim.rlim_max) {
150	newlim.rlim_cur = newlim.rlim_max;
151	}
152	} else {
153	T_FAIL("Unknown action on hard limit: %d", action);
154	}
155	}
156	/* Changing unknown limit type */
157	else {
158	T_FAIL("Unknown limit type: %d", limit_type);
159	}
160
161	/* Request the kernel to change limit values */
162	err = setrlimit(i, &newlim);
163
164	if (expect_failure) {
165	/* We expect the setrlimit call to fail */
166	T_EXPECT_EQ(-1, err, "setrlimit(%15s, soft: 0x%16llx, hard 0x%16llx) failed as expected: %s", RESOURCE_STRING[i], newlim.rlim_cur, newlim.rlim_max, strerror(errno));
167	T_EXPECT_EQ(expect_errno, errno, "Expect errno %d, errno returned %d", expect_errno, errno);
168	continue;
169	} else {
170	T_EXPECT_EQ(0, err, "setrlimit(%15s, soft: 0x%16llx, hard 0x%16llx) %s", RESOURCE_STRING[i], newlim.rlim_cur, newlim.rlim_max, err == 0 ? "" : strerror(errno));
171	}
172
173	/* Verify the kernel correctly changed the limit values */
174	err = getrlimit(i, &verifylim);
175	T_EXPECT_EQ(0, err, "getrlimit(%15s, soft: 0x%16llx, hard 0x%16llx) %s", RESOURCE_STRING[i], verifylim.rlim_cur, verifylim.rlim_max, err == 0 ? "" : strerror(errno));
176
177	/* The kernel forces the hard limit of RLIMIT_NOFILE to be at most maxfileperproc for normal user when changing the hard limit with setrlimit */
178	if (i == RLIMIT_NOFILE && limit_type == HARD_LIMIT && newlim.rlim_max > maxfilesperproc) {
179	if (newlim.rlim_cur != verifylim.rlim_cur \|\|
180	maxfilesperproc != verifylim.rlim_max) {
181	T_FAIL("Mismatch limit values %s despite a successful setrlimit call (setrlimit'd soft 0x%16llx hard 0x%16llx but getrlimit'd soft 0x%16llx hard 0x%16llx)",
182	RESOURCE_STRING[i], newlim.rlim_cur, newlim.rlim_max, verifylim.rlim_cur, verifylim.rlim_max);
183	}
184	}
185	/* The kernel forces the hard limit of RLIMIT_NPROC to be at most maxproc for normal user when changing either soft/hard limit with setrlimit */
186	else if (i == RLIMIT_NPROC && newlim.rlim_max > maxprocperuid) {
187	if (newlim.rlim_cur != verifylim.rlim_cur \|\|
188	maxprocperuid != verifylim.rlim_max) {
189	T_FAIL("Mismatch limit values %s despite a successful setrlimit call (setrlimit'd soft 0x%16llx hard 0x%16llx but getrlimit'd soft 0x%16llx hard 0x%16llx)",
190	RESOURCE_STRING[i], newlim.rlim_cur, newlim.rlim_max, verifylim.rlim_cur, verifylim.rlim_max);
191	}
192	} else {
193	if (newlim.rlim_cur != verifylim.rlim_cur \|\|
194	newlim.rlim_max != verifylim.rlim_max) {
195	T_FAIL("Mismatch limit values %s despite a successful setrlimit call (setrlimit'd soft 0x%16llx hard 0x%16llx but getrlimit'd soft 0x%16llx hard 0x%16llx)",
196	RESOURCE_STRING[i], newlim.rlim_cur, newlim.rlim_max, verifylim.rlim_cur, verifylim.rlim_max);
197	}
198	}
199	}
200	}
201
202	T_DECL(proc_rlimit,
203	"Test basic functionalities of the getrlimit and setrlimit")
204	{
205	int err;
206	struct rlimit lim;
207
208	T_SETUPBEGIN;
209
210	if (geteuid() == 0) {
211	superuser = TRUE;
212	T_SKIP("This test should not be run as super user.");
213	}
214
215	/* Use sysctl to query the real limits of RLIMIT_NOFILE/RLIMIT_NPROC for normal user on Apple's systems */
216	err = sysctlbyname("kern.maxfilesperproc", &maxfilesperproc, &maxfilesperproc_size, NULL, 0);
217	T_EXPECT_EQ_INT(0, err, "maxfilesperproc: %llu", maxfilesperproc);
218
219	err = sysctlbyname("kern.maxprocperuid", &maxprocperuid, &maxprocperuid_size, NULL, 0);
220	T_EXPECT_EQ_INT(0, err, "maxprocperuid: %llu", maxprocperuid);
221
222	/* Use sysctl to query the real limits of RLIMIT_NOFILE/RLIMIT_NPROC for super user on Apple's systems (placeholder for adding super user tests) */
223	err = sysctlbyname("kern.maxfiles", &maxfiles, &maxfiles_size, NULL, 0);
224	T_EXPECT_EQ_INT(0, err, "maxfiles: %llu", maxfiles);
225
226	err = sysctlbyname("kern.maxproc", &maxproc, &maxproc_size, NULL, 0);
227	T_EXPECT_EQ_INT(0, err, "maxproc: %llu", maxproc);
228
229	/* Issue getrlimit syscall to retrieve the initial resource limit values before calling setrlimit */
230	err = get_initial_rlimits();
231	T_EXPECT_EQ(0, err, "Obtained initial resource values.");
232
233	/* Print out resource limit values to stdout for less-painful triage in case needed */
234	T_LOG("Resource limits before the test:");
235	print_rlimits(TRUE);
236
237	T_SETUPEND;
238
239	/* Lower soft limits by arbitrary amount */
240	T_LOG("---------Lowering soft limits by 0x%x---------:\n", LIMIT_DIFF);
241	change_rlimits(SOFT_LIMIT, LIMIT_DIFF, LOWER);
242
243	/* Raise soft limits back to the orginal values */
244	T_LOG("---------Raising soft limits by 0x%x---------:\n", LIMIT_DIFF);
245	change_rlimits(SOFT_LIMIT, LIMIT_DIFF, RAISE);
246
247	/* Lower hard limits */
248	T_LOG("---------Lowering hard limits by 0x%x---------:", LIMIT_DIFF);
249	change_rlimits(HARD_LIMIT, LIMIT_DIFF, LOWER);
250
251	/* Raise soft limits to exceed hard limits (setrlimit should fail, but the darwintest should pass) */
252	T_LOG("---------Attempting to raised soft limits by 0x%x to exceed hard limits---------:", LIMIT_DIFF);
253	change_rlimits(SOFT_LIMIT, LIMIT_DIFF, RAISE);
254
255	/* Raise hard limits (setrlimit should fail, but the darwintest should pass) */
256	T_LOG("---------Attempting to raise hard limits by 0x%x---------:", LIMIT_DIFF);
257	change_rlimits(HARD_LIMIT, LIMIT_DIFF, RAISE);
258
259	/* Get and set a non-existing resource limit */
260	T_LOG("---------Accessing a non-existing resource---------:");
261	err = getrlimit(RLIMIT_NLIMITS + 1, &lim);
262	T_EXPECT_EQ(-1, err, "Expect getrlimit to fail when accessing a non-existing resource: %s\n", strerror(errno));
263	T_EXPECT_EQ(EINVAL, errno, "Expect errno %d, errno returned %d", EINVAL, errno);
264
265	err = setrlimit(RLIMIT_NLIMITS + 1, &lim);
266	T_EXPECT_EQ(-1, err, "Expect setrlimit to fail when accessing a non-existing resource: %s\n", strerror(errno));
267	T_EXPECT_EQ(EINVAL, errno, "Expect errno %d, errno returned %d", EINVAL, errno);
268
269	T_LOG("Resource limits after the test:");
270	print_rlimits(FALSE);
271	}