[PATCH 0/4] Fix compile against musl

Jörg Krause

unread,

Apr 23, 2015, 7:19:58 PM4/23/15

to swup...@googlegroups.com, Stefano Babic, Jörg Krause

This patchset fixes several issues compiling swupdate against the musl C
libary.

The biggest impact is to replace the system header <sys/queue.h> by a local
copy.

Jörg Krause (3):
Fix musl warning
Fix compile error against musl
Fix musl warning

Romain Naour (1):
Add missing header for off_t

--
2.3.6

Jörg Krause

unread,

Apr 23, 2015, 7:19:58 PM4/23/15

to swup...@googlegroups.com, Stefano Babic, Jörg Krause

Fix warning "redirecting incorrect #include <sys/fcntl.h> to <fcntl.h>"

diff --git a/core/cpio_utils.c b/core/cpio_utils.c
index 8dcc13e..da9ed51 100644
--- a/core/cpio_utils.c
+++ b/core/cpio_utils.c
@@ -14,7 +14,7 @@
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
- * Foundation, Inc.
+ * Foundation, Inc.
*/

#include <stdio.h>
@@ -27,7 +27,7 @@
#include <ctype.h>
#include <sys/types.h>
#include <sys/queue.h>
-#include <sys/fcntl.h>
+#include <fcntl.h>

#include "autoconf.h"
#include "cpiohdr.h"
@@ -392,4 +392,3 @@ int cpio_scan(int fd, struct swupdate_cfg *cfg, off_t start)

return 0;
}
-
diff --git a/core/handler.c b/core/handler.c
index 9fce738..135a561 100644
--- a/core/handler.c
+++ b/core/handler.c
@@ -26,7 +26,7 @@
#include <getopt.h>
#include <errno.h>
#include <sys/ioctl.h>
-#include <sys/fcntl.h>
+#include <fcntl.h>
#include "swupdate.h"
#include "handler.h"
#include "lua_util.h"
@@ -203,7 +203,7 @@ void lua_handlers_init(void)
void lua_handlers_init(void) {}
#endif

-int register_handler(const char *desc,
+int register_handler(const char *desc,
handler installer, void *data)
{

diff --git a/core/notifier.c b/core/notifier.c
index 2c85d86..fcb8566 100644
--- a/core/notifier.c
+++ b/core/notifier.c
@@ -25,7 +25,7 @@
#include <getopt.h>
#include <errno.h>
#include <sys/ioctl.h>
-#include <sys/fcntl.h>
+#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/queue.h>
diff --git a/core/parser.c b/core/parser.c
index 30a485c..b286919 100644
--- a/core/parser.c
+++ b/core/parser.c
@@ -19,7 +19,7 @@
*/

#include <unistd.h>
-#include <sys/fcntl.h>
+#include <fcntl.h>
#include "swupdate.h"
#include "parsers.h"

diff --git a/core/swupdate.c b/core/swupdate.c
index 641364d..011b101 100644
--- a/core/swupdate.c
+++ b/core/swupdate.c
@@ -14,7 +14,7 @@
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
- * Foundation, Inc.
+ * Foundation, Inc.
*/

#include <stdio.h>
@@ -30,7 +30,7 @@
#include <ctype.h>
#include <sys/types.h>
#include <sys/queue.h>
-#include <sys/fcntl.h>
+#include <fcntl.h>
#include <sys/stat.h>
#include <sys/mount.h>

@@ -427,4 +427,4 @@ int main(int argc, char **argv)
if (opt_w || opt_s)
network_initializer(&swcfg);

-}
+}
diff --git a/core/util.c b/core/util.c
index d3e9bec..7eb94a0 100644
--- a/core/util.c
+++ b/core/util.c
@@ -24,7 +24,7 @@
#include <string.h>
#include <ctype.h>
#include <errno.h>
-#include <sys/fcntl.h>
+#include <fcntl.h>
#include <dirent.h>
#include "swupdate.h"
#include "util.h"
diff --git a/corelib/installer.c b/corelib/installer.c
index dd1233f..e9ac268 100644
--- a/corelib/installer.c
+++ b/corelib/installer.c
@@ -28,7 +28,7 @@
#include <ctype.h>
#include <sys/types.h>
#include <sys/queue.h>
-#include <sys/fcntl.h>
+#include <fcntl.h>
#include <sys/stat.h>
#include <sys/mount.h>

diff --git a/corelib/network_thread.c b/corelib/network_thread.c
index 15f5713..d5f38da 100644
--- a/corelib/network_thread.c
+++ b/corelib/network_thread.c
@@ -25,7 +25,7 @@
#include <string.h>
#include <errno.h>
#include <sys/ioctl.h>
-#include <sys/fcntl.h>
+#include <fcntl.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/queue.h>
diff --git a/corelib/stream_interface.c b/corelib/stream_interface.c
index c5f018f..2e9ebd6 100644
--- a/corelib/stream_interface.c
+++ b/corelib/stream_interface.c
@@ -26,7 +26,7 @@
#include <getopt.h>
#include <errno.h>
#include <sys/ioctl.h>
-#include <sys/fcntl.h>
+#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/queue.h>
diff --git a/examples/client/client.c b/examples/client/client.c
index dd9250a..2742bc1 100644
--- a/examples/client/client.c
+++ b/examples/client/client.c
@@ -38,7 +38,7 @@
#include <string.h>
#include <errno.h>
#include <sys/ioctl.h>
-#include <sys/fcntl.h>
+#include <fcntl.h>
#include <sys/types.h>
#include <sys/socket.h>
#include "network_ipc.h"
diff --git a/ipc/network_ipc.c b/ipc/network_ipc.c
index 0caf81a..7f5fa4d 100644
--- a/ipc/network_ipc.c
+++ b/ipc/network_ipc.c
@@ -27,7 +27,7 @@
#include <errno.h>
#include <signal.h>
#include <sys/ioctl.h>
-#include <sys/fcntl.h>
+#include <fcntl.h>
#include <sys/types.h>
#include <sys/un.h>
#include <arpa/inet.h>
--
2.3.6

