os0file.h

Go to the documentation of this file.

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

Copyright (C) 1995, 2010, Innobase Oy. All Rights Reserved.
Copyright (C) 2009, Percona Inc.

Portions of this file contain modifications contributed and copyrighted
by Percona Inc.. Those modifications are
gratefully acknowledged and are described briefly in the InnoDB
documentation. The contributions by Percona Inc. are incorporated with
their permission, and subject to the conditions contained in the file
COPYING.Percona.

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 St, Fifth Floor, Boston, MA 02110-1301 USA

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

/**************************************************/
#pragma once
#ifndef os0file_h
#define os0file_h

#include "univ.i"

#ifndef __WIN__
#include <dirent.h>
#include <sys/stat.h>
#include <time.h>
#endif

typedef struct fil_node_struct  fil_node_t;

#ifdef UNIV_DO_FLUSH
extern ibool  os_do_not_call_flush_at_each_write;
#endif /* UNIV_DO_FLUSH */
extern ibool  os_has_said_disk_full;
extern ibool  os_aio_print_debug;

extern ulint  os_file_n_pending_preads;
extern ulint  os_file_n_pending_pwrites;

extern ulint  os_n_pending_reads;
extern ulint  os_n_pending_writes;

#ifdef __WIN__

#define WIN_ASYNC_IO

#define UNIV_NON_BUFFERED_IO

#endif

#ifdef __WIN__

# define os_file_t  HANDLE

# define OS_FILE_FROM_FD(fd) (HANDLE) _get_osfhandle(fd)
#else

typedef int os_file_t;
# define OS_FILE_FROM_FD(fd) fd
#endif

extern ulint  os_innodb_umask;

#define OS_FILE_LOG_BLOCK_SIZE    srv_log_block_size

#define OS_FILE_OPEN      51
#define OS_FILE_CREATE      52
#define OS_FILE_OVERWRITE   53
#define OS_FILE_OPEN_RAW    54
#define OS_FILE_CREATE_PATH   55
#define OS_FILE_OPEN_RETRY    56  /* for os_file_create() on
            the first ibdata file */

#define OS_FILE_READ_ONLY   333
#define OS_FILE_READ_WRITE    444
#define OS_FILE_READ_ALLOW_DELETE 555 /* for ibbackup */

/* Options for file_create */
#define OS_FILE_AIO     61
#define OS_FILE_NORMAL      62
/* @} */

#define OS_DATA_FILE      100
#define OS_LOG_FILE     101
/* @} */

#define OS_FILE_NOT_FOUND   71
#define OS_FILE_DISK_FULL   72
#define OS_FILE_ALREADY_EXISTS    73
#define OS_FILE_PATH_ERROR    74
#define OS_FILE_AIO_RESOURCES_RESERVED  75  /* wait for OS aio resources
            to become available again */
#define OS_FILE_SHARING_VIOLATION 76
#define OS_FILE_ERROR_NOT_SPECIFIED 77
#define OS_FILE_INSUFFICIENT_RESOURCE 78
#define OS_FILE_AIO_INTERRUPTED   79
#define OS_FILE_OPERATION_ABORTED 80
/* @} */

#define OS_FILE_READ  10
#define OS_FILE_WRITE 11

#define OS_FILE_LOG 256 /* This can be ORed to type */
/* @} */

#define OS_AIO_N_PENDING_IOS_PER_THREAD 32  
#define OS_AIO_NORMAL 21  
#define OS_AIO_IBUF 22  
#define OS_AIO_LOG  23  
#define OS_AIO_SYNC 24  
#define OS_AIO_SIMULATED_WAKE_LATER 512 
/* @} */

#define OS_WIN31  1 
#define OS_WIN95  2 
#define OS_WINNT  3 
#define OS_WIN2000  4 
#define OS_WINXP  5 
#define OS_WINVISTA 6 
#define OS_WIN7   7 
extern ulint  os_n_file_reads;
extern ulint  os_n_file_writes;
extern ulint  os_n_fsyncs;

extern uint32_t srv_log_block_size;

#ifdef UNIV_PFS_IO
/* Keys to register InnoDB I/O with performance schema */
extern mysql_pfs_key_t  innodb_file_data_key;
extern mysql_pfs_key_t  innodb_file_log_key;
extern mysql_pfs_key_t  innodb_file_temp_key;

