Diff [b7ee0369ab06af3c771aa449a315cb1881f6870b:051e6ac65018ed47a68dcf61995473a17b5e3d51] for / – HelenOS

uspace/lib/posix/assert.h

-              rb7ee0369
+              r051e6ac
 #ifndef NDEBUG
+        #define assert(expr) ((expr) ? (void) 0 : assert_abort(#expr, __FILE__, __LINE__))
+        #define assert(expr) \
+                do { \
+                        if (!(expr)) { \
+                                assert_abort(#expr, __FILE__, __LINE__); \
+                        } \
+                } while (0)
 #else
         #define assert(expr) ((void) 0)

uspace/lib/posix/ctype.c

rb7ee0369	r051e6ac
94	94	int posix_isprint(int c)
95	95	{
96		return ~~posix_isascii(c) &&~~ !posix_iscntrl(c);
	96	return !posix_iscntrl(c);
97	97	}
98	98

uspace/lib/posix/fnmatch.c

-              rb7ee0369
+              r051e6ac
 static char *_casefold(const char *s)
+{
-        assert(s != NULL);
         char *result = strdup(s);
         for (char *i = result; *i != '\0'; ++i) {
 …
 int posix_fnmatch(const char *pattern, const char *string, int flags)
+{
-        assert(pattern != NULL);
-        assert(string != NULL);
         // TODO: don't fold everything in advance, but only when needed

uspace/lib/posix/internal/common.h

-              rb7ee0369
+              r051e6ac
     __func__, __FILE__, __LINE__), abort())
-/* A little helper macro to avoid typing this over and over. */
-#define errnify(func, ...) ({ \
-        int rc = func(__VA_ARGS__); \
-        if (rc < 0) { \
-                errno = -rc; \
-                rc = -1; \
-        } \
-        rc; \
-})
 #endif /* LIBPOSIX_COMMON_H_ */

uspace/lib/posix/pwd.c

-              rb7ee0369
+              r051e6ac
 #include "errno.h"
+// TODO: documentation
 static bool entry_read = false;
 …
 static const struct posix_passwd dummy_pwd = {
         .pw_name = (char *) "user",
         .pw_uid = 0,
         .pw_gid = 0,
+        .pw_uid = 1,
+        .pw_gid = 1,
         .pw_dir = (char *) "/",
         .pw_shell = (char *) "/app/bdsh"
 …
+{
         assert(name != NULL);
-        assert(pwd != NULL);
-        assert(buffer != NULL);
-        assert(result != NULL);
         if (posix_strcmp(name, "user") != 0) {
 …
+        }
         return posix_getpwuid_r(0, pwd, buffer, bufsize, result);
+        return posix_getpwuid_r(1, pwd, buffer, bufsize, result);
+}
 …
 struct posix_passwd *posix_getpwuid(posix_uid_t uid)
+{
         if (uid != 0) {
+        if (uid != 1) {
                 return NULL;
+        }
 …
             '/', '\0', 'b', 'd', 's', 'h', '\0' };
         if (uid != 0) {
+        if (uid != 1) {
                 *result = NULL;
                 return 0;
 …
         pwd->pw_name = (char *) bf;
         pwd->pw_uid = 0;
         pwd->pw_gid = 0;
+        pwd->pw_uid = 1;
+        pwd->pw_gid = 1;
         pwd->pw_dir = (char *) bf + 5;
         pwd->pw_shell = (char *) bf + 7;

uspace/lib/posix/pwd.h

rb7ee0369	r051e6ac
35	35	#ifndef POSIX_PWD_H_
36	36	#define POSIX_PWD_H_
	37
	38	// TODO: documentation
37	39
38	40	#include "sys/types.h"

uspace/lib/posix/signal.c

-              rb7ee0369
+              r051e6ac
 /**
+ * Default signal handler. Executes the default action for each signal,
+ * as reasonable within HelenOS.
+ *
+ * @param signo Signal number.
+ *
+ * @param signo
  */
 void __posix_default_signal_handler(int signo)
 …
                 abort();
         case SIGQUIT:
                 fprintf(stderr, "Quit signal raised. Exiting.\n");
+                fprintf(stderr, "Quit signal raised. Exiting.");
                 exit(EXIT_FAILURE);
         case SIGINT:
                 fprintf(stderr, "Interrupt signal caught. Exiting.\n");
+                fprintf(stderr, "Interrupt signal caught. Exiting.");
                 exit(EXIT_FAILURE);
         case SIGTERM:
                 fprintf(stderr, "Termination signal caught. Exiting.\n");
+                fprintf(stderr, "Termination signal caught. Exiting.");
                 exit(EXIT_FAILURE);
         case SIGSTOP:
                 fprintf(stderr, "Stop signal caught, but unsupported. Ignoring.\n");
+                fprintf(stderr, "Stop signal caught, but unsupported. Ignoring.");
                 break;
         case SIGKILL:
 …
                     " or fully unsupported signal. This handler may only be"
                     " invoked by the raise() function, which may not be what"
                     " the application developer intended");
+                    " the application developer intended.\nSignal name");
+        }
 …
+        }
-        if (signo > _TOP_SIGNAL) {
-                errno = EINVAL;
-                return -1;
+        }
         if (pid == (posix_pid_t) task_get_id()) {
                 return posix_raise(signo);
+        }
+        if (pid > _TOP_SIGNAL) {
+                errno = EINVAL;
+                return -1;
+        }

