← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to include/my_sys.h

  • Committer: Jay Pipes
  • Date: 2008-07-17 19:43:08 UTC
  • mto: This revision was merged to the branch mainline in revision 182.
  • Revision ID: jay@mysql.com-20080717194308-l9i4ti57gikm2qbv
Phase 1 removal of DBUG in mysys

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
#include <my_pthread.h>
31
32
 
32
 
#include <mystrings/m_ctype.h>                    /* for CHARSET_INFO */
 
33
#include <m_ctype.h>                    /* for CHARSET_INFO */
33
34
#include <stdarg.h>
34
 
#include <mysys/typelib.h>
 
35
#include <typelib.h>
35
36
 
 
37
#define MYSYS_PROGRAM_DONT_USE_CURSES()  { error_handler_hook = my_message_no_curses; mysys_uses_curses=0;}
36
38
#define MY_INIT(name);          { my_progname= name; my_init(); }
37
39
 
38
40
#define ERRMSGSIZE      (SC_MAXWIDTH)   /* Max length of a error message */
107
109
        /* Some constants */
108
110
#define MY_WAIT_FOR_USER_TO_FIX_PANIC   60      /* in seconds */
109
111
#define MY_WAIT_GIVE_USER_A_MESSAGE     10      /* Every 10 times of prev */
 
112
#define MIN_COMPRESS_LENGTH             50      /* Don't compress small bl. */
110
113
#define DFLT_INIT_HITS  3
111
114
 
112
115
        /* root_alloc flags */
125
128
#define GETDATE_FIXEDLENGTH     16
126
129
 
127
130
        /* defines when allocating data */
 
131
#ifdef SAFEMALLOC
 
132
#else
128
133
#define my_checkmalloc()
129
134
#undef TERMINATE
130
135
#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
 
 
 
136
#define QUICK_SAFEMALLOC
 
137
#define NORMAL_SAFEMALLOC
139
138
extern void *my_malloc(size_t Size,myf MyFlags);
140
139
#define my_malloc_ci(SZ,FLAG) my_malloc( SZ, FLAG )
141
140
extern void *my_realloc(void *oldpoint, size_t Size, myf MyFlags);
144
143
extern char *my_strdup(const char *from,myf MyFlags);
145
144
extern char *my_strndup(const char *from, size_t length,
146
145
                                   myf MyFlags);
 
146
/* we do use FG (as a no-op) in below so that a typo on FG is caught */
 
147
#define my_free(PTR,FG) ((void)FG,my_no_flags_free(PTR))
147
148
#define CALLER_INFO_PROTO   /* nothing */
148
149
#define CALLER_INFO         /* nothing */
149
150
#define ORIG_CALLER_INFO    /* nothing */
150
151
#define TRASH(A,B) /* nothing */
 
152
#endif
151
153
 
152
154
#ifdef HAVE_ALLOCA
153
155
#if defined(__GNUC__) && !defined(HAVE_ALLOCA_H) && ! defined(alloca)
154
156
#define alloca __builtin_alloca
155
157
#endif /* GNUC */
156
 
#define my_alloca(SZ) malloc((size_t) (SZ))
157
 
#define my_afree(PTR) free((PTR))
 
158
#define my_alloca(SZ) alloca((size_t) (SZ))
 
159
#define my_afree(PTR) {}
158
160
#else
159
 
#define my_alloca(SZ) malloc((SZ))
160
 
#define my_afree(PTR) free((PTR))
 
161
#define my_alloca(SZ) my_malloc(SZ,MYF(0))
 
162
#define my_afree(PTR) my_free(PTR,MYF(MY_WME))
161
163
#endif /* HAVE_ALLOCA */
162
164
 
163
165
#ifndef errno                           /* did we already get it? */
170
172
extern char errbuff[NRERRBUFFS][ERRMSGSIZE];
171
173
extern char *home_dir;                  /* Home directory for user */
172
174
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,
 
175
extern void (*error_handler_hook)(uint my_err, const char *str,myf MyFlags);
 
