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#include <linux/slab.h> 16 17#ifdef CONFIG_BLOCK 18 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 24extern struct device_type part_type; 25extern struct kobject *block_depr; 26extern struct class block_class; 27 28enum { 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 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 68struct 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 81struct 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 90#define PARTITION_META_INFO_VOLNAMELTH 64 91/* 92 * Enough for the string representation of any kind of UUID plus NULL. 93 * EFI UUID is 36 characters. MSDOS UUID is 11 characters. 94 */ 95#define PARTITION_META_INFO_UUIDLTH 37 96 97struct partition_meta_info { 98 char uuid[PARTITION_META_INFO_UUIDLTH]; 99 u8 volname[PARTITION_META_INFO_VOLNAMELTH]; 100}; 101 102struct hd_struct { 103 sector_t start_sect; 104 /* 105 * nr_sects is protected by sequence counter. One might extend a 106 * partition while IO is happening to it and update of nr_sects 107 * can be non-atomic on 32bit machines with 64bit sector_t. 108 */ 109 sector_t nr_sects; 110 seqcount_t nr_sects_seq; 111 sector_t alignment_offset; 112 unsigned int discard_alignment; 113 struct device __dev; 114 struct kobject *holder_dir; 115 int policy, partno; 116 struct partition_meta_info *info; 117#ifdef CONFIG_FAIL_MAKE_REQUEST 118 int make_it_fail; 119#endif 120 unsigned long stamp; 121 atomic_t in_flight[2]; 122#ifdef CONFIG_SMP 123 struct disk_stats __percpu *dkstats; 124#else 125 struct disk_stats dkstats; 126#endif 127 atomic_t ref; 128 struct rcu_head rcu_head; 129}; 130 131#define GENHD_FL_REMOVABLE 1 132/* 2 is unused */ 133#define GENHD_FL_MEDIA_CHANGE_NOTIFY 4 134#define GENHD_FL_CD 8 135#define GENHD_FL_UP 16 136#define GENHD_FL_SUPPRESS_PARTITION_INFO 32 137#define GENHD_FL_EXT_DEVT 64 /* allow extended devt */ 138#define GENHD_FL_NATIVE_CAPACITY 128 139#define GENHD_FL_BLOCK_EVENTS_ON_EXCL_WRITE 256 140#define GENHD_FL_NO_PART_SCAN 512 141 142enum { 143 DISK_EVENT_MEDIA_CHANGE = 1 << 0, /* media changed */ 144 DISK_EVENT_EJECT_REQUEST = 1 << 1, /* eject requested */ 145}; 146 147#define BLK_SCSI_MAX_CMDS (256) 148#define BLK_SCSI_CMD_PER_LONG (BLK_SCSI_MAX_CMDS / (sizeof(long) * 8)) 149 150struct blk_scsi_cmd_filter { 151 unsigned long read_ok[BLK_SCSI_CMD_PER_LONG]; 152 unsigned long write_ok[BLK_SCSI_CMD_PER_LONG]; 153 struct kobject kobj; 154}; 155 156struct disk_part_tbl { 157 struct rcu_head rcu_head; 158 int len; 159 struct hd_struct __rcu *last_lookup; 160 struct hd_struct __rcu *part[]; 161}; 162 163struct disk_events; 164 165struct gendisk { 166 /* major, first_minor and minors are input parameters only, 167 * don't use directly. Use disk_devt() and disk_max_parts(). 168 */ 169 int major; /* major number of driver */ 170 int first_minor; 171 int minors; /* maximum number of minors, =1 for 172 * disks that can't be partitioned. */ 173 174 char disk_name[DISK_NAME_LEN]; /* name of major driver */ 175 char *(*devnode)(struct gendisk *gd, umode_t *mode); 176 177 unsigned int events; /* supported events */ 178 unsigned int async_events; /* async events, subset of all */ 179 180 /* Array of pointers to partitions indexed by partno. 181 * Protected with matching bdev lock but stat and other 182 * non-critical accesses use RCU. Always access through 183 * helpers. 184 */ 185 struct disk_part_tbl __rcu *part_tbl; 186 struct hd_struct part0; 187 188 const struct block_device_operations *fops; 189 struct request_queue *queue; 190 void *private_data; 191 192 int flags; 193 struct device *driverfs_dev; // FIXME: remove 194 struct kobject *slave_dir; 195 196 struct timer_rand_state *random; 197 atomic_t sync_io; /* RAID */ 198 struct disk_events *ev; 199#ifdef CONFIG_BLK_DEV_INTEGRITY 200 struct blk_integrity *integrity; 201#endif 202 int node_id; 203}; 204 205static inline struct gendisk *part_to_disk(struct hd_struct *part) 206{ 207 if (likely(part)) { 208 if (part->partno) 209 return dev_to_disk(part_to_dev(part)->parent); 210 else 211 return dev_to_disk(part_to_dev(part)); 212 } 213 return NULL; 214} 215 216static inline void part_pack_uuid(const u8 *uuid_str, u8 *to) 217{ 218 int i; 219 for (i = 0; i < 16; ++i) { 220 *to++ = (hex_to_bin(*uuid_str) << 4) | 221 (hex_to_bin(*(uuid_str + 1))); 222 uuid_str += 2; 223 switch (i) { 224 case 3: 225 case 5: 226 case 7: 227 case 9: 228 uuid_str++; 229 continue; 230 } 231 } 232} 233 234static inline int blk_part_pack_uuid(const u8 *uuid_str, u8 *to) 235{ 236 part_pack_uuid(uuid_str, to); 237 return 0; 238} 239 240static inline int disk_max_parts(struct gendisk *disk) 241{ 242 if (disk->flags & GENHD_FL_EXT_DEVT) 243 return DISK_MAX_PARTS; 244 return disk->minors; 245} 246 247static inline bool disk_part_scan_enabled(struct gendisk *disk) 248{ 249 return disk_max_parts(disk) > 1 && 250 !(disk->flags & GENHD_FL_NO_PART_SCAN); 251} 252 253static inline dev_t disk_devt(struct gendisk *disk) 254{ 255 return disk_to_dev(disk)->devt; 256} 257 258static inline dev_t part_devt(struct hd_struct *part) 259{ 260 return part_to_dev(part)->devt; 261} 262 263extern struct hd_struct *disk_get_part(struct gendisk *disk, int partno); 264 265static inline void disk_put_part(struct hd_struct *part) 266{ 267 if (likely(part)) 268 put_device(part_to_dev(part)); 269} 270 271/* 272 * Smarter partition iterator without context limits. 273 */ 274#define DISK_PITER_REVERSE (1 << 0) /* iterate in the reverse direction */ 275#define DISK_PITER_INCL_EMPTY (1 << 1) /* include 0-sized parts */ 276#define DISK_PITER_INCL_PART0 (1 << 2) /* include partition 0 */ 277#define DISK_PITER_INCL_EMPTY_PART0 (1 << 3) /* include empty partition 0 */ 278 279struct disk_part_iter { 280 struct gendisk *disk; 281 struct hd_struct *part; 282 int idx; 283 unsigned int flags; 284}; 285 286extern void disk_part_iter_init(struct disk_part_iter *piter, 287 struct gendisk *disk, unsigned int flags); 288extern struct hd_struct *disk_part_iter_next(struct disk_part_iter *piter); 289extern void disk_part_iter_exit(struct disk_part_iter *piter); 290 291extern struct hd_struct *disk_map_sector_rcu(struct gendisk *disk, 292 sector_t sector); 293 294/* 295 * Macros to operate on percpu disk statistics: 296 * 297 * {disk|part|all}_stat_{add|sub|inc|dec}() modify the stat counters 298 * and should be called between disk_stat_lock() and 299 * disk_stat_unlock(). 300 * 301 * part_stat_read() can be called at any time. 302 * 303 * part_stat_{add|set_all}() and {init|free}_part_stats are for 304 * internal use only. 305 */ 306#ifdef CONFIG_SMP 307#define part_stat_lock() ({ rcu_read_lock(); get_cpu(); }) 308#define part_stat_unlock() do { put_cpu(); rcu_read_unlock(); } while (0) 309 310#define __part_stat_add(cpu, part, field, addnd) \ 311 (per_cpu_ptr((part)->dkstats, (cpu))->field += (addnd)) 312 313#define part_stat_read(part, field) \ 314({ \ 315 typeof((part)->dkstats->field) res = 0; \ 316 unsigned int _cpu; \ 317 for_each_possible_cpu(_cpu) \ 318 res += per_cpu_ptr((part)->dkstats, _cpu)->field; \ 319 res; \ 320}) 321 322static inline void part_stat_set_all(struct hd_struct *part, int value) 323{ 324 int i; 325 326 for_each_possible_cpu(i) 327 memset(per_cpu_ptr(part->dkstats, i), value, 328 sizeof(struct disk_stats)); 329} 330 331static inline int init_part_stats(struct hd_struct *part) 332{ 333 part->dkstats = alloc_percpu(struct disk_stats); 334 if (!part->dkstats) 335 return 0; 336 return 1; 337} 338 339static inline void free_part_stats(struct hd_struct *part) 340{ 341 free_percpu(part->dkstats); 342} 343 344#else /* !CONFIG_SMP */ 345#define part_stat_lock() ({ rcu_read_lock(); 0; }) 346#define part_stat_unlock() rcu_read_unlock() 347 348#define __part_stat_add(cpu, part, field, addnd) \ 349 ((part)->dkstats.field += addnd) 350 351#define part_stat_read(part, field) ((part)->dkstats.field) 352 353static inline void part_stat_set_all(struct hd_struct *part, int value) 354{ 355 memset(&part->dkstats, value, sizeof(struct disk_stats)); 356} 357 358static inline int init_part_stats(struct hd_struct *part) 359{ 360 return 1; 361} 362 363static inline void free_part_stats(struct hd_struct *part) 364{ 365} 366 367#endif /* CONFIG_SMP */ 368 369#define part_stat_add(cpu, part, field, addnd) do { \ 370 __part_stat_add((cpu), (part), field, addnd); \ 371 if ((part)->partno) \ 372 __part_stat_add((cpu), &part_to_disk((part))->part0, \ 373 field, addnd); \ 374} while (0) 375 376#define part_stat_dec(cpu, gendiskp, field) \ 377 part_stat_add(cpu, gendiskp, field, -1) 378#define part_stat_inc(cpu, gendiskp, field) \ 379 part_stat_add(cpu, gendiskp, field, 1) 380#define part_stat_sub(cpu, gendiskp, field, subnd) \ 381 part_stat_add(cpu, gendiskp, field, -subnd) 382 383static inline void part_inc_in_flight(struct hd_struct *part, int rw) 384{ 385 atomic_inc(&part->in_flight[rw]); 386 if (part->partno) 387 atomic_inc(&part_to_disk(part)->part0.in_flight[rw]); 388} 389 390static inline void part_dec_in_flight(struct hd_struct *part, int rw) 391{ 392 atomic_dec(&part->in_flight[rw]); 393 if (part->partno) 394 atomic_dec(&part_to_disk(part)->part0.in_flight[rw]); 395} 396 397static inline int part_in_flight(struct hd_struct *part) 398{ 399 return atomic_read(&part->in_flight[0]) + atomic_read(&part->in_flight[1]); 400} 401 402static inline struct partition_meta_info *alloc_part_info(struct gendisk *disk) 403{ 404 if (disk) 405 return kzalloc_node(sizeof(struct partition_meta_info), 406 GFP_KERNEL, disk->node_id); 407 return kzalloc(sizeof(struct partition_meta_info), GFP_KERNEL); 408} 409 410static inline void free_part_info(struct hd_struct *part) 411{ 412 kfree(part->info); 413} 414 415/* block/blk-core.c */ 416extern void part_round_stats(int cpu, struct hd_struct *part); 417 418/* block/genhd.c */ 419extern void add_disk(struct gendisk *disk); 420extern void del_gendisk(struct gendisk *gp); 421extern struct gendisk *get_gendisk(dev_t dev, int *partno); 422extern struct block_device *bdget_disk(struct gendisk *disk, int partno); 423 424extern void set_device_ro(struct block_device *bdev, int flag); 425extern void set_disk_ro(struct gendisk *disk, int flag); 426 427static inline int get_disk_ro(struct gendisk *disk) 428{ 429 return disk->part0.policy; 430} 431 432extern void disk_block_events(struct gendisk *disk); 433extern void disk_unblock_events(struct gendisk *disk); 434extern void disk_flush_events(struct gendisk *disk, unsigned int mask); 435extern unsigned int disk_clear_events(struct gendisk *disk, unsigned int mask); 436 437/* drivers/char/random.c */ 438extern void add_disk_randomness(struct gendisk *disk); 439extern void rand_initialize_disk(struct gendisk *disk); 440 441static inline sector_t get_start_sect(struct block_device *bdev) 442{ 443 return bdev->bd_part->start_sect; 444} 445static inline sector_t get_capacity(struct gendisk *disk) 446{ 447 return disk->part0.nr_sects; 448} 449static inline void set_capacity(struct gendisk *disk, sector_t size) 450{ 451 disk->part0.nr_sects = size; 452} 453 454#ifdef CONFIG_SOLARIS_X86_PARTITION 455 456#define SOLARIS_X86_NUMSLICE 16 457#define SOLARIS_X86_VTOC_SANE (0x600DDEEEUL) 458 459struct solaris_x86_slice { 460 __le16 s_tag; /* ID tag of partition */ 461 __le16 s_flag; /* permission flags */ 462 __le32 s_start; /* start sector no of partition */ 463 __le32 s_size; /* # of blocks in partition */ 464}; 465 466struct solaris_x86_vtoc { 467 unsigned int v_bootinfo[3]; /* info needed by mboot (unsupported) */ 468 __le32 v_sanity; /* to verify vtoc sanity */ 469 __le32 v_version; /* layout version */ 470 char v_volume[8]; /* volume name */ 471 __le16 v_sectorsz; /* sector size in bytes */ 472 __le16 v_nparts; /* number of partitions */ 473 unsigned int v_reserved[10]; /* free space */ 474 struct solaris_x86_slice 475 v_slice[SOLARIS_X86_NUMSLICE]; /* slice headers */ 476 unsigned int timestamp[SOLARIS_X86_NUMSLICE]; /* timestamp (unsupported) */ 477 char v_asciilabel[128]; /* for compatibility */ 478}; 479 480#endif /* CONFIG_SOLARIS_X86_PARTITION */ 481 482#ifdef CONFIG_BSD_DISKLABEL 483/* 484 * BSD disklabel support by Yossi Gottlieb <yogo@math.tau.ac.il> 485 * updated by Marc Espie <Marc.Espie@openbsd.org> 486 */ 487 488/* check against BSD src/sys/sys/disklabel.h for consistency */ 489 490#define BSD_DISKMAGIC (0x82564557UL) /* The disk magic number */ 491#define BSD_MAXPARTITIONS 16 492#define OPENBSD_MAXPARTITIONS 16 493#define BSD_FS_UNUSED 0 /* disklabel unused partition entry ID */ 494struct bsd_disklabel { 495 __le32 d_magic; /* the magic number */ 496 __s16 d_type; /* drive type */ 497 __s16 d_subtype; /* controller/d_type specific */ 498 char d_typename[16]; /* type name, e.g. "eagle" */ 499 char d_packname[16]; /* pack identifier */ 500 __u32 d_secsize; /* # of bytes per sector */ 501 __u32 d_nsectors; /* # of data sectors per track */ 502 __u32 d_ntracks; /* # of tracks per cylinder */ 503 __u32 d_ncylinders; /* # of data cylinders per unit */ 504 __u32 d_secpercyl; /* # of data sectors per cylinder */ 505 __u32 d_secperunit; /* # of data sectors per unit */ 506 __u16 d_sparespertrack; /* # of spare sectors per track */ 507 __u16 d_sparespercyl; /* # of spare sectors per cylinder */ 508 __u32 d_acylinders; /* # of alt. cylinders per unit */ 509 __u16 d_rpm; /* rotational speed */ 510 __u16 d_interleave; /* hardware sector interleave */ 511 __u16 d_trackskew; /* sector 0 skew, per track */ 512 __u16 d_cylskew; /* sector 0 skew, per cylinder */ 513 __u32 d_headswitch; /* head switch time, usec */ 514 __u32 d_trkseek; /* track-to-track seek, usec */ 515 __u32 d_flags; /* generic flags */ 516#define NDDATA 5 517 __u32 d_drivedata[NDDATA]; /* drive-type specific information */ 518#define NSPARE 5 519 __u32 d_spare[NSPARE]; /* reserved for future use */ 520 __le32 d_magic2; /* the magic number (again) */ 521 __le16 d_checksum; /* xor of data incl. partitions */ 522 523 /* filesystem and partition information: */ 524 __le16 d_npartitions; /* number of partitions in following */ 525 __le32 d_bbsize; /* size of boot area at sn0, bytes */ 526 __le32 d_sbsize; /* max size of fs superblock, bytes */ 527 struct bsd_partition { /* the partition table */ 528 __le32 p_size; /* number of sectors in partition */ 529 __le32 p_offset; /* starting sector */ 530 __le32 p_fsize; /* filesystem basic fragment size */ 531 __u8 p_fstype; /* filesystem type, see below */ 532 __u8 p_frag; /* filesystem fragments per block */ 533 __le16 p_cpg; /* filesystem cylinders per group */ 534 } d_partitions[BSD_MAXPARTITIONS]; /* actually may be more */ 535}; 536 537#endif /* CONFIG_BSD_DISKLABEL */ 538 539#ifdef CONFIG_UNIXWARE_DISKLABEL 540/* 541 * Unixware slices support by Andrzej Krzysztofowicz <ankry@mif.pg.gda.pl> 542 * and Krzysztof G. Baranowski <kgb@knm.org.pl> 543 */ 544 545#define UNIXWARE_DISKMAGIC (0xCA5E600DUL) /* The disk magic number */ 546#define UNIXWARE_DISKMAGIC2 (0x600DDEEEUL) /* The slice table magic nr */ 547#define UNIXWARE_NUMSLICE 16 548#define UNIXWARE_FS_UNUSED 0 /* Unused slice entry ID */ 549 550struct unixware_slice { 551 __le16 s_label; /* label */ 552 __le16 s_flags; /* permission flags */ 553 __le32 start_sect; /* starting sector */ 554 __le32 nr_sects; /* number of sectors in slice */ 555}; 556 557struct unixware_disklabel { 558 __le32 d_type; /* drive type */ 559 __le32 d_magic; /* the magic number */ 560 __le32 d_version; /* version number */ 561 char d_serial[12]; /* serial number of the device */ 562 __le32 d_ncylinders; /* # of data cylinders per device */ 563 __le32 d_ntracks; /* # of tracks per cylinder */ 564 __le32 d_nsectors; /* # of data sectors per track */ 565 __le32 d_secsize; /* # of bytes per sector */ 566 __le32 d_part_start; /* # of first sector of this partition */ 567 __le32 d_unknown1[12]; /* ? */ 568 __le32 d_alt_tbl; /* byte offset of alternate table */ 569 __le32 d_alt_len; /* byte length of alternate table */ 570 __le32 d_phys_cyl; /* # of physical cylinders per device */ 571 __le32 d_phys_trk; /* # of physical tracks per cylinder */ 572 __le32 d_phys_sec; /* # of physical sectors per track */ 573 __le32 d_phys_bytes; /* # of physical bytes per sector */ 574 __le32 d_unknown2; /* ? */ 575 __le32 d_unknown3; /* ? */ 576 __le32 d_pad[8]; /* pad */ 577 578 struct unixware_vtoc { 579 __le32 v_magic; /* the magic number */ 580 __le32 v_version; /* version number */ 581 char v_name[8]; /* volume name */ 582 __le16 v_nslices; /* # of slices */ 583 __le16 v_unknown1; /* ? */ 584 __le32 v_reserved[10]; /* reserved */ 585 struct unixware_slice 586 v_slice[UNIXWARE_NUMSLICE]; /* slice headers */ 587 } vtoc; 588 589}; /* 408 */ 590 591#endif /* CONFIG_UNIXWARE_DISKLABEL */ 592 593#ifdef CONFIG_MINIX_SUBPARTITION 594# define MINIX_NR_SUBPARTITIONS 4 595#endif /* CONFIG_MINIX_SUBPARTITION */ 596 597#define ADDPART_FLAG_NONE 0 598#define ADDPART_FLAG_RAID 1 599#define ADDPART_FLAG_WHOLEDISK 2 600 601extern int blk_alloc_devt(struct hd_struct *part, dev_t *devt); 602extern void blk_free_devt(dev_t devt); 603extern dev_t blk_lookup_devt(const char *name, int partno); 604extern char *disk_name (struct gendisk *hd, int partno, char *buf); 605 606extern int disk_expand_part_tbl(struct gendisk *disk, int target); 607extern int rescan_partitions(struct gendisk *disk, struct block_device *bdev); 608extern int invalidate_partitions(struct gendisk *disk, struct block_device *bdev); 609extern struct hd_struct * __must_check add_partition(struct gendisk *disk, 610 int partno, sector_t start, 611 sector_t len, int flags, 612 struct partition_meta_info 613 *info); 614extern void __delete_partition(struct hd_struct *); 615extern void delete_partition(struct gendisk *, int); 616extern void printk_all_partitions(void); 617 618extern struct gendisk *alloc_disk_node(int minors, int node_id); 619extern struct gendisk *alloc_disk(int minors); 620extern struct kobject *get_disk(struct gendisk *disk); 621extern void put_disk(struct gendisk *disk); 622extern void blk_register_region(dev_t devt, unsigned long range, 623 struct module *module, 624 struct kobject *(*probe)(dev_t, int *, void *), 625 int (*lock)(dev_t, void *), 626 void *data); 627extern void blk_unregister_region(dev_t devt, unsigned long range); 628 629extern ssize_t part_size_show(struct device *dev, 630 struct device_attribute *attr, char *buf); 631extern ssize_t part_stat_show(struct device *dev, 632 struct device_attribute *attr, char *buf); 633extern ssize_t part_inflight_show(struct device *dev, 634 struct device_attribute *attr, char *buf); 635#ifdef CONFIG_FAIL_MAKE_REQUEST 636extern ssize_t part_fail_show(struct device *dev, 637 struct device_attribute *attr, char *buf); 638extern ssize_t part_fail_store(struct device *dev, 639 struct device_attribute *attr, 640 const char *buf, size_t count); 641#endif /* CONFIG_FAIL_MAKE_REQUEST */ 642 643static inline void hd_ref_init(struct hd_struct *part) 644{ 645 atomic_set(&part->ref, 1); 646 smp_mb(); 647} 648 649static inline void hd_struct_get(struct hd_struct *part) 650{ 651 atomic_inc(&part->ref); 652 smp_mb__after_atomic(); 653} 654 655static inline int hd_struct_try_get(struct hd_struct *part) 656{ 657 return atomic_inc_not_zero(&part->ref); 658} 659 660static inline void hd_struct_put(struct hd_struct *part) 661{ 662 if (atomic_dec_and_test(&part->ref)) 663 __delete_partition(part); 664} 665 666/* 667 * Any access of part->nr_sects which is not protected by partition 668 * bd_mutex or gendisk bdev bd_mutex, should be done using this 669 * accessor function. 670 * 671 * Code written along the lines of i_size_read() and i_size_write(). 672 * CONFIG_PREEMPT case optimizes the case of UP kernel with preemption 673 * on. 674 */ 675static inline sector_t part_nr_sects_read(struct hd_struct *part) 676{ 677#if BITS_PER_LONG==32 && defined(CONFIG_LBDAF) && defined(CONFIG_SMP) 678 sector_t nr_sects; 679 unsigned seq; 680 do { 681 seq = read_seqcount_begin(&part->nr_sects_seq); 682 nr_sects = part->nr_sects; 683 } while (read_seqcount_retry(&part->nr_sects_seq, seq)); 684 return nr_sects; 685#elif BITS_PER_LONG==32 && defined(CONFIG_LBDAF) && defined(CONFIG_PREEMPT) 686 sector_t nr_sects; 687 688 preempt_disable(); 689 nr_sects = part->nr_sects; 690 preempt_enable(); 691 return nr_sects; 692#else 693 return part->nr_sects; 694#endif 695} 696 697/* 698 * Should be called with mutex lock held (typically bd_mutex) of partition 699 * to provide mutual exlusion among writers otherwise seqcount might be 700 * left in wrong state leaving the readers spinning infinitely. 701 */ 702static inline void part_nr_sects_write(struct hd_struct *part, sector_t size) 703{ 704#if BITS_PER_LONG==32 && defined(CONFIG_LBDAF) && defined(CONFIG_SMP) 705 write_seqcount_begin(&part->nr_sects_seq); 706 part->nr_sects = size; 707 write_seqcount_end(&part->nr_sects_seq); 708#elif BITS_PER_LONG==32 && defined(CONFIG_LBDAF) && defined(CONFIG_PREEMPT) 709 preempt_disable(); 710 part->nr_sects = size; 711 preempt_enable(); 712#else 713 part->nr_sects = size; 714#endif 715} 716 717#else /* CONFIG_BLOCK */ 718 719static inline void printk_all_partitions(void) { } 720 721static inline dev_t blk_lookup_devt(const char *name, int partno) 722{ 723 dev_t devt = MKDEV(0, 0); 724 return devt; 725} 726 727static inline int blk_part_pack_uuid(const u8 *uuid_str, u8 *to) 728{ 729 return -EINVAL; 730} 731#endif /* CONFIG_BLOCK */ 732 733#endif /* _LINUX_GENHD_H */ 734