uspace/lib/posix/stdio.c

-              rb7ee0369
+              r051e6ac
 #include "assert.h"
 #include "errno.h"
-#include "stdlib.h"
 #include "string.h"
 #include "sys/types.h"
-#include "unistd.h"
 #include "libc/io/printf_core.h"
 #include "libc/str.h"
 #include "libc/malloc.h"
-#include "libc/adt/list.h"
-#include "libc/sys/stat.h"
 …
         assert(mode != NULL);
         assert(stream != NULL);
+        if (filename == NULL) {
+                // TODO
+                /* print error to stderr as well, to avoid hard to find problems
+                 * with buggy apps that expect this to work
+                 */
+                fprintf(stderr,
+                    "ERROR: Application wants to use freopen() to change mode of opened stream.\n"
+                    "       libposix does not support that yet, the application may function improperly.\n");
+                errno = ENOTSUP;
+                return NULL;
+        }
+        FILE* copy = malloc(sizeof(FILE));
+        if (copy == NULL) {
+                errno = ENOMEM;
+                return NULL;
+        }
+        memcpy(copy, stream, sizeof(FILE));
+        fclose(copy); /* copy is now freed */
+        /* Retieve the node. */
+        struct stat st;
+        int rc;
+        copy = fopen(filename, mode); /* open new stream */
+        if (copy == NULL) {
+                /* fopen() sets errno */
+                return NULL;
+        }
+        if (filename == NULL) {
+                rc = fstat(stream->fd, &st);
+        } else {
+                rc = stat(filename, &st);
+        }
+        /* move the new stream to the original location */
+        memcpy(stream, copy, sizeof (FILE));
+        free(copy);
+        if (rc != EOK) {
+                fclose(stream);
+                errno = -rc;
+                return NULL;
+        }
+        fdi_node_t node = {
+                .fs_handle = st.fs_handle,
+                .devmap_handle = st.devmap_handle,
+                .index = st.index
+        };
+        /* Open a new stream. */
+        FILE* new = fopen_node(&node, mode);
+        if (new == NULL) {
+                fclose(stream);
+                /* fopen_node() sets errno. */
+                return NULL;
+        }
+        /* Close the original stream without freeing it (ignoring errors). */
+        if (stream->buf != NULL) {
+                fflush(stream);
+        }
+        if (stream->sess != NULL) {
+                async_hangup(stream->sess);
+        }
+        if (stream->fd >= 0) {
+                close(stream->fd);
+        }
+        list_remove(&stream->link);
+        /* Move the new stream to the original location. */
+        memcpy(stream, new, sizeof (FILE));
+        free(new);
+        /* Update references in the file list. */
+        /* update references in the file list */
         stream->link.next->prev = &stream->link;
         stream->link.prev->next = &stream->link;
 …
 /**
  * Remove a file or directory.
+ * Remove a file.
+ *
  * @param path Pathname of the file that shall be removed.
  * @return Zero on success, -1 (with errno set) otherwise.
+ * @return Zero on success, -1 otherwise.
  */
 int posix_remove(const char *path)
