File Coverage

lib/Linux/FD.xs
Criterion Covered Total %
statement 117 149 78.5
branch 67 136 49.2
condition n/a
subroutine n/a
pod n/a
total 184 285 64.5


line stmt bran cond sub pod time code
1             #ifndef _GNU_SOURCE
2             # define _GNU_SOURCE
3             #endif
4             #define GNU_STRERROR_R
5              
6             #include
7              
8             #include
9             #include
10             #include
11              
12             #define PERL_NO_GET_CONTEXT
13             #define PERL_REENTR_API 1
14             #include "EXTERN.h"
15             #include "perl.h"
16             #include "XSUB.h"
17             #include "ppport.h"
18              
19             #define get_fd(self) PerlIO_fileno(IoOFP(sv_2io(SvRV(self))));
20              
21             #define die_sys(format) Perl_croak(aTHX_ format, strerror(errno))
22              
23 2           static sigset_t* S_sv_to_sigset(pTHX_ SV* sigmask, const char* name) {
24             IV tmp;
25 1 50         if (!SvOK(sigmask))
    0          
    0          
26             return NULL;
27 1 50         if (!SvROK(sigmask) || !sv_derived_from(sigmask, "POSIX::SigSet"))
    50          
28 0           Perl_croak(aTHX_ "%s is not of type POSIX::SigSet");
29             #if PERL_VERSION > 15 || PERL_VERSION == 15 && PERL_SUBVERSION > 2
30 1 50         return (sigset_t *) SvPV_nolen(SvRV(sigmask));
31             #else
32             tmp = SvIV((SV*)SvRV(sigmask));
33             return INT2PTR(sigset_t*, tmp);
34             #endif
35             }
36             #define sv_to_sigset(sigmask, name) S_sv_to_sigset(aTHX_ sigmask, name)
37              
38 6           static sigset_t* S_get_sigset(pTHX_ SV* signal, const char* name) {
39 3 100         if (SvROK(signal))
40 1           return sv_to_sigset(signal, name);
41             else {
42 2 100         int signo = (SvIOK(signal) || looks_like_number(signal)) && SvIV(signal) ? SvIV(signal) : whichsig(SvPV_nolen(signal));
    50          
    50          
    50          
    0          
    50          
    50          
43 2           SV* buffer = sv_2mortal(newSVpvn("", 0));
44 2 50         SvGROW(buffer, sizeof(sigset_t));
    50          
45 2 50         sigset_t* ret = (sigset_t*)SvPV_nolen(buffer);
46 2           sigemptyset(ret);
47 2           sigaddset(ret, signo);
48             return ret;
49             }
50             }
51             #define get_sigset(sigmask, name) S_get_sigset(aTHX_ sigmask, name)
52              
53             #define NANO_SECONDS 1000000000
54              
55             static NV timespec_to_nv(struct timespec* time) {
56 4           return time->tv_sec + time->tv_nsec / (double)NANO_SECONDS;
57             }
58              
59             static void nv_to_timespec(NV input, struct timespec* output) {
60 4           output->tv_sec = (time_t) floor(input);
61 4           output->tv_nsec = (long) ((input - output->tv_sec) * NANO_SECONDS);
62             }
63              
64             typedef struct { const char* key; clockid_t value; } map[];
65              
66             static map clocks = {
67             { "monotonic" , CLOCK_MONOTONIC },
68             { "realtime" , CLOCK_REALTIME },
69             { "boottime" , CLOCK_BOOTTIME },
70             { "realtime_alarm", CLOCK_REALTIME_ALARM },
71             { "boottime_alarm", CLOCK_BOOTTIME_ALARM },
72             };
73              
74 1           static clockid_t S_get_clockid(pTHX_ const char* clock_name) {
75             int i;
76 2 50         for (i = 0; i < sizeof clocks / sizeof *clocks; ++i) {
77 2 100         if (strEQ(clock_name, clocks[i].key))
78 1           return clocks[i].value;
79             }
80 0           Perl_croak(aTHX_ "No such timer '%s' known", clock_name);
81             }
82             #define get_clockid(name) S_get_clockid(aTHX_ name)
83              
84 0           static clockid_t S_get_clock(pTHX_ SV* ref, const char* funcname) {
85             SV* value;
86 0 0         if (!SvROK(ref) || !(value = SvRV(ref)))
    0          
87 0           Perl_croak(aTHX_ "Could not %s: this variable is not a clock", funcname);
88 0 0         return SvIV(value);
89             }
90             #define get_clock(ref, func) S_get_clock(aTHX_ ref, func)
91              
92 6           static SV* S_io_fdopen(pTHX_ int fd, const char* classname, char type) {
93 6           PerlIO* pio = PerlIO_fdopen(fd, "r");
94 6           GV* gv = newGVgen(classname);
95 6           SV* ret = newRV_noinc((SV*)gv);
96 6 50         IO* io = GvIOn(gv);
    50          
    50          
    50          
97 6           HV* stash = gv_stashpv(classname, FALSE);
98 6           IoTYPE(io) = type;
99 6           IoIFP(io) = pio;
100 6           IoOFP(io) = pio;
101 6           sv_bless(ret, stash);
102 6           return ret;
103             }
104             #define io_fdopen(fd, classname, type) S_io_fdopen(aTHX_ fd, classname, type)
105              
106             #define SET_HASH_IMPL(key,value) hv_store(hash, key, sizeof key - 1, value, 0)
107             #define SET_HASH_U(key) SET_HASH_IMPL(#key, newSVuv(buffer.ssi_##key))
108             #define SET_HASH_I(key) SET_HASH_IMPL(#key, newSViv(buffer.ssi_##key))
109              
110 5           static UV S_get_flag(pTHX_ map flags, size_t map_size, SV* flag_name) {
111             int i;
112 6 50         for (i = 0; i < map_size / sizeof *flags; ++i)
113 6 50         if (strEQ(SvPV_nolen(flag_name), flags[i].key))
    100          
114 5           return flags[i].value;
115 0           Perl_croak(aTHX_ "No such flag '%s' known", flag_name);
116             }
117             #define get_flag(map, name) S_get_flag(aTHX_ map, sizeof(map), name)
118              
119             static map event_flags = {
120             { "non-blocking" , EFD_NONBLOCK },
121             { "semaphore" , EFD_SEMAPHORE },
122             };
123             #define get_event_flag(name) get_flag(event_flags, name)
124              
125 2           static SV* S_new_eventfd(pTHX_ const char* classname, UV initial, int flags) {
126 2           int fd = eventfd(initial, flags);
127 2 50         if (fd < 0)
128 0           die_sys("Can't open eventfd descriptor: %s");
129 2           return io_fdopen(fd, classname, '|');
130             }
131             #define new_eventfd(classname, initial, flags) S_new_eventfd(aTHX_ classname, initial, flags)
132              
133             static map signal_flags = {
134             { "non-blocking" , SFD_NONBLOCK },
135             };
136             #define get_signal_flag(name) get_flag(signal_flags, name)
137              
138 3           static SV* S_new_signalfd(pTHX_ const char* classname, SV* sigmask, int flags) {
139 3           int fd = signalfd(-1, get_sigset(sigmask, "signalfd"), flags);
140 3 50         if (fd < 0)
141 0           die_sys("Can't open signalfd descriptor: %s");
142 3           return io_fdopen(fd, classname, '<');
143             }
144             #define new_signalfd(classname, sigset, flags) S_new_signalfd(aTHX_ classname, sigset, flags)
145              
146             static map timer_flags = {
147             { "non-blocking" , TFD_NONBLOCK },
148             };
149             #define get_timer_flag(name) get_flag(timer_flags, name)
150              
151 1           static SV* S_new_timerfd(pTHX_ const char* classname, SV* clock, int flags, const char* funcname) {
152 1 50         clockid_t clock_id = SvROK(clock) ? get_clock(clock, funcname) : get_clockid(SvPV_nolen(clock));
    50          
153 1           int fd = timerfd_create(clock_id, flags);
154 1 50         if (fd < 0)
155 0           die_sys("Can't open timerfd descriptor: %s");
156 1           return io_fdopen(fd, classname, '<');
157             }
158             #define new_timerfd(classname, clock, flags, func) S_new_timerfd(aTHX_ classname, clock, flags, func)
159              
160 13           static int S_interrupted(pTHX_ int value) {
161 13 100         if (value == -1 && errno == EINTR) {
    50          
162 0 0         PERL_ASYNC_CHECK();
163             return 1;
164             }
165             return 0;
166             }
167             #define interrupted(value) S_interrupted(aTHX_ value)
168              
169             MODULE = Linux::FD PACKAGE = Linux::FD
170              
171             BOOT:
172 3           load_module(PERL_LOADMOD_NOIMPORT, newSVpvs("IO::Handle"), NULL);
173 3           av_push(get_av("Linux::FD::Event::ISA" , GV_ADD), newSVpvs("IO::Handle"));
174 3           av_push(get_av("Linux::FD::Signal::ISA", GV_ADD), newSVpvs("IO::Handle"));
175 3           av_push(get_av("Linux::FD::Timer::ISA" , GV_ADD), newSVpvs("IO::Handle"));
176              
177             SV*
178             eventfd(initial = 0, ...)
179             UV initial;
180             PREINIT:
181             int i, flags = EFD_CLOEXEC;
182             CODE:
183 5 100         for (i = 1; i < items; i++)
184 3           flags |= get_event_flag(ST(i));
185 2           RETVAL = new_eventfd("Linux::FD::Event", initial, flags);
186             OUTPUT:
187             RETVAL
188              
189             SV*
190             signalfd(sigmask, ...)
191             SV* sigmask;
192             PREINIT:
193             int i, flags = SFD_CLOEXEC;
194             CODE:
195 4 100         for (i = 1; i < items; i++)
196 1           flags |= get_signal_flag(ST(i));
197 3           RETVAL = new_signalfd("Linux::FD::Signal", sigmask, flags);
198             OUTPUT:
199             RETVAL
200              
201             SV*
202             timerfd(clock, ...)
203             SV* clock;
204             PREINIT:
205             int i, flags = TFD_CLOEXEC;
206             CODE:
207 2 100         for (i = 1; i < items; i++)
208 1           flags |= get_timer_flag(ST(i));
209 1           RETVAL = new_timerfd("Linux::FD::Timer", clock, flags, "timerfd");
210             OUTPUT:
211             RETVAL
212              
213             MODULE = Linux::FD PACKAGE = Linux::FD::Event
214              
215             SV*
216             new(classname, initial = 0, ...)
217             const char* classname;
218             UV initial;
219             PREINIT:
220             int i, flags = EFD_CLOEXEC;
221             CODE:
222 0 0         for (i = 2; i < items; i++)
223 0           flags |= get_event_flag(ST(i));
224 0           RETVAL = new_eventfd(classname, initial, flags);
225             OUTPUT:
226             RETVAL
227              
228             UV
229             get(self)
230             SV* self;
231             PREINIT:
232             uint64_t buffer;
233             int ret, events;
234             CODE:
235 6           events = get_fd(self);
236             do {
237 6           ret = read(events, &buffer, sizeof buffer);
238 6 50         } while (interrupted(ret));
239 6 100         if (ret == -1) {
240 3 50         if (errno == EAGAIN)
241 3           XSRETURN_EMPTY;
242             else
243 0           die_sys("Couldn't read from eventfd: %s");
244             }
245 3           RETVAL = buffer;
246             OUTPUT:
247             RETVAL
248              
249             UV
250             add(self, value)
251             SV* self;
252             UV value;
253             PREINIT:
254             uint64_t buffer;
255             int ret, events;
256             CODE:
257 2           events = get_fd(self);
258 2           buffer = value;
259             do {
260 2           ret = write(events, &buffer, sizeof buffer);
261 2 50         } while (interrupted(ret));
262 2 50         if (ret == -1) {
263 0 0         if (errno == EAGAIN)
264 0           XSRETURN_EMPTY;
265             else
266 0           die_sys("Couldn't write to eventfd: %s");
267             }
268             RETVAL = value;
269             OUTPUT:
270             RETVAL
271              
272              
273             MODULE = Linux::FD PACKAGE = Linux::FD::Signal
274              
275             SV*
276             new(classname, sigmask, ...)
277             const char* classname;
278             SV* sigmask;
279             PREINIT:
280             int i, flags = SFD_CLOEXEC;
281             CODE:
282 0 0         for (i = 2; i < items; i++)
283 0           flags |= get_signal_flag(ST(i));
284 0           RETVAL = new_signalfd(classname, sigmask, flags);
285             OUTPUT:
286             RETVAL
287              
288             void set_mask(self, sigmask)
289             SV* self;
290             SV* sigmask;
291             PREINIT:
292             int fd;
293             CODE:
294 0           fd = get_fd(self);
295 0 0         if(signalfd(fd, sv_to_sigset(sigmask, "signalfd"), 0) == -1)
296 0           die_sys("Couldn't set_mask: %s");
297              
298             SV*
299             receive(self)
300             SV* self;
301             PREINIT:
302             struct signalfd_siginfo buffer;
303             int tmp, timer;
304             HV* hash;
305             CODE:
306 2           timer = get_fd(self);
307             do {
308 2           tmp = read(timer, &buffer, sizeof buffer);
309 2 50         } while (interrupted(tmp));
310 2 100         if (tmp == -1) {
311 1 50         if (errno == EAGAIN)
312 1           XSRETURN_EMPTY;
313             else
314 0           die_sys("Couldn't read from signalfd: %s");
315             }
316 1           hash = newHV();
317 1           SET_HASH_U(signo);
318 1           SET_HASH_I(errno);
319 1           SET_HASH_I(code);
320 1           SET_HASH_U(pid);
321 1           SET_HASH_U(uid);
322 1           SET_HASH_I(fd);
323 1           SET_HASH_U(tid);
324 1           SET_HASH_U(band);
325 1           SET_HASH_U(overrun);
326 1           SET_HASH_U(trapno);
327 1           SET_HASH_I(status);
328 1           SET_HASH_I(int);
329 1           SET_HASH_U(ptr);
330 1           SET_HASH_U(utime);
331 1           SET_HASH_U(stime);
332 1           SET_HASH_U(addr);
333 1           RETVAL = newRV_noinc((SV*)hash);
334             OUTPUT:
335             RETVAL
336              
337              
338             MODULE = Linux::FD PACKAGE = Linux::FD::Timer
339              
340             SV*
341             new(classname, clock)
342             const char* classname;
343             SV* clock;
344             PREINIT:
345             int i, flags = TFD_CLOEXEC;
346             CODE:
347 0 0         for (i = 2; i < items; i++)
348 0           flags |= get_timer_flag(ST(i));
349 0           RETVAL = new_timerfd(classname, clock, flags, "Linux::FD::Timer->new");
350             OUTPUT:
351             RETVAL
352              
353             void
354             get_timeout(self)
355             SV* self;
356             PREINIT:
357             int timer;
358             struct itimerspec value;
359             PPCODE:
360 1           timer = get_fd(self);
361 1 50         if (timerfd_gettime(timer, &value) == -1)
362 0           die_sys("Couldn't get_timeout: %s");
363 1 50         mXPUSHn(timespec_to_nv(&value.it_value));
364 1 50         if (GIMME_V == G_ARRAY)
    50          
