dbreg_auto.c
上传用户:romrleung
上传日期:2022-05-23
资源大小:18897k
文件大小:8k
源码类别:

MySQL数据库

开发平台:

Visual C++

  1. /* Do not edit: automatically built by gen_rec.awk. */
  2. #include "db_config.h"
  3. #ifndef NO_SYSTEM_INCLUDES
  4. #include <sys/types.h>
  5. #include <ctype.h>
  6. #include <string.h>
  7. #endif
  8. #include "db_int.h"
  9. #include "dbinc/crypto.h"
  10. #include "dbinc/db_page.h"
  11. #include "dbinc/db_dispatch.h"
  12. #include "dbinc/db_am.h"
  13. #include "dbinc/log.h"
  14. #include "dbinc/rep.h"
  15. #include "dbinc/txn.h"
  16. /*
  17.  * PUBLIC: int __dbreg_register_log __P((DB_ENV *, DB_TXN *,
  18.  * PUBLIC:     DB_LSN *, u_int32_t, u_int32_t, const DBT *, const DBT *,
  19.  * PUBLIC:     int32_t, DBTYPE, db_pgno_t, u_int32_t));
  20.  */
  21. int
  22. __dbreg_register_log(dbenv, txnid, ret_lsnp, flags,
  23.     opcode, name, uid, fileid, ftype, meta_pgno,
  24.     id)
  25. DB_ENV *dbenv;
  26. DB_TXN *txnid;
  27. DB_LSN *ret_lsnp;
  28. u_int32_t flags;
  29. u_int32_t opcode;
  30. const DBT *name;
  31. const DBT *uid;
  32. int32_t fileid;
  33. DBTYPE ftype;
  34. db_pgno_t meta_pgno;
  35. u_int32_t id;
  36. {
  37. DBT logrec;
  38. DB_LSN *lsnp, null_lsn;
  39. u_int32_t zero;
  40. u_int32_t uinttmp;
  41. u_int32_t npad, rectype, txn_num;
  42. int ret;
  43. u_int8_t *bp;
  44. rectype = DB___dbreg_register;
  45. npad = 0;
  46. if (txnid == NULL) {
  47. txn_num = 0;
  48. null_lsn.file = 0;
  49. null_lsn.offset = 0;
  50. lsnp = &null_lsn;
  51. } else {
  52. if (TAILQ_FIRST(&txnid->kids) != NULL &&
  53.     (ret = __txn_activekids(dbenv, rectype, txnid)) != 0)
  54. return (ret);
  55. txn_num = txnid->txnid;
  56. lsnp = &txnid->last_lsn;
  57. }
  58. logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
  59.     + sizeof(u_int32_t)
  60.     + sizeof(u_int32_t) + (name == NULL ? 0 : name->size)
  61.     + sizeof(u_int32_t) + (uid == NULL ? 0 : uid->size)
  62.     + sizeof(u_int32_t)
  63.     + sizeof(u_int32_t)
  64.     + sizeof(u_int32_t)
  65.     + sizeof(u_int32_t);
  66. if (CRYPTO_ON(dbenv)) {
  67. npad =
  68.     ((DB_CIPHER *)dbenv->crypto_handle)->adj_size(logrec.size);
  69. logrec.size += npad;
  70. }
  71. if ((ret = __os_malloc(dbenv,
  72.     logrec.size, &logrec.data)) != 0)
  73. return (ret);
  74. if (npad > 0)
  75. memset((u_int8_t *)logrec.data + logrec.size - npad, 0, npad);
  76. bp = logrec.data;
  77. memcpy(bp, &rectype, sizeof(rectype));
  78. bp += sizeof(rectype);
  79. memcpy(bp, &txn_num, sizeof(txn_num));
  80. bp += sizeof(txn_num);
  81. memcpy(bp, lsnp, sizeof(DB_LSN));
  82. bp += sizeof(DB_LSN);
  83. uinttmp = (u_int32_t)opcode;
  84. memcpy(bp, &uinttmp, sizeof(uinttmp));
  85. bp += sizeof(uinttmp);
  86. if (name == NULL) {
  87. zero = 0;
  88. memcpy(bp, &zero, sizeof(u_int32_t));
  89. bp += sizeof(u_int32_t);
  90. } else {
  91. memcpy(bp, &name->size, sizeof(name->size));
  92. bp += sizeof(name->size);
  93. memcpy(bp, name->data, name->size);
  94. bp += name->size;
  95. }
  96. if (uid == NULL) {
  97. zero = 0;
  98. memcpy(bp, &zero, sizeof(u_int32_t));
  99. bp += sizeof(u_int32_t);
  100. } else {
  101. memcpy(bp, &uid->size, sizeof(uid->size));
  102. bp += sizeof(uid->size);
  103. memcpy(bp, uid->data, uid->size);
  104. bp += uid->size;
  105. }
  106. uinttmp = (u_int32_t)fileid;
  107. memcpy(bp, &uinttmp, sizeof(uinttmp));
  108. bp += sizeof(uinttmp);
  109. uinttmp = (u_int32_t)ftype;
  110. memcpy(bp, &uinttmp, sizeof(uinttmp));
  111. bp += sizeof(uinttmp);
  112. uinttmp = (u_int32_t)meta_pgno;
  113. memcpy(bp, &uinttmp, sizeof(uinttmp));
  114. bp += sizeof(uinttmp);
  115. uinttmp = (u_int32_t)id;
  116. memcpy(bp, &uinttmp, sizeof(uinttmp));
  117. bp += sizeof(uinttmp);
  118. DB_ASSERT((u_int32_t)(bp - (u_int8_t *)logrec.data) <= logrec.size);
  119. ret = dbenv->log_put(dbenv,
  120.    ret_lsnp, (DBT *)&logrec, flags | DB_NOCOPY);
  121. if (txnid != NULL && ret == 0)
  122. txnid->last_lsn = *ret_lsnp;
  123. #ifdef LOG_DIAGNOSTIC
  124. if (ret != 0)
  125. (void)__dbreg_register_print(dbenv,
  126.     (DBT *)&logrec, ret_lsnp, NULL, NULL);
  127. #endif
  128. __os_free(dbenv, logrec.data);
  129. return (ret);
  130. }
  131. /*
  132.  * PUBLIC: int __dbreg_register_getpgnos __P((DB_ENV *, DBT *,
  133.  * PUBLIC:     DB_LSN *, db_recops, void *));
  134.  */
  135. int
  136. __dbreg_register_getpgnos(dbenv, rec, lsnp, notused1, summary)
  137. DB_ENV *dbenv;
  138. DBT *rec;
  139. DB_LSN *lsnp;
  140. db_recops notused1;
  141. void *summary;
  142. {
  143. TXN_RECS *t;
  144. int ret;
  145. COMPQUIET(rec, NULL);
  146. COMPQUIET(notused1, DB_TXN_ABORT);
  147. t = (TXN_RECS *)summary;
  148. if ((ret = __rep_check_alloc(dbenv, t, 1)) != 0)
  149. return (ret);
  150. t->array[t->npages].flags = LSN_PAGE_NOLOCK;
  151. t->array[t->npages].lsn = *lsnp;
  152. t->array[t->npages].fid = DB_LOGFILEID_INVALID;
  153. memset(&t->array[t->npages].pgdesc, 0,
  154.     sizeof(t->array[t->npages].pgdesc));
  155. t->npages++;
  156. return (0);
  157. }
  158. /*
  159.  * PUBLIC: int __dbreg_register_print __P((DB_ENV *, DBT *, DB_LSN *,
  160.  * PUBLIC:     db_recops, void *));
  161.  */
  162. int
  163. __dbreg_register_print(dbenv, dbtp, lsnp, notused2, notused3)
  164. DB_ENV *dbenv;
  165. DBT *dbtp;
  166. DB_LSN *lsnp;
  167. db_recops notused2;
  168. void *notused3;
  169. {
  170. __dbreg_register_args *argp;
  171. u_int32_t i;
  172. int ch;
  173. int ret;
  174. notused2 = DB_TXN_ABORT;
  175. notused3 = NULL;
  176. if ((ret = __dbreg_register_read(dbenv, dbtp->data, &argp)) != 0)
  177. return (ret);
  178. (void)printf(
  179.     "[%lu][%lu]__dbreg_register: rec: %lu txnid %lx prevlsn [%lu][%lu]n",
  180.     (u_long)lsnp->file,
  181.     (u_long)lsnp->offset,
  182.     (u_long)argp->type,
  183.     (u_long)argp->txnid->txnid,
  184.     (u_long)argp->prev_lsn.file,
  185.     (u_long)argp->prev_lsn.offset);
  186. (void)printf("topcode: %lun", (u_long)argp->opcode);
  187. (void)printf("tname: ");
  188. for (i = 0; i < argp->name.size; i++) {
  189. ch = ((u_int8_t *)argp->name.data)[i];
  190. printf(isprint(ch) || ch == 0x0a ? "%c" : "%#x ", ch);
  191. }
  192. (void)printf("n");
  193. (void)printf("tuid: ");
  194. for (i = 0; i < argp->uid.size; i++) {
  195. ch = ((u_int8_t *)argp->uid.data)[i];
  196. printf(isprint(ch) || ch == 0x0a ? "%c" : "%#x ", ch);
  197. }
  198. (void)printf("n");
  199. (void)printf("tfileid: %ldn", (long)argp->fileid);
  200. (void)printf("tftype: 0x%lxn", (u_long)argp->ftype);
  201. (void)printf("tmeta_pgno: %lun", (u_long)argp->meta_pgno);
  202. (void)printf("tid: 0x%lxn", (u_long)argp->id);
  203. (void)printf("n");
  204. __os_free(dbenv, argp);
  205. return (0);
  206. }
  207. /*
  208.  * PUBLIC: int __dbreg_register_read __P((DB_ENV *, void *,
  209.  * PUBLIC:     __dbreg_register_args **));
  210.  */
  211. int
  212. __dbreg_register_read(dbenv, recbuf, argpp)
  213. DB_ENV *dbenv;
  214. void *recbuf;
  215. __dbreg_register_args **argpp;
  216. {
  217. __dbreg_register_args *argp;
  218. u_int32_t uinttmp;
  219. u_int8_t *bp;
  220. int ret;
  221. if ((ret = __os_malloc(dbenv,
  222.     sizeof(__dbreg_register_args) + sizeof(DB_TXN), &argp)) != 0)
  223. return (ret);
  224. argp->txnid = (DB_TXN *)&argp[1];
  225. bp = recbuf;
  226. memcpy(&argp->type, bp, sizeof(argp->type));
  227. bp += sizeof(argp->type);
  228. memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
  229. bp += sizeof(argp->txnid->txnid);
  230. memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
  231. bp += sizeof(DB_LSN);
  232. memcpy(&uinttmp, bp, sizeof(uinttmp));
  233. argp->opcode = (u_int32_t)uinttmp;
  234. bp += sizeof(uinttmp);
  235. memset(&argp->name, 0, sizeof(argp->name));
  236. memcpy(&argp->name.size, bp, sizeof(u_int32_t));
  237. bp += sizeof(u_int32_t);
  238. argp->name.data = bp;
  239. bp += argp->name.size;
  240. memset(&argp->uid, 0, sizeof(argp->uid));
  241. memcpy(&argp->uid.size, bp, sizeof(u_int32_t));
  242. bp += sizeof(u_int32_t);
  243. argp->uid.data = bp;
  244. bp += argp->uid.size;
  245. memcpy(&uinttmp, bp, sizeof(uinttmp));
  246. argp->fileid = (int32_t)uinttmp;
  247. bp += sizeof(uinttmp);
  248. memcpy(&uinttmp, bp, sizeof(uinttmp));
  249. argp->ftype = (DBTYPE)uinttmp;
  250. bp += sizeof(uinttmp);
  251. memcpy(&uinttmp, bp, sizeof(uinttmp));
  252. argp->meta_pgno = (db_pgno_t)uinttmp;
  253. bp += sizeof(uinttmp);
  254. memcpy(&uinttmp, bp, sizeof(uinttmp));
  255. argp->id = (u_int32_t)uinttmp;
  256. bp += sizeof(uinttmp);
  257. *argpp = argp;
  258. return (0);
  259. }
  260. /*
  261.  * PUBLIC: int __dbreg_init_print __P((DB_ENV *, int (***)(DB_ENV *,
  262.  * PUBLIC:     DBT *, DB_LSN *, db_recops, void *), size_t *));
  263.  */
  264. int
  265. __dbreg_init_print(dbenv, dtabp, dtabsizep)
  266. DB_ENV *dbenv;
  267. int (***dtabp)__P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *));
  268. size_t *dtabsizep;
  269. {
  270. int ret;
  271. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  272.     __dbreg_register_print, DB___dbreg_register)) != 0)
  273. return (ret);
  274. return (0);
  275. }
  276. /*
  277.  * PUBLIC: int __dbreg_init_getpgnos __P((DB_ENV *,
  278.  * PUBLIC:     int (***)(DB_ENV *, DBT *, DB_LSN *, db_recops, void *),
  279.  * PUBLIC:     size_t *));
  280.  */
  281. int
  282. __dbreg_init_getpgnos(dbenv, dtabp, dtabsizep)
  283. DB_ENV *dbenv;
  284. int (***dtabp)__P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *));
  285. size_t *dtabsizep;
  286. {
  287. int ret;
  288. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  289.     __dbreg_register_getpgnos, DB___dbreg_register)) != 0)
  290. return (ret);
  291. return (0);
  292. }
  293. /*
  294.  * PUBLIC: int __dbreg_init_recover __P((DB_ENV *, int (***)(DB_ENV *,
  295.  * PUBLIC:     DBT *, DB_LSN *, db_recops, void *), size_t *));
  296.  */
  297. int
  298. __dbreg_init_recover(dbenv, dtabp, dtabsizep)
  299. DB_ENV *dbenv;
  300. int (***dtabp)__P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *));
  301. size_t *dtabsizep;
  302. {
  303. int ret;
  304. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  305.     __dbreg_register_recover, DB___dbreg_register)) != 0)
  306. return (ret);
  307. return (0);
  308. }