mirror of
https://github.com/AuxXxilium/linux_dsm_epyc7002.git
synced 2024-12-07 02:06:39 +07:00
7564beda19
For clustered raid10 scenario, we need to let all the nodes know about that a new disk is added to the array, and the reshape caused by add new member just need to be happened in one node, but other nodes should know about the change. Since reshape means read data from somewhere (which is already used by array) and write data to unused region. Obviously, it is awful if one node is reading data from address while another node is writing to the same address. Considering we have implemented suspend writes in the resyncing area, so we can just broadcast the reading address to other nodes to avoid the trouble. For master node, it would call reshape_request then update sb during the reshape period. To avoid above trouble, we call resync_info_update to send RESYNC message in reshape_request. Then from slave node's view, it receives two type messages: 1. RESYNCING message Slave node add the address (where master node reading data from) to suspend list. 2. METADATA_UPDATED message Once slave nodes know the reshaping is started in master node, it is time to update reshape position and call start_reshape to follow master node's step. After reshape is done, only reshape position is need to be updated, so the majority task of reshaping is happened on the master node. Reviewed-by: NeilBrown <neilb@suse.com> Signed-off-by: Guoqing Jiang <gqjiang@suse.com> Signed-off-by: Shaohua Li <shli@fb.com>
763 lines
26 KiB
C
763 lines
26 KiB
C
/*
|
|
md.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_MD_H
|
|
#define _MD_MD_H
|
|
|
|
#include <linux/blkdev.h>
|
|
#include <linux/backing-dev.h>
|
|
#include <linux/badblocks.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>
|
|
#include "md-cluster.h"
|
|
|
|
#define MaxSector (~(sector_t)0)
|
|
|
|
/*
|
|
* These flags should really be called "NO_RETRY" rather than
|
|
* "FAILFAST" because they don't make any promise about time lapse,
|
|
* only about the number of retries, which will be zero.
|
|
* REQ_FAILFAST_DRIVER is not included because
|
|
* Commit: 4a27446f3e39 ("[SCSI] modify scsi to handle new fail fast flags.")
|
|
* seems to suggest that the errors it avoids retrying should usually
|
|
* be retried.
|
|
*/
|
|
#define MD_FAILFAST (REQ_FAILFAST_DEV | REQ_FAILFAST_TRANSPORT)
|
|
/*
|
|
* MD's 'extended' device
|
|
*/
|
|
struct md_rdev {
|
|
struct list_head same_set; /* RAID devices within the same set */
|
|
|
|
sector_t sectors; /* Device size (in 512bytes sectors) */
|
|
struct mddev *mddev; /* RAID array if running */
|
|
int last_events; /* IO event timestamp */
|
|
|
|
/*
|
|
* 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;
|
|
struct block_device *bdev; /* block device handle */
|
|
|
|
struct page *sb_page, *bb_page;
|
|
int sb_loaded;
|
|
__u64 sb_events;
|
|
sector_t data_offset; /* start of data in array */
|
|
sector_t new_data_offset;/* only relevant while reshaping */
|
|
sector_t sb_start; /* offset of the super block (in 512byte sectors) */
|
|
int sb_size; /* bytes in the superblock */
|
|
int preferred_minor; /* autorun support */
|
|
|
|
struct kobject kobj;
|
|
|
|
/* 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
|
|
*/
|
|
|
|
unsigned long flags; /* bit set of 'enum flag_bits' bits. */
|
|
wait_queue_head_t blocked_wait;
|
|
|
|
int desc_nr; /* descriptor index in the superblock */
|
|
int raid_disk; /* role of device in array */
|
|
int new_raid_disk; /* role that the device will have in
|
|
* the array after a level-change completes.
|
|
*/
|
|
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
|
|
*/
|
|
union {
|
|
sector_t recovery_offset;/* If this device has been partially
|
|
* recovered, this is where we were
|
|
* up to.
|
|
*/
|
|
sector_t journal_tail; /* If this device is a journal device,
|
|
* this is the journal tail (journal
|
|
* recovery start point)
|
|
*/
|
|
};
|
|
|
|
atomic_t nr_pending; /* number of pending requests.
|
|
* only maintained for arrays that
|
|
* support hot removal
|
|
*/
|
|
atomic_t read_errors; /* number of consecutive read errors that
|
|
* we have tried to ignore.
|
|
*/
|
|
time64_t last_read_error; /* monotonic time since our
|
|
* last read error
|
|
*/
|
|
atomic_t corrected_errors; /* number of corrected read errors,
|
|
* for reporting to userspace and storing
|
|
* in superblock.
|
|
*/
|
|
struct work_struct del_work; /* used for delayed sysfs removal */
|
|
|
|
struct kernfs_node *sysfs_state; /* handle for 'state'
|
|
* sysfs entry */
|
|
|
|
struct badblocks badblocks;
|
|
|
|
struct {
|
|
short offset; /* Offset from superblock to start of PPL.
|
|
* Not used by external metadata. */
|
|
unsigned int size; /* Size in sectors of the PPL space */
|
|
sector_t sector; /* First sector of the PPL space */
|
|
} ppl;
|
|
};
|
|
enum flag_bits {
|
|
Faulty, /* device is known to have a fault */
|
|
In_sync, /* device is in_sync with rest of array */
|
|
Bitmap_sync, /* ..actually, not quite In_sync. Need a
|
|
* bitmap-based recovery to get fully in sync.
|
|
* The bit is only meaningful before device
|
|
* has been passed to pers->hot_add_disk.
|
|
*/
|
|
WriteMostly, /* Avoid reading if at all possible */
|
|
AutoDetected, /* added by auto-detect */
|
|
Blocked, /* An error occurred but has not yet
|
|
* been acknowledged by the metadata
|
|
* handler, so don't allow writes
|
|
* until it is cleared */
|
|
WriteErrorSeen, /* A write error has been seen on this
|
|
* device
|
|
*/
|
|
FaultRecorded, /* Intermediate state for clearing
|
|
* Blocked. The Fault is/will-be
|
|
* recorded in the metadata, but that
|
|
* metadata hasn't been stored safely
|
|
* on disk yet.
|
|
*/
|
|
BlockedBadBlocks, /* A writer is blocked because they
|
|
* found an unacknowledged bad-block.
|
|
* This can safely be cleared at any
|
|
* time, and the writer will re-check.
|
|
* It may be set at any time, and at
|
|
* worst the writer will timeout and
|
|
* re-check. So setting it as
|
|
* accurately as possible is good, but
|
|
* not absolutely critical.
|
|
*/
|
|
WantReplacement, /* This device is a candidate to be
|
|
* hot-replaced, either because it has
|
|
* reported some faults, or because
|
|
* of explicit request.
|
|
*/
|
|
Replacement, /* This device is a replacement for
|
|
* a want_replacement device with same
|
|
* raid_disk number.
|
|
*/
|
|
Candidate, /* For clustered environments only:
|
|
* This device is seen locally but not
|
|
* by the whole cluster
|
|
*/
|
|
Journal, /* This device is used as journal for
|
|
* raid-5/6.
|
|
* Usually, this device should be faster
|
|
* than other devices in the array
|
|
*/
|
|
ClusterRemove,
|
|
RemoveSynchronized, /* synchronize_rcu() was called after
|
|
* this device was known to be faulty,
|
|
* so it is safe to remove without
|
|
* another synchronize_rcu() call.
|
|
*/
|
|
ExternalBbl, /* External metadata provides bad
|
|
* block management for a disk
|
|
*/
|
|
FailFast, /* Minimal retries should be attempted on
|
|
* this device, so use REQ_FAILFAST_DEV.
|
|
* Also don't try to repair failed reads.
|
|
* It is expects that no bad block log
|
|
* is present.
|
|
*/
|
|
LastDev, /* Seems to be the last working dev as
|
|
* it didn't fail, so don't use FailFast
|
|
* any more for metadata
|
|
*/
|
|
};
|
|
|
|
static inline int is_badblock(struct md_rdev *rdev, sector_t s, int sectors,
|
|
sector_t *first_bad, int *bad_sectors)
|
|
{
|
|
if (unlikely(rdev->badblocks.count)) {
|
|
int rv = badblocks_check(&rdev->badblocks, rdev->data_offset + s,
|
|
sectors,
|
|
first_bad, bad_sectors);
|
|
if (rv)
|
|
*first_bad -= rdev->data_offset;
|
|
return rv;
|
|
}
|
|
return 0;
|
|
}
|
|
extern int rdev_set_badblocks(struct md_rdev *rdev, sector_t s, int sectors,
|
|
int is_new);
|
|
extern int rdev_clear_badblocks(struct md_rdev *rdev, sector_t s, int sectors,
|
|
int is_new);
|
|
struct md_cluster_info;
|
|
|
|
/* change UNSUPPORTED_MDDEV_FLAGS for each array type if new flag is added */
|
|
enum mddev_flags {
|
|
MD_ARRAY_FIRST_USE, /* First use of array, needs initialization */
|
|
MD_CLOSING, /* If set, we are closing the array, do not open
|
|
* it then */
|
|
MD_JOURNAL_CLEAN, /* A raid with journal is already clean */
|
|
MD_HAS_JOURNAL, /* The raid array has journal feature set */
|
|
MD_CLUSTER_RESYNC_LOCKED, /* cluster raid only, which means node
|
|
* already took resync lock, need to
|
|
* release the lock */
|
|
MD_FAILFAST_SUPPORTED, /* Using MD_FAILFAST on metadata writes is
|
|
* supported as calls to md_error() will
|
|
* never cause the array to become failed.
|
|
*/
|
|
MD_HAS_PPL, /* The raid array has PPL feature set */
|
|
MD_HAS_MULTIPLE_PPLS, /* The raid array has multiple PPLs feature set */
|
|
MD_ALLOW_SB_UPDATE, /* md_check_recovery is allowed to update
|
|
* the metadata without taking reconfig_mutex.
|
|
*/
|
|
MD_UPDATING_SB, /* md_check_recovery is updating the metadata
|
|
* without explicitly holding reconfig_mutex.
|
|
*/
|
|
};
|
|
|
|
enum mddev_sb_flags {
|
|
MD_SB_CHANGE_DEVS, /* Some device status has changed */
|
|
MD_SB_CHANGE_CLEAN, /* transition to or from 'clean' */
|
|
MD_SB_CHANGE_PENDING, /* switch from 'clean' to 'active' in progress */
|
|
MD_SB_NEED_REWRITE, /* metadata write needs to be repeated */
|
|
};
|
|
|
|
#define NR_FLUSH_INFOS 8
|
|
#define NR_FLUSH_BIOS 64
|
|
struct flush_info {
|
|
struct bio *bio;
|
|
struct mddev *mddev;
|
|
struct work_struct flush_work;
|
|
atomic_t flush_pending;
|
|
};
|
|
struct flush_bio {
|
|
struct flush_info *fi;
|
|
struct md_rdev *rdev;
|
|
};
|
|
|
|
struct mddev {
|
|
void *private;
|
|
struct md_personality *pers;
|
|
dev_t unit;
|
|
int md_minor;
|
|
struct list_head disks;
|
|
unsigned long flags;
|
|
unsigned long sb_flags;
|
|
|
|
int suspended;
|
|
atomic_t active_io;
|
|
int ro;
|
|
int sysfs_active; /* set when sysfs deletes
|
|
* are happening, so run/
|
|
* takeover/stop are not safe
|
|
*/
|
|
struct gendisk *gendisk;
|
|
|
|
struct kobject kobj;
|
|
int hold_active;
|
|
#define UNTIL_IOCTL 1
|
|
#define UNTIL_STOP 2
|
|
|
|
/* Superblock information */
|
|
int major_version,
|
|
minor_version,
|
|
patch_version;
|
|
int persistent;
|
|
int external; /* metadata is
|
|
* managed externally */
|
|
char metadata_type[17]; /* externally set*/
|
|
int chunk_sectors;
|
|
time64_t ctime, utime;
|
|
int level, layout;
|
|
char clevel[16];
|
|
int raid_disks;
|
|
int max_disks;
|
|
sector_t dev_sectors; /* used size of
|
|
* component devices */
|
|
sector_t array_sectors; /* exported array size */
|
|
int external_size; /* size managed
|
|
* externally */
|
|
__u64 events;
|
|
/* 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;
|
|
|
|
char uuid[16];
|
|
|
|
/* 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;
|
|
int new_chunk_sectors;
|
|
int reshape_backwards;
|
|
|
|
struct md_thread *thread; /* management thread */
|
|
struct md_thread *sync_thread; /* doing resync or reconstruct */
|
|
|
|
/* 'last_sync_action' is initialized to "none". It is set when a
|
|
* sync operation (i.e "data-check", "requested-resync", "resync",
|
|
* "recovery", or "reshape") is started. It holds this value even
|
|
* when the sync thread is "frozen" (interrupted) or "idle" (stopped
|
|
* or finished). It is overwritten when a new sync operation is begun.
|
|
*/
|
|
char *last_sync_action;
|
|
sector_t curr_resync; /* last block scheduled */
|
|
/* 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;
|
|
unsigned long resync_mark; /* a recent timestamp */
|
|
sector_t resync_mark_cnt;/* blocks written at resync_mark */
|
|
sector_t curr_mark_cnt; /* blocks scheduled now */
|
|
|
|
sector_t resync_max_sectors; /* may be set by personality */
|
|
|
|
atomic64_t resync_mismatches; /* count of sectors where
|
|
* parity/replica mismatch found
|
|
*/
|
|
|
|
/* allow user-space to request suspension of IO to regions of the array */
|
|
sector_t suspend_lo;
|
|
sector_t suspend_hi;
|
|
/* if zero, use the system-wide default */
|
|
int sync_speed_min;
|
|
int sync_speed_max;
|
|
|
|
/* resync even though the same disks are shared among md-devices */
|
|
int parallel_resync;
|
|
|
|
int ok_start_degraded;
|
|
|
|
unsigned long recovery;
|
|
/* If a RAID personality determines that recovery (of a particular
|
|
* device) will fail due to a read error on the source device, it
|
|
* takes a copy of this number and does not attempt recovery again
|
|
* until this number changes.
|
|
*/
|
|
int recovery_disabled;
|
|
|
|
int in_sync; /* know to not need resync */
|
|
/* '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;
|
|
struct mutex reconfig_mutex;
|
|
atomic_t active; /* general refcount */
|
|
atomic_t openers; /* number of active opens */
|
|
|
|
int changed; /* True if we might need to
|
|
* reread partition info */
|
|
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;
|
|
sector_t resync_min; /* user requested sync
|
|
* starts here */
|
|
sector_t resync_max; /* resync should pause
|
|
* when it gets here */
|
|
|
|
struct kernfs_node *sysfs_state; /* handle for 'array_state'
|
|
* file in sysfs.
|
|
*/
|
|
struct kernfs_node *sysfs_action; /* handle for 'sync_action' */
|
|
|
|
struct work_struct del_work; /* used for delayed sysfs removal */
|
|
|
|
/* "lock" protects:
|
|
* flush_bio transition from NULL to !NULL
|
|
* rdev superblocks, events
|
|
* clearing MD_CHANGE_*
|
|
* in_sync - and related safemode and MD_CHANGE changes
|
|
* pers (also protected by reconfig_mutex and pending IO).
|
|
* clearing ->bitmap
|
|
* clearing ->bitmap_info.file
|
|
* changing ->resync_{min,max}
|
|
* setting MD_RECOVERY_RUNNING (which interacts with resync_{min,max})
|
|
*/
|
|
spinlock_t lock;
|
|
wait_queue_head_t sb_wait; /* for waiting on superblock updates */
|
|
atomic_t pending_writes; /* number of active superblock writes */
|
|
|
|
unsigned int safemode; /* if set, update "clean" superblock
|
|
* when no writes pending.
|
|
*/
|
|
unsigned int safemode_delay;
|
|
struct timer_list safemode_timer;
|
|
struct percpu_ref writes_pending;
|
|
int sync_checkers; /* # of threads checking writes_pending */
|
|
struct request_queue *queue; /* for plugging ... */
|
|
|
|
struct bitmap *bitmap; /* the bitmap for the device */
|
|
struct {
|
|
struct file *file; /* the bitmap file */
|
|
loff_t offset; /* offset from superblock of
|
|
* start of bitmap. May be
|
|
* negative, but not '0'
|
|
* For external metadata, offset
|
|
* from start of device.
|
|
*/
|
|
unsigned long space; /* space available at this offset */
|
|
loff_t default_offset; /* this is the offset to use when
|
|
* hot-adding a bitmap. It should
|
|
* eventually be settable by sysfs.
|
|
*/
|
|
unsigned long default_space; /* space available at
|
|
* default offset */
|
|
struct mutex mutex;
|
|
unsigned long chunksize;
|
|
unsigned long daemon_sleep; /* how many jiffies between updates? */
|
|
unsigned long max_write_behind; /* write-behind mode */
|
|
int external;
|
|
int nodes; /* Maximum number of nodes in the cluster */
|
|
char cluster_name[64]; /* Name of the cluster */
|
|
} bitmap_info;
|
|
|
|
atomic_t max_corr_read_errors; /* max read retries */
|
|
struct list_head all_mddevs;
|
|
|
|
struct attribute_group *to_remove;
|
|
|
|
struct bio_set bio_set;
|
|
struct bio_set sync_set; /* for sync operations like
|
|
* metadata and bitmap writes
|
|
*/
|
|
|
|
mempool_t *flush_pool;
|
|
mempool_t *flush_bio_pool;
|
|
struct work_struct event_work; /* used by dm to report failure event */
|
|
void (*sync_super)(struct mddev *mddev, struct md_rdev *rdev);
|
|
struct md_cluster_info *cluster_info;
|
|
unsigned int good_device_nr; /* good device num within cluster raid */
|
|
|
|
bool has_superblocks:1;
|
|
};
|
|
|
|
enum recovery_flags {
|
|
/*
|
|
* If neither SYNC or RESHAPE are set, then it is a recovery.
|
|
*/
|
|
MD_RECOVERY_RUNNING, /* a thread is running, or about to be started */
|
|
MD_RECOVERY_SYNC, /* actually doing a resync, not a recovery */
|
|
MD_RECOVERY_RECOVER, /* doing recovery, or need to try it. */
|
|
MD_RECOVERY_INTR, /* resync needs to be aborted for some reason */
|
|
MD_RECOVERY_DONE, /* thread is done and is waiting to be reaped */
|
|
MD_RECOVERY_NEEDED, /* we might need to start a resync/recover */
|
|
MD_RECOVERY_REQUESTED, /* user-space has requested a sync (used with SYNC) */
|
|
MD_RECOVERY_CHECK, /* user-space request for check-only, no repair */
|
|
MD_RECOVERY_RESHAPE, /* A reshape is happening */
|
|
MD_RECOVERY_FROZEN, /* User request to abort, and not restart, any action */
|
|
MD_RECOVERY_ERROR, /* sync-action interrupted because io-error */
|
|
MD_RECOVERY_WAIT, /* waiting for pers->start() to finish */
|
|
MD_RESYNCING_REMOTE, /* remote node is running resync thread */
|
|
};
|
|
|
|
static inline int __must_check mddev_lock(struct mddev *mddev)
|
|
{
|
|
return mutex_lock_interruptible(&mddev->reconfig_mutex);
|
|
}
|
|
|
|
/* Sometimes we need to take the lock in a situation where
|
|
* failure due to interrupts is not acceptable.
|
|
*/
|
|
static inline void mddev_lock_nointr(struct mddev *mddev)
|
|
{
|
|
mutex_lock(&mddev->reconfig_mutex);
|
|
}
|
|
|
|
static inline int mddev_trylock(struct mddev *mddev)
|
|
{
|
|
return mutex_trylock(&mddev->reconfig_mutex);
|
|
}
|
|
extern void mddev_unlock(struct mddev *mddev);
|
|
|
|
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);
|
|
}
|
|
|
|
static inline void md_sync_acct_bio(struct bio *bio, unsigned long nr_sectors)
|
|
{
|
|
atomic_add(nr_sectors, &bio->bi_disk->sync_io);
|
|
}
|
|
|
|
struct md_personality
|
|
{
|
|
char *name;
|
|
int level;
|
|
struct list_head list;
|
|
struct module *owner;
|
|
bool (*make_request)(struct mddev *mddev, struct bio *bio);
|
|
/*
|
|
* start up works that do NOT require md_thread. tasks that
|
|
* requires md_thread should go into start()
|
|
*/
|
|
int (*run)(struct mddev *mddev);
|
|
/* start up works that require md threads */
|
|
int (*start)(struct mddev *mddev);
|
|
void (*free)(struct mddev *mddev, void *priv);
|
|
void (*status)(struct seq_file *seq, struct mddev *mddev);
|
|
/* error_handler must set ->faulty and clear ->in_sync
|
|
* if appropriate, and should abort recovery if needed
|
|
*/
|
|
void (*error_handler)(struct mddev *mddev, struct md_rdev *rdev);
|
|
int (*hot_add_disk) (struct mddev *mddev, struct md_rdev *rdev);
|
|
int (*hot_remove_disk) (struct mddev *mddev, struct md_rdev *rdev);
|
|
int (*spare_active) (struct mddev *mddev);
|
|
sector_t (*sync_request)(struct mddev *mddev, sector_t sector_nr, int *skipped);
|
|
int (*resize) (struct mddev *mddev, sector_t sectors);
|
|
sector_t (*size) (struct mddev *mddev, sector_t sectors, int raid_disks);
|
|
int (*check_reshape) (struct mddev *mddev);
|
|
int (*start_reshape) (struct mddev *mddev);
|
|
void (*finish_reshape) (struct mddev *mddev);
|
|
void (*update_reshape_pos) (struct mddev *mddev);
|
|
/* quiesce suspends or resumes internal processing.
|
|
* 1 - stop new actions and wait for action io to complete
|
|
* 0 - return to normal behaviour
|
|
*/
|
|
void (*quiesce) (struct mddev *mddev, int quiesce);
|
|
/* 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) (struct mddev *mddev);
|
|
/* congested implements bdi.congested_fn().
|
|
* Will not be called while array is 'suspended' */
|
|
int (*congested)(struct mddev *mddev, int bits);
|
|
/* Changes the consistency policy of an active array. */
|
|
int (*change_consistency_policy)(struct mddev *mddev, const char *buf);
|
|
};
|
|
|
|
struct md_sysfs_entry {
|
|
struct attribute attr;
|
|
ssize_t (*show)(struct mddev *, char *);
|
|
ssize_t (*store)(struct mddev *, const char *, size_t);
|
|
};
|
|
extern struct attribute_group md_bitmap_group;
|
|
|
|
static inline struct kernfs_node *sysfs_get_dirent_safe(struct kernfs_node *sd, char *name)
|
|
{
|
|
if (sd)
|
|
return sysfs_get_dirent(sd, name);
|
|
return sd;
|
|
}
|
|
static inline void sysfs_notify_dirent_safe(struct kernfs_node *sd)
|
|
{
|
|
if (sd)
|
|
sysfs_notify_dirent(sd);
|
|
}
|
|
|
|
static inline char * mdname (struct mddev * mddev)
|
|
{
|
|
return mddev->gendisk ? mddev->gendisk->disk_name : "mdX";
|
|
}
|
|
|
|
static inline int sysfs_link_rdev(struct mddev *mddev, struct md_rdev *rdev)
|
|
{
|
|
char nm[20];
|
|
if (!test_bit(Replacement, &rdev->flags) &&
|
|
!test_bit(Journal, &rdev->flags) &&
|
|
mddev->kobj.sd) {
|
|
sprintf(nm, "rd%d", rdev->raid_disk);
|
|
return sysfs_create_link(&mddev->kobj, &rdev->kobj, nm);
|
|
} else
|
|
return 0;
|
|
}
|
|
|
|
static inline void sysfs_unlink_rdev(struct mddev *mddev, struct md_rdev *rdev)
|
|
{
|
|
char nm[20];
|
|
if (!test_bit(Replacement, &rdev->flags) &&
|
|
!test_bit(Journal, &rdev->flags) &&
|
|
mddev->kobj.sd) {
|
|
sprintf(nm, "rd%d", rdev->raid_disk);
|
|
sysfs_remove_link(&mddev->kobj, nm);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* iterates through some rdev ringlist. It's safe to remove the
|
|
* current 'rdev'. Dont touch 'tmp' though.
|
|
*/
|
|
#define rdev_for_each_list(rdev, tmp, head) \
|
|
list_for_each_entry_safe(rdev, tmp, head, same_set)
|
|
|
|
/*
|
|
* iterates through the 'same array disks' ringlist
|
|
*/
|
|
#define rdev_for_each(rdev, mddev) \
|
|
list_for_each_entry(rdev, &((mddev)->disks), same_set)
|
|
|
|
#define rdev_for_each_safe(rdev, tmp, mddev) \
|
|
list_for_each_entry_safe(rdev, tmp, &((mddev)->disks), same_set)
|
|
|
|
#define rdev_for_each_rcu(rdev, mddev) \
|
|
list_for_each_entry_rcu(rdev, &((mddev)->disks), same_set)
|
|
|
|
struct md_thread {
|
|
void (*run) (struct md_thread *thread);
|
|
struct mddev *mddev;
|
|
wait_queue_head_t wqueue;
|
|
unsigned long flags;
|
|
struct task_struct *tsk;
|
|
unsigned long timeout;
|
|
void *private;
|
|
};
|
|
|
|
#define THREAD_WAKEUP 0
|
|
|
|
static inline void safe_put_page(struct page *p)
|
|
{
|
|
if (p) put_page(p);
|
|
}
|
|
|
|
extern int register_md_personality(struct md_personality *p);
|
|
extern int unregister_md_personality(struct md_personality *p);
|
|
extern int register_md_cluster_operations(struct md_cluster_operations *ops,
|
|
struct module *module);
|
|
extern int unregister_md_cluster_operations(void);
|
|
extern int md_setup_cluster(struct mddev *mddev, int nodes);
|
|
extern void md_cluster_stop(struct mddev *mddev);
|
|
extern struct md_thread *md_register_thread(
|
|
void (*run)(struct md_thread *thread),
|
|
struct mddev *mddev,
|
|
const char *name);
|
|
extern void md_unregister_thread(struct md_thread **threadp);
|
|
extern void md_wakeup_thread(struct md_thread *thread);
|
|
extern void md_check_recovery(struct mddev *mddev);
|
|
extern void md_reap_sync_thread(struct mddev *mddev);
|
|
extern int mddev_init_writes_pending(struct mddev *mddev);
|
|
extern bool md_write_start(struct mddev *mddev, struct bio *bi);
|
|
extern void md_write_inc(struct mddev *mddev, struct bio *bi);
|
|
extern void md_write_end(struct mddev *mddev);
|
|
extern void md_done_sync(struct mddev *mddev, int blocks, int ok);
|
|
extern void md_error(struct mddev *mddev, struct md_rdev *rdev);
|
|
extern void md_finish_reshape(struct mddev *mddev);
|
|
|
|
extern int mddev_congested(struct mddev *mddev, int bits);
|
|
extern void md_flush_request(struct mddev *mddev, struct bio *bio);
|
|
extern void md_super_write(struct mddev *mddev, struct md_rdev *rdev,
|
|
sector_t sector, int size, struct page *page);
|
|
extern int md_super_wait(struct mddev *mddev);
|
|
extern int sync_page_io(struct md_rdev *rdev, sector_t sector, int size,
|
|
struct page *page, int op, int op_flags,
|
|
bool metadata_op);
|
|
extern void md_do_sync(struct md_thread *thread);
|
|
extern void md_new_event(struct mddev *mddev);
|
|
extern void md_allow_write(struct mddev *mddev);
|
|
extern void md_wait_for_blocked_rdev(struct md_rdev *rdev, struct mddev *mddev);
|
|
extern void md_set_array_sectors(struct mddev *mddev, sector_t array_sectors);
|
|
extern int md_check_no_bitmap(struct mddev *mddev);
|
|
extern int md_integrity_register(struct mddev *mddev);
|
|
extern int md_integrity_add_rdev(struct md_rdev *rdev, struct mddev *mddev);
|
|
extern int strict_strtoul_scaled(const char *cp, unsigned long *res, int scale);
|
|
|
|
extern void mddev_init(struct mddev *mddev);
|
|
extern int md_run(struct mddev *mddev);
|
|
extern int md_start(struct mddev *mddev);
|
|
extern void md_stop(struct mddev *mddev);
|
|
extern void md_stop_writes(struct mddev *mddev);
|
|
extern int md_rdev_init(struct md_rdev *rdev);
|
|
extern void md_rdev_clear(struct md_rdev *rdev);
|
|
|
|
extern void md_handle_request(struct mddev *mddev, struct bio *bio);
|
|
extern void mddev_suspend(struct mddev *mddev);
|
|
extern void mddev_resume(struct mddev *mddev);
|
|
extern struct bio *bio_alloc_mddev(gfp_t gfp_mask, int nr_iovecs,
|
|
struct mddev *mddev);
|
|
|
|
extern void md_reload_sb(struct mddev *mddev, int raid_disk);
|
|
extern void md_update_sb(struct mddev *mddev, int force);
|
|
extern void md_kick_rdev_from_array(struct md_rdev * rdev);
|
|
struct md_rdev *md_find_rdev_nr_rcu(struct mddev *mddev, int nr);
|
|
struct md_rdev *md_find_rdev_rcu(struct mddev *mddev, dev_t dev);
|
|
|
|
static inline void rdev_dec_pending(struct md_rdev *rdev, struct mddev *mddev)
|
|
{
|
|
int faulty = test_bit(Faulty, &rdev->flags);
|
|
if (atomic_dec_and_test(&rdev->nr_pending) && faulty) {
|
|
set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
|
|
md_wakeup_thread(mddev->thread);
|
|
}
|
|
}
|
|
|
|
extern struct md_cluster_operations *md_cluster_ops;
|
|
static inline int mddev_is_clustered(struct mddev *mddev)
|
|
{
|
|
return mddev->cluster_info && mddev->bitmap_info.nodes > 1;
|
|
}
|
|
|
|
/* clear unsupported mddev_flags */
|
|
static inline void mddev_clear_unsupported_flags(struct mddev *mddev,
|
|
unsigned long unsupported_flags)
|
|
{
|
|
mddev->flags &= ~unsupported_flags;
|
|
}
|
|
|
|
static inline void mddev_check_writesame(struct mddev *mddev, struct bio *bio)
|
|
{
|
|
if (bio_op(bio) == REQ_OP_WRITE_SAME &&
|
|
!bio->bi_disk->queue->limits.max_write_same_sectors)
|
|
mddev->queue->limits.max_write_same_sectors = 0;
|
|
}
|
|
|
|
static inline void mddev_check_write_zeroes(struct mddev *mddev, struct bio *bio)
|
|
{
|
|
if (bio_op(bio) == REQ_OP_WRITE_ZEROES &&
|
|
!bio->bi_disk->queue->limits.max_write_zeroes_sectors)
|
|
mddev->queue->limits.max_write_zeroes_sectors = 0;
|
|
}
|
|
#endif /* _MD_MD_H */
|