+{
+        struct stat st;
+        int rc = stat(path, &st);
+        if (rc != EOK) {
+                errno = -rc;
+                return -1;
+        }
+        if (st.is_directory) {
+                rc = rmdir(path);
+        } else {
+                rc = unlink(path);
+        }
+        if (rc != EOK) {
+                errno = -rc;
+                return -1;
+        }
+        return 0;
+}
+/**
+ * Rename a file or directory.
+ *
+ * @param old Old pathname.
+ * @param new New pathname.
+ * @return Zero on success, -1 (with errno set) otherwise.
+ */
+int posix_rename(const char *old, const char *new)
+{
+        return errnify(rename, old, new);
+}
+/**
+ * Get a unique temporary file name (obsolete).
+ *
+ * @param s Buffer for the file name. Must be at least L_tmpnam bytes long.
+ * @return The value of s on success, NULL on failure.
+        // FIXME: unlink() and rmdir() seem to be equivalent at the moment,
+        //        but that does not have to be true forever
+        return unlink(path);
+}
+/**
+ *
+ * @param s
+ * @return
  */
 char *posix_tmpnam(char *s)
+{
+        assert(L_tmpnam >= posix_strlen("/tmp/tnXXXXXX"));
+        static char buffer[L_tmpnam + 1];
+        if (s == NULL) {
+                s = buffer;
+        }
+        posix_strcpy(s, "/tmp/tnXXXXXX");
+        posix_mktemp(s);
+        if (*s == '\0') {
+                /* Errno set by mktemp(). */
+                return NULL;
+        }
+        return s;
+}
+/**
+ * Get an unique temporary file name with additional constraints (obsolete).
+ *
+ * @param dir Path to directory, where the file should be created.
+ * @param pfx Optional prefix up to 5 characters long.
+ * @return Newly allocated unique path for temporary file. NULL on failure.
+ */
+char *posix_tempnam(const char *dir, const char *pfx)
+{
+        /* Sequence number of the filename. */
+        static int seq = 0;
+        size_t dir_len = posix_strlen(dir);
+        if (dir[dir_len - 1] == '/') {
+                dir_len--;
+        }
+        size_t pfx_len = posix_strlen(pfx);
+        if (pfx_len > 5) {
+                pfx_len = 5;
+        }
+        char *result = malloc(dir_len + /* slash*/ 1 +
+            pfx_len + /* three-digit seq */ 3 + /* .tmp */ 4 + /* nul */ 1);
+        if (result == NULL) {
+                errno = ENOMEM;
+                return NULL;
+        }
+        char *res_ptr = result;
+        posix_strncpy(res_ptr, dir, dir_len);
+        res_ptr += dir_len;
+        posix_strncpy(res_ptr, pfx, pfx_len);
+        res_ptr += pfx_len;
+        for (; seq < 1000; ++seq) {
+                snprintf(res_ptr, 8, "%03d.tmp", seq);
+                int orig_errno = errno;
+                errno = 0;
+                /* Check if the file exists. */
+                if (posix_access(result, F_OK) == -1) {
+                        if (errno == ENOENT) {
+                                errno = orig_errno;
+                                break;
+                        } else {
+                                /* errno set by access() */
+                                return NULL;
+                        }
+                }
+        }
+        if (seq == 1000) {
+                free(result);
+                errno = EINVAL;
+                return NULL;
+        }
+        return result;
+}
+/**
+ * Create and open an unique temporary file.
+ * The file is automatically removed when the stream is closed.
+ *
+ * @param dir Path to directory, where the file should be created.
+ * @param pfx Optional prefix up to 5 characters long.
+ * @return Newly allocated unique path for temporary file. NULL on failure.
+ */
+FILE *posix_tmpfile(void)
+{
+        char filename[] = "/tmp/tfXXXXXX";
+        int fd = posix_mkstemp(filename);
+        if (fd == -1) {
+                /* errno set by mkstemp(). */
+                return NULL;
+        }
+        /* Unlink the created file, so that it's removed on close(). */
+        posix_unlink(filename);
+        return fdopen(fd, "w+");
+        // TODO: low priority, just a compile-time dependency of binutils
+        not_implemented();
+}

