15a7763bfSjmcp /*
25a7763bfSjmcp * CDDL HEADER START
35a7763bfSjmcp *
45a7763bfSjmcp * The contents of this file are subject to the terms of the
55a7763bfSjmcp * Common Development and Distribution License (the "License").
65a7763bfSjmcp * You may not use this file except in compliance with the License.
75a7763bfSjmcp *
85a7763bfSjmcp * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
95a7763bfSjmcp * or http://www.opensolaris.org/os/licensing.
105a7763bfSjmcp * See the License for the specific language governing permissions
115a7763bfSjmcp * and limitations under the License.
125a7763bfSjmcp *
135a7763bfSjmcp * When distributing Covered Code, include this CDDL HEADER in each
145a7763bfSjmcp * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
155a7763bfSjmcp * If applicable, add the following below this CDDL HEADER, with the
165a7763bfSjmcp * fields enclosed by brackets "[]" replaced with your own identifying
175a7763bfSjmcp * information: Portions Copyright [yyyy] [name of copyright owner]
185a7763bfSjmcp *
195a7763bfSjmcp * CDDL HEADER END
205a7763bfSjmcp */
215a7763bfSjmcp /*
2241f7470aSXin Chen - Sun Microsystems - Beijing China * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
238d55b806SRobert Mustacchi * Copyright 2020 Oxide Computer Company
245a7763bfSjmcp */
255a7763bfSjmcp
265a7763bfSjmcp /*
275a7763bfSjmcp * fwflash.c
285a7763bfSjmcp */
295a7763bfSjmcp #include <stdio.h>
305a7763bfSjmcp #include <stdlib.h>
315a7763bfSjmcp #include <unistd.h>
325a7763bfSjmcp #include <strings.h>
335a7763bfSjmcp #include <errno.h>
345a7763bfSjmcp #include <sys/queue.h>
355a7763bfSjmcp #include <signal.h>
365a7763bfSjmcp #include <locale.h>
375a7763bfSjmcp #include <sys/stat.h>
385a7763bfSjmcp #include <sys/types.h>
395a7763bfSjmcp #include <sys/param.h>
405a7763bfSjmcp #include <fcntl.h>
415a7763bfSjmcp #include <dlfcn.h>
425a7763bfSjmcp #include <dirent.h>
435a7763bfSjmcp #include <sys/varargs.h>
445a7763bfSjmcp #include <libintl.h> /* for gettext(3c) */
455a7763bfSjmcp #include <libdevinfo.h>
464196e263SSherry Moore #include <libscf_priv.h>
475a7763bfSjmcp #include <fwflash/fwflash.h>
48c4800545Sjmcp #include <sys/modctl.h> /* for MAXMODCONFNAME */
495a7763bfSjmcp
505a7763bfSjmcp /* global arg list */
515a7763bfSjmcp int fwflash_arg_list = 0;
525a7763bfSjmcp char *filelist[10];
535a7763bfSjmcp
54a799b1e7Speihong huang /* exposed global args */
55a799b1e7Speihong huang di_node_t rootnode;
56a799b1e7Speihong huang struct PLUGINLIST *fw_pluginlist;
57a799b1e7Speihong huang struct DEVICELIST *fw_devices;
58a799b1e7Speihong huang struct vrfyplugin *verifier;
59a799b1e7Speihong huang struct fw_plugin *self;
60a799b1e7Speihong huang int fwflash_debug = 0;
61a799b1e7Speihong huang
625a7763bfSjmcp /* are we writing to flash? */
635a7763bfSjmcp static int fwflash_in_write = 0;
645a7763bfSjmcp
655a7763bfSjmcp /*
665a7763bfSjmcp * If we *must* track the version string for fwflash, then
675a7763bfSjmcp * we should do so in this common file rather than the header
685a7763bfSjmcp * file since it will then be in sync with what the customer
69f1c23465SJames C. McPherson * sees. We should deprecate the "-v" option since it is not
70f1c23465SJames C. McPherson * actually of any use - it doesn't line up with Mercurial's
71f1c23465SJames C. McPherson * concept of the changeset.
725a7763bfSjmcp */
730bc9814fSXinChen #define FWFLASH_VERSION "v1.9"
745a7763bfSjmcp #define FWFLASH_PROG_NAME "fwflash"
755a7763bfSjmcp
765a7763bfSjmcp static int get_fileopts(char *options);
775a7763bfSjmcp static int flash_device_list();
785a7763bfSjmcp static int flash_load_plugins();
795a7763bfSjmcp static int fwflash_update(char *device, char *filename, int flags);
805a7763bfSjmcp static int fwflash_read_file(char *device, char *filename);
815a7763bfSjmcp static int fwflash_list_fw(char *class);
825a7763bfSjmcp static int fwflash_load_verifier(char *drv, char *vendorid, char *fwimg);
835a7763bfSjmcp static void fwflash_intr(int sig);
845a7763bfSjmcp static void fwflash_handle_signals(void);
85f1c23465SJames C. McPherson static void fwflash_usage(char *arg);
865a7763bfSjmcp static void fwflash_version(void);
875a7763bfSjmcp static int confirm_target(struct devicelist *thisdev, char *file);
885a7763bfSjmcp
895a7763bfSjmcp /*
905a7763bfSjmcp * FWFlash main code
915a7763bfSjmcp */
925a7763bfSjmcp int
main(int argc,char ** argv)93f8bf33c3SShantkumar Hiremath main(int argc, char **argv)
94f8bf33c3SShantkumar Hiremath {
955a7763bfSjmcp int rv = FWFLASH_SUCCESS;
965a7763bfSjmcp int i;
97*ef150c2bSRichard Lowe int ch;
985a7763bfSjmcp char *read_file;
995a7763bfSjmcp extern char *optarg;
1005a7763bfSjmcp char *devclass = NULL;
1015a7763bfSjmcp char *devpath = NULL;
1025a7763bfSjmcp
1035a7763bfSjmcp /* local variables from env */
1045a7763bfSjmcp (void) setlocale(LC_ALL, "");
1055a7763bfSjmcp
1065a7763bfSjmcp #if !defined(TEXT_DOMAIN) /* Should be defined by cc -D */
1075a7763bfSjmcp #define TEXT_DOMAIN "SYS_TEST" /* Use this only if it isn't. */
1085a7763bfSjmcp #endif
1095a7763bfSjmcp
1105a7763bfSjmcp (void) textdomain(TEXT_DOMAIN);
1115a7763bfSjmcp
1125a7763bfSjmcp read_file = NULL;
1135a7763bfSjmcp
1145a7763bfSjmcp if (argc < 2) {
1155a7763bfSjmcp /* no args supplied */
1165a7763bfSjmcp fwflash_usage(NULL);
1175a7763bfSjmcp return (FWFLASH_FAILURE);
1185a7763bfSjmcp }
1195a7763bfSjmcp
12087d06e46Speihong huang while ((ch = getopt(argc, argv, "hvylc:f:r:Qd:")) != EOF) {
1215a7763bfSjmcp switch (ch) {
1225a7763bfSjmcp case 'h':
1235a7763bfSjmcp fwflash_arg_list |= FWFLASH_HELP_FLAG;
1245a7763bfSjmcp break;
1255a7763bfSjmcp case 'v':
1265a7763bfSjmcp fwflash_arg_list |= FWFLASH_VER_FLAG;
1275a7763bfSjmcp break;
1285a7763bfSjmcp case 'y':
1295a7763bfSjmcp fwflash_arg_list |= FWFLASH_YES_FLAG;
1305a7763bfSjmcp break;
1315a7763bfSjmcp case 'l':
1325a7763bfSjmcp fwflash_arg_list |= FWFLASH_LIST_FLAG;
1335a7763bfSjmcp break;
1345a7763bfSjmcp case 'c':
1355a7763bfSjmcp fwflash_arg_list |= FWFLASH_CLASS_FLAG;
1365a7763bfSjmcp /* we validate later */
1375a7763bfSjmcp devclass = strdup(optarg);
1385a7763bfSjmcp break;
1395a7763bfSjmcp case 'd':
1405a7763bfSjmcp fwflash_arg_list |= FWFLASH_DEVICE_FLAG;
1415a7763bfSjmcp devpath = strdup(optarg);
1425a7763bfSjmcp break;
1435a7763bfSjmcp case 'f':
1445a7763bfSjmcp fwflash_arg_list |= FWFLASH_FW_FLAG;
1455a7763bfSjmcp if ((rv = get_fileopts(optarg)) != FWFLASH_SUCCESS) {
146f1c23465SJames C. McPherson fwflash_usage(NULL);
1475a7763bfSjmcp return (FWFLASH_FAILURE);
1485a7763bfSjmcp }
1495a7763bfSjmcp break;
1505a7763bfSjmcp case 'r':
1515a7763bfSjmcp fwflash_arg_list |= FWFLASH_READ_FLAG;
1525a7763bfSjmcp read_file = strdup(optarg);
1535a7763bfSjmcp break;
1545a7763bfSjmcp case 'Q':
1555a7763bfSjmcp /* NOT in the manpage */
1565a7763bfSjmcp fwflash_debug = 1;
1575a7763bfSjmcp break;
158c4800545Sjmcp /* illegal options */
1595a7763bfSjmcp default:
1605a7763bfSjmcp fwflash_usage(optarg);
1615a7763bfSjmcp return (FWFLASH_FAILURE);
1625a7763bfSjmcp }
1635a7763bfSjmcp }
1645a7763bfSjmcp
1655a7763bfSjmcp /* Do Help */
1665a7763bfSjmcp if ((fwflash_arg_list & FWFLASH_HELP_FLAG) ||
1675a7763bfSjmcp ((fwflash_arg_list & FWFLASH_DEVICE_FLAG) &&
168f8bf33c3SShantkumar Hiremath !((fwflash_arg_list & FWFLASH_FW_FLAG) ||
169f8bf33c3SShantkumar Hiremath (fwflash_arg_list & FWFLASH_READ_FLAG)))) {
170f1c23465SJames C. McPherson fwflash_usage(NULL);
1715a7763bfSjmcp return (FWFLASH_SUCCESS);
1725a7763bfSjmcp }
1735a7763bfSjmcp
1745a7763bfSjmcp /* Do Version */
1755a7763bfSjmcp if (fwflash_arg_list == FWFLASH_VER_FLAG) {
1765a7763bfSjmcp fwflash_version();
1775a7763bfSjmcp return (FWFLASH_SUCCESS);
1785a7763bfSjmcp }
1795a7763bfSjmcp
1805a7763bfSjmcp /* generate global list of devices */
1815a7763bfSjmcp if ((rv = flash_load_plugins()) != FWFLASH_SUCCESS) {
1825a7763bfSjmcp logmsg(MSG_ERROR,
1835a7763bfSjmcp gettext("Unable to load fwflash plugins\n"));
1845a7763bfSjmcp fwflash_intr(0);
1855a7763bfSjmcp return (rv);
1865a7763bfSjmcp }
1875a7763bfSjmcp
1885a7763bfSjmcp if ((rv = flash_device_list()) != FWFLASH_SUCCESS) {
1895a7763bfSjmcp logmsg(MSG_ERROR,
1905a7763bfSjmcp gettext("No flashable devices in this system\n"));
1915a7763bfSjmcp fwflash_intr(0);
1925a7763bfSjmcp return (rv);
1935a7763bfSjmcp }
1945a7763bfSjmcp
1955a7763bfSjmcp /* Do list */
1965a7763bfSjmcp if (fwflash_arg_list == (FWFLASH_LIST_FLAG) ||
1975a7763bfSjmcp fwflash_arg_list == (FWFLASH_LIST_FLAG | FWFLASH_CLASS_FLAG)) {
1985a7763bfSjmcp rv = fwflash_list_fw(devclass);
1995a7763bfSjmcp fwflash_intr(0);
2005a7763bfSjmcp return (rv);
2015a7763bfSjmcp }
2025a7763bfSjmcp
2035a7763bfSjmcp fwflash_handle_signals();
2045a7763bfSjmcp
2055a7763bfSjmcp /* Do flash update (write) */
2065a7763bfSjmcp if ((fwflash_arg_list == (FWFLASH_FW_FLAG | FWFLASH_DEVICE_FLAG)) ||
2075a7763bfSjmcp (fwflash_arg_list == (FWFLASH_FW_FLAG | FWFLASH_DEVICE_FLAG |
208f8bf33c3SShantkumar Hiremath FWFLASH_YES_FLAG))) {
2094196e263SSherry Moore int fastreboot_disabled = 0;
2105a7763bfSjmcp /* the update function handles the real arg parsing */
2115a7763bfSjmcp i = 0;
2125a7763bfSjmcp while (filelist[i] != NULL) {
2135a7763bfSjmcp if ((rv = fwflash_update(devpath, filelist[i],
2145a7763bfSjmcp fwflash_arg_list)) == FWFLASH_SUCCESS) {
2155a7763bfSjmcp /* failed ops have already been noted */
2164196e263SSherry Moore if (!fastreboot_disabled &&
2174196e263SSherry Moore scf_fastreboot_default_set_transient(
2184196e263SSherry Moore B_FALSE) != SCF_SUCCESS)
2194196e263SSherry Moore logmsg(MSG_ERROR, gettext(
2204196e263SSherry Moore "Failed to disable fast "
2214196e263SSherry Moore "reboot.\n"));
2224196e263SSherry Moore else
2234196e263SSherry Moore fastreboot_disabled = 1;
2245a7763bfSjmcp logmsg(MSG_ERROR,
2255a7763bfSjmcp gettext("New firmware will be activated "
226f8bf33c3SShantkumar Hiremath "after you reboot\n\n"));
2275a7763bfSjmcp }
2285a7763bfSjmcp ++i;
2295a7763bfSjmcp }
2305a7763bfSjmcp
2315a7763bfSjmcp fwflash_intr(0);
2325a7763bfSjmcp return (rv);
2335a7763bfSjmcp }
2345a7763bfSjmcp
2355a7763bfSjmcp /* Do flash read */
2365a7763bfSjmcp if ((fwflash_arg_list == (FWFLASH_READ_FLAG | FWFLASH_DEVICE_FLAG)) ||
2375a7763bfSjmcp (fwflash_arg_list == (FWFLASH_READ_FLAG | FWFLASH_DEVICE_FLAG |
238f8bf33c3SShantkumar Hiremath FWFLASH_YES_FLAG))) {
2395a7763bfSjmcp rv = fwflash_read_file(devpath, read_file);
2405a7763bfSjmcp fwflash_intr(0);
2415a7763bfSjmcp return (rv);
2425a7763bfSjmcp }
2435a7763bfSjmcp
2445a7763bfSjmcp fwflash_usage(NULL);
2455a7763bfSjmcp
2465a7763bfSjmcp return (FWFLASH_FAILURE);
2475a7763bfSjmcp }
2485a7763bfSjmcp
2495a7763bfSjmcp
2505a7763bfSjmcp static int
flash_load_plugins()251f8bf33c3SShantkumar Hiremath flash_load_plugins()
252f8bf33c3SShantkumar Hiremath {
2535a7763bfSjmcp
2545a7763bfSjmcp int rval = FWFLASH_SUCCESS;
2555a7763bfSjmcp DIR *dirp;
2565a7763bfSjmcp struct dirent *plugdir;
2575a7763bfSjmcp char *plugname;
2585a7763bfSjmcp struct fw_plugin *tmpplug;
2595a7763bfSjmcp struct pluginlist *tmpelem;
2605a7763bfSjmcp void *sym;
2615a7763bfSjmcp char *fwplugdirpath, *tempdirpath;
2625a7763bfSjmcp
2635a7763bfSjmcp
2645a7763bfSjmcp #define CLOSEFREE() { \
2655a7763bfSjmcp (void) dlclose(tmpplug->handle); \
2665a7763bfSjmcp free(tmpplug); }
2675a7763bfSjmcp
2685a7763bfSjmcp /*
2695a7763bfSjmcp * Procedure:
2705a7763bfSjmcp *
2715a7763bfSjmcp * cd /usr/lib/fwflash/identify
2725a7763bfSjmcp * open each .so file found therein
2735a7763bfSjmcp * dlopen(.sofile)
2745a7763bfSjmcp * if it's one of our plugins, add it to fw_pluginlist;
2755a7763bfSjmcp *
2765a7763bfSjmcp * functions we need here include dlopen and dlsym.
2775a7763bfSjmcp *
2785a7763bfSjmcp * If we get to the end and fw_pluginlist struct is empty,
2795a7763bfSjmcp * return FWFLASH_FAILURE so we return to the shell.
2805a7763bfSjmcp */
2815a7763bfSjmcp
2825a7763bfSjmcp if ((fwplugdirpath = calloc(1, MAXPATHLEN + 1)) == NULL) {
2835a7763bfSjmcp logmsg(MSG_ERROR,
2845a7763bfSjmcp gettext("Unable to malloc %d bytes while "
2855a7763bfSjmcp "trying to load plugins: %s\n"),
2865a7763bfSjmcp MAXPATHLEN + 1, strerror(errno));
2875a7763bfSjmcp return (FWFLASH_FAILURE);
2885a7763bfSjmcp }
2895a7763bfSjmcp
2905a7763bfSjmcp tempdirpath = getenv("FWPLUGINDIR");
2915a7763bfSjmcp
2925a7763bfSjmcp if ((fwflash_debug > 0) && (tempdirpath != NULL)) {
2935a7763bfSjmcp (void) strlcpy(fwplugdirpath, tempdirpath,
2945a7763bfSjmcp strlen(tempdirpath) + 1);
2955a7763bfSjmcp } else {
2965a7763bfSjmcp (void) strlcpy(fwplugdirpath, FWPLUGINDIR,
2975a7763bfSjmcp strlen(FWPLUGINDIR) + 1);
2985a7763bfSjmcp }
2995a7763bfSjmcp
3005a7763bfSjmcp if ((dirp = opendir(fwplugdirpath)) == NULL) {
3015a7763bfSjmcp logmsg(MSG_ERROR,
302c4800545Sjmcp gettext("Unable to open %s\n"),
3035a7763bfSjmcp fwplugdirpath);
3045a7763bfSjmcp return (errno);
3055a7763bfSjmcp }
3065a7763bfSjmcp
3075a7763bfSjmcp if ((fw_pluginlist = calloc(1, sizeof (struct fw_plugin)))
3085a7763bfSjmcp == NULL) {
3095a7763bfSjmcp logmsg(MSG_ERROR,
3105a7763bfSjmcp gettext("Unable to malloc %d bytes while "
311f8bf33c3SShantkumar Hiremath "trying to load plugins: %s\n"),
312d65b419eSXinChen sizeof (struct fw_plugin), strerror(errno));
3135a7763bfSjmcp return (FWFLASH_FAILURE);
3145a7763bfSjmcp }
3155a7763bfSjmcp
3165a7763bfSjmcp TAILQ_INIT(fw_pluginlist);
3175a7763bfSjmcp
3182a690de6SMarco van Wieringen while ((plugdir = readdir(dirp)) != NULL) {
3195a7763bfSjmcp
3205a7763bfSjmcp errno = 0; /* remove chance of false results */
3215a7763bfSjmcp
3225a7763bfSjmcp if ((plugdir->d_name[0] == '.') ||
3235a7763bfSjmcp (strstr(plugdir->d_name, ".so") == NULL)) {
3245a7763bfSjmcp continue;
3255a7763bfSjmcp }
3265a7763bfSjmcp
3275a7763bfSjmcp if ((plugname = calloc(1, MAXPATHLEN + 1)) == NULL) {
3285a7763bfSjmcp logmsg(MSG_ERROR,
3295a7763bfSjmcp gettext("Unable to malloc %d bytes while "
330f8bf33c3SShantkumar Hiremath "trying to load plugins: %s\n"),
3315a7763bfSjmcp MAXPATHLEN + 1, strerror(errno));
3325a7763bfSjmcp return (FWFLASH_FAILURE);
3335a7763bfSjmcp }
3345a7763bfSjmcp
3355a7763bfSjmcp (void) snprintf(plugname, MAXPATHLEN, "%s/%s",
3365a7763bfSjmcp fwplugdirpath, plugdir->d_name);
3375a7763bfSjmcp
3385a7763bfSjmcp /* start allocating storage */
3395a7763bfSjmcp if ((tmpelem = calloc(1, sizeof (struct pluginlist)))
3405a7763bfSjmcp == NULL) {
3415a7763bfSjmcp logmsg(MSG_ERROR,
3425a7763bfSjmcp gettext("Unable to malloc %d bytes while "
343f8bf33c3SShantkumar Hiremath "trying to load plugins: %s\n"),
3445a7763bfSjmcp sizeof (struct pluginlist), strerror(errno));
3455a7763bfSjmcp return (FWFLASH_FAILURE);
3465a7763bfSjmcp }
3475a7763bfSjmcp
3485a7763bfSjmcp if ((tmpplug = calloc(1, sizeof (struct fw_plugin)))
3495a7763bfSjmcp == NULL) {
3505a7763bfSjmcp logmsg(MSG_ERROR,
3515a7763bfSjmcp gettext("Unable to malloc %d bytes while "
3525a7763bfSjmcp "trying to load plugins: %s\n"),
3535a7763bfSjmcp sizeof (struct fw_plugin), strerror(errno));
3545a7763bfSjmcp return (FWFLASH_FAILURE);
3555a7763bfSjmcp }
3565a7763bfSjmcp
3575a7763bfSjmcp /* load 'er up! */
3585a7763bfSjmcp tmpplug->handle = dlopen(plugname, RTLD_NOW);
3595a7763bfSjmcp if (tmpplug->handle == NULL) {
3605a7763bfSjmcp free(tmpplug);
3615a7763bfSjmcp continue; /* assume there are other plugins */
3625a7763bfSjmcp }
3635a7763bfSjmcp
3645a7763bfSjmcp if ((tmpplug->filename = calloc(1, strlen(plugname) + 1))
3655a7763bfSjmcp == NULL) {
3665a7763bfSjmcp logmsg(MSG_ERROR,
3675a7763bfSjmcp gettext("Unable to allocate %d bytes for plugin "
368f8bf33c3SShantkumar Hiremath "filename %s:%s\n"),
3695a7763bfSjmcp strlen(plugname) + 1, plugname,
3705a7763bfSjmcp strerror(errno));
3715a7763bfSjmcp return (rval);
3725a7763bfSjmcp }
3735a7763bfSjmcp
3745a7763bfSjmcp (void) strlcpy(tmpplug->filename, plugname,
3755a7763bfSjmcp strlen(plugname) + 1);
3765a7763bfSjmcp
3775a7763bfSjmcp /* now sanity check the file */
3785a7763bfSjmcp if ((sym = dlsym(tmpplug->handle, "drivername"))
3795a7763bfSjmcp != NULL) {
3805a7763bfSjmcp /* max length of drivername */
381c4800545Sjmcp tmpplug->drvname = calloc(1, MAXMODCONFNAME);
382c4800545Sjmcp
383c4800545Sjmcp /* are we doing double-time? */
384c4800545Sjmcp if (strncmp((char *)sym, plugdir->d_name,
385c4800545Sjmcp MAXMODCONFNAME) != 0) {
386c4800545Sjmcp char *tempnm = calloc(1, MAXMODCONFNAME);
387c4800545Sjmcp
388d65b419eSXinChen (void) memcpy(tempnm, plugdir->d_name,
389d65b419eSXinChen MAXMODCONFNAME);
390c4800545Sjmcp (void) strlcpy(tmpplug->drvname,
391c4800545Sjmcp strtok(tempnm, "."),
392c4800545Sjmcp strlen(plugdir->d_name) + 1);
393c4800545Sjmcp free(tempnm);
394c4800545Sjmcp } else {
395c4800545Sjmcp (void) strlcpy(tmpplug->drvname,
396c4800545Sjmcp (char *)sym, strlen(sym) + 1);
397c4800545Sjmcp }
3985a7763bfSjmcp } else {
3995a7763bfSjmcp CLOSEFREE();
4005a7763bfSjmcp continue;
4015a7763bfSjmcp }
4025a7763bfSjmcp if ((sym = dlsym(tmpplug->handle, "fw_readfw"))
4035a7763bfSjmcp != NULL) {
4045a7763bfSjmcp tmpplug->fw_readfw = (int (*)())sym;
4055a7763bfSjmcp } else {
4065a7763bfSjmcp CLOSEFREE();
4075a7763bfSjmcp continue;
4085a7763bfSjmcp }
4095a7763bfSjmcp if ((sym = dlsym(tmpplug->handle, "fw_writefw"))
4105a7763bfSjmcp != NULL) {
4115a7763bfSjmcp tmpplug->fw_writefw = (int (*)())sym;
4125a7763bfSjmcp } else {
4135a7763bfSjmcp CLOSEFREE();
4145a7763bfSjmcp continue;
4155a7763bfSjmcp }
4165a7763bfSjmcp
4175a7763bfSjmcp if ((sym = dlsym(tmpplug->handle, "fw_identify"))
4185a7763bfSjmcp != NULL) {
4195a7763bfSjmcp tmpplug->fw_identify =
4205a7763bfSjmcp (int (*)(int))sym;
4215a7763bfSjmcp } else {
4225a7763bfSjmcp CLOSEFREE();
4235a7763bfSjmcp continue;
4245a7763bfSjmcp }
4255a7763bfSjmcp if ((sym = dlsym(tmpplug->handle, "fw_devinfo"))
4265a7763bfSjmcp != NULL) {
4275a7763bfSjmcp tmpplug->fw_devinfo =
4285a7763bfSjmcp (int (*)(struct devicelist *))sym;
4295a7763bfSjmcp } else {
4305a7763bfSjmcp CLOSEFREE();
4315a7763bfSjmcp continue;
4325a7763bfSjmcp }
4335a7763bfSjmcp
4348d55b806SRobert Mustacchi if ((sym = dlsym(tmpplug->handle, "plugin_version")) != NULL) {
435d65b419eSXinChen if ((*(int *)sym) >= FWPLUGIN_VERSION_2) {
436d65b419eSXinChen if ((sym = dlsym(tmpplug->handle,
437d65b419eSXinChen "fw_cleanup")) != NULL) {
438d65b419eSXinChen tmpplug->fw_cleanup =
439d65b419eSXinChen (void (*)(struct devicelist *))sym;
440d65b419eSXinChen } else {
441d65b419eSXinChen logmsg(MSG_ERROR,
442d65b419eSXinChen gettext("ERROR: v2 plugin (%s) "
443d65b419eSXinChen "has no fw_cleanup function\n"),
444d65b419eSXinChen tmpplug->filename);
445d65b419eSXinChen CLOSEFREE();
446d65b419eSXinChen continue;
447d65b419eSXinChen }
448d65b419eSXinChen } else {
449d65b419eSXinChen logmsg(MSG_INFO,
450d65b419eSXinChen "Identification plugin %s defined "
451d65b419eSXinChen "plugin_version < FWPLUGIN_VERSION_2 !");
452d65b419eSXinChen }
453d65b419eSXinChen }
454d65b419eSXinChen
455c4800545Sjmcp if ((tmpelem->drvname = calloc(1, MAXMODCONFNAME))
4565a7763bfSjmcp == NULL) {
4575a7763bfSjmcp logmsg(MSG_ERROR,
458c4800545Sjmcp gettext("Unable to allocate space for a"
459f8bf33c3SShantkumar Hiremath "drivername %s\n"),
4605a7763bfSjmcp tmpplug->drvname);
4615a7763bfSjmcp return (FWFLASH_FAILURE);
4625a7763bfSjmcp }
4635a7763bfSjmcp
4645a7763bfSjmcp (void) strlcpy(tmpelem->drvname, tmpplug->drvname,
4655a7763bfSjmcp strlen(tmpplug->drvname) + 1);
4665a7763bfSjmcp
4675a7763bfSjmcp if ((tmpelem->filename = calloc(1,
4685a7763bfSjmcp strlen(tmpplug->filename) + 1)) == NULL) {
4695a7763bfSjmcp logmsg(MSG_ERROR,
4705a7763bfSjmcp gettext("Unable to allocate %d bytes for "
471f8bf33c3SShantkumar Hiremath "filename %s\n"),
4725a7763bfSjmcp strlen(tmpplug->filename) + 1,
473c4800545Sjmcp tmpplug->filename);
4745a7763bfSjmcp return (FWFLASH_FAILURE);
4755a7763bfSjmcp }
4765a7763bfSjmcp
4775a7763bfSjmcp (void) strlcpy(tmpelem->filename, plugname,
4785a7763bfSjmcp strlen(plugname) + 1);
4795a7763bfSjmcp tmpelem->plugin = tmpplug;
4805a7763bfSjmcp
4815a7763bfSjmcp /* CONSTCOND */
4825a7763bfSjmcp TAILQ_INSERT_TAIL(fw_pluginlist, tmpelem, nextplugin);
4835a7763bfSjmcp }
4845a7763bfSjmcp
4855a7763bfSjmcp if ((plugdir == NULL) && TAILQ_EMPTY(fw_pluginlist)) {
4865a7763bfSjmcp return (FWFLASH_FAILURE);
4875a7763bfSjmcp }
4885a7763bfSjmcp
4895a7763bfSjmcp if (errno != 0) {
4905a7763bfSjmcp logmsg(MSG_ERROR,
4915a7763bfSjmcp gettext("Error reading directory entry in %s\n"),
4925a7763bfSjmcp fwplugdirpath);
4935a7763bfSjmcp rval = errno;
4945a7763bfSjmcp }
4955a7763bfSjmcp
496d65b419eSXinChen free(fwplugdirpath);
4975a7763bfSjmcp (void) closedir(dirp);
4985a7763bfSjmcp return (rval);
4995a7763bfSjmcp }
5005a7763bfSjmcp
5015a7763bfSjmcp /*
5025a7763bfSjmcp * fwflash_load_verifier dlload()s the appropriate firmware image
5035a7763bfSjmcp * verification plugin, and attaches the designated fwimg's fd to
5045a7763bfSjmcp * the vrfyplugin structure so we only have to load the image in
5055a7763bfSjmcp * one place.
5065a7763bfSjmcp */
5075a7763bfSjmcp int
fwflash_load_verifier(char * drv,char * vendorid,char * fwimg)508f8bf33c3SShantkumar Hiremath fwflash_load_verifier(char *drv, char *vendorid, char *fwimg)
509f8bf33c3SShantkumar Hiremath {
5105a7763bfSjmcp
5115a7763bfSjmcp int rv = FWFLASH_FAILURE;
5125a7763bfSjmcp int imgfd;
5135a7763bfSjmcp char *fwvrfydirpath, *tempdirpath, *filename;
5145a7763bfSjmcp char *clean; /* for the space-removed vid */
5155a7763bfSjmcp struct stat fwstat;
5165a7763bfSjmcp struct vrfyplugin *vrfy;
5175a7763bfSjmcp void *vrfysym;
5185a7763bfSjmcp
5195a7763bfSjmcp /*
5205a7763bfSjmcp * To make flashing multiple firmware images somewhat more
5215a7763bfSjmcp * efficient, we start this function by checking whether a
5225a7763bfSjmcp * verifier for this device has already been loaded. If it
5235a7763bfSjmcp * has been loaded, we replace the imgfile information, and
5245a7763bfSjmcp * then continue as if we were loading for the first time.
5255a7763bfSjmcp */
5265a7763bfSjmcp
5275a7763bfSjmcp if (verifier != NULL) {
5285a7763bfSjmcp verifier->imgsize = 0;
5295a7763bfSjmcp verifier->flashbuf = 0; /* set by the verifier function */
5305a7763bfSjmcp
531d65b419eSXinChen if (verifier->imgfile != NULL) {
532d65b419eSXinChen free(verifier->imgfile);
533d65b419eSXinChen verifier->imgfile = NULL;
534d65b419eSXinChen }
5355a7763bfSjmcp
536d65b419eSXinChen if (verifier->fwimage != NULL) {
537d65b419eSXinChen free(verifier->fwimage);
538d65b419eSXinChen verifier->fwimage = NULL;
539d65b419eSXinChen }
5405a7763bfSjmcp } else {
5415a7763bfSjmcp if ((fwvrfydirpath = calloc(1, MAXPATHLEN + 1)) == NULL) {
5425a7763bfSjmcp logmsg(MSG_ERROR,
5435a7763bfSjmcp gettext("Unable to allocate space for a firmware "
544f8bf33c3SShantkumar Hiremath "verifier file(1)"));
5455a7763bfSjmcp return (rv);
5465a7763bfSjmcp }
5475a7763bfSjmcp
5485a7763bfSjmcp if ((filename = calloc(1, MAXPATHLEN + 1)) == NULL) {
5495a7763bfSjmcp logmsg(MSG_ERROR,
5505a7763bfSjmcp gettext("Unable to allocate space "
5515a7763bfSjmcp "for a firmware verifier file(2)"));
552d65b419eSXinChen free(fwvrfydirpath);
5535a7763bfSjmcp return (rv);
5545a7763bfSjmcp }
5555a7763bfSjmcp
556d65b419eSXinChen /*
557d65b419eSXinChen * Since SCSI devices can have a vendor id of up to 8
558d65b419eSXinChen * left-aligned and _space-padded_ characters, we first need to
559d65b419eSXinChen * strip off any space characters before we try to make a
560d65b419eSXinChen * filename out of it
561d65b419eSXinChen */
5625a7763bfSjmcp clean = strtok(vendorid, " ");
5635a7763bfSjmcp if (clean == NULL) {
5645a7763bfSjmcp /* invalid vendorid, something's really wrong */
5655a7763bfSjmcp logmsg(MSG_ERROR,
5665a7763bfSjmcp gettext("Invalid vendorid (null) specified for "
567f8bf33c3SShantkumar Hiremath "device\n"));
568d65b419eSXinChen free(filename);
569d65b419eSXinChen free(fwvrfydirpath);
5705a7763bfSjmcp return (rv);
5715a7763bfSjmcp }
5725a7763bfSjmcp
5735a7763bfSjmcp tempdirpath = getenv("FWVERIFYPLUGINDIR");
5745a7763bfSjmcp
5755a7763bfSjmcp if ((fwflash_debug > 0) && (tempdirpath != NULL)) {
5765a7763bfSjmcp (void) strlcpy(fwvrfydirpath, tempdirpath,
5775a7763bfSjmcp strlen(tempdirpath) + 1);
5785a7763bfSjmcp } else {
5795a7763bfSjmcp (void) strlcpy(fwvrfydirpath, FWVERIFYPLUGINDIR,
5805a7763bfSjmcp strlen(FWVERIFYPLUGINDIR) + 1);
5815a7763bfSjmcp }
5825a7763bfSjmcp
5835a7763bfSjmcp if ((vrfy = calloc(1, sizeof (struct vrfyplugin))) == NULL) {
5845a7763bfSjmcp logmsg(MSG_ERROR,
5855a7763bfSjmcp gettext("Unable to allocate space "
5865a7763bfSjmcp "for a firmware verifier structure"));
5875a7763bfSjmcp free(filename);
5885a7763bfSjmcp free(fwvrfydirpath);
589d65b419eSXinChen return (rv);
5905a7763bfSjmcp }
5915a7763bfSjmcp
5925a7763bfSjmcp errno = 0; /* false positive removal */
5935a7763bfSjmcp
594d65b419eSXinChen (void) snprintf(filename, MAXPATHLEN, "%s/%s-%s.so",
5955a7763bfSjmcp fwvrfydirpath, drv, clean);
596d65b419eSXinChen if ((vrfy->handle = dlopen(filename, RTLD_NOW)) == NULL) {
597d65b419eSXinChen logmsg(MSG_INFO, gettext(dlerror()));
598d65b419eSXinChen logmsg(MSG_INFO,
599d65b419eSXinChen gettext("\nUnable to open verification plugin "
600d65b419eSXinChen "%s. Looking for %s-GENERIC plugin instead.\n"),
601d65b419eSXinChen filename, drv);
602d65b419eSXinChen
603d65b419eSXinChen /* Try the drv-GENERIC.so form, _then_ die */
604d65b419eSXinChen bzero(filename, strlen(filename) + 1);
605d65b419eSXinChen (void) snprintf(filename, MAXPATHLEN,
606d65b419eSXinChen "%s/%s-GENERIC.so", fwvrfydirpath, drv);
607d65b419eSXinChen
608d65b419eSXinChen if ((vrfy->handle = dlopen(filename, RTLD_NOW))
609d65b419eSXinChen == NULL) {
610d65b419eSXinChen logmsg(MSG_INFO, gettext(dlerror()));
611d65b419eSXinChen logmsg(MSG_ERROR,
612d65b419eSXinChen gettext("\nUnable to open either "
613d65b419eSXinChen "verification plugin %s/%s-%s.so or "
614d65b419eSXinChen "generic plugin %s.\nUnable to verify "
615d65b419eSXinChen "firmware image. Aborting.\n"),
616d65b419eSXinChen fwvrfydirpath, drv, clean, filename);
617d65b419eSXinChen free(filename);
618d65b419eSXinChen free(fwvrfydirpath);
619d65b419eSXinChen return (rv);
620d65b419eSXinChen }
621d65b419eSXinChen }
6225a7763bfSjmcp
6235a7763bfSjmcp if ((vrfy->filename = calloc(1, strlen(filename) + 1))
6245a7763bfSjmcp == NULL) {
6255a7763bfSjmcp logmsg(MSG_ERROR,
6265a7763bfSjmcp gettext("Unable to allocate space to store "
627f8bf33c3SShantkumar Hiremath "a verifier filename\n"));
6285a7763bfSjmcp free(filename);
6295a7763bfSjmcp free(fwvrfydirpath);
6305a7763bfSjmcp free(vrfy->handle);
631d65b419eSXinChen return (rv);
6325a7763bfSjmcp }
6335a7763bfSjmcp (void) strlcpy(vrfy->filename, filename, strlen(filename) + 1);
6345a7763bfSjmcp
6355a7763bfSjmcp if ((vrfysym = dlsym(vrfy->handle, "vendorvrfy")) == NULL) {
6365a7763bfSjmcp logmsg(MSG_ERROR,
6375a7763bfSjmcp gettext("%s is an invalid firmware verification "
638f8bf33c3SShantkumar Hiremath "plugin."), filename);
6395a7763bfSjmcp (void) dlclose(vrfy->handle);
6405a7763bfSjmcp free(filename);
6415a7763bfSjmcp free(fwvrfydirpath);
6425a7763bfSjmcp free(vrfy);
643d65b419eSXinChen return (rv);
6445a7763bfSjmcp } else {
6455a7763bfSjmcp vrfy->vendorvrfy =
6465a7763bfSjmcp (int (*)(struct devicelist *))vrfysym;
6475a7763bfSjmcp }
6485a7763bfSjmcp
6495a7763bfSjmcp vrfysym = dlsym(vrfy->handle, "vendor");
6505a7763bfSjmcp
6515a7763bfSjmcp if (vrfysym == NULL) {
6525a7763bfSjmcp logmsg(MSG_ERROR,
6535a7763bfSjmcp gettext("Invalid vendor (null) in verification "
654f8bf33c3SShantkumar Hiremath "plugin %s\n"), filename);
6555a7763bfSjmcp (void) dlclose(vrfy->handle);
6565a7763bfSjmcp free(vrfy);
657d65b419eSXinChen return (rv);
6585a7763bfSjmcp } else {
6595a7763bfSjmcp if (strncmp(vendorid, (char *)vrfysym,
6605a7763bfSjmcp strlen(vendorid)) != 0) {
6615a7763bfSjmcp logmsg(MSG_INFO,
6625a7763bfSjmcp "Using a sym-linked (%s -> %s) "
663d65b419eSXinChen "verification plugin\n",
6645a7763bfSjmcp vendorid, vrfysym);
6655a7763bfSjmcp vrfy->vendor = calloc(1, strlen(vendorid) + 1);
6665a7763bfSjmcp } else {
6675a7763bfSjmcp vrfy->vendor = calloc(1, strlen(vrfysym) + 1);
6685a7763bfSjmcp }
6695a7763bfSjmcp (void) strlcpy(vrfy->vendor, (char *)vrfysym,
6705a7763bfSjmcp strlen(vendorid) + 1);
6715a7763bfSjmcp }
6725a7763bfSjmcp
6735a7763bfSjmcp verifier = vrfy; /* a convenience variable */
674d65b419eSXinChen free(filename);
675d65b419eSXinChen free(fwvrfydirpath);
6765a7763bfSjmcp }
6775a7763bfSjmcp
6785a7763bfSjmcp /*
6795a7763bfSjmcp * We don't do any verification that the fw image file is in
6805a7763bfSjmcp * an approved location, but it's easy enough to modify this
6815a7763bfSjmcp * function to do so. The verification plugin should provide
6825a7763bfSjmcp * sufficient protection.
6835a7763bfSjmcp */
6845a7763bfSjmcp
6855a7763bfSjmcp if ((imgfd = open(fwimg, O_RDONLY)) < 0) {
6865a7763bfSjmcp logmsg(MSG_ERROR,
6875a7763bfSjmcp gettext("Unable to open designated firmware "
688f8bf33c3SShantkumar Hiremath "image file %s: %s\n"),
6895a7763bfSjmcp (fwimg != NULL) ? fwimg : "(null)",
6905a7763bfSjmcp strerror(errno));
6915a7763bfSjmcp rv = FWFLASH_FAILURE;
6925a7763bfSjmcp goto cleanup;
6935a7763bfSjmcp }
6945a7763bfSjmcp
6955a7763bfSjmcp if (stat(fwimg, &fwstat) == -1) {
6965a7763bfSjmcp logmsg(MSG_ERROR,
6975a7763bfSjmcp gettext("Unable to stat() firmware image file "
698f8bf33c3SShantkumar Hiremath "%s: %s\n"),
6995a7763bfSjmcp fwimg, strerror(errno));
7005a7763bfSjmcp rv = FWFLASH_FAILURE;
7015a7763bfSjmcp goto cleanup;
7025a7763bfSjmcp } else {
7035a7763bfSjmcp verifier->imgsize = fwstat.st_size;
7045a7763bfSjmcp if ((verifier->fwimage = calloc(1, verifier->imgsize))
7055a7763bfSjmcp == NULL) {
7065a7763bfSjmcp logmsg(MSG_ERROR,
7075a7763bfSjmcp gettext("Unable to load firmware image "
708f8bf33c3SShantkumar Hiremath "%s: %s\n"),
7095a7763bfSjmcp fwimg, strerror(errno));
7105a7763bfSjmcp rv = FWFLASH_FAILURE;
7115a7763bfSjmcp goto cleanup;
7125a7763bfSjmcp }
7135a7763bfSjmcp }
7145a7763bfSjmcp
7155a7763bfSjmcp errno = 0;
7165a7763bfSjmcp if ((rv = read(imgfd, verifier->fwimage,
7175a7763bfSjmcp (size_t)verifier->imgsize)) < verifier->imgsize) {
7185a7763bfSjmcp /* we haven't read enough data, bail */
7195a7763bfSjmcp logmsg(MSG_ERROR,
7205a7763bfSjmcp gettext("Failed to read sufficient data "
721f8bf33c3SShantkumar Hiremath "(got %d bytes, expected %d bytes) from "
722f8bf33c3SShantkumar Hiremath "firmware image file %s: %s\n"),
7235a7763bfSjmcp rv, verifier->imgsize,
724d65b419eSXinChen verifier->filename, strerror(errno));
7255a7763bfSjmcp rv = FWFLASH_FAILURE;
7265a7763bfSjmcp } else {
7275a7763bfSjmcp rv = FWFLASH_SUCCESS;
7285a7763bfSjmcp }
7295a7763bfSjmcp
7305a7763bfSjmcp if ((verifier->imgfile = calloc(1, strlen(fwimg) + 1)) == NULL) {
7315a7763bfSjmcp logmsg(MSG_ERROR,
7325a7763bfSjmcp gettext("Unable to save name of firmware image\n"));
7335a7763bfSjmcp rv = FWFLASH_FAILURE;
7345a7763bfSjmcp } else {
7355a7763bfSjmcp (void) strlcpy(verifier->imgfile, fwimg, strlen(fwimg) + 1);
7365a7763bfSjmcp }
7375a7763bfSjmcp
7385a7763bfSjmcp if (rv != FWFLASH_SUCCESS) {
7395a7763bfSjmcp /* cleanup and let's get outta here */
7405a7763bfSjmcp cleanup:
7415a7763bfSjmcp free(verifier->filename);
7425a7763bfSjmcp free(verifier->vendor);
7435a7763bfSjmcp
744d65b419eSXinChen if (!(fwflash_arg_list & FWFLASH_READ_FLAG) &&
745d65b419eSXinChen verifier->fwimage)
7465a7763bfSjmcp free(verifier->fwimage);
7475a7763bfSjmcp
7485a7763bfSjmcp verifier->filename = NULL;
7495a7763bfSjmcp verifier->vendor = NULL;
7505a7763bfSjmcp verifier->vendorvrfy = NULL;
7515a7763bfSjmcp verifier->fwimage = NULL;
7525a7763bfSjmcp (void) dlclose(verifier->handle);
7535a7763bfSjmcp verifier->handle = NULL;
7545a7763bfSjmcp free(verifier);
7555a7763bfSjmcp if (imgfd >= 0) {
7565a7763bfSjmcp (void) close(imgfd);
7575a7763bfSjmcp }
7585a7763bfSjmcp verifier = NULL;
7595a7763bfSjmcp }
7605a7763bfSjmcp
7615a7763bfSjmcp return (rv);
7625a7763bfSjmcp }
7635a7763bfSjmcp
7645a7763bfSjmcp /*
7655a7763bfSjmcp * cycles through the global list of plugins to find
7665a7763bfSjmcp * each flashable device, which is added to fw_devices
7675a7763bfSjmcp *
7685a7763bfSjmcp * Each plugin's identify routine must allocated storage
7695a7763bfSjmcp * as required.
7705a7763bfSjmcp *
7715a7763bfSjmcp * Each plugin's identify routine must return
7725a7763bfSjmcp * FWFLASH_FAILURE if it cannot find any devices
7735a7763bfSjmcp * which it handles.
7745a7763bfSjmcp */
7755a7763bfSjmcp static int
flash_device_list()7765a7763bfSjmcp flash_device_list()
7775a7763bfSjmcp {
7785a7763bfSjmcp int rv = FWFLASH_FAILURE;
7795a7763bfSjmcp int startidx = 0;
7805a7763bfSjmcp int sumrv = 0;
7815a7763bfSjmcp struct pluginlist *plugins;
7825a7763bfSjmcp
7835a7763bfSjmcp /* we open rootnode here, and close it in fwflash_intr */
784d65b419eSXinChen if ((rootnode = di_init("/", DINFOCPYALL|DINFOFORCE)) == DI_NODE_NIL) {
7855a7763bfSjmcp logmsg(MSG_ERROR,
7865a7763bfSjmcp gettext("Unable to take device tree snapshot: %s\n"),
7875a7763bfSjmcp strerror(errno));
7885a7763bfSjmcp return (rv);
7895a7763bfSjmcp }
7905a7763bfSjmcp
7915a7763bfSjmcp if ((fw_devices = calloc(1, sizeof (struct devicelist))) == NULL) {
7925a7763bfSjmcp logmsg(MSG_ERROR,
7935a7763bfSjmcp gettext("Unable to malloc %d bytes while "
7945a7763bfSjmcp "trying to find devices: %s\n"),
7955a7763bfSjmcp sizeof (struct devicelist), strerror(errno));
7965a7763bfSjmcp return (FWFLASH_FAILURE);
7975a7763bfSjmcp }
7985a7763bfSjmcp
7995a7763bfSjmcp /* CONSTCOND */
8005a7763bfSjmcp TAILQ_INIT(fw_devices);
8015a7763bfSjmcp
8025a7763bfSjmcp TAILQ_FOREACH(plugins, fw_pluginlist, nextplugin) {
8035a7763bfSjmcp self = plugins->plugin;
8045a7763bfSjmcp rv = plugins->plugin->fw_identify(startidx);
8055a7763bfSjmcp
8065a7763bfSjmcp logmsg(MSG_INFO,
8075a7763bfSjmcp gettext("fwflash:flash_device_list() got %d from "
8085a7763bfSjmcp "identify routine\n"), rv);
8095a7763bfSjmcp
8105a7763bfSjmcp /* only bump startidx if we've found at least one device */
8115a7763bfSjmcp if (rv == FWFLASH_SUCCESS) {
8125a7763bfSjmcp startidx += 100;
8135a7763bfSjmcp sumrv++;
8145a7763bfSjmcp } else {
8155a7763bfSjmcp logmsg(MSG_INFO,
8165a7763bfSjmcp gettext("No flashable devices attached with "
8175a7763bfSjmcp "the %s driver in this system\n"),
8185a7763bfSjmcp plugins->drvname);
8195a7763bfSjmcp }
8205a7763bfSjmcp }
8215a7763bfSjmcp
8225a7763bfSjmcp if (sumrv > 0)
8235a7763bfSjmcp rv = FWFLASH_SUCCESS;
8245a7763bfSjmcp
8255a7763bfSjmcp return (rv);
8265a7763bfSjmcp }
8275a7763bfSjmcp
8285a7763bfSjmcp static int
fwflash_list_fw(char * class)8295a7763bfSjmcp fwflash_list_fw(char *class)
8305a7763bfSjmcp {
8315a7763bfSjmcp int rv = 0;
8325a7763bfSjmcp struct devicelist *curdev;
8335a7763bfSjmcp int header = 1;
8345a7763bfSjmcp
8355a7763bfSjmcp TAILQ_FOREACH(curdev, fw_devices, nextdev) {
8365a7763bfSjmcp
8375a7763bfSjmcp /* we're either class-conscious, or we're not */
8385a7763bfSjmcp if (((class != NULL) &&
8395a7763bfSjmcp ((strncmp(curdev->classname, "ALL", 3) == 0) ||
8405a7763bfSjmcp (strcmp(curdev->classname, class) == 0))) ||
8415a7763bfSjmcp (class == NULL)) {
8425a7763bfSjmcp
8435a7763bfSjmcp if (header != 0) {
8445a7763bfSjmcp (void) fprintf(stdout,
8455a7763bfSjmcp gettext("List of available devices:\n"));
8465a7763bfSjmcp header--;
8475a7763bfSjmcp }
8485a7763bfSjmcp /*
8495a7763bfSjmcp * If any plugin's fw_devinfo() function returns
8505a7763bfSjmcp * FWFLASH_FAILURE then we want to keep track of
8515a7763bfSjmcp * it. _Most_ plugins should always return
8525a7763bfSjmcp * FWFLASH_SUCCESS from this function. The only
8535a7763bfSjmcp * exception known at this point is the tavor plugin.
8545a7763bfSjmcp */
8555a7763bfSjmcp rv += curdev->plugin->fw_devinfo(curdev);
8565a7763bfSjmcp }
8575a7763bfSjmcp }
8585a7763bfSjmcp return (rv);
8595a7763bfSjmcp }
8605a7763bfSjmcp
8615a7763bfSjmcp static int
fwflash_update(char * device,char * filename,int flags)862f1c23465SJames C. McPherson fwflash_update(char *device, char *filename, int flags)
863f1c23465SJames C. McPherson {
8645a7763bfSjmcp
8655a7763bfSjmcp int rv = FWFLASH_FAILURE;
8665a7763bfSjmcp int needsfree = 0;
867c4800545Sjmcp int found = 0;
8685a7763bfSjmcp struct devicelist *curdev;
8695a7763bfSjmcp char *realfile;
8705a7763bfSjmcp
8715a7763bfSjmcp /*
8725a7763bfSjmcp * Here's how we operate:
8735a7763bfSjmcp *
8745a7763bfSjmcp * We perform some basic checks on the args, then walk
8755a7763bfSjmcp * through the device list looking for the device which
8765a7763bfSjmcp * matches. We then load the appropriate verifier for the
8775a7763bfSjmcp * image file and device, verify the image, then call the
8785a7763bfSjmcp * fw_writefw() function of the appropriate plugin.
8795a7763bfSjmcp *
8805a7763bfSjmcp * There is no "force" flag to enable you to flash a firmware
8815a7763bfSjmcp * image onto an incompatible device because the verifier
8825a7763bfSjmcp * will return FWFLASH_FAILURE if the image doesn't match.
8835a7763bfSjmcp */
8845a7763bfSjmcp
8855a7763bfSjmcp /* new firmware filename and device desc */
8865a7763bfSjmcp if (filename == NULL) {
8875a7763bfSjmcp logmsg(MSG_ERROR,
8885a7763bfSjmcp gettext("Invalid firmware filename (null)\n"));
8895a7763bfSjmcp return (FWFLASH_FAILURE);
8905a7763bfSjmcp }
8915a7763bfSjmcp
8925a7763bfSjmcp if (device == NULL) {
8935a7763bfSjmcp logmsg(MSG_ERROR,
8945a7763bfSjmcp gettext("Invalid device requested (null)\n"));
8955a7763bfSjmcp return (FWFLASH_FAILURE);
8965a7763bfSjmcp }
8975a7763bfSjmcp
8985a7763bfSjmcp if ((realfile = calloc(1, PATH_MAX + 1)) == NULL) {
8995a7763bfSjmcp logmsg(MSG_ERROR,
9005a7763bfSjmcp gettext("Unable to allocate space for device "
901f1c23465SJames C. McPherson "filename, operation might fail if %s is"
902f1c23465SJames C. McPherson "a symbolic link\n"),
9035a7763bfSjmcp device);
9045a7763bfSjmcp realfile = device;
9055a7763bfSjmcp } else {
9065a7763bfSjmcp /*
9075a7763bfSjmcp * If realpath() succeeds, then we have a valid
9085a7763bfSjmcp * device filename in realfile.
9095a7763bfSjmcp */
9105a7763bfSjmcp if (realpath(device, realfile) == NULL) {
9115a7763bfSjmcp logmsg(MSG_ERROR,
9125a7763bfSjmcp gettext("Unable to resolve device filename"
913f1c23465SJames C. McPherson ": %s\n"),
9145a7763bfSjmcp strerror(errno));
9155a7763bfSjmcp /* tidy up */
9165a7763bfSjmcp free(realfile);
9175a7763bfSjmcp /* realpath didn't succeed, use fallback */
9185a7763bfSjmcp realfile = device;
9195a7763bfSjmcp } else {
9205a7763bfSjmcp needsfree = 1;
9215a7763bfSjmcp }
9225a7763bfSjmcp }
9235a7763bfSjmcp
9245a7763bfSjmcp logmsg(MSG_INFO,
9255a7763bfSjmcp gettext("fwflash_update: fw_filename (%s) device (%s)\n"),
9265a7763bfSjmcp filename, device);
9275a7763bfSjmcp
9285a7763bfSjmcp TAILQ_FOREACH(curdev, fw_devices, nextdev) {
9295a7763bfSjmcp if (strcmp(curdev->access_devname, realfile) == 0) {
930c4800545Sjmcp found++;
9315a7763bfSjmcp rv = fwflash_load_verifier(curdev->drvname,
9325a7763bfSjmcp curdev->ident->vid, filename);
9335a7763bfSjmcp if (rv == FWFLASH_FAILURE) {
9345a7763bfSjmcp logmsg(MSG_ERROR,
9355a7763bfSjmcp gettext("Unable to load verifier "
936f1c23465SJames C. McPherson "for device %s\n"),
9375a7763bfSjmcp curdev->access_devname);
9385a7763bfSjmcp return (FWFLASH_FAILURE);
9395a7763bfSjmcp }
9405a7763bfSjmcp rv = verifier->vendorvrfy(curdev);
9415a7763bfSjmcp if (rv == FWFLASH_FAILURE) {
9425a7763bfSjmcp /* the verifier prints a message */
9435a7763bfSjmcp logmsg(MSG_INFO,
9445a7763bfSjmcp "verifier (%s) for %s :: %s returned "
9455a7763bfSjmcp "FWFLASH_FAILURE\n",
9465a7763bfSjmcp verifier->filename,
9475a7763bfSjmcp filename, curdev->access_devname);
9485a7763bfSjmcp return (rv);
9495a7763bfSjmcp }
9505a7763bfSjmcp
951f1c23465SJames C. McPherson if (((flags & FWFLASH_YES_FLAG) == FWFLASH_YES_FLAG) ||
9525a7763bfSjmcp (rv = confirm_target(curdev, filename)) ==
9535a7763bfSjmcp FWFLASH_YES_FLAG) {
9545a7763bfSjmcp logmsg(MSG_INFO,
9555a7763bfSjmcp "about to flash using plugin %s\n",
9565a7763bfSjmcp curdev->plugin->filename);
9575a7763bfSjmcp rv = curdev->plugin->fw_writefw(curdev,
9585a7763bfSjmcp filename);
9595a7763bfSjmcp if (rv == FWFLASH_FAILURE) {
9605a7763bfSjmcp logmsg(MSG_ERROR,
9615a7763bfSjmcp gettext("Failed to flash "
962f1c23465SJames C. McPherson "firmware file %s on "
963f1c23465SJames C. McPherson "device %s: %d\n"),
9645a7763bfSjmcp filename,
9655a7763bfSjmcp curdev->access_devname, rv);
9665a7763bfSjmcp }
9675a7763bfSjmcp } else {
9685a7763bfSjmcp logmsg(MSG_ERROR,
9695a7763bfSjmcp gettext("Flash operation not confirmed "
970f1c23465SJames C. McPherson "by user\n"),
9715a7763bfSjmcp curdev->access_devname);
9725a7763bfSjmcp rv = FWFLASH_FAILURE;
9735a7763bfSjmcp }
9745a7763bfSjmcp }
9755a7763bfSjmcp }
9765a7763bfSjmcp
977c4800545Sjmcp if (!found)
978c4800545Sjmcp /* report the same device that the user passed in */
979c4800545Sjmcp logmsg(MSG_ERROR,
980c4800545Sjmcp gettext("Device %s does not appear "
981c4800545Sjmcp "to be flashable\n"),
982c4800545Sjmcp ((strncmp(device, realfile, strlen(device)) == 0) ?
983d65b419eSXinChen realfile : device));
984c4800545Sjmcp
9855a7763bfSjmcp if (needsfree)
9865a7763bfSjmcp free(realfile);
9875a7763bfSjmcp
9885a7763bfSjmcp return (rv);
9895a7763bfSjmcp }
9905a7763bfSjmcp
9915a7763bfSjmcp /*
9925a7763bfSjmcp * We validate that the device path is in our global device list and
9935a7763bfSjmcp * that the filename exists, then palm things off to the relevant plugin.
9945a7763bfSjmcp */
9955a7763bfSjmcp static int
fwflash_read_file(char * device,char * filename)9965a7763bfSjmcp fwflash_read_file(char *device, char *filename)
9975a7763bfSjmcp {
9985a7763bfSjmcp struct devicelist *curdev;
9995a7763bfSjmcp int rv;
1000f8bf33c3SShantkumar Hiremath int found = 0;
10015a7763bfSjmcp
10025a7763bfSjmcp /* new firmware filename and device desc */
10035a7763bfSjmcp
10045a7763bfSjmcp TAILQ_FOREACH(curdev, fw_devices, nextdev) {
10055a7763bfSjmcp if (strncmp(curdev->access_devname, device,
10065a7763bfSjmcp MAXPATHLEN) == 0) {
10075a7763bfSjmcp rv = curdev->plugin->fw_readfw(curdev, filename);
10085a7763bfSjmcp
10095a7763bfSjmcp if (rv != FWFLASH_SUCCESS)
10105a7763bfSjmcp logmsg(MSG_ERROR,
10115a7763bfSjmcp gettext("Unable to write out firmware "
10125a7763bfSjmcp "image for %s to file %s\n"),
10135a7763bfSjmcp curdev->access_devname, filename);
1014f8bf33c3SShantkumar Hiremath found++;
10155a7763bfSjmcp }
10165a7763bfSjmcp
10175a7763bfSjmcp }
1018f8bf33c3SShantkumar Hiremath
1019f8bf33c3SShantkumar Hiremath if (!found) {
10205a7763bfSjmcp logmsg(MSG_ERROR,
10215a7763bfSjmcp gettext("No device matching %s was found.\n"),
10225a7763bfSjmcp device);
10235a7763bfSjmcp rv = FWFLASH_FAILURE;
10245a7763bfSjmcp }
10255a7763bfSjmcp
10265a7763bfSjmcp return (rv);
10275a7763bfSjmcp }
10285a7763bfSjmcp
10295a7763bfSjmcp static void
fwflash_usage(char * arg)10305a7763bfSjmcp fwflash_usage(char *arg)
10315a7763bfSjmcp {
10325a7763bfSjmcp
10335a7763bfSjmcp (void) fprintf(stderr, "\n");
10345a7763bfSjmcp if (arg != NULL) {
10355a7763bfSjmcp logmsg(MSG_ERROR,
10365a7763bfSjmcp gettext("Invalid argument (%s) supplied\n"), arg);
10375a7763bfSjmcp }
10385a7763bfSjmcp
10395a7763bfSjmcp (void) fprintf(stderr, "\n");
10405a7763bfSjmcp
10415a7763bfSjmcp (void) fprintf(stdout, gettext("Usage:\n\t"));
10425a7763bfSjmcp (void) fprintf(stdout, gettext("fwflash [-l [-c device_class "
10435a7763bfSjmcp "| ALL]] | [-v] | [-h]\n\t"));
10445a7763bfSjmcp (void) fprintf(stdout, gettext("fwflash [-f file1,file2,file3"
10455a7763bfSjmcp ",... | -r file] [-y] -d device_path\n\n"));
10465a7763bfSjmcp (void) fprintf(stdout, "\n"); /* workaround for xgettext */
10475a7763bfSjmcp
10485a7763bfSjmcp (void) fprintf(stdout,
10495a7763bfSjmcp gettext("\t-l\t\tlist flashable devices in this system\n"
10505a7763bfSjmcp "\t-c device_class limit search to a specific class\n"
10515a7763bfSjmcp "\t\t\teg IB for InfiniBand, ses for SCSI Enclosures\n"
10525a7763bfSjmcp "\t-v\t\tprint version number of fwflash utility\n"
1053f8bf33c3SShantkumar Hiremath "\t-h\t\tprint this usage message\n\n"));
10545a7763bfSjmcp (void) fprintf(stdout,
10555a7763bfSjmcp gettext("\t-f file1,file2,file3,...\n"
10565a7763bfSjmcp "\t\t\tfirmware image file list to flash\n"
10575a7763bfSjmcp "\t-r file\t\tfile to dump device firmware to\n"
10585a7763bfSjmcp "\t-y\t\tanswer Yes/Y/y to prompts\n"
10595a7763bfSjmcp "\t-d device_path\tpathname of device to be flashed\n\n"));
10605a7763bfSjmcp
10615a7763bfSjmcp (void) fprintf(stdout,
10625a7763bfSjmcp gettext("\tIf -d device_path is specified, then one of -f "
10635a7763bfSjmcp "<files>\n"
10645a7763bfSjmcp "\tor -r <file> must also be specified\n\n"));
10655a7763bfSjmcp
10665a7763bfSjmcp (void) fprintf(stdout,
10675a7763bfSjmcp gettext("\tIf multiple firmware images are required to be "
10685a7763bfSjmcp "flashed\n"
10695a7763bfSjmcp "\tthey must be listed together, separated by commas. The\n"
10705a7763bfSjmcp "\timages will be flashed in the order specified.\n\n"));
10715a7763bfSjmcp
10725a7763bfSjmcp (void) fprintf(stdout, "\n");
10735a7763bfSjmcp }
10745a7763bfSjmcp
10755a7763bfSjmcp static void
fwflash_version(void)10765a7763bfSjmcp fwflash_version(void)
10775a7763bfSjmcp {
10785a7763bfSjmcp (void) fprintf(stdout, gettext("\n%s: "), FWFLASH_PROG_NAME);
10795a7763bfSjmcp (void) fprintf(stdout, gettext("version %s\n"),
10805a7763bfSjmcp FWFLASH_VERSION);
10815a7763bfSjmcp }
10825a7763bfSjmcp
10835a7763bfSjmcp static void
fwflash_intr(int sig)10845a7763bfSjmcp fwflash_intr(int sig)
10855a7763bfSjmcp {
10865a7763bfSjmcp
10878d55b806SRobert Mustacchi struct devicelist *thisdev, *tmpdev;
10888d55b806SRobert Mustacchi struct pluginlist *thisplug, *tmpplug;
10895a7763bfSjmcp
10905a7763bfSjmcp (void) signal(SIGINT, SIG_IGN);
10915a7763bfSjmcp (void) signal(SIGTERM, SIG_IGN);
1092c4800545Sjmcp (void) signal(SIGABRT, SIG_IGN);
1093d65b419eSXinChen
10945a7763bfSjmcp if (fwflash_in_write) {
10955a7763bfSjmcp (void) fprintf(stderr,
10965a7763bfSjmcp gettext("WARNING: firmware image may be corrupted\n\t"));
10975a7763bfSjmcp (void) fprintf(stderr,
10985a7763bfSjmcp gettext("Reflash firmware before rebooting!\n"));
10995a7763bfSjmcp }
11005a7763bfSjmcp
11015a7763bfSjmcp if (sig > 0) {
11025a7763bfSjmcp (void) logmsg(MSG_ERROR, gettext("\n"));
11035a7763bfSjmcp (void) logmsg(MSG_ERROR,
11045a7763bfSjmcp gettext("fwflash exiting due to signal (%d)\n"), sig);
11055a7763bfSjmcp }
11065a7763bfSjmcp
11075a7763bfSjmcp /*
11085a7763bfSjmcp * we need to close everything down properly, so
11095a7763bfSjmcp * call the plugin closure routines
11105a7763bfSjmcp */
11115a7763bfSjmcp if (fw_devices != NULL) {
11128d55b806SRobert Mustacchi TAILQ_FOREACH_SAFE(thisdev, fw_devices, nextdev, tmpdev) {
11138d55b806SRobert Mustacchi TAILQ_REMOVE(fw_devices, thisdev, nextdev);
1114d65b419eSXinChen if (thisdev->plugin->fw_cleanup != NULL) {
1115d65b419eSXinChen /*
1116d65b419eSXinChen * If we've got a cleanup routine, it
1117d65b419eSXinChen * cleans up _everything_ for thisdev
1118d65b419eSXinChen */
1119d65b419eSXinChen thisdev->plugin->fw_cleanup(thisdev);
1120d65b419eSXinChen } else {
1121d65b419eSXinChen /* free the components first */
1122d65b419eSXinChen free(thisdev->access_devname);
1123d65b419eSXinChen free(thisdev->drvname);
1124d65b419eSXinChen free(thisdev->classname);
1125d65b419eSXinChen if (thisdev->ident != NULL)
1126d65b419eSXinChen free(thisdev->ident);
1127d65b419eSXinChen /* We don't free address[] for old plugins */
1128d65b419eSXinChen thisdev->ident = NULL;
1129d65b419eSXinChen thisdev->plugin = NULL;
11308d55b806SRobert Mustacchi free(thisdev);
1131d65b419eSXinChen }
11325a7763bfSjmcp }
11335a7763bfSjmcp }
11345a7763bfSjmcp
11355a7763bfSjmcp if (fw_pluginlist != NULL) {
11368d55b806SRobert Mustacchi TAILQ_FOREACH_SAFE(thisplug, fw_pluginlist, nextplugin,
11378d55b806SRobert Mustacchi tmpplug) {
11388d55b806SRobert Mustacchi TAILQ_REMOVE(fw_pluginlist, thisplug, nextplugin);
11395a7763bfSjmcp free(thisplug->filename);
11405a7763bfSjmcp free(thisplug->drvname);
11415a7763bfSjmcp free(thisplug->plugin->filename);
11425a7763bfSjmcp free(thisplug->plugin->drvname);
11435a7763bfSjmcp thisplug->filename = NULL;
11445a7763bfSjmcp thisplug->drvname = NULL;
11455a7763bfSjmcp thisplug->plugin->filename = NULL;
11465a7763bfSjmcp thisplug->plugin->drvname = NULL;
11475a7763bfSjmcp thisplug->plugin->fw_readfw = NULL;
11485a7763bfSjmcp thisplug->plugin->fw_writefw = NULL;
11495a7763bfSjmcp thisplug->plugin->fw_identify = NULL;
11505a7763bfSjmcp thisplug->plugin->fw_devinfo = NULL;
1151d65b419eSXinChen thisplug->plugin->fw_cleanup = NULL;
11525a7763bfSjmcp (void) dlclose(thisplug->plugin->handle);
11535a7763bfSjmcp thisplug->plugin->handle = NULL;
11545a7763bfSjmcp free(thisplug->plugin);
11555a7763bfSjmcp thisplug->plugin = NULL;
11568d55b806SRobert Mustacchi free(thisplug);
11575a7763bfSjmcp }
11585a7763bfSjmcp }
11595a7763bfSjmcp
11605a7763bfSjmcp if (verifier != NULL) {
11615a7763bfSjmcp free(verifier->filename);
11625a7763bfSjmcp free(verifier->vendor);
1163c4800545Sjmcp free(verifier->imgfile);
1164c4800545Sjmcp free(verifier->fwimage);
11655a7763bfSjmcp verifier->filename = NULL;
11665a7763bfSjmcp verifier->vendor = NULL;
11675a7763bfSjmcp verifier->vendorvrfy = NULL;
1168c4800545Sjmcp verifier->imgfile = NULL;
1169c4800545Sjmcp verifier->fwimage = NULL;
11705a7763bfSjmcp (void) dlclose(verifier->handle);
11715a7763bfSjmcp verifier->handle = NULL;
11725a7763bfSjmcp free(verifier);
11735a7763bfSjmcp }
11745a7763bfSjmcp di_fini(rootnode);
1175d65b419eSXinChen
1176d65b419eSXinChen if (sig > 0)
1177d65b419eSXinChen exit(FWFLASH_FAILURE);
11785a7763bfSjmcp }
11795a7763bfSjmcp
11805a7763bfSjmcp static void
fwflash_handle_signals(void)11815a7763bfSjmcp fwflash_handle_signals(void)
11825a7763bfSjmcp {
11835a7763bfSjmcp if (signal(SIGINT, fwflash_intr) == SIG_ERR) {
11845a7763bfSjmcp perror("signal");
11855a7763bfSjmcp exit(FWFLASH_FAILURE);
11865a7763bfSjmcp }
11875a7763bfSjmcp
11885a7763bfSjmcp if (signal(SIGTERM, fwflash_intr) == SIG_ERR) {
11895a7763bfSjmcp perror("signal");
11905a7763bfSjmcp exit(FWFLASH_FAILURE);
11915a7763bfSjmcp }
11925a7763bfSjmcp }
11935a7763bfSjmcp
11945a7763bfSjmcp static int
confirm_target(struct devicelist * thisdev,char * file)11955a7763bfSjmcp confirm_target(struct devicelist *thisdev, char *file)
11965a7763bfSjmcp {
11975a7763bfSjmcp int resp;
11985a7763bfSjmcp
1199c4800545Sjmcp (void) fflush(stdin);
1200c4800545Sjmcp (void) printf(gettext("About to update firmware on %s\n"),
1201c4800545Sjmcp thisdev->access_devname);
1202d65b419eSXinChen (void) printf(gettext("with file %s.\n"
1203d65b419eSXinChen "Do you want to continue? (Y/N): "), file);
12045a7763bfSjmcp
12055a7763bfSjmcp resp = getchar();
12065a7763bfSjmcp if (resp == 'Y' || resp == 'y') {
12075a7763bfSjmcp return (FWFLASH_YES_FLAG);
12085a7763bfSjmcp } else {
12095a7763bfSjmcp logmsg(MSG_INFO, "flash operation NOT confirmed.\n");
12105a7763bfSjmcp }
12115a7763bfSjmcp
12125a7763bfSjmcp (void) fflush(stdin);
12135a7763bfSjmcp return (FWFLASH_FAILURE);
12145a7763bfSjmcp }
12155a7763bfSjmcp
12165a7763bfSjmcp int
get_fileopts(char * options)12175a7763bfSjmcp get_fileopts(char *options)
12185a7763bfSjmcp {
12195a7763bfSjmcp
12205a7763bfSjmcp int i;
12215a7763bfSjmcp char *files;
12225a7763bfSjmcp
12235a7763bfSjmcp if (files = strtok(options, ",")) {
12245a7763bfSjmcp /* we have more than one */
12255a7763bfSjmcp if ((filelist[0] = calloc(1, MAXPATHLEN + 1)) == NULL) {
12265a7763bfSjmcp logmsg(MSG_ERROR,
12275a7763bfSjmcp gettext("Unable to allocate space for "
12285a7763bfSjmcp "a firmware image filename\n"));
12295a7763bfSjmcp return (FWFLASH_FAILURE);
12305a7763bfSjmcp }
12315a7763bfSjmcp (void) strlcpy(filelist[0], files, strlen(files) + 1);
12325a7763bfSjmcp i = 1;
12335a7763bfSjmcp
12345a7763bfSjmcp logmsg(MSG_INFO, "fwflash: filelist[0]: %s\n",
12355a7763bfSjmcp filelist[0]);
12365a7763bfSjmcp
12375a7763bfSjmcp
12385a7763bfSjmcp while (files = strtok(NULL, ",")) {
12395a7763bfSjmcp if ((filelist[i] = calloc(1, MAXPATHLEN + 1))
12405a7763bfSjmcp == NULL) {
12415a7763bfSjmcp logmsg(MSG_ERROR,
12425a7763bfSjmcp gettext("Unable to allocate space for "
12435a7763bfSjmcp "a firmware image filename\n"));
12445a7763bfSjmcp return (FWFLASH_FAILURE);
12455a7763bfSjmcp }
12465a7763bfSjmcp (void) strlcpy(filelist[i], files,
12475a7763bfSjmcp strlen(files) + 1);
12485a7763bfSjmcp logmsg(MSG_INFO, "fwflash: filelist[%d]: %s\n",
12495a7763bfSjmcp i, filelist[i]);
12505a7763bfSjmcp ++i;
12515a7763bfSjmcp }
12525a7763bfSjmcp } else {
12535a7763bfSjmcp if ((filelist[0] = calloc(1, MAXPATHLEN + 1)) == NULL) {
12545a7763bfSjmcp logmsg(MSG_ERROR,
12555a7763bfSjmcp gettext("Unable to allocate space for "
12565a7763bfSjmcp "a firmware image filename\n"));
12575a7763bfSjmcp return (FWFLASH_FAILURE);
12585a7763bfSjmcp }
12595a7763bfSjmcp (void) strlcpy(filelist[0], options, strlen(files) + 1);
12605a7763bfSjmcp logmsg(MSG_INFO, "fwflash: filelist[0]: %s\n",
12615a7763bfSjmcp filelist[0]);
12625a7763bfSjmcp }
12635a7763bfSjmcp return (FWFLASH_SUCCESS);
12645a7763bfSjmcp }
12655a7763bfSjmcp
12665a7763bfSjmcp /*
12675a7763bfSjmcp * code reuse - cheerfully borrowed from stmsboot_util.c
12685a7763bfSjmcp */
12695a7763bfSjmcp void
logmsg(int severity,const char * msg,...)1270d65b419eSXinChen logmsg(int severity, const char *msg, ...)
1271d65b419eSXinChen {
12725a7763bfSjmcp va_list ap;
12735a7763bfSjmcp
12745a7763bfSjmcp if ((severity > MSG_INFO) ||
12755a7763bfSjmcp ((severity == MSG_INFO) && (fwflash_debug > 0))) {
12765a7763bfSjmcp (void) fprintf(stderr, "%s: ", FWFLASH_PROG_NAME);
12775a7763bfSjmcp va_start(ap, msg);
12785a7763bfSjmcp (void) vfprintf(stderr, msg, ap);
12795a7763bfSjmcp va_end(ap);
12805a7763bfSjmcp }
12815a7763bfSjmcp }
1282