diff --git a/src/os/unix/ngx_daemon.c b/src/os/unix/ngx_daemon.c
new file mode 100644
index 0000000..6faf85b
--- /dev/null
+++ b/src/os/unix/ngx_daemon.c
@@ -0,0 +1,80 @@
+
+#include <ngx_config.h>
+#include <ngx_core.h>
+#include <ngx_log.h>
+
+/* daemon in Linux */
+
+int ngx_daemon(ngx_log_t *log)
+{
+    int  fd;
+
+    switch (fork()) {
+    case -1:
+        ngx_log_error(NGX_LOG_ALERT, log, errno, "fork() failed");
+        return NGX_ERROR;
+
+    case 0:
+        break;
+
+    default:
+        exit(0);
+    }
+
+    if (setsid() == -1) {
+        ngx_log_error(NGX_LOG_ALERT, log, errno, "setsid() failed");
+        return NGX_ERROR;
+    }
+
+#if (__SVR4 || linux)
+
+    /* need HUP IGN ? check in Solaris and Linux */
+
+    switch (fork()) {
+    case -1:
+        ngx_log_error(NGX_LOG_ALERT, log, errno, "fork() failed");
+        return NGX_ERROR;
+
+    case 0:
+        break;
+
+    default:
+        exit(0);
+    }
+
+#endif
+
+    umask(0);
+
+#if 0
+    fd = open("/dev/null", O_RDWR);
+    if (fd == -1) {
+        ngx_log_error(NGX_LOG_ALERT, log, errno, "open(\"/dev/null\") failed");
+        return NGX_ERROR;
+    }
+
+    if (dup2(fd, STDIN_FILENO) == -1) {
+        ngx_log_error(NGX_LOG_ALERT, log, errno, "dup2(STDIN) failed");
+        return NGX_ERROR;
+    }
+
+    if (dup2(fd, STDOUT_FILENO) == -1) {
+        ngx_log_error(NGX_LOG_ALERT, log, errno, "dup2(STDOUT) failed");
+        return NGX_ERROR;
+    }
+
+    if (dup2(fd, STDERR_FILENO) == -1) {
+        ngx_log_error(NGX_LOG_ALERT, log, errno, "dup2(STDERR) failed");
+        return NGX_ERROR;
+    }
+
+    if (fd > STDERR_FILENO) {
+        if (close(fd) == -1) {
+            ngx_log_error(NGX_LOG_ALERT, log, errno, "close() failed");
+            return NGX_ERROR;
+        }
+    }
+#endif
+
+    return NGX_OK;
+}
diff --git a/src/os/unix/ngx_freebsd_init.c b/src/os/unix/ngx_freebsd_init.c
new file mode 100644
index 0000000..a24fc41
--- /dev/null
+++ b/src/os/unix/ngx_freebsd_init.c
@@ -0,0 +1,67 @@
+
+#include <ngx_freebsd_init.h>
+
+
+int freebsd_kern_osreldate;
+int freebsd_hw_ncpu;
+
+int freebsd_sendfile_nbytes_bug;
+
+
+int ngx_os_init(ngx_log_t *log)
+{
+    size_t  size;
+
+    size = 4;
+    if (sysctlbyname("kern.osreldate",
+                     &freebsd_kern_osreldate, &size, NULL, 0) == -1) {
+        ngx_log_error(NGX_LOG_ALERT, log, errno,
+                      "sysctlbyname(kern.osreldate) failed");
+        return NGX_ERROR;
+    }
+
+    ngx_log_error(NGX_LOG_INFO, log, 0,
+                  "kern.osreldate: %d, built on %d",
+                  freebsd_kern_osreldate, __FreeBSD_version);
+
+
+#if HAVE_FREEBSD_SENDFILE
+
+    /* The determination of the sendfile() nbytes bug is complex enough.
+       There're two sendfile() syscalls: a new 393 has no bug while
+       an old 336 has the bug in some versions and has not in others.
+       libc_r wrapper also emulates the bug in some versions.
+       There's no way to say exactly if a given FreeBSD version has bug.
+       Here is the algorithm that work at least for RELEASEs
+       and for syscalls only (not libc_r wrapper). */
+
+    /* detect was the new sendfile() version available at the compile time
+       to allow an old binary to run correctly on an updated FreeBSD system. */
+
+#if (__FreeBSD__ == 4 && __FreeBSD_version >= 460102) \
+    || __FreeBSD_version == 460002 || __FreeBSD_version >= 500039
+
+    /* a new syscall without the bug */
+    freebsd_sendfile_nbytes_bug = 0;
+
+#else
+
+    /* an old syscall that can have the bug */
+    freebsd_sendfile_nbytes_bug = 1;
+
+#endif
+
+#endif /* HAVE_FREEBSD_SENDFILE */
+
+
+    size = 4;
+    if (sysctlbyname("hw.ncpu", &freebsd_hw_ncpu, &size, NULL, 0) == -1) {
+        ngx_log_error(NGX_LOG_ALERT, log, errno,
+                      "sysctlbyname(hw.ncpu) failed");
+        return NGX_ERROR;
+    }
+
+    ngx_log_error(NGX_LOG_INFO, log, 0, "hw.ncpu: %d", freebsd_hw_ncpu);
+
+    return NGX_OK;
+}
diff --git a/src/os/unix/ngx_freebsd_init.h b/src/os/unix/ngx_freebsd_init.h
new file mode 100644
index 0000000..d0af10b
--- /dev/null
+++ b/src/os/unix/ngx_freebsd_init.h
@@ -0,0 +1,18 @@
+#ifndef _NGX_OS_INIT_H_INCLUDED_
+#define _NGX_OS_INIT_H_INCLUDED_
+
+
+#include <ngx_config.h>
+#include <ngx_core.h>
+#include <ngx_log.h>
+#include <sys/sysctl.h>
+
+
+int ngx_os_init(ngx_log_t *log);
+
+
+extern int freebsd_kern_osreldate;
+extern int freebsd_hw_ncpu;
+
+
+#endif /* _NGX_OS_INIT_H_INCLUDED_ */
diff --git a/src/os/unix/ngx_freebsd_rfork_thread.c b/src/os/unix/ngx_freebsd_rfork_thread.c
index 6cbb078..88ceced 100644
--- a/src/os/unix/ngx_freebsd_rfork_thread.c
+++ b/src/os/unix/ngx_freebsd_rfork_thread.c
@@ -11,57 +11,76 @@
 
 typedef int  ngx_tid_t;
 
