Changeset 2423 in kBuild for trunk/src

Timestamp:

Oct 17, 2010 11:43:35 PM (14 years ago)

Author:

bird

Message:

kash: made the SHFILE_IN_USE mode work on unix (because openbsd has a very hackish pthread library).

Location:

trunk/src/kash

Files:

• Makefile.kmk (modified) (2 diffs)
• eval.c (modified) (1 diff)
• redir.c (modified) (1 diff)
• shfile.c (modified) (18 diffs)
• shfile.h (modified) (1 diff)
• shinstance.c (modified) (1 diff)
• show.c (modified) (1 diff)
• tests/Makefile.kmk (modified) (3 diffs)

trunk/src/kash/Makefile.kmk

@@ -31 +31 @@
 #
 PROGRAMS += kash
-kash_TEMPLATE = BIN
-kash_NAME.win = kmk_ash
+kash_TEMPLATE = BIN-THREADED
+kash_NAME = kmk_ash
 kash_ASTOOL = YASM
 kash_DEFS = lint SHELL SMALL
@@ -50 +50 @@
         HAVE_SYS_SIGNAME HAVE_SYSCTL_H HAVE_SETPROGNAME
 kash_DEFS.freebsd = \
+        HAVE_SYS_SIGNAME HAVE_SYSCTL_H HAVE_SETPROGNAME
+kash_DEFS.openbsd = \
         HAVE_SYS_SIGNAME HAVE_SYSCTL_H HAVE_SETPROGNAME
 kash_INCS = $(kash_0_OUTDIR) . # (the last is because of error.h)

trunk/src/kash/eval.c

@@ -45 +45 @@
 #include <sys/types.h>
 #ifdef HAVE_SYSCTL_H
+# ifdef __OpenBSD__ /* joyful crap */
+#  include <sys/param.h>
+#  undef psh
+# endif
 # include <sys/sysctl.h>
 #endif

trunk/src/kash/redir.c

@@ -383 +383 @@
         return newfd;
 }
+
+
+/*
+ * Copy a file descriptor to be = to.  Returns -1
+ * if the source file descriptor is closed, EMPTY if there are no unused
+ * file descriptors left.
+ */
+
+int
+copyfd2(shinstance *psh, int from, int to)
+{
+        int newfd;
+
+        /** @todo Use dup2()... */
+        newfd = shfile_fcntl(&psh->fdtab, from, F_DUPFD, to);
+        if (newfd < 0) {
+                if (errno == EMFILE)
+                        return EMPTY;
+                else
+                        error(psh, "%d: %s", from, strerror(errno));
+        }
+        else if (newfd != to) {
+                error(psh, "%d: F_DUPFD returned %d, expected %d", from, newfd, to);
+                close(newfd);
+                newfd = -1;
+        }
+
+        return newfd;
+}
+

trunk/src/kash/shfile.c

@@ -32 +32 @@
 #include <stdlib.h>
 #include <stdio.h>
+#include <string.h>
 #include <assert.h>
 
@@ -60 +61 @@
  */
 #if K_OS == K_OS_WINDOWS \
+ || K_OS == K_OS_OPENBSD /* because of ugly pthread library pipe hacks */ \
  || !defined(SH_FORKED_MODE)
 # define SHFILE_IN_USE
@@ -201 +203 @@
         return -1;
     }
+# if K_OS != K_OS_WINDOWS
+    if (fcntl((int)native, F_SETFD, fcntl((int)native, F_GETFD, 0) | FD_CLOEXEC) == -1)
+    {
+        int e = errno;
+        close((int)native);
+        errno = e;
+        return -1;
+    }
+# endif
 
     shmtx_enter(&pfdtab->mtx, &tmp);
@@ -264 +275 @@
     return fd;
 }
