Page MenuHomeFreeBSD
Differential D1049

Implement dup3() system call.
ClosedPublic
Actions

Authored by dchagin on Oct 31 2014, 6:45 AM.
Tags
None
Referenced Files
Unknown Object (File)
Mon, Apr 14, 6:49 AM
Unknown Object (File)
Mon, Apr 14, 5:44 AM
Unknown Object (File)
Mon, Apr 14, 5:25 AM
Unknown Object (File)
Mon, Apr 14, 3:14 AM
Unknown Object (File)
Thu, Apr 10, 5:16 PM
Unknown Object (File)
Sun, Apr 6, 12:55 PM
Unknown Object (File)
Mar 9 2025, 8:59 PM
Unknown Object (File)
Mar 4 2025, 6:55 PM
View All Files
Subscribers
None

Details

Reviewers
emaste
Group Reviewers
Linux Emulation
Commits
rS283399: Implement dup3() system call.

Diff Detail

Lint
No Lint Coverage
Unit
No Test Coverage

Event Timeline

dchagin updated this revision to Diff 2179.Oct 31 2014, 6:45 AM
dchagin retitled this revision from to Implement dup3() system call..
dchagin added a reviewer: Linux Emulation.Oct 31 2014, 6:59 AM
emaste accepted this revision.Oct 31 2014, 1:37 PM
emaste added a reviewer: emaste.
This revision is now accepted and ready to land.Oct 31 2014, 1:37 PM
Closed by commit rS283399: Implement dup3() system call. (authored by dchagin). · Explain WhyMay 24 2015, 3:14 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathSize
sys/
amd64/
linux32/
1 line
3 lines
compat/
linux/
19 lines
i386/
linux/
1 line
3 lines

Diff 2179

View Options

sys/amd64/linux32/linux32_dummy.c

