my_sys.h 31 KB
Newer Older
unknown's avatar
unknown committed
1 2 3 4 5 6 7 8
/* Copyright (C) 2000 MySQL AB

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
unknown's avatar
unknown committed
9
   but WITHOUT ANY WARRANTY; without even the implied warranty of
unknown's avatar
unknown committed
10 11 12 13 14 15
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
unknown's avatar
unknown committed
16 17 18

#ifndef _my_sys_h
#define _my_sys_h
unknown's avatar
unknown committed
19
C_MODE_START
unknown's avatar
unknown committed
20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58

#ifdef HAVE_AIOWAIT
#include <sys/asynch.h>			/* Used by record-cache */
typedef struct my_aio_result {
  aio_result_t result;
  int	       pending;
} my_aio_result;
#endif

#ifndef THREAD
extern int NEAR my_errno;		/* Last error in mysys */
#else
#include <my_pthread.h>
#endif

#ifndef _m_ctype_h
#include <m_ctype.h>                    /* for CHARSET_INFO */
#endif

#include <stdarg.h>  

#define MYSYS_PROGRAM_USES_CURSES()  { error_handler_hook = my_message_curses;	mysys_uses_curses=1; }
#define MYSYS_PROGRAM_DONT_USE_CURSES()  { error_handler_hook = my_message_no_curses; mysys_uses_curses=0;}
#define MY_INIT(name);		{ my_progname= name; my_init(); }

#define MAXMAPS		(4)	/* Number of error message maps */
#define ERRMOD		(1000)	/* Max number of errors in a map */
#define ERRMSGSIZE	(SC_MAXWIDTH)	/* Max length of a error message */
#define NRERRBUFFS	(2)	/* Buffers for parameters */
#define MY_FILE_ERROR	((uint) ~0)

	/* General bitmaps for my_func's */
#define MY_FFNF		1	/* Fatal if file not found */
#define MY_FNABP	2	/* Fatal if not all bytes read/writen */
#define MY_NABP		4	/* Error if not all bytes read/writen */
#define MY_FAE		8	/* Fatal if any error */
#define MY_WME		16	/* Write message on error */
#define MY_WAIT_IF_FULL 32	/* Wait and try again if disk full error */
#define MY_RAID         64      /* Support for RAID (not the "Johnson&Johnson"-s one ;) */
59
#define MY_FULL_IO     512      /* For my_read - loop intil I/O
unknown's avatar
unknown committed
60 61
				   is complete
				*/
62
#define MY_DONT_CHECK_FILESIZE 128	/* Option to init_io_cache() */
unknown's avatar
unknown committed
63 64
#define MY_LINK_WARNING 32	/* my_redel() gives warning if links */
#define MY_COPYTIME	64	/* my_redel() copys time */
65 66
#define MY_DELETE_OLD	256	/* my_create_with_symlink() */
#define MY_RESOLVE_LINK 128	/* my_realpath(); Only resolve links */
unknown's avatar
unknown committed
67
#define MY_HOLD_ORIGINAL_MODES 128  /* my_copy() holds to file modes */
68
#define MY_REDEL_MAKE_BACKUP 256
unknown's avatar
unknown committed
69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92
#define MY_SEEK_NOT_DONE 32	/* my_lock may have to do a seek */
#define MY_DONT_WAIT	64	/* my_lock() don't wait if can't lock */
#define MY_ZEROFILL	32	/* my_malloc(), fill array with zero */
#define MY_ALLOW_ZERO_PTR 64	/* my_realloc() ; zero ptr -> malloc */
#define MY_FREE_ON_ERROR 128	/* my_realloc() ; Free old ptr on error */
#define MY_HOLD_ON_ERROR 256	/* my_realloc() ; Return old ptr on error */
#define MY_THREADSAFE	128	/* pread/pwrite:  Don't allow interrupts */

#define MY_CHECK_ERROR	1	/* Params to my_end; Check open-close */
#define MY_GIVE_INFO	2	/* Give time info about process*/

#define ME_HIGHBYTE	8	/* Shift for colours */
#define ME_NOCUR	1	/* Don't use curses message */
#define ME_OLDWIN	2	/* Use old window */
#define ME_BELL		4	/* Ring bell then printing message */
#define ME_HOLDTANG	8	/* Don't delete last keys */
#define ME_WAITTOT	16	/* Wait for errtime secs of for a action */
#define ME_WAITTANG	32	/* Wait for a user action  */
#define ME_NOREFRESH	64	/* Dont refresh screen */
#define ME_NOINPUT	128	/* Dont use the input libary */
#define ME_COLOUR1	((1 << ME_HIGHBYTE))	/* Possibly error-colours */
#define ME_COLOUR2	((2 << ME_HIGHBYTE))
#define ME_COLOUR3	((3 << ME_HIGHBYTE))

93 94 95 96 97 98 99 100 101 102
	/* Bits in last argument to fn_format */
#define MY_REPLACE_DIR		1	/* replace dir in name with 'dir' */
#define MY_REPLACE_EXT		2	/* replace extension with 'ext' */
#define MY_UNPACK_FILENAME	4	/* Unpack name (~ -> home) */
#define MY_PACK_FILENAME	8	/* Pack name (home -> ~) */
#define MY_RESOLVE_SYMLINKS	16	/* Resolve all symbolic links */
#define MY_RETURN_REAL_PATH	32	/* return full path for file */
#define MY_SAFE_PATH		64	/* Return NULL if too long path */
#define MY_RELATIVE_PATH	128	/* name is relative to 'dir' */

