← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to include/my_sys.h

  • Committer: Stewart Smith
  • Date: 2008-06-30 06:46:40 UTC
  • mto: This revision was merged to the branch mainline in revision 19.
  • Revision ID: stewart@flamingspork.com-20080630064640-1tbyi1e8j4duba45
no embedded server, stop testing for it in tests.

Show diffs side-by-side

added added

removed removed

Lines of Context:
include/my_sys.h
15
15
 
16
16
#ifndef _my_sys_h
17
17
#define _my_sys_h
 
18
C_MODE_START
18
19
 
19
20
#ifdef HAVE_AIOWAIT
20
21
#include <sys/asynch.h>                 /* Used by record-cache */
27
28
#include <errno.h>
28
29
#define my_errno (errno)
29
30
 
30
 
#include <mysys/my_pthread.h>
 
31
#ifdef THREAD
 
32
#include <my_pthread.h>
 
33
#endif
31
34
 
32
 
#include <mystrings/m_ctype.h>                    /* for CHARSET_INFO */
 
35
#include <m_ctype.h>                    /* for CHARSET_INFO */
33
36
#include <stdarg.h>
34
 
#include <mysys/typelib.h>
 
37
#include <typelib.h>
35
38
 
 
39
#define MYSYS_PROGRAM_DONT_USE_CURSES()  { error_handler_hook = my_message_no_curses; mysys_uses_curses=0;}
36
40
#define MY_INIT(name);          { my_progname= name; my_init(); }
37
41
 
38
42
#define ERRMSGSIZE      (SC_MAXWIDTH)   /* Max length of a error message */
68
72
 
69
73
#define MY_CHECK_ERROR  1       /* Params to my_end; Check open-close */
70
74
#define MY_GIVE_INFO    2       /* Give time info about process*/
 
75
#define MY_DONT_FREE_DBUG 4     /* Do not call DBUG_END() in my_end() */
71
76
 
72
77
#define MY_REMOVE_NONE    0     /* Params for modify_defaults_file */
73
78
#define MY_REMOVE_OPTION  1
107
112
        /* Some constants */
108
113
#define MY_WAIT_FOR_USER_TO_FIX_PANIC   60      /* in seconds */
109
114
#define MY_WAIT_GIVE_USER_A_MESSAGE     10      /* Every 10 times of prev */
 
115
#define MIN_COMPRESS_LENGTH             50      /* Don't compress small bl. */
110
116
#define DFLT_INIT_HITS  3
111
117
 
112
118
        /* root_alloc flags */
125
131
#define GETDATE_FIXEDLENGTH     16
126
132
 
127
133
        /* defines when allocating data */
 
134
#ifdef SAFEMALLOC
 
135
#else
128
136
#define my_checkmalloc()
129
137
#undef TERMINATE
130
138
#define TERMINATE(A,B) {}
131
 
 
132
 
#ifdef __cplusplus
133
 
