Subversion Repositories shark

Rev

Blame | Last modification | View Log | RSS feed

/*
 * Project: S.Ha.R.K.
 *
 * Coordinators:
 *   Giorgio Buttazzo    <giorgio@sssup.it>
 *   Paolo Gai           <pj@gandalf.sssup.it>
 *
 * Authors     :
 *   Paolo Gai           <pj@gandalf.sssup.it>
 *   Massimiliano Giorgi <massy@gandalf.sssup.it>
 *   Luca Abeni          <luca@gandalf.sssup.it>
 *   (see the web pages for full authors list)
 *
 * ReTiS Lab (Scuola Superiore S.Anna - Pisa - Italy)
 *
 * http://www.sssup.it
 * http://retis.sssup.it
 * http://shark.sssup.it
 */



/***************************************

  CVS :        $Id: bdev.c,v 1.1.1.1 2002-03-29 14:12:49 pj Exp $
 
  Revision:    $Revision: 1.1.1.1 $

  Last update: $Date: 2002-03-29 14:12:49 $

  This module contains the block device manager: it export some functions
  to the rest of the kernel that are mapped to a real device driver
  sub-system.

***************************************/


/*
 * 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
 *
 */


#include "glue.h"
#include <fs/bdevconf.h>
#include <fs/bdev.h>
#include <fs/magic.h>
#include <fs/assert.h>
#include <fs/sysmacro.h>
#include <fs/bdevinit.h>
#include <fs/fsind.h>
//#include <fs/mutex.h>

#include "bdev.h"

/*+ Log Level to use +*/
#define BDEVLOG KERN_ERR

/*+ an entry for every block device +*/
static struct block_device bdev[MAXBLOCKDEVICE];

/*+ an index into bdev_minor +*/
int bdev_minor_index=0;

/*+ an entry for every block device minor number +*/
struct block_device_minor bdev_minor[MAXBLOCKDEVICEMINOR];

/*+ some operations must be done in mutual exclusion +*/
NOP_mutexattr_t        bdevdef_mutexattr=NOP_MUTEXATTR_INITIALIZER;
__b_mutex_t            mutex;
void                   *bmutexattr=NULL;
static BDEV_PARMS      defaultparms=BASE_BDEV;

/*++++++++++++++++++++++++++++++++++++++
 
  Initialize the block device manager and then initialize every
  block-device sub-system defined into bdevconf.h (Actualy it is
  impossible to load a module at run-time).

  int bdev_init
    return 0 on success, other value on error

  BDEV_PARMS *parms
    pointer to a structure that contains all device inizialization parameter
  ++++++++++++++++++++++++++++++++++++++*/


int bdev_init(BDEV_PARMS *parms)
{
  int i;

  if (parms==NULL) parms=&defaultparms;
 
  /* 'bmutexattr' initialization */
  bmutexattr=parms->bmutexattr;
  if (bmutexattr==NULL) bmutexattr=&bdevdef_mutexattr;
 
  /* initialize mutex */
  __b_mutex_init(&mutex);
 
  /* initialize the bdev[] table */
  for (i=0;i<MAXBLOCKDEVICE;i++) {    
    magic_set(bdev[i].magic,BLOCK_DEVICE_MAGIC);    
    bdev[i].bd_flag_used=0;
  }

  /* initialize the bdev_minor[] table */
  /*for (i=0;i<MAX*/
         
#ifdef IDE_BLOCK_DEVICE
  /* if requested initialize the IDE subsystem */
  ide_init(parms);
#endif

#ifdef LOOP_BLOCK_DEVICE
  /* if requested initialize the "loop device" subsystem */
  loop_init(parms);
#endif

  return 0;
}

/*++++++++++++++++++++++++++++++++++++++
 
  Every block device sub-system must call this function yo register
  itself to the device block manager.

  int bdev_register
    return 0 on success, -1 on failure

  __dev_t devmajor
    major block device number to register

  char *name
    the name of the device (must be a pointer to static data)

  struct block_device *dev
    information to hook the block device routine
  ++++++++++++++++++++++++++++++++++++++*/


