ITPub博客
首页 博客 专栏 学院 社区 IT新媒体评选
发博

首页 > 数据库 > 数据库开发技术 > leveldb代码精读 数据库启动和初始化

leveldb代码精读 数据库启动和初始化

原创 数据库开发技术 作者：liiinuuux 时间：2015-11-25 11:21:16 0 删除 编辑


基本概念
数据库主要包括cache、日志文件、数据文件、CURRENT文件和manifest文件几大块。


所有文件都是依照类型+文件号的命名规则，文件号非常重要，类似oracle的sequence#。
其中cache是当前写入的数据缓存，写入数据时
1 将数据写入日志文件
2 将数据放入cache
当达到一定条件，如cache里的数据够多时
1 将cache转成只读cache，供查询用。
2 新建一个读写cache和一个新日志文件。
3 将只读cache里的数据写到数据文件里，这种新生成的数据文件称为level 0。


由于每次写文件后都会启用新的cache，写入的key可能和已有数据重复，将来也会落地成文件。
因此leveldb会对文件进行“压缩”，在多个level 0文件中给key去重，称为level 1。
随着数据库运行，level 1还会进一步和level n+1的文件合并，以此类推。
每次合并后删除老文件。
这样做的结果就是从level 1开始，每层的文件不会有重复的key，层与层之间的文件也不会有重复的key，大大提高从文件查询的效率。
由于所有文件的内容都是排序的，并且记录了key的范围，因此这些操作的成本非常可控。

当数据库重启时会根据日志文件重新构建cache并将cache里的数据写到level 0文件里。


上述所有信息称为数据库的一个Version。
Version的增量叫VersionEdit，VersionEdit记录了增加哪些文件，减少哪些文件，以及文件的概要信息等。
version1 + versionedit1 = version2
数据库里可能会保存多个version信息，所有version的载体是VersionSet。

这些信息还记录在manifest文件内，相当于oracle的控制文件。
CURRENT文件记录数据库当前manifest文件的文件名。

数据库宕机后，实例恢复的流程就是
1 根据文件命名规则，在文件夹寻找之前的CURRENT 
2 寻找之前的manifest 
3 定位logfile 
4 将logfile数据复原到cache 
5 将cache里的数据写到level 0数据文件


下面看代码
初始化数据库包括新建数据库和打开已关闭的数据库两种情况
功能入口是DB::Open

点击(此处)折叠或打开

  1. Status DB::Open(const Options& options, const std::string& dbname,
  2.                 DB** dbptr) {
  3.   *dbptr = NULL;


  6.   /*
  7.   DBImpl是leveldb的“主类”，初始化配置信息
  8.   dbname是数据库的所在目录
  9.   */
  10.   DBImpl* impl = new DBImpl(options, dbname);
  11.   impl->mutex_.Lock();


  14.   /*
  15.   打开数据库，如果不存在就创建。
  16.   如果存在就检查manifest文件，并根据其中的信息创建一个VersionEdit，用这个VersionEdit还原数据库的Version。
  17.   */
  18.   VersionEdit edit;
  19.   Status s = impl->Recover(&edit); // Handles create_if_missing, error_if_exists
  20.   if (s.ok()) {
  21.     uint64_t new_log_number = impl->versions_->NewFileNumber();
  22.     WritableFile* lfile;


  25.     /*
  26.     以w选项打开一个新logfile。
  27.     lfile就是打开的文件，类型是PosixWritableFile，封装了一些IO操作。
  28.     */
  29.     s = options.env->NewWritableFile(LogFileName(dbname, new_log_number),
  30.                                      &lfile);
  31.     if (s.ok()) {
  32.       // 初始化当前logfile文件号
  33.       edit.SetLogNumber(new_log_number);
  34.       impl->logfile_ = lfile;
  35.       impl->logfile_number_ = new_log_number;
  36.       // log::Writer用来写日志，公共函数就一个AddRecord
  37.       impl->log_ = new log::Writer(lfile);


  40.       /*
  41.       1 结合VersionSet，进一步设置VersionEdit，
  42.       2 根据当前logfile号创建一个新version作为current version
  43.       3 创建manifest文件
  44.       4 创建一个snapshot
  45.       */
  46.       s = impl->versions_->LogAndApply(&edit, &impl->mutex_);
  47.     }
  48.     if (s.ok()) {
  49.       // 根据文件号等条件，删除不再需要的文件。
  50.       impl->DeleteObsoleteFiles();
  51.       // 进行一次压缩，把重复键值的文件由低级向高级合并。
  52.       impl->MaybeScheduleCompaction();
  53.     }
  54.   }
  55.   impl->mutex_.Unlock();
  56.   if (s.ok()) {
  57.     *dbptr = impl;
  58.   } else {
  59.     delete impl;
  60.   }
  61.   return s;
  62. }


