s6-linux-init-1.0.3.1/0002755000000000000000000000000013553343654011203 5ustar s6-linux-init-1.0.3.1/skel/0002755000000000000000000000000013526504222012127 5ustar s6-linux-init-1.0.3.1/skel/rc.init0000755000000000000000000000235013466352025013426 0ustar #!/bin/sh -e rl="$1" shift ### argv now contains the arguments of the kernel command line that are ### not of the form key=value. (The key=value arguments were stored by ### s6-linux-init into an envdir, if instructed so via the -s option.) ### Normally this argv remains unused because programs that need the ### kernel command line usually read it later on from /proc/cmdline - ### but just in case, it's available here. ### 1. Early preparation ### This is done only once at boot time. ### Ideally, this phase should just initialize the service manager. ### If your services are managed by sysv-rc: # /etc/init.d/rcS ### If your services are managed by OpenRC: # /sbin/openrc sysinit # /sbin/openrc boot ### If your services are managed by s6-rc: ### (replace /run/service with your scandir) # s6-rc-init /run/service ### 2. Starting the wanted set of services ### This is also called every time you change runlevels with telinit. ### (edit the location to suit your installation) ### By default, $rl is the string "default", unless you changed it ### via the -D option to s6-linux-init-maker. ### Numeric arguments from 1 to 5 on the kernel command line will ### override the default. # exec /etc/s6-linux-init/current/scripts/runlevel "$rl" s6-linux-init-1.0.3.1/skel/rc.shutdown.final0000755000000000000000000000137213526505022015423 0ustar #!/bin/sh -e ### Things to do *right before* the machine gets rebooted or ### powered off, at the very end of the shutdown sequence, ### when all the filesystems are unmounted. ### This is a last resort hook; normally nothing should be ### done here (your rc.shutdown script should have taken care ### of everything) and you should leave this script empty. ### Some distributions, however, may need to perform some ### actions after unmounting the filesystems: typically if ### an additional teardown action is required on a filesystem ### after unmounting it, or if the system needs to be ### pivot_rooted before it can be shut down, etc. ### Those are all exceptional cases. If you don't know for ### certain that you need to do something here, you don't. s6-linux-init-1.0.3.1/skel/rc.shutdown0000755000000000000000000000141413470532274014337 0ustar #!/bin/sh -e ### Things to do before hardware halt/reboot/poweroff. ### Ideally, it should be a single call to the service manager, ### telling it to bring all the services down. ### If your services are managed by sysv-rc: ### also remove the K11reboot link from /etc/rc6.d to prevent ### sysv-rc from rebooting prematurely - because sysvinit does ### not properly separate state changes from system init/shutdown. # exec /etc/init.d/rc 6 ### If your services are managed by OpenRC: ### also remove the "killprocs" and "mount-ro" symlinks from ### /etc/runlevels/shutdown - because OpenRC does not properly ### separate the service manager from the shutdown manager either. # exec /sbin/openrc shutdown ### If your services are managed by s6-rc: # exec s6-rc -v2 -bda change s6-linux-init-1.0.3.1/skel/runlevel0000755000000000000000000000105213470516373013715 0ustar #!/bin/sh -e ### This script is called once at boot time by rc.init, and is ### also called by the runleveld service every time the user ### requests a machine state change via telinit. ### Ideally, it should just be a call to the service manager. test "$#" -gt 0 || { echo 'runlevel: fatal: too few arguments' 1>&2 ; exit 100 ; } ### If your services are managed by sysv-rc: # exec /etc/init.d/rc "$1" ### If your services are managed by OpenRC: # exec /sbin/openrc "$1" ### If your services are managed by s6-rc: # exec s6-rc -v2 -up change "$1" s6-linux-init-1.0.3.1/AUTHORS0000644000000000000000000000042313514077227012245 0ustar Main author: Laurent Bercot Thanks to: Colin Booth multiplexd Luis Ressel Samuel Holland Max Rees Guillermo s6-linux-init-1.0.3.1/INSTALL0000644000000000000000000001524713553361060012232 0ustar Build Instructions ------------------ * Requirements ------------ - A Linux-based system with a standard C development environment - GNU make version 3.81 or later - skalibs version 2.9.1.0 or later: https://skarnet.org/software/skalibs/ - execline version 2.5.3.0 or later: https://skarnet.org/software/execline/ - s6 version 2.9.0.1 or later: https://skarnet.org/software/s6/ - Optional: nsss version 0.0.2.1 or later: https://skarnet.org/software/nsss/ - Optional: utmps version 0.0.3.1 or later: https://skarnet.org/software/utmps/ This software is Linux-specific. It will run on a Linux kernel, version 2.6.32 or later. However, it should not be too hard to port to other Unix-like operating systems. * Standard usage -------------- ./configure && make && sudo make install will work for most users. It will install the exported binaries in /bin, the unexported binaries in /libexec, and the skeleton scripts in /etc/s6-linux-init/skel. You can strip the binaries and libraries of their extra symbols via "make strip" before the "make install" phase. It will shave a few bytes off them. Your default init binaries will not be overwritten. They will only be overwritten by a manual action after you invoke s6-linux-init-maker, check that you are happy with its output, and decide to use it as your default init. * Customization ------------- You can customize paths via flags given to configure. See ./configure --help for a list of all available configure options. * Environment variables --------------------- Controlling a build process via environment variables is a big and dangerous hammer. You should try and pass flags to configure instead; nevertheless, a few standard environment variables are recognized. If the CC environment variable is set, its value will override compiler detection by configure. The --host=HOST option will still add a HOST- prefix to the value of CC. The values of CFLAGS, CPPFLAGS and LDFLAGS will be appended to flags auto-detected by configure. To entirely override the flags set by configure instead, use make variables. * Make variables -------------- You can invoke make with a few variables for more configuration. CC, CFLAGS, CPPFLAGS, LDFLAGS, LDLIBS, AR, RANLIB, STRIP, INSTALL and CROSS_COMPILE can all be overridden on the make command line. This is an even bigger hammer than running ./configure with environment variables, so it is advised to only do this when it is the only way of obtaining the behaviour you want. DESTDIR can be given on the "make install" command line in order to install to a staging directory. * Shared libraries ---------------- Software from skarnet.org is small enough that shared libraries are generally not worth using. Static linking is simpler and incurs less runtime overhead and less points of failure: so by default, shared libraries are not built and binaries are linked against the static versions of the skarnet.org libraries. Nevertheless, you can: * build shared libraries: --enable-shared * link binaries against shared libraries: --disable-allstatic * Static binaries --------------- By default, binaries are linked against static versions of all the libraries they depend on, except for the libc. You can enforce linking against the static libc with --enable-static-libc. (If you are using a GNU/Linux system, be aware that the GNU libc behaves badly with static linking and produces huge executables, which is why it is not the default. Other libcs are better suited to static linking, for instance musl: http://musl-libc.org/) * Cross-compilation ----------------- skarnet.org packages centralize all the difficulty of cross-compilation in one place: skalibs. Once you have cross-compiled skalibs, the rest is easy. * Use the --host=HOST option to configure, HOST being the triplet for your target. * Make sure your cross-toolchain binaries (i.e. prefixed with HOST-) are accessible via your PATH environment variable. * Make sure to use the correct version of skalibs for your target, and the correct sysdeps directory, making use of the --with-include, --with-lib, --with-dynlib and --with-sysdeps options as necessary. * The slashpackage convention --------------------------- The slashpackage convention (http://cr.yp.to/slashpackage.html) is a package installation scheme that provides a few guarantees over other conventions such as the FHS, for instance fixed absolute pathnames. skarnet.org packages support it: use the --enable-slashpackage option to configure, or --enable-slashpackage=DIR for a prefixed DIR/package tree. This option will activate slashpackage support during the build and set slashpackage-compatible installation directories. If $package_home is the home of the package, defined as DIR/package/$category/$package-$version with the variables read from the package/info file, then: --dynlibdir is set to $package_home/library.so --bindir is set to $package_home/command --sbindir is also set to $package_home/command (slashpackage differentiates root-only binaries by their Unix rights, not their location in the filesystem) --libexecdir is also set to $package_home/command (slashpackage does not need a specific directory for internal binaries) --libdir is set to $package_home/library --includedir is set to $package_home/include --prefix is pretty much ignored when you use --enable-slashpackage. You should probably not use both --enable-slashpackage and --prefix. When using slashpackage, two additional Makefile targets are available after "make install": - "make update" changes the default version of the software to the freshly installed one. (This is useful when you have several installed versions of the same software, which slashpackage supports.) - "make -L global-links" adds links from /command and /library.so to the default version of the binaries and shared libraries. The "-L" option to make is necessary because targets are symbolic links, and the default make behaviour is to check the pointed file's timestamp and not the symlink's timestamp. * Absolute pathnames ------------------ You may want to use fixed absolute pathnames even if you're not following the slashpackage convention: for instance, the Nix packaging system prefers calling binaries with immutable paths rather than rely on PATH resolution. If you are in that case, use the --enable-absolute-paths option to configure. This will ensure that programs calling binaries from this package will call them with their full installation path (in bindir) without relying on a PATH search. * Out-of-tree builds ------------------ skarnet.org packages do not support out-of-tree builds. They are small, so it does not cost much to duplicate the entire source tree if parallel builds are needed. s6-linux-init-1.0.3.1/README0000644000000000000000000000107113553367227012062 0ustar s6-linux-init - tools to create an s6-based Linux init system ------------------------------------------------------------- s6-linux-init is a suite of tools designed to provide an init program for the Linux kernel - i.e., the first program run at boot time. See https://skarnet.org/software/s6-linux-init/ for details. * Installation ------------ See the INSTALL file. * Contact information ------------------- Laurent Bercot Please use the mailing-list for questions about s6-linux-init. s6-linux-init-1.0.3.1/src/0000755000000000000000000000000013463713373011767 5ustar s6-linux-init-1.0.3.1/src/shutdown/0000755000000000000000000000000013541665243013641 5ustar s6-linux-init-1.0.3.1/src/shutdown/s6-linux-init-hpr.c0000644000000000000000000000524013534441045017215 0ustar /* ISC license. */ #include #include #include #include #include #include #include #include #include #include #include #include "defaults.h" #include "hpr.h" #ifndef UT_NAMESIZE #define UT_NAMESIZE 32 #endif #ifndef UT_HOSTSIZE #define UT_HOSTSIZE 256 #endif #ifndef _PATH_WTMP #define _PATH_WTMP "/dev/null/wtmp" #endif #define USAGE "s6-linux-init-hpr [ -h | -p | -r ] [ -d | -w ] [ -W ] [ -f ]" int main (int argc, char const *const *argv) { int what = 0 ; int force = 0 ; int dowtmp = 1 ; int dowall = 1 ; PROG = "s6-linux-init-hpr" ; { subgetopt_t l = SUBGETOPT_ZERO ; for (;;) { int opt = subgetopt_r(argc, argv, "hprfdwW", &l) ; if (opt == -1) break ; switch (opt) { case 'h' : what = 1 ; break ; case 'p' : what = 2 ; break ; case 'r' : what = 3 ; break ; case 'f' : force = 1 ; break ; case 'd' : dowtmp = 0 ; break ; case 'w' : dowtmp = 2 ; break ; case 'W' : dowall = 0 ; break ; default : strerr_dieusage(100, USAGE) ; } } argc -= l.ind ; argv += l.ind ; } if (!what) strerr_dief1x(100, "one of the -h, -p or -r options must be given") ; if (geteuid()) { errno = EPERM ; strerr_dief1sys(100, "nice try, peon") ; } if (force) { sync() ; reboot(what == 3 ? RB_AUTOBOOT : what == 2 ? RB_POWER_OFF : RB_HALT_SYSTEM) ; strerr_diefu1sys(111, "reboot()") ; } if (!tain_now_g()) strerr_warnw1sys("get current time") ; if (dowtmp) { struct utmpx utx = { .ut_type = RUN_LVL, .ut_pid = getpid(), .ut_line = "~", .ut_id = "", .ut_session = getsid(0) } ; strncpy(utx.ut_user, what == 3 ? "reboot" : "shutdown", UT_NAMESIZE) ; if (gethostname(utx.ut_host, UT_HOSTSIZE) < 0) { utx.ut_host[0] = 0 ; strerr_warnwu1sys("gethostname") ; } else utx.ut_host[UT_HOSTSIZE - 1] = 0 ; /* glibc multilib can go fuck itself */ #ifdef __WORDSIZE_TIME64_COMPAT32 { struct timeval tv ; if (!timeval_from_tain(&tv, &STAMP)) strerr_warnwu1sys("timeval_from_tain") ; utx.ut_tv.tv_sec = tv.tv_sec ; utx.ut_tv.tv_usec = tv.tv_usec ; } #else if (!timeval_from_tain(&utx.ut_tv, &STAMP)) strerr_warnwu1sys("timeval_from_tain") ; #endif updwtmpx(_PATH_WTMP, &utx) ; } if (dowall) hpr_wall(HPR_WALL_BANNER) ; if (dowtmp < 2) { if (!hpr_shutdown(what, &tain_zero, 0)) strerr_diefu1sys(111, "notify s6-linux-init-shutdownd") ; } return 0 ; } s6-linux-init-1.0.3.1/src/shutdown/deps-exe/0000755000000000000000000000000013540723124015343 5ustar s6-linux-init-1.0.3.1/src/shutdown/deps-exe/s6-linux-init-hpr0000644000000000000000000000010313540723124020475 0ustar libhpr.a.xyzzy ${LIBUTMPS} -lskarnet ${SYSCLOCK_LIB} ${SOCKET_LIB} s6-linux-init-1.0.3.1/src/shutdown/deps-exe/s6-linux-init-shutdown0000644000000000000000000000010313540723124021557 0ustar libhpr.a.xyzzy ${LIBUTMPS} -lskarnet ${SYSCLOCK_LIB} ${SOCKET_LIB} s6-linux-init-1.0.3.1/src/shutdown/deps-exe/s6-linux-init-shutdownd0000644000000000000000000000007113540723124021727 0ustar -ls6 ${LIBUTMPS} -lskarnet ${SYSCLOCK_LIB} ${SOCKET_LIB} s6-linux-init-1.0.3.1/src/shutdown/hpr_shutdown.c0000644000000000000000000000056213463713373016535 0ustar /* ISC license. */ #include #include #include #include "hpr.h" int hpr_shutdown (unsigned int what, tain_t const *when, unsigned int grace) { char pack[5 + TAIN_PACK] = { "Shpr"[what] } ; tain_pack(pack+1, when) ; uint32_pack_big(pack + 1 + TAIN_PACK, (uint32_t)grace) ; return hpr_send(pack, 5 + TAIN_PACK) ; } s6-linux-init-1.0.3.1/src/shutdown/s6-linux-init-shutdown.c0000644000000000000000000001527713534515205020312 0ustar /* ISC license. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "defaults.h" #include "initctl.h" #include "hpr.h" #ifndef UT_NAMESIZE #define UT_NAMESIZE 32 #endif #define USAGE "s6-linux-init-shutdown [ -h [ -H | -P ] | -p | -r | -k ] [ -f | -F ] [ -a ] [ -t sec ] time [ message ] or s6-linux-init-shutdown -c [ message ]" #define dieusage() strerr_dieusage(100, USAGE) #define AC_FILE "/etc/shutdown.allow" #define AC_BUFSIZE 4096 #define AC_MAX 64 /* shutdown 01:23: date/time format parsing */ static inline void add_one_day (struct tm *tm) { tm->tm_isdst = -1 ; if (tm->tm_mday++ < 31) return ; tm->tm_mday = 1 ; if (tm->tm_mon++ < 11) return ; tm->tm_mon = 0 ; tm->tm_year++ ; } static inline void parse_hourmin (tain_t *when, char const *s) { tai_t taithen ; struct tm tmthen ; unsigned int hour, minute ; size_t len = uint_scan(s, &hour) ; if (!len || len > 2 || s[len] != ':' || hour > 23) strerr_dief1x(100, "invalid time format") ; s += len+1 ; len = uint0_scan(s, &minute) ; if (!len || len != 2 || minute > 59) strerr_dief1x(100, "invalid time format") ; if (!localtm_from_tai(&tmthen, tain_secp(&STAMP), 1)) strerr_diefu1sys(111, "break down current time into struct tm") ; tmthen.tm_hour = hour ; tmthen.tm_min = minute ; tmthen.tm_sec = 0 ; if (!tai_from_localtm(&taithen, &tmthen)) strerr_diefu1sys(111, "assemble broken-down time into tain_t") ; if (tai_less(&taithen, tain_secp(&STAMP))) { add_one_day(&tmthen) ; if (!tai_from_localtm(&taithen, &tmthen)) strerr_diefu1sys(111, "assemble broken-down time into tain_t") ; } when->sec = taithen ; when->nano = 0 ; } static void parse_mins (tain_t *when, char const *s) { unsigned int mins ; if (!uint0_scan(s, &mins)) dieusage() ; tain_addsec_g(when, mins * 60) ; } static inline void parse_time (tain_t *when, char const *s) { if (!strcmp(s, "now")) tain_copynow(when) ; else if (s[0] == '+') parse_mins(when, s+1) ; else if (strchr(s, ':')) parse_hourmin(when, s) ; else parse_mins(when, s) ; } /* shutdown -a: access control */ static inline unsigned char cclass (unsigned char c) { switch (c) { case 0 : return 0 ; case '\n' : return 1 ; case '#' : return 2 ; default : return 3 ; } } static inline unsigned int parse_authorized_users (char *buf, char const **users, unsigned int max) { static unsigned char const table[3][4] = { { 0x03, 0x00, 0x01, 0x12 }, { 0x03, 0x00, 0x01, 0x01 }, { 0x23, 0x20, 0x02, 0x02 } } ; size_t pos = 0 ; size_t mark = 0 ; unsigned int n = 0 ; unsigned int state = 0 ; for (; state < 3 ; pos++) { unsigned char what = table[state][cclass(buf[pos])] ; state = what & 3 ; if (what & 0x10) mark = pos ; if (what & 0x20) { if (n >= max) { char fmt[UINT32_FMT] ; fmt[uint32_fmt(fmt, AC_MAX)] = 0 ; strerr_warnw4x(AC_FILE, " lists more than ", fmt, " authorized users - ignoring the extra ones") ; break ; } buf[pos] = 0 ; users[n++] = buf + mark ; } } return n ; } static inline int match_users_with_utmp (char const *const *users, unsigned int n) { setutxent() ; for (;;) { struct utmpx *utx ; errno = 0 ; utx = getutxent() ; if (!utx) break ; if (utx->ut_type != USER_PROCESS) continue ; for (unsigned int i = 0 ; i < n ; i++) if (!strncmp(utx->ut_user, users[i], UT_NAMESIZE)) goto yes ; } endutxent() ; return 0 ; yes: endutxent() ; return 1 ; } static inline void access_control (void) { char buf[AC_BUFSIZE] ; char const *users[AC_MAX] ; unsigned int n ; struct stat st ; int fd = open_readb(AC_FILE) ; if (fd == -1) { if (errno == ENOENT) return ; strerr_diefu2sys(111, "open ", AC_FILE) ; } if (fstat(fd, &st) == -1) strerr_diefu2sys(111, "stat ", AC_FILE) ; if (st.st_size >= AC_BUFSIZE) { char fmt[UINT32_FMT] ; fmt[uint32_fmt(fmt, AC_BUFSIZE - 1)] = 0 ; strerr_dief4x(1, AC_FILE, " is too big: it needs to be ", fmt, " bytes or less") ; } if (allread(fd, buf, st.st_size) < st.st_size) strerr_diefu2sys(111, "read ", AC_FILE) ; fd_close(fd) ; buf[st.st_size] = 0 ; n = parse_authorized_users(buf, users, AC_MAX) ; if (!n || !match_users_with_utmp(users, n)) strerr_dief1x(1, "no authorized users logged in") ; } /* main */ int main (int argc, char const *const *argv) { unsigned int gracetime = 0 ; int what = 0 ; int subwhat = 0 ; int doactl = 0 ; int docancel = 0 ; tain_t when ; PROG = "s6-linux-init-shutdown" ; { subgetopt_t l = SUBGETOPT_ZERO ; for (;;) { int opt = subgetopt_r(argc, argv, "HPhprkafFct:", &l) ; if (opt == -1) break ; switch (opt) { case 'H' : subwhat = 1 ; break ; case 'P' : subwhat = 2 ; break ; case 'h' : what = 1 ; break ; case 'p' : what = 2 ; break ; case 'r' : what = 3 ; break ; case 'k' : what = 4 ; break ; case 'a' : doactl = 1 ; break ; case 'f' : /* talk to the hand */ break ; case 'F' : /* no, the other hand */ break ; case 'c' : docancel = 1 ; break ; case 't' : if (!uint0_scan(l.arg, &gracetime)) dieusage() ; break ; default : strerr_dieusage(100, USAGE) ; } } argc -= l.ind ; argv += l.ind ; } if (subwhat) { if (what == 1) what = subwhat ; else strerr_dieusage(100, USAGE) ; } if (geteuid()) { errno = EPERM ; strerr_diefu1sys(111, "shutdown") ; } if (doactl) access_control() ; if (!tain_now_g()) strerr_warnw1sys("get current time") ; if (docancel) { if (argv[0]) hpr_wall(argv[0]) ; if (!hpr_cancel()) goto err ; return 0 ; } if (!argc) dieusage() ; parse_time(&when, argv[0]) ; tain_sub(&when, &when, &STAMP) ; if (argv[1]) { size_t len = strlen(argv[1]) ; char msg[sizeof(HPR_WALL_BANNER) + 1 + len] ; memcpy(msg, HPR_WALL_BANNER, sizeof(HPR_WALL_BANNER) - 1) ; msg[sizeof(HPR_WALL_BANNER) - 1] = '\n' ; memcpy(msg + sizeof(HPR_WALL_BANNER), argv[1], len + 1) ; hpr_wall(msg) ; } if (what < 4) { if (gracetime > 300) { gracetime = 300 ; strerr_warnw1x("delay between SIGTERM and SIGKILL is capped to 300 seconds") ; } if (!hpr_shutdown(what, &when, gracetime * 1000)) goto err ; } return 0 ; err: strerr_diefu2sys(111, "write to ", INITCTL) ; } s6-linux-init-1.0.3.1/src/shutdown/hpr.h0000644000000000000000000000067513463713373014614 0ustar /* ISC license. */ #ifndef HPR_H #define HPR_H #include #include #include #include "initctl.h" #define HPR_WALL_BANNER "\n\n*** WARNING ***\nThe system is going down NOW!\n" #define hpr_send(s, n) openwritenclose_unsafe(INITCTL, (s), n) #define hpr_cancel() hpr_send("c", 1) extern int hpr_shutdown (unsigned int, tain_t const *, unsigned int) ; extern void hpr_wall (char const *) ; #endif s6-linux-init-1.0.3.1/src/shutdown/hpr_wall.c0000644000000000000000000000150313463713373015615 0ustar /* ISC license. */ #include #include #include #include #include #include #include "hpr.h" #ifndef UT_LINESIZE #define UT_LINESIZE 32 #endif void hpr_wall (char const *s) { size_t n = strlen(s) ; char tty[10 + UT_LINESIZE] = "/dev/" ; char msg[n+1] ; memcpy(msg, s, n) ; msg[n++] = '\n' ; setutxent() ; for (;;) { size_t linelen ; int fd ; struct utmpx *utx = getutxent() ; if (!utx) break ; if (utx->ut_type != USER_PROCESS) continue ; linelen = strnlen(utx->ut_line, UT_LINESIZE) ; memcpy(tty + 5, utx->ut_line, linelen) ; tty[5 + linelen] = 0 ; fd = open_append(tty) ; if (fd == -1) continue ; allwrite(fd, msg, n) ; fd_close(fd) ; } endutxent() ; } s6-linux-init-1.0.3.1/src/shutdown/s6-linux-init-shutdownd.c0000644000000000000000000002155513534441145020453 0ustar /* ISC license. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "defaults.h" #include "initctl.h" #include "hpr.h" #define STAGE4_FILE "stage 4" #define SCANPREFIX S6_LINUX_INIT_TMPFS "/" SCANDIR "/" #define SCANPREFIXLEN (sizeof(SCANPREFIX) - 1) #define DOTPREFIX ".s6-linux-init-shutdownd:" #define DOTPREFIXLEN (sizeof(DOTPREFIX) - 1) #define DOTSUFFIX ":XXXXXX" #define DOTSUFFIXLEN (sizeof(DOTSUFFIX) - 1) #define USAGE "s6-linux-init-shutdownd [ -c basedir ] [ -g gracetime ]" #define dieusage() strerr_dieusage(100, USAGE) static char const *basedir = BASEDIR ; struct at_s { int fd ; char const *name ; } ; static int renametemp (char const *s, mode_t mode, void *data) { struct at_s *at = data ; (void)mode ; return renameat(at->fd, at->name, at->fd, s) ; } static int mkrenametemp (int fd, char const *src, char *dst) { struct at_s at = { .fd = fd, .name = src } ; return mkfiletemp(dst, &renametemp, 0700, &at) ; } static inline void run_stage3 (char const *basedir, char const *const *envp) { pid_t pid ; size_t basedirlen = strlen(basedir) ; char stage3[basedirlen + sizeof("/scripts/" STAGE3)] ; char const *stage3_argv[2] = { stage3, 0 } ; memcpy(stage3, basedir, basedirlen) ; memcpy(stage3 + basedirlen, "/scripts/" STAGE3, sizeof("/scripts/" STAGE3)) ; pid = child_spawn0(stage3_argv[0], stage3_argv, envp) ; if (pid) { int wstat ; if (wait_pid(pid, &wstat) == -1) strerr_diefu1sys(111, "waitpid") ; if (WIFSIGNALED(wstat)) { char fmt[UINT_FMT] ; fmt[uint_fmt(fmt, WTERMSIG(wstat))] = 0 ; strerr_warnw3x(stage3, " was killed by signal ", fmt) ; } else if (WEXITSTATUS(wstat)) { char fmt[UINT_FMT] ; fmt[uint_fmt(fmt, WEXITSTATUS(wstat))] = 0 ; strerr_warnw3x(stage3, " exited ", fmt) ; } } else strerr_warnwu2sys("spawn ", stage3) ; } static inline void prepare_shutdown (buffer *b, tain_t *deadline, unsigned int *grace_time) { uint32_t u ; char pack[TAIN_PACK + 4] ; ssize_t r = sanitize_read(buffer_get(b, pack, TAIN_PACK + 4)) ; if (r == -1) strerr_diefu1sys(111, "read from pipe") ; if (r < TAIN_PACK + 4) strerr_dief1x(101, "bad shutdown protocol") ; tain_unpack(pack, deadline) ; tain_add_g(deadline, deadline) ; uint32_unpack_big(pack + TAIN_PACK, &u) ; if (u && u <= 300000) *grace_time = u ; } static inline void handle_fifo (buffer *b, char *what, tain_t *deadline, unsigned int *grace_time) { for (;;) { char c ; ssize_t r = sanitize_read(buffer_get(b, &c, 1)) ; if (r == -1) strerr_diefu1sys(111, "read from pipe") ; else if (!r) break ; switch (c) { case 'S' : case 'h' : case 'p' : case 'r' : *what = c ; prepare_shutdown(b, deadline, grace_time) ; break ; case 'c' : *what = 'S' ; tain_add_g(deadline, &tain_infinite_relative) ; break ; default : { char s[2] = { c, 0 } ; strerr_warnw2x("unknown command: ", s) ; } break ; } } } static inline void prepare_stage4 (char const *basedir, char what) { buffer b ; int fd ; char buf[512] ; size_t sabase = satmp.len ; unlink_void(STAGE4_FILE ".new") ; fd = open_excl(STAGE4_FILE ".new") ; if (fd == -1) strerr_diefu3sys(111, "open ", STAGE4_FILE ".new", " for writing") ; buffer_init(&b, &buffer_write, fd, buf, 512) ; if (buffer_puts(&b, "#!" EXECLINE_SHEBANGPREFIX "execlineb -P\n\n" EXECLINE_EXTBINPREFIX "foreground { " S6_LINUX_INIT_BINPREFIX "s6-linux-init-umountall }\n" EXECLINE_EXTBINPREFIX "foreground { ") < 0 || !string_quote(&satmp, basedir, strlen(basedir)) || buffer_put(&b, satmp.s + sabase, satmp.len - sabase) < 0 || buffer_puts(&b, "/scripts/" STAGE4 " }\n" S6_LINUX_INIT_BINPREFIX "s6-linux-init-hpr -f -") < 0 || buffer_put(&b, &what, 1) < 0 || buffer_putsflush(&b, "\n") < 0) strerr_diefu2sys(111, "write to ", STAGE4_FILE ".new") ; satmp.len = sabase ; if (fchmod(fd, S_IRWXU) == -1) strerr_diefu2sys(111, "fchmod ", STAGE4_FILE ".new") ; fd_close(fd) ; if (rename(STAGE4_FILE ".new", STAGE4_FILE) == -1) strerr_diefu4sys(111, "rename ", STAGE4_FILE ".new", " to ", STAGE4_FILE) ; } static inline void unsupervise_tree (void) { static char const *except[] = { LOGGER_SERVICEDIR, SHUTDOWND_SERVICEDIR, /* EARLYGETTY_SERVICEDIR, */ 0 } ; DIR *dir = opendir(S6_LINUX_INIT_TMPFS "/" SCANDIR) ; int fdd ; if (!dir) strerr_diefu1sys(111, "opendir " S6_LINUX_INIT_TMPFS "/" SCANDIR) ; fdd = dirfd(dir) ; if (fdd == -1) strerr_diefu1sys(111, "dir_fd " S6_LINUX_INIT_TMPFS "/" SCANDIR) ; for (;;) { char const *const *p = except ; direntry *d ; errno = 0 ; d = readdir(dir) ; if (!d) break ; if (d->d_name[0] == '.') continue ; for (; *p ; p++) if (!strcmp(*p, d->d_name)) break ; if (!*p) { size_t dlen = strlen(d->d_name) ; char fn[SCANPREFIXLEN + DOTPREFIXLEN + dlen + DOTSUFFIXLEN + 1] ; memcpy(fn, SCANPREFIX DOTPREFIX, SCANPREFIXLEN + DOTPREFIXLEN) ; memcpy(fn + SCANPREFIXLEN + DOTPREFIXLEN, d->d_name, dlen) ; memcpy(fn + SCANPREFIXLEN + DOTPREFIXLEN + dlen, DOTSUFFIX, DOTSUFFIXLEN + 1) ; if (mkrenametemp(fdd, d->d_name, fn + SCANPREFIXLEN) == -1) { strerr_warnwu4sys("rename " SCANPREFIX, d->d_name, " to something based on ", fn) ; unlinkat(fdd, d->d_name, 0) ; /* if it still fails, too bad, it will restart in stage 4 and race */ } else s6_svc_writectl(fn, S6_SUPERVISE_CTLDIR, "dx", 2) ; } } if (errno) strerr_diefu1sys(111, "readdir " S6_LINUX_INIT_TMPFS "/" SCANDIR) ; dir_close(dir) ; } int main (int argc, char const *const *argv, char const *const *envp) { char what = 'S' ; unsigned int grace_time = 3000 ; tain_t deadline ; int fdr, fdw ; buffer b ; char buf[64] ; PROG = "s6-linux-init-shutdownd" ; { subgetopt_t l = SUBGETOPT_ZERO ; for (;;) { int opt = subgetopt_r(argc, argv, "c:g:", &l) ; if (opt == -1) break ; switch (opt) { case 'c' : basedir = l.arg ; break ; case 'g' : if (!uint0_scan(l.arg, &grace_time)) dieusage() ; break ; default : dieusage() ; } } argc -= l.ind ; argv += l.ind ; } if (basedir[0] != '/') strerr_dief2x(100, "basedir", " must be an absolute path") ; if (grace_time > 300000) grace_time = 300000 ; /* if we're in stage 4, exec it immediately */ { char const *stage4_argv[2] = { "./" STAGE4_FILE, 0 } ; execve(stage4_argv[0], (char **)stage4_argv, (char *const *)envp) ; if (errno != ENOENT) strerr_warnwu2sys("exec ", stage4_argv[0]) ; } fdr = open_read(SHUTDOWND_FIFO) ; if (fdr == -1 || coe(fdr) == -1) strerr_diefu3sys(111, "open ", SHUTDOWND_FIFO, " for reading") ; fdw = open_write(SHUTDOWND_FIFO) ; if (fdw == -1 || coe(fdw) == -1) strerr_diefu3sys(111, "open ", SHUTDOWND_FIFO, " for writing") ; if (sig_ignore(SIGPIPE) == -1) strerr_diefu1sys(111, "sig_ignore SIGPIPE") ; buffer_init(&b, &buffer_read, fdr, buf, 64) ; tain_now_set_stopwatch_g() ; tain_add_g(&deadline, &tain_infinite_relative) ; for (;;) { iopause_fd x = { .fd = fdr, .events = IOPAUSE_READ } ; int r = iopause_g(&x, 1, &deadline) ; if (r == -1) strerr_diefu1sys(111, "iopause") ; if (!r) { run_stage3(basedir, envp) ; tain_now_g() ; if (what != 'S') break ; tain_add_g(&deadline, &tain_infinite_relative) ; continue ; } if (x.revents & IOPAUSE_READ) handle_fifo(&b, &what, &deadline, &grace_time) ; } fd_close(fdw) ; fd_close(fdr) ; fd_close(1) ; if (open("/dev/console", O_WRONLY) != 1) strerr_diefu1sys(111, "open /dev/console for writing") ; if (fd_copy(2, 1) == -1) strerr_warnwu1sys("fd_copy") ; /* The end is coming! */ prepare_stage4(basedir, what) ; unsupervise_tree() ; sync() ; if (sig_ignore(SIGTERM) == -1) strerr_warnwu1sys("sig_ignore SIGTERM") ; strerr_warni1x("sending all processes the TERM signal...") ; kill(-1, SIGTERM) ; kill(-1, SIGCONT) ; tain_from_millisecs(&deadline, grace_time) ; tain_now_g() ; tain_add_g(&deadline, &deadline) ; deepsleepuntil_g(&deadline) ; sync() ; strerr_warni1x("sending all processes the KILL signal...") ; kill(-1, SIGKILL) ; return 0 ; } s6-linux-init-1.0.3.1/src/shutdown/deps-lib/0000755000000000000000000000000013463713373015341 5ustar s6-linux-init-1.0.3.1/src/shutdown/deps-lib/hpr0000644000000000000000000000003213463713373016050 0ustar hpr_shutdown.o hpr_wall.o s6-linux-init-1.0.3.1/src/misc/0000755000000000000000000000000013541665243012721 5ustar s6-linux-init-1.0.3.1/src/misc/s6-linux-init-logouthookd.c0000644000000000000000000000271613463713373020056 0ustar /* ISC license. */ #include #ifndef SKALIBS_HASSOPEERCRED #error "The SO_PEERCRED option to getsockopt() is required." #endif #include #include #include #include #include #include #include #include #include #ifndef UT_NAMESIZE #define UT_NAMESIZE 32 #endif #ifndef UT_HOSTSIZE #define UT_HOSTSIZE 256 #endif int main (void) { struct utmpx *utx ; struct ucred client ; socklen_t len = sizeof(client) ; ssize_t r ; char c ; close(1) ; if (getsockopt(0, SOL_SOCKET, SO_PEERCRED, &client, &len) == -1) strerr_diefu1sys(111, "getsockopt") ; /* Only take connections from root. */ if (client.uid) return 1 ; /* Wait for the client to die. */ r = fd_read(0, &c, 1) ; if (r < 0) strerr_diefu1sys(111, "read from stdin") ; if (r) strerr_dief1x(2, "client attempted to write") ; /* Clean up utmpx record for the client's pid, then exit. */ for (;;) { errno = 0 ; utx = getutxent() ; if (!utx) break ; if (utx->ut_pid == client.pid) goto gotit ; } if (errno) strerr_diefu1sys(111, "getutxent") ; return 0 ; gotit: utx->ut_type = DEAD_PROCESS ; memset(utx->ut_user, 0, UT_NAMESIZE) ; memset(utx->ut_host, 0, UT_HOSTSIZE) ; utx->ut_tv.tv_sec = 0 ; utx->ut_tv.tv_usec = 0 ; setutxent() ; if (!pututxline(utx)) strerr_diefu1sys(111, "pututxline") ; return 0 ; } s6-linux-init-1.0.3.1/src/misc/s6-linux-init-echo.c0000644000000000000000000000171113463713373016430 0ustar /* ISC license. */ #include #include #include #define USAGE "s6-linux-init-echo [ -n ] [ -s sep ] args..." int main (int argc, char const *const *argv) { char sep = ' ' ; char donl = 1 ; PROG = "s6-linux-init-echo" ; { subgetopt_t l = SUBGETOPT_ZERO ; for (;;) { int opt = subgetopt_r(argc, argv, "ns:", &l) ; if (opt == -1) break ; switch (opt) { case 'n': donl = 0 ; break ; case 's': sep = *l.arg ; break ; default : strerr_dieusage(100, USAGE) ; } } argc -= l.ind ; argv += l.ind ; } for ( ; *argv ; argv++) if ((buffer_puts(buffer_1small, *argv) < 0) || (argv[1] && (buffer_put(buffer_1small, &sep, 1) < 0))) goto err ; if (donl && (buffer_put(buffer_1small, "\n", 1) < 0)) goto err ; if (!buffer_flush(buffer_1small)) goto err ; return 0 ; err: strerr_diefu1sys(111, "write to stdout") ; } s6-linux-init-1.0.3.1/src/misc/deps-exe/0000755000000000000000000000000013540723124014423 5ustar s6-linux-init-1.0.3.1/src/misc/deps-exe/s6-linux-init-logouthookd0000644000000000000000000000006413540723124021330 0ustar ${LIBUTMPS} -lskarnet ${SYSCLOCK_LIB} ${SOCKET_LIB} s6-linux-init-1.0.3.1/src/misc/deps-exe/s6-linux-init-echo0000644000000000000000000000001213463713373017712 0ustar -lskarnet s6-linux-init-1.0.3.1/src/misc/deps-exe/s6-linux-init-umountall0000644000000000000000000000001213463713373021014 0ustar -lskarnet s6-linux-init-1.0.3.1/src/misc/s6-linux-init-umountall.c0000644000000000000000000000270713526511376017537 0ustar /* ISC license. */ #include #include #include #include #include #include #include #include #define MAXLINES 99 #define EXCLUDEN 3 static char const *exclude_type[EXCLUDEN] = { "devtmpfs", "proc", "sysfs" } ; int main (int argc, char const *const *argv) { size_t mountpoints[MAXLINES] ; unsigned int got[EXCLUDEN] = { 0, 0, 0 } ; stralloc sa = STRALLOC_ZERO ; unsigned int line = 0 ; FILE *fp ; int e = 0 ; PROG = "s6-linux-init-umountall" ; fp = setmntent("/proc/mounts", "r") ; if (!fp) strerr_diefu1sys(111, "open /proc/mounts") ; for (;;) { struct mntent *p ; unsigned int i = 0 ; errno = 0 ; p = getmntent(fp) ; if (!p) break ; for (; i < EXCLUDEN ; i++) if (!strcmp(p->mnt_type, exclude_type[i])) { got[i]++ ; break ; } if (i < EXCLUDEN && got[i] == 1) continue ; if (line >= MAXLINES) strerr_dief1x(100, "too many mount points") ; mountpoints[line++] = sa.len ; if (!stralloc_cats(&sa, p->mnt_dir) || !stralloc_0(&sa)) strerr_diefu1sys(111, "add mount point to list") ; } if (errno) strerr_diefu1sys(111, "read /proc/mounts") ; endmntent(fp) ; while (line--) if (umount(sa.s + mountpoints[line]) == -1) { e++ ; strerr_warnwu2sys("umount ", sa.s + mountpoints[line]) ; } stralloc_free(&sa) ; return e ; } s6-linux-init-1.0.3.1/src/misc/deps-lib/0000755000000000000000000000000013407461127014414 5ustar s6-linux-init-1.0.3.1/src/include-local/0000755000000000000000000000000013463713373014502 5ustar s6-linux-init-1.0.3.1/src/include-local/defaults.h0000644000000000000000000000025513463713373016464 0ustar /* ISC license. */ #ifndef S6_LINUX_INIT_DEFAULTS_H #define S6_LINUX_INIT_DEFAULTS_H #define BASEDIR "/etc/s6-linux-init/current" #define INITPATH "/usr/bin:/bin" #endif s6-linux-init-1.0.3.1/src/include-local/initctl.h0000644000000000000000000000217713526504072016322 0ustar /* ISC license. */ #ifndef S6_LINUX_INIT_INITCTL_H #define S6_LINUX_INIT_INITCTL_H #include #define SCANDIR "service" #define SHUTDOWND_SERVICEDIR "s6-linux-init-shutdownd" #define SHUTDOWND_FIFO "fifo" #define INITCTL S6_LINUX_INIT_TMPFS "/" SCANDIR "/" SHUTDOWND_SERVICEDIR "/" SHUTDOWND_FIFO #define RUNLEVELD_SERVICEDIR "s6-linux-init-runleveld" #define RUNLEVELD_SOCKET "s" #define RUNLEVELD_PATH S6_LINUX_INIT_TMPFS "/" SCANDIR "/" RUNLEVELD_SERVICEDIR "/" RUNLEVELD_SOCKET #define LOGOUTHOOKD_SERVICEDIR "s6-linux-init-logouthookd" #define LOGOUTHOOKD_SOCKET "s" #define LOGOUTHOOKD_PATH S6_LINUX_INIT_TMPFS "/" SCANDIR "/" LOGOUTHOOKD_SERVICEDIR "/" LOGOUTHOOKD_SOCKET #define LOGGER_SERVICEDIR "s6-svscan-log" #define LOGGER_FIFO "fifo" #define LOGFIFO S6_LINUX_INIT_TMPFS "/" SCANDIR "/" LOGGER_SERVICEDIR "/" LOGGER_FIFO #define EARLYGETTY_SERVICEDIR "s6-linux-init-early-getty" #define EARLYGETTY S6_LINUX_INIT_TMPFS "/" SCANDIR "/" EARLYGETTY_SERVICEDIR #define RUNIMAGE "run-image" #define ENVSTAGE1 "env" #define STAGE2 "rc.init" #define STAGE3 "rc.shutdown" #define STAGE4 "rc.shutdown.final" #endif s6-linux-init-1.0.3.1/src/init/0000755000000000000000000000000013541665243012731 5ustar s6-linux-init-1.0.3.1/src/init/s6-linux-init-maker.c0000644000000000000000000005003513541646717016630 0ustar /* ISC license. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "defaults.h" #include "initctl.h" #ifdef S6_LINUX_INIT_UTMPD_PATH # include # define USAGE "s6-linux-init-maker [ -c basedir ] [ -u log_user ] [ -G early_getty_cmd ] [ -1 ] [ -L ] [ -p initial_path ] [ -m initial_umask ] [ -t timestamp_style ] [ -d slashdev ] [ -s env_store ] [ -e initial_envvar ... ] [ -q default_grace_time ] [ -D initdefault ] [ -n | -N ] [ -f skeldir ] [ -U utmp_user ] dir" # define OPTION_STRING "c:u:G:1Lp:m:t:d:s:e:E:q:D:nNf:U:" # define UTMPS_DIR "utmps" #else # define USAGE "s6-linux-init-maker [ -c basedir ] [ -u log_user ] [ -G early_getty_cmd ] [ -1 ] [ -L ] [ -p initial_path ] [ -m initial_umask ] [ -t timestamp_style ] [ -d slashdev ] [ -s env_store ] [ -e initial_envvar ... ] [ -q default_grace_time ] [ -D initdefault ] [ -n | -N ] [ -f skeldir ] dir" # define OPTION_STRING "c:u:G:1Lp:m:t:d:s:e:E:q:D:nNf:" #endif #define dieusage() strerr_dieusage(100, USAGE) #define dienomem() strerr_diefu1sys(111, "stralloc_catb") ; #define UNCAUGHT_DIR "uncaught-logs" static char const *robase = BASEDIR ; static char const *initial_path = INITPATH ; static char const *env_store = 0 ; static char const *early_getty = 0 ; static char const *slashdev = 0 ; static char const *log_user = "root" ; static char const *initdefault = 0 ; static char const *skeldir = S6_LINUX_INIT_SKELDIR ; static unsigned int initial_umask = 0022 ; static unsigned int timestamp_style = 1 ; static unsigned int finalsleep = 3000 ; static int mounttype = 1 ; static int console = 0 ; static int logouthookd = 0 ; #ifdef S6_LINUX_INIT_UTMPD_PATH static char const *utmp_user = "utmp" ; #endif typedef int writetobuf_func_t (buffer *, char const *) ; typedef writetobuf_func_t *writetobuf_func_t_ref ; #define put_shebang(b) put_shebang_options((b), "-P") static int put_shebang_options (buffer *b, char const *options) { return buffer_puts(b, "#!" EXECLINE_SHEBANGPREFIX "execlineb ") >= 0 && buffer_puts(b, options && options[0] ? options : "-P") >= 0 && buffer_puts(b, "\n\n") >= 0 ; } static int line_script (buffer *b, char const *line) { return put_shebang(b) && buffer_puts(b, line) >= 0 && buffer_put(b, "\n", 1) >= 0 ; } static int linewithargs_script (buffer *b, char const *line) { return put_shebang_options(b, "-S0") && buffer_puts(b, line) >= 0 && buffer_puts(b, " $@\n") >= 0 ; } static int hpr_script (buffer *b, char const *what) { return put_shebang_options(b, "-S0") && buffer_puts(b, S6_LINUX_INIT_EXTBINPREFIX "s6-linux-init-hpr -") >= 0 && buffer_puts(b, what) >= 0 && buffer_puts(b, " $@\n") >= 0 ; } static int death_script (buffer *b, char const *s) { return put_shebang(b) && buffer_puts(b, EXECLINE_EXTBINPREFIX "redirfd -w 1 /dev/console\n" EXECLINE_EXTBINPREFIX "fdmove -c 2 1\n" EXECLINE_EXTBINPREFIX "foreground { " S6_LINUX_INIT_EXTBINPREFIX "s6-linux-init-echo -- \"s6-svscan ") >= 0 && buffer_puts(b, s) >= 0 && buffer_puts(b, ". Rebooting.\" }\n" S6_LINUX_INIT_EXTBINPREFIX "s6-linux-init-hpr -r -f\n") >= 0 ; } static int s6_svscan_log_script (buffer *b, char const *data) { size_t sabase = satmp.len ; if (!put_shebang(b) || buffer_puts(b, EXECLINE_EXTBINPREFIX "redirfd -w 2 /dev/console\n" EXECLINE_EXTBINPREFIX "redirfd -w 1 /dev/") < 0 || buffer_puts(b, console ? "console" : "null") < 0 || buffer_puts(b, "\n" EXECLINE_EXTBINPREFIX "redirfd -rnb 0 " LOGGER_FIFO "\n" S6_EXTBINPREFIX "s6-setuidgid ") < 0 || !string_quote(&satmp, log_user, strlen(log_user))) return 0 ; if (buffer_put(b, satmp.s + sabase, satmp.len - sabase) < 0) goto err ; satmp.len = sabase ; if (buffer_puts(b, "\ns6-log -bpd3 -- ") < 0) return 0 ; if (console && buffer_puts(b, "1 ") < 0) return 0 ; if (timestamp_style & 1 && buffer_puts(b, "t ") < 0 || timestamp_style & 2 && buffer_puts(b, "T ") < 0 || buffer_puts(b, S6_LINUX_INIT_TMPFS "/" UNCAUGHT_DIR "\n") < 0) return 0 ; (void)data ; return 1 ; err: satmp.len = sabase ; return 0 ; } static int logouthookd_script (buffer *b, char const *data) { (void)data ; return put_shebang(b) && buffer_puts(b, S6_EXTBINPREFIX "s6-ipcserver -1 -a 0700 -c 1000 -C 1000 -- " LOGOUTHOOKD_SOCKET "\n" S6_LINUX_INIT_EXTBINPREFIX "s6-linux-init-logouthookd\n") >= 0 ; } static int shutdownd_script (buffer *b, char const *data) { size_t sabase = satmp.len ; char fmt[UINT_FMT] ; if (!put_shebang(b) || buffer_puts(b, S6_LINUX_INIT_EXTBINPREFIX "s6-linux-init-shutdownd -c ") < 0 || !string_quote(&satmp, robase, strlen(robase))) return 0 ; if (buffer_put(b, satmp.s + sabase, satmp.len - sabase) < 0) goto err ; satmp.len = sabase ; if (buffer_puts(b, " -g ") < 0 || buffer_put(b, fmt, uint_fmt(fmt, finalsleep)) < 0 || buffer_puts(b, "\n") < 0) return 0 ; (void)data ; return 1 ; err: satmp.len = sabase ; return 0 ; } static int runleveld_script (buffer *b, char const *data) { size_t sabase = satmp.len ; if (!put_shebang(b) || buffer_puts(b, EXECLINE_EXTBINPREFIX "fdmove -c 2 1\n" EXECLINE_EXTBINPREFIX "fdmove 1 3\n" S6_EXTBINPREFIX "s6-ipcserver -1 -a 0700 -c 1 -- " RUNLEVELD_SOCKET "\n" S6_EXTBINPREFIX "s6-sudod -0 -1 -2 -t 30000 --\n") < 0 || !string_quote(&satmp, robase, strlen(robase))) return 0 ; if (buffer_put(b, satmp.s + sabase, satmp.len - sabase) < 0) goto err ; satmp.len = sabase ; if (buffer_puts(b, "/scripts/runlevel\n") < 0) return 0 ; (void)data ; return 1 ; err: satmp.len = sabase ; return 0 ; } static int sig_script (buffer *b, char const *option) { return put_shebang(b) && buffer_puts(b, S6_LINUX_INIT_EXTBINPREFIX "s6-linux-init-shutdown -a ") >= 0 && buffer_puts(b, option) >= 0 && buffer_puts(b, " -- now\n") >= 0 ; } static inline int stage1_script (buffer *b, char const *data) { size_t sabase = satmp.len ; if (!put_shebang_options(b, "-S0") || buffer_puts(b, S6_LINUX_INIT_EXTBINPREFIX "s6-linux-init -c ") < 0 || !string_quote(&satmp, robase, strlen(robase))) return 0 ; if (buffer_put(b, satmp.s + sabase, satmp.len - sabase) < 0) goto err ; satmp.len = sabase ; { char fmt[UINT_OFMT] ; if (buffer_puts(b, " -m 00") < 0 || buffer_put(b, fmt, uint_ofmt(fmt, initial_umask)) < 0) return 0 ; } if (initial_path) { if (buffer_puts(b, " -p ") < 0 || !string_quote(&satmp, initial_path, strlen(initial_path))) return 0 ; if (buffer_put(b, satmp.s + sabase, satmp.len - sabase) < 0) goto err ; satmp.len = sabase ; } if (env_store) { if (buffer_puts(b, " -s ") < 0 || !string_quote(&satmp, env_store, strlen(env_store))) return 0 ; if (buffer_put(b, satmp.s + sabase, satmp.len - sabase) < 0) goto err ; satmp.len = sabase ; } if (slashdev) { if (buffer_puts(b, " -d ") < 0 || !string_quote(&satmp, slashdev, strlen(slashdev))) return 0 ; if (buffer_put(b, satmp.s + sabase, satmp.len - sabase) < 0) goto err ; satmp.len = sabase ; } if (initdefault) { if (buffer_puts(b, " -D ") < 0 || !string_quote(&satmp, initdefault, strlen(initdefault))) return 0 ; if (buffer_put(b, satmp.s + sabase, satmp.len - sabase) < 0) goto err ; satmp.len = sabase ; } if (mounttype == 2) { if (buffer_puts(b, " -n") < 0) return 0 ; } else if (!mounttype) { if (buffer_puts(b, " -N") < 0) return 0 ; } if (buffer_puts(b, "\n") < 0) return 0 ; (void)data ; return 1 ; err: satmp.len = sabase ; return 0 ; } static void cleanup (char const *base) { int e = errno ; rm_rf(base) ; errno = e ; } static void auto_dir_internal (char const *base, char const *dir, uid_t uid, gid_t gid, unsigned int mode, int strict) { size_t clen = strlen(base) ; size_t dlen = strlen(dir) ; char fn[clen + dlen + 2] ; memcpy(fn, base, clen) ; fn[clen] = dlen ? '/' : 0 ; memcpy(fn + clen + 1, dir, dlen + 1) ; if (mkdir(fn, mode) < 0) { if (errno != EEXIST || strict) goto err ; } else { if ((uid || gid) && chown(fn, uid, gid) < 0) goto err ; if (mode & 07000 && chmod(fn, mode) < 0) goto err ; } return ; err: cleanup(base) ; strerr_diefu2sys(111, "mkdir ", fn) ; } #define auto_dir(base, dir, uid, gid, mode) auto_dir_internal(base, dir, uid, gid, (mode), 1) static void auto_file (char const *base, char const *file, char const *s, unsigned int n) { size_t clen = strlen(base) ; size_t flen = strlen(file) ; char fn[clen + flen + 2] ; memcpy(fn, base, clen) ; fn[clen] = '/' ; memcpy(fn + clen + 1, file, flen + 1) ; if (!openwritenclose_unsafe(fn, s, n) || chmod(fn, 0644) == -1) { cleanup(base) ; strerr_diefu2sys(111, "write to ", fn) ; } } static void auto_symlink (char const *base, char const *name, char const *target) { size_t clen = strlen(base) ; size_t dlen = strlen(name) ; char fn[clen + dlen + 2] ; memcpy(fn, base, clen) ; fn[clen] = '/' ; memcpy(fn + clen + 1, name, dlen + 1) ; if (symlink(target, fn) == -1) { cleanup(base) ; strerr_diefu4sys(111, "make a symlink named ", fn, " pointing to ", target) ; } } static void auto_fifo (char const *base, char const *fifo) { size_t baselen = strlen(base) ; size_t fifolen = strlen(fifo) ; char fn[baselen + fifolen + 2] ; memcpy(fn, base, baselen) ; fn[baselen] = '/' ; memcpy(fn + baselen + 1, fifo, fifolen + 1) ; if (mkfifo(fn, 0600) < 0) { cleanup(base) ; strerr_diefu2sys(111, "mkfifo ", fn) ; } } static void auto_script (char const *base, char const *file, writetobuf_func_t_ref scriptf, char const *data) { char buf[4096] ; buffer b ; size_t baselen = strlen(base) ; size_t filelen = strlen(file) ; int fd ; char fn[baselen + filelen + 2] ; memcpy(fn, base, baselen) ; fn[baselen] = '/' ; memcpy(fn + baselen + 1, file, filelen + 1) ; fd = open_trunc(fn) ; if (fd < 0 || ndelay_off(fd) < 0 || fchmod(fd, 0755) < 0) { cleanup(base) ; strerr_diefu3sys(111, "open ", fn, " for script writing") ; } buffer_init(&b, &fd_writev, fd, buf, 4096) ; if (!(*scriptf)(&b, data) || !buffer_flush(&b)) { cleanup(base) ; strerr_diefu2sys(111, "write to ", fn) ; } fd_close(fd) ; } static void copy_script (char const *base, char const *name) { size_t baselen = strlen(base) ; size_t namelen = strlen(name) ; size_t skellen = strlen(skeldir) ; char dst[baselen + sizeof("/scripts/") + namelen] ; char src[skellen + namelen + 2] ; memcpy(dst, base, baselen) ; memcpy(dst + baselen, "/scripts/", sizeof("/scripts/") - 1) ; memcpy(dst + baselen + sizeof("/scripts/") - 1, name, namelen + 1) ; memcpy(src, skeldir, skellen) ; src[skellen] = '/' ; memcpy(src + skellen + 1, name, namelen + 1) ; if (!filecopy_unsafe(src, dst, 0755)) { cleanup(base) ; strerr_diefu4sys(111, "copy ", src, " to ", dst) ; } } static void auto_exec (char const *base, char const *name, char const *target) { if (S6_LINUX_INIT_EXTBINPREFIX[0] == '/') { size_t len = strlen(target) ; char fn[sizeof(S6_LINUX_INIT_EXTBINPREFIX) + len] ; memcpy(fn, S6_LINUX_INIT_EXTBINPREFIX, sizeof(S6_LINUX_INIT_EXTBINPREFIX) - 1) ; memcpy(fn + sizeof(S6_LINUX_INIT_EXTBINPREFIX) - 1, target, len + 1) ; auto_symlink(base, name, fn) ; } else auto_script(base, name, &linewithargs_script, target) ; } static void make_env (char const *base, char const *envname, char *modif, size_t modiflen) { size_t envnamelen = strlen(envname) ; auto_dir(base, envname, 0, 0, 0755) ; while (modiflen) { size_t len = strlen(modif) ; size_t pos = byte_chr(modif, len, '=') ; char fn[envnamelen + pos + 2] ; memcpy(fn, envname, envnamelen) ; fn[envnamelen] = '/' ; memcpy(fn + envnamelen + 1, modif, pos) ; fn[envnamelen + 1 + pos] = 0 ; if (pos + 1 < len) { modif[len] = '\n' ; auto_file(base, fn, modif + pos + 1, len - pos) ; modif[len] = 0 ; } else if (pos + 1 == len) auto_file(base, fn, "\n", 1) ; else auto_file(base, fn, "", 0) ; modif += len+1 ; modiflen -= len+1 ; } } static void getug (char const *base, char const *s, uid_t *uid, gid_t *gid) { struct passwd *pw ; errno = 0 ; pw = getpwnam(s) ; if (!pw) { cleanup(base) ; if (!errno) strerr_diefu3x(100, "find user ", s, " in passwd database") ; else strerr_diefu2sys(111, "getpwnam for ", s) ; } *uid = pw->pw_uid ; *gid = pw->pw_gid ; } #ifdef S6_LINUX_INIT_UTMPD_PATH static inline void auto_basedir (char const *base, char const *dir, uid_t uid, gid_t gid, unsigned int mode) { size_t n = strlen(dir) ; char tmp[n + 1] ; for (size_t i = 0 ; i < n ; i++) { if ((dir[i] == '/') && i) { tmp[i] = 0 ; auto_dir_internal(base, tmp, uid, gid, mode, 0) ; } tmp[i] = dir[i] ; } } static int utmpd_script (buffer *b, char const *uw) { size_t sabase = satmp.len ; if (!put_shebang(b) || buffer_puts(b, EXECLINE_EXTBINPREFIX "fdmove -c 2 1\n" S6_EXTBINPREFIX "s6-setuidgid ") < 0 || !string_quote(&satmp, utmp_user, strlen(utmp_user))) return 0 ; if (buffer_put(b, satmp.s + sabase, satmp.len - sabase) < 0) goto err ; satmp.len = sabase ; if (buffer_puts(b, "\n" EXECLINE_EXTBINPREFIX "cd " S6_LINUX_INIT_TMPFS "/" UTMPS_DIR "\n" EXECLINE_EXTBINPREFIX "fdmove 1 3\n" S6_EXTBINPREFIX "s6-ipcserver -1 -c 1000 -- ") < 0) return 0 ; if (buffer_puts(b, uw[0] == 'u' ? UTMPS_UTMPD_PATH : UTMPS_WTMPD_PATH) < 0 || buffer_puts(b, "\n" UTMPS_EXTBINPREFIX "utmps-") < 0 || buffer_puts(b, uw) < 0 || buffer_puts(b, "tmpd\n") < 0) return 0 ; return 1 ; err: satmp.len = sabase ; return 0 ; } static inline void make_utmps (char const *base) { auto_dir(base, "run-image/" SCANDIR "/utmpd", 0, 0, 0755) ; auto_file(base, "run-image/" SCANDIR "/utmpd/notification-fd", "3\n", 2) ; auto_script(base, "run-image/" SCANDIR "/utmpd/run", &utmpd_script, "u") ; auto_dir(base, "run-image/" SCANDIR "/wtmpd", 0, 0, 0755) ; auto_file(base, "run-image/" SCANDIR "/wtmpd/notification-fd", "3\n", 2) ; auto_script(base, "run-image/" SCANDIR "/wtmpd/run", &utmpd_script, "w") ; { uid_t uid ; gid_t gid ; getug(base, utmp_user, &uid, &gid) ; auto_dir(base, "run-image/" UTMPS_DIR, uid, gid, 0755) ; auto_basedir(base, "run-image/" S6_LINUX_INIT_UTMPD_PATH, uid, gid, 0755) ; auto_basedir(base, "run-image/" S6_LINUX_INIT_WTMPD_PATH, uid, gid, 0755) ; } } #endif static inline void make_image (char const *base) { auto_dir(base, "run-image", 0, 0, 0755) ; { uid_t uid ; gid_t gid ; getug(base, log_user, &uid, &gid) ; auto_dir(base, "run-image/" UNCAUGHT_DIR, uid, gid, 02750) ; } auto_dir(base, "run-image/" SCANDIR, 0, 0, 0755) ; auto_dir(base, "run-image/" SCANDIR "/.s6-svscan", 0, 0, 0755) ; auto_script(base, "run-image/" SCANDIR "/.s6-svscan/crash", &death_script, "crashed") ; auto_script(base, "run-image/" SCANDIR "/.s6-svscan/finish", &death_script, "exited") ; auto_script(base, "run-image/" SCANDIR "/.s6-svscan/SIGTERM", &put_shebang_options, 0) ; auto_script(base, "run-image/" SCANDIR "/.s6-svscan/SIGHUP", &put_shebang_options, 0) ; auto_script(base, "run-image/" SCANDIR "/.s6-svscan/SIGQUIT", &put_shebang_options, 0) ; auto_script(base, "run-image/" SCANDIR "/.s6-svscan/SIGINT", &sig_script, "-r") ; auto_script(base, "run-image/" SCANDIR "/.s6-svscan/SIGUSR1", &sig_script, "-p") ; auto_script(base, "run-image/" SCANDIR "/.s6-svscan/SIGUSR2", &sig_script, "-h") ; auto_dir(base, "run-image/" SCANDIR "/" LOGGER_SERVICEDIR, 0, 0, 0755) ; auto_fifo(base, "run-image/" SCANDIR "/" LOGGER_SERVICEDIR "/" LOGGER_FIFO) ; auto_file(base, "run-image/" SCANDIR "/" LOGGER_SERVICEDIR "/notification-fd", "3\n", 2) ; auto_script(base, "run-image/" SCANDIR "/" LOGGER_SERVICEDIR "/run", &s6_svscan_log_script, 0) ; auto_dir(base, "run-image/" SCANDIR "/" SHUTDOWND_SERVICEDIR, 0, 0, 0755) ; auto_fifo(base, "run-image/" SCANDIR "/" SHUTDOWND_SERVICEDIR "/" SHUTDOWND_FIFO) ; auto_script(base, "run-image/" SCANDIR "/" SHUTDOWND_SERVICEDIR "/run", &shutdownd_script, 0) ; auto_dir(base, "run-image/" SCANDIR "/" RUNLEVELD_SERVICEDIR, 0, 0, 0755) ; auto_file(base, "run-image/" SCANDIR "/" RUNLEVELD_SERVICEDIR "/notification-fd", "3\n", 2) ; auto_script(base, "run-image/" SCANDIR "/" RUNLEVELD_SERVICEDIR "/run", &runleveld_script, 0) ; if (logouthookd) { auto_dir(base, "run-image/" SCANDIR "/" LOGOUTHOOKD_SERVICEDIR, 0, 0, 0755) ; auto_file(base, "run-image/" SCANDIR "/" LOGOUTHOOKD_SERVICEDIR "/notification-fd", "1\n", 2) ; auto_script(base, "run-image/" SCANDIR "/" LOGOUTHOOKD_SERVICEDIR "/run", &logouthookd_script, 0) ; } if (early_getty) { auto_dir(base, "run-image/" SCANDIR "/" EARLYGETTY_SERVICEDIR, 0, 0, 0755) ; auto_script(base, "run-image/" SCANDIR "/" EARLYGETTY_SERVICEDIR "/run", &line_script, early_getty) ; } #ifdef S6_LINUX_INIT_UTMPD_PATH if (utmp_user[0]) make_utmps(base) ; #endif } static inline void make_scripts (char const *base) { auto_dir(base, "scripts", 0, 0, 0755) ; copy_script(base, "runlevel") ; copy_script(base, STAGE2) ; copy_script(base, STAGE3) ; copy_script(base, STAGE4) ; } static inline void make_bins (char const *base) { auto_dir(base, "bin", 0, 0, 0755) ; auto_script(base, "bin/init", &stage1_script, 0) ; auto_script(base, "bin/halt", &hpr_script, "h") ; auto_script(base, "bin/poweroff", &hpr_script, "p") ; auto_script(base, "bin/reboot", &hpr_script, "r") ; auto_exec(base, "bin/shutdown", "s6-linux-init-shutdown") ; auto_exec(base, "bin/telinit", "s6-linux-init-telinit") ; } int main (int argc, char const *const *argv, char const *const *envp) { PROG = "s6-linux-init-maker" ; { subgetopt_t l = SUBGETOPT_ZERO ; for (;;) { int opt = subgetopt_r(argc, argv, OPTION_STRING, &l) ; if (opt == -1) break ; switch (opt) { case 'c' : robase = l.arg ; break ; case 'u' : log_user = l.arg ; break ; case 'G' : early_getty = l.arg ; break ; case '1' : console = 1 ; break ; case 'L' : logouthookd = 1 ; break ; case 'p' : initial_path = l.arg ; break ; case 'm' : if (!uint0_oscan(l.arg, &initial_umask)) dieusage() ; break ; case 't' : if (!uint0_scan(l.arg, ×tamp_style)) dieusage() ; break ; case 'd' : slashdev = l.arg ; break ; case 's' : env_store = l.arg ; break ; case 'e' : if (!stralloc_catb(&satmp, l.arg, strlen(l.arg) + 1)) dienomem() ; break ; case 'q' : if (!uint0_scan(l.arg, &finalsleep)) dieusage() ; break ; case 'D' : initdefault = l.arg ; break ; case 'n' : mounttype = 2 ; break ; case 'N' : mounttype = 0 ; break ; case 'f' : skeldir = l.arg ; break ; #ifdef S6_LINUX_INIT_UTMPD_PATH case 'U' : utmp_user = l.arg ; break ; #endif default : dieusage() ; } } argc -= l.ind ; argv += l.ind ; } if (!argc) dieusage() ; if (robase[0] != '/') strerr_dief3x(100, "base directory ", robase, " is not absolute") ; if (slashdev && slashdev[0] != '/') strerr_dief3x(100, "devtmpfs directory ", slashdev, " is not absolute") ; if (env_store) { if (env_store[0] != '/') strerr_dief3x(100, "kernel environment store ", env_store, " is not absolute") ; if (!str_start(env_store, S6_LINUX_INIT_TMPFS "/")) strerr_warnw3x("kernel environment store ", env_store, " is not located under initial tmpfs " S6_LINUX_INIT_TMPFS) ; } if (timestamp_style > 3) strerr_dief1x(100, "-t timestamp_style must be 0, 1, 2 or 3") ; umask(0) ; if (mkdir(argv[0], 0755) < 0) strerr_diefu2sys(111, "mkdir ", argv[0]) ; make_env(argv[0], ENVSTAGE1, satmp.s, satmp.len) ; satmp.len = 0 ; make_image(argv[0]) ; make_scripts(argv[0]) ; make_bins(argv[0]) ; return 0 ; } s6-linux-init-1.0.3.1/src/init/deps-exe/0000755000000000000000000000000013463713373014444 5ustar s6-linux-init-1.0.3.1/src/init/deps-exe/s6-linux-init-maker0000644000000000000000000000005113463713373020106 0ustar ${LIBNSSS} -lskarnet ${MAYBEPTHREAD_LIB} s6-linux-init-1.0.3.1/src/init/deps-exe/s6-linux-init0000644000000000000000000000001213463713373017006 0ustar -lskarnet s6-linux-init-1.0.3.1/src/init/deps-exe/s6-linux-init-telinit0000644000000000000000000000001213463713373020454 0ustar -lskarnet s6-linux-init-1.0.3.1/src/init/s6-linux-init-telinit.c0000644000000000000000000000377613463713373017207 0ustar /* ISC license. */ #include #include #include #include #include #include #include #include #include "initctl.h" #define USAGE "s6-linux-init-telinit runlevel" #define dieusage() strerr_dieusage(100, USAGE) int main (int argc, char const *const *argv, char const *const *envp) { char const *newargv[8] = { S6_EXTBINPREFIX "s6-sudo", "-e", "-T", "3600000", "--", RUNLEVELD_PATH, 0, 0 } ; PROG = "s6-linux-init-telinit" ; { subgetopt_t l = SUBGETOPT_ZERO ; for (;;) { int opt = subgetopt_r(argc, argv, "c:p:s:m:d:D:", &l) ; if (opt == -1) break ; switch (opt) { case 'c' : /* s6-linux-init may be called with these options, don't choke on them */ case 'p' : case 's' : case 'm' : case 'd' : case 'D' : break ; default : dieusage() ; } } argc -= l.ind ; argv += l.ind ; } if (!argc) dieusage() ; newargv[6] = argv[0] ; /* specialcase 0 and 6: fork runlevel call then exec shutdown, instead of execing runlevel call */ if (!strcmp(argv[0], "0") || !strcmp(argv[0], "6")) { int wstat ; pid_t pid = child_spawn0(newargv[0], newargv, envp) ; if (!pid) strerr_diefu2sys(111, "spawn ", newargv[0]) ; if (wait_pid(pid, &wstat) < 0) strerr_diefu1sys(111, "wait_pid") ; if (WIFSIGNALED(wstat)) { char fmt[UINT_FMT] ; fmt[uint_fmt(fmt, WTERMSIG(wstat))] = 0 ; strerr_dief3x(wait_estatus(wstat), newargv[0], " crashed with signal ", fmt) ; } else if (WEXITSTATUS(wstat)) { char fmt[UINT_FMT] ; fmt[uint_fmt(fmt, WEXITSTATUS(wstat))] = 0 ; strerr_dief3x(wait_estatus(wstat), newargv[0], " died with exitcode ", fmt) ; } newargv[0] = S6_LINUX_INIT_BINPREFIX "s6-linux-init-hpr" ; newargv[1] = argv[0][0] == '6' ? "-r" : "-p" ; newargv[2] = 0 ; } xpathexec_run(newargv[0], newargv, envp) ; } s6-linux-init-1.0.3.1/src/init/deps-lib/0000755000000000000000000000000013367345167014436 5ustar s6-linux-init-1.0.3.1/src/init/s6-linux-init.c0000644000000000000000000001417413523260413015520 0ustar /* ISC license. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "defaults.h" #include "initctl.h" #define USAGE "s6-linux-init [ -c basedir ] [ -p initpath ] [ -s envdumpdir ] [ -m umask ] [ -d devtmpfs ] [ -D initdefault ] [ -n | -N ]" #define dieusage() strerr_dieusage(100, USAGE) #define BANNER "\n s6-linux-init version " S6_LINUX_INIT_VERSION "\n\n" static inline char const *scan_cmdline (char const *initdefault, char const *const *argv, unsigned int argc) { static char const *valid[] = { "default", "2", "3", "4", "5", 0 } ; for (unsigned int i = 0 ; i < argc ; i++) for (char const *const *p = valid ; *p ; p++) if (!strcmp(argv[i], *p)) return argv[i] ; return initdefault ; } static inline void run_stage2 (char const *basedir, char const **argv, unsigned int argc, char const *const *envp, size_t envlen, char const *modifs, size_t modiflen, char const *initdefault) { size_t dirlen = strlen(basedir) ; char const *childargv[argc + 3] ; char fn[dirlen + sizeof("/scripts/" STAGE2)] ; PROG = "s6-linux-init (child)" ; memcpy(fn, basedir, dirlen) ; memcpy(fn + dirlen, "/scripts/" STAGE2, sizeof("/scripts/" STAGE2)) ; childargv[0] = fn ; childargv[1] = scan_cmdline(initdefault, argv, argc) ; for (unsigned int i = 0 ; i < argc ; i++) childargv[i+2] = argv[i] ; childargv[argc + 2] = 0 ; setsid() ; fd_close(1) ; if (open(LOGFIFO, O_WRONLY) != 1) /* blocks until catch-all logger is up */ strerr_diefu1sys(111, "open " LOGFIFO " for writing") ; if (fd_copy(2, 1) == -1) strerr_diefu1sys(111, "fd_copy stdout to stderr") ; xpathexec_r(childargv, envp, envlen, modifs, modiflen) ; } int main (int argc, char const **argv, char const *const *envp) { mode_t mask = 0022 ; char const *basedir = BASEDIR ; char const *path = INITPATH ; char const *slashdev = 0 ; char const *envdumpdir = 0 ; char const *initdefault = "default" ; int mounttype = 1 ; stralloc envmodifs = STRALLOC_ZERO ; PROG = "s6-linux-init" ; if (getpid() != 1) { argv[0] = S6_LINUX_INIT_BINPREFIX "s6-linux-init-telinit" ; pathexec_run(argv[0], argv, envp) ; strerr_dieexec(111, argv[0]) ; } { subgetopt_t l = SUBGETOPT_ZERO ; for (;;) { int opt = subgetopt_r(argc, argv, "c:p:s:m:d:D:nN", &l) ; if (opt == -1) break ; switch (opt) { case 'c' : basedir = l.arg ; break ; case 'p' : path = l.arg ; break ; case 's' : envdumpdir = l.arg ; break ; case 'm' : if (!uint0_oscan(l.arg, &mask)) dieusage() ; break ; case 'd' : slashdev = l.arg ; break ; case 'D' : initdefault = l.arg ; break ; case 'n' : mounttype = 2 ; break ; case 'N' : mounttype = 0 ; break ; default : dieusage() ; } } argc -= l.ind ; argv += l.ind ; } allwrite(1, BANNER, sizeof(BANNER) - 1) ; if (chdir("/") == -1) strerr_diefu1sys(111, "chdir to /") ; umask(mask) ; setpgid(0, 0) ; fd_close(0) ; if (slashdev) { fd_close(1) ; fd_close(2) ; if (mount("dev", slashdev, "devtmpfs", MS_NOSUID | MS_NOEXEC, "") == -1) { int e = errno ; open("/dev/null", O_RDONLY) ; open("/dev/console", O_WRONLY) ; fd_copy(2, 1) ; errno = e ; strerr_diefu2sys(111, "mount ", slashdev) ; } if (open("/dev/console", O_WRONLY) || fd_copy(1, 0) == -1 || fd_move(2, 0) == -1) return 111 ; } if (open("/dev/null", O_RDONLY)) strerr_diefu1sys(111, "open /dev/null") ; if (mounttype) { if (mounttype == 2) { if (mount("tmpfs", S6_LINUX_INIT_TMPFS, "tmpfs", MS_REMOUNT | MS_NODEV | MS_NOSUID, "mode=0755") == -1) strerr_diefu1sys(111, "remount " S6_LINUX_INIT_TMPFS) ; } else { if (umount(S6_LINUX_INIT_TMPFS) == -1) { if (errno != EINVAL) strerr_warnwu1sys("umount " S6_LINUX_INIT_TMPFS) ; } if (mount("tmpfs", S6_LINUX_INIT_TMPFS, "tmpfs", MS_NODEV | MS_NOSUID, "mode=0755") == -1) strerr_diefu1sys(111, "mount tmpfs on " S6_LINUX_INIT_TMPFS) ; } } { size_t dirlen = strlen(basedir) ; char fn[dirlen + 1 + (sizeof(RUNIMAGE) > sizeof(ENVSTAGE1) ? sizeof(RUNIMAGE) : sizeof(ENVSTAGE1))] ; memcpy(fn, basedir, dirlen) ; fn[dirlen] = '/' ; memcpy(fn + dirlen + 1, RUNIMAGE, sizeof(RUNIMAGE)) ; if (!hiercopy(fn, S6_LINUX_INIT_TMPFS)) strerr_diefu3sys(111, "copy ", fn, " to " S6_LINUX_INIT_TMPFS) ; memcpy(fn + dirlen + 1, ENVSTAGE1, sizeof(ENVSTAGE1)) ; if (envdir(fn, &envmodifs) == -1) strerr_warnwu2sys("envdir ", fn) ; } if (envdumpdir && !env_dump(envdumpdir, 0700, envp)) strerr_warnwu2sys("dump kernel environment to ", envdumpdir) ; { int fdr = open_read(LOGFIFO) ; if (fdr == -1) strerr_diefu1sys(111, "open " LOGFIFO) ; fd_close(1) ; if (open(LOGFIFO, O_WRONLY) != 1) strerr_diefu1sys(111, "open " LOGFIFO) ; fd_close(fdr) ; } { static char const *const newargv[5] = { S6_EXTBINPREFIX "s6-svscan", "-st0", "--", S6_LINUX_INIT_TMPFS "/" SCANDIR, 0 } ; char const *newenvp[2] = { 0, 0 } ; pid_t pid ; size_t pathlen = path ? strlen(path) : 0 ; char pathvar[6 + pathlen] ; if (path) { if (setenv("PATH", path, 1) == -1) strerr_diefu1sys(111, "set initial PATH") ; memcpy(pathvar, "PATH=", 5) ; memcpy(pathvar + 5, path, pathlen + 1) ; newenvp[0] = pathvar ; } pid = fork() ; if (pid == -1) strerr_diefu1sys(111, "fork") ; if (!pid) run_stage2(basedir, argv, argc, newenvp, !!path, envmodifs.s, envmodifs.len, initdefault) ; if (reboot(RB_DISABLE_CAD) == -1) strerr_warnwu1sys("trap ctrl-alt-del") ; if (fd_copy(2, 1) == -1) strerr_diefu1sys(111, "redirect output file descriptor") ; xpathexec_r(newargv, newenvp, !!path, envmodifs.s, envmodifs.len) ; } } s6-linux-init-1.0.3.1/src/include/0000755000000000000000000000000012540011046013371 5ustar s6-linux-init-1.0.3.1/src/include/s6-linux-init/0000755000000000000000000000000013541665243016037 5ustar s6-linux-init-1.0.3.1/src/include/s6-linux-init/s6-linux-init.h0000644000000000000000000000017213463713373020637 0ustar /* ISC license. */ #ifndef S6_LINUX_INIT_H #define S6_LINUX_INIT_H extern int s6_linux_init_logouthook (void) ; #endif s6-linux-init-1.0.3.1/src/lib/0000755000000000000000000000000013541665243012534 5ustar s6-linux-init-1.0.3.1/src/lib/deps-exe/0000755000000000000000000000000013407461330014236 5ustar s6-linux-init-1.0.3.1/src/lib/s6_linux_init_logouthook.c0000644000000000000000000000053613463713373017751 0ustar /* ISC license. */ #include #include #include #include "initctl.h" int s6_linux_init_logouthook (void) { int fd = ipc_stream_nbcoe() ; if (fd < 0) return -1 ; if (!ipc_timed_connect(fd, LOGOUTHOOKD_PATH, 0, 0)) { fd_close(fd) ; return -1 ; } return fd ; } s6-linux-init-1.0.3.1/src/lib/deps-lib/0000755000000000000000000000000013540723124014223 5ustar s6-linux-init-1.0.3.1/src/lib/deps-lib/s6_linux_init0000644000000000000000000000010313540723124016732 0ustar s6_linux_init_logouthook.o -lskarnet ${SOCKET_LIB} ${SYSCLOCK_LIB} s6-linux-init-1.0.3.1/package/0002755000000000000000000000000013473054142012566 5ustar s6-linux-init-1.0.3.1/package/deps.mak0000644000000000000000000000706413553364325014226 0ustar # # This file has been generated by tools/gen-deps.sh # src/include-local/initctl.h: src/include/s6-linux-init/config.h src/shutdown/hpr.h: src/include-local/initctl.h src/init/s6-linux-init-maker.o src/init/s6-linux-init-maker.lo: src/init/s6-linux-init-maker.c src/include-local/defaults.h src/include-local/initctl.h src/include/s6-linux-init/config.h src/init/s6-linux-init-telinit.o src/init/s6-linux-init-telinit.lo: src/init/s6-linux-init-telinit.c src/include-local/initctl.h src/include/s6-linux-init/config.h src/init/s6-linux-init.o src/init/s6-linux-init.lo: src/init/s6-linux-init.c src/include-local/defaults.h src/include-local/initctl.h src/include/s6-linux-init/config.h src/lib/s6_linux_init_logouthook.o src/lib/s6_linux_init_logouthook.lo: src/lib/s6_linux_init_logouthook.c src/include-local/initctl.h src/include/s6-linux-init/s6-linux-init.h src/misc/s6-linux-init-echo.o src/misc/s6-linux-init-echo.lo: src/misc/s6-linux-init-echo.c src/misc/s6-linux-init-logouthookd.o src/misc/s6-linux-init-logouthookd.lo: src/misc/s6-linux-init-logouthookd.c src/misc/s6-linux-init-umountall.o src/misc/s6-linux-init-umountall.lo: src/misc/s6-linux-init-umountall.c src/shutdown/hpr_shutdown.o src/shutdown/hpr_shutdown.lo: src/shutdown/hpr_shutdown.c src/shutdown/hpr.h src/shutdown/hpr_wall.o src/shutdown/hpr_wall.lo: src/shutdown/hpr_wall.c src/shutdown/hpr.h src/shutdown/s6-linux-init-hpr.o src/shutdown/s6-linux-init-hpr.lo: src/shutdown/s6-linux-init-hpr.c src/include-local/defaults.h src/shutdown/hpr.h src/shutdown/s6-linux-init-shutdown.o src/shutdown/s6-linux-init-shutdown.lo: src/shutdown/s6-linux-init-shutdown.c src/include-local/defaults.h src/shutdown/hpr.h src/include-local/initctl.h src/shutdown/s6-linux-init-shutdownd.o src/shutdown/s6-linux-init-shutdownd.lo: src/shutdown/s6-linux-init-shutdownd.c src/include-local/defaults.h src/shutdown/hpr.h src/include-local/initctl.h src/include/s6-linux-init/config.h s6-linux-init: EXTRA_LIBS := -lskarnet s6-linux-init: src/init/s6-linux-init.o s6-linux-init-maker: EXTRA_LIBS := -lskarnet ${MAYBEPTHREAD_LIB} s6-linux-init-maker: src/init/s6-linux-init-maker.o ${LIBNSSS} s6-linux-init-telinit: EXTRA_LIBS := -lskarnet s6-linux-init-telinit: src/init/s6-linux-init-telinit.o ifeq ($(strip $(STATIC_LIBS_ARE_PIC)),) libs6_linux_init.a.xyzzy: src/lib/s6_linux_init_logouthook.o else libs6_linux_init.a.xyzzy: src/lib/s6_linux_init_logouthook.lo endif libs6_linux_init.so.xyzzy: EXTRA_LIBS := -lskarnet ${SOCKET_LIB} ${SYSCLOCK_LIB} libs6_linux_init.so.xyzzy: src/lib/s6_linux_init_logouthook.lo s6-linux-init-echo: EXTRA_LIBS := -lskarnet s6-linux-init-echo: src/misc/s6-linux-init-echo.o s6-linux-init-logouthookd: EXTRA_LIBS := -lskarnet ${SYSCLOCK_LIB} ${SOCKET_LIB} s6-linux-init-logouthookd: src/misc/s6-linux-init-logouthookd.o ${LIBUTMPS} s6-linux-init-umountall: EXTRA_LIBS := -lskarnet s6-linux-init-umountall: src/misc/s6-linux-init-umountall.o ifeq ($(strip $(STATIC_LIBS_ARE_PIC)),) libhpr.a.xyzzy: src/shutdown/hpr_shutdown.o src/shutdown/hpr_wall.o else libhpr.a.xyzzy: src/shutdown/hpr_shutdown.lo src/shutdown/hpr_wall.lo endif s6-linux-init-hpr: EXTRA_LIBS := -lskarnet ${SYSCLOCK_LIB} ${SOCKET_LIB} s6-linux-init-hpr: src/shutdown/s6-linux-init-hpr.o libhpr.a.xyzzy ${LIBUTMPS} s6-linux-init-shutdown: EXTRA_LIBS := -lskarnet ${SYSCLOCK_LIB} ${SOCKET_LIB} s6-linux-init-shutdown: src/shutdown/s6-linux-init-shutdown.o libhpr.a.xyzzy ${LIBUTMPS} s6-linux-init-shutdownd: EXTRA_LIBS := -ls6 -lskarnet ${SYSCLOCK_LIB} ${SOCKET_LIB} s6-linux-init-shutdownd: src/shutdown/s6-linux-init-shutdownd.o ${LIBUTMPS} INTERNAL_LIBS := libhpr.a.xyzzy s6-linux-init-1.0.3.1/package/deps-build0000644000000000000000000000017113463713373014545 0ustar /package/prog/skalibs /package/admin/nsss $usensss /package/admin/utmps $utmps /package/admin/execline /package/admin/s6 s6-linux-init-1.0.3.1/package/targets.mak0000644000000000000000000000072513463713373014742 0ustar BIN_TARGETS := \ s6-linux-init \ s6-linux-init-hpr \ s6-linux-init-shutdown \ s6-linux-init-shutdownd \ s6-linux-init-telinit \ s6-linux-init-logouthookd \ s6-linux-init-echo \ s6-linux-init-umountall \ s6-linux-init-maker LIB_DEFS := S6_LINUX_INIT=s6_linux_init SKELFILES := $(wildcard skel/*) $(DESTDIR)$(skeldir)/%: skel/% ./tools/install.sh -D -m 0755 $< $@ install-skel: $(SKELFILES:skel/%=$(DESTDIR)$(skeldir)/%) .PHONY: install-skel install: install-skel s6-linux-init-1.0.3.1/package/modes0000644000000000000000000000036413470512217013620 0ustar s6-linux-init 0744 s6-linux-init-hpr 0744 s6-linux-init-shutdown 0744 s6-linux-init-shutdownd 0744 s6-linux-init-telinit 0744 s6-linux-init-logouthookd 0744 s6-linux-init-echo 0755 s6-linux-init-umountall 0744 s6-linux-init-maker 0744 s6-linux-init-1.0.3.1/package/info0000644000000000000000000000012613553360762013450 0ustar package=s6-linux-init version=1.0.3.1 category=admin package_macro_name=S6_LINUX_INIT s6-linux-init-1.0.3.1/COPYING0000644000000000000000000000137013436451135012227 0ustar Copyright (c) 2015-2019 Laurent Bercot Permission to use, copy, modify, and distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies. THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. s6-linux-init-1.0.3.1/configure0000755000000000000000000003704313553343654013117 0ustar #!/bin/sh cd `dirname "$0"` . package/info usage () { cat </dev/null 2>&1 && { echo "$1" ; return 0 ; } $1 EOF echo "$1" | sed -e "s/'/'\\\\''/g" -e "1s/^/'/" -e "\$s/\$/'/" -e "s#^'\([-[:alnum:]_,./:]*\)=\(.*\)\$#\1='\2#" -e "s|\*/|* /|g" } fail () { echo "$*" exit 1 } isprefix() { case "$1" in "$2"*) return 0 ;; *) return 1 ;; esac ; } fnmatch () { eval "case \"\$2\" in $1) return 0 ;; *) return 1 ;; esac" } cmdexists () { type "$1" >/dev/null 2>&1 } trycc () { test -z "$CC_AUTO" && cmdexists "$1" && CC_AUTO="$*" } stripdir () { while eval "fnmatch '*/' \"\${$1}\"" ; do eval "$1=\${$1%/}" done } tryflag () { echo "Checking whether compiler accepts $2 ..." echo "typedef int x;" > "$tmpc" if $CC_AUTO $CPPFLAGS_AUTO $CPPFLAGS $CPPFLAGS_POST $CFLAGS_AUTO $CFLAGS $CFLAGS_POST "$2" -c -o /dev/null "$tmpc" >/dev/null 2>&1 ; then echo " ... yes" eval "$1=\"\${$1} \$2\"" eval "$1=\${$1# }" return 0 else echo " ... no" return 1 fi } tryldflag () { echo "Checking whether linker accepts $2 ..." echo "typedef int x;" > "$tmpc" if $CC_AUTO $CFLAGS_AUTO $CFLAGS $CFLAGS_POST $LDFLAGS_AUTO $LDFLAGS $LDFLAGS_POST -nostdlib "$2" -o /dev/null "$tmpc" >/dev/null 2>&1 ; then echo " ... yes" eval "$1=\"\${$1} \$2\"" eval "$1=\${$1# }" return 0 else echo " ... no" return 1 fi } getmacro () { echo "#include <$1>" | $CC_AUTO $CPPFLAGS_AUTO $CPPFLAGS $CPPFLAGS_POST $CFLAGS_AUTO $CFLAGS $CFLAGS_POST -E -dM - | grep -F -- "$2" | cut -d' ' -f3- } getmacrostring () { getmacro "$1" "$2" | sed -e 's/^"//' -e 's/"$//' } # Actual script CC_AUTO= CPPFLAGS_AUTO="-D_POSIX_C_SOURCE=200809L -D_XOPEN_SOURCE=700 -iquote src/include-local -Isrc/include" CPPFLAGS_POST="$CPPFLAGS" CPPFLAGS= CFLAGS_AUTO="-pipe -Wall" CFLAGS_POST="$CFLAGS" CFLAGS=-O2 LDFLAGS_AUTO= LDFLAGS_POST="$LDFLAGS" LDFLAGS= LDFLAGS_NOSHARED= LDFLAGS_SHARED=-shared prefix= exec_prefix='$prefix' dynlibdir='$prefix/lib' libexecdir='$exec_prefix/libexec' bindir='$exec_prefix/bin' libdir='$prefix/lib/$package' includedir='$prefix/include' sysdeps='$prefix/lib/skalibs/sysdeps' manualsysdeps=false shared=false static=true allpic=true slashpackage=false abspath=false usensss=false sproot= home= exthome= allstatic=true evenmorestatic=false addincpath='' addlibspath='' addlibdpath='' vpaths='' vpathd='' build= skeldir='$prefix/etc/s6-linux-init/skel' tmpfsdir=/run utmps=false for arg ; do case "$arg" in --help) usage ;; --prefix=*) prefix=${arg#*=} ;; --exec-prefix=*) exec_prefix=${arg#*=} ;; --dynlibdir=*) dynlibdir=${arg#*=} ;; --libexecdir=*) libexecdir=${arg#*=} ;; --bindir=*) bindir=${arg#*=} ;; --libdir=*) libdir=${arg#*=} ;; --includedir=*) includedir=${arg#*=} ;; --with-sysdeps=*) sysdeps=${arg#*=} manualsysdeps=true ;; --with-include=*) var=${arg#*=} ; stripdir var ; addincpath="$addincpath -I$var" ;; --with-lib=*) var=${arg#*=} ; stripdir var ; addlibspath="$addlibspath -L$var" ; vpaths="$vpaths $var" ;; --with-dynlib=*) var=${arg#*=} ; stripdir var ; addlibdpath="$addlibdpath -L$var" ; vpathd="$vpathd $var" ;; --enable-shared|--enable-shared=yes) shared=true ;; --disable-shared|--enable-shared=no) shared=false ;; --enable-static|--enable-static=yes) static=true ;; --disable-static|--enable-static=no) static=false ;; --enable-allstatic|--enable-allstatic=yes) allstatic=true ;; --disable-allstatic|--enable-allstatic=no) allstatic=false ; evenmorestatic=false ;; --enable-static-libc|--enable-static-libc=yes) allstatic=true ; evenmorestatic=true ;; --disable-static-libc|--enable-static-libc=no) evenmorestatic=false ;; --enable-all-pic|--enable-all-pic=yes) allpic=true ;; --disable-all-pic|--enable-all-pic=no) allpic=false ;; --enable-slashpackage=*) sproot=${arg#*=} ; slashpackage=true ; ;; --enable-slashpackage) sproot= ; slashpackage=true ;; --disable-slashpackage) sproot= ; slashpackage=false ;; --enable-absolute-paths|--enable-absolute-paths=yes) abspath=true ;; --disable-absolute-paths|--enable-absolute-paths=no) abspath=false ;; --enable-nsss|--enable-nsss=yes) usensss=true ;; --disable-nsss|--enable-nsss=no) usensss=false ;; --skeldir=*) skeldir=${arg#*=} ;; --tmpfsdir=*) tmpfsdir=${arg#*=} ;; --enable-utmps|--enable-utmps=yes) utmps=true ;; --disable-utmps|--enable-utmps=no) utmps=false ;; --enable-*|--disable-*|--with-*|--without-*|--*dir=*) ;; --host=*|--target=*) target=${arg#*=} ;; --build=*) build=${arg#*=} ;; -* ) echo "$0: unknown option $arg" ;; *=*) ;; *) target=$arg ;; esac done # Add /usr in the default default case if test -z "$prefix" ; then if test "$libdir" = '$prefix/lib/$package' ; then libdir=/usr/lib/$package fi if test "$includedir" = '$prefix/include' ; then includedir=/usr/include fi if test "$sysdeps" = '$prefix/lib/skalibs/sysdeps' ; then sysdeps=/usr/lib/skalibs/sysdeps fi fi # Expand installation directories stripdir prefix for i in exec_prefix dynlibdir libexecdir bindir libdir includedir sysdeps sproot tmpfsdir skeldir ; do eval tmp=\${$i} eval $i=$tmp stripdir $i done # Get usable temp filenames i=0 set -C while : ; do i=$(($i+1)) tmpc="./tmp-configure-$$-$PPID-$i.c" tmpe="./tmp-configure-$$-$PPID-$i.tmp" 2>|/dev/null > "$tmpc" && break 2>|/dev/null > "$tmpe" && break test "$i" -gt 50 && fail "$0: cannot create temporary files" done set +C trap 'rm -f "$tmpc" "$tmpe"' EXIT ABRT INT QUIT TERM HUP # Set slashpackage values if $slashpackage ; then home=${sproot}/package/${category}/${package}-${version} exthome=${sproot}/package/${category}/${package} if $manualsysdeps ; then : else sysdeps=${sproot}/package/prog/skalibs/sysdeps fi extbinprefix=${exthome}/command dynlibdir=${home}/library.so bindir=${home}/command libdir=${home}/library libexecdir=$bindir includedir=${home}/include skeldir=${home}/etc/skel while read dep condvar ; do if test -n "$condvar" ; then eval "cond=$condvar" else cond=true fi if $cond ; then addincpath="$addincpath -I${sproot}${dep}/include" vpaths="$vpaths ${sproot}${dep}/library" addlibspath="$addlibspath -L${sproot}${dep}/library" vpathd="$vpathd ${sproot}${dep}/library.so" addlibdpath="$addlibdpath -L${sproot}${dep}/library.so" fi done < package/deps-build fi # Find a C compiler to use if test -n "$target" && test x${build} != x${target} ; then cross=${target}- else cross= fi echo "Checking for C compiler..." trycc ${CC} if test -n "$CC_AUTO" ; then b=`basename "$CC"` adjust_cross=false if test "$b" != "$CC" ; then adjust_cross=true echo "$0: warning: compiler $CC is declared with its own path. If it's not accessible via PATH, you will need to pass AR, RANLIB and STRIP make variables to the make invocation." 1>&2 fi if test -n "$cross" ; then if test "$b" = "${b##$cross}" ; then echo "$0: warning: compiler $CC is declared as a cross-compiler for target $target but does not start with prefix ${cross}" 1>&2 elif $adjust_cross ; then cross=`dirname "$CC"`/"$cross" fi fi fi trycc ${cross}gcc trycc ${cross}clang trycc ${cross}cc test -n "$CC_AUTO" || { echo "$0: cannot find a C compiler" ; exit 1 ; } echo " ... $CC_AUTO" echo "Checking whether C compiler works... " echo "typedef int x;" > "$tmpc" if $CC_AUTO $CPPFLAGS_AUTO $CPPFLAGS $CPPFLAGS_POST $CFLAGS_AUTO $CFLAGS $CFLAGS_POST -c -o /dev/null "$tmpc" 2>"$tmpe" ; then echo " ... yes" else echo " ... no. Compiler output follows:" cat < "$tmpe" exit 1 fi echo "Checking target system type..." if test -z "$target" ; then if test -n "$build" ; then target=$build ; else target=$($CC_AUTO -dumpmachine 2>/dev/null) || target=unknown fi fi echo " ... $target" if test ! -d $sysdeps || test ! -f $sysdeps/target ; then echo "$0: error: $sysdeps is not a valid sysdeps directory" exit 1 fi if [ "x$target" != "x$(cat $sysdeps/target)" ] ; then echo "$0: error: target $target does not match the contents of $sysdeps/target" exit 1 fi spawn_lib=$(cat $sysdeps/spawn.lib) socket_lib=$(cat $sysdeps/socket.lib) sysclock_lib=$(cat $sysdeps/sysclock.lib) timer_lib=$(cat $sysdeps/timer.lib) util_lib=$(cat $sysdeps/util.lib) if $allpic ; then tryflag CPPFLAGS_AUTO -fPIC fi tryflag CFLAGS_AUTO -std=c99 tryflag CFLAGS -fomit-frame-pointer tryflag CFLAGS_AUTO -fno-exceptions tryflag CFLAGS_AUTO -fno-unwind-tables tryflag CFLAGS_AUTO -fno-asynchronous-unwind-tables tryflag CFLAGS_AUTO -Wa,--noexecstack tryflag CFLAGS -fno-stack-protector tryflag CPPFLAGS_AUTO -Werror=implicit-function-declaration tryflag CPPFLAGS_AUTO -Werror=implicit-int tryflag CPPFLAGS_AUTO -Werror=pointer-sign tryflag CPPFLAGS_AUTO -Werror=pointer-arith tryflag CPPFLAGS_AUTO -Wno-parentheses tryflag CFLAGS_AUTO -ffunction-sections tryflag CFLAGS_AUTO -fdata-sections tryldflag LDFLAGS_AUTO -Wl,--sort-section=alignment tryldflag LDFLAGS_AUTO -Wl,--sort-common CPPFLAGS_AUTO="${CPPFLAGS_AUTO}${addincpath}" if $evenmorestatic ; then LDFLAGS_NOSHARED=-static fi if $shared ; then tryldflag LDFLAGS -Wl,--hash-style=both fi LDFLAGS_SHARED="${LDFLAGS_SHARED}${addlibdpath}" if $allstatic ; then LDFLAGS_NOSHARED="${LDFLAGS_NOSHARED}${addlibspath}" tryldflag LDFLAGS_NOSHARED -Wl,--gc-sections else LDFLAGS_NOSHARED="${LDFLAGS_NOSHARED}${addlibdpath}" fi if test -z "$vpaths" ; then while read dep ; do base=$(basename $dep) ; vpaths="$vpaths /usr/lib/$base" addlibspath="$addlibspath -L/usr/lib/$base" done < package/deps-build fi if $utmps ; then echo "Sanity checking cross-package configuration..." p=`getmacrostring utmps/config.h UTMPS_UTMPD_PATH` if isprefix "$p" "$tmpfsdir"/ ; then : ; else echo "UTMPS_UTMPD_PATH has been configured as $p which is not located under $tmpfsdir" exit 1 fi utmpd_path=${p##${tmpfsdir}/} p=`getmacrostring utmps/config.h UTMPS_WTMPD_PATH` if isprefix "$p" "$tmpfsdir"/ ; then : ; else echo "UTMPS_WTMPD_PATH has been configured as $p which is not located under $tmpfsdir" exit 1 fi wtmpd_path=${p##${tmpfsdir}/} echo " ... ok" fi echo "Creating config.mak..." cmdline=$(quote "$0") for i ; do cmdline="$cmdline $(quote "$i")" ; done exec 3>&1 1>config.mak cat << EOF # This file was generated by: # $cmdline # Any changes made here will be lost if configure is re-run. target := $target package := $package prefix := $prefix exec_prefix := $exec_prefix dynlibdir := $dynlibdir libexecdir := $libexecdir bindir := $bindir libdir := $libdir includedir := $includedir skeldir := $skeldir sysdeps := $sysdeps slashpackage := $slashpackage sproot := $sproot version := $version home := $home exthome := $exthome SPAWN_LIB := ${spawn_lib} SOCKET_LIB := ${socket_lib} SYSCLOCK_LIB := ${sysclock_lib} TIMER_LIB := ${timer_lib} UTIL_LIB := ${util_lib} CC := $CC_AUTO CPPFLAGS_AUTO := $CPPFLAGS_AUTO CPPFLAGS := $CPPFLAGS $CPPFLAGS_POST CFLAGS_AUTO := $CFLAGS_AUTO CFLAGS := $CFLAGS $CFLAGS_POST LDFLAGS_AUTO := $LDFLAGS_AUTO LDFLAGS := $LDFLAGS $LDFLAGS_POST LDFLAGS_SHARED := $LDFLAGS_SHARED LDFLAGS_NOSHARED := $LDFLAGS_NOSHARED CROSS_COMPILE := $cross vpath lib%.a$vpaths vpath lib%.so$vpathd EOF if $allstatic ; then echo ".LIBPATTERNS := lib%.a" echo "DO_ALLSTATIC := 1" else echo ".LIBPATTERNS := lib%.so" fi if $static ; then echo "DO_STATIC := 1" else echo "DO_STATIC :=" fi if $shared ; then echo "DO_SHARED := 1" else echo "DO_SHARED :=" fi if $allpic ; then echo "STATIC_LIBS_ARE_PIC := 1" else echo "STATIC_LIBS_ARE_PIC :=" fi if $usensss ; then echo "LIBNSSS := -lnsss" echo "MAYBEPTHREAD_LIB := -lpthread" else echo "LIBNSSS :=" echo "MAYBEPTHREAD_LIB :=" fi if $utmps ; then echo "LIBUTMPS := -lutmps" else echo "LIBUTMPS :=" fi exec 1>&3 3>&- echo " ... done." echo "Creating src/include/${package}/config.h..." mkdir -p -m 0755 src/include/${package} exec 3>&1 1> src/include/${package}/config.h cat <&3 3>&- echo " ... done." s6-linux-init-1.0.3.1/tools/0002755000000000000000000000000013553363665012347 5ustar s6-linux-init-1.0.3.1/tools/install.sh0000755000000000000000000000167512365207173014352 0ustar #!/bin/sh usage() { echo "usage: $0 [-D] [-l] [-m mode] src dst" 1>&2 exit 1 } mkdirp=false symlink=false mode=0755 while getopts Dlm: name ; do case "$name" in D) mkdirp=true ;; l) symlink=true ;; m) mode=$OPTARG ;; ?) usage ;; esac done shift $(($OPTIND - 1)) test "$#" -eq 2 || usage src=$1 dst=$2 tmp="$dst.tmp.$$" case "$dst" in */) echo "$0: $dst ends in /" 1>&2 ; exit 1 ;; esac set -C set -e if $mkdirp ; then umask 022 case "$2" in */*) mkdir -p "${dst%/*}" ;; esac fi trap 'rm -f "$tmp"' EXIT INT QUIT TERM HUP umask 077 if $symlink ; then ln -s "$src" "$tmp" else cat < "$1" > "$tmp" chmod "$mode" "$tmp" fi mv -f "$tmp" "$dst" if test -d "$dst" ; then rm -f "$dst/$(basename $tmp)" if $symlink ; then mkdir "$tmp" ln -s "$src" "$tmp/$(basename $dst)" mv -f "$tmp/$(basename $dst)" "${dst%/*}" rmdir "$tmp" else echo "$0: $dst is a directory" 1>&2 exit 1 fi fi s6-linux-init-1.0.3.1/tools/gen-deps.sh0000755000000000000000000000526013553363665014411 0ustar #!/bin/sh -e . package/info echo '#' echo '# This file has been generated by tools/gen-deps.sh' echo '#' echo internal_libs= for dir in src/include/${package} src/* ; do for file in $(ls -1 $dir | grep -- \\.h$) ; do { grep -F -- "#include <${package}/" < ${dir}/$file | cut -d'<' -f2 | cut -d'>' -f1 ; grep -- '#include ".*\.h"' < ${dir}/$file | cut -d'"' -f2 } | sort -u | { deps= while read dep ; do if echo $dep | grep -q "^${package}/" ; then deps="$deps src/include/$dep" elif test -f "${dir}/$dep" ; then deps="$deps ${dir}/$dep" else deps="$deps src/include-local/$dep" fi done if test -n "$deps" ; then echo "${dir}/${file}:${deps}" fi } done done for dir in src/* ; do for file in $(ls -1 $dir | grep -- \\.c$) ; do { grep -F -- "#include <${package}/" < ${dir}/$file | cut -d'<' -f2 | cut -d'>' -f1 ; grep -- '#include ".*\.h"' < ${dir}/$file | cut -d'"' -f2 } | sort -u | { deps=" ${dir}/$file" while read dep ; do if echo $dep | grep -q "^${package}/" ; then deps="$deps src/include/$dep" elif test -f "${dir}/$dep" ; then deps="$deps ${dir}/$dep" else deps="$deps src/include-local/$dep" fi done o=$(echo $file | sed s/\\.c$/.o/) lo=$(echo $file | sed s/\\.c$/.lo/) echo "${dir}/${o} ${dir}/${lo}:${deps}" } done done echo for dir in $(ls -1 src | grep -v ^include) ; do for file in $(ls -1 src/$dir/deps-lib) ; do deps= libs= while read dep ; do if echo $dep | grep -q -e ^-l -e '^\${.*_LIB}' ; then libs="$libs $dep" else deps="$deps src/$dir/$dep" fi done < src/$dir/deps-lib/$file echo 'ifeq ($(strip $(STATIC_LIBS_ARE_PIC)),)' echo "lib${file}.a.xyzzy:$deps" echo else echo "lib${file}.a.xyzzy:$(echo "$deps" | sed 's/\.o/.lo/g')" echo endif if grep -F "LIB_DEFS :=" package/targets.mak | grep -qF "$file" ; then echo "lib${file}.so.xyzzy: EXTRA_LIBS :=$libs" echo "lib${file}.so.xyzzy:$(echo "$deps" | sed 's/\.o/.lo/g')" else internal_libs="$internal_libs lib${file}.a.xyzzy" fi done for file in $(ls -1 src/$dir/deps-exe) ; do deps= libs= while read dep ; do if echo $dep | grep -q -- \\.o$ ; then dep="src/$dir/$dep" fi if echo $dep | grep -q -e ^-l -e '^\${.*_LIB}' ; then libs="$libs $dep" else deps="$deps $dep" fi done < src/$dir/deps-exe/$file echo "$file: EXTRA_LIBS :=$libs" echo "$file: src/$dir/$file.o$deps" done done echo "INTERNAL_LIBS :=$internal_libs" s6-linux-init-1.0.3.1/NEWS0000644000000000000000000000353313553361144011676 0ustar Changelog for s6-linux-init. In 1.0.3.1 ---------- - Bugfixes. In 1.0.3.0 ---------- - Compatibility with skalibs-2.9.0.0. - s6-linux-init now activates ctrl-alt-del management by default (no need to manually configure it via sysctl in stage 2 anymore.) In 1.0.2.1 ---------- - Bugfixes. In 1.0.2.0 ---------- - New -H and -P options to s6-linux-init-shutdown, for better compatibility with sysvinit shutdown. In 1.0.1.0 ---------- - New -f option to s6-linux-init-maker, for use in distribution packaging scripts with a staging directory. - Better permissions on the binaries. - The skeleton runlevel script now includes a guard to avoid calling the service manager without an argument. - /run/uncaught-logs directory permissions changed to 02750. In 1.0.0.0 ---------- - Complete rework; see the documentation overview. - s6-halt, s6-poweroff, s6-reboot removed. - s6-linux-init-maker now produces a set of executable scripts that are a drop-in replacement for a sysvinit installation, and that respect the LSB-3.0.0 specification. - utmp management, runlevel management. - See doc/upgrade.html if rebooting from a system using a previous version of s6-linux-init. In 0.4.0.1 ---------- - Compatibility with skalibs-2.8.0.0. - Everything now builds as PIC by default. In 0.4.0.0 ---------- - The old /etc/rc.shutdown is now created by s6-linux-init-maker and is not the user's responsibility anymore. - /etc/rc.tini is now named /etc/rc.shutdown. In summary: now, /etc/rc.shutdown marks the end of stage 2, not stage 3, and stage 3 is all automatically generated. In 0.3.1.1 ---------- - Build bug fix from 0.3.1.0. In 0.3.1.0 ---------- - Support for running in Linux containers In 0.3.0.0 ---------- - Added this NEWS file. :) - Major types overhaul to make them more POSIXly correct: compatibility with skalibs-2.5.0.0. s6-linux-init-1.0.3.1/Makefile0000644000000000000000000001104113515356750012635 0ustar # # This Makefile requires GNU make. # # Do not make changes here. # Use the included .mak files. # it: all make_need := 3.81 ifeq "" "$(strip $(filter $(make_need), $(firstword $(sort $(make_need) $(MAKE_VERSION)))))" fail := $(error Your make ($(MAKE_VERSION)) is too old. You need $(make_need) or newer) endif CC = $(error Please use ./configure first) STATIC_LIBS := SHARED_LIBS := INTERNAL_LIBS := EXTRA_TARGETS := LIB_DEFS := define library_definition LIB$(firstword $(subst =, ,$(1))) := lib$(lastword $(subst =, ,$(1))).$(if $(DO_ALLSTATIC),a,so).xyzzy ifdef DO_SHARED SHARED_LIBS += lib$(lastword $(subst =, ,$(1))).so.xyzzy endif ifdef DO_STATIC STATIC_LIBS += lib$(lastword $(subst =, ,$(1))).a.xyzzy endif endef -include config.mak include package/targets.mak $(foreach var,$(LIB_DEFS),$(eval $(call library_definition,$(var)))) include package/deps.mak version_m := $(basename $(version)) version_M := $(basename $(version_m)) version_l := $(basename $(version_M)) CPPFLAGS_ALL := $(CPPFLAGS_AUTO) $(CPPFLAGS) CFLAGS_ALL := $(CFLAGS_AUTO) $(CFLAGS) ifeq ($(strip $(STATIC_LIBS_ARE_PIC)),) CFLAGS_SHARED := -fPIC else CFLAGS_SHARED := endif LDFLAGS_ALL := $(LDFLAGS_AUTO) $(LDFLAGS) AR := $(CROSS_COMPILE)ar RANLIB := $(CROSS_COMPILE)ranlib STRIP := $(CROSS_COMPILE)strip INSTALL := ./tools/install.sh ALL_BINS := $(LIBEXEC_TARGETS) $(BIN_TARGETS) ALL_LIBS := $(SHARED_LIBS) $(STATIC_LIBS) $(INTERNAL_LIBS) ALL_INCLUDES := $(wildcard src/include/$(package)/*.h) all: $(ALL_LIBS) $(ALL_BINS) $(ALL_INCLUDES) clean: @exec rm -f $(ALL_LIBS) $(ALL_BINS) $(wildcard src/*/*.o src/*/*.lo) $(EXTRA_TARGETS) distclean: clean @exec rm -f config.mak src/include/$(package)/config.h tgz: distclean @. package/info && \ rm -rf /tmp/$$package-$$version && \ cp -a . /tmp/$$package-$$version && \ cd /tmp && \ tar -zpcv --owner=0 --group=0 --numeric-owner --exclude=.git* -f /tmp/$$package-$$version.tar.gz $$package-$$version && \ exec rm -rf /tmp/$$package-$$version strip: $(ALL_LIBS) $(ALL_BINS) ifneq ($(strip $(STATIC_LIBS)),) exec $(STRIP) -x -R .note -R .comment -R .note.GNU-stack $(STATIC_LIBS) endif ifneq ($(strip $(ALL_BINS)$(SHARED_LIBS)),) exec $(STRIP) -R .note -R .comment -R .note.GNU-stack $(ALL_BINS) $(SHARED_LIBS) endif install: install-dynlib install-libexec install-bin install-lib install-include install-dynlib: $(SHARED_LIBS:lib%.so.xyzzy=$(DESTDIR)$(dynlibdir)/lib%.so) install-libexec: $(LIBEXEC_TARGETS:%=$(DESTDIR)$(libexecdir)/%) install-bin: $(BIN_TARGETS:%=$(DESTDIR)$(bindir)/%) install-lib: $(STATIC_LIBS:lib%.a.xyzzy=$(DESTDIR)$(libdir)/lib%.a) install-include: $(ALL_INCLUDES:src/include/$(package)/%.h=$(DESTDIR)$(includedir)/$(package)/%.h) ifneq ($(exthome),) $(DESTDIR)$(exthome): $(DESTDIR)$(home) exec $(INSTALL) -l $(notdir $(home)) $(DESTDIR)$(exthome) update: $(DESTDIR)$(exthome) global-links: $(DESTDIR)$(exthome) $(SHARED_LIBS:lib%.so.xyzzy=$(DESTDIR)$(sproot)/library.so/lib%.so.$(version_M)) $(BIN_TARGETS:%=$(DESTDIR)$(sproot)/command/%) $(DESTDIR)$(sproot)/command/%: $(DESTDIR)$(home)/command/% exec $(INSTALL) -D -l ..$(subst $(sproot),,$(exthome))/command/$( s6-linux-init: the s6-linux-init-telinit program

