← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to mysys/my_sys.h

Merged in latest plugin-slot-reorg.

Show diffs side-by-side

added added

removed removed

Lines of Context:
mysys/my_sys.h
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 */
 
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
 */
15
20
 
16
21
#ifndef _my_sys_h
17
22
#define _my_sys_h
18
23
 
19
 
#ifdef HAVE_AIOWAIT
20
 
#include <sys/asynch.h>                 /* Used by record-cache */
21
 
typedef struct my_aio_result {
22
 
  aio_result_t result;
23
 
  int          pending;
24
 
} my_aio_result;
25
 
#endif
26
 
 
27
24
#include <errno.h>
28
25
#define my_errno (errno)
29
26
 
32
29
#include <mystrings/m_ctype.h>                    /* for CHARSET_INFO */
33
30
#include <stdarg.h>
34
31
#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
35
40
 
36
41
#define MY_INIT(name);          { my_progname= name; my_init(); }
37
42
 
 
43
/* Max width of screen (for error messages) */
 
44
#define SC_MAXWIDTH 256
38
45
#define ERRMSGSIZE      (SC_MAXWIDTH)   /* Max length of a error message */
39
46
#define NRERRBUFFS      (2)     /* Buffers for parameters */
40
47
#define MY_FILE_ERROR   ((size_t) -1)
48
55
#define MY_WAIT_IF_FULL 32      /* Wait and try again if disk full error */
49
56
#define MY_IGNORE_BADFD 32      /* my_sync: ignore 'bad descriptor' errors */
50
57
#define MY_SYNC_DIR     1024    /* my_create/delete/rename: sync directory */
51
 
#define MY_RAID         64      /* Support for RAID */
52
58
#define MY_FULL_IO     512      /* For my_read - loop intil I/O is complete */
53
59
#define MY_DONT_CHECK_FILESIZE 128 /* Option to init_io_cache() */
54
60
#define MY_LINK_WARNING 32      /* my_redel() gives warning if links */
57
63
#define MY_RESOLVE_LINK 128     /* my_realpath(); Only resolve links */
58
64
#define MY_HOLD_ORIGINAL_MODES 128  /* my_copy() holds to file modes */
59
65
#define MY_REDEL_MAKE_BACKUP 256
60
 
#define MY_SEEK_NOT_DONE 32     /* my_lock may have to do a seek */
61
66
#define MY_DONT_WAIT    64      /* my_lock() don't wait if can't lock */
62
 
#define MY_ZEROFILL     32      /* my_malloc(), fill array with zero */
63
 
#define MY_ALLOW_ZERO_PTR 64    /* my_realloc() ; zero ptr -> malloc */
64
 
#define MY_FREE_ON_ERROR 128    /* my_realloc() ; Free old ptr on error */
65
 
#define MY_HOLD_ON_ERROR 256    /* my_realloc() ; Return old ptr on error */
 
67
#define MY_ZEROFILL     32      /* my_multi_malloc(), fill array with zero */
66
68
#define MY_DONT_OVERWRITE_FILE 1024     /* my_copy: Don't overwrite file */
67
69
#define MY_THREADSAFE 2048      /* my_seek(): lock fd mutex */
68
70
 
69
71
#define MY_CHECK_ERROR  1       /* Params to my_end; Check open-close */
70
72
#define MY_GIVE_INFO    2       /* Give time info about process*/
71
73
 
72
 
#define MY_REMOVE_NONE    0     /* Params for modify_defaults_file */
73
 
#define MY_REMOVE_OPTION  1
74
 
#define MY_REMOVE_SECTION 2
75
 
 
76
74
#define ME_HIGHBYTE     8       /* Shift for colours */
77
75
#define ME_NOCUR        1       /* Don't use curses message */
78
76
#define ME_OLDWIN       2       /* Use old window */
99
97
#define MY_APPEND_EXT           256     /* add 'ext' as additional extension*/
100
98
 
101
99
 
102
 
        /* My seek flags */
103
 
#define MY_SEEK_SET     0
104
 
