struct partition is the on-disk format of a MSDOS partition table entry.
Move it out of genhd.h into a new msdos_partition.h header and give it
a msdos_ prefix to avoid confusion.
Also move the magic number from block/partitions/msdos.h to the new
header so that it can be used by the SCSI drivers looking at the DOS
partition tables.
Signed-off-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Jens Axboe <axboe@kernel.dk>
 #include <linux/stringify.h>
 #include <linux/kernel.h>
 #include <linux/uuid.h>
+#include <linux/msdos_partition.h>
 
 #include "ldm.h"
 #include "check.h"
-#include "msdos.h"
 
 /*
  * ldm_debug/info/error/crit - Output an error message
 {
        Sector sect;
        u8 *data;
-       struct partition *p;
+       struct msdos_partition *p;
        int i;
        bool result = false;
 
        if (*(__le16*) (data + 0x01FE) != cpu_to_le16 (MSDOS_LABEL_MAGIC))
                goto out;
 
-       p = (struct partition*)(data + 0x01BE);
+       p = (struct msdos_partition *)(data + 0x01BE);
        for (i = 0; i < 4; i++, p++)
                if (SYS_IND (p) == LDM_PARTITION) {
                        result = true;
 
  *  Re-organised Feb 1998 Russell King
  */
 #include <linux/msdos_fs.h>
+#include <linux/msdos_partition.h>
 
 #include "check.h"
-#include "msdos.h"
 #include "efi.h"
 
 /*
 
 #define SYS_IND(p)     get_unaligned(&p->sys_ind)
 
-static inline sector_t nr_sects(struct partition *p)
+static inline sector_t nr_sects(struct msdos_partition *p)
 {
        return (sector_t)get_unaligned_le32(&p->nr_sects);
 }
 
-static inline sector_t start_sect(struct partition *p)
+static inline sector_t start_sect(struct msdos_partition *p)
 {
        return (sector_t)get_unaligned_le32(&p->start_sect);
 }
 
-static inline int is_extended_partition(struct partition *p)
+static inline int is_extended_partition(struct msdos_partition *p)
 {
        return (SYS_IND(p) == DOS_EXTENDED_PARTITION ||
                SYS_IND(p) == WIN98_EXTENDED_PARTITION ||
 #define AIX_LABEL_MAGIC4       0xC1
 static int aix_magic_present(struct parsed_partitions *state, unsigned char *p)
 {
-       struct partition *pt = (struct partition *) (p + 0x1be);
+       struct msdos_partition *pt = (struct msdos_partition *) (p + 0x1be);
        Sector sect;
        unsigned char *d;
        int slot, ret = 0;
                           sector_t first_sector, sector_t first_size,
                           u32 disksig)
 {
-       struct partition *p;
+       struct msdos_partition *p;
        Sector sect;
        unsigned char *data;
        sector_t this_sector, this_size;
                if (!msdos_magic_present(data + 510))
                        goto done;
 
-               p = (struct partition *) (data + 0x1be);
+               p = (struct msdos_partition *) (data + 0x1be);
 
                /*
                 * Usually, the first entry is the real data partition,
 #ifdef CONFIG_MINIX_SUBPARTITION
        Sector sect;
        unsigned char *data;
-       struct partition *p;
+       struct msdos_partition *p;
        int i;
 
        data = read_part_sector(state, offset, §);
        if (!data)
                return;
 
-       p = (struct partition *)(data + 0x1be);
+       p = (struct msdos_partition *)(data + 0x1be);
 
        /* The first sector of a Minix partition can have either
         * a secondary MBR describing its subpartitions, or
        sector_t sector_size = bdev_logical_block_size(state->bdev) / 512;
        Sector sect;
        unsigned char *data;
-       struct partition *p;
+       struct msdos_partition *p;
        struct fat_boot_sector *fb;
        int slot;
        u32 disksig;
         * partition table. Reject this in case the boot indicator
         * is not 0 or 0x80.
         */
