2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
md_k.h : kernel internal structure of the Linux MD driver
|
|
|
|
Copyright (C) 1996-98 Ingo Molnar, Gadi Oxman
|
|
|
|
|
|
|
|
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.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef _MD_K_H
|
|
|
|
#define _MD_K_H
|
|
|
|
|
2005-06-21 18:17:12 -06:00
|
|
|
/* and dm-bio-list.h is not under include/linux because.... ??? */
|
|
|
|
#include "../../../drivers/md/dm-bio-list.h"
|
|
|
|
|
[PATCH] BLOCK: Make it possible to disable the block layer [try #6]
Make it possible to disable the block layer. Not all embedded devices require
it, some can make do with just JFFS2, NFS, ramfs, etc - none of which require
the block layer to be present.
This patch does the following:
(*) Introduces CONFIG_BLOCK to disable the block layer, buffering and blockdev
support.
(*) Adds dependencies on CONFIG_BLOCK to any configuration item that controls
an item that uses the block layer. This includes:
(*) Block I/O tracing.
(*) Disk partition code.
(*) All filesystems that are block based, eg: Ext3, ReiserFS, ISOFS.
(*) The SCSI layer. As far as I can tell, even SCSI chardevs use the
block layer to do scheduling. Some drivers that use SCSI facilities -
such as USB storage - end up disabled indirectly from this.
(*) Various block-based device drivers, such as IDE and the old CDROM
drivers.
(*) MTD blockdev handling and FTL.
(*) JFFS - which uses set_bdev_super(), something it could avoid doing by
taking a leaf out of JFFS2's book.
(*) Makes most of the contents of linux/blkdev.h, linux/buffer_head.h and
linux/elevator.h contingent on CONFIG_BLOCK being set. sector_div() is,
however, still used in places, and so is still available.
(*) Also made contingent are the contents of linux/mpage.h, linux/genhd.h and
parts of linux/fs.h.
(*) Makes a number of files in fs/ contingent on CONFIG_BLOCK.
(*) Makes mm/bounce.c (bounce buffering) contingent on CONFIG_BLOCK.
(*) set_page_dirty() doesn't call __set_page_dirty_buffers() if CONFIG_BLOCK
is not enabled.
(*) fs/no-block.c is created to hold out-of-line stubs and things that are
required when CONFIG_BLOCK is not set:
(*) Default blockdev file operations (to give error ENODEV on opening).
(*) Makes some /proc changes:
(*) /proc/devices does not list any blockdevs.
(*) /proc/diskstats and /proc/partitions are contingent on CONFIG_BLOCK.
(*) Makes some compat ioctl handling contingent on CONFIG_BLOCK.
(*) If CONFIG_BLOCK is not defined, makes sys_quotactl() return -ENODEV if
given command other than Q_SYNC or if a special device is specified.
(*) In init/do_mounts.c, no reference is made to the blockdev routines if
CONFIG_BLOCK is not defined. This does not prohibit NFS roots or JFFS2.
(*) The bdflush, ioprio_set and ioprio_get syscalls can now be absent (return
error ENOSYS by way of cond_syscall if so).
(*) The seclvl_bd_claim() and seclvl_bd_release() security calls do nothing if
CONFIG_BLOCK is not set, since they can't then happen.
Signed-Off-By: David Howells <dhowells@redhat.com>
Signed-off-by: Jens Axboe <axboe@kernel.dk>
2006-09-30 12:45:40 -06:00
|
|
|
#ifdef CONFIG_BLOCK
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
#define LEVEL_MULTIPATH (-4)
|
|
|
|
#define LEVEL_LINEAR (-1)
|
|
|
|
#define LEVEL_FAULTY (-5)
|
|
|
|
|
2006-01-06 01:20:36 -07:00
|
|
|
/* we need a value for 'no level specified' and 0
|
|
|
|
* means 'raid0', so we need something else. This is
|
|
|
|
* for internal use only
|
|
|
|
*/
|
|
|
|
#define LEVEL_NONE (-1000000)
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
#define MaxSector (~(sector_t)0)
|
|
|
|
|
|
|
|
typedef struct mddev_s mddev_t;
|
|
|
|
typedef struct mdk_rdev_s mdk_rdev_t;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* options passed in raidrun:
|
|
|
|
*/
|
|
|
|
|
2006-10-03 02:15:59 -06:00
|
|
|
/* Currently this must fit in an 'int' */
|
2006-06-26 01:27:36 -06:00
|
|
|
#define MAX_CHUNK_SIZE (1<<30)
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* MD's 'extended' device
|
|
|
|
*/
|
|
|
|
struct mdk_rdev_s
|
|
|
|
{
|
|
|
|
struct list_head same_set; /* RAID devices within the same set */
|
|
|
|
|
|
|
|
sector_t size; /* Device size (in blocks) */
|
|
|
|
mddev_t *mddev; /* RAID array if running */
|
2007-07-17 05:06:12 -06:00
|
|
|
long last_events; /* IO event timestamp */
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
struct block_device *bdev; /* block device handle */
|
|
|
|
|
|
|
|
struct page *sb_page;
|
|
|
|
int sb_loaded;
|
2006-06-26 01:27:57 -06:00
|
|
|
__u64 sb_events;
|
2005-04-16 16:20:36 -06:00
|
|
|
sector_t data_offset; /* start of data in array */
|
|
|
|
sector_t sb_offset;
|
2005-09-09 17:23:53 -06:00
|
|
|
int sb_size; /* bytes in the superblock */
|
2005-04-16 16:20:36 -06:00
|
|
|
int preferred_minor; /* autorun support */
|
|
|
|
|
2005-11-08 22:39:24 -07:00
|
|
|
struct kobject kobj;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* A device can be in one of three states based on two flags:
|
|
|
|
* Not working: faulty==1 in_sync==0
|
|
|
|
* Fully working: faulty==0 in_sync==1
|
|
|
|
* Working, but not
|
|
|
|
* in sync with array
|
|
|
|
* faulty==0 in_sync==0
|
|
|
|
*
|
|
|
|
* It can never have faulty==1, in_sync==1
|
|
|
|
* This reduces the burden of testing multiple flags in many cases
|
|
|
|
*/
|
|
|
|
|
2005-11-08 22:39:31 -07:00
|
|
|
unsigned long flags;
|
|
|
|
#define Faulty 1 /* device is known to have a fault */
|
|
|
|
#define In_sync 2 /* device is in_sync with rest of array */
|
2005-09-09 17:23:45 -06:00
|
|
|
#define WriteMostly 4 /* Avoid reading if at all possible */
|
[PATCH] md: support BIO_RW_BARRIER for md/raid1
We can only accept BARRIER requests if all slaves handle
barriers, and that can, of course, change with time....
So we keep track of whether the whole array seems safe for barriers,
and also whether each individual rdev handles barriers.
We initially assumes barriers are OK.
When writing the superblock we try a barrier, and if that fails, we flag
things for no-barriers. This will usually clear the flags fairly quickly.
If writing the superblock finds that BIO_RW_BARRIER is -ENOTSUPP, we need to
resubmit, so introduce function "md_super_wait" which waits for requests to
finish, and retries ENOTSUPP requests without the barrier flag.
When writing the real raid1, write requests which were BIO_RW_BARRIER but
which aresn't supported need to be retried. So raid1d is enhanced to do this,
and when any bio write completes (i.e. no retry needed) we remove it from the
r1bio, so that devices needing retry are easy to find.
We should hardly ever get -ENOTSUPP errors when writing data to the raid.
It should only happen if:
1/ the device used to support BARRIER, but now doesn't. Few devices
change like this, though raid1 can!
or
2/ the array has no persistent superblock, so there was no opportunity to
pre-test for barriers when writing the superblock.
Signed-off-by: Neil Brown <neilb@cse.unsw.edu.au>
Signed-off-by: Neil Brown <neilb@suse.de>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-11-08 22:39:34 -07:00
|
|
|
#define BarriersNotsupp 5 /* BIO_RW_BARRIER is not supported */
|
2005-09-09 17:23:45 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
int desc_nr; /* descriptor index in the superblock */
|
|
|
|
int raid_disk; /* role of device in array */
|
2005-06-21 18:17:25 -06:00
|
|
|
int saved_raid_disk; /* role that device used to have in the
|
|
|
|
* array and could again if we did a partial
|
|
|
|
* resync from the bitmap
|
|
|
|
*/
|
2006-06-26 01:27:40 -06:00
|
|
|
sector_t recovery_offset;/* If this device has been partially
|
|
|
|
* recovered, this is where we were
|
|
|
|
* up to.
|
|
|
|
*/
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
atomic_t nr_pending; /* number of pending requests.
|
|
|
|
* only maintained for arrays that
|
|
|
|
* support hot removal
|
|
|
|
*/
|
2005-11-08 22:39:31 -07:00
|
|
|
atomic_t read_errors; /* number of consecutive read errors that
|
|
|
|
* we have tried to ignore.
|
|
|
|
*/
|
2006-01-06 01:20:52 -07:00
|
|
|
atomic_t corrected_errors; /* number of corrected read errors,
|
|
|
|
* for reporting to userspace and storing
|
|
|
|
* in superblock.
|
|
|
|
*/
|
2007-04-04 20:08:18 -06:00
|
|
|
struct work_struct del_work; /* used for delayed sysfs removal */
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
struct mddev_s
|
|
|
|
{
|
|
|
|
void *private;
|
2006-01-06 01:20:36 -07:00
|
|
|
struct mdk_personality *pers;
|
2005-04-16 16:20:36 -06:00
|
|
|
dev_t unit;
|
|
|
|
int md_minor;
|
|
|
|
struct list_head disks;
|
2006-10-03 02:15:46 -06:00
|
|
|
unsigned long flags;
|
|
|
|
#define MD_CHANGE_DEVS 0 /* Some device status has changed */
|
|
|
|
#define MD_CHANGE_CLEAN 1 /* transition to or from 'clean' */
|
|
|
|
#define MD_CHANGE_PENDING 2 /* superblock update in progress */
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
int ro;
|
|
|
|
|
|
|
|
struct gendisk *gendisk;
|
|
|
|
|
2005-11-08 22:39:23 -07:00
|
|
|
struct kobject kobj;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* Superblock information */
|
|
|
|
int major_version,
|
|
|
|
minor_version,
|
|
|
|
patch_version;
|
|
|
|
int persistent;
|
|
|
|
int chunk_size;
|
|
|
|
time_t ctime, utime;
|
|
|
|
int level, layout;
|
2006-01-06 01:20:51 -07:00
|
|
|
char clevel[16];
|
2005-04-16 16:20:36 -06:00
|
|
|
int raid_disks;
|
|
|
|
int max_disks;
|
|
|
|
sector_t size; /* used size of component devices */
|
|
|
|
sector_t array_size; /* exported array size */
|
|
|
|
__u64 events;
|
|
|
|
|
|
|
|
char uuid[16];
|
|
|
|
|
2006-03-27 02:18:11 -07:00
|
|
|
/* If the array is being reshaped, we need to record the
|
|
|
|
* new shape and an indication of where we are up to.
|
|
|
|
* This is written to the superblock.
|
|
|
|
* If reshape_position is MaxSector, then no reshape is happening (yet).
|
|
|
|
*/
|
|
|
|
sector_t reshape_position;
|
|
|
|
int delta_disks, new_level, new_layout, new_chunk;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
struct mdk_thread_s *thread; /* management thread */
|
|
|
|
struct mdk_thread_s *sync_thread; /* doing resync or reconstruct */
|
2006-07-10 05:44:16 -06:00
|
|
|
sector_t curr_resync; /* last block scheduled */
|
2005-04-16 16:20:36 -06:00
|
|
|
unsigned long resync_mark; /* a recent timestamp */
|
|
|
|
sector_t resync_mark_cnt;/* blocks written at resync_mark */
|
2006-07-10 05:44:16 -06:00
|
|
|
sector_t curr_mark_cnt; /* blocks scheduled now */
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
sector_t resync_max_sectors; /* may be set by personality */
|
2005-11-08 22:39:26 -07:00
|
|
|
|
|
|
|
sector_t resync_mismatches; /* count of sectors where
|
|
|
|
* parity/replica mismatch found
|
|
|
|
*/
|
2006-03-27 02:18:14 -07:00
|
|
|
|
|
|
|
/* allow user-space to request suspension of IO to regions of the array */
|
|
|
|
sector_t suspend_lo;
|
|
|
|
sector_t suspend_hi;
|
2006-01-06 01:21:36 -07:00
|
|
|
/* if zero, use the system-wide default */
|
|
|
|
int sync_speed_min;
|
|
|
|
int sync_speed_max;
|
|
|
|
|
2006-01-06 01:20:15 -07:00
|
|
|
int ok_start_degraded;
|
2005-04-16 16:20:36 -06:00
|
|
|
/* recovery/resync flags
|
|
|
|
* NEEDED: we might need to start a resync/recover
|
|
|
|
* RUNNING: a thread is running, or about to be started
|
|
|
|
* SYNC: actually doing a resync, not a recovery
|
|
|
|
* ERR: and IO error was detected - abort the resync/recovery
|
|
|
|
* INTR: someone requested a (clean) early abort.
|
|
|
|
* DONE: thread is done and is waiting to be reaped
|
2005-11-08 22:39:26 -07:00
|
|
|
* REQUEST: user-space has requested a sync (used with SYNC)
|
|
|
|
* CHECK: user-space request for for check-only, no repair
|
2006-03-27 02:18:09 -07:00
|
|
|
* RESHAPE: A reshape is happening
|
|
|
|
*
|
|
|
|
* If neither SYNC or RESHAPE are set, then it is a recovery.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
#define MD_RECOVERY_RUNNING 0
|
|
|
|
#define MD_RECOVERY_SYNC 1
|
|
|
|
#define MD_RECOVERY_ERR 2
|
|
|
|
#define MD_RECOVERY_INTR 3
|
|
|
|
#define MD_RECOVERY_DONE 4
|
|
|
|
#define MD_RECOVERY_NEEDED 5
|
2005-11-08 22:39:26 -07:00
|
|
|
#define MD_RECOVERY_REQUESTED 6
|
|
|
|
#define MD_RECOVERY_CHECK 7
|
2006-03-27 02:18:09 -07:00
|
|
|
#define MD_RECOVERY_RESHAPE 8
|
2006-06-26 01:27:40 -06:00
|
|
|
#define MD_RECOVERY_FROZEN 9
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
unsigned long recovery;
|
|
|
|
|
|
|
|
int in_sync; /* know to not need resync */
|
2006-03-27 02:18:20 -07:00
|
|
|
struct mutex reconfig_mutex;
|
2005-04-16 16:20:36 -06:00
|
|
|
atomic_t active;
|
|
|
|
|
2007-05-09 19:51:36 -06:00
|
|
|
int changed; /* true if we might need to reread partition info */
|
2005-04-16 16:20:36 -06:00
|
|
|
int degraded; /* whether md should consider
|
|
|
|
* adding a spare
|
|
|
|
*/
|
[PATCH] md: support BIO_RW_BARRIER for md/raid1
We can only accept BARRIER requests if all slaves handle
barriers, and that can, of course, change with time....
So we keep track of whether the whole array seems safe for barriers,
and also whether each individual rdev handles barriers.
We initially assumes barriers are OK.
When writing the superblock we try a barrier, and if that fails, we flag
things for no-barriers. This will usually clear the flags fairly quickly.
If writing the superblock finds that BIO_RW_BARRIER is -ENOTSUPP, we need to
resubmit, so introduce function "md_super_wait" which waits for requests to
finish, and retries ENOTSUPP requests without the barrier flag.
When writing the real raid1, write requests which were BIO_RW_BARRIER but
which aresn't supported need to be retried. So raid1d is enhanced to do this,
and when any bio write completes (i.e. no retry needed) we remove it from the
r1bio, so that devices needing retry are easy to find.
We should hardly ever get -ENOTSUPP errors when writing data to the raid.
It should only happen if:
1/ the device used to support BARRIER, but now doesn't. Few devices
change like this, though raid1 can!
or
2/ the array has no persistent superblock, so there was no opportunity to
pre-test for barriers when writing the superblock.
Signed-off-by: Neil Brown <neilb@cse.unsw.edu.au>
Signed-off-by: Neil Brown <neilb@suse.de>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-11-08 22:39:34 -07:00
|
|
|
int barriers_work; /* initialised to true, cleared as soon
|
|
|
|
* as a barrier request to slave
|
|
|
|
* fails. Only supported
|
|
|
|
*/
|
|
|
|
struct bio *biolist; /* bios that need to be retried
|
|
|
|
* because BIO_RW_BARRIER is not supported
|
|
|
|
*/
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
atomic_t recovery_active; /* blocks scheduled, but not written */
|
|
|
|
wait_queue_head_t recovery_wait;
|
|
|
|
sector_t recovery_cp;
|
2005-06-21 18:17:12 -06:00
|
|
|
|
|
|
|
spinlock_t write_lock;
|
2005-06-21 18:17:26 -06:00
|
|
|
wait_queue_head_t sb_wait; /* for waiting on superblock updates */
|
2005-06-21 18:17:28 -06:00
|
|
|
atomic_t pending_writes; /* number of active superblock writes */
|
2005-06-21 18:17:12 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
unsigned int safemode; /* if set, update "clean" superblock
|
|
|
|
* when no writes pending.
|
|
|
|
*/
|
|
|
|
unsigned int safemode_delay;
|
|
|
|
struct timer_list safemode_timer;
|
|
|
|
atomic_t writes_pending;
|
2007-07-24 01:28:11 -06:00
|
|
|
struct request_queue *queue; /* for plugging ... */
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-09-09 17:23:47 -06:00
|
|
|
atomic_t write_behind; /* outstanding async IO */
|
|
|
|
unsigned int max_write_behind; /* 0 = sync */
|
|
|
|
|
2005-06-21 18:17:14 -06:00
|
|
|
struct bitmap *bitmap; /* the bitmap for the device */
|
|
|
|
struct file *bitmap_file; /* the bitmap file */
|
2005-06-21 18:17:27 -06:00
|
|
|
long bitmap_offset; /* offset from superblock of
|
|
|
|
* start of bitmap. May be
|
|
|
|
* negative, but not '0'
|
|
|
|
*/
|
2005-09-09 17:23:45 -06:00
|
|
|
long default_bitmap_offset; /* this is the offset to use when
|
|
|
|
* hot-adding a bitmap. It should
|
|
|
|
* eventually be settable by sysfs.
|
|
|
|
*/
|
2005-06-21 18:17:14 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
struct list_head all_mddevs;
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
static inline void rdev_dec_pending(mdk_rdev_t *rdev, mddev_t *mddev)
|
|
|
|
{
|
2005-11-08 22:39:31 -07:00
|
|
|
int faulty = test_bit(Faulty, &rdev->flags);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (atomic_dec_and_test(&rdev->nr_pending) && faulty)
|
|
|
|
set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void md_sync_acct(struct block_device *bdev, unsigned long nr_sectors)
|
|
|
|
{
|
|
|
|
atomic_add(nr_sectors, &bdev->bd_contains->bd_disk->sync_io);
|
|
|
|
}
|
|
|
|
|
2006-01-06 01:20:36 -07:00
|
|
|
struct mdk_personality
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
char *name;
|
2006-01-06 01:20:36 -07:00
|
|
|
int level;
|
|
|
|
struct list_head list;
|
2005-04-16 16:20:36 -06:00
|
|
|
struct module *owner;
|
2007-07-24 01:28:11 -06:00
|
|
|
int (*make_request)(struct request_queue *q, struct bio *bio);
|
2005-04-16 16:20:36 -06:00
|
|
|
int (*run)(mddev_t *mddev);
|
|
|
|
int (*stop)(mddev_t *mddev);
|
|
|
|
void (*status)(struct seq_file *seq, mddev_t *mddev);
|
|
|
|
/* error_handler must set ->faulty and clear ->in_sync
|
|
|
|
* if appropriate, and should abort recovery if needed
|
|
|
|
*/
|
|
|
|
void (*error_handler)(mddev_t *mddev, mdk_rdev_t *rdev);
|
|
|
|
int (*hot_add_disk) (mddev_t *mddev, mdk_rdev_t *rdev);
|
|
|
|
int (*hot_remove_disk) (mddev_t *mddev, int number);
|
|
|
|
int (*spare_active) (mddev_t *mddev);
|
2005-06-21 18:17:13 -06:00
|
|
|
sector_t (*sync_request)(mddev_t *mddev, sector_t sector_nr, int *skipped, int go_faster);
|
2005-04-16 16:20:36 -06:00
|
|
|
int (*resize) (mddev_t *mddev, sector_t sectors);
|
2006-03-27 02:18:13 -07:00
|
|
|
int (*check_reshape) (mddev_t *mddev);
|
|
|
|
int (*start_reshape) (mddev_t *mddev);
|
2005-04-16 16:20:36 -06:00
|
|
|
int (*reconfig) (mddev_t *mddev, int layout, int chunk_size);
|
2005-09-09 17:23:45 -06:00
|
|
|
/* quiesce moves between quiescence states
|
|
|
|
* 0 - fully active
|
|
|
|
* 1 - no new requests allowed
|
|
|
|
* others - reserved
|
|
|
|
*/
|
|
|
|
void (*quiesce) (mddev_t *mddev, int state);
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
|
2005-11-08 22:39:30 -07:00
|
|
|
struct md_sysfs_entry {
|
|
|
|
struct attribute attr;
|
|
|
|
ssize_t (*show)(mddev_t *, char *);
|
|
|
|
ssize_t (*store)(mddev_t *, const char *, size_t);
|
|
|
|
};
|
|
|
|
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
static inline char * mdname (mddev_t * mddev)
|
|
|
|
{
|
|
|
|
return mddev->gendisk ? mddev->gendisk->disk_name : "mdX";
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* iterates through some rdev ringlist. It's safe to remove the
|
|
|
|
* current 'rdev'. Dont touch 'tmp' though.
|
|
|
|
*/
|
|
|
|
#define ITERATE_RDEV_GENERIC(head,rdev,tmp) \
|
|
|
|
\
|
|
|
|
for ((tmp) = (head).next; \
|
|
|
|
(rdev) = (list_entry((tmp), mdk_rdev_t, same_set)), \
|
|
|
|
(tmp) = (tmp)->next, (tmp)->prev != &(head) \
|
|
|
|
; )
|
|
|
|
/*
|
|
|
|
* iterates through the 'same array disks' ringlist
|
|
|
|
*/
|
|
|
|
#define ITERATE_RDEV(mddev,rdev,tmp) \
|
|
|
|
ITERATE_RDEV_GENERIC((mddev)->disks,rdev,tmp)
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Iterates through 'pending RAID disks'
|
|
|
|
*/
|
|
|
|
#define ITERATE_RDEV_PENDING(rdev,tmp) \
|
|
|
|
ITERATE_RDEV_GENERIC(pending_raid_disks,rdev,tmp)
|
|
|
|
|
|
|
|
typedef struct mdk_thread_s {
|
|
|
|
void (*run) (mddev_t *mddev);
|
|
|
|
mddev_t *mddev;
|
|
|
|
wait_queue_head_t wqueue;
|
|
|
|
unsigned long flags;
|
|
|
|
struct task_struct *tsk;
|
2005-06-21 18:17:14 -06:00
|
|
|
unsigned long timeout;
|
2005-04-16 16:20:36 -06:00
|
|
|
} mdk_thread_t;
|
|
|
|
|
|
|
|
#define THREAD_WAKEUP 0
|
|
|
|
|
|
|
|
#define __wait_event_lock_irq(wq, condition, lock, cmd) \
|
|
|
|
do { \
|
|
|
|
wait_queue_t __wait; \
|
|
|
|
init_waitqueue_entry(&__wait, current); \
|
|
|
|
\
|
|
|
|
add_wait_queue(&wq, &__wait); \
|
|
|
|
for (;;) { \
|
|
|
|
set_current_state(TASK_UNINTERRUPTIBLE); \
|
|
|
|
if (condition) \
|
|
|
|
break; \
|
|
|
|
spin_unlock_irq(&lock); \
|
|
|
|
cmd; \
|
|
|
|
schedule(); \
|
|
|
|
spin_lock_irq(&lock); \
|
|
|
|
} \
|
|
|
|
current->state = TASK_RUNNING; \
|
|
|
|
remove_wait_queue(&wq, &__wait); \
|
|
|
|
} while (0)
|
|
|
|
|
|
|
|
#define wait_event_lock_irq(wq, condition, lock, cmd) \
|
|
|
|
do { \
|
|
|
|
if (condition) \
|
|
|
|
break; \
|
|
|
|
__wait_event_lock_irq(wq, condition, lock, cmd); \
|
|
|
|
} while (0)
|
|
|
|
|
2006-01-06 01:20:40 -07:00
|
|
|
static inline void safe_put_page(struct page *p)
|
|
|
|
{
|
|
|
|
if (p) put_page(p);
|
|
|
|
}
|
|
|
|
|
[PATCH] BLOCK: Make it possible to disable the block layer [try #6]
Make it possible to disable the block layer. Not all embedded devices require
it, some can make do with just JFFS2, NFS, ramfs, etc - none of which require
the block layer to be present.
This patch does the following:
(*) Introduces CONFIG_BLOCK to disable the block layer, buffering and blockdev
support.
(*) Adds dependencies on CONFIG_BLOCK to any configuration item that controls
an item that uses the block layer. This includes:
(*) Block I/O tracing.
(*) Disk partition code.
(*) All filesystems that are block based, eg: Ext3, ReiserFS, ISOFS.
(*) The SCSI layer. As far as I can tell, even SCSI chardevs use the
block layer to do scheduling. Some drivers that use SCSI facilities -
such as USB storage - end up disabled indirectly from this.
(*) Various block-based device drivers, such as IDE and the old CDROM
drivers.
(*) MTD blockdev handling and FTL.
(*) JFFS - which uses set_bdev_super(), something it could avoid doing by
taking a leaf out of JFFS2's book.
(*) Makes most of the contents of linux/blkdev.h, linux/buffer_head.h and
linux/elevator.h contingent on CONFIG_BLOCK being set. sector_div() is,
however, still used in places, and so is still available.
(*) Also made contingent are the contents of linux/mpage.h, linux/genhd.h and
parts of linux/fs.h.
(*) Makes a number of files in fs/ contingent on CONFIG_BLOCK.
(*) Makes mm/bounce.c (bounce buffering) contingent on CONFIG_BLOCK.
(*) set_page_dirty() doesn't call __set_page_dirty_buffers() if CONFIG_BLOCK
is not enabled.
(*) fs/no-block.c is created to hold out-of-line stubs and things that are
required when CONFIG_BLOCK is not set:
(*) Default blockdev file operations (to give error ENODEV on opening).
(*) Makes some /proc changes:
(*) /proc/devices does not list any blockdevs.
(*) /proc/diskstats and /proc/partitions are contingent on CONFIG_BLOCK.
(*) Makes some compat ioctl handling contingent on CONFIG_BLOCK.
(*) If CONFIG_BLOCK is not defined, makes sys_quotactl() return -ENODEV if
given command other than Q_SYNC or if a special device is specified.
(*) In init/do_mounts.c, no reference is made to the blockdev routines if
CONFIG_BLOCK is not defined. This does not prohibit NFS roots or JFFS2.
(*) The bdflush, ioprio_set and ioprio_get syscalls can now be absent (return
error ENOSYS by way of cond_syscall if so).
(*) The seclvl_bd_claim() and seclvl_bd_release() security calls do nothing if
CONFIG_BLOCK is not set, since they can't then happen.
Signed-Off-By: David Howells <dhowells@redhat.com>
Signed-off-by: Jens Axboe <axboe@kernel.dk>
2006-09-30 12:45:40 -06:00
|
|
|
#endif /* CONFIG_BLOCK */
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif
|
|
|
|
|