s6-linux-init
Software
skarnet.org

The s6-linux-init-telinit program

s6-linux-init-telinit changes runlevels, i.e. changes the system state. It is normally invoked as /sbin/telinit or just init with an argument.

Interface 

     s6-linux-init-telinit rl
  • s6-linux-init-telinit may be called with the same options as s6-linux-init, but it ignores them all.
  • It calls the runleveld local service with the rl argument. This local service executes the user-provided runlevel script, which changes the system state to the state described by rl.
  • As a special case, if rl is 0 or 6, s6-linux-init-telinit then executes into s6-linux-init-hpr with the -p or -r option respectively, for compatibility with sysvinit's 0 and 6 runlevels that respectively halt and reboot the machine.

Exit codes

  • 100: wrong usage
  • 111: system call failed
  • Else, s6-linux-init-telinit exits with the same exit code as the runlevel script called with the rl argument.
  • If rl is 0 or 6, in case of success s6-linux-init-telinit exits 0, but the system shuts down immediately as it returns.

Notes

  • Traditional sysvinit only allows integer runlevels, from 0 to 6. More advanced service managers, like OpenRC or s6-rc, allow the admin to define alphanumerical runlevels, or states. s6-linux-init-telinit does not implement policy; it only makes sure the user-provided runlevel script is called with the rl argument, under a safe and reproducible environment. The runlevel script can then change the machine state as chosen by the user - typically by invoking the service manager.
  • The 0 and 6 special case has been added because some legacy programs may assume that calling init 0 and init 6 respectively halt and reboot the system.
  • The s6-linux-init-telinit binary is not meant to be called directly by administrators. Instead, after a s6-linux-init-maker invocation, the bin/ subdirectory of the target will contain a telinit symlink to s6-linux-init-telinit. The bin/ subdirectory should be copied by the administrator into /sbin for full interface compatibility with sysvinit.
