|
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index] [[UNIKRAFT RFC PATCH] v2 1/1] Implementation of isrlib string.c
From: Cristian Vijelie <cristianvijelie@xxxxxxxxx>
Signed-off-by: Cristian Vijelie <cristianvijelie@xxxxxxxxx>
---
include/uk/isr/string.h | 76 +++++
lib/isrlib/Config.uk | 7 +
lib/isrlib/Makefile.uk | 3 +
lib/isrlib/string.c | 633 ++++++++++++++++++++++++++++++++++++++++
4 files changed, 719 insertions(+)
create mode 100644 include/uk/isr/string.h
create mode 100644 lib/isrlib/Config.uk
create mode 100644 lib/isrlib/Makefile.uk
create mode 100644 lib/isrlib/string.c
diff --git a/include/uk/isr/string.h b/include/uk/isr/string.h
new file mode 100644
index 0000000..7ce9fea
--- /dev/null
+++ b/include/uk/isr/string.h
@@ -0,0 +1,76 @@
+/* SPDX-License-Identifier: BSD-3-Clause */
+/*
+ * Authors: Simon Kuenzer <simon.kuenzer@xxxxxxxxx>
+ *
+ *
+ * Copyright (c) 2017, NEC Europe Ltd., NEC Corporation. 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 copyright holder 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 COPYRIGHT HOLDERS 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 COPYRIGHT HOLDER 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.
+ *
+ */
+
+#ifndef __UK_ISR_STRING_H__
+#define __UK_ISR_STRING_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <string.h>
+
+void *memcpy_isr(void *dst, const void *src, size_t len);
+void *memset_isr(void *ptr, int val, size_t len);
+void *memchr_isr(const void *ptr, int val, size_t len);
+void *memrchr_isr(const void *m, int c, size_t n);
+int memcmp_isr(const void *ptr1, const void *ptr2, size_t len);
+void *memmove_isr(void *dst, const void *src, size_t len);
+
+char *strncpy_isr(char *dst, const char *src, size_t len);
+char *strcpy_isr(char *dst, const char *src);
+size_t strlcpy_isr(char *d, const char *s, size_t n);
+size_t strlcat_isr(char *d, const char *s, size_t n);
+size_t strnlen_isr(const char *str, size_t maxlen);
+size_t strlen_isr(const char *str);
+char *strchrnul_isr(const char *s, int c);
+char *strchr_isr(const char *str, int c);
+char *strrchr_isr(const char *s, int c);
+int strncmp_isr(const char *str1, const char *str2, size_t len);
+int strcmp_isr(const char *str1, const char *str2);
+size_t strcspn_isr(const char *s, const char *c);
+size_t strspn_isr(const char *s, const char *c);
+char *strtok_isr(char *restrict s, const char *restrict sep);
+char *strtok_isr_r(char *restrict s, const char *restrict sep, char **restrict
p);
+char *strndup_isr(const char *str, size_t len);
+char *strdup_isr(const char *str);
+
+char *strerror_isr_r(int errnum, char *buf, size_t buflen);
+char *strerror_isr(int errnum);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __UK_ISR_STRING_H__ */
diff --git a/lib/isrlib/Config.uk b/lib/isrlib/Config.uk
new file mode 100644
index 0000000..c6be13c
--- /dev/null
+++ b/lib/isrlib/Config.uk
@@ -0,0 +1,7 @@
+menuconfig LIBISRLIB
+ bool "isrlib: ISR helper library"
+ default n
+
+if LIBISRLIB
+
+endif
diff --git a/lib/isrlib/Makefile.uk b/lib/isrlib/Makefile.uk
new file mode 100644
index 0000000..df3616d
--- /dev/null
+++ b/lib/isrlib/Makefile.uk
@@ -0,0 +1,3 @@
+$(eval $(call addlib_s,libisrlib,$(CONFIG_LIBISRLIB)))
+
+LIBISRLIB_SRCS-y += $(LIBISRLIB_BASE)/string.c|isr
diff --git a/lib/isrlib/string.c b/lib/isrlib/string.c
new file mode 100644
index 0000000..6cb0981
--- /dev/null
+++ b/lib/isrlib/string.c
@@ -0,0 +1,633 @@
+#include <uk/isr/string.h>
+/* I included types.h because VSCode was complaining that __u8 and other
+ * types are not defined, but the build is succesfull without it.
+ */
+#include <uk/arch/types.h>
+#include <stdint.h>
+#include <limits.h>
+#include <errno.h>
+
+void *memcpy_isr(void *dst, const void *src, size_t len)
+{
+ size_t p;
+
+ for (p = 0; p < len; ++p)
+ *((__u8 *)(((__uptr)dst) + p)) = *((__u8 *)(((__uptr)src) + p));
+
+ return dst;
+}
+
+void *memset_isr(void *ptr, int val, size_t len)
+{
+ __u8 *p = (__u8 *) ptr;
+
+ for (; len > 0; --len)
+ *(p++) = (__u8)val;
+
+ return ptr;
+}
+
+void *memchr_isr(const void *ptr, int val, size_t len)
+{
+ uintptr_t o = 0;
+
+ for (o = 0; o < (uintptr_t)len; ++o)
+ if (*((const uint8_t *)(((uintptr_t)ptr) + o)) == (uint8_t)val)
+ return (void *)((uintptr_t)ptr + o);
+
+ return NULL; /* did not find val */
+}
+
+void *memrchr_isr(const void *m, int c, size_t n)
+{
+ const unsigned char *s = m;
+
+ c = (unsigned char) c;
+ while (n--)
+ if (s[n] == c)
+ return (void *) (s + n);
+ return 0;
+}
+
+void *memmove_isr(void *dst, const void *src, size_t len)
+{
+ uint8_t *d = dst;
+ const uint8_t *s = src;
+
+ if (src > dst) {
+ for (; len > 0; --len)
+ *(d++) = *(s++);
+ } else {
+ s += len;
+ d += len;
+
+ for (; len > 0; --len)
+ *(d--) = *(s--);
+ }
+
+ return dst;
+}
+
+int memcmp_isr(const void *ptr1, const void *ptr2, size_t len)
+{
+ const unsigned char *c1 = (const unsigned char *)ptr1;
+ const unsigned char *c2 = (const unsigned char *)ptr2;
+
+ for (; len > 0; --len, ++c1, ++c2) {
+ if ((*c1) != (*c2))
+ return ((*c1) - (*c2));
+ }
+
+ return 0;
+}
+
+size_t strlen_isr(const char *str)
+{
+ return strnlen_isr(str, SIZE_MAX);
+}
+
+size_t strnlen_isr(const char *str, size_t len)
+{
+ const char *p = memchr_isr(str, 0, len);
+ return p ? (size_t) (p - str) : len;
+}
+
+char *strncpy_isr(char *dst, const char *src, size_t len)
+{
+ size_t clen;
+
+ clen = strnlen_isr(src, len);
+ memcpy_isr(dst, src, clen);
+
+ /* instead of filling up the rest of left space with zeros,
+ * append a termination character if we did not copy one
+ */
+ if (clen < len && dst[clen - 1] != '\0')
+ dst[clen] = '\0';
+ return dst;
+}
+
+char *strcpy_isr(char *dst, const char *src)
+{
+ return strncpy_isr(dst, src, SIZE_MAX);
+}
+
+int strncmp_isr(const char *str1, const char *str2, size_t len)
+{
+ const char *c1 = (const char *)str1;
+ const char *c2 = (const char *)str2;
+
+ for (; len > 0; --len, ++c1, ++c2) {
+ if ((*c1) != (*c2))
+ return (int)((*c1) - (*c2));
+ if ((*c1) == '\0')
+ break;
+ }
+ return 0;
+}
+
+int strcmp_isr(const char *str1, const char *str2)
+{
+ register signed char __res;
+
+ while ((__res = *str1 - *str2++) == 0 && *str1++)
+ ;
+
+ return __res;
+}
+
+/* The following code is taken from musl libc */
+#define ALIGN (sizeof(size_t))
+#define ONES ((size_t) -1 / UCHAR_MAX)
+#define HIGHS (ONES * (UCHAR_MAX / 2 + 1))
+#define HASZERO(x) (((x) - ONES) & ~(x) & HIGHS)
+#define BITOP(a, b, op) \
+ ((a)[(size_t)(b) / (8*sizeof *(a))] op \
+ (size_t)1 << ((size_t)(b) % (8 * sizeof *(a))))
+
+char *strchrnul_isr(const char *s, int c)
+{
+ size_t *w, k;
+
+ c = (unsigned char)c;
+ if (!c)
+ return (char *)s + strlen_isr(s);
+
+ for (; (uintptr_t)s % ALIGN; s++)
+ if (!*s || *(unsigned char *)s == c)
+ return (char *)s;
+ k = ONES * c;
+ for (w = (void *)s; !HASZERO(*w) && !HASZERO(*w ^ k); w++)
+ ;
+ for (s = (void *)w; *s && *(unsigned char *)s != c; s++)
+ ;
+ return (char *)s;
+}
+
+char *strchr_isr(const char *str, int c)
+{
+ char *r = strchrnul_sr(str, c);
+ return *(unsigned char *)r == (unsigned char)c ? r : 0;
+}
+
+char *strrchr_isr(const char *s, int c)
+{
+ return memrchr_isr(s, c, strlen_isr(s) + 1);
+}
+
+size_t strcspn_isr(const char *s, const char *c)
+{
+ const char *a = s;
+ size_t byteset[32 / sizeof(size_t)];
+
+ if (!c[0] || !c[1])
+ return strchrnul_isr(s, *c)-a;
+
+ memset_isr(byteset, 0, sizeof(byteset));
+ for (; *c && BITOP(byteset, *(unsigned char *)c, |=); c++)
+ ;
+ for (; *s && !BITOP(byteset, *(unsigned char *)s, &); s++)
+ ;
+ return s-a;
+}
+
+size_t strspn_isr(const char *s, const char *c)
+{
+ const char *a = s;
+ size_t byteset[32 / sizeof(size_t)] = { 0 };
+
+ if (!c[0])
+ return 0;
+ if (!c[1]) {
+ for (; *s == *c; s++)
+ ;
+ return s-a;
+ }
+
+ for (; *c && BITOP(byteset, *(unsigned char *)c, |=); c++)
+ ;
+ for (; *s && BITOP(byteset, *(unsigned char *)s, &); s++)
+ ;
+ return s-a;
+}
+
+char *strtok_isr(char *restrict s, const char *restrict sep)
+{
+ static char *p;
+
+ if (!s && !(s = p))
+ return NULL;
+ s += strspn_isr(s, sep);
+ if (!*s)
+ return p = 0;
+ p = s + strcspn_isr(s, sep);
+ if (*p)
+ *p++ = 0;
+ else
+ p = 0;
+ return s;
+}
+
+char *strtok_isr_r(char *restrict s, const char *restrict sep, char **restrict
p)
+{
+ if (!s && !(s = *p))
+ return NULL;
+ s += strspn_isr(s, sep);
+ if (!*s)
+ return *p = 0;
+ *p = s + strcspn_isr(s, sep);
+ if (**p)
+ *(*p)++ = 0;
+ else
+ *p = 0;
+ return s;
+}
+
+char *strndup_isr(const char *str, size_t len)
+{
+ char *__res;
+ int __len;
+
+ __len = strnlen(str, len);
+
+ __res = malloc(__len + 1);
+ if (__res) {
+ memcpy(__res, str, __len);
+ __res[__len] = '\0';
+ }
+
+ return __res;
+}
+
+char *strdup_isr(const char *str)
+{
+ return strndup_isr(str, SIZE_MAX);
+}
+
+/* strlcpy has different ALIGN */
+#undef ALIGN
+#define ALIGN (sizeof(size_t)-1)
+size_t strlcpy_isr(char *d, const char *s, size_t n)
+{
+ char *d0 = d;
+ size_t *wd;
+ const size_t *ws;
+
+ if (!n--)
+ goto finish;
+
+ if (((uintptr_t)s & ALIGN) == ((uintptr_t)d & ALIGN)) {
+ for (; ((uintptr_t) s & ALIGN) && n && (*d = *s);
+ n--, s++, d++)
+ ;
+
+ if (n && *s) {
+ wd = (void *)d; ws = (const void *)s;
+ for (; n >= sizeof(size_t) && !HASZERO(*ws);
+ n -= sizeof(size_t), ws++, wd++)
+ *wd = *ws;
+
+ d = (void *)wd; s = (const void *)ws;
+ }
+ }
+
+ for (; n && (*d = *s); n--, s++, d++)
+ ;
+ *d = 0;
+finish:
+ return d-d0 + strlen_isr(s);
+}
+
+size_t strlcat_isr(char *d, const char *s, size_t n)
+{
+ size_t l = strnlen_isr(d, n);
+ if (l == n)
+ return l + strlen_isr(s);
+ return l + strlcpy_isr(d+l, s, n-l);
+}
+
+/* GNU-specific version of strerror_r */
+char *strerror_isr_r(int errnum, char *buf, size_t buflen)
+{
+ const char *strerr;
+
+ switch (errnum) {
+ case EPERM:
+ strerr = "Operation not permitted";
+ break;
+ case ENOENT:
+ strerr = "No such file or directory";
+ break;
+ case ESRCH:
+ strerr = "No such process";
+ break;
+ case EINTR:
+ strerr = "Interrupted system call";
+ break;
+ case EIO:
+ strerr = "Input/output error";
+ break;
+ case ENXIO:
+ strerr = "Device not configured";
+ break;
+ case E2BIG:
+ strerr = "Argument list too long";
+ break;
+ case ENOEXEC:
+ strerr = "Exec format error";
+ break;
+ case EBADF:
+ strerr = "Bad file descriptor";
+ break;
+ case ECHILD:
+ strerr = "No child processes";
+ break;
+ case EDEADLK:
+ strerr = "Resource deadlock avoided";
+ break;
+ case ENOMEM:
+ strerr = "Cannot allocate memory";
+ break;
+ case EACCES:
+ strerr = "Permission denied";
+ break;
+ case EFAULT:
+ strerr = "Bad address";
+ break;
+ case ENOTBLK:
+ strerr = "Block device required";
+ break;
+ case EBUSY:
+ strerr = "Device busy";
+ break;
+ case EEXIST:
+ strerr = "File exists";
+ break;
+ case EXDEV:
+ strerr = "Cross-device link";
+ break;
+ case ENODEV:
+ strerr = "Operation not supported by device";
+ break;
+ case ENOTDIR:
+ strerr = "Not a directory";
+ break;
+ case EISDIR:
+ strerr = "Is a directory";
+ break;
+ case EINVAL:
+ strerr = "Invalid argument";
+ break;
+ case ENFILE:
+ strerr = "Too many open files in system";
+ break;
+ case EMFILE:
+ strerr = "Too many open files";
+ break;
+ case ENOTTY:
+ strerr = "Inappropriate ioctl for device";
+ break;
+ case ETXTBSY:
+ strerr = "Text file busy";
+ break;
+ case EFBIG:
+ strerr = "File too large";
+ break;
+ case ENOSPC:
+ strerr = "No space left on device";
+ break;
+ case ESPIPE:
+ strerr = "Illegal seek";
+ break;
+ case EROFS:
+ strerr = "Read-only file system";
+ break;
+ case EMLINK:
+ strerr = "Too many links";
+ break;
+ case EPIPE:
+ strerr = "Broken pipe";
+ break;
+ case EDOM:
+ strerr = "Numerical argument out of domain";
+ break;
+ case ERANGE:
+ strerr = "Result too large";
+ break;
+ case EAGAIN:
+ strerr = "Resource temporarily unavailable";
+ break;
+ case EINPROGRESS:
+ strerr = "Operation now in progress";
+ break;
+ case EALREADY:
+ strerr = "Operation already in progress";
+ break;
+ case ENOTSOCK:
+ strerr = "Socket operation on non-socket";
+ break;
+ case EDESTADDRREQ:
+ strerr = "Destination address required";
+ break;
+ case EMSGSIZE:
+ strerr = "Message too long";
+ break;
+ case EPROTOTYPE:
+ strerr = "Protocol wrong type for socket";
+ break;
+ case ENOPROTOOPT:
+ strerr = "Protocol not available";
+ break;
+ case EPROTONOSUPPORT:
+ strerr = "Protocol not supported";
+ break;
+ case ESOCKTNOSUPPORT:
+ strerr = "Socket type not supported";
+ break;
+ case EOPNOTSUPP:
+ strerr = "Operation not supported on socket";
+ break;
+ case EPFNOSUPPORT:
+ strerr = "Protocol family not supported";
+ break;
+ case EAFNOSUPPORT:
+ strerr = "Address family not supported by protocol family";
+ break;
+ case EADDRINUSE:
+ strerr = "Address already in use";
+ break;
+ case EADDRNOTAVAIL:
+ strerr = "Can't assign requested address";
+ break;
+ case ENETDOWN:
+ strerr = "Network is down";
+ break;
+ case ENETUNREACH:
+ strerr = "Network is unreachable";
+ break;
+ case ENETRESET:
+ strerr = "Network dropped connection on reset";
+ break;
+ case ECONNABORTED:
+ strerr = "Software caused connection abort";
+ break;
+ case ECONNRESET:
+ strerr = "Connection reset by peer";
+ break;
+ case ENOBUFS:
+ strerr = "No buffer space available";
+ break;
+ case EISCONN:
+ strerr = "Socket is already connected";
+ break;
+ case ENOTCONN:
+ strerr = "Socket is not connected";
+ break;
+ case ESHUTDOWN:
+ strerr = "Can't send after socket shutdown";
+ break;
+ case ETIMEDOUT:
+ strerr = "Operation timed out";
+ break;
+ case ECONNREFUSED:
+ strerr = "Connection refused";
+ break;
+ case ELOOP:
+ strerr = "Too many levels of symbolic links";
+ break;
+ case ENAMETOOLONG:
+ strerr = "File name too long";
+ break;
+ case EHOSTDOWN:
+ strerr = "Host is down";
+ break;
+ case EHOSTUNREACH:
+ strerr = "No route to host";
+ break;
+ case ENOTEMPTY:
+ strerr = "Directory not empty";
+ break;
+ case EPROCLIM:
+ strerr = "Too many processes";
+ break;
+ case EUSERS:
+ strerr = "Too many users";
+ break;
+ case EDQUOT:
+ strerr = "Disc quota exceeded";
+ break;
+ case ESTALE:
+ strerr = "Stale NFS file handle";
+ break;
+ case EBADRPC:
+ strerr = "RPC struct is bad";
+ break;
+ case ERPCMISMATCH:
+ strerr = "RPC version wrong";
+ break;
+ case EPROGUNAVAIL:
+ strerr = "RPC prog";
+ break;
+ case EPROGMISMATCH:
+ strerr = "Program version wrong";
+ break;
+ case EPROCUNAVAIL:
+ strerr = "Bad procedure for program";
+ break;
+ case ENOLCK:
+ strerr = "No locks available";
+ break;
+ case ENOSYS:
+ strerr = "Function not implemented";
+ break;
+ case EFTYPE:
+ strerr = "Inappropriate file type or format";
+ break;
+ case EAUTH:
+ strerr = "Authentication error";
+ break;
+ case ENEEDAUTH:
+ strerr = "Need authenticator";
+ break;
+ case EIDRM:
+ strerr = "Identifier removed";
+ break;
+ case ENOMSG:
+ strerr = "No message of desired type";
+ break;
+ case EOVERFLOW:
+ strerr = "Value too large to be stored in data type";
+ break;
+ case ECANCELED:
+ strerr = "Operation canceled";
+ break;
+ case EILSEQ:
+ strerr = "Illegal byte sequence";
+ break;
+ case ENOATTR:
+ strerr = "Attribute not found";
+ break;
+ case EDOOFUS:
+ strerr = "Programming error";
+ break;
+ case EBADMSG:
+ strerr = "Bad message";
+ break;
+ case EMULTIHOP:
+ strerr = "Multihop attempted";
+ break;
+ case ENOLINK:
+ strerr = "Link has been severed";
+ break;
+ case EPROTO:
+ strerr = "Protocol error";
+ break;
+ case ENOTCAPABLE:
+ strerr = "Capabilities insufficient";
+ break;
+ case ECAPMODE:
+ strerr = "Not permitted in capability mode";
+ break;
+ case ENOTRECOVERABLE:
+ strerr = "State not recoverable";
+ break;
+ case EOWNERDEAD:
+ strerr = "Previous owner died";
+ break;
+ case ENOTSUP:
+ strerr = "Not supported";
+ break;
+ default:
+ strerr = NULL;
+ errno = EINVAL; /* Unknown errnum requires errno to be set */
+ break;
+ }
+
+ if (!buflen)
+ return buf;
+
+ /*
+ * NOTE: If target buffer is too small, we are supposed to set
+ * errno to ERANGE. We ignore this case for simplification.
+ */
+ if (strerr)
+ strncpy_isr(buf, strerr, buflen);
+ else
+ snprintf_isr(buf, buflen, "Unknown error %d", errnum);
+
+ /* ensure null termination */
+ buf[buflen - 1] = '\0';
+ return buf;
+}
+
+/* NOTE: strerror() is not thread-safe, nor reentrant-safe */
+char *strerror_isr(int errnum)
+{
+ /* NOTE: Our longest message is currently 48 characters. With
+ * 64 characters we should have room for minor changes
+ * in the future.
+ */
+ static char buf[64];
+
+ return strerror_isr_r(errnum, buf, sizeof(buf));
+}
--
2.25.1
|
 |
Lists.xenproject.org is hosted with RackSpace, monitoring our |