tools/diskomizer/diskomizer64mpism.h

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#pragma ident	"@(#)diskomizer64mpism.h	1.44	09/05/26 SMI"

/*
 *	diskomizer64mpism
 *
 *	Write to and then read from disk partitions and or files.
 *
 *	Chris.Gerhard (at) uk.sun.com - SMCC CTE
 */

#ifndef _DISKOMIZER64MPISM_H
#define	_DISKOMIZER64MPISM_H

#ifdef	__cplusplus
extern "C" {
#endif


#ifndef	_REENTRANT
#define	_REENTRANT
#endif
#include <note.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
#include <sys/time.h>
#include <sys/errno.h>
#include <pthread.h>
#include <sys/shm.h>
#include <limits.h>
#include <signal.h>
#include <sys/wait.h>
#include <alloca.h>
#include <sys/mman.h>
#include <errno.h>
#include <strings.h>
#include <diskomizer/assert.h>
#include <sys/termios.h>
#include <diskomizer/daio.h>
#include <diskomizer/tnf.h>
#include <diskomizer/recent.h>

#define	MAX(A, B) (((A) > (B)) ? (A) : (B))
#define	MIN(A, B) (((A) < (B)) ? (A) : (B))
#define	MILLION 1000000
#define	THOUSAND 1000
#define	BILLION (MILLION * THOUSAND)
#define	ACCURACY BILLION
#ifdef __sparc
#define	SPARC
#endif
#define	TIME_FORMAT "%T %d/%b/%Y"

#define	MAP_BITS WORD_BIT
typedef uint32_t bitmap_t;
/* typedef unsigned long long  ullong_t; Now in <diskomizer/recent.h> */
typedef uint16_t ushort16_t;
typedef uchar_t iolen_index_t;
#define	MAX_IO_LENS UCHAR_MAX
#define	INDEX_TO_DIOLEN(A) (opts.disk_io_sizes.vals[A])
#define	ARRAY_LEN(A) (sizeof (A)/sizeof ((A)[0]))

/* These are currently per process */
struct times {
	long long best;
	long long worst;
	long long ave;
	long long count;
	long long last_few[100];
	char *str;
};
struct aioqtop {
	struct aio_str  *head;
	struct aio_str  *tail;
};
/*
 * Device control is shared between processes. So it has it's own lock to
 * protect it's contents.
 */
typedef enum {
	DEV_NOT_READY, /* when device is not yet ready to start */
	DEV_RUNNING, /* when the processes_stopped count is 0 */
	DEV_STOPPING, /* This is a request to tell all the procs to stop */
	DEV_STOPPED, /* when the processes_stopped count is nprocs */
	DEV_STARTING /* this one tells the procs to start again */
} dev_state;
struct device_control {
	pthread_mutex_t lock; /* Must be initialized as a inter process lock */
	struct	timeval state_ttl;
	dev_state state;
	long processes_stopped; /* The number of processes which have stopped */
};

struct device_id {
	ino_t    ino;	/* Inode number */
	/*
	 * The device id if a char special or block special, padded to
	 * 64 bits to prevent the 32bit build being padded in an
	 * unctorolled way
	 */
	uint64_t    dev;
};
/*
 * the fds structure, used for doing alternate paths. This forms
 * a ring attached to the device structure
 *
 * The timing stats are also collected per fd (path).
 */
struct fds {
	int fd;
	char *name;
	char *longname;
	char *shortname;
	struct device_id devid;
	struct aioqtop all_aios; /* sorted list of all aios outstanding */
	struct aio_str  *oldest_io;
	long   number_of_hung_read;
	long   total_read;
	long   number_of_hung_write;
	long   total_write;
	time_t last_report; /* time when the last hang was reported */
	hrtime_t last_write_time;
	hrtime_t last_read_time;
	struct times read_times;
	struct times write_times;
	/*
	 * Need_to_stop: Set non zero when the path has failed but the fact
	 * has not yet been comunicated to the other processes.
	 */
	unsigned need_to_stop : 1;
	/*
	 * Stop flag: set non zero when the path has failed and the fact has
	 * been comunicated, or we got the failure message from another
	 * process.
	 */
	unsigned stop_flag : 1; /* set to 1 when the path is "failed" */
	unsigned error_path : 1; /* used as a fail over path */
	unsigned created : 1;
	unsigned path_id : 8;
	void *shared_data_handle;
	struct fds *next;
};
/* #include "frags.h" */
/*
 * there is one of these per diskomizer block that is in use on each device
 * bing accessed. So it is well worth the effort to make these as small as
 * possible.
 */
struct blks {
	time_t last_requested;
	union {
		time_t prev_requested;
		/*
		 * This is only set if the block could not be written during
		 * the sequential run, it is checked during an assert.
		 * Since once the block is written this is no longer checked
		 * it can share space with prev_requested.
		 */
		int  was_unwritten;
	} u;
#define	SET_LAST_RETURN(A, B) A = (B);
#define	GET_LAST_RETURN(A) A
#if LONG_BIT == 32
#define	BIT2CHARSTAR(A) ((uchar_t *)((A) == 0 ? 0L : 1L))
	/*
	 * 24 bits give a maximum value for the delta of 194.18 days.
	 * If the io is taking that long then the device is not working
	 * so I'm happy to only to use 24 bits.  This saves 8 bits of
	 * space per diskomiser block on each device. In a 64 bit world
	 * this is a waste of time due to padding, so just use ints, and
	 * if there is 64bit address space we won't be short of space!
	 */
	unsigned last_returned_delta : 24;
	unsigned read_count : 8;
#else
#define	BIT2CHARSTAR(A) ((uchar_t *)((A) == 0 ? 0LL : 1LL))
	uint_t last_returned_delta;
	uint_t read_count;
#endif
	unsigned hdrchksum : 16; /* the checksum from the header */
	unsigned path_id : 8; /* hold the id of the fd down which this went */
	unsigned bad_hdr : 1; /* 1 if the header written was bad */
	unsigned ab : 1; /* 1 for type A, 0 for type B */
	unsigned bad_chksum : 1; /* 0 if the checksum written was bad */
#define	SEQUENCE_BITS 5
	unsigned sequence : SEQUENCE_BITS; /* Sequence number */
	/*
	 * Union holding either the read only or the read write information.
	 */
	union {
		/*
		 * 	Length's offsets of the last and previous ios.
		 *	we could do a nice structure that contains all
		 *	the previous ios but it would end up being padded
		 *	and I'm short of space.
		 */
		struct {
			iolen_index_t last_iolen;
			iolen_index_t last_off;
			iolen_index_t prev_iolen;
			iolen_index_t prev_off;
			/*
			 * Put a pointer as the last element to force the
			 * compiler to generate the correct allignment.
			 * If the stucture is not the "correct"
			 * size then the compiler will pad it.
			 *
			 */
			uchar_t *last_io;
			uchar_t *prev_io;
		} w;
		/*
		 * In the read-only world, only fixed size io is supported.
		 * If this structure grows to be bigger than the one above,
		 * then it needs to handle alignment issues.
		 */
		struct {
			check_t last_chksum;
			check_t prev_chksum;
			uint_t last_io:1;
			uint_t prev_io:1;
		} o;
	} r;
};

#define	DEV_BLOCK_HANDLE(A, B) ((A)->blocks->handles[(B) / (A)->blocks->len])
#define	DEV_BLOCK_INDEX(A, B) ((B) % (A)->blocks->len)

#define	AIO_BLOCK_HANDLE(A) DEV_BLOCK_HANDLE((A)->dev, (A)->off)
#define	AIO_BLOCK_INDEX(A) DEV_BLOCK_INDEX((A)->dev, (A)->off)

/*
 * diff return is returned by the diff printing routines giving a count
 * of the number of bits changed and also which bits were seen in error.
 */
struct diff_return {
	int64_t count;
	off64_t bits;
};


struct shm_handle {
	long len;
	int count;
	void *handles[1];
};

struct offset_list {
	ullong_t  offset;
	struct offset_list *next;
};

typedef void (*choose_block_t)(bitmap_t *map,
		struct aio_str *aiop, ullong_t start, ullong_t len, int maplen);
/*
 * The device structure.  There is one of these per device (file) that is
 * being diskomized.	They are linked together in a single list with
 * head being the global "devices".
 *
 */
struct device {
	struct fds *fdhead; /* list of device paths. They must all be to */
			    /* the same physical device */
	char *logicalname;
	void *writemap_handle; /* bit map protecting the blocks on disk */
	void *shared_data_handle; /* any data shared between all processes */
	struct disko_partition *v_part; /* the vtoc partition info */
	ulong_t writemap_size; /* size of the write map */
	ulong_t running_rthreads; /* the number of read threads running */
	ullong_t block; /* the last offset that has been written to */
	ullong_t read_start_block; /* the block on which to start reads */
	ullong_t length; /* the length in bytes of the area we are writing to */
	ullong_t next_write_blk; /* The next block to do a write I/O to */
	ullong_t next_read_blk; /* The next block to do a read I/O to */
	/*
	 * count of errors that have not yet been added to the shared
	 * errors
	 */
	int errors:29;
	int stop_flag:1;
	int need_to_stop:1;
	int failed_to_push_unwritten:1;
	uint_t device_block_size; /* the block size of the underlying device */
	long seq_passes; /* the number of sequential passes to do */
	/*
	 * A list of blocks that have not  yet been written as they were locked
	 */
	struct offset_list *unwritten;
	long long countdown; /* number of reads to complete before we stop */
	struct shm_handle *blocks; /* information about blocks */
	choose_block_t choose_block;
	/*
	 * The time to live of this state.
	 *
	 * If the device is stopped then this time indicates when the
	 * device should be restarted.  The first process to get run after
	 * this time will change the state from DEV_STOPPED to DEV_STARTING
	 * and decrement the stopped process count. All the other processes
	 * just decrement the stopped process count until it is zero, then
	 * the state is set to DEV_RUNNING.
	 *
	 * If the device is running then the first process to reach this
	 * time sets ti to DEV_STOPPING and increments the stopped process
	 * count. When the stopped process count is equal to nprocs the
	 * device state  is set to stopped and no io will be taking place.
	 */
	struct	timeval state_ttl;
	dev_state state;
	struct aioqtop stopped_ios;
	/*
	 * If a path fails outstanding ios are cancelled and submitted
	 * down an alternative path, if available.
	 */
	struct aioqtop cancelled;
	/*
	 * deferred ios are ios that could not get queued for
	 * some reason.
	 */
	struct aioqtop deferred_ios;
	struct device_control *control; /* The shared control info */
	struct recent_blocks *recent;
	struct device *next; /* the next device */
};

/*
 * err_type and err_info are used by report_error.  All errors should be
 * reported via report_error, that way you always get all the info.
 */
typedef enum {
	ERR_SYS,
	ERR_CORRUPT,
	ERR_HUNG,
	ERR_DEFERRED
} err_type;

struct error_desc {
	uint_t HEADER_CHECKSUM_ERR:1;
	/* The lenght in the header does not match the length we expect */
	uint_t LENGTH_MISMATCH:1;
	uint_t BODY_CHECKSUM_ERR:1;
	/* Matches the device given in error.dev */
	uint_t MATCHING_DEVICE:1;
	/* Matches the last write to the offset given in error.off */
	uint_t MATCHING_LAST:1;
	/* Matches the previous write to the offset given in error.off */
	uint_t MATCHING_PREV:1;
	uint_t UNABLE_TO_LOCK:1;
};

struct error {
	struct error_desc desc;
	/* this errors instance number */
	int instance;
	/* If this is a follow on error the previous instance number */
	int previous;
	/* if this is a follow on error the parent's instance number */
	int parent;
	check_t bad_checksum;
	struct fds *fd;
	struct device *dev;
	char *diff_file;
	/* diskomizer offset */
	off64_t doff;
	time_t last_requested;
	struct diff_return dr;
	long delta;
	uint32_t len;
	unsigned path_id : 8;
};

#include "bufs.h"
/*
 * NB. The aio_result structure MUST be the first element in this structure
 */
typedef struct aio_str {
	daio_result_t	aio_res; /* aio_result passed to aioread/write */
	struct	timeval tv;	/* time when the aio request was submitted */
	struct	device *dev;	/* The device the aio is to/from */
	struct  fds	*fd;	/* the file descriptor for this i/o */
	uchar_t		*buf;	/* The buffer being used for this I/O */
	ullong_t	off;		/* The offset being used for this I/O */
	uint16_t	retrycnt; /* number of times we have retried this I/O */
	iolen_index_t	iolen;	/* The index into the iolen array */
	int	count;		/* The number times we have done I/O */
	time_t	(*handler)(struct aio_str *aio_resp, ullong_t start);
	struct bufhdr hdr;
	struct daio_id daio_id;	/* the id of the buffer */
	struct error error; /* error reporting info */
	struct aio_str	*next;	/* linked list for cancellation and stats */
	struct aio_str	*prev;	/* linked list for removing entries */
} aio_str_t;
TNF_DECLARE_RECORD(aio_str_t, aio_tnf_str);
typedef enum {
	CONTINUE, /* continue with error processing. */
	RETRY,	  /* Do the aioread again */
	BREAK	  /* All is well, break from error processing */
} loop_type;

union err_info {
	time_t time;
	char *str;
};

typedef loop_type
	(*on_error_t)(ullong_t start, struct aio_str *aio_resp);

extern void nop(void);
extern iolen_index_t max_disk_io_len;
extern struct device *devices; /* all the devices there are */
extern pid_t pgrp;
extern int  nfunc_bufs;
extern uchar_t (*init_uchar_func)(int bufno, int i);
extern void (*shm_chmod)(void *addr, ulong_t len, int mode);
/*
 * All the external functions in diskomizer64mpism.c
 */
#ifdef __sparc
extern void flush(int32_t *x);
extern void flush_windows(void);
#endif
extern time_t handle_write(struct aio_str *aio_resp, ullong_t start);
extern time_t handle_write_then_read(struct aio_str *aio_resp, ullong_t start);
extern time_t handle_read_then_write(struct aio_str *aio_resp, ullong_t start);
extern time_t handle_readonly_seq(struct aio_str *aio_resp, ullong_t start);
extern int how_many_devices(struct device *devices);
extern void print_number(unsigned long long  i, char *singular,
	char *plural);
extern void * alloc_mem(long a, long b);
extern ullong_t find_next_free(bitmap_t map[], ullong_t offset,
	int len, int maplen);
extern void clear_write(bitmap_t map[], ullong_t off, ulong_t maplen);
extern ulong_t my_lrand(void);
extern int longest_logical_name(void);
extern int longest_device_name(void);
extern void *my_calloc(long a, long b);
extern char *alloc_time_now_fmt(char *fmt);
extern int this_proc(void);
extern int is_readonly(void);
extern int would_stop_before(time_t secs);
extern pid_t master_pid(void);
extern void check_exit_flag(void);
extern struct fds *find_path(struct fds *fdhead, char path_id);
extern ullong_t diskomizer_off2byteoff(ullong_t off);
extern char *diff_file(void);
/*
 * macros.
 */
#define	ZERO_OBJ(X) (void) memset(&X, NULL, sizeof (X))
#define	GET_OFF(X) (X / MAP_BITS)
#define	GET_BIT(X) (1 << (X % MAP_BITS))

#ifdef	__cplusplus
}
#endif

#endif /* _DISKOMIZER64MPISM_H */