s6-linux-init-1.0.3.1/doc/s6-linux-init.html0000644000000000000000000001617713502374062015265 0ustar s6-linux-init: the s6-linux-init program

s6-linux-init
Software
skarnet.org

The s6-linux-init program

s6-linux-init is a program that is meant to run as pid 1, as a stage 1 init: it performs the necessary early system preparation and execs into s6-svscan.

Interface 

     s6-linux-init [ -c basedir ] [ -p initial_path ] [ -s env_store ] [ -m umask ] [ -d slashdev ] [ -D initdefault ] [ -n | -N ] [ args... ]
  • If s6-linux-init isn't pid 1, it execs into s6-linux-init-telinit with the same arguments.
  • Else, it performs some early preparation, spawns a process that will run the rc.init script, then execs into s6-svscan.

Options

These options should exactly mirror the options with the same name that have been given to s6-linux-init-maker. If there is a discrepancy, the system might not boot.

  • -c basedir : read all its initialization data from basedir. If the data has not indeed been copied to basedir, the system will not boot.
  • -p initial_path : the initial value for the PATH environment variable.
  • -s env_store : the place where to dump kernel environment variables.
  • -m initial_umask : the initial file umask.
  • -d slashdev : mount a devtmpfs on slashdev. By default, no such mount is performed - it is assumed that a devtmpfs is automounted on /dev at boot time by the kernel.
  • -D initdefault : the initial runlevel to boot to, if it isn't overridden by the kernel command line. This is only given as a first argument to rc.init. Default is default.
  • -n : instead of unmounting /run and mounting a tmpfs on it, just remount /run.
  • -N : do not touch /run at all.

