log_archive.c 11.1 KB
Newer Older
unknown's avatar
unknown committed
1 2 3
/*-
 * See the file LICENSE for redistribution information.
 *
unknown's avatar
unknown committed
4
 * Copyright (c) 1997-2002
unknown's avatar
unknown committed
5 6 7 8 9 10
 *	Sleepycat Software.  All rights reserved.
 */

#include "db_config.h"

#ifndef lint
unknown's avatar
unknown committed
11
static const char revid[] = "$Id: log_archive.c,v 11.39 2002/08/06 05:00:31 bostic Exp $";
unknown's avatar
unknown committed
12 13 14 15 16 17 18 19 20 21 22
#endif /* not lint */

#ifndef NO_SYSTEM_INCLUDES
#include <sys/types.h>

#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#endif

#include "db_int.h"
unknown's avatar
unknown committed
23 24 25 26
#include "dbinc/db_page.h"
#include "dbinc/log.h"
#include "dbinc/qam.h"
#include "dbinc/txn.h"
unknown's avatar
unknown committed
27 28

static int __absname __P((DB_ENV *, char *, char *, char **));
unknown's avatar
unknown committed
29
static int __build_data __P((DB_ENV *, char *, char ***));
unknown's avatar
unknown committed
30
static int __cmpfunc __P((const void *, const void *));
unknown's avatar
unknown committed
31
static int __usermem __P((DB_ENV *, char ***));
unknown's avatar
unknown committed
32 33

/*
unknown's avatar
unknown committed
34
 * __log_archive --
unknown's avatar
unknown committed
35
 *	Supporting function for db_archive(1).
unknown's avatar
unknown committed
36 37
 *
 * PUBLIC: int __log_archive __P((DB_ENV *, char **[], u_int32_t));
unknown's avatar
unknown committed
38 39
 */
