]>
git.ipfire.org Git - thirdparty/systemd.git/blob - src/basic/util.h
1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
6 This file is part of systemd.
8 Copyright 2010 Lennart Poettering
10 systemd is free software; you can redistribute it and/or modify it
11 under the terms of the GNU Lesser General Public License as published by
12 the Free Software Foundation; either version 2.1 of the License, or
13 (at your option) any later version.
15 systemd is distributed in the hope that it will be useful, but
16 WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 Lesser General Public License for more details.
20 You should have received a copy of the GNU Lesser General Public License
21 along with systemd; If not, see <http://www.gnu.org/licenses/>.
34 #include <sys/inotify.h>
35 #include <sys/socket.h>
37 #include <sys/statfs.h>
38 #include <sys/types.h>
42 #include "formats-util.h"
45 #include "time-util.h"
47 /* What is interpreted as whitespace? */
48 #define WHITESPACE " \t\n\r"
49 #define NEWLINE "\n\r"
52 #define GLOB_CHARS "*?["
54 size_t page_size(void) _pure_
;
55 #define PAGE_ALIGN(l) ALIGN_TO((l), page_size())
57 #define new(t, n) ((t*) malloc_multiply(sizeof(t), (n)))
59 #define new0(t, n) ((t*) calloc((n), sizeof(t)))
61 #define newa(t, n) ((t*) alloca(sizeof(t)*(n)))
63 #define newa0(t, n) ((t*) alloca0(sizeof(t)*(n)))
65 #define newdup(t, p, n) ((t*) memdup_multiply(p, sizeof(t), (n)))
67 #define malloc0(n) (calloc(1, (n)))
69 static inline void *mfree(void *memory
) {
74 static inline const char* yes_no(bool b
) {
75 return b
? "yes" : "no";
78 static inline const char* true_false(bool b
) {
79 return b
? "true" : "false";
82 static inline const char* one_zero(bool b
) {
86 bool fstype_is_network(const char *fstype
);
88 noreturn
void freeze(void);
90 void execute_directories(const char* const* directories
, usec_t timeout
, char *argv
[]);
92 bool plymouth_running(void);
94 bool display_is_local(const char *display
) _pure_
;
95 int socket_from_display(const char *display
, char **path
);
97 int glob_exists(const char *path
);
98 int glob_extend(char ***strv
, const char *path
);
100 int block_get_whole_disk(dev_t d
, dev_t
*ret
);
102 #define NULSTR_FOREACH(i, l) \
103 for ((i) = (l); (i) && *(i); (i) = strchr((i), 0)+1)
105 #define NULSTR_FOREACH_PAIR(i, j, l) \
106 for ((i) = (l), (j) = strchr((i), 0)+1; (i) && *(i); (i) = strchr((j), 0)+1, (j) = *(i) ? strchr((i), 0)+1 : (i))
108 int ioprio_class_to_string_alloc(int i
, char **s
);
109 int ioprio_class_from_string(const char *s
);
111 const char *sigchld_code_to_string(int i
) _const_
;
112 int sigchld_code_from_string(const char *s
) _pure_
;
114 int sched_policy_to_string_alloc(int i
, char **s
);
115 int sched_policy_from_string(const char *s
);
117 extern int saved_argc
;
118 extern char **saved_argv
;
120 bool kexec_loaded(void);
122 int prot_from_flags(int flags
) _const_
;
124 void* memdup(const void *p
, size_t l
) _alloc_(2);
126 int fork_agent(pid_t
*pid
, const int except
[], unsigned n_except
, const char *path
, ...);
128 bool in_initrd(void);
130 static inline void freep(void *p
) {
134 #define _cleanup_free_ _cleanup_(freep)
135 #define _cleanup_globfree_ _cleanup_(globfree)
137 _malloc_
_alloc_(1, 2) static inline void *malloc_multiply(size_t a
, size_t b
) {
138 if (_unlikely_(b
!= 0 && a
> ((size_t) -1) / b
))
141 return malloc(a
* b
);
144 _alloc_(2, 3) static inline void *realloc_multiply(void *p
, size_t a
, size_t b
) {
145 if (_unlikely_(b
!= 0 && a
> ((size_t) -1) / b
))
148 return realloc(p
, a
* b
);
151 _alloc_(2, 3) static inline void *memdup_multiply(const void *p
, size_t a
, size_t b
) {
152 if (_unlikely_(b
!= 0 && a
> ((size_t) -1) / b
))
155 return memdup(p
, a
* b
);
159 * Check if a string contains any glob patterns.
161 _pure_
static inline bool string_is_glob(const char *p
) {
162 return !!strpbrk(p
, GLOB_CHARS
);
165 void *xbsearch_r(const void *key
, const void *base
, size_t nmemb
, size_t size
,
166 int (*compar
) (const void *, const void *, void *),
169 int on_ac_power(void);
171 static inline void *mempset(void *s
, int c
, size_t n
) {
173 return (uint8_t*)s
+ n
;
176 void* greedy_realloc(void **p
, size_t *allocated
, size_t need
, size_t size
);
177 void* greedy_realloc0(void **p
, size_t *allocated
, size_t need
, size_t size
);
178 #define GREEDY_REALLOC(array, allocated, need) \
179 greedy_realloc((void**) &(array), &(allocated), (need), sizeof((array)[0]))
181 #define GREEDY_REALLOC0(array, allocated, need) \
182 greedy_realloc0((void**) &(array), &(allocated), (need), sizeof((array)[0]))
184 static inline void _reset_errno_(int *saved_errno
) {
185 errno
= *saved_errno
;
188 #define PROTECT_ERRNO _cleanup_(_reset_errno_) __attribute__((unused)) int _saved_errno_ = errno
190 static inline int negative_errno(void) {
191 /* This helper should be used to shut up gcc if you know 'errno' is
192 * negative. Instead of "return -errno;", use "return negative_errno();"
193 * It will suppress bogus gcc warnings in case it assumes 'errno' might
194 * be 0 and thus the caller's error-handling might not be triggered. */
195 assert_return(errno
> 0, -EINVAL
);
199 static inline unsigned u64log2(uint64_t n
) {
200 #if __SIZEOF_LONG_LONG__ == 8
201 return (n
> 1) ? (unsigned) __builtin_clzll(n
) ^ 63U : 0;
207 static inline unsigned u32ctz(uint32_t n
) {
208 #if __SIZEOF_INT__ == 4
209 return __builtin_ctz(n
);
215 static inline unsigned log2i(int x
) {
218 return __SIZEOF_INT__
* 8 - __builtin_clz(x
) - 1;
221 static inline unsigned log2u(unsigned x
) {
224 return sizeof(unsigned) * 8 - __builtin_clz(x
) - 1;
227 static inline unsigned log2u_round_up(unsigned x
) {
233 return log2u(x
- 1) + 1;
240 _new_ = alloca(_len_); \
241 (void *) memset(_new_, 0, _len_); \
244 /* It's not clear what alignment glibc/gcc alloca() guarantee, hence provide a guaranteed safe version */
245 #define alloca_align(size, align) \
248 size_t _mask_ = (align) - 1; \
249 _ptr_ = alloca((size) + _mask_); \
250 (void*)(((uintptr_t)_ptr_ + _mask_) & ~_mask_); \
253 #define alloca0_align(size, align) \
256 size_t _size_ = (size); \
257 _new_ = alloca_align(_size_, (align)); \
258 (void*)memset(_new_, 0, _size_); \
261 bool id128_is_valid(const char *s
) _pure_
;
264 * Normal qsort requires base to be nonnull. Here were require
265 * that only if nmemb > 0.
267 static inline void qsort_safe(void *base
, size_t nmemb
, size_t size
, comparison_fn_t compar
) {
272 qsort(base
, nmemb
, size
, compar
);
275 int container_get_leader(const char *machine
, pid_t
*pid
);
277 int namespace_open(pid_t pid
, int *pidns_fd
, int *mntns_fd
, int *netns_fd
, int *userns_fd
, int *root_fd
);
278 int namespace_enter(int pidns_fd
, int mntns_fd
, int netns_fd
, int userns_fd
, int root_fd
);
280 #ifndef PERSONALITY_INVALID
281 /* personality(7) documents that 0xffffffffUL is used for querying the
282 * current personality, hence let's use that here as error
284 #define PERSONALITY_INVALID 0xffffffffLU
287 unsigned long personality_from_string(const char *p
);
288 const char *personality_to_string(unsigned long);
290 uint64_t physical_memory(void);
292 union file_handle_union
{
293 struct file_handle handle
;
294 char padding
[sizeof(struct file_handle
) + MAX_HANDLE_SZ
];
296 #define FILE_HANDLE_INIT { .handle.handle_bytes = MAX_HANDLE_SZ }
298 int update_reboot_param_file(const char *param
);
300 #define INOTIFY_EVENT_MAX (sizeof(struct inotify_event) + NAME_MAX + 1)
302 #define FOREACH_INOTIFY_EVENT(e, buffer, sz) \
303 for ((e) = &buffer.ev; \
304 (uint8_t*) (e) < (uint8_t*) (buffer.raw) + (sz); \
305 (e) = (struct inotify_event*) ((uint8_t*) (e) + sizeof(struct inotify_event) + (e)->len))
307 union inotify_event_buffer
{
308 struct inotify_event ev
;
309 uint8_t raw
[INOTIFY_EVENT_MAX
];
314 bool fdname_is_valid(const char *s
);
316 bool oom_score_adjust_is_valid(int oa
);