Early preparation

When booting a system, s6-linux-init performs the following operations:

  • It prints a banner to /dev/console.
  • It chdirs to /.
  • It sets the umask to initial_umask.
  • It becomes a session leader.
  • It mounts a devtmpfs on slashdev, if requested.
  • It uses /dev/null as its stdin (instead of /dev/console). /dev/console is still used, for now, as stdout and stderr.
  • It unmounts /run (or the directory you have given to the --tmpfsdir configure option at package build time), just in case; then it creates a tmpfs on it. Alternatively, it remounts /run, or does not touch it at all.
  • It copies the whole basedir/run-image hierarchy to /run (or your chosen tmpfsdir).
  • It reads the initial environment from basedir/env.
  • If required, it stores the kernel environment into env_store.
  • It performs "the fifo trick", i.e. it redirects its stdout to the catch-all logger's fifo, without blocking, before the catch-all logger is even up (because it's a service that will be spawned a bit later, when s6-svscan is executed).
  • It forks a child.
    • The child scans the kernel command line to find a suitable runlevel (default, 2, 3, 4, or 5). If it doesn't find any kernel command line argument that defines a runlevel, it uses initdefault.
    • The child becomes a session leader.
    • The child blocks until the catch-all logger runs.
  • It also makes the catch-all logger's fifo its stderr.
  • It execs into s6-svscan with /run/service as its scandir (or tmpfsdir/service).
    • s6-svscan spawns the early services that are defined in basedir/run-image/service, and have been copied into /run/service (or tmpfsdir/service).
    • One of those early services is s6-svscan-log, which is the catch-all logger. When this service is up, s6-linux-init's child unblocks.
    • The child execs into basedir/scripts/rc.init. The first argument to rc.init is the chosen runlevel. The kernel command line, as given by the kernel to s6-linux-init (i.e. without the key=value arguments, which were passed into s6-linux-init's environment and were stored into env_store), makes for the rest of the arguments given to rc.init.

By the time rc.init runs, s6-svscan is running as pid 1 and has spawned its early services - at least the catch-all logger, and the other services, including the early getty if it has been defined, are started in parallel and will be ready instantly. rc.init can then perform stage 2 of the initialization process, i.e. the handoff to the service manager.

Exit codes

s6-linux-init never exits. It spawns the rc.init script and execs into s6-svscan, which runs forever until the machine stops or reboots.

Notes

  • The s6-linux-init binary is not meant to be called directly, or be linked to /sbin/init directly, because it takes command-line options. Instead, after a s6-linux-init-maker invocation, the bin/ subdirectory of the target will contain a script called init, which execs into s6-linux-init with the appropriate command-line options, and is suitable as a /sbin/init program. The bin/ subdirectory should be copied by the administrator into /sbin for full interface compatibility with sysvinit.
s6-linux-init-1.0.3.1/doc/s6-linux-init-shutdownd.html0000644000000000000000000000544513546441455017307 0ustar s6-linux-init: the s6-linux-init-shutdownd program

s6-linux-init
Software
skarnet.org

The s6-linux-init-shutdownd program

s6-linux-init-shutdownd is the daemon that manages the shutdown procedure for a s6-linux-init installation. It is not meant to be called directly by the user.

Interface 

     s6-linux-init-shutdownd [ -c basedir ] [ -g gracetime ]
  • s6-linux-init-shutdownd opens a named pipe in its current directory and listens to it. This fifo has a fixed, internal, name: this is a rendezvous point where programs such as s6-linux-init-shutdown send their commands when they are told to trigger the shutdown procedure.
  • When it receives a command to shut down, s6-linux-init-shutdownd first spawns the rc.shutdown script defined by the s6-linux-init-maker invocation that created the shutdownd service.
  • When this script exits, s6-linux-init-shutdownd kills all processes, first with a SIGTERM, then (after the grace time specified by the shutdown command) with a SIGKILL.
  • It then runs an automatically-generated script (called stage 4), which unmounts the file systems and halts, powers off or reboots the machine.

Options

  • -c basedir : look for the rc.shutdown script in the basedir/scripts directory. Default is /etc/s6-linux-init/current.
  • -g gracetime : if the shutdown command does not specify a grace time between the SIGTERM and the SIGKILL, use gracetime milliseconds. Default is 3000.

Notes

s6-linux-init-1.0.3.1/doc/index.html0000644000000000000000000001351613553361374013750 0ustar s6-linux-init - tools for a Linux init system

Software
skarnet.org

s6-linux-init

What is it ?

s6-linux-init is a set of minimalistic tools used to create a s6-based init system, including a /sbin/init binary, on a Linux kernel.

The resulting architecture follows the Unix philosophy (one job → one tool) as closely as possible, and is fully dedicated to the s6 way of managing a system:

  • s6-svscan runs as process 1 for the whole machine lifetime.
  • Every daemon is supervised.
  • No logs are ever lost.
  • Policy is entirely left to the user. Typically, any service manager can be run on top of s6-linux-init.

Nevertheless, the architecture is fully compliant with various empirical and historical specifications. For instance, it provides:

  • utmp management compatible with sysvinit
  • runlevel management, with a configurable default, overridable from the kernel command line
  • sysvinit-like commands to shut the system down, including a shutdown command that follows the LSB specification

Installation

Requirements

  • A Linux-based system with a standard C development environment
  • GNU make, version 3.81 or later
  • skalibs version 2.9.1.0 or later
  • execline version 2.5.3.0 or later
  • s6 version 2.9.0.1 or later

The following optional dependencies are also supported:

  • If you're using musl and want nsswitch-like functionality: nsss version 0.0.2.1 or later
  • If you want secure utmp functionality: utmps version 0.0.3.1 or later

All those dependencies are build-time and run-time, except possibly skalibs, which is not needed at run time if you are linking all the other packages against the static version of libskarnet.

Licensing

s6-linux-init is free software. It is available under the ISC license.

Download

  • The current released version of s6-linux-init is 1.0.3.1.
  • Alternatively, you can checkout a copy of the s6-linux-init git repository: 
     git clone git://git.skarnet.org/s6-linux-init
  • There's also a GitHub mirror of the s6-linux-init git repository.

Compilation

  • See the enclosed INSTALL file for installation details.

Upgrade notes

  • This page lists the differences to be aware of between the previous versions of s6-linux-init and the current one.

Reference

General

Commands

Unless more details are provided in an Exit codes section of a specific page, all these commands exit 0 on success, 111 if they encounter a temporary error (such as a system call failure) and 100 if they encounter a permanent error (such as a misuse).

Related resources

  • s6-linux-init is discussed on the skaware and supervision mailing-lists.
  • There is a #s6 IRC channel on Freenode. Sometimes people are there and even answer questions.
s6-linux-init-1.0.3.1/doc/s6-linux-init-logouthookd.html0000644000000000000000000000711613463713373017622 0ustar s6-linux-init: the s6-linux-init-logouthookd program

s6-linux-init
Software
skarnet.org

The s6-linux-init-logouthookd program

s6-linux-init-logouthookd cleans up its client's utmp record when it dies.

Interface 

     s6-ipcserver socket s6-linux-init-logouthookd

s6-linux-init-logouthookd implements a local service for getty programs that add an utmp record when a user logs in.

In the sysvinit model, getty/login and similar programs add an utmp record for every user that logs in, then exec into the user's shell. At logout time, the shell dies; sysvinit is supervising the getty program, so it's watching the pid, and respawns the getty when the shell dies. But before respawning the getty, it cleans up the utmp record, to correctly report that the user isn't logged in on this terminal anymore.

utmp is an old, clunky, insecure system (unless you're using utmps) and it is definitely not pid 1's job to have any knowledge of utmp and play janitor after getty. s6-svscan definitely will not do it.

Some distributions use versions of login that fork the user's shell instead of execing it. When the user logs out, the login program cleans up after itself. This is a better model, but it's not always easy to patch login to go from a "exec the shell" model to a "fork the shell as a child" model.

s6-linux-init comes with a small library which makes it easy for a distribution to fully support utmp cleanup with an s6 init system if they so choose. Before execing into the user's shell, the login program should just make a call to s6_linux_init_logouthook(), and that's it. That function will call the s6-linux-init-logouthookd local service, which will do nothing but wait until the user's shell dies; and when it happens, the user's utmp record will automatically be cleaned up.

Exit codes

s6-linux-init-logouthookd's exit code does not matter, because no program uses it. However, here's the list for completeness:

  • 0: success, whether or not there was an utmp record to clean up.
  • 1: connection attempt from a non-root user.
  • 2: write attempt from a (misprogrammed) client.
  • 111: system call failed.

Notes

  • The local service implementing logouthook support is automatically created at boot time when the -L option has been given to s6-linux-init-maker. Client-side, though, the various login programs must be patched at the source level.
s6-linux-init-1.0.3.1/doc/s6-linux-init-umountall.html0000644000000000000000000000555613526512002017274 0ustar s6-linux-init: the s6-linux-init-umountall program

s6-linux-init
Software
skarnet.org

The s6-linux-init-umountall program

s6-linux-init-umountall unmounts all filesystems.

Interface 

     s6-linux-init-umountall
  • s6-linux-init-umountall unmounts all filesystems according to /proc/mounts. It processes /proc/mounts in the reverse order, starting with the most recently mounted partition and ending with the root filesystem ("unmounting" the root filesystem means remounting it read-only).
  • It makes an exception for the first instances of devtmpfs, proc and sysfs filesystem types, but not for later instances. In other words: it does not attempt to unmount /dev, /proc and /sys, but it will attempt to unmount duplicates of those pseudo-filesystems.
  • s6-linux-init-umountall does not touch /etc/mtab.
  • If a filesystem fails to unmount, a warning is printed to stderr, but s6-linux-init-umountall still attempts to unmount all the other ones.

Exit codes

s6-linux-init-umountall returns the number of errors it encountered when attempting to unmount the filesystems listed in /proc/mounts.

Notes

  • s6-linux-init-umountall is automatically called at the very end of the shutdown procedure, in "stage 4", i.e. after a SIGKILL has been sent to all the processes on the system, and right before the system reboots (or halts, or is powered off). By that point, there is no possible process that could prevent real file systems from being unmounted.
  • It is likely that some filesystems will still fail to unmount, typically cgroups or tmpfses. That's okay: those are pseudo-filesystems, and will not cause data loss or a fsck if the system shuts down while they are still mounted.
  • Distributions usually provide a umount command with a -a option to unmount all filesystems. That command is usually bloated with historical artifacts and relies on unsafe interfaces, so it was decided not to use it.
s6-linux-init-1.0.3.1/doc/why.html0000644000000000000000000001214413463713373013444 0ustar s6-linux-init: why?

s6-linux-init
Software
skarnet.org

Why s6-linux-init ?

The s6 software stack

The s6 ecosystem is made of several parts, which are mainly the following:

  • skalibs: a C system programming library that is used in all skarnet.org software.
  • execline: a small scripting language that is mainly used in various parts of the s6 ecosystem because:
    • It is very quick to launch, and efficient with small scripts, so it is a good choice for s6 run scripts.
    • It is much easier to programmatically generate execline scripts than shell scripts. execline allows programs such as s6-linux-init-maker to generate scripts quite easily, whereas using the shell syntax would require them to understand the full subleties of shell quoting.
  • s6, the main dish: a process supervision suite.
  • s6-rc: a service manager for s6.
  • and s6-linux-init: this package.

Providing a complete init system

As explained in this presentation, an init system is made of four parts:

  1. /sbin/init: the first userspace program that is run by the kernel at boot time (not counting an initramfs).
  2. pid 1: the program that will run as process 1 for most of the lifetime of the machine. This is not necessarily the same executable as /sbin/init, because /sbin/init can exec into something else.
  3. a process supervisor.
  4. a service manager.

The s6 package obviously provides part 3. It also provides part 2, because s6-svscan is suitable as being pid 1 after some small setup is performed.

Part 4, service management, can be provided in a variety of ways. The s6-rc service manager is the natural complement to the s6 process supervisor, but it is not the only possibility. The anopa package also provides a service manager designed to work with s6. And, at the expense of tight integration with the supervisor, it is possible to run a "traditional" service manager, such as sysv-rc or OpenRC, with an s6-based init system. This flexibility is possible because service management is one layer above the mechanisms of init and process supervision.

Remains part 1. And that's where s6-linux-init enters the picture.

Portability

Part 1 of an init system, the /sbin/init program, has been purposefully omitted from the main s6 package, for a simple reason: s6 aims to be portable to any flavor of Unix, and it is impossible to implement /sbin/init in a portable way.

For instance, to do its job, s6-svscan needs a writable directory. Such a directory may not be available at boot time, before mounting filesystems, because the root filesystem may be read-only. So, at least one writable filesystem (typically a RAM-backed one) must be mounted before s6-svscan can be executed and be pid 1. And mounting a filesystem is a non-portable operation.

Complexity

Moreover, the sequence of operations that a /sbin/init program needs to perform before executing into s6-svscan is a bit tricky. It can be scripted, but it's not easy, and since it's so early in the lifetime of the machine, there's no safety net at all (the supervision tree itself, and the early getty, are supposed to be the safety net, and they're not there yet). So it's better to automate these operations.

Conclusion

s6-linux-init aims to provide a fully functional /sbin/init program that executes into an s6 supervision tree with all the necessary support services already in place, as well as the corresponding shutdown commands. It also aims to be flexible enough to accommodate various needs and be compatible with any user-chosen service manager.

As usual, it is about mechanism, not policy.

s6-linux-init-1.0.3.1/doc/quickstart.html0000644000000000000000000000462513502373464015031 0ustar s6-linux-init: quickstart

s6-linux-init
Software
skarnet.org

Quickstart for s6-linux-init

Quickstart

  1. Install all the s6-linux-init dependencies:
  2. Save and remove your old /etc/s6-linux-init directory, if you have one.
  3. Install s6-linux-init itself.
  4. Save your old /sbin/init, /sbin/telinit, /sbin/shutdown, /sbin/halt, /sbin/poweroff and /sbin/reboot binaries.
  5. Make sure you have a /run directory.
  6. Edit the scripts in /etc/s6-linux-init/skel.
  7. Check that your devtmpfs is automounted by your kernel at boot time. If it is not, add the -d /dev option to the s6-linux-init-maker command line below.
  8. As root, run: 
         rm -rf /tmp/blah
     s6-linux-init-maker -1 -G "/sbin/getty 38400 tty1" /tmp/blah
     rm -rf /etc/s6-linux-init/current
     mv /tmp/blah /etc/s6-linux-init/current
     cp -a /etc/s6-linux-init/current/bin/* /sbin/
  9. Reboot. Warning: use your old reboot command, that you saved, not the new one that has just been created by s6-linux-init-maker, because you're still running on your old init system and need to use a reboot command that matches it.
  10. After the reboot: congratulations! your machine is now running a s6-based init system.
  11. To shut the machine down, use /sbin/shutdown, /sbin/halt, /sbin/poweroff or /sbin/reboot as usual.
s6-linux-init-1.0.3.1/doc/s6-linux-init-echo.html0000644000000000000000000000534613463713373016205 0ustar s6-linux-init: the s6-linux-init-echo program

s6-linux-init
Software
skarnet.org

The s6-linux-init-echo program

s6-linux-init-echo writes its arguments to stdout.

Interface 

     s6-linux-init-echo [ -n ] [ -s sep ] args...

s6-linux-init-echo writes its arguments args to stdout, separated with spaces.

Options

  • -n : do not output a trailing newline.
  • -s sep : separate arguments with the sep character instead of a space.

Notes

  • Strange, and appalling, as it may seem for such a simple task, there is no way to ensure that the echo program will behave consistently from Unix system to Unix system - and even from Linux distribution to Linux distribution. Despite there being a standard for it, the echo commands in GNU coreutils, busybox, toybox, sbase, and other implementations basically all exhibit different behaviours. Every shell has a built-in echo command, that fails to follow the POSIX standard. echo is the prime example of the consequences of the blatant disregard of early Unices for cross-system compatibility, and its followup as a turf war between GNU and the rest of the Linux world. As a distribution-agnostic software developer, it is ironically impossible to rely on a definite behaviour of the echo command on every supported system, and that is why s6-linux-init provides its own implementation. Fortunately, it is very easy to do so, with minimal overhead.
  • This command is an exact duplicate of the s6-echo command provided in the s6-portable-utils package. It was decided not to have a dependency from s6-linux-init to s6-portable-utils: that dependency would arguably be a higher cost than the small amount of code duplication.
s6-linux-init-1.0.3.1/doc/upgrade.html0000644000000000000000000002126513553361512014262 0ustar s6-linux-init: how to upgrade

s6-linux-init
Software
skarnet.org

What has changed in s6-linux-init

in 1.0.3.1

  • skalibs dependency bumped to 2.9.1.0.
  • execline dependency bumped to 2.5.3.0.
  • s6 dependency bumped to 2.9.0.1.
  • nsss optional dependency bumped to 0.0.2.1.
  • utmps optional dependency bumped to 0.0.3.1.

in 1.0.3.0

  • skalibs dependency bumped to 2.9.0.0.
  • execline dependency bumped to 2.5.2.0.
  • s6 dependency bumped to 2.9.0.0.
  • nsss optional dependency bumped to 0.0.2.0.
  • utmps optional dependency bumped to 0.0.3.0.
  • Ctrl-Alt-Del management is now activated by default, instead of requiring a sysctl setting in stage 2.
  • s6-linux-init-umountall now skips the first instance of /dev, /proc and sys.
  • stage 4 (after every process has been killed and the filesystems have been unmounted) now calls a new user script, rc.shutdown.final.

in 1.0.2.1

  • utmps optional dependency bumped to 0.0.2.2.

in 1.0.2.0

in 1.0.1.0

  • -f option added to s6-linux-init-maker for use in distribution packaging scripts with a staging directory.
  • Permissions on the binaries have been adjusted.
  • The skeleton runlevel script now includes a guard to avoid calling the service manager without an argument.
  • The permissions of the /run/uncaught-logs directory in the generated image have been changed to 02750.

in 1.0.0.0

  • This is a complete rewrite and redesign of s6-linux-init: the lifetime version number has increased. No compatibility whatsoever is retained with previous versions.
  • When rebooting after upgrading from a 0.4.0.x version of s6-linux-init to 1.0.0.0: the s6-reboot command, which is needed for the 0.4.0.x shutdown procedure, may not be accessible via PATH anymore. Make sure to have (a copy of) s6-reboot available in your PATH; you can remove it after rebooting on the new system.

in 0.4.0.1

in 0.4.0.0

  • skalibs dependency bumped to 2.6.4.0.
  • execline dependency bumped to 2.3.0.4.
  • s6 dependency bumped to 2.7.1.0.
  • s6-linux-init-maker now autogenerates stage 3, which is not the responsibility of the user anymore (stage 3 was previously the user-written /etc/rc.shutdown script).
  • The default user-provided "end of stage 2, bring down services" script was named /etc/rc.tini before; now it's named /etc/rc.shutdown.
  • Everything now builds as PIC by default no matter the toolchain's settings. Use the --disable-all-pic configure option to build executables and static libraries as non-PIC.

in 0.3.1.1

  • No functional changes

in 0.3.1.0

in 0.3.0.0

in 0.2.0.0

in 0.1.0.0

in 0.0.1.4

in 0.0.1.3

  • skalibs dependency bumped to 2.3.6.1.

in 0.0.1.2

  • s6 dependency bumped to 2.1.6.0.

in 0.0.1.1

  • s6 dependency bumped to 2.1.5.0.
s6-linux-init-1.0.3.1/doc/overview.html0000644000000000000000000001616013526520215014474 0ustar s6-linux-init: overview

s6-linux-init
Software
skarnet.org

An overview of s6-linux-init

Organisation of the package

When installed, the s6-linux-init package provides the following:

  • Binaries, that are typically installed in /bin:
    • s6-linux-init-maker is the main program of the package and is used to create /sbin/init scripts and their supporting environment depending on configuration parameters given on its command line.
    • s6-linux-init-hpr is an implementation of the SysV halt, poweroff and reboot commands; s6-linux-init-telinit is an implementation of the SysV telinit command; and s6-linux-init-shutdown is an implementation of the shutdown command. s6-linux-init is an implementation of stage 1 /sbin/init, but it needs to be given command-line options in order to do what the user has chosen. An invocation of s6-linux-init-maker will create proper wrappers for all those commands, named after their short SysV names; the wrappers are directly usable as turnkey replacements for SysV commands.
    • Other binaries are support binaries, not meant to be called directly by the user. They are called internally, in scripts created by a s6-linux-init-maker invocation - typically in run scripts for early services.

  • A small library, that for now contains a single symbol, s6_linux_init_logouthook(), intended for distributions using login programs that add utmp entries for users logging in and expect init to clean up after them when users log out. See the s6-linux-init-logouthookd page for details.

  • Skeleton scripts, installed by default in /etc/s6-linux-init/skel; that location can be changed at build time via the --skeldir configure option. At s6-linux-init-maker invocation time, the scripts are copied from the skeleton directory to the scripts subdirectory of the directory created by s6-linux-init-maker, and the copy is meant to be edited by the user. The skeleton scripts are commented and examples of interaction with various service managers are given; it is recommended to review them, and possibly edit them too. These scripts are the following:
    • rc.init: the script launching the system initialization procedure once stage 1 init is done and s6-svscan is safely running as pid 1.
    • rc.shutdown: the script launching the system shutdown procedure when the admin runs a halt, poweroff, reboot or shutdown command.
    • runlevel: the script executing a machine state change at boot time (normally invoked by rc.init, towards the default runlevel) or when the administrator runs a telinit command.
    • rc.shutdown.final: a script that will be run at the very end of the shutdown procedure, after all processes have been killed and all filesystems have been unmounted, just before the system is rebooted or the power turned off. This script normally remains empty.

Organisation of the booted system

When a system has booted on an /sbin/init program created by s6-linux-init-maker, the following invariants are met:

  • A tmpfs is mounted on /run - that location can be changed at build-time via the --tmpfsdir option to configure. The rest of this document assumes it is /run.
  • s6-svscan is running as pid 1 on the /run/service scandir.
  • Every process on the system is running with at least the environment defined in the /etc/s6-linux-init/current/env envdir. The /etc/s6-linux-init/current location can be changed at s6-linux-init-maker invocation time via the -c option.
  • Some early services are defined in /run/service, and running. They are not seen by the service manager and should remain up all the time, until the machine shuts down: they are considered a part of the init system, even if they're not process 1. Each of these services uses very few resources. The services are:
    • s6-svscan-log: the catch-all logger
    • s6-linux-init-shutdownd: the shutdown manager, running the shutdown sequence in a reproducible environment when a shutdown command is executed, then performing the last shutdown steps.
    • s6-linux-init-runleveld: the runlevel manager, running the runlevel script in a reproducible environment when a telinit command is executed.
    • (optionally) s6-linux-init-logouthookd: a local service performing utmp record cleanup duty for patched login programs.
    • (optionally) s6-linux-init-early-getty: the early getty, allowing the user to login even if rc.init fails early.
    • (optionally) utmpd and wtmpd: the services performing utmp and wtmp access when utmps is used.

Integration with the service manager

The s6-linux-init package's duties stop where the service manager's start. s6-linux-init simply brings the system up to the point where it is stable and operational enough for the service manager to take over; and at shutdown time, s6-linux-init just tells the service manager to bring down the services, and then performs the last steps of the shutdown: killing all the remaining processes, unmounting the file systems and halting/powering off/rebooting the machine.

All the interactions between s6-linux-init and the service manager are configurable: they happen in the rc.init, rc.shutdown and runlevel scripts. Examples are provided in the skeleton scripts, that you should review and edit.

s6-linux-init-1.0.3.1/doc/s6-linux-init-maker.html0000644000000000000000000005172213504177662016366 0ustar s6-linux-init: the s6-linux-init-maker program

s6-linux-init
Software
skarnet.org

The s6-linux-init-maker program

s6-linux-init-maker reads configuration options on the command line, and outputs a directory to place in the root filesystem. That directory contains a script that is suitable as an /sbin/init program as well as all the necessary files that this script needs to properly boot and bring up a full s6 infrastructure.

s6-linux-init-maker only writes scripts. At boot time, these scripts will call commands provided by other skarnet.org packages such as execline and s6. It is the responsibility of the administrator to make sure that all the dependencies are properly installed at boot time, and that the correct options have been given to s6-linux-init-maker so that the programs are found on the root filesystem of the machine. If it is not the case, the system will fail to boot.

Interface and usage 

     s6-linux-init-maker \
       [ -c basedir ] \
       [ -u log_user ] \
       [ -G early_getty ] \
       [ -1 ] \
       [ -L ] \
       [ -p initial_path ] \
       [ -m initial_umask ] \
       [ -t timestamp_style ] \
       [ -d slashdev ] \
       [ -s env_store ] \
       [ -e initial_envvar ] ... \
       [ -q finalsleeptime ] \
       [ -D initdefault ] \
       [ -n | -N ] \
       [ -f skeldir ] \
       [ -U utmp_user ] \
       dir
  • s6-linux-init-maker must be run as root, on the machine that will boot an s6-based system.
  • s6-linux-init-maker parses options on its command line.
  • It writes data into a directory dir, which must not exist beforehand.
  • It exits 0 if everything went well, 100 if a user error occurred, and 111 if a problem occurred during the creation of the directory or its contents.

Once the command has been run and dir has been created, there are a few manual steps to take:

  1. s6-linux-init-maker has copied some scripts from the /etc/s6-linux-init/skel directory (or the directory you gave as an argument to the --skeldir configure option at build time) to the dir/scripts directory. You should edit these scripts and adapt them to your use case. (Or you could edit the skeleton scripts before running s6-linux-init-maker.) The scripts are:
    • rc.init: this script will be run as stage 2 initialization, i.e. the initialization that happens once s6-svscan is running as process 1, and should contain all your normal system bootup tasks. Typically, it should initialize the service manager and then order it to bring the machine state to its fully operational state. rc.init is given the default runlevel as a first argument (i.e. the name of the state the machine should be brought to, traditionally default for OpenRC and 2 or 5 for sysv-rc), and the rest of the command line is made of the kernel's command line except for the kernel arguments of the key=value form, which have been stored into env_store.
    • rc.shutdown: this script will be run as the shutdown sequence, when the administrator runs the shutdown, halt, poweroff or reboot command. (As well as init 0, init 6, telinit 0 and telinit 6 for compatibility reasons.) It should ask the service manager to bring all the services down, and exit when it's done (in other words: it should not try to perform a hard halt/poweroff/reboot itself.) No arguments are given to this script.
    • runlevel: this script will be invoked for every runlevel change, i.e. change of machine states. It is given one argument: the name of the runlevel to change to. Typically, the runlevel script should just invoke the service manager, asking it to bring the machine state to the wanted runlevel.
  2. Copy the dir directory to the place declared as basedir (/etc/s6-linux-init/current by default). Be careful: it contains fifos, files with precise uid/gid permissions, and files with non-standard access rights, so be sure to copy it verbatim. The s6-hiercopy tool can do it, as well as the GNU or busybox cp -a or mv commands.
  3. Back up your /sbin. Then copy, link or symlink all the scripts and symlinks in the basedir/bin directory into /sbin. In particular, the basedir/bin/init script should be accessible as /sbin/init.

Boot sequence

When the kernel boots, it may run an initramfs first, but in any case it then runs the /sbin/init script, also known as stage 1. This script is just an execution of the s6-linux-init program with some command-line options that are directly transferred from the s6-linux-init-maker invocation. Refer to the s6-linux-init man page to know exactly what it does.

s6-linux-init-maker options

  • -c basedir : at boot time, stage 1, which should be accessible as basedir/init, will read its read-only data from basedir. After running s6-linux-init-maker, you should make sure to copy the created directory dir to basedir. basedir must be absolute. Default is /etc/s6-linux-init/current.

  • -u log_user : the catch-all logger will run as the log_user user. Default is root.

  • -G early_getty : if this option is set, s6-linux-init-maker will define an additional s6 service that will be named s6-linux-init-early-getty and started at the same time rc.init is executed. This early service should be a getty, or equivalent, to allow logins even if stage2 fails. early_getty should be a simple command line: for instance, "/sbin/getty 38400 tty1". By default, no early service is defined.

  • -1 : make it so that all the messages that are sent to the catch-all logger (i.e. all the error messages that are not caught by a dedicated logger, as well as the output from rc.init, runlevel and rc.shutdown) are also copied to /dev/console. (Timestamps are not copied to /dev/console.) This is generally useful to debug a system at a glance, but if a failing program keeps sending error messages, it may interfere with comfortable usage of an early getty. A common workaround is to make the early getty start on tty2 and leave tty1 for /dev/console to print on.

  • -L : add an early s6-linux-init-logouthookd service to clean up utmp records at user logout time. Check the s6-linux-init-logouthookd page for details.

  • -p initial_path : the initial value for the PATH environment variable, that will be transmitted to all the starting process unless it's overridden by a PATH declaration via the -e option. It is absolutely necessary for execline and s6 binaries to be accessible via initial_path, else the machine will not boot. Default is /usr/bin:/bin.

  • -m initial_umask : the value of the initial file umask for all the starting processes, in octal. Default is 022.

  • -t timestamp_style : how logs are timestamped by the catch-all logger. 0 means no timestamp, 1 means external TAI64N format, 2 means ISO 8601 format, and 3 means both. Default is 1.

  • -d slashdev : mount a devtmpfs. If this option is given, s6-linux-init will mount a devtmpfs pseudo-filesystem on slashdev. This is useful if the kernel has not been configured to mount the devtmpfs at boot time and there is no static /dev. By default, it is assumed that there is a suitable /dev at boot time, and no additional devtmpfs is mounted.

  • -s env_store : stage 1 init sometimes inherits a few environment variables from the kernel. (These variables correspond to the arguments on the kernel command line that are of the form key=value.) It empties its environment before spawning rc.init and executing into s6-svscan, in order to prevent those "kernel" environment variables from leaking into the whole process tree. However, sometimes those variables are needed at a later time; in that case, giving the -s option to s6-linux-init-maker makes stage 1 init dump the "kernel" environment variables into the env_store directory (under a format that is later readable with s6-envdir -fn) before erasing them. env_store should obviously be a writable directory, so it should be located under /run (or your chosen tmpfsdir)! If this option is not given, the environment inherited from the kernel isn't saved anywhere - which is the default.

  • -e initial_envvar : this option can be repeated. For every initial_envvar, s6-linux-init-maker will adjust the global environment directory in dir/env. initial_envvar must either be of the form VAR, to make sure that VAR does not appear in the global environment, or of the form VAR=VALUE, to add an environment variable VAR with the value VALUE. The global environment is the environment that every supervised process (as well as the rc.init script) will run with, so it will be inherited by default by every process running on the system. The TZ variable, for instance, is a good candidate to be set in the global environment.

  • -q finalsleeptime : when the machine shuts down, all processes that have not already been killed during shutdownscript will receive a SIGTERM or a SIGHUP to allow them to exit gracefully; then, after finalsleeptime milliseconds, they will receive a SIGKILL and the shutdown sequence will go on. This option configures the amount of time that will elapse between the SIGTERM/SIGHUP and the SIGKILL. Default is 3000, meaning a grace period of 3 seconds.

  • -D initdefault : boot the system with a runlevel set to initdefault, which can be an arbitrary string, but is usually 2, 3, 5 (traditional sysvinit behaviour) or default (OpenRC behaviour). Default is default. Note that if a 2, 3, 4, 5, or default argument is encountered in the kernel command line, it will be interpreted as the runlevel to boot the system on, and will override the default given here.

  • -n : at boot time, assume that a tmpfs is already present on /run (or the argument that was given to the --tmpfsdir configure option at build time) and that its contents are essential. Instead of unmounting /run then mounting a tmpfs on it, s6-linux-init will simply remount /run. This option is useful when s6-linux-init is used on a distribution that imposes its initramfs and said initramfs writes data to /run that is then used by the distribution's initialization scripts. (An initramfs should normally be transparent and leave no trace in the filesystem; unfortunately, a lot of distributions do not care.) By default, /run will be unmounted at boot time (just in case), and then a tmpfs will be mounted on it. Do not use this option if you are not sure: failure to remount /run will cause init to die and the kernel to panic. This option is incompatible with the -N option.

  • -N : at boot time, do not perform mounting/unmounting/remounting on /run (or the tmpfsdir declared at build time) at all. By default, a tmpfs is mounted on /run at boot time. This option is useful when s6-linux-init is used to boot on an initramfs that will remain the de facto rootfs of the system (which is the case for instance in certain live CDs or certain embedded devices), in which case the rootfs is already read-write and in RAM and mounting an additional tmpfs is unnecessary. Do not use this option if your rootfs is read-only: failure to write to /run will cause init to die and the kernel to panic. This option is incompatible with the -n option.

  • -f skeldir : copy the skeleton scripts from directory skeldir. By default, skeldir is /etc/s6-linux-init/skel, or the directory that has been given as an argument to the --skeldir configure option at build time. This option is typically useful when distributions run s6-linux-init-maker in packaging scripts, when preparing files in a staging directory.

  • -U utmp_user : this option is only available when the s6-linux-init package has been built with the --enable-utmps configure option, that enables support for the utmps package. The option defines the user that the utmpd and wtmpd services will run as. Default is utmp.

Organization of the created directory

If s6-linux-init-maker returns successfully, dir contains data that will be used at boot time. (Actually, basedir will be used at boot time, not dir. Do not forget to copy dir to basedir once you have checked you are happy with what s6-linux-init-maker has created.)

This boot-time data is made of several subdirectories:

  • bin: this subdirectory contains scripts and symlinks that should be copied to /sbin or /bin. There is an init program performing stage 1 init, a telinit program to change runlevels, and utilities to order a machine shutdown.
  • env: this subdirectory is the envdir that is used to store the global environment. It will be read at boot time by stage 1 init, and transmitted to all spawned processes.
  • scripts: this subdirectory contains a copy of the skeleton scripts that have been installed in /etc/s6-linux-init/skel (or the argument to the --skeldir configure option at build time). These scripts should be edited before booting. They are described above.
  • run-image: this is a file hierarchy that will be copied verbatim at boot time to the newly made and mounted /run tmpfs (or whatever your tmpfsdir is). The subdirectories it contains are the following:
    • uncaught-logs: this is the directory where the catch-all logger will store and rotate the error messages produced by the s6 supervision tree and the services that do not redirect their own logs.
    • service: /run/service will be the scandir. It initially contains a .s6-svscan subdirectory that tells s6-svscan what to do if it receives a signal (typically via the ctrlaltdel combination) and ensures a hard reboot if s6-svscan ever fails. It also contains a list of early services, i.e. s6 services that will be run at boot time as soon as s6-svscan is executed. These services are:
      • s6-svscan-log: the catch-all logger.
      • s6-linux-init-shutdownd: a service that listens to shutdown commands such as reboot and triggers the software shutdown procedure.
      • s6-linux-init-runleveld: a service that listens to runlevel change commands such as telinit and calls the runlevel script in a reproducible environment to bring the machine to the wanted state.
      • (If the -L option has been given to s6-linux-init-maker) s6-linux-init-logouthookd: the "clean up user utmp records at logout time" service. See the s6-linux-init-logouthookd page for details.
      • (If the -G option has been given to s6-linux-init-maker) s6-linux-init-early-getty: the early getty service, that will allow a user to log in even if rc.init fails to bring the machine to a state where logins are possible.

If s6-linux-init has been built with utmps support, some more directories may exist:

  • A directory somewhere under run-image, by default utmps, that is the location where the utmp and wtmp files will be created.
  • Two additional early services named utmpd and wtmpd, that are the utmps way of providing secure utmp functionality.

Notes

A directory created by s6-linux-init-maker is only valid on the machine it has been created on. Pre-creating init directories for other machines is not supported.

After booting, basedir should remain untouched during the lifetime of the machine, because the machine state change and shutdown procedures will look for data in basedir. New invocations of s6-linux-init-maker should use a different basedir.

The difficult parts of running s6-svscan as process 1 are:

  • The fact that the supervision tree requires writable directories, so in order to accommodate read-only root filesystems, there needs to be a tmpfs mounted before s6-svscan is run.
  • The catch-22 coming from the need to redirect the supervision tree's output away from /dev/console (which is fine for a first process invocation but impractical for log management of a whole process tree) and into a logger that is itself managed by the supervision tree it's reading data from.
  • Keeping appearances of compatibility with another init system is difficult: in particular, the mechanisms around the shutdown procedure are fundamentally different from about any other init system, so even a simple command such as reboot needs an ad-hoc implementation.

The main benefit of s6-linux-init-maker is that it offers transparent compatibility while automating the tricky technical part. That means that s6-linux-init-maker has been designed for real hardware, or at least full-fledged Linux systems, where the above issues apply. If you are building an init system for a container, or anything similar that does not have the /dev/console issue, the read-only rootfs issue, or the need for sysvinit compatibility, you will probably not reap much benefit from using s6-linux-init-maker: you could probably invoke s6-svscan directly as your process 1, or build a script by hand, which would result in a simpler init with less dependencies.

s6-linux-init-1.0.3.1/doc/s6-linux-init-shutdown.html0000644000000000000000000001214213502377561017131 0ustar s6-linux-init: the s6-linux-init-shutdown program

s6-linux-init
Software
skarnet.org

The s6-linux-init-shutdown program

s6-linux-init-shutdown triggers the system shutdown procedure. It is normally invoked as /sbin/shutdown.

Interface 

     s6-linux-init-shutdown [ -h [ -H | -P ] | -p | -r | -k ] [ -a ] [ -t sec ] [ -f | -F ] time [ message ]
     s6-linux-init-shutdown -c [ message ]
  • If the -c option is present, a pending shutdown is cancelled.
  • Else, it plans the shutdown procedure at time time.
  • If a message argument has been given, message is broadcast to all logged in users (as tracked by utmp).
  • shutdown exits 0. The shutdown procedure happens asynchronously.

The s6-linux-init-shutdown program conforms to the LSB-3.0.0 shutdown interface.

time must follow the following format: [ now | [+]mins | hh:mm ]

  • now means: trigger the shutdown sequence immediately.
  • hh:mm means: absolute time. Trigger the shutdown sequence when the time hh:mm occurs. If that time has passed for the day, it will wait for the next day. hh must have 1 or 2 digits; mm must have 2 digits.
  • mins or +mins means: relative time. Trigger the shutdown sequence after mins minutes.

Options

  • -a : access control. The shutdown sequence will only be launched if one of the users listed in /etc/shutdown.allow is currently logged in (as tracked by utmp). /etc/shutdown.allow is a text file, one user per line, lines starting with # are comments.
  • -t sec : at the end of the shutdown sequence, when it's time to kill all processes, have a "grace time" period of sec seconds between the SIGTERM and the SIGKILL (to allow processes receiving SIGTERM to exit cleanly). Default is 3 seconds.
  • -k : warning only. message will be sent to all logged in users, but the shutdown sequence will not be triggered.
  • -h : at the end of the shutdown sequence, halt the system. The behaviour of this option may be altered with -H or -P.
  • -p : at the end of the shutdown sequence, power off the system. (This option is provided as an extension, it is not required by the LSB interface.)
  • -r : at the end of the shutdown sequence, reboot the system.
  • -f : ignored.
  • -F : ignored.
  • -c : cancel a planned shutdown (i.e. cancel the effect of a previous call to shutdown with a time argument that was not now). This cannot be used to interrupt a shutdown sequence that has already started.
  • -H : this option can only be used in conjunction with -h. Ensures the system is halted, not powered off, at the end of the shutdown sequence. -Hh is equivalent to -h.
  • -P : this option can only be used in conjunction with -h. Ensures the system is powered off at the end of the shutdown sequence. -Ph is equivalent to -p.

Notes

  • The s6-linux-init-shutdown binary is not meant to be called directly by administrators. Instead, after a s6-linux-init-maker invocation, the bin/ subdirectory of the target will contain a shutdown symlink to s6-linux-init-shutdown. The bin/ subdirectory should be copied by the administrator into /sbin for full interface compatibility with sysvinit.
  • The -f and -F options are only accepted for compatibility. LSB says they are used to advise the system to skip or enforce a fsck after rebooting. But they are only advisory, and for decades now systems have used other methods of evaluating whether they should perform filesystem checks, so these options are largely obsolete nowadays.
s6-linux-init-1.0.3.1/doc/s6-linux-init-hpr.html0000644000000000000000000000621413463713373016053 0ustar s6-linux-init: the s6-linux-init-hpr program

s6-linux-init
Software
skarnet.org

The s6-linux-init-hpr program

s6-linux-init-hpr triggers the software shutdown procedure, or, with the -f option, it perform an immediate hardware shutdown. It is normally invoked through halt, poweroff or reboot wrappers created by s6-linux-init-maker.

Interface 

     s6-linux-init-hpr [ -f ] [ -h | -p | -r ] [ -d | -w ] [ -W ]
  • If the -f option is present, the system is stopped or rebooted immediately.
  • Else, the machine's shutdown procedure is started.
  • The command exits 0; the shutdown procedure happens asynchronously.

This interface is the traditional sysvinit interface for the halt, poweroff and reboot programs. s6-linux-init-hpr must always be called with one of the -h, -p or -r options.

Options

  • -f : force. The command will not trigger a clean shutdown procedure; it will just sync the filesystems then tell the kernel to immediately halt, poweroff or reboot. This should be the last step in the lifetime of the machine.
  • -h : halt. The system will be shut down, but the power will remain up.
  • -p : poweroff. The system will be shut down and the power turned off.
  • -r : reboot. The system will reboot.
  • -d : Do not write a wtmp shutdown entry.
  • -w : Only write a wtmp shutdown entry; do not actually shut down the system.
  • -W : Do not send a wall message to users before shutting down the system. Some other implementations of the halt, poweroff and reboot commands use the --no-wall long option to achieve this.

Notes

  • When an administrator runs s6-linux-init-maker, the resulting directory has a bin/ subdirectory that contains halt, poweroff and reboot scripts that call s6-linux-init-hpr with the relevant option. The contents of this bin/ subdirectory should then be copied by the administrator into /sbin for full interface compatibility with sysvinit.