Warning: That file was not part of the compilation database. It may have many parsing errors.

1 | /* Copyright (C) 2018-2019 Free Software Foundation, Inc. |
---|---|

2 | This file is part of the GNU C Library. |

3 | |

4 | The GNU C Library is free software; you can redistribute it and/or |

5 | modify it under the terms of the GNU Lesser General Public |

6 | License as published by the Free Software Foundation; either |

7 | version 2.1 of the License, or (at your option) any later version. |

8 | |

9 | The GNU C Library is distributed in the hope that it will be useful, |

10 | but WITHOUT ANY WARRANTY; without even the implied warranty of |

11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |

12 | Lesser General Public License for more details. |

13 | |

14 | You should have received a copy of the GNU Lesser General Public |

15 | License along with the GNU C Library; if not, see |

16 | <http://www.gnu.org/licenses/>. */ |

17 | |

18 | #include <errno.h> |

19 | #include <stdio.h> |

20 | #include <sys/resource.h> |

21 | #include <support/check.h> |

22 | |

23 | static int resources[] = { |

24 | /* The following 7 limits are part of POSIX and must exist. */ |

25 | RLIMIT_CORE, |

26 | RLIMIT_CPU, |

27 | RLIMIT_DATA, |

28 | RLIMIT_FSIZE, |

29 | RLIMIT_NOFILE, |

30 | RLIMIT_STACK, |

31 | RLIMIT_AS |

32 | }; |

33 | |

34 | #define nresources (sizeof (resources) / sizeof (resources[0])) |

35 | |

36 | /* Assume that the prlimit64 function calls the prlimit64 syscall without |

37 | mangling the arguments. */ |

38 | #define PRLIMIT64_INFINITY ((rlim64_t) -1) |

39 | |

40 | /* As we don't know which limit will be modified, use a sufficiently high |

41 | value to not shoot ourself in the foot. Use a 32-bit value to test |

42 | both the 32- and 64-bit versions, and keep the highest bit clear to |

43 | avoid sign extension. */ |

44 | #define PRLIMIT64_TESTVAL ((rlim64_t) 0x42420000) |

45 | |

46 | static void |

47 | test_getrlimit (int resource, rlim_t exp_cur, rlim_t exp_max) |

48 | { |

49 | struct rlimit r; |

50 | TEST_VERIFY_EXIT (getrlimit (resource, &r) == 0); |

51 | TEST_COMPARE (r.rlim_cur, exp_cur); |

52 | TEST_COMPARE (r.rlim_max, exp_max); |

53 | } |

54 | |

55 | static void |

56 | test_getrlimit64 (int resource, rlim64_t exp_cur, rlim64_t exp_max) |

57 | { |

58 | struct rlimit64 r; |

59 | TEST_VERIFY_EXIT (getrlimit64 (resource, &r) == 0); |

60 | TEST_COMPARE (r.rlim_cur, exp_cur); |

61 | TEST_COMPARE (r.rlim_max, exp_max); |

62 | } |

63 | |

64 | static void |

65 | test_prlimit_get (int resource, rlim_t exp_cur, rlim_t exp_max) |

66 | { |

67 | struct rlimit r; |

68 | TEST_VERIFY_EXIT (prlimit (0, resource, NULL, &r) == 0); |

69 | TEST_COMPARE (r.rlim_cur, exp_cur); |

70 | TEST_COMPARE (r.rlim_max, exp_max); |

71 | } |

72 | |

73 | static void |

74 | test_prlimit64_get (int resource, rlim64_t exp_cur, rlim64_t exp_max) |

75 | { |

76 | struct rlimit64 r; |

77 | TEST_COMPARE (prlimit64 (0, resource, NULL, &r), 0); |

78 | TEST_COMPARE (r.rlim_cur, exp_cur); |

79 | TEST_COMPARE (r.rlim_max, exp_max); |

80 | } |

81 | |

82 | static void |

83 | test_setrlimit (int resource, rlim_t new_cur, rlim_t new_max) |

84 | { |

85 | struct rlimit r = { new_cur, new_max }; |

86 | TEST_COMPARE (setrlimit (resource, &r), 0); |

87 | } |

88 | |

89 | static void |

90 | test_setrlimit64 (int resource, rlim64_t new_cur, rlim64_t new_max) |

91 | { |

92 | struct rlimit64 r = { new_cur, new_max }; |

93 | TEST_COMPARE (setrlimit64 (resource, &r), 0); |

94 | } |

95 | |

96 | static void |

97 | test_prlimit_set (int resource, rlim_t new_cur, rlim_t new_max) |