176
extern void (*fatal_error_handler_hook)(uint my_err, const char *str,
175
177
                                        myf MyFlags);
176
 
extern uint32_t my_file_limit;
177
 
extern uint32_t my_thread_stack_size;
 
178
extern uint my_file_limit;
 
179
extern ulong my_thread_stack_size;
178
180
 
179
181
/* charsets */
180
 
extern const CHARSET_INFO *default_charset_info;
 
182
extern CHARSET_INFO *default_charset_info;
181
183
extern CHARSET_INFO *all_charsets[256];
182
184
extern CHARSET_INFO compiled_charsets[];
183
185
 
184
186
/* statistics */
185
 
extern uint32_t my_file_opened,my_stream_opened, my_tmp_file_created;
186
 
extern uint32_t    my_file_total_opened;
 
187
extern ulong    my_file_opened,my_stream_opened, my_tmp_file_created;
 
188
extern ulong    my_file_total_opened;
187
189
extern uint     mysys_usage_id;
188
190
extern bool     my_init_done;
189
191
 
199
201
           my_safe_to_handle_signal, /* Set when allowed to SIGTSTP */
200
202
           my_dont_interrupt;   /* call remember_intr when set */
201
203
extern bool mysys_uses_curses, my_use_symdir;
202
 
extern uint32_t sf_malloc_cur_memory, sf_malloc_max_memory;
 
204
extern ulong sf_malloc_cur_memory, sf_malloc_max_memory;
203
205
 
204
 
extern uint32_t my_default_record_cache_size;
 
206
extern ulong    my_default_record_cache_size;
205
207
extern bool my_disable_async_io,
206
208
               my_disable_flush_key_blocks, my_disable_symlinks;
207
209
extern char     wild_many, wild_one, wild_prefix;
238
240
  int   rc_seek,error,inited;
239
241
  uint  rc_length,read_length,reclength;
240
242
  my_off_t rc_record_pos,end_of_file;
241
 
  unsigned char *rc_buff,*rc_buff2,*rc_pos,*rc_end,*rc_request_pos;
 
243
  uchar *rc_buff,*rc_buff2,*rc_pos,*rc_end,*rc_request_pos;
242
244
#ifdef HAVE_AIOWAIT
243
245
  int   use_async_io;
244
246
  my_aio_result aio_result;
265
267
 
266
268
typedef struct st_dynamic_array
267
269
{
268
 
  unsigned char *buffer;
269
 
  uint32_t elements,max_element;
270
 
  uint32_t alloc_increment;
271
 
  uint32_t size_of_element;
 
270
  uchar *buffer;
 
271
  uint elements,max_element;
 
272
  uint alloc_increment;
 
273
  uint size_of_element;
272
274
} DYNAMIC_ARRAY;
273
275
 
274
276
typedef struct st_my_tmpdir
275
277
{
276
278
  DYNAMIC_ARRAY full_list;
277
279
  char **list;
278
 
  uint32_t cur, max;
 
280
  uint cur, max;
279
281
  pthread_mutex_t mutex;
280
282
} MY_TMPDIR;
281
283
 
 
284
typedef struct st_dynamic_string
 
285
{
 
286
  char *str;
 
287
  size_t length,max_length,alloc_increment;
 
288
} DYNAMIC_STRING;
 
289
 
282
290
struct st_io_cache;
283
291
typedef int (*IO_CACHE_CALLBACK)(struct st_io_cache*);
284
292
 
291
299
  my_off_t              pos_in_file;
292
300
  /* If a synchronized write cache is the source of the data. */
293
301
  struct st_io_cache    *source_cache;
294
 
  unsigned char                 *buffer;         /* The read buffer. */
295
 
  unsigned char                 *read_end;       /* Behind last valid byte of buffer. */
 
302
  uchar                 *buffer;         /* The read buffer. */
 
303
  uchar                 *read_end;       /* Behind last valid byte of buffer. */
296
304
  int                   running_threads; /* threads not in lock. */
