← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to mysys/my_sys.h

  • Committer: Brian Aker
  • Date: 2008-09-04 19:31:00 UTC
  • Revision ID: brian@tangent.org-20080904193100-l849hgghfy4urj43
Changing default character set from this point on.

Show diffs side-by-side

added added

removed removed

Lines of Context:
mysys/my_sys.h
1
 
/* - mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
2
 
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
3
 
 *
4
 
 *  Copyright (C) 2008 MySQL
5
 
 *
6
 
 *  This program is free software; you can redistribute it and/or modify
7
 
 *  it under the terms of the GNU General Public License as published by
8
 
 *  the Free Software Foundation; either version 2 of the License, or
9
 
 *  (at your option) any later version.
10
 
 *
11
 
 *  This program is distributed in the hope that it will be useful,
12
 
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
13
 
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14
 
 *  GNU General Public License for more details.
15
 
 *
16
 
 *  You should have received a copy of the GNU General Public License
17
 
 *  along with this program; if not, write to the Free Software
18
 
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
19
 
 */
 
1
/* Copyright (C) 2000-2003 MySQL AB
 
2
 
 
3
   This program is free software; you can redistribute it and/or modify
 
4
   it under the terms of the GNU General Public License as published by
 
5
   the Free Software Foundation; version 2 of the License.
 
6
 
 
7
   This program is distributed in the hope that it will be useful,
 
8
   but WITHOUT ANY WARRANTY; without even the implied warranty of
 
9
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
10
   GNU General Public License for more details.
 
11
 
 
12
   You should have received a copy of the GNU General Public License
 
13
   along with this program; if not, write to the Free Software
 
14
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
20
15
 
21
16
#ifndef _my_sys_h
22
17
#define _my_sys_h
 
18
C_MODE_START
 
19
 
 
20
#ifdef HAVE_AIOWAIT
 
21
#include <sys/asynch.h>                 /* Used by record-cache */
 
22
typedef struct my_aio_result {
 
23
  aio_result_t result;
 
24
  int          pending;
 
25
} my_aio_result;
 
26
#endif
23
27
 
24
28
#include <errno.h>
25
29
#define my_errno (errno)
29
33
#include <mystrings/m_ctype.h>                    /* for CHARSET_INFO */
30
34
#include <stdarg.h>
31
35
#include <mysys/typelib.h>
32
 
#include <mysys/aio_result.h>
33
 
 
34
 
#include <mysys/my_alloc.h>
35
 
 
36
 
/* Sun Studio does not inject this into main namespace yet */
37
 
#if defined(__cplusplus)
38
 
  using std::FILE;
39
 
#endif 
40
36
 
41
37
#define MY_INIT(name);          { my_progname= name; my_init(); }
42
38
 
53
49
#define MY_WAIT_IF_FULL 32      /* Wait and try again if disk full error */
54
50
#define MY_IGNORE_BADFD 32      /* my_sync: ignore 'bad descriptor' errors */
55
51
#define MY_SYNC_DIR     1024    /* my_create/delete/rename: sync directory */
 
52
#define MY_RAID         64      /* Support for RAID */
56
53
#define MY_FULL_IO     512      /* For my_read - loop intil I/O is complete */
57
54
#define MY_DONT_CHECK_FILESIZE 128 /* Option to init_io_cache() */
58
55
#define MY_LINK_WARNING 32      /* my_redel() gives warning if links */
111
108
        /* Some constants */
112
109
#define MY_WAIT_FOR_USER_TO_FIX_PANIC   60      /* in seconds */
113
110
#define MY_WAIT_GIVE_USER_A_MESSAGE     10      /* Every 10 times of prev */
 
111
#define MIN_COMPRESS_LENGTH             50      /* Don't compress small bl. */
114
112
#define DFLT_INIT_HITS  3
115
113
 
116
114
        /* root_alloc flags */
129
127
#define GETDATE_FIXEDLENGTH     16
130
128
 
131
129
        /* defines when allocating data */
 
130
#ifdef SAFEMALLOC
 
131
#else
132
132
#define my_checkmalloc()
133
133
#undef TERMINATE
134
134
#define TERMINATE(A,B) {}
135
 
 
136
 
#ifdef __cplusplus
137
 