98 | { |

99 | struct rlimit r = { new_cur, new_max }; |

100 | TEST_COMPARE (prlimit (0, resource, &r, NULL), 0); |

101 | } |

102 | |

103 | static void |

104 | test_prlimit64_set (int resource, rlim64_t new_cur, rlim64_t new_max) |

105 | { |

106 | struct rlimit64 r = { new_cur, new_max }; |

107 | TEST_COMPARE (prlimit64 (0, resource, &r, NULL), 0); |

108 | } |

109 | |

110 | static int |

111 | do_test (void) |

112 | { |

113 | int resource = -1; |

114 | |

115 | /* Find a resource with hard limit set to infinity, so that the soft limit |

116 | can be manipulated to any value. */ |

117 | for (int i = 0; i < nresources; ++i) |

118 | { |

119 | struct rlimit64 r64; |

120 | int res = prlimit64 (0, resources[i], NULL, &r64); |

121 | if ((res == 0) && (r64.rlim_max == PRLIMIT64_INFINITY)) |

122 | { |

123 | resource = resources[i]; |

124 | break; |

125 | } |

126 | } |

127 | |

128 | if (resource == -1) |

129 | FAIL_UNSUPPORTED |

130 | ("Could not find and limit with hard limit set to infinity."); |

131 | |

132 | /* First check that the get functions work correctly with the test value. */ |

133 | test_prlimit64_set (resource, PRLIMIT64_TESTVAL, PRLIMIT64_INFINITY); |

134 | test_getrlimit (resource, PRLIMIT64_TESTVAL, RLIM_INFINITY); |

135 | test_getrlimit64 (resource, PRLIMIT64_TESTVAL, RLIM64_INFINITY); |

136 | test_prlimit_get (resource, PRLIMIT64_TESTVAL, RLIM_INFINITY); |

137 | test_prlimit64_get (resource, PRLIMIT64_TESTVAL, RLIM64_INFINITY); |

138 | |

139 | /* Then check that the get functions work correctly with infinity. */ |

140 | test_prlimit64_set (resource, PRLIMIT64_INFINITY, PRLIMIT64_INFINITY); |

141 | test_getrlimit (resource, RLIM_INFINITY, RLIM_INFINITY); |

142 | test_getrlimit64 (resource, RLIM64_INFINITY, RLIM64_INFINITY); |

143 | test_prlimit_get (resource, RLIM_INFINITY, RLIM_INFINITY); |

144 | test_prlimit64_get (resource, RLIM64_INFINITY, RLIM64_INFINITY); |

145 | |

146 | /* Then check that setrlimit works correctly with the test value. */ |

147 | test_setrlimit (resource, PRLIMIT64_TESTVAL, RLIM_INFINITY); |

148 | test_prlimit64_get (resource, PRLIMIT64_TESTVAL, PRLIMIT64_INFINITY); |

149 | |

150 | /* Then check that setrlimit works correctly with infinity. */ |

151 | test_setrlimit (resource, RLIM_INFINITY, RLIM_INFINITY); |

152 | test_prlimit64_get (resource, PRLIMIT64_INFINITY, PRLIMIT64_INFINITY); |

153 | |

154 | /* Then check that setrlimit64 works correctly with the test value. */ |

155 | test_setrlimit64 (resource, PRLIMIT64_TESTVAL, RLIM64_INFINITY); |

156 | test_prlimit64_get (resource, PRLIMIT64_TESTVAL, PRLIMIT64_INFINITY); |

157 | |

158 | /* Then check that setrlimit64 works correctly with infinity. */ |

159 | test_setrlimit64 (resource, RLIM64_INFINITY, RLIM64_INFINITY); |

160 | test_prlimit64_get (resource, PRLIMIT64_INFINITY, PRLIMIT64_INFINITY); |

161 | |

162 | /* Then check that prlimit works correctly with the test value. */ |

163 | test_prlimit_set (resource, RLIM_INFINITY, RLIM_INFINITY); |

164 | test_prlimit64_get (resource, PRLIMIT64_INFINITY, PRLIMIT64_INFINITY); |

165 | |

166 | /* Finally check that prlimit works correctly with infinity. */ |

167 | test_prlimit_set (resource, PRLIMIT64_TESTVAL, RLIM_INFINITY); |

168 | test_prlimit64_get (resource, PRLIMIT64_TESTVAL, PRLIMIT64_INFINITY); |

169 | |

170 | return 0; |

171 | } |

172 | |

173 | #include <support/test-driver.c> |

174 |

Warning: That file was not part of the compilation database. It may have many parsing errors.