/*
 * Copyright (c) 2007 The DragonFly Project.  All rights reserved.
 *
 * This code is derived from software contributed to The DragonFly Project
 * by Matthew Dillon <dillon@backplane.com>
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 * 3. Neither the name of The DragonFly Project nor the names of its
 *    contributors may be used to endorse or promote products derived
 *    from this software without specific, prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
 * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */
/*-
 * Copyright (c) 1994 Bruce D. Evans.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * $FreeBSD: src/sys/sys/diskslice.h,v 1.36.2.1 2001/01/29 01:50:50 ken Exp $
 */

#ifndef	_SYS_DISKSLICE_H_
#define	_SYS_DISKSLICE_H_

#ifndef _SYS_TYPES_H_
#include <sys/types.h>
#endif
#ifndef _SYS_DISKLABEL_H_
#include <sys/disklabel.h>
#endif
#ifndef _SYS_UUID_H_
#include <sys/uuid.h>
#endif
#ifndef _SYS_IOCCOM_H_
#include <sys/ioccom.h>
#endif
#if defined(_KERNEL)
#ifndef _SYS_CONF_H_
#include <sys/conf.h>           /* for make_sub_dev() */
#endif
#ifndef _SYS_SYSTM_H_
#include <sys/systm.h>		/* for minor() */
#endif
#endif

#define	COMPATIBILITY_SLICE	0	/* e.g. ad0s0 */
					/* 1 is WHOLE_DISK_SLICE; see below */
#define	BASE_SLICE		2	/* e.g. ad0s1 */

				/* 101 - compat disklabel DIOCGDINFO	*/
				/* 102 - compat disklabel DIOCSDINFO	*/
				/* 103 - compat disklabel DIOCWDINFO	*/
				/* 104 - DIOCGPART (see below)		*/
				/* 105 - compat disklabel DIOCGDVIRGIN	*/
#define DIOCWLABEL		_IOW('d', 109, int)
				/* 111 - DIOCGSLICEINFO */
				/* 112 - DIOCSYNCSLICEINFO */
#define DIOCGKERNELDUMP		_IOW('d', 133, u_int)   /* Set/Clear dumps */
#define DIOCRECLUSTER		_IOWR('d', 134, struct disk_ioc_recluster)
#define	DIOCGMEDIASIZE		_IOR('d', 135, off_t)
#define	DIOCGSECTORSIZE		_IOR('d', 136, u_int)

/*
 * Support limits
 */
#define DKMAXUNITS	512	/* maximum supported disk units */
#define DKMAXSLICES	128	/* maximum supported slices (0 & 1 special) */
#define DKRESPARTITIONS	128	/* 128+ have special meanings */
#define DKMAXPARTITIONS	256	/* maximum supported in-kernel partitions */

/*
 * The whole-disk-slice does not try to interpret the MBR.  The whole slice
 * partition does not try to interpret the disklabel within the slice.
 */
#define	WHOLE_DISK_SLICE	1
#define WHOLE_SLICE_PART	(DKMAXPARTITIONS - 1)

/*
 * The max number of slices to probe for MBR disks.
 * GPT disks use more slices; see dsmakeslicestruct().
 */
#define	MAX_SLICES		16

#ifdef MAXPARTITIONS			/* XXX don't depend on disklabel.h */
#if MAXPARTITIONS !=	16		/* but check consistency if possible */
#error "inconsistent MAXPARTITIONS"
#endif
#else
#define	MAXPARTITIONS	16
#endif

/*
 * diskslice structure - slices up the disk and indicates where the
 * BSD labels are, if any.
 *
 * ds_reserved	     -  indicates read-only sectors due to an overlap with
 *			a parent partition or an in-band label.  BSD labels
 *			are in-band labels.  This field is also set if
 *			label snooping has been requested, even if there is
 *			no label present.
 */
struct diskslice {
#if defined(_KERNEL) || defined(_KERNEL_STRUCTURES)
	cdev_t		ds_dev;
#else
	void		*ds_dev;
#endif
	u_int64_t	ds_offset;	/* starting sector */
	u_int64_t	ds_size;	/* number of sectors */
	u_int32_t	ds_reserved;	/* sectors reserved parent overlap */
	struct uuid	ds_type_uuid;	/* slice type uuid */
	struct uuid	ds_stor_uuid;	/* slice storage unique uuid */
	int		ds_type;	/* (foreign) slice type */
	int		ds_flags;	/* DSF_ flags */
	disklabel_t 	ds_label;	/* label, if any */
	struct disklabel_ops *ds_ops;	/* label ops (probe default) */
	//void		*ds_dev;	/* devfs token for raw whole slice */
	void		*ds_devs[MAXPARTITIONS]; /* XXX s.b. in label */
	u_int32_t	ds_openmask[DKMAXPARTITIONS/(sizeof(u_int32_t)*8)];
					/* devs open */
	u_char		ds_wlabel;	/* nonzero if label is writable */
	int		ds_ttlopens;	/* total opens, incl slice & raw */
};

