← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to mysys/my_sys.h

  • Committer: Stewart Smith
  • Date: 2009-01-12 05:43:13 UTC
  • mto: (784.1.4 for-brian)
  • mto: This revision was merged to the branch mainline in revision 785.
  • Revision ID: stewart@flamingspork.com-20090112054313-edk6kpf4l6kpz4j7
fix archive_basic for drizzle

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
 
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
27
23
 
28
24
#include <errno.h>
29
25
#define my_errno (errno)
33
29
#include <mystrings/m_ctype.h>                    /* for CHARSET_INFO */
34
30
#include <stdarg.h>
35
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
36
40
 
37
41
#define MY_INIT(name);          { my_progname= name; my_init(); }
38
42
 
 
43
/* Max width of screen (for error messages) */
 
44
#define SC_MAXWIDTH 256
39
45
#define ERRMSGSIZE      (SC_MAXWIDTH)   /* Max length of a error message */
40
46
#define NRERRBUFFS      (2)     /* Buffers for parameters */
41
47
#define MY_FILE_ERROR   ((size_t) -1)
49
55
#define MY_WAIT_IF_FULL 32      /* Wait and try again if disk full error */
50
56
#define MY_IGNORE_BADFD 32      /* my_sync: ignore 'bad descriptor' errors */
51
57
#define MY_SYNC_DIR     1024    /* my_create/delete/rename: sync directory */
52
 
#define MY_RAID         64      /* Support for RAID */
53
58
#define MY_FULL_IO     512      /* For my_read - loop intil I/O is complete */
54
59
#define MY_DONT_CHECK_FILESIZE 128 /* Option to init_io_cache() */
55
60
#define MY_LINK_WARNING 32      /* my_redel() gives warning if links */
58
63
#define MY_RESOLVE_LINK 128     /* my_realpath(); Only resolve links */
59
64
#define MY_HOLD_ORIGINAL_MODES 128  /* my_copy() holds to file modes */
60
65
#define MY_REDEL_MAKE_BACKUP 256
61
 
#define MY_SEEK_NOT_DONE 32     /* my_lock may have to do a seek */
62
66
#define MY_DONT_WAIT    64      /* my_lock() don't wait if can't lock */
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 */
 
67
#define MY_ZEROFILL     32      /* my_multi_malloc(), fill array with zero */
67
68
#define MY_DONT_OVERWRITE_FILE 1024     /* my_copy: Don't overwrite file */
68
69
#define MY_THREADSAFE 2048      /* my_seek(): lock fd mutex */
69
70
 
100
101
#define MY_APPEND_EXT           256     /* add 'ext' as additional extension*/
101
102
 
102
103
 
103
 
        /* My seek flags */
104
 
#define MY_SEEK_SET     0
105
 
#define MY_SEEK_CUR     1
106
 
#define MY_SEEK_END     2
107
 
 
108
104
        /* Some constants */
109
105
#define MY_WAIT_FOR_USER_TO_FIX_PANIC   60      /* in seconds */
110
106
#define MY_WAIT_GIVE_USER_A_MESSAGE     10      /* Every 10 times of prev */
111
 
#define MIN_COMPRESS_LENGTH             50      /* Don't compress small bl. */
112
107
#define DFLT_INIT_HITS  3
113
108
 
114
109
        /* root_alloc flags */
127
122
#define GETDATE_FIXEDLENGTH     16
128
123
 
129
124
        /* defines when allocating data */
130
 
#ifdef SAFEMALLOC
131
 
#else
132
125
#define my_checkmalloc()
133
126
#undef TERMINATE
134
127
#define TERMINATE(A,B) {}
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 */
 
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
 
150
136
#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 */
163
137
 
164
138
#ifndef errno                           /* did we already get it? */
165
139
#ifdef HAVE_ERRNO_AS_DEFINE
171
145
extern char errbuff[NRERRBUFFS][ERRMSGSIZE];
172
146
extern char *home_dir;                  /* Home directory for user */
173
147
extern const char *my_progname;         /* program-name (printed in errors) */
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 uint32_t my_thread_stack_size;
 
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;
179
152
 
