s6-rc-0.5.1.1/0002755000000000000000000000000013553343655007512 5ustar s6-rc-0.5.1.1/examples/0002755000000000000000000000000013110270203011301 5ustar s6-rc-0.5.1.1/examples/README0000644000000000000000000000077412550375711012210 0ustar An example set of service definition directories. ok-all is the bundle containing all the services used for normal operation of the machine this set has been taken out of; the stage 2 init script of this machine is basically "s6-rc-init && s6-rc change ok-all". ok-all contains ok-local, ok-lan and ok-wan, all bundles each containing their own services. "00" is the service at the bottom of the dependency graph. So 00/up is the first script that is run by the initial "s6-rc change ok-all" command. s6-rc-0.5.1.1/examples/source/0000755000000000000000000000000013336722055012620 5ustar s6-rc-0.5.1.1/examples/source/taiclockd-4/0001755000000000000000000000000013336722446014723 5ustar s6-rc-0.5.1.1/examples/source/taiclockd-4/run0000755000000000000000000000016213156254435015451 0ustar #!/command/execlineb -P fdmove -c 2 1 s6-setuidgid tai importas -i ETH0_IP4 EHT0_IP4 s6-taiclockd -i ${ETH0_IP4} s6-rc-0.5.1.1/examples/source/taiclockd-4/dependencies0000644000000000000000000000001112547262646017267 0ustar init-lan s6-rc-0.5.1.1/examples/source/taiclockd-4/type0000644000000000000000000000001012547262657015623 0ustar longrun s6-rc-0.5.1.1/examples/source/taiclockd-4/producer-for0000644000000000000000000000002012547262724017245 0ustar taiclockd-4-log s6-rc-0.5.1.1/examples/source/mount-proc/0000755000000000000000000000000012547247476014737 5ustar s6-rc-0.5.1.1/examples/source/mount-proc/dependencies0000644000000000000000000000000312547247476017301 0ustar 00 s6-rc-0.5.1.1/examples/source/mount-proc/down0000644000000000000000000000002012550367337015612 0ustar s6-umount /proc s6-rc-0.5.1.1/examples/source/mount-proc/type0000644000000000000000000000001012547247153015622 0ustar oneshot s6-rc-0.5.1.1/examples/source/mount-proc/up0000644000000000000000000000003512550367347015276 0ustar s6-mount -wt proc proc /proc s6-rc-0.5.1.1/examples/source/dns-server-udp-log/0000755000000000000000000000000013417375671016265 5ustar s6-rc-0.5.1.1/examples/source/dns-server-udp-log/pipeline-name0000644000000000000000000000003012562442036020712 0ustar dns-server-udp-pipeline s6-rc-0.5.1.1/examples/source/dns-server-udp-log/run0000755000000000000000000000015113417375671017014 0ustar #!/command/execlineb -P s6-setuidgid dnslog exec -c s6-log -d3 -- t s1000000 n20 /var/log/dns-server-udp s6-rc-0.5.1.1/examples/source/dns-server-udp-log/dependencies0000644000000000000000000000001312550363520020613 0ustar mount-sync s6-rc-0.5.1.1/examples/source/dns-server-udp-log/consumer-for0000644000000000000000000000001712547256612020621 0ustar dns-server-udp s6-rc-0.5.1.1/examples/source/dns-server-udp-log/type0000644000000000000000000000001012547256626017161 0ustar longrun s6-rc-0.5.1.1/examples/source/dns-server-udp-log/notification-fd0000644000000000000000000000000213417375570021253 0ustar 3 s6-rc-0.5.1.1/examples/source/wan/0000755000000000000000000000000012547274441013411 5ustar s6-rc-0.5.1.1/examples/source/wan/type0000644000000000000000000000000712547274430014310 0ustar bundle s6-rc-0.5.1.1/examples/source/wan/contents0000644000000000000000000000002612550370405015156 0ustar init-eth3 udhcpc-eth3 s6-rc-0.5.1.1/examples/source/ntpclient/0001755000000000000000000000000013336722446014625 5ustar s6-rc-0.5.1.1/examples/source/ntpclient/run0000755000000000000000000000051713156254435015357 0ustar #!/command/execlineb -P fdmove -c 2 1 if { pipeline { s6-setuidgid ntp backtick -n NTPSERVERIP { pipeline { s6-dnsip4 -t 16000 0.fr.pool.ntp.org } s6-head -n 1 } importas -u NTPSERVERIP NTPSERVERIP s6-sntpclock -v 2 $NTPSERVERIP } s6-clockadd -e 120000 } s6-setuidgid nobody s6-sleep 14400 s6-rc-0.5.1.1/examples/source/ntpclient/dependencies0000644000000000000000000000001612547276563017201 0ustar wan dns-cache s6-rc-0.5.1.1/examples/source/ntpclient/type0000644000000000000000000000001012547276576015532 0ustar longrun s6-rc-0.5.1.1/examples/source/ntpclient/producer-for0000644000000000000000000000001612547276603017155 0ustar ntpclient-log s6-rc-0.5.1.1/examples/source/syslogd-srv/0001755000000000000000000000000013336722514015115 5ustar s6-rc-0.5.1.1/examples/source/syslogd-srv/run0000755000000000000000000000024012537624451015645 0ustar #!/command/execlineb -P fdmove -c 2 1 exec -c s6-envuidgid nobody fdmove 1 3 s6-ipcserver -U -1 -- /dev/log fdmove -c 1 2 ucspilogd IPCREMOTEEUID IPCREMOTEEGID s6-rc-0.5.1.1/examples/source/syslogd-srv/dependencies0000644000000000000000000000001612547253330017460 0ustar init-devtmpfs s6-rc-0.5.1.1/examples/source/syslogd-srv/type0000644000000000000000000000001012547253307016011 0ustar longrun s6-rc-0.5.1.1/examples/source/syslogd-srv/producer-for0000644000000000000000000000001412547253300017434 0ustar syslogd-log s6-rc-0.5.1.1/examples/source/syslogd-srv/notification-fd0000644000000000000000000000000212537624201020100 0ustar 3 s6-rc-0.5.1.1/examples/source/syslogd-log/0000755000000000000000000000000013417375671015073 5ustar s6-rc-0.5.1.1/examples/source/syslogd-log/pipeline-name0000644000000000000000000000001012645223546017523 0ustar syslogd s6-rc-0.5.1.1/examples/source/syslogd-log/run0000755000000000000000000000014213417375671015622 0ustar #!/command/execlineb -P s6-setuidgid syslog exec -c s6-log -d3 -- t s1000000 n20 /var/log/syslogd s6-rc-0.5.1.1/examples/source/syslogd-log/dependencies0000644000000000000000000000001312550363520017421 0ustar mount-sync s6-rc-0.5.1.1/examples/source/syslogd-log/consumer-for0000644000000000000000000000001412547265763017433 0ustar syslogd-srv s6-rc-0.5.1.1/examples/source/syslogd-log/type0000644000000000000000000000001012547265717015770 0ustar longrun s6-rc-0.5.1.1/examples/source/syslogd-log/notification-fd0000644000000000000000000000000213417375570020061 0ustar 3 s6-rc-0.5.1.1/examples/source/dns-cache-log/0000755000000000000000000000000013417375671015234 5ustar s6-rc-0.5.1.1/examples/source/dns-cache-log/pipeline-name0000644000000000000000000000002312562442036017663 0ustar dns-cache-pipeline s6-rc-0.5.1.1/examples/source/dns-cache-log/run0000755000000000000000000000014413417375710015757 0ustar #!/command/execlineb -P s6-setuidgid dnslog exec -c s6-log -d3 -- t s1000000 n20 /var/log/dns-cache s6-rc-0.5.1.1/examples/source/dns-cache-log/dependencies0000644000000000000000000000001312550363520017562 0ustar mount-sync s6-rc-0.5.1.1/examples/source/dns-cache-log/consumer-for0000644000000000000000000000001212547256074017565 0ustar dns-cache s6-rc-0.5.1.1/examples/source/dns-cache-log/type0000644000000000000000000000001012547256101016114 0ustar longrun s6-rc-0.5.1.1/examples/source/dns-cache-log/notification-fd0000644000000000000000000000000213417375570020222 0ustar 3 s6-rc-0.5.1.1/examples/source/fdholder/0001755000000000000000000000000013430015460014376 5ustar s6-rc-0.5.1.1/examples/source/fdholder/run0000755000000000000000000000017412547302742015143 0ustar #!/command/execlineb -P fdmove -c 2 1 s6-envuidgid fdh fdmove 1 3 s6-fdholder-daemon -v 2 -1 -T 20000 -U -i data/rules -- s s6-rc-0.5.1.1/examples/source/fdholder/down-signal0000644000000000000000000000001013430015416016532 0ustar SIGTERM s6-rc-0.5.1.1/examples/source/fdholder/dependencies0000644000000000000000000000000312547302556016754 0ustar 00 s6-rc-0.5.1.1/examples/source/fdholder/timeout-finish0000644000000000000000000000000513430015440017255 0ustar 5000 s6-rc-0.5.1.1/examples/source/fdholder/type0000644000000000000000000000001012547257437015314 0ustar longrun s6-rc-0.5.1.1/examples/source/fdholder/producer-for0000644000000000000000000000001512547303506016734 0ustar fdholder-log s6-rc-0.5.1.1/examples/source/fdholder/timeout-kill0000644000000000000000000000000213430015460016727 0ustar 0 s6-rc-0.5.1.1/examples/source/fdholder/data/0000755000000000000000000000000012547303014015311 5ustar s6-rc-0.5.1.1/examples/source/fdholder/data/rules/0000755000000000000000000000000012547303026016446 5ustar s6-rc-0.5.1.1/examples/source/fdholder/data/rules/uid/0000755000000000000000000000000012547303032017224 5ustar s6-rc-0.5.1.1/examples/source/fdholder/data/rules/uid/0/0000755000000000000000000000000012547303041017363 5ustar s6-rc-0.5.1.1/examples/source/fdholder/data/rules/uid/0/allow0000644000000000000000000000000012547303037020417 0ustar s6-rc-0.5.1.1/examples/source/fdholder/data/rules/uid/0/env/0000755000000000000000000000000012547303135020157 5ustar s6-rc-0.5.1.1/examples/source/fdholder/data/rules/uid/0/env/S6_FDHOLDER_SETDUMP0000644000000000000000000000000212547303075023035 0ustar 1 s6-rc-0.5.1.1/examples/source/fdholder/data/rules/uid/0/env/S6_FDHOLDER_GETDUMP0000644000000000000000000000000212547303066023021 0ustar 1 s6-rc-0.5.1.1/examples/source/fdholder/data/rules/uid/0/env/S6_FDHOLDER_RETRIEVE_REGEX0000644000000000000000000000000312547303121024064 0ustar .* s6-rc-0.5.1.1/examples/source/fdholder/data/rules/uid/0/env/S6_FDHOLDER_STORE_REGEX0000644000000000000000000000000312547303135023540 0ustar .* s6-rc-0.5.1.1/examples/source/fdholder/notification-fd0000644000000000000000000000000212547317100017371 0ustar 3 s6-rc-0.5.1.1/examples/source/fdholder/max-death-tally0000644000000000000000000000000413430015400017277 0ustar 100 s6-rc-0.5.1.1/examples/source/httpd-4/0001755000000000000000000000000013336722446014111 5ustar s6-rc-0.5.1.1/examples/source/httpd-4/run0000755000000000000000000000025213156254435014637 0ustar #!/command/execlineb -P fdmove -c 2 1 s6-envuidgid www cd /home/www importas -ui ETH0_IP4 ETH0_IP4 fdmove 1 3 s6-tcpserver4 -v 2 -U -c 512 -1 -- ${ETH0_IP4} 80 httpd -iv s6-rc-0.5.1.1/examples/source/httpd-4/dependencies0000644000000000000000000000002412550364253016450 0ustar init-lan mount-rwfs s6-rc-0.5.1.1/examples/source/httpd-4/type0000644000000000000000000000001012547257604015005 0ustar longrun s6-rc-0.5.1.1/examples/source/httpd-4/producer-for0000644000000000000000000000001412547257615016441 0ustar httpd-4-log s6-rc-0.5.1.1/examples/source/httpd-4/notification-fd0000644000000000000000000000000212537624201017070 0ustar 3 s6-rc-0.5.1.1/examples/source/init-urandom/0000755000000000000000000000000012547247476015242 5ustar s6-rc-0.5.1.1/examples/source/init-urandom/dependencies0000644000000000000000000000000312547247476017604 0ustar 00 s6-rc-0.5.1.1/examples/source/init-urandom/down0000644000000000000000000000000112547247600016110 0ustar s6-rc-0.5.1.1/examples/source/init-urandom/type0000644000000000000000000000001012547247153016125 0ustar oneshot s6-rc-0.5.1.1/examples/source/init-urandom/up0000644000000000000000000000011212547247715015577 0ustar redirfd -w 1 /dev/urandom pipeline { if { s6-clock } s6-clock } sha512sum s6-rc-0.5.1.1/examples/source/ok-all/0000755000000000000000000000000012547254507014004 5ustar s6-rc-0.5.1.1/examples/source/ok-all/type0000644000000000000000000000000712547254334014703 0ustar bundle s6-rc-0.5.1.1/examples/source/ok-all/contents0000644000000000000000000000002712547300112015543 0ustar ok-local ok-lan ok-wan s6-rc-0.5.1.1/examples/source/mount-sys/0000755000000000000000000000000012547247506014604 5ustar s6-rc-0.5.1.1/examples/source/mount-sys/dependencies0000644000000000000000000000000312547247506017146 0ustar 00 s6-rc-0.5.1.1/examples/source/mount-sys/down0000644000000000000000000000001712550367365015474 0ustar s6-umount /sys s6-rc-0.5.1.1/examples/source/mount-sys/type0000644000000000000000000000001012547247153015475 0ustar oneshot s6-rc-0.5.1.1/examples/source/mount-sys/up0000644000000000000000000000003412550367376015152 0ustar s6-mount -wt sysfs sys /sys s6-rc-0.5.1.1/examples/source/hostapd-log/0000755000000000000000000000000013417375671015051 5ustar s6-rc-0.5.1.1/examples/source/hostapd-log/pipeline-name0000644000000000000000000000002112562442036017476 0ustar hostapd-pipeline s6-rc-0.5.1.1/examples/source/hostapd-log/run0000755000000000000000000000014313417375671015601 0ustar #!/command/execlineb -P s6-setuidgid wifilog exec -c s6-log -d3 -- s1000000 n20 t /var/log/hostapd s6-rc-0.5.1.1/examples/source/hostapd-log/dependencies0000644000000000000000000000001312550363520017377 0ustar mount-sync s6-rc-0.5.1.1/examples/source/hostapd-log/consumer-for0000644000000000000000000000001012547257530017376 0ustar hostapd s6-rc-0.5.1.1/examples/source/hostapd-log/type0000644000000000000000000000001012547257540015741 0ustar longrun s6-rc-0.5.1.1/examples/source/hostapd-log/notification-fd0000644000000000000000000000000213417375570020037 0ustar 3 s6-rc-0.5.1.1/examples/source/fdholder-log/0000755000000000000000000000000013417375671015176 5ustar s6-rc-0.5.1.1/examples/source/fdholder-log/pipeline-name0000644000000000000000000000002212562442036017624 0ustar fdholder-pipeline s6-rc-0.5.1.1/examples/source/fdholder-log/run0000755000000000000000000000014313417375671015726 0ustar #!/command/execlineb -P s6-setuidgid fdhlog exec -c s6-log -d3 -- s1000000 n20 t /var/log/fdholder s6-rc-0.5.1.1/examples/source/fdholder-log/dependencies0000644000000000000000000000001312550363520017524 0ustar mount-sync s6-rc-0.5.1.1/examples/source/fdholder-log/consumer-for0000644000000000000000000000001112547302414017514 0ustar fdholder s6-rc-0.5.1.1/examples/source/fdholder-log/type0000644000000000000000000000001012547257540016066 0ustar longrun s6-rc-0.5.1.1/examples/source/fdholder-log/notification-fd0000644000000000000000000000000213417375570020164 0ustar 3 s6-rc-0.5.1.1/examples/source/sshd-4-log/0000755000000000000000000000000013417375671014511 5ustar s6-rc-0.5.1.1/examples/source/sshd-4-log/pipeline-name0000644000000000000000000000002012562442036017135 0ustar sshd-4-pipeline s6-rc-0.5.1.1/examples/source/sshd-4-log/run0000755000000000000000000000013613417375671015243 0ustar #!/command/execlineb -P s6-setuidgid log exec -c s6-log -d3 -- t s1000000 n20 /var/log/sshd-4 s6-rc-0.5.1.1/examples/source/sshd-4-log/dependencies0000644000000000000000000000001312550363520017037 0ustar mount-sync s6-rc-0.5.1.1/examples/source/sshd-4-log/consumer-for0000644000000000000000000000000712547262600017036 0ustar sshd-4 s6-rc-0.5.1.1/examples/source/sshd-4-log/type0000644000000000000000000000001012547262573015403 0ustar longrun s6-rc-0.5.1.1/examples/source/sshd-4-log/notification-fd0000644000000000000000000000000213417375570017477 0ustar 3 s6-rc-0.5.1.1/examples/source/fifodir-cleanup/0000755000000000000000000000000013156254435015671 5ustar s6-rc-0.5.1.1/examples/source/fifodir-cleanup/run0000755000000000000000000000043713156254435016427 0ustar #!/command/execlineb -P fdmove -c 2 1 if { forbacktickx -ep -0 i { s6-ls -0 /service } importas -u i i foreground { if { s6-test -d /service/${i}/log } s6-cleanfifodir /service/${i}/log/event } s6-cleanfifodir /service/${i}/event } s6-setuidgid nobody s6-sleep 86400 s6-rc-0.5.1.1/examples/source/fifodir-cleanup/dependencies0000644000000000000000000000000312547257361020237 0ustar 00 s6-rc-0.5.1.1/examples/source/fifodir-cleanup/type0000644000000000000000000000001012547257210016561 0ustar longrun s6-rc-0.5.1.1/examples/source/qmtpd-4-log/0000755000000000000000000000000013417375671014675 5ustar s6-rc-0.5.1.1/examples/source/qmtpd-4-log/pipeline-name0000644000000000000000000000002112562442036017322 0ustar qmtpd-4-pipeline s6-rc-0.5.1.1/examples/source/qmtpd-4-log/run0000755000000000000000000000014413417375671015426 0ustar #!/command/execlineb -P s6-setuidgid qmaillog exec -c s6-log -d3 -- t s1000000 n20 /var/log/qmtpd-4 s6-rc-0.5.1.1/examples/source/qmtpd-4-log/dependencies0000644000000000000000000000001312550363520017223 0ustar mount-sync s6-rc-0.5.1.1/examples/source/qmtpd-4-log/consumer-for0000644000000000000000000000001012547261602017215 0ustar qmtpd-4 s6-rc-0.5.1.1/examples/source/qmtpd-4-log/type0000644000000000000000000000001012547261605015562 0ustar longrun s6-rc-0.5.1.1/examples/source/qmtpd-4-log/notification-fd0000644000000000000000000000000213417375570017663 0ustar 3 s6-rc-0.5.1.1/examples/source/hostapd/0001755000000000000000000000000013336722446014267 5ustar s6-rc-0.5.1.1/examples/source/hostapd/run0000755000000000000000000000011012502235543014777 0ustar #!/command/execlineb -P fdmove -c 2 1 hostapd /etc/hostapd/hostapd.conf s6-rc-0.5.1.1/examples/source/hostapd/dependencies0000644000000000000000000000001312547277422016633 0ustar init-wlan0 s6-rc-0.5.1.1/examples/source/hostapd/type0000644000000000000000000000001012547257437015167 0ustar longrun s6-rc-0.5.1.1/examples/source/hostapd/producer-for0000644000000000000000000000001412547257434016616 0ustar hostapd-log s6-rc-0.5.1.1/examples/source/udhcpc-eth3-log/0000755000000000000000000000000013417375671015516 5ustar s6-rc-0.5.1.1/examples/source/udhcpc-eth3-log/pipeline-name0000644000000000000000000000002512562442036020147 0ustar udhcpc-eth3-pipeline s6-rc-0.5.1.1/examples/source/udhcpc-eth3-log/run0000755000000000000000000000014313417375671016246 0ustar #!/command/execlineb -P s6-setuidgid log exec -c s6-log -d3 -- t s1000000 n20 /var/log/udhcpc-eth3 s6-rc-0.5.1.1/examples/source/udhcpc-eth3-log/dependencies0000644000000000000000000000001312550363520020044 0ustar mount-sync s6-rc-0.5.1.1/examples/source/udhcpc-eth3-log/consumer-for0000644000000000000000000000001412547264517020052 0ustar udhcpc-eth3 s6-rc-0.5.1.1/examples/source/udhcpc-eth3-log/type0000644000000000000000000000001012547264523016405 0ustar longrun s6-rc-0.5.1.1/examples/source/udhcpc-eth3-log/notification-fd0000644000000000000000000000000213417375570020504 0ustar 3 s6-rc-0.5.1.1/examples/source/mount-swap/0000755000000000000000000000000013156254435014734 5ustar s6-rc-0.5.1.1/examples/source/mount-swap/dependencies0000644000000000000000000000002012547251003017264 0ustar init-diskconfig s6-rc-0.5.1.1/examples/source/mount-swap/down0000644000000000000000000000011513156254435015623 0ustar s6-envdir -i /run/disk-devices importas -i swap swap s6-swapoff /dev/${swap} s6-rc-0.5.1.1/examples/source/mount-swap/type0000644000000000000000000000001012547247153015631 0ustar oneshot s6-rc-0.5.1.1/examples/source/mount-swap/up0000644000000000000000000000011413156254435015277 0ustar s6-envdir -i /run/disk-devices importas -i swap swap s6-swapon /dev/${swap} s6-rc-0.5.1.1/examples/source/init-eth3/0000755000000000000000000000000012547267735014440 5ustar s6-rc-0.5.1.1/examples/source/init-eth3/dependencies0000644000000000000000000000001112547267750016776 0ustar init-lan s6-rc-0.5.1.1/examples/source/init-eth3/down0000644000000000000000000000003212547267741015322 0ustar ip link set dev eth3 down s6-rc-0.5.1.1/examples/source/init-eth3/type0000644000000000000000000000001012547247153015323 0ustar oneshot s6-rc-0.5.1.1/examples/source/init-eth3/up0000644000000000000000000000003012547267733014776 0ustar ip link set dev eth3 up s6-rc-0.5.1.1/examples/source/dns-server-tcp-4/0001755000000000000000000000000013336722446015642 5ustar s6-rc-0.5.1.1/examples/source/dns-server-tcp-4/run0000755000000000000000000000027313156254435016373 0ustar #!/command/execlineb -P fdmove -c 2 1 s6-envuidgid dnsserve export ROOT /home/dns export AXFR "" importas -ui ETH1_IP4 ETH1_IP4 fdmove 1 3 s6-tcpserver4 -v 2 -1 -- ${ETH1_IP4} 53 axfrdns s6-rc-0.5.1.1/examples/source/dns-server-tcp-4/dependencies0000644000000000000000000000002412550364147020203 0ustar init-lan mount-rwfs s6-rc-0.5.1.1/examples/source/dns-server-tcp-4/type0000644000000000000000000000001012547256234016534 0ustar longrun s6-rc-0.5.1.1/examples/source/dns-server-tcp-4/producer-for0000644000000000000000000000002512547256242020167 0ustar dns-server-tcp-4-log s6-rc-0.5.1.1/examples/source/dns-server-tcp-4/notification-fd0000644000000000000000000000000212537624201020621 0ustar 3 s6-rc-0.5.1.1/examples/source/dns-server-udp/0001755000000000000000000000000013336722446015503 5ustar s6-rc-0.5.1.1/examples/source/dns-server-udp/run0000755000000000000000000000024513156254435016233 0ustar #!/command/execlineb -P fdmove -c 2 1 s6-softlimit -d 300000 s6-envuidgid dnsserve importas -i ETH1_IP4 ETH1_IP4 export IP ${ETH1_IP4} export ROOT /home/dns tinydns s6-rc-0.5.1.1/examples/source/dns-server-udp/dependencies0000644000000000000000000000002412550364244020042 0ustar init-lan mount-rwfs s6-rc-0.5.1.1/examples/source/dns-server-udp/type0000644000000000000000000000001012547256533016377 0ustar longrun s6-rc-0.5.1.1/examples/source/dns-server-udp/producer-for0000644000000000000000000000002312547256523020030 0ustar dns-server-udp-log s6-rc-0.5.1.1/examples/source/ok-lan/0000755000000000000000000000000012547254507014006 5ustar s6-rc-0.5.1.1/examples/source/ok-lan/type0000644000000000000000000000000712547254334014705 0ustar bundle s6-rc-0.5.1.1/examples/source/ok-lan/contents0000644000000000000000000000016312550370710015553 0ustar dns-cache dns-server-tcp-4 dns-server-udp httpd-4 identd-4 qmtpd-4 smtpd-4 sshd-4 taiclockd-4 hostapd udhcpd-wlan0 s6-rc-0.5.1.1/examples/source/ntpclient-log/0000755000000000000000000000000013417375671015407 5ustar s6-rc-0.5.1.1/examples/source/ntpclient-log/pipeline-name0000644000000000000000000000002312562442036020036 0ustar ntpclient-pipeline s6-rc-0.5.1.1/examples/source/ntpclient-log/run0000755000000000000000000000012713417375671016141 0ustar #!/command/execlineb -P s6-setuidgid ntplog exec -c s6-log -d3 -- t /var/log/ntpclient s6-rc-0.5.1.1/examples/source/ntpclient-log/dependencies0000644000000000000000000000001312550363520017735 0ustar mount-sync s6-rc-0.5.1.1/examples/source/ntpclient-log/consumer-for0000644000000000000000000000001212547276660017743 0ustar ntpclient s6-rc-0.5.1.1/examples/source/ntpclient-log/type0000644000000000000000000000001012547276642016303 0ustar longrun s6-rc-0.5.1.1/examples/source/ntpclient-log/notification-fd0000644000000000000000000000000213417375570020375 0ustar 3 s6-rc-0.5.1.1/examples/source/sshd-4/0001755000000000000000000000000013336722446013727 5ustar s6-rc-0.5.1.1/examples/source/sshd-4/run0000755000000000000000000000030213156254435014451 0ustar #!/command/execlineb -P fdmove -c 2 1 importas -ui ETH0_IP4 ETH0_IP4 fdmove 1 3 s6-tcpserver4 -v 2 -1 -- ${ETH0_IP4} 22 s6-tcpserver-access -v 2 -DRl0 -t 5000 -i data/rules -- dropbear -i -K 60 s6-rc-0.5.1.1/examples/source/sshd-4/dependencies0000644000000000000000000000001112547262552016267 0ustar init-lan s6-rc-0.5.1.1/examples/source/sshd-4/type0000644000000000000000000000001012547262472014622 0ustar longrun s6-rc-0.5.1.1/examples/source/sshd-4/producer-for0000644000000000000000000000001312547262540016247 0ustar sshd-4-log s6-rc-0.5.1.1/examples/source/sshd-4/data/0000755000000000000000000000000012547262445014640 5ustar s6-rc-0.5.1.1/examples/source/sshd-4/data/rules/0000755000000000000000000000000012204635345015763 5ustar s6-rc-0.5.1.1/examples/source/sshd-4/data/rules/ip4/0000755000000000000000000000000012447241627016464 5ustar s6-rc-0.5.1.1/examples/source/sshd-4/data/rules/ip4/0.0.0.0_0/0000755000000000000000000000000012235000527017457 5ustar s6-rc-0.5.1.1/examples/source/sshd-4/data/rules/ip4/0.0.0.0_0/deny0000644000000000000000000000000012235000524020324 0ustar s6-rc-0.5.1.1/examples/source/sshd-4/data/rules/ip4/192.168.0.0_22/0000755000000000000000000000000012447241457020114 5ustar s6-rc-0.5.1.1/examples/source/sshd-4/data/rules/ip4/192.168.0.0_22/allow0000644000000000000000000000000012447241457021143 0ustar s6-rc-0.5.1.1/examples/source/sshd-4/notification-fd0000644000000000000000000000000212537624201016706 0ustar 3 s6-rc-0.5.1.1/examples/source/udhcpd-wlan0/0001755000000000000000000000000013336722446015113 5ustar s6-rc-0.5.1.1/examples/source/udhcpd-wlan0/run0000755000000000000000000000017013156254435015640 0ustar #!/command/execlineb -P fdmove -c 2 1 importas -ui WLAN0_IP4 WLAN0_IP4 udhcpd -f -I ${WLAN0_IP4} /etc/udhcpd-wlan0.conf s6-rc-0.5.1.1/examples/source/udhcpd-wlan0/dependencies0000644000000000000000000000002312547277450017461 0ustar init-wlan0 hostapd s6-rc-0.5.1.1/examples/source/udhcpd-wlan0/type0000644000000000000000000000001012547263234016003 0ustar longrun s6-rc-0.5.1.1/examples/source/udhcpd-wlan0/producer-for0000644000000000000000000000002112547263227017435 0ustar udhcpd-wlan0-log s6-rc-0.5.1.1/examples/source/mount-sync/0000755000000000000000000000000013156254435014736 5ustar s6-rc-0.5.1.1/examples/source/mount-sync/dependencies0000644000000000000000000000002012547251003017266 0ustar init-diskconfig s6-rc-0.5.1.1/examples/source/mount-sync/down0000644000000000000000000000002612550365736015632 0ustar s6-umount /mnt/syncfs s6-rc-0.5.1.1/examples/source/mount-sync/type0000644000000000000000000000001012547247153015633 0ustar oneshot s6-rc-0.5.1.1/examples/source/mount-sync/up0000644000000000000000000000021413156254435015302 0ustar s6-envdir -i /run/disk-devices importas -i syncfs syncfs s6-mount -wt ext4 -o barrier=0,sync,nodev,noexec,nosuid /dev/${syncfs} /mnt/syncfs s6-rc-0.5.1.1/examples/source/00/0000755000000000000000000000000012562441567013045 5ustar s6-rc-0.5.1.1/examples/source/00/type0000644000000000000000000000001012547247136013737 0ustar oneshot s6-rc-0.5.1.1/examples/source/00/up0000644000000000000000000000010312550364647013406 0ustar if { s6-echo "init-stage2 starting." } s6-hostname foo.example.com s6-rc-0.5.1.1/examples/source/httpd-4-log/0000755000000000000000000000000013417375671014673 5ustar s6-rc-0.5.1.1/examples/source/httpd-4-log/pipeline-name0000644000000000000000000000002112562442036017320 0ustar httpd-4-pipeline s6-rc-0.5.1.1/examples/source/httpd-4-log/run0000755000000000000000000000014413417375671015424 0ustar #!/command/execlineb -P s6-setuidgid publilog exec -c s6-log -d3 -- t s1000000 n20 /var/log/httpd-4 s6-rc-0.5.1.1/examples/source/httpd-4-log/dependencies0000644000000000000000000000001312550363520017221 0ustar mount-sync s6-rc-0.5.1.1/examples/source/httpd-4-log/consumer-for0000644000000000000000000000001012547261052017212 0ustar httpd-4 s6-rc-0.5.1.1/examples/source/httpd-4-log/type0000644000000000000000000000001012547261045015556 0ustar longrun s6-rc-0.5.1.1/examples/source/httpd-4-log/notification-fd0000644000000000000000000000000213417375570017661 0ustar 3 s6-rc-0.5.1.1/examples/source/ok-local/0000755000000000000000000000000012547254507014326 5ustar s6-rc-0.5.1.1/examples/source/ok-local/type0000644000000000000000000000000712547254334015225 0ustar bundle s6-rc-0.5.1.1/examples/source/ok-local/contents0000644000000000000000000000015613336722260016101 0ustar mdevd syslogd klogd fdholder mount-disks mount-cgroups init-coldplug init-sysctl init-urandom fifodir-cleanup s6-rc-0.5.1.1/examples/source/klogd-srv/0001755000000000000000000000000013336722502014526 5ustar s6-rc-0.5.1.1/examples/source/klogd-srv/run0000755000000000000000000000012011333754600015247 0ustar #!/command/execlineb -P fdmove -c 2 1 redirfd -r 0 /proc/kmsg exec -c ucspilogd s6-rc-0.5.1.1/examples/source/klogd-srv/dependencies0000644000000000000000000000001312547253102017066 0ustar mount-proc s6-rc-0.5.1.1/examples/source/klogd-srv/type0000644000000000000000000000001012547253074015426 0ustar longrun s6-rc-0.5.1.1/examples/source/klogd-srv/producer-for0000644000000000000000000000001212547253107017053 0ustar klogd-log s6-rc-0.5.1.1/examples/source/qmail/0001755000000000000000000000000013336722446013730 5ustar s6-rc-0.5.1.1/examples/source/qmail/run0000755000000000000000000000007612207740726014461 0ustar #!/command/execlineb -P fdmove -c 2 1 qmail-start ./Maildir/ s6-rc-0.5.1.1/examples/source/qmail/dependencies0000644000000000000000000000003112550364273016267 0ustar mount-sync wan dns-cache s6-rc-0.5.1.1/examples/source/qmail/type0000644000000000000000000000001012547276360014624 0ustar longrun s6-rc-0.5.1.1/examples/source/qmail/producer-for0000644000000000000000000000001212547276434016256 0ustar qmail-log s6-rc-0.5.1.1/examples/source/identd-4-log/0000755000000000000000000000000013417375671015017 5ustar s6-rc-0.5.1.1/examples/source/identd-4-log/pipeline-name0000644000000000000000000000002212562442036017445 0ustar identd-4-pipeline s6-rc-0.5.1.1/examples/source/identd-4-log/run0000755000000000000000000000014513417375671015551 0ustar #!/command/execlineb -P s6-setuidgid identlog exec -c s6-log -d3 -- t s1000000 n20 /var/log/identd-4 s6-rc-0.5.1.1/examples/source/identd-4-log/dependencies0000644000000000000000000000001312550363520017345 0ustar mount-sync s6-rc-0.5.1.1/examples/source/identd-4-log/consumer-for0000644000000000000000000000001112547261363017344 0ustar identd-4 s6-rc-0.5.1.1/examples/source/identd-4-log/type0000644000000000000000000000001012547261354015705 0ustar longrun s6-rc-0.5.1.1/examples/source/identd-4-log/notification-fd0000644000000000000000000000000213417375570020005 0ustar 3 s6-rc-0.5.1.1/examples/source/qmtpd-4/0001755000000000000000000000000013336722446014113 5ustar s6-rc-0.5.1.1/examples/source/qmtpd-4/run0000755000000000000000000000024313156254435014641 0ustar #!/command/execlineb -P fdmove -c 2 1 s6-envuidgid qmaild importas -ui ETH0_IP4 ETH0_IP4 fdmove 1 3 s6-tcpserver4 -v 1 -U -c 255 -1 -- ${ETH0_IP4} 209 qmail-qmtpd s6-rc-0.5.1.1/examples/source/qmtpd-4/dependencies0000644000000000000000000000001112547261564016455 0ustar init-lan s6-rc-0.5.1.1/examples/source/qmtpd-4/type0000644000000000000000000000001012547261534015004 0ustar longrun s6-rc-0.5.1.1/examples/source/qmtpd-4/producer-for0000644000000000000000000000001412547261551016435 0ustar qmtpd-4-log s6-rc-0.5.1.1/examples/source/qmtpd-4/notification-fd0000644000000000000000000000000212537624201017072 0ustar 3 s6-rc-0.5.1.1/examples/source/mount-cgroups/0000755000000000000000000000000013156254435015444 5ustar s6-rc-0.5.1.1/examples/source/mount-cgroups/dependencies0000644000000000000000000000002512547254200020003 0ustar mount-sys mount-proc s6-rc-0.5.1.1/examples/source/mount-cgroups/down0000644000000000000000000000000112547254210016317 0ustar s6-rc-0.5.1.1/examples/source/mount-cgroups/type0000644000000000000000000000001012547247153016341 0ustar oneshot s6-rc-0.5.1.1/examples/source/mount-cgroups/up0000644000000000000000000000052213156254435016012 0ustar if { mkdir -p -m 0755 /sys/fs/cgroup } if { s6-mount -wt tmpfs cgroup /sys/fs/cgroup } redirfd -r 0 /proc/cgroups pipeline { s6-tail -n +2 } pipeline { s6-cut -d"\t" -f1 } pipeline { s6-grep -vF -- devices } forstdin -d"\n" -- i importas -u i i if { s6-mkdir /sys/fs/cgroup/${i} } s6-mount -t cgroup -o ${i} -- cgroup /sys/fs/cgroup/${i} s6-rc-0.5.1.1/examples/source/ok-wan/0000755000000000000000000000000012547254507014021 5ustar s6-rc-0.5.1.1/examples/source/ok-wan/type0000644000000000000000000000000712547254334014720 0ustar bundle s6-rc-0.5.1.1/examples/source/ok-wan/contents0000644000000000000000000000002412547277760015603 0ustar wan qmail ntpclient s6-rc-0.5.1.1/examples/source/init-wlan0/0000755000000000000000000000000013156254435014604 5ustar s6-rc-0.5.1.1/examples/source/init-wlan0/dependencies0000644000000000000000000000001112547254761017152 0ustar ok-local s6-rc-0.5.1.1/examples/source/init-wlan0/down0000644000000000000000000000002212547275570015476 0ustar modprobe -r ath9k s6-rc-0.5.1.1/examples/source/init-wlan0/type0000644000000000000000000000001012547247153015501 0ustar oneshot s6-rc-0.5.1.1/examples/source/init-wlan0/up0000644000000000000000000000023013156254435015146 0ustar foreground { modprobe ath9k blink=1 } unexport ? if { iw reg set FR } importas -i WLAN0_IP4 WLAN0_IP4 ifconfig wlan0 ${WLAN0_IP4} netmask 255.255.255.0 s6-rc-0.5.1.1/examples/source/smtpd-4/0001755000000000000000000000000013336722446014115 5ustar s6-rc-0.5.1.1/examples/source/smtpd-4/run0000755000000000000000000000032713156254435014646 0ustar #!/command/execlineb -P fdmove -c 2 1 s6-envuidgid qmaild importas -ui ETH0_IP4 ETH0_IP4 fdmove 1 3 s6-tcpserver4 -v 2 -U -c 255 -1 -- ${ETH0_IP4} 25 s6-tcpserver-access -v 2 -w -t 2000 -i data/rules -- qmail-smtpd s6-rc-0.5.1.1/examples/source/smtpd-4/dependencies0000644000000000000000000000002412550364301016446 0ustar init-lan mount-sync s6-rc-0.5.1.1/examples/source/smtpd-4/type0000644000000000000000000000001012547262150015001 0ustar longrun s6-rc-0.5.1.1/examples/source/smtpd-4/producer-for0000644000000000000000000000001412547262164016440 0ustar smtpd-4-log s6-rc-0.5.1.1/examples/source/smtpd-4/data/0000755000000000000000000000000012547262132015017 5ustar s6-rc-0.5.1.1/examples/source/smtpd-4/data/rules/0000755000000000000000000000000012271223737016153 5ustar s6-rc-0.5.1.1/examples/source/smtpd-4/data/rules/ip4/0000755000000000000000000000000012550367744016656 5ustar s6-rc-0.5.1.1/examples/source/smtpd-4/data/rules/ip4/0.0.0.0_0/0000755000000000000000000000000012271223756017660 5ustar s6-rc-0.5.1.1/examples/source/smtpd-4/data/rules/ip4/0.0.0.0_0/allow0000644000000000000000000000000012271223756020707 0ustar s6-rc-0.5.1.1/examples/source/smtpd-4/data/rules/ip4/192.168.0.0_24/0000755000000000000000000000000012506101035020263 5ustar s6-rc-0.5.1.1/examples/source/smtpd-4/data/rules/ip4/192.168.0.0_24/allow0000644000000000000000000000000012506101034021311 0ustar s6-rc-0.5.1.1/examples/source/smtpd-4/data/rules/ip4/192.168.0.0_24/env/0000755000000000000000000000000012506101044021053 5ustar s6-rc-0.5.1.1/examples/source/smtpd-4/data/rules/ip4/192.168.0.0_24/env/RELAYCLIENT0000644000000000000000000000000112506101044022540 0ustar s6-rc-0.5.1.1/examples/source/smtpd-4/notification-fd0000644000000000000000000000000212537624201017074 0ustar 3 s6-rc-0.5.1.1/examples/source/udhcpc-eth3/0001755000000000000000000000000013336722446014734 5ustar s6-rc-0.5.1.1/examples/source/udhcpc-eth3/run0000755000000000000000000000023213156254435015460 0ustar #!/command/execlineb -P fdmove -c 2 1 s6-envdir -I env importas -uD 1.2.3.4 IP IP udhcpc -f -C -i eth3 -x lease:86400 -r $IP -s /etc/udhcpc/udhcpc-script s6-rc-0.5.1.1/examples/source/udhcpc-eth3/dependencies0000644000000000000000000000002512550364315017273 0ustar init-eth3 mount-rwfs s6-rc-0.5.1.1/examples/source/udhcpc-eth3/type0000644000000000000000000000001012547264126015625 0ustar longrun s6-rc-0.5.1.1/examples/source/udhcpc-eth3/producer-for0000644000000000000000000000002012547264270017254 0ustar udhcpc-eth3-log s6-rc-0.5.1.1/examples/source/udhcpc-eth3/notification-fd0000644000000000000000000000000212545202333017710 0ustar 3 s6-rc-0.5.1.1/examples/source/udhcpc-eth3/env/0000755000000000000000000000000012547264317015524 5ustar s6-rc-0.5.1.1/examples/source/klogd-log/0000755000000000000000000000000013417375671014507 5ustar s6-rc-0.5.1.1/examples/source/klogd-log/pipeline-name0000644000000000000000000000000612645223546017144 0ustar klogd s6-rc-0.5.1.1/examples/source/klogd-log/run0000755000000000000000000000013613417375671015241 0ustar #!/command/execlineb -P s6-setuidgid klog exec -c s6-log -d3 -- t s1000000 n20 /var/log/klogd s6-rc-0.5.1.1/examples/source/klogd-log/dependencies0000644000000000000000000000001312550363520017035 0ustar mount-sync s6-rc-0.5.1.1/examples/source/klogd-log/consumer-for0000644000000000000000000000001212547253226017034 0ustar klogd-srv s6-rc-0.5.1.1/examples/source/klogd-log/type0000644000000000000000000000001012547253213015370 0ustar longrun s6-rc-0.5.1.1/examples/source/klogd-log/notification-fd0000644000000000000000000000000213417375570017475 0ustar 3 s6-rc-0.5.1.1/examples/source/init-sysctl/0000755000000000000000000000000013156254435015104 5ustar s6-rc-0.5.1.1/examples/source/init-sysctl/dependencies0000644000000000000000000000001312547251134017443 0ustar mount-proc s6-rc-0.5.1.1/examples/source/init-sysctl/down0000644000000000000000000000000112547247600015764 0ustar s6-rc-0.5.1.1/examples/source/init-sysctl/type0000644000000000000000000000001012547247153016001 0ustar oneshot s6-rc-0.5.1.1/examples/source/init-sysctl/up0000644000000000000000000000023613156254435015454 0ustar redirfd -r 0 /etc/sysctl.txt forstdin -nCd"\n" -- LINE importas -u LINE LINE multidefine -C $LINE { CTL VALUE } redirfd -w 1 /proc/sys/$CTL s6-echo -- $VALUE s6-rc-0.5.1.1/examples/source/init-diskconfig/0000755000000000000000000000000012547247476015715 5ustar s6-rc-0.5.1.1/examples/source/init-diskconfig/dependencies0000644000000000000000000000000312547247476020257 0ustar 00 s6-rc-0.5.1.1/examples/source/init-diskconfig/down0000644000000000000000000000000112547247600016563 0ustar s6-rc-0.5.1.1/examples/source/init-diskconfig/type0000644000000000000000000000001012547247153016600 0ustar oneshot s6-rc-0.5.1.1/examples/source/init-diskconfig/up0000644000000000000000000000034212550365550016247 0ustar if { redirfd -w 1 /run/disk-devices/rofs s6-echo sda1 } if { redirfd -w 1 /run/disk-devices/rwfs s6-echo sda2 } if { redirfd -w 1 /run/disk-devices/syncfs s6-echo sda3 } if { redirfd -w 1 /run/disk-devices/swap s6-echo sda5 } s6-rc-0.5.1.1/examples/source/mount-rwfs/0000755000000000000000000000000013156254435014743 5ustar s6-rc-0.5.1.1/examples/source/mount-rwfs/dependencies0000644000000000000000000000002012547251003017273 0ustar init-diskconfig s6-rc-0.5.1.1/examples/source/mount-rwfs/down0000644000000000000000000000002412550362754015632 0ustar s6-umount /mnt/rwfs s6-rc-0.5.1.1/examples/source/mount-rwfs/type0000644000000000000000000000001012547247153015640 0ustar oneshot s6-rc-0.5.1.1/examples/source/mount-rwfs/up0000644000000000000000000000016113156254435015310 0ustar s6-envdir -i /run/disk-devices importas -i rwfs rwfs s6-mount -wt ext4 -o barrier=0,nodev /dev/${rwfs} /mnt/rwfs s6-rc-0.5.1.1/examples/source/init-devtmpfs/0000755000000000000000000000000012547247476015425 5ustar s6-rc-0.5.1.1/examples/source/init-devtmpfs/dependencies0000644000000000000000000000000312547247476017767 0ustar 00 s6-rc-0.5.1.1/examples/source/init-devtmpfs/down0000644000000000000000000000000112547247600016273 0ustar s6-rc-0.5.1.1/examples/source/init-devtmpfs/type0000644000000000000000000000001012547247153016310 0ustar oneshot s6-rc-0.5.1.1/examples/source/init-devtmpfs/up0000644000000000000000000000063412550365452015764 0ustar if { mkdir -p -m 0755 -- /dev/pts } if { s6-mount -wt devpts -o noexec,nosuid,gid=0,mode=0600 devpts /dev/pts } if { s6-ln -s /proc/self/fd /dev/fd } if { s6-ln -s /proc/kcore /dev/core } if { s6-ln -s loop0 /dev/loop } if { s6-ln -s ram0 /dev/ram } if { s6-ln -s rtc0 /dev/rtc } if { s6-ln -s /run/shm /dev/shm } if { s6-ln -s fd/0 /dev/stdin } if { s6-ln -s fd/1 /dev/stdout } if { s6-ln -s fd/2 /dev/stderr } s6-rc-0.5.1.1/examples/source/init-coldplug/0000755000000000000000000000000012547247476015406 5ustar s6-rc-0.5.1.1/examples/source/init-coldplug/dependencies0000644000000000000000000000003613336722300017733 0ustar init-devtmpfs mount-sys mdevd s6-rc-0.5.1.1/examples/source/init-coldplug/down0000644000000000000000000000000112547247600016254 0ustar s6-rc-0.5.1.1/examples/source/init-coldplug/type0000644000000000000000000000001012547247153016271 0ustar oneshot s6-rc-0.5.1.1/examples/source/init-coldplug/up0000644000000000000000000000001713336722311015732 0ustar mdevd-coldplug s6-rc-0.5.1.1/examples/source/dns-server-tcp-4-log/0000755000000000000000000000000013417375671016424 5ustar s6-rc-0.5.1.1/examples/source/dns-server-tcp-4-log/pipeline-name0000644000000000000000000000003212562442036021053 0ustar dns-server-tcp-4-pipeline s6-rc-0.5.1.1/examples/source/dns-server-tcp-4-log/run0000755000000000000000000000015313417375734017155 0ustar #!/command/execlineb -P s6-setuidgid dnslog exec -c s6-log -d3 -- t s1000000 n20 /var/log/dns-server-tcp-4 s6-rc-0.5.1.1/examples/source/dns-server-tcp-4-log/dependencies0000644000000000000000000000001312550363520020752 0ustar mount-sync s6-rc-0.5.1.1/examples/source/dns-server-tcp-4-log/consumer-for0000644000000000000000000000002112547256357020761 0ustar dns-server-tcp-4 s6-rc-0.5.1.1/examples/source/dns-server-tcp-4-log/type0000644000000000000000000000001012547256346017317 0ustar longrun s6-rc-0.5.1.1/examples/source/dns-server-tcp-4-log/notification-fd0000644000000000000000000000000213417375570021412 0ustar 3 s6-rc-0.5.1.1/examples/source/udhcpd-wlan0-log/0000755000000000000000000000000013417375671015675 5ustar s6-rc-0.5.1.1/examples/source/udhcpd-wlan0-log/pipeline-name0000644000000000000000000000002612562442036020327 0ustar udhcpd-wlan0-pipeline s6-rc-0.5.1.1/examples/source/udhcpd-wlan0-log/run0000755000000000000000000000015013417375671016423 0ustar #!/command/execlineb -P s6-setuidgid wifilog exec -c s6-log -d3 -- t s1000000 n20 /var/log/udhcpd-wlan0 s6-rc-0.5.1.1/examples/source/udhcpd-wlan0-log/dependencies0000644000000000000000000000001312550363520020223 0ustar mount-sync s6-rc-0.5.1.1/examples/source/udhcpd-wlan0-log/consumer-for0000644000000000000000000000001512547263451020226 0ustar udhcpd-wlan0 s6-rc-0.5.1.1/examples/source/udhcpd-wlan0-log/type0000644000000000000000000000001012547263431016561 0ustar longrun s6-rc-0.5.1.1/examples/source/udhcpd-wlan0-log/notification-fd0000644000000000000000000000000213417375570020663 0ustar 3 s6-rc-0.5.1.1/examples/source/mount-disks/0000755000000000000000000000000012550363337015076 5ustar s6-rc-0.5.1.1/examples/source/mount-disks/type0000644000000000000000000000000712550363314015772 0ustar bundle s6-rc-0.5.1.1/examples/source/mount-disks/contents0000644000000000000000000000004112550363337016651 0ustar mount-rwfs mount-sync mount-swap s6-rc-0.5.1.1/examples/source/init-lan/0000755000000000000000000000000013156254435014335 5ustar s6-rc-0.5.1.1/examples/source/init-lan/dependencies0000644000000000000000000000003212547300235016672 0ustar init-sysctl mount-cgroups s6-rc-0.5.1.1/examples/source/init-lan/down0000644000000000000000000000000112547247600015215 0ustar s6-rc-0.5.1.1/examples/source/init-lan/type0000644000000000000000000000001012547247153015232 0ustar oneshot s6-rc-0.5.1.1/examples/source/init-lan/up0000644000000000000000000000051113156254435014701 0ustar multisubstitute { importas -i ETH0_IP4 ETH0_IP4 importas -i ETH1_IP4 ETH1_IP4 importas -i ETH2_IP4 ETH2_IP4 } if { ifconfig lo 127.0.0.1 netmask 255.0.0.0 } if { ifconfig eth0 ${ETH0_IP4} netmask 255.255.255.0 } if { ifconfig eth1 ${ETH1_IP4} netmask 255.255.255.0 } if { ifconfig eth2 ${ETH2_IP4} netmask 255.255.255.0 } s6-rc-0.5.1.1/examples/source/mdevd/0000755000000000000000000000000013336722154013717 5ustar s6-rc-0.5.1.1/examples/source/mdevd/run0000755000000000000000000000010513336722144014444 0ustar #!/command/execlineb -P exec -c export PATH /command:/bin mdevd -D 3 s6-rc-0.5.1.1/examples/source/mdevd/dependencies0000644000000000000000000000001613110267557016266 0ustar init-devtmpfs s6-rc-0.5.1.1/examples/source/mdevd/type0000644000000000000000000000001013006623650014605 0ustar longrun s6-rc-0.5.1.1/examples/source/mdevd/notification-fd0000644000000000000000000000000213336722154016707 0ustar 3 s6-rc-0.5.1.1/examples/source/taiclockd-4-log/0000755000000000000000000000000013417375671015505 5ustar s6-rc-0.5.1.1/examples/source/taiclockd-4-log/pipeline-name0000644000000000000000000000002512562442036020136 0ustar taiclockd-4-pipeline s6-rc-0.5.1.1/examples/source/taiclockd-4-log/run0000755000000000000000000000014613417375671016240 0ustar #!/command/execlineb -P s6-setuidgid tailog exec -c s6-log -d3 -- t s1000000 n20 /var/log/taiclockd-4 s6-rc-0.5.1.1/examples/source/taiclockd-4-log/dependencies0000644000000000000000000000001312550363520020033 0ustar mount-sync s6-rc-0.5.1.1/examples/source/taiclockd-4-log/consumer-for0000644000000000000000000000001412547263015020031 0ustar taiclockd-4 s6-rc-0.5.1.1/examples/source/taiclockd-4-log/type0000644000000000000000000000001012547263005016366 0ustar longrun s6-rc-0.5.1.1/examples/source/taiclockd-4-log/notification-fd0000644000000000000000000000000213417375570020473 0ustar 3 s6-rc-0.5.1.1/examples/source/dns-cache/0001755000000000000000000000000013336722446014452 5ustar s6-rc-0.5.1.1/examples/source/dns-cache/run0000755000000000000000000000035213156254435015201 0ustar #!/command/execlineb -P fdmove -c 2 1 s6-envuidgid dnscache s6-envdir env importas ETH0_IP4 ETH0_IP4 export IP ${ETH0_IP4} s6-softlimit -m 4000000 pipeline -d { redirfd -r 0 /dev/urandom s6-head -c 128 } unexport LASTPID dnscache s6-rc-0.5.1.1/examples/source/dns-cache/dependencies0000644000000000000000000000002612547256012017012 0ustar init-urandom init-lan s6-rc-0.5.1.1/examples/source/dns-cache/type0000644000000000000000000000001012547256030015336 0ustar longrun s6-rc-0.5.1.1/examples/source/dns-cache/producer-for0000644000000000000000000000001612547256061016776 0ustar dns-cache-log s6-rc-0.5.1.1/examples/source/dns-cache/data/0000755000000000000000000000000012547255370015362 5ustar s6-rc-0.5.1.1/examples/source/dns-cache/data/root/0000755000000000000000000000000011535423036016335 5ustar s6-rc-0.5.1.1/examples/source/dns-cache/data/root/servers/0000755000000000000000000000000012550365032020025 5ustar s6-rc-0.5.1.1/examples/source/dns-cache/data/root/servers/@0000644000000000000000000000025012550365040020123 0ustar 198.41.0.4 192.228.79.201 192.33.4.12 128.8.10.90 192.203.230.10 192.5.5.241 192.112.36.4 128.63.2.53 192.36.148.17 192.58.128.30 193.0.14.129 199.7.83.42 202.12.27.33 s6-rc-0.5.1.1/examples/source/dns-cache/data/root/servers/168.192.in-addr.arpa0000777000000000000000000000000012550365032025167 2example.comustar s6-rc-0.5.1.1/examples/source/dns-cache/data/root/servers/example.com0000644000000000000000000000001412550365004022152 0ustar 192.168.1.1 s6-rc-0.5.1.1/examples/source/dns-cache/data/root/ip/0000755000000000000000000000000012550364757016761 5ustar s6-rc-0.5.1.1/examples/source/dns-cache/data/root/ip/192.168.20000644000000000000000000000000012502550113017636 0ustar s6-rc-0.5.1.1/examples/source/dns-cache/data/root/ip/192.168.10000644000000000000000000000000012502550112017634 0ustar s6-rc-0.5.1.1/examples/source/dns-cache/data/root/ip/192.168.00000644000000000000000000000000012316371013017637 0ustar s6-rc-0.5.1.1/examples/source/dns-cache/data/root/ip/192.168.40000644000000000000000000000000012502550114017641 0ustar s6-rc-0.5.1.1/examples/source/dns-cache/data/root/ip/127.0.0.10000644000000000000000000000000011535423041017616 0ustar s6-rc-0.5.1.1/examples/source/dns-cache/data/root/ip/192.168.30000644000000000000000000000000012502550113017637 0ustar s6-rc-0.5.1.1/examples/source/dns-cache/env/0000755000000000000000000000000012502327327015232 5ustar s6-rc-0.5.1.1/examples/source/dns-cache/env/IPSEND0000644000000000000000000000001012316370740016126 0ustar 0.0.0.0 s6-rc-0.5.1.1/examples/source/dns-cache/env/ROOT0000644000000000000000000000004112550364706015740 0ustar /run/service/dns-cache/data/root s6-rc-0.5.1.1/examples/source/dns-cache/env/CACHESIZE0000644000000000000000000000001012231455345016443 0ustar 2097152 s6-rc-0.5.1.1/examples/source/qmail-log/0000755000000000000000000000000013417375671014512 5ustar s6-rc-0.5.1.1/examples/source/qmail-log/pipeline-name0000644000000000000000000000001712562442036017144 0ustar qmail-pipeline s6-rc-0.5.1.1/examples/source/qmail-log/run0000755000000000000000000000014313417375671015242 0ustar #!/command/execlineb -P s6-setuidgid qmaillog exec -c s6-log -d3 -- t s16777216 n64 /var/log/qmail s6-rc-0.5.1.1/examples/source/qmail-log/dependencies0000644000000000000000000000001312550363520017040 0ustar mount-sync s6-rc-0.5.1.1/examples/source/qmail-log/consumer-for0000644000000000000000000000000612547276501017043 0ustar qmail s6-rc-0.5.1.1/examples/source/qmail-log/type0000644000000000000000000000001012547276460015404 0ustar longrun s6-rc-0.5.1.1/examples/source/qmail-log/notification-fd0000644000000000000000000000000213417375570017500 0ustar 3 s6-rc-0.5.1.1/examples/source/identd-4/0001755000000000000000000000000013336722446014235 5ustar s6-rc-0.5.1.1/examples/source/identd-4/run0000755000000000000000000000031613156254435014764 0ustar #!/command/execlineb -P fdmove -c 2 1 s6-envuidgid ident importas -ui ETH0_IP4 ETH0_IP4 fdmove 1 3 s6-tcpserver4 -v 1 -U -c 512 -1 -- ${ETH0_IP4} 113 s6-tcpserver-access -Hl0 -t 2000 -- minidentd -vt 10000 s6-rc-0.5.1.1/examples/source/identd-4/dependencies0000644000000000000000000000001112547261327016574 0ustar init-lan s6-rc-0.5.1.1/examples/source/identd-4/type0000644000000000000000000000001012547261270015123 0ustar longrun s6-rc-0.5.1.1/examples/source/identd-4/producer-for0000644000000000000000000000001512547261302016552 0ustar identd-4-log s6-rc-0.5.1.1/examples/source/identd-4/notification-fd0000644000000000000000000000000212537624201017214 0ustar 3 s6-rc-0.5.1.1/examples/source/smtpd-4-log/0000755000000000000000000000000013417375671014677 5ustar s6-rc-0.5.1.1/examples/source/smtpd-4-log/pipeline-name0000644000000000000000000000002112562442036017324 0ustar smtpd-4-pipeline s6-rc-0.5.1.1/examples/source/smtpd-4-log/run0000755000000000000000000000014413417375671015430 0ustar #!/command/execlineb -P s6-setuidgid qmaillog exec -c s6-log -d3 -- t s1000000 n20 /var/log/smtpd-4 s6-rc-0.5.1.1/examples/source/smtpd-4-log/dependencies0000644000000000000000000000001312550363520017225 0ustar mount-sync s6-rc-0.5.1.1/examples/source/smtpd-4-log/consumer-for0000644000000000000000000000001012547262241017217 0ustar smtpd-4 s6-rc-0.5.1.1/examples/source/smtpd-4-log/type0000644000000000000000000000001012547262244015564 0ustar longrun s6-rc-0.5.1.1/examples/source/smtpd-4-log/notification-fd0000644000000000000000000000000213417375570017665 0ustar 3 s6-rc-0.5.1.1/README.macos0000644000000000000000000000025313207063057011460 0ustar This package will compile and run on Darwin (MacOS), but the building of shared libraries is not supported. Make sure you use the --disable-shared option to configure. s6-rc-0.5.1.1/README.solaris0000644000000000000000000000065312376372746012054 0ustar This package assumes the existence of a POSIX shell in /bin/sh. On Solaris, /bin/sh is not POSIX. Most versions of Solaris provide a POSIX shell in /usr/xpg4/bin/sh. To compile this package on Solaris, you will need to run ./patch-for-solaris before you run ./configure. This script will change the #! invocation of the configure script and various tools so that a POSIX shell is used for the compilation process. s6-rc-0.5.1.1/AUTHORS0000644000000000000000000000113513527043471010552 0ustar Main author: Laurent Bercot Contributors: Eric Le Bihan Brett Neumeier Lionel Van Bemten Thanks to: Avery Payne Olivier Brunel Guillermo Colin Booth Casper Ti. Vector Jesse Young Rasmus Villemoes Jan Bramkamp Guillermo Josuah Demangeon s6-rc-0.5.1.1/INSTALL0000644000000000000000000001500113553360045010526 0ustar Build Instructions ------------------ * Requirements ------------ - A POSIX-compliant C development environment - GNU make version 3.81 or later - skalibs version 2.9.1.0 or later: http://skarnet.org/software/skalibs/ - execline version 2.5.3.0 or later: http://skarnet.org/software/execline/ - s6 version 2.9.0.1 or later: http://skarnet.org/software/s6/ This software will run on any operating system that implements POSIX.1-2008, available at: http://pubs.opengroup.org/onlinepubs/9699919799/ * Standard usage -------------- ./configure && make && sudo make install will work for most users. It will install the binaries in /bin and the static libraries in /usr/lib/s6-rc. Please note that static libraries in /usr/lib/s6-rc *will not* be found by a default linker invocation: you need -L/usr/lib/s6-rc. Other skarnet.org software automatically handles that case if the default configuration is used, but if you change the configuration, remember to use the appropriate --with-lib configure option. 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. * 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-rc-0.5.1.1/patch-for-solaris0000755000000000000000000000075112443715173012771 0ustar #!/usr/xpg4/bin/sh patchit () { echo '#!/usr/xpg4/bin/sh' > $1.tmp tail -n +2 $1 >> $1.tmp mv -f $1.tmp $1 chmod 755 $1 } # Solaris doesn't understand POSIX.1-2008 either. sed -e 's/XOPEN_SOURCE=700/XOPEN_SOURCE=600/' < configure > configure.tmp mv -f configure.tmp configure patchit ./configure patchit ./tools/install.sh patchit ./tools/gen-deps.sh echo 'SHELL := /usr/xpg4/bin/sh' > Makefile.tmp echo >> Makefile.tmp cat Makefile >> Makefile.tmp mv -f Makefile.tmp Makefile s6-rc-0.5.1.1/README0000644000000000000000000000157313553367227010377 0ustar s6-rc - a dependency-based init script management system -------------------------------------------------------- s6-rc is a suite of programs designed to help Unix distributions manage services provided by various software packages, and automate initialization, shutdown, and more generally changes to the machine state. It keeps track of the complete service dependency tree and automatically brings services up or down to reach the desired state. In conjunction with s6, it ensures that long-lived services are supervised, and that short-lived instructions are run in a reproducible manner. See https://skarnet.org/software/s6-rc/ for details. * Installation ------------ See the INSTALL file. * Contact information ------------------- Laurent Bercot Please use the mailing-list for questions about s6-rc. s6-rc-0.5.1.1/src/0000755000000000000000000000000012521655463010274 5ustar s6-rc-0.5.1.1/src/libs6rc/0000755000000000000000000000000013541514470011633 5ustar s6-rc-0.5.1.1/src/libs6rc/s6rc_graph_closure.c0000644000000000000000000000225513061734164015576 0ustar /* ISC license. */ #include #include #include #include typedef struct recinfo_s recinfo_t, *recinfo_t_ref ; struct recinfo_s { s6rc_db_t const *db ; unsigned int n ; unsigned char *bits ; unsigned char *mark ; unsigned char mask ; unsigned char h : 1 ; } ; static void s6rc_graph_closure_rec (recinfo_t *recinfo, unsigned int i) { if (!bitarray_peek(recinfo->mark, i)) { unsigned int j = recinfo->db->services[i].ndeps[recinfo->h] ; bitarray_set(recinfo->mark, i) ; while (j--) s6rc_graph_closure_rec(recinfo, recinfo->db->deps[recinfo->h * recinfo->db->ndeps + recinfo->db->services[i].deps[recinfo->h] + j]) ; recinfo->bits[i] |= recinfo->mask ; } } void s6rc_graph_closure (s6rc_db_t const *db, unsigned char *bits, unsigned int bitno, int h) { unsigned int n = db->nshort + db->nlong ; unsigned int m = bitarray_div8(n) ; unsigned char mark[m] ; recinfo_t info = { .db = db, .n = n, .bits = bits, .mark = mark, .mask = 1 << (bitno & 7), .h = !!h } ; unsigned int i = n ; memset(mark, 0, m) ; while (i--) if (bits[i] & info.mask) s6rc_graph_closure_rec(&info, i) ; } s6-rc-0.5.1.1/src/libs6rc/s6rc_servicedir_block.c0000644000000000000000000000112213324563667016254 0ustar /* ISC license. */ #include #include #include #include #include #include int s6rc_servicedir_block (char const *dir) { size_t dirlen = strlen(dir) ; s6_svstatus_t status ; char fn[dirlen + 6] ; if (!s6_svstatus_read(dir, &status)) return -1 ; memcpy(fn, dir, dirlen) ; memcpy(fn + dirlen, "/down", 6) ; if (!touch(fn)) return -1 ; if (s6_svc_writectl(dir, S6_SUPERVISE_CTLDIR, "O", 1) < 0) { unlink_void(fn) ; return -1 ; } return status.flagwantup ; } s6-rc-0.5.1.1/src/libs6rc/s6rc_db_read_uint32.c0000644000000000000000000000044013061734164015517 0ustar /* ISC license. */ #include #include #include int s6rc_db_read_uint32 (buffer *b, uint32_t *x) { size_t w = 0 ; char pack[4] ; if (buffer_getall(b, pack, 4, &w) <= 0) return 0 ; uint32_unpack_big(pack, x) ; return 1 ; } s6-rc-0.5.1.1/src/libs6rc/s6rc_db_read_sizes.c0000644000000000000000000000205713207066205015532 0ustar /* ISC license. */ #include #include #include #include #include #include static inline int s6rc_db_read_sizes_buffer (buffer *b, s6rc_db_t *db) { uint32_t x ; if (!s6rc_db_read_uint32(b, &x)) return 0 ; db->nshort = x ; if (!s6rc_db_read_uint32(b, &x)) return 0 ; db->nlong = x ; if (!s6rc_db_read_uint32(b, &x)) return 0 ; db->stringlen = x ; if (!s6rc_db_read_uint32(b, &x)) return 0 ; db->nargvs = x ; if (!s6rc_db_read_uint32(b, &x)) return 0 ; db->ndeps = x ; if (!s6rc_db_read_uint32(b, &x)) return 0 ; db->nproducers = x ; return 1 ; } int s6rc_db_read_sizes (int fdcompiled, s6rc_db_t *db) { char buf[24] ; buffer b ; int fd = open_readatb(fdcompiled, "n") ; if (fd < 0) return 0 ; buffer_init(&b, &buffer_read, fd, buf, 24) ; if (!s6rc_db_read_sizes_buffer(&b, db)) { fd_close(fd) ; return 0 ; } { char c ; ssize_t r = buffer_get(&b, &c, 1) ; fd_close(fd) ; return !r ; } } s6-rc-0.5.1.1/src/libs6rc/s6rc_db_read.c0000644000000000000000000001247113433016110014305 0ustar /* ISC license. */ #include #include #include #include #include #include #include #include #ifdef DEBUG #include #define DBG(...) LOLDEBUG(__VA_ARGS__) #else #define DBG(...) #endif static int s6rc_db_check_valid_string (char const *string, size_t stringlen, size_t pos) { if (pos >= stringlen) return 0 ; if (strnlen(string + pos, stringlen - pos) == stringlen - pos) return 0 ; return 1 ; } static inline int s6rc_db_check_valid_strings (char const *string, size_t stringlen, size_t pos, unsigned int n) { while (n--) { if (!s6rc_db_check_valid_string(string, stringlen, pos)) return 0 ; pos += strlen(string + pos) + 1 ; } return 1 ; } static inline int s6rc_db_read_uints (buffer *b, unsigned int max, uint32_t *p, unsigned int n) { uint32_t x ; while (n--) { if (!s6rc_db_read_uint32(b, &x)) return -1 ; if (x >= max) return 0 ; *p++ = x ; } return 1 ; } static inline int s6rc_db_read_services (buffer *b, s6rc_db_t *db) { unsigned int n = db->nshort + db->nlong ; unsigned int nargvs = db->nargvs ; unsigned int argvpos = 0 ; unsigned int i = 0 ; for (; i < n ; i++) { s6rc_service_t *sv = db->services + i ; DBG("service %u/%u", i, n) ; if (!s6rc_db_read_uint32(b, &sv->name)) return -1 ; DBG(" name is %u: %s", sv->name, db->string + sv->name) ; if (sv->name >= db->stringlen) return 0 ; if (!s6rc_db_check_valid_string(db->string, db->stringlen, sv->name)) return 0 ; if (!s6rc_db_read_uint32(b, &sv->flags)) return -1 ; DBG(" flags is %x", sv->flags) ; if (!s6rc_db_read_uint32(b, &sv->timeout[0])) return -1 ; DBG(" timeout0 is %u", sv->timeout[0]) ; if (!s6rc_db_read_uint32(b, &sv->timeout[1])) return -1 ; DBG(" timeout1 is %u", sv->timeout[1]) ; if (!s6rc_db_read_uint32(b, &sv->ndeps[0])) return -1 ; DBG(" ndeps0 is %u", sv->ndeps[0]) ; if (!s6rc_db_read_uint32(b, &sv->ndeps[1])) return -1 ; DBG(" ndeps1 is %u", sv->ndeps[1]) ; if (!s6rc_db_read_uint32(b, &sv->deps[0])) return -1 ; DBG(" deps0 is %u", sv->deps[0]) ; if (sv->deps[0] > db->ndeps || sv->deps[0] + sv->ndeps[0] > db->ndeps) return 0 ; if (!s6rc_db_read_uint32(b, &sv->deps[1])) return -1 ; DBG(" deps1 is %u", sv->deps[1]) ; if (sv->deps[1] > db->ndeps || sv->deps[1] + sv->ndeps[1] > db->ndeps) return 0 ; #ifdef DEBUG { unsigned int k = 0 ; for (; k < sv->ndeps[0] ; k++) DBG(" rev dep on %u", db->deps[sv->deps[0] + k]) ; for (k = 0 ; k < sv->ndeps[1] ; k++) DBG(" dep on %u", db->deps[db->ndeps + sv->deps[1] + k]) ; } #endif if (i < db->nlong) { if (!s6rc_db_read_uint32(b, &sv->x.longrun.consumer)) return -1 ; if (!s6rc_db_read_uint32(b, &sv->x.longrun.nproducers)) return -1 ; if (!s6rc_db_read_uint32(b, &sv->x.longrun.producers)) return -1 ; } else { unsigned int j = 0 ; DBG(" oneshot") ; for (; j < 2 ; j++) { uint32_t pos, argc ; if (!s6rc_db_read_uint32(b, &argc)) return -1 ; DBG(" argc[%u] is %u, nargvs is %u", j, argc, nargvs) ; if (argc > nargvs) return 0 ; if (!s6rc_db_read_uint32(b, &pos)) return -1 ; DBG(" pos[%u] is %u", j, pos) ; if (!s6rc_db_check_valid_strings(db->string, db->stringlen, pos, argc)) return 0 ; if (!env_make((char const **)db->argvs + argvpos, argc, db->string + pos, db->stringlen - pos)) return -1 ; DBG(" first arg is %s", db->argvs[argvpos]) ; sv->x.oneshot.argv[j] = argvpos ; sv->x.oneshot.argc[j] = argc ; argvpos += argc ; nargvs -= argc ; if (!nargvs--) return 0 ; db->argvs[argvpos++] = 0 ; } } { char c ; if (buffer_get(b, &c, 1) < 1) return -1 ; if (c != '\376') return 0 ; } } if (nargvs) return 0 ; return 1 ; } static inline int s6rc_db_read_string (buffer *b, char *string, size_t len) { if (buffer_get(b, string, len) < (ssize_t)len) return -1 ; return 1 ; } static inline int s6rc_db_read_buffer (buffer *b, s6rc_db_t *db) { { char banner[S6RC_DB_BANNER_START_LEN] ; if (buffer_get(b, banner, S6RC_DB_BANNER_START_LEN) < S6RC_DB_BANNER_START_LEN) return -1 ; if (memcmp(banner, S6RC_DB_BANNER_START, S6RC_DB_BANNER_START_LEN)) return 0 ; } { int r = s6rc_db_read_string(b, db->string, db->stringlen) ; if (r < 1) return r ; r = s6rc_db_read_uints(b, db->nshort + db->nlong, db->deps, db->ndeps << 1) ; if (r < 1) return r ; r = s6rc_db_read_uints(b, db->nlong, db->producers, db->nproducers) ; if (r < 1) return r ; r = s6rc_db_read_services(b, db) ; if (r < 1) return r ; } { char banner[S6RC_DB_BANNER_END_LEN] ; if (buffer_get(b, banner, S6RC_DB_BANNER_END_LEN) < S6RC_DB_BANNER_END_LEN) return -1 ; if (memcmp(banner, S6RC_DB_BANNER_END, S6RC_DB_BANNER_END_LEN)) return 0 ; } return 1 ; } int s6rc_db_read (int fdcompiled, s6rc_db_t *db) { int r ; buffer b ; char buf[BUFFER_INSIZE] ; int fd = open_readatb(fdcompiled, "db") ; if (fd < 0) return -1 ; buffer_init(&b, &buffer_read, fd, buf, BUFFER_INSIZE) ; r = s6rc_db_read_buffer(&b, db) ; fd_close(fd) ; return r ; } s6-rc-0.5.1.1/src/libs6rc/s6rc_read_uint.c0000644000000000000000000000072713166374630014721 0ustar /* ISC license. */ #include #include #include #include #include #include int s6rc_read_uint (char const *file, unsigned int *u) { char buf[UINT_FMT + 1] ; ssize_t r = openreadnclose(file, buf, UINT_FMT) ; if (r < 0) return (errno == ENOENT) ? 0 : -1 ; buf[byte_chr(buf, r, '\n')] = 0 ; if (!uint0_scan(buf, u)) return (errno = EINVAL, -1) ; return 1 ; } s6-rc-0.5.1.1/src/libs6rc/s6rc-servicedir-internal.h0000644000000000000000000000143213061734164016631 0ustar /* ISC license. */ #ifndef S6RC_SERVICEDIR_INTERNAL_H #define S6RC_SERVICEDIR_INTERNAL_H #include typedef enum s6rc_filetype_e s6rc_filetype_t, *s6rc_filetype_t_ref ; enum s6rc_filetype_e { FILETYPE_NORMAL, FILETYPE_EMPTY, FILETYPE_UINT, FILETYPE_DIR } ; #define SVFILE_EXECUTABLE 0x01 #define SVFILE_MANDATORY 0x02 #define SVFILE_ATOMIC 0x04 typedef struct s6rc_servicedir_desc_s s6rc_servicedir_desc_t, *s6rc_servicedir_desc_t_ref ; struct s6rc_servicedir_desc_s { char const *name ; s6rc_filetype_t type ; unsigned char options ; } ; extern s6rc_servicedir_desc_t const *s6rc_servicedir_file_list ; extern size_t const s6rc_servicedir_file_maxlen ; extern int s6rc_servicedir_copy_one (char const *, char const *, s6rc_servicedir_desc_t const *) ; #endif s6-rc-0.5.1.1/src/libs6rc/s6rc_livedir_create.c0000644000000000000000000000332613426511061015714 0ustar /* ISC license. */ #include #include #include #include #include #include #include #include #include int s6rc_livedir_create (stralloc *sa, char const *live, char const *suffix, char const *scandir, char const *prefix, char const *compiled, unsigned char const *state, unsigned int statelen, size_t *dirlen) { size_t newlen, ddirlen ; size_t sabase = sa->len ; int wasnull = !sa->s ; if (!s6rc_sanitize_dir(sa, live, &ddirlen)) return 0 ; if (!stralloc_cats(sa, ":")) goto err ; if (!stralloc_cats(sa, suffix)) goto err ; if (!stralloc_cats(sa, ":XXXXXX")) goto err ; if (!stralloc_0(sa)) goto err ; if (!mkdtemp(sa->s + sabase)) goto err ; newlen = sa->len-- ; if (chmod(sa->s + sabase, 0755) < 0) goto delerr ; if (!stralloc_catb(sa, "/servicedirs", 13)) goto delerr ; /* allocates enough for the next strcpys */ if (mkdir(sa->s + sabase, 0755) < 0) goto delerr ; strcpy(sa->s + newlen, "compiled") ; if (symlink(compiled, sa->s + sabase) < 0) goto delerr ; strcpy(sa->s + newlen, "scandir") ; if (symlink(scandir, sa->s + sabase) < 0) goto delerr ; strcpy(sa->s + newlen, "prefix") ; if (!openwritenclose_unsafe(sa->s + sabase, prefix, strlen(prefix))) goto delerr ; strcpy(sa->s + newlen, "state") ; if (!openwritenclose_unsafe(sa->s + sabase, (char const *)state, statelen)) goto delerr ; sa->len = newlen-1 ; sa->s[newlen-1] = 0 ; *dirlen = ddirlen ; return 1 ; delerr: { int e = errno ; sa->s[newlen] = 0 ; rm_rf_in_tmp(sa, sabase) ; errno = e ; } err: if (wasnull) stralloc_free(sa) ; else sa->len = sabase ; return 0 ; } s6-rc-0.5.1.1/src/libs6rc/s6rc_livedir_prefix.c0000644000000000000000000000075413166707376015771 0ustar /* ISC license. */ #include #include #include #include ssize_t s6rc_livedir_prefix (char const *live, char *s, size_t n) { size_t llen = strlen(live) ; ssize_t r ; char sfn[llen + 8] ; memcpy(sfn, live, llen) ; memcpy(sfn + llen, "/prefix", 8) ; r = openreadnclose(sfn, s, n) ; if (r < 0) return errno == ENOENT ? 0 : r ; if (memchr(s, '/', r) || memchr(s, '\n', r)) return (errno = EINVAL, -1) ; return r ; } s6-rc-0.5.1.1/src/libs6rc/deps-exe/0000755000000000000000000000000012521655511013344 5ustar s6-rc-0.5.1.1/src/libs6rc/s6rc_servicedir_copy_offline.c0000644000000000000000000000066712645223546017645 0ustar /* ISC license. */ #include #include #include "s6rc-servicedir-internal.h" #include int s6rc_servicedir_copy_offline (char const *src, char const *dst) { s6rc_servicedir_desc_t const *p = s6rc_servicedir_file_list ; if (mkdir(dst, 0755) < 0) { if (errno != EEXIST) return 0 ; } for (; p->name ; p++) if (!s6rc_servicedir_copy_one(src, dst, p)) return 0 ; return 1 ; } s6-rc-0.5.1.1/src/libs6rc/s6rc_servicedir_internal.c0000644000000000000000000000560113310733043016762 0ustar /* ISC license. */ #include #include #include #include #include #include #include "s6rc-servicedir-internal.h" static s6rc_servicedir_desc_t const svdir_file_list[] = { { .name = "finish", .type = FILETYPE_NORMAL, .options = SVFILE_EXECUTABLE | SVFILE_ATOMIC }, { .name = "finish.user", .type = FILETYPE_NORMAL, .options = SVFILE_EXECUTABLE }, { .name = "run", .type = FILETYPE_NORMAL, .options = SVFILE_EXECUTABLE | SVFILE_MANDATORY | SVFILE_ATOMIC }, { .name = "run.user", .type = FILETYPE_NORMAL, .options = SVFILE_EXECUTABLE }, { .name = "nosetsid", .type = FILETYPE_EMPTY, .options = 0 }, { .name = "notification-fd", .type = FILETYPE_UINT, .options = 0 }, { .name = "timeout-kill", .type = FILETYPE_UINT, .options = 0 }, { .name = "timeout-finish", .type = FILETYPE_UINT, .options = 0 }, { .name = "max-death-tally", .type = FILETYPE_UINT, .options = 0 }, { .name = "down-signal", .type = FILETYPE_NORMAL, .options = 0 }, { .name = "data", .type = FILETYPE_DIR, .options = 0 }, { .name = "env", .type = FILETYPE_DIR, .options = 0 }, { .name = 0, .options = 0 } } ; s6rc_servicedir_desc_t const *s6rc_servicedir_file_list = svdir_file_list ; size_t const s6rc_servicedir_file_maxlen = 16 ; int s6rc_servicedir_copy_one (char const *src, char const *dst, s6rc_servicedir_desc_t const *p) { size_t srclen = strlen(src) ; size_t dstlen = strlen(dst) ; size_t plen = strlen(p->name) ; char srcfn[srclen + plen + 2] ; char dstfn[dstlen + plen + 2] ; memcpy(srcfn, src, srclen) ; srcfn[srclen] = '/' ; memcpy(srcfn + srclen + 1, p->name, plen + 1) ; memcpy(dstfn, dst, dstlen) ; dstfn[dstlen] = '/' ; memcpy(dstfn + dstlen + 1, p->name, plen + 1) ; switch (p->type) { case FILETYPE_NORMAL : { unsigned int mode = p->options & SVFILE_EXECUTABLE ? 0755 : 0644 ; if (!(p->options & SVFILE_ATOMIC ? filecopy_suffix(srcfn, dstfn, mode, ".new") : filecopy_unsafe(srcfn, dstfn, mode))) { if (errno != ENOENT || p->options & SVFILE_MANDATORY) return 0 ; } break ; } case FILETYPE_EMPTY : if (access(srcfn, F_OK) < 0) { if (errno != ENOENT || p->options & SVFILE_MANDATORY) return 0 ; } else if (!touch(dstfn)) return 0 ; break ; case FILETYPE_UINT : { unsigned int u ; int r = s6rc_read_uint(srcfn, &u) ; if (r < 0 || (!r && p->options & SVFILE_MANDATORY)) return 0 ; if (r) { char fmt[UINT_FMT] ; r = uint_fmt(fmt, u) ; fmt[r++] = '\n' ; if (!openwritenclose_unsafe(dstfn, fmt, r)) return 0 ; } break ; } case FILETYPE_DIR : if (!hiercopy(srcfn, dstfn)) { if (errno != ENOENT || p->options & SVFILE_MANDATORY) return 0 ; } break ; default : return (errno = EDOM, 0) ; } return 1 ; } s6-rc-0.5.1.1/src/libs6rc/s6rc_sanitize_dir.c0000644000000000000000000000116013061734164015417 0ustar /* ISC license. */ #include #include #include #include int s6rc_sanitize_dir (stralloc *sa, char const *fn, size_t *dirlen) { size_t base = sa->len ; size_t fnlen = strlen(fn) ; size_t ddirlen ; int wasnull = !sa->s ; if (!sadirname(sa, fn, fnlen)) return 0 ; if (sa->len != base + 1 || sa->s[base] != '/') if (!stralloc_catb(sa, "/", 1)) goto err ; ddirlen = sa->len ; if (!sabasename(sa, fn, fnlen)) goto err ; *dirlen = ddirlen ; return 1 ; err: if (wasnull) stralloc_free(sa) ; else sa->len = base ; return 0 ; } s6-rc-0.5.1.1/src/libs6rc/s6rc_servicedir_manage.c0000644000000000000000000000665113324554720016414 0ustar /* ISC license. */ #include #include #include #include #include #include #include #include #include #include #include #include static inline void rollback (char const *live, char const *prefix, char const *s, size_t len) { while (len) { size_t n = strlen(s) + 1 ; s6rc_servicedir_unsupervise(live, prefix, s, 0) ; s += n ; len -= n ; } } int s6rc_servicedir_manage (char const *live, char const *prefix, tain_t const *deadline, tain_t *stamp) { ftrigr_t a = FTRIGR_ZERO ; stralloc newnames = STRALLOC_ZERO ; genalloc ids = GENALLOC_ZERO ; /* uint16_t */ gid_t gid = getgid() ; size_t livelen = strlen(live) ; size_t prefixlen = strlen(prefix) ; int fdlock ; int ok = 1 ; DIR *dir ; char dirfn[livelen + 13] ; if (!ftrigr_startf(&a, deadline, stamp)) return 0 ; memcpy(dirfn, live, livelen) ; memcpy(dirfn + livelen, "/servicedirs", 13) ; dir = opendir(dirfn) ; if (!dir) goto closederr ; for (;;) { direntry *d ; errno = 0 ; d = readdir(dir) ; if (!d) break ; if (d->d_name[0] == '.') continue ; { size_t len = strlen(d->d_name) ; int r ; uint16_t id ; char srcfn[livelen + 20 + len] ; char dstfn[livelen + 10 + prefixlen + len] ; memcpy(srcfn, dirfn, livelen + 12) ; srcfn[livelen + 12] = '/' ; memcpy(srcfn + livelen + 13, d->d_name, len + 1) ; fdlock = s6_svc_lock_take(srcfn) ; if (fdlock < 0) goto err ; r = s6_svc_ok(srcfn) ; if (r < 0) goto erru ; if (!r) { memcpy(srcfn + livelen + 13 + len, "/down", 6) ; if (!touch(srcfn)) goto erru ; memcpy(srcfn + livelen + 14 + len, "event", 6) ; if (!ftrigw_fifodir_make(srcfn, gid, 0)) goto erru ; id = ftrigr_subscribe(&a, srcfn, "s", 0, deadline, stamp) ; if (!id) goto erru ; s6_svc_lock_release(fdlock) ; if (!genalloc_append(uint16_t, &ids, &id)) goto err ; srcfn[livelen + 13 + len] = 0 ; } else s6_svc_lock_release(fdlock) ; memcpy(dstfn, live, livelen) ; memcpy(dstfn + livelen, "/scandir/", 9) ; memcpy(dstfn + livelen + 9, prefix, prefixlen) ; memcpy(dstfn + livelen + 9 + prefixlen, d->d_name, len + 1) ; if (symlink(srcfn, dstfn) < 0) { if (!r || errno != EEXIST) goto err ; } else if (!r) { if (!stralloc_catb(&newnames, d->d_name, len + 1)) { s6rc_servicedir_unsupervise(live, prefix, d->d_name, 0) ; goto err ; } } } } if (errno) goto err ; dir_close(dir) ; { char scanfn[livelen + 9] ; int r ; memcpy(scanfn, live, livelen) ; memcpy(scanfn + livelen, "/scandir", 9) ; r = s6_svc_writectl(scanfn, S6_SVSCAN_CTLDIR, "a", 1) ; if (r < 0) goto closederr ; if (!r) ok = 3 ; else if (ftrigr_wait_and(&a, genalloc_s(uint16_t, &ids), genalloc_len(uint16_t, &ids), deadline, stamp) < 0) goto closederr ; } ftrigr_end(&a) ; genalloc_free(uint16_t, &ids) ; stralloc_free(&newnames) ; return ok ; erru: s6_svc_lock_release(fdlock) ; err: dir_close(dir) ; closederr: ftrigr_end(&a) ; genalloc_free(uint16_t, &ids) ; rollback(live, prefix, newnames.s, newnames.len) ; stralloc_free(&newnames) ; return 0 ; } s6-rc-0.5.1.1/src/libs6rc/s6rc_livedir_prefixsize.c0000644000000000000000000000111013172057607016637 0ustar /* ISC license. */ #include #include #include #include #include int s6rc_livedir_prefixsize (char const *live, size_t *n) { struct stat st ; size_t llen = strlen(live) ; char sfn[llen + 8] ; memcpy(sfn, live, llen) ; memcpy(sfn + llen, "/prefix", 8) ; if (stat(sfn, &st) < 0) { if (errno != ENOENT) return 0 ; *n = 0 ; return 1 ; } if (!S_ISREG(st.st_mode)) return (errno = EINVAL, 0) ; if (st.st_size > PATH_MAX) return (errno = ENAMETOOLONG, 0) ; *n = st.st_size ; return 1 ; } s6-rc-0.5.1.1/src/libs6rc/s6rc_lock.c0000644000000000000000000000251513147002156013662 0ustar /* ISC license. */ #include #include #include #include static inline int lockex (int fd, int blocking) { return blocking ? lock_ex(fd) : lock_exnb(fd) ; } static inline int locksh (int fd, int blocking) { return blocking ? lock_sh(fd) : lock_shnb(fd) ; } int s6rc_lock (char const *live, int lwhat, int *llfd, char const *compiled, int cwhat, int *ccfd, int blocking) { int lfd = -1, cfd = -1 ; if (lwhat) { size_t llen = strlen(live) ; char lfn[llen + 6] ; memcpy(lfn, live, llen) ; memcpy(lfn + llen, "/lock", 6) ; lfd = open_create(lfn) ; if (lfd < 0) return 0 ; if (coe(lfd) < 0) goto lerr ; if ((lwhat > 1 ? lockex(lfd, blocking) : locksh(lfd, blocking)) < 0) goto lerr ; } if (cwhat) { size_t clen = strlen(compiled) ; char cfn[clen + 6] ; memcpy(cfn, compiled, clen) ; memcpy(cfn + clen, "/lock", 6) ; cfd = open_create(cfn) ; if (cfd < 0) if (cwhat > 1 || errno != EROFS) goto lerr ; else cfd = -errno ; else { if (coe(cfd) < 0) goto cerr ; if ((cwhat > 1 ? lockex(cfd, blocking) : locksh(cfd, blocking)) < 0) goto cerr ; } } if (lwhat) *llfd = lfd ; if (cwhat) *ccfd = cfd ; return 1 ; cerr: fd_close(cfd) ; lerr: if (lwhat) fd_close(lfd) ; return 0 ; } s6-rc-0.5.1.1/src/libs6rc/s6rc_db_check_depcycles.c0000644000000000000000000000263113061734164016514 0ustar /* ISC license. */ #include #include #include #include typedef struct recinfo_s recinfo_t, *recinfo_t_ref ; struct recinfo_s { s6rc_db_t const *db ; uint32_t n ; unsigned char *gray ; unsigned char *black ; unsigned char h : 1 ; } ; static uint32_t s6rc_db_checknocycle_rec (recinfo_t *recinfo, uint32_t i) { if (!bitarray_peek(recinfo->black, i)) { uint32_t j = recinfo->db->services[i].ndeps[recinfo->h] ; if (bitarray_peek(recinfo->gray, i)) return i ; bitarray_set(recinfo->gray, i) ; while (j--) { uint32_t r = s6rc_db_checknocycle_rec(recinfo, recinfo->db->deps[recinfo->h * recinfo->db->ndeps + recinfo->db->services[i].deps[recinfo->h] + j]) ; if (r < recinfo->n) return r ; } bitarray_set(recinfo->black, i) ; } return recinfo->n ; } int s6rc_db_check_depcycles (s6rc_db_t const *db, int h, diuint32 *problem) { uint32_t n = db->nshort + db->nlong ; uint32_t i = n ; unsigned char gray[bitarray_div8(n)] ; unsigned char black[bitarray_div8(n)] ; recinfo_t info = { .db = db, .n = n, .gray = gray, .black = black, .h = !!h } ; memset(gray, 0, bitarray_div8(n)) ; memset(black, 0, bitarray_div8(n)) ; while (i--) { uint32_t r = s6rc_db_checknocycle_rec(&info, i) ; if (r < n) { problem->left = i ; problem->right = r ; return 1 ; } } return 0 ; } s6-rc-0.5.1.1/src/libs6rc/s6rc_db_check_pipelines.c0000644000000000000000000000307513207066205016530 0ustar /* ISC license. */ #include #include #include #include struct recinfo_s { s6rc_db_t const *db ; unsigned char *mark ; } ; static uint32_t check_prod_rec (struct recinfo_s *recinfo, uint32_t n) { uint32_t i = 0 ; if (recinfo->mark[n] & 3) return n ; recinfo->mark[n] |= 1 ; for (; i < recinfo->db->services[n].x.longrun.nproducers ; i++) { uint32_t j = recinfo->db->producers[recinfo->db->services[n].x.longrun.producers + i] ; if (j >= recinfo->db->nlong) return (recinfo->mark[n] |= 4, n) ; if (recinfo->db->services[j].x.longrun.consumer != n) return (recinfo->mark[j] |= 4, j) ; j = check_prod_rec(recinfo, j) ; if (j < recinfo->db->nlong) return j ; } recinfo->mark[n] |= 2 ; return recinfo->db->nlong ; } int s6rc_db_check_pipelines (s6rc_db_t const *db, diuint32 *problem) { uint32_t i = db->nlong ; unsigned char mark[db->nlong] ; struct recinfo_s recinfo = { .db = db, .mark = mark } ; memset(mark, 0, db->nlong) ; while (i--) { if (db->services[i].x.longrun.consumer >= db->nlong && db->services[i].x.longrun.nproducers) { uint32_t j = check_prod_rec(&recinfo, i) ; if (j < db->nlong) { problem->left = i ; problem->right = j ; return mark[j] & 4 ? 3 : mark[j] & 2 ? 2 : 1 ; } } } i = db->nlong ; while (i--) { if (!mark[i] && db->services[i].x.longrun.nproducers) { problem->left = db->services[i].x.longrun.consumer ; problem->right = i ; return 1 ; } } return 0 ; } s6-rc-0.5.1.1/src/libs6rc/s6rc_db_check_revdeps.c0000644000000000000000000000134313061734164016210 0ustar /* ISC license. */ #include #include #include int s6rc_db_check_revdeps (s6rc_db_t const *db) { size_t n = db->nshort + db->nlong ; size_t m = bitarray_div8(n) ; unsigned char matrix[n * m] ; unsigned int i = n ; unsigned char const *p = matrix ; memset(matrix, 0, n * m) ; while (i--) { unsigned int j = db->services[i].ndeps[1] ; while (j--) bitarray_not(matrix + m * i, db->deps[db->ndeps + db->services[i].deps[1] + j], 1) ; } i = n ; while (i--) { unsigned int j = db->services[i].ndeps[0] ; while (j--) bitarray_not(matrix + m * db->deps[db->services[i].deps[0] + j], i, 1) ; } n *= m ; while (n--) if (*p++) return 1 ; return 0 ; } s6-rc-0.5.1.1/src/libs6rc/s6rc_servicedir_unblock.c0000644000000000000000000000075113061734164016614 0ustar /* ISC license. */ #include #include #include #include #include int s6rc_servicedir_unblock (char const *dir, int h) { if (h) { size_t dirlen = strlen(dir) ; char fn[dirlen + 6] ; memcpy(fn, dir, dirlen) ; memcpy(fn + dirlen, "/down", 6) ; if (unlink(fn) < 0 && errno != ENOENT) return -1 ; if (s6_svc_writectl(dir, S6_SUPERVISE_CTLDIR, "u", 1) < 0) return -1 ; } return 0 ; } s6-rc-0.5.1.1/src/libs6rc/s6rc_servicedir_unsupervise.c0000644000000000000000000000154113324563553017551 0ustar /* ISC license. */ #include #include #include #include #include #include void s6rc_servicedir_unsupervise (char const *live, char const *prefix, char const *name, int keepsupervisor) { size_t livelen = strlen(live) ; size_t prefixlen = strlen(prefix) ; size_t namelen = strlen(name) ; char fn[livelen + 14 + prefixlen + namelen] ; memcpy(fn, live, livelen) ; memcpy(fn + livelen, "/scandir/", 9) ; memcpy(fn + livelen + 9, prefix, prefixlen) ; memcpy(fn + livelen + 9 + prefixlen, name, namelen + 1) ; unlink_void(fn) ; if (!keepsupervisor) { int e = errno ; memcpy(fn + livelen + 1, "servicedirs/", 12) ; memcpy(fn + livelen + 13, name, namelen + 1) ; s6_svc_writectl(fn, S6_SUPERVISE_CTLDIR, "x", 1) ; errno = e ; } } s6-rc-0.5.1.1/src/libs6rc/s6rc_servicedir_copy_online.c0000644000000000000000000000402113061734164017467 0ustar /* ISC license. */ #include #include #include #include #include #include #include #include "s6rc-servicedir-internal.h" #include int s6rc_servicedir_copy_online (char const *src, char const *dst) { size_t srclen = strlen(src) ; size_t dstlen = strlen(dst) ; unsigned int n ; unsigned int i = 0 ; int wantup = 0 ; int e ; char srcfn[srclen + s6rc_servicedir_file_maxlen + 6] ; char dstfn[dstlen + s6rc_servicedir_file_maxlen + 6] ; char oldfn[dstlen + s6rc_servicedir_file_maxlen + 6] ; memcpy(srcfn, src, srclen) ; srcfn[srclen] = '/' ; memcpy(dstfn, dst, dstlen + 1) ; memcpy(oldfn, dst, dstlen) ; memcpy(oldfn + dstlen, "/old", 5) ; if (rm_rf(oldfn) < 0 && errno != ENOENT) return 0 ; if (mkdir(oldfn, 0755) < 0) return 0 ; dstfn[dstlen] = '/' ; oldfn[dstlen + 4] = '/' ; wantup = s6rc_servicedir_block(dst) ; if (wantup < 0) { e = errno ; goto errdir ; } for (; s6rc_servicedir_file_list[i].name ; i++) { strcpy(dstfn + dstlen + 1, s6rc_servicedir_file_list[i].name) ; strcpy(oldfn + dstlen + 5, s6rc_servicedir_file_list[i].name) ; if (rename(dstfn, oldfn) < 0 && (errno != ENOENT || s6rc_servicedir_file_list[i].options & SVFILE_MANDATORY)) { e = errno ; goto errrename ; } } n = i ; while (i--) { if (!s6rc_servicedir_copy_one(src, dst, s6rc_servicedir_file_list + i)) { e = errno ; goto errremove ; } } oldfn[dstlen + 4] = 0 ; rm_rf(oldfn) ; s6rc_servicedir_unblock(dst, wantup) ; return 1 ; errremove: for (; i < n ; i++) { strcpy(dstfn + dstlen + 1, s6rc_servicedir_file_list[i].name) ; rm_rf(dstfn) ; } i = n ; errrename: while (i--) { strcpy(dstfn + dstlen + 1, s6rc_servicedir_file_list[i].name) ; strcpy(oldfn + dstlen + 5, s6rc_servicedir_file_list[i].name) ; rename(oldfn, dstfn) ; } errdir: oldfn[dstlen + 4] = 0 ; rmdir(oldfn) ; errno = e ; return 0 ; } s6-rc-0.5.1.1/src/libs6rc/deps-lib/0000755000000000000000000000000012645223546013337 5ustar s6-rc-0.5.1.1/src/libs6rc/deps-lib/s6rc0000644000000000000000000000074213210771115014127 0ustar s6rc_db_check_depcycles.o s6rc_db_check_pipelines.o s6rc_db_check_revdeps.o s6rc_db_read.o s6rc_db_read_sizes.o s6rc_db_read_uint32.o s6rc_graph_closure.o s6rc_livedir_create.o s6rc_livedir_prefix.o s6rc_livedir_prefixsize.o s6rc_lock.o s6rc_read_uint.o s6rc_sanitize_dir.o s6rc_servicedir_internal.o s6rc_servicedir_block.o s6rc_servicedir_unblock.o s6rc_servicedir_copy_offline.o s6rc_servicedir_copy_online.o s6rc_servicedir_manage.o s6rc_servicedir_unsupervise.o -ls6 -lskarnet s6-rc-0.5.1.1/src/include-local/0000755000000000000000000000000012412615566013006 5ustar s6-rc-0.5.1.1/src/s6-rc/0000755000000000000000000000000013541514470011221 5ustar s6-rc-0.5.1.1/src/s6-rc/s6-rc-format-upgrade.c0000644000000000000000000000373013534435363015242 0ustar /* ISC license. */ #include #include #include #include #include #include #include #include #define USAGE "s6-rc-format-upgrade [ -v verbosity ] [ -t timeout ] [ -l live ] [ -b ] newdb" #define dieusage() strerr_dieusage(100, USAGE) static unsigned int verbosity = 1 ; /* This function will change if format changes become heavier */ static inline void update_livedir (char const *live, char const *newcompiled, tain_t const *deadline) { size_t livelen = strlen(live) ; char cfn[livelen + 10] ; memcpy(cfn, live, livelen) ; memcpy(cfn + livelen, "/compiled", 10) ; if (!atomic_symlink(newcompiled, cfn, PROG)) strerr_diefu4sys(111, "atomic_symlink ", cfn, " to ", newcompiled) ; } int main (int argc, char const *const *argv, char const *const *envp) { tain_t deadline ; char const *live = S6RC_LIVE_BASE ; int blocking = 0 ; int livelock ; PROG = "s6-rc-format-upgrade" ; { unsigned int t = 0 ; subgetopt_t l = SUBGETOPT_ZERO ; for (;;) { int opt = subgetopt_r(argc, argv, "v:t:l:b", &l) ; if (opt == -1) break ; switch (opt) { case 'v' : if (!uint0_scan(l.arg, &verbosity)) dieusage() ; break ; case 't' : if (!uint0_scan(l.arg, &t)) dieusage() ; break ; case 'l' : live = l.arg ; break ; case 'b' : blocking = 1 ; break ; default : dieusage() ; } } argc -= l.ind ; argv += l.ind ; if (t) tain_from_millisecs(&deadline, t) ; else deadline = tain_infinite_relative ; } if (!argc) dieusage() ; if (argv[0][0] != '/') strerr_dief2x(100, argv[0], " is not an absolute path") ; tain_now_set_stopwatch_g() ; tain_add_g(&deadline, &deadline) ; if (!s6rc_lock(live, 2, &livelock, 0, 0, 0, blocking)) strerr_diefu2sys(111, "take lock on ", live) ; update_livedir(live, argv[0], &deadline) ; return 0 ; } s6-rc-0.5.1.1/src/s6-rc/s6-rc-update.c0000644000000000000000000007000513534435404013602 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 #define USAGE "s6-rc-update [ -n ] [ -v verbosity ] [ -t timeout ] [ -l live ] [ -f conversion_file ] [ -b ] newdb" #define dieusage() strerr_dieusage(100, USAGE) #define dienomem() strerr_diefu1sys(111, "build string") ; static char const *live = S6RC_LIVE_BASE ; static size_t livelen = sizeof(S6RC_LIVE_BASE) - 1 ; static unsigned int verbosity = 1 ; /* Conversions and transitions */ /* oldstate flags: 1 -> is up 2 -> wanted down 4 -> restart 8 -> converts to atomic or singleton 16 -> has a new name 32 -> wanted down after closure 64 -> appears in convfile newstate flags: 1 -> is up (converted from old up) 2 -> wanted up 4 -> is a bijective conversion target 8 -> is a conversion target 16 -> changed names 32 -> is up after closure (i.e. includes new deps) 128 -> depends on a new service, has to be restarted */ static inline void parse_line (stralloc *sa, char const *s, size_t slen, unsigned int *newnames, unsigned char *oldstate, cdb_t *oldc, s6rc_db_t const *olddb) { size_t base = sa->len ; unsigned int oldn = olddb->nshort + olddb->nlong ; int n ; if (!stralloc_readyplus(sa, slen)) dienomem() ; sa->len += slen ; n = el_parse_from_string(sa, s) ; switch (n) { case -1 : dienomem() ; case -2 : strerr_dief2x(100, "syntax error in conversion file: ", s) ; case -3 : strerr_dief2x(100, "mismatched braces in conversion file: ", s) ; default : break ; } sa->len = base ; if (n--) { char pack[4] ; uint32_t x ; unsigned int cur ; int r = cdb_find(oldc, sa->s + base + slen, strlen(sa->s + base + slen)) ; if (r < 0) strerr_diefu3sys(111, "read ", live, "/compiled/resolve.cdb") ; if (!r) strerr_dief5x(3, "unknown identifier in ", live, "/compiled/resolve.cdb", ": ", sa->s + base + slen) ; if (cdb_datalen(oldc) != 4) strerr_dief5x(5, "identifier ", sa->s + base + slen, " does not represent an atomic service in ", live, "/compiled") ; if (cdb_read(oldc, pack, 4, cdb_datapos(oldc)) < 0) strerr_diefu3sys(111, "read ", live, "/compiled/resolve.cdb") ; uint32_unpack_big(pack, &x) ; if (x >= oldn) strerr_dief3x(4, "invalid database in ", live, "/compiled") ; if (oldstate[x] & 64) strerr_dief3x(6, "service ", olddb->string + olddb->services[x].name, " appears more than once in conversion file") ; oldstate[x] |= 64 ; cur = base + slen + strlen(sa->s + base + slen) + 1 ; if (n >= 2 && !strcmp(sa->s + cur, "->")) { size_t newnamelen = strlen(sa->s + cur + 3) ; memcpy(sa->s + sa->len, sa->s + cur + 3, newnamelen + 1) ; newnames[x] = sa->len ; oldstate[x] |= 16 ; sa->len += newnamelen + 1 ; cur += newnamelen + 4 ; n -= 2 ; } while (n--) { if (!strcmp(sa->s + cur, "restart")) oldstate[x] |= 4 ; else strerr_dief2x(100, "unknown keyword in conversion file: ", sa->s + cur) ; cur += strlen(sa->s + cur) + 1 ; } } } static inline void parse_conversion_file (char const *convfile, stralloc *sa, unsigned int *newnames, unsigned char *oldstate, cdb_t *oldc, s6rc_db_t const *olddb) { int fd = openb_read(convfile) ; char buf[4096] ; buffer b = BUFFER_INIT(&buffer_read, fd, buf, 4096) ; size_t base = satmp.len ; if (fd < 0) strerr_diefu2sys(111, "open ", convfile) ; for (;;) { int r = skagetln(&b, &satmp, '\n') ; if (!r) break ; if (r < 0) { if (errno != EPIPE) strerr_diefu1sys(111, "read from stdin") ; if (!stralloc_0(&satmp)) dienomem() ; } else satmp.s[satmp.len - 1] = 0 ; parse_line(sa, satmp.s + base, satmp.len - base, newnames, oldstate, oldc, olddb) ; satmp.len = base ; } satmp.len = base ; close(fd) ; } static inline void stuff_with_oldc (unsigned char *oldstate, int fdoldc, s6rc_db_t const *olddb, char const *convfile, unsigned int *oldindex, stralloc *namedata) { cdb_t oldc = CDB_ZERO ; int oldfdres = open_readatb(fdoldc, "resolve.cdb") ; if (oldfdres < 0) strerr_diefu3sys(111, "open ", live, "/compiled/resolve.cdb") ; if (!cdb_init_map(&oldc, oldfdres, 1)) strerr_diefu3sys(111, "cdb_init ", live, "/compiled/resolve.cdb") ; parse_conversion_file(convfile, namedata, oldindex, oldstate, &oldc, olddb) ; cdb_free(&oldc) ; close(oldfdres) ; } static inline void fill_convtable_and_flags (unsigned char *conversion_table, unsigned char *oldstate, unsigned char *newstate, char const *namedata, unsigned int const *oldindex, unsigned int *invimage, cdb_t *newc, char const *newfn, s6rc_db_t const *olddb, s6rc_db_t const *newdb) { unsigned int newn = newdb->nshort + newdb->nlong ; unsigned int i = olddb->nshort + olddb->nlong ; while (i--) { char const *newname = oldstate[i] & 16 ? namedata + oldindex[i] : olddb->string + olddb->services[i].name ; uint32_t len ; int r = cdb_find(newc, newname, strlen(newname)) ; if (r < 0) strerr_diefu3sys(111, "read ", newfn, "/resolve.cdb") ; if (!r) { if (oldstate[i] & 16) strerr_dief4x(4, "bad conversion file: new service ", newname, " is undefined in database ", newfn) ; oldstate[i] |= 34 ; /* disappeared */ continue ; } if (cdb_datalen(newc) & 3) strerr_dief3x(4, "invalid resolve database in ", newfn, "/resolve.cdb") ; len = cdb_datalen(newc) >> 2 ; if (len > newn) strerr_dief3x(4, "invalid resolve database in ", newfn, "/resolve.cdb") ; { char pack[cdb_datalen(newc) + 1] ; char const *p = pack ; if (cdb_read(newc, pack, cdb_datalen(newc), cdb_datapos(newc)) < 0) strerr_diefu3sys(111, "read ", newfn, "/resolve.cdb") ; if (len == 1) oldstate[i] |= 8 ; while (len--) { uint32_t x ; uint32_unpack_big(p, &x) ; p += 4 ; if (x >= newn) strerr_dief3x(4, "invalid resolve database in ", newfn, "/resolve.cdb") ; if (newstate[x] & 8) strerr_diefu4x(6, "convert database: new service ", newdb->string + newdb->services[x].name, " is a target for more than one conversion, including old service ", olddb->string + olddb->services[i].name) ; newstate[x] |= 8 ; invimage[x] = i ; if (oldstate[i] & 16) newstate[x] |= 16 ; bitarray_set(conversion_table + i * bitarray_div8(newn), x) ; if (oldstate[i] & 8) { newstate[x] |= 4 ; if ((i < olddb->nlong) != (x < newdb->nlong)) oldstate[i] |= 4 ; } } } } } static inline void stuff_with_newc (int fdnewc, char const *newfn, unsigned char *conversion_table, unsigned char *oldstate, unsigned char *newstate, char const *namedata, unsigned int const *oldindex, unsigned int *invimage, s6rc_db_t const *olddb, s6rc_db_t const *newdb) { cdb_t newc = CDB_ZERO ; int newfdres = open_readatb(fdnewc, "resolve.cdb") ; if (newfdres < 0) strerr_diefu3sys(111, "open ", newfn, "/compiled/resolve.cdb") ; if (!cdb_init_map(&newc, newfdres, 1)) strerr_diefu3sys(111, "cdb_init ", newfn, "/compiled/resolve.cdb") ; fill_convtable_and_flags(conversion_table, oldstate, newstate, namedata, oldindex, invimage, &newc, newfn, olddb, newdb) ; cdb_free(&newc) ; close(newfdres) ; } static void compute_transitions (char const *convfile, unsigned char *oldstate, int fdoldc, s6rc_db_t const *olddb, unsigned char *newstate, unsigned int *invimage, int fdnewc, char const *newfn, s6rc_db_t const *newdb, stralloc *sa) { unsigned int oldn = olddb->nshort + olddb->nlong ; unsigned int newn = newdb->nshort + newdb->nlong ; unsigned int newm = bitarray_div8(newn) ; unsigned int oldindex[oldn] ; unsigned char conversion_table[oldn * newm] ; memset(conversion_table, 0, oldn * newm) ; stuff_with_oldc(oldstate, fdoldc, olddb, convfile, oldindex, sa) ; stuff_with_newc(fdnewc, newfn, conversion_table, oldstate, newstate, sa->s, oldindex, invimage, olddb, newdb) ; sa->len = 0 ; for (;;) { int done = 1 ; unsigned int i = newn ; while (i--) newstate[i] &= 28 ; /* If an old service needs to restart, mark it wanted down, as well as everything that depends on it. */ i = oldn ; while (i--) { if (oldstate[i] & 1 && (oldstate[i] & 4 || !(oldstate[i] & 8))) oldstate[i] |= 34 ; else oldstate[i] &= 221 ; } s6rc_graph_closure(olddb, oldstate, 5, 0) ; /* Convert the old state to the new state: if an old service is up, the new service will be either up or wanted up. This part runs in O(oldn*newn). There are no syscalls in the loop, so it should still be negligible unless you have 10k services. */ i = oldn ; while (i--) if (oldstate[i] & 1) { unsigned int j = newn ; while (j--) if (bitarray_peek(conversion_table + i * newm, j)) newstate[j] |= (oldstate[i] & 32) ? 2 : 33 ; } /* Check for new dependencies. If a new service is still up but depends on a new service that is not, it has to be restarted. Mark the old service for restart and loop until there are no new dependencies. */ s6rc_graph_closure(newdb, newstate, 5, 1) ; i = newn ; while (i--) if ((newstate[i] & 33) == 32) { done = 0 ; newstate[i] |= 128U ; } if (done) break ; s6rc_graph_closure(newdb, newstate, 7, 0) ; i = newn ; while (i--) if ((newstate[i] & 129U) == 129U) oldstate[invimage[i]] |= 4 ; } } /* Update the live directory while keeping active servicedirs */ static inline void rollback_servicedirs (char const *newlive, unsigned char const *newstate, unsigned int const *invimage, s6rc_db_t const *olddb, s6rc_db_t const *newdb, unsigned int n) { size_t newllen = strlen(newlive) ; unsigned int i = n ; while (i--) { size_t newnamelen = strlen(newdb->string + newdb->services[i].name) ; char newfn[newllen + 14 + newnamelen] ; memcpy(newfn, newlive, newllen) ; memcpy(newfn + newllen, "/servicedirs/", 13) ; memcpy(newfn + newllen + 13, newdb->string + newdb->services[i].name, newnamelen + 1) ; if (newstate[i] & 1) { char const *oldname = newstate[i] & 8 ? olddb->string + olddb->services[invimage[i]].name : newdb->string + newdb->services[i].name ; size_t oldnamelen = strlen(oldname) ; char oldfn[livelen + 23 + oldnamelen] ; memcpy(oldfn, live, livelen) ; memcpy(oldfn + livelen, "/compiled/servicedirs/", 22) ; memcpy(oldfn + livelen + 22, oldname, oldnamelen + 1) ; if (!s6rc_servicedir_copy_online(oldfn, newfn)) strerr_diefu4sys(111, "rollback ", oldfn, " into ", newfn) ; memcpy(oldfn + livelen, "/servicedirs/", 13) ; memcpy(oldfn + livelen + 13, oldname, oldnamelen + 1) ; if (rename(newfn, oldfn) < 0) strerr_diefu4sys(111, "rollback: can't rename ", newfn, " to ", oldfn) ; } } } static inline void make_new_livedir (unsigned char const *oldstate, s6rc_db_t const *olddb, unsigned char const *newstate, s6rc_db_t const *newdb, char const *newcompiled, unsigned int *invimage, char const *prefix, stralloc *sa) { size_t dirlen, pos, newlen, sdlen ; size_t newclen = strlen(newcompiled) ; unsigned int i = newdb->nlong + newdb->nshort ; if (sarealpath(sa, live) < 0 || !stralloc_0(sa)) strerr_diefu2sys(111, "sarealpath ", live) ; pos = sa->len ; { ssize_t r ; char sdtarget[PATH_MAX] ; char sdlink[livelen + 9] ; unsigned char tmpstate[newdb->nlong + newdb->nshort] ; memcpy(sdlink, live, livelen) ; memcpy(sdlink + livelen, "/scandir", 9) ; r = readlink(sdlink, sdtarget, PATH_MAX) ; if (r < 0) strerr_diefu2sys(111, "readlink ", sdlink) ; if (r >= PATH_MAX - 1) strerr_dief3x(100, "target for ", sdlink, " is too long") ; sdtarget[r] = 0 ; while (i--) tmpstate[i] = newstate[i] & 1 ; if (!s6rc_livedir_create(sa, live, PROG, sdtarget, prefix, newcompiled, tmpstate, newdb->nlong + newdb->nshort, &dirlen)) strerr_diefu1sys(111, "create new livedir") ; } newlen = sa->len ; i = 0 ; if (!stralloc_catb(sa, "/servicedirs/", 13)) goto rollback ; sdlen = sa->len ; for (; i < newdb->nlong ; i++) { size_t newnamelen = strlen(newdb->string + newdb->services[i].name) ; char newfn[newclen + 14 + newnamelen] ; memcpy(newfn, newcompiled, newclen) ; memcpy(newfn + newclen, "/servicedirs/", 13) ; memcpy(newfn + newclen + 13, newdb->string + newdb->services[i].name, newnamelen + 1) ; sa->len = sdlen ; if (!stralloc_cats(sa, newdb->string + newdb->services[i].name) || !stralloc_0(sa)) goto rollback ; if (newstate[i] & 1) { char const *oldname = newstate[i] & 8 ? olddb->string + olddb->services[invimage[i]].name : newdb->string + newdb->services[i].name ; size_t oldnamelen = strlen(oldname) ; char oldfn[livelen + 14 + oldnamelen] ; memcpy(oldfn, live, livelen) ; memcpy(oldfn + livelen, "/servicedirs/", 13) ; memcpy(oldfn + livelen + 13, oldname, oldnamelen + 1) ; if (rename(oldfn, sa->s + pos) < 0) goto rollback ; if (!s6rc_servicedir_copy_online(newfn, sa->s + pos)) { i++ ; goto rollback ; } } else if (!s6rc_servicedir_copy_offline(newfn, sa->s + pos)) goto rollback ; } sa->len = newlen ; sa->s[sa->len] = 0 ; /* The point of no return is here */ if (!atomic_symlink(sa->s + dirlen, live, "s6-rc-update_atomic_symlink")) goto rollback ; if (verbosity >= 2) strerr_warni1x("successfully switched to new database") ; /* scandir cleanup, then old livedir cleanup */ i = olddb->nlong ; while (i--) s6rc_servicedir_unsupervise(sa->s, prefix, olddb->string + olddb->services[i].name, (oldstate[i] & 33) == 1) ; rm_rf_in_tmp(sa, 0) ; sa->len = 0 ; return ; rollback: { int e = errno ; sa->len = newlen ; sa->s[sa->len++] = 0 ; rollback_servicedirs(sa->s + pos, newstate, invimage, olddb, newdb, i) ; rm_rf_in_tmp(sa, 0) ; errno = e ; } strerr_diefu2sys(111, "make new live directory in ", sa->s) ; } /* Updating the pipes contained in the fdholder */ static inline int delete_unused_pipes (s6_fdholder_t *a, s6rc_db_t const *olddb, unsigned char const *oldstate, tain_t const *deadline) { unsigned int i = olddb->nlong ; while (i--) if (!(oldstate[i] & 8) && olddb->services[i].x.longrun.nproducers) { size_t len = strlen(olddb->string + olddb->services[i].name) ; char pipename[len + 13] ; memcpy(pipename, "pipe:s6rc-w-", 12) ; memcpy(pipename + 12, olddb->string + olddb->services[i].name, len + 1) ; if (!s6_fdholder_delete_g(a, pipename, deadline)) return 0 ; pipename[10] = 'r' ; if (!s6_fdholder_delete_g(a, pipename, deadline)) return 0 ; } return 1 ; } static inline int rename_pipes (s6_fdholder_t *a, s6rc_db_t const *olddb, s6rc_db_t const *newdb, unsigned char const *newstate, unsigned int const *invimage, tain_t const *deadline) { tain_t nano1 = { .sec = TAI_ZERO, .nano = 1 } ; tain_t limit ; tain_add_g(&limit, &tain_infinite_relative) ; unsigned int i = newdb->nlong ; while (i--) { if ((newstate[i] & 20) == 20 && newdb->services[i].x.longrun.nproducers) { int fd ; size_t oldlen = strlen(olddb->string + olddb->services[invimage[i]].name) ; size_t newlen = strlen(newdb->string + newdb->services[i].name) ; char oldpipename[oldlen + 13] ; char newpipename[newlen + 13] ; memcpy(oldpipename, "pipe:s6rc-r-", 12) ; memcpy(oldpipename + 12, olddb->string + olddb->services[invimage[i]].name, oldlen + 1) ; memcpy(newpipename, "pipe:s6rc-r-", 12) ; memcpy(newpipename + 12, newdb->string + newdb->services[i].name, newlen + 1) ; fd = s6_fdholder_retrieve_delete_g(a, oldpipename, deadline) ; if (fd < 0) return 0 ; if (!s6_fdholder_store_g(a, fd, newpipename, &limit, deadline)) { close(fd) ; return 0 ; } close(fd) ; tain_add(&limit, &limit, &nano1) ; oldpipename[10] = 'w' ; newpipename[10] = 'w' ; fd = s6_fdholder_retrieve_delete_g(a, oldpipename, deadline) ; if (fd < 0) return 0 ; if (!s6_fdholder_store_g(a, fd, newpipename, &limit, deadline)) { close(fd) ; return 0 ; } close(fd) ; tain_add(&limit, &limit, &nano1) ; } } return 1 ; } static inline int create_new_pipes (s6_fdholder_t *a, s6rc_db_t const *newdb, unsigned char const *newstate, tain_t const *deadline) { tain_t nano1 = { .sec = TAI_ZERO, .nano = newdb->nlong % 1000000000U } ; tain_t limit ; unsigned int i = newdb->nlong ; tain_add_g(&limit, &tain_infinite_relative) ; tain_add(&limit, &limit, &nano1) ; nano1.nano = 1 ; while (i--) { if (!(newstate[i] & 4) && newdb->services[i].x.longrun.nproducers) { int p[2] ; size_t len = strlen(newdb->string + newdb->services[i].name) ; char pipename[len + 13] ; memcpy(pipename, "pipe:s6rc-r-", 12) ; memcpy(pipename + 12, newdb->string + newdb->services[i].name, len + 1) ; if (pipe(p) < 0) return 0 ; if (!s6_fdholder_store_g(a, p[0], pipename, &limit, deadline)) { close(p[0]) ; close(p[1]) ; return 0 ; } close(p[0]) ; tain_add(&limit, &limit, &nano1) ; pipename[10] = 'w' ; if (!s6_fdholder_store_g(a, p[1], pipename, &limit, deadline)) { close(p[1]) ; return 0 ; } close(p[1]) ; tain_add(&limit, &limit, &nano1) ; } } return 1 ; } static void fill_tfmt (char *tfmt, tain_t const *deadline) { int t ; tain_t tto ; tain_sub(&tto, deadline, &STAMP) ; t = tain_to_millisecs(&tto) ; if (!t) t = 1 ; else if (t < 0) t = 0 ; tfmt[uint_fmt(tfmt, t)] = 0 ; } static inline void update_fdholder (s6rc_db_t const *olddb, unsigned char const *oldstate, s6rc_db_t const *newdb, unsigned char const *newstate, unsigned int const *invimage, char const *const *envp, tain_t const *deadline) { s6_fdholder_t a = S6_FDHOLDER_ZERO ; char fnsocket[livelen + sizeof("/servicedirs/" S6RC_FDHOLDER "/s")] ; if (!(newstate[1] & 1)) return ; memcpy(fnsocket, live, livelen) ; memcpy(fnsocket + livelen, "/servicedirs/" S6RC_FDHOLDER "/s", sizeof("/servicedirs/" S6RC_FDHOLDER "/s")) ; if (!s6_fdholder_start_g(&a, fnsocket, deadline)) goto hammer ; if (!delete_unused_pipes(&a, olddb, oldstate, deadline)) goto freehammer ; if (!rename_pipes(&a, olddb, newdb, newstate, invimage, deadline)) goto freehammer ; if (!create_new_pipes(&a, newdb, newstate, deadline)) goto freehammer ; s6_fdholder_end(&a) ; return ; freehammer: s6_fdholder_end(&a) ; hammer: if (verbosity) strerr_warnwu1x("live update s6rc-fdholder - restarting it") ; { pid_t pid ; int wstat ; char tfmt[UINT_FMT] ; char const *newargv[7] = { S6_EXTBINPREFIX "s6-svc", "-T", tfmt, "-twR", "--", fnsocket, 0 } ; fill_tfmt(tfmt, deadline) ; fnsocket[livelen + sizeof("/servicedirs/" S6RC_FDHOLDER) - 1] = 0 ; pid = child_spawn0(newargv[0], newargv, envp) ; if (!pid) strerr_diefu2sys(111, "spawn ", newargv[0]) ; if (wait_pid(pid, &wstat) < 0) strerr_diefu1sys(111, "waitpid") ; tain_now_g() ; if (WIFSIGNALED(wstat) || WEXITSTATUS(wstat)) if (verbosity) strerr_warnwu1x("restart s6rc-fdholder") ; if (!tain_future(deadline)) strerr_dief1x(2, "timed out during s6rc-fdholder update") ; } } /* Main */ static unsigned int want_count (unsigned char const *state, unsigned int n) { unsigned int count = 0, i = n ; while (i--) if (state[i] & 2) count++ ; return count ; } int main (int argc, char const *const *argv, char const *const *envp) { char const *convfile = "/dev/null" ; tain_t deadline ; int dryrun = 0 ; int blocking = 0 ; PROG = "s6-rc-update" ; { unsigned int t = 0 ; subgetopt_t l = SUBGETOPT_ZERO ; for (;;) { int opt = subgetopt_r(argc, argv, "v:t:nl:f:b", &l) ; if (opt == -1) break ; switch (opt) { case 'v' : if (!uint0_scan(l.arg, &verbosity)) dieusage() ; break ; case 't' : if (!uint0_scan(l.arg, &t)) dieusage() ; break ; case 'n' : dryrun = 1 ; break ; case 'l' : live = l.arg ; break ; case 'f' : convfile = l.arg ; break ; case 'b' : blocking = 1 ; break ; default : dieusage() ; } } argc -= l.ind ; argv += l.ind ; if (t) tain_from_millisecs(&deadline, t) ; else deadline = tain_infinite_relative ; } if (!argc) dieusage() ; if (live[0] != '/') strerr_dief2x(100, live, " is not an absolute path") ; if (argv[0][0] != '/') strerr_dief2x(100, argv[0], " is not an absolute path") ; livelen = strlen(live) ; { int livelock, oldlock, newlock ; int fdoldc, fdnewc ; s6rc_db_t olddb, newdb ; unsigned int oldn, newn ; size_t prefixlen = 0 ; char dbfn[livelen + 10] ; tain_now_set_stopwatch_g() ; tain_add_g(&deadline, &deadline) ; /* Take the live, old and new locks */ memcpy(dbfn, live, livelen) ; memcpy(dbfn + livelen, "/compiled", 10) ; if (!s6rc_lock(live, 2, &livelock, dbfn, 1, &oldlock, blocking)) strerr_diefu4sys(111, "take lock on ", live, " and ", dbfn) ; if (!s6rc_lock(0, 0, 0, argv[0], 1, &newlock, blocking)) strerr_diefu2sys(111, "take lock on ", argv[0]) ; /* Read the sizes of the prefix and compiled dbs */ if (!s6rc_livedir_prefixsize(live, &prefixlen)) strerr_diefu2sys(111, "read prefix size for ", live) ; fdoldc = open_readb(dbfn) ; if (!s6rc_db_read_sizes(fdoldc, &olddb)) strerr_diefu3sys(111, "read ", dbfn, "/n") ; oldn = olddb.nshort + olddb.nlong ; fdnewc = open_readb(argv[0]) ; if (!s6rc_db_read_sizes(fdnewc, &newdb)) strerr_diefu3sys(111, "read ", argv[0], "/n") ; newn = newdb.nshort + newdb.nlong ; /* Allocate enough stack for the dbs */ { pid_t pid ; stralloc sa = STRALLOC_ZERO ; s6rc_service_t oldserviceblob[oldn] ; char const *oldargvblob[olddb.nargvs] ; uint32_t olddepsblob[olddb.ndeps << 1] ; uint32_t oldproducersblob[olddb.nproducers] ; s6rc_service_t newserviceblob[newn] ; char const *newargvblob[newdb.nargvs] ; uint32_t newdepsblob[newdb.ndeps << 1] ; uint32_t newproducersblob[newdb.nproducers] ; unsigned int invimage[newn] ; char oldstringblob[olddb.stringlen] ; char newstringblob[newdb.stringlen] ; unsigned char oldstate[oldn] ; unsigned char newstate[newn] ; char prefix[prefixlen + 1] ; int r ; olddb.services = oldserviceblob ; olddb.argvs = oldargvblob ; olddb.deps = olddepsblob ; olddb.producers = oldproducersblob ; olddb.string = oldstringblob ; newdb.services = newserviceblob ; newdb.argvs = newargvblob ; newdb.deps = newdepsblob ; newdb.producers = newproducersblob ; newdb.string = newstringblob ; /* Read the prefix */ { ssize_t rr = s6rc_livedir_prefix(live, prefix, prefixlen) ; if (rr != prefixlen) strerr_diefu2sys(111, "read prefix for ", live) ; prefix[prefixlen] = 0 ; } /* Read the dbs */ r = s6rc_db_read(fdoldc, &olddb) ; if (r < 0) strerr_diefu3sys(111, "read ", dbfn, "/db") ; if (!r) strerr_dief3x(4, "invalid service database in ", dbfn, "/db") ; r = s6rc_db_read(fdnewc, &newdb) ; if (r < 0) strerr_diefu3sys(111, "read ", argv[0], "/db") ; if (!r) strerr_dief3x(4, "invalid service database in ", argv[0], "/db") ; /* Initial state */ memcpy(dbfn + livelen + 1, "state", 6) ; { ssize_t rr = openreadnclose(dbfn, (char *)oldstate, oldn) ; if (rr != oldn) strerr_diefu2sys(111, "read ", dbfn) ; } r = oldn ; while (r--) oldstate[r] &= 1 ; memset(newstate, 0, newn) ; r = newn ; while (r--) invimage[r] = olddb.nlong + olddb.nshort ; /* Read the conversion file and compute what to do */ if (verbosity >= 2) strerr_warni1x("computing state adjustments") ; compute_transitions(convfile, oldstate, fdoldc, &olddb, newstate, invimage, fdnewc, argv[0], &newdb, &sa) ; tain_now_g() ; if (!tain_future(&deadline)) strerr_dief1x(10, "timed out while computing state adjutments") ; /* Down transition */ { char const *newargv[12 + (dryrun * 4) + want_count(oldstate, oldn)] ; unsigned int m = 0, i = oldn ; int wstat ; char vfmt[UINT_FMT] ; char tfmt[UINT_FMT] ; vfmt[uint_fmt(vfmt, verbosity)] = 0 ; fill_tfmt(tfmt, &deadline) ; if (dryrun) { newargv[m++] = S6RC_BINPREFIX "s6-rc-dryrun" ; newargv[m++] = "-v" ; newargv[m++] = vfmt ; newargv[m++] = "-t0" ; newargv[m++] = "--" ; } newargv[m++] = S6RC_BINPREFIX "s6-rc" ; newargv[m++] = "-v" ; newargv[m++] = vfmt ; newargv[m++] = "-t" ; newargv[m++] = tfmt ; newargv[m++] = "-l" ; newargv[m++] = live ; if (!dryrun) newargv[m++] = "-X" ; newargv[m++] = "-d" ; newargv[m++] = "--" ; newargv[m++] = "change" ; while (i--) if (oldstate[i] & 2) newargv[m++] = olddb.string + olddb.services[i].name ; newargv[m++] = 0 ; if (verbosity >= 2) strerr_warni1x("stopping services in the old database") ; pid = child_spawn0(newargv[0], newargv, envp) ; if (!pid) strerr_diefu2sys(111, "spawn ", newargv[0]) ; if (wait_pid(pid, &wstat) < 0) strerr_diefu1sys(111, "waitpid") ; tain_now_g() ; if (WIFSIGNALED(wstat) || WEXITSTATUS(wstat)) { wstat = wait_estatus(wstat) ; if (wstat == 1 || wstat == 2) wstat += 8 ; strerr_dief1x(wstat, "first s6-rc invocation failed") ; } } if (!dryrun) { /* Update state and service directories */ if (verbosity >= 2) strerr_warni1x("updating state and service directories") ; make_new_livedir(oldstate, &olddb, newstate, &newdb, argv[0], invimage, prefix, &sa) ; stralloc_free(&sa) ; r = s6rc_servicedir_manage_g(live, prefix, &deadline) ; if (!r) strerr_diefu2sys(111, "manage new service directories in ", live) ; if (r & 2) strerr_warnw3x("s6-svscan not running on ", live, "/scandir") ; /* Adjust stored pipes */ if (verbosity >= 2) strerr_warni1x("updating s6rc-fdholder pipe storage") ; update_fdholder(&olddb, oldstate, &newdb, newstate, invimage, envp, &deadline) ; } /* Up transition */ { char const *newargv[12 + (dryrun * 4) + want_count(newstate, newn)] ; unsigned int m = 0, i = newn ; char vfmt[UINT_FMT] ; char tfmt[UINT_FMT] ; vfmt[uint_fmt(vfmt, verbosity)] = 0 ; fill_tfmt(tfmt, &deadline) ; if (dryrun) { newargv[m++] = S6RC_BINPREFIX "s6-rc-dryrun" ; newargv[m++] = "-v" ; newargv[m++] = vfmt ; newargv[m++] = "-t0" ; newargv[m++] = "--" ; } newargv[m++] = S6RC_BINPREFIX "s6-rc" ; newargv[m++] = "-v" ; newargv[m++] = vfmt ; newargv[m++] = "-t" ; newargv[m++] = tfmt ; newargv[m++] = "-l" ; newargv[m++] = live ; if (!dryrun) newargv[m++] = "-X" ; newargv[m++] = "-u" ; newargv[m++] = "--" ; newargv[m++] = "change" ; while (i--) if (newstate[i] & 2) newargv[m++] = newdb.string + newdb.services[i].name ; newargv[m++] = 0 ; if (verbosity >= 2) strerr_warni1x("starting services in the new database") ; xpathexec_run(newargv[0], newargv, envp) ; } } } } s6-rc-0.5.1.1/src/s6-rc/s6-rc-compile.c0000644000000000000000000014531013430016360013741 0ustar /* ISC license. */ #include #include #include #include #include #include #include /* qsort */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #define USAGE "s6-rc-compile [ -v verbosity ] [ -h fdholder_user ] [ -b ] destdir sources..." #define dieusage() strerr_dieusage(100, USAGE) #define dienomem() strerr_dief1x(111, "out of memory") ; #define S6RC_INTERNALS "s6-rc-compile internals" static unsigned int verbosity = 1 ; static stralloc keep = STRALLOC_ZERO ; static stralloc data = STRALLOC_ZERO ; typedef enum servicetype_e servicetype_t, *servicetype_t_ref ; enum servicetype_e { SVTYPE_UNDEFINED = 0, SVTYPE_ONESHOT = 1, SVTYPE_LONGRUN = 2, SVTYPE_BUNDLE = 4 } ; /* The names tree */ typedef struct nameinfo_s nameinfo_t, *nameinfo_t_ref ; struct nameinfo_s { unsigned int pos ; unsigned int kpos ; unsigned int i ; servicetype_t type ; } ; static void *names_dtok (unsigned int d, void *x) { return (void *)(data.s + genalloc_s(nameinfo_t, (genalloc *)x)[d].pos) ; } static int names_cmp (void const *a, void const *b, void *x) { (void)x ; return strcmp((char const *)a, (char const *)b) ; } static genalloc nameinfo = GENALLOC_ZERO ; /* nameinfo_t */ static avltree names_map = AVLTREE_INIT(8, 3, 8, &names_dtok, &names_cmp, &nameinfo) ; /* Services before resolution */ typedef struct common_s common_t, *common_t_ref ; struct common_s { unsigned int kname ; /* pos in keep */ unsigned int ndeps ; unsigned int depindex ; /* pos in indices */ uint32_t annotation_flags ; uint32_t timeout[2] ; } ; typedef struct oneshot_s oneshot_t, *oneshot_t_ref ; struct oneshot_s { common_t common ; unsigned int argvindex[2] ; /* pos in keep */ unsigned int argc[2] ; } ; typedef struct longrun_s longrun_t, *longrun_t_ref ; struct longrun_s { common_t common ; char const *srcdir ; unsigned int nproducers ; unsigned int prodindex ; /* pos in indices */ unsigned int consumer ; /* pos in data */ unsigned int pipelinename ; /* pos in data */ } ; typedef struct bundle_s bundle_t, *bundle_t_ref ; struct bundle_s { unsigned int name ; /* pos in data */ unsigned int n ; unsigned int listindex ; /* pos in indices */ } ; typedef struct before_s before_t, *before_t_ref ; struct before_s { genalloc indices ; /* unsigned int */ genalloc oneshots ; /* oneshot_t */ genalloc longruns ; /* longrun_t */ genalloc bundles ; /* bundle_t */ unsigned int nargvs ; uint32_t specialdeps[2] ; uint32_t nproducers ; } ; #define BEFORE_ZERO { .indices = GENALLOC_ZERO, .oneshots = GENALLOC_ZERO, .longruns = GENALLOC_ZERO, .bundles = GENALLOC_ZERO, .nargvs = 0, .specialdeps = { 0, 0 }, .nproducers = 0 } ; /* Read all the sources, populate the name map */ static char const *typestr (servicetype_t type) { return (type == SVTYPE_ONESHOT) ? "oneshot" : (type == SVTYPE_LONGRUN) ? "longrun" : (type == SVTYPE_BUNDLE) ? "bundle" : "unknown" ; } static int add_name_nocheck (before_t *be, char const *srcdir, char const *name, servicetype_t type, unsigned int *pos, unsigned int *kpos) { uint32_t id ; if (verbosity >= 4) strerr_warnt6x("from ", srcdir, ": adding identifier ", name, " of type ", typestr(type)) ; if (avltree_search(&names_map, name, &id)) { nameinfo_t *info = genalloc_s(nameinfo_t, &nameinfo) + id ; if (type == SVTYPE_UNDEFINED) { if (verbosity >= 4) strerr_warnt4x("identifier ", name, " was already declared with type ", typestr(info->type)) ; switch (info->type) { case SVTYPE_ONESHOT : case SVTYPE_LONGRUN : *kpos = info->kpos ; default : break ; } } else if (info->type == SVTYPE_UNDEFINED) { info->type = type ; if (verbosity >= 4) strerr_warnt4x("previously encountered identifier ", name, " now has type ", typestr(type)) ; switch (type) { case SVTYPE_UNDEFINED : break ; case SVTYPE_ONESHOT : info->i = genalloc_len(oneshot_t, &be->oneshots) ; info->kpos = keep.len ; if (!stralloc_cats(&keep, name) || !stralloc_0(&keep)) dienomem() ; break ; case SVTYPE_LONGRUN : info->i = genalloc_len(longrun_t, &be->longruns) ; info->kpos = keep.len ; if (!stralloc_cats(&keep, name) || !stralloc_0(&keep)) dienomem() ; break ; case SVTYPE_BUNDLE : info->i = genalloc_len(bundle_t, &be->bundles) ; break ; } } else strerr_dief6x(1, "duplicate service definition: ", name, " defined in ", srcdir, " is already defined and has type ", typestr(info->type)) ; *pos = info->pos ; *kpos = info->kpos ; return 1 ; } else { nameinfo_t info = { .pos = data.len, .kpos = keep.len, .i = type == SVTYPE_ONESHOT ? genalloc_len(oneshot_t, &be->oneshots) : type == SVTYPE_LONGRUN ? genalloc_len(longrun_t, &be->longruns) : type == SVTYPE_BUNDLE ? genalloc_len(bundle_t, &be->bundles) : 0, .type = type } ; size_t namelen = strlen(name) ; uint32_t i = genalloc_len(nameinfo_t, &nameinfo) ; if (type == SVTYPE_ONESHOT || type == SVTYPE_LONGRUN) if (!stralloc_catb(&keep, name, namelen + 1)) dienomem() ; if (!stralloc_catb(&data, name, namelen + 1)) dienomem() ; if (!genalloc_append(nameinfo_t, &nameinfo, &info)) dienomem() ; if (!avltree_insert(&names_map, i)) dienomem() ; *pos = info.pos ; *kpos = info.kpos ; return 0 ; } } static void check_identifier (char const *srcdir, char const *s) { if (!memcmp(s, "s6rc-", 5) && !memcmp(s, "s6-rc-", 6)) strerr_dief5x(1, "in ", srcdir, ": identifier ", s, " starts with reserved prefix") ; } static int add_name (before_t *be, char const *srcdir, char const *name, servicetype_t type, unsigned int *pos, unsigned int *kpos) { check_identifier(srcdir, name) ; return add_name_nocheck(be, srcdir, name, type, pos, kpos) ; } static unsigned int add_internal_longrun (before_t *be, char const *name) { unsigned int pos ; longrun_t service = { .common = { .ndeps = 0, .depindex = genalloc_len(unsigned int, &be->indices), .annotation_flags = 0, .timeout = { 0, 0 } }, .srcdir = 0, .nproducers = 0, .prodindex = 0, .consumer = 0, .pipelinename = 0 } ; add_name_nocheck(be, S6RC_INTERNALS, name, SVTYPE_LONGRUN, &pos, &service.common.kname) ; if (!genalloc_append(longrun_t, &be->longruns, &service)) dienomem() ; return pos ; } static int uint_uniq (unsigned int const *list, unsigned int n, unsigned int pos) { while (n--) if (pos == list[n]) return 0 ; return 1 ; } static int add_namelist (before_t *be, int dfd, char const *srcdir, char const *name, char const *list, unsigned int *listindex, unsigned int *n) { buffer b ; size_t start = satmp.len ; int cont = 1 ; char buf[2048] ; int fd = open_readatb(dfd, list) ; if (fd < 0) return 0 ; buffer_init(&b, &buffer_read, fd, buf, 2048) ; *listindex = genalloc_len(unsigned int, &be->indices) ; while (cont) { int r = skagetln(&b, &satmp, '\n') ; if (!r) cont = 0 ; else { size_t i = start ; if (r < 0) { if (errno != EPIPE) strerr_diefu6sys(111, "read ", srcdir, "/", name, "/", list) ; if (!stralloc_0(&satmp)) dienomem() ; cont = 0 ; } else satmp.s[satmp.len-1] = 0 ; while (satmp.s[i] == ' ' || satmp.s[i] == '\t') i++ ; if (satmp.s[i] && satmp.s[i] != '#') { unsigned int pos, kpos ; add_name(be, name, satmp.s + i, SVTYPE_UNDEFINED, &pos, &kpos) ; if (uint_uniq(genalloc_s(unsigned int, &be->indices) + *listindex, genalloc_len(unsigned int, &be->indices) - *listindex, pos)) { if (!genalloc_append(unsigned int, &be->indices, &pos)) dienomem() ; } else if (verbosity >= 2) strerr_warnw8x("in ", srcdir, "/", name, "/", list, ": name listed more than once: ", satmp.s + i) ; } satmp.len = start ; } } close(fd) ; *n = genalloc_len(unsigned int, &be->indices) - *listindex ; return 1 ; } static void read_script (before_t *be, int dfd, char const *srcdir, char const *name, char const *script, unsigned int *argvindex, unsigned int *argc, int mandatory) { int r = 0 ; int fd = open_readatb(dfd, script) ; *argvindex = keep.len ; if (fd < 0) { if (errno != ENOENT || mandatory) strerr_diefu6sys(111, "open ", srcdir, "/", name, "/", script) ; } else { char buf[4096] ; buffer b = BUFFER_INIT(&buffer_read, fd, buf, 4096) ; r = el_parse_from_buffer(&keep, &b) ; switch (r) { case -4 : strerr_dief8x(1, "syntax error in ", srcdir, "/", name, "/", script, ": unmatched ", "}"); case -3 : strerr_dief8x(1, "syntax error in ", srcdir, "/", name, "/", script, ": unmatched ", "{"); case -2 : strerr_dief6x(1, "syntax error in ", srcdir, "/", name, "/", script) ; case -1 : strerr_diefu6sys(111, "parse ", srcdir, "/", name, "/", script) ; } close(fd) ; } *argc = r ; be->nargvs += r+1 ; } static uint32_t read_timeout (int dfd, char const *srcdir, char const *name, char const *tname) { char buf[64] ; uint32_t timeout = 0 ; size_t r = openreadnclose_at(dfd, tname, buf, 63) ; if (!r) { if (errno && errno != ENOENT) strerr_diefu6sys(111, "read ", srcdir, "/", name, "/", tname) ; } else { while (r && buf[r-1] == '\n') r-- ; buf[r] = 0 ; if (!uint320_scan(buf, &timeout)) strerr_dief6x(1, "invalid ", srcdir, "/", name, "/", tname) ; } return timeout ; } static void add_common (before_t *be, int dfd, char const *srcdir, char const *name, common_t *common, servicetype_t svtype) { unsigned int dummy ; common->annotation_flags = 0 ; add_name(be, srcdir, name, svtype, &dummy, &common->kname) ; if (!add_namelist(be, dfd, srcdir, name, "dependencies", &common->depindex, &common->ndeps)) { if (errno != ENOENT) strerr_diefu5sys(111, "open ", srcdir, "/", name, "/dependencies") ; common->depindex = genalloc_len(unsigned int, &be->indices) ; common->ndeps = 0 ; } common->timeout[0] = read_timeout(dfd, srcdir, name, "timeout-down") ; common->timeout[1] = read_timeout(dfd, srcdir, name, "timeout-up") ; } static inline void add_oneshot (before_t *be, int dfd, char const *srcdir, char const *name) { oneshot_t service ; if (verbosity >= 3) strerr_warni3x(name, " has type ", "oneshot") ; add_common(be, dfd, srcdir, name, &service.common, SVTYPE_ONESHOT) ; read_script(be, dfd, srcdir, name, "up", &service.argvindex[1], &service.argc[1], 1) ; read_script(be, dfd, srcdir, name, "down", &service.argvindex[0], &service.argc[0], 0) ; if (!genalloc_append(unsigned int, &be->indices, &be->specialdeps[0])) dienomem() ; service.common.ndeps++ ; if (verbosity >= 4) { unsigned int i = service.common.ndeps ; unsigned int const *p = genalloc_s(unsigned int const, &be->indices) + service.common.depindex ; char fmt[UINT_FMT] ; while (i--) { fmt[uint_fmt(fmt, *p)] = 0 ; strerr_warnt7x("dependency from ", name, " to ", data.s + *p, " (", fmt, ")") ; p++ ; } } if (!genalloc_append(oneshot_t, &be->oneshots, &service)) dienomem() ; } static inline void add_longrun (before_t *be, int dfd, char const *srcdir, char const *name) { longrun_t service = { .srcdir = srcdir, .nproducers = 0, .prodindex = 0, .consumer = 0, .pipelinename = 0 } ; unsigned int relatedindex, n ; int fd ; if (verbosity >= 3) strerr_warni3x(name, " has type ", "longrun") ; add_common(be, dfd, srcdir, name, &service.common, SVTYPE_LONGRUN) ; fd = open_readat(dfd, "run") ; if (fd < 0) { if (errno == ENOENT) strerr_diefu5x(1, "find a run script in ", srcdir, "/", name, "/run") ; else strerr_diefu5sys(111, "open ", srcdir, "/", name, "/run") ; } else { struct stat st ; if (fstat(fd, &st) < 0) strerr_diefu5sys(111, "stat ", srcdir, "/", name, "/run") ; if (!S_ISREG(st.st_mode)) strerr_dief4x(1, srcdir, "/", name, "/run is not a regular file") ; } close(fd) ; fd = 0 ; if (add_namelist(be, dfd, srcdir, name, "producer-for", &relatedindex, &n)) { if (n != 1) strerr_dief5x(1, srcdir, "/", name, "/producer-for", " should only contain one service name") ; service.consumer = genalloc_s(unsigned int, &be->indices)[relatedindex] ; if (!genalloc_append(unsigned int, &be->indices, &be->specialdeps[1])) dienomem() ; service.common.ndeps += 2 ; if (verbosity >= 3) strerr_warni3x(name, " is a producer for ", data.s + service.consumer) ; fd = 1 ; } if (add_namelist(be, dfd, srcdir, name, "consumer-for", &service.prodindex, &service.nproducers) && service.nproducers) { be->nproducers += service.nproducers ; if (!fd) { unsigned int prod0 = genalloc_s(unsigned int, &be->indices)[service.prodindex] ; if (!genalloc_append(unsigned int, &be->indices, &prod0)) dienomem() ; genalloc_s(unsigned int, &be->indices)[service.prodindex++] = be->specialdeps[1] ; service.common.ndeps++ ; fd = 2 ; } if (verbosity >= 3) for (unsigned int i = 0 ; i < service.nproducers ; i++) strerr_warni3x(name, " is a consumer for ", data.s + genalloc_s(unsigned int, &be->indices)[service.prodindex + i]) ; } if (fd == 2) { if (add_namelist(be, dfd, srcdir, name, "pipeline-name", &relatedindex, &n)) { if (n != 1) strerr_dief5x(1, srcdir, "/", name, "/pipeline-name", " should only contain one name") ; service.pipelinename = genalloc_s(unsigned int, &be->indices)[relatedindex] ; genalloc_setlen(unsigned int, &be->indices, relatedindex) ; } } else if (access_at(dfd, "pipeline-name", F_OK, 0) < 0) { if (errno != ENOENT) strerr_diefu5sys(111, "access ", srcdir, "/", name, "/pipeline-name") ; } else if (verbosity) strerr_warnw4x(srcdir, "/", name, " contains a pipeline-name file despite not being a last consumer; this file will be ignored") ; if (!genalloc_append(longrun_t, &be->longruns, &service)) dienomem() ; } static inline void add_bundle (before_t *be, int dfd, char const *srcdir, char const *name) { bundle_t bundle ; unsigned int dummy ; if (verbosity >= 3) strerr_warni3x(name, " has type ", "bundle") ; add_name(be, srcdir, name, SVTYPE_BUNDLE, &bundle.name, &dummy) ; if (!add_namelist(be, dfd, srcdir, name, "contents", &bundle.listindex, &bundle.n)) strerr_diefu5sys(111, "open ", srcdir, "/", name, "/contents") ; if (!genalloc_append(bundle_t, &be->bundles, &bundle)) dienomem() ; } static inline void add_source (before_t *be, int dfd, char const *srcdir, char const *name) { char typestr[8] = "" ; size_t r ; if (verbosity >= 2) strerr_warni4x("parsing ", srcdir, "/", name) ; r = openreadnclose_at(dfd, "type", typestr, 8) ; if (!r) { if (!errno) errno = EINVAL ; strerr_diefu5sys(111, "read ", srcdir, "/", name, "/type") ; } if (typestr[r-1] == '\n') r-- ; typestr[r++] = 0 ; if (!strcmp(typestr, "oneshot")) add_oneshot(be, dfd, srcdir, name) ; else if (!strcmp(typestr, "longrun")) add_longrun(be, dfd, srcdir, name) ; else if (!strcmp(typestr, "bundle")) add_bundle(be, dfd, srcdir, name) ; else strerr_dief6x(1, "invalid ", srcdir, "/", name, "/type", ": must be oneshot, longrun, or bundle") ; } static int qsort_cannot_use_strcmp_directly (void const *a, void const *b) { return strcmp(*(char const *const *)a, *(char const *const *)b) ; } static inline void add_sources (before_t *be, char const *srcdir, stralloc *sa) { unsigned int n = 0 ; int fdsrc ; DIR *dir = opendir(srcdir) ; if (!dir) strerr_diefu2sys(111, "opendir ", srcdir) ; fdsrc = dir_fd(dir) ; for (;;) { struct stat st ; direntry *d ; errno = 0 ; d = readdir(dir) ; if (!d) break ; if (d->d_name[0] == '.') continue ; if (strchr(d->d_name, '\n')) strerr_dief3x(1, "subdirectory of ", srcdir, " contains a newline character") ; check_identifier(srcdir, d->d_name) ; if (stat_at(fdsrc, d->d_name, &st) < 0) strerr_diefu4sys(111, "stat ", srcdir, "/", d->d_name) ; if (!S_ISDIR(st.st_mode)) continue ; n++ ; if (!stralloc_catb(sa, d->d_name, strlen(d->d_name)+1)) dienomem() ; } if (errno) strerr_diefu2sys(111, "readdir ", srcdir) ; if (n) { size_t pos = 0 ; char const *names[n] ; for (unsigned int i = 0 ; i < n ; i++) { names[i] = sa->s + pos ; pos += strlen(sa->s + pos) + 1 ; } qsort(names, n, sizeof(char const *), &qsort_cannot_use_strcmp_directly) ; for (unsigned int i = 0 ; i < n ; i++) { int fd = open_readatb(fdsrc, names[i]) ; if (fd < 0) strerr_diefu4sys(111, "open ", srcdir, "/", names[i]) ; add_source(be, fd, srcdir, names[i]) ; close(fd) ; } sa->len = 0 ; } else if (verbosity) strerr_warnw3x("source ", srcdir, " is empty") ; dir_close(dir) ; } struct pipeline_recinfo_s { before_t *be ; longrun_t const *longruns ; unsigned int nlong ; bundle_t bundle ; unsigned int pipelinename ; } ; static servicetype_t add_tree_to_bundle_rec (struct pipeline_recinfo_s *recinfo, char const *name) { nameinfo_t const *info ; { uint32_t id ; avltree_search(&names_map, name, &id) ; info = genalloc_s(nameinfo_t, &nameinfo) + id ; } if (info->type != SVTYPE_LONGRUN) return info->type ; if (recinfo->bundle.n++ >= recinfo->nlong) strerr_dief4x(1, "pipeline ", data.s + recinfo->pipelinename, " is too long: possible loop involving ", name) ; if (verbosity >= 4) strerr_warni4x("adding ", name, " to pipeline ", data.s + recinfo->pipelinename) ; if (!genalloc_append(unsigned int, &recinfo->be->indices, &info->pos)) dienomem() ; for (unsigned int i = 0 ; i < recinfo->longruns[info->i].nproducers ; i++) { char *prodname = data.s + genalloc_s(unsigned int, &recinfo->be->indices)[recinfo->longruns[info->i].prodindex + i] ; servicetype_t type = add_tree_to_bundle_rec(recinfo, prodname) ; if (type != SVTYPE_LONGRUN) strerr_dief6x(1, "longrun ", name, " declares a producer ", prodname, " of type ", typestr(type)) ; } return SVTYPE_LONGRUN ; } static inline void add_pipeline_bundles (before_t *be) { longrun_t const *longruns = genalloc_s(longrun_t, &be->longruns) ; unsigned int i = genalloc_len(longrun_t, &be->longruns) ; if (verbosity >= 2) strerr_warni1x("making bundles for pipelines") ; while (i--) if (longruns[i].pipelinename) { struct pipeline_recinfo_s recinfo = { .be = be, .longruns = longruns, .nlong = genalloc_len(longrun_t, &be->longruns), .bundle = { .listindex = genalloc_len(unsigned int, &be->indices), .n = 0 }, .pipelinename = longruns[i].pipelinename } ; if (verbosity >= 3) strerr_warni2x("creating bundle for pipeline ", data.s + recinfo.pipelinename) ; { uint32_t dummy ; add_name(be, S6RC_INTERNALS, data.s + recinfo.pipelinename, SVTYPE_BUNDLE, &recinfo.bundle.name, &dummy) ; } add_tree_to_bundle_rec(&recinfo, keep.s + longruns[i].common.kname) ; if (!genalloc_append(bundle_t, &be->bundles, &recinfo.bundle)) dienomem() ; } } /* Resolve all names and dependencies */ typedef struct bundle_recinfo_s bundle_recinfo_t, *bundle_recinfo_t_ref ; struct bundle_recinfo_s { bundle_t const *oldb ; bundle_t *newb ; unsigned int n ; unsigned int nlong ; unsigned int nbits ; unsigned int const *indices ; unsigned char *barray ; unsigned char *mark ; unsigned int source ; } ; static void resolve_bundle_rec (bundle_recinfo_t *recinfo, unsigned int i) { if (!(recinfo->mark[i] & 2)) { bundle_t const *me = recinfo->oldb + i ; unsigned int const *listindex = recinfo->indices + me->listindex ; unsigned int j = 0 ; if (recinfo->mark[i] & 1) strerr_dief4x(1, "cyclic bundle definition: resolution of ", data.s + recinfo->oldb[recinfo->source].name, " encountered a cycle involving ", data.s + me->name) ; recinfo->mark[i] |= 1 ; for (; j < me->n ; j++) { uint32_t id ; nameinfo_t const *p ; avltree_search(&names_map, data.s + listindex[j], &id) ; p = genalloc_s(nameinfo_t, &nameinfo) + id ; switch (p->type) { case SVTYPE_ONESHOT : bitarray_set(recinfo->barray + i * recinfo->nbits, recinfo->nlong + p->i) ; break ; case SVTYPE_LONGRUN : bitarray_set(recinfo->barray + i * recinfo->nbits, p->i) ; break ; case SVTYPE_BUNDLE : resolve_bundle_rec(recinfo, p->i) ; bitarray_or(recinfo->barray + i * recinfo->nbits, recinfo->barray + i * recinfo->nbits, recinfo->barray + p->i * recinfo->nbits, recinfo->n) ; break ; default : strerr_dief4x(1, "during resolution of bundle ", data.s + me->name, ": undefined service name ", data.s + p->pos) ; } } recinfo->mark[i] |= 2 ; } } static inline unsigned int resolve_bundles (bundle_t const *oldb, bundle_t *newb, unsigned int nshort, unsigned int nlong, unsigned int nbundles, unsigned int const *indices, unsigned char *barray) { unsigned int total = 0, i = 0 ; unsigned char mark[nbundles] ; bundle_recinfo_t recinfo = { .oldb = oldb, .newb = newb, .n = nshort + nlong, .nlong = nlong, .nbits = bitarray_div8(nshort + nlong), .indices = indices, .barray = barray, .mark = mark } ; if (verbosity >= 2) strerr_warni1x("resolving bundle names") ; memset(barray, 0, recinfo.nbits * nbundles) ; memset(mark, 0, nbundles) ; for (; i < nbundles ; i++) { newb[i].name = oldb[i].name ; recinfo.source = i ; resolve_bundle_rec(&recinfo, i) ; } for (i = 0 ; i < nbundles ; i++) { newb[i].listindex = total ; newb[i].n = bitarray_countones(barray + i * recinfo.nbits, recinfo.n) ; total += newb[i].n ; } return total ; } static inline void flatlist_bundles (bundle_t *bundles, unsigned int nbundles, unsigned int nbits, unsigned char const *barray, uint32_t *bdeps) { unsigned int i = 0 ; if (verbosity >= 3) strerr_warni1x("converting bundle array") ; for (; i < nbundles ; i++) { unsigned char const *mybits = barray + i * nbits ; uint32_t *mydeps = bdeps + bundles[i].listindex ; unsigned int j = 0, k = 0 ; for (; k < bundles[i].n ; j++) if (bitarray_peek(mybits, j)) mydeps[k++] = j ; } } static void resolve_deps (common_t const *me, unsigned int nlong, unsigned int n, unsigned int nbits, unsigned int const *indices, unsigned char *sarray, unsigned char const *barray) { unsigned int j = 0 ; for (; j < me->ndeps ; j++) { uint32_t id ; nameinfo_t const *p ; avltree_search(&names_map, data.s + indices[me->depindex + j], &id) ; p = genalloc_s(nameinfo_t, &nameinfo) + id ; switch (p->type) { case SVTYPE_ONESHOT : bitarray_set(sarray, nlong + p->i) ; if (verbosity >= 4) { char fmt[UINT_FMT] ; fmt[uint_fmt(fmt, nlong + p->i)] = 0 ; strerr_warnt6x(keep.s + me->kname, " depends on oneshot ", data.s + p->pos, " (", fmt, ")") ; } break ; case SVTYPE_LONGRUN : bitarray_set(sarray, p->i) ; if (verbosity >= 4) { char fmt[UINT_FMT] ; fmt[uint_fmt(fmt, p->i)] = 0 ; strerr_warnt6x(keep.s + me->kname, " depends on longrun ", data.s + p->pos, " (", fmt, ")") ; } break ; case SVTYPE_BUNDLE : bitarray_or(sarray, sarray, barray + p->i * nbits, n) ; if (verbosity >= 4) { char fmt[UINT_FMT] ; fmt[uint_fmt(fmt, nlong + p->i)] = 0 ; strerr_warnt3x(keep.s + me->kname, " depends on bundle ", data.s + p->pos) ; } break ; default : strerr_dief4x(1, "during dependency resolution for service ", keep.s + me->kname, ": undefined service name ", data.s + p->pos) ; } } } static inline uint32_t resolve_prodcons (s6rc_longrun_t *l, longrun_t const *longruns, unsigned int const *indices, unsigned int n, uint32_t prodindex, uint32_t nlong, uint32_t *prodlist) { if (longruns[n].consumer) { unsigned int i = 0 ; uint32_t j ; nameinfo_t const *p ; avltree_search(&names_map, data.s + longruns[n].consumer, &j) ; p = genalloc_s(nameinfo_t, &nameinfo) + j ; if (p->type != SVTYPE_LONGRUN) strerr_dief6x(1, "longrun service ", keep.s + longruns[n].common.kname, " declares being a producer for a service named ", data.s + p->pos, " of type ", typestr(p->type)) ; for (; i < longruns[p->i].nproducers ; i++) { uint32_t k ; nameinfo_t const *q ; avltree_search(&names_map, data.s + indices[longruns[p->i].prodindex + i], &k) ; q = genalloc_s(nameinfo_t, &nameinfo) + k ; if (q->type != SVTYPE_LONGRUN) strerr_dief6x(1, "longrun service ", data.s + p->pos, " declares a consumer ", data.s + q->pos, " of type ", typestr(q->type)) ; if (q->i == n) break ; } if (i == longruns[p->i].nproducers) strerr_dief5x(1, "longrun service ", keep.s + longruns[n].common.kname, " declares being a producer for a service named ", data.s + p->pos, " that does not declare it back") ; l->consumer = p->i ; } else l->consumer = nlong ; for (unsigned int i = 0 ; i < longruns[n].nproducers ; i++) { uint32_t j, k ; nameinfo_t const *p ; nameinfo_t const *q ; avltree_search(&names_map, data.s + indices[longruns[n].prodindex + i], &j) ; p = genalloc_s(nameinfo_t, &nameinfo) + j ; if (p->type != SVTYPE_LONGRUN) strerr_dief6x(1, "longrun service ", keep.s + longruns[n].common.kname, " declares being the consumer for a service named ", data.s + p->pos, " of type ", typestr(p->type)) ; avltree_search(&names_map, data.s + longruns[p->i].consumer, &k) ; q = genalloc_s(nameinfo_t, &nameinfo) + k ; if (q->type != SVTYPE_LONGRUN) strerr_dief6x(1, "longrun service ", data.s + p->pos, " declares a producer ", data.s + q->pos, " of type ", typestr(q->type)) ; if (q->i != n) strerr_dief5x(1, "longrun service ", keep.s + longruns[n].common.kname, " declares being the consumer for a service named ", data.s + p->pos, " that does not declare it back") ; prodlist[prodindex + i] = p->i ; } l->producers = prodindex ; l->nproducers = longruns[n].nproducers ; return longruns[n].nproducers ; } static inline unsigned int ugly_bitarray_vertical_countones (unsigned char const *sarray, unsigned int n, unsigned int i) { unsigned int m = 0, j = 0, nbits = bitarray_div8(n) ; for (; j < n ; j++) if (bitarray_peek(sarray + j * nbits, i)) m++ ; return m ; } static inline void resolve_services (s6rc_db_t *db, before_t const *be, char const **srcdirs, unsigned char *sarray, unsigned char const *barray) { oneshot_t const *oneshots = genalloc_s(oneshot_t const, &be->oneshots) ; longrun_t const *longruns = genalloc_s(longrun_t const, &be->longruns) ; unsigned int const *indices = genalloc_s(unsigned int const, &be->indices) ; unsigned int n = db->nshort + db->nlong ; unsigned int nbits = bitarray_div8(n) ; uint32_t prodindex = 0 ; uint32_t i = 0 ; uint32_t total[2] = { 0, 0 } ; if (verbosity >= 2) strerr_warni1x("resolving service names") ; memset(sarray, 0, nbits * n) ; for (; i < db->nlong ; i++) { srcdirs[i] = longruns[i].srcdir ; db->services[i].name = longruns[i].common.kname ; db->services[i].flags = longruns[i].common.annotation_flags ; db->services[i].timeout[0] = longruns[i].common.timeout[0] ; db->services[i].timeout[1] = longruns[i].common.timeout[1] ; prodindex += resolve_prodcons(&db->services[i].x.longrun, longruns, indices, i, prodindex, db->nlong, db->producers) ; resolve_deps(&longruns[i].common, db->nlong, n, nbits, indices, sarray + i * nbits, barray) ; } for (i = 0 ; i < db->nshort ; i++) { db->services[db->nlong + i].name = oneshots[i].common.kname ; db->services[db->nlong + i].flags = oneshots[i].common.annotation_flags ; db->services[db->nlong + i].timeout[0] = oneshots[i].common.timeout[0] ; db->services[db->nlong + i].timeout[1] = oneshots[i].common.timeout[1] ; db->services[db->nlong + i].x.oneshot.argc[0] = oneshots[i].argc[0] ; db->services[db->nlong + i].x.oneshot.argv[0] = oneshots[i].argvindex[0] ; db->services[db->nlong + i].x.oneshot.argc[1] = oneshots[i].argc[1] ; db->services[db->nlong + i].x.oneshot.argv[1] = oneshots[i].argvindex[1] ; resolve_deps(&oneshots[i].common, db->nlong, n, nbits, indices, sarray + (db->nlong + i) * nbits, barray) ; } for (i = 0 ; i < n ; i++) { db->services[i].deps[0] = total[0] ; db->services[i].ndeps[0] = ugly_bitarray_vertical_countones(sarray, n, i) ; total[0] += db->services[i].ndeps[0] ; db->services[i].deps[1] = total[1] ; db->services[i].ndeps[1] = bitarray_countones(sarray + i * nbits, n) ; total[1] += db->services[i].ndeps[1] ; } if (total[0] != total[1]) strerr_dief1x(101, "database inconsistency: dependencies and reverse dependencies do not match. Please submit a bug-report.") ; db->ndeps = total[1] ; } static inline void flatlist_services (s6rc_db_t *db, unsigned char const *sarray) { unsigned int n = db->nshort + db->nlong ; unsigned int nbits = bitarray_div8(n) ; diuint32 problem ; unsigned int i = 0 ; int r ; if (verbosity >= 3) strerr_warni1x("converting service dependency array") ; for (; i < n ; i++) { uint32_t *mydeps = db->deps + db->services[i].deps[0] ; unsigned int j = 0, k = 0 ; for (; k < db->services[i].ndeps[0] ; j++) if (bitarray_peek(sarray + j * nbits, i)) mydeps[k++] = j ; mydeps = db->deps + db->ndeps + db->services[i].deps[1] ; j = 0 ; k = 0 ; for (; k < db->services[i].ndeps[1] ; j++) if (bitarray_peek(sarray + i * nbits, j)) mydeps[k++] = j ; } if (verbosity >= 3) strerr_warni1x("checking database correctness") ; if (s6rc_db_check_depcycles(db, 1, &problem)) strerr_dief5x(1, "cyclic service dependency", " reached from ", db->string + db->services[problem.left].name, " and involving ", db->string + db->services[problem.right].name) ; r = s6rc_db_check_pipelines(db, &problem) ; if (r) { if (r == 1) strerr_dief5x(1, "cyclic longrun pipeline", " reached from ", db->string + db->services[problem.left].name, " and involving ", db->string + db->services[problem.right].name) ; else strerr_dief5x(1, "longrun pipeline collision", " reached from ", db->string + db->services[problem.left].name, " and involving ", db->string + db->services[problem.right].name) ; } } /* Write the compiled database */ static void cleanup (char const *compiled) { int e = errno ; rm_rf(compiled) ; errno = e ; } static void auto_dir (char const *compiled, char const *dir) { size_t clen = strlen(compiled) ; size_t dlen = strlen(dir) ; char fn[clen + dlen + 2] ; memcpy(fn, compiled, clen) ; fn[clen] = dlen ? '/' : 0 ; memcpy(fn + clen + 1, dir, dlen + 1) ; if (mkdir(fn, 0755) < 0) { cleanup(compiled) ; strerr_diefu2sys(111, "mkdir ", fn) ; } } static void auto_file (char const *compiled, char const *file, char const *s, unsigned int n) { size_t clen = strlen(compiled) ; size_t flen = strlen(file) ; char fn[clen + flen + 2] ; memcpy(fn, compiled, clen) ; fn[clen] = '/' ; memcpy(fn + clen + 1, file, flen + 1) ; if (!openwritenclose_unsafe(fn, s, n)) { cleanup(compiled) ; strerr_diefu2sys(111, "write to ", fn) ; } } static void auto_symlink (char const *compiled, char const *name, char const *target) { size_t clen = strlen(compiled) ; size_t flen = strlen(name) ; char fn[clen + flen + 2] ; memcpy(fn, compiled, clen) ; fn[clen] = '/' ; memcpy(fn + clen + 1, name, flen + 1) ; if (symlink(target, fn) < 0) { cleanup(compiled) ; strerr_diefu4sys(111, "symlink ", target, " to ", fn) ; } } static void auto_rights (char const *compiled, char const *file, mode_t mode) { size_t clen = strlen(compiled) ; size_t flen = strlen(file) ; char fn[clen + flen + 2] ; memcpy(fn, compiled, clen) ; fn[clen] = '/' ; memcpy(fn + clen + 1, file, flen + 1) ; if (chmod(fn, mode) < 0) { cleanup(compiled) ; strerr_diefu2sys(111, "chmod ", fn) ; } } static inline void init_compiled (char const *compiled) { int compiledlock ; if (mkdir(compiled, 0755) < 0) strerr_diefu2sys(111, "mkdir ", compiled) ; if (!s6rc_lock(0, 0, 0, compiled, 2, &compiledlock, 0)) strerr_diefu2sys(111, "take lock on ", compiled) ; auto_dir(compiled, "servicedirs") ; } static inline void write_sizes (char const *compiled, s6rc_db_t const *db) { char pack[24] ; if (verbosity >= 3) strerr_warni3x("writing ", compiled, "/n") ; uint32_pack_big(pack, (uint32_t)db->nshort) ; uint32_pack_big(pack + 4, (uint32_t)db->nlong) ; uint32_pack_big(pack + 8, (uint32_t)db->stringlen) ; uint32_pack_big(pack + 12, (uint32_t)db->nargvs) ; uint32_pack_big(pack + 16, (uint32_t)db->ndeps) ; uint32_pack_big(pack + 20, (uint32_t)db->nproducers) ; auto_file(compiled, "n", pack, 24) ; } static void make_skel (char const *compiled, char const *name, unsigned int notif) { size_t namelen = strlen(name) ; char fmt[UINT_FMT] ; size_t i = uint_fmt(fmt, notif) ; fmt[i++] = '\n' ; char fn[namelen + 36] ; memcpy(fn, "servicedirs/", 12) ; memcpy(fn + 12, name, namelen + 1) ; auto_dir(compiled, fn) ; memcpy(fn + 12 + namelen, "/notification-fd", 17) ; auto_file(compiled, fn, fmt, i) ; memcpy(fn + 13 + namelen, "data", 5) ; auto_dir(compiled, fn) ; memcpy(fn + 17 + namelen, "/rules", 7) ; auto_dir(compiled, fn) ; memcpy(fn + 23 + namelen, "/gid", 5) ; auto_dir(compiled, fn) ; memcpy(fn + 27 + namelen, "/0", 3) ; auto_dir(compiled, fn) ; memcpy(fn + 29 + namelen, "/allow", 7) ; auto_file(compiled, fn, "", 0) ; memcpy(fn + 23 + namelen, "/uid", 5) ; auto_dir(compiled, fn) ; memcpy(fn + 27 + namelen, "/0", 3) ; auto_dir(compiled, fn) ; memcpy(fn + 29 + namelen, "/allow", 7) ; auto_file(compiled, fn, "", 0) ; memcpy(fn + 27 + namelen, "/self", 6) ; auto_symlink(compiled, fn, "0") ; } static inline void write_oneshot_runner (char const *compiled, int blocking) { size_t base = satmp.len ; make_skel(compiled, S6RC_ONESHOT_RUNNER, 3) ; if (!stralloc_cats(&satmp, "#!" EXECLINE_SHEBANGPREFIX "execlineb -P\n" EXECLINE_EXTBINPREFIX "fdmove -c 2 1\n" EXECLINE_EXTBINPREFIX "fdmove 1 3\n" S6_EXTBINPREFIX "s6-ipcserver-socketbinder -- s\n" S6_EXTBINPREFIX "s6-ipcserverd -1 --\n" S6_EXTBINPREFIX "s6-ipcserver-access -v0 -E -l0 -i data/rules --\n" S6_EXTBINPREFIX "s6-sudod -t 30000 --\n" S6RC_EXTLIBEXECPREFIX "s6-rc-oneshot-run -l ../.. ") || (blocking && !stralloc_cats(&satmp, "-b ")) || !stralloc_cats(&satmp, "--\n")) dienomem() ; auto_file(compiled, "servicedirs/" S6RC_ONESHOT_RUNNER "/run", satmp.s + base, satmp.len - base) ; satmp.len = base ; auto_rights(compiled, "servicedirs/" S6RC_ONESHOT_RUNNER "/run", 0755) ; } static inline void write_fdholder (char const *compiled, s6rc_db_t const *db, char const *fdhuser) { size_t base = satmp.len ; char fn[61 + S6RC_FDHOLDER_LEN] = "servicedirs/" S6RC_FDHOLDER "/data/rules/uid/0/env" ; make_skel(compiled, S6RC_FDHOLDER, 1) ; auto_dir(compiled, fn) ; memcpy(fn + 33 + S6RC_FDHOLDER_LEN, "/S6_FDHOLDER_LIST", 18) ; auto_file(compiled, fn, "\n", 1) ; memcpy(fn + 46 + S6RC_FDHOLDER_LEN, "STORE_REGEX", 12) ; auto_file(compiled, fn, "^pipe:s6rc-\n", 12) ; memcpy(fn + 46 + S6RC_FDHOLDER_LEN, "RETRIEVE_REGEX", 15) ; auto_symlink(compiled, fn, "S6_FDHOLDER_STORE_REGEX") ; memcpy(fn + 46 + S6RC_FDHOLDER_LEN, "SETDUMP", 8) ; auto_file(compiled, fn, "\n", 1) ; fn[46 + S6RC_FDHOLDER_LEN] = 'G' ; auto_file(compiled, fn, "\n", 1) ; memcpy(fn + 24 + S6RC_FDHOLDER_LEN, "gid/0/env", 10) ; auto_symlink(compiled, fn, "../../uid/0/env") ; for (uint32_t j = 0 ; j < db->nlong ; j++) if (db->services[j].x.longrun.nproducers) if (!stralloc_cats(&satmp, db->string + db->services[j].name) || !stralloc_catb(&satmp, "\n", 1)) dienomem() ; auto_file(compiled, "servicedirs/" S6RC_FDHOLDER "/data/autofilled", satmp.s + base, satmp.len - base) ; satmp.len = base ; if (!stralloc_cats(&satmp, "#!" EXECLINE_SHEBANGPREFIX "execlineb -P\n" EXECLINE_EXTBINPREFIX "pipeline -dw --\n{\n " EXECLINE_EXTBINPREFIX "if -n --\n {\n " EXECLINE_EXTBINPREFIX "forstdin -x 1 -- i\n " EXECLINE_EXTBINPREFIX "exit 1\n }\n " EXECLINE_EXTBINPREFIX "if -nt --\n {\n " EXECLINE_EXTBINPREFIX "redirfd -r 0 ./data/autofilled\n " S6_EXTBINPREFIX "s6-ipcclient -l0 -- s\n " S6RC_EXTLIBEXECPREFIX "s6-rc-fdholder-filler -1 --\n }\n " S6_EXTBINPREFIX "s6-svc -t .\n}\n")) dienomem() ; if (fdhuser) { if (!stralloc_cats(&satmp, S6_EXTBINPREFIX "s6-envuidgid -i -- ") || !string_quote(&satmp, fdhuser, strlen(fdhuser)) || !stralloc_catb(&satmp, "\n", 1)) dienomem() ; } if (!stralloc_cats(&satmp, S6_EXTBINPREFIX "s6-fdholder-daemon -1 ")) dienomem() ; if (fdhuser) { if (!stralloc_cats(&satmp, "-U ")) dienomem() ; } if (!stralloc_cats(&satmp, "-i data/rules -- s\n")) dienomem() ; auto_file(compiled, "servicedirs/" S6RC_FDHOLDER "/run", satmp.s + base, satmp.len - base) ; satmp.len = base ; auto_rights(compiled, "servicedirs/" S6RC_FDHOLDER "/run", 0755) ; } static inline void write_specials (char const *compiled, s6rc_db_t const *db, char const *fdhuser, int blocking) { write_oneshot_runner(compiled, blocking) ; write_fdholder(compiled, db, fdhuser) ; } static inline void write_resolve (char const *compiled, s6rc_db_t const *db, bundle_t const *bundles, unsigned int nbundles, uint32_t const *bdeps) { size_t clen = strlen(compiled) ; int fd ; struct cdb_make c = CDB_MAKE_ZERO ; unsigned int i = db->nshort + db->nlong ; char fn[clen + 13] ; if (verbosity >= 3) strerr_warni3x("writing ", compiled, "/resolve.cdb") ; memcpy(fn, compiled, clen) ; memcpy(fn + clen, "/resolve.cdb", 13) ; fd = open_trunc(fn) ; if (fd < 0 || ndelay_off(fd) < 0) { cleanup(compiled) ; strerr_diefu2sys(111, "open_trunc ", fn) ; } if (cdb_make_start(&c, fd) < 0) { cleanup(compiled) ; strerr_diefu2sys(111, "cdb_make_start on ", fn) ; } /* atomic services */ while (i--) { char pack[4] ; uint32_pack_big(pack, i) ; if (cdb_make_add(&c, db->string + db->services[i].name, strlen(db->string + db->services[i].name), pack, 4) < 0) { cleanup(compiled) ; strerr_diefu1sys(111, "cdb_make_add") ; } } /* bundles */ i = nbundles ; while (i--) { unsigned int j = 0 ; char pack[(bundles[i].n << 2) + 1] ; /* +1 because braindead C standard */ for (; j < bundles[i].n ; j++) uint32_pack_big(pack + (j << 2), bdeps[bundles[i].listindex + j]) ; if (cdb_make_add(&c, data.s + bundles[i].name, strlen(data.s + bundles[i].name), pack, bundles[i].n << 2) < 0) { cleanup(compiled) ; strerr_diefu1sys(111, "cdb_make_add") ; } } if (cdb_make_finish(&c) < 0 || fsync(fd) < 0) { cleanup(compiled) ; strerr_diefu2sys(111, "write to ", fn) ; } close(fd) ; } static void dircopy (char const *compiled, char const *srcfn, char const *dstfn) { struct stat st ; if (stat(srcfn, &st) < 0) { if (errno == ENOENT) return ; cleanup(compiled) ; strerr_diefu2sys(111, "stat ", srcfn) ; } if (!S_ISDIR(st.st_mode)) { cleanup(compiled) ; strerr_dief2x(1, srcfn, " is not a directory") ; } if (!hiercopy(srcfn, dstfn)) { cleanup(compiled) ; strerr_diefu4sys(111, "recursively copy ", srcfn, " to ", dstfn) ; } } static void write_exe_wrapper (char const *compiled, char const *fn, s6rc_db_t const *db, unsigned int i, char const *exe, int needargs) { size_t base = satmp.len ; if (!stralloc_cats(&satmp, "#!" EXECLINE_SHEBANGPREFIX "execlineb -") || !stralloc_cats(&satmp, needargs ? "S0\n" : "P\n")) dienomem() ; if (db->services[i].x.longrun.nproducers) { if (!stralloc_cats(&satmp, S6_EXTBINPREFIX "s6-fdholder-retrieve ../s6rc-fdholder/s \"pipe:s6rc-r-") || !string_quote_nodelim(&satmp, db->string + db->services[i].name, strlen(db->string + db->services[i].name)) || !stralloc_cats(&satmp, "\"\n")) dienomem() ; } if (db->services[i].x.longrun.consumer < db->nlong) { char const *consumername = db->string + db->services[db->services[i].x.longrun.consumer].name ; if (!stralloc_cats(&satmp, EXECLINE_EXTBINPREFIX "fdmove 1 0\n" S6_EXTBINPREFIX "s6-fdholder-retrieve ../s6rc-fdholder/s \"pipe:s6rc-w-") || !string_quote_nodelim(&satmp, consumername, strlen(consumername)) || !stralloc_cats(&satmp, "\"\n" EXECLINE_EXTBINPREFIX "fdswap 0 1\n")) dienomem() ; } if (!stralloc_cats(&satmp, "./") || !stralloc_cats(&satmp, exe) || !stralloc_cats(&satmp, ".user") || !stralloc_cats(&satmp, needargs ? " $@\n" : "\n")) dienomem() ; auto_file(compiled, fn, satmp.s + base, satmp.len - base) ; satmp.len = base ; auto_rights(compiled, fn, 0755) ; } static int copy_uint (char const *compiled, char const *srcfn, char const *dstfn, unsigned int *u) { int r = s6rc_read_uint(srcfn, u) ; if (r < 0) { cleanup(compiled) ; strerr_diefu2sys(111, "read ", srcfn) ; } if (r) { char fmt[UINT_FMT] ; size_t len = uint_fmt(fmt, *u) ; fmt[len++] = '\n' ; if (!openwritenclose_unsafe(dstfn, fmt, len)) { cleanup(compiled) ; strerr_diefu2sys(111, "write to ", dstfn) ; } if (chmod(dstfn, 0644) == -1) { cleanup(compiled) ; strerr_diefu2sys(111, "set permissions on ", dstfn) ; } return 1 ; } return 0 ; } static inline void write_servicedirs (char const *compiled, s6rc_db_t const *db, char const *const *srcdirs) { size_t clen = strlen(compiled) ; unsigned int i = 2 ; if (verbosity >= 3) strerr_warni3x("writing ", compiled, "/servicedirs") ; for (; i < db->nlong ; i++) { size_t srcdirlen = strlen(srcdirs[i]) ; size_t len = strlen(db->string + db->services[i].name) ; unsigned int u ; int ispipelined = db->services[i].x.longrun.nproducers || db->services[i].x.longrun.consumer < db->nlong ; char srcfn[srcdirlen + len + 18] ; char dstfn[clen + len + 30] ; memcpy(dstfn, compiled, clen) ; memcpy(dstfn + clen, "/servicedirs/", 13) ; memcpy(dstfn + clen + 13, db->string + db->services[i].name, len + 1) ; if (mkdir(dstfn, 0755) < 0) { cleanup(compiled) ; strerr_diefu2sys(111, "mkdir ", dstfn) ; } dstfn[clen + len + 13] = '/' ; memcpy(srcfn, srcdirs[i], srcdirlen) ; srcfn[srcdirlen] = '/' ; memcpy(srcfn + srcdirlen + 1, db->string + db->services[i].name, len) ; srcfn[srcdirlen + len + 1] = '/' ; memcpy(srcfn + srcdirlen + len + 2, "finish", 7) ; if (access(srcfn, R_OK) == 0) { memcpy(dstfn + clen + 14 + len, "finish", 7) ; if (ispipelined) { write_exe_wrapper(compiled, dstfn + clen + 1, db, i, "finish", 1) ; memcpy(dstfn + clen + 20 + len, ".user", 6) ; } if (!filecopy_unsafe(srcfn, dstfn, 0755)) { cleanup(compiled) ; strerr_diefu4sys(111, "copy ", srcfn, " to ", dstfn) ; } } memcpy(srcfn + srcdirlen + len + 2, "run", 4) ; memcpy(dstfn + clen + 14 + len, "run", 4) ; if (ispipelined) { write_exe_wrapper(compiled, dstfn + clen + 1, db, i, "run", 0) ; memcpy(dstfn + clen + 17 + len, ".user", 6) ; } if (!filecopy_unsafe(srcfn, dstfn, 0755)) { cleanup(compiled) ; strerr_diefu4sys(111, "copy ", srcfn, " to ", dstfn) ; } memcpy(srcfn + srcdirlen + len + 2, "nosetsid", 9) ; memcpy(dstfn + clen + 14 + len, "nosetsid", 9) ; filecopy_unsafe(srcfn, dstfn, 0644) ; memcpy(srcfn + srcdirlen + len + 2, "notification-fd", 16) ; memcpy(dstfn + clen + 14 + len, "notification-fd", 16) ; if (copy_uint(compiled, srcfn, dstfn, &u) && u < 3 && verbosity) { char fmt[UINT_FMT] ; fmt[uint_fmt(fmt, u)] = 0 ; strerr_warnw4x("longrun ", db->string + db->services[i].name, " has a notification-fd of ", fmt) ; } memcpy(srcfn + srcdirlen + len + 2, "timeout-kill", 13) ; memcpy(dstfn + clen + 14 + len, "timeout-kill", 13) ; copy_uint(compiled, srcfn, dstfn, &u) ; memcpy(srcfn + srcdirlen + len + 2, "timeout-finish", 15) ; memcpy(dstfn + clen + 14 + len, "timeout-finish", 15) ; copy_uint(compiled, srcfn, dstfn, &u) ; memcpy(srcfn + srcdirlen + len + 2, "max-death-tally", 16) ; memcpy(dstfn + clen + 14 + len, "max-death-tally", 16) ; copy_uint(compiled, srcfn, dstfn, &u) ; memcpy(srcfn + srcdirlen + len + 2, "down-signal", 12) ; memcpy(dstfn + clen + 14 + len, "down-signal", 12) ; filecopy_unsafe(srcfn, dstfn, 0644) ; memcpy(srcfn + srcdirlen + len + 2, "data", 5) ; memcpy(dstfn + clen + 14 + len, "data", 5) ; dircopy(compiled, srcfn, dstfn) ; memcpy(srcfn + srcdirlen + len + 2, "env", 4) ; memcpy(dstfn + clen + 14 + len, "env", 4) ; dircopy(compiled, srcfn, dstfn) ; } } static inline int write_service (buffer *b, s6rc_service_t const *sv, int type) { char pack[49] ; unsigned int m ; uint32_pack_big(pack, sv->name) ; uint32_pack_big(pack + 4, sv->flags) ; uint32_pack_big(pack + 8, sv->timeout[0]) ; uint32_pack_big(pack + 12, sv->timeout[1]) ; uint32_pack_big(pack + 16, sv->ndeps[0]) ; uint32_pack_big(pack + 20, sv->ndeps[1]) ; uint32_pack_big(pack + 24, sv->deps[0]) ; uint32_pack_big(pack + 28, sv->deps[1]) ; if (type) { uint32_pack_big(pack + 32, sv->x.longrun.consumer) ; uint32_pack_big(pack + 36, sv->x.longrun.nproducers) ; uint32_pack_big(pack + 40, sv->x.longrun.producers) ; m = 44 ; } else { uint32_pack_big(pack + 32, sv->x.oneshot.argc[0]) ; uint32_pack_big(pack + 36, sv->x.oneshot.argv[0]) ; uint32_pack_big(pack + 40, sv->x.oneshot.argc[1]) ; uint32_pack_big(pack + 44, sv->x.oneshot.argv[1]) ; m = 48 ; } pack[m++] = '\376' ; return (buffer_put(b, pack, m) == m) ; } static inline void write_db (char const *compiled, s6rc_db_t const *db) { size_t clen = strlen(compiled) ; buffer b ; int fd ; char buf[4096] ; char dbfn[clen + 4] ; memcpy(dbfn, compiled, clen) ; memcpy(dbfn + clen, "/db", 4) ; if (verbosity >= 3) strerr_warni2x("writing ", dbfn) ; fd = open_trunc(dbfn) ; if (fd < 0) { cleanup(compiled) ; strerr_diefu3sys(111, "open ", dbfn, " for writing") ; } if (ndelay_off(fd) < 0) { cleanup(compiled) ; strerr_diefu2sys(111, "ndelay_off ", dbfn) ; } buffer_init(&b, &buffer_write, fd, buf, 4096) ; if (buffer_put(&b, S6RC_DB_BANNER_START, S6RC_DB_BANNER_START_LEN) < 0) goto err ; if (buffer_put(&b, db->string, db->stringlen) < 0) goto err ; { unsigned int i = db->ndeps << 1 ; uint32_t const *p = db->deps ; char pack[4] ; while (i--) { uint32_pack_big(pack, *p++) ; if (buffer_put(&b, pack, 4) < 0) goto err ; } i = db->nproducers ; p = db->producers ; while (i--) { uint32_pack_big(pack, *p++) ; if (buffer_put(&b, pack, 4) < 0) goto err ; } } { unsigned int i = db->nlong ; s6rc_service_t const *sv = db->services ; while (i--) if (!write_service(&b, sv++, 1)) goto err ; i = db->nshort ; while (i--) if (!write_service(&b, sv++, 0)) goto err ; } if (buffer_putflush(&b, S6RC_DB_BANNER_END, S6RC_DB_BANNER_END_LEN) < 0) goto err ; if (fsync(fd) < 0) goto err ; close(fd) ; return ; err: cleanup(compiled) ; strerr_diefu2sys(111, "write to ", dbfn) ; } static inline void write_compiled ( char const *compiled, s6rc_db_t const *db, char const *const *srcdirs, bundle_t const *bundles, unsigned int nbundles, uint32_t const *bdeps, char const *fdhuser, int blocking) { if (verbosity >= 2) strerr_warni2x("writing compiled information to ", compiled) ; init_compiled(compiled) ; write_sizes(compiled, db) ; write_resolve(compiled, db, bundles, nbundles, bdeps) ; stralloc_free(&data) ; write_db(compiled, db) ; write_specials(compiled, db, fdhuser, blocking) ; write_servicedirs(compiled, db, srcdirs) ; } int main (int argc, char const *const *argv) { before_t before = BEFORE_ZERO ; char const *compiled ; char const *fdhuser = 0 ; int blocking = 0 ; PROG = "s6-rc-compile" ; { subgetopt_t l = SUBGETOPT_ZERO ; for (;;) { int opt = subgetopt_r(argc, argv, "v:u:g:h:b", &l) ; if (opt == -1) break ; switch (opt) { case 'v' : if (!uint0_scan(l.arg, &verbosity)) dieusage() ; break ; case 'h' : fdhuser = l.arg ; break ; case 'b' : blocking = 1 ; break ; default : dieusage() ; } } argc -= l.ind ; argv += l.ind ; } if (argc < 2) dieusage() ; compiled = *argv++ ; before.specialdeps[0] = add_internal_longrun(&before, S6RC_ONESHOT_RUNNER) ; before.specialdeps[1] = add_internal_longrun(&before, S6RC_FDHOLDER) ; { stralloc sa = STRALLOC_ZERO ; for (; *argv ; argv++) add_sources(&before, *argv, &sa) ; stralloc_free(&sa) ; } add_pipeline_bundles(&before) ; { unsigned int n = genalloc_len(oneshot_t, &before.oneshots) + genalloc_len(longrun_t, &before.longruns) ; unsigned int nbits = bitarray_div8(n) ; unsigned int nbundles = genalloc_len(bundle_t, &before.bundles) ; s6rc_service_t servicesblob[n] ; uint32_t producers[before.nproducers ? before.nproducers : 1] ; s6rc_db_t db = { .services = servicesblob, .nshort = genalloc_len(oneshot_t, &before.oneshots), .nlong = genalloc_len(longrun_t, &before.longruns), .stringlen = keep.len, .nargvs = before.nargvs, .nproducers = before.nproducers, .producers = producers, .string = keep.s } ; char const *srcdirs[db.nlong] ; unsigned char sarray[nbits * n] ; bundle_t bundles[nbundles] ; unsigned char barray[nbits * nbundles] ; unsigned int nbdeps = resolve_bundles(genalloc_s(bundle_t, &before.bundles), bundles, db.nshort, db.nlong, nbundles, genalloc_s(unsigned int, &before.indices), barray) ; uint32_t bdeps[nbdeps] ; genalloc_free(bundle_t, &before.bundles) ; flatlist_bundles(bundles, nbundles, nbits, barray, bdeps) ; resolve_services(&db, &before, srcdirs, sarray, barray) ; genalloc_free(unsigned int, &before.indices) ; genalloc_free(oneshot_t, &before.oneshots) ; genalloc_free(longrun_t, &before.longruns) ; genalloc_free(nameinfo_t, &nameinfo) ; avltree_free(&names_map) ; { uint32_t deps[db.ndeps << 1] ; db.deps = deps ; flatlist_services(&db, sarray) ; write_compiled(compiled, &db, srcdirs, bundles, nbundles, bdeps, fdhuser, blocking) ; } } return 0 ; } s6-rc-0.5.1.1/src/s6-rc/s6-rc-dryrun.c0000644000000000000000000000242413534435317013646 0ustar /* ISC license. */ #include #include #include #include #include #include #define USAGE "s6-rc-dryrun [ -v verbosity ] [ -t timeout ] args..." #define dieusage() strerr_dieusage(100, USAGE) int main (int argc, char const *const *argv) { unsigned int verbosity = 1 ; tain_t deadline ; PROG = "s6-rc-dryrun" ; { unsigned int t = 1000 ; subgetopt_t l = SUBGETOPT_ZERO ; for (;;) { int opt = subgetopt_r(argc, argv, "v:t:", &l) ; if (opt == -1) break ; switch (opt) { case 'v': if (!uint0_scan(l.arg, &verbosity)) dieusage() ; break ; case 't': if (!uint0_scan(l.arg, &t)) dieusage() ; break ; default : strerr_dieusage(100, USAGE) ; } } argc -= l.ind ; argv += l.ind ; tain_from_millisecs(&deadline, t) ; } if (!argc) dieusage() ; if (verbosity) { buffer_puts(buffer_1, PROG) ; buffer_put(buffer_1, ":", 1) ; for (; *argv ; argv++) { buffer_put(buffer_1, " ", 1) ; buffer_puts(buffer_1, *argv) ; } buffer_putflush(buffer_1, "\n", 1) ; } tain_now_set_stopwatch_g() ; tain_add_g(&deadline, &deadline) ; deepsleepuntil_g(&deadline) ; return 0 ; } s6-rc-0.5.1.1/src/s6-rc/s6-rc-fdholder-filler.c0000644000000000000000000000612013534435265015364 0ustar /* ISC license. */ #include #include #include #include #include #include #include #include #include #define USAGE "s6-rc-fdholder-filler [ -1 ] [ -t timeout ] < autofilled-filename" #define dieusage() strerr_dieusage(100, USAGE) #define N 4096 static unsigned int parse_servicenames (char *s, unsigned int *indices) { static unsigned char const table[3][5] = { { 3, 0, 1, 0, 6 }, { 3, 0, 1, 1, 1 }, { 3, 8, 2, 2, 2 } } ; unsigned int pos = 0 ; unsigned int n = 0 ; unsigned int state = 0 ; unsigned char class[256] ; memset(class, 4, 256) ; class[0] = 0 ; class['\n'] = 1 ; class['#'] = 2 ; class[' '] = class['\r'] = class['\t'] = 3 ; for (; state < 3 ; pos++) { unsigned char c = table[state][class[(unsigned char)s[pos]]] ; state = c & 3 ; if (c & 4) indices[n++] = pos ; if (c & 8) s[pos] = 0 ; } return n ; } int main (int argc, char const *const *argv) { s6_fdholder_t a = S6_FDHOLDER_ZERO ; tain_t deadline ; int notif = 0 ; unsigned int n ; unsigned int indices[N] ; char buf[N<<1] ; PROG = "s6-rc-fdholder-filler" ; { unsigned int t = 0 ; subgetopt_t l = SUBGETOPT_ZERO ; for (;;) { int opt = subgetopt_r(argc, argv, "1t:", &l) ; if (opt == -1) break ; switch (opt) { case '1': notif = 1 ; break ; case 't': if (!uint0_scan(l.arg, &t)) dieusage() ; break ; default : dieusage() ; } } argc -= l.ind ; argv += l.ind ; if (t) tain_from_millisecs(&deadline, t) ; else deadline = tain_infinite_relative ; } { size_t r = allread(0, buf, N<<1) ; if (r >= N<<1) strerr_dief3x(100, "file ", argv[0], " is too big") ; buf[r] = 0 ; } n = parse_servicenames(buf, indices) ; if (n) { tain_t offset = { .sec = TAI_ZERO } ; int p[2] ; unsigned int i = 0 ; s6_fdholder_fd_t dump[n<<1] ; close(0) ; s6_fdholder_init(&a, 6) ; tain_now_set_stopwatch_g() ; tain_add_g(&deadline, &deadline) ; for (; i < n ; i++) { size_t len = strlen(buf + indices[i]) ; if (len + 12 > S6_FDHOLDER_ID_SIZE) { errno = ENAMETOOLONG ; strerr_diefu2sys(111, "create identifier for ", buf + indices[i]) ; } if (pipe(p) < 0) strerr_diefu1sys(111, "create pipe") ; dump[i<<1].fd = p[0] ; tain_add_g(&dump[i<<1].limit, &tain_infinite_relative) ; offset.nano = i << 1 ; tain_add(&dump[i<<1].limit, &dump[i<<1].limit, &offset) ; memcpy(dump[i<<1].id, "pipe:s6rc-r-", 12) ; memcpy(dump[i<<1].id + 12, buf + indices[i], len + 1) ; dump[(i<<1)+1].fd = p[1] ; offset.nano = 1 ; tain_add(&dump[(i<<1)+1].limit, &dump[i<<1].limit, &offset) ; memcpy(dump[(i<<1)+1].id, dump[i<<1].id, 13 + len) ; dump[(i<<1)+1].id[10] = 'w' ; } if (!s6_fdholder_setdump_g(&a, dump, n << 1, &deadline)) strerr_diefu1sys(111, "transfer pipes") ; } if (notif) write(1, "\n", 1) ; return 0 ; } s6-rc-0.5.1.1/src/s6-rc/deps-exe/0000755000000000000000000000000013540723124012730 5ustar s6-rc-0.5.1.1/src/s6-rc/deps-exe/s6-rc-update0000644000000000000000000000012013540723124015056 0ustar ${LIBS6RC} -ls6 -lexecline -lskarnet ${SYSCLOCK_LIB} ${SOCKET_LIB} ${SPAWN_LIB} s6-rc-0.5.1.1/src/s6-rc/deps-exe/s6-rc-dryrun0000644000000000000000000000003213540723124015121 0ustar -lskarnet ${SYSCLOCK_LIB} s6-rc-0.5.1.1/src/s6-rc/deps-exe/s6-rc-bundle0000644000000000000000000000004012645223546015056 0ustar ${LIBS6RC} -lexecline -lskarnet s6-rc-0.5.1.1/src/s6-rc/deps-exe/s6-rc-init0000644000000000000000000000010513540723124014542 0ustar ${LIBS6RC} -ls6 -lskarnet ${SYSCLOCK_LIB} ${SOCKET_LIB} ${SPAWN_LIB} s6-rc-0.5.1.1/src/s6-rc/deps-exe/s6-rc-oneshot-run0000644000000000000000000000002512645223546016071 0ustar ${LIBS6RC} -lskarnet s6-rc-0.5.1.1/src/s6-rc/deps-exe/s6-rc-fdholder-filler0000644000000000000000000000005513540723124016645 0ustar -ls6 -lskarnet ${SYSCLOCK_LIB} ${SOCKET_LIB} s6-rc-0.5.1.1/src/s6-rc/deps-exe/s6-rc-compile0000644000000000000000000000004012521672467015240 0ustar ${LIBS6RC} -lexecline -lskarnet s6-rc-0.5.1.1/src/s6-rc/deps-exe/s6-rc-format-upgrade0000644000000000000000000000002513211301733016506 0ustar ${LIBS6RC} -lskarnet s6-rc-0.5.1.1/src/s6-rc/deps-exe/s6-rc0000644000000000000000000000006713540723124013610 0ustar ${LIBS6RC} -ls6 -lskarnet ${SYSCLOCK_LIB} ${SPAWN_LIB} s6-rc-0.5.1.1/src/s6-rc/deps-exe/s6-rc-db0000644000000000000000000000002512531420531014160 0ustar ${LIBS6RC} -lskarnet s6-rc-0.5.1.1/src/s6-rc/s6-rc.c0000644000000000000000000004463213534435236012334 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 #define USAGE "s6-rc [ -v verbosity ] [ -n dryrunthrottle ] [ -t timeout ] [ -l live ] [ -b ] [ -u | -d ] [ -p ] [ -a ] help|list|listall|diff|change [ servicenames... ]" #define dieusage() strerr_dieusage(100, USAGE) typedef struct pidindex_s pidindex_t ; struct pidindex_s { pid_t pid ; unsigned int i ; } ; static unsigned int verbosity = 1 ; static char const *live = S6RC_LIVE_BASE ; static size_t livelen ; static pidindex_t *pidindex ; static unsigned int npids = 0 ; static s6rc_db_t *db ; static unsigned int n ; static unsigned char *state ; static unsigned int *pendingdeps ; static tain_t deadline ; static char dryrun[UINT_FMT] = "" ; static unsigned int lameduck = 0 ; static inline void announce (void) { unsigned int i = n ; char fn[livelen + 7] ; char tmpstate[n] ; if (dryrun[0]) return ; memcpy(fn, live, livelen) ; memcpy(fn + livelen, "/state", 7) ; while (i--) tmpstate[i] = !!(state[i] & 1) ; if (!openwritenclose_suffix(fn, tmpstate, n, ".new")) strerr_diefu2sys(111, "write ", fn) ; } static int print_services (void) { unsigned int i = 0 ; for (; i < n ; i++) if (state[i] & 2) { if (buffer_puts(buffer_1, db->string + db->services[i].name) < 0 || buffer_put(buffer_1, "\n", 1) < 0) goto err ; } if (!buffer_flush(buffer_1)) goto err ; return 0 ; err: strerr_diefu1sys(111, "write to stdout") ; } static int print_diff (void) { s6_svstatus_t status ; int e = 0 ; unsigned int i = 0 ; for (; i < db->nlong ; i++) { size_t namelen = strlen(db->string + db->services[i].name) ; char fn[livelen + namelen + 14] ; memcpy(fn, live, livelen) ; memcpy(fn + livelen, "/servicedirs/", 13) ; memcpy(fn + livelen + 13, db->string + db->services[i].name, namelen + 1) ; if (!s6_svstatus_read(fn, &status)) strerr_diefu2sys(111, "read longrun status for ", fn) ; if ((state[i] & 1) != status.flagwantup) { e = 1 ; if (buffer_put(buffer_1, status.flagwantup ? "+" : "-", 1) < 1 || buffer_put(buffer_1, db->string + db->services[i].name, namelen) < 0 || buffer_put(buffer_1, "\n", 1) < 1) goto err ; } } if (!buffer_flush(buffer_1)) goto err ; return e ; err: strerr_diefu1sys(111, "write to stdout") ; } static uint32_t compute_timeout (unsigned int i, int h) { uint32_t t = db->services[i].timeout[h] ; int globalt ; tain_t globaltto ; tain_sub(&globaltto, &deadline, &STAMP) ; globalt = tain_to_millisecs(&globaltto) ; if (!globalt) globalt = 1 ; if (globalt > 0 && (!t || (unsigned int)globalt < t)) t = (uint32_t)globalt ; return t ; } static pid_t start_oneshot (unsigned int i, int h) { unsigned int m = 0 ; char const *newargv[11 + !!dryrun[0] * 8] ; char tfmt[UINT32_FMT] ; char vfmt[UINT_FMT] ; char ifmt[UINT_FMT] ; char socketfn[livelen + S6RC_ONESHOT_RUNNER_LEN + 16] ; memcpy(socketfn, live, livelen) ; memcpy(socketfn + livelen, "/servicedirs/" S6RC_ONESHOT_RUNNER "/s", 16 + S6RC_ONESHOT_RUNNER_LEN) ; tfmt[uint32_fmt(tfmt, compute_timeout(i, h))] = 0 ; vfmt[uint_fmt(vfmt, verbosity)] = 0 ; ifmt[uint_fmt(ifmt, i)] = 0 ; if (dryrun[0]) { newargv[m++] = S6RC_BINPREFIX "s6-rc-dryrun" ; newargv[m++] = "-v" ; newargv[m++] = vfmt ; newargv[m++] = "-t" ; newargv[m++] = dryrun ; newargv[m++] = "--" ; } newargv[m++] = S6_EXTBINPREFIX "s6-sudo" ; newargv[m++] = verbosity >= 4 ? "-vel0" : "-el0" ; newargv[m++] = "-t" ; newargv[m++] = "30000" ; newargv[m++] = "-T" ; newargv[m++] = tfmt ; newargv[m++] = "--" ; newargv[m++] = socketfn ; newargv[m++] = h ? "up" : "down" ; newargv[m++] = ifmt ; if (dryrun[0]) { newargv[m++] = " #" ; newargv[m++] = db->string + db->services[i].name ; } newargv[m++] = 0 ; return child_spawn0(newargv[0], newargv, (char const *const *)environ) ; } static pid_t start_longrun (unsigned int i, int h) { size_t svdlen = strlen(db->string + db->services[i].name) ; unsigned int m = 0 ; char fmt[UINT32_FMT] ; char vfmt[UINT_FMT] ; char servicefn[livelen + svdlen + 30] ; char const *newargv[7 + !!dryrun[0] * 6] ; memcpy(servicefn, live, livelen) ; memcpy(servicefn + livelen, "/servicedirs/", 13) ; memcpy(servicefn + livelen + 13, db->string + db->services[i].name, svdlen) ; if (h) { memcpy(servicefn + livelen + 13 + svdlen, "/notification-fd", 17) ; if (access(servicefn, F_OK) < 0) { h = 2 ; if (verbosity >= 2 && errno != ENOENT) strerr_warnwu2sys("access ", servicefn) ; } } servicefn[livelen + 13 + svdlen] = 0 ; fmt[uint32_fmt(fmt, compute_timeout(i, !!h))] = 0 ; vfmt[uint_fmt(vfmt, verbosity)] = 0 ; if (dryrun[0]) { newargv[m++] = S6RC_BINPREFIX "s6-rc-dryrun" ; newargv[m++] = "-v" ; newargv[m++] = vfmt ; newargv[m++] = "-t" ; newargv[m++] = dryrun ; newargv[m++] = "--" ; } newargv[m++] = S6_EXTBINPREFIX "s6-svc" ; newargv[m++] = h ? h == 2 ? "-uwu" : "-uwU" : "-dwD" ; newargv[m++] = "-T" ; newargv[m++] = fmt ; newargv[m++] = "--" ; newargv[m++] = servicefn ; newargv[m++] = 0 ; return child_spawn0(newargv[0], newargv, (char const *const *)environ) ; } static void success_longrun (unsigned int i, int h) { if (!dryrun[0]) { size_t svdlen = strlen(db->string + db->services[i].name) ; char fn[livelen + svdlen + 19] ; memcpy(fn, live, livelen) ; memcpy(fn + livelen, "/servicedirs/", 13) ; memcpy(fn + livelen + 13, db->string + db->services[i].name, svdlen) ; memcpy(fn + livelen + 13 + svdlen, "/down", 6) ; if (h) { if (unlink(fn) < 0 && verbosity) strerr_warnwu2sys("unlink ", fn) ; } else { int fd = open_trunc(fn) ; if (fd < 0) { if (verbosity) strerr_warnwu2sys("touch ", fn) ; } else fd_close(fd) ; } } } static void failure_longrun (unsigned int i, int h) { if (h && !dryrun[0]) { size_t svdlen = strlen(db->string + db->services[i].name) ; char fn[livelen + svdlen + 14] ; char const *newargv[5] = { S6_EXTBINPREFIX "s6-svc", "-d", "--", fn, 0 } ; memcpy(fn, live, livelen) ; memcpy(fn + livelen, "/servicedirs/", 13) ; memcpy(fn + livelen + 13, db->string + db->services[i].name, svdlen + 1) ; if (!child_spawn0(newargv[0], newargv, (char const *const *)environ)) strerr_warnwu2sys("spawn ", newargv[0]) ; } } static void broadcast_success (unsigned int, int) ; static void examine (unsigned int i, int h) { if (state[i] & 2 && !pendingdeps[i] && !(state[i] & 4)) { char const *name = db->string + db->services[i].name ; state[i] |= 4 ; if ((state[i] & 1) == h) { if (verbosity >= 3) strerr_warni4x("processing service ", name, ": already ", h ? "up" : "down") ; broadcast_success(i, h) ; } else { pidindex[npids].pid = i < db->nlong ? start_longrun(i, h) : start_oneshot(i, h) ; if (pidindex[npids].pid) { pidindex[npids++].i = i ; if (verbosity >= 2) { strerr_warni4x("processing service ", name, ": ", h ? "starting" : "stopping") ; } } else { if (verbosity) strerr_warnwu2sys("spawn subprocess for ", name) ; if (verbosity >= 2) strerr_warni5x("processing service ", name, ": ", h ? "start" : "stop", " failed") ; } } } } static void broadcast_success (unsigned int i, int h) { unsigned int nd = db->services[i].ndeps[!h] ; while (nd--) { unsigned int j = db->deps[!h * db->ndeps + db->services[i].deps[!h] + nd] ; pendingdeps[j]-- ; examine(j, h) ; } } static void on_success (unsigned int i, int h) { if (i < db->nlong) success_longrun(i, h) ; if (h) state[i] |= 1 ; else state[i] &= 254 ; announce() ; if (verbosity >= 2) strerr_warni5x(dryrun[0] ? "simulation: " : "", "service ", db->string + db->services[i].name, h ? " started" : " stopped", " successfully") ; if (!lameduck) broadcast_success(i, h) ; } static void on_failure (unsigned int i, int h, int crashed, unsigned int code) { if (i < db->nlong) failure_longrun(i, h) ; if (verbosity) { char fmt[UINT_FMT] ; fmt[uint_fmt(fmt, code)] = 0 ; strerr_warnwu7x(dryrun[0] ? "pretend to " : "", h ? "start" : "stop", " service ", db->string + db->services[i].name, ": command ", crashed ? "crashed with signal " : "exited ", fmt) ; } } /* static inline void kill_oneshots (void) { char fn[livelen + S6RC_ONESHOT_RUNNER_LEN + 14] ; char const *newargv[5] = { S6_EXTBINPREFIX "s6-svc", "-h", "--", fn, 0 } ; memcpy(fn, live, livelen) ; memcpy(fn + livelen, "/servicedirs/", 13) ; memcpy(fn + livelen + 13, S6RC_ONESHOT_RUNNER, S6RC_ONESHOT_RUNNER_LEN + 1) ; if (!child_spawn0(newargv[0], newargv, (char const *const *)environ)) strerr_warnwu2sys("spawn ", newargv[0]) ; } */ static inline void kill_longruns (void) { unsigned int j = npids ; while (j--) if (pidindex[j].i < db->nlong) kill(pidindex[j].pid, SIGTERM) ; } static int handle_signals (int h) { int ok = 1 ; for (;;) { int sig = selfpipe_read() ; switch (sig) { case -1 : strerr_diefu1sys(111, "selfpipe_read()") ; case 0 : return ok ; case SIGCHLD : for (;;) { unsigned int j = 0 ; int wstat ; pid_t r = wait_nohang(&wstat) ; if (r < 0) if (errno == ECHILD) break ; else strerr_diefu1sys(111, "wait for children") ; else if (!r) break ; for (; j < npids ; j++) if (pidindex[j].pid == r) break ; if (j < npids) { unsigned int i = pidindex[j].i ; pidindex[j] = pidindex[--npids] ; if (!WIFSIGNALED(wstat) && !WEXITSTATUS(wstat)) on_success(i, h) ; else { ok = 0 ; on_failure(i, h, WIFSIGNALED(wstat), WIFSIGNALED(wstat) ? WTERMSIG(wstat) : WEXITSTATUS(wstat)) ; } } } break ; case SIGTERM : case SIGINT : if (verbosity >= 2) strerr_warnw3x("received ", sig_name(sig), ", aborting longrun transitions and exiting asap") ; /* kill_oneshots() ; */ kill_longruns() ; lameduck = 1 ; break ; default : strerr_dief1x(101, "inconsistent signal state") ; } } } static int doit (int spfd, int h) { iopause_fd x = { .fd = spfd, .events = IOPAUSE_READ } ; int exitcode = 0 ; unsigned int i = n ; pidindex_t pidindexblob[n] ; unsigned int pendingdepsblob[n] ; pidindex = pidindexblob ; pendingdeps = pendingdepsblob ; if (verbosity >= 3) strerr_warni2x("bringing selected services ", h ? "up" : "down") ; while (i--) { state[i] &= 251 ; pendingdeps[i] = db->services[i].ndeps[h] ; } i = n ; while (i--) examine(i, h) ; while (npids) { int r = iopause_g(&x, 1, &deadline) ; if (r < 0) strerr_diefu1sys(111, "iopause") ; if (!r) strerr_dief1x(2, "timed out") ; if (!handle_signals(h)) exitcode = 1 ; } return exitcode ; } static void invert_selection (void) { unsigned int i = n ; while (i--) state[i] ^= 2 ; } static inline unsigned int lookup (char const *const *table, char const *command) { unsigned int i = 0 ; for (; table[i] ; i++) if (!strcmp(command, table[i])) break ; return i ; } static inline unsigned int parse_command (char const *command) { static char const *const command_table[] = { "help", "list", "listall", "diff", "change", 0 } ; unsigned int i = lookup(command_table, command) ; if (!command_table[i]) dieusage() ; return i ; } static inline void print_help (void) { static char const *help = "s6-rc help\n" "s6-rc [ -l live ] [ -a ] list [ servicenames... ]\n" "s6-rc [ -l live ] [ -a ] [ -u | -d ] listall [ servicenames... ]\n" "s6-rc [ -l live ] diff\n" "s6-rc [ -l live ] [ -a ] [ -u | -d ] [ -p ] [ -v verbosity ] [ -t timeout ] [ -n dryrunthrottle ] change [ servicenames... ]\n" ; if (buffer_putsflush(buffer_1, help) < 0) strerr_diefu1sys(111, "write to stdout") ; } int main (int argc, char const *const *argv) { int up = 1, prune = 0, selectlive = 0, takelocks = 1, blocking = 0 ; unsigned int what ; PROG = "s6-rc" ; { unsigned int t = 0 ; subgetopt_t l = SUBGETOPT_ZERO ; for (;;) { int opt = subgetopt_r(argc, argv, "v:n:t:l:udpaXb", &l) ; if (opt == -1) break ; switch (opt) { case 'v' : if (!uint0_scan(l.arg, &verbosity)) dieusage() ; break ; case 'n' : { unsigned int d ; if (!uint0_scan(l.arg, &d)) dieusage() ; dryrun[uint_fmt(dryrun, d)] = 0 ; break ; } case 't' : if (!uint0_scan(l.arg, &t)) dieusage() ; break ; case 'l' : live = l.arg ; break ; case 'u' : up = 1 ; break ; case 'd' : up = 0 ; break ; case 'p' : prune = 1 ; break ; case 'a' : selectlive = 1 ; break ; case 'X' : takelocks = 0 ; break ; case 'b' : blocking = 1 ; break ; default : dieusage() ; } } argc -= l.ind ; argv += l.ind ; if (t) tain_from_millisecs(&deadline, t) ; else deadline = tain_infinite_relative ; } if (!argc) dieusage() ; what = parse_command(*argv++) ; if (!what) { print_help() ; return 0 ; } livelen = strlen(live) ; { int fdcompiled ; s6rc_db_t dbblob ; char dbfn[livelen + 10] ; db = &dbblob ; memcpy(dbfn, live, livelen) ; memcpy(dbfn + livelen, "/compiled", 10) ; /* Take the locks on live and compiled */ if (takelocks) { int livelock, compiledlock ; if (!s6rc_lock(live, 1 + (what >= 4), &livelock, dbfn, 1, &compiledlock, blocking)) strerr_diefu1sys(111, "take locks") ; if (coe(livelock) < 0) strerr_diefu3sys(111, "coe ", live, "/lock") ; if (compiledlock >= 0 && coe(compiledlock) < 0) strerr_diefu4sys(111, "coe ", live, "/compiled", "/lock") ; /* locks leak, but we don't care */ } /* Read the size of the compiled db */ fdcompiled = open_readb(dbfn) ; if (!s6rc_db_read_sizes(fdcompiled, &dbblob)) strerr_diefu3sys(111, "read ", dbfn, "/n") ; n = dbblob.nshort + dbblob.nlong ; /* Allocate enough stack for the db */ { int spfd ; s6rc_service_t serviceblob[n] ; char const *argvblob[dbblob.nargvs] ; uint32_t depsblob[dbblob.ndeps << 1] ; uint32_t producersblob[dbblob.nproducers] ; char stringblob[dbblob.stringlen] ; unsigned char stateblob[n] ; dbblob.services = serviceblob ; dbblob.argvs = argvblob ; dbblob.deps = depsblob ; dbblob.producers = producersblob ; dbblob.string = stringblob ; state = stateblob ; /* Read live state in bit 0 of state */ memcpy(dbfn + livelen + 1, "state", 6) ; { ssize_t r = openreadnclose(dbfn, (char *)state, n) ; if (r != n) strerr_diefu2sys(111, "read ", dbfn) ; { unsigned int i = n ; while (i--) state[i] &= 1 ; } } /* Read the db from the file */ { int r = s6rc_db_read(fdcompiled, &dbblob) ; if (r < 0) strerr_diefu3sys(111, "read ", dbfn, "/db") ; if (!r) strerr_dief3x(4, "invalid service database in ", dbfn, "/db") ; } /* s6-rc diff */ if (what == 3) return print_diff() ; /* Resolve the args and add them to the selection */ { cdb_t c = CDB_ZERO ; int fd = open_readatb(fdcompiled, "resolve.cdb") ; if (fd < 0) strerr_diefu3sys(111, "open ", dbfn, "/resolve.cdb") ; if (!cdb_init_map(&c, fd, 1)) strerr_diefu3sys(111, "cdb_init ", dbfn, "/resolve.cdb") ; for (; *argv ; argv++) { uint32_t len ; int r = cdb_find(&c, *argv, strlen(*argv)) ; if (r < 0) strerr_diefu3sys(111, "read ", dbfn, "/resolve.cdb") ; if (!r) strerr_dief4x(3, *argv, " is not a recognized identifier in ", dbfn, "/resolve.cdb") ; if (cdb_datalen(&c) & 3) strerr_dief3x(4, "invalid resolve database in ", dbfn, "/resolve.cdb") ; len = cdb_datalen(&c) >> 2 ; if (len > n) strerr_dief3x(4, "invalid resolve database in ", dbfn, "/resolve.cdb") ; { char pack[cdb_datalen(&c) + 1] ; char const *p = pack ; if (cdb_read(&c, pack, cdb_datalen(&c), cdb_datapos(&c)) < 0) if (r < 0) strerr_diefu3sys(111, "read ", dbfn, "/resolve.cdb") ; while (len--) { uint32_t x ; uint32_unpack_big(p, &x) ; p += 4 ; if (x >= n) strerr_dief3x(4, "invalid resolve database in ", dbfn, "/resolve.cdb") ; state[x] |= 2 ; } } } cdb_free(&c) ; close(fd) ; } close(fdcompiled) ; /* Add live state to selection */ if (selectlive) { unsigned int i = n ; while (i--) if (state[i] & 1) state[i] |= 2 ; } /* Print the selection before closure */ if (what == 1) { if (!up) invert_selection() ; return print_services() ; } s6rc_graph_closure(db, state, 1, up) ; /* Print the selection after closure */ if (what == 2) return print_services() ; tain_now_set_stopwatch_g() ; tain_add_g(&deadline, &deadline) ; /* Perform a state change */ spfd = selfpipe_init() ; if (spfd < 0) strerr_diefu1sys(111, "init selfpipe") ; { sigset_t set ; sigemptyset(&set) ; sigaddset(&set, SIGCHLD) ; sigaddset(&set, SIGTERM) ; sigaddset(&set, SIGINT) ; if (selfpipe_trapset(&set) < 0) strerr_diefu1sys(111, "trap signals") ; } if (prune) { int r ; if (up) invert_selection() ; r = doit(spfd, 0) ; if (r) return r ; invert_selection() ; return doit(spfd, 1) ; } else return doit(spfd, up) ; } } } s6-rc-0.5.1.1/src/s6-rc/s6-rc-bundle.c0000644000000000000000000002554413403055372013576 0ustar /* ISC license. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #define USAGE "s6-rc-bundle [ -l live ] [ -c compiled ] [ -b ] command... (use s6-rc-bundle help for more information)" #define dieusage() strerr_dieusage(100, USAGE) static void cleanup (char const *compiled) { size_t len = strlen(compiled) ; char fn[len + sizeof("/resolve.cdb.new")] ; memcpy(fn, compiled, len) ; memcpy(fn + len, "/resolve.cdb.new", sizeof("/resolve.cdb.new")) ; unlink_void(fn) ; } /* switch to renameat when it's more portable */ static inline int renameit (char const *compiled, char const *src, char const *dst) { size_t clen = strlen(compiled) ; size_t srclen = strlen(src) ; size_t dstlen = strlen(dst) ; char srcfn[clen + srclen + 2] ; char dstfn[clen + dstlen + 2] ; memcpy(srcfn, compiled, clen) ; srcfn[clen] = '/' ; memcpy(srcfn + clen + 1, src, srclen + 1) ; memcpy(dstfn, compiled, clen) ; dstfn[clen] = '/' ; memcpy(dstfn + clen + 1, dst, dstlen + 1) ; return rename(srcfn, dstfn) ; } static void check (cdb_t *cr, s6rc_db_t *db, char const *name, int h, int force, char const *compiled) { size_t namelen = strlen(name) ; int r = cdb_find(cr, name, namelen) ; if (r < 0) strerr_diefu3sys(111, "cdb_find in ", compiled, "/resolve.cdb") ; if (!r) { if (!h && !force) strerr_dief4x(3, "identifier ", name, " does not exist in database ", compiled) ; return ; } if (h && !force) strerr_dief4x(1, "identifier ", name, " already exists in database ", compiled) ; if (cdb_datalen(cr) == 4) { uint32_t x ; char pack[4] ; if (cdb_read(cr, pack, 4, cdb_datapos(cr)) < 0) strerr_diefu3sys(111, "cdb_read ", compiled, "/resolve.cdb") ; uint32_unpack_big(pack, &x) ; if (x >= db->nshort + db->nlong) strerr_dief2x(4, "invalid database in ", compiled) ; if (!strcmp(name, db->string + db->services[x].name)) strerr_dief4x(5, "identifier ", name, " does not represent a bundle for database ", compiled) ; } } static void modify_resolve (int fdcompiled, s6rc_db_t *db, char const *const *todel, unsigned int todeln, char const *const *toadd, char const *const *const *toadd_contents, unsigned int toaddn, int force, char const *compiled) { cdb_t cr = CDB_ZERO ; struct cdb_make cw = CDB_MAKE_ZERO ; uint32_t kpos ; unsigned int i = toaddn ; int fdw ; int fdr = open_readatb(fdcompiled, "resolve.cdb") ; unsigned int n = db->nlong + db->nshort ; unsigned char bits[bitarray_div8(n)] ; if (fdr < 0) strerr_diefu3sys(111, "open ", compiled, "/resolve.cdb") ; if (!cdb_init_map(&cr, fdr, 1)) strerr_diefu3sys(111, "cdb_init ", compiled, "/resolve.cdb") ; while (i--) check(&cr, db, toadd[i], 1, force, compiled) ; i = todeln ; while (i--) check(&cr, db, todel[i], 0, force, compiled) ; fdw = open_truncatb(fdcompiled, "resolve.cdb.new") ; if (fdw < 0) strerr_diefu3sys(111, "open ", compiled, "/resolve.cdb.new") ; if (cdb_make_start(&cw, fdw) < 0) { cleanup(compiled) ; strerr_diefu1sys(111, "cdb_make_start") ; } cdb_traverse_init(&cr, &kpos) ; for (;;) { int r = cdb_nextkey(&cr, &kpos) ; if (r < 0) { cleanup(compiled) ; strerr_diefu3sys(111, "cdb_nextkey in ", compiled, "/resolve.cdb") ; } if (!r) break ; { uint32_t klen = cdb_keylen(&cr) ; char ktmp[klen + 1] ; if (cdb_read(&cr, ktmp, klen, cdb_keypos(&cr)) < 0) { cleanup(compiled) ; strerr_diefu3sys(111, "cdb_read ", compiled, "/resolve.cdb") ; } for (i = 0 ; i < todeln ; i++) if (klen == strlen(todel[i]) && !strncmp(todel[i], ktmp, klen)) break ; if (i < todeln) continue ; for (i = 0 ; i < toaddn ; i++) if (klen == strlen(toadd[i]) && !strncmp(toadd[i], ktmp, klen)) break ; if (i < toaddn) continue ; { uint32_t dlen = cdb_datalen(&cr) ; char dtmp[dlen + 1] ; if (cdb_read(&cr, dtmp, dlen, cdb_datapos(&cr)) < 0) { cleanup(compiled) ; strerr_diefu3sys(111, "cdb_read ", compiled, "/resolve.cdb") ; } if (cdb_make_add(&cw, ktmp, klen, dtmp, dlen) < 0) { cleanup(compiled) ; strerr_diefu1sys(111, "cdb_make_add") ; } } } } i = toaddn ; while (i--) { char const *const *p = toadd_contents[i] ; unsigned int total = 0 ; memset(bits, 0, bitarray_div8(n)) ; for (; *p ; p++) { int r = cdb_find(&cr, *p, strlen(*p)) ; if (r < 0) strerr_diefu3sys(111, "cdb_find in ", compiled, "/resolve.cdb") ; if (!r) strerr_dief4x(3, "identifier ", *p, " does not exist in database ", compiled) ; { uint32_t j = cdb_datalen(&cr) ; char pack[j + 1] ; if (cdb_read(&cr, pack, j, cdb_datapos(&cr)) < 0) { cleanup(compiled) ; strerr_diefu3sys(111, "cdb_read ", compiled, "/resolve.cdb") ; } j >>= 2 ; while (j--) { uint32_t x ; uint32_unpack_big(pack + (j << 2), &x) ; if (x >= db->nshort + db->nlong) strerr_dief2x(4, "invalid database in ", compiled) ; if (!bitarray_testandset(bits, x)) total++ ; } } } { char pack[(total << 2) + 1] ; char *s = pack ; uint32_t j = n ; while (j--) if (bitarray_peek(bits, j)) { uint32_pack_big(s, j) ; s += 4 ; } if (cdb_make_add(&cw, toadd[i], strlen(toadd[i]), pack, total << 2) < 0) { cleanup(compiled) ; strerr_diefu1sys(111, "cdb_make_add") ; } } } cdb_free(&cr) ; close(fdr) ; if (cdb_make_finish(&cw) < 0 || fsync(fdw) < 0) { cleanup(compiled) ; strerr_diefu3sys(111, "write to ", compiled, "/resolve.cdb.new") ; } close(fdw) ; if (renameit(compiled, "resolve.cdb.new", "resolve.cdb") < 0) { cleanup(compiled) ; strerr_diefu2sys(111, "rename resolve.cdb.new to resolve.cdb in ", compiled) ; } } static inline void parse_multiple (int argc, char const **argv, unsigned int *todeln, unsigned int *toaddn, char const **toadd, char const *const **toadd_contents) { unsigned int m = 0 ; int argc1 = el_semicolon(argv) ; if (argc1 >= argc) strerr_dief1x(100, "unterminated block") ; *todeln = argc1 ; argv += argc1 + 1 ; argc -= argc1 + 1 ; while (argc) { toadd[m] = *argv++ ; if (!--argc) strerr_dief1x(100, "missing bundle contents block") ; argc1 = el_semicolon(argv) ; if (argc1 >= argc) strerr_dief1x(100, "unterminated block") ; argv[argc1] = 0 ; toadd_contents[m++] = argv ; argv += argc1 + 1 ; argc -= argc1 + 1 ; } *toaddn = m ; } static inline void print_help (void) { static char const *help = "s6-rc-bundle help\n" "s6-rc-bundle add bundlename contents...\n" "s6-rc-bundle delete bundlenames...\n" "s6-rc-bundle multiple { to-delete } to-add { contents... } ... (execlineb syntax)\n" ; if (buffer_putsflush(buffer_1, help) < 0) strerr_diefu1sys(111, "write to stdout") ; } static inline unsigned int lookup (char const *const *table, char const *command) { unsigned int i = 0 ; for (; table[i] ; i++) if (!strcmp(command, table[i])) break ; return i ; } static inline unsigned int parse_command (char const *command) { static char const *const command_table[5] = { "help", "add", "delete", "multiple", 0 } ; unsigned int i = lookup(command_table, command) ; if (!command_table[i]) dieusage() ; return i ; } int main (int argc, char const **argv) { char const *live = S6RC_LIVE_BASE ; char const *compiled = 0 ; unsigned int what ; int force = 0 ; int blocking = 0 ; PROG = "s6-rc-bundle" ; { subgetopt_t l = SUBGETOPT_ZERO ; for (;;) { int opt = subgetopt_r(argc, argv, "fl:c:b", &l) ; if (opt == -1) break ; switch (opt) { case 'f' : force = 1 ; break ; case 'l' : live = l.arg ; break ; case 'c' : compiled = l.arg ; break ; case 'b' : blocking = 1 ; break ; default : dieusage() ; } } argc -= l.ind ; argv += l.ind ; } if (!argc) dieusage() ; what = parse_command(*argv++) ; if (!what) { print_help() ; return 0 ; } if (!--argc) dieusage() ; if (what != 2 && argc < 2) dieusage() ; { size_t livelen = strlen(live) ; int fdcompiled = -1 ; int compiledlock ; s6rc_db_t dbblob ; char compiledblob[compiled ? strlen(compiled) : livelen + 10] ; if (!compiled) { memcpy(compiledblob, live, livelen) ; memcpy(compiledblob + livelen, "/compiled", 10) ; compiled = compiledblob ; } if (!s6rc_lock(0, 0, 0, compiled, 2, &compiledlock, blocking)) strerr_diefu2sys(111, "take lock on ", compiled) ; fdcompiled = open_readb(compiled) ; if (fdcompiled < 0) strerr_diefu2sys(111, "open ", compiled) ; /* Read the sizes of the compiled db */ fdcompiled = open_readb(compiled) ; if (!s6rc_db_read_sizes(fdcompiled, &dbblob)) strerr_diefu3sys(111, "read ", compiled, "/n") ; /* Allocate enough stack for the db */ { unsigned int n = dbblob.nshort + dbblob.nlong ; s6rc_service_t serviceblob[n] ; char const *argvblob[dbblob.nargvs] ; uint32_t depsblob[dbblob.ndeps << 1] ; uint32_t producersblob[dbblob.nproducers] ; char stringblob[dbblob.stringlen] ; int r ; dbblob.services = serviceblob ; dbblob.argvs = argvblob ; dbblob.deps = depsblob ; dbblob.producers = producersblob ; dbblob.string = stringblob ; /* Read the db from the file */ r = s6rc_db_read(fdcompiled, &dbblob) ; if (r < 0) strerr_diefu3sys(111, "read ", compiled, "/db") ; if (!r) strerr_dief3x(4, "invalid service database in ", compiled, "/db") ; /* Perform the action */ switch (what) { case 1 : /* add */ { char const *const *contents = argv + 1 ; modify_resolve(fdcompiled, &dbblob, 0, 0, argv, &contents, 1, force, compiled) ; break ; } case 2 : /* delete */ modify_resolve(fdcompiled, &dbblob, argv, argc, 0, 0, 0, force, compiled) ; break ; case 3 : /* multiple */ { unsigned int toaddn, todeln ; char const *toadd[argc - 1] ; char const *const *toadd_contents[argc - 1] ; parse_multiple(argc, argv, &todeln, &toaddn, toadd, toadd_contents) ; modify_resolve(fdcompiled, &dbblob, argv, todeln, toadd, toadd_contents, toaddn, force, compiled) ; break ; } } } } return 0 ; } s6-rc-0.5.1.1/src/s6-rc/s6-rc-oneshot-run.c0000644000000000000000000000555213207066205014602 0ustar /* ISC license. */ #include #include #include #include #include #include #include #include #include #include #define USAGE "s6-rc-oneshot-run [ -l live ] [ -b ] up|down servicenumber" #define dieusage() strerr_dieusage(100, USAGE) int main (int argc, char const *const *argv, char const *const *envp) { char const *live = S6RC_LIVE_BASE ; unsigned int number ; int up ; int blocking = 0 ; PROG = "s6-rc-oneshot-run" ; { subgetopt_t l = SUBGETOPT_ZERO ; for (;;) { int opt = subgetopt_r(argc, argv, "l:b", &l) ; if (opt == -1) break ; switch (opt) { case 'l' : live = l.arg ; break ; case 'b' : blocking = 1 ; break ; default : dieusage() ; } } argc -= l.ind ; argv += l.ind ; } if (argc < 2) dieusage() ; if (!strcasecmp(argv[0], "up")) up = 1 ; else if (!strcasecmp(argv[0], "down")) up = 0 ; else dieusage() ; if (!uint0_scan(argv[1], &number)) dieusage() ; { size_t livelen = strlen(live) ; int fdcompiled, compiledlock ; s6rc_db_t db ; char compiled[livelen + 10] ; memcpy(compiled, live, livelen) ; memcpy(compiled + livelen, "/compiled", 10) ; if (!s6rc_lock(0, 0, 0, compiled, 1, &compiledlock, blocking)) strerr_diefu2sys(111, "take lock on ", compiled) ; fdcompiled = open_readb(compiled) ; if (fdcompiled < 0) strerr_diefu2sys(111, "open ", compiled) ; /* Read the sizes of the compiled db */ if (!s6rc_db_read_sizes(fdcompiled, &db)) strerr_diefu3sys(111, "read ", compiled, "/n") ; if (number < db.nlong || number >= db.nlong + db.nshort) strerr_dief1x(3, "invalid service number") ; /* Allocate enough stack for the db */ { s6rc_service_t serviceblob[db.nshort + db.nlong] ; char const *argvblob[db.nargvs] ; uint32_t depsblob[db.ndeps << 1] ; uint32_t producersblob[db.nproducers] ; char stringblob[db.stringlen] ; int r ; db.services = serviceblob ; db.argvs = argvblob ; db.deps = depsblob ; db.producers = producersblob ; db.string = stringblob ; /* Read the db from the file */ r = s6rc_db_read(fdcompiled, &db) ; if (r < 0) strerr_diefu3sys(111, "read ", compiled, "/db") ; if (!r) strerr_dief3x(4, "invalid service database in ", compiled, "/db") ; close(fdcompiled) ; /* Run the script */ { unsigned int sargc = db.services[number].x.oneshot.argc[up] ; char const *const *sargv = db.argvs + db.services[number].x.oneshot.argv[up] ; char const *newargv[sargc + 1] ; char const **p = newargv ; while (sargc--) *p++ = *sargv++ ; *p = 0 ; xpathexec0_run(newargv, envp) ; } } } } s6-rc-0.5.1.1/src/s6-rc/s6-rc-db.c0000644000000000000000000003753113207066205012710 0ustar /* ISC license. */ #include #include #include #include #include #include #include #include #include #include #include #include #define USAGE "s6-rc-db [ -u | -d ] [ -l live ] [ -c compiled ] [ -b ] command... (use s6-rc-db help for more information)" #define dieusage() strerr_dieusage(100, USAGE) static char const *compiled = 0 ; static int fdcompiled = -1 ; static s6rc_db_t *db ; static void print_bundle_contents (char const *name) { cdb_t c = CDB_ZERO ; int fd = open_readatb(fdcompiled, "resolve.cdb") ; int r ; if (fd < 0) strerr_diefu3sys(111, "open ", compiled, "/resolve.cdb") ; if (!cdb_init_map(&c, fd, 1)) strerr_diefu3sys(111, "cdb_init ", compiled, "/resolve.cdb") ; r = cdb_find(&c, name, strlen(name)) ; if (r < 0) strerr_diefu3sys(111, "read ", compiled, "/resolve.cdb") ; if (!r) strerr_dief3x(3, name, " is not a valid identifier in ", compiled) ; if (cdb_datalen(&c) == 4) { uint32_t x ; char pack[4] ; if (cdb_read(&c, pack, 4, cdb_datapos(&c)) < 0) strerr_diefu3sys(111, "cdb_read ", compiled, "/resolve.cdb") ; uint32_unpack_big(pack, &x) ; if (x >= db->nshort + db->nlong) strerr_dief2x(4, "invalid database in ", compiled) ; if (!strcmp(name, db->string + db->services[x].name)) strerr_dief5x(5, "in database ", compiled, ": identifier ", name, " represents an atomic service") ; if (buffer_puts(buffer_1, db->string + db->services[x].name) < 0 || buffer_put(buffer_1, "\n", 1) < 0) strerr_diefu1sys(111, "write to stdout") ; } else { uint32_t len = cdb_datalen(&c) >> 2 ; char pack[cdb_datalen(&c) + 1] ; char const *p = pack ; if (cdb_datalen(&c) & 3) strerr_dief2x(4, "invalid database in ", compiled) ; if (cdb_read(&c, pack, cdb_datalen(&c), cdb_datapos(&c)) < 0) strerr_diefu3sys(111, "cdb_read ", compiled, "/resolve.cdb") ; while (len--) { uint32_t x ; uint32_unpack_big(p, &x) ; p += 4 ; if (x >= db->nshort + db->nlong) strerr_dief2x(4, "invalid database in ", compiled) ; if (buffer_puts(buffer_1, db->string + db->services[x].name) < 0 || buffer_put(buffer_1, "\n", 1) < 1) strerr_diefu1sys(111, "write to stdout") ; } } cdb_free(&c) ; close(fd) ; if (!buffer_flush(buffer_1)) strerr_diefu1sys(111, "write to stdout") ; } static void print_services (unsigned int from, unsigned int to) { for (; from < to ; from++) { if (buffer_puts(buffer_1, db->string + db->services[from].name) < 0 || buffer_put(buffer_1, "\n", 1) < 1) strerr_diefu1sys(111, "write to stdout") ; } if (!buffer_flush(buffer_1)) strerr_diefu1sys(111, "write to stdout") ; } static void print_all (int bundlesonly) { cdb_t c = CDB_ZERO ; uint32_t kpos ; int fd = open_readatb(fdcompiled, "resolve.cdb") ; if (fd < 0) strerr_diefu3sys(111, "open ", compiled, "/resolve.cdb") ; if (!cdb_init_map(&c, fd, 1)) strerr_diefu3sys(111, "cdb_init ", compiled, "/resolve.cdb") ; cdb_traverse_init(&c, &kpos) ; for (;;) { int r = cdb_nextkey(&c, &kpos) ; char name[cdb_keylen(&c) + 1] ; if (r < 0) strerr_diefu3sys(111, "read ", compiled, "/resolve.cdb") ; if (!r) break ; if (cdb_read(&c, name, cdb_keylen(&c), cdb_keypos(&c)) < 0) strerr_diefu3sys(111, "cdb_read ", compiled, "/resolve.cdb") ; if (bundlesonly && cdb_datalen(&c) == 4) { uint32_t x ; char pack[4] ; if (cdb_read(&c, pack, 4, cdb_datapos(&c)) < 0) strerr_diefu3sys(111, "cdb_read ", compiled, "/resolve.cdb") ; uint32_unpack_big(pack, &x) ; if (x >= db->nshort + db->nlong) strerr_dief2x(4, "invalid database in ", compiled) ; if (!memcmp(name, db->string + db->services[x].name, cdb_keylen(&c)) && !db->string[db->services[x].name + cdb_keylen(&c)]) continue ; } name[cdb_keylen(&c)] = '\n' ; if (buffer_put(buffer_1, name, cdb_keylen(&c) + 1) < 0) strerr_diefu1sys(111, "write to stdout") ; } cdb_free(&c) ; close(fd) ; if (!buffer_flush(buffer_1)) strerr_diefu1sys(111, "write to stdout") ; } static unsigned int resolve_service (char const *name) { cdb_t c = CDB_ZERO ; int fd = open_readatb(fdcompiled, "resolve.cdb") ; uint32_t x ; char pack[4] ; int r ; if (fd < 0) strerr_diefu3sys(111, "open ", compiled, "/resolve.cdb") ; if (!cdb_init_map(&c, fd, 1)) strerr_diefu3sys(111, "cdb_init ", compiled, "/resolve.cdb") ; r = cdb_find(&c, name, strlen(name)) ; if (r < 0) strerr_diefu3sys(111, "read ", compiled, "/resolve.cdb") ; if (!r) strerr_dief3x(3, name, " is not a valid identifier in ", compiled) ; if (cdb_datalen(&c) != 4) return db->nshort + db->nlong ; if (cdb_read(&c, pack, 4, cdb_datapos(&c)) < 0) strerr_diefu3sys(111, "cdb_read ", compiled, "/resolve.cdb") ; uint32_unpack_big(pack, &x) ; cdb_free(&c) ; close(fd) ; if (x >= db->nshort + db->nlong) strerr_dief2x(4, "invalid database in ", compiled) ; if (strcmp(name, db->string + db->services[x].name)) x = db->nshort + db->nlong ; return x ; } static void print_type (char const *name) { unsigned int n = resolve_service(name) ; char const *s = n >= db->nshort + db->nlong ? "bundle" : n < db->nlong ? "longrun" : "oneshot" ; if (buffer_puts(buffer_1, s) < 0 || buffer_putflush(buffer_1, "\n", 1) < 0) strerr_diefu1sys(111, "write to stdout") ; } static void print_timeout (char const *name, int h) { size_t len ; unsigned int n = resolve_service(name) ; char fmt[UINT32_FMT] ; if (n >= db->nshort + db->nlong) strerr_dief5x(5, "in database ", compiled, ": identifier ", name, " represents a bundle") ; len = uint32_fmt(fmt, db->services[n].timeout[h]) ; fmt[len++] = '\n' ; if (buffer_putflush(buffer_1, fmt, len) < 0) strerr_diefu1sys(111, "write to stdout") ; } static void print_script (char const *name, int h) { unsigned int argc ; char const *const *argv ; unsigned int n = resolve_service(name) ; if (n >= db->nshort + db->nlong) strerr_dief5x(5, "in database ", compiled, ": identifier ", name, " represents a bundle") ; if (n < db->nlong) strerr_dief5x(5, "in database ", compiled, ": identifier ", name, " represents a longrun service") ; argv = db->argvs + db->services[n].x.oneshot.argv[h] ; argc = db->services[n].x.oneshot.argc[h] ; while (argc--) if (buffer_puts(buffer_1, *argv++) < 0 || buffer_put(buffer_1, "\0", 1) < 1) strerr_diefu1sys(111, "write to stdout") ; if (!buffer_flush(buffer_1)) strerr_diefu1sys(111, "write to stdout") ; } static void print_producers_rec (uint32_t n) { uint32_t i = 0 ; for (; i < db->services[n].x.longrun.nproducers ; i++) { uint32_t m = db->producers[db->services[n].x.longrun.producers + i] ; print_producers_rec(m) ; if (buffer_puts(buffer_1, db->string + db->services[m].name) < 0 || buffer_put(buffer_1, " | ", 3) < 0 || buffer_puts(buffer_1, db->string + db->services[n].name) < 0 || buffer_put(buffer_1, "\n", 1) < 0) strerr_diefu1sys(111, "write to stdout") ; } } static inline void print_pipeline (char const *name) { unsigned int n = resolve_service(name) ; if (n >= db->nlong) strerr_dief5x(5, "in database ", compiled, ": identifier ", name, " does not represent a longrun") ; for (;;) { uint32_t j = db->services[n].x.longrun.consumer ; if (j >= db->nlong) break ; n = j ; } print_producers_rec(n) ; if (!buffer_flush(buffer_1)) strerr_diefu1sys(111, "write to stdout") ; } static inline void print_flags (char const *name) { unsigned int n = resolve_service(name) ; char fmt[9] = "00000000\n" ; if (n >= db->nshort + db->nlong) strerr_dief5x(5, "in database ", compiled, ": identifier ", name, " represents a bundle") ; uint320_xfmt(fmt, db->services[n].flags, 8) ; if (buffer_putflush(buffer_1, fmt, 9) < 0) strerr_diefu1sys(111, "write to stdout") ; } static void print_union (char const *const *argv, int h, int isdeps, int doclosure) { unsigned int n = db->nshort + db->nlong ; cdb_t c = CDB_ZERO ; int fd = open_readatb(fdcompiled, "resolve.cdb") ; unsigned char state[n] ; if (fd < 0) strerr_diefu3sys(111, "open ", compiled, "/resolve.cdb") ; if (!cdb_init_map(&c, fd, 1)) strerr_diefu3sys(111, "cdb_init ", compiled, "/resolve.cdb") ; memset(state, 0, n) ; for (; *argv ; argv++) { int r = cdb_find(&c, *argv, strlen(*argv)) ; if (r < 0) strerr_diefu3sys(111, "read ", compiled, "/resolve.cdb") ; if (!r) strerr_dief3x(3, *argv, " is not a valid identifier in ", compiled) ; { uint32_t len = cdb_datalen(&c) >> 2 ; char pack[cdb_datalen(&c) + 1] ; char const *p = pack ; if (cdb_read(&c, pack, cdb_datalen(&c), cdb_datapos(&c)) < 0) strerr_diefu3sys(111, "cdb_read ", compiled, "/resolve.cdb") ; while (len--) { uint32_t x ; uint32_unpack_big(p, &x) ; p += 4 ; if (x >= db->nshort + db->nlong) strerr_dief2x(4, "invalid database in ", compiled) ; if (isdeps) { uint32_t ndeps = db->services[x].ndeps[h] ; uint32_t const *deps = db->deps + h * db->ndeps + db->services[x].deps[h] ; while (ndeps--) state[*deps++] |= 1 ; } else state[x] |= 1 ; } } } cdb_free(&c) ; close(fd) ; if (doclosure) s6rc_graph_closure(db, state, 0, h) ; while (n--) if (state[n]) if (buffer_puts(buffer_1, db->string + db->services[n].name) < 0 || buffer_put(buffer_1, "\n", 1) < 0) strerr_diefu1sys(111, "write to stdout") ; if (!buffer_flush(buffer_1)) strerr_diefu1sys(111, "write to stdout") ; } static inline void print_help (void) { static char const *help = "s6-rc-db help\n" "s6-rc-db check\n" "s6-rc-db list all|services|oneshots|longruns|bundles\n" "s6-rc-db type servicename\n" "s6-rc-db [ -u | -d ] timeout atomicname\n" "s6-rc-db contents bundlename\n" "s6-rc-db [ -u | -d ] dependencies servicename...\n" "s6-rc-db pipeline longrunname\n" "s6-rc-db [ -u | -d ] script oneshotname\n" "s6-rc-db flags atomicname\n" "s6-rc-db atomics servicename...\n" "s6-rc-db [ -u | -d ] all-dependencies servicename...\n" ; if (buffer_putsflush(buffer_1, help) < 0) strerr_diefu1sys(111, "write to stdout") ; } static unsigned int lookup (char const *const *table, char const *command) { unsigned int i = 0 ; for (; table[i] ; i++) if (!strcmp(command, table[i])) break ; return i ; } static inline unsigned int parse_command (char const *command) { static char const *const command_table[13] = { "help", "check", "list", "type", "timeout", "contents", "dependencies", "pipeline", "script", "flags", "atomics", "all-dependencies", 0 } ; unsigned int i = lookup(command_table, command) ; if (!command_table[i]) dieusage() ; return i ; } static inline unsigned int parse_list (char const *command) { static char const *const list_table[6] = { "all", "services", "oneshots", "longruns", "bundles", 0 } ; unsigned int i = lookup(list_table, command) ; if (!list_table[i]) dieusage() ; return i ; } int main (int argc, char const *const *argv) { char const *live = S6RC_LIVE_BASE ; unsigned int what, subwhat = 0 ; int up = 1 ; int blocking = 0 ; PROG = "s6-rc-db" ; { subgetopt_t l = SUBGETOPT_ZERO ; for (;;) { int opt = subgetopt_r(argc, argv, "udl:c:b", &l) ; if (opt == -1) break ; switch (opt) { case 'l' : live = l.arg ; break ; case 'c' : compiled = l.arg ; break ; case 'u' : up = 1 ; break ; case 'd' : up = 0 ; break ; case 'b' : blocking = 1 ; break ; default : dieusage() ; } } argc -= l.ind ; argv += l.ind ; } if (!argc) dieusage() ; what = parse_command(argv[0]) ; if (!what) { print_help() ; return 0 ; } if (what >= 2 && argc < 2) dieusage() ; if (what == 2) subwhat = 1 + parse_list(argv[1]) ; { size_t livelen = strlen(live) ; int compiledlock ; s6rc_db_t dbblob ; char compiledblob[compiled ? strlen(compiled) : livelen + 10] ; db = &dbblob ; if (!compiled) { memcpy(compiledblob, live, livelen) ; memcpy(compiledblob + livelen, "/compiled", 10) ; compiled = compiledblob ; } if (!s6rc_lock(0, 0, 0, compiled, 1, &compiledlock, blocking)) strerr_diefu2sys(111, "take lock on ", compiled) ; fdcompiled = open_readb(compiled) ; if (fdcompiled < 0) strerr_diefu2sys(111, "open ", compiled) ; /* Read the sizes of the compiled db */ fdcompiled = open_readb(compiled) ; if (!s6rc_db_read_sizes(fdcompiled, &dbblob)) strerr_diefu3sys(111, "read ", compiled, "/n") ; /* Allocate enough stack for the db */ { unsigned int n = dbblob.nshort + dbblob.nlong ; s6rc_service_t serviceblob[n] ; char const *argvblob[dbblob.nargvs] ; uint32_t depsblob[dbblob.ndeps << 1] ; uint32_t producersblob[dbblob.nproducers] ; char stringblob[dbblob.stringlen] ; int r ; dbblob.services = serviceblob ; dbblob.argvs = argvblob ; dbblob.deps = depsblob ; dbblob.producers = producersblob ; dbblob.string = stringblob ; /* Read the db from the file */ r = s6rc_db_read(fdcompiled, &dbblob) ; if (r < 0) strerr_diefu3sys(111, "read ", compiled, "/db") ; if (!r) strerr_dief3x(4, "invalid service database in ", compiled, "/db") ; /* Perform the action */ switch (what) { case 1 : /* check */ { diuint32 problem ; if (s6rc_db_check_revdeps(&dbblob)) strerr_dief3x(4, "invalid service database in ", compiled, ": direct and reverse dependencies are mismatched") ; if (s6rc_db_check_depcycles(&dbblob, 1, &problem)) strerr_dief8x(4, "invalid service database in ", compiled, ": dependency ", "cycle", " reached from ", stringblob + serviceblob[problem.left].name, " and involving ", stringblob + serviceblob[problem.right].name) ; r = s6rc_db_check_pipelines(&dbblob, &problem) ; if (r) { if (r == 1) strerr_dief8x(4, "invalid service database in ", compiled, ": pipeline ", "cycle", " reached from ", stringblob + serviceblob[problem.left].name, " and involving ", stringblob + serviceblob[problem.right].name) ; else strerr_dief8x(4, "invalid service database in ", compiled, ": pipeline ", "collision", " reached from ", stringblob + serviceblob[problem.left].name, " and involving ", stringblob + serviceblob[problem.right].name) ; } break ; } case 2 : /* list */ switch (subwhat) { case 1 : print_all(0) ; break ; case 2 : print_services(0, n) ; break ; case 3 : print_services(dbblob.nlong, n) ; break ; case 4 : print_services(0, dbblob.nlong) ; break ; case 5 : print_all(1) ; break ; } break ; case 3 : /* type */ print_type(argv[1]) ; break ; case 4 : /* timeout */ print_timeout(argv[1], up) ; break ; case 5 : /* contents */ print_bundle_contents(argv[1]) ; break ; case 6 : /* dependencies */ print_union(argv + 1, up, 1, 0) ; break ; case 7 : /* pipeline */ print_pipeline(argv[1]) ; break ; case 8 : /* script */ print_script(argv[1], up) ; break ; case 9 : /* flags */ print_flags(argv[1]) ; break ; case 10 : /* atomics */ print_union(argv + 1, 1, 0, 0) ; break ; case 11 : /* all-dependencies */ print_union(argv + 1, up, 0, 1) ; break ; } } } return 0 ; } s6-rc-0.5.1.1/src/s6-rc/s6-rc-init.c0000644000000000000000000000706313534435223013266 0ustar /* ISC license. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #define USAGE "s6-rc-init [ -c compiled ] [ -l live ] [ -p prefix ] [ -t timeout ] [ -d ] scandir" #define dieusage() strerr_dieusage(100, USAGE) static void cleanup (stralloc *sa) { int e = errno ; rm_rf_in_tmp(sa, 0) ; errno = e ; } int main (int argc, char const *const *argv) { tain_t deadline ; stralloc sa = STRALLOC_ZERO ; size_t dirlen ; char const *live = S6RC_LIVE_BASE ; char const *compiled = S6RC_COMPILED_BASE ; char const *prefix = "" ; int deref = 0 ; PROG = "s6-rc-init" ; { unsigned int t = 0 ; subgetopt_t l = SUBGETOPT_ZERO ; for (;;) { int opt = subgetopt_r(argc, argv, "c:l:p:t:bd", &l) ; if (opt == -1) break ; switch (opt) { case 'c' : compiled = l.arg ; break ; case 'l' : live = l.arg ; break ; case 'p' : prefix = l.arg ; break ; case 't' : if (!uint0_scan(l.arg, &t)) dieusage() ; break ; case 'b' : break ; case 'd' : deref = 1 ; break ; default : dieusage() ; } } argc -= l.ind ; argv += l.ind ; if (t) tain_from_millisecs(&deadline, t) ; else deadline = tain_infinite_relative ; } if (!argc) dieusage() ; if (!deref && compiled[0] != '/') strerr_dief2x(100, compiled, " is not an absolute path") ; if (live[0] != '/') strerr_dief2x(100, live, " is not an absolute path") ; if (argv[0][0] != '/') strerr_dief2x(100, argv[0], " is not an absolute path") ; if (strchr(prefix, '/') || strchr(prefix, '\n')) strerr_dief1x(100, "prefix cannot contain a / or a newline") ; tain_now_set_stopwatch_g() ; tain_add_g(&deadline, &deadline) ; if (deref) { char *x = realpath(compiled, 0) ; if (!x) strerr_diefu2sys(111, "realpath ", compiled) ; compiled = x ; } { s6rc_db_t db ; int r ; int fdcompiled = open_readb(compiled) ; if (fdcompiled < 0) strerr_diefu2sys(111, "open ", compiled) ; r = s6rc_db_read_sizes(fdcompiled, &db) ; if (r < 0) strerr_diefu2sys(111, "read database size in ", compiled) ; else if (!r) strerr_dief2x(4, "invalid database size in ", compiled) ; close(fdcompiled) ; { unsigned char state[db.nshort + db.nlong] ; memset(state, 0, db.nshort + db.nlong) ; if (!s6rc_livedir_create(&sa, live, PROG, argv[0], prefix, compiled, state, db.nshort + db.nlong, &dirlen)) strerr_diefu1sys(111, "create live directory") ; } } { size_t clen = strlen(compiled) ; char lfn[sa.len + 13] ; char cfn[clen + 13] ; memcpy(lfn, sa.s, sa.len) ; memcpy(lfn + sa.len, "/servicedirs", 13) ; memcpy(cfn, compiled, clen) ; memcpy(cfn + clen, "/servicedirs", 13) ; sa.len++ ; if (!hiercopy(cfn, lfn)) { cleanup(&sa) ; strerr_diefu4sys(111, "recursively copy ", cfn, " to ", lfn) ; } } if (!atomic_symlink(sa.s + dirlen, live, PROG)) { cleanup(&sa) ; strerr_diefu4sys(111, "symlink ", sa.s + dirlen, " to ", live) ; } deref = s6rc_servicedir_manage_g(live, prefix, &deadline) ; if (!deref) { cleanup(&sa) ; strerr_diefu3sys(111, "supervise service directories in ", live, "/servicedirs") ; } if (deref & 2) strerr_warnw2x("s6-svscan not running on ", argv[0]) ; return 0 ; } s6-rc-0.5.1.1/src/s6-rc/deps-lib/0000755000000000000000000000000012472376167012733 5ustar s6-rc-0.5.1.1/src/include/0000755000000000000000000000000012472710204011705 5ustar s6-rc-0.5.1.1/src/include/s6-rc/0000755000000000000000000000000013541514470012644 5ustar s6-rc-0.5.1.1/src/include/s6-rc/s6rc-servicedir.h0000644000000000000000000000141413166440614016030 0ustar /* ISC license. */ #ifndef S6RC_SERVICEDIR_H #define S6RC_SERVICEDIR_H #include extern int s6rc_servicedir_block (char const *) ; extern int s6rc_servicedir_unblock (char const *, int) ; extern int s6rc_servicedir_copy_offline (char const *, char const *) ; extern int s6rc_servicedir_copy_online (char const *, char const *) ; #define s6rc_servicedir_copy(src, dst, h) ((h) ? s6rc_servicedir_copy_online(src, dst) : s6rc_servicedir_copy_offline(src, dst)) extern void s6rc_servicedir_unsupervise (char const *, char const *, char const *, int) ; extern int s6rc_servicedir_manage (char const *, char const *, tain_t const *, tain_t *) ; #define s6rc_servicedir_manage_g(live, suffix, deadline) s6rc_servicedir_manage(live, suffix, (deadline), &STAMP) #endif s6-rc-0.5.1.1/src/include/s6-rc/s6rc-utils.h0000644000000000000000000000134713211237024015024 0ustar /* ISC license. */ #ifndef S6RC_UTILS_H #define S6RC_UTILS_H #include #include #include extern void s6rc_graph_closure (s6rc_db_t const *, unsigned char *, unsigned int, int) ; extern int s6rc_lock (char const *, int, int *, char const *, int, int *, int) ; extern int s6rc_read_uint (char const *, unsigned int *) ; extern int s6rc_sanitize_dir (stralloc *, char const *, size_t *) ; extern int s6rc_livedir_prefixsize (char const *, size_t *) ; extern ssize_t s6rc_livedir_prefix (char const *, char *, size_t) ; extern int s6rc_livedir_create (stralloc *, char const *, char const *, char const *, char const *, char const *, unsigned char const *, unsigned int, size_t *) ; #endif s6-rc-0.5.1.1/src/include/s6-rc/s6rc-db.h0000644000000000000000000000331713207066205014256 0ustar /* ISC license. */ #ifndef S6RC_DB_H #define S6RC_DB_H #include #include #include #define S6RC_DB_BANNER_START "s6rc-db: start\n" #define S6RC_DB_BANNER_START_LEN (sizeof(S6RC_DB_BANNER_START) - 1) #define S6RC_DB_BANNER_END "\ns6rc-db: end\n" #define S6RC_DB_BANNER_END_LEN (sizeof(S6RC_DB_BANNER_END) - 1) typedef struct s6rc_oneshot_s s6rc_oneshot_t, *s6rc_oneshot_t_ref ; struct s6rc_oneshot_s { uint32_t argc[2] ; uint32_t argv[2] ; } ; typedef struct s6rc_longrun_s s6rc_longrun_t, *s6rc_longrun_t_ref ; struct s6rc_longrun_s { uint32_t consumer ; uint32_t nproducers ; uint32_t producers ; } ; typedef union s6rc_longshot_u s6rc_longshot_t, *s6rc_longshot_t_ref ; union s6rc_longshot_u { s6rc_oneshot_t oneshot ; s6rc_longrun_t longrun ; } ; typedef struct s6rc_service_s s6rc_service_t, *s6rc_service_t_ref ; struct s6rc_service_s { uint32_t name ; uint32_t flags ; uint32_t deps[2] ; uint32_t ndeps[2] ; uint32_t timeout[2] ; s6rc_longshot_t x ; } ; typedef struct s6rc_db_s s6rc_db_t, *s6rc_db_t_ref ; struct s6rc_db_s { s6rc_service_t *services ; unsigned int nshort ; unsigned int nlong ; unsigned int stringlen ; unsigned int nargvs ; unsigned int ndeps ; unsigned int nproducers ; char *string ; char const **argvs ; uint32_t *deps ; uint32_t *producers ; } ; extern int s6rc_db_read_uint32 (buffer *, uint32_t *) ; extern int s6rc_db_read_sizes (int, s6rc_db_t *) ; extern int s6rc_db_read (int, s6rc_db_t *) ; extern int s6rc_db_check_pipelines (s6rc_db_t const *, diuint32 *) ; extern int s6rc_db_check_depcycles (s6rc_db_t const *, int, diuint32 *) ; extern int s6rc_db_check_revdeps (s6rc_db_t const *) ; #endif s6-rc-0.5.1.1/src/include/s6-rc/s6rc-constants.h0000644000000000000000000000052012570553433015704 0ustar /* ISC license. */ #ifndef S6RC_CONSTANTS_H #define S6RC_CONSTANTS_H #define S6RC_COMPILED_BASE "/etc/s6-rc/compiled" #define S6RC_ONESHOT_RUNNER "s6rc-oneshot-runner" #define S6RC_ONESHOT_RUNNER_LEN (sizeof S6RC_ONESHOT_RUNNER - 1) #define S6RC_FDHOLDER "s6rc-fdholder" #define S6RC_FDHOLDER_LEN (sizeof S6RC_FDHOLDER - 1) #endif s6-rc-0.5.1.1/src/include/s6-rc/s6rc.h0000644000000000000000000000027112645223546013677 0ustar /* ISC license. */ #ifndef S6RC_H #define S6RC_H #include #include #include #include #endif s6-rc-0.5.1.1/package/0002755000000000000000000000000013207066205011072 5ustar s6-rc-0.5.1.1/package/deps.mak0000644000000000000000000001730013553364332012524 0ustar # # This file has been generated by tools/gen-deps.sh # src/include/s6-rc/s6rc-utils.h: src/include/s6-rc/s6rc-db.h src/include/s6-rc/s6rc.h: src/include/s6-rc/s6rc-constants.h src/include/s6-rc/s6rc-db.h src/include/s6-rc/s6rc-servicedir.h src/include/s6-rc/s6rc-utils.h src/libs6rc/s6rc_db_check_depcycles.o src/libs6rc/s6rc_db_check_depcycles.lo: src/libs6rc/s6rc_db_check_depcycles.c src/include/s6-rc/s6rc-db.h src/libs6rc/s6rc_db_check_pipelines.o src/libs6rc/s6rc_db_check_pipelines.lo: src/libs6rc/s6rc_db_check_pipelines.c src/include/s6-rc/s6rc-db.h src/libs6rc/s6rc_db_check_revdeps.o src/libs6rc/s6rc_db_check_revdeps.lo: src/libs6rc/s6rc_db_check_revdeps.c src/include/s6-rc/s6rc-db.h src/libs6rc/s6rc_db_read.o src/libs6rc/s6rc_db_read.lo: src/libs6rc/s6rc_db_read.c src/include/s6-rc/s6rc-db.h src/libs6rc/s6rc_db_read_sizes.o src/libs6rc/s6rc_db_read_sizes.lo: src/libs6rc/s6rc_db_read_sizes.c src/include/s6-rc/s6rc-db.h src/libs6rc/s6rc_db_read_uint32.o src/libs6rc/s6rc_db_read_uint32.lo: src/libs6rc/s6rc_db_read_uint32.c src/include/s6-rc/s6rc-db.h src/libs6rc/s6rc_graph_closure.o src/libs6rc/s6rc_graph_closure.lo: src/libs6rc/s6rc_graph_closure.c src/include/s6-rc/s6rc-db.h src/include/s6-rc/s6rc-utils.h src/libs6rc/s6rc_livedir_create.o src/libs6rc/s6rc_livedir_create.lo: src/libs6rc/s6rc_livedir_create.c src/include/s6-rc/s6rc-utils.h src/libs6rc/s6rc_livedir_prefix.o src/libs6rc/s6rc_livedir_prefix.lo: src/libs6rc/s6rc_livedir_prefix.c src/include/s6-rc/s6rc-utils.h src/libs6rc/s6rc_livedir_prefixsize.o src/libs6rc/s6rc_livedir_prefixsize.lo: src/libs6rc/s6rc_livedir_prefixsize.c src/include/s6-rc/s6rc-utils.h src/libs6rc/s6rc_lock.o src/libs6rc/s6rc_lock.lo: src/libs6rc/s6rc_lock.c src/include/s6-rc/s6rc-utils.h src/libs6rc/s6rc_read_uint.o src/libs6rc/s6rc_read_uint.lo: src/libs6rc/s6rc_read_uint.c src/include/s6-rc/s6rc-utils.h src/libs6rc/s6rc_sanitize_dir.o src/libs6rc/s6rc_sanitize_dir.lo: src/libs6rc/s6rc_sanitize_dir.c src/include/s6-rc/s6rc-utils.h src/libs6rc/s6rc_servicedir_block.o src/libs6rc/s6rc_servicedir_block.lo: src/libs6rc/s6rc_servicedir_block.c src/include/s6-rc/s6rc-servicedir.h src/libs6rc/s6rc_servicedir_copy_offline.o src/libs6rc/s6rc_servicedir_copy_offline.lo: src/libs6rc/s6rc_servicedir_copy_offline.c src/include/s6-rc/s6rc-servicedir.h src/libs6rc/s6rc-servicedir-internal.h src/libs6rc/s6rc_servicedir_copy_online.o src/libs6rc/s6rc_servicedir_copy_online.lo: src/libs6rc/s6rc_servicedir_copy_online.c src/include/s6-rc/s6rc-servicedir.h src/include/s6-rc/s6rc-utils.h src/libs6rc/s6rc-servicedir-internal.h src/libs6rc/s6rc_servicedir_internal.o src/libs6rc/s6rc_servicedir_internal.lo: src/libs6rc/s6rc_servicedir_internal.c src/include/s6-rc/s6rc-utils.h src/libs6rc/s6rc-servicedir-internal.h src/libs6rc/s6rc_servicedir_manage.o src/libs6rc/s6rc_servicedir_manage.lo: src/libs6rc/s6rc_servicedir_manage.c src/include/s6-rc/s6rc-servicedir.h src/libs6rc/s6rc_servicedir_unblock.o src/libs6rc/s6rc_servicedir_unblock.lo: src/libs6rc/s6rc_servicedir_unblock.c src/include/s6-rc/s6rc-servicedir.h src/libs6rc/s6rc_servicedir_unsupervise.o src/libs6rc/s6rc_servicedir_unsupervise.lo: src/libs6rc/s6rc_servicedir_unsupervise.c src/include/s6-rc/s6rc-servicedir.h src/s6-rc/s6-rc-bundle.o src/s6-rc/s6-rc-bundle.lo: src/s6-rc/s6-rc-bundle.c src/include/s6-rc/config.h src/include/s6-rc/s6rc.h src/s6-rc/s6-rc-compile.o src/s6-rc/s6-rc-compile.lo: src/s6-rc/s6-rc-compile.c src/include/s6-rc/config.h src/include/s6-rc/s6rc.h src/s6-rc/s6-rc-db.o src/s6-rc/s6-rc-db.lo: src/s6-rc/s6-rc-db.c src/include/s6-rc/config.h src/include/s6-rc/s6rc.h src/s6-rc/s6-rc-dryrun.o src/s6-rc/s6-rc-dryrun.lo: src/s6-rc/s6-rc-dryrun.c src/s6-rc/s6-rc-fdholder-filler.o src/s6-rc/s6-rc-fdholder-filler.lo: src/s6-rc/s6-rc-fdholder-filler.c src/s6-rc/s6-rc-format-upgrade.o src/s6-rc/s6-rc-format-upgrade.lo: src/s6-rc/s6-rc-format-upgrade.c src/include/s6-rc/config.h src/include/s6-rc/s6rc.h src/s6-rc/s6-rc-init.o src/s6-rc/s6-rc-init.lo: src/s6-rc/s6-rc-init.c src/include/s6-rc/config.h src/include/s6-rc/s6rc.h src/s6-rc/s6-rc-oneshot-run.o src/s6-rc/s6-rc-oneshot-run.lo: src/s6-rc/s6-rc-oneshot-run.c src/include/s6-rc/config.h src/include/s6-rc/s6rc.h src/s6-rc/s6-rc-update.o src/s6-rc/s6-rc-update.lo: src/s6-rc/s6-rc-update.c src/include/s6-rc/config.h src/include/s6-rc/s6rc.h src/s6-rc/s6-rc.o src/s6-rc/s6-rc.lo: src/s6-rc/s6-rc.c src/include/s6-rc/config.h src/include/s6-rc/s6rc.h ifeq ($(strip $(STATIC_LIBS_ARE_PIC)),) libs6rc.a.xyzzy: src/libs6rc/s6rc_db_check_depcycles.o src/libs6rc/s6rc_db_check_pipelines.o src/libs6rc/s6rc_db_check_revdeps.o src/libs6rc/s6rc_db_read.o src/libs6rc/s6rc_db_read_sizes.o src/libs6rc/s6rc_db_read_uint32.o src/libs6rc/s6rc_graph_closure.o src/libs6rc/s6rc_livedir_create.o src/libs6rc/s6rc_livedir_prefix.o src/libs6rc/s6rc_livedir_prefixsize.o src/libs6rc/s6rc_lock.o src/libs6rc/s6rc_read_uint.o src/libs6rc/s6rc_sanitize_dir.o src/libs6rc/s6rc_servicedir_internal.o src/libs6rc/s6rc_servicedir_block.o src/libs6rc/s6rc_servicedir_unblock.o src/libs6rc/s6rc_servicedir_copy_offline.o src/libs6rc/s6rc_servicedir_copy_online.o src/libs6rc/s6rc_servicedir_manage.o src/libs6rc/s6rc_servicedir_unsupervise.o else libs6rc.a.xyzzy: src/libs6rc/s6rc_db_check_depcycles.lo src/libs6rc/s6rc_db_check_pipelines.lo src/libs6rc/s6rc_db_check_revdeps.lo src/libs6rc/s6rc_db_read.lo src/libs6rc/s6rc_db_read_sizes.lo src/libs6rc/s6rc_db_read_uint32.lo src/libs6rc/s6rc_graph_closure.lo src/libs6rc/s6rc_livedir_create.lo src/libs6rc/s6rc_livedir_prefix.lo src/libs6rc/s6rc_livedir_prefixsize.lo src/libs6rc/s6rc_lock.lo src/libs6rc/s6rc_read_uint.lo src/libs6rc/s6rc_sanitize_dir.lo src/libs6rc/s6rc_servicedir_internal.lo src/libs6rc/s6rc_servicedir_block.lo src/libs6rc/s6rc_servicedir_unblock.lo src/libs6rc/s6rc_servicedir_copy_offline.lo src/libs6rc/s6rc_servicedir_copy_online.lo src/libs6rc/s6rc_servicedir_manage.lo src/libs6rc/s6rc_servicedir_unsupervise.lo endif libs6rc.so.xyzzy: EXTRA_LIBS := -ls6 -lskarnet libs6rc.so.xyzzy: src/libs6rc/s6rc_db_check_depcycles.lo src/libs6rc/s6rc_db_check_pipelines.lo src/libs6rc/s6rc_db_check_revdeps.lo src/libs6rc/s6rc_db_read.lo src/libs6rc/s6rc_db_read_sizes.lo src/libs6rc/s6rc_db_read_uint32.lo src/libs6rc/s6rc_graph_closure.lo src/libs6rc/s6rc_livedir_create.lo src/libs6rc/s6rc_livedir_prefix.lo src/libs6rc/s6rc_livedir_prefixsize.lo src/libs6rc/s6rc_lock.lo src/libs6rc/s6rc_read_uint.lo src/libs6rc/s6rc_sanitize_dir.lo src/libs6rc/s6rc_servicedir_internal.lo src/libs6rc/s6rc_servicedir_block.lo src/libs6rc/s6rc_servicedir_unblock.lo src/libs6rc/s6rc_servicedir_copy_offline.lo src/libs6rc/s6rc_servicedir_copy_online.lo src/libs6rc/s6rc_servicedir_manage.lo src/libs6rc/s6rc_servicedir_unsupervise.lo s6-rc: EXTRA_LIBS := -ls6 -lskarnet ${SYSCLOCK_LIB} ${SPAWN_LIB} s6-rc: src/s6-rc/s6-rc.o ${LIBS6RC} s6-rc-bundle: EXTRA_LIBS := -lexecline -lskarnet s6-rc-bundle: src/s6-rc/s6-rc-bundle.o ${LIBS6RC} s6-rc-compile: EXTRA_LIBS := -lexecline -lskarnet s6-rc-compile: src/s6-rc/s6-rc-compile.o ${LIBS6RC} s6-rc-db: EXTRA_LIBS := -lskarnet s6-rc-db: src/s6-rc/s6-rc-db.o ${LIBS6RC} s6-rc-dryrun: EXTRA_LIBS := -lskarnet ${SYSCLOCK_LIB} s6-rc-dryrun: src/s6-rc/s6-rc-dryrun.o s6-rc-fdholder-filler: EXTRA_LIBS := -ls6 -lskarnet ${SYSCLOCK_LIB} ${SOCKET_LIB} s6-rc-fdholder-filler: src/s6-rc/s6-rc-fdholder-filler.o s6-rc-format-upgrade: EXTRA_LIBS := -lskarnet s6-rc-format-upgrade: src/s6-rc/s6-rc-format-upgrade.o ${LIBS6RC} s6-rc-init: EXTRA_LIBS := -ls6 -lskarnet ${SYSCLOCK_LIB} ${SOCKET_LIB} ${SPAWN_LIB} s6-rc-init: src/s6-rc/s6-rc-init.o ${LIBS6RC} s6-rc-oneshot-run: EXTRA_LIBS := -lskarnet s6-rc-oneshot-run: src/s6-rc/s6-rc-oneshot-run.o ${LIBS6RC} s6-rc-update: EXTRA_LIBS := -ls6 -lexecline -lskarnet ${SYSCLOCK_LIB} ${SOCKET_LIB} ${SPAWN_LIB} s6-rc-update: src/s6-rc/s6-rc-update.o ${LIBS6RC} s6-rc-0.5.1.1/package/deps-build0000644000000000000000000000010012471613217013035 0ustar /package/prog/skalibs /package/admin/execline /package/admin/s6 s6-rc-0.5.1.1/package/targets.mak0000644000000000000000000000033213211301773013226 0ustar BIN_TARGETS := \ s6-rc-compile \ s6-rc-dryrun \ s6-rc-db \ s6-rc-bundle \ s6-rc-init \ s6-rc \ s6-rc-update \ s6-rc-format-upgrade LIBEXEC_TARGETS := \ s6-rc-fdholder-filler \ s6-rc-oneshot-run LIB_DEFS := S6RC=s6rc s6-rc-0.5.1.1/package/modes0000644000000000000000000000030613212254016012114 0ustar s6-rc-compile 0755 s6-rc-db 0755 s6-rc-dryrun 0755 s6-rc-bundle 0755 s6-rc-init 0755 s6-rc 0755 s6-rc-update 0755 s6-rc-fdholder-filler 0755 s6-rc-oneshot-run 0755 s6-rc-format-upgrade 0755 s6-rc-0.5.1.1/package/info0000644000000000000000000000010513553357770011760 0ustar package=s6-rc version=0.5.1.1 category=admin package_macro_name=S6RC s6-rc-0.5.1.1/COPYING0000644000000000000000000000137013415121604010525 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-rc-0.5.1.1/configure0000755000000000000000000003330613553343655011424 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 } 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 } # 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' livedir=/run/s6-rc sysdeps='$prefix/lib/skalibs/sysdeps' manualsysdeps=false shared=false static=true allpic=true slashpackage=false abspath=false sproot= home= exthome= allstatic=true evenmorestatic=false addincpath='' addlibspath='' addlibdpath='' vpaths='' vpathd='' build= 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#*=} ;; --livedir=*) livedir=${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-*|--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 livedir ; 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 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 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 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 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 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-rc-0.5.1.1/tools/0002755000000000000000000000000013553363665010655 5ustar s6-rc-0.5.1.1/tools/install.sh0000755000000000000000000000167512365207173012660 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-rc-0.5.1.1/tools/gen-deps.sh0000755000000000000000000000474313553363665012724 0ustar #!/bin/sh -e . package/info echo '#' echo '# This file has been generated by tools/gen-deps.sh' echo '#' echo 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 echo "lib${file}.so.xyzzy: EXTRA_LIBS :=$libs" echo "lib${file}.so.xyzzy:$(echo "$deps" | sed 's/\.o/.lo/g')" 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 s6-rc-0.5.1.1/NEWS0000644000000000000000000000646113553360005010202 0ustar Changelog for s6-rc. In 0.5.1.1 ---------- - Bugfixes. In 0.5.1.0 ---------- - Adaptation to skalibs-2.9.0.0 and s6-2.9.0.0. In 0.5.0.0 ---------- - Adaptation to skalibs-2.8.0.0 and s6-2.8.0.0. - Bugfixes. - s6-rc-compile doesn't support -u and -g anymore; the user who can run s6-rc on a database is the user who owns the supervision tree. - Everything builds as PIC by default. In 0.4.1.0 ---------- - Adaptation to skalibs-2.7.0.0 and s6-2.7.2.0. - Support for max-death-tally and down-signal files in a longrun definition directory. In 0.4.0.1 ---------- - Improved portability to (guess what) OpenBSD In 0.4.0.0 ---------- - s6-rc-compile now accepts several producers in a consumer-for file. All the producers for a service will write to the same pipe. In other words: pipelines are now funnels. - The pipeline-name file, defining the name of a bundle containing all the services in a pipeline, must now be place in the definition directory of the last consumer in the pipeline, instead of the definition directory of the first producer (since the latter is not unique anymore). - All service databases must be edited and recompiled. - New tool: s6-rc-format-upgrade, to handle the upgrade to the new compiled format. In 0.3.0.0 ---------- - s6-rc-init now takes a -p option that adds a prefix to the symbolic links created in the scandir to manage longruns. This allows the user to use the same scandir for several s6-rc databases and live directories without risking conflicts, if the prefixes are unique enough. - s6-rc-update does not use random number generation anymore, so it does not block at boot time. - Bugfixes. Despite this being a major version release, the compiled service databases did not change formats; you do not need to recompile your service databases. In 0.2.1.2 ---------- - Bugfix release. - s6-rc's verbosity has been adjusted. (-v2 is less verbose, -v3 is what the previous -v2 was, -v4 is still extremely verbose.) In 0.2.1.1 ---------- - Bugfix release. In 0.2.1.0 ---------- - Timeouts for oneshots have been increased to 30 seconds. - s6-rc now sends an explicit "s6-svc -d" to a longrun when an up transition fails. - s6-rc now kills subprocesses waiting on longrun transitions when it receives a SIGINT or a SIGTERM. + Those two changes combined ensure that a user can interrupt a transition that is blocked in a "service is not-ready" limbo, and bring back the service to a known "down" state. In 0.2.0.1 ---------- - Bugfix release. - Support for timeout-kill (in s6-2.5.1.0). In 0.2.0.0 ---------- - Added this NEWS file. :) - Major types overhaul to make them more POSIXly correct: compatibility with skalibs-2.5.0.0. - s6-2.5.0.0 now allows longruns to report permanent failures (when ./finish exits 125). s6-rc should pick that up automatically and fail a longrun transition when it's the case. - s6-rc commands taking a lock on the live directory or the service database now fail instantly if they're already locked. A -b option has been added to give them the "block and wait for the lock to be released" behaviour back. - Easier external interaction with the hidden s6rc-fdholder service: the list of pipes to autofill a new fdholder with is now taken from the data/autofilled file (previously: was a hardcoded command line in the s6rc-fdholder run script). s6-rc-0.5.1.1/Makefile0000644000000000000000000001125513515356574011156 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) install-data: $(ALL_DATA:src/etc/%=$(DESTDIR)$(datadir)/%) 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-rc: the s6-rc-bundle program

s6-rc
Software
skarnet.org

The s6-rc-bundle program

s6-rc-bundle is a tool to add or delete bundles from a compiled service database without having to recompile it from source.

It is an offline tool, i.e. you can run it on any compiled service database without actually having a live set of services managed by s6-rc. However, if you do have a live set, you can still run s6-rc-bundle on the current database (and it is the default); it won't interfere with your normal service operation.

Interface 

     s6-rc-bundle help
     s6-rc-bundle [ -f ] [ -l live ] [ -c compiled ] [ -b ] add bundlename contents...
     s6-rc-bundle [ -f ] [ -l live ] [ -c compiled ] [ -b ] delete bundlenames...
     s6-rc-bundle [ -f ] [ -l live ] [ -c compiled ] [ -b ] multiple args...
  • s6-rc-bundle expects to find a compiled service database in compiled; by default it uses the service database used by the live state in live.
  • Depending on the arguments, it adds a bundle definition to this database, or deletes a bundle definition from it, or performs multiple additions/deletions.

Options

  • -c compiled : operate on a compiled service database in compiled instead of the current live one.
  • -l live : assume the live state is in live. This option is ignored if the -c option has been given. Default is /run/s6-rc. The default can be changed at package compilation time, by giving the --livedir=live option to ./configure.
  • -f : force. s6-rc-bundle will not complain when given a nonexisting name to delete (it will do nothing), or when given an existing name to add (it will replace the definition). By default, s6-rc-bundle will complain and exit when asked to delete a nonexistent name or to add an existing name.
  • -b : blocking lock. If the database is currently being used by another program, s6-rc-bundle will wait until that other program has released its lock on the database, then proceed. By default, s6-rc-bundle fails with an error message if the database is currently in use.

Exit codes

  • 0: success
  • 1: identifier already exists in service database
  • 3: identifier not found in service database
  • 4: invalid or corrupted service database
  • 5: wrong identifier type for the given command
  • 100: wrong usage
  • 111: system call failed

Subcommands

s6-rc-bundle help

Prints a help message on stdout.

s6-rc-bundle add bundlename contents...

Adds a bundle named bundlename to the database, representing the services listed in contents. The arguments in contents... are resolved before the database is modified by the s6-rc-bundle invocation.

s6-rc-bundle delete bundlenames...

Deletes bundles listed in bundlenames....

s6-rc-bundle multiple args...

Performs multiple bundle deletions and additions. This subcommand is best used in an execline script, because it uses blocks.

args... is composed of:

  • One block listing bundle names that will be deleted from the database.
  • Zero or more addition definitions, each of them composed of:
    • One argument that is the name of the bundle to add
    • One block listing the services contained in the new bundle. The names in the block are resolved before any addition or deletion is made to the database.
s6-rc-0.5.1.1/doc/s6-rc.html0000644000000000000000000003766713426110722012102 0ustar s6-rc: the s6-rc program

s6-rc
Software
skarnet.org

The s6-rc program

s6-rc is a service manager, a.k.a machine state manager: a program to manage the live state of a machine - what services are currently up and what services are currently down. It can list active services, or change the live state.

s6-rc is meant to be the one-stop shop of service management: once service definitions have been made into a compiled service database via s6-rc-compile, and the machine state has been initialized via s6-rc-init, any state change - be it initial startup, shutdown, or anything else - should be achieved by a single s6-rc change invocation.

s6-rc should only be run by the user owning the underlying s6 supervision tree. It can also be run by root even if the supervision tree is not owned by root, but in this case the services will always be started and stopped by the user owning the supervision tree - they will not have root privileges.

Interface 

     s6-rc help
     s6-rc [ -l live ] [ -b ] [ -a ] [ -u | -d ] list servicenames...
     s6-rc [ -l live ] [ -b ] [ -a ] [ -u | -d ] listall servicenames...
     s6-rc [ -l live ] [ -b ] diff
     s6-rc [ -l live ] [ -b ] [ -a ] [ -u | -d ] [ -p ] [ -v verbosity ] [ -n dryrunthrottle ] [ -t timeout ] change [ servicenames... ]
  • s6-rc expects to find a functional live state in live. The live state is normally created at boot time by s6-rc-init. If the live state is invalid, s6-rc complains and exits 4.
  • Depending on the arguments given, it prints the requested information to stdout, then exits 0; or it performs a machine state change.

Exit codes

  • 0: success
  • 1: some of the state transitions could not be performed by s6-rc change; or a mismatch was found by s6-rc diff
  • 2: timed out during state change
  • 3: unknown service name in the arguments
  • 4: invalid service database
  • 100: wrong usage
  • 111: system call failed

Service selection

The arguments servicenames... may be atomic services or bundles; they are resolved into a set of atomic services, which is called the selection. If the -a option is present, the current set of active services (i.e. services that are up) is added to the selection. The s6-rc command always operates on the selection.

Options

General options

  • -l live : look for the live state in live. Default is /run/s6-rc. The default can be changed at compile-time by giving the --livedir=live option to ./configure.
  • -a : add the current set of active services to the selection. This is useful for instance at shutdown time: s6-rc -da change will stop all services.
  • -b : blocking lock. If the service database is currently being used by another program, s6-rc will wait until that other program has released its lock on the database, then proceed. By default, s6-rc fails with an error message if the service database is currently in use. The default is the safe behaviour: for instance, it will correctly detect and fail nested s6-rc invocations (which are an admin error), whereas s6-rc -b would deadlock in such a case.

Up or down

These options control what is to be done: bring selected services up or down (for s6-rc change) or whether to use the forward or reverse dependency graph (for s6-rc listall). Default is up.

  • -u : up.
  • -d : down.

s6-rc change control

  • -v verbosity : be more or less verbose. Default is 1: warning and error messages will be printed to stderr. 0 silences warnings. 2 writes information messages whenever s6-rc performs a transition. 3 or more is debug info.
  • -n dryruntimeout : dry run. s6-rc will pretend to perform transitions, but will replace all its program invocations by a call to s6-rc-dryrun, which will do nothing but print the command line s6-rc would have executed, then sleep for dryruntimeout milliseconds before reporting success.
  • -t timeout : timeout. If s6-rc isn't done after timeout milliseconds, it will exit, leaving the live state as it is at exit time. It does not kill its children, so a child may successfully complete afterwards and the live state will not be updated; in that case, subsequent s6-rc change invocations will notice and correctly update it.
  • -p : prune. The state will be brought to exactly the set of selected services, plus their dependencies, and the other services will be brought down. With the -d option, the meaning is reversed: the state will be brought to the maximum possible set that does not include selected services. The change, however, is always performed in the same manner: first the unwanted services are all brought down, then the wanted services are all brought up.

Subcommands

s6-rc help

Prints a short help message.

s6-rc list servicenames...

Prints the selection. If the -d option has been given, the selection is inverted before it is printed, i.e. all the services but servicenames... will be printed.

This is mostly useful as s6-rc -a list, which simply prints the list of currently active services. s6-rc -da list will print the list of currently down services.

s6-rc listall servicenames...

  • s6-rc computes the complete dependency tree of the selection: the selection, plus the dependencies of every service in the selection, and recursively down. With the -d option, it computes the reverse dependency tree: the selection, plus what depends on it, and recursively up. The result is called the closed selection.
  • It prints the closed selection to its standard output. Note that the closed selection may be a very long list of services, including the most basic ones.

s6-rc diff

Checks the consistency between s6-rc's view of the state of the longruns it's managing, and s6's view. s6-rc will print one line per service whose s6 state fails to match what s6-rc believes: a + character (if s6 is maintaining the service as up when s6-rc thinks it's down) or a - character (if s6 is not trying to maintain the service when s6-rc thinks it's up), followed by the service name. If s6-rc finds at least one mismatch, it exits 1; else it exits 0.

s6-rc diff normally reports nothing. Currently, the only case where s6-rc's view can diverge from s6's view is when a service has been brought up via a s6-rc change command, then has failed at some point with a permanent failure - which means its supervisor has stopped trying to bring it back up.

s6-rc change

s6-rc change is the service state engine. It will bring the machine to a state where:

  • -u (default): all the services in the selection are up
  • -d: all the services in the selection are down
  • -pu: all the services in the selection, and only them, are up
  • -pd: all the services in the selection, and only them, are down

To do so:

  • From the selection, s6-rc computes the closed selection
  • It then computes the necessary transitions so that all the services in the closed selection can match the desired state
  • It then performs the transitions - or simulates them if the -n option has been given.
  • s6-rc processes services as soon as they can be processed: as soon as a service that needs to change state has all its dependencies fulfilled, it undergoes its transition. Independent services are processed in parallel: s6-rc parallelizes the transitions as much as it can, and there is no useless waiting time.
  • s6-rc updates the live state in live after every successful transition.
  • If every transition completes successfully, the live state eventually matches the desired state, and s6-rc exits 0.
  • If a transition fails, s6-rc will not perform the transitions that depend on it. It will keep processing all the other independent transitions, though, until there is no more work it can complete; then it will exit 1.

Longrun transitions

Transitions for longrun services are simple: s6-rc removes or creates a ./down file in the live service directory for the longrun service, then sends a command to the supervision tree to start or stop the service. (A service that is considered down by s6-rc will have a ./down file in its live service directory; a service that is considered up by s6-rc will not.) The transition is considered successful as soon as the daemon dies (for down transitions), or becomes up and ready (for up transitions). If a longrun service does not support readiness notification, the s6-svc command that is invoked by s6-rc will print a warning message, and the transition will be considered successful as soon as the daemon is up, i.e. as soon as the ./run script is executed by s6-supervise.

When a longrun service supports readiness notification, unless a nonzero timeout has been declared in the timeout-up file in the service definition directory, s6-rc will wait forever on an "up" transition for the notification to arrive. The transition will fail if a timeout occurs.

If a down transition fails, s6-rc does nothing with it. The service has already received a SIGTERM, and may be stuck in the process of exiting; or it may already have died but is stuck in a bad finish script that is not timing out. In any case, it is not a situation that s6-rc can recover from; the service is most likely down, but the administrator should manually check their process list. And fix their scripts, or timeout values, because a down transition failure is always a programmer or sysadmin error.

If an up transition fails, s6-rc sends an explicit s6-svc -d command to the longrun. This ensures the service is in a known down state when failing to go up, instead of (for instance) being stuck in a not-ready limbo state.

Note that proper usage of the timeout-kill and timeout-finish values in the longrun's definition directory can considerably reduce the number of cases where the service is left in an unknown state.

Transitions are supposed to be idempotent, but it is a general rule of supervision that run and finish scripts must be idempotent, so a properly designed service directory should work with s6-rc with no additional effort.

Oneshot transitions

Transitions for oneshot services amount to running the up or down script for the service; those scripts are stored in the compiled service database that is linked from the live state. The transition is considered successful if the script exits zero, and unsuccessful otherwise.

s6-rc performs some black magic so that up and down scripts are always run in a reproducible way, no matter when or how s6-rc change is invoked. That black magic involves a special longrun service, s6rc-oneshot-runner, that every oneshot service automatically depends on, and that is actually used to fork the up or down scripts as scions of the s6 supervision tree, instead of children of the s6-rc process.

Transitions should be ideally transactional, or at the very least idempotent. If a transition fails, it should leave the machine in the same state as before the transition was attempted; at the very least, it should not prevent a subsequent run of the same transition from completing successfully. If an s6-rc change invocation fails because some transition experienced a temporary failure, it should be possible to run the exact same s6-rc change invocation later, and be met with success.

This is important: it means that oneshot scripts should be treated as atoms, and that some care should be taken when writing them.

Dry runs

For any manual change, is it recommended to perform a dry run before the state change itself: add the -n dryrunthrottle option to the s6-rc command line. s6-rc will then simulate all the transitions, but not actually perform them or change the real live state. The command lines that s6-rc would have run will be printed to stdout instead, and each simulated transition will take dryrunthrottle milliseconds to complete successfully.

Signals

s6-rc change reacts to the following signals:

  • SIGTERM: s6-rc immediately aborts all its longrun transitions with a failure, and the impacted longruns will most likely be in a down state. Oneshot transitions are untouched, because killing the oneshot subprocess would make it impossible to determine what state the oneshot service is in.
  • SIGINT: same as SIGTERM.

Usage examples 

 s6-rc change myservicebundle

Brings up all the services represented by myservicebundle, bringing up all its dependencies first (recursively). 

 s6-rc -bad change

Waits for any pending program of the s6-rc family to stop using the live database and current compiled service database, then brings down all the currently running services in an orderly manner. This is typically run at shutdown time. (And it's not necessarily a bad change!) 

 s6-rc -l /zork -ua listall myservicebundle

Prints the names of all atomic services represented by myservicebundle plus the current live services, as well as everything they depend on, recursively. Assumes the live state is stored in the /zork directory instead of /run/s6-rc. 

 s6-rc -d listall myservicebundle

Prints the names of all atomic services represented by myservicebundle, as well as everything that depends on them. 

 s6-rc -pun0 change myservicebundle

Prints what s6-rc would do to bring the state to exactly the contents of myservicebundle as well as its recursive dependencies, and pruning all the rest. Does not wait any extra time between simulated transitions.

s6-rc-0.5.1.1/doc/index.html0000644000000000000000000001043713553360103012242 0ustar s6-rc - a service manager for s6

Software
skarnet.org

s6-rc

What is it ?

s6-rc is a service manager for s6-based systems, i.e. a suite of programs that can start and stop services, both long-running daemons and one-time initialization scripts, in the proper order according to a dependency tree. It ensures that long-running daemons are supervised by the s6 infrastructure, and that one-time scripts are also run in a controlled environment.

Installation

Requirements

  • A POSIX-compliant 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

Licensing

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

Download

  • The current released version of s6-rc is 0.5.1.1.
  • Alternatively, you can checkout a copy of the s6-rc git repository: 
     git clone git://git.skarnet.org/s6-rc
  • There's also a GitHub mirror of the s6-rc 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-rc and the current one.

Reference

Commands

Offline tools: creating and managing a compiled service database

Online tools: managing your live services

Upgrading from earlier s6-rc database formats

Programs used internally

Related resources

Discussion

  • s6-rc is discussed on the skaware mailing-list.

Similar work

  • anopa is another service manager for s6, with a similar design (but no compilation phase).
  • nosh is a complete init system and service manager for Unix.
s6-rc-0.5.1.1/doc/s6-rc-dryrun.html0000644000000000000000000000423213111013156013373 0ustar s6-rc: the s6-rc-dryrun program

s6-rc
Software
skarnet.org

The s6-rc-dryrun internal program

s6-rc-dryrun is a command wrapper and nullifier, roughly equivalent to the Unix echo command. When run, it simply prints its arguments to stdout.

s6-rc-dryrun is not meant to be used directly; it is internally called by s6-rc when given the -n option. When a dry-running s6-rc instance wants to change the system state by spawning a command cmd, it spawns s6-rc-dryrun cmd instead, which allows the user to see what would have been done without actually running the command.

Interface 

     s6-rc-dryrun [ -v verbosity ] [ -t timeout ] cmd...
  • s6-rc-dryrun prints its name, a colon, a space, and the space-separated list of its arguments to stdout.
  • It then waits for timeout milliseconds, then exits 0.

Options

  • -v verbosity : if verbosity is 0, s6-rc-dryrun will not print anything to stdout. Default is 1.
  • -t timeout : sleep for timeout milliseconds before exiting. Default is 1000, but when invoked by s6-rc, it will be the value of the dryruntimeout argument to the -n option. This is used to simulate a start or stop script that does not complete immediately.
s6-rc-0.5.1.1/doc/faq.html0000644000000000000000000004021613111013156011671 0ustar s6-rc: FAQ

s6-rc
Software
skarnet.org

s6-rc: Frequently Asked Questions

Quick recipes

How do I...

list every active service ? 

s6-rc -a list

list every service in the current live database, active or not ? 

s6-rc -d list

or

s6-rc-db list services

bring up service foo ? 

s6-rc -u change foo

bring down everything ? 

s6-rc -da change

print the "up" script for oneshot service foo ? 

s6-rc-db -u script foo | xargs -0 printf "%s "

see what pipeline longrun service foo is a part of ? 

s6-rc-db pipeline foo

see the list of all services that depend on foo, directly or indirectly ? 

s6-rc-db -d all-dependencies foo

see what services will restart if I update my live service database to newcompiled ? 

s6-rc-update -n newcompiled

The first line is the s6-rc invocation that will bring the old services down. The services that will stop are listed after -- change. The second line is the s6-rc invocation that will bring the new services up. The services that will start are listed after -- change.

The s6-rc-compile source format

The source format for s6-rc-compile is not very convenient. Why not put all the information for a service in a single file ?

Because parsing sucks. Writing parsers is an annoying, ungrateful task, with significant risks of bugs and security holes; and automatic parser generators produce big and inefficient code - and they are not immune to bugs or security holes either. For security, efficiency and maintainability reasons, I prefer to focus my efforts on code that actually does stuff, not code that parses a text file.

Using the filesystem as a key-value store is a good technique to avoid parsing, and skarnet.org packages do it everywhere: for instance, s6-envdir uses the file name as a key and the file contents as a value. The s6-rc-compile source format is just another instance of this technique.

The source format generally plays well with automated tools, be it for reading, as s6-rc-compile does, as for writing. I fully expect it to be used as the input (resp. the output) of some automated tools that would convert service definitions to (resp. from) another format, such as systemd unit files, sysv-rc scripts or OpenRC scripts; at least the s6-rc source format will make it easy on those tools.

And if you love configuration files, are ok with writing a parser (which is indubitably easier to do in other languages than C), and want to write a program that takes a text file, parses it and outputs a service definition directory in the s6-rc-compile source format, it should also be rather easy - please, feel free!

There are no "Provides:", no virtual services. What do I do if I have several implementations for a service ?

Use bundles. Bundles are the solution to most of the questions in the same vein.

Let's say you want to provide a ssh daemon, and have two possible implementations, opensshd and dropbear, but you want to provide a virtual service named sshd.

Define your two longruns, opensshd and dropbear; then define a bundle named sshd that only contains your default implementation, opensshd. Use the name sshd in your dependencies. When you run s6-rc-compile, all the dependencies will resolve to opensshd, and the compiled service database will consider opensshd to be the "real" service; but users will still be able to run s6-rc commands involving sshd. And if you want to change the default to dropbear, just change the sshd/contents file to dropbear, recompile the database, and run s6-rc-update.

The advantage of proceeding this way is that online service dependencies are kept very simple: dependencies are a directed acyclic graph, which is easy to handle - that is the reason why the compiled database is small, and why the s6-rc program is so small and fast. There are "AND" dependencies, but no "OR" dependencies, which would introduce great complexity both in data structures and in the dependency resolution engine. s6-rc handles this complexity offline.

You can use bundles to represent any collection of services, and write all your dependencies using only bundle names if you want. Bundles have multiple uses, and virtual services are definitely one of them.

Managing compiled databases

How do I safely update my compiled database? It is a directory, so I cannot atomically replace my old database with the new one.

Use symbolic links. You can atomically replace a symbolic link, and the s6-rc programs have been designed with that mechanism in mind. Here is the simplest way of managing your compiled databases: (change the names according to your preferences, but keep the same idea)

  • Make sure your s6-rc-init invocation, in your init scripts, always uses the /etc/s6-rc/compiled name to refer to the database to use at boot time.
  • Make sure /etc/s6-rc/compiled is a symbolic link that points to your current compiled database. For instance, the first time you compile a service database, you could run: 
     s6-rc-compile /etc/s6-rc/compiled-initial /etc/s6-rc/source-initial
 ln -sf compiled-initial /etc/s6-rc/compiled
  • When you compile a new service database, always compile it to a unique name, preferrably in the same directory as your current compiled database. You can for instance use a TAI64N timestamp, obtained by s6-clock, to create such a name: 
     stamp=`s6-clock`
 s6-rc-compile /etc/s6-rc/compiled-$stamp /etc/s6-rc/source-current
  • To replace your current compiled database with the one you just created, run s6-rc-update on the new name: 
     s6-rc-update /etc/s6-rc/compiled-$stamp
  • At this point, your current database is the new one, but if your machine reboots, it will still use the old one (because the /etc/s6-rc/compiled link is still pointing to the old one). To ensure that the new database will be used on the next boot, atomically update the link: 
     olddb=`s6-linkname -f /etc/s6-rc/compiled`
 s6-ln -nsf compiled-$stamp /etc/s6-rc/compiled
    The use of the s6-ln utility is recommended, because the ln standard actually forbids an atomic replacement, so utilities that follow it to the letter, for instance, ln from GNU coreutils, cannot be atomic: they first remove the old link, then create the new one. If you do not have s6-ln, you need to perform an unintuitive workaround to get POSIX-compliant tools to do the right thing: ln -sf compiled-$stamp /etc/s6-rc/compiled/compiled && mv -f /etc/s6-rc/compiled/compiled /etc/s6-rc
  • Your current compiled database, stored in /etc/s6-rc/compiled-$stamp, is now accessible via the /etc/s6-rc/compiled symlink and will be used at boot time. You do not need to modify your init scripts. If you wish, you can dispose of the old database you just replaced: 
     rm -rf $olddb

Switching from another service manager

I have a collection of init scripts in another format, but don't want to wait until the whole collection is converted before switching to s6-rc. Is there a smooth way in ?

Yes.

If you are using a service manager such as sysv-rc or OpenRC, you have a collection of init scripts that can be called with at least start and stop arguments. You also know dependencies between those scripts, or at least a reasonable ordering.

You can automatically generate a source directory for s6-rc-compile. For every init script /etc/init.d/foo that you have, create a service definition directory named foo:

  • foo/type contains oneshot
  • foo/dependencies contains the list of dependencies for foo
  • foo/up contains /etc/init.d/foo start if you're using sysv-rc, or rc-service start foo -D -q if you're using OpenRC
  • foo/down contains /etc/init.d/foo stop if you're using sysv-rc, or rc-service stop foo -D -q if you're using OpenRC

You can now run compile your s6-rc service database, and use the s6-rc engine as your service manager. Transitions will use your original init scripts, and the supervision features of s6 will not be used, but you will get proper dependency tracking and easy state changes.

Then, you can improve the database by changing services one by one, turning them into longruns so daemons get supervised when applicable, rewriting them into bundles calling more atomic services if needed, etc. That can be done at your own pace, one service at a time, while still getting some benefits from s6-rc; and if an iteration doesn't work, you can always roll back while you fix it.

There are no runlevels in s6-rc. I like runlevels.

You have better than runlevels. You have bundles.

When writing your service database in source format, take note of the common sets of services that you like to run together, what other init systems sometimes call runlevels. For each of those sets, define a bundle containing all those services. For instance, you could define a runlevel-1 bundle that contains only a single getty, a runlevel-2 bundle that contains only your local services and no network, a runlevel-3 bundle that contains runlevel-2 as well as network services, and a runlevel-5 bundle that contains runlevel-3 and your desktop. You can even create a runlevel-0 bundle that contains nothing at all!

In your boot script (/etc/rc.init, for instance, if you're using s6-linux-init), after invoking s6-rc-init, just ask s6-rc to start the set of services you want up by default: s6-rc change runlevel-5.

If you later want to change your current set of services, you can then tell s6-rc to switch, using the -p option to make sure to stop services you don't want up anymore: s6-rc -p change runlevel-2.

Bundles are easy to use, they're flexible, and they're powerful. They give you the same level of functionality as runlevels would, and more. You can even add bundles to compiled service databases - including the live one - or remove bundles from them without having to recompile them: that's what the s6-rc-bundle utility is for.

When in doubt, use bundles.

There are no intermediate states in s6-rc. There's just "up" and "down", no "starting", no "failed", etc. Why ?

Because those intermediate states are unnecessary.

From the machine's point of view, things are simple: a service is either up or it's not. If a service fails to start, then it's still down. Note that it is recommended to write transactional oneshots for this very reason: it is simple to try starting again a service that failed to start, but it is hard to recover from a service that is only "partially up" - and this is true whether you're using s6-rc or another service manager.

Service managers that use intermediate states do so in order to keep track of what they're doing and what they have done. But this introduces needless complexity: the reality is that the service is either up or down, it's either in the state you wanted it to be or not. If it's in some other, weird, state, then the service scripts have not been properly designed - they are not transactional.

s6-rc does not keep track of "failed" states: a service that fails to start simply remains down, and s6-rc exits 1 to report that something went wrong. To know what services failed to start, compare the result of s6-rc -a list against your expected machine state.

The reason for this design is simple: if the s6-rc process is killed in the middle of a transition while a service state is "starting", what should the next invocation do? This is unclear, and the intermediate state introduces ambiguity where there should not be. Also, if there is a "failed" service, what should the next invocation do? Try and restart it, or not? This depends on what the user wants; this is policy, not mechanism. Simply reporting the error while keeping the state as "down" allows users to apply their chosen policies - see below.

Keep it simple, stupid.

Mechanism vs. policy

s6-rc feels bare: there are tools, but no wrappers, no pre-packaged scripts to boot my machines, no default runlevels. By comparison, OpenRC provides a complete default set of scripts !

In the world of software development, it is important to distinguish mechanism from policy. Mechanism is "how do I perform the job", and should, theoretically, be addressed by software authors. Policy is "what are the details of the job I perform, where should I put my files, what conventions do I use", and should, theoretically, be addressed by Unix distributions.

Like the rest of skarnet.org software, s6-rc aims to provide mechanism, not policy: it is OS-agnostic and distribution-agnostic. Providing boot scripts, or anything of this kind, would go against this principle; it is possible that a policy defined by software conflicts with a policy defined by a distribution, for instance the provided boot scripts do not match the distribution's needs, and so the distributors have to patch the software!

The s6-rc tools only provide mechanism, so they can be used as is by individual users, or by a distribution. They do not need to be patched. It is up to distributions to provide their own policy surrounding those tools, including complete service databases. It is literally the distributors' job!

OpenRC is a different case, because it was developed by and for a Linux distribution, so with that in mind, the OpenRC developers did not have to think much about separating mechanism from policy. It works very well for Gentoo and Gentoo-derived distributions; but it requires adaptation and more work for the admin to use OpenRC outside of that frame.

s6-rc-0.5.1.1/doc/s6-rc-fdholder-filler.html0000644000000000000000000000732213111013156015115 0ustar s6-rc: the s6-rc-fdholder-filler program

s6-rc
Software
skarnet.org

The s6-rc-fdholder-filler internal program

s6-rc-fdholder-filler creates anonymous pipes and stores them into a s6-fdholderd "fd-holding" daemon.

s6-rc-fdholder-filler is not meant to be used directly; it is used in internal scripts created by s6-rc-compile, which are invoked during an s6-rc execution.

Interface 

     s6-rc-fdholder-filler [ -1 ] [ -t timeout ] < longrunnamesfile
  • s6-rc-fdholder-filler expects file descriptor 6 to be open and connected to the s6-fdholderd daemon instance managed by s6-rc as the internal s6rc-fdholder service.
  • It reads a list of longrun names from its stdin, one per line. Empty lines are ignored; comments starting with # are ignored; leading whitespace is ignored, but trailing whitespace is not.
  • For every name longrun that it finds, it creates an anonymous pipe, and stores both ends of that pipe into the s6-fdholderd instance, with the pipe:s6-rc-r-longrun (for the reading end) and pipe:s6-rc-w-longrun (for the writing end) identifiers, and an infinite timeout.
  • It then exits 0.

Options

  • -1 : write a newline to stdout before exiting after successful operation. This is used as a notification mechanism.
  • -t timeout : if the operation cannot be achieved in timeout milliseconds, abort and report failure. By default, timeout is 0, meaning infinite.

Exit codes

  • 0: success
  • 100: wrong usage
  • 111: system call failed

Notes

  • s6-rc-fdholder-filler is never meant to be used manually; this page should only be used to understand s6-rc internals.
  • s6-rc-fdholder-filler is used in the s6rc-fdholder internal service's run script, right after the s6-fdholderd daemon is started; its arguments are the names of all the consumer longrun services declared in the service database.
  • The point is to create all the pipes for the longrun pipelines in advance, every time the s6rc-fdholder service is started, and make them available in the fd holder. This way, pipelined services can simply retrieve their stdin (for consumers) or stdout (for producers) from the fd holder, at any time: even if a pipeline service dies and is restarted, the pipe will remain valid.
  • If the fd holder itself dies, it will be refilled with a new set of pipes as soon as it is restarted. Pipelined services will not be impacted until one of them restarts; then all the pipeline will restart.
s6-rc-0.5.1.1/doc/s6-rc-compile.html0000644000000000000000000004215213426111422013507 0ustar s6-rc: the s6-rc-compile program

s6-rc
Software
skarnet.org

The s6-rc-compile program

s6-rc-compile is a service database compiler. It takes a series of service definitions in the source format, and compiles them into a directory, which is the compiled format.

The administrator can then examine that compiled database via s6-rc-db, put it into a place where it will be registered at boot time as the current compiled database by s6-rc-init, or even live update the current service database via s6-rc-update.

Interface 

     s6-rc-compile [ -v verbosity ] [ -h fdhuser ]  [ -b ] compiled source...
  • s6-rc-compile analyzes every directory source in its arguments. For every subdirectory service in source, it expects to find a valid service definition in service.
  • s6-rc-compile outputs a compiled version of the service database into compiled. This database contains information for all the services declared in every source argument.

Exit codes

  • 0: success
  • 1: error in a source directory
  • 100: wrong usage
  • 111: system call failed

Options

  • -v verbosity : be more or less verbose. Default is 1: warning and error messages will be printed to stderr. 0 silences warnings. 2 adds a bit more information about what s6-rc-compile is doing. 3 or more is heavy debug output.
  • -h fdhuser : arrange for the s6-fdholder-daemon program, which maintains the pipes for the longrun pipelines, to run as user fdhuser. By default, it runs as the user owning the supervision tree, i.e. most likely root.
  • -b : make s6-rc-oneshot-run invocations wait instead of fail on lock contention. This should not change anything in practice, and you can ignore that option.

Source format

s6-rc-compile scans every source directory to find service definition directories in it. It ignores every file that is not a directory, or that starts with a dot. For every service definition directory that it finds, it creates a service with the same name as the directory. Names cannot be duplicated and cannot contain a slash or a newline; they can contain spaces and tabs, but using anything else than alphanumerical characters, underscores and dashes is discouraged - the s6-rc programs will handle weird names just fine, but other tools, especially shell scripts, may not. Names are also forbidden to use the reserved s6rc- and s6-rc- prefixes.

Every service definition directory service is expected to contain the following files:

For every service

  • A regular file named type, that contains only the text oneshot, longrun or bundle, and a terminating newline. This file declares the type of service defined by the directory.

For bundles

  • A regular file named contents. This file must be a list of service names, one per line. Whitespace at the beginning of a line is ignored, but trailing whitespace is not. Lines starting with a # character are ignored. The file defines the services that will be represented by the bundle named service.

It is possible to use bundle names in a contents file. However, if s6-rc-compile detects a cycle in bundle definitions, it will complain and exit 1.

For atomic services

  • An optional regular file named timeout-up. This file, if it exists, must contain an integer, which is the maximum number of milliseconds s6-rc will wait for successful completion of the service start; if starting the service takes longer than this value, s6-rc will declare the transition a failure. If the file does not exist, or contains 0, no timeout is defined and s6-rc will wait indefinitely for the service to start.
  • An optional regular file named timeout-down. This file, if it exists, must contain an integer, which is the maximum number of milliseconds s6-rc will wait for successful completion of the service stop; if stopping the service takes longer than this value, s6-rc will declare the transition a failure. If the file does not exist, or contains 0, no timeout is defined and s6-rc will wait indefinitely for the service to stop.
  • An optional regular file named dependencies. This file must be a list of service names, one per line. Whitespace at the beginning of a line is ignored, but trailing whitespace is not. Lines starting with a # character are ignored. The file defines the direct dependencies of service, i.e. the services that must be up in order for service to work properly.

It is unnecessary to manually define complete sets of dependencies in the dependencies file, because s6-rc will properly handle dependency chains. If A depends on B, no matter the underlying implementation of B, and the current implementation of B depends on C, then you should just put B in A/dependencies; when starting the set, s6-rc will start C first, then B, then A. If the underlying implementation of B changes and does not depend on C, then you will just have to modify the dependencies for B, and the definition of A will still be correct.

Of course, if A depends on C anyway, you should add both B and C to A/dependencies.

If s6-rc-compile detects a cycle in dependencies across services, it will complain and exit 1.

For oneshots

  • Two regular files named up and down, which must each contain a single Unix command line. The files will be interpreted by the execlineb lexer at compile time and the results will be stored into the compiled database in an internal form. up will be run when the service is started, and down will be executed when the service is stopped. up is mandatory, but down is optional; if no down file is provided in the source definition directory, then it is treated as the empty script. If a script is empty, then s6-rc will consider that the corresponding transition for this service does nothing and always succeeds.

up and down are interpreted by execlineb, but that does not mean they have to be entirely written in the execline language. The execlineb lexer is only used because it can compile a Unix command line from a text file and store the compiled result, whereas a shell would have to be invoked everytime the script is run. There are many ways to write up and down scripts:

  • They can be written as standard execline scripts, without the initial shebang line or positional parameter management.
  • They can be written in any scripting language by invoking the interpreter directly: for instance /bin/sh -c "script", where script is a shell script.
  • They can also just call a script that will actually be stored somewhere else: for instance, up can contain /etc/init.d/service start while down contains /etc/init.d/service stop, and /etc/init.d/service is a System V-style init script.

Don't think you have to learn all the intricacies of the execline language just because the up and down scripts get lexed by it. You don't.

For longruns

The s6-rc service definition directory for a longrun service is similar to a s6 service directory, but there are a few differences:

  • s6-rc-compile crafts the servicedir itself, based on what it finds in the service definition directory. It does not copy everything directly from the definition directory to the servicedir; only two subdirectories will be copied verbatim, data and env. So if you want to store service configuration data, to be used by the run script, in the service directory, make sure it is in a data/ or env/ subdirectory.
  • Definition directories cannot have a log subdirectory - or if they do, it will be ignored. From s6-rc-compile's point of view, logged s6 services must actually be defined as two separate s6-rc services, one defined as a producer and one defined as a consumer, making a pipeline of just two services; see below for more information about pipelines.

The following files must or may appear in a longrun definition directory:

  • A mandatory regular file named run, as well as optional files named finish, notification-fd, timeout-kill, timeout-finish, nosetsid, max-death-tally, and down-signal. These files will be copied, or recreated, in the generated service directory: they are meant to be used by the s6-supervise process that will manage the longrun service.
  • Optional directories named data and env. These will be copied verbatim into the generated service directory.
  • An optional file named producer-for. If this file exists, then it must contain the name of another longrun service servicelog; service is then declared as a producer for servicelog. servicelog must also, in its own definition directory, be declared as a consumer for at least service.
  • An optional file named consumer-for. If this file exists, then it must contain a list of longrun services serviceprod...: service is then declared as a consumer for all the services in serviceprod. Each of those services must also, in its own definition directory, be declared as a producer for service.
  • An optional file named pipeline-name. If this file exists along with a consumer-for file, and there is no producer-for file, then a bundle will automatically be created, named with the content of the pipeline-name file, and containing all the services in the pipeline that ends at service. See below for more about pipelining. The pipeline-name file is ignored if service is not a last consumer.

Be aware that service directories will be relocated, and copied at boot time, so if your run or finish scripts refer to files in the service directory (probably in the data or env subdirectories!), they should use relative paths, not absolute ones.

Note that you cannot create a ./down file for s6-supervise in a generated service directory. Even if such a file exists in the definition directory, it will be ignored - it will not be replicated in the service directory. This is intentional: s6-rc internally uses ./down files in the service directories it manages, to mark longrun services that are down.

The producer-for, consumer-for and pipeline-name files are used to set up automatic longrun pipelining.

Longrun pipelining

Users of supervision suites know about logged services: a service acts as a producer, and is coupled with another service, its logger; the supervision system automatically maintains an open pipe between the producer's stdout and the logger's stdin.

s6-rc comes with an extension of this mechanism. Rather than only allowing two longrun services to be pipelined, it can set up an indefinite number of longrun services this way.

  • A producer declares its direct consumer in a producer-for file.
  • Intermediate services declare both their direct producers in their consumer-for file, and their direct consumer in their producer-for file.
  • The last consumer only declares its direct producers in a consumer-for file.
  • The last consumer may also declare a name for the whole pipeline, in its pipeline-name file. If it does so, then a bundle is automatically created with the given name, and it contains all the services in the pipeline.

s6-rc-compile will detect pipelines, and set up the service directories so that every producer's stdout is connected to its consumer's stdin, and that the pipes are not broken whenever one element in the chain dies.

A service can only be declared as a producer for one other services, but it can be declared as a consumer for several other services: the consumer-for can have several lines. This means that one service can only send its output to one consumer, but it can read its input from several producers. If there are several producers to a service, they will all write to the same Unix pipe that the service reads.

This means that what s6-rc calls pipelines are really funnels: you can collapse multiple data streams into a single data stream, at every step of your processing chain. The pipeline terminology remains for history reasons: previous versions of s6-rc could not handle multiple producers.

s6-rc-compile checks for pipeline consistency. It must see a producer-for file in the producers' definition that is consistent with the consumer-for file in the consumer's definition. It will detect and reject cycles as well as collisions.

The pipe linking a set of producers with a consumer is created and stored at run-time in a s6-fdholder-daemon instance managed by an automatically generated longrun service named s6rc-fdholder.

Compiled database usage

  • Once it has been built with s6-rc-compile, a compiled database cannot be modified. It (i.e. the directory containing the n, db and resolve.cdb files as well as the servicedirs subdirectory) can be moved around in the filesystem, provided the insides remain untouched.
  • Once a compiled database is live (i.e. it has services running on it, following an invocation of s6-rc-init or s6-rc-update, it must not move anymore, and it must not be deleted. The only way to "free" such a compiled database for displacement or deletion is to replace it as the live one via another call to s6-rc-update.
  • No matter what user compiles the database, only root and the user owning the supervision tree at run-time will be able to operate the compiled database with the s6-rc command.

A complete example

The examples/source subdirectory of the s6-rc package contains a set of service definition directories, which is actually a working, valid set for a Linux system running busybox and the skarnet.org packages; of course, only the service definition set has been kept, and private information has been removed, so it won't work out-of-the-box without the proper specific files, notably configuration in /etc - but nevertheless, you can browse the source and understand what it does, and adapt it to your own needs. It will compile as is with s6-rc-compile, and you can examine the resulting compiled database with s6-rc-db.

s6-rc-0.5.1.1/doc/s6-rc-format-upgrade.html0000644000000000000000000001156013211307341014772 0ustar s6-rc: the s6-rc-format-upgrade program

s6-rc
Software
skarnet.org

The s6-rc-format-upgrade program

s6-rc-format-upgrade is a program that is normally used very rarely: when the s6-rc package is upgraded, some services are currently managed with s6-rc, and the database format has changed. This program transitions a live directory using a database with the old s6-rc format (the one being replaced) so that it uses a database with the new s6-rc format.

The point is to ensure a smooth transition between different versions of s6-rc without needing a reboot.

s6-rc-format-upgrade is very different from s6-rc-update and does not duplicate its functionality:

  • s6-rc-update updates a live directory to use a different compiled database, compiled from a different source, where services may have changed, be renamed, etc. But it can only handle databases with the format that it knows - the format created by the s6-rc-compile binary that comes in the same package as s6-rc-update.
  • s6-rc-format-upgrade is the opposite: it cannot handle service changes, it can only update a live directory to use a compiled database corresponding to the same source as the compiled database the live directory is currently using. But it will replace an obsolete compiled database with a compiled database that uses the new format (provided both compiled databases come from the same source, and have just been produced by invocation of different versions of s6-rc-compile), ensuring the s6-rc installation can live through database format changes.

Interface 

     s6-rc-format-upgrade [ -v verbosity ] [ -l live ] [ -t timeout ] [ -b ] newcompiled
  • newcompiled must be an absolute path.
  • s6-rc-format-upgrade expects to find a compiled service database with the new format in compiled
  • newcompiled must be compiled from the same source database as the current compiled database currently being used by live.
  • s6-rc-format-upgrade then updates the live directory in live so it uses newcompiled as its compiled database.
  • On success, it exits 0.

Options

  • -v verbosity : be more or less verbose. Default is 1.
  • -t timeout : if all operations have not completed after timeout milliseconds, complain and exit 1.
  • -l live : Work with the live state in the live directory. Default is /run/s6-rc. The default can be changed at compile time by giving the --livedir=live option to ./configure.
  • -b : blocking lock. If live is currently being used by another program, s6-rc-format-upgrade will wait until that other program has released its lock on the directory, then proceed. By default, s6-rc-format-upgrade fails with an error message if the live directory is currently in use.

Typical usage

s6-rc-format-upgrade is only necessary when the database format changes, which only happens when s6-rc's major version number (the third number from the right) changes. The correct order of operations is then the following:

  • Make sure your current compiled database is up-to-date with your source database. If it's not, update it, by invoking the s6-rc-compile and s6-rc-update binaries from your old s6-rc installation, the ones that understand the old format.
  • From the same source, compile a new database with the new format, using the s6-rc-compile binary from the new s6-rc package.
  • Update your live directories with this new database, using s6-rc-format-upgrade.
  • You can now remove the old databases, and delete the old s6-rc package.
s6-rc-0.5.1.1/doc/s6-rc-update.html0000644000000000000000000002711013366152352013350 0ustar s6-rc: the s6-rc-update program

s6-rc
Software
skarnet.org

The s6-rc-update program

s6-rc-update is an online service database switcher: it will replace your compiled service database with another one, and adjust the live state accordingly. This allows you to change your set of services without having to reboot.

Live upgrading a service database is not easy, and no fully automated system can get it right in all cases. s6-rc-update will do its best on its own, but it lets the user give it instructions to handle difficult cases; and rather than implement doubtful heuristics, it will fail with an error message in situations it cannot solve.

Interface 

     s6-rc-update [ -n ] [ -v verbosity ] [ -t timeout ] [ -l live ] [ -f convfile ] [ -b ] newdb
  • s6-rc-update analyzes the current live state, the current compiled service database, and the compiled service database contained at newdb (which must be an absolute path).
  • Additionally, it can process an optional conversion file containing instructions.
  • It computes the necessary service transitions to safely update the live database.
  • It shuts down the necessary services.
  • It updates the live directory so that newdb becomes the live compiled service database.
  • It starts up the necessary services.

Exit codes

  • 0: success
  • 1: failure to perform some state transitions, but the database was switched to newdb
  • 2: timed out, but the database was switched to newdb
  • 3: unknown service name in the conversion file
  • 4: invalid service database
  • 5: wrong service type in the conversion file
  • 6: duplicate service in the conversion file
  • 9: failure to perform some state transitions, and the database was not switched
  • 10: timed out, and the database was not switched
  • 100: wrong usage
  • 111: system call failed
  • 126: cannot exec into s6-rc for the final "up" transition (error other than ENOENT)
  • 127: cannot exec into s6-rc for the final "up" transition (executable not found)

Options

  • -n : dry run. s6-rc-update will compute the service transitions, and print the s6-rc command lines it would execute to perform those transitions. It will not actually run them or modify the live database.
  • -v verbosity : be more or less verbose. Default is 1: warning and error messages will be printed to stderr. 0 silences warnings. 2 adds a bit more information about what s6-rc-update is doing. 3 or more is heavy debug output.
  • -t timeout : if s6-rc-update cannot perform its job within timeout milliseconds, it will exit. The default is 0, meaning infinite (no timeout). Be aware that timing out and exiting may leave the live database in an inconsistent state, so use of this option is not recommended.
  • -l live : look for the live state in live. It must be an absolute path. Default is /run/s6-rc. The default can be changed at compile-time by giving the --livedir=live option to ./configure.
  • -f convfile : use the conversion file located at convfile. Default is /dev/null, meaning no special instructions.
  • -b : blocking lock. If the database is currently being used by another program, s6-rc-update will wait until that other program has released its lock on the database, then proceed. By default, s6-rc-update fails with an error message if the database is currently in use.

Transition details

s6-rc-update's job is to ensure consistency of the live state across a change of compiled service databases. To do so, it must make sure that the services that are up at the time of its invocation are still up after its invocation; but service definitions in the new compiled may be different from those in the old one - in particular, dependencies may change, or a service can change types: a oneshot can become a longrun and vice-versa, and an atomic service can even become a bundle.

Service identity

s6-rc-update examines atomic services, as defined in the old compiled, that are up at invocation time, and computes what is necessary for the "same" services, as defined in the new compiled, to be up. Barring instructions from the conversion file, the service is "the same" if it has the same name in the new compiled, no matter its type.

So, if there is an up oneshot named sshd in the old compiled, and there is a longrun named sshd in the new compiled, then s6-rc-update will decide that the new sshd longrun will replace the old sshd oneshot. If the new compiled defines a sshd bundle instead, then s6-rc-update will decide that the old sshd oneshot will be replaced with the contents of the sshd bundle.

Restarts

s6-rc-update tries to avoid needlessly restarting services. For instance, running it with a new compiled that is an exact copy of the old compiled should not cause any restarts. s6-rc-update will flag a service to be restarted in the following cases:

  • The service has disappeared in the new compiled. In this case, the old service will simply be stopped.
  • The service has changed types: a oneshot becomes a longrun, a longrun becomes a oneshot, or an atomic service becomes a bundle. In this case, the old service will be stopped, then the new service will be started.
  • The service has a dependency to a service that must restart, or to an old service that must stop, or to a new service that did not previously exist or that was previously down.
  • There is an instruction to restart the service in the conversion file.

Steps

After it has decided what services it should restart, s6-rc-update will:

  • Invoke s6-rc to stop old services.
  • Update the live directory with the data from the new compiled. This is the critical part; s6-rc-update should not be interrupted at this point. It does its best to avoid risking leaving behind an inconsistent state, but a 100% atomicity guarantee is impossible to achieve.
  • Adjust pipe names for the existing pipelines, if needed.
  • Exec into s6-rc to start new services.

The conversion file

The conversion file is used to give s6-rc-update instructions when the change of databases is not entirely straightforward. Currently, it supports the following features:

  • changing the name of a service
  • forcing a restart on a service

Format

The conversion file is a sequence of lines; each line is parsed independently, there's no carrying of information from one line to the next.

A line is lexed into words by the execlineb lexer, which means that words are normally separated by whitespace, but can be quoted, that # comments are recognized, etc.

The first word in a line must be the name of an "old" atomic service, i.e. an atomic service contained in the current live database. The remaining words in the line are instructions telling s6-rc-update how to convert that service.

Renaming

If the second word in the line is ->, then the third word in the line must be the new name of the service in the new database: s6-rc-update will then rename it. It is possible to rename an atomic service to another atomic service or a bundle, but no matter whether a service is renamed or not, changing its type will force a restart.

Restarting

If the word following either the old name, or a renaming instruction, is the word restart, then the service will forced to restart.

Examples

Consider the following conversion file: 

# Simple conversion file
mount-var -> mount-rwfs
httpd restart
sqld -> mysqld restart
  • It will rename mount-var to mount-rwfs, not restarting it if mount-var in the old database and mount-rwfs in the new database have the same type and do not depend on services that would force a restart.
  • It will restart httpd
  • It will rename sqld to mysqld and make it restart.

Safely managing and updating compiled databases

The sequence of operations needed to update a database from source to live can be a little tricky. It involves:

  • Compiling the new database without overwriting the live one
  • Calling s6-rc-update to safely replace the live database
  • Making sure the new database will be correctly used at boot time

This FAQ entry gives a step-by-step explanation on how to proceed.

Notes

  • The live argument to the -l option, if present, should be the same argument that was given to the s6-rc-init invocation when the system was booted. In other words: it should be the name of the symbolic link pointing to the real directory containing the live information, not the name of the real directory.
  • If a longrun service is renamed from oldname to newname, but not restarted, the s6-supervise process in charge of it will still show up in the process list as s6-supervise oldname. This is purely cosmetic and will have no impact on the service; nevertheless, if you wish to avoid that, simply force a restart on every longrun you rename.
  • After a s6-rc-update invocation, the old compiled service database is left unchanged where it was, and the new compiled service database is used in-place. If the machine is rebooted, the s6-rc-init invocation will still boot on the old compiled unless more work is performed. It is recommended to keep a current symbolic link to the current compiled, to always s6-rc-init on current, and to make current a link to the new compiled right after a s6-rc-update invocation.
  • s6-rc-update is the only way to "free" the old compiled database for displacement or deletion. A live compiled database must not be tampered with. After a s6-rc-update invocation, the old database isn't live anymore and can be moved or deleted; instead, newdb is live.
s6-rc-0.5.1.1/doc/why.html0000644000000000000000000003172113520032742011740 0ustar s6-rc: why?

s6-rc
Software
skarnet.org

Why s6-rc ?

The limits of supervision suites

Supervision suites such as s6, runit, perp or daemontools define a service as a long-lived process, a.k.a daemon. They provide tools to run the daemon in a reproducible way in a controlled environment and keep it alive if it dies; they also provide daemon management tools to, among others, send signals to the daemon without knowing its PID. They can control individual long-lived processes perfectly well, and s6 also provides tools to manage a whole supervision tree. To any system administrator concerned about reliability, supervision suites are a good thing.

However, a supervision suite is not a service manager.

Relying on a supervision suite to handle all the service management is doable on simple systems, where there aren't many dependencies, and where most of the one-time initialization can take place in stage 1, before any daemons are launched. On some embedded systems, for instance, this is perfectly reasonable.

On other systems, though, it is more problematic. Here are a few issues encountered:

  • With a pure supervision tree, all daemons are launched in parallel; if their dependencies are not met, daemons just die, and are restarted by the supervisors, and so on; so eventually the dependency tree is correctly built and everything is brought up. This is okay with lightweight daemons that do not take up too many resources when starting; but with heavyweight daemons, bringing them up at the wrong time can expend CPU or cause heavy disk access, and increase the total booting time significantly.
  • The runit model of separating one-time initialization (stage 1) and daemon management (stage 2) does not always work: some one-time initialization may depend on a daemon being up. Example: udevd on Linux. Such daemons then need to be run in stage 1, unsupervised - which defeats the purpose of having a supervision suite.
  • More generally, supervision suites do not perform dependency management. Their job is to maintain daemons alive and ease their administration; dependency across those daemons is not their concern, and one-time initialization scripts are entirely foreign to them. So a situation like udevd where it is necessary to interleave daemons and one-time scripts is not handled properly by them.

To manage complex systems, pure supervision suites are insufficient, and real service managers, starting and stopping services in the proper order and handling both oneshots (one-time initialization scripts) and longruns (daemons), are needed.

Previous alternatives

Unix distributions usually come with their own init systems and service managers; all of those have flaws one way or another. No widely spread init system gets things right, which is the main reason for the recent "init wars" - no matter what init system you talk about, there are strong, valid reasons to like it and support it, and there are also strong, valid reasons to dislike it.

Non-supervision init systems usually fall in one of two categories, both with pros and cons.

Traditional, sequential starters

Those are either the historical Unix init systems, or newer systems that still favor simplicity. Among them, for instance:

  • sysvinit, the historical GNU/Linux init system, and its companion set of /etc/rc.d init scripts that some distributions like to call sysv-rc. Note that sysvinit does have supervision capabilities, but nobody ever bothered to use them for anything else than gettys, and all the machine initialization, including longruns, is done by the sysv-rc scripts, in a less than elegant way.
  • BSD init, which is very similar to sysvinit - including the supervision abilities that are only ever used for gettys. The /etc/rc script takes care of all the initialization.
  • OpenRC, an alternative, dependency-based rc system.

All these systems run sequentially: they will start services, either oneshots or longruns, one by one, even when the dependency graph says that some services could be started in parallel. Also, the daemons they start are always unsupervised, even when the underlying init system provides supervision features. There usually is no readiness notification support on daemons either, daemons are fire-and-forget (but that's more on the scripts themselves than on the frameworks). Another common criticism of those systems is that the amount of shell scripting is so huge that it has a significant performance impact.

(Note that OpenRC has an option to start services in parallel, but at the time of this writing, it uses polling on a lock file to check whether a service has completed all its dependencies; this is heavily prone to race conditions, and is not the correct mechanism to ensure proper service ordering, so this option cannot be considered reliable.)

Another, less obvious, but important drawback is that service-launching scripts run as scions of the shell that invoked the command, and so they may exhibit different behaviours when they're run automatically at boot time and when they're run manually by an admin, because the environment is different. Scripts usually try to run in a clean environment, but it's hard to think of everything (open file descriptors!) and every script must protect itself with a gigantic boilerplate, which adds to the inefficiency problem.

Monolithic init behemoths

The other category of service managers is made of attempts to cover the flaws of traditional service starters, and provide supervision, dependency management and sometimes readiness notification, while reducing the amount of scripting needed. Unfortunately, the results are tightly integrated, monolithic init systems straying far away from Unix core principles, with design flaws that make the historical inits' design flaws look like a joke.

  • Upstart was the first one. On the front page, in the "feature highlights" section: "Tasks and Services are started and stopped by events. Events are generated as tasks and services are started and stopped." Do you understand what that means? I don't. Also, Upstart was the first system that used ptrace on the processes it spawned in order to keep track of their forks. If you don't know what that means: it was pure insanity.
  • launchd, Darwin's init and service manager. The wikipedia page (linked here because Apple doesn't see fit to provide a documentation page for launchd) is very clear: it replaces init, rc, init.d/rc.d, SystemStarter, inetd, crontd, atd and watchdogd. It does all of this in process 1. And it uses XML for daemon configuration, so launchctl has to link in a XML parsing library, and it communicates with process 1 via a Mach-specific IPC mechanism. Is this the sleek, elegant design that Apple is usually known for? Stick to selling iPhones, guys.
  • systemd, the main protagonist (or antagonist) in the "init wars". It has the same problems as launchd, up by an order of magnitude; here is why. systemd avowedly aims to replace the whole low-level user-space of Linux systems, but its design is horrendous. It doesn't even get readiness notification right.

The problem of integrated init systems is that:

  • They have been developed by companies and associations, not individuals, and despite the licensing, they are for all intents and purposes closer to proprietary software than free software; they also suffer from many of the technical flaws of enterprise software design.
  • As a result, and despite being backed by tremendous manpower, they have been very poorly thought out. The manpower goes into the coding of features, not into architecture conception; and the architects were obviously not Unix experts, which is a shame when it's about creating a process 1 for Unix. This is apparent because:
  • They have been designed like application software, not system software, which requires a fairly different set of skills, and careful attention to details that are not as important in application software, such as minimal software dependencies and shortness of code paths.

Pages and pages could be - and have been - written about the shortcomings of integrated init systems, but one fact remains: they are not a satisfying solution to the problem of service management under Unix.

The best of both worlds

s6-rc aims to be such a solution: it is small and modular, but offers full functionality. Parallel service startup and shutdown with correct dependency management (none of the systemd nonsense where services are started before their dependencies are met), correct readiness notification support, reproducible script execution, and short code paths.

  • s6-rc is a service manager, i.e. the equivalent of sysv-rc or OpenRC. It is not an init system. You can run s6-rc with any init system of your choosing. Of course, s6-rc requires a s6 supervision tree to be running on the system, since it delegates the management of longrun services to that supervision tree, but it does not require that s6 be the init system itself. s6-rc will work when s6-svscan runs as process 1 (on Linux, such a setup can be easily achieved via the help of the s6-linux-init package), and it will also work when s6-svscan runs under another init process.
  • The service manager runs on top of a supervision suite. It does not try to make it perform boot/shutdown operations or dependency management itself; and it does not substitute itself to it. s6-rc uses the functionality provided by s6, but it is still possible to run s6 without s6-rc for systems that do not need a service manager. It would also be theoretically possible to run s6-rc on top of another supervision suite, if said supervision suite provided the hooks that s6-rc needs.
  • A significantly time-consuming part of a service manager is the analysis of a set of services and computation of a dependency graph for that set. At the time of writing this document, s6-rc is the only service manager that performs that work offline, eliminating the dependency analysis overhead from boot time, shutdown time, or any other time where the machine state changes.
  • The source format for the s6-rc-compile tool is purposefully simple, in order to allow external tools to automatically write service definitions for s6-rc - for instance for conversions between service manager formats.
  • Like every skarnet.org tool, s6-rc is made of very little code, that does its job and nothing else. The binaries are small, it is very light in memory usage, and the code paths are extremely short.

The combination of s6 and s6-rc makes a complete, full-featured and performant init system and service manager, with probably the lowest total memory footprint of any service manager out there, and all the reliability and ease of administration that a supervision suite can provide. It is a real, viable alternative to integrated init behemoths, providing equivalent functionality while being much smaller and much more maintainable.

s6-rc-0.5.1.1/doc/upgrade.html0000644000000000000000000002340613553360140012563 0ustar s6-rc: how to upgrade

s6-rc
Software
skarnet.org

Upgrade notes for s6-rc

As a general rule, if you change major versions, for instance if you upgrade from 0.1.0.0 to 0.2.1.2, you need to recompile your service databases, because the binary format is not guaranteed stable across major version changes. You can keep your compiled service databases across minor and bugfix version changes.

What has changed in s6-rc

in 0.5.1.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.

in 0.5.1.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.

in 0.5.0.0

  • This is a major version update but the database format did not change, no need to recompile your service databases.
  • skalibs dependency bumped to 2.8.0.0.
  • execline dependency bumped to 2.5.1.0.
  • s6 dependency bumped to 2.8.0.0.
  • s6-rc-compile does not support the -u or -g options anymore; instead, at any time, the user who can operate a s6-rc database is the user who owns the supervision tree.
  • 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.
  • The underlying s6 dependency needs a major version upgrade. It is recommended to first stop all your services, then upgrade s6 and s6-rc, then immediately restart your supervision tree, then start your services again. Failure to do so *will* cause issues if you're relying on s6-ftrigrd notifications (which is the case with services managed by s6-rc).

in 0.4.1.0

  • skalibs dependency bumped to 2.7.0.0.
  • execline dependency bumped to 2.5.0.1.
  • s6 dependency bumped to 2.7.2.0.
  • The max-death-tally and down-signal files, used by recent versions of s6, are now supported by s6-rc in a longrun definition directory.

in 0.4.0.1

  • s6 dependency bumped to 2.7.1.0.

in 0.4.0.0

  • skalibs dependency bumped to 2.6.3.0.
  • s6 dependency bumped to 2.6.2.0.
  • s6-rc-compile now accepts multiple lines in a consumer-for file: a longrun can now have multiple producers, which means that pipelines are really funnels. The compiled databases are not compatible with previous versions, and the source databases are not compatible either, because the pipeline-name file must now be present in the definition of the final consumer of a pipeline, not in the definition of a first producer (to avoid ambiguity). Edit your databases and recompile them.
  • New tool: s6-rc-format-upgrade

in 0.3.0.1

  • skalibs dependency bumped to 2.6.2.0.
  • execline dependency bumped to 2.3.0.4.
  • s6 dependency bumped to 2.6.2.0.
  • New -p option to s6-rc-init to allow using several live directories with the same scandir.
  • New command: s6-rc diff.
  • s6-rc-compile now guarantees that service numbers do not change if the source database does not change. This is useful for updates to the database format. You should recompile your service databases in preparation for the switch to s6-rc-0.4.0.0.

in 0.3.0.0

  • skalibs dependency bumped to 2.6.0.1.
  • execline dependency bumped to 2.3.0.3.
  • s6 dependency bumped to 2.6.1.1.
  • New -p option to s6-rc-init to allow using several live directories with the same scandir.
  • New command: s6-rc diff.

in 0.2.1.2

  • skalibs dependency bumped to 2.6.0.0.
  • execline dependency bumped to 2.3.0.2.
  • s6 dependency bumped to 2.6.1.0.

in 0.2.1.1

  • No functional changes.

in 0.2.1.0

  • skalibs dependency bumped to 2.5.1.1.
  • execline dependency bumped to 2.3.0.1.
  • s6 dependency bumped to 2.6.0.0.
  • s6-rc change now ensures that a longrun is down when its up transition fails.
  • s6-rc change now kills subprocesses waiting on a longrun transition when it receives a SIGINT or a SIGTERM.

in 0.2.0.1

  • skalibs dependency bumped to 2.5.1.0.
  • execline dependency bumped to 2.3.0.1.
  • s6 dependency bumped to 2.5.1.0.

in 0.2.0.0

  • skalibs dependency bumped to 2.5.0.0.
  • execline dependency bumped to 2.3.0.0.
  • s6 dependency bumped to 2.5.0.0.
  • s6-rc commands taking a lock on the live directory or the service database now fail instantly if the lock is already held. The new -b option makes them revert to the "block until the lock is released" behaviour.

in 0.1.0.0

  • skalibs dependency bumped to 2.4.0.0.
  • execline dependency bumped to 2.2.0.0.
  • s6 dependency bumped to 2.4.0.0.

in 0.0.3.0

  • skalibs dependency bumped to 2.3.10.0.
  • execline dependency bumped to 2.1.5.0.
  • s6 dependency bumped to 2.3.0.0.

in 0.0.2.1

  • s6 dependency bumped to 2.2.4.2.

in 0.0.2.0

  • Better exit codes for s6-rc-update.
  • skalibs dependency bumped to 2.3.8.3.
  • execline dependency bumped to 2.1.4.5.
  • s6 dependency bumped to 2.2.4.0.

in 0.0.1.5

  • skalibs dependency bumped to 2.3.8.2.
  • execline dependency bumped to 2.1.4.4.
  • s6 dependency bumped to 2.2.3.1.

in 0.0.1.4

  • No functional changes.

in 0.0.1.3

  • No functional changes.

in 0.0.1.2

  • GNU make dependency pushed back to 3.81.
  • skalibs dependency bumped to 2.3.8.0.
  • execline dependency bumped to 2.1.4.2.
  • s6 dependency bumped to 2.2.2.0.

in 0.0.1.1

  • skalibs dependency bumped to 2.3.7.1.
  • execline dependency bumped to 2.1.4.1.
  • s6 dependency bumped to 2.2.1.1.

in 0.0.1.0

  • Initial release.
s6-rc-0.5.1.1/doc/overview.html0000644000000000000000000002300013111013156012760 0ustar s6-rc: an overview

s6-rc
Software
skarnet.org

An overview of s6-rc

A manager for services

s6-rc is a service manager, or, in other words, a machine state manager: given a database of services, with dependencies between them, it can safely bring the global machine state, or live state, to the desired point, making sure dependencies are never broken.

The live state

The live state, by definition, is the tuple of all service states on the machine. Changing the live state means bringing services up, or bringing services down.

2.5 kinds of services

Supervision suites manage long-lived processes, a.k.a daemons, and sometimes call them services. With s6-rc, things are a little different: a long-lived process is also called a longrun and is a service, but a service does not have to be a longrun. There is a second kind of service, which is called a oneshot, and which represents a change of system state that is not embodied by the presence of a long-lived process. For instance, "mounting a filesystem" is a system state change, but in most cases there is no process hanging around while the filesystem is mounted.

s6-rc handles both oneshots and longruns.

  • A longrun is the exact equivalent of a service in the supervision sense. It is defined by a service directory, with a run script and optional other data. The service is considered up as long as the long-lived process is alive and, for daemons that support it, has notified its readiness. It is considered down otherwise.
  • A oneshot, on the other hand, is totally unknown from supervision suites, because there is no daemon to manage. A oneshot is represented by two short-lived scripts, up and down, used to bring the service respectively up and down. The service is considered up when the up program has exited successfully, and until the down program has exited successfully.

Services can depend on one another. If service A has been declared as depending on service B, then s6-rc will make sure to never start A until it knows that B is up, and will make sure to never stop B until it knows that A is down. This works whether A and B are both oneshots, both longruns, or a oneshot and a longrun.

Oneshots and longruns are called atomic services. By opposition to atomic services, s6-rc also handles an additional kind of service that it calls a bundle. A bundle is just a collection of atomic services, described under a single name. A bundle definition can even contain other bundles, but ultimately a bundle will always represent a set of one or more atomic services. Bundle names can be used anywhere with the s6-rc user interface, and they will internally be converted to a set of atomic services. An atomic service can depend on a bundle: it will simply depend on all the atomic services represented by the bundle. A bundle, however, cannot have dependencies.

A two-part operation

Unlike other service managers such as anopa, s6-rc separates the work of analyzing a set of service definitions, resolving dependencies, and so on, from the work of actually applying the dependency graph to perform live state changes. The former is the compilation phase, and is done offline; the latter is the live phase, and is of course done online - it impacts the actual state of the machine.

The compilation phase

  • Users are expected to write their service definitions - be it oneshots, longruns or bundles - in one or more source directories, in the s6-rc source format. The source format is simple to parse automatically - which is one of the main reasons why it has been designed that way - and it is also simple to generate automatically: it is easy to write converters from a given service definition format to the s6-rc source format.
  • Users then run the s6-rc-compile program, that takes a set of service definitions in one or more source directories and makes a compiled service database, abbreviated as compiled. This compiled should be stored by the administrator on the root filesystem.
  • The s6-rc-db tool can be used to examine compiled service databases and extract information from them in a human-friendly format.

The live phase

When the machine boots up:

  • First, the chosen init should make sure that a s6 supervision tree is up and running. s6-rc will only work if there is an active s6-svscan process monitoring a scan directory. On Linux, for instance, it is possible to achieve such a state by using an init created by the s6-linux-init-maker tool: when control reaches stage 2, s6-svscan is guaranteed to run, so using s6-rc in the stage 2 script is the way to go.
  • The boot process, let's name it stage2, should then call the s6-rc-init program. This program will set up an area for s6-rc in a writable directory (which can be on a RAM filesystem such as tmpfs) to host its live information such as the machine state, a working copy of all service directories for longruns, and a link to the current compiled state database. s6-rc-init initializes the machine state as "every declared service is down".
  • stage2 should then invoke the s6-rc program (s6-rc change) with, as arguments, the names of the services that should be brought up. Of course, bundles can be used for shortcuts.
  • That's it, the services are up and the initialization should be over. If the service database has been properly written, a stage2 script can actually be really short: an invocation of s6-rc-init and an invocation of s6-rc.

Other state changes and shutdown

The administrator can make changes to the live state of the machine by manually calling s6-rc again with the proper arguments. This is more powerful than the old runlevels: it is possible to change the live state to any set of services, not only predefined ones. The only thing that s6-rc will not allow is a state that would break service dependencies; it will always respect the dependency graph.

The s6-rc command is the central for machine state changes, and it is also true for shutdown. When shutting a machine down, all the services managed by s6-rc should be brought down in the proper order (via the s6-rc -da change command). Once all those services have been brought down successfully, the final shutdown procedure can take place; for instance, if s6-svscan is running as process 1 with the s6-linux-init defaults, s6-svscanctl -6 /run/service will kill the supervision tree and call /etc/rc.shutdown reboot, which should reboot the machine.

Live updates to the service database

The s6-rc command is a one-stop shop for service management as long as the compiled database doesn't change. If an administrator wishes to make a new compiled database the current live one, without rebooting the machine, a bit more work is needed, and that's the job of the s6-rc-update command. This command has been specifically written with Unix distributions in mind: when new packages ship, they come with new service definitions, or upgraded ones, and it is necessary to compile a new service database and update the live state so it matches; if source definitions for s6-rc are provided in the packages, an invocation of s6-rc-compile followed by an invocation of s6-rc-update should be all it takes to keep the live state up to date.

Live bundle modifications

It is possible to change bundle definitions in a compiled service database, including the live one, without recompiling everything by calling s6-rc-compile. The s6-rc-bundle tool can edit compiled databases to add bundles to them, or delete bundles from them.

s6-rc-0.5.1.1/doc/s6-rc-db.html0000644000000000000000000002012013111013156012427 0ustar s6-rc: the s6-rc-db program

s6-rc
Software
skarnet.org

The s6-rc-db program

s6-rc-db is a tool to analyze a compiled service database and extract information from it, and print it in a user-friendly format.

It is an offline tool, i.e. you can run it on any compiled service database without actually having a live set of services managed by s6-rc. However, if you do have a live set, you can still run s6-rc-db on the current database (and it is the default); it won't interfere with your normal service operation.

Interface 

     s6-rc-db help
     s6-rc-db [ -l live ] [ -c compiled ] [ -b ] check
     s6-rc-db [ -l live ] [ -c compiled ] [ -b ] list all|services|oneshots|longruns|bundles
     s6-rc-db [ -l live ] [ -c compiled ] [ -b ] type servicename
     s6-rc-db [ -l live ] [ -c compiled ] [ -b ] [ -u | -d ] timeout atomicname
     s6-rc-db [ -l live ] [ -c compiled ] [ -b ] contents bundlename
     s6-rc-db [ -l live ] [ -c compiled ] [ -b ] [ -u | -d ] dependencies servicename
     s6-rc-db [ -l live ] [ -c compiled ] [ -b ] pipeline longrunname
     s6-rc-db [ -l live ] [ -c compiled ] [ -b ] [ -u | -d ] script oneshotname
     s6-rc-db [ -l live ] [ -c compiled ] [ -b ] flags atomicname
     s6-rc-db [ -l live ] [ -c compiled ] [ -b ] atomics servicename...
     s6-rc-db [ -l live ] [ -c compiled ] [ -b ] [ -u | -d ] all-dependencies servicename...
  • s6-rc-db expects to find a compiled service database in compiled; by default it uses the service database used by the live state in live. It reads and parses the compiled database it finds; depending on its arguments, it prints the requested information to stdout, then exits 0.

Options

  • -c compiled : examine a compiled service database in compiled instead of the current live one.
  • -l live : assume the live state is in live. This option is ignored if the -c option has been given. Default is /run/s6-rc. The default can be changed at package compilation time, by giving the --livedir=live option to ./configure.
  • -u : for commands that use different data depending on whether it's about bringing the service up or down, select the "up" data (this is the default). This option is ignored when it is irrelevant.
  • -d : for commands that use different data depending on whether it's about bringing the service up or down, select the "down" data. This option is ignored when it is irrelevant.
  • -b : blocking lock. If the database is currently being used by another program, s6-rc-db will wait until that other program has released its lock on the database, then proceed. By default, s6-rc-db fails with an error message if the database is currently in use.

Exit codes

  • 0: success
  • 3: identifier not found in service database
  • 4: invalid or corrupted service database
  • 5: wrong identifier type for the given command
  • 100: wrong usage
  • 111: system call failed

Subcommands

s6-rc-db help

Prints a help message on stdout.

s6-rc-db check

Checks the database consistency. Exits 4 with an error message if it finds a problem, such as a mismatch in the direct and reverse dependency tables, or a dependency cycle.

s6-rc-db list

Lists all services of a given type. This subcommand takes a second subcommand:

s6-rc-db list all

Lists everything - atomic services and bundles - contained in the database.

s6-rc-db list services

Lists all atomic services.

s6-rc-db list oneshots

Lists oneshots.

s6-rc-db list longruns

Lists longruns.

s6-rc-db list bundles

Lists all bundles.

s6-rc-db type servicename

Prints the type of servicename: oneshot, longrun or bundle.

s6-rc-db timeout atomicname

Prints the timeout value, in milliseconds, after which bringing atomicname up or down is considered a failure if the called script still has not succeeded. By default, or if the -u option has been given to s6-rc-db, the timeout for up is printed; the timeout for down is printed instead if the -d option has been given.

s6-rc-db contents bundlename

Lists the atomic services represented by bundle bundlename.

s6-rc-db dependencies servicename

Prints the list of direct dependencies for servicename. If servicename is a bundle, its set of direct dependencies is the union of the direct dependencies of all the atomic services contained in the bundle.

If the -d option has been given to s6-rc-db, the reverse dependencies are given instead: services that directly depend on servicename, or on one of its components if it is a bundle.

s6-rc-db pipeline longrunname

Prints the longrun service pipeline longrunname is a part of, one service per line, producers before consumers. If longrunname isn't part of a pipeline, only longrunname is printed.

s6-rc-db script oneshotname

Prints the up script for oneshotname, which is an argv, i.e. a Unix command line. Each component of this command line is terminated by a null character, so to print it in a human-readable format, pipe the output into something like xargs -0 echo.

If the -d option has been given to s6-rc-db, the down script is printed instead.

s6-rc-db flags atomicname

Prints a hexadecimal number that is the list of all binary flags for atomic service atomicname.

Those binary flags are currently unused, but this may change in a future version of s6-rc.

s6-rc-db atomics servicename...

Prints the fully resolved list of services represented by the servicename... arguments, i.e. the union of all atomic services contained in servicename.... Each argument in servicename... can be an atomic service or a bundle.

s6-rc-db all-dependencies servicename...

Prints the list of all atomic services needed to bring up all of the servicename... arguments, with all their dependencies, recursively. In other words: for servicename... to be up, every single service listed in the output will need to be up. The output includes the atomic services represented by the servicename... arguments themselves.

The list is not topologically sorted.

If the -d option has been given to s6-rc-db, the recursive list of reverse dependencies is printed: for servicename... to be down, every single service listed in the output will need to be down.

s6-rc-0.5.1.1/doc/s6-rc-oneshot-run.html0000644000000000000000000000453613147046574014363 0ustar s6-rc: the s6-rc-oneshot-run program

s6-rc
Software
skarnet.org

The s6-rc-oneshot-run internal program

s6-rc-oneshot-run executes a oneshot service's up or down script taken from the current live compiled database.

s6-rc-oneshot-run is not meant to be used directly; it is used in internal scripts created by s6-rc-compile, which are invoked during an s6-rc execution.

Interface 

     s6-rc-oneshot-run [ -l live ] [ -b ] up|down n
  • s6-rc-oneshot-run executes into the up or down script of the nth oneshot service defined in the current compiled service database (i.e. the compiled linked from the live directory).

Options

  • -l live : use the live directory in live. Default is /run/s6-rc, or what was given to the --livedir configure option at compile time.
  • -b : blocking lock. If the service database is currently being used by another program, s6-rc-oneshot-run will wait until that other program has released its lock on the database, then proceed. By default, s6-rc-oneshot-run fails with an error message if the database is currently in use.

Exit codes

  • 3: invalid service number
  • 4: invalid service database
  • 100: wrong usage
  • 111: system call failed
  • 126: cannot exec script
  • 127: cannot exec script: executable not found
  • other exit codes: returned from the executed up or down script
s6-rc-0.5.1.1/doc/s6-rc-init.html0000644000000000000000000001557413405476613013047 0ustar s6-rc: the s6-rc-init program

s6-rc
Software
skarnet.org

The s6-rc-init program

s6-rc-init is an initialization tool for the s6-rc system. It must be run as root, at boot time, prior to any invocation of the s6-rc binary.

Interface 

     s6-rc-init [ -c compiled ] [ -l live ] [ -p prefix ] [ -t timeout ] [ -b ] [ -d ] scandir
  • compiled (if the -d option hasn't been given), live and scandir must be absolute paths.
  • s6-rc-init expects to find a compiled service database in compiled. It expects to be able to create a directory named live. It also expects that an instance of s6-svscan is running on scandir.
  • s6-rc-init initializes the live state in live. It declares compiled as the current service database and sets the state as "all services down".
  • It then copies verbatim all the service directories declared by compiled into a subdirectory of live, adds ./down files to the live copies and links those live copies into scandir. It then triggers s6-svscan, which will pick up the new service directories and start s6-supervise processes on them - but the service themselves will not be started right away, because of the ./down files.
  • s6-rc-init waits for all s6-supervise processes to be operational, then exits 0.

Options

  • -t timeout : if all s6-supervise processes are not up and running after timeout milliseconds, s6-rc-init will complain and exit 111. This is a safety feature so s6-rc-init doesn't hang indefinitely on a nonworking installation; normally this initialization should not take more than a few milliseconds.
  • -c compiled : declare compiled as the current compiled service database for the upcoming live state. Default is /etc/s6-rc/compiled.
  • -l live : Store the live state into the live directory, which should not exist prior to running s6-rc-init, but should be under a writable filesystem - likely a RAM filesystem. Default is /run/s6-rc. The default can be changed at compile time by giving the --livedir=live option to ./configure.
  • -p prefix : when linking all the service directory into scandir, prepend the symbolic link names with prefix, i.e. a longrun named A will have its service directory accessible via scandir/prefixA. This allows several live directories to be used with a unique scandir without risking conflicts between longruns with the same name from different service databases. This option is only useful if you intend to have several sets of services independently managed by s6-rc, with different live directories, all using the same scandir to supervise their longruns. The default is no prefix at all, which is good when you only have one live directory.
  • -b : blocking lock. If the database is currently being used by another program, s6-rc-init will wait until that other program has released its lock on the database, then proceed. By default, s6-rc-init fails with an error message if the database is currently in use.
  • -d : dereference compiled. Fully resolve the compiled path before declaring it as the current compiled service database for the upcoming live state. This allows compiled to be a symlink that can be updated later without impacting the current live state. Using this flag in your init scripts' s6-rc-init invocation means that it's possible to boot on a compiled service database whose validity has not previously been guaranteed by a successful s6-rc-update invocation: you should know what you are doing.

Typical usage

Administrators should invoke s6-rc-init once, in their early boot scripts, after s6-svscan is functional and ready to supervise longrun services (and after its catch-all logger, if any, has started), but before any other initialization. (The rest of the initialization can be written as a set of s6-rc services, and performed by just one invocation of the s6-rc change command.)

For instance, when using an init created by s6-linux-init, s6-rc-init should be the first command in the stage2 (by default /etc/rc.init) script.

Notes

  • The directory created by s6-rc-init will actually be called live:initial, and live will be a symbolic link to that directory. Users should ignore this, and always refer to the live directory as live in their future s6-rc or s6-rc-update invocations. The reason for this behaviour is that s6-rc-update creates another, similarly named, directory (live:suffix) and updates the live state by atomically changing the target of the live symlink - so live will not change names, whereas the real directory may.)
  • Similarly, it is recommended that administrators store their compiled service databases into some versioned directory, and that compiled be a symbolic link to the database currently in use. This will make it easier to create new compiled databases and switch them with s6-rc-update without having to change the s6-rc-init invocation in boot scripts.
  • After s6-rc-init runs, compiled has become the "live compiled database", and must not be tampered with or deleted. The only way to free it for deletion is to replace it with another database, via a call to s6-rc-update.