#define DSF_REPROBE	0x0001		/* sniffer wants us to reprobe */

struct diskslices {
	struct cdevsw *dss_cdevsw;	/* for containing device */
	int	dss_first_bsd_slice;	/* COMPATIBILITY_SLICE is mapped here */
	u_int	dss_nslices;		/* actual dimension of dss_slices[] */
	u_int	dss_oflags;		/* copy of flags for "first" open */
	int	dss_secmult;		/* block to sector multiplier */
	int	dss_secshift;		/* block to sector shift (or -1) */
	int	dss_secsize;		/* sector size */
	struct diskslice
		dss_slices[MAX_SLICES];	/* usually less; can allocate more */
};

struct disk_ioc_recluster {
	int	fd;
};

/*
 * DIOCGPART ioctl - returns information about a disk, slice, or partition.
 * This ioctl is primarily used to get the block size and media size.
 *
 * NOTE: media_offset currently represents the byte offset on the raw device,
 * it is not a partition relative offset.  disklabel(32) uses this field
 * to figure out the slice offset so it fixup raw labels.
 *
 * NOTE: reserved_blocks indicates how many blocks at the beginning of the
 * partition are read-only due to in-band sharing with the parent.  For
 * example, if partition 'a' starts at block 0, it actually overlaps the
 * disklabel itself so numerous sectors at the beginning of 'a' will be
 * reserved.
 */
struct partinfo {
	u_int64_t	media_offset;	/* byte offset in parent layer */
	u_int64_t	media_size;	/* media size in bytes */
	u_int64_t	media_blocks;	/* media size in blocks */
	int		media_blksize;	/* block size in bytes (sector size) */

	u_int64_t	reserved_blocks;/* read-only, in sectors */
	int		fstype;		/* legacy filesystem type or FS_OTHER */
	char		fsreserved[16];	/* reserved for future use */

	/*
	 * These fields are loaded from the diskinfo structure
	 */
	u_int		d_nheads;
	u_int		d_ncylinders;
	u_int		d_secpertrack;
	u_int		d_secpercyl;
	u_int		d_reserved[8];	/* reserved for future use */

	/*
	 * UUIDs can be extracted from GPT slices and disklabel64
	 * partitions.  If not known, they will be set to a nil uuid.
	 *
	 * fstype_uuid represents the slice or partition type, e.g.
	 * like GPT_ENT_TYPE_DRAGONFLY_LABEL64.  If not nil,
	 * storage_uuid uniquely identifies the physical storage.
	 */
	struct uuid	fstype_uuid;
	struct uuid	storage_uuid;
};

#define DIOCGPART	_IOR('d', 104, struct partinfo)	/* get partition */

/*
 * disk unit and slice helper functions
 *
 *     3                   2                   1                   0
 *   1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0
 *  _________________________________________________________________
 *  | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | |
 *  -----------------------------------------------------------------
 *  | SL2 | PART3 |UNIT_2 |P| SLICE |  MAJOR?       |  UNIT   |PART |
 *  -----------------------------------------------------------------
 */

#if defined(_KERNEL) || defined(_KERNEL_STRUCTURES)

/*
 * Build a minor device number.
 */
static __inline u_int32_t
dkmakeminor(u_int32_t unit, u_int32_t slice, u_int32_t part)
{
	u_int32_t val;

	val = ((unit & 0x001f) << 3) | ((unit & 0x01e0) << 16) |
	      ((slice & 0x000f) << 16) | ((slice & 0x0070) << 25) |
	      (part & 0x0007) | ((part & 0x0008) << 17) |
	      ((part & 0x00F0) << 21);
	return(val);
}

/*
 * Generate the minor number representing the entire disk, with no
 * mbr or label interpretation.
 */
static __inline u_int32_t
dkmakewholedisk(u_int32_t unit)
{
	return(dkmakeminor(unit, WHOLE_DISK_SLICE, WHOLE_SLICE_PART));
}

/*
 * Generate the minor number representing an entire slice, with no
 * recursive mbr, boot sector, or label interpretation.
 */
