Update from db-2.3.12.
[kopensolaris-gnu/glibc.git] / db2 / log / log_put.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_put.c     10.20 (Sleepycat) 11/2/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 <time.h>
21 #include <unistd.h>
22 #endif
23
24 #include "db_int.h"
25 #include "shqueue.h"
26 #include "db_page.h"
27 #include "log.h"
28 #include "hash.h"
29 #include "common_ext.h"
30
31 static int __log_fill __P((DB_LOG *, void *, u_int32_t));
32 static int __log_flush __P((DB_LOG *, const DB_LSN *));
33 static int __log_newfd __P((DB_LOG *));
34 static int __log_putr __P((DB_LOG *, const DBT *, u_int32_t));
35 static int __log_write __P((DB_LOG *, void *, u_int32_t));
36
37 /*
38  * log_put --
39  *      Write a log record.
40  */
41 int
42 log_put(dblp, lsn, dbt, flags)
43         DB_LOG *dblp;
44         DB_LSN *lsn;
45         const DBT *dbt;
46         int flags;
47 {
48         int ret;
49
50         /* Validate arguments. */
51 #define OKFLAGS (DB_CHECKPOINT | DB_FLUSH)
52         if (flags != 0) {
53                 if ((ret =
54                     __db_fchk(dblp->dbenv, "log_put", flags, OKFLAGS)) != 0)
55                         return (ret);
56                 switch (flags) {
57                 case DB_CHECKPOINT:
58                 case DB_FLUSH:
59                 case 0:
60                         break;
61                 default:
62                         return (__db_ferr(dblp->dbenv, "log_put", 1));
63                 }
64         }
65
66         LOCK_LOGREGION(dblp);
67         ret = __log_put(dblp, lsn, dbt, flags);
68         UNLOCK_LOGREGION(dblp);
69         return (ret);
70 }
71
72 /*
73  * __log_put --
74  *      Write a log record; internal version.
75  *
76  * PUBLIC: int __log_put __P((DB_LOG *, DB_LSN *, const DBT *, int));
77  */
78 int
79 __log_put(dblp, lsn, dbt, flags)
80         DB_LOG *dblp;
81         DB_LSN *lsn;
82         const DBT *dbt;
83         int flags;
84 {
85         DBT t;
86         DBT fid_dbt;
87         DB_LSN r_unused;
88         FNAME *fnp;
89         LOG *lp;
90         u_int32_t lastoff;
91         int ret;
92
93         lp = dblp->lp;
94
95         /* If this information won't fit in the file, swap files. */
96         if (lp->lsn.offset + sizeof(HDR) + dbt->size > lp->persist.lg_max) {
97                 if (sizeof(HDR) +
98                     sizeof(LOGP) + dbt->size > lp->persist.lg_max) {
99                         __db_err(dblp->dbenv,
100                             "log_put: record larger than maximum file size");
101                         return (EINVAL);
102                 }
103
104                 /* Flush the log. */
105                 if ((ret = __log_flush(dblp, NULL)) != 0)
106                         return (ret);
107
108                 /*
109                  * Save the last known offset from the previous file, we'll
110                  * need it to initialize the persistent header information.
111                  */
112                 lastoff = lp->lsn.offset;
113
114                 /* Point the current LSN to the new file. */
115                 ++lp->lsn.file;
116                 lp->lsn.offset = 0;
117
118                 /* Reset the file write offset. */
119                 lp->w_off = 0;
120
121                 /* Reset the first-unwritten LSN for the buffer. */
122                 lp->uw_lsn = lp->lsn;
123         } else
124                 lastoff = 0;
125
126         /*
127          * Insert persistent information as the first record in every file.
128          * Note that the previous length is wrong for the very first record
129          * of the log, but that's okay, we check for it during retrieval.
130          */
131         if (lp->lsn.offset == 0) {
132                 t.data = &lp->persist;
133                 t.size = sizeof(LOGP);
134                 if ((ret = __log_putr(dblp,
135                     &t, lastoff == 0 ? 0 : lastoff - lp->len)) != 0)
136                         return (ret);
137         }
138
139         /* Initialize the LSN information returned to the user. */
140         lsn->file = lp->lsn.file;
141         lsn->offset = lp->lsn.offset;
142
143         /* Put out the user's record. */
144         if ((ret = __log_putr(dblp, dbt, lp->lsn.offset - lp->len)) != 0)
145                 return (ret);
146
147         /*
148          * On a checkpoint, we:
149          *      Put out the checkpoint record (above).
150          *      Save the LSN of the checkpoint in the shared region.
151          *      Append the set of file name information into the log.
152          */
153         if (flags == DB_CHECKPOINT) {
154                 lp->c_lsn = *lsn;
155
156                 for (fnp = SH_TAILQ_FIRST(&dblp->lp->fq, __fname);
157                     fnp != NULL; fnp = SH_TAILQ_NEXT(fnp, q, __fname)) {
158                         t.data = R_ADDR(dblp, fnp->name_off);
159                         t.size = strlen(t.data) + 1;
160                         memset(&fid_dbt, 0, sizeof(fid_dbt));
161                         fid_dbt.data = R_ADDR(dblp, fnp->fileid_off);
162                         fid_dbt.size = DB_FILE_ID_LEN;
163                         if ((ret = __log_register_log(dblp, NULL, &r_unused,
164                             0, &t, &fid_dbt, fnp->id, fnp->s_type)) != 0)
165                                 return (ret);
166                 }
167         }
168
169         /*
170          * On a checkpoint or when flush is requested, we:
171          *      Flush the current buffer contents to disk.
172          *      Sync the log to disk.
173          */
174         if (flags == DB_FLUSH || flags == DB_CHECKPOINT)
175                 if ((ret = __log_flush(dblp, NULL)) != 0)
176                         return (ret);
177
178         /*
179          * On a checkpoint, we:
180          *      Save the time the checkpoint was written.
181          *      Reset the bytes written since the last checkpoint.
182          */
183         if (flags == DB_CHECKPOINT) {
184                 (void)time(&lp->chkpt);
185                 lp->stat.st_wc_bytes = lp->stat.st_wc_mbytes = 0;
186         }
187
188         /*
189          * When an application calls the log_flush routine, we need to figure
190          * out if the current buffer needs to be flushed.  The problem is that
191          * if a record spans buffers, it's possible for the record continued
192          * in the current buffer to have begun in a previous buffer.  Each time
193          * we write a buffer, we update the first-unwritten LSN to point to the
194          * first LSN after that written buffer.  If we have a spanning record,
195          * correct that value to be the LSN that started it all, here.
196          */
197         if (lsn->offset < lp->w_off && lsn->offset + lp->len > lp->w_off)
198                 lp->uw_lsn = *lsn;
199
200         return (0);
201 }
202
203 /*
204  * __log_putr --
205  *      Actually put a record into the log.
206  */
207 static int
208 __log_putr(dblp, dbt, prev)
209         DB_LOG *dblp;
210         const DBT *dbt;
211         u_int32_t prev;
212 {
213         HDR hdr;
214         LOG *lp;
215         int ret;
216
217         lp = dblp->lp;
218
219         /*
220          * Initialize the header.  If we just switched files, lsn.offset will
221          * be 0, and what we really want is the offset of the previous record
222          * in the previous file.  Fortunately, prev holds the value we want.
223          */
224         hdr.prev = prev;
225         hdr.len = sizeof(HDR) + dbt->size;
226         hdr.cksum = __ham_func4(dbt->data, dbt->size);
227
228         if ((ret = __log_fill(dblp, &hdr, sizeof(HDR))) != 0)
229                 return (ret);
230         lp->lsn.offset += sizeof(HDR);
231
232         if ((ret = __log_fill(dblp, dbt->data, dbt->size)) != 0)
233                 return (ret);
234         lp->lsn.offset += dbt->size;
235
236         lp->len = sizeof(HDR) + dbt->size;
237         return (0);
238 }
239
240 /*
241  * log_flush --
242  *      Write all records less than or equal to the specified LSN.
243  */
244 int
245 log_flush(dblp, lsn)
246         DB_LOG *dblp;
247         const DB_LSN *lsn;
248 {
249         int ret;
250
251         LOCK_LOGREGION(dblp);
252         ret = __log_flush(dblp, lsn);
253         UNLOCK_LOGREGION(dblp);
254         return (ret);
255 }
256
257 /*
258  * __log_flush --
259  *      Write all records less than or equal to the specified LSN; internal
260  *      version.
261  */
262 static int
263 __log_flush(dblp, lsn)
264         DB_LOG *dblp;
265         const DB_LSN *lsn;
266 {
267         DB_LSN t_lsn;
268         LOG *lp;
269         int ret;
270
271         ret = 0;
272         lp = dblp->lp;
273
274         /*
275          * If no LSN specified, flush the entire log by setting the flush LSN
276          * to the last LSN written in the log.  Otherwise, check that the LSN
277          * isn't a non-existent record for the log.
278          */
279         if (lsn == NULL) {
280                 t_lsn.file = lp->lsn.file;
281                 t_lsn.offset = lp->lsn.offset - lp->len;
282                 lsn = &t_lsn;
283         } else
284                 if (lsn->file > lp->lsn.file ||
285                     (lsn->file == lp->lsn.file &&
286                     lsn->offset > lp->lsn.offset - lp->len)) {
287                         __db_err(dblp->dbenv,
288                             "log_flush: LSN past current end-of-log");
289                         return (EINVAL);
290                 }
291
292         /*
293          * If the LSN is less than the last-sync'd LSN, we're done.  Note,
294          * the last-sync LSN saved in s_lsn is the LSN of the first byte 
295          * that has not yet been written to disk, so the test is <, not <=.
296          */
297         if (lsn->file < lp->s_lsn.file ||
298             (lsn->file == lp->s_lsn.file && lsn->offset < lp->s_lsn.offset))
299                 return (0);
300
301         /*
302          * We may need to write the current buffer.  We have to write the
303          * current buffer if the flush LSN is greater than or equal to the
304          * first-unwritten LSN (uw_lsn).  If we write the buffer, then we
305          * update the first-unwritten LSN.
306          */
307         if (lp->b_off != 0 &&
308             lsn->file >= lp->uw_lsn.file && lsn->offset >= lp->uw_lsn.offset)
309                 if ((ret = __log_write(dblp, lp->buf, lp->b_off)) != 0)
310                         return (ret);
311
312         /*
313          * It's possible that this thread may never have written to this log
314          * file.  Acquire a file descriptor if we don't already have one.
315          */
316         if (dblp->lfname != dblp->lp->lsn.file)
317                 if ((ret = __log_newfd(dblp)) != 0)
318                         return (ret);
319
320         /* Sync all writes to disk. */
321         if ((ret = __db_fsync(dblp->lfd)) != 0)
322                 return (ret);
323         ++lp->stat.st_scount;
324
325         /*
326          * Set the last-synced LSN, the first LSN after the last record
327          * that we know is on disk.
328          */
329         lp->s_lsn = lp->uw_lsn;
330
331         return (0);
332 }
333
334 /*
335  * __log_fill --
336  *      Write information into the log.
337  */
338 static int
339 __log_fill(dblp, addr, len)
340         DB_LOG *dblp;
341         void *addr;
342         u_int32_t len;
343 {
344         LOG *lp;
345         u_int32_t nrec;
346         size_t nw, remain;
347         int ret;
348
349         /* Copy out the data. */
350         for (lp = dblp->lp; len > 0;) {
351                 /*
352                  * If we're on a buffer boundary and the data is big enough,
353                  * copy as many records as we can directly from the data.
354                  */
355                 if (lp->b_off == 0 && len >= sizeof(lp->buf)) {
356                         nrec = len / sizeof(lp->buf);
357                         if ((ret = __log_write(dblp,
358                             addr, nrec * sizeof(lp->buf))) != 0)
359                                 return (ret);
360                         addr = (u_int8_t *)addr + nrec * sizeof(lp->buf);
361                         len -= nrec * sizeof(lp->buf);
362                         continue;
363                 }
364
365                 /* Figure out how many bytes we can copy this time. */
366                 remain = sizeof(lp->buf) - lp->b_off;
367                 nw = remain > len ? len : remain;
368                 memcpy(lp->buf + lp->b_off, addr, nw);
369                 addr = (u_int8_t *)addr + nw;
370                 len -= nw;
371                 lp->b_off += nw;
372
373                 /* If we fill the buffer, flush it. */
374                 if (lp->b_off == sizeof(lp->buf) &&
375                     (ret = __log_write(dblp, lp->buf, sizeof(lp->buf))) != 0)
376                         return (ret);
377         }
378         return (0);
379 }
380
381 /*
382  * __log_write --
383  *      Write the log buffer to disk.
384  */
385 static int
386 __log_write(dblp, addr, len)
387         DB_LOG *dblp;
388         void *addr;
389         u_int32_t len;
390 {
391         LOG *lp;
392         ssize_t nw;
393         int ret;
394
395         /*
396          * If we haven't opened the log file yet or the current one
397          * has changed, acquire a new log file.
398          */
399         lp = dblp->lp;
400         if (dblp->lfd == -1 || dblp->lfname != lp->lsn.file)
401                 if ((ret = __log_newfd(dblp)) != 0)
402                         return (ret);
403
404         /*
405          * Seek to the offset in the file (someone may have written it
406          * since we last did).
407          */
408         if ((ret = __db_seek(dblp->lfd, 0, 0, lp->w_off, SEEK_SET)) != 0)
409                 return (ret);
410         if ((ret = __db_write(dblp->lfd, addr, len, &nw)) != 0)
411                 return (ret);
412         if (nw != (int32_t)len)
413                 return (EIO);
414
415         /*
416          * Reset the buffer offset, update the seek offset, and update the
417          * first-unwritten LSN.
418          */
419         lp->b_off = 0;
420         lp->w_off += len;
421         lp->uw_lsn.file = lp->lsn.file;
422         lp->uw_lsn.offset = lp->w_off;
423
424         /* Update written statistics. */
425         if ((lp->stat.st_w_bytes += len) >= MEGABYTE) {
426                 lp->stat.st_w_bytes -= MEGABYTE;
427                 ++lp->stat.st_w_mbytes;
428         }
429         if ((lp->stat.st_wc_bytes += len) >= MEGABYTE) {
430                 lp->stat.st_wc_bytes -= MEGABYTE;
431                 ++lp->stat.st_wc_mbytes;
432         }
433         ++lp->stat.st_wcount;
434
435         return (0);
436 }
437
438 /*
439  * log_file --
440  *      Map a DB_LSN to a file name.
441  */
442 int
443 log_file(dblp, lsn, namep, len)
444         DB_LOG *dblp;
445         const DB_LSN *lsn;
446         char *namep;
447         size_t len;
448 {
449         int ret;
450         char *p;
451
452         LOCK_LOGREGION(dblp);
453         ret = __log_name(dblp, lsn->file, &p);
454         UNLOCK_LOGREGION(dblp);
455         if (ret != 0)
456                 return (ret);
457
458         /* Check to make sure there's enough room and copy the name. */
459         if (len < strlen(p)) {
460                 *namep = '\0';
461                 return (ENOMEM);
462         }
463         (void)strcpy(namep, p);
464         __db_free(p);
465
466         return (0);
467 }
468
469 /*
470  * __log_newfd --
471  *      Acquire a file descriptor for the current log file.
472  */
473 static int
474 __log_newfd(dblp)
475         DB_LOG *dblp;
476 {
477         int ret;
478         char *p;
479
480         /* Close any previous file descriptor. */
481         if (dblp->lfd != -1) {
482                 (void)__db_close(dblp->lfd);
483                 dblp->lfd = -1;
484         }
485
486         /* Get the path of the new file and open it. */
487         dblp->lfname = dblp->lp->lsn.file;
488         if ((ret = __log_name(dblp, dblp->lfname, &p)) != 0)
489                 return (ret);
490         if ((ret = __db_open(p,
491             DB_CREATE | DB_SEQUENTIAL,
492             DB_CREATE | DB_SEQUENTIAL,
493             dblp->lp->persist.mode, &dblp->lfd)) != 0)
494                 __db_err(dblp->dbenv,
495                     "log_put: %s: %s", p, strerror(ret));
496         FREES(p);
497         return (ret);
498 }
499
500 /*
501  * __log_name --
502  *      Return the log name for a particular file.
503  *
504  * PUBLIC: int __log_name __P((DB_LOG *, int, char **));
505  */
506 int
507 __log_name(dblp, filenumber, namep)
508         DB_LOG *dblp;
509         char **namep;
510         int filenumber;
511 {
512         char name[sizeof(LFNAME) + 10];
513
514         (void)snprintf(name, sizeof(name), LFNAME, filenumber);
515         return (__db_appname(dblp->dbenv,
516             DB_APP_LOG, dblp->dir, name, NULL, namep));
517 }