extern "C" {
134
 
#endif
135
 
 
136
 
typedef int  (*qsort_cmp)(const void *,const void *);
137
 
typedef int  (*qsort_cmp2)(void*, const void *,const void *);
138
 
 
 
139
#define QUICK_SAFEMALLOC
 
140
#define NORMAL_SAFEMALLOC
139
141
extern void *my_malloc(size_t Size,myf MyFlags);
140
142
#define my_malloc_ci(SZ,FLAG) my_malloc( SZ, FLAG )
141
143
extern void *my_realloc(void *oldpoint, size_t Size, myf MyFlags);
144
146
extern char *my_strdup(const char *from,myf MyFlags);
145
147
extern char *my_strndup(const char *from, size_t length,
146
148
                                   myf MyFlags);
 
149
/* we do use FG (as a no-op) in below so that a typo on FG is caught */
 
150
#define my_free(PTR,FG) ((void)FG,my_no_flags_free(PTR))
147
151
#define CALLER_INFO_PROTO   /* nothing */
148
152
#define CALLER_INFO         /* nothing */
149
153
#define ORIG_CALLER_INFO    /* nothing */
150
154
#define TRASH(A,B) /* nothing */
 
155
#endif
 
156
 
 
157
#ifdef HAVE_LARGE_PAGES
 
158
extern uint my_get_large_page_size(void);
 
159
extern uchar * my_large_malloc(size_t size, myf my_flags);
 
160
extern void my_large_free(uchar * ptr, myf my_flags);
 
161
#else
 
162
#define my_get_large_page_size() (0)
 
163
#define my_large_malloc(A,B) my_malloc_lock((A),(B))
 
164
#define my_large_free(A,B) my_free_lock((A),(B))
 
165
#endif /* HAVE_LARGE_PAGES */
151
166
 
152
167
#ifdef HAVE_ALLOCA
153
168
#if defined(__GNUC__) && !defined(HAVE_ALLOCA_H) && ! defined(alloca)
154
169
#define alloca __builtin_alloca
155
170
#endif /* GNUC */
156
 
#define my_alloca(SZ) malloc((size_t) (SZ))
157
 
#define my_afree(PTR) free((PTR))
 
171
#define my_alloca(SZ) alloca((size_t) (SZ))
 
172
#define my_afree(PTR) {}
158
173
#else
159
 
#define my_alloca(SZ) malloc((SZ))
160
 
#define my_afree(PTR) free((PTR))
 
174
#define my_alloca(SZ) my_malloc(SZ,MYF(0))
 
175
#define my_afree(PTR) my_free(PTR,MYF(MY_WME))
161
176
#endif /* HAVE_ALLOCA */
162
177
 
163
178
#ifndef errno                           /* did we already get it? */
170
185
extern char errbuff[NRERRBUFFS][ERRMSGSIZE];
171
186
extern char *home_dir;                  /* Home directory for user */
172
187
extern const char *my_progname;         /* program-name (printed in errors) */
173
 
extern void (*error_handler_hook)(uint32_t my_err, const char *str,myf MyFlags);
174
 
extern void (*fatal_error_handler_hook)(uint32_t my_err, const char *str,
 
188
extern char curr_dir[];         /* Current directory for user */
 
189
extern void (*error_handler_hook)(uint my_err, const char *str,myf MyFlags);
 
190
extern void (*fatal_error_handler_hook)(uint my_err, const char *str,
175
191
                                        myf MyFlags);
176
 
extern uint32_t my_file_limit;
177
 
extern uint32_t my_thread_stack_size;
 
192
extern uint my_file_limit;
 
193
extern ulong my_thread_stack_size;
 
194
 
 
195
#ifdef HAVE_LARGE_PAGES
 
196
extern my_bool my_use_large_pages;
 
197
extern uint    my_large_page_size;
 
198
#endif
178
199
 
179
200
/* charsets */
180
 
extern const CHARSET_INFO *default_charset_info;
 
201
extern CHARSET_INFO *default_charset_info;
181
202
extern CHARSET_INFO *all_charsets[256];
182
203
extern CHARSET_INFO compiled_charsets[];
183
204
 
184
205
/* statistics */
185
 
extern uint32_t my_file_opened,my_stream_opened, my_tmp_file_created;
186
 
extern uint32_t    my_file_total_opened;
 
206
extern ulong    my_file_opened,my_stream_opened, my_tmp_file_created;
 
207
extern ulong    my_file_total_opened;
187
208
extern uint     mysys_usage_id;
188
 
extern bool     my_init_done;
 
209
extern my_bool  my_init_done;
189
210
 
190
211
                                        /* Point to current my_message() */
191
212
extern void (*my_sigtstp_cleanup)(void),
198
219
           my_recived_signals,  /* Signals we have got */
199
220
           my_safe_to_handle_signal, /* Set when allowed to SIGTSTP */
200
221
           my_dont_interrupt;   /* call remember_intr when set */
201
 
extern bool mysys_uses_curses, my_use_symdir;
202
 
extern uint32_t sf_malloc_cur_memory, sf_malloc_max_memory;
 
222
extern my_bool mysys_uses_curses, my_use_symdir;
 
223
extern ulong sf_malloc_cur_memory, sf_malloc_max_memory;
203
224
 
204
 
extern uint32_t my_default_record_cache_size;
205
 
extern bool my_disable_async_io,
 
225
extern ulong    my_default_record_cache_size;
 
226
extern my_bool my_disable_locking, my_disable_async_io,
206
227
               my_disable_flush_key_blocks, my_disable_symlinks;
207
228
extern char     wild_many, wild_one, wild_prefix;
208
229
extern const char *charsets_dir;
211
232
extern const char *my_defaults_group_suffix;
212
233
extern const char *my_defaults_file;
213
234
 
214
 
extern bool timed_mutexes;
 
235
extern my_bool timed_mutexes;
215
236
 
216
237
typedef struct wild_file_pack   /* Struct to hold info when selecting files */
217
238
{
232
253
  SEQ_READ_APPEND               /* sequential read or append */,
233
254
  READ_FIFO, READ_NET,WRITE_NET};
234
255
 
 
256
enum flush_type
 
257
{
 
258
  FLUSH_KEEP,           /* flush block and keep it in the cache */
 
259
  FLUSH_RELEASE,        /* flush block and remove it from the cache */
 
260
  FLUSH_IGNORE_CHANGED, /* remove block from the cache */
 
261
  /*
 
262
    As my_disable_flush_pagecache_blocks is always 0, the following option
 
263
    is strictly equivalent to FLUSH_KEEP
 
264
  */
 
265
  FLUSH_FORCE_WRITE
 
266
};
 
267
 
235
268
typedef struct st_record_cache  /* Used when cacheing records */
236
269
{
237
270
  File file;
238
271
  int   rc_seek,error,inited;
239
272
  uint  rc_length,read_length,reclength;
240
273
  my_off_t rc_record_pos,end_of_file;
241
 
  unsigned char *rc_buff,*rc_buff2,*rc_pos,*rc_end,*rc_request_pos;
 
274
  uchar *rc_buff,*rc_buff2,*rc_pos,*rc_end,*rc_request_pos;
242
275
#ifdef HAVE_AIOWAIT
243
276
  int   use_async_io;
244
277
  my_aio_result aio_result;
256
289
{
257
290
  char *                name;
258
291
  enum file_type        type;
259
 
#if !defined(HAVE_PREAD)
 
292
#if defined(THREAD) && !defined(HAVE_PREAD)
260
293
  pthread_mutex_t       mutex;
261
294
#endif
262
295
};
265
298
 
266
299
typedef struct st_dynamic_array
267
300
{
268
 
  unsigned char *buffer;
269
 
  uint32_t elements,max_element;
270
 
  uint32_t alloc_increment;
271
 
  uint32_t size_of_element;
 
301
  uchar *buffer;
 
302
  uint elements,max_element;
 
303
  uint alloc_increment;
 
304
  uint size_of_element;
272
305
} DYNAMIC_ARRAY;
273
306
 
274
307
typedef struct st_my_tmpdir
275
308
{
276
309
  DYNAMIC_ARRAY full_list;
277
310
  char **list;
278
 
  uint32_t cur, max;
 
311
  uint cur, max;
 
312
#ifdef THREAD
279
313
  pthread_mutex_t mutex;
 
314
#endif
280
315
} MY_TMPDIR;
281
316
 
 
317
typedef struct st_dynamic_string
 
318
{
 
319
  char *str;
 
320
  size_t length,max_length,alloc_increment;
 
321
} DYNAMIC_STRING;
 
322
 
282
323
struct st_io_cache;
283
324
typedef int (*IO_CACHE_CALLBACK)(struct st_io_cache*);
284
325
 
 
326
#ifdef THREAD
285
327
typedef struct st_io_cache_share
286
328
{
287
329
  pthread_mutex_t       mutex;           /* To sync on reads into buffer. */
291
333
  my_off_t              pos_in_file;
292
334
  /* If a synchronized write cache is the source of the data. */
293
335
  struct st_io_cache    *source_cache;
294
 
  unsigned char                 *buffer;         /* The read buffer. */
295
 
  unsigned char                 *read_end;       /* Behind last valid byte of buffer. */
 
336
  uchar                 *buffer;         /* The read buffer. */
 
337
  uchar                 *read_end;       /* Behind last valid byte of buffer. */
296
338
  int                   running_threads; /* threads not in lock. */
297
339
  int                   total_threads;   /* threads sharing the cache. */
298
340
  int                   error;           /* Last error. */
299
341
#ifdef NOT_YET_IMPLEMENTED
300
342
  /* whether the structure should be free'd */
301
 
  bool alloced;
 
343
  my_bool alloced;
302
344
#endif
303
345
} IO_CACHE_SHARE;
 
346
#endif
304
347
 
305
348
typedef struct st_io_cache              /* Used when cacheing files */
306
349
{
307
 
  /* Offset in file corresponding to the first byte of unsigned char* buffer. */
 
350
  /* Offset in file corresponding to the first byte of uchar* buffer. */
308
351
  my_off_t pos_in_file;
309
352
  /*
310
353
    The offset of end of file for READ_CACHE and WRITE_CACHE.
313
356
  */
314
357
  my_off_t end_of_file;
315
358
  /* Points to current read position in the buffer */
316
 
  unsigned char *read_pos;
 
359
  uchar *read_pos;
317
360
  /* the non-inclusive boundary in the buffer for the currently valid read */
318
 
  unsigned char  *read_end;
319
 
  unsigned char  *buffer;                               /* The read buffer */
 
361
  uchar  *read_end;
 
362
  uchar  *buffer;                               /* The read buffer */
320
363
  /* Used in ASYNC_IO */
321
 
  unsigned char  *request_pos;
 
364
  uchar  *request_pos;
322
365
 
323
366
  /* Only used in WRITE caches and in SEQ_READ_APPEND to buffer writes */
324
 
  unsigned char  *write_buffer;
 
367
  uchar  *write_buffer;
325
368
  /*
326
369
    Only used in SEQ_READ_APPEND, and points to the current read position
327
370
    in the write buffer. Note that reads in SEQ_READ_APPEND caches can
328
 
    happen from both read buffer (unsigned char* buffer) and write buffer
329
 
    (unsigned char* write_buffer).
 
371
    happen from both read buffer (uchar* buffer) and write buffer
 
372
    (uchar* write_buffer).
330
373
  */
331
 
  unsigned char *append_read_pos;
 
374
  uchar *append_read_pos;
332
375
  /* Points to current write position in the write buffer */
333
 
  unsigned char *write_pos;
 
376
  uchar *write_pos;
334
377
  /* The non-inclusive boundary of the valid write area */
335
 
  unsigned char *write_end;
 
378
  uchar *write_end;
336
379
 
337
380
  /*
338
381
    Current_pos and current_end are convenience variables used by
340
383
    current_pos points to &write_pos, and current_end to &write_end in a
341
384
    WRITE_CACHE, and &read_pos and &read_end respectively otherwise
342
385
  */
343
 
  unsigned char  **current_pos, **current_end;
 
386
  uchar  **current_pos, **current_end;
 
387
#ifdef THREAD
344
388
  /*
345
389
    The lock is for append buffer used in SEQ_READ_APPEND cache
346
390
    need mutex copying from append buffer to read buffer.
354
398
    READ_CACHE mode is supported.
355
399
  */
356
400
  IO_CACHE_SHARE *share;
 
401
#endif
357
402
  /*
358
403
    A caller will use my_b_read() macro to read from the cache
359
404
    if the data is already in cache, it will be simply copied with
362
407
    my_b_read() will call read_function to fetch the data. read_function
363
408
    must never be invoked directly.
364
409
  */
365
 
  int (*read_function)(struct st_io_cache *,unsigned char *,size_t);
 
410
  int (*read_function)(struct st_io_cache *,uchar *,size_t);
366
411
  /*
367
412
    Same idea as in the case of read_function, except my_b_write() needs to
368
413
    be replaced with my_b_append() for a SEQ_READ_APPEND cache
369
414
  */
370
 
  int (*write_function)(struct st_io_cache *,const unsigned char *,size_t);
 
415
  int (*write_function)(struct st_io_cache *,const uchar *,size_t);
371
416
  /*
372
417
    Specifies the type of the cache. Depending on the type of the cache
373
418
    certain operations might not be available and yield unpredicatable
388
433
    Counts the number of times, when we were forced to use disk. We use it to
389
434
    increase the binlog_cache_disk_use status variable.
390
435
  */
391
 
  uint32_t disk_writes;
 
436
  ulong disk_writes;
392
437
  void* arg;                            /* for use by pre/post_read */
393
438
  char *file_name;                      /* if used with 'open_cached_file' */
394
439
  char *dir,*prefix;
412
457
    Currently READ_NET is the only one that will use a buffer allocated
413
458
    somewhere else
414
459
  */
415
 
  bool alloced_buffer;
 
460
  my_bool alloced_buffer;
416
461
#ifdef HAVE_AIOWAIT
417
462
  /*
418
463
    As inidicated by ifdef, this is for async I/O, which is not currently
419
464
    used (because it's not reliable on all systems)
420
465
  */
421
 
  uint32_t inited;
 
466
  uint inited;
422
467
  my_off_t aio_read_pos;
423
468
  my_aio_result aio_result;
424
469
#endif
447
492
 
448
493
#define my_b_get(info) \
449
494
  ((info)->read_pos != (info)->read_end ?\
450
 
   ((info)->read_pos++, (int) (unsigned char) (info)->read_pos[-1]) :\
 
495
   ((info)->read_pos++, (int) (uchar) (info)->read_pos[-1]) :\
451
496
   _my_b_get(info))
452
497
 
453
498
        /* my_b_write_byte dosn't have any err-check */
475
520
#define my_b_bytes_in_cache(info) (size_t) (*(info)->current_end - \
476
521
                                          *(info)->current_pos)
477
522
 
478
 
typedef uint32_t ha_checksum;
 
523
typedef uint32 ha_checksum;
479
524
 
480
525
/* Define the type of function to be passed to process_default_option_files */
481
526
typedef int (*Process_option_func)(void *ctx, const char *group_name,
482
527
                                   const char *option);
483
528
 
484
 
#include <mysys/my_alloc.h>
 
529
#include <my_alloc.h>
485
530
 
486
531
 
487
532
        /* Prototypes for mysys and my_func functions */
488
533
 
489
534
extern int my_copy(const char *from,const char *to,myf MyFlags);
 
535
extern int my_append(const char *from,const char *to,myf MyFlags);
490
536
extern int my_delete(const char *name,myf MyFlags);
491
537
extern int my_getwd(char * buf,size_t size,myf MyFlags);
492
538
extern int my_setwd(const char *dir,myf MyFlags);
 
539
extern int my_lock(File fd,int op,my_off_t start, my_off_t length,myf MyFlags);
493
540
extern void *my_once_alloc(size_t Size,myf MyFlags);
494
541
extern void my_once_free(void);
495
542
extern char *my_once_strdup(const char *src,myf myflags);
497
544
extern File my_open(const char *FileName,int Flags,myf MyFlags);
498
545
extern File my_register_filename(File fd, const char *FileName,
499
546
                                 enum file_type type_of_file,
500
 
                                 uint32_t error_message_number, myf MyFlags);
 
547
                                 uint error_message_number, myf MyFlags);
501
548
extern File my_create(const char *FileName,int CreateFlags,
502
549
                      int AccessFlags, myf MyFlags);
503
550
extern int my_close(File Filedes,myf MyFlags);
511
558
extern int my_delete_with_symlink(const char *name, myf MyFlags);
512
559
extern int my_rename_with_symlink(const char *from,const char *to,myf MyFlags);
513
560
extern int my_symlink(const char *content, const char *linkname, myf MyFlags);
514
 
extern size_t my_read(File Filedes,unsigned char *Buffer,size_t Count,myf MyFlags);
 
561
extern size_t my_read(File Filedes,uchar *Buffer,size_t Count,myf MyFlags);
 
562
extern size_t my_pread(File Filedes,uchar *Buffer,size_t Count,my_off_t offset,
 
563
                     myf MyFlags);
515
564
extern int my_rename(const char *from,const char *to,myf MyFlags);
516
565
extern my_off_t my_seek(File fd,my_off_t pos,int whence,myf MyFlags);
517
566
extern my_off_t my_tell(File fd,myf MyFlags);
518
 
extern size_t my_write(File Filedes,const unsigned char *Buffer,size_t Count,
 
567
extern size_t my_write(File Filedes,const uchar *Buffer,size_t Count,
519
568
                     myf MyFlags);
520
 
extern size_t my_fwrite(FILE *stream,const unsigned char *Buffer,size_t Count,
 
569
extern size_t my_pwrite(File Filedes,const uchar *Buffer,size_t Count,
 
570
                      my_off_t offset,myf MyFlags);
 
571
extern size_t my_fread(FILE *stream,uchar *Buffer,size_t Count,myf MyFlags);
 
572
extern size_t my_fwrite(FILE *stream,const uchar *Buffer,size_t Count,
521
573
                      myf MyFlags);
522
574
extern my_off_t my_fseek(FILE *stream,my_off_t pos,int whence,myf MyFlags);
 
575
extern my_off_t my_ftell(FILE *stream,myf MyFlags);
523
576
extern void *_mymalloc(size_t uSize,const char *sFile,
524
 
                       uint32_t uLine, myf MyFlag);
 
577
                       uint uLine, myf MyFlag);
525
578
extern void *_myrealloc(void *pPtr,size_t uSize,const char *sFile,
526
 
                       uint32_t uLine, myf MyFlag);
527
 
extern void * my_multi_malloc (myf MyFlags, ...);
528
 
extern void _myfree(void *pPtr, const char *sFile, uint32_t uLine, myf MyFlag);
529
 
extern int _sanity(const char *sFile, uint32_t uLine);
 
579
                       uint uLine, myf MyFlag);
 
580
extern void * my_multi_malloc _VARARGS((myf MyFlags, ...));
 
581
extern void _myfree(void *pPtr,const char *sFile,uint uLine, myf MyFlag);
 
582
extern int _sanity(const char *sFile, uint uLine);
530
583
extern void *_my_memdup(const void *from, size_t length,
531
 
                        const char *sFile, uint32_t uLine,myf MyFlag);
532
 
extern char * _my_strdup(const char *from, const char *sFile, uint32_t uLine,
 
584
                        const char *sFile, uint uLine,myf MyFlag);
 
585
extern char * _my_strdup(const char *from, const char *sFile, uint uLine,
533
586
                         myf MyFlag);
534
587
extern char *_my_strndup(const char *from, size_t length,
535
 
                         const char *sFile, uint32_t uLine,
 
588
                         const char *sFile, uint uLine,
536
589
                         myf MyFlag);
537
590
 
 
591
/* implemented in my_memmem.c */
 
592
extern void *my_memmem(const void *haystack, size_t haystacklen,
 
593
                       const void *needle, size_t needlelen);
 
594
 
 
595
 
538
596
#define my_access access
539
597
extern int check_if_legal_filename(const char *path);
540
598
extern int check_if_legal_tablename(const char *path);
542
600
#define my_delete_allow_opened(fname,flags)  my_delete((fname),(flags))
543
601
 
544
602
#ifndef TERMINATE
545
 
extern void TERMINATE(FILE *file, uint32_t flag);
 
603
extern void TERMINATE(FILE *file, uint flag);
546
604
#endif
547
605
extern void init_glob_errs(void);
548
606
extern FILE *my_fopen(const char *FileName,int Flags,myf MyFlags);
 
607
extern FILE *my_fdopen(File Filedes,const char *name, int Flags,myf MyFlags);
549
608
extern int my_fclose(FILE *fd,myf MyFlags);
 
609
extern int my_chsize(File fd,my_off_t newlength, int filler, myf MyFlags);
550
610
extern int my_sync(File fd, myf my_flags);
551
611
extern int my_sync_dir(const char *dir_name, myf my_flags);
552
612
extern int my_sync_dir_by_file(const char *file_name, myf my_flags);
553
 
extern void my_error(int nr,myf MyFlags, ...);
554
 
extern void my_printf_error(uint32_t my_err, const char *format,
555
 
                            myf MyFlags, ...)
556
 
  __attribute__((format(printf, 2, 4)));
 
613
extern void my_error _VARARGS((int nr,myf MyFlags, ...));
 
614
extern void my_printf_error _VARARGS((uint my_err, const char *format,
 
615
                                      myf MyFlags, ...))
 
616
                                      ATTRIBUTE_FORMAT(printf, 2, 4);
557
617
extern int my_error_register(const char **errmsgs, int first, int last);
558
618
extern const char **my_error_unregister(int first, int last);
559
 
extern void my_message(uint32_t my_err, const char *str,myf MyFlags);
560
 
extern void my_message_no_curses(uint32_t my_err, const char *str,myf MyFlags);
561
 
extern bool my_init(void);
 
619
extern void my_message(uint my_err, const char *str,myf MyFlags);
 
620
extern void my_message_no_curses(uint my_err, const char *str,myf MyFlags);
 
621
extern my_bool my_init(void);
562
622
extern void my_end(int infoflag);
563
623
extern int my_redel(const char *from, const char *to, int MyFlags);
564
624
extern int my_copystat(const char *from, const char *to, int MyFlags);
565
625
extern char * my_filename(File fd);
566
626
 
 
627
#ifndef THREAD
 
628
extern void dont_break(void);
 
629
extern void allow_break(void);
 
630
#else
 
631
#define dont_break()
 
632
#define allow_break()
 
633
#endif
 
634
 
567
635
#ifdef EXTRA_DEBUG
568
636
void my_print_open_files(void);
569
637
#else
570
638
#define my_print_open_files()
571
639
#endif
572
640
 
573
 
extern bool init_tmpdir(MY_TMPDIR *tmpdir, const char *pathlist);
 
641
extern my_bool init_tmpdir(MY_TMPDIR *tmpdir, const char *pathlist);
574
642
extern char *my_tmpdir(MY_TMPDIR *tmpdir);
575
643
extern void free_tmpdir(MY_TMPDIR *tmpdir);
576
644
 
577
 
extern void my_remember_signal(int signal_number,RETSIGTYPE (*func)(int));
 
645
extern void my_remember_signal(int signal_number,sig_handler (*func)(int));
578
646
extern size_t dirname_part(char * to,const char *name, size_t *to_res_length);
579
647
extern size_t dirname_length(const char *name);
580
648
#define base_name(A) (A+dirname_length(A))
581
649
extern int test_if_hard_path(const char *dir_name);
582
 
extern bool has_path(const char *name);
 
650
extern my_bool has_path(const char *name);
583
651
extern char *convert_dirname(char *to, const char *from, const char *from_end);
584
652
extern void to_unix_path(char * name);
585
653
extern char * fn_ext(const char *name);
586
654
extern char * fn_same(char * toname,const char *name,int flag);
587
655
extern char * fn_format(char * to,const char *name,const char *dir,
588
 
                           const char *form, uint32_t flag);
 
656
                           const char *form, uint flag);
589
657
extern size_t strlength(const char *str);
590
658
extern void pack_dirname(char * to,const char *from);
591
659
extern size_t unpack_dirname(char * to,const char *from);
600
668
extern char * my_load_path(char * to, const char *path,
601
669
                              const char *own_path_prefix);
602
670
extern int wild_compare(const char *str,const char *wildstr,
603
 
                        bool str_is_pattern);
 
671
                        pbool str_is_pattern);
