Musl make

1 files changed, 253 insertions, 60 deletions

diff --git a/tools/common.c b/tools/common.c
index 00f7d3c..8156bec 100644
--- a/tools/common.c
+++ b/tools/common.c
@@ -50,6 +50,16 @@ int open(char *fname, int flags, int mode)
 				flags|o_largefile, mode));
 }
 
+int chdir(char *path)
+{
+	return sysret(__syscall1(__NR_chdir, (long)path));
+}
+
+int getdents64(int fd, char *buf, int size)
+{
+	return sysret(__syscall3(__NR_getdents64, fd, (long)buf, size));
+}
+
 int stat(char *fname, struct stat *st)
 {
 	return sysret(__syscall2(__NR_stat, (long)fname, (long)st));
@@ -60,6 +70,21 @@ int fstat(int fd, struct stat *st)
 	return sysret(__syscall2(__NR_fstat, (long)fd, (long)st));
 }
 
+int access(char *path, int mode)
+{
+	return sysret(__syscall2(__NR_access, (long)path, mode));
+}
+
+int dup2(int oldfd, int newfd)
+{
+	return sysret(__syscall2(__NR_dup2, oldfd, newfd));
+}
+
+int pipe(int *fds)
+{
+	return sysret(__syscall1(__NR_pipe, (long)fds));
+}
+
 int close(int fd)
 {
 	return sysret(__syscall1(__NR_close, fd));
@@ -69,7 +94,7 @@ void *mmap(char *addr, unsigned long length, int prot, int flags, int fd,
 		unsigned long offset)
 {
 	return (void*)sysret(__syscall6(__NR_mmap, (long)addr, length,
-				prot, flags, fd, offset));
+			prot, flags, fd, offset));
 }
 
 int munmap(char *addr, int length)
@@ -79,11 +104,72 @@ int munmap(char *addr, int length)
 
 #define MREMAP_MAYMOVE 1
 
-int mremap(void *old_addr, unsigned long old_size, unsigned long new_size,
+void *mremap(void *old_addr, unsigned long old_size, unsigned long new_size,
 		int flags, void *new_addr)
 {
-	return sysret(__syscall5(__NR_mremap, (long)old_addr, old_size,
-				new_size, flags, (long)new_addr));
+	return (void *)sysret(__syscall5(__NR_mremap, (long)old_addr,
+			old_size, new_size, flags, (long)new_addr));
+}
+
+int fork()
+{
+	return sysret(__syscall0(__NR_fork));
+}
+
+int wait4(int pid, int *wstatus, int options, void *rusage)
+{
+	return sysret(__syscall6(__NR_wait4, pid, (long)wstatus, options,
+		(long)rusage, 0, 0));
+}
+
+int execve(char *path, char **argv, char **envp)
+{
+	return sysret(__syscall3(__NR_execve, (long)path, (long)argv,
+		(long)envp));
+}
+
+int getrusage(int who, struct rusage *rusage)
+{
+	return sysret(__syscall2(__NR_getrusage, who, (long)rusage));
+}
+
+enum {
+	dirbuf_size = 16 * 1024
+};
+
+int opendir(struct dir *dir, char *path)
+{
+	dir->fd = open(path, O_RDONLY|O_DIRECTORY, 0);
+	if (dir->fd == -1)
+		return 0;
+
+	dir->buf = malloc(dirbuf_size);
+	dir->cur = dir->buf;
+	dir->end = dir->cur;
+	dir->path = path;
+	return 1;
+}
+
+void closedir(struct dir *dir)
+{
+	close(dir->fd);
+}
+
+struct dirent *readdir(struct dir *dir)
+{
+	struct dirent *tmp;
+	if (dir->cur == dir->end) {
+		int r = getdents64(dir->fd, dir->buf, dirbuf_size);
+		if (r == -1)
+			syscall_error(dir->path);
+		if (r == 0)
+			return NULL;
+		dir->cur = dir->buf;
+		dir->end = dir->buf + r;
+	}
+	tmp = (struct dirent *)dir->cur;
+	dir->cur += tmp->dsize;
+	return tmp;
 }
 
 int strzlen(char *s)
@@ -94,6 +180,14 @@ int strzlen(char *s)
 	return s - sc;
 }
 
