mirror of
https://github.com/MariaDB/server.git
synced 2025-01-20 05:52:27 +01:00
716099e07c
Bug#24509 - 2048 file descriptor limit on windows needs increasing, also WL#3049 - improved Windows I/O The patch replaces the use of the POSIX I/O interfaces in mysys on Windows with the Win32 API calls (CreateFile, WriteFile, etc). The Windows HANDLE for the open file is stored in the my_file_info struct, along with a flag for append mode because the Windows API does not support opening files in append mode in all cases) The default max open files has been increased to 16384 and can be increased further by setting --max-open-files=<value> during the server start. Another major change in this patch that almost all Windows specific file IO code has been moved to a new file my_winfile.c, greatly reducing the amount of code in #ifdef blocks within mysys, thus improving readability. Minor enhancements: - my_(f)stat() is changed to use __stati64 structure with 64 file size and timestamps. It will return correct file size now (C runtime implementation used to report outdated information) - my_lock on Windows is prepared to handle additional timeout parameter - after review : changed __WIN__ to _WIN32 in the new and changed code. client/mysqlbinlog.cc: fileno -> my_fileno client/readline.cc: fileno -> my_fileno include/config-win.h: Increase OS_FILE_LIMIT for Windows. Remove O_SHARE - Windows does not support it. Its definition conflicts with O_SHORT_LIVED, that has different semantics. include/my_dir.h: Use stat64 for stat() family of functions on Windows, because of 64 bit file size. include/my_global.h: Increased default value for open file limit to 16K include/my_sys.h: - my_file_info got new structure members - file handle and open flags - 2 new Windows-only mysys functions : my_get_osfhandle and my_osmaperr, modelled after Windows C runtime functions _get_osfhandle and _dosmaperr libmysql/CMakeLists.txt: new files my_winfile.c and my_winerr.c mysql-test/suite/large_tests/r/lock_tables_big.result: test for more then 2048 open file descriptors on Windows mysql-test/suite/large_tests/t/lock_tables_big.test: test for more then 2048 open file descriptors on Windows mysys/CMakeLists.txt: new files my_winfile.c and my_winerr.c mysys/Makefile.am: new files my_winfile.c and my_winerr.c mysys/default_modify.c: fileno -> my_fileno mysys/my_chsize.c: implementation of chsize on Windows now moved to my_winfile.c mysys/my_create.c: - my_sopen->my_win_open - close open file before removing (won't generally work on Windows otherwise) mysys/my_file.c: On Windows, files returned by my_open will not start with 0, but 2048 (making it simple to detect incompatible mix of CRT and mysys io functions) mysys/my_fopen.c: fileno->my_win_fileno , fclose->my_win_fclose, fdopen->my_win_fdopen Check for legal filename is done by my_win_[f]open functions mysys/my_fstream.c: fileno->my_fileno mysys/my_lib.c: Windows stat() functions are moved to my_winfile.c mysys/my_lock.c: Move Windows code under #ifdef to a separate function win_lock(). Add a parameter for lock wait timeout mysys/my_mmap.c: _get_osfhandle->my_get_osfhandle mysys/my_open.c: my_sopen->my_win_open (simpler interface) mysys/my_pread.c: moved most windows specific code to my_win_file.c Use my_win_pread mysys/my_quick.c: Use my_win_read/my_win_write mysys/my_read.c: Moved most of windows specific code to my_win_file.c Use my_win_read() mysys/my_seek.c: On Windows, use my_win_lseek() in my_seek()/my_tell() Removed dead code (synchronization of lseeks) Improved DBUG tracing (file position is ulonglong, not ulong) mysys/my_static.c: Removed array initialization. my_file_info_default is global variable thus it is initialized with all zeros anyway mysys/my_sync.c: _commit->my_win_fsync mysys/my_winerr.c: New file my_winerr.c Exports my_osmaperr modelled after undocumented C runtime function _dosmaperr(). The problem with _dosmaperr() used previously is that 1) it is nowhere documented and thus code relying on it is not guaranteed to work in subsequent releases on the C runtime 2) it is present only in static C runtime (mysqld does not link if compiled with /MD) mysys/my_winfile.c: New file my_winfile.c Implements ANSI/Posix file IO routines, when possible using native Windows IO, without C runtime (C runtime dropped because of the 2048 file descriptor limit). mysys/my_write.c: write->my_win_write mysys/mysys_priv.h: Declaration of Windows Posix functions (private to mysys, shall not be visible outside) storage/innobase/handler/ha_innodb.cc: mysys native Windows IO : correct innodb tmp file handling mysql_tmpfile does not return valid CRT file descriptor, thus it is not possible to dup() it. Instead, the native file handle has to be duplicated and then converted to CRT descriptor. storage/myisam/mi_locking.c: _commit->my_sync
237 lines
6.6 KiB
C++
237 lines
6.6 KiB
C++
/* Copyright (C) 2000 MySQL AB
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; version 2 of the License.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program; if not, write to the Free Software
|
|
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
|
|
|
|
/* readline for batch mode */
|
|
|
|
#include <my_global.h>
|
|
#include <my_sys.h>
|
|
#include <m_string.h>
|
|
#include "my_readline.h"
|
|
|
|
static bool init_line_buffer(LINE_BUFFER *buffer,File file,ulong size,
|
|
ulong max_size);
|
|
static bool init_line_buffer_from_string(LINE_BUFFER *buffer,char * str);
|
|
static size_t fill_buffer(LINE_BUFFER *buffer);
|
|
static char *intern_read_line(LINE_BUFFER *buffer, ulong *out_length, bool *truncated);
|
|
|
|
|
|
LINE_BUFFER *batch_readline_init(ulong max_size,FILE *file)
|
|
{
|
|
LINE_BUFFER *line_buff;
|
|
if (!(line_buff=(LINE_BUFFER*)
|
|
my_malloc(sizeof(*line_buff),MYF(MY_WME | MY_ZEROFILL))))
|
|
return 0;
|
|
if (init_line_buffer(line_buff,my_fileno(file),IO_SIZE,max_size))
|
|
{
|
|
my_free(line_buff,MYF(0));
|
|
return 0;
|
|
}
|
|
return line_buff;
|
|
}
|
|
|
|
|
|
char *batch_readline(LINE_BUFFER *line_buff, bool *truncated)
|
|
{
|
|
char *pos;
|
|
ulong out_length;
|
|
DBUG_ASSERT(truncated != NULL);
|
|
|
|
if (!(pos=intern_read_line(line_buff,&out_length, truncated)))
|
|
return 0;
|
|
if (out_length && pos[out_length-1] == '\n')
|
|
if (--out_length && pos[out_length-1] == '\r') /* Remove '\n' */
|
|
out_length--; /* Remove '\r' */
|
|
line_buff->read_length=out_length;
|
|
pos[out_length]=0;
|
|
return pos;
|
|
}
|
|
|
|
|
|
void batch_readline_end(LINE_BUFFER *line_buff)
|
|
{
|
|
if (line_buff)
|
|
{
|
|
my_free(line_buff->buffer,MYF(MY_ALLOW_ZERO_PTR));
|
|
my_free(line_buff,MYF(0));
|
|
}
|
|
}
|
|
|
|
|
|
LINE_BUFFER *batch_readline_command(LINE_BUFFER *line_buff, char * str)
|
|
{
|
|
if (!line_buff)
|
|
if (!(line_buff=(LINE_BUFFER*)
|
|
my_malloc(sizeof(*line_buff),MYF(MY_WME | MY_ZEROFILL))))
|
|
return 0;
|
|
if (init_line_buffer_from_string(line_buff,str))
|
|
{
|
|
my_free(line_buff,MYF(0));
|
|
return 0;
|
|
}
|
|
return line_buff;
|
|
}
|
|
|
|
|
|
/*****************************************************************************
|
|
Functions to handle buffered readings of lines from a stream
|
|
******************************************************************************/
|
|
|
|
static bool
|
|
init_line_buffer(LINE_BUFFER *buffer,File file,ulong size,ulong max_buffer)
|
|
{
|
|
buffer->file=file;
|
|
buffer->bufread=size;
|
|
buffer->max_size=max_buffer;
|
|
if (!(buffer->buffer = (char*) my_malloc(buffer->bufread+1,
|
|
MYF(MY_WME | MY_FAE))))
|
|
return 1;
|
|
buffer->end_of_line=buffer->end=buffer->buffer;
|
|
buffer->buffer[0]=0; /* For easy start test */
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
init_line_buffer_from_string can be called on the same buffer
|
|
several times. the resulting buffer will contain a
|
|
concatenation of all strings separated by spaces
|
|
*/
|
|
static bool init_line_buffer_from_string(LINE_BUFFER *buffer,char * str)
|
|
{
|
|
uint old_length=(uint)(buffer->end - buffer->buffer);
|
|
uint length= (uint) strlen(str);
|
|
if (!(buffer->buffer= buffer->start_of_line= buffer->end_of_line=
|
|
(char*) my_realloc((uchar*) buffer->buffer, old_length+length+2,
|
|
MYF(MY_FAE|MY_ALLOW_ZERO_PTR))))
|
|
return 1;
|
|
buffer->end= buffer->buffer + old_length;
|
|
if (old_length)
|
|
buffer->end[-1]=' ';
|
|
memcpy(buffer->end, str, length);
|
|
buffer->end[length]= '\n';
|
|
buffer->end[length+1]= 0;
|
|
buffer->end+= length+1;
|
|
buffer->eof=1;
|
|
buffer->max_size=1;
|
|
return 0;
|
|
}
|
|
|
|
|
|
/*
|
|
Fill the buffer retaining the last n bytes at the beginning of the
|
|
newly filled buffer (for backward context). Returns the number of new
|
|
bytes read from disk.
|
|
*/
|
|
|
|
static size_t fill_buffer(LINE_BUFFER *buffer)
|
|
{
|
|
size_t read_count;
|
|
uint bufbytes= (uint) (buffer->end - buffer->start_of_line);
|
|
|
|
if (buffer->eof)
|
|
return 0; /* Everything read */
|
|
|
|
/* See if we need to grow the buffer. */
|
|
|
|
for (;;)
|
|
{
|
|
uint start_offset=(uint) (buffer->start_of_line - buffer->buffer);
|
|
read_count=(buffer->bufread - bufbytes)/IO_SIZE;
|
|
if ((read_count*=IO_SIZE))
|
|
break;
|
|
if (buffer->bufread * 2 > buffer->max_size)
|
|
{
|
|
/*
|
|
So we must grow the buffer but we cannot due to the max_size limit.
|
|
Return 0 w/o setting buffer->eof to signal this condition.
|
|
*/
|
|
return 0;
|
|
}
|
|
buffer->bufread *= 2;
|
|
if (!(buffer->buffer = (char*) my_realloc(buffer->buffer,
|
|
buffer->bufread+1,
|
|
MYF(MY_WME | MY_FAE))))
|
|
return (uint) -1;
|
|
buffer->start_of_line=buffer->buffer+start_offset;
|
|
buffer->end=buffer->buffer+bufbytes;
|
|
}
|
|
|
|
/* Shift stuff down. */
|
|
if (buffer->start_of_line != buffer->buffer)
|
|
{
|
|
bmove(buffer->buffer,buffer->start_of_line,(uint) bufbytes);
|
|
buffer->end=buffer->buffer+bufbytes;
|
|
}
|
|
|
|
/* Read in new stuff. */
|
|
if ((read_count= my_read(buffer->file, (uchar*) buffer->end, read_count,
|
|
MYF(MY_WME))) == MY_FILE_ERROR)
|
|
return (size_t) -1;
|
|
|
|
DBUG_PRINT("fill_buff", ("Got %lu bytes", (ulong) read_count));
|
|
|
|
if (!read_count)
|
|
{
|
|
buffer->eof = 1;
|
|
/* Kludge to pretend every nonempty file ends with a newline. */
|
|
if (bufbytes && buffer->end[-1] != '\n')
|
|
{
|
|
read_count = 1;
|
|
*buffer->end = '\n';
|
|
}
|
|
}
|
|
buffer->end_of_line=(buffer->start_of_line=buffer->buffer)+bufbytes;
|
|
buffer->end+=read_count;
|
|
*buffer->end=0; /* Sentinel */
|
|
return read_count;
|
|
}
|
|
|
|
|
|
|
|
char *intern_read_line(LINE_BUFFER *buffer, ulong *out_length, bool *truncated)
|
|
{
|
|
char *pos;
|
|
size_t length;
|
|
DBUG_ENTER("intern_read_line");
|
|
|
|
buffer->start_of_line=buffer->end_of_line;
|
|
for (;;)
|
|
{
|
|
pos=buffer->end_of_line;
|
|
while (*pos != '\n' && *pos)
|
|
pos++;
|
|
if (pos == buffer->end)
|
|
{
|
|
/*
|
|
fill_buffer() can return 0 either on EOF in which case we abort
|
|
or when the internal buffer has hit the size limit. In the latter case
|
|
return what we have read so far and signal string truncation.
|
|
*/
|
|
if (!(length=fill_buffer(buffer)) || length == (uint) -1)
|
|
{
|
|
if (buffer->eof)
|
|
DBUG_RETURN(0);
|
|
}
|
|
else
|
|
continue;
|
|
pos--; /* break line here */
|
|
*truncated= 1;
|
|
}
|
|
else
|
|
*truncated= 0;
|
|
buffer->end_of_line=pos+1;
|
|
*out_length=(ulong) (pos + 1 - buffer->eof - buffer->start_of_line);
|
|
DBUG_RETURN(buffer->start_of_line);
|
|
}
|
|
}
|