/* Following four macros are instumentations to register
various file I/O operations with performance schema.
1) register_pfs_file_open_begin() and register_pfs_file_open_end() are
used to register file creation, opening, closing and renaming.
2) register_pfs_file_io_begin() and register_pfs_file_io_end() are
used to register actual file read, write and flush */
# define register_pfs_file_open_begin(state, locker, key, op, name, \
              src_file, src_line)   \
do {                  \
  if (PSI_server) {           \
    locker = PSI_server->get_thread_file_name_locker( \
      state, key, op, name, &locker);     \
    if (locker) {           \
      PSI_server->start_file_open_wait(   \
        locker, src_file, src_line);    \
    }             \
  }               \
} while (0)

# define register_pfs_file_open_end(locker, file)     \
do {                  \
  if (locker) {             \
    PSI_server->end_file_open_wait_and_bind_to_descriptor(  \
      locker, file);          \
  }               \
} while (0)

# define register_pfs_file_io_begin(state, locker, file, count, op, \
            src_file, src_line)     \
do {                  \
  if (PSI_server) {           \
    locker = PSI_server->get_thread_file_descriptor_locker( \
      state, file, op);       \
    if (locker) {           \
      PSI_server->start_file_wait(      \
        locker, count, src_file, src_line); \
    }             \
  }               \
} while (0)

# define register_pfs_file_io_end(locker, count)      \
do {                  \
  if (locker) {             \
    PSI_server->end_file_wait(locker, count);   \
  }               \
} while (0)
#endif /* UNIV_PFS_IO  */

/* Following macros/functions are file I/O APIs that would be performance
schema instrumented if "UNIV_PFS_IO" is defined. They would point to
wrapper functions with performance schema instrumentation in such case.

os_file_create
os_file_create_simple
os_file_create_simple_no_error_handling
os_file_close
os_file_rename
os_aio
os_file_read
os_file_read_no_error_handling
os_file_write

The wrapper functions have the prefix of "innodb_". */

#ifdef UNIV_PFS_IO
# define os_file_create(key, name, create, purpose, type, success)  \
  pfs_os_file_create_func(key, name, create, purpose, type, \
        success, __FILE__, __LINE__)

# define os_file_create_simple(key, name, create, access, success)  \
  pfs_os_file_create_simple_func(key, name, create, access, \
               success, __FILE__, __LINE__)

# define os_file_create_simple_no_error_handling(     \
    key, name, create_mode, access, success)    \
  pfs_os_file_create_simple_no_error_handling_func(   \
    key, name, create_mode, access, success, __FILE__, __LINE__)

# define os_file_close(file)            \
  pfs_os_file_close_func(file, __FILE__, __LINE__)

# define os_aio(type, mode, name, file, buf, offset, offset_high, \
    n, message1, message2)          \
  pfs_os_aio_func(type, mode, name, file, buf, offset,    \
      offset_high, n, message1, message2,   \
      __FILE__, __LINE__)

# define os_file_read(file, buf, offset, offset_high, n)    \
  pfs_os_file_read_func(file, buf, offset, offset_high, n,  \
            __FILE__, __LINE__)

# define os_file_read_no_error_handling(file, buf, offset,    \
          offset_high, n)     \
  pfs_os_file_read_no_error_handling_func(file, buf, offset,  \
            offset_high, n,   \
            __FILE__, __LINE__)

# define os_file_write(name, file, buf, offset, offset_high, n)   \
  pfs_os_file_write_func(name, file, buf, offset, offset_high,  \
             n, __FILE__, __LINE__)

# define os_file_flush(file)            \
  pfs_os_file_flush_func(file, __FILE__, __LINE__)

# define os_file_rename(key, oldpath, newpath)        \
  pfs_os_file_rename_func(key, oldpath, newpath, __FILE__, __LINE__)
#else /* UNIV_PFS_IO */

/* If UNIV_PFS_IO is not defined, these I/O APIs point
to original un-instrumented file I/O APIs */
# define os_file_create(key, name, create, purpose, type, success)  \
  os_file_create_func(name, create, purpose, type, success)

# define os_file_create_simple(key, name, create, access, success)  \
  os_file_create_simple_func(name, create_mode, access, success)

# define os_file_create_simple_no_error_handling(     \
    key, name, create_mode, access, success)    \
  os_file_create_simple_no_error_handling_func(     \
    name, create_mode, access, success)

# define os_file_close(file)  os_file_close_func(file)

# define os_aio(type, mode, name, file, buf, offset, offset_high, \
         n, message1, message2)         \
  os_aio_func(type, mode, name, file, buf, offset, offset_high, n,\
        message1, message2)