Jörg Krause

unread,

Apr 23, 2015, 7:19:58 PM4/23/15

to swup...@googlegroups.com, Stefano Babic, Romain Naour, Jörg Krause

From: Romain Naour <romain...@openwide.fr>

Signed-off-by: Romain Naour <romain...@openwide.fr>

Signed-off-by: Jörg Krause <joerg....@embedded.rocks>
---

include/swupdate.h | 1 +
1 file changed, 1 insertion(+)

diff --git a/include/swupdate.h b/include/swupdate.h
index dc03a50..5adf36c 100644
--- a/include/swupdate.h
+++ b/include/swupdate.h
@@ -20,6 +20,7 @@
#ifndef _SWUPDATE_H
#define _SWUPDATE_H

+#include <sys/types.h>
#include <sys/queue.h>
#include "flash.h"
#include "globals.h"
--
2.3.6

Jörg Krause

unread,

Apr 23, 2015, 7:19:58 PM4/23/15

to swup...@googlegroups.com, Stefano Babic, Jörg Krause

The musl C library does not include <sys/queue.h>. Provide a local
queue.h taken from glibc.

Signed-off-by: Jörg Krause <joerg....@embedded.rocks>
---

include/flash.h | 2 +-
include/queue.h | 574 +++++++++++++++++++++++++++++++++++++++++++++

include/swupdate.h | 2 +-
parser/parse_config.c | 2 +-
11 files changed, 584 insertions(+), 10 deletions(-)
create mode 100644 include/queue.h

diff --git a/core/cpio_utils.c b/core/cpio_utils.c
index da9ed51..9bd11be 100644
--- a/core/cpio_utils.c
+++ b/core/cpio_utils.c
@@ -26,7 +26,7 @@
#include <errno.h>
#include <ctype.h>
#include <sys/types.h>
-#include <sys/queue.h>
+#include "queue.h"
#include <fcntl.h>

#include "autoconf.h"
diff --git a/core/notifier.c b/core/notifier.c
index fcb8566..f9fe656 100644
--- a/core/notifier.c
+++ b/core/notifier.c
@@ -28,7 +28,7 @@

#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>

-#include <sys/queue.h>
+#include "queue.h"
#include <ctype.h>
#include <fcntl.h>
#include <dirent.h>
diff --git a/core/swupdate.c b/core/swupdate.c
index 011b101..326a99b 100644
--- a/core/swupdate.c
+++ b/core/swupdate.c
@@ -29,7 +29,7 @@
#include <errno.h>
#include <ctype.h>
#include <sys/types.h>
-#include <sys/queue.h>
+#include "queue.h"

#include <fcntl.h>
#include <sys/stat.h>
#include <sys/mount.h>

diff --git a/corelib/installer.c b/corelib/installer.c
index e9ac268..118186f 100644
--- a/corelib/installer.c
+++ b/corelib/installer.c

@@ -27,7 +27,7 @@
#include <errno.h>

#include <ctype.h>
#include <sys/types.h>
-#include <sys/queue.h>
+#include "queue.h"

#include <fcntl.h>
#include <sys/stat.h>
#include <sys/mount.h>

diff --git a/corelib/mtd-interface.c b/corelib/mtd-interface.c
index e3c4ce6..fbf89da 100644
--- a/corelib/mtd-interface.c
+++ b/corelib/mtd-interface.c
@@ -23,7 +23,7 @@
#include <string.h>
#include <mtd/mtd-user.h>
#include <sys/types.h>
-#include <sys/queue.h>
+#include "queue.h"
#include <sys/mount.h>
#include <unistd.h>
#include <errno.h>
diff --git a/corelib/network_thread.c b/corelib/network_thread.c
index d5f38da..7df5d1c 100644
--- a/corelib/network_thread.c
+++ b/corelib/network_thread.c
@@ -28,7 +28,7 @@

#include <fcntl.h>
#include <sys/types.h>
#include <sys/socket.h>

-#include <sys/queue.h>
+#include "queue.h"
#include <sys/stat.h>
#include <sys/un.h>
#include <sys/select.h>
diff --git a/corelib/stream_interface.c b/corelib/stream_interface.c
index 2e9ebd6..3167a1f 100644
--- a/corelib/stream_interface.c
+++ b/corelib/stream_interface.c
@@ -29,7 +29,7 @@

#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>

-#include <sys/queue.h>
+#include "queue.h"
#include <ctype.h>
#include <fcntl.h>
#include <dirent.h>
diff --git a/include/flash.h b/include/flash.h
index da17182..1e4a245 100644
--- a/include/flash.h
+++ b/include/flash.h
@@ -24,7 +24,7 @@

#include <stdint.h>
#include <mtd/libmtd.h>
-#include <sys/queue.h>
+#include "queue.h"
#include <mtd/libubi.h>