uspace/lib/posix/stdio.h

-              rb7ee0369
+              r051e6ac
 extern int posix_remove(const char *path);
-/* Renaming Files */
-extern int posix_rename(const char *old, const char *new);
 /* Temporary Files */
 #undef L_tmpnam
 #define L_tmpnam PATH_MAX
 extern char *posix_tmpnam(char *s);
-extern char *posix_tempnam(const char *dir, const char *pfx);
-extern FILE *posix_tmpfile(void);
 #ifndef LIBPOSIX_INTERNAL
 …
         #define remove posix_remove
-        #define rename posix_rename
         #define tmpnam posix_tmpnam
-        #define tempnam posix_tempnam
-        #define tmpfile posix_tmpfile
 #endif

uspace/lib/posix/stdlib.c

-              rb7ee0369
+              r051e6ac
 #include "errno.h"
-#include "fcntl.h"
 #include "limits.h"
-#include "string.h"
-#include "sys/stat.h"
-#include "unistd.h"
 #include "libc/sort.h"
 …
 /**
+ * Creates and opens an unique temporary file from template.
+ *
+ * @param tmpl Template. Last six characters must be XXXXXX.
+ * @return The opened file descriptor or -1 on error.
+ */
+int posix_mkstemp(char *tmpl)
+{
+        int fd = -1;
+        char *tptr = tmpl + posix_strlen(tmpl) - 6;
+        while (fd < 0) {
+                if (*posix_mktemp(tmpl) == '\0') {
+                        /* Errno set by mktemp(). */
+                        return -1;
+                }
+                fd = open(tmpl, O_RDWR | O_CREAT | O_EXCL, S_IRUSR | S_IWUSR);
+                if (fd == -1) {
+                        /* Restore template to it's original state. */
+                        snprintf(tptr, 7, "XXXXXX");
+                }
+        }
+        return fd;
+}
+/**
+ * Creates an unique temporary file name from template.
+ *
+ * @param tmpl Template. Last six characters must be XXXXXX.
+ * @return The value of tmpl. The template is modified in place.
+ *    If no temporary file name can be created, template is
+ *    reduced to an empty string.
+ *
+ * @param tmpl
+ * @return
  */
 char *posix_mktemp(char *tmpl)
+{
+        int tmpl_len = posix_strlen(tmpl);
+        if (tmpl_len < 6) {
+                errno = EINVAL;
+                *tmpl = '\0';
+                return tmpl;
+        }
+        char *tptr = tmpl + tmpl_len - 6;
+        if (posix_strcmp(tptr, "XXXXXX") != 0) {
+                errno = EINVAL;
+                *tmpl = '\0';
+                return tmpl;
+        }
+        static int seq = 0;
+        for (; seq < 1000000; ++seq) {
+                snprintf(tptr, 7, "%06d", seq);
+                int orig_errno = errno;
+                errno = 0;
+                /* Check if the file exists. */
+                if (posix_access(tmpl, F_OK) == -1) {
+                        if (errno == ENOENT) {
+                                errno = orig_errno;
+                                break;
+                        } else {
+                                /* errno set by access() */
+                                *tmpl = '\0';
+                                return tmpl;
+                        }
+                }
+        }
+        if (seq == 10000000) {
+                errno = EEXIST;
+                *tmpl = '\0';
+                return tmpl;
+        }
+        return tmpl;
+        // TODO: low priority, just a compile-time dependency of binutils
+        not_implemented();
+}

