← Back to branch summary

~ubuntu-branches/ubuntu/utopic/gridengine/utopic

« back to all changes in this revision

Viewing changes to source/libs/uti/sge_signal.c

  • Committer: Bazaar Package Importer
  • Author(s): Mark Hymers
  • Date: 2008-06-25 22:36:13 UTC
  • Revision ID: james.westby@ubuntu.com-20080625223613-tvd9xlhuoct9kyhm
Tags: upstream-6.2~beta2
Import upstream version 6.2~beta2

Show diffs side-by-side

added added

removed removed

Lines of Context:
source/libs/uti/sge_signal.c
 
1
/*___INFO__MARK_BEGIN__*/
 
2
/*************************************************************************
 
3
 * 
 
4
 *  The Contents of this file are made available subject to the terms of
 
5
 *  the Sun Industry Standards Source License Version 1.2
 
6
 * 
 
7
 *  Sun Microsystems Inc., March, 2001
 
8
 * 
 
9
 * 
 
10
 *  Sun Industry Standards Source License Version 1.2
 
11
 *  =================================================
 
12
 *  The contents of this file are subject to the Sun Industry Standards
 
13
 *  Source License Version 1.2 (the "License"); You may not use this file
 
14
 *  except in compliance with the License. You may obtain a copy of the
 
15
 *  License at http://gridengine.sunsource.net/Gridengine_SISSL_license.html
 
16
 * 
 
17
 *  Software provided under this License is provided on an "AS IS" basis,
 
18
 *  WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
 
19
 *  WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
 
20
 *  MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
 
21
 *  See the License for the specific provisions governing your rights and
 
22
 *  obligations concerning the Software.
 
23
 * 
 
24
 *   The Initial Developer of the Original Code is: Sun Microsystems, Inc.
 
25
 * 
 
26
 *   Copyright: 2001 by Sun Microsystems, Inc.
 
27
 * 
 
28
 *   All Rights Reserved.
 
29
 * 
 
30
 ************************************************************************/
 
31
/*___INFO__MARK_END__*/
 
32
 
 
33
#include <stdlib.h>
 
34
#include <stdio.h>
 
35
#include <string.h>
 
36
#include <signal.h>
 
37
#include <errno.h>
 
38
 
 
39
#include "sge_signal.h"
 
40
#include "sge_string.h"
 
41
 
 
42
#include "msg_utilib.h"
 
43
 
 
44
#ifdef WIN32
 
45
#   define SIGIOT 6
 
46
#   define SIGURG 16
 
47
#   define SIGIO 23
 
48
#   define SIGVTALRM 26
 
49
#   define SIGPROF 27
 
50
#   define SIGWINCH 28
 
51
#endif
 
52
 
 
53
#if defined(CRAY) && !defined(SIGXCPU)
 
54
#   define SIGXCPU SIGCPULIM
 
55
#endif
 
56
 
 
57
#if defined(ALPHA)
 
58
#  undef NSIG
 
59
#  define NSIG (SIGUSR2+1)
 
60
#endif
 
61
 
 
62
const sig_mapT sig_map[] = 
 