extern "C" {
138
 
#endif
139
 
 
140
 
typedef int  (*qsort_cmp)(const void *,const void *);
141
 
typedef int  (*qsort_cmp2)(void*, const void *,const void *);
142
 
 
 
135
#define QUICK_SAFEMALLOC
 
136
#define NORMAL_SAFEMALLOC
143
137
extern void *my_malloc(size_t Size,myf MyFlags);
144
138
#define my_malloc_ci(SZ,FLAG) my_malloc( SZ, FLAG )
145
139
extern void *my_realloc(void *oldpoint, size_t Size, myf MyFlags);
148
142
extern char *my_strdup(const char *from,myf MyFlags);
149
143
extern char *my_strndup(const char *from, size_t length,
150
144
                                   myf MyFlags);
 
145
/* we do use FG (as a no-op) in below so that a typo on FG is caught */
 
146
#define my_free(PTR,FG) ((void)FG,my_no_flags_free(PTR))
151
147
#define CALLER_INFO_PROTO   /* nothing */
152
148
#define CALLER_INFO         /* nothing */
153
149
#define ORIG_CALLER_INFO    /* nothing */
154
150
#define TRASH(A,B) /* nothing */
 
151
#endif
155
152
 
156
153
#ifdef HAVE_ALLOCA
157
154
#if defined(__GNUC__) && !defined(HAVE_ALLOCA_H) && ! defined(alloca)
158
155
#define alloca __builtin_alloca
159
156
#endif /* GNUC */
160
 
#define my_alloca(SZ) malloc((size_t) (SZ))
161
 
#define my_afree(PTR) free((PTR))
 
157
#define my_alloca(SZ) alloca((size_t) (SZ))
 
158
#define my_afree(PTR) {}
162
159
#else
163
 
#define my_alloca(SZ) malloc((SZ))
164
 
#define my_afree(PTR) free((PTR))
 
160
#define my_alloca(SZ) my_malloc(SZ,MYF(0))
 
161
#define my_afree(PTR) my_free(PTR,MYF(MY_WME))
165
162
#endif /* HAVE_ALLOCA */
166
163
 
167
164
#ifndef errno                           /* did we already get it? */
174
171
extern char errbuff[NRERRBUFFS][ERRMSGSIZE];
175
172
extern char *home_dir;                  /* Home directory for user */
176
173
extern const char *my_progname;         /* program-name (printed in errors) */
177
 
extern void (*error_handler_hook)(uint32_t my_err, const char *str,myf MyFlags);
178
 
extern void (*fatal_error_handler_hook)(uint32_t my_err, const char *str,
 
174
extern void (*error_handler_hook)(uint my_err, const char *str,myf MyFlags);
 
175
extern void (*fatal_error_handler_hook)(uint my_err, const char *str,
179
176
                                        myf MyFlags);
180
 
extern uint32_t my_file_limit;
 
177
extern uint my_file_limit;
181
178
extern uint32_t my_thread_stack_size;
182
179
 
183
180
/* charsets */
242
239
  int   rc_seek,error,inited;
243
240
  uint  rc_length,read_length,reclength;
244
241
  my_off_t rc_record_pos,end_of_file;
245
 
  unsigned char *rc_buff,*rc_buff2,*rc_pos,*rc_end,*rc_request_pos;
 
242
  uchar *rc_buff,*rc_buff2,*rc_pos,*rc_end,*rc_request_pos;
246
243
#ifdef HAVE_AIOWAIT
247
244
  int   use_async_io;
248
245
  my_aio_result aio_result;
269
266
 
270
267
typedef struct st_dynamic_array
271
268
{
272
 
  unsigned char *buffer;
273
 
  uint32_t elements,max_element;
274
 
  uint32_t alloc_increment;
275
 
  uint32_t size_of_element;
 
269
  uchar *buffer;
 
270
  uint elements,max_element;
 
271
  uint alloc_increment;
 
272
  uint size_of_element;
276
273
} DYNAMIC_ARRAY;
277
274
 
278
275
typedef struct st_my_tmpdir
279
276
{
280
277
  DYNAMIC_ARRAY full_list;
281
278
  char **list;
282
 
  uint32_t cur, max;
 
279
  uint cur, max;
283
280
  pthread_mutex_t mutex;
284
281
} MY_TMPDIR;
285
282
 
 
283
typedef struct st_dynamic_string
 
284
{
 
285
  char *str;
 
286
  size_t length,max_length,alloc_increment;
 
287
} DYNAMIC_STRING;
 
288
 
 
289
struct st_io_cache;
 
290
typedef int (*IO_CACHE_CALLBACK)(struct st_io_cache*);
 
291
 
 
292
typedef struct st_io_cache_share
 
293
{
 
294
  pthread_mutex_t       mutex;           /* To sync on reads into buffer. */
 
295
  pthread_cond_t        cond;            /* To wait for signals. */
 
296
  pthread_cond_t        cond_writer;     /* For a synchronized writer. */
 
297
  /* Offset in file corresponding to the first byte of buffer. */
 
298
  my_off_t              pos_in_file;
 
299
  /* If a synchronized write cache is the source of the data. */
 
300
  struct st_io_cache    *source_cache;
 
301
  uchar                 *buffer;         /* The read buffer. */
 
302
  uchar                 *read_end;       /* Behind last valid byte of buffer. */
 
303
  int                   running_threads; /* threads not in lock. */
 
304
  int                   total_threads;   /* threads sharing the cache. */
 
305
  int                   error;           /* Last error. */
 
306
#ifdef NOT_YET_IMPLEMENTED
 
307
  /* whether the structure should be free'd */
 
308
  bool alloced;
 
309
#endif
 
310
} IO_CACHE_SHARE;
 
311
 
 
312
typedef struct st_io_cache              /* Used when cacheing files */
 
313
{
 
314
  /* Offset in file corresponding to the first byte of uchar* buffer. */
 
315
  my_off_t pos_in_file;
 
316
  /*
 
317
    The offset of end of file for READ_CACHE and WRITE_CACHE.
 
318
    For SEQ_READ_APPEND it the maximum of the actual end of file and
 
319
    the position represented by read_end.
 
320
  */
 
321
  my_off_t end_of_file;
 
322
  /* Points to current read position in the buffer */
 
323
  uchar *read_pos;
 
324
  /* the non-inclusive boundary in the buffer for the currently valid read */
 
325
  uchar  *read_end;
 
326
  uchar  *buffer;                               /* The read buffer */
 
327
  /* Used in ASYNC_IO */
 
328
  uchar  *request_pos;
 
329
 
 
330
  /* Only used in WRITE caches and in SEQ_READ_APPEND to buffer writes */
 
331
  uchar  *write_buffer;
 
332
  /*
 
333
    Only used in SEQ_READ_APPEND, and points to the current read position
 
334
    in the write buffer. Note that reads in SEQ_READ_APPEND caches can
 
335
    happen from both read buffer (uchar* buffer) and write buffer
 
336
    (uchar* write_buffer).
 
337
  */
 
338
  uchar *append_read_pos;
 
339
  /* Points to current write position in the write buffer */
 
340
  uchar *write_pos;
 
341
  /* The non-inclusive boundary of the valid write area */
 
342
  uchar *write_end;
 
343
 
 
344
  /*
 
345
    Current_pos and current_end are convenience variables used by
 
346
    my_b_tell() and other routines that need to know the current offset
 
347
    current_pos points to &write_pos, and current_end to &write_end in a
 
348
    WRITE_CACHE, and &read_pos and &read_end respectively otherwise
 
349
  */
 
350
  uchar  **current_pos, **current_end;
 
351
  /*
 
352
    The lock is for append buffer used in SEQ_READ_APPEND cache
 
353
    need mutex copying from append buffer to read buffer.
 
354
  */
 
355
  pthread_mutex_t append_buffer_lock;
 
356
  /*
 
357
    The following is used when several threads are reading the
 
358
    same file in parallel. They are synchronized on disk
 
359
    accesses reading the cached part of the file asynchronously.
 
360
    It should be set to NULL to disable the feature.  Only
 
361
    READ_CACHE mode is supported.
 
362
  */
 
363
  IO_CACHE_SHARE *share;
 
364
  /*
 
365
    A caller will use my_b_read() macro to read from the cache
 
366
    if the data is already in cache, it will be simply copied with
 
367
    memcpy() and internal variables will be accordinging updated with
 
368
    no functions invoked. However, if the data is not fully in the cache,
 
369
    my_b_read() will call read_function to fetch the data. read_function
 
370
    must never be invoked directly.
 
371
  */
 
372
  int (*read_function)(struct st_io_cache *,uchar *,size_t);
 
373
  /*
 
374
    Same idea as in the case of read_function, except my_b_write() needs to
 
375
    be replaced with my_b_append() for a SEQ_READ_APPEND cache
 
376
  */
 
377
  int (*write_function)(struct st_io_cache *,const uchar *,size_t);
 
378
  /*
 
379
    Specifies the type of the cache. Depending on the type of the cache
 
380
    certain operations might not be available and yield unpredicatable
 
381
    results. Details to be documented later
 
382
  */
 
383
  enum cache_type type;
 
384
  /*
 
385
    Callbacks when the actual read I/O happens. These were added and
 
386
    are currently used for binary logging of LOAD DATA INFILE - when a
 
387
    block is read from the file, we create a block create/append event, and
 
388
    when IO_CACHE is closed, we create an end event. These functions could,
 
389
    of course be used for other things
 
390
  */
 
391
  IO_CACHE_CALLBACK pre_read;
 
392
  IO_CACHE_CALLBACK post_read;
 
393
  IO_CACHE_CALLBACK pre_close;
 
394
  /*
 
395
    Counts the number of times, when we were forced to use disk. We use it to
 
396
    increase the binlog_cache_disk_use status variable.
 
397
  */
 
398
  uint32_t disk_writes;
 
399
  void* arg;                            /* for use by pre/post_read */
 
400
  char *file_name;                      /* if used with 'open_cached_file' */
 
401
  char *dir,*prefix;
 
402
  File file; /* file descriptor */
 
403
  /*
 
404
    seek_not_done is set by my_b_seek() to inform the upcoming read/write
 
405
    operation that a seek needs to be preformed prior to the actual I/O
 
406
    error is 0 if the cache operation was successful, -1 if there was a
 
407
    "hard" error, and the actual number of I/O-ed bytes if the read/write was
 
408
    partial.
 
409
  */
 
410
  int   seek_not_done,error;
 
411
  /* buffer_length is memory size allocated for buffer or write_buffer */
 
412
  size_t        buffer_length;
 
413
  /* read_length is the same as buffer_length except when we use async io */
 
414
  size_t  read_length;
 
415
  myf   myflags;                        /* Flags used to my_read/my_write */
 
416
  /*
 
417
    alloced_buffer is 1 if the buffer was allocated by init_io_cache() and
 
418
    0 if it was supplied by the user.
 
419
    Currently READ_NET is the only one that will use a buffer allocated
 
420
    somewhere else
 
421
  */
 
422
  bool alloced_buffer;
 
423
#ifdef HAVE_AIOWAIT
 
424
  /*
 
425
    As inidicated by ifdef, this is for async I/O, which is not currently
 
426
    used (because it's not reliable on all systems)
 
427
  */
 
428
  uint inited;
 
429
  my_off_t aio_read_pos;
 
430
  my_aio_result aio_result;
 
431
#endif
 
432
} IO_CACHE;
286
433
 
287
434
typedef int (*qsort2_cmp)(const void *, const void *, const void *);
288
435
 
307
454
 
308
455
#define my_b_get(info) \
309
456
  ((info)->read_pos != (info)->read_end ?\
310
 
   ((info)->read_pos++, (int) (unsigned char) (info)->read_pos[-1]) :\
 
457
   ((info)->read_pos++, (int) (uchar) (info)->read_pos[-1]) :\
311
458
   _my_b_get(info))
312
459
 
313
460
        /* my_b_write_byte dosn't have any err-check */
327
474
  (char*) my_b_get_buffer_start(info)
328
475
#define my_b_get_pos_in_file(info) (info)->pos_in_file
329
476
 
 
477
/* tell write offset in the SEQ_APPEND cache */
 
478
int      my_b_copy_to_file(IO_CACHE *cache, FILE *file);
 
479
my_off_t my_b_append_tell(IO_CACHE* info);
 
480
my_off_t my_b_safe_tell(IO_CACHE* info); /* picks the correct tell() */
330
481
 
331
482
#define my_b_bytes_in_cache(info) (size_t) (*(info)->current_end - \
332
483
                                          *(info)->current_pos)
353
504
extern File my_open(const char *FileName,int Flags,myf MyFlags);
354
505
extern File my_register_filename(File fd, const char *FileName,
355
506
                                 enum file_type type_of_file,
356
 
                                 uint32_t error_message_number, myf MyFlags);
 
507
                                 uint error_message_number, myf MyFlags);