604
672
extern WF_PACK *wf_comp(char * str);
605
673
extern int wf_test(struct wild_file_pack *wf_pack,const char *name);
606
674
extern void wf_end(struct wild_file_pack *buffer);
607
 
extern bool array_append_string_unique(const char *str,
 
675
extern size_t strip_sp(char * str);
 
676
extern my_bool array_append_string_unique(const char *str,
608
677
                                          const char **array, size_t size);
609
678
extern void get_date(char * to,int timeflag,time_t use_time);
610
679
extern void soundex(CHARSET_INFO *, char * out_pntr, char * in_pntr,
611
 
                    bool remove_garbage);
 
680
                    pbool remove_garbage);
612
681
extern int init_record_cache(RECORD_CACHE *info,size_t cachesize,File file,
613
682
                             size_t reclength,enum cache_type type,
614
 
                             bool use_async_io);
615
 
extern int read_cache_record(RECORD_CACHE *info,unsigned char *to);
 
683
                             pbool use_async_io);
 
684
extern int read_cache_record(RECORD_CACHE *info,uchar *to);
616
685
extern int end_record_cache(RECORD_CACHE *info);
617
686
extern int write_cache_record(RECORD_CACHE *info,my_off_t filepos,
618
 
                              const unsigned char *record,size_t length);
 
