1berry/MariaDB-server
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

mysys: remove dead ME_xxx flags

Browse Source
This commit is contained in:
Sergei Golubchik 2018-05-29 23:00:51 +02:00
parent 9988a423d2
commit 37659ef43b
30 changed files with 52 additions and 61 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
extra/mariabackup/ds_local.cc
View File

@ -65,7 +65,7 @@ local_init(const char *root)
{ {
char errbuf[MYSYS_STRERROR_SIZE]; char errbuf[MYSYS_STRERROR_SIZE];
my_strerror(errbuf, sizeof(errbuf),my_errno); my_strerror(errbuf, sizeof(errbuf),my_errno);
my_error(EE_CANT_MKDIR, MYF(ME_BELL | ME_WAITTANG), my_error(EE_CANT_MKDIR, MYF(ME_BELL),
root, my_errno,errbuf, my_errno); root, my_errno,errbuf, my_errno);
return NULL; return NULL;
} }
@ -97,7 +97,7 @@ local_open(ds_ctxt_t *ctxt, const char *path,
if (my_mkdir(dirpath, 0777, MYF(0)) < 0 && my_errno != EEXIST) { if (my_mkdir(dirpath, 0777, MYF(0)) < 0 && my_errno != EEXIST) {
char errbuf[MYSYS_STRERROR_SIZE]; char errbuf[MYSYS_STRERROR_SIZE];
my_strerror(errbuf, sizeof(errbuf), my_errno); my_strerror(errbuf, sizeof(errbuf), my_errno);
my_error(EE_CANT_MKDIR, MYF(ME_BELL | ME_WAITTANG), my_error(EE_CANT_MKDIR, MYF(ME_BELL),
dirpath, my_errno, errbuf); dirpath, my_errno, errbuf);
return NULL; return NULL;
} }

2
include/my_sys.h
View File

@ -105,9 +105,7 @@ typedef struct my_aio_result {
#define MY_DONT_FREE_DBUG 4U /* Do not call DBUG_END() in my_end() */ #define MY_DONT_FREE_DBUG 4U /* Do not call DBUG_END() in my_end() */
#define ME_BELL 4U /* Ring bell then printing message */ #define ME_BELL 4U /* Ring bell then printing message */
#define ME_WAITTANG 0 /* Wait for a user action */
#define ME_NOREFRESH 64U /* Write the error message to error log */ #define ME_NOREFRESH 64U /* Write the error message to error log */
#define ME_NOINPUT 0 /* Don't use the input library */
#define ME_JUST_INFO 1024U /**< not error but just info */ #define ME_JUST_INFO 1024U /**< not error but just info */
#define ME_JUST_WARNING 2048U /**< not error but just warning */ #define ME_JUST_WARNING 2048U /**< not error but just warning */
#define ME_FATALERROR 4096U /* Fatal statement error */ #define ME_FATALERROR 4096U /* Fatal statement error */

2
mysys/mf_cache.c
View File

@ -82,7 +82,7 @@ void close_cached_file(IO_CACHE *cache)
#ifdef CANT_DELETE_OPEN_FILES #ifdef CANT_DELETE_OPEN_FILES
if (cache->file_name) if (cache->file_name)
{ {
(void) my_delete(cache->file_name,MYF(MY_WME | ME_NOINPUT)); (void) my_delete(cache->file_name, MYF(MY_WME));
my_free(cache->file_name); my_free(cache->file_name);
} }
#endif #endif

6
mysys/mf_iocache.c
View File

@ -1534,8 +1534,7 @@ int _my_b_async_read(IO_CACHE *info, uchar *Buffer, size_t Count)
if (info->aio_result.result.aio_errno) if (info->aio_result.result.aio_errno)
{ {
if (info->myflags & MY_WME) if (info->myflags & MY_WME)
my_error(EE_READ, MYF(ME_BELL+ME_WAITTANG), my_error(EE_READ, MYF(ME_BELL), my_filename(info->file),
my_filename(info->file),
info->aio_result.result.aio_errno); info->aio_result.result.aio_errno);
my_errno=info->aio_result.result.aio_errno; my_errno=info->aio_result.result.aio_errno;
info->error= -1; info->error= -1;
@ -1628,8 +1627,7 @@ int _my_b_async_read(IO_CACHE *info, uchar *Buffer, size_t Count)
if (Count != use_length) if (Count != use_length)
{ /* Didn't find hole block */ { /* Didn't find hole block */
if (info->myflags & (MY_WME | MY_FAE | MY_FNABP) && Count != org_Count) if (info->myflags & (MY_WME | MY_FAE | MY_FNABP) && Count != org_Count)
my_error(EE_EOFERR, MYF(ME_BELL+ME_WAITTANG), my_error(EE_EOFERR, MYF(ME_BELL), my_filename(info->file), my_errno);
my_filename(info->file),my_errno);
info->error=(int) (read_length+left_length); info->error=(int) (read_length+left_length);
return 1; return 1;
} }

2
mysys/mf_tempfile.c
View File

@ -137,7 +137,7 @@ File create_temp_file(char *to, const char *dir, const char *prefix,
{ {
int tmp=my_errno; int tmp=my_errno;
close(org_file); close(org_file);
(void) my_delete(to, MYF(MY_WME | ME_NOINPUT)); (void) my_delete(to, MYF(MY_WME));
my_errno=tmp; my_errno=tmp;
} }
} }

2
mysys/my_chsize.c
View File

@ -96,6 +96,6 @@ int my_chsize(File fd, my_off_t newlength, int filler, myf MyFlags)
err: err:
DBUG_PRINT("error", ("errno: %d", errno)); DBUG_PRINT("error", ("errno: %d", errno));
if (MyFlags & MY_WME) if (MyFlags & MY_WME)
my_error(EE_CANT_CHSIZE, MYF(ME_BELL+ME_WAITTANG), my_errno); my_error(EE_CANT_CHSIZE, MYF(ME_BELL), my_errno);
DBUG_RETURN(1); DBUG_RETURN(1);
} /* my_chsize */ } /* my_chsize */

4
mysys/my_copy.c
View File

@ -112,7 +112,7 @@ int my_copy(const char *from, const char *to, myf MyFlags)
{ {
my_errno= errno; my_errno= errno;
if (MyFlags & MY_WME) if (MyFlags & MY_WME)
my_error(EE_CHANGE_PERMISSIONS, MYF(ME_BELL+ME_WAITTANG), to, errno); my_error(EE_CHANGE_PERMISSIONS, MYF(ME_BELL), to, errno);
if (MyFlags & MY_FAE) if (MyFlags & MY_FAE)
goto err; goto err;
} }
@ -122,7 +122,7 @@ int my_copy(const char *from, const char *to, myf MyFlags)
{ {
my_errno= errno; my_errno= errno;
if (MyFlags & MY_WME) if (MyFlags & MY_WME)
my_error(EE_CANT_COPY_OWNERSHIP, MYF(ME_BELL+ME_WAITTANG), to, errno); my_error(EE_CANT_COPY_OWNERSHIP, MYF(ME_BELL), to, errno);
if (MyFlags & MY_FAE) if (MyFlags & MY_FAE)
goto err; goto err;
} }

6
mysys/my_delete.c
View File

@ -46,11 +46,9 @@ int my_delete(const char *name, myf MyFlags)
{ {
my_errno=errno; my_errno=errno;
if (MyFlags & (MY_FAE+MY_WME)) if (MyFlags & (MY_FAE+MY_WME))
my_error(EE_DELETE,MYF(ME_BELL+ME_WAITTANG+(MyFlags & ME_NOINPUT)), my_error(EE_DELETE, MYF(ME_BELL), name, errno);
name,errno);
} }
else if ((MyFlags & MY_SYNC_DIR) && else if ((MyFlags & MY_SYNC_DIR) && my_sync_dir_by_file(name, MyFlags))
my_sync_dir_by_file(name, MyFlags))
err= -1; err= -1;
DBUG_RETURN(err); DBUG_RETURN(err);
} /* my_delete */ } /* my_delete */

