LCOV - code coverage report
Current view: top level - include/linux - genhd.h (source / functions) Hit Total Coverage
Test: coverage.info Lines: 11 11 100.0 %
Date: 2017-01-25 Functions: 3 3 100.0 %

          Line data    Source code
       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/types.h>
      13             : #include <linux/kdev_t.h>
      14             : #include <linux/rcupdate.h>
      15             : 
      16             : #ifdef CONFIG_BLOCK
      17             : 
      18             : #define kobj_to_dev(k)          container_of((k), struct device, kobj)
      19             : #define dev_to_disk(device)     container_of((device), struct gendisk, part0.__dev)
      20             : #define dev_to_part(device)     container_of((device), struct hd_struct, __dev)
      21             : #define disk_to_dev(disk)       (&(disk)->part0.__dev)
      22             : #define part_to_dev(part)       (&((part)->__dev))
      23             : 
      24           1 : extern struct device_type part_type;
      25             : extern struct kobject *block_depr;
      26           1 : extern struct class block_class;
      27             : 
      28             : enum {
      29             : /* These three have identical behaviour; use the second one if DOS FDISK gets
      30             :    confused about extended/logical partitions starting past cylinder 1023. */
      31             :         DOS_EXTENDED_PARTITION = 5,
      32             :         LINUX_EXTENDED_PARTITION = 0x85,
      33             :         WIN98_EXTENDED_PARTITION = 0x0f,
      34             : 
      35             :         SUN_WHOLE_DISK = DOS_EXTENDED_PARTITION,
      36             : 
      37             :         LINUX_SWAP_PARTITION = 0x82,
      38             :         LINUX_DATA_PARTITION = 0x83,
      39             :         LINUX_LVM_PARTITION = 0x8e,
      40             :         LINUX_RAID_PARTITION = 0xfd,    /* autodetect RAID partition */
      41             : 
      42             :         SOLARIS_X86_PARTITION = LINUX_SWAP_PARTITION,
      43             :         NEW_SOLARIS_X86_PARTITION = 0xbf,
      44             : 
      45             :         DM6_AUX1PARTITION = 0x51,       /* no DDO:  use xlated geom */
      46             :         DM6_AUX3PARTITION = 0x53,       /* no DDO:  use xlated geom */
      47             :         DM6_PARTITION = 0x54,           /* has DDO: use xlated geom & offset */
      48             :         EZD_PARTITION = 0x55,           /* EZ-DRIVE */
      49             : 
      50           1 :         FREEBSD_PARTITION = 0xa5,       /* FreeBSD Partition ID */
      51             :         OPENBSD_PARTITION = 0xa6,       /* OpenBSD Partition ID */
      52             :         NETBSD_PARTITION = 0xa9,        /* NetBSD Partition ID */
      53             :         BSDI_PARTITION = 0xb7,          /* BSDI Partition ID */
      54             :         MINIX_PARTITION = 0x81,         /* Minix Partition ID */
      55             :         UNIXWARE_PARTITION = 0x63,      /* Same as GNU_HURD and SCO Unix */
      56             : };
      57             : 
      58             : #define DISK_MAX_PARTS                  256
      59             : #define DISK_NAME_LEN                   32
      60             : 
      61             : #include <linux/major.h>
      62             : #include <linux/device.h>
      63             : #include <linux/smp.h>
      64             : #include <linux/string.h>
      65             : #include <linux/fs.h>
      66             : #include <linux/workqueue.h>
      67             : 
      68             : struct partition {
      69             :         unsigned char boot_ind;         /* 0x80 - active */
      70             :         unsigned char head;             /* starting head */
      71             :         unsigned char sector;           /* starting sector */
      72             :         unsigned char cyl;              /* starting cylinder */
      73             :         unsigned char sys_ind;          /* What partition type */
      74             :         unsigned char end_head;         /* end head */
      75             :         unsigned char end_sector;       /* end sector */
      76             :         unsigned char end_cyl;          /* end cylinder */
      77             :         __le32 start_sect;      /* starting sector counting from 0 */
      78             :         __le32 nr_sects;                /* nr of sectors in partition */
      79             : } __attribute__((packed));
      80           1 : 
      81             : struct disk_stats {
      82             :         unsigned long sectors[2];       /* READs and WRITEs */
      83             :         unsigned long ios[2];
      84             :         unsigned long merges[2];
      85             :         unsigned long ticks[2];
      86             :         unsigned long io_ticks;
      87             :         unsigned long time_in_queue;
      88             : };
      89           1 :         
      90             : struct hd_struct {
      91             :         sector_t start_sect;
      92             :         sector_t nr_sects;
      93             :         sector_t alignment_offset;
      94             :         unsigned int discard_alignment;
      95             :         struct device __dev;
      96             :         struct kobject *holder_dir;
      97             :         int policy, partno;
      98             : #ifdef CONFIG_FAIL_MAKE_REQUEST
      99             :         int make_it_fail;
     100             : #endif
     101             :         unsigned long stamp;
     102             :         int in_flight[2];
     103             : #ifdef  CONFIG_SMP
     104             :         struct disk_stats *dkstats;
     105             : #else
     106             :         struct disk_stats dkstats;
     107             : #endif
     108             :         struct rcu_head rcu_head;
     109             : };
     110             : 
     111             : #define GENHD_FL_REMOVABLE                      1
     112             : #define GENHD_FL_DRIVERFS                       2
     113             : #define GENHD_FL_MEDIA_CHANGE_NOTIFY            4
     114             : #define GENHD_FL_CD                             8
     115             : #define GENHD_FL_UP                             16
     116             : #define GENHD_FL_SUPPRESS_PARTITION_INFO        32
     117             : #define GENHD_FL_EXT_DEVT                       64 /* allow extended devt */
     118             : #define GENHD_FL_NATIVE_CAPACITY                128
     119             : 
     120             : #define BLK_SCSI_MAX_CMDS       (256)
     121             : #define BLK_SCSI_CMD_PER_LONG   (BLK_SCSI_MAX_CMDS / (sizeof(long) * 8))
     122             : 
     123             : struct blk_scsi_cmd_filter {
     124             :         unsigned long read_ok[BLK_SCSI_CMD_PER_LONG];
     125             :         unsigned long write_ok[BLK_SCSI_CMD_PER_LONG];
     126             :         struct kobject kobj;
     127             : };
     128           1 : 
     129             : struct disk_part_tbl {
     130             :         struct rcu_head rcu_head;
     131             :         int len;
     132             :         struct hd_struct *last_lookup;
     133             :         struct hd_struct *part[];
     134             : };
     135           3 : 
     136             : struct gendisk {
     137             :         /* major, first_minor and minors are input parameters only,
     138             :          * don't use directly.  Use disk_devt() and disk_max_parts().
     139             :          */
     140             :         int major;                      /* major number of driver */
     141             :         int first_minor;
     142             :         int minors;                     /* maximum number of minors, =1 for
     143             :                                          * disks that can't be partitioned. */
     144             : 
     145             :         char disk_name[DISK_NAME_LEN];  /* name of major driver */
     146             :         char *(*devnode)(struct gendisk *gd, mode_t *mode);
     147             :         /* Array of pointers to partitions indexed by partno.
     148             :          * Protected with matching bdev lock but stat and other
     149             :          * non-critical accesses use RCU.  Always access through
     150             :          * helpers.
     151             :          */
     152             :         struct disk_part_tbl *part_tbl;
     153             :         struct hd_struct part0;
     154             : 
     155             :         const struct block_device_operations *fops;
     156             :         struct request_queue *queue;
     157             :         void *private_data;
     158             : 
     159             :         int flags;
     160             :         struct device *driverfs_dev;  // FIXME: remove
     161             :         struct kobject *slave_dir;
     162             : 
     163             :         struct timer_rand_state *random;
     164             : 
     165             :         atomic_t sync_io;               /* RAID */
     166             :         struct work_struct async_notify;
     167             : #ifdef  CONFIG_BLK_DEV_INTEGRITY
     168             :         struct blk_integrity *integrity;
     169             : #endif
     170             :         int node_id;
     171             : };
     172             : 
     173             : static inline struct gendisk *part_to_disk(struct hd_struct *part)
     174             : {
     175             :         if (likely(part)) {
     176             :                 if (part->partno)
     177             :                         return dev_to_disk(part_to_dev(part)->parent);
     178             :                 else
     179             :                         return dev_to_disk(part_to_dev(part));
     180             :         }
     181             :         return NULL;
     182             : }
     183             : 
     184             : static inline int disk_max_parts(struct gendisk *disk)
     185             : {
     186             :         if (disk->flags & GENHD_FL_EXT_DEVT)
     187             :                 return DISK_MAX_PARTS;
     188             :         return disk->minors;
     189             : }
     190             : 
     191             : static inline bool disk_partitionable(struct gendisk *disk)
     192             : {
     193             :         return disk_max_parts(disk) > 1;
     194             : }
     195             : 
     196             : static inline dev_t disk_devt(struct gendisk *disk)
     197             : {
     198           8 :         return disk_to_dev(disk)->devt;
     199             : }
     200             : 
     201             : static inline dev_t part_devt(struct hd_struct *part)
     202             : {
     203             :         return part_to_dev(part)->devt;
     204             : }
     205             : 
     206             : extern struct hd_struct *disk_get_part(struct gendisk *disk, int partno);
     207             : 
     208             : static inline void disk_put_part(struct hd_struct *part)
     209             : {
     210             :         if (likely(part))
     211             :                 put_device(part_to_dev(part));
     212             : }
     213             : 
     214             : /*
     215             :  * Smarter partition iterator without context limits.
     216             :  */
     217             : #define DISK_PITER_REVERSE      (1 << 0) /* iterate in the reverse direction */
     218             : #define DISK_PITER_INCL_EMPTY   (1 << 1) /* include 0-sized parts */
     219             : #define DISK_PITER_INCL_PART0   (1 << 2) /* include partition 0 */
     220             : #define DISK_PITER_INCL_EMPTY_PART0 (1 << 3) /* include empty partition 0 */
     221             : 
     222             : struct disk_part_iter {
     223             :         struct gendisk          *disk;
     224             :         struct hd_struct        *part;
     225             :         int                     idx;
     226             :         unsigned int            flags;
     227             : };
     228             : 
     229             : extern void disk_part_iter_init(struct disk_part_iter *piter,
     230             :                                  struct gendisk *disk, unsigned int flags);
     231             : extern struct hd_struct *disk_part_iter_next(struct disk_part_iter *piter);
     232             : extern void disk_part_iter_exit(struct disk_part_iter *piter);
     233             : 
     234             : extern struct hd_struct *disk_map_sector_rcu(struct gendisk *disk,
     235             :                                              sector_t sector);
     236             : 
     237             : /*
     238             :  * Macros to operate on percpu disk statistics:
     239             :  *
     240             :  * {disk|part|all}_stat_{add|sub|inc|dec}() modify the stat counters
     241             :  * and should be called between disk_stat_lock() and
     242             :  * disk_stat_unlock().
     243             :  *
     244             :  * part_stat_read() can be called at any time.
     245             :  *
     246             :  * part_stat_{add|set_all}() and {init|free}_part_stats are for
     247             :  * internal use only.
     248             :  */
     249             : #ifdef  CONFIG_SMP
     250             : #define part_stat_lock()        ({ rcu_read_lock(); get_cpu(); })
     251             : #define part_stat_unlock()      do { put_cpu(); rcu_read_unlock(); } while (0)
     252             : 
     253             : #define __part_stat_add(cpu, part, field, addnd)                        \
     254             :         (per_cpu_ptr((part)->dkstats, (cpu))->field += (addnd))
     255             : 
     256             : #define part_stat_read(part, field)                                     \
     257             : ({                                                                      \
     258             :         typeof((part)->dkstats->field) res = 0;                           \
     259             :         unsigned int _cpu;                                              \
     260             :         for_each_possible_cpu(_cpu)                                     \
     261             :                 res += per_cpu_ptr((part)->dkstats, _cpu)->field; \
     262             :         res;                                                            \
     263             : })
     264             : 
     265             : static inline void part_stat_set_all(struct hd_struct *part, int value)
     266             : {
     267             :         int i;
     268             : 
     269             :         for_each_possible_cpu(i)
     270             :                 memset(per_cpu_ptr(part->dkstats, i), value,
     271             :                                 sizeof(struct disk_stats));
     272             : }
     273             : 
     274             : static inline int init_part_stats(struct hd_struct *part)
     275             : {
     276             :         part->dkstats = alloc_percpu(struct disk_stats);
     277             :         if (!part->dkstats)
     278             :                 return 0;
     279             :         return 1;
     280             : }
     281             : 
     282             : static inline void free_part_stats(struct hd_struct *part)
     283             : {
     284             :         free_percpu(part->dkstats);
     285             : }
     286             : 
     287             : #else /* !CONFIG_SMP */
     288             : #define part_stat_lock()        ({ rcu_read_lock(); 0; })
     289             : #define part_stat_unlock()      rcu_read_unlock()
     290             : 
     291             : #define __part_stat_add(cpu, part, field, addnd)                                \
     292             :         ((part)->dkstats.field += addnd)
     293             : 
     294             : #define part_stat_read(part, field)     ((part)->dkstats.field)
     295             : 
     296             : static inline void part_stat_set_all(struct hd_struct *part, int value)
     297             : {
     298             :         memset(&part->dkstats, value, sizeof(struct disk_stats));
     299             : }
     300             : 
     301             : static inline int init_part_stats(struct hd_struct *part)
     302             : {
     303             :         return 1;
     304             : }
     305             : 
     306             : static inline void free_part_stats(struct hd_struct *part)
     307             : {
     308             : }
     309             : 
     310             : #endif /* CONFIG_SMP */
     311             : 
     312             : #define part_stat_add(cpu, part, field, addnd)  do {                    \
     313             :         __part_stat_add((cpu), (part), field, addnd);                   \
     314             :         if ((part)->partno)                                          \
     315             :                 __part_stat_add((cpu), &part_to_disk((part))->part0,     \
     316             :                                 field, addnd);                          \
     317             : } while (0)
     318             : 
     319             : #define part_stat_dec(cpu, gendiskp, field)                             \
     320             :         part_stat_add(cpu, gendiskp, field, -1)
     321             : #define part_stat_inc(cpu, gendiskp, field)                             \
     322             :         part_stat_add(cpu, gendiskp, field, 1)
     323             : #define part_stat_sub(cpu, gendiskp, field, subnd)                      \
     324             :         part_stat_add(cpu, gendiskp, field, -subnd)
     325             : 
     326             : static inline void part_inc_in_flight(struct hd_struct *part, int rw)
     327             : {
     328             :         part->in_flight[rw]++;
     329             :         if (part->partno)
     330             :                 part_to_disk(part)->part0.in_flight[rw]++;
     331             : }
     332             : 
     333             : static inline void part_dec_in_flight(struct hd_struct *part, int rw)
     334             : {
     335             :         part->in_flight[rw]--;
     336             :         if (part->partno)
     337             :                 part_to_disk(part)->part0.in_flight[rw]--;
     338             : }
     339             : 
     340             : static inline int part_in_flight(struct hd_struct *part)
     341             : {
     342             :         return part->in_flight[0] + part->in_flight[1];
     343             : }
     344             : 
     345             : /* block/blk-core.c */
     346             : extern void part_round_stats(int cpu, struct hd_struct *part);
     347             : 
     348             : /* block/genhd.c */
     349             : extern void add_disk(struct gendisk *disk);
     350             : extern void del_gendisk(struct gendisk *gp);
     351             : extern void unlink_gendisk(struct gendisk *gp);
     352             : extern struct gendisk *get_gendisk(dev_t dev, int *partno);
     353             : extern struct block_device *bdget_disk(struct gendisk *disk, int partno);
     354             : 
     355             : extern void set_device_ro(struct block_device *bdev, int flag);
     356             : extern void set_disk_ro(struct gendisk *disk, int flag);
     357             : 
     358             : static inline int get_disk_ro(struct gendisk *disk)
     359             : {
     360             :         return disk->part0.policy;
     361             : }
     362             : 
     363             : /* drivers/char/random.c */
     364             : extern void add_disk_randomness(struct gendisk *disk);
     365             : extern void rand_initialize_disk(struct gendisk *disk);
     366             : 
     367             : static inline sector_t get_start_sect(struct block_device *bdev)
     368             : {
     369             :         return bdev->bd_part->start_sect;
     370             : }
     371             : static inline sector_t get_capacity(struct gendisk *disk)
     372             : {
     373           2 :         return disk->part0.nr_sects;
     374             : }
     375             : static inline void set_capacity(struct gendisk *disk, sector_t size)
     376             : {
     377           2 :         disk->part0.nr_sects = size;
     378           2 : }
     379             : 
     380             : #ifdef CONFIG_SOLARIS_X86_PARTITION
     381             : 
     382             : #define SOLARIS_X86_NUMSLICE    16
     383             : #define SOLARIS_X86_VTOC_SANE   (0x600DDEEEUL)
     384             : 
     385             : struct solaris_x86_slice {
     386             :         __le16 s_tag;           /* ID tag of partition */
     387             :         __le16 s_flag;          /* permission flags */
     388             :         __le32 s_start;         /* start sector no of partition */
     389             :         __le32 s_size;          /* # of blocks in partition */
     390             : };
     391             : 
     392             : struct solaris_x86_vtoc {
     393             :         unsigned int v_bootinfo[3];     /* info needed by mboot (unsupported) */
     394             :         __le32 v_sanity;                /* to verify vtoc sanity */
     395             :         __le32 v_version;               /* layout version */
     396             :         char    v_volume[8];            /* volume name */
     397             :         __le16  v_sectorsz;             /* sector size in bytes */
     398             :         __le16  v_nparts;               /* number of partitions */
     399             :         unsigned int v_reserved[10];    /* free space */
     400             :         struct solaris_x86_slice
     401             :                 v_slice[SOLARIS_X86_NUMSLICE]; /* slice headers */
     402             :         unsigned int timestamp[SOLARIS_X86_NUMSLICE]; /* timestamp (unsupported) */
     403             :         char    v_asciilabel[128];      /* for compatibility */
     404             : };
     405             : 
     406             : #endif /* CONFIG_SOLARIS_X86_PARTITION */
     407             : 
     408             : #ifdef CONFIG_BSD_DISKLABEL
     409             : /*
     410             :  * BSD disklabel support by Yossi Gottlieb <yogo@math.tau.ac.il>
     411             :  * updated by Marc Espie <Marc.Espie@openbsd.org>
     412             :  */
     413             : 
     414             : /* check against BSD src/sys/sys/disklabel.h for consistency */
     415             : 
     416             : #define BSD_DISKMAGIC   (0x82564557UL)  /* The disk magic number */
     417             : #define BSD_MAXPARTITIONS       16
     418             : #define OPENBSD_MAXPARTITIONS   16
     419             : #define BSD_FS_UNUSED           0       /* disklabel unused partition entry ID */
     420             : struct bsd_disklabel {
     421             :         __le32  d_magic;                /* the magic number */
     422             :         __s16   d_type;                 /* drive type */
     423             :         __s16   d_subtype;              /* controller/d_type specific */
     424             :         char    d_typename[16];         /* type name, e.g. "eagle" */
     425             :         char    d_packname[16];                 /* pack identifier */ 
     426             :         __u32   d_secsize;              /* # of bytes per sector */
     427             :         __u32   d_nsectors;             /* # of data sectors per track */
     428             :         __u32   d_ntracks;              /* # of tracks per cylinder */
     429             :         __u32   d_ncylinders;           /* # of data cylinders per unit */
     430             :         __u32   d_secpercyl;            /* # of data sectors per cylinder */
     431             :         __u32   d_secperunit;           /* # of data sectors per unit */
     432             :         __u16   d_sparespertrack;       /* # of spare sectors per track */
     433             :         __u16   d_sparespercyl;         /* # of spare sectors per cylinder */
     434             :         __u32   d_acylinders;           /* # of alt. cylinders per unit */
     435             :         __u16   d_rpm;                  /* rotational speed */
     436             :         __u16   d_interleave;           /* hardware sector interleave */
     437             :         __u16   d_trackskew;            /* sector 0 skew, per track */
     438             :         __u16   d_cylskew;              /* sector 0 skew, per cylinder */
     439             :         __u32   d_headswitch;           /* head switch time, usec */
     440             :         __u32   d_trkseek;              /* track-to-track seek, usec */
     441             :         __u32   d_flags;                /* generic flags */
     442             : #define NDDATA 5
     443             :         __u32   d_drivedata[NDDATA];    /* drive-type specific information */
     444             : #define NSPARE 5
     445             :         __u32   d_spare[NSPARE];        /* reserved for future use */
     446             :         __le32  d_magic2;               /* the magic number (again) */
     447             :         __le16  d_checksum;             /* xor of data incl. partitions */
     448             : 
     449             :                         /* filesystem and partition information: */
     450             :         __le16  d_npartitions;          /* number of partitions in following */
     451             :         __le32  d_bbsize;               /* size of boot area at sn0, bytes */
     452             :         __le32  d_sbsize;               /* max size of fs superblock, bytes */
     453             :         struct  bsd_partition {         /* the partition table */
     454             :                 __le32  p_size;         /* number of sectors in partition */
     455             :                 __le32  p_offset;       /* starting sector */
     456             :                 __le32  p_fsize;        /* filesystem basic fragment size */
     457             :                 __u8    p_fstype;       /* filesystem type, see below */
     458             :                 __u8    p_frag;         /* filesystem fragments per block */
     459             :                 __le16  p_cpg;          /* filesystem cylinders per group */
     460             :         } d_partitions[BSD_MAXPARTITIONS];      /* actually may be more */
     461             : };
     462             : 
     463             : #endif  /* CONFIG_BSD_DISKLABEL */
     464             : 
     465             : #ifdef CONFIG_UNIXWARE_DISKLABEL
     466             : /*
     467             :  * Unixware slices support by Andrzej Krzysztofowicz <ankry@mif.pg.gda.pl>
     468             :  * and Krzysztof G. Baranowski <kgb@knm.org.pl>
     469             :  */
     470             : 
     471             : #define UNIXWARE_DISKMAGIC     (0xCA5E600DUL)   /* The disk magic number */
     472             : #define UNIXWARE_DISKMAGIC2    (0x600DDEEEUL)   /* The slice table magic nr */
     473             : #define UNIXWARE_NUMSLICE      16
     474             : #define UNIXWARE_FS_UNUSED     0                /* Unused slice entry ID */
     475             : 
     476             : struct unixware_slice {
     477             :         __le16   s_label;       /* label */
     478             :         __le16   s_flags;       /* permission flags */
     479             :         __le32   start_sect;    /* starting sector */
     480             :         __le32   nr_sects;      /* number of sectors in slice */
     481             : };
     482             : 
     483             : struct unixware_disklabel {
     484             :         __le32   d_type;                /* drive type */
     485             :         __le32   d_magic;                /* the magic number */
     486             :         __le32   d_version;              /* version number */
     487             :         char    d_serial[12];           /* serial number of the device */
     488             :         __le32   d_ncylinders;           /* # of data cylinders per device */
     489             :         __le32   d_ntracks;              /* # of tracks per cylinder */
     490             :         __le32   d_nsectors;             /* # of data sectors per track */
     491             :         __le32   d_secsize;              /* # of bytes per sector */
     492             :         __le32   d_part_start;           /* # of first sector of this partition */
     493             :         __le32   d_unknown1[12];         /* ? */
     494             :         __le32  d_alt_tbl;              /* byte offset of alternate table */
     495             :         __le32  d_alt_len;              /* byte length of alternate table */
     496             :         __le32  d_phys_cyl;             /* # of physical cylinders per device */
     497             :         __le32  d_phys_trk;             /* # of physical tracks per cylinder */
     498             :         __le32  d_phys_sec;             /* # of physical sectors per track */
     499             :         __le32  d_phys_bytes;           /* # of physical bytes per sector */
     500             :         __le32  d_unknown2;             /* ? */
     501             :         __le32   d_unknown3;             /* ? */
     502             :         __le32  d_pad[8];               /* pad */
     503             : 
     504             :         struct unixware_vtoc {
     505             :                 __le32  v_magic;                /* the magic number */
     506             :                 __le32  v_version;              /* version number */
     507             :                 char    v_name[8];              /* volume name */
     508             :                 __le16  v_nslices;              /* # of slices */
     509             :                 __le16  v_unknown1;             /* ? */
     510             :                 __le32  v_reserved[10];         /* reserved */
     511             :                 struct unixware_slice
     512             :                         v_slice[UNIXWARE_NUMSLICE];     /* slice headers */
     513             :         } vtoc;
     514             : 
     515             : };  /* 408 */
     516             : 
     517             : #endif /* CONFIG_UNIXWARE_DISKLABEL */
     518             : 
     519             : #ifdef CONFIG_MINIX_SUBPARTITION
     520             : #   define MINIX_NR_SUBPARTITIONS  4
     521             : #endif /* CONFIG_MINIX_SUBPARTITION */
     522             : 
     523             : #define ADDPART_FLAG_NONE       0
     524             : #define ADDPART_FLAG_RAID       1
     525             : #define ADDPART_FLAG_WHOLEDISK  2
     526             : 
     527             : extern int blk_alloc_devt(struct hd_struct *part, dev_t *devt);
     528             : extern void blk_free_devt(dev_t devt);
     529             : extern dev_t blk_lookup_devt(const char *name, int partno);
     530             : extern char *disk_name (struct gendisk *hd, int partno, char *buf);
     531             : 
     532             : extern int disk_expand_part_tbl(struct gendisk *disk, int target);
     533             : extern int rescan_partitions(struct gendisk *disk, struct block_device *bdev);
     534             : extern struct hd_struct * __must_check add_partition(struct gendisk *disk,
     535             :                                                      int partno, sector_t start,
     536             :                                                      sector_t len, int flags);
     537             : extern void delete_partition(struct gendisk *, int);
     538             : extern void printk_all_partitions(void);
     539             : 
     540             : extern struct gendisk *alloc_disk_node(int minors, int node_id);
     541             : extern struct gendisk *alloc_disk(int minors);
     542             : extern struct kobject *get_disk(struct gendisk *disk);
     543             : extern void put_disk(struct gendisk *disk);
     544             : extern void blk_register_region(dev_t devt, unsigned long range,
     545             :                         struct module *module,
     546             :                         struct kobject *(*probe)(dev_t, int *, void *),
     547             :                         int (*lock)(dev_t, void *),
     548             :                         void *data);
     549             : extern void blk_unregister_region(dev_t devt, unsigned long range);
     550             : 
     551             : extern ssize_t part_size_show(struct device *dev,
     552             :                               struct device_attribute *attr, char *buf);
     553             : extern ssize_t part_stat_show(struct device *dev,
     554             :                               struct device_attribute *attr, char *buf);
     555             : extern ssize_t part_inflight_show(struct device *dev,
     556             :                               struct device_attribute *attr, char *buf);
     557             : #ifdef CONFIG_FAIL_MAKE_REQUEST
     558             : extern ssize_t part_fail_show(struct device *dev,
     559             :                               struct device_attribute *attr, char *buf);
     560             : extern ssize_t part_fail_store(struct device *dev,
     561             :                                struct device_attribute *attr,
     562             :                                const char *buf, size_t count);
     563             : #endif /* CONFIG_FAIL_MAKE_REQUEST */
     564             : 
     565             : #else /* CONFIG_BLOCK */
     566             : 
     567             : static inline void printk_all_partitions(void) { }
     568             : 
     569             : static inline dev_t blk_lookup_devt(const char *name, int partno)
     570             : {
     571             :         dev_t devt = MKDEV(0, 0);
     572             :         return devt;
     573             : }
     574             : 
     575             : #endif /* CONFIG_BLOCK */
     576             : 
     577             : #endif /* _LINUX_GENHD_H */

Generated by: LCOV version 1.10