687
                              const uchar *record,size_t length);
619
688
extern int flush_write_cache(RECORD_CACHE *info);
620
 
extern RETSIGTYPE sigtstp_handler(int signal_number);
 
689
extern long my_clock(void);
 
690
extern sig_handler sigtstp_handler(int signal_number);
621
691
extern void handle_recived_signals(void);
622
692
 
623
 
extern RETSIGTYPE my_set_alarm_variable(int signo);
624
 
extern void my_string_ptr_sort(unsigned char *base,uint32_t items,size_t size);
625
 
extern void radixsort_for_str_ptr(unsigned char* base[], uint32_t number_of_elements,
626
 
                                  size_t size_of_element,unsigned char *buffer[]);
627
 
extern RETQSORTTYPE my_qsort(void *base_ptr, size_t total_elems, size_t size,
628
 
                             qsort_cmp cmp);
629
 
extern RETQSORTTYPE my_qsort2(void *base_ptr, size_t total_elems, size_t size,
630
 
                              qsort2_cmp cmp, void *cmp_argument);
 
693
extern sig_handler my_set_alarm_variable(int signo);
 
694
extern void my_string_ptr_sort(uchar *base,uint items,size_t size);
 
695
extern void radixsort_for_str_ptr(uchar* base[], uint number_of_elements,
 
696
                                  size_t size_of_element,uchar *buffer[]);
 