int
unknown's avatar
unknown committed
40
__log_archive(dbenv, listp, flags)
unknown's avatar
unknown committed
41 42 43 44 45 46
	DB_ENV *dbenv;
	char ***listp;
	u_int32_t flags;
{
	DBT rec;
	DB_LOG *dblp;
unknown's avatar
unknown committed
47
	DB_LOGC *logc;
unknown's avatar
unknown committed
48
	DB_LSN stable_lsn;
unknown's avatar
unknown committed
49
	__txn_ckp_args *ckp_args;
unknown's avatar
unknown committed
50
	char **array, **arrayp, *name, *p, *pref, buf[MAXPATHLEN];
unknown's avatar
unknown committed
51 52
	int array_size, db_arch_abs, n, ret;
	u_int32_t fnum;
unknown's avatar
unknown committed
53 54

	PANIC_CHECK(dbenv);
unknown's avatar
unknown committed
55 56
	ENV_REQUIRES_CONFIG(dbenv,
	    dbenv->lg_handle, "DB_ENV->log_archive", DB_INIT_LOG);
unknown's avatar
unknown committed
57 58 59 60 61 62 63

	name = NULL;
	dblp = dbenv->lg_handle;
	COMPQUIET(fnum, 0);

#define	OKFLAGS	(DB_ARCH_ABS | DB_ARCH_DATA | DB_ARCH_LOG)
	if (flags != 0) {
unknown's avatar
unknown committed
64 65
		if ((ret = __db_fchk(
		    dbenv, "DB_ENV->log_archive", flags, OKFLAGS)) != 0)
unknown's avatar
unknown committed
66
			return (ret);
unknown's avatar
unknown committed
67 68
		if ((ret = __db_fcchk(dbenv, "DB_ENV->log_archive",
		    flags, DB_ARCH_DATA, DB_ARCH_LOG)) != 0)
unknown's avatar
unknown committed
69 70 71
			return (ret);
	}

unknown's avatar
unknown committed
72 73 74 75 76 77 78 79 80 81
	if (LF_ISSET(DB_ARCH_ABS)) {
		db_arch_abs = 1;
		LF_CLR(DB_ARCH_ABS);
	} else
		db_arch_abs = 0;

	if (flags == 0 || flags == DB_ARCH_DATA)
		ENV_REQUIRES_CONFIG(dbenv,
		    dbenv->tx_handle, "DB_ENV->log_archive", DB_INIT_TXN);

unknown's avatar
unknown committed
82 83 84 85 86 87 88 89 90
	/*
	 * Get the absolute pathname of the current directory.  It would
	 * be nice to get the shortest pathname of the database directory,
	 * but that's just not possible.
	 *
	 * XXX
	 * Can't trust getcwd(3) to set a valid errno.  If it doesn't, just
	 * guess that we ran out of memory.
	 */
unknown's avatar
unknown committed
91
	if (db_arch_abs) {
unknown's avatar
unknown committed
92 93 94 95 96 97 98 99 100
		__os_set_errno(0);
		if ((pref = getcwd(buf, sizeof(buf))) == NULL) {
			if (__os_get_errno() == 0)
				__os_set_errno(ENOMEM);
			return (__os_get_errno());
		}
	} else
		pref = NULL;

unknown's avatar
unknown committed
101
	switch (flags) {
unknown's avatar
unknown committed
102
	case DB_ARCH_DATA:
unknown's avatar
unknown committed
103
		return (__build_data(dbenv, pref, listp));
unknown's avatar
unknown committed
104 105
	case DB_ARCH_LOG:
		memset(&rec, 0, sizeof(rec));
unknown's avatar
unknown committed
106 107 108 109 110 111 112 113
		if ((ret = dbenv->log_cursor(dbenv, &logc, 0)) != 0)
			return (ret);
#ifdef UMRW
		ZERO_LSN(stable_lsn);
#endif
		ret = logc->get(logc, &stable_lsn, &rec, DB_LAST);
		(void)logc->close(logc, 0);
		if (ret != 0)
unknown's avatar
unknown committed
114 115 116 117
			return (ret);
		fnum = stable_lsn.file;
		break;
	case 0:
unknown's avatar
unknown committed
118 119
		memset(&rec, 0, sizeof(rec));
		if (__txn_getckp(dbenv, &stable_lsn) != 0) {
unknown's avatar
unknown committed
120
			/*
unknown's avatar
unknown committed
121 122 123
			 * A failure return means that there's no checkpoint
			 * in the log (so we are not going to be deleting
			 * any log files).
unknown's avatar
unknown committed
124 125 126 127
			 */
			*listp = NULL;
			return (0);
		}
unknown's avatar
unknown committed
128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149
		if ((ret = dbenv->log_cursor(dbenv, &logc, 0)) != 0)
			return (ret);
		if ((ret = logc->get(logc, &stable_lsn, &rec, DB_SET)) != 0 ||
		    (ret = __txn_ckp_read(dbenv, rec.data, &ckp_args)) != 0) {
			/*
			 * A return of DB_NOTFOUND may only mean that the
			 * checkpoint LSN is before the beginning of the
			 * log files that we still have.  This is not
			 * an error;  it just means our work is done.
			 */
			if (ret == DB_NOTFOUND) {
				*listp = NULL;
				ret = 0;
			}
			(void)logc->close(logc, 0);
			return (ret);
		}
		if ((ret = logc->close(logc, 0)) != 0)
			return (ret);
		stable_lsn = ckp_args->ckp_lsn;
		__os_free(dbenv, ckp_args);

unknown's avatar
unknown committed
150 151 152 153 154 155 156
		/* Remove any log files before the last stable LSN. */
		fnum = stable_lsn.file - 1;
		break;
	}

#define	LIST_INCREMENT	64
	/* Get some initial space. */
unknown's avatar
unknown committed
157
	array_size = 64;
unknown's avatar
unknown committed
158
	if ((ret = __os_malloc(dbenv,
unknown's avatar
unknown committed
159
	    sizeof(char *) * array_size, &array)) != 0)
unknown's avatar
unknown committed
160 161 162 163 164 165 166 167 168 169
		return (ret);
	array[0] = NULL;

	/* Build an array of the file names. */
	for (n = 0; fnum > 0; --fnum) {
		if ((ret = __log_name(dblp, fnum, &name, NULL, 0)) != 0)
			goto err;
		if (__os_exists(name, NULL) != 0) {
			if (LF_ISSET(DB_ARCH_LOG) && fnum == stable_lsn.file)
				continue;
unknown's avatar
unknown committed
170
			__os_free(dbenv, name);
unknown's avatar
unknown committed
171 172 173 174
			name = NULL;
			break;
		}

unknown's avatar
unknown committed
175
		if (n >= array_size - 2) {
unknown's avatar
unknown committed
176 177
			array_size += LIST_INCREMENT;
			if ((ret = __os_realloc(dbenv,
unknown's avatar
unknown committed
178
			    sizeof(char *) * array_size, &array)) != 0)
unknown's avatar
unknown committed
179 180 181
				goto err;
		}

unknown's avatar
unknown committed
182
		if (db_arch_abs) {
unknown's avatar
unknown committed
183 184 185
			if ((ret = __absname(dbenv,
			    pref, name, &array[n])) != 0)
				goto err;
unknown's avatar
unknown committed
186
			__os_free(dbenv, name);
unknown's avatar
unknown committed
187 188 189
		} else if ((p = __db_rpath(name)) != NULL) {
			if ((ret = __os_strdup(dbenv, p + 1, &array[n])) != 0)
				goto err;
unknown's avatar
unknown committed
190
			__os_free(dbenv, name);
unknown's avatar
unknown committed
191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208
		} else
			array[n] = name;

		name = NULL;
		array[++n] = NULL;
	}

	/* If there's nothing to return, we're done. */
	if (n == 0) {
		*listp = NULL;
		ret = 0;
		goto err;
	}

	/* Sort the list. */
	qsort(array, (size_t)n, sizeof(char *), __cmpfunc);

	/* Rework the memory. */
unknown's avatar
unknown committed
209
	if ((ret = __usermem(dbenv, &array)) != 0)
unknown's avatar
unknown committed
210 211 212 213 214 215 216
		goto err;

	*listp = array;
	return (0);

err:	if (array != NULL) {
		for (arrayp = array; *arrayp != NULL; ++arrayp)
unknown's avatar
unknown committed
217 218
			__os_free(dbenv, *arrayp);
		__os_free(dbenv, array);
unknown's avatar
unknown committed
219 220
	}
	if (name != NULL)
unknown's avatar
unknown committed
221
		__os_free(dbenv, name);
unknown's avatar
unknown committed
222 223 224 225 226 227 228 229
	return (ret);
}