# define os_file_read(file, buf, offset, offset_high, n)    \
  os_file_read_func(file, buf, offset, offset_high, n)

# define os_file_read_no_error_handling(file, buf, offset,    \
               offset_high, n)      \
  os_file_read_no_error_handling_func(file, buf, offset, offset_high, n)

# define os_file_write(name, file, buf, offset, offset_high, n)   \
  os_file_write_func(name, file, buf, offset, offset_high, n)

# define os_file_flush(file)  os_file_flush_func(file)

# define os_file_rename(key, oldpath, newpath)        \
  os_file_rename_func(oldpath, newpath)

#endif /* UNIV_PFS_IO */

/* File types for directory entry data type */

enum os_file_type_enum{
  OS_FILE_TYPE_UNKNOWN = 0,
  OS_FILE_TYPE_FILE,      /* regular file */
  OS_FILE_TYPE_DIR,     /* directory */
  OS_FILE_TYPE_LINK     /* symbolic link */
};
typedef enum os_file_type_enum    os_file_type_t;

/* Maximum path string length in bytes when referring to tables with in the
'./databasename/tablename.ibd' path format; we can allocate at least 2 buffers
of this size from the thread stack; that is why this should not be made much
bigger than 4000 bytes */
#define OS_FILE_MAX_PATH  4000

/* Struct used in fetching information of a file in a directory */
struct os_file_stat_struct{
  char    name[OS_FILE_MAX_PATH]; 
  os_file_type_t  type;     
  ib_int64_t  size;     
  time_t    ctime;      
  time_t    mtime;      
  time_t    atime;      
};
typedef struct os_file_stat_struct  os_file_stat_t;

#ifdef __WIN__
typedef HANDLE  os_file_dir_t;  
#else
typedef DIR*  os_file_dir_t;  
#endif

/***********************************************************************/
UNIV_INTERN
ulint
os_get_os_version(void);
/*===================*/
#ifndef UNIV_HOTBACKUP
/****************************************************************/
UNIV_INTERN
void
os_io_init_simple(void);
/*===================*/
/***********************************************************************/
FILE*
os_file_create_tmpfile(void);
/*========================*/
#endif /* !UNIV_HOTBACKUP */
/***********************************************************************/
UNIV_INTERN
os_file_dir_t
os_file_opendir(
/*============*/
  const char* dirname,  
  ibool   error_is_fatal);
/***********************************************************************/
UNIV_INTERN
int
os_file_closedir(
/*=============*/
  os_file_dir_t dir); 
/***********************************************************************/
UNIV_INTERN
int
os_file_readdir_next_file(
/*======================*/
  const char* dirname,
  os_file_dir_t dir,  
  os_file_stat_t* info);  
/*****************************************************************/
UNIV_INTERN
ibool
os_file_create_directory(
/*=====================*/
  const char* pathname, 
  ibool   fail_if_exists);
/****************************************************************/
UNIV_INTERN
os_file_t
os_file_create_simple_func(
/*=======================*/
  const char* name, 
  ulint   create_mode,
  ulint   access_type,
  ibool*    success);
/****************************************************************/
UNIV_INTERN
os_file_t
os_file_create_simple_no_error_handling_func(
/*=========================================*/
  const char* name, 
  ulint   create_mode,
  ulint   access_type,
  ibool*    success);
/****************************************************************/
UNIV_INTERN
void
os_file_set_nocache(
/*================*/
  int   fd,   
  const char* file_name,  
  const char* operation_name);
/****************************************************************/
UNIV_INTERN
os_file_t
os_file_create_func(
/*================*/
  const char* name, 
  ulint   create_mode,
  ulint   purpose,
  ulint   type, 
  ibool*    success);
/***********************************************************************/
UNIV_INTERN
ibool
os_file_delete(
/*===========*/
  const char* name);  
/***********************************************************************/
UNIV_INTERN
ibool
os_file_delete_if_exists(
/*=====================*/
  const char* name);  
/***********************************************************************/
UNIV_INTERN
ibool
os_file_rename_func(
/*================*/
  const char* oldpath,  
  const char* newpath); 
/***********************************************************************/
UNIV_INTERN
ibool
os_file_close_func(
/*===============*/
  os_file_t file);  
#ifdef UNIV_PFS_IO
/****************************************************************/
UNIV_INLINE
os_file_t
pfs_os_file_create_simple_func(
/*===========================*/
  mysql_pfs_key_t key,  
  const char* name, 
  ulint   create_mode,
  ulint   access_type,
  ibool*    success,
  const char* src_file,
  ulint   src_line);