#define MY_SEEK_CUR     1
105
 
#define MY_SEEK_END     2
106
 
 
107
100
        /* Some constants */
108
101
#define MY_WAIT_FOR_USER_TO_FIX_PANIC   60      /* in seconds */
109
102
#define MY_WAIT_GIVE_USER_A_MESSAGE     10      /* Every 10 times of prev */
136
129
typedef int  (*qsort_cmp)(const void *,const void *);
137
130
typedef int  (*qsort_cmp2)(void*, const void *,const void *);
138
131
 
139
 
extern void *my_malloc(size_t Size,myf MyFlags);
140
 
#define my_malloc_ci(SZ,FLAG) my_malloc( SZ, FLAG )
141
 
extern void *my_realloc(void *oldpoint, size_t Size, myf MyFlags);
142
 
extern void my_no_flags_free(void *ptr);
143
 
extern void *my_memdup(const void *from,size_t length,myf MyFlags);
144
 
extern char *my_strdup(const char *from,myf MyFlags);
145
 
extern char *my_strndup(const char *from, size_t length,
146
 
                                   myf MyFlags);
147
 
#define CALLER_INFO_PROTO   /* nothing */
148
 
#define CALLER_INFO         /* nothing */
149
 
#define ORIG_CALLER_INFO    /* nothing */
150
132
#define TRASH(A,B) /* nothing */
151
133
 
152
 
#ifdef HAVE_ALLOCA
153
 
#if defined(__GNUC__) && !defined(HAVE_ALLOCA_H) && ! defined(alloca)
154
 
#define alloca __builtin_alloca
155
 
#endif /* GNUC */
156
 
#define my_alloca(SZ) malloc((size_t) (SZ))
157
 
#define my_afree(PTR) free((PTR))
158
 
#else
159
 
#define my_alloca(SZ) malloc((SZ))
160
 
#define my_afree(PTR) free((PTR))
161
 
#endif /* HAVE_ALLOCA */
162
 
 
163
134
#ifndef errno                           /* did we already get it? */
164
135
#ifdef HAVE_ERRNO_AS_DEFINE
165
136
#include <errno.h>                      /* errno is a define */
167
138
extern int errno;                       /* declare errno */
168
139
#endif
169
140
#endif                                  /* #ifndef errno */
170
 
extern char errbuff[NRERRBUFFS][ERRMSGSIZE];
171
141
extern char *home_dir;                  /* Home directory for user */
172
142
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
 
                                        myf MyFlags);
 
143
typedef void (*error_handler_func)(uint32_t my_err, const char *str,myf MyFlags);
 
144
extern error_handler_func error_handler_hook;
176
145
extern uint32_t my_file_limit;
177
 
extern uint32_t my_thread_stack_size;
178
146
 
179
147
/* charsets */
180
148
extern const CHARSET_INFO *default_charset_info;
187
155
extern uint     mysys_usage_id;
188
156
extern bool     my_init_done;
189
157
 
 
158
typedef void (*void_ptr_func)(void);
 
159
typedef void (*void_ptr_int_func)(int);
 
160
 
190
161
                                        /* Point to current my_message() */
191
 
extern void (*my_sigtstp_cleanup)(void),
 
162
extern void_ptr_func my_sigtstp_cleanup,
192
163
                                        /* Executed before jump to shell */
193
 
            (*my_sigtstp_restart)(void),
194
 
            (*my_abort_hook)(int);
 
164
            my_sigtstp_restart;
195
165
                                        /* Executed when comming from shell */
196
166
extern int my_umask,            /* Default creation mask  */
197
167
           my_umask_dir,
246
216
  enum cache_type type;
247
217
} RECORD_CACHE;
248
218
 
249
 
enum file_type
250
 
{
251
 
  UNOPEN = 0, FILE_BY_OPEN, FILE_BY_CREATE, STREAM_BY_FOPEN, STREAM_BY_FDOPEN,
252
 
  FILE_BY_MKSTEMP, FILE_BY_DUP
253
 
};
254
 
 
255
 