uspace/lib/posix/stdlib.h

-              rb7ee0369
+              r051e6ac
 extern void posix_free(void *ptr);
-/* Temporary Files */
-extern int posix_mkstemp(char *tmpl);
 /* Legacy Declarations */
 extern char *posix_mktemp(char *tmpl);
 …
         #define free posix_free
-        #define mkstemp posix_mkstemp
         #define mktemp posix_mktemp
         #define getloadavg bsd_getloadavg

uspace/lib/posix/sys/wait.c

-              rb7ee0369
+              r051e6ac
 #include "wait.h"
+#include "../libc/task.h"
+#include "../assert.h"
+#include "../errno.h"
+#include "../limits.h"
+#include "../signal.h"
+int __posix_wifexited(int status) {
+        return status != INT_MIN;
+}
+int __posix_wexitstatus(int status) {
+        assert(__posix_wifexited(status));
+        return status;
+}
+int __posix_wifsignaled(int status) {
+        return status == INT_MIN;
+}
+int __posix_wtermsig(int status) {
+        assert(__posix_wifsignaled(status));
+        /* There is no way to distinguish reason
+         * for unexpected termination at the moment.
+         */
+        return SIGABRT;
+/**
+ *
+ * @param stat_ptr
+ * @return
+ */
+posix_pid_t posix_wait(int *stat_ptr)
+{
+        // TODO: low priority, just a compile-time dependency of binutils
+        not_implemented();
+}
 /**
- * Wait for any child process to stop or terminate.
+ *
+ * @param stat_ptr Location of the final status code of the child process.
+ * @return ID of the child process for which status is reported,
+ *     -1 on signal interrupt, (pid_t)-1 otherwise.
+ */
+posix_pid_t posix_wait(int *stat_ptr)
+{
+        /* HelenOS does not support this. */
+        errno = ENOSYS;
+        return (posix_pid_t) -1;
+}
+/**
+ * Wait for a child process to stop or terminate.
+ *
+ * @param pid What child process shall the caller wait for. See POSIX manual
+ *     for details.
+ * @param stat_ptr Location of the final status code of the child process.
+ * @param options Constraints of the waiting. See POSIX manual for details.
+ * @return ID of the child process for which status is reported,
+ *     -1 on signal interrupt, 0 if non-blocking wait is requested but there is
+ *     no child process whose status can be reported, (pid_t)-1 otherwise.
+ * @param pid
+ * @param stat_ptr
+ * @param options
+ * @return
  */
 posix_pid_t posix_waitpid(posix_pid_t pid, int *stat_ptr, int options)
+{
+        assert(stat_ptr != NULL);
+        assert(options == 0 /* None of the options are supported. */);
+        task_exit_t texit;
+        int retval;
+        int rc = task_wait((task_id_t) pid, &texit, &retval);
+        if (rc < 0) {
+                /* Unable to retrieve status. */
+                errno = -rc;
+                return (posix_pid_t) -1;
+        }
+        if (texit == TASK_EXIT_NORMAL) {
+                // FIXME: relies on application not returning this value
+                assert(retval != INT_MIN);
+                *stat_ptr = retval;
+        } else {
+                /* Reserve the lowest value for unexpected termination. */
+                *stat_ptr = INT_MIN;
+        }
+        return pid;
+        // TODO: low priority, just a compile-time dependency of binutils
+        not_implemented();
+}

uspace/lib/posix/sys/wait.h

-              rb7ee0369
+              r051e6ac
 #include "types.h"
-#undef WIFEXITED
-#undef WEXITSTATUS
-#undef WIFSIGNALED
-#undef WTERMSIG
-#define WIFEXITED(status) __posix_wifexited(status)
-#define WEXITSTATUS(status) __posix_wexitstatus(status)
-#define WIFSIGNALED(status) __posix_wifsignaled(status)
-#define WTERMSIG(status) __posix_wtermsig(status)
-extern int __posix_wifexited(int status);
-extern int __posix_wexitstatus(int status);
-extern int __posix_wifsignaled(int status);
-extern int __posix_wtermsig(int status);
 extern posix_pid_t posix_wait(int *stat_ptr);
 extern posix_pid_t posix_waitpid(posix_pid_t pid, int *stat_ptr, int options);
 …
 #ifndef LIBPOSIX_INTERNAL
         #define wait posix_wait
         #define waitpid posix_waitpid
+        #define waitpid posix_waitpid
 #endif

uspace/lib/posix/unistd.c

-              rb7ee0369
+              r051e6ac
                 return NULL;
+        }
-        /* Save the original value to comply with the "no modification on
-         * success" semantics.
-         */
-        int orig_errno = errno;
-        errno = EOK;
         char *ret = getcwd(buf, size);
