FileStore::mkjournal()&&FileJournal::create()

Ceph Version : Kraken
Component：FileStore
mkjournal()函数是用来初始化OSD的事务日志，格式化事务日志的头，事务日志可以使用裸块设备（已分区）也可以是一个文件。
mkjournal函数实现：
1.读取OSD的fsid信息（从fsid文件中）
2.创建FileJournal类型实例。
3.检查事务日志是否已经存在，若存在读取事务日志头，检查是否跟OSD fsid相等。
4.若事务日志不存在或者fsid不相等，则初始化事务日志（添加事务日志头）。
mkjournal代码实现：

//初始化journal
int FileStore::mkjournal()
{
  // read fsid
  int ret;
  char fn[PATH_MAX];
  snprintf(fn, sizeof(fn), "%s/fsid", basedir.c_str());
  int fd = ::open(fn, O_RDONLY, 0644);
  if (fd < 0) {
  ¦ int err = errno;
  ¦ derr << __FUNC__ << ": open error: " << cpp_strerror(err) << dendl;
  ¦ return -err;
  }
  ret = read_fsid(fd, &fsid);
  if (ret < 0) {
  ¦ derr << __FUNC__ << ": read error: " << cpp_strerror(ret) << dendl;
  ¦ VOID_TEMP_FAILURE_RETRY(::close(fd));
  ¦ return ret;
  }
  VOID_TEMP_FAILURE_RETRY(::close(fd));

  ret = 0;
//创建FileJournal对象
  new_journal();
  if (journal) {
  ¦ ret = journal->check();
  ¦ if (ret < 0) {
  //创建初始化日志设备，或者构建日志文件
  ¦ ¦ ret = journal->create();
  ¦ ¦ if (ret)
        derr << __FUNC__ << ": error creating journal on " << journalpath
                << ": " << cpp_strerror(ret) << dendl;
  ¦ ¦ else
        dout(0) << __FUNC__ << ": created journal on " << journalpath << dendl;
  ¦ }
  ¦ delete journal;
  ¦ journal = 0;
  }
  return ret;
}           

初始事务日志

事务日志可以使用裸块分区也可以是一个文件，下面这段函数中主要是：如果是裸分区用于记录日志，则检查该分区大小是否满足，并格式化事务日志头，如果是一个文件用于记录日志，则构建该文件，检查大小是否满足，并格式化事务日志头。

//创建日志文件或初始日志设备，并初始化日志头                                             
int FileJournal::create()                                                        
{                                                                                
  void *buf = 0;                                                                 
  int64_t needed_space;                                                          
  int ret;                                                                       
  buffer::ptr bp;                                                                
  dout(2) << "create " << fn << " fsid " << fsid << dendl;                       
//检查日志块                                                                     
  ret = _open(true, true);                                                       
  if (ret)                                                                       
  ¦ goto done;                                                                   
   //构建空的日志头                                                                              
  // write empty header                                                          
  header = header_t();                                                           
  header.flags = header_t::FLAG_CRC;  // enable crcs on any new journal.         
  header.fsid = fsid;                                                            
  header.max_size = max_size;                                                    
  header.block_size = block_size;                                                
  if (cct->_conf->journal_block_align || directio)                               
  ¦ header.alignment = block_size;                                               
  else                                                                           
  ¦ header.alignment = 16;  // at least stay word aligned on 64bit machines...   

  header.start = get_top();  //设置日志头之后的第一个日志块位置                                                    
  header.start_seq = 0;                                                          

  print_header(header);                                                          

  // static zeroed buffer for alignment padding                                  
  delete [] zero_buf;                                                            
  zero_buf = new char[header.alignment];                                         
  memset(zero_buf, 0, header.alignment);                                         
  bp = prepare_header();   
//将日志头信息写入到日志的开始处。  
  if (TEMP_FAILURE_RETRY(::pwrite(fd, bp.c_str(), bp.length(), 0)) < 0) {        
  ¦ ret = -errno;                                                                
  ¦ derr << "FileJournal::create : create write header error "                   
  ¦ ¦ ¦ ¦<< cpp_strerror(ret) << dendl;                                          
  ¦ goto close_fd;                                                               
  }                                                                              

  // zero first little bit, too.                                                 
  ret = posix_memalign(&buf, block_size, block_size);                            
  if (ret) {                                                                     
  ¦ ret = -ret;                                                                  
  ¦ derr << "FileJournal::create: failed to allocate " << block_size             
        ¦<< " bytes of memory: " << cpp_strerror(ret) << dendl;                  
  ¦ goto close_fd;                                                               
  }                                                                              
  memset(buf, 0, block_size); 
//将头之后的第一个日志块，初始化为0.  
  if (TEMP_FAILURE_RETRY(::pwrite(fd, buf, block_size, get_top())) < 0) {        
  ¦ ret = -errno;                                                                
  ¦ derr << "FileJournal::create: error zeroing first " << block_size            
        ¦<< " bytes " << cpp_strerror(ret) << dendl;                             
  ¦ goto free_buf;                                                               
  }                                                                              
//判断当前日志的空间是否满足最小日志大小要求。                                                                                
  needed_space = ((int64_t)cct->_conf->osd_max_write_size) << 20;                
  needed_space += (2 * sizeof(entry_header_t)) + get_top();  
//注：这里的  header.max_size 不应该在减去 header.start（日志头所占用的空间大小），因为
//needed_space已经将其包含在内。
  if (header.max_size - header.start < needed_space) {                           
  ¦ derr << "FileJournal::create: OSD journal is not large enough to hold "      
        ¦<< "osd_max_write_size bytes!" << dendl;                                
  ¦ ret = -ENOSPC;                                                               
  ¦ goto free_buf;                                                               
  }                                                                              

  dout(2) << "create done" << dendl;                                             
  ret = 0;                                                                       

free_buf:                                                                        
  free(buf);                                                                     
  buf = 0;                                                                       
close_fd:                                                                        
  if (TEMP_FAILURE_RETRY(::close(fd)) < 0) {                                     
  ¦ ret = -errno;                                                                
  ¦ derr << "FileJournal::create: error closing fd: " << cpp_strerror(ret)       
        ¦<< dendl;                                                               
  }                                                                              
done:                                                                            
  fd = -1;                                                                       
  return ret;                                                                    
}