#define DEFAULT_CTRL_DEV "/dev/ubi_ctrl"
diff --git a/include/queue.h b/include/queue.h
new file mode 100644
index 0000000..daf4553
--- /dev/null
+++ b/include/queue.h
@@ -0,0 +1,574 @@
+/*
+ * Copyright (c) 1991, 1993
+ * The Regents of the University of California. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the University nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * @(#)queue.h 8.5 (Berkeley) 8/20/94
+ */
+
+#ifndef _SYS_QUEUE_H_
+#define _SYS_QUEUE_H_
+
+/*
+ * This file defines five types of data structures: singly-linked lists,
+ * lists, simple queues, tail queues, and circular queues.
+ *
+ * A singly-linked list is headed by a single forward pointer. The
+ * elements are singly linked for minimum space and pointer manipulation
+ * overhead at the expense of O(n) removal for arbitrary elements. New
+ * elements can be added to the list after an existing element or at the
+ * head of the list. Elements being removed from the head of the list
+ * should use the explicit macro for this purpose for optimum
+ * efficiency. A singly-linked list may only be traversed in the forward
+ * direction. Singly-linked lists are ideal for applications with large
+ * datasets and few or no removals or for implementing a LIFO queue.
+ *
+ * A list is headed by a single forward pointer (or an array of forward
+ * pointers for a hash table header). The elements are doubly linked
+ * so that an arbitrary element can be removed without a need to
+ * traverse the list. New elements can be added to the list before
+ * or after an existing element or at the head of the list. A list
+ * may only be traversed in the forward direction.
+ *
+ * A simple queue is headed by a pair of pointers, one the head of the
+ * list and the other to the tail of the list. The elements are singly
+ * linked to save space, so elements can only be removed from the
+ * head of the list. New elements can be added to the list after
+ * an existing element, at the head of the list, or at the end of the
+ * list. A simple queue may only be traversed in the forward direction.
+ *
+ * A tail queue is headed by a pair of pointers, one to the head of the
+ * list and the other to the tail of the list. The elements are doubly
+ * linked so that an arbitrary element can be removed without a need to
+ * traverse the list. New elements can be added to the list before or
+ * after an existing element, at the head of the list, or at the end of
+ * the list. A tail queue may be traversed in either direction.
+ *
+ * A circle queue is headed by a pair of pointers, one to the head of the
+ * list and the other to the tail of the list. The elements are doubly
+ * linked so that an arbitrary element can be removed without a need to
+ * traverse the list. New elements can be added to the list before or after
+ * an existing element, at the head of the list, or at the end of the list.
+ * A circle queue may be traversed in either direction, but has a more
+ * complex end of list detection.
+ *
+ * For details on the use of these macros, see the queue(3) manual page.
+ */
+
+/*
+ * List definitions.
+ */
+#define LIST_HEAD(name, type) \
+struct name { \
+ struct type *lh_first; /* first element */ \
+}
+
+#define LIST_HEAD_INITIALIZER(head) \
+ { NULL }
+
+#define LIST_ENTRY(type) \
+struct { \
+ struct type *le_next; /* next element */ \
+ struct type **le_prev; /* address of previous next element */ \
+}
+
+/*
+ * List functions.
+ */
+#define LIST_INIT(head) do { \
+ (head)->lh_first = NULL; \
+} while (/*CONSTCOND*/0)
+
+#define LIST_INSERT_AFTER(listelm, elm, field) do { \
+ if (((elm)->field.le_next = (listelm)->field.le_next) != NULL) \
+ (listelm)->field.le_next->field.le_prev = \
+ &(elm)->field.le_next; \
+ (listelm)->field.le_next = (elm); \
+ (elm)->field.le_prev = &(listelm)->field.le_next; \
+} while (/*CONSTCOND*/0)
+
+#define LIST_INSERT_BEFORE(listelm, elm, field) do { \
+ (elm)->field.le_prev = (listelm)->field.le_prev; \
+ (elm)->field.le_next = (listelm); \
+ *(listelm)->field.le_prev = (elm); \
+ (listelm)->field.le_prev = &(elm)->field.le_next; \
+} while (/*CONSTCOND*/0)
+
+#define LIST_INSERT_HEAD(head, elm, field) do { \
+ if (((elm)->field.le_next = (head)->lh_first) != NULL) \
+ (head)->lh_first->field.le_prev = &(elm)->field.le_next;\
+ (head)->lh_first = (elm); \
+ (elm)->field.le_prev = &(head)->lh_first; \
+} while (/*CONSTCOND*/0)
+
+#define LIST_REMOVE(elm, field) do { \
+ if ((elm)->field.le_next != NULL) \
+ (elm)->field.le_next->field.le_prev = \
+ (elm)->field.le_prev; \
+ *(elm)->field.le_prev = (elm)->field.le_next; \
+} while (/*CONSTCOND*/0)
+
+#define LIST_FOREACH(var, head, field) \
+ for ((var) = ((head)->lh_first); \
+ (var); \
+ (var) = ((var)->field.le_next))
+
+/*
+ * List access methods.
+ */
+#define LIST_EMPTY(head) ((head)->lh_first == NULL)
+#define LIST_FIRST(head) ((head)->lh_first)
+#define LIST_NEXT(elm, field) ((elm)->field.le_next)
+
+
+/*
+ * Singly-linked List definitions.
+ */
+#define SLIST_HEAD(name, type) \
+struct name { \
+ struct type *slh_first; /* first element */ \
+}
+
+#define SLIST_HEAD_INITIALIZER(head) \
+ { NULL }
+
+#define SLIST_ENTRY(type) \
+struct { \
+ struct type *sle_next; /* next element */ \
+}
+
+/*
+ * Singly-linked List functions.
+ */
+#define SLIST_INIT(head) do { \
+ (head)->slh_first = NULL; \
+} while (/*CONSTCOND*/0)
+
+#define SLIST_INSERT_AFTER(slistelm, elm, field) do { \
+ (elm)->field.sle_next = (slistelm)->field.sle_next; \
+ (slistelm)->field.sle_next = (elm); \
+} while (/*CONSTCOND*/0)
+
+#define SLIST_INSERT_HEAD(head, elm, field) do { \
+ (elm)->field.sle_next = (head)->slh_first; \
+ (head)->slh_first = (elm); \
+} while (/*CONSTCOND*/0)
+
+#define SLIST_REMOVE_HEAD(head, field) do { \
+ (head)->slh_first = (head)->slh_first->field.sle_next; \
+} while (/*CONSTCOND*/0)
+
+#define SLIST_REMOVE(head, elm, type, field) do { \
+ if ((head)->slh_first == (elm)) { \
+ SLIST_REMOVE_HEAD((head), field); \
+ } \
+ else { \
+ struct type *curelm = (head)->slh_first; \
+ while(curelm->field.sle_next != (elm)) \
+ curelm = curelm->field.sle_next; \
+ curelm->field.sle_next = \
+ curelm->field.sle_next->field.sle_next; \
+ } \
+} while (/*CONSTCOND*/0)
+
+#define SLIST_FOREACH(var, head, field) \
+ for((var) = (head)->slh_first; (var); (var) = (var)->field.sle_next)
+
+/*
+ * Singly-linked List access methods.
+ */
+#define SLIST_EMPTY(head) ((head)->slh_first == NULL)
+#define SLIST_FIRST(head) ((head)->slh_first)
+#define SLIST_NEXT(elm, field) ((elm)->field.sle_next)
+
+
+/*
+ * Singly-linked Tail queue declarations.
+ */
+#define STAILQ_HEAD(name, type) \
+struct name { \
+ struct type *stqh_first; /* first element */ \
+ struct type **stqh_last; /* addr of last next element */ \
+}
+
+#define STAILQ_HEAD_INITIALIZER(head) \
+ { NULL, &(head).stqh_first }
+
+#define STAILQ_ENTRY(type) \
+struct { \
+ struct type *stqe_next; /* next element */ \
+}
+
+/*
+ * Singly-linked Tail queue functions.
+ */
+#define STAILQ_INIT(head) do { \
+ (head)->stqh_first = NULL; \
+ (head)->stqh_last = &(head)->stqh_first; \
+} while (/*CONSTCOND*/0)
+
+#define STAILQ_INSERT_HEAD(head, elm, field) do { \
+ if (((elm)->field.stqe_next = (head)->stqh_first) == NULL) \
+ (head)->stqh_last = &(elm)->field.stqe_next; \
+ (head)->stqh_first = (elm); \
+} while (/*CONSTCOND*/0)
+
+#define STAILQ_INSERT_TAIL(head, elm, field) do { \
+ (elm)->field.stqe_next = NULL; \
+ *(head)->stqh_last = (elm); \
+ (head)->stqh_last = &(elm)->field.stqe_next; \
+} while (/*CONSTCOND*/0)
+
+#define STAILQ_INSERT_AFTER(head, listelm, elm, field) do { \
+ if (((elm)->field.stqe_next = (listelm)->field.stqe_next) == NULL)\
+ (head)->stqh_last = &(elm)->field.stqe_next; \
+ (listelm)->field.stqe_next = (elm); \
+} while (/*CONSTCOND*/0)
+
+#define STAILQ_REMOVE_HEAD(head, field) do { \
+ if (((head)->stqh_first = (head)->stqh_first->field.stqe_next) == NULL) \
+ (head)->stqh_last = &(head)->stqh_first; \
+} while (/*CONSTCOND*/0)
+
+#define STAILQ_REMOVE(head, elm, type, field) do { \
+ if ((head)->stqh_first == (elm)) { \
+ STAILQ_REMOVE_HEAD((head), field); \
+ } else { \
+ struct type *curelm = (head)->stqh_first; \
+ while (curelm->field.stqe_next != (elm)) \
+ curelm = curelm->field.stqe_next; \
+ if ((curelm->field.stqe_next = \
+ curelm->field.stqe_next->field.stqe_next) == NULL) \
+ (head)->stqh_last = &(curelm)->field.stqe_next; \
+ } \
+} while (/*CONSTCOND*/0)
+
+#define STAILQ_FOREACH(var, head, field) \
+ for ((var) = ((head)->stqh_first); \
+ (var); \
+ (var) = ((var)->field.stqe_next))
+
+#define STAILQ_CONCAT(head1, head2) do { \
+ if (!STAILQ_EMPTY((head2))) { \
+ *(head1)->stqh_last = (head2)->stqh_first; \
+ (head1)->stqh_last = (head2)->stqh_last; \
+ STAILQ_INIT((head2)); \
+ } \
+} while (/*CONSTCOND*/0)
+
+/*
+ * Singly-linked Tail queue access methods.
+ */
+#define STAILQ_EMPTY(head) ((head)->stqh_first == NULL)
+#define STAILQ_FIRST(head) ((head)->stqh_first)
+#define STAILQ_NEXT(elm, field) ((elm)->field.stqe_next)
+
+
+/*
+ * Simple queue definitions.
+ */
+#define SIMPLEQ_HEAD(name, type) \
+struct name { \
+ struct type *sqh_first; /* first element */ \
+ struct type **sqh_last; /* addr of last next element */ \
+}
+
+#define SIMPLEQ_HEAD_INITIALIZER(head) \
+ { NULL, &(head).sqh_first }
+
+#define SIMPLEQ_ENTRY(type) \
+struct { \
+ struct type *sqe_next; /* next element */ \
+}
+
+/*
+ * Simple queue functions.
+ */
+#define SIMPLEQ_INIT(head) do { \
+ (head)->sqh_first = NULL; \
+ (head)->sqh_last = &(head)->sqh_first; \
+} while (/*CONSTCOND*/0)
+
+#define SIMPLEQ_INSERT_HEAD(head, elm, field) do { \
+ if (((elm)->field.sqe_next = (head)->sqh_first) == NULL) \
+ (head)->sqh_last = &(elm)->field.sqe_next; \
+ (head)->sqh_first = (elm); \
+} while (/*CONSTCOND*/0)
+
+#define SIMPLEQ_INSERT_TAIL(head, elm, field) do { \
+ (elm)->field.sqe_next = NULL; \
+ *(head)->sqh_last = (elm); \
+ (head)->sqh_last = &(elm)->field.sqe_next; \
+} while (/*CONSTCOND*/0)
+
+#define SIMPLEQ_INSERT_AFTER(head, listelm, elm, field) do { \
+ if (((elm)->field.sqe_next = (listelm)->field.sqe_next) == NULL)\
+ (head)->sqh_last = &(elm)->field.sqe_next; \
+ (listelm)->field.sqe_next = (elm); \
+} while (/*CONSTCOND*/0)
+
+#define SIMPLEQ_REMOVE_HEAD(head, field) do { \
+ if (((head)->sqh_first = (head)->sqh_first->field.sqe_next) == NULL) \
+ (head)->sqh_last = &(head)->sqh_first; \
+} while (/*CONSTCOND*/0)
+
+#define SIMPLEQ_REMOVE(head, elm, type, field) do { \
+ if ((head)->sqh_first == (elm)) { \
+ SIMPLEQ_REMOVE_HEAD((head), field); \
+ } else { \
+ struct type *curelm = (head)->sqh_first; \
+ while (curelm->field.sqe_next != (elm)) \
+ curelm = curelm->field.sqe_next; \
+ if ((curelm->field.sqe_next = \
+ curelm->field.sqe_next->field.sqe_next) == NULL) \
+ (head)->sqh_last = &(curelm)->field.sqe_next; \
+ } \
+} while (/*CONSTCOND*/0)
+
+#define SIMPLEQ_FOREACH(var, head, field) \
+ for ((var) = ((head)->sqh_first); \
+ (var); \
+ (var) = ((var)->field.sqe_next))
+
+/*
+ * Simple queue access methods.
+ */
+#define SIMPLEQ_EMPTY(head) ((head)->sqh_first == NULL)
+#define SIMPLEQ_FIRST(head) ((head)->sqh_first)
+#define SIMPLEQ_NEXT(elm, field) ((elm)->field.sqe_next)
+
+
+/*
+ * Tail queue definitions.
+ */
+#define _TAILQ_HEAD(name, type, qual) \
+struct name { \
+ qual type *tqh_first; /* first element */ \
+ qual type *qual *tqh_last; /* addr of last next element */ \
+}
+#define TAILQ_HEAD(name, type) _TAILQ_HEAD(name, struct type,)
+
+#define TAILQ_HEAD_INITIALIZER(head) \
+ { NULL, &(head).tqh_first }
+
+#define _TAILQ_ENTRY(type, qual) \
+struct { \
+ qual type *tqe_next; /* next element */ \
+ qual type *qual *tqe_prev; /* address of previous next element */\
+}
+#define TAILQ_ENTRY(type) _TAILQ_ENTRY(struct type,)
+
+/*
+ * Tail queue functions.
+ */
+#define TAILQ_INIT(head) do { \
+ (head)->tqh_first = NULL; \
+ (head)->tqh_last = &(head)->tqh_first; \
+} while (/*CONSTCOND*/0)
+
+#define TAILQ_INSERT_HEAD(head, elm, field) do { \
+ if (((elm)->field.tqe_next = (head)->tqh_first) != NULL) \
+ (head)->tqh_first->field.tqe_prev = \
+ &(elm)->field.tqe_next; \
+ else \
+ (head)->tqh_last = &(elm)->field.tqe_next; \
+ (head)->tqh_first = (elm); \
+ (elm)->field.tqe_prev = &(head)->tqh_first; \
+} while (/*CONSTCOND*/0)
+
+#define TAILQ_INSERT_TAIL(head, elm, field) do { \
+ (elm)->field.tqe_next = NULL; \
+ (elm)->field.tqe_prev = (head)->tqh_last; \
+ *(head)->tqh_last = (elm); \
+ (head)->tqh_last = &(elm)->field.tqe_next; \
+} while (/*CONSTCOND*/0)
+
+#define TAILQ_INSERT_AFTER(head, listelm, elm, field) do { \
+ if (((elm)->field.tqe_next = (listelm)->field.tqe_next) != NULL)\
+ (elm)->field.tqe_next->field.tqe_prev = \
+ &(elm)->field.tqe_next; \
+ else \
+ (head)->tqh_last = &(elm)->field.tqe_next; \
+ (listelm)->field.tqe_next = (elm); \
+ (elm)->field.tqe_prev = &(listelm)->field.tqe_next; \
+} while (/*CONSTCOND*/0)
+
+#define TAILQ_INSERT_BEFORE(listelm, elm, field) do { \
+ (elm)->field.tqe_prev = (listelm)->field.tqe_prev; \
+ (elm)->field.tqe_next = (listelm); \
+ *(listelm)->field.tqe_prev = (elm); \
+ (listelm)->field.tqe_prev = &(elm)->field.tqe_next; \
+} while (/*CONSTCOND*/0)
+
+#define TAILQ_REMOVE(head, elm, field) do { \
+ if (((elm)->field.tqe_next) != NULL) \
+ (elm)->field.tqe_next->field.tqe_prev = \
+ (elm)->field.tqe_prev; \
+ else \
+ (head)->tqh_last = (elm)->field.tqe_prev; \
+ *(elm)->field.tqe_prev = (elm)->field.tqe_next; \
+} while (/*CONSTCOND*/0)
+
+#define TAILQ_FOREACH(var, head, field) \
+ for ((var) = ((head)->tqh_first); \
+ (var); \
+ (var) = ((var)->field.tqe_next))
+
+#define TAILQ_FOREACH_REVERSE(var, head, headname, field) \
+ for ((var) = (*(((struct headname *)((head)->tqh_last))->tqh_last)); \
+ (var); \
+ (var) = (*(((struct headname *)((var)->field.tqe_prev))->tqh_last)))
+
+#define TAILQ_CONCAT(head1, head2, field) do { \
+ if (!TAILQ_EMPTY(head2)) { \
+ *(head1)->tqh_last = (head2)->tqh_first; \
+ (head2)->tqh_first->field.tqe_prev = (head1)->tqh_last; \
+ (head1)->tqh_last = (head2)->tqh_last; \
+ TAILQ_INIT((head2)); \
+ } \
+} while (/*CONSTCOND*/0)
+
+/*
+ * Tail queue access methods.
+ */
+#define TAILQ_EMPTY(head) ((head)->tqh_first == NULL)
+#define TAILQ_FIRST(head) ((head)->tqh_first)
+#define TAILQ_NEXT(elm, field) ((elm)->field.tqe_next)
+
+#define TAILQ_LAST(head, headname) \
+ (*(((struct headname *)((head)->tqh_last))->tqh_last))
+#define TAILQ_PREV(elm, headname, field) \
+ (*(((struct headname *)((elm)->field.tqe_prev))->tqh_last))
+
+
+/*
+ * Circular queue definitions.
+ */
+#define CIRCLEQ_HEAD(name, type) \
+struct name { \
+ struct type *cqh_first; /* first element */ \
+ struct type *cqh_last; /* last element */ \
+}
+
+#define CIRCLEQ_HEAD_INITIALIZER(head) \
+ { (void *)&head, (void *)&head }
+
+#define CIRCLEQ_ENTRY(type) \
+struct { \
+ struct type *cqe_next; /* next element */ \
+ struct type *cqe_prev; /* previous element */ \
+}
+
+/*
+ * Circular queue functions.
+ */
+#define CIRCLEQ_INIT(head) do { \
+ (head)->cqh_first = (void *)(head); \
+ (head)->cqh_last = (void *)(head); \
+} while (/*CONSTCOND*/0)
+
+#define CIRCLEQ_INSERT_AFTER(head, listelm, elm, field) do { \
+ (elm)->field.cqe_next = (listelm)->field.cqe_next; \
+ (elm)->field.cqe_prev = (listelm); \
+ if ((listelm)->field.cqe_next == (void *)(head)) \
+ (head)->cqh_last = (elm); \
+ else \
+ (listelm)->field.cqe_next->field.cqe_prev = (elm); \
+ (listelm)->field.cqe_next = (elm); \
+} while (/*CONSTCOND*/0)
+
+#define CIRCLEQ_INSERT_BEFORE(head, listelm, elm, field) do { \
+ (elm)->field.cqe_next = (listelm); \
+ (elm)->field.cqe_prev = (listelm)->field.cqe_prev; \
+ if ((listelm)->field.cqe_prev == (void *)(head)) \
+ (head)->cqh_first = (elm); \
+ else \
+ (listelm)->field.cqe_prev->field.cqe_next = (elm); \
+ (listelm)->field.cqe_prev = (elm); \
+} while (/*CONSTCOND*/0)
+
+#define CIRCLEQ_INSERT_HEAD(head, elm, field) do { \
+ (elm)->field.cqe_next = (head)->cqh_first; \
+ (elm)->field.cqe_prev = (void *)(head); \
+ if ((head)->cqh_last == (void *)(head)) \
+ (head)->cqh_last = (elm); \
+ else \
+ (head)->cqh_first->field.cqe_prev = (elm); \
+ (head)->cqh_first = (elm); \
+} while (/*CONSTCOND*/0)
+
+#define CIRCLEQ_INSERT_TAIL(head, elm, field) do { \
+ (elm)->field.cqe_next = (void *)(head); \
+ (elm)->field.cqe_prev = (head)->cqh_last; \
+ if ((head)->cqh_first == (void *)(head)) \
+ (head)->cqh_first = (elm); \
+ else \
+ (head)->cqh_last->field.cqe_next = (elm); \
+ (head)->cqh_last = (elm); \
+} while (/*CONSTCOND*/0)
+
+#define CIRCLEQ_REMOVE(head, elm, field) do { \
+ if ((elm)->field.cqe_next == (void *)(head)) \
+ (head)->cqh_last = (elm)->field.cqe_prev; \
+ else \
+ (elm)->field.cqe_next->field.cqe_prev = \
+ (elm)->field.cqe_prev; \
+ if ((elm)->field.cqe_prev == (void *)(head)) \
+ (head)->cqh_first = (elm)->field.cqe_next; \
+ else \
+ (elm)->field.cqe_prev->field.cqe_next = \
+ (elm)->field.cqe_next; \
+} while (/*CONSTCOND*/0)
+
+#define CIRCLEQ_FOREACH(var, head, field) \
+ for ((var) = ((head)->cqh_first); \
+ (var) != (const void *)(head); \
+ (var) = ((var)->field.cqe_next))
+
+#define CIRCLEQ_FOREACH_REVERSE(var, head, field) \
+ for ((var) = ((head)->cqh_last); \
+ (var) != (const void *)(head); \
+ (var) = ((var)->field.cqe_prev))
+
+/*
+ * Circular queue access methods.
+ */
+#define CIRCLEQ_EMPTY(head) ((head)->cqh_first == (void *)(head))
+#define CIRCLEQ_FIRST(head) ((head)->cqh_first)
+#define CIRCLEQ_LAST(head) ((head)->cqh_last)
+#define CIRCLEQ_NEXT(elm, field) ((elm)->field.cqe_next)
+#define CIRCLEQ_PREV(elm, field) ((elm)->field.cqe_prev)
+
+#define CIRCLEQ_LOOP_NEXT(head, elm, field) \
+ (((elm)->field.cqe_next == (void *)(head)) \
+ ? ((head)->cqh_first) \
+ : (elm->field.cqe_next))
+#define CIRCLEQ_LOOP_PREV(head, elm, field) \
+ (((elm)->field.cqe_prev == (void *)(head)) \
+ ? ((head)->cqh_last) \
+ : (elm->field.cqe_prev))
+
+#endif /* sys/queue.h */
diff --git a/include/swupdate.h b/include/swupdate.h
index 5adf36c..02a9033 100644
--- a/include/swupdate.h
+++ b/include/swupdate.h
@@ -21,7 +21,7 @@
#define _SWUPDATE_H

