/*
* logwr_flush_header_page -
*
* return:
* Note:
*/
void
logwr_flush_header_page (void)
{
PAGEID phy_pageid;
PAGEID logical_pageid;
int nbytes;
if (logwr_Gl.loghdr_pgptr == NULL)
{
return;
}
/* flush current archiving status */
logwr_Gl.hdr.nxarv_num = logwr_Gl.last_arv_num;
logwr_Gl.hdr.last_deleted_arv_num = logwr_Gl.last_deleted_arv_num;
logwr_Gl.hdr.nxarv_pageid = logwr_Gl.last_arv_fpageid;
logwr_Gl.hdr.nxarv_phy_pageid
= logwr_to_physical_pageid (logwr_Gl.last_arv_fpageid);
memcpy (logwr_Gl.loghdr_pgptr->area, &logwr_Gl.hdr, sizeof (logwr_Gl.hdr));
logical_pageid = LOGPB_HEADER_PAGE_ID;
phy_pageid = logwr_to_physical_pageid (logical_pageid);
/* logwr_Gl.append_vdes is only changed
* while starting or finishing or recovering server.
* So, log cs is not needed.
*/
if (fileio_write (NULL, logwr_Gl.append_vdes, logwr_Gl.loghdr_pgptr,
phy_pageid, LOG_PAGESIZE) == NULL
|| (logwr_Gl.mode != LOGWR_MODE_ASYNC
&& fileio_synchronize (NULL, logwr_Gl.append_vdes,
logwr_Gl.active_name)) == NULL_VOLDES)
{
if (er_errid () == ER_IO_WRITE_OUT_OF_SPACE)
{
nbytes = ((logwr_Gl.hdr.npages + 1 - logical_pageid) *
logwr_Gl.hdr.db_logpagesize);
er_set (ER_FATAL_ERROR_SEVERITY, ARG_FILE_LINE,
ER_LOG_WRITE_OUT_OF_SPACE, 4, logical_pageid, phy_pageid,
logwr_Gl.active_name, nbytes);
}
else
{
er_set_with_oserror (ER_FATAL_ERROR_SEVERITY, ARG_FILE_LINE,
ER_LOG_WRITE, 3, logical_pageid, phy_pageid,
logwr_Gl.active_name);
}
}
/* save last checkpoint pageid */
logwr_Gl.last_chkpt_pageid = logwr_Gl.hdr.chkpt_lsa.pageid;
er_log_debug (ARG_FILE_LINE,
"logwr_flush_header_page, ha_server_state=%s, ha_file_status=%s\n",
css_ha_server_state_string (logwr_Gl.hdr.ha_server_state),
logwr_Gl.hdr.ha_file_status ==
LOG_HA_FILESTAT_SYNCHRONIZED ? "sync" : "unsync");
}
int fsdevice_write(struct vdrive_s *vdrive, BYTE data, unsigned int secondary)
{
bufinfo_t *bufinfo;
bufinfo = fsdevice_dev[vdrive->unit - 8].bufinfo;
if (secondary == 15)
return fsdevice_flush_write_byte(vdrive, data);
if (bufinfo[secondary].mode != Write
&& bufinfo[secondary].mode != Append)
return SERIAL_ERROR;
if (bufinfo[secondary].fileio_info != NULL) {
unsigned int len;
len = fileio_write(bufinfo[secondary].fileio_info, &data, 1);
if (len == 0)
return SERIAL_ERROR;
return SERIAL_OK;
}
return SERIAL_ERROR;
}
int fileio_write_u32(struct fileio *fileio_p, uint32_t data)
{
uint8_t buf[4];
h_u32_to_be(buf, data);
size_t size_written;
int retval = fileio_write(fileio_p, 4, buf, &size_written);
if (ERROR_OK == retval && size_written != sizeof(uint32_t))
retval = -EIO;
return retval;
}
/*
* logwr_archive_active_log -
*
* return:
* Note:
*/
static int
logwr_archive_active_log (void)
{
char archive_name[PATH_MAX] = { '\0' }, archive_name_first[PATH_MAX];
LOG_PAGE *arvhdr_pgptr = NULL;
struct log_arv_header *arvhdr;
char log_pgbuf[IO_MAX_PAGE_SIZE * LOGPB_IO_NPAGES + MAX_ALIGNMENT];
char *aligned_log_pgbuf;
LOG_PAGE *log_pgptr = NULL;
LOG_PAGE *malloc_arv_hdr_pgptr = NULL;
PAGEID pageid, ar_phy_pageid = NULL_PAGEID, phy_pageid = NULL_PAGEID;
int vdes = NULL_VOLDES;
int i, first_arv_num_to_delete, last_arv_num_to_delete;
int error_code;
int num_pages = 0;
const char *info_reason, *catmsg;
BACKGROUND_ARCHIVING_INFO *bg_arv_info;
aligned_log_pgbuf = PTR_ALIGN (log_pgbuf, MAX_ALIGNMENT);
if ((logwr_Gl.last_arv_num - logwr_Gl.last_deleted_arv_num)
> PRM_LOG_MAX_ARCHIVES)
{
er_set (ER_WARNING_SEVERITY, ARG_FILE_LINE,
ER_LOG_MAX_ARCHIVES_HAS_BEEN_EXCEEDED, 1, PRM_LOG_MAX_ARCHIVES);
/* Remove the log archives at this point */
first_arv_num_to_delete = logwr_Gl.last_deleted_arv_num + 1;
last_arv_num_to_delete = logwr_Gl.last_arv_num - PRM_LOG_MAX_ARCHIVES;
last_arv_num_to_delete--;
for (i = first_arv_num_to_delete; i <= last_arv_num_to_delete; i++)
{
fileio_make_log_archive_name (archive_name, logwr_Gl.log_path,
logwr_Gl.db_name, i);
fileio_unformat (NULL, archive_name);
logwr_Gl.last_deleted_arv_num = last_arv_num_to_delete;
}
info_reason = msgcat_message (MSGCAT_CATALOG_CUBRID,
MSGCAT_SET_LOG,
MSGCAT_LOG_MAX_ARCHIVES_HAS_BEEN_EXCEEDED);
if (info_reason == NULL)
{
info_reason = "Number of active log archives has been exceeded"
" the max desired number.";
}
catmsg = msgcat_message (MSGCAT_CATALOG_CUBRID,
MSGCAT_SET_LOG,
MSGCAT_LOG_LOGINFO_REMOVE_REASON);
if (catmsg == NULL)
{
catmsg = "REMOVE: %d %s to \n%d %s.\nREASON: %s\n";
}
if (first_arv_num_to_delete == last_arv_num_to_delete)
{
log_dump_log_info (logwr_Gl.loginf_path, false, catmsg,
first_arv_num_to_delete, archive_name,
last_arv_num_to_delete, archive_name,
info_reason);
}
else
{
fileio_make_log_archive_name (archive_name_first, logwr_Gl.log_path,
logwr_Gl.db_name,
first_arv_num_to_delete);
log_dump_log_info (logwr_Gl.loginf_path, false, catmsg,
first_arv_num_to_delete, archive_name_first,
last_arv_num_to_delete, archive_name,
info_reason);
}
/* ignore error from log_dump_log_info() */
/* It will continue.... */
}
/* Create the archive header page */
malloc_arv_hdr_pgptr = (LOG_PAGE *) malloc (LOG_PAGESIZE);
if (malloc_arv_hdr_pgptr == NULL)
{
error_code = ER_OUT_OF_VIRTUAL_MEMORY;
er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_OUT_OF_VIRTUAL_MEMORY, 1,
LOG_PAGESIZE);
goto error;
}
malloc_arv_hdr_pgptr->hdr.logical_pageid = LOGPB_HEADER_PAGE_ID;
malloc_arv_hdr_pgptr->hdr.offset = NULL_OFFSET;
/* Construct the archive log header */
arvhdr = (struct log_arv_header *) malloc_arv_hdr_pgptr->area;
strncpy (arvhdr->magic, CUBRID_MAGIC_LOG_ARCHIVE, CUBRID_MAGIC_MAX_LENGTH);
arvhdr->db_creation = logwr_Gl.hdr.db_creation;
arvhdr->next_trid = NULL_TRANID;
arvhdr->fpageid = logwr_Gl.last_arv_fpageid;
arvhdr->arv_num = logwr_Gl.last_arv_num;
arvhdr->npages = logwr_Gl.last_arv_lpageid - arvhdr->fpageid + 1;
/*
* Now create the archive and start copying pages
*/
fileio_make_log_archive_name (archive_name, logwr_Gl.log_path,
logwr_Gl.db_name, arvhdr->arv_num);
bg_arv_info = &logwr_Gl.bg_archive_info;
if (PRM_LOG_BACKGROUND_ARCHIVING && bg_arv_info->vdes != NULL_VOLDES)
{
vdes = bg_arv_info->vdes;
}
else
{
if (fileio_is_volume_exist (archive_name) == true)
{
vdes = fileio_mount (NULL, archive_name, archive_name,
LOG_DBLOG_ARCHIVE_VOLID, true, false);
if (vdes == NULL_VOLDES)
{
error_code = ER_IO_MOUNT_FAIL;
goto error;
}
}
else
{
vdes = fileio_format (NULL, logwr_Gl.db_name, archive_name,
LOG_DBLOG_ARCHIVE_VOLID, arvhdr->npages + 1,
false, false, false, LOG_PAGESIZE);
if (vdes == NULL_VOLDES)
{
/* Unable to create archive log to archive */
error_code = ER_LOG_CREATE_LOGARCHIVE_FAIL;
er_set (ER_FATAL_ERROR_SEVERITY, ARG_FILE_LINE,
ER_LOG_CREATE_LOGARCHIVE_FAIL, 3,
archive_name, arvhdr->fpageid,
arvhdr->fpageid + arvhdr->npages - 1);
goto error;
}
}
}
if (fileio_write (NULL, vdes, malloc_arv_hdr_pgptr, 0, LOG_PAGESIZE) ==
NULL)
{
/* Error archiving header page into archive */
error_code = ER_LOG_WRITE;
er_set (ER_FATAL_ERROR_SEVERITY, ARG_FILE_LINE, ER_LOG_WRITE, 3,
0, 0, archive_name);
goto error;
}
if (PRM_LOG_BACKGROUND_ARCHIVING
&& bg_arv_info->vdes != NULL_VOLDES
&& logwr_Gl.last_arv_fpageid == bg_arv_info->start_page_id)
{
pageid = bg_arv_info->current_page_id;
ar_phy_pageid = (bg_arv_info->current_page_id
- bg_arv_info->start_page_id + 1);
}
else
{
pageid = logwr_Gl.last_arv_fpageid;
ar_phy_pageid = 1;
}
log_pgptr = (LOG_PAGE *) aligned_log_pgbuf;
/* Now start dumping the current active pages to archive */
for (; pageid <= logwr_Gl.last_arv_lpageid;
pageid += num_pages, ar_phy_pageid += num_pages)
{
/*
* Page is contained in the active log.
* Find the corresponding physical page and read the page form disk.
*/
num_pages = MIN (LOGPB_IO_NPAGES,
logwr_Gl.last_arv_lpageid - pageid + 1);
phy_pageid = logwr_to_physical_pageid (pageid);
num_pages = MIN (num_pages, logwr_Gl.hdr.npages - phy_pageid + 1);
if (fileio_read_pages (NULL, logwr_Gl.append_vdes, (char *) log_pgptr,
phy_pageid, num_pages, LOG_PAGESIZE) == NULL)
{
error_code = ER_LOG_READ;
er_set (ER_FATAL_ERROR_SEVERITY, ARG_FILE_LINE, ER_LOG_READ, 3,
pageid, phy_pageid, logwr_Gl.active_name);
goto error;
}
else
{
if (log_pgptr->hdr.logical_pageid != pageid)
{
/* Clean the buffer... since it may be corrupted */
error_code = ER_LOG_PAGE_CORRUPTED;
er_set (ER_FATAL_ERROR_SEVERITY, ARG_FILE_LINE,
ER_LOG_PAGE_CORRUPTED, 1, pageid);
goto error;
}
}
if (fileio_write_pages (NULL, vdes, (char *) log_pgptr,
ar_phy_pageid, num_pages, LOG_PAGESIZE) == NULL)
{
error_code = ER_LOG_WRITE;
er_set (ER_FATAL_ERROR_SEVERITY, ARG_FILE_LINE, ER_LOG_WRITE, 3,
pageid, ar_phy_pageid, archive_name);
goto error;
}
}
fileio_dismount (NULL, vdes);
vdes = NULL_VOLDES;
if (PRM_LOG_BACKGROUND_ARCHIVING && bg_arv_info->vdes != NULL_VOLDES)
{
bg_arv_info->vdes = NULL_VOLDES;
if (fileio_rename (NULL_VOLID, logwr_Gl.bg_archive_name, archive_name)
== NULL)
{
goto error;
}
bg_arv_info->vdes = fileio_format (NULL, logwr_Gl.db_name,
logwr_Gl.bg_archive_name,
LOG_DBLOG_BG_ARCHIVE_VOLID,
logwr_Gl.hdr.npages, false, false,
false, LOG_PAGESIZE);
if (bg_arv_info->vdes != NULL_VOLDES)
{
bg_arv_info->start_page_id = logwr_Gl.hdr.nxarv_pageid;
bg_arv_info->current_page_id = logwr_Gl.hdr.nxarv_pageid;
}
else
{
bg_arv_info->start_page_id = NULL_PAGEID;
bg_arv_info->current_page_id = NULL_PAGEID;
er_log_debug (ARG_FILE_LINE,
"Unable to create temporary archive log %s\n",
logwr_Gl.bg_archive_name);
}
}
/* Update archive info */
logwr_Gl.last_arv_num++;
logwr_Gl.last_arv_fpageid = logwr_Gl.last_arv_lpageid + 1;
/* Flush the log header to reflect the archive */
logwr_flush_header_page ();
er_set (ER_NOTIFICATION_SEVERITY, ARG_FILE_LINE, ER_LOG_ARCHIVE_CREATED, 3,
archive_name, arvhdr->fpageid,
arvhdr->fpageid + arvhdr->npages - 1);
catmsg = msgcat_message (MSGCAT_CATALOG_CUBRID,
MSGCAT_SET_LOG, MSGCAT_LOG_LOGINFO_ARCHIVE);
if (catmsg == NULL)
{
catmsg = "ARCHIVE: %d %s %d %d\n";
}
error_code = log_dump_log_info (logwr_Gl.loginf_path, false, catmsg,
arvhdr->arv_num, archive_name,
arvhdr->fpageid,
arvhdr->fpageid + arvhdr->npages - 1);
er_log_debug (ARG_FILE_LINE,
"logwr_archive_active_log, arv_num(%d), fpageid(%d) lpageid(%d)\n",
arvhdr->arv_num, arvhdr->fpageid,
arvhdr->fpageid + arvhdr->npages - 1);
free_and_init (malloc_arv_hdr_pgptr);
return NO_ERROR;
error:
if (malloc_arv_hdr_pgptr != NULL)
{
free_and_init (malloc_arv_hdr_pgptr);
}
if (vdes != NULL_VOLDES)
{
fileio_dismount (NULL, vdes);
fileio_unformat (NULL, archive_name);
}
return error_code;
}