unknown's avatar
unknown committed
103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118
	/* My seek flags */
#define MY_SEEK_SET	0
#define MY_SEEK_CUR	1
#define MY_SEEK_END	2

        /* My charsets_list flags */
#define MY_NO_SETS       0
#define MY_COMPILED_SETS 1      /* show compiled-in sets */
#define MY_CONFIG_SETS   2      /* sets that have a *.conf file */
#define MY_INDEX_SETS    4      /* all sets listed in the Index file */
#define MY_LOADED_SETS    8      /* the sets that are currently loaded */

	/* Some constants */
#define MY_WAIT_FOR_USER_TO_FIX_PANIC	60	/* in seconds */
#define MY_WAIT_GIVE_USER_A_MESSAGE	10	/* Every 10 times of prev */
#define MIN_COMPRESS_LENGTH		50	/* Don't compress small bl. */
unknown's avatar
unknown committed
119 120
#define DEFAULT_KEYCACHE_BLOCK_SIZE	1024
#define MAX_KEYCACHE_BLOCK_SIZE		16384
unknown's avatar
unknown committed
121

122 123
	/* root_alloc flags */
#define MY_KEEP_PREALLOC	1
124
#define MY_MARK_BLOCKS_FREE     2  /* move used to free list and reuse them */
unknown's avatar
unknown committed
125

unknown's avatar
unknown committed
126 127 128 129
	/* defines when allocating data */

#ifdef SAFEMALLOC
#define my_malloc(SZ,FLAG) _mymalloc( SZ, __FILE__, __LINE__, FLAG )
130
#define my_malloc_ci(SZ,FLAG) _mymalloc( SZ, sFile, uLine, FLAG )
unknown's avatar
unknown committed
131 132 133 134 135 136 137 138
#define my_realloc(PTR,SZ,FLAG) _myrealloc( PTR, SZ, __FILE__, __LINE__, FLAG )
#define my_checkmalloc() _sanity( __FILE__, __LINE__ )
#define my_free(PTR,FLAG) _myfree( PTR, __FILE__, __LINE__,FLAG)
#define my_memdup(A,B,C) _my_memdup(A,B,__FILE__,__LINE__,C)
#define my_strdup(A,C) _my_strdup(A,__FILE__,__LINE__,C)
#define QUICK_SAFEMALLOC sf_malloc_quick=1
#define NORMAL_SAFEMALLOC sf_malloc_quick=0
extern uint sf_malloc_prehunc,sf_malloc_endhunc,sf_malloc_quick;
unknown's avatar
unknown committed
139
extern ulonglong safemalloc_mem_limit;
140 141 142 143
/* keep track of shutdown,signal, and main threads so that my_end() will not
   report errors with them
*/
extern pthread_t shutdown_th, main_th,signal_th;
144 145 146
#define CALLER_INFO_PROTO   , const char *sFile, uint uLine
#define CALLER_INFO         , __FILE__, __LINE__
#define ORIG_CALLER_INFO    , sFile, uLine
unknown's avatar
unknown committed
147 148
#else
#define my_checkmalloc() (0)
unknown's avatar
unknown committed
149
#undef TERMINATE
unknown's avatar
unknown committed
150 151 152 153
#define TERMINATE(A) {}
#define QUICK_SAFEMALLOC
#define NORMAL_SAFEMALLOC
extern gptr my_malloc(uint Size,myf MyFlags);
154
#define my_malloc_ci(SZ,FLAG) my_malloc( SZ, FLAG )
unknown's avatar
unknown committed
155 156 157 158 159
extern gptr my_realloc(gptr oldpoint,uint Size,myf MyFlags);
extern void my_no_flags_free(gptr ptr);
extern gptr my_memdup(const byte *from,uint length,myf MyFlags);
extern my_string my_strdup(const char *from,myf MyFlags);
#define my_free(PTR,FG) my_no_flags_free(PTR)
160 161 162
#define CALLER_INFO_PROTO   /* nothing */
#define CALLER_INFO         /* nothing */
#define ORIG_CALLER_INFO    /* nothing */
unknown's avatar
unknown committed
163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191
#endif
#ifdef HAVE_ALLOCA
#define my_alloca(SZ) alloca((size_t) (SZ))
#define my_afree(PTR) {}
#else
#define my_alloca(SZ) my_malloc(SZ,MYF(0))
#define my_afree(PTR) my_free(PTR,MYF(MY_WME))
#endif /* HAVE_ALLOCA */
#ifdef MSDOS
#ifdef __ZTC__
void * __CDECL halloc(long count,size_t length);
void   __CDECL hfree(void *ptr);
#endif
#if defined(USE_HALLOC)
#if defined(_VCM_) || defined(M_IC80386)
#undef USE_HALLOC
#endif
#endif
#ifdef USE_HALLOC
#define malloc(a) halloc((long) (a),1)
#define free(a) hfree(a)
#endif
#endif /* MSDOS */