+        if (ret == NULL) {
+                /* Check errno to avoid shadowing other possible errors. */
+                if (errno == EOK) {
+                        errno = ERANGE;
+                }
+        } else {
+                /* Success, restore previous errno value. */
+                errno = orig_errno;
+        }
+        if (ret == NULL && errno == EOK) {
+                errno = ERANGE;
+        }
         return ret;
+}
-/**
- * Change the current working directory.
+ *
- * @param path New working directory.
- */
-int posix_chdir(const char *path)
+{
-        return errnify(chdir, path);
+}
 …
         /* There is currently no support for user accounts in HelenOS. */
         return 0;
+}
-/**
- * Close a file.
+ *
- * @param fildes File descriptor of the opened file.
- * @return 0 on success, -1 on error.
- */
-int posix_close(int fildes)
+{
-        return errnify(close, fildes);
+}
 …
 ssize_t posix_read(int fildes, void *buf, size_t nbyte)
+{
+        return errnify(read, fildes, buf, nbyte);
+}
+/**
+ * Write to a file.
+ *
+ * @param fildes File descriptor of the opened file.
+ * @param buf Buffer to write.
+ * @param nbyte Size of the buffer.
+ * @return Number of written bytes on success, -1 otherwise.
+ */
+ssize_t posix_write(int fildes, const void *buf, size_t nbyte)
+{
+        return errnify(write, fildes, buf, nbyte);
+}
+/**
+ * Requests outstanding data to be written to the underlying storage device.
+ *
+ * @param fildes File descriptor of the opened file.
+ * @return Zero on success, -1 otherwise.
+ */
+int posix_fsync(int fildes)
+{
+        return errnify(fsync, fildes);
+}
+/**
+ * Truncate a file to a specified length.
+ *
+ * @param fildes File descriptor of the opened file.
+ * @param length New length of the file.
+ * @return Zero on success, -1 otherwise.
+ */
+int posix_ftruncate(int fildes, posix_off_t length)
+{
+        return errnify(ftruncate, fildes, (aoff64_t) length);
+}
+/**
+ * Remove a directory.
+ *
+ * @param path Directory pathname.
+ * @return Zero on success, -1 otherwise.
+ */
+int posix_rmdir(const char *path)
+{
+        return errnify(rmdir, path);
+        int rc = read(fildes, buf, nbyte);
+        if (rc < 0) {
+                errno = -rc;
+                return -1;
+        } else {
+                return rc;
+        }
+}
 …
 int posix_unlink(const char *path)
