1/*-
2 * See the file LICENSE for redistribution information.
3 *
4 * Copyright (c) 1996, 1997, 1998
5 *	Sleepycat Software.  All rights reserved.
6 */
7#include "config.h"
8
9#ifndef lint
10static const char sccsid[] = "@(#)log.c	10.63 (Sleepycat) 10/10/98";
11#endif /* not lint */
12
13#ifndef NO_SYSTEM_INCLUDES
14#include <sys/types.h>
15
16#include <errno.h>
17#include <shqueue.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 "log.h"
26#include "db_dispatch.h"
27#include "txn.h"
28#include "txn_auto.h"
29#include "common_ext.h"
30
31static int __log_recover __P((DB_LOG *));
32
33/*
34 * log_open --
35 *	Initialize and/or join a log.
36 */
37int
38log_open(path, flags, mode, dbenv, lpp)
39	const char *path;
40	u_int32_t flags;
41	int mode;
42	DB_ENV *dbenv;
43	DB_LOG **lpp;
44{
45	DB_LOG *dblp;
46	LOG *lp;
47	int ret;
48
49	/* Validate arguments. */
50#ifdef HAVE_SPINLOCKS
51#define	OKFLAGS	(DB_CREATE | DB_THREAD)
52#else
53#define	OKFLAGS	(DB_CREATE)
54#endif
55	if ((ret = __db_fchk(dbenv, "log_open", flags, OKFLAGS)) != 0)
56		return (ret);
57
58	/* Create and initialize the DB_LOG structure. */
59	if ((ret = __os_calloc(1, sizeof(DB_LOG), &dblp)) != 0)
60		return (ret);
61
62	if (path != NULL && (ret = __os_strdup(path, &dblp->dir)) != 0)
63		goto err;
64
65	dblp->dbenv = dbenv;
66	dblp->lfd = -1;
67	ZERO_LSN(dblp->c_lsn);
68	dblp->c_fd = -1;
69
70	/*
71	 * The log region isn't fixed size because we store the registered
72	 * file names there.  Make it fairly large so that we don't have to
73	 * grow it.
74	 */
75#define	DEF_LOG_SIZE	(30 * 1024)
76
77	/* Map in the region. */
78	dblp->reginfo.dbenv = dbenv;
79	dblp->reginfo.appname = DB_APP_LOG;
80	if (path == NULL)
81		dblp->reginfo.path = NULL;
82	else
83		if ((ret = __os_strdup(path, &dblp->reginfo.path)) != 0)
84			goto err;
85	dblp->reginfo.file = DB_DEFAULT_LOG_FILE;
86	dblp->reginfo.mode = mode;
87	dblp->reginfo.size = DEF_LOG_SIZE;
88	dblp->reginfo.dbflags = flags;
89	dblp->reginfo.flags = REGION_SIZEDEF;
90	if ((ret = __db_rattach(&dblp->reginfo)) != 0)
91		goto err;
92
93	/*
94	 * The LOG structure is first in the region, the rest of the region
95	 * is free space.
96	 */
97	dblp->lp = dblp->reginfo.addr;
98	dblp->addr = (u_int8_t *)dblp->lp + sizeof(LOG);
99
100	/* Initialize a created region. */
101	if (F_ISSET(&dblp->reginfo, REGION_CREATED)) {
102		__db_shalloc_init(dblp->addr, DEF_LOG_SIZE - sizeof(LOG));
103
104		/* Initialize the LOG structure. */
105		lp = dblp->lp;
106		lp->persist.lg_max = dbenv == NULL ? 0 : dbenv->lg_max;
107		if (lp->persist.lg_max == 0)
108			lp->persist.lg_max = DEFAULT_MAX;
109		lp->persist.magic = DB_LOGMAGIC;
110		lp->persist.version = DB_LOGVERSION;
111		lp->persist.mode = mode;
112		SH_TAILQ_INIT(&lp->fq);
113
114		/* Initialize LOG LSNs. */
115		lp->lsn.file = 1;
116		lp->lsn.offset = 0;
117	}
118
119	/* Initialize thread information, mutex. */
120	if (LF_ISSET(DB_THREAD)) {
121		F_SET(dblp, DB_AM_THREAD);
122		if ((ret = __db_shalloc(dblp->addr,
123		    sizeof(db_mutex_t), MUTEX_ALIGNMENT, &dblp->mutexp)) != 0)
124			goto err;
125		(void)__db_mutex_init(dblp->mutexp, 0);
126	}
127
128	/*
129	 * If doing recovery, try and recover any previous log files before
130	 * releasing the lock.
131	 */
132	if (F_ISSET(&dblp->reginfo, REGION_CREATED) &&
133	    (ret = __log_recover(dblp)) != 0)
134		goto err;
135
136	UNLOCK_LOGREGION(dblp);
137	*lpp = dblp;
138	return (0);
139
140err:	if (dblp->reginfo.addr != NULL) {
141		if (dblp->mutexp != NULL)
142			__db_shalloc_free(dblp->addr, dblp->mutexp);
143
144		UNLOCK_LOGREGION(dblp);
145		(void)__db_rdetach(&dblp->reginfo);
146		if (F_ISSET(&dblp->reginfo, REGION_CREATED))
147			(void)log_unlink(path, 1, dbenv);
148	}
149
150	if (dblp->reginfo.path != NULL)
151		__os_freestr(dblp->reginfo.path);
152	if (dblp->dir != NULL)
153		__os_freestr(dblp->dir);
154	__os_free(dblp, sizeof(*dblp));
155	return (ret);
156}
157
158/*
159 * __log_panic --
160 *	Panic a log.
161 *
162 * PUBLIC: void __log_panic __P((DB_ENV *));
163 */
164void
165__log_panic(dbenv)
166	DB_ENV *dbenv;
167{
168	if (dbenv->lg_info != NULL)
169		dbenv->lg_info->lp->rlayout.panic = 1;
170}
171
172/*
173 * __log_recover --
174 *	Recover a log.
175 */
176static int
177__log_recover(dblp)
178	DB_LOG *dblp;
179{
180	DBT dbt;
181	DB_LSN lsn;
182	LOG *lp;
183	u_int32_t chk;
184	int cnt, found_checkpoint, ret;
185
186	lp = dblp->lp;
187
188	/*
189	 * Find a log file.  If none exist, we simply return, leaving
190	 * everything initialized to a new log.
191	 */
192	if ((ret = __log_find(dblp, 0, &cnt)) != 0)
193		return (ret);
194	if (cnt == 0)
195		return (0);
196
197	/*
198	 * We have the last useful log file and we've loaded any persistent
199	 * information.  Pretend that the log is larger than it can possibly
200	 * be, and read the last file, looking for the last checkpoint and
201	 * the log's end.
202	 */
203	lp->lsn.file = cnt + 1;
204	lp->lsn.offset = 0;
205	lsn.file = cnt;
206	lsn.offset = 0;
207
208	/* Set the cursor.  Shouldn't fail, leave error messages on. */
209	memset(&dbt, 0, sizeof(dbt));
210	if ((ret = __log_get(dblp, &lsn, &dbt, DB_SET, 0)) != 0)
211		return (ret);
212
213	/*
214	 * Read to the end of the file, saving checkpoints.  This will fail
215	 * at some point, so turn off error messages.
216	 */
217	found_checkpoint = 0;
218	while (__log_get(dblp, &lsn, &dbt, DB_NEXT, 1) == 0) {
219		if (dbt.size < sizeof(u_int32_t))
220			continue;
221		memcpy(&chk, dbt.data, sizeof(u_int32_t));
222		if (chk == DB_txn_ckp) {
223			lp->chkpt_lsn = lsn;
224			found_checkpoint = 1;
225		}
226	}
227
228	/*
229	 * We now know where the end of the log is.  Set the first LSN that
230	 * we want to return to an application and the LSN of the last known
231	 * record on disk.
232	 */
233	lp->lsn = lp->s_lsn = lsn;
234	lp->lsn.offset += dblp->c_len;
235
236	/* Set up the current buffer information, too. */
237	lp->len = dblp->c_len;
238	lp->b_off = 0;
239	lp->w_off = lp->lsn.offset;
240
241	/*
242	 * It's possible that we didn't find a checkpoint because there wasn't
243	 * one in the last log file.  Start searching.
244	 */
245	while (!found_checkpoint && cnt > 1) {
246		lsn.file = --cnt;
247		lsn.offset = 0;
248
249		/* Set the cursor.  Shouldn't fail, leave error messages on. */
250		if ((ret = __log_get(dblp, &lsn, &dbt, DB_SET, 0)) != 0)
251			return (ret);
252
253		/*
254		 * Read to the end of the file, saving checkpoints.  Shouldn't
255		 * fail, leave error messages on.
256		 */
257		while (__log_get(dblp, &lsn, &dbt, DB_NEXT, 0) == 0) {
258			if (dbt.size < sizeof(u_int32_t))
259				continue;
260			memcpy(&chk, dbt.data, sizeof(u_int32_t));
261			if (chk == DB_txn_ckp) {
262				lp->chkpt_lsn = lsn;
263				found_checkpoint = 1;
264			}
265		}
266	}
267	/*
268	 * Reset the cursor lsn to the beginning of the log, so that an
269	 * initial call to DB_NEXT does the right thing.
270	 */
271	ZERO_LSN(dblp->c_lsn);
272
273	/* If we never find a checkpoint, that's okay, just 0 it out. */
274	if (!found_checkpoint)
275		ZERO_LSN(lp->chkpt_lsn);
276
277	/*
278	 * !!!
279	 * The test suite explicitly looks for this string -- don't change
280	 * it here unless you also change it there.
281	 */
282	__db_err(dblp->dbenv,
283	    "Finding last valid log LSN: file: %lu offset %lu",
284	    (u_long)lp->lsn.file, (u_long)lp->lsn.offset);
285
286	return (0);
287}
288
289/*
290 * __log_find --
291 *	Try to find a log file.  If find_first is set, valp will contain
292 * the number of the first log file, else it will contain the number of
293 * the last log file.
294 *
295 * PUBLIC: int __log_find __P((DB_LOG *, int, int *));
296 */
297int
298__log_find(dblp, find_first, valp)
299	DB_LOG *dblp;
300	int find_first, *valp;
301{
302	u_int32_t clv, logval;
303	int cnt, fcnt, ret;
304	const char *dir;
305	char **names, *p, *q;
306
307	*valp = 0;
308
309	/* Find the directory name. */
310	if ((ret = __log_name(dblp, 1, &p, NULL, 0)) != 0)
311		return (ret);
312	if ((q = __db_rpath(p)) == NULL)
313		dir = PATH_DOT;
314	else {
315		*q = '\0';
316		dir = p;
317	}
318
319	/* Get the list of file names. */
320	ret = __os_dirlist(dir, &names, &fcnt);
321	__os_freestr(p);
322	if (ret != 0) {
323		__db_err(dblp->dbenv, "%s: %s", dir, strerror(ret));
324		return (ret);
325	}
326
327	/*
328	 * Search for a valid log file name, return a value of 0 on
329	 * failure.
330	 *
331	 * XXX
332	 * Assumes that atoi(3) returns a 32-bit number.
333	 */
334	for (cnt = fcnt, clv = logval = 0; --cnt >= 0;) {
335		if (strncmp(names[cnt], LFPREFIX, sizeof(LFPREFIX) - 1) != 0)
336			continue;
337
338		clv = atoi(names[cnt] + (sizeof(LFPREFIX) - 1));
339		if (find_first) {
340			if (logval != 0 && clv > logval)
341				continue;
342		} else
343			if (logval != 0 && clv < logval)
344				continue;
345
346		if (__log_valid(dblp, clv, 1) == 0)
347			logval = clv;
348	}
349
350	*valp = logval;
351
352	/* Discard the list. */
353	__os_dirfree(names, fcnt);
354
355	return (0);
356}
357
358/*
359 * log_valid --
360 *	Validate a log file.
361 *
362 * PUBLIC: int __log_valid __P((DB_LOG *, u_int32_t, int));
363 */
364int
365__log_valid(dblp, number, set_persist)
366	DB_LOG *dblp;
367	u_int32_t number;
368	int set_persist;
369{
370	LOGP persist;
371	ssize_t nw;
372	char *fname;
373	int fd, ret;
374
375	/* Try to open the log file. */
376	if ((ret = __log_name(dblp,
377	    number, &fname, &fd, DB_RDONLY | DB_SEQUENTIAL)) != 0) {
378		__os_freestr(fname);
379		return (ret);
380	}
381
382	/* Try to read the header. */
383	if ((ret = __os_seek(fd, 0, 0, sizeof(HDR), 0, SEEK_SET)) != 0 ||
384	    (ret = __os_read(fd, &persist, sizeof(LOGP), &nw)) != 0 ||
385	    nw != sizeof(LOGP)) {
386		if (ret == 0)
387			ret = EIO;
388
389		(void)__os_close(fd);
390
391		__db_err(dblp->dbenv,
392		    "Ignoring log file: %s: %s", fname, strerror(ret));
393		goto err;
394	}
395	(void)__os_close(fd);
396
397	/* Validate the header. */
398	if (persist.magic != DB_LOGMAGIC) {
399		__db_err(dblp->dbenv,
400		    "Ignoring log file: %s: magic number %lx, not %lx",
401		    fname, (u_long)persist.magic, (u_long)DB_LOGMAGIC);
402		ret = EINVAL;
403		goto err;
404	}
405	if (persist.version < DB_LOGOLDVER || persist.version > DB_LOGVERSION) {
406		__db_err(dblp->dbenv,
407		    "Ignoring log file: %s: unsupported log version %lu",
408		    fname, (u_long)persist.version);
409		ret = EINVAL;
410		goto err;
411	}
412
413	/*
414	 * If we're going to use this log file, set the region's persistent
415	 * information based on the headers.
416	 */
417	if (set_persist) {
418		dblp->lp->persist.lg_max = persist.lg_max;
419		dblp->lp->persist.mode = persist.mode;
420	}
421	ret = 0;
422
423err:	__os_freestr(fname);
424	return (ret);
425}
426
427/*
428 * log_close --
429 *	Close a log.
430 */
431int
432log_close(dblp)
433	DB_LOG *dblp;
434{
435	u_int32_t i;
436	int ret, t_ret;
437
438	LOG_PANIC_CHECK(dblp);
439
440	/* We may have opened files as part of XA; if so, close them. */
441	__log_close_files(dblp);
442
443	/* Discard the per-thread pointer. */
444	if (dblp->mutexp != NULL) {
445		LOCK_LOGREGION(dblp);
446		__db_shalloc_free(dblp->addr, dblp->mutexp);
447		UNLOCK_LOGREGION(dblp);
448	}
449
450	/* Close the region. */
451	ret = __db_rdetach(&dblp->reginfo);
452
453	/* Close open files, release allocated memory. */
454	if (dblp->lfd != -1 && (t_ret = __os_close(dblp->lfd)) != 0 && ret == 0)
455		ret = t_ret;
456	if (dblp->c_dbt.data != NULL)
457		__os_free(dblp->c_dbt.data, dblp->c_dbt.ulen);
458	if (dblp->c_fd != -1 &&
459	    (t_ret = __os_close(dblp->c_fd)) != 0 && ret == 0)
460		ret = t_ret;
461	if (dblp->dbentry != NULL) {
462		for (i = 0; i < dblp->dbentry_cnt; i++)
463			if (dblp->dbentry[i].name != NULL)
464				__os_freestr(dblp->dbentry[i].name);
465		__os_free(dblp->dbentry,
466		    (dblp->dbentry_cnt * sizeof(DB_ENTRY)));
467	}
468
469	if (dblp->dir != NULL)
470		__os_freestr(dblp->dir);
471
472	if (dblp->reginfo.path != NULL)
473		__os_freestr(dblp->reginfo.path);
474	__os_free(dblp, sizeof(*dblp));
475
476	return (ret);
477}
478
479/*
480 * log_unlink --
481 *	Exit a log.
482 */
483int
484log_unlink(path, force, dbenv)
485	const char *path;
486	int force;
487	DB_ENV *dbenv;
488{
489	REGINFO reginfo;
490	int ret;
491
492	memset(&reginfo, 0, sizeof(reginfo));
493	reginfo.dbenv = dbenv;
494	reginfo.appname = DB_APP_LOG;
495	if (path != NULL && (ret = __os_strdup(path, &reginfo.path)) != 0)
496		return (ret);
497	reginfo.file = DB_DEFAULT_LOG_FILE;
498	ret = __db_runlink(&reginfo, force);
499	if (reginfo.path != NULL)
500		__os_freestr(reginfo.path);
501	return (ret);
502}
503
504/*
505 * log_stat --
506 *	Return LOG statistics.
507 */
508int
509log_stat(dblp, gspp, db_malloc)
510	DB_LOG *dblp;
511	DB_LOG_STAT **gspp;
512	void *(*db_malloc) __P((size_t));
513{
514	LOG *lp;
515	int ret;
516
517	*gspp = NULL;
518	lp = dblp->lp;
519
520	LOG_PANIC_CHECK(dblp);
521
522	if ((ret = __os_malloc(sizeof(**gspp), db_malloc, gspp)) != 0)
523		return (ret);
524
525	/* Copy out the global statistics. */
526	LOCK_LOGREGION(dblp);
527	**gspp = lp->stat;
528
529	(*gspp)->st_magic = lp->persist.magic;
530	(*gspp)->st_version = lp->persist.version;
531	(*gspp)->st_mode = lp->persist.mode;
532	(*gspp)->st_lg_max = lp->persist.lg_max;
533
534	(*gspp)->st_region_nowait = lp->rlayout.lock.mutex_set_nowait;
535	(*gspp)->st_region_wait = lp->rlayout.lock.mutex_set_wait;
536
537	(*gspp)->st_cur_file = lp->lsn.file;
538	(*gspp)->st_cur_offset = lp->lsn.offset;
539
540	(*gspp)->st_refcnt = lp->rlayout.refcnt;
541	(*gspp)->st_regsize = lp->rlayout.size;
542
543	UNLOCK_LOGREGION(dblp);
544
545	return (0);
546}
547