180
153
/* charsets */
181
154
extern const CHARSET_INFO *default_charset_info;
188
161
extern uint     mysys_usage_id;
189
162
extern bool     my_init_done;
190
163
 
 
164
typedef void (*void_ptr_func)(void);
 
165
typedef void (*void_ptr_int_func)(int);
 
166
 
191
167
                                        /* Point to current my_message() */
192
 
extern void (*my_sigtstp_cleanup)(void),
 
168
extern void_ptr_func my_sigtstp_cleanup,
193
169
                                        /* Executed before jump to shell */
194
 
            (*my_sigtstp_restart)(void),
195
 
            (*my_abort_hook)(int);
 
170
            my_sigtstp_restart;
 
171
extern void_ptr_int_func my_abort_hook;
196
172
                                        /* Executed when comming from shell */
197
173
extern int my_umask,            /* Default creation mask  */
198
174
           my_umask_dir,
239
215
  int   rc_seek,error,inited;
240
216
  uint  rc_length,read_length,reclength;
241
217
  my_off_t rc_record_pos,end_of_file;
242
 
  uchar *rc_buff,*rc_buff2,*rc_pos,*rc_end,*rc_request_pos;
 
218
  unsigned char *rc_buff,*rc_buff2,*rc_pos,*rc_end,*rc_request_pos;
243
219
#ifdef HAVE_AIOWAIT
244
220
  int   use_async_io;
245
221
  my_aio_result aio_result;
257
233
{
258
234
  char *                name;
259
235
  enum file_type        type;
260
 
#if !defined(HAVE_PREAD)
261
 
  pthread_mutex_t       mutex;
262
 
#endif
263
236
};
264
237
 
265
238
extern struct st_my_file_info *my_file_info;
266
239
 
267
240
typedef struct st_dynamic_array
268
241
{
269
 
  uchar *buffer;
270
 
  uint elements,max_element;
271
 
  uint alloc_increment;
272
 
  uint size_of_element;
 
242
  unsigned char *buffer;
 
243
  size_t elements,max_element;
 
244
  uint32_t alloc_increment;
 
245
  uint32_t size_of_element;
273
246
} DYNAMIC_ARRAY;
274
247
 
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
 
  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;
433
248
 
434
249
typedef int (*qsort2_cmp)(const void *, const void *, const void *);
435
250
 
454
269
 
455
270
#define my_b_get(info) \
456
271
  ((info)->read_pos != (info)->read_end ?\
457
 
   ((info)->read_pos++, (int) (uchar) (info)->read_pos[-1]) :\
 
272
   ((info)->read_pos++, (int) (unsigned char) (info)->read_pos[-1]) :\
458
273
   _my_b_get(info))
459
274
 
460
275
        /* my_b_write_byte dosn't have any err-check */
469
284
#define my_b_tell(info) ((info)->pos_in_file + \
470
285
                         (size_t) (*(info)->current_pos - (info)->request_pos))
471
286
 
472
 
#define my_b_get_buffer_start(info) (info)->request_pos 
 
287
#define my_b_get_buffer_start(info) (info)->request_pos
473
288
#define my_b_get_bytes_in_buffer(info) (char*) (info)->read_end -   \
474
289
  (char*) my_b_get_buffer_start(info)
475
290
#define my_b_get_pos_in_file(info) (info)->pos_in_file
476
291
 
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() */
481
292
 
482
293
#define my_b_bytes_in_cache(info) (size_t) (*(info)->current_end - \
483
294
                                          *(info)->current_pos)
488
299
typedef int (*Process_option_func)(void *ctx, const char *group_name,
489
300
                                   const char *option);
490
301
 
 
302
int handle_default_option(void *in_ctx, const char *group_name,
 
303
                          const char *option);
 
304
 
491
305
#include <mysys/my_alloc.h>
492
306
 
493
307
 
495
309
 
