redo log write和flush

http://bbs.chinaunix.net/thread-1753130-1-1.html

在事务提交时innobase会调用ha_innodb.cc 中的innobase_commit，而innobase_commit通过调用trx_commit_complete_for_mysql（trx0trx.c)来调用log_write_up_to（log0log.c),也就是当innobase提交事务的时候就会调用log_write_up_to来写redo log
innobase_commit中

1. if (all              # 如果是事务提交
2.                 || (!thd_test_options(thd, OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN))) {

复制代码

通过下面的代码实现事务的commit串行化

1. if (innobase_commit_concurrency > 0) {
2.                         pthread_mutex_lock(&commit_cond_m);
3.                         commit_threads++;
5.                         if (commit_threads > innobase_commit_concurrency) {
6.                                 commit_threads--;
7.                                 pthread_cond_wait(&commit_cond,
8.                                         &commit_cond_m);
9.                                 pthread_mutex_unlock(&commit_cond_m);
10.                                 goto retry;
11.                         }
12.                         else {
13.                                 pthread_mutex_unlock(&commit_cond_m);
14.                         }
15.                 }

复制代码

1.                 trx->flush_log_later = TRUE;   # 在做提交操作时禁止flush binlog 到磁盘
2.                 innobase_commit_low(trx);
3.                 trx->flush_log_later = FALSE;

复制代码

先略过innobase_commit_low调用 ,下面开始调用trx_commit_complete_for_mysql做write日志操作

1. trx_commit_complete_for_mysql(trx);  #开始flush  log
2. trx->active_trans = 0;

复制代码

在trx_commit_complete_for_mysql中，主要做的是对系统参数srv_flush_log_at_trx_commit值做判断来调用
log_write_up_to，或者write redo log file或者write&&flush to disk

1. if (!trx->must_flush_log_later) {
2.                 /* Do nothing */
3.         } else if (srv_flush_log_at_trx_commit == 0) {  #flush_log_at_trx_commit=0，事务提交不写redo log
4.                 /* Do nothing */
5.         } else if (srv_flush_log_at_trx_commit == 1) { #flush_log_at_trx_commit=1,事务提交写log并flush磁盘,如果flush方式不是SRV_UNIX_NOSYNC （这个不是很熟悉）
6.                 if (srv_unix_file_flush_method == SRV_UNIX_NOSYNC) {
7.                         /* Write the log but do not flush it to disk */
9.                         log_write_up_to(lsn, LOG_WAIT_ONE_GROUP, FALSE);
10.                 } else {
11.                         /* Write the log to the log files AND flush them to
12.                         disk */
14.                         log_write_up_to(lsn, LOG_WAIT_ONE_GROUP, TRUE);
15.                 }
16.         } else if (srv_flush_log_at_trx_commit == 2) {   #如果是2，则只write到redo log
18.                 /* Write the log but do not flush it to disk */
20.                 log_write_up_to(lsn, LOG_WAIT_ONE_GROUP, FALSE);
21.         } else {
22.                 ut_error;
23.         }

复制代码

那么下面看log_write_up_to

1. if (flush_to_disk              #如果flush到磁盘，则比较当前commit的lsn是否大于已经flush到磁盘的lsn
2.             && ut_dulint_cmp(log_sys->flushed_to_disk_lsn, lsn) >= 0) {
4.                 mutex_exit(&(log_sys->mutex));
6.                 return;
7.         }
9. if (!flush_to_disk       #如果不flush磁盘则比较当前commit的lsn是否大于已经写到所有redo log file的lsn,或者在只等一个group完成条件下是否大于已经写到某个redo file的lsn
10.             && (ut_dulint_cmp(log_sys->written_to_all_lsn, lsn) >= 0
11.                 || (ut_dulint_cmp(log_sys->written_to_some_lsn, lsn)
12.                     >= 0
13.                     && wait != LOG_WAIT_ALL_GROUPS))) {
15.                 mutex_exit(&(log_sys->mutex));
17.                 return;
18.         }
19. #下面的代码判断是否log在write,有的话等待其完成
20. if (log_sys->n_pending_writes > 0) {
21.           if (flush_to_disk    # 如果需要刷新到磁盘，如果正在flush的lsn包括了commit的lsn，只要等待操作完成就可以了
22.                     && ut_dulint_cmp(log_sys->current_flush_lsn, lsn)
23.                     >= 0) {
24.                       goto do_waits;
25.                 }
27.                 if (!flush_to_disk  # 如果是刷到redo log file的那么如果在write的lsn包括了commit的lsn,也只要等待就可以了
28.                     && ut_dulint_cmp(log_sys->write_lsn, lsn) >= 0) {
29.                       goto do_waits;
30.                 }
31.       ......
32.                 if (!flush_to_disk  # 如果在当前IO空闲情况下 ，而且不需要flush到磁盘，那么 如果下次写的位置已经到达buf_free位置说明wirte操作都已经完成了，直接返回
33.                          && log_sys->buf_free == log_sys->buf_next_to_write) {
34.                              mutex_exit(&(log_sys->mutex));
35.                          return;
36.                }

复制代码

下面取到group,设置相关write or flush相关字段，并且得到起始和结束位置的block号

1. log_sys->n_pending_writes++;
3.         group = UT_LIST_GET_FIRST(log_sys->log_groups);
4.         group->n_pending_writes++;      /* We assume here that we have only
5.                                         one log group! */
7.         os_event_reset(log_sys->no_flush_event);
8.         os_event_reset(log_sys->one_flushed_event);
10.         start_offset = log_sys->buf_next_to_write;
11.         end_offset = log_sys->buf_free;
13.         area_start = ut_calc_align_down(start_offset, OS_FILE_LOG_BLOCK_SIZE);
14.         area_end = ut_calc_align(end_offset, OS_FILE_LOG_BLOCK_SIZE);
16.         ut_ad(area_end - area_start > 0);
18.         log_sys->write_lsn = log_sys->lsn;
20.         if (flush_to_disk) {
21.                 log_sys->current_flush_lsn = log_sys->lsn;
22.         }

复制代码

log_block_set_checkpoint_no调用设置end_offset所在block的LOG_BLOCK_CHECKPOINT_NO为log_sys中下个检查点号

1.         log_block_set_flush_bit(log_sys->buf + area_start, TRUE);   # 这个没看明白
2.         log_block_set_checkpoint_no(
3.                 log_sys->buf + area_end - OS_FILE_LOG_BLOCK_SIZE,
4.                 log_sys->next_checkpoint_no);

复制代码

保存不属于end_offset但在其所在的block中的数据到下一个空闲的block

1. ut_memcpy(log_sys->buf + area_end,
2.                   log_sys->buf + area_end - OS_FILE_LOG_BLOCK_SIZE,
3.                   OS_FILE_LOG_BLOCK_SIZE);

复制代码

对于每个group调用log_group_write_buf写redo log buffer

1. while (group) {
2.                 log_group_write_buf(
3.                         group, log_sys->buf + area_start,
4.                         area_end - area_start,
5.                         ut_dulint_align_down(log_sys->written_to_all_lsn,
6.                                              OS_FILE_LOG_BLOCK_SIZE),
7.                         start_offset - area_start);
9.                 log_group_set_fields(group, log_sys->write_lsn);   # 计算这次写的lsn和offset来设置group->lsn和group->lsn_offset
11.                 group = UT_LIST_GET_NEXT(log_groups, group);
12.         }
13. ......
14. if (srv_unix_file_flush_method == SRV_UNIX_O_DSYNC) {  # 这个是什么东西
15.                 /* O_DSYNC means the OS did not buffer the log file at all:
16.                 so we have also flushed to disk what we have written */
18.                 log_sys->flushed_to_disk_lsn = log_sys->write_lsn;
20.         } else if (flush_to_disk) {
22.                 group = UT_LIST_GET_FIRST(log_sys->log_groups);
24.                 fil_flush(group->space_id);         # 最后调用fil_flush执行flush到磁盘
25.                 log_sys->flushed_to_disk_lsn = log_sys->write_lsn;
26.         }

复制代码

接下来看log_group_write_buf做了点什么

在log_group_calc_size_offset中,从group中取到上次记录的lsn位置（注意是log files组成的1个环状buffer),并计算这次的lsn相对于上次的差值

1. # 调用log_group_calc_size_offset计算group->lsn_offset除去多个LOG_FILE头部长度后的大小，比如lsn_offset落在第3个log file上，那么需要减掉3*LOG_FILE_HDR_SIZE的大小
2. gr_lsn_size_offset = (ib_longlong)
3.        log_group_calc_size_offset(group->lsn_offset, group);
4. group_size = (ib_longlong) log_group_get_capacity(group); # 计算group除去所有LOG_FILE_HDR_SIZE长度后的DATA部分大小
6. # 下面是典型的环状结构差值计算
7. if (ut_dulint_cmp(lsn, gr_lsn) >= 0) {
9.                 difference = (ib_longlong) ut_dulint_minus(lsn, gr_lsn);
10.         } else {
11.                 difference = (ib_longlong) ut_dulint_minus(gr_lsn, lsn);
13.                 difference = difference % group_size;
15.                 difference = group_size - difference;
16.         }
18.         offset = (gr_lsn_size_offset + difference) % group_size;
19. # 最后算上每个log file 头部大小，返回真实的offset
20.      return(log_group_calc_real_offset((ulint)offset, group));

复制代码

接着看

1. # 如果需要写的内容超过一个文件大小
2. if ((next_offset % group->file_size) + len > group->file_size) {
4.                 write_len = group->file_size                # 写到file末尾
5.                         - (next_offset % group->file_size);
6.         } else {
7.                 write_len = len;                              # 否者写len个block
8.         }
10. # 最后真正的内容就是写buffer了，如果跨越file的话另外需要写file log file head部分
12. if ((next_offset % group->file_size == LOG_FILE_HDR_SIZE)
13.             && write_header) {
14.                 /* We start to write a new log file instance in the group */
16.                 log_group_file_header_flush(group,
17.                                             next_offset / group->file_size,
18.                                             start_lsn);
19.                 srv_os_log_written+= OS_FILE_LOG_BLOCK_SIZE;
20.                 srv_log_writes++;
21.         }
23. # 调用fil_io来执行buffer写
24. if (log_do_write) {
25.                 log_sys->n_log_ios++;
27.                 srv_os_log_pending_writes++;
29.                 fil_io(OS_FILE_WRITE | OS_FILE_LOG, TRUE, group->space_id,
30.                        next_offset / UNIV_PAGE_SIZE,
31.                        next_offset % UNIV_PAGE_SIZE, write_len, buf, group);
33.                 srv_os_log_pending_writes--;
35.                 srv_os_log_written+= write_len;
36.                 srv_log_writes++;
37.         }

复制代码