7
mysys/my_fopen.c
View File

@ -76,7 +76,7 @@ FILE *my_fopen(const char *filename, int flags, myf MyFlags)
DBUG_PRINT("error",("Got error %d on open",my_errno)); DBUG_PRINT("error",("Got error %d on open",my_errno));
if (MyFlags & (MY_FFNF | MY_FAE | MY_WME)) if (MyFlags & (MY_FFNF | MY_FAE | MY_WME))
my_error((flags & O_RDONLY) ? EE_FILENOTFOUND : EE_CANTCREATEFILE, my_error((flags & O_RDONLY) ? EE_FILENOTFOUND : EE_CANTCREATEFILE,
MYF(ME_BELL+ME_WAITTANG), filename, my_errno); MYF(ME_BELL), filename, my_errno);
DBUG_RETURN((FILE*) 0); DBUG_RETURN((FILE*) 0);
} /* my_fopen */ } /* my_fopen */
@ -182,8 +182,7 @@ int my_fclose(FILE *fd, myf MyFlags)
{ {
my_errno=errno; my_errno=errno;
if (MyFlags & (MY_FAE | MY_WME)) if (MyFlags & (MY_FAE | MY_WME))
my_error(EE_BADCLOSE, MYF(ME_BELL+ME_WAITTANG), my_error(EE_BADCLOSE, MYF(ME_BELL), name, errno);
name,errno);
} }
else else
statistic_decrement(my_stream_opened, &THR_LOCK_open); statistic_decrement(my_stream_opened, &THR_LOCK_open);
@ -217,7 +216,7 @@ FILE *my_fdopen(File Filedes, const char *name, int Flags, myf MyFlags)
{ {
my_errno=errno; my_errno=errno;
if (MyFlags & (MY_FAE | MY_WME)) if (MyFlags & (MY_FAE | MY_WME))
my_error(EE_CANT_OPEN_STREAM, MYF(ME_BELL+ME_WAITTANG),errno); my_error(EE_CANT_OPEN_STREAM, MYF(ME_BELL), errno);
} }
else else
{ {

8
mysys/my_fstream.c
View File

@ -55,11 +55,11 @@ size_t my_fread(FILE *stream, uchar *Buffer, size_t Count, myf MyFlags)
if (MyFlags & (MY_WME | MY_FAE | MY_FNABP)) if (MyFlags & (MY_WME | MY_FAE | MY_FNABP))
{ {
if (ferror(stream)) if (ferror(stream))
my_error(EE_READ, MYF(ME_BELL+ME_WAITTANG), my_error(EE_READ, MYF(ME_BELL),
my_filename(my_fileno(stream)),errno); my_filename(my_fileno(stream)),errno);
else else
if (MyFlags & (MY_NABP | MY_FNABP)) if (MyFlags & (MY_NABP | MY_FNABP))
my_error(EE_EOFERR, MYF(ME_BELL+ME_WAITTANG), my_error(EE_EOFERR, MYF(ME_BELL),
my_filename(my_fileno(stream)),errno); my_filename(my_fileno(stream)),errno);
} }
my_errno=errno ? errno : -1; my_errno=errno ? errno : -1;
@ -140,8 +140,8 @@ size_t my_fwrite(FILE *stream, const uchar *Buffer, size_t Count, myf MyFlags)
{ {
if (MyFlags & (MY_WME | MY_FAE | MY_FNABP)) if (MyFlags & (MY_WME | MY_FAE | MY_FNABP))
{ {
my_error(EE_WRITE, MYF(ME_BELL+ME_WAITTANG), my_error(EE_WRITE, MYF(ME_BELL),
my_filename(my_fileno(stream)),errno); my_filename(my_fileno(stream)), errno);
} }
writtenbytes= (size_t) -1; /* Return that we got error */ writtenbytes= (size_t) -1; /* Return that we got error */
break; break;

4
mysys/my_getwd.c
View File

@ -64,7 +64,7 @@ int my_getwd(char * buf, size_t size, myf MyFlags)
if (!getcwd(buf,(uint) (size-2)) && MyFlags & MY_WME) if (!getcwd(buf,(uint) (size-2)) && MyFlags & MY_WME)
{ {
my_errno=errno; my_errno=errno;
my_error(EE_GETWD,MYF(ME_BELL+ME_WAITTANG),errno); my_error(EE_GETWD,MYF(ME_BELL),errno);
DBUG_RETURN(-1); DBUG_RETURN(-1);
} }
#elif defined(HAVE_GETWD) #elif defined(HAVE_GETWD)
@ -104,7 +104,7 @@ int my_setwd(const char *dir, myf MyFlags)
{ {
my_errno=errno; my_errno=errno;
if (MyFlags & MY_WME) if (MyFlags & MY_WME)
my_error(EE_SETWD,MYF(ME_BELL+ME_WAITTANG),start,errno); my_error(EE_SETWD,MYF(ME_BELL),start,errno);
} }
else else
{ {

6
mysys/my_lib.c
View File

@ -185,7 +185,7 @@ MY_DIR *my_dir(const char *path, myf MyFlags)
(void) closedir(dirp); (void) closedir(dirp);
my_dirend(&dirh->dir); my_dirend(&dirh->dir);
if (MyFlags & (MY_FAE | MY_WME)) if (MyFlags & (MY_FAE | MY_WME))
my_error(EE_DIR, MYF(ME_BELL | ME_WAITTANG), path, my_errno); my_error(EE_DIR, MYF(ME_BELL), path, my_errno);
DBUG_RETURN(NULL); DBUG_RETURN(NULL);
} /* my_dir */ } /* my_dir */
@ -308,7 +308,7 @@ error:
_findclose(handle); _findclose(handle);
my_dirend(&dirh->dir); my_dirend(&dirh->dir);
if (MyFlags & (MY_FAE | MY_WME)) if (MyFlags & (MY_FAE | MY_WME))
my_error(EE_DIR,MYF(ME_BELL | ME_WAITTANG), path, errno); my_error(EE_DIR,MYF(ME_BELL), path, errno);
DBUG_RETURN(NULL); DBUG_RETURN(NULL);
} /* my_dir */ } /* my_dir */
@ -358,7 +358,7 @@ MY_STAT *my_stat(const char *path, MY_STAT *stat_area, myf my_flags)
error: error:
if (my_flags & (MY_FAE+MY_WME)) if (my_flags & (MY_FAE+MY_WME))
{ {
my_error(EE_STAT, MYF(ME_BELL+ME_WAITTANG),path,my_errno); my_error(EE_STAT, MYF(ME_BELL), path, my_errno);
DBUG_RETURN((MY_STAT *) NULL); DBUG_RETURN((MY_STAT *) NULL);
} }
DBUG_RETURN((MY_STAT *) NULL); DBUG_RETURN((MY_STAT *) NULL);

4
mysys/my_lock.c
View File

@ -219,9 +219,9 @@ int my_lock(File fd, int locktype, my_off_t start, my_off_t length,
if (MyFlags & MY_WME) if (MyFlags & MY_WME)
{ {
if (locktype == F_UNLCK) if (locktype == F_UNLCK)
my_error(EE_CANTUNLOCK,MYF(ME_BELL+ME_WAITTANG),my_errno); my_error(EE_CANTUNLOCK,MYF(ME_BELL),my_errno);
else else
my_error(EE_CANTLOCK,MYF(ME_BELL+ME_WAITTANG),my_errno); my_error(EE_CANTLOCK,MYF(ME_BELL),my_errno);
} }
DBUG_PRINT("error",("my_errno: %d (%d)",my_errno,errno)); DBUG_PRINT("error",("my_errno: %d (%d)",my_errno,errno));
DBUG_RETURN(-1); DBUG_RETURN(-1);

2
mysys/my_lockmem.c
View File

@ -43,7 +43,7 @@ uchar *my_malloc_lock(uint size,myf MyFlags)
if (!(ptr=memalign(pagesize,size))) if (!(ptr=memalign(pagesize,size)))
{ {
if (MyFlags & (MY_FAE+MY_WME)) if (MyFlags & (MY_FAE+MY_WME))
my_error(EE_OUTOFMEMORY, MYF(ME_BELL+ME_WAITTANG+ME_FATALERROR), size); my_error(EE_OUTOFMEMORY, MYF(ME_BELL+ME_FATALERROR), size);
DBUG_RETURN(0); DBUG_RETURN(0);
} }
success = mlock((uchar*) ptr,size); success = mlock((uchar*) ptr,size);

5
mysys/my_malloc.c
View File

@ -106,8 +106,7 @@ void *my_malloc(size_t size, myf my_flags)
if (my_flags & MY_FAE) if (my_flags & MY_FAE)
error_handler_hook=fatal_error_handler_hook; error_handler_hook=fatal_error_handler_hook;
if (my_flags & (MY_FAE+MY_WME)) if (my_flags & (MY_FAE+MY_WME))
my_error(EE_OUTOFMEMORY, MYF(ME_BELL + ME_WAITTANG + my_error(EE_OUTOFMEMORY, MYF(ME_BELL+ME_NOREFRESH+ME_FATALERROR),size);
ME_NOREFRESH + ME_FATALERROR),size);
if (my_flags & MY_FAE) if (my_flags & MY_FAE)
abort(); abort();
} }
@ -175,7 +174,7 @@ void *my_realloc(void *oldpoint, size_t size, myf my_flags)
DBUG_RETURN(oldpoint); DBUG_RETURN(oldpoint);
my_errno=errno; my_errno=errno;
if (my_flags & (MY_FAE+MY_WME)) if (my_flags & (MY_FAE+MY_WME))
my_error(EE_OUTOFMEMORY, MYF(ME_BELL + ME_WAITTANG + ME_FATALERROR), size); my_error(EE_OUTOFMEMORY, MYF(ME_BELL + ME_FATALERROR), size);
} }
else else
{ {

2
mysys/my_mkdir.c
View File

@ -36,7 +36,7 @@ int my_mkdir(const char *dir, int Flags, myf MyFlags)
my_errno=errno; my_errno=errno;
DBUG_PRINT("error",("error %d when creating direcory %s",my_errno,dir)); DBUG_PRINT("error",("error %d when creating direcory %s",my_errno,dir));
if (MyFlags & (MY_FFNF | MY_FAE | MY_WME)) if (MyFlags & (MY_FFNF | MY_FAE | MY_WME))
my_error(EE_CANT_MKDIR, MYF(ME_BELL+ME_WAITTANG), dir, my_errno); my_error(EE_CANT_MKDIR, MYF(ME_BELL), dir, my_errno);
DBUG_RETURN(-1); DBUG_RETURN(-1);
} }
DBUG_RETURN(0); DBUG_RETURN(0);

