[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

[UNIKRAFT/NEWLIB PATCH 1/1] Import missing headers from musl



We add import the following header files from musl: mqueue.h,
obstack.h, scsi.h, mtio.h, personality.h, timex.h, vfs.h, utmp.h,
utmpx.h. They are used by the compiler-rt sanitizer.

Signed-off-by: Vlad-Andrei Badoiu <vlad_andrei.badoiu@xxxxxx>
---
 musl-imported/include/mqueue.h          |  36 ++
 musl-imported/include/obstack.h         | 538 ++++++++++++++++++++++++
 musl-imported/include/scsi/scsi.h       | 150 +++++++
 musl-imported/include/sys/mtio.h        | 188 +++++++++
 musl-imported/include/sys/personality.h |  46 ++
 musl-imported/include/sys/timex.h       |  98 +++++
 musl-imported/include/sys/vfs.h         |   1 +
 musl-imported/include/utmp.h            |  52 +++
 musl-imported/include/utmpx.h           |  62 +++
 9 files changed, 1171 insertions(+)
 create mode 100644 musl-imported/include/mqueue.h
 create mode 100644 musl-imported/include/obstack.h
 create mode 100644 musl-imported/include/scsi/scsi.h
 create mode 100644 musl-imported/include/sys/mtio.h
 create mode 100644 musl-imported/include/sys/personality.h
 create mode 100644 musl-imported/include/sys/timex.h
 create mode 100644 musl-imported/include/sys/vfs.h
 create mode 100644 musl-imported/include/utmp.h
 create mode 100644 musl-imported/include/utmpx.h

diff --git a/musl-imported/include/mqueue.h b/musl-imported/include/mqueue.h
new file mode 100644
index 0000000..ef4113c
--- /dev/null
+++ b/musl-imported/include/mqueue.h
@@ -0,0 +1,36 @@
+#ifndef _MQUEUE_H
+#define _MQUEUE_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <features.h>
+
+#define __NEED_size_t
+#define __NEED_ssize_t
+#define __NEED_pthread_attr_t
+#define __NEED_time_t
+#define __NEED_struct_timespec
+#include <bits/alltypes.h>
+
+typedef int mqd_t;
+struct mq_attr {
+       long mq_flags, mq_maxmsg, mq_msgsize, mq_curmsgs,_unused[4];
+};
+struct sigevent;
+
+int mq_close(mqd_t);
+int mq_getattr(mqd_t, struct mq_attr *);
+int mq_notify(mqd_t, const struct sigevent *);
+mqd_t mq_open(const char *, int, ...);
+ssize_t mq_receive(mqd_t, char *, size_t, unsigned *);
+int mq_send(mqd_t, const char *, size_t, unsigned);
+int mq_setattr(mqd_t, const struct mq_attr *__restrict, struct mq_attr 
*__restrict);
+ssize_t mq_timedreceive(mqd_t, char *__restrict, size_t, unsigned *__restrict, 
const struct timespec *__restrict);
+int mq_timedsend(mqd_t, const char *, size_t, unsigned, const struct timespec 
*);
+int mq_unlink(const char *);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/musl-imported/include/obstack.h b/musl-imported/include/obstack.h
new file mode 100644
index 0000000..a9cbc39
--- /dev/null
+++ b/musl-imported/include/obstack.h
@@ -0,0 +1,538 @@
+/* obstack.h - object stack macros
+   Copyright (C) 1988-2020 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, see
+   <http://www.gnu.org/licenses/>.  */
+
+/* Summary:
+
+   All the apparent functions defined here are macros. The idea
+   is that you would use these pre-tested macros to solve a
+   very specific set of problems, and they would run fast.
+   Caution: no side-effects in arguments please!! They may be
+   evaluated MANY times!!
+
+   These macros operate a stack of objects.  Each object starts life
+   small, and may grow to maturity.  (Consider building a word syllable
+   by syllable.)  An object can move while it is growing.  Once it has
+   been "finished" it never changes address again.  So the "top of the
+   stack" is typically an immature growing object, while the rest of the
+   stack is of mature, fixed size and fixed address objects.
+
+   These routines grab large chunks of memory, using a function you
+   supply, called 'obstack_chunk_alloc'.  On occasion, they free chunks,
+   by calling 'obstack_chunk_free'.  You must define them and declare
+   them before using any obstack macros.
+
+   Each independent stack is represented by a 'struct obstack'.
+   Each of the obstack macros expects a pointer to such a structure
+   as the first argument.
+
+   One motivation for this package is the problem of growing char strings
+   in symbol tables.  Unless you are "fascist pig with a read-only mind"
+   --Gosper's immortal quote from HAKMEM item 154, out of context--you
+   would not like to put any arbitrary upper limit on the length of your
+   symbols.
+
+   In practice this often means you will build many short symbols and a
+   few long symbols.  At the time you are reading a symbol you don't know
+   how long it is.  One traditional method is to read a symbol into a
+   buffer, realloc()ating the buffer every time you try to read a symbol
+   that is longer than the buffer.  This is beaut, but you still will
+   want to copy the symbol from the buffer to a more permanent
+   symbol-table entry say about half the time.
+
+   With obstacks, you can work differently.  Use one obstack for all symbol
+   names.  As you read a symbol, grow the name in the obstack gradually.
+   When the name is complete, finalize it.  Then, if the symbol exists already,
+   free the newly read name.
+
+   The way we do this is to take a large chunk, allocating memory from
+   low addresses.  When you want to build a symbol in the chunk you just
+   add chars above the current "high water mark" in the chunk.  When you
+   have finished adding chars, because you got to the end of the symbol,
+   you know how long the chars are, and you can create a new object.
+   Mostly the chars will not burst over the highest address of the chunk,
+   because you would typically expect a chunk to be (say) 100 times as
+   long as an average object.
+
+   In case that isn't clear, when we have enough chars to make up
+   the object, THEY ARE ALREADY CONTIGUOUS IN THE CHUNK (guaranteed)
+   so we just point to it where it lies.  No moving of chars is
+   needed and this is the second win: potentially long strings need
+   never be explicitly shuffled. Once an object is formed, it does not
+   change its address during its lifetime.
+
+   When the chars burst over a chunk boundary, we allocate a larger
+   chunk, and then copy the partly formed object from the end of the old
+   chunk to the beginning of the new larger chunk.  We then carry on
+   accreting characters to the end of the object as we normally would.
+
+   A special macro is provided to add a single char at a time to a
+   growing object.  This allows the use of register variables, which
+   break the ordinary 'growth' macro.
+
+   Summary:
+        We allocate large chunks.
+        We carve out one object at a time from the current chunk.
+        Once carved, an object never moves.
+        We are free to append data of any size to the currently
+          growing object.
+        Exactly one object is growing in an obstack at any one time.
+        You can run one obstack per control block.
+        You may have as many control blocks as you dare.
+        Because of the way we do it, you can "unwind" an obstack
+          back to a previous state. (You may remove objects much
+          as you would with a stack.)
+ */
+
+
+/* Don't do the contents of this file more than once.  */
+
+#ifndef _OBSTACK_H
+#define _OBSTACK_H 1
+
+#ifndef _OBSTACK_INTERFACE_VERSION
+# define _OBSTACK_INTERFACE_VERSION 2
+#endif
+
+#include <stddef.h>             /* For size_t and ptrdiff_t.  */
+#include <string.h>             /* For __GNU_LIBRARY__, and memcpy.  */
+
+#if _OBSTACK_INTERFACE_VERSION == 1
+/* For binary compatibility with obstack version 1, which used "int"
+   and "long" for these two types.  */
+# define _OBSTACK_SIZE_T unsigned int
+# define _CHUNK_SIZE_T unsigned long
+# define _OBSTACK_CAST(type, expr) ((type) (expr))
+#else
+/* Version 2 with sane types, especially for 64-bit hosts.  */
+# define _OBSTACK_SIZE_T size_t
+# define _CHUNK_SIZE_T size_t
+# define _OBSTACK_CAST(type, expr) (expr)
+#endif
+
+/* If B is the base of an object addressed by P, return the result of
+   aligning P to the next multiple of A + 1.  B and P must be of type
+   char *.  A + 1 must be a power of 2.  */
+
+#define __BPTR_ALIGN(B, P, A) ((B) + (((P) - (B) + (A)) & ~(A)))
+
+/* Similar to __BPTR_ALIGN (B, P, A), except optimize the common case
+   where pointers can be converted to integers, aligned as integers,
+   and converted back again.  If ptrdiff_t is narrower than a
+   pointer (e.g., the AS/400), play it safe and compute the alignment
+   relative to B.  Otherwise, use the faster strategy of computing the
+   alignment relative to 0.  */
+
+#define __PTR_ALIGN(B, P, A)                                                 \
+  __BPTR_ALIGN (sizeof (ptrdiff_t) < sizeof (void *) ? (B) : (char *) 0,      \
+                P, A)
+
+#ifndef __attribute_pure__
+# if defined __GNUC_MINOR__ && __GNUC__ * 1000 + __GNUC_MINOR__ >= 2096
+#  define __attribute_pure__ __attribute__ ((__pure__))
+# else
+#  define __attribute_pure__
+# endif
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct _obstack_chunk           /* Lives at front of each chunk. */
+{
+  char *limit;                  /* 1 past end of this chunk */
+  struct _obstack_chunk *prev;  /* address of prior chunk or NULL */
+  char contents[4];             /* objects begin here */
+};
+
+struct obstack          /* control current object in current chunk */
+{
+  _CHUNK_SIZE_T chunk_size;     /* preferred size to allocate chunks in */
+  struct _obstack_chunk *chunk; /* address of current struct obstack_chunk */
+  char *object_base;            /* address of object we are building */
+  char *next_free;              /* where to add next char to current object */
+  char *chunk_limit;            /* address of char after current chunk */
+  union
+  {
+    _OBSTACK_SIZE_T i;
+    void *p;
+  } temp;                       /* Temporary for some macros.  */
+  _OBSTACK_SIZE_T alignment_mask;  /* Mask of alignment for each object. */
+
+  /* These prototypes vary based on 'use_extra_arg'.  */
+  union
+  {
+    void *(*plain) (size_t);
+    void *(*extra) (void *, size_t);
+  } chunkfun;
+  union
+  {
+    void (*plain) (void *);
+    void (*extra) (void *, void *);
+  } freefun;
+
+  void *extra_arg;              /* first arg for chunk alloc/dealloc funcs */
+  unsigned use_extra_arg : 1;     /* chunk alloc/dealloc funcs take extra arg 
*/
+  unsigned maybe_empty_object : 1; /* There is a possibility that the current
+                                      chunk contains a zero-length object.  
This
+                                      prevents freeing the chunk if we allocate
+                                      a bigger chunk to replace it. */
+  unsigned alloc_failed : 1;      /* No longer used, as we now call the failed
+                                     handler on error, but retained for binary
+                                     compatibility.  */
+};
+
+/* Declare the external functions we use; they are in obstack.c.  */
+
+extern void _obstack_newchunk (struct obstack *, _OBSTACK_SIZE_T);
+extern void _obstack_free (struct obstack *, void *);
+extern int _obstack_begin (struct obstack *,
+                           _OBSTACK_SIZE_T, _OBSTACK_SIZE_T,
+                           void *(*) (size_t), void (*) (void *));
+extern int _obstack_begin_1 (struct obstack *,
+                             _OBSTACK_SIZE_T, _OBSTACK_SIZE_T,
+                             void *(*) (void *, size_t),
+                             void (*) (void *, void *), void *);
+extern _OBSTACK_SIZE_T _obstack_memory_used (struct obstack *)
+  __attribute_pure__;
+
+/* Declare obstack_printf; it's in obstack_printf.c. */
+extern int obstack_printf(struct obstack *obstack, const char *__restrict fmt, 
...);
+
+
+/* Error handler called when 'obstack_chunk_alloc' failed to allocate
+   more memory.  This can be set to a user defined function which
+   should either abort gracefully or use longjump - but shouldn't
+   return.  The default action is to print a message and abort.  */
+extern void (*obstack_alloc_failed_handler) (void);
+
+/* Exit value used when 'print_and_abort' is used.  */
+extern int obstack_exit_failure;
+
+/* Pointer to beginning of object being allocated or to be allocated next.
+   Note that this might not be the final address of the object
+   because a new chunk might be needed to hold the final size.  */
+
+#define obstack_base(h) ((void *) (h)->object_base)
+
+/* Size for allocating ordinary chunks.  */
+
+#define obstack_chunk_size(h) ((h)->chunk_size)
+
+/* Pointer to next byte not yet allocated in current chunk.  */
+
+#define obstack_next_free(h) ((void *) (h)->next_free)
+
+/* Mask specifying low bits that should be clear in address of an object.  */
+
+#define obstack_alignment_mask(h) ((h)->alignment_mask)
+
+/* To prevent prototype warnings provide complete argument list.  */
+#define obstack_init(h)                                                        
      \
+  _obstack_begin ((h), 0, 0,                                                 \
+                  _OBSTACK_CAST (void *(*) (size_t), obstack_chunk_alloc),    \
+                  _OBSTACK_CAST (void (*) (void *), obstack_chunk_free))
+
+#define obstack_begin(h, size)                                               \
+  _obstack_begin ((h), (size), 0,                                            \
+                  _OBSTACK_CAST (void *(*) (size_t), obstack_chunk_alloc), \
+                  _OBSTACK_CAST (void (*) (void *), obstack_chunk_free))
+
+#define obstack_specify_allocation(h, size, alignment, chunkfun, freefun)     \
+  _obstack_begin ((h), (size), (alignment),                                  \
+                  _OBSTACK_CAST (void *(*) (size_t), chunkfun),                
      \
+                  _OBSTACK_CAST (void (*) (void *), freefun))
+
+#define obstack_specify_allocation_with_arg(h, size, alignment, chunkfun, 
freefun, arg) \
+  _obstack_begin_1 ((h), (size), (alignment),                                \
+                    _OBSTACK_CAST (void *(*) (void *, size_t), chunkfun),     \
+                    _OBSTACK_CAST (void (*) (void *, void *), freefun), arg)
+
+#define obstack_chunkfun(h, newchunkfun)                                     \
+  ((void) ((h)->chunkfun.extra = (void *(*) (void *, size_t)) (newchunkfun)))
+
+#define obstack_freefun(h, newfreefun)                                       \
+  ((void) ((h)->freefun.extra = (void *(*) (void *, void *)) (newfreefun)))
+
+#define obstack_1grow_fast(h, achar) ((void) (*((h)->next_free)++ = (achar)))
+
+#define obstack_blank_fast(h, n) ((void) ((h)->next_free += (n)))
+
+#define obstack_memory_used(h) _obstack_memory_used (h)
+
+#if defined __GNUC__
+# if !defined __GNUC_MINOR__ || __GNUC__ * 1000 + __GNUC_MINOR__ < 2008
+#  define __extension__
+# endif
+
+/* For GNU C, if not -traditional,
+   we can define these macros to compute all args only once
+   without using a global variable.
+   Also, we can avoid using the 'temp' slot, to make faster code.  */
+
+# define obstack_object_size(OBSTACK)                                        \
+  __extension__                                                                
      \