-       p = (struct partition *) (data + 0x1be);
+       p = (struct msdos_partition *) (data + 0x1be);
        for (slot = 1; slot <= 4; slot++, p++) {
                if (p->boot_ind != 0 && p->boot_ind != 0x80) {
                        /*
        }
 
 #ifdef CONFIG_EFI_PARTITION
-       p = (struct partition *) (data + 0x1be);
+       p = (struct msdos_partition *) (data + 0x1be);
        for (slot = 1 ; slot <= 4 ; slot++, p++) {
                /* If this is an EFI GPT disk, msdos should ignore it. */
                if (SYS_IND(p) == EFI_PMBR_OSTYPE_EFI_GPT) {
                }
        }
 #endif
-       p = (struct partition *) (data + 0x1be);
+       p = (struct msdos_partition *) (data + 0x1be);
 
        disksig = le32_to_cpup((__le32 *)(data + 0x1b8));
 
        strlcat(state->pp_buf, "\n", PAGE_SIZE);
 
        /* second pass - output for each on a separate line */
-       p = (struct partition *) (0x1be + data);
+       p = (struct msdos_partition *) (0x1be + data);
        for (slot = 1 ; slot <= 4 ; slot++, p++) {
                unsigned char id = SYS_IND(p);
                int n;
 
+++ /dev/null
-/* SPDX-License-Identifier: GPL-2.0 */
-/*
- *  fs/partitions/msdos.h
- */
-
-#define MSDOS_LABEL_MAGIC              0xAA55
-
-
 
 #include <linux/jiffies.h>
 #include <linux/dma-mapping.h>
 #include <linux/slab.h>
+#include <linux/msdos_partition.h>
 #include <scsi/scsicam.h>
 
 #include <asm/dma.h>
           a partition table entry whose end_head matches one of the
           standard BusLogic geometry translations (64/32, 128/32, or 255/63).
         */
-       if (*(unsigned short *) (buf + 64) == 0xAA55) {
-               struct partition *part1_entry = (struct partition *) buf;
-               struct partition *part_entry = part1_entry;
+       if (*(unsigned short *) (buf + 64) == MSDOS_LABEL_MAGIC) {
+               struct msdos_partition *part1_entry =
+                               (struct msdos_partition *)buf;
+               struct msdos_partition *part_entry = part1_entry;
                int saved_cyl = diskparam->cylinders, part_no;
                unsigned char part_end_head = 0, part_end_sector = 0;
 
 
 #include <linux/syscalls.h>
 #include <linux/delay.h>
 #include <linux/kthread.h>
+#include <linux/msdos_partition.h>
 
 #include <scsi/scsi.h>
 #include <scsi/scsi_cmnd.h>
        buf = scsi_bios_ptable(bdev);
        if (!buf)
                return 0;
-       if(*(__le16 *)(buf + 0x40) == cpu_to_le16(0xaa55)) {
-               struct partition *first = (struct partition * )buf;
-               struct partition *entry = first;
+       if (*(__le16 *)(buf + 0x40) == cpu_to_le16(MSDOS_LABEL_MAGIC)) {
+               struct msdos_partition *first = (struct msdos_partition *)buf;
+               struct msdos_partition *entry = first;
                int saved_cylinders = param->cylinders;
                int num;
                unsigned char end_head, end_sec;
 
 #include <linux/hrtimer.h>
 #include <linux/uuid.h>
 #include <linux/t10-pi.h>
+#include <linux/msdos_partition.h>
 
 #include <net/checksum.h>
 
 static void __init sdebug_build_parts(unsigned char *ramp,
                                      unsigned long store_size)
 {
-       struct partition *pp;
+       struct msdos_partition *pp;
        int starts[SDEBUG_MAX_PARTS + 2];
        int sectors_per_part, num_sectors, k;
        int heads_by_sects, start_sec, end_sec;
 
        ramp[510] = 0x55;       /* magic partition markings */
        ramp[511] = 0xAA;
-       pp = (struct partition *)(ramp + 0x1be);
+       pp = (struct msdos_partition *)(ramp + 0x1be);
        for (k = 0; starts[k + 1]; ++k, ++pp) {
                start_sec = starts[k];
                end_sec = starts[k + 1] - 1;
 
 #include <linux/genhd.h>
 #include <linux/kernel.h>
 #include <linux/blkdev.h>
+#include <linux/msdos_partition.h>
 #include <asm/unaligned.h>
 
 #include <scsi/scsicam.h>
 {
        int cyl, ext_cyl, end_head, end_cyl, end_sector;
        unsigned int logical_end, physical_end, ext_physical_end;
-       struct partition *p, *largest = NULL;
+       struct msdos_partition *p, *largest = NULL;
        void *buf;
        int ret = false;
 
 
 #include <linux/fs.h>
 #include <linux/workqueue.h>
 
-struct partition {
-       unsigned char boot_ind;         /* 0x80 - active */
-       unsigned char head;             /* starting head */
-       unsigned char sector;           /* starting sector */
-       unsigned char cyl;              /* starting cylinder */
-       unsigned char sys_ind;          /* What partition type */
-       unsigned char end_head;         /* end head */
-       unsigned char end_sector;       /* end sector */
-       unsigned char end_cyl;          /* end cylinder */
-       __le32 start_sect;      /* starting sector counting from 0 */
-       __le32 nr_sects;                /* nr of sectors in partition */
-} __attribute__((packed));
-
 struct disk_stats {
        u64 nsecs[NR_STAT_GROUPS];
        unsigned long sectors[NR_STAT_GROUPS];
 
--- /dev/null
+/* SPDX-License-Identifier: GPL-2.0 */
+#ifndef _LINUX_MSDOS_PARTITION_H
+#define _LINUX_MSDOS_PARTITION_H
+
+#define MSDOS_LABEL_MAGIC              0xAA55
+
+struct msdos_partition {
+       u8 boot_ind;            /* 0x80 - active */
+       u8 head;                /* starting head */
+       u8 sector;              /* starting sector */
+       u8 cyl;                 /* starting cylinder */
+       u8 sys_ind;             /* What partition type */
+       u8 end_head;            /* end head */
+       u8 end_sector;          /* end sector */
+       u8 end_cyl;             /* end cylinder */
+       __le32 start_sect;      /* starting sector counting from 0 */
+       __le32 nr_sects;        /* nr of sectors in partition */
+} __packed;
+
+#endif /* LINUX_MSDOS_PARTITION_H */