ut0ut.cc

Go to the documentation of this file.

/*****************************************************************************

Copyright (c) 1994, 2012, Oracle and/or its affiliates. All Rights Reserved.

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.,
51 Franklin Street, Suite 500, Boston, MA 02110-1335 USA

*****************************************************************************/

/***************************************************************/
#include "ut0ut.h"

#ifndef UNIV_INNOCHECKSUM

#include "ut0sort.h"
#include "os0thread.h" /* thread-ID */

#ifdef UNIV_NONINL
#include "ut0ut.ic"
#endif

#include <stdarg.h>
#include <string.h>
#include <ctype.h>

#ifndef UNIV_HOTBACKUP
# include "trx0trx.h"
# include "ha_prototypes.h"
# include "mysql_com.h" /* NAME_LEN */
#endif /* UNIV_HOTBACKUP */

UNIV_INTERN ibool       ut_always_false = FALSE;

#ifdef __WIN__
/*****************************************************************/
#define WIN_TO_UNIX_DELTA_USEC  ((ib_int64_t) 11644473600000000ULL)


/*****************************************************************/
static
int
ut_gettimeofday(
/*============*/
        struct timeval* tv,     
        void*           tz)     
{
        FILETIME        ft;
        ib_int64_t      tm;

        if (!tv) {
                errno = EINVAL;
                return(-1);
        }

        GetSystemTimeAsFileTime(&ft);

        tm = (ib_int64_t) ft.dwHighDateTime << 32;
        tm |= ft.dwLowDateTime;

        ut_a(tm >= 0);  /* If tm wraps over to negative, the quotient / 10
                        does not work */

        tm /= 10;       /* Convert from 100 nsec periods to usec */

        /* If we don't convert to the Unix epoch the value for
        struct timeval::tv_sec will overflow.*/
        tm -= WIN_TO_UNIX_DELTA_USEC;

        tv->tv_sec  = (long) (tm / 1000000L);
        tv->tv_usec = (long) (tm % 1000000L);

        return(0);
}
#else

#define ut_gettimeofday         gettimeofday
#endif

/**********************************************************/
UNIV_INTERN
ib_time_t
ut_time(void)
/*=========*/
{
        return(time(NULL));
}

#ifndef UNIV_HOTBACKUP
/**********************************************************/
UNIV_INTERN
int
ut_usectime(
/*========*/
        ulint*  sec,    
        ulint*  ms)     
{
        struct timeval  tv;
        int             ret;
        int             errno_gettimeofday;
        int             i;

        for (i = 0; i < 10; i++) {

                ret = ut_gettimeofday(&tv, NULL);

                if (ret == -1) {
                        errno_gettimeofday = errno;
                        ut_print_timestamp(stderr);
                        fprintf(stderr, "  InnoDB: gettimeofday(): %s\n",
                                strerror(errno_gettimeofday));
                        os_thread_sleep(100000);  /* 0.1 sec */
                        errno = errno_gettimeofday;
                } else {
                        break;
                }
        }

        if (ret != -1) {
                *sec = (ulint) tv.tv_sec;
                *ms  = (ulint) tv.tv_usec;
        }

        return(ret);
}

/**********************************************************/
UNIV_INTERN
ullint
ut_time_us(
/*=======*/
        ullint* tloc)   
{
        struct timeval  tv;
        ullint          us;

        ut_gettimeofday(&tv, NULL);

        us = (ullint) tv.tv_sec * 1000000 + tv.tv_usec;

        if (tloc != NULL) {
                *tloc = us;
        }

        return(us);
}

/**********************************************************/
UNIV_INTERN
ulint
ut_time_ms(void)
/*============*/
{
        struct timeval  tv;

        ut_gettimeofday(&tv, NULL);

        return((ulint) tv.tv_sec * 1000 + tv.tv_usec / 1000);
}
#endif /* !UNIV_HOTBACKUP */

/**********************************************************/
UNIV_INTERN
double
ut_difftime(
/*========*/
        ib_time_t       time2,  
        ib_time_t       time1)  
{
        return(difftime(time2, time1));
}