#ifdef HAVE_ERRNO_AS_DEFINE
#include <errno.h>			/* errno is a define */
#else
extern int errno;			/* declare errno */
#endif
192
extern const char ** NEAR my_errmsg[];
unknown's avatar
unknown committed
193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209
extern char NEAR errbuff[NRERRBUFFS][ERRMSGSIZE];
extern char *home_dir;			/* Home directory for user */
extern char *my_progname;		/* program-name (printed in errors) */
extern char NEAR curr_dir[];		/* Current directory for user */
extern int (*error_handler_hook)(uint my_err, const char *str,myf MyFlags);
extern int (*fatal_error_handler_hook)(uint my_err, const char *str,
				       myf MyFlags);

/* charsets */
extern uint get_charset_number(const char *cs_name);
extern const char *get_charset_name(uint cs_number);
extern CHARSET_INFO *get_charset(uint cs_number, myf flags);
extern my_bool set_default_charset(uint cs, myf flags);
extern CHARSET_INFO *get_charset_by_name(const char *cs_name, myf flags);
extern my_bool set_default_charset_by_name(const char *cs_name, myf flags);
extern void free_charsets(void);
extern char *list_charsets(myf want_flags); /* my_free() this string... */
210
extern char *get_charsets_dir(char *buf);
unknown's avatar
unknown committed
211 212


213
/* statistics */
unknown's avatar
unknown committed
214 215
extern ulong	_my_cache_w_requests,_my_cache_write,_my_cache_r_requests,
		_my_cache_read;
unknown's avatar
unknown committed
216 217
extern ulong	_my_blocks_used,_my_blocks_changed;
extern uint	key_cache_block_size;
218
extern ulong	my_file_opened,my_stream_opened, my_tmp_file_created;
unknown's avatar
unknown committed
219
extern my_bool	key_cache_inited, my_init_done;
unknown's avatar
unknown committed
220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236

					/* Point to current my_message() */
extern void (*my_sigtstp_cleanup)(void),
					/* Executed before jump to shell */
	    (*my_sigtstp_restart)(void),
	    (*my_abort_hook)(int);
					/* Executed when comming from shell */
extern int NEAR my_umask,		/* Default creation mask  */
	   NEAR my_umask_dir,
	   NEAR my_recived_signals,	/* Signals we have got */
	   NEAR my_safe_to_handle_signal, /* Set when allowed to SIGTSTP */
	   NEAR my_dont_interrupt;	/* call remember_intr when set */
extern my_bool NEAR mysys_uses_curses, my_use_symdir;
extern long lCurMemory,lMaxMemory;	/* from safemalloc */

extern ulong	my_default_record_cache_size;
extern my_bool NEAR my_disable_locking,NEAR my_disable_async_io,
unknown's avatar
unknown committed
237
               NEAR my_disable_flush_key_blocks, NEAR my_disable_symlinks;
unknown's avatar
unknown committed
238 239
extern char	wild_many,wild_one,wild_prefix;
extern const char *charsets_dir;
unknown's avatar
unknown committed
240
extern char *defaults_extra_file;
unknown's avatar
unknown committed
241 242 243 244 245 246 247 248 249 250 251 252 253 254

typedef struct wild_file_pack	/* Struct to hold info when selecting files */
{
  uint		wilds;		/* How many wildcards */
  uint		not_pos;	/* Start of not-theese-files */
  my_string	*wild;		/* Pointer to wildcards */
} WF_PACK;

typedef struct st_typelib {	/* Different types saved here */
  uint count;			/* How many types */
  const char *name;			/* Name of typelib */
  const char **type_names;
} TYPELIB;

unknown's avatar
unknown committed
255 256 257 258
enum cache_type {READ_CACHE,WRITE_CACHE,
		 SEQ_READ_APPEND /* sequential read or append */,
		 READ_FIFO,
		 READ_NET,WRITE_NET};
unknown's avatar
unknown committed
259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276
enum flush_type { FLUSH_KEEP, FLUSH_RELEASE, FLUSH_IGNORE_CHANGED,
		  FLUSH_FORCE_WRITE};

typedef struct st_record_cache	/* Used when cacheing records */
{
  File file;
  int	rc_seek,error,inited;
  uint	rc_length,read_length,reclength;
  my_off_t rc_record_pos,end_of_file;
  byte	*rc_buff,*rc_buff2,*rc_pos,*rc_end,*rc_request_pos;
#ifdef HAVE_AIOWAIT
  int	use_async_io;
  my_aio_result aio_result;
#endif
  enum cache_type type;
} RECORD_CACHE;

enum file_type { UNOPEN = 0, FILE_BY_OPEN, FILE_BY_CREATE,
unknown's avatar
unknown committed
277 278
		 STREAM_BY_FOPEN, STREAM_BY_FDOPEN, FILE_BY_MKSTEMP,
		 FILE_BY_DUP };
unknown's avatar
unknown committed
279 280 281 282 283

extern struct my_file_info
{
  my_string		name;
  enum file_type	type;
284 285 286
#if defined(THREAD) && !defined(HAVE_PREAD)  
  pthread_mutex_t	mutex;
#endif
unknown's avatar
unknown committed
287 288 289 290 291 292 293 294 295 296 297 298 299 300 301
} my_file_info[MY_NFILE];


typedef struct st_dynamic_array {
  char *buffer;
  uint elements,max_element;
  uint alloc_increment;
  uint size_of_element;
} DYNAMIC_ARRAY;

