[PATCH 3/4] Add sigpending, sigsuspend, sigwait, sigwaitinfo, sigtimedwait and raise

--- luxio.c | 276 +++++++++++++++++++++++++++++++++++++------- tests/test-sigpending.lua | 17 +++ tests/test-sigsuspend.lua | 15 +++ tests/test-sigtimedwait.lua | 37 ++++++ tests/test-sigwait.lua | 21 ++++ tests/test-sigwaitinfo.lua | 21 ++++ 6 files changed, 347 insertions(+), 40 deletions(-) create mode 100644 tests/test-sigpending.lua create mode 100644 tests/test-sigsuspend.lua create mode 100644 tests/test-sigtimedwait.lua create mode 100644 tests/test-sigwait.lua create mode 100644 tests/test-sigwaitinfo.lua diff --git a/luxio.c b/luxio.c index 0db4979..0f729ae 100644 --- a/luxio.c +++ b/luxio.c @@ -606,10 +606,12 @@ luxio_sigdelset(lua_State *L) /*** Check whether a signal set contains a given signal. -Return 0 on success, or -1 on error with errno set appropriately. +Return 1 if signal is a member of the set, or 0 if the signal is +not a member of the set. A return value of -1 indicates that an error +occurred and errno will be set accordingly. -@tparam sigset signal set -@tparam number signo signal +@tparam sigset set +@tparam number signal @treturn number return value @treturn errno errno @function sigismember @@ -640,54 +642,58 @@ static struct { bool sigaction; } luxio__signal_ctx; -static void luxio__sigaction_hook(lua_State *L, lua_Debug *ar) +static void luxio__push_siginfo_table(lua_State *L, const siginfo_t *info) { - int nargs = 1; + lua_newtable(L); - /* Push the callback onto the stack using the Lua reference we */ - /* stored in the registry */ - lua_rawgeti(L, LUA_REGISTRYINDEX, - luxio__signal_ctx.handlers[luxio__signal_ctx.signo].handler_fn); - lua_pushinteger(L, luxio__signal_ctx.signo); + lua_pushinteger(L, info->si_signo); + lua_setfield(L, -2, "si_signo"); - if (luxio__signal_ctx.sigaction) { - nargs++; + lua_pushinteger(L, info->si_code); + lua_setfield(L, -2, "si_code"); - if (luxio__signal_ctx.isinfo) { - siginfo_t *info = &luxio__signal_ctx.info; - lua_newtable(L); + lua_pushinteger(L, info->si_errno); + lua_setfield(L, -2, "si_errno"); + + lua_pushinteger(L, info->si_pid); + lua_setfield(L, -2, "si_pid"); - lua_pushinteger(L, info->si_signo); - lua_setfield(L, -2, "si_signo"); + lua_pushinteger(L, info->si_uid); + lua_setfield(L, -2, "si_uid"); - lua_pushinteger(L, info->si_code); - lua_setfield(L, -2, "si_code"); + lua_pushinteger(L, info->si_utime); + lua_setfield(L, -2, "si_utime"); - lua_pushinteger(L, info->si_errno); - lua_setfield(L, -2, "si_errno"); + lua_pushinteger(L, info->si_stime); + lua_setfield(L, -2, "si_stime"); - lua_pushinteger(L, info->si_pid); - lua_setfield(L, -2, "si_pid"); + lua_pushinteger(L, (lua_Integer) info->si_addr); + lua_setfield(L, -2, "si_addr"); - lua_pushinteger(L, info->si_uid); - lua_setfield(L, -2, "si_uid"); + lua_pushinteger(L, info->si_status); + lua_setfield(L, -2, "si_status"); - lua_pushinteger(L, info->si_utime); - lua_setfield(L, -2, "si_utime"); +#ifdef __linux__ + lua_pushinteger(L, info->si_band); + lua_setfield(L, -2, "si_band"); +#endif +} - lua_pushinteger(L, info->si_stime); - lua_setfield(L, -2, "si_stime"); +static void luxio__sigaction_hook(lua_State *L, lua_Debug *ar) +{ + int nargs = 1; - lua_pushinteger(L, (lua_Integer) info->si_addr); - lua_setfield(L, -2, "si_addr"); + /* Push the callback onto the stack using the Lua reference we */ + /* stored in the registry */ + lua_rawgeti(L, LUA_REGISTRYINDEX, + luxio__signal_ctx.handlers[luxio__signal_ctx.signo].handler_fn); + lua_pushinteger(L, luxio__signal_ctx.signo); - lua_pushinteger(L, info->si_status); - lua_setfield(L, -2, "si_status"); + if (luxio__signal_ctx.sigaction) { + nargs++; -#ifdef __linux__ - lua_pushinteger(L, info->si_band); - lua_setfield(L, -2, "si_band"); -#endif + if (luxio__signal_ctx.isinfo) { + luxio__push_siginfo_table(L, &luxio__signal_ctx.info); } else { lua_pushnil(L); } @@ -934,9 +940,190 @@ luxio_sigprocmask(lua_State *L) return 2; } -/* TODO: sigpending() 3.3.6 */ -/* TODO: sigsuspend() 3.3.7 */ -/* TODO: sigwait(), sigwaitinfo(), sigtimedwait() 3.3.8 */ +/*** Send a signal to the calling process. + +@tparam sig signal The signal to send +@treturn number return value +@treturn errno +@function raise +*/ +static int +luxio_raise(lua_State *L) +{ + int sig = luaL_checkinteger(L, 1); + + lua_pushinteger(L, raise(sig)); + lua_pushinteger(L, errno); + return 2; +} + +/*** Return set of signals pending for the calling process. + +@treturn sigset|nil set of pending signals, or nil on error +@treturn errno +@function sigpending +*/ +static int +luxio_sigpending(lua_State *L) +{ + sigset_t s; + luxio_signalset *pending; + + if (sigpending(&s) == -1) { + lua_pushinteger(L, -1); + } else { + pending = lua_newuserdata(L, sizeof(*pending)); + pending->set = s; + luxio__bless_signalset(L); + } + + lua_pushinteger(L, errno); + return 2; +} + +/*** Suspend execution of calling process until signal is delivered. + +sigsuspend temporarily replaces the signal mask of the calling +process with another mask until delivery of a signal that is not +masked occurs. sigsuspend always returns -1, with errno set to +indicate the error (which is generally EINTR). Upon returning +sigsuspend will restore the original signal mask that was replaced. + +@tparam set mask +@treturn number return value +@treturn errno +@function sigsuspend +*/ +static int +luxio_sigsuspend(lua_State *L) +{ + luxio_signalset *s = luaL_checkudata(L, 1, LUXIO_SIGNALSET_METATABLE); + + lua_pushinteger(L, sigsuspend(&s->set)); + lua_pushinteger(L, errno); + return 2; +} + +/*** Suspend execution of calling process until signal becomes pending. + +sigwait temporarily waits for any one of the signals provided in +the set parameter to become pending. The signal that becomes +pending will be removed from the set. On success the pending signal +will be returned, otherwise nil is returned and errno is set accordingly. + +@tparam set set of signals to wait on +@treturn number|nil signal, or nil on error +@treturn errno +@function sigwait +*/ +static int +luxio_sigwait(lua_State *L) +{ + luxio_signalset *s = luaL_checkudata(L, 1, LUXIO_SIGNALSET_METATABLE); + int sig; + + if (sigwait(&s->set, &sig) == -1) { + lua_pushnil(L); + } else { + lua_pushinteger(L, sig); + } + + lua_pushinteger(L, errno); + return 2; +} + +#ifdef __linux__ +/*** Suspend execution of calling process until signal becomes pending. + +Linux only. + +sigwaitinfo suspends execution of the calling process until one of +the signals provided in the set parameter is pending. If one of +the signals is already pending then sigwaitinfo will return without +suspending execution. + +sigwaitinfo returns the info table for the signal that was received +and removes that signal from the set argument. + +If multiple signals are pending then the signal returned by sigwaitinfo is +determined using the usual rules detailed in signal(7). + +@tparam set set of signals to wait on +@treturn sigwaitinfo-table|nil signal info table, or nil on error +@treturn errno +@function sigwaitinfo +*/ + +/*** sigwaitinfo() table +@table sigwaitinfo-table +@field si_signo Signal number +@field si_code Signal code +@field si_errno An errno value +@field si_pid Sending process ID +@field si_uid Real user ID of sending process +@field si_utime User time consumed +@field si_stime System time consumed +@field si_addr Memory location which caused fault +@field si_status Exit value or signal +@field si_band Band event (Linux only) +*/ + +static int +luxio_sigwaitinfo(lua_State *L) +{ + luxio_signalset *s = luaL_checkudata(L, 1, LUXIO_SIGNALSET_METATABLE); + siginfo_t info; + + if (sigwaitinfo(&s->set, &info) == -1) { + lua_pushnil(L); + } else { + luxio__push_siginfo_table(L, &info); + } + + lua_pushinteger(L, errno); + return 2; +} + +/*** Suspend execution of process for a given time period +or until signal is delivered. + +Linux only. + +sigtimedwait behaves exactly as sigwaitinfo but will suspend execution +for a given time period specified by the (seconds, nanoseconds) arguments. +If both of the (seconds, nanoseconds) arguments are 0 then the function +polls for pending signals rather than suspending execution until a signal +becomes pending. On success a signal info table for the pending signal +is returned, otherwise nil is returned and errno is set accordingly. + +@tparam set set of signals to wait on +@tparam number seconds +@tparam number nanoseconds +@treturn sigwaitinfo-table|nil signal info table, or nil on error +@treturn errno +@function sigtimedwait +*/ + +static int +luxio_sigtimedwait(lua_State *L) +{ + luxio_signalset *s = luaL_checkudata(L, 1, LUXIO_SIGNALSET_METATABLE); + siginfo_t info; + time_t tv_secs = luaL_checkinteger(L, 2); + long tv_nsec = luaL_checkinteger(L, 3); + struct timespec timeout = { tv_secs, tv_nsec }; + + if (sigtimedwait(&s->set, &info, &timeout) == -1) { + lua_pushnil(L); + } else { + luxio__push_siginfo_table(L, &info); + } + + lua_pushinteger(L, errno); + return 2; +} +#endif + /* TODO: sigqueue() 3.3.9 */ /* TODO: pthread_kill() 3.3.10 */ @@ -3827,6 +4014,7 @@ luxio_gai_strerror(lua_State *L) @tparam[opt=AF_UNSPEC] number ai_family @tparam[opt=0] number ai_socktype @tparam[opt=0] number ai_protocol +@treturn number return value @treturn errno|table table of result `addrinfo` entries @function getaddrinfo */ @@ -5023,7 +5211,15 @@ luxio_functions[] = { { "sigaction", luxio_sigaction }, { "sigprocmask", luxio_sigprocmask }, + { "sigpending", luxio_sigpending }, + { "sigsuspend", luxio_sigsuspend }, + { "sigwait", luxio_sigwait }, +#ifdef __linux__ + { "sigwaitinfo", luxio_sigwaitinfo }, + { "sigtimedwait", luxio_sigtimedwait }, +#endif + { "raise", luxio_raise }, { "alarm", luxio_alarm }, { "pause", luxio_pause }, { "sleep", luxio_sleep }, diff --git a/tests/test-sigpending.lua b/tests/test-sigpending.lua new file mode 100644 index 0000000..43136b1 --- /dev/null +++ b/tests/test-sigpending.lua @@ -0,0 +1,17 @@ +local l = require "luxio" + +s = l.newsigset() +l.sigemptyset(s) +l.sigaddset(s, l.SIGUSR1) +l.sigprocmask(l.SIG_BLOCK, s) +l.raise(l.SIGUSR1) + +pending = l.sigpending() + +present, errno = l.sigismember(pending, l.SIGUSR1) + +if present == 1 then + print("PASS") +else + print("FAIL") +end diff --git a/tests/test-sigsuspend.lua b/tests/test-sigsuspend.lua new file mode 100644 index 0000000..5c85e77 --- /dev/null +++ b/tests/test-sigsuspend.lua @@ -0,0 +1,15 @@ +local l = require "luxio" + +function handler() + return +end + +l.sigaction(l.SIGINT, {["sa_handler"] = handler}) + +s = l.newsigset() +l.sigfillset(s) +l.sigdelset(s, l.SIGINT) +print("Press CTRL-C...") +l.sigsuspend(s) + +print("PASS") diff --git a/tests/test-sigtimedwait.lua b/tests/test-sigtimedwait.lua new file mode 100644 index 0000000..0311a50 --- /dev/null +++ b/tests/test-sigtimedwait.lua @@ -0,0 +1,37 @@ +local l = require "luxio" + +function handler() + return +end + +l.sigaction(l.SIGINT, {["sa_handler"] = handler}) + +s = l.newsigset() +l.sigemptyset(s) +l.sigaddset(s, l.SIGINT) + +info, errno = l.sigtimedwait(s, 0, 0) + +if not (info == nil and errno == l.EAGAIN) then + print("FAIL") +end + +print("Wait...") +pid, errno = l.fork() +if pid == 0 then + l.sleep(5) + print("Press CTRL-C...") + os.exit(0) +elseif pid == -1 then + io.stderr:write(("fork: %s\n"):format(l.strerror(errno))) + os.exit(2) +end + +seconds = 3600 +info, errno = l.sigtimedwait(s, seconds, 0) + +if info ~= nil and info["si_signo"] == l.SIGINT then + print("PASS") +else + print(("FAIL (expected sig to be %d but it is %d)"):format(l.SIGINT, info["si_signo"])) +end diff --git a/tests/test-sigwait.lua b/tests/test-sigwait.lua new file mode 100644 index 0000000..bbd2378 --- /dev/null +++ b/tests/test-sigwait.lua @@ -0,0 +1,21 @@ +local l = require "luxio" + +function handler() + return +end + +l.sigaction(l.SIGINT, {["sa_handler"] = handler}) + +s = l.newsigset() +l.sigemptyset(s) +l.sigaddset(s, l.SIGINT) +print("Press CTRL-C...") + + +sig, errno = l.sigwait(s, l.SIGINT) + +if sig == l.SIGINT then + print("PASS") +else + print(("FAIL (expected sig to be %d but it is %d)"):format(l.SIGINT, sig)) +end diff --git a/tests/test-sigwaitinfo.lua b/tests/test-sigwaitinfo.lua new file mode 100644 index 0000000..242b444 --- /dev/null +++ b/tests/test-sigwaitinfo.lua @@ -0,0 +1,21 @@ +local l = require "luxio" + +function handler() + return +end + +l.sigaction(l.SIGINT, {["sa_handler"] = handler}) + +s = l.newsigset() +l.sigemptyset(s) +l.sigaddset(s, l.SIGINT) +print("Press CTRL-C...") + + +info, errno = l.sigwaitinfo(s) + +if info ~= nil and info["si_signo"] == l.SIGINT then + print("PASS") +else + print(("FAIL (expected sig to be %d but it is %d)"):format(l.SIGINT, info["si_signo"])) +end -- 2.11.0