+struct str *debug2str(char *s)
+{
+	static struct str str;
+	str.start = s;
+	str.end = str.start + strzlen(s);
+	return &str;
+}
+
 int strzeq(char *s1, char *s2)
 {
 	for (; *s1 && *s1 == *s2; ++s1, ++s2)
@@ -104,15 +198,32 @@ int strzeq(char *s1, char *s2)
 int streq(struct str *s1, struct str *s2)
 {
 	int i;
+	char * restrict tmp1, * restrict tmp2;
 	if (s1->end - s1->start != s2->end - s2->start)
 		return 0;
+
+	tmp1 = s1->start;
+	tmp2 = s2->start;
 	for (i = 0; s1->start + i < s1->end; ++i) {
-		if (s1->start[i] != s2->start[i])
+		if (tmp1[i] != tmp2[i])
 			return 0;
 	}
 	return 1;
 }
 
+int strge(struct str *s1, struct str *s2)
+{
+	char *tmp1 =s1->start, *tmp2 = s2->start;
+	for (;; ++tmp1, ++tmp2) {
+		if (tmp1 == s1->end)
+			return tmp2 == s2->end;
+		if (tmp2 == s2->end)
+			return 1;
+		if (*tmp1 != *tmp2)
+			return *tmp1 > *tmp2;
+	}
+}
+
 void memmove(char *dest, char *src, int len)
 {
 	int i;
@@ -125,11 +236,11 @@ void memmove(char *dest, char *src, int len)
 	}
 }
 
-void memcpy(void *dest, void *src, int len)
+void memcpy(void * restrict dest, void * restrict src, int len)
 {
-	int i;
 	char *d = dest;
 	char *s = src;
+	int i;
 	for (i = 0; i < len; ++i)
 		d[i] = s[i];
 }
@@ -141,6 +252,18 @@ void memset(void *dest, char c, int len)
 		*tmp = c;
 }
 
+int memeq(void *m1, void *m2, int len)
+{
+	char *s1 = m1;
+	char *s2 = m2;
+	int i;
+	for (i = 0; i < len; ++i) {
+		if (s1[i] != s2[i])
+			return 0;
+	}
+	return 1;
+}
+
 #define E(e, s) [e] = s,
 
 char *estrings[256] = {
@@ -156,12 +279,6 @@ void perror(char *s)
 	eprintf("%s: %s\n", s, estrings[idx]);
 }
 
-void syscall_error(char *fname)
-{
-	perror(fname);
-	hexit(1);
-}
-
 enum {
 	buflen = 32 * 1024
 };