357
508
extern File my_create(const char *FileName,int CreateFlags,
358
509
                      int AccessFlags, myf MyFlags);
359
510
extern int my_close(File Filedes,myf MyFlags);
367
518
extern int my_delete_with_symlink(const char *name, myf MyFlags);
368
519
extern int my_rename_with_symlink(const char *from,const char *to,myf MyFlags);
369
520
extern int my_symlink(const char *content, const char *linkname, myf MyFlags);
370
 
extern size_t my_read(File Filedes,unsigned char *Buffer,size_t Count,myf MyFlags);
 
521
extern size_t my_read(File Filedes,uchar *Buffer,size_t Count,myf MyFlags);
371
522
extern int my_rename(const char *from,const char *to,myf MyFlags);
372
523
extern my_off_t my_seek(File fd,my_off_t pos,int whence,myf MyFlags);
373
524
extern my_off_t my_tell(File fd,myf MyFlags);
374
 
extern size_t my_write(File Filedes,const unsigned char *Buffer,size_t Count,
 
525
extern size_t my_write(File Filedes,const uchar *Buffer,size_t Count,
375
526
                     myf MyFlags);
376
 
extern size_t my_fwrite(FILE *stream,const unsigned char *Buffer,size_t Count,
 
527
extern size_t my_fwrite(FILE *stream,const uchar *Buffer,size_t Count,
377
528
                      myf MyFlags);
378
529
extern my_off_t my_fseek(FILE *stream,my_off_t pos,int whence,myf MyFlags);
379
530
extern void *_mymalloc(size_t uSize,const char *sFile,
380
 
                       uint32_t uLine, myf MyFlag);
 
531
                       uint uLine, myf MyFlag);
381
532
extern void *_myrealloc(void *pPtr,size_t uSize,const char *sFile,
382
 
                       uint32_t uLine, myf MyFlag);
383
 
extern void * my_multi_malloc (myf MyFlags, ...);
384
 
extern void _myfree(void *pPtr, const char *sFile, uint32_t uLine, myf MyFlag);
385
 
extern int _sanity(const char *sFile, uint32_t uLine);
 
533
                       uint uLine, myf MyFlag);
 
