Changeset 35929a


Ignore:
Timestamp:
04/28/10 10:19:48 (4 years ago)
Author:
Pavan Balaji <balaji@…>
Branches:
master
Children:
20317f
Parents:
1ed50b
Message:

[svn-r6576] Make VA_ARGS a requirement for Hydra.

Location:
src/pm/hydra
Files:
25 edited

Legend:

Unmodified
Added
Removed
  • src/pm/hydra/configure.in

    rf7de66 r35929a  
    543543pac_tmp_compile='$CC $CFLAGS conftest.c -o conftest' 
    544544if AC_TRY_EVAL(pac_tmp_compile) && test -s conftest ; then 
    545    AC_DEFINE(COMPILER_ACCEPTS_VA_ARGS,1,[Define if compiler supports __VA_ARGS__]) 
    546545   AC_MSG_RESULT(yes) 
    547546else 
    548547   AC_MSG_RESULT(no) 
     548   AC_ERROR([Hydra needs a compiler that supports __VA_ARGS__]) 
    549549fi 
    550550rm -f conftest* 
  • src/pm/hydra/include/hydra_utils.h

    r76fe1e r35929a  
    1010#include "hydra_base.h" 
    1111#include "mpl.h" 
     12 
     13extern char *HYD_dbg_prefix; 
     14 
     15#define HYDU_dump_prefix(fp)                    \ 
     16    {                                           \ 
     17        fprintf(fp, "[%s] ", HYD_dbg_prefix);   \ 
     18        fflush(fp);                             \ 
     19    } 
     20 
     21#define HYDU_dump_noprefix(fp, ...)             \ 
     22    {                                           \ 
     23        fprintf(fp, __VA_ARGS__);               \ 
     24        fflush(fp);                             \ 
     25    } 
     26 
     27#define HYDU_dump(fp, ...)                      \ 
     28    {                                           \ 
     29        HYDU_dump_prefix(fp);                   \ 
     30        HYDU_dump_noprefix(fp, __VA_ARGS__);    \ 
     31    } 
    1232 
    1333#if defined HAVE__FUNC__ 
     
    1939#endif 
    2040 
    21 #if !defined COMPILER_ACCEPTS_VA_ARGS 
    22 #define HYDU_error_printf printf 
    23 #elif defined __FILE__ && defined HYDU_FUNC 
     41#if defined __FILE__ && defined HYDU_FUNC 
    2442#define HYDU_error_printf(...)                                          \ 
    2543    {                                                                   \ 
     
    4664    {                                                                   \ 
    4765        if (!(x)) {                                                     \ 
    48             HYDU_ERR_SETANDJUMP1(status, HYD_INTERNAL_ERROR,            \ 
     66            HYDU_ERR_SETANDJUMP(status, HYD_INTERNAL_ERROR,             \ 
    4967                                 "assert (%s) failed\n", #x);           \ 
    5068        }                                                               \ 
     
    5775    } 
    5876 
    59 #define HYDU_ERR_POP(status, message)                                   \ 
     77#define HYDU_ERR_POP(status, ...)                                       \ 
    6078    {                                                                   \ 
    6179        if (status && !HYD_SILENT_ERROR(status)) {                      \ 
    62             if (strlen(message))                                        \ 
    63                 HYDU_error_printf(message);                             \ 
     80            HYDU_error_printf(__VA_ARGS__);                             \ 
    6481            goto fn_fail;                                               \ 
    6582        }                                                               \ 
     
    6986    } 
    7087 
    71 #define HYDU_ERR_POP1(status, message, arg1)                            \ 
    72     {                                                                   \ 
    73         if (status && !HYD_SILENT_ERROR(status)) {                      \ 
    74             if (strlen(message))                                        \ 
    75                 HYDU_error_printf(message, arg1);                       \ 
    76             goto fn_fail;                                               \ 
    77         }                                                               \ 
    78         else if (HYD_SILENT_ERROR(status)) {                            \ 
    79             goto fn_exit;                                               \ 
    80         }                                                               \ 
    81     } 
    82  
    83 #define HYDU_ERR_POP2(status, message, arg1, arg2)                      \ 
    84     {                                                                   \ 
    85         if (status && !HYD_SILENT_ERROR(status)) {                      \ 
    86             if (strlen(message))                                        \ 
    87                 HYDU_error_printf(message, arg1, arg2);                 \ 
    88             goto fn_fail;                                               \ 
    89         }                                                               \ 
    90         else if (HYD_SILENT_ERROR(status)) {                            \ 
    91             goto fn_exit;                                               \ 
    92         }                                                               \ 
    93     } 
    94  
    95 #define HYDU_ERR_SETANDJUMP(status, error, message)                     \ 
     88#define HYDU_ERR_SETANDJUMP(status, error, ...)                         \ 
    9689    {                                                                   \ 
    9790        status = error;                                                 \ 
    98         if (status && !HYD_SILENT_ERROR(status)) {                      \ 
    99             if (strlen(message))                                        \ 
    100                 HYDU_error_printf(message);                             \ 
    101             goto fn_fail;                                               \ 
    102         }                                                               \ 
    103         else if (HYD_SILENT_ERROR(status)) {                            \ 
    104             goto fn_exit;                                               \ 
    105         }                                                               \ 
    106     } 
    107  
    108 #define HYDU_ERR_SETANDJUMP1(status, error, message, arg1)              \ 
    109     {                                                                   \ 
    110         status = error;                                                 \ 
    111         if (status && !HYD_SILENT_ERROR(status)) {                      \ 
    112             if (strlen(message))                                        \ 
    113                 HYDU_error_printf(message, arg1);                       \ 
    114             goto fn_fail;                                               \ 
    115         }                                                               \ 
    116         else if (HYD_SILENT_ERROR(status)) {                            \ 
    117             goto fn_exit;                                               \ 
    118         }                                                               \ 
    119     } 
    120  
    121 #define HYDU_ERR_SETANDJUMP2(status, error, message, arg1, arg2)        \ 
    122     {                                                                   \ 
    123         status = error;                                                 \ 
    124         if (status && !HYD_SILENT_ERROR(status)) {                      \ 
    125             if (strlen(message))                                        \ 
    126                 HYDU_error_printf(message, arg1, arg2);                 \ 
    127             goto fn_fail;                                               \ 
    128         }                                                               \ 
    129         else if (HYD_SILENT_ERROR(status)) {                            \ 
    130             goto fn_exit;                                               \ 
    131         }                                                               \ 
    132     } 
    133  
    134 #define HYDU_ERR_CHKANDJUMP(status, chk, error, message)                \ 
     91        HYDU_ERR_POP(status, __VA_ARGS__);                              \ 
     92    } 
     93 
     94#define HYDU_ERR_CHKANDJUMP(status, chk, error, ...)                    \ 
    13595    {                                                                   \ 
    13696        if ((chk))                                                      \ 
    137             HYDU_ERR_SETANDJUMP(status, error, message);                \ 
    138     } 
    139  
    140 #define HYDU_ERR_CHKANDJUMP1(status, chk, error, message, arg1)         \ 
    141     {                                                                   \ 
    142         if ((chk))                                                      \ 
    143             HYDU_ERR_SETANDJUMP1(status, error, message, arg1);         \ 
     97            HYDU_ERR_SETANDJUMP(status, error, __VA_ARGS__);            \ 
    14498    } 
    14599 
     
    186140/* debug */ 
    187141HYD_status HYDU_dbg_init(const char *str); 
    188 void HYDU_dump_prefix(FILE * fp); 
    189 void HYDU_dump_noprefix(FILE * fp, const char *str, ...); 
    190 void HYDU_dump(FILE * fp, const char *str, ...); 
    191142void HYDU_dbg_finalize(void); 
    192143 
     
    287238        (p) = (type) HYDU_malloc((size));                               \ 
    288239        if ((p) == NULL)                                                \ 
    289             HYDU_ERR_SETANDJUMP1((status), HYD_NO_MEM,                  \ 
    290                                  "failed to allocate %d bytes\n",       \ 
    291                                  (size));                               \ 
     240            HYDU_ERR_SETANDJUMP((status), HYD_NO_MEM,                   \ 
     241                                "failed to allocate %d bytes\n",        \ 
     242                                (int) (size));                          \ 
    292243    } 
    293244 
  • src/pm/hydra/pm/pmiserv/pmip.c

    r76fe1e r35929a  
    1212 
    1313struct HYD_pmcd_pmip HYD_pmcd_pmip; 
     14char *HYD_dbg_prefix = (char *) "unknown"; 
    1415 
    1516static HYD_status init_params(void) 
     
    196197                                   HYD_pmcd_pmip.upstream.server_port, 
    197198                                   &HYD_pmcd_pmip.upstream.control); 
    198         HYDU_ERR_POP2(status, "unable to connect to server %s at port %d\n", 
     199        HYDU_ERR_POP(status, "unable to connect to server %s at port %d\n", 
    199200                      HYD_pmcd_pmip.upstream.server_name, HYD_pmcd_pmip.upstream.server_port); 
    200201    } 
  • src/pm/hydra/pm/pmiserv/pmip_cb.c

    r1ed50b r35929a  
    596596 
    597597        if (exec->wdir && chdir(exec->wdir) < 0) 
    598             HYDU_ERR_SETANDJUMP2(status, HYD_INTERNAL_ERROR, 
    599                                  "unable to change wdir to %s (%s)\n", exec->wdir, 
    600                                  HYDU_strerror(errno)); 
     598            HYDU_ERR_SETANDJUMP(status, HYD_INTERNAL_ERROR, 
     599                                "unable to change wdir to %s (%s)\n", exec->wdir, 
     600                                HYDU_strerror(errno)); 
    601601 
    602602        for (i = 0; i < exec->proc_count; i++) { 
  • src/pm/hydra/pm/pmiserv/pmip_pmi_v1.c

    r1ed50b r35929a  
    104104        tmp = HYDU_strdup("cmd=response_to_init pmi_version=2 pmi_subversion=0 rc=0\n"); 
    105105    else        /* PMI version mismatch */ 
    106         HYDU_ERR_SETANDJUMP2(status, HYD_INTERNAL_ERROR, 
    107                              "PMI version mismatch; %d.%d\n", pmi_version, pmi_subversion); 
     106        HYDU_ERR_SETANDJUMP(status, HYD_INTERNAL_ERROR, 
     107                            "PMI version mismatch; %d.%d\n", pmi_version, pmi_subversion); 
    108108 
    109109    status = send_cmd_downstream(fd, tmp); 
  • src/pm/hydra/pm/pmiserv/pmiserv_cb.c

    rf2303e r35929a  
    4949    if (!h->handler) { 
    5050        /* We don't understand the command */ 
    51         HYDU_ERR_SETANDJUMP1(status, HYD_INTERNAL_ERROR, 
    52                              "Unrecognized PMI command: %s | cleaning up processes\n", cmd); 
     51        HYDU_ERR_SETANDJUMP(status, HYD_INTERNAL_ERROR, 
     52                            "Unrecognized PMI command: %s | cleaning up processes\n", cmd); 
    5353    } 
    5454 
     
    242242    } 
    243243    else { 
    244         HYDU_ERR_SETANDJUMP1(status, HYD_INTERNAL_ERROR, "unhandled command = %d\n", cmd); 
     244        HYDU_ERR_SETANDJUMP(status, HYD_INTERNAL_ERROR, "unhandled command = %d\n", cmd); 
    245245    } 
    246246 
     
    302302            break; 
    303303    if (!pg) 
    304         HYDU_ERR_SETANDJUMP1(status, HYD_INTERNAL_ERROR, "could not find pg with ID %d\n", 
    305                              pgid); 
     304        HYDU_ERR_SETANDJUMP(status, HYD_INTERNAL_ERROR, "could not find pg with ID %d\n", 
     305                            pgid); 
    306306 
    307307    /* Find the proxy */ 
     
    310310            break; 
    311311    } 
    312     HYDU_ERR_CHKANDJUMP1(status, proxy == NULL, HYD_INTERNAL_ERROR, 
    313                          "cannot find proxy with ID %d\n", proxy_id); 
     312    HYDU_ERR_CHKANDJUMP(status, proxy == NULL, HYD_INTERNAL_ERROR, 
     313                        "cannot find proxy with ID %d\n", proxy_id); 
    314314 
    315315    /* This will be the control socket for this proxy */ 
     
    351351            break; 
    352352    if (!pg) 
    353         HYDU_ERR_SETANDJUMP1(status, HYD_INTERNAL_ERROR, "could not find pg with ID %d\n", 
    354                              pgid); 
     353        HYDU_ERR_SETANDJUMP(status, HYD_INTERNAL_ERROR, "could not find pg with ID %d\n", 
     354                            pgid); 
    355355 
    356356    pg_scratch = (struct HYD_pmcd_pmi_pg_scratch *) pg->pg_scratch; 
  • src/pm/hydra/pm/pmiserv/pmiserv_pmi_v1.c

    r32cc8c r35929a  
    121121 
    122122    if (strcmp(pg_scratch->kvs->kvs_name, kvsname)) 
    123         HYDU_ERR_SETANDJUMP2(status, HYD_INTERNAL_ERROR, 
    124                              "kvsname (%s) does not match this group's kvs space (%s)\n", 
    125                              kvsname, pg_scratch->kvs->kvs_name); 
     123        HYDU_ERR_SETANDJUMP(status, HYD_INTERNAL_ERROR, 
     124                            "kvsname (%s) does not match this group's kvs space (%s)\n", 
     125                            kvsname, pg_scratch->kvs->kvs_name); 
    126126 
    127127    status = HYD_pmcd_pmi_add_kvs(key, val, pg_scratch->kvs, &ret); 
     
    189189 
    190190    if (strcmp(pg_scratch->kvs->kvs_name, kvsname)) 
    191         HYDU_ERR_SETANDJUMP2(status, HYD_INTERNAL_ERROR, 
    192                              "kvsname (%s) does not match this group's kvs space (%s)\n", 
    193                              kvsname, pg_scratch->kvs->kvs_name); 
     191        HYDU_ERR_SETANDJUMP(status, HYD_INTERNAL_ERROR, 
     192                            "kvsname (%s) does not match this group's kvs space (%s)\n", 
     193                            kvsname, pg_scratch->kvs->kvs_name); 
    194194 
    195195    /* Try to find the key */ 
     
    389389            val = HYD_pmcd_pmi_find_token_keyval(&tokens[segment_list[j].start_idx], 
    390390                                                 segment_list[j].token_count, key); 
    391             HYDU_ERR_CHKANDJUMP1(status, val == NULL, HYD_INTERNAL_ERROR, 
    392                                  "unable to find token: %s\n", key); 
     391            HYDU_ERR_CHKANDJUMP(status, val == NULL, HYD_INTERNAL_ERROR, 
     392                                "unable to find token: %s\n", key); 
    393393            info_key = val; 
    394394 
     
    396396            val = HYD_pmcd_pmi_find_token_keyval(&tokens[segment_list[j].start_idx], 
    397397                                                 segment_list[j].token_count, key); 
    398             HYDU_ERR_CHKANDJUMP1(status, val == NULL, HYD_INTERNAL_ERROR, 
    399                                  "unable to find token: %s\n", key); 
     398            HYDU_ERR_CHKANDJUMP(status, val == NULL, HYD_INTERNAL_ERROR, 
     399                                "unable to find token: %s\n", key); 
    400400            info_val = val; 
    401401 
     
    409409                /* FIXME: Unrecognized info key; what should we do 
    410410                 * here? Abort? */ 
    411                 HYDU_ERR_SETANDJUMP1(status, HYD_INTERNAL_ERROR, "unrecognized info key: %s\n", 
    412                                      info_key); 
     411                HYDU_ERR_SETANDJUMP(status, HYD_INTERNAL_ERROR, "unrecognized info key: %s\n", 
     412                                    info_key); 
    413413            } 
    414414        } 
     
    442442            val = HYD_pmcd_pmi_find_token_keyval(&tokens[segment_list[j].start_idx], 
    443443                                                 segment_list[j].token_count, key); 
    444             HYDU_ERR_CHKANDJUMP1(status, val == NULL, HYD_INTERNAL_ERROR, 
    445                                  "unable to find token: %s\n", key); 
     444            HYDU_ERR_CHKANDJUMP(status, val == NULL, HYD_INTERNAL_ERROR, 
     445                                "unable to find token: %s\n", key); 
    446446            exec->exec[i++] = HYDU_strdup(val); 
    447447            HYDU_FREE(key); 
     
    479479        HYDU_snprintf(key, MAXKEYLEN, "preput_key_%d", i); 
    480480        val = HYD_pmcd_pmi_find_token_keyval(tokens, token_count, key); 
    481         HYDU_ERR_CHKANDJUMP1(status, val == NULL, HYD_INTERNAL_ERROR, 
    482                              "unable to find token: %s\n", key); 
     481        HYDU_ERR_CHKANDJUMP(status, val == NULL, HYD_INTERNAL_ERROR, 
     482                            "unable to find token: %s\n", key); 
    483483        preput_key = val; 
    484484 
    485485        HYDU_snprintf(key, HYD_TMP_STRLEN, "preput_val_%d", i); 
    486486        val = HYD_pmcd_pmi_find_token_keyval(tokens, token_count, key); 
    487         HYDU_ERR_CHKANDJUMP1(status, val == NULL, HYD_INTERNAL_ERROR, 
    488                              "unable to find token: %s\n", key); 
     487        HYDU_ERR_CHKANDJUMP(status, val == NULL, HYD_INTERNAL_ERROR, 
     488                            "unable to find token: %s\n", key); 
    489489        preput_val = val; 
    490490        HYDU_FREE(key); 
  • src/pm/hydra/pm/pmiserv/pmiserv_pmi_v2.c

    r32cc8c r35929a  
    572572            val = HYD_pmcd_pmi_find_token_keyval(&tokens[segment_list[j].start_idx], 
    573573                                                 segment_list[j].token_count, key); 
    574             HYDU_ERR_CHKANDJUMP1(status, val == NULL, HYD_INTERNAL_ERROR, 
    575                                  "unable to find token: %s\n", key); 
     574            HYDU_ERR_CHKANDJUMP(status, val == NULL, HYD_INTERNAL_ERROR, 
     575                                "unable to find token: %s\n", key); 
    576576            info_key = val; 
    577577 
     
    579579            val = HYD_pmcd_pmi_find_token_keyval(&tokens[segment_list[j].start_idx], 
    580580                                                 segment_list[j].token_count, key); 
    581             HYDU_ERR_CHKANDJUMP1(status, val == NULL, HYD_INTERNAL_ERROR, 
    582                                  "unable to find token: %s\n", key); 
     581            HYDU_ERR_CHKANDJUMP(status, val == NULL, HYD_INTERNAL_ERROR, 
     582                                "unable to find token: %s\n", key); 
    583583            info_val = val; 
    584584 
     
    592592                /* FIXME: Unrecognized info key; what should we do 
    593593                 * here? Abort? */ 
    594                 HYDU_ERR_SETANDJUMP1(status, HYD_INTERNAL_ERROR, "unrecognized info key: %s\n", 
    595                                      info_key); 
     594                HYDU_ERR_SETANDJUMP(status, HYD_INTERNAL_ERROR, "unrecognized info key: %s\n", 
     595                                    info_key); 
    596596            } 
    597597        } 
     
    625625            val = HYD_pmcd_pmi_find_token_keyval(&tokens[segment_list[j].start_idx], 
    626626                                                 segment_list[j].token_count, key); 
    627             HYDU_ERR_CHKANDJUMP1(status, val == NULL, HYD_INTERNAL_ERROR, 
    628                                  "unable to find token: %s\n", key); 
     627            HYDU_ERR_CHKANDJUMP(status, val == NULL, HYD_INTERNAL_ERROR, 
     628                                "unable to find token: %s\n", key); 
    629629            exec->exec[i++] = HYDU_strdup(val); 
    630630            HYDU_FREE(key); 
     
    662662        HYDU_snprintf(key, MAXKEYLEN, "ppkey%d", i); 
    663663        val = HYD_pmcd_pmi_find_token_keyval(tokens, token_count, key); 
    664         HYDU_ERR_CHKANDJUMP1(status, val == NULL, HYD_INTERNAL_ERROR, 
    665                              "unable to find token: %s\n", key); 
     664        HYDU_ERR_CHKANDJUMP(status, val == NULL, HYD_INTERNAL_ERROR, 
     665                            "unable to find token: %s\n", key); 
    666666        preput_key = val; 
    667667 
    668668        HYDU_snprintf(key, HYD_TMP_STRLEN, "ppval%d", i); 
    669669        val = HYD_pmcd_pmi_find_token_keyval(tokens, token_count, key); 
    670         HYDU_ERR_CHKANDJUMP1(status, val == NULL, HYD_INTERNAL_ERROR, 
    671                              "unable to find token: %s\n", key); 
     670        HYDU_ERR_CHKANDJUMP(status, val == NULL, HYD_INTERNAL_ERROR, 
     671                            "unable to find token: %s\n", key); 
    672672        preput_val = val; 
    673673        HYDU_FREE(key); 
  • src/pm/hydra/tools/bootstrap/persist/persist_server.c

    r4e7e48 r35929a  
    99#include "persist_server.h" 
    1010 
     11char *HYD_dbg_prefix = (char *) "unknown"; 
    1112struct HYDT_persist_handle HYDT_persist_handle; 
    1213static struct { 
     
    8081        if (closed) { 
    8182            status = HYDT_dmx_deregister_fd(private.client_fd); 
    82             HYDU_ERR_SETANDJUMP1(status, status, "error deregistering fd %d\n", 
    83                                  private.client_fd); 
     83            HYDU_ERR_SETANDJUMP(status, status, "error deregistering fd %d\n", 
     84                                private.client_fd); 
    8485            close(private.client_fd); 
    8586        } 
     
    106107        else { 
    107108            status = HYDT_dmx_deregister_fd(private.stdout_fd); 
    108             HYDU_ERR_SETANDJUMP1(status, status, "error deregistering fd %d\n", 
    109                                  private.stdout_fd); 
     109            HYDU_ERR_SETANDJUMP(status, status, "error deregistering fd %d\n", 
     110                                private.stdout_fd); 
    110111            close(private.stdout_fd); 
    111112        } 
     
    135136        else { 
    136137            status = HYDT_dmx_deregister_fd(private.stderr_fd); 
    137             HYDU_ERR_SETANDJUMP1(status, status, "error deregistering fd %d\n", 
    138                                  private.stderr_fd); 
     138            HYDU_ERR_SETANDJUMP(status, status, "error deregistering fd %d\n", 
     139                                private.stderr_fd); 
    139140            close(private.stderr_fd); 
    140141        } 
  • src/pm/hydra/tools/bootstrap/src/bsci_init.c.in

    r51fa57 r35929a  
    5252 
    5353    if (HYDT_bsci_comp_array[i] == NULL) 
    54         HYDU_ERR_SETANDJUMP1(status, HYD_INTERNAL_ERROR, 
    55                              "unrecognized bootstrap server: %s\n", bootstrap); 
     54        HYDU_ERR_SETANDJUMP(status, HYD_INTERNAL_ERROR, 
     55                            "unrecognized bootstrap server: %s\n", bootstrap); 
    5656 
    5757    /* This function is mandatory */ 
  • src/pm/hydra/tools/bootstrap/utils/bscu_cb.c

    r711744 r35929a  
    2626        /* connection has closed */ 
    2727        status = HYDT_dmx_deregister_fd(fd); 
    28         HYDU_ERR_SETANDJUMP1(status, status, "error deregistering fd %d\n", fd); 
     28        HYDU_ERR_SETANDJUMP(status, status, "error deregistering fd %d\n", fd); 
    2929 
    3030        for (i = 0; i < HYD_bscu_fd_count; i++) { 
     
    6565    if (closed || (events & HYD_POLLHUP)) { 
    6666        status = HYDT_dmx_deregister_fd(fd); 
    67         HYDU_ERR_SETANDJUMP1(status, status, "error deregistering fd %d\n", fd); 
     67        HYDU_ERR_SETANDJUMP(status, status, "error deregistering fd %d\n", fd); 
    6868 
    6969        for (i = 0; i < HYD_bscu_fd_count; i++) { 
  • src/pm/hydra/tools/ckpoint/blcr/ckpoint_blcr.c

    r46bc89 r35929a  
    4646 
    4747    ret = mkfifo(filename, 0600); 
    48     HYDU_ERR_CHKANDJUMP1(status, ret, HYD_INTERNAL_ERROR, "mkfifo failed: %s\n", 
    49                          strerror(errno)); 
     48    HYDU_ERR_CHKANDJUMP(status, ret, HYD_INTERNAL_ERROR, "mkfifo failed: %s\n", 
     49                        strerror(errno)); 
    5050 
    5151    *fd = open(filename, O_RDWR); 
    52     HYDU_ERR_CHKANDJUMP1(status, *fd < 0, HYD_INTERNAL_ERROR, "open failed: %s\n", 
    53                          strerror(errno)); 
     52    HYDU_ERR_CHKANDJUMP(status, *fd < 0, HYD_INTERNAL_ERROR, "open failed: %s\n", 
     53                        strerror(errno)); 
    5454 
    5555  fn_exit: 
     
    111111 
    112112        f = fopen(filename, "w"); 
    113         HYDU_ERR_CHKANDJUMP1(status, f == NULL, HYD_INTERNAL_ERROR, "fopen failed: %s\n", 
    114                              strerror(errno)); 
     113        HYDU_ERR_CHKANDJUMP(status, f == NULL, HYD_INTERNAL_ERROR, "fopen failed: %s\n", 
     114                            strerror(errno)); 
    115115 
    116116        for (e = envlist; e; e = e->next) { 
     
    119119 
    120120        ret = fclose(f); 
    121         HYDU_ERR_CHKANDJUMP1(status, ret, HYD_INTERNAL_ERROR, "fclose failed: %s\n", 
    122                              strerror(errno)); 
     121        HYDU_ERR_CHKANDJUMP(status, ret, HYD_INTERNAL_ERROR, "fclose failed: %s\n", 
     122                            strerror(errno)); 
    123123    } 
    124124 
     
    150150    /* open the checkpoint file */ 
    151151    fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC /* | O_LARGEFILE */ , 0600); 
    152     HYDU_ERR_CHKANDJUMP1(status, fd < 0, HYD_INTERNAL_ERROR, "open failed: %s\n", 
    153                          strerror(errno)); 
     152    HYDU_ERR_CHKANDJUMP(status, fd < 0, HYD_INTERNAL_ERROR, "open failed: %s\n", 
     153                        strerror(errno)); 
    154154 
    155155    cr_initialize_checkpoint_args_t(&my_args); 
     
    160160    ret = cr_request_checkpoint(&my_args, &my_handle); 
    161161    if (ret < 0) { 
    162         HYDU_ERR_CHKANDJUMP1(status, errno == CR_ENOSUPPORT, HYD_INTERNAL_ERROR, 
    163                              "cr_request_checkpoint failed, %s\n", strerror(errno)); 
    164         HYDU_ERR_SETANDJUMP1(status, HYD_INTERNAL_ERROR, "cr_request_checkpoint failed, %s\n", 
    165                              strerror(errno)); 
     162        HYDU_ERR_CHKANDJUMP(status, errno == CR_ENOSUPPORT, HYD_INTERNAL_ERROR, 
     163                            "cr_request_checkpoint failed, %s\n", strerror(errno)); 
     164        HYDU_ERR_SETANDJUMP(status, HYD_INTERNAL_ERROR, "cr_request_checkpoint failed, %s\n", 
     165                            strerror(errno)); 
    166166    } 
    167167    /* wait for the request to complete */ 
     
    177177            } 
    178178            else { 
    179                 HYDU_ERR_SETANDJUMP1(status, HYD_INTERNAL_ERROR, 
    180                                      "cr_poll_checkpoint failed: %s\n", strerror(errno)); 
     179                HYDU_ERR_SETANDJUMP(status, HYD_INTERNAL_ERROR, 
     180                                    "cr_poll_checkpoint failed: %s\n", strerror(errno)); 
    181181            } 
    182182        } 
     
    191191 
    192192    ret = close(my_args.cr_fd); 
    193     HYDU_ERR_CHKANDJUMP1(status, ret, HYD_INTERNAL_ERROR, "close failed, %s\n", 
    194                          strerror(errno)); 
     193    HYDU_ERR_CHKANDJUMP(status, ret, HYD_INTERNAL_ERROR, "close failed, %s\n", 
     194                        strerror(errno)); 
    195195 
    196196  fn_exit: 
     
    228228 
    229229    context_fd = open(filename, O_RDONLY /* | O_LARGEFILE */); 
    230     HYDU_ERR_CHKANDJUMP1(status, context_fd < 0, HYD_INTERNAL_ERROR, "open failed, %s\n", 
    231                          strerror(errno)); 
     230    HYDU_ERR_CHKANDJUMP(status, context_fd < 0, HYD_INTERNAL_ERROR, "open failed, %s\n", 
     231                        strerror(errno)); 
    232232 
    233233    /* ... initialize the request structure */ 
     
    238238    /* ... issue the request */ 
    239239    ret = cr_request_restart(&args, &cr_handle); 
    240     HYDU_ERR_CHKANDJUMP1(status, ret, HYD_INTERNAL_ERROR, "cr_request_restart failed, %s\n", 
    241                          strerror(errno)); 
     240    HYDU_ERR_CHKANDJUMP(status, ret, HYD_INTERNAL_ERROR, "cr_request_restart failed, %s\n", 
     241                        strerror(errno)); 
    242242 
    243243    ret = close(context_fd); 
    244     HYDU_ERR_CHKANDJUMP1(status, ret, HYD_INTERNAL_ERROR, "close failed, %s\n", 
    245                          strerror(errno)); 
     244    HYDU_ERR_CHKANDJUMP(status, ret, HYD_INTERNAL_ERROR, "close failed, %s\n", 
     245                        strerror(errno)); 
    246246 
    247247  fn_exit: 
  • src/pm/hydra/tools/demux/demux.c

    r566f96 r35929a  
    6969    for (i = 0; i < num_fds; i++) { 
    7070        if (fd[i] < 0) 
    71             HYDU_ERR_SETANDJUMP1(status, HYD_INTERNAL_ERROR, "registering bad fd %d\n", fd[i]); 
     71            HYDU_ERR_SETANDJUMP(status, HYD_INTERNAL_ERROR, "registering bad fd %d\n", fd[i]); 
    7272 
    7373        cb_element = HYDT_dmxu_cb_list; 
     
    7575            for (j = 0; j < cb_element->num_fds; j++) { 
    7676                if (cb_element->fd[j] == fd[i]) { 
    77                     HYDU_ERR_SETANDJUMP1(status, HYD_INTERNAL_ERROR, 
    78                                          "registering duplicate fd %d\n", fd[i]); 
     77                    HYDU_ERR_SETANDJUMP(status, HYD_INTERNAL_ERROR, 
     78                                        "registering duplicate fd %d\n", fd[i]); 
    7979                } 
    8080            } 
     
    135135 
    136136    /* FD is not found */ 
    137     HYDU_ERR_SETANDJUMP1(status, HYD_INTERNAL_ERROR, 
    138                          "could not find fd to deregister: %d\n", fd); 
     137    HYDU_ERR_SETANDJUMP(status, HYD_INTERNAL_ERROR, 
     138                        "could not find fd to deregister: %d\n", fd); 
    139139 
    140140  fn_exit: 
  • src/pm/hydra/tools/demux/demux_poll.c

    r566f96 r35929a  
    4747            goto fn_exit; 
    4848        } 
    49         HYDU_ERR_SETANDJUMP1(status, HYD_SOCK_ERROR, "poll error (%s)\n", 
    50                              HYDU_strerror(errno)); 
     49        HYDU_ERR_SETANDJUMP(status, HYD_SOCK_ERROR, "poll error (%s)\n", 
     50                            HYDU_strerror(errno)); 
    5151    } 
    5252 
  • src/pm/hydra/tools/demux/demux_select.c

    r566f96 r35929a  
    5252            goto fn_exit; 
    5353        } 
    54         HYDU_ERR_SETANDJUMP1(status, HYD_SOCK_ERROR, "select error (%s)\n", 
    55                              HYDU_strerror(errno)); 
     54        HYDU_ERR_SETANDJUMP(status, HYD_SOCK_ERROR, "select error (%s)\n", 
     55                            HYDU_strerror(errno)); 
    5656    } 
    5757 
  • src/pm/hydra/tools/nameserver/hydra_nameserver.c

    r76fe1e r35929a  
    1616 
    1717static struct HYDT_ns_publish *publish_list = NULL; 
     18char *HYD_dbg_prefix = (char *) "unknown"; 
    1819 
    1920static struct { 
     
    249250    } 
    250251    else { 
    251         HYDU_ERR_SETANDJUMP1(status, HYD_INTERNAL_ERROR, "unrecognized command: %s\n", cmd); 
     252        HYDU_ERR_SETANDJUMP(status, HYD_INTERNAL_ERROR, "unrecognized command: %s\n", cmd); 
    252253    } 
    253254 
  • src/pm/hydra/tools/rmk/pbs/rmk_pbs_query_node_list.c

    r2eb35a r35929a  
    2626    } 
    2727    else {      /* Not a new line */ 
    28         HYDU_ERR_SETANDJUMP1(status, HYD_INTERNAL_ERROR, 
    29                              "token %s not supported at this time\n", token); 
     28        HYDU_ERR_SETANDJUMP(status, HYD_INTERNAL_ERROR, 
     29                            "token %s not supported at this time\n", token); 
    3030    } 
    3131 
  • src/pm/hydra/tools/rmk/src/rmki_init.c.in

    readc1f r35929a  
    4747 
    4848    if (HYDT_rmki_comp_array[i] == NULL) 
    49         HYDU_ERR_SETANDJUMP1(status, HYD_INTERNAL_ERROR, 
    50                              "unrecognized resource management kernel: %s\n", rmk); 
     49        HYDU_ERR_SETANDJUMP(status, HYD_INTERNAL_ERROR, 
     50                            "unrecognized resource management kernel: %s\n", rmk); 
    5151 
    5252    if (HYDT_rmki_fns.query_node_list == NULL) 
  • src/pm/hydra/ui/mpich/mpiexec.c

    r76fe1e r35929a  
    1515 
    1616struct HYD_handle HYD_handle = { {0} }; 
    17  
    1817struct HYD_exec *HYD_uii_mpx_exec_list = NULL; 
     18char *HYD_dbg_prefix = (char *) "unknown"; 
    1919 
    2020static void usage(void) 
  • src/pm/hydra/ui/mpich/utils.c

    r32cc8c r35929a  
    173173        } 
    174174        else { 
    175             HYDU_ERR_SETANDJUMP1(status, HYD_INTERNAL_ERROR, 
    176                                  "token %s not supported at this time\n", token); 
     175            HYDU_ERR_SETANDJUMP(status, HYD_INTERNAL_ERROR, 
     176                                "token %s not supported at this time\n", token); 
    177177        } 
    178178    } 
  • src/pm/hydra/utils/args/args.c

    r51fa57 r35929a  
    120120 
    121121    if (m->handler_fn == NULL) 
    122         HYDU_ERR_SETANDJUMP1(status, HYD_INTERNAL_ERROR, "unrecognized argument %s\n", arg); 
     122        HYDU_ERR_SETANDJUMP(status, HYD_INTERNAL_ERROR, "unrecognized argument %s\n", arg); 
    123123 
    124124  fn_exit: 
     
    155155    HYD_status status = HYD_SUCCESS; 
    156156 
    157     HYDU_ERR_CHKANDJUMP1(status, *var, HYD_INTERNAL_ERROR, "duplicate setting: %s\n", arg); 
     157    HYDU_ERR_CHKANDJUMP(status, *var, HYD_INTERNAL_ERROR, "duplicate setting: %s\n", arg); 
    158158 
    159159    if (val == NULL) 
     
    192192    HYD_status status = HYD_SUCCESS; 
    193193 
    194     HYDU_ERR_CHKANDJUMP1(status, *var != -1, HYD_INTERNAL_ERROR, 
    195                          "duplicate setting: %s\n", arg); 
     194    HYDU_ERR_CHKANDJUMP(status, *var != -1, HYD_INTERNAL_ERROR, 
     195                        "duplicate setting: %s\n", arg); 
    196196 
    197197    *var = val; 
     
    273273 
    274274    if ((fp = fopen(hostfile, "r")) == NULL) 
    275         HYDU_ERR_SETANDJUMP1(status, HYD_INTERNAL_ERROR, 
    276                              "unable to open host file: %s\n", hostfile); 
     275        HYDU_ERR_SETANDJUMP(status, HYD_INTERNAL_ERROR, 
     276                            "unable to open host file: %s\n", hostfile); 
    277277 
    278278    while (fgets(line, HYD_TMP_STRLEN, fp)) { 
  • src/pm/hydra/utils/dbg/dbg.c

    r96e4c6 r35929a  
    66 
    77#include "hydra_utils.h" 
    8  
    9 static char *dbg_prefix = (char *) "unknown"; 
    10  
    11 void HYDU_dump_prefix(FILE * fp) 
    12 { 
    13     fprintf(fp, "[%s] ", dbg_prefix); 
    14     fflush(fp); 
    15 } 
    16  
    17 void HYDU_dump_noprefix(FILE * fp, const char *str, ...) 
    18 { 
    19     va_list list; 
    20  
    21     va_start(list, str); 
    22     vfprintf(fp, str, list); 
    23     fflush(fp); 
    24     va_end(list); 
    25 } 
    26  
    27 void HYDU_dump(FILE * fp, const char *str, ...) 
    28 { 
    29     va_list list; 
    30  
    31     va_start(list, str); 
    32     HYDU_dump_prefix(fp); 
    33     vfprintf(fp, str, list); 
    34     fflush(fp); 
    35     va_end(list); 
    36 } 
    378 
    389HYD_status HYDU_dbg_init(const char *str) 
     
    4617    HYDU_ERR_POP(status, "unable to get local host name\n"); 
    4718 
    48     HYDU_MALLOC(dbg_prefix, char *, strlen(hostname) + 1 + strlen(str) + 1, status); 
    49     HYDU_snprintf(dbg_prefix, strlen(hostname) + 1 + strlen(str) + 1, "%s@%s", str, hostname); 
     19    HYDU_MALLOC(HYD_dbg_prefix, char *, strlen(hostname) + 1 + strlen(str) + 1, status); 
     20    HYDU_snprintf(HYD_dbg_prefix, strlen(hostname) + 1 + strlen(str) + 1, "%s@%s", str, hostname); 
    5021 
    5122  fn_exit: 
     
    5930void HYDU_dbg_finalize(void) 
    6031{ 
    61     HYDU_FREE(dbg_prefix); 
     32    HYDU_FREE(HYD_dbg_prefix); 
    6233} 
  • src/pm/hydra/utils/launch/launch.c

    r4e7e48 r35929a  
    1717 
    1818    if (in && (pipe(inpipe) < 0)) 
    19         HYDU_ERR_SETANDJUMP1(status, HYD_SOCK_ERROR, "pipe error (%s)\n", 
    20                              HYDU_strerror(errno)); 
     19        HYDU_ERR_SETANDJUMP(status, HYD_SOCK_ERROR, "pipe error (%s)\n", 
     20                            HYDU_strerror(errno)); 
    2121 
    2222    if (out && (pipe(outpipe) < 0)) 
    23         HYDU_ERR_SETANDJUMP1(status, HYD_SOCK_ERROR, "pipe error (%s)\n", 
    24                              HYDU_strerror(errno)); 
     23        HYDU_ERR_SETANDJUMP(status, HYD_SOCK_ERROR, "pipe error (%s)\n", 
     24                            HYDU_strerror(errno)); 
    2525 
    2626    if (err && (pipe(errpipe) < 0)) 
    27         HYDU_ERR_SETANDJUMP1(status, HYD_SOCK_ERROR, "pipe error (%s)\n", 
    28                              HYDU_strerror(errno)); 
     27        HYDU_ERR_SETANDJUMP(status, HYD_SOCK_ERROR, "pipe error (%s)\n", 
     28                            HYDU_strerror(errno)); 
    2929 
    3030    /* Fork off the process */ 
     
    3535            close(inpipe[1]); 
    3636            if (dup2(inpipe[0], STDIN_FILENO) < 0) 
    37                 HYDU_ERR_SETANDJUMP1(status, HYD_SOCK_ERROR, "dup2 error (%s)\n", 
    38                                      HYDU_strerror(errno)); 
     37                HYDU_ERR_SETANDJUMP(status, HYD_SOCK_ERROR, "dup2 error (%s)\n", 
     38                                    HYDU_strerror(errno)); 
    3939        } 
    4040 
     
    4343            close(outpipe[0]); 
    4444            if (dup2(outpipe[1], STDOUT_FILENO) < 0) 
    45                 HYDU_ERR_SETANDJUMP1(status, HYD_SOCK_ERROR, "dup2 error (%s)\n", 
    46                                      HYDU_strerror(errno)); 
     45                HYDU_ERR_SETANDJUMP(status, HYD_SOCK_ERROR, "dup2 error (%s)\n", 
     46                                    HYDU_strerror(errno)); 
    4747        } 
    4848 
     
    5151            close(errpipe[0]); 
    5252            if (dup2(errpipe[1], STDERR_FILENO) < 0) 
    53                 HYDU_ERR_SETANDJUMP1(status, HYD_SOCK_ERROR, "dup2 error (%s)\n", 
    54                                      HYDU_strerror(errno)); 
     53                HYDU_ERR_SETANDJUMP(status, HYD_SOCK_ERROR, "dup2 error (%s)\n", 
     54                                    HYDU_strerror(errno)); 
    5555        } 
    5656 
  • src/pm/hydra/utils/others/others.c

    r76fe1e r35929a  
    6464 
    6565    if (gethostname(hostname, MAX_HOSTNAME_LEN) < 0) 
    66         HYDU_ERR_SETANDJUMP2(status, HYD_SOCK_ERROR, 
    67                              "gethostname error (hostname: %s; errno: %d)\n", hostname, errno); 
     66        HYDU_ERR_SETANDJUMP(status, HYD_SOCK_ERROR, 
     67                            "gethostname error (hostname: %s; errno: %d)\n", hostname, errno); 
    6868 
    6969    HYDU_snprintf(local_hostname, MAX_HOSTNAME_LEN, "%s", hostname); 
  • src/pm/hydra/utils/sock/sock.c

    r76fe1e r35929a  
    5858    *listen_fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); 
    5959    if (*listen_fd < 0) 
    60         HYDU_ERR_SETANDJUMP1(status, HYD_SOCK_ERROR, "cannot open socket (%s)\n", 
    61                              HYDU_strerror(errno)); 
     60        HYDU_ERR_SETANDJUMP(status, HYD_SOCK_ERROR, "cannot open socket (%s)\n", 
     61                            HYDU_strerror(errno)); 
    6262 
    6363    if (setsockopt(*listen_fd, IPPROTO_TCP, TCP_NODELAY, &one, sizeof(int)) < 0) 
     
    8282             * port. Otherwise, it's an error. */ 
    8383            if (errno != EADDRINUSE) 
    84                 HYDU_ERR_SETANDJUMP1(status, HYD_SOCK_ERROR, "bind error (%s)\n", 
    85                                      HYDU_strerror(errno)); 
     84                HYDU_ERR_SETANDJUMP(status, HYD_SOCK_ERROR, "bind error (%s)\n", 
     85                                    HYDU_strerror(errno)); 
    8686        } 
    8787        else    /* We got a port */ 
     
    9494 
    9595    if (listen(*listen_fd, -1) < 0) 
    96         HYDU_ERR_SETANDJUMP1(status, HYD_SOCK_ERROR, "listen error (%s)\n", 
    97                              HYDU_strerror(errno)); 
     96        HYDU_ERR_SETANDJUMP(status, HYD_SOCK_ERROR, "listen error (%s)\n", 
     97                            HYDU_strerror(errno)); 
    9898 
    9999    /* We asked for any port, so we need to find out which port we 
     
    103103 
    104104        if (getsockname(*listen_fd, (struct sockaddr *) &sa, &sinlen) < 0) 
    105             HYDU_ERR_SETANDJUMP1(status, HYD_SOCK_ERROR, "getsockname error (%s)\n", 
    106                                  HYDU_strerror(errno)); 
     105            HYDU_ERR_SETANDJUMP(status, HYD_SOCK_ERROR, "getsockname error (%s)\n", 
     106                                HYDU_strerror(errno)); 
    107107        *port = ntohs(sa.sin_port); 
    108108    } 
     
    135135    ht = gethostbyname(host); 
    136136    if (ht == NULL) 
    137         HYDU_ERR_SETANDJUMP1(status, HYD_INVALID_PARAM, 
    138                              "unable to get host address (%s)\n", HYDU_strerror(errno)); 
     137        HYDU_ERR_SETANDJUMP(status, HYD_INVALID_PARAM, 
     138                            "unable to get host address (%s)\n", HYDU_strerror(errno)); 
    139139    memcpy(&sa.sin_addr, ht->h_addr_list[0], ht->h_length); 
    140140 
     
    142142    *fd = socket(AF_INET, SOCK_STREAM, 0); 
    143143    if (*fd < 0) 
    144         HYDU_ERR_SETANDJUMP1(status, HYD_SOCK_ERROR, "cannot open socket (%s)\n", 
    145                              HYDU_strerror(errno)); 
     144        HYDU_ERR_SETANDJUMP(status, HYD_SOCK_ERROR, "cannot open socket (%s)\n", 
     145                            HYDU_strerror(errno)); 
    146146 
    147147    /* Not being able to connect is not an error in all cases. So we 
     
    176176    *fd = accept(listen_fd, 0, 0); 
    177177    if (*fd < 0) 
    178         HYDU_ERR_SETANDJUMP1(status, HYD_SOCK_ERROR, "accept error (%s)\n", 
    179                              HYDU_strerror(errno)); 
     178        HYDU_ERR_SETANDJUMP(status, HYD_SOCK_ERROR, "accept error (%s)\n", 
     179                            HYDU_strerror(errno)); 
    180180 
    181181    /* Disable nagle */ 
     
    210210        if (tmp < 0) { 
    211211            *recvd = tmp; 
    212             HYDU_ERR_SETANDJUMP1(status, HYD_SOCK_ERROR, "read errno (%s)\n", 
    213                                  HYDU_strerror(errno)); 
     212            HYDU_ERR_SETANDJUMP(status, HYD_SOCK_ERROR, "read errno (%s)\n", 
     213                                HYDU_strerror(errno)); 
    214214        } 
    215215        else if (tmp == 0) { 
     
    276276#if defined O_NONBLOCK 
    277277    if (fcntl(fd, F_SETFL, flags | O_NONBLOCK) < 0) 
    278         HYDU_ERR_SETANDJUMP1(status, HYD_SOCK_ERROR, "fcntl failed on %d\n", fd); 
     278        HYDU_ERR_SETANDJUMP(status, HYD_SOCK_ERROR, "fcntl failed on %d\n", fd); 
    279279#endif /* O_NONBLOCK */ 
    280280 
     
    298298#if defined O_NONBLOCK 
    299299    if (fcntl(fd, F_SETFL, flags & ~O_NONBLOCK) < 0) 
    300         HYDU_ERR_SETANDJUMP1(status, HYD_SOCK_ERROR, "fcntl failed on %d\n", fd); 
     300        HYDU_ERR_SETANDJUMP(status, HYD_SOCK_ERROR, "fcntl failed on %d\n", fd); 
    301301#endif /* O_NONBLOCK */ 
    302302 
     
    436436 
    437437    if (!ifa) 
    438         HYDU_ERR_SETANDJUMP1(status, HYD_INTERNAL_ERROR, "unable to find interface %s\n", 
    439                              iface); 
     438        HYDU_ERR_SETANDJUMP(status, HYD_INTERNAL_ERROR, "unable to find interface %s\n", 
     439                            iface); 
    440440 
    441441    sa = (struct sockaddr_in *) ifa->ifa_addr; 
     
    443443                        inet_ntop(AF_INET, (void *) &(sa->sin_addr), buf, MAX_HOSTNAME_LEN)); 
    444444    if (!*ip) 
    445         HYDU_ERR_SETANDJUMP1(status, HYD_INTERNAL_ERROR, 
    446                              "unable to find IP for interface %s\n", iface); 
     445        HYDU_ERR_SETANDJUMP(status, HYD_INTERNAL_ERROR, 
     446                            "unable to find IP for interface %s\n", iface); 
    447447 
    448448    freeifaddrs(ifaddr); 
Note: See TracChangeset for help on using the changeset viewer.