iobuf
char iobuf[1];
iov.iov_base = iobuf;
newbuf = realloc(kd->iobuf, dsize);
kd->iobuf = newbuf;
rv = pread(fd, kd->iobuf, dsize, doff);
memcpy(buf, kd->iobuf + moff, size);
kd->iobuf = NULL;
if (kd->iobuf != 0)
free(kd->iobuf);
newbuf = realloc(kd->iobuf, dsize);
kd->iobuf = newbuf;
memset(kd->iobuf, 0, dsize);
if (pwrite(kd->pmfd, kd->iobuf, dsize, doff) == -1) {
uint8_t *iobuf;
uint8_t iobuf[NVMM_IO_BATCH_SIZE];
io->data = iobuf;
ret = read_guest_memory(mach, vcpu, gva, iobuf, iosize);
ret = write_guest_memory(mach, vcpu, gva, iobuf, iosize);
uint8_t iobuf[8];
io.data = iobuf;
static char *iobuf; /* buffer for non 512 sector I/O */
if ((nr = read(*rfd, iobuf, secsize)) != secsize)
memcpy(buf, &iobuf[mod], 512);
if ((nr = read(wfd, iobuf, secsize)) != secsize)
memcpy(&iobuf[mod], buf, 512);
if ((nr = write(wfd, iobuf, secsize)) != secsize)
if ((iobuf = malloc(secsize)) == NULL)
rdfs(d, sblock.fs_bsize, (char *)iobuf);
dp1 = (struct ufs1_dinode *)iobuf;
dp2 = (struct ufs2_dinode *)iobuf;
wtfs(d, sblock.fs_bsize, iobuf);
char *iobuf;
roundup(sizeof sblock, sectorsize), iobuf);
iobuf = mmap(0, iobuf_memsize, PROT_READ|PROT_WRITE,
if (iobuf != MAP_FAILED)
memset(iobuf, 0, iobuf_memsize);
wtfs(fssize - 1, sectorsize, iobuf);
memcpy(iobuf, &sblock, sizeof sblock);
ffs_sb_swap(&sblock, (struct fs *)iobuf);
memset(iobuf + offsetof(struct fs, fs_old_postbl_start),
memcpy(iobuf, &sblock, sizeof(sblock));
memset(iobuf + sizeof(sblock), 0, i - sizeof(sblock));
ffs_sb_swap(&sblock, (struct fs *)iobuf);
((struct fs *)iobuf)->fs_magic = FS_UFS2EA_MAGIC;
memset(iobuf + offsetof(struct fs, fs_old_postbl_start),
wtfs(sblock.fs_sblockloc / sectorsize, i, iobuf);
munmap(iobuf, iobuf_memsize);
memcpy(&iobuf[start], &acg, sblock.fs_cgsize);
ffs_cg_swap(&acg, (struct cg*)&iobuf[start], &sblock);
dp1 = (struct ufs1_dinode *)(&iobuf[start]);
dp2 = (struct ufs2_dinode *)(&iobuf[start]);
wtfs(FFS_FSBTODB(&sblock, cgsblock(&sblock, cylno)), iobufsize, iobuf);
dp1 = (struct ufs1_dinode *)(&iobuf[start]);
while ((char *)++dp1 < &iobuf[iobuf_memsize]);
d * sblock.fs_bsize / sblock.fs_frag, &iobuf[start]);
static uint8_t *iobuf; /* for superblock and group descriptors */
iobuf = mmap(0, iobufsize, PROT_READ|PROT_WRITE,
if (iobuf == NULL)
memset(iobuf, 0, iobufsize);
wtfs(fssize - 1, sectorsize, iobuf);
e2fs_sbsave(&sblock.e2fs, (struct ext2fs *)(iobuf + sboff));
e2fs_cgsave(gd, (struct ext2_gd *)(iobuf + sblock.e2fs_bsize),
iobufsize - sboff, iobuf + sboff);
munmap(iobuf, iobufsize);
e2fs_sbsave(&sblock.e2fs, (struct ext2fs *)(iobuf + sboff));
e2fs_cgsave(gd, (struct ext2_gd *)(iobuf +
sboff / sectorsize, iobufsize - sboff, iobuf + sboff);
roundup(SBSIZE, sectorsize), iobuf);
cputobsdlabel(&sdlabel, (struct cpu_disklabel *)&(iobuf[0]));
static int iobuf[DEV_BSIZE / sizeof(int)];
error = bugscstrategy(pp, F_READ, LABELSECTOR, DEV_BSIZE, iobuf, &nrd);
drive_ident(d, l->iobuf);
decode_dlabel(d, l->iobuf);
p = (uint16_t *)l->iobuf;
decode_dlabel(struct disk *d, char *iobuf)
(*d->lba_read)(d, 0, 1, iobuf);
if (bswap16(*(uint16_t *)(iobuf + MBR_MAGIC_OFFSET)) != MBR_MAGIC)
mp = (struct mbr_partition *)(iobuf + MBR_PART_OFFSET);
(*d->lba_read)(d, first + LABELSECTOR, 1, iobuf);
dlp = search_dmagic(iobuf);
(*d->lba_read)(d, rf_offset + LABELSECTOR, 1, iobuf);
dlp = search_dmagic(iobuf);
char *iobuf;
l->iobuf = allocaligned(512, 16);
l->iobuf = allocaligned(512, 16);
void *iobuf;
unsigned char iobuf[16];
iobuf[APS_CMD] = 0x13;
if (aps_do_io(iot, ioh, iobuf, APS_WRITE_0, APS_READ_1)) {
cr = iobuf[APS_ARG1];
if (iobuf[APS_RET] != 0 || cr < 1 || cr > 5) {
unsigned char iobuf[16];
iobuf[APS_CMD] = 0x17;
iobuf[APS_ARG1] = 0x81;
if (aps_do_io(sc->sc_iot, sc->sc_ioh, iobuf, APS_WRITE_1, APS_READ_3))
if (iobuf[APS_RET] != 0 ||iobuf[APS_ARG3] != 0)
if ((iobuf[APS_ARG1] != 0 || iobuf[APS_ARG2] != 0x60) &&
(iobuf[APS_ARG1] != 1 || iobuf[APS_ARG2] != 0))
iobuf[APS_CMD] = 0x14;
iobuf[APS_ARG1] = 0x01;
if (aps_do_io(sc->sc_iot, sc->sc_ioh, iobuf, APS_WRITE_1, APS_READ_0))
if (iobuf[APS_RET] != 0)
iobuf[APS_CMD] = 0x10;
iobuf[APS_ARG1] = 0xc8;
iobuf[APS_ARG2] = 0x00;
iobuf[APS_ARG3] = 0x02;
if (aps_do_io(sc->sc_iot, sc->sc_ioh, iobuf, APS_WRITE_3, APS_READ_0))
iobuf[APS_CMD] = 0x11;
if (aps_do_io(sc->sc_iot, sc->sc_ioh, iobuf, APS_WRITE_0, APS_READ_1))
if (iobuf[APS_ARG1] != 0)
unsigned char iobuf[16];
iobuf[APS_CMD] = 0x11;
if (aps_do_io(sc->sc_iot, sc->sc_ioh, iobuf, APS_WRITE_0, APS_READ_ALL))
sc->aps_data.state = iobuf[APS_STATE];
sc->aps_data.x_accel = iobuf[APS_XACCEL] + 256 * iobuf[APS_XACCEL + 1];
sc->aps_data.y_accel = iobuf[APS_YACCEL] + 256 * iobuf[APS_YACCEL + 1];
sc->aps_data.temp1 = iobuf[APS_TEMP];
sc->aps_data.x_var = iobuf[APS_XVAR] + 256 * iobuf[APS_XVAR + 1];
sc->aps_data.y_var = iobuf[APS_YVAR] + 256 * iobuf[APS_YVAR + 1];
sc->aps_data.temp2 = iobuf[APS_TEMP2];
sc->aps_data.input = iobuf[APS_INPUT];
unsigned char iobuf[16];
iobuf[APS_CMD] = 0x13;
if (aps_do_io(sc->sc_iot, sc->sc_ioh, iobuf, APS_WRITE_0, APS_READ_1)
vple = raidPtr->iobuf;
raidPtr->iobuf = vple->next;
vple->next = raidPtr->iobuf;
raidPtr->iobuf = vple;
raidPtr->iobuf = NULL;
vple->next = raidPtr->iobuf;
raidPtr->iobuf = vple;
while (raidPtr->iobuf != NULL) {
tmp = raidPtr->iobuf;
raidPtr->iobuf = raidPtr->iobuf->next;
RF_VoidPointerListElem_t *iobuf; /* I/O buffer free list */
static int iobuf(DOS_FS *, u_int);
if ((err = iobuf(fs, bytsec(offset))))
if ((err = iobuf(fs, bytsec(offset))))
memcpy(io->data, iobuf + iobuf_off, io->size);
memcpy(iobuf + iobuf_off, io->data, io->size);
memset(iobuf, 0, IO_SIZE);
strcpy(iobuf, test->wanted);
res = iobuf;
static char iobuf[IO_SIZE];
uint8_t *iobuf;
createbpfport(ifname, &iobuf, &iolen, &station);
read(pollfd.fd, iobuf, iolen); /* returns 1468 */
fp = (struct frame *)ISIBOOT_FRAME(iobuf);
char *iobuf;
iobuf = ecalloc(1, iobufsize);
memcpy(iobuf, writebuf, SBLOCKSIZE);
memcpy(&iobuf[start], &acg, sblock.fs_cgsize);
ffs_cg_swap(&acg, (struct cg*)&iobuf[start], &sblock);
dp1 = (struct ufs1_dinode *)(&iobuf[start]);
dp2 = (struct ufs2_dinode *)(&iobuf[start]);
ffs_wtfs(FFS_FSBTODB(&sblock, cgsblock(&sblock, cylno)), iobufsize, iobuf,
dp1 = (struct ufs1_dinode *)(&iobuf[start]);
sblock.fs_bsize, &iobuf[start], fsopts);
char *iobuf;
iobuf = malloc(secsize);
if (iobuf == NULL)
nr = pread(fd, iobuf, secsize, rnd);
memcpy(buf, &iobuf[mod], nbytes);
free(iobuf);
char *iobuf;
iobuf = malloc(secsize);
if (iobuf == NULL)
nr = pread(fd, iobuf, secsize, rnd);
memcpy(&iobuf[mod], buf, nbytes);
nr = pwrite(fd, iobuf, secsize, rnd);
free(iobuf);