534
extern void * my_multi_malloc _VARARGS((myf MyFlags, ...));
 
535
extern void _myfree(void *pPtr,const char *sFile,uint uLine, myf MyFlag);
 
536
extern int _sanity(const char *sFile, uint uLine);
386
537
extern void *_my_memdup(const void *from, size_t length,
387
 
                        const char *sFile, uint32_t uLine,myf MyFlag);
388
 
extern char * _my_strdup(const char *from, const char *sFile, uint32_t uLine,
 
538
                        const char *sFile, uint uLine,myf MyFlag);
 
539
extern char * _my_strdup(const char *from, const char *sFile, uint uLine,
389
540
                         myf MyFlag);
390
541
extern char *_my_strndup(const char *from, size_t length,
391
 
                         const char *sFile, uint32_t uLine,
 
542
                         const char *sFile, uint uLine,
392
543
                         myf MyFlag);
393
544
 
394
545
#define my_access access
398
549
#define my_delete_allow_opened(fname,flags)  my_delete((fname),(flags))
399
550
 
400
551
#ifndef TERMINATE
401
 
extern void TERMINATE(FILE *file, uint32_t flag);
 
552
extern void TERMINATE(FILE *file, uint flag);
402
553
#endif
403
554
extern void init_glob_errs(void);
404
555
extern FILE *my_fopen(const char *FileName,int Flags,myf MyFlags);
406
557
extern int my_sync(File fd, myf my_flags);
407
558
extern int my_sync_dir(const char *dir_name, myf my_flags);
408
559
extern int my_sync_dir_by_file(const char *file_name, myf my_flags);
409
 