int bdev_register(__dev_t devmajor, char *name, struct block_device *dev)
{
  __dev_t mj=major(devmajor);

  /* check for consistency */
  if (mj<=0||mj>=MAXBLOCKDEVICE) {
    printk(BDEVLOG "bdev: request to register invalid major %i",
           mj);
    return -1;
  }
  if (bdev[mj].bd_flag_used) {
    printk(BDEVLOG "bdev: requet to register used major %i",
           mj);
    return -1;
  }
  magic_assert(bdev[mj].magic,BLOCK_DEVICE_MAGIC,
               "bdev: device(%i,%i) overwritten prior to use",
               mj,minor(devmajor));

  /* register the device */
  memcpy(bdev+mj,dev,sizeof(struct block_device));
  bdev[mj].bd_flag_used=1;
  bdev[mj].bd_name=name;
  magic_set(bdev[mj].magic,BLOCK_DEVICE_MAGIC);
 
  return 0;
}

static __uint8_t part2sysind(__uint8_t par_ind)
{
  switch(par_ind) {
    case FSPAR_DOS12:
    case FSPAR_DOS16:
    case FSPAR_DOSBIG:
      return FS_MSDOS;
    case FSPAR_LNXNTV:
      return FS_EXT2;
  }
  return FS_DEFAULT;
}

/*++++++++++++++++++++++++++++++++++++++
 
  Every block device sub-system must call this function to register
  itself to the device block manager (these information are used by
  the devfs filesystem to export device name to the system in a
  POSIX fanshion).

  int bdev_register_minor
    return a minor index on success, <0 on failure

  __dev_t device
    block device to register

  char *name
    the name of the device

  __uint8_t fsind
    file system indicator (see fsind.h)
  ++++++++++++++++++++++++++++++++++++++*/


int bdev_register_minor(__dev_t device, char *name,__uint8_t fsind)
{
  /* checks for bad requests */
  if (bdev_minor_index==MAXBLOCKDEVICEMINOR) return -1;
  if (major(device)>MAXBLOCKDEVICE) return -2;
  if (!bdev[major(device)].bd_flag_used) return -3;

  /* register minor device */
  strncpy(bdev_minor[bdev_minor_index].bdm_name,name,MAXDEVICENAME);
  bdev_minor[bdev_minor_index].bdm_name[MAXDEVICENAME-1]='\0';
  bdev_minor[bdev_minor_index].bdm_device=device;
  bdev_minor[bdev_minor_index].bdm_fsind=part2sysind(fsind);
   
  return bdev_minor_index++;
}

/*++++++++++++++++++++++++++++++++++++++
 
  Find a device using its name.
 
  __dev_t bdev_find_byname
    return a device number on success, <0 on failure

  char *name
    the name of the device to find
  ++++++++++++++++++++++++++++++++++++++*/


__dev_t bdev_find_byname(char *name)
{
  char *s0,*s1,*s2;
  char saved;
  int i;

  /*
   * a name can be, for example, "/dev/ide/hda1";
   * after this code s0 is a pointer to "ide" (the major name) and s1 is
   * a pointer to "hda1" (the minor name)
   */

  s0=name;  
  s1=strchr(name,'/');
  if (s1==NULL) return -1;
  while ((s2=strchr(s1+1,'/'))!=NULL) {
    s0=s1+1;
    s1=s2;
  }
  saved=*s1;
  *s1++='\0';

  /* search for a device... */
  for (i=0;i<bdev_minor_index;i++)
    /* compare a minor name */
    if (!strcmp(s1,bdev_minor[i].bdm_name))
      /* compare a major name */
      if (!strcmp(bdev[major(bdev_minor[i].bdm_device)].bd_name,s0)) {
        *(s1-1)=saved;
        return bdev_minor[i].bdm_device;
      }
  *(s1-1)=saved;
  return -2;
}


/*++++++++++++++++++++++++++++++++++++++
 
  Find major and minor name using a device id (__dev_t).
 
  int bdev_findname
    return 0 on success; -1 on failure.
   
  __dev_t dev
    device identification

  char **major
    the major name is pointed here
   
  char **minor
    the minor name is pointed here
  ++++++++++++++++++++++++++++++++++++++*/


