git.saurik.com Git - apple/xnu.git/blob - bsd/security/audit/audit

1 /*-

4 *

5 * Redistribution and use in source and binary forms, with or without

6 * modification, are permitted provided that the following conditions

7 * are met:

8 *

9 * 1. Redistributions of source code must retain the above copyright

10 * notice, this list of conditions and the following disclaimer.

11 * 2. Redistributions in binary form must reproduce the above copyright

12 * notice, this list of conditions and the following disclaimer in the

13 * documentation and/or other materials provided with the distribution.

14 * 3. Neither the name of Apple Inc. ("Apple") nor the names of

15 * its contributors may be used to endorse or promote products derived

16 * from this software without specific prior written permission.

17 *

18 * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY

19 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

20 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

21 * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY

22 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES

23 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

24 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND

25 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

26 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF

27 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

28 */

30 #ifndef _SECURITY_AUDIT_AUDIT_BSD_H

31 #define _SECURITY_AUDIT_AUDIT_BSD_H

33 #include <sys/cdefs.h>

34 #include <machine/endian.h>

36 #if defined(_KERNEL) || defined(KERNEL)

37 #include <kern/kalloc.h>

39 #if DIAGNOSTIC

40 #ifdef KASSERT

41 #undef KASSERT

42 #endif

43 #ifdef AUDIT_KASSERT_DEBUG

44 #define KASSERT(exp, msg) do { \

45 if (__builtin_expect(!(exp), 0)) { \

                 printf("%s:%d KASSERT failed: ", __FILE__, __LINE__);   \

47 printf msg; \

                 printf("\n");                                           \

49 } \

50 } while (0)

51 #else

52 #define KASSERT(exp, msg) do { \

53 if (__builtin_expect(!(exp), 0)) \

54 panic msg; \

55 } while (0)

56 #endif

57 #endif /* DIAGNOSTIC */

59 #define AU_MAX_LCK_NAME 32

61 #if __DARWIN_BYTE_ORDER == __DARWIN_BIG_ENDIAN

62 #define be16enc(p, d) *(p) = (d)

63 #define be32enc(p, d) *(p) = (d)

64 #define be64enc(p, d) *(p) = (d)

66 #else /* __DARWIN_BYTE_ORDER == __DARWIN_LITTLE_ENDIAN */

68 #include <libkern/OSByteOrder.h>

70 #define be16enc(p, d) OSWriteSwapInt16(p, 0, d)

71 #define be32enc(p, d) OSWriteSwapInt32(p, 0, d)

72 #define be64enc(p, d) OSWriteSwapInt64(p, 0, d)

73 #endif /* __DARWIN_BYTE_ORDER == __DARWIN_LITTLE_ENDIAN */

75 /*

76 * BSD kernel memory allocation.

77 */

78 #define AUDIT_MALLOC_DEBUG 0 /* Change to 1 for malloc debugging. */

80 #define M_AUDITUNKNOWN 0

81 #define M_AUDITDATA 1

82 #define M_AUDITPATH 2

83 #define M_AUDITTEXT 3

84 #define M_AUDITBSM 4

85 #define M_AUDITEVCLASS 5

86 #define M_AUDIT_PIPE 6

87 #define M_AUDIT_PIPE_ENTRY 7

88 #define M_AUDIT_PIPE_PRESELECT 8

89 #define M_AU_SESSION 9

90 #define M_AU_EV_PLIST 10

92 #define NUM_MALLOC_TYPES 11

94 #ifdef M_WAITOK

95 #undef M_WAITOK

96 #define M_WAITOK 0x0000 /* ok to block */

97 #endif

98 #ifdef M_NOWAIT

99 #undef M_NOWAIT

100 #endif

101 #define M_NOWAIT 0x0001 /* do not block */

102 #ifdef M_ZERO

103 #undef M_ZERO

104 #endif

105 #define M_ZERO 0x0004 /* bzero the allocation */

106

107 #ifdef M_MAGIC

108 #undef M_MAGIC

109 #endif

110 #define M_MAGIC 877983977

111

112 #ifdef MALLOC_DEFINE

113 #undef MALLOC_DEFINE

114 #endif

115 #if AUDIT_MALLOC_DEBUG

116 struct au_malloc_type {

117 SInt64 mt_size;

118 SInt64 mt_maxsize;

119 SInt32 mt_inuse;

120 SInt32 mt_maxused;

121 unsigned mt_type;

122 unsigned mt_magic;

123 const char *mt_shortdesc;

124 const char *mt_lastcaller;

125 };

126 typedef struct au_malloc_type au_malloc_type_t;

127