typedef struct st_dynamic_string {
  char *str;
  uint length,max_length,alloc_increment;
} DYNAMIC_STRING;

302 303
struct st_io_cache;
typedef int (*IO_CACHE_CALLBACK)(struct st_io_cache*);
unknown's avatar
unknown committed
304

unknown's avatar
unknown committed
305

unknown's avatar
unknown committed
306 307
typedef struct st_io_cache		/* Used when cacheing files */
{
308 309 310 311 312
  /* pos_in_file is offset in file corresponding to the first byte of
     byte* buffer. end_of_file is the offset of end of file for READ_CACHE
     and WRITE_CACHE. For SEQ_READ_APPEND it the maximum of the actual
     end of file and the position represented by read_end.
  */
313
  my_off_t pos_in_file,end_of_file;
314 315 316 317 318 319
  /* read_pos points to current read position in the buffer
     read_end is the non-inclusive boundary in the buffer for the currently
     valid read area
     buffer is the read buffer
     not sure about request_pos except that it is used in async_io
  */
unknown's avatar
unknown committed
320
  byte	*read_pos,*read_end,*buffer,*request_pos;
321 322 323 324 325 326 327 328 329
  /* write_buffer is used only in WRITE caches and in SEQ_READ_APPEND to
     buffer writes
     append_read_pos is only used in SEQ_READ_APPEND, and points to the
     current read position in the write buffer. Note that reads in
     SEQ_READ_APPEND caches can happen from both read buffer (byte* buffer),
     and write buffer (byte* write_buffer).
     write_pos points to current write position in the write buffer and
     write_end is the non-inclusive boundary of the valid write area
  */
unknown's avatar
unknown committed
330
  byte  *write_buffer, *append_read_pos, *write_pos, *write_end;
331 332 333 334 335
  /* current_pos and current_end are convenience variables used by
     my_b_tell() and other routines that need to know the current offset
     current_pos points to &write_pos, and current_end to &write_end in a
     WRITE_CACHE, and &read_pos and &read_end respectively otherwise
  */
unknown's avatar
unknown committed
336
  byte  **current_pos, **current_end;
337
/* The lock is for append buffer used in SEQ_READ_APPEND cache */
unknown's avatar
unknown committed
338 339 340
#ifdef THREAD
  pthread_mutex_t append_buffer_lock;
  /* need mutex copying from append buffer to read buffer */
341 342 343 344 345 346 347 348
#endif
  /* a caller will use my_b_read() macro to read from the cache
     if the data is already in cache, it will be simply copied with
     memcpy() and internal variables will be accordinging updated with
     no functions invoked. However, if the data is not fully in the cache,
     my_b_read() will call read_function to fetch the data. read_function
     must never be invoked directly
  */
349
  int (*read_function)(struct st_io_cache *,byte *,uint);
350 351 352
  /* same idea as in the case of read_function, except my_b_write() needs to
     be replaced with my_b_append() for a SEQ_READ_APPEND cache
  */
353
  int (*write_function)(struct st_io_cache *,const byte *,uint);
354 355 356 357
  /* specifies the type of the cache. Depending on the type of the cache
     certain operations might not be available and yield unpredicatable
     results. Details to be documented later
  */
unknown's avatar
unknown committed
358
  enum cache_type type;
359 360 361 362 363 364
  /* callbacks when the actual read I/O happens. These were added and
   are currently used for binary logging of LOAD DATA INFILE - when a
   block is read from the file, we create a block create/append event, and
   when IO_CACHE is closed, we create an end event. These functions could,
   of course be used for other things
  */
365 366
  IO_CACHE_CALLBACK pre_read;
  IO_CACHE_CALLBACK post_read;
367 368
  IO_CACHE_CALLBACK pre_close;
  void* arg; /* for use by pre/post_read */
369 370
  char *file_name;			/* if used with 'open_cached_file' */
  char *dir,*prefix;
371 372 373 374 375 376 377
  File file; /* file descriptor */
  /* seek_not_done is set by my_b_seek() to inform the upcoming read/write
     operation that a seek needs to be preformed prior to the actual I/O
     error is 0 if the cache operation was successful, -1 if there was a
     "hard" error, and the actual number of I/O-ed bytes if the read/write was
     partial
  */
unknown's avatar
unknown committed
378
  int	seek_not_done,error;
379 380 381 382
  /* buffer_length is the size of memory allocated for buffer or write_buffer
     read_length is the same as buffer_length except when we use async io
     not sure why we need it
   */
unknown's avatar
unknown committed
383 384
  uint	buffer_length,read_length;
  myf	myflags;			/* Flags used to my_read/my_write */
unknown's avatar
unknown committed
385
 /*
386 387
   alloced_buffer is 1 if the buffer was allocated by init_io_cache() and
   0 if it was supplied by the user
unknown's avatar
unknown committed
388 389 390 391
   Currently READ_NET is the only one that will use a buffer allocated
   somewhere else
 */
  my_bool alloced_buffer;
392 393 394 395 396 397 398 399 400 401 402
  /* init_count is incremented every time we call init_io_cache()
     It is not reset in end_io_cache(). This variable
     was introduced for slave relay logs - RELAY_LOG_INFO stores a pointer
     to IO_CACHE that could in some cases refer to the IO_CACHE of the
     currently active relay log. The IO_CACHE then could be closed,
     re-opened and start pointing to a different log file. In that case,
     we could not know reliably if this happened without init_count
     one must be careful with bzero() prior to the subsequent init_io_cache()
     call
  */
  int init_count;
unknown's avatar
unknown committed
403
#ifdef HAVE_AIOWAIT
404 405 406
  /* as inidicated by ifdef, this is for async I/O, we will have
     Sinisa comment this some time
  */
unknown's avatar
unknown committed
407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422
  uint inited;
  my_off_t aio_read_pos;
  my_aio_result aio_result;
#endif
} IO_CACHE;

