16489Sjmcp /* 26489Sjmcp * CDDL HEADER START 36489Sjmcp * 46489Sjmcp * The contents of this file are subject to the terms of the 56489Sjmcp * Common Development and Distribution License (the "License"). 66489Sjmcp * You may not use this file except in compliance with the License. 76489Sjmcp * 86489Sjmcp * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 96489Sjmcp * or http://www.opensolaris.org/os/licensing. 106489Sjmcp * See the License for the specific language governing permissions 116489Sjmcp * and limitations under the License. 126489Sjmcp * 136489Sjmcp * When distributing Covered Code, include this CDDL HEADER in each 146489Sjmcp * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 156489Sjmcp * If applicable, add the following below this CDDL HEADER, with the 166489Sjmcp * fields enclosed by brackets "[]" replaced with your own identifying 176489Sjmcp * information: Portions Copyright [yyyy] [name of copyright owner] 186489Sjmcp * 196489Sjmcp * CDDL HEADER END 206489Sjmcp */ 216489Sjmcp /* 226489Sjmcp * Copyright 2008 Sun Microsystems, Inc. All rights reserved. 236489Sjmcp * Use is subject to license terms. 246489Sjmcp */ 256489Sjmcp 266489Sjmcp /* 276489Sjmcp * fwflash.c 286489Sjmcp */ 296489Sjmcp #include <stdio.h> 306489Sjmcp #include <stdlib.h> 316489Sjmcp #include <unistd.h> 326489Sjmcp #include <strings.h> 336489Sjmcp #include <errno.h> 346489Sjmcp #include <sys/queue.h> 356489Sjmcp #include <signal.h> 366489Sjmcp #include <locale.h> 376489Sjmcp #include <sys/stat.h> 386489Sjmcp #include <sys/types.h> 396489Sjmcp #include <sys/param.h> 406489Sjmcp #include <fcntl.h> 416489Sjmcp #include <dlfcn.h> 426489Sjmcp #include <dirent.h> 436489Sjmcp #include <sys/varargs.h> 446489Sjmcp #include <libintl.h> /* for gettext(3c) */ 456489Sjmcp #include <libdevinfo.h> 466489Sjmcp #include <fwflash/fwflash.h> 476846Sjmcp #include <sys/modctl.h> /* for MAXMODCONFNAME */ 486489Sjmcp 496489Sjmcp 506489Sjmcp #if !defined(lint) 516489Sjmcp /* embedded software license agreement */ 526489Sjmcp static char *sla [] = { "Copyright 2007 Sun Microsystems, Inc., 4150 Network " 536489Sjmcp "Circle, Santa Clara, California 95054, U.S.A. All rights reserved. U.S. " 546489Sjmcp "Government Rights - Commercial software. Government users are subject to the " 556489Sjmcp "Sun Microsystems, Inc. standard license agreement and applicable provisions " 566489Sjmcp "of the FAR and its supplements. Use is subject to license terms. Parts of " 576489Sjmcp "the product may be derived from Berkeley BSD systems, licensed from the " 586489Sjmcp "University of California. UNIX is a registered trademark in the U.S. and in " 596489Sjmcp "other countries, exclusively licensed through X/Open Company, Ltd.Sun, Sun " 606489Sjmcp "Microsystems, the Sun logo and Solaris are trademarks or registered " 616489Sjmcp "trademarks of Sun Microsystems, Inc. in the U.S. and other countries. This " 626489Sjmcp "product is covered and controlled by U.S. Export Control laws and may be " 636489Sjmcp "subject to the export or import laws in other countries. Nuclear, missile, " 646489Sjmcp "chemical biological weapons or nuclear maritime end uses or end users, " 656489Sjmcp "whether direct or indirect, are strictly prohibited. Export or reexport " 666489Sjmcp "to countries subject to U.S. embargo or to entities identified on U.S. export " 676489Sjmcp "exclusion lists, including, but not limited to, the denied persons and " 686489Sjmcp "specially designated nationals lists is strictly prohibited." }; 696489Sjmcp #endif /* lint */ 706489Sjmcp 716489Sjmcp /* global arg list */ 726489Sjmcp int fwflash_arg_list = 0; 736489Sjmcp char *filelist[10]; 746489Sjmcp 756489Sjmcp /* are we writing to flash? */ 766489Sjmcp static int fwflash_in_write = 0; 776489Sjmcp 786489Sjmcp /* 796489Sjmcp * If we *must* track the version string for fwflash, then 806489Sjmcp * we should do so in this common file rather than the header 816489Sjmcp * file since it will then be in sync with what the customer 82*7317SJames.McPherson@Sun.COM * sees. We should deprecate the "-v" option since it is not 83*7317SJames.McPherson@Sun.COM * actually of any use - it doesn't line up with Mercurial's 84*7317SJames.McPherson@Sun.COM * concept of the changeset. 856489Sjmcp */ 86*7317SJames.McPherson@Sun.COM #define FWFLASH_VERSION "v1.6" 876489Sjmcp #define FWFLASH_PROG_NAME "fwflash" 886489Sjmcp 896489Sjmcp static int get_fileopts(char *options); 906489Sjmcp static int flash_device_list(); 916489Sjmcp static int flash_load_plugins(); 926489Sjmcp static int fwflash_update(char *device, char *filename, int flags); 936489Sjmcp static int fwflash_read_file(char *device, char *filename); 946489Sjmcp static int fwflash_list_fw(char *class); 956489Sjmcp static int fwflash_load_verifier(char *drv, char *vendorid, char *fwimg); 966489Sjmcp static void fwflash_intr(int sig); 976489Sjmcp static void fwflash_handle_signals(void); 98*7317SJames.McPherson@Sun.COM static void fwflash_usage(char *arg); 996489Sjmcp static void fwflash_version(void); 1006489Sjmcp static int confirm_target(struct devicelist *thisdev, char *file); 1016489Sjmcp 1026489Sjmcp /* 1036489Sjmcp * FWFlash main code 1046489Sjmcp */ 1056489Sjmcp int 1066489Sjmcp main(int argc, char **argv) { 1076489Sjmcp int rv = FWFLASH_SUCCESS; 1086489Sjmcp int i; 1096489Sjmcp char ch; 1106489Sjmcp char *read_file; 1116489Sjmcp extern char *optarg; 1126489Sjmcp char *devclass = NULL; 1136489Sjmcp char *devpath = NULL; 1146489Sjmcp 1156489Sjmcp /* local variables from env */ 1166489Sjmcp (void) setlocale(LC_ALL, ""); 1176489Sjmcp 1186489Sjmcp #if !defined(TEXT_DOMAIN) /* Should be defined by cc -D */ 1196489Sjmcp #define TEXT_DOMAIN "SYS_TEST" /* Use this only if it isn't. */ 1206489Sjmcp #endif 1216489Sjmcp 1226489Sjmcp (void) textdomain(TEXT_DOMAIN); 1236489Sjmcp 1246489Sjmcp read_file = NULL; 1256489Sjmcp 1266489Sjmcp if (argc < 2) { 1276489Sjmcp /* no args supplied */ 1286489Sjmcp fwflash_usage(NULL); 1296489Sjmcp return (FWFLASH_FAILURE); 1306489Sjmcp } 1316489Sjmcp 1326846Sjmcp while ((ch = getopt(argc, argv, "hvylc:f:r:Qd:M")) != EOF) { 1336489Sjmcp switch (ch) { 1346489Sjmcp case 'h': 1356489Sjmcp fwflash_arg_list |= FWFLASH_HELP_FLAG; 1366489Sjmcp break; 1376489Sjmcp case 'v': 1386489Sjmcp fwflash_arg_list |= FWFLASH_VER_FLAG; 1396489Sjmcp break; 1406489Sjmcp case 'y': 1416489Sjmcp fwflash_arg_list |= FWFLASH_YES_FLAG; 1426489Sjmcp break; 1436489Sjmcp case 'l': 1446489Sjmcp fwflash_arg_list |= FWFLASH_LIST_FLAG; 1456489Sjmcp break; 1466489Sjmcp case 'c': 1476489Sjmcp fwflash_arg_list |= FWFLASH_CLASS_FLAG; 1486489Sjmcp /* we validate later */ 1496489Sjmcp devclass = strdup(optarg); 1506489Sjmcp break; 1516489Sjmcp case 'd': 1526489Sjmcp fwflash_arg_list |= FWFLASH_DEVICE_FLAG; 1536489Sjmcp devpath = strdup(optarg); 1546489Sjmcp break; 1556489Sjmcp case 'f': 1566489Sjmcp fwflash_arg_list |= FWFLASH_FW_FLAG; 1576489Sjmcp if ((rv = get_fileopts(optarg)) != FWFLASH_SUCCESS) { 158*7317SJames.McPherson@Sun.COM fwflash_usage(NULL); 1596489Sjmcp return (FWFLASH_FAILURE); 1606489Sjmcp } 1616489Sjmcp break; 1626489Sjmcp case 'r': 1636489Sjmcp fwflash_arg_list |= FWFLASH_READ_FLAG; 1646489Sjmcp read_file = strdup(optarg); 1656489Sjmcp break; 1666489Sjmcp case 'Q': 1676489Sjmcp /* NOT in the manpage */ 1686489Sjmcp fwflash_debug = 1; 1696489Sjmcp break; 1706846Sjmcp case 'M': 1716846Sjmcp /* NOT in the manpage */ 1726846Sjmcp #if (MANUFACTURING_MODE > 0) 1736846Sjmcp manufacturing_mode = 1; 1746846Sjmcp logmsg(MSG_WARN, "Enabling Manufacturing Mode " 1756846Sjmcp "operations. This can be destructive!\n"); 1766846Sjmcp break; 1776846Sjmcp #endif 1786846Sjmcp /* illegal options */ 1796489Sjmcp default: 1806489Sjmcp fwflash_usage(optarg); 1816489Sjmcp return (FWFLASH_FAILURE); 1826489Sjmcp } 1836489Sjmcp } 1846489Sjmcp 1856489Sjmcp /* Do Help */ 1866489Sjmcp if ((fwflash_arg_list & FWFLASH_HELP_FLAG) || 1876489Sjmcp ((fwflash_arg_list & FWFLASH_DEVICE_FLAG) && 1886489Sjmcp !((fwflash_arg_list & FWFLASH_FW_FLAG) || 1896489Sjmcp (fwflash_arg_list & FWFLASH_READ_FLAG)))) { 190*7317SJames.McPherson@Sun.COM fwflash_usage(NULL); 1916489Sjmcp return (FWFLASH_SUCCESS); 1926489Sjmcp } 1936489Sjmcp 1946489Sjmcp /* Do Version */ 1956489Sjmcp if (fwflash_arg_list == FWFLASH_VER_FLAG) { 1966489Sjmcp fwflash_version(); 1976489Sjmcp return (FWFLASH_SUCCESS); 1986489Sjmcp } 1996489Sjmcp 2006489Sjmcp /* generate global list of devices */ 2016489Sjmcp if ((rv = flash_load_plugins()) != FWFLASH_SUCCESS) { 2026489Sjmcp logmsg(MSG_ERROR, 2036489Sjmcp gettext("Unable to load fwflash plugins\n")); 2046489Sjmcp fwflash_intr(0); 2056489Sjmcp return (rv); 2066489Sjmcp } 2076489Sjmcp 2086489Sjmcp if ((rv = flash_device_list()) != FWFLASH_SUCCESS) { 2096489Sjmcp logmsg(MSG_ERROR, 2106489Sjmcp gettext("No flashable devices in this system\n")); 2116489Sjmcp fwflash_intr(0); 2126489Sjmcp return (rv); 2136489Sjmcp } 2146489Sjmcp 2156489Sjmcp /* Do list */ 2166489Sjmcp if (fwflash_arg_list == (FWFLASH_LIST_FLAG) || 2176489Sjmcp fwflash_arg_list == (FWFLASH_LIST_FLAG | FWFLASH_CLASS_FLAG)) { 2186489Sjmcp rv = fwflash_list_fw(devclass); 2196489Sjmcp fwflash_intr(0); 2206489Sjmcp return (rv); 2216489Sjmcp } 2226489Sjmcp 2236489Sjmcp fwflash_handle_signals(); 2246489Sjmcp 2256489Sjmcp /* Do flash update (write) */ 2266489Sjmcp if ((fwflash_arg_list == (FWFLASH_FW_FLAG | FWFLASH_DEVICE_FLAG)) || 2276489Sjmcp (fwflash_arg_list == (FWFLASH_FW_FLAG | FWFLASH_DEVICE_FLAG | 2286489Sjmcp FWFLASH_YES_FLAG))) { 2296489Sjmcp /* the update function handles the real arg parsing */ 2306489Sjmcp i = 0; 2316489Sjmcp while (filelist[i] != NULL) { 2326489Sjmcp if ((rv = fwflash_update(devpath, filelist[i], 2336489Sjmcp fwflash_arg_list)) == FWFLASH_SUCCESS) { 2346489Sjmcp /* failed ops have already been noted */ 2356489Sjmcp logmsg(MSG_ERROR, 2366489Sjmcp gettext("New firmware will be activated " 2376489Sjmcp "after you reboot\n\n")); 2386489Sjmcp } 2396489Sjmcp ++i; 2406489Sjmcp } 2416489Sjmcp 2426489Sjmcp fwflash_intr(0); 2436489Sjmcp return (rv); 2446489Sjmcp } 2456489Sjmcp 2466489Sjmcp /* Do flash read */ 2476489Sjmcp if ((fwflash_arg_list == (FWFLASH_READ_FLAG | FWFLASH_DEVICE_FLAG)) || 2486489Sjmcp (fwflash_arg_list == (FWFLASH_READ_FLAG | FWFLASH_DEVICE_FLAG | 2496489Sjmcp FWFLASH_YES_FLAG))) { 2506489Sjmcp rv = fwflash_read_file(devpath, read_file); 2516489Sjmcp fwflash_intr(0); 2526489Sjmcp return (rv); 2536489Sjmcp } 2546489Sjmcp 2556489Sjmcp fwflash_usage(NULL); 2566489Sjmcp 2576489Sjmcp return (FWFLASH_FAILURE); 2586489Sjmcp } 2596489Sjmcp 2606489Sjmcp 2616489Sjmcp static int 2626489Sjmcp flash_load_plugins() { 2636489Sjmcp 2646489Sjmcp int rval = FWFLASH_SUCCESS; 2656489Sjmcp DIR *dirp; 2666489Sjmcp struct dirent *plugdir; 2676489Sjmcp char *plugname; 2686489Sjmcp struct fw_plugin *tmpplug; 2696489Sjmcp struct pluginlist *tmpelem; 2706489Sjmcp void *sym; 2716489Sjmcp char *fwplugdirpath, *tempdirpath; 2726489Sjmcp 2736489Sjmcp 2746489Sjmcp #define CLOSEFREE() { \ 2756489Sjmcp (void) dlclose(tmpplug->handle); \ 2766489Sjmcp free(tmpplug); } 2776489Sjmcp 2786489Sjmcp /* 2796489Sjmcp * Procedure: 2806489Sjmcp * 2816489Sjmcp * cd /usr/lib/fwflash/identify 2826489Sjmcp * open each .so file found therein 2836489Sjmcp * dlopen(.sofile) 2846489Sjmcp * if it's one of our plugins, add it to fw_pluginlist; 2856489Sjmcp * 2866489Sjmcp * functions we need here include dlopen and dlsym. 2876489Sjmcp * 2886489Sjmcp * If we get to the end and fw_pluginlist struct is empty, 2896489Sjmcp * return FWFLASH_FAILURE so we return to the shell. 2906489Sjmcp */ 2916489Sjmcp 2926489Sjmcp if ((fwplugdirpath = calloc(1, MAXPATHLEN + 1)) == NULL) { 2936489Sjmcp logmsg(MSG_ERROR, 2946489Sjmcp gettext("Unable to malloc %d bytes while " 2956489Sjmcp "trying to load plugins: %s\n"), 2966489Sjmcp MAXPATHLEN + 1, strerror(errno)); 2976489Sjmcp return (FWFLASH_FAILURE); 2986489Sjmcp } 2996489Sjmcp 3006489Sjmcp tempdirpath = getenv("FWPLUGINDIR"); 3016489Sjmcp 3026489Sjmcp if ((fwflash_debug > 0) && (tempdirpath != NULL)) { 3036489Sjmcp (void) strlcpy(fwplugdirpath, tempdirpath, 3046489Sjmcp strlen(tempdirpath) + 1); 3056489Sjmcp } else { 3066489Sjmcp (void) strlcpy(fwplugdirpath, FWPLUGINDIR, 3076489Sjmcp strlen(FWPLUGINDIR) + 1); 3086489Sjmcp } 3096489Sjmcp 3106489Sjmcp if ((dirp = opendir(fwplugdirpath)) == NULL) { 3116489Sjmcp logmsg(MSG_ERROR, 3126846Sjmcp gettext("Unable to open %s\n"), 3136489Sjmcp fwplugdirpath); 3146489Sjmcp return (errno); 3156489Sjmcp } 3166489Sjmcp 3176489Sjmcp if ((plugdir = calloc(1, sizeof (struct dirent) + MAXPATHLEN + 1)) 3186489Sjmcp == NULL) { 3196489Sjmcp logmsg(MSG_ERROR, 3206489Sjmcp gettext("Unable to malloc %d bytes while " 3216489Sjmcp "trying to load plugins: %s\n"), 3226489Sjmcp MAXPATHLEN + 1 + sizeof (struct dirent), 3236489Sjmcp strerror(errno)); 3246489Sjmcp return (FWFLASH_FAILURE); 3256489Sjmcp } 3266489Sjmcp 3276489Sjmcp if ((fw_pluginlist = calloc(1, sizeof (struct fw_plugin))) 3286489Sjmcp == NULL) { 3296489Sjmcp logmsg(MSG_ERROR, 3306489Sjmcp gettext("Unable to malloc %d bytes while " 3316489Sjmcp "trying to load plugins: %s\n"), 3326489Sjmcp sizeof (struct fw_plugin) + 1, strerror(errno)); 3336489Sjmcp return (FWFLASH_FAILURE); 3346489Sjmcp } 3356489Sjmcp 3366489Sjmcp TAILQ_INIT(fw_pluginlist); 3376489Sjmcp 3386489Sjmcp while ((readdir_r(dirp, plugdir, &plugdir) == 0) && (plugdir != NULL)) { 3396489Sjmcp 3406489Sjmcp errno = 0; /* remove chance of false results */ 3416489Sjmcp 3426489Sjmcp if ((plugdir->d_name[0] == '.') || 3436489Sjmcp (strstr(plugdir->d_name, ".so") == NULL)) { 3446489Sjmcp continue; 3456489Sjmcp } 3466489Sjmcp 3476489Sjmcp if ((plugname = calloc(1, MAXPATHLEN + 1)) == NULL) { 3486489Sjmcp logmsg(MSG_ERROR, 3496489Sjmcp gettext("Unable to malloc %d bytes while " 3506489Sjmcp "trying to load plugins: %s\n"), 3516489Sjmcp MAXPATHLEN + 1, strerror(errno)); 3526489Sjmcp return (FWFLASH_FAILURE); 3536489Sjmcp } 3546489Sjmcp 3556489Sjmcp (void) snprintf(plugname, MAXPATHLEN, "%s/%s", 3566489Sjmcp fwplugdirpath, plugdir->d_name); 3576489Sjmcp 3586489Sjmcp /* start allocating storage */ 3596489Sjmcp if ((tmpelem = calloc(1, sizeof (struct pluginlist))) 3606489Sjmcp == NULL) { 3616489Sjmcp logmsg(MSG_ERROR, 3626489Sjmcp gettext("Unable to malloc %d bytes while " 3636489Sjmcp "trying to load plugins: %s\n"), 3646489Sjmcp sizeof (struct pluginlist), strerror(errno)); 3656489Sjmcp return (FWFLASH_FAILURE); 3666489Sjmcp } 3676489Sjmcp 3686489Sjmcp if ((tmpplug = calloc(1, sizeof (struct fw_plugin))) 3696489Sjmcp == NULL) { 3706489Sjmcp logmsg(MSG_ERROR, 3716489Sjmcp gettext("Unable to malloc %d bytes while " 3726489Sjmcp "trying to load plugins: %s\n"), 3736489Sjmcp sizeof (struct fw_plugin), strerror(errno)); 3746489Sjmcp return (FWFLASH_FAILURE); 3756489Sjmcp } 3766489Sjmcp 3776489Sjmcp /* load 'er up! */ 3786489Sjmcp tmpplug->handle = dlopen(plugname, RTLD_NOW); 3796489Sjmcp if (tmpplug->handle == NULL) { 3806489Sjmcp free(tmpplug); 3816489Sjmcp continue; /* assume there are other plugins */ 3826489Sjmcp } 3836489Sjmcp 3846489Sjmcp if ((tmpplug->filename = calloc(1, strlen(plugname) + 1)) 3856489Sjmcp == NULL) { 3866489Sjmcp logmsg(MSG_ERROR, 3876489Sjmcp gettext("Unable to allocate %d bytes for plugin " 3886489Sjmcp "filename %s:%s\n"), 3896489Sjmcp strlen(plugname) + 1, plugname, 3906489Sjmcp strerror(errno)); 3916489Sjmcp return (rval); 3926489Sjmcp } 3936489Sjmcp 3946489Sjmcp (void) strlcpy(tmpplug->filename, plugname, 3956489Sjmcp strlen(plugname) + 1); 3966489Sjmcp 3976489Sjmcp /* now sanity check the file */ 3986489Sjmcp if ((sym = dlsym(tmpplug->handle, "drivername")) 3996489Sjmcp != NULL) { 4006489Sjmcp /* max length of drivername */ 4016846Sjmcp tmpplug->drvname = calloc(1, MAXMODCONFNAME); 4026846Sjmcp 4036846Sjmcp /* are we doing double-time? */ 4046846Sjmcp if (strncmp((char *)sym, plugdir->d_name, 4056846Sjmcp MAXMODCONFNAME) != 0) { 4066846Sjmcp char *tempnm = calloc(1, MAXMODCONFNAME); 4076846Sjmcp 4086846Sjmcp memcpy(tempnm, plugdir->d_name, MAXMODCONFNAME); 4096846Sjmcp (void) strlcpy(tmpplug->drvname, 4106846Sjmcp strtok(tempnm, "."), 4116846Sjmcp strlen(plugdir->d_name) + 1); 4126846Sjmcp free(tempnm); 4136846Sjmcp } else { 4146846Sjmcp (void) strlcpy(tmpplug->drvname, 4156846Sjmcp (char *)sym, strlen(sym) + 1); 4166846Sjmcp } 4176489Sjmcp } else { 4186489Sjmcp CLOSEFREE(); 4196489Sjmcp continue; 4206489Sjmcp } 4216489Sjmcp if ((sym = dlsym(tmpplug->handle, "fw_readfw")) 4226489Sjmcp != NULL) { 4236489Sjmcp tmpplug->fw_readfw = (int (*)())sym; 4246489Sjmcp } else { 4256489Sjmcp CLOSEFREE(); 4266489Sjmcp continue; 4276489Sjmcp } 4286489Sjmcp if ((sym = dlsym(tmpplug->handle, "fw_writefw")) 4296489Sjmcp != NULL) { 4306489Sjmcp tmpplug->fw_writefw = (int (*)())sym; 4316489Sjmcp } else { 4326489Sjmcp CLOSEFREE(); 4336489Sjmcp continue; 4346489Sjmcp } 4356489Sjmcp 4366489Sjmcp if ((sym = dlsym(tmpplug->handle, "fw_identify")) 4376489Sjmcp != NULL) { 4386489Sjmcp tmpplug->fw_identify = 4396489Sjmcp (int (*)(int))sym; 4406489Sjmcp } else { 4416489Sjmcp CLOSEFREE(); 4426489Sjmcp continue; 4436489Sjmcp } 4446489Sjmcp if ((sym = dlsym(tmpplug->handle, "fw_devinfo")) 4456489Sjmcp != NULL) { 4466489Sjmcp tmpplug->fw_devinfo = 4476489Sjmcp (int (*)(struct devicelist *))sym; 4486489Sjmcp } else { 4496489Sjmcp CLOSEFREE(); 4506489Sjmcp continue; 4516489Sjmcp } 4526489Sjmcp 4536846Sjmcp if ((tmpelem->drvname = calloc(1, MAXMODCONFNAME)) 4546489Sjmcp == NULL) { 4556489Sjmcp logmsg(MSG_ERROR, 4566846Sjmcp gettext("Unable to allocate space for a" 4576489Sjmcp "drivername %s\n"), 4586489Sjmcp tmpplug->drvname); 4596489Sjmcp return (FWFLASH_FAILURE); 4606489Sjmcp } 4616489Sjmcp 4626489Sjmcp (void) strlcpy(tmpelem->drvname, tmpplug->drvname, 4636489Sjmcp strlen(tmpplug->drvname) + 1); 4646489Sjmcp 4656489Sjmcp if ((tmpelem->filename = calloc(1, 4666489Sjmcp strlen(tmpplug->filename) + 1)) == NULL) { 4676489Sjmcp logmsg(MSG_ERROR, 4686489Sjmcp gettext("Unable to allocate %d bytes for " 4696489Sjmcp "filename %s\n"), 4706489Sjmcp strlen(tmpplug->filename) + 1, 4716846Sjmcp tmpplug->filename); 4726489Sjmcp return (FWFLASH_FAILURE); 4736489Sjmcp } 4746489Sjmcp 4756489Sjmcp (void) strlcpy(tmpelem->filename, plugname, 4766489Sjmcp strlen(plugname) + 1); 4776489Sjmcp tmpelem->plugin = tmpplug; 4786489Sjmcp 4796489Sjmcp /* CONSTCOND */ 4806489Sjmcp TAILQ_INSERT_TAIL(fw_pluginlist, tmpelem, nextplugin); 4816489Sjmcp } 4826489Sjmcp 4836489Sjmcp if ((plugdir == NULL) && TAILQ_EMPTY(fw_pluginlist)) { 4846489Sjmcp return (FWFLASH_FAILURE); 4856489Sjmcp } 4866489Sjmcp 4876489Sjmcp if (errno != 0) { 4886489Sjmcp logmsg(MSG_ERROR, 4896489Sjmcp gettext("Error reading directory entry in %s\n"), 4906489Sjmcp fwplugdirpath); 4916489Sjmcp (void) closedir(dirp); 4926489Sjmcp rval = errno; 4936489Sjmcp } 4946489Sjmcp 4956489Sjmcp (void) free(fwplugdirpath); 4966489Sjmcp (void) free(plugdir); 4976489Sjmcp (void) closedir(dirp); 4986489Sjmcp return (rval); 4996489Sjmcp } 5006489Sjmcp 5016489Sjmcp /* 5026489Sjmcp * fwflash_load_verifier dlload()s the appropriate firmware image 5036489Sjmcp * verification plugin, and attaches the designated fwimg's fd to 5046489Sjmcp * the vrfyplugin structure so we only have to load the image in 5056489Sjmcp * one place. 5066489Sjmcp */ 5076489Sjmcp int 5086489Sjmcp fwflash_load_verifier(char *drv, char *vendorid, char *fwimg) { 5096489Sjmcp 5106489Sjmcp int rv = FWFLASH_FAILURE; 5116489Sjmcp int imgfd; 5126489Sjmcp char *fwvrfydirpath, *tempdirpath, *filename; 5136489Sjmcp char *clean; /* for the space-removed vid */ 5146489Sjmcp struct stat fwstat; 5156489Sjmcp struct vrfyplugin *vrfy; 5166489Sjmcp void *vrfysym; 5176489Sjmcp 5186489Sjmcp /* 5196489Sjmcp * To make flashing multiple firmware images somewhat more 5206489Sjmcp * efficient, we start this function by checking whether a 5216489Sjmcp * verifier for this device has already been loaded. If it 5226489Sjmcp * has been loaded, we replace the imgfile information, and 5236489Sjmcp * then continue as if we were loading for the first time. 5246489Sjmcp */ 5256489Sjmcp 5266489Sjmcp if (verifier != NULL) { 5276489Sjmcp verifier->imgsize = 0; 5286489Sjmcp verifier->flashbuf = 0; /* set by the verifier function */ 5296489Sjmcp 5306489Sjmcp if (verifier->imgfile != NULL) 5316489Sjmcp (void) free(verifier->imgfile); 5326489Sjmcp 5336489Sjmcp if (verifier->fwimage != NULL) 5346489Sjmcp (void) free(verifier->fwimage); 5356489Sjmcp } else { 5366489Sjmcp if ((fwvrfydirpath = calloc(1, MAXPATHLEN + 1)) == NULL) { 5376489Sjmcp logmsg(MSG_ERROR, 5386489Sjmcp gettext("Unable to allocate space for a firmware " 5396489Sjmcp "verifier file(1)")); 5406489Sjmcp return (rv); 5416489Sjmcp } 5426489Sjmcp 5436489Sjmcp if ((filename = calloc(1, MAXPATHLEN + 1)) == NULL) { 5446489Sjmcp logmsg(MSG_ERROR, 5456489Sjmcp gettext("Unable to allocate space " 5466489Sjmcp "for a firmware verifier file(2)")); 5476489Sjmcp return (rv); 5486489Sjmcp } 5496489Sjmcp 5506489Sjmcp /* 5516489Sjmcp * Since SCSI devices can have a vendor id of up to 8 left-aligned 5526489Sjmcp * and _space-padded_ characters, we first need to strip off any 5536489Sjmcp * space characters before we try to make a filename out of it 5546489Sjmcp */ 5556489Sjmcp clean = strtok(vendorid, " "); 5566489Sjmcp if (clean == NULL) { 5576489Sjmcp /* invalid vendorid, something's really wrong */ 5586489Sjmcp logmsg(MSG_ERROR, 5596489Sjmcp gettext("Invalid vendorid (null) specified for " 5606489Sjmcp "device\n")); 5616489Sjmcp return (rv); 5626489Sjmcp } 5636489Sjmcp 5646489Sjmcp tempdirpath = getenv("FWVERIFYPLUGINDIR"); 5656489Sjmcp 5666489Sjmcp if ((fwflash_debug > 0) && (tempdirpath != NULL)) { 5676489Sjmcp (void) strlcpy(fwvrfydirpath, tempdirpath, 5686489Sjmcp strlen(tempdirpath) + 1); 5696489Sjmcp } else { 5706489Sjmcp (void) strlcpy(fwvrfydirpath, FWVERIFYPLUGINDIR, 5716489Sjmcp strlen(FWVERIFYPLUGINDIR) + 1); 5726489Sjmcp } 5736489Sjmcp 5746489Sjmcp if ((vrfy = calloc(1, sizeof (struct vrfyplugin))) == NULL) { 5756489Sjmcp logmsg(MSG_ERROR, 5766489Sjmcp gettext("Unable to allocate space " 5776489Sjmcp "for a firmware verifier structure")); 5786489Sjmcp free(filename); 5796489Sjmcp free(fwvrfydirpath); 5806489Sjmcp return (FWFLASH_FAILURE); 5816489Sjmcp } 5826489Sjmcp 5836489Sjmcp errno = 0; /* false positive removal */ 5846489Sjmcp 5856489Sjmcp (void) snprintf(filename, strlen(fwvrfydirpath) + 5866489Sjmcp strlen(drv) + 7 + strlen(clean), "%s/%s-%s.so\0", 5876489Sjmcp fwvrfydirpath, drv, clean); 5886489Sjmcp 5896489Sjmcp if ((vrfy->filename = calloc(1, strlen(filename) + 1)) 5906489Sjmcp == NULL) { 5916489Sjmcp logmsg(MSG_ERROR, 5926489Sjmcp gettext("Unable to allocate space to store " 5936489Sjmcp "a verifier filename\n")); 5946489Sjmcp free(filename); 5956489Sjmcp free(fwvrfydirpath); 5966489Sjmcp free(vrfy->handle); 5976489Sjmcp return (FWFLASH_FAILURE); 5986489Sjmcp } 5996489Sjmcp 6006489Sjmcp (void) strlcpy(vrfy->filename, filename, strlen(filename) + 1); 6016489Sjmcp 6026489Sjmcp if ((vrfy->handle = dlopen(filename, RTLD_NOW)) == NULL) { 6036489Sjmcp logmsg(MSG_ERROR, gettext(dlerror())); 6046489Sjmcp logmsg(MSG_ERROR, 6056489Sjmcp gettext("Unable to open verification plugin " 6066846Sjmcp "%s. Unable to verify firmware image. " 6076489Sjmcp "Aborting.\n"), 6086489Sjmcp filename); 6096489Sjmcp free(filename); 6106489Sjmcp free(fwvrfydirpath); 6116489Sjmcp return (FWFLASH_FAILURE); 6126489Sjmcp } 6136489Sjmcp 6146489Sjmcp if ((vrfysym = dlsym(vrfy->handle, "vendorvrfy")) == NULL) { 6156489Sjmcp logmsg(MSG_ERROR, 6166489Sjmcp gettext("%s is an invalid firmware verification " 6176489Sjmcp "plugin."), filename); 6186489Sjmcp (void) dlclose(vrfy->handle); 6196489Sjmcp free(filename); 6206489Sjmcp free(fwvrfydirpath); 6216489Sjmcp free(vrfy); 6226489Sjmcp return (FWFLASH_FAILURE); 6236489Sjmcp } else { 6246489Sjmcp vrfy->vendorvrfy = 6256489Sjmcp (int (*)(struct devicelist *))vrfysym; 6266489Sjmcp } 6276489Sjmcp 6286489Sjmcp vrfysym = dlsym(vrfy->handle, "vendor"); 6296489Sjmcp 6306489Sjmcp if (vrfysym == NULL) { 6316489Sjmcp logmsg(MSG_ERROR, 6326489Sjmcp gettext("Invalid vendor (null) in verification " 6336489Sjmcp "plugin %s\n"), filename); 6346489Sjmcp (void) dlclose(vrfy->handle); 6356489Sjmcp free(vrfy); 6366489Sjmcp return (NULL); 6376489Sjmcp } else { 6386489Sjmcp if (strncmp(vendorid, (char *)vrfysym, 6396489Sjmcp strlen(vendorid)) != 0) { 6406489Sjmcp logmsg(MSG_INFO, 6416489Sjmcp "Using a sym-linked (%s -> %s) " 6426489Sjmcp "verification plugin", 6436489Sjmcp vendorid, vrfysym); 6446489Sjmcp vrfy->vendor = calloc(1, strlen(vendorid) + 1); 6456489Sjmcp } else { 6466489Sjmcp vrfy->vendor = calloc(1, strlen(vrfysym) + 1); 6476489Sjmcp } 6486489Sjmcp (void) strlcpy(vrfy->vendor, (char *)vrfysym, 6496489Sjmcp strlen(vendorid) + 1); 6506489Sjmcp } 6516489Sjmcp 6526489Sjmcp verifier = vrfy; /* a convenience variable */ 6536489Sjmcp } 6546489Sjmcp 6556489Sjmcp 6566489Sjmcp /* 6576489Sjmcp * We don't do any verification that the fw image file is in 6586489Sjmcp * an approved location, but it's easy enough to modify this 6596489Sjmcp * function to do so. The verification plugin should provide 6606489Sjmcp * sufficient protection. 6616489Sjmcp */ 6626489Sjmcp 6636489Sjmcp if ((imgfd = open(fwimg, O_RDONLY)) < 0) { 6646489Sjmcp logmsg(MSG_ERROR, 6656489Sjmcp gettext("Unable to open designated firmware " 6666489Sjmcp "image file %s: %s\n"), 6676489Sjmcp (fwimg != NULL) ? fwimg : "(null)", 6686489Sjmcp strerror(errno)); 6696489Sjmcp rv = FWFLASH_FAILURE; 6706489Sjmcp goto cleanup; 6716489Sjmcp } 6726489Sjmcp 6736489Sjmcp if (stat(fwimg, &fwstat) == -1) { 6746489Sjmcp logmsg(MSG_ERROR, 6756489Sjmcp gettext("Unable to stat() firmware image file " 6766489Sjmcp "%s: %s\n"), 6776489Sjmcp fwimg, strerror(errno)); 6786489Sjmcp rv = FWFLASH_FAILURE; 6796489Sjmcp goto cleanup; 6806489Sjmcp } else { 6816489Sjmcp verifier->imgsize = fwstat.st_size; 6826489Sjmcp if ((verifier->fwimage = calloc(1, verifier->imgsize)) 6836489Sjmcp == NULL) { 6846489Sjmcp logmsg(MSG_ERROR, 6856489Sjmcp gettext("Unable to load firmware image " 6866489Sjmcp "%s: %s\n"), 6876489Sjmcp fwimg, strerror(errno)); 6886489Sjmcp rv = FWFLASH_FAILURE; 6896489Sjmcp goto cleanup; 6906489Sjmcp } 6916489Sjmcp } 6926489Sjmcp 6936489Sjmcp errno = 0; 6946489Sjmcp if ((rv = read(imgfd, verifier->fwimage, 6956489Sjmcp (size_t)verifier->imgsize)) < verifier->imgsize) { 6966489Sjmcp /* we haven't read enough data, bail */ 6976489Sjmcp logmsg(MSG_ERROR, 6986489Sjmcp gettext("Failed to read sufficient data " 6996489Sjmcp "(got %d bytes, expected %d bytes) from " 7006489Sjmcp "firmware image file %s: %s\n"), 7016489Sjmcp rv, verifier->imgsize, 7026489Sjmcp filename, strerror(errno)); 7036489Sjmcp rv = FWFLASH_FAILURE; 7046489Sjmcp } else { 7056489Sjmcp rv = FWFLASH_SUCCESS; 7066489Sjmcp } 7076489Sjmcp 7086489Sjmcp if ((verifier->imgfile = calloc(1, strlen(fwimg) + 1)) == NULL) { 7096489Sjmcp logmsg(MSG_ERROR, 7106489Sjmcp gettext("Unable to save name of firmware image\n")); 7116489Sjmcp rv = FWFLASH_FAILURE; 7126489Sjmcp } else { 7136489Sjmcp (void) strlcpy(verifier->imgfile, fwimg, strlen(fwimg) + 1); 7146489Sjmcp } 7156489Sjmcp 7166489Sjmcp if (rv != FWFLASH_SUCCESS) { 7176489Sjmcp /* cleanup and let's get outta here */ 7186489Sjmcp cleanup: 7196489Sjmcp free(verifier->filename); 7206489Sjmcp free(verifier->vendor); 7216489Sjmcp 7226489Sjmcp if (!(fwflash_arg_list & FWFLASH_READ_FLAG)) 7236489Sjmcp free(verifier->fwimage); 7246489Sjmcp 7256489Sjmcp verifier->filename = NULL; 7266489Sjmcp verifier->vendor = NULL; 7276489Sjmcp verifier->vendorvrfy = NULL; 7286489Sjmcp verifier->fwimage = NULL; 7296489Sjmcp (void) dlclose(verifier->handle); 7306489Sjmcp verifier->handle = NULL; 7316489Sjmcp free(verifier); 7326489Sjmcp if (imgfd >= 0) { 7336489Sjmcp (void) close(imgfd); 7346489Sjmcp } 7356489Sjmcp verifier = NULL; 7366489Sjmcp } 7376489Sjmcp 7386489Sjmcp return (rv); 7396489Sjmcp } 7406489Sjmcp 7416489Sjmcp /* 7426489Sjmcp * cycles through the global list of plugins to find 7436489Sjmcp * each flashable device, which is added to fw_devices 7446489Sjmcp * 7456489Sjmcp * Each plugin's identify routine must allocated storage 7466489Sjmcp * as required. 7476489Sjmcp * 7486489Sjmcp * Each plugin's identify routine must return 7496489Sjmcp * FWFLASH_FAILURE if it cannot find any devices 7506489Sjmcp * which it handles. 7516489Sjmcp */ 7526489Sjmcp static int 7536489Sjmcp flash_device_list() 7546489Sjmcp { 7556489Sjmcp int rv = FWFLASH_FAILURE; 7566489Sjmcp int startidx = 0; 7576489Sjmcp int sumrv = 0; 7586489Sjmcp struct pluginlist *plugins; 7596489Sjmcp 7606489Sjmcp /* we open rootnode here, and close it in fwflash_intr */ 7616489Sjmcp if ((rootnode = di_init("/", DINFOCPYALL)) == DI_NODE_NIL) { 7626489Sjmcp logmsg(MSG_ERROR, 7636489Sjmcp gettext("Unable to take device tree snapshot: %s\n"), 7646489Sjmcp strerror(errno)); 7656489Sjmcp return (rv); 7666489Sjmcp } 7676489Sjmcp 7686489Sjmcp if ((fw_devices = calloc(1, sizeof (struct devicelist))) == NULL) { 7696489Sjmcp logmsg(MSG_ERROR, 7706489Sjmcp gettext("Unable to malloc %d bytes while " 7716489Sjmcp "trying to find devices: %s\n"), 7726489Sjmcp sizeof (struct devicelist), strerror(errno)); 7736489Sjmcp return (FWFLASH_FAILURE); 7746489Sjmcp } 7756489Sjmcp 7766489Sjmcp /* CONSTCOND */ 7776489Sjmcp TAILQ_INIT(fw_devices); 7786489Sjmcp 7796489Sjmcp TAILQ_FOREACH(plugins, fw_pluginlist, nextplugin) { 7806489Sjmcp self = plugins->plugin; 7816489Sjmcp rv = plugins->plugin->fw_identify(startidx); 7826489Sjmcp 7836489Sjmcp logmsg(MSG_INFO, 7846489Sjmcp gettext("fwflash:flash_device_list() got %d from " 7856489Sjmcp "identify routine\n"), rv); 7866489Sjmcp 7876489Sjmcp /* only bump startidx if we've found at least one device */ 7886489Sjmcp if (rv == FWFLASH_SUCCESS) { 7896489Sjmcp startidx += 100; 7906489Sjmcp sumrv++; 7916489Sjmcp } else { 7926489Sjmcp logmsg(MSG_INFO, 7936489Sjmcp gettext("No flashable devices attached with " 7946489Sjmcp "the %s driver in this system\n"), 7956489Sjmcp plugins->drvname); 7966489Sjmcp } 7976489Sjmcp } 7986489Sjmcp 7996489Sjmcp if (sumrv > 0) 8006489Sjmcp rv = FWFLASH_SUCCESS; 8016489Sjmcp 8026489Sjmcp return (rv); 8036489Sjmcp } 8046489Sjmcp 8056489Sjmcp static int 8066489Sjmcp fwflash_list_fw(char *class) 8076489Sjmcp { 8086489Sjmcp int rv = 0; 8096489Sjmcp struct devicelist *curdev; 8106489Sjmcp int header = 1; 8116489Sjmcp 8126489Sjmcp TAILQ_FOREACH(curdev, fw_devices, nextdev) { 8136489Sjmcp 8146489Sjmcp /* we're either class-conscious, or we're not */ 8156489Sjmcp if (((class != NULL) && 8166489Sjmcp ((strncmp(curdev->classname, "ALL", 3) == 0) || 8176489Sjmcp (strcmp(curdev->classname, class) == 0))) || 8186489Sjmcp (class == NULL)) { 8196489Sjmcp 8206489Sjmcp if (header != 0) { 8216489Sjmcp (void) fprintf(stdout, 8226489Sjmcp gettext("List of available devices:\n")); 8236489Sjmcp header--; 8246489Sjmcp } 8256489Sjmcp /* 8266489Sjmcp * If any plugin's fw_devinfo() function returns 8276489Sjmcp * FWFLASH_FAILURE then we want to keep track of 8286489Sjmcp * it. _Most_ plugins should always return 8296489Sjmcp * FWFLASH_SUCCESS from this function. The only 8306489Sjmcp * exception known at this point is the tavor plugin. 8316489Sjmcp */ 8326489Sjmcp rv += curdev->plugin->fw_devinfo(curdev); 8336489Sjmcp } 8346489Sjmcp } 8356489Sjmcp return (rv); 8366489Sjmcp } 8376489Sjmcp 8386489Sjmcp static int 839*7317SJames.McPherson@Sun.COM fwflash_update(char *device, char *filename, int flags) 840*7317SJames.McPherson@Sun.COM { 8416489Sjmcp 8426489Sjmcp int rv = FWFLASH_FAILURE; 8436489Sjmcp int needsfree = 0; 8446846Sjmcp int found = 0; 8456489Sjmcp struct devicelist *curdev; 8466489Sjmcp char *realfile; 8476489Sjmcp 8486489Sjmcp /* 8496489Sjmcp * Here's how we operate: 8506489Sjmcp * 8516489Sjmcp * We perform some basic checks on the args, then walk 8526489Sjmcp * through the device list looking for the device which 8536489Sjmcp * matches. We then load the appropriate verifier for the 8546489Sjmcp * image file and device, verify the image, then call the 8556489Sjmcp * fw_writefw() function of the appropriate plugin. 8566489Sjmcp * 8576489Sjmcp * There is no "force" flag to enable you to flash a firmware 8586489Sjmcp * image onto an incompatible device because the verifier 8596489Sjmcp * will return FWFLASH_FAILURE if the image doesn't match. 8606489Sjmcp */ 8616489Sjmcp 8626489Sjmcp /* new firmware filename and device desc */ 8636489Sjmcp if (filename == NULL) { 8646489Sjmcp logmsg(MSG_ERROR, 8656489Sjmcp gettext("Invalid firmware filename (null)\n")); 8666489Sjmcp return (FWFLASH_FAILURE); 8676489Sjmcp } 8686489Sjmcp 8696489Sjmcp if (device == NULL) { 8706489Sjmcp logmsg(MSG_ERROR, 8716489Sjmcp gettext("Invalid device requested (null)\n")); 8726489Sjmcp return (FWFLASH_FAILURE); 8736489Sjmcp } 8746489Sjmcp 8756489Sjmcp if ((realfile = calloc(1, PATH_MAX + 1)) == NULL) { 8766489Sjmcp logmsg(MSG_ERROR, 8776489Sjmcp gettext("Unable to allocate space for device " 878*7317SJames.McPherson@Sun.COM "filename, operation might fail if %s is" 879*7317SJames.McPherson@Sun.COM "a symbolic link\n"), 8806489Sjmcp device); 8816489Sjmcp realfile = device; 8826489Sjmcp } else { 8836489Sjmcp /* 8846489Sjmcp * If realpath() succeeds, then we have a valid 8856489Sjmcp * device filename in realfile. 8866489Sjmcp */ 8876489Sjmcp if (realpath(device, realfile) == NULL) { 8886489Sjmcp logmsg(MSG_ERROR, 8896489Sjmcp gettext("Unable to resolve device filename" 890*7317SJames.McPherson@Sun.COM ": %s\n"), 8916489Sjmcp strerror(errno)); 8926489Sjmcp /* tidy up */ 8936489Sjmcp free(realfile); 8946489Sjmcp /* realpath didn't succeed, use fallback */ 8956489Sjmcp realfile = device; 8966489Sjmcp } else { 8976489Sjmcp needsfree = 1; 8986489Sjmcp } 8996489Sjmcp } 9006489Sjmcp 9016489Sjmcp logmsg(MSG_INFO, 9026489Sjmcp gettext("fwflash_update: fw_filename (%s) device (%s)\n"), 9036489Sjmcp filename, device); 9046489Sjmcp 9056489Sjmcp TAILQ_FOREACH(curdev, fw_devices, nextdev) { 9066489Sjmcp 9076489Sjmcp if (strcmp(curdev->access_devname, realfile) == 0) { 9086846Sjmcp found++; 9096489Sjmcp rv = fwflash_load_verifier(curdev->drvname, 9106489Sjmcp curdev->ident->vid, filename); 9116489Sjmcp if (rv == FWFLASH_FAILURE) { 9126489Sjmcp logmsg(MSG_ERROR, 9136489Sjmcp gettext("Unable to load verifier " 914*7317SJames.McPherson@Sun.COM "for device %s\n"), 9156489Sjmcp curdev->access_devname); 9166489Sjmcp return (FWFLASH_FAILURE); 9176489Sjmcp } 9186489Sjmcp rv = verifier->vendorvrfy(curdev); 9196489Sjmcp if (rv == FWFLASH_FAILURE) { 9206489Sjmcp /* the verifier prints a message */ 9216489Sjmcp logmsg(MSG_INFO, 9226489Sjmcp "verifier (%s) for %s :: %s returned " 9236489Sjmcp "FWFLASH_FAILURE\n", 9246489Sjmcp verifier->filename, 9256489Sjmcp filename, curdev->access_devname); 9266489Sjmcp return (rv); 9276489Sjmcp } 9286489Sjmcp 929*7317SJames.McPherson@Sun.COM if (((flags & FWFLASH_YES_FLAG) == FWFLASH_YES_FLAG) || 9306489Sjmcp (rv = confirm_target(curdev, filename)) == 9316489Sjmcp FWFLASH_YES_FLAG) { 9326489Sjmcp logmsg(MSG_INFO, 9336489Sjmcp "about to flash using plugin %s\n", 9346489Sjmcp curdev->plugin->filename); 9356489Sjmcp rv = curdev->plugin->fw_writefw(curdev, 9366489Sjmcp filename); 9376489Sjmcp if (rv == FWFLASH_FAILURE) { 9386489Sjmcp logmsg(MSG_ERROR, 9396489Sjmcp gettext("Failed to flash " 940*7317SJames.McPherson@Sun.COM "firmware file %s on " 941*7317SJames.McPherson@Sun.COM "device %s: %d\n"), 9426489Sjmcp filename, 9436489Sjmcp curdev->access_devname, rv); 9446489Sjmcp } 9456489Sjmcp } else { 9466489Sjmcp logmsg(MSG_ERROR, 9476489Sjmcp gettext("Flash operation not confirmed " 948*7317SJames.McPherson@Sun.COM "by user\n"), 9496489Sjmcp curdev->access_devname); 9506489Sjmcp rv = FWFLASH_FAILURE; 9516489Sjmcp } 9526489Sjmcp } 9536489Sjmcp } 9546489Sjmcp 9556846Sjmcp if (!found) 9566846Sjmcp /* report the same device that the user passed in */ 9576846Sjmcp logmsg(MSG_ERROR, 9586846Sjmcp gettext("Device %s does not appear " 9596846Sjmcp "to be flashable\n"), 9606846Sjmcp ((strncmp(device, realfile, strlen(device)) == 0) ? 9616846Sjmcp device : realfile)); 9626846Sjmcp 9636489Sjmcp if (needsfree) 9646489Sjmcp free(realfile); 9656489Sjmcp 9666489Sjmcp return (rv); 9676489Sjmcp } 9686489Sjmcp 9696489Sjmcp /* 9706489Sjmcp * We validate that the device path is in our global device list and 9716489Sjmcp * that the filename exists, then palm things off to the relevant plugin. 9726489Sjmcp */ 9736489Sjmcp static int 9746489Sjmcp fwflash_read_file(char *device, char *filename) 9756489Sjmcp { 9766489Sjmcp struct devicelist *curdev; 9776489Sjmcp int rv; 9786489Sjmcp int notfound = 0; 9796489Sjmcp 9806489Sjmcp /* new firmware filename and device desc */ 9816489Sjmcp 9826489Sjmcp TAILQ_FOREACH(curdev, fw_devices, nextdev) { 9836489Sjmcp if (strncmp(curdev->access_devname, device, 9846489Sjmcp MAXPATHLEN) == 0) { 9856489Sjmcp rv = curdev->plugin->fw_readfw(curdev, filename); 9866489Sjmcp 9876489Sjmcp if (rv != FWFLASH_SUCCESS) 9886489Sjmcp logmsg(MSG_ERROR, 9896489Sjmcp gettext("Unable to write out firmware " 9906489Sjmcp "image for %s to file %s\n"), 9916489Sjmcp curdev->access_devname, filename); 9926489Sjmcp } else { 9936489Sjmcp notfound++; 9946489Sjmcp } 9956489Sjmcp 9966489Sjmcp } 9976489Sjmcp if (notfound) { 9986489Sjmcp logmsg(MSG_ERROR, 9996489Sjmcp gettext("No device matching %s was found.\n"), 10006489Sjmcp device); 10016489Sjmcp rv = FWFLASH_FAILURE; 10026489Sjmcp } 10036489Sjmcp 10046489Sjmcp return (rv); 10056489Sjmcp } 10066489Sjmcp 10076489Sjmcp static void 10086489Sjmcp fwflash_usage(char *arg) 10096489Sjmcp { 10106489Sjmcp 10116489Sjmcp (void) fprintf(stderr, "\n"); 10126489Sjmcp if (arg != NULL) { 10136489Sjmcp logmsg(MSG_ERROR, 10146489Sjmcp gettext("Invalid argument (%s) supplied\n"), arg); 10156489Sjmcp } 10166489Sjmcp 10176489Sjmcp (void) fprintf(stderr, "\n"); 10186489Sjmcp 10196489Sjmcp (void) fprintf(stdout, gettext("Usage:\n\t")); 10206489Sjmcp (void) fprintf(stdout, gettext("fwflash [-l [-c device_class " 10216489Sjmcp "| ALL]] | [-v] | [-h]\n\t")); 10226489Sjmcp (void) fprintf(stdout, gettext("fwflash [-f file1,file2,file3" 10236489Sjmcp ",... | -r file] [-y] -d device_path\n\n")); 10246489Sjmcp (void) fprintf(stdout, "\n"); /* workaround for xgettext */ 10256489Sjmcp 10266489Sjmcp (void) fprintf(stdout, 10276489Sjmcp gettext("\t-l\t\tlist flashable devices in this system\n" 10286489Sjmcp "\t-c device_class limit search to a specific class\n" 10296489Sjmcp "\t\t\teg IB for InfiniBand, ses for SCSI Enclosures\n" 10306489Sjmcp "\t-v\t\tprint version number of fwflash utility\n" 10316489Sjmcp "\t-h\t\tprint this usage mesage\n\n")); 10326489Sjmcp (void) fprintf(stdout, 10336489Sjmcp gettext("\t-f file1,file2,file3,...\n" 10346489Sjmcp "\t\t\tfirmware image file list to flash\n" 10356489Sjmcp "\t-r file\t\tfile to dump device firmware to\n" 10366489Sjmcp "\t-y\t\tanswer Yes/Y/y to prompts\n" 10376489Sjmcp "\t-d device_path\tpathname of device to be flashed\n\n")); 10386489Sjmcp 10396489Sjmcp (void) fprintf(stdout, 10406489Sjmcp gettext("\tIf -d device_path is specified, then one of -f " 10416489Sjmcp "<files>\n" 10426489Sjmcp "\tor -r <file> must also be specified\n\n")); 10436489Sjmcp 10446489Sjmcp (void) fprintf(stdout, 10456489Sjmcp gettext("\tIf multiple firmware images are required to be " 10466489Sjmcp "flashed\n" 10476489Sjmcp "\tthey must be listed together, separated by commas. The\n" 10486489Sjmcp "\timages will be flashed in the order specified.\n\n")); 10496489Sjmcp 10506489Sjmcp (void) fprintf(stdout, "\n"); 10516489Sjmcp } 10526489Sjmcp 10536489Sjmcp static void 10546489Sjmcp fwflash_version(void) 10556489Sjmcp { 10566489Sjmcp (void) fprintf(stdout, gettext("\n%s: "), FWFLASH_PROG_NAME); 10576489Sjmcp (void) fprintf(stdout, gettext("version %s\n"), 10586489Sjmcp FWFLASH_VERSION); 10596489Sjmcp } 10606489Sjmcp 10616489Sjmcp static void 10626489Sjmcp fwflash_intr(int sig) 10636489Sjmcp { 10646489Sjmcp 10656489Sjmcp struct devicelist *thisdev; 10666489Sjmcp struct pluginlist *thisplug; 10676489Sjmcp 10686489Sjmcp 10696489Sjmcp (void) signal(SIGINT, SIG_IGN); 10706489Sjmcp (void) signal(SIGTERM, SIG_IGN); 10716846Sjmcp (void) signal(SIGABRT, SIG_IGN); 10726489Sjmcp if (fwflash_in_write) { 10736489Sjmcp (void) fprintf(stderr, 10746489Sjmcp gettext("WARNING: firmware image may be corrupted\n\t")); 10756489Sjmcp (void) fprintf(stderr, 10766489Sjmcp gettext("Reflash firmware before rebooting!\n")); 10776489Sjmcp } 10786489Sjmcp 10796489Sjmcp if (sig > 0) { 10806489Sjmcp (void) logmsg(MSG_ERROR, gettext("\n")); 10816489Sjmcp (void) logmsg(MSG_ERROR, 10826489Sjmcp gettext("fwflash exiting due to signal (%d)\n"), sig); 10836489Sjmcp } 10846489Sjmcp 10856489Sjmcp /* 10866489Sjmcp * we need to close everything down properly, so 10876489Sjmcp * call the plugin closure routines 10886489Sjmcp */ 10896489Sjmcp if (fw_devices != NULL) { 10906489Sjmcp TAILQ_FOREACH(thisdev, fw_devices, nextdev) { 10916489Sjmcp /* free the components first */ 10926489Sjmcp free(thisdev->access_devname); 10936489Sjmcp free(thisdev->drvname); 10946489Sjmcp free(thisdev->classname); 10956846Sjmcp if (thisdev->ident != NULL) 10966489Sjmcp free(thisdev->ident); 10976846Sjmcp 10986489Sjmcp thisdev->ident = NULL; 10996489Sjmcp thisdev->plugin = NULL; /* we free this elsewhere */ 11006489Sjmcp /* CONSTCOND */ 11016489Sjmcp TAILQ_REMOVE(fw_devices, thisdev, nextdev); 11026489Sjmcp } 11036489Sjmcp } 11046489Sjmcp 11056489Sjmcp if (fw_pluginlist != NULL) { 11066489Sjmcp TAILQ_FOREACH(thisplug, fw_pluginlist, nextplugin) { 11076489Sjmcp free(thisplug->filename); 11086489Sjmcp free(thisplug->drvname); 11096489Sjmcp free(thisplug->plugin->filename); 11106489Sjmcp free(thisplug->plugin->drvname); 11116489Sjmcp thisplug->filename = NULL; 11126489Sjmcp thisplug->drvname = NULL; 11136489Sjmcp thisplug->plugin->filename = NULL; 11146489Sjmcp thisplug->plugin->drvname = NULL; 11156489Sjmcp thisplug->plugin->fw_readfw = NULL; 11166489Sjmcp thisplug->plugin->fw_writefw = NULL; 11176489Sjmcp thisplug->plugin->fw_identify = NULL; 11186489Sjmcp thisplug->plugin->fw_devinfo = NULL; 11196489Sjmcp (void) dlclose(thisplug->plugin->handle); 11206489Sjmcp thisplug->plugin->handle = NULL; 11216489Sjmcp free(thisplug->plugin); 11226489Sjmcp thisplug->plugin = NULL; 11236489Sjmcp /* CONSTCOND */ 11246489Sjmcp TAILQ_REMOVE(fw_pluginlist, thisplug, nextplugin); 11256489Sjmcp } 11266489Sjmcp } 11276489Sjmcp 11286489Sjmcp if (verifier != NULL) { 11296489Sjmcp free(verifier->filename); 11306489Sjmcp free(verifier->vendor); 11316846Sjmcp free(verifier->imgfile); 11326846Sjmcp free(verifier->fwimage); 11336489Sjmcp verifier->filename = NULL; 11346489Sjmcp verifier->vendor = NULL; 11356489Sjmcp verifier->vendorvrfy = NULL; 11366846Sjmcp verifier->imgfile = NULL; 11376846Sjmcp verifier->fwimage = NULL; 11386489Sjmcp (void) dlclose(verifier->handle); 11396489Sjmcp verifier->handle = NULL; 11406489Sjmcp free(verifier); 11416489Sjmcp } 11426489Sjmcp di_fini(rootnode); 11436489Sjmcp } 11446489Sjmcp 11456489Sjmcp static void 11466489Sjmcp fwflash_handle_signals(void) 11476489Sjmcp { 11486489Sjmcp if (signal(SIGINT, fwflash_intr) == SIG_ERR) { 11496489Sjmcp perror("signal"); 11506489Sjmcp exit(FWFLASH_FAILURE); 11516489Sjmcp } 11526489Sjmcp 11536489Sjmcp if (signal(SIGTERM, fwflash_intr) == SIG_ERR) { 11546489Sjmcp perror("signal"); 11556489Sjmcp exit(FWFLASH_FAILURE); 11566489Sjmcp } 11576489Sjmcp } 11586489Sjmcp 11596489Sjmcp static int 11606489Sjmcp confirm_target(struct devicelist *thisdev, char *file) 11616489Sjmcp { 11626489Sjmcp int resp; 11636489Sjmcp 11646846Sjmcp (void) fflush(stdin); 11656846Sjmcp (void) printf(gettext("About to update firmware on %s\n"), 11666846Sjmcp thisdev->access_devname); 11676846Sjmcp (void) printf(gettext("with file %s. Do you want to continue? " 11686846Sjmcp "(Y/N): "), file); 11696489Sjmcp 11706489Sjmcp resp = getchar(); 11716489Sjmcp if (resp == 'Y' || resp == 'y') { 11726489Sjmcp return (FWFLASH_YES_FLAG); 11736489Sjmcp } else { 11746489Sjmcp logmsg(MSG_INFO, "flash operation NOT confirmed.\n"); 11756489Sjmcp } 11766489Sjmcp 11776489Sjmcp (void) fflush(stdin); 11786489Sjmcp return (FWFLASH_FAILURE); 11796489Sjmcp } 11806489Sjmcp 11816489Sjmcp int 11826489Sjmcp get_fileopts(char *options) 11836489Sjmcp { 11846489Sjmcp 11856489Sjmcp int i; 11866489Sjmcp char *files; 11876489Sjmcp 11886489Sjmcp if (files = strtok(options, ",")) { 11896489Sjmcp /* we have more than one */ 11906489Sjmcp if ((filelist[0] = calloc(1, MAXPATHLEN + 1)) == NULL) { 11916489Sjmcp logmsg(MSG_ERROR, 11926489Sjmcp gettext("Unable to allocate space for " 11936489Sjmcp "a firmware image filename\n")); 11946489Sjmcp return (FWFLASH_FAILURE); 11956489Sjmcp } 11966489Sjmcp (void) strlcpy(filelist[0], files, strlen(files) + 1); 11976489Sjmcp i = 1; 11986489Sjmcp 11996489Sjmcp logmsg(MSG_INFO, "fwflash: filelist[0]: %s\n", 12006489Sjmcp filelist[0]); 12016489Sjmcp 12026489Sjmcp 12036489Sjmcp while (files = strtok(NULL, ",")) { 12046489Sjmcp if ((filelist[i] = calloc(1, MAXPATHLEN + 1)) 12056489Sjmcp == NULL) { 12066489Sjmcp logmsg(MSG_ERROR, 12076489Sjmcp gettext("Unable to allocate space for " 12086489Sjmcp "a firmware image filename\n")); 12096489Sjmcp return (FWFLASH_FAILURE); 12106489Sjmcp } 12116489Sjmcp (void) strlcpy(filelist[i], files, 12126489Sjmcp strlen(files) + 1); 12136489Sjmcp logmsg(MSG_INFO, "fwflash: filelist[%d]: %s\n", 12146489Sjmcp i, filelist[i]); 12156489Sjmcp ++i; 12166489Sjmcp } 12176489Sjmcp } else { 12186489Sjmcp if ((filelist[0] = calloc(1, MAXPATHLEN + 1)) == NULL) { 12196489Sjmcp logmsg(MSG_ERROR, 12206489Sjmcp gettext("Unable to allocate space for " 12216489Sjmcp "a firmware image filename\n")); 12226489Sjmcp return (FWFLASH_FAILURE); 12236489Sjmcp } 12246489Sjmcp (void) strlcpy(filelist[0], options, strlen(files) + 1); 12256489Sjmcp logmsg(MSG_INFO, "fwflash: filelist[0]: %s\n", 12266489Sjmcp filelist[0]); 12276489Sjmcp } 12286489Sjmcp return (FWFLASH_SUCCESS); 12296489Sjmcp } 12306489Sjmcp 12316489Sjmcp /* 12326489Sjmcp * code reuse - cheerfully borrowed from stmsboot_util.c 12336489Sjmcp */ 12346489Sjmcp void 1235*7317SJames.McPherson@Sun.COM logmsg(int severity, const char *msg, ...) { 12366489Sjmcp 12376489Sjmcp va_list ap; 12386489Sjmcp 12396489Sjmcp if ((severity > MSG_INFO) || 12406489Sjmcp ((severity == MSG_INFO) && (fwflash_debug > 0))) { 12416489Sjmcp (void) fprintf(stderr, "%s: ", FWFLASH_PROG_NAME); 12426489Sjmcp va_start(ap, msg); 12436489Sjmcp (void) vfprintf(stderr, msg, ap); 12446489Sjmcp va_end(ap); 12456489Sjmcp } 12466489Sjmcp } 1247