496
310
extern int my_copy(const char *from,const char *to,myf MyFlags);
497
311
extern int my_delete(const char *name,myf MyFlags);
498
 
extern int my_getwd(char * buf,size_t size,myf MyFlags);
499
 
extern int my_setwd(const char *dir,myf MyFlags);
500
 
extern void *my_once_alloc(size_t Size,myf MyFlags);
501
 
extern void my_once_free(void);
502
 
extern char *my_once_strdup(const char *src,myf myflags);
503
 
extern void *my_once_memdup(const void *src, size_t len, myf myflags);
504
312
extern File my_open(const char *FileName,int Flags,myf MyFlags);
505
313
extern File my_register_filename(File fd, const char *FileName,
506
314
                                 enum file_type type_of_file,
507
 
                                 uint error_message_number, myf MyFlags);
 
315
                                 uint32_t error_message_number, myf MyFlags);
508
316
extern File my_create(const char *FileName,int CreateFlags,
509
317
                      int AccessFlags, myf MyFlags);
510
318
extern int my_close(File Filedes,myf MyFlags);
518
326
extern int my_delete_with_symlink(const char *name, myf MyFlags);
519
327
extern int my_rename_with_symlink(const char *from,const char *to,myf MyFlags);
520
328
extern int my_symlink(const char *content, const char *linkname, myf MyFlags);
521
 
extern size_t my_read(File Filedes,uchar *Buffer,size_t Count,myf MyFlags);
 
329
extern size_t my_read(File Filedes,unsigned char *Buffer,size_t Count,myf MyFlags);
522
330
extern int my_rename(const char *from,const char *to,myf MyFlags);
523
 
extern my_off_t my_seek(File fd,my_off_t pos,int whence,myf MyFlags);
524
 
extern my_off_t my_tell(File fd,myf MyFlags);
525
 
extern size_t my_write(File Filedes,const uchar *Buffer,size_t Count,
 
331
extern size_t my_write(File Filedes,const unsigned char *Buffer,size_t Count,
526
332
                     myf MyFlags);
527
 
extern size_t my_fwrite(FILE *stream,const uchar *Buffer,size_t Count,
528
 
                      myf MyFlags);
529
 
extern my_off_t my_fseek(FILE *stream,my_off_t pos,int whence,myf MyFlags);
530
 
extern void *_mymalloc(size_t uSize,const char *sFile,
531
 
                       uint uLine, myf MyFlag);
532
 
extern void *_myrealloc(void *pPtr,size_t uSize,const char *sFile,
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);
537
 
extern void *_my_memdup(const void *from, size_t length,
538
 
                        const char *sFile, uint uLine,myf MyFlag);
539
 
extern char * _my_strdup(const char *from, const char *sFile, uint uLine,
540
 
                         myf MyFlag);
541
 
extern char *_my_strndup(const char *from, size_t length,
542
 
                         const char *sFile, uint uLine,
543
 
                         myf MyFlag);
 
333
extern void * my_multi_malloc (myf MyFlags, ...);
 
334
extern int _sanity(const char *sFile, uint32_t uLine);
544
335
 
545
336
#define my_access access
546
337
extern int check_if_legal_filename(const char *path);
549
340
#define my_delete_allow_opened(fname,flags)  my_delete((fname),(flags))
550
341
 
551
342
#ifndef TERMINATE
552
 
extern void TERMINATE(FILE *file, uint flag);
 
343
extern void TERMINATE(FILE *file, uint32_t flag);
553
344
#endif
554
345
extern void init_glob_errs(void);
555
346
extern FILE *my_fopen(const char *FileName,int Flags,myf MyFlags);
557
348
extern int my_sync(File fd, myf my_flags);
558
349
extern int my_sync_dir(const char *dir_name, myf my_flags);
559
350
extern int my_sync_dir_by_file(const char *file_name, myf my_flags);
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)));
 
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)));
564
355
extern int my_error_register(const char **errmsgs, int first, int last);
565
356
extern const char **my_error_unregister(int first, int last);
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);
 
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);
568
359
extern bool my_init(void);
569
360
extern void my_end(int infoflag);
570
361
extern int my_redel(const char *from, const char *to, int MyFlags);
577
368
#define my_print_open_files()
578
369
#endif
579
370
 
