URL
https://opencores.org/ocsvn/or1k/or1k/trunk
Subversion Repositories or1k
[/] [or1k/] [tags/] [before_ORP/] [uclinux/] [uClinux-2.0.x/] [drivers/] [block/] [raid0.c] - Rev 199
Go to most recent revision | Compare with Previous | Blame | View Log
/* raid0.c : Multiple Devices driver for Linux Copyright (C) 1994-96 Marc ZYNGIER <zyngier@ufr-info-p7.ibp.fr> or <maz@gloups.fdn.fr> RAID-0 management functions. 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, or (at your option) any later version. You should have received a copy of the GNU General Public License (for example /usr/src/linux/COPYING); if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #include <linux/module.h> #include <linux/md.h> #include <linux/raid0.h> #include <linux/malloc.h> #define MAJOR_NR MD_MAJOR #define MD_DRIVER #define MD_PERSONALITY static int create_strip_zones (int minor, struct md_dev *mddev) { int i, j, c=0; int current_offset=0; struct real_dev *smallest_by_zone; struct raid0_data *data=(struct raid0_data *) mddev->private; data->nr_strip_zones=1; for (i=1; i<mddev->nb_dev; i++) { for (j=0; j<i; j++) if (mddev->devices[i].size==mddev->devices[j].size) { c=1; break; } if (!c) data->nr_strip_zones++; c=0; } if ((data->strip_zone=vmalloc(sizeof(struct strip_zone)*data->nr_strip_zones)) == NULL) return 1; data->smallest=NULL; for (i=0; i<data->nr_strip_zones; i++) { data->strip_zone[i].dev_offset=current_offset; smallest_by_zone=NULL; c=0; for (j=0; j<mddev->nb_dev; j++) if (mddev->devices[j].size>current_offset) { data->strip_zone[i].dev[c++]=mddev->devices+j; if (!smallest_by_zone || smallest_by_zone->size > mddev->devices[j].size) smallest_by_zone=mddev->devices+j; } data->strip_zone[i].nb_dev=c; data->strip_zone[i].size=(smallest_by_zone->size-current_offset)*c; if (!data->smallest || data->smallest->size > data->strip_zone[i].size) data->smallest=data->strip_zone+i; data->strip_zone[i].zone_offset=i ? (data->strip_zone[i-1].zone_offset+ data->strip_zone[i-1].size) : 0; current_offset=smallest_by_zone->size; } return 0; } static int raid0_run (int minor, struct md_dev *mddev) { int cur=0, i=0, size, zone0_size, nb_zone; struct raid0_data *data; MOD_INC_USE_COUNT; if ((mddev->private=vmalloc (sizeof (struct raid0_data))) == NULL) return 1; data=(struct raid0_data *) mddev->private; if (create_strip_zones (minor, mddev)) return 1; nb_zone=data->nr_zones= md_size[minor]/data->smallest->size + (md_size[minor]%data->smallest->size ? 1 : 0); printk ("raid0 : Allocating %d bytes for hash.\n",sizeof(struct raid0_hash)*nb_zone); if ((data->hash_table=vmalloc (sizeof (struct raid0_hash)*nb_zone)) == NULL) return 1; size=data->strip_zone[cur].size; i=0; while (cur<data->nr_strip_zones) { data->hash_table[i].zone0=data->strip_zone+cur; if (size>=data->smallest->size)/* If we completely fill the slot */ { data->hash_table[i++].zone1=NULL; size-=data->smallest->size; if (!size) { if (++cur==data->nr_strip_zones) continue; size=data->strip_zone[cur].size; } continue; } if (++cur==data->nr_strip_zones) /* Last dev, set unit1 as NULL */ { data->hash_table[i].zone1=NULL; continue; } zone0_size=size; /* Here, we use a 2nd dev to fill the slot */ size=data->strip_zone[cur].size; data->hash_table[i++].zone1=data->strip_zone+cur; size-=(data->smallest->size - zone0_size); } return (0); } static int raid0_stop (int minor, struct md_dev *mddev) { struct raid0_data *data=(struct raid0_data *) mddev->private; vfree (data->hash_table); vfree (data->strip_zone); vfree (data); MOD_DEC_USE_COUNT; return 0; } /* * FIXME - We assume some things here : * - requested buffers NEVER bigger than chunk size, * - requested buffers NEVER cross stripes limits. * Of course, those facts may not be valid anymore (and surely won't...) * Hey guys, there's some work out there ;-) */ static int raid0_map (struct md_dev *mddev, kdev_t *rdev, unsigned long *rsector, unsigned long size) { struct raid0_data *data=(struct raid0_data *) mddev->private; static struct raid0_hash *hash; struct strip_zone *zone; struct real_dev *tmp_dev; int blk_in_chunk, factor, chunk, chunk_size; long block, rblock; factor=FACTOR(mddev); chunk_size=(1UL << FACTOR_SHIFT(factor)); block=*rsector >> 1; hash=data->hash_table+(block/data->smallest->size); /* Sanity check */ if ((chunk_size*2)<(*rsector % (chunk_size*2))+size) { printk ("raid0_convert : can't convert block across chunks or bigger than %dk %ld %ld\n", chunk_size, *rsector, size); return (-1); } if (block >= (hash->zone0->size + hash->zone0->zone_offset)) { if (!hash->zone1) { printk ("raid0_convert : hash->zone1==NULL for block %ld\n", block); return (-1); } zone=hash->zone1; } else zone=hash->zone0; blk_in_chunk=block & (chunk_size -1); chunk=(block - zone->zone_offset) / (zone->nb_dev<<FACTOR_SHIFT(factor)); tmp_dev=zone->dev[(block >> FACTOR_SHIFT(factor)) % zone->nb_dev]; rblock=(chunk << FACTOR_SHIFT(factor)) + blk_in_chunk + zone->dev_offset; *rdev=tmp_dev->dev; *rsector=rblock<<1; return (0); } static int raid0_status (char *page, int minor, struct md_dev *mddev) { int sz=0; #undef MD_DEBUG #ifdef MD_DEBUG int j, k; struct raid0_data *data=(struct raid0_data *) mddev->private; sz+=sprintf (page+sz, " "); for (j=0; j<data->nr_zones; j++) { sz+=sprintf (page+sz, "[z%d", data->hash_table[j].zone0-data->strip_zone); if (data->hash_table[j].zone1) sz+=sprintf (page+sz, "/z%d] ", data->hash_table[j].zone1-data->strip_zone); else sz+=sprintf (page+sz, "] "); } sz+=sprintf (page+sz, "\n"); for (j=0; j<data->nr_strip_zones; j++) { sz+=sprintf (page+sz, " z%d=[", j); for (k=0; k<data->strip_zone[j].nb_dev; k++) sz+=sprintf (page+sz, "%s/", partition_name(data->strip_zone[j].dev[k]->dev)); sz--; sz+=sprintf (page+sz, "] zo=%d do=%d s=%d\n", data->strip_zone[j].zone_offset, data->strip_zone[j].dev_offset, data->strip_zone[j].size); } #endif sz+=sprintf (page+sz, " %dk chunks", 1<<FACTOR_SHIFT(FACTOR(mddev))); return sz; } static struct md_personality raid0_personality= { "raid0", raid0_map, NULL, /* no special make_request */ NULL, /* no special end_request */ raid0_run, raid0_stop, raid0_status, NULL, /* no ioctls */ 0, NULL, /* no error_handler */ }; #ifndef MODULE void raid0_init (void) { register_md_personality (RAID0, &raid0_personality); } #else int init_module (void) { return (register_md_personality (RAID0, &raid0_personality)); } void cleanup_module (void) { unregister_md_personality (RAID0); } #endif
Go to most recent revision | Compare with Previous | Blame | View Log