fCookie
void* fCookie;
int32 fCookie;
fController->write_pio(fCookie, (uint16 *)buffer, 1, false);
fController->write_pio(fCookie, (uint16 *)virtualAddress, length / 2,
fController->read_pio(fCookie, (uint16 *)virtualAddress, length / 2,
fController->read_pio(fCookie, (uint16 *)buffer, 1, false);
fCookie(NULL),
return fController->prepare_dma(fCookie, ccb->sg_list, ccb->sg_count,
return fController->start_dma(fCookie);
return fController->finish_dma(fCookie);
(driver_module_info **)&fController, &fCookie);
return fController->get_altstatus(fCookie);
return fController->read_pio(fCookie, (uint16 *)buffer,
fController->set_channel(fCookie, this);
return fController->write_pio(fCookie, (uint16 *)buffer,
return fController->read_command_block_regs(fCookie, taskFile, mask);
return fController->write_command_block_regs(fCookie, taskFile, mask);
return fController->write_device_control(fCookie, ATA_DEVICE_CONTROL_BIT3
fController->read_pio(fCookie, (uint16 *)buffer, currentLength, false);
fController->write_pio(fCookie, (uint16 *)buffer, 1, false);
fController->write_pio(fCookie, (uint16 *)buffer, currentLength, false);
void * fCookie;
fController->release_bus(fCookie);
(driver_module_info **)&fController, &fCookie);
fController->set_i2c_bus(fCookie, this);
return fController->exec_command(fCookie, op, slaveAddress, cmdBuffer, cmdLength,
fController->scan_bus(fCookie);
return fController->acquire_bus(fCookie);
void* fCookie;
return fController->do_io(fCookie, command, operation, offsetAsSectors);
fController->set_clock(fCookie, frequency);
fController->set_bus_width(fCookie, width);
result = fController->execute_command(fCookie, SD_SELECT_DESELECT_CARD,
fCookie(NULL),
(driver_module_info**)&fController, &fCookie);
fController->set_scan_semaphore(fCookie, fScanSemaphore);
return fController->execute_command(fCookie, command, argument, response);
void* fCookie;
status_t status = fController->read_host_features(fCookie, &fFeatures);
status = fController->write_guest_features(fCookie, fFeatures);
fController->set_status(fCookie, VIRTIO_CONFIG_STATUS_FEATURES_OK);
if ((fController->get_status(fCookie) & VIRTIO_CONFIG_STATUS_FEATURES_OK) == 0) {
fController->set_status(fCookie, VIRTIO_CONFIG_STATUS_FAILED);
fController->set_status(fCookie, VIRTIO_CONFIG_STATUS_FAILED);
return fController->write_guest_features(fCookie, fFeatures);
return fController->read_device_config(fCookie, offset, buffer,
return fController->write_device_config(fCookie, offset, buffer,
uint16 size = fController->get_queue_ring_size(fCookie, index);
fController->set_status(fCookie, VIRTIO_CONFIG_STATUS_RESET);
fController->set_status(fCookie, VIRTIO_CONFIG_STATUS_DRIVER);
status_t status = fController->setup_interrupt(fCookie, fQueueCount);
fController->set_status(fCookie, VIRTIO_CONFIG_STATUS_DRIVER_OK);
fController->set_status(fCookie, VIRTIO_CONFIG_STATUS_DRIVER);
return fController->free_interrupt(fCookie);
return fController->setup_queue(fCookie, queueNumber, physAddr, phyAvail, phyUsed);
fController->notify_queue(fCookie, queueNumber);
fCookie(NULL),
(driver_module_info **)&fController, &fCookie);
fController->set_sim(fCookie, this);
fController->set_status(fCookie, VIRTIO_CONFIG_STATUS_DRIVER);
fController->set_status(fCookie, VIRTIO_CONFIG_STATUS_RESET);
void* fCookie;
void * fCookie;
fCookie = cookie;
fCookie = NULL;
fCookie = cookie;
fCallback(Device()->DriverCookie(), fCookie);
void* Cookie() { return fCookie; }
void* fCookie;
fCookie(NULL),
: fCookie(-1),
fCookie = cookie;
return fCookie;
int32 fCookie;
fCookie(-1),
fCookie = cookie;
return fCookie;
int32 fCookie;
fCookie = AttributeIndexTreeValue::Create(owner, attributeCookie,
if (fCookie == NULL)
_data = fCookie->data;
fCookie->Delete();
fCookie = NULL;
{ return fCookie; }
AttributeIndexTreeValue* fCookie;
{ recursive_lock_unlock(fCookie->tty->lock); }
tty_cookie* fCookie;
fCookie(NULL),
fCookie = cookie;
kprintf("%s cookie: %p\n", prefix, fCookie);
fCookie(NULL),
fCookie = cookie;
fRequests[0].Init(this, fCookie, bytesNeeded);
fRequests[1].Init(this, fCookie, bytesNeeded);
fSource(fCookie->tty),
fTarget(fCookie->other_tty),
fRequestOwner.Enqueue(fCookie, &fTarget->writer_queue,
if (fEcho && fCookie->closed)
fRequestOwner.Enqueue(fCookie, &fTTY->reader_queue);
struct tty* otherTTY = fCookie->other_tty;
if (fCookie->closed)
if (fCookie->other_tty->open_count == 0
&& fCookie->other_tty->opened_count > 0) {
fCookie->other_tty->opened_count));
fCookie(cookie),
{ recursive_lock_lock(fCookie->tty->lock); }
tty_cookie* fCookie;
tty_cookie *TTYCookie() const { return fCookie; }
tty_cookie *fCookie;
return (*fGetNextChunk)(chunkData, chunkLen, mh, fCookie);
, fCookie(cookie)
void * fCookie;
return fCookie;
BPrivate::Network::BNetworkCookie fCookie;
fNotifierFunc(fCookie, B_STARTED, this);
fNotifierFunc(fCookie, B_STOPPED, this);
return fCookie;
fCookie = cookie;
fCookie = this;
fCookie = cookie;
(*fNotifierFunc)(fCookie, what);
(*fPlayBufferFunc)(fCookie, buffer, size, format);
: fCookie(0),
device = next_dev(&fCookie);
fCookie = 0;
int32 Cookie() { return fCookie; }
int32 fCookie;
msg.AddInt32("cookie", fCookie);
msg.AddInt32("cookie", fCookie);
msg.AddInt32("cookie", fCookie);
PRINT(("%s cookie %" B_PRId32 "\n", __PRETTY_FUNCTION__, fCookie));
msg.AddInt32("cookie", fCookie);
PRINT(("%s cookie %" B_PRId32 "\n", __PRETTY_FUNCTION__, fCookie));
msg.AddInt32("cookie", fCookie);
int32 Cookie() { return fCookie; };
int32 fCookie;
fCookie(cookie),
ssize_t bytesRead = fNode->ReadAt(fCookie, fOffset, buffer, bufferSize);
return fNode->ReadAt(fCookie, pos, buffer, bufferSize);
ssize_t bytesWritten = fNode->WriteAt(fCookie, fOffset, buffer, bufferSize);
return fNode->WriteAt(fCookie, pos, buffer, bufferSize);
status_t status = fNode->Close(fCookie);
void *fCookie;
return fCookie;
file_cookie* fCookie;
fCookie(cookie),
fCookie(cookie),
mode, fVnode, fMountID, fNodeID, fCookie, fPos,
void* fCookie;
void* fCookie;
return FS_CALL(fVnode, write, fCookie, offset, buffer, length);
return FS_CALL(fVnode, write_pages, fCookie, offset, &vec, 1,
return FS_CALL(fVnode, read, fCookie, offset, buffer, length);
return FS_CALL(fVnode, read_pages, fCookie, offset, &vec, 1, length);
void* fCookie;
return fDoIO(fCookie, offset, buffer, length);
fCookie, fCache);
void* fCookie;
fConstructor(fCookie, data);
fDestructor(fCookie, data);
void *fCookie;