297
305
  int                   total_threads;   /* threads sharing the cache. */
298
306
  int                   error;           /* Last error. */
304
312
 
305
313
typedef struct st_io_cache              /* Used when cacheing files */
306
314
{
307
 
  /* Offset in file corresponding to the first byte of unsigned char* buffer. */
 
315
  /* Offset in file corresponding to the first byte of uchar* buffer. */
308
316
  my_off_t pos_in_file;
309
317
  /*
310
318
    The offset of end of file for READ_CACHE and WRITE_CACHE.
313
321
  */
314
322
  my_off_t end_of_file;
315
323
  /* Points to current read position in the buffer */
316
 
  unsigned char *read_pos;
 
324
  uchar *read_pos;
317
325
  /* the non-inclusive boundary in the buffer for the currently valid read */
318
 
  unsigned char  *read_end;
319
 
  unsigned char  *buffer;                               /* The read buffer */
 
326
  uchar  *read_end;
 
327
  uchar  *buffer;                               /* The read buffer */
320
328
  /* Used in ASYNC_IO */
321
 
  unsigned char  *request_pos;
 
329
  uchar  *request_pos;
322
330
 
323
331
  /* Only used in WRITE caches and in SEQ_READ_APPEND to buffer writes */
324
 
  unsigned char  *write_buffer;
 
332
  uchar  *write_buffer;
325
333
  /*
326
334
    Only used in SEQ_READ_APPEND, and points to the current read position
327
335
    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).
 
336
    happen from both read buffer (uchar* buffer) and write buffer
 
337
    (uchar* write_buffer).
330
338
  */
331
 
  unsigned char *append_read_pos;
 
339
  uchar *append_read_pos;
332
340
  /* Points to current write position in the write buffer */
333
 
  unsigned char *write_pos;
 
341
  uchar *write_pos;
334
342
  /* The non-inclusive boundary of the valid write area */
335
 
  unsigned char *write_end;
 
343
  uchar *write_end;
336
344
 
337
345
  /*
338
346
    Current_pos and current_end are convenience variables used by
340
348
    current_pos points to &write_pos, and current_end to &write_end in a
341
349
    WRITE_CACHE, and &read_pos and &read_end respectively otherwise
342
350
  */
343
 
  unsigned char  **current_pos, **current_end;
 
351
  uchar  **current_pos, **current_end;
344
352
  /*
345
353
    The lock is for append buffer used in SEQ_READ_APPEND cache
346
354
    need mutex copying from append buffer to read buffer.
362
370
    my_b_read() will call read_function to fetch the data. read_function
363
371
    must never be invoked directly.
364
372
  */
365
 
  int (*read_function)(struct st_io_cache *,unsigned char *,size_t);
 
373
  int (*read_function)(struct st_io_cache *,uchar *,size_t);
366
374
  /*
367
375
    Same idea as in the case of read_function, except my_b_write() needs to
368
376
    be replaced with my_b_append() for a SEQ_READ_APPEND cache
369
377
  */
370
 
  int (*write_function)(struct st_io_cache *,const unsigned char *,size_t);
 
378
  int (*write_function)(struct st_io_cache *,const uchar *,size_t);
371
379
  /*
372
380
    Specifies the type of the cache. Depending on the type of the cache
373
381
    certain operations might not be available and yield unpredicatable
388
396
    Counts the number of times, when we were forced to use disk. We use it to
389
397
    increase the binlog_cache_disk_use status variable.
390
398
  */
391
 
  uint32_t disk_writes;
 
399
  ulong disk_writes;
392
400
  void* arg;                            /* for use by pre/post_read */
393
401
  char *file_name;                      /* if used with 'open_cached_file' */
394
402
  char *dir,*prefix;
418
426
    As inidicated by ifdef, this is for async I/O, which is not currently
419
427
    used (because it's not reliable on all systems)
420
428
  */
421
 
  uint32_t inited;
 
429
  uint inited;
422
430
  my_off_t aio_read_pos;
423
431
  my_aio_result aio_result;
424
432
#endif
447
455
 
448
456
#define my_b_get(info) \
449
457
  ((info)->read_pos != (info)->read_end ?\
450
 
   ((info)->read_pos++, (int) (unsigned char) (info)->read_pos[-1]) :\
 
458
   ((info)->read_pos++, (int) (uchar) (info)->read_pos[-1]) :\
451
459
   _my_b_get(info))
452
460
 
453
461
        /* my_b_write_byte dosn't have any err-check */
475
483
#define my_b_bytes_in_cache(info) (size_t) (*(info)->current_end - \
476
484
                                          *(info)->current_pos)
477
485
 
478
 
typedef uint32_t ha_checksum;
 
486
typedef uint32 ha_checksum;
479
487
 
480
488
/* Define the type of function to be passed to process_default_option_files */
481
489
typedef int (*Process_option_func)(void *ctx, const char *group_name,
482
490
                                   const char *option);
483
491
 
484
 
#include <mysys/my_alloc.h>
 
492
#include <my_alloc.h>
485
493
 
486
494
 
487
495
        /* Prototypes for mysys and my_func functions */
488
496
 
489
497
extern int my_copy(const char *from,const char *to,myf MyFlags);
 
498
extern int my_append(const char *from,const char *to,myf MyFlags);
490
499
extern int my_delete(const char *name,myf MyFlags);
491
500
extern int my_getwd(char * buf,size_t size,myf MyFlags);
492
501
extern int my_setwd(const char *dir,myf MyFlags);
497
506
extern File my_open(const char *FileName,int Flags,myf MyFlags);
498
507
extern File my_register_filename(File fd, const char *FileName,
499
508
                                 enum file_type type_of_file,
500
 
                                 uint32_t error_message_number, myf MyFlags);
 
509
                                 uint error_message_number, myf MyFlags);
