1 /* SPDX-License-Identifier: BSD-3-Clause 2 * Copyright (c) Intel Corporation. All rights reserved. 3 * Copyright (c) 2019 Mellanox Technologies LTD. All rights reserved. 4 * Copyright (c) 2021 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 5 */ 6 7 #include "spdk/stdinc.h" 8 #include "spdk/version.h" 9 10 #include "spdk_internal/event.h" 11 12 #include "spdk/assert.h" 13 #include "spdk/env.h" 14 #include "spdk/init.h" 15 #include "spdk/log.h" 16 #include "spdk/thread.h" 17 #include "spdk/trace.h" 18 #include "spdk/string.h" 19 #include "spdk/scheduler.h" 20 #include "spdk/rpc.h" 21 #include "spdk/util.h" 22 23 #define SPDK_APP_DEFAULT_LOG_LEVEL SPDK_LOG_NOTICE 24 #define SPDK_APP_DEFAULT_LOG_PRINT_LEVEL SPDK_LOG_INFO 25 #define SPDK_APP_DEFAULT_NUM_TRACE_ENTRIES SPDK_DEFAULT_NUM_TRACE_ENTRIES 26 27 #define SPDK_APP_DPDK_DEFAULT_MEM_SIZE -1 28 #define SPDK_APP_DPDK_DEFAULT_MAIN_CORE -1 29 #define SPDK_APP_DPDK_DEFAULT_MEM_CHANNEL -1 30 #define SPDK_APP_DPDK_DEFAULT_CORE_MASK "0x1" 31 #define SPDK_APP_DPDK_DEFAULT_BASE_VIRTADDR 0x200000000000 32 #define SPDK_APP_DEFAULT_CORE_LIMIT 0x140000000 /* 5 GiB */ 33 34 struct spdk_app { 35 const char *json_config_file; 36 bool json_config_ignore_errors; 37 bool stopped; 38 const char *rpc_addr; 39 int shm_id; 40 spdk_app_shutdown_cb shutdown_cb; 41 int rc; 42 }; 43 44 static struct spdk_app g_spdk_app; 45 static spdk_msg_fn g_start_fn = NULL; 46 static void *g_start_arg = NULL; 47 static struct spdk_thread *g_app_thread = NULL; 48 static bool g_delay_subsystem_init = false; 49 static bool g_shutdown_sig_received = false; 50 static char *g_executable_name; 51 static struct spdk_app_opts g_default_opts; 52 53 int 54 spdk_app_get_shm_id(void) 55 { 56 return g_spdk_app.shm_id; 57 } 58 59 /* append one empty option to indicate the end of the array */ 60 static const struct option g_cmdline_options[] = { 61 #define CONFIG_FILE_OPT_IDX 'c' 62 {"config", required_argument, NULL, CONFIG_FILE_OPT_IDX}, 63 #define LIMIT_COREDUMP_OPT_IDX 'd' 64 {"limit-coredump", no_argument, NULL, LIMIT_COREDUMP_OPT_IDX}, 65 #define TPOINT_GROUP_MASK_OPT_IDX 'e' 66 {"tpoint-group-mask", required_argument, NULL, TPOINT_GROUP_MASK_OPT_IDX}, 67 #define SINGLE_FILE_SEGMENTS_OPT_IDX 'g' 68 {"single-file-segments", no_argument, NULL, SINGLE_FILE_SEGMENTS_OPT_IDX}, 69 #define HELP_OPT_IDX 'h' 70 {"help", no_argument, NULL, HELP_OPT_IDX}, 71 #define SHM_ID_OPT_IDX 'i' 72 {"shm-id", required_argument, NULL, SHM_ID_OPT_IDX}, 73 #define CPUMASK_OPT_IDX 'm' 74 {"cpumask", required_argument, NULL, CPUMASK_OPT_IDX}, 75 #define MEM_CHANNELS_OPT_IDX 'n' 76 {"mem-channels", required_argument, NULL, MEM_CHANNELS_OPT_IDX}, 77 #define MAIN_CORE_OPT_IDX 'p' 78 {"main-core", required_argument, NULL, MAIN_CORE_OPT_IDX}, 79 {"master-core", required_argument, NULL, MAIN_CORE_OPT_IDX}, /* deprecated */ 80 #define RPC_SOCKET_OPT_IDX 'r' 81 {"rpc-socket", required_argument, NULL, RPC_SOCKET_OPT_IDX}, 82 #define MEM_SIZE_OPT_IDX 's' 83 {"mem-size", required_argument, NULL, MEM_SIZE_OPT_IDX}, 84 #define NO_PCI_OPT_IDX 'u' 85 {"no-pci", no_argument, NULL, NO_PCI_OPT_IDX}, 86 #define VERSION_OPT_IDX 'v' 87 {"version", no_argument, NULL, VERSION_OPT_IDX}, 88 #define PCI_BLOCKED_OPT_IDX 'B' 89 {"pci-blocked", required_argument, NULL, PCI_BLOCKED_OPT_IDX}, 90 {"pci-blacklist", required_argument, NULL, PCI_BLOCKED_OPT_IDX}, /* deprecated */ 91 #define LOGFLAG_OPT_IDX 'L' 92 {"logflag", required_argument, NULL, LOGFLAG_OPT_IDX}, 93 #define HUGE_UNLINK_OPT_IDX 'R' 94 {"huge-unlink", no_argument, NULL, HUGE_UNLINK_OPT_IDX}, 95 #define PCI_ALLOWED_OPT_IDX 'A' 96 {"pci-allowed", required_argument, NULL, PCI_ALLOWED_OPT_IDX}, 97 #define PCI_WHITELIST_OPT_IDX 'W' 98 {"pci-whitelist", required_argument, NULL, PCI_WHITELIST_OPT_IDX}, /* deprecated */ 99 #define SILENCE_NOTICELOG_OPT_IDX 257 100 {"silence-noticelog", no_argument, NULL, SILENCE_NOTICELOG_OPT_IDX}, 101 #define WAIT_FOR_RPC_OPT_IDX 258 102 {"wait-for-rpc", no_argument, NULL, WAIT_FOR_RPC_OPT_IDX}, 103 #define HUGE_DIR_OPT_IDX 259 104 {"huge-dir", required_argument, NULL, HUGE_DIR_OPT_IDX}, 105 #define NUM_TRACE_ENTRIES_OPT_IDX 260 106 {"num-trace-entries", required_argument, NULL, NUM_TRACE_ENTRIES_OPT_IDX}, 107 #define MAX_REACTOR_DELAY_OPT_IDX 261 108 {"max-delay", required_argument, NULL, MAX_REACTOR_DELAY_OPT_IDX}, 109 #define JSON_CONFIG_OPT_IDX 262 110 {"json", required_argument, NULL, JSON_CONFIG_OPT_IDX}, 111 #define JSON_CONFIG_IGNORE_INIT_ERRORS_IDX 263 112 {"json-ignore-init-errors", no_argument, NULL, JSON_CONFIG_IGNORE_INIT_ERRORS_IDX}, 113 #define IOVA_MODE_OPT_IDX 264 114 {"iova-mode", required_argument, NULL, IOVA_MODE_OPT_IDX}, 115 #define BASE_VIRTADDR_OPT_IDX 265 116 {"base-virtaddr", required_argument, NULL, BASE_VIRTADDR_OPT_IDX}, 117 #define ENV_CONTEXT_OPT_IDX 266 118 {"env-context", required_argument, NULL, ENV_CONTEXT_OPT_IDX}, 119 }; 120 121 static void 122 app_start_shutdown(void *ctx) 123 { 124 if (g_spdk_app.shutdown_cb) { 125 g_spdk_app.shutdown_cb(); 126 g_spdk_app.shutdown_cb = NULL; 127 } else { 128 spdk_app_stop(0); 129 } 130 } 131 132 void 133 spdk_app_start_shutdown(void) 134 { 135 spdk_thread_send_critical_msg(g_app_thread, app_start_shutdown); 136 } 137 138 static void 139 __shutdown_signal(int signo) 140 { 141 if (!g_shutdown_sig_received) { 142 g_shutdown_sig_received = true; 143 spdk_app_start_shutdown(); 144 } 145 } 146 147 static int 148 app_opts_validate(const char *app_opts) 149 { 150 int i = 0, j; 151 152 for (i = 0; app_opts[i] != '\0'; i++) { 153 /* ignore getopt control characters */ 154 if (app_opts[i] == ':' || app_opts[i] == '+' || app_opts[i] == '-') { 155 continue; 156 } 157 158 for (j = 0; SPDK_APP_GETOPT_STRING[j] != '\0'; j++) { 159 if (app_opts[i] == SPDK_APP_GETOPT_STRING[j]) { 160 return app_opts[i]; 161 } 162 } 163 } 164 return 0; 165 } 166 167 void 168 spdk_app_opts_init(struct spdk_app_opts *opts, size_t opts_size) 169 { 170 if (!opts) { 171 SPDK_ERRLOG("opts should not be NULL\n"); 172 return; 173 } 174 175 if (!opts_size) { 176 SPDK_ERRLOG("opts_size should not be zero value\n"); 177 return; 178 } 179 180 memset(opts, 0, opts_size); 181 opts->opts_size = opts_size; 182 183 #define SET_FIELD(field, value) \ 184 if (offsetof(struct spdk_app_opts, field) + sizeof(opts->field) <= opts_size) { \ 185 opts->field = value; \ 186 } \ 187 188 SET_FIELD(enable_coredump, true); 189 SET_FIELD(shm_id, -1); 190 SET_FIELD(mem_size, SPDK_APP_DPDK_DEFAULT_MEM_SIZE); 191 SET_FIELD(main_core, SPDK_APP_DPDK_DEFAULT_MAIN_CORE); 192 SET_FIELD(mem_channel, SPDK_APP_DPDK_DEFAULT_MEM_CHANNEL); 193 SET_FIELD(reactor_mask, SPDK_APP_DPDK_DEFAULT_CORE_MASK); 194 SET_FIELD(base_virtaddr, SPDK_APP_DPDK_DEFAULT_BASE_VIRTADDR); 195 SET_FIELD(print_level, SPDK_APP_DEFAULT_LOG_PRINT_LEVEL); 196 SET_FIELD(rpc_addr, SPDK_DEFAULT_RPC_ADDR); 197 SET_FIELD(num_entries, SPDK_APP_DEFAULT_NUM_TRACE_ENTRIES); 198 SET_FIELD(delay_subsystem_init, false); 199 SET_FIELD(disable_signal_handlers, false); 200 SET_FIELD(msg_mempool_size, SPDK_DEFAULT_MSG_MEMPOOL_SIZE); 201 #undef SET_FIELD 202 } 203 204 static int 205 app_setup_signal_handlers(struct spdk_app_opts *opts) 206 { 207 struct sigaction sigact; 208 sigset_t sigmask; 209 int rc; 210 211 sigemptyset(&sigmask); 212 memset(&sigact, 0, sizeof(sigact)); 213 sigemptyset(&sigact.sa_mask); 214 215 sigact.sa_handler = SIG_IGN; 216 rc = sigaction(SIGPIPE, &sigact, NULL); 217 if (rc < 0) { 218 SPDK_ERRLOG("sigaction(SIGPIPE) failed\n"); 219 return rc; 220 } 221 222 /* Install the same handler for SIGINT and SIGTERM */ 223 g_shutdown_sig_received = false; 224 sigact.sa_handler = __shutdown_signal; 225 rc = sigaction(SIGINT, &sigact, NULL); 226 if (rc < 0) { 227 SPDK_ERRLOG("sigaction(SIGINT) failed\n"); 228 return rc; 229 } 230 sigaddset(&sigmask, SIGINT); 231 232 rc = sigaction(SIGTERM, &sigact, NULL); 233 if (rc < 0) { 234 SPDK_ERRLOG("sigaction(SIGTERM) failed\n"); 235 return rc; 236 } 237 sigaddset(&sigmask, SIGTERM); 238 239 pthread_sigmask(SIG_UNBLOCK, &sigmask, NULL); 240 241 return 0; 242 } 243 244 static void 245 app_start_application(void) 246 { 247 assert(spdk_get_thread() == g_app_thread); 248 249 g_start_fn(g_start_arg); 250 } 251 252 static void 253 app_start_rpc(int rc, void *arg1) 254 { 255 if (rc) { 256 spdk_app_stop(rc); 257 return; 258 } 259 260 rc = spdk_rpc_initialize(g_spdk_app.rpc_addr); 261 if (rc) { 262 spdk_app_stop(rc); 263 return; 264 } 265 266 if (!g_delay_subsystem_init) { 267 spdk_rpc_set_state(SPDK_RPC_RUNTIME); 268 app_start_application(); 269 } 270 } 271 272 static int 273 app_opts_add_pci_addr(struct spdk_app_opts *opts, struct spdk_pci_addr **list, char *bdf) 274 { 275 struct spdk_pci_addr *tmp = *list; 276 size_t i = opts->num_pci_addr; 277 278 tmp = realloc(tmp, sizeof(*tmp) * (i + 1)); 279 if (tmp == NULL) { 280 SPDK_ERRLOG("realloc error\n"); 281 return -ENOMEM; 282 } 283 284 *list = tmp; 285 if (spdk_pci_addr_parse(*list + i, bdf) < 0) { 286 SPDK_ERRLOG("Invalid address %s\n", bdf); 287 return -EINVAL; 288 } 289 290 opts->num_pci_addr++; 291 return 0; 292 } 293 294 static int 295 app_setup_env(struct spdk_app_opts *opts) 296 { 297 struct spdk_env_opts env_opts = {}; 298 int rc; 299 300 if (opts == NULL) { 301 rc = spdk_env_init(NULL); 302 if (rc != 0) { 303 SPDK_ERRLOG("Unable to reinitialize SPDK env\n"); 304 } 305 306 return rc; 307 } 308 309 spdk_env_opts_init(&env_opts); 310 311 env_opts.name = opts->name; 312 env_opts.core_mask = opts->reactor_mask; 313 env_opts.shm_id = opts->shm_id; 314 env_opts.mem_channel = opts->mem_channel; 315 env_opts.main_core = opts->main_core; 316 env_opts.mem_size = opts->mem_size; 317 env_opts.hugepage_single_segments = opts->hugepage_single_segments; 318 env_opts.unlink_hugepage = opts->unlink_hugepage; 319 env_opts.hugedir = opts->hugedir; 320 env_opts.no_pci = opts->no_pci; 321 env_opts.num_pci_addr = opts->num_pci_addr; 322 env_opts.pci_blocked = opts->pci_blocked; 323 env_opts.pci_allowed = opts->pci_allowed; 324 env_opts.base_virtaddr = opts->base_virtaddr; 325 env_opts.env_context = opts->env_context; 326 env_opts.iova_mode = opts->iova_mode; 327 328 rc = spdk_env_init(&env_opts); 329 free(env_opts.pci_blocked); 330 free(env_opts.pci_allowed); 331 332 if (rc < 0) { 333 SPDK_ERRLOG("Unable to initialize SPDK env\n"); 334 } 335 336 return rc; 337 } 338 339 static int 340 app_setup_trace(struct spdk_app_opts *opts) 341 { 342 char shm_name[64]; 343 uint64_t tpoint_group_mask, tpoint_mask = -1ULL; 344 char *end = NULL, *tpoint_group_mask_str, *tpoint_group_str = NULL; 345 char *tp_g_str, *tpoint_group, *tpoints; 346 bool error_found = false; 347 uint64_t group_id; 348 349 if (opts->shm_id >= 0) { 350 snprintf(shm_name, sizeof(shm_name), "/%s_trace.%d", opts->name, opts->shm_id); 351 } else { 352 snprintf(shm_name, sizeof(shm_name), "/%s_trace.pid%d", opts->name, (int)getpid()); 353 } 354 355 if (spdk_trace_init(shm_name, opts->num_entries) != 0) { 356 return -1; 357 } 358 359 if (opts->tpoint_group_mask == NULL) { 360 return 0; 361 } 362 363 tpoint_group_mask_str = strdup(opts->tpoint_group_mask); 364 if (tpoint_group_mask_str == NULL) { 365 SPDK_ERRLOG("Unable to get string of tpoint group mask from opts.\n"); 366 return -1; 367 } 368 /* Save a pointer to the original value of the tpoint group mask string 369 * to free later, because spdk_strsepq() modifies given char*. */ 370 tp_g_str = tpoint_group_mask_str; 371 while ((tpoint_group_str = spdk_strsepq(&tpoint_group_mask_str, ",")) != NULL) { 372 if (strchr(tpoint_group_str, ':')) { 373 /* Get the tpoint group mask */ 374 tpoint_group = spdk_strsepq(&tpoint_group_str, ":"); 375 /* Get the tpoint mask inside that group */ 376 tpoints = spdk_strsepq(&tpoint_group_str, ":"); 377 378 errno = 0; 379 tpoint_group_mask = strtoull(tpoint_group, &end, 16); 380 if (*end != '\0' || errno) { 381 tpoint_group_mask = spdk_trace_create_tpoint_group_mask(tpoint_group); 382 if (tpoint_group_mask == 0) { 383 error_found = true; 384 break; 385 } 386 } 387 /* Check if tpoint group mask has only one bit set. 388 * This is to avoid enabling individual tpoints in 389 * more than one tracepoint group at once. */ 390 if (!spdk_u64_is_pow2(tpoint_group_mask)) { 391 SPDK_ERRLOG("Tpoint group mask: %s contains multiple tpoint groups.\n", tpoint_group); 392 SPDK_ERRLOG("This is not supported, to prevent from activating tpoints by mistake.\n"); 393 error_found = true; 394 break; 395 } 396 397 errno = 0; 398 tpoint_mask = strtoull(tpoints, &end, 16); 399 if (*end != '\0' || errno) { 400 error_found = true; 401 break; 402 } 403 } else { 404 errno = 0; 405 tpoint_group_mask = strtoull(tpoint_group_str, &end, 16); 406 if (*end != '\0' || errno) { 407 tpoint_group_mask = spdk_trace_create_tpoint_group_mask(tpoint_group_str); 408 if (tpoint_group_mask == 0) { 409 error_found = true; 410 break; 411 } 412 } 413 tpoint_mask = -1ULL; 414 } 415 416 for (group_id = 0; group_id < SPDK_TRACE_MAX_GROUP_ID; ++group_id) { 417 if (tpoint_group_mask & (1 << group_id)) { 418 spdk_trace_set_tpoints(group_id, tpoint_mask); 419 } 420 } 421 } 422 423 if (error_found) { 424 SPDK_ERRLOG("invalid tpoint mask %s\n", opts->tpoint_group_mask); 425 return -1; 426 } else { 427 SPDK_NOTICELOG("Tracepoint Group Mask %s specified.\n", opts->tpoint_group_mask); 428 SPDK_NOTICELOG("Use 'spdk_trace -s %s %s %d' to capture a snapshot of events at runtime.\n", 429 opts->name, 430 opts->shm_id >= 0 ? "-i" : "-p", 431 opts->shm_id >= 0 ? opts->shm_id : getpid()); 432 #if defined(__linux__) 433 SPDK_NOTICELOG("Or copy /dev/shm%s for offline analysis/debug.\n", shm_name); 434 #endif 435 } 436 free(tp_g_str); 437 438 return 0; 439 } 440 441 static void 442 bootstrap_fn(void *arg1) 443 { 444 int rc; 445 446 if (g_spdk_app.json_config_file) { 447 g_delay_subsystem_init = false; 448 spdk_subsystem_init_from_json_config(g_spdk_app.json_config_file, g_spdk_app.rpc_addr, 449 app_start_rpc, 450 NULL, !g_spdk_app.json_config_ignore_errors); 451 } else { 452 if (!g_delay_subsystem_init) { 453 spdk_subsystem_init(app_start_rpc, NULL); 454 } else { 455 rc = spdk_rpc_initialize(g_spdk_app.rpc_addr); 456 if (rc) { 457 spdk_app_stop(rc); 458 return; 459 } 460 } 461 } 462 } 463 464 static void 465 app_copy_opts(struct spdk_app_opts *opts, struct spdk_app_opts *opts_user, size_t opts_size) 466 { 467 spdk_app_opts_init(opts, sizeof(*opts)); 468 opts->opts_size = opts_size; 469 470 #define SET_FIELD(field) \ 471 if (offsetof(struct spdk_app_opts, field) + sizeof(opts->field) <= (opts->opts_size)) { \ 472 opts->field = opts_user->field; \ 473 } \ 474 475 SET_FIELD(name); 476 SET_FIELD(json_config_file); 477 SET_FIELD(json_config_ignore_errors); 478 SET_FIELD(rpc_addr); 479 SET_FIELD(reactor_mask); 480 SET_FIELD(tpoint_group_mask); 481 SET_FIELD(shm_id); 482 SET_FIELD(shutdown_cb); 483 SET_FIELD(enable_coredump); 484 SET_FIELD(mem_channel); 485 SET_FIELD(main_core); 486 SET_FIELD(mem_size); 487 SET_FIELD(no_pci); 488 SET_FIELD(hugepage_single_segments); 489 SET_FIELD(unlink_hugepage); 490 SET_FIELD(hugedir); 491 SET_FIELD(print_level); 492 SET_FIELD(num_pci_addr); 493 SET_FIELD(pci_blocked); 494 SET_FIELD(pci_allowed); 495 SET_FIELD(iova_mode); 496 SET_FIELD(delay_subsystem_init); 497 SET_FIELD(num_entries); 498 SET_FIELD(env_context); 499 SET_FIELD(log); 500 SET_FIELD(base_virtaddr); 501 SET_FIELD(disable_signal_handlers); 502 SET_FIELD(msg_mempool_size); 503 504 /* You should not remove this statement, but need to update the assert statement 505 * if you add a new field, and also add a corresponding SET_FIELD statement */ 506 SPDK_STATIC_ASSERT(sizeof(struct spdk_app_opts) == 200, "Incorrect size"); 507 508 #undef SET_FIELD 509 } 510 511 int 512 spdk_app_start(struct spdk_app_opts *opts_user, spdk_msg_fn start_fn, 513 void *arg1) 514 { 515 int rc; 516 char *tty; 517 struct spdk_cpuset tmp_cpumask = {}; 518 static bool g_env_was_setup = false; 519 struct spdk_app_opts opts_local = {}; 520 struct spdk_app_opts *opts = &opts_local; 521 522 if (!opts_user) { 523 SPDK_ERRLOG("opts_user should not be NULL\n"); 524 return 1; 525 } 526 527 if (!opts_user->opts_size) { 528 SPDK_ERRLOG("The opts_size in opts_user structure should not be zero value\n"); 529 return 1; 530 } 531 532 if (opts_user->name == NULL) { 533 SPDK_ERRLOG("spdk_app_opts::name not specified\n"); 534 return 1; 535 } 536 537 app_copy_opts(opts, opts_user, opts_user->opts_size); 538 539 if (!start_fn) { 540 SPDK_ERRLOG("start_fn should not be NULL\n"); 541 return 1; 542 } 543 544 tty = ttyname(STDERR_FILENO); 545 if (opts->print_level > SPDK_LOG_WARN && 546 isatty(STDERR_FILENO) && 547 tty && 548 !strncmp(tty, "/dev/tty", strlen("/dev/tty"))) { 549 printf("Warning: printing stderr to console terminal without -q option specified.\n"); 550 printf("Suggest using --silence-noticelog to disable logging to stderr and\n"); 551 printf("monitor syslog, or redirect stderr to a file.\n"); 552 printf("(Delaying for 10 seconds...)\n"); 553 sleep(10); 554 } 555 556 spdk_log_set_print_level(opts->print_level); 557 558 #ifndef SPDK_NO_RLIMIT 559 if (opts->enable_coredump) { 560 struct rlimit core_limits; 561 562 core_limits.rlim_cur = core_limits.rlim_max = SPDK_APP_DEFAULT_CORE_LIMIT; 563 setrlimit(RLIMIT_CORE, &core_limits); 564 } 565 #endif 566 567 memset(&g_spdk_app, 0, sizeof(g_spdk_app)); 568 g_spdk_app.json_config_file = opts->json_config_file; 569 g_spdk_app.json_config_ignore_errors = opts->json_config_ignore_errors; 570 g_spdk_app.rpc_addr = opts->rpc_addr; 571 g_spdk_app.shm_id = opts->shm_id; 572 g_spdk_app.shutdown_cb = opts->shutdown_cb; 573 g_spdk_app.rc = 0; 574 g_spdk_app.stopped = false; 575 576 spdk_log_set_level(SPDK_APP_DEFAULT_LOG_LEVEL); 577 578 /* Pass NULL to app_setup_env if SPDK app has been set up, in order to 579 * indicate that this is a reinitialization. 580 */ 581 if (app_setup_env(g_env_was_setup ? NULL : opts) < 0) { 582 return 1; 583 } 584 585 spdk_log_open(opts->log); 586 SPDK_NOTICELOG("Total cores available: %d\n", spdk_env_get_core_count()); 587 588 if ((rc = spdk_reactors_init(opts->msg_mempool_size)) != 0) { 589 SPDK_ERRLOG("Reactor Initialization failed: rc = %d\n", rc); 590 return 1; 591 } 592 593 spdk_cpuset_set_cpu(&tmp_cpumask, spdk_env_get_current_core(), true); 594 595 /* Now that the reactors have been initialized, we can create an 596 * initialization thread. */ 597 g_app_thread = spdk_thread_create("app_thread", &tmp_cpumask); 598 if (!g_app_thread) { 599 SPDK_ERRLOG("Unable to create an spdk_thread for initialization\n"); 600 return 1; 601 } 602 603 /* 604 * Disable and ignore trace setup if setting num_entries 605 * to be 0. 606 * 607 * Note the call to app_setup_trace() is located here 608 * ahead of app_setup_signal_handlers(). 609 * That's because there is not an easy/direct clean 610 * way of unwinding alloc'd resources that can occur 611 * in app_setup_signal_handlers(). 612 */ 613 if (opts->num_entries != 0 && app_setup_trace(opts) != 0) { 614 return 1; 615 } 616 617 if (!opts->disable_signal_handlers && app_setup_signal_handlers(opts) != 0) { 618 return 1; 619 } 620 621 g_delay_subsystem_init = opts->delay_subsystem_init; 622 g_start_fn = start_fn; 623 g_start_arg = arg1; 624 625 spdk_thread_send_msg(g_app_thread, bootstrap_fn, NULL); 626 627 /* This blocks until spdk_app_stop is called */ 628 spdk_reactors_start(); 629 630 g_env_was_setup = true; 631 632 return g_spdk_app.rc; 633 } 634 635 void 636 spdk_app_fini(void) 637 { 638 spdk_trace_cleanup(); 639 spdk_reactors_fini(); 640 spdk_env_fini(); 641 spdk_log_close(); 642 } 643 644 static void 645 _start_subsystem_fini(void *arg1) 646 { 647 if (g_scheduling_in_progress) { 648 spdk_thread_send_msg(g_app_thread, _start_subsystem_fini, NULL); 649 return; 650 } 651 652 spdk_subsystem_fini(spdk_reactors_stop, NULL); 653 } 654 655 static void 656 app_stop(void *arg1) 657 { 658 if (g_spdk_app.rc == 0) { 659 g_spdk_app.rc = (int)(intptr_t)arg1; 660 } 661 662 if (g_spdk_app.stopped) { 663 SPDK_NOTICELOG("spdk_app_stop called twice\n"); 664 return; 665 } 666 667 spdk_rpc_finish(); 668 g_spdk_app.stopped = true; 669 _start_subsystem_fini(NULL); 670 } 671 672 void 673 spdk_app_stop(int rc) 674 { 675 if (rc) { 676 SPDK_WARNLOG("spdk_app_stop'd on non-zero\n"); 677 } 678 679 /* 680 * We want to run spdk_subsystem_fini() from the same thread where spdk_subsystem_init() 681 * was called. 682 */ 683 spdk_thread_send_msg(g_app_thread, app_stop, (void *)(intptr_t)rc); 684 } 685 686 struct spdk_thread * 687 _spdk_get_app_thread(void) 688 { 689 return g_app_thread; 690 } 691 692 static void 693 usage(void (*app_usage)(void)) 694 { 695 printf("%s [options]\n", g_executable_name); 696 printf("options:\n"); 697 printf(" -c, --config <config> JSON config file (default %s)\n", 698 g_default_opts.json_config_file != NULL ? g_default_opts.json_config_file : "none"); 699 printf(" --json <config> JSON config file (default %s)\n", 700 g_default_opts.json_config_file != NULL ? g_default_opts.json_config_file : "none"); 701 printf(" --json-ignore-init-errors\n"); 702 printf(" don't exit on invalid config entry\n"); 703 printf(" -d, --limit-coredump do not set max coredump size to RLIM_INFINITY\n"); 704 printf(" -g, --single-file-segments\n"); 705 printf(" force creating just one hugetlbfs file\n"); 706 printf(" -h, --help show this usage\n"); 707 printf(" -i, --shm-id <id> shared memory ID (optional)\n"); 708 printf(" -m, --cpumask <mask or list> core mask (like 0xF) or core list of '[]' embraced (like [0,1,10]) for DPDK\n"); 709 printf(" -n, --mem-channels <num> channel number of memory channels used for DPDK\n"); 710 printf(" -p, --main-core <id> main (primary) core for DPDK\n"); 711 printf(" -r, --rpc-socket <path> RPC listen address (default %s)\n", SPDK_DEFAULT_RPC_ADDR); 712 printf(" -s, --mem-size <size> memory size in MB for DPDK (default: "); 713 #ifndef __linux__ 714 if (g_default_opts.mem_size <= 0) { 715 printf("all hugepage memory)\n"); 716 } else 717 #endif 718 { 719 printf("%dMB)\n", g_default_opts.mem_size >= 0 ? g_default_opts.mem_size : 0); 720 } 721 printf(" --silence-noticelog disable notice level logging to stderr\n"); 722 printf(" -u, --no-pci disable PCI access\n"); 723 printf(" --wait-for-rpc wait for RPCs to initialize subsystems\n"); 724 printf(" --max-delay <num> maximum reactor delay (in microseconds)\n"); 725 printf(" -B, --pci-blocked <bdf>\n"); 726 printf(" pci addr to block (can be used more than once)\n"); 727 printf(" -R, --huge-unlink unlink huge files after initialization\n"); 728 printf(" -v, --version print SPDK version\n"); 729 printf(" -A, --pci-allowed <bdf>\n"); 730 printf(" pci addr to allow (-B and -A cannot be used at the same time)\n"); 731 printf(" --huge-dir <path> use a specific hugetlbfs mount to reserve memory from\n"); 732 printf(" --iova-mode <pa/va> set IOVA mode ('pa' for IOVA_PA and 'va' for IOVA_VA)\n"); 733 printf(" --base-virtaddr <addr> the base virtual address for DPDK (default: 0x200000000000)\n"); 734 printf(" --num-trace-entries <num> number of trace entries for each core, must be power of 2, setting 0 to disable trace (default %d)\n", 735 SPDK_APP_DEFAULT_NUM_TRACE_ENTRIES); 736 printf(" --env-context Opaque context for use of the env implementation\n"); 737 spdk_log_usage(stdout, "-L"); 738 spdk_trace_mask_usage(stdout, "-e"); 739 if (app_usage) { 740 app_usage(); 741 } 742 } 743 744 spdk_app_parse_args_rvals_t 745 spdk_app_parse_args(int argc, char **argv, struct spdk_app_opts *opts, 746 const char *app_getopt_str, struct option *app_long_opts, 747 int (*app_parse)(int ch, char *arg), 748 void (*app_usage)(void)) 749 { 750 int ch, rc, opt_idx, global_long_opts_len, app_long_opts_len; 751 struct option *cmdline_options; 752 char *cmdline_short_opts = NULL; 753 char *shm_id_str = NULL; 754 enum spdk_app_parse_args_rvals retval = SPDK_APP_PARSE_ARGS_FAIL; 755 long int tmp; 756 757 memcpy(&g_default_opts, opts, sizeof(g_default_opts)); 758 759 if (opts->json_config_file && access(opts->json_config_file, R_OK) != 0) { 760 SPDK_WARNLOG("Can't read JSON configuration file '%s'\n", opts->json_config_file); 761 opts->json_config_file = NULL; 762 } 763 764 if (app_long_opts == NULL) { 765 app_long_opts_len = 0; 766 } else { 767 for (app_long_opts_len = 0; 768 app_long_opts[app_long_opts_len].name != NULL; 769 app_long_opts_len++); 770 } 771 772 global_long_opts_len = SPDK_COUNTOF(g_cmdline_options); 773 774 cmdline_options = calloc(global_long_opts_len + app_long_opts_len + 1, sizeof(*cmdline_options)); 775 if (!cmdline_options) { 776 SPDK_ERRLOG("Out of memory\n"); 777 return SPDK_APP_PARSE_ARGS_FAIL; 778 } 779 780 memcpy(&cmdline_options[0], g_cmdline_options, sizeof(g_cmdline_options)); 781 if (app_long_opts) { 782 memcpy(&cmdline_options[global_long_opts_len], app_long_opts, 783 app_long_opts_len * sizeof(*app_long_opts)); 784 } 785 786 if (app_getopt_str != NULL) { 787 ch = app_opts_validate(app_getopt_str); 788 if (ch) { 789 SPDK_ERRLOG("Duplicated option '%c' between the generic and application specific spdk opts.\n", 790 ch); 791 goto out; 792 } 793 } 794 795 cmdline_short_opts = spdk_sprintf_alloc("%s%s", app_getopt_str, SPDK_APP_GETOPT_STRING); 796 if (!cmdline_short_opts) { 797 SPDK_ERRLOG("Out of memory\n"); 798 goto out; 799 } 800 801 g_executable_name = argv[0]; 802 803 while ((ch = getopt_long(argc, argv, cmdline_short_opts, cmdline_options, &opt_idx)) != -1) { 804 switch (ch) { 805 case CONFIG_FILE_OPT_IDX: 806 case JSON_CONFIG_OPT_IDX: 807 opts->json_config_file = optarg; 808 break; 809 case JSON_CONFIG_IGNORE_INIT_ERRORS_IDX: 810 opts->json_config_ignore_errors = true; 811 break; 812 case LIMIT_COREDUMP_OPT_IDX: 813 opts->enable_coredump = false; 814 break; 815 case TPOINT_GROUP_MASK_OPT_IDX: 816 opts->tpoint_group_mask = optarg; 817 break; 818 case SINGLE_FILE_SEGMENTS_OPT_IDX: 819 opts->hugepage_single_segments = true; 820 break; 821 case HELP_OPT_IDX: 822 usage(app_usage); 823 retval = SPDK_APP_PARSE_ARGS_HELP; 824 goto out; 825 case SHM_ID_OPT_IDX: 826 shm_id_str = optarg; 827 /* a negative shm-id disables shared configuration file */ 828 if (optarg[0] == '-') { 829 shm_id_str++; 830 } 831 /* check if the positive value of provided shm_id can be parsed as 832 * an integer 833 */ 834 opts->shm_id = spdk_strtol(shm_id_str, 0); 835 if (opts->shm_id < 0) { 836 SPDK_ERRLOG("Invalid shared memory ID %s\n", optarg); 837 goto out; 838 } 839 if (optarg[0] == '-') { 840 opts->shm_id = -opts->shm_id; 841 } 842 break; 843 case CPUMASK_OPT_IDX: 844 opts->reactor_mask = optarg; 845 break; 846 case MEM_CHANNELS_OPT_IDX: 847 opts->mem_channel = spdk_strtol(optarg, 0); 848 if (opts->mem_channel < 0) { 849 SPDK_ERRLOG("Invalid memory channel %s\n", optarg); 850 goto out; 851 } 852 break; 853 case MAIN_CORE_OPT_IDX: 854 opts->main_core = spdk_strtol(optarg, 0); 855 if (opts->main_core < 0) { 856 SPDK_ERRLOG("Invalid main core %s\n", optarg); 857 goto out; 858 } 859 break; 860 case SILENCE_NOTICELOG_OPT_IDX: 861 opts->print_level = SPDK_LOG_WARN; 862 break; 863 case RPC_SOCKET_OPT_IDX: 864 opts->rpc_addr = optarg; 865 break; 866 case MEM_SIZE_OPT_IDX: { 867 uint64_t mem_size_mb; 868 bool mem_size_has_prefix; 869 870 rc = spdk_parse_capacity(optarg, &mem_size_mb, &mem_size_has_prefix); 871 if (rc != 0) { 872 SPDK_ERRLOG("invalid memory pool size `-s %s`\n", optarg); 873 usage(app_usage); 874 goto out; 875 } 876 877 if (mem_size_has_prefix) { 878 /* the mem size is in MB by default, so if a prefix was 879 * specified, we need to manually convert to MB. 880 */ 881 mem_size_mb /= 1024 * 1024; 882 } 883 884 if (mem_size_mb > INT_MAX) { 885 SPDK_ERRLOG("invalid memory pool size `-s %s`\n", optarg); 886 usage(app_usage); 887 goto out; 888 } 889 890 opts->mem_size = (int) mem_size_mb; 891 break; 892 } 893 case NO_PCI_OPT_IDX: 894 opts->no_pci = true; 895 break; 896 case WAIT_FOR_RPC_OPT_IDX: 897 opts->delay_subsystem_init = true; 898 break; 899 case PCI_BLOCKED_OPT_IDX: 900 if (opts->pci_allowed) { 901 free(opts->pci_allowed); 902 opts->pci_allowed = NULL; 903 SPDK_ERRLOG("-B and -A cannot be used at the same time\n"); 904 usage(app_usage); 905 goto out; 906 } 907 908 rc = app_opts_add_pci_addr(opts, &opts->pci_blocked, optarg); 909 if (rc != 0) { 910 free(opts->pci_blocked); 911 opts->pci_blocked = NULL; 912 goto out; 913 } 914 break; 915 case LOGFLAG_OPT_IDX: 916 rc = spdk_log_set_flag(optarg); 917 if (rc < 0) { 918 SPDK_ERRLOG("unknown flag\n"); 919 usage(app_usage); 920 goto out; 921 } 922 #ifdef DEBUG 923 opts->print_level = SPDK_LOG_DEBUG; 924 #endif 925 break; 926 case HUGE_UNLINK_OPT_IDX: 927 opts->unlink_hugepage = true; 928 break; 929 case PCI_WHITELIST_OPT_IDX: 930 SPDK_WARNLOG("-W/--pci-whitelist is deprecated. Use -A/--pci-allowed.\n"); 931 /* fallthrough */ 932 case PCI_ALLOWED_OPT_IDX: 933 if (opts->pci_blocked) { 934 free(opts->pci_blocked); 935 opts->pci_blocked = NULL; 936 SPDK_ERRLOG("-B and -W cannot be used at the same time\n"); 937 usage(app_usage); 938 goto out; 939 } 940 941 rc = app_opts_add_pci_addr(opts, &opts->pci_allowed, optarg); 942 if (rc != 0) { 943 free(opts->pci_allowed); 944 opts->pci_allowed = NULL; 945 goto out; 946 } 947 break; 948 case BASE_VIRTADDR_OPT_IDX: 949 tmp = spdk_strtoll(optarg, 0); 950 if (tmp <= 0) { 951 SPDK_ERRLOG("Invalid base-virtaddr %s\n", optarg); 952 usage(app_usage); 953 goto out; 954 } 955 opts->base_virtaddr = (uint64_t)tmp; 956 break; 957 case HUGE_DIR_OPT_IDX: 958 opts->hugedir = optarg; 959 break; 960 case IOVA_MODE_OPT_IDX: 961 opts->iova_mode = optarg; 962 break; 963 case NUM_TRACE_ENTRIES_OPT_IDX: 964 tmp = spdk_strtoll(optarg, 0); 965 if (tmp < 0) { 966 SPDK_ERRLOG("Invalid num-trace-entries %s\n", optarg); 967 usage(app_usage); 968 goto out; 969 } 970 opts->num_entries = (uint64_t)tmp; 971 if (opts->num_entries > 0 && opts->num_entries & (opts->num_entries - 1)) { 972 SPDK_ERRLOG("num-trace-entries must be power of 2\n"); 973 usage(app_usage); 974 goto out; 975 } 976 break; 977 case MAX_REACTOR_DELAY_OPT_IDX: 978 SPDK_ERRLOG("Deprecation warning: The maximum allowed latency parameter is no longer supported.\n"); 979 break; 980 case ENV_CONTEXT_OPT_IDX: 981 opts->env_context = optarg; 982 break; 983 case VERSION_OPT_IDX: 984 printf(SPDK_VERSION_STRING"\n"); 985 retval = SPDK_APP_PARSE_ARGS_HELP; 986 goto out; 987 case '?': 988 /* 989 * In the event getopt() above detects an option 990 * in argv that is NOT in the getopt_str, 991 * getopt() will return a '?' indicating failure. 992 */ 993 usage(app_usage); 994 goto out; 995 default: 996 rc = app_parse(ch, optarg); 997 if (rc) { 998 SPDK_ERRLOG("Parsing application specific arguments failed: %d\n", rc); 999 goto out; 1000 } 1001 } 1002 } 1003 1004 if (opts->json_config_file && opts->delay_subsystem_init) { 1005 SPDK_ERRLOG("JSON configuration file can't be used together with --wait-for-rpc.\n"); 1006 goto out; 1007 } 1008 1009 retval = SPDK_APP_PARSE_ARGS_SUCCESS; 1010 out: 1011 if (retval != SPDK_APP_PARSE_ARGS_SUCCESS) { 1012 free(opts->pci_blocked); 1013 opts->pci_blocked = NULL; 1014 free(opts->pci_allowed); 1015 opts->pci_allowed = NULL; 1016 } 1017 free(cmdline_short_opts); 1018 free(cmdline_options); 1019 return retval; 1020 } 1021 1022 void 1023 spdk_app_usage(void) 1024 { 1025 if (g_executable_name == NULL) { 1026 SPDK_ERRLOG("%s not valid before calling spdk_app_parse_args()\n", __func__); 1027 return; 1028 } 1029 1030 usage(NULL); 1031 } 1032 1033 static void 1034 rpc_framework_start_init_cpl(int rc, void *arg1) 1035 { 1036 struct spdk_jsonrpc_request *request = arg1; 1037 1038 assert(spdk_get_thread() == g_app_thread); 1039 1040 if (rc) { 1041 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 1042 "framework_initialization failed"); 1043 return; 1044 } 1045 1046 spdk_rpc_set_state(SPDK_RPC_RUNTIME); 1047 app_start_application(); 1048 1049 spdk_jsonrpc_send_bool_response(request, true); 1050 } 1051 1052 static void 1053 rpc_framework_start_init(struct spdk_jsonrpc_request *request, 1054 const struct spdk_json_val *params) 1055 { 1056 if (params != NULL) { 1057 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS, 1058 "framework_start_init requires no parameters"); 1059 return; 1060 } 1061 1062 spdk_subsystem_init(rpc_framework_start_init_cpl, request); 1063 } 1064 SPDK_RPC_REGISTER("framework_start_init", rpc_framework_start_init, SPDK_RPC_STARTUP) 1065 1066 struct subsystem_init_poller_ctx { 1067 struct spdk_poller *init_poller; 1068 struct spdk_jsonrpc_request *request; 1069 }; 1070 1071 static int 1072 rpc_subsystem_init_poller_ctx(void *ctx) 1073 { 1074 struct subsystem_init_poller_ctx *poller_ctx = ctx; 1075 1076 if (spdk_rpc_get_state() == SPDK_RPC_RUNTIME) { 1077 spdk_jsonrpc_send_bool_response(poller_ctx->request, true); 1078 spdk_poller_unregister(&poller_ctx->init_poller); 1079 free(poller_ctx); 1080 } 1081 1082 return SPDK_POLLER_BUSY; 1083 } 1084 1085 static void 1086 rpc_framework_wait_init(struct spdk_jsonrpc_request *request, 1087 const struct spdk_json_val *params) 1088 { 1089 struct subsystem_init_poller_ctx *ctx; 1090 1091 if (spdk_rpc_get_state() == SPDK_RPC_RUNTIME) { 1092 spdk_jsonrpc_send_bool_response(request, true); 1093 } else { 1094 ctx = malloc(sizeof(struct subsystem_init_poller_ctx)); 1095 if (ctx == NULL) { 1096 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 1097 "Unable to allocate memory for the request context\n"); 1098 return; 1099 } 1100 ctx->request = request; 1101 ctx->init_poller = SPDK_POLLER_REGISTER(rpc_subsystem_init_poller_ctx, ctx, 0); 1102 } 1103 } 1104 SPDK_RPC_REGISTER("framework_wait_init", rpc_framework_wait_init, 1105 SPDK_RPC_STARTUP | SPDK_RPC_RUNTIME) 1106