static __inline u_int32_t
dkmakewholeslice(u_int32_t unit, u_int32_t slice)
{
	return(dkmakeminor(unit, slice, WHOLE_SLICE_PART));
}

/*
 * Return the unit mask, used in calls to make_dev()
 */
static __inline u_int32_t
dkunitmask(void)
{
	return (0x01e000f8);
}

/*
 * build minor number elements - encode unit number, slice, and partition
 * (OR the results together).
 */
static __inline u_int32_t
dkmakeunit(int unit)
{
        return(dkmakeminor((u_int32_t)unit, 0, 0));
}

static __inline u_int32_t
dkmakeslice(int slice)
{
        return(dkmakeminor(0, (u_int32_t)slice, 0));
}

static __inline u_int32_t
dkmakepart(int part)
{
        return(dkmakeminor(0, 0, (u_int32_t)part));
}

#endif

/*
 * dk*() support functions operating on cdev_t's
 */
#ifdef _KERNEL

static __inline int
dkunit(cdev_t dev)
{
	u_int32_t val = minor(dev);

	val = ((val >> 3) & 0x001f) | ((val >> 16) & 0x01e0);
	return((int)val);
}

static __inline u_int32_t
dkslice(cdev_t dev)
{
	u_int32_t val = minor(dev);

	val = ((val >> 16) & 0x000f) | ((val >> 25) & 0x0070);
	return(val);
}

static __inline u_int32_t
dkpart(cdev_t dev)
{
	u_int32_t val = minor(dev);

	val = (val & 0x0007) | ((val >> 17) & 0x0008) | ((val >> 21) & 0x00f0);
	return(val);
}

#endif

/*
 * Bitmask ops, keeping track of which partitions are open.
 */
static __inline
void
dsclrmask(struct diskslice *ds, int part)
{
	part &= (DKMAXPARTITIONS - 1);
	ds->ds_openmask[part >> 5] &= ~(1 << (part & 31));
}

static __inline
void
dssetmask(struct diskslice *ds, int part)
{
	part &= (DKMAXPARTITIONS - 1);
	ds->ds_openmask[part >> 5] |= (1 << (part & 31));
}

static __inline
int
dschkmask(struct diskslice *ds, int part)
{
	part &= (DKMAXPARTITIONS - 1);
	return (ds->ds_openmask[part >> 5] & (1 << (part & 31)));
}

static __inline
int
dscountmask(struct diskslice *ds)
{
	int count = 0;
	int i;
	int j;

	for (i = 0; i < DKMAXPARTITIONS / 32; ++i) {
		if (ds->ds_openmask[i]) {
			for (j = 0; j < 32; ++j) {
				if (ds->ds_openmask[i] & (1 << j))
					++count;
			}
		}
	}
	return(count);
}

static __inline
void
dssetmaskfrommask(struct diskslice *ds, u_int32_t *tmask)
{
	int i;

	for (i = 0; i < DKMAXPARTITIONS / 32; ++i)
		tmask[i] |= ds->ds_openmask[i];
}

/*
 * disk management functions
 */

#ifdef _KERNEL

struct buf;
struct bio;
struct disk_info;
struct bio_queue_head;

int	mbrinit (cdev_t dev, struct disk_info *info,
		    struct diskslices **sspp);
int	gptinit (cdev_t dev, struct disk_info *info,
		    struct diskslices **sspp);
struct bio *
	dscheck (cdev_t dev, struct bio *bio, struct diskslices *ssp);
void	dsclose (cdev_t dev, int mode, struct diskslices *ssp);
void	dsgone (struct diskslices **sspp);
int	dsioctl (cdev_t dev, u_long cmd, caddr_t data, int flags,
		    struct diskslices **sspp, struct disk_info *info);
int	dsisopen (struct diskslices *ssp);
struct diskslices *
	dsmakeslicestruct (int nslices, struct disk_info *info);
char	*dsname (cdev_t dev, int unit, int slice, int part,
		    char *partname);
int	dsopen (cdev_t dev, int mode, u_int flags,
		    struct diskslices **sspp, struct disk_info *info);
int64_t	dssize (cdev_t dev, struct diskslices **sspp);

/*
 * Ancillary functions
 */

void	diskerr (struct bio *bio, cdev_t dev, const char *what, int pri,
		    int donecnt);
void	bioqdisksort (struct bio_queue_head *ap, struct bio *bio);

#endif /* _KERNEL */

#endif /* !_SYS_DISKSLICE_H_ */
