2005-04-17 00:20:36 +02: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.
|
|
|
|
*/
|
|
|
|
|
2009-04-14 04:01:53 +02:00
|
|
|
#ifndef _MD_MD_H
|
|
|
|
#define _MD_MD_H
|
|
|
|
|
|
|
|
#include <linux/blkdev.h>
|
|
|
|
#include <linux/kobject.h>
|
|
|
|
#include <linux/list.h>
|
|
|
|
#include <linux/mm.h>
|
|
|
|
#include <linux/mutex.h>
|
|
|
|
#include <linux/timer.h>
|
|
|
|
#include <linux/wait.h>
|
|
|
|
#include <linux/workqueue.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 20:45:40 +02:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
#define MaxSector (~(sector_t)0)
|
|
|
|
|
|
|
|
typedef struct mddev_s mddev_t;
|
|
|
|
typedef struct mdk_rdev_s mdk_rdev_t;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* MD's 'extended' device
|
|
|
|
*/
|
|
|
|
struct mdk_rdev_s
|
|
|
|
{
|
|
|
|
struct list_head same_set; /* RAID devices within the same set */
|
|
|
|
|
2009-03-31 05:33:13 +02:00
|
|
|
sector_t sectors; /* Device size (in 512bytes sectors) */
|
2005-04-17 00:20:36 +02:00
|
|
|
mddev_t *mddev; /* RAID array if running */
|
2009-03-31 05:27:02 +02:00
|
|
|
int last_events; /* IO event timestamp */
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2011-01-13 23:14:34 +01:00
|
|
|
/*
|
|
|
|
* If meta_bdev is non-NULL, it means that a separate device is
|
|
|
|
* being used to store the metadata (superblock/bitmap) which
|
|
|
|
* would otherwise be contained on the same device as the data (bdev).
|
|
|
|
*/
|
|
|
|
struct block_device *meta_bdev;
|
2005-04-17 00:20:36 +02:00
|
|
|
struct block_device *bdev; /* block device handle */
|
|
|
|
|
|
|
|
struct page *sb_page;
|
|
|
|
int sb_loaded;
|
2006-06-26 09:27:57 +02:00
|
|
|
__u64 sb_events;
|
2005-04-17 00:20:36 +02:00
|
|
|
sector_t data_offset; /* start of data in array */
|
2008-07-11 14:02:23 +02:00
|
|
|
sector_t sb_start; /* offset of the super block (in 512byte sectors) */
|
2005-09-10 01:23:53 +02:00
|
|
|
int sb_size; /* bytes in the superblock */
|
2005-04-17 00:20:36 +02:00
|
|
|
int preferred_minor; /* autorun support */
|
|
|
|
|
2005-11-09 06:39:24 +01:00
|
|
|
struct kobject kobj;
|
|
|
|
|
2005-04-17 00:20:36 +02: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-09 06:39:31 +01: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-10 01:23:45 +02:00
|
|
|
#define WriteMostly 4 /* Avoid reading if at all possible */
|
2008-03-04 23:29:31 +01:00
|
|
|
#define AutoDetected 7 /* added by auto-detect */
|
2011-03-31 03:57:33 +02:00
|
|
|
#define Blocked 8 /* An error occurred on an externally
|
2008-04-30 09:52:32 +02:00
|
|
|
* managed array, don't allow writes
|
|
|
|
* until it is cleared */
|
|
|
|
wait_queue_head_t blocked_wait;
|
2005-09-10 01:23:45 +02:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
int desc_nr; /* descriptor index in the superblock */
|
|
|
|
int raid_disk; /* role of device in array */
|
2010-06-15 10:36:03 +02:00
|
|
|
int new_raid_disk; /* role that the device will have in
|
|
|
|
* the array after a level-change completes.
|
|
|
|
*/
|
2005-06-22 02:17:25 +02: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 09:27:40 +02:00
|
|
|
sector_t recovery_offset;/* If this device has been partially
|
|
|
|
* recovered, this is where we were
|
|
|
|
* up to.
|
|
|
|
*/
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
atomic_t nr_pending; /* number of pending requests.
|
|
|
|
* only maintained for arrays that
|
|
|
|
* support hot removal
|
|
|
|
*/
|
2005-11-09 06:39:31 +01:00
|
|
|
atomic_t read_errors; /* number of consecutive read errors that
|
|
|
|
* we have tried to ignore.
|
|
|
|
*/
|
2009-12-14 02:49:58 +01:00
|
|
|
struct timespec last_read_error; /* monotonic time since our
|
|
|
|
* last read error
|
|
|
|
*/
|
2006-01-06 09:20:52 +01:00
|
|
|
atomic_t corrected_errors; /* number of corrected read errors,
|
|
|
|
* for reporting to userspace and storing
|
|
|
|
* in superblock.
|
|
|
|
*/
|
2007-04-05 04:08:18 +02:00
|
|
|
struct work_struct del_work; /* used for delayed sysfs removal */
|
2008-10-21 04:25:28 +02:00
|
|
|
|
|
|
|
struct sysfs_dirent *sysfs_state; /* handle for 'state'
|
|
|
|
* sysfs entry */
|
2005-04-17 00:20:36 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
struct mddev_s
|
|
|
|
{
|
|
|
|
void *private;
|
2006-01-06 09:20:36 +01:00
|
|
|
struct mdk_personality *pers;
|
2005-04-17 00:20:36 +02:00
|
|
|
dev_t unit;
|
|
|
|
int md_minor;
|
|
|
|
struct list_head disks;
|
2006-10-03 10:15:46 +02:00
|
|
|
unsigned long flags;
|
|
|
|
#define MD_CHANGE_DEVS 0 /* Some device status has changed */
|
|
|
|
#define MD_CHANGE_CLEAN 1 /* transition to or from 'clean' */
|
2010-08-30 09:33:34 +02:00
|
|
|
#define MD_CHANGE_PENDING 2 /* switch from 'clean' to 'active' in progress */
|
2011-06-09 00:59:30 +02:00
|
|
|
#define MD_ARRAY_FIRST_USE 3 /* First use of array, needs initialization */
|
2006-10-03 10:15:46 +02:00
|
|
|
|
2009-03-31 05:39:39 +02:00
|
|
|
int suspended;
|
|
|
|
atomic_t active_io;
|
2005-04-17 00:20:36 +02:00
|
|
|
int ro;
|
2010-08-08 13:18:03 +02:00
|
|
|
int sysfs_active; /* set when sysfs deletes
|
|
|
|
* are happening, so run/
|
|
|
|
* takeover/stop are not safe
|
|
|
|
*/
|
2011-01-13 23:14:33 +01:00
|
|
|
int ready; /* See when safe to pass
|
|
|
|
* IO requests down */
|
2005-04-17 00:20:36 +02:00
|
|
|
struct gendisk *gendisk;
|
|
|
|
|
2005-11-09 06:39:23 +01:00
|
|
|
struct kobject kobj;
|
md: make devices disappear when they are no longer needed.
Currently md devices, once created, never disappear until the module
is unloaded. This is essentially because the gendisk holds a
reference to the mddev, and the mddev holds a reference to the
gendisk, this a circular reference.
If we drop the reference from mddev to gendisk, then we need to ensure
that the mddev is destroyed when the gendisk is destroyed. However it
is not possible to hook into the gendisk destruction process to enable
this.
So we drop the reference from the gendisk to the mddev and destroy the
gendisk when the mddev gets destroyed. However this has a
complication.
Between the call
__blkdev_get->get_gendisk->kobj_lookup->md_probe
and the call
__blkdev_get->md_open
there is no obvious way to hold a reference on the mddev any more, so
unless something is done, it will disappear and gendisk will be
destroyed prematurely.
Also, once we decide to destroy the mddev, there will be an unlockable
moment before the gendisk is unlinked (blk_unregister_region) during
which a new reference to the gendisk can be created. We need to
ensure that this reference can not be used. i.e. the ->open must
fail.
So:
1/ in md_probe we set a flag in the mddev (hold_active) which
indicates that the array should be treated as active, even
though there are no references, and no appearance of activity.
This is cleared by md_release when the device is closed if it
is no longer needed.
This ensures that the gendisk will survive between md_probe and
md_open.
2/ In md_open we check if the mddev we expect to open matches
the gendisk that we did open.
If there is a mismatch we return -ERESTARTSYS and modify
__blkdev_get to retry from the top in that case.
In the -ERESTARTSYS sys case we make sure to wait until
the old gendisk (that we succeeded in opening) is really gone so
we loop at most once.
Some udev configurations will always open an md device when it first
appears. If we allow an md device that was just created by an open
to disappear on an immediate close, then this can race with such udev
configurations and result in an infinite loop the device being opened
and closed, then re-open due to the 'ADD' even from the first open,
and then close and so on.
So we make sure an md device, once created by an open, remains active
at least until some md 'ioctl' has been made on it. This means that
all normal usage of md devices will allow them to disappear promptly
when not needed, but the worst that an incorrect usage will do it
cause an inactive md device to be left in existence (it can easily be
removed).
As an array can be stopped by writing to a sysfs attribute
echo clear > /sys/block/mdXXX/md/array_state
we need to use scheduled work for deleting the gendisk and other
kobjects. This allows us to wait for any pending gendisk deletion to
complete by simply calling flush_scheduled_work().
Signed-off-by: NeilBrown <neilb@suse.de>
2009-01-08 22:31:10 +01:00
|
|
|
int hold_active;
|
|
|
|
#define UNTIL_IOCTL 1
|
2009-01-08 22:31:10 +01:00
|
|
|
#define UNTIL_STOP 2
|
2005-11-09 06:39:23 +01:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/* Superblock information */
|
|
|
|
int major_version,
|
|
|
|
minor_version,
|
|
|
|
patch_version;
|
|
|
|
int persistent;
|
2008-02-06 10:39:51 +01:00
|
|
|
int external; /* metadata is
|
|
|
|
* managed externally */
|
|
|
|
char metadata_type[17]; /* externally set*/
|
2009-06-18 00:45:01 +02:00
|
|
|
int chunk_sectors;
|
2005-04-17 00:20:36 +02:00
|
|
|
time_t ctime, utime;
|
|
|
|
int level, layout;
|
2006-01-06 09:20:51 +01:00
|
|
|
char clevel[16];
|
2005-04-17 00:20:36 +02:00
|
|
|
int raid_disks;
|
|
|
|
int max_disks;
|
2009-03-31 05:33:13 +02:00
|
|
|
sector_t dev_sectors; /* used size of
|
|
|
|
* component devices */
|
2008-07-21 09:05:22 +02:00
|
|
|
sector_t array_sectors; /* exported array size */
|
2009-03-31 06:00:31 +02:00
|
|
|
int external_size; /* size managed
|
|
|
|
* externally */
|
2005-04-17 00:20:36 +02:00
|
|
|
__u64 events;
|
2010-05-18 01:28:43 +02:00
|
|
|
/* If the last 'event' was simply a clean->dirty transition, and
|
|
|
|
* we didn't write it to the spares, then it is safe and simple
|
|
|
|
* to just decrement the event count on a dirty->clean transition.
|
|
|
|
* So we record that possibility here.
|
|
|
|
*/
|
|
|
|
int can_decrease_events;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
char uuid[16];
|
|
|
|
|
2006-03-27 11:18:11 +02: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;
|
2009-06-18 00:45:27 +02:00
|
|
|
int delta_disks, new_level, new_layout;
|
|
|
|
int new_chunk_sectors;
|
2006-03-27 11:18:11 +02:00
|
|
|
|
2011-04-18 10:25:42 +02:00
|
|
|
atomic_t plug_cnt; /* If device is expecting
|
|
|
|
* more bios soon.
|
|
|
|
*/
|
2005-04-17 00:20:36 +02:00
|
|
|
struct mdk_thread_s *thread; /* management thread */
|
|
|
|
struct mdk_thread_s *sync_thread; /* doing resync or reconstruct */
|
2006-07-10 13:44:16 +02:00
|
|
|
sector_t curr_resync; /* last block scheduled */
|
2009-03-31 05:33:13 +02:00
|
|
|
/* As resync requests can complete out of order, we cannot easily track
|
|
|
|
* how much resync has been completed. So we occasionally pause until
|
|
|
|
* everything completes, then set curr_resync_completed to curr_resync.
|
|
|
|
* As such it may be well behind the real resync mark, but it is a value
|
|
|
|
* we are certain of.
|
|
|
|
*/
|
|
|
|
sector_t curr_resync_completed;
|
2005-04-17 00:20:36 +02:00
|
|
|
unsigned long resync_mark; /* a recent timestamp */
|
|
|
|
sector_t resync_mark_cnt;/* blocks written at resync_mark */
|
2006-07-10 13:44:16 +02:00
|
|
|
sector_t curr_mark_cnt; /* blocks scheduled now */
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
sector_t resync_max_sectors; /* may be set by personality */
|
2005-11-09 06:39:26 +01:00
|
|
|
|
|
|
|
sector_t resync_mismatches; /* count of sectors where
|
|
|
|
* parity/replica mismatch found
|
|
|
|
*/
|
2006-03-27 11:18:14 +02: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 09:21:36 +01:00
|
|
|
/* if zero, use the system-wide default */
|
|
|
|
int sync_speed_min;
|
|
|
|
int sync_speed_max;
|
|
|
|
|
2008-05-23 22:04:38 +02:00
|
|
|
/* resync even though the same disks are shared among md-devices */
|
|
|
|
int parallel_resync;
|
|
|
|
|
2006-01-06 09:20:15 +01:00
|
|
|
int ok_start_degraded;
|
2005-04-17 00:20:36 +02: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
|
2008-06-28 00:31:41 +02:00
|
|
|
* RECOVER: doing recovery, or need to try it.
|
md: restart recovery cleanly after device failure.
When we get any IO error during a recovery (rebuilding a spare), we abort
the recovery and restart it.
For RAID6 (and multi-drive RAID1) it may not be best to restart at the
beginning: when multiple failures can be tolerated, the recovery may be
able to continue and re-doing all that has already been done doesn't make
sense.
We already have the infrastructure to record where a recovery is up to
and restart from there, but it is not being used properly.
This is because:
- We sometimes abort with MD_RECOVERY_ERR rather than just MD_RECOVERY_INTR,
which causes the recovery not be be checkpointed.
- We remove spares and then re-added them which loses important state
information.
The distinction between MD_RECOVERY_ERR and MD_RECOVERY_INTR really isn't
needed. If there is an error, the relevant drive will be marked as
Faulty, and that is enough to ensure correct handling of the error. So we
first remove MD_RECOVERY_ERR, changing some of the uses of it to
MD_RECOVERY_INTR.
Then we cause the attempt to remove a non-faulty device from an array to
fail (unless recovery is impossible as the array is too degraded). Then
when remove_and_add_spares attempts to remove the devices on which
recovery can continue, it will fail, they will remain in place, and
recovery will continue on them as desired.
Issue: If we are halfway through rebuilding a spare and another drive
fails, and a new spare is immediately available, do we want to:
1/ complete the current rebuild, then go back and rebuild the new spare or
2/ restart the rebuild from the start and rebuild both devices in
parallel.
Both options can be argued for. The code currently takes option 2 as
a/ this requires least code change
b/ this results in a minimally-degraded array in minimal time.
Cc: "Eivind Sarto" <ivan@kasenna.com>
Signed-off-by: Neil Brown <neilb@suse.de>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2008-05-23 22:04:39 +02:00
|
|
|
* INTR: resync needs to be aborted for some reason
|
2005-04-17 00:20:36 +02:00
|
|
|
* DONE: thread is done and is waiting to be reaped
|
2005-11-09 06:39:26 +01:00
|
|
|
* REQUEST: user-space has requested a sync (used with SYNC)
|
2009-07-07 11:54:23 +02:00
|
|
|
* CHECK: user-space request for check-only, no repair
|
2006-03-27 11:18:09 +02:00
|
|
|
* RESHAPE: A reshape is happening
|
|
|
|
*
|
|
|
|
* If neither SYNC or RESHAPE are set, then it is a recovery.
|
2005-04-17 00:20:36 +02:00
|
|
|
*/
|
|
|
|
#define MD_RECOVERY_RUNNING 0
|
|
|
|
#define MD_RECOVERY_SYNC 1
|
2008-06-28 00:31:41 +02:00
|
|
|
#define MD_RECOVERY_RECOVER 2
|
2005-04-17 00:20:36 +02:00
|
|
|
#define MD_RECOVERY_INTR 3
|
|
|
|
#define MD_RECOVERY_DONE 4
|
|
|
|
#define MD_RECOVERY_NEEDED 5
|
2005-11-09 06:39:26 +01:00
|
|
|
#define MD_RECOVERY_REQUESTED 6
|
|
|
|
#define MD_RECOVERY_CHECK 7
|
2006-03-27 11:18:09 +02:00
|
|
|
#define MD_RECOVERY_RESHAPE 8
|
2006-06-26 09:27:40 +02:00
|
|
|
#define MD_RECOVERY_FROZEN 9
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
unsigned long recovery;
|
2009-01-08 22:31:11 +01:00
|
|
|
int recovery_disabled; /* if we detect that recovery
|
|
|
|
* will always fail, set this
|
|
|
|
* so we don't loop trying */
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
int in_sync; /* know to not need resync */
|
2009-08-10 04:50:52 +02:00
|
|
|
/* 'open_mutex' avoids races between 'md_open' and 'do_md_stop', so
|
|
|
|
* that we are never stopping an array while it is open.
|
|
|
|
* 'reconfig_mutex' protects all other reconfiguration.
|
|
|
|
* These locks are separate due to conflicting interactions
|
|
|
|
* with bdev->bd_mutex.
|
|
|
|
* Lock ordering is:
|
|
|
|
* reconfig_mutex -> bd_mutex : e.g. do_md_run -> revalidate_disk
|
|
|
|
* bd_mutex -> open_mutex: e.g. __blkdev_get -> md_open
|
|
|
|
*/
|
|
|
|
struct mutex open_mutex;
|
2006-03-27 11:18:20 +02:00
|
|
|
struct mutex reconfig_mutex;
|
2008-07-21 09:05:25 +02:00
|
|
|
atomic_t active; /* general refcount */
|
|
|
|
atomic_t openers; /* number of active opens */
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2011-02-24 07:26:41 +01:00
|
|
|
int changed; /* True if we might need to
|
|
|
|
* reread partition info */
|
2005-04-17 00:20:36 +02:00
|
|
|
int degraded; /* whether md should consider
|
|
|
|
* adding a spare
|
|
|
|
*/
|
|
|
|
|
|
|
|
atomic_t recovery_active; /* blocks scheduled, but not written */
|
|
|
|
wait_queue_head_t recovery_wait;
|
|
|
|
sector_t recovery_cp;
|
2008-06-28 00:31:24 +02:00
|
|
|
sector_t resync_min; /* user requested sync
|
|
|
|
* starts here */
|
2008-02-06 10:39:52 +01:00
|
|
|
sector_t resync_max; /* resync should pause
|
|
|
|
* when it gets here */
|
2005-06-22 02:17:12 +02:00
|
|
|
|
2008-10-21 04:25:21 +02:00
|
|
|
struct sysfs_dirent *sysfs_state; /* handle for 'array_state'
|
|
|
|
* file in sysfs.
|
|
|
|
*/
|
2009-01-08 22:31:05 +01:00
|
|
|
struct sysfs_dirent *sysfs_action; /* handle for 'sync_action' */
|
2008-10-21 04:25:21 +02:00
|
|
|
|
md: make devices disappear when they are no longer needed.
Currently md devices, once created, never disappear until the module
is unloaded. This is essentially because the gendisk holds a
reference to the mddev, and the mddev holds a reference to the
gendisk, this a circular reference.
If we drop the reference from mddev to gendisk, then we need to ensure
that the mddev is destroyed when the gendisk is destroyed. However it
is not possible to hook into the gendisk destruction process to enable
this.
So we drop the reference from the gendisk to the mddev and destroy the
gendisk when the mddev gets destroyed. However this has a
complication.
Between the call
__blkdev_get->get_gendisk->kobj_lookup->md_probe
and the call
__blkdev_get->md_open
there is no obvious way to hold a reference on the mddev any more, so
unless something is done, it will disappear and gendisk will be
destroyed prematurely.
Also, once we decide to destroy the mddev, there will be an unlockable
moment before the gendisk is unlinked (blk_unregister_region) during
which a new reference to the gendisk can be created. We need to
ensure that this reference can not be used. i.e. the ->open must
fail.
So:
1/ in md_probe we set a flag in the mddev (hold_active) which
indicates that the array should be treated as active, even
though there are no references, and no appearance of activity.
This is cleared by md_release when the device is closed if it
is no longer needed.
This ensures that the gendisk will survive between md_probe and
md_open.
2/ In md_open we check if the mddev we expect to open matches
the gendisk that we did open.
If there is a mismatch we return -ERESTARTSYS and modify
__blkdev_get to retry from the top in that case.
In the -ERESTARTSYS sys case we make sure to wait until
the old gendisk (that we succeeded in opening) is really gone so
we loop at most once.
Some udev configurations will always open an md device when it first
appears. If we allow an md device that was just created by an open
to disappear on an immediate close, then this can race with such udev
configurations and result in an infinite loop the device being opened
and closed, then re-open due to the 'ADD' even from the first open,
and then close and so on.
So we make sure an md device, once created by an open, remains active
at least until some md 'ioctl' has been made on it. This means that
all normal usage of md devices will allow them to disappear promptly
when not needed, but the worst that an incorrect usage will do it
cause an inactive md device to be left in existence (it can easily be
removed).
As an array can be stopped by writing to a sysfs attribute
echo clear > /sys/block/mdXXX/md/array_state
we need to use scheduled work for deleting the gendisk and other
kobjects. This allows us to wait for any pending gendisk deletion to
complete by simply calling flush_scheduled_work().
Signed-off-by: NeilBrown <neilb@suse.de>
2009-01-08 22:31:10 +01:00
|
|
|
struct work_struct del_work; /* used for delayed sysfs removal */
|
|
|
|
|
2005-06-22 02:17:12 +02:00
|
|
|
spinlock_t write_lock;
|
2005-06-22 02:17:26 +02:00
|
|
|
wait_queue_head_t sb_wait; /* for waiting on superblock updates */
|
2005-06-22 02:17:28 +02:00
|
|
|
atomic_t pending_writes; /* number of active superblock writes */
|
2005-06-22 02:17:12 +02:00
|
|
|
|
2005-04-17 00:20:36 +02: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 09:28:11 +02:00
|
|
|
struct request_queue *queue; /* for plugging ... */
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2005-06-22 02:17:14 +02:00
|
|
|
struct bitmap *bitmap; /* the bitmap for the device */
|
2009-12-14 02:49:52 +01:00
|
|
|
struct {
|
|
|
|
struct file *file; /* the bitmap file */
|
2009-12-14 02:49:54 +01:00
|
|
|
loff_t offset; /* offset from superblock of
|
2009-12-14 02:49:52 +01:00
|
|
|
* start of bitmap. May be
|
|
|
|
* negative, but not '0'
|
2009-12-14 02:49:54 +01:00
|
|
|
* For external metadata, offset
|
|
|
|
* from start of device.
|
2009-12-14 02:49:52 +01:00
|
|
|
*/
|
2009-12-14 02:49:54 +01:00
|
|
|
loff_t default_offset; /* this is the offset to use when
|
2009-12-14 02:49:52 +01:00
|
|
|
* hot-adding a bitmap. It should
|
|
|
|
* eventually be settable by sysfs.
|
|
|
|
*/
|
2010-06-01 11:37:34 +02:00
|
|
|
/* When md is serving under dm, it might use a
|
|
|
|
* dirty_log to store the bits.
|
|
|
|
*/
|
|
|
|
struct dm_dirty_log *log;
|
|
|
|
|
2009-12-14 02:49:52 +01:00
|
|
|
struct mutex mutex;
|
2009-12-14 02:49:53 +01:00
|
|
|
unsigned long chunksize;
|
2010-06-01 11:37:31 +02:00
|
|
|
unsigned long daemon_sleep; /* how many jiffies between updates? */
|
2009-12-14 02:49:53 +01:00
|
|
|
unsigned long max_write_behind; /* write-behind mode */
|
2009-12-14 02:49:56 +01:00
|
|
|
int external;
|
2009-12-14 02:49:52 +01:00
|
|
|
} bitmap_info;
|
2005-06-22 02:17:14 +02:00
|
|
|
|
2009-12-14 02:49:58 +01:00
|
|
|
atomic_t max_corr_read_errors; /* max read retries */
|
2005-04-17 00:20:36 +02:00
|
|
|
struct list_head all_mddevs;
|
2009-12-14 02:49:49 +01:00
|
|
|
|
2010-04-14 09:15:37 +02:00
|
|
|
struct attribute_group *to_remove;
|
2010-06-01 11:37:29 +02:00
|
|
|
|
2010-10-26 09:31:13 +02:00
|
|
|
struct bio_set *bio_set;
|
|
|
|
|
2010-09-03 11:56:18 +02:00
|
|
|
/* Generic flush handling.
|
|
|
|
* The last to finish preflush schedules a worker to submit
|
|
|
|
* the rest of the request (without the REQ_FLUSH flag).
|
2009-12-14 02:49:49 +01:00
|
|
|
*/
|
2010-09-03 11:56:18 +02:00
|
|
|
struct bio *flush_bio;
|
2009-12-14 02:49:49 +01:00
|
|
|
atomic_t flush_pending;
|
2010-09-03 11:56:18 +02:00
|
|
|
struct work_struct flush_work;
|
2010-07-26 03:49:55 +02:00
|
|
|
struct work_struct event_work; /* used by dm to report failure event */
|
2011-06-08 00:51:30 +02:00
|
|
|
void (*sync_super)(mddev_t *mddev, mdk_rdev_t *rdev);
|
2005-04-17 00:20:36 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
static inline void rdev_dec_pending(mdk_rdev_t *rdev, mddev_t *mddev)
|
|
|
|
{
|
2005-11-09 06:39:31 +01:00
|
|
|
int faulty = test_bit(Faulty, &rdev->flags);
|
2005-04-17 00:20:36 +02: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 09:20:36 +01:00
|
|
|
struct mdk_personality
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
char *name;
|
2006-01-06 09:20:36 +01:00
|
|
|
int level;
|
|
|
|
struct list_head list;
|
2005-04-17 00:20:36 +02:00
|
|
|
struct module *owner;
|
2010-04-01 06:02:13 +02:00
|
|
|
int (*make_request)(mddev_t *mddev, struct bio *bio);
|
2005-04-17 00:20:36 +02: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-22 02:17:13 +02:00
|
|
|
sector_t (*sync_request)(mddev_t *mddev, sector_t sector_nr, int *skipped, int go_faster);
|
2005-04-17 00:20:36 +02:00
|
|
|
int (*resize) (mddev_t *mddev, sector_t sectors);
|
2009-03-18 02:10:40 +01:00
|
|
|
sector_t (*size) (mddev_t *mddev, sector_t sectors, int raid_disks);
|
2006-03-27 11:18:13 +02:00
|
|
|
int (*check_reshape) (mddev_t *mddev);
|
|
|
|
int (*start_reshape) (mddev_t *mddev);
|
2009-03-31 06:15:05 +02:00
|
|
|
void (*finish_reshape) (mddev_t *mddev);
|
2005-09-10 01:23:45 +02:00
|
|
|
/* quiesce moves between quiescence states
|
|
|
|
* 0 - fully active
|
|
|
|
* 1 - no new requests allowed
|
|
|
|
* others - reserved
|
|
|
|
*/
|
|
|
|
void (*quiesce) (mddev_t *mddev, int state);
|
2009-03-31 05:39:39 +02:00
|
|
|
/* takeover is used to transition an array from one
|
|
|
|
* personality to another. The new personality must be able
|
|
|
|
* to handle the data in the current layout.
|
|
|
|
* e.g. 2drive raid1 -> 2drive raid5
|
|
|
|
* ndrive raid5 -> degraded n+1drive raid6 with special layout
|
|
|
|
* If the takeover succeeds, a new 'private' structure is returned.
|
|
|
|
* This needs to be installed and then ->run used to activate the
|
|
|
|
* array.
|
|
|
|
*/
|
|
|
|
void *(*takeover) (mddev_t *mddev);
|
2005-04-17 00:20:36 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
|
2005-11-09 06:39:30 +01:00
|
|
|
struct md_sysfs_entry {
|
|
|
|
struct attribute attr;
|
|
|
|
ssize_t (*show)(mddev_t *, char *);
|
|
|
|
ssize_t (*store)(mddev_t *, const char *, size_t);
|
|
|
|
};
|
2009-12-14 02:49:55 +01:00
|
|
|
extern struct attribute_group md_bitmap_group;
|
2005-11-09 06:39:30 +01:00
|
|
|
|
2010-06-01 11:37:23 +02:00
|
|
|
static inline struct sysfs_dirent *sysfs_get_dirent_safe(struct sysfs_dirent *sd, char *name)
|
|
|
|
{
|
|
|
|
if (sd)
|
|
|
|
return sysfs_get_dirent(sd, NULL, name);
|
|
|
|
return sd;
|
|
|
|
}
|
|
|
|
static inline void sysfs_notify_dirent_safe(struct sysfs_dirent *sd)
|
|
|
|
{
|
|
|
|
if (sd)
|
|
|
|
sysfs_notify_dirent(sd);
|
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02: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.
|
|
|
|
*/
|
2009-01-08 22:31:08 +01:00
|
|
|
#define rdev_for_each_list(rdev, tmp, head) \
|
|
|
|
list_for_each_entry_safe(rdev, tmp, head, same_set)
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/*
|
|
|
|
* iterates through the 'same array disks' ringlist
|
|
|
|
*/
|
2008-02-06 10:39:59 +01:00
|
|
|
#define rdev_for_each(rdev, tmp, mddev) \
|
2009-01-08 22:31:08 +01:00
|
|
|
list_for_each_entry_safe(rdev, tmp, &((mddev)->disks), same_set)
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2008-07-21 09:05:25 +02:00
|
|
|
#define rdev_for_each_rcu(rdev, mddev) \
|
|
|
|
list_for_each_entry_rcu(rdev, &((mddev)->disks), same_set)
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
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-22 02:17:14 +02:00
|
|
|
unsigned long timeout;
|
2005-04-17 00:20:36 +02: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 09:20:40 +01:00
|
|
|
static inline void safe_put_page(struct page *p)
|
|
|
|
{
|
|
|
|
if (p) put_page(p);
|
|
|
|
}
|
|
|
|
|
2009-03-31 05:33:13 +02:00
|
|
|
extern int register_md_personality(struct mdk_personality *p);
|
|
|
|
extern int unregister_md_personality(struct mdk_personality *p);
|
|
|
|
extern mdk_thread_t * md_register_thread(void (*run) (mddev_t *mddev),
|
|
|
|
mddev_t *mddev, const char *name);
|
|
|
|
extern void md_unregister_thread(mdk_thread_t *thread);
|
|
|
|
extern void md_wakeup_thread(mdk_thread_t *thread);
|
|
|
|
extern void md_check_recovery(mddev_t *mddev);
|
|
|
|
extern void md_write_start(mddev_t *mddev, struct bio *bi);
|
|
|
|
extern void md_write_end(mddev_t *mddev);
|
|
|
|
extern void md_done_sync(mddev_t *mddev, int blocks, int ok);
|
|
|
|
extern void md_error(mddev_t *mddev, mdk_rdev_t *rdev);
|
|
|
|
|
2009-09-23 10:10:29 +02:00
|
|
|
extern int mddev_congested(mddev_t *mddev, int bits);
|
2010-09-03 11:56:18 +02:00
|
|
|
extern void md_flush_request(mddev_t *mddev, struct bio *bio);
|
2009-03-31 05:33:13 +02:00
|
|
|
extern void md_super_write(mddev_t *mddev, mdk_rdev_t *rdev,
|
|
|
|
sector_t sector, int size, struct page *page);
|
|
|
|
extern void md_super_wait(mddev_t *mddev);
|
2011-01-13 23:14:33 +01:00
|
|
|
extern int sync_page_io(mdk_rdev_t *rdev, sector_t sector, int size,
|
|
|
|
struct page *page, int rw, bool metadata_op);
|
2009-03-31 05:33:13 +02:00
|
|
|
extern void md_do_sync(mddev_t *mddev);
|
|
|
|
extern void md_new_event(mddev_t *mddev);
|
|
|
|
extern int md_allow_write(mddev_t *mddev);
|
|
|
|
extern void md_wait_for_blocked_rdev(mdk_rdev_t *rdev, mddev_t *mddev);
|
2009-03-31 05:59:03 +02:00
|
|
|
extern void md_set_array_sectors(mddev_t *mddev, sector_t array_sectors);
|
2009-06-18 00:49:23 +02:00
|
|
|
extern int md_check_no_bitmap(mddev_t *mddev);
|
2009-08-03 02:59:47 +02:00
|
|
|
extern int md_integrity_register(mddev_t *mddev);
|
2009-12-14 02:49:55 +01:00
|
|
|
extern void md_integrity_add_rdev(mdk_rdev_t *rdev, mddev_t *mddev);
|
|
|
|
extern int strict_strtoul_scaled(const char *cp, unsigned long *res, int scale);
|
2009-12-14 02:49:55 +01:00
|
|
|
extern void restore_bitmap_write_access(struct file *file);
|
2009-04-14 04:01:53 +02:00
|
|
|
|
2010-06-01 11:37:27 +02:00
|
|
|
extern void mddev_init(mddev_t *mddev);
|
|
|
|
extern int md_run(mddev_t *mddev);
|
|
|
|
extern void md_stop(mddev_t *mddev);
|
|
|
|
extern void md_stop_writes(mddev_t *mddev);
|
2010-06-01 11:37:26 +02:00
|
|
|
extern void md_rdev_init(mdk_rdev_t *rdev);
|
2009-04-14 04:01:53 +02:00
|
|
|
|
2010-06-01 11:37:27 +02:00
|
|
|
extern void mddev_suspend(mddev_t *mddev);
|
|
|
|
extern void mddev_resume(mddev_t *mddev);
|
2010-10-26 09:31:13 +02:00
|
|
|
extern struct bio *bio_clone_mddev(struct bio *bio, gfp_t gfp_mask,
|
|
|
|
mddev_t *mddev);
|
|
|
|
extern struct bio *bio_alloc_mddev(gfp_t gfp_mask, int nr_iovecs,
|
|
|
|
mddev_t *mddev);
|
2011-04-18 10:25:42 +02:00
|
|
|
extern int mddev_check_plugged(mddev_t *mddev);
|
2009-04-14 04:01:53 +02:00
|
|
|
#endif /* _MD_MD_H */
|