+    ({ struct obstack const *__o = (OBSTACK);                                \
+       (_OBSTACK_SIZE_T) (__o->next_free - __o->object_base); })
+
+/* The local variable is named __o1 to avoid a shadowed variable
+   warning when invoked from other obstack macros.  */
+# define obstack_room(OBSTACK)                                               \
+  __extension__                                                                
      \
+    ({ struct obstack const *__o1 = (OBSTACK);                               \
+       (_OBSTACK_SIZE_T) (__o1->chunk_limit - __o1->next_free); })
+
+# define obstack_make_room(OBSTACK, length)                                  \
+  __extension__                                                                
      \
+    ({ struct obstack *__o = (OBSTACK);                                        
      \
+       _OBSTACK_SIZE_T __len = (length);                                     \
+       if (obstack_room (__o) < __len)                                       \
+         _obstack_newchunk (__o, __len);                                     \
+       (void) 0; })
+
+# define obstack_empty_p(OBSTACK)                                            \
+  __extension__                                                                
      \
+    ({ struct obstack const *__o = (OBSTACK);                                \
+       (__o->chunk->prev == 0                                                \
+        && __o->next_free == __PTR_ALIGN ((char *) __o->chunk,               \
+                                          __o->chunk->contents,                
      \
+                                          __o->alignment_mask)); })
+
+# define obstack_grow(OBSTACK, where, length)                                \
+  __extension__                                                                
      \