int bdev_findname(__dev_t dev, char **major,char **minor)
{
  int i;
 
  assertk(major!=NULL&&minor!=NULL);
 
  for (i=0;i<bdev_minor_index;i++)
    if (bdev_minor[i].bdm_device==dev) {
      *minor=bdev_minor[i].bdm_name;
      *major=bdev[major(dev)].bd_name;
      return 0;
    }

  return -1;
}

/*++++++++++++++++++++++++++++++++++++++
 
  Find a device using its file system indicator (the first device
  that use this file system).
 
  __dev_t bdev_find_byfs
    return a device number on success, <0 on failure

  __uint8_t fsind
    file system indicator
  ++++++++++++++++++++++++++++++++++++++*/


__dev_t bdev_find_byfs(__uint8_t fsind)
{
  int i;
  for (i=0;i<bdev_minor_index;i++)
    if (bdev_minor[i].bdm_fsind==fsind)
      return bdev_minor[i].bdm_device;         
  return -1;
}

/*++++++++++++++++++++++++++++++++++++++
 
  Scan all devices into the system: for every device found call
  the callback function, if it returns -1 continue scanning else
  the values passed is returned.
 
  __dev_t bdev_find_byfs
    return a device number on success, <0 on failure

  __uint8_t fsind
    file system indicator
  ++++++++++++++++++++++++++++++++++++++*/


int bdev_scan_devices(int(*callback)(__dev_t,__uint8_t))
{
  int res=0;
  int i;
 
  for (i=0;i<bdev_minor_index;i++) {
    res=callback(bdev_minor[i].bdm_device,
                 bdev_minor[i].bdm_fsind
                 );
    if (res!=-1) break;
  }
  return res;
}

//#ifndef NDEBUG

#include <fs/major.h>
extern int ide_dump_startsize(__dev_t, __blkcnt_t*, __blkcnt_t*);

void bdev_dump_names(void)
{
  int i;
  __blkcnt_t start,size;
 
  printk(KERN_INFO "block device names:");
  for (i=0;i<bdev_minor_index;i++) {
    start=size=0;
    if (major(bdev_minor[i].bdm_device)==MAJOR_B_IDE)
      ide_dump_startsize(bdev_minor[i].bdm_device,&start,&size);
    printk(KERN_INFO "    %s/%8s   %08x (start-%-8li size-%-8li sysind-%02x)",
           bdev[major(bdev_minor[i].bdm_device)].bd_name,
           bdev_minor[i].bdm_name,
           bdev_minor[i].bdm_device,
           (long int)start,(long int)size,
           bdev_minor[i].bdm_fsind         
           );
  }
 
}

void bdev_dump_status(void)
{
  int counter,i;
 
  printk(KERN_INFO "block device status:");
  printk(KERN_INFO "  registered devices:");
  for (counter=0,i=0;i<MAXBLOCKDEVICE;i++)
    if (bdev[i].bd_flag_used) {
      printk(KERN_INFO "    %s",bdev[i].bd_name);
      counter++;
    }  
  printk(KERN_INFO "  num. majors: %i",counter);
  printk(KERN_INFO "  num. minors: %i",bdev_minor_index);

#ifdef IDE_BLOCK_DEVICE
  ide_dump_status();
#endif
 
}

//#endif

/*++++++++++++++++++++++++++++++++++++++
 
  Try to lock a device.
  Locking a device means that the locking entity can do I/O on that
  device (no check is performed during I/O operations).
 
  int bdev_trylock
    return 1 on success, 0 on failure and, -1 on error
   
  __dev_t dev
    device to lock
  ++++++++++++++++++++++++++++++++++++++*/


int bdev_trylock(__dev_t dev)
{
  int res;

  magic_assert(bdev[major(dev)].magic,BLOCK_DEVICE_MAGIC,
               "bdev: device(%04x:%04x) overwritten",
               major(dev),minor(dev));

  if (!bdev[major(dev)].bd_flag_used) {
    printk(BDEVLOG "bdev: device(%04x:%04x) not registered",
           major(dev),minor(dev));       
    return -1;
  }
 
  __b_mutex_lock(&mutex);
  res=bdev[major(dev)].bd_op->_trylock(dev);
  __b_mutex_unlock(&mutex);
                                   
  return res;
}