501
510
extern File my_create(const char *FileName,int CreateFlags,
502
511
                      int AccessFlags, myf MyFlags);
503
512
extern int my_close(File Filedes,myf MyFlags);
511
520
extern int my_delete_with_symlink(const char *name, myf MyFlags);
512
521
extern int my_rename_with_symlink(const char *from,const char *to,myf MyFlags);
513
522
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);
 
523
extern size_t my_read(File Filedes,uchar *Buffer,size_t Count,myf MyFlags);
515
524
extern int my_rename(const char *from,const char *to,myf MyFlags);
516
525
extern my_off_t my_seek(File fd,my_off_t pos,int whence,myf MyFlags);
517
526
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,
 
527
extern size_t my_write(File Filedes,const uchar *Buffer,size_t Count,
519
528
                     myf MyFlags);
520
 
extern size_t my_fwrite(FILE *stream,const unsigned char *Buffer,size_t Count,
 
529
extern size_t my_fread(FILE *stream,uchar *Buffer,size_t Count,myf MyFlags);
 
530
extern size_t my_fwrite(FILE *stream,const uchar *Buffer,size_t Count,
521
531
                      myf MyFlags);
522
532
extern my_off_t my_fseek(FILE *stream,my_off_t pos,int whence,myf MyFlags);
 
533
extern my_off_t my_ftell(FILE *stream,myf MyFlags);
523
534
extern void *_mymalloc(size_t uSize,const char *sFile,
524
 
                       uint32_t uLine, myf MyFlag);
 
535
                       uint uLine, myf MyFlag);
525
536
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);
 
537
                       uint uLine, myf MyFlag);
 
538
extern void * my_multi_malloc _VARARGS((myf MyFlags, ...));
 
539
extern void _myfree(void *pPtr,const char *sFile,uint uLine, myf MyFlag);
 
540
extern int _sanity(const char *sFile, uint uLine);
530
541
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,
 
542
                        const char *sFile, uint uLine,myf MyFlag);
 
543
extern char * _my_strdup(const char *from, const char *sFile, uint uLine,
533
544
                         myf MyFlag);
