Update from db-2.3.12.
[kopensolaris-gnu/glibc.git] / 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