blib/lib/POE/Resource/Signals.pm

filter: Statementstmt 88.9% 298 / 335 Branchbran 71.3% 107 / 150 Conditioncond 84.8% 56 / 66 MC/DCmcdc 63.8% 23 / 36 Subroutinesub 100% 47 / 47 Podpod n/a totaltotal 83.7% 531 / 634 CC 109 SCAR 24.4
CC
109
Cov
84%
_data_sig_finalize
56.8
_data_sig_reap_pids
15.2
_data_sig_pipe_read
12.2
CRAP 11.4
« blib/lib/POE/Loop/Select.pm ↑ Summary blib/lib/POE/Filter/HTTPD.pm »
1 # The data necessary to manage signals, and the accessors to get at
2 # that data in a sane fashion.
3  
4 package POE::Resource::Signals;
5  
6 200 ▶use vars qw($VERSION);
Subroutine BEGIN: called CC=1 SCAR=0.0
7 78 $VERSION = '1.370'; # NOTE - Should be #.### (three decimal places)
8  
9 # These methods are folded into POE::Kernel;
10 package POE::Kernel;
11  
12 200 ▶use strict;
Subroutine BEGIN: called CC=1 SCAR=0.0
13  
14 200 ▶use POE::Pipe::OneWay;
Subroutine BEGIN: called CC=1 SCAR=0.0
15 200 ▶use POE::Resource::FileHandles;
Subroutine BEGIN: called CC=1 SCAR=0.0
16 200 ▶use POSIX qw(:sys_wait_h sigprocmask SIG_SETMASK);
Subroutine BEGIN: called CC=1 SCAR=0.0
17  
18 ### Map watched signal names to the sessions that are watching them
19 ### and the events that must be delivered when they occur.
20  
21 sub SEV_EVENT () { 0 }
22 sub SEV_ARGS () { 1 }
23 sub SEV_SESSION () { 2 }
24  
25 115 my %kr_signals;
26 # ( $signal_name =>
27 # { $session_id =>
28 # [ $event_name, SEV_EVENT
29 # $event_args, SEV_ARGS
30 # $session_ref, SEV_SESSION
31 # ],
32 # ...,
33 # },
34 # ...,
35 # );
36  
37 my %kr_sessions_to_signals;
38 # ( $session_id =>
39 # { $signal_name =>
40 # [ $event_name, SEV_EVENT
41 # $event_args, SEV_ARGS
42 # $session_ref, SEV_SESSION
43 # ],
44 # ...,
45 # },
46 # ...,
47 # );
48  
49 200 my %kr_pids_to_events;
50 # { $pid =>
51 # { $session_id =>
52 # [ $blessed_session, # PID_SESSION
53 # $event_name, # PID_EVENT
54 # $args, # PID_ARGS
55 # ]
56 # }
57 # }
58  
59 200 my %kr_sessions_to_pids;
60 # { $session_id => { $pid => 1 } }
61  
62 sub PID_SESSION () { 0 }
63 sub PID_EVENT () { 1 }
64 sub PID_ARGS () { 2 }
65  
66 10 ▶sub _data_sig_relocate_kernel_id {
Subroutine _data_sig_relocate_kernel_id: called CC=7 SCAR=19.9
67 10 my ($self, $old_id, $new_id) = @_;
68  
69 10 ▶ while (my ($signal, $sig_rec) = each %kr_signals) {
Branch: 1 branch
BranchTrueFalseTotal
if (() = each %kr_signals) 4 10 14
70 4 ▶ next unless exists $sig_rec->{$old_id};
Branch: 1 branch
BranchTrueFalseTotal
unless exists $sig_rec->{$old_id} 0 4 4
71 4 $sig_rec->{$new_id} = delete $sig_rec->{$old_id};
72 }
73  
74 $kr_sessions_to_signals{$new_id} = delete $kr_sessions_to_signals{$old_id}
75 10 ▶ if exists $kr_sessions_to_signals{$old_id};
Branch: 1 branch
BranchTrueFalseTotal
if exists $kr_sessions_to_signals{$old_id} 4 6 10
76  
77 10 ▶ while (my ($pid, $pid_rec) = each %kr_pids_to_events) {
Branch: 1 branch
BranchTrueFalseTotal
if (() = each %kr_pids_to_events) 2 10 12
78 2 ▶ next unless exists $pid_rec->{$old_id};
Branch: 1 branch
BranchTrueFalseTotal
unless exists $pid_rec->{$old_id} 2 0 2
79 0 $pid_rec->{$new_id} = delete $pid_rec->{$old_id};
80 }
81  
82 $kr_sessions_to_pids{$new_id} = delete $kr_sessions_to_pids{$old_id}
83 10 ▶ if exists $kr_sessions_to_pids{$old_id};
Branch: 1 branch
BranchTrueFalseTotal
if exists $kr_sessions_to_pids{$old_id} 0 10 10
84 }
85  
86 # Bookkeeping per dispatched signal.
87  
88 # TODO - Why not lexicals?
89 200 ▶use vars (
Subroutine BEGIN: called CC=1 SCAR=0.0
90 200 '@kr_signaled_sessions', # The sessions touched by a signal.
91 '$kr_signal_total_handled', # How many sessions handled a signal.
92 '$kr_signal_type', # The type of signal being dispatched.
93 200 );
94  
95 #my @kr_signaled_sessions; # The sessions touched by a signal.
96 #my $kr_signal_total_handled; # How many sessions handled a signal.
97 #my $kr_signal_type; # The type of signal being dispatched.
98  
99 # A flag to tell whether we're currently polling for signals.
100 # Under USE_SIGCHLD, determines whether a SIGCHLD polling event has
101 # already been queued.
102 200 my $polling_for_signals = 0;
103  
104 # There may be latent subprocesses in some environments.
105 # Or we may need to "always loop once" if we're polling for SIGCHLD.
106 # This constant lets us define those exceptional cases.
107 # We had some in the past, but as of 2013-10-06 we seem to have
108 # eliminated those special cases.
109 200 ▶use constant BASE_SIGCHLD_COUNT => 0;
Subroutine BEGIN: called CC=1 SCAR=0.0
110  
111 200 my $kr_has_child_procs = BASE_SIGCHLD_COUNT;
112  
113 # A list of special signal types. Signals that aren't listed here are
114 # benign (they do not kill sessions at all). "Terminal" signals are
115 # the ones that UNIX defaults to killing processes with. Thus STOP is
116 # not terminal.
117  
118 sub SIGTYPE_BENIGN () { 0x00 }
119 sub SIGTYPE_TERMINAL () { 0x01 }
120 sub SIGTYPE_NONMASKABLE () { 0x02 }
121  
122 200 my %_signal_types = (
123 QUIT => SIGTYPE_TERMINAL,
124 INT => SIGTYPE_TERMINAL,
125 KILL => SIGTYPE_TERMINAL,
126 TERM => SIGTYPE_TERMINAL,
127 HUP => SIGTYPE_TERMINAL,
128 IDLE => SIGTYPE_TERMINAL,
129 DIE => SIGTYPE_TERMINAL,
130 ZOMBIE => SIGTYPE_NONMASKABLE,
131 UIDESTROY => SIGTYPE_NONMASKABLE,
132 );
133  
134 # Build a list of useful, real signals. Nonexistent signals, and ones
135 # which are globally unhandled, usually cause segmentation faults if
136 # perl was poorly configured. Some signals aren't available in some
137 # environments.
138  
139 200 my %_safe_signals;
140  
141 294 ▶sub _data_sig_initialize {
Subroutine _data_sig_initialize: called CC=11 SCAR=24.9
142 294 my $self = shift;
143  
144 294 $self->_data_sig_reset_procs;
145  
146 294 $poe_kernel->[KR_SIGNALS] = \%kr_signals;
147 294 $poe_kernel->[KR_PIDS] = \%kr_pids_to_events;
148  
149 # In case we're called multiple times.
150 294 ▶ unless (keys %_safe_signals) {
Branch: 1 branch
BranchTrueFalseTotal
unless (keys %_safe_signals) 293 1 294
151 293 foreach my $signal (keys %SIG) {
152  
153 # Nonexistent signals, and ones which are globally unhandled.
154 next if (
155 19803 ▶ $signal =~ /^
Branch: 1 branch
BranchTrueFalseTotal
if $signal =~ /^ ( NUM\d+ |__[A-Z0-9]+__ |ALL|CATCHALL|DEFER|HOLD|IGNORE|MAX|PAUSE |RTMIN|RTMAX|SETS |SEGV | ) $/x 10134 9669 19803
156 ( NUM\d+
157 |__[A-Z0-9]+__
158 |ALL|CATCHALL|DEFER|HOLD|IGNORE|MAX|PAUSE
159 |RTMIN|RTMAX|SETS
160 |SEGV
161 |
162 )
163 $/x
164 );
165  
166 # Windows doesn't have a SIGBUS, but the debugger causes SIGBUS
167 # to be entered into %SIG. It's fatal to register its handler.
168 9669 ▶ next if $signal eq 'BUS' and RUNNING_IN_HELL;
Branch: 1 branch
BranchTrueFalseTotal
if $signal eq "BUS" and RUNNING_IN_HELL() 0 9669 9669
Condition66%2/3
$signal eq "BUS" and RUNNING_IN_HELL()
!ll&&!rl&&r
93762930
MC/DC0%0/2
$signal eq "BUS" and RUNNING_IN_HELL()
$signal eq "BUS" RUNNING_IN_HELL()
Truth table66%2/3
A and B
A= $signal eq "BUS"B= RUNNING_IN_HELL()
ABresult
0X0
100
111
169  
170 # Apache uses SIGCHLD and/or SIGCLD itself, so we can't.
171 9669 ▶ next if $signal =~ /^CH?LD$/ and exists $INC{'Apache.pm'};
Branch: 1 branch
BranchTrueFalseTotal
if $signal =~ /^CH?LD$/ and exists $INC{"Apache.pm"} 0 9669 9669
Condition66%2/3
$signal =~ /^CH?LD$/ and exists $INC{"Apache.pm"}
!ll&&!rl&&r
90835860
MC/DC0%0/2
$signal =~ /^CH?LD$/ and exists $INC{"Apache.pm"}
$signal =~ /^CH?LD$/ exists $INC{"Apache.pm"}
Truth table66%2/3
A and B
A= $signal =~ /^CH?LD$/B= exists $INC{"Apache.pm"}
ABresult
0X0
100
111
172  
173 9669 $_safe_signals{$signal} = 1;
174 }
175  
176 # Reset some important signal handlers. The rest remain
177 # untouched.
178  
179 293 ▶ $self->loop_ignore_signal("CHLD") if exists $SIG{CHLD};
Branch: 1 branch
BranchTrueFalseTotal
if exists $SIG{"CHLD"} 293 0 293
180 292 ▶ $self->loop_ignore_signal("CLD") if exists $SIG{CLD};
Branch: 1 branch
BranchTrueFalseTotal
if exists $SIG{"CLD"} 292 0 292
181 292 ▶ $self->loop_ignore_signal("PIPE") if exists $SIG{PIPE};
Branch: 1 branch
BranchTrueFalseTotal
if exists $SIG{"PIPE"} 292 0 292
182  
183 292 $self->_data_sig_pipe_build if USE_SIGNAL_PIPE;
184 }
185 }
186  
187 10 ▶sub _data_sig_has_forked {
Subroutine _data_sig_has_forked: called CC=1 SCAR=0.0
188 10 my( $self ) = @_;
189 10 $self->_data_sig_reset_procs;
190 10 if( USE_SIGNAL_PIPE ) {
191 10 $self->_data_sig_mask_all;
192 10 $self->_data_sig_pipe_finalize;
193 10 $self->_data_sig_pipe_build;
194 10 $self->_data_sig_unmask_all;
195 }
196 }
197  
198 304 ▶sub _data_sig_reset_procs {
Subroutine _data_sig_reset_procs: called CC=1 SCAR=0.0
199 304 my $self = shift;
200 # Initialize this to a true value so our waitpid() loop can run at
201 # least once. Starts false when running in an Apache handler so our
202 # SIGCHLD hijinks don't interfere with the web server.
203 304 $self->_data_sig_cease_polling();
204 304 $kr_has_child_procs = BASE_SIGCHLD_COUNT;
205 }
206  
207  
208 ### Return signals that are safe to manipulate.
209  
210 253 ▶sub _data_sig_get_safe_signals {
Subroutine _data_sig_get_safe_signals: called CC=1 SCAR=0.0
211 253 return keys %_safe_signals;
212 }
213  
214 ### End-run leak checking.
215 200 our $finalizing;
216  
217 204 ▶sub _data_sig_finalize {
Subroutine _data_sig_finalize: called CC=16 SCAR=40.4
218 204 my( $self ) = @_;
219 204 my $finalized_ok = 1;
220 # tell _data_sig_pipe_send to ignore CHLD that waitpid might provoke
221 204 local $finalizing = 1;
222  
223 204 $self->_data_sig_pipe_finalize;
224  
225 204 ▶ while (my ($sig, $sig_rec) = each(%kr_signals)) {
Branch: 1 branch
BranchTrueFalseTotal
if (() = each %kr_signals) 0 204 204
226 0 $finalized_ok = 0;
227 0 _warn "!!! Leaked signal $sig\n";
228 0 ▶ while (my ($sid, $ses_rec) = each(%{$kr_signals{$sig}})) {
Branch: 1 branch
BranchTrueFalseTotal
if (() = each %{$kr_signals{$sig};}) 0 0 0
229 0 my ($event, $args, $session) = @$ses_rec;
230 0 _warn "!!!\t$sid = $session -> $event (@$args)\n";
231 }
232 }
233  
234 204 ▶ while (my ($sid, $ses_rec) = each(%kr_sessions_to_signals)) {
Branch: 1 branch
BranchTrueFalseTotal
if (() = each %kr_sessions_to_signals) 0 204 204
235 0 $finalized_ok = 0;
236 0 _warn "!!! Leaked signal cross-reference: $sid\n";
237 0 ▶ while (my ($sig, $sig_rec) = each(%{$kr_signals{$sid}})) {
Branch: 1 branch
BranchTrueFalseTotal
if (() = each %{$kr_signals{$sid};}) 0 0 0
238 0 my ($event, $args) = @$sig_rec;
239 0 _warn "!!!\t$sig = $event (@$args)\n";
240 }
241 }
242  
243 204 ▶ while (my ($sid, $pid_rec) = each(%kr_sessions_to_pids)) {
Branch: 1 branch
BranchTrueFalseTotal
if (() = each %kr_sessions_to_pids) 0 204 204
244 0 $finalized_ok = 0;
245 0 my @pids = keys %$pid_rec;
246 0 _warn "!!! Leaked session to PID map: $sid -> (@pids)\n";
247 }
248  
249 204 ▶ while (my ($pid, $ses_rec) = each(%kr_pids_to_events)) {
Branch: 1 branch
BranchTrueFalseTotal
if (() = each %kr_pids_to_events) 0 204 204
250 0 $finalized_ok = 0;
251 0 _warn "!!! Leaked PID to event map: $pid\n";
252 0 ▶ while (my ($sid, $ev_rec, $ses) = each %$ses_rec) {
Branch: 1 branch
BranchTrueFalseTotal
if (() = each %$ses_rec) 0 0 0
253 0 _warn "!!!\t$ses -> $ev_rec->[PID_EVENT] (@{$ev_rec->[PID_ARGS]})\n";
254 }
255 }
256  
257 204 ▶ if ($kr_has_child_procs) {
Branch: 1 branch
BranchTrueFalseTotal
if ($kr_has_child_procs) 0 204 204
258 0 _warn "!!! Kernel has $kr_has_child_procs child process(es).\n";
259 }
260  
261 204 ▶ if ($polling_for_signals) {
Branch: 1 branch
BranchTrueFalseTotal
if ($polling_for_signals) 0 204 204
262 0 _warn "!!! Finalizing signals while polling is active.\n";
263 }
264  
265 204 ▶ if (USE_SIGNAL_PIPE and $self->_data_sig_pipe_has_signals()) {
Branch: 1 branch
BranchTrueFalseTotal
if ($self->_data_sig_pipe_has_signals) 0 204 204
266 2 _warn "!!! Finalizing signals while signal pipe contains messages.\n";
267 }
268  
269 202 ▶ if (exists $kr_signals{CHLD}) {
Branch: 1 branch
BranchTrueFalseTotal
if (exists $kr_signals{"CHLD"}) 2 202 204
270 2 _warn "!!! Finalizing signals while a blanket _child signal is watched.\n";
271 }
272  
273 204 %_safe_signals = ();
274  
275 204 ▶ unless (RUNNING_IN_HELL) {
Branch: 1 branch
BranchTrueFalseTotal
unless (RUNNING_IN_HELL()) 202 2 204
276 204 local $!;
277 204 local $?;
278  
279 204 my $leaked_children = 0;
280  
281 202 ▶ PROCESS: until ((my $pid = waitpid( -1, WNOHANG )) == -1) {
Branch: 1 branch
BranchTrueFalseTotal
unless ((my $pid = waitpid(-1, 1)) == -1) 0 202 202
282 0 $finalized_ok = 0;
283 0 $leaked_children++;
284  
285 0 ▶ if ($pid == 0) {
Branch: 1 branch
BranchTrueFalseTotal
if ($pid == 0) 0 2 2
286 0 _warn(
287 "!!! At least one child process is still running " .
288 "when POE::Kernel->run() is ready to return.\n"
289 );
290 0 last PROCESS;
291 }
292  
293 _warn(
294 2 "!!! Stopped child process (PID $pid) reaped " .
295 "when POE::Kernel->run() is ready to return.\n"
296 );
297 }
298  
299 202 ▶ if ($leaked_children) {
Branch: 1 branch
BranchTrueFalseTotal
if ($leaked_children) 0 202 202
300 0 _warn("!!! Be sure to use sig_child() to reap child processes.\n");
301 0 _warn("!!! In extreme cases, failure to reap child processes has\n");
302 2 _warn("!!! resulted in a slow 'fork bomb' that has halted systems.\n");
303 }
304 }
305  
306 202 return $finalized_ok;
307 }
308  
309 ### Add a signal to a session.
310  
311 379 ▶sub _data_sig_add {
Subroutine _data_sig_add: called CC=3 SCAR=11.0
312 379 my ($self, $session, $signal, $event, $args) = @_;
313  
314 379 my $sid = $session->ID;
315 379 ▶ $kr_sessions_to_signals{$sid}->{$signal} = [ $event, $args || [], $session ];
Condition100%2/2
$args || []
l!l
160219
MC/DC100%1/1
$args || []
$args
Truth table100%2/2
A
A= $args
Aresult
11
00
316 379 $self->_data_sig_signal_watch($sid, $signal);
317 379 ▶ $kr_signals{$signal}->{$sid} = [ $event, $args || [], $session ];
Condition100%2/2
$args || []
l!l
160219
MC/DC100%1/1
$args || []
$args
Truth table100%2/2
A
A= $args
Aresult
11
00
318 }
319  
320 609 ▶sub _data_sig_signal_watch {
Subroutine _data_sig_signal_watch: called CC=5 SCAR=16.1
321 609 my ($self, $sid, $signal) = @_;
322  
323 # TODO - $sid not used?
324  
325 # First session to watch the signal.
326 # Ask the event loop to watch the signal.
327 609 ▶ if (
Branch: 1 branch
BranchTrueFalseTotal
if (not exists $kr_signals{$signal} and exists $_safe_signals{$signal} and $signal ne "CHLD" || !scalar(keys %kr_sessions_to_pids)) 221 388 609
Condition100%9/9
not exists $kr_signals{$signal} and exists $_safe_signals{$signal} and $signal ne "CHLD" || !scalar(keys %kr_sessions_to_pids)
!ll&&!rl&&r
279109221
not exists $kr_signals{$signal} and exists $_safe_signals{$signal}
!ll&&!rl&&r
45234330
$signal ne "CHLD" or not scalar keys %kr_sessions_to_pids
l!l&&r!l&&!r
16205109
MC/DC100%4/4
not exists $kr_signals{$signal} and exists $_safe_signals{$signal} and $signal ne "CHLD" || !scalar(keys %kr_sessions_to_pids)
not exists $kr_signals{$signal} exists $_safe_signals{$signal} $signal ne "CHLD" not scalar keys %kr_sessions_to_pids
Truth table100%5/5
not(A) and B and C or not(D)
A= not exists $kr_signals{$signal}B= exists $_safe_signals{$signal}C= $signal ne "CHLD"D= not scalar keys %kr_sessions_to_pids
ABCDresult
0XXX0
10XX0
11000
111X1
11011
328 !exists($kr_signals{$signal}) and
329 exists($_safe_signals{$signal}) and
330 ($signal ne "CHLD" or !scalar(keys %kr_sessions_to_pids))
331 ) {
332 221 $self->loop_watch_signal($signal);
333 }
334 }
335  
336 674 ▶sub _data_sig_signal_ignore {
Subroutine _data_sig_signal_ignore: called CC=5 SCAR=16.1
337 674 my ($self, $sid, $signal) = @_;
338  
339 # TODO - $sid not used?
340  
341 674 ▶ if (
Branch: 1 branch
BranchTrueFalseTotal
if (not exists $kr_signals{$signal} and exists $_safe_signals{$signal} and $signal ne "CHLD" || !scalar(keys %kr_sessions_to_pids)) 191 483 674
Condition100%9/9
not exists $kr_signals{$signal} and exists $_safe_signals{$signal} and $signal ne "CHLD" || !scalar(keys %kr_sessions_to_pids)
!ll&&!rl&&r
43053191
not exists $kr_signals{$signal} and exists $_safe_signals{$signal}
!ll&&!rl&&r
4426244
$signal ne "CHLD" or not scalar keys %kr_sessions_to_pids
l!l&&r!l&&!r
1617553
MC/DC100%4/4
not exists $kr_signals{$signal} and exists $_safe_signals{$signal} and $signal ne "CHLD" || !scalar(keys %kr_sessions_to_pids)
not exists $kr_signals{$signal} exists $_safe_signals{$signal} $signal ne "CHLD" not scalar keys %kr_sessions_to_pids
Truth table100%5/5
not(A) and B and C or not(D)
A= not exists $kr_signals{$signal}B= exists $_safe_signals{$signal}C= $signal ne "CHLD"D= not scalar keys %kr_sessions_to_pids
ABCDresult
0XXX0
10XX0
11000
111X1
11011
342 !exists($kr_signals{$signal}) and
343 exists($_safe_signals{$signal}) and
344 ($signal ne "CHLD" or !scalar(keys %kr_sessions_to_pids))
345 ) {
346 191 $self->loop_ignore_signal($signal);
347 }
348 }
349  
350 ### Remove a signal from a session.
351  
352 566 ▶sub _data_sig_remove {
Subroutine _data_sig_remove: called CC=3 SCAR=11.0
353 566 my ($self, $sid, $signal) = @_;
354  
355 566 delete $kr_sessions_to_signals{$sid}->{$signal};
356 delete $kr_sessions_to_signals{$sid}
357 566 ▶ unless keys(%{$kr_sessions_to_signals{$sid}});
Branch: 1 branch
BranchTrueFalseTotal
unless keys %{$kr_sessions_to_signals{$sid};} 553 13 566
358  
359 566 delete $kr_signals{$signal}->{$sid};
360  
361 # Last watcher for that signal. Stop watching it internally.
362 566 ▶ unless (keys %{$kr_signals{$signal}}) {
Branch: 1 branch
BranchTrueFalseTotal
unless (keys %{$kr_signals{$signal};}) 551 15 566
363 551 delete $kr_signals{$signal};
364 551 $self->_data_sig_signal_ignore($sid, $signal);
365 }
366 }
367  
368 ### Clear all the signals from a session.
369  
370 # XXX - It's ok to clear signals from a session that doesn't exist.
371 # Usually it means that the signals are being cleared, but it might
372 # mean that the session really doesn't exist. Should we care?
373  
374 817 ▶sub _data_sig_clear_session {
Subroutine _data_sig_clear_session: called CC=5 SCAR=16.1
375 817 my ($self, $sid) = @_;
376  
377 817 ▶ if (exists $kr_sessions_to_signals{$sid}) { # avoid autoviv
Branch: 1 branch
BranchTrueFalseTotal
if (exists $kr_sessions_to_signals{$sid}) 233 584 817
378 233 foreach (keys %{$kr_sessions_to_signals{$sid}}) {
379 241 $self->_data_sig_remove($sid, $_);
380 }
381 }
382  
383 817 ▶ if (exists $kr_sessions_to_pids{$sid}) { # avoid autoviv
Branch: 1 branch
BranchTrueFalseTotal
if (exists $kr_sessions_to_pids{$sid}) 10 807 817
384 10 foreach (keys %{$kr_sessions_to_pids{$sid}}) {
385 10 $self->_data_sig_pid_ignore($sid, $_);
386 }
387 }
388 }
389  
390 ### Watch and ignore PIDs.
391  
392 230 ▶sub _data_sig_pid_watch {
Subroutine _data_sig_pid_watch: called CC=1 SCAR=0.0
393 230 my ($self, $session, $pid, $event, $args) = @_;
394  
395 230 my $sid = $session->ID;
396  
397 230 $kr_pids_to_events{$pid}{$sid} = [
398 $session, # PID_SESSION
399 $event, # PID_EVENT
400 $args, # PID_ARGS
401 ];
402  
403 230 $self->_data_sig_signal_watch($sid, "CHLD");
404  
405 230 $kr_sessions_to_pids{$sid}{$pid} = 1;
406 230 $self->_data_ses_refcount_inc($sid);
407  
408 # Assume there's a child process. This will be corrected on the
409 # next polling interval.
410 230 $kr_has_child_procs++ unless USE_SIGCHLD;
411 }
412  
413 167 ▶sub _data_sig_pid_ignore {
Subroutine _data_sig_pid_ignore: called CC=3 SCAR=11.0
414 167 my ($self, $sid, $pid) = @_;
415  
416 # Remove PID to event mapping.
417  
418 167 delete $kr_pids_to_events{$pid}{$sid};
419 delete $kr_pids_to_events{$pid} unless (
420 167 ▶ keys %{$kr_pids_to_events{$pid}}
Branch: 1 branch
BranchTrueFalseTotal
unless keys %{$kr_pids_to_events{$pid};} 145 22 167
421 );
422  
423 # Remove session to PID mapping.
424  
425 167 delete $kr_sessions_to_pids{$sid}{$pid};
426 167 ▶ unless (keys %{$kr_sessions_to_pids{$sid}}) {
Branch: 1 branch
BranchTrueFalseTotal
unless (keys %{$kr_sessions_to_pids{$sid};}) 123 44 167
427 123 delete $kr_sessions_to_pids{$sid};
428 123 $self->_data_sig_signal_ignore($sid, "CHLD");
429 }
430  
431 167 $self->_data_ses_refcount_dec($sid);
432 }
433  
434 8915 ▶sub _data_sig_session_awaits_pids {
Subroutine _data_sig_session_awaits_pids: called CC=5 SCAR=16.1
435 8915 my ($self, $sid) = @_;
436  
437 # There must be child processes or pending signals.
438 # Watching PIDs doesn't matter if there are none to be reaped.
439 8915 ▶ return 0 unless $kr_has_child_procs or $self->_data_sig_pipe_has_signals();
Branch: 1 branch
BranchTrueFalseTotal
unless $kr_has_child_procs or $self->_data_sig_pipe_has_signals 8044 871 8915
Condition100%3/3
$kr_has_child_procs or $self->_data_sig_pipe_has_signals
l!l&&r!l&&!r
86838044
MC/DC100%2/2
$kr_has_child_procs or $self->_data_sig_pipe_has_signals
$kr_has_child_procs $self->_data_sig_pipe_has_signals
Truth table100%3/3
A or B
A= $kr_has_child_procsB= $self->_data_sig_pipe_has_signals
ABresult
1X1
011
000
440  
441 # This session is watching at least one PID with sig_child().
442 # TODO - Watching a non-existent PID is legal but ill-advised.
443 871 ▶ return 1 if exists $kr_sessions_to_pids{$sid};
Branch: 1 branch
BranchTrueFalseTotal
if exists $kr_sessions_to_pids{$sid} 386 485 871
444  
445 # Is the session waiting for a blanket sig(CHLD)?
446 return(
447 (exists $kr_sessions_to_signals{$sid}) &&
448 (exists $kr_sessions_to_signals{$sid}{CHLD})
449 485 ▶ );
Condition100%3/3
exists $kr_sessions_to_signals{$sid} && exists $kr_sessions_to_signals{$sid}{'CHLD'}
!ll&&!rl&&r
12235310
MC/DC100%2/2
exists $kr_sessions_to_signals{$sid} && exists $kr_sessions_to_signals{$sid}{'CHLD'}
exists $kr_sessions_to_signals{$sid} exists $kr_sessions_to_signals{$sid}{'CHLD'}
Truth table100%3/3
A && B
A= exists $kr_sessions_to_signals{$sid}B= exists $kr_sessions_to_signals{$sid}{'CHLD'}
ABresult
0X0
100
111
450 }
451  
452 1 ▶sub _data_sig_pids_is_ses_watching {
Subroutine _data_sig_pids_is_ses_watching: called CC=2 SCAR=8.1
453 1 my ($self, $sid, $pid) = @_;
454 return(
455 exists($kr_sessions_to_pids{$sid}) &&
456 1 ▶ exists($kr_sessions_to_pids{$sid}{$pid})
Condition33%1/3
exists $kr_sessions_to_pids{$sid} && exists $kr_sessions_to_pids{$sid}{$pid}
!ll&&!rl&&r
100
MC/DC0%0/2
exists $kr_sessions_to_pids{$sid} && exists $kr_sessions_to_pids{$sid}{$pid}
exists $kr_sessions_to_pids{$sid} exists $kr_sessions_to_pids{$sid}{$pid}
Truth table33%1/3
A && B
A= exists $kr_sessions_to_pids{$sid}B= exists $kr_sessions_to_pids{$sid}{$pid}
ABresult
0X0
100
111
457 );
458 }
459  
460 ### Return a signal's type, or SIGTYPE_BENIGN if it's not special.
461  
462 504 ▶sub _data_sig_type {
Subroutine _data_sig_type: called CC=2 SCAR=6.9
463 504 my ($self, $signal) = @_;
464 504 ▶ return $_signal_types{$signal} || SIGTYPE_BENIGN;
Condition100%2/2
$_signal_types{$signal} || 0
l!l
224280
MC/DC100%1/1
$_signal_types{$signal} || 0
$_signal_types{$signal}
Truth table100%2/2
A
A= $_signal_types{$signal}
Aresult
11
00
465 }
466  
467 ### Flag a signal as being handled by some session.
468  
469 127 ▶sub _data_sig_handled {
Subroutine _data_sig_handled: called CC=1 SCAR=0.0
470 127 my $self = shift;
471 127 $kr_signal_total_handled++;
472 }
473  
474 ### Clear the structures associated with a signal's "handled" status.
475  
476 502 ▶sub _data_sig_reset_handled {
Subroutine _data_sig_reset_handled: called CC=1 SCAR=0.0
477 502 my ($self, $signal) = @_;
478 502 undef $kr_signal_total_handled;
479 502 $kr_signal_type = $self->_data_sig_type($signal);
480 502 undef @kr_signaled_sessions;
481 }
482  
483 ### Is the signal explicitly watched?
484  
485 498 ▶sub _data_sig_explicitly_watched {
Subroutine _data_sig_explicitly_watched: called CC=1 SCAR=0.0
486 498 my ($self, $signal) = @_;
487 498 return exists $kr_signals{$signal};
488 }
489  
490 ### Return the signals watched by a session and the events they
491 ### generate. TODO Used mainly for testing, but may also be useful
492 ### for introspection.
493  
494 1 ▶sub _data_sig_watched_by_session {
Subroutine _data_sig_watched_by_session: called CC=2 SCAR=7.0
495 1 my ($self, $sid) = @_;
496 1 ▶ return unless exists $kr_sessions_to_signals{$sid};
Branch: 1 branch
BranchTrueFalseTotal
unless exists $kr_sessions_to_signals{$sid} 0 1 1
497 1 return %{$kr_sessions_to_signals{$sid}};
498 }
499  
500 ### Which sessions are watching a signal?
501  
502 369 ▶sub _data_sig_watchers {
Subroutine _data_sig_watchers: called CC=1 SCAR=0.0
503 369 my ($self, $signal) = @_;
504 369 return %{$kr_signals{$signal}};
505 }
506  
507 ### Return the current signal's handled status.
508 ### TODO Used for testing.
509  
510 503 ▶sub _data_sig_handled_status {
Subroutine _data_sig_handled_status: called CC=1 SCAR=0.0
511 return(
512 503 $kr_signal_total_handled,
513 $kr_signal_type,
514 \@kr_signaled_sessions,
515 );
516 }
517  
518 ### Determine if a given session is watching a signal. This uses a
519 ### two-step exists so that the longer one does not autovivify keys in
520 ### the shorter one.
521  
522 4 ▶sub _data_sig_is_watched_by_session {
Subroutine _data_sig_is_watched_by_session: called CC=2 SCAR=6.9
523 4 my ($self, $signal, $sid) = @_;
524 return(
525 exists($kr_signals{$signal}) &&
526 4 ▶ exists($kr_signals{$signal}->{$sid})
Condition100%3/3
exists $kr_signals{$signal} && exists $kr_signals{$signal}{$sid}
!ll&&!rl&&r
112
MC/DC100%2/2
exists $kr_signals{$signal} && exists $kr_signals{$signal}{$sid}
exists $kr_signals{$signal} exists $kr_signals{$signal}{$sid}
Truth table100%3/3
A && B
A= exists $kr_signals{$signal}B= exists $kr_signals{$signal}{$sid}
ABresult
0X0
100
111
527 );
528 }
529  
530 ### Destroy sessions touched by a nonmaskable signal or by an
531 ### unhandled terminal signal. Check for garbage-collection on
532 ### sessions which aren't to be terminated.
533  
534 499 ▶sub _data_sig_free_terminated_sessions {
Subroutine _data_sig_free_terminated_sessions: called CC=6 SCAR=17.9
535 499 my $self = shift;
536  
537 499 ▶ if (
Branch: 1 branch
BranchTrueFalseTotal
if ($POE::Kernel::kr_signal_type & 2 or $POE::Kernel::kr_signal_type & 1 and not $POE::Kernel::kr_signal_total_handled) 217 282 499
Condition100%6/6
$POE::Kernel::kr_signal_type & 2 or $POE::Kernel::kr_signal_type & 1 and not $POE::Kernel::kr_signal_total_handled
l!l&&r!l&&!r
3214282
$POE::Kernel::kr_signal_type & 1 and not $POE::Kernel::kr_signal_total_handled
!ll&&!rl&&r
2775214
MC/DC100%3/3
$POE::Kernel::kr_signal_type & 2 or $POE::Kernel::kr_signal_type & 1 and not $POE::Kernel::kr_signal_total_handled
$POE::Kernel::kr_signal_type & 2 $POE::Kernel::kr_signal_type & 1 not $POE::Kernel::kr_signal_total_handled
Truth table100%4/4
A or B and not(C)
A= $POE::Kernel::kr_signal_type & 2B= $POE::Kernel::kr_signal_type & 1C= not $POE::Kernel::kr_signal_total_handled
ABCresult
1XX1
0111
00X0
0100
538 ($kr_signal_type & SIGTYPE_NONMASKABLE) or
539 ($kr_signal_type & SIGTYPE_TERMINAL and !$kr_signal_total_handled)
540 ) {
541 217 foreach my $dead_session (@kr_signaled_sessions) {
542 300 ▶ next unless $self->_data_ses_exists($dead_session->ID);
Branch: 1 branch
BranchTrueFalseTotal
unless $self->_data_ses_exists($dead_session->ID) 0 300 300
543  
544 300 if (TRACE_SIGNALS) {
545 _warn(
546 "<sg> stopping signaled session ",
547 $self->_data_alias_loggable($dead_session->ID)
548 );
549 }
550  
551 300 $self->_data_ses_stop($dead_session->ID);
552 }
553 }
554  
555 # Erase @kr_signaled_sessions, or they will leak until the next
556 # signal.
557 460 @kr_signaled_sessions = ();
558 }
559  
560 ### A signal has touched a session. Record this fact for later
561 ### destruction tests.
562  
563 1557 ▶sub _data_sig_touched_session {
Subroutine _data_sig_touched_session: called CC=1 SCAR=0.0
564 1763 my ($self, $session) = @_;
565 1557 push @kr_signaled_sessions, $session;
566 }
567  
568 # only used under !USE_SIGCHLD
569 1 ▶sub _data_sig_begin_polling {
Subroutine _data_sig_begin_polling: called CC=2 SCAR=7.0
570 1 my ($self, $signal) = @_;
571  
572 1 ▶ return if $polling_for_signals;
Branch: 1 branch
BranchTrueFalseTotal
if $polling_for_signals 0 1 1
573 1 $polling_for_signals = 1;
574  
575 1 $self->_data_sig_enqueue_poll_event($signal);
576 1 $self->_idle_queue_grow();
577 }
578  
579 # only used under !USE_SIGCHLD
580 311 ▶sub _data_sig_cease_polling {
Subroutine _data_sig_cease_polling: called CC=1 SCAR=0.0
581 311 $polling_for_signals = 0;
582 }
583  
584 437 ▶sub _data_sig_enqueue_poll_event {
Subroutine _data_sig_enqueue_poll_event: called CC=2 SCAR=6.9
585 437 my ($self, $signal) = @_;
586  
587 437 if ( USE_SIGCHLD ) {
588 437 ▶ return if $polling_for_signals;
Branch: 1 branch
BranchTrueFalseTotal
if $polling_for_signals 29 408 437
589 408 $polling_for_signals = 1;
590  
591 408 $self->_data_ev_enqueue(
592 $self, $self, EN_SCPOLL, ET_SCPOLL, [ $signal ],
593 __FILE__, __LINE__, undef
594 );
595 } else {
596 return if $self->_data_ses_count() < 1;
597 return unless $polling_for_signals;
598  
599 $self->_data_ev_enqueue(
600 $self, $self, EN_SCPOLL, ET_SCPOLL, [ $signal ],
601 __FILE__, __LINE__, undef, walltime(), POE::Kernel::CHILD_POLLING_INTERVAL(),
602 );
603 }
604 }
605  
606 375 ▶sub _data_sig_handle_poll_event {
Subroutine _data_sig_handle_poll_event: called CC=1 SCAR=0.0
607 375 my ($self, $signal) = @_;
608  
609 375 if ( USE_SIGCHLD ) {
610 375 $polling_for_signals = undef;
611 }
612  
613 375 if (TRACE_SIGNALS) {
614 _warn(
615 "<sg> POE::Kernel is polling for signals at " . monotime() .
616 (USE_SIGCHLD ? " due to SIGCHLD" : "")
617 );
618 }
619  
620 375 $self->_data_sig_reap_pids();
621  
622 # The poll loop is over. Resume slowly polling for signals.
623  
624 375 if (USE_SIGCHLD) {
625 375 if (TRACE_SIGNALS) {
626 _warn("<sg> POE::Kernel has reset the SIG$signal handler");
627 }
628 # Per https://rt.cpan.org/Ticket/Display.html?id=45109 setting the
629 # signal handler must be done after reaping the outstanding child
630 # processes, at least on SysV systems like HP-UX.
631 375 $SIG{$signal} = \&_loop_signal_handler_chld;
632 }
633 else {
634 # The poll loop is over. Resume slowly polling for signals.
635  
636 if ($polling_for_signals) {
637 if (TRACE_SIGNALS) {
638 _warn("<sg> POE::Kernel will poll again after a delay");
639 }
640 $self->_data_sig_enqueue_poll_event($signal);
641 }
642 else {
643 if (TRACE_SIGNALS) {
644 _warn("<sg> POE::Kernel SIGCHLD poll loop paused");
645 }
646 $self->_idle_queue_shrink();
647 }
648 }
649 }
650  
651 375 ▶sub _data_sig_reap_pids {
Subroutine _data_sig_reap_pids: called CC=14 SCAR=27.2
652 426 my $self = shift();
653  
654 # Reap children for as long as waitpid(2) says something
655 # interesting has happened.
656 # TODO This has a possibility of an infinite loop, but so far it
657 # hasn't hasn't happened.
658  
659 426 my $pid;
660 375 ▶ while ($pid = waitpid(-1, WNOHANG)) {
Branch: 1 branch
BranchTrueFalseTotal
if ($pid = waitpid(-1, 1)) 418 202 620
661 # waitpid(2) returned a process ID. Emit an appropriate SIGCHLD
662 # event and loop around again.
663  
664 416 ▶ if (($pid > 0) or (RUNNING_IN_HELL and $pid < -1)) {
Branch: 1 branch
BranchTrueFalseTotal
if ($pid > 0 or RUNNING_IN_HELL() and $pid < -1) 240 176 416
Condition50%3/6
$pid > 0 or RUNNING_IN_HELL() and $pid < -1
l!l&&r!l&&!r
2400176
RUNNING_IN_HELL() and $pid < -1
!ll&&!rl&&r
17600
MC/DC33%1/3
$pid > 0 or RUNNING_IN_HELL() and $pid < -1
$pid > 0 RUNNING_IN_HELL() $pid < -1
Truth table50%2/4
A or B and C
A= $pid > 0B= RUNNING_IN_HELL()C= $pid < -1
ABCresult
1XX1
0111
00X0
0100
665 240 ▶ if (RUNNING_IN_HELL or WIFEXITED($?) or WIFSIGNALED($?)) {
Branch: 1 branch
BranchTrueFalseTotal
if (RUNNING_IN_HELL() or WIFEXITED($?) or WIFSIGNALED($?)) { } 240 0 240
Condition66%4/6
RUNNING_IN_HELL() or WIFEXITED($?) or WIFSIGNALED($?)
l!l&&r!l&&!r
202380
RUNNING_IN_HELL() or WIFEXITED($?)
l!l&&r!l&&!r
020238
MC/DC0%0/3
RUNNING_IN_HELL() or WIFEXITED($?) or WIFSIGNALED($?)
RUNNING_IN_HELL() WIFEXITED($?) WIFSIGNALED($?)
Truth table50%2/4
A or B or C
A= RUNNING_IN_HELL()B= WIFEXITED($?)C= WIFSIGNALED($?)
ABCresult
1XX1
01X1
0011
0000
666  
667 240 if (TRACE_SIGNALS) {
668 _warn("<sg> POE::Kernel detected SIGCHLD (pid=$pid; exit=$?)");
669 }
670  
671 # Check for explicit SIGCHLD watchers, and enqueue explicit
672 # events for them.
673  
674 240 ▶ if (exists $kr_pids_to_events{$pid}) {
Branch: 1 branch
BranchTrueFalseTotal
if (exists $kr_pids_to_events{$pid}) 141 99 240
675 159 my @sessions_to_clear;
676 141 ▶ while (my ($sid, $ses_rec) = each %{$kr_pids_to_events{$pid}}) {
Branch: 1 branch
BranchTrueFalseTotal
if (() = each %{$kr_pids_to_events{$pid};}) 157 141 298
677 $self->_data_ev_enqueue(
678 $ses_rec->[PID_SESSION], $self, $ses_rec->[PID_EVENT], ET_SIGCLD,
679 209 [ 'CHLD', $pid, $?, @{$ses_rec->[PID_ARGS]} ],
680 __FILE__, __LINE__, undef
681 );
682 157 push @sessions_to_clear, $sid;
683 }
684 157 $self->_data_sig_pid_ignore($_, $pid) foreach @sessions_to_clear;
685 }
686  
687 # Kick off a SIGCHLD cascade.
688 $self->_data_ev_enqueue(
689 222 $self, $self, EN_SIGNAL, ET_SIGNAL, [ 'CHLD', $pid, $? ],
690 __FILE__, __LINE__, undef
691 );
692 }
693 elsif (TRACE_SIGNALS) {
694 _warn("<sg> POE::Kernel detected strange exit (pid=$pid; exit=$?");
695 }
696  
697 240 if (TRACE_SIGNALS) {
698 _warn("<sg> POE::Kernel will poll again immediately");
699 }
700  
701 170 next;
702 }
703  
704 # The only other negative value waitpid(2) should return is -1.
705 # This is highly unlikely, but it's necessary to catch
706 # portability problems.
707 #
708 # TODO - Find a way to test this.
709  
710 227 ▶ _trap "internal consistency error: waitpid returned $pid" if $pid != -1;
Branch: 1 branch
BranchTrueFalseTotal
if $pid != -1 0 176 176
711  
712 # If the error is an interrupted syscall, poll again right away.
713  
714 227 ▶ if ($! == EINTR) {
Branch: 1 branch
BranchTrueFalseTotal
if ($! == 4) 0 176 176
715 70 if (TRACE_SIGNALS) {
716 _warn(
717 "<sg> POE::Kernel's waitpid(2) was interrupted.\n",
718 "POE::Kernel will poll again immediately.\n"
719 );
720 }
721 19 next;
722 }
723  
724 # No child processes exist. TODO This is different than
725 # children being present but running. Maybe this condition
726 # could halt polling entirely, and some UNIVERSAL::fork wrapper
727 # could restart polling when processes are forked.
728  
729 176 ▶ if ($! == ECHILD) {
Branch: 1 branch
BranchTrueFalseTotal
if ($! == 10) 176 0 176
730 157 if (TRACE_SIGNALS) {
731 _warn("<sg> POE::Kernel has no child processes");
732 }
733 157 last;
734 }
735  
736 # Some other error occurred.
737  
738 0 if (TRACE_SIGNALS) {
739 _warn("<sg> POE::Kernel's waitpid(2) got error: $!");
740 }
741 19 last;
742 }
743  
744 # Remember whether there are more processes to reap.
745  
746 343 $kr_has_child_procs = !$pid;
747 }
748  
749 # Are there child processes worth waiting for?
750 # We don't really care if we're not polling for signals.
751  
752 2565 ▶sub _data_sig_kernel_awaits_pids {
Subroutine _data_sig_kernel_awaits_pids: called CC=4 SCAR=13.9
753 2584 my $self = shift();
754  
755 2584 return 0 if !USE_SIGCHLD and !$polling_for_signals;
756  
757 # There must be child processes or pending signals.
758 2564 ▶ return 0 unless $kr_has_child_procs or $self->_data_sig_pipe_has_signals();
Branch: 1 branch
BranchTrueFalseTotal
unless $kr_has_child_procs or $self->_data_sig_pipe_has_signals 2312 253 2565
Condition100%3/3
$kr_has_child_procs or $self->_data_sig_pipe_has_signals
l!l&&r!l&&!r
236172311
MC/DC100%2/2
$kr_has_child_procs or $self->_data_sig_pipe_has_signals
$kr_has_child_procs $self->_data_sig_pipe_has_signals
Truth table100%3/3
A or B
A= $kr_has_child_procsB= $self->_data_sig_pipe_has_signals
ABresult
1X1
011
000
759  
760 # At least one session is watching an explicit PID.
761 # TODO - Watching a non-existent PID is legal but ill-advised.
762 253 ▶ return 1 if scalar keys %kr_pids_to_events;
Branch: 1 branch
BranchTrueFalseTotal
if scalar keys %kr_pids_to_events 148 105 253
763  
764 # Is the session waiting for a blanket sig(CHLD)?
765 105 return exists $kr_signals{CHLD};
766 }
767  
768 ######################
769 ## Safe signals, the final solution:
770 ## Semantically, signal handlers and the main loop are in different threads.
771 ## To avoid all possible deadlock and race conditions once and for all we
772 ## implement them as shared-nothing threads.
773 ##
774 ## The signal handlers are split in 2 :
775 ## - a top handler, which sends the signal number over a one-way pipe.
776 ## - a bottom handler, which is called when this number is received in the
777 ## main loop.
778 ## The top handler will send a packet of PID and number. We need the PID
779 ## because of the race condition with signals in perl; signals meant for the
780 ## parent end up in both the parent and child. So we check the PID to make
781 ## sure it was intended for the child. We use 'ii' (2 ints, aka 8 bytes)
782 ## and not 'iC' (int+byte, aka 5 bytes) because we want a small factor of
783 ## the buffer size in the hopes of never getting a short read. Ever.
784  
785 200 ▶use vars qw( $signal_pipe_read_fd );
Subroutine BEGIN: called CC=1 SCAR=0.0
786 my(
787 200 $signal_pipe_write,
788 $signal_pipe_read,
789 $signal_pipe_pid,
790 $signal_mask_none,
791 $signal_mask_all,
792  
793 @pending_signals,
794 );
795  
796 sub SIGINFO_NAME () { 0 }
797 sub SIGINFO_SRC_PID () { 1 }
798  
799  
800 10577 ▶sub _data_sig_pipe_has_signals {
Subroutine _data_sig_pipe_has_signals: called CC=2 SCAR=6.9
801 10628 my $self = shift();
802 10577 ▶ return unless $signal_pipe_read;
Branch: 1 branch
BranchTrueFalseTotal
unless $signal_pipe_read 786 9791 10577
803 9791 my $vec = '';
804 9791 vec($vec, fileno($signal_pipe_read), 1) = 1;
805  
806 # Ambiguous call resolved as CORE::select(), qualify as such or use &
807 9791 return(CORE::select($vec, undef, undef, 0) > 0);
808 }
809  
810  
811 300 ▶sub _data_sig_pipe_build {
Subroutine _data_sig_pipe_build: called CC=3 SCAR=11.3
812 300 my( $self ) = @_;
813 300 return unless USE_SIGNAL_PIPE;
814 300 my $fake = 128;
815  
816 # Associate the pipe with this PID
817 300 $signal_pipe_pid = $$;
818  
819 # Mess with the signal mask
820 300 $self->_data_sig_mask_all;
821  
822 # Open the signal pipe.
823 # TODO - Normally POE::Pipe::OneWay will do the right thing. Why
824 # are we overriding its per-platform autodetection?
825 300 ▶ if (RUNNING_IN_HELL) {
Branch: 1 branch
BranchTrueFalseTotal
if (RUNNING_IN_HELL()) { } 0 300 300
826 0 ( $signal_pipe_read, $signal_pipe_write ) = POE::Pipe::OneWay->new('inet');
827 }
828 else {
829 300 ( $signal_pipe_read, $signal_pipe_write ) = POE::Pipe::OneWay->new('pipe');
830 }
831  
832 300 ▶ unless ($signal_pipe_write) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($signal_pipe_write) 0 300 300
833 0 _trap "<sg> Error " . ($!+0) . " trying to create the signal pipe: $!";
834 }
835  
836 # Allows Resource::FileHandles to by-pass the queue
837 300 $signal_pipe_read_fd = fileno $signal_pipe_read;
838 300 if( TRACE_SIGNALS ) {
839 _warn "<sg> signal_pipe_write=$signal_pipe_write";
840 _warn "<sg> signal_pipe_read=$signal_pipe_read";
841 _warn "<sg> signal_pipe_read_fd=$signal_pipe_read_fd";
842 }
843  
844 # Add to the select list
845 300 $self->_data_handle_condition( $signal_pipe_read );
846 300 $self->loop_watch_filehandle( $signal_pipe_read, MODE_RD );
847 300 $self->_data_sig_unmask_all;
848 }
849  
850 198 ▶sub _data_sig_mask_build {
Subroutine _data_sig_mask_build: called CC=2 SCAR=7.0
851 325 ▶ return if RUNNING_IN_HELL;
Branch: 1 branch
BranchTrueFalseTotal
if RUNNING_IN_HELL() 0 198 198
852 325 $signal_mask_none = POSIX::SigSet->new();
853 325 $signal_mask_none->emptyset();
854 198 $signal_mask_all = POSIX::SigSet->new();
855 198 $signal_mask_all->fillset();
856 }
857  
858 ### Mask all signals
859 625 ▶sub _data_sig_mask_all {
Subroutine _data_sig_mask_all: called CC=4 SCAR=14.0
860 625 ▶ return if RUNNING_IN_HELL;
Branch: 1 branch
BranchTrueFalseTotal
if RUNNING_IN_HELL() 0 625 625
861 625 my $self = $poe_kernel;
862 625 ▶ unless( $signal_mask_all ) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($signal_mask_all) 198 427 625
863 198 $self->_data_sig_mask_build;
864 }
865 625 my $mask_temp = POSIX::SigSet->new();
866 625 ▶ sigprocmask( SIG_SETMASK, $signal_mask_all, $mask_temp )
Branch: 1 branch
BranchTrueFalseTotal
sigprocmask(2, $signal_mask_all, $mask_temp) or _trap("<sg> Unable to mask all signals: $!") 625 0 625
867 or _trap "<sg> Unable to mask all signals: $!";
868 }
869  
870 ### Unmask all signals
871 625 ▶sub _data_sig_unmask_all {
Subroutine _data_sig_unmask_all: called CC=4 SCAR=15.2
872 625 ▶ return if RUNNING_IN_HELL;
Branch: 1 branch
BranchTrueFalseTotal
if RUNNING_IN_HELL() 0 625 625
873 625 my $self = $poe_kernel;
874 625 ▶ unless( $signal_mask_none ) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($signal_mask_none) 0 625 625
875 0 $self->_data_sig_mask_build;
876 }
877 625 my $mask_temp = POSIX::SigSet->new();
878 625 ▶ sigprocmask( SIG_SETMASK, $signal_mask_none, $mask_temp )
Branch: 1 branch
BranchTrueFalseTotal
sigprocmask(2, $signal_mask_none, $mask_temp) or _trap("<sg> Unable to unmask all signals: $!") 625 0 625
879 or _trap "<sg> Unable to unmask all signals: $!";
880 }
881  
882  
883  
884 214 ▶sub _data_sig_pipe_finalize {
Subroutine _data_sig_pipe_finalize: called CC=3 SCAR=11.0
885 214 my( $self ) = @_;
886 214 ▶ if( $signal_pipe_read ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($signal_pipe_read) 212 2 214
887 212 $self->loop_ignore_filehandle( $signal_pipe_read, MODE_RD );
888 212 close $signal_pipe_read; undef $signal_pipe_read;
889 }
890 214 ▶ if( $signal_pipe_write ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($signal_pipe_write) 212 2 214
891 212 close $signal_pipe_write; undef $signal_pipe_write;
892 }
893 # Don't send anything more!
894 214 undef( $signal_pipe_pid );
895 }
896  
897 ### Send a signal "message" to the main thread
898 ### Called from the top signal handlers
899 255 ▶sub _data_sig_pipe_send {
Subroutine _data_sig_pipe_send: called CC=6 SCAR=18.5
900 255 local $!;
901  
902 255 my $signal_name = $_[1];
903  
904 255 if( TRACE_SIGNALS ) {
905 _warn "<sg> Caught SIG$signal_name";
906 }
907  
908 255 ▶ return if $finalizing;
Branch: 1 branch
BranchTrueFalseTotal
if $POE::Kernel::finalizing 0 255 255
909  
910 255 ▶ if( not defined $signal_pipe_pid ) {
Branch: 1 branch
BranchTrueFalseTotal
unless (defined $signal_pipe_pid) 0 255 255
911 92 _trap "<sg> _data_sig_pipe_send called before signal pipe was initialized.";
912 }
913  
914 # ugh- has_forked() can't be called fast enough. This warning might
915 # show up before it is called. Should we just detect forking and do it
916 # for the user? Probably not...
917  
918 163 ▶ if( $$ != $signal_pipe_pid ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($$ != $signal_pipe_pid) 0 255 255
919 92 _warn(
920 "<sg> Signal caught in different process than POE::Kernel initialized " .
921 "(newPID=$$ oldPID=$signal_pipe_pid sig=$signal_name).\n"
922 );
923 0 _warn(
924 "Call POE::Kernel->has_forked() in the child process " .
925 "to relocate the signal handler.\n"
926 );
927 }
928  
929 # We're registering signals in a list. Pipes have more finite
930 # capacity, so we'll just write a single-byte semaphore-like token.
931 # It's up to the reader to process the list. Duplicates are
932 # permitted, and their ordering may be significant. Precedent:
933 # http://search.cpan.org/perldoc?IPC%3A%3AMorseSignals
934  
935 163 push @pending_signals, [
936 $signal_name, # SIGINFO_NAME
937 $$, # SIGINFO_SRC_PID
938 ];
939  
940 255 if (TRACE_SIGNALS) {
941 _warn "<sg> Attempting signal pipe write";
942 }
943  
944 255 my $count = syswrite( $signal_pipe_write, '!' );
945  
946 # TODO - We need to crash gracefully if the write fails, but not if
947 # it's due to the pipe being full. We might solve this by only
948 # writing on the edge of @pending_signals == 1 after the push().
949 # We assume @pending_signals > 1 means there's a byte in the pipe,
950 # so the reader will wake up to catch 'em all.
951  
952 255 if ( ASSERT_DATA ) {
953 unless (defined $count and $count == 1) {
954 _trap "<sg> Signal pipe write failed: $!";
955 }
956 }
957 }
958  
959 ### Read all signal numbers.
960 ### Call the related bottom handler. That is, inside the kernel loop.
961 212 ▶sub _data_sig_pipe_read {
Subroutine _data_sig_pipe_read: called CC=12 SCAR=25.0
962 379 my( $self, $fileno, $mode ) = @_;
963  
964 304 if( ASSERT_DATA ) {
965 _trap "Illegal mode=$mode on fileno=$fileno" unless
966 $fileno == $signal_pipe_read_fd
967 and $mode eq MODE_RD;
968 }
969  
970 # Read all data from the signal pipe.
971 # The data itself doesn't matter.
972 # TODO - If writes can happen on the edge of @pending_signals (from
973 # 0 to 1 element), then we oughtn't need to loop here.
974  
975 304 while (1) {
976 300 my $octets_count = sysread( $signal_pipe_read, (my $data), 65536 );
977  
978 424 ▶ next if $octets_count;
Branch: 1 branch
BranchTrueFalseTotal
if $octets_count 88 379 467
979 336 ▶ last if defined $octets_count;
Branch: 1 branch
BranchTrueFalseTotal
if defined $octets_count 124 212 336
980  
981 212 ▶ last if $! == EAGAIN or $! == EWOULDBLOCK;
Branch: 1 branch
BranchTrueFalseTotal
if $! == 11 or $! == 11 88 124 212
Condition66%2/3
$! == 11 or $! == 11
l!l&&r!l&&!r
880291
MC/DC0%0/2
$! == 11 or $! == 11
$! == 11 $! == 11
Truth table33%1/3
A or B
A= $! == 11B= $! == 11
ABresult
1X1
011
000
982  
983 124 if (ASSERT_DATA) {
984 _trap "<sg> Error " . ($!+0) . " reading from signal pipe: $!";
985 }
986 0 elsif(TRACE_SIGNALS) {
987 _warn "<sg> Error " . ($!+0) . " reading from signal pipe: $!";
988 }
989  
990 0 last;
991 }
992  
993 # Double buffer signals.
994 # The intent is to avoid a race condition by processing the same
995 # buffer that new signals go into.
996  
997 88 ▶ return unless @pending_signals;
Branch: 1 branch
BranchTrueFalseTotal
unless @pending_signals 124 88 212
998 212 my @signals = @pending_signals;
999 212 @pending_signals = ();
1000  
1001 212 if (TRACE_SIGNALS) {
1002 _warn "<sg> Read " . scalar(@signals) . " signals from the list";
1003 }
1004  
1005 212 foreach my $signal (@signals) {
1006 212 my $signal_name = $signal->[SIGINFO_NAME];
1007 212 my $signal_src_pid = $signal->[SIGINFO_SRC_PID];
1008  
1009 # Ignore signals from other processes.
1010 # This can happen if we've fork()ed without calling has_forked()
1011 # to reset the signals subsystem.
1012 #
1013 # TODO - We might be able to get rid of has_forked() if PID
1014 # mismatches are detected.
1015  
1016 255 ▶ next if $signal_src_pid != $$;
Branch: 1 branch
BranchTrueFalseTotal
if $signal_src_pid != $$ 0 212 212
1017  
1018 255 ▶ if( $signal_name eq 'CHLD' ) {
Branch: 2 branches
BranchTrueFalseTotal
if ($signal_name eq 'CHLD') { } 88 167 255
elsif ($signal_name eq 'PIPE') { } 139 28 167
1019 255 _loop_signal_handler_chld_bottom( $signal_name );
1020 }
1021 elsif( $signal_name eq 'PIPE' ) {
1022 167 _loop_signal_handler_pipe_bottom( $signal_name );
1023 }
1024 else {
1025 64 _loop_signal_handler_generic_bottom( $signal_name );
1026 }
1027 }
1028 }
1029  
1030 200 1;
1031  
1032 __END__
« blib/lib/POE/Loop/Select.pm ↑ Summary blib/lib/POE/Filter/HTTPD.pm »