struct st_my_file_info
256
 
{
257
 
  char *                name;
258
 
  enum file_type        type;
259
 
#if !defined(HAVE_PREAD)
260
 
  pthread_mutex_t       mutex;
261
 
#endif
262
 
};
263
 
 
264
 
extern struct st_my_file_info *my_file_info;
265
 
 
266
 
typedef struct st_dynamic_array
267
 
{
268
 
  unsigned char *buffer;
269
 
  uint32_t elements,max_element;
270
 
  uint32_t alloc_increment;
271
 
  uint32_t size_of_element;
272
 
} DYNAMIC_ARRAY;
273
 
 
274
 
typedef struct st_my_tmpdir
275
 
{
276
 
  DYNAMIC_ARRAY full_list;
277
 
  char **list;
278
 
  uint32_t cur, max;
279
 
  pthread_mutex_t mutex;
280
 
} MY_TMPDIR;
281
 
 
282
 
struct st_io_cache;
283
 
typedef int (*IO_CACHE_CALLBACK)(struct st_io_cache*);
284
 
 
285
 
typedef struct st_io_cache_share
286
 
{
287
 
  pthread_mutex_t       mutex;           /* To sync on reads into buffer. */
288
 
  pthread_cond_t        cond;            /* To wait for signals. */
289
 
  pthread_cond_t        cond_writer;     /* For a synchronized writer. */
290
 
  /* Offset in file corresponding to the first byte of buffer. */
291
 
  my_off_t              pos_in_file;
292
 
  /* If a synchronized write cache is the source of the data. */
293
 
  struct st_io_cache    *source_cache;
294
 
  unsigned char                 *buffer;         /* The read buffer. */
295
 
  unsigned char                 *read_end;       /* Behind last valid byte of buffer. */
296
 
  int                   running_threads; /* threads not in lock. */
297
 
  int                   total_threads;   /* threads sharing the cache. */
298
 
  int                   error;           /* Last error. */
299
 
#ifdef NOT_YET_IMPLEMENTED
300
 
  /* whether the structure should be free'd */
301
 
  bool alloced;
302
 
#endif
303
 
} IO_CACHE_SHARE;
304
 
 
305
 
typedef struct st_io_cache              /* Used when cacheing files */
306
 
