LXR linux/include/linux/genhd.h

   1#ifndef _LINUX_GENHD_H
   2#define _LINUX_GENHD_H
   3
   4/*
   5 *      genhd.h Copyright (C) 1992 Drew Eckhardt
   6 *      Generic hard disk header file by  
   7 *              Drew Eckhardt
   8 *
   9 *              <drew@colorado.edu>
  10 */
  11
  12#include <linux/config.h>
  13#include <linux/types.h>
  14#include <linux/major.h>
  15#include <linux/device.h>
  16#include <linux/smp.h>
  17#include <linux/string.h>
  18#include <linux/fs.h>
  19
  20enum {
  21/* These three have identical behaviour; use the second one if DOS FDISK gets
  22   confused about extended/logical partitions starting past cylinder 1023. */
  23        DOS_EXTENDED_PARTITION = 5,
  24        LINUX_EXTENDED_PARTITION = 0x85,
  25        WIN98_EXTENDED_PARTITION = 0x0f,
  26
  27        LINUX_SWAP_PARTITION = 0x82,
  28        LINUX_RAID_PARTITION = 0xfd,    /* autodetect RAID partition */
  29
  30        SOLARIS_X86_PARTITION = LINUX_SWAP_PARTITION,
  31        NEW_SOLARIS_X86_PARTITION = 0xbf,
  32
  33        DM6_AUX1PARTITION = 0x51,       /* no DDO:  use xlated geom */
  34        DM6_AUX3PARTITION = 0x53,       /* no DDO:  use xlated geom */
  35        DM6_PARTITION = 0x54,           /* has DDO: use xlated geom & offset */
  36        EZD_PARTITION = 0x55,           /* EZ-DRIVE */
  37
  38        FREEBSD_PARTITION = 0xa5,       /* FreeBSD Partition ID */
  39        OPENBSD_PARTITION = 0xa6,       /* OpenBSD Partition ID */
  40        NETBSD_PARTITION = 0xa9,        /* NetBSD Partition ID */
  41        BSDI_PARTITION = 0xb7,          /* BSDI Partition ID */
  42        MINIX_PARTITION = 0x81,         /* Minix Partition ID */
  43        UNIXWARE_PARTITION = 0x63,      /* Same as GNU_HURD and SCO Unix */
  44};
  45
  46#ifndef __KERNEL__
  47
  48struct partition {
  49        unsigned char boot_ind;         /* 0x80 - active */
  50        unsigned char head;             /* starting head */
  51        unsigned char sector;           /* starting sector */
  52        unsigned char cyl;              /* starting cylinder */
  53        unsigned char sys_ind;          /* What partition type */
  54        unsigned char end_head;         /* end head */
  55        unsigned char end_sector;       /* end sector */
  56        unsigned char end_cyl;          /* end cylinder */
  57        unsigned int start_sect;        /* starting sector counting from 0 */
  58        unsigned int nr_sects;          /* nr of sectors in partition */
  59} __attribute__((packed));
  60
  61#endif
  62
  63#ifdef __KERNEL__
  64struct partition {
  65        unsigned char boot_ind;         /* 0x80 - active */
  66        unsigned char head;             /* starting head */
  67        unsigned char sector;           /* starting sector */
  68        unsigned char cyl;              /* starting cylinder */
  69        unsigned char sys_ind;          /* What partition type */
  70        unsigned char end_head;         /* end head */
  71        unsigned char end_sector;       /* end sector */
  72        unsigned char end_cyl;          /* end cylinder */
  73        __le32 start_sect;      /* starting sector counting from 0 */
  74        __le32 nr_sects;                /* nr of sectors in partition */
  75} __attribute__((packed));
  76
  77struct hd_struct {
  78        sector_t start_sect;
  79        sector_t nr_sects;
  80        struct kobject kobj;
  81        unsigned reads, read_sectors, writes, write_sectors;
  82        int policy, partno;
  83};
  84
  85#define GENHD_FL_REMOVABLE                      1
  86#define GENHD_FL_DRIVERFS                       2
  87#define GENHD_FL_CD                             8
  88#define GENHD_FL_UP                             16
  89#define GENHD_FL_SUPPRESS_PARTITION_INFO        32
  90
  91struct disk_stats {
  92        unsigned read_sectors, write_sectors;
  93        unsigned reads, writes;
  94        unsigned read_merges, write_merges;
  95        unsigned read_ticks, write_ticks;
  96        unsigned io_ticks;
  97        unsigned time_in_queue;
  98};
  99        
 100struct gendisk {
 101        int major;                      /* major number of driver */
 102        int first_minor;
 103        int minors;                     /* maximum number of minors, =1 for
 104                                         * disks that can't be partitioned. */
 105        char disk_name[32];             /* name of major driver */
 106        struct hd_struct **part;        /* [indexed by minor] */
 107        struct block_device_operations *fops;
 108        struct request_queue *queue;
 109        void *private_data;
 110        sector_t capacity;
 111
 112        int flags;
 113        char devfs_name[64];            /* devfs crap */
 114        int number;                     /* more of the same */
 115        struct device *driverfs_dev;
 116        struct kobject kobj;
 117
 118        struct timer_rand_state *random;
 119        int policy;
 120
 121        atomic_t sync_io;               /* RAID */
 122        unsigned long stamp, stamp_idle;
 123        int in_flight;
 124#ifdef  CONFIG_SMP
 125        struct disk_stats *dkstats;
 126#else
 127        struct disk_stats dkstats;
 128#endif
 129};
 130
 131/* Structure for sysfs attributes on block devices */
 132struct disk_attribute {
 133        struct attribute attr;
 134        ssize_t (*show)(struct gendisk *, char *);
 135};
 136
 137/* 
 138 * Macros to operate on percpu disk statistics:
 139 *
 140 * The __ variants should only be called in critical sections. The full
 141 * variants disable/enable preemption.
 142 */
 143#ifdef  CONFIG_SMP
 144#define __disk_stat_add(gendiskp, field, addnd)         \
 145        (per_cpu_ptr(gendiskp->dkstats, smp_processor_id())->field += addnd)
 146
 147#define disk_stat_read(gendiskp, field)                                 \
 148({                                                                      \
 149        typeof(gendiskp->dkstats->field) res = 0;                       \
 150        int i;                                                          \
 151        for (i=0; i < NR_CPUS; i++) {                                   \
 152                if (!cpu_possible(i))                                   \
 153                        continue;                                       \
 154                res += per_cpu_ptr(gendiskp->dkstats, i)->field;        \
 155        }                                                               \
 156        res;                                                            \
 157})
 158
 159static inline void disk_stat_set_all(struct gendisk *gendiskp, int value)       {
 160        int i;
 161        for (i=0; i < NR_CPUS; i++) {
 162                if (cpu_possible(i)) {
 163                        memset(per_cpu_ptr(gendiskp->dkstats, i), value,        
 164                                        sizeof (struct disk_stats));
 165                }
 166        }
 167}               
 168                                
 169#else
 170#define __disk_stat_add(gendiskp, field, addnd) \
 171                                (gendiskp->dkstats.field += addnd)
 172#define disk_stat_read(gendiskp, field) (gendiskp->dkstats.field)
 173
 174static inline void disk_stat_set_all(struct gendisk *gendiskp, int value)       {
 175        memset(&gendiskp->dkstats, value, sizeof (struct disk_stats));
 176}
 177#endif
 178
 179#define disk_stat_add(gendiskp, field, addnd)                   \
 180        do {                                                    \
 181                preempt_disable();                              \
 182                __disk_stat_add(gendiskp, field, addnd);        \
 183                preempt_enable();                               \
 184        } while (0)
 185
 186#define __disk_stat_dec(gendiskp, field) __disk_stat_add(gendiskp, field, -1)
 187#define disk_stat_dec(gendiskp, field) disk_stat_add(gendiskp, field, -1)
 188
 189#define __disk_stat_inc(gendiskp, field) __disk_stat_add(gendiskp, field, 1)
 190#define disk_stat_inc(gendiskp, field) disk_stat_add(gendiskp, field, 1)
 191
 192#define __disk_stat_sub(gendiskp, field, subnd) \
 193                __disk_stat_add(gendiskp, field, -subnd)
 194#define disk_stat_sub(gendiskp, field, subnd) \
 195                disk_stat_add(gendiskp, field, -subnd)
 196
 197
 198/* Inlines to alloc and free disk stats in struct gendisk */
 199#ifdef  CONFIG_SMP
 200static inline int init_disk_stats(struct gendisk *disk)
 201{
 202        disk->dkstats = alloc_percpu(struct disk_stats);
 203        if (!disk->dkstats)
 204                return 0;
 205        return 1;
 206}
 207
 208static inline void free_disk_stats(struct gendisk *disk)
 209{
 210        free_percpu(disk->dkstats);
 211}
 212#else   /* CONFIG_SMP */
 213static inline int init_disk_stats(struct gendisk *disk)
 214{
 215        return 1;
 216}
 217
 218static inline void free_disk_stats(struct gendisk *disk)
 219{
 220}
 221#endif  /* CONFIG_SMP */
 222
 223/* drivers/block/ll_rw_blk.c */
 224extern void disk_round_stats(struct gendisk *disk);
 225
 226/* drivers/block/genhd.c */
 227extern int get_blkdev_list(char *);
 228extern void add_disk(struct gendisk *disk);
 229extern void del_gendisk(struct gendisk *gp);
 230extern void unlink_gendisk(struct gendisk *gp);
 231extern struct gendisk *get_gendisk(dev_t dev, int *part);
 232
 233extern void set_device_ro(struct block_device *bdev, int flag);
 234extern void set_disk_ro(struct gendisk *disk, int flag);
 235
 236/* drivers/char/random.c */
 237extern void add_disk_randomness(struct gendisk *disk);
 238extern void rand_initialize_disk(struct gendisk *disk);
 239
 240static inline sector_t get_start_sect(struct block_device *bdev)
 241{
 242        return bdev->bd_contains == bdev ? 0 : bdev->bd_part->start_sect;
 243}
 244static inline sector_t get_capacity(struct gendisk *disk)
 245{
 246        return disk->capacity;
 247}
 248static inline void set_capacity(struct gendisk *disk, sector_t size)
 249{
 250        disk->capacity = size;
 251}
 252
 253#endif  /*  __KERNEL__  */
 254
 255#ifdef CONFIG_SOLARIS_X86_PARTITION
 256
 257#define SOLARIS_X86_NUMSLICE    8
 258#define SOLARIS_X86_VTOC_SANE   (0x600DDEEEUL)
 259
 260struct solaris_x86_slice {
 261        __le16 s_tag;           /* ID tag of partition */
 262        __le16 s_flag;          /* permission flags */
 263        __le32 s_start;         /* start sector no of partition */
 264        __le32 s_size;          /* # of blocks in partition */
 265};
 266
 267struct solaris_x86_vtoc {
 268        unsigned int v_bootinfo[3];     /* info needed by mboot (unsupported) */
 269        __le32 v_sanity;                /* to verify vtoc sanity */
 270        __le32 v_version;               /* layout version */
 271        char    v_volume[8];            /* volume name */
 272        __le16  v_sectorsz;             /* sector size in bytes */
 273        __le16  v_nparts;               /* number of partitions */
 274        unsigned int v_reserved[10];    /* free space */
 275        struct solaris_x86_slice
 276                v_slice[SOLARIS_X86_NUMSLICE]; /* slice headers */
 277        unsigned int timestamp[SOLARIS_X86_NUMSLICE]; /* timestamp (unsupported) */
 278        char    v_asciilabel[128];      /* for compatibility */
 279};
 280
 281#endif /* CONFIG_SOLARIS_X86_PARTITION */
 282
 283#ifdef CONFIG_BSD_DISKLABEL
 284/*
 285 * BSD disklabel support by Yossi Gottlieb <yogo@math.tau.ac.il>
 286 * updated by Marc Espie <Marc.Espie@openbsd.org>
 287 */
 288
 289/* check against BSD src/sys/sys/disklabel.h for consistency */
 290
 291#define BSD_DISKMAGIC   (0x82564557UL)  /* The disk magic number */
 292#define BSD_MAXPARTITIONS       16
 293#define OPENBSD_MAXPARTITIONS   16
 294#define BSD_FS_UNUSED           0       /* disklabel unused partition entry ID */
 295struct bsd_disklabel {
 296        __le32  d_magic;                /* the magic number */
 297        __s16   d_type;                 /* drive type */
 298        __s16   d_subtype;              /* controller/d_type specific */
 299        char    d_typename[16];         /* type name, e.g. "eagle" */
 300        char    d_packname[16];                 /* pack identifier */ 
 301        __u32   d_secsize;              /* # of bytes per sector */
 302        __u32   d_nsectors;             /* # of data sectors per track */
 303        __u32   d_ntracks;              /* # of tracks per cylinder */
 304        __u32   d_ncylinders;           /* # of data cylinders per unit */
 305        __u32   d_secpercyl;            /* # of data sectors per cylinder */
 306        __u32   d_secperunit;           /* # of data sectors per unit */
 307        __u16   d_sparespertrack;       /* # of spare sectors per track */
 308        __u16   d_sparespercyl;         /* # of spare sectors per cylinder */
 309        __u32   d_acylinders;           /* # of alt. cylinders per unit */
 310        __u16   d_rpm;                  /* rotational speed */
 311        __u16   d_interleave;           /* hardware sector interleave */
 312        __u16   d_trackskew;            /* sector 0 skew, per track */
 313        __u16   d_cylskew;              /* sector 0 skew, per cylinder */
 314        __u32   d_headswitch;           /* head switch time, usec */
 315        __u32   d_trkseek;              /* track-to-track seek, usec */
 316        __u32   d_flags;                /* generic flags */
 317#define NDDATA 5
 318        __u32   d_drivedata[NDDATA];    /* drive-type specific information */
 319#define NSPARE 5
 320        __u32   d_spare[NSPARE];        /* reserved for future use */
 321        __le32  d_magic2;               /* the magic number (again) */
 322        __le16  d_checksum;             /* xor of data incl. partitions */
 323
 324                        /* filesystem and partition information: */
 325        __le16  d_npartitions;          /* number of partitions in following */
 326        __le32  d_bbsize;               /* size of boot area at sn0, bytes */
 327        __le32  d_sbsize;               /* max size of fs superblock, bytes */
 328        struct  bsd_partition {         /* the partition table */
 329                __le32  p_size;         /* number of sectors in partition */
 330                __le32  p_offset;       /* starting sector */
 331                __le32  p_fsize;        /* filesystem basic fragment size */
 332                __u8    p_fstype;       /* filesystem type, see below */
 333                __u8    p_frag;         /* filesystem fragments per block */
 334                __le16  p_cpg;          /* filesystem cylinders per group */
 335        } d_partitions[BSD_MAXPARTITIONS];      /* actually may be more */
 336};
 337
 338#endif  /* CONFIG_BSD_DISKLABEL */
 339
 340#ifdef CONFIG_UNIXWARE_DISKLABEL
 341/*
 342 * Unixware slices support by Andrzej Krzysztofowicz <ankry@mif.pg.gda.pl>
 343 * and Krzysztof G. Baranowski <kgb@knm.org.pl>
 344 */
 345
 346#define UNIXWARE_DISKMAGIC     (0xCA5E600DUL)   /* The disk magic number */
 347#define UNIXWARE_DISKMAGIC2    (0x600DDEEEUL)   /* The slice table magic nr */
 348#define UNIXWARE_NUMSLICE      16
 349#define UNIXWARE_FS_UNUSED     0                /* Unused slice entry ID */
 350
 351struct unixware_slice {
 352        __le16   s_label;       /* label */
 353        __le16   s_flags;       /* permission flags */
 354        __le32   start_sect;    /* starting sector */
 355        __le32   nr_sects;      /* number of sectors in slice */
 356};
 357
 358struct unixware_disklabel {
 359        __le32   d_type;                /* drive type */
 360        __le32   d_magic;                /* the magic number */
 361        __le32   d_version;              /* version number */
 362        char    d_serial[12];           /* serial number of the device */
 363        __le32   d_ncylinders;           /* # of data cylinders per device */
 364        __le32   d_ntracks;              /* # of tracks per cylinder */
 365        __le32   d_nsectors;             /* # of data sectors per track */
 366        __le32   d_secsize;              /* # of bytes per sector */
 367        __le32   d_part_start;           /* # of first sector of this partition */
 368        __le32   d_unknown1[12];         /* ? */
 369        __le32  d_alt_tbl;              /* byte offset of alternate table */
 370        __le32  d_alt_len;              /* byte length of alternate table */
 371        __le32  d_phys_cyl;             /* # of physical cylinders per device */
 372        __le32  d_phys_trk;             /* # of physical tracks per cylinder */
 373        __le32  d_phys_sec;             /* # of physical sectors per track */
 374        __le32  d_phys_bytes;           /* # of physical bytes per sector */
 375        __le32  d_unknown2;             /* ? */
 376        __le32   d_unknown3;             /* ? */
 377        __le32  d_pad[8];               /* pad */
 378
 379        struct unixware_vtoc {
 380                __le32  v_magic;                /* the magic number */
 381                __le32  v_version;              /* version number */
 382                char    v_name[8];              /* volume name */
 383                __le16  v_nslices;              /* # of slices */
 384                __le16  v_unknown1;             /* ? */
 385                __le32  v_reserved[10];         /* reserved */
 386                struct unixware_slice
 387                        v_slice[UNIXWARE_NUMSLICE];     /* slice headers */
 388        } vtoc;
 389
 390};  /* 408 */
 391
 392#endif /* CONFIG_UNIXWARE_DISKLABEL */
 393
 394#ifdef CONFIG_MINIX_SUBPARTITION
 395#   define MINIX_NR_SUBPARTITIONS  4
 396#endif /* CONFIG_MINIX_SUBPARTITION */
 397
 398#ifdef __KERNEL__
 399
 400char *disk_name (struct gendisk *hd, int part, char *buf);
 401
 402extern int rescan_partitions(struct gendisk *disk, struct block_device *bdev);
 403extern void add_partition(struct gendisk *, int, sector_t, sector_t);
 404extern void delete_partition(struct gendisk *, int);
 405
 406extern struct gendisk *alloc_disk(int minors);
 407extern struct kobject *get_disk(struct gendisk *disk);
 408extern void put_disk(struct gendisk *disk);
 409
 410extern void blk_register_region(dev_t dev, unsigned long range,
 411                        struct module *module,
 412                        struct kobject *(*probe)(dev_t, int *, void *),
 413                        int (*lock)(dev_t, void *),
 414                        void *data);
 415extern void blk_unregister_region(dev_t dev, unsigned long range);
 416
 417static inline struct block_device *bdget_disk(struct gendisk *disk, int index)
 418{
 419        return bdget(MKDEV(disk->major, disk->first_minor) + index);
 420}
 421
 422#endif
 423
 424#endif
 425