#include <sys/types.h>
-#include <sys/queue.h>
+#include "queue.h"
#include "flash.h"
#include "globals.h"

diff --git a/parser/parse_config.c b/parser/parse_config.c
index f53106d..ed8651c 100644
--- a/parser/parse_config.c
+++ b/parser/parse_config.c
@@ -22,7 +22,7 @@
#include <string.h>
#include <libconfig.h>
#include <sys/types.h>
-#include <sys/queue.h>
+#include "queue.h"
#include "autoconf.h"
#include "util.h"
#include "swupdate.h"
--
2.3.6

Jörg Krause

unread,

Apr 23, 2015, 7:19:58 PM4/23/15

to swup...@googlegroups.com, Stefano Babic, Jörg Krause

Fix warning "redirecting incorrect #include <sys/poll.h> to <poll.h>"

Signed-off-by: Jörg Krause <joerg....@embedded.rocks>
---

mongoose/mongoose.c | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/mongoose/mongoose.c b/mongoose/mongoose.c
index bc4f29e..ef0df8f 100644
--- a/mongoose/mongoose.c
+++ b/mongoose/mongoose.c
@@ -203,7 +203,7 @@ struct pollfd {
#else // UNIX specific
#include <sys/wait.h>
#include <sys/socket.h>
-#include <sys/poll.h>
+#include <poll.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/time.h>
--
2.3.6

Stefano Babic

unread,

Apr 24, 2015, 2:31:20 AM4/24/15

to Jörg Krause, swup...@googlegroups.com, Stefano Babic

Hi Jörg,

On 24/04/2015 01:19, Jörg Krause wrote:
> This patchset fixes several issues compiling swupdate against the musl C
> libary.
>

Thanks for this - I have some general questions.

- which is the main goal for substituting glibc in your environment ?
Maybe the footprint ?
Footprint for swupdate in rescue configuration (ramdisk) is ~3MB. Which
is the footprint you can reach ?

- do you use only static libraries ?

- any differences / issues running swupdate with musl against glibc ?
Have you also tested with Webserver / Network ?

> The biggest impact is to replace the system header <sys/queue.h> by a local
> copy.

Stefano Babic

unread,

Apr 24, 2015, 2:42:08 AM4/24/15

to Jörg Krause, swup...@googlegroups.com, Stefano Babic

Hi Jörg,

On 24/04/2015 01:19, Jörg Krause wrote:

> Fix warning "redirecting incorrect #include <sys/fcntl.h> to <fcntl.h>"

The issue seems unrelated to musl. glibc provides compatibility
redirecting without warnings, and then it remained hidden. I would
suggest to drop musl from the title.

I guess you fixed here some trailing blanks, thanks. Anyway, each patch
should address a single problem, and this patch should be better split,
having one addressing the fcntl include and the second one for the
coding style.

Stefano Babic

unread,

Apr 24, 2015, 3:04:18 AM4/24/15

to Jörg Krause, swup...@googlegroups.com, Stefano Babic

Hi Jörg,

On 24/04/2015 01:19, Jörg Krause wrote:

> The musl C library does not include <sys/queue.h>. Provide a local
> queue.h taken from glibc.

I do not like to copy code from another package (libc) and putting
simply here. The same could be if another include was missing, but this
should be solved in the provider (glibc or musl) and not in the software
using it.

Duplication of the header creates other issue. Now they are
synchronized, good. But what if glibc will deliver in a future version a
modified queue.h ? We miss here even which is the header that is
included, because the compiler picks "queue.h" locally or sys/queue.h
from the sysroots directory. In case of significant changes, it is
difficult to find the cause because nobody thinks that the wrong header
is included.

What about to push queue.h to musl ? It looks like the right place to do.

If this does not work, the local copy in swupdate should have a
different name to be sure we have not duplicated header. Something like
"queue_musl.h" and by including

#ifdef __musl__
#include "queue_musl.h"
#else
#include <queue.h>
#endif

We should track when we are copying software from another package -
let's say, in the commit message there must be where the source is taken
(glibc) and from which version (better with a commit id).

Jörg Krause

unread,

Apr 24, 2015, 7:26:21 AM4/24/15

to Stefano Babic, swup...@googlegroups.com

Hi Stefano,

On Fr, 2015-04-24 at 08:42 +0200, Stefano Babic wrote:
> Hi Jörg,
>
> On 24/04/2015 01:19, Jörg Krause wrote:
> > Fix warning "redirecting incorrect #include <sys/fcntl.h> to
> > <fcntl.h>"
>
> The issue seems unrelated to musl. glibc provides compatibility
> redirecting without warnings, and then it remained hidden. I would
> suggest to drop musl from the title.

Ok. I will reword the commit message in v2.

[snip]

> > diff --git a/core/cpio_utils.c b/core/cpio_utils.c
> > index 8dcc13e..da9ed51 100644
> > --- a/core/cpio_utils.c
> > +++ b/core/cpio_utils.c
> > @@ -14,7 +14,7 @@
> > *
> > * You should have received a copy of the GNU General Public
> > License
> > * along with this program; if not, write to the Free Software
> > - * Foundation, Inc.
> > + * Foundation, Inc.
> > */
>
> I guess you fixed here some trailing blanks, thanks. Anyway, each
> patch
> should address a single problem, and this patch should be better
> split,
> having one addressing the fcntl include and the second one for the
> coding style.

The editor does this automatically. Seems I forget to disable this
setting... I will revert this in v2.

[snip]

Best regards
Jörg Krause

Jörg Krause

unread,

Apr 24, 2015, 9:00:40 AM4/24/15

to Stefano Babic, swup...@googlegroups.com

Hi Stefano,

On Fr, 2015-04-24 at 09:04 +0200, Stefano Babic wrote:
> Hi Jörg,
>
> On 24/04/2015 01:19, Jörg Krause wrote:
> > The musl C library does not include <sys/queue.h>. Provide a local
> > queue.h taken from glibc.
>
> I do not like to copy code from another package (libc) and putting
> simply here. The same could be if another include was missing, but
> this
> should be solved in the provider (glibc or musl) and not in the
> software
> using it.

I see. This solution was used for the meta-musl layer in yocto and
pushed upstream to logrotate:
http://yocto.yoctoproject.narkive.com/9msIcDzG/announcing-meta-musl-oe
-yocto-layer-supporting-musl-c-library
https://fedorahosted.org/logrotate/ticket/47

> Duplication of the header creates other issue. Now they are
> synchronized, good. But what if glibc will deliver in a future
> version a
> modified queue.h ?

You're right. This issue was addressed in some other projects as well:
https://github.com/miniupnp/miniupnp/pull/39
https://github.com/troglobit/libuev/commit/6e7234fa4d1865b3cba24c00b54a
47c52fcfef2a

The problem is that some libc implementations does not have queue.h or
ships different versions of queue.h. A fact is that Glibc copied the
queue implementation from BSD.

> We miss here even which is the header that is
> included, because the compiler picks "queue.h" locally or sys/queue.h
> from the sysroots directory. In case of significant changes, it is
> difficult to find the cause because nobody thinks that the wrong
> header
> is included.

This should not happen since "queue.h" is a local file and
<sys/queue.h> is a system file.

> What about to push queue.h to musl ? It looks like the right place
> to do.

musl does not and will not provide <sys/queue.h>. This is the
corresponding FAQ: http://wiki.musl
-libc.org/wiki/FAQ#Q:_why_is_sys.2Fqueue.h_not_included_.3F

The maintainers of musl also critizes the 3-clause BSD license:
http://www.openwall.com/lists/musl/2013/06/28/9

> If this does not work, the local copy in swupdate should have a
> different name to be sure we have not duplicated header.

This should not happen. But I've seen projects which rename the header
to bsdqueue.h or sys-queue.h.

> Something like
> "queue_musl.h" and by including

queue_musl is not a good choice because it is not really a musl
specific implementation.

> #ifdef __musl__
> #include "queue_musl.h"
> #else
> #include <queue.h>
> #endif

musl does not provide __musl__ or __MUSL__:
http://wiki.musl-libc.org/wiki/FAQ#Q:_why_is_there_no_MUSL_macro_.3F

> We should track when we are copying software from another package -
> let's say, in the commit message there must be where the source is
> taken
> (glibc) and from which version (better with a commit id).

You're right! I will add a note in the commit log next time.

Stefano Babic

unread,

Apr 24, 2015, 9:23:27 AM4/24/15

to Jörg Krause, Stefano Babic, swup...@googlegroups.com

Hi Jörg,

On 24/04/2015 15:00, Jörg Krause wrote:

>
> I see. This solution was used for the meta-musl layer in yocto and
> pushed upstream to logrotate:
> http://yocto.yoctoproject.narkive.com/9msIcDzG/announcing-meta-musl-oe
> -yocto-layer-supporting-musl-c-library
> https://fedorahosted.org/logrotate/ticket/47
>
>> Duplication of the header creates other issue. Now they are
>> synchronized, good. But what if glibc will deliver in a future
>> version a
>> modified queue.h ?
>
> You're right. This issue was addressed in some other projects as well:
> https://github.com/miniupnp/miniupnp/pull/39
> https://github.com/troglobit/libuev/commit/6e7234fa4d1865b3cba24c00b54a
> 47c52fcfef2a

ok - as queue.h is a set of macros and contains all code that is needed,
it could be ok.

>
> The problem is that some libc implementations does not have queue.h or
> ships different versions of queue.h. A fact is that Glibc copied the
> queue implementation from BSD.

Everybody copies from someone else...

>
>> We miss here even which is the header that is
>> included, because the compiler picks "queue.h" locally or sys/queue.h
>> from the sysroots directory. In case of significant changes, it is
>> difficult to find the cause because nobody thinks that the wrong
>> header
>> is included.
>
> This should not happen since "queue.h" is a local file and
> <sys/queue.h> is a system file.
>
>> What about to push queue.h to musl ? It looks like the right place
>> to do.
>
> musl does not and will not provide <sys/queue.h>. This is the
> corresponding FAQ: http://wiki.musl
> -libc.org/wiki/FAQ#Q:_why_is_sys.2Fqueue.h_not_included_.3F

Got it, that is not a solution.

>
> The maintainers of musl also critizes the 3-clause BSD license:
> http://www.openwall.com/lists/musl/2013/06/28/9
>
>> If this does not work, the local copy in swupdate should have a
>> different name to be sure we have not duplicated header.
>
> This should not happen.

I know but it could generate confusion.

> But I've seen projects which rename the header
> to bsdqueue.h or sys-queue.h.
>
>> Something like
>> "queue_musl.h" and by including
>
> queue_musl is not a good choice because it is not really a musl
> specific implementation.

Ok, I meant a different name - bsdqueue.h or sys-queue.h are surely a
better choice.

>
>> #ifdef __musl__
>> #include "queue_musl.h"
>> #else
>> #include <queue.h>
>> #endif
>
> musl does not provide __musl__ or __MUSL__:
> http://wiki.musl-libc.org/wiki/FAQ#Q:_why_is_there_no_MUSL_macro_.3F

I have found the same, yes.

>
>> We should track when we are copying software from another package -
>> let's say, in the commit message there must be where the source is
>> taken
>> (glibc) and from which version (better with a commit id).
>
> You're right! I will add a note in the commit log next time.

ok - all together, maybe having a local copy is not so bad.

Best regards,
Stefano

Jörg Krause

unread,

Apr 24, 2015, 3:15:27 PM4/24/15

to Stefano Babic, swup...@googlegroups.com

Hi Stefano,

On Fr, 2015-04-24 at 08:31 +0200, Stefano Babic wrote:
> Hi Jörg,
>
> On 24/04/2015 01:19, Jörg Krause wrote:
> > This patchset fixes several issues compiling swupdate against the
> > musl C
> > libary.
> >
>
> Thanks for this - I have some general questions.
>
> - which is the main goal for substituting glibc in your environment ?
> Maybe the footprint ?

Currently, I'm using Buildroot for building the Linux system with
eglibc as C library, but I want to switch to musl for several reasons.
One is footprint (hopefully) and one is maintenance - musl is actively
developed and has in contrast to eglibc or uClibc a time-based release
cycle.

> Footprint for swupdate in rescue configuration (ramdisk) is ~3MB.
> Which
> is the footprint you can reach ?

Unfortunatly, not all packages I need in Buildroot compile with musl.
So, I'm trying from time to time to fix these packages which is not so
easy sometimes.

I've built swupdate with all its dependencies (without Lua and U-Boot
handler) in Buildroot and created a rootfs.tar to compare the result
for musl and eglibc. rootfs.tar size for musl is 4065280 bytes and for
eglibc is 5980160. Note this is uncompressed and contains most of the
mtd(-utils) binaries which are selected by default in Buildroot.

> - do you use only static libraries ?

No.

> - any differences / issues running swupdate with musl against glibc ?
> Have you also tested with Webserver / Network ?

I've build swupdate with Webserver support but did not a runtime test
yet.

> > The biggest impact is to replace the system header <sys/queue.h>
> > by a local
> > copy.
>
> More in the 3/4 patch.

I will prepare a v2 for this patchset changing the issues we discussed
in the other mails.

Best regards
Jörg Krause

Reply all

Reply to author

Forward