{
307
 
  /* Offset in file corresponding to the first byte of unsigned char* buffer. */
308
 
  my_off_t pos_in_file;
309
 
  /*
310
 
    The offset of end of file for READ_CACHE and WRITE_CACHE.
311
 
    For SEQ_READ_APPEND it the maximum of the actual end of file and
312
 
    the position represented by read_end.
313
 
  */
314
 
  my_off_t end_of_file;
315
 
  /* Points to current read position in the buffer */
316
 
  unsigned char *read_pos;
317
 
  /* the non-inclusive boundary in the buffer for the currently valid read */
318
 
  unsigned char  *read_end;
319
 
  unsigned char  *buffer;                               /* The read buffer */
320
 
  /* Used in ASYNC_IO */
321
 
  unsigned char  *request_pos;
322
 
 
323
 
  /* Only used in WRITE caches and in SEQ_READ_APPEND to buffer writes */
324
 
  unsigned char  *write_buffer;
325
 
  /*
326
 
    Only used in SEQ_READ_APPEND, and points to the current read position
327
 
    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).
330
 
  */
331
 
  unsigned char *append_read_pos;
332
 
  /* Points to current write position in the write buffer */
333
 
  unsigned char *write_pos;
334
 
  /* The non-inclusive boundary of the valid write area */
335
 
  unsigned char *write_end;
336
 
 
337
 
  /*
338
 
    Current_pos and current_end are convenience variables used by
339
 
    my_b_tell() and other routines that need to know the current offset
340
 
    current_pos points to &write_pos, and current_end to &write_end in a
341
 
    WRITE_CACHE, and &read_pos and &read_end respectively otherwise
342
 
  */
343
 
  unsigned char  **current_pos, **current_end;
344
 
  /*
345
 
    The lock is for append buffer used in SEQ_READ_APPEND cache
346
 
    need mutex copying from append buffer to read buffer.
347
 
  */
348
 
  pthread_mutex_t append_buffer_lock;
349
 
  /*
350
 
    The following is used when several threads are reading the
351
 
    same file in parallel. They are synchronized on disk
352
 
    accesses reading the cached part of the file asynchronously.
353
 
    It should be set to NULL to disable the feature.  Only
354
 
    READ_CACHE mode is supported.
355
 
  */
356
 
  IO_CACHE_SHARE *share;
357
 
  /*
358
 
    A caller will use my_b_read() macro to read from the cache
359
 
    if the data is already in cache, it will be simply copied with
360
 
    memcpy() and internal variables will be accordinging updated with
361
 
    no functions invoked. However, if the data is not fully in the cache,
362
 
    my_b_read() will call read_function to fetch the data. read_function
363
 
    must never be invoked directly.
364
 
  */
365
 
  int (*read_function)(struct st_io_cache *,unsigned char *,size_t);
366
 
  /*
367
 
    Same idea as in the case of read_function, except my_b_write() needs to
368
 
    be replaced with my_b_append() for a SEQ_READ_APPEND cache
369
 
  */
370
 
  int (*write_function)(struct st_io_cache *,const unsigned char *,size_t);
371
 
  /*
372
 
    Specifies the type of the cache. Depending on the type of the cache
373
 
    certain operations might not be available and yield unpredicatable
374
 
    results. Details to be documented later
375
 
  */
376
 
  enum cache_type type;
377
 
  /*
378
 
    Callbacks when the actual read I/O happens. These were added and
379
 
    are currently used for binary logging of LOAD DATA INFILE - when a
380
 
    block is read from the file, we create a block create/append event, and
381
 
    when IO_CACHE is closed, we create an end event. These functions could,
382
 
    of course be used for other things
383
 
  */
384
 
  IO_CACHE_CALLBACK pre_read;
385
 
  IO_CACHE_CALLBACK post_read;
386
 
  IO_CACHE_CALLBACK pre_close;
387
 
  /*
388
 
    Counts the number of times, when we were forced to use disk. We use it to
389
 
    increase the binlog_cache_disk_use status variable.
390
 
  */
391
 
  uint32_t disk_writes;
392
 
  void* arg;                            /* for use by pre/post_read */
393
 
  char *file_name;                      /* if used with 'open_cached_file' */
394
 
  char *dir,*prefix;
395
 
  File file; /* file descriptor */
396
 
  /*
397
 
    seek_not_done is set by my_b_seek() to inform the upcoming read/write
398
 
    operation that a seek needs to be preformed prior to the actual I/O
399
 
    error is 0 if the cache operation was successful, -1 if there was a
400
 
    "hard" error, and the actual number of I/O-ed bytes if the read/write was
401
 
    partial.
402
 
  */
403
 
  int   seek_not_done,error;
404
 
  /* buffer_length is memory size allocated for buffer or write_buffer */
405
 
  size_t        buffer_length;
406
 
  /* read_length is the same as buffer_length except when we use async io */
407
 
  size_t  read_length;
408
 
  myf   myflags;                        /* Flags used to my_read/my_write */
409
 
  /*
410
 
    alloced_buffer is 1 if the buffer was allocated by init_io_cache() and
411
 
    0 if it was supplied by the user.
412
 
    Currently READ_NET is the only one that will use a buffer allocated
413
 
    somewhere else
414
 
  */
415
 
  bool alloced_buffer;
416
 
#ifdef HAVE_AIOWAIT
417
 
  /*
418
 
    As inidicated by ifdef, this is for async I/O, which is not currently
419
 
    used (because it's not reliable on all systems)
420
 
  */
421
 
  uint32_t inited;
422
 
  my_off_t aio_read_pos;
423
 
  my_aio_result aio_result;
424
 
#endif
425
 
} IO_CACHE;
426
219
 
427
220
typedef int (*qsort2_cmp)(const void *, const void *, const void *);
428
221
 