extern void my_error(int nr,myf MyFlags, ...);
410
 
extern void my_printf_error(uint32_t my_err, const char *format,
411
 
                            myf MyFlags, ...)
412
 
  __attribute__((format(printf, 2, 4)));
 
560
extern void my_error _VARARGS((int nr,myf MyFlags, ...));
 
561
extern void my_printf_error _VARARGS((uint my_err, const char *format,
 
562
                                      myf MyFlags, ...))
 
563
                                      __attribute__((format(printf, 2, 4)));
413
564
extern int my_error_register(const char **errmsgs, int first, int last);
414
565
extern const char **my_error_unregister(int first, int last);
415
 
extern void my_message(uint32_t my_err, const char *str,myf MyFlags);
416
 
extern void my_message_no_curses(uint32_t my_err, const char *str,myf MyFlags);
 
566
extern void my_message(uint my_err, const char *str,myf MyFlags);
 
567
extern void my_message_no_curses(uint my_err, const char *str,myf MyFlags);
417
568
extern bool my_init(void);
418
569
extern void my_end(int infoflag);
419
570
extern int my_redel(const char *from, const char *to, int MyFlags);
430
581
extern char *my_tmpdir(MY_TMPDIR *tmpdir);
431
582
extern void free_tmpdir(MY_TMPDIR *tmpdir);
432
583
 
433
 
extern void my_remember_signal(int signal_number,RETSIGTYPE (*func)(int));
 
584
extern void my_remember_signal(int signal_number,sig_handler (*func)(int));
434
585
extern size_t dirname_part(char * to,const char *name, size_t *to_res_length);
435
586
extern size_t dirname_length(const char *name);
436
587
#define base_name(A) (A+dirname_length(A))
441
592
extern char * fn_ext(const char *name);
442
593
extern char * fn_same(char * toname,const char *name,int flag);
443
594
extern char * fn_format(char * to,const char *name,const char *dir,
444
 
                           const char *form, uint32_t flag);
 
595
                           const char *form, uint flag);
445
596
extern size_t strlength(const char *str);
446
597
extern void pack_dirname(char * to,const char *from);
447
598
extern size_t unpack_dirname(char * to,const char *from);
468
619
extern int init_record_cache(RECORD_CACHE *info,size_t cachesize,File file,
469
620
                             size_t reclength,enum cache_type type,
470
621
                             bool use_async_io);
471
 
extern int read_cache_record(RECORD_CACHE *info,unsigned char *to);
 
622
extern int read_cache_record(RECORD_CACHE *info,uchar *to);
472
623
extern int end_record_cache(RECORD_CACHE *info);
473
624
extern int write_cache_record(RECORD_CACHE *info,my_off_t filepos,
474
 
                              const unsigned char *record,size_t length);
 
625
                              const uchar *record,size_t length);
475
626
extern int flush_write_cache(RECORD_CACHE *info);
476
 
extern RETSIGTYPE sigtstp_handler(int signal_number);
 
