File file_io.h¶
File List > cubrid > src > storage > file_io.h
Go to the documentation of this file
/*
* Copyright 2008 Search Solution Corporation
* Copyright 2016 CUBRID Corporation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
/*
* file_io.h - I/O module at server
*
*/
#ifndef _FILE_IO_H_
#define _FILE_IO_H_
#ident "$Id$"
#include "config.h"
#include "dbtype_def.h"
#include "log_lsa.hpp"
#include "memory_hash.h"
#include "porting.h"
#include "porting_inline.hpp"
#include "release_string.h"
#include "storage_common.h"
#include "thread_compat.hpp"
#include <stdio.h>
#include <time.h>
#include <map>
#define NULL_VOLDES (-1) /* Value of a null (invalid) vol descriptor */
#define FILEIO_INITIAL_BACKUP_UNITS 0
#define FILEIO_NO_BACKUP_UNITS -1
/* Note: this value must be at least as large as PATH_MAX */
#define FILEIO_MAX_USER_RESPONSE_SIZE 2000
#if defined(WINDOWS)
#define S_ISDIR(mode) ((mode) & _S_IFDIR)
#define S_ISREG(mode) ((mode) & _S_IFREG)
#endif /* WINDOWS */
#define FILEIO_FIRST_BACKUP_VOL_INFO 0
#define FILEIO_SECOND_BACKUP_VOL_INFO 1
#define FILEIO_BACKUP_NUM_THREADS_AUTO 0
#define FILEIO_BACKUP_SLEEP_MSECS_AUTO 0
/* FILEIO_PAGE_FLAG (pflag in FILEIO_PAGE_RESERVED) */
#define FILEIO_PAGE_FLAG_ENCRYPTED_AES 0x1
#define FILEIO_PAGE_FLAG_ENCRYPTED_ARIA 0x2
#define FILEIO_PAGE_FLAG_ENCRYPTED_MASK 0x3
#if defined(WINDOWS)
#define STR_PATH_SEPARATOR "\\"
#else /* WINDOWS */
#define STR_PATH_SEPARATOR "/"
#endif /* WINDOWS */
#define PEEK true /* Peek volume label pointer */
#define ALLOC_COPY false /* alloc and copy volume label */
/* If the last character of path string is PATH_SEPARATOR, don't append PATH_SEPARATOR */
#define FILEIO_PATH_SEPARATOR(path) \
(path[strlen(path) - 1] == PATH_SEPARATOR ? "" : STR_PATH_SEPARATOR)
/* Definitions of some log archive and backup names */
#define FILEIO_SUFFIX_LOGACTIVE "_lgat"
#define FILEIO_SUFFIX_LOGARCHIVE "_lgar"
#define FILEIO_SUFFIX_TMP_LOGARCHIVE "_lgar_t"
#define FILEIO_SUFFIX_LOGINFO "_lginf"
#define FILEIO_SUFFIX_BACKUP "_bk"
#define FILEIO_SUFFIX_BACKUP_VOLINFO "_bkvinf"
#define FILEIO_VOLEXT_PREFIX "_x"
#define FILEIO_VOLTMP_PREFIX "_t"
#define FILEIO_VOLINFO_SUFFIX "_vinf"
#define FILEIO_VOLLOCK_SUFFIX "__lock"
#define FILEIO_SUFFIX_DWB "_dwb"
#define FILEIO_SUFFIX_KEYS "_keys"
#define FILEIO_MAX_SUFFIX_LENGTH 7
typedef enum
{
FILEIO_BACKUP_FULL_LEVEL = 0, /* Full backup */
FILEIO_BACKUP_BIG_INCREMENT_LEVEL, /* Backup since last full backup */
FILEIO_BACKUP_SMALL_INCREMENT_LEVEL, /* Backup since last INCRBIG */
FILEIO_BACKUP_UNDEFINED_LEVEL /* Undefined (must be highest ordinal value) */
} FILEIO_BACKUP_LEVEL;
typedef enum
{
FILEIO_ZIP_NONE_METHOD, /* None */
FILEIO_ZIP_LZO1X_METHOD, /* LZO1X - Unsupported */
FILEIO_ZIP_ZLIB_METHOD, /* ZLIB */
FILEIO_ZIP_LZ4_METHOD, /* LZ4X */
FILEIO_ZIP_UNDEFINED_METHOD /* Undefined (must be highest ordinal value) */
} FILEIO_ZIP_METHOD;
typedef enum
{
FILEIO_ZIP_NONE_LEVEL, /* None */
FILEIO_ZIP_1_LEVEL,
FILEIO_ZIP_UNDEFINED_LEVEL, /* Undefined (must be highest ordinal value) */
FILEIO_ZIP_LZ4_DEFAULT_LEVEL = FILEIO_ZIP_1_LEVEL
} FILEIO_ZIP_LEVEL;
typedef enum
{
FILEIO_BACKUP_VOL_UNKNOWN,
FILEIO_BACKUP_VOL_DIRECTORY,
FILEIO_BACKUP_VOL_DEVICE
} FILEIO_BACKUP_VOL_TYPE;
typedef enum
{
FILEIO_PROMPT_UNKNOWN,
FILEIO_PROMPT_RANGE_TYPE,
FILEIO_PROMPT_BOOLEAN_TYPE,
FILEIO_PROMPT_STRING_TYPE,
FILEIO_PROMPT_RANGE_WITH_SECONDARY_STRING_TYPE,
FILEIO_PROMPT_DISPLAY_ONLY
} FILEIO_REMOTE_PROMPT_TYPE;
typedef enum
{
FILEIO_ERROR_INTERRUPT, /* error/interrupt */
FILEIO_READ, /* access device for read */
FILEIO_WRITE /* access device for write */
} FILEIO_TYPE;
typedef enum
{
FILEIO_BACKUP_WRITE, /* access backup device for write */
FILEIO_BACKUP_READ /* access backup device for read */
} FILEIO_BACKUP_TYPE;
typedef enum
{
FILEIO_LOCKF,
FILEIO_RUN_AWAY_LOCKF,
FILEIO_NOT_LOCKF
} FILEIO_LOCKF_TYPE;
typedef enum
{
FILEIO_WRITE_DEFAULT_WRITE, /* default write mode does compensate write including sync */
FILEIO_WRITE_NO_COMPENSATE_WRITE /* skips */
} FILEIO_WRITE_MODE;
/* Reserved area of FILEIO_PAGE */
typedef struct fileio_page_reserved FILEIO_PAGE_RESERVED;
struct fileio_page_reserved
{
LOG_LSA lsa; /* Log Sequence number of page, Page recovery stuff */
INT32 pageid; /* Page identifier */
INT16 volid; /* Volume identifier where the page reside */
unsigned char ptype; /* Page type */
unsigned char pflag;
INT32 p_reserve_1;
INT32 p_reserve_2; /* unused - Reserved field */
INT64 tde_nonce; /* tde nonce. atomic counter for temp pages, lsa for perm pages */
};
typedef struct fileio_page_watermark FILEIO_PAGE_WATERMARK;
struct fileio_page_watermark
{
LOG_LSA lsa; /* duplication of prv.lsa */
};
/* The FILEIO_PAGE */
typedef struct fileio_page FILEIO_PAGE;
struct fileio_page
{
FILEIO_PAGE_RESERVED prv; /* System page area. Reserved */
char page[1]; /* The user page area */
// You cannot directly access prv2 like page_ptr.prv2, since it does not point to the real location */
FILEIO_PAGE_WATERMARK prv2; /* system page area. It should be located at the end of page. */
};
STATIC_INLINE FILEIO_PAGE_WATERMARK *
fileio_get_page_watermark_pos (FILEIO_PAGE * io_page, PGLENGTH page_size)
{
return (FILEIO_PAGE_WATERMARK *) (((char *) io_page) + (page_size - sizeof (FILEIO_PAGE_WATERMARK)));
}
STATIC_INLINE void
fileio_init_lsa_of_page (FILEIO_PAGE * io_page, PGLENGTH page_size)
{
LSA_SET_NULL (&io_page->prv.lsa);
FILEIO_PAGE_WATERMARK *prv2 = fileio_get_page_watermark_pos (io_page, page_size);
LSA_SET_NULL (&prv2->lsa);
}
STATIC_INLINE void
fileio_reset_page_lsa (FILEIO_PAGE * io_page, PGLENGTH page_size)
{
LSA_SET_NULL (&io_page->prv.lsa);
FILEIO_PAGE_WATERMARK *prv2 = fileio_get_page_watermark_pos (io_page, page_size);
LSA_SET_NULL (&prv2->lsa);
}
STATIC_INLINE void
fileio_set_page_lsa (FILEIO_PAGE * io_page, const LOG_LSA * lsa, PGLENGTH page_size)
{
LSA_COPY (&io_page->prv.lsa, lsa);
FILEIO_PAGE_WATERMARK *prv2 = fileio_get_page_watermark_pos (io_page, page_size);
LSA_COPY (&prv2->lsa, lsa);
}
STATIC_INLINE int
fileio_is_page_sane (FILEIO_PAGE * io_page, PGLENGTH page_size)
{
FILEIO_PAGE_WATERMARK *prv2 = fileio_get_page_watermark_pos (io_page, page_size);
return (LSA_EQ (&io_page->prv.lsa, &prv2->lsa));
}
typedef struct fileio_backup_page FILEIO_BACKUP_PAGE;
struct fileio_backup_page
{
PAGEID iopageid; /* Identifier of page to buffer */
INT32 dummy; /* Dummy field for 8byte align */
FILEIO_PAGE iopage; /* The content of the page */
PAGEID iopageid_dup; /* Copy of pageid for redundant checking during restore. Note: that the offset of this
* field cannot be used, because the size of an iopage is not know until run-time.
* Take care when trying to access this value. */
};
/*
* During incremental restores, this structure helps keep track of
* which pages have already been restored, so we do not overwrite newer
* pages from an earlier backup.
*/
typedef struct page_bitmap FILEIO_RESTORE_PAGE_BITMAP;
struct page_bitmap
{
FILEIO_RESTORE_PAGE_BITMAP *next;
int vol_id;
int size;
unsigned char *bitmap;
};
typedef struct page_bitmap_list FILEIO_RESTORE_PAGE_BITMAP_LIST;
struct page_bitmap_list
{
FILEIO_RESTORE_PAGE_BITMAP *head;
FILEIO_RESTORE_PAGE_BITMAP *tail;
};
typedef struct fileio_backup_record_info FILEIO_BACKUP_RECORD_INFO;
struct fileio_backup_record_info
{
INT64 at_time;
LOG_LSA lsa;
};
/* Backup header */
typedef struct fileio_backup_header FILEIO_BACKUP_HEADER;
struct fileio_backup_header
{
PAGEID iopageid; /* Must be the same as start of an FILEIO_BACKUP_PAGE NOTE: a union would be better. */
char magic[CUBRID_MAGIC_MAX_LENGTH]; /* Magic value for file/magic Unix utility */
float db_compatibility; /* Compatibility of the database against the current release of CUBRID */
int bk_hdr_version; /* For future compatibility checking */
INT64 db_creation; /* Database creation time */
INT64 start_time; /* Time of backup start */
INT64 end_time; /* Time of backup end */
char db_release[REL_MAX_RELEASE_LENGTH]; /* CUBRID Release */
char db_fullname[PATH_MAX]; /* Fullname of backed up database. Really more than one byte */
PGLENGTH db_iopagesize; /* Size of database pages */
FILEIO_BACKUP_LEVEL level; /* Backup level: one of the following level 0: Full backup, every database page that
* has been allocated. level 1: All database pages that have changed since last level 0
* backup level 2: All database pages that have changed since last level 0 or 1. */
LOG_LSA start_lsa; /* A page with a LSA greater than this value is going to be backed up. */
LOG_LSA chkpt_lsa; /* LSA for next incremental backup */
/* remember lsa's for every backup level */
int unit_num; /* Part # of removable backup vol, count from 1 */
int bkup_iosize; /* Buffered io size when backup was taken */
FILEIO_BACKUP_RECORD_INFO previnfo[FILEIO_BACKUP_UNDEFINED_LEVEL];
/* Backward chain to preceding backup volume. */
char db_prec_bkvolname[PATH_MAX];
/* Forward chain to next backup volume. Note not implemented yet. */
char db_next_bkvolname[PATH_MAX];
int bkpagesize; /* size of backup page */
FILEIO_ZIP_METHOD zip_method; /* compression method */
FILEIO_ZIP_LEVEL zip_level; /* compression level */
int skip_activelog;
};
/* Shouldn't this structure should use int and such? */
typedef struct fileio_backup_buffer FILEIO_BACKUP_BUFFER;
struct fileio_backup_buffer
{
char loc_db_fullname[PATH_MAX]; /* Fullname specified in the database-loc-file */
char log_path[PATH_MAX]; /* for restore */
LOG_LSA last_chkpt_lsa; /* The chkpt_lsa of the highest level backup volume in the restore session. */
int vdes; /* Open descriptor of backup device */
const char *vlabel; /* Pointer to current backup device name */
char name[PATH_MAX]; /* Name of the current backup volume: either a file, or a raw device. */
/* Original source location to backup (restore) volumes. Can be a directory or raw device. Used for mult. volumes. */
char current_path[PATH_MAX];
int dtype; /* Set to the type (dir, file, dev) */
INT64 iosize; /* Optimal I/O pagesize for backup device */
INT64 count; /* Number of current buffered bytes */
INT64 voltotalio; /* Total number of bytes that have been either read or written (current volume) */
INT64 alltotalio; /* total for all volumes */
char *buffer; /* Pointer to the buffer */
char *ptr; /* Pointer to the first buffered byte when reading and pointer to the next byte to
* buffer when writing */
FILEIO_BACKUP_HEADER *bkuphdr; /* pointer to header information */
};
typedef struct fileio_backup_db_buffer FILEIO_BACKUP_DB_BUFFER;
struct fileio_backup_db_buffer
{
FILEIO_BACKUP_LEVEL level; /* Backup level: one of the following level 0: Full backup, every database page that
* has been allocated. level 1: All database pages that have changed since last level 0
* backup level 2: All database pages that have changed since last level 0 or 1. */
LOG_LSA lsa; /* A page with a LSA greater than this value is going to be backed up. */
int vdes; /* Open file descriptor of device name for writing purposes */
VOLID volid; /* Identifier of volume to backup/restore */
INT64 nbytes; /* Number of bytes of file */
const char *vlabel; /* Pointer to file name to backup */
#if (__WORDSIZE == 32)
int dummy; /* Dummy field for 8byte align */
#endif
FILEIO_BACKUP_PAGE *area; /* Area to read/write the page */
};
typedef struct file_zip_page FILEIO_ZIP_PAGE;
struct file_zip_page
{
int buf_len; /* compressed block size */
char buf[1]; /* data block */
};
typedef struct file_zip_info FILEIO_ZIP_INFO;
struct file_zip_info
{
int buf_size; /* allocated block size */
FILEIO_ZIP_PAGE zip_page; /* zip page */
};
typedef struct fileio_node FILEIO_NODE;
struct fileio_node
{
struct fileio_node *prev;
struct fileio_node *next;
int pageid;
bool writeable;
ssize_t nread;
FILEIO_BACKUP_PAGE *area; /* Area to read/write the page */
FILEIO_ZIP_INFO *zip_info; /* Zip info containing area to compress/decompress the page */
};
typedef struct fileio_queue FILEIO_QUEUE;
struct fileio_queue
{
int size;
FILEIO_NODE *head;
FILEIO_NODE *tail;
FILEIO_NODE *free_list;
};
typedef struct fileio_thread_info FILEIO_THREAD_INFO;
struct fileio_thread_info
{
#if defined(SERVER_MODE)
pthread_mutex_t mtx;
pthread_cond_t rcv; /* condition variable of read_thread */
pthread_cond_t wcv; /* condition variable of write_thread */
#endif /* SERVER_MODE */
int tran_index;
int num_threads; /* number of read threads plus one write thread */
int act_r_threads; /* number of activated read threads */
int end_r_threads; /* number of ended read threads */
int pageid;
int from_npages;
FILEIO_TYPE io_type;
int errid;
bool only_updated_pages;
bool initialized;
int check_ratio;
int check_npages;
FILEIO_QUEUE io_queue;
};
typedef struct io_backup_session FILEIO_BACKUP_SESSION;
struct io_backup_session
{
FILEIO_BACKUP_TYPE type;
FILEIO_BACKUP_BUFFER bkup; /* Buffering area for backup device */
FILEIO_BACKUP_DB_BUFFER dbfile; /* Buffer area for database files */
FILEIO_THREAD_INFO read_thread_info; /* read-threads info */
FILE *verbose_fp; /* Backupdb/Restoredb status msg */
int sleep_msecs; /* sleep internval in msecs */
};
typedef struct token_bucket TOKEN_BUCKET;
struct token_bucket
{
pthread_mutex_t token_mutex;
int tokens; /* shared tokens between all lines */
int token_consumed; /* TODO: Remove me? This seems to server no true purpose. */
pthread_cond_t waiter_cond;
};
typedef struct flush_stats FLUSH_STATS;
struct flush_stats
{
unsigned int num_log_pages;
unsigned int num_pages;
unsigned int num_tokens;
};
// *INDENT-OFF*
using FILEIO_UNLINKED_VOLINFO_MAP = std::map <int, std::pair<std::string, std::string>>;
// *INDENT-ON*
extern int fileio_open (const char *vlabel, int flags, int mode);
extern void fileio_close (int vdes);
extern int fileio_format (THREAD_ENTRY * thread_p, const char *db_fullname, const char *vlabel, VOLID volid,
DKNPAGES npages, bool sweep_clean, bool dolock, bool dosync, size_t page_size,
int kbytes_to_be_written_per_sec, bool reuse_file);
#if !defined (CS_MODE)
extern int fileio_expand_to (THREAD_ENTRY * threda_p, VOLID volid, DKNPAGES npages_toadd, DB_VOLTYPE voltype);
#endif /* not CS_MODE */
extern void *fileio_initialize_pages (THREAD_ENTRY * thread_p, int vdes, FILEIO_PAGE * io_pgptr, DKNPAGES start_pageid,
DKNPAGES npages, size_t page_size, bool ensure_metadata,
int kbytes_to_be_written_per_sec);
extern void fileio_initialize_res (THREAD_ENTRY * thread_p, FILEIO_PAGE * io_page, PGLENGTH page_size);
#if defined (ENABLE_UNUSED_FUNCTION)
extern DKNPAGES fileio_truncate (VOLID volid, DKNPAGES npages_to_resize);
#endif
extern void fileio_unformat (THREAD_ENTRY * thread_p, const char *vlabel);
extern void fileio_unformat_and_rename (THREAD_ENTRY * thread_p, const char *vlabel, const char *new_vlabel);
extern int fileio_copy_volume (THREAD_ENTRY * thread_p, int from_vdes, DKNPAGES npages, const char *to_vlabel,
VOLID to_volid, bool reset_recvinfo);
extern int fileio_reset_volume (THREAD_ENTRY * thread_p, int vdes, const char *vlabel, DKNPAGES npages,
const LOG_LSA * reset_lsa);
extern int fileio_mount (THREAD_ENTRY * thread_p, const char *db_fullname, const char *vlabel, VOLID volid,
int lockwait, bool dosync);
extern void fileio_dismount (THREAD_ENTRY * thread_p, int vdes);
extern void fileio_dismount_without_fsync (THREAD_ENTRY * thread_p, int vdes);
extern void fileio_dismount_all (THREAD_ENTRY * thread_p);
extern void *fileio_read (THREAD_ENTRY * thread_p, int vol_fd, void *io_page_p, PAGEID page_id, size_t page_size);
extern void *fileio_write_or_add_to_dwb (THREAD_ENTRY * thread_p, int vol_fd, FILEIO_PAGE * io_page_p, PAGEID page_id,
size_t page_size, bool ensure_metadata);
extern void *fileio_write (THREAD_ENTRY * thread_p, int vol_fd, void *io_page_p, PAGEID page_id, size_t page_size,
FILEIO_WRITE_MODE write_mode);
extern void *fileio_read_pages (THREAD_ENTRY * thread_p, int vol_fd, char *io_pages_p, PAGEID page_id, int num_pages,
size_t page_size);
extern void *fileio_write_pages (THREAD_ENTRY * thread_p, int vol_fd, char *io_pages_p, PAGEID page_id, int num_pages,
size_t page_size, FILEIO_WRITE_MODE write_mode);
extern void *fileio_writev (THREAD_ENTRY * thread_p, int vdes, void **arrayof_io_pgptr, PAGEID start_pageid,
DKNPAGES npages, size_t page_size);
extern bool fileio_fsync_pending (void);
extern int fileio_synchronize_directory (THREAD_ENTRY * thread_p, const char *label);
extern int fileio_synchronize (THREAD_ENTRY * thread_p, int vdes, const char *vlabel, bool ensure_metadata);
extern int fileio_synchronize_all (THREAD_ENTRY * thread_p);
#if defined (ENABLE_UNUSED_FUNCTION)
extern void *fileio_read_user_area (THREAD_ENTRY * thread_p, int vdes, PAGEID pageid, off_t start_offset, size_t nbytes,
void *area);
extern void *fileio_write_user_area (THREAD_ENTRY * thread_p, int vdes, PAGEID pageid, off_t start_offset, int nbytes,
void *area);
#endif
extern bool fileio_is_volume_exist_and_file (const char *vlabel);
extern DKNPAGES fileio_get_number_of_volume_pages (int vdes, size_t page_size);
extern char *fileio_get_volume_label (VOLID volid, bool is_peek);
extern char *fileio_get_volume_label_by_fd (int vol_fd, bool is_peek);
extern VOLID fileio_find_volume_id_with_label (THREAD_ENTRY * thread_p, const char *vlabel);
extern bool fileio_is_temp_volume (THREAD_ENTRY * thread_p, VOLID volid);
extern bool fileio_is_permanent_volume_descriptor (THREAD_ENTRY * thread_p, int vol_fd);
extern VOLID fileio_find_next_perm_volume (THREAD_ENTRY * thread_p, VOLID volid);
extern VOLID fileio_find_previous_perm_volume (THREAD_ENTRY * thread_p, VOLID volid);
extern VOLID fileio_find_previous_temp_volume (THREAD_ENTRY * thread_p, VOLID volid);
extern int fileio_get_volume_descriptor (VOLID volid);
extern bool fileio_map_mounted (THREAD_ENTRY * thread_p, bool (*fun) (THREAD_ENTRY * thread_p, VOLID volid, void *args),
void *args);
extern int fileio_get_number_of_partition_free_pages (const char *path, size_t page_size); /* remove me */
extern DKNSECTS fileio_get_number_of_partition_free_sectors (const char *path_p);
extern const char *fileio_rename (VOLID volid, const char *old_vlabel, const char *new_vlabel);
extern bool fileio_is_volume_exist (const char *vlabel);
extern int fileio_find_volume_descriptor_with_label (const char *vol_label_p);
extern int fileio_get_max_name (const char *path, long int *filename_max, long int *pathname_max);
extern const char *fileio_get_base_file_name (const char *fullname);
extern char *fileio_get_directory_path (char *path, const char *fullname);
extern int fileio_get_volume_max_suffix (void);
extern void fileio_make_volume_info_name (char *volinfo_name, const char *db_fullname);
extern void fileio_make_volume_ext_name (char *volext_fullname, const char *ext_path, const char *ext_name,
VOLID volid);
extern void fileio_make_volume_ext_given_name (char *volext_fullname, const char *ext_path, const char *ext_name);
extern void fileio_make_volume_temp_name (char *voltmp_fullname, const char *tmp_path, const char *tmp_name,
VOLID volid);
extern void fileio_make_log_active_name (char *logactive_name, const char *log_path, const char *dbname);
extern void fileio_make_temp_log_files_from_backup (char *temp_log_name, VOLID volid, FILEIO_BACKUP_LEVEL level,
const char *base_log_name);
extern void fileio_make_log_archive_name (char *logarchive_name, const char *log_path, const char *dbname, int arvnum);
extern void fileio_make_removed_log_archive_name (char *logarchive_name, const char *log_path, const char *dbname);
extern void fileio_make_log_archive_temp_name (char *log_archive_temp_name_p, const char *log_path_p,
const char *db_name_p);
extern void fileio_make_log_info_name (char *loginfo_name, const char *log_path, const char *dbname);
extern void fileio_make_backup_volume_info_name (char *backup_volinfo_name, const char *backinfo_path,
const char *dbname);
extern void fileio_make_backup_name (char *backup_name, const char *nopath_volname, const char *backup_path,
FILEIO_BACKUP_LEVEL level, int unit_num);
extern void fileio_make_dwb_name (char *dwb_name_p, const char *dwb_path_p, const char *db_name_p);
extern void fileio_make_keys_name (char *keys_name_p, const char *db_name_p);
extern void fileio_make_keys_name_given_path (char *keys_name_p, const char *keys_path_p, const char *db_name_p);
#ifdef UNSTABLE_TDE_FOR_REPLICATION_LOG
extern void fileio_make_ha_sock_name (char *sock_path_p, const char *base_path_p, const char *sock_name_p);
#endif /* UNSTABLE_TDE_FOR_REPLICATION_LOG */
extern void fileio_remove_all_backup (THREAD_ENTRY * thread_p, int level);
extern FILEIO_BACKUP_SESSION *fileio_initialize_backup (const char *db_fullname, const char *backup_destination,
FILEIO_BACKUP_SESSION * session, FILEIO_BACKUP_LEVEL level,
const char *verbose_file_path, int num_threads,
int sleep_msecs);
extern FILEIO_BACKUP_SESSION *fileio_start_backup (THREAD_ENTRY * thread_p, const char *db_fullname,
INT64 * db_creation, FILEIO_BACKUP_LEVEL backup_level,
LOG_LSA * backup_start_lsa, LOG_LSA * backup_ckpt_lsa,
FILEIO_BACKUP_RECORD_INFO * all_levels_info,
FILEIO_BACKUP_SESSION * session, FILEIO_ZIP_METHOD zip_method,
FILEIO_ZIP_LEVEL zip_level);
extern FILEIO_BACKUP_SESSION *fileio_finish_backup (THREAD_ENTRY * thread_p, FILEIO_BACKUP_SESSION * session);
extern void fileio_abort_backup (THREAD_ENTRY * thread_p, FILEIO_BACKUP_SESSION * session, bool does_unformat_bk);
extern int fileio_backup_volume (THREAD_ENTRY * thread_p, FILEIO_BACKUP_SESSION * session, const char *from_vlabel,
VOLID from_volid, PAGEID last_page, bool only_updated_pages);
extern FILEIO_BACKUP_SESSION *fileio_start_restore (THREAD_ENTRY * thread_p, const char *db_fullname,
char *backup_source, INT64 match_dbcreation,
PGLENGTH * db_iopagesize, float *db_compatibility,
FILEIO_BACKUP_SESSION * session, FILEIO_BACKUP_LEVEL level,
bool authenticate, INT64 match_bkupcreation,
const char *restore_verbose_file_path, bool newvolpath);
extern int fileio_finish_restore (THREAD_ENTRY * thread_p, FILEIO_BACKUP_SESSION * session);
extern void fileio_abort_restore (THREAD_ENTRY * thread_p, FILEIO_BACKUP_SESSION * session);
extern int fileio_list_restore (THREAD_ENTRY * thread_p, const char *db_fullname, char *backup_source,
FILEIO_BACKUP_LEVEL level, bool newvolpath);
extern int fileio_get_backup_volume (THREAD_ENTRY * thread_p, const char *db_fullname, const char *logpath,
const char *user_backuppath, int try_level, char *from_volbackup);
extern int fileio_get_next_restore_file (THREAD_ENTRY * thread_p, FILEIO_BACKUP_SESSION * session, char *filename,
VOLID * volid);
extern int fileio_restore_volume (THREAD_ENTRY * thread_p, FILEIO_BACKUP_SESSION * session, char *to_vlabel,
char *verbose_to_vlabel, char *prev_vlabel, FILEIO_RESTORE_PAGE_BITMAP * page_bitmap,
bool remember_pages, bool & is_prev_vheader_restored,
FILEIO_UNLINKED_VOLINFO_MAP & unlinked_vol_info);
extern int fileio_skip_restore_volume (THREAD_ENTRY * thread_p, FILEIO_BACKUP_SESSION * session);
extern const char *fileio_get_zip_method_string (FILEIO_ZIP_METHOD zip_method);
extern const char *fileio_get_zip_level_string (FILEIO_ZIP_LEVEL zip_level);
extern int fileio_read_backup_info_entries (FILE * fp, int which_bkvinf);
extern int fileio_write_backup_info_entries (FILE * fp, int which_bkvinf);
extern const char *fileio_get_backup_info_volume_name (FILEIO_BACKUP_LEVEL level, int unit_num, int which_bkvinf);
extern int fileio_add_volume_to_backup_info (const char *name, FILEIO_BACKUP_LEVEL level, int unit_num,
int which_bkvinf);
extern int fileio_clear_backup_info_level (int level, bool dealloc, int which_bkvinf);
extern void fileio_finalize_backup_info (int which_bkvinf);
extern int fileio_request_user_response (THREAD_ENTRY * thread_p, FILEIO_REMOTE_PROMPT_TYPE prompt_id,
const char *prompt, char *response, const char *failure_prompt, int range_low,
int range_high, const char *secondary_prompt, int reprompt_value);
#if !defined(WINDOWS)
extern FILEIO_LOCKF_TYPE fileio_lock_la_log_path (const char *db_fullname, const char *lock_path, int vdes,
int *last_deleted_arv_num);
extern FILEIO_LOCKF_TYPE fileio_lock_la_dbname (int *lockf_vdes, char *db_name, char *log_path);
extern FILEIO_LOCKF_TYPE fileio_unlock_la_dbname (int *lockf_vdes, char *db_name, bool clear_owner);
extern int fileio_symlink (const char *src, const char *dest, int overwrite);
extern int fileio_set_permission (const char *vlabel);
#endif /* !WINDOWS */
#if defined(ENABLE_UNUSED_FUNCTION)
#if defined(SERVER_MODE)
int fileio_os_sysconf (void);
#endif /* SERVER_MODE */
#endif
/* flush control related */
extern int fileio_flush_control_initialize (void);
extern void fileio_flush_control_finalize (void);
/* flush token management */
extern int fileio_flush_control_add_tokens (THREAD_ENTRY * thread_p, INT64 diff_usec, int *token_gen,
int *token_consumed);
extern void fileio_page_bitmap_list_init (FILEIO_RESTORE_PAGE_BITMAP_LIST * page_bitmap_list);
extern FILEIO_RESTORE_PAGE_BITMAP *fileio_page_bitmap_create (int vol_id, int total_pages);
extern FILEIO_RESTORE_PAGE_BITMAP *fileio_page_bitmap_list_find (FILEIO_RESTORE_PAGE_BITMAP_LIST * page_bitmap_list,
int vol_id);
extern void fileio_page_bitmap_list_add (FILEIO_RESTORE_PAGE_BITMAP_LIST * page_bitmap_list,
FILEIO_RESTORE_PAGE_BITMAP * page_bitmap);
extern void fileio_page_bitmap_list_destroy (FILEIO_RESTORE_PAGE_BITMAP_LIST * page_bitmap_list);
extern int fileio_set_page_checksum (THREAD_ENTRY * thread_p, FILEIO_PAGE * io_page);
extern int fileio_page_check_corruption (THREAD_ENTRY * thread_p, FILEIO_PAGE * io_page, bool * is_page_corrupted);
extern void fileio_page_hexa_dump (const char *data, int length);
extern bool fileio_is_formatted_page (THREAD_ENTRY * thread_p, const char *io_page);
/* lob_dir */
extern int fileio_lob_remove_dir (char *lob_path);
extern int fileio_lob_remove_matching_dir (const char *keyword);
#endif /* _FILE_IO_H_ */