462
255
#define my_b_tell(info) ((info)->pos_in_file + \
463
256
                         (size_t) (*(info)->current_pos - (info)->request_pos))
464
257
 
465
 
#define my_b_get_buffer_start(info) (info)->request_pos 
 
258
#define my_b_get_buffer_start(info) (info)->request_pos
466
259
#define my_b_get_bytes_in_buffer(info) (char*) (info)->read_end -   \
467
260
  (char*) my_b_get_buffer_start(info)
468
261
#define my_b_get_pos_in_file(info) (info)->pos_in_file
469
262
 
470
 
/* tell write offset in the SEQ_APPEND cache */
471
 
int      my_b_copy_to_file(IO_CACHE *cache, FILE *file);
472
 
my_off_t my_b_append_tell(IO_CACHE* info);
473
 
my_off_t my_b_safe_tell(IO_CACHE* info); /* picks the correct tell() */
474
263
 
475
264
#define my_b_bytes_in_cache(info) (size_t) (*(info)->current_end - \
476
265
                                          *(info)->current_pos)
481
270
typedef int (*Process_option_func)(void *ctx, const char *group_name,
482
271
                                   const char *option);
483
272
 
 
273
int handle_default_option(void *in_ctx, const char *group_name,
 
274
                          const char *option);
 
275
 
484
276
#include <mysys/my_alloc.h>
485
277
 
486
278
 
488
280
 
489
281
extern int my_copy(const char *from,const char *to,myf MyFlags);
490
282
extern int my_delete(const char *name,myf MyFlags);
491
 
extern int my_getwd(char * buf,size_t size,myf MyFlags);
492
 
extern int my_setwd(const char *dir,myf MyFlags);
493
 
extern void *my_once_alloc(size_t Size,myf MyFlags);
494
 
extern void my_once_free(void);
495
 
extern char *my_once_strdup(const char *src,myf myflags);
496
 
extern void *my_once_memdup(const void *src, size_t len, myf myflags);
497
283
extern File my_open(const char *FileName,int Flags,myf MyFlags);
498
284
extern File my_register_filename(File fd, const char *FileName,
499
 
                                 enum file_type type_of_file,
500
285
                                 uint32_t error_message_number, myf MyFlags);
501
286
extern File my_create(const char *FileName,int CreateFlags,
502
287
                      int AccessFlags, myf MyFlags);
503
288
extern int my_close(File Filedes,myf MyFlags);
504
289
extern File my_dup(File file, myf MyFlags);
505
290
extern int my_mkdir(const char *dir, int Flags, myf MyFlags);
506
 
extern int my_readlink(char *to, const char *filename, myf MyFlags);
507
291
extern int my_realpath(char *to, const char *filename, myf MyFlags);
508
292
extern File my_create_with_symlink(const char *linkname, const char *filename,
509
293
                                   int createflags, int access_flags,
510
294
                                   myf MyFlags);
511
295
extern int my_delete_with_symlink(const char *name, myf MyFlags);
512
296
extern int my_rename_with_symlink(const char *from,const char *to,myf MyFlags);
513
 
extern int my_symlink(const char *content, const char *linkname, myf MyFlags);
514
297
extern size_t my_read(File Filedes,unsigned char *Buffer,size_t Count,myf MyFlags);
515
298
extern int my_rename(const char *from,const char *to,myf MyFlags);
516
 
extern my_off_t my_seek(File fd,my_off_t pos,int whence,myf MyFlags);
517
 
extern my_off_t my_tell(File fd,myf MyFlags);
518
299
extern size_t my_write(File Filedes,const unsigned char *Buffer,size_t Count,
519
300
                     myf MyFlags);
520
 
extern size_t my_fwrite(FILE *stream,const unsigned char *Buffer,size_t Count,
521
 
                      myf MyFlags);
522
 
extern my_off_t my_fseek(FILE *stream,my_off_t pos,int whence,myf MyFlags);
523
 
extern void *_mymalloc(size_t uSize,const char *sFile,
524
 
                       uint32_t uLine, myf MyFlag);
