db2/log/log_auto.c

   1 /* Do not edit: automatically built by dist/db_gen.sh. */
   2 #include "config.h"
   3
   4 #ifndef NO_SYSTEM_INCLUDES
   5 #include <ctype.h>
   6 #include <errno.h>
   7 #include <stddef.h>
   8 #include <stdlib.h>
   9 #include <string.h>
  10 #endif
  11
  12 #include "db_int.h"
  13 #include "shqueue.h"
  14 #include "db_page.h"
  15 #include "db_dispatch.h"
  16 #include "log.h"
  17 #include "db_am.h"
  18 #include "common_ext.h"
  19
  20 /*
  21  * PUBLIC: int __log_register_log
  22  * PUBLIC:     __P((DB_LOG *, DB_TXN *, DB_LSN *, u_int32_t,
  23  * PUBLIC:     DBT *, DBT *, u_int32_t, DBTYPE));
  24  */
  25 int __log_register_log(logp, txnid, ret_lsnp, flags,
  26         name, uid, id, ftype)
  27         DB_LOG *logp;
  28         DB_TXN *txnid;
  29         DB_LSN *ret_lsnp;
  30         u_int32_t flags;
  31         DBT *name;
  32         DBT *uid;
  33         u_int32_t id;
  34         DBTYPE ftype;
  35 {
  36         DBT logrec;
  37         DB_LSN *lsnp, null_lsn;
  38         u_int32_t zero;
  39         u_int32_t rectype, txn_num;
  40         int ret;
  41         u_int8_t *bp;
  42
  43         rectype = DB_log_register;
  44         txn_num = txnid == NULL ? 0 : txnid->txnid;
  45         if (txnid == NULL) {
  46                 null_lsn.file = 0;
  47                 null_lsn.offset = 0;
  48                 lsnp = &null_lsn;
  49         } else
  50                 lsnp = &txnid->last_lsn;
  51         logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
  52             + sizeof(u_int32_t) + (name == NULL ? 0 : name->size)
  53             + sizeof(u_int32_t) + (uid == NULL ? 0 : uid->size)
  54             + sizeof(id)
  55             + sizeof(ftype);
  56         if ((logrec.data = (void *)__db_malloc(logrec.size)) == NULL)
  57                 return (ENOMEM);
  58
  59         bp = logrec.data;
  60         memcpy(bp, &rectype, sizeof(rectype));
  61         bp += sizeof(rectype);
  62         memcpy(bp, &txn_num, sizeof(txn_num));
  63         bp += sizeof(txn_num);
  64         memcpy(bp, lsnp, sizeof(DB_LSN));
  65         bp += sizeof(DB_LSN);
  66         if (name == NULL) {
  67                 zero = 0;
  68                 memcpy(bp, &zero, sizeof(u_int32_t));
  69                 bp += sizeof(u_int32_t);
  70         } else {
  71                 memcpy(bp, &name->size, sizeof(name->size));
  72                 bp += sizeof(name->size);
  73                 memcpy(bp, name->data, name->size);
  74                 bp += name->size;
  75         }
  76         if (uid == NULL) {
  77                 zero = 0;
  78                 memcpy(bp, &zero, sizeof(u_int32_t));
  79                 bp += sizeof(u_int32_t);
  80         } else {
  81                 memcpy(bp, &uid->size, sizeof(uid->size));
  82                 bp += sizeof(uid->size);
  83                 memcpy(bp, uid->data, uid->size);
  84                 bp += uid->size;
  85         }
  86         memcpy(bp, &id, sizeof(id));
  87         bp += sizeof(id);
  88         memcpy(bp, &ftype, sizeof(ftype));
  89         bp += sizeof(ftype);
  90 #ifdef DEBUG
  91         if ((u_int32_t)(bp - (u_int8_t *)logrec.data) != logrec.size)
  92                 fprintf(stderr, "Error in log record length");
  93 #endif
  94         ret = __log_put(logp, ret_lsnp, (DBT *)&logrec, flags);
  95         if (txnid != NULL)
  96                 txnid->last_lsn = *ret_lsnp;
  97         __db_free(logrec.data);
  98         return (ret);
  99 }
 100
 101 /*
 102  * PUBLIC: int __log_register_print
 103  * PUBLIC:    __P((DB_LOG *, DBT *, DB_LSN *, int, void *));
 104  */
 105
 106 int
 107 __log_register_print(notused1, dbtp, lsnp, notused3, notused4)
 108         DB_LOG *notused1;
 109         DBT *dbtp;
 110         DB_LSN *lsnp;
 111         int notused3;
 112         void *notused4;
 113 {
 114         __log_register_args *argp;
 115         u_int32_t i;
 116         int c, ret;
 117
 118         i = 0;
 119         c = 0;
 120         notused1 = NULL;
 121         notused3 = 0;
 122         notused4 = NULL;
 123
 124         if ((ret = __log_register_read(dbtp->data, &argp)) != 0)
 125                 return (ret);
 126         printf("[%lu][%lu]log_register: rec: %lu txnid %lx prevlsn [%lu][%lu]\n",
 127             (u_long)lsnp->file,
 128             (u_long)lsnp->offset,
 129             (u_long)argp->type,
 130             (u_long)argp->txnid->txnid,
 131             (u_long)argp->prev_lsn.file,
 132             (u_long)argp->prev_lsn.offset);
 133         printf("\tname: ");
 134         for (i = 0; i < argp->name.size; i++) {
 135                 c = ((char *)argp->name.data)[i];
 136                 if (isprint(c) || c == 0xa)
 137                         putchar(c);
 138                 else
 139                         printf("%#x ", c);
 140         }
 141         printf("\n");
 142         printf("\tuid: ");
 143         for (i = 0; i < argp->uid.size; i++) {
 144                 c = ((char *)argp->uid.data)[i];
 145                 if (isprint(c) || c == 0xa)
 146                         putchar(c);
 147                 else
 148                         printf("%#x ", c);
 149         }
 150         printf("\n");
 151         printf("\tid: %lu\n", (u_long)argp->id);
 152         printf("\tftype: 0x%lx\n", (u_long)argp->ftype);
 153         printf("\n");
 154         __db_free(argp);
 155         return (0);
 156 }
 157
 158 /*
 159  * PUBLIC: int __log_register_read __P((void *, __log_register_args **));
 160  */
 161 int
 162 __log_register_read(recbuf, argpp)
 163         void *recbuf;
 164         __log_register_args **argpp;
 165 {
 166         __log_register_args *argp;
 167         u_int8_t *bp;
 168
 169         argp = (__log_register_args *)__db_malloc(sizeof(__log_register_args) +
 170             sizeof(DB_TXN));
 171         if (argp == NULL)
 172                 return (ENOMEM);
 173         argp->txnid = (DB_TXN *)&argp[1];
 174         bp = recbuf;
 175         memcpy(&argp->type, bp, sizeof(argp->type));
 176         bp += sizeof(argp->type);
 177         memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
 178         bp += sizeof(argp->txnid->txnid);
 179         memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
 180         bp += sizeof(DB_LSN);
 181         memcpy(&argp->name.size, bp, sizeof(u_int32_t));
 182         bp += sizeof(u_int32_t);
 183         argp->name.data = bp;
 184         bp += argp->name.size;
 185         memcpy(&argp->uid.size, bp, sizeof(u_int32_t));
 186         bp += sizeof(u_int32_t);
 187         argp->uid.data = bp;
 188         bp += argp->uid.size;
 189         memcpy(&argp->id, bp, sizeof(argp->id));
 190         bp += sizeof(argp->id);
 191         memcpy(&argp->ftype, bp, sizeof(argp->ftype));
 192         bp += sizeof(argp->ftype);
 193         *argpp = argp;
 194         return (0);
 195 }
 196
 197 /*
 198  * PUBLIC: int __log_unregister_log
 199  * PUBLIC:     __P((DB_LOG *, DB_TXN *, DB_LSN *, u_int32_t,
 200  * PUBLIC:     u_int32_t));
 201  */
 202 int __log_unregister_log(logp, txnid, ret_lsnp, flags,
 203         id)
 204         DB_LOG *logp;
 205         DB_TXN *txnid;
 206         DB_LSN *ret_lsnp;
 207         u_int32_t flags;
 208         u_int32_t id;
 209 {
 210         DBT logrec;
 211         DB_LSN *lsnp, null_lsn;
 212         u_int32_t rectype, txn_num;
 213         int ret;
 214         u_int8_t *bp;
 215
 216         rectype = DB_log_unregister;
 217         txn_num = txnid == NULL ? 0 : txnid->txnid;
 218         if (txnid == NULL) {
 219                 null_lsn.file = 0;
 220                 null_lsn.offset = 0;
 221                 lsnp = &null_lsn;
 222         } else
 223                 lsnp = &txnid->last_lsn;
 224         logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
 225             + sizeof(id);
 226         if ((logrec.data = (void *)__db_malloc(logrec.size)) == NULL)
 227                 return (ENOMEM);
 228
 229         bp = logrec.data;
 230         memcpy(bp, &rectype, sizeof(rectype));
 231         bp += sizeof(rectype);
 232         memcpy(bp, &txn_num, sizeof(txn_num));
 233         bp += sizeof(txn_num);
 234         memcpy(bp, lsnp, sizeof(DB_LSN));
 235         bp += sizeof(DB_LSN);
 236         memcpy(bp, &id, sizeof(id));
 237         bp += sizeof(id);
 238 #ifdef DEBUG
 239         if ((u_int32_t)(bp - (u_int8_t *)logrec.data) != logrec.size)
 240                 fprintf(stderr, "Error in log record length");
 241 #endif
 242         ret = __log_put(logp, ret_lsnp, (DBT *)&logrec, flags);
 243         if (txnid != NULL)
 244                 txnid->last_lsn = *ret_lsnp;
 245         __db_free(logrec.data);
 246         return (ret);
 247 }
 248
 249 /*
 250  * PUBLIC: int __log_unregister_print
 251  * PUBLIC:    __P((DB_LOG *, DBT *, DB_LSN *, int, void *));
 252  */
 253
 254 int
 255 __log_unregister_print(notused1, dbtp, lsnp, notused3, notused4)
 256         DB_LOG *notused1;
 257         DBT *dbtp;
 258         DB_LSN *lsnp;
 259         int notused3;
 260         void *notused4;
 261 {
 262         __log_unregister_args *argp;
 263         u_int32_t i;
 264         int c, ret;
 265
 266         i = 0;
 267         c = 0;
 268         notused1 = NULL;
 269         notused3 = 0;
 270         notused4 = NULL;
 271
 272         if ((ret = __log_unregister_read(dbtp->data, &argp)) != 0)
 273                 return (ret);
 274         printf("[%lu][%lu]log_unregister: rec: %lu txnid %lx prevlsn [%lu][%lu]\n",
 275             (u_long)lsnp->file,
 276             (u_long)lsnp->offset,
 277             (u_long)argp->type,
 278             (u_long)argp->txnid->txnid,
 279             (u_long)argp->prev_lsn.file,
 280             (u_long)argp->prev_lsn.offset);
 281         printf("\tid: %lu\n", (u_long)argp->id);
 282         printf("\n");
 283         __db_free(argp);
 284         return (0);
 285 }
 286
 287 /*
 288  * PUBLIC: int __log_unregister_read __P((void *, __log_unregister_args **));
 289  */
 290 int
 291 __log_unregister_read(recbuf, argpp)
 292         void *recbuf;
 293         __log_unregister_args **argpp;
 294 {
 295         __log_unregister_args *argp;
 296         u_int8_t *bp;
 297
 298         argp = (__log_unregister_args *)__db_malloc(sizeof(__log_unregister_args) +
 299             sizeof(DB_TXN));
 300         if (argp == NULL)
 301                 return (ENOMEM);
 302         argp->txnid = (DB_TXN *)&argp[1];
 303         bp = recbuf;
 304         memcpy(&argp->type, bp, sizeof(argp->type));
 305         bp += sizeof(argp->type);
 306         memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
 307         bp += sizeof(argp->txnid->txnid);
 308         memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
 309         bp += sizeof(DB_LSN);
 310         memcpy(&argp->id, bp, sizeof(argp->id));
 311         bp += sizeof(argp->id);
 312         *argpp = argp;
 313         return (0);
 314 }
 315
 316 /*
 317  * PUBLIC: int __log_init_print __P((DB_ENV *));
 318  */
 319 int
 320 __log_init_print(dbenv)
 321         DB_ENV *dbenv;
 322 {
 323         int ret;
 324
 325         if ((ret = __db_add_recovery(dbenv,
 326             __log_register_print, DB_log_register)) != 0)
 327                 return (ret);
 328         if ((ret = __db_add_recovery(dbenv,
 329             __log_unregister_print, DB_log_unregister)) != 0)
 330                 return (ret);
 331         return (0);
 332 }
 333
 334 /*
 335  * PUBLIC: int __log_init_recover __P((DB_ENV *));
 336  */
 337 int
 338 __log_init_recover(dbenv)
 339         DB_ENV *dbenv;
 340 {
 341         int ret;
 342
 343         if ((ret = __db_add_recovery(dbenv,
 344             __log_register_recover, DB_log_register)) != 0)
 345                 return (ret);
 346         if ((ret = __db_add_recovery(dbenv,
 347             __log_unregister_recover, DB_log_unregister)) != 0)
 348                 return (ret);
 349         return (0);
 350 }
 351