log/log_archive.c

   1 /*-
   2  * See the file LICENSE for redistribution information.
   3  *
   4  * Copyright (c) 1997-2009 Oracle.  All rights reserved.
   5  *
   6  * $Id$
   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
  17 static int __absname __P((ENV *, char *, char *, char **));
  18 static int __build_data __P((ENV *, char *, char ***));
  19 static int __cmpfunc __P((const void *, const void *));
  20 static int __log_archive __P((ENV *, char **[], u_int32_t));
  21 static 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  */
  29 int
  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  */
  68 static 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) {
 241 err:            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  */
 259 int
 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;
 316 err:
 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  */
 326 void
 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  */
 357 static 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                         }
 429 q_err:                  if (list != NULL)
 430                                 __os_free(env, list);
 431                 }
 432 free_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], 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
 514 err2:   /*
 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
 524 err1:   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  */
 536 static 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  */
 571 static 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
 610 static int
 611 __cmpfunc(p1, p2)
 612         const void *p1, *p2;
 613 {
 614         return (strcmp(*((char * const *)p1), *((char * const *)p2)));
 615 }