63
{
 
64
   {SGE_SIGHUP, SIGHUP, "HUP"},
 
65
   {SGE_SIGINT, SIGINT, "INT"},
 
66
   {SGE_SIGQUIT, SIGQUIT, "QUIT"},
 
67
   {SGE_SIGILL, SIGILL, "ILL"},
 
68
   {SGE_SIGTRAP, SIGTRAP, "TRAP"},
 
69
   {SGE_SIGABRT, SIGABRT, "ABRT"},
 
70
   {SGE_SIGIOT, SIGIOT, "IOT"},
 
71
#ifdef SIGEMT
 
72
   {SGE_SIGEMT, SIGEMT, "EMT"},
 
73
#else
 
74
   {SGE_SIGEMT, SIGUNKNOWN, "EMT"},
 
75
#endif
 
76
   {SGE_SIGFPE, SIGFPE, "FPE"},
 
77
   {SGE_SIGKILL, SIGKILL, "KILL"},
 
78
   {SGE_SIGSEGV, SIGSEGV, "SEGV"},
 
79
   {SGE_SIGPIPE, SIGPIPE, "PIPE"},
 
80
   {SGE_SIGALRM, SIGALRM, "ALRM"},
 
81
   {SGE_SIGTERM, SIGTERM, "TERM"},
 
82
   {SGE_SIGURG, SIGURG, "URG"},
 
83
   {SGE_SIGSTOP, SIGSTOP, "STOP"},
 
84
   {SGE_SIGTSTP, SIGTSTP, "TSTP"},
 
85
   {SGE_SIGCONT, SIGCONT, "CONT"},
 
86
   {SGE_SIGCHLD, SIGCHLD, "CHLD"},
 
87
   {SGE_SIGTTIN, SIGTTIN, "TTIN"},
 
88
   {SGE_SIGTTOU, SIGTTOU, "TTOU"},
 
89
   {SGE_SIGIO, SIGIO, "IO"},
 
90
   {SGE_SIGXCPU, SIGXCPU, "XCPU"},
 
91
#ifndef CRAY
 
92
   {SGE_SIGXFSZ, SIGXFSZ, "XFSZ"},
 
93
#endif
 
94
#if !(defined(CRAY) || defined(NECSX4) || defined(NECSX5))
 
95
   {SGE_SIGVTALRM, SIGVTALRM, "VTALRM"},
 
96
   {SGE_SIGPROF, SIGPROF, "PROF"},
 
97
#endif
 
98
   {SGE_SIGWINCH, SIGWINCH, "WINCH"},
 
99
   {SGE_SIGUSR1, SIGUSR1, "USR1"},
 
100
   {SGE_SIGUSR2, SIGUSR2, "USR2"},
 
101
   {SGE_SIGBUS, SIGBUS, "BUS"},
 
102
   {SGE_MIGRATE, SIGTTOU, "MIGRATE"},
 
103
   {0, 0}
 
104
};
 
105
 
 
106
/****** uti/signal/sge_unmap_signal() *****************************************
 
107
*  NAME
 
108
*     sge_unmap_signal() -- Unmap 32bit SGE/EE signal to system signal 
 
109
*
 
110
*  SYNOPSIS
 
111
*     int sge_unmap_signal(u_long32 sge_sig) 
 
112
*
 
113
*  FUNCTION
 
114
*     Unmap the 32bit SGE/EEsignal to the system specific signal 
 
115
*
 
116
*  INPUTS
 
117
*     u_long32 sge_sig - SGE/EE signal 
 
118
*
 
119
*  RESULT
 
120
*     int - system signal
 
121
*
 
122
*  NOTES
 
123
*     MT-NOTE: sge_unmap_signal() is MT safe
 
124
*
 
125
******************************************************************************/
 
126
int sge_unmap_signal(u_long32 sge_sig) 
 
127
{
 
128
   const sig_mapT *mapptr=sig_map;
 
129
 
 
130
   while (mapptr->sge_sig) {
 
131
      if (mapptr->sge_sig == sge_sig) {
 
132
         return mapptr->sig;
 
133
      }
 
134
      mapptr++;
 
135
   }
 
136
   return -1;
 
137
}
 
138
 
 
139
/****** uti/signal/sge_map_signal() *******************************************
 
140
*  NAME
 
141
*     sge_map_signal() -- Map system signal to 32bit SGE/EE signal 
 
142
*
 
143
*  SYNOPSIS
 
144
*     u_long32 sge_map_signal(int sys_sig) 
 
145
*
 
146
*  FUNCTION
 
147
*     Map the system specific signal to the 32bit sge signal 
 
148
*
 
149
*  INPUTS
 
150
*     int sys_sig - system signal 
 
151
*
 
152
*  RESULT
 
153
*     u_long32 - SGE/EE Signal
 
154
*
 
155
*  NOTES
 
156
*     MT-NOTE: sge_map_signal() is MT safe
 
157
*
 
158
******************************************************************************/
 
159
u_long32 sge_map_signal(int sys_sig) 
 
160
{
 
161
   const sig_mapT *mapptr=sig_map;
 
162
 
 
163
   while (mapptr->sge_sig) {
 
164
      if (mapptr->sig == sys_sig) {
 
165
         return mapptr->sge_sig;
 
166
      }
 
167
      mapptr++;
 
168
   }
 
169
   return -1;
 
170
}
 
171
 
 
172
/****** uti/signal/sge_str2signal() ********************************************
 
173
*  NAME
 
174
*     str2signal() -- Make a SGE/SGEEE signal out of a string 
 
175
*
 
176
*  SYNOPSIS
 
177
*     u_long32 sge_str2signal(const char *str) 
 
178
*
 
179
*  FUNCTION
 
180
*     Make a sge signal out of a string. 'str' can be the signal name 
 
181
*     (caseinsensitive) without sig or the signal number (Take care 
 
182
*     numbers are system dependent).
 
183
*
 
184
*  INPUTS
 
185
*     const char *str - signal string 
 
186
*
 
187
*  RESULT
 
188
*     u_long32 - SGE/EE signal 
 
189
*
 
190
*  NOTES
 
191
*     MT-NOTE: sge_str2signal() is MT safe
 
192
*
 
193
******************************************************************************/
 
