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