2
mysys/my_once.c
View File

@ -59,7 +59,7 @@ void* my_once_alloc(size_t Size, myf MyFlags)
{ {
my_errno=errno; my_errno=errno;
if (MyFlags & (MY_FAE+MY_WME)) if (MyFlags & (MY_FAE+MY_WME))
my_error(EE_OUTOFMEMORY, MYF(ME_BELL+ME_WAITTANG+ME_FATALERROR), get_size); my_error(EE_OUTOFMEMORY, MYF(ME_BELL+ME_FATALERROR), get_size);
return((uchar*) 0); return((uchar*) 0);
} }
DBUG_PRINT("test",("my_once_malloc %lu byte malloced", (ulong) get_size)); DBUG_PRINT("test",("my_once_malloc %lu byte malloced", (ulong) get_size));

4
mysys/my_open.c
View File

@ -101,7 +101,7 @@ int my_close(File fd, myf MyFlags)
DBUG_PRINT("error",("Got error %d on close",err)); DBUG_PRINT("error",("Got error %d on close",err));
my_errno=errno; my_errno=errno;
if (MyFlags & (MY_FAE | MY_WME)) if (MyFlags & (MY_FAE | MY_WME))
my_error(EE_BADCLOSE, MYF(ME_BELL | ME_WAITTANG | (MyFlags & (ME_JUST_INFO | ME_NOREFRESH))), my_error(EE_BADCLOSE, MYF(ME_BELL | (MyFlags & (ME_JUST_INFO | ME_NOREFRESH))),
name,errno); name,errno);
} }
if (name) if (name)
@ -156,7 +156,7 @@ File my_register_filename(File fd, const char *FileName, enum file_type
if (my_errno == EMFILE) if (my_errno == EMFILE)
error_message_number= EE_OUT_OF_FILERESOURCES; error_message_number= EE_OUT_OF_FILERESOURCES;
my_error(error_message_number, my_error(error_message_number,
MYF(ME_BELL | ME_WAITTANG | (MyFlags & (ME_JUST_INFO | ME_NOREFRESH))), MYF(ME_BELL | (MyFlags & (ME_JUST_INFO | ME_NOREFRESH))),
FileName, my_errno); FileName, my_errno);
} }
DBUG_RETURN(-1); DBUG_RETURN(-1);

