1 /*- 2 * BSD LICENSE 3 * 4 * Copyright (c) Intel Corporation. 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 11 * * Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * * Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in 15 * the documentation and/or other materials provided with the 16 * distribution. 17 * * Neither the name of Intel Corporation nor the names of its 18 * contributors may be used to endorse or promote products derived 19 * from this software without specific prior written permission. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 22 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 24 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 25 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 26 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 27 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 28 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 29 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 30 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 31 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 32 */ 33 34 #include "spdk/stdinc.h" 35 36 #include "spdk_internal/event.h" 37 38 #include "spdk/env.h" 39 #include "spdk/log.h" 40 #include "spdk/conf.h" 41 #include "spdk/thread.h" 42 #include "spdk/trace.h" 43 #include "spdk/string.h" 44 #include "spdk/rpc.h" 45 #include "spdk/util.h" 46 47 #include "json_config.h" 48 49 #define SPDK_APP_DEFAULT_LOG_LEVEL SPDK_LOG_NOTICE 50 #define SPDK_APP_DEFAULT_LOG_PRINT_LEVEL SPDK_LOG_INFO 51 #define SPDK_APP_DEFAULT_BACKTRACE_LOG_LEVEL SPDK_LOG_ERROR 52 #define SPDK_APP_DEFAULT_NUM_TRACE_ENTRIES SPDK_DEFAULT_NUM_TRACE_ENTRIES 53 54 #define SPDK_APP_DPDK_DEFAULT_MEM_SIZE -1 55 #define SPDK_APP_DPDK_DEFAULT_MASTER_CORE -1 56 #define SPDK_APP_DPDK_DEFAULT_MEM_CHANNEL -1 57 #define SPDK_APP_DPDK_DEFAULT_CORE_MASK "0x1" 58 #define SPDK_APP_DEFAULT_CORE_LIMIT 0x140000000 /* 5 GiB */ 59 60 struct spdk_app { 61 struct spdk_conf *config; 62 const char *json_config_file; 63 const char *rpc_addr; 64 int shm_id; 65 spdk_app_shutdown_cb shutdown_cb; 66 int rc; 67 }; 68 69 static struct spdk_app g_spdk_app; 70 static spdk_msg_fn g_start_fn = NULL; 71 static void *g_start_arg = NULL; 72 static struct spdk_event *g_shutdown_event = NULL; 73 static uint32_t g_init_lcore; 74 static bool g_delay_subsystem_init = false; 75 static bool g_shutdown_sig_received = false; 76 static char *g_executable_name; 77 static struct spdk_app_opts g_default_opts; 78 79 int 80 spdk_app_get_shm_id(void) 81 { 82 return g_spdk_app.shm_id; 83 } 84 85 /* append one empty option to indicate the end of the array */ 86 static const struct option g_cmdline_options[] = { 87 #define CONFIG_FILE_OPT_IDX 'c' 88 {"config", required_argument, NULL, CONFIG_FILE_OPT_IDX}, 89 #define LIMIT_COREDUMP_OPT_IDX 'd' 90 {"limit-coredump", no_argument, NULL, LIMIT_COREDUMP_OPT_IDX}, 91 #define TPOINT_GROUP_MASK_OPT_IDX 'e' 92 {"tpoint-group-mask", required_argument, NULL, TPOINT_GROUP_MASK_OPT_IDX}, 93 #define SINGLE_FILE_SEGMENTS_OPT_IDX 'g' 94 {"single-file-segments", no_argument, NULL, SINGLE_FILE_SEGMENTS_OPT_IDX}, 95 #define HELP_OPT_IDX 'h' 96 {"help", no_argument, NULL, HELP_OPT_IDX}, 97 #define SHM_ID_OPT_IDX 'i' 98 {"shm-id", required_argument, NULL, SHM_ID_OPT_IDX}, 99 #define CPUMASK_OPT_IDX 'm' 100 {"cpumask", required_argument, NULL, CPUMASK_OPT_IDX}, 101 #define MEM_CHANNELS_OPT_IDX 'n' 102 {"mem-channels", required_argument, NULL, MEM_CHANNELS_OPT_IDX}, 103 #define MASTER_CORE_OPT_IDX 'p' 104 {"master-core", required_argument, NULL, MASTER_CORE_OPT_IDX}, 105 #define RPC_SOCKET_OPT_IDX 'r' 106 {"rpc-socket", required_argument, NULL, RPC_SOCKET_OPT_IDX}, 107 #define MEM_SIZE_OPT_IDX 's' 108 {"mem-size", required_argument, NULL, MEM_SIZE_OPT_IDX}, 109 #define NO_PCI_OPT_IDX 'u' 110 {"no-pci", no_argument, NULL, NO_PCI_OPT_IDX}, 111 #define PCI_BLACKLIST_OPT_IDX 'B' 112 {"pci-blacklist", required_argument, NULL, PCI_BLACKLIST_OPT_IDX}, 113 #define LOGFLAG_OPT_IDX 'L' 114 {"logflag", required_argument, NULL, LOGFLAG_OPT_IDX}, 115 #define HUGE_UNLINK_OPT_IDX 'R' 116 {"huge-unlink", no_argument, NULL, HUGE_UNLINK_OPT_IDX}, 117 #define PCI_WHITELIST_OPT_IDX 'W' 118 {"pci-whitelist", required_argument, NULL, PCI_WHITELIST_OPT_IDX}, 119 #define SILENCE_NOTICELOG_OPT_IDX 257 120 {"silence-noticelog", no_argument, NULL, SILENCE_NOTICELOG_OPT_IDX}, 121 #define WAIT_FOR_RPC_OPT_IDX 258 122 {"wait-for-rpc", no_argument, NULL, WAIT_FOR_RPC_OPT_IDX}, 123 #define HUGE_DIR_OPT_IDX 259 124 {"huge-dir", no_argument, NULL, HUGE_DIR_OPT_IDX}, 125 #define NUM_TRACE_ENTRIES_OPT_IDX 260 126 {"num-trace-entries", required_argument, NULL, NUM_TRACE_ENTRIES_OPT_IDX}, 127 #define MAX_REACTOR_DELAY_OPT_IDX 261 128 {"max-delay", required_argument, NULL, MAX_REACTOR_DELAY_OPT_IDX}, 129 #define JSON_CONFIG_OPT_IDX 262 130 {"json", required_argument, NULL, JSON_CONFIG_OPT_IDX}, 131 }; 132 133 /* Global section */ 134 #define GLOBAL_CONFIG_TMPL \ 135 "# Configuration file\n" \ 136 "#\n" \ 137 "# Please write all parameters using ASCII.\n" \ 138 "# The parameter must be quoted if it includes whitespace.\n" \ 139 "#\n" \ 140 "# Configuration syntax:\n" \ 141 "# Spaces at head of line are deleted, other spaces are as separator\n" \ 142 "# Lines starting with '#' are comments and not evaluated.\n" \ 143 "# Lines ending with '\\' are concatenated with the next line.\n" \ 144 "# Bracketed keys are section keys grouping the following value keys.\n" \ 145 "# Number of section key is used as a tag number.\n" \ 146 "# Ex. [TargetNode1] = TargetNode section key with tag number 1\n" \ 147 "[Global]\n" \ 148 " Comment \"Global section\"\n" \ 149 "\n" \ 150 " # Users can restrict work items to only run on certain cores by\n" \ 151 " # specifying a ReactorMask. Default is to allow work items to run\n" \ 152 " # on all cores. Core 0 must be set in the mask if one is specified.\n" \ 153 " # Default: 0xFFFF (cores 0-15)\n" \ 154 " ReactorMask \"0x%s\"\n" \ 155 "\n" \ 156 " # Tracepoint group mask for spdk trace buffers\n" \ 157 " # Default: 0x0 (all tracepoint groups disabled)\n" \ 158 " # Set to 0xFFFF to enable all tracepoint groups.\n" \ 159 " TpointGroupMask \"0x%" PRIX64 "\"\n" \ 160 "\n" \ 161 162 static void 163 spdk_app_config_dump_global_section(FILE *fp) 164 { 165 struct spdk_cpuset *coremask; 166 167 if (NULL == fp) { 168 return; 169 } 170 171 coremask = spdk_app_get_core_mask(); 172 173 fprintf(fp, GLOBAL_CONFIG_TMPL, spdk_cpuset_fmt(coremask), 174 spdk_trace_get_tpoint_group_mask()); 175 } 176 177 int 178 spdk_app_get_running_config(char **config_str, char *name) 179 { 180 FILE *fp = NULL; 181 int fd = -1; 182 long length = 0, ret = 0; 183 char vbuf[BUFSIZ]; 184 char config_template[64]; 185 186 snprintf(config_template, sizeof(config_template), "/tmp/%s.XXXXXX", name); 187 /* Create temporary file to hold config */ 188 fd = mkstemp(config_template); 189 if (fd == -1) { 190 SPDK_ERRLOG("mkstemp failed\n"); 191 return -1; 192 } 193 fp = fdopen(fd, "wb+"); 194 if (NULL == fp) { 195 SPDK_ERRLOG("error opening tmpfile fd = %d\n", fd); 196 return -1; 197 } 198 199 /* Buffered IO */ 200 setvbuf(fp, vbuf, _IOFBF, BUFSIZ); 201 202 spdk_app_config_dump_global_section(fp); 203 spdk_subsystem_config(fp); 204 205 length = ftell(fp); 206 207 *config_str = malloc(length + 1); 208 if (!*config_str) { 209 SPDK_ERRLOG("out-of-memory for config\n"); 210 fclose(fp); 211 return -1; 212 } 213 fseek(fp, 0, SEEK_SET); 214 ret = fread(*config_str, sizeof(char), length, fp); 215 if (ret < length) { 216 SPDK_ERRLOG("short read\n"); 217 } 218 fclose(fp); 219 (*config_str)[length] = '\0'; 220 221 return 0; 222 } 223 224 void 225 spdk_app_start_shutdown(void) 226 { 227 if (g_shutdown_event != NULL) { 228 spdk_event_call(g_shutdown_event); 229 g_shutdown_event = NULL; 230 } else { 231 spdk_app_stop(0); 232 } 233 } 234 235 static void 236 __shutdown_signal(int signo) 237 { 238 if (!g_shutdown_sig_received) { 239 g_shutdown_sig_received = true; 240 spdk_app_start_shutdown(); 241 } 242 } 243 244 static void 245 __shutdown_event_cb(void *arg1, void *arg2) 246 { 247 g_spdk_app.shutdown_cb(); 248 } 249 250 static int 251 spdk_app_opts_validate(const char *app_opts) 252 { 253 int i = 0, j; 254 255 for (i = 0; app_opts[i] != '\0'; i++) { 256 /* ignore getopt control characters */ 257 if (app_opts[i] == ':' || app_opts[i] == '+' || app_opts[i] == '-') { 258 continue; 259 } 260 261 for (j = 0; SPDK_APP_GETOPT_STRING[j] != '\0'; j++) { 262 if (app_opts[i] == SPDK_APP_GETOPT_STRING[j]) { 263 return app_opts[i]; 264 } 265 } 266 } 267 return 0; 268 } 269 270 void 271 spdk_app_opts_init(struct spdk_app_opts *opts) 272 { 273 if (!opts) { 274 return; 275 } 276 277 memset(opts, 0, sizeof(*opts)); 278 279 opts->enable_coredump = true; 280 opts->shm_id = -1; 281 opts->mem_size = SPDK_APP_DPDK_DEFAULT_MEM_SIZE; 282 opts->master_core = SPDK_APP_DPDK_DEFAULT_MASTER_CORE; 283 opts->mem_channel = SPDK_APP_DPDK_DEFAULT_MEM_CHANNEL; 284 opts->reactor_mask = NULL; 285 opts->print_level = SPDK_APP_DEFAULT_LOG_PRINT_LEVEL; 286 opts->rpc_addr = SPDK_DEFAULT_RPC_ADDR; 287 opts->num_entries = SPDK_APP_DEFAULT_NUM_TRACE_ENTRIES; 288 opts->delay_subsystem_init = false; 289 } 290 291 static int 292 spdk_app_setup_signal_handlers(struct spdk_app_opts *opts) 293 { 294 struct sigaction sigact; 295 sigset_t sigmask; 296 int rc; 297 298 /* Set up custom shutdown handling if the user requested it. */ 299 if (opts->shutdown_cb != NULL) { 300 g_shutdown_event = spdk_event_allocate(spdk_env_get_current_core(), 301 __shutdown_event_cb, 302 NULL, NULL); 303 } 304 305 sigemptyset(&sigmask); 306 memset(&sigact, 0, sizeof(sigact)); 307 sigemptyset(&sigact.sa_mask); 308 309 sigact.sa_handler = SIG_IGN; 310 rc = sigaction(SIGPIPE, &sigact, NULL); 311 if (rc < 0) { 312 SPDK_ERRLOG("sigaction(SIGPIPE) failed\n"); 313 return rc; 314 } 315 316 /* Install the same handler for SIGINT and SIGTERM */ 317 sigact.sa_handler = __shutdown_signal; 318 319 rc = sigaction(SIGINT, &sigact, NULL); 320 if (rc < 0) { 321 SPDK_ERRLOG("sigaction(SIGINT) failed\n"); 322 return rc; 323 } 324 sigaddset(&sigmask, SIGINT); 325 326 rc = sigaction(SIGTERM, &sigact, NULL); 327 if (rc < 0) { 328 SPDK_ERRLOG("sigaction(SIGTERM) failed\n"); 329 return rc; 330 } 331 sigaddset(&sigmask, SIGTERM); 332 333 if (opts->usr1_handler != NULL) { 334 sigact.sa_handler = opts->usr1_handler; 335 rc = sigaction(SIGUSR1, &sigact, NULL); 336 if (rc < 0) { 337 SPDK_ERRLOG("sigaction(SIGUSR1) failed\n"); 338 return rc; 339 } 340 sigaddset(&sigmask, SIGUSR1); 341 } 342 343 pthread_sigmask(SIG_UNBLOCK, &sigmask, NULL); 344 345 return 0; 346 } 347 348 static void 349 spdk_app_start_application(void) 350 { 351 spdk_rpc_set_state(SPDK_RPC_RUNTIME); 352 353 assert(spdk_env_get_current_core() == g_init_lcore); 354 355 g_start_fn(g_start_arg); 356 } 357 358 static void 359 spdk_app_start_rpc(void *arg1) 360 { 361 spdk_rpc_initialize(g_spdk_app.rpc_addr); 362 if (!g_delay_subsystem_init) { 363 spdk_app_start_application(); 364 } 365 } 366 367 static struct spdk_conf * 368 spdk_app_setup_conf(const char *config_file) 369 { 370 struct spdk_conf *config; 371 int rc; 372 373 config = spdk_conf_allocate(); 374 assert(config != NULL); 375 if (config_file) { 376 rc = spdk_conf_read(config, config_file); 377 if (rc != 0) { 378 SPDK_ERRLOG("Could not read config file %s\n", config_file); 379 goto error; 380 } 381 if (spdk_conf_first_section(config) == NULL) { 382 SPDK_ERRLOG("Invalid config file %s\n", config_file); 383 goto error; 384 } 385 } 386 spdk_conf_set_as_default(config); 387 return config; 388 389 error: 390 spdk_conf_free(config); 391 return NULL; 392 } 393 394 static int 395 spdk_app_opts_add_pci_addr(struct spdk_app_opts *opts, struct spdk_pci_addr **list, char *bdf) 396 { 397 struct spdk_pci_addr *tmp = *list; 398 size_t i = opts->num_pci_addr; 399 400 tmp = realloc(tmp, sizeof(*tmp) * (i + 1)); 401 if (tmp == NULL) { 402 SPDK_ERRLOG("realloc error\n"); 403 return -ENOMEM; 404 } 405 406 *list = tmp; 407 if (spdk_pci_addr_parse(*list + i, bdf) < 0) { 408 SPDK_ERRLOG("Invalid address %s\n", bdf); 409 return -EINVAL; 410 } 411 412 opts->num_pci_addr++; 413 return 0; 414 } 415 416 static int 417 spdk_app_read_config_file_global_params(struct spdk_app_opts *opts) 418 { 419 struct spdk_conf_section *sp; 420 char *bdf; 421 int i, rc = 0; 422 423 sp = spdk_conf_find_section(NULL, "Global"); 424 425 if (opts->shm_id == -1) { 426 if (sp != NULL) { 427 opts->shm_id = spdk_conf_section_get_intval(sp, "SharedMemoryID"); 428 } 429 } 430 431 if (opts->reactor_mask == NULL) { 432 if (sp && spdk_conf_section_get_val(sp, "ReactorMask")) { 433 SPDK_ERRLOG("ReactorMask config option is deprecated. Use -m/--cpumask\n" 434 "command line parameter instead.\n"); 435 opts->reactor_mask = spdk_conf_section_get_val(sp, "ReactorMask"); 436 } else { 437 opts->reactor_mask = SPDK_APP_DPDK_DEFAULT_CORE_MASK; 438 } 439 } 440 441 if (!opts->no_pci && sp) { 442 opts->no_pci = spdk_conf_section_get_boolval(sp, "NoPci", false); 443 } 444 445 if (opts->tpoint_group_mask == NULL) { 446 if (sp != NULL) { 447 opts->tpoint_group_mask = spdk_conf_section_get_val(sp, "TpointGroupMask"); 448 } 449 } 450 451 if (sp == NULL) { 452 return 0; 453 } 454 455 for (i = 0; ; i++) { 456 bdf = spdk_conf_section_get_nmval(sp, "PciBlacklist", i, 0); 457 if (!bdf) { 458 break; 459 } 460 461 rc = spdk_app_opts_add_pci_addr(opts, &opts->pci_blacklist, bdf); 462 if (rc != 0) { 463 free(opts->pci_blacklist); 464 return rc; 465 } 466 } 467 468 for (i = 0; ; i++) { 469 bdf = spdk_conf_section_get_nmval(sp, "PciWhitelist", i, 0); 470 if (!bdf) { 471 break; 472 } 473 474 if (opts->pci_blacklist != NULL) { 475 SPDK_ERRLOG("PciBlacklist and PciWhitelist cannot be used at the same time\n"); 476 free(opts->pci_blacklist); 477 return -EINVAL; 478 } 479 480 rc = spdk_app_opts_add_pci_addr(opts, &opts->pci_whitelist, bdf); 481 if (rc != 0) { 482 free(opts->pci_whitelist); 483 return rc; 484 } 485 } 486 return 0; 487 } 488 489 static int 490 spdk_app_setup_env(struct spdk_app_opts *opts) 491 { 492 struct spdk_env_opts env_opts = {}; 493 int rc; 494 495 spdk_env_opts_init(&env_opts); 496 497 env_opts.name = opts->name; 498 env_opts.core_mask = opts->reactor_mask; 499 env_opts.shm_id = opts->shm_id; 500 env_opts.mem_channel = opts->mem_channel; 501 env_opts.master_core = opts->master_core; 502 env_opts.mem_size = opts->mem_size; 503 env_opts.hugepage_single_segments = opts->hugepage_single_segments; 504 env_opts.unlink_hugepage = opts->unlink_hugepage; 505 env_opts.hugedir = opts->hugedir; 506 env_opts.no_pci = opts->no_pci; 507 env_opts.num_pci_addr = opts->num_pci_addr; 508 env_opts.pci_blacklist = opts->pci_blacklist; 509 env_opts.pci_whitelist = opts->pci_whitelist; 510 env_opts.env_context = opts->env_context; 511 512 rc = spdk_env_init(&env_opts); 513 free(env_opts.pci_blacklist); 514 free(env_opts.pci_whitelist); 515 516 if (rc < 0) { 517 fprintf(stderr, "Unable to initialize SPDK env\n"); 518 } 519 520 return rc; 521 } 522 523 static int 524 spdk_app_setup_trace(struct spdk_app_opts *opts) 525 { 526 char shm_name[64]; 527 uint64_t tpoint_group_mask; 528 char *end; 529 530 if (opts->shm_id >= 0) { 531 snprintf(shm_name, sizeof(shm_name), "/%s_trace.%d", opts->name, opts->shm_id); 532 } else { 533 snprintf(shm_name, sizeof(shm_name), "/%s_trace.pid%d", opts->name, (int)getpid()); 534 } 535 536 if (spdk_trace_init(shm_name, opts->num_entries) != 0) { 537 return -1; 538 } 539 540 if (opts->tpoint_group_mask != NULL) { 541 errno = 0; 542 tpoint_group_mask = strtoull(opts->tpoint_group_mask, &end, 16); 543 if (*end != '\0' || errno) { 544 SPDK_ERRLOG("invalid tpoint mask %s\n", opts->tpoint_group_mask); 545 } else { 546 SPDK_NOTICELOG("Tracepoint Group Mask %s specified.\n", opts->tpoint_group_mask); 547 SPDK_NOTICELOG("Use 'spdk_trace -s %s %s %d' to capture a snapshot of events at runtime.\n", 548 opts->name, 549 opts->shm_id >= 0 ? "-i" : "-p", 550 opts->shm_id >= 0 ? opts->shm_id : getpid()); 551 #if defined(__linux__) 552 SPDK_NOTICELOG("Or copy /dev/shm%s for offline analysis/debug.\n", shm_name); 553 #endif 554 spdk_trace_set_tpoint_group_mask(tpoint_group_mask); 555 } 556 } 557 558 return 0; 559 } 560 561 static void 562 bootstrap_fn(void *arg1, void *arg2) 563 { 564 if (g_spdk_app.json_config_file) { 565 g_delay_subsystem_init = false; 566 spdk_app_json_config_load(g_spdk_app.json_config_file, g_spdk_app.rpc_addr, spdk_app_start_rpc, 567 NULL); 568 } else { 569 if (!g_delay_subsystem_init) { 570 spdk_subsystem_init(spdk_app_start_rpc, NULL); 571 } else { 572 spdk_rpc_initialize(g_spdk_app.rpc_addr); 573 } 574 } 575 } 576 577 int 578 spdk_app_start(struct spdk_app_opts *opts, spdk_msg_fn start_fn, 579 void *arg1) 580 { 581 struct spdk_conf *config = NULL; 582 int rc; 583 char *tty; 584 struct spdk_event *event; 585 586 if (!opts) { 587 SPDK_ERRLOG("opts should not be NULL\n"); 588 return 1; 589 } 590 591 if (!start_fn) { 592 SPDK_ERRLOG("start_fn should not be NULL\n"); 593 return 1; 594 } 595 596 tty = ttyname(STDERR_FILENO); 597 if (opts->print_level > SPDK_LOG_WARN && 598 isatty(STDERR_FILENO) && 599 tty && 600 !strncmp(tty, "/dev/tty", strlen("/dev/tty"))) { 601 printf("Warning: printing stderr to console terminal without -q option specified.\n"); 602 printf("Suggest using --silence-noticelog to disable logging to stderr and\n"); 603 printf("monitor syslog, or redirect stderr to a file.\n"); 604 printf("(Delaying for 10 seconds...)\n"); 605 sleep(10); 606 } 607 608 spdk_log_set_print_level(opts->print_level); 609 610 #ifndef SPDK_NO_RLIMIT 611 if (opts->enable_coredump) { 612 struct rlimit core_limits; 613 614 core_limits.rlim_cur = core_limits.rlim_max = SPDK_APP_DEFAULT_CORE_LIMIT; 615 setrlimit(RLIMIT_CORE, &core_limits); 616 } 617 #endif 618 619 config = spdk_app_setup_conf(opts->config_file); 620 if (config == NULL) { 621 goto app_start_setup_conf_err; 622 } 623 624 if (spdk_app_read_config_file_global_params(opts) < 0) { 625 goto app_start_setup_conf_err; 626 } 627 628 spdk_log_set_level(SPDK_APP_DEFAULT_LOG_LEVEL); 629 spdk_log_set_backtrace_level(SPDK_APP_DEFAULT_BACKTRACE_LOG_LEVEL); 630 631 if (spdk_app_setup_env(opts) < 0) { 632 goto app_start_setup_conf_err; 633 } 634 635 spdk_log_open(); 636 SPDK_NOTICELOG("Total cores available: %d\n", spdk_env_get_core_count()); 637 638 /* 639 * If mask not specified on command line or in configuration file, 640 * reactor_mask will be 0x1 which will enable core 0 to run one 641 * reactor. 642 */ 643 if ((rc = spdk_reactors_init()) != 0) { 644 SPDK_ERRLOG("Reactor Initilization failed: rc = %d\n", rc); 645 goto app_start_log_close_err; 646 } 647 648 /* 649 * Note the call to spdk_app_setup_trace() is located here 650 * ahead of spdk_app_setup_signal_handlers(). 651 * That's because there is not an easy/direct clean 652 * way of unwinding alloc'd resources that can occur 653 * in spdk_app_setup_signal_handlers(). 654 */ 655 if (spdk_app_setup_trace(opts) != 0) { 656 goto app_start_log_close_err; 657 } 658 659 if ((rc = spdk_app_setup_signal_handlers(opts)) != 0) { 660 goto app_start_trace_cleanup_err; 661 } 662 663 memset(&g_spdk_app, 0, sizeof(g_spdk_app)); 664 g_spdk_app.config = config; 665 g_spdk_app.json_config_file = opts->json_config_file; 666 g_spdk_app.rpc_addr = opts->rpc_addr; 667 g_spdk_app.shm_id = opts->shm_id; 668 g_spdk_app.shutdown_cb = opts->shutdown_cb; 669 g_spdk_app.rc = 0; 670 671 g_init_lcore = spdk_env_get_current_core(); 672 g_delay_subsystem_init = opts->delay_subsystem_init; 673 g_start_fn = start_fn; 674 g_start_arg = arg1; 675 676 event = spdk_event_allocate(g_init_lcore, bootstrap_fn, NULL, NULL); 677 678 spdk_event_call(event); 679 680 /* This blocks until spdk_app_stop is called */ 681 spdk_reactors_start(); 682 683 return g_spdk_app.rc; 684 685 app_start_trace_cleanup_err: 686 spdk_trace_cleanup(); 687 688 app_start_log_close_err: 689 spdk_log_close(); 690 691 app_start_setup_conf_err: 692 return 1; 693 } 694 695 void 696 spdk_app_fini(void) 697 { 698 spdk_trace_cleanup(); 699 spdk_reactors_fini(); 700 spdk_env_fini(); 701 spdk_conf_free(g_spdk_app.config); 702 spdk_log_close(); 703 } 704 705 static void 706 _spdk_app_stop(void *arg1, void *arg2) 707 { 708 spdk_rpc_finish(); 709 spdk_subsystem_fini(spdk_reactors_stop, NULL); 710 } 711 712 void 713 spdk_app_stop(int rc) 714 { 715 if (rc) { 716 SPDK_WARNLOG("spdk_app_stop'd on non-zero\n"); 717 } 718 g_spdk_app.rc = rc; 719 /* 720 * We want to run spdk_subsystem_fini() from the same lcore where spdk_subsystem_init() 721 * was called. 722 */ 723 spdk_event_call(spdk_event_allocate(g_init_lcore, _spdk_app_stop, NULL, NULL)); 724 } 725 726 static void 727 usage(void (*app_usage)(void)) 728 { 729 printf("%s [options]\n", g_executable_name); 730 printf("options:\n"); 731 printf(" -c, --config <config> config file (default %s)\n", 732 g_default_opts.config_file != NULL ? g_default_opts.config_file : "none"); 733 printf(" --json <config> JSON config file (default %s)\n", 734 g_default_opts.json_config_file != NULL ? g_default_opts.json_config_file : "none"); 735 printf(" -d, --limit-coredump do not set max coredump size to RLIM_INFINITY\n"); 736 printf(" -g, --single-file-segments\n"); 737 printf(" force creating just one hugetlbfs file\n"); 738 printf(" -h, --help show this usage\n"); 739 printf(" -i, --shm-id <id> shared memory ID (optional)\n"); 740 printf(" -m, --cpumask <mask> core mask for DPDK\n"); 741 printf(" -n, --mem-channels <num> channel number of memory channels used for DPDK\n"); 742 printf(" -p, --master-core <id> master (primary) core for DPDK\n"); 743 printf(" -r, --rpc-socket <path> RPC listen address (default %s)\n", SPDK_DEFAULT_RPC_ADDR); 744 printf(" -s, --mem-size <size> memory size in MB for DPDK (default: "); 745 #ifndef __linux__ 746 if (g_default_opts.mem_size <= 0) { 747 printf("all hugepage memory)\n"); 748 } else 749 #endif 750 { 751 printf("%dMB)\n", g_default_opts.mem_size >= 0 ? g_default_opts.mem_size : 0); 752 } 753 printf(" --silence-noticelog disable notice level logging to stderr\n"); 754 printf(" -u, --no-pci disable PCI access\n"); 755 printf(" --wait-for-rpc wait for RPCs to initialize subsystems\n"); 756 printf(" --max-delay <num> maximum reactor delay (in microseconds)\n"); 757 printf(" -B, --pci-blacklist <bdf>\n"); 758 printf(" pci addr to blacklist (can be used more than once)\n"); 759 printf(" -R, --huge-unlink unlink huge files after initialization\n"); 760 printf(" -W, --pci-whitelist <bdf>\n"); 761 printf(" pci addr to whitelist (-B and -W cannot be used at the same time)\n"); 762 printf(" --huge-dir <path> use a specific hugetlbfs mount to reserve memory from\n"); 763 printf(" --num-trace-entries <num> number of trace entries for each core, must be power of 2. (default %d)\n", 764 SPDK_APP_DEFAULT_NUM_TRACE_ENTRIES); 765 spdk_log_usage(stdout, "-L"); 766 spdk_trace_mask_usage(stdout, "-e"); 767 if (app_usage) { 768 app_usage(); 769 } 770 } 771 772 spdk_app_parse_args_rvals_t 773 spdk_app_parse_args(int argc, char **argv, struct spdk_app_opts *opts, 774 const char *app_getopt_str, struct option *app_long_opts, 775 int (*app_parse)(int ch, char *arg), 776 void (*app_usage)(void)) 777 { 778 int ch, rc, opt_idx, global_long_opts_len, app_long_opts_len; 779 struct option *cmdline_options; 780 char *cmdline_short_opts = NULL; 781 enum spdk_app_parse_args_rvals retval = SPDK_APP_PARSE_ARGS_FAIL; 782 long int tmp; 783 784 memcpy(&g_default_opts, opts, sizeof(g_default_opts)); 785 786 if (opts->config_file && access(opts->config_file, R_OK) != 0) { 787 SPDK_WARNLOG("Can't read legacy configuration file '%s'\n", opts->config_file); 788 opts->config_file = NULL; 789 } 790 791 if (opts->json_config_file && access(opts->json_config_file, R_OK) != 0) { 792 SPDK_WARNLOG("Can't read JSON configuration file '%s'\n", opts->json_config_file); 793 opts->json_config_file = NULL; 794 } 795 796 if (app_long_opts == NULL) { 797 app_long_opts_len = 0; 798 } else { 799 for (app_long_opts_len = 0; 800 app_long_opts[app_long_opts_len].name != NULL; 801 app_long_opts_len++); 802 } 803 804 global_long_opts_len = SPDK_COUNTOF(g_cmdline_options); 805 806 cmdline_options = calloc(global_long_opts_len + app_long_opts_len + 1, sizeof(*cmdline_options)); 807 if (!cmdline_options) { 808 fprintf(stderr, "Out of memory\n"); 809 return SPDK_APP_PARSE_ARGS_FAIL; 810 } 811 812 memcpy(&cmdline_options[0], g_cmdline_options, sizeof(g_cmdline_options)); 813 if (app_long_opts) { 814 memcpy(&cmdline_options[global_long_opts_len], app_long_opts, 815 app_long_opts_len * sizeof(*app_long_opts)); 816 } 817 818 if (app_getopt_str != NULL) { 819 ch = spdk_app_opts_validate(app_getopt_str); 820 if (ch) { 821 fprintf(stderr, "Duplicated option '%c' between the generic and application specific spdk opts.\n", 822 ch); 823 goto out; 824 } 825 } 826 827 cmdline_short_opts = spdk_sprintf_alloc("%s%s", app_getopt_str, SPDK_APP_GETOPT_STRING); 828 if (!cmdline_short_opts) { 829 fprintf(stderr, "Out of memory\n"); 830 goto out; 831 } 832 833 g_executable_name = argv[0]; 834 835 while ((ch = getopt_long(argc, argv, cmdline_short_opts, cmdline_options, &opt_idx)) != -1) { 836 switch (ch) { 837 case CONFIG_FILE_OPT_IDX: 838 opts->config_file = optarg; 839 break; 840 case JSON_CONFIG_OPT_IDX: 841 opts->json_config_file = optarg; 842 break; 843 case LIMIT_COREDUMP_OPT_IDX: 844 opts->enable_coredump = false; 845 break; 846 case TPOINT_GROUP_MASK_OPT_IDX: 847 opts->tpoint_group_mask = optarg; 848 break; 849 case SINGLE_FILE_SEGMENTS_OPT_IDX: 850 opts->hugepage_single_segments = true; 851 break; 852 case HELP_OPT_IDX: 853 usage(app_usage); 854 retval = SPDK_APP_PARSE_ARGS_HELP; 855 goto out; 856 case SHM_ID_OPT_IDX: 857 opts->shm_id = spdk_strtol(optarg, 0); 858 if (opts->shm_id < 0) { 859 fprintf(stderr, "Invalid shared memory ID %s\n", optarg); 860 goto out; 861 } 862 break; 863 case CPUMASK_OPT_IDX: 864 opts->reactor_mask = optarg; 865 break; 866 case MEM_CHANNELS_OPT_IDX: 867 opts->mem_channel = spdk_strtol(optarg, 0); 868 if (opts->mem_channel < 0) { 869 fprintf(stderr, "Invalid memory channel %s\n", optarg); 870 goto out; 871 } 872 break; 873 case MASTER_CORE_OPT_IDX: 874 opts->master_core = spdk_strtol(optarg, 0); 875 if (opts->master_core < 0) { 876 fprintf(stderr, "Invalid master core %s\n", optarg); 877 goto out; 878 } 879 break; 880 case SILENCE_NOTICELOG_OPT_IDX: 881 opts->print_level = SPDK_LOG_WARN; 882 break; 883 case RPC_SOCKET_OPT_IDX: 884 opts->rpc_addr = optarg; 885 break; 886 case MEM_SIZE_OPT_IDX: { 887 uint64_t mem_size_mb; 888 bool mem_size_has_prefix; 889 890 rc = spdk_parse_capacity(optarg, &mem_size_mb, &mem_size_has_prefix); 891 if (rc != 0) { 892 fprintf(stderr, "invalid memory pool size `-s %s`\n", optarg); 893 usage(app_usage); 894 goto out; 895 } 896 897 if (mem_size_has_prefix) { 898 /* the mem size is in MB by default, so if a prefix was 899 * specified, we need to manually convert to MB. 900 */ 901 mem_size_mb /= 1024 * 1024; 902 } 903 904 if (mem_size_mb > INT_MAX) { 905 fprintf(stderr, "invalid memory pool size `-s %s`\n", optarg); 906 usage(app_usage); 907 goto out; 908 } 909 910 opts->mem_size = (int) mem_size_mb; 911 break; 912 } 913 case NO_PCI_OPT_IDX: 914 opts->no_pci = true; 915 break; 916 case WAIT_FOR_RPC_OPT_IDX: 917 opts->delay_subsystem_init = true; 918 break; 919 case PCI_BLACKLIST_OPT_IDX: 920 if (opts->pci_whitelist) { 921 free(opts->pci_whitelist); 922 opts->pci_whitelist = NULL; 923 fprintf(stderr, "-B and -W cannot be used at the same time\n"); 924 usage(app_usage); 925 goto out; 926 } 927 928 rc = spdk_app_opts_add_pci_addr(opts, &opts->pci_blacklist, optarg); 929 if (rc != 0) { 930 free(opts->pci_blacklist); 931 opts->pci_blacklist = NULL; 932 goto out; 933 } 934 break; 935 case LOGFLAG_OPT_IDX: 936 #ifndef DEBUG 937 fprintf(stderr, "%s must be built with CONFIG_DEBUG=y for -L flag\n", 938 argv[0]); 939 usage(app_usage); 940 goto out; 941 #else 942 rc = spdk_log_set_flag(optarg); 943 if (rc < 0) { 944 fprintf(stderr, "unknown flag\n"); 945 usage(app_usage); 946 goto out; 947 } 948 opts->print_level = SPDK_LOG_DEBUG; 949 break; 950 #endif 951 case HUGE_UNLINK_OPT_IDX: 952 opts->unlink_hugepage = true; 953 break; 954 case PCI_WHITELIST_OPT_IDX: 955 if (opts->pci_blacklist) { 956 free(opts->pci_blacklist); 957 opts->pci_blacklist = NULL; 958 fprintf(stderr, "-B and -W cannot be used at the same time\n"); 959 usage(app_usage); 960 goto out; 961 } 962 963 rc = spdk_app_opts_add_pci_addr(opts, &opts->pci_whitelist, optarg); 964 if (rc != 0) { 965 free(opts->pci_whitelist); 966 opts->pci_whitelist = NULL; 967 goto out; 968 } 969 break; 970 case HUGE_DIR_OPT_IDX: 971 opts->hugedir = optarg; 972 break; 973 case NUM_TRACE_ENTRIES_OPT_IDX: 974 tmp = spdk_strtoll(optarg, 0); 975 if (tmp <= 0) { 976 fprintf(stderr, "Invalid num-trace-entries %s\n", optarg); 977 usage(app_usage); 978 goto out; 979 } 980 opts->num_entries = (uint64_t)tmp; 981 if (opts->num_entries & (opts->num_entries - 1)) { 982 fprintf(stderr, "num-trace-entries must be power of 2\n"); 983 usage(app_usage); 984 goto out; 985 } 986 break; 987 case MAX_REACTOR_DELAY_OPT_IDX: 988 fprintf(stderr, 989 "Deprecation warning: The maximum allowed latency parameter is no longer supported.\n"); 990 break; 991 case '?': 992 /* 993 * In the event getopt() above detects an option 994 * in argv that is NOT in the getopt_str, 995 * getopt() will return a '?' indicating failure. 996 */ 997 usage(app_usage); 998 goto out; 999 default: 1000 rc = app_parse(ch, optarg); 1001 if (rc) { 1002 fprintf(stderr, "Parsing application specific arguments failed: %d\n", rc); 1003 goto out; 1004 } 1005 } 1006 } 1007 1008 if (opts->config_file && opts->json_config_file) { 1009 fprintf(stderr, "ERROR: Legacy config and JSON config can't be used together.\n"); 1010 goto out; 1011 } 1012 1013 if (opts->json_config_file && opts->delay_subsystem_init) { 1014 fprintf(stderr, "ERROR: JSON configuration file can't be used together with --wait-for-rpc.\n"); 1015 goto out; 1016 } 1017 1018 /* TBD: Replace warning by failure when RPCs for startup are prepared. */ 1019 if (opts->config_file && opts->delay_subsystem_init) { 1020 fprintf(stderr, 1021 "WARNING: --wait-for-rpc and config file are used at the same time. " 1022 "- Please be careful one options might overwrite others.\n"); 1023 } 1024 1025 retval = SPDK_APP_PARSE_ARGS_SUCCESS; 1026 out: 1027 if (retval != SPDK_APP_PARSE_ARGS_SUCCESS) { 1028 free(opts->pci_blacklist); 1029 opts->pci_blacklist = NULL; 1030 free(opts->pci_whitelist); 1031 opts->pci_whitelist = NULL; 1032 } 1033 free(cmdline_short_opts); 1034 free(cmdline_options); 1035 return retval; 1036 } 1037 1038 void 1039 spdk_app_usage(void) 1040 { 1041 if (g_executable_name == NULL) { 1042 fprintf(stderr, "%s not valid before calling spdk_app_parse_args()\n", __func__); 1043 return; 1044 } 1045 1046 usage(NULL); 1047 } 1048 1049 static void 1050 spdk_rpc_start_subsystem_init_cpl(void *arg1) 1051 { 1052 struct spdk_jsonrpc_request *request = arg1; 1053 struct spdk_json_write_ctx *w; 1054 1055 assert(spdk_env_get_current_core() == g_init_lcore); 1056 1057 spdk_app_start_application(); 1058 1059 w = spdk_jsonrpc_begin_result(request); 1060 if (w == NULL) { 1061 return; 1062 } 1063 1064 spdk_json_write_bool(w, true); 1065 spdk_jsonrpc_end_result(request, w); 1066 } 1067 1068 static void 1069 spdk_rpc_start_subsystem_init(struct spdk_jsonrpc_request *request, 1070 const struct spdk_json_val *params) 1071 { 1072 if (params != NULL) { 1073 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS, 1074 "start_subsystem_init requires no parameters"); 1075 return; 1076 } 1077 1078 spdk_subsystem_init(spdk_rpc_start_subsystem_init_cpl, request); 1079 } 1080 SPDK_RPC_REGISTER("start_subsystem_init", spdk_rpc_start_subsystem_init, SPDK_RPC_STARTUP) 1081 1082 struct subsystem_init_poller_ctx { 1083 struct spdk_poller *init_poller; 1084 struct spdk_jsonrpc_request *request; 1085 }; 1086 1087 static int 1088 spdk_rpc_subsystem_init_poller_ctx(void *ctx) 1089 { 1090 struct spdk_json_write_ctx *w; 1091 struct subsystem_init_poller_ctx *poller_ctx = ctx; 1092 1093 if (spdk_rpc_get_state() == SPDK_RPC_RUNTIME) { 1094 w = spdk_jsonrpc_begin_result(poller_ctx->request); 1095 if (w != NULL) { 1096 spdk_json_write_bool(w, true); 1097 spdk_jsonrpc_end_result(poller_ctx->request, w); 1098 } 1099 spdk_poller_unregister(&poller_ctx->init_poller); 1100 free(poller_ctx); 1101 } 1102 1103 return 1; 1104 } 1105 1106 static void 1107 spdk_rpc_wait_subsystem_init(struct spdk_jsonrpc_request *request, 1108 const struct spdk_json_val *params) 1109 { 1110 struct spdk_json_write_ctx *w; 1111 struct subsystem_init_poller_ctx *ctx; 1112 1113 if (spdk_rpc_get_state() == SPDK_RPC_RUNTIME) { 1114 w = spdk_jsonrpc_begin_result(request); 1115 if (w == NULL) { 1116 return; 1117 } 1118 spdk_json_write_bool(w, true); 1119 spdk_jsonrpc_end_result(request, w); 1120 } else { 1121 ctx = malloc(sizeof(struct subsystem_init_poller_ctx)); 1122 if (ctx == NULL) { 1123 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 1124 "Unable to allocate memory for the request context\n"); 1125 return; 1126 } 1127 ctx->request = request; 1128 ctx->init_poller = spdk_poller_register(spdk_rpc_subsystem_init_poller_ctx, ctx, 0); 1129 } 1130 } 1131 SPDK_RPC_REGISTER("wait_subsystem_init", spdk_rpc_wait_subsystem_init, 1132 SPDK_RPC_STARTUP | SPDK_RPC_RUNTIME) 1133