534
545
extern char *_my_strndup(const char *from, size_t length,
535
 
                         const char *sFile, uint32_t uLine,
 
546
                         const char *sFile, uint uLine,
536
547
                         myf MyFlag);
537
548
 
 
549
/* implemented in my_memmem.c */
 
550
extern void *my_memmem(const void *haystack, size_t haystacklen,
 
551
                       const void *needle, size_t needlelen);
 
552
 
 
553
 
538
554
#define my_access access
539
555
extern int check_if_legal_filename(const char *path);
540
556
extern int check_if_legal_tablename(const char *path);
542
558
#define my_delete_allow_opened(fname,flags)  my_delete((fname),(flags))
543
559
 
544
560
#ifndef TERMINATE
545
 
extern void TERMINATE(FILE *file, uint32_t flag);
 
561
extern void TERMINATE(FILE *file, uint flag);
546
562
#endif
547
563
extern void init_glob_errs(void);
548
564
extern FILE *my_fopen(const char *FileName,int Flags,myf MyFlags);
 
565
extern FILE *my_fdopen(File Filedes,const char *name, int Flags,myf MyFlags);
549
566
extern int my_fclose(FILE *fd,myf MyFlags);
550
567
extern int my_sync(File fd, myf my_flags);
551
568
extern int my_sync_dir(const char *dir_name, myf my_flags);
552
569
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)));
 
570
extern void my_error _VARARGS((int nr,myf MyFlags, ...));
 
571
extern void my_printf_error _VARARGS((uint my_err, const char *format,
 
572
                                      myf MyFlags, ...))
 
573
                                      ATTRIBUTE_FORMAT(printf, 2, 4);
557
574
extern int my_error_register(const char **errmsgs, int first, int last);
558
575
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);
 
576
extern void my_message(uint my_err, const char *str,myf MyFlags);
 
577
extern void my_message_no_curses(uint my_err, const char *str,myf MyFlags);
561
578
extern bool my_init(void);
562
579
extern void my_end(int infoflag);
563
580
extern int my_redel(const char *from, const char *to, int MyFlags);
574
591
extern char *my_tmpdir(MY_TMPDIR *tmpdir);
575
592
extern void free_tmpdir(MY_TMPDIR *tmpdir);
576
593
 
577
 
extern void my_remember_signal(int signal_number,RETSIGTYPE (*func)(int));
 
594
extern void my_remember_signal(int signal_number,sig_handler (*func)(int));
578
595
extern size_t dirname_part(char * to,const char *name, size_t *to_res_length);
579
596
extern size_t dirname_length(const char *name);
580
597
#define base_name(A) (A+dirname_length(A))
585
602
extern char * fn_ext(const char *name);
586
603
extern char * fn_same(char * toname,const char *name,int flag);
587
604
extern char * fn_format(char * to,const char *name,const char *dir,
588
 
                           const char *form, uint32_t flag);
 
605
                           const char *form, uint flag);
589
606
extern size_t strlength(const char *str);
590
607
extern void pack_dirname(char * to,const char *from);
591
608
extern size_t unpack_dirname(char * to,const char *from);
604
621
extern WF_PACK *wf_comp(char * str);
605
622
extern int wf_test(struct wild_file_pack *wf_pack,const char *name);
606
623
extern void wf_end(struct wild_file_pack *buffer);
 
624
extern size_t strip_sp(char * str);
607
625
extern bool array_append_string_unique(const char *str,
608
626
                                          const char **array, size_t size);
609
627
extern void get_date(char * to,int timeflag,time_t use_time);
612
630
extern int init_record_cache(RECORD_CACHE *info,size_t cachesize,File file,
613
631
                             size_t reclength,enum cache_type type,
614
632
                             bool use_async_io);
615
 
extern int read_cache_record(RECORD_CACHE *info,unsigned char *to);
 
633
extern int read_cache_record(RECORD_CACHE *info,uchar *to);
616
634
extern int end_record_cache(RECORD_CACHE *info);
617
635
extern int write_cache_record(RECORD_CACHE *info,my_off_t filepos,
618
 
                              const unsigned char *record,size_t length);
 