+{
+        return errnify(unlink, path);
+}
+/**
+ * Duplicate an open file descriptor.
+ *
+ * @param fildes File descriptor to be duplicated.
+ * @return On success, new file descriptor for the same file, otherwise -1.
+ */
+int posix_dup(int fildes)
+{
+        return posix_fcntl(fildes, F_DUPFD, 0);
+}
+/**
+ * Duplicate an open file descriptor.
+ *
+ * @param fildes File descriptor to be duplicated.
+ * @param fildes2 File descriptor to be paired with the same file description
+ *     as is paired fildes.
+ * @return fildes2 on success, -1 otherwise.
+ */
+int posix_dup2(int fildes, int fildes2)
+{
+        return errnify(dup2, fildes, fildes2);
+        int rc = unlink(path);
+        if (rc < 0) {
+                errno = -rc;
+                return -1;
+        } else {
+                return rc;
+        }
+}
 …
 int posix_access(const char *path, int amode)
+{
+        if (amode == F_OK || (amode & (X_OK | W_OK | R_OK))) {
+                /* HelenOS doesn't support permissions, permission checks
+                 * are equal to existence check.
+                 *
+                 * Check file existence by attempting to open it.
+                 */
+        if (amode == F_OK) {
+                /* Check file existence by attempt to open it. */
                 int fd = open(path, O_RDONLY);
+                if (fd < 0) {
+                        errno = -fd;
+                        return -1;
+                if (fd != -1) {
+                        close(fd);
+                }
+                close(fd);
+                return fd;
+        } else if (amode & (X_OK | W_OK | R_OK)) {
+                /* HelenOS doesn't support permissions, return success. */
                 return 0;
         } else {

uspace/lib/posix/unistd.h

-              rb7ee0369
+              r051e6ac
 /* Working Directory */
 extern char *posix_getcwd(char *buf, size_t size);
-extern int posix_chdir(const char *path);
 /* Query Memory Parameters */
 …
 extern posix_gid_t posix_getgid(void);
+/* File Manipulation */
+extern int posix_close(int fildes);
+/* File Input/Output */
 extern ssize_t posix_read(int fildes, void *buf, size_t nbyte);
+extern ssize_t posix_write(int fildes, const void *buf, size_t nbyte);
+extern int posix_fsync(int fildes);
+extern int posix_ftruncate(int fildes, posix_off_t length);
+extern int posix_rmdir(const char *path);
+/* Deleting Files */
 extern int posix_unlink(const char *path);
-extern int posix_dup(int fildes);
-extern int posix_dup2(int fildes, int fildes2);
 /* Standard Streams */
 …
         #define getcwd posix_getcwd
-        #define chdir posix_chdir
         #define isatty posix_isatty
 …
         #define getgid posix_getgid
-        #define close posix_close
         #define read posix_read
+        #define write posix_write
+        #define fsync posix_fsync
+        #define ftruncate posix_ftruncate
+        #define rmdir posix_rmdir
         #define unlink posix_unlink
-        #define dup posix_dup
-        #define dup2 posix_dup2
         #define access posix_access

uspace/lib/softint/Makefile

-              rb7ee0369
+              r051e6ac
 SOURCES = \
-        generic/comparison.c \
         generic/division.c \
+        generic/multiplication.c \
+        generic/shift.c
+        generic/multiplication.c
 include $(USPACE_PREFIX)/Makefile.common

uspace/srv/hw/irc/apic/apic.c

-              rb7ee0369
+              r051e6ac
 #include <as.h>
 #include <ddi.h>
+#include <libarch/ddi.h>
+#include <align.h>
 #include <bool.h>
 #include <errno.h>
 #include <async.h>
+#include <align.h>
+#include <async.h>
+#include <stdio.h>
+#include <ipc/devmap.h>
 #define NAME  "apic"
-#define APIC_MAX_IRQ    15
-#define IOREGSEL  (0x00U / sizeof(uint32_t))
-#define IOWIN     (0x10U / sizeof(uint32_t))
-#define IOREDTBL   0x10U
-/** I/O Register Select Register. */
-typedef union {
-        uint32_t value;
-        struct {
-                uint8_t reg_addr;       /**< APIC Register Address. */
-                unsigned int : 24;      /**< Reserved. */
-        } __attribute__ ((packed));
-} io_regsel_t;
-/** I/O Redirection Register. */
-typedef struct io_redirection_reg {
-        union {
-                uint32_t lo;
-                struct {
-                        uint8_t intvec;                 /**< Interrupt Vector. */
-                        unsigned int delmod : 3;        /**< Delivery Mode. */
-                        unsigned int destmod : 1;       /**< Destination mode. */
-                        unsigned int delivs : 1;        /**< Delivery status (RO). */
-                        unsigned int intpol : 1;        /**< Interrupt Input Pin Polarity. */
-                        unsigned int irr : 1;           /**< Remote IRR (RO). */
-                        unsigned int trigger_mode : 1;  /**< Trigger Mode. */
-                        unsigned int masked : 1;        /**< Interrupt Mask. */
-                        unsigned int : 15;              /**< Reserved. */
-                } __attribute__ ((packed));
-        };
-        union {
-                uint32_t hi;
-                struct {
-                        unsigned int : 24;      /**< Reserved. */
-                        uint8_t dest : 8;       /**< Destination Field. */
-                } __attribute__ ((packed));
-        };
-} __attribute__ ((packed)) io_redirection_reg_t;
-// FIXME: get the address from the kernel
-#define IO_APIC_BASE    0xfec00000UL
-#define IO_APIC_SIZE    20
-ioport32_t *io_apic = NULL;
-/** Read from IO APIC register.
+ *
- * @param address IO APIC register address.
+ *
- * @return Content of the addressed IO APIC register.
+ *
- */
-static uint32_t io_apic_read(uint8_t address)
+{
-        io_regsel_t regsel;
-        regsel.value = io_apic[IOREGSEL];
-        regsel.reg_addr = address;
-        io_apic[IOREGSEL] = regsel.value;
-        return io_apic[IOWIN];
+}
-/** Write to IO APIC register.
+ *
- * @param address IO APIC register address.
- * @param val     Content to be written to the addressed IO APIC register.
+ *
- */
-static void io_apic_write(uint8_t address, uint32_t val)
+{
-        io_regsel_t regsel;
-        regsel.value = io_apic[IOREGSEL];
-        regsel.reg_addr = address;
-        io_apic[IOREGSEL] = regsel.value;
-        io_apic[IOWIN] = val;
+}
-static int irq_to_pin(int irq)
+{
-        // FIXME: get the map from the kernel, even though this may work
-        //        for simple cases
-        return irq;
+}
 static int apic_enable_irq(sysarg_t irq)
+{
+        io_redirection_reg_t reg;
+        if (irq > APIC_MAX_IRQ)
+                return ELIMIT;
+        int pin = irq_to_pin(irq);
+        if (pin == -1)
+                return ENOENT;
+        reg.lo = io_apic_read((uint8_t) (IOREDTBL + pin * 2));
+        reg.masked = false;
+        io_apic_write((uint8_t) (IOREDTBL + pin * 2), reg.lo);
+        return EOK;
+        // FIXME: TODO
+        return ENOTSUP;
+}
 …
                 return false;
+        }
-        if (pio_enable((void *) IO_APIC_BASE, IO_APIC_SIZE,
-            (void **) &io_apic) != EOK)
-                return false;
         async_set_client_connection(apic_connection);

Context Navigation

Changes in / [b7ee0369:051e6ac] in mainline

Legend:

uspace/lib/posix/assert.h

uspace/lib/posix/ctype.c

uspace/lib/posix/fnmatch.c

uspace/lib/posix/internal/common.h

uspace/lib/posix/pwd.c

uspace/lib/posix/pwd.h

uspace/lib/posix/signal.c

uspace/lib/posix/stdio.c

uspace/lib/posix/stdio.h

uspace/lib/posix/stdlib.c

uspace/lib/posix/stdlib.h

uspace/lib/posix/sys/wait.c

uspace/lib/posix/sys/wait.h

uspace/lib/posix/unistd.c

uspace/lib/posix/unistd.h

uspace/lib/softint/Makefile

uspace/srv/hw/irc/apic/apic.c

Download in other formats: