← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to mysys/my_sys.h

  • Committer: Monty Taylor
  • Date: 2008-08-02 01:03:15 UTC
  • mto: (236.1.42 codestyle)
  • mto: This revision was merged to the branch mainline in revision 261.
  • Revision ID: monty@inaugust.com-20080802010315-65h5938pymg9d99z
Moved m4 macros to top-level m4 dir, per GNU standards (and where gettext wanted it :)

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
 
43
 
/* Max width of screen (for error messages) */
44
 
#define SC_MAXWIDTH 256
45
39
#define ERRMSGSIZE      (SC_MAXWIDTH)   /* Max length of a error message */
46
40
#define NRERRBUFFS      (2)     /* Buffers for parameters */
47
41
#define MY_FILE_ERROR   ((size_t) -1)
55
49
#define MY_WAIT_IF_FULL 32      /* Wait and try again if disk full error */
56
50
#define MY_IGNORE_BADFD 32      /* my_sync: ignore 'bad descriptor' errors */
57
51
#define MY_SYNC_DIR     1024    /* my_create/delete/rename: sync directory */
 
52
#define MY_RAID         64      /* Support for RAID */
58
53
#define MY_FULL_IO     512      /* For my_read - loop intil I/O is complete */
59
54
#define MY_DONT_CHECK_FILESIZE 128 /* Option to init_io_cache() */
60
55
#define MY_LINK_WARNING 32      /* my_redel() gives warning if links */
63
58
#define MY_RESOLVE_LINK 128     /* my_realpath(); Only resolve links */
64
59
#define MY_HOLD_ORIGINAL_MODES 128  /* my_copy() holds to file modes */
65
60
#define MY_REDEL_MAKE_BACKUP 256
 
61
#define MY_SEEK_NOT_DONE 32     /* my_lock may have to do a seek */
66
62
#define MY_DONT_WAIT    64      /* my_lock() don't wait if can't lock */
67
 
#define MY_ZEROFILL     32      /* my_multi_malloc(), fill array with zero */
 
63
#define MY_ZEROFILL     32      /* my_malloc(), fill array with zero */
 
64
#define MY_ALLOW_ZERO_PTR 64    /* my_realloc() ; zero ptr -> malloc */
 
65
#define MY_FREE_ON_ERROR 128    /* my_realloc() ; Free old ptr on error */
 
66
#define MY_HOLD_ON_ERROR 256    /* my_realloc() ; Return old ptr on error */
68
67
#define MY_DONT_OVERWRITE_FILE 1024     /* my_copy: Don't overwrite file */
69
68
#define MY_THREADSAFE 2048      /* my_seek(): lock fd mutex */
70
69
 
101
100
#define MY_APPEND_EXT           256     /* add 'ext' as additional extension*/
102
101
 
103
102
 
 
103
        /* My seek flags */
 
104
#define MY_SEEK_SET     0
 
105
#define MY_SEEK_CUR     1
 
106
#define MY_SEEK_END     2
 
107
 
104
108
        /* Some constants */
105
109
#define MY_WAIT_FOR_USER_TO_FIX_PANIC   60      /* in seconds */
106
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. */
107
112
#define DFLT_INIT_HITS  3
108
113
 
109
114
        /* root_alloc flags */
122
127
#define GETDATE_FIXEDLENGTH     16
123
128
 
124
129
        /* defines when allocating data */
 
130
#ifdef SAFEMALLOC
 
131
#else
125
132
#define my_checkmalloc()
126
133
#undef TERMINATE
127
134
#define TERMINATE(A,B) {}
128
 
 
129
 
#ifdef __cplusplus
130
 
extern "C" {
131
 
#endif
132
 
 
133
 
typedef int  (*qsort_cmp)(const void *,const void *);
134
 
typedef int  (*qsort_cmp2)(void*, const void *,const void *);
135
 
 
 
135
#define QUICK_SAFEMALLOC
 
136
#define NORMAL_SAFEMALLOC
 
137
extern void *my_malloc(size_t Size,myf MyFlags);
 
138
#define my_malloc_ci(SZ,FLAG) my_malloc( SZ, FLAG )
 
139
extern void *my_realloc(void *oldpoint, size_t Size, myf MyFlags);
 
140
extern void my_no_flags_free(void *ptr);
 
141
extern void *my_memdup(const void *from,size_t length,myf MyFlags);
 
142
extern char *my_strdup(const char *from,myf MyFlags);
 
143
extern char *my_strndup(const char *from, size_t length,
 
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))
 
147
#define CALLER_INFO_PROTO   /* nothing */
 
148
#define CALLER_INFO         /* nothing */
 
149
#define ORIG_CALLER_INFO    /* nothing */
136
150
#define TRASH(A,B) /* nothing */
 
151
#endif
 
152
 
 
153
#ifdef HAVE_ALLOCA
 
154
#if defined(__GNUC__) && !defined(HAVE_ALLOCA_H) && ! defined(alloca)
 
155
#define alloca __builtin_alloca
 
156
#endif /* GNUC */
 
157
#define my_alloca(SZ) alloca((size_t) (SZ))
 
158
#define my_afree(PTR) {}
 
159
#else
 
160
#define my_alloca(SZ) my_malloc(SZ,MYF(0))
 
161
#define my_afree(PTR) my_free(PTR,MYF(MY_WME))
 
162
#endif /* HAVE_ALLOCA */
137
163
 
138
164
#ifndef errno                           /* did we already get it? */
139
165
#ifdef HAVE_ERRNO_AS_DEFINE
145
171
extern char errbuff[NRERRBUFFS][ERRMSGSIZE];
146
172
extern char *home_dir;                  /* Home directory for user */
147
173
extern const char *my_progname;         /* program-name (printed in errors) */
148
 
typedef void (*error_handler_func)(uint32_t my_err, const char *str,myf MyFlags);
149
 
extern error_handler_func error_handler_hook;
150
 
extern error_handler_func fatal_error_handler_hook;
151
 
extern uint32_t my_file_limit;
 
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,
 
176
                                        myf MyFlags);
 
177
extern uint my_file_limit;
 
178
extern ulong my_thread_stack_size;
152
179
 
153
180
/* charsets */
154
 
extern const CHARSET_INFO *default_charset_info;
 
181
extern CHARSET_INFO *default_charset_info;
155
182
extern CHARSET_INFO *all_charsets[256];
156
183
extern CHARSET_INFO compiled_charsets[];
157
184
 
158
185
/* statistics */
159
 
extern uint32_t my_file_opened,my_stream_opened, my_tmp_file_created;
160
 
extern uint32_t    my_file_total_opened;
 
186
extern ulong    my_file_opened,my_stream_opened, my_tmp_file_created;
 
187
extern ulong    my_file_total_opened;
161
188
extern uint     mysys_usage_id;
162
189
extern bool     my_init_done;
163
190
 
164
 
typedef void (*void_ptr_func)(void);
165
 
typedef void (*void_ptr_int_func)(int);
166
 
 
167
191
                                        /* Point to current my_message() */
168
 
extern void_ptr_func my_sigtstp_cleanup,
 
192
extern void (*my_sigtstp_cleanup)(void),
169
193
                                        /* Executed before jump to shell */
170
 
            my_sigtstp_restart;
171
 
extern void_ptr_int_func my_abort_hook;
 
194
            (*my_sigtstp_restart)(void),
 
195
            (*my_abort_hook)(int);
172
196
                                        /* Executed when comming from shell */
173
197
extern int my_umask,            /* Default creation mask  */
174
198
           my_umask_dir,
176
200
           my_safe_to_handle_signal, /* Set when allowed to SIGTSTP */
177
201
           my_dont_interrupt;   /* call remember_intr when set */
178
202
extern bool mysys_uses_curses, my_use_symdir;
179
 
extern uint32_t sf_malloc_cur_memory, sf_malloc_max_memory;
 
203
extern ulong sf_malloc_cur_memory, sf_malloc_max_memory;
180
204
 
181
 
extern uint32_t my_default_record_cache_size;
 
205
extern ulong    my_default_record_cache_size;
182
206
extern bool my_disable_async_io,
183
207
               my_disable_flush_key_blocks, my_disable_symlinks;
184
208
extern char     wild_many, wild_one, wild_prefix;
215
239
  int   rc_seek,error,inited;
216
240
  uint  rc_length,read_length,reclength;
217
241
  my_off_t rc_record_pos,end_of_file;
218
 
  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;
219
243
#ifdef HAVE_AIOWAIT
220
244
  int   use_async_io;
221
245
  my_aio_result aio_result;
233
257
{
234
258
  char *                name;
235
259
  enum file_type        type;
 
260
#if !defined(HAVE_PREAD)
 
261
  pthread_mutex_t       mutex;
 
262
#endif
236
263
};
237
264
 
238
265
extern struct st_my_file_info *my_file_info;
239
266
 
240
267
typedef struct st_dynamic_array
241
268
{
242
 
  unsigned char *buffer;
243
 
  size_t elements,max_element;
244
 
  uint32_t alloc_increment;
245
 
  uint32_t size_of_element;
 
269
  uchar *buffer;
 
270
  uint elements,max_element;
 
271
  uint alloc_increment;
 
272
  uint size_of_element;
246
273
} DYNAMIC_ARRAY;
247
274
 
 
275
typedef struct st_my_tmpdir
 
276
{
 
277
  DYNAMIC_ARRAY full_list;
 
278
  char **list;
 
279
  uint cur, max;
 
280
  pthread_mutex_t mutex;
 
281
} MY_TMPDIR;
 
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
  ulong 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;
248
433
 
249
434
typedef int (*qsort2_cmp)(const void *, const void *, const void *);
250
435
 
269
454
 
270
455
#define my_b_get(info) \
271
456
  ((info)->read_pos != (info)->read_end ?\
272
 
   ((info)->read_pos++, (int) (unsigned char) (info)->read_pos[-1]) :\
 
457
   ((info)->read_pos++, (int) (uchar) (info)->read_pos[-1]) :\
273
458
   _my_b_get(info))
274
459
 
275
460
        /* my_b_write_byte dosn't have any err-check */
284
469
#define my_b_tell(info) ((info)->pos_in_file + \
285
470
                         (size_t) (*(info)->current_pos - (info)->request_pos))
286
471
 
287
 
#define my_b_get_buffer_start(info) (info)->request_pos
 
472
#define my_b_get_buffer_start(info) (info)->request_pos 
288
473
#define my_b_get_bytes_in_buffer(info) (char*) (info)->read_end -   \
289
474
  (char*) my_b_get_buffer_start(info)
290
475
#define my_b_get_pos_in_file(info) (info)->pos_in_file
291
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() */
292
481
 
293
482
#define my_b_bytes_in_cache(info) (size_t) (*(info)->current_end - \
294
483
                                          *(info)->current_pos)
299
488
typedef int (*Process_option_func)(void *ctx, const char *group_name,
300
489
                                   const char *option);
301
490
 
302
 
int handle_default_option(void *in_ctx, const char *group_name,
303
 
                          const char *option);
304
 
 
305
491
#include <mysys/my_alloc.h>
306
492
 
307
493
 
308
494
        /* Prototypes for mysys and my_func functions */
309
495
 
310
496
extern int my_copy(const char *from,const char *to,myf MyFlags);
 
497
extern int my_append(const char *from,const char *to,myf MyFlags);
311
498
extern int my_delete(const char *name,myf MyFlags);
 
499
extern int my_getwd(char * buf,size_t size,myf MyFlags);
 
500
extern int my_setwd(const char *dir,myf MyFlags);
 
501
extern void *my_once_alloc(size_t Size,myf MyFlags);
 
502
extern void my_once_free(void);
 
503
extern char *my_once_strdup(const char *src,myf myflags);
 
504
extern void *my_once_memdup(const void *src, size_t len, myf myflags);
312
505
extern File my_open(const char *FileName,int Flags,myf MyFlags);
313
506
extern File my_register_filename(File fd, const char *FileName,
314
507
                                 enum file_type type_of_file,
315
 
                                 uint32_t error_message_number, myf MyFlags);
 
508
                                 uint error_message_number, myf MyFlags);
316
509
extern File my_create(const char *FileName,int CreateFlags,
317
510
                      int AccessFlags, myf MyFlags);
318
511
extern int my_close(File Filedes,myf MyFlags);
326
519
extern int my_delete_with_symlink(const char *name, myf MyFlags);
327
520
extern int my_rename_with_symlink(const char *from,const char *to,myf MyFlags);
328
521
extern int my_symlink(const char *content, const char *linkname, myf MyFlags);
329
 
extern size_t my_read(File Filedes,unsigned char *Buffer,size_t Count,myf MyFlags);
 
522
extern size_t my_read(File Filedes,uchar *Buffer,size_t Count,myf MyFlags);
330
523
extern int my_rename(const char *from,const char *to,myf MyFlags);
331
 
extern size_t my_write(File Filedes,const unsigned char *Buffer,size_t Count,
 
524
extern my_off_t my_seek(File fd,my_off_t pos,int whence,myf MyFlags);
 
525
extern my_off_t my_tell(File fd,myf MyFlags);
 
526
extern size_t my_write(File Filedes,const uchar *Buffer,size_t Count,
332
527
                     myf MyFlags);
333
 
extern void * my_multi_malloc (myf MyFlags, ...);
334
 
extern int _sanity(const char *sFile, uint32_t uLine);
 
528
extern size_t my_fread(FILE *stream,uchar *Buffer,size_t Count,myf MyFlags);
 
529
extern size_t my_fwrite(FILE *stream,const uchar *Buffer,size_t Count,
 
530
                      myf MyFlags);
 
531
extern my_off_t my_fseek(FILE *stream,my_off_t pos,int whence,myf MyFlags);
 
532
extern my_off_t my_ftell(FILE *stream,myf MyFlags);
 
533
extern void *_mymalloc(size_t uSize,const char *sFile,
 
534
                       uint uLine, myf MyFlag);
 
535
extern void *_myrealloc(void *pPtr,size_t uSize,const char *sFile,
 
536
                       uint uLine, myf MyFlag);
 
537
extern void * my_multi_malloc _VARARGS((myf MyFlags, ...));
 
538
extern void _myfree(void *pPtr,const char *sFile,uint uLine, myf MyFlag);
 
539
extern int _sanity(const char *sFile, uint uLine);
 
540
extern void *_my_memdup(const void *from, size_t length,
 
541
                        const char *sFile, uint uLine,myf MyFlag);
 
542
extern char * _my_strdup(const char *from, const char *sFile, uint uLine,
 
543
                         myf MyFlag);
 
544
extern char *_my_strndup(const char *from, size_t length,
 
545
                         const char *sFile, uint uLine,
 
546
                         myf MyFlag);
 
547
 
 
548
/* implemented in my_memmem.c */
 
549
extern void *my_memmem(const void *haystack, size_t haystacklen,
 
550
                       const void *needle, size_t needlelen);
 
551
 
335
552
 
336
553
#define my_access access
337
554
extern int check_if_legal_filename(const char *path);
340
557
#define my_delete_allow_opened(fname,flags)  my_delete((fname),(flags))
341
558
 
342
559
#ifndef TERMINATE
343
 
extern void TERMINATE(FILE *file, uint32_t flag);
 
560
extern void TERMINATE(FILE *file, uint flag);
344
561
#endif
345
562
extern void init_glob_errs(void);
346
563
extern FILE *my_fopen(const char *FileName,int Flags,myf MyFlags);
 
564
extern FILE *my_fdopen(File Filedes,const char *name, int Flags,myf MyFlags);
347
565
extern int my_fclose(FILE *fd,myf MyFlags);
348
566
extern int my_sync(File fd, myf my_flags);
349
567
extern int my_sync_dir(const char *dir_name, myf my_flags);
350
568
extern int my_sync_dir_by_file(const char *file_name, myf my_flags);
351
 
extern void my_error(int nr,myf MyFlags, ...);
352
 
extern void my_printf_error(uint32_t my_err, const char *format,
353
 
                            myf MyFlags, ...)
354
 
  __attribute__((format(printf, 2, 4)));
 
569
extern void my_error _VARARGS((int nr,myf MyFlags, ...));
 
570
extern void my_printf_error _VARARGS((uint my_err, const char *format,
 
571
                                      myf MyFlags, ...))
 
572
                                      __attribute__((format(printf, 2, 4)));
355
573
extern int my_error_register(const char **errmsgs, int first, int last);
356
574
extern const char **my_error_unregister(int first, int last);
357
 
extern void my_message(uint32_t my_err, const char *str,myf MyFlags);
358
 
extern void my_message_no_curses(uint32_t my_err, const char *str,myf MyFlags);
 
575
extern void my_message(uint my_err, const char *str,myf MyFlags);
 
576
extern void my_message_no_curses(uint my_err, const char *str,myf MyFlags);
359
577
extern bool my_init(void);
360
578
extern void my_end(int infoflag);
361
579
extern int my_redel(const char *from, const char *to, int MyFlags);
368
586
#define my_print_open_files()
369
587
#endif
370
588
 
371
 
extern void my_remember_signal(int signal_number,void (*func)(int));
 
589
extern bool init_tmpdir(MY_TMPDIR *tmpdir, const char *pathlist);
 
590
extern char *my_tmpdir(MY_TMPDIR *tmpdir);
 
591
extern void free_tmpdir(MY_TMPDIR *tmpdir);
 
592
 
 
593
extern void my_remember_signal(int signal_number,sig_handler (*func)(int));
372
594
extern size_t dirname_part(char * to,const char *name, size_t *to_res_length);
373
595
extern size_t dirname_length(const char *name);
374
596
#define base_name(A) (A+dirname_length(A))
375
 
bool test_if_hard_path(const char *dir_name);
 
597
extern int test_if_hard_path(const char *dir_name);
 
598
extern bool has_path(const char *name);
376
599
extern char *convert_dirname(char *to, const char *from, const char *from_end);
377
600
extern void to_unix_path(char * name);
378
601
extern char * fn_ext(const char *name);
379
602
extern char * fn_same(char * toname,const char *name,int flag);
380
603
extern char * fn_format(char * to,const char *name,const char *dir,
381
 
                           const char *form, uint32_t flag);
 
604
                           const char *form, uint flag);