下面是Open函数一上来调用的构造函数

点击(此处)折叠或打开

  1. DBImpl::DBImpl(const Options& raw_options, const std::string& dbname)
  2.       /*
  3.       leveldb将系统相关的操作封装到env里，
  4.       linux版的env是PosixEnv类，在util/env_posix.cc里
  5.       */
  6.     : env_(raw_options.env),
  7.       // comparator用来比较key的大小，可以自己实现，也可以用leveldb默认的
  8.       internal_comparator_(raw_options.comparator),
  9.       // 定义过滤数据的算法，比如布隆过滤等
  10.       internal_filter_policy_(raw_options.filter_policy),
  11.       // SanitizeOptions函数用来对参数raw_options的选项进行必要的处理，并封装成一个处理后的Options
  12.       options_(SanitizeOptions(dbname, &internal_comparator_,
  13.                                &internal_filter_policy_, raw_options)),
  14.       owns_info_log_(options_.info_log != raw_options.info_log),
  15.       owns_cache_(options_.block_cache != raw_options.block_cache),
  16.       // dbname其实是指定数据库的文件夹，所有数据文件都会放到这个文件夹下。
  17.       dbname_(dbname),


  20.       // 用于锁文件，linux的是PosixFileLock类，里面有一个文件描述符和一个字符串
  21.       db_lock_(NULL),
  22.       shutting_down_(NULL),


  25.       // 管理后台线程的并发
  26.       bg_cv_(&mutex_),


  29.       /*
  30.       下面两个memtable，是对SkipList类的封装。
  31.       关于SkipList, 参考我之前的博客 http://blog.itpub.net/26239116/viewspace-1839630/
  32.       具体封装方式是在memtable.h里定义typedef，并设置为成员变量
  33.       typedef SkipList<const char*, KeyComparator> Table;
  34.       ...
  35.       Table table_;
  36.       */
  37.       mem_(new MemTable(internal_comparator_)),
  38.       imm_(NULL),
  39.       logfile_(NULL),
  40.       logfile_number_(0),
  41.       log_(NULL),
  42.       seed_(0),
  43.       // 文件IO的工具
  44.       tmp_batch_(new WriteBatch),
  45.       bg_compaction_scheduled_(false),
  46.       manual_compaction_(NULL) {
  47.   mem_->Ref();
  48.   has_imm_.Release_Store(NULL);


  51.   // Reserve ten files or so for other uses and give the rest to TableCache.
  52.   /*
  53.   最大文件数减去预留的辅助文件数，需要维护数据的文件数
  54.   在创建TableCache的时候，这个文件数对应的是TableCache里lrucache的数量
  55.   关于lrucache，参考文献之前的博客 http://blog.itpub.net/26239116/viewspace-1842049/
  56.   */
  57.   const int table_cache_size = options_.max_open_files - kNumNonTableCacheFiles;
  58.   table_cache_ = new TableCache(dbname_, &options_, table_cache_size);


  61.   // 初始化VersionSet，用于存放数据库里所有version
  62.   versions_ = new VersionSet(dbname_, &options_, table_cache_,
  63.                              &internal_comparator_);
  64. }





构造函数里调的SanitizeOptions的具体内容。对option做了一下预处理

