1/*-
2 * See the file LICENSE for redistribution information.
3 *
4 * Copyright (c) 1997,2008 Oracle.  All rights reserved.
5 *
6 * $Id: log_archive.c,v 12.34 2008/02/26 01:34:55 ubell Exp $
7 */
8
9#include "db_config.h"
10
11#include "db_int.h"
12#include "dbinc/db_page.h"
13#include "dbinc/log.h"
14#include "dbinc/qam.h"
15#include "dbinc/txn.h"
16
17static int __absname __P((ENV *, char *, char *, char **));
18static int __build_data __P((ENV *, char *, char ***));
19static int __cmpfunc __P((const void *, const void *));
20static int __log_archive __P((ENV *, char **[], u_int32_t));
21static int __usermem __P((ENV *, char ***));
22
23/*
24 * __log_archive_pp --
25 *	ENV->log_archive pre/post processing.
26 *
27 * PUBLIC: int __log_archive_pp __P((DB_ENV *, char **[], u_int32_t));
28 */
29int
30__log_archive_pp(dbenv, listp, flags)
31	DB_ENV *dbenv;
32	char ***listp;
33	u_int32_t flags;
34{
35	DB_THREAD_INFO *ip;
36	ENV *env;
37	int ret;
38
39	env = dbenv->env;
40
41	ENV_REQUIRES_CONFIG(env,
42	    env->lg_handle, "DB_ENV->log_archive", DB_INIT_LOG);
43
44#define	OKFLAGS	(DB_ARCH_ABS | DB_ARCH_DATA | DB_ARCH_LOG | DB_ARCH_REMOVE)
45	if (flags != 0) {
46		if ((ret = __db_fchk(
47		    env, "DB_ENV->log_archive", flags, OKFLAGS)) != 0)
48			return (ret);
49		if ((ret = __db_fcchk(env, "DB_ENV->log_archive",
50		    flags, DB_ARCH_DATA, DB_ARCH_LOG)) != 0)
51			return (ret);
52		if ((ret = __db_fcchk(env, "DB_ENV->log_archive",
53		    flags, DB_ARCH_REMOVE,
54		    DB_ARCH_ABS | DB_ARCH_DATA | DB_ARCH_LOG)) != 0)
55			return (ret);
56	}
57
58	ENV_ENTER(env, ip);
59	REPLICATION_WRAP(env, (__log_archive(env, listp, flags)), 0, ret);
60	ENV_LEAVE(env, ip);
61	return (ret);
62}
63
64/*
65 * __log_archive --
66 *	ENV->log_archive.  Internal.
67 */
68static int
69__log_archive(env, listp, flags)
70	ENV *env;
71	char ***listp;
72	u_int32_t flags;
73{
74	DBT rec;
75	DB_LOG *dblp;
76	DB_LOGC *logc;
77	DB_LSN stable_lsn;
78	LOG *lp;
79	u_int array_size, n;
80	u_int32_t fnum;
81	int ret, t_ret;
82	char **array, **arrayp, *name, *p, *pref;
83#ifdef HAVE_GETCWD
84	char path[DB_MAXPATHLEN];
85#endif
86
87	dblp = env->lg_handle;
88	lp = (LOG *)dblp->reginfo.primary;
89	array = NULL;
90	name = NULL;
91	ret = 0;
92	COMPQUIET(fnum, 0);
93
94	if (flags != DB_ARCH_REMOVE)
95		*listp = NULL;
96
97	/* There are no log files if logs are in memory. */
98	if (lp->db_log_inmemory) {
99		LF_CLR(~DB_ARCH_DATA);
100		if (flags == 0)
101			return (0);
102	}
103
104	/*
105	 * If the user wants the list of log files to remove and we're
106	 * at a bad time in replication initialization, just return.
107	 */
108	if (!LF_ISSET(DB_ARCH_DATA) &&
109	    !LF_ISSET(DB_ARCH_LOG) && __rep_noarchive(env))
110		return (0);
111
112	/*
113	 * Prepend the original absolute pathname if the user wants an
114	 * absolute path to the database environment directory.
115	 */
116#ifdef HAVE_GETCWD
117	if (LF_ISSET(DB_ARCH_ABS)) {
118		/*
119		 * XXX
120		 * Can't trust getcwd(3) to set a valid errno, so don't display
121		 * one unless we know it's good.  It's likely a permissions
122		 * problem: use something bland and useless in the default
123		 * return value, so we don't send somebody off in the wrong
124		 * direction.
125		 */
126		__os_set_errno(0);
127		if (getcwd(path, sizeof(path)) == NULL) {
128			ret = __os_get_errno();
129			__db_err(env,
130			    ret, "no absolute path for the current directory");
131			return (ret);
132		}
133		pref = path;
134	} else
135#endif
136		pref = NULL;
137
138	LF_CLR(DB_ARCH_ABS);
139	switch (flags) {
140	case DB_ARCH_DATA:
141		ret = __build_data(env, pref, listp);
142		goto err;
143	case DB_ARCH_LOG:
144		memset(&rec, 0, sizeof(rec));
145		if ((ret = __log_cursor(env, &logc)) != 0)
146			goto err;
147#ifdef UMRW
148		ZERO_LSN(stable_lsn);
149#endif
150		ret = __logc_get(logc, &stable_lsn, &rec, DB_LAST);
151		if ((t_ret = __logc_close(logc)) != 0 && ret == 0)
152			ret = t_ret;
153		if (ret != 0)
154			goto err;
155		fnum = stable_lsn.file;
156		break;
157	case DB_ARCH_REMOVE:
158		__log_autoremove(env);
159		goto err;
160	case 0:
161
162		ret = __log_get_stable_lsn(env, &stable_lsn);
163		/*
164		 * A return of DB_NOTFOUND means the checkpoint LSN
165		 * is before the beginning of the log files we have.
166		 * This is not an error; it just means we're done.
167		 */
168		if (ret != 0) {
169			if (ret == DB_NOTFOUND)
170				ret = 0;
171			goto err;
172		}
173		/* Remove any log files before the last stable LSN. */
174		fnum = stable_lsn.file - 1;
175		break;
176	default:
177		ret = __db_unknown_path(env, "__log_archive");
178		goto err;
179	}
180
181#define	LIST_INCREMENT	64
182	/* Get some initial space. */
183	array_size = 64;
184	if ((ret = __os_malloc(env,
185	    sizeof(char *) * array_size, &array)) != 0)
186		goto err;
187	array[0] = NULL;
188
189	/* Build an array of the file names. */
190	for (n = 0; fnum > 0; --fnum) {
191		if ((ret = __log_name(dblp, fnum, &name, NULL, 0)) != 0) {
192			__os_free(env, name);
193			goto err;
194		}
195		if (__os_exists(env, name, NULL) != 0) {
196			if (LF_ISSET(DB_ARCH_LOG) && fnum == stable_lsn.file)
197				continue;
198			__os_free(env, name);
199			name = NULL;
200			break;
201		}
202
203		if (n >= array_size - 2) {
204			array_size += LIST_INCREMENT;
205			if ((ret = __os_realloc(env,
206			    sizeof(char *) * array_size, &array)) != 0)
207				goto err;
208		}
209
210		if (pref != NULL) {
211			if ((ret =
212			    __absname(env, pref, name, &array[n])) != 0)
213				goto err;
214			__os_free(env, name);
215		} else if ((p = __db_rpath(name)) != NULL) {
216			if ((ret = __os_strdup(env, p + 1, &array[n])) != 0)
217				goto err;
218			__os_free(env, name);
219		} else
220			array[n] = name;
221
222		name = NULL;
223		array[++n] = NULL;
224	}
225
226	/* If there's nothing to return, we're done. */
227	if (n == 0)
228		goto err;
229
230	/* Sort the list. */
231	qsort(array, (size_t)n, sizeof(char *), __cmpfunc);
232
233	/* Rework the memory. */
234	if ((ret = __usermem(env, &array)) != 0)
235		goto err;
236
237	if (listp != NULL)
238		*listp = array;
239
240	if (0) {
241err:		if (array != NULL) {
242			for (arrayp = array; *arrayp != NULL; ++arrayp)
243				__os_free(env, *arrayp);
244			__os_free(env, array);
245		}
246		if (name != NULL)
247			__os_free(env, name);
248	}
249
250	return (ret);
251}
252
253/*
254 * __log_get_stable_lsn --
255 *	Get the stable lsn based on where checkpoints are.
256 *
257 * PUBLIC: int __log_get_stable_lsn __P((ENV *, DB_LSN *));
258 */
259int
260__log_get_stable_lsn(env, stable_lsn)
261	ENV *env;
262	DB_LSN *stable_lsn;
263{
264	DBT rec;
265	DB_LOGC *logc;
266	LOG *lp;
267	__txn_ckp_args *ckp_args;
268	int ret, t_ret;
269
270	lp = env->lg_handle->reginfo.primary;
271
272	ret = 0;
273	memset(&rec, 0, sizeof(rec));
274	if (!TXN_ON(env)) {
275		if ((ret = __log_get_cached_ckp_lsn(env, stable_lsn)) != 0)
276			goto err;
277		/*
278		 * No need to check for a return value of DB_NOTFOUND;
279		 * __txn_findlastckp returns 0 if no checkpoint record
280		 * is found.  Instead of checking the return value, we
281		 * check to see if the return LSN has been filled in.
282		 */
283		if (IS_ZERO_LSN(*stable_lsn) && (ret =
284		     __txn_findlastckp(env, stable_lsn, NULL)) != 0)
285			goto err;
286		/*
287		 * If the LSN has not been filled in return DB_NOTFOUND
288		 * so that the caller knows it may be done.
289		 */
290		if (IS_ZERO_LSN(*stable_lsn)) {
291			ret = DB_NOTFOUND;
292			goto err;
293		}
294	} else if ((ret = __txn_getckp(env, stable_lsn)) != 0)
295		goto err;
296	if ((ret = __log_cursor(env, &logc)) != 0)
297		goto err;
298	/*
299	 * Read checkpoint records until we find one that is on disk,
300	 * then copy the ckp_lsn to the stable_lsn;
301	 */
302	while ((ret = __logc_get(logc, stable_lsn, &rec, DB_SET)) == 0 &&
303	    (ret = __txn_ckp_read(env, rec.data, &ckp_args)) == 0) {
304		if (stable_lsn->file < lp->s_lsn.file ||
305		    (stable_lsn->file == lp->s_lsn.file &&
306		    stable_lsn->offset < lp->s_lsn.offset)) {
307			*stable_lsn = ckp_args->ckp_lsn;
308			__os_free(env, ckp_args);
309			break;
310		}
311		*stable_lsn = ckp_args->last_ckp;
312		__os_free(env, ckp_args);
313	}
314	if ((t_ret = __logc_close(logc)) != 0 && ret == 0)
315		ret = t_ret;
316err:
317	return (ret);
318}
319
320/*
321 * __log_autoremove --
322 *	Delete any non-essential log files.
323 *
324 * PUBLIC: void __log_autoremove __P((ENV *));
325 */
326void
327__log_autoremove(env)
328	ENV *env;
329{
330	int ret;
331	char **begin, **list;
332
333	/*
334	 * Complain if there's an error, but don't return the error to our
335	 * caller.  Auto-remove is done when writing a log record, and we
336	 * don't want to fail a write, which could fail the corresponding
337	 * committing transaction, for a permissions error.
338	 */
339	if ((ret = __log_archive(env, &list, DB_ARCH_ABS)) != 0) {
340		if (ret != DB_NOTFOUND)
341			__db_err(env, ret, "log file auto-remove");
342		return;
343	}
344
345	/* Remove the files. */
346	if (list != NULL) {
347		for (begin = list; *list != NULL; ++list)
348			(void)__os_unlink(env, *list, 0);
349		__os_ufree(env, begin);
350	}
351}
352
353/*
354 * __build_data --
355 *	Build a list of datafiles for return.
356 */
357static int
358__build_data(env, pref, listp)
359	ENV *env;
360	char *pref, ***listp;
361{
362	DBT rec;
363	DB_LOGC *logc;
364	DB_LSN lsn;
365	__dbreg_register_args *argp;
366	u_int array_size, last, n, nxt;
367	u_int32_t rectype;
368	int ret, t_ret;
369	char **array, **arrayp, **list, **lp, *p, *real_name;
370
371	/* Get some initial space. */
372	array_size = 64;
373	if ((ret = __os_malloc(env,
374	    sizeof(char *) * array_size, &array)) != 0)
375		return (ret);
376	array[0] = NULL;
377
378	memset(&rec, 0, sizeof(rec));
379	if ((ret = __log_cursor(env, &logc)) != 0)
380		return (ret);
381	for (n = 0; (ret = __logc_get(logc, &lsn, &rec, DB_PREV)) == 0;) {
382		if (rec.size < sizeof(rectype)) {
383			ret = EINVAL;
384			__db_errx(env, "DB_ENV->log_archive: bad log record");
385			break;
386		}
387
388		LOGCOPY_32(env, &rectype, rec.data);
389		if (rectype != DB___dbreg_register)
390			continue;
391		if ((ret =
392		    __dbreg_register_read(env, rec.data, &argp)) != 0) {
393			ret = EINVAL;
394			__db_errx(env,
395			    "DB_ENV->log_archive: unable to read log record");
396			break;
397		}
398
399		if (n >= array_size - 2) {
400			array_size += LIST_INCREMENT;
401			if ((ret = __os_realloc(env,
402			    sizeof(char *) * array_size, &array)) != 0)
403				goto free_continue;
404		}
405
406		if ((ret = __os_strdup(env,
407		    argp->name.data, &array[n++])) != 0)
408			goto free_continue;
409		array[n] = NULL;
410
411		if (argp->ftype == DB_QUEUE) {
412			if ((ret = __qam_extent_names(env,
413			    argp->name.data, &list)) != 0)
414				goto q_err;
415			for (lp = list;
416			    lp != NULL && *lp != NULL; lp++) {
417				if (n >= array_size - 2) {
418					array_size += LIST_INCREMENT;
419					if ((ret = __os_realloc(env,
420					    sizeof(char *) *
421					    array_size, &array)) != 0)
422						goto q_err;
423				}
424				if ((ret =
425				    __os_strdup(env, *lp, &array[n++])) != 0)
426					goto q_err;
427				array[n] = NULL;
428			}
429q_err:			if (list != NULL)
430				__os_free(env, list);
431		}
432free_continue:	__os_free(env, argp);
433		if (ret != 0)
434			break;
435	}
436	if (ret == DB_NOTFOUND)
437		ret = 0;
438	if ((t_ret = __logc_close(logc)) != 0 && ret == 0)
439		ret = t_ret;
440	if (ret != 0)
441		goto err1;
442
443	/* If there's nothing to return, we're done. */
444	if (n == 0) {
445		ret = 0;
446		*listp = NULL;
447		goto err1;
448	}
449
450	/* Sort the list. */
451	qsort(array, (size_t)n, sizeof(char *), __cmpfunc);
452
453	/*
454	 * Build the real pathnames, discarding nonexistent files and
455	 * duplicates.
456	 */
457	for (last = nxt = 0; nxt < n;) {
458		/*
459		 * Discard duplicates.  Last is the next slot we're going
460		 * to return to the user, nxt is the next slot that we're
461		 * going to consider.
462		 */
463		if (last != nxt) {
464			array[last] = array[nxt];
465			array[nxt] = NULL;
466		}
467		for (++nxt; nxt < n &&
468		    strcmp(array[last], array[nxt]) == 0; ++nxt) {
469			__os_free(env, array[nxt]);
470			array[nxt] = NULL;
471		}
472
473		/* Get the real name. */
474		if ((ret = __db_appname(env,
475		    DB_APP_DATA, array[last], 0, NULL, &real_name)) != 0)
476			goto err2;
477
478		/* If the file doesn't exist, ignore it. */
479		if (__os_exists(env, real_name, NULL) != 0) {
480			__os_free(env, real_name);
481			__os_free(env, array[last]);
482			array[last] = NULL;
483			continue;
484		}
485
486		/* Rework the name as requested by the user. */
487		__os_free(env, array[last]);
488		array[last] = NULL;
489		if (pref != NULL) {
490			ret = __absname(env, pref, real_name, &array[last]);
491			__os_free(env, real_name);
492			if (ret != 0)
493				goto err2;
494		} else if ((p = __db_rpath(real_name)) != NULL) {
495			ret = __os_strdup(env, p + 1, &array[last]);
496			__os_free(env, real_name);
497			if (ret != 0)
498				goto err2;
499		} else
500			array[last] = real_name;
501		++last;
502	}
503
504	/* NULL-terminate the list. */
505	array[last] = NULL;
506
507	/* Rework the memory. */
508	if ((ret = __usermem(env, &array)) != 0)
509		goto err1;
510
511	*listp = array;
512	return (0);
513
514err2:	/*
515	 * XXX
516	 * We've possibly inserted NULLs into the array list, so clean up a
517	 * bit so that the other error processing works.
518	 */
519	if (array != NULL)
520		for (; nxt < n; ++nxt)
521			__os_free(env, array[nxt]);
522	/* FALLTHROUGH */
523
524err1:	if (array != NULL) {
525		for (arrayp = array; *arrayp != NULL; ++arrayp)
526			__os_free(env, *arrayp);
527		__os_free(env, array);
528	}
529	return (ret);
530}
531
532/*
533 * __absname --
534 *	Return an absolute path name for the file.
535 */
536static int
537__absname(env, pref, name, newnamep)
538	ENV *env;
539	char *pref, *name, **newnamep;
540{
541	size_t l_pref, l_name;
542	int isabspath, ret;
543	char *newname;
544
545	l_name = strlen(name);
546	isabspath = __os_abspath(name);
547	l_pref = isabspath ? 0 : strlen(pref);
548
549	/* Malloc space for concatenating the two. */
550	if ((ret = __os_malloc(env,
551	    l_pref + l_name + 2, &newname)) != 0)
552		return (ret);
553	*newnamep = newname;
554
555	/* Build the name.  If `name' is an absolute path, ignore any prefix. */
556	if (!isabspath) {
557		memcpy(newname, pref, l_pref);
558		if (strchr(PATH_SEPARATOR, newname[l_pref - 1]) == NULL)
559			newname[l_pref++] = PATH_SEPARATOR[0];
560	}
561	memcpy(newname + l_pref, name, l_name + 1);
562
563	return (0);
564}
565
566/*
567 * __usermem --
568 *	Create a single chunk of memory that holds the returned information.
569 *	If the user has their own malloc routine, use it.
570 */
571static int
572__usermem(env, listp)
573	ENV *env;
574	char ***listp;
575{
576	size_t len;
577	int ret;
578	char **array, **arrayp, **orig, *strp;
579
580	/* Find out how much space we need. */
581	for (len = 0, orig = *listp; *orig != NULL; ++orig)
582		len += sizeof(char *) + strlen(*orig) + 1;
583	len += sizeof(char *);
584
585	/* Allocate it and set up the pointers. */
586	if ((ret = __os_umalloc(env, len, &array)) != 0)
587		return (ret);
588
589	strp = (char *)(array + (orig - *listp) + 1);
590
591	/* Copy the original information into the new memory. */
592	for (orig = *listp, arrayp = array; *orig != NULL; ++orig, ++arrayp) {
593		len = strlen(*orig);
594		memcpy(strp, *orig, len + 1);
595		*arrayp = strp;
596		strp += len + 1;
597
598		__os_free(env, *orig);
599	}
600
601	/* NULL-terminate the list. */
602	*arrayp = NULL;
603
604	__os_free(env, *listp);
605	*listp = array;
606
607	return (0);
608}
609
610static int
611__cmpfunc(p1, p2)
612	const void *p1, *p2;
613{
614	return (strcmp(*((char * const *)p1), *((char * const *)p2)));
615}
616