typedef int (*qsort2_cmp)(const void *, const void *, const void *);

	/* defines for mf_iocache */

	/* Test if buffer is inited */
#define my_b_clear(info) (info)->buffer=0
#define my_b_inited(info) (info)->buffer
#define my_b_EOF INT_MIN

#define my_b_read(info,Buffer,Count) \
unknown's avatar
unknown committed
423 424 425
  ((info)->read_pos + (Count) <= (info)->read_end ?\
   (memcpy(Buffer,(info)->read_pos,(size_t) (Count)), \
    ((info)->read_pos+=(Count)),0) :\
unknown's avatar
unknown committed
426 427
   (*(info)->read_function)((info),Buffer,Count))

428 429 430 431 432
#define my_b_write(info,Buffer,Count) \
 ((info)->write_pos + (Count) <=(info)->write_end ?\
  (memcpy((info)->write_pos, (Buffer), (size_t)(Count)),\
   ((info)->write_pos+=(Count)),0) : \
   (*(info)->write_function)((info),(Buffer),(Count)))
unknown's avatar
unknown committed
433

434

unknown's avatar
unknown committed
435
#define my_b_get(info) \
unknown's avatar
unknown committed
436 437
  ((info)->read_pos != (info)->read_end ?\
   ((info)->read_pos++, (int) (uchar) (info)->read_pos[-1]) :\
unknown's avatar
unknown committed
438 439 440 441
   _my_b_get(info))

	/* my_b_write_byte dosn't have any err-check */
#define my_b_write_byte(info,chr) \
unknown's avatar
unknown committed
442 443 444
  (((info)->write_pos < (info)->write_end) ?\
   ((*(info)->write_pos++)=(chr)) :\
   (_my_b_write(info,0,0) , ((*(info)->write_pos++)=(chr))))
unknown's avatar
unknown committed
445 446

#define my_b_fill_cache(info) \
unknown's avatar
unknown committed
447
  (((info)->read_end=(info)->read_pos),(*(info)->read_function)(info,0,0))
unknown's avatar
unknown committed
448

unknown's avatar
unknown committed
449
#define my_b_tell(info) ((info)->pos_in_file + \
unknown's avatar
unknown committed
450
			 (uint) (*(info)->current_pos - (info)->request_pos))
451 452 453

/* tell write offset in the SEQ_APPEND cache */
my_off_t my_b_append_tell(IO_CACHE* info);
unknown's avatar
unknown committed
454 455 456

#define my_b_bytes_in_cache(info) (uint) (*(info)->current_end - \
					  *(info)->current_pos)
unknown's avatar
unknown committed
457

458

unknown's avatar
unknown committed
459
typedef struct st_changeable_var {
unknown's avatar
unknown committed
460 461 462 463 464 465 466
  const char *name;			/* Name of variable */
  long *varptr;				/* Pointer to variable */
  long def_value,			/* Default value */
       min_value,			/* Min allowed value */
       max_value,			/* Max allowed value */
       sub_size,			/* Subtract this from given value */
       block_size;			/* Value should be a mult. of this */
unknown's avatar
unknown committed
467 468 469 470 471 472 473 474 475
} CHANGEABLE_VAR;


/* structs for alloc_root */

#ifndef ST_USED_MEM_DEFINED
#define ST_USED_MEM_DEFINED
typedef struct st_used_mem {			/* struct for once_alloc */
  struct st_used_mem *next;			/* Next block in use */
476 477
  unsigned int left;				/* memory left in block  */
  unsigned int size;				/* Size of block */
unknown's avatar
unknown committed
478 479 480 481 482
} USED_MEM;

typedef struct st_mem_root {
  USED_MEM *free;
  USED_MEM *used;
483
  USED_MEM *pre_alloc;
unknown's avatar
unknown committed
484 485
  unsigned int	min_malloc;
  unsigned int	block_size;
486

unknown's avatar
unknown committed
487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502
  void (*error_handler)(void);
} MEM_ROOT;
#endif

	/* Prototypes for mysys and my_func functions */

extern int my_copy(const char *from,const char *to,myf MyFlags);
extern int my_append(const char *from,const char *to,myf MyFlags);
extern int my_delete(const char *name,myf MyFlags);
extern int my_getwd(my_string buf,uint size,myf MyFlags);
extern int my_setwd(const char *dir,myf MyFlags);
extern int my_lock(File fd,int op,my_off_t start, my_off_t length,myf MyFlags);
extern gptr my_once_alloc(uint Size,myf MyFlags);
extern void my_once_free(void);
extern my_string my_tempnam(const char *dir,const char *pfx,myf MyFlags);
extern File my_open(const char *FileName,int Flags,myf MyFlags);
unknown's avatar
unknown committed
503 504 505
extern File my_register_filename(File fd, const char *FileName,
				 enum file_type type_of_file,
				 uint error_message_number, myf MyFlags);