Show First 20 Lines • Show All 45 Lines • ▼ Show 20 Lines
static int ofw_cpulist_probe(device_t); static int ofw_cpulist_probe(device_t);
static int ofw_cpulist_attach(device_t); static int ofw_cpulist_attach(device_t);
static const struct ofw_bus_devinfo *ofw_cpulist_get_devinfo(device_t dev, static const struct ofw_bus_devinfo *ofw_cpulist_get_devinfo(device_t dev,
device_t child); device_t child);
static MALLOC_DEFINE(M_OFWCPU, "ofwcpu", "OFW CPU device information"); static MALLOC_DEFINE(M_OFWCPU, "ofwcpu", "OFW CPU device information");
struct ofw_cpulist_softc {
pcell_t sc_addr_cells;
};
static device_method_t ofw_cpulist_methods[] = { static device_method_t ofw_cpulist_methods[] = {
/* Device interface */ /* Device interface */
DEVMETHOD(device_probe, ofw_cpulist_probe), DEVMETHOD(device_probe, ofw_cpulist_probe),
DEVMETHOD(device_attach, ofw_cpulist_attach), DEVMETHOD(device_attach, ofw_cpulist_attach),
/* Bus interface */ /* Bus interface */
DEVMETHOD(bus_add_child, bus_generic_add_child), DEVMETHOD(bus_add_child, bus_generic_add_child),
DEVMETHOD(bus_child_pnpinfo_str, ofw_bus_gen_child_pnpinfo_str), DEVMETHOD(bus_child_pnpinfo_str, ofw_bus_gen_child_pnpinfo_str),
/* ofw_bus interface */ /* ofw_bus interface */
DEVMETHOD(ofw_bus_get_devinfo, ofw_cpulist_get_devinfo), DEVMETHOD(ofw_bus_get_devinfo, ofw_cpulist_get_devinfo),
DEVMETHOD(ofw_bus_get_compat, ofw_bus_gen_get_compat), DEVMETHOD(ofw_bus_get_compat, ofw_bus_gen_get_compat),
DEVMETHOD(ofw_bus_get_model, ofw_bus_gen_get_model), DEVMETHOD(ofw_bus_get_model, ofw_bus_gen_get_model),
DEVMETHOD(ofw_bus_get_name, ofw_bus_gen_get_name), DEVMETHOD(ofw_bus_get_name, ofw_bus_gen_get_name),
DEVMETHOD(ofw_bus_get_node, ofw_bus_gen_get_node), DEVMETHOD(ofw_bus_get_node, ofw_bus_gen_get_node),
DEVMETHOD(ofw_bus_get_type, ofw_bus_gen_get_type), DEVMETHOD(ofw_bus_get_type, ofw_bus_gen_get_type),
DEVMETHOD_END DEVMETHOD_END
}; };
static driver_t ofw_cpulist_driver = { static driver_t ofw_cpulist_driver = {
"cpulist", "cpulist",
ofw_cpulist_methods, ofw_cpulist_methods,
0 sizeof(struct ofw_cpulist_softc)
}; };
static devclass_t ofw_cpulist_devclass; static devclass_t ofw_cpulist_devclass;
DRIVER_MODULE(ofw_cpulist, ofwbus, ofw_cpulist_driver, ofw_cpulist_devclass, DRIVER_MODULE(ofw_cpulist, ofwbus, ofw_cpulist_driver, ofw_cpulist_devclass,
0, 0); 0, 0);
static int static int
Show All 9 Linesofw_cpulist_probe(device_t dev)
device_set_desc(dev, "Open Firmware CPU Group"); device_set_desc(dev, "Open Firmware CPU Group");
return (0); return (0);
} }
static int static int
ofw_cpulist_attach(device_t dev) ofw_cpulist_attach(device_t dev)
{ {
struct ofw_cpulist_softc *sc;
phandle_t root, child; phandle_t root, child;
device_t cdev; device_t cdev;
struct ofw_bus_devinfo *dinfo; struct ofw_bus_devinfo *dinfo;
sc = device_get_softc(dev);
root = ofw_bus_get_node(dev); root = ofw_bus_get_node(dev);
sc->sc_addr_cells = 1;
OF_getencprop(root, "#address-cells", &sc->sc_addr_cells,
sizeof(sc->sc_addr_cells));
for (child = OF_child(root); child != 0; child = OF_peer(child)) { for (child = OF_child(root); child != 0; child = OF_peer(child)) {
dinfo = malloc(sizeof(*dinfo), M_OFWCPU, M_WAITOK | M_ZERO); dinfo = malloc(sizeof(*dinfo), M_OFWCPU, M_WAITOK | M_ZERO);
if (ofw_bus_gen_setup_devinfo(dinfo, child) != 0) { if (ofw_bus_gen_setup_devinfo(dinfo, child) != 0) {
free(dinfo, M_OFWCPU); free(dinfo, M_OFWCPU);
continue; continue;
} }
cdev = device_add_child(dev, NULL, -1); cdev = device_add_child(dev, NULL, -1);
Show All 19 Lines
static int ofw_cpu_probe(device_t); static int ofw_cpu_probe(device_t);
static int ofw_cpu_attach(device_t); static int ofw_cpu_attach(device_t);
static int ofw_cpu_read_ivar(device_t dev, device_t child, int index, static int ofw_cpu_read_ivar(device_t dev, device_t child, int index,
uintptr_t *result); uintptr_t *result);
struct ofw_cpu_softc { struct ofw_cpu_softc {
struct pcpu *sc_cpu_pcpu; struct pcpu *sc_cpu_pcpu;
uint32_t sc_nominal_mhz; uint32_t sc_nominal_mhz;
boolean_t sc_reg_valid;
pcell_t sc_reg[2];
}; };
static device_method_t ofw_cpu_methods[] = { static device_method_t ofw_cpu_methods[] = {
/* Device interface */ /* Device interface */
DEVMETHOD(device_probe, ofw_cpu_probe), DEVMETHOD(device_probe, ofw_cpu_probe),
DEVMETHOD(device_attach, ofw_cpu_attach), DEVMETHOD(device_attach, ofw_cpu_attach),
/* Bus interface */ /* Bus interface */
Show All 28 Linesofw_cpu_probe(device_t dev)
device_set_desc(dev, "Open Firmware CPU"); device_set_desc(dev, "Open Firmware CPU");
return (0); return (0);
} }
static int static int
ofw_cpu_attach(device_t dev) ofw_cpu_attach(device_t dev)
{ {
struct ofw_cpulist_softc *psc;
struct ofw_cpu_softc *sc; struct ofw_cpu_softc *sc;
phandle_t node; phandle_t node;
uint32_t cell; pcell_t cell;
int rv;
sc = device_get_softc(dev); sc = device_get_softc(dev);
node = ofw_bus_get_node(dev); psc = device_get_softc(device_get_parent(dev));
if (OF_getencprop(node, "reg", &cell, sizeof(cell)) < 0) {
cell = device_get_unit(dev); if (nitems(sc->sc_reg) < psc->sc_addr_cells) {
device_printf(dev, "missing 'reg' property, using %u\n", cell); if (bootverbose)
device_printf(dev, "Too many address cells\n");
return (EINVAL);
} }
sc->sc_cpu_pcpu = pcpu_find(cell);
node = ofw_bus_get_node(dev);
/* Read and validate the reg property for use later */
sc->sc_reg_valid = false;
rv = OF_getencprop(node, "reg", sc->sc_reg, sizeof(sc->sc_reg));
if (rv < 0)
device_printf(dev, "missing 'reg' property\n");
else if ((rv % 4) != 0) {
if (bootverbose)
device_printf(dev, "Malformed reg property\n");
} else if ((rv / 4) != psc->sc_addr_cells) {
if (bootverbose)
device_printf(dev, "Invalid reg size %u\n", rv);
} else
sc->sc_reg_valid = true;
sc->sc_cpu_pcpu = pcpu_find(device_get_unit(dev));
if (OF_getencprop(node, "clock-frequency", &cell, sizeof(cell)) < 0) { if (OF_getencprop(node, "clock-frequency", &cell, sizeof(cell)) < 0) {
if (bootverbose) if (bootverbose)
device_printf(dev, device_printf(dev,
"missing 'clock-frequency' property\n"); "missing 'clock-frequency' property\n");
} else } else
sc->sc_nominal_mhz = cell / 1000000; /* convert to MHz */ sc->sc_nominal_mhz = cell / 1000000; /* convert to MHz */
bus_generic_probe(dev); bus_generic_probe(dev);
Show All 25 Lines
View Options

sys/amd64/linux32/syscalls.master

Show First 20 Lines • Show All 45 Lines • ▼ Show 20 Lines
static int ofw_cpulist_probe(device_t); static int ofw_cpulist_probe(device_t);
static int ofw_cpulist_attach(device_t); static int ofw_cpulist_attach(device_t);
static const struct ofw_bus_devinfo *ofw_cpulist_get_devinfo(device_t dev, static const struct ofw_bus_devinfo *ofw_cpulist_get_devinfo(device_t dev,
device_t child); device_t child);
static MALLOC_DEFINE(M_OFWCPU, "ofwcpu", "OFW CPU device information"); static MALLOC_DEFINE(M_OFWCPU, "ofwcpu", "OFW CPU device information");
struct ofw_cpulist_softc {
pcell_t sc_addr_cells;
};
static device_method_t ofw_cpulist_methods[] = { static device_method_t ofw_cpulist_methods[] = {
/* Device interface */ /* Device interface */
DEVMETHOD(device_probe, ofw_cpulist_probe), DEVMETHOD(device_probe, ofw_cpulist_probe),
DEVMETHOD(device_attach, ofw_cpulist_attach), DEVMETHOD(device_attach, ofw_cpulist_attach),
/* Bus interface */ /* Bus interface */
DEVMETHOD(bus_add_child, bus_generic_add_child), DEVMETHOD(bus_add_child, bus_generic_add_child),
DEVMETHOD(bus_child_pnpinfo_str, ofw_bus_gen_child_pnpinfo_str), DEVMETHOD(bus_child_pnpinfo_str, ofw_bus_gen_child_pnpinfo_str),
/* ofw_bus interface */ /* ofw_bus interface */
DEVMETHOD(ofw_bus_get_devinfo, ofw_cpulist_get_devinfo), DEVMETHOD(ofw_bus_get_devinfo, ofw_cpulist_get_devinfo),
DEVMETHOD(ofw_bus_get_compat, ofw_bus_gen_get_compat), DEVMETHOD(ofw_bus_get_compat, ofw_bus_gen_get_compat),
DEVMETHOD(ofw_bus_get_model, ofw_bus_gen_get_model), DEVMETHOD(ofw_bus_get_model, ofw_bus_gen_get_model),
DEVMETHOD(ofw_bus_get_name, ofw_bus_gen_get_name), DEVMETHOD(ofw_bus_get_name, ofw_bus_gen_get_name),
DEVMETHOD(ofw_bus_get_node, ofw_bus_gen_get_node), DEVMETHOD(ofw_bus_get_node, ofw_bus_gen_get_node),
DEVMETHOD(ofw_bus_get_type, ofw_bus_gen_get_type), DEVMETHOD(ofw_bus_get_type, ofw_bus_gen_get_type),
DEVMETHOD_END DEVMETHOD_END
}; };
static driver_t ofw_cpulist_driver = { static driver_t ofw_cpulist_driver = {
"cpulist", "cpulist",
ofw_cpulist_methods, ofw_cpulist_methods,
0 sizeof(struct ofw_cpulist_softc)
}; };
static devclass_t ofw_cpulist_devclass; static devclass_t ofw_cpulist_devclass;
DRIVER_MODULE(ofw_cpulist, ofwbus, ofw_cpulist_driver, ofw_cpulist_devclass, DRIVER_MODULE(ofw_cpulist, ofwbus, ofw_cpulist_driver, ofw_cpulist_devclass,
0, 0); 0, 0);
static int static int
Show All 9 Linesofw_cpulist_probe(device_t dev)
device_set_desc(dev, "Open Firmware CPU Group"); device_set_desc(dev, "Open Firmware CPU Group");
return (0); return (0);
} }
static int static int
ofw_cpulist_attach(device_t dev) ofw_cpulist_attach(device_t dev)
{ {
struct ofw_cpulist_softc *sc;
phandle_t root, child; phandle_t root, child;
device_t cdev; device_t cdev;
struct ofw_bus_devinfo *dinfo; struct ofw_bus_devinfo *dinfo;
sc = device_get_softc(dev);
root = ofw_bus_get_node(dev); root = ofw_bus_get_node(dev);
sc->sc_addr_cells = 1;
OF_getencprop(root, "#address-cells", &sc->sc_addr_cells,
sizeof(sc->sc_addr_cells));
for (child = OF_child(root); child != 0; child = OF_peer(child)) { for (child = OF_child(root); child != 0; child = OF_peer(child)) {
dinfo = malloc(sizeof(*dinfo), M_OFWCPU, M_WAITOK | M_ZERO); dinfo = malloc(sizeof(*dinfo), M_OFWCPU, M_WAITOK | M_ZERO);
if (ofw_bus_gen_setup_devinfo(dinfo, child) != 0) { if (ofw_bus_gen_setup_devinfo(dinfo, child) != 0) {
free(dinfo, M_OFWCPU); free(dinfo, M_OFWCPU);
continue; continue;
} }
cdev = device_add_child(dev, NULL, -1); cdev = device_add_child(dev, NULL, -1);
Show All 19 Lines
static int ofw_cpu_probe(device_t); static int ofw_cpu_probe(device_t);
static int ofw_cpu_attach(device_t); static int ofw_cpu_attach(device_t);
static int ofw_cpu_read_ivar(device_t dev, device_t child, int index, static int ofw_cpu_read_ivar(device_t dev, device_t child, int index,
uintptr_t *result); uintptr_t *result);
struct ofw_cpu_softc { struct ofw_cpu_softc {
struct pcpu *sc_cpu_pcpu; struct pcpu *sc_cpu_pcpu;
uint32_t sc_nominal_mhz; uint32_t sc_nominal_mhz;
boolean_t sc_reg_valid;
pcell_t sc_reg[2];
}; };
static device_method_t ofw_cpu_methods[] = { static device_method_t ofw_cpu_methods[] = {
/* Device interface */ /* Device interface */
DEVMETHOD(device_probe, ofw_cpu_probe), DEVMETHOD(device_probe, ofw_cpu_probe),
DEVMETHOD(device_attach, ofw_cpu_attach), DEVMETHOD(device_attach, ofw_cpu_attach),
/* Bus interface */ /* Bus interface */
Show All 28 Linesofw_cpu_probe(device_t dev)
device_set_desc(dev, "Open Firmware CPU"); device_set_desc(dev, "Open Firmware CPU");
return (0); return (0);
} }
static int static int
ofw_cpu_attach(device_t dev) ofw_cpu_attach(device_t dev)
{ {
struct ofw_cpulist_softc *psc;
struct ofw_cpu_softc *sc; struct ofw_cpu_softc *sc;
phandle_t node; phandle_t node;
uint32_t cell; pcell_t cell;
int rv;
sc = device_get_softc(dev); sc = device_get_softc(dev);
node = ofw_bus_get_node(dev); psc = device_get_softc(device_get_parent(dev));
if (OF_getencprop(node, "reg", &cell, sizeof(cell)) < 0) {
cell = device_get_unit(dev); if (nitems(sc->sc_reg) < psc->sc_addr_cells) {
device_printf(dev, "missing 'reg' property, using %u\n", cell); if (bootverbose)
device_printf(dev, "Too many address cells\n");
return (EINVAL);
} }
sc->sc_cpu_pcpu = pcpu_find(cell);
node = ofw_bus_get_node(dev);
/* Read and validate the reg property for use later */
sc->sc_reg_valid = false;
rv = OF_getencprop(node, "reg", sc->sc_reg, sizeof(sc->sc_reg));
if (rv < 0)
device_printf(dev, "missing 'reg' property\n");
else if ((rv % 4) != 0) {
if (bootverbose)
device_printf(dev, "Malformed reg property\n");
} else if ((rv / 4) != psc->sc_addr_cells) {
if (bootverbose)
device_printf(dev, "Invalid reg size %u\n", rv);
} else
sc->sc_reg_valid = true;
sc->sc_cpu_pcpu = pcpu_find(device_get_unit(dev));
if (OF_getencprop(node, "clock-frequency", &cell, sizeof(cell)) < 0) { if (OF_getencprop(node, "clock-frequency", &cell, sizeof(cell)) < 0) {
if (bootverbose) if (bootverbose)
device_printf(dev, device_printf(dev,
"missing 'clock-frequency' property\n"); "missing 'clock-frequency' property\n");
} else } else
sc->sc_nominal_mhz = cell / 1000000; /* convert to MHz */ sc->sc_nominal_mhz = cell / 1000000; /* convert to MHz */
bus_generic_probe(dev); bus_generic_probe(dev);
Show All 25 Lines
View Options

sys/compat/linux/linux_file.c

Show First 20 Lines • Show All 45 Lines • ▼ Show 20 Lines
static int ofw_cpulist_probe(device_t); static int ofw_cpulist_probe(device_t);
static int ofw_cpulist_attach(device_t); static int ofw_cpulist_attach(device_t);
static const struct ofw_bus_devinfo *ofw_cpulist_get_devinfo(device_t dev, static const struct ofw_bus_devinfo *ofw_cpulist_get_devinfo(device_t dev,
device_t child); device_t child);
static MALLOC_DEFINE(M_OFWCPU, "ofwcpu", "OFW CPU device information"); static MALLOC_DEFINE(M_OFWCPU, "ofwcpu", "OFW CPU device information");
struct ofw_cpulist_softc {
pcell_t sc_addr_cells;
};
static device_method_t ofw_cpulist_methods[] = { static device_method_t ofw_cpulist_methods[] = {
/* Device interface */ /* Device interface */
DEVMETHOD(device_probe, ofw_cpulist_probe), DEVMETHOD(device_probe, ofw_cpulist_probe),
DEVMETHOD(device_attach, ofw_cpulist_attach), DEVMETHOD(device_attach, ofw_cpulist_attach),
/* Bus interface */ /* Bus interface */
DEVMETHOD(bus_add_child, bus_generic_add_child), DEVMETHOD(bus_add_child, bus_generic_add_child),
DEVMETHOD(bus_child_pnpinfo_str, ofw_bus_gen_child_pnpinfo_str), DEVMETHOD(bus_child_pnpinfo_str, ofw_bus_gen_child_pnpinfo_str),
/* ofw_bus interface */ /* ofw_bus interface */
DEVMETHOD(ofw_bus_get_devinfo, ofw_cpulist_get_devinfo), DEVMETHOD(ofw_bus_get_devinfo, ofw_cpulist_get_devinfo),
DEVMETHOD(ofw_bus_get_compat, ofw_bus_gen_get_compat), DEVMETHOD(ofw_bus_get_compat, ofw_bus_gen_get_compat),
DEVMETHOD(ofw_bus_get_model, ofw_bus_gen_get_model), DEVMETHOD(ofw_bus_get_model, ofw_bus_gen_get_model),
DEVMETHOD(ofw_bus_get_name, ofw_bus_gen_get_name), DEVMETHOD(ofw_bus_get_name, ofw_bus_gen_get_name),
DEVMETHOD(ofw_bus_get_node, ofw_bus_gen_get_node), DEVMETHOD(ofw_bus_get_node, ofw_bus_gen_get_node),
DEVMETHOD(ofw_bus_get_type, ofw_bus_gen_get_type), DEVMETHOD(ofw_bus_get_type, ofw_bus_gen_get_type),
DEVMETHOD_END DEVMETHOD_END
}; };
static driver_t ofw_cpulist_driver = { static driver_t ofw_cpulist_driver = {
"cpulist", "cpulist",
ofw_cpulist_methods, ofw_cpulist_methods,
0 sizeof(struct ofw_cpulist_softc)
}; };
static devclass_t ofw_cpulist_devclass; static devclass_t ofw_cpulist_devclass;
DRIVER_MODULE(ofw_cpulist, ofwbus, ofw_cpulist_driver, ofw_cpulist_devclass, DRIVER_MODULE(ofw_cpulist, ofwbus, ofw_cpulist_driver, ofw_cpulist_devclass,
0, 0); 0, 0);
static int static int
Show All 9 Linesofw_cpulist_probe(device_t dev)
device_set_desc(dev, "Open Firmware CPU Group"); device_set_desc(dev, "Open Firmware CPU Group");
return (0); return (0);
} }
static int static int
ofw_cpulist_attach(device_t dev) ofw_cpulist_attach(device_t dev)
{ {
struct ofw_cpulist_softc *sc;
phandle_t root, child; phandle_t root, child;
device_t cdev; device_t cdev;
struct ofw_bus_devinfo *dinfo; struct ofw_bus_devinfo *dinfo;
sc = device_get_softc(dev);
root = ofw_bus_get_node(dev); root = ofw_bus_get_node(dev);
sc->sc_addr_cells = 1;
OF_getencprop(root, "#address-cells", &sc->sc_addr_cells,
sizeof(sc->sc_addr_cells));
for (child = OF_child(root); child != 0; child = OF_peer(child)) { for (child = OF_child(root); child != 0; child = OF_peer(child)) {
dinfo = malloc(sizeof(*dinfo), M_OFWCPU, M_WAITOK | M_ZERO); dinfo = malloc(sizeof(*dinfo), M_OFWCPU, M_WAITOK | M_ZERO);
if (ofw_bus_gen_setup_devinfo(dinfo, child) != 0) { if (ofw_bus_gen_setup_devinfo(dinfo, child) != 0) {
free(dinfo, M_OFWCPU); free(dinfo, M_OFWCPU);
continue; continue;
} }
cdev = device_add_child(dev, NULL, -1); cdev = device_add_child(dev, NULL, -1);
Show All 19 Lines
static int ofw_cpu_probe(device_t); static int ofw_cpu_probe(device_t);
static int ofw_cpu_attach(device_t); static int ofw_cpu_attach(device_t);
static int ofw_cpu_read_ivar(device_t dev, device_t child, int index, static int ofw_cpu_read_ivar(device_t dev, device_t child, int index,
uintptr_t *result); uintptr_t *result);
struct ofw_cpu_softc { struct ofw_cpu_softc {
struct pcpu *sc_cpu_pcpu; struct pcpu *sc_cpu_pcpu;
uint32_t sc_nominal_mhz; uint32_t sc_nominal_mhz;
boolean_t sc_reg_valid;
pcell_t sc_reg[2];
}; };
static device_method_t ofw_cpu_methods[] = { static device_method_t ofw_cpu_methods[] = {
/* Device interface */ /* Device interface */
DEVMETHOD(device_probe, ofw_cpu_probe), DEVMETHOD(device_probe, ofw_cpu_probe),
DEVMETHOD(device_attach, ofw_cpu_attach), DEVMETHOD(device_attach, ofw_cpu_attach),
/* Bus interface */ /* Bus interface */
Show All 28 Linesofw_cpu_probe(device_t dev)
device_set_desc(dev, "Open Firmware CPU"); device_set_desc(dev, "Open Firmware CPU");
return (0); return (0);
} }
static int static int
ofw_cpu_attach(device_t dev) ofw_cpu_attach(device_t dev)
{ {
struct ofw_cpulist_softc *psc;
struct ofw_cpu_softc *sc; struct ofw_cpu_softc *sc;
phandle_t node; phandle_t node;
uint32_t cell; pcell_t cell;
int rv;
sc = device_get_softc(dev); sc = device_get_softc(dev);
node = ofw_bus_get_node(dev); psc = device_get_softc(device_get_parent(dev));
if (OF_getencprop(node, "reg", &cell, sizeof(cell)) < 0) {
cell = device_get_unit(dev); if (nitems(sc->sc_reg) < psc->sc_addr_cells) {
device_printf(dev, "missing 'reg' property, using %u\n", cell); if (bootverbose)
device_printf(dev, "Too many address cells\n");
return (EINVAL);
} }
sc->sc_cpu_pcpu = pcpu_find(cell);
node = ofw_bus_get_node(dev);
/* Read and validate the reg property for use later */
sc->sc_reg_valid = false;
rv = OF_getencprop(node, "reg", sc->sc_reg, sizeof(sc->sc_reg));
if (rv < 0)
device_printf(dev, "missing 'reg' property\n");
else if ((rv % 4) != 0) {
if (bootverbose)
device_printf(dev, "Malformed reg property\n");
} else if ((rv / 4) != psc->sc_addr_cells) {
if (bootverbose)
device_printf(dev, "Invalid reg size %u\n", rv);
} else
sc->sc_reg_valid = true;
sc->sc_cpu_pcpu = pcpu_find(device_get_unit(dev));
if (OF_getencprop(node, "clock-frequency", &cell, sizeof(cell)) < 0) { if (OF_getencprop(node, "clock-frequency", &cell, sizeof(cell)) < 0) {
if (bootverbose) if (bootverbose)
device_printf(dev, device_printf(dev,
"missing 'clock-frequency' property\n"); "missing 'clock-frequency' property\n");
} else } else
sc->sc_nominal_mhz = cell / 1000000; /* convert to MHz */ sc->sc_nominal_mhz = cell / 1000000; /* convert to MHz */
bus_generic_probe(dev); bus_generic_probe(dev);
Show All 25 Lines
View Options

sys/i386/linux/linux_dummy.c

Show First 20 Lines • Show All 45 Lines • ▼ Show 20 Lines
static int ofw_cpulist_probe(device_t); static int ofw_cpulist_probe(device_t);
static int ofw_cpulist_attach(device_t); static int ofw_cpulist_attach(device_t);
static const struct ofw_bus_devinfo *ofw_cpulist_get_devinfo(device_t dev, static const struct ofw_bus_devinfo *ofw_cpulist_get_devinfo(device_t dev,
device_t child); device_t child);
static MALLOC_DEFINE(M_OFWCPU, "ofwcpu", "OFW CPU device information"); static MALLOC_DEFINE(M_OFWCPU, "ofwcpu", "OFW CPU device information");
struct ofw_cpulist_softc {
pcell_t sc_addr_cells;
};
static device_method_t ofw_cpulist_methods[] = { static device_method_t ofw_cpulist_methods[] = {
/* Device interface */ /* Device interface */
DEVMETHOD(device_probe, ofw_cpulist_probe), DEVMETHOD(device_probe, ofw_cpulist_probe),
DEVMETHOD(device_attach, ofw_cpulist_attach), DEVMETHOD(device_attach, ofw_cpulist_attach),
/* Bus interface */ /* Bus interface */
DEVMETHOD(bus_add_child, bus_generic_add_child), DEVMETHOD(bus_add_child, bus_generic_add_child),
DEVMETHOD(bus_child_pnpinfo_str, ofw_bus_gen_child_pnpinfo_str), DEVMETHOD(bus_child_pnpinfo_str, ofw_bus_gen_child_pnpinfo_str),
/* ofw_bus interface */ /* ofw_bus interface */
DEVMETHOD(ofw_bus_get_devinfo, ofw_cpulist_get_devinfo), DEVMETHOD(ofw_bus_get_devinfo, ofw_cpulist_get_devinfo),
DEVMETHOD(ofw_bus_get_compat, ofw_bus_gen_get_compat), DEVMETHOD(ofw_bus_get_compat, ofw_bus_gen_get_compat),
DEVMETHOD(ofw_bus_get_model, ofw_bus_gen_get_model), DEVMETHOD(ofw_bus_get_model, ofw_bus_gen_get_model),
DEVMETHOD(ofw_bus_get_name, ofw_bus_gen_get_name), DEVMETHOD(ofw_bus_get_name, ofw_bus_gen_get_name),
DEVMETHOD(ofw_bus_get_node, ofw_bus_gen_get_node), DEVMETHOD(ofw_bus_get_node, ofw_bus_gen_get_node),
DEVMETHOD(ofw_bus_get_type, ofw_bus_gen_get_type), DEVMETHOD(ofw_bus_get_type, ofw_bus_gen_get_type),
DEVMETHOD_END DEVMETHOD_END
}; };
static driver_t ofw_cpulist_driver = { static driver_t ofw_cpulist_driver = {
"cpulist", "cpulist",
ofw_cpulist_methods, ofw_cpulist_methods,
0 sizeof(struct ofw_cpulist_softc)
}; };
static devclass_t ofw_cpulist_devclass; static devclass_t ofw_cpulist_devclass;
DRIVER_MODULE(ofw_cpulist, ofwbus, ofw_cpulist_driver, ofw_cpulist_devclass, DRIVER_MODULE(ofw_cpulist, ofwbus, ofw_cpulist_driver, ofw_cpulist_devclass,
0, 0); 0, 0);
static int static int
Show All 9 Linesofw_cpulist_probe(device_t dev)
device_set_desc(dev, "Open Firmware CPU Group"); device_set_desc(dev, "Open Firmware CPU Group");
return (0); return (0);
} }
static int static int
ofw_cpulist_attach(device_t dev) ofw_cpulist_attach(device_t dev)
{ {
struct ofw_cpulist_softc *sc;
phandle_t root, child; phandle_t root, child;
device_t cdev; device_t cdev;
struct ofw_bus_devinfo *dinfo; struct ofw_bus_devinfo *dinfo;
sc = device_get_softc(dev);
root = ofw_bus_get_node(dev); root = ofw_bus_get_node(dev);
sc->sc_addr_cells = 1;
OF_getencprop(root, "#address-cells", &sc->sc_addr_cells,
sizeof(sc->sc_addr_cells));
for (child = OF_child(root); child != 0; child = OF_peer(child)) { for (child = OF_child(root); child != 0; child = OF_peer(child)) {
dinfo = malloc(sizeof(*dinfo), M_OFWCPU, M_WAITOK | M_ZERO); dinfo = malloc(sizeof(*dinfo), M_OFWCPU, M_WAITOK | M_ZERO);
if (ofw_bus_gen_setup_devinfo(dinfo, child) != 0) { if (ofw_bus_gen_setup_devinfo(dinfo, child) != 0) {
free(dinfo, M_OFWCPU); free(dinfo, M_OFWCPU);
continue; continue;
} }
cdev = device_add_child(dev, NULL, -1); cdev = device_add_child(dev, NULL, -1);
Show All 19 Lines
static int ofw_cpu_probe(device_t); static int ofw_cpu_probe(device_t);
static int ofw_cpu_attach(device_t); static int ofw_cpu_attach(device_t);
static int ofw_cpu_read_ivar(device_t dev, device_t child, int index, static int ofw_cpu_read_ivar(device_t dev, device_t child, int index,
uintptr_t *result); uintptr_t *result);
struct ofw_cpu_softc { struct ofw_cpu_softc {
struct pcpu *sc_cpu_pcpu; struct pcpu *sc_cpu_pcpu;
uint32_t sc_nominal_mhz; uint32_t sc_nominal_mhz;
boolean_t sc_reg_valid;
pcell_t sc_reg[2];
}; };
static device_method_t ofw_cpu_methods[] = { static device_method_t ofw_cpu_methods[] = {
/* Device interface */ /* Device interface */
DEVMETHOD(device_probe, ofw_cpu_probe), DEVMETHOD(device_probe, ofw_cpu_probe),
DEVMETHOD(device_attach, ofw_cpu_attach), DEVMETHOD(device_attach, ofw_cpu_attach),
/* Bus interface */ /* Bus interface */
Show All 28 Linesofw_cpu_probe(device_t dev)
device_set_desc(dev, "Open Firmware CPU"); device_set_desc(dev, "Open Firmware CPU");
return (0); return (0);
} }
static int static int
ofw_cpu_attach(device_t dev) ofw_cpu_attach(device_t dev)
{ {
struct ofw_cpulist_softc *psc;
struct ofw_cpu_softc *sc; struct ofw_cpu_softc *sc;
phandle_t node; phandle_t node;
uint32_t cell; pcell_t cell;
int rv;
sc = device_get_softc(dev); sc = device_get_softc(dev);
node = ofw_bus_get_node(dev); psc = device_get_softc(device_get_parent(dev));
if (OF_getencprop(node, "reg", &cell, sizeof(cell)) < 0) {
cell = device_get_unit(dev); if (nitems(sc->sc_reg) < psc->sc_addr_cells) {
device_printf(dev, "missing 'reg' property, using %u\n", cell); if (bootverbose)
device_printf(dev, "Too many address cells\n");
return (EINVAL);
} }
sc->sc_cpu_pcpu = pcpu_find(cell);
node = ofw_bus_get_node(dev);
/* Read and validate the reg property for use later */
sc->sc_reg_valid = false;
rv = OF_getencprop(node, "reg", sc->sc_reg, sizeof(sc->sc_reg));
if (rv < 0)
device_printf(dev, "missing 'reg' property\n");
else if ((rv % 4) != 0) {
if (bootverbose)
device_printf(dev, "Malformed reg property\n");
} else if ((rv / 4) != psc->sc_addr_cells) {
if (bootverbose)
device_printf(dev, "Invalid reg size %u\n", rv);
} else
sc->sc_reg_valid = true;
sc->sc_cpu_pcpu = pcpu_find(device_get_unit(dev));
if (OF_getencprop(node, "clock-frequency", &cell, sizeof(cell)) < 0) { if (OF_getencprop(node, "clock-frequency", &cell, sizeof(cell)) < 0) {
if (bootverbose) if (bootverbose)
device_printf(dev, device_printf(dev,
"missing 'clock-frequency' property\n"); "missing 'clock-frequency' property\n");
} else } else
sc->sc_nominal_mhz = cell / 1000000; /* convert to MHz */ sc->sc_nominal_mhz = cell / 1000000; /* convert to MHz */
bus_generic_probe(dev); bus_generic_probe(dev);
Show All 25 Lines
View Options

sys/i386/linux/syscalls.master

Show First 20 Lines • Show All 45 Lines • ▼ Show 20 Lines
static int ofw_cpulist_probe(device_t); static int ofw_cpulist_probe(device_t);
static int ofw_cpulist_attach(device_t); static int ofw_cpulist_attach(device_t);
static const struct ofw_bus_devinfo *ofw_cpulist_get_devinfo(device_t dev, static const struct ofw_bus_devinfo *ofw_cpulist_get_devinfo(device_t dev,
device_t child); device_t child);
static MALLOC_DEFINE(M_OFWCPU, "ofwcpu", "OFW CPU device information"); static MALLOC_DEFINE(M_OFWCPU, "ofwcpu", "OFW CPU device information");
struct ofw_cpulist_softc {
pcell_t sc_addr_cells;
};
static device_method_t ofw_cpulist_methods[] = { static device_method_t ofw_cpulist_methods[] = {
/* Device interface */ /* Device interface */
DEVMETHOD(device_probe, ofw_cpulist_probe), DEVMETHOD(device_probe, ofw_cpulist_probe),
DEVMETHOD(device_attach, ofw_cpulist_attach), DEVMETHOD(device_attach, ofw_cpulist_attach),
/* Bus interface */ /* Bus interface */
DEVMETHOD(bus_add_child, bus_generic_add_child), DEVMETHOD(bus_add_child, bus_generic_add_child),
DEVMETHOD(bus_child_pnpinfo_str, ofw_bus_gen_child_pnpinfo_str), DEVMETHOD(bus_child_pnpinfo_str, ofw_bus_gen_child_pnpinfo_str),
/* ofw_bus interface */ /* ofw_bus interface */
DEVMETHOD(ofw_bus_get_devinfo, ofw_cpulist_get_devinfo), DEVMETHOD(ofw_bus_get_devinfo, ofw_cpulist_get_devinfo),
DEVMETHOD(ofw_bus_get_compat, ofw_bus_gen_get_compat), DEVMETHOD(ofw_bus_get_compat, ofw_bus_gen_get_compat),
DEVMETHOD(ofw_bus_get_model, ofw_bus_gen_get_model), DEVMETHOD(ofw_bus_get_model, ofw_bus_gen_get_model),
DEVMETHOD(ofw_bus_get_name, ofw_bus_gen_get_name), DEVMETHOD(ofw_bus_get_name, ofw_bus_gen_get_name),
DEVMETHOD(ofw_bus_get_node, ofw_bus_gen_get_node), DEVMETHOD(ofw_bus_get_node, ofw_bus_gen_get_node),
DEVMETHOD(ofw_bus_get_type, ofw_bus_gen_get_type), DEVMETHOD(ofw_bus_get_type, ofw_bus_gen_get_type),
DEVMETHOD_END DEVMETHOD_END
}; };
static driver_t ofw_cpulist_driver = { static driver_t ofw_cpulist_driver = {
"cpulist", "cpulist",
ofw_cpulist_methods, ofw_cpulist_methods,
0 sizeof(struct ofw_cpulist_softc)
}; };
static devclass_t ofw_cpulist_devclass; static devclass_t ofw_cpulist_devclass;
DRIVER_MODULE(ofw_cpulist, ofwbus, ofw_cpulist_driver, ofw_cpulist_devclass, DRIVER_MODULE(ofw_cpulist, ofwbus, ofw_cpulist_driver, ofw_cpulist_devclass,
0, 0); 0, 0);
static int static int
Show All 9 Linesofw_cpulist_probe(device_t dev)
device_set_desc(dev, "Open Firmware CPU Group"); device_set_desc(dev, "Open Firmware CPU Group");
return (0); return (0);
} }
static int static int
ofw_cpulist_attach(device_t dev) ofw_cpulist_attach(device_t dev)
{ {
struct ofw_cpulist_softc *sc;
phandle_t root, child; phandle_t root, child;
device_t cdev; device_t cdev;
struct ofw_bus_devinfo *dinfo; struct ofw_bus_devinfo *dinfo;
sc = device_get_softc(dev);
root = ofw_bus_get_node(dev); root = ofw_bus_get_node(dev);
sc->sc_addr_cells = 1;
OF_getencprop(root, "#address-cells", &sc->sc_addr_cells,
sizeof(sc->sc_addr_cells));
for (child = OF_child(root); child != 0; child = OF_peer(child)) { for (child = OF_child(root); child != 0; child = OF_peer(child)) {
dinfo = malloc(sizeof(*dinfo), M_OFWCPU, M_WAITOK | M_ZERO); dinfo = malloc(sizeof(*dinfo), M_OFWCPU, M_WAITOK | M_ZERO);
if (ofw_bus_gen_setup_devinfo(dinfo, child) != 0) { if (ofw_bus_gen_setup_devinfo(dinfo, child) != 0) {
free(dinfo, M_OFWCPU); free(dinfo, M_OFWCPU);
continue; continue;
} }
cdev = device_add_child(dev, NULL, -1); cdev = device_add_child(dev, NULL, -1);
Show All 19 Lines
static int ofw_cpu_probe(device_t); static int ofw_cpu_probe(device_t);
static int ofw_cpu_attach(device_t); static int ofw_cpu_attach(device_t);
static int ofw_cpu_read_ivar(device_t dev, device_t child, int index, static int ofw_cpu_read_ivar(device_t dev, device_t child, int index,
uintptr_t *result); uintptr_t *result);
struct ofw_cpu_softc { struct ofw_cpu_softc {
struct pcpu *sc_cpu_pcpu; struct pcpu *sc_cpu_pcpu;
uint32_t sc_nominal_mhz; uint32_t sc_nominal_mhz;
boolean_t sc_reg_valid;
pcell_t sc_reg[2];
}; };
static device_method_t ofw_cpu_methods[] = { static device_method_t ofw_cpu_methods[] = {
/* Device interface */ /* Device interface */
DEVMETHOD(device_probe, ofw_cpu_probe), DEVMETHOD(device_probe, ofw_cpu_probe),
DEVMETHOD(device_attach, ofw_cpu_attach), DEVMETHOD(device_attach, ofw_cpu_attach),
/* Bus interface */ /* Bus interface */
Show All 28 Linesofw_cpu_probe(device_t dev)
device_set_desc(dev, "Open Firmware CPU"); device_set_desc(dev, "Open Firmware CPU");
return (0); return (0);
} }
static int static int
ofw_cpu_attach(device_t dev) ofw_cpu_attach(device_t dev)
{ {
struct ofw_cpulist_softc *psc;
struct ofw_cpu_softc *sc; struct ofw_cpu_softc *sc;
phandle_t node; phandle_t node;
uint32_t cell; pcell_t cell;
int rv;
sc = device_get_softc(dev); sc = device_get_softc(dev);
node = ofw_bus_get_node(dev); psc = device_get_softc(device_get_parent(dev));
if (OF_getencprop(node, "reg", &cell, sizeof(cell)) < 0) {
cell = device_get_unit(dev); if (nitems(sc->sc_reg) < psc->sc_addr_cells) {
device_printf(dev, "missing 'reg' property, using %u\n", cell); if (bootverbose)
device_printf(dev, "Too many address cells\n");
return (EINVAL);
} }
sc->sc_cpu_pcpu = pcpu_find(cell);
node = ofw_bus_get_node(dev);
/* Read and validate the reg property for use later */
sc->sc_reg_valid = false;
rv = OF_getencprop(node, "reg", sc->sc_reg, sizeof(sc->sc_reg));
if (rv < 0)
device_printf(dev, "missing 'reg' property\n");
else if ((rv % 4) != 0) {
if (bootverbose)
device_printf(dev, "Malformed reg property\n");
} else if ((rv / 4) != psc->sc_addr_cells) {
if (bootverbose)
device_printf(dev, "Invalid reg size %u\n", rv);
} else
sc->sc_reg_valid = true;
sc->sc_cpu_pcpu = pcpu_find(device_get_unit(dev));
if (OF_getencprop(node, "clock-frequency", &cell, sizeof(cell)) < 0) { if (OF_getencprop(node, "clock-frequency", &cell, sizeof(cell)) < 0) {
if (bootverbose) if (bootverbose)
device_printf(dev, device_printf(dev,
"missing 'clock-frequency' property\n"); "missing 'clock-frequency' property\n");
} else } else
sc->sc_nominal_mhz = cell / 1000000; /* convert to MHz */ sc->sc_nominal_mhz = cell / 1000000; /* convert to MHz */
bus_generic_probe(dev); bus_generic_probe(dev);
Show All 25 Lines