6
mysys/my_pread.c
View File

@ -86,11 +86,11 @@ size_t my_pread(File Filedes, uchar *Buffer, size_t Count, my_off_t offset,
{ {
if (readbytes == (size_t) -1) if (readbytes == (size_t) -1)
my_error(EE_READ, my_error(EE_READ,
MYF(ME_BELL | ME_WAITTANG | (MyFlags & (ME_JUST_INFO | ME_NOREFRESH))), MYF(ME_BELL | (MyFlags & (ME_JUST_INFO | ME_NOREFRESH))),
my_filename(Filedes),my_errno); my_filename(Filedes),my_errno);
else if (MyFlags & (MY_NABP | MY_FNABP)) else if (MyFlags & (MY_NABP | MY_FNABP))
my_error(EE_EOFERR, my_error(EE_EOFERR,
MYF(ME_BELL | ME_WAITTANG | (MyFlags & (ME_JUST_INFO | ME_NOREFRESH))), MYF(ME_BELL | (MyFlags & (ME_JUST_INFO | ME_NOREFRESH))),
my_filename(Filedes),my_errno); my_filename(Filedes),my_errno);
} }
if (readbytes == (size_t) -1 || (MyFlags & (MY_FNABP | MY_NABP))) if (readbytes == (size_t) -1 || (MyFlags & (MY_FNABP | MY_NABP)))
@ -173,7 +173,7 @@ size_t my_pwrite(int Filedes, const uchar *Buffer, size_t Count,
if (MyFlags & (MY_NABP | MY_FNABP)) if (MyFlags & (MY_NABP | MY_FNABP))
{ {
if (MyFlags & (MY_WME | MY_FAE | MY_FNABP)) if (MyFlags & (MY_WME | MY_FAE | MY_FNABP))
my_error(EE_WRITE, MYF(ME_BELL | ME_WAITTANG | (MyFlags & (ME_JUST_INFO | ME_NOREFRESH))), my_error(EE_WRITE, MYF(ME_BELL | (MyFlags & (ME_JUST_INFO | ME_NOREFRESH))),
my_filename(Filedes),my_errno); my_filename(Filedes),my_errno);
DBUG_RETURN(MY_FILE_ERROR); /* Error on write */ DBUG_RETURN(MY_FILE_ERROR); /* Error on write */
} }

4
mysys/my_read.c
View File

@ -90,11 +90,11 @@ size_t my_read(File Filedes, uchar *Buffer, size_t Count, myf MyFlags)
{ {
if (readbytes == (size_t) -1) if (readbytes == (size_t) -1)
my_error(EE_READ, my_error(EE_READ,
MYF(ME_BELL | ME_WAITTANG | (MyFlags & (ME_JUST_INFO | ME_NOREFRESH))), MYF(ME_BELL | (MyFlags & (ME_JUST_INFO | ME_NOREFRESH))),
my_filename(Filedes), got_errno); my_filename(Filedes), got_errno);
else if (MyFlags & (MY_NABP | MY_FNABP)) else if (MyFlags & (MY_NABP | MY_FNABP))
my_error(EE_EOFERR, my_error(EE_EOFERR,
MYF(ME_BELL | ME_WAITTANG | (MyFlags & (ME_JUST_INFO | ME_NOREFRESH))), MYF(ME_BELL | (MyFlags & (ME_JUST_INFO | ME_NOREFRESH))),
my_filename(Filedes), got_errno); my_filename(Filedes), got_errno);
} }
if (readbytes == (size_t) -1 || if (readbytes == (size_t) -1 ||

6
mysys/my_redel.c
View File

@ -102,7 +102,7 @@ int my_copystat(const char *from, const char *to, int MyFlags)
{ {
my_errno= errno; my_errno= errno;
if (MyFlags & (MY_FAE+MY_WME)) if (MyFlags & (MY_FAE+MY_WME))
my_error(EE_CHANGE_PERMISSIONS, MYF(ME_BELL+ME_WAITTANG), from, errno); my_error(EE_CHANGE_PERMISSIONS, MYF(ME_BELL), from, errno);
return -1; return -1;
} }
@ -110,14 +110,14 @@ int my_copystat(const char *from, const char *to, int MyFlags)
if (statbuf.st_nlink > 1 && MyFlags & MY_LINK_WARNING) if (statbuf.st_nlink > 1 && MyFlags & MY_LINK_WARNING)
{ {
if (MyFlags & MY_LINK_WARNING) if (MyFlags & MY_LINK_WARNING)
my_error(EE_LINK_WARNING,MYF(ME_BELL+ME_WAITTANG),from,statbuf.st_nlink); my_error(EE_LINK_WARNING,MYF(ME_BELL),from,statbuf.st_nlink);
} }
/* Copy ownership */ /* Copy ownership */
if (chown(to, statbuf.st_uid, statbuf.st_gid)) if (chown(to, statbuf.st_uid, statbuf.st_gid))
{ {
my_errno= errno; my_errno= errno;
if (MyFlags & MY_WME) if (MyFlags & MY_WME)
my_error(EE_CHANGE_OWNERSHIP, MYF(ME_BELL+ME_WAITTANG), from, errno); my_error(EE_CHANGE_OWNERSHIP, MYF(ME_BELL), from, errno);
if (MyFlags & MY_FAE) if (MyFlags & MY_FAE)
return -1; return -1;
} }

2
mysys/my_rename.c
View File

@ -42,7 +42,7 @@ int my_rename(const char *from, const char *to, myf MyFlags)
my_errno=errno; my_errno=errno;
error = -1; error = -1;
if (MyFlags & (MY_FAE+MY_WME)) if (MyFlags & (MY_FAE+MY_WME))
my_error(EE_LINK, MYF(ME_BELL+ME_WAITTANG),from,to,my_errno); my_error(EE_LINK, MYF(ME_BELL),from,to,my_errno);
} }
else if (MyFlags & MY_SYNC_DIR) else if (MyFlags & MY_SYNC_DIR)
{ {

2
mysys/my_sync.c
View File

@ -122,7 +122,7 @@ int my_sync(File fd, myf my_flags)
res= 0; res= 0;
} }
else if (my_flags & MY_WME) else if (my_flags & MY_WME)
my_error(EE_SYNC, MYF(ME_BELL+ME_WAITTANG), my_filename(fd), my_errno); my_error(EE_SYNC, MYF(ME_BELL), my_filename(fd), my_errno);
} }
else else
{ {

2
mysys/my_write.c
View File

@ -107,7 +107,7 @@ size_t my_write(File Filedes, const uchar *Buffer, size_t Count, myf MyFlags)
{ {
if (MyFlags & (MY_WME | MY_FAE | MY_FNABP)) if (MyFlags & (MY_WME | MY_FAE | MY_FNABP))
{ {
my_error(EE_WRITE, MYF(ME_BELL | ME_WAITTANG | (MyFlags & (ME_JUST_INFO | ME_NOREFRESH))), my_error(EE_WRITE, MYF(ME_BELL | (MyFlags & (ME_JUST_INFO | ME_NOREFRESH))),
my_filename(Filedes),my_errno); my_filename(Filedes),my_errno);
} }
DBUG_RETURN(MY_FILE_ERROR); /* Error on read */ DBUG_RETURN(MY_FILE_ERROR); /* Error on read */

4
sql/filesort.cc
View File

@ -872,8 +872,8 @@ static ha_rows find_all_keys(THD *thd, Sort_param *param, SQL_SELECT *select,
DBUG_PRINT("test",("error: %d indexpos: %d",error,indexpos)); DBUG_PRINT("test",("error: %d indexpos: %d",error,indexpos));
if (unlikely(error != HA_ERR_END_OF_FILE)) if (unlikely(error != HA_ERR_END_OF_FILE))
{ {
file->print_error(error,MYF(ME_ERROR | ME_WAITTANG)); // purecov: inspected file->print_error(error,MYF(ME_ERROR));
DBUG_RETURN(HA_POS_ERROR); /* purecov: inspected */ DBUG_RETURN(HA_POS_ERROR);
} }
if (indexpos && idx && if (indexpos && idx &&
write_keys(param, fs_info, idx, buffpek_pointers, tempfile)) write_keys(param, fs_info, idx, buffpek_pointers, tempfile))

4
sql/log.cc
View File

@ -2647,7 +2647,7 @@ bool MYSQL_LOG::open(
#endif #endif
if ((file= mysql_file_open(log_file_key, log_file_name, open_flags, if ((file= mysql_file_open(log_file_key, log_file_name, open_flags,
MYF(MY_WME | ME_WAITTANG))) < 0) MYF(MY_WME))) < 0)
goto err; goto err;
if (is_fifo) if (is_fifo)
@ -4625,7 +4625,7 @@ int MYSQL_BIN_LOG::open_purge_index_file(bool destroy)
if (!my_b_inited(&purge_index_file)) if (!my_b_inited(&purge_index_file))
{ {
if ((file= my_open(purge_index_file_name, O_RDWR | O_CREAT | O_BINARY, if ((file= my_open(purge_index_file_name, O_RDWR | O_CREAT | O_BINARY,
MYF(MY_WME | ME_WAITTANG))) < 0 || MYF(MY_WME))) < 0 ||
init_io_cache(&purge_index_file, file, IO_SIZE, init_io_cache(&purge_index_file, file, IO_SIZE,
(destroy ? WRITE_CACHE : READ_CACHE), (destroy ? WRITE_CACHE : READ_CACHE),
0, 0, MYF(MY_WME | MY_NABP | MY_WAIT_IF_FULL))) 0, 0, MYF(MY_WME | MY_NABP | MY_WAIT_IF_FULL)))

2
sql/sql_class.cc
View File

@ -2659,7 +2659,7 @@ CHANGED_TABLE_LIST* THD::changed_table_dup(const char *key, size_t key_length)
key_length + 1); key_length + 1);
if (!new_table) if (!new_table)
{ {
my_error(EE_OUTOFMEMORY, MYF(ME_BELL+ME_FATALERROR), my_error(EE_OUTOFMEMORY, MYF(ME_FATALERROR),
ALIGN_SIZE(sizeof(TABLE_LIST)) + key_length + 1); ALIGN_SIZE(sizeof(TABLE_LIST)) + key_length + 1);
set_killed(KILL_CONNECTION); set_killed(KILL_CONNECTION);
return 0; return 0;

3
sql/sql_repl.cc
View File

@ -3840,8 +3840,7 @@ int reset_master(THD* thd, rpl_gtid *init_state, uint32 init_state_len,
if (!mysql_bin_log.is_open()) if (!mysql_bin_log.is_open())
{ {
my_message(ER_FLUSH_MASTER_BINLOG_CLOSED, my_message(ER_FLUSH_MASTER_BINLOG_CLOSED,
ER_THD(thd, ER_FLUSH_MASTER_BINLOG_CLOSED), ER_THD(thd, ER_FLUSH_MASTER_BINLOG_CLOSED), MYF(0));
MYF(ME_BELL+ME_WAITTANG));
return 1; return 1;
} }

4
sql/sql_show.cc
View File

@ -1034,9 +1034,9 @@ find_files(THD *thd, Dynamic_array<LEX_CSTRING*> *files, LEX_CSTRING *db,
if (!(dirp = my_dir(path, MY_THREAD_SPECIFIC | (db ? 0 : MY_WANT_STAT)))) if (!(dirp = my_dir(path, MY_THREAD_SPECIFIC | (db ? 0 : MY_WANT_STAT))))
{ {
if (my_errno == ENOENT) if (my_errno == ENOENT)
my_error(ER_BAD_DB_ERROR, MYF(ME_BELL | ME_WAITTANG), db->str); my_error(ER_BAD_DB_ERROR, MYF(0), db->str);
else else
my_error(ER_CANT_READ_DIR, MYF(ME_BELL | ME_WAITTANG), path, my_errno); my_error(ER_CANT_READ_DIR, MYF(0), path, my_errno);
DBUG_RETURN(FIND_FILES_DIR); DBUG_RETURN(FIND_FILES_DIR);
} }

2
sql/table.cc
View File

@ -3668,7 +3668,7 @@ void open_table_error(TABLE_SHARE *share, enum open_frm_error error,
int db_errno) int db_errno)
{ {
char buff[FN_REFLEN]; char buff[FN_REFLEN];
const myf errortype= ME_ERROR+ME_WAITTANG; // Write fatals error to log const myf errortype= ME_ERROR_LOG; // Write fatals error to log
DBUG_ENTER("open_table_error"); DBUG_ENTER("open_table_error");
DBUG_PRINT("info", ("error: %d db_errno: %d", error, db_errno)); DBUG_PRINT("info", ("error: %d db_errno: %d", error, db_errno));