697
extern qsort_t my_qsort(void *base_ptr, size_t total_elems, size_t size,
 
698
                        qsort_cmp cmp);
 
699
extern qsort_t my_qsort2(void *base_ptr, size_t total_elems, size_t size,
 
700
                         qsort2_cmp cmp, void *cmp_argument);
631
701
extern qsort2_cmp get_ptr_compare(size_t);
632
 
void my_store_ptr(unsigned char *buff, size_t pack_length, my_off_t pos);
633
 
my_off_t my_get_ptr(unsigned char *ptr, size_t pack_length);
 
702
void my_store_ptr(uchar *buff, size_t pack_length, my_off_t pos);
 
703
my_off_t my_get_ptr(uchar *ptr, size_t pack_length);
634
704
extern int init_io_cache(IO_CACHE *info,File file,size_t cachesize,
635
705
                         enum cache_type type,my_off_t seek_offset,
636
 
                         bool use_async_io, myf cache_myflags);
637
 
extern bool reinit_io_cache(IO_CACHE *info,enum cache_type type,
638
 
                               my_off_t seek_offset,bool use_async_io,
639
 
                               bool clear_cache);
 
706
                         pbool use_async_io, myf cache_myflags);
 
707
extern my_bool reinit_io_cache(IO_CACHE *info,enum cache_type type,
 
708
                               my_off_t seek_offset,pbool use_async_io,
 
709
                               pbool clear_cache);