#endif /* !UNIV_INNOCHECKSUM */

/**********************************************************/
UNIV_INTERN
void
ut_print_timestamp(
/*===============*/
        FILE*  file) 
{
        ulint thread_id = 0;

#ifndef UNIV_INNOCHECKSUM
        thread_id = os_thread_pf(os_thread_get_curr_id());
#endif

#ifdef __WIN__
        SYSTEMTIME cal_tm;

        GetLocalTime(&cal_tm);

        fprintf(file, "%d-%02d-%02d %02d:%02d:%02d %lx",
                (int) cal_tm.wYear,
                (int) cal_tm.wMonth,
                (int) cal_tm.wDay,
                (int) cal_tm.wHour,
                (int) cal_tm.wMinute,
                (int) cal_tm.wSecond,
                thread_id);
#else
        struct tm* cal_tm_ptr;
        time_t     tm;

#ifdef HAVE_LOCALTIME_R
        struct tm  cal_tm;
        time(&tm);
        localtime_r(&tm, &cal_tm);
        cal_tm_ptr = &cal_tm;
#else
        time(&tm);
        cal_tm_ptr = localtime(&tm);
#endif
        fprintf(file, "%d-%02d-%02d %02d:%02d:%02d %lx",
                cal_tm_ptr->tm_year + 1900,
                cal_tm_ptr->tm_mon + 1,
                cal_tm_ptr->tm_mday,
                cal_tm_ptr->tm_hour,
                cal_tm_ptr->tm_min,
                cal_tm_ptr->tm_sec,
                thread_id);
#endif
}

#ifndef UNIV_INNOCHECKSUM

/**********************************************************/
UNIV_INTERN
void
ut_sprintf_timestamp(
/*=================*/
        char*   buf) 
{
#ifdef __WIN__
        SYSTEMTIME cal_tm;

        GetLocalTime(&cal_tm);

        sprintf(buf, "%02d%02d%02d %2d:%02d:%02d",
                (int) cal_tm.wYear % 100,
                (int) cal_tm.wMonth,
                (int) cal_tm.wDay,
                (int) cal_tm.wHour,
                (int) cal_tm.wMinute,
                (int) cal_tm.wSecond);
#else
        struct tm* cal_tm_ptr;
        time_t     tm;

#ifdef HAVE_LOCALTIME_R
        struct tm  cal_tm;
        time(&tm);
        localtime_r(&tm, &cal_tm);
        cal_tm_ptr = &cal_tm;
#else
        time(&tm);
        cal_tm_ptr = localtime(&tm);
#endif
        sprintf(buf, "%02d%02d%02d %2d:%02d:%02d",
                cal_tm_ptr->tm_year % 100,
                cal_tm_ptr->tm_mon + 1,
                cal_tm_ptr->tm_mday,
                cal_tm_ptr->tm_hour,
                cal_tm_ptr->tm_min,
                cal_tm_ptr->tm_sec);
#endif
}

#ifdef UNIV_HOTBACKUP
/**********************************************************/
UNIV_INTERN
void
ut_sprintf_timestamp_without_extra_chars(
/*=====================================*/
        char*   buf) 
{
#ifdef __WIN__
        SYSTEMTIME cal_tm;

        GetLocalTime(&cal_tm);

        sprintf(buf, "%02d%02d%02d_%2d_%02d_%02d",
                (int) cal_tm.wYear % 100,
                (int) cal_tm.wMonth,
                (int) cal_tm.wDay,
                (int) cal_tm.wHour,
                (int) cal_tm.wMinute,
                (int) cal_tm.wSecond);
#else
        struct tm* cal_tm_ptr;
        time_t     tm;

#ifdef HAVE_LOCALTIME_R
        struct tm  cal_tm;
        time(&tm);
        localtime_r(&tm, &cal_tm);
        cal_tm_ptr = &cal_tm;
#else
        time(&tm);
        cal_tm_ptr = localtime(&tm);
#endif
        sprintf(buf, "%02d%02d%02d_%2d_%02d_%02d",
                cal_tm_ptr->tm_year % 100,
                cal_tm_ptr->tm_mon + 1,
                cal_tm_ptr->tm_mday,
                cal_tm_ptr->tm_hour,
                cal_tm_ptr->tm_min,
                cal_tm_ptr->tm_sec);
#endif
}