525
 
extern void *_myrealloc(void *pPtr,size_t uSize,const char *sFile,
526
 
                       uint32_t uLine, myf MyFlag);
527
301
extern void * my_multi_malloc (myf MyFlags, ...);
528
 
extern void _myfree(void *pPtr, const char *sFile, uint32_t uLine, myf MyFlag);
529
302
extern int _sanity(const char *sFile, uint32_t uLine);
530
 
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,
533
 
                         myf MyFlag);
534
 
extern char *_my_strndup(const char *from, size_t length,
535
 
                         const char *sFile, uint32_t uLine,
536
 
                         myf MyFlag);
537
303
 
538
304
#define my_access access
539
305
extern int check_if_legal_filename(const char *path);
545
311
extern void TERMINATE(FILE *file, uint32_t flag);
546
312
#endif
547
313
extern void init_glob_errs(void);
548
 
extern FILE *my_fopen(const char *FileName,int Flags,myf MyFlags);
549
 
extern int my_fclose(FILE *fd,myf MyFlags);
550
314
extern int my_sync(File fd, myf my_flags);
551
315
extern int my_sync_dir(const char *dir_name, myf my_flags);
552
316
extern int my_sync_dir_by_file(const char *file_name, myf my_flags);
570
334
#define my_print_open_files()
571
335
#endif
572
336
 
573
 
extern bool init_tmpdir(MY_TMPDIR *tmpdir, const char *pathlist);
574
 
extern char *my_tmpdir(MY_TMPDIR *tmpdir);
575
 
extern void free_tmpdir(MY_TMPDIR *tmpdir);
576
 
 
577
 
extern void my_remember_signal(int signal_number,RETSIGTYPE (*func)(int));
 
337
extern void my_remember_signal(int signal_number,void (*func)(int));
578
338
extern size_t dirname_part(char * to,const char *name, size_t *to_res_length);
579
339
extern size_t dirname_length(const char *name);
580
340
#define base_name(A) (A+dirname_length(A))
581
 
extern int test_if_hard_path(const char *dir_name);
582
 
extern bool has_path(const char *name);
 
341
bool test_if_hard_path(const char *dir_name);
 
342
 
583
343
extern char *convert_dirname(char *to, const char *from, const char *from_end);
584
 
extern void to_unix_path(char * name);
585
344
extern char * fn_ext(const char *name);
586
345
extern char * fn_same(char * toname,const char *name,int flag);
587
346
extern char * fn_format(char * to,const char *name,const char *dir,
588
347
                           const char *form, uint32_t flag);
589
348
extern size_t strlength(const char *str);
590
 
extern void pack_dirname(char * to,const char *from);
591
349
extern size_t unpack_dirname(char * to,const char *from);
592
350
extern size_t cleanup_dirname(char * to,const char *from);
593
351
extern size_t system_filename(char * to,const char *from);
595
353
extern char * intern_filename(char * to,const char *from);
596
354
extern char * directory_file_name(char * dst, const char *src);
597
355
extern int pack_filename(char * to, const char *name, size_t max_length);
598
 
extern char * my_path(char * to,const char *progname,
599
 
                         const char *own_pathname_part);
600
356
extern char * my_load_path(char * to, const char *path,
601
357
                              const char *own_path_prefix);
