stand/libsa/stand.h

   1 /*
   2  * Copyright (c) 1998 Michael Smith.
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  *
  26  * $FreeBSD$
  27  * From $NetBSD: stand.h,v 1.22 1997/06/26 19:17:40 drochner Exp $
  28  */
  29
  30 /*-
  31  * Copyright (c) 1993
  32  *      The Regents of the University of California.  All rights reserved.
  33  *
  34  * Redistribution and use in source and binary forms, with or without
  35  * modification, are permitted provided that the following conditions
  36  * are met:
  37  * 1. Redistributions of source code must retain the above copyright
  38  *    notice, this list of conditions and the following disclaimer.
  39  * 2. Redistributions in binary form must reproduce the above copyright
  40  *    notice, this list of conditions and the following disclaimer in the
  41  *    documentation and/or other materials provided with the distribution.
  42  * 3. Neither the name of the University nor the names of its contributors
  43  *    may be used to endorse or promote products derived from this software
  44  *    without specific prior written permission.
  45  *
  46  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  47  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  48  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  49  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  50  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  51  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  52  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  53  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  54  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  55  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  56  * SUCH DAMAGE.
  57  *
  58  *      @(#)stand.h     8.1 (Berkeley) 6/11/93
  59  */
  60
  61 #ifndef STAND_H
  62 #define STAND_H
  63
  64 #include <sys/types.h>
  65 #include <sys/cdefs.h>
  66 #include <sys/stat.h>
  67 #include <sys/dirent.h>
  68
  69 /* this header intentionally exports NULL from <string.h> */
  70 #include <string.h>
  71 #define strcoll(a, b)   strcmp((a), (b))
  72
  73 #define CHK(fmt, args...)       printf("%s(%d): " fmt "\n", __func__, __LINE__ , ##args)
  74 #define PCHK(fmt, args...)      {printf("%s(%d): " fmt "\n", __func__, __LINE__ , ##args); getchar();}
  75
  76 #include <sys/errno.h>
  77
  78 /* special stand error codes */
  79 #define EADAPT  (ELAST+1)       /* bad adaptor */
  80 #define ECTLR   (ELAST+2)       /* bad controller */
  81 #define EUNIT   (ELAST+3)       /* bad unit */
  82 #define ESLICE  (ELAST+4)       /* bad slice */
  83 #define EPART   (ELAST+5)       /* bad partition */
  84 #define ERDLAB  (ELAST+6)       /* can't read disk label */
  85 #define EUNLAB  (ELAST+7)       /* unlabeled disk */
  86 #define EOFFSET (ELAST+8)       /* relative seek not supported */
  87 #define ESALAST (ELAST+8)       /* */
  88
  89 /* Partial signal emulation for sig_atomic_t */
  90 #include <machine/signal.h>
  91
  92 struct open_file;
  93
  94 /*
  95  * This structure is used to define file system operations in a file system
  96  * independent way.
  97  *
  98  * XXX note that filesystem providers should export a pointer to their fs_ops
  99  *     struct, so that consumers can reference this and thus include the
 100  *     filesystems that they require.
 101  */
 102 struct fs_ops {
 103     const char  *fs_name;
 104     int         (*fo_open)(const char *path, struct open_file *f);
 105     int         (*fo_close)(struct open_file *f);
 106     int         (*fo_read)(struct open_file *f, void *buf,
 107                            size_t size, size_t *resid);
 108     int         (*fo_write)(struct open_file *f, void *buf,
 109                             size_t size, size_t *resid);
 110     off_t       (*fo_seek)(struct open_file *f, off_t offset, int where);
 111     int         (*fo_stat)(struct open_file *f, struct stat *sb);
 112     int         (*fo_readdir)(struct open_file *f, struct dirent *d);
 113 };
 114
 115 /*
 116  * libstand-supplied filesystems
 117  */
 118 extern struct fs_ops ufs_fsops;
 119 extern struct fs_ops tftp_fsops;
 120 extern struct fs_ops nfs_fsops;
 121 extern struct fs_ops cd9660_fsops;
 122 extern struct fs_ops nandfs_fsops;
 123 extern struct fs_ops gzipfs_fsops;
 124 extern struct fs_ops bzipfs_fsops;
 125 extern struct fs_ops dosfs_fsops;
 126 extern struct fs_ops ext2fs_fsops;
 127 extern struct fs_ops splitfs_fsops;
 128 extern struct fs_ops pkgfs_fsops;
 129
 130 /* where values for lseek(2) */
 131 #define SEEK_SET        0       /* set file offset to offset */
 132 #define SEEK_CUR        1       /* set file offset to current plus offset */
 133 #define SEEK_END        2       /* set file offset to EOF plus offset */
 134
 135 /*
 136  * Device switch
 137  */
 138 struct devsw {
 139     const char  dv_name[8];
 140     int         dv_type;                /* opaque type constant, arch-dependant */
 141     int         (*dv_init)(void);       /* early probe call */
 142     int         (*dv_strategy)(void *devdata, int rw, daddr_t blk,
 143                         size_t size, char *buf, size_t *rsize);
 144     int         (*dv_open)(struct open_file *f, ...);
 145     int         (*dv_close)(struct open_file *f);
 146     int         (*dv_ioctl)(struct open_file *f, u_long cmd, void *data);
 147     int         (*dv_print)(int verbose);       /* print device information */
 148     void        (*dv_cleanup)(void);
 149 };
 150
 151 /*
 152  * libstand-supplied device switch
 153  */
 154 extern struct devsw netdev;
 155
 156 extern int errno;
 157
 158 /*
 159  * Generic device specifier; architecture-dependent
 160  * versions may be larger, but should be allowed to
 161  * overlap.
 162  */
 163 struct devdesc
 164 {
 165     struct devsw        *d_dev;
 166     int                 d_type;
 167 #define DEVT_NONE       0
 168 #define DEVT_DISK       1
 169 #define DEVT_NET        2
 170 #define DEVT_CD         3
 171 #define DEVT_ZFS        4
 172 #define DEVT_FD         5
 173     int                 d_unit;
 174     void                *d_opendata;
 175 };
 176
 177 struct open_file {
 178     int                 f_flags;        /* see F_* below */
 179     struct devsw        *f_dev;         /* pointer to device operations */
 180     void                *f_devdata;     /* device specific data */
 181     struct fs_ops       *f_ops;         /* pointer to file system operations */
 182     void                *f_fsdata;      /* file system specific data */
 183     off_t               f_offset;       /* current file offset */
 184     char                *f_rabuf;       /* readahead buffer pointer */
 185     size_t              f_ralen;        /* valid data in readahead buffer */
 186     off_t               f_raoffset;     /* consumer offset in readahead buffer */
 187 #define SOPEN_RASIZE    512
 188 };
 189
 190 #define SOPEN_MAX       64
 191 extern struct open_file files[];
 192
 193 /* f_flags values */
 194 #define F_READ          0x0001  /* file opened for reading */
 195 #define F_WRITE         0x0002  /* file opened for writing */
 196 #define F_RAW           0x0004  /* raw device open - no file system */
 197 #define F_NODEV         0x0008  /* network open - no device */
 198 #define F_MASK          0xFFFF
 199 /* Mode modifier for strategy() */
 200 #define F_NORA          (0x01 << 16)    /* Disable Read-Ahead */
 201
 202 #define isascii(c)      (((c) & ~0x7F) == 0)
 203
 204 static __inline int isupper(int c)
 205 {
 206     return c >= 'A' && c <= 'Z';
 207 }
 208
 209 static __inline int islower(int c)
 210 {
 211     return c >= 'a' && c <= 'z';
 212 }
 213
 214 static __inline int isspace(int c)
 215 {
 216     return c == ' ' || (c >= 0x9 && c <= 0xd);
 217 }
 218
 219 static __inline int isdigit(int c)
 220 {
 221     return c >= '0' && c <= '9';
 222 }
 223
 224 static __inline int isxdigit(int c)
 225 {
 226     return isdigit(c) || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F');
 227 }
 228
 229 static __inline int isalpha(int c)
 230 {
 231     return isupper(c) || islower(c);
 232 }
 233
 234 static __inline int isalnum(int c)
 235 {
 236     return isalpha(c) || isdigit(c);
 237 }
 238
 239 static __inline int iscntrl(int c)
 240 {
 241         return (c >= 0 && c < ' ') || c == 127;
 242 }
 243
 244 static __inline int isgraph(int c)
 245 {
 246         return c >= '!' && c <= '~';
 247 }
 248
 249 static __inline int ispunct(int c)
 250 {
 251         return (c >= '!' && c <= '/') || (c >= ':' && c <= '@') ||
 252             (c >= '[' && c <= '`') || (c >= '{' && c <= '~');
 253 }
 254
 255 static __inline int toupper(int c)
 256 {
 257     return islower(c) ? c - 'a' + 'A' : c;
 258 }
 259
 260 static __inline int tolower(int c)
 261 {
 262     return isupper(c) ? c - 'A' + 'a' : c;
 263 }
 264
 265 /* sbrk emulation */
 266 extern void     setheap(void *base, void *top);
 267 extern char     *sbrk(int incr);
 268
 269 extern void     *reallocf(void *ptr, size_t size);
 270 extern void     mallocstats(void);
 271
 272 extern int      printf(const char *fmt, ...) __printflike(1, 2);
 273 extern void     vprintf(const char *fmt, __va_list);
 274 extern int      sprintf(char *buf, const char *cfmt, ...) __printflike(2, 3);
 275 extern int      snprintf(char *buf, size_t size, const char *cfmt, ...) __printflike(3, 4);
 276 extern void     vsprintf(char *buf, const char *cfmt, __va_list);
 277
 278 extern void     twiddle(u_int callerdiv);
 279 extern void     twiddle_divisor(u_int globaldiv);
 280
 281 extern void     ngets(char *, int);
 282 #define gets(x) ngets((x), 0)
 283 extern int      fgetstr(char *buf, int size, int fd);
 284
 285 extern int      open(const char *, int);
 286 #define O_RDONLY        0x0
 287 #define O_WRONLY        0x1
 288 #define O_RDWR          0x2
 289 extern int      close(int);
 290 extern void     closeall(void);
 291 extern ssize_t  read(int, void *, size_t);
 292 extern ssize_t  write(int, void *, size_t);
 293 extern struct   dirent *readdirfd(int);
 294
 295 extern void     srandom(unsigned int);
 296 extern long     random(void);
 297
 298 /* imports from stdlib, locally modified */
 299 extern char     *optarg;                        /* getopt(3) external variables */
 300 extern int      optind, opterr, optopt, optreset;
 301 extern int      getopt(int, char * const [], const char *);
 302
 303 /* pager.c */
 304 extern void     pager_open(void);
 305 extern void     pager_close(void);
 306 extern int      pager_output(const char *lines);
 307 extern int      pager_file(const char *fname);
 308
 309 /* No signal state to preserve */
 310 #define setjmp  _setjmp
 311 #define longjmp _longjmp
 312
 313 /* environment.c */
 314 #define EV_DYNAMIC      (1<<0)          /* value was dynamically allocated, free if changed/unset */
 315 #define EV_VOLATILE     (1<<1)          /* value is volatile, make a copy of it */
 316 #define EV_NOHOOK       (1<<2)          /* don't call hook when setting */
 317
 318 struct env_var;
 319 typedef char    *(ev_format_t)(struct env_var *ev);
 320 typedef int     (ev_sethook_t)(struct env_var *ev, int flags,
 321                     const void *value);
 322 typedef int     (ev_unsethook_t)(struct env_var *ev);
 323
 324 struct env_var
 325 {
 326     char                *ev_name;
 327     int                 ev_flags;
 328     void                *ev_value;
 329     ev_sethook_t        *ev_sethook;
 330     ev_unsethook_t      *ev_unsethook;
 331     struct env_var      *ev_next, *ev_prev;
 332 };
 333 extern struct env_var   *environ;
 334
 335 extern struct env_var   *env_getenv(const char *name);
 336 extern int              env_setenv(const char *name, int flags,
 337                                    const void *value, ev_sethook_t sethook,
 338                                    ev_unsethook_t unsethook);
 339 extern char             *getenv(const char *name);
 340 extern int              setenv(const char *name, const char *value,
 341                                int overwrite);
 342 extern int              putenv(char *string);
 343 extern int              unsetenv(const char *name);
 344
 345 extern ev_sethook_t     env_noset;              /* refuse set operation */
 346 extern ev_unsethook_t   env_nounset;            /* refuse unset operation */
 347
 348 /* stdlib.h routines */
 349 extern int              abs(int a);
 350 extern void             abort(void) __dead2;
 351 extern long             strtol(const char * __restrict, char ** __restrict, int);
 352 extern long long        strtoll(const char * __restrict, char ** __restrict, int);
 353 extern unsigned long    strtoul(const char * __restrict, char ** __restrict, int);
 354 extern unsigned long long strtoull(const char * __restrict, char ** __restrict, int);
 355
 356 /* BCD conversions (undocumented) */
 357 extern u_char const     bcd2bin_data[];
 358 extern u_char const     bin2bcd_data[];
 359 extern char const       hex2ascii_data[];
 360
 361 #define bcd2bin(bcd)    (bcd2bin_data[bcd])
 362 #define bin2bcd(bin)    (bin2bcd_data[bin])
 363 #define hex2ascii(hex)  (hex2ascii_data[hex])
 364 #define validbcd(bcd)   (bcd == 0 || (bcd > 0 && bcd <= 0x99 && bcd2bin_data[bcd] != 0))
 365
 366 /* min/max (undocumented) */
 367 static __inline int imax(int a, int b) { return (a > b ? a : b); }
 368 static __inline int imin(int a, int b) { return (a < b ? a : b); }
 369 static __inline long lmax(long a, long b) { return (a > b ? a : b); }
 370 static __inline long lmin(long a, long b) { return (a < b ? a : b); }
 371 static __inline u_int max(u_int a, u_int b) { return (a > b ? a : b); }
 372 static __inline u_int min(u_int a, u_int b) { return (a < b ? a : b); }
 373 static __inline quad_t qmax(quad_t a, quad_t b) { return (a > b ? a : b); }
 374 static __inline quad_t qmin(quad_t a, quad_t b) { return (a < b ? a : b); }
 375 static __inline u_long ulmax(u_long a, u_long b) { return (a > b ? a : b); }
 376 static __inline u_long ulmin(u_long a, u_long b) { return (a < b ? a : b); }
 377
 378 /* null functions for device/filesystem switches (undocumented) */
 379 extern int      nodev(void);
 380 extern int      noioctl(struct open_file *, u_long, void *);
 381 extern void     nullsys(void);
 382
 383 extern int      null_open(const char *path, struct open_file *f);
 384 extern int      null_close(struct open_file *f);
 385 extern int      null_read(struct open_file *f, void *buf, size_t size, size_t *resid);
 386 extern int      null_write(struct open_file *f, void *buf, size_t size, size_t *resid);
 387 extern off_t    null_seek(struct open_file *f, off_t offset, int where);
 388 extern int      null_stat(struct open_file *f, struct stat *sb);
 389 extern int      null_readdir(struct open_file *f, struct dirent *d);
 390
 391
 392 /*
 393  * Machine dependent functions and data, must be provided or stubbed by
 394  * the consumer
 395  */
 396 extern void             exit(int) __dead2;
 397 extern int              getchar(void);
 398 extern int              ischar(void);
 399 extern void             putchar(int);
 400 extern int              devopen(struct open_file *, const char *, const char **);
 401 extern int              devclose(struct open_file *f);
 402 extern void             panic(const char *, ...) __dead2 __printflike(1, 2);
 403 extern void             panic_action(void) __weak_symbol __dead2;
 404 extern time_t           getsecs(void);
 405 extern struct fs_ops    *file_system[];
 406 extern struct fs_ops    *exclusive_file_system;
 407 extern struct devsw     *devsw[];
 408
 409 /*
 410  * Expose byteorder(3) functions.
 411  */
 412 #ifndef _BYTEORDER_PROTOTYPED
 413 #define _BYTEORDER_PROTOTYPED
 414 extern uint32_t         htonl(uint32_t);
 415 extern uint16_t         htons(uint16_t);
 416 extern uint32_t         ntohl(uint32_t);
 417 extern uint16_t         ntohs(uint16_t);
 418 #endif
 419
 420 #ifndef _BYTEORDER_FUNC_DEFINED
 421 #define _BYTEORDER_FUNC_DEFINED
 422 #define htonl(x)        __htonl(x)
 423 #define htons(x)        __htons(x)
 424 #define ntohl(x)        __ntohl(x)
 425 #define ntohs(x)        __ntohs(x)
 426 #endif
 427
 428 void *Malloc(size_t, const char *, int);
 429 void *Calloc(size_t, size_t, const char *, int);
 430 void *Realloc(void *, size_t, const char *, int);
 431 void Free(void *, const char *, int);
 432
 433 #ifdef DEBUG_MALLOC
 434 #define malloc(x)       Malloc(x, __FILE__, __LINE__)
 435 #define calloc(x, y)    Calloc(x, y, __FILE__, __LINE__)
 436 #define free(x)         Free(x, __FILE__, __LINE__)
 437 #define realloc(x, y)   Realloc(x, y, __FILE__, __LINE__)
 438 #else
 439 #define malloc(x)       Malloc(x, NULL, 0)
 440 #define calloc(x, y)    Calloc(x, y, NULL, 0)
 441 #define free(x)         Free(x, NULL, 0)
 442 #define realloc(x, y)   Realloc(x, y, NULL, 0)
 443 #endif
 444
 445 #endif  /* STAND_H */