/**********************************************************/
UNIV_INTERN
void
ut_get_year_month_day(
/*==================*/
        ulint*  year,   
        ulint*  month,  
        ulint*  day)    
{
#ifdef __WIN__
        SYSTEMTIME cal_tm;

        GetLocalTime(&cal_tm);

        *year = (ulint) cal_tm.wYear;
        *month = (ulint) cal_tm.wMonth;
        *day = (ulint) cal_tm.wDay;
#else
        struct tm* cal_tm_ptr;
        time_t     tm;

#ifdef HAVE_LOCALTIME_R
        struct tm  cal_tm;
        time(&tm);
        localtime_r(&tm, &cal_tm);
        cal_tm_ptr = &cal_tm;
#else
        time(&tm);
        cal_tm_ptr = localtime(&tm);
#endif
        *year = (ulint) cal_tm_ptr->tm_year + 1900;
        *month = (ulint) cal_tm_ptr->tm_mon + 1;
        *day = (ulint) cal_tm_ptr->tm_mday;
#endif
}
#endif /* UNIV_HOTBACKUP */

#ifndef UNIV_HOTBACKUP
/*************************************************************/
UNIV_INTERN
ulint
ut_delay(
/*=====*/
        ulint   delay)  
{
        ulint   i, j;

        j = 0;

        for (i = 0; i < delay * 50; i++) {
                j += i;
                UT_RELAX_CPU();
        }

        if (ut_always_false) {
                ut_always_false = (ibool) j;
        }

        return(j);
}
#endif /* !UNIV_HOTBACKUP */

/*************************************************************/
UNIV_INTERN
void
ut_print_buf(
/*=========*/
        FILE*           file,   
        const void*     buf,    
        ulint           len)    
{
        const byte*     data;
        ulint           i;

        UNIV_MEM_ASSERT_RW(buf, len);

        fprintf(file, " len %lu; hex ", len);

        for (data = (const byte*) buf, i = 0; i < len; i++) {
                fprintf(file, "%02lx", (ulong)*data++);
        }

        fputs("; asc ", file);

        data = (const byte*) buf;

        for (i = 0; i < len; i++) {
                int     c = (int) *data++;
                putc(isprint(c) ? c : ' ', file);
        }

        putc(';', file);
}

/**********************************************************************/
UNIV_INTERN
void
ut_ulint_sort(
/*==========*/
        ulint*  arr,            
        ulint*  aux_arr,        
        ulint   low,            
        ulint   high)           
{
        UT_SORT_FUNCTION_BODY(ut_ulint_sort, arr, aux_arr, low, high,
                              ut_ulint_cmp);
}

/*************************************************************/
UNIV_INTERN
ulint
ut_2_power_up(
/*==========*/
        ulint   n)      
{
        ulint   res;

        res = 1;

        ut_ad(n > 0);

        while (res < n) {
                res = res * 2;
        }

        return(res);
}

/**********************************************************************/
UNIV_INTERN
void
ut_print_filename(
/*==============*/
        FILE*           f,      
        const char*     name)   
{
        putc('\'', f);
        for (;;) {
                int     c = *name++;
                switch (c) {
                case 0:
                        goto done;
                case '\'':
                        putc(c, f);
                        /* fall through */
                default:
                        putc(c, f);
                }
        }
done:
        putc('\'', f);
}
#ifndef UNIV_HOTBACKUP
/**********************************************************************/
UNIV_INTERN
void
ut_print_name(
/*==========*/
        FILE*           f,      
        const trx_t*    trx,    
        ibool           table_id,
        const char*     name)   
{
        ut_print_namel(f, trx, table_id, name, strlen(name));
}