@@ -175,9 +292,12 @@ struct iobuf {
 struct iobuf stdout = { 1 };
 struct iobuf stderr = { 2 };
 
-static void flush(struct iobuf *buf)
+void flush(struct iobuf *buf)
 {
-	int ret = write(buf->fd, buf->buf, buf->len);
+	int ret;
+	if (buf->len == 0)
+		return;
+	ret = write(buf->fd, buf->buf, buf->len);
 	if (ret != buf->len) {
 		write(2, _S("some stdout/stderr error\n"));
 		exit(3);
@@ -185,6 +305,12 @@ static void flush(struct iobuf *buf)
 	buf->len = 0;
 }
 
+void syscall_error(char *fname)
+{
+	perror(fname);
+	hexit(1);
+}
+
 static void putchar(struct iobuf *buf, char c)
 {
 	if (buf->len == buflen)
@@ -204,7 +330,7 @@ void hexit(int code)
 }
 
 static void print_int(struct iobuf *buf, int nsigned, int byte4,
-		unsigned long n)
+		unsigned long n, int size)
 {
 	char tmpbuf[64];
 	char *p = tmpbuf;
@@ -238,6 +364,10 @@ static void print_int(struct iobuf *buf, int nsigned, int byte4,
 		*p = k % 10 + '0';
 		++p;
 	}
+	if (p - tmpbuf < size) {
+		for (; p < tmpbuf + size; ++p)
+			*p = '0';
+	}
 	for (--p;; --p) {
 		putchar(buf, *p);
 		if (p == tmpbuf)
@@ -258,30 +388,38 @@ void print_str(struct iobuf *buf, struct str *s)
 		putchar(buf, *tmp);
 }
 
-static void format(struct iobuf *buf, char c, va_list vl)
+static void format(struct iobuf *buf, char c, int size, va_list vl)
 {
 	switch(c) {
 		unsigned long arg;
 	case '%':
+		if (size != -1)
+			goto size_err;
 		putchar(buf, '%');
 		break;
 	case 'd':
 	case 'u':
 		arg = va_arg(vl, unsigned int);
-		print_int(buf, c == 'd', 1, arg);
+		print_int(buf, c == 'd', 1, arg, size);
 		break;
 	case 'D':
 	case 'U':
 		arg = va_arg(vl, unsigned long);
-		print_int(buf, c == 'D', 0, arg);
+		print_int(buf, c == 'D', 0, arg, size);
 		break;
 	case 's':
+		if (size != -1)
+			goto size_err;
 		print_strz(buf, va_arg(vl, char*));
 		break;
 	case 'S':
+		if (size != -1)
+			goto size_err;
 		print_str(buf, va_arg(vl, struct str *));
 		break;
 	case 'c':
+		if (size != -1)
+			goto size_err;
 		arg = va_arg(vl, int);
 		putchar(buf, arg);
 		break;
@@ -289,23 +427,35 @@ static void format(struct iobuf *buf, char c, va_list vl)
 		write(2, _S("printf: unexpected format option \n"));
 		hexit(2);
 	}
+	return;
+size_err:
+	write(2, _S("printf: %c: size not applicable\n"));
+	hexit(2);
 }
 
 static void __printf(struct iobuf *buf, char *s, va_list vl)
 {
 	for (; *s; ++s) {
 		if (*s == '%') {
-			if (s[1] == 0) {
-				write(2, _S("printf: nothing comes after '%'"));
-				hexit(2);
+			int size = -1;
+			if (s[1] == 0)
+				goto zero_err;
+			if (s[1] >= '0' && s[1] <= '9') {
+				size = s[1] - '0';
+				++s;
 			}
-			format(buf, s[1], vl);
+			if (s[1] == 0)
+				goto zero_err;
+			format(buf, s[1], size, vl);
 			++s;
 		} else  {
 			putchar(buf, *s);
 		}
 	}
 	return;
+zero_err:
+	write(2, _S("printf: nothing specifier after '%'"));
+	hexit(2);
 }
 
 void printf(char *fmt, ...)
@@ -318,8 +468,6 @@ void printf(char *fmt, ...)
 
 void evprintf(char *fmt, va_list vl)
 {
-	print_strz(&stderr, progname);
-	print_strz(&stderr, ": ");
 	__printf(&stderr, fmt, vl);
 }
 
@@ -331,38 +479,56 @@ void eprintf(char *fmt, ...)
 	va_end(vl);
 }
 
-/* Memory management */
+void error(char *fmt, ...)
+{
+	va_list vl;
+	va_start(vl, fmt);
 
-struct mem_buffer {
-	char *cur, *end;
-	char *saved;
-};
+	print_strz(&stderr, progname);
+	print_strz(&stderr, ": ");
+	evprintf(fmt, vl);
+
+	va_end(vl);
+	print_strz(&stderr, "\n");
+	hexit(1);
+}
+
+/* Memory management */
 
-static struct mem_buffer mem_buf;
+struct heap heap;
 
-static void mem_buffer_init()
+void heap_offset_save()
 {
-	mem_buf.cur = mem_buf.end = brk(NULL);
-	mem_buf.saved = NULL;
+	if (heap.snum == heap_saves_max)
+		error("heap: offset stack is full");
+	heap.saved[heap.snum] = heap.a.cur;
+	++heap.snum;
 }
 
-void save_heap_offset()
+void heap_offset_remove()
 {
-	if (mem_buf.saved != NULL) {
-		eprintf("mem_buffer: offset already saved\n");
-		hexit(2);
+	if (heap.snum == 0) {
+		error("heap: offset stack is empty");
 	}
-	mem_buf.saved = mem_buf.cur;
+	--heap.snum;
 }
 
-void restore_heap_offset()
+void heap_offset_restore()
 {
-	if (mem_buf.saved == NULL) {
-		eprintf("mem_buffer: no offset was saved\n");
-		hexit(2);
-	}
-	mem_buf.cur = mem_buf.saved;
-	mem_buf.saved = NULL;
+	if (heap.snum == 0)
+		error("mem_buffer: no offset was saved\n");
+	heap.a.cur = heap.saved[heap.snum - 1];
+	--heap.snum;
+	heap.last_alloc = NULL;
+}
+
+void *mem_alloc(int size)
+{
+	void *tmp = mmap(NULL, size, PROT_READ|PROT_WRITE,
+		MAP_PRIVATE|MAP_ANON, -1, 0);
+	if (tmp == (void*)-1)
+		syscall_error("mmap");
+	return tmp;
 }
 
 static int get_alignment(int n)
@@ -378,7 +544,7 @@ static int get_alignment(int n)
 	return 1;
 }
 
-static void mem_buf_grow(int size)
+static void heap_grow(struct arena *a, int size)
 {
 	char *tmp;
 	if (size < 128*1024) {
@@ -388,31 +554,58 @@ static void mem_buf_grow(int size)
 		size &= -4096;
 	}
 	/*printf("Growing (%d)\n", size);*/
-	tmp = brk(mem_buf.end + size);
-	if (tmp == mem_buf.end) {
-		eprintf("mem_buf: unable to allocate memory\n");
-		hexit(1);
-	}
-	mem_buf.end = tmp;
+	tmp = brk(a->end + size);
+	if (tmp == a->end)
+		error("heap: unable to grow");
+	a->end = tmp;
+}
+
+static void heap_init()
+{
+	heap.a.start = heap.a.cur = heap.a.end = brk(NULL);
+	heap.a.grow = heap_grow;
+
+	heap.snum = 0;
+	heap.last_alloc = NULL;
 }
 
 #define ALIGN(v, align) \
 	(void*)(((unsigned long)(v) + (align) - 1ul) & -(align))
 
-void *malloc(int size)
+void *amalloc(struct arena *a, int size)
 {
 	int align = get_alignment(size);
-	char *tmp = ALIGN(mem_buf.cur, align);
-	int diff = tmp + size - mem_buf.end;
+	char *tmp = ALIGN(a->cur, align);
+	int diff = tmp + size - a->end;
 
 	if (diff > 0)
-		mem_buf_grow(diff);
+		a->grow(a, diff);
+
+	a->cur = tmp + size;
+
+	return tmp;
+}
 
-	mem_buf.cur = tmp + size;
+void *malloc(int size)
+{
+	void *tmp = amalloc(&heap.a, size);
+	heap.last_alloc = tmp;
 	return tmp;
 }
 
-int main(int argc, char **argv, char **envp);
+void realloc(void *p, int newsize)
+{
+	int diff;
+	if (heap.last_alloc != p)
+		error("realloc: not a previously allocated region");
+	diff = heap.last_alloc + newsize - heap.a.end;
+	if (diff > 0)
+		heap.a.grow(&heap.a, diff);
+
+	heap.a.cur = heap.last_alloc + newsize;
+}
+
+extern int main(int argc, char **argv, char **envp);
 
 void _start_c(unsigned long *p)
 {
@@ -421,7 +614,7 @@ void _start_c(unsigned long *p)
 	char **envp = argv + argc + 1;
 
 	progname = argv[0];
-	mem_buffer_init();
+	heap_init();
 
 	hexit(main(argc, argv, envp));
 }