1#ifndef _LINUX_GENHD_H
2#define _LINUX_GENHD_H
3
4
5
6
7
8
9
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
30
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,
41
42 SOLARIS_X86_PARTITION = LINUX_SWAP_PARTITION,
43 NEW_SOLARIS_X86_PARTITION = 0xbf,
44
45 DM6_AUX1PARTITION = 0x51,
46 DM6_AUX3PARTITION = 0x53,
47 DM6_PARTITION = 0x54,
48 EZD_PARTITION = 0x55,
49
50 FREEBSD_PARTITION = 0xa5,
51 OPENBSD_PARTITION = 0xa6,
52 NETBSD_PARTITION = 0xa9,
53 BSDI_PARTITION = 0xb7,
54 MINIX_PARTITION = 0x81,
55 UNIXWARE_PARTITION = 0x63,
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;
70 unsigned char head;
71 unsigned char sector;
72 unsigned char cyl;
73 unsigned char sys_ind;
74 unsigned char end_head;
75 unsigned char end_sector;
76 unsigned char end_cyl;
77 __le32 start_sect;
78 __le32 nr_sects;
79} __attribute__((packed));
80
81struct disk_stats {
82 unsigned long sectors[2];
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
93
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
106
107
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
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
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,
144 DISK_EVENT_EJECT_REQUEST = 1 << 1,
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
167
168
169 int major;
170 int first_minor;
171 int minors;
172
173
174 char disk_name[DISK_NAME_LEN];
175 char *(*devnode)(struct gendisk *gd, umode_t *mode);
176
177 unsigned int events;
178 unsigned int async_events;
179
180
181
182
183
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;
194 struct kobject *slave_dir;
195
196 struct timer_rand_state *random;
197 atomic_t sync_io;
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 disk_max_parts(struct gendisk *disk)
235{
236 if (disk->flags & GENHD_FL_EXT_DEVT)
237 return DISK_MAX_PARTS;
238 return disk->minors;
239}
240
241static inline bool disk_part_scan_enabled(struct gendisk *disk)
242{
243 return disk_max_parts(disk) > 1 &&
244 !(disk->flags & GENHD_FL_NO_PART_SCAN);
245}
246
247static inline dev_t disk_devt(struct gendisk *disk)
248{
249 return disk_to_dev(disk)->devt;
250}
251
252static inline dev_t part_devt(struct hd_struct *part)
253{
254 return part_to_dev(part)->devt;
255}
256
257extern struct hd_struct *disk_get_part(struct gendisk *disk, int partno);
258
259static inline void disk_put_part(struct hd_struct *part)
260{
261 if (likely(part))
262 put_device(part_to_dev(part));
263}
264
265
266
267
268#define DISK_PITER_REVERSE (1 << 0)
269#define DISK_PITER_INCL_EMPTY (1 << 1)
270#define DISK_PITER_INCL_PART0 (1 << 2)
271#define DISK_PITER_INCL_EMPTY_PART0 (1 << 3)
272
273struct disk_part_iter {
274 struct gendisk *disk;
275 struct hd_struct *part;
276 int idx;
277 unsigned int flags;
278};
279
280extern void disk_part_iter_init(struct disk_part_iter *piter,
281 struct gendisk *disk, unsigned int flags);
282extern struct hd_struct *disk_part_iter_next(struct disk_part_iter *piter);
283extern void disk_part_iter_exit(struct disk_part_iter *piter);
284
285extern struct hd_struct *disk_map_sector_rcu(struct gendisk *disk,
286 sector_t sector);
287
288
289
290
291
292
293
294
295
296
297
298
299
300#ifdef CONFIG_SMP
301#define part_stat_lock() ({ rcu_read_lock(); get_cpu(); })
302#define part_stat_unlock() do { put_cpu(); rcu_read_unlock(); } while (0)
303
304#define __part_stat_add(cpu, part, field, addnd) \
305 (per_cpu_ptr((part)->dkstats, (cpu))->field += (addnd))
306
307#define part_stat_read(part, field) \
308({ \
309 typeof((part)->dkstats->field) res = 0; \
310 unsigned int _cpu; \
311 for_each_possible_cpu(_cpu) \
312 res += per_cpu_ptr((part)->dkstats, _cpu)->field; \
313 res; \
314})
315
316static inline void part_stat_set_all(struct hd_struct *part, int value)
317{
318 int i;
319
320 for_each_possible_cpu(i)
321 memset(per_cpu_ptr(part->dkstats, i), value,
322 sizeof(struct disk_stats));
323}
324
325static inline int init_part_stats(struct hd_struct *part)
326{
327 part->dkstats = alloc_percpu(struct disk_stats);
328 if (!part->dkstats)
329 return 0;
330 return 1;
331}
332
333static inline void free_part_stats(struct hd_struct *part)
334{
335 free_percpu(part->dkstats);
336}
337
338#else
339#define part_stat_lock() ({ rcu_read_lock(); 0; })
340#define part_stat_unlock() rcu_read_unlock()
341
342#define __part_stat_add(cpu, part, field, addnd) \
343 ((part)->dkstats.field += addnd)
344
345#define part_stat_read(part, field) ((part)->dkstats.field)
346
347static inline void part_stat_set_all(struct hd_struct *part, int value)
348{
349 memset(&part->dkstats, value, sizeof(struct disk_stats));
350}
351
352static inline int init_part_stats(struct hd_struct *part)
353{
354 return 1;
355}
356
357static inline void free_part_stats(struct hd_struct *part)
358{
359}
360
361#endif
362
363#define part_stat_add(cpu, part, field, addnd) do { \
364 __part_stat_add((cpu), (part), field, addnd); \
365 if ((part)->partno) \
366 __part_stat_add((cpu), &part_to_disk((part))->part0, \
367 field, addnd); \
368} while (0)
369
370#define part_stat_dec(cpu, gendiskp, field) \
371 part_stat_add(cpu, gendiskp, field, -1)
372#define part_stat_inc(cpu, gendiskp, field) \
373 part_stat_add(cpu, gendiskp, field, 1)
374#define part_stat_sub(cpu, gendiskp, field, subnd) \
375 part_stat_add(cpu, gendiskp, field, -subnd)
376
377static inline void part_inc_in_flight(struct hd_struct *part, int rw)
378{
379 atomic_inc(&part->in_flight[rw]);
380 if (part->partno)
381 atomic_inc(&part_to_disk(part)->part0.in_flight[rw]);
382}
383
384static inline void part_dec_in_flight(struct hd_struct *part, int rw)
385{
386 atomic_dec(&part->in_flight[rw]);
387 if (part->partno)
388 atomic_dec(&part_to_disk(part)->part0.in_flight[rw]);
389}
390
391static inline int part_in_flight(struct hd_struct *part)
392{
393 return atomic_read(&part->in_flight[0]) + atomic_read(&part->in_flight[1]);
394}
395
396static inline struct partition_meta_info *alloc_part_info(struct gendisk *disk)
397{
398 if (disk)
399 return kzalloc_node(sizeof(struct partition_meta_info),
400 GFP_KERNEL, disk->node_id);
401 return kzalloc(sizeof(struct partition_meta_info), GFP_KERNEL);
402}
403
404static inline void free_part_info(struct hd_struct *part)
405{
406 kfree(part->info);
407}
408
409
410extern void part_round_stats(int cpu, struct hd_struct *part);
411
412
413extern void add_disk(struct gendisk *disk);
414extern void del_gendisk(struct gendisk *gp);
415extern struct gendisk *get_gendisk(dev_t dev, int *partno);
416extern struct block_device *bdget_disk(struct gendisk *disk, int partno);
417
418extern void set_device_ro(struct block_device *bdev, int flag);
419extern void set_disk_ro(struct gendisk *disk, int flag);
420
421static inline int get_disk_ro(struct gendisk *disk)
422{
423 return disk->part0.policy;
424}
425
426extern void disk_block_events(struct gendisk *disk);
427extern void disk_unblock_events(struct gendisk *disk);
428extern void disk_flush_events(struct gendisk *disk, unsigned int mask);
429extern unsigned int disk_clear_events(struct gendisk *disk, unsigned int mask);
430
431
432extern void add_disk_randomness(struct gendisk *disk);
433extern void rand_initialize_disk(struct gendisk *disk);
434
435static inline sector_t get_start_sect(struct block_device *bdev)
436{
437 return bdev->bd_part->start_sect;
438}
439static inline sector_t get_capacity(struct gendisk *disk)
440{
441 return disk->part0.nr_sects;
442}
443static inline void set_capacity(struct gendisk *disk, sector_t size)
444{
445 disk->part0.nr_sects = size;
446}
447
448#ifdef CONFIG_SOLARIS_X86_PARTITION
449
450#define SOLARIS_X86_NUMSLICE 16
451#define SOLARIS_X86_VTOC_SANE (0x600DDEEEUL)
452
453struct solaris_x86_slice {
454 __le16 s_tag;
455 __le16 s_flag;
456 __le32 s_start;
457 __le32 s_size;
458};
459
460struct solaris_x86_vtoc {
461 unsigned int v_bootinfo[3];
462 __le32 v_sanity;
463 __le32 v_version;
464 char v_volume[8];
465 __le16 v_sectorsz;
466 __le16 v_nparts;
467 unsigned int v_reserved[10];
468 struct solaris_x86_slice
469 v_slice[SOLARIS_X86_NUMSLICE];
470 unsigned int timestamp[SOLARIS_X86_NUMSLICE];
471 char v_asciilabel[128];
472};
473
474#endif
475
476#ifdef CONFIG_BSD_DISKLABEL
477
478
479
480
481
482
483
484#define BSD_DISKMAGIC (0x82564557UL)
485#define BSD_MAXPARTITIONS 16
486#define OPENBSD_MAXPARTITIONS 16
487#define BSD_FS_UNUSED 0
488struct bsd_disklabel {
489 __le32 d_magic;
490 __s16 d_type;
491 __s16 d_subtype;
492 char d_typename[16];
493 char d_packname[16];
494 __u32 d_secsize;
495 __u32 d_nsectors;
496 __u32 d_ntracks;
497 __u32 d_ncylinders;
498 __u32 d_secpercyl;
499 __u32 d_secperunit;
500 __u16 d_sparespertrack;
501 __u16 d_sparespercyl;
502 __u32 d_acylinders;
503 __u16 d_rpm;
504 __u16 d_interleave;
505 __u16 d_trackskew;
506 __u16 d_cylskew;
507 __u32 d_headswitch;
508 __u32 d_trkseek;
509 __u32 d_flags;
510#define NDDATA 5
511 __u32 d_drivedata[NDDATA];
512#define NSPARE 5
513 __u32 d_spare[NSPARE];
514 __le32 d_magic2;
515 __le16 d_checksum;
516
517
518 __le16 d_npartitions;
519 __le32 d_bbsize;
520 __le32 d_sbsize;
521 struct bsd_partition {
522 __le32 p_size;
523 __le32 p_offset;
524 __le32 p_fsize;
525 __u8 p_fstype;
526 __u8 p_frag;
527 __le16 p_cpg;
528 } d_partitions[BSD_MAXPARTITIONS];
529};
530
531#endif
532
533#ifdef CONFIG_UNIXWARE_DISKLABEL
534
535
536
537
538
539#define UNIXWARE_DISKMAGIC (0xCA5E600DUL)
540#define UNIXWARE_DISKMAGIC2 (0x600DDEEEUL)
541#define UNIXWARE_NUMSLICE 16
542#define UNIXWARE_FS_UNUSED 0
543
544struct unixware_slice {
545 __le16 s_label;
546 __le16 s_flags;
547 __le32 start_sect;
548 __le32 nr_sects;
549};
550
551struct unixware_disklabel {
552 __le32 d_type;
553 __le32 d_magic;
554 __le32 d_version;
555 char d_serial[12];
556 __le32 d_ncylinders;
557 __le32 d_ntracks;
558 __le32 d_nsectors;
559 __le32 d_secsize;
560 __le32 d_part_start;
561 __le32 d_unknown1[12];
562 __le32 d_alt_tbl;
563 __le32 d_alt_len;
564 __le32 d_phys_cyl;
565 __le32 d_phys_trk;
566 __le32 d_phys_sec;
567 __le32 d_phys_bytes;
568 __le32 d_unknown2;
569 __le32 d_unknown3;
570 __le32 d_pad[8];
571
572 struct unixware_vtoc {
573 __le32 v_magic;
574 __le32 v_version;
575 char v_name[8];
576 __le16 v_nslices;
577 __le16 v_unknown1;
578 __le32 v_reserved[10];
579 struct unixware_slice
580 v_slice[UNIXWARE_NUMSLICE];
581 } vtoc;
582
583};
584
585#endif
586
587#ifdef CONFIG_MINIX_SUBPARTITION
588# define MINIX_NR_SUBPARTITIONS 4
589#endif
590
591#define ADDPART_FLAG_NONE 0
592#define ADDPART_FLAG_RAID 1
593#define ADDPART_FLAG_WHOLEDISK 2
594
595extern int blk_alloc_devt(struct hd_struct *part, dev_t *devt);
596extern void blk_free_devt(dev_t devt);
597extern dev_t blk_lookup_devt(const char *name, int partno);
598extern char *disk_name (struct gendisk *hd, int partno, char *buf);
599
600extern int disk_expand_part_tbl(struct gendisk *disk, int target);
601extern int rescan_partitions(struct gendisk *disk, struct block_device *bdev);
602extern int invalidate_partitions(struct gendisk *disk, struct block_device *bdev);
603extern struct hd_struct * __must_check add_partition(struct gendisk *disk,
604 int partno, sector_t start,
605 sector_t len, int flags,
606 struct partition_meta_info
607 *info);
608extern void __delete_partition(struct hd_struct *);
609extern void delete_partition(struct gendisk *, int);
610extern void printk_all_partitions(void);
611
612extern struct gendisk *alloc_disk_node(int minors, int node_id);
613extern struct gendisk *alloc_disk(int minors);
614extern struct kobject *get_disk(struct gendisk *disk);
615extern void put_disk(struct gendisk *disk);
616extern void blk_register_region(dev_t devt, unsigned long range,
617 struct module *module,
618 struct kobject *(*probe)(dev_t, int *, void *),
619 int (*lock)(dev_t, void *),
620 void *data);
621extern void blk_unregister_region(dev_t devt, unsigned long range);
622
623extern ssize_t part_size_show(struct device *dev,
624 struct device_attribute *attr, char *buf);
625extern ssize_t part_stat_show(struct device *dev,
626 struct device_attribute *attr, char *buf);
627extern ssize_t part_inflight_show(struct device *dev,
628 struct device_attribute *attr, char *buf);
629#ifdef CONFIG_FAIL_MAKE_REQUEST
630extern ssize_t part_fail_show(struct device *dev,
631 struct device_attribute *attr, char *buf);
632extern ssize_t part_fail_store(struct device *dev,
633 struct device_attribute *attr,
634 const char *buf, size_t count);
635#endif
636
637static inline void hd_ref_init(struct hd_struct *part)
638{
639 atomic_set(&part->ref, 1);
640 smp_mb();
641}
642
643static inline void hd_struct_get(struct hd_struct *part)
644{
645 atomic_inc(&part->ref);
646 smp_mb__after_atomic_inc();
647}
648
649static inline int hd_struct_try_get(struct hd_struct *part)
650{
651 return atomic_inc_not_zero(&part->ref);
652}
653
654static inline void hd_struct_put(struct hd_struct *part)
655{
656 if (atomic_dec_and_test(&part->ref))
657 __delete_partition(part);
658}
659
660
661
662
663
664
665
666
667
668
669static inline sector_t part_nr_sects_read(struct hd_struct *part)
670{
671#if BITS_PER_LONG==32 && defined(CONFIG_LBDAF) && defined(CONFIG_SMP)
672 sector_t nr_sects;
673 unsigned seq;
674 do {
675 seq = read_seqcount_begin(&part->nr_sects_seq);
676 nr_sects = part->nr_sects;
677 } while (read_seqcount_retry(&part->nr_sects_seq, seq));
678 return nr_sects;
679#elif BITS_PER_LONG==32 && defined(CONFIG_LBDAF) && defined(CONFIG_PREEMPT)
680 sector_t nr_sects;
681
682 preempt_disable();
683 nr_sects = part->nr_sects;
684 preempt_enable();
685 return nr_sects;
686#else
687 return part->nr_sects;
688#endif
689}
690
691
692
693
694
695
696static inline void part_nr_sects_write(struct hd_struct *part, sector_t size)
697{
698#if BITS_PER_LONG==32 && defined(CONFIG_LBDAF) && defined(CONFIG_SMP)
699 write_seqcount_begin(&part->nr_sects_seq);
700 part->nr_sects = size;
701 write_seqcount_end(&part->nr_sects_seq);
702#elif BITS_PER_LONG==32 && defined(CONFIG_LBDAF) && defined(CONFIG_PREEMPT)
703 preempt_disable();
704 part->nr_sects = size;
705 preempt_enable();
706#else
707 part->nr_sects = size;
708#endif
709}
710
711#else
712
713static inline void printk_all_partitions(void) { }
714
715static inline dev_t blk_lookup_devt(const char *name, int partno)
716{
717 dev_t devt = MKDEV(0, 0);
718 return devt;
719}
720
721#endif
722
723#endif
724