检查事务日志

检查日志头中记录的fsid与current/fsid的值是否相等

//检查日志头中记录的fsid与current/fsid的值是否相等。
// This can not be used on an active journal
int FileJournal::check()
{
  int ret;

  assert(fd == -1);
  //打开日志文件
  ret = _open(false, false);
  if (ret)
  ¦ return ret;
//读取日志头信息
  ret = read_header(&header);
  if (ret < 0)
  ¦ goto done;
//判断当前OSD的fsid与日志头中记录的fsid是否相等
  if (header.fsid != fsid) {
  ¦ derr << "check: ondisk fsid " << header.fsid << " doesn't match expected " << fsid
        ¦<< ", invalid (someone else's?) journal" << dendl;
  ¦ ret = -EINVAL;
  ¦ goto done;
  }

  dout(1) << "check: header looks ok" << dendl;
  ret = 0;

 done:
  close();
  return ret;
}

序列化事务日志头

//将内存中的日志header结构对象序列化到一段内存空间中，并返回该空间的指针
bufferptr FileJournal::prepare_header() 
{
  bufferlist bl; 
  {
  ¦ Mutex::Locker l(finisher_lock);
  ¦ header.committed_up_to = journaled_seq;
  }
  ::encode(header, bl);
  bufferptr bp = buffer::create_page_aligned(get_top());
  // don't use bp.zero() here, because it also invalidates
  // crc cache (which is not yet populated anyway)
  char* data = bp.c_str();
  memcpy(data, bl.c_str(), bl.length());
  data += bl.length();
  memset(data, 0, bp.length()-bl.length());                                                                                                                                                  
  return bp;
}

事务日志头信息：

 /*
  ¦* journal header
  ¦*/   
  struct header_t {
  ¦ enum {
  ¦ ¦ FLAG_CRC = (1<<0),
  ¦ ¦ // NOTE: remove kludgey weirdness in read_header() next time a flag is added.
  ¦ };

  ¦ uint64_t flags;
  ¦ uuid_d fsid;
  ¦ __u32 block_size;
  ¦ __u32 alignment;
  ¦ int64_t max_size;   // max size of journal ring buffer
  ¦ int64_t start;      // offset of first entry
  ¦ uint64_t committed_up_to; // committed up to

  ¦ /**
  ¦ ¦* start_seq
  ¦ ¦*
  ¦ ¦* entry at header.start has sequence >= start_seq
  ¦ ¦*
  ¦ ¦* Generally, the entry at header.start will have sequence
  ¦ ¦* start_seq if it exists.  The only exception is immediately
  ¦ ¦* after journal creation since the first sequence number is
  ¦ ¦* not known.
  ¦ ¦*
  ¦ ¦* If the first read on open fails, we can assume corruption
  ¦ ¦* if start_seq > committed_up_to because the entry would have
  ¦ ¦* a sequence >= start_seq and therefore > committed_up_to.
  ¦ ¦*/
  ¦ uint64_t start_seq;
 ¦ void encode(bufferlist& bl) const {
  ¦ ¦ __u32 v = 4;
  ¦ ¦ ::encode(v, bl);
  ¦ ¦ bufferlist em;
  ¦ ¦ {
        ::encode(flags, em);
        ::encode(fsid, em);
        ::encode(block_size, em);
        ::encode(alignment, em);
        ::encode(max_size, em);
        ::encode(start, em);
        ::encode(committed_up_to, em);
        ::encode(start_seq, em);
  ¦ ¦ }
  ¦ ¦ ::encode(em, bl);
  ¦ }
  ¦ void decode(bufferlist::iterator& bl) {
  ¦ ¦ __u32 v;
  ¦ ¦ ::decode(v, bl);
  ¦ ¦ if (v < 2) {  // normally 0, but concievably 1
        // decode old header_t struct (pre v0.40).
        bl.advance(4); // skip __u32 flags (it was unused by any old code)
        flags = 0;
        uint64_t tfsid;
        ::decode(tfsid, bl);
        *(uint64_t*)&fsid.bytes()[0] = tfsid;
        *(uint64_t*)&fsid.bytes()[8] = tfsid;
        ::decode(block_size, bl);
        ::decode(alignment, bl);
        ::decode(max_size, bl);
        ::decode(start, bl);
        committed_up_to = 0;
        start_seq = 0;
        return;
  ¦ ¦ }
  ¦ ¦ bufferlist em;
  ¦ ¦ ::decode(em, bl);
  ¦ ¦ bufferlist::iterator t = em.begin();
  ¦ ¦ ::decode(flags, t);
  ¦ ¦ ::decode(fsid, t);
  ¦ ¦ ::decode(block_size, t);
  ¦ ¦ ::decode(alignment, t);
  ¦ ¦ ::decode(max_size, t);
  ¦ ¦ ::decode(start, t);

  ¦ ¦ if (v > 2)
        ::decode(committed_up_to, t);
  ¦ ¦ else
        committed_up_to = 0;

  ¦ ¦ if (v > 3)
        ::decode(start_seq, t);
  ¦ ¦ else
        start_seq = 0;
  ¦ }

。。。
}