640
710
extern void setup_io_cache(IO_CACHE* info);
641
 
extern int _my_b_read(IO_CACHE *info,unsigned char *Buffer,size_t Count);
642
 
extern int _my_b_read_r(IO_CACHE *info,unsigned char *Buffer,size_t Count);
 
711
extern int _my_b_read(IO_CACHE *info,uchar *Buffer,size_t Count);
 
712
#ifdef THREAD
 
713
extern int _my_b_read_r(IO_CACHE *info,uchar *Buffer,size_t Count);
643
714
extern void init_io_cache_share(IO_CACHE *read_cache, IO_CACHE_SHARE *cshare,
644
 
                                IO_CACHE *write_cache, uint32_t num_threads);
 
715
                                IO_CACHE *write_cache, uint num_threads);
645
716
extern void remove_io_thread(IO_CACHE *info);
646
 
extern int _my_b_seq_read(IO_CACHE *info,unsigned char *Buffer,size_t Count);
647
 
extern int _my_b_net_read(IO_CACHE *info,unsigned char *Buffer,size_t Count);
 
717
#endif
 
718
extern int _my_b_seq_read(IO_CACHE *info,uchar *Buffer,size_t Count);
 
719
extern int _my_b_net_read(IO_CACHE *info,uchar *Buffer,size_t Count);
648
720
extern int _my_b_get(IO_CACHE *info);
649
 
extern int _my_b_async_read(IO_CACHE *info,unsigned char *Buffer,size_t Count);
650
 
extern int _my_b_write(IO_CACHE *info,const unsigned char *Buffer,size_t Count);
651
 
extern int my_b_append(IO_CACHE *info,const unsigned char *Buffer,size_t Count);
652
 
extern int my_b_safe_write(IO_CACHE *info,const unsigned char *Buffer,size_t Count);
 
721
extern int _my_b_async_read(IO_CACHE *info,uchar *Buffer,size_t Count);
 
722
extern int _my_b_write(IO_CACHE *info,const uchar *Buffer,size_t Count);
 
723
extern int my_b_append(IO_CACHE *info,const uchar *Buffer,size_t Count);
 
724
extern int my_b_safe_write(IO_CACHE *info,const uchar *Buffer,size_t Count);
653
725
 
654
 