+
+#if K_OS != K_OS_WINDOWS
+/**
+ * Makes a copy of the native file, closes the original, and inserts the copy
+ * into the descriptor table.
+ *
+ * If we're out of memory and cannot extend the table, we'll close the
+ * file, set errno to EMFILE and return -1.
+ *
+ * @returns The file descriptor number. -1 and errno on failure.
+ * @param   pfdtab      The file descriptor table.
+ * @param   pnative     The native file handle on input, -1 on output.
+ * @param   oflags      The flags the it was opened/created with.
+ * @param   shflags     The shell file flags.
+ * @param   fdMin       The minimum file descriptor number, pass -1 if any is ok.
+ * @param   who         Who we're doing this for (for logging purposes).
+ */
+static int shfile_copy_insert_and_close(shfdtab *pfdtab, int *pnative, unsigned oflags, unsigned shflags, int fdMin, const char *who)
+{
+    int fd          = -1;
+    int s           = errno;
+    int native_copy = fcntl(*pnative, F_DUPFD, SHFILE_UNIX_MIN_FD);
+    close(*pnative);
+    *pnative = -1;
+    errno = s;
+
+    if (native_copy != -1)
+        fd = shfile_insert(pfdtab, native_copy, oflags, shflags, fdMin, who);
+    return fd;
+}
+#endif /* !K_OS_WINDOWS */
 
 /**
@@ -646 +688 @@
                     }
 # else
+                /*
+                 * Annoying...
+                 */
+                int fd;
+
+                for (fd = 0; fd < 10; fd++)
+                {
+                    int oflags = fcntl(fd, F_GETFL, 0);
+                    if (oflags != -1)
+                    {
+                        int cox = fcntl(fd, F_GETFD, 0);
+                        struct stat st;
+                        if (   cox != -1
+                            && fstat(fd, &st) != -1)
+                        {
+                            int native;
+                            int fd2;
+                            int fFlags2 = 0;
+                            if (cox & FD_CLOEXEC)
+                                fFlags2 |= SHFILE_FLAGS_CLOSE_ON_EXEC;
+                            if (S_ISREG(st.st_mode))
+                                fFlags2 |= SHFILE_FLAGS_FILE;
+                            else if (S_ISDIR(st.st_mode))
+                                fFlags2 |= SHFILE_FLAGS_DIR;
+                            else if (S_ISCHR(st.st_mode))
+                                fFlags2 |= SHFILE_FLAGS_TTY;
+                            else if (S_ISFIFO(st.st_mode))
+                                fFlags2 |= SHFILE_FLAGS_PIPE;
+                            else
+                                fFlags2 |= SHFILE_FLAGS_TTY;
+
+                            native = fcntl(fd, F_DUPFD, SHFILE_UNIX_MIN_FD);
+                            if (native == -1)
+                                native = fd;
+                            fd2 = shfile_insert(pfdtab, native, oflags, fFlags2, fd, "shtab_init");
+                            assert(fd2 == fd); (void)fd2;
+                            if (fd2 != fd)
+                                rc = -1;
+                            if (native != fd)
+                                close(fd);
+                        }
+                    }
+                }
+
 # endif
             }
@@ -829 +915 @@
 #endif /* K_OS_WINDOWS */
 