382
605
extern size_t strlength(const char *str);
383
606
extern void pack_dirname(char * to,const char *from);
384
607
extern size_t unpack_dirname(char * to,const char *from);
397
620
extern WF_PACK *wf_comp(char * str);
398
621
extern int wf_test(struct wild_file_pack *wf_pack,const char *name);
399
622
extern void wf_end(struct wild_file_pack *buffer);
 
623
extern size_t strip_sp(char * str);
400
624
extern bool array_append_string_unique(const char *str,
401
625
                                          const char **array, size_t size);
402
626
extern void get_date(char * to,int timeflag,time_t use_time);
405
629
extern int init_record_cache(RECORD_CACHE *info,size_t cachesize,File file,
406
630
                             size_t reclength,enum cache_type type,
407
631
                             bool use_async_io);
408
 
extern int read_cache_record(RECORD_CACHE *info,unsigned char *to);
 
632
extern int read_cache_record(RECORD_CACHE *info,uchar *to);
409
633
extern int end_record_cache(RECORD_CACHE *info);
410
634
extern int write_cache_record(RECORD_CACHE *info,my_off_t filepos,
411
 
                              const unsigned char *record,size_t length);
 
635
                              const uchar *record,size_t length);
412
636
extern int flush_write_cache(RECORD_CACHE *info);
413
 
extern void sigtstp_handler(int signal_number);
 
637
extern long my_clock(void);
 
638
extern sig_handler sigtstp_handler(int signal_number);
414
639
extern void handle_recived_signals(void);
415
640
 
416
 
extern void my_set_alarm_variable(int signo);
417
 
extern void my_string_ptr_sort(unsigned char *base,uint32_t items,size_t size);
418
 
extern void radixsort_for_str_ptr(unsigned char* base[], uint32_t number_of_elements,
419
 
                                  size_t size_of_element,unsigned char *buffer[]);
420
 
extern void my_qsort(void *base_ptr, size_t total_elems, size_t size,
421
 
                     qsort_cmp cmp);
422
 
extern void my_qsort2(void *base_ptr, size_t total_elems, size_t size,
423
 
                      qsort2_cmp cmp, void *cmp_argument);
 
641
extern sig_handler my_set_alarm_variable(int signo);
 
642
extern void my_string_ptr_sort(uchar *base,uint items,size_t size);
 
643
extern void radixsort_for_str_ptr(uchar* base[], uint number_of_elements,
 
644
                                  size_t size_of_element,uchar *buffer[]);
 
645
extern qsort_t my_qsort(void *base_ptr, size_t total_elems, size_t size,
 
646
                        qsort_cmp cmp);
 
647
extern qsort_t my_qsort2(void *base_ptr, size_t total_elems, size_t size,
 
648
                         qsort2_cmp cmp, void *cmp_argument);
424
649
extern qsort2_cmp get_ptr_compare(size_t);
425
 
void my_store_ptr(unsigned char *buff, size_t pack_length, my_off_t pos);
426
 
my_off_t my_get_ptr(unsigned char *ptr, size_t pack_length);
 
650
void my_store_ptr(uchar *buff, size_t pack_length, my_off_t pos);
 
651
my_off_t my_get_ptr(uchar *ptr, size_t pack_length);
 
652
extern int init_io_cache(IO_CACHE *info,File file,size_t cachesize,
 
653
                         enum cache_type type,my_off_t seek_offset,
 
654
                         bool use_async_io, myf cache_myflags);
 
655
extern bool reinit_io_cache(IO_CACHE *info,enum cache_type type,
 
656
                               my_off_t seek_offset,bool use_async_io,
 
657
                               bool clear_cache);
 
658
extern void setup_io_cache(IO_CACHE* info);
 
659
extern int _my_b_read(IO_CACHE *info,uchar *Buffer,size_t Count);
 
660
extern int _my_b_read_r(IO_CACHE *info,uchar *Buffer,size_t Count);
 
661
extern void init_io_cache_share(IO_CACHE *read_cache, IO_CACHE_SHARE *cshare,
 
662
                                IO_CACHE *write_cache, uint num_threads);
 
663
extern void remove_io_thread(IO_CACHE *info);
 
664
extern int _my_b_seq_read(IO_CACHE *info,uchar *Buffer,size_t Count);
 