602
358
extern int wild_compare(const char *str,const char *wildstr,
607
363
extern bool array_append_string_unique(const char *str,
608
364
                                          const char **array, size_t size);
609
365
extern void get_date(char * to,int timeflag,time_t use_time);
610
 
extern void soundex(CHARSET_INFO *, char * out_pntr, char * in_pntr,
611
 
                    bool remove_garbage);
612
366
extern int init_record_cache(RECORD_CACHE *info,size_t cachesize,File file,
613
367
                             size_t reclength,enum cache_type type,
614
368
                             bool use_async_io);
617
371
extern int write_cache_record(RECORD_CACHE *info,my_off_t filepos,
618
372
                              const unsigned char *record,size_t length);
619
373
extern int flush_write_cache(RECORD_CACHE *info);
620
 
extern RETSIGTYPE sigtstp_handler(int signal_number);
 
374
extern void sigtstp_handler(int signal_number);
621
375
extern void handle_recived_signals(void);
622
376
 
623
 
extern RETSIGTYPE my_set_alarm_variable(int signo);
 
377
extern void my_set_alarm_variable(int signo);
624
378
extern void my_string_ptr_sort(unsigned char *base,uint32_t items,size_t size);
625
379
extern void radixsort_for_str_ptr(unsigned char* base[], uint32_t number_of_elements,
626
380
                                  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);
 
381
extern void my_qsort(void *base_ptr, size_t total_elems, size_t size,
 
382
                     qsort_cmp cmp);
 
383
extern void my_qsort2(void *base_ptr, size_t total_elems, size_t size,
 
384
                      qsort2_cmp cmp, void *cmp_argument);
631
385
extern qsort2_cmp get_ptr_compare(size_t);
632
386
void my_store_ptr(unsigned char *buff, size_t pack_length, my_off_t pos);
633
387
my_off_t my_get_ptr(unsigned char *ptr, size_t pack_length);
634
 
extern int init_io_cache(IO_CACHE *info,File file,size_t cachesize,
635
 
                         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);
640
 
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);
643
 
extern void init_io_cache_share(IO_CACHE *read_cache, IO_CACHE_SHARE *cshare,
644
 
                                IO_CACHE *write_cache, uint32_t num_threads);
645
 
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);
648
 
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);
653
 
 
654
 
extern int my_block_write(IO_CACHE *info, const unsigned char *Buffer,
655
 
                          size_t Count, my_off_t pos);
656
 
extern int my_b_flush_io_cache(IO_CACHE *info, int need_append_buffer_lock);
657
 
 
658
 
#define flush_io_cache(info) my_b_flush_io_cache((info),1)
659
 
 
660
 
extern int end_io_cache(IO_CACHE *info);
661
 
extern size_t my_b_fill(IO_CACHE *info);
662
 
extern void my_b_seek(IO_CACHE *info,my_off_t pos);
663
 
extern size_t my_b_gets(IO_CACHE *info, char *to, size_t max_length);
664
 
extern my_off_t my_b_filelength(IO_CACHE *info);
665
 
extern size_t my_b_printf(IO_CACHE *info, const char* fmt, ...);
666
 
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,
668
 
                                 const char *prefix, size_t cache_size,
669
 
                                 myf cache_myflags);
670
 
extern bool real_open_cached_file(IO_CACHE *cache);
671
 
extern void close_cached_file(IO_CACHE *cache);
672
 
File create_temp_file(char *to, const char *dir, const char *pfx,
673
 
                      int mode, myf MyFlags);
674
 
#define my_init_dynamic_array(A,B,C,D) init_dynamic_array2(A,B,NULL,C,D CALLER_INFO)
675
 
#define my_init_dynamic_array_ci(A,B,C,D) init_dynamic_array2(A,B,NULL,C,D ORIG_CALLER_INFO)
676
 
#define my_init_dynamic_array2(A,B,C,D,E) init_dynamic_array2(A,B,C,D,E CALLER_INFO)
677
 
#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
681
 
                                   CALLER_INFO_PROTO);
682
 
