/*- * 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. * * $Id: vinumext.h,v 1.2 2003/10/15 01:31:39 grog Exp $ */ /* vinumext.h: external definitions */ /* *sigh* We still need this at the moment. */ #ifdef _KERNEL extern struct _vinum_conf vinum_conf; /* configuration information */ #else extern struct __vinum_conf vinum_conf; /* configuration information */ #endif #ifdef VINUMDEBUG extern int debug; /* debug flags */ #endif /* Physical read and write drive */ #define read_drive(a, b, c, d) driveio (a, b, c, d, B_READ) #define write_drive(a, b, c, d) driveio (a, b, c, d, B_WRITE) #define CHECKALLOC(ptr, msg) \ if (ptr == NULL) \ { \ printf (msg); \ longjmp (&command_fail); \ } #ifndef _KERNEL struct vnode; struct proc; #endif #ifdef _KERNEL int vinum_inactive(int); void free_vinum(int); int give_sd_to_plex(int plexno, int sdno); void give_sd_to_drive(int sdno); int give_plex_to_volume(int volno, int plexno); struct drive *check_drive(char *); enum drive_label_info read_drive_label(struct drive *, int); int parse_config(char *, struct keywordset *, int); int parse_user_config(char *cptr, struct keywordset *keyset); u_int64_t sizespec(char *spec); int volume_index(struct volume *volume); int plex_index(struct plex *plex); int sd_index(struct sd *sd); int drive_index(struct drive *drive); int my_plex(int volno, int plexno); int my_sd(int plexno, int sdno); int get_empty_drive(void); int find_drive(const char *name, int create); int find_drive_by_name(const char *devname, int create); int get_empty_sd(void); int find_subdisk(const char *name, int create); void return_drive_space(int driveno, int64_t offset, int length); void free_sd(int sdno); void free_volume(int volno); int get_empty_plex(void); int find_plex(const char *name, int create); void free_plex(int plexno); int get_empty_volume(void); int find_volume(const char *name, int create); void config_subdisk(int); void config_plex(int); void config_volume(int); void config_drive(int); void updateconfig(int); void update_sd_config(int sdno, int kernelstate); void update_plex_config(int plexno, int kernelstate); void update_volume_config(int volno, int kernelstate); void update_config(void); void drive_io_done(struct buf *); void save_config(void); void daemon_save_config(void); void write_config(char *, int); int start_config(int); void finish_config(int); void remove(struct vinum_ioctl_msg *msg); void remove_drive_entry(int driveno, int force); void remove_sd_entry(int sdno, int force, int recurse); void remove_plex_entry(int plexno, int force, int recurse); void remove_volume_entry(int volno, int force, int recurse); void checkdiskconfig(char *); int open_drive(struct drive *, struct proc *, int); void close_drive(struct drive *drive); void close_locked_drive(struct drive *drive); int driveio(struct drive *, char *, size_t, off_t, int); int set_drive_parms(struct drive *drive); int init_drive(struct drive *, int); /* void throw_rude_remark (int, struct _ioctl_reply *, char *, ...); XXX */ void throw_rude_remark(int, char *,...); void format_config(char *config, int len); void checkkernel(char *op); void free_drive(struct drive *drive); void down_drive(struct drive *drive); void remove_drive(int driveno); int vinum_scandisk(char *drivename[], int drives); /* I/O */ dev_type_open (vinumopen); dev_type_close (vinumclose); dev_type_strategy (vinumstrategy); dev_type_ioctl (vinumioctl); dev_type_size(vinumsize); dev_type_dump(vinumdump); dev_type_read (vinumread); dev_type_write (vinumwrite); int vinum_super_ioctl(dev_t, u_long, caddr_t); int vinumstart(struct buf *bp, int reviveok); int launch_requests(struct request *rq, int reviveok); void sdio(struct buf *bp); /* XXX Do we need this? */ int vinumpart(dev_t); extern label_t command_fail; /* return here if config fails */ #ifdef VINUMDEBUG /* Memory allocation and request tracing */ void vinum_meminfo(caddr_t data); int vinum_mallocinfo(caddr_t data); int vinum_rqinfo(caddr_t data); void LongJmp(label_t *); #else void longjmp(label_t *); /* the kernel doesn't define this */ #endif char *basename(char *); typedef int cmp_t __P((const void *, const void *)); void qsort(void *a, size_t n, size_t es, cmp_t * cmp); void expand_table(void **, int, int); struct request; struct rqgroup *allocrqg(struct request *rq, int elements); void deallocrqg(struct rqgroup *rqg); /* Device number decoding */ int Volno(dev_t x); int Plexno(dev_t x); int Sdno(dev_t x); /* State transitions */ int set_drive_state(int driveno, enum drivestate state, enum setstateflags flags); int set_sd_state(int sdno, enum sdstate state, enum setstateflags flags); enum requeststatus checksdstate(struct sd *sd, struct request *rq, daddr_t diskaddr, daddr_t diskend); int set_plex_state(int plexno, enum plexstate state, enum setstateflags flags); int set_volume_state(int volumeno, enum volumestate state, enum setstateflags flags); void update_sd_state(int sdno); void forceup(int plexno); void update_plex_state(int plexno); void update_volume_state(int volno); void invalidate_subdisks(struct plex *, enum sdstate); void get_volume_label(char *name, int plexes, u_int64_t size, struct disklabel *lp); int write_volume_label(int); void start_object(struct vinum_ioctl_msg *); void stop_object(struct vinum_ioctl_msg *); void setstate(struct vinum_ioctl_msg *msg); void setstate_by_force(struct vinum_ioctl_msg *msg); void vinum_label(int); int vinum_writedisklabel(struct volume *, struct disklabel *); int initsd(int, int); struct buf *parityrebuild(struct plex *, u_int64_t, int, enum parityop, struct rangelock **, off_t *); enum requeststatus sddownstate(struct request *rq); int restart_plex(int plexno); int revive_read(struct sd *sd); int revive_block(int sdno); void parityops(struct vinum_ioctl_msg *); /* Auxiliary functions */ enum sdstates sdstatemap(struct plex *plex); enum volplexstate vpstate(struct plex *plex); #endif struct drive *validdrive(int driveno, struct _ioctl_reply *); struct sd *validsd(int sdno, struct _ioctl_reply *); struct plex *validplex(int plexno, struct _ioctl_reply *); struct volume *validvol(int volno, struct _ioctl_reply *); void resetstats(struct vinum_ioctl_msg *msg); /* Locking */ #ifdef VINUMDEBUG int lockdrive(struct drive *drive, char *, int); #else int lockdrive(struct drive *drive); #endif void unlockdrive(struct drive *drive); int lockvol(struct volume *vol); void unlockvol(struct volume *vol); int lockplex(struct plex *plex); void unlockplex(struct plex *plex); struct rangelock *lockrange(daddr_t stripe, struct buf *bp, struct plex *plex); int lock_config(void); void unlock_config(void); /* Dæmon */ void vinum_daemon(void); int vinum_finddaemon(void); int vinum_setdaemonopts(int); extern struct daemonq *daemonq; /* daemon's work queue */ extern struct daemonq *dqend; /* and the end of the queue */ #undef Free /* defined in some funny net stuff */ #ifdef _KERNEL #ifdef VINUMDEBUG #define Malloc(x) MMalloc ((x), __FILE__, __LINE__) /* show where we came from */ #define Free(x) FFree ((x), __FILE__, __LINE__) /* show where we came from */ caddr_t MMalloc(int size, char *, int); void FFree(void *mem, char *, int); #define LOCKDRIVE(d) lockdrive (d, __FILE__, __LINE__) #else /* kernel, no debug */ #define Malloc(x) malloc ((x), M_DEVBUF, M_NOWAIT) #define Free(x) free((x), M_DEVBUF) #define LOCKDRIVE(d) lockdrive (d) #endif #else /* not kernel */ #define Malloc(x) malloc ((x)) /* just the size */ #define Free(x) free ((x)) /* just the address */ #endif /* Local Variables: */ /* fill-column: 50 */ /* End: */