665
extern int _my_b_net_read(IO_CACHE *info,uchar *Buffer,size_t Count);
 
666
extern int _my_b_get(IO_CACHE *info);
 
667
extern int _my_b_async_read(IO_CACHE *info,uchar *Buffer,size_t Count);
 
668
extern int _my_b_write(IO_CACHE *info,const uchar *Buffer,size_t Count);
 
669
extern int my_b_append(IO_CACHE *info,const uchar *Buffer,size_t Count);
 
670
extern int my_b_safe_write(IO_CACHE *info,const uchar *Buffer,size_t Count);
 
671
 
 
672
extern int my_block_write(IO_CACHE *info, const uchar *Buffer,
 
673
                          size_t Count, my_off_t pos);
 
674
extern int my_b_flush_io_cache(IO_CACHE *info, int need_append_buffer_lock);
 
675
 
 
676
#define flush_io_cache(info) my_b_flush_io_cache((info),1)
 
677
 
 
678
extern int end_io_cache(IO_CACHE *info);
 
679
extern size_t my_b_fill(IO_CACHE *info);
 
680
extern void my_b_seek(IO_CACHE *info,my_off_t pos);
 
681
extern size_t my_b_gets(IO_CACHE *info, char *to, size_t max_length);
 
682
extern my_off_t my_b_filelength(IO_CACHE *info);
 
683
extern size_t my_b_printf(IO_CACHE *info, const char* fmt, ...);
 
684
extern size_t my_b_vprintf(IO_CACHE *info, const char* fmt, va_list ap);
 
685
extern bool open_cached_file(IO_CACHE *cache,const char *dir,
 
686
                                 const char *prefix, size_t cache_size,
 
687
                                 myf cache_myflags);
 
688
extern bool real_open_cached_file(IO_CACHE *cache);
 
689
extern void close_cached_file(IO_CACHE *cache);
427
690
File create_temp_file(char *to, const char *dir, const char *pfx,
428
691
                      int mode, myf MyFlags);
429
 
#define my_init_dynamic_array(A,B,C,D) init_dynamic_array2(A,B,NULL,C,D)
430
 
#define my_init_dynamic_array_ci(A,B,C,D) init_dynamic_array2(A,B,NULL,C,D)
431
 
#define my_init_dynamic_array2(A,B,C,D,E) init_dynamic_array2(A,B,C,D,E)
432
 
#define my_init_dynamic_array2_ci(A,B,C,D,E) init_dynamic_array2(A,B,C,D,E)
433
 
extern bool init_dynamic_array2(DYNAMIC_ARRAY *array,uint32_t element_size,
434
 
                                   void *init_buffer, uint32_t init_alloc,
435
 
                                   uint32_t alloc_increment);
 
692
#define my_init_dynamic_array(A,B,C,D) init_dynamic_array2(A,B,NULL,C,D CALLER_INFO)
 
693
#define my_init_dynamic_array_ci(A,B,C,D) init_dynamic_array2(A,B,NULL,C,D ORIG_CALLER_INFO)
 
694
#define my_init_dynamic_array2(A,B,C,D,E) init_dynamic_array2(A,B,C,D,E CALLER_INFO)
 
695
#define my_init_dynamic_array2_ci(A,B,C,D,E) init_dynamic_array2(A,B,C,D,E ORIG_CALLER_INFO)
 
696
extern bool init_dynamic_array2(DYNAMIC_ARRAY *array,uint element_size,
 
697
                                   void *init_buffer, uint init_alloc, 
 
698
                                   uint alloc_increment
 
699
                                   CALLER_INFO_PROTO);
436
700
/* init_dynamic_array() function is deprecated */
437
 
extern bool init_dynamic_array(DYNAMIC_ARRAY *array,uint32_t element_size,
438
 
                                  uint32_t init_alloc,uint32_t alloc_increment);
439
 
extern bool insert_dynamic(DYNAMIC_ARRAY *array,unsigned char * element);
440
 
extern unsigned char *alloc_dynamic(DYNAMIC_ARRAY *array);
441
 
extern unsigned char *pop_dynamic(DYNAMIC_ARRAY*);
442
 
extern bool set_dynamic(DYNAMIC_ARRAY *array,unsigned char * element,uint32_t array_index);
443
 
extern bool allocate_dynamic(DYNAMIC_ARRAY *array, uint32_t max_elements);
444
 
extern void get_dynamic(DYNAMIC_ARRAY *array,unsigned char * element,uint32_t array_index);
 
701
extern bool init_dynamic_array(DYNAMIC_ARRAY *array,uint element_size,
 
702
                                  uint init_alloc,uint alloc_increment
 
703
                                  CALLER_INFO_PROTO);
 