365 1 50         mXPUSHn(timespec_to_nv(&value.it_interval));
366              
367             SV*
368             set_timeout(self, new_value, new_interval = 0, abstime = 0)
369             SV* self;
370             NV new_value;
371             NV new_interval;
372             IV abstime;
373             PREINIT:
374             int timer;
375             struct itimerspec new_itimer, old_itimer;
376             PPCODE:
377 2           timer = get_fd(self);
378             nv_to_timespec(new_value, &new_itimer.it_value);
379             nv_to_timespec(new_interval, &new_itimer.it_interval);
380 2 50         if (timerfd_settime(timer, (abstime ? TIMER_ABSTIME : 0), &new_itimer, &old_itimer) == -1)
381 0           die_sys("Couldn't set_timeout: %s");
382 2 50         mXPUSHn(timespec_to_nv(&old_itimer.it_value));
383 2 50         if (GIMME_V == G_ARRAY)
    50          
384 0 0         mXPUSHn(timespec_to_nv(&old_itimer.it_interval));
385              
386             IV
387             receive(self)
388             SV* self;
389             PREINIT:
390             uint64_t buffer;
391             int ret, timer;
392             CODE:
393 3           timer = get_fd(self);
394             do {
395 3           ret = read(timer, &buffer, sizeof buffer);
396 3 50         } while (interrupted(ret));
397 3 100         if (ret == -1) {
398 1 50         if (errno == EAGAIN)
399 1           XSRETURN_EMPTY;
400             else
401 0           die_sys("Couldn't read from timerfd: %s");
402             }
403 2           RETVAL = buffer;
404             OUTPUT:
405             RETVAL
406              
407             void
408             clocks(classname)
409             SV* classname;
410             INIT:
411             int i;
412             PPCODE:
413 6 100         for (i = 0; i < sizeof clocks / sizeof *clocks; ++i)
414 5 50         mXPUSHp(clocks[i].key, strlen(clocks[i].key));