/*
 * __build_data --
 *	Build a list of datafiles for return.
 */
static int
unknown's avatar
unknown committed
230
__build_data(dbenv, pref, listp)
unknown's avatar
unknown committed
231 232 233 234
	DB_ENV *dbenv;
	char *pref, ***listp;
{
	DBT rec;
unknown's avatar
unknown committed
235
	DB_LOGC *logc;
unknown's avatar
unknown committed
236
	DB_LSN lsn;
unknown's avatar
unknown committed
237
	__dbreg_register_args *argp;
unknown's avatar
unknown committed
238
	u_int32_t rectype;
unknown's avatar
unknown committed
239 240
	int array_size, last, n, nxt, ret, t_ret;
	char **array, **arrayp, **list, **lp, *p, *real_name;
unknown's avatar
unknown committed
241 242

	/* Get some initial space. */
unknown's avatar
unknown committed
243
	array_size = 64;
unknown's avatar
unknown committed
244
	if ((ret = __os_malloc(dbenv,
unknown's avatar
unknown committed
245
	    sizeof(char *) * array_size, &array)) != 0)
unknown's avatar
unknown committed
246 247 248 249
		return (ret);
	array[0] = NULL;

	memset(&rec, 0, sizeof(rec));
unknown's avatar
unknown committed
250 251 252
	if ((ret = dbenv->log_cursor(dbenv, &logc, 0)) != 0)
		return (ret);
	for (n = 0; (ret = logc->get(logc, &lsn, &rec, DB_PREV)) == 0;) {
unknown's avatar
unknown committed
253 254
		if (rec.size < sizeof(rectype)) {
			ret = EINVAL;
unknown's avatar
unknown committed
255 256
			__db_err(dbenv, "DB_ENV->log_archive: bad log record");
			goto free_continue;
unknown's avatar
unknown committed
257 258 259
		}

		memcpy(&rectype, rec.data, sizeof(rectype));
unknown's avatar
unknown committed
260
		if (rectype != DB___dbreg_register)
unknown's avatar
unknown committed
261
			continue;
unknown's avatar
unknown committed
262 263
		if ((ret =
		    __dbreg_register_read(dbenv, rec.data, &argp)) != 0) {
unknown's avatar
unknown committed
264 265
			ret = EINVAL;
			__db_err(dbenv,
unknown's avatar
unknown committed
266 267
			    "DB_ENV->log_archive: unable to read log record");
			goto free_continue;
unknown's avatar
unknown committed
268 269
		}

unknown's avatar
unknown committed
270
		if (n >= array_size - 2) {
unknown's avatar
unknown committed
271 272
			array_size += LIST_INCREMENT;
			if ((ret = __os_realloc(dbenv,
unknown's avatar
unknown committed
273 274
			    sizeof(char *) * array_size, &array)) != 0)
				goto free_continue;
unknown's avatar
unknown committed
275 276 277
		}

		if ((ret = __os_strdup(dbenv,
unknown's avatar
unknown committed
278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301
		    argp->name.data, &array[n++])) != 0)
			goto free_continue;
		array[n] = NULL;

		if (argp->ftype == DB_QUEUE) {
			if ((ret = __qam_extent_names(dbenv,
			    argp->name.data, &list)) != 0)
				goto q_err;
			for (lp = list;
			    lp != NULL && *lp != NULL; lp++) {
				if (n >= array_size - 2) {
					array_size += LIST_INCREMENT;
					if ((ret = __os_realloc(dbenv,
					    sizeof(char *) *
					    array_size, &array)) != 0)
						goto q_err;
				}
				if ((ret =
				    __os_strdup(dbenv, *lp, &array[n++])) != 0)
					goto q_err;
				array[n] = NULL;
			}
q_err:			if (list != NULL)
				__os_free(dbenv, list);
unknown's avatar
unknown committed
302
		}
unknown's avatar
unknown committed
303 304 305
free_continue:	__os_free(dbenv, argp);
		if (ret != 0)
			break;
unknown's avatar
unknown committed
306
	}
unknown's avatar
unknown committed
307 308 309 310 311 312
	if (ret == DB_NOTFOUND)
		ret = 0;
	if ((t_ret = logc->close(logc, 0)) != 0 && ret == 0)
		ret = t_ret;
	if (ret != 0)
		goto err1;
unknown's avatar
unknown committed
313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339

	/* If there's nothing to return, we're done. */
	if (n == 0) {
		ret = 0;
		*listp = NULL;
		goto err1;
	}

	/* Sort the list. */
	qsort(array, (size_t)n, sizeof(char *), __cmpfunc);

	/*
	 * Build the real pathnames, discarding nonexistent files and
	 * duplicates.
	 */
	for (last = nxt = 0; nxt < n;) {
		/*
		 * Discard duplicates.  Last is the next slot we're going
		 * to return to the user, nxt is the next slot that we're
		 * going to consider.
		 */
		if (last != nxt) {
			array[last] = array[nxt];
			array[nxt] = NULL;
		}
		for (++nxt; nxt < n &&
		    strcmp(array[last], array[nxt]) == 0; ++nxt) {
unknown's avatar
unknown committed
340
			__os_free(dbenv, array[nxt]);
unknown's avatar
unknown committed
341 342 343 344 345
			array[nxt] = NULL;
		}

		/* Get the real name. */
		if ((ret = __db_appname(dbenv,
unknown's avatar
unknown committed
346
		    DB_APP_DATA, array[last], 0, NULL, &real_name)) != 0)
unknown's avatar
unknown committed
347 348 349 350
			goto err2;

		/* If the file doesn't exist, ignore it. */
		if (__os_exists(real_name, NULL) != 0) {
unknown's avatar
unknown committed
351 352
			__os_free(dbenv, real_name);
			__os_free(dbenv, array[last]);
unknown's avatar
unknown committed
353 354 355 356 357
			array[last] = NULL;
			continue;
		}

		/* Rework the name as requested by the user. */
unknown's avatar
unknown committed
358
		__os_free(dbenv, array[last]);
unknown's avatar
unknown committed
359 360 361
		array[last] = NULL;
		if (pref != NULL) {
			ret = __absname(dbenv, pref, real_name, &array[last]);
unknown's avatar
unknown committed
362
			__os_free(dbenv, real_name);
unknown's avatar
unknown committed
363 364 365 366
			if (ret != 0)
				goto err2;
		} else if ((p = __db_rpath(real_name)) != NULL) {
			ret = __os_strdup(dbenv, p + 1, &array[last]);
unknown's avatar
unknown committed
367
			__os_free(dbenv, real_name);
unknown's avatar
unknown committed
368 369 370 371 372 373 374 375 376 377 378
			if (ret != 0)
				goto err2;
		} else
			array[last] = real_name;
		++last;
	}

	/* NULL-terminate the list. */
	array[last] = NULL;

	/* Rework the memory. */
unknown's avatar
unknown committed
379
	if ((ret = __usermem(dbenv, &array)) != 0)
unknown's avatar
unknown committed
380 381 382 383 384 385 386 387 388 389 390 391
		goto err1;

	*listp = array;
	return (0);

err2:	/*
	 * XXX
	 * We've possibly inserted NULLs into the array list, so clean up a
	 * bit so that the other error processing works.
	 */
	if (array != NULL)
		for (; nxt < n; ++nxt)
unknown's avatar
unknown committed
392
			__os_free(dbenv, array[nxt]);
unknown's avatar
unknown committed
393 394 395 396
	/* FALLTHROUGH */

err1:	if (array != NULL) {
		for (arrayp = array; *arrayp != NULL; ++arrayp)
unknown's avatar
unknown committed
397 398
			__os_free(dbenv, *arrayp);
		__os_free(dbenv, array);
unknown's avatar
unknown committed
399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421
	}
	return (ret);
}