unknown's avatar
unknown committed
506 507 508
extern File my_create(const char *FileName,int CreateFlags,
		      int AccsesFlags, myf MyFlags);
extern int my_close(File Filedes,myf MyFlags);
unknown's avatar
unknown committed
509
extern File my_dup(File file, myf MyFlags);
unknown's avatar
unknown committed
510
extern int my_mkdir(const char *dir, int Flags, myf MyFlags);
511 512 513 514 515
extern int my_readlink(char *to, const char *filename, myf MyFlags);
extern int my_realpath(char *to, const char *filename, myf MyFlags);
extern File my_create_with_symlink(const char *linkname, const char *filename,
				   int createflags, int access_flags,
				   myf MyFlags);
516 517
extern int my_delete_with_symlink(const char *name, myf MyFlags);
extern int my_rename_with_symlink(const char *from,const char *to,myf MyFlags);
518
extern int my_symlink(const char *content, const char *linkname, myf MyFlags);
unknown's avatar
unknown committed
519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549
extern uint my_read(File Filedes,byte *Buffer,uint Count,myf MyFlags);
extern uint my_pread(File Filedes,byte *Buffer,uint Count,my_off_t offset,
		     myf MyFlags);
extern int my_rename(const char *from,const char *to,myf MyFlags);
extern my_off_t my_seek(File fd,my_off_t pos,int whence,myf MyFlags);
extern my_off_t my_tell(File fd,myf MyFlags);
extern uint my_write(File Filedes,const byte *Buffer,uint Count,
		     myf MyFlags);
extern uint my_pwrite(File Filedes,const byte *Buffer,uint Count,
		      my_off_t offset,myf MyFlags);
extern uint my_fread(FILE *stream,byte *Buffer,uint Count,myf MyFlags);
extern uint my_fwrite(FILE *stream,const byte *Buffer,uint Count,
		      myf MyFlags);
extern my_off_t my_fseek(FILE *stream,my_off_t pos,int whence,myf MyFlags);
extern my_off_t my_ftell(FILE *stream,myf MyFlags);
extern gptr _mymalloc(uint uSize,const char *sFile,
		      uint uLine, myf MyFlag);
extern gptr _myrealloc(gptr pPtr,uint uSize,const char *sFile,
		       uint uLine, myf MyFlag);
extern gptr my_multi_malloc _VARARGS((myf MyFlags, ...));
extern void _myfree(gptr pPtr,const char *sFile,uint uLine, myf MyFlag);
extern int _sanity(const char *sFile,unsigned int uLine);
extern gptr _my_memdup(const byte *from,uint length,
		       const char *sFile, uint uLine,myf MyFlag);
extern my_string _my_strdup(const char *from, const char *sFile, uint uLine,
			    myf MyFlag);
#ifndef TERMINATE
extern void TERMINATE(FILE *file);
#endif
extern void init_glob_errs(void);
extern FILE *my_fopen(const char *FileName,int Flags,myf MyFlags);
550
extern FILE *my_fdopen(File Filedes,const char *name, int Flags,myf MyFlags);
unknown's avatar
unknown committed
551 552 553 554 555 556 557 558
extern int my_fclose(FILE *fd,myf MyFlags);
extern int my_chsize(File fd,my_off_t newlength,myf MyFlags);
extern int my_error _VARARGS((int nr,myf MyFlags, ...));
extern int my_printf_error _VARARGS((uint my_err, const char *format,
				     myf MyFlags, ...)
				    __attribute__ ((format (printf, 2, 4))));
extern int my_vsnprintf( char *str, size_t n,
                                const char *format, va_list ap );
559
extern int my_snprintf(char* to, size_t n, const char* fmt, ...);
unknown's avatar
unknown committed
560 561 562 563 564 565 566 567 568
extern int my_message(uint my_err, const char *str,myf MyFlags);
extern int my_message_no_curses(uint my_err, const char *str,myf MyFlags);
extern int my_message_curses(uint my_err, const char *str,myf MyFlags);
extern void my_init(void);
extern void my_end(int infoflag);
extern int my_redel(const char *from, const char *to, int MyFlags);
extern int my_copystat(const char *from, const char *to, int MyFlags);
extern my_string my_filename(File fd);

569
#ifndef THREAD
unknown's avatar
unknown committed
570 571
extern void dont_break(void);
extern void allow_break(void);
572 573 574 575 576
#else
#define dont_break()
#define allow_break()
#endif

unknown's avatar
unknown committed
577 578 579 580 581 582 583 584 585 586
extern void my_remember_signal(int signal_number,sig_handler (*func)(int));
extern void caseup(my_string str,uint length);
extern void casedn(my_string str,uint length);
extern void caseup_str(my_string str);
extern void casedn_str(my_string str);
extern void case_sort(my_string str,uint length);
extern uint dirname_part(my_string to,const char *name);
extern uint dirname_length(const char *name);
#define base_name(A) (A+dirname_length(A))
extern int test_if_hard_path(const char *dir_name);
587
extern char *convert_dirname(char *to, const char *from, const char *from_end);
unknown's avatar
unknown committed
588 589 590
extern void to_unix_path(my_string name);
extern my_string fn_ext(const char *name);
extern my_string fn_same(my_string toname,const char *name,int flag);
591 592
extern my_string fn_format(my_string to,const char *name,const char *dir,
			   const char *form, uint flag);