点击(此处)折叠或打开

  1. Options SanitizeOptions(const std::string& dbname,
  2.                         const InternalKeyComparator* icmp,
  3.                         const InternalFilterPolicy* ipolicy,
  4.                         const Options& src) {
  5.   // 复制一份调用者提供的Options，做返回值用。
  6.   Options result = src;
  7.   result.comparator = icmp;
  8.   result.filter_policy = (src.filter_policy != NULL) ? ipolicy : NULL;


  11.   // 校验数值型参数，太大的设置为最大值，太小的设置为最小值
  12.   ClipToRange(&result.max_open_files, 64 + kNumNonTableCacheFiles, 50000);
  13.   ClipToRange(&result.write_buffer_size, 64<<10, 1<<30);
  14.   ClipToRange(&result.block_size, 1<<10, 4<<20);


  17.   // 如果没有指定日志，创建一个。
  18.   if (result.info_log == NULL) {
  19.     // Open a log file in the same directory as the db
  20.     src.env->CreateDir(dbname); // In case it does not exist
  21.     /*
  22.     日志文件的命名规则是 dbname + "/LOG"，
  23.     创建之前需要先原有的重命名为 dbname + "/LOG.old"
  24.     */
  25.     src.env->RenameFile(InfoLogFileName(dbname), OldInfoLogFileName(dbname));


  28.     /*
  29.     创建一个logger，对于linux平台，是创建一个PosixLogger
  30.     */
  31.     Status s = src.env->NewLogger(InfoLogFileName(dbname), &result.info_log);
  32.     if (!s.ok()) {
  33.       // No place suitable for logging
  34.       result.info_log = NULL;
  35.     }
  36.   }


  39.   /*
  40.   创建一个lru cache
  41.   关于lru cache，参考我前面的博客 http://blog.itpub.net/26239116/viewspace-1842049/
  42.   */
  43.   if (result.block_cache == NULL) {
  44.     result.block_cache = NewLRUCache(8 << 20);
  45.   }
  46.   return result;
  47. }



数据库初始化的主要工作由DBImpl::Recover函数完成

点击(此处)折叠或打开

  1. Status DBImpl::Recover(VersionEdit* edit) {
  2.   mutex_.AssertHeld();


  5.   // Ignore error from CreateDir since the creation of the DB is
  6.   // committed only when the descriptor is created, and this directory
  7.   // may already exist from a previous failed creation attempt.
  8.   env_->CreateDir(dbname_);
  9.   assert(db_lock_ == NULL);


  12.   /*
  13.     创建文件锁，格式是"dbname_/LOC"
  14.     linux版的env是env_posix.cc
  15.     大致过程是
  16.     1 对文件信息进行一系列记录，如记录到PosixFileLock类里。
  17.     2 创建一个“锁”文件，写入flock结构体写进去。flock定义在fcntl.h里。
  18.   */
  19.   Status s = env_->LockFile(LockFileName(dbname_), &db_lock_);
  20.   if (!s.ok()) {
  21.     return s;
  22.   }
  23.   
  24.   /*
  25.   判断current文件是否存在，格式是“dbname_/CURRENT”
  26.   用来记录当前的manifest文件名，madifest文件里记录当前数据库的概要信息，类似oracle的控制文件
  27.   */
  28.   if (!env_->FileExists(CurrentFileName(dbname_))) {
  29.     if (options_.create_if_missing) {
  30.       // 初始化一个新的VersionEdit，设置logfile信息，然后写入manifest文件。
  31.       s = NewDB();
  32.       if (!s.ok()) {
  33.         return s;
  34.       }
  35.     } else {
  36.       return Status::InvalidArgument(
  37.           dbname_, "does not exist (create_if_missing is false)");
  38.     }
  39.   } else {
  40.     if (options_.error_if_exists) {
  41.       return Status::InvalidArgument(
  42.           dbname_, "exists (error_if_exists is true)");
  43.     }
  44.   }


  47.   // 如果之前存在这个数据库，打开时需要做恢复工作，manifest文件里的信息应用的当前version。
  48.   s = versions_->Recover();
  49.   if (s.ok()) {
  50.     SequenceNumber max_sequence(0);


  53.     // Recover from all newer log files than the ones named in the
  54.     // descriptor (new log files may have been added by the previous
  55.     // incarnation without registering them in the descriptor).
  56.     //
  57.     // Note that PrevLogNumber() is no longer used, but we pay
  58.     // attention to it in case we are recovering a database
  59.     // produced by an older version of leveldb.
  60.     const uint64_t min_log = versions_->LogNumber();
  61.     const uint64_t prev_log = versions_->PrevLogNumber();
  62.     std::vector<std::string> filenames;
  63.     s = env_->GetChildren(dbname_, &filenames);
  64.     if (!s.ok()) {
  65.       return s;
  66.     }
  67.     std::set<uint64_t> expected;


  70.     // 从所有version里获得所有文件号
  71.     versions_->AddLiveFiles(&expected);
  72.     uint64_t number;
  73.     FileType type;
  74.     std::vector<uint64_t> logs;


  77.     /*
  78.     从文件夹内所有文件名中提取文件类型和文件号
  79.     从versions_提取的expected中移除这些文件号
  80.     同时记录其中有哪些log文件
  81.     */
  82.     for (size_t i = 0; i < filenames.size(); i++) {
  83.       if (ParseFileName(filenames[i], &number, &type)) {
  84.         expected.erase(number);
  85.         if (type == kLogFile && ((number >= min_log) || (number == prev_log)))
  86.           logs.push_back(number);
  87.       }
  88.     }


  91.     // 如果expected的内容么有全部清空，说明丢失文件了。
  92.     if (!expected.empty()) {
  93.       char buf[50];
  94.       snprintf(buf, sizeof(buf), "%d missing files; e.g.",
  95.                static_cast<int>(expected.size()));
  96.       return Status::Corruption(buf, TableFileName(dbname_, *(expected.begin())));
  97.     }


  100.     // 按顺序逐个恢复log文件
  101.     // Recover in the order in which the logs were generated
  102.     std::sort(logs.begin(), logs.end());
  103.     for (size_t i = 0; i < logs.size(); i++) {
  104.       s = RecoverLogFile(logs[i], edit, &max_sequence);


  107.       // The previous incarnation may not have written any MANIFEST
  108.       // records after allocating this log number. So we manually
  109.       // update the file number allocation counter in VersionSet.
  110.       versions_->MarkFileNumberUsed(logs[i]);
  111.     }


  114.     if (s.ok()) {
  115.       if (versions_->LastSequence() < max_sequence) {
  116.         versions_->SetLastSequence(max_sequence);
  117.       }
  118.     }
  119.   }


  122.   return s;
  123. }