/*++++++++++++++++++++++++++++++++++++++
 
  Try to unlock a device.
 
  int bdev_tryunlock
    return 1 on success, 0 on failure and, -1 on error
 
  __dev_t dev
    device to unlock
  ++++++++++++++++++++++++++++++++++++++*/


int bdev_tryunlock(__dev_t dev)
{
  int res;

  magic_assert(bdev[major(dev)].magic,BLOCK_DEVICE_MAGIC,
               "bdev: device(%04x:%04x) overwritten",
               major(dev),minor(dev));

  if (!bdev[major(dev)].bd_flag_used) {
    printk(BDEVLOG "bdev: device(%04x:%04x) not registered",
           major(dev),minor(dev));       
    return -1;
  }
 
  __b_mutex_lock(&mutex);
  res=bdev[major(dev)].bd_op->_tryunlock(dev);
  __b_mutex_unlock(&mutex);
                                   
  return res;
}

             
/*++++++++++++++++++++++++++++++++++++++
 
  The following function are used to "virtualize" the call of a function
  of a block device sub-system.
  Actually they are implemeted by function to perform some parameters
  check but they will be implemented by macro.
  +latex+ \\

  This function request to read a block number.

  int bdev_read
    return 0 on success, other value on error

  __dev_t dev
    device where to read from

  __blkcnt_t blocknum
    block number to read

  __uint8_t *buffer
    buffer for the readed data
  ++++++++++++++++++++++++++++++++++++++*/


int bdev_read(__dev_t dev, __blkcnt_t blocknum, __uint8_t *buffer)
{

  magic_assert(bdev[major(dev)].magic,BLOCK_DEVICE_MAGIC,
               "bdev: device(%04x:%04x) overwritten",
               major(dev),minor(dev));

  if (!bdev[major(dev)].bd_flag_used) {
    printk(BDEVLOG "bdev: device(%04x:%04x) not registered",
           major(dev),minor(dev));       
    return -1;
  }
   
  if (blocknum<0) {
    printk(BDEVLOG "bdev: device(%04x:%04x) read request out of range",
           major(dev),minor(dev));       
    return -1;
  }

  return bdev[major(dev)].bd_op->read(dev,blocknum,buffer);
}

/*++++++++++++++++++++++++++++++++++++++
 
  This function request to move the head to a specified block of a device.

  int bdev_seek
    return 0 on success, other value on error

  __dev_t dev
    device to seek

  __blkcnt_t blocknum
    block number to seek into
  ++++++++++++++++++++++++++++++++++++++*/


int bdev_seek(__dev_t dev, __blkcnt_t blocknum)
{
  magic_assert(bdev[major(dev)].magic,BLOCK_DEVICE_MAGIC,
               "bdev: device(%04x:%04x) overwritten",
               major(dev),minor(dev));

  if (!bdev[major(dev)].bd_flag_used) {
    printk(BDEVLOG "bdev: device(%04x:%04x) not registered",
           major(dev),minor(dev));       
    return -1;
  }
   
  if (blocknum<0) {
    printk(BDEVLOG "bdev: device(%04x:%04x) seek request out of range",
           major(dev),minor(dev));       
    return -1;
  }
   
  return bdev[major(dev)].bd_op->seek(dev,blocknum);
}

/*++++++++++++++++++++++++++++++++++++++
 
  Write a block into a device.

  int bdev_write
    return 0 on success, other value on error

  __dev_t dev
    device to write into

  __blkcnt_t blocknum
    block number to write

  __uint8_t *buffer
    buffer with data to write
  ++++++++++++++++++++++++++++++++++++++*/


int bdev_write(__dev_t dev, __blkcnt_t blocknum, __uint8_t *buffer)
{
  magic_assert(bdev[major(dev)].magic,BLOCK_DEVICE_MAGIC,              
               "bdev: device(%04x:%04x) overwritten",
               major(dev),minor(dev));

  if (!bdev[major(dev)].bd_flag_used) {
    printk(BDEVLOG "bdev: device(%04x:%04x) not registered",
           major(dev),minor(dev));       
    return -1;
  }

  if (blocknum<0) {
    printk(BDEVLOG "bdev: device(%04x:%04x) write request out of range",
           major(dev),minor(dev));       
    return -1;
  }

  return bdev[major(dev)].bd_op->write(dev,blocknum,buffer);
}