Subversion Repositories shark

/*
 * Project: HARTIK (HA-rd R-eal TI-me K-ernel)
 *
 * Coordinators: Giorgio Buttazzo <giorgio@sssup.it>
 *               Gerardo Lamastra <gerardo@sssup.it>
 *
 * Authors     : Massimiliano Giorgi <massy@hartik.sssup.it>
 * (see authors.txt for full list of hartik's authors)
 *
 * ReTiS Lab (Scuola Superiore S.Anna - Pisa - Italy)
 *
 * http://www.sssup.it
 * http://retis.sssup.it
 * http://hartik.sssup.it
 */

/*
 * Copyright (C) 1999 Massimiliano Giorgi
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */

/*
 * CVS :        $Id: msdos_i.c,v 1.1.1.1 2002-03-29 14:12:50 pj Exp $
 *
 * File:        $File$
 * Revision:    $Revision: 1.1.1.1 $
 * Last update: $Date: 2002-03-29 14:12:50 $
 */

#include <fs/types.h>
#include <fs/const.h>
#include <fs/stat.h>
#include <fs/assert.h>

#include "dcache.h"
#include "fs.h"
#include "msdos.h"
#include "msdos/msdos.h"

#include "debug.h"

/*
 * local DEBUG
 */

#define DEBUG_ADDCLUSTER KERN_DEBUG
#undef DEBUG_ADDCLUSTER KERN_DEBUG

#define DEBUG_ADDCLUSTER_EXTRA KERN_DEBUG
#undef DEBUG_ADDCLUSTER_EXTRA

/**/