704
extern bool insert_dynamic(DYNAMIC_ARRAY *array,uchar * element);
 
705
extern uchar *alloc_dynamic(DYNAMIC_ARRAY *array);
 
706
extern uchar *pop_dynamic(DYNAMIC_ARRAY*);
 
707
extern bool set_dynamic(DYNAMIC_ARRAY *array,uchar * element,uint array_index);
 
708
extern bool allocate_dynamic(DYNAMIC_ARRAY *array, uint max_elements);
 
709
extern void get_dynamic(DYNAMIC_ARRAY *array,uchar * element,uint array_index);
445
710
extern void delete_dynamic(DYNAMIC_ARRAY *array);
446
 
extern void delete_dynamic_element(DYNAMIC_ARRAY *array, uint32_t array_index);
 
711
extern void delete_dynamic_element(DYNAMIC_ARRAY *array, uint array_index);
447
712
extern void freeze_size(DYNAMIC_ARRAY *array);
448
 
extern int  get_index_dynamic(DYNAMIC_ARRAY *array, unsigned char * element);
 
713
extern int  get_index_dynamic(DYNAMIC_ARRAY *array, uchar * element);
449
714
#define dynamic_array_ptr(array,array_index) ((array)->buffer+(array_index)*(array)->size_of_element)
450
715
#define dynamic_element(array,array_index,type) ((type)((array)->buffer) +(array_index))
451
716
#define push_dynamic(A,B) insert_dynamic((A),(B))
452
717
#define reset_dynamic(array) ((array)->elements= 0)
453
718
#define sort_dynamic(A,cmp) my_qsort((A)->buffer, (A)->elements, (A)->size_of_element, (cmp))
454
719
 
 
720
extern bool init_dynamic_string(DYNAMIC_STRING *str, const char *init_str,
 
721
                                   size_t init_alloc,size_t alloc_increment);
 
722
extern bool dynstr_append(DYNAMIC_STRING *str, const char *append);
 
723
bool dynstr_append_mem(DYNAMIC_STRING *str, const char *append,
 
724
                          size_t length);
 
725
extern bool dynstr_append_os_quoted(DYNAMIC_STRING *str, const char *append,
 
726
                                       ...);
 
727
extern bool dynstr_set(DYNAMIC_STRING *str, const char *init_str);
 
728
extern bool dynstr_realloc(DYNAMIC_STRING *str, size_t additional_size);
 
729
extern bool dynstr_trunc(DYNAMIC_STRING *str, size_t n);
 
730
extern void dynstr_free(DYNAMIC_STRING *str);
 
731
#ifdef HAVE_MLOCK
 
732
extern void *my_malloc_lock(size_t length,myf flags);
 
733
extern void my_free_lock(void *ptr,myf flags);
 
734
#else
 
735
#define my_malloc_lock(A,B) my_malloc((A),(B))
 
736
#define my_free_lock(A,B) my_free((A),(B))
 
737
#endif
455
738
#define alloc_root_inited(A) ((A)->min_malloc != 0)
456
739
#define ALLOC_ROOT_MIN_BLOCK_SIZE (MALLOC_OVERHEAD + sizeof(USED_MEM) + 8)
457
740
#define clear_alloc_root(A) do { (A)->free= (A)->used= (A)->pre_alloc= 0; (A)->min_malloc=0;} while(0)
 
741
extern void init_alloc_root(MEM_ROOT *mem_root, size_t block_size,
 
742
                            size_t pre_alloc_size);
 
743
extern void *alloc_root(MEM_ROOT *mem_root, size_t Size);
 
744
extern void *multi_alloc_root(MEM_ROOT *mem_root, ...);
 
745
extern void free_root(MEM_ROOT *root, myf MyFLAGS);
 
746
extern void set_prealloc_root(MEM_ROOT *root, char *ptr);
 
747
extern void reset_root_defaults(MEM_ROOT *mem_root, size_t block_size,
 
748
                                size_t prealloc_size);
 
749
extern char *strdup_root(MEM_ROOT *root,const char *str);
 
750
extern char *strmake_root(MEM_ROOT *root,const char *str,size_t len);
 
751
extern void *memdup_root(MEM_ROOT *root,const void *str, size_t len);
458
752
extern int get_defaults_options(int argc, char **argv,
459
753
                                char **defaults, char **extra_defaults,
460
754
                                char **group_suffix);
464
758
                                const char *option_value,
465
759
                                const char *section_name, int remove_option);