+    ({ struct obstack *__o = (OBSTACK);                                        
      \
+       _OBSTACK_SIZE_T __len = (length);                                     \
+       if (obstack_room (__o) < __len)                                       \
+         _obstack_newchunk (__o, __len);                                     \
+       memcpy (__o->next_free, where, __len);                                \
+       __o->next_free += __len;                                                
      \
+       (void) 0; })
+
+# define obstack_grow0(OBSTACK, where, length)                               \
+  __extension__                                                                
      \
+    ({ struct obstack *__o = (OBSTACK);                                        
      \
+       _OBSTACK_SIZE_T __len = (length);                                     \
+       if (obstack_room (__o) < __len + 1)                                   \
+         _obstack_newchunk (__o, __len + 1);                                 \
+       memcpy (__o->next_free, where, __len);                                \
+       __o->next_free += __len;                                                
      \
+       *(__o->next_free)++ = 0;                                                
      \
+       (void) 0; })
+
+# define obstack_1grow(OBSTACK, datum)                                       \
+  __extension__                                                                
      \
+    ({ struct obstack *__o = (OBSTACK);                                        
      \
+       if (obstack_room (__o) < 1)                                           \
+         _obstack_newchunk (__o, 1);                                         \
+       obstack_1grow_fast (__o, datum); })
+
+/* These assume that the obstack alignment is good enough for pointers
+   or ints, and that the data added so far to the current object
+   shares that much alignment.  */
+
+# define obstack_ptr_grow(OBSTACK, datum)                                    \
+  __extension__                                                                
      \
+    ({ struct obstack *__o = (OBSTACK);                                        
      \
+       if (obstack_room (__o) < sizeof (void *))                             \
+         _obstack_newchunk (__o, sizeof (void *));                           \
+       obstack_ptr_grow_fast (__o, datum); })
+
+# define obstack_int_grow(OBSTACK, datum)                                    \
+  __extension__                                                                
      \
+    ({ struct obstack *__o = (OBSTACK);                                        
      \
+       if (obstack_room (__o) < sizeof (int))                                \
+         _obstack_newchunk (__o, sizeof (int));                                
      \
+       obstack_int_grow_fast (__o, datum); })
+
+# define obstack_ptr_grow_fast(OBSTACK, aptr)                                \
+  __extension__                                                                
      \
+    ({ struct obstack *__o1 = (OBSTACK);                                     \
+       void *__p1 = __o1->next_free;                                         \
+       *(const void **) __p1 = (aptr);                                       \
+       __o1->next_free += sizeof (const void *);                             \
+       (void) 0; })
+
+# define obstack_int_grow_fast(OBSTACK, aint)                                \
+  __extension__                                                                
      \
+    ({ struct obstack *__o1 = (OBSTACK);                                     \
+       void *__p1 = __o1->next_free;                                         \
+       *(int *) __p1 = (aint);                                               \
+       __o1->next_free += sizeof (int);                                        
      \
+       (void) 0; })
+
+# define obstack_blank(OBSTACK, length)                                        
      \
+  __extension__                                                                
      \
+    ({ struct obstack *__o = (OBSTACK);                                        
      \
+       _OBSTACK_SIZE_T __len = (length);                                     \
+       if (obstack_room (__o) < __len)                                       \
+         _obstack_newchunk (__o, __len);                                     \
+       obstack_blank_fast (__o, __len); })
+
+# define obstack_alloc(OBSTACK, length)                                        
      \
