NetBSD/sys/dev/firmload.c

344 lines
7.6 KiB
C

/* $NetBSD: firmload.c,v 1.24 2022/10/26 23:39:10 riastradh Exp $ */
/*-
* Copyright (c) 2005, 2006 The NetBSD Foundation, Inc.
* All rights reserved.
*
* This code is derived from software contributed to The NetBSD Foundation
* by Jason R. Thorpe.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: firmload.c,v 1.24 2022/10/26 23:39:10 riastradh Exp $");
/*
* The firmload API provides an interface for device drivers to access
* firmware images that must be loaded onto their devices.
*/
#include <sys/param.h>
#include <sys/fcntl.h>
#include <sys/filedesc.h>
#include <sys/kmem.h>
#include <sys/namei.h>
#include <sys/systm.h>
#include <sys/sysctl.h>
#include <sys/vnode.h>
#include <sys/kauth.h>
#include <sys/lwp.h>
#include <dev/firmload.h>
struct firmware_handle {
struct vnode *fh_vp;
off_t fh_size;
};
static firmware_handle_t
firmware_handle_alloc(void)
{
return (kmem_alloc(sizeof(struct firmware_handle), KM_SLEEP));
}
static void
firmware_handle_free(firmware_handle_t fh)
{
kmem_free(fh, sizeof(*fh));
}
#if !defined(FIRMWARE_PATHS)
#define FIRMWARE_PATHS \
"/libdata/firmware:/usr/libdata/firmware:/usr/pkg/libdata/firmware:/usr/pkg/libdata"
#endif
static char firmware_paths[PATH_MAX+1] = FIRMWARE_PATHS;
static int
sysctl_hw_firmware_path(SYSCTLFN_ARGS)
{
int error, i;
char newpath[PATH_MAX+1];
struct sysctlnode node;
char expected_char;
node = *rnode;
node.sysctl_data = &newpath[0];
memcpy(node.sysctl_data, rnode->sysctl_data, PATH_MAX+1);
error = sysctl_lookup(SYSCTLFN_CALL(&node));
if (error || newp == NULL)
return (error);
/*
* Make sure that all of the paths in the new path list are
* absolute.
*
* When sysctl_lookup() deals with a string, it's guaranteed
* to come back nul-terminated.
*/
expected_char = '/';
for (i = 0; i < PATH_MAX+1; i++) {
if (expected_char != 0 && newpath[i] != expected_char)
return (EINVAL);
if (newpath[i] == '\0')
break;
else if (newpath[i] == ':')
expected_char = '/';
else
expected_char = 0;
}
memcpy(rnode->sysctl_data, node.sysctl_data, PATH_MAX+1);
return (0);
}
SYSCTL_SETUP(sysctl_hw_firmware_setup, "sysctl hw.firmware subtree setup")
{
const struct sysctlnode *firmware_node;
if (sysctl_createv(clog, 0, NULL, &firmware_node,
CTLFLAG_PERMANENT,
CTLTYPE_NODE, "firmware", NULL,
NULL, 0, NULL, 0,
CTL_HW, CTL_CREATE, CTL_EOL) != 0)
return;
sysctl_createv(clog, 0, NULL, NULL,
CTLFLAG_READWRITE,
CTLTYPE_STRING, "path",
SYSCTL_DESCR("Device firmware loading path list"),
sysctl_hw_firmware_path, 0, firmware_paths, PATH_MAX+1,
CTL_HW, firmware_node->sysctl_num, CTL_CREATE, CTL_EOL);
}
static char *
firmware_path_next(const char *drvname, const char *imgname, char *pnbuf,
char **prefixp)
{
char *prefix = *prefixp;
size_t maxprefix, i;
if (prefix == NULL /* terminated early */
|| *prefix != '/') { /* empty or not absolute */
*prefixp = NULL;
return (NULL);
}
/*
* Compute the max path prefix based on the length of the provided
* names.
*/
maxprefix = MAXPATHLEN -
(1 /* / */
+ strlen(drvname)
+ 1 /* / */
+ strlen(imgname)
+ 1 /* terminating NUL */);
/* Check for underflow (size_t is unsigned). */
if (maxprefix > MAXPATHLEN) {
*prefixp = NULL;
return (NULL);
}
for (i = 0; i < maxprefix; i++) {
if (*prefix == ':' || *prefix == '\0')
break;
pnbuf[i] = *prefix++;
}
if (*prefix != ':' && *prefix != '\0') {
/* Path prefix was too long. */
*prefixp = NULL;
return (NULL);
}
if (*prefix != '\0')
prefix++;
*prefixp = prefix;
KASSERT(MAXPATHLEN >= i);
snprintf(pnbuf + i, MAXPATHLEN - i, "/%s/%s", drvname, imgname);
return (pnbuf);
}
static char *
firmware_path_first(const char *drvname, const char *imgname, char *pnbuf,
char **prefixp)
{
*prefixp = firmware_paths;
return (firmware_path_next(drvname, imgname, pnbuf, prefixp));
}
/*
* firmware_open:
*
* Open a firmware image and return its handle.
*/
int
firmware_open(const char *drvname, const char *imgname, firmware_handle_t *fhp)
{
struct pathbuf *pb;
struct vattr va;
char *pnbuf, *path, *prefix;
firmware_handle_t fh;
struct vnode *vp;
int error;
if (drvname == NULL || imgname == NULL)
return (EINVAL);
if (cwdi0.cwdi_cdir == NULL) {
printf("firmware_open(%s/%s) called too early.\n",
drvname, imgname);
return ENOENT;
}
pnbuf = PNBUF_GET();
KASSERT(pnbuf != NULL);
fh = firmware_handle_alloc();
KASSERT(fh != NULL);
error = 0;
for (path = firmware_path_first(drvname, imgname, pnbuf, &prefix);
path != NULL;
path = firmware_path_next(drvname, imgname, pnbuf, &prefix)) {
pb = pathbuf_create(path);
if (pb == NULL) {
error = ENOMEM;
break;
}
error = vn_open(NULL, pb, NOCHROOT, FREAD, 0, &vp, NULL, NULL);
pathbuf_destroy(pb);
if (error == ENOENT) {
continue;
}
break;
}
PNBUF_PUT(pnbuf);
if (error) {
firmware_handle_free(fh);
return (error);
}
error = VOP_GETATTR(vp, &va, kauth_cred_get());
if (error) {
VOP_UNLOCK(vp);
(void)vn_close(vp, FREAD, kauth_cred_get());
firmware_handle_free(fh);
return (error);
}
if (va.va_type != VREG) {
VOP_UNLOCK(vp);
(void)vn_close(vp, FREAD, kauth_cred_get());
firmware_handle_free(fh);
return (EINVAL);
}
/* XXX Mark as busy text file. */
fh->fh_vp = vp;
fh->fh_size = va.va_size;
VOP_UNLOCK(vp);
*fhp = fh;
return (0);
}
/*
* firmware_close:
*
* Close a firmware image.
*/
int
firmware_close(firmware_handle_t fh)
{
int error;
error = vn_close(fh->fh_vp, FREAD, kauth_cred_get());
firmware_handle_free(fh);
return (error);
}
/*
* firmware_get_size:
*
* Return the total size of a firmware image.
*/
off_t
firmware_get_size(firmware_handle_t fh)
{
return (fh->fh_size);
}
/*
* firmware_read:
*
* Read data from a firmware image at the specified offset into
* the provided buffer.
*/
int
firmware_read(firmware_handle_t fh, off_t offset, void *buf, size_t len)
{
return (vn_rdwr(UIO_READ, fh->fh_vp, buf, len, offset,
UIO_SYSSPACE, 0, kauth_cred_get(), NULL, curlwp));
}
/*
* firmware_malloc:
*
* Allocate a firmware buffer of the specified size.
*
* NOTE: This routine may block.
*/
void *
firmware_malloc(size_t size)
{
return (kmem_alloc(size, KM_SLEEP));
}
/*
* firmware_free:
*
* Free a previously allocated firmware buffer.
*/
/*ARGSUSED*/
void
firmware_free(void *v, size_t size)
{
kmem_free(v, size);
}