| 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 | * <[email protected]>
|
| 10 |
|
| 11 |
|
| 12 | #include <linux/types.h>
|
| 13 | #include <linux/kdev_t.h>
|
| 14 | #include <linux/rcupdate.h>
|
| 15 | #include <linux/slab.h>
|
| 16 | #include <linux/percpu-refcount.h>
|
| 17 | #include <linux/uuid.h>
|
| 18 |
|
| 19 | #ifdef CONFIG_BLOCK
|
| 20 |
|
| 21 | #define dev_to_disk(device) container_of((device), struct gendisk, part0.__dev)
|
| 22 | #define dev_to_part(device) container_of((device), struct hd_struct, __dev)
|
| 23 | #define disk_to_dev(disk) (&(disk)->part0.__dev)
|
| 24 | #define part_to_dev(part) (&((part)->__dev))
|
| 25 |
|
| 26 | extern struct device_type part_type;
|
| 27 | extern struct kobject *block_depr;
|
| 28 | extern struct class block_class;
|
| 29 |
|
| 30 | enum {
|
| 31 | |
| 32 | confused about extended/logical partitions starting past cylinder 1023.
|
| 33 | DOS_EXTENDED_PARTITION = 5,
|
| 34 | LINUX_EXTENDED_PARTITION = 0x85,
|
| 35 | WIN98_EXTENDED_PARTITION = 0x0f,
|
| 36 |
|
| 37 | SUN_WHOLE_DISK = DOS_EXTENDED_PARTITION,
|
| 38 |
|
| 39 | LINUX_SWAP_PARTITION = 0x82,
|
| 40 | LINUX_DATA_PARTITION = 0x83,
|
| 41 | LINUX_LVM_PARTITION = 0x8e,
|
| 42 | LINUX_RAID_PARTITION = 0xfd,
|
| 43 |
|
| 44 | SOLARIS_X86_PARTITION = LINUX_SWAP_PARTITION,
|
| 45 | NEW_SOLARIS_X86_PARTITION = 0xbf,
|
| 46 |
|
| 47 | DM6_AUX1PARTITION = 0x51,
|
| 48 | DM6_AUX3PARTITION = 0x53,
|
| 49 | DM6_PARTITION = 0x54,
|
| 50 | EZD_PARTITION = 0x55,
|
| 51 |
|
| 52 | FREEBSD_PARTITION = 0xa5,
|
| 53 | OPENBSD_PARTITION = 0xa6,
|
| 54 | NETBSD_PARTITION = 0xa9,
|
| 55 | BSDI_PARTITION = 0xb7,
|
| 56 | MINIX_PARTITION = 0x81,
|
| 57 | UNIXWARE_PARTITION = 0x63,
|
| 58 | };
|
| 59 |
|
| 60 | #define DISK_MAX_PARTS 256
|
| 61 | #define DISK_NAME_LEN 32
|
| 62 |
|
| 63 | #include <linux/major.h>
|
| 64 | #include <linux/device.h>
|
| 65 | #include <linux/smp.h>
|
| 66 | #include <linux/string.h>
|
| 67 | #include <linux/fs.h>
|
| 68 | #include <linux/workqueue.h>
|
| 69 |
|
| 70 | struct partition {
|
| 71 | unsigned char boot_ind;
|
| 72 | unsigned char head;
|
| 73 | unsigned char sector;
|
| 74 | unsigned char cyl;
|
| 75 | unsigned char sys_ind;
|
| 76 | unsigned char end_head;
|
| 77 | unsigned char end_sector;
|
| 78 | unsigned char end_cyl;
|
| 79 | __le32 start_sect;
|
| 80 | __le32 nr_sects;
|
| 81 | } __attribute__((packed));
|
| 82 |
|
| 83 | struct disk_stats {
|
| 84 | unsigned long sectors[2];
|
| 85 | unsigned long ios[2];
|
| 86 | unsigned long merges[2];
|
| 87 | unsigned long ticks[2];
|
| 88 | unsigned long io_ticks;
|
| 89 | unsigned long time_in_queue;
|
| 90 | };
|
| 91 |
|
| 92 | #define PARTITION_META_INFO_VOLNAMELTH 64
|
| 93 | |
| 94 | * Enough for the string representation of any kind of UUID plus NULL.
|
| 95 | * EFI UUID is 36 characters. MSDOS UUID is 11 characters.
|
| 96 |
|
| 97 | #define PARTITION_META_INFO_UUIDLTH (UUID_STRING_LEN + 1)
|
| 98 |
|
| 99 | struct partition_meta_info {
|
| 100 | char uuid[PARTITION_META_INFO_UUIDLTH];
|
| 101 | u8 volname[PARTITION_META_INFO_VOLNAMELTH];
|
| 102 | };
|
| 103 |
|
| 104 | struct hd_struct {
|
| 105 | sector_t start_sect;
|
| 106 | |
| 107 | * nr_sects is protected by sequence counter. One might extend a
|
| 108 | * partition while IO is happening to it and update of nr_sects
|
| 109 | * can be non-atomic on 32bit machines with 64bit sector_t.
|
| 110 |
|
| 111 | sector_t nr_sects;
|
| 112 | seqcount_t nr_sects_seq;
|
| 113 | sector_t alignment_offset;
|
| 114 | unsigned int discard_alignment;
|
| 115 | struct device __dev;
|
| 116 | struct kobject *holder_dir;
|
| 117 | int policy, partno;
|
| 118 | struct partition_meta_info *info;
|
| 119 | #ifdef CONFIG_FAIL_MAKE_REQUEST
|
| 120 | int make_it_fail;
|
| 121 | #endif
|
| 122 | unsigned long stamp;
|
| 123 | atomic_t in_flight[2];
|
| 124 | #ifdef CONFIG_SMP
|
| 125 | struct disk_stats __percpu *dkstats;
|
| 126 | #else
|
| 127 | struct disk_stats dkstats;
|
| 128 | #endif
|
| 129 | struct percpu_ref ref;
|
| 130 | struct rcu_head rcu_head;
|
| 131 | };
|
| 132 |
|
| 133 | #define GENHD_FL_REMOVABLE 1
|
| 134 |
|
| 135 | #define GENHD_FL_MEDIA_CHANGE_NOTIFY 4
|
| 136 | #define GENHD_FL_CD 8
|
| 137 | #define GENHD_FL_UP 16
|
| 138 | #define GENHD_FL_SUPPRESS_PARTITION_INFO 32
|
| 139 | #define GENHD_FL_EXT_DEVT 64
|
| 140 | #define GENHD_FL_NATIVE_CAPACITY 128
|
| 141 | #define GENHD_FL_BLOCK_EVENTS_ON_EXCL_WRITE 256
|
| 142 | #define GENHD_FL_NO_PART_SCAN 512
|
| 143 |
|
| 144 | enum {
|
| 145 | DISK_EVENT_MEDIA_CHANGE = 1 << 0,
|
| 146 | DISK_EVENT_EJECT_REQUEST = 1 << 1,
|
| 147 | };
|
| 148 |
|
| 149 | struct disk_part_tbl {
|
| 150 | struct rcu_head rcu_head;
|
| 151 | int len;
|
| 152 | struct hd_struct __rcu *last_lookup;
|
| 153 | struct hd_struct __rcu *part[];
|
| 154 | };
|
| 155 |
|
| 156 | struct disk_events;
|
| 157 | struct badblocks;
|
| 158 |
|
| 159 | #if defined(CONFIG_BLK_DEV_INTEGRITY)
|
| 160 |
|
| 161 | struct blk_integrity {
|
| 162 | const struct blk_integrity_profile *profile;
|
| 163 | unsigned char flags;
|
| 164 | unsigned char tuple_size;
|
| 165 | unsigned char interval_exp;
|
| 166 | unsigned char tag_size;
|
| 167 | };
|
| 168 |
|
| 169 | #endif
|
| 170 |
|
| 171 | struct gendisk {
|
| 172 | |
| 173 | * don't use directly. Use disk_devt() and disk_max_parts().
|
| 174 |
|
| 175 | int major;
|
| 176 | int first_minor;
|
| 177 | int minors; |
| 178 | * disks that can't be partitioned.
|
| 179 |
|
| 180 | char disk_name[DISK_NAME_LEN];
|
| 181 | char *(*devnode)(struct gendisk *gd, umode_t *mode);
|
| 182 |
|
| 183 | unsigned int events;
|
| 184 | unsigned int async_events;
|
| 185 |
|
| 186 | |
| 187 | * Protected with matching bdev lock but stat and other
|
| 188 | * non-critical accesses use RCU. Always access through
|
| 189 | * helpers.
|
| 190 |
|
| 191 | struct disk_part_tbl __rcu *part_tbl;
|
| 192 | struct hd_struct part0;
|
| 193 |
|
| 194 | const struct block_device_operations *fops;
|
| 195 | struct request_queue *queue;
|
| 196 | void *private_data;
|
| 197 |
|
| 198 | int flags;
|
| 199 | struct kobject *slave_dir;
|
| 200 |
|
| 201 | struct timer_rand_state *random;
|
| 202 | atomic_t sync_io;
|
| 203 | struct disk_events *ev;
|
| 204 | #ifdef CONFIG_BLK_DEV_INTEGRITY
|
| 205 | struct kobject integrity_kobj;
|
| 206 | #endif
|
| 207 | int node_id;
|
| 208 | struct badblocks *bb;
|
| 209 | };
|
| 210 |
|
| 211 | static inline struct gendisk *part_to_disk(struct hd_struct *part)
|
| 212 | {
|
| 213 | if (likely(part)) {
|
| 214 | if (part->partno)
|
| 215 | return dev_to_disk(part_to_dev(part)->parent);
|
| 216 | else
|
| 217 | return dev_to_disk(part_to_dev(part));
|
| 218 | }
|
| 219 | return NULL;
|
| 220 | }
|
| 221 |
|
| 222 | static inline int blk_part_pack_uuid(const u8 *uuid_str, u8 *to)
|
| 223 | {
|
| 224 | uuid_be_to_bin(uuid_str, (uuid_be *)to);
|
| 225 | return 0;
|
| 226 | }
|
| 227 |
|
| 228 | static inline int disk_max_parts(struct gendisk *disk)
|
| 229 | {
|
| 230 | if (disk->flags & GENHD_FL_EXT_DEVT)
|
| 231 | return DISK_MAX_PARTS;
|
| 232 | return disk->minors;
|
| 233 | }
|
| 234 |
|
| 235 | static inline bool disk_part_scan_enabled(struct gendisk *disk)
|
| 236 | {
|
| 237 | return disk_max_parts(disk) > 1 &&
|
| 238 | !(disk->flags & GENHD_FL_NO_PART_SCAN);
|
| 239 | }
|
| 240 |
|
| 241 | static inline dev_t disk_devt(struct gendisk *disk)
|
| 242 | {
|
| 243 | return disk_to_dev(disk)->devt;
|
| 244 | }
|
| 245 |
|
| 246 | static inline dev_t part_devt(struct hd_struct *part)
|
| 247 | {
|
| 248 | return part_to_dev(part)->devt;
|
| 249 | }
|
| 250 |
|
| 251 | extern struct hd_struct *disk_get_part(struct gendisk *disk, int partno);
|
| 252 |
|
| 253 | static inline void disk_put_part(struct hd_struct *part)
|
| 254 | {
|
| 255 | if (likely(part))
|
| 256 | put_device(part_to_dev(part));
|
| 257 | }
|
| 258 |
|
| 259 | |
| 260 | * Smarter partition iterator without context limits.
|
| 261 |
|
| 262 | #define DISK_PITER_REVERSE (1 << 0)
|
| 263 | #define DISK_PITER_INCL_EMPTY (1 << 1)
|
| 264 | #define DISK_PITER_INCL_PART0 (1 << 2)
|
| 265 | #define DISK_PITER_INCL_EMPTY_PART0 (1 << 3)
|
| 266 |
|
| 267 | struct disk_part_iter {
|
| 268 | struct gendisk *disk;
|
| 269 | struct hd_struct *part;
|
| 270 | int idx;
|
| 271 | unsigned int flags;
|
| 272 | };
|
| 273 |
|
| 274 | extern void disk_part_iter_init(struct disk_part_iter *piter,
|
| 275 | struct gendisk *disk, unsigned int flags);
|
| 276 | extern struct hd_struct *disk_part_iter_next(struct disk_part_iter *piter);
|
| 277 | extern void disk_part_iter_exit(struct disk_part_iter *piter);
|
| 278 |
|
| 279 | extern struct hd_struct *disk_map_sector_rcu(struct gendisk *disk,
|
| 280 | sector_t sector);
|
| 281 |
|
| 282 | |
| 283 | * Macros to operate on percpu disk statistics:
|
| 284 | *
|
| 285 | * {disk|part|all}_stat_{add|sub|inc|dec}() modify the stat counters
|
| 286 | * and should be called between disk_stat_lock() and
|
| 287 | * disk_stat_unlock().
|
| 288 | *
|
| 289 | * part_stat_read() can be called at any time.
|
| 290 | *
|
| 291 | * part_stat_{add|set_all}() and {init|free}_part_stats are for
|
| 292 | * internal use only.
|
| 293 |
|
| 294 | #ifdef CONFIG_SMP
|
| 295 | #define part_stat_lock() ({ rcu_read_lock(); get_cpu(); })
|
| 296 | #define part_stat_unlock() do { put_cpu(); rcu_read_unlock(); } while (0)
|
| 297 |
|
| 298 | #define __part_stat_add(cpu, part, field, addnd) \
|
| 299 | (per_cpu_ptr((part)->dkstats, (cpu))->field += (addnd))
|
| 300 |
|
| 301 | #define part_stat_read(part, field) \
|
| 302 | ({ \
|
| 303 | typeof((part)->dkstats->field) res = 0; \
|
| 304 | unsigned int _cpu; \
|
| 305 | for_each_possible_cpu(_cpu) \
|
| 306 | res += per_cpu_ptr((part)->dkstats, _cpu)->field; \
|
| 307 | res; \
|
| 308 | })
|
| 309 |
|
| 310 | static inline void part_stat_set_all(struct hd_struct *part, int value)
|
| 311 | {
|
| 312 | int i;
|
| 313 |
|
| 314 | for_each_possible_cpu(i)
|
| 315 | memset(per_cpu_ptr(part->dkstats, i), value,
|
| 316 | sizeof(struct disk_stats));
|
| 317 | }
|
| 318 |
|
| 319 | static inline int init_part_stats(struct hd_struct *part)
|
| 320 | {
|
| 321 | part->dkstats = alloc_percpu(struct disk_stats);
|
| 322 | if (!part->dkstats)
|
| 323 | return 0;
|
| 324 | return 1;
|
| 325 | }
|
| 326 |
|
| 327 | static inline void free_part_stats(struct hd_struct *part)
|
| 328 | {
|
| 329 | free_percpu(part->dkstats);
|
| 330 | }
|
| 331 |
|
| 332 | #else
|
| 333 | #define part_stat_lock() ({ rcu_read_lock(); 0; })
|
| 334 | #define part_stat_unlock() rcu_read_unlock()
|
| 335 |
|
| 336 | #define __part_stat_add(cpu, part, field, addnd) \
|
| 337 | ((part)->dkstats.field += addnd)
|
| 338 |
|
| 339 | #define part_stat_read(part, field) ((part)->dkstats.field)
|
| 340 |
|
| 341 | static inline void part_stat_set_all(struct hd_struct *part, int value)
|
| 342 | {
|
| 343 | memset(&part->dkstats, value, sizeof(struct disk_stats));
|
| 344 | }
|
| 345 |
|
| 346 | static inline int init_part_stats(struct hd_struct *part)
|
| 347 | {
|
| 348 | return 1;
|
| 349 | }
|
| 350 |
|
| 351 | static inline void free_part_stats(struct hd_struct *part)
|
| 352 | {
|
| 353 | }
|
| 354 |
|
| 355 | #endif
|
| 356 |
|
| 357 | #define part_stat_add(cpu, part, field, addnd) do { \
|
| 358 | __part_stat_add((cpu), (part), field, addnd); \
|
| 359 | if ((part)->partno) \
|
| 360 | __part_stat_add((cpu), &part_to_disk((part))->part0, \
|
| 361 | field, addnd); \
|
| 362 | } while (0)
|
| 363 |
|
| 364 | #define part_stat_dec(cpu, gendiskp, field) \
|
| 365 | part_stat_add(cpu, gendiskp, field, -1)
|
| 366 | #define part_stat_inc(cpu, gendiskp, field) \
|
| 367 | part_stat_add(cpu, gendiskp, field, 1)
|
| 368 | #define part_stat_sub(cpu, gendiskp, field, subnd) \
|
| 369 | part_stat_add(cpu, gendiskp, field, -subnd)
|
| 370 |
|
| 371 | static inline void part_inc_in_flight(struct hd_struct *part, int rw)
|
| 372 | {
|
| 373 | atomic_inc(&part->in_flight[rw]);
|
| 374 | if (part->partno)
|
| 375 | atomic_inc(&part_to_disk(part)->part0.in_flight[rw]);
|
| 376 | }
|
| 377 |
|
| 378 | static inline void part_dec_in_flight(struct hd_struct *part, int rw)
|
| 379 | {
|
| 380 | atomic_dec(&part->in_flight[rw]);
|
| 381 | if (part->partno)
|
| 382 | atomic_dec(&part_to_disk(part)->part0.in_flight[rw]);
|
| 383 | }
|
| 384 |
|
| 385 | static inline int part_in_flight(struct hd_struct *part)
|
| 386 | {
|
| 387 | return atomic_read(&part->in_flight[0]) + atomic_read(&part->in_flight[1]);
|
| 388 | }
|
| 389 |
|
| 390 | static inline struct partition_meta_info *alloc_part_info(struct gendisk *disk)
|
| 391 | {
|
| 392 | if (disk)
|
| 393 | return kzalloc_node(sizeof(struct partition_meta_info),
|
| 394 | GFP_KERNEL, disk->node_id);
|
| 395 | return kzalloc(sizeof(struct partition_meta_info), GFP_KERNEL);
|
| 396 | }
|
| 397 |
|
| 398 | static inline void free_part_info(struct hd_struct *part)
|
| 399 | {
|
| 400 | kfree(part->info);
|
| 401 | }
|
| 402 |
|
| 403 |
|
| 404 | extern void part_round_stats(int cpu, struct hd_struct *part);
|
| 405 |
|
| 406 |
|
| 407 | extern void device_add_disk(struct device *parent, struct gendisk *disk);
|
| 408 | static inline void add_disk(struct gendisk *disk)
|
| 409 | {
|
| 410 | device_add_disk(NULL, disk);
|
| 411 | }
|
| 412 |
|
| 413 | extern void del_gendisk(struct gendisk *gp);
|
| 414 | extern struct gendisk *get_gendisk(dev_t dev, int *partno);
|
| 415 | extern struct block_device *bdget_disk(struct gendisk *disk, int partno);
|
| 416 |
|
| 417 | extern void set_device_ro(struct block_device *bdev, int flag);
|
| 418 | extern void set_disk_ro(struct gendisk *disk, int flag);
|
| 419 |
|
| 420 | static inline int get_disk_ro(struct gendisk *disk)
|
| 421 | {
|
| 422 | return disk->part0.policy;
|
| 423 | }
|
| 424 |
|
| 425 | extern void disk_block_events(struct gendisk *disk);
|
| 426 | extern void disk_unblock_events(struct gendisk *disk);
|
| 427 | extern void disk_flush_events(struct gendisk *disk, unsigned int mask);
|
| 428 | extern unsigned int disk_clear_events(struct gendisk *disk, unsigned int mask);
|
| 429 |
|
| 430 |
|
| 431 | extern void add_disk_randomness(struct gendisk *disk) __latent_entropy;
|
| 432 | extern void rand_initialize_disk(struct gendisk *disk);
|
| 433 |
|
| 434 | static inline sector_t get_start_sect(struct block_device *bdev)
|
| 435 | {
|
| 436 | return bdev->bd_part->start_sect;
|
| 437 | }
|
| 438 | static inline sector_t get_capacity(struct gendisk *disk)
|
| 439 | {
|
| 440 | return disk->part0.nr_sects;
|
| 441 | }
|
| 442 | static inline void set_capacity(struct gendisk *disk, sector_t size)
|
| 443 | {
|
| 444 | disk->part0.nr_sects = size;
|
| 445 | }
|
| 446 |
|
| 447 | #ifdef CONFIG_SOLARIS_X86_PARTITION
|
| 448 |
|
| 449 | #define SOLARIS_X86_NUMSLICE 16
|
| 450 | #define SOLARIS_X86_VTOC_SANE (0x600DDEEEUL)
|
| 451 |
|
| 452 | struct solaris_x86_slice {
|
| 453 | __le16 s_tag;
|
| 454 | __le16 s_flag;
|
| 455 | __le32 s_start;
|
| 456 | __le32 s_size;
|
| 457 | };
|
| 458 |
|
| 459 | struct solaris_x86_vtoc {
|
| 460 | unsigned int v_bootinfo[3];
|
| 461 | __le32 v_sanity;
|
| 462 | __le32 v_version;
|
| 463 | char v_volume[8];
|
| 464 | __le16 v_sectorsz;
|
| 465 | __le16 v_nparts;
|
| 466 | unsigned int v_reserved[10];
|
| 467 | struct solaris_x86_slice
|
| 468 | v_slice[SOLARIS_X86_NUMSLICE];
|
| 469 | unsigned int timestamp[SOLARIS_X86_NUMSLICE];
|
| 470 | char v_asciilabel[128];
|
| 471 | };
|
| 472 |
|
| 473 | #endif
|
| 474 |
|
| 475 | #ifdef CONFIG_BSD_DISKLABEL
|
| 476 | |
| 477 | * BSD disklabel support by Yossi Gottlieb <[email protected]>
|
| 478 | * updated by Marc Espie <[email protected]>
|
| 479 |
|
| 480 |
|
| 481 |
|
| 482 |
|
| 483 | #define BSD_DISKMAGIC (0x82564557UL)
|
| 484 | #define BSD_MAXPARTITIONS 16
|
| 485 | #define OPENBSD_MAXPARTITIONS 16
|
| 486 | #define BSD_FS_UNUSED 0
|
| 487 | struct bsd_disklabel {
|
| 488 | __le32 d_magic;
|
| 489 | __s16 d_type;
|
| 490 | __s16 d_subtype;
|
| 491 | char d_typename[16];
|
| 492 | char d_packname[16];
|
| 493 | __u32 d_secsize;
|
| 494 | __u32 d_nsectors;
|
| 495 | __u32 d_ntracks;
|
| 496 | __u32 d_ncylinders;
|
| 497 | __u32 d_secpercyl;
|
| 498 | __u32 d_secperunit;
|
| 499 | __u16 d_sparespertrack;
|
| 500 | __u16 d_sparespercyl;
|
| 501 | __u32 d_acylinders;
|
| 502 | __u16 d_rpm;
|
| 503 | __u16 d_interleave;
|
| 504 | __u16 d_trackskew;
|
| 505 | __u16 d_cylskew;
|
| 506 | __u32 d_headswitch;
|
| 507 | __u32 d_trkseek;
|
| 508 | __u32 d_flags;
|
| 509 | #define NDDATA 5
|
| 510 | __u32 d_drivedata[NDDATA];
|
| 511 | #define NSPARE 5
|
| 512 | __u32 d_spare[NSPARE];
|
| 513 | __le32 d_magic2;
|
| 514 | __le16 d_checksum;
|
| 515 |
|
| 516 |
|
| 517 | __le16 d_npartitions;
|
| 518 | __le32 d_bbsize;
|
| 519 | __le32 d_sbsize;
|
| 520 | struct bsd_partition {
|
| 521 | __le32 p_size;
|
| 522 | __le32 p_offset;
|
| 523 | __le32 p_fsize;
|
| 524 | __u8 p_fstype;
|
| 525 | __u8 p_frag;
|
| 526 | __le16 p_cpg;
|
| 527 | } d_partitions[BSD_MAXPARTITIONS];
|
| 528 | };
|
| 529 |
|
| 530 | #endif
|
| 531 |
|
| 532 | #ifdef CONFIG_UNIXWARE_DISKLABEL
|
| 533 | |
| 534 | * Unixware slices support by Andrzej Krzysztofowicz <[email protected]>
|
| 535 | * and Krzysztof G. Baranowski <[email protected]>
|
| 536 |
|
| 537 |
|
| 538 | #define UNIXWARE_DISKMAGIC (0xCA5E600DUL)
|
| 539 | #define UNIXWARE_DISKMAGIC2 (0x600DDEEEUL)
|
| 540 | #define UNIXWARE_NUMSLICE 16
|
| 541 | #define UNIXWARE_FS_UNUSED 0
|
| 542 |
|
| 543 | struct unixware_slice {
|
| 544 | __le16 s_label;
|
| 545 | __le16 s_flags;
|
| 546 | __le32 start_sect;
|
| 547 | __le32 nr_sects;
|
| 548 | };
|
| 549 |
|
| 550 | struct unixware_disklabel {
|
| 551 | __le32 d_type;
|
| 552 | __le32 d_magic;
|
| 553 | __le32 d_version;
|
| 554 | char d_serial[12];
|
| 555 | __le32 d_ncylinders;
|
| 556 | __le32 d_ntracks;
|
| 557 | __le32 d_nsectors;
|
| 558 | __le32 d_secsize;
|
| 559 | __le32 d_part_start;
|
| 560 | __le32 d_unknown1[12];
|
| 561 | __le32 d_alt_tbl;
|
| 562 | __le32 d_alt_len;
|
| 563 | __le32 d_phys_cyl;
|
| 564 | __le32 d_phys_trk;
|
| 565 | __le32 d_phys_sec;
|
| 566 | __le32 d_phys_bytes;
|
| 567 | __le32 d_unknown2;
|
| 568 | __le32 d_unknown3;
|
| 569 | __le32 d_pad[8];
|
| 570 |
|
| 571 | struct unixware_vtoc {
|
| 572 | __le32 v_magic;
|
| 573 | __le32 v_version;
|
| 574 | char v_name[8];
|
| 575 | __le16 v_nslices;
|
| 576 | __le16 v_unknown1;
|
| 577 | __le32 v_reserved[10];
|
| 578 | struct unixware_slice
|
| 579 | v_slice[UNIXWARE_NUMSLICE];
|
| 580 | } vtoc;
|
| 581 |
|
| 582 | };
|
| 583 |
|
| 584 | #endif
|
| 585 |
|
| 586 | #ifdef CONFIG_MINIX_SUBPARTITION
|
| 587 | # define MINIX_NR_SUBPARTITIONS 4
|
| 588 | #endif
|
| 589 |
|
| 590 | #define ADDPART_FLAG_NONE 0
|
| 591 | #define ADDPART_FLAG_RAID 1
|
| 592 | #define ADDPART_FLAG_WHOLEDISK 2
|
| 593 |
|
| 594 | extern int blk_alloc_devt(struct hd_struct *part, dev_t *devt);
|
| 595 | extern void blk_free_devt(dev_t devt);
|
| 596 | extern dev_t blk_lookup_devt(const char *name, int partno);
|
| 597 | extern char *disk_name (struct gendisk *hd, int partno, char *buf);
|
| 598 |
|
| 599 | extern int disk_expand_part_tbl(struct gendisk *disk, int target);
|
| 600 | extern int rescan_partitions(struct gendisk *disk, struct block_device *bdev);
|
| 601 | extern int invalidate_partitions(struct gendisk *disk, struct block_device *bdev);
|
| 602 | extern struct hd_struct * __must_check add_partition(struct gendisk *disk,
|
| 603 | int partno, sector_t start,
|
| 604 | sector_t len, int flags,
|
| 605 | struct partition_meta_info
|
| 606 | *info);
|
| 607 | extern void __delete_partition(struct percpu_ref *);
|
| 608 | extern void delete_partition(struct gendisk *, int);
|
| 609 | extern void printk_all_partitions(void);
|
| 610 |
|
| 611 | extern struct gendisk *alloc_disk_node(int minors, int node_id);
|
| 612 | extern struct gendisk *alloc_disk(int minors);
|
| 613 | extern struct kobject *get_disk(struct gendisk *disk);
|
| 614 | extern void put_disk(struct gendisk *disk);
|
| 615 | extern void blk_register_region(dev_t devt, unsigned long range,
|
| 616 | struct module *module,
|
| 617 | struct kobject *(*probe)(dev_t, int *, void *),
|
| 618 | int (*lock)(dev_t, void *),
|
| 619 | void *data);
|
| 620 | extern void blk_unregister_region(dev_t devt, unsigned long range);
|
| 621 |
|
| 622 | extern ssize_t part_size_show(struct device *dev,
|
| 623 | struct device_attribute *attr, char *buf);
|
| 624 | extern ssize_t part_stat_show(struct device *dev,
|
| 625 | struct device_attribute *attr, char *buf);
|
| 626 | extern ssize_t part_inflight_show(struct device *dev,
|
| 627 | struct device_attribute *attr, char *buf);
|
| 628 | #ifdef CONFIG_FAIL_MAKE_REQUEST
|
| 629 | extern ssize_t part_fail_show(struct device *dev,
|
| 630 | struct device_attribute *attr, char *buf);
|
| 631 | extern ssize_t part_fail_store(struct device *dev,
|
| 632 | struct device_attribute *attr,
|
| 633 | const char *buf, size_t count);
|
| 634 | #endif
|
| 635 |
|
| 636 | static inline int hd_ref_init(struct hd_struct *part)
|
| 637 | {
|
| 638 | if (percpu_ref_init(&part->ref, __delete_partition, 0,
|
| 639 | GFP_KERNEL))
|
| 640 | return -ENOMEM;
|
| 641 | return 0;
|
| 642 | }
|
| 643 |
|
| 644 | static inline void hd_struct_get(struct hd_struct *part)
|
| 645 | {
|
| 646 | percpu_ref_get(&part->ref);
|
| 647 | }
|
| 648 |
|
| 649 | static inline int hd_struct_try_get(struct hd_struct *part)
|
| 650 | {
|
| 651 | return percpu_ref_tryget_live(&part->ref);
|
| 652 | }
|
| 653 |
|
| 654 | static inline void hd_struct_put(struct hd_struct *part)
|
| 655 | {
|
| 656 | percpu_ref_put(&part->ref);
|
| 657 | }
|
| 658 |
|
| 659 | static inline void hd_struct_kill(struct hd_struct *part)
|
| 660 | {
|
| 661 | percpu_ref_kill(&part->ref);
|
| 662 | }
|
| 663 |
|
| 664 | static inline void hd_free_part(struct hd_struct *part)
|
| 665 | {
|
| 666 | free_part_stats(part);
|
| 667 | free_part_info(part);
|
| 668 | percpu_ref_exit(&part->ref);
|
| 669 | }
|
| 670 |
|
| 671 | |
| 672 | * Any access of part->nr_sects which is not protected by partition
|
| 673 | * bd_mutex or gendisk bdev bd_mutex, should be done using this
|
| 674 | * accessor function.
|
| 675 | *
|
| 676 | * Code written along the lines of i_size_read() and i_size_write().
|
| 677 | * CONFIG_PREEMPT case optimizes the case of UP kernel with preemption
|
| 678 | * on.
|
| 679 |
|
| 680 | static inline sector_t part_nr_sects_read(struct hd_struct *part)
|
| 681 | {
|
| 682 | #if BITS_PER_LONG==32 && defined(CONFIG_LBDAF) && defined(CONFIG_SMP)
|
| 683 | sector_t nr_sects;
|
| 684 | unsigned seq;
|
| 685 | do {
|
| 686 | seq = read_seqcount_begin(&part->nr_sects_seq);
|
| 687 | nr_sects = part->nr_sects;
|
| 688 | } while (read_seqcount_retry(&part->nr_sects_seq, seq));
|
| 689 | return nr_sects;
|
| 690 | #elif BITS_PER_LONG==32 && defined(CONFIG_LBDAF) && defined(CONFIG_PREEMPT)
|
| 691 | sector_t nr_sects;
|
| 692 |
|
| 693 | preempt_disable();
|
| 694 | nr_sects = part->nr_sects;
|
| 695 | preempt_enable();
|
| 696 | return nr_sects;
|
| 697 | #else
|
| 698 | return part->nr_sects;
|
| 699 | #endif
|
| 700 | }
|
| 701 |
|
| 702 | |
| 703 | * Should be called with mutex lock held (typically bd_mutex) of partition
|
| 704 | * to provide mutual exlusion among writers otherwise seqcount might be
|
| 705 | * left in wrong state leaving the readers spinning infinitely.
|
| 706 |
|
| 707 | static inline void part_nr_sects_write(struct hd_struct *part, sector_t size)
|
| 708 | {
|
| 709 | #if BITS_PER_LONG==32 && defined(CONFIG_LBDAF) && defined(CONFIG_SMP)
|
| 710 | write_seqcount_begin(&part->nr_sects_seq);
|
| 711 | part->nr_sects = size;
|
| 712 | write_seqcount_end(&part->nr_sects_seq);
|
| 713 | #elif BITS_PER_LONG==32 && defined(CONFIG_LBDAF) && defined(CONFIG_PREEMPT)
|
| 714 | preempt_disable();
|
| 715 | part->nr_sects = size;
|
| 716 | preempt_enable();
|
| 717 | #else
|
| 718 | part->nr_sects = size;
|
| 719 | #endif
|
| 720 | }
|
| 721 |
|
| 722 | #if defined(CONFIG_BLK_DEV_INTEGRITY)
|
| 723 | extern void blk_integrity_add(struct gendisk *);
|
| 724 | extern void blk_integrity_del(struct gendisk *);
|
| 725 | #else
|
| 726 | static inline void blk_integrity_add(struct gendisk *disk) { }
|
| 727 | static inline void blk_integrity_del(struct gendisk *disk) { }
|
| 728 | #endif
|
| 729 |
|
| 730 | #else
|
| 731 |
|
| 732 | static inline void printk_all_partitions(void) { }
|
| 733 |
|
| 734 | static inline dev_t blk_lookup_devt(const char *name, int partno)
|
| 735 | {
|
| 736 | dev_t devt = MKDEV(0, 0);
|
| 737 | return devt;
|
| 738 | }
|
| 739 |
|
| 740 | static inline int blk_part_pack_uuid(const u8 *uuid_str, u8 *to)
|
| 741 | {
|
| 742 | return -EINVAL;
|
| 743 | }
|
| 744 | #endif
|
| 745 |
|
| 746 | #endif
|