plibc/lib/unistd.c

#include "unistd.h"
#include "errno.h"
#include "stdbool.h"
#include "stdio.h"
#include "syscalls.h"

volatile bool plibc_sfds_status_array[3] = { true, true, true };

static inline int
syscall_wrapper (int ret)
{
    if (ret < 0)
        {
            errno = -ret;
            return -1;
        }

    return ret;
}

int
write (int fd, const void *buf, size_t count)
{
    return syscall_wrapper (sys_write (fd, buf, count));
}

void *
sbrk (intptr_t increment)
{
    void *ptr = sys_sbrk (increment);

    if (ptr == (void *) -1)
        {
            errno = ENOMEM;
            return (void *) -1;
        }

    return ptr;
}

void *
brk (void)
{
    void *ptr = sys_brk ();

    if (ptr == (void *) -1)
        {
            errno = ENOMEM;
            return (void *) -1;
        }

    return ptr;
}

void
exit (int status)
{
    sys_exit (status);
}

void *
mmap (void *addr, size_t len, int prot, int flags, int fd, off_t offset)
{
    void *ptr = sys_mmap (addr, len, prot, flags, fd, offset);

    if (ptr == (void *) -1)
        {
            errno = ENOMEM;
            return (void *) -1;
        }

    return ptr;
}

void *
sysinfo (void *buffer)
{
    void *ptr = sys_sysinfo (buffer);

    if (ptr == (void *) -1)
        {
            errno = ENOMEM;
            return (void *) -1;
        }

    return ptr;
}

int
kill (pid_t pid, int sig)
{
    return syscall_wrapper (sys_kill (pid, sig));
}

int
open (const char *pathname, int flags)
{
    return syscall_wrapper (sys_open (pathname, flags, 0644));
}

int
close (int fd)
{
    int ret = syscall_wrapper (sys_close (fd));

    if (ret < 0)
        return ret;

    if (fd < 3)
        plibc_sfds_status_array[fd] = false;

    return ret;
}

const volatile bool *
plibc_sfds_status ()
{
    return plibc_sfds_status_array;
}
1	#include "unistd.h"
2	#include "errno.h"
3	#include "stdbool.h"
4	#include "stdio.h"
5	#include "syscalls.h"
6
7	volatile bool plibc_sfds_status_array[3] = { true, true, true };
8
9	static inline int
10	syscall_wrapper (int ret)
11	{
12	if (ret < 0)
13	{
14	errno = -ret;
15	return -1;
16	}
17
18	return ret;
19	}
20
21	int
22	write (int fd, const void *buf, size_t count)
23	{
24	return syscall_wrapper (sys_write (fd, buf, count));
25	}
26
27	void *
28	sbrk (intptr_t increment)
29	{
30	void *ptr = sys_sbrk (increment);
31
32	if (ptr == (void *) -1)
33	{
34	errno = ENOMEM;
35	return (void *) -1;
36	}
37
38	return ptr;
39	}
40
41	void *
42	brk (void)
43	{
44	void *ptr = sys_brk ();
45
46	if (ptr == (void *) -1)
47	{
48	errno = ENOMEM;
49	return (void *) -1;
50	}
51
52	return ptr;
53	}
54
55	void
56	exit (int status)
57	{
58	sys_exit (status);
59	}
60
61	void *
62	mmap (void *addr, size_t len, int prot, int flags, int fd, off_t offset)
63	{
64	void *ptr = sys_mmap (addr, len, prot, flags, fd, offset);
65
66	if (ptr == (void *) -1)
67	{
68	errno = ENOMEM;
69	return (void *) -1;
70	}
71
72	return ptr;
73	}
74
75	void *
76	sysinfo (void *buffer)
77	{
78	void *ptr = sys_sysinfo (buffer);
79
80	if (ptr == (void *) -1)
81	{
82	errno = ENOMEM;
83	return (void *) -1;
84	}
85
86	return ptr;
87	}
88
89	int
90	kill (pid_t pid, int sig)
91	{
92	return syscall_wrapper (sys_kill (pid, sig));
93	}
94
95	int
96	open (const char *pathname, int flags)
97	{
98	return syscall_wrapper (sys_open (pathname, flags, 0644));
99	}
100
101	int
102	close (int fd)
103	{
104	int ret = syscall_wrapper (sys_close (fd));
105
106	if (ret < 0)
107	return ret;
108
109	if (fd < 3)
110	plibc_sfds_status_array[fd] = false;
111
112	return ret;
113	}
114
115	const volatile bool *
116	plibc_sfds_status ()
117	{
118	return plibc_sfds_status_array;
119	}