include/linux/genhd.h

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 #ifndef _LINUX_GENHD_H
   3 #define _LINUX_GENHD_H
   4
   5 /*
   6  *      genhd.h Copyright (C) 1992 Drew Eckhardt
   7  *      Generic hard disk header file by
   8  *              Drew Eckhardt
   9  *
  10  *              <drew@colorado.edu>
  11  */
  12
  13 #include <linux/types.h>
  14 #include <linux/kdev_t.h>
  15 #include <linux/uuid.h>
  16 #include <linux/blk_types.h>
  17 #include <linux/device.h>
  18 #include <linux/xarray.h>
  19
  20 extern const struct device_type disk_type;
  21 extern struct device_type part_type;
  22 extern struct class block_class;
  23
  24 #define DISK_MAX_PARTS                  256
  25 #define DISK_NAME_LEN                   32
  26
  27 #define PARTITION_META_INFO_VOLNAMELTH  64
  28 /*
  29  * Enough for the string representation of any kind of UUID plus NULL.
  30  * EFI UUID is 36 characters. MSDOS UUID is 11 characters.
  31  */
  32 #define PARTITION_META_INFO_UUIDLTH     (UUID_STRING_LEN + 1)
  33
  34 struct partition_meta_info {
  35         char uuid[PARTITION_META_INFO_UUIDLTH];
  36         u8 volname[PARTITION_META_INFO_VOLNAMELTH];
  37 };
  38
  39 /**
  40  * DOC: genhd capability flags
  41  *
  42  * ``GENHD_FL_REMOVABLE``: indicates that the block device gives access to
  43  * removable media.  When set, the device remains present even when media is not
  44  * inserted.  Shall not be set for devices which are removed entirely when the
  45  * media is removed.
  46  *
  47  * ``GENHD_FL_HIDDEN``: the block device is hidden; it doesn't produce events,
  48  * doesn't appear in sysfs, and can't be opened from userspace or using
  49  * blkdev_get*. Used for the underlying components of multipath devices.
  50  *
  51  * ``GENHD_FL_NO_PART``: partition support is disabled.  The kernel will not
  52  * scan for partitions from add_disk, and users can't add partitions manually.
  53  *
  54  */
  55 enum {
  56         GENHD_FL_REMOVABLE                      = 1 << 0,
  57         GENHD_FL_HIDDEN                         = 1 << 1,
  58         GENHD_FL_NO_PART                        = 1 << 2,
  59 };
  60
  61 enum {
  62         DISK_EVENT_MEDIA_CHANGE                 = 1 << 0, /* media changed */
  63         DISK_EVENT_EJECT_REQUEST                = 1 << 1, /* eject requested */
  64 };
  65
  66 enum {
  67         /* Poll even if events_poll_msecs is unset */
  68         DISK_EVENT_FLAG_POLL                    = 1 << 0,
  69         /* Forward events to udev */
  70         DISK_EVENT_FLAG_UEVENT                  = 1 << 1,
  71         /* Block event polling when open for exclusive write */
  72         DISK_EVENT_FLAG_BLOCK_ON_EXCL_WRITE     = 1 << 2,
  73 };
  74
  75 struct disk_events;
  76 struct badblocks;
  77
  78 struct blk_integrity {
  79         const struct blk_integrity_profile      *profile;
  80         unsigned char                           flags;
  81         unsigned char                           tuple_size;
  82         unsigned char                           interval_exp;
  83         unsigned char                           tag_size;
  84 };
  85
  86 struct gendisk {
  87         /*
  88          * major/first_minor/minors should not be set by any new driver, the
  89          * block core will take care of allocating them automatically.
  90          */
  91         int major;
  92         int first_minor;
  93         int minors;
  94
  95         char disk_name[DISK_NAME_LEN];  /* name of major driver */
  96
  97         unsigned short events;          /* supported events */
  98         unsigned short event_flags;     /* flags related to event processing */
  99
 100         struct xarray part_tbl;
 101         struct block_device *part0;
 102
 103         const struct block_device_operations *fops;
 104         struct request_queue *queue;
 105         void *private_data;
 106
 107         int flags;
 108         unsigned long state;
 109 #define GD_NEED_PART_SCAN               0
 110 #define GD_READ_ONLY                    1
 111 #define GD_DEAD                         2
 112 #define GD_NATIVE_CAPACITY              3
 113
 114         struct mutex open_mutex;        /* open/close mutex */
 115         unsigned open_partitions;       /* number of open partitions */
 116
 117         struct backing_dev_info *bdi;
 118         struct kobject *slave_dir;
 119 #ifdef CONFIG_BLOCK_HOLDER_DEPRECATED
 120         struct list_head slave_bdevs;
 121 #endif
 122         struct timer_rand_state *random;
 123         atomic_t sync_io;               /* RAID */
 124         struct disk_events *ev;
 125 #ifdef  CONFIG_BLK_DEV_INTEGRITY
 126         struct kobject integrity_kobj;
 127 #endif  /* CONFIG_BLK_DEV_INTEGRITY */
 128 #if IS_ENABLED(CONFIG_CDROM)
 129         struct cdrom_device_info *cdi;
 130 #endif
 131         int node_id;
 132         struct badblocks *bb;
 133         struct lockdep_map lockdep_map;
 134         u64 diskseq;
 135 };
 136
 137 static inline bool disk_live(struct gendisk *disk)
 138 {
 139         return !inode_unhashed(disk->part0->bd_inode);
 140 }
 141
 142 /*
 143  * The gendisk is refcounted by the part0 block_device, and the bd_device
 144  * therein is also used for device model presentation in sysfs.
 145  */
 146 #define dev_to_disk(device) \
 147         (dev_to_bdev(device)->bd_disk)
 148 #define disk_to_dev(disk) \
 149         (&((disk)->part0->bd_device))
 150
 151 #if IS_REACHABLE(CONFIG_CDROM)
 152 #define disk_to_cdi(disk)       ((disk)->cdi)
 153 #else
 154 #define disk_to_cdi(disk)       NULL
 155 #endif
 156
 157 static inline dev_t disk_devt(struct gendisk *disk)
 158 {
 159         return MKDEV(disk->major, disk->first_minor);
 160 }
 161
 162 void disk_uevent(struct gendisk *disk, enum kobject_action action);
 163
 164 /* block/genhd.c */
 165 int __must_check device_add_disk(struct device *parent, struct gendisk *disk,
 166                                  const struct attribute_group **groups);
 167 static inline int __must_check add_disk(struct gendisk *disk)
 168 {
 169         return device_add_disk(NULL, disk, NULL);
 170 }
 171 extern void del_gendisk(struct gendisk *gp);
 172
 173 void invalidate_disk(struct gendisk *disk);
 174
 175 void set_disk_ro(struct gendisk *disk, bool read_only);
 176
 177 static inline int get_disk_ro(struct gendisk *disk)
 178 {
 179         return disk->part0->bd_read_only ||
 180                 test_bit(GD_READ_ONLY, &disk->state);
 181 }
 182
 183 static inline int bdev_read_only(struct block_device *bdev)
 184 {
 185         return bdev->bd_read_only || get_disk_ro(bdev->bd_disk);
 186 }
 187
 188 extern void disk_block_events(struct gendisk *disk);
 189 extern void disk_unblock_events(struct gendisk *disk);
 190 extern void disk_flush_events(struct gendisk *disk, unsigned int mask);
 191 bool set_capacity_and_notify(struct gendisk *disk, sector_t size);
 192 bool disk_force_media_change(struct gendisk *disk, unsigned int events);
 193
 194 /* drivers/char/random.c */
 195 extern void add_disk_randomness(struct gendisk *disk) __latent_entropy;
 196 extern void rand_initialize_disk(struct gendisk *disk);
 197
 198 static inline sector_t get_start_sect(struct block_device *bdev)
 199 {
 200         return bdev->bd_start_sect;
 201 }
 202
 203 static inline sector_t bdev_nr_sectors(struct block_device *bdev)
 204 {
 205         return bdev->bd_nr_sectors;
 206 }
 207
 208 static inline loff_t bdev_nr_bytes(struct block_device *bdev)
 209 {
 210         return (loff_t)bdev_nr_sectors(bdev) << SECTOR_SHIFT;
 211 }
 212
 213 static inline sector_t get_capacity(struct gendisk *disk)
 214 {
 215         return bdev_nr_sectors(disk->part0);
 216 }
 217
 218 static inline u64 sb_bdev_nr_blocks(struct super_block *sb)
 219 {
 220         return bdev_nr_sectors(sb->s_bdev) >>
 221                 (sb->s_blocksize_bits - SECTOR_SHIFT);
 222 }
 223
 224 int bdev_disk_changed(struct gendisk *disk, bool invalidate);
 225 void blk_drop_partitions(struct gendisk *disk);
 226
 227 struct gendisk *__alloc_disk_node(struct request_queue *q, int node_id,
 228                 struct lock_class_key *lkclass);
 229 extern void put_disk(struct gendisk *disk);
 230 struct gendisk *__blk_alloc_disk(int node, struct lock_class_key *lkclass);
 231
 232 /**
 233  * blk_alloc_disk - allocate a gendisk structure
 234  * @node_id: numa node to allocate on
 235  *
 236  * Allocate and pre-initialize a gendisk structure for use with BIO based
 237  * drivers.
 238  *
 239  * Context: can sleep
 240  */
 241 #define blk_alloc_disk(node_id)                                         \
 242 ({                                                                      \
 243         static struct lock_class_key __key;                             \
 244                                                                         \
 245         __blk_alloc_disk(node_id, &__key);                              \
 246 })
 247 void blk_cleanup_disk(struct gendisk *disk);
 248
 249 int __register_blkdev(unsigned int major, const char *name,
 250                 void (*probe)(dev_t devt));
 251 #define register_blkdev(major, name) \
 252         __register_blkdev(major, name, NULL)
 253 void unregister_blkdev(unsigned int major, const char *name);
 254
 255 bool bdev_check_media_change(struct block_device *bdev);
 256 int __invalidate_device(struct block_device *bdev, bool kill_dirty);
 257 void set_capacity(struct gendisk *disk, sector_t size);
 258
 259 #ifdef CONFIG_BLOCK_HOLDER_DEPRECATED
 260 int bd_link_disk_holder(struct block_device *bdev, struct gendisk *disk);
 261 void bd_unlink_disk_holder(struct block_device *bdev, struct gendisk *disk);
 262 int bd_register_pending_holders(struct gendisk *disk);
 263 #else
 264 static inline int bd_link_disk_holder(struct block_device *bdev,
 265                                       struct gendisk *disk)
 266 {
 267         return 0;
 268 }
 269 static inline void bd_unlink_disk_holder(struct block_device *bdev,
 270                                          struct gendisk *disk)
 271 {
 272 }
 273 static inline int bd_register_pending_holders(struct gendisk *disk)
 274 {
 275         return 0;
 276 }
 277 #endif /* CONFIG_BLOCK_HOLDER_DEPRECATED */
 278
 279 dev_t part_devt(struct gendisk *disk, u8 partno);
 280 void inc_diskseq(struct gendisk *disk);
 281 dev_t blk_lookup_devt(const char *name, int partno);
 282 void blk_request_module(dev_t devt);
 283 #ifdef CONFIG_BLOCK
 284 void printk_all_partitions(void);
 285 #else /* CONFIG_BLOCK */
 286 static inline void printk_all_partitions(void)
 287 {
 288 }
 289 #endif /* CONFIG_BLOCK */
 290
 291 #endif /* _LINUX_GENHD_H */