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