1 /* Copyright (c) 2000, 2021, Oracle and/or its affiliates.
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, version 2.0,
5 as published by the Free Software Foundation.
6
7 This program is also distributed with certain software (including
8 but not limited to OpenSSL) that is licensed under separate terms,
9 as designated in a particular file or component or in included license
10 documentation. The authors of MySQL hereby grant you an additional
11 permission to link the program and your derivative works with the
12 separately licensed software that they have included with MySQL.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License, version 2.0, for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
22
23 #ifndef _my_sys_h
24 #define _my_sys_h
25
26 #include "my_global.h" /* C_MODE_START, C_MODE_END */
27 #include "m_ctype.h" /* for CHARSET_INFO */
28
29 #include "my_thread.h" /* Needed for psi.h */
30 #include "mysql/psi/psi.h"
31 #include "mysql/service_mysql_alloc.h"
32 #include "mysql/psi/mysql_memory.h"
33 #include "mysql/psi/mysql_thread.h"
34
35 #ifdef HAVE_ALLOCA_H
36 #include <alloca.h>
37 #endif
38 #ifdef _WIN32
39 #include <malloc.h>
40 #endif
41 #ifdef HAVE_UNISTD_H
42 #include <unistd.h>
43 #endif
44 #include <sys/stat.h>
45
46 C_MODE_START
47
48 #ifdef HAVE_VALGRIND
49 # include <valgrind/valgrind.h>
50 # define MEM_MALLOCLIKE_BLOCK(p1, p2, p3, p4) VALGRIND_MALLOCLIKE_BLOCK(p1, p2, p3, p4)
51 # define MEM_FREELIKE_BLOCK(p1, p2) VALGRIND_FREELIKE_BLOCK(p1, p2)
52 # include <valgrind/memcheck.h>
53 # define MEM_UNDEFINED(a,len) VALGRIND_MAKE_MEM_UNDEFINED(a,len)
54 # define MEM_NOACCESS(a,len) VALGRIND_MAKE_MEM_NOACCESS(a,len)
55 # define MEM_CHECK_ADDRESSABLE(a,len) VALGRIND_CHECK_MEM_IS_ADDRESSABLE(a,len)
56 #else /* HAVE_VALGRIND */
57 # define MEM_MALLOCLIKE_BLOCK(p1, p2, p3, p4) do {} while (0)
58 # define MEM_FREELIKE_BLOCK(p1, p2) do {} while (0)
59 # define MEM_UNDEFINED(a,len) ((void) 0)
60 # define MEM_NOACCESS(a,len) ((void) 0)
61 # define MEM_CHECK_ADDRESSABLE(a,len) ((void) 0)
62 #endif /* HAVE_VALGRIND */
63
64 #include <typelib.h>
65
66 #define MY_INIT(name) { my_progname= name; my_init(); }
67
68 /**
69 Max length of an error message generated by mysys utilities.
70 Some mysys functions produce error messages. These mostly go
71 to stderr.
72 This constant defines the size of the buffer used to format
73 the message. It should be kept in sync with MYSQL_ERRMSG_SIZE,
74 since sometimes mysys errors are stored in the server diagnostics
75 area, and we would like to avoid unexpected truncation.
76 */
77 #define MYSYS_ERRMSG_SIZE (512)
78 #define MYSYS_STRERROR_SIZE (128)
79
80 #define MY_FILE_ERROR ((size_t) -1)
81
82 /* General bitmaps for my_func's */
83 #define MY_FFNF 1 /* Fatal if file not found */
84 #define MY_FNABP 2 /* Fatal if not all bytes read/writen */
85 #define MY_NABP 4 /* Error if not all bytes read/writen */
86 #define MY_FAE 8 /* Fatal if any error */
87 #define MY_WME 16 /* Write message on error */
88 #define MY_WAIT_IF_FULL 32 /* Wait and try again if disk full error */
89 #define MY_IGNORE_BADFD 32 /* my_sync: ignore 'bad descriptor' errors */
90 #define MY_SYNC_DIR 8192 /* my_create/delete/rename: sync directory */
91 #define MY_UNUSED 64 /* Unused (was support for RAID) */
92 #define MY_FULL_IO 512 /* For my_read - loop intil I/O is complete */
93 #define MY_DONT_CHECK_FILESIZE 128 /* Option to init_io_cache() */
94 #define MY_LINK_WARNING 32 /* my_redel() gives warning if links */
95 #define MY_COPYTIME 64 /* my_redel() copys time */
96 #define MY_DELETE_OLD 256 /* my_create_with_symlink() */
97 #define MY_RESOLVE_LINK 128 /* my_realpath(); Only resolve links */
98 #define MY_HOLD_ORIGINAL_MODES 128 /* my_copy() holds to file modes */
99 #define MY_REDEL_MAKE_BACKUP 256
100 #define MY_REDEL_NO_COPY_STAT 512 /* my_redel() doesn't call my_copystat() */
101 #define MY_SEEK_NOT_DONE 32 /* my_lock may have to do a seek */
102 #define MY_DONT_WAIT 64 /* my_lock() don't wait if can't lock */
103 #define MY_ZEROFILL 32 /* my_malloc(), fill array with zero */
104 #define MY_ALLOW_ZERO_PTR 64 /* my_realloc() ; zero ptr -> malloc */
105 #define MY_FREE_ON_ERROR 128 /* my_realloc() ; Free old ptr on error */
106 #define MY_HOLD_ON_ERROR 256 /* my_realloc() ; Return old ptr on error */
107 #define MY_DONT_OVERWRITE_FILE 1024 /* my_copy: Don't overwrite file */
108 #define MY_THREADSAFE 2048 /* my_seek(): lock fd mutex */
109 #define MY_SYNC 4096 /* my_copy(): sync dst file */
110
111 #define MYF_RW MYF(MY_WME+MY_NABP) /* For my_read & my_write */
112
113 #define MY_CHECK_ERROR 1 /* Params to my_end; Check open-close */
114 #define MY_GIVE_INFO 2 /* Give time info about process*/
115 #define MY_DONT_FREE_DBUG 4 /* Do not call DBUG_END() in my_end() */
116
117 /* Flags for my_error() */
118 #define ME_BELL 4 /* DEPRECATED: Ring bell then printing message */
119 #define ME_ERRORLOG 64 /* Write the error message to error log */
120 #define ME_FATALERROR 1024 /* Fatal statement error */
121
122 /* Bits in last argument to fn_format */
123 #define MY_REPLACE_DIR 1 /* replace dir in name with 'dir' */
124 #define MY_REPLACE_EXT 2 /* replace extension with 'ext' */
125 #define MY_UNPACK_FILENAME 4 /* Unpack name (~ -> home) */
126 #define MY_PACK_FILENAME 8 /* Pack name (home -> ~) */
127 #define MY_RESOLVE_SYMLINKS 16 /* Resolve all symbolic links */
128 #define MY_RETURN_REAL_PATH 32 /* return full path for file */
129 #define MY_SAFE_PATH 64 /* Return NULL if too long path */
130 #define MY_RELATIVE_PATH 128 /* name is relative to 'dir' */
131 #define MY_APPEND_EXT 256 /* add 'ext' as additional extension*/
132
133
134 /* My seek flags */
135 #define MY_SEEK_SET 0
136 #define MY_SEEK_CUR 1
137 #define MY_SEEK_END 2
138
139 /* Some constants */
140 #define MY_WAIT_FOR_USER_TO_FIX_PANIC 60 /* in seconds */
141 #define MY_WAIT_GIVE_USER_A_MESSAGE 10 /* Every 10 times of prev */
142 #define MIN_COMPRESS_LENGTH 50 /* Don't compress small bl. */
143 #define DFLT_INIT_HITS 3
144
145 /* root_alloc flags */
146 #define MY_KEEP_PREALLOC 1
147 #define MY_MARK_BLOCKS_FREE 2 /* move used to free list and reuse them */
148
149 /* Internal error numbers (for assembler functions) */
150 #define MY_ERRNO_EDOM 33
151 #define MY_ERRNO_ERANGE 34
152
153 /* Bits for get_date timeflag */
154 #define GETDATE_DATE_TIME 1
155 #define GETDATE_SHORT_DATE 2
156 #define GETDATE_HHMMSSTIME 4
157 #define GETDATE_GMT 8
158 #define GETDATE_FIXEDLENGTH 16
159 #define GETDATE_T_DELIMITER 32
160 #define GETDATE_SHORT_DATE_FULL_YEAR 64
161
162 /* defines when allocating data */
163 extern void *my_multi_malloc(PSI_memory_key key, myf flags, ...);
164
165 /*
166 Switch to my_malloc() if the memory block to be allocated is bigger than
167 max_alloca_sz.
168 */
169 extern PSI_memory_key key_memory_max_alloca;
170 #define my_safe_alloca(size, max_alloca_sz) ((size <= max_alloca_sz) ? \
171 my_alloca(size) : \
172 my_malloc(key_memory_max_alloca, size, MYF(0)))
173 #define my_safe_afree(ptr, size, max_alloca_sz) if (size > max_alloca_sz) \
174 my_free(ptr)
175
176 #if !defined(NDEBUG) || defined(HAVE_VALGRIND)
177 /**
178 Put bad content in memory to be sure it will segfault if dereferenced.
179 With Valgrind, verify that memory is addressable, and mark it undefined.
180 We cache value of B because if B is expression which depends on A, memset()
181 trashes value of B.
182 */
183 #define TRASH(A,B) do { \
184 void *p = (A); \
185 const size_t l= (B); \
186 MEM_CHECK_ADDRESSABLE(A, l); \
187 memset(p, 0x8F, l); \
188 MEM_UNDEFINED(A, l); \
189 } while (0)
190 #else
191 #define TRASH(A,B) do {} while(0)
192 #endif
193 #if defined(ENABLED_DEBUG_SYNC)
194 extern void (*debug_sync_C_callback_ptr)(const char *, size_t);
195 #define DEBUG_SYNC_C(_sync_point_name_) do { \
196 if (debug_sync_C_callback_ptr != NULL) \
197 (*debug_sync_C_callback_ptr)(STRING_WITH_LEN(_sync_point_name_)); } \
198 while(0)
199 #define DEBUG_SYNC_C_IF_THD(thd, _sync_point_name_) do { \
200 if (debug_sync_C_callback_ptr != NULL && thd) \
201 (*debug_sync_C_callback_ptr)(STRING_WITH_LEN(_sync_point_name_)); } \
202 while(0)
203 #else
204 #define DEBUG_SYNC_C(_sync_point_name_)
205 #define DEBUG_SYNC_C_IF_THD(thd, _sync_point_name_)
206 #endif /* defined(ENABLED_DEBUG_SYNC) */
207
208 #ifdef HAVE_LINUX_LARGE_PAGES
209 extern uint my_get_large_page_size(void);
210 extern uchar * my_large_malloc(PSI_memory_key key, size_t size, myf my_flags);
211 extern void my_large_free(uchar *ptr);
212 extern my_bool my_use_large_pages;
213 extern uint my_large_page_size;
214 #else
215 #define my_get_large_page_size() (0)
216 #define my_large_malloc(A,B,C) my_malloc((A),(B),(C))
217 #define my_large_free(A) my_free((A))
218 #endif /* HAVE_LINUX_LARGE_PAGES */
219
220 #define my_alloca(SZ) alloca((size_t) (SZ))
221
222 #include <errno.h> /* errno is a define */
223
224 extern char *home_dir; /* Home directory for user */
225 extern const char *my_progname; /* program-name (printed in errors) */
226 extern char curr_dir[]; /* Current directory for user */
227 extern void (*error_handler_hook)(uint my_err, const char *str,myf MyFlags);
228 extern void (*fatal_error_handler_hook)(uint my_err, const char *str,
229 myf MyFlags);
230 extern void (*local_message_hook)(enum loglevel ll,
231 const char *format, va_list args);
232 extern uint my_file_limit;
233 extern MYSQL_PLUGIN_IMPORT ulong my_thread_stack_size;
234
235 /*
236 Hooks for reporting execution stage information. The server implementation
237 of these will also set THD::current_cond/current_mutex.
238 By having hooks, we avoid direct dependencies on server code.
239 */
240 extern void (*enter_cond_hook)(void *opaque_thd,
241 mysql_cond_t *cond,
242 mysql_mutex_t *mutex,
243 const PSI_stage_info *stage,
244 PSI_stage_info *old_stage,
245 const char *src_function,
246 const char *src_file,
247 int src_line);
248
249 extern void (*exit_cond_hook)(void *opaque_thd,
250 const PSI_stage_info *stage,
251 const char *src_function,
252 const char *src_file,
253 int src_line);
254
255 /*
256 Hook for checking if the thread has been killed.
257 */
258 extern int (*is_killed_hook)(const void *opaque_thd);
259
260 /* charsets */
261 #define MY_ALL_CHARSETS_SIZE 2048
262 extern MYSQL_PLUGIN_IMPORT CHARSET_INFO *default_charset_info;
263 extern MYSQL_PLUGIN_IMPORT CHARSET_INFO *all_charsets[MY_ALL_CHARSETS_SIZE];
264 extern CHARSET_INFO compiled_charsets[];
265
266 /* statistics */
267 extern ulong my_file_opened,my_stream_opened, my_tmp_file_created;
268 extern ulong my_file_total_opened;
269 extern my_bool my_init_done;
270
271 extern MYSQL_PLUGIN_IMPORT int my_umask; /* Default creation mask */
272 extern int my_umask_dir;
273
274 extern ulong my_default_record_cache_size;
275 extern my_bool my_disable_locking,
276 my_enable_symlinks;
277 extern char wild_many,wild_one,wild_prefix;
278 extern const char *charsets_dir;
279
280 enum cache_type
281 {
282 TYPE_NOT_SET= 0, READ_CACHE, WRITE_CACHE,
283 SEQ_READ_APPEND /* sequential read or append */,
284 READ_FIFO, READ_NET,WRITE_NET};
285
286 enum flush_type
287 {
288 FLUSH_KEEP, /* flush block and keep it in the cache */
289 FLUSH_RELEASE, /* flush block and remove it from the cache */
290 FLUSH_IGNORE_CHANGED, /* remove block from the cache */
291 /*
292 As my_disable_flush_pagecache_blocks is always 0, the following option
293 is strictly equivalent to FLUSH_KEEP
294 */
295 FLUSH_FORCE_WRITE
296 };
297
298 enum file_type
299 {
300 UNOPEN = 0, FILE_BY_OPEN, FILE_BY_CREATE, STREAM_BY_FOPEN, STREAM_BY_FDOPEN,
301 FILE_BY_MKSTEMP, FILE_BY_DUP
302 };
303
304 struct st_my_file_info
305 {
306 char *name;
307 #ifdef _WIN32
308 HANDLE fhandle; /* win32 file handle */
309 int oflag; /* open flags, e.g O_APPEND */
310 #endif
311 enum file_type type;
312 };
313
314 extern struct st_my_file_info *my_file_info;
315
316 /* needed for client-only build */
317 #ifndef PSI_FILE_KEY_DEFINED
318 typedef unsigned int PSI_file_key;
319 #define PSI_FILE_KEY_DEFINED
320 #endif
321
322 typedef struct st_dynamic_array
323 {
324 uchar *buffer;
325 uint elements,max_element;
326 uint alloc_increment;
327 uint size_of_element;
328 PSI_memory_key m_psi_key;
329 } DYNAMIC_ARRAY;
330
331 typedef struct st_my_tmpdir
332 {
333 char **list;
334 uint cur, max;
335 mysql_mutex_t mutex;
336 } MY_TMPDIR;
337
338 typedef struct st_dynamic_string
339 {
340 char *str;
341 size_t length,max_length,alloc_increment;
342 } DYNAMIC_STRING;
343
344 struct st_io_cache;
345 typedef int (*IO_CACHE_CALLBACK)(struct st_io_cache*);
346
347 typedef struct st_io_cache_share
348 {
349 mysql_mutex_t mutex; /* To sync on reads into buffer. */
350 mysql_cond_t cond; /* To wait for signals. */
351 mysql_cond_t cond_writer; /* For a synchronized writer. */
352 /* Offset in file corresponding to the first byte of buffer. */
353 my_off_t pos_in_file;
354 /* If a synchronized write cache is the source of the data. */
355 struct st_io_cache *source_cache;
356 uchar *buffer; /* The read buffer. */
357 uchar *read_end; /* Behind last valid byte of buffer. */
358 int running_threads; /* threads not in lock. */
359 int total_threads; /* threads sharing the cache. */
360 int error; /* Last error. */
361 } IO_CACHE_SHARE;
362
363 typedef struct st_io_cache /* Used when cacheing files */
364 {
365 /* Offset in file corresponding to the first byte of uchar* buffer. */
366 my_off_t pos_in_file;
367 /*
368 The offset of end of file for READ_CACHE and WRITE_CACHE.
369 For SEQ_READ_APPEND it the maximum of the actual end of file and
370 the position represented by read_end.
371 */
372 my_off_t end_of_file;
373 /* Points to current read position in the buffer */
374 uchar *read_pos;
375 /* the non-inclusive boundary in the buffer for the currently valid read */
376 uchar *read_end;
377 uchar *buffer; /* The read buffer */
378 /* Used in ASYNC_IO */
379 uchar *request_pos;
380
381 /* Only used in WRITE caches and in SEQ_READ_APPEND to buffer writes */
382 uchar *write_buffer;
383 /*
384 Only used in SEQ_READ_APPEND, and points to the current read position
385 in the write buffer. Note that reads in SEQ_READ_APPEND caches can
386 happen from both read buffer (uchar* buffer) and write buffer
387 (uchar* write_buffer).
388 */
389 uchar *append_read_pos;
390 /* Points to current write position in the write buffer */
391 uchar *write_pos;
392 /* The non-inclusive boundary of the valid write area */
393 uchar *write_end;
394
395 /*
396 Current_pos and current_end are convenience variables used by
397 my_b_tell() and other routines that need to know the current offset
398 current_pos points to &write_pos, and current_end to &write_end in a
399 WRITE_CACHE, and &read_pos and &read_end respectively otherwise
400 */
401 uchar **current_pos, **current_end;
402
403 /*
404 The lock is for append buffer used in SEQ_READ_APPEND cache
405 need mutex copying from append buffer to read buffer.
406 */
407 mysql_mutex_t append_buffer_lock;
408 /*
409 The following is used when several threads are reading the
410 same file in parallel. They are synchronized on disk
411 accesses reading the cached part of the file asynchronously.
412 It should be set to NULL to disable the feature. Only
413 READ_CACHE mode is supported.
414 */
415 IO_CACHE_SHARE *share;
416
417 /*
418 A caller will use my_b_read() macro to read from the cache
419 if the data is already in cache, it will be simply copied with
420 memcpy() and internal variables will be accordinging updated with
421 no functions invoked. However, if the data is not fully in the cache,
422 my_b_read() will call read_function to fetch the data. read_function
423 must never be invoked directly.
424 */
425 int (*read_function)(struct st_io_cache *,uchar *,size_t);
426 /*
427 Same idea as in the case of read_function, except my_b_write() needs to
428 be replaced with my_b_append() for a SEQ_READ_APPEND cache
429 */
430 int (*write_function)(struct st_io_cache *,const uchar *,size_t);
431 /*
432 Specifies the type of the cache. Depending on the type of the cache
433 certain operations might not be available and yield unpredicatable
434 results. Details to be documented later
435 */
436 enum cache_type type;
437 /*
438 Callbacks when the actual read I/O happens. These were added and
439 are currently used for binary logging of LOAD DATA INFILE - when a
440 block is read from the file, we create a block create/append event, and
441 when IO_CACHE is closed, we create an end event. These functions could,
442 of course be used for other things
443 */
444 IO_CACHE_CALLBACK pre_read;
445 IO_CACHE_CALLBACK post_read;
446 IO_CACHE_CALLBACK pre_close;
447 /*
448 Counts the number of times, when we were forced to use disk. We use it to
449 increase the binlog_cache_disk_use and binlog_stmt_cache_disk_use status
450 variables.
451 */
452 ulong disk_writes;
453 void* arg; /* for use by pre/post_read */
454 char *file_name; /* if used with 'open_cached_file' */
455 char *dir,*prefix;
456 File file; /* file descriptor */
457 PSI_file_key file_key; /* instrumented file key */
458
459 /*
460 seek_not_done is set by my_b_seek() to inform the upcoming read/write
461 operation that a seek needs to be preformed prior to the actual I/O
462 error is 0 if the cache operation was successful, -1 if there was a
463 "hard" error, and the actual number of I/O-ed bytes if the read/write was
464 partial.
465 */
466 int seek_not_done,error;
467 /* buffer_length is memory size allocated for buffer or write_buffer */
468 size_t buffer_length;
469 /* read_length is the same as buffer_length except when we use async io */
470 size_t read_length;
471 myf myflags; /* Flags used to my_read/my_write */
472 /*
473 alloced_buffer is 1 if the buffer was allocated by init_io_cache() and
474 0 if it was supplied by the user.
475 Currently READ_NET is the only one that will use a buffer allocated
476 somewhere else
477 */
478 my_bool alloced_buffer;
479 } IO_CACHE;
480
481 typedef int (*qsort2_cmp)(const void *, const void *, const void *);
482
483 /*
484 Subset of struct stat fields filled by stat/lstat/fstat that uniquely
485 identify a file
486 */
487 typedef struct st_file_id
488 {
489 dev_t st_dev;
490 ino_t st_ino;
491 } ST_FILE_ID;
492
493 typedef void (*my_error_reporter)(enum loglevel level, const char *format, ...)
494 MY_ATTRIBUTE((format(printf, 2, 3)));
495
496 extern my_error_reporter my_charset_error_reporter;
497
498 /* defines for mf_iocache */
499 extern PSI_file_key key_file_io_cache;
500
501 /* Test if buffer is inited */
502 #define my_b_clear(info) (info)->buffer=0
503 #define my_b_inited(info) (info)->buffer
504 #define my_b_EOF INT_MIN
505
506 #define my_b_read(info,Buffer,Count) \
507 ((info)->read_pos + (Count) <= (info)->read_end ?\
508 (memcpy(Buffer,(info)->read_pos,(size_t) (Count)), \
509 ((info)->read_pos+=(Count)),0) :\
510 (*(info)->read_function)((info),Buffer,Count))
511
512 #define my_b_write(info,Buffer,Count) \
513 ((info)->write_pos + (Count) <=(info)->write_end ?\
514 (memcpy((info)->write_pos, (Buffer), (size_t)(Count)),\
515 ((info)->write_pos+=(Count)),0) : \
516 (*(info)->write_function)((info),(uchar *)(Buffer),(Count)))
517
518 #define my_b_get(info) \
519 ((info)->read_pos != (info)->read_end ?\
520 ((info)->read_pos++, (int) (uchar) (info)->read_pos[-1]) :\
521 _my_b_get(info))
522
523 #define my_b_tell(info) ((info)->pos_in_file + \
524 (size_t) (*(info)->current_pos - (info)->request_pos))
525
526 #define my_b_get_buffer_start(info) (info)->request_pos
527 #define my_b_get_bytes_in_buffer(info) (char*) (info)->read_end - \
528 (char*) my_b_get_buffer_start(info)
529 #define my_b_get_pos_in_file(info) (info)->pos_in_file
530
531 /* tell write offset in the SEQ_APPEND cache */
532 int my_b_copy_to_file(IO_CACHE *cache, FILE *file);
533 my_off_t my_b_append_tell(IO_CACHE* info);
534 my_off_t my_b_safe_tell(IO_CACHE* info); /* picks the correct tell() */
535
536 #define my_b_bytes_in_cache(info) (size_t) (*(info)->current_end - \
537 *(info)->current_pos)
538
539 typedef uint32 ha_checksum;
540
541 #include <my_alloc.h>
542
543
544 /* Prototypes for mysys and my_func functions */
545
546 extern int my_copy(const char *from,const char *to,myf MyFlags);
547 extern int my_delete(const char *name,myf MyFlags);
548 extern int my_getwd(char * buf,size_t size,myf MyFlags);
549 extern int my_setwd(const char *dir,myf MyFlags);
550 extern int my_lock(File fd,int op,my_off_t start, my_off_t length,myf MyFlags);
551 extern void *my_once_alloc(size_t Size,myf MyFlags);
552 extern void my_once_free(void);
553 extern char *my_once_strdup(const char *src,myf myflags);
554 extern void *my_once_memdup(const void *src, size_t len, myf myflags);
555 extern File my_open(const char *FileName,int Flags,myf MyFlags);
556 extern File my_register_filename(File fd, const char *FileName,
557 enum file_type type_of_file,
558 uint error_message_number, myf MyFlags);
559 extern File my_create(const char *FileName,int CreateFlags,
560 int AccessFlags, myf MyFlags);
561 extern int my_close(File Filedes,myf MyFlags);
562 extern int my_mkdir(const char *dir, int Flags, myf MyFlags);
563 extern int my_readlink(char *to, const char *filename, myf MyFlags);
564 extern int my_is_symlink(const char *filename, ST_FILE_ID *file_id);
565 extern int my_realpath(char *to, const char *filename, myf MyFlags);
566 extern int my_is_same_file(File file, const ST_FILE_ID *file_id);
567 extern File my_create_with_symlink(const char *linkname, const char *filename,
568 int createflags, int access_flags,
569 myf MyFlags);
570 extern int my_delete_with_symlink(const char *name, myf MyFlags);
571 extern int my_rename_with_symlink(const char *from,const char *to,myf MyFlags);
572 extern int my_symlink(const char *content, const char *linkname, myf MyFlags);
573 extern size_t my_read(File Filedes,uchar *Buffer,size_t Count,myf MyFlags);
574 extern size_t my_pread(File Filedes,uchar *Buffer,size_t Count,my_off_t offset,
575 myf MyFlags);
576 extern int my_rename(const char *from,const char *to,myf MyFlags);
577 extern my_off_t my_seek(File fd,my_off_t pos,int whence,myf MyFlags);
578 extern my_off_t my_tell(File fd,myf MyFlags);
579 extern size_t my_write(File Filedes,const uchar *Buffer,size_t Count,
580 myf MyFlags);
581 extern size_t my_pwrite(File Filedes,const uchar *Buffer,size_t Count,
582 my_off_t offset,myf MyFlags);
583 extern size_t my_fread(FILE *stream,uchar *Buffer,size_t Count,myf MyFlags);
584 extern size_t my_fwrite(FILE *stream,const uchar *Buffer,size_t Count,
585 myf MyFlags);
586 extern my_off_t my_fseek(FILE *stream,my_off_t pos,int whence,myf MyFlags);
587 extern my_off_t my_ftell(FILE *stream,myf MyFlags);
588
589 /* implemented in my_syslog.c */
590
591 // Maximum size of message that will be logged.
592 #define MAX_SYSLOG_MESSAGE_SIZE 1024
593
594 /* Platform-independent SysLog support */
595
596 /* facilities on unixoid syslog. harmless on systemd / Win platforms. */
597 typedef struct st_syslog_facility { int id; const char *name; } SYSLOG_FACILITY;
598 extern SYSLOG_FACILITY syslog_facility[];
599
600 enum my_syslog_options { MY_SYSLOG_PIDS= 1 };
601
602 int my_openlog(const char *eventSourceName, int option, int facility);
603 int my_closelog();
604 int my_syslog(const CHARSET_INFO *cs, enum loglevel level, const char *msg);
605
606 /* implemented in my_memmem.c */
607 extern void *my_memmem(const void *haystack, size_t haystacklen,
608 const void *needle, size_t needlelen);
609
610
611 #ifdef _WIN32
612 extern int my_access(const char *path, int amode);
613 #else
614 #define my_access access
615 #endif
616
617 extern int check_if_legal_filename(const char *path);
618 extern int check_if_legal_tablename(const char *path);
619
620 #ifdef _WIN32
621 extern my_bool is_filename_allowed(const char *name, size_t length,
622 my_bool allow_current_dir);
623 #else /* _WIN32 */
624 # define is_filename_allowed(name, length, allow_cwd) (TRUE)
625 #endif /* _WIN32 */
626
627 #ifdef _WIN32
628 extern int nt_share_delete(const char *name,myf MyFlags);
629 #define my_delete_allow_opened(fname,flags) nt_share_delete((fname),(flags))
630 #else
631 #define my_delete_allow_opened(fname,flags) my_delete((fname),(flags))
632 #endif
633
634 #ifdef _WIN32
635 /* Windows-only functions (CRT equivalents)*/
636 extern HANDLE my_get_osfhandle(File fd);
637 extern void my_osmaperr(unsigned long last_error);
638 #endif
639
640 extern const char* get_global_errmsg(int nr);
641 extern void wait_for_free_space(const char *filename, int errors);
642 extern FILE *my_fopen(const char *FileName,int Flags,myf MyFlags);
643 extern FILE *my_fdopen(File Filedes,const char *name, int Flags,myf MyFlags);
644 extern FILE *my_freopen(const char *path, const char *mode, FILE *stream);
645 extern int my_fclose(FILE *fd,myf MyFlags);
646 extern File my_fileno(FILE *fd);
647 extern int my_chsize(File fd,my_off_t newlength, int filler, myf MyFlags);
648 extern void thr_set_sync_wait_callback(void (*before_sync)(void),
649 void (*after_sync)(void));
650 extern int my_sync(File fd, myf my_flags);
651 extern int my_sync_dir(const char *dir_name, myf my_flags);
652 extern int my_sync_dir_by_file(const char *file_name, myf my_flags);
653 extern char *my_strerror(char *buf, size_t len, int errnum);
654 extern const char *my_get_err_msg(int nr);
655 extern void my_error(int nr,myf MyFlags, ...);
656 extern void my_printf_error(uint my_err, const char *format,
657 myf MyFlags, ...)
658 MY_ATTRIBUTE((format(printf, 2, 4)));
659 extern void my_printv_error(uint error, const char *format, myf MyFlags,
660 va_list ap);
661 extern int my_error_register(const char* (*get_errmsg) (int),
662 int first, int last);
663 extern my_bool my_error_unregister(int first, int last);
664 extern void my_message(uint my_err, const char *str,myf MyFlags);
665 extern void my_message_stderr(uint my_err, const char *str, myf MyFlags);
666 void my_message_local_stderr(enum loglevel ll,
667 const char *format, va_list args);
668 extern void my_message_local(enum loglevel ll, const char *format, ...);
669 extern my_bool my_init(void);
670 extern void my_end(int infoflag);
671 extern int my_redel(const char *from, const char *to, int MyFlags);
672 extern int my_copystat(const char *from, const char *to, int MyFlags);
673 extern char * my_filename(File fd);
674 extern MY_MODE get_file_perm(ulong perm_flags);
675 extern my_bool my_chmod(const char *filename, ulong perm_flags, myf my_flags);
676
677 #ifdef EXTRA_DEBUG
678 void my_print_open_files(void);
679 #else
680 #define my_print_open_files()
681 #endif
682
683 extern my_bool init_tmpdir(MY_TMPDIR *tmpdir, const char *pathlist);
684 extern char *my_tmpdir(MY_TMPDIR *tmpdir);
685 extern void free_tmpdir(MY_TMPDIR *tmpdir);
686
687 extern size_t dirname_part(char * to,const char *name, size_t *to_res_length);
688 extern size_t dirname_length(const char *name);
689 #define base_name(A) (A+dirname_length(A))
690 extern int test_if_hard_path(const char *dir_name);
691 extern my_bool has_path(const char *name);
692 extern char *convert_dirname(char *to, const char *from, const char *from_end);
693 extern void to_unix_path(char * name);
694 extern char * fn_ext(const char *name);
695 extern char * fn_same(char * toname,const char *name,int flag);
696 extern char * fn_format(char * to,const char *name,const char *dir,
697 const char *form, uint flag);
698 extern size_t strlength(const char *str);
699 extern void pack_dirname(char * to,const char *from);
700 extern size_t normalize_dirname(char * to, const char *from);
701 extern size_t unpack_dirname(char * to,const char *from);
702 extern size_t cleanup_dirname(char * to,const char *from);
703 extern size_t system_filename(char * to,const char *from);
704 extern size_t unpack_filename(char * to,const char *from);
705 extern char * intern_filename(char * to,const char *from);
706 extern int pack_filename(char * to, const char *name, size_t max_length);
707 extern char * my_path(char * to,const char *progname,
708 const char *own_pathname_part);
709 extern char * my_load_path(char * to, const char *path,
710 const char *own_path_prefix);
711 extern int wild_compare(const char *str,const char *wildstr,
712 pbool str_is_pattern);
713 extern my_bool array_append_string_unique(const char *str,
714 const char **array, size_t size);
715 extern void get_date(char * to,int timeflag,time_t use_time);
716 extern void soundex(CHARSET_INFO *, char * out_pntr, char * in_pntr,
717 pbool remove_garbage);
718
719 extern my_bool radixsort_is_appliccable(uint n_items, size_t size_of_element);
720 extern void radixsort_for_str_ptr(uchar* base[], uint number_of_elements,
721 size_t size_of_element,uchar *buffer[]);
722 extern void my_qsort(void *base_ptr, size_t total_elems, size_t size,
723 qsort_cmp cmp);
724 extern void my_qsort2(void *base_ptr, size_t total_elems, size_t size,
725 qsort2_cmp cmp, const void *cmp_argument);
726 void my_store_ptr(uchar *buff, size_t pack_length, my_off_t pos);
727 my_off_t my_get_ptr(uchar *ptr, size_t pack_length);
728 extern int init_io_cache_ext(IO_CACHE *info,File file,size_t cachesize,
729 enum cache_type type,my_off_t seek_offset,
730 pbool use_async_io, myf cache_myflags,
731 PSI_file_key file_key);
732 extern int init_io_cache(IO_CACHE *info,File file,size_t cachesize,
733 enum cache_type type,my_off_t seek_offset,
734 pbool use_async_io, myf cache_myflags);
735 extern my_bool reinit_io_cache(IO_CACHE *info,enum cache_type type,
736 my_off_t seek_offset,pbool use_async_io,
737 pbool clear_cache);
738 extern void setup_io_cache(IO_CACHE* info);
739 extern int _my_b_read(IO_CACHE *info,uchar *Buffer,size_t Count);
740 extern int _my_b_read_r(IO_CACHE *info,uchar *Buffer,size_t Count);
741 extern void init_io_cache_share(IO_CACHE *read_cache, IO_CACHE_SHARE *cshare,
742 IO_CACHE *write_cache, uint num_threads);
743 extern void remove_io_thread(IO_CACHE *info);
744 extern int _my_b_seq_read(IO_CACHE *info,uchar *Buffer,size_t Count);
745 extern int _my_b_net_read(IO_CACHE *info,uchar *Buffer,size_t Count);
746 extern int _my_b_get(IO_CACHE *info);
747 extern int _my_b_write(IO_CACHE *info,const uchar *Buffer,size_t Count);
748 extern int my_b_append(IO_CACHE *info,const uchar *Buffer,size_t Count);
749 extern int my_b_safe_write(IO_CACHE *info,const uchar *Buffer,size_t Count);
750
751 extern int my_block_write(IO_CACHE *info, const uchar *Buffer,
752 size_t Count, my_off_t pos);
753 extern int my_b_flush_io_cache(IO_CACHE *info, int need_append_buffer_lock);
754
755 #define flush_io_cache(info) my_b_flush_io_cache((info),1)
756
757 extern int end_io_cache(IO_CACHE *info);
758 extern size_t my_b_fill(IO_CACHE *info);
759 extern void my_b_seek(IO_CACHE *info,my_off_t pos);
760 extern size_t my_b_gets(IO_CACHE *info, char *to, size_t max_length);
761 extern my_off_t my_b_filelength(IO_CACHE *info);
762 extern size_t my_b_printf(IO_CACHE *info, const char* fmt, ...)
763 MY_ATTRIBUTE((format(printf, 2, 3)));
764 extern size_t my_b_vprintf(IO_CACHE *info, const char* fmt, va_list ap);
765 extern my_bool open_cached_file(IO_CACHE *cache,const char *dir,
766 const char *prefix, size_t cache_size,
767 myf cache_myflags);
768 extern my_bool real_open_cached_file(IO_CACHE *cache);
769 extern void close_cached_file(IO_CACHE *cache);
770 File create_temp_file(char *to, const char *dir, const char *pfx,
771 int mode, myf MyFlags);
772
773 // Use Prealloced_array or std::vector or something similar in C++
774
775 #ifdef __cplusplus
776 extern "C" {
777 #endif
778
779 extern my_bool my_init_dynamic_array(DYNAMIC_ARRAY *array,
780 PSI_memory_key key,
781 uint element_size,
782 void *init_buffer,
783 uint init_alloc,
784 uint alloc_increment);
785 /* init_dynamic_array() function is deprecated */
786 extern my_bool init_dynamic_array(DYNAMIC_ARRAY *array, uint element_size,
787 uint init_alloc, uint alloc_increment);
788 #define dynamic_element(array,array_index,type) \
789 ((type)((array)->buffer) +(array_index))
790
791 #ifdef __cplusplus
792 }
793 #endif
794
795 /* Some functions are still in use in C++, because HASH uses DYNAMIC_ARRAY */
796 extern my_bool insert_dynamic(DYNAMIC_ARRAY *array, const void *element);
797 extern void *alloc_dynamic(DYNAMIC_ARRAY *array);
798 extern void *pop_dynamic(DYNAMIC_ARRAY*);
799 extern void get_dynamic(DYNAMIC_ARRAY *array, void *element, uint array_index);
800 extern void claim_dynamic(DYNAMIC_ARRAY *array);
801 extern void delete_dynamic(DYNAMIC_ARRAY *array);
802 extern void freeze_size(DYNAMIC_ARRAY *array);
reset_dynamic(DYNAMIC_ARRAY * array)803 static inline void reset_dynamic(DYNAMIC_ARRAY *array)
804 {
805 array->elements= 0;
806 }
807
808 extern my_bool init_dynamic_string(DYNAMIC_STRING *str, const char *init_str,
809 size_t init_alloc,size_t alloc_increment);
810 extern my_bool dynstr_append(DYNAMIC_STRING *str, const char *append);
811 my_bool dynstr_append_mem(DYNAMIC_STRING *str, const char *append,
812 size_t length);
813 extern my_bool dynstr_append_os_quoted(DYNAMIC_STRING *str, const char *append,
814 ...);
815 extern my_bool dynstr_set(DYNAMIC_STRING *str, const char *init_str);
816 extern my_bool dynstr_realloc(DYNAMIC_STRING *str, size_t additional_size);
817 extern my_bool dynstr_trunc(DYNAMIC_STRING *str, size_t n);
818 extern void dynstr_free(DYNAMIC_STRING *str);
819 #define alloc_root_inited(A) ((A)->min_malloc != 0)
820 #define ALLOC_ROOT_MIN_BLOCK_SIZE (MALLOC_OVERHEAD + sizeof(USED_MEM) + 8)
821 #define clear_alloc_root(A) do { (A)->free= (A)->used= (A)->pre_alloc= 0; (A)->min_malloc=0;} while(0)
822 extern void init_alloc_root(PSI_memory_key key,
823 MEM_ROOT *mem_root, size_t block_size,
824 size_t pre_alloc_size);
825 extern void *alloc_root(MEM_ROOT *mem_root, size_t Size);
826 extern void *multi_alloc_root(MEM_ROOT *mem_root, ...);
827 extern void claim_root(MEM_ROOT *root);
828 extern void free_root(MEM_ROOT *root, myf MyFLAGS);
829 extern void reset_root_defaults(MEM_ROOT *mem_root, size_t block_size,
830 size_t prealloc_size);
831 extern char *strdup_root(MEM_ROOT *root,const char *str);
safe_strdup_root(MEM_ROOT * root,const char * str)832 static inline char *safe_strdup_root(MEM_ROOT *root, const char *str)
833 {
834 return str ? strdup_root(root, str) : 0;
835 }
836 extern char *strmake_root(MEM_ROOT *root,const char *str,size_t len);
837 extern void *memdup_root(MEM_ROOT *root,const void *str, size_t len);
838 extern void set_memroot_max_capacity(MEM_ROOT *mem_root, size_t size);
839 extern void set_memroot_error_reporting(MEM_ROOT *mem_root,
840 my_bool report_error);
841 extern my_bool my_compress(uchar *, size_t *, size_t *);
842 extern my_bool my_uncompress(uchar *, size_t , size_t *);
843 extern uchar *my_compress_alloc(const uchar *packet, size_t *len,
844 size_t *complen);
845 extern int packfrm(uchar *, size_t, uchar **, size_t *);
846 extern int unpackfrm(uchar **, size_t *, const uchar *);
847
848 extern ha_checksum my_checksum(ha_checksum crc, const uchar *mem,
849 size_t count);
850
851 /* Wait a given number of microseconds */
my_sleep(time_t m_seconds)852 static inline void my_sleep(time_t m_seconds)
853 {
854 #if defined(_WIN32)
855 Sleep((DWORD)m_seconds/1000+1); /* Sleep() has millisecond arg */
856 #else
857 struct timeval t;
858 t.tv_sec= m_seconds / 1000000L;
859 t.tv_usec= m_seconds % 1000000L;
860 select(0,0,0,0,&t); /* sleep */
861 #endif
862 }
863
864 extern ulong crc32(ulong crc, const uchar *buf, uint len);
865 extern uint my_set_max_open_files(uint files);
866 void my_free_open_file_info(void);
867
868 extern time_t my_time(myf flags);
869 extern ulonglong my_getsystime(void);
870 extern ulonglong my_micro_time();
871 extern my_bool my_gethwaddr(uchar *to);
872
873 #ifdef HAVE_SYS_MMAN_H
874 #include <sys/mman.h>
875
876 #ifndef MAP_NOSYNC
877 #define MAP_NOSYNC 0
878 #endif
879
880 /*
881 Not defined in FreeBSD 11.
882 Was never implemented in FreeBSD, so we just set it to 0.
883 */
884 #ifndef MAP_NORESERVE
885 #define MAP_NORESERVE 0
886 #endif
887
888 #ifdef HAVE_MMAP64
889 #define my_mmap(a,b,c,d,e,f) mmap64(a,b,c,d,e,f)
890 #else
891 #define my_mmap(a,b,c,d,e,f) mmap(a,b,c,d,e,f)
892 #endif
893 #define my_munmap(a,b) munmap((a),(b))
894
895 #else
896 /* not a complete set of mmap() flags, but only those that nesessary */
897 #define PROT_READ 1
898 #define PROT_WRITE 2
899 #define MAP_NORESERVE 0
900 #define MAP_SHARED 0x0001
901 #define MAP_PRIVATE 0x0002
902 #define MAP_NOSYNC 0x0800
903 #define MAP_FAILED ((void *)-1)
904 #define MS_SYNC 0x0000
905
906 void *my_mmap(void *, size_t, int, int, int, my_off_t);
907 int my_munmap(void *, size_t);
908 #endif
909
910 /* my_getpagesize */
my_getpagesize()911 static inline int my_getpagesize()
912 {
913 #ifndef _WIN32
914 return getpagesize();
915 #else
916 SYSTEM_INFO si;
917 GetSystemInfo(&si);
918 return (int)si.dwPageSize;
919 #endif
920 }
921
922 int my_msync(int, void *, size_t, int);
923
924 /* character sets */
925 extern void my_charset_loader_init_mysys(MY_CHARSET_LOADER *loader);
926 extern uint get_charset_number(const char *cs_name, uint cs_flags);
927 extern uint get_collation_number(const char *name);
928 extern const char *get_charset_name(uint cs_number);
929
930 extern CHARSET_INFO *get_charset(uint cs_number, myf flags);
931 extern CHARSET_INFO *get_charset_by_name(const char *cs_name, myf flags);
932 extern CHARSET_INFO *my_collation_get_by_name(MY_CHARSET_LOADER *loader,
933 const char *name, myf flags);
934 extern CHARSET_INFO *get_charset_by_csname(const char *cs_name,
935 uint cs_flags, myf my_flags);
936 extern CHARSET_INFO *my_charset_get_by_name(MY_CHARSET_LOADER *loader,
937 const char *name,
938 uint cs_flags, myf my_flags);
939 extern my_bool resolve_charset(const char *cs_name,
940 const CHARSET_INFO *default_cs,
941 const CHARSET_INFO **cs);
942 extern my_bool resolve_collation(const char *cl_name,
943 const CHARSET_INFO *default_cl,
944 const CHARSET_INFO **cl);
945 extern void free_charsets(void);
946 extern char *get_charsets_dir(char *buf);
947 extern my_bool my_charset_same(const CHARSET_INFO *cs1,
948 const CHARSET_INFO *cs2);
949 extern my_bool init_compiled_charsets(myf flags);
950 extern void add_compiled_collation(CHARSET_INFO *cs);
951 extern size_t escape_string_for_mysql(const CHARSET_INFO *charset_info,
952 char *to, size_t to_length,
953 const char *from, size_t length);
954 #ifdef _WIN32
955 /* File system character set */
956 extern CHARSET_INFO *fs_character_set(void);
957 #endif
958 extern size_t escape_quotes_for_mysql(CHARSET_INFO *charset_info,
959 char *to, size_t to_length,
960 const char *from, size_t length, char quote);
961 #ifdef _WIN32
962 extern my_bool have_tcpip; /* Is set if tcpip is used */
963
964 /* implemented in my_windac.c */
965
966 int my_security_attr_create(SECURITY_ATTRIBUTES **psa, const char **perror,
967 DWORD owner_rights, DWORD everybody_rights);
968
969 void my_security_attr_free(SECURITY_ATTRIBUTES *sa);
970
971 /* implemented in my_conio.c */
972 my_bool my_win_is_console(FILE *file);
973 char *my_win_console_readline(const CHARSET_INFO *cs, char *mbbuf, size_t mbbufsize,
974 size_t *nread);
975 void my_win_console_write(const CHARSET_INFO *cs, const char *data, size_t datalen);
976 void my_win_console_fputs(const CHARSET_INFO *cs, const char *data);
977 void my_win_console_putc(const CHARSET_INFO *cs, int c);
978 void my_win_console_vfprintf(const CHARSET_INFO *cs, const char *fmt, va_list args);
979 int my_win_translate_command_line_args(const CHARSET_INFO *cs, int *ac, char ***av);
980 #endif /* _WIN32 */
981
982 #ifdef HAVE_PSI_INTERFACE
983 extern MYSQL_PLUGIN_IMPORT struct PSI_bootstrap *PSI_hook;
984 extern void set_psi_server(PSI *psi);
985 void my_init_mysys_psi_keys(void);
986 #endif
987
988 struct st_mysql_file;
989 extern struct st_mysql_file *mysql_stdin;
990
991 C_MODE_END
992 #endif /* _my_sys_h */
993