-#define NGX_MAX_THREADS  10
-
 
 static inline int ngx_gettid();
 
 
-static char        *stacks_start;
-static char        *stacks_end;
-static size_t       stack_size;
-static char        *last_stack;
-static int          last_thread;
-
-static ngx_log_t   *log;
-
-static ngx_tid_t    tids[NGX_MAX_THREADS];
-
+static char        *usrstack;
 static int          red_zone = 4096;
 
+static size_t       stack_size;
+static size_t       usable_stack_size;
+static char        *last_stack;
+
+static int          threads;
+static int          nthreads;
+static ngx_tid_t   *tids;
 
 /* the thread-safe errno */
 
-static int   errnos[NGX_MAX_THREADS];
+static int   errno0;   /* the main thread's errno */
+static int  *errnos;
 
 int *__error()
 {
-    return &errnos[ngx_gettid()];
+    int  tid;
+
+    tid = ngx_gettid();
+
+    return tid ? &errnos[tid - 1] : &errno0;
 }
 
 
-int ngx_create_thread(ngx_tid_t *tid, int (*func)(void *arg), void *arg)
+int ngx_create_thread(ngx_tid_t *tid, int (*func)(void *arg), void *arg,
+                      ngx_log_t *log)
 {
     int         id, err;
-    char       *stack_top;
+    char       *stack, *stack_top;
 
-    last_stack += stack_size;
-    stack_top = last_stack - red_zone;
-
-    if (stack_top > stacks_end) {
-        ngx_log_error(NGX_LOG_CRIT, log, 0, "no more threads allocated");
+    if (threads >= nthreads) {
+        ngx_log_error(NGX_LOG_CRIT, log, 0,
+                      "no more than %d threads can be created", nthreads);
         return NGX_ERROR;
     }
 
-#if 0
-    id = rfork(RFFDG|RFCFDG);
-#elif 0
-    id = rfork_thread(RFFDG|RFCFDG, stack_top, func, arg);
-#elif 0
-    id = rfork_thread(RFPROC|RFMEM, stack_top, func, arg);
-#else
+    last_stack -= stack_size;
+    stack = mmap(last_stack, usable_stack_size, PROT_READ|PROT_WRITE,
+                 MAP_STACK, -1, 0);
+    if (stack == MAP_FAILED) {
+        ngx_log_error(NGX_LOG_ALERT, log, errno,
+                      "mmap(%08X:%d, MAP_STACK) thread stack failed",
+                      last_stack, usable_stack_size);
+        return NGX_ERROR;
+    }
+
+    if (stack != last_stack) {
+        ngx_log_error(NGX_LOG_ALERT, log, 0, "stack address was changed");
+    }
+
+    stack_top = stack + usable_stack_size;
+
+printf("stack: %08X-%08X\n", stack, stack_top);
+
+#if 1
     id = rfork_thread(RFPROC|RFTHREAD|RFMEM, stack_top, func, arg);
+#elif 1
+    id = rfork_thread(RFPROC|RFMEM, stack_top, func, arg);
+#elif 1
+    id = rfork_thread(RFFDG|RFCFDG, stack_top, func, arg);
+#else
+    id = rfork(RFFDG|RFCFDG);
 #endif
+
     err = errno;
 
     if (id == -1) {
@@ -69,7 +88,8 @@
 
     } else {
         *tid = id;
-        tids[last_thread++] = id;
+        threads = (usrstack - stack_top) / stack_size;
+        tids[threads] = id;
 
         /* allow the spinlock in libc malloc() */
         __isthreaded = 1;
@@ -79,14 +99,12 @@
 }
 
 
-int ngx_init_thread_env(int n, size_t size, ngx_log_t *lg)
+int ngx_init_thread_env(int n, size_t size, ngx_log_t *log)
 {
-    int    len, i;
-    char  *usrstack, *zone;
+    int    len;
+    char  *rz, *zone;
 
-    log = lg;
-
-    /* create the thread stacks */
+    nthreads = n;
 
     len = 4;
     if (sysctlbyname("kern.usrstack", &usrstack, &len, NULL, 0) == -1) {
@@ -96,41 +114,37 @@
     }
 
 printf("usrstack: %08X\n", usrstack);
-printf("red zone: %08X\n", usrstack - (size + red_zone));
 
-#if 1
     /* red zone */
-    zone = mmap(usrstack - (size + red_zone), red_zone,
-                PROT_NONE, MAP_ANON, -1, 0);
+    rz = usrstack - (size + red_zone);
+
+printf("red zone: %08X\n", rz);
+
+    zone = mmap(rz, red_zone, PROT_NONE, MAP_ANON, -1, 0);
     if (zone == MAP_FAILED) {
         ngx_log_error(NGX_LOG_ALERT, log, errno,
-                      "mmap(%d, PROT_NONE, MAP_ANON) failed", red_zone);
+                      "mmap(%08X:%d, PROT_NONE, MAP_ANON) red zone failed",
+                      rz, red_zone);
         return NGX_ERROR;
     }
-#else
-    zone = usrstack - (size + red_zone);
-#endif
 
-    last_stack = zone + red_zone;
-
-    for (i = 0; i < n; i++) {
-        last_stack -= size + red_zone;
-printf("stack: %08X\n", last_stack);
-        last_stack = mmap(last_stack, size, PROT_READ|PROT_WRITE,
-                          MAP_STACK, -1, 0);
-        if (last_stack == MAP_FAILED) {
-            ngx_log_error(NGX_LOG_ALERT, log, errno,
-                          "mmap(%d, MAP_STACK) failed", size);
-            return NGX_ERROR;
-        }
+    if (zone != rz) {
+        ngx_log_error(NGX_LOG_ALERT, log, 0, "red zone address was changed");
     }
 
-    stacks_start = last_stack;
-    stack_size = size + red_zone;
-    stacks_end = stacks_start + n * stack_size;
+    /* create the thread errno array */
+    ngx_test_null(errnos, ngx_calloc(n * sizeof(int), log), NGX_ERROR);
+
+    /* create the thread tid array */
+    ngx_test_null(tids, ngx_calloc((n + 1) * sizeof(ngx_tid_t), log),
+                  NGX_ERROR);
 
     tids[0] = ngx_getpid();
-    last_thread = 1;
+    threads = 1;
+
+    last_stack = zone + red_zone;
+    usable_stack_size = size;
+    stack_size = size + red_zone;
 
     return NGX_OK;
 }
@@ -138,7 +152,18 @@
 
 ngx_tid_t ngx_thread_self()
 {
-    return tids[ngx_gettid()];
+    int        tid;
+    ngx_tid_t  pid;
+
+    tid = ngx_gettid();
+
+    if (tids[tid] == 0) {
+        pid = ngx_getpid();
+        tids[tid] = pid;
+        return pid;
+    }
+
+    return tids[tid];
 }
 
 
@@ -146,7 +171,11 @@
 {   
     char  *sp;
 
+    if (stack_size == 0) {
+        return 0;
+    }
+
     __asm__ ("mov %%esp, %0" : "=q" (sp));
 
-    return (sp > stacks_end) ? 0 : ((sp - stacks_start) / stack_size  + 1);
+    return (usrstack - sp) / stack_size;
 }
diff --git a/src/os/unix/ngx_init.c b/src/os/unix/ngx_init.c
new file mode 100644
index 0000000..28af128
--- /dev/null
+++ b/src/os/unix/ngx_init.c
@@ -0,0 +1,20 @@
+
+
+int ngx_unix_init(ngx_log_t *log)
+{
+    struct rlimit  rlmt;
+
+    if (getrlimit(RLIMIT_NOFILE, &rlmt) == -1) {
+        ngx_log_error(NGX_LOG_ALERT, log, errno,
+                      "getrlimit(RLIMIT_NOFILE) failed)");
+        return NGX_ERROR;
+    }
+
+    ngx_log_error(NGX_LOG_INFO, log, 0,
+                  "getrlimit(RLIMIT_NOFILE): %d", rlmt.rlim_cur);
+
+    RLIM_INFINITY
+    max_connections =< rlmt.rlim_cur;
+
+    return NGX_OK;
+}