/*-
 * Copyright (c) 1997, 1998
 *	Nan Yang Computer Services Limited.  All rights reserved.
 *
 *  This software is distributed under the so-called ``Berkeley
 *  License'':
 *
 * 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. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *	This product includes software developed by Nan Yang Computer
 *      Services Limited.
 * 4. Neither the name of the Company 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 ``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 company 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.
 */

/* Information needed to set up a transfer */

enum xferinfo {
	XFR_NORMAL_READ = 1,
	XFR_NORMAL_WRITE = 2,		/* write request in normal mode */
	XFR_RECOVERY_READ = 4,
	XFR_DEGRADED_WRITE = 8,
	XFR_PARITYLESS_WRITE = 0x10,
	XFR_NO_PARITY_STRIPE = 0x20,	/* parity stripe is not available */
	XFR_DATA_BLOCK = 0x40,		/* data block in request */
	XFR_PARITY_BLOCK = 0x80,	/* parity block in request */
	XFR_BAD_SUBDISK = 0x100,	/* this subdisk is dead */
	XFR_MALLOCED = 0x200,		/* this buffer is malloced */
#ifdef VINUMDEBUG
	XFR_PHASE2 = 0x800,		/* debug only: 2nd phase write */
#endif
	XFR_REVIVECONFLICT = 0x1000,	/* possible conflict with a revive */
	XFR_BUFLOCKED = 0x2000,		/* BUF_LOCK performed on this buffer */

	/*
	 * operations that need a parity block
	 */
	XFR_PARITYOP = (XFR_NORMAL_WRITE | XFR_RECOVERY_READ |
			XFR_DEGRADED_WRITE),

	/*
	 * operations that use the group parameters
	 */
	XFR_GROUPOP = (XFR_DEGRADED_WRITE | XFR_RECOVERY_READ),

	/*
	 * operations that that use the data parameters
	 */
	XFR_DATAOP = (XFR_NORMAL_READ | XFR_NORMAL_WRITE |
		      XFR_PARITYLESS_WRITE),

	/*
	 * operations requiring read before write
	 */
	XFR_RBW = (XFR_NORMAL_WRITE | XFR_DEGRADED_WRITE),

	/*
	 * operations that need a malloced buffer
	 */
	XFR_NEEDS_MALLOC = (XFR_NORMAL_WRITE | XFR_RECOVERY_READ |
			    XFR_DEGRADED_WRITE)
};

/*
 * Describe one low-level request, part of a
 * high-level request.  This is an extended
 * struct buf buffer, and the first element
 * *must* be a struct buf.  We pass this
 * structure to the I/O routines instead of a
 * struct buf in order to be able to locate the
 * high-level request when it completes.
 *
 * All offsets and lengths are in sectors.
 */
struct rqelement {
	struct buf b;			/* buf structure */
	struct rqgroup *rqg;		/* pointer to our group */

	vinum_off_t sdoffset;		/* offset in subdisk */
	int useroffset;			/* offset of data in user buffer */

	/*
	 * dataoffset and datalen refer to "individual" data
	 * transfers which involve only this drive (normal read,
	 * parityless write) and also degraded write.
	 *
	 * groupoffset and grouplen refer to the other "group"
	 * operations (normal write, recovery read) which involve
	 * more than one drive.  Both the offsets are relative to
	 * the start of the local buffer.
	 */
	int dataoffset;			/* offset of the normal data */
	int groupoffset;		/* offset of group data */
	short datalen;			/* length of normal data (sectors) */
	short grouplen;			/* length of group data (sectors) */
	short buflen;			/* total buffer length to allocate */
	short flags;			/* really enum xferinfo (see above) */

	/*
	 * Ways to find other components
	 */
	short sdno;			/* subdisk number */
	short driveno;			/* drive number */
};

/*
 * A group of requests built to satisfy an I/O
 * transfer on a single plex.
 */
struct rqgroup {
	struct rqgroup *next;		/* pointer to next group */
	struct request *rq;		/* pointer to the request */
	short count;			/* number of requests in this group */
	short active;			/* and number active */
	short plexno;			/* index of plex */
	int badsdno;			/* index of bad subdisk or -1 */
	enum xferinfo flags;		/* description of transfer */
	struct rangelock *lock;		/* lock for this transfer */
	vinum_off_t lockbase;		/* and lock address */
	struct rqelement rqe[0];	/* and the elements of this request */
};

/*
 * Describe one high-level request and the
 * work we have to do to satisfy it.
 */
