WebSVN - shark - Rev 378 - /shark/tags/rel_1

/*
* 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);
}

Subversion Repositories shark

(root)/shark/tags/rel_1_21/drivers/block/bdev.c - Rev 378