627
extern sig_handler sigtstp_handler(int signal_number);
477
628
extern void handle_recived_signals(void);
478
629
 
479
 
extern RETSIGTYPE my_set_alarm_variable(int signo);
480
 
extern void my_string_ptr_sort(unsigned char *base,uint32_t items,size_t size);
481
 
extern void radixsort_for_str_ptr(unsigned char* base[], uint32_t number_of_elements,
482
 
                                  size_t size_of_element,unsigned char *buffer[]);
483
 
extern RETQSORTTYPE my_qsort(void *base_ptr, size_t total_elems, size_t size,
484
 
                             qsort_cmp cmp);
485
 
extern RETQSORTTYPE my_qsort2(void *base_ptr, size_t total_elems, size_t size,
486
 
                              qsort2_cmp cmp, void *cmp_argument);
 
630
extern sig_handler my_set_alarm_variable(int signo);
 
631
extern void my_string_ptr_sort(uchar *base,uint items,size_t size);
 
632
extern void radixsort_for_str_ptr(uchar* base[], uint number_of_elements,
 
633
                                  size_t size_of_element,uchar *buffer[]);
 
634
extern qsort_t my_qsort(void *base_ptr, size_t total_elems, size_t size,
 
635
                        qsort_cmp cmp);
 
636
extern qsort_t my_qsort2(void *base_ptr, size_t total_elems, size_t size,
 
637
                         qsort2_cmp cmp, void *cmp_argument);
487
638
extern qsort2_cmp get_ptr_compare(size_t);
488
 
void my_store_ptr(unsigned char *buff, size_t pack_length, my_off_t pos);
489
 
my_off_t my_get_ptr(unsigned char *ptr, size_t pack_length);
 
639
void my_store_ptr(uchar *buff, size_t pack_length, my_off_t pos);
 
640
my_off_t my_get_ptr(uchar *ptr, size_t pack_length);
 
641
extern int init_io_cache(IO_CACHE *info,File file,size_t cachesize,
 
642
                         enum cache_type type,my_off_t seek_offset,
 
643
                         bool use_async_io, myf cache_myflags);
 
644
extern bool reinit_io_cache(IO_CACHE *info,enum cache_type type,
 
645
                               my_off_t seek_offset,bool use_async_io,
 
646
                               bool clear_cache);
 
647
extern void setup_io_cache(IO_CACHE* info);
 
648
extern int _my_b_read(IO_CACHE *info,uchar *Buffer,size_t Count);
 
649
extern int _my_b_read_r(IO_CACHE *info,uchar *Buffer,size_t Count);
 
650
extern void init_io_cache_share(IO_CACHE *read_cache, IO_CACHE_SHARE *cshare,
 
651
                                IO_CACHE *write_cache, uint num_threads);
 
652
extern void remove_io_thread(IO_CACHE *info);
 
653
extern int _my_b_seq_read(IO_CACHE *info,uchar *Buffer,size_t Count);
 
654
extern int _my_b_net_read(IO_CACHE *info,uchar *Buffer,size_t Count);
 
655
extern int _my_b_get(IO_CACHE *info);
 
656
extern int _my_b_async_read(IO_CACHE *info,uchar *Buffer,size_t Count);
 
657
extern int _my_b_write(IO_CACHE *info,const uchar *Buffer,size_t Count);
 
658
extern int my_b_append(IO_CACHE *info,const uchar *Buffer,size_t Count);
 
659
extern int my_b_safe_write(IO_CACHE *info,const uchar *Buffer,size_t Count);
 
660
 
 
661
extern int my_block_write(IO_CACHE *info, const uchar *Buffer,
 
662
                          size_t Count, my_off_t pos);
 
663
extern int my_b_flush_io_cache(IO_CACHE *info, int need_append_buffer_lock);
 
664
 
 
665
#define flush_io_cache(info) my_b_flush_io_cache((info),1)
 
666
 
 
667
extern int end_io_cache(IO_CACHE *info);
 
668
extern size_t my_b_fill(IO_CACHE *info);
 
669
extern void my_b_seek(IO_CACHE *info,my_off_t pos);
 
670
extern size_t my_b_gets(IO_CACHE *info, char *to, size_t max_length);
 
671
extern my_off_t my_b_filelength(IO_CACHE *info);
 
672
extern size_t my_b_printf(IO_CACHE *info, const char* fmt, ...);
 
673
extern size_t my_b_vprintf(IO_CACHE *info, const char* fmt, va_list ap);
 
674
extern bool open_cached_file(IO_CACHE *cache,const char *dir,
 
675
                                 const char *prefix, size_t cache_size,
 
676
                                 myf cache_myflags);
 
677
extern bool real_open_cached_file(IO_CACHE *cache);
 
678
extern void close_cached_file(IO_CACHE *cache);
490
679
File create_temp_file(char *to, const char *dir, const char *pfx,
491
680
                      int mode, myf MyFlags);
