macro.h: let F_TYPE_CMP() macro fail to compile, if second parameter is not const

[elogind.git] / src / shared / macro.h

diff --git a/src/shared/macro.h b/src/shared/macro.h
index 4e5d0f4f2f8d304e10403b34a31378785c087e37..2bb72f0d167626413aa5d91c1182050cc41da57d 100644 (file)
--- a/src/shared/macro.h
+++ b/src/shared/macro.h
@@ -45,6 +45,7 @@
 #define _weakref_(x) __attribute__((weakref(#x)))
 #define _introspect_(x) __attribute__((section("introspect." x)))
 #define _alignas_(x) __attribute__((aligned(__alignof(x))))
+#define _cleanup_(x) __attribute__((cleanup(x)))
 
 /* automake test harness */
 #define EXIT_TEST_SKIP 77
@@ -53,11 +54,28 @@
 #define STRINGIFY(x) XSTRINGIFY(x)
 
 /* Rounds up */
-#define ALIGN(l) ALIGN_TO((l), sizeof(void*))
+
+#define ALIGN4(l) (((l) + 3) & ~3)
+#define ALIGN8(l) (((l) + 7) & ~7)
+
+#if __SIZEOF_POINTER__ == 8
+#define ALIGN(l) ALIGN8(l)
+#elif __SIZEOF_POINTER__ == 4
+#define ALIGN(l) ALIGN4(l)
+#else
+#error "Wut? Pointers are neither 4 nor 8 bytes long?"
+#endif
+
+#define ALIGN_PTR(p) ((void*) ALIGN((unsigned long) p))
+#define ALIGN4_PTR(p) ((void*) ALIGN4((unsigned long) p))
+#define ALIGN8_PTR(p) ((void*) ALIGN8((unsigned long) p))
+
 static inline size_t ALIGN_TO(size_t l, size_t ali) {
         return ((l + ali - 1) & ~(ali - 1));
 }
 
+#define ALIGN_TO_PTR(p, ali) ((void*) ALIGN_TO((unsigned long) p))
+
 #define ELEMENTSOF(x) (sizeof(x)/sizeof((x)[0]))
 
 /*
@@ -67,9 +85,11 @@ static inline size_t ALIGN_TO(size_t l, size_t ali) {
  * @member: the name of the member within the struct.
  *
  */
-#define container_of(ptr, type, member) ({ \
-        const typeof( ((type *)0)->member ) *__mptr = (ptr); \
-        (type *)( (char *)__mptr - offsetof(type,member) );})
+#define container_of(ptr, type, member)                                 \
+        __extension__ ({                                                \
+                        const typeof( ((type *)0)->member ) *__mptr = (ptr); \
+                        (type *)( (char *)__mptr - offsetof(type,member) ); \
+                })
 
 #undef MAX
 #define MAX(a,b)                                 \
@@ -199,17 +219,6 @@ static inline size_t IOVEC_INCREMENT(struct iovec *i, unsigned n, size_t k) {
         return k;
 }
 
-#define _cleanup_free_ __attribute__((cleanup(freep)))
-#define _cleanup_fclose_ __attribute__((cleanup(fclosep)))
-#define _cleanup_pclose_ __attribute__((cleanup(pclosep)))
-#define _cleanup_close_ __attribute__((cleanup(closep)))
-#define _cleanup_closedir_ __attribute__((cleanup(closedirp)))
-#define _cleanup_umask_ __attribute__((cleanup(umaskp)))
-#define _cleanup_set_free_ __attribute__((cleanup(set_freep)))
-#define _cleanup_set_free_free_ __attribute__((cleanup(set_free_freep)))
-#define _cleanup_strv_free_ __attribute__((cleanup(strv_freep)))
-#define _cleanup_journal_close_ __attribute__((cleanup(journal_closep)))
-
 #define VA_FORMAT_ADVANCE(format, ap)                                   \
 do {                                                                    \
         int _argtypes[128];                                             \
@@ -255,4 +264,32 @@ do {                                                                    \
         }                                                               \
 } while(false)
 
+/* Remove this macro, when the kernel has f_type as unsigned int or long
+ * for every architecure. Currently some 64bit architecures (like s390x)
+ * have int in the kernel, but long in userspace for f_type, so glibc
+ * extends the int to long and carries over the sign. Negative numbers are
+ * caused by the 32bit magic constants in linux/magic.h stuffed into the
+ * signed int in the kernel and these negative numbers are extended to
+ * long, which cannot be simply compared to the magic constants anymore.
+ */
+#define F_TYPE_CMP(f_type, magic)                                       \
+        __extension__ ({                                                \
+                        __SWORD_TYPE _f = (f_type);                     \
+                        const __SWORD_TYPE _c = (magic);                \
+                        const int _c32 = 1 ? (magic)                    \
+                                    : sizeof((int[magic]){0});          \
+                        (_f == _c || _f == _c32 );                      \
+                })
+
+
+/* Returns the number of chars needed to format variables of the
+ * specified type as a decimal string. Adds in extra space for a
+ * negative '-' prefix. */
+
+#define DECIMAL_STR_MAX(type)                                           \
+        (1+(sizeof(type) <= 1 ? 3 :                                     \
+            sizeof(type) <= 2 ? 5 :                                     \
+            sizeof(type) <= 4 ? 10 :                                    \
+            sizeof(type) <= 8 ? 20 : sizeof(int[-2*(sizeof(type) > 8)])))
+
 #include "log.h"