1 /* $FreeBSD$ */ 2 /* $NetBSD: kttcp.c,v 1.5 2002/07/11 23:32:35 simonb Exp $ */ 3 4 /* 5 * Copyright (c) 2002 Wasabi Systems, Inc. 6 * All rights reserved. 7 * 8 * Written by Frank van der Linden and Jason R. Thorpe 9 * for Wasabi Systems, Inc. 10 * 11 * Redistribution and use in source and binary forms, with or without 12 * modification, are permitted provided that the following conditions 13 * are met: 14 * 1. Redistributions of source code must retain the above copyright 15 * notice, this list of conditions and the following disclaimer. 16 * 2. Redistributions in binary form must reproduce the above copyright 17 * notice, this list of conditions and the following disclaimer in the 18 * documentation and/or other materials provided with the distribution. 19 * 3. All advertising materials mentioning features or use of this software 20 * must display the following acknowledgement: 21 * This product includes software developed for the NetBSD Project by 22 * Wasabi Systems, Inc. 23 * 4. The name of Wasabi Systems, Inc. may not be used to endorse 24 * or promote products derived from this software without specific prior 25 * written permission. 26 * 27 * THIS SOFTWARE IS PROVIDED BY WASABI SYSTEMS, INC. ``AS IS'' AND 28 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 29 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 30 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL WASABI SYSTEMS, INC 31 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 32 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 33 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 34 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 35 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 36 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 37 * POSSIBILITY OF SUCH DAMAGE. 38 */ 39 40 #include <sys/types.h> 41 #include <sys/param.h> 42 #include <sys/time.h> 43 #include <sys/resource.h> 44 #include <sys/socket.h> 45 #include <sys/ioctl.h> 46 #include <errno.h> 47 #include <netdb.h> 48 #include <unistd.h> 49 #include <stdio.h> 50 #include <err.h> 51 #include <fcntl.h> 52 #include <stdlib.h> 53 #include <limits.h> 54 #include <string.h> 55 56 #include "kttcpio.h" 57 58 #define KTTCP_PORT "22222" 59 #define KTTCP_XMITSIZE (10*1024*1024) 60 #define KTTCP_SOCKBUF_DEFAULT 65536 61 62 #define KTTCP_DEVICE "/dev/kttcp" 63 64 static void 65 usage(void) 66 { 67 fprintf(stderr, 68 "usage: kttcp -r [-b sockbufsize] [-p port] [-q] [-v]\n" 69 " [-4] [-6]\n" 70 " kttcp -t [-b sockbufsize] [-n bytes] [-q] [-v] [-p port]\n" 71 " [-4] [-6] host\n" 72 ); 73 exit(1); 74 } 75 76 static unsigned long long 77 get_bytes(const char *str) 78 { 79 unsigned long long bytes; 80 char *cp; 81 82 bytes = strtoull(str, &cp, 10); 83 if (bytes == ULLONG_MAX && errno == ERANGE) 84 err(1, "%s", str); 85 86 if (cp[0] != '\0') { 87 if (cp[1] != '\0') 88 errx(1, "invalid byte count: %s", str); 89 if (cp[0] == 'k' || cp[0] == 'K') 90 bytes *= 1024; 91 else if (cp[0] == 'm' || cp[0] == 'M') 92 bytes *= 1024 * 1024; 93 else if (cp[0] == 'g' || cp[0] == 'G') 94 bytes *= 1024 * 1024 * 1024; 95 else 96 errx(1, "invalid byte count modifier: %s", str); 97 } 98 99 return (bytes); 100 } 101 102 int 103 main(int argc, char *argv[]) 104 { 105 int c, error, s, verbose, s2, kfd; 106 int xmitset, family; 107 int bufsize; 108 int ai_flag; 109 char *host; 110 char *portstr; 111 struct kttcp_io_args kio; 112 struct addrinfo hints, *addr, *res; 113 struct sockaddr_storage ss; 114 struct rusage rustart, ruend; 115 struct timeval tvtmp; 116 unsigned long long ull, usecs, bytespersec, bitspersec, xmitsize; 117 char connecthost[NI_MAXHOST]; 118 socklen_t slen; 119 const int one = 1; 120 u_long cmd; 121 122 cmd = 0; 123 portstr = KTTCP_PORT; 124 verbose = 1; 125 xmitset = 0; 126 bufsize = KTTCP_SOCKBUF_DEFAULT; 127 xmitsize = KTTCP_XMITSIZE; 128 family = PF_UNSPEC; 129 while ((c = getopt(argc, argv, "46b:n:p:qrtvw:")) != -1) { 130 switch (c) { 131 case '4': 132 if (family != PF_UNSPEC) 133 usage(); 134 family = PF_INET; 135 break; 136 case '6': 137 if (family != PF_UNSPEC) 138 usage(); 139 family = PF_INET6; 140 break; 141 case 'b': 142 ull = get_bytes(optarg); 143 if (ull > INT_MAX) 144 errx(1, 145 "invalid socket buffer size: %s\n", optarg); 146 bufsize = ull; 147 break; 148 case 'n': 149 xmitsize = get_bytes(optarg); 150 xmitset = 1; 151 break; 152 case 'p': 153 portstr = optarg; 154 break; 155 case 'q': 156 verbose = 0; 157 break; 158 case 'r': 159 if (cmd != 0) 160 usage(); 161 cmd = KTTCP_IO_RECV; 162 break; 163 case 't': 164 if (cmd != 0) 165 usage(); 166 cmd = KTTCP_IO_SEND; 167 break; 168 case 'v': 169 verbose = 2; 170 break; 171 case '?': 172 default: 173 usage(); 174 } 175 } 176 if (cmd == 0) 177 usage(); 178 179 argc -= optind; 180 argv += optind; 181 182 if (cmd == KTTCP_IO_SEND) { 183 if (xmitsize <= 0 || argc < 1) 184 usage(); 185 host = argv[0]; 186 ai_flag = 0; 187 } else { 188 if (xmitset == 0) 189 xmitsize = KTTCP_MAX_XMIT; 190 host = NULL; 191 ai_flag = AI_PASSIVE; 192 } 193 194 if ((kfd = open(KTTCP_DEVICE, O_RDWR, 666)) == -1) 195 err(2, "open %s", KTTCP_DEVICE); 196 197 memset(&hints, 0, sizeof hints); 198 hints.ai_flags = ai_flag; 199 hints.ai_socktype = SOCK_STREAM; 200 hints.ai_family = family; 201 error = getaddrinfo(host, portstr, &hints, &addr); 202 203 if (error != 0) 204 errx(2, "%s", gai_strerror(error)); 205 206 s = -1; 207 for (res = addr; res != NULL; res = res->ai_next) { 208 s = socket(res->ai_family, res->ai_socktype, res->ai_protocol); 209 if (s >= 0) 210 break; 211 } 212 if (res == NULL) 213 err(2, "can't create socket"); 214 215 printf("kttcp: socket buffer size: %d\n", bufsize); 216 217 if (cmd == KTTCP_IO_SEND) { 218 if (connect(s, res->ai_addr, res->ai_addrlen) < 0) 219 err(2, "connect"); 220 if (verbose) { 221 getnameinfo(res->ai_addr, res->ai_addrlen, 222 connecthost, sizeof connecthost, NULL, 0, 223 NI_NUMERICHOST); 224 printf("kttcp: connected to %s\n", connecthost); 225 } 226 if (setsockopt(s, SOL_SOCKET, SO_SNDBUF, &bufsize, sizeof (int)) 227 < 0) 228 err(2, "setsockopt sndbuf"); 229 kio.kio_socket = s; 230 } else { 231 if (setsockopt(s, SOL_SOCKET, SO_REUSEADDR, &one, 232 sizeof (int)) < 0) 233 err(2, "setsockopt reuseaddr"); 234 if (bind(s, res->ai_addr, res->ai_addrlen) < 0) 235 err(2, "bind"); 236 if (listen(s, 1) < 0) 237 err(2, "listen"); 238 if (verbose) 239 printf("kttcp: listening on port %s\n", portstr); 240 slen = sizeof ss; 241 s2 = accept(s, (struct sockaddr *)&ss, &slen); 242 if (s2 < 0) 243 err(2, "accept"); 244 if (verbose) { 245 getnameinfo((struct sockaddr *)&ss, ss.ss_len, 246 connecthost, sizeof connecthost, NULL, 0, 247 NI_NUMERICHOST); 248 printf("kttcp: connect from %s\n", connecthost); 249 } 250 if (setsockopt(s2, SOL_SOCKET, SO_RCVBUF, &bufsize, 251 sizeof (int)) < 0) 252 err(2, "setsockopt rcvbuf"); 253 kio.kio_socket = s2; 254 } 255 256 kio.kio_totalsize = xmitsize; 257 258 getrusage(RUSAGE_SELF, &rustart); 259 if (ioctl(kfd, cmd, &kio) == -1) 260 err(2, "kttcp i/o command"); 261 getrusage(RUSAGE_SELF, &ruend); 262 263 usecs = (unsigned long long)kio.kio_elapsed.tv_sec * 1000000; 264 usecs += kio.kio_elapsed.tv_usec; 265 266 bytespersec = kio.kio_bytesdone * 1000000LL / usecs; 267 bitspersec = bytespersec * NBBY; 268 printf("kttcp: %llu bytes in %ld.%03ld real seconds ==> %llu bytes/sec\n", 269 kio.kio_bytesdone, kio.kio_elapsed.tv_sec, 270 kio.kio_elapsed.tv_usec / 1000, bytespersec); 271 if (verbose > 1) { 272 timersub(&ruend.ru_stime, &rustart.ru_stime, &tvtmp); 273 bytespersec = kio.kio_bytesdone * 1000000LL / 274 (tvtmp.tv_sec * 1000000ULL + tvtmp.tv_usec); 275 printf("kttcp: %llu bytes in %ld.%03ld CPU seconds ==> %llu bytes/CPU sec\n", 276 kio.kio_bytesdone, tvtmp.tv_sec, tvtmp.tv_usec / 1000, bytespersec); 277 } 278 printf(" %g (%g) Megabits/sec\n", 279 ((double) bitspersec / 1024.0) / 1024.0, 280 ((double) bitspersec / 1000.0) / 1000.0); 281 282 timersub(&ruend.ru_utime, &rustart.ru_utime, &tvtmp); 283 /* XXX 284 * sometimes, this ends up as -1 * hz!? 285 */ 286 if (tvtmp.tv_sec < 0) 287 tvtmp.tv_sec = tvtmp.tv_usec = 0; 288 printf(" %ld.%02lduser", tvtmp.tv_sec, tvtmp.tv_usec / 10000); 289 ull = tvtmp.tv_sec * 1000000ULL + tvtmp.tv_usec; 290 291 timersub(&ruend.ru_stime, &rustart.ru_stime, &tvtmp); 292 printf(" %ld.%02ldsys", tvtmp.tv_sec, tvtmp.tv_usec / 10000); 293 ull += tvtmp.tv_sec * 1000000ULL + tvtmp.tv_usec; 294 295 printf(" %lld.%lldreal", usecs / 1000000, (usecs % 1000000) / 10000); 296 printf(" %lld%%", ull * 100 / usecs); 297 printf("\n"); 298 299 300 close(kio.kio_socket); 301 if (cmd == KTTCP_IO_RECV) 302 close(s); 303 close(kfd); 304 freeaddrinfo(addr); 305 306 return 0; 307 } 308