unknown's avatar
unknown committed
593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650
extern size_s strlength(const char *str);
extern void pack_dirname(my_string to,const char *from);
extern uint unpack_dirname(my_string to,const char *from);
extern uint cleanup_dirname(my_string to,const char *from);
extern uint system_filename(my_string to,const char *from);
extern my_string unpack_filename(my_string to,const char *from);
extern my_string intern_filename(my_string to,const char *from);
extern my_string directory_file_name(my_string dst, const char *src);
extern int pack_filename(my_string to, const char *name, size_s max_length);
extern my_string my_path(my_string to,const char *progname,
			 const char *own_pathname_part);
extern my_string my_load_path(my_string to, const char *path,
			      const char *own_path_prefix);
extern int wild_compare(const char *str,const char *wildstr);
extern my_string my_strcasestr(const char *src,const char *suffix);
extern int my_strcasecmp(const char *s,const char *t);
extern int my_strsortcmp(const char *s,const char *t);
extern int my_casecmp(const char *s,const char *t,uint length);
extern int my_sortcmp(const char *s,const char *t,uint length);
extern int my_sortncmp(const char *s,uint s_len, const char *t,uint t_len);
extern WF_PACK *wf_comp(my_string str);
extern int wf_test(struct wild_file_pack *wf_pack,const char *name);
extern void wf_end(struct wild_file_pack *buffer);
extern size_s stripp_sp(my_string str);
extern void get_date(my_string to,int timeflag,time_t use_time);
extern void soundex(my_string out_pntr, my_string in_pntr,pbool remove_garbage);
extern int init_record_cache(RECORD_CACHE *info,uint cachesize,File file,
			     uint reclength,enum cache_type type,
			     pbool use_async_io);
extern int read_cache_record(RECORD_CACHE *info,byte *to);
extern int end_record_cache(RECORD_CACHE *info);
extern int write_cache_record(RECORD_CACHE *info,my_off_t filepos,
			      const byte *record,uint length);
extern int flush_write_cache(RECORD_CACHE *info);
extern long my_clock(void);
extern sig_handler sigtstp_handler(int signal_number);
extern void handle_recived_signals(void);
extern int init_key_cache(ulong use_mem,ulong leave_this_much_mem);
extern byte *key_cache_read(File file,my_off_t filepos,byte* buff,uint length,
			    uint block_length,int return_buffer);
extern int key_cache_write(File file,my_off_t filepos,byte* buff,uint length,
			   uint block_length,int force_write);
extern int flush_key_blocks(int file, enum flush_type type);
extern void end_key_cache(void);
extern sig_handler my_set_alarm_variable(int signo);
extern void my_string_ptr_sort(void *base,uint items,size_s size);
extern void radixsort_for_str_ptr(uchar* base[], uint number_of_elements,
				  size_s size_of_element,uchar *buffer[]);
extern qsort_t qsort2(void *base_ptr, size_t total_elems, size_t size,
		      qsort2_cmp cmp, void *cmp_argument);
extern qsort2_cmp get_ptr_compare(uint);
extern int init_io_cache(IO_CACHE *info,File file,uint cachesize,
			 enum cache_type type,my_off_t seek_offset,
			 pbool use_async_io, myf cache_myflags);
extern my_bool reinit_io_cache(IO_CACHE *info,enum cache_type type,
			       my_off_t seek_offset,pbool use_async_io,
			       pbool clear_cache);
extern int _my_b_read(IO_CACHE *info,byte *Buffer,uint Count);
unknown's avatar
unknown committed
651
extern int _my_b_seq_read(IO_CACHE *info,byte *Buffer,uint Count);
unknown's avatar
unknown committed
652 653 654 655
extern int _my_b_net_read(IO_CACHE *info,byte *Buffer,uint Count);
extern int _my_b_get(IO_CACHE *info);
extern int _my_b_async_read(IO_CACHE *info,byte *Buffer,uint Count);
extern int _my_b_write(IO_CACHE *info,const byte *Buffer,uint Count);
unknown's avatar
unknown committed
656
extern int my_b_append(IO_CACHE *info,const byte *Buffer,uint Count);
unknown's avatar
unknown committed
657 658
extern int my_block_write(IO_CACHE *info, const byte *Buffer,
			  uint Count, my_off_t pos);
659 660 661 662
extern int _flush_io_cache(IO_CACHE *info, int need_append_buffer_lock);

#define flush_io_cache(info) _flush_io_cache((info),1)

unknown's avatar
unknown committed
663
extern int end_io_cache(IO_CACHE *info);
664 665 666 667
extern uint my_b_fill(IO_CACHE *info);
extern void my_b_seek(IO_CACHE *info,my_off_t pos);
extern uint my_b_gets(IO_CACHE *info, char *to, uint max_length);
extern uint my_b_printf(IO_CACHE *info, const char* fmt, ...);
668
extern uint my_b_vprintf(IO_CACHE *info, const char* fmt, va_list ap);
unknown's avatar
unknown committed
669 670 671 672 673
extern my_bool open_cached_file(IO_CACHE *cache,const char *dir,
				 const char *prefix, uint cache_size,
				 myf cache_myflags);