/**********************************************************************/
UNIV_INTERN
void
ut_print_namel(
/*===========*/
        FILE*           f,      
        const trx_t*    trx,    
        ibool           table_id,
        const char*     name,   
        ulint           namelen)
{
        /* 2 * NAME_LEN for database and table name,
        and some slack for the #mysql50# prefix and quotes */
        char            buf[3 * NAME_LEN];
        const char*     bufend;

        bufend = innobase_convert_name(buf, sizeof buf,
                                       name, namelen,
                                       trx ? trx->mysql_thd : NULL,
                                       table_id);

        fwrite(buf, 1, bufend - buf, f);
}

/**********************************************************************/
UNIV_INTERN
char*
ut_format_name(
/*===========*/
        const char*     name,           
        ibool           is_table,       
        char*           formatted,      
        ulint           formatted_size) 
{
        switch (formatted_size) {
        case 1:
                formatted[0] = '\0';
                /* FALL-THROUGH */
        case 0:
                return(formatted);
        }

        char*   end;

        end = innobase_convert_name(formatted, formatted_size,
                                    name, strlen(name), NULL, is_table);

        /* If the space in 'formatted' was completely used, then sacrifice
        the last character in order to write '\0' at the end. */
        if ((ulint) (end - formatted) == formatted_size) {
                end--;
        }

        ut_a((ulint) (end - formatted) < formatted_size);

        *end = '\0';

        return(formatted);
}

/**********************************************************************/
UNIV_INTERN
void
ut_copy_file(
/*=========*/
        FILE*   dest,   
        FILE*   src)    
{
        long    len = ftell(src);
        char    buf[4096];

        rewind(src);
        do {
                size_t  maxs = len < (long) sizeof buf
                        ? (size_t) len
                        : sizeof buf;
                size_t  size = fread(buf, 1, maxs, src);
                fwrite(buf, 1, size, dest);
                len -= (long) size;
                if (size < maxs) {
                        break;
                }
        } while (len > 0);
}
#endif /* !UNIV_HOTBACKUP */

#ifdef __WIN__
# include <stdarg.h>
/**********************************************************************/
UNIV_INTERN
void
ut_vsnprintf(
/*=========*/
        char*           str,    
        size_t          size,   
        const char*     fmt,    
        va_list         ap)     
{
        _vsnprintf(str, size, fmt, ap);
        str[size - 1] = '\0';
}

/**********************************************************************/
UNIV_INTERN
int
ut_snprintf(
/*========*/
        char*           str,    
        size_t          size,   
        const char*     fmt,    
        ...)                    
{
        int     res;
        va_list ap1;
        va_list ap2;

        va_start(ap1, fmt);
        va_start(ap2, fmt);

        res = _vscprintf(fmt, ap1);
        ut_a(res != -1);

        if (size > 0) {
                _vsnprintf(str, size, fmt, ap2);

                if ((size_t) res >= size) {
                        str[size - 1] = '\0';
                }
        }

        va_end(ap1);
        va_end(ap2);

        return(res);
}
#endif /* __WIN__ */