128 #define MALLOC_DEFINE(type, shortdesc, longdesc) \

129 au_malloc_type_t audit_##type[1] = { \

130 { 0, 0, 0, 0, (type < NUM_MALLOC_TYPES) ? type :\

131 M_AUDITUNKNOWN, M_MAGIC, shortdesc, NULL } \

132 }

133

134 extern au_malloc_type_t *audit_malloc_types[];

135

136 #else

137

138 struct au_malloc_type {

139 uint32_t mt_magic;

140 const char *mt_shortdesc;

141 };

142 typedef struct au_malloc_type au_malloc_type_t;

143

144 #define MALLOC_DEFINE(type, shortdesc, longdesc) \

145 au_malloc_type_t audit_##type[1] = { \

146 {M_MAGIC, shortdesc } \

147 }

148

149 #endif /* AUDIT_MALLOC_DEBUG */

150

151 #ifdef MALLOC_DECLARE

152 #undef MALLOC_DECLARE

153 #endif

154 #define MALLOC_DECLARE(type) \

155 extern au_malloc_type_t audit_##type[]

156

157 #if AUDIT_MALLOC_DEBUG

158 #define malloc(sz, tp, fl) _audit_malloc(sz, audit_##tp, fl, __FUNCTION__)

 void *_audit_malloc(size_t size, au_malloc_type_t *type, int flags,

160 const char *fn);

161 #else

162 #define malloc(sz, tp, fl) _audit_malloc(sz, audit_##tp, fl)

 void *_audit_malloc(size_t size, au_malloc_type_t *type, int flags);

164 #endif

165

166 #define free(ad, tp) _audit_free(ad, audit_##tp)

 void _audit_free(void *addr, au_malloc_type_t *type);

168

169 /*

170 * BSD condition variable.

171 */

172 struct cv {

173 const char *cv_description;

174 int cv_waiters;

175 };

176

177 /*

178 * BSD mutex.

179 */

180 struct mtx {

181 lck_mtx_t *mtx_lock;

182 #if DIAGNOSTIC

183 char mtx_name[AU_MAX_LCK_NAME];

184 #endif

185 };

186

187 /*

188 * BSD rw lock.

189 */

190 struct rwlock {

191 lck_rw_t *rw_lock;

192 #if DIAGNOSTIC

193 char rw_name[AU_MAX_LCK_NAME];

194 #endif

195 };

196

197 /*

198 * Sleep lock.

199 */

200 struct slck {

201 lck_mtx_t *sl_mtx;

202 int sl_locked;

203 int sl_waiting;

204 #if DIAGNOSTIC

205 char sl_name[AU_MAX_LCK_NAME];

206 #endif

207 };

208

209 /*

210 * Recursive lock.

211 */

212 struct rlck {

213 lck_mtx_t *rl_mtx;

214 uint32_t rl_recurse;

215 thread_t rl_thread;

216 #if DIAGNOSTIC

217 char rl_name[AU_MAX_LCK_NAME];

218 #endif

219 };

220

221 /*

222 * BSD condition variables functions.

223 */

 void    _audit_cv_init(struct cv *cvp, const char *desc);

 void    _audit_cv_destroy(struct cv *cvp);

 void    _audit_cv_signal(struct cv *cvp);

 void    _audit_cv_broadcast(struct cv *cvp);

 void    _audit_cv_wait(struct cv *cvp, lck_mtx_t *mp, const char *desc);

 int     _audit_cv_wait_sig(struct cv *cvp, lck_mtx_t *mp, const char *desc);

 int     _audit_cv_wait_continuation(struct cv *cvp, lck_mtx_t *mp,

231 thread_continue_t function);

232 #define cv_init(cvp, desc) _audit_cv_init(cvp, desc)

233 #define cv_destroy(cvp) _audit_cv_destroy(cvp)

234 #define cv_signal(cvp) _audit_cv_signal(cvp)

235 #define cv_broadcast(cvp) _audit_cv_broadcast(cvp)

236 #define cv_broadcastpri(cvp, pri) _audit_cv_broadcast(cvp)

237 #define cv_wait(cvp, mp) _audit_cv_wait(cvp, (mp)->mtx_lock, #cvp)

238 #define cv_wait_sig(cvp, mp) _audit_cv_wait_sig(cvp, (mp)->mtx_lock, #cvp)

239 #define cv_wait_continuation(cvp, mp, f) \

240 _audit_cv_wait_continuation(cvp, (mp)->mtx_lock, f)

241

242 /*

243 * BSD Mutexes.

244 */

 void    _audit_mtx_init(struct mtx *mp, const char *name);

 void    _audit_mtx_destroy(struct mtx *mp);

