Changeset 4887

Show
Ignore:
Timestamp:
07/01/09 23:23:06 (4 months ago)
Author:
balaji
Message:

Warning stomp.

Location:
mpich2/trunk/src/pm/hydra
Files:
28 modified

Legend:

Unmodified
Added
Removed

  • mpich2/trunk/src/pm/hydra/bootstrap/fork/fork.h

    r4569 r4887  
    1010#include "hydra_base.h" 
    1111 
    12 HYD_Status HYD_BSCD_fork_launch_procs(char **global_args, char *partition_id_str, 
     12HYD_Status HYD_BSCD_fork_launch_procs(char **global_args, const char *partition_id_str, 
    1313                                      struct HYD_Partition *partition_list); 
    1414 

  • mpich2/trunk/src/pm/hydra/bootstrap/fork/fork_launch.c

    r4601 r4887  
    1010#include "fork.h" 
    1111 
    12 HYD_Status HYD_BSCD_fork_launch_procs(char **global_args, char *partition_id_str, 
     12HYD_Status HYD_BSCD_fork_launch_procs(char **global_args, const char *partition_id_str, 
    1313                                      struct HYD_Partition *partition_list) 
    1414{ 

  • mpich2/trunk/src/pm/hydra/bootstrap/include/bsci.h.in

    r4614 r4887  
    1515 
    1616struct HYD_BSCI_fns { 
    17     HYD_Status(*launch_procs) (char **global_args, char *partition_id_str, 
     17    HYD_Status(*launch_procs) (char **global_args, const char *partition_id_str, 
    1818                               struct HYD_Partition *partition_list); 
    1919    HYD_Status(*finalize) (void); 
    … …  
    2727 
    2828HYD_Status HYD_BSCI_init(char *bootstrap, char *bootstrap_exec, int enablex, int debug); 
    29 HYD_Status HYD_BSCI_launch_procs(char **global_args, char *partition_id_str, 
     29HYD_Status HYD_BSCI_launch_procs(char **global_args, const char *partition_id_str, 
    3030                                 struct HYD_Partition *partition_list); 
    3131HYD_Status HYD_BSCI_finalize(void); 

  • mpich2/trunk/src/pm/hydra/bootstrap/rsh/rsh.h

    r4569 r4887  
    1010#include "hydra_base.h" 
    1111 
    12 HYD_Status HYD_BSCD_rsh_launch_procs(char **global_args, char *partition_id_str, 
     12HYD_Status HYD_BSCD_rsh_launch_procs(char **global_args, const char *partition_id_str, 
    1313                                     struct HYD_Partition *partition_list); 
    1414 

  • mpich2/trunk/src/pm/hydra/bootstrap/rsh/rsh_launch.c

    r4601 r4887  
    1616 * environment and execvp's this executable. 
    1717 */ 
    18 HYD_Status HYD_BSCD_rsh_launch_procs(char **global_args, char *partition_id_str, 
     18HYD_Status HYD_BSCD_rsh_launch_procs(char **global_args, const char *partition_id_str, 
    1919                                     struct HYD_Partition *partition_list) 
    2020{ 
    … …  
    4141 
    4242        if (test_path) { 
    43             tmp[0] = test_path; 
    44             tmp[1] = "rsh"; 
     43            tmp[0] = HYDU_strdup(test_path); 
     44            tmp[1] = HYDU_strdup("rsh"); 
    4545            tmp[2] = NULL; 
    4646 
    4747            status = HYDU_str_alloc_and_join(tmp, &path); 
    4848            HYDU_ERR_POP(status, "error joining strings\n"); 
     49 
     50            HYDU_free_strlist(tmp); 
    4951        } 
    5052        else 

  • mpich2/trunk/src/pm/hydra/bootstrap/slurm/slurm.h

    r4569 r4887  
    1010#include "hydra_base.h" 
    1111 
    12 HYD_Status HYD_BSCD_slurm_launch_procs(char **global_args, char *partition_id_str, 
     12HYD_Status HYD_BSCD_slurm_launch_procs(char **global_args, const char *partition_id_str, 
    1313                                       struct HYD_Partition *partition_list); 
    1414HYD_Status HYD_BSCD_slurm_query_partition_id(int *partition_id); 

  • mpich2/trunk/src/pm/hydra/bootstrap/slurm/slurm_launch.c

    r4601 r4887  
    1010#include "slurm.h" 
    1111 
    12 HYD_Status HYD_BSCD_slurm_launch_procs(char **global_args, char *partition_id_str, 
     12HYD_Status HYD_BSCD_slurm_launch_procs(char **global_args, const char *partition_id_str, 
    1313                                       struct HYD_Partition *partition_list) 
    1414{ 
    … …  
    3535 
    3636        if (test_path) { 
    37             tmp[0] = test_path; 
    38             tmp[1] = "srun"; 
     37            tmp[0] = HYDU_strdup(test_path); 
     38            tmp[1] = HYDU_strdup("srun"); 
    3939            tmp[2] = NULL; 
    4040 
    4141            status = HYDU_str_alloc_and_join(tmp, &path); 
    4242            HYDU_ERR_POP(status, "error joining strings\n"); 
     43 
     44            HYDU_free_strlist(tmp); 
    4345        } 
    4446        else 
    … …  
    5355    num_nodes = 0; 
    5456    FORALL_ACTIVE_PARTITIONS(partition, partition_list) { 
    55         tmp[i++] = partition->base->name; 
     57        tmp[i++] = HYDU_strdup(partition->base->name); 
    5658        if (partition->next && partition->next->base->active) 
    57             tmp[i++] = ","; 
     59            tmp[i++] = HYDU_strdup(","); 
    5860        num_nodes++; 
    5961    } 
    … …  
    6163    status = HYDU_str_alloc_and_join(tmp, &client_arg[arg]); 
    6264    HYDU_ERR_POP(status, "error joining strings\n"); 
     65 
     66    HYDU_free_strlist(tmp); 
    6367 
    6468    arg++; 

  • mpich2/trunk/src/pm/hydra/bootstrap/src/bsci_init.c.in

    r4614 r4887  
    1010 
    1111struct HYD_BSCI_fns HYD_BSCI_fns = { 0 }; 
    12 char *HYD_BSCI_comp_array[] = { @hydra_bss_name_array@ }; 
     12const char *HYD_BSCI_comp_array[] = { @hydra_bss_name_array@ }; 
    1313HYD_Status(*HYD_BSCI_comp_init[])(void) = { @hydra_bss_init_array@ }; 
    1414struct HYD_BSCI_info HYD_BSCI_info = { 0 }; 

  • mpich2/trunk/src/pm/hydra/bootstrap/src/bsci_launch.c

    r4601 r4887  
    88#include "bsci.h" 
    99 
    10 HYD_Status HYD_BSCI_launch_procs(char **global_args, char *partition_id_str, 
     10HYD_Status HYD_BSCI_launch_procs(char **global_args, const char *partition_id_str, 
    1111                                 struct HYD_Partition *partition_list) 
    1212{ 

  • mpich2/trunk/src/pm/hydra/bootstrap/ssh/ssh.h

    r4569 r4887  
    1010#include "hydra_base.h" 
    1111 
    12 HYD_Status HYD_BSCD_ssh_launch_procs(char **global_args, char *partition_id_str, 
     12HYD_Status HYD_BSCD_ssh_launch_procs(char **global_args, const char *partition_id_str, 
    1313                                     struct HYD_Partition *partition_list); 
    1414 

  • mpich2/trunk/src/pm/hydra/bootstrap/ssh/ssh_launch.c

    r4601 r4887  
    1616 * environment and execvp's this executable. 
    1717 */ 
    18 HYD_Status HYD_BSCD_ssh_launch_procs(char **global_args, char *partition_id_str, 
     18HYD_Status HYD_BSCD_ssh_launch_procs(char **global_args, const char *partition_id_str, 
    1919                                     struct HYD_Partition *partition_list) 
    2020{ 
    … …  
    4141 
    4242        if (test_path) { 
    43             tmp[0] = test_path; 
    44             tmp[1] = "ssh"; 
     43            tmp[0] = HYDU_strdup(test_path); 
     44            tmp[1] = HYDU_strdup("ssh"); 
    4545            tmp[2] = NULL; 
    4646 
    4747            status = HYDU_str_alloc_and_join(tmp, &path); 
    4848            HYDU_ERR_POP(status, "error joining strings\n"); 
     49 
     50            HYDU_free_strlist(tmp); 
    4951        } 
    5052        else 

  • mpich2/trunk/src/pm/hydra/configure.in

    r4861 r4887  
    1414AC_CONFIG_HEADER(include/hydra_config.h) 
    1515 
    16 # Check for special types 
    17 AC_TYPE_SIZE_T 
    18  
    1916dnl Bug in autoconf adds -O2 and -g by default. Make sure we only get 
    2017dnl the flags we want. 
    2118save_cflags=$CFLAGS 
    2219AC_PROG_CC 
     20AC_TYPE_SIZE_T 
    2321CFLAGS=$save_cflags 
    2422 
    … …  
    254252dnl Debugging support 
    255253AC_ARG_ENABLE(g, [  --enable-g              Enable Debugging], 
    256                  [ DEBUG=$enableval ], 
    257                  [ DEBUG=no ]) 
     254                 [ debug=$enableval ], 
     255                 [ debug=no ]) 
    258256AC_MSG_CHECKING(debugging support) 
    259 AC_MSG_RESULT($DEBUG) 
    260 if test "$DEBUG" = "yes"; then 
    261    EXTRA_CFLAGS="$EXTRA_CFLAGS -g" 
     257AC_MSG_RESULT($debug) 
     258if test "$debug" = "yes"; then 
     259   CFLAGS="$CFLAGS -g" 
    262260   AC_DEFINE(ENABLE_DEBUG,1,[Define if debugging support is enabled]) 
    263261fi 
    264 AC_SUBST(EXTRA_CFLAGS) 
    265262 
    266263dnl Warning messages 

  • mpich2/trunk/src/pm/hydra/css/src/cssi_init.c.in

    r4601 r4887  
    1010struct HYD_CSSI_fns HYD_CSSI_fns = { 0 }; 
    1111 
    12 char *HYD_CSSI_comp_array[] = { @hydra_css_name_array@ }; 
     12const char *HYD_CSSI_comp_array[] = { @hydra_css_name_array@ }; 
    1313HYD_Status(*HYD_CSSI_comp_init[])(void) = { @hydra_css_init_array@ }; 
    1414 

  • mpich2/trunk/src/pm/hydra/demux/demux.c

    r4213 r4887  
    9999 
    100100 
    101 HYD_Status HYD_DMX_wait_for_event(int time) 
     101HYD_Status HYD_DMX_wait_for_event(int wtime) 
    102102{ 
    103103    int total_fds, i, j, events, ret; 
    … …  
    132132 
    133133    while (1) { 
    134         ret = poll(pollfds, total_fds, time); 
     134        ret = poll(pollfds, total_fds, wtime); 
    135135        if (ret < 0) { 
    136136            if (errno == EINTR) { 

  • mpich2/trunk/src/pm/hydra/include/hydra_utils.h

    r4835 r4887  
    137137 
    138138/* args */ 
    139 HYD_Status HYDU_find_in_path(char *execname, char **path); 
    140 HYD_Status HYDU_get_base_path(char *execname, char *wdir, char **path); 
     139HYD_Status HYDU_find_in_path(const char *execname, char **path); 
     140HYD_Status HYDU_get_base_path(const char *execname, char *wdir, char **path); 
    141141 
    142142 
    … …  
    154154HYD_Status HYDU_list_inherited_env(HYD_Env_t ** env_list); 
    155155HYD_Env_t *HYDU_env_list_dup(HYD_Env_t * env); 
    156 HYD_Status HYDU_env_create(HYD_Env_t ** env, char *env_name, char *env_value); 
     156HYD_Status HYDU_env_create(HYD_Env_t ** env, const char *env_name, char *env_value); 
    157157HYD_Status HYDU_env_free(HYD_Env_t * env); 
    158158HYD_Status HYDU_env_free_list(HYD_Env_t * env); 
    … …  
    223223HYD_Status HYDU_sock_accept(int listen_fd, int *fd); 
    224224HYD_Status HYDU_sock_readline(int fd, char *buf, int maxlen, int *linelen); 
    225 HYD_Status HYDU_sock_writeline(int fd, char *buf, int maxsize); 
     225HYD_Status HYDU_sock_writeline(int fd, const char *buf, int maxsize); 
    226226HYD_Status HYDU_sock_read(int fd, void *buf, int maxlen, int *count, 
    227227                          enum HYDU_sock_comm_flag flag); 
    228 HYD_Status HYDU_sock_write(int fd, void *buf, int maxsize); 
    229 HYD_Status HYDU_sock_trywrite(int fd, void *buf, int maxsize); 
     228HYD_Status HYDU_sock_write(int fd, const void *buf, int maxsize); 
     229HYD_Status HYDU_sock_trywrite(int fd, const void *buf, int maxsize); 
    230230HYD_Status HYDU_sock_set_nonblock(int fd); 
    231231HYD_Status HYDU_sock_set_cloexec(int fd); 

  • mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_handle.c

    r4835 r4887  
    158158 
    159159 
    160 HYD_Status HYD_PMCD_pmi_add_kvs(char *key, char *val, HYD_PMCD_pmi_kvs_t * kvs, 
     160HYD_Status HYD_PMCD_pmi_add_kvs(const char *key, char *val, HYD_PMCD_pmi_kvs_t * kvs, 
    161161                                char **key_pair_str, int *ret) 
    162162{ 

  • mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_handle.h

    r4601 r4887  
    7676HYD_Status HYD_PMCD_pmi_id_to_rank(int id, int *rank); 
    7777HYD_PMCD_pmi_process_t *HYD_PMCD_pmi_find_process(int fd); 
    78 HYD_Status HYD_PMCD_pmi_add_kvs(char *key, char *val, HYD_PMCD_pmi_kvs_t * kvs, 
     78HYD_Status HYD_PMCD_pmi_add_kvs(const char *key, char *val, HYD_PMCD_pmi_kvs_t * kvs, 
    7979                                char **key_pair_str, int *ret); 
    8080HYD_Status HYD_PMCD_pmi_process_mapping(HYD_PMCD_pmi_process_t * process, 
    … …  
    8787 
    8888struct HYD_PMCD_pmi_handle_fns { 
    89     char *cmd; 
     89    const char *cmd; 
    9090     HYD_Status(*handler) (int fd, char *args[]); 
    9191}; 

  • mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_handle_common.c

    r4835 r4887  
    1414{ 
    1515    int pmi_version, pmi_subversion; 
    16     char *tmp; 
     16    const char *tmp; 
    1717    HYD_Status status = HYD_SUCCESS; 
    1818 

  • mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_handle_v1.c

    r4614 r4887  
    5858    status = HYDU_str_alloc_and_join(tmp, &cmd); 
    5959    HYDU_ERR_POP(status, "error while joining strings\n"); 
    60  
    61     for (i = 0; tmp[i]; i++) 
    62         HYDU_FREE(tmp[i]); 
     60    HYDU_free_strlist(tmp); 
    6361 
    6462    status = HYDU_sock_writeline(fd, cmd, strlen(cmd)); 
    … …  
    104102    status = HYDU_str_alloc_and_join(tmp, &cmd); 
    105103    HYDU_ERR_POP(status, "unable to join strings\n"); 
    106  
    107     for (i = 0; tmp[i]; i++) 
    108         HYDU_FREE(tmp[i]); 
     104    HYDU_free_strlist(tmp); 
    109105 
    110106    status = HYDU_sock_writeline(fd, cmd, strlen(cmd)); 
    … …  
    143139    status = HYDU_str_alloc_and_join(tmp, &cmd); 
    144140    HYDU_ERR_POP(status, "unable to join strings\n"); 
    145  
    146     for (i = 0; tmp[i]; i++) 
    147         HYDU_FREE(tmp[i]); 
     141    HYDU_free_strlist(tmp); 
    148142 
    149143    status = HYDU_sock_writeline(fd, cmd, strlen(cmd)); 
    … …  
    176170 
    177171    i = 0; 
    178     tmp[i++] = "cmd=my_kvsname kvsname="; 
    179     tmp[i++] = process->node->pg->kvs->kvs_name; 
    180     tmp[i++] = "\n"; 
    181     tmp[i++] = NULL; 
    182  
    183     status = HYDU_str_alloc_and_join(tmp, &cmd); 
    184     HYDU_ERR_POP(status, "unable to join strings\n"); 
     172    tmp[i++] = HYDU_strdup("cmd=my_kvsname kvsname="); 
     173    tmp[i++] = HYDU_strdup(process->node->pg->kvs->kvs_name); 
     174    tmp[i++] = HYDU_strdup("\n"); 
     175    tmp[i++] = NULL; 
     176 
     177    status = HYDU_str_alloc_and_join(tmp, &cmd); 
     178    HYDU_ERR_POP(status, "unable to join strings\n"); 
     179    HYDU_free_strlist(tmp); 
    185180 
    186181    status = HYDU_sock_writeline(fd, cmd, strlen(cmd)); 
    … …  
    201196    HYD_PMCD_pmi_process_t *process, *prun; 
    202197    HYD_PMCD_pmi_node_t *node; 
    203     char *cmd; 
     198    const char *cmd; 
    204199    HYD_Status status = HYD_SUCCESS; 
    205200 
    … …  
    272267 
    273268    i = 0; 
    274     tmp[i++] = "cmd=put_result rc="; 
     269    tmp[i++] = HYDU_strdup("cmd=put_result rc="); 
    275270    if (process->node->pg->kvs->key_pair == NULL) { 
    276271        process->node->pg->kvs->key_pair = key_pair; 
    277         tmp[i++] = "0 msg=success"; 
     272        tmp[i++] = HYDU_strdup("0 msg=success"); 
    278273    } 
    279274    else { 
    … …  
    281276        while (run->next) { 
    282277            if (!strcmp(run->key, key_pair->key)) { 
    283                 tmp[i++] = "-1 msg=duplicate_key"; 
     278                tmp[i++] = HYDU_strdup("-1 msg=duplicate_key"); 
    284279                key_pair_str = HYDU_strdup(key_pair->key); 
    285                 tmp[i++] = key_pair_str; 
     280                tmp[i++] = HYDU_strdup(key_pair_str); 
    286281                break; 
    287282            } 
    … …  
    289284        } 
    290285        run->next = key_pair; 
    291         tmp[i++] = "0 msg=success"; 
    292     } 
    293     tmp[i++] = "\n"; 
    294     tmp[i++] = NULL; 
    295  
    296     status = HYDU_str_alloc_and_join(tmp, &cmd); 
    297     HYDU_ERR_POP(status, "unable to join strings\n"); 
     286        tmp[i++] = HYDU_strdup("0 msg=success"); 
     287    } 
     288    tmp[i++] = HYDU_strdup("\n"); 
     289    tmp[i++] = NULL; 
     290 
     291    status = HYDU_str_alloc_and_join(tmp, &cmd); 
     292    HYDU_ERR_POP(status, "unable to join strings\n"); 
     293    HYDU_free_strlist(tmp); 
    298294 
    299295    status = HYDU_sock_writeline(fd, cmd, strlen(cmd)); 
    … …  
    339335 
    340336    i = 0; 
    341     tmp[i++] = "cmd=get_result rc="; 
     337    tmp[i++] = HYDU_strdup("cmd=get_result rc="); 
    342338    if (process->node->pg->kvs->key_pair == NULL) { 
    343         tmp[i++] = "-1 msg=key_"; 
    344         tmp[i++] = key; 
    345         tmp[i++] = "_not_found value=unknown"; 
     339        tmp[i++] = HYDU_strdup("-1 msg=key_"); 
     340        tmp[i++] = HYDU_strdup(key); 
     341        tmp[i++] = HYDU_strdup("_not_found value=unknown"); 
    346342    } 
    347343    else { 
    … …  
    349345        while (run) { 
    350346            if (!strcmp(run->key, key)) { 
    351                 tmp[i++] = "0 msg=success value="; 
     347                tmp[i++] = HYDU_strdup("0 msg=success value="); 
    352348                key_val_str = HYDU_strdup(run->val); 
    353349                tmp[i++] = key_val_str; 
    … …  
    357353        } 
    358354        if (run == NULL) { 
    359             tmp[i++] = "-1 msg=key_"; 
    360             tmp[i++] = key; 
    361             tmp[i++] = "_not_found value=unknown"; 
     355            tmp[i++] = HYDU_strdup("-1 msg=key_"); 
     356            tmp[i++] = HYDU_strdup(key); 
     357            tmp[i++] = HYDU_strdup("_not_found value=unknown"); 
    362358        } 
    363359    } 
    364     tmp[i++] = "\n"; 
    365     tmp[i++] = NULL; 
    366  
    367     status = HYDU_str_alloc_and_join(tmp, &cmd); 
    368     HYDU_ERR_POP(status, "unable to join strings\n"); 
    369  
    370     status = HYDU_sock_writeline(fd, cmd, strlen(cmd)); 
    371     HYDU_ERR_POP(status, "error writing PMI line\n"); 
    372     HYDU_FREE(cmd); 
    373     HYDU_FREE(key_val_str); 
     360    tmp[i++] = HYDU_strdup("\n"); 
     361    tmp[i++] = NULL; 
     362 
     363    status = HYDU_str_alloc_and_join(tmp, &cmd); 
     364    HYDU_ERR_POP(status, "unable to join strings\n"); 
     365    HYDU_free_strlist(tmp); 
     366 
     367    status = HYDU_sock_writeline(fd, cmd, strlen(cmd)); 
     368    HYDU_ERR_POP(status, "error writing PMI line\n"); 
     369    HYDU_FREE(cmd); 
    374370 
    375371  fn_exit: 
    … …  
    384380HYD_Status HYD_PMCD_pmi_handle_v1_finalize(int fd, char *args[]) 
    385381{ 
    386     char *cmd; 
     382    const char *cmd; 
    387383    HYD_Status status = HYD_SUCCESS; 
    388384 
    … …  
    420416 
    421417    i = 0; 
    422     tmp[i++] = "cmd=universe_size size="; 
     418    tmp[i++] = HYDU_strdup("cmd=universe_size size="); 
    423419    tmp[i++] = HYDU_int_to_str(usize); 
    424     tmp[i++] = "\n"; 
    425     tmp[i++] = NULL; 
    426  
    427     status = HYDU_str_alloc_and_join(tmp, &cmd); 
    428     HYDU_ERR_POP(status, "unable to join strings\n"); 
    429  
    430     status = HYDU_sock_writeline(fd, cmd, strlen(cmd)); 
    431     HYDU_ERR_POP(status, "error writing PMI line\n"); 
    432     HYDU_FREE(cmd); 
    433  
    434   fn_exit: 
    435     HYDU_FUNC_EXIT(); 
    436     return status; 
    437  
    438   fn_fail: 
    439     goto fn_exit; 
    440 } 
     420    tmp[i++] = HYDU_strdup("\n"); 
     421    tmp[i++] = NULL; 
     422 
     423    status = HYDU_str_alloc_and_join(tmp, &cmd); 
     424    HYDU_ERR_POP(status, "unable to join strings\n"); 
     425    HYDU_free_strlist(tmp); 
     426 
     427    status = HYDU_sock_writeline(fd, cmd, strlen(cmd)); 
     428    HYDU_ERR_POP(status, "error writing PMI line\n"); 
     429    HYDU_FREE(cmd); 
     430 
     431  fn_exit: 
     432    HYDU_FUNC_EXIT(); 
     433    return status; 
     434 
     435  fn_fail: 
     436    goto fn_exit; 
     437} 

  • mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_handle_v2.c

    r4719 r4887  
    5656        for (i = 0; areq->req[i]; i++) { 
    5757            dprintf("%s", areq->req[i]); 
    58             if (areq->req[i + 1]) 
     58            if (areq->req[i + 1]) { 
    5959                dprintf(","); 
     60            } 
    6061        } 
    6162        dprintf(") "); 
    … …  
    197198 
    198199 
    199 static char *find_token_keyval(struct token *tokens, int count, char *key) 
     200static char *find_token_keyval(struct token *tokens, int count, const char *key) 
    200201{ 
    201202    int i; 
    … …  
    395396    HYD_PMCD_pmi_process_t *process; 
    396397    HYD_PMCD_pmi_kvs_pair_t *run; 
    397     char *key, *wait, *thrid; 
     398    char *key, *waitval, *thrid; 
    398399    char *tmp[HYD_NUM_TMP_STRINGS] = { 0 }, *cmd; 
    399400    struct token *tokens; 
    … …  
    409410    HYDU_ERR_CHKANDJUMP(status, key == NULL, HYD_INTERNAL_ERROR, "unable to find key token\n"); 
    410411 
    411     wait = find_token_keyval(tokens, token_count, "wait"); 
     412    waitval = find_token_keyval(tokens, token_count, "wait"); 
    412413    thrid = find_token_keyval(tokens, token_count, "thrid"); 
    413414 
    … …  
    431432            goto fn_exit; 
    432433 
    433         if (wait && !strcmp(wait, "TRUE")) { 
     434        if (waitval && !strcmp(waitval, "TRUE")) { 
    434435            /* queue up */ 
    435436            status = queue_outstanding_req(fd, GET_NODE_ATTR, args); 

  • mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_serv_cb.c

    r4601 r4887  
    7575        buflen -= linelen; 
    7676        bufptr += linelen; 
    77          
    7877 
    7978        /* Unexpected termination of connection */ 
    … …  
    315314 
    316315 
    317 void HYD_PMCD_pmi_serv_signal_cb(int signal) 
    318 { 
    319     HYDU_FUNC_ENTER(); 
    320  
    321     if (signal == SIGINT || signal == SIGQUIT || signal == SIGTERM 
     316void HYD_PMCD_pmi_serv_signal_cb(int sig) 
     317{ 
     318    HYDU_FUNC_ENTER(); 
     319 
     320    if (sig == SIGINT || sig == SIGQUIT || sig == SIGTERM 
    322321#if defined SIGSTOP 
    323         || signal == SIGSTOP 
     322        || sig == SIGSTOP 
    324323#endif /* SIGSTOP */ 
    325324#if defined SIGCONT 
    326         || signal == SIGCONT 
     325        || sig == SIGCONT 
    327326#endif /* SIGSTOP */ 
    328327) { 

  • mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_serv_launch.c

    r4836 r4887  
    200200    int inherited_env_count, user_env_count, system_env_count; 
    201201    int segment_count, exec_count, total_args; 
    202     static proxy_count = 0; 
     202    static int proxy_count = 0; 
    203203    HYD_Env_t *env; 
    204204    struct HYD_Partition *partition; 

  • mpich2/trunk/src/pm/hydra/rmk/src/rmki_init.c.in

    r4601 r4887  
    1313struct HYD_RMKI_fns HYD_RMKI_fns = { 0 }; 
    1414 
    15 char *HYD_RMKI_comp_array[] = { @hydra_rmk_name_array@ }; 
     15const char *HYD_RMKI_comp_array[] = { @hydra_rmk_name_array@ }; 
    1616HYD_Status(*HYD_RMKI_comp_init[])(void) = { @hydra_rmk_init_array@ }; 
    1717 

  • mpich2/trunk/src/pm/hydra/utils/args/args.c

    r4508 r4887  
    1818} 
    1919 
    20 HYD_Status HYDU_find_in_path(char *execname, char **path) 
     20HYD_Status HYDU_find_in_path(const char *execname, char **path) 
    2121{ 
    2222    char *user_path = NULL, *tmp[HYD_NUM_TMP_STRINGS], *path_loc = NULL, *test_loc; 
    … …  
    3131        test_loc = strtok(user_path, ";:"); 
    3232        do { 
    33             tmp[0] = test_loc; 
    34             tmp[1] = "/"; 
    35             tmp[2] = execname; 
     33            tmp[0] = HYDU_strdup(test_loc); 
     34            tmp[1] = HYDU_strdup("/"); 
     35            tmp[2] = HYDU_strdup(execname); 
    3636            tmp[3] = NULL; 
    3737 
    3838            status = HYDU_str_alloc_and_join(tmp, &path_loc); 
    3939            HYDU_ERR_POP(status, "unable to join strings\n"); 
     40            HYDU_free_strlist(tmp); 
    4041 
    4142            if (exists(path_loc)) { 
    42                 tmp[0] = test_loc; 
    43                 tmp[1] = "/"; 
     43                tmp[0] = HYDU_strdup(test_loc); 
     44                tmp[1] = HYDU_strdup("/"); 
    4445                tmp[2] = NULL; 
    4546 
    4647                status = HYDU_str_alloc_and_join(tmp, path); 
    4748                HYDU_ERR_POP(status, "unable to join strings\n"); 
     49                HYDU_free_strlist(tmp); 
    4850 
    4951                goto fn_exit;   /* We are done */ 
    … …  
    7173} 
    7274 
    73 HYD_Status HYDU_get_base_path(char *execname, char *wdir, char **path) 
     75HYD_Status HYDU_get_base_path(const char *execname, char *wdir, char **path) 
    7476{ 
    7577    char *loc, *post; 
    … …  
    9294        /* Check if its absolute or relative */ 
    9395        if (post[0] != '/') {   /* relative */ 
    94             tmp[0] = wdir; 
    95             tmp[1] = "/"; 
    96             tmp[2] = post; 
     96            tmp[0] = HYDU_strdup(wdir); 
     97            tmp[1] = HYDU_strdup("/"); 
     98            tmp[2] = HYDU_strdup(post); 
    9799            tmp[3] = NULL; 
    98100            status = HYDU_str_alloc_and_join(tmp, path); 
    99101            HYDU_ERR_POP(status, "unable to join strings\n"); 
     102            HYDU_free_strlist(tmp); 
    100103        } 
    101104        else {  /* absolute */ 

  • mpich2/trunk/src/pm/hydra/utils/env/env.c

    r4786 r4887  
    174174 
    175175 
    176 HYD_Status HYDU_env_create(HYD_Env_t ** env, char *env_name, char *env_value) 
     176HYD_Status HYDU_env_create(HYD_Env_t ** env, const char *env_name, char *env_value) 
    177177{ 
    178178    HYD_Status status = HYD_SUCCESS; 

  • mpich2/trunk/src/pm/hydra/utils/launch/allocate.c

    r4836 r4887  
    243243 
    244244 
    245 static int count_elements(char *str, char *delim) 
     245static int count_elements(char *str, const char *delim) 
    246246{ 
    247247    int count; 
    … …  
    260260 
    261261 
    262 static char *pad_string(char *str, char *pad, int count) 
     262static char *pad_string(char *str, const char *pad, int count) 
    263263{ 
    264264    char *tmp[HYD_NUM_TMP_STRINGS], *out; 

  • mpich2/trunk/src/pm/hydra/utils/sock/sock.c

    r4518 r4887  
    222222 
    223223 
    224 HYD_Status HYDU_sock_writeline(int fd, char *buf, int maxsize) 
     224HYD_Status HYDU_sock_writeline(int fd, const char *buf, int maxsize) 
    225225{ 
    226226    int n; 
    … …  
    286286 
    287287 
    288 HYD_Status HYDU_sock_write(int fd, void *buf, int maxsize) 
     288HYD_Status HYDU_sock_write(int fd, const void *buf, int maxsize) 
    289289{ 
    290290    int n; 
    … …  
    310310 
    311311 
    312 HYD_Status HYDU_sock_trywrite(int fd, void *buf, int maxsize) 
     312HYD_Status HYDU_sock_trywrite(int fd, const void *buf, int maxsize) 
    313313{ 
    314314    int n; 

  • mpich2/trunk/src/pm/hydra/utils/timer/timer.c

    r4140 r4887  
    99/* FIXME: Here we assume that the timer is gettimeofday. */ 
    1010 
    11 void HYDU_time_set(HYD_Time * time, int *val) 
     11void HYDU_time_set(HYD_Time * time_p, int *val) 
    1212{ 
    1313    if (val == NULL) { 
    1414        /* Set time to right now */ 
    15         gettimeofday(time, NULL); 
     15        gettimeofday(time_p, NULL); 
    1616    } 
    1717    else { 
    18         time->tv_sec = *val; 
    19         time->tv_usec = 0; 
     18        time_p->tv_sec = *val; 
     19        time_p->tv_usec = 0; 
    2020    } 
    2121}