+  __extension__                                                                
      \
+    ({ struct obstack *__h = (OBSTACK);                                        
      \
+       obstack_blank (__h, (length));                                        \
+       obstack_finish (__h); })
+
+# define obstack_copy(OBSTACK, where, length)                                \
+  __extension__                                                                
      \
+    ({ struct obstack *__h = (OBSTACK);                                        
      \
+       obstack_grow (__h, (where), (length));                                \
+       obstack_finish (__h); })
+
+# define obstack_copy0(OBSTACK, where, length)                               \
+  __extension__                                                                
      \
+    ({ struct obstack *__h = (OBSTACK);                                        
      \
+       obstack_grow0 (__h, (where), (length));                               \
+       obstack_finish (__h); })
+
+/* The local variable is named __o1 to avoid a shadowed variable
+   warning when invoked from other obstack macros, typically obstack_free.  */
+# define obstack_finish(OBSTACK)                                             \
+  __extension__                                                                
      \
+    ({ struct obstack *__o1 = (OBSTACK);                                     \
+       void *__value = (void *) __o1->object_base;                           \
+       if (__o1->next_free == __value)                                       \
+         __o1->maybe_empty_object = 1;                                       \
+       __o1->next_free                                                       \
+         = __PTR_ALIGN (__o1->object_base, __o1->next_free,                  \
+                        __o1->alignment_mask);                               \
+       if ((size_t) (__o1->next_free - (char *) __o1->chunk)                 \
+           > (size_t) (__o1->chunk_limit - (char *) __o1->chunk))            \
+         __o1->next_free = __o1->chunk_limit;                                \
+       __o1->object_base = __o1->next_free;                                  \
+       __value; })
+
+# define obstack_free(OBSTACK, OBJ)                                          \
+  __extension__                                                                
      \
+    ({ struct obstack *__o = (OBSTACK);                                        
      \
+       void *__obj = (void *) (OBJ);                                         \
+       if (__obj > (void *) __o->chunk && __obj < (void *) __o->chunk_limit)  \
+         __o->next_free = __o->object_base = (char *) __obj;                 \
+       else                                                                  \
+         _obstack_free (__o, __obj); })
+
+#else /* not __GNUC__ */
+
+# define obstack_object_size(h)                                                
      \
+  ((_OBSTACK_SIZE_T) ((h)->next_free - (h)->object_base))
+
+# define obstack_room(h)                                                     \
+  ((_OBSTACK_SIZE_T) ((h)->chunk_limit - (h)->next_free))
+
+# define obstack_empty_p(h)                                                  \
+  ((h)->chunk->prev == 0                                                     \
+   && (h)->next_free == __PTR_ALIGN ((char *) (h)->chunk,                    \
+                                     (h)->chunk->contents,                   \
+                                     (h)->alignment_mask))
+
+/* Note that the call to _obstack_newchunk is enclosed in (..., 0)
+   so that we can avoid having void expressions
+   in the arms of the conditional expression.
+   Casting the third operand to void was tried before,
+   but some compilers won't accept it.  */
+
+# define obstack_make_room(h, length)                                        \
+  ((h)->temp.i = (length),                                                   \
+   ((obstack_room (h) < (h)->temp.i)                                         \
+    ? (_obstack_newchunk (h, (h)->temp.i), 0) : 0),                          \
+   (void) 0)
+
+# define obstack_grow(h, where, length)                                        
      \
+  ((h)->temp.i = (length),                                                   \
+   ((obstack_room (h) < (h)->temp.i)                                         \
+   ? (_obstack_newchunk ((h), (h)->temp.i), 0) : 0),                         \
+   memcpy ((h)->next_free, where, (h)->temp.i),                                
      \
+   (h)->next_free += (h)->temp.i,                                            \
+   (void) 0)
+
+# define obstack_grow0(h, where, length)                                     \
+  ((h)->temp.i = (length),                                                   \
+   ((obstack_room (h) < (h)->temp.i + 1)                                     \
+   ? (_obstack_newchunk ((h), (h)->temp.i + 1), 0) : 0),                     \
+   memcpy ((h)->next_free, where, (h)->temp.i),                                
      \
+   (h)->next_free += (h)->temp.i,                                            \
+   *((h)->next_free)++ = 0,                                                  \
+   (void) 0)
+
+# define obstack_1grow(h, datum)                                             \
+  (((obstack_room (h) < 1)                                                   \
+    ? (_obstack_newchunk ((h), 1), 0) : 0),                                  \
+   obstack_1grow_fast (h, datum))
+
+# define obstack_ptr_grow(h, datum)                                          \
+  (((obstack_room (h) < sizeof (char *))                                     \
+    ? (_obstack_newchunk ((h), sizeof (char *)), 0) : 0),                    \
+   obstack_ptr_grow_fast (h, datum))
+
+# define obstack_int_grow(h, datum)                                          \
+  (((obstack_room (h) < sizeof (int))                                        \
+    ? (_obstack_newchunk ((h), sizeof (int)), 0) : 0),                       \
+   obstack_int_grow_fast (h, datum))
+
+# define obstack_ptr_grow_fast(h, aptr)                                        
      \
+  (((const void **) ((h)->next_free += sizeof (void *)))[-1] = (aptr),       \
+   (void) 0)
+
+# define obstack_int_grow_fast(h, aint)                                        
      \
+  (((int *) ((h)->next_free += sizeof (int)))[-1] = (aint),                  \
+   (void) 0)
+
+# define obstack_blank(h, length)                                            \
+  ((h)->temp.i = (length),                                                   \
+   ((obstack_room (h) < (h)->temp.i)                                         \
+   ? (_obstack_newchunk ((h), (h)->temp.i), 0) : 0),                         \
+   obstack_blank_fast (h, (h)->temp.i))
+
+# define obstack_alloc(h, length)                                            \
+  (obstack_blank ((h), (length)), obstack_finish ((h)))
+
+# define obstack_copy(h, where, length)                                        
      \
