I realise whitespace changes are generally frowned on, but nbd-tester-client.c is almost impossible to edit in (e.g.) emacs even in 'linux' mode, because its whitespacing is inconsistent and does not follow the style of the rest of the package.
This is a whitespace ONLY change and is the equivalent of running Lindent. Lindent does: indent -npro -kr -i8 -ts8 -sob -l80 -ss -ncs -cp1 -il0 nbd-tester-client.c on indent >= v2.2.10, and indent -npro -kr -i8 -ts8 -sob -l80 -ss -ncs -cp1 nbd-tester-client.c otherwise. See: https://github.com/torvalds/linux/blob/master/scripts/Lindent Signed-off-by: Alex Bligh <[email protected]> --- tests/run/nbd-tester-client.c | 1181 +++++++++++++++++++++++------------------ 1 file changed, 675 insertions(+), 506 deletions(-) diff --git a/tests/run/nbd-tester-client.c b/tests/run/nbd-tester-client.c index 1b99fa8..592930e 100644 --- a/tests/run/nbd-tester-client.c +++ b/tests/run/nbd-tester-client.c @@ -43,13 +43,13 @@ #include "cliserv.h" static gchar errstr[1024]; -const static int errstr_len=1023; +const static int errstr_len = 1023; static uint64_t size; static int looseordering = 0; -static gchar * transactionlog = "nbd-tester-client.tr"; +static gchar *transactionlog = "nbd-tester-client.tr"; typedef enum { CONNECTION_TYPE_NONE, @@ -68,29 +68,29 @@ struct reqcontext { uint64_t seq; char orighandle[8]; struct nbd_request req; - struct reqcontext * next; - struct reqcontext * prev; + struct reqcontext *next; + struct reqcontext *prev; }; struct rclist { - struct reqcontext * head; - struct reqcontext * tail; + struct reqcontext *head; + struct reqcontext *tail; int numitems; }; struct chunk { - char * buffer; - char * readptr; - char * writeptr; + char *buffer; + char *readptr; + char *writeptr; uint64_t space; uint64_t length; - struct chunk * next; - struct chunk * prev; + struct chunk *next; + struct chunk *prev; }; struct chunklist { - struct chunk * head; - struct chunk * tail; + struct chunk *head; + struct chunk *tail; int numitems; }; @@ -100,17 +100,18 @@ struct blkitem { int32_t inflightw; }; -void rclist_unlink(struct rclist * l, struct reqcontext * p) { +void rclist_unlink(struct rclist *l, struct reqcontext *p) +{ if (p && l) { - struct reqcontext * prev = p->prev; - struct reqcontext * next = p->next; - + struct reqcontext *prev = p->prev; + struct reqcontext *next = p->next; + /* Fix link to previous */ if (prev) prev->next = next; else l->head = next; - + if (next) next->prev = prev; else @@ -119,11 +120,12 @@ void rclist_unlink(struct rclist * l, struct reqcontext * p) { p->prev = NULL; p->next = NULL; l->numitems--; - } -} + } +} /* Add a new list item to the tail */ -void rclist_addtail(struct rclist * l, struct reqcontext * p) { +void rclist_addtail(struct rclist *l, struct reqcontext *p) +{ if (!p || !l) return; if (l->tail) { @@ -144,17 +146,18 @@ void rclist_addtail(struct rclist * l, struct reqcontext * p) { l->numitems++; } -void chunklist_unlink(struct chunklist * l, struct chunk * p) { +void chunklist_unlink(struct chunklist *l, struct chunk *p) +{ if (p && l) { - struct chunk * prev = p->prev; - struct chunk * next = p->next; - + struct chunk *prev = p->prev; + struct chunk *next = p->next; + /* Fix link to previous */ if (prev) prev->next = next; else l->head = next; - + if (next) next->prev = prev; else @@ -163,11 +166,12 @@ void chunklist_unlink(struct chunklist * l, struct chunk * p) { p->prev = NULL; p->next = NULL; l->numitems--; - } -} + } +} /* Add a new list item to the tail */ -void chunklist_addtail(struct chunklist * l, struct chunk * p) { +void chunklist_addtail(struct chunklist *l, struct chunk *p) +{ if (!p || !l) return; if (l->tail) { @@ -189,13 +193,13 @@ void chunklist_addtail(struct chunklist * l, struct chunk * p) { } /* Add some new bytes to a chunklist */ -void addbuffer(struct chunklist * l, void * data, uint64_t len) { - void * buf; - uint64_t size = 64*1024; - struct chunk * pchunk; +void addbuffer(struct chunklist *l, void *data, uint64_t len) +{ + void *buf; + uint64_t size = 64 * 1024; + struct chunk *pchunk; - while (len>0) - { + while (len > 0) { /* First see if there is a current chunk, and if it has space */ if (l->tail && l->tail->space) { uint64_t towrite = len; @@ -209,11 +213,13 @@ void addbuffer(struct chunklist * l, void * data, uint64_t len) { data += towrite; } - if (len>0) { + if (len > 0) { /* We still need to write more, so prepare a new chunk */ - if ((NULL == (buf = malloc(size))) || (NULL == (pchunk = calloc(1, sizeof(struct chunk))))) { + if ((NULL == (buf = malloc(size))) + || (NULL == + (pchunk = calloc(1, sizeof(struct chunk))))) { g_critical("Out of memory"); - exit (1); + exit(1); } pchunk->buffer = buf; @@ -227,15 +233,15 @@ void addbuffer(struct chunklist * l, void * data, uint64_t len) { } /* returns 0 on success, -1 on failure */ -int writebuffer(int fd, struct chunklist * l) { +int writebuffer(int fd, struct chunklist *l) +{ - struct chunk * pchunk = NULL; + struct chunk *pchunk = NULL; int res; if (!l) return 0; - while (!pchunk) - { + while (!pchunk) { pchunk = l->head; if (!pchunk) return 0; @@ -246,12 +252,12 @@ int writebuffer(int fd, struct chunklist * l) { pchunk = NULL; } } - + /* OK we have a chunk with some data in */ res = write(fd, pchunk->readptr, pchunk->length); - if (res==0) + if (res == 0) errno = EAGAIN; - if (res<=0) + if (res <= 0) return -1; pchunk->length -= res; pchunk->readptr += res; @@ -263,70 +269,74 @@ int writebuffer(int fd, struct chunklist * l) { return 0; } - - #define TEST_WRITE (1<<0) #define TEST_FLUSH (1<<1) #define TEST_EXPECT_ERROR (1<<2) -int timeval_subtract (struct timeval *result, struct timeval *x, - struct timeval *y) { +int timeval_subtract(struct timeval *result, struct timeval *x, + struct timeval *y) +{ if (x->tv_usec < y->tv_usec) { int nsec = (y->tv_usec - x->tv_usec) / 1000000 + 1; y->tv_usec -= 1000000 * nsec; y->tv_sec += nsec; } - + if (x->tv_usec - y->tv_usec > 1000000) { int nsec = (x->tv_usec - y->tv_usec) / 1000000; y->tv_usec += 1000000 * nsec; y->tv_sec -= nsec; } - + result->tv_sec = x->tv_sec - y->tv_sec; result->tv_usec = x->tv_usec - y->tv_usec; - + return x->tv_sec < y->tv_sec; } -double timeval_diff_to_double (struct timeval * x, struct timeval * y) { +double timeval_diff_to_double(struct timeval *x, struct timeval *y) +{ struct timeval r; timeval_subtract(&r, x, y); - return r.tv_sec * 1.0 + r.tv_usec/1000000.0; + return r.tv_sec * 1.0 + r.tv_usec / 1000000.0; } -static inline int read_all(int f, void *buf, size_t len) { +static inline int read_all(int f, void *buf, size_t len) +{ ssize_t res; - size_t retval=0; + size_t retval = 0; - while(len>0) { - if((res=read(f, buf, len)) <=0) { + while (len > 0) { + if ((res = read(f, buf, len)) <= 0) { if (!res) - errno=EAGAIN; - snprintf(errstr, errstr_len, "Read failed: %s", strerror(errno)); + errno = EAGAIN; + snprintf(errstr, errstr_len, "Read failed: %s", + strerror(errno)); return -1; } - len-=res; - buf+=res; - retval+=res; + len -= res; + buf += res; + retval += res; } return retval; } -static inline int write_all(int f, void *buf, size_t len) { +static inline int write_all(int f, void *buf, size_t len) +{ ssize_t res; - size_t retval=0; + size_t retval = 0; - while(len>0) { - if((res=write(f, buf, len)) <=0) { + while (len > 0) { + if ((res = write(f, buf, len)) <= 0) { if (!res) - errno=EAGAIN; - snprintf(errstr, errstr_len, "Write failed: %s", strerror(errno)); + errno = EAGAIN; + snprintf(errstr, errstr_len, "Write failed: %s", + strerror(errno)); return -1; } - len-=res; - buf+=res; - retval+=res; + len -= res; + buf += res; + retval += res; } return retval; } @@ -337,7 +347,9 @@ static inline int write_all(int f, void *buf, size_t len) { #define WRITE_ALL_ERRCHK(f, buf, len, whereto, errmsg...) if((write_all(f, buf, len))<=0) { snprintf(errstr, errstr_len, ##errmsg); goto whereto; } #define WRITE_ALL_ERR_RT(f, buf, len, whereto, rval, errmsg...) if((write_all(f, buf, len))<=0) { snprintf(errstr, errstr_len, ##errmsg); retval = rval; goto whereto; } -int setup_connection_common(int sock, char* name, CONNECTION_TYPE ctype, int* serverflags) { +int setup_connection_common(int sock, char *name, CONNECTION_TYPE ctype, + int *serverflags) +{ char buf[256]; u64 tmp64; uint64_t mymagic = (name ? opts_magic : cliserv_magic); @@ -345,72 +357,87 @@ int setup_connection_common(int sock, char* name, CONNECTION_TYPE ctype, int* se uint16_t handshakeflags = 0; uint32_t negotiationflags = 0; - if(ctype<CONNECTION_TYPE_INIT_PASSWD) + if (ctype < CONNECTION_TYPE_INIT_PASSWD) goto end; - READ_ALL_ERRCHK(sock, buf, strlen(INIT_PASSWD), err, "Could not read INIT_PASSWD: %s", strerror(errno)); - if(strlen(buf)==0) { + READ_ALL_ERRCHK(sock, buf, strlen(INIT_PASSWD), err, + "Could not read INIT_PASSWD: %s", strerror(errno)); + if (strlen(buf) == 0) { snprintf(errstr, errstr_len, "Server closed connection"); goto err; } - if(strncmp(buf, INIT_PASSWD, strlen(INIT_PASSWD))) { + if (strncmp(buf, INIT_PASSWD, strlen(INIT_PASSWD))) { snprintf(errstr, errstr_len, "INIT_PASSWD does not match"); goto err; } - if(ctype<CONNECTION_TYPE_CLISERV) + if (ctype < CONNECTION_TYPE_CLISERV) goto end; - READ_ALL_ERRCHK(sock, &tmp64, sizeof(tmp64), err, "Could not read cliserv_magic: %s", strerror(errno)); - tmp64=ntohll(tmp64); - if(tmp64 != mymagic) { + READ_ALL_ERRCHK(sock, &tmp64, sizeof(tmp64), err, + "Could not read cliserv_magic: %s", strerror(errno)); + tmp64 = ntohll(tmp64); + if (tmp64 != mymagic) { strncpy(errstr, "mymagic does not match", errstr_len); goto err; } - if(ctype<CONNECTION_TYPE_FULL) + if (ctype < CONNECTION_TYPE_FULL) goto end; - if(!name) { - READ_ALL_ERRCHK(sock, &size, sizeof(size), err, "Could not read size: %s", strerror(errno)); - size=ntohll(size); - READ_ALL_ERRCHK(sock, buf, 128, err, "Could not read data: %s", strerror(errno)); + if (!name) { + READ_ALL_ERRCHK(sock, &size, sizeof(size), err, + "Could not read size: %s", strerror(errno)); + size = ntohll(size); + READ_ALL_ERRCHK(sock, buf, 128, err, "Could not read data: %s", + strerror(errno)); goto end; } /* handshake flags */ - READ_ALL_ERRCHK(sock, &handshakeflags, sizeof(handshakeflags), err, "Could not read reserved field: %s", strerror(errno)); + READ_ALL_ERRCHK(sock, &handshakeflags, sizeof(handshakeflags), err, + "Could not read reserved field: %s", strerror(errno)); /* negotiation flags */ if (handshakeflags & NBD_FLAG_FIXED_NEWSTYLE) negotiationflags |= NBD_FLAG_C_FIXED_NEWSTYLE; - WRITE_ALL_ERRCHK(sock, &negotiationflags, sizeof(negotiationflags), err, "Could not write reserved field: %s", strerror(errno)); + WRITE_ALL_ERRCHK(sock, &negotiationflags, sizeof(negotiationflags), err, + "Could not write reserved field: %s", strerror(errno)); /* magic */ tmp64 = htonll(opts_magic); - WRITE_ALL_ERRCHK(sock, &tmp64, sizeof(tmp64), err, "Could not write magic: %s", strerror(errno)); + WRITE_ALL_ERRCHK(sock, &tmp64, sizeof(tmp64), err, + "Could not write magic: %s", strerror(errno)); /* name */ tmp32 = htonl(NBD_OPT_EXPORT_NAME); - WRITE_ALL_ERRCHK(sock, &tmp32, sizeof(tmp32), err, "Could not write option: %s", strerror(errno)); - tmp32 = htonl((uint32_t)strlen(name)); - WRITE_ALL_ERRCHK(sock, &tmp32, sizeof(tmp32), err, "Could not write name length: %s", strerror(errno)); - WRITE_ALL_ERRCHK(sock, name, strlen(name), err, "Could not write name:: %s", strerror(errno)); - READ_ALL_ERRCHK(sock, &size, sizeof(size), err, "Could not read size: %s", strerror(errno)); + WRITE_ALL_ERRCHK(sock, &tmp32, sizeof(tmp32), err, + "Could not write option: %s", strerror(errno)); + tmp32 = htonl((uint32_t) strlen(name)); + WRITE_ALL_ERRCHK(sock, &tmp32, sizeof(tmp32), err, + "Could not write name length: %s", strerror(errno)); + WRITE_ALL_ERRCHK(sock, name, strlen(name), err, + "Could not write name:: %s", strerror(errno)); + READ_ALL_ERRCHK(sock, &size, sizeof(size), err, + "Could not read size: %s", strerror(errno)); size = ntohll(size); uint16_t flags; - READ_ALL_ERRCHK(sock, &flags, sizeof(uint16_t), err, "Could not read flags: %s", strerror(errno)); + READ_ALL_ERRCHK(sock, &flags, sizeof(uint16_t), err, + "Could not read flags: %s", strerror(errno)); flags = ntohs(flags); *serverflags = flags; - READ_ALL_ERRCHK(sock, buf, 124, err, "Could not read reserved zeroes: %s", strerror(errno)); + READ_ALL_ERRCHK(sock, buf, 124, err, + "Could not read reserved zeroes: %s", strerror(errno)); goto end; err: close(sock); - sock=-1; + sock = -1; end: return sock; } -int setup_unix_connection(gchar* unixsock, gchar* name, CONNECTION_TYPE ctype, int* serverflags) { +int setup_unix_connection(gchar * unixsock, gchar * name, CONNECTION_TYPE ctype, + int *serverflags) +{ struct sockaddr_un addr; int sock; sock = 0; - if(ctype<CONNECTION_TYPE_CONNECT) { + if (ctype < CONNECTION_TYPE_CONNECT) { goto end; } - if((sock=socket(AF_UNIX, SOCK_STREAM, 0))<0) { + if ((sock = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) { strncpy(errstr, strerror(errno), errstr_len); goto err; } @@ -419,7 +446,7 @@ int setup_unix_connection(gchar* unixsock, gchar* name, CONNECTION_TYPE ctype, i memset(&addr, 0, sizeof(struct sockaddr_un)); addr.sun_family = AF_UNIX; strncpy(addr.sun_path, unixsock, sizeof addr.sun_path); - if(connect(sock, (struct sockaddr*)&addr, sizeof(addr))<0) { + if (connect(sock, (struct sockaddr *)&addr, sizeof(addr)) < 0) { strncpy(errstr, strerror(errno), errstr_len); goto err_open; } @@ -428,185 +455,226 @@ int setup_unix_connection(gchar* unixsock, gchar* name, CONNECTION_TYPE ctype, i err_open: close(sock); err: - sock=-1; + sock = -1; end: return sock; } -int setup_inet_connection(gchar *hostname, int port, gchar* name, CONNECTION_TYPE ctype, int* serverflags) { +int setup_inet_connection(gchar * hostname, int port, gchar * name, + CONNECTION_TYPE ctype, int *serverflags) +{ int sock; struct hostent *host; struct sockaddr_in addr; - sock=0; - if(ctype<CONNECTION_TYPE_CONNECT) + sock = 0; + if (ctype < CONNECTION_TYPE_CONNECT) goto end; - if((sock=socket(PF_INET, SOCK_STREAM, IPPROTO_TCP))<0) { + if ((sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) { strncpy(errstr, strerror(errno), errstr_len); goto err; } setmysockopt(sock); - if(!(host=gethostbyname(hostname))) { + if (!(host = gethostbyname(hostname))) { strncpy(errstr, hstrerror(h_errno), errstr_len); goto err_open; } - addr.sin_family=AF_INET; - addr.sin_port=htons(port); - addr.sin_addr.s_addr=*((int *) host->h_addr); - if((connect(sock, (struct sockaddr *)&addr, sizeof(addr))<0)) { + addr.sin_family = AF_INET; + addr.sin_port = htons(port); + addr.sin_addr.s_addr = *((int *)host->h_addr); + if ((connect(sock, (struct sockaddr *)&addr, sizeof(addr)) < 0)) { strncpy(errstr, strerror(errno), errstr_len); goto err_open; } - sock=setup_connection_common(sock, name, ctype, serverflags); + sock = setup_connection_common(sock, name, ctype, serverflags); goto end; err_open: close(sock); err: - sock=-1; + sock = -1; end: return sock; } -int setup_connection(gchar* hostname, gchar* unixsock, int port, gchar* name, CONNECTION_TYPE ctype, int* serverflags) { - if(hostname != NULL) { - return setup_inet_connection(hostname, port, name, ctype, serverflags); - } else if(unixsock != NULL) { - return setup_unix_connection(unixsock, name, ctype, serverflags); +int setup_connection(gchar * hostname, gchar * unixsock, int port, gchar * name, + CONNECTION_TYPE ctype, int *serverflags) +{ + if (hostname != NULL) { + return setup_inet_connection(hostname, port, name, ctype, + serverflags); + } else if (unixsock != NULL) { + return setup_unix_connection(unixsock, name, ctype, + serverflags); } else { g_error("need a hostname or a unix domain socket!"); return -1; } } -int close_connection(int sock, CLOSE_TYPE type) { +int close_connection(int sock, CLOSE_TYPE type) +{ struct nbd_request req; - u64 counter=0; - - switch(type) { - case CONNECTION_CLOSE_PROPERLY: - req.magic=htonl(NBD_REQUEST_MAGIC); - req.type=htonl(NBD_CMD_DISC); - memcpy(&(req.handle), &(counter), sizeof(counter)); - counter++; - req.from=0; - req.len=0; - if(write(sock, &req, sizeof(req))<0) { - snprintf(errstr, errstr_len, "Could not write to socket: %s", strerror(errno)); - return -1; - } - case CONNECTION_CLOSE_FAST: - if(close(sock)<0) { - snprintf(errstr, errstr_len, "Could not close socket: %s", strerror(errno)); - return -1; - } - break; - default: - g_critical("Your compiler is on crack!"); /* or I am buggy */ + u64 counter = 0; + + switch (type) { + case CONNECTION_CLOSE_PROPERLY: + req.magic = htonl(NBD_REQUEST_MAGIC); + req.type = htonl(NBD_CMD_DISC); + memcpy(&(req.handle), &(counter), sizeof(counter)); + counter++; + req.from = 0; + req.len = 0; + if (write(sock, &req, sizeof(req)) < 0) { + snprintf(errstr, errstr_len, + "Could not write to socket: %s", + strerror(errno)); + return -1; + } + case CONNECTION_CLOSE_FAST: + if (close(sock) < 0) { + snprintf(errstr, errstr_len, + "Could not close socket: %s", strerror(errno)); return -1; + } + break; + default: + g_critical("Your compiler is on crack!"); /* or I am buggy */ + return -1; } return 0; } -int read_packet_check_header(int sock, size_t datasize, long long int curhandle) { +int read_packet_check_header(int sock, size_t datasize, long long int curhandle) +{ struct nbd_reply rep; - int retval=0; + int retval = 0; char buf[datasize]; - READ_ALL_ERR_RT(sock, &rep, sizeof(rep), end, -1, "Could not read reply header: %s", strerror(errno)); - rep.magic=ntohl(rep.magic); - rep.error=ntohl(rep.error); - if(rep.magic!=NBD_REPLY_MAGIC) { - snprintf(errstr, errstr_len, "Received package with incorrect reply_magic. Index of sent packages is %lld (0x%llX), received handle is %lld (0x%llX). Received magic 0x%lX, expected 0x%lX", (long long int)curhandle, (long long unsigned int)curhandle, (long long int)*((u64*)rep.handle), (long long unsigned int)*((u64*)rep.handle), (long unsigned int)rep.magic, (long unsigned int)NBD_REPLY_MAGIC); - retval=-1; + READ_ALL_ERR_RT(sock, &rep, sizeof(rep), end, -1, + "Could not read reply header: %s", strerror(errno)); + rep.magic = ntohl(rep.magic); + rep.error = ntohl(rep.error); + if (rep.magic != NBD_REPLY_MAGIC) { + snprintf(errstr, errstr_len, + "Received package with incorrect reply_magic. Index of sent packages is %lld (0x%llX), received handle is %lld (0x%llX). Received magic 0x%lX, expected 0x%lX", + (long long int)curhandle, + (long long unsigned int)curhandle, + (long long int)*((u64 *) rep.handle), + (long long unsigned int)*((u64 *) rep.handle), + (long unsigned int)rep.magic, + (long unsigned int)NBD_REPLY_MAGIC); + retval = -1; goto end; } - if(rep.error) { - snprintf(errstr, errstr_len, "Received error from server: %ld (0x%lX). Handle is %lld (0x%llX).", (long int)rep.error, (long unsigned int)rep.error, (long long int)(*((u64*)rep.handle)), (long long unsigned int)*((u64*)rep.handle)); - retval=-2; + if (rep.error) { + snprintf(errstr, errstr_len, + "Received error from server: %ld (0x%lX). Handle is %lld (0x%llX).", + (long int)rep.error, (long unsigned int)rep.error, + (long long int)(*((u64 *) rep.handle)), + (long long unsigned int)*((u64 *) rep.handle)); + retval = -2; goto end; } if (datasize) - READ_ALL_ERR_RT(sock, &buf, datasize, end, -1, "Could not read data: %s", strerror(errno)); + READ_ALL_ERR_RT(sock, &buf, datasize, end, -1, + "Could not read data: %s", strerror(errno)); end: return retval; } -int oversize_test(gchar* hostname, gchar* unixsock, int port, char* name, int sock, - char sock_is_open, char close_sock, int testflags) { - int retval=0; +int oversize_test(gchar * hostname, gchar * unixsock, int port, char *name, + int sock, char sock_is_open, char close_sock, int testflags) +{ + int retval = 0; struct nbd_request req; struct nbd_reply rep; - int i=0; + int i = 0; int serverflags = 0; pid_t G_GNUC_UNUSED mypid = getpid(); - char buf[((1024*1024)+sizeof(struct nbd_request)/2)<<1]; + char buf[((1024 * 1024) + sizeof(struct nbd_request) / 2) << 1]; bool got_err; /* This should work */ - if(!sock_is_open) { - if((sock=setup_connection(hostname, unixsock, port, name, CONNECTION_TYPE_FULL, &serverflags))<0) { + if (!sock_is_open) { + if ((sock = + setup_connection(hostname, unixsock, port, name, + CONNECTION_TYPE_FULL, + &serverflags)) < 0) { g_warning("Could not open socket: %s", errstr); - retval=-1; + retval = -1; goto err; } } - req.magic=htonl(NBD_REQUEST_MAGIC); - req.type=htonl(NBD_CMD_READ); - req.len=htonl(1024*1024); - memcpy(&(req.handle),&i,sizeof(i)); - req.from=htonll(i); - WRITE_ALL_ERR_RT(sock, &req, sizeof(req), err, -1, "Could not write request: %s", strerror(errno)); + req.magic = htonl(NBD_REQUEST_MAGIC); + req.type = htonl(NBD_CMD_READ); + req.len = htonl(1024 * 1024); + memcpy(&(req.handle), &i, sizeof(i)); + req.from = htonll(i); + WRITE_ALL_ERR_RT(sock, &req, sizeof(req), err, -1, + "Could not write request: %s", strerror(errno)); printf("%d: testing oversized request: %d: ", getpid(), ntohl(req.len)); - READ_ALL_ERR_RT(sock, &rep, sizeof(struct nbd_reply), err, -1, "Could not read reply header: %s", strerror(errno)); - READ_ALL_ERR_RT(sock, &buf, ntohl(req.len), err, -1, "Could not read data: %s", strerror(errno)); - if(rep.error) { - snprintf(errstr, errstr_len, "Received unexpected error: %d", rep.error); - retval=-1; + READ_ALL_ERR_RT(sock, &rep, sizeof(struct nbd_reply), err, -1, + "Could not read reply header: %s", strerror(errno)); + READ_ALL_ERR_RT(sock, &buf, ntohl(req.len), err, -1, + "Could not read data: %s", strerror(errno)); + if (rep.error) { + snprintf(errstr, errstr_len, "Received unexpected error: %d", + rep.error); + retval = -1; goto err; } else { printf("OK\n"); } /* This probably should not work */ - i++; req.from=htonll(i); + i++; + req.from = htonll(i); req.len = htonl(ntohl(req.len) + sizeof(struct nbd_request) / 2); - WRITE_ALL_ERR_RT(sock, &req, sizeof(req), err, -1, "Could not write request: %s", strerror(errno)); + WRITE_ALL_ERR_RT(sock, &req, sizeof(req), err, -1, + "Could not write request: %s", strerror(errno)); printf("%d: testing oversized request: %d: ", getpid(), ntohl(req.len)); - READ_ALL_ERR_RT(sock, &rep, sizeof(struct nbd_reply), err, -1, "Could not read reply header: %s", strerror(errno)); - READ_ALL_ERR_RT(sock, &buf, ntohl(req.len), err, -1, "Could not read data: %s", strerror(errno)); - if(rep.error) { + READ_ALL_ERR_RT(sock, &rep, sizeof(struct nbd_reply), err, -1, + "Could not read reply header: %s", strerror(errno)); + READ_ALL_ERR_RT(sock, &buf, ntohl(req.len), err, -1, + "Could not read data: %s", strerror(errno)); + if (rep.error) { printf("Received expected error\n"); - got_err=true; + got_err = true; } else { printf("OK\n"); - got_err=false; + got_err = false; } /* ... unless this works, too */ - i++; req.from=htonll(i); + i++; + req.from = htonll(i); req.len = htonl(ntohl(req.len) << 1); - WRITE_ALL_ERR_RT(sock, &req, sizeof(req), err, -1, "Could not write request: %s", strerror(errno)); + WRITE_ALL_ERR_RT(sock, &req, sizeof(req), err, -1, + "Could not write request: %s", strerror(errno)); printf("%d: testing oversized request: %d: ", getpid(), ntohl(req.len)); - READ_ALL_ERR_RT(sock, &rep, sizeof(struct nbd_reply), err, -1, "Could not read reply header: %s", strerror(errno)); - READ_ALL_ERR_RT(sock, &buf, ntohl(req.len), err, -1, "Could not read data: %s", strerror(errno)); - if(rep.error) { + READ_ALL_ERR_RT(sock, &rep, sizeof(struct nbd_reply), err, -1, + "Could not read reply header: %s", strerror(errno)); + READ_ALL_ERR_RT(sock, &buf, ntohl(req.len), err, -1, + "Could not read data: %s", strerror(errno)); + if (rep.error) { printf("error\n"); } else { printf("OK\n"); } - if((rep.error && !got_err) || (!rep.error && got_err)) { + if ((rep.error && !got_err) || (!rep.error && got_err)) { printf("Received unexpected error\n"); - retval=-1; + retval = -1; } - err: +err: return retval; } -int throughput_test(gchar* hostname, gchar* unixsock, int port, char* name, int sock, - char sock_is_open, char close_sock, int testflags) { +int throughput_test(gchar * hostname, gchar * unixsock, int port, char *name, + int sock, char sock_is_open, char close_sock, int testflags) +{ long long int i; char writebuf[1024]; struct nbd_request req; - int requests=0; + int requests = 0; fd_set set; struct timeval tv; struct timeval start; @@ -614,65 +682,75 @@ int throughput_test(gchar* hostname, gchar* unixsock, int port, char* name, int double timespan; double speed; char speedchar[2] = { '\0', '\0' }; - int retval=0; + int retval = 0; int serverflags = 0; - signed int do_write=TRUE; + signed int do_write = TRUE; pid_t mypid = getpid(); - if (!(testflags & TEST_WRITE)) testflags &= ~TEST_FLUSH; - memset (writebuf, 'X', 1024); - size=0; - if(!sock_is_open) { - if((sock=setup_connection(hostname, unixsock, port, name, CONNECTION_TYPE_FULL, &serverflags))<0) { + memset(writebuf, 'X', 1024); + size = 0; + if (!sock_is_open) { + if ((sock = + setup_connection(hostname, unixsock, port, name, + CONNECTION_TYPE_FULL, + &serverflags)) < 0) { g_warning("Could not open socket: %s", errstr); - retval=-1; + retval = -1; goto err; } } - if ((testflags & TEST_FLUSH) && ((serverflags & (NBD_FLAG_SEND_FLUSH | NBD_FLAG_SEND_FUA)) - != (NBD_FLAG_SEND_FLUSH | NBD_FLAG_SEND_FUA))) { - snprintf(errstr, errstr_len, "Server did not supply flush capability flags"); + if ((testflags & TEST_FLUSH) + && ((serverflags & (NBD_FLAG_SEND_FLUSH | NBD_FLAG_SEND_FUA)) + != (NBD_FLAG_SEND_FLUSH | NBD_FLAG_SEND_FUA))) { + snprintf(errstr, errstr_len, + "Server did not supply flush capability flags"); retval = -1; goto err_open; } - req.magic=htonl(NBD_REQUEST_MAGIC); - req.len=htonl(1024); - if(gettimeofday(&start, NULL)<0) { - retval=-1; - snprintf(errstr, errstr_len, "Could not measure start time: %s", strerror(errno)); + req.magic = htonl(NBD_REQUEST_MAGIC); + req.len = htonl(1024); + if (gettimeofday(&start, NULL) < 0) { + retval = -1; + snprintf(errstr, errstr_len, "Could not measure start time: %s", + strerror(errno)); goto err_open; } int printer = 0; - for(i=0;i+1024<=size;i+=1024) { - if(do_write) { - int sendfua = (testflags & TEST_FLUSH) && (((i>>10) & 15) == 3); - int sendflush = (testflags & TEST_FLUSH) && (((i>>10) & 15) == 11); - req.type=htonl((testflags & TEST_WRITE)?NBD_CMD_WRITE:NBD_CMD_READ); + for (i = 0; i + 1024 <= size; i += 1024) { + if (do_write) { + int sendfua = (testflags & TEST_FLUSH) + && (((i >> 10) & 15) == 3); + int sendflush = (testflags & TEST_FLUSH) + && (((i >> 10) & 15) == 11); + req.type = + htonl((testflags & TEST_WRITE) ? NBD_CMD_WRITE : + NBD_CMD_READ); if (sendfua) - req.type = htonl(NBD_CMD_WRITE | NBD_CMD_FLAG_FUA); - memcpy(&(req.handle),&i,sizeof(i)); - req.from=htonll(i); - if (write_all(sock, &req, sizeof(req)) <0) { - retval=-1; + req.type = + htonl(NBD_CMD_WRITE | NBD_CMD_FLAG_FUA); + memcpy(&(req.handle), &i, sizeof(i)); + req.from = htonll(i); + if (write_all(sock, &req, sizeof(req)) < 0) { + retval = -1; goto err_open; } if (testflags & TEST_WRITE) { - if (write_all(sock, writebuf, 1024) <0) { - retval=-1; + if (write_all(sock, writebuf, 1024) < 0) { + retval = -1; goto err_open; } } ++requests; if (sendflush) { - long long int j = i ^ (1LL<<63); + long long int j = i ^ (1LL << 63); req.type = htonl(NBD_CMD_FLUSH); - memcpy(&(req.handle),&j,sizeof(j)); - req.from=0; - if (write_all(sock, &req, sizeof(req)) <0) { - retval=-1; + memcpy(&(req.handle), &j, sizeof(j)); + req.from = 0; + if (write_all(sock, &req, sizeof(req)) < 0) { + retval = -1; goto err_open; } ++requests; @@ -681,23 +759,28 @@ int throughput_test(gchar* hostname, gchar* unixsock, int port, char* name, int do { FD_ZERO(&set); FD_SET(sock, &set); - tv.tv_sec=0; - tv.tv_usec=0; - select(sock+1, &set, NULL, NULL, &tv); - if(FD_ISSET(sock, &set)) { + tv.tv_sec = 0; + tv.tv_usec = 0; + select(sock + 1, &set, NULL, NULL, &tv); + if (FD_ISSET(sock, &set)) { /* Okay, there's something ready for * reading here */ int rv; - if((rv=read_packet_check_header(sock, (testflags & TEST_WRITE)?0:1024, i))<0) { - if(!(testflags & TEST_EXPECT_ERROR) || rv != -2) { - retval=-1; + if ((rv = + read_packet_check_header(sock, + (testflags & + TEST_WRITE) ? 0 : + 1024, i)) < 0) { + if (!(testflags & TEST_EXPECT_ERROR) + || rv != -2) { + retval = -1; } else { printf("\n"); } goto err_open; } else { - if(testflags & TEST_EXPECT_ERROR) { - retval=-1; + if (testflags & TEST_EXPECT_ERROR) { + retval = -1; goto err_open; } } @@ -708,16 +791,18 @@ int throughput_test(gchar* hostname, gchar* unixsock, int port, char* name, int * passed, whichever comes first*/ FD_ZERO(&set); FD_SET(sock, &set); - tv.tv_sec=1; - tv.tv_usec=0; - do_write=select(sock+1,NULL,&set,NULL,&tv); - if(!do_write) printf("Select finished\n"); - if(do_write<0) { - snprintf(errstr, errstr_len, "select: %s", strerror(errno)); - retval=-1; + tv.tv_sec = 1; + tv.tv_usec = 0; + do_write = select(sock + 1, NULL, &set, NULL, &tv); + if (!do_write) + printf("Select finished\n"); + if (do_write < 0) { + snprintf(errstr, errstr_len, "select: %s", + strerror(errno)); + retval = -1; goto err_open; } - if(!(printer++ % 10)) { + if (!(printer++ % 10)) { printf("%d: Requests: %d \r", (int)mypid, requests); } } @@ -725,43 +810,50 @@ int throughput_test(gchar* hostname, gchar* unixsock, int port, char* name, int do { FD_ZERO(&set); FD_SET(sock, &set); - tv.tv_sec=0; - tv.tv_usec=0; - select(sock+1, &set, NULL, NULL, &tv); - if(FD_ISSET(sock, &set)) { + tv.tv_sec = 0; + tv.tv_usec = 0; + select(sock + 1, &set, NULL, NULL, &tv); + if (FD_ISSET(sock, &set)) { /* Okay, there's something ready for * reading here */ - read_packet_check_header(sock, (testflags & TEST_WRITE)?0:1024, i); + read_packet_check_header(sock, + (testflags & TEST_WRITE) ? 0 : + 1024, i); --requests; } - if(!(printer++ % 10)) { + if (!(printer++ % 10)) { printf("%d: Requests: %d \r", (int)mypid, requests); } } while (requests); printf("%d: Requests: %d \n", (int)mypid, requests); - if(gettimeofday(&stop, NULL)<0) { - retval=-1; - snprintf(errstr, errstr_len, "Could not measure end time: %s", strerror(errno)); + if (gettimeofday(&stop, NULL) < 0) { + retval = -1; + snprintf(errstr, errstr_len, "Could not measure end time: %s", + strerror(errno)); goto err_open; } - timespan=timeval_diff_to_double(&stop, &start); - speed=size/timespan; - if(speed>1024) { - speed=speed/1024.0; - speedchar[0]='K'; + timespan = timeval_diff_to_double(&stop, &start); + speed = size / timespan; + if (speed > 1024) { + speed = speed / 1024.0; + speedchar[0] = 'K'; } - if(speed>1024) { - speed=speed/1024.0; - speedchar[0]='M'; + if (speed > 1024) { + speed = speed / 1024.0; + speedchar[0] = 'M'; } - if(speed>1024) { - speed=speed/1024.0; - speedchar[0]='G'; + if (speed > 1024) { + speed = speed / 1024.0; + speedchar[0] = 'G'; } - g_message("%d: Throughput %s test (%s flushes) complete. Took %.3f seconds to complete, %.3f%sib/s", (int)getpid(), (testflags & TEST_WRITE)?"write":"read", (testflags & TEST_FLUSH)?"with":"without", timespan, speed, speedchar); + g_message + ("%d: Throughput %s test (%s flushes) complete. Took %.3f seconds to complete, %.3f%sib/s", + (int)getpid(), (testflags & TEST_WRITE) ? "write" : "read", + (testflags & TEST_FLUSH) ? "with" : "without", timespan, speed, + speedchar); err_open: - if(close_sock) { + if (close_sock) { close_connection(sock, CONNECTION_CLOSE_PROPERLY); } err: @@ -773,73 +865,76 @@ err: * only on handle and blknum. The first word is blknum, and the second handle, for ease * of understanding. Things with handle 0 are blank. */ -static inline void makebuf(char *buf, uint64_t seq, uint64_t blknum) { - uint64_t x = ((uint64_t)blknum) ^ (seq << 32) ^ (seq >> 32); - uint64_t* p = (uint64_t*)buf; +static inline void makebuf(char *buf, uint64_t seq, uint64_t blknum) +{ + uint64_t x = ((uint64_t) blknum) ^ (seq << 32) ^ (seq >> 32); + uint64_t *p = (uint64_t *) buf; int i; if (!seq) { bzero(buf, 512); return; } - for (i = 0; i<512/sizeof(uint64_t); i++) { + for (i = 0; i < 512 / sizeof(uint64_t); i++) { int s; *(p++) = x; - x+=0xFEEDA1ECDEADBEEFULL+i+(((uint64_t)i)<<56); + x += 0xFEEDA1ECDEADBEEFULL + i + (((uint64_t) i) << 56); s = x & 63; - x = x ^ (x<<s) ^ (x>>(64-s)) ^ 0xAA55AA55AA55AA55ULL ^ seq; + x = x ^ (x << s) ^ (x >> (64 - s)) ^ 0xAA55AA55AA55AA55ULL ^ + seq; } } - -static inline int checkbuf(char *buf, uint64_t seq, uint64_t blknum) { - uint64_t cmp[64]; // 512/8 = 64 + +static inline int checkbuf(char *buf, uint64_t seq, uint64_t blknum) +{ + uint64_t cmp[64]; // 512/8 = 64 makebuf((char *)cmp, seq, blknum); - return memcmp(cmp, buf, 512)?-1:0; + return memcmp(cmp, buf, 512) ? -1 : 0; } -static inline void dumpcommand(char * text, uint32_t command) +static inline void dumpcommand(char *text, uint32_t command) { #ifdef DEBUG_COMMANDS - command=ntohl(command); - char * ctext; + command = ntohl(command); + char *ctext; switch (command & NBD_CMD_MASK_COMMAND) { case NBD_CMD_READ: - ctext="NBD_CMD_READ"; + ctext = "NBD_CMD_READ"; break; case NBD_CMD_WRITE: - ctext="NBD_CMD_WRITE"; + ctext = "NBD_CMD_WRITE"; break; case NBD_CMD_DISC: - ctext="NBD_CMD_DISC"; + ctext = "NBD_CMD_DISC"; break; case NBD_CMD_FLUSH: - ctext="NBD_CMD_FLUSH"; + ctext = "NBD_CMD_FLUSH"; break; default: - ctext="UNKNOWN"; + ctext = "UNKNOWN"; break; } printf("%s: %s [%s] (0x%08x)\n", text, - ctext, - (command & NBD_CMD_FLAG_FUA)?"FUA":"NONE", - command); + ctext, (command & NBD_CMD_FLAG_FUA) ? "FUA" : "NONE", command); #endif } /* return an unused handle */ -uint64_t getrandomhandle(GHashTable *phash) { +uint64_t getrandomhandle(GHashTable * phash) +{ uint64_t handle = 0; int i; do { /* RAND_MAX may be as low as 2^15 */ - for (i= 1 ; i<=5; i++) - handle ^= random() ^ (handle << 15); + for (i = 1; i <= 5; i++) + handle ^= random() ^ (handle << 15); } while (g_hash_table_lookup(phash, &handle)); return handle; } -int integrity_test(gchar* hostname, gchar* unixsock, int port, char* name, int sock, - char sock_is_open, char close_sock, int testflags) { +int integrity_test(gchar * hostname, gchar * unixsock, int port, char *name, + int sock, char sock_is_open, char close_sock, int testflags) +{ struct nbd_reply rep; fd_set rset; fd_set wset; @@ -849,28 +944,31 @@ int integrity_test(gchar* hostname, gchar* unixsock, int port, char* name, int s double timespan; double speed; char speedchar[2] = { '\0', '\0' }; - int retval=-1; + int retval = -1; int serverflags = 0; pid_t G_GNUC_UNUSED mypid = getpid(); int blkhashfd = -1; - char *blkhashname=NULL; + char *blkhashname = NULL; struct blkitem *blkhash = NULL; - int logfd=-1; - uint64_t seq=1; - uint64_t processed=0; - uint64_t printer=0; - uint64_t xfer=0; + int logfd = -1; + uint64_t seq = 1; + uint64_t processed = 0; + uint64_t printer = 0; + uint64_t xfer = 0; int readtransactionfile = 1; int blocked = 0; - struct rclist txqueue={NULL, NULL, 0}; - struct rclist inflight={NULL, NULL, 0}; - struct chunklist txbuf={NULL, NULL, 0}; + struct rclist txqueue = { NULL, NULL, 0 }; + struct rclist inflight = { NULL, NULL, 0 }; + struct chunklist txbuf = { NULL, NULL, 0 }; GHashTable *handlehash = g_hash_table_new(g_int64_hash, g_int64_equal); - size=0; - if(!sock_is_open) { - if((sock=setup_connection(hostname, unixsock, port, name, CONNECTION_TYPE_FULL, &serverflags))<0) { + size = 0; + if (!sock_is_open) { + if ((sock = + setup_connection(hostname, unixsock, port, name, + CONNECTION_TYPE_FULL, + &serverflags)) < 0) { g_warning("Could not open socket: %s", errstr); goto err; } @@ -878,19 +976,20 @@ int integrity_test(gchar* hostname, gchar* unixsock, int port, char* name, int s if ((serverflags & (NBD_FLAG_SEND_FLUSH | NBD_FLAG_SEND_FUA)) != (NBD_FLAG_SEND_FLUSH | NBD_FLAG_SEND_FUA)) - g_warning("Server flags do not support FLUSH and FUA - these may error"); + g_warning + ("Server flags do not support FLUSH and FUA - these may error"); #ifdef HAVE_MKSTEMP - blkhashname=strdup("/tmp/blkarray-XXXXXX"); + blkhashname = strdup("/tmp/blkarray-XXXXXX"); if (!blkhashname || (-1 == (blkhashfd = mkstemp(blkhashname)))) { g_warning("Could not open temp file: %s", strerror(errno)); goto err; } #else /* use tmpnam here to avoid further feature test nightmare */ - if (-1 == (blkhashfd = open(blkhashname=strdup(tmpnam(NULL)), + if (-1 == (blkhashfd = open(blkhashname = strdup(tmpnam(NULL)), O_CREAT | O_RDWR, - S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH))) { + S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH))) { g_warning("Could not open temp file: %s", strerror(errno)); goto err; } @@ -901,7 +1000,9 @@ int integrity_test(gchar* hostname, gchar* unixsock, int port, char* name, int s goto err; } - if (-1 == lseek(blkhashfd, (off_t)((size>>9)*sizeof(struct blkitem)), SEEK_SET)) { + if (-1 == + lseek(blkhashfd, (off_t) ((size >> 9) * sizeof(struct blkitem)), + SEEK_SET)) { g_warning("Could not llseek temp file: %s", strerror(errno)); goto err; } @@ -912,36 +1013,35 @@ int integrity_test(gchar* hostname, gchar* unixsock, int port, char* name, int s } if (NULL == (blkhash = mmap(NULL, - (size>>9)*sizeof(struct blkitem), + (size >> 9) * sizeof(struct blkitem), PROT_READ | PROT_WRITE, - MAP_SHARED, - blkhashfd, - 0))) { + MAP_SHARED, blkhashfd, 0))) { g_warning("Could not mmap temp file: %s", strerror(errno)); goto err; } - if (-1 == (logfd = open(transactionlog, O_RDONLY))) - { + if (-1 == (logfd = open(transactionlog, O_RDONLY))) { g_warning("Could open log file: %s", strerror(errno)); goto err; } - - if(gettimeofday(&start, NULL)<0) { - snprintf(errstr, errstr_len, "Could not measure start time: %s", strerror(errno)); + + if (gettimeofday(&start, NULL) < 0) { + snprintf(errstr, errstr_len, "Could not measure start time: %s", + strerror(errno)); goto err_open; } - while (readtransactionfile || txqueue.numitems || txbuf.numitems || inflight.numitems) { + while (readtransactionfile || txqueue.numitems || txbuf.numitems + || inflight.numitems) { int ret; uint32_t magic; - uint32_t command; - uint64_t from; - uint32_t len; - struct reqcontext * prc; + uint32_t command; + uint64_t from; + uint32_t len; + struct reqcontext *prc; - *errstr=0; + *errstr = 0; FD_ZERO(&wset); FD_ZERO(&rset); @@ -951,13 +1051,16 @@ int integrity_test(gchar* hostname, gchar* unixsock, int port, char* name, int s FD_SET(sock, &wset); if (inflight.numitems) FD_SET(sock, &rset); - tv.tv_sec=5; - tv.tv_usec=0; - ret = select(1+((sock>logfd)?sock:logfd), &rset, &wset, NULL, &tv); + tv.tv_sec = 5; + tv.tv_usec = 0; + ret = + select(1 + ((sock > logfd) ? sock : logfd), &rset, &wset, + NULL, &tv); if (ret == 0) { - snprintf(errstr, errstr_len, "Timeout reading from socket"); + snprintf(errstr, errstr_len, + "Timeout reading from socket"); goto err_open; - } else if (ret<0) { + } else if (ret < 0) { g_warning("Could not mmap temp file: %s", errstr); goto err; } @@ -965,7 +1068,7 @@ int integrity_test(gchar* hostname, gchar* unixsock, int port, char* name, int s /* Get a command from the transaction log */ if (FD_ISSET(logfd, &rset)) { - + /* Read a request or reply from the transaction file */ READ_ALL_ERRCHK(logfd, &magic, @@ -976,67 +1079,77 @@ int integrity_test(gchar* hostname, gchar* unixsock, int port, char* name, int s magic = ntohl(magic); switch (magic) { case NBD_REQUEST_MAGIC: - if (NULL == (prc = calloc(1, sizeof(struct reqcontext)))) { - snprintf(errstr, errstr_len, "Could not allocate request"); + if (NULL == + (prc = + calloc(1, sizeof(struct reqcontext)))) { + snprintf(errstr, errstr_len, + "Could not allocate request"); goto err_open; } READ_ALL_ERRCHK(logfd, - sizeof(magic)+(char *)&(prc->req), - sizeof(struct nbd_request)-sizeof(magic), - err_open, + sizeof(magic) + + (char *)&(prc->req), + sizeof(struct nbd_request) - + sizeof(magic), err_open, "Could not read transaction log: %s", strerror(errno)); prc->req.magic = htonl(NBD_REQUEST_MAGIC); memcpy(prc->orighandle, prc->req.handle, 8); - prc->seq=seq++; - if ((ntohl(prc->req.type) & NBD_CMD_MASK_COMMAND) == NBD_CMD_DISC) { + prc->seq = seq++; + if ((ntohl(prc->req.type) & + NBD_CMD_MASK_COMMAND) == NBD_CMD_DISC) { /* no more to read; don't enqueue as no reply * we will disconnect manually at the end */ readtransactionfile = 0; - free (prc); + free(prc); } else { - dumpcommand("Enqueuing command", prc->req.type); + dumpcommand("Enqueuing command", + prc->req.type); rclist_addtail(&txqueue, prc); } prc = NULL; break; case NBD_REPLY_MAGIC: READ_ALL_ERRCHK(logfd, - sizeof(magic)+(char *)(&rep), - sizeof(struct nbd_reply)-sizeof(magic), - err_open, + sizeof(magic) + (char *)(&rep), + sizeof(struct nbd_reply) - + sizeof(magic), err_open, "Could not read transaction log: %s", strerror(errno)); if (rep.error) { - snprintf(errstr, errstr_len, "Transaction log file contained errored transaction"); + snprintf(errstr, errstr_len, + "Transaction log file contained errored transaction"); goto err_open; } - + /* We do not need to consume data on a read reply as there is * none in the log */ break; default: - snprintf(errstr, errstr_len, "Could not measure start time: %08x", magic); + snprintf(errstr, errstr_len, + "Could not measure start time: %08x", + magic); goto err_open; } } /* See if we have a write we can do */ - if (FD_ISSET(sock, &wset)) - { + if (FD_ISSET(sock, &wset)) { if ((!(txqueue.head) && !(txbuf.head)) || blocked) - g_warning("Socket write FD set but we shouldn't have been interested"); + g_warning + ("Socket write FD set but we shouldn't have been interested"); /* If there is no buffered data, generate some */ - if (!blocked && !(txbuf.head) && (NULL != (prc = txqueue.head))) - { + if (!blocked && !(txbuf.head) + && (NULL != (prc = txqueue.head))) { if (ntohl(prc->req.magic) != NBD_REQUEST_MAGIC) { - g_warning("Asked to write a request without a magic number"); + g_warning + ("Asked to write a request without a magic number"); goto err_open; } - + command = ntohl(prc->req.type); from = ntohll(prc->req.from); len = ntohl(prc->req.len); @@ -1046,24 +1159,31 @@ int integrity_test(gchar* hostname, gchar* unixsock, int port, char* name, int s * command is a write, and there is an inflight read or write, then * we need to leave the command alone and signal that we are blocked */ - - if (!looseordering) - { + + if (!looseordering) { uint64_t cfrom; uint32_t clen; cfrom = from; clen = len; while (clen > 0) { - uint64_t blknum = cfrom>>9; - if (cfrom>=size) { - snprintf(errstr, errstr_len, "offset %llx beyond size %llx", - (long long int) cfrom, (long long int)size); + uint64_t blknum = cfrom >> 9; + if (cfrom >= size) { + snprintf(errstr, + errstr_len, + "offset %llx beyond size %llx", + (long long int) + cfrom, + (long long int) + size); goto err_open; } if (blkhash[blknum].inflightw || - (blkhash[blknum].inflightr && - ((command & NBD_CMD_MASK_COMMAND)==NBD_CMD_WRITE))) { - blocked=1; + (blkhash[blknum].inflightr + && + ((command & + NBD_CMD_MASK_COMMAND) == + NBD_CMD_WRITE))) { + blocked = 1; break; } cfrom += 512; @@ -1076,21 +1196,29 @@ int integrity_test(gchar* hostname, gchar* unixsock, int port, char* name, int s rclist_unlink(&txqueue, prc); rclist_addtail(&inflight, prc); - + dumpcommand("Sending command", prc->req.type); /* we rewrite the handle as they otherwise may not be unique */ - *((uint64_t*)(prc->req.handle))=getrandomhandle(handlehash); - g_hash_table_insert(handlehash, prc->req.handle, prc); - addbuffer(&txbuf, &(prc->req), sizeof(struct nbd_request)); + *((uint64_t *) (prc->req.handle)) = + getrandomhandle(handlehash); + g_hash_table_insert(handlehash, prc->req.handle, + prc); + addbuffer(&txbuf, &(prc->req), + sizeof(struct nbd_request)); switch (command & NBD_CMD_MASK_COMMAND) { case NBD_CMD_WRITE: - xfer+=len; - while (len > 0) { - uint64_t blknum = from>>9; + xfer += len; + while (len > 0) { + uint64_t blknum = from >> 9; char dbuf[512]; - if (from>=size) { - snprintf(errstr, errstr_len, "offset %llx beyond size %llx", - (long long int) from, (long long int)size); + if (from >= size) { + snprintf(errstr, + errstr_len, + "offset %llx beyond size %llx", + (long long int) + from, + (long long int) + size); goto err_open; } (blkhash[blknum].inflightw)++; @@ -1102,12 +1230,17 @@ int integrity_test(gchar* hostname, gchar* unixsock, int port, char* name, int s } break; case NBD_CMD_READ: - xfer+=len; - while (len > 0) { - uint64_t blknum = from>>9; - if (from>=size) { - snprintf(errstr, errstr_len, "offset %llx beyond size %llx", - (long long int) from, (long long int)size); + xfer += len; + while (len > 0) { + uint64_t blknum = from >> 9; + if (from >= size) { + snprintf(errstr, + errstr_len, + "offset %llx beyond size %llx", + (long long int) + from, + (long long int) + size); goto err_open; } (blkhash[blknum].inflightr)++; @@ -1119,25 +1252,29 @@ int integrity_test(gchar* hostname, gchar* unixsock, int port, char* name, int s case NBD_CMD_FLUSH: break; default: - snprintf(errstr, errstr_len, "Incomprehensible command: %08x", command); + snprintf(errstr, errstr_len, + "Incomprehensible command: %08x", + command); goto err_open; break; } - + prc = NULL; } - skipdequeue: +skipdequeue: /* there should be some now */ - if (writebuffer(sock, &txbuf)<0) { - snprintf(errstr, errstr_len, "Failed to write to socket buffer: %s", strerror(errno)); + if (writebuffer(sock, &txbuf) < 0) { + snprintf(errstr, errstr_len, + "Failed to write to socket buffer: %s", + strerror(errno)); goto err_open; } - + } /* See if there is a reply to be processed from the socket */ - if(FD_ISSET(sock, &rset)) { + if (FD_ISSET(sock, &rset)) { /* Okay, there's something ready for * reading here */ @@ -1147,47 +1284,60 @@ int integrity_test(gchar* hostname, gchar* unixsock, int port, char* name, int s err_open, "Could not read from server socket: %s", strerror(errno)); - + if (rep.magic != htonl(NBD_REPLY_MAGIC)) { - snprintf(errstr, errstr_len, "Bad magic from server"); + snprintf(errstr, errstr_len, + "Bad magic from server"); goto err_open; } - + if (rep.error) { - snprintf(errstr, errstr_len, "Server errored a transaction"); + snprintf(errstr, errstr_len, + "Server errored a transaction"); goto err_open; } - + uint64_t handle; - memcpy(&handle,rep.handle,8); + memcpy(&handle, rep.handle, 8); prc = g_hash_table_lookup(handlehash, &handle); if (!prc) { - snprintf(errstr, errstr_len, "Unrecognised handle in reply: 0x%llX", *(long long unsigned int*)(rep.handle)); + snprintf(errstr, errstr_len, + "Unrecognised handle in reply: 0x%llX", + *(long long unsigned int *)(rep. + handle)); goto err_open; } if (!g_hash_table_remove(handlehash, &handle)) { - snprintf(errstr, errstr_len, "Could not remove handle from hash: 0x%llX", *(long long unsigned int*)(rep.handle)); + snprintf(errstr, errstr_len, + "Could not remove handle from hash: 0x%llX", + *(long long unsigned int *)(rep. + handle)); goto err_open; } if (prc->req.magic != htonl(NBD_REQUEST_MAGIC)) { - snprintf(errstr, errstr_len, "Bad magic in inflight data: %08x", prc->req.magic); + snprintf(errstr, errstr_len, + "Bad magic in inflight data: %08x", + prc->req.magic); goto err_open; } - - dumpcommand("Processing reply to command", prc->req.type); + + dumpcommand("Processing reply to command", + prc->req.type); command = ntohl(prc->req.type); from = ntohll(prc->req.from); len = ntohl(prc->req.len); - + switch (command & NBD_CMD_MASK_COMMAND) { case NBD_CMD_READ: - while (len > 0) { - uint64_t blknum = from>>9; + while (len > 0) { + uint64_t blknum = from >> 9; char dbuf[512]; - if (from>=size) { - snprintf(errstr, errstr_len, "offset %llx beyond size %llx", - (long long int) from, (long long int)size); + if (from >= size) { + snprintf(errstr, errstr_len, + "offset %llx beyond size %llx", + (long long int)from, + (long long int)size); goto err_open; } READ_ALL_ERRCHK(sock, @@ -1196,36 +1346,44 @@ int integrity_test(gchar* hostname, gchar* unixsock, int port, char* name, int s err_open, "Could not read data: %s", strerror(errno)); - if (--(blkhash[blknum].inflightr) <0 ) { - snprintf(errstr, errstr_len, "Received a read reply for offset %llx when not in flight", - (long long int) from); + if (--(blkhash[blknum].inflightr) < 0) { + snprintf(errstr, errstr_len, + "Received a read reply for offset %llx when not in flight", + (long long int)from); goto err_open; } /* work out what we was written */ - if (checkbuf(dbuf, blkhash[blknum].seq, blknum)) { - snprintf(errstr, errstr_len, "Bad reply data: I wanted blk %08x, seq %08x but I got (at a guess) blk %08x, seq %08x", - (unsigned int) blknum, + if (checkbuf + (dbuf, blkhash[blknum].seq, + blknum)) { + snprintf(errstr, errstr_len, + "Bad reply data: I wanted blk %08x, seq %08x but I got (at a guess) blk %08x, seq %08x", + (unsigned int)blknum, blkhash[blknum].seq, - ((uint32_t *)(dbuf))[0], - ((uint32_t *)(dbuf))[1] - ); + ((uint32_t + *) (dbuf))[0], + ((uint32_t + *) (dbuf))[1] + ); goto err_open; - + } from += 512; len -= 512; } break; case NBD_CMD_WRITE: - /* subsequent reads should get data with this seq*/ - while (len > 0) { - uint64_t blknum = from>>9; - if (--(blkhash[blknum].inflightw) <0 ) { - snprintf(errstr, errstr_len, "Received a write reply for offset %llx when not in flight", - (long long int) from); + /* subsequent reads should get data with this seq */ + while (len > 0) { + uint64_t blknum = from >> 9; + if (--(blkhash[blknum].inflightw) < 0) { + snprintf(errstr, errstr_len, + "Received a write reply for offset %llx when not in flight", + (long long int)from); goto err_open; } - blkhash[blknum].seq=(uint32_t)(prc->seq); + blkhash[blknum].seq = + (uint32_t) (prc->seq); from += 512; len -= 512; } @@ -1236,154 +1394,165 @@ int integrity_test(gchar* hostname, gchar* unixsock, int port, char* name, int s blocked = 0; processed++; rclist_unlink(&inflight, prc); - prc->req.magic=0; /* so a duplicate reply is detected */ + prc->req.magic = 0; /* so a duplicate reply is detected */ free(prc); } - if (!(printer++ % 1000) || !(readtransactionfile || txqueue.numitems || inflight.numitems) ) - printf("%d: Seq %08lld Queued: %08d Inflight: %08d Done: %08lld\r", - (int)mypid, - (long long int) seq, - txqueue.numitems, - inflight.numitems, - (long long int) processed); + if (!(printer++ % 1000) + || !(readtransactionfile || txqueue.numitems + || inflight.numitems)) + printf + ("%d: Seq %08lld Queued: %08d Inflight: %08d Done: %08lld\r", + (int)mypid, (long long int)seq, txqueue.numitems, + inflight.numitems, (long long int)processed); } printf("\n"); - if (gettimeofday(&stop, NULL)<0) { - snprintf(errstr, errstr_len, "Could not measure end time: %s", strerror(errno)); + if (gettimeofday(&stop, NULL) < 0) { + snprintf(errstr, errstr_len, "Could not measure end time: %s", + strerror(errno)); goto err_open; } - timespan=timeval_diff_to_double(&stop, &start); - speed=xfer/timespan; - if(speed>1024) { - speed=speed/1024.0; - speedchar[0]='K'; + timespan = timeval_diff_to_double(&stop, &start); + speed = xfer / timespan; + if (speed > 1024) { + speed = speed / 1024.0; + speedchar[0] = 'K'; } - if(speed>1024) { - speed=speed/1024.0; - speedchar[0]='M'; + if (speed > 1024) { + speed = speed / 1024.0; + speedchar[0] = 'M'; } - if(speed>1024) { - speed=speed/1024.0; - speedchar[0]='G'; + if (speed > 1024) { + speed = speed / 1024.0; + speedchar[0] = 'G'; } - g_message("%d: Integrity %s test complete. Took %.3f seconds to complete, %.3f%sib/s", (int)getpid(), (testflags & TEST_WRITE)?"write":"read", timespan, speed, speedchar); + g_message + ("%d: Integrity %s test complete. Took %.3f seconds to complete, %.3f%sib/s", + (int)getpid(), (testflags & TEST_WRITE) ? "write" : "read", + timespan, speed, speedchar); retval = 0; err_open: - if(close_sock) { + if (close_sock) { close_connection(sock, CONNECTION_CLOSE_PROPERLY); } err: if (size && blkhash) - munmap(blkhash, (size>>9)*sizeof(struct blkitem)); + munmap(blkhash, (size >> 9) * sizeof(struct blkitem)); if (blkhashfd != -1) - close (blkhashfd); + close(blkhashfd); if (logfd != -1) - close (logfd); + close(logfd); if (blkhashname) free(blkhashname); if (*errstr) - g_warning("%s",errstr); + g_warning("%s", errstr); g_hash_table_destroy(handlehash); return retval; } -void handle_nonopt(char* opt, gchar** hostname, long int* p) { - static int nonopt=0; +void handle_nonopt(char *opt, gchar ** hostname, long int *p) +{ + static int nonopt = 0; - switch(nonopt) { - case 0: - *hostname=g_strdup(opt); - nonopt++; - break; - case 1: - *p=(strtol(opt, NULL, 0)); - if(*p==LONG_MIN||*p==LONG_MAX) { - g_critical("Could not parse port number: %s", strerror(errno)); - exit(EXIT_FAILURE); - } - break; + switch (nonopt) { + case 0: + *hostname = g_strdup(opt); + nonopt++; + break; + case 1: + *p = (strtol(opt, NULL, 0)); + if (*p == LONG_MIN || *p == LONG_MAX) { + g_critical("Could not parse port number: %s", + strerror(errno)); + exit(EXIT_FAILURE); + } + break; } } -typedef int (*testfunc)(gchar*, gchar*, int, char*, int, char, char, int); +typedef int (*testfunc) (gchar *, gchar *, int, char *, int, char, char, int); -int main(int argc, char**argv) { - gchar *hostname=NULL, *unixsock=NULL; +int main(int argc, char **argv) +{ + gchar *hostname = NULL, *unixsock = NULL; long int p = 0; - char* name = NULL; - int sock=0; + char *name = NULL; + int sock = 0; int c; - int testflags=0; + int testflags = 0; testfunc test = throughput_test; /* Ignore SIGPIPE as we want to pick up the error from write() */ - signal (SIGPIPE, SIG_IGN); + signal(SIGPIPE, SIG_IGN); - errstr[errstr_len]='\0'; + errstr[errstr_len] = '\0'; - if(argc<3) { + if (argc < 3) { g_message("%d: Not enough arguments", (int)getpid()); - g_message("%d: Usage: %s <hostname> <port>", (int)getpid(), argv[0]); - g_message("%d: Or: %s <hostname> -N <exportname> [<port>]", (int)getpid(), argv[0]); - g_message("%d: Or: %s -u <unix socket> -N <exportname>", (int)getpid(), argv[0]); + g_message("%d: Usage: %s <hostname> <port>", (int)getpid(), + argv[0]); + g_message("%d: Or: %s <hostname> -N <exportname> [<port>]", + (int)getpid(), argv[0]); + g_message("%d: Or: %s -u <unix socket> -N <exportname>", + (int)getpid(), argv[0]); exit(EXIT_FAILURE); } logging(MY_NAME); - while((c=getopt(argc, argv, "-FN:t:owfilu:"))>=0) { - switch(c) { - case 1: - handle_nonopt(optarg, &hostname, &p); - break; - case 'N': - name=g_strdup(optarg); - if(!p) { - p = 10809; - } - break; - case 'F': - testflags|=TEST_EXPECT_ERROR; - break; - case 't': - transactionlog=g_strdup(optarg); - break; - case 'o': - test=oversize_test; - break; - case 'l': - looseordering=1; - break; - case 'w': - testflags|=TEST_WRITE; - break; - case 'f': - testflags|=TEST_FLUSH; - break; - case 'i': - test=integrity_test; - break; - case 'u': - unixsock=g_strdup(optarg); - break; + while ((c = getopt(argc, argv, "-FN:t:owfilu:")) >= 0) { + switch (c) { + case 1: + handle_nonopt(optarg, &hostname, &p); + break; + case 'N': + name = g_strdup(optarg); + if (!p) { + p = 10809; + } + break; + case 'F': + testflags |= TEST_EXPECT_ERROR; + break; + case 't': + transactionlog = g_strdup(optarg); + break; + case 'o': + test = oversize_test; + break; + case 'l': + looseordering = 1; + break; + case 'w': + testflags |= TEST_WRITE; + break; + case 'f': + testflags |= TEST_FLUSH; + break; + case 'i': + test = integrity_test; + break; + case 'u': + unixsock = g_strdup(optarg); + break; } } - while(optind < argc) { + while (optind < argc) { handle_nonopt(argv[optind++], &hostname, &p); } - if(test(hostname, unixsock, (int)p, name, sock, FALSE, TRUE, testflags)<0) { + if (test(hostname, unixsock, (int)p, name, sock, FALSE, TRUE, testflags) + < 0) { g_warning("Could not run test: %s", errstr); exit(EXIT_FAILURE); } -- 1.9.1 ------------------------------------------------------------------------------ Find and fix application performance issues faster with Applications Manager Applications Manager provides deep performance insights into multiple tiers of your business applications. It resolves application problems quickly and reduces your MTTR. Get your free trial! http://pubads.g.doubleclick.net/ gampad/clk?id=1444514301&iu=/ca-pub-7940484522588532 _______________________________________________ Nbd-general mailing list [email protected] https://lists.sourceforge.net/lists/listinfo/nbd-general
