Subversion Repositories shark

/*

 *

 *

 *

 *

 */

#include <fs/maccess.h>

#include <fs/util.h>

#include <fs/errno.h>

#include <fs/stat.h>

#include <fs/dirent.h>

#include <fs/fcntl.h>

#include "dcache.h"

#include "fs.h"

#include "msdos.h"

#include "fsconst.h"

#include "file.h"

#include "fileop.h"

#include "msdos/msdos_f.h"

#include "debug.h"

/* debug __position() */

#define DEBUG_POSITION KERN_DEBUG

#undef DEBUG_POSITION

/* debug __increase() */

#define DEBUG_INCREASE KERN_DEBUG

#undef DEBUG_INCREASE

/*

 *

 */

#ifdef DEBUG_POSITION

#define printk3a(fmt,args...) \

        if (debug_info) printk(DEBUG_POSITION fmt,##args)

#else

#define printk3a(fmt,args...)

#endif

#ifdef DEBUG_INCREASE

#define _printk1(fmt,args...) \

        if (debug_info) printk(DEBUG_INCREASE fmt,##args)

#else

#define _printk1(fmt,args...)

#endif

static inline void startoffile(struct inode *in, struct file *f)

{

  MSDOS_F(f).cluster=MSDOS_I(in).scluster;

  MSDOS_F(f).bakcluster=NO_CLUSTER;

  MSDOS_F(f).lsector=msdos_cluster2sector(in,MSDOS_F(f).cluster);

  if (MSDOS_F(f).cluster!=FREE_CLUSTER)

    _assert(MSDOS_F(f).lsector!=(__uint32_t)-1);

  MSDOS_F(f).sectnum=0;

  MSDOS_F(f).bpos=0;

}

/*

 *

 *

 */

static int msdos_open(struct inode *in, struct file *f)

{

  startoffile(in,f);

  f->f_pos=0;

  printk0("msdos_open: starting (cluster 0x%lx) (lsect %li)",

          (long)MSDOS_I(in).scluster,

          (long)MSDOS_F(f).lsector);

  return EOK;

}

static void __position(struct file *f,__off_t pos)

{

  struct inode *in=f->f_dentry->d_inode;

  struct super_block *sb=f->f_dentry->d_sb;

  __uint32_t nc;

  /* it can be optimized:

   * if the new position is after the actual position we

   * can not go thought all the file list chain

   */

  /* from 0 (start-of-file) to in->i_st.st_size (end-of-file) */

  _assert(pos>=0&&pos<=in->i_st.st_size);

  /* remeber that f->f_pos is the position (in bytes) of the next

   * bytes to read/write

   * so

   * if we are at end-of-file the bytes is not into the file

   */

  printk3a("__position: START");

  f->f_pos=pos;

  startoffile(in,f);

  nc=pos/(MSDOS_SB(sb).spc*SECTORSIZE);  /* number of cluster to skip */

  pos-=nc*(MSDOS_SB(sb).spc*SECTORSIZE);

  printk3a("__position: cluster to skip %li",(long)nc);

  printk3a("__position: position into cluster %li",(long)pos);

  /* very good :-( I must go thought the list chain! */

  while (nc>0) {

    MSDOS_F(f).bakcluster=MSDOS_F(f).cluster;

    MSDOS_F(f).cluster=msdos_nextcluster(sb,MSDOS_F(f).cluster);

    nc--;

  }

  MSDOS_F(f).sectnum=pos/SECTORSIZE;

  pos-=MSDOS_F(f).sectnum*SECTORSIZE;

  printk3a("__position: sector number %i",MSDOS_F(f).sectnum);

  MSDOS_F(f).lsector=msdos_cluster2sector(in,MSDOS_F(f).cluster);

  _assert(MSDOS_F(f).lsector!=(__uint32_t)-1);

  MSDOS_F(f).lsector+=MSDOS_F(f).sectnum;

  MSDOS_F(f).bpos=pos;

  printk3a("__position: position into sector %li",(long)pos);

  printk3a("__position: logical sector %li",(long)MSDOS_F(f).lsector);

  printk3a("__position: END");

}

static __off_t msdos_lseek(struct file *f, __off_t off, int whence)

{

  struct inode *in=f->f_dentry->d_inode;

  __off_t   pos;

  /* da fare il test sulla fine cluster!!!! */

  printk3("msdos_lseek: START");

  printk3("msdos_lseek: current position %li",(long)f->f_pos);  

  switch (whence) {

    case SEEK_SET: pos=off; break;

    case SEEK_CUR: pos=f->f_pos+off; break;

    case SEEK_END: pos=in->i_st.st_size+off; break;

    default:

      printk3("msdos_lseek: END");

      return -EINVAL;

  }

  printk3("msdos_lseek: next position %li",(long)pos);

  if (pos<0) {

    printk3("msdos_lseek: out of position range");

    printk3("msdos_lseek: END");

    return -ESPIPE; /* it is "illegal seek" */

  }

  f->f_pos=pos;

  if (f->f_pos>in->i_st.st_size) {

    printk3("msdos_lseek: after end-of-file");

    printk3("msdos_lseek: END");

    return f->f_pos;

  }

  __position(f,pos);

  printk3("msdos_lseek: END");

  return f->f_pos;  

}

static int msdos_close(struct inode *in, struct file *f)

{

  return EOK;

}

/* --- */

/* advance the file pointer by sz bytes */

/* PS: sz must NOT cross sectors (see msdos_read())*/

static void __inline__ __advance(struct file *f,

                               struct super_block *sb,

                               struct inode *in,

                               int sz)

{

  f->f_pos+=sz;

  if (sz==SECTORSIZE-MSDOS_F(f).bpos) {

    MSDOS_F(f).bpos=0;

    MSDOS_F(f).lsector++;

    MSDOS_F(f).sectnum++;

    if (MSDOS_I(in).scluster==ROOT_CLUSTER) return;

    if (MSDOS_F(f).sectnum==MSDOS_SB(sb).spc) {

      MSDOS_F(f).sectnum=0;

      //printk(KERN_DEBUG "act cluster 0x%04li",(long)MSDOS_F(f).cluster);

      MSDOS_F(f).bakcluster=MSDOS_F(f).cluster;

      MSDOS_F(f).cluster=msdos_nextcluster(sb,MSDOS_F(f).cluster);

      if (MSDOS_F(f).cluster!=NO_CLUSTER) {

        MSDOS_F(f).lsector=msdos_cluster2sector(in,MSDOS_F(f).cluster);

        _assert(MSDOS_F(f).lsector!=(__uint32_t)-1);

      }

      //printk(KERN_DEBUG "new cluster 0x%04li",(long)MSDOS_F(f).cluster);

    }

  } else {

    MSDOS_F(f).bpos+=sz;

  }

}

/* increase the file size by delta (we must be on end-of-file) */

static __ssize_t __inline__ __increase(struct file *f,

                               struct super_block *sb,

                               struct inode *in,

                               __ssize_t delta)

{

  __uint16_t scluster,cluster;

  __ssize_t l;

  long i,n;

  _printk1("__increase: START");

  _printk1("__increase: clusters act:0x%04x bak:0x%04x",

           MSDOS_F(f).cluster,MSDOS_F(f).bakcluster);

  /*

   * MSDOS_F(f).bakcluster contains the previous cluster of the actual

   * file position;

   * it is used only into when MSDOS_F(f).cluster==NO_CLUSTER

   * (we are at end-of-file of a file that is multiple of a cluster)

   */

  _assert(delta!=0);

  if (MSDOS_I(in).scluster==ROOT_CLUSTER) return 0;

  if (MSDOS_F(f).cluster==FREE_CLUSTER) {

    /* we must allocate a cluster */

    /* we do not have any cluster in this chain! */

    _printk1("__increase: free cluster");

    MSDOS_F(f).cluster=msdos_addcluster(sb,NO_CLUSTER);

    if (MSDOS_F(f).cluster==NO_CLUSTER) return 0;

    MSDOS_F(f).lsector=msdos_cluster2sector(in,MSDOS_F(f).cluster);    

    _assert(MSDOS_F(f).lsector!=(__uint32_t)-1);

    MSDOS_I(in).scluster=MSDOS_F(f).cluster;

    in->i_dirty=1;

  }

  if (MSDOS_F(f).cluster==NO_CLUSTER) {

    /* we must allocate a cluster */

    /* we are at end-of-file on a cluster boundary! */

    _printk1("__increase: no cluster");    

    _assert(MSDOS_F(f).bakcluster!=NO_CLUSTER);

    MSDOS_F(f).cluster=msdos_addcluster(sb,MSDOS_F(f).bakcluster);

    if (MSDOS_F(f).cluster==NO_CLUSTER) return 0;

    MSDOS_F(f).lsector=msdos_cluster2sector(in,MSDOS_F(f).cluster);

    _assert(MSDOS_F(f).lsector!=(__uint32_t)-1);

  }

  _printk1("__increase: compute space available");

  /* space available (to the end of cluster) */

  l=((__ssize_t)MSDOS_SB(sb).spc-(__ssize_t)MSDOS_F(f).sectnum-1)*SECTORSIZE;

  l+=(SECTORSIZE-(__ssize_t)MSDOS_F(f).bpos);

  if ((long)delta-(long)l>0) {

    /* some other clusters needed */

    n=(delta-l)/(SECTORSIZE*MSDOS_SB(sb).spc)+1;

    scluster=cluster=MSDOS_F(f).cluster;

    _printk1("__increase: other clusters needed");

    for (i=0;i<n;i++) {

      _printk1("__increase: added cluster from 0x%04x",cluster);

      cluster=msdos_addcluster(sb,cluster);

      if (cluster==NO_CLUSTER) {

        /* we shall allow an allocation lesser than requested */

        delta=l+i*SECTORSIZE*MSDOS_SB(sb).spc;

        break;

      }

    }

  }

  if (delta>0) {

    _printk1("__increase: delta>0 => dirty inode");    

    in->i_st.st_size+=delta;

    in->i_dirty=1;

  }

  _printk1("__increase: END");

  return delta;

}

/*

 *

 */

static __ssize_t msdos_read(struct file *f, char *p, __ssize_t d)

{

  struct inode *in=f->f_dentry->d_inode;

  struct super_block *sb=f->f_dentry->d_sb;

  dcache_t *buf;

  int sz;

  __ssize_t bc;

  //printk(KERN_DEBUG "reading %i bytes from position %li",d,(long)f->f_pos);

  if (d==0) return 0;

  /* if we are at or after the end-of-file */

  if (f->f_pos>=in->i_st.st_size) return 0;

  bc=0;

  while (bc<d&&in->i_st.st_size>f->f_pos) {

    buf=dcache_lock(sb->sb_dev,MSDOS_F(f).lsector);

    if (buf==NULL) return -EIO;

    sz=min(d-bc,SECTORSIZE-MSDOS_F(f).bpos);

    sz=min(sz,in->i_st.st_size-f->f_pos);

    memcpytouser(p,buf->buffer+MSDOS_F(f).bpos,sz);

    dcache_unlock(buf);

    p+=sz;    

    bc+=sz;

    __advance(f,sb,in,sz);    

  }

  return bc;

}

static __ssize_t msdos_write(struct file *f, char *p, __ssize_t d)

{

  struct inode *in=f->f_dentry->d_inode;

  struct super_block *sb=f->f_dentry->d_sb;

  dcache_t *buf;

  int sz;

  __ssize_t bc;

  //printk(KERN_DEBUG "writing %i bytes from position %li",d,(long)f->f_pos);

  if (d==0) return 0;

  /* O_APPEND flag - test for safety */

  /*

  if (f->f_flags&O_APPEND)

    if (f->f_pos!=in->i_st.st_size) {

      __position(f,in->i_st.st_size);      

    }

  */

  if (f->f_pos>in->i_st.st_size) {

    /* lseek() has moved the file position AFTER the end of file !!*/

    __ssize_t inc,delta;

    //printk(KERN_DEBUG "lseek() after end of file!");

    delta=f->f_pos-in->i_st.st_size;

    __position(f,in->i_st.st_size);

    inc=__increase(f,sb,in,delta);

    if (inc!=delta) return -EIO;

    bc=0;

    while (bc<delta) {

      buf=dcache_acquire(sb->sb_dev,MSDOS_F(f).lsector);    

      if (buf==NULL) return -EIO;

      dcache_dirty(buf);

      sz=min(delta-bc,SECTORSIZE-MSDOS_F(f).bpos);

      sz=min(sz,in->i_st.st_size-f->f_pos);

      memset(buf->buffer+MSDOS_F(f).bpos,0,sz);

      dcache_release(buf);

      bc+=sz;

      __advance(f,sb,in,sz);    

    }

  }

  /*

  printk(KERN_DEBUG "pos: %li d: %li act size: %li",

         (long)f->f_pos,(long)d,(long)in->i_st.st_size);

  */

  if (f->f_pos+d>in->i_st.st_size) {

    /* no room for the data that must be written */

    __ssize_t inc;

    //printk(KERN_DEBUG "increase request" );

    inc=__increase(f,sb,in,f->f_pos+d-in->i_st.st_size);

    if (inc==0) return -EIO;

    d=inc+in->i_st.st_size-f->f_pos;

    //printk(KERN_DEBUG "new size: %li",(long)in->i_st.st_size);

  }

  //printk(KERN_DEBUG "init writing");

  bc=0;

  while (bc<d&&in->i_st.st_size>f->f_pos) {

    buf=dcache_acquire(sb->sb_dev,MSDOS_F(f).lsector);

    if (buf==NULL) {

      //printk(KERN_DEBUG "can't aquire!");

      return -EIO;

    }    

    //printk(KERN_DEBUG "write on %li",MSDOS_F(f).lsector);        

    dcache_dirty(buf);

    sz=min(d-bc,SECTORSIZE-MSDOS_F(f).bpos);

    sz=min(sz,in->i_st.st_size-f->f_pos);

    memcpyfromuser(buf->buffer+MSDOS_F(f).bpos,p,sz);

    dcache_release(buf);

    p+=sz;    

    bc+=sz;

    __advance(f,sb,in,sz);    

  }

  return bc;

}

#ifdef DEBUG_READDIR_DUMP

#define dump_directory_entry(ptr) msdos_dump_direntry(ptr)

#else

#define dump_directory_entry(ptr)

#endif

//int startcounter=0;

//int counter;

static int msdos_readdir(struct file *f, void *den)

{

  struct super_block *sb=f->f_dentry->d_sb;

  struct inode *in=f->f_dentry->d_inode;

  struct directoryentry *de;

  struct dirent ude;

  dcache_t *buf=NULL;

  struct qstr name;

  __uint32_t lsect;

  int res;

  //debug_check_mutex(__FILE__,__LINE__,501);

  printk5("msdos_readdir: START");

  if (MSDOS_F(f).cluster==NO_CLUSTER) {

    printk5("msdos_readdir: end of cluster (no more entries)");

    printk5("msdos_readdir: END");

    return 1;

  }

  lsect=-1;

  for (;;) {

    if (MSDOS_F(f).lsector!=lsect) {

      if (lsect!=-1) dcache_unlock(buf);

      buf=dcache_lock(sb->sb_dev,MSDOS_F(f).lsector);

      if (buf==NULL) {

        //printk(KERN_ERR "msdos_readdir: can't lock sector %li",

        //       (long)MSDOS_F(f).lsector);

        printk5("msdos_readdir: END");

        return -EIO;

      }

      lsect=MSDOS_F(f).lsector;

      printk5("msdos_readdir: read %li logical sector",(long int)lsect);

    }

    de=(struct directoryentry *)(buf->buffer+MSDOS_F(f).bpos);

    dump_directory_entry(de);

    /*

      for debug purpose

    if (startcounter) {

      if (--counter==0) return 1;

    } else

    if (msdos_islastentry(de)) {

      startcounter=1;

      counter=1;

    }

    */

    if (msdos_islastentry(de)) {

      printk5("msdos_readdir: last entry found");

      printk5("msdos_readdir: END");

      // *(int*)&ude=0;

      dcache_unlock(buf);

      return 1;      

    }

    __advance(f,sb,in,sizeof(struct directoryentry));

    if (!msdos_isunvalidentry(de)) {

      res=msdos_formatname(de,&name);

      /* there's no need to check for result, but in future... */      

      if (res!=0) {

        printk5("msdos_readdir: entry found BUT can't format the name");

        printk5("msdos_readdir: END");

        dcache_unlock(buf);

        return -EIO;

      }

      strcpy(ude.d_name,QSTRNAME(&name));

      printk5("msdos_readdir: entry found '%s'",ude.d_name);

      break;

    }

    printk5("msdos_readdir: invalid entry found");

  }

  dcache_unlock(buf);

  __copy_to_user(den,&ude,sizeof(struct dirent));

  printk5("msdos_readdir: END");

  return EOK;

}

/*--------*/

struct file_operations msdos_file_ro_operations={

  msdos_lseek,

  msdos_read,

  dummy_write,

  msdos_readdir,

  msdos_open,

  msdos_close

};

struct file_operations msdos_file_rw_operations={

  msdos_lseek,

  msdos_read,

  msdos_write,

  msdos_readdir,

  msdos_open,

  msdos_close

};