+  (obstack_grow ((h), (where), (length)), obstack_finish ((h)))
+
+# define obstack_copy0(h, where, length)                                     \
+  (obstack_grow0 ((h), (where), (length)), obstack_finish ((h)))
+
+# define obstack_finish(h)                                                   \
+  (((h)->next_free == (h)->object_base                                       \
+    ? (((h)->maybe_empty_object = 1), 0)                                     \
+    : 0),                                                                    \
+   (h)->temp.p = (h)->object_base,                                           \
+   (h)->next_free                                                            \
+     = __PTR_ALIGN ((h)->object_base, (h)->next_free,                        \
+                    (h)->alignment_mask),                                    \
+   (((size_t) ((h)->next_free - (char *) (h)->chunk)                         \
+     > (size_t) ((h)->chunk_limit - (char *) (h)->chunk))                    \
+   ? ((h)->next_free = (h)->chunk_limit) : 0),                               \
+   (h)->object_base = (h)->next_free,                                        \
+   (h)->temp.p)
+
+# define obstack_free(h, obj)                                                \
+  ((h)->temp.p = (void *) (obj),                                             \
+   (((h)->temp.p > (void *) (h)->chunk                                       \
+     && (h)->temp.p < (void *) (h)->chunk_limit)                             \
+    ? (void) ((h)->next_free = (h)->object_base = (char *) (h)->temp.p)       \
+    : _obstack_free ((h), (h)->temp.p)))
+
+#endif /* not __GNUC__ */
+
+#ifdef __cplusplus
+}       /* C++ */
+#endif
+
+#endif /* _OBSTACK_H */
diff --git a/musl-imported/include/scsi/scsi.h 
b/musl-imported/include/scsi/scsi.h
new file mode 100644
index 0000000..8837f58
--- /dev/null
+++ b/musl-imported/include/scsi/scsi.h
@@ -0,0 +1,150 @@
+#ifndef _SCSI_SCSI_H
+#define _SCSI_SCSI_H
+
+#define TEST_UNIT_READY 0x00
+#define REZERO_UNIT 0x01
+#define REQUEST_SENSE 0x03
+#define FORMAT_UNIT 0x04
+#define READ_BLOCK_LIMITS 0x05
+#define REASSIGN_BLOCKS 0x07
+#define READ_6 0x08
+#define WRITE_6 0x0a
+#define SEEK_6 0x0b
+#define READ_REVERSE 0x0f
+#define WRITE_FILEMARKS 0x10
+#define SPACE 0x11
+#define INQUIRY 0x12
+#define RECOVER_BUFFERED_DATA 0x14
+#define MODE_SELECT 0x15
+#define RESERVE 0x16
+#define RELEASE 0x17
+#define COPY 0x18
+#define ERASE 0x19
+#define MODE_SENSE 0x1a
+#define START_STOP 0x1b
+#define RECEIVE_DIAGNOSTIC 0x1c
+#define SEND_DIAGNOSTIC 0x1d
+#define ALLOW_MEDIUM_REMOVAL 0x1e
+#define SET_WINDOW 0x24
+#define READ_CAPACITY 0x25
+#define READ_10 0x28
+#define WRITE_10 0x2a
+#define SEEK_10 0x2b
+#define WRITE_VERIFY 0x2e
+#define VERIFY 0x2f
+#define SEARCH_HIGH 0x30
+#define SEARCH_EQUAL 0x31
+#define SEARCH_LOW 0x32
+#define SET_LIMITS 0x33
+#define PRE_FETCH 0x34
+#define READ_POSITION 0x34
+#define SYNCHRONIZE_CACHE 0x35
+#define LOCK_UNLOCK_CACHE 0x36
+#define READ_DEFECT_DATA 0x37
+#define MEDIUM_SCAN 0x38
+#define COMPARE 0x39
+#define COPY_VERIFY 0x3a
+#define WRITE_BUFFER 0x3b
+#define READ_BUFFER 0x3c
+#define UPDATE_BLOCK 0x3d
+#define READ_LONG 0x3e
+#define WRITE_LONG 0x3f
+#define CHANGE_DEFINITION 0x40
+#define WRITE_SAME 0x41
+#define READ_TOC 0x43
+#define LOG_SELECT 0x4c
+#define LOG_SENSE 0x4d
+#define MODE_SELECT_10 0x55
+#define RESERVE_10 0x56
+#define RELEASE_10 0x57
+#define MODE_SENSE_10 0x5a
+#define PERSISTENT_RESERVE_IN 0x5e
+#define PERSISTENT_RESERVE_OUT 0x5f
+#define MOVE_MEDIUM 0xa5
+#define READ_12 0xa8
+#define WRITE_12 0xaa
+#define WRITE_VERIFY_12 0xae
+#define SEARCH_HIGH_12 0xb0
+#define SEARCH_EQUAL_12 0xb1
+#define SEARCH_LOW_12 0xb2
+#define READ_ELEMENT_STATUS 0xb8
+#define SEND_VOLUME_TAG 0xb6
+#define WRITE_LONG_2 0xea
+#define GOOD 0x00
+#define CHECK_CONDITION 0x01
+#define CONDITION_GOOD 0x02
+#define BUSY 0x04
+#define INTERMEDIATE_GOOD 0x08
+#define INTERMEDIATE_C_GOOD 0x0a
+#define RESERVATION_CONFLICT 0x0c
+#define COMMAND_TERMINATED 0x11
+#define QUEUE_FULL 0x14
+#define STATUS_MASK 0x3e
+#define NO_SENSE 0x00
+#define RECOVERED_ERROR 0x01
+#define NOT_READY 0x02
+#define MEDIUM_ERROR 0x03
+#define HARDWARE_ERROR 0x04
+#define ILLEGAL_REQUEST 0x05
+#define UNIT_ATTENTION 0x06
+#define DATA_PROTECT 0x07
+#define BLANK_CHECK 0x08
+#define COPY_ABORTED 0x0a
+#define ABORTED_COMMAND 0x0b
+#define VOLUME_OVERFLOW 0x0d
+#define MISCOMPARE 0x0e
+#define TYPE_DISK 0x00
+#define TYPE_TAPE 0x01
+#define TYPE_PROCESSOR 0x03
+#define TYPE_WORM 0x04
+#define TYPE_ROM 0x05
+#define TYPE_SCANNER 0x06
+#define TYPE_MOD 0x07
+#define TYPE_MEDIUM_CHANGER 0x08
+#define TYPE_ENCLOSURE 0x0d
+#define TYPE_NO_LUN 0x7f
+#define COMMAND_COMPLETE 0x00
+#define EXTENDED_MESSAGE 0x01
+#define EXTENDED_MODIFY_DATA_POINTER 0x00
+#define EXTENDED_SDTR 0x01
+#define EXTENDED_EXTENDED_IDENTIFY 0x02
+#define EXTENDED_WDTR 0x03
+#define SAVE_POINTERS 0x02
+#define RESTORE_POINTERS 0x03
+#define DISCONNECT 0x04
+#define INITIATOR_ERROR 0x05
+#define ABORT 0x06
+#define MESSAGE_REJECT 0x07
+#define NOP 0x08
+#define MSG_PARITY_ERROR 0x09
+#define LINKED_CMD_COMPLETE 0x0a
+#define LINKED_FLG_CMD_COMPLETE 0x0b
+#define BUS_DEVICE_RESET 0x0c
+#define INITIATE_RECOVERY 0x0f
+#define RELEASE_RECOVERY 0x10
+#define SIMPLE_QUEUE_TAG 0x20
+#define HEAD_OF_QUEUE_TAG 0x21
+#define ORDERED_QUEUE_TAG 0x22
+#define SCSI_IOCTL_GET_IDLUN 0x5382
+#define SCSI_IOCTL_TAGGED_ENABLE 0x5383
+#define SCSI_IOCTL_TAGGED_DISABLE 0x5384
+#define SCSI_IOCTL_PROBE_HOST 0x5385
+#define SCSI_IOCTL_GET_BUS_NUMBER 0x5386
+
+struct ccs_modesel_head {
+       unsigned char _r1;
+       unsigned char medium;
+       unsigned char _r2;
+       unsigned char block_desc_length;
+       unsigned char density;
+       unsigned char number_blocks_hi;
+       unsigned char number_blocks_med;
+       unsigned char number_blocks_lo;
+       unsigned char _r3;
+       unsigned char block_length_hi;
+       unsigned char block_length_med;
+       unsigned char block_length_lo;
+};
+
+#endif
+
diff --git a/musl-imported/include/sys/mtio.h b/musl-imported/include/sys/mtio.h
new file mode 100644
index 0000000..f16a529
--- /dev/null
+++ b/musl-imported/include/sys/mtio.h
@@ -0,0 +1,188 @@
+#ifndef _SYS_MTIO_H
+#define _SYS_MTIO_H
+
+#include <sys/types.h>
+#include <sys/ioctl.h>
+
+struct mtop {
+       short mt_op;
+       int mt_count;
+};
+
+#define _IOT_mtop _IOT (_IOTS (short), 1, _IOTS (int), 1, 0, 0)
+#define _IOT_mtget _IOT (_IOTS (long), 7, 0, 0, 0, 0)
+#define _IOT_mtpos _IOT_SIMPLE (long)
+#define _IOT_mtconfiginfo _IOT (_IOTS (long), 2, _IOTS (short), 3, _IOTS 
(long), 1)
+
+
+#define MTRESET 0
+#define MTFSF  1
+#define MTBSF  2
+#define MTFSR  3
+#define MTBSR  4
+#define MTWEOF 5
+#define MTREW  6
+#define MTOFFL 7
+#define MTNOP  8
+#define MTRETEN 9
+#define MTBSFM 10
+#define MTFSFM  11
+#define MTEOM  12
+#define MTERASE 13
+#define MTRAS1  14
+#define MTRAS2 15
+#define MTRAS3  16
+#define MTSETBLK 20
+#define MTSETDENSITY 21
+#define MTSEEK 22
+#define MTTELL 23
+#define MTSETDRVBUFFER 24
+#define MTFSS  25
+#define MTBSS  26
+#define MTWSM  27
+#define MTLOCK  28
+#define MTUNLOCK 29
+#define MTLOAD  30
+#define MTUNLOAD 31
+#define MTCOMPRESSION 32
+#define MTSETPART 33
+#define MTMKPART  34
+
+struct mtget {
+       long mt_type;
+       long mt_resid;
+       long mt_dsreg;
+       long mt_gstat;
+       long mt_erreg;
+       int mt_fileno;
+       int mt_blkno;
+};
+
+#define MT_ISUNKNOWN           0x01
+#define MT_ISQIC02             0x02
+#define MT_ISWT5150            0x03
+#define MT_ISARCHIVE_5945L2    0x04
+#define MT_ISCMSJ500           0x05
+#define MT_ISTDC3610           0x06
+#define MT_ISARCHIVE_VP60I     0x07
+#define MT_ISARCHIVE_2150L     0x08
+#define MT_ISARCHIVE_2060L     0x09
+#define MT_ISARCHIVESC499      0x0A
+#define MT_ISQIC02_ALL_FEATURES        0x0F
+#define MT_ISWT5099EEN24       0x11
+#define MT_ISTEAC_MT2ST                0x12
+#define MT_ISEVEREX_FT40A      0x32
+#define MT_ISDDS1              0x51
+#define MT_ISDDS2              0x52
+#define MT_ISSCSI1             0x71
+#define MT_ISSCSI2             0x72
+#define MT_ISFTAPE_UNKNOWN     0x800000
+#define MT_ISFTAPE_FLAG                0x800000
+
+struct mt_tape_info {
+       long t_type;
+       char *t_name;
+};
+
+#define MT_TAPE_INFO \
+{                                                                            \
+       {MT_ISUNKNOWN,          "Unknown type of tape device"},               \
+       {MT_ISQIC02,            "Generic QIC-02 tape streamer"},              \
+       {MT_ISWT5150,           "Wangtek 5150, QIC-150"},                     \
+       {MT_ISARCHIVE_5945L2,   "Archive 5945L-2"},                           \
+       {MT_ISCMSJ500,          "CMS Jumbo 500"},                             \
+       {MT_ISTDC3610,          "Tandberg TDC 3610, QIC-24"},                 \
+       {MT_ISARCHIVE_VP60I,    "Archive VP60i, QIC-02"},                     \
+       {MT_ISARCHIVE_2150L,    "Archive Viper 2150L"},                       \
+       {MT_ISARCHIVE_2060L,    "Archive Viper 2060L"},                       \
+       {MT_ISARCHIVESC499,     "Archive SC-499 QIC-36 controller"},          \
+       {MT_ISQIC02_ALL_FEATURES, "Generic QIC-02 tape, all features"},       \
+       {MT_ISWT5099EEN24,      "Wangtek 5099-een24, 60MB"},                  \
+       {MT_ISTEAC_MT2ST,       "Teac MT-2ST 155mb data cassette drive"},     \
+       {MT_ISEVEREX_FT40A,     "Everex FT40A, QIC-40"},                      \
+       {MT_ISSCSI1,            "Generic SCSI-1 tape"},                       \
+       {MT_ISSCSI2,            "Generic SCSI-2 tape"},                       \
+       {0, 0}                                                                \
+}
+
+struct mtpos {
+       long mt_blkno;
+};
+
+struct mtconfiginfo  {
+       long mt_type;
+       long ifc_type;
+       unsigned short irqnr;
+       unsigned short dmanr;
+       unsigned short port;
+       unsigned long debug;
+       unsigned have_dens:1;
+       unsigned have_bsf:1;
+       unsigned have_fsr:1;
+       unsigned have_bsr:1;
+       unsigned have_eod:1;
+       unsigned have_seek:1;
+       unsigned have_tell:1;
+       unsigned have_ras1:1;
+       unsigned have_ras2:1;
+       unsigned have_ras3:1;
+       unsigned have_qfa:1;
+       unsigned pad1:5;
+       char reserved[10];
+};
+
+#define        MTIOCTOP _IOW('m', 1, struct mtop)
+#define        MTIOCGET _IOR('m', 2, struct mtget)
+#define        MTIOCPOS _IOR('m', 3, struct mtpos)
+
+#define        MTIOCGETCONFIG  _IOR('m', 4, struct mtconfiginfo)
+#define        MTIOCSETCONFIG  _IOW('m', 5, struct mtconfiginfo)
+
+#define GMT_EOF(x)              ((x) & 0x80000000)
+#define GMT_BOT(x)              ((x) & 0x40000000)
+#define GMT_EOT(x)              ((x) & 0x20000000)
+#define GMT_SM(x)               ((x) & 0x10000000)
+#define GMT_EOD(x)              ((x) & 0x08000000)
+#define GMT_WR_PROT(x)          ((x) & 0x04000000)
+#define GMT_ONLINE(x)           ((x) & 0x01000000)
+#define GMT_D_6250(x)           ((x) & 0x00800000)
+#define GMT_D_1600(x)           ((x) & 0x00400000)
+#define GMT_D_800(x)            ((x) & 0x00200000)
+#define GMT_DR_OPEN(x)          ((x) & 0x00040000)
+#define GMT_IM_REP_EN(x)        ((x) & 0x00010000)
+
+#define MT_ST_BLKSIZE_SHIFT    0
+#define MT_ST_BLKSIZE_MASK     0xffffff
+#define MT_ST_DENSITY_SHIFT    24
+#define MT_ST_DENSITY_MASK     0xff000000
+#define MT_ST_SOFTERR_SHIFT    0
+#define MT_ST_SOFTERR_MASK     0xffff
+#define MT_ST_OPTIONS          0xf0000000
+#define MT_ST_BOOLEANS         0x10000000
+#define MT_ST_SETBOOLEANS      0x30000000
+#define MT_ST_CLEARBOOLEANS    0x40000000
+#define MT_ST_WRITE_THRESHOLD  0x20000000
+#define MT_ST_DEF_BLKSIZE      0x50000000
+#define MT_ST_DEF_OPTIONS      0x60000000
+#define MT_ST_BUFFER_WRITES    0x1
+#define MT_ST_ASYNC_WRITES     0x2
+#define MT_ST_READ_AHEAD       0x4
+#define MT_ST_DEBUGGING                0x8
+#define MT_ST_TWO_FM           0x10
+#define MT_ST_FAST_MTEOM       0x20
+#define MT_ST_AUTO_LOCK                0x40
+#define MT_ST_DEF_WRITES       0x80
+#define MT_ST_CAN_BSR          0x100
+#define MT_ST_NO_BLKLIMS       0x200
+#define MT_ST_CAN_PARTITIONS    0x400
+#define MT_ST_SCSI2LOGICAL      0x800
+#define MT_ST_CLEAR_DEFAULT    0xfffff
+#define MT_ST_DEF_DENSITY      (MT_ST_DEF_OPTIONS | 0x100000)
+#define MT_ST_DEF_COMPRESSION  (MT_ST_DEF_OPTIONS | 0x200000)
+#define MT_ST_DEF_DRVBUFFER    (MT_ST_DEF_OPTIONS | 0x300000)
+#define MT_ST_HPLOADER_OFFSET 10000
+#ifndef DEFTAPE
+# define DEFTAPE       "/dev/tape"
+#endif
+
+#endif
diff --git a/musl-imported/include/sys/personality.h 
b/musl-imported/include/sys/personality.h
new file mode 100644
index 0000000..31d43df
--- /dev/null
+++ b/musl-imported/include/sys/personality.h
@@ -0,0 +1,46 @@
+#ifndef _PERSONALITY_H
+#define _PERSONALITY_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define ADDR_NO_RANDOMIZE  0x0040000
+#define MMAP_PAGE_ZERO     0x0100000
+#define ADDR_COMPAT_LAYOUT 0x0200000
+#define READ_IMPLIES_EXEC  0x0400000
+#define ADDR_LIMIT_32BIT   0x0800000
+#define SHORT_INODE        0x1000000
+#define WHOLE_SECONDS      0x2000000
+#define STICKY_TIMEOUTS    0x4000000
+#define ADDR_LIMIT_3GB     0x8000000
+
+#define PER_LINUX 0
+#define PER_LINUX_32BIT ADDR_LIMIT_32BIT
+#define PER_SVR4 (1 | STICKY_TIMEOUTS | MMAP_PAGE_ZERO)
+#define PER_SVR3 (2 | STICKY_TIMEOUTS | SHORT_INODE)
+#define PER_SCOSVR3 (3 | STICKY_TIMEOUTS | WHOLE_SECONDS | SHORT_INODE)
+#define PER_OSR5 (3 | STICKY_TIMEOUTS | WHOLE_SECONDS)
+#define PER_WYSEV386 (4 | STICKY_TIMEOUTS | SHORT_INODE)
+#define PER_ISCR4 (5 | STICKY_TIMEOUTS)
+#define PER_BSD 6
+#define PER_SUNOS (6 | STICKY_TIMEOUTS)
+#define PER_XENIX (7 | STICKY_TIMEOUTS | SHORT_INODE)
+#define PER_LINUX32 8
+#define PER_LINUX32_3GB (8 | ADDR_LIMIT_3GB)
+#define PER_IRIX32 (9 | STICKY_TIMEOUTS)
+#define PER_IRIXN32 (0xa | STICKY_TIMEOUTS)
+#define PER_IRIX64 (0x0b | STICKY_TIMEOUTS)
+#define PER_RISCOS 0xc
+#define PER_SOLARIS (0xd | STICKY_TIMEOUTS)
+#define PER_UW7 (0xe | STICKY_TIMEOUTS | MMAP_PAGE_ZERO)
+#define PER_OSF4 0xf
+#define PER_HPUX 0x10
+#define PER_MASK 0xff
+
+int personality(unsigned long);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/musl-imported/include/sys/timex.h 
b/musl-imported/include/sys/timex.h
new file mode 100644
index 0000000..2e68888
--- /dev/null
+++ b/musl-imported/include/sys/timex.h
@@ -0,0 +1,98 @@
+#ifndef _SYS_TIMEX_H
+#define _SYS_TIMEX_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define __NEED_clockid_t
+
+#include <bits/alltypes.h>
+
+#include <sys/time.h>
+
+struct ntptimeval {
+       struct timeval time;
+       long maxerror, esterror;
+};
+
+struct timex {
+       unsigned modes;
+       long offset, freq, maxerror, esterror;
+       int status;
+       long constant, precision, tolerance;
+       struct timeval time;
+       long tick, ppsfreq, jitter;
+       int shift;
+       long stabil, jitcnt, calcnt, errcnt, stbcnt;
+       int tai;
+       int __padding[11];
+};
+
+#define ADJ_OFFSET             0x0001
+#define ADJ_FREQUENCY          0x0002
+#define ADJ_MAXERROR           0x0004
+#define ADJ_ESTERROR           0x0008
+#define ADJ_STATUS             0x0010
+#define ADJ_TIMECONST          0x0020
+#define ADJ_TAI                        0x0080
+#define ADJ_SETOFFSET          0x0100
+#define ADJ_MICRO              0x1000
+#define ADJ_NANO               0x2000
+#define ADJ_TICK               0x4000
+#define ADJ_OFFSET_SINGLESHOT  0x8001
+#define ADJ_OFFSET_SS_READ     0xa001
+
+#define MOD_OFFSET     ADJ_OFFSET
+#define MOD_FREQUENCY  ADJ_FREQUENCY
+#define MOD_MAXERROR   ADJ_MAXERROR
+#define MOD_ESTERROR   ADJ_ESTERROR
+#define MOD_STATUS     ADJ_STATUS
+#define MOD_TIMECONST  ADJ_TIMECONST
+#define MOD_CLKB       ADJ_TICK
+#define MOD_CLKA       ADJ_OFFSET_SINGLESHOT
+#define MOD_TAI                ADJ_TAI
+#define MOD_MICRO      ADJ_MICRO
+#define MOD_NANO       ADJ_NANO
+
+#define STA_PLL                0x0001
+#define STA_PPSFREQ    0x0002
+#define STA_PPSTIME    0x0004
+#define STA_FLL                0x0008
+
+#define STA_INS                0x0010
+#define STA_DEL                0x0020
+#define STA_UNSYNC     0x0040
+#define STA_FREQHOLD   0x0080
+
+#define STA_PPSSIGNAL  0x0100
+#define STA_PPSJITTER  0x0200
+#define STA_PPSWANDER  0x0400
+#define STA_PPSERROR   0x0800
+
+#define STA_CLOCKERR   0x1000
+#define STA_NANO       0x2000
+#define STA_MODE       0x4000
+#define STA_CLK                0x8000
+
+#define STA_RONLY (STA_PPSSIGNAL | STA_PPSJITTER | STA_PPSWANDER | \
+    STA_PPSERROR | STA_CLOCKERR | STA_NANO | STA_MODE | STA_CLK)
+
+#define TIME_OK                0
+#define TIME_INS       1
+#define TIME_DEL       2
+#define TIME_OOP       3
+#define TIME_WAIT      4
+#define TIME_ERROR     5
+#define TIME_BAD       TIME_ERROR
+
+#define MAXTC          6
+
+int adjtimex(struct timex *);
+int clock_adjtime(clockid_t, struct timex *);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/musl-imported/include/sys/vfs.h b/musl-imported/include/sys/vfs.h
new file mode 100644
index 0000000..a899db2
--- /dev/null
+++ b/musl-imported/include/sys/vfs.h
@@ -0,0 +1 @@
+#include <sys/statfs.h>
diff --git a/musl-imported/include/utmp.h b/musl-imported/include/utmp.h
new file mode 100644
index 0000000..48a400d
--- /dev/null
+++ b/musl-imported/include/utmp.h
@@ -0,0 +1,52 @@
+#ifndef _UTMP_H
+#define _UTMP_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <utmpx.h>
+
+#define ACCOUNTING 9
+#define UT_NAMESIZE 32
+#define UT_HOSTSIZE 256
+#define UT_LINESIZE 32
+
+struct lastlog {
+       time_t ll_time;
+       char ll_line[UT_LINESIZE];
+       char ll_host[UT_HOSTSIZE];
+};
+
+#define ut_time ut_tv.tv_sec
+#define ut_name ut_user
+#define ut_addr ut_addr_v6[0]
+#define utmp utmpx
+#define e_exit __e_exit
+#define e_termination __e_termination
+
+void         endutent(void);
+struct utmp *getutent(void);
+struct utmp *getutid(const struct utmp *);
+struct utmp *getutline(const struct utmp *);
+struct utmp *pututline(const struct utmp *);
+void         setutent(void);
+
+void updwtmp(const char *, const struct utmp *);
+int utmpname(const char *);
+
+int login_tty(int);
+
+#define _PATH_UTMP "/dev/null/utmp"
+#define _PATH_WTMP "/dev/null/wtmp"
+
+#define UTMP_FILE _PATH_UTMP
+#define WTMP_FILE _PATH_WTMP
+#define UTMP_FILENAME _PATH_UTMP
+#define WTMP_FILENAME _PATH_WTMP
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/musl-imported/include/utmpx.h b/musl-imported/include/utmpx.h
new file mode 100644
index 0000000..cdcc90d
--- /dev/null
+++ b/musl-imported/include/utmpx.h
@@ -0,0 +1,62 @@
+#ifndef _UTMPX_H
+#define _UTMPX_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <features.h>
+
+#define __NEED_pid_t
+#define __NEED_time_t
+#define __NEED_suseconds_t
+#define __NEED_struct_timeval
+
+#include <bits/alltypes.h>
+
+struct utmpx {
+       short ut_type;
+       pid_t ut_pid;
+       char ut_line[32];
+       char ut_id[4];
+       char ut_user[32];
+       char ut_host[256];
+       struct {
+               short __e_termination;
+               short __e_exit;
+       } ut_exit;
+       long ut_session;
+       struct timeval ut_tv;
+       unsigned ut_addr_v6[4];
+       char unused[20];
+};
+
+void          endutxent(void);
+struct utmpx *getutxent(void);
+struct utmpx *getutxid(const struct utmpx *);
+struct utmpx *getutxline(const struct utmpx *);
+struct utmpx *pututxline(const struct utmpx *);
+void          setutxent(void);
+
+#if defined(_BSD_SOURCE) || defined(_GNU_SOURCE)
+#define e_exit __e_exit
+#define e_termination __e_termination
+void updwtmpx(const char *, const struct utmpx *);
+int utmpxname(const char *);
+#endif
+
+#define EMPTY           0
+#define RUN_LVL         1
+#define BOOT_TIME       2
+#define NEW_TIME        3
+#define OLD_TIME        4
+#define INIT_PROCESS    5
+#define LOGIN_PROCESS   6
+#define USER_PROCESS    7
+#define DEAD_PROCESS    8
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
-- 
2.27.0






 


Rackspace

Lists.xenproject.org is hosted with RackSpace, monitoring our
servers 24x7x365 and backed by RackSpace's Fanatical Support®.