/*************************************************************/
UNIV_INTERN
const char*
ut_strerr(
/*======*/
        dberr_t num)    
{
        switch (num) {
        case DB_SUCCESS:
                return("Success");
        case DB_SUCCESS_LOCKED_REC:
                return("Success, record lock created");
        case DB_ERROR:
                return("Generic error");
        case DB_READ_ONLY:
                return("Read only transaction");
        case DB_INTERRUPTED:
                return("Operation interrupted");
        case DB_OUT_OF_MEMORY:
                return("Cannot allocate memory");
        case DB_OUT_OF_FILE_SPACE:
                return("Out of disk space");
        case DB_LOCK_WAIT:
                return("Lock wait");
        case DB_DEADLOCK:
                return("Deadlock");
        case DB_ROLLBACK:
                return("Rollback");
        case DB_DUPLICATE_KEY:
                return("Duplicate key");
        case DB_QUE_THR_SUSPENDED:
                return("The queue thread has been suspended");
        case DB_MISSING_HISTORY:
                return("Required history data has been deleted");
        case DB_CLUSTER_NOT_FOUND:
                return("Cluster not found");
        case DB_TABLE_NOT_FOUND:
                return("Table not found");
        case DB_MUST_GET_MORE_FILE_SPACE:
                return("More file space needed");
        case DB_TABLE_IS_BEING_USED:
                return("Table is being used");
        case DB_TOO_BIG_RECORD:
                return("Record too big");
        case DB_TOO_BIG_INDEX_COL:
                return("Index columns size too big");
        case DB_LOCK_WAIT_TIMEOUT:
                return("Lock wait timeout");
        case DB_NO_REFERENCED_ROW:
                return("Referenced key value not found");
        case DB_ROW_IS_REFERENCED:
                return("Row is referenced");
        case DB_CANNOT_ADD_CONSTRAINT:
                return("Cannot add constraint");
        case DB_CORRUPTION:
                return("Data structure corruption");
        case DB_CANNOT_DROP_CONSTRAINT:
                return("Cannot drop constraint");
        case DB_NO_SAVEPOINT:
                return("No such savepoint");
        case DB_TABLESPACE_EXISTS:
                return("Tablespace already exists");
        case DB_TABLESPACE_DELETED:
                return("Tablespace deleted or being deleted");
        case DB_TABLESPACE_NOT_FOUND:
                return("Tablespace not found");
        case DB_LOCK_TABLE_FULL:
                return("Lock structs have exhausted the buffer pool");
        case DB_FOREIGN_DUPLICATE_KEY:
                return("Foreign key activated with duplicate keys");
        case DB_FOREIGN_EXCEED_MAX_CASCADE:
                return("Foreign key cascade delete/update exceeds max depth");
        case DB_TOO_MANY_CONCURRENT_TRXS:
                return("Too many concurrent transactions");
        case DB_UNSUPPORTED:
                return("Unsupported");
        case DB_INVALID_NULL:
                return("NULL value encountered in NOT NULL column");
        case DB_STATS_DO_NOT_EXIST:
                return("Persistent statistics do not exist");
        case DB_FAIL:
                return("Failed, retry may succeed");
        case DB_OVERFLOW:
                return("Overflow");
        case DB_UNDERFLOW:
                return("Underflow");
        case DB_STRONG_FAIL:
                return("Failed, retry will not succeed");
        case DB_ZIP_OVERFLOW:
                return("Zip overflow");
        case DB_RECORD_NOT_FOUND:
                return("Record not found");
        case DB_CHILD_NO_INDEX:
                return("No index on referencing keys in referencing table");
        case DB_PARENT_NO_INDEX:
                return("No index on referenced keys in referenced table");
        case DB_FTS_INVALID_DOCID:
                return("FTS Doc ID cannot be zero");
        case DB_INDEX_CORRUPT:
                return("Index corrupted");
        case DB_UNDO_RECORD_TOO_BIG:
                return("Undo record too big");
        case DB_END_OF_INDEX:
                return("End of index");
        case DB_IO_ERROR:
                return("I/O error");
        case DB_TABLE_IN_FK_CHECK:
                return("Table is being used in foreign key check");
        case DB_DATA_MISMATCH:
                return("data mismatch");
        case DB_SCHEMA_NOT_LOCKED:
                return("schema not locked");
        case DB_NOT_FOUND:
                return("not found");
        case DB_ONLINE_LOG_TOO_BIG:
                return("Log size exceeded during online index creation");
        case DB_DICT_CHANGED:
                return("Table dictionary has changed");
        case DB_IDENTIFIER_TOO_LONG:
                return("Identifier name is too long");
        case DB_FTS_EXCEED_RESULT_CACHE_LIMIT:
                return("FTS query exceeds result cache limit");

        /* do not add default: in order to produce a warning if new code
        is added to the enum but not added here */
        }

        /* we abort here because if unknown error code is given, this could
        mean that memory corruption has happened and someone's error-code
        variable has been overwritten with bogus data */
        ut_error;

        /* NOT REACHED */
        return("Unknown error");
}
#endif /* !UNIV_INNOCHECKSUM */