* functioning of this software in any circumstances.
*
* $FreeBSD: src/sys/cam/cam_extend.c,v 1.3 1999/08/28 00:40:39 peter Exp $
- * $DragonFly: src/sys/bus/cam/cam_extend.c,v 1.5 2005/05/28 01:16:30 swildner Exp $
+ * $DragonFly: src/sys/bus/cam/cam_extend.c,v 1.6 2006/09/05 00:55:31 dillon Exp $
*/
/*
* XXX XXX XXX XXX We should get DEVFS working so that we
struct extend_array *
cam_extend_new(void)
{
- return(malloc(sizeof(struct extend_array), M_DEVBUF,
+ return(kmalloc(sizeof(struct extend_array), M_DEVBUF,
M_INTWAIT | M_ZERO));
}
{
if (index >= ea->nelem) {
void **space;
- space = malloc(sizeof(void *) * (index + EXTEND_CHUNK),
+ space = kmalloc(sizeof(void *) * (index + EXTEND_CHUNK),
M_DEVBUF, M_INTWAIT | M_ZERO);
/* Make sure we have something to copy before we copy it */
if (ea->nelem) {
bcopy(ea->ps, space, sizeof(void *) * ea->nelem);
- free(ea->ps, M_DEVBUF);
+ kfree(ea->ps, M_DEVBUF);
}
ea->ps = space;
* SUCH DAMAGE.
*
* $FreeBSD: src/sys/cam/cam_periph.c,v 1.24.2.3 2003/01/25 19:04:40 dillon Exp $
- * $DragonFly: src/sys/bus/cam/cam_periph.c,v 1.15 2006/04/30 20:23:19 dillon Exp $
+ * $DragonFly: src/sys/bus/cam/cam_periph.c,v 1.16 2006/09/05 00:55:31 dillon Exp $
*/
#include <sys/param.h>
return (CAM_REQ_INVALID);
}
- periph = malloc(sizeof(*periph), M_DEVBUF, M_INTWAIT | M_ZERO);
+ periph = kmalloc(sizeof(*periph), M_DEVBUF, M_INTWAIT | M_ZERO);
init_level++;
case 2:
xpt_free_path(periph->path);
case 1:
- free(periph, M_DEVBUF);
+ kfree(periph, M_DEVBUF);
case 0:
/* No cleanup to perform. */
break;
periph->path, arg);
}
xpt_free_path(periph->path);
- free(periph, M_DEVBUF);
+ kfree(periph, M_DEVBUF);
}
/*
* SUCH DAMAGE.
*
* $FreeBSD: src/sys/cam/cam_queue.c,v 1.5 1999/08/28 00:40:41 peter Exp $
- * $DragonFly: src/sys/bus/cam/cam_queue.c,v 1.6 2004/03/15 05:43:52 dillon Exp $
+ * $DragonFly: src/sys/bus/cam/cam_queue.c,v 1.7 2006/09/05 00:55:31 dillon Exp $
*/
#include <sys/param.h>
#include <sys/systm.h>
{
struct camq *camq;
- camq = malloc(sizeof(*camq), M_DEVBUF, M_INTWAIT);
+ camq = kmalloc(sizeof(*camq), M_DEVBUF, M_INTWAIT);
camq_init(camq, size);
return (camq);
}
bzero(camq, sizeof(*camq));
camq->array_size = size;
if (camq->array_size != 0) {
- camq->queue_array = malloc(size * sizeof(cam_pinfo *),
+ camq->queue_array = kmalloc(size * sizeof(cam_pinfo *),
M_DEVBUF, M_INTWAIT);
/*
* Heap algorithms like everything numbered from 1, so
{
if (queue != NULL) {
camq_fini(queue);
- free(queue, M_DEVBUF);
+ kfree(queue, M_DEVBUF);
}
}
* our pointer into the heap array is offset by one element.
*/
queue->queue_array++;
- free(queue->queue_array, M_DEVBUF);
+ kfree(queue->queue_array, M_DEVBUF);
}
}
panic("camq_resize: New queue size can't accomodate "
"queued entries.");
#endif
- new_array = malloc(new_size * sizeof(cam_pinfo *), M_DEVBUF, M_INTWAIT);
+ new_array = kmalloc(new_size * sizeof(cam_pinfo *), M_DEVBUF, M_INTWAIT);
/*
* Heap algorithms like everything numbered from 1, so
queue->queue_array++;
bcopy(queue->queue_array, new_array,
queue->entries * sizeof(cam_pinfo *));
- free(queue->queue_array, M_DEVBUF);
+ kfree(queue->queue_array, M_DEVBUF);
}
queue->queue_array = new_array-1;
queue->array_size = new_size;
{
struct cam_devq *devq;
- devq = malloc(sizeof(*devq), M_DEVBUF, M_INTWAIT);
+ devq = kmalloc(sizeof(*devq), M_DEVBUF, M_INTWAIT);
cam_devq_init(devq, devices, openings);
return (devq);
}
printf("cam_devq_release: WARNING active allocations %d active send %d!\n", devq->alloc_active, devq->send_active);
camq_fini(&devq->alloc_queue);
camq_fini(&devq->send_queue);
- free(devq, M_DEVBUF);
+ kfree(devq, M_DEVBUF);
}
}
{
struct cam_ccbq *ccbq;
- ccbq = malloc(sizeof(*ccbq), M_DEVBUF, M_INTWAIT);
+ ccbq = kmalloc(sizeof(*ccbq), M_DEVBUF, M_INTWAIT);
cam_ccbq_init(ccbq, openings);
return (ccbq);
}
{
if (ccbq) {
camq_fini(&ccbq->queue);
- free(ccbq, M_DEVBUF);
+ kfree(ccbq, M_DEVBUF);
}
}
* SUCH DAMAGE.
*
* $FreeBSD: src/sys/cam/cam_sim.c,v 1.3 1999/08/28 00:40:42 peter Exp $
- * $DragonFly: src/sys/bus/cam/cam_sim.c,v 1.7 2004/09/17 02:20:53 joerg Exp $
+ * $DragonFly: src/sys/bus/cam/cam_sim.c,v 1.8 2006/09/05 00:55:31 dillon Exp $
*/
#include <sys/param.h>
else
cam_devq_reference(queue);
- sim = malloc(sizeof(struct cam_sim), M_DEVBUF, M_INTWAIT | M_ZERO);
+ sim = kmalloc(sizeof(struct cam_sim), M_DEVBUF, M_INTWAIT | M_ZERO);
sim->sim_action = sim_action;
sim->sim_poll = sim_poll;
sim->sim_name = sim_name;
}
if (sim->refcount == 1) {
sim->refcount = 0;
- free(sim, M_DEVBUF);
+ kfree(sim, M_DEVBUF);
} else {
--sim->refcount;
}
* SUCH DAMAGE.
*
* $FreeBSD: src/sys/cam/cam_xpt.c,v 1.80.2.18 2002/12/09 17:31:55 gibbs Exp $
- * $DragonFly: src/sys/bus/cam/cam_xpt.c,v 1.29 2006/07/28 02:17:31 dillon Exp $
+ * $DragonFly: src/sys/bus/cam/cam_xpt.c,v 1.30 2006/09/05 00:55:31 dillon Exp $
*/
#include <sys/param.h>
#include <sys/systm.h>
/*
* Register a callback for when interrupts are enabled.
*/
- xpt_config_hook = malloc(sizeof(struct intr_config_hook),
+ xpt_config_hook = kmalloc(sizeof(struct intr_config_hook),
M_TEMP, M_INTWAIT | M_ZERO);
xpt_config_hook->ich_func = xpt_config;
xpt_config_hook->ich_desc = "xpt";
if (config_intrhook_establish(xpt_config_hook) != 0) {
- free (xpt_config_hook, M_TEMP);
+ kfree (xpt_config_hook, M_TEMP);
printf("xpt_init: config_intrhook_establish failed "
"- failing attach\n");
}
SLIST_REMOVE(async_head, cur_entry,
async_node, links);
csa->ccb_h.path->device->refcount--;
- free(cur_entry, M_DEVBUF);
+ kfree(cur_entry, M_DEVBUF);
} else {
cur_entry->event_enable = csa->event_enable;
}
} else {
- cur_entry = malloc(sizeof(*cur_entry),
+ cur_entry = kmalloc(sizeof(*cur_entry),
M_DEVBUF, M_INTWAIT);
cur_entry->event_enable = csa->event_enable;
cur_entry->callback_arg = csa->callback_arg;
struct cam_path *path;
cam_status status;
- path = malloc(sizeof(*path), M_DEVBUF, M_INTWAIT);
+ path = kmalloc(sizeof(*path), M_DEVBUF, M_INTWAIT);
status = xpt_compile_path(path, perph, path_id, target_id, lun_id);
if (status != CAM_REQ_CMP) {
- free(path, M_DEVBUF);
+ kfree(path, M_DEVBUF);
path = NULL;
}
*new_path_ptr = path;
{
CAM_DEBUG(path, CAM_DEBUG_TRACE, ("xpt_free_path\n"));
xpt_release_path(path);
- free(path, M_DEVBUF);
+ kfree(path, M_DEVBUF);
}
struct ccb_pathinq cpi;
sim->bus_id = bus;
- new_bus = malloc(sizeof(*new_bus), M_DEVBUF, M_INTWAIT);
+ new_bus = kmalloc(sizeof(*new_bus), M_DEVBUF, M_INTWAIT);
if (strcmp(sim->sim_name, "xpt") != 0) {
sim->path_id =
{
union ccb *new_ccb;
- new_ccb = malloc(sizeof(*new_ccb), M_DEVBUF, M_INTWAIT);
+ new_ccb = kmalloc(sizeof(*new_ccb), M_DEVBUF, M_INTWAIT);
return (new_ccb);
}
void
xpt_free_ccb(union ccb *free_ccb)
{
- free(free_ccb, M_DEVBUF);
+ kfree(free_ccb, M_DEVBUF);
}
crit_enter();
if ((new_ccb = (union ccb *)ccb_freeq.slh_first) == NULL) {
- new_ccb = malloc(sizeof(*new_ccb), M_DEVBUF, M_INTWAIT);
+ new_ccb = kmalloc(sizeof(*new_ccb), M_DEVBUF, M_INTWAIT);
SLIST_INSERT_HEAD(&ccb_freeq, &new_ccb->ccb_h,
xpt_links.sle);
xpt_ccb_count++;
}
bus_generation++;
KKASSERT(bus->refcount == 1);
- free(bus, M_DEVBUF);
+ kfree(bus, M_DEVBUF);
} else {
--bus->refcount;
}
struct cam_et *target;
struct cam_et *cur_target;
- target = malloc(sizeof(*target), M_DEVBUF, M_INTWAIT);
+ target = kmalloc(sizeof(*target), M_DEVBUF, M_INTWAIT);
TAILQ_INIT(&target->ed_entries);
target->bus = bus;
bus->generation++;
xpt_release_bus(bus);
KKASSERT(target->refcount == 1);
- free(target, M_DEVBUF);
+ kfree(target, M_DEVBUF);
} else {
--target->refcount;
}
if (status != CAM_REQ_CMP) {
device = NULL;
} else {
- device = malloc(sizeof(*device), M_DEVBUF, M_INTWAIT);
+ device = kmalloc(sizeof(*device), M_DEVBUF, M_INTWAIT);
}
if (device != NULL) {
device->lun_id = lun_id;
/* Initialize our queues */
if (camq_init(&device->drvq, 0) != 0) {
- free(device, M_DEVBUF);
+ kfree(device, M_DEVBUF);
return (NULL);
}
if (cam_ccbq_init(&device->ccbq,
bus->sim->max_dev_openings) != 0) {
camq_fini(&device->drvq);
- free(device, M_DEVBUF);
+ kfree(device, M_DEVBUF);
return (NULL);
}
SLIST_INIT(&device->asyncs);
cam_devq_resize(devq, devq->alloc_queue.array_size - 1);
xpt_release_target(bus, target);
KKASSERT(device->refcount == 1);
- free(device, M_DEVBUF);
+ kfree(device, M_DEVBUF);
} else {
--device->refcount;
}
/* Save some state for use while we probe for devices */
scan_info = (xpt_scan_bus_info *)
- malloc(sizeof(xpt_scan_bus_info), M_TEMP, M_INTWAIT);
+ kmalloc(sizeof(xpt_scan_bus_info), M_TEMP, M_INTWAIT);
scan_info->request_ccb = request_ccb;
scan_info->cpi = &work_ccb->cpi;
if (scan_info->pending_count == 0) {
xpt_free_ccb((union ccb *)scan_info->cpi);
request_ccb = scan_info->request_ccb;
- free(scan_info, M_TEMP);
+ kfree(scan_info, M_TEMP);
request_ccb->ccb_h.status = CAM_REQ_CMP;
xpt_done(request_ccb);
}
xpt_free_ccb(
(union ccb *)scan_info->cpi);
request_ccb = scan_info->request_ccb;
- free(scan_info, M_TEMP);
+ kfree(scan_info, M_TEMP);
request_ccb->ccb_h.status = CAM_REQ_CMP;
xpt_done(request_ccb);
break;
}
if (request_ccb == NULL) {
- request_ccb = malloc(sizeof(union ccb), M_TEMP, M_INTWAIT);
- new_path = malloc(sizeof(*new_path), M_TEMP, M_INTWAIT);
+ request_ccb = kmalloc(sizeof(union ccb), M_TEMP, M_INTWAIT);
+ new_path = kmalloc(sizeof(*new_path), M_TEMP, M_INTWAIT);
status = xpt_compile_path(new_path, xpt_periph,
path->bus->path_id,
path->target->target_id,
xpt_print_path(path);
printf("xpt_scan_lun: can't compile path, can't "
"continue\n");
- free(request_ccb, M_TEMP);
- free(new_path, M_TEMP);
+ kfree(request_ccb, M_TEMP);
+ kfree(new_path, M_TEMP);
return;
}
xpt_setup_ccb(&request_ccb->ccb_h, new_path, /*priority*/ 1);
xptscandone(struct cam_periph *periph, union ccb *done_ccb)
{
xpt_release_path(done_ccb->ccb_h.path);
- free(done_ccb->ccb_h.path, M_TEMP);
- free(done_ccb, M_TEMP);
+ kfree(done_ccb->ccb_h.path, M_TEMP);
+ kfree(done_ccb, M_TEMP);
}
static cam_status
return(CAM_REQ_CMP_ERR);
}
- softc = malloc(sizeof(*softc), M_TEMP, M_INTWAIT | M_ZERO);
+ softc = kmalloc(sizeof(*softc), M_TEMP, M_INTWAIT | M_ZERO);
TAILQ_INIT(&softc->request_ccbs);
TAILQ_INSERT_TAIL(&softc->request_ccbs, &request_ccb->ccb_h,
periph_links.tqe);
mode_buf_len = sizeof(struct scsi_mode_header_6)
+ sizeof(struct scsi_mode_blk_desc)
+ sizeof(struct scsi_control_page);
- mode_buf = malloc(mode_buf_len, M_TEMP, M_INTWAIT);
+ mode_buf = kmalloc(mode_buf_len, M_TEMP, M_INTWAIT);
scsi_mode_sense(csio,
/*retries*/4,
probedone,
device->serial_num_len = 0;
if ((device->quirk->quirks & CAM_QUIRK_NOSERIAL) == 0) {
- serial_buf = malloc(sizeof(*serial_buf), M_TEMP,
+ serial_buf = kmalloc(sizeof(*serial_buf), M_TEMP,
M_INTWAIT | M_ZERO);
scsi_inquiry(csio,
/*retries*/4,
/*count*/1, /*run_queue*/TRUE);
}
xpt_release_ccb(done_ccb);
- free(mode_hdr, M_TEMP);
+ kfree(mode_hdr, M_TEMP);
softc->action = PROBE_SERIAL_NUM;
xpt_schedule(periph, priority);
return;
/* Clean up from previous instance of this device */
if (path->device->serial_num != NULL) {
- free(path->device->serial_num, M_DEVBUF);
+ kfree(path->device->serial_num, M_DEVBUF);
path->device->serial_num = NULL;
path->device->serial_num_len = 0;
}
have_serialnum = 1;
path->device->serial_num =
- malloc((serial_buf->length + 1),
+ kmalloc((serial_buf->length + 1),
M_DEVBUF, M_INTWAIT);
bcopy(serial_buf->serial_num,
path->device->serial_num,
xpt_async(AC_LOST_DEVICE, path, NULL);
}
if (serial_buf != NULL)
- free(serial_buf, M_TEMP);
+ kfree(serial_buf, M_TEMP);
if (changed != 0) {
/*
static void
probecleanup(struct cam_periph *periph)
{
- free(periph->softc, M_TEMP);
+ kfree(periph->softc, M_TEMP);
}
static void
/* Release our hook so that the boot can continue. */
config_intrhook_disestablish(xpt_config_hook);
- free(xpt_config_hook, M_TEMP);
+ kfree(xpt_config_hook, M_TEMP);
xpt_config_hook = NULL;
}
if (done_ccb != NULL)
* SUCH DAMAGE.
*
* $FreeBSD: src/sys/cam/scsi/scsi_cd.c,v 1.31.2.16 2003/10/21 22:26:11 thomas Exp $
- * $DragonFly: src/sys/bus/cam/scsi/scsi_cd.c,v 1.23 2006/07/28 02:17:32 dillon Exp $
+ * $DragonFly: src/sys/bus/cam/scsi/scsi_cd.c,v 1.24 2006/09/05 00:55:32 dillon Exp $
*/
/*
* Portions of this driver taken from the original FreeBSD cd driver.
changer_links);
xpt_print_path(periph->path);
printf("removing changer entry\n");
- free(softc->changer, M_DEVBUF);
+ kfree(softc->changer, M_DEVBUF);
num_changers--;
}
devstat_remove_entry(&softc->device_stats);
if (softc->disk.d_rawdev) {
disk_destroy(&softc->disk);
}
- free(softc, M_DEVBUF);
+ kfree(softc, M_DEVBUF);
crit_exit();
}
return(CAM_REQ_CMP_ERR);
}
- softc = malloc(sizeof(*softc), M_DEVBUF, M_INTWAIT | M_ZERO);
+ softc = kmalloc(sizeof(*softc), M_DEVBUF, M_INTWAIT | M_ZERO);
LIST_INIT(&softc->pending_ccbs);
STAILQ_INIT(&softc->mode_queue);
softc->state = CD_STATE_PROBE;
* been marked as part of the changer.)
*/
else {
- nchanger = malloc(sizeof(struct cdchanger),
+ nchanger = kmalloc(sizeof(struct cdchanger),
M_DEVBUF, M_INTWAIT | M_ZERO);
callout_init(&nchanger->short_handle);
callout_init(&nchanger->long_handle);
case CD_STATE_PROBE:
{
- rcap = malloc(sizeof(*rcap), M_TEMP, M_INTWAIT);
+ rcap = kmalloc(sizeof(*rcap), M_TEMP, M_INTWAIT);
csio = &start_ccb->csio;
scsi_read_capacity(csio,
/*retries*/1,
}
}
}
- free(rdcap, M_TEMP);
+ kfree(rdcap, M_TEMP);
if (announce_buf[0] != '\0') {
xpt_announce_periph(periph, announce_buf);
if (softc->flags & CD_FLAG_CHANGER)
union cd_pages *page;
params.alloc_len = sizeof(union cd_mode_data_6_10);
- params.mode_buf = malloc(params.alloc_len, M_TEMP,
+ params.mode_buf = kmalloc(params.alloc_len, M_TEMP,
M_WAITOK | M_ZERO);
CAM_DEBUG(periph->path, CAM_DEBUG_SUBTRACE,
error = cdgetmode(periph, ¶ms, AUDIO_PAGE);
if (error) {
- free(params.mode_buf, M_TEMP);
+ kfree(params.mode_buf, M_TEMP);
break;
}
page = cdgetpage(¶ms);
page->audio.flags &= ~CD_PA_SOTC;
page->audio.flags |= CD_PA_IMMED;
error = cdsetmode(periph, ¶ms);
- free(params.mode_buf, M_TEMP);
+ kfree(params.mode_buf, M_TEMP);
if (error)
break;
union cd_pages *page;
params.alloc_len = sizeof(union cd_mode_data_6_10);
- params.mode_buf = malloc(params.alloc_len, M_TEMP,
+ params.mode_buf = kmalloc(params.alloc_len, M_TEMP,
M_WAITOK | M_ZERO);
CAM_DEBUG(periph->path, CAM_DEBUG_SUBTRACE,
error = cdgetmode(periph, ¶ms, AUDIO_PAGE);
if (error) {
- free(params.mode_buf, M_TEMP);
+ kfree(params.mode_buf, M_TEMP);
break;
}
page = cdgetpage(¶ms);
page->audio.flags &= ~CD_PA_SOTC;
page->audio.flags |= CD_PA_IMMED;
error = cdsetmode(periph, ¶ms);
- free(params.mode_buf, M_TEMP);
+ kfree(params.mode_buf, M_TEMP);
if (error)
break;
error = cdplaymsf(periph,
("trying to do CDIOCPLAYBLOCKS\n"));
params.alloc_len = sizeof(union cd_mode_data_6_10);
- params.mode_buf = malloc(params.alloc_len, M_TEMP,
+ params.mode_buf = kmalloc(params.alloc_len, M_TEMP,
M_WAITOK | M_ZERO);
error = cdgetmode(periph, ¶ms, AUDIO_PAGE);
if (error) {
- free(params.mode_buf, M_TEMP);
+ kfree(params.mode_buf, M_TEMP);
break;
}
page = cdgetpage(¶ms);
page->audio.flags &= ~CD_PA_SOTC;
page->audio.flags |= CD_PA_IMMED;
error = cdsetmode(periph, ¶ms);
- free(params.mode_buf, M_TEMP);
+ kfree(params.mode_buf, M_TEMP);
if (error)
break;
error = cdplay(periph, args->blk, args->len);
CAM_DEBUG(periph->path, CAM_DEBUG_SUBTRACE,
("trying to do CDIOCREADSUBCHANNEL\n"));
- data = malloc(sizeof(struct cd_sub_channel_info),
+ data = kmalloc(sizeof(struct cd_sub_channel_info),
M_TEMP, M_WAITOK);
if ((len > sizeof(struct cd_sub_channel_info)) ||
"cdioreadsubchannel: error, len=%d\n",
len);
error = EINVAL;
- free(data, M_TEMP);
+ kfree(data, M_TEMP);
break;
}
args->data_format, args->track, data, len);
if (error) {
- free(data, M_TEMP);
+ kfree(data, M_TEMP);
break;
}
if (softc->quirks & CD_Q_BCD_TRACKS)
if (copyout(data, args->data, len) != 0) {
error = EFAULT;
}
- free(data, M_TEMP);
+ kfree(data, M_TEMP);
}
break;
CAM_DEBUG(periph->path, CAM_DEBUG_SUBTRACE,
("trying to do CDIOREADTOCHEADER\n"));
- th = malloc(sizeof(struct ioc_toc_header), M_TEMP,
+ th = kmalloc(sizeof(struct ioc_toc_header), M_TEMP,
M_WAITOK);
error = cdreadtoc(periph, 0, 0, (u_int8_t *)th,
sizeof (*th), /*sense_flags*/0);
if (error) {
- free(th, M_TEMP);
+ kfree(th, M_TEMP);
break;
}
if (softc->quirks & CD_Q_BCD_TRACKS) {
}
th->len = ntohs(th->len);
bcopy(th, addr, sizeof(*th));
- free(th, M_TEMP);
+ kfree(th, M_TEMP);
}
break;
case CDIOREADTOCENTRYS:
CAM_DEBUG(periph->path, CAM_DEBUG_SUBTRACE,
("trying to do CDIOREADTOCENTRYS\n"));
- data = malloc(sizeof(*data), M_TEMP, M_WAITOK);
- lead = malloc(sizeof(*lead), M_TEMP, M_WAITOK);
+ data = kmalloc(sizeof(*data), M_TEMP, M_WAITOK);
+ lead = kmalloc(sizeof(*lead), M_TEMP, M_WAITOK);
if (te->data_len < sizeof(struct cd_toc_entry)
|| (te->data_len % sizeof(struct cd_toc_entry)) != 0
error = EINVAL;
printf("scsi_cd: error in readtocentries, "
"returning EINVAL\n");
- free(data, M_TEMP);
- free(lead, M_TEMP);
+ kfree(data, M_TEMP);
+ kfree(lead, M_TEMP);
break;
}
error = cdreadtoc(periph, 0, 0, (u_int8_t *)th,
sizeof (*th), /*sense_flags*/0);
if (error) {
- free(data, M_TEMP);
- free(lead, M_TEMP);
+ kfree(data, M_TEMP);
+ kfree(lead, M_TEMP);
break;
}
starting_track > th->ending_track + 1) {
printf("scsi_cd: error in readtocentries, "
"returning EINVAL\n");
- free(data, M_TEMP);
- free(lead, M_TEMP);
+ kfree(data, M_TEMP);
+ kfree(lead, M_TEMP);
error = EINVAL;
break;
}
printf("scsi_cd: error in readtocentries, "
"returning EINVAL\n");
error = EINVAL;
- free(data, M_TEMP);
- free(lead, M_TEMP);
+ kfree(data, M_TEMP);
+ kfree(lead, M_TEMP);
break;
}
num = len / sizeof(struct cd_toc_entry);
readlen + sizeof (*th),
/*sense_flags*/0);
if (error) {
- free(data, M_TEMP);
- free(lead, M_TEMP);
+ kfree(data, M_TEMP);
+ kfree(lead, M_TEMP);
break;
}
}
sizeof(*lead),
/*sense_flags*/0);
if (error) {
- free(data, M_TEMP);
- free(lead, M_TEMP);
+ kfree(data, M_TEMP);
+ kfree(lead, M_TEMP);
break;
}
data->entries[idx - starting_track] =
}
error = copyout(data->entries, te->data, len);
- free(data, M_TEMP);
- free(lead, M_TEMP);
+ kfree(data, M_TEMP);
+ kfree(lead, M_TEMP);
}
break;
case CDIOREADTOCENTRY:
CAM_DEBUG(periph->path, CAM_DEBUG_SUBTRACE,
("trying to do CDIOREADTOCENTRY\n"));
- data = malloc(sizeof(*data), M_TEMP, M_WAITOK);
+ data = kmalloc(sizeof(*data), M_TEMP, M_WAITOK);
if (te->address_format != CD_MSF_FORMAT
&& te->address_format != CD_LBA_FORMAT) {
printf("error in readtocentry, "
" returning EINVAL\n");
- free(data, M_TEMP);
+ kfree(data, M_TEMP);
error = EINVAL;
break;
}
error = cdreadtoc(periph, 0, 0, (u_int8_t *)th,
sizeof (*th), /*sense_flags*/0);
if (error) {
- free(data, M_TEMP);
+ kfree(data, M_TEMP);
break;
}
track > th->ending_track + 1) {
printf("error in readtocentry, "
" returning EINVAL\n");
- free(data, M_TEMP);
+ kfree(data, M_TEMP);
error = EINVAL;
break;
}
(u_int8_t *)data, sizeof(*data),
/*sense_flags*/0);
if (error) {
- free(data, M_TEMP);
+ kfree(data, M_TEMP);
break;
}
data->entry.track = bcd2bin(data->entry.track);
bcopy(&data->entry, &te->entry,
sizeof(struct cd_toc_entry));
- free(data, M_TEMP);
+ kfree(data, M_TEMP);
}
break;
case CDIOCSETPATCH:
("trying to do CDIOCSETPATCH\n"));
params.alloc_len = sizeof(union cd_mode_data_6_10);
- params.mode_buf = malloc(params.alloc_len, M_TEMP,
+ params.mode_buf = kmalloc(params.alloc_len, M_TEMP,
M_WAITOK | M_ZERO);
error = cdgetmode(periph, ¶ms, AUDIO_PAGE);
if (error) {
- free(params.mode_buf, M_TEMP);
+ kfree(params.mode_buf, M_TEMP);
break;
}
page = cdgetpage(¶ms);
page->audio.port[2].channels = arg->patch[2];
page->audio.port[3].channels = arg->patch[3];
error = cdsetmode(periph, ¶ms);
- free(params.mode_buf, M_TEMP);
+ kfree(params.mode_buf, M_TEMP);
}
break;
case CDIOCGETVOL:
("trying to do CDIOCGETVOL\n"));
params.alloc_len = sizeof(union cd_mode_data_6_10);
- params.mode_buf = malloc(params.alloc_len, M_TEMP,
+ params.mode_buf = kmalloc(params.alloc_len, M_TEMP,
M_WAITOK | M_ZERO);
error = cdgetmode(periph, ¶ms, AUDIO_PAGE);
if (error) {
- free(params.mode_buf, M_TEMP);
+ kfree(params.mode_buf, M_TEMP);
break;
}
page = cdgetpage(¶ms);
page->audio.port[RIGHT_PORT].volume;
arg->vol[2] = page->audio.port[2].volume;
arg->vol[3] = page->audio.port[3].volume;
- free(params.mode_buf, M_TEMP);
+ kfree(params.mode_buf, M_TEMP);
}
break;
case CDIOCSETVOL:
("trying to do CDIOCSETVOL\n"));
params.alloc_len = sizeof(union cd_mode_data_6_10);
- params.mode_buf = malloc(params.alloc_len, M_TEMP,
+ params.mode_buf = kmalloc(params.alloc_len, M_TEMP,
M_WAITOK | M_ZERO);
error = cdgetmode(periph, ¶ms, AUDIO_PAGE);
if (error) {
- free(params.mode_buf, M_TEMP);
+ kfree(params.mode_buf, M_TEMP);
break;
}
page = cdgetpage(¶ms);
page->audio.port[2].volume = arg->vol[2];
page->audio.port[3].volume = arg->vol[3];
error = cdsetmode(periph, ¶ms);
- free(params.mode_buf, M_TEMP);
+ kfree(params.mode_buf, M_TEMP);
}
break;
case CDIOCSETMONO:
("trying to do CDIOCSETMONO\n"));
params.alloc_len = sizeof(union cd_mode_data_6_10);
- params.mode_buf = malloc(params.alloc_len, M_TEMP,
+ params.mode_buf = kmalloc(params.alloc_len, M_TEMP,
M_WAITOK | M_ZERO);
error = cdgetmode(periph, ¶ms, AUDIO_PAGE);
if (error) {
- free(params.mode_buf, M_TEMP);
+ kfree(params.mode_buf, M_TEMP);
break;
}
page = cdgetpage(¶ms);
page->audio.port[2].channels = 0;
page->audio.port[3].channels = 0;
error = cdsetmode(periph, ¶ms);
- free(params.mode_buf, M_TEMP);
+ kfree(params.mode_buf, M_TEMP);
}
break;
case CDIOCSETSTEREO:
("trying to do CDIOCSETSTEREO\n"));
params.alloc_len = sizeof(union cd_mode_data_6_10);
- params.mode_buf = malloc(params.alloc_len, M_TEMP,
+ params.mode_buf = kmalloc(params.alloc_len, M_TEMP,
M_WAITOK | M_ZERO);
error = cdgetmode(periph, ¶ms, AUDIO_PAGE);
if (error) {
- free(params.mode_buf, M_TEMP);
+ kfree(params.mode_buf, M_TEMP);
break;
}
page = cdgetpage(¶ms);
page->audio.port[2].channels = 0;
page->audio.port[3].channels = 0;
error = cdsetmode(periph, ¶ms);
- free(params.mode_buf, M_TEMP);
+ kfree(params.mode_buf, M_TEMP);
}
break;
case CDIOCSETMUTE:
("trying to do CDIOCSETMUTE\n"));
params.alloc_len = sizeof(union cd_mode_data_6_10);
- params.mode_buf = malloc(params.alloc_len, M_TEMP,
+ params.mode_buf = kmalloc(params.alloc_len, M_TEMP,
M_WAITOK | M_ZERO);
error = cdgetmode(periph, ¶ms, AUDIO_PAGE);
if (error) {
- free(¶ms, M_TEMP);
+ kfree(¶ms, M_TEMP);
break;
}
page = cdgetpage(¶ms);
page->audio.port[2].channels = 0;
page->audio.port[3].channels = 0;
error = cdsetmode(periph, ¶ms);
- free(params.mode_buf, M_TEMP);
+ kfree(params.mode_buf, M_TEMP);
}
break;
case CDIOCSETLEFT:
("trying to do CDIOCSETLEFT\n"));
params.alloc_len = sizeof(union cd_mode_data_6_10);
- params.mode_buf = malloc(params.alloc_len, M_TEMP,
+ params.mode_buf = kmalloc(params.alloc_len, M_TEMP,
M_WAITOK | M_ZERO);
error = cdgetmode(periph, ¶ms, AUDIO_PAGE);
if (error) {
- free(params.mode_buf, M_TEMP);
+ kfree(params.mode_buf, M_TEMP);
break;
}
page = cdgetpage(¶ms);
page->audio.port[2].channels = 0;
page->audio.port[3].channels = 0;
error = cdsetmode(periph, ¶ms);
- free(params.mode_buf, M_TEMP);
+ kfree(params.mode_buf, M_TEMP);
}
break;
case CDIOCSETRIGHT:
("trying to do CDIOCSETRIGHT\n"));
params.alloc_len = sizeof(union cd_mode_data_6_10);
- params.mode_buf = malloc(params.alloc_len, M_TEMP,
+ params.mode_buf = kmalloc(params.alloc_len, M_TEMP,
M_WAITOK | M_ZERO);
error = cdgetmode(periph, ¶ms, AUDIO_PAGE);
if (error) {
- free(params.mode_buf, M_TEMP);
+ kfree(params.mode_buf, M_TEMP);
break;
}
page = cdgetpage(¶ms);
page->audio.port[2].channels = 0;
page->audio.port[3].channels = 0;
error = cdsetmode(periph, ¶ms);
- free(params.mode_buf, M_TEMP);
+ kfree(params.mode_buf, M_TEMP);
}
break;
case CDIOCRESUME:
ccb = cdgetccb(periph, /* priority */ 1);
- rcap_buf = malloc(sizeof(struct scsi_read_capacity_data),
+ rcap_buf = kmalloc(sizeof(struct scsi_read_capacity_data),
M_TEMP, M_INTWAIT | M_ZERO);
scsi_read_capacity(&ccb->csio,
if (softc->params.blksize > 2048 && softc->params.blksize <= 2352)
softc->params.blksize = 2048;
- free(rcap_buf, M_TEMP);
+ kfree(rcap_buf, M_TEMP);
*size = softc->params.disksize;
return (error);
}
if (length != 0) {
- databuf = malloc(length, M_DEVBUF, M_INTWAIT | M_ZERO);
+ databuf = kmalloc(length, M_DEVBUF, M_INTWAIT | M_ZERO);
} else {
databuf = NULL;
}
}
bailout:
if (databuf != NULL)
- free(databuf, M_DEVBUF);
+ kfree(databuf, M_DEVBUF);
xpt_release_ccb(ccb);
length = sizeof(*challenge_data);
- challenge_data = malloc(length, M_DEVBUF, M_INTWAIT | M_ZERO);
+ challenge_data = kmalloc(length, M_DEVBUF, M_INTWAIT | M_ZERO);
databuf = (u_int8_t *)challenge_data;
length = sizeof(*key2_data);
- key2_data = malloc(length, M_DEVBUF, M_INTWAIT | M_ZERO);
+ key2_data = kmalloc(length, M_DEVBUF, M_INTWAIT | M_ZERO);
databuf = (u_int8_t *)key2_data;
length = sizeof(*rpc_data);
- rpc_data = malloc(length, M_DEVBUF, M_INTWAIT | M_ZERO);
+ rpc_data = kmalloc(length, M_DEVBUF, M_INTWAIT | M_ZERO);
databuf = (u_int8_t *)rpc_data;
bailout:
if (databuf != NULL)
- free(databuf, M_DEVBUF);
+ kfree(databuf, M_DEVBUF);
xpt_release_ccb(ccb);
}
if (length != 0) {
- databuf = malloc(length, M_DEVBUF, M_INTWAIT | M_ZERO);
+ databuf = kmalloc(length, M_DEVBUF, M_INTWAIT | M_ZERO);
} else {
databuf = NULL;
}
bailout:
if (databuf != NULL)
- free(databuf, M_DEVBUF);
+ kfree(databuf, M_DEVBUF);
xpt_release_ccb(ccb);
* SUCH DAMAGE.
*
* $FreeBSD: src/sys/cam/scsi/scsi_ch.c,v 1.20.2.2 2000/10/31 08:09:49 dwmalone Exp $
- * $DragonFly: src/sys/bus/cam/scsi/scsi_ch.c,v 1.14 2006/07/28 02:17:32 dillon Exp $
+ * $DragonFly: src/sys/bus/cam/scsi/scsi_ch.c,v 1.15 2006/09/05 00:55:32 dillon Exp $
*/
/*
* Derived from the NetBSD SCSI changer driver.
xpt_print_path(periph->path);
printf("removing device entry\n");
dev_ops_remove(&ch_ops, -1, periph->unit_number);
- free(softc, M_DEVBUF);
+ kfree(softc, M_DEVBUF);
}
static void
return(CAM_REQ_CMP_ERR);
}
- softc = malloc(sizeof(*softc), M_DEVBUF, M_INTWAIT | M_ZERO);
+ softc = kmalloc(sizeof(*softc), M_DEVBUF, M_INTWAIT | M_ZERO);
softc->state = CH_STATE_PROBE;
periph->softc = softc;
cam_extend_set(chperiphs, periph->unit_number, periph);
sizeof(struct scsi_mode_blk_desc) +
sizeof(struct page_element_address_assignment);
- mode_buffer = malloc(mode_buffer_len, M_TEMP, M_INTWAIT | M_ZERO);
+ mode_buffer = kmalloc(mode_buffer_len, M_TEMP, M_INTWAIT | M_ZERO);
/*
* Get the element address assignment page.
*/
if (announce_buf[0] != '\0')
xpt_announce_periph(periph, announce_buf);
softc->state = CH_STATE_NORMAL;
- free(mode_header, M_TEMP);
+ kfree(mode_header, M_TEMP);
/*
* Since our peripheral may be invalidated by an error
* above or an external event, we must release our CCB
* we can allocate enough storage for all of them. We assume
* that the first one can fit into 1k.
*/
- data = (caddr_t)malloc(1024, M_DEVBUF, M_INTWAIT);
+ data = (caddr_t)kmalloc(1024, M_DEVBUF, M_INTWAIT);
ccb = cam_periph_getccb(periph, /*priority*/ 1);
* Reallocate storage for descriptors and get them from the
* device.
*/
- free(data, M_DEVBUF);
- data = (caddr_t)malloc(size, M_DEVBUF, M_INTWAIT);
+ kfree(data, M_DEVBUF);
+ data = (caddr_t)kmalloc(size, M_DEVBUF, M_INTWAIT);
scsi_read_element_status(&ccb->csio,
/* retries */ 1,
xpt_release_ccb(ccb);
if (data != NULL)
- free(data, M_DEVBUF);
+ kfree(data, M_DEVBUF);
if (user_data != NULL)
- free(user_data, M_DEVBUF);
+ kfree(user_data, M_DEVBUF);
return (error);
}
*/
mode_buffer_len = sizeof(struct scsi_mode_sense_data);
- mode_buffer = malloc(mode_buffer_len, M_TEMP, M_INTWAIT | M_ZERO);
+ mode_buffer = kmalloc(mode_buffer_len, M_TEMP, M_INTWAIT | M_ZERO);
if (softc->quirks & CH_Q_NO_DBD)
dbd = FALSE;
printf("chgetparams: error getting element "
"address page\n");
xpt_release_ccb(ccb);
- free(mode_buffer, M_TEMP);
+ kfree(mode_buffer, M_TEMP);
return(error);
}
}
printf("chgetparams: error getting device "
"capabilities page\n");
xpt_release_ccb(ccb);
- free(mode_buffer, M_TEMP);
+ kfree(mode_buffer, M_TEMP);
return(error);
}
}
softc->sc_exchangemask[from] = exchanges[from];
}
- free(mode_buffer, M_TEMP);
+ kfree(mode_buffer, M_TEMP);
return(error);
}
* SUCH DAMAGE.
*
* $FreeBSD: src/sys/cam/scsi/scsi_da.c,v 1.42.2.46 2003/10/21 22:18:19 thomas Exp $
- * $DragonFly: src/sys/bus/cam/scsi/scsi_da.c,v 1.30 2006/07/28 02:17:32 dillon Exp $
+ * $DragonFly: src/sys/bus/cam/scsi/scsi_da.c,v 1.31 2006/09/05 00:55:32 dillon Exp $
*/
#ifdef _KERNEL
struct scsi_read_capacity_data *rcap;
union ccb *ccb;
- rcap = malloc(sizeof(*rcap), M_TEMP, M_INTWAIT | M_ZERO);
+ rcap = kmalloc(sizeof(*rcap), M_TEMP, M_INTWAIT | M_ZERO);
ccb = cam_periph_getccb(periph, /*priority*/1);
scsi_read_capacity(&ccb->csio,
dasetgeom(periph, rcap);
}
- free(rcap, M_TEMP);
+ kfree(rcap, M_TEMP);
}
if (error == 0) {
if (softc->disk.d_rawdev) {
disk_destroy(&softc->disk);
}
- free(softc, M_DEVBUF);
+ kfree(softc, M_DEVBUF);
}
static void
return(CAM_REQ_CMP_ERR);
}
- softc = malloc(sizeof(*softc), M_DEVBUF, M_INTWAIT | M_ZERO);
+ softc = kmalloc(sizeof(*softc), M_DEVBUF, M_INTWAIT | M_ZERO);
LIST_INIT(&softc->pending_ccbs);
softc->state = DA_STATE_PROBE;
bioq_init(&softc->bio_queue);
struct ccb_scsiio *csio;
struct scsi_read_capacity_data *rcap;
- rcap = malloc(sizeof(*rcap), M_TEMP, M_INTWAIT | M_ZERO);
+ rcap = kmalloc(sizeof(*rcap), M_TEMP, M_INTWAIT | M_ZERO);
csio = &start_ccb->csio;
scsi_read_capacity(csio,
/*retries*/4,
}
}
}
- free(rdcap, M_TEMP);
+ kfree(rdcap, M_TEMP);
if (announce_buf[0] != '\0') {
xpt_announce_periph(periph, announce_buf);
/*
/*
* $FreeBSD: src/sys/cam/scsi/scsi_low.c,v 1.1.2.5 2003/08/09 06:18:30 non Exp $
- * $DragonFly: src/sys/bus/cam/scsi/scsi_low.c,v 1.15 2006/01/22 14:03:51 swildner Exp $
+ * $DragonFly: src/sys/bus/cam/scsi/scsi_low.c,v 1.16 2006/09/05 00:55:32 dillon Exp $
* $NetBSD: scsi_low.c,v 1.24.10.8 2001/06/26 07:39:44 honda Exp $
*/
/**************************************************************
* SCSI INTERFACE (CAM)
**************************************************************/
-#define SCSI_LOW_MALLOC(size) malloc((size), M_DEVBUF, M_INTWAIT)
-#define SCSI_LOW_FREE(pt) free((pt), M_DEVBUF)
+#define SCSI_LOW_MALLOC(size) kmalloc((size), M_DEVBUF, M_INTWAIT)
+#define SCSI_LOW_FREE(pt) kfree((pt), M_DEVBUF)
#define SCSI_LOW_ALLOC_CCB(flags) scsi_low_get_ccb()
static void scsi_low_poll_cam (struct cam_sim *);
scsi_low_cam_rescan_callback(struct cam_periph *periph, union ccb *ccb)
{
xpt_free_path(ccb->ccb_h.path);
- free(ccb, M_DEVBUF);
+ kfree(ccb, M_DEVBUF);
}
static void
scsi_low_rescan_bus_cam(struct scsi_low_softc *slp)
{
struct cam_path *path;
- union ccb *ccb = malloc(sizeof(union ccb), M_DEVBUF, M_INTWAIT | M_ZERO);
+ union ccb *ccb = kmalloc(sizeof(union ccb), M_DEVBUF, M_INTWAIT | M_ZERO);
cam_status status;
status = xpt_create_path(&path, xpt_periph,
* SUCH DAMAGE.
*
* $FreeBSD: src/sys/cam/scsi/scsi_pass.c,v 1.19 2000/01/17 06:27:37 mjacob Exp $
- * $DragonFly: src/sys/bus/cam/scsi/scsi_pass.c,v 1.16 2006/07/28 02:17:32 dillon Exp $
+ * $DragonFly: src/sys/bus/cam/scsi/scsi_pass.c,v 1.17 2006/09/05 00:55:32 dillon Exp $
*/
#include <sys/param.h>
printf("removing device entry\n");
}
dev_ops_remove(&pass_ops, -1, periph->unit_number);
- free(softc, M_DEVBUF);
+ kfree(softc, M_DEVBUF);
}
static void
return(CAM_REQ_CMP_ERR);
}
- softc = malloc(sizeof(*softc), M_DEVBUF, M_INTWAIT | M_ZERO);
+ softc = kmalloc(sizeof(*softc), M_DEVBUF, M_INTWAIT | M_ZERO);
softc->state = PASS_STATE_NORMAL;
softc->pd_type = SID_TYPE(&cgd->inq_data);
bioq_init(&softc->bio_queue);
* SUCH DAMAGE.
*
* $FreeBSD: src/sys/cam/scsi/scsi_pt.c,v 1.17 2000/01/17 06:27:37 mjacob Exp $
- * $DragonFly: src/sys/bus/cam/scsi/scsi_pt.c,v 1.15 2006/07/28 02:17:32 dillon Exp $
+ * $DragonFly: src/sys/bus/cam/scsi/scsi_pt.c,v 1.16 2006/09/05 00:55:32 dillon Exp $
*/
#include <sys/param.h>
return(CAM_REQ_CMP_ERR);
}
- softc = malloc(sizeof(*softc), M_DEVBUF, M_INTWAIT | M_ZERO);
+ softc = kmalloc(sizeof(*softc), M_DEVBUF, M_INTWAIT | M_ZERO);
LIST_INIT(&softc->pending_ccbs);
softc->state = PT_STATE_NORMAL;
bioq_init(&softc->bio_queue);
xpt_print_path(periph->path);
printf("removing device entry\n");
dev_ops_remove(&pt_ops, -1, periph->unit_number);
- free(softc, M_DEVBUF);
+ kfree(softc, M_DEVBUF);
}
static void
/*
* $FreeBSD: src/sys/cam/scsi/scsi_sa.c,v 1.45.2.13 2002/12/17 17:08:50 trhodes Exp $
- * $DragonFly: src/sys/bus/cam/scsi/scsi_sa.c,v 1.18 2006/07/28 02:17:32 dillon Exp $
+ * $DragonFly: src/sys/bus/cam/scsi/scsi_sa.c,v 1.19 2006/09/05 00:55:32 dillon Exp $
*
* Implementation of SCSI Sequential Access Peripheral driver for CAM.
*
xpt_print_path(periph->path);
printf("removing device entry\n");
dev_ops_remove(&sa_ops, SA_UNITMASK, SA_UNIT(periph->unit_number));
- free(softc, M_DEVBUF);
+ kfree(softc, M_DEVBUF);
}
static void
return (CAM_REQ_CMP_ERR);
}
- softc = malloc(sizeof (*softc), M_DEVBUF, M_INTWAIT | M_ZERO);
+ softc = kmalloc(sizeof (*softc), M_DEVBUF, M_INTWAIT | M_ZERO);
softc->scsi_rev = SID_ANSI_REV(&cgd->inq_data);
softc->state = SA_STATE_NORMAL;
softc->fileno = (daddr_t) -1;
* blocksize on tape is and don't expect to really
* read a full record.
*/
- rblim = malloc(8192, M_TEMP, M_INTWAIT);
+ rblim = kmalloc(8192, M_TEMP, M_INTWAIT);
if ((softc->quirks & SA_QUIRK_NODREAD) == 0) {
scsi_sa_read_write(&ccb->csio, 0, sadone,
}
exit:
if (rblim != NULL)
- free(rblim, M_TEMP);
+ kfree(rblim, M_TEMP);
if (error != 0) {
softc->dsreg = MTIO_DSREG_NIL;
mode_buffer_len += sizeof (sa_comp_t);
}
- mode_buffer = malloc(mode_buffer_len, M_TEMP, M_INTWAIT | M_ZERO);
+ mode_buffer = kmalloc(mode_buffer_len, M_TEMP, M_INTWAIT | M_ZERO);
mode_hdr = (struct scsi_mode_header_6 *)mode_buffer;
mode_blk = (struct scsi_mode_blk_desc *)&mode_hdr[1];
goto retry;
}
softc->quirks |= SA_QUIRK_NOCOMP;
- free(mode_buffer, M_TEMP);
+ kfree(mode_buffer, M_TEMP);
goto retry;
} else if (status == CAM_SCSI_STATUS_ERROR) {
/* Tell the user about the fatal error. */
sagetparamsexit:
xpt_release_ccb(ccb);
- free(mode_buffer, M_TEMP);
+ kfree(mode_buffer, M_TEMP);
return (error);
}
softc = (struct sa_softc *)periph->softc;
- ccomp = malloc(sizeof (sa_comp_t), M_TEMP, M_INTWAIT);
+ ccomp = kmalloc(sizeof (sa_comp_t), M_TEMP, M_INTWAIT);
/*
* Since it doesn't make sense to set the number of blocks, or
¤t_calg, ccomp);
if (error != 0) {
- free(ccomp, M_TEMP);
+ kfree(ccomp, M_TEMP);
return (error);
}
if (params_to_set & SA_PARAM_COMPRESSION)
mode_buffer_len += sizeof (sa_comp_t);
- mode_buffer = malloc(mode_buffer_len, M_TEMP, M_INTWAIT | M_ZERO);
+ mode_buffer = kmalloc(mode_buffer_len, M_TEMP, M_INTWAIT | M_ZERO);
mode_hdr = (struct scsi_mode_header_6 *)mode_buffer;
mode_blk = (struct scsi_mode_blk_desc *)&mode_hdr[1];
* 'operation not supported'.
*/
if (params_to_set == SA_PARAM_NONE) {
- free(mode_buffer, M_TEMP);
+ kfree(mode_buffer, M_TEMP);
xpt_release_ccb(ccb);
return (ENODEV);
}
xpt_release_ccb(ccb);
if (ccomp != NULL)
- free(ccomp, M_TEMP);
+ kfree(ccomp, M_TEMP);
if (params_to_set & SA_PARAM_COMPRESSION) {
if (error) {
}
}
- free(mode_buffer, M_TEMP);
+ kfree(mode_buffer, M_TEMP);
return (error);
}
/* $FreeBSD: src/sys/cam/scsi/scsi_ses.c,v 1.8.2.2 2000/08/08 23:19:21 mjacob Exp $ */
-/* $DragonFly: src/sys/bus/cam/scsi/scsi_ses.c,v 1.16 2006/08/03 16:40:46 swildner Exp $ */
+/* $DragonFly: src/sys/bus/cam/scsi/scsi_ses.c,v 1.17 2006/09/05 00:55:32 dillon Exp $ */
/*
* Copyright (c) 2000 Matthew Jacob
* All rights reserved.
#define SES_DLOG if (0) ses_log
#endif
#define SES_VLOG if (bootverbose) ses_log
-#define SES_MALLOC(amt) malloc(amt, M_DEVBUF, M_INTWAIT)
-#define SES_FREE(ptr, amt) free(ptr, M_DEVBUF)
+#define SES_MALLOC(amt) kmalloc(amt, M_DEVBUF, M_INTWAIT)
+#define SES_FREE(ptr, amt) kfree(ptr, M_DEVBUF)
#define MEMZERO bzero
#define MEMCPY(dest, src, amt) bcopy(src, dest, amt)
xpt_print_path(periph->path);
printf("removing device entry\n");
dev_ops_remove(&ses_ops, -1, periph->unit_number);
- free(softc, M_DEVBUF);
+ kfree(softc, M_DEVBUF);
}
static void
return (CAM_REQ_CMP_ERR);
}
- softc = malloc(sizeof (struct ses_softc), M_DEVBUF, M_INTWAIT | M_ZERO);
+ softc = kmalloc(sizeof (struct ses_softc), M_DEVBUF, M_INTWAIT | M_ZERO);
periph->softc = softc;
softc->periph = periph;
break;
case SES_NONE:
default:
- free(softc, M_DEVBUF);
+ kfree(softc, M_DEVBUF);
return (CAM_REQ_CMP_ERR);
}
* SUCH DAMAGE.
*
* $FreeBSD: src/sys/cam/scsi/scsi_targ_bh.c,v 1.4.2.6 2003/11/14 11:31:25 simokawa Exp $
- * $DragonFly: src/sys/bus/cam/scsi/scsi_targ_bh.c,v 1.11 2006/08/03 16:40:46 swildner Exp $
+ * $DragonFly: src/sys/bus/cam/scsi/scsi_targ_bh.c,v 1.12 2006/09/05 00:55:33 dillon Exp $
*/
#include <sys/param.h>
#include <sys/queue.h>
for (i = 0; i < MAX_ACCEPT; i++) {
struct ccb_accept_tio *atio;
- atio = malloc(sizeof(*atio), M_DEVBUF, M_INTWAIT);
+ atio = kmalloc(sizeof(*atio), M_DEVBUF, M_INTWAIT);
atio->ccb_h.ccb_descr = targbhallocdescr();
status = atio->ccb_h.status;
if (status != CAM_REQ_INPROG) {
targbhfreedescr(atio->ccb_h.ccb_descr);
- free(atio, M_DEVBUF);
+ kfree(atio, M_DEVBUF);
break;
}
((struct targbh_cmd_desc*)atio->ccb_h.ccb_descr)->atio_link =
for (i = 0; i < MAX_ACCEPT; i++) {
struct ccb_immed_notify *inot;
- inot = malloc(sizeof(*inot), M_DEVBUF, M_INTWAIT);
+ inot = kmalloc(sizeof(*inot), M_DEVBUF, M_INTWAIT);
xpt_setup_ccb(&inot->ccb_h, periph->path, /*priority*/1);
inot->ccb_h.func_code = XPT_IMMED_NOTIFY;
xpt_action((union ccb *)inot);
status = inot->ccb_h.status;
if (status != CAM_REQ_INPROG) {
- free(inot, M_DEVBUF);
+ kfree(inot, M_DEVBUF);
break;
}
SLIST_INSERT_HEAD(&softc->immed_notify_slist, &inot->ccb_h,
cpi = (struct ccb_pathinq *)arg;
/* Allocate our per-instance private storage */
- softc = malloc(sizeof(*softc), M_DEVBUF, M_INTWAIT | M_ZERO);
+ softc = kmalloc(sizeof(*softc), M_DEVBUF, M_INTWAIT | M_ZERO);
TAILQ_INIT(&softc->pending_queue);
TAILQ_INIT(&softc->work_queue);
softc->accept_tio_list = NULL;
default:
/* XXX Wait for callback of targbhdislun() */
tsleep(softc, 0, "targbh", hz/2);
- free(softc, M_DEVBUF);
+ kfree(softc, M_DEVBUF);
break;
}
}
if (softc->state == TARGBH_STATE_TEARDOWN
|| atio->ccb_h.status == CAM_REQ_ABORTED) {
targbhfreedescr(descr);
- free(done_ccb, M_DEVBUF);
+ kfree(done_ccb, M_DEVBUF);
return;
}
break;
} else {
targbhfreedescr(desc);
- free(atio, M_DEVBUF);
+ kfree(atio, M_DEVBUF);
}
break;
}
if (softc->state == TARGBH_STATE_TEARDOWN
|| done_ccb->ccb_h.status == CAM_REQ_ABORTED) {
printf("Freed an immediate notify\n");
- free(done_ccb, M_DEVBUF);
+ kfree(done_ccb, M_DEVBUF);
}
break;
}
struct targbh_cmd_desc* descr;
/* Allocate the targbh_descr structure */
- descr = malloc(sizeof(*descr), M_DEVBUF, M_INTWAIT | M_ZERO);
+ descr = kmalloc(sizeof(*descr), M_DEVBUF, M_INTWAIT | M_ZERO);
/* Allocate buffer backing store */
- descr->backing_store = malloc(MAX_BUF_SIZE, M_DEVBUF, M_INTWAIT);
+ descr->backing_store = kmalloc(MAX_BUF_SIZE, M_DEVBUF, M_INTWAIT);
descr->max_size = MAX_BUF_SIZE;
return (descr);
}
static void
targbhfreedescr(struct targbh_cmd_desc *descr)
{
- free(descr->backing_store, M_DEVBUF);
- free(descr, M_DEVBUF);
+ kfree(descr->backing_store, M_DEVBUF);
+ kfree(descr, M_DEVBUF);
}
* SUCH DAMAGE.
*
* $FreeBSD: src/sys/dev/eisa/eisaconf.c,v 1.55 2000/01/14 07:13:57 peter Exp $
- * $DragonFly: src/sys/bus/eisa/eisaconf.c,v 1.6 2006/01/22 14:03:51 swildner Exp $
+ * $DragonFly: src/sys/bus/eisa/eisaconf.c,v 1.7 2006/09/05 00:55:34 dillon Exp $
*/
#include "opt_eisa.h"
devices_found++;
/* Prepare an eisa_device_node for this slot */
- e_dev = malloc(sizeof(*e_dev), M_DEVBUF, M_INTWAIT | M_ZERO);
+ e_dev = kmalloc(sizeof(*e_dev), M_DEVBUF, M_INTWAIT | M_ZERO);
e_dev->id = eisa_id;
e_dev->ioconf.slot = slot;
struct eisa_device *e_dev = device_get_ivars(dev);
struct irq_node *irq_info;
- irq_info = malloc(sizeof(*irq_info), M_DEVBUF, M_INTWAIT);
+ irq_info = kmalloc(sizeof(*irq_info), M_DEVBUF, M_INTWAIT);
irq_info->irq_no = irq;
irq_info->irq_trigger = trigger;
irq_info->idesc = NULL;
{
resvaddr_t *reservation;
- reservation = malloc(sizeof(resvaddr_t), M_DEVBUF, M_INTWAIT);
+ reservation = kmalloc(sizeof(resvaddr_t), M_DEVBUF, M_INTWAIT);
reservation->addr = base;
reservation->size = size;
reservation->flags = flags;
* matches any already in here,
* fail.
*/
- free(reservation, M_DEVBUF);
+ kfree(reservation, M_DEVBUF);
return (EEXIST);
}
* POSSIBILITY OF SUCH DAMAGE.
*
* $FreeBSD: src/sys/dev/firewire/firewire.c,v 1.68 2004/01/08 14:58:09 simokawa Exp $
- * $DragonFly: src/sys/bus/firewire/firewire.c,v 1.14 2006/01/22 14:03:51 swildner Exp $
+ * $DragonFly: src/sys/bus/firewire/firewire.c,v 1.15 2006/09/05 00:55:35 dillon Exp $
*
*/
for (fwdev = STAILQ_FIRST(&sc->fc->devices); fwdev != NULL;
fwdev = fwdev_next) {
fwdev_next = STAILQ_NEXT(fwdev, link);
- free(fwdev, M_FW);
+ kfree(fwdev, M_FW);
}
for (csrd = SLIST_FIRST(&sc->fc->csrfree); csrd != NULL; csrd = next) {
next = SLIST_NEXT(csrd, link);
- free(csrd, M_FW);
+ kfree(csrd, M_FW);
}
- free(sc->fc->topology_map, M_FW);
- free(sc->fc->speed_map, M_FW);
- free(sc->fc->crom_src_buf, M_FW);
+ kfree(sc->fc->topology_map, M_FW);
+ kfree(sc->fc->speed_map, M_FW);
+ kfree(sc->fc->crom_src_buf, M_FW);
return(0);
}
#if 0
struct crom_src *src;
fc->crom_src_buf = (struct crom_src_buf *)
- malloc(sizeof(struct crom_src_buf), M_FW, M_WAITOK | M_ZERO);
+ kmalloc(sizeof(struct crom_src_buf), M_FW, M_WAITOK | M_ZERO);
if (fc->crom_src_buf == NULL)
return;
if (fdc->post_busreset != NULL)
fdc->post_busreset(fdc);
}
- free(devlistp, M_TEMP);
+ kfree(devlistp, M_TEMP);
}
- newrom = malloc(CROMSIZE, M_FW, M_WAITOK | M_ZERO);
+ newrom = kmalloc(CROMSIZE, M_FW, M_WAITOK | M_ZERO);
src = &fc->crom_src_buf->src;
crom_load(src, (u_int32_t *)newrom, CROMSIZE);
if (bcmp(newrom, fc->config_rom, CROMSIZE) != 0) {
crom_load(src, (u_int32_t *)newrom, CROMSIZE);
bcopy(newrom, (void *)fc->config_rom, CROMSIZE);
}
- free(newrom, M_FW);
+ kfree(newrom, M_FW);
}
/* Call once after reboot */
SLIST_INIT(&fc->ongocsr);
SLIST_INIT(&fc->csrfree);
for( i = 0 ; i < FWMAXCSRDIR ; i++){
- csrd = malloc(sizeof(struct csrdir), M_FW, M_WAITOK);
+ csrd = kmalloc(sizeof(struct csrdir), M_FW, M_WAITOK);
if(csrd == NULL) break;
SLIST_INSERT_HEAD(&fc->csrfree, csrd, link);
}
xfer = fw_xfer_alloc();
if(xfer == NULL) return;
- fwb = malloc(sizeof (struct fw_bind), M_FW, M_WAITOK);
+ fwb = kmalloc(sizeof (struct fw_bind), M_FW, M_WAITOK);
xfer->act.hand = fw_vmaccess;
xfer->fc = fc;
xfer->sc = NULL;
tl = STAILQ_NEXT(tl, link)){
if(tl->xfer == xfer){
STAILQ_REMOVE(&fc->tlabels[xfer->tl], tl, tlabel, link);
- free(tl, M_FW);
+ kfree(tl, M_FW);
break;
}
}
{
struct fw_xfer *xfer;
- xfer = malloc(sizeof(struct fw_xfer), type, M_INTWAIT | M_ZERO);
+ xfer = kmalloc(sizeof(struct fw_xfer), type, M_INTWAIT | M_ZERO);
xfer->malloc = type;
return xfer;
if (xfer == NULL)
return(NULL);
if (send_len > 0) {
- xfer->send.payload = malloc(send_len, type, M_INTWAIT | M_ZERO);
+ xfer->send.payload = kmalloc(send_len, type, M_INTWAIT | M_ZERO);
if (xfer->send.payload == NULL) {
fw_xfer_free(xfer);
return(NULL);
}
}
if (recv_len > 0) {
- xfer->recv.payload = malloc(recv_len, type, M_INTWAIT);
+ xfer->recv.payload = kmalloc(recv_len, type, M_INTWAIT);
if (xfer->recv.payload == NULL) {
if (xfer->send.payload != NULL)
- free(xfer->send.payload, type);
+ kfree(xfer->send.payload, type);
fw_xfer_free(xfer);
return(NULL);
}
}
fw_xfer_unload(xfer);
if(xfer->send.payload != NULL){
- free(xfer->send.payload, xfer->malloc);
+ kfree(xfer->send.payload, xfer->malloc);
}
if(xfer->recv.payload != NULL){
- free(xfer->recv.payload, xfer->malloc);
+ kfree(xfer->recv.payload, xfer->malloc);
}
- free(xfer, xfer->malloc);
+ kfree(xfer, xfer->malloc);
}
void
return;
}
fw_xfer_unload(xfer);
- free(xfer, xfer->malloc);
+ kfree(xfer, xfer->malloc);
}
void
addr = 0xf0000000 | fc->ongoaddr;
goto dorequest;
}
- fwdev = malloc(sizeof(struct fw_device), M_FW,
+ fwdev = kmalloc(sizeof(struct fw_device), M_FW,
M_WAITOK | M_ZERO);
fwdev->fc = fc;
fwdev->rommax = 0;
*/
STAILQ_REMOVE(&fc->devices, fwdev, fw_device,
link);
- free(fwdev, M_FW);
+ kfree(fwdev, M_FW);
}
}
}
fdc->post_explore(fdc);
}
}
- free(devlistp, M_TEMP);
+ kfree(devlistp, M_TEMP);
if (fc->retry_count > 0) {
printf("probe failed for %d node\n", fc->retry_count);
break;
}
if(tmptl == NULL) {
- tl = malloc(sizeof(struct tlabel), M_FW, M_WAITOK);
+ tl = kmalloc(sizeof(struct tlabel), M_FW, M_WAITOK);
tl->xfer = xfer;
STAILQ_INSERT_TAIL(&fc->tlabels[label], tl, link);
crit_exit();
switch(rfp->mode.hdr.tcode){
/* XXX need fix for 64bit arch */
case FWTCODE_WREQB:
- xfer->send.buf = malloc(12, M_FW, M_WAITOK);
+ xfer->send.buf = kmalloc(12, M_FW, M_WAITOK);
xfer->send.len = 12;
sfp = (struct fw_pkt *)xfer->send.buf;
bcopy(rfp->mode.wreqb.payload,
sfp->mode.wres.rtcode = 0;
break;
case FWTCODE_WREQQ:
- xfer->send.buf = malloc(12, M_FW, M_WAITOK);
+ xfer->send.buf = kmalloc(12, M_FW, M_WAITOK);
xfer->send.len = 12;
sfp->mode.wres.tcode = FWTCODE_WRES;
*((u_int32_t *)(ntohl(rfp->mode.wreqb.dest_lo))) = rfp->mode.wreqq.data;
sfp->mode.wres.rtcode = 0;
break;
case FWTCODE_RREQB:
- xfer->send.buf = malloc(16 + rfp->mode.rreqb.len, M_FW, M_WAITOK);
+ xfer->send.buf = kmalloc(16 + rfp->mode.rreqb.len, M_FW, M_WAITOK);
xfer->send.len = 16 + ntohs(rfp->mode.rreqb.len);
sfp = (struct fw_pkt *)xfer->send.buf;
bcopy((caddr_t)ntohl(rfp->mode.rreqb.dest_lo),
sfp->mode.rresb.extcode = 0;
break;
case FWTCODE_RREQQ:
- xfer->send.buf = malloc(16, M_FW, M_WAITOK);
+ xfer->send.buf = kmalloc(16, M_FW, M_WAITOK);
xfer->send.len = 16;
sfp = (struct fw_pkt *)xfer->send.buf;
sfp->mode.rresq.data = *(u_int32_t *)(ntohl(rfp->mode.rreqq.dest_lo));
* POSSIBILITY OF SUCH DAMAGE.
*
* $FreeBSD: src/sys/dev/firewire/fwdev.c,v 1.36 2004/01/22 14:41:17 simokawa Exp $
- * $DragonFly: src/sys/bus/firewire/fwdev.c,v 1.12 2006/07/28 02:17:33 dillon Exp $
+ * $DragonFly: src/sys/bus/firewire/fwdev.c,v 1.13 2006/09/05 00:55:35 dillon Exp $
*
*/
b->psize, b->nchunk * b->npacket, BUS_DMA_WAITOK);
if (q->buf == NULL) {
- free(q->bulkxfer, M_FW);
+ kfree(q->bulkxfer, M_FW);
q->bulkxfer = NULL;
return(ENOMEM);
}
if (q->buf != NULL)
fwdma_free_multiseg(q->buf);
q->buf = NULL;
- free(q->bulkxfer, M_FW);
+ kfree(q->bulkxfer, M_FW);
q->bulkxfer = NULL;
q->flag &= ~FWXFERQ_EXTBUF;
q->psize = 0;
}
#endif
- dev->si_drv1 = malloc(sizeof(struct fw_drv1), M_FW, M_WAITOK | M_ZERO);
+ dev->si_drv1 = kmalloc(sizeof(struct fw_drv1), M_FW, M_WAITOK | M_ZERO);
return err;
}
fwb = STAILQ_FIRST(&ir->binds)) {
STAILQ_REMOVE(&fc->binds, fwb, fw_bind, fclist);
STAILQ_REMOVE_HEAD(&ir->binds, chlist);
- free(fwb, M_FW);
+ kfree(fwb, M_FW);
}
ir->flag &= ~(FWXFERQ_OPEN |
FWXFERQ_MODEMASK | FWXFERQ_CHTAGMASK);
FWXFERQ_MODEMASK | FWXFERQ_CHTAGMASK);
d->it = NULL;
}
- free(dev->si_drv1, M_FW);
+ kfree(dev->si_drv1, M_FW);
dev->si_drv1 = NULL;
return err;
}
STAILQ_REMOVE(&sc->fc->binds, fwb, fw_bind, fclist);
STAILQ_REMOVE(&ir->binds, fwb, fw_bind, chlist);
- free(fwb, M_FW);
+ kfree(fwb, M_FW);
break;
case FW_SBINDADDR:
if(bindreq->len <= 0 ){
err = EINVAL;
break;
}
- fwb = malloc(sizeof (struct fw_bind), M_FW, M_WAITOK);
+ fwb = kmalloc(sizeof (struct fw_bind), M_FW, M_WAITOK);
fwb->start = ((u_int64_t)bindreq->start.hi << 32) |
bindreq->start.lo;
fwb->end = fwb->start + bindreq->len;
/* XXX alloc buf */
xfer = fw_xfer_alloc(M_FWXFER);
if(xfer == NULL){
- free(fwb, M_FW);
+ kfree(fwb, M_FW);
return (ENOMEM);
}
xfer->fc = sc->fc;
break;
}
/* myself */
- ptr = malloc(CROMSIZE, M_FW, M_WAITOK);
+ ptr = kmalloc(CROMSIZE, M_FW, M_WAITOK);
len = CROMSIZE;
for (i = 0; i < CROMSIZE/4; i++)
((u_int32_t *)ptr)[i]
err = copyout(ptr, crom_buf->ptr, len);
if (fwdev == NULL)
/* myself */
- free(ptr, M_FW);
+ kfree(ptr, M_FW);
break;
default:
sc->fc->ioctl(ap);
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
- * $DragonFly: src/sys/bus/firewire/fwdma.c,v 1.5 2004/02/05 17:51:43 joerg Exp $
+ * $DragonFly: src/sys/bus/firewire/fwdma.c,v 1.6 2006/09/05 00:55:35 dillon Exp $
*/
#ifndef __DragonFly__
#endif
&am->dma_tag)) {
printf("fwdma_malloc_multiseg: tag_create failed\n");
- free(am, M_FW);
+ kfree(am, M_FW);
return(NULL);
}
seg->v_addr, am->ssize);
}
bus_dma_tag_destroy(am->dma_tag);
- free(am, M_FW);
+ kfree(am, M_FW);
}
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
- * $DragonFly: src/sys/bus/firewire/fwmem.c,v 1.10 2006/07/28 02:17:33 dillon Exp $
+ * $DragonFly: src/sys/bus/firewire/fwmem.c,v 1.11 2006/09/05 00:55:35 dillon Exp $
*/
#ifndef __DragonFly__
if (fwmem_debug)
printf("%s: refcount=%d\n", __func__, fms->refcount);
if (fms->refcount < 1) {
- free(dev->si_drv1, M_FW);
+ kfree(dev->si_drv1, M_FW);
dev->si_drv1 = NULL;
}
*
* $FreeBSD: src/sys/dev/firewire/fwohci.c,v 1.72 2004/01/22 14:41:17 simokawa Exp $
* $FreeBSD: src/sys/dev/firewire/fwohci.c,v 1.1.2.19 2003/05/01 06:24:37 simokawa Exp $
- * $DragonFly: src/sys/bus/firewire/fwohci.c,v 1.10 2006/07/28 02:17:33 dillon Exp $
+ * $DragonFly: src/sys/bus/firewire/fwohci.c,v 1.11 2006/09/05 00:55:35 dillon Exp $
*/
#define ATRQ_CH 0
dbch->ndb = 0;
db_tr = STAILQ_FIRST(&dbch->db_trq);
fwdma_free_multiseg(dbch->am);
- free(db_tr, M_FW);
+ kfree(db_tr, M_FW);
STAILQ_INIT(&dbch->db_trq);
dbch->flags &= ~FWOHCI_DBCH_INIT;
}
DB_SIZE(dbch), dbch->ndb, BUS_DMA_WAITOK);
if (dbch->am == NULL) {
printf("fwohci_db_init: fwdma_malloc_multiseg failed\n");
- free(db_tr, M_FW);
+ kfree(db_tr, M_FW);
return;
}
/* Attach DB to DMA ch. */
goto sidout;
}
plen -= 4; /* chop control info */
- buf = (u_int32_t *)malloc(OHCI_SIDSIZE, M_FW, M_INTWAIT);
+ buf = (u_int32_t *)kmalloc(OHCI_SIDSIZE, M_FW, M_INTWAIT);
if (buf == NULL) {
device_printf(fc->dev, "malloc failed\n");
goto sidout;
fw_drain_txq(fc);
#endif
fw_sidrcv(fc, buf, plen);
- free(buf, M_FW);
+ kfree(buf, M_FW);
}
sidout:
if((stat & OHCI_INT_DMA_ATRQ )){
* SUCH DAMAGE.
*
* $FreeBSD: src/sys/i386/isa/isa_compat.c,v 1.18.2.1 2001/05/17 23:05:06 imp Exp $
- * $DragonFly: src/sys/bus/isa/i386/isa_compat.c,v 1.9 2005/05/24 20:58:50 dillon Exp $
+ * $DragonFly: src/sys/bus/isa/i386/isa_compat.c,v 1.10 2006/09/05 00:55:35 dillon Exp $
*/
#include <sys/param.h>
struct isa_compat_driver *driver;
for (i = 0, op = &old_drivers[0]; i < old_drivers_count; i++, op++) {
- driver = malloc(sizeof(struct isa_compat_driver), M_DEVBUF, M_WAITOK | M_ZERO);
+ driver = kmalloc(sizeof(struct isa_compat_driver), M_DEVBUF, M_WAITOK | M_ZERO);
driver->driver.name = op->driver->name;
driver->driver.methods = isa_compat_methods;
driver->driver.size = sizeof(struct isa_device);
*
* from: @(#)isa.c 7.2 (Berkeley) 5/13/91
* $FreeBSD: src/sys/i386/isa/isa_dma.c,v 1.4.2.1 2000/08/08 19:49:53 peter Exp $
- * $DragonFly: src/sys/bus/isa/i386/isa_dma.c,v 1.8 2006/04/30 17:22:15 dillon Exp $
+ * $DragonFly: src/sys/bus/isa/i386/isa_dma.c,v 1.9 2006/09/05 00:55:35 dillon Exp $
*/
/*
dma_bouncebufsize[chan] = bouncebufsize;
/* Try malloc() first. It works better if it works. */
- buf = malloc(bouncebufsize, M_DEVBUF, M_NOWAIT);
+ buf = kmalloc(bouncebufsize, M_DEVBUF, M_NOWAIT);
if (buf != NULL) {
if (isa_dmarangecheck(buf, bouncebufsize, chan) == 0) {
dma_bouncebuf[chan] = buf;
return;
}
- free(buf, M_DEVBUF);
+ kfree(buf, M_DEVBUF);
}
buf = contigmalloc(bouncebufsize, M_DEVBUF, M_NOWAIT, 0ul, 0xfffffful,
1ul, chan & 4 ? 0x20000ul : 0x10000ul);
* SUCH DAMAGE.
*
* $FreeBSD: src/sys/isa/isa_common.c,v 1.16.2.1 2000/09/16 15:49:52 roger Exp $
- * $DragonFly: src/sys/bus/isa/isa_common.c,v 1.10 2006/08/03 16:40:46 swildner Exp $
+ * $DragonFly: src/sys/bus/isa/isa_common.c,v 1.11 2006/09/05 00:55:35 dillon Exp $
*/
/*
* Modifications for Intel architecture by Garrett A. Wollman.
}
}
- free(children, M_TEMP);
+ kfree(children, M_TEMP);
isa_running = 1;
}
device_t child;
struct isa_device *idev;
- idev = malloc(sizeof(struct isa_device), M_ISADEV, M_WAITOK | M_ZERO);
+ idev = kmalloc(sizeof(struct isa_device), M_ISADEV, M_WAITOK | M_ZERO);
resource_list_init(&idev->id_resources);
TAILQ_INIT(&idev->id_configs);
}
}
- free(children, M_TEMP);
+ kfree(children, M_TEMP);
}
static int
struct isa_device* idev = DEVTOISA(child);
struct isa_config_entry *newice, *ice;
- newice = malloc(sizeof *ice, M_DEVBUF, M_WAITOK);
+ newice = kmalloc(sizeof *ice, M_DEVBUF, M_WAITOK);
newice->ice_priority = priority;
newice->ice_config = *config;
* SUCH DAMAGE.
*
* $FreeBSD: src/sys/isa/pnp.c,v 1.5.2.1 2002/10/14 09:31:09 nyan Exp $
- * $DragonFly: src/sys/bus/isa/pnp.c,v 1.10 2006/08/03 16:40:46 swildner Exp $
+ * $DragonFly: src/sys/bus/isa/pnp.c,v 1.11 2006/09/05 00:55:35 dillon Exp $
* from: pnp.c,v 1.11 1999/05/06 22:11:19 peter Exp
*/
isa_set_vendorid(dev, p->vendor_id);
isa_set_serial(dev, p->serial);
isa_set_logicalid(dev, logical_id);
- csnldn = malloc(sizeof *csnldn, M_DEVBUF, M_WAITOK);
+ csnldn = kmalloc(sizeof *csnldn, M_DEVBUF, M_WAITOK);
csnldn->csn = csn;
csnldn->ldn = ldn;
ISA_SET_CONFIG_CALLBACK(parent, dev,
if (space == 0) {
space = 1024;
- resources = malloc(space, M_TEMP, M_WAITOK);
+ resources = kmalloc(space, M_TEMP, M_WAITOK);
}
if (len + amount > space) {
int extra = 1024;
while (len + amount > space + extra)
extra += 1024;
- newres = malloc(space + extra, M_TEMP, M_WAITOK);
+ newres = kmalloc(space + extra, M_TEMP, M_WAITOK);
bcopy(resources, newres, len);
- free(resources, M_TEMP);
+ kfree(resources, M_TEMP);
resources = newres;
space += extra;
}
* Cleanup.
*/
if (resources)
- free(resources, M_TEMP);
+ kfree(resources, M_TEMP);
return found;
}
* SUCH DAMAGE.
*
* $FreeBSD: src/sys/isa/pnpparse.c,v 1.14 2003/06/11 00:32:45 obrien Exp $
- * $DragonFly: src/sys/bus/isa/pnpparse.c,v 1.6 2004/04/07 05:54:32 dillon Exp $
+ * $DragonFly: src/sys/bus/isa/pnpparse.c,v 1.7 2006/09/05 00:55:35 dillon Exp $
*/
#include <sys/param.h>
if (ncfgs == 1) {
/* Single config without dependants */
ISA_ADD_CONFIG(parent, dev, priorities[0], &configs[0]);
- free(configs, M_DEVBUF);
+ kfree(configs, M_DEVBUF);
return;
}
ISA_ADD_CONFIG(parent, dev, priorities[i], &configs[i]);
}
- free(configs, M_DEVBUF);
+ kfree(configs, M_DEVBUF);
}
u_char *
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* $FreeBSD: src/sys/isa/vga_isa.c,v 1.17 2000/01/29 15:08:56 peter Exp $
- * $DragonFly: src/sys/bus/isa/vga_isa.c,v 1.10 2006/07/28 02:17:34 dillon Exp $
+ * $DragonFly: src/sys/bus/isa/vga_isa.c,v 1.11 2006/09/05 00:55:35 dillon Exp $
*/
#include "opt_vga.h"
/* Save the video state across the suspend. */
if (sc->state_buf != NULL) {
- free(sc->state_buf, M_TEMP);
+ kfree(sc->state_buf, M_TEMP);
sc->state_buf = NULL;
}
nbytes = (*vidsw[sc->adp->va_index]->save_state)(sc->adp, NULL, 0);
if (nbytes <= 0)
return (0);
- sc->state_buf = malloc(nbytes, M_TEMP, M_NOWAIT | M_ZERO);
+ sc->state_buf = kmalloc(nbytes, M_TEMP, M_NOWAIT | M_ZERO);
if (sc->state_buf == NULL)
return (0);
if (bootverbose)
nbytes) != 0) {
device_printf(dev, "failed to save state (nbytes=%d)\n",
nbytes);
- free(sc->state_buf, M_TEMP);
+ kfree(sc->state_buf, M_TEMP);
sc->state_buf = NULL;
}
return (0);
if ((*vidsw[sc->adp->va_index]->load_state)(sc->adp,
sc->state_buf) != 0)
device_printf(dev, "failed to reload state\n");
- free(sc->state_buf, M_TEMP);
+ kfree(sc->state_buf, M_TEMP);
sc->state_buf = NULL;
}
/* $NetBSD: pcmcia.c,v 1.23 2000/07/28 19:17:02 drochner Exp $ */
/* $FreeBSD: src/sys/dev/pccard/pccard.c,v 1.70 2002/11/14 14:02:32 mux Exp $ */
-/* $DragonFly: src/sys/bus/pccard/pccard.c,v 1.15 2005/12/19 01:18:57 dillon Exp $ */
+/* $DragonFly: src/sys/bus/pccard/pccard.c,v 1.16 2006/09/05 00:55:36 dillon Exp $ */
/*
* Copyright (c) 1997 Marc Horowitz. All rights reserved.
* are combination cards, but only one of these units
* can be on at a time.
*/
- ivar = malloc(sizeof(struct pccard_ivar), M_DEVBUF,
+ ivar = kmalloc(sizeof(struct pccard_ivar), M_DEVBUF,
M_INTWAIT | M_ZERO);
child = device_add_child(dev, NULL, -1);
device_set_ivars(child, ivar);
while (NULL != (pf = STAILQ_FIRST(&sc->card.pf_head))) {
while (NULL != (cfe = STAILQ_FIRST(&pf->cfe_head))) {
STAILQ_REMOVE_HEAD(&pf->cfe_head, cfe_list);
- free(cfe, M_DEVBUF);
+ kfree(cfe, M_DEVBUF);
}
STAILQ_REMOVE_HEAD(&sc->card.pf_head, pf_list);
- free(pf, M_DEVBUF);
+ kfree(pf, M_DEVBUF);
}
return (0);
}
/* $NetBSD: pcmcia_cis.c,v 1.17 2000/02/10 09:01:52 chopps Exp $ */
/* $FreeBSD: src/sys/dev/pccard/pccard_cis.c,v 1.23 2002/11/14 14:02:32 mux Exp $ */
-/* $DragonFly: src/sys/bus/pccard/pccard_cis.c,v 1.3 2004/06/28 02:34:44 dillon Exp $ */
+/* $DragonFly: src/sys/bus/pccard/pccard_cis.c,v 1.4 2006/09/05 00:55:36 dillon Exp $ */
/*
* Copyright (c) 1997 Marc Horowitz. All rights reserved.
for (pf = STAILQ_FIRST(&state->card->pf_head);
pf != NULL; pf = pfnext) {
pfnext = STAILQ_NEXT(pf, pf_list);
- free(pf, M_DEVBUF);
+ kfree(pf, M_DEVBUF);
}
STAILQ_INIT(&state->card->pf_head);
break;
}
if ((state->pf == NULL) || (state->gotmfc == 2)) {
- state->pf = malloc(sizeof(*state->pf), M_DEVBUF,
+ state->pf = kmalloc(sizeof(*state->pf), M_DEVBUF,
M_INTWAIT | M_ZERO);
state->pf->number = state->count++;
state->pf->last_config_index = -1;
* with the current default
*/
if (num != state->default_cfe->number) {
- cfe = malloc(sizeof(*cfe), M_DEVBUF, M_INTWAIT);
+ cfe = kmalloc(sizeof(*cfe), M_DEVBUF, M_INTWAIT);
*cfe = *state->default_cfe;
/* $NetBSD: pcmcia_cis_quirks.c,v 1.6 2000/04/12 21:07:55 scw Exp $ */
/* $FreeBSD: src/sys/dev/pccard/pccard_cis_quirks.c,v 1.7 2002/02/09 21:34:06 imp Exp $ */
-/* $DragonFly: src/sys/bus/pccard/pccard_cis_quirks.c,v 1.3 2006/01/22 14:03:51 swildner Exp $ */
+/* $DragonFly: src/sys/bus/pccard/pccard_cis_quirks.c,v 1.4 2006/09/05 00:55:36 dillon Exp $ */
#define PCCARDDEBUG
for (cfe = STAILQ_FIRST(&pf->cfe_head); cfe != NULL;
cfe = cfe_next) {
cfe_next = STAILQ_NEXT(cfe, cfe_list);
- free(cfe, M_DEVBUF);
+ kfree(cfe, M_DEVBUF);
}
pf_next = STAILQ_NEXT(pf, pf_list);
- free(pf, M_DEVBUF);
+ kfree(pf, M_DEVBUF);
}
STAILQ_INIT(&sc->card.pf_head);
}
if (pf_last == pccard_cis_quirks[i].pf) {
- cfe = malloc(sizeof(*cfe), M_DEVBUF, M_INTWAIT);
+ cfe = kmalloc(sizeof(*cfe), M_DEVBUF, M_INTWAIT);
*cfe = *pccard_cis_quirks[i].cfe;
STAILQ_INSERT_TAIL(&pf->cfe_head, cfe, cfe_list);
} else {
- pf = malloc(sizeof(*pf), M_DEVBUF, M_INTWAIT);
+ pf = kmalloc(sizeof(*pf), M_DEVBUF, M_INTWAIT);
*pf = *pccard_cis_quirks[i].pf;
STAILQ_INIT(&pf->cfe_head);
- cfe = malloc(sizeof(*cfe), M_DEVBUF, M_INTWAIT);
+ cfe = kmalloc(sizeof(*cfe), M_DEVBUF, M_INTWAIT);
*cfe = *pccard_cis_quirks[i].cfe;
STAILQ_INSERT_TAIL(&pf->cfe_head, cfe, cfe_list);
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* $FreeBSD: src/sys/i386/isa/pci_cfgreg.c,v 1.1.2.7 2001/11/28 05:47:03 imp Exp $
- * $DragonFly: src/sys/bus/pci/i386/pci_cfgreg.c,v 1.11 2005/11/04 08:57:23 dillon Exp $
+ * $DragonFly: src/sys/bus/pci/i386/pci_cfgreg.c,v 1.12 2006/09/05 00:55:36 dillon Exp $
*
*/
}
}
if (pci_children != NULL)
- free(pci_children, M_TEMP);
+ kfree(pci_children, M_TEMP);
}
if (pci_devices != NULL)
- free(pci_devices, M_TEMP);
+ kfree(pci_devices, M_TEMP);
return (irq);
}
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* $FreeBSD: src/sys/i386/isa/pcibus.c,v 1.57.2.12 2003/08/07 06:19:26 imp Exp $
- * $DragonFly: src/sys/bus/pci/i386/pcibus.c,v 1.14 2005/10/30 04:41:12 dillon Exp $
+ * $DragonFly: src/sys/bus/pci/i386/pcibus.c,v 1.15 2006/09/05 00:55:36 dillon Exp $
*
*/
if (nexus_get_pcibus(devs[i]) == busnum)
s = NULL;
}
- free(devs, M_TEMP);
+ kfree(devs, M_TEMP);
}
if (s == NULL)
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* $FreeBSD: src/sys/pci/pci.c,v 1.141.2.15 2002/04/30 17:48:18 tmm Exp $
- * $DragonFly: src/sys/bus/pci/pci.c,v 1.31 2006/08/25 22:37:08 swildner Exp $
+ * $DragonFly: src/sys/bus/pci/pci.c,v 1.32 2006/09/05 00:55:36 dillon Exp $
*
*/
{
pcih1cfgregs *p;
- p = malloc(sizeof (pcih1cfgregs), M_DEVBUF, M_WAITOK | M_ZERO);
+ p = kmalloc(sizeof (pcih1cfgregs), M_DEVBUF, M_WAITOK | M_ZERO);
if (p == NULL)
return (NULL);
{
pcih2cfgregs *p;
- p = malloc(sizeof (pcih2cfgregs), M_DEVBUF, M_WAITOK | M_ZERO);
+ p = kmalloc(sizeof (pcih2cfgregs), M_DEVBUF, M_WAITOK | M_ZERO);
if (p == NULL)
return (NULL);
if (PCIB_READ_CONFIG(pcib, b, s, f, PCIR_DEVVENDOR, 4) != -1) {
- devlist_entry = malloc(size, M_DEVBUF, M_WAITOK | M_ZERO);
+ devlist_entry = kmalloc(size, M_DEVBUF, M_WAITOK | M_ZERO);
if (devlist_entry == NULL)
return (NULL);
devlist_head = &pci_devq;
if (dinfo->cfg.hdrspec != NULL)
- free(dinfo->cfg.hdrspec, M_DEVBUF);
+ kfree(dinfo->cfg.hdrspec, M_DEVBUF);
/* XXX this hasn't been tested */
STAILQ_REMOVE(devlist_head, dinfo, pci_devinfo, pci_links);
- free(dinfo, M_DEVBUF);
+ kfree(dinfo, M_DEVBUF);
/* increment the generation count */
pci_generation++;
/*
* Allocate a buffer to hold the patterns.
*/
- pattern_buf = malloc(cio->pat_buf_len, M_TEMP,
+ pattern_buf = kmalloc(cio->pat_buf_len, M_TEMP,
M_WAITOK);
error = copyin(cio->patterns, pattern_buf,
cio->pat_buf_len);
cio->status = PCI_GETCONF_MORE_DEVS;
if (pattern_buf != NULL)
- free(pattern_buf, M_TEMP);
+ kfree(pattern_buf, M_TEMP);
break;
}
}
}
- free(children, M_TEMP);
+ kfree(children, M_TEMP);
return (bus_generic_resume(dev));
}
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* $FreeBSD: src/sys/pci/pci_compat.c,v 1.35.2.1 2001/10/14 21:14:14 luigi Exp $
- * $DragonFly: src/sys/bus/pci/pci_compat.c,v 1.10 2005/11/04 08:57:22 dillon Exp $
+ * $DragonFly: src/sys/bus/pci/pci_compat.c,v 1.11 2006/09/05 00:55:36 dillon Exp $
*
*/
switch (type) {
case MOD_LOAD:
- driver = malloc(sizeof(struct pci_compat_driver), M_DEVBUF, M_WAITOK | M_ZERO);
+ driver = kmalloc(sizeof(struct pci_compat_driver), M_DEVBUF, M_WAITOK | M_ZERO);
driver->driver.name = dvp->pd_name;
driver->driver.methods = pci_compat_methods;
driver->driver.size = sizeof(struct pci_devinfo *);
/**************************************************************************
**
** $FreeBSD: src/sys/pci/pcisupport.c,v 1.154.2.15 2003/04/29 15:55:06 simokawa Exp $
-** $DragonFly: src/sys/bus/pci/pcisupport.c,v 1.16 2006/01/22 14:03:51 swildner Exp $
+** $DragonFly: src/sys/bus/pci/pcisupport.c,v 1.17 2006/09/05 00:55:36 dillon Exp $
**
** Device driver for DEC/INTEL PCI chipsets.
**
snprintf(tmpbuf+strlen(tmpbuf), sizeof(tmpbuf)-strlen(tmpbuf),
" bridge (vendor=%04x device=%04x)",
pci_get_vendor(dev), pci_get_device(dev));
- descr = malloc (strlen(tmpbuf) +1, M_DEVBUF, M_WAITOK);
+ descr = kmalloc (strlen(tmpbuf) +1, M_DEVBUF, M_WAITOK);
strcpy(descr, tmpbuf);
return descr;
}
* SUCH DAMAGE.
*
* $FreeBSD: src/sys/dev/ppbus/ppbconf.c,v 1.17.2.1 2000/05/24 00:20:57 n_hibma Exp $
- * $DragonFly: src/sys/bus/ppbus/ppbconf.c,v 1.9 2005/10/30 04:41:14 dillon Exp $
+ * $DragonFly: src/sys/bus/ppbus/ppbconf.c,v 1.10 2006/09/05 00:55:36 dillon Exp $
*
*/
#include "opt_ppb_1284.h"
device_t child;
/* allocate ivars for the new ppbus child */
- ppbdev = malloc(sizeof(struct ppb_device), M_PPBUSDEV, M_WAITOK | M_ZERO);
+ ppbdev = kmalloc(sizeof(struct ppb_device), M_PPBUSDEV, M_WAITOK | M_ZERO);
/* initialize the ivars */
ppbdev->name = name;
/*
* $NetBSD: ehci.c,v 1.67 2004/07/06 04:18:05 mycroft Exp $
* $FreeBSD: src/sys/dev/usb/ehci.c,v 1.5 2003/11/10 00:20:52 joe Exp $
- * $DragonFly: src/sys/bus/usb/ehci.c,v 1.23 2006/08/03 16:40:46 swildner Exp $
+ * $DragonFly: src/sys/bus/usb/ehci.c,v 1.24 2006/09/05 00:55:36 dillon Exp $
*/
/*
}
#endif
} else {
- xfer = malloc(sizeof(struct ehci_xfer), M_USB, M_INTWAIT);
+ xfer = kmalloc(sizeof(struct ehci_xfer), M_USB, M_INTWAIT);
}
if (xfer != NULL) {
memset(xfer, 0, sizeof(struct ehci_xfer));
/*
* $NetBSD: hid.c,v 1.17 2001/11/13 06:24:53 lukem Exp $
* $FreeBSD: src/sys/dev/usb/hid.c,v 1.23 2003/08/24 17:55:54 obrien Exp $
- * $DragonFly: src/sys/bus/usb/hid.c,v 1.7 2005/11/11 19:34:38 dillon Exp $
+ * $DragonFly: src/sys/bus/usb/hid.c,v 1.8 2006/09/05 00:55:36 dillon Exp $
*/
/*
* Copyright (c) 1998 The NetBSD Foundation, Inc.
{
struct hid_data *s;
- s = malloc(sizeof *s, M_TEMP, M_INTWAIT|M_ZERO);
+ s = kmalloc(sizeof *s, M_TEMP, M_INTWAIT|M_ZERO);
s->start = s->p = d;
s->end = (char *)d + len;
s->kindset = kindset;
while (s->cur.next != NULL) {
struct hid_item *hi = s->cur.next->next;
- free(s->cur.next, M_TEMP);
+ kfree(s->cur.next, M_TEMP);
s->cur.next = hi;
}
- free(s, M_TEMP);
+ kfree(s, M_TEMP);
}
int
c->loc.count = dval;
break;
case 10: /* Push */
- hi = malloc(sizeof *hi, M_TEMP, M_INTWAIT);
+ hi = kmalloc(sizeof *hi, M_TEMP, M_INTWAIT);
*hi = s->cur;
c->next = hi;
break;
oldpos = c->loc.pos;
s->cur = *hi;
c->loc.pos = oldpos;
- free(hi, M_TEMP);
+ kfree(hi, M_TEMP);
break;
default:
printf("Global bTag=%d\n", bTag);
/*
* $NetBSD: ohci.c,v 1.138 2003/02/08 03:32:50 ichiro Exp $
* $FreeBSD: src/sys/dev/usb/ohci.c,v 1.141 2003/12/22 15:40:10 shiba Exp $
- * $DragonFly: src/sys/bus/usb/ohci.c,v 1.14 2006/05/03 15:08:41 dillon Exp $
+ * $DragonFly: src/sys/bus/usb/ohci.c,v 1.15 2006/09/05 00:55:36 dillon Exp $
*/
/* Also, already ported:
* $NetBSD: ohci.c,v 1.140 2003/05/13 04:42:00 gson Exp $
}
#endif
} else {
- xfer = malloc(sizeof(struct ohci_xfer), M_USB, M_INTWAIT);
+ xfer = kmalloc(sizeof(struct ohci_xfer), M_USB, M_INTWAIT);
}
if (xfer != NULL) {
memset(xfer, 0, sizeof (struct ohci_xfer));
* $NetBSD: uhci.c,v 1.80 2000/01/19 01:16:38 augustss Exp $
* $NetBSD: uhci.c,v 1.170 2003/02/19 01:35:04 augustss Exp $
* $FreeBSD: src/sys/dev/usb/uhci.c,v 1.149 2003/11/10 00:08:41 joe Exp $
- * $DragonFly: src/sys/bus/usb/uhci.c,v 1.14 2006/07/18 02:03:11 dillon Exp $
+ * $DragonFly: src/sys/bus/usb/uhci.c,v 1.15 2006/09/05 00:55:36 dillon Exp $
*/
/* Also already incorporated from NetBSD:
if (xfer == NULL)
break;
SIMPLEQ_REMOVE_HEAD(&sc->sc_free_xfers, next);
- free(xfer, M_USB);
+ kfree(xfer, M_USB);
}
/* XXX free other data structures XXX */
}
#endif
} else {
- xfer = malloc(sizeof(struct uhci_xfer), M_USB, M_INTWAIT);
+ xfer = kmalloc(sizeof(struct uhci_xfer), M_USB, M_INTWAIT);
}
if (xfer != NULL) {
memset(xfer, 0, sizeof (struct uhci_xfer));
for(i = 0; i < npoll; i++)
uhci_free_sqh(sc, upipe->u.intr.qhs[i]);
- free(upipe->u.intr.qhs, M_USBHC);
+ kfree(upipe->u.intr.qhs, M_USBHC);
/* XXX free other resources */
}
}
crit_exit();
- free(iso->stds, M_USBHC);
+ kfree(iso->stds, M_USBHC);
}
usbd_status
bad:
while (--i >= 0)
uhci_free_std(sc, iso->stds[i]);
- free(iso->stds, M_USBHC);
+ kfree(iso->stds, M_USBHC);
return (USBD_NOMEM);
}
upipe->u.intr.npoll = npoll;
upipe->u.intr.qhs =
- malloc(npoll * sizeof(uhci_soft_qh_t *), M_USBHC, M_INTWAIT);
+ kmalloc(npoll * sizeof(uhci_soft_qh_t *), M_USBHC, M_INTWAIT);
/*
* Figure out which offset in the schedule that has most
/*
* $NetBSD: uhub.c,v 1.64 2003/02/08 03:32:51 ichiro Exp $
* $FreeBSD: src/sys/dev/usb/uhub.c,v 1.54 2003/08/24 17:55:55 obrien Exp $
- * $DragonFly: src/sys/bus/usb/uhub.c,v 1.6 2004/03/12 03:43:06 dillon Exp $
+ * $DragonFly: src/sys/bus/usb/uhub.c,v 1.7 2006/09/05 00:55:36 dillon Exp $
*/
/*
usbd_interface_handle iface;
usb_endpoint_descriptor_t *ed;
- devinfo = malloc(1024, M_TEMP, M_WAITOK);
+ devinfo = kmalloc(1024, M_TEMP, M_WAITOK);
DPRINTFN(1,("uhub_attach\n"));
sc->sc_hub = dev;
usbd_devinfo(dev, 1, devinfo);
if (err) {
DPRINTF(("%s: configuration failed, error=%s\n",
USBDEVNAME(sc->sc_dev), usbd_errstr(err)));
- free(devinfo, M_TEMP);
+ kfree(devinfo, M_TEMP);
USB_ATTACH_ERROR_RETURN;
}
if (dev->depth > USB_HUB_MAX_DEPTH) {
printf("%s: hub depth (%d) exceeded, hub ignored\n",
USBDEVNAME(sc->sc_dev), USB_HUB_MAX_DEPTH);
- free(devinfo, M_TEMP);
+ kfree(devinfo, M_TEMP);
USB_ATTACH_ERROR_RETURN;
}
if (err) {
DPRINTF(("%s: getting hub descriptor failed, error=%s\n",
USBDEVNAME(sc->sc_dev), usbd_errstr(err)));
- free(devinfo, M_TEMP);
+ kfree(devinfo, M_TEMP);
USB_ATTACH_ERROR_RETURN;
}
USB_ATTACH_SUCCESS_RETURN;
bad:
- free(hub, M_USBDEV);
- free(devinfo, M_TEMP);
+ kfree(hub, M_USBDEV);
+ kfree(devinfo, M_TEMP);
dev->hub = 0;
USB_ATTACH_ERROR_RETURN;
}
usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_hub,
USBDEV(sc->sc_dev));
- free(hub, M_USBDEV);
+ kfree(hub, M_USBDEV);
sc->sc_hub->hub = NULL;
return (0);
/*
* $NetBSD: usb.c,v 1.68 2002/02/20 20:30:12 christos Exp $
* $FreeBSD: src/sys/dev/usb/usb.c,v 1.95 2003/11/09 23:54:21 joe Exp $
- * $DragonFly: src/sys/bus/usb/usb.c,v 1.19 2006/09/03 18:29:14 dillon Exp $
+ * $DragonFly: src/sys/bus/usb/usb.c,v 1.20 2006/09/05 00:55:36 dillon Exp $
*/
/* Also already merged from NetBSD:
ur->ucr_request.bmRequestType & UT_READ ?
UIO_READ : UIO_WRITE;
uio.uio_td = curthread;
- ptr = malloc(len, M_TEMP, M_WAITOK);
+ ptr = kmalloc(len, M_TEMP, M_WAITOK);
if (uio.uio_rw == UIO_WRITE) {
error = uiomove(ptr, len, &uio);
if (error)
}
ret:
if (ptr)
- free(ptr, M_TEMP);
+ kfree(ptr, M_TEMP);
return (error);
}
#endif
*ue = ueq->ue;
TAILQ_REMOVE(&usb_events, ueq, next);
- free(ueq, M_USBDEV);
+ kfree(ueq, M_USBDEV);
usb_nevents--;
return (1);
}
struct usb_event ue;
struct timeval thetime;
- ueq = malloc(sizeof *ueq, M_USBDEV, M_INTWAIT);
+ ueq = kmalloc(sizeof *ueq, M_USBDEV, M_INTWAIT);
ueq->ue = *uep;
ueq->ue.ue_type = type;
microtime(&thetime);
if (ueqi->ue.u.ue_driver.ue_cookie.cookie ==
uep->u.ue_device.udi_cookie.cookie) {
TAILQ_REMOVE(&usb_events, ueqi, next);
- free(ueqi, M_USBDEV);
+ kfree(ueqi, M_USBDEV);
usb_nevents--;
ueqi_next = TAILQ_FIRST(&usb_events);
}
/*
* $NetBSD: usb_mem.c,v 1.26 2003/02/01 06:23:40 thorpej Exp $
* $FreeBSD: src/sys/dev/usb/usb_mem.c,v 1.5 2003/10/04 22:13:21 joe Exp $
- * $DragonFly: src/sys/bus/usb/usb_mem.c,v 1.6 2005/07/18 14:50:55 dillon Exp $
+ * $DragonFly: src/sys/bus/usb/usb_mem.c,v 1.7 2006/09/05 00:55:36 dillon Exp $
*/
/*
* Copyright (c) 1998 The NetBSD Foundation, Inc.
crit_exit();
DPRINTFN(6, ("usb_block_allocmem: no free\n"));
- p = malloc(sizeof *p, M_USB, M_INTWAIT);
+ p = kmalloc(sizeof *p, M_USB, M_INTWAIT);
logmemory(blkalloc, p, NULL, size, align);
#if defined(__FreeBSD__) && __FreeBSD_version >= 500000
tagfree:
bus_dma_tag_destroy(p->tag);
free:
- free(p, M_USB);
+ kfree(p, M_USB);
return (USBD_NOMEM);
}
/*
* $NetBSD: usb_subr.c,v 1.99 2002/07/11 21:14:34 augustss Exp $
* $FreeBSD: src/sys/dev/usb/usb_subr.c,v 1.58 2003/09/01 07:47:42 ticso Exp $
- * $DragonFly: src/sys/bus/usb/usb_subr.c,v 1.11 2006/01/22 14:03:51 swildner Exp $
+ * $DragonFly: src/sys/bus/usb/usb_subr.c,v 1.12 2006/09/05 00:55:36 dillon Exp $
*/
/* Also already have from NetBSD:
bad:
if (ifc->endpoints != NULL) {
- free(ifc->endpoints, M_USB);
+ kfree(ifc->endpoints, M_USB);
ifc->endpoints = NULL;
}
return (USBD_INVAL);
{
usbd_interface_handle ifc = &dev->ifaces[ifcno];
if (ifc->endpoints)
- free(ifc->endpoints, M_USB);
+ kfree(ifc->endpoints, M_USB);
}
Static usbd_status
nifc = dev->cdesc->bNumInterface;
for (ifcidx = 0; ifcidx < nifc; ifcidx++)
usbd_free_iface_data(dev, ifcidx);
- free(dev->ifaces, M_USB);
- free(dev->cdesc, M_USB);
+ kfree(dev->ifaces, M_USB);
+ kfree(dev->cdesc, M_USB);
dev->ifaces = NULL;
dev->cdesc = NULL;
dev->config = USB_UNCONFIG_NO;
if (err)
return (err);
len = UGETW(cd.wTotalLength);
- cdp = malloc(len, M_USB, M_INTWAIT);
+ cdp = kmalloc(len, M_USB, M_INTWAIT);
/* Get the full descriptor. */
err = usbd_get_desc(dev, UDESC_CONFIG, index, len, cdp);
if (err)
return (USBD_NORMAL_COMPLETION);
bad:
- free(cdp, M_USB);
+ kfree(cdp, M_USB);
return (err);
}
DPRINTFN(1,("usbd_setup_pipe: dev=%p iface=%p ep=%p pipe=%p\n",
dev, iface, ep, pipe));
- p = malloc(dev->bus->pipe_size, M_USB, M_INTWAIT);
+ p = kmalloc(dev->bus->pipe_size, M_USB, M_INTWAIT);
p->device = dev;
p->iface = iface;
p->endpoint = ep;
DPRINTFN(-1,("usbd_setup_pipe: endpoint=0x%x failed, error="
"%s\n",
ep->edesc->bEndpointAddress, usbd_errstr(err)));
- free(p, M_USB);
+ kfree(p, M_USB);
return (err);
}
/* Clear any stall and make sure DATA0 toggle will be used next. */
usbd_abort_pipe(pipe);
pipe->methods->close(pipe);
pipe->endpoint->refcnt--;
- free(pipe, M_USB);
+ kfree(pipe, M_USB);
}
int
DPRINTF(("usbd_probe_and_attach: trying device specific drivers\n"));
dv = USB_DO_ATTACH(dev, bdev, parent, &uaa, usbd_print, usbd_submatch);
if (dv) {
- dev->subdevs = malloc(2 * sizeof dv, M_USB, M_INTWAIT);
+ dev->subdevs = kmalloc(2 * sizeof dv, M_USB, M_INTWAIT);
dev->subdevs[0] = dv;
dev->subdevs[1] = 0;
return (USBD_NORMAL_COMPLETION);
ifaces[i] = &dev->ifaces[i];
uaa.ifaces = ifaces;
uaa.nifaces = nifaces;
- dev->subdevs = malloc((nifaces+1) * sizeof dv, M_USB, M_INTWAIT);
+ dev->subdevs = kmalloc((nifaces+1) * sizeof dv, M_USB, M_INTWAIT);
found = 0;
for (i = 0; i < nifaces; i++) {
#endif
return (USBD_NORMAL_COMPLETION);
}
- free(dev->subdevs, M_USB);
+ kfree(dev->subdevs, M_USB);
dev->subdevs = 0;
}
/* No interfaces were attached in any of the configurations. */
uaa.ifaceno = UHUB_UNK_INTERFACE;
dv = USB_DO_ATTACH(dev, bdev, parent, &uaa, usbd_print, usbd_submatch);
if (dv != NULL) {
- dev->subdevs = malloc(2 * sizeof dv, M_USB, M_INTWAIT);
+ dev->subdevs = kmalloc(2 * sizeof dv, M_USB, M_INTWAIT);
dev->subdevs[0] = dv;
dev->subdevs[1] = 0;
return (USBD_NORMAL_COMPLETION);
return (USBD_NO_ADDR);
}
- dev = malloc(sizeof *dev, M_USB, M_INTWAIT | M_ZERO);
+ dev = kmalloc(sizeof *dev, M_USB, M_INTWAIT | M_ZERO);
dev->bus = bus;
/* Set up default endpoint handle. */
up->device = 0;
dev->bus->devices[dev->address] = 0;
- free(dev, M_USB);
+ kfree(dev, M_USB);
}
#if defined(__NetBSD__) || defined(__OpenBSD__)
nifc = dev->cdesc->bNumInterface;
for (ifcidx = 0; ifcidx < nifc; ifcidx++)
usbd_free_iface_data(dev, ifcidx);
- free(dev->ifaces, M_USB);
+ kfree(dev->ifaces, M_USB);
}
if (dev->cdesc != NULL)
- free(dev->cdesc, M_USB);
+ kfree(dev->cdesc, M_USB);
if (dev->subdevs != NULL)
- free(dev->subdevs, M_USB);
- free(dev, M_USB);
+ kfree(dev->subdevs, M_USB);
+ kfree(dev, M_USB);
}
/*
{
void *q;
- q = malloc(size, pool, flags);
+ q = kmalloc(size, pool, flags);
if (q == NULL)
return (NULL);
bcopy(p, q, size);
- free(p, pool);
+ kfree(p, pool);
return (q);
}
#endif
/*
* $NetBSD: usbdi.c,v 1.103 2002/09/27 15:37:38 provos Exp $
* $FreeBSD: src/sys/dev/usb/usbdi.c,v 1.84 2003/11/09 23:56:19 joe Exp $
- * $DragonFly: src/sys/bus/usb/usbdi.c,v 1.9 2005/06/02 20:40:40 dillon Exp $
+ * $DragonFly: src/sys/bus/usb/usbdi.c,v 1.10 2006/09/05 00:55:36 dillon Exp $
*/
/*
pipe->methods->close(pipe);
if (pipe->intrxfer != NULL)
usbd_free_xfer(pipe->intrxfer);
- free(pipe, M_USB);
+ kfree(pipe, M_USB);
return (USBD_NORMAL_COMPLETION);
}
/* new setting works, we can free old endpoints */
if (endpoints != NULL)
- free(endpoints, M_USB);
+ kfree(endpoints, M_USB);
#ifdef DIAGNOSTIC
if (iface->idesc == NULL) {
* $NetBSD: usbdi_util.c,v 1.24 1999/11/17 23:00:50 augustss Exp $
* $NetBSD: usbdi_util.c,v 1.36 2001/11/13 06:24:57 lukem Exp $
* $FreeBSD: src/sys/dev/usb/usbdi_util.c,v 1.31 2003/08/24 17:55:55 obrien Exp $
- * $DragonFly: src/sys/bus/usb/usbdi_util.c,v 1.8 2005/06/02 20:40:40 dillon Exp $
+ * $DragonFly: src/sys/bus/usb/usbdi_util.c,v 1.9 2006/09/05 00:55:36 dillon Exp $
*/
/*
if (hid == NULL)
return (USBD_IOERROR);
*sizep = UGETW(hid->descrs[0].wDescriptorLength);
- *descp = malloc(*sizep, mem, M_INTWAIT);
+ *descp = kmalloc(*sizep, mem, M_INTWAIT);
err = usbd_get_report_descriptor(dev, id->bInterfaceNumber,
*sizep, *descp);
if (err) {
- free(*descp, mem);
+ kfree(*descp, mem);
*descp = NULL;
return (err);
}
void*
ath_hal_malloc(size_t size)
{
- return malloc(size, M_ATH_HAL, M_NOWAIT | M_ZERO);
+ return kmalloc(size, M_ATH_HAL, M_NOWAIT | M_ZERO);
}
void
ath_hal_free(void* p)
{
- return free(p, M_ATH_HAL);
+ return kfree(p, M_ATH_HAL);
}
void
* ----------------------------------------------------------------------------
*
* $FreeBSD: src/sys/contrib/dev/fla/fla.c,v 1.16 1999/12/08 04:45:16 ken Exp $
- * $DragonFly: src/sys/contrib/dev/fla/Attic/fla.c,v 1.13 2006/07/28 02:17:35 dillon Exp $
+ * $DragonFly: src/sys/contrib/dev/fla/Attic/fla.c,v 1.14 2006/09/05 00:55:36 dillon Exp $
*
*/
void *
doc2k_malloc(int bytes)
{
- return malloc(bytes, M_FLA, M_WAITOK);
+ return kmalloc(bytes, M_FLA, M_WAITOK);
}
void
doc2k_free(void *ptr)
{
- free(ptr, M_FLA);
+ kfree(ptr, M_FLA);
}
void
* SUCH DAMAGE.
*
* $FreeBSD: src/sys/contrib/dev/oltr/if_oltr.c,v 1.11.2.5 2001/10/20 04:15:21 mdodd Exp $
- * $DragonFly: src/sys/contrib/dev/oltr/Attic/if_oltr.c,v 1.22 2005/11/30 13:35:24 sephe Exp $
+ * $DragonFly: src/sys/contrib/dev/oltr/Attic/if_oltr.c,v 1.23 2006/09/05 00:55:36 dillon Exp $
*/
#include <sys/param.h>
scratch_size = TRlldAdapterSize();
if (bootverbose)
device_printf(dev, "adapter memory block size %d bytes\n", scratch_size);
- sc->TRlldAdapter = (TRlldAdapter_t)malloc(scratch_size, M_DEVBUF, M_NOWAIT);
+ sc->TRlldAdapter = (TRlldAdapter_t)kmalloc(scratch_size, M_DEVBUF, M_NOWAIT);
if (sc->TRlldAdapter == NULL) {
device_printf(dev, "couldn't allocate scratch buffer (%d bytes)\n", scratch_size);
goto config_failed;
*/
for (i = 0; i < RING_BUFFER_LEN; i++) {
sc->rx_ring[i].index = i;
- sc->rx_ring[i].data = (char *)malloc(RX_BUFFER_LEN, M_DEVBUF, M_NOWAIT);
+ sc->rx_ring[i].data = (char *)kmalloc(RX_BUFFER_LEN, M_DEVBUF, M_NOWAIT);
sc->rx_ring[i].address = vtophys(sc->rx_ring[i].data);
sc->tx_ring[i].index = i;
- sc->tx_ring[i].data = (char *)malloc(TX_BUFFER_LEN, M_DEVBUF, M_NOWAIT);
+ sc->tx_ring[i].data = (char *)kmalloc(TX_BUFFER_LEN, M_DEVBUF, M_NOWAIT);
sc->tx_ring[i].address = vtophys(sc->tx_ring[i].data);
if ((!sc->rx_ring[i].data) || (!sc->tx_ring[i].data)) {
device_printf(dev, "unable to allocate ring buffers\n");
while (i > 0) {
if (sc->rx_ring[i].data)
- free(sc->rx_ring[i].data, M_DEVBUF);
+ kfree(sc->rx_ring[i].data, M_DEVBUF);
if (sc->tx_ring[i].data)
- free(sc->tx_ring[i].data, M_DEVBUF);
+ kfree(sc->tx_ring[i].data, M_DEVBUF);
i--;
}
goto config_failed;
/* Deallocate all dynamic memory regions */
for (i = 0; i < RING_BUFFER_LEN; i++) {
- free(sc->rx_ring[i].data, M_DEVBUF);
- free(sc->tx_ring[i].data, M_DEVBUF);
+ kfree(sc->rx_ring[i].data, M_DEVBUF);
+ kfree(sc->tx_ring[i].data, M_DEVBUF);
}
if (sc->work_memory)
- free(sc->work_memory, M_DEVBUF);
- free(sc->TRlldAdapter, M_DEVBUF);
+ kfree(sc->work_memory, M_DEVBUF);
+ kfree(sc->TRlldAdapter, M_DEVBUF);
crit_exit();
crit_enter();
- sc = malloc(sizeof(struct oltr_softc), M_DEVBUF, M_NOWAIT | M_ZERO);
+ sc = kmalloc(sizeof(struct oltr_softc), M_DEVBUF, M_NOWAIT | M_ZERO);
if (sc == NULL) {
printf("oltr%d: no memory for softc struct!\n", unit);
goto config_failed;
scratch_size = TRlldAdapterSize();
if (bootverbose)
printf("oltr%d: adapter memory block size %d bytes\n", unit, scratch_size);
- sc->TRlldAdapter = (TRlldAdapter_t)malloc(scratch_size, M_DEVBUF, M_NOWAIT);
+ sc->TRlldAdapter = (TRlldAdapter_t)kmalloc(scratch_size, M_DEVBUF, M_NOWAIT);
if (sc->TRlldAdapter == NULL) {
printf("oltr%d: couldn't allocate scratch buffer (%d bytes)\n",unit, scratch_size);
goto config_failed;
*/
for (i = 0; i < RING_BUFFER_LEN; i++) {
sc->rx_ring[i].index = i;
- sc->rx_ring[i].data = (char *)malloc(RX_BUFFER_LEN, M_DEVBUF, M_NOWAIT);
+ sc->rx_ring[i].data = (char *)kmalloc(RX_BUFFER_LEN, M_DEVBUF, M_NOWAIT);
sc->rx_ring[i].address = vtophys(sc->rx_ring[i].data);
sc->tx_ring[i].index = i;
- sc->tx_ring[i].data = (char *)malloc(TX_BUFFER_LEN, M_DEVBUF, M_NOWAIT);
+ sc->tx_ring[i].data = (char *)kmalloc(TX_BUFFER_LEN, M_DEVBUF, M_NOWAIT);
sc->tx_ring[i].address = vtophys(sc->tx_ring[i].data);
if ((!sc->rx_ring[i].data) || (!sc->tx_ring[i].data)) {
printf("oltr%d: unable to allocate ring buffers\n", unit);
while (i > 0) {
if (sc->rx_ring[i].data)
- free(sc->rx_ring[i].data, M_DEVBUF);
+ kfree(sc->rx_ring[i].data, M_DEVBUF);
if (sc->tx_ring[i].data)
- free(sc->tx_ring[i].data, M_DEVBUF);
+ kfree(sc->tx_ring[i].data, M_DEVBUF);
i--;
}
goto config_failed;
}
if (work_size) {
- if ((sc->work_memory = malloc(work_size, M_DEVBUF, M_NOWAIT)) == NULL) {
+ if ((sc->work_memory = kmalloc(work_size, M_DEVBUF, M_NOWAIT)) == NULL) {
printf("oltr%d: failed to allocate work memory (%d octets).\n", sc->unit, work_size);
} else {
TRlldAddMemory(sc->TRlldAdapter, sc->work_memory,
* SUCH DAMAGE.
*
* $FreeBSD: src/sys/dev/acpica/Osd/OsdMemory.c,v 1.11 2004/04/14 03:39:08 njl Exp $
- * $DragonFly: src/sys/dev/acpica5/Osd/OsdMemory.c,v 1.3 2004/06/27 08:52:42 dillon Exp $
+ * $DragonFly: src/sys/dev/acpica5/Osd/OsdMemory.c,v 1.4 2006/09/05 00:55:36 dillon Exp $
*/
/*
void *
AcpiOsAllocate(ACPI_SIZE Size)
{
- return (malloc(Size, M_ACPICA, M_INTWAIT));
+ return (kmalloc(Size, M_ACPICA, M_INTWAIT));
}
void
AcpiOsFree(void *Memory)
{
- free(Memory, M_ACPICA);
+ kfree(Memory, M_ACPICA);
}
ACPI_STATUS
if (*LogicalAddress == NULL)
return(AE_BAD_ADDRESS);
else {
- track = malloc(sizeof(struct acpi_memtrack), M_ACPICA, M_INTWAIT);
+ track = kmalloc(sizeof(struct acpi_memtrack), M_ACPICA, M_INTWAIT);
track->next = acpi_mapbase;
track->base = *LogicalAddress;
track->size = Length;
if (track->base == LogicalAddress && track->size == Length) {
*ptrack = track->next;
pmap_unmapdev((vm_offset_t)track->base, track->size);
- free(track, M_ACPICA);
+ kfree(track, M_ACPICA);
return;
}
/*
" large! %p/%08x (actual was %p/%08x)\n",
LogicalAddress, Length,
track->base, track->size);
- free(track, M_ACPICA);
+ kfree(track, M_ACPICA);
goto again;
}
* SUCH DAMAGE.
*
* $FreeBSD: src/sys/dev/acpica/Osd/OsdSchedule.c,v 1.28 2004/05/06 02:18:58 njl Exp $
- * $DragonFly: src/sys/dev/acpica5/Osd/OsdSchedule.c,v 1.5 2005/03/12 14:33:40 y0netan1 Exp $
+ * $DragonFly: src/sys/dev/acpica5/Osd/OsdSchedule.c,v 1.6 2006/09/05 00:55:36 dillon Exp $
*/
/*
}
/* Note: Interrupt Context */
- at = malloc(sizeof(*at), M_ACPITASK, M_INTWAIT | M_ZERO);
+ at = kmalloc(sizeof(*at), M_ACPITASK, M_INTWAIT | M_ZERO);
lwkt_initmsg(&at->at_msg, &acpi_afree_rport, 0,
lwkt_cmd_op_none, lwkt_cmd_op_none);
at->at_function = Function;
static void
acpi_autofree_reply(lwkt_port_t port, lwkt_msg_t msg)
{
- free(msg, M_ACPITASK);
+ kfree(msg, M_ACPITASK);
}
UINT64
* SUCH DAMAGE.
*
* $FreeBSD: src/sys/dev/acpica/Osd/OsdSynch.c,v 1.21 2004/05/05 20:07:52 njl Exp $
- * $DragonFly: src/sys/dev/acpica5/Osd/OsdSynch.c,v 1.7 2006/06/04 21:09:48 dillon Exp $
+ * $DragonFly: src/sys/dev/acpica5/Osd/OsdSynch.c,v 1.8 2006/09/05 00:55:36 dillon Exp $
*/
/*
if (InitialUnits > MaxUnits)
return_ACPI_STATUS (AE_BAD_PARAMETER);
- as = malloc(sizeof(*as), M_ACPISEM, M_INTWAIT | M_ZERO);
+ as = kmalloc(sizeof(*as), M_ACPISEM, M_INTWAIT | M_ZERO);
#if __FreeBSD_version >= 500000
mtx_init(&as->as_mtx, "ACPI semaphore", NULL, MTX_DEF);
#if __FreeBSD_version >= 500000
mtx_destroy(&as->as_mtx);
#endif
- free(as, M_ACPISEM);
+ kfree(as, M_ACPISEM);
#endif /* !ACPI_NO_SEMAPHORES */
return_ACPI_STATUS (AE_OK);
if (OutHandle == NULL)
return (AE_BAD_PARAMETER);
- lock = malloc(sizeof(*lock), M_ACPISEM, M_INTWAIT|M_ZERO);
+ lock = kmalloc(sizeof(*lock), M_ACPISEM, M_INTWAIT|M_ZERO);
lockinit(lock, "oslck", 0, 0);
*OutHandle = (ACPI_HANDLE)lock;
return (AE_OK);
struct lock *lock;
if ((lock = (struct lock *)Handle) != NULL)
- free(lock, M_ACPISEM);
+ kfree(lock, M_ACPISEM);
}
/*
* SUCH DAMAGE.
*
* $FreeBSD: src/sys/dev/acpica/acpi.c,v 1.157 2004/06/05 09:56:04 njl Exp $
- * $DragonFly: src/sys/dev/acpica5/acpi.c,v 1.21 2006/09/03 17:43:55 dillon Exp $
+ * $DragonFly: src/sys/dev/acpica5/acpi.c,v 1.22 2006/09/05 00:55:36 dillon Exp $
*/
#include "opt_acpi.h"
(xsdt->OemRevision == quirk->OemRevision ||
quirk->OemRevision == ACPI_OEM_REV_ANY)) {
len += strlen(quirk->value) + 2;
- if ((tmp = malloc(len, M_TEMP, M_NOWAIT)) == NULL)
+ if ((tmp = kmalloc(len, M_TEMP, M_NOWAIT)) == NULL)
goto out;
sprintf(tmp, "%s %s", env ? env : "", quirk->value);
#ifdef notyet
setenv("debug.acpi.disabled", tmp);
#endif /* notyet */
- free(tmp, M_TEMP);
+ kfree(tmp, M_TEMP);
break;
}
}
struct acpi_device *ad;
device_t child;
- ad = malloc(sizeof(*ad), M_ACPIDEV, M_INTWAIT | M_ZERO);
+ ad = kmalloc(sizeof(*ad), M_ACPIDEV, M_INTWAIT | M_ZERO);
resource_list_init(&ad->ad_rl);
{
ACPI_BUFFER *buf;
- buf = malloc(size + sizeof(*buf), M_ACPIDEV, M_INTWAIT);
+ buf = kmalloc(size + sizeof(*buf), M_ACPIDEV, M_INTWAIT);
buf->Length = size;
buf->Pointer = (void *)(buf + 1);
return (buf);
}
acpi_wake_sysctl_walk(child);
}
- free(devlist, M_TEMP);
+ kfree(devlist, M_TEMP);
return (0);
}
{
struct acpi_ioctl_hook *hp;
- hp = malloc(sizeof(*hp), M_ACPIDEV, M_INTWAIT);
+ hp = kmalloc(sizeof(*hp), M_ACPIDEV, M_INTWAIT);
hp->cmd = cmd;
hp->fn = fn;
hp->arg = arg;
if (hp != NULL) {
TAILQ_REMOVE(&acpi_ioctl_hooks, hp, link);
- free(hp, M_ACPIDEV);
+ kfree(hp, M_ACPIDEV);
}
}
* SUCH DAMAGE.
*
* $FreeBSD: src/sys/dev/acpica/acpi_battery.c,v 1.8 2003/08/11 15:34:43 njl Exp $
- * $DragonFly: src/sys/dev/acpica5/acpi_battery.c,v 1.2 2004/05/05 22:19:24 dillon Exp $
+ * $DragonFly: src/sys/dev/acpica5/acpi_battery.c,v 1.3 2006/09/05 00:55:36 dillon Exp $
*/
#include "opt_acpi.h"
int error;
error = 0;
- bp = malloc(sizeof(*bp), M_ACPIBATT, M_INTWAIT);
+ bp = kmalloc(sizeof(*bp), M_ACPIBATT, M_INTWAIT);
bp->battdesc.type = type;
bp->battdesc.phys_unit = phys_unit;
if (acpi_batteries_initted == 0) {
if ((error = acpi_battery_init()) != 0) {
- free(bp, M_ACPIBATT);
+ kfree(bp, M_ACPIBATT);
return (error);
}
}
* SUCH DAMAGE.
*
* $FreeBSD: src/sys/dev/acpica/acpi_cmbat.c,v 1.29 2004/05/30 20:08:23 phk Exp $
- * $DragonFly: src/sys/dev/acpica5/acpi_cmbat.c,v 1.6 2005/03/12 14:33:40 y0netan1 Exp $
+ * $DragonFly: src/sys/dev/acpica5/acpi_cmbat.c,v 1.7 2006/09/05 00:55:36 dillon Exp $
*/
#include "opt_acpi.h"
/* Allocate array of softc pointers */
if (bat_units != acpi_cmbat_units) {
if (bat != NULL) {
- free(bat, M_ACPICMBAT);
+ kfree(bat, M_ACPICMBAT);
bat = NULL;
}
bat_units = 0;
* SUCH DAMAGE.
*
* $FreeBSD: src/sys/dev/acpica/acpi_ec.c,v 1.51 2004/05/30 20:08:23 phk Exp $
- * $DragonFly: src/sys/dev/acpica5/acpi_ec.c,v 1.7 2006/06/04 21:09:47 dillon Exp $
+ * $DragonFly: src/sys/dev/acpica5/acpi_ec.c,v 1.8 2006/09/05 00:55:36 dillon Exp $
*/
/******************************************************************************
*
*****************************************************************************/
/*
* $FreeBSD: src/sys/dev/acpica/acpi_ec.c,v 1.51 2004/05/30 20:08:23 phk Exp $
- * $DragonFly: src/sys/dev/acpica5/acpi_ec.c,v 1.7 2006/06/04 21:09:47 dillon Exp $
+ * $DragonFly: src/sys/dev/acpica5/acpi_ec.c,v 1.8 2006/09/05 00:55:36 dillon Exp $
*
*/
* before initializing devices, but in practice this function
* should be safe to call at this point.
*/
- params = malloc(sizeof(struct acpi_ec_params), M_TEMP, M_WAITOK | M_ZERO);
+ params = kmalloc(sizeof(struct acpi_ec_params), M_TEMP, M_WAITOK | M_ZERO);
params->gpe_handle = NULL;
params->gpe_bit = ecdt->gpe_bit;
params->uid = ecdt->uid;
params = acpi_get_private(dev);
ret = 0;
} else if (acpi_MatchHid(dev, "PNP0C09")) {
- params = malloc(sizeof(struct acpi_ec_params), M_TEMP,
+ params = kmalloc(sizeof(struct acpi_ec_params), M_TEMP,
M_WAITOK | M_ZERO);
h = acpi_get_handle(dev);
}
if (ret > 0 && params)
- free(params, M_TEMP);
+ kfree(params, M_TEMP);
if (buf.Pointer)
AcpiOsFree(buf.Pointer);
return (ret);
sc->ec_gpebit = params->gpe_bit;
sc->ec_gpehandle = params->gpe_handle;
sc->ec_uid = params->uid;
- free(params, M_TEMP);
+ kfree(params, M_TEMP);
/* Attach bus resources for data and command/status ports. */
sc->ec_data_rid = 0;
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* $FreeBSD: src/sys/dev/acpica/acpi_pci.c,v 1.16 2004/05/29 04:32:50 njl Exp $
- * $DragonFly: src/sys/dev/acpica5/acpi_pci.c,v 1.4 2005/10/30 04:41:15 dillon Exp $
+ * $DragonFly: src/sys/dev/acpica5/acpi_pci.c,v 1.5 2006/09/05 00:55:36 dillon Exp $
*/
#include "opt_bus.h"
if (dinfo->ap_dinfo.cfg.func == func &&
dinfo->ap_dinfo.cfg.slot == slot) {
dinfo->ap_handle = handle;
- free(devlist, M_TEMP);
+ kfree(devlist, M_TEMP);
return_ACPI_STATUS (AE_OK);
}
}
- free(devlist, M_TEMP);
+ kfree(devlist, M_TEMP);
return_ACPI_STATUS (AE_OK);
}
* SUCH DAMAGE.
*
* $FreeBSD: src/sys/dev/acpica/acpi_powerres.c,v 1.22 2004/04/14 17:58:19 njl Exp $
- * $DragonFly: src/sys/dev/acpica5/acpi_powerres.c,v 1.3 2004/06/27 08:52:39 dillon Exp $
+ * $DragonFly: src/sys/dev/acpica5/acpi_powerres.c,v 1.4 2006/09/05 00:55:36 dillon Exp $
*/
#include "opt_acpi.h"
return_ACPI_STATUS (AE_OK); /* already know about it */
/* Allocate a new resource */
- rp = malloc(sizeof(*rp), M_ACPIPWR, M_INTWAIT | M_ZERO);
+ rp = kmalloc(sizeof(*rp), M_ACPIPWR, M_INTWAIT | M_ZERO);
TAILQ_INIT(&rp->ap_references);
rp->ap_resource = res;
if (buf.Pointer != NULL)
AcpiOsFree(buf.Pointer);
if (ACPI_FAILURE(status) && rp != NULL)
- free(rp, M_ACPIPWR);
+ kfree(rp, M_ACPIPWR);
return_ACPI_STATUS (status);
}
/* Pull it off the list and free it */
TAILQ_REMOVE(&acpi_powerresources, rp, ap_link);
- free(rp, M_ACPIPWR);
+ kfree(rp, M_ACPIPWR);
ACPI_DEBUG_PRINT((ACPI_DB_OBJECTS, "deregistered power resource %s\n",
acpi_name(res)));
return_ACPI_STATUS (AE_OK);
/* Allocate a new power consumer */
- pc = malloc(sizeof(*pc), M_ACPIPWR, M_INTWAIT);
+ pc = kmalloc(sizeof(*pc), M_ACPIPWR, M_INTWAIT);
TAILQ_INSERT_HEAD(&acpi_powerconsumers, pc, ac_link);
TAILQ_INIT(&pc->ac_references);
pc->ac_consumer = consumer;
acpi_name(pr->ar_resource->ap_resource)));
TAILQ_REMOVE(&pr->ar_resource->ap_references, pr, ar_rlink);
TAILQ_REMOVE(&pc->ac_references, pr, ar_clink);
- free(pr, M_ACPIPWR);
+ kfree(pr, M_ACPIPWR);
}
/*
acpi_name(rp->ap_resource)));
/* Create a reference between the consumer and resource */
- pr = malloc(sizeof(*pr), M_ACPIPWR, M_INTWAIT | M_ZERO);
+ pr = kmalloc(sizeof(*pr), M_ACPIPWR, M_INTWAIT | M_ZERO);
pr->ar_consumer = pc;
pr->ar_resource = rp;
TAILQ_INSERT_TAIL(&pc->ac_references, pr, ar_clink);
* SUCH DAMAGE.
*
* $FreeBSD: src/sys/pci/agp.c,v 1.3.2.4 2002/08/11 19:58:12 alc Exp $
- * $DragonFly: src/sys/dev/agp/agp.c,v 1.22 2006/08/03 16:40:46 swildner Exp $
+ * $DragonFly: src/sys/dev/agp/agp.c,v 1.23 2006/09/05 00:55:36 dillon Exp $
*/
#include "opt_bus.h"
if (pci_get_class(dev) == PCIC_DISPLAY
&& pci_get_subclass(dev) == PCIS_DISPLAY_VGA)
if (agp_find_caps(dev)) {
- free(kids, M_TEMP);
+ kfree(kids, M_TEMP);
return dev;
}
}
- free(kids, M_TEMP);
+ kfree(kids, M_TEMP);
}
return 0;
return NULL;
}
- gatt = malloc(sizeof(struct agp_gatt), M_AGP, M_INTWAIT);
+ gatt = kmalloc(sizeof(struct agp_gatt), M_AGP, M_INTWAIT);
gatt->ag_entries = entries;
gatt->ag_virtual = contigmalloc(entries * sizeof(u_int32_t), M_AGP,
M_WAITOK, 0, ~0, PAGE_SIZE, 0);
if (!gatt->ag_virtual) {
if (bootverbose)
device_printf(dev, "contiguous allocation failed\n");
- free(gatt, M_AGP);
+ kfree(gatt, M_AGP);
return 0;
}
bzero(gatt->ag_virtual, entries * sizeof(u_int32_t));
{
contigfree(gatt->ag_virtual,
gatt->ag_entries * sizeof(u_int32_t), M_AGP);
- free(gatt, M_AGP);
+ kfree(gatt, M_AGP);
}
static int agp_max[][2] = {
return 0;
}
- mem = malloc(sizeof *mem, M_AGP, M_INTWAIT);
+ mem = kmalloc(sizeof *mem, M_AGP, M_INTWAIT);
mem->am_id = sc->as_nextid++;
mem->am_size = size;
mem->am_type = 0;
sc->as_allocated -= mem->am_size;
TAILQ_REMOVE(&sc->as_memory, mem, am_link);
vm_object_deallocate(mem->am_obj);
- free(mem, M_AGP);
+ kfree(mem, M_AGP);
return 0;
}
* SUCH DAMAGE.
*
* $FreeBSD: src/sys/pci/agp_amd.c,v 1.3.2.4 2002/04/25 23:41:36 cokane Exp $
- * $DragonFly: src/sys/dev/agp/agp_amd.c,v 1.5 2004/03/24 20:42:12 dillon Exp $
+ * $DragonFly: src/sys/dev/agp/agp_amd.c,v 1.6 2006/09/05 00:55:36 dillon Exp $
*/
#include "opt_bus.h"
"allocating GATT for aperture of size %dM\n",
apsize / (1024*1024));
- gatt = malloc(sizeof(struct agp_amd_gatt), M_AGP, M_INTWAIT);
+ gatt = kmalloc(sizeof(struct agp_amd_gatt), M_AGP, M_INTWAIT);
/*
* The AMD751 uses a page directory to map a non-contiguous
/*
* Allocate the page directory.
*/
- gatt->ag_vdir = malloc(AGP_PAGE_SIZE, M_AGP, M_INTWAIT | M_ZERO);
+ gatt->ag_vdir = kmalloc(AGP_PAGE_SIZE, M_AGP, M_INTWAIT | M_ZERO);
gatt->ag_pdir = vtophys((vm_offset_t) gatt->ag_vdir);
if(bootverbose)
device_printf(dev, "gatt -> ag_pdir %8x\n",
static void
agp_amd_free_gatt(struct agp_amd_gatt *gatt)
{
- free(gatt->ag_virtual, M_AGP);
- free(gatt->ag_vdir, M_AGP);
- free(gatt, M_AGP);
+ kfree(gatt->ag_virtual, M_AGP);
+ kfree(gatt->ag_vdir, M_AGP);
+ kfree(gatt, M_AGP);
}
static const char*
* SUCH DAMAGE.
*
* $FreeBSD: src/sys/pci/agp_i810.c,v 1.1.2.5 2002/09/15 08:45:41 anholt Exp $
- * $DragonFly: src/sys/dev/agp/agp_i810.c,v 1.8 2004/07/04 00:24:52 dillon Exp $
+ * $DragonFly: src/sys/dev/agp/agp_i810.c,v 1.9 2006/09/05 00:55:36 dillon Exp $
*/
/*
child = children[i];
if (pci_get_devid(child) == devid) {
- free(children, M_TEMP);
+ kfree(children, M_TEMP);
return child;
}
}
- free(children, M_TEMP);
+ kfree(children, M_TEMP);
return 0;
}
return ENXIO;
}
- gatt = malloc( sizeof(struct agp_gatt), M_AGP, M_INTWAIT);
+ gatt = kmalloc( sizeof(struct agp_gatt), M_AGP, M_INTWAIT);
sc->gatt = gatt;
gatt->ag_entries = AGP_GET_APERTURE(dev) >> AGP_PAGE_SHIFT;
if (!gatt->ag_virtual) {
if (bootverbose)
device_printf(dev, "contiguous allocation failed\n");
- free(gatt, M_AGP);
+ kfree(gatt, M_AGP);
agp_generic_detach(dev);
return ENOMEM;
}
if ( sc->chiptype == CHIP_I810 ) {
contigfree(sc->gatt->ag_virtual, 64 * 1024, M_AGP);
}
- free(sc->gatt, M_AGP);
+ kfree(sc->gatt, M_AGP);
bus_release_resource(dev, SYS_RES_MEMORY,
AGP_I810_MMADR, sc->regs);
return 0;
}
- mem = malloc(sizeof *mem, M_AGP, M_INTWAIT);
+ mem = kmalloc(sizeof *mem, M_AGP, M_INTWAIT);
mem->am_id = sc->agp.as_nextid++;
mem->am_size = size;
mem->am_type = type;
TAILQ_REMOVE(&sc->agp.as_memory, mem, am_link);
if (mem->am_obj)
vm_object_deallocate(mem->am_obj);
- free(mem, M_AGP);
+ kfree(mem, M_AGP);
return 0;
}
/* $FreeBSD: src/sys/dev/hifn/hifn7751.c,v 1.5.2.5 2003/06/04 17:56:59 sam Exp $ */
-/* $DragonFly: src/sys/dev/crypto/hifn/hifn7751.c,v 1.10 2005/10/12 17:35:49 dillon Exp $ */
+/* $DragonFly: src/sys/dev/crypto/hifn/hifn7751.c,v 1.11 2006/09/05 00:55:36 dillon Exp $ */
/* $OpenBSD: hifn7751.c,v 1.120 2002/05/17 00:33:34 deraadt Exp $ */
/*
goto errout;
}
- cmd = malloc(sizeof(struct hifn_command), M_DEVBUF, M_INTWAIT | M_ZERO);
+ cmd = kmalloc(sizeof(struct hifn_command), M_DEVBUF, M_INTWAIT | M_ZERO);
if (crp->crp_flags & CRYPTO_F_IMBUF) {
cmd->src_m = (struct mbuf *)crp->crp_buf;
if (hifn_debug)
device_printf(sc->sc_dev, "requeue request\n");
#endif
- free(cmd, M_DEVBUF);
+ kfree(cmd, M_DEVBUF);
sc->sc_needwakeup |= CRYPTO_SYMQ;
return (err);
}
errout:
if (cmd != NULL)
- free(cmd, M_DEVBUF);
+ kfree(cmd, M_DEVBUF);
if (err == EINVAL)
hifnstats.hst_invalid++;
else
bus_dmamap_unload(sc->sc_dmat, cmd->src_map);
bus_dmamap_destroy(sc->sc_dmat, cmd->src_map);
- free(cmd, M_DEVBUF);
+ kfree(cmd, M_DEVBUF);
if (crp->crp_etype != EAGAIN)
crypto_done(crp);
}
}
bus_dmamap_unload(sc->sc_dmat, cm
projects / dragonfly.git / commitdiff