include/linux/raid/md_k.h

   1 /*
   2    md_k.h : kernel internal structure of the Linux MD driver
   3           Copyright (C) 1996-98 Ingo Molnar, Gadi Oxman
   4
   5    This program is free software; you can redistribute it and/or modify
   6    it under the terms of the GNU General Public License as published by
   7    the Free Software Foundation; either version 2, or (at your option)
   8    any later version.
   9
  10    You should have received a copy of the GNU General Public License
  11    (for example /usr/src/linux/COPYING); if not, write to the Free
  12    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  13 */
  14
  15 #ifndef _MD_K_H
  16 #define _MD_K_H
  17
  18 #define MD_RESERVED       0UL
  19 #define LINEAR            1UL
  20 #define STRIPED           2UL
  21 #define RAID0             STRIPED
  22 #define RAID1             3UL
  23 #define RAID5             4UL
  24 #define TRANSLUCENT       5UL
  25 #define HSM               6UL
  26 #define MAX_PERSONALITY   7UL
  27
  28 extern inline int pers_to_level (int pers)
  29 {
  30         switch (pers) {
  31                 case HSM:               return -3;
  32                 case TRANSLUCENT:       return -2;
  33                 case LINEAR:            return -1;
  34                 case RAID0:             return 0;
  35                 case RAID1:             return 1;
  36                 case RAID5:             return 5;
  37         }
  38         panic("pers_to_level()");
  39 }
  40
  41 extern inline int level_to_pers (int level)
  42 {
  43         switch (level) {
  44                 case -3: return HSM;
  45                 case -2: return TRANSLUCENT;
  46                 case -1: return LINEAR;
  47                 case 0: return RAID0;
  48                 case 1: return RAID1;
  49                 case 4:
  50                 case 5: return RAID5;
  51         }
  52         return MD_RESERVED;
  53 }
  54
  55 typedef struct mddev_s mddev_t;
  56 typedef struct mdk_rdev_s mdk_rdev_t;
  57
  58 #if (MINORBITS != 8)
  59 #error MD doesnt handle bigger kdev yet
  60 #endif
  61
  62 #define MAX_MD_DEVS  (1<<MINORBITS)     /* Max number of md dev */
  63
  64 /*
  65  * Maps a kdev to an mddev/subdev. How 'data' is handled is up to
  66  * the personality. (eg. HSM uses this to identify individual LVs)
  67  */
  68 typedef struct dev_mapping_s {
  69         mddev_t *mddev;
  70         void *data;
  71 } dev_mapping_t;
  72
  73 extern dev_mapping_t mddev_map [MAX_MD_DEVS];
  74
  75 extern inline mddev_t * kdev_to_mddev (kdev_t dev)
  76 {
  77         if (MAJOR(dev) != MD_MAJOR)
  78                 BUG();
  79         return mddev_map[MINOR(dev)].mddev;
  80 }
  81
  82 /*
  83  * options passed in raidrun:
  84  */
  85
  86 #define MAX_CHUNK_SIZE (4096*1024)
  87
  88 /*
  89  * default readahead
  90  */
  91 #define MD_READAHEAD    MAX_READAHEAD
  92
  93 extern inline int disk_faulty(mdp_disk_t * d)
  94 {
  95         return d->state & (1 << MD_DISK_FAULTY);
  96 }
  97
  98 extern inline int disk_active(mdp_disk_t * d)
  99 {
 100         return d->state & (1 << MD_DISK_ACTIVE);
 101 }
 102
 103 extern inline int disk_sync(mdp_disk_t * d)
 104 {
 105         return d->state & (1 << MD_DISK_SYNC);
 106 }
 107
 108 extern inline int disk_spare(mdp_disk_t * d)
 109 {
 110         return !disk_sync(d) && !disk_active(d) && !disk_faulty(d);
 111 }
 112
 113 extern inline int disk_removed(mdp_disk_t * d)
 114 {
 115         return d->state & (1 << MD_DISK_REMOVED);
 116 }
 117
 118 extern inline void mark_disk_faulty(mdp_disk_t * d)
 119 {
 120         d->state |= (1 << MD_DISK_FAULTY);
 121 }
 122
 123 extern inline void mark_disk_active(mdp_disk_t * d)
 124 {
 125         d->state |= (1 << MD_DISK_ACTIVE);
 126 }
 127
 128 extern inline void mark_disk_sync(mdp_disk_t * d)
 129 {
 130         d->state |= (1 << MD_DISK_SYNC);
 131 }
 132
 133 extern inline void mark_disk_spare(mdp_disk_t * d)
 134 {
 135         d->state = 0;
 136 }
 137
 138 extern inline void mark_disk_removed(mdp_disk_t * d)
 139 {
 140         d->state = (1 << MD_DISK_FAULTY) | (1 << MD_DISK_REMOVED);
 141 }
 142
 143 extern inline void mark_disk_inactive(mdp_disk_t * d)
 144 {
 145         d->state &= ~(1 << MD_DISK_ACTIVE);
 146 }
 147
 148 extern inline void mark_disk_nonsync(mdp_disk_t * d)
 149 {
 150         d->state &= ~(1 << MD_DISK_SYNC);
 151 }
 152
 153 /*
 154  * MD's 'extended' device
 155  */
 156 struct mdk_rdev_s
 157 {
 158         struct md_list_head same_set;   /* RAID devices within the same set */
 159         struct md_list_head all;        /* all RAID devices */
 160         struct md_list_head pending;    /* undetected RAID devices */
 161
 162         kdev_t dev;                     /* Device number */
 163         kdev_t old_dev;                 /*  "" when it was last imported */
 164         unsigned long size;             /* Device size (in blocks) */
 165         mddev_t *mddev;                 /* RAID array if running */
 166         unsigned long last_events;      /* IO event timestamp */
 167
 168         struct block_device *bdev;      /* block device handle */
 169
 170         mdp_super_t *sb;
 171         unsigned long sb_offset;
 172
 173         int faulty;                     /* if faulty do not issue IO requests */
 174         int desc_nr;                    /* descriptor index in the superblock */
 175 };
 176
 177
 178 /*
 179  * disk operations in a working array:
 180  */
 181 #define DISKOP_SPARE_INACTIVE   0
 182 #define DISKOP_SPARE_WRITE      1
 183 #define DISKOP_SPARE_ACTIVE     2
 184 #define DISKOP_HOT_REMOVE_DISK  3
 185 #define DISKOP_HOT_ADD_DISK     4
 186
 187 typedef struct mdk_personality_s mdk_personality_t;
 188
 189 struct mddev_s
 190 {
 191         void                            *private;
 192         mdk_personality_t               *pers;
 193         int                             __minor;
 194         mdp_super_t                     *sb;
 195         int                             nb_dev;
 196         struct md_list_head             disks;
 197         int                             sb_dirty;
 198         mdu_param_t                     param;
 199         int                             ro;
 200         unsigned long                   curr_resync;    /* blocks scheduled */
 201         unsigned long                   resync_mark;    /* a recent timestamp */
 202         unsigned long                   resync_mark_cnt;/* blocks written at resync_mark */
 203         char                            *name;
 204         int                             recovery_running;
 205         struct semaphore                reconfig_sem;
 206         struct semaphore                recovery_sem;
 207         struct semaphore                resync_sem;
 208         atomic_t                        active;
 209
 210         atomic_t                        recovery_active; /* blocks scheduled, but not written */
 211         md_wait_queue_head_t            recovery_wait;
 212
 213         struct md_list_head             all_mddevs;
 214 };
 215
 216 struct mdk_personality_s
 217 {
 218         char *name;
 219         int (*make_request)(mddev_t *mddev, int rw, struct buffer_head * bh);
 220         int (*run)(mddev_t *mddev);
 221         int (*stop)(mddev_t *mddev);
 222         int (*status)(char *page, mddev_t *mddev);
 223         int (*error_handler)(mddev_t *mddev, kdev_t dev);
 224
 225 /*
 226  * Some personalities (RAID-1, RAID-5) can have disks hot-added and
 227  * hot-removed. Hot removal is different from failure. (failure marks
 228  * a disk inactive, but the disk is still part of the array) The interface
 229  * to such operations is the 'pers->diskop()' function, can be NULL.
 230  *
 231  * the diskop function can change the pointer pointing to the incoming
 232  * descriptor, but must do so very carefully. (currently only
 233  * SPARE_ACTIVE expects such a change)
 234  */
 235         int (*diskop) (mddev_t *mddev, mdp_disk_t **descriptor, int state);
 236
 237         int (*stop_resync)(mddev_t *mddev);
 238         int (*restart_resync)(mddev_t *mddev);
 239         int (*sync_request)(mddev_t *mddev, unsigned long block_nr);
 240 };
 241
 242
 243 /*
 244  * Currently we index md_array directly, based on the minor
 245  * number. This will have to change to dynamic allocation
 246  * once we start supporting partitioning of md devices.
 247  */
 248 extern inline int mdidx (mddev_t * mddev)
 249 {
 250         return mddev->__minor;
 251 }
 252
 253 extern inline kdev_t mddev_to_kdev(mddev_t * mddev)
 254 {
 255         return MKDEV(MD_MAJOR, mdidx(mddev));
 256 }
 257
 258 extern mdk_rdev_t * find_rdev(mddev_t * mddev, kdev_t dev);
 259 extern mdk_rdev_t * find_rdev_nr(mddev_t *mddev, int nr);
 260
 261 /*
 262  * iterates through some rdev ringlist. It's safe to remove the
 263  * current 'rdev'. Dont touch 'tmp' though.
 264  */
 265 #define ITERATE_RDEV_GENERIC(head,field,rdev,tmp)                       \
 266                                                                         \
 267         for (tmp = head.next;                                           \
 268                 rdev = md_list_entry(tmp, mdk_rdev_t, field),           \
 269                         tmp = tmp->next, tmp->prev != &head             \
 270                 ; )
 271 /*
 272  * iterates through the 'same array disks' ringlist
 273  */
 274 #define ITERATE_RDEV(mddev,rdev,tmp)                                    \
 275         ITERATE_RDEV_GENERIC((mddev)->disks,same_set,rdev,tmp)
 276
 277 /*
 278  * Same as above, but assumes that the device has rdev->desc_nr numbered
 279  * from 0 to mddev->nb_dev, and iterates through rdevs in ascending order.
 280  */
 281 #define ITERATE_RDEV_ORDERED(mddev,rdev,i)                              \
 282         for (i = 0; rdev = find_rdev_nr(mddev, i), i < mddev->nb_dev; i++)
 283
 284
 285 /*
 286  * Iterates through all 'RAID managed disks'
 287  */
 288 #define ITERATE_RDEV_ALL(rdev,tmp)                                      \
 289         ITERATE_RDEV_GENERIC(all_raid_disks,all,rdev,tmp)
 290
 291 /*
 292  * Iterates through 'pending RAID disks'
 293  */
 294 #define ITERATE_RDEV_PENDING(rdev,tmp)                                  \
 295         ITERATE_RDEV_GENERIC(pending_raid_disks,pending,rdev,tmp)
 296
 297 /*
 298  * iterates through all used mddevs in the system.
 299  */
 300 #define ITERATE_MDDEV(mddev,tmp)                                        \
 301                                                                         \
 302         for (tmp = all_mddevs.next;                                     \
 303                 mddev = md_list_entry(tmp, mddev_t, all_mddevs),        \
 304                         tmp = tmp->next, tmp->prev != &all_mddevs       \
 305                 ; )
 306
 307 extern inline int lock_mddev (mddev_t * mddev)
 308 {
 309         return down_interruptible(&mddev->reconfig_sem);
 310 }
 311
 312 extern inline void unlock_mddev (mddev_t * mddev)
 313 {
 314         up(&mddev->reconfig_sem);
 315 }
 316
 317 #define xchg_values(x,y) do { __typeof__(x) __tmp = x; \
 318                                 x = y; y = __tmp; } while (0)
 319
 320 typedef struct mdk_thread_s {
 321         void                    (*run) (void *data);
 322         void                    *data;
 323         md_wait_queue_head_t    wqueue;
 324         unsigned long           flags;
 325         struct semaphore        *sem;
 326         struct task_struct      *tsk;
 327         const char              *name;
 328 } mdk_thread_t;
 329
 330 #define THREAD_WAKEUP  0
 331
 332 #define MAX_DISKNAME_LEN 64
 333
 334 typedef struct dev_name_s {
 335         struct md_list_head list;
 336         kdev_t dev;
 337         char namebuf [MAX_DISKNAME_LEN];
 338         char *name;
 339 } dev_name_t;
 340
 341
 342 #define __wait_event_lock_irq(wq, condition, lock)                      \
 343 do {                                                                    \
 344         wait_queue_t __wait;                                            \
 345         init_waitqueue_entry(&__wait, current);                         \
 346                                                                         \
 347         add_wait_queue(&wq, &__wait);                                   \
 348         for (;;) {                                                      \
 349                 set_current_state(TASK_UNINTERRUPTIBLE);                \
 350                 if (condition)                                          \
 351                         break;                                          \
 352                 spin_unlock_irq(&lock);                                 \
 353                 run_task_queue(&tq_disk);                               \
 354                 schedule();                                             \
 355                 spin_lock_irq(&lock);                                   \
 356         }                                                               \
 357         current->state = TASK_RUNNING;                                  \
 358         remove_wait_queue(&wq, &__wait);                                \
 359 } while (0)
 360
 361 #define wait_event_lock_irq(wq, condition, lock)                        \
 362 do {                                                                    \
 363         if (condition)                                                  \
 364                 break;                                                  \
 365         __wait_event_lock_irq(wq, condition, lock);                     \
 366 } while (0)
 367
 368 #endif
 369