+#if K_OS != K_OS_WINDOWS
+/**
+ * Prepare file handles for inherting before a execve call.
+ *
+ * This is only used in the normal mode, so we've forked and need not worry
+ * about cleaning anything up after us.  Nor do we need think about locking.
+ *
+ * @returns 0 on success, -1 on failure.
+ */
+int shfile_exec_unix(shfdtab *pfdtab)
+{
+    int rc = 0;
+# ifdef SHFILE_IN_USE
+    unsigned fd;
+
+    for (fd = 0; fd < pfdtab->size; fd++)
+    {
+        if (   pfdtab->tab[fd].fd != -1
+            && !(pfdtab->tab[fd].shflags & SHFILE_FLAGS_CLOSE_ON_EXEC) )
+        {
+            TRACE2((NULL, "shfile_exec_unix: %d => %d\n", pfdtab->tab[fd].native, fd));
+            if (dup2(pfdtab->tab[fd].native, fd) < 0)
+            {
+                /* fatal_error(NULL, "shfile_exec_unix: failed to move %d to %d", pfdtab->tab[fd].fd, fd); */
+                rc = -1;
+            }
+        }
+    }
+# endif
+    return rc;
+}
+#endif /* !K_OS_WINDOWS */
 
 /**
@@ -911 +1029 @@
     if (!fd)
     {
-        fd = open(absname, flag, mode);
+        fd = open(absname, flags, mode);
         if (fd != -1)
-        {
-            int native = fcntl(fd, F_DUPFD, SHFILE_UNIX_MIN_FD);
-            int s = errno;
-            close(fd);
-            errno = s;
-            if (native != -1)
-                fd = shfile_insert(pfdtab, native, flags, 0, -1, "shfile_open");
-            else
-                fd = -1;
-        }
+            fd = shfile_copy_insert_and_close(pfdtab, &fd, flags, 0, -1, "shfile_open");
     }
 
@@ -937 +1046 @@
 int shfile_pipe(shfdtab *pfdtab, int fds[2])
 {
-    int rc;
+    int rc = -1;
 #ifdef SHFILE_IN_USE
 # if K_OS == K_OS_WINDOWS
@@ -965 +1074 @@
     if (!pipe(native_fds))
     {
-        fds[0] = shfile_insert(pfdtab, native_fds[0], O_RDONLY, SHFILE_FLAGS_PIPE, -1, "shfile_pipe");
+        fds[0] = shfile_copy_insert_and_close(pfdtab, &native_fds[0], O_RDONLY, SHFILE_FLAGS_PIPE, -1, "shfile_pipe");
         if (fds[0] != -1)
         {
-            fds[1] = shfile_insert(pfdtab, native_fds[1], O_WRONLY, SHFILE_FLAGS_PIPE, -1, "shfile_pipe");
+            fds[1] = shfile_copy_insert_and_close(pfdtab, &native_fds[1], O_WRONLY, SHFILE_FLAGS_PIPE, -1, "shfile_pipe");
             if (fds[1] != -1)
                 rc = 0;
@@ -1049 +1158 @@
 
 #else
+    fsync(fd);
+    {
+        struct stat s;
+        fstat(fd, &s);
+        TRACE2((NULL, "shfile_close(%d) - %lu bytes\n", fd, (long)s.st_size));
+    }
     rc = close(fd);
 #endif
@@ -1115 +1230 @@
 
 #else
+    if (fd != shthread_get_shell()->tracefd)
+    {
+        struct stat s;
+        int x;
+        x = fstat(fd, &s);
+        TRACE2((NULL, "shfile_write(%d) - %lu bytes (%d) - pos %lu - before; %o\n",
+                fd, (long)s.st_size, x, (long)lseek(fd, 0, SEEK_CUR), s.st_mode ));
+        errno = 0;
+    }
+
     rc = write(fd, buf, len);
+#endif
+
+#ifdef DEBUG
+    if (fd != shthread_get_shell()->tracefd)
+    {
+        struct stat s;
+        int x;
+        TRACE2((NULL, "shfile_write(%d,,%d) -> %d [%d]\n", fd, len, rc, errno));
+        x=fstat(fd, &s);
+        TRACE2((NULL, "shfile_write(%d) - %lu bytes (%d) - pos %lu - after\n", fd, (long)s.st_size, x, (long)lseek(fd, 0, SEEK_CUR) ));
+    }
 #endif
     return rc;
@@ -1191 +1327 @@
                     rc = fcntl(file->native, F_SETFL, arg);
                     if (rc != -1)
-                        file->flags = (file->flags & ~mask) | (arg & mask);
+                        file->oflags = (file->oflags & ~mask) | (arg & mask);
 # endif
                 }
@@ -1212 +1348 @@
                     rc = shfile_dos2errno(GetLastError());
 # else
-                int nativeNew = fcntl(file->native F_DUPFD, SHFILE_UNIX_MIN_FD);
+                int nativeNew = fcntl(file->native, F_DUPFD, SHFILE_UNIX_MIN_FD);
                 if (nativeNew != -1)
                     rc = shfile_insert(pfdtab, nativeNew, file->oflags, file->shflags, arg, "shfile_fcntl");
+                else
+                    rc = -1;
 # endif
                 break;
@@ -1352 +1490 @@
         else
         {
-            if (size < cwd_size)
+            if ((size_t)size < cwd_size)
                 size = (int)cwd_size;
             ret = sh_malloc(shthread_get_shell(), size);
@@ -1445 +1583 @@
             file->shflags &= ~SHFILE_FLAGS_CLOSE_ON_EXEC;
         shfile_put(pfdtab, file, &tmp);
+        rc = 0;
     }
     else
@@ -1501 +1640 @@
 shdir *shfile_opendir(shfdtab *pfdtab, const char *dir)
 {
-#ifdef SHFILE_IN_USE
+#if defined(SHFILE_IN_USE) && K_OS == K_OS_WINDOWS
     shdir  *pdir = NULL;
 
@@ -1549 +1688 @@
 shdirent *shfile_readdir(struct shdir *pdir)
 {
-#ifdef SHFILE_IN_USE
+#if defined(SHFILE_IN_USE) && K_OS == K_OS_WINDOWS
     if (pdir)
     {
@@ -1617 +1756 @@
 void shfile_closedir(struct shdir *pdir)
 {
-#ifdef SHFILE_IN_USE
+#if defined(SHFILE_IN_USE) && K_OS == K_OS_WINDOWS
     if (pdir)
     {

trunk/src/kash/shfile.h

@@ -132 +132 @@
 void shfile_fork_win(shfdtab *pfdtab, int set, intptr_t *hndls);
 void *shfile_exec_win(shfdtab *pfdtab, int prepare, unsigned short *sizep, intptr_t *hndls);
+int shfile_exec_unix(shfdtab *pfdtab);
 
 int shfile_open(shfdtab *, const char *, unsigned, mode_t);

trunk/src/kash/shinstance.c

@@ -1080 +1080 @@
     }
     rc = -1;
-# else
-    rc = execve(exe, (char **)argv, (char **)envp);
+
+# else
+    rc = shfile_exec_unix(&psh->fdtab);
+    if (!rc)
+        rc = execve(exe, (char **)argv, (char **)envp);
 # endif
 

trunk/src/kash/show.c

@@ -516 +516 @@
                         want_fd = ((want_fd + 1) / 2) - 1;
                 }
+                shfile_cloexec(&psh->fdtab, psh->tracefd, 1 /* close it */);
         }
         if (psh->tracefd == -1) {

trunk/src/kash/tests/Makefile.kmk

@@ -24 +24 @@
 #
 
-SUB_DEPTH = ../..
+SUB_DEPTH = ../../..
 include $(KBUILD_PATH)/subheader.kmk
 
@@ -33 +33 @@
 TESTING += kash_tests
 
-KASH_TEST_BIN   = $(if $(kash_1_TARGET),$(kash_1_TARGET),$(PATH_INS)/$(TEMPLATE_BIN_INST)kash$(SUFF_EXE))
+KASH_TEST_BIN   = $(if $(kash_1_TARGET),$(kash_1_TARGET),$(PATH_INS)/$(TEMPLATE_BIN_INST)kmk_ash$(SUFF_EXE))
 KASH_TEST_DIR  := $(PATH_SUB_CURRENT)
 KASH_TESTCASES := $(addprefix $(KASH_TEST_DIR)/,\
@@ -45 +45 @@
         pipe-1 \
         pipe-2 \
+        exec-1 \
         )