492
681
#define my_init_dynamic_array(A,B,C,D) init_dynamic_array2(A,B,NULL,C,D CALLER_INFO)
493
682
#define my_init_dynamic_array_ci(A,B,C,D) init_dynamic_array2(A,B,NULL,C,D ORIG_CALLER_INFO)
494
683
#define my_init_dynamic_array2(A,B,C,D,E) init_dynamic_array2(A,B,C,D,E CALLER_INFO)
495
684
#define my_init_dynamic_array2_ci(A,B,C,D,E) init_dynamic_array2(A,B,C,D,E ORIG_CALLER_INFO)
496
 
extern bool init_dynamic_array2(DYNAMIC_ARRAY *array,uint32_t element_size,
497
 
                                   void *init_buffer, uint32_t init_alloc, 
498
 
                                   uint32_t alloc_increment
 
685
extern bool init_dynamic_array2(DYNAMIC_ARRAY *array,uint element_size,
 
686
                                   void *init_buffer, uint init_alloc, 
 
687
                                   uint alloc_increment
499
688
                                   CALLER_INFO_PROTO);
500
689
/* init_dynamic_array() function is deprecated */
501
 
extern bool init_dynamic_array(DYNAMIC_ARRAY *array,uint32_t element_size,
502
 
                                  uint32_t init_alloc,uint32_t alloc_increment
 
690
extern bool init_dynamic_array(DYNAMIC_ARRAY *array,uint element_size,
 
691
                                  uint init_alloc,uint alloc_increment
503
692
                                  CALLER_INFO_PROTO);
504
 
extern bool insert_dynamic(DYNAMIC_ARRAY *array,unsigned char * element);
505
 
extern unsigned char *alloc_dynamic(DYNAMIC_ARRAY *array);
506
 
extern unsigned char *pop_dynamic(DYNAMIC_ARRAY*);
507
 
extern bool set_dynamic(DYNAMIC_ARRAY *array,unsigned char * element,uint32_t array_index);
508
 
extern bool allocate_dynamic(DYNAMIC_ARRAY *array, uint32_t max_elements);
509
 
extern void get_dynamic(DYNAMIC_ARRAY *array,unsigned char * element,uint32_t array_index);
 
693
extern bool insert_dynamic(DYNAMIC_ARRAY *array,uchar * element);
 
694
extern uchar *alloc_dynamic(DYNAMIC_ARRAY *array);
 
695
extern uchar *pop_dynamic(DYNAMIC_ARRAY*);
 
696
extern bool set_dynamic(DYNAMIC_ARRAY *array,uchar * element,uint array_index);
 
697
extern bool allocate_dynamic(DYNAMIC_ARRAY *array, uint max_elements);
 
698
extern void get_dynamic(DYNAMIC_ARRAY *array,uchar * element,uint array_index);
510
699
extern void delete_dynamic(DYNAMIC_ARRAY *array);
511
 
extern void delete_dynamic_element(DYNAMIC_ARRAY *array, uint32_t array_index);
 
700
extern void delete_dynamic_element(DYNAMIC_ARRAY *array, uint array_index);
512
701
extern void freeze_size(DYNAMIC_ARRAY *array);
513
 
extern int  get_index_dynamic(DYNAMIC_ARRAY *array, unsigned char * element);
 
702
extern int  get_index_dynamic(DYNAMIC_ARRAY *array, uchar * element);
514
703
#define dynamic_array_ptr(array,array_index) ((array)->buffer+(array_index)*(array)->size_of_element)
515
704
#define dynamic_element(array,array_index,type) ((type)((array)->buffer) +(array_index))
516
705
#define push_dynamic(A,B) insert_dynamic((A),(B))
517
706
#define reset_dynamic(array) ((array)->elements= 0)
518
707
#define sort_dynamic(A,cmp) my_qsort((A)->buffer, (A)->elements, (A)->size_of_element, (cmp))
519
708
 
 
709
extern bool init_dynamic_string(DYNAMIC_STRING *str, const char *init_str,
 
710
                                   size_t init_alloc,size_t alloc_increment);
 
711
extern bool dynstr_append(DYNAMIC_STRING *str, const char *append);
 
712
bool dynstr_append_mem(DYNAMIC_STRING *str, const char *append,
 
713
                          size_t length);
 
714
extern bool dynstr_append_os_quoted(DYNAMIC_STRING *str, const char *append,
 
715
                                       ...);
 
716
extern bool dynstr_set(DYNAMIC_STRING *str, const char *init_str);
 
717
extern bool dynstr_realloc(DYNAMIC_STRING *str, size_t additional_size);
 
718
extern bool dynstr_trunc(DYNAMIC_STRING *str, size_t n);
 
719
extern void dynstr_free(DYNAMIC_STRING *str);
520
720
#define my_malloc_lock(A,B) my_malloc((A),(B))
 
721
#define my_free_lock(A,B) my_free((A),(B))
521
722
#define alloc_root_inited(A) ((A)->min_malloc != 0)
522
723
#define ALLOC_ROOT_MIN_BLOCK_SIZE (MALLOC_OVERHEAD + sizeof(USED_MEM) + 8)
523
724
#define clear_alloc_root(A) do { (A)->free= (A)->used= (A)->pre_alloc= 0; (A)->min_malloc=0;} while(0)
 
725
extern void init_alloc_root(MEM_ROOT *mem_root, size_t block_size,
 
726
                            size_t pre_alloc_size);
 
727
extern void *alloc_root(MEM_ROOT *mem_root, size_t Size);
 
728
extern void *multi_alloc_root(MEM_ROOT *mem_root, ...);
 
729
extern void free_root(MEM_ROOT *root, myf MyFLAGS);
 
730
extern void set_prealloc_root(MEM_ROOT *root, char *ptr);
 
731
extern void reset_root_defaults(MEM_ROOT *mem_root, size_t block_size,
 
732
                                size_t prealloc_size);
 
733
extern char *strdup_root(MEM_ROOT *root,const char *str);
 
734
extern char *strmake_root(MEM_ROOT *root,const char *str,size_t len);
 
735
extern void *memdup_root(MEM_ROOT *root,const void *str, size_t len);
524
736
extern int get_defaults_options(int argc, char **argv,
525
737
                                char **defaults, char **extra_defaults,
526
738
                                char **group_suffix);
530
742
                                const char *option_value,
531
743
                                const char *section_name, int remove_option);
532
744
extern int my_search_option_files(const char *conf_file, int *argc,
533
 
                                  char ***argv, uint32_t *args_used,
 
745
                                  char ***argv, uint *args_used,
534
746
                                  Process_option_func func, void *func_ctx);
535
747
extern void free_defaults(char **argv);
536
748
extern void my_print_default_files(const char *conf_file);
537
749
extern void print_defaults(const char *conf_file, const char **groups);
538
 
extern ha_checksum my_checksum(ha_checksum crc, const unsigned char *mem,
 
750
extern bool my_compress(uchar *, size_t *, size_t *);
 
751
extern bool my_uncompress(uchar *, size_t , size_t *);
 
752
extern uchar *my_compress_alloc(const uchar *packet, size_t *len,
 
753
                                size_t *complen);
 
754
extern ha_checksum my_checksum(ha_checksum crc, const uchar *mem,
539
755
                               size_t count);
540
756
extern void my_sleep(uint32_t m_seconds);
541
 
extern uint32_t my_set_max_open_files(uint32_t files);
 
757
extern uint my_set_max_open_files(uint files);
542
758
void my_free_open_file_info(void);
543
759
 
544
760
extern time_t my_time(myf flags);
546
762
extern uint64_t my_micro_time(void);
547
763
extern uint64_t my_micro_time_and_time(time_t *time_arg);
548
764
time_t my_time_possible_from_micro(uint64_t microtime);
549
 
extern bool my_gethwaddr(unsigned char *to);
 
765
extern bool my_gethwaddr(uchar *to);
550
766
 
551
767
#ifdef HAVE_SYS_MMAN_H
552
768
#include <sys/mman.h>
582
798
#endif
583
799
 
584
800
/* character sets */
585
 
extern uint32_t get_charset_number(const char *cs_name, uint32_t cs_flags);
586
 
extern uint32_t get_collation_number(const char *name);
587
 
extern const char *get_charset_name(uint32_t cs_number);
 
801
extern uint get_charset_number(const char *cs_name, uint cs_flags);
 
802
extern uint get_collation_number(const char *name);
 
803
extern const char *get_charset_name(uint cs_number);
588
804
 
589
 
extern const CHARSET_INFO *get_charset(uint32_t cs_number, myf flags);
 
805
extern const CHARSET_INFO *get_charset(uint cs_number, myf flags);
590
806
extern const CHARSET_INFO *get_charset_by_name(const char *cs_name, myf flags);
591
 
extern const CHARSET_INFO *get_charset_by_csname(const char *cs_name, uint32_t cs_flags, myf my_flags);
 
807
extern const CHARSET_INFO *get_charset_by_csname(const char *cs_name, uint cs_flags, myf my_flags);
592
808
 
593
809
extern bool resolve_charset(const char *cs_name,
594
810
                            const CHARSET_INFO *default_cs,
613
829
extern void thd_increment_bytes_received(uint32_t length);
614
830
extern void thd_increment_net_big_packet_count(uint32_t length);
615
831
 
616
 
#ifdef __cplusplus
617
 
}
618
 
#endif
619
 
 
 
832
C_MODE_END
620
833
#endif /* _my_sys_h */