247 #define mtx_init(mp, name, type, opts) \

248 _audit_mtx_init(mp, name)

249 #define mtx_lock(mp) lck_mtx_lock((mp)->mtx_lock)

250 #define mtx_unlock(mp) lck_mtx_unlock((mp)->mtx_lock)

251 #define mtx_destroy(mp) _audit_mtx_destroy(mp)

252 #define mtx_yield(mp) lck_mtx_yield((mp)->mtx_lock)

253

254 /*

255 * Sleep lock functions.

256 */

 void            _audit_slck_init(struct slck *lp, const char *grpname);

 wait_result_t   _audit_slck_lock(struct slck *lp, int intr);

 void            _audit_slck_unlock(struct slck *lp);

 int             _audit_slck_trylock(struct slck *lp);

 void            _audit_slck_assert(struct slck *lp, u_int assert);

 void            _audit_slck_destroy(struct slck *lp);

263 #define slck_init(lp, name) _audit_slck_init((lp), (name))

264 #define slck_lock(lp) _audit_slck_lock((lp), 0)

265 #define slck_lock_sig(lp) (_audit_slck_lock((lp), 1) != THREAD_AWAKENED)

266 #define slck_unlock(lp) _audit_slck_unlock((lp))

267 #define slck_destroy(lp) _audit_slck_destroy((lp))

268

269 /*

270 * Recursive lock functions.

271 */

 void            _audit_rlck_init(struct rlck *lp, const char *grpname);

 void            _audit_rlck_lock(struct rlck *lp);

 void            _audit_rlck_unlock(struct rlck *lp);

 void            _audit_rlck_assert(struct rlck *lp, u_int assert);

 void            _audit_rlck_destroy(struct rlck *lp);

277 #define rlck_init(lp, name) _audit_rlck_init((lp), (name))

278 #define rlck_lock(lp) _audit_rlck_lock((lp))

279 #define rlck_unlock(lp) _audit_rlck_unlock((lp))

280 #define rlck_destroy(lp) _audit_rlck_destroy((lp))

281

282 /*

283 * BSD rw locks.

284 */

 void    _audit_rw_init(struct rwlock *lp, const char *name);

 void    _audit_rw_destroy(struct rwlock *lp);

287 #define rw_init(lp, name) _audit_rw_init(lp, name)

288 #define rw_rlock(lp) lck_rw_lock_shared((lp)->rw_lock)

289 #define rw_runlock(lp) lck_rw_unlock_shared((lp)->rw_lock)

290 #define rw_wlock(lp) lck_rw_lock_exclusive((lp)->rw_lock)

291 #define rw_wunlock(lp) lck_rw_unlock_exclusive((lp)->rw_lock)

292 #define rw_destroy(lp) _audit_rw_destroy(lp)

293

294 #define MA_OWNED LCK_MTX_ASSERT_OWNED

295 #define RA_LOCKED LCK_RW_ASSERT_HELD

296 #define RA_RLOCKED LCK_RW_ASSERT_SHARED

297 #define RA_WLOCKED LCK_RW_ASSERT_EXCLUSIVE

298 #define SA_LOCKED LCK_RW_ASSERT_HELD

299 #define SA_XLOCKED LCK_RW_ASSERT_EXCLUSIVE

300 #define SL_OWNED LCK_MTX_ASSERT_OWNED

301 #define SL_NOTOWNED LCK_MTX_ASSERT_NOTOWNED

302 #if DIAGNOSTIC

303 #define mtx_assert(mp, wht) lck_mtx_assert((mp)->mtx_lock, wht)

304 #define rw_assert(lp, wht) lck_rw_assert((lp)->rw_lock, wht)

305 #define sx_assert(lp, wht) lck_rw_assert((lp)->sx_lock, wht)

306 #define rlck_assert(lp, wht) _audit_rlck_assert((lp), wht)

307 #define slck_assert(lp, wht) _audit_slck_assert((lp), wht)

308 #else

309 #define mtx_assert(mp, wht)

310 #define rw_assert(lp, wht)

311 #define sx_assert(lp, wht)

312 #define rlck_assert(lp, wht)

313 #define slck_assert(lp, wht)

314 #endif /* DIAGNOSTIC */

315

316 /*

317 * BSD (IPv6) event rate limiter.

318 */

 int _audit_ppsratecheck(struct timeval *lasttime, int *curpps, int maxpps);

320 #define ppsratecheck(tv, cr, mr) _audit_ppsratecheck(tv, cr, mr)

321

322 #endif /* defined(_KERNEL) || defined(KERNEL) */

323 #endif /* _SECURITY_AUDIT_AUDIT_BSD_H */