1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (C) 2024 ARM Limited. 4 */ 5 6 #define _GNU_SOURCE 7 8 #include <stdio.h> 9 #include <stdlib.h> 10 #include <stdbool.h> 11 #include <errno.h> 12 #include <fcntl.h> 13 #include <signal.h> 14 #include <string.h> 15 #include <unistd.h> 16 17 #include <sys/socket.h> 18 19 #include <linux/kernel.h> 20 #include <linux/if_alg.h> 21 22 #define DATA_SIZE (16 * 4096) 23 24 static int base, sock; 25 26 static int digest_len; 27 static char *ref; 28 static char *digest; 29 static char *alg_name; 30 31 static struct iovec data_iov; 32 static int zerocopy[2]; 33 static int sigs; 34 static int iter; 35 36 static void handle_exit_signal(int sig, siginfo_t *info, void *context) 37 { 38 printf("Terminated by signal %d, iterations=%d, signals=%d\n", 39 sig, iter, sigs); 40 exit(0); 41 } 42 43 static void handle_kick_signal(int sig, siginfo_t *info, void *context) 44 { 45 sigs++; 46 } 47 48 static char *drivers[] = { 49 "crct10dif-arm64-ce", 50 /* "crct10dif-arm64-neon", - Same priority as generic */ 51 "sha1-ce", 52 "sha224-arm64", 53 "sha224-arm64-neon", 54 "sha224-ce", 55 "sha256-arm64", 56 "sha256-arm64-neon", 57 "sha256-ce", 58 "sha384-ce", 59 "sha512-ce", 60 "sha3-224-ce", 61 "sha3-256-ce", 62 "sha3-384-ce", 63 "sha3-512-ce", 64 "sm3-ce", 65 "sm3-neon", 66 }; 67 68 static bool create_socket(void) 69 { 70 FILE *proc; 71 struct sockaddr_alg addr; 72 char buf[1024]; 73 char *c, *driver_name; 74 bool is_shash, match; 75 int ret, i; 76 77 ret = socket(AF_ALG, SOCK_SEQPACKET, 0); 78 if (ret < 0) { 79 if (errno == EAFNOSUPPORT) { 80 printf("AF_ALG not supported\n"); 81 return false; 82 } 83 84 printf("Failed to create AF_ALG socket: %s (%d)\n", 85 strerror(errno), errno); 86 return false; 87 } 88 base = ret; 89 90 memset(&addr, 0, sizeof(addr)); 91 addr.salg_family = AF_ALG; 92 strncpy((char *)addr.salg_type, "hash", sizeof(addr.salg_type)); 93 94 proc = fopen("/proc/crypto", "r"); 95 if (!proc) { 96 printf("Unable to open /proc/crypto\n"); 97 return false; 98 } 99 100 driver_name = NULL; 101 is_shash = false; 102 match = false; 103 104 /* Look through /proc/crypto for a driver with kernel mode FP usage */ 105 while (!match) { 106 c = fgets(buf, sizeof(buf), proc); 107 if (!c) { 108 if (feof(proc)) { 109 printf("Nothing found in /proc/crypto\n"); 110 return false; 111 } 112 continue; 113 } 114 115 /* Algorithm descriptions are separated by a blank line */ 116 if (*c == '\n') { 117 if (is_shash && driver_name) { 118 for (i = 0; i < ARRAY_SIZE(drivers); i++) { 119 if (strcmp(drivers[i], 120 driver_name) == 0) { 121 match = true; 122 } 123 } 124 } 125 126 if (!match) { 127 digest_len = 0; 128 129 free(driver_name); 130 driver_name = NULL; 131 132 free(alg_name); 133 alg_name = NULL; 134 135 is_shash = false; 136 } 137 continue; 138 } 139 140 /* Remove trailing newline */ 141 c = strchr(buf, '\n'); 142 if (c) 143 *c = '\0'; 144 145 /* Find the field/value separator and start of the value */ 146 c = strchr(buf, ':'); 147 if (!c) 148 continue; 149 c += 2; 150 151 if (strncmp(buf, "digestsize", strlen("digestsize")) == 0) 152 sscanf(c, "%d", &digest_len); 153 154 if (strncmp(buf, "name", strlen("name")) == 0) 155 alg_name = strdup(c); 156 157 if (strncmp(buf, "driver", strlen("driver")) == 0) 158 driver_name = strdup(c); 159 160 if (strncmp(buf, "type", strlen("type")) == 0) 161 if (strncmp(c, "shash", strlen("shash")) == 0) 162 is_shash = true; 163 } 164 165 strncpy((char *)addr.salg_name, alg_name, 166 sizeof(addr.salg_name) - 1); 167 168 ret = bind(base, (struct sockaddr *)&addr, sizeof(addr)); 169 if (ret < 0) { 170 printf("Failed to bind %s: %s (%d)\n", 171 addr.salg_name, strerror(errno), errno); 172 return false; 173 } 174 175 ret = accept(base, NULL, 0); 176 if (ret < 0) { 177 printf("Failed to accept %s: %s (%d)\n", 178 addr.salg_name, strerror(errno), errno); 179 return false; 180 } 181 182 sock = ret; 183 184 ret = pipe(zerocopy); 185 if (ret != 0) { 186 printf("Failed to create zerocopy pipe: %s (%d)\n", 187 strerror(errno), errno); 188 return false; 189 } 190 191 ref = malloc(digest_len); 192 if (!ref) { 193 printf("Failed to allocated %d byte reference\n", digest_len); 194 return false; 195 } 196 197 digest = malloc(digest_len); 198 if (!digest) { 199 printf("Failed to allocated %d byte digest\n", digest_len); 200 return false; 201 } 202 203 return true; 204 } 205 206 static bool compute_digest(void *buf) 207 { 208 struct iovec iov; 209 int ret, wrote; 210 211 iov = data_iov; 212 while (iov.iov_len) { 213 ret = vmsplice(zerocopy[1], &iov, 1, SPLICE_F_GIFT); 214 if (ret < 0) { 215 printf("Failed to send buffer: %s (%d)\n", 216 strerror(errno), errno); 217 return false; 218 } 219 220 wrote = ret; 221 ret = splice(zerocopy[0], NULL, sock, NULL, wrote, 0); 222 if (ret < 0) { 223 printf("Failed to splice buffer: %s (%d)\n", 224 strerror(errno), errno); 225 } else if (ret != wrote) { 226 printf("Short splice: %d < %d\n", ret, wrote); 227 } 228 229 iov.iov_len -= wrote; 230 iov.iov_base += wrote; 231 } 232 233 reread: 234 ret = recv(sock, buf, digest_len, 0); 235 if (ret == 0) { 236 printf("No digest returned\n"); 237 return false; 238 } 239 if (ret != digest_len) { 240 if (errno == -EAGAIN) 241 goto reread; 242 printf("Failed to get digest: %s (%d)\n", 243 strerror(errno), errno); 244 return false; 245 } 246 247 return true; 248 } 249 250 int main(void) 251 { 252 char *data; 253 struct sigaction sa; 254 int ret; 255 256 /* Ensure we have unbuffered output */ 257 setvbuf(stdout, NULL, _IOLBF, 0); 258 259 /* The parent will communicate with us via signals */ 260 memset(&sa, 0, sizeof(sa)); 261 sa.sa_sigaction = handle_exit_signal; 262 sa.sa_flags = SA_RESTART | SA_SIGINFO; 263 sigemptyset(&sa.sa_mask); 264 ret = sigaction(SIGTERM, &sa, NULL); 265 if (ret < 0) 266 printf("Failed to install SIGTERM handler: %s (%d)\n", 267 strerror(errno), errno); 268 269 sa.sa_sigaction = handle_kick_signal; 270 ret = sigaction(SIGUSR1, &sa, NULL); 271 if (ret < 0) 272 printf("Failed to install SIGUSR1 handler: %s (%d)\n", 273 strerror(errno), errno); 274 ret = sigaction(SIGUSR2, &sa, NULL); 275 if (ret < 0) 276 printf("Failed to install SIGUSR2 handler: %s (%d)\n", 277 strerror(errno), errno); 278 279 data = malloc(DATA_SIZE); 280 if (!data) { 281 printf("Failed to allocate data buffer\n"); 282 return EXIT_FAILURE; 283 } 284 memset(data, 0, DATA_SIZE); 285 286 data_iov.iov_base = data; 287 data_iov.iov_len = DATA_SIZE; 288 289 /* 290 * If we can't create a socket assume it's a lack of system 291 * support and fall back to a basic FPSIMD test for the 292 * benefit of fp-stress. 293 */ 294 if (!create_socket()) { 295 execl("./fpsimd-test", "./fpsimd-test", NULL); 296 printf("Failed to fall back to fspimd-test: %d (%s)\n", 297 errno, strerror(errno)); 298 return EXIT_FAILURE; 299 } 300 301 /* 302 * Compute a reference digest we hope is repeatable, we do 303 * this at runtime partly to make it easier to play with 304 * parameters. 305 */ 306 if (!compute_digest(ref)) { 307 printf("Failed to compute reference digest\n"); 308 return EXIT_FAILURE; 309 } 310 311 printf("AF_ALG using %s\n", alg_name); 312 313 while (true) { 314 if (!compute_digest(digest)) { 315 printf("Failed to compute digest, iter=%d\n", iter); 316 return EXIT_FAILURE; 317 } 318 319 if (memcmp(ref, digest, digest_len) != 0) { 320 printf("Digest mismatch, iter=%d\n", iter); 321 return EXIT_FAILURE; 322 } 323 324 iter++; 325 } 326 327 return EXIT_FAILURE; 328 } 329