/*
 * __absname --
 *	Return an absolute path name for the file.
 */
static int
__absname(dbenv, pref, name, newnamep)
	DB_ENV *dbenv;
	char *pref, *name, **newnamep;
{
	size_t l_pref, l_name;
	int isabspath, ret;
	char *newname;

	l_name = strlen(name);
	isabspath = __os_abspath(name);
	l_pref = isabspath ? 0 : strlen(pref);

	/* Malloc space for concatenating the two. */
	if ((ret = __os_malloc(dbenv,
unknown's avatar
unknown committed
422
	    l_pref + l_name + 2, &newname)) != 0)
unknown's avatar
unknown committed
423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442
		return (ret);
	*newnamep = newname;

	/* Build the name.  If `name' is an absolute path, ignore any prefix. */
	if (!isabspath) {
		memcpy(newname, pref, l_pref);
		if (strchr(PATH_SEPARATOR, newname[l_pref - 1]) == NULL)
			newname[l_pref++] = PATH_SEPARATOR[0];
	}
	memcpy(newname + l_pref, name, l_name + 1);

	return (0);
}

/*
 * __usermem --
 *	Create a single chunk of memory that holds the returned information.
 *	If the user has their own malloc routine, use it.
 */
static int
unknown's avatar
unknown committed
443
__usermem(dbenv, listp)
unknown's avatar
unknown committed
444 445 446 447 448 449 450 451 452 453 454 455 456
	DB_ENV *dbenv;
	char ***listp;
{
	size_t len;
	int ret;
	char **array, **arrayp, **orig, *strp;

	/* Find out how much space we need. */
	for (len = 0, orig = *listp; *orig != NULL; ++orig)
		len += sizeof(char *) + strlen(*orig) + 1;
	len += sizeof(char *);

	/* Allocate it and set up the pointers. */
unknown's avatar
unknown committed
457
	if ((ret = __os_umalloc(dbenv, len, &array)) != 0)
unknown's avatar
unknown committed
458 459 460 461 462 463 464 465 466 467 468
		return (ret);

	strp = (char *)(array + (orig - *listp) + 1);

	/* Copy the original information into the new memory. */
	for (orig = *listp, arrayp = array; *orig != NULL; ++orig, ++arrayp) {
		len = strlen(*orig);
		memcpy(strp, *orig, len + 1);
		*arrayp = strp;
		strp += len + 1;

unknown's avatar
unknown committed
469
		__os_free(dbenv, *orig);
unknown's avatar
unknown committed
470 471 472 473 474
	}

	/* NULL-terminate the list. */
	*arrayp = NULL;

unknown's avatar
unknown committed
475
	__os_free(dbenv, *listp);
unknown's avatar
unknown committed
476 477 478 479 480 481 482 483 484 485 486
	*listp = array;

	return (0);
}

static int
__cmpfunc(p1, p2)
	const void *p1, *p2;
{
	return (strcmp(*((char * const *)p1), *((char * const *)p2)));
}