static int read_headers(demuxer_priv_tt * ogg, stream_tt ** streams) {
int i;
int err;
if ((err = read_page(ogg, &i))) return err;
do {
if ((err = read_page(ogg, &i))) return err;
}
while (i != 0);
ogg->stream_count = ogg->nstreams;
for (i = 0; i < ogg->stream_count; i++) {
int j;
for (j = 0; codecs[j].magic; j++) {
if (codecs[j].magic_len > ogg->s[i].packets[0].p.len) continue;
if (!memcmp(codecs[j].magic, ogg->s[i].packets[0].buf, codecs[j].magic_len)) break;
}
if (!codecs[j].magic) return err_ogg_no_codec;
ogg->s[i].codec_id = codecs[j].id;
}
*streams = ogg->s;
return 0;
}
/*
General reader. Read a page and hand it over for processing.
*/
file_status_e
ogm_reader_c::read(generic_packetizer_c *,
bool) {
// Some tracks may contain huge gaps. We don't want to suck in the complete
// file.
if (get_queued_bytes() > 20 * 1024 * 1024)
return FILE_STATUS_HOLDING;
ogg_page og;
do {
// Make sure we have a page that we can work with.
if (read_page(&og) == FILE_STATUS_DONE)
return flush_packetizers();
// Is this the first page of a new stream? No, so process it normally.
if (!ogg_page_bos(&og))
process_page(&og);
} while (ogg_page_bos(&og));
size_t i;
// Are there streams that have not finished yet?
for (i = 0; i < sdemuxers.size(); i++)
if (!sdemuxers[i]->eos && sdemuxers[i]->in_use)
return FILE_STATUS_MOREDATA;
// No, we're done with this file.
return flush_packetizers();
}
static void
send_page(struct deluge_object *obj, unsigned pagenum)
{
unsigned char buf[S_PAGE];
struct deluge_msg_packet pkt;
unsigned char *cp;
pkt.cmd = DELUGE_CMD_PACKET;
pkt.pagenum = pagenum;
pkt.version = obj->pages[pagenum].version;
pkt.packetnum = 0;
pkt.object_id = obj->object_id;
pkt.crc = 0;
read_page(obj, pagenum, buf);
/* Divide the page into packets and send them one at a time. */
for(cp = buf; cp + S_PKT <= (unsigned char *)&buf[S_PAGE]; cp += S_PKT) {
if(obj->tx_set & (1 << pkt.packetnum)) {
pkt.crc = crc16_data(cp, S_PKT, 0);
memcpy(pkt.payload, cp, S_PKT);
packetbuf_copyfrom(&pkt, sizeof(pkt));
broadcast_send(&deluge_broadcast);
}
pkt.packetnum++;
}
obj->tx_set = 0;
}
static int
xc_ia64_pv_recv_vcpu_context(int xc_handle, int io_fd, int32_t dom,
uint32_t vcpu)
{
int rc = -1;
/* A copy of the CPU context of the guest. */
vcpu_guest_context_any_t ctxt_any;
vcpu_guest_context_t *ctxt = &ctxt_any.c;
if (lock_pages(&ctxt_any, sizeof(ctxt_any))) {
/* needed for build domctl, but might as well do early */
ERROR("Unable to lock_pages ctxt");
return -1;
}
if (xc_ia64_recv_vcpu_context(xc_handle, io_fd, dom, vcpu, &ctxt_any))
goto out;
/* Then get privreg page. */
if (read_page(xc_handle, io_fd, dom, ctxt->privregs_pfn) < 0) {
ERROR("Could not read vcpu privregs");
goto out;
}
rc = 0;
out:
unlock_pages(&ctxt, sizeof(ctxt));
return rc;
}
RideFile * run() {
errors.clear();
rideFile = new RideFile;
rideFile->setDeviceType("Macro Sync");
if (!file.open(QIODevice::ReadOnly)) {
delete rideFile;
return NULL;
}
bool stop = false;
int data_size = file.size();
int bytes_read = 0;
while (!stop && (bytes_read < data_size)) {
bytes_read += read_page(); // read_page(stop, errors);
}
if (stop) {
delete rideFile;
return NULL;
}
else {
return rideFile;
}
}
RideFile * run() {
errors.clear();
rideFile = new RideFile;
rideFile->setDeviceType("o_synce macro/macrox");
rideFile->setFileFormat("Macro GoldenCheetah Sync File (osyn)");
if (!file.open(QIODevice::ReadOnly)) {
delete rideFile;
return NULL;
}
bool stop = false;
int data_size = file.size();
int bytes_read = 0;
while (!stop && (bytes_read < data_size)) {
bytes_read += read_page(); // read_page(stop, errors);
}
if (stop) {
file.close();
delete rideFile;
return NULL;
} else {
file.close();
return rideFile;
}
}
int
swap_in(struct addrspace* as, vaddr_t va, void* kbuf){
(void)kbuf;
int itr =0;
//spinlock_acquire(&cm_lock);
for(; itr < MAX_VAL; itr++){
if(sw_space[itr].sw_addrspace == as && sw_space[itr].sw_vaddr == va){
if(read_page(kbuf, sw_space[itr].sw_offset)){
//spinlock_release(&cm_lock);
panic("Error while swapping in\n");
return 1;
}
break;
}
}
if(itr == MAX_VAL){
panic("Data lost in swapping\n");
return 1;
}else{
sw_space[itr].sw_addrspace = NULL;
sw_space[itr].sw_vaddr = 0;
sw_space[itr].sw_offset = 0;
//spinlock_release(&cm_lock);
return 0;
}
}
bool i2cdb::getParams( int code, dbrecord &recout )
{
uint8_t buffer[ PACKEDDBRECORD_WIDTH ];
read_page( m_eeoffset + code * PACKEDDBRECORD_WIDTH, buffer, sizeof(buffer) );
recout.unpack( buffer );
return true;
}
static int __init read_pagedir(void)
{
unsigned long addr;
int i, n = pmdisk_info.pagedir_pages;
int error = 0;
pagedir_order = get_bitmask_order(n);
addr =__get_free_pages(GFP_ATOMIC, pagedir_order);
if (!addr)
return -ENOMEM;
pm_pagedir_nosave = (struct pbe *)addr;
pr_debug("pmdisk: Reading pagedir (%d Pages)\n",n);
for (i = 0; i < n && !error; i++, addr += PAGE_SIZE) {
unsigned long offset = swp_offset(pmdisk_info.pagedir[i]);
if (offset)
error = read_page(offset, (void *)addr);
else
error = -EFAULT;
}
if (error)
free_pages((unsigned long)pm_pagedir_nosave,pagedir_order);
return error;
}
int main(void)
{
CLKPR = 0x80;
CLKPR = 0x00;
MCUCR = (1<<IVCE);
MCUCR = (1<<IVSEL);
i2c_slave_transmit = transmit;
i2c_slave_receive = receive;
i2c_slave_init(0x10);
addr = 0x0000;
read_page(addr);
sei();
do
{
_delay_ms(1000);
} while (state != BOOT);
cli();
write_page();
MCUCR = (1<<IVCE);
MCUCR = (0<<IVSEL);
app_main = (void *)addr;
boot_rww_enable_safe();
app_main();
}
int main(int argc, char * argv[])
{
/*
* use example :
* make
* ./reader https://pilotweb.nas.faa.gov/common/nat.html
*/
if (argc != 2)
return EXIT_FAILURE;
char * page = read_page(argv[1]);
if (page == NULL)
return EXIT_FAILURE;
stack_t * stack = get_tracks(page);
char * track = (char *)s_pop(&stack);
while(track != NULL)
{
printf("%s\n", track);
free(track);
track = (char *)s_pop(&stack);
}
free(page);
return EXIT_SUCCESS;
}
void initialize_program_5() {
t_swap* swap = create_swap("./spec/config_file_test.txt");
initialize_program(swap, 1, 2, "1234567890");
char* data = malloc(5);
data = read_page(swap, 1, 1);
CU_ASSERT_NSTRING_EQUAL(data, "67890", 5);
}
void read_page_2() {
t_swap* swap = create_swap("./spec/config_file_test.txt");
initialize_program(swap, 1, 1, "123");
char* data = malloc(5);
data = read_page(swap, 1, 0);
CU_ASSERT_NSTRING_EQUAL(data, "12300", 5);
}
static int fill_buffer(demuxer_priv_tt * ogg) {
int err, dummy;
if ((err = read_page(ogg, &dummy))) return err;
if (ogg->stream_count != ogg->nstreams) return err_ogg_non_interleaved;
return 0;
}
void init_read(FILE* in) {
next_findex = 1;
m_in = in;
m_out = NULL;
read_page(1, (UCHAR*)files);
next_findex = files[0].first;
files[0].first = 0;
}
int vmem_read(int address) {
if(vmem == NULL) { /* Pruefen ob eine Verbindung zum Shared Memory besteht*/
vm_init();
}
int data;
int page = address/VMEM_PAGESIZE; /* Ermitlung der Pagenummer */
int offset = address%VMEM_PAGESIZE; /* Ermittlung des Offsets */
vmem->adm.req_pageno = page; /* Angeforderte Seite */
sem_wait(&vmem->adm.sema);
if((vmem->pt.entries[page].flags & PTF_PRESENT) == PTF_PRESENT) { /* Ist die Seite im Speicher? */
data = read_page(page, offset); /* Wenn ja, Seite lesen */
} else { /* Wenn nein, Seite anfordern */
kill(vmem->adm.mmanage_pid, SIGUSR1); /* Sende Signal an mmanage*/
sem_wait(&vmem->adm.sema); /* Warte bis mmanage den Semaphor freigibt */
data = read_page(page, offset); /* Page lesen*/
}
sem_post(&vmem->adm.sema);
return data;
}
unsigned char receive(volatile unsigned char *buffer, unsigned char size)
{
if (buffer == 0)
{
state = START;
return 3;
}
else
{
switch (state)
{
case START:
if (size == 3)
{
addr = (uint16_t)buffer[1] << 8 | (uint16_t)buffer[2];
switch (buffer[0])
{
case 0x00:
state = READ;
break;
case 0x01:
state = WRITE;
return SPM_PAGESIZE - page_offset(addr);
case 0x02:
state = BOOT;
break;
default:
break;
}
return 0;
}
break;
case WRITE:
if(page_address != page_start(addr))
{
write_page();
read_page(page_start(addr));
}
for (i = 0; i < size; i++)
{
page_buffer[page_offset(addr)] = buffer[i];
addr++;
page_dirty = 1;
}
return SPM_PAGESIZE - page_offset(addr);
default:
break;
}
}
return 0;
}
bool
flac_header_extractor_c::extract() {
mxverb(2, "flac_header_extraction: extract\n");
if (!read_page()) {
mxverb(2, "flac_header_extraction: read_page() failed.\n");
return false;
}
int result = (int)FLAC__stream_decoder_process_until_end_of_stream(decoder);
mxverb(2, boost::format("flac_header_extraction: extract, result: %1%, mdp: %2%, num_header_packets: %3%\n") % result % metadata_parsed % num_header_packets);
return metadata_parsed;
}
static int usb_get_otp(struct bladerf *dev, char *otp)
{
int status, restore_status;
const uint16_t dummy_page = 0;
status = change_setting(dev, USB_IF_SPI_FLASH);
if (status) {
return status;
}
status = read_page(dev, BLADE_USB_CMD_READ_OTP, dummy_page, (uint8_t*)otp);
restore_status = restore_post_flash_setting(dev);
return status == 0 ? restore_status : status;
}
static unsigned take_phys_page(unsigned virt_page)
{
unsigned page; /* Page to be replaced. */
coremap_entry_t *coremap_entry;
page_table_entry_t *swap_entry;
page = (*replace)();
/*printf("\t%x\n", page);*/
// I renamed ram_entry to coremap_entry:
coremap_entry = &coremap[page]; // "page" is the page in RAM we want to replace,
// and coremap_entry->page is the same page but on swap.
swap_entry = &page_table[virt_page]; // swap_entry->page is the page we want to get,
// now (probably) on swap. We want to write this page to "page".
if (coremap_entry->owner != NULL) {
if (coremap_entry->owner->modified) {
if (!coremap_entry->owner->ondisk) {
coremap_entry->page = new_swap_page();
coremap_entry->owner->ondisk = 1;
}
write_page(page, coremap_entry->page);
coremap_entry->owner->modified = 0;
}
coremap_entry->owner->inmemory = 0;
coremap_entry->owner->page = coremap_entry->page;
coremap_entry->owner->ondisk = 1;
}
// after this you can write over page, without loosing the old page.
if(swap_entry->ondisk){
read_page(page, swap_entry->page);
coremap_entry->page = swap_entry->page;
}
swap_entry->inmemory = 1;
swap_entry->page = page;
coremap_entry->owner = swap_entry;
return page;
}
static int __init read_image_data(void)
{
struct pbe * p;
int error = 0;
int i;
printk( "Reading image data (%d pages): ", pmdisk_pages );
for(i = 0, p = pm_pagedir_nosave; i < pmdisk_pages && !error; i++, p++) {
if (!(i%100))
printk( "." );
error = read_page(swp_offset(p->swap_address),
(void *)p->address);
}
printk(" %d done.\n",i);
return error;
}
static int read_page(demuxer_priv_tt * ogg, int * stream) {
ogg_stream_tt * os;
int i, serial, segments;
char tmp_header[27];
uint8_t sizes[256];
int len, tot = 0;
FREAD(ogg->in, 27, tmp_header);
if (strncmp(tmp_header, "OggS", 5)) return err_bad_oggs_magic; // including version
serial = (tmp_header[14] << 24) |
(tmp_header[15] << 16) |
(tmp_header[16] << 8) |
(tmp_header[17] );
*stream = find_stream(ogg, serial);
os = &ogg->os[*stream];
segments = tmp_header[26];
FREAD(ogg->in, segments, sizes);
len = os->leftover;
for (i = 0; i < segments; i++) {
len += sizes[i];
if (sizes[i] != 255) {
packet_tt p;
p.buf = malloc(len);
p.p.len = len;
p.p.stream = *stream;
p.p.flags = p.p.pts = p.p.next_pts = 0; // Ogg sucks
memcpy(p.buf, os->leftover_buf, os->leftover);
FREAD(ogg->in, len - os->leftover, p.buf + os->leftover);
push_packet(&ogg->s[*stream], &p);
tot++;
len = 0;
os->leftover = 0;
}
}
if (len) {
os->leftover_buf = realloc(os->leftover_buf, len);
FREAD(ogg->in, len - os->leftover, os->leftover_buf + os->leftover);
os->leftover = len;
}
if (!tot) return read_page(ogg, stream); // this page gave nothing, move on to next page
return 0;
}
void
vionet_notify_rx(struct vionet_dev *dev)
{
uint64_t q_gpa;
uint32_t vr_sz, i;
uint16_t idx, pkt_desc_idx;
char *vr;
struct vring_desc *desc, *pkt_desc;
struct vring_avail *avail;
struct vring_used *used;
vr_sz = vring_size(VIONET_QUEUE_SIZE);
q_gpa = dev->vq[dev->cfg.queue_notify].qa;
q_gpa = q_gpa * VIRTIO_PAGE_SIZE;
vr = malloc(vr_sz);
if (vr == NULL) {
fprintf(stderr, "malloc error getting vionet ring\n\r");
return;
}
bzero(vr, vr_sz);
for (i = 0; i < vr_sz; i += VIRTIO_PAGE_SIZE) {
if (read_page((uint32_t)q_gpa + i, vr + i, PAGE_SIZE, 0)) {
fprintf(stderr, "error reading gpa 0x%x\n\r",
(uint32_t)q_gpa + i);
free(vr);
return;
}
}
/* Compute offsets in ring of descriptors, avail ring, and used ring */
desc = (struct vring_desc *)(vr);
avail = (struct vring_avail *)(vr +
dev->vq[dev->cfg.queue_notify].vq_availoffset);
used = (struct vring_used *)(vr +
dev->vq[dev->cfg.queue_notify].vq_usedoffset);
idx = dev->vq[dev->cfg.queue_notify].last_avail & VIONET_QUEUE_MASK;
pkt_desc_idx = avail->ring[idx] & VIONET_QUEUE_MASK;
pkt_desc = &desc[pkt_desc_idx];
dev->rx_added = 1;
free(vr);
}
static int usb_get_cal(struct bladerf *dev, char *cal)
{
const uint16_t dummy_page = 0;
int status, restore_status;
assert(CAL_BUFFER_SIZE == BLADERF_FLASH_PAGE_SIZE);
status = change_setting(dev, USB_IF_SPI_FLASH);
if (status) {
return status;
}
status = read_page(dev, BLADE_USB_CMD_READ_CAL_CACHE,
dummy_page, (uint8_t*)cal);
restore_status = restore_post_flash_setting(dev);
return status == 0 ? restore_status : status;
}
static void pagefault(unsigned virt_page)
{
unsigned page;
num_pagefault += 1;
page = take_phys_page();
page_table_entry_t* pt = &page_table[virt_page];
if (pt->ondisk) {
coremap[page].page = pt->page;
read_page(page,pt->page);
}
pt->inmemory = 1;
pt->page = page;
coremap[page].owner = pt;
}
static int __init check_header(void)
{
const char * reason = NULL;
int error;
init_header();
if ((error = read_page(swp_offset(pmdisk_header.pmdisk_info),
&pmdisk_info)))
return error;
/* Is this same machine? */
if ((reason = sanity_check())) {
printk(KERN_ERR "pmdisk: Resume mismatch: %s\n",reason);
return -EPERM;
}
pmdisk_pages = pmdisk_info.image_pages;
return error;
}
long eprom24x_io::read(uint32_t addr, void *data, uint16_t len)
{
try {
// Lockdown the read operation
pthread_mutex_lock(&m_rw_mutex);
// Check that there is enough room for data on chip
check_valid_access(addr, len);
// All chips support sequential read using pages
read_page(addr, (uint8_t *)data, len);
pthread_mutex_unlock(&m_rw_mutex);
return EPROM24x_SUCCESS;
}
catch (...) {
pthread_mutex_unlock(&m_rw_mutex);
throw;
}
}
static int usb_read_flash_pages(struct bladerf *dev, uint8_t *buf,
uint32_t page_u32, uint32_t count_u32)
{
int status;
size_t n_read;
uint16_t i;
/* 16-bit control transfer fields are used for these.
* The current bladeRF build only has a 4MiB flash, anyway. */
const uint16_t page = (uint16_t) page_u32;
const uint16_t count = (uint16_t) count_u32;
assert(page == page_u32);
assert(count == count_u32);
status = change_setting(dev, USB_IF_SPI_FLASH);
if (status != 0) {
return status;
}
log_info("Reading %u pages starting at page %u\n", count, page);
for (n_read = i = 0; i < count; i++) {
log_info("Reading page %u%c", page + i, (i+1) == count ? '\n':'\r' );
status = read_page(dev, BLADE_USB_CMD_FLASH_READ,
page + i, buf + n_read);
if (status != 0) {
goto error;
}
n_read += BLADERF_FLASH_PAGE_SIZE;
}
log_info("Done reading %u pages\n", count);
error:
status = restore_post_flash_setting(dev);
return status;
}
static int __init check_sig(void)
{
int error;
memset(&pmdisk_header,0,sizeof(pmdisk_header));
if ((error = read_page(0,&pmdisk_header)))
return error;
if (!memcmp(PMDISK_SIG,pmdisk_header.sig,10)) {
memcpy(pmdisk_header.sig,pmdisk_header.orig_sig,10);
/*
* Reset swap signature now.
*/
error = write_page(0,&pmdisk_header);
} else {
pr_debug(KERN_ERR "pmdisk: Invalid partition type.\n");
return -EINVAL;
}
if (!error)
pr_debug("pmdisk: Signature found, resuming\n");
return error;
}
static void
init_page(struct deluge_object *obj, int pagenum, int have)
{
struct deluge_page *page;
unsigned char buf[S_PAGE];
page = &obj->pages[pagenum];
page->flags = 0;
page->last_request = 0;
page->last_data = 0;
if(have) {
page->version = obj->version;
page->packet_set = ALL_PACKETS;
page->flags |= PAGE_COMPLETE;
read_page(obj, pagenum, buf);
page->crc = crc16_data(buf, S_PAGE, 0);
} else {
page->version = 0;
page->packet_set = 0;
}
}
