From e14953a7d23cb8b951b8bc7eaaaf2cdd3b67a079 Mon Sep 17 00:00:00 2001 From: Trond Norbye Date: Sun, 6 Dec 2009 10:02:23 +0100 Subject: [PATCH] Fixed ILP32 issues --- clients/memslap.c | 57 +++++++++------ clients/ms_conn.c | 26 +++++-- clients/ms_setting.c | 22 +++--- clients/ms_thread.c | 4 +- libmemcached/memcached_get.c | 138 +++++++++++++++++------------------ 5 files changed, 133 insertions(+), 114 deletions(-) diff --git a/clients/memslap.c b/clients/memslap.c index 298453dd..d08b4d9b 100644 --- a/clients/memslap.c +++ b/clients/memslap.c @@ -24,56 +24,65 @@ #define PROGRAM_DESCRIPTION \ "Generates workload against memcached servers." +#ifdef __sun + /* For some odd reason the option struct on solaris defines the argument + * as char* and not const char* + */ +#define OPTIONSTRING char* +#else +#define OPTIONSTRING const char* +#endif + /* options */ static struct option long_options[]= { - { "servers", required_argument, NULL, + { (OPTIONSTRING)"servers", required_argument, NULL, OPT_SERVERS }, - { "threads", required_argument, NULL, + { (OPTIONSTRING)"threads", required_argument, NULL, OPT_THREAD_NUMBER }, - { "concurrency", required_argument, NULL, + { (OPTIONSTRING)"concurrency", required_argument, NULL, OPT_CONCURRENCY }, - { "conn_sock", required_argument, NULL, + { (OPTIONSTRING)"conn_sock", required_argument, NULL, OPT_SOCK_PER_CONN }, - { "execute_number", required_argument, NULL, + { (OPTIONSTRING)"execute_number", required_argument, NULL, OPT_EXECUTE_NUMBER }, - { "time", required_argument, NULL, + { (OPTIONSTRING)"time", required_argument, NULL, OPT_TIME }, - { "cfg_cmd", required_argument, NULL, + { (OPTIONSTRING)"cfg_cmd", required_argument, NULL, OPT_CONFIG_CMD }, - { "win_size", required_argument, NULL, + { (OPTIONSTRING)"win_size", required_argument, NULL, OPT_WINDOW_SIZE }, - { "fixed_size", required_argument, NULL, + { (OPTIONSTRING)"fixed_size", required_argument, NULL, OPT_FIXED_LTH }, - { "verify", required_argument, NULL, + { (OPTIONSTRING)"verify", required_argument, NULL, OPT_VERIFY }, - { "division", required_argument, NULL, + { (OPTIONSTRING)"division", required_argument, NULL, OPT_GETS_DIVISION }, - { "stat_freq", required_argument, NULL, + { (OPTIONSTRING)"stat_freq", required_argument, NULL, OPT_STAT_FREQ }, - { "exp_verify", required_argument, NULL, + { (OPTIONSTRING)"exp_verify", required_argument, NULL, OPT_EXPIRE }, - { "overwrite", required_argument, NULL, + { (OPTIONSTRING)"overwrite", required_argument, NULL, OPT_OVERWRITE }, - { "reconnect", no_argument, NULL, + { (OPTIONSTRING)"reconnect", no_argument, NULL, OPT_RECONNECT }, - { "udp", no_argument, NULL, + { (OPTIONSTRING)"udp", no_argument, NULL, OPT_UDP }, - { "facebook", no_argument, NULL, + { (OPTIONSTRING)"facebook", no_argument, NULL, OPT_FACEBOOK_TEST }, - { "binary", no_argument, NULL, + { (OPTIONSTRING)"binary", no_argument, NULL, OPT_BINARY_PROTOCOL }, - { "tps", required_argument, NULL, + { (OPTIONSTRING)"tps", required_argument, NULL, OPT_TPS }, - { "rep_write", required_argument, NULL, + { (OPTIONSTRING)"rep_write", required_argument, NULL, OPT_REP_WRITE_SRV }, - { "verbose", no_argument, NULL, + { (OPTIONSTRING)"verbose", no_argument, NULL, OPT_VERBOSE }, - { "help", no_argument, NULL, + { (OPTIONSTRING)"help", no_argument, NULL, OPT_HELP }, - { "version", no_argument, NULL, + { (OPTIONSTRING)"version", no_argument, NULL, OPT_VERSION }, - { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, }; /* Prototypes */ diff --git a/clients/ms_conn.c b/clients/ms_conn.c index 59b0875d..34707958 100644 --- a/clients/ms_conn.c +++ b/clients/ms_conn.c @@ -23,6 +23,18 @@ #include "ms_thread.h" #include "ms_atomic.h" +#ifdef linux +/* /usr/include/netinet/in.h defines macros from ntohs() to _bswap_nn to + * optimize the conversion functions, but the prototypes generate warnings + * from gcc. The conversion methods isn't the bottleneck for my app, so + * just remove the warnings by undef'ing the optimization .. + */ +#undef ntohs +#undef ntohl +#undef htons +#undef htonl +#endif + /* for network write */ #define TRANSMIT_COMPLETE 0 #define TRANSMIT_INCOMPLETE 1 @@ -1272,7 +1284,7 @@ void ms_reset_conn(ms_conn_t *c, bool timeout) { if ((c->packets > 0) && (c->packets < MAX_UDP_PACKET)) { - memset(c->udppkt, 0, sizeof(ms_udppkt_t) * (uint64_t)c->packets); + memset(c->udppkt, 0, sizeof(ms_udppkt_t) * (size_t)c->packets); } c->packets= 0; @@ -1331,9 +1343,9 @@ static int ms_try_read_line(ms_conn_t *c) c->binary_header= *rsp; c->binary_header.response.extlen= rsp->response.extlen; - c->binary_header.response.keylen= ntohl(rsp->response.keylen); + c->binary_header.response.keylen= ntohs(rsp->response.keylen); c->binary_header.response.bodylen= ntohl(rsp->response.bodylen); - c->binary_header.response.status= ntohl(rsp->response.status); + c->binary_header.response.status= ntohs(rsp->response.status); if (c->binary_header.response.magic != PROTOCOL_BINARY_RES) { @@ -2013,7 +2025,7 @@ static int ms_add_msghdr(ms_conn_t *c) if (c->msgsize == c->msgused) { msg= - realloc(c->msglist, (uint64_t)c->msgsize * 2 * sizeof(struct msghdr)); + realloc(c->msglist, (size_t)c->msgsize * 2 * sizeof(struct msghdr)); if (! msg) return -1; @@ -2066,7 +2078,7 @@ static int ms_ensure_iov_space(ms_conn_t *c) { int i, iovnum; struct iovec *new_iov= (struct iovec *)realloc(c->iov, - ((uint64_t)c->iovsize + ((size_t)c->iovsize * 2) * sizeof(struct iovec)); if (! new_iov) @@ -2258,7 +2270,7 @@ static int ms_transmit(ms_conn_t *c) if (res > 0) { m->msg_iov->iov_base= (void *)((unsigned char *)m->msg_iov->iov_base + res); - m->msg_iov->iov_len-= (uint64_t)res; + m->msg_iov->iov_len-= (size_t)res; } return TRANSMIT_INCOMPLETE; } @@ -3298,7 +3310,7 @@ static void ms_add_bin_header(ms_conn_t *c, header->request.magic= (uint8_t)PROTOCOL_BINARY_REQ; header->request.opcode= (uint8_t)opcode; - header->request.keylen= htonl(key_len); + header->request.keylen= htons(key_len); header->request.extlen= (uint8_t)hdr_len; header->request.datatype= (uint8_t)PROTOCOL_BINARY_RAW_BYTES; diff --git a/clients/ms_setting.c b/clients/ms_setting.c index 52e4670f..2821ec52 100644 --- a/clients/ms_setting.c +++ b/clients/ms_setting.c @@ -89,9 +89,7 @@ static ssize_t getline (char **line, size_t *line_size, FILE *fp) for (;;) { - char i; - - i = getc(fp); + int i= getc(fp); if (i == EOF) { result = -1; @@ -126,7 +124,7 @@ static ssize_t getline (char **line, size_t *line_size, FILE *fp) *line_size= needed; } - (*line)[cur_len]= i; + (*line)[cur_len]= (char)i; cur_len++; if (i == delim) @@ -200,7 +198,7 @@ static void ms_get_serverlist(char *str) { srvs= (ms_mcd_server_t *)realloc( ms_setting.servers, - (uint64_t)ms_setting.total_srv_cnt + (size_t)ms_setting.total_srv_cnt * sizeof(ms_mcd_server_t) * 2); if (srvs == NULL) { @@ -400,7 +398,7 @@ static void ms_parse_cfg_file(char *cfg_file) if (nread != EOF) { - if (sscanf(line, "%lu %lu %lf ", &start_len, + if (sscanf(line, "%zu %zu %lf ", &start_len, &end_len, &proportion) != 3) { conf_type= ms_get_conf_type(line); @@ -415,7 +413,7 @@ static void ms_parse_cfg_file(char *cfg_file) { key_distr= (ms_key_distr_t *)realloc( ms_setting.key_distr, - (uint64_t)ms_setting. + (size_t)ms_setting. total_key_rng_cnt * sizeof(ms_key_distr_t) * 2); if (key_distr == NULL) { @@ -442,7 +440,7 @@ static void ms_parse_cfg_file(char *cfg_file) if (nread != EOF) { - if (sscanf(line, "%lu %lu %lf %lu", &start_len, &end_len, + if (sscanf(line, "%zu %zu %lf %zu", &start_len, &end_len, &proportion, &frequence) != 3) { conf_type= ms_get_conf_type(line); @@ -459,7 +457,7 @@ static void ms_parse_cfg_file(char *cfg_file) { val_distr= (ms_value_distr_t *)realloc( ms_setting.value_distr, - (uint64_t)ms_setting. + (size_t)ms_setting. total_val_rng_cnt * sizeof(ms_value_distr_t) * 2); if (val_distr == NULL) { @@ -911,7 +909,7 @@ void ms_setting_init_pre() ms_setting.run_time= DEFAULT_RUN_TIME; ms_setting.total_srv_cnt= MCD_SRVS_NUM_INIT; ms_setting.servers= (ms_mcd_server_t *)malloc( - (uint64_t)ms_setting.total_srv_cnt + (size_t)ms_setting.total_srv_cnt * sizeof(ms_mcd_server_t)); if (ms_setting.servers == NULL) { @@ -930,7 +928,7 @@ static void ms_setting_slapmode_init_post() { ms_setting.total_key_rng_cnt= KEY_RANGE_COUNT_INIT; ms_setting.key_distr= (ms_key_distr_t *)malloc( - (uint64_t)ms_setting.total_key_rng_cnt + (size_t)ms_setting.total_key_rng_cnt * sizeof(ms_key_distr_t)); if (ms_setting.key_distr == NULL) { @@ -940,7 +938,7 @@ static void ms_setting_slapmode_init_post() ms_setting.total_val_rng_cnt= VALUE_RANGE_COUNT_INIT; ms_setting.value_distr= (ms_value_distr_t *)malloc( - (uint64_t)ms_setting.total_val_rng_cnt + (size_t)ms_setting.total_val_rng_cnt * sizeof( ms_value_distr_t)); if (ms_setting.value_distr == NULL) diff --git a/clients/ms_thread.c b/clients/ms_thread.c index af856366..5c387d0e 100644 --- a/clients/ms_thread.c +++ b/clients/ms_thread.c @@ -61,7 +61,7 @@ static void ms_check_sock_timeout(void) if (c->udp) { - time_diff= (int)(ms_thread->curr_time - c->start_time.tv_sec); + time_diff= (int)(ms_thread->curr_time - (rel_time_t)c->start_time.tv_sec); /* wait time out */ if (time_diff > SOCK_WAIT_TIMEOUT) @@ -169,7 +169,7 @@ static int ms_set_thread_cpu_affinity(int cpu) */ static int ms_setup_thread(ms_thread_ctx_t *thread_ctx) { - + ms_thread_t *ms_thread= (ms_thread_t *)calloc(sizeof(*ms_thread), 1); pthread_setspecific(ms_thread_key, (void *)ms_thread); diff --git a/libmemcached/memcached_get.c b/libmemcached/memcached_get.c index 0aa0f44c..9ba1388d 100644 --- a/libmemcached/memcached_get.c +++ b/libmemcached/memcached_get.c @@ -1,32 +1,32 @@ #include "common.h" #include "memcached_io.h" -/* +/* What happens if no servers exist? */ -char *memcached_get(memcached_st *ptr, const char *key, - size_t key_length, - size_t *value_length, +char *memcached_get(memcached_st *ptr, const char *key, + size_t key_length, + size_t *value_length, uint32_t *flags, memcached_return *error) { - return memcached_get_by_key(ptr, NULL, 0, key, key_length, value_length, + return memcached_get_by_key(ptr, NULL, 0, key, key_length, value_length, flags, error); } -static memcached_return memcached_mget_by_key_real(memcached_st *ptr, - const char *master_key, +static memcached_return memcached_mget_by_key_real(memcached_st *ptr, + const char *master_key, size_t master_key_length, - const char * const *keys, - const size_t *key_length, + const char * const *keys, + const size_t *key_length, size_t number_of_keys, bool mget_mode); -char *memcached_get_by_key(memcached_st *ptr, - const char *master_key, - size_t master_key_length, +char *memcached_get_by_key(memcached_st *ptr, + const char *master_key, + size_t master_key_length, const char *key, size_t key_length, - size_t *value_length, + size_t *value_length, uint32_t *flags, memcached_return *error) { @@ -42,11 +42,11 @@ char *memcached_get_by_key(memcached_st *ptr, } /* Request the key */ - *error= memcached_mget_by_key_real(ptr, master_key, master_key_length, - (const char * const *)&key, + *error= memcached_mget_by_key_real(ptr, master_key, master_key_length, + (const char * const *)&key, &key_length, 1, false); - value= memcached_fetch(ptr, NULL, NULL, + value= memcached_fetch(ptr, NULL, NULL, value_length, flags, error); /* This is for historical reasons */ if (*error == MEMCACHED_END) @@ -60,7 +60,7 @@ char *memcached_get_by_key(memcached_st *ptr, memcached_result_reset(&ptr->result); rc= ptr->get_key_failure(ptr, key, key_length, &ptr->result); - + /* On all failure drop to returning NULL */ if (rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED) { @@ -71,7 +71,7 @@ char *memcached_get_by_key(memcached_st *ptr, if (latch == 0) memcached_behavior_set(ptr, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, 1); - rc= memcached_set(ptr, key, key_length, + rc= memcached_set(ptr, key, key_length, memcached_result_value(&ptr->result), memcached_result_length(&ptr->result), 0, memcached_result_flags(&ptr->result)); @@ -81,7 +81,7 @@ char *memcached_get_by_key(memcached_st *ptr, } else { - rc= memcached_set(ptr, key, key_length, + rc= memcached_set(ptr, key, key_length, memcached_result_value(&ptr->result), memcached_result_length(&ptr->result), 0, memcached_result_flags(&ptr->result)); @@ -100,17 +100,17 @@ char *memcached_get_by_key(memcached_st *ptr, return NULL; } - (void)memcached_fetch(ptr, NULL, NULL, - &dummy_length, &dummy_flags, + (void)memcached_fetch(ptr, NULL, NULL, + &dummy_length, &dummy_flags, &dummy_error); WATCHPOINT_ASSERT(dummy_length == 0); return value; } -memcached_return memcached_mget(memcached_st *ptr, - const char * const *keys, - const size_t *key_length, +memcached_return memcached_mget(memcached_st *ptr, + const char * const *keys, + const size_t *key_length, size_t number_of_keys) { return memcached_mget_by_key(ptr, NULL, 0, keys, key_length, number_of_keys); @@ -119,16 +119,16 @@ memcached_return memcached_mget(memcached_st *ptr, static memcached_return binary_mget_by_key(memcached_st *ptr, unsigned int master_server_key, bool is_master_key_set, - const char * const *keys, + const char * const *keys, const size_t *key_length, size_t number_of_keys, bool mget_mode); -static memcached_return memcached_mget_by_key_real(memcached_st *ptr, - const char *master_key, +static memcached_return memcached_mget_by_key_real(memcached_st *ptr, + const char *master_key, size_t master_key_length, - const char * const *keys, - const size_t *key_length, + const char * const *keys, + const size_t *key_length, size_t number_of_keys, bool mget_mode) { @@ -162,7 +162,7 @@ static memcached_return memcached_mget_by_key_real(memcached_st *ptr, is_master_key_set= true; } - /* + /* Here is where we pay for the non-block API. We need to remove any data sitting in the queue before we start our get. @@ -181,9 +181,9 @@ static memcached_return memcached_mget_by_key_real(memcached_st *ptr, (void)memcached_response(&ptr->hosts[x], buffer, MEMCACHED_DEFAULT_COMMAND_SIZE, &ptr->result); } } - + if (ptr->flags & MEM_BINARY_PROTOCOL) - return binary_mget_by_key(ptr, master_server_key, is_master_key_set, keys, + return binary_mget_by_key(ptr, master_server_key, is_master_key_set, keys, key_length, number_of_keys, mget_mode); if (ptr->flags & MEM_SUPPORT_CAS) @@ -192,7 +192,7 @@ static memcached_return memcached_mget_by_key_real(memcached_st *ptr, get_command_length= 5; } - /* + /* If a server fails we warn about errors and start all over with sending keys to the server. */ @@ -267,14 +267,14 @@ static memcached_return memcached_mget_by_key_real(memcached_st *ptr, return rc; } -memcached_return memcached_mget_by_key(memcached_st *ptr, - const char *master_key, +memcached_return memcached_mget_by_key(memcached_st *ptr, + const char *master_key, size_t master_key_length, - const char * const *keys, - const size_t *key_length, + const char * const *keys, + const size_t *key_length, size_t number_of_keys) { - return memcached_mget_by_key_real(ptr, master_key, master_key_length, keys, + return memcached_mget_by_key_real(ptr, master_key, master_key_length, keys, key_length, number_of_keys, true); } @@ -322,8 +322,8 @@ memcached_return memcached_mget_execute_by_key(memcached_st *ptr, static memcached_return simple_binary_mget(memcached_st *ptr, unsigned int master_server_key, bool is_master_key_set, - const char * const *keys, - const size_t *key_length, + const char * const *keys, + const size_t *key_length, size_t number_of_keys, bool mget_mode) { memcached_return rc= MEMCACHED_NOTFOUND; @@ -331,11 +331,11 @@ static memcached_return simple_binary_mget(memcached_st *ptr, int flush= number_of_keys == 1; - /* + /* If a server fails we warn about errors and start all over with sending keys to the server. */ - for (x= 0; x < number_of_keys; x++) + for (x= 0; x < number_of_keys; x++) { unsigned int server_key; @@ -344,13 +344,13 @@ static memcached_return simple_binary_mget(memcached_st *ptr, else server_key= memcached_generate_hash(ptr, keys[x], key_length[x]); - if (memcached_server_response_count(&ptr->hosts[server_key]) == 0) + if (memcached_server_response_count(&ptr->hosts[server_key]) == 0) { rc= memcached_connect(&ptr->hosts[server_key]); - if (rc != MEMCACHED_SUCCESS) + if (rc != MEMCACHED_SUCCESS) continue; } - + protocol_binary_request_getk request= {.bytes= {0}}; request.message.header.request.magic= PROTOCOL_BINARY_REQ; if (mget_mode) @@ -371,26 +371,26 @@ static memcached_return simple_binary_mget(memcached_st *ptr, request.message.header.request.keylen= htons((uint16_t)key_length[x]); request.message.header.request.datatype= PROTOCOL_BINARY_RAW_BYTES; request.message.header.request.bodylen= htonl((uint32_t) key_length[x]); - + if ((memcached_io_write(&ptr->hosts[server_key], request.bytes, sizeof(request.bytes), 0) == -1) || - (memcached_io_write(&ptr->hosts[server_key], keys[x], - key_length[x], (char) flush) == -1)) + (memcached_io_write(&ptr->hosts[server_key], keys[x], + key_length[x], (char) flush) == -1)) { memcached_server_response_reset(&ptr->hosts[server_key]); rc= MEMCACHED_SOME_ERRORS; continue; } - + /* We just want one pending response per server */ - memcached_server_response_reset(&ptr->hosts[server_key]); - memcached_server_response_increment(&ptr->hosts[server_key]); + memcached_server_response_reset(&ptr->hosts[server_key]); + memcached_server_response_increment(&ptr->hosts[server_key]); if ((x > 0 && x == ptr->io_key_prefetch) && memcached_flush_buffers(ptr) != MEMCACHED_SUCCESS) rc= MEMCACHED_SOME_ERRORS; } - if (mget_mode) + if (mget_mode) { /* * Send a noop command to flush the buffers @@ -399,19 +399,19 @@ static memcached_return simple_binary_mget(memcached_st *ptr, request.message.header.request.magic= PROTOCOL_BINARY_REQ; request.message.header.request.opcode= PROTOCOL_BINARY_CMD_NOOP; request.message.header.request.datatype= PROTOCOL_BINARY_RAW_BYTES; - + for (x= 0; x < ptr->number_of_hosts; x++) - if (memcached_server_response_count(&ptr->hosts[x])) + if (memcached_server_response_count(&ptr->hosts[x])) { - if (memcached_io_write(&ptr->hosts[x], NULL, 0, 1) == -1) + if (memcached_io_write(&ptr->hosts[x], NULL, 0, 1) == -1) { memcached_server_response_reset(&ptr->hosts[x]); memcached_io_reset(&ptr->hosts[x]); rc= MEMCACHED_SOME_ERRORS; } - if (memcached_io_write(&ptr->hosts[x], request.bytes, - sizeof(request.bytes), 1) == -1) + if (memcached_io_write(&ptr->hosts[x], request.bytes, + sizeof(request.bytes), 1) == -1) { memcached_server_response_reset(&ptr->hosts[x]); memcached_io_reset(&ptr->hosts[x]); @@ -425,9 +425,9 @@ static memcached_return simple_binary_mget(memcached_st *ptr, } static memcached_return replication_binary_mget(memcached_st *ptr, - uint32_t* hash, + uint32_t* hash, bool* dead_servers, - const char *const *keys, + const char *const *keys, const size_t *key_length, size_t number_of_keys) { @@ -435,14 +435,14 @@ static memcached_return replication_binary_mget(memcached_st *ptr, uint32_t x, start= 0; uint64_t randomize_read= memcached_behavior_get(ptr, MEMCACHED_BEHAVIOR_RANDOMIZE_REPLICA_READ); - if (randomize_read) - start= (uint32_t)(random() % (ptr->number_of_replicas + 1)); + if (randomize_read) + start= (uint32_t)random() % (uint32_t)(ptr->number_of_replicas + 1); /* Loop for each replica */ for (uint32_t replica= 0; replica <= ptr->number_of_replicas; ++replica) { bool success= true; - + for (x= 0; x < number_of_keys; ++x) { if (hash[x] == ptr->number_of_hosts) @@ -453,7 +453,7 @@ static memcached_return replication_binary_mget(memcached_st *ptr, /* In case of randomized reads */ if (randomize_read && ((server + start) <= (hash[x] + ptr->number_of_replicas))) server += start; - + while (server >= ptr->number_of_hosts) server -= ptr->number_of_hosts; @@ -517,19 +517,19 @@ static memcached_return replication_binary_mget(memcached_st *ptr, static memcached_return binary_mget_by_key(memcached_st *ptr, unsigned int master_server_key, bool is_master_key_set, - const char * const *keys, + const char * const *keys, const size_t *key_length, - size_t number_of_keys, + size_t number_of_keys, bool mget_mode) { memcached_return rc; - if (ptr->number_of_replicas == 0) + if (ptr->number_of_replicas == 0) { rc= simple_binary_mget(ptr, master_server_key, is_master_key_set, keys, key_length, number_of_keys, mget_mode); - } - else + } + else { uint32_t* hash; bool* dead_servers; @@ -551,7 +551,7 @@ static memcached_return binary_mget_by_key(memcached_st *ptr, for (unsigned int x= 0; x < number_of_keys; x++) hash[x]= memcached_generate_hash(ptr, keys[x], key_length[x]); - rc= replication_binary_mget(ptr, hash, dead_servers, keys, + rc= replication_binary_mget(ptr, hash, dead_servers, keys, key_length, number_of_keys); ptr->call_free(ptr, hash); -- 2.30.2