extern int my_block_write(IO_CACHE *info, const unsigned char *Buffer,
 
726
extern int my_block_write(IO_CACHE *info, const uchar *Buffer,
655
727
                          size_t Count, my_off_t pos);
656
728
extern int my_b_flush_io_cache(IO_CACHE *info, int need_append_buffer_lock);
657
729
 
664
736
extern my_off_t my_b_filelength(IO_CACHE *info);
665
737
extern size_t my_b_printf(IO_CACHE *info, const char* fmt, ...);
666
738
extern size_t my_b_vprintf(IO_CACHE *info, const char* fmt, va_list ap);
667
 
extern bool open_cached_file(IO_CACHE *cache,const char *dir,
 
739
extern my_bool open_cached_file(IO_CACHE *cache,const char *dir,
668
740
                                 const char *prefix, size_t cache_size,
669
741
                                 myf cache_myflags);
670
 
extern bool real_open_cached_file(IO_CACHE *cache);
 
742
extern my_bool real_open_cached_file(IO_CACHE *cache);
671
743
extern void close_cached_file(IO_CACHE *cache);
672
744
File create_temp_file(char *to, const char *dir, const char *pfx,
673
745
                      int mode, myf MyFlags);
675
747
#define my_init_dynamic_array_ci(A,B,C,D) init_dynamic_array2(A,B,NULL,C,D ORIG_CALLER_INFO)
676
748
#define my_init_dynamic_array2(A,B,C,D,E) init_dynamic_array2(A,B,C,D,E CALLER_INFO)
677
749
#define my_init_dynamic_array2_ci(A,B,C,D,E) init_dynamic_array2(A,B,C,D,E ORIG_CALLER_INFO)
678
 
extern bool init_dynamic_array2(DYNAMIC_ARRAY *array,uint32_t element_size,
679
 
                                   void *init_buffer, uint32_t init_alloc, 
680
 
                                   uint32_t alloc_increment
 
750
extern my_bool init_dynamic_array2(DYNAMIC_ARRAY *array,uint element_size,
 
751
                                   void *init_buffer, uint init_alloc, 
 
752
                                   uint alloc_increment
681
753
                                   CALLER_INFO_PROTO);
682
754
/* init_dynamic_array() function is deprecated */
683
 
extern bool init_dynamic_array(DYNAMIC_ARRAY *array,uint32_t element_size,
684
 
                                  uint32_t init_alloc,uint32_t alloc_increment
 
755
extern my_bool init_dynamic_array(DYNAMIC_ARRAY *array,uint element_size,
 
756
                                  uint init_alloc,uint alloc_increment
685
757
                                  CALLER_INFO_PROTO);
686
 
extern bool insert_dynamic(DYNAMIC_ARRAY *array,unsigned char * element);
687
 
extern unsigned char *alloc_dynamic(DYNAMIC_ARRAY *array);
688
 
extern unsigned char *pop_dynamic(DYNAMIC_ARRAY*);
689
 
extern bool set_dynamic(DYNAMIC_ARRAY *array,unsigned char * element,uint32_t array_index);
690
 
extern bool allocate_dynamic(DYNAMIC_ARRAY *array, uint32_t max_elements);
691
 
extern void get_dynamic(DYNAMIC_ARRAY *array,unsigned char * element,uint32_t array_index);
 
758
extern my_bool insert_dynamic(DYNAMIC_ARRAY *array,uchar * element);
 
759
extern uchar *alloc_dynamic(DYNAMIC_ARRAY *array);
 
760
extern uchar *pop_dynamic(DYNAMIC_ARRAY*);
 
761
extern my_bool set_dynamic(DYNAMIC_ARRAY *array,uchar * element,uint array_index);
 
762
extern my_bool allocate_dynamic(DYNAMIC_ARRAY *array, uint max_elements);
 
763
extern void get_dynamic(DYNAMIC_ARRAY *array,uchar * element,uint array_index);
692
764
extern void delete_dynamic(DYNAMIC_ARRAY *array);
693
 
extern void delete_dynamic_element(DYNAMIC_ARRAY *array, uint32_t array_index);
 
765
extern void delete_dynamic_element(DYNAMIC_ARRAY *array, uint array_index);
694
766
extern void freeze_size(DYNAMIC_ARRAY *array);
695
 
extern int  get_index_dynamic(DYNAMIC_ARRAY *array, unsigned char * element);
 
767
extern int  get_index_dynamic(DYNAMIC_ARRAY *array, uchar * element);
696
768
#define dynamic_array_ptr(array,array_index) ((array)->buffer+(array_index)*(array)->size_of_element)
697
769
#define dynamic_element(array,array_index,type) ((type)((array)->buffer) +(array_index))
698
770
#define push_dynamic(A,B) insert_dynamic((A),(B))
699
771
#define reset_dynamic(array) ((array)->elements= 0)
700
772
#define sort_dynamic(A,cmp) my_qsort((A)->buffer, (A)->elements, (A)->size_of_element, (cmp))
701
773
 
 
774
extern my_bool init_dynamic_string(DYNAMIC_STRING *str, const char *init_str,
 
775
                                   size_t init_alloc,size_t alloc_increment);
 
776
extern my_bool dynstr_append(DYNAMIC_STRING *str, const char *append);
 
777
my_bool dynstr_append_mem(DYNAMIC_STRING *str, const char *append,
 
778
                          size_t length);
 
779
extern my_bool dynstr_append_os_quoted(DYNAMIC_STRING *str, const char *append,
 
780
                                       ...);
 
781
extern my_bool dynstr_set(DYNAMIC_STRING *str, const char *init_str);
 
782
extern my_bool dynstr_realloc(DYNAMIC_STRING *str, size_t additional_size);
 
783
extern my_bool dynstr_trunc(DYNAMIC_STRING *str, size_t n);
 
784
extern void dynstr_free(DYNAMIC_STRING *str);
 
785
#ifdef HAVE_MLOCK
 
786
extern void *my_malloc_lock(size_t length,myf flags);
 
787
extern void my_free_lock(void *ptr,myf flags);
 
788
#else
702
789
#define my_malloc_lock(A,B) my_malloc((A),(B))
 
790
#define my_free_lock(A,B) my_free((A),(B))
 
791
#endif
703
792
#define alloc_root_inited(A) ((A)->min_malloc != 0)
704
793
#define ALLOC_ROOT_MIN_BLOCK_SIZE (MALLOC_OVERHEAD + sizeof(USED_MEM) + 8)
705
794
#define clear_alloc_root(A) do { (A)->free= (A)->used= (A)->pre_alloc= 0; (A)->min_malloc=0;} while(0)
723
812
                                const char *option_value,
724
813
                                const char *section_name, int remove_option);
725
814
extern int my_search_option_files(const char *conf_file, int *argc,
726
 
                                  char ***argv, uint32_t *args_used,
 
815
                                  char ***argv, uint *args_used,
727
816
                                  Process_option_func func, void *func_ctx);
728
817
extern void free_defaults(char **argv);
729
818
extern void my_print_default_files(const char *conf_file);
730
819
extern void print_defaults(const char *conf_file, const char **groups);
731
 
extern ha_checksum my_checksum(ha_checksum crc, const unsigned char *mem,
 
820
extern my_bool my_compress(uchar *, size_t *, size_t *);
 
821
extern my_bool my_uncompress(uchar *, size_t , size_t *);
 
822
extern uchar *my_compress_alloc(const uchar *packet, size_t *len,
 
823
                                size_t *complen);
 
824
extern int packfrm(uchar *, size_t, uchar **, size_t *);
 
825
extern int unpackfrm(uchar **, size_t *, const uchar *);
 
826
 
 
827
extern ha_checksum my_checksum(ha_checksum crc, const uchar *mem,
732
828
                               size_t count);
733
 
extern void my_sleep(uint32_t m_seconds);
734
 
extern uint32_t my_set_max_open_files(uint32_t files);
 
829
extern void my_sleep(ulong m_seconds);
 
830
extern ulong crc32(ulong crc, const uchar *buf, uint len);
 
831
extern uint my_set_max_open_files(uint files);
735
832
void my_free_open_file_info(void);
736
833
 
737
834
extern time_t my_time(myf flags);
738
 
extern uint64_t my_getsystime(void);
739
 
extern uint64_t my_micro_time(void);
740
 
extern uint64_t my_micro_time_and_time(time_t *time_arg);
741
 
time_t my_time_possible_from_micro(uint64_t microtime);
742
 
extern bool my_gethwaddr(unsigned char *to);
 
835
extern ulonglong my_getsystime(void);
 
836
extern ulonglong my_micro_time();
 
837
extern ulonglong my_micro_time_and_time(time_t *time_arg);
 
838
time_t my_time_possible_from_micro(ulonglong microtime);
 
839
extern my_bool my_gethwaddr(uchar *to);
 
840
extern int my_getncpus();
743
841
 
744
842
#ifdef HAVE_SYS_MMAN_H
745
843
#include <sys/mman.h>
768
866
#define MAP_NOSYNC       0x0800
769
867
#define MAP_FAILED       ((void *)-1)
770
868
#define MS_SYNC          0x0000
 
869
 
 
870
#ifndef __NETWARE__
771
871
#define HAVE_MMAP
 
872
#endif
772
873
 
773
874
void *my_mmap(void *, size_t, int, int, int, my_off_t);
774
875
int my_munmap(void *, size_t);
775
876
#endif
776
877
 
 
878
/* my_getpagesize */
 
879
#ifdef HAVE_GETPAGESIZE
 
880
#define my_getpagesize()        getpagesize()
 
881
#else
 
882
int my_getpagesize(void);
 
883
#endif
 
884
 
777
885
/* character sets */
778
 
extern uint32_t get_charset_number(const char *cs_name, uint32_t cs_flags);
779
 
extern uint32_t get_collation_number(const char *name);
780
 
extern const char *get_charset_name(uint32_t cs_number);
781
 
 
782
 
extern const CHARSET_INFO *get_charset(uint32_t cs_number, myf flags);
783
 
extern const CHARSET_INFO *get_charset_by_name(const char *cs_name, myf flags);
784
 
extern const CHARSET_INFO *get_charset_by_csname(const char *cs_name, uint32_t cs_flags, myf my_flags);
785
 
 
786
 
extern bool resolve_charset(const char *cs_name,
787
 
                            const CHARSET_INFO *default_cs,
788
 
                            const CHARSET_INFO **cs);
789
 
extern bool resolve_collation(const char *cl_name,
790
 
                             const CHARSET_INFO *default_cl,
791
 
                             const CHARSET_INFO **cl);
 
886
extern uint get_charset_number(const char *cs_name, uint cs_flags);
 
887
extern uint get_collation_number(const char *name);
 
888
extern const char *get_charset_name(uint cs_number);
 
889
 
 
890
extern CHARSET_INFO *get_charset(uint cs_number, myf flags);
 
891
extern CHARSET_INFO *get_charset_by_name(const char *cs_name, myf flags);
 
892
extern CHARSET_INFO *get_charset_by_csname(const char *cs_name,
 
893
                                           uint cs_flags, myf my_flags);
 
894
 
 
895
extern my_bool resolve_charset(const char *cs_name,
 
896
                               CHARSET_INFO *default_cs,
 
897
                               CHARSET_INFO **cs);
 
898
extern my_bool resolve_collation(const char *cl_name,
 
899
                                 CHARSET_INFO *default_cl,
 
900
                                 CHARSET_INFO **cl);
792
901
 
793
902
extern void free_charsets(void);
794
903
extern char *get_charsets_dir(char *buf);
795
 
extern bool my_charset_same(const CHARSET_INFO *cs1, const CHARSET_INFO *cs2);
796
 
extern bool init_compiled_charsets(myf flags);
 
904
extern my_bool my_charset_same(CHARSET_INFO *cs1, CHARSET_INFO *cs2);
 
905
extern my_bool init_compiled_charsets(myf flags);
797
906
extern void add_compiled_collation(CHARSET_INFO *cs);
798
 
extern size_t escape_string_for_drizzle(const CHARSET_INFO *charset_info,
799
 
                                        char *to, size_t to_length,
800
 
                                        const char *from, size_t length);
801
 
extern size_t escape_quotes_for_drizzle(const CHARSET_INFO *charset_info,
802
 
                                        char *to, size_t to_length,
803
 
                                        const char *from, size_t length);
804
 
 
805
 
extern void thd_increment_bytes_sent(uint32_t length);
806
 
extern void thd_increment_bytes_received(uint32_t length);
807
 
extern void thd_increment_net_big_packet_count(uint32_t length);
808
 
 
809
 
#ifdef __cplusplus
810
 
}
811
 
#endif
812
 
 
 
907
extern size_t escape_string_for_mysql(CHARSET_INFO *charset_info,
 
908
                                      char *to, size_t to_length,
 
909
                                      const char *from, size_t length);
 
910
extern size_t escape_quotes_for_mysql(CHARSET_INFO *charset_info,
 
911
                                      char *to, size_t to_length,
 
912
                                      const char *from, size_t length);
 
913
 
 
914
extern void thd_increment_bytes_sent(ulong length);
 
915
extern void thd_increment_bytes_received(ulong length);
 
916
extern void thd_increment_net_big_packet_count(ulong length);
 
917
 
 
918
C_MODE_END
813
919
#endif /* _my_sys_h */