由于DBImpl::Recover前面已经判断过CURRENT文件是否存在，如果不存在就创建新数据库了，
因此这里就是要处理新的或者曾经关闭过的数据库。

点击(此处)折叠或打开

  1. Status VersionSet::Recover() {
  2.   struct LogReporter : public log::Reader::Reporter {
  3.     Status* status;
  4.     virtual void Corruption(size_t bytes, const Status& s) {
  5.       if (this->status->ok()) *this->status = s;
  6.     }
  7.   };


  10.   // Read "CURRENT" file, which contains a pointer to the current manifest file
  11.   std::string current;
  12.   // 从CURRENT文件把当前的manifest文件名读到字符串里current里
  13.   Status s = ReadFileToString(env_, CurrentFileName(dbname_), &current);
  14.   if (!s.ok()) {
  15.     return s;
  16.   }


  19.   /*
  20.   CURRENT文件应该只有一行，就是当前manifest文件名。
  21.   要求CURRENT文件必须以换行符结尾
  22.   这样resize后就只剩文件名了。
  23.   */
  24.   if (current.empty() || current[current.size()-1] != '\n') {
  25.     return Status::Corruption("CURRENT file does not end with newline");
  26.   }
  27.   current.resize(current.size() - 1);
  28.   
  29.   // 打开manifest文件
  30.   std::string dscname = dbname_ + "/" + current;
  31.   SequentialFile* file;
  32.   s = env_->NewSequentialFile(dscname, &file);
  33.   if (!s.ok()) {
  34.     return s;
  35.   }
  36.  
  37.   // 初始化logfile信息，构建一个新的Version作为current version
  38.   bool have_log_number = false;
  39.   bool have_prev_log_number = false;
  40.   bool have_next_file = false;
  41.   bool have_last_sequence = false;
  42.   uint64_t next_file = 0;
  43.   uint64_t last_sequence = 0;
  44.   uint64_t log_number = 0;
  45.   uint64_t prev_log_number = 0;


  48.   /*
  49.   此时的current_，也就是current version是之前在构造函数里初始化的
  50.   AppendVersion(new Version(this));
  51.   在AppendVersion中会把新初始化的Version作为current version
  52.   current_ = v;
  53.   因此到builder这一步，一切都值是初始化，还没有正式开始真正恢复操作
  54.   */
  55.   Builder builder(this, current_);


  58.   {
  59.     LogReporter reporter;
  60.     reporter.status = &s;
  61.     log::Reader reader(file, &reporter, true/*checksum*/, 0/*initial_offset*/);
  62.     Slice record;
  63.     std::string scratch;
  64.     // 解析manifest的内容，还原出上次关闭的数据库的logfile等信息，装入VersionEdit
  65.     while (reader.ReadRecord(&record, &scratch) && s.ok()) {
  66.       /*
  67.       创建一个edit，要改变Version的状态，就需要用VersionEdit
  68.       version1 + edit1 = verion2
  69.       */
  70.       VersionEdit edit;


  73.       /*
  74.       leveldb的存储是按一定格式的，需要decode还原
  75.       将manifest中读到的信息decode后放入edit，后面恢复会用到。
  76.       只是概要信息，比如新文件，删除了哪些文件等。
  77.       */
  78.       s = edit.DecodeFrom(record);
  79.       if (s.ok()) {
  80.         if (edit.has_comparator_ &&
  81.             edit.comparator_ != icmp_.user_comparator()->Name()) {
  82.           s = Status::InvalidArgument(
  83.               edit.comparator_ + " does not match existing comparator ",
  84.               icmp_.user_comparator()->Name());
  85.         }
  86.       }


  89.       if (s.ok()) {
  90.         /*
  91.         将edit的内容封装到builder里。
  92.         */
  93.         builder.Apply(&edit);
  94.       }


  97.       if (edit.has_log_number_) {
  98.         log_number = edit.log_number_;
  99.         have_log_number = true;
  100.       }


  103.       if (edit.has_prev_log_number_) {
  104.         prev_log_number = edit.prev_log_number_;
  105.         have_prev_log_number = true;
  106.       }


  109.       if (edit.has_next_file_number_) {
  110.         next_file = edit.next_file_number_;
  111.         have_next_file = true;
  112.       }


  115.       if (edit.has_last_sequence_) {
  116.         last_sequence = edit.last_sequence_;
  117.         have_last_sequence = true;
  118.       }
  119.     }
  120.   }
  121.   delete file;
  122.   file = NULL;


  125.   if (s.ok()) {
  126.     if (!have_next_file) {
  127.       s = Status::Corruption("no meta-nextfile entry in descriptor");
  128.     } else if (!have_log_number) {
  129.       s = Status::Corruption("no meta-lognumber entry in descriptor");
  130.     } else if (!have_last_sequence) {
  131.       s = Status::Corruption("no last-sequence-number entry in descriptor");
  132.     }


  135.     if (!have_prev_log_number) {
  136.       prev_log_number = 0;
  137.     }


  140.     MarkFileNumberUsed(prev_log_number);
  141.     MarkFileNumberUsed(log_number);
  142.   }


  145.   if (s.ok()) {
  146.     // 利用builder的信息封装一个新的version，追加到VersionSet里
  147.     Version* v = new Version(this);


  150.     /*
  151.     builder前面从edit里读了manifest文件，
  152.     SaveTo会将从manifest文件里读到的文件添加到Version.files_里
  153.     在打开数据库操作的后面步骤里，会读取files_里的文件信息，与目录下的实体文件进行对照，看文件全不全。
  154.     这个过程就是version + edit，只不过这个version是新建的空version。
  155.     最终得到的是上次关闭的数据库version
  156.     */
  157.     builder.SaveTo(v);
  158.     // Install recovered version
  159.     // 根据各level的文件大小计算一个“得分”，以后影响压缩行为
  160.     Finalize(v);
  161.     // 将新封装好的Version放到VersionSet里，作为current version
  162.     AppendVersion(v);
  163.     manifest_file_number_ = next_file;
  164.     next_file_number_ = next_file + 1;
  165.     last_sequence_ = last_sequence;
  166.     log_number_ = log_number;
  167.     prev_log_number_ = prev_log_number;
  168.   }


  171.   return s;
  172. }