#ifdef DEBUG_ADDCLUSTER
#define printd0(fmt,args...) \
        if (debug_info) printk(DEBUG_ADDCLUSTER fmt,##args)
#else
#define printd0(fmt,args...)
#endif

#if defined(DEBUG_ADDCLUSTER)&&defined(DEBUG_ADDCLUSTER_EXTRA)
#define printd1(fmt,args...) \
        if (debug_info) printk(DEBUG_ADDCLUSTER fmt,##args)
#else
#define printd1(fmt,args...)
#endif

/*
 *
 */
     
static char *chr2str(char*s, int n)
{
  static char str[13];
  _assert(n<13);
  memcpy(str,s,n);
  str[n]='\0';
  return str;
}

void msdos_dump_direntry(struct directoryentry *ptr)
{
  printk(KERN_DEBUG "status    : 0x%02x",(int)ptr->name[0]);
  printk(KERN_DEBUG "filename  : '%s'",chr2str(ptr->name,8));
  printk(KERN_DEBUG "ext       : '%s'",chr2str(ptr->ext,3));
  printk(KERN_DEBUG "attribute : 0x%02x",ptr->attribute);
  printk(KERN_DEBUG "cluster   : %04x",ptr->cluster);
  printk(KERN_DEBUG "size      : %li",(long)ptr->size);
  printk(KERN_DEBUG "time      : %li",(long)ptr->time);
}

/* what is the logical sector of a cluster into the fat */
static __inline __uint32_t __cluster2lsect(struct super_block *sb,
                                           __uint16_t cluster)
{
  return MSDOS_SB(sb).lfat+((__uint32_t)cluster*2)/SECTORSIZE;
}

/* what is the offset of a cluster into the fat */
static __inline __uint32_t __cluster2offs(__uint16_t cluster)
{
  return ((__uint32_t)cluster*2)%SECTORSIZE;
}

/**/

static __inline__ void __lock(struct super_block *sb,
                                dcache_t *buf[],
                                __uint32_t lsect)
{
  _assert(buf[0]==NULL);
  buf[0]=dcache_lock(sb->sb_dev,lsect);
}

static __inline__ void __unlock(struct super_block *sb,
                                dcache_t *buf[])
{
  _assert(buf[0]!=NULL);
  dcache_unlock(buf[0]);
  buf[0]=NULL;
}

static __inline__ void __acquire(struct super_block *sb,
                                dcache_t *buf[],
                                __uint32_t lsect)
{
  int i=0;
  _assert(buf[0]==NULL);
  _assert(MSDOS_SB(sb).nfat<=MAXFATS);
  for (i=0;i<MSDOS_SB(sb).nfat;i++) {
    buf[i]=dcache_acquire(sb->sb_dev,lsect);
    _assert(buf[i]!=NULL);
    lsect+=MSDOS_SB(sb).spf;
  }
}

static __inline__ void __release(struct super_block *sb,
                                dcache_t *buf[])
{
  int i;
  _assert(buf[0]!=NULL);
  for (i=MSDOS_SB(sb).nfat-1;i>=0;i--) {
    _assert(buf[i]!=NULL);
    dcache_release(buf[i]);
  }
  buf[0]=NULL;
}

static __inline__ __uint16_t __getcluster(struct super_block *sb,
                                          dcache_t *buf[],
                                          __uint16_t offs)
{
  _assert(buf[0]!=NULL);
  return *(__uint16_t*)(buf[0]->buffer+offs);  
}

static __inline__ void __setcluster(struct super_block *sb,
                                    dcache_t *buf[],
                                    __uint16_t offs,
                                    __uint16_t val)
{
  int i;
  _assert(buf[0]!=NULL);
  for (i=0;i<MSDOS_SB(sb).nfat;i++) {
    _assert(buf[i]!=NULL);
    *(__uint16_t*)(buf[i]->buffer+offs)=val;
    dcache_dirty(buf[i]);
    dcache_skipwt(buf[i]);
  }
}

/*
 *
 */

__uint16_t msdos_nextcluster(struct super_block *sb, __uint16_t cluster)
{
  dcache_t *buf[MAXFATS];
  __uint32_t lsect;
  __uint16_t  offs;
  __uint16_t  ret;

  buf[0]=NULL;
  lsect=__cluster2lsect(sb,cluster);
  offs=__cluster2offs(cluster);

  __lock(sb,buf,lsect);
  ret=__getcluster(sb,buf,offs);  
  __unlock(sb,buf);

  return ret;
}

void msdos_freecluster(struct super_block *sb, __uint16_t cluster)
{
  dcache_t   *buf[MAXFATS];
  __uint32_t lsect;
  __uint16_t offs;

  buf[0]=NULL;
  lsect=__cluster2lsect(sb,cluster);
  offs=__cluster2offs(cluster);
 
  __acquire(sb,buf,lsect);

  _assert(__getcluster(sb,buf,offs)!=FREECLUSTER);
  __setcluster(sb,buf,offs,FREECLUSTER);
 
  __release(sb,buf);
  return;
}

void msdos_lastcluster(struct super_block *sb, __uint16_t cluster)
{
  dcache_t   *buf[MAXFATS];
  __uint32_t lsect;
  __uint16_t offs;

  buf[0]=NULL;
  lsect=__cluster2lsect(sb,cluster);
  offs=__cluster2offs(cluster);
 
  __acquire(sb,buf,lsect);

  //_assert(__getcluster(sb,buf,offs)==FREECLUSTER);
  _assert(__getcluster(sb,buf,offs)!=LASTCLUSTER);
  __setcluster(sb,buf,offs,LASTCLUSTER);
 
  __release(sb,buf);
  return;
}

__uint16_t msdos_addcluster(struct super_block *sb, __uint16_t lacluster)
{
  dcache_t   *buf[MAXFATS];
  __uint32_t lsect;
  __uint16_t offs;
  __uint32_t olsect;
  __uint16_t cluster,stcluster;

  printd0("msdos_addcluster START");
 
  stcluster=cluster=MSDOS_SB(sb).stclust;  
  olsect=0;
  buf[0]=NULL;

  printd0("searching from cluster 0x%04lx",(long)stcluster);
 
  for (;;) {
    lsect=__cluster2lsect(sb,cluster);
    offs=__cluster2offs(cluster);

    if (lsect>=MSDOS_SB(sb).lroot) {
      cluster=STARTCLUSTER;
      lsect=__cluster2lsect(sb,cluster);
      offs=__cluster2offs(cluster);
      _assert(lsect<MSDOS_SB(sb).lroot);
    }
       
    if (lsect!=olsect) {
      if (buf[0]!=NULL) __release(sb,buf);
      __acquire(sb,buf,lsect);
      printd1("read sector %li",(long)lsect);
      olsect=lsect;
    }
   
    if (__getcluster(sb,buf,offs)==FREECLUSTER) {
      printd0("cluster 0x%04lx (into FAT lsect: %li) added to 0x%04lx",
              (long)cluster,(long)lsect,(long)lacluster);
      MSDOS_SB(sb).stclust=cluster;
      __setcluster(sb,buf,offs,LASTCLUSTER);

      /* if lacluster is not a cluster we do NOT change the FAT table!*/
      if (lacluster==NO_CLUSTER) break;
      __release(sb,buf);

      lsect=__cluster2lsect(sb,lacluster);
      offs=__cluster2offs(lacluster);
      __acquire(sb,buf,lsect);
      _assert(__getcluster(sb,buf,offs)==LASTCLUSTER);
      __setcluster(sb,buf,offs,cluster);
      break;
    }
   
    cluster++;
    if (cluster==stcluster) {
      cluster=NO_CLUSTER;
      break;
    }
  }  

  __release(sb,buf);
  printd0("msdos_addcluster END");
  return cluster;
}

void msdos_freeclusterchain(struct super_block *sb, __uint16_t cluster)
{
  dcache_t *buf[MAXFATS];
  __uint32_t  lsect;
  __uint16_t  offs;
  __uint32_t  olsect;

  buf[0]=NULL;
  olsect=0;
 
  for (;;) {
    lsect=__cluster2lsect(sb,cluster);
    offs=__cluster2offs(cluster);

    if (lsect!=olsect) {
      if (buf[0]!=NULL) __release(sb,buf);
      __acquire(sb,buf,lsect);
      olsect=lsect;
    }
   
    cluster=__getcluster(sb,buf,offs);
    _assert(cluster!=FREECLUSTER);
    __setcluster(sb,buf,offs,FREECLUSTER);

    if (cluster==LASTCLUSTER) break;
  }  

  __release(sb,buf);  
  return;
}

/*
 *
 */

/* from FS specific filename into 'de' to the general filename into 'str' */
int msdos_formatname(struct directoryentry *de, struct qstr *str)
{  
  char *s=str->name;
  char *ptr=de->name;
  int i;
 
  if (*ptr==0x05) *s++=0xed;
  else *s++=*ptr++;
  i=sizeof(de->name)-1;
  while (i-->0) {
    if (*ptr==' '||*ptr=='\0') break;
    *s++=*ptr++;
  }

  if (de->ext[0]!=' '&&de->ext[0]!='\0') {
    *s++='.';
    ptr=de->ext;
    i=sizeof(de->ext);
    while (i-->0) {
      if (*ptr==' '||*ptr=='\0') break;
      *s++=*ptr++;
    }
  }

  *s++='\0';
 
  str->nameptr=NULL;
  return 0;
}

/* all filename are traslated in upper case */
#define _up(x) (((x)>='a'&&(x)<='z')?(x)-'a'+'A':(x))

/* from the general filename into 'str' to FS specific filename into 'de' */
int msdos_deformatname(struct qstr *str,struct directoryentry *de)
{
  char *s=QSTRNAME(str);
  char *ptr=de->name;
  int i;

  memset(de->name,' ',sizeof(de->name));
  memset(de->ext,' ',sizeof(de->ext));
 
  i=0;
  for (i=0;i<sizeof(de->name);i++,s++,ptr++) {    
    if (*s=='.'||*s=='\0') break;
    *ptr=_up(*s);
  }
  if (*s=='\0') return 0;
 
  while (*s!='.') {
    if (*s=='\0') return 0;
    s++;
  }

  ptr=de->ext;
  s++;
  for (i=0;i<sizeof(de->name);i++,s++,ptr++) {    
    if (*s=='.'||*s=='\0') break;
    *ptr=_up(*s);
  }

 
  return 0;
}

static int msdos_dummy_truncate(struct inode *in, __off_t len)
{
  return -1;
}

static int msdos_truncate(struct inode *in, __off_t len)
{
  int numclusters;
  int cl,pcl;
 
  if (len>=in->i_st.st_size) return 0;

  if (len==0) {
    msdos_freeclusterchain(in->i_sb,MSDOS_I(in).scluster);
    MSDOS_I(in).scluster=FREE_CLUSTER;
    in->i_st.st_size=0;
    in->i_dirty=1;
    return 0;
  }
 
  numclusters=(len-1)/(MSDOS_SB(in->i_sb).spc*(long)SECTORSIZE)+1;

  /* walk on cluster chain */
  pcl=-1;
  cl=MSDOS_I(in).scluster;  
  while (numclusters-->0) {
    pcl=cl;
    cl=msdos_nextcluster(in->i_sb,cl);
  }
  if (cl!=LASTCLUSTER) {
    _assert(pcl!=-1);
    msdos_lastcluster(in->i_sb,pcl);
    msdos_freeclusterchain(in->i_sb,cl);
  }
 
  in->i_st.st_size=len;
  in->i_dirty=1;
  return 0;
}

/* msdos_create_inode() and msdos_lockup() are very similar */
/* they should be share code */

static struct inode *msdos_create_inode(struct inode *in, struct dentry *den)
{
  struct inode *in2;
  struct directoryentry *de;
  dcache_t *buf;
  __uint32_t lsect;
  __uint16_t  ldisk;
  __uint16_t cluster,prevcluster;
  int flagroot;
  int spc;
  int i,j;
  int res;
 
  /* for safety ;-) */
  if (!__S_ISDIR(in->i_st.st_mode)) return NULL;

  flagroot=(((in->i_st.st_ino&CLUSTER_MASK)>>CLUSTER_SHIFT)==ROOT_CLUSTER);
  if (flagroot) {
    cluster=SPECIAL_CLUSTER;
    lsect=MSDOS_SB(in->i_sb).lroot;
    spc=MSDOS_SB(in->i_sb).rootsect;
  } else {
    cluster=MSDOS_I(in).scluster;
    lsect=msdos_cluster2sector(in,cluster);
    _assert(lsect!=(__uint32_t)-1);
    spc=MSDOS_SB(in->i_sb).spc;
  }

  printk1("msdos create inode: start directory scanning");
 
  ldisk=in->i_sb->sb_dev;
  /* for every cluster... */
  for (;;) {

    /* for every sectors... */
    for (j=0;j<spc;j++,lsect++) {
      buf=dcache_acquire(ldisk,lsect);

      printk1("msdos create inode: logical sector %li",(long)lsect);
     
      if (buf==NULL) {
        printk1("msdos create inode: can't read sector");
        return NULL;
      }
     
      /* for every directory entry... */
      de=(struct directoryentry *)(buf->buffer);
      for (i=0;i<SECTORSIZE/DIRENTRYSIZE;i++) {
       
        if (msdos_isfreeentry(de+i)) {
          printk1("msdos create inode: found free entry");
 
          in2=catch_inode();
          printk1("-------------------");        
          if (in2==NULL) {
            printk1("msdos create inode: can't get free inode!");
            dcache_release(buf);
            return NULL;           
          }
         
          in2->i_sb=in->i_sb;
          in2->i_st.st_ino=CLUOFF2INODE(cluster,j*SECTORSIZE/DIRENTRYSIZE+i);
          res=in2->i_sb->sb_op->init_inode(in2);
          if (res!=0) {
            printk1("msdos create inode: can't init inode!");
            free_inode(in2);
            dcache_release(buf);
            return NULL;    
          }
         
          msdos_markentrybusy(de+i);
          msdos_deformatname(&den->d_name,de+i);
          dcache_dirty(buf);
         
          dcache_release(buf);
          return in2;
        }
       
      } /* end directory entry loop */
 
      dcache_release(buf);

      printk1("msdos create inode: next sector");
     
    } /* end sector loop */
   
    if (flagroot) {
      printk1("msdos create inode : no free slot (can't add one)");
      return NULL;
    }
   
    cluster=msdos_nextcluster(in->i_sb,prevcluster=cluster);
    if (cluster==LASTCLUSTER) {
      printk1("msdos create inode: no free slot (try to add one)");

      cluster=msdos_addcluster(in->i_sb,prevcluster);
      if (cluster==NO_CLUSTER) {
        printk1("msdos create inode: can't add cluster");
        return NULL;
      }

      /* zeroing the new cluster */
      lsect=msdos_cluster2sector(in,cluster);
      _assert(lsect!=(__uint32_t)-1);
      for (j=0;j<spc;j++,lsect++) {
        buf=dcache_acquire(ldisk,lsect);
        _assert(buf!=NULL);
        memset(buf->buffer,0,SECTORSIZE);
        dcache_dirty(buf);
        dcache_release(buf);
      }
     
      printk1("msdos create inode: added cluster");
     
    }
    lsect=msdos_cluster2sector(in,cluster);
    _assert(lsect!=(__uint32_t)-1);

    printk1("msdos create inode: next cluster");
   
  } /* end cluster loop */
 
}

static struct inode *msdos_lookup(struct inode *in, struct dentry *den)
{
  struct inode *in2;
  struct directoryentry *de;
  struct qstr str;
  dcache_t *buf;
  __uint32_t lsect;
  __uint16_t  ldisk;
  __uint16_t cluster;
  int flagroot;
  int spc;
  int i,j;
  int res;

  printk1("msdos lookup: START for %s",QSTRNAME(&(den->d_name)));
 
  /* for safety ;-) */
  if (!__S_ISDIR(in->i_st.st_mode)) return NULL;

  printk1("msdos lookup: is directory... ok");
 
  flagroot=(((in->i_st.st_ino&CLUSTER_MASK)>>CLUSTER_SHIFT)==ROOT_CLUSTER);
  if (flagroot) {
    cluster=SPECIAL_CLUSTER;
    lsect=MSDOS_SB(in->i_sb).lroot;
    spc=MSDOS_SB(in->i_sb).rootsect;
  } else {
    cluster=MSDOS_I(in).scluster;
    lsect=msdos_cluster2sector(in,cluster);
    _assert(lsect!=(__uint32_t)-1);
    spc=MSDOS_SB(in->i_sb).spc;
  }

  printk1("msdos lookup: start directory scanning");
 
  ldisk=in->i_sb->sb_dev;
  /* for every cluster... */
  for (;;) {

    /* for every sectors... */
    for (j=0;j<spc;j++,lsect++) {
      buf=dcache_lock(ldisk,lsect);

      printk1("msdos lookup: logical sector %li",(long)lsect);
     
      if (buf==NULL) {
        printk1("msdos lookup: can't read sector");
        return NULL;
      }
     
      /* for every directory entry... */
      de=(struct directoryentry *)(buf->buffer);
      for (i=0;i<SECTORSIZE/DIRENTRYSIZE;i++) {
        if (msdos_islastentry(de+i)) {
          /* last entry... not found! */
          dcache_unlock(buf);
          printk1("msdos lookup: NOT found");
          return NULL;
        }

        /* if it' an invalid entry (not a regular file or directory entry) */
        if (msdos_isunvalidentry(de+i)) continue;
       
        /* extract name */
        res=msdos_formatname(de+i,&str);
        if (res!=0) {
          dcache_unlock(buf);
          printk1("msdos lookup: can't extract filename");
          return NULL;
        }

        printk1e("msdos lookup: filename '%s'",QSTRNAME(&str));
       
        /* compare name and if found... */
        if (den->d_op->d_compare(den,&den->d_name,&str)==0) {

          printk1("msdos lookup: found");        
          in2=catch_inode();
          printk1("-------------------");
         
          if (in2==NULL) {
            printk1("msdos lookup: can't get free inode!");
            dcache_unlock(buf);
            return NULL;    
          }
          in2->i_sb=in->i_sb;
          in2->i_st.st_ino=CLUOFF2INODE(cluster,j*SECTORSIZE/DIRENTRYSIZE+i);
          res=in2->i_sb->sb_op->read_inode(in2);
          if (res!=0) {
            printk1("msdos lookup: can't read inode!");
            free_inode(in2);
            dcache_unlock(buf);
            return NULL;    
          }

          dcache_unlock(buf);
          return in2;
        }
       
      } /* end directory entry loop */
 
      dcache_unlock(buf);
      printk1("msdos lookup: next sector");
     
    } /* end sector loop */
   
    if (flagroot) {
      printk1("msdos lookup: NOT found (no other entry into root dir)");
      return NULL;
    }
   
    cluster=msdos_nextcluster(in->i_sb,cluster);
    if (cluster==0||cluster>=0xfff0) {
      printk1("msdos lookup: NOT found (end cluster)");  
      return NULL;
    }
    lsect=msdos_cluster2sector(in,cluster);
    _assert(lsect!=(__uint32_t)-1);

    printk1("msdos lookup: next cluster");
   
  } /* end cluster loop */
 
}

static int msdos_dummy_unlink(struct dentry *d)
{
  return EROFS;
}

static int msdos_unlink(struct dentry *d)
{
  printkd("msdos_unlink: START");
 
  /* only one dentry can own this inode... */
  _assert(d->d_inode->i_dlink==1);

  /* nothing to do */

  /* update link count */
  d->d_inode->i_st.st_nlink--;
  _assert(d->d_inode->i_st.st_nlink==0);
 
  printkd("msdos_unlink: END");
  return 0;  
}

static void msdos_destroy(struct inode *in)
{
  msdos_truncate(in,0);
  return;
}

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

struct inode_operations msdos_inode_ro_operations={
  &msdos_file_ro_operations,
  msdos_create_inode,
  msdos_lookup,
  msdos_dummy_unlink,
  msdos_destroy,
  msdos_dummy_truncate
};

struct inode_operations msdos_inode_rw_operations={
  &msdos_file_rw_operations,
  msdos_create_inode,
  msdos_lookup,
  msdos_unlink,
  msdos_destroy,
  msdos_truncate
};


/*
 *
 * for inlines
 *
 */

int msdos_islastentry(struct directoryentry *de)
{
  return (*((de)->name)==LASTENTRYCHAR);
}

int msdos_isunvalidentry(struct directoryentry *de)
{
  return (*((de)->name)==ERASEDENTRYCHAR)||
    ((de)->attribute&ATTR_VOLUME)||
    (msdos_islastentry(de));
}