580
 
extern bool init_tmpdir(MY_TMPDIR *tmpdir, const char *pathlist);
581
 
extern char *my_tmpdir(MY_TMPDIR *tmpdir);
582
 
extern void free_tmpdir(MY_TMPDIR *tmpdir);
583
 
 
584
 
extern void my_remember_signal(int signal_number,sig_handler (*func)(int));
 
371
extern void my_remember_signal(int signal_number,void (*func)(int));
585
372
extern size_t dirname_part(char * to,const char *name, size_t *to_res_length);
586
373
extern size_t dirname_length(const char *name);
587
374
#define base_name(A) (A+dirname_length(A))
588
 
extern int test_if_hard_path(const char *dir_name);
589
 
extern bool has_path(const char *name);
 
375
bool test_if_hard_path(const char *dir_name);
590
376
extern char *convert_dirname(char *to, const char *from, const char *from_end);
591
377
extern void to_unix_path(char * name);
592
378
extern char * fn_ext(const char *name);
593
379
extern char * fn_same(char * toname,const char *name,int flag);
594
380
extern char * fn_format(char * to,const char *name,const char *dir,
595
 
                           const char *form, uint flag);
 
381
                           const char *form, uint32_t flag);
596
382
extern size_t strlength(const char *str);
597
383
extern void pack_dirname(char * to,const char *from);
598
384
extern size_t unpack_dirname(char * to,const char *from);
619
405
extern int init_record_cache(RECORD_CACHE *info,size_t cachesize,File file,
620
406
                             size_t reclength,enum cache_type type,
621
407
                             bool use_async_io);
622
 
extern int read_cache_record(RECORD_CACHE *info,uchar *to);
 
408
extern int read_cache_record(RECORD_CACHE *info,unsigned char *to);
623
409
extern int end_record_cache(RECORD_CACHE *info);
624
410
extern int write_cache_record(RECORD_CACHE *info,my_off_t filepos,
625
 
                              const uchar *record,size_t length);
 
411
                              const unsigned char *record,size_t length);
626
412
extern int flush_write_cache(RECORD_CACHE *info);
627
 
extern sig_handler sigtstp_handler(int signal_number);
 
413
extern void sigtstp_handler(int signal_number);
628
414
extern void handle_recived_signals(void);
629
415
 
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);
 
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);
638
424
extern qsort2_cmp get_ptr_compare(size_t);
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);
 
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);
679
427
File create_temp_file(char *to, const char *dir, const char *pfx,
680
428
                      int mode, myf MyFlags);
681
 
#define my_init_dynamic_array(A,B,C,D) init_dynamic_array2(A,B,NULL,C,D CALLER_INFO)
682
 
#define my_init_dynamic_array_ci(A,B,C,D) init_dynamic_array2(A,B,NULL,C,D ORIG_CALLER_INFO)
683
 
#define my_init_dynamic_array2(A,B,C,D,E) init_dynamic_array2(A,B,C,D,E CALLER_INFO)
684
 
#define my_init_dynamic_array2_ci(A,B,C,D,E) init_dynamic_array2(A,B,C,D,E ORIG_CALLER_INFO)
685
 
extern bool init_dynamic_array2(DYNAMIC_ARRAY *array,uint element_size,
686
 
                                   void *init_buffer, uint init_alloc, 
687
 
                                   uint alloc_increment
688
 
                                   CALLER_INFO_PROTO);
 
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);
689
436
/* init_dynamic_array() function is deprecated */
690
 
extern bool init_dynamic_array(DYNAMIC_ARRAY *array,uint element_size,
691
 
                                  uint init_alloc,uint alloc_increment
692
 
                                  CALLER_INFO_PROTO);
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);
 
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);
699
445
extern void delete_dynamic(DYNAMIC_ARRAY *array);
700
 