extern my_bool real_open_cached_file(IO_CACHE *cache);
extern void close_cached_file(IO_CACHE *cache);
674 675
File create_temp_file(char *to, const char *dir, const char *pfx,
		      int mode, myf MyFlags);
676 677 678 679
#define init_dynamic_array(A,B,C,D) _init_dynamic_array(A,B,C,D CALLER_INFO)
#define init_dynamic_array_ci(A,B,C,D) _init_dynamic_array(A,B,C,D ORIG_CALLER_INFO)
extern my_bool _init_dynamic_array(DYNAMIC_ARRAY *array,uint element_size,
	  uint init_alloc,uint alloc_increment CALLER_INFO_PROTO);
unknown's avatar
unknown committed
680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697
extern my_bool insert_dynamic(DYNAMIC_ARRAY *array,gptr element);
extern byte *alloc_dynamic(DYNAMIC_ARRAY *array);
extern byte *pop_dynamic(DYNAMIC_ARRAY*);
extern my_bool set_dynamic(DYNAMIC_ARRAY *array,gptr element,uint array_index);
extern void get_dynamic(DYNAMIC_ARRAY *array,gptr element,uint array_index);
extern void delete_dynamic(DYNAMIC_ARRAY *array);
extern void delete_dynamic_element(DYNAMIC_ARRAY *array, uint array_index);
extern void freeze_size(DYNAMIC_ARRAY *array);
#define dynamic_array_ptr(array,array_index) ((array)->buffer+(array_index)*(array)->size_of_element)
#define dynamic_element(array,array_index,type) ((type)((array)->buffer) +(array_index))
#define push_dynamic(A,B) insert_dynamic(A,B)

extern int find_type(my_string x,TYPELIB *typelib,uint full_name);
extern void make_type(my_string to,uint nr,TYPELIB *typelib);
extern const char *get_type(TYPELIB *typelib,uint nr);
extern my_bool init_dynamic_string(DYNAMIC_STRING *str, const char *init_str,
				   uint init_alloc,uint alloc_increment);
extern my_bool dynstr_append(DYNAMIC_STRING *str, const char *append);
698 699
my_bool dynstr_append_mem(DYNAMIC_STRING *str, const char *append,
			  uint length);
unknown's avatar
unknown committed
700 701 702 703 704 705 706 707 708 709 710 711 712 713
extern my_bool dynstr_set(DYNAMIC_STRING *str, const char *init_str);
extern my_bool dynstr_realloc(DYNAMIC_STRING *str, ulong additional_size);
extern void dynstr_free(DYNAMIC_STRING *str);
void set_all_changeable_vars(CHANGEABLE_VAR *vars);
my_bool set_changeable_var(my_string str,CHANGEABLE_VAR *vars);
my_bool set_changeable_varval(const char *var, ulong val,
			      CHANGEABLE_VAR *vars);
#ifdef HAVE_MLOCK
extern byte *my_malloc_lock(uint length,myf flags);
extern void my_free_lock(byte *ptr,myf flags);
#else
#define my_malloc_lock(A,B) my_malloc((A),(B))
#define my_free_lock(A,B) my_free((A),(B))
#endif
unknown's avatar
unknown committed
714
#define alloc_root_inited(A) ((A)->min_malloc != 0)
715
void init_alloc_root(MEM_ROOT *mem_root, uint block_size, uint pre_alloc_size);
unknown's avatar
unknown committed
716
gptr alloc_root(MEM_ROOT *mem_root,unsigned int Size);
717
void free_root(MEM_ROOT *root, myf MyFLAGS);
unknown's avatar
unknown committed
718
void set_prealloc_root(MEM_ROOT *root, char *ptr);
unknown's avatar
unknown committed
719
char *strdup_root(MEM_ROOT *root,const char *str);
720
char *strmake_root(MEM_ROOT *root,const char *str,uint len);
unknown's avatar
unknown committed
721 722 723 724 725 726 727 728 729
char *memdup_root(MEM_ROOT *root,const char *str,uint len);
void load_defaults(const char *conf_file, const char **groups,
		   int *argc, char ***argv);
void free_defaults(char **argv);
void print_defaults(const char *conf_file, const char **groups);
my_bool my_compress(byte *, ulong *, ulong *);
my_bool my_uncompress(byte *, ulong *, ulong *);
byte *my_compress_alloc(const byte *packet, ulong *len, ulong *complen);
ulong checksum(const byte *mem, uint count);
unknown's avatar
unknown committed
730
uint my_bit_log2(ulong value);
unknown's avatar
unknown committed
731

unknown's avatar
unknown committed
732 733 734 735 736 737
#if defined(SAFE_MUTEX) && !defined(DBUG_OFF)
#define DBUG_ASSERT_LOCK(lock) DBUG_ASSERT((lock)->count == 1 && \
				   (lock)->thread == pthread_self())
#else
#define DBUG_ASSERT_LOCK(lock)
#endif
738

unknown's avatar
unknown committed
739 740 741 742 743 744 745
#if defined(_MSC_VER) && !defined(__WIN__)
extern void sleep(int sec);
#endif
#ifdef __WIN__
extern my_bool have_tcpip;		/* Is set if tcpip is used */
#endif

unknown's avatar
unknown committed
746
C_MODE_END
unknown's avatar
unknown committed
747 748
#include "raid.h"
#endif /* _my_sys_h */