/****************************************************************/
UNIV_INLINE
os_file_t
pfs_os_file_create_simple_no_error_handling_func(
/*=============================================*/
  mysql_pfs_key_t key,  
  const char* name, 
  ulint   create_mode,
  ulint   access_type,
  ibool*    success,
  const char* src_file,
  ulint   src_line);
/****************************************************************/
UNIV_INLINE
os_file_t
pfs_os_file_create_func(
/*====================*/
  mysql_pfs_key_t key,  
  const char* name, 
  ulint   create_mode,
  ulint   purpose,
  ulint   type, 
  ibool*    success,
  const char* src_file,
  ulint   src_line);
/***********************************************************************/
UNIV_INLINE
ibool
pfs_os_file_close_func(
/*===================*/
        os_file_t file, 
  const char* src_file,
  ulint   src_line);
/*******************************************************************/
UNIV_INLINE
ibool
pfs_os_file_read_func(
/*==================*/
  os_file_t file, 
  void*   buf,  
  ulint   offset, 
  ulint   offset_high,
  ulint   n,  
  const char* src_file,
  ulint   src_line);
/*******************************************************************/
UNIV_INLINE
ibool
pfs_os_file_read_no_error_handling_func(
/*====================================*/
  os_file_t file, 
  void*   buf,  
  ulint   offset, 
  ulint   offset_high,
  ulint   n,  
  const char* src_file,
  ulint   src_line);
/*******************************************************************/
UNIV_INLINE
ibool
pfs_os_aio_func(
/*============*/
  ulint   type, 
  ulint   mode, 
  const char* name, 
  os_file_t file, 
  void*   buf,  
  ulint   offset, 
  ulint   offset_high,
  ulint   n,  
  fil_node_t* message1,
  void*   message2,
  const char* src_file,
  ulint   src_line);
/*******************************************************************/
UNIV_INLINE
ibool
pfs_os_file_write_func(
/*===================*/
  const char* name, 
  os_file_t file, 
  const void* buf,  
  ulint   offset, 
  ulint   offset_high,
  ulint   n,  
  const char* src_file,
  ulint   src_line);
/***********************************************************************/
UNIV_INLINE
ibool
pfs_os_file_flush_func(
/*===================*/
  os_file_t file, 
  const char* src_file,
  ulint   src_line);
/***********************************************************************/
UNIV_INLINE
ibool
pfs_os_file_rename_func(
/*====================*/
  mysql_pfs_key_t key,  
  const char* oldpath,
  const char* newpath,
  const char* src_file,
  ulint   src_line);
#endif  /* UNIV_PFS_IO */

#ifdef UNIV_HOTBACKUP
/***********************************************************************/
UNIV_INTERN
ibool
os_file_close_no_error_handling(
/*============================*/
  os_file_t file);  
#endif /* UNIV_HOTBACKUP */
/***********************************************************************/
UNIV_INTERN
ibool
os_file_get_size(
/*=============*/
  os_file_t file, 
  ulint*    size, 
  ulint*    size_high);
/***********************************************************************/
UNIV_INTERN
ib_int64_t
os_file_get_size_as_iblonglong(
/*===========================*/
  os_file_t file);  
/***********************************************************************/
UNIV_INTERN
ibool
os_file_set_size(
/*=============*/
  const char* name, 
  os_file_t file, 
  ulint   size, 
  ulint   size_high);
/***********************************************************************/
UNIV_INTERN
ibool
os_file_set_eof(
/*============*/
  FILE*   file);  
/***********************************************************************/
UNIV_INTERN
ibool
os_file_flush_func(
/*===============*/
  os_file_t file);  
/***********************************************************************/
UNIV_INTERN
ulint
os_file_get_last_error(
/*===================*/
  ibool report_all_errors); 
/*******************************************************************/
UNIV_INTERN
ibool
os_file_read_func(
/*==============*/
  os_file_t file, 
  void*   buf,  
  ulint   offset, 
  ulint   offset_high,
  ulint   n); 
/*******************************************************************/
UNIV_INTERN
void
os_file_read_string(
/*================*/
  FILE* file, 
  char* str,  
  ulint size);  
/*******************************************************************/
UNIV_INTERN
ibool
os_file_read_no_error_handling_func(
/*================================*/
  os_file_t file, 
  void*   buf,  
  ulint   offset, 
  ulint   offset_high,
  ulint   n); 