extern void delete_dynamic_element(DYNAMIC_ARRAY *array, uint array_index);
 
446
extern void delete_dynamic_element(DYNAMIC_ARRAY *array, uint32_t array_index);
701
447
extern void freeze_size(DYNAMIC_ARRAY *array);
702
 
extern int  get_index_dynamic(DYNAMIC_ARRAY *array, uchar * element);
 
448
extern int  get_index_dynamic(DYNAMIC_ARRAY *array, unsigned char * element);
703
449
#define dynamic_array_ptr(array,array_index) ((array)->buffer+(array_index)*(array)->size_of_element)
704
450
#define dynamic_element(array,array_index,type) ((type)((array)->buffer) +(array_index))
705
451
#define push_dynamic(A,B) insert_dynamic((A),(B))
706
452
#define reset_dynamic(array) ((array)->elements= 0)
707
453
#define sort_dynamic(A,cmp) my_qsort((A)->buffer, (A)->elements, (A)->size_of_element, (cmp))
708
454
 
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);
720
 
#define my_malloc_lock(A,B) my_malloc((A),(B))
721
 
#define my_free_lock(A,B) my_free((A),(B))
722
455
#define alloc_root_inited(A) ((A)->min_malloc != 0)
723
456
#define ALLOC_ROOT_MIN_BLOCK_SIZE (MALLOC_OVERHEAD + sizeof(USED_MEM) + 8)
724
457
#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);
736
458
extern int get_defaults_options(int argc, char **argv,
737
459
                                char **defaults, char **extra_defaults,
738
460
                                char **group_suffix);
742
464
                                const char *option_value,
743
465
                                const char *section_name, int remove_option);
744
466
extern int my_search_option_files(const char *conf_file, int *argc,
745
 
                                  char ***argv, uint *args_used,
 
467
                                  char ***argv, uint32_t *args_used,
746
468
                                  Process_option_func func, void *func_ctx);
747
469
extern void free_defaults(char **argv);
748
470
extern void my_print_default_files(const char *conf_file);
749
471
extern void print_defaults(const char *conf_file, const char **groups);
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,
 
472
extern ha_checksum my_checksum(ha_checksum crc, const unsigned char *mem,
755
473
                               size_t count);
756
474
extern void my_sleep(uint32_t m_seconds);
757
 
extern uint my_set_max_open_files(uint files);
 
475
extern uint32_t my_set_max_open_files(uint32_t files);
758
476
void my_free_open_file_info(void);
759
477
 
760
 
extern time_t my_time(myf flags);
761
478
extern uint64_t my_getsystime(void);
762
479
extern uint64_t my_micro_time(void);
763
480
extern uint64_t my_micro_time_and_time(time_t *time_arg);
764
481
time_t my_time_possible_from_micro(uint64_t microtime);
765
 
extern bool my_gethwaddr(uchar *to);
766
482
 
767
483
#ifdef HAVE_SYS_MMAN_H
768
484
#include <sys/mman.h>
798
514
#endif
799
515
 
800
516
/* character sets */
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);
804
 
 
805
 
extern const CHARSET_INFO *get_charset(uint cs_number, myf flags);
 
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);
806
524
extern const CHARSET_INFO *get_charset_by_name(const char *cs_name, myf flags);
807
 
extern const CHARSET_INFO *get_charset_by_csname(const char *cs_name, uint cs_flags, myf my_flags);
 
525
extern const CHARSET_INFO *get_charset_by_csname(const char *cs_name, uint32_t cs_flags, myf my_flags);
808
526
 
809
527
extern bool resolve_charset(const char *cs_name,
810
528
                            const CHARSET_INFO *default_cs,
829
547
extern void thd_increment_bytes_received(uint32_t length);
830
548
extern void thd_increment_net_big_packet_count(uint32_t length);
831
549
 
832
 
C_MODE_END
 
550
#ifdef __cplusplus
 
551
}
 
552
#endif
 
553
 
833
554
#endif /* _my_sys_h */