194
u_long32 sge_str2signal(const char *str) 
 
195
{
 
196
   const sig_mapT *mapptr=sig_map;
 
197
   u_long32 signum;
 
198
 
 
199
   /* look for signal names in mapping table */
 
200
   while (mapptr->sge_sig) {
 
201
      if (!strcasecmp(str, mapptr->signame)) {
 
202
         return mapptr->sge_sig;
 
203
      }
 
204
      mapptr++;
 
205
   }
 
206
 
 
207
   /* could not find per name -> look for signal numbers */
 
208
   if (sge_strisint(str)) {
 
209
      signum = strtol(str, NULL, 10);
 
210
      mapptr = sig_map;
 
211
      while (mapptr->sge_sig) {
 
212
         if ((int) signum ==  mapptr->sig) {
 
213
            return mapptr->sge_sig;
 
214
         }
 
215
         mapptr++;
 
216
      }
 
217
   }
 
218
 
 
219
   return -1;
 
220
}
 
221
 
 
222
/****** uti/signal/sge_sys_str2signal() ***************************************
 
223
*  NAME
 
224
*     sge_sys_str2signal() -- Make a SGE/SGEEE signal out of a string 
 
225
*
 
226
*  SYNOPSIS
 
227
*     u_long32 sge_sys_str2signal(const char *str) 
 
228
*
 
229
*  FUNCTION
 
230
*     Make a SGE/SGEEE signal out of a string 
 
231
*
 
232
*  INPUTS
 
233
*     const char *str - signal name 
 
234
*
 
235
*  RESULT
 
236
*     u_long32 - SGE/EE signal
 
237
*
 
238
*  NOTES
 
239
*     MT-NOTE: sge_sys_str2signal() is MT safe
 
240
*
 
241
******************************************************************************/
 
242
u_long32 sge_sys_str2signal(const char *str) 
 
243
{
 
244
   const sig_mapT *mapptr=sig_map;
 
245
   u_long32 signum;
 
246
 
 
247
   /* look for signal names in mapping table */
 
248
   while (mapptr->sge_sig) {
 
249
      if (!strcasecmp(str, mapptr->signame)) {
 
250
         return mapptr->sig;
 
251
      }
 
252
      mapptr++;
 
253
   }
 
254
 
 
255
   /* could not find per name -> look for signal numbers */
 
256
   if (sge_strisint(str)) {
 
257
      signum = strtol(str, NULL, 10);
 
258
      return signum;
 
259
   }
 
260
 
 
261
   return -1;
 
262
}
 
263
 
 
264
/****** uti/signal/sge_sig2str() **********************************************
 
265
*  NAME
 
266
*     sge_sig2str() -- Make a string out of a SGE/EE signal 
 
267
*
 
268
*  SYNOPSIS
 
269
*     const char* sge_sig2str(u_long32 sge_sig) 
 
270
*
 
271
*  FUNCTION
 
272
*     Make a string out of a SGE/EE signal    
 
273
*
 
274
*  INPUTS
 
275
*     u_long32 sge_sig - SGE/EE signal
 
276
*
 
277
*  RESULT
 
278
*     const char* - signal string
 
279
*
 
280
*  NOTES
 
281
*     MT-NOTE: sge_sig2str() is MT safe
 
282
*
 
283
******************************************************************************/
 
284
const char *sge_sig2str(u_long32 sge_sig) 
 
285
{
 
286
   const sig_mapT *mapptr;
 
287
 
 
288
   /* look for signal names in mapping table */
 
289
   for (mapptr=sig_map; mapptr->sge_sig; mapptr++) {
 
290
      if (sge_sig == mapptr->sge_sig) {
 
291
         return mapptr->signame;
 
292
      }
 
293
   }
 
294
 
 
295
   return MSG_PROC_UNKNOWNSIGNAL;
 
296
}
 
297
 
 
298
/****** uti/signal/sge_sys_sig2str() ******************************************
 
299
*  NAME
 
300
*     sge_sys_sig2str() -- Make a string out of a system signal 
 
301
*
 
302
*  SYNOPSIS
 
303
*     const char* sge_sys_sig2str(u_long32 sys_sig) 
 
304
*
 
305
*  FUNCTION
 
306
*     Make a string out of a system signal 
 
307
*
 
308
*  INPUTS
 
309
*     u_long32 sys_sig - system signal 
 
310
*
 
311
*  RESULT
 
312
*     const char* - signal string
 
313
*
 
314
*  NOTES
 
315
*     MT-NOTE: sge_sys_sig2str() is MT safe
 
316
*
 
317
******************************************************************************/
 