逐个恢复logfile

点击(此处)折叠或打开

  1. Status DBImpl::RecoverLogFile(uint64_t log_number,
  2.                               VersionEdit* edit,
  3.                               SequenceNumber* max_sequence) {
  4.   struct LogReporter : public log::Reader::Reporter {
  5.     Env* env;
  6.     Logger* info_log;
  7.     const char* fname;
  8.     Status* status; // NULL if options_.paranoid_checks==false
  9.     virtual void Corruption(size_t bytes, const Status& s) {
  10.       Log(info_log, "%s%s: dropping %d bytes; %s",
  11.           (this->status == NULL ? "(ignoring error) " : ""),
  12.           fname, static_cast<int>(bytes), s.ToString().c_str());
  13.       if (this->status != NULL && this->status->ok()) *this->status = s;
  14.     }
  15.   };


  18.   mutex_.AssertHeld();


  21.   // Open the log file
  22.   std::string fname = LogFileName(dbname_, log_number);
  23.   SequentialFile* file;
  24.   // 只读打开logfile
  25.   Status status = env_->NewSequentialFile(fname, &file);
  26.   if (!status.ok()) {
  27.     MaybeIgnoreError(&status);
  28.     return status;
  29.   }


  32.   // Create the log reader.
  33.   LogReporter reporter;
  34.   reporter.env = env_;
  35.   reporter.info_log = options_.info_log;
  36.   reporter.fname = fname.c_str();
  37.   reporter.status = (options_.paranoid_checks ? &status : NULL);
  38.   // We intentionally make log::Reader do checksumming even if
  39.   // paranoid_checks==false so that corruptions cause entire commits
  40.   // to be skipped instead of propagating bad information (like overly
  41.   // large sequence numbers).
  42.   log::Reader reader(file, &reporter, true/*checksum*/,
  43.                      0/*initial_offset*/);
  44.   Log(options_.info_log, "Recovering log #%llu",
  45.       (unsigned long long) log_number);


  48.   // Read all the records and add to a memtable
  49.   std::string scratch;
  50.   Slice record;
  51.   WriteBatch batch;
  52.   MemTable* mem = NULL;
  53.   /*
  54.   逐行读取logfile
  55.   将得到的数据放入memtable mm里
  56.   */
  57.   while (reader.ReadRecord(&record, &scratch) &&
  58.          status.ok()) {
  59.     if (record.size() < 12) {
  60.       reporter.Corruption(
  61.           record.size(), Status::Corruption("log record too small"));
  62.       continue;
  63.     }
  64.     WriteBatchInternal::SetContents(&batch, record);


  67.     if (mem == NULL) {
  68.       mem = new MemTable(internal_comparator_);
  69.       mem->Ref();
  70.     }
  71.     status = WriteBatchInternal::InsertInto(&batch, mem);
  72.     MaybeIgnoreError(&status);
  73.     if (!status.ok()) {
  74.       break;
  75.     }
  76.     const SequenceNumber last_seq =
  77.         WriteBatchInternal::Sequence(&batch) +
  78.         WriteBatchInternal::Count(&batch) - 1;
  79.     if (last_seq > *max_sequence) {
  80.       *max_sequence = last_seq;
  81.     }
  82.     
  83.     // 当memtable使用量超过设置的值时，将数据刷到level 0 数据文件里。
  84.     // 这样在恢复过程中不会将内存撑爆
  85.     if (mem->ApproximateMemoryUsage() > options_.write_buffer_size) {
  86.       status = WriteLevel0Table(mem, edit, NULL);
  87.       if (!status.ok()) {
  88.         // Reflect errors immediately so that conditions like full
  89.         // file-systems cause the DB::Open() to fail.
  90.         break;
  91.       }
  92.       mem->Unref();
  93.       mem = NULL;
  94.     }
  95.   }


  98.   if (status.ok() && mem != NULL) {
  99.     status = WriteLevel0Table(mem, edit, NULL);
  100.     // Reflect errors immediately so that conditions like full
  101.     // file-systems cause the DB::Open() to fail.
  102.   }


  105.   if (mem != NULL) mem->Unref();
  106.   delete file;
  107.   return status;
  108. }



















来自 “ ITPUB博客 ” ，链接：https://blog.itpub.net/26239116/viewspace-1846192/ ，如需转载，请注明出处，否则将追究法律责任。

0
0
上一篇： leveldb代码精读 lru cache
下一篇： leveldb代码精读 插入操作
请登录后发表评论 登录
全部评论
liiinuuux

注册时间：2012-11-12

  • 博文量
    94
  • 访问量
    353435

最新文章

支持我们 作者招募 用户协议 FAQ Contact Us

北京盛拓优讯信息技术有限公司. 版权所有  京ICP备16024965号-8 北京市公安局海淀分局网监中心备案编号：11010802021510 niuxiaotong@pcpop.com 17352615567 未成年人举报专区

广播电视节目制作经营许可证(京) 字第1234号 中国互联网协会会员

违法和不良信息举报电话:18101376593