struct request {
	struct bio *bio;		/* pointer to the high-level request */
	enum xferinfo flags;
	union {
	    int volno;			/* volume index */
	    int plexno;			/* or plex index */
	} volplex;
	int error;			/* current error indication */
	int sdno;			/* reviving subdisk	*/
					/* (XFR_REVIVECONFLICT) */
	short isplex;			/* set if this is a plex request */
	short active;			/* number of subrequests still active */
	struct rqgroup *rqg;		/* ptr to the first group of requests */
	struct rqgroup *lrqg;		/* and to the last group of requests */
	struct request *next;		/* link of waiting requests */
};

/*
 * Extended buffer header for subdisk I/O.  Includes
 * a pointer to the user I/O request.
 */
struct sdbuf {
	struct buf b;			/* our buffer */
	struct bio *bio;		/* and pointer to parent */
	short driveno;			/* drive index */
	short sdno;			/* and subdisk index */
};

/*
 * Values returned by rqe and friends.  Be careful
 * with these: they are in order of increasing
 * seriousness.  Some routines check for
 * > REQUEST_RECOVERED to indicate a failed request. XXX
 */
enum requeststatus {
	REQUEST_OK,		/* request built OK */
	REQUEST_RECOVERED,	/* request OK, but involves RAID5 recovery */
	REQUEST_DEGRADED,	/* parts of request failed */
	REQUEST_EOF,		/* parts of request failed: outside plex */
	REQUEST_DOWN,		/* all of request failed: subdisk(s) down */
	REQUEST_ENOMEM		/* all of request failed: ran out of memory */
};

#ifdef VINUMDEBUG

/*
 * Trace entry for request info (DEBUG_LASTREQS)
 */
enum rqinfo_type {
	loginfo_unused,		/* never been used */
	loginfo_user_bp,	/* this is the bp when strategy is called */
	loginfo_user_bpl,	/* and this is the bp at launch time */
	loginfo_rqe,		/* user RQE */
	loginfo_iodone,		/* iodone */
	loginfo_raid5_data,	/* write RAID-5 data block */
	loginfo_raid5_parity,	/* write RAID-5 parity block */
	loginfo_sdio,		/* subdisk I/O */
	loginfo_sdiol,		/* subdisk I/O launch */
	loginfo_sdiodone,	/* subdisk iodone */
	loginfo_lockwait,	/* wait for range lock */
	loginfo_lock,		/* lock range */
	loginfo_unlock,		/* unlock range */
};

/*
 * Info to pass to logrq
 */
union rqinfou {
	struct bio *bio;
	struct rqelement *rqe;		/* addr of request, for correlation */
	struct rangelock *lockinfo;
};

struct rqinfo {
	enum rqinfo_type type;		/* kind of event */
	struct timeval timestamp;	/* time it happened */
	struct bio *bio;		/* point to user buffer */
	int devmajor;			/* major and minor device info */
	int devminor;
	union {
		struct buf b;		/* yup, the *whole* buffer header */
		struct bio bio;
		struct rqelement rqe;	/* and the whole rqe */
		struct rangelock lockinfo;
	} info;
};

#define RQINFO_SIZE 128		/* number of info slots in buffer */

void logrq(enum rqinfo_type type, union rqinfou info, struct bio *ubio);

#endif

/* Structures for the daemon */

/*
 * Types of request to the daemon
 */
enum daemonrq {
	daemonrq_none,		/* dummy to catch bugs */
	daemonrq_ioerror,	/* error occurred on I/O */
	daemonrq_saveconfig,	/* save configuration */
	daemonrq_return,	/* return to userland */
	daemonrq_ping,		/* show sign of life */
	daemonrq_init,		/* initialize a plex */
	daemonrq_revive,	/* revive a subdisk */
	daemonrq_closedrive,	/* close a drive */
};

/*
 * Info field for daemon requests and the request information
 */
union daemoninfo {
	struct request *rq;	/* for daemonrq_ioerror */
	struct sd *sd;		/* for daemonrq_revive */
	struct plex *plex;	/* for daemonrq_init */
	struct drive *drive;	/* for daemonrq_closedrive */
	int nothing;		/* for passing NULL */
};

struct daemonq {
	struct daemonq *next;	/* pointer to next element in queue */
	enum daemonrq type;	/* type of request */
	int privateinuse;	/* private element, being used */
	union daemoninfo info;	/* and the request information */
};

void queue_daemon_request(enum daemonrq type, union daemoninfo info);

extern int daemon_options;

enum daemon_option {
	daemon_verbose = 1,	/* talk about what we're doing */
	daemon_stopped = 2,
	daemon_noupdate = 4,	/* don't update the disk config, for recovery */
};

void freerq(struct request *rq);
void unlockrange(int plexno, struct rangelock *);