Subversion Repositories shark

/*

 *

 *

 *

 *

 */

#include "config.h"

#include <ll/i386/cons.h>

#include <kernel/func.h>

#include <kernel/int_sem.h>

#define seminit(s,v) internal_sem_init(s,v)

#define semwait(s)   internal_sem_wait(s)

#define semsignal(s) internal_sem_post(s)

#include <stdio.h>

#include <stdlib.h>

#include <unistd.h>

#include <assert.h>

#include "xread.h"

/**/

/*

 */

#ifndef ACTIVATE

int x_fseek(FILE *file, long where, int from)

{

  return fseek(file,where,from);

}

size_t x_fread(void *buffer, size_t size, size_t n, FILE *file)

{

  return fread(buffer,size,n,file);

}

void x_init(void)

{}

int x_initbuffer(int group, FILE *f, int rate, int band)

{

  return XUNUSEDPID;

}

#endif

#ifdef ACTIVATE

int x_fseek(FILE *file, long where, int from)

{

  return -1;

}

#define BLOCKSIZE (512*4)

#define BLOCKSPERBUFFER (BUFFERMAXSIZE/BLOCKSIZE)

/* in millisecondi */

#define PRELOAD 500

struct xbuffer *table[OPEN_MAX];

int end_counter=0;

static TASK bufferfiller(void *arg)

{

  struct xbuffer *ptr=(struct xbuffer *)arg;

  int n;

  for (;;) {

    if (freespace(ptr)>BLOCKSIZE+8) {

      //assert(ptr->writeptr>=0);

      //assert(ptr->writeptr+BLOCKSIZE<=BUFFERMAXSIZE);

      n=read(ptr->handle,ptr->buffer+ptr->writeptr,BLOCKSIZE);

#ifdef NOGRX

      cprintf("²");

#endif

      kern_cli();

      ptr->writeptr+=n;

      /* ipotesi: non si legge mai piu' di BUFFERMAXSIZE */

      if (ptr->writeptr>=BUFFERMAXSIZE) ptr->writeptr-=BUFFERMAXSIZE;

      kern_sti();

      if (n!=BLOCKSIZE) {

        //cprintf("<XXX>");     

        break;

      }

      //assert(ptr->writeptr%512==0);      

    }

    task_endcycle();

  }

  end_counter++;

  return NULL;

}

void x_init(void)

{

  int i;

  for (i=0;i<OPEN_MAX;i++) table[i]=NULL;

}

/* rate in bits/sec */

/* band in percentuale *100 */

int x_initbuffer(int group, FILE *f, int rate, int band)

{

#ifdef EDFSCHED

  BDEDF_RES_MODEL resource;

#endif

#ifdef PSCANSCHED

  BDPSCAN_RES_MODEL resource;

#endif

  SOFT_TASK_MODEL model;

  struct xbuffer *ptr;

  int handle;

  int period,wcet;

  int n,preload;

  PID pid;

  handle=fileno(f);

  if (handle>OPEN_MAX||handle<0) return -11;

  if (table[handle]!=NULL) return -2;

  ptr=table[handle]=(struct xbuffer *)malloc(sizeof(struct xbuffer));

  if (ptr==NULL) return -3;

  ptr->handle=handle;

  ptr->writeptr=ptr->readptr=0;

  n=lseek(ptr->handle,0,SEEK_SET);

  if (n!=0) {

    cprintf("can't seek to 0\n");

    return -12;

  }

  /* PRELOAD */

  preload=rate*PRELOAD/8/1000;

  if (preload<100*1024) preload=100*1024;

  preload=(preload/BLOCKSIZE+1)*BLOCKSIZE;

  if (preload>BUFFERMAXSIZE-BLOCKSIZE) return -4;  

  n=read(ptr->handle,ptr->buffer,preload);

  if (n!=preload) {

    cprintf("preload: request %li bytes (%li returned)\n",

            (long)preload,(long)n);

    return -5;

  }

  ptr->writeptr+=n;

  //cprintf("%li bytes preloaded\n",(long)n);

  if (rate==0) sys_abort(997);

  period=1000000l*BLOCKSIZE/rate*8;

  wcet=period*band/10000;

  soft_task_default_model(model);    

  soft_task_def_met(model,wcet);

  soft_task_def_wcet(model,wcet);

  soft_task_def_period(model,period);  

  soft_task_def_periodic(model);

  soft_task_def_arg(model,(void*)ptr);

  soft_task_def_group(model,group);

#if defined(EDFSCHED)

  BDEDF_res_default_model(resource);

  BDEDF_res_def_dl(resource,period);

  pid=task_createn("xfill", bufferfiller,(TASK_MODEL*)&model, &resource, NULL);

#elif defined(PSCANSCHED)

  BDPSCAN_res_default_model(resource);

  BDPSCAN_res_def_priority(resource,0);

  pid=task_createn("xfill", bufferfiller,(TASK_MODEL*)&model, &resource, NULL);

#else

  pid=task_create("xfill", bufferfiller, &model, NULL);

#endif

  if (pid!=-1) {

    cprintf("task wcet=%10li period=%10li\n",(long)wcet,(long)period);

  }

  return pid;

}

size_t x_fread(void *buffer, size_t objsize, size_t n, FILE *file)

{

  struct xbuffer *ptr;

  int size,sz;

  int nv;

  ptr=table[fileno(file)];

  if (ptr==NULL) {

    cprintf("x_fread with bad fd\n");

    return 0;

  }

  size=objsize*n;

  //cprintf("[for %i]",size);

REDO:

  if (filledspace(ptr)<size) {

    /*

    cprintf("x_fread called for %li bytes (%li available)\n",

            (long)size,

            (long)filledspace(ptr));

    */

    nv=n;

    n=filledspace(ptr)/objsize;

    if (n==0) {

      struct timespec delay;

      delay.tv_sec=0;

      delay.tv_nsec=15000000;

      n=nv;

      nanosleep(&delay, 0);

      goto REDO;

      return 0;

    }

    size=objsize*n;

    /*cprintf("%i will return\n",size);*/

  }

  sz=BUFFERMAXSIZE-ptr->readptr;

  if (sz>=size) {

    //cprintf("X");

    memcpy(buffer,ptr->buffer+ptr->readptr,size);

  } else {

    //cprintf("Y");

    memcpy(buffer,ptr->buffer+ptr->readptr,sz);

    assert(size-sz>0);

    memcpy(buffer+sz,ptr->buffer,size-sz);

  }

  kern_cli();

  ptr->readptr+=size;

  /* ipotesi: non si legge mai piu' di BUFFERMAXSIZE */

  if (ptr->readptr>=BUFFERMAXSIZE) ptr->readptr-=BUFFERMAXSIZE;

  kern_sti();

  return n;

}

#endif