636
                              const uchar *record,size_t length);
619
637
extern int flush_write_cache(RECORD_CACHE *info);
620
 
extern RETSIGTYPE sigtstp_handler(int signal_number);
 
638
extern long my_clock(void);
 
639
extern sig_handler sigtstp_handler(int signal_number);
621
640
extern void handle_recived_signals(void);
622
641
 
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);
 
642
extern sig_handler my_set_alarm_variable(int signo);
 
643
extern void my_string_ptr_sort(uchar *base,uint items,size_t size);
 
644
extern void radixsort_for_str_ptr(uchar* base[], uint number_of_elements,
 
645
                                  size_t size_of_element,uchar *buffer[]);
 
646
extern qsort_t my_qsort(void *base_ptr, size_t total_elems, size_t size,
 
647
                        qsort_cmp cmp);
 
648
extern qsort_t my_qsort2(void *base_ptr, size_t total_elems, size_t size,
 
649
                         qsort2_cmp cmp, void *cmp_argument);
631
650
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);
 
651
void my_store_ptr(uchar *buff, size_t pack_length, my_off_t pos);
 
652
my_off_t my_get_ptr(uchar *ptr, size_t pack_length);
634
653
extern int init_io_cache(IO_CACHE *info,File file,size_t cachesize,
635
654
                         enum cache_type type,my_off_t seek_offset,
636
655
                         bool use_async_io, myf cache_myflags);
638
657
                               my_off_t seek_offset,bool use_async_io,
639
658
                               bool clear_cache);
640
659
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);
 
660
extern int _my_b_read(IO_CACHE *info,uchar *Buffer,size_t Count);
 
661
extern int _my_b_read_r(IO_CACHE *info,uchar *Buffer,size_t Count);
643
662
extern void init_io_cache_share(IO_CACHE *read_cache, IO_CACHE_SHARE *cshare,
644
 
                                IO_CACHE *write_cache, uint32_t num_threads);
 
663
                                IO_CACHE *write_cache, uint num_threads);
645
664
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);
 
665
extern int _my_b_seq_read(IO_CACHE *info,uchar *Buffer,size_t Count);
 
666
extern int _my_b_net_read(IO_CACHE *info,uchar *Buffer,size_t Count);
648
667
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);
 
668
extern int _my_b_async_read(IO_CACHE *info,uchar *Buffer,size_t Count);
 
669
extern int _my_b_write(IO_CACHE *info,const uchar *Buffer,size_t Count);
 
670
extern int my_b_append(IO_CACHE *info,const uchar *Buffer,size_t Count);
 
671
extern int my_b_safe_write(IO_CACHE *info,const uchar *Buffer,size_t Count);
653
672
 
654
 