/* 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
685
 
                                  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);
692
 
extern void delete_dynamic(DYNAMIC_ARRAY *array);
693
 
extern void delete_dynamic_element(DYNAMIC_ARRAY *array, uint32_t array_index);
694
 
extern void freeze_size(DYNAMIC_ARRAY *array);
695
 
extern int  get_index_dynamic(DYNAMIC_ARRAY *array, unsigned char * element);
696
 
#define dynamic_array_ptr(array,array_index) ((array)->buffer+(array_index)*(array)->size_of_element)
697
 
#define dynamic_element(array,array_index,type) ((type)((array)->buffer) +(array_index))
698
 
#define push_dynamic(A,B) insert_dynamic((A),(B))
699
 
#define reset_dynamic(array) ((array)->elements= 0)
700
 
#define sort_dynamic(A,cmp) my_qsort((A)->buffer, (A)->elements, (A)->size_of_element, (cmp))
701
 
 
702
 
#define my_malloc_lock(A,B) my_malloc((A),(B))
 
388
File create_temp_file(char *to, const char *dir, const char *pfx, myf MyFlags);
 
389
 
 
390
#include <mysys/dynamic_array.h>
 
391
 
703
392
#define alloc_root_inited(A) ((A)->min_malloc != 0)
704
393
#define ALLOC_ROOT_MIN_BLOCK_SIZE (MALLOC_OVERHEAD + sizeof(USED_MEM) + 8)
705
394
#define clear_alloc_root(A) do { (A)->free= (A)->used= (A)->pre_alloc= 0; (A)->min_malloc=0;} while(0)
706
 
extern void init_alloc_root(MEM_ROOT *mem_root, size_t block_size,
707
 
                            size_t pre_alloc_size);
708
 
extern void *alloc_root(MEM_ROOT *mem_root, size_t Size);
709
 
extern void *multi_alloc_root(MEM_ROOT *mem_root, ...);
710
 
extern void free_root(MEM_ROOT *root, myf MyFLAGS);
711
 
extern void set_prealloc_root(MEM_ROOT *root, char *ptr);
712
 
extern void reset_root_defaults(MEM_ROOT *mem_root, size_t block_size,
713
 
                                size_t prealloc_size);
714
 
extern char *strdup_root(MEM_ROOT *root,const char *str);
715
 
extern char *strmake_root(MEM_ROOT *root,const char *str,size_t len);
716
 
extern void *memdup_root(MEM_ROOT *root,const void *str, size_t len);
717
395
extern int get_defaults_options(int argc, char **argv,
718
396
                                char **defaults, char **extra_defaults,
719
397
                                char **group_suffix);
720
398
extern int load_defaults(const char *conf_file, const char **groups,
721
399
                         int *argc, char ***argv);
722
 
extern int modify_defaults_file(const char *file_location, const char *option,
723
 
                                const char *option_value,
724
 
                                const char *section_name, int remove_option);
725
400
extern int my_search_option_files(const char *conf_file, int *argc,
726
401
                                  char ***argv, uint32_t *args_used,
727
402
                                  Process_option_func func, void *func_ctx);
731
406
extern ha_checksum my_checksum(ha_checksum crc, const unsigned char *mem,
732
407
                               size_t count);
733
408
extern void my_sleep(uint32_t m_seconds);
734
 
extern uint32_t my_set_max_open_files(uint32_t files);
735
409
void my_free_open_file_info(void);
736
410
 
737
 
extern time_t my_time(myf flags);
738
411
extern uint64_t my_getsystime(void);
739
412
extern uint64_t my_micro_time(void);
740
413
extern uint64_t my_micro_time_and_time(time_t *time_arg);
741
414
time_t my_time_possible_from_micro(uint64_t microtime);
742
 
extern bool my_gethwaddr(unsigned char *to);
743
415
 
744
416
#ifdef HAVE_SYS_MMAN_H
745
417
#include <sys/mman.h>
775
447
#endif
776
448
 
777
449
/* character sets */
 
450
void *cs_alloc(size_t size);
 
451
 
778
452
extern uint32_t get_charset_number(const char *cs_name, uint32_t cs_flags);
779
453
extern uint32_t get_collation_number(const char *name);
780
454
extern const char *get_charset_name(uint32_t cs_number);
781
455
 
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);
 
456
extern const CHARSET_INFO *get_charset(uint32_t cs_number);
 
457
extern const CHARSET_INFO *get_charset_by_name(const char *cs_name);
 
458
extern const CHARSET_INFO *get_charset_by_csname(const char *cs_name, uint32_t cs_flags);
785
459
 
786
460
extern bool resolve_charset(const char *cs_name,
787
461
                            const CHARSET_INFO *default_cs,