Differential D1989

Correct the use of an unitialized variable in sendfind_getobj()
ClosedPublic
Actions

Authored by rstone on Feb 28 2015, 9:15 PM.

Details

Reviewers

Commits

rS279410: Correct the use of an unitialized variable in sendfind_getobj()

Summary

When sendfile_getobj() is called on a DTYPE_SHM file, it never
initializes error, which is eventually returned to the caller.

Reported by: Brainy Code Scanner, by Maxime Villard.

Diff Detail

Repository

rS FreeBSD src repository - subversion

Lint

Lint Skipped

Unit

Tests Skipped

Event Timeline

rstone updated this revision to Diff 4036.Feb 28 2015, 9:15 PM

rstone retitled this revision from to Correct the use of an unitialized variable in sendfind_getobj().

rstone edited the test plan for this revision. (Show Details)

rstone added a reviewer: kib.

rstone updated this object.

kib accepted this revision.Feb 28 2015, 9:19 PM

kib edited edge metadata.

This revision is now accepted and ready to land.Feb 28 2015, 9:19 PM

Closed by commit rS279410 (authored by @rstone).

Revision Contents
Changeset List

Path

Size

head/

sys/

kern/

uipc_syscalls.c

1 line

Diff 4037

View Options

head/sys/kern/uipc_syscalls.c

Show First 20 Lines • Show All 65 Lines • ▼ Show 20 Lines	bcm2835_firmware_probe(device_t dev)

if (ofw_bus_search_compatible(dev, compat_data)->ocd_data == 0)		if (ofw_bus_search_compatible(dev, compat_data)->ocd_data == 0)
return (ENXIO);		return (ENXIO);

device_set_desc(dev, "BCM2835 Firmware");		device_set_desc(dev, "BCM2835 Firmware");
return (BUS_PROBE_DEFAULT);		return (BUS_PROBE_DEFAULT);
}		}

		static device_t
		bcm2835_firmware_add_device(device_t dev, phandle_t node, u_int order,
		const char *name, int unit)
		{
		struct ofw_bus_devinfo *di;
		device_t cdev;

		di = malloc(sizeof(*di), M_DEVBUF, M_WAITOK \| M_ZERO);
		if (ofw_bus_gen_setup_devinfo(di, node) != 0) {
		free(di, M_DEVBUF);
		return (NULL);
		}
		cdev = device_add_child_ordered(dev, order, name, unit);
		if (cdev == NULL) {
		device_printf(dev, "<%s>: device_add_child failed\n",
		di->obd_name);
		ofw_bus_gen_destroy_devinfo(di);
		free(di, M_DEVBUF);
		return (NULL);
		}
		device_set_ivars(cdev, di);

		return(cdev);
		}

static int		static int
bcm2835_firmware_attach(device_t dev)		bcm2835_firmware_attach(device_t dev)
{		{
struct bcm2835_firmware_softc *sc;		struct bcm2835_firmware_softc *sc;
struct sysctl_ctx_list *ctx;		struct sysctl_ctx_list *ctx;
struct sysctl_oid *tree_node;		struct sysctl_oid *tree_node;
struct sysctl_oid_list *tree;		struct sysctl_oid_list *tree;
phandle_t node, mbox;		phandle_t node, mbox;
Show All 14 Lines	bcm2835_firmware_attach(device_t dev)

ctx = device_get_sysctl_ctx(sc->sc_dev);		ctx = device_get_sysctl_ctx(sc->sc_dev);
tree_node = device_get_sysctl_tree(sc->sc_dev);		tree_node = device_get_sysctl_tree(sc->sc_dev);
tree = SYSCTL_CHILDREN(tree_node);		tree = SYSCTL_CHILDREN(tree_node);
SYSCTL_ADD_PROC(ctx, tree, OID_AUTO, "revision",		SYSCTL_ADD_PROC(ctx, tree, OID_AUTO, "revision",
CTLTYPE_UINT \| CTLFLAG_RD, sc, sizeof(*sc),		CTLTYPE_UINT \| CTLFLAG_RD, sc, sizeof(*sc),
sysctl_bcm2835_firmware_get_revision, "IU",		sysctl_bcm2835_firmware_get_revision, "IU",
"Firmware revision");		"Firmware revision");
return (0);
		for (node = OF_child(node); node > 0; node = OF_peer(node))
		bcm2835_firmware_add_device(dev, node, 0, NULL, -1);
		return (bus_generic_attach(dev));
}		}

		static device_t
		bcm2835_firmware_add_child(device_t dev, u_int order, const char *name,
		int unit)
		{
		device_t cdev;
		struct ofw_bus_devinfo *ndi;

		cdev = device_add_child_ordered(dev, order, name, unit);
		if (cdev == NULL)
		return (NULL);

		ndi = malloc(sizeof(*ndi), M_DEVBUF, M_WAITOK \| M_ZERO);
		ndi->obd_node = -1;
		device_set_ivars(cdev, ndi);

		return (cdev);
		}

		static void
		bcm2835_firmware_probe_nomatch(device_t bus, device_t child)
		{
		const char name, type, *compat;

		if (!bootverbose)
		return;

		compat = ofw_bus_get_compat(child);
		if (compat == NULL)
		return;
		name = ofw_bus_get_name(child);
		type = ofw_bus_get_type(child);

		device_printf(bus, "<%s>", name != NULL ? name : "unknown");
		if (!ofw_bus_status_okay(child))
		printf(" disabled");
		if (type)
		printf(" type %s", type);
		printf(" compat %s (no driver attached)\n", compat);
		}

		static int
		bcm2835_firmware_print_child(device_t bus, device_t child)
		{
		int rv;

		rv = bus_print_child_header(bus, child);
		if (!ofw_bus_status_okay(child))
		rv += printf(" disabled");
		rv += bus_print_child_footer(bus, child);
		return (rv);
		}

		static const struct ofw_bus_devinfo *
		bcm2835_firmware_get_devinfo(device_t bus __unused, device_t child)
		{
		struct ofw_bus_devinfo *ndi;

		ndi = device_get_ivars(child);
		if (ndi == NULL)
		return (NULL);
		return (ndi);
		}


