-
Notifications
You must be signed in to change notification settings - Fork 54
/
timeout.m
670 lines (557 loc) · 15.7 KB
/
timeout.m
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
%-----------------------------------------------------------------------------%
% Copyright (C) 2001-2002 The University of Melbourne.
% This file may only be copied under the terms of the GNU General
% Public License - see the file COPYING in the Mercury distribution.
%-----------------------------------------------------------------------------%
%
% Author: zs.
%
% This module implements timeouts and cleanup for the deep profiler.
%
% The timeout design we use and its rationale are given in the file DESIGN.
%
% The cleanup system consists of an array of filenames. When the profiler
% creates a temporary file, it adds its name to the array; when it deletes
% the temporary file, it deletes its name from the array. When we get an
% unexpected signal, we clean up by deleting all the temporary files named
% in the array. The
%
% We establish the exit action to clean up the files as soon as they are
% created, but we don't want the parent process after the fork to delete them
% while they are still in use by the child process. This is prevented by the
% boolean flag process_is_detached_server.
:- module timeout.
:- interface.
:- import_module bool, io.
% Add the given file name to the list of files to be cleaned up.
:- pred register_file_for_cleanup(string::in, io__state::di, io__state::uo)
is det.
% Remove the given file name from the list of files to be cleaned up.
:- pred unregister_file_for_cleanup(string::in, io__state::di, io__state::uo)
is det.
% Remove all file names from the list of files to be cleaned up.
:- pred unregister_all_files_for_cleanup(io__state::di, io__state::uo) is det.
% Delete all the files on the cleanup list.
:- pred delete_cleanup_files(io__state::di, io__state::uo) is det.
% Set up signal handlers for all the signals we can catch. The three strings
% specify the name of the mutex file, the name of the directory containing the
% `want' files, and the prefix of the names of the `want' files.
:- pred setup_signals(string::in, string::in, string::in,
io__state::di, io__state::uo) is det.
% Set up a timeout for the given number of minutes in the future.
:- pred setup_timeout(int::in, io__state::di, io__state::uo) is det.
% Get the lock on the named mutex file if the bool is `no'.
% (The mutex file exists iff some process holds the lock.)
% If the bool is `yes', meaning debugging is enabled, do nothing.
:- pred get_lock(bool::in, string::in,
io__state::di, io__state::uo) is det.
% Release the lock on the named mutex file if the bool is `no'.
% (The mutex file exists iff some process holds the lock.)
% If the bool is `yes', meaning debugging is enabled, do nothing.
:- pred release_lock(bool::in, string::in,
io__state::di, io__state::uo) is det.
% Create the `want' file with the given name.
:- pred make_want_file(string::in, io__state::di, io__state::uo) is det.
% Delete the `want' file with the given name.
:- pred remove_want_file(string::in, io__state::di, io__state::uo) is det.
:- implementation.
:- import_module int.
:- import_module string.
:- pragma foreign_decl("C",
"
#ifdef MR_DEEP_PROFILER_ENABLED
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h> /* for O_CREAT, O_EXCL */
#include <signal.h> /* for signal numbers */
#include <unistd.h> /* for alarm() */
#include <stdio.h>
#include <errno.h> /* for EEXIST etc */
#include <dirent.h>
#include ""mercury_signal.h""
#define MP_MAX_CLEANUP_FILES 20 /* this should be plenty */
extern const char *MP_cleanup_files[MP_MAX_CLEANUP_FILES];
extern int MP_cleanup_file_next;
extern void MP_maybe_print_cleanup_files(const char *msg);
extern void MP_register_cleanup_file(const char *filename);
extern void MP_unregister_cleanup_file(const char *filename);
extern void MP_handle_fatal_exception(void *data);
extern void MP_delete_cleanup_files(void);
extern void MP_delete_cleanup_files_and_exit_failure(
const char *signal_name);
extern int MP_timeout_seconds;
extern const char *MP_timeout_mutex_file;
extern const char *MP_timeout_want_dir;
extern const char *MP_timeout_want_prefix;
typedef struct
{
int MP_signum;
void (*MP_handler)(void);
} MP_sig_handler;
extern const MP_sig_handler MP_signal_structs[];
extern void MP_handle_timeout(void);
extern void MP_handle_sig_term(void);
extern void MP_handle_sig_hup(void);
extern void MP_handle_sig_int(void);
extern void MP_handle_sig_quit(void);
extern void MP_handle_sig_ill(void);
extern void MP_handle_sig_abrt(void);
extern void MP_handle_sig_bus(void);
extern void MP_handle_sig_fpe(void);
extern void MP_handle_sig_segv(void);
extern void MP_handle_sig_pipe(void);
extern MR_bool MP_do_try_get_lock(const char *mutex_file);
extern void MP_do_get_lock(const char *mutex_file);
extern void MP_do_release_lock(const char *mutex_file);
#endif
").
:- pragma foreign_code("C",
"
#ifdef MR_DEEP_PROFILER_ENABLED
#include <sys/types.h>
const char *MP_cleanup_files[MP_MAX_CLEANUP_FILES];
int MP_cleanup_file_next = 0;
int MP_timeout_seconds = 30 * 60;
const char *MP_timeout_mutex_file = NULL;
const char *MP_timeout_want_dir = NULL;
const char *MP_timeout_want_prefix = NULL;
/* set this variable to MR_TRUE to debug the code cleanup array */
MR_bool MP_print_cleanup_files = MR_FALSE;
void
MP_maybe_print_cleanup_files(const char *msg)
{
int i;
if (MP_print_cleanup_files) {
fprintf(stderr, ""\\n%s cleanup files:\\n"", msg);
for (i = 0; i < MP_cleanup_file_next; i++) {
fprintf(stderr, ""%i %s\\n"", i, MP_cleanup_files[i]);
}
}
}
void
MP_register_cleanup_file(const char *filename)
{
int i;
if (MP_cleanup_file_next >= MP_MAX_CLEANUP_FILES - 1) {
MR_fatal_error(""MP_register_cleanup_file: too many entries"");
}
for (i = 0; i < MP_cleanup_file_next; i++) {
if (MR_streq(filename, MP_cleanup_files[i])) {
MR_fatal_error(""MP_register_cleanup_file: duplicate"");
}
}
MP_cleanup_files[MP_cleanup_file_next] = filename;
MP_cleanup_file_next++;
MP_maybe_print_cleanup_files(""register"");
}
void
MP_unregister_cleanup_file(const char *filename)
{
int i;
int j;
for (i = 0; i < MP_cleanup_file_next; i++) {
if (MR_streq(filename, MP_cleanup_files[i])) {
/* shift the array entries above index i down one */
for (j = i + 1; j < MP_cleanup_file_next; j++) {
MP_cleanup_files[j - 1] = MP_cleanup_files[j];
}
MP_cleanup_file_next--;
MP_maybe_print_cleanup_files(""unregister"");
return;
}
}
MR_fatal_error(""MP_unregister_cleanup_file: not found"");
}
void
MP_handle_fatal_exception(void *data)
{
/* we ignore data */
MP_delete_cleanup_files();
}
void
MP_delete_cleanup_files(void)
{
int i;
MR_bool delayed_mutex_file;
/*
** We want to remove the mutex file only after we have removed the
** files manipulated by the critical section it was protecting.
*/
MP_maybe_print_cleanup_files(""delete"");
delayed_mutex_file = MR_FALSE;
for (i = 0; i < MP_cleanup_file_next; i++) {
if (MR_streq(MP_timeout_mutex_file, MP_cleanup_files[i])) {
delayed_mutex_file = MR_TRUE;
} else {
if (remove(MP_cleanup_files[i]) != 0) {
perror(MP_cleanup_files[i]);
}
}
}
if (delayed_mutex_file) {
if (remove(MP_timeout_mutex_file) != 0) {
perror(MP_timeout_mutex_file);
}
}
MP_cleanup_file_next = 0;
}
void
MP_delete_cleanup_files_and_exit_failure(const char *signal_name)
{
FILE *fp;
char buf[1024]; /* that should be big enough */
#ifdef MP_DEBUG_MDPROF_SIGNAL
fp = fopen(""/tmp/mdprof_signal"", ""w"");
if (fp != NULL) {
fprintf(fp, ""%s\\n"", signal_name);
(void) fclose(fp);
}
#endif
MP_delete_cleanup_files();
#ifdef MP_DEBUG_MDPROF_SIGNAL
sprintf(buf, ""Mercury deep profiler: received unexpected signal %s"",
signal_name);
MR_fatal_error(buf);
#else
exit(EXIT_FAILURE);
#endif
}
/*
** SIGALRM alarm signal indicates a timeout. SIGTERM usually indicates the
** machine is being shut down. The others are there to catch forceful shutdowns
** during development, both intentional ones where the programmer sends the
** signal and those caused by bugs in the server code. We would like to include
** all catchable, fatal signals in this list, but that set is somewhat OS
** dependent. The set whose existence we test for here includes all the
** signals that are at all likely to be sent to server process.
**
** We don't test for the existence of SIGALRM, because we want compilation to
** fail if it does not exist. Without alarm signals, server processes will
** never be timed out, and thus constitute a resource leak (mostly of virtual
** memory/swap space).
**
** We could avoid this problem if we had a version of atexit that executed
** its actions even when the program exits after a signal.
*/
const MP_sig_handler MP_signal_structs[] =
{
{ SIGALRM, MP_handle_timeout },
#ifdef SIGTERM
{ SIGTERM, MP_handle_sig_term },
#endif
#ifdef SIGHUP
{ SIGHUP, MP_handle_sig_hup },
#endif
#ifdef SIGINT
{ SIGINT, MP_handle_sig_int },
#endif
#ifdef SIGQUIT
{ SIGQUIT, MP_handle_sig_quit },
#endif
#ifdef SIGILL
{ SIGILL, MP_handle_sig_ill },
#endif
#ifdef SIGABRT
{ SIGABRT, MP_handle_sig_abrt },
#endif
#ifdef SIGBUS
{ SIGBUS, MP_handle_sig_bus },
#endif
#ifdef SIGFPE
{ SIGFPE, MP_handle_sig_fpe },
#endif
#ifdef SIGSEGV
{ SIGSEGV, MP_handle_sig_segv },
#endif
#ifdef SIGPIPE
{ SIGPIPE, MP_handle_sig_pipe },
#endif
{ -1, NULL }
};
void
MP_handle_timeout(void)
{
DIR *dir;
struct dirent *dirent;
int matchlen;
MR_bool success;
if (MP_timeout_want_dir == NULL || MP_timeout_want_prefix == NULL) {
MR_fatal_error(""MP_handle_timeout: null dir or prefix"");
}
matchlen = strlen(MP_timeout_want_prefix);
success = MP_do_try_get_lock(MP_timeout_mutex_file);
if (! success) {
/*
** We could not get the lock, so some other process holds it.
** We therefore abort the timeout, but schedule the next one.
*/
(void) alarm(MP_timeout_seconds);
return;
}
dir = opendir(MP_timeout_want_dir);
if (dir == NULL) {
MR_fatal_error(""MP_handle_timeout: opendir failed"");
}
while ((dirent = readdir(dir)) != NULL) {
if (MR_strneq(dirent->d_name, MP_timeout_want_prefix,
matchlen))
{
/* abort the timeout */
(void) closedir(dir);
(void) alarm(MP_timeout_seconds);
return;
}
}
(void) closedir(dir);
/*
** This call will delete the mutex file last, releasing the mutex
*/
MP_delete_cleanup_files();
exit(EXIT_SUCCESS);
}
void
MP_handle_sig_term(void)
{
MP_delete_cleanup_files_and_exit_failure(""SIGTERM"");
}
void
MP_handle_sig_hup(void)
{
MP_delete_cleanup_files_and_exit_failure(""SIGHUP"");
}
void
MP_handle_sig_int(void)
{
MP_delete_cleanup_files_and_exit_failure(""SIGINT"");
}
void
MP_handle_sig_quit(void)
{
MP_delete_cleanup_files_and_exit_failure(""SIGQUIT"");
}
void
MP_handle_sig_ill(void)
{
MP_delete_cleanup_files_and_exit_failure(""SIGILL"");
}
void
MP_handle_sig_abrt(void)
{
MP_delete_cleanup_files_and_exit_failure(""SIGABRT"");
}
void
MP_handle_sig_bus(void)
{
MP_delete_cleanup_files_and_exit_failure(""SIGBUS"");
}
void
MP_handle_sig_fpe(void)
{
MP_delete_cleanup_files_and_exit_failure(""SIGFPE"");
}
void
MP_handle_sig_segv(void)
{
MP_delete_cleanup_files_and_exit_failure(""SIGSEGV"");
}
void
MP_handle_sig_pipe(void)
{
MP_delete_cleanup_files_and_exit_failure(""SIGPIPE"");
}
MR_bool
MP_do_try_get_lock(const char *mutex_file)
{
int res;
MR_bool success;
res = open(mutex_file, O_CREAT | O_EXCL, 0);
if (res >= 0) {
(void) close(res);
MP_register_cleanup_file(mutex_file);
success = MR_TRUE;
} else if (res < 0 && errno == EEXIST) {
success = MR_FALSE;
} else {
MR_fatal_error(""MP_do_try_get_lock failed"");
}
return res;
}
void
MP_do_get_lock(const char *mutex_file)
{
int res;
for (;;) {
res = open(mutex_file, O_CREAT | O_EXCL, 0);
if (res >= 0) {
(void) close(res);
MP_register_cleanup_file(mutex_file);
return;
} else if (res < 0 && errno == EEXIST) {
sleep(5);
continue;
} else {
MR_fatal_error(""MP_do_get_lock failed"");
}
}
}
void
MP_do_release_lock(const char *mutex_file)
{
MP_unregister_cleanup_file(mutex_file);
(void) unlink(mutex_file);
}
#endif /* MR_DEEP_PROFILER_ENABLED */
").
:- pragma foreign_proc("C",
register_file_for_cleanup(File::in, S0::di, S::uo),
[will_not_call_mercury, promise_pure],
"
#ifdef MR_DEEP_PROFILER_ENABLED
MP_register_cleanup_file(File);
S = S0;
#else
MR_fatal_error(""deep profiler not enabled"");
#endif
").
:- pragma foreign_proc("C",
unregister_file_for_cleanup(File::in, S0::di, S::uo),
[will_not_call_mercury, promise_pure],
"
#ifdef MR_DEEP_PROFILER_ENABLED
MP_unregister_cleanup_file(File);
S = S0;
#else
MR_fatal_error(""deep profiler not enabled"");
#endif
").
:- pragma foreign_proc("C",
unregister_all_files_for_cleanup(S0::di, S::uo),
[will_not_call_mercury, promise_pure],
"
#ifdef MR_DEEP_PROFILER_ENABLED
MP_cleanup_file_next = 0;
S = S0;
#else
MR_fatal_error(""deep profiler not enabled"");
#endif
").
:- pragma foreign_proc("C",
delete_cleanup_files(S0::di, S::uo),
[will_not_call_mercury, promise_pure],
"
#ifdef MR_DEEP_PROFILER_ENABLED
MP_delete_cleanup_files();
S = S0;
#else
MR_fatal_error(""deep profiler not enabled"");
#endif
").
:- pragma foreign_proc("C",
setup_signals(MutexFile::in, WantDir::in, WantPrefix::in,
S0::di, S::uo),
[will_not_call_mercury, promise_pure],
"
#ifdef MR_DEEP_PROFILER_ENABLED
int i;
MP_timeout_mutex_file = MutexFile;
MP_timeout_want_dir = WantDir;
MP_timeout_want_prefix = WantPrefix;
for (i = 0; MP_signal_structs[i].MP_signum >= 0; i++) {
MR_setup_signal(MP_signal_structs[i].MP_signum,
MP_signal_structs[i].MP_handler, MR_FALSE,
""Mercury deep profiler: cannot setup signal exit"");
}
/*
** Mercury exceptions do not cause signals. The default exception
** handler prints and error message and exits. To ensure that
** we delete up the files we need to clean up, we get the exit
** library function to invoke MP_delete_cleanup_files through
** MP_handle_fatal_exception.
*/
MR_register_exception_cleanup(MP_handle_fatal_exception, NULL);
S = S0;
#else
MR_fatal_error(""deep profiler not enabled"");
#endif
").
:- pragma foreign_proc("C",
setup_timeout(Minutes::in, S0::di, S::uo),
[will_not_call_mercury, promise_pure],
"
#ifdef MR_DEEP_PROFILER_ENABLED
MP_timeout_seconds = Minutes * 60;
(void) alarm(MP_timeout_seconds);
S = S0;
#else
MR_fatal_error(""deep profiler not enabled"");
#endif
").
%-----------------------------------------------------------------------------%
get_lock(Debug, MutexFile) -->
(
{ Debug = yes }
;
{ Debug = no },
do_get_lock(MutexFile)
).
release_lock(Debug, MutexFile) -->
(
{ Debug = yes }
;
{ Debug = no },
do_release_lock(MutexFile)
).
:- pred do_get_lock(string::in, io__state::di, io__state::uo) is det.
:- pragma foreign_proc("C",
do_get_lock(MutexFile::in, S0::di, S::uo),
[will_not_call_mercury, promise_pure, tabled_for_io],
"
#ifdef MR_DEEP_PROFILER_ENABLED
MP_do_get_lock(MutexFile);
S = S0;
#else
MR_fatal_error(""deep profiler not enabled"");
#endif
").
:- pred do_release_lock(string::in, io__state::di, io__state::uo)
is det.
:- pragma foreign_proc("C",
do_release_lock(MutexFile::in, S0::di, S::uo),
[will_not_call_mercury, promise_pure, tabled_for_io],
"
#ifdef MR_DEEP_PROFILER_ENABLED
MP_do_release_lock(MutexFile);
S = S0;
#else
MR_fatal_error(""deep profiler not enabled"");
#endif
").
:- pragma foreign_proc("C",
make_want_file(WantFileName::in, S0::di, S::uo),
[will_not_call_mercury, promise_pure],
"
#ifdef MR_DEEP_PROFILER_ENABLED
int fd;
fd = open(WantFileName, O_CREAT, 0);
if (fd < 0) {
MR_fatal_error(""make_want_file: open failed"");
}
(void) close(fd);
MP_register_cleanup_file(WantFileName);
S = S0;
#else
MR_fatal_error(""deep profiler not enabled"");
#endif
").
:- pragma foreign_proc("C",
remove_want_file(WantFileName::in, S0::di, S::uo),
[will_not_call_mercury, promise_pure],
"
#ifdef MR_DEEP_PROFILER_ENABLED
MP_unregister_cleanup_file(WantFileName);
(void) unlink(WantFileName);
S = S0;
#else
MR_fatal_error(""deep profiler not enabled"");
#endif
").