Update from db-2.3.12.
[kopensolaris-gnu/glibc.git] / db2 / log / log_get.c
1 /*-
2  * See the file LICENSE for redistribution information.
3  *
4  * Copyright (c) 1996, 1997
5  *      Sleepycat Software.  All rights reserved.
6  */
7 #include "config.h"
8
9 #ifndef lint
10 static const char sccsid[] = "@(#)log_get.c     10.21 (Sleepycat) 10/25/97";
11 #endif /* not lint */
12
13 #ifndef NO_SYSTEM_INCLUDES
14 #include <sys/types.h>
15
16 #include <errno.h>
17 #include <fcntl.h>
18 #include <stdlib.h>
19 #include <string.h>
20 #include <unistd.h>
21 #endif
22
23 #include "db_int.h"
24 #include "shqueue.h"
25 #include "db_page.h"
26 #include "log.h"
27 #include "hash.h"
28 #include "common_ext.h"
29
30 /*
31  * log_get --
32  *      Get a log record.
33  */
34 int
35 log_get(dblp, alsn, dbt, flags)
36         DB_LOG *dblp;
37         DB_LSN *alsn;
38         DBT *dbt;
39         int flags;
40 {
41         LOG *lp;
42         int ret;
43
44         /* Validate arguments. */
45 #define OKFLAGS (DB_CHECKPOINT | \
46     DB_CURRENT | DB_FIRST | DB_LAST | DB_NEXT | DB_PREV | DB_SET)
47         if (flags != 0) {
48                 if ((ret =
49                     __db_fchk(dblp->dbenv, "log_get", flags, OKFLAGS)) != 0)
50                         return (ret);
51                 switch (flags) {
52                 case DB_CHECKPOINT:
53                 case DB_CURRENT:
54                 case DB_FIRST:
55                 case DB_LAST:
56                 case DB_NEXT:
57                 case DB_PREV:
58                 case DB_SET:
59                 case 0:
60                         break;
61                 default:
62                         return (__db_ferr(dblp->dbenv, "log_get", 1));
63                 }
64         }
65         if (F_ISSET(dblp, DB_AM_THREAD)) {
66                 if (LF_ISSET(DB_NEXT | DB_PREV | DB_CURRENT))
67                         return (__db_ferr(dblp->dbenv, "log_get", 1));
68                 if (!F_ISSET(dbt, DB_DBT_USERMEM | DB_DBT_MALLOC))
69                         return (__db_ferr(dblp->dbenv, "threaded data", 1));
70         }
71
72         lp = dblp->lp;
73
74         LOCK_LOGREGION(dblp);
75
76         /*
77          * If we get one of the log's header records, repeat the operation.
78          * This assumes that applications don't ever request the log header
79          * records by LSN, but that seems reasonable to me.
80          */
81         ret = __log_get(dblp, alsn, dbt, flags, 0);
82         if (ret == 0 && alsn->offset == 0) {
83                 switch (flags) {
84                 case DB_FIRST:
85                         flags = DB_NEXT;
86                         break;
87                 case DB_LAST:
88                         flags = DB_PREV;
89                         break;
90                 }
91                 ret = __log_get(dblp, alsn, dbt, flags, 0);
92         }
93
94         UNLOCK_LOGREGION(dblp);
95
96         return (ret);
97 }
98
99 /*
100  * __log_get --
101  *      Get a log record; internal version.
102  *
103  * PUBLIC: int __log_get __P((DB_LOG *, DB_LSN *, DBT *, int, int));
104  */
105 int
106 __log_get(dblp, alsn, dbt, flags, silent)
107         DB_LOG *dblp;
108         DB_LSN *alsn;
109         DBT *dbt;
110         int flags, silent;
111 {
112         DB_LSN nlsn;
113         HDR hdr;
114         LOG *lp;
115         size_t len;
116         ssize_t nr;
117         int cnt, ret;
118         char *np, *tbuf;
119         const char *fail;
120         void *p, *shortp;
121
122         lp = dblp->lp;
123         fail = np = tbuf = NULL;
124
125         nlsn = dblp->c_lsn;
126         switch (flags) {
127         case DB_CHECKPOINT:
128                 nlsn = dblp->lp->c_lsn;
129                 if (IS_ZERO_LSN(nlsn)) {
130                         __db_err(dblp->dbenv,
131         "log_get: unable to find checkpoint record: no checkpoint set.");
132                         ret = ENOENT;
133                         goto err2;
134                 }
135                 break;
136         case DB_NEXT:                           /* Next log record. */
137                 if (!IS_ZERO_LSN(nlsn)) {
138                         /* Increment the cursor by the cursor record size. */
139                         nlsn.offset += dblp->c_len;
140                         break;
141                 }
142                 /* FALLTHROUGH */
143         case DB_FIRST:                          /* Find the first log record. */
144                 /*
145                  * Find any log file.  Note, we may have only entered records
146                  * in the buffer, and not yet written a log file.
147                  */
148                 if ((ret = __log_find(dblp, &cnt)) != 0) {
149                         __db_err(dblp->dbenv,
150         "log_get: unable to find the first record: no log files found.");
151                         goto err2;
152                 }
153
154                 /* If there's anything in the buffer, it belongs to file 1. */
155                 if (cnt == 0)
156                         cnt = 1;
157
158                 /* Now go backwards to find the smallest one. */
159                 for (; cnt > 1; --cnt)
160                         if (__log_valid(dblp, NULL, cnt) != 0) {
161                                 ++cnt;
162                                 break;
163                         }
164                 nlsn.file = cnt;
165                 nlsn.offset = 0;
166                 break;
167         case DB_CURRENT:                        /* Current log record. */
168                 break;
169         case DB_PREV:                           /* Previous log record. */
170                 if (!IS_ZERO_LSN(nlsn)) {
171                         /* If at start-of-file, move to the previous file. */
172                         if (nlsn.offset == 0) {
173                                 if (nlsn.file == 1 ||
174                                     __log_valid(dblp, NULL, nlsn.file - 1) != 0)
175                                         return (DB_NOTFOUND);
176
177                                 --nlsn.file;
178                                 nlsn.offset = dblp->c_off;
179                         } else
180                                 nlsn.offset = dblp->c_off;
181                         break;
182                 }
183                 /* FALLTHROUGH */
184         case DB_LAST:                           /* Last log record. */
185                 nlsn.file = lp->lsn.file;
186                 nlsn.offset = lp->lsn.offset - lp->len;
187                 break;
188         case DB_SET:                            /* Set log record. */
189                 nlsn = *alsn;
190                 break;
191         }
192
193 retry:
194         /* Return 1 if the request is past end-of-file. */
195         if (nlsn.file > lp->lsn.file ||
196             (nlsn.file == lp->lsn.file && nlsn.offset >= lp->lsn.offset))
197                 return (DB_NOTFOUND);
198
199         /* If we've switched files, discard the current fd. */
200         if (dblp->c_lsn.file != nlsn.file && dblp->c_fd != -1) {
201                 (void)__db_close(dblp->c_fd);
202                 dblp->c_fd = -1;
203         }
204
205         /* If the entire record is in the in-memory buffer, copy it out. */
206         if (nlsn.file == lp->lsn.file && nlsn.offset >= lp->w_off) {
207                 /* Copy the header. */
208                 p = lp->buf + (nlsn.offset - lp->w_off);
209                 memcpy(&hdr, p, sizeof(HDR));
210
211                 /* Copy the record. */
212                 len = hdr.len - sizeof(HDR);
213                 if ((ret = __db_retcopy(dbt, (u_int8_t *)p + sizeof(HDR),
214                     len, &dblp->c_dbt.data, &dblp->c_dbt.ulen, NULL)) != 0)
215                         goto err1;
216                 goto cksum;
217         }
218
219         /* Acquire a file descriptor. */
220         if (dblp->c_fd == -1) {
221                 if ((ret = __log_name(dblp, nlsn.file, &np)) != 0)
222                         goto err1;
223                 if ((ret = __db_open(np, DB_RDONLY | DB_SEQUENTIAL,
224                     DB_RDONLY | DB_SEQUENTIAL, 0, &dblp->c_fd)) != 0) {
225                         fail = np;
226                         goto err1;
227                 }
228                 __db_free(np);
229                 np = NULL;
230         }
231
232         /* Seek to the header offset and read the header. */
233         if ((ret = __db_seek(dblp->c_fd, 0, 0, nlsn.offset, SEEK_SET)) != 0) {
234                 fail = "seek";
235                 goto err1;
236         }
237         if ((ret = __db_read(dblp->c_fd, &hdr, sizeof(HDR), &nr)) != 0) {
238                 fail = "read";
239                 goto err1;
240         }
241         if (nr == sizeof(HDR))
242                 shortp = NULL;
243         else {
244                 /* If read returns EOF, try the next file. */
245                 if (nr == 0) {
246                         if (flags != DB_NEXT || nlsn.file == lp->lsn.file)
247                                 goto corrupt;
248
249                         /* Move to the next file. */
250                         ++nlsn.file;
251                         nlsn.offset = 0;
252                         goto retry;
253                 }
254
255                 /*
256                  * If read returns a short count the rest of the record has
257                  * to be in the in-memory buffer.
258                  */
259                 if (lp->b_off < sizeof(HDR) - nr)
260                         goto corrupt;
261
262                 /* Get the rest of the header from the in-memory buffer. */
263                 memcpy((u_int8_t *)&hdr + nr, lp->buf, sizeof(HDR) - nr);
264                 shortp = lp->buf + (sizeof(HDR) - nr);
265         }
266
267         /*
268          * Check for buffers of 0's, that's what we usually see during
269          * recovery, although it's certainly not something on which we
270          * can depend.
271          */
272         if (hdr.len <= sizeof(HDR))
273                 goto corrupt;
274         len = hdr.len - sizeof(HDR);
275
276         /* If we've already moved to the in-memory buffer, fill from there. */
277         if (shortp != NULL) {
278                 if (lp->b_off < ((u_int8_t *)shortp - lp->buf) + len)
279                         goto corrupt;
280                 if ((ret = __db_retcopy(dbt, shortp, len,
281                     &dblp->c_dbt.data, &dblp->c_dbt.ulen, NULL)) != 0)
282                         goto err1;
283                 goto cksum;
284         }
285
286         /* Allocate temporary memory to hold the record. */
287         if ((tbuf = (char *)__db_malloc(len)) == NULL) {
288                 ret = ENOMEM;
289                 goto err1;
290         }
291
292         /*
293          * Read the record into the buffer.  If read returns a short count,
294          * there was an error or the rest of the record is in the in-memory
295          * buffer.  Note, the information may be garbage if we're in recovery,
296          * so don't read past the end of the buffer's memory.
297          */
298         if ((ret = __db_read(dblp->c_fd, tbuf, len, &nr)) != 0) {
299                 fail = "read";
300                 goto err1;
301         }
302         if (len - nr > sizeof(lp->buf))
303                 goto corrupt;
304         if (nr != (ssize_t)len) {
305                 if (lp->b_off < len - nr)
306                         goto corrupt;
307
308                 /* Get the rest of the record from the in-memory buffer. */
309                 memcpy((u_int8_t *)tbuf + nr, lp->buf, len - nr);
310         }
311
312         /* Copy the record into the user's DBT. */
313         if ((ret = __db_retcopy(dbt, tbuf, len,
314             &dblp->c_dbt.data, &dblp->c_dbt.ulen, NULL)) != 0)
315                 goto err1;
316         __db_free(tbuf);
317         tbuf = NULL;
318
319 cksum:  if (hdr.cksum != __ham_func4(dbt->data, dbt->size)) {
320                 if (!silent)
321                         __db_err(dblp->dbenv, "log_get: checksum mismatch");
322                 goto corrupt;
323         }
324
325         /* Update the cursor and the return lsn. */
326         dblp->c_off = hdr.prev;
327         dblp->c_len = hdr.len;
328         dblp->c_lsn = *alsn = nlsn;
329
330         return (0);
331
332 corrupt:/*
333          * This is the catchall -- for some reason we didn't find enough
334          * information or it wasn't reasonable information, and it wasn't
335          * because a system call failed.
336          */
337         ret = EIO;
338         fail = "read";
339
340 err1:   if (!silent)
341                 if (fail == NULL)
342                         __db_err(dblp->dbenv, "log_get: %s", strerror(ret));
343                 else
344                         __db_err(dblp->dbenv,
345                             "log_get: %s: %s", fail, strerror(ret));
346 err2:   if (np != NULL)
347                 __db_free(np);
348         if (tbuf != NULL)
349                 __db_free(tbuf);
350         return (ret);
351 }