include/linux/md.h

   1 /*
   2    md.h : Multiple Devices driver for Linux
   3           Copyright (C) 1994-96 Marc ZYNGIER
   4           <zyngier@ufr-info-p7.ibp.fr> or
   5           <maz@gloups.fdn.fr>
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2, or (at your option)
  10    any later version.
  11
  12    You should have received a copy of the GNU General Public License
  13    (for example /usr/src/linux/COPYING); if not, write to the Free
  14    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  15 */
  16
  17 #ifndef _MD_H
  18 #define _MD_H
  19
  20 #include <linux/major.h>
  21 #include <linux/ioctl.h>
  22 #include <linux/types.h>
  23
  24 /*
  25  * Different major versions are not compatible.
  26  * Different minor versions are only downward compatible.
  27  * Different patchlevel versions are downward and upward compatible.
  28  */
  29 #define MD_MAJOR_VERSION                0
  30 #define MD_MINOR_VERSION                36
  31 #define MD_PATCHLEVEL_VERSION           6
  32
  33 #define MD_DEFAULT_DISK_READAHEAD       (256 * 1024)
  34
  35 /* ioctls */
  36 #define REGISTER_DEV            _IO (MD_MAJOR, 1)
  37 #define START_MD                _IO (MD_MAJOR, 2)
  38 #define STOP_MD                 _IO (MD_MAJOR, 3)
  39 #define REGISTER_DEV_NEW        _IO (MD_MAJOR, 4)
  40
  41 /*
  42    personalities :
  43    Byte 0 : Chunk size factor
  44    Byte 1 : Fault tolerance count for each physical device
  45             (   0 means no fault tolerance,
  46              0xFF means always tolerate faults), not used by now.
  47    Byte 2 : Personality
  48    Byte 3 : Reserved.
  49  */
  50
  51 #define FAULT_SHIFT       8
  52 #define PERSONALITY_SHIFT 16
  53
  54 #define FACTOR_MASK       0x000000FFUL
  55 #define FAULT_MASK        0x0000FF00UL
  56 #define PERSONALITY_MASK  0x00FF0000UL
  57
  58 #define MD_RESERVED       0     /* Not used by now */
  59 #define LINEAR            (1UL << PERSONALITY_SHIFT)
  60 #define STRIPED           (2UL << PERSONALITY_SHIFT)
  61 #define RAID0             STRIPED
  62 #define RAID1             (3UL << PERSONALITY_SHIFT)
  63 #define RAID5             (4UL << PERSONALITY_SHIFT)
  64 #define MAX_PERSONALITY   5
  65
  66 /*
  67  * MD superblock.
  68  *
  69  * The MD superblock maintains some statistics on each MD configuration.
  70  * Each real device in the MD set contains it near the end of the device.
  71  * Some of the ideas are copied from the ext2fs implementation.
  72  *
  73  * We currently use 4096 bytes as follows:
  74  *
  75  *      word offset     function
  76  *
  77  *         0  -    31   Constant generic MD device information.
  78  *        32  -    63   Generic state information.
  79  *        64  -   127   Personality specific information.
  80  *       128  -   511   12 32-words descriptors of the disks in the raid set.
  81  *       512  -   911   Reserved.
  82  *       912  -  1023   Disk specific descriptor.
  83  */
  84
  85 /*
  86  * If x is the real device size in bytes, we return an apparent size of:
  87  *
  88  *      y = (x & ~(MD_RESERVED_BYTES - 1)) - MD_RESERVED_BYTES
  89  *
  90  * and place the 4kB superblock at offset y.
  91  */
  92 #define MD_RESERVED_BYTES               (64 * 1024)
  93 #define MD_RESERVED_SECTORS             (MD_RESERVED_BYTES / 512)
  94 #define MD_RESERVED_BLOCKS              (MD_RESERVED_BYTES / BLOCK_SIZE)
  95
  96 #define MD_NEW_SIZE_SECTORS(x)          ((x & ~(MD_RESERVED_SECTORS - 1)) - MD_RESERVED_SECTORS)
  97 #define MD_NEW_SIZE_BLOCKS(x)           ((x & ~(MD_RESERVED_BLOCKS - 1)) - MD_RESERVED_BLOCKS)
  98
  99 #define MD_SB_BYTES                     4096
 100 #define MD_SB_WORDS                     (MD_SB_BYTES / 4)
 101 #define MD_SB_BLOCKS                    (MD_SB_BYTES / BLOCK_SIZE)
 102 #define MD_SB_SECTORS                   (MD_SB_BYTES / 512)
 103
 104 /*
 105  * The following are counted in 32-bit words
 106  */
 107 #define MD_SB_GENERIC_OFFSET            0
 108 #define MD_SB_PERSONALITY_OFFSET        64
 109 #define MD_SB_DISKS_OFFSET              128
 110 #define MD_SB_DESCRIPTOR_OFFSET         992
 111
 112 #define MD_SB_GENERIC_CONSTANT_WORDS    32
 113 #define MD_SB_GENERIC_STATE_WORDS       32
 114 #define MD_SB_GENERIC_WORDS             (MD_SB_GENERIC_CONSTANT_WORDS + MD_SB_GENERIC_STATE_WORDS)
 115 #define MD_SB_PERSONALITY_WORDS         64
 116 #define MD_SB_DISKS_WORDS               384
 117 #define MD_SB_DESCRIPTOR_WORDS          32
 118 #define MD_SB_RESERVED_WORDS            (1024 - MD_SB_GENERIC_WORDS - MD_SB_PERSONALITY_WORDS - MD_SB_DISKS_WORDS - MD_SB_DESCRIPTOR_WORDS)
 119 #define MD_SB_EQUAL_WORDS               (MD_SB_GENERIC_WORDS + MD_SB_PERSONALITY_WORDS + MD_SB_DISKS_WORDS)
 120 #define MD_SB_DISKS                     (MD_SB_DISKS_WORDS / MD_SB_DESCRIPTOR_WORDS)
 121
 122 /*
 123  * Device "operational" state bits
 124  */
 125 #define MD_FAULTY_DEVICE                0       /* Device is faulty / operational */
 126 #define MD_ACTIVE_DEVICE                1       /* Device is a part or the raid set / spare disk */
 127 #define MD_SYNC_DEVICE                  2       /* Device is in sync with the raid set */
 128
 129 typedef struct md_device_descriptor_s {
 130         __u32 number;           /* 0 Device number in the entire set */
 131         __u32 major;            /* 1 Device major number */
 132         __u32 minor;            /* 2 Device minor number */
 133         __u32 raid_disk;        /* 3 The role of the device in the raid set */
 134         __u32 state;            /* 4 Operational state */
 135         __u32 reserved[MD_SB_DESCRIPTOR_WORDS - 5];
 136 } md_descriptor_t;
 137
 138 #define MD_SB_MAGIC             0xa92b4efc
 139
 140 /*
 141  * Superblock state bits
 142  */
 143 #define MD_SB_CLEAN             0
 144 #define MD_SB_ERRORS            1
 145
 146 typedef struct md_superblock_s {
 147
 148         /*
 149          * Constant generic information
 150          */
 151         __u32 md_magic;         /*  0 MD identifier */
 152         __u32 major_version;    /*  1 major version to which the set conforms */
 153         __u32 minor_version;    /*  2 minor version to which the set conforms */
 154         __u32 patch_version;    /*  3 patchlevel version to which the set conforms */
 155         __u32 gvalid_words;     /*  4 Number of non-reserved words in this section */
 156         __u32 set_magic;        /*  5 Raid set identifier */
 157         __u32 ctime;            /*  6 Creation time */
 158         __u32 level;            /*  7 Raid personality (mirroring, raid5, ...) */
 159         __u32 size;             /*  8 Apparent size of each individual disk, in kB */
 160         __u32 nr_disks;         /*  9 Number of total disks in the raid set */
 161         __u32 raid_disks;       /* 10 Number of disks in a fully functional raid set */
 162         __u32 gstate_creserved[MD_SB_GENERIC_CONSTANT_WORDS - 11];
 163
 164         /*
 165          * Generic state information
 166          */
 167         __u32 utime;            /*  0 Superblock update time */
 168         __u32 state;            /*  1 State bits (clean, ...) */
 169         __u32 active_disks;     /*  2 Number of currently active disks (some non-faulty disks might not be in sync) */
 170         __u32 working_disks;    /*  3 Number of working disks */
 171         __u32 failed_disks;     /*  4 Number of failed disks */
 172         __u32 spare_disks;      /*  5 Number of spare disks */
 173         __u32 gstate_sreserved[MD_SB_GENERIC_STATE_WORDS - 6];
 174
 175         /*
 176          * Personality information
 177          */
 178         __u32 parity_algorithm;
 179         __u32 chunk_size;
 180         __u32 pstate_reserved[MD_SB_PERSONALITY_WORDS - 2];
 181
 182         /*
 183          * Disks information
 184          */
 185         md_descriptor_t disks[MD_SB_DISKS];
 186
 187         /*
 188          * Reserved
 189          */
 190         __u32 reserved[MD_SB_RESERVED_WORDS];
 191
 192         /*
 193          * Active descriptor
 194          */
 195         md_descriptor_t descriptor;
 196 } md_superblock_t;
 197
 198 #ifdef __KERNEL__
 199
 200 #include <linux/mm.h>
 201 #include <linux/fs.h>
 202 #include <linux/blkdev.h>
 203 #include <asm/semaphore.h>
 204
 205 /*
 206  * Kernel-based reconstruction is mostly working, but still requires
 207  * some additional work.
 208  */
 209 #define SUPPORT_RECONSTRUCTION  0
 210
 211 #define MAX_REAL     8          /* Max number of physical dev per md dev */
 212 #define MAX_MD_DEV   4          /* Max number of md dev */
 213
 214 #define FACTOR(a)         ((a)->repartition & FACTOR_MASK)
 215 #define MAX_FAULT(a)      (((a)->repartition & FAULT_MASK)>>8)
 216 #define PERSONALITY(a)    ((a)->repartition & PERSONALITY_MASK)
 217
 218 #define FACTOR_SHIFT(a) (PAGE_SHIFT + (a) - 10)
 219
 220 struct real_dev
 221 {
 222   kdev_t dev;                   /* Device number */
 223   int size;                     /* Device size (in blocks) */
 224   int offset;                   /* Real device offset (in blocks) in md dev
 225                                    (only used in linear mode) */
 226   struct inode *inode;          /* Lock inode */
 227   md_superblock_t *sb;
 228   u32 sb_offset;
 229 };
 230
 231 struct md_dev;
 232
 233 #define SPARE_INACTIVE  0
 234 #define SPARE_WRITE     1
 235 #define SPARE_ACTIVE    2
 236
 237 struct md_personality
 238 {
 239   char *name;
 240   int (*map)(struct md_dev *mddev, kdev_t *rdev,
 241                       unsigned long *rsector, unsigned long size);
 242   int (*make_request)(struct md_dev *mddev, int rw, struct buffer_head * bh);
 243   void (*end_request)(struct buffer_head * bh, int uptodate);
 244   int (*run)(int minor, struct md_dev *mddev);
 245   int (*stop)(int minor, struct md_dev *mddev);
 246   int (*status)(char *page, int minor, struct md_dev *mddev);
 247   int (*ioctl)(struct inode *inode, struct file *file,
 248                unsigned int cmd, unsigned long arg);
 249   int max_invalid_dev;
 250   int (*error_handler)(struct md_dev *mddev, kdev_t dev);
 251
 252 /*
 253  * Some personalities (RAID-1, RAID-5) can get disks hot-added and
 254  * hot-removed. Hot removal is different from failure. (failure marks
 255  * a disk inactive, but the disk is still part of the array)
 256  */
 257   int (*hot_add_disk) (struct md_dev *mddev, kdev_t dev);
 258   int (*hot_remove_disk) (struct md_dev *mddev, kdev_t dev);
 259   int (*mark_spare) (struct md_dev *mddev, md_descriptor_t *descriptor, int state);
 260 };
 261
 262 struct md_dev
 263 {
 264   struct real_dev       devices[MAX_REAL];
 265   struct md_personality *pers;
 266   md_superblock_t       *sb;
 267   int                   sb_dirty;
 268   int                   repartition;
 269   int                   busy;
 270   int                   nb_dev;
 271   void                  *private;
 272 };
 273
 274 struct md_thread {
 275         void                    (*run) (void *data);
 276         void                    *data;
 277         wait_queue_head_t       wqueue;
 278         unsigned long           flags;
 279         struct semaphore        *sem;
 280         struct task_struct      *tsk;
 281 };
 282
 283 #define THREAD_WAKEUP  0
 284
 285 extern struct md_dev md_dev[MAX_MD_DEV];
 286 extern int md_size[MAX_MD_DEV];
 287 extern int md_maxreadahead[MAX_MD_DEV];
 288
 289 extern char *partition_name (kdev_t dev);
 290
 291 extern int register_md_personality (int p_num, struct md_personality *p);
 292 extern int unregister_md_personality (int p_num);
 293 extern struct md_thread *md_register_thread (void (*run) (void *data), void *data);
 294 extern void md_unregister_thread (struct md_thread *thread);
 295 extern void md_wakeup_thread(struct md_thread *thread);
 296 extern int md_update_sb (int minor);
 297 extern int md_do_sync(struct md_dev *mddev);
 298
 299 #endif __KERNEL__
 300 #endif _MD_H