extern int my_block_write(IO_CACHE *info, const unsigned char *Buffer,
 
673
extern int my_block_write(IO_CACHE *info, const uchar *Buffer,
655
674
                          size_t Count, my_off_t pos);
656
675
extern int my_b_flush_io_cache(IO_CACHE *info, int need_append_buffer_lock);
657
676
 
675
694
#define my_init_dynamic_array_ci(A,B,C,D) init_dynamic_array2(A,B,NULL,C,D ORIG_CALLER_INFO)
676
695
#define my_init_dynamic_array2(A,B,C,D,E) init_dynamic_array2(A,B,C,D,E CALLER_INFO)
677
696
#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
 
697
extern bool init_dynamic_array2(DYNAMIC_ARRAY *array,uint element_size,
 
698
                                   void *init_buffer, uint init_alloc, 
 
699
                                   uint alloc_increment
681
700
                                   CALLER_INFO_PROTO);
682
701
/* 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
 
702
extern bool init_dynamic_array(DYNAMIC_ARRAY *array,uint element_size,
 
703
                                  uint init_alloc,uint alloc_increment
685
704
                                  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);
 
705
extern bool insert_dynamic(DYNAMIC_ARRAY *array,uchar * element);
 
706
extern uchar *alloc_dynamic(DYNAMIC_ARRAY *array);
 
707
extern uchar *pop_dynamic(DYNAMIC_ARRAY*);
 
708
extern bool set_dynamic(DYNAMIC_ARRAY *array,uchar * element,uint array_index);
 
709
extern bool allocate_dynamic(DYNAMIC_ARRAY *array, uint max_elements);
 
710
extern void get_dynamic(DYNAMIC_ARRAY *array,uchar * element,uint array_index);
692
711
extern void delete_dynamic(DYNAMIC_ARRAY *array);
693
 
extern void delete_dynamic_element(DYNAMIC_ARRAY *array, uint32_t array_index);
 
712
extern void delete_dynamic_element(DYNAMIC_ARRAY *array, uint array_index);
694
713
extern void freeze_size(DYNAMIC_ARRAY *array);
695
 
extern int  get_index_dynamic(DYNAMIC_ARRAY *array, unsigned char * element);
 
714
extern int  get_index_dynamic(DYNAMIC_ARRAY *array, uchar * element);
696
715
#define dynamic_array_ptr(array,array_index) ((array)->buffer+(array_index)*(array)->size_of_element)
697
716
#define dynamic_element(array,array_index,type) ((type)((array)->buffer) +(array_index))
698
717
#define push_dynamic(A,B) insert_dynamic((A),(B))
699
718
#define reset_dynamic(array) ((array)->elements= 0)
700
719
#define sort_dynamic(A,cmp) my_qsort((A)->buffer, (A)->elements, (A)->size_of_element, (cmp))
701
720
 
 
721
extern bool init_dynamic_string(DYNAMIC_STRING *str, const char *init_str,
 
722
                                   size_t init_alloc,size_t alloc_increment);
 
723
extern bool dynstr_append(DYNAMIC_STRING *str, const char *append);
 
724
bool dynstr_append_mem(DYNAMIC_STRING *str, const char *append,
 
725
                          size_t length);
 
726
extern bool dynstr_append_os_quoted(DYNAMIC_STRING *str, const char *append,
 
727
                                       ...);
 
728
extern bool dynstr_set(DYNAMIC_STRING *str, const char *init_str);
 
729
extern bool dynstr_realloc(DYNAMIC_STRING *str, size_t additional_size);
 
730
extern bool dynstr_trunc(DYNAMIC_STRING *str, size_t n);
 
731
extern void dynstr_free(DYNAMIC_STRING *str);
 
732
#ifdef HAVE_MLOCK
 
733
extern void *my_malloc_lock(size_t length,myf flags);
 
734
extern void my_free_lock(void *ptr,myf flags);
 
735
#else
702
736
#define my_malloc_lock(A,B) my_malloc((A),(B))
 
737
#define my_free_lock(A,B) my_free((A),(B))
 
738
#endif
703
739
#define alloc_root_inited(A) ((A)->min_malloc != 0)
704
740
#define ALLOC_ROOT_MIN_BLOCK_SIZE (MALLOC_OVERHEAD + sizeof(USED_MEM) + 8)
705
741
#define clear_alloc_root(A) do { (A)->free= (A)->used= (A)->pre_alloc= 0; (A)->min_malloc=0;} while(0)
723
759
                                const char *option_value,
724
760
                                const char *section_name, int remove_option);
725
761
extern int my_search_option_files(const char *conf_file, int *argc,
726
 
                                  char ***argv, uint32_t *args_used,
 
762
                                  char ***argv, uint *args_used,
727
763
                                  Process_option_func func, void *func_ctx);
728
764
extern void free_defaults(char **argv);
729
765
extern void my_print_default_files(const char *conf_file);
730
766
extern void print_defaults(const char *conf_file, const char **groups);
731
 
extern ha_checksum my_checksum(ha_checksum crc, const unsigned char *mem,
 
767
extern bool my_compress(uchar *, size_t *, size_t *);
 
768
extern bool my_uncompress(uchar *, size_t , size_t *);
 
769
extern uchar *my_compress_alloc(const uchar *packet, size_t *len,
 
770
                                size_t *complen);
 
771
extern ha_checksum my_checksum(ha_checksum crc, const uchar *mem,
732
772
                               size_t count);
733
 
extern void my_sleep(uint32_t m_seconds);
734
 
extern uint32_t my_set_max_open_files(uint32_t files);
 
773
extern void my_sleep(ulong m_seconds);
 
774
extern uint my_set_max_open_files(uint files);
735
775
void my_free_open_file_info(void);
736
776
 
737
777
extern time_t my_time(myf flags);
739
779
extern uint64_t my_micro_time(void);
740
780
extern uint64_t my_micro_time_and_time(time_t *time_arg);
741
781
time_t my_time_possible_from_micro(uint64_t microtime);
742
 
extern bool my_gethwaddr(unsigned char *to);
 
782
extern bool my_gethwaddr(uchar *to);
 
783
extern int my_getncpus(void);
743
784
 
744
785
#ifdef HAVE_SYS_MMAN_H
745
786
#include <sys/mman.h>
768
809
#define MAP_NOSYNC       0x0800
769
810
#define MAP_FAILED       ((void *)-1)
770
811
#define MS_SYNC          0x0000
 
812
 
 
813
#ifndef __NETWARE__
771
814
#define HAVE_MMAP
 
815
#endif
772
816
 
773
817
void *my_mmap(void *, size_t, int, int, int, my_off_t);
774
818
int my_munmap(void *, size_t);
775
819
#endif
776
820
 
 
821
/* my_getpagesize */
 
822
#ifdef HAVE_GETPAGESIZE
 
823
#define my_getpagesize()        getpagesize()
 
824
#else
 
825
int my_getpagesize(void);
 
826
#endif
 
827
 
777
828
/* 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);
 
829
extern uint get_charset_number(const char *cs_name, uint cs_flags);
 
830
extern uint get_collation_number(const char *name);
 
831
extern const char *get_charset_name(uint cs_number);
781
832
 
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);
 
833
extern CHARSET_INFO *get_charset(uint cs_number, myf flags);
 
834
extern CHARSET_INFO *get_charset_by_name(const char *cs_name, myf flags);
 
835
extern CHARSET_INFO *get_charset_by_csname(const char *cs_name,
 
836
                                           uint cs_flags, myf my_flags);
785
837
 
786
838
extern bool resolve_charset(const char *cs_name,
787
 
                            const CHARSET_INFO *default_cs,
788
 
                            const CHARSET_INFO **cs);
 
839
                               CHARSET_INFO *default_cs,
 
840
                               CHARSET_INFO **cs);
789
841
extern bool resolve_collation(const char *cl_name,
790
 
                             const CHARSET_INFO *default_cl,
791
 
                             const CHARSET_INFO **cl);
 
842
                                 CHARSET_INFO *default_cl,
 
843
                                 CHARSET_INFO **cl);
792
844
 
793
845
extern void free_charsets(void);
794
846
extern char *get_charsets_dir(char *buf);
795
 
extern bool my_charset_same(const CHARSET_INFO *cs1, const CHARSET_INFO *cs2);
 
847
extern bool my_charset_same(CHARSET_INFO *cs1, CHARSET_INFO *cs2);
796
848
extern bool init_compiled_charsets(myf flags);
797
849
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
 
 
 
850
extern size_t escape_string_for_mysql(CHARSET_INFO *charset_info,
 
851
                                      char *to, size_t to_length,
 
852
                                      const char *from, size_t length);
 
853
extern size_t escape_quotes_for_mysql(CHARSET_INFO *charset_info,
 
854
                                      char *to, size_t to_length,
 
855
                                      const char *from, size_t length);
 
856
 
 
857
extern void thd_increment_bytes_sent(ulong length);
 
858
extern void thd_increment_bytes_received(ulong length);
 
859
extern void thd_increment_net_big_packet_count(ulong length);
 
860
 
 
861
C_MODE_END
813
862
#endif /* _my_sys_h */