/*******************************************************************/
UNIV_INTERN
ibool
os_file_write_func(
/*===============*/
  const char* name, 
  os_file_t file, 
  const void* buf,  
  ulint   offset, 
  ulint   offset_high,
  ulint   n); 
/*******************************************************************/
UNIV_INTERN
ibool
os_file_status(
/*===========*/
  const char* path, 
  ibool*    exists, 
  os_file_type_t* type);  
/****************************************************************/
UNIV_INTERN
char*
os_file_dirname(
/*============*/
  const char* path);  
/****************************************************************/
UNIV_INTERN
ibool
os_file_create_subdirs_if_needed(
/*=============================*/
  const char* path);  
/***********************************************************************
Initializes the asynchronous io system. Creates one array each for ibuf
and log i/o. Also creates one array each for read and write where each
array is divided logically into n_read_segs and n_write_segs
respectively. The caller must create an i/o handler thread for each
segment in these arrays. This function also creates the sync array.
No i/o handler thread needs to be created for that */
UNIV_INTERN
ibool
os_aio_init(
/*========*/
  ulint n_per_seg,  /*<! in: maximum number of pending aio
        operations allowed per segment */
  ulint n_read_segs,  /*<! in: number of reader threads */
  ulint n_write_segs, /*<! in: number of writer threads */
  ulint n_slots_sync);  /*<! in: number of slots in the sync aio
        array */
/***********************************************************************
Frees the asynchronous io system. */
UNIV_INTERN
void
os_aio_free(void);
/*=============*/

/*******************************************************************/
UNIV_INTERN
ibool
os_aio_func(
/*========*/
  ulint   type, 
  ulint   mode, 
  const char* name, 
  os_file_t file, 
  void*   buf,  
  ulint   offset, 
  ulint   offset_high, 
  ulint   n,  
  fil_node_t* message1,
  void*   message2);
/************************************************************************/
UNIV_INTERN
void
os_aio_wake_all_threads_at_shutdown(void);
/*=====================================*/
/************************************************************************/
UNIV_INTERN
void
os_aio_wait_until_no_pending_writes(void);
/*=====================================*/
/**********************************************************************/
UNIV_INTERN
void
os_aio_simulated_wake_handler_threads(void);
/*=======================================*/
/**********************************************************************/
UNIV_INTERN
void
os_aio_simulated_put_read_threads_to_sleep(void);
/*============================================*/

#ifdef WIN_ASYNC_IO
/**********************************************************************/
UNIV_INTERN
ibool
os_aio_windows_handle(
/*==================*/
  ulint segment,  
  ulint pos,    
  fil_node_t**message1, 
  void**  message2,
  ulint*  type);    
#endif

/**********************************************************************/
UNIV_INTERN
ibool
os_aio_simulated_handle(
/*====================*/
  ulint segment,  
  fil_node_t**message1, 
  void**  message2,
  ulint*  type);    
/**********************************************************************/
UNIV_INTERN
ibool
os_aio_validate(void);
/*=================*/
/**********************************************************************/
UNIV_INTERN
void
os_aio_print(
/*=========*/
  FILE* file);  
/**********************************************************************/
UNIV_INTERN
void
os_aio_refresh_stats(void);
/*======================*/

#ifdef UNIV_DEBUG
/**********************************************************************/
UNIV_INTERN
ibool
os_aio_all_slots_free(void);
/*=======================*/
#endif /* UNIV_DEBUG */

/*******************************************************************/
UNIV_INTERN
ibool
os_file_get_status(
/*===============*/
  const char* path,   
  os_file_stat_t* stat_info); 
#if !defined(UNIV_HOTBACKUP)
/*********************************************************************/
UNIV_INTERN
int
innobase_mysql_tmpfile(void);
/*========================*/
#endif /* !UNIV_HOTBACKUP */


#if defined(LINUX_NATIVE_AIO)
/**************************************************************************
This function is only used in Linux native asynchronous i/o.
Waits for an aio operation to complete. This function is used to wait the
for completed requests. The aio array of pending requests is divided
into segments. The thread specifies which segment or slot it wants to wait
for. NOTE: this function will also take care of freeing the aio slot,
therefore no other thread is allowed to do the freeing!
@return TRUE if the IO was successful */
UNIV_INTERN
ibool
os_aio_linux_handle(
/*================*/
  ulint global_seg, 
  fil_node_t**message1, 
  void**  message2, 
  ulint*  type);    
#endif /* LINUX_NATIVE_AIO */

#ifndef UNIV_NONINL
#include "os0file.ic"
#endif

#endif