int		int
bcm2835_firmware_property(device_t dev, uint32_t prop, void *data, size_t len)		bcm2835_firmware_property(device_t dev, uint32_t prop, void *data, size_t len)
{		{
struct {		struct {
struct bcm2835_mbox_hdr hdr;		struct bcm2835_mbox_hdr hdr;
struct bcm2835_mbox_tag_hdr tag_hdr;		struct bcm2835_mbox_tag_hdr tag_hdr;
uint32_t data[];		uint32_t data[];
} *msg_hdr;		} *msg_hdr;
▲ Show 20 Lines • Show All 46 Lines • ▼ Show 20 Lines	sysctl_bcm2835_firmware_get_revision(SYSCTL_HANDLER_ARGS)
/* write request */		/* write request */
return (EINVAL);		return (EINVAL);
}		}

static device_method_t bcm2835_firmware_methods[] = {		static device_method_t bcm2835_firmware_methods[] = {
/* Device interface */		/* Device interface */
DEVMETHOD(device_probe, bcm2835_firmware_probe),		DEVMETHOD(device_probe, bcm2835_firmware_probe),
DEVMETHOD(device_attach, bcm2835_firmware_attach),		DEVMETHOD(device_attach, bcm2835_firmware_attach),

		/* Bus interface */
		DEVMETHOD(bus_add_child, bcm2835_firmware_add_child),
		DEVMETHOD(bus_print_child, bcm2835_firmware_print_child),
		DEVMETHOD(bus_probe_nomatch, bcm2835_firmware_probe_nomatch),
		DEVMETHOD(bus_read_ivar, bus_generic_read_ivar),
		DEVMETHOD(bus_write_ivar, bus_generic_write_ivar),
		DEVMETHOD(bus_child_pnpinfo_str, ofw_bus_gen_child_pnpinfo_str),

		/* ofw_bus interface */
		DEVMETHOD(ofw_bus_get_devinfo, bcm2835_firmware_get_devinfo),
		DEVMETHOD(ofw_bus_get_compat, ofw_bus_gen_get_compat),
		DEVMETHOD(ofw_bus_get_model, ofw_bus_gen_get_model),
		DEVMETHOD(ofw_bus_get_name, ofw_bus_gen_get_name),
		DEVMETHOD(ofw_bus_get_node, ofw_bus_gen_get_node),
		DEVMETHOD(ofw_bus_get_type, ofw_bus_gen_get_type),

DEVMETHOD_END		DEVMETHOD_END
};		};

static devclass_t bcm2835_firmware_devclass;		static devclass_t bcm2835_firmware_devclass;
static driver_t bcm2835_firmware_driver = {		static driver_t bcm2835_firmware_driver = {
"bcm2835_firmware",		"bcm2835_firmware",
bcm2835_firmware_methods,		bcm2835_firmware_methods,
sizeof(struct bcm2835_firmware_softc),		sizeof(struct bcm2835_firmware_softc),
};		};

EARLY_DRIVER_MODULE(bcm2835_firmware, simplebus, bcm2835_firmware_driver,		EARLY_DRIVER_MODULE(bcm2835_firmware, simplebus, bcm2835_firmware_driver,
bcm2835_firmware_devclass, 0, 0, BUS_PASS_INTERRUPT + BUS_PASS_ORDER_LAST);		bcm2835_firmware_devclass, 0, 0, BUS_PASS_INTERRUPT + BUS_PASS_ORDER_LAST);
MODULE_DEPEND(bcm2835_firmware, mbox, 1, 1, 1);		MODULE_DEPEND(bcm2835_firmware, mbox, 1, 1, 1);

Correct the use of an unitialized variable in sendfind_getobj()ClosedPublicActions