466
760
extern int my_search_option_files(const char *conf_file, int *argc,
467
 
                                  char ***argv, uint32_t *args_used,
 
761
                                  char ***argv, uint *args_used,
468
762
                                  Process_option_func func, void *func_ctx);
469
763
extern void free_defaults(char **argv);
470
764
extern void my_print_default_files(const char *conf_file);
471
765
extern void print_defaults(const char *conf_file, const char **groups);
472
 
extern ha_checksum my_checksum(ha_checksum crc, const unsigned char *mem,
 
766
extern bool my_compress(uchar *, size_t *, size_t *);
 
767
extern bool my_uncompress(uchar *, size_t , size_t *);
 
768
extern uchar *my_compress_alloc(const uchar *packet, size_t *len,
 
769
                                size_t *complen);
 
770
extern ha_checksum my_checksum(ha_checksum crc, const uchar *mem,
473
771
                               size_t count);
474
 
extern void my_sleep(uint32_t m_seconds);
475
 
extern uint32_t my_set_max_open_files(uint32_t files);
 
772
extern void my_sleep(ulong m_seconds);
 
773
extern uint my_set_max_open_files(uint files);
476
774
void my_free_open_file_info(void);
477
775
 
 
776
extern time_t my_time(myf flags);
478
777
extern uint64_t my_getsystime(void);
479
778
extern uint64_t my_micro_time(void);
480
779
extern uint64_t my_micro_time_and_time(time_t *time_arg);
481
780
time_t my_time_possible_from_micro(uint64_t microtime);
 
781
extern bool my_gethwaddr(uchar *to);
 
782
extern int my_getncpus(void);
482
783
 
483
784
#ifdef HAVE_SYS_MMAN_H
484
785
#include <sys/mman.h>
513
814
int my_munmap(void *, size_t);
514
815
#endif
515
816
 
 
817
/* my_getpagesize */
 
818
#ifdef HAVE_GETPAGESIZE
 
819
#define my_getpagesize()        getpagesize()
 
820
#else
 
821
int my_getpagesize(void);
 
822
#endif
 
823
 
516
824
/* character sets */
517
 
void *cs_alloc(size_t size);
518
 
 
519
 
extern uint32_t get_charset_number(const char *cs_name, uint32_t cs_flags);
520
 
extern uint32_t get_collation_number(const char *name);
521
 
extern const char *get_charset_name(uint32_t cs_number);
522
 
 
523
 
extern const CHARSET_INFO *get_charset(uint32_t cs_number, myf flags);
524
 
extern const CHARSET_INFO *get_charset_by_name(const char *cs_name, myf flags);
525
 
extern const CHARSET_INFO *get_charset_by_csname(const char *cs_name, uint32_t cs_flags, myf my_flags);
 
825
extern uint get_charset_number(const char *cs_name, uint cs_flags);
 
826
extern uint get_collation_number(const char *name);
 
827
extern const char *get_charset_name(uint cs_number);
 
828
 
 
829
extern CHARSET_INFO *get_charset(uint cs_number, myf flags);
 
830
extern CHARSET_INFO *get_charset_by_name(const char *cs_name, myf flags);
 
831
extern CHARSET_INFO *get_charset_by_csname(const char *cs_name,
 
832
                                           uint cs_flags, myf my_flags);
526
833
 
527
834
extern bool resolve_charset(const char *cs_name,
528
 
                            const CHARSET_INFO *default_cs,
529
 
                            const CHARSET_INFO **cs);
 
835
                               CHARSET_INFO *default_cs,
 
836
                               CHARSET_INFO **cs);
530
837
extern bool resolve_collation(const char *cl_name,
531
 
                             const CHARSET_INFO *default_cl,
532
 
                             const CHARSET_INFO **cl);
 
838
                                 CHARSET_INFO *default_cl,
 
839
                                 CHARSET_INFO **cl);
533
840
 
534
841
extern void free_charsets(void);
535
842
extern char *get_charsets_dir(char *buf);
543
850
                                        char *to, size_t to_length,
544
851
                                        const char *from, size_t length);
545
852
 
546
 
extern void thd_increment_bytes_sent(uint32_t length);
547
 
extern void thd_increment_bytes_received(uint32_t length);
548
 
extern void thd_increment_net_big_packet_count(uint32_t length);
549
 
 
550
 
#ifdef __cplusplus
551
 
}
552
 
#endif
553
 
 
 
853
extern void thd_increment_bytes_sent(ulong length);
 
854
extern void thd_increment_bytes_received(ulong length);
 
855
extern void thd_increment_net_big_packet_count(ulong length);
 
856
 
 
857
C_MODE_END
554
858
#endif /* _my_sys_h */