318
const char *sge_sys_sig2str(u_long32 sys_sig) 
 
319
{
 
320
   const sig_mapT *mapptr;
 
321
 
 
322
   /* look for signal names in mapping table */
 
323
   for (mapptr=sig_map; mapptr->sge_sig; mapptr++) {
 
324
      if ((int) sys_sig == mapptr->sig) {
 
325
         return mapptr->signame;
 
326
      }
 
327
   }
 
328
 
 
329
   return MSG_PROC_UNKNOWNSIGNAL;
 
330
}
 
331
 
 
332
/****** uti/signal/sge_set_def_sig_mask() *************************************
 
333
*  NAME
 
334
*     sge_set_def_sig_mask() -- Set signal mask to default
 
335
*
 
336
*  SYNOPSIS
 
337
*     void sge_set_def_sig_mask(int sig_num, err_func_t err_func)
 
338
*
 
339
*  FUNCTION
 
340
*     Set signal mask to default for all signals except given signal
 
341
*
 
342
*  INPUTS
 
343
*     sigset_t sig_num    - signals which should be ignored
 
344
*                           (use sigemptyset and sigaddset to set signals,
 
345
*                           if NULL, no signals are ignored)
 
346
*     err_func_t err_func - callback function to report errors
 
347
*
 
348
*  NOTES
 
349
*     MT-NOTE: sge_set_def_sig_mask() is MT safe
 
350
*
 
351
******************************************************************************/
 
352
void sge_set_def_sig_mask(sigset_t* sig_num, err_func_t err_func)
 
353
{
 
354
   int i = 1;
 
355
   struct sigaction sig_vec;
 
356
   
 
357
   while (i < NSIG) {
 
358
      /*
 
359
       * never set default handler for 
 
360
       * SIGKILL and SIGSTOP
 
361
       */
 
362
      if ((i == SIGKILL) || (i == SIGSTOP)) {
 
363
         i++;
 
364
         continue;
 
365
      }
 
366
 
 
367
      /*
 
368
       * on HPUX don't set default handler for
 
369
       * _SIGRESERVE and SIGDIL
 
370
       */
 
371
#if defined(HPUX)
 
372
      if ((i == _SIGRESERVE) || (i == SIGDIL)) {
 
373
         i++;
 
374
         continue;
 
375
      }
 
376
#endif     
 
377
 
 
378
      /*
 
379
       * never set default handler for signals set
 
380
       * in sig_num if not NULL 
 
381
       */
 
382
      if (sig_num != NULL && sigismember(sig_num, i)) {
 
383
         i++;
 
384
         continue;
 
385
      }
 
386
 
 
387
      errno = 0;
 
388
      sigemptyset(&sig_vec.sa_mask);
 
389
      sig_vec.sa_flags = 0;
 
390
      sig_vec.sa_handler = 0;
 
391
      sig_vec.sa_handler = SIG_DFL;
 
392
      if (sigaction(i, &sig_vec, NULL)) {
 
393
         if (err_func) {
 
394
            char err_str[256];
 
395
            snprintf(err_str, 256, MSG_PROC_SIGACTIONFAILED_IS, i, strerror(errno));
 
396
            err_func(err_str);
 
397
         }
 
398
      }
 
399
      i++;
 
400
   }
 
401
}   
 
402
 
 
403
/****** uti/signal/sge_unblock_all_signals() **********************************
 
404
*  NAME
 
405
*     sge_unblock_all_signals()
 
406
*
 
407
*  SYNOPSIS
 
408
*     void sge_unblock_all_signals(void)
 
409
*
 
410
*  FUNCTION
 
411
*     Allow for all signals.
 
412
*
 
413
*  NOTES
 
414
*     MT-NOTE: sge_unblock_all_signals() is MT safe
 
415
*
 
416
*******************************************************************************/
 
417
void sge_unblock_all_signals(void)
 
418
{
 
419
   sigset_t sigmask;
 
420
   /* unblock all signals */
 
421
   /* without this we depend on shell to unblock the signals */
 
422
   /* result is that SIGXCPU was not delivered with several shells */
 
423
   sigemptyset(&sigmask);
 
424
   sigprocmask(SIG_SETMASK, &sigmask, NULL);
 
425
}
 
426
 
 
427