subversion/libsvn_fs_base/trail.c

   1 /* trail.c : backing out of aborted Berkeley DB transactions
   2  *
   3  * ====================================================================
   4  * Copyright (c) 2000-2004 CollabNet.  All rights reserved.
   5  *
   6  * This software is licensed as described in the file COPYING, which
   7  * you should have received as part of this distribution.  The terms
   8  * are also available at http://subversion.tigris.org/license-1.html.
   9  * If newer versions of this license are posted there, you may use a
  10  * newer version instead, at your option.
  11  *
  12  * This software consists of voluntary contributions made by many
  13  * individuals.  For exact contribution history, see the revision
  14  * history and logs, available at http://subversion.tigris.org/.
  15  * ====================================================================
  16  */
  17
  18 #define APU_WANT_DB
  19 #include <apu_want.h>
  20
  21 #include <apr_pools.h>
  22 #include "svn_pools.h"
  23 #include "svn_fs.h"
  24 #include "fs.h"
  25 #include "err.h"
  26 #include "bdb/bdb-err.h"
  27 #include "bdb/bdb_compat.h"
  28 #include "trail.h"
  29 #include "../libsvn_fs/fs-loader.h"
  30
  31
  32 #if defined(SVN_FS__TRAIL_DEBUG)
  33
  34 struct trail_debug_t
  35 {
  36   struct trail_debug_t *prev;
  37   const char *table;
  38   const char *op;
  39 };
  40
  41 void
  42 svn_fs_base__trail_debug(trail_t *trail, const char *table, const char *op)
  43 {
  44   struct trail_debug_t *trail_debug;
  45
  46   trail_debug = apr_palloc(trail->pool, sizeof(*trail_debug));
  47   trail_debug->prev = trail->trail_debug;
  48   trail_debug->table = table;
  49   trail_debug->op = op;
  50   trail->trail_debug = trail_debug;
  51 }
  52
  53 static void
  54 print_trail_debug(trail_t *trail,
  55                   const char *txn_body_fn_name,
  56                   const char *filename, int line)
  57 {
  58   struct trail_debug_t *trail_debug;
  59
  60   fprintf(stderr, "(%s, %s, %u, %u): ",
  61           txn_body_fn_name, filename, line, trail->db_txn ? 1 : 0);
  62
  63   trail_debug = trail->trail_debug;
  64   while (trail_debug)
  65     {
  66       fprintf(stderr, "(%s, %s) ", trail_debug->table, trail_debug->op);
  67       trail_debug = trail_debug->prev;
  68     }
  69   fprintf(stderr, "\n");
  70 }
  71 #else
  72 #define print_trail_debug(trail, txn_body_fn_name, filename, line)
  73 #endif /* defined(SVN_FS__TRAIL_DEBUG) */
  74
  75
  76 static svn_error_t *
  77 begin_trail(trail_t **trail_p,
  78             svn_fs_t *fs,
  79             svn_boolean_t use_txn,
  80             apr_pool_t *pool)
  81 {
  82   base_fs_data_t *bfd = fs->fsap_data;
  83   trail_t *trail = apr_pcalloc(pool, sizeof(*trail));
  84
  85   trail->pool = svn_pool_create(pool);
  86   trail->fs = fs;
  87   if (use_txn)
  88     {
  89       /* [*]
  90          If we're already inside a trail operation, abort() -- this is
  91          a coding problem (and will likely hang the repository anyway). */
  92       if (bfd->in_txn_trail)
  93         abort();
  94
  95       SVN_ERR(BDB_WRAP(fs, "beginning Berkeley DB transaction",
  96                        bfd->bdb->env->txn_begin(bfd->bdb->env, 0,
  97                                                 &trail->db_txn, 0)));
  98       bfd->in_txn_trail = TRUE;
  99     }
 100   else
 101     {
 102       trail->db_txn = NULL;
 103     }
 104
 105   *trail_p = trail;
 106   return SVN_NO_ERROR;
 107 }
 108
 109
 110 static svn_error_t *
 111 abort_trail(trail_t *trail)
 112 {
 113   svn_fs_t *fs = trail->fs;
 114   base_fs_data_t *bfd = fs->fsap_data;
 115
 116   if (trail->db_txn)
 117     {
 118       /* [**]
 119          We have to reset the in_txn_trail flag *before* calling
 120          DB_TXN->abort().  If we did it the other way around, the next
 121          call to begin_trail() (e.g., as part of a txn retry) would
 122          cause an abort, even though there's strictly speaking no
 123          programming error involved (see comment [*] above).
 124
 125          In any case, if aborting the txn fails, restarting it will
 126          most likely fail for the same reason, and so it's better to
 127          see the returned error than to abort.  An obvious example is
 128          when DB_TXN->abort() returns DB_RUNRECOVERY. */
 129       bfd->in_txn_trail = FALSE;
 130       SVN_ERR(BDB_WRAP(fs, "aborting Berkeley DB transaction",
 131                        trail->db_txn->abort(trail->db_txn)));
 132     }
 133   svn_pool_destroy(trail->pool);
 134
 135   return SVN_NO_ERROR;
 136 }
 137
 138
 139 static svn_error_t *
 140 commit_trail(trail_t *trail)
 141 {
 142   int db_err;
 143   svn_fs_t *fs = trail->fs;
 144   base_fs_data_t *bfd = fs->fsap_data;
 145
 146   /* According to the example in the Berkeley DB manual, txn_commit
 147      doesn't return DB_LOCK_DEADLOCK --- all deadlocks are reported
 148      earlier.  */
 149   if (trail->db_txn)
 150     {
 151       /* See comment [**] in abort_trail() above.
 152          An error during txn commit will abort the transaction anyway. */
 153       bfd->in_txn_trail = FALSE;
 154       SVN_ERR(BDB_WRAP(fs, "committing Berkeley DB transaction",
 155                        trail->db_txn->commit(trail->db_txn, 0)));
 156     }
 157
 158   /* Do a checkpoint here, if enough has gone on.
 159      The checkpoint parameters below are pretty arbitrary.  Perhaps
 160      there should be an svn_fs_berkeley_mumble function to set them.  */
 161   db_err = bfd->bdb->env->txn_checkpoint(bfd->bdb->env, 1024, 5, 0);
 162
 163   /* Pre-4.1 Berkeley documentation says:
 164
 165         The DB_ENV->txn_checkpoint function returns a non-zero error
 166         value on failure, 0 on success, and returns DB_INCOMPLETE if
 167         there were pages that needed to be written to complete the
 168         checkpoint but that DB_ENV->memp_sync was unable to write
 169         immediately.
 170
 171      It's safe to ignore DB_INCOMPLETE if we get it while
 172      checkpointing.  (Post-4.1 Berkeley doesn't have DB_INCOMPLETE
 173      anymore, so it's not an issue there.)  */
 174   if (db_err)
 175     {
 176 #if SVN_BDB_HAS_DB_INCOMPLETE
 177       if (db_err != DB_INCOMPLETE)
 178 #endif /* SVN_BDB_HAS_DB_INCOMPLETE */
 179         {
 180           return svn_fs_bdb__wrap_db
 181             (fs, "checkpointing after Berkeley DB transaction", db_err);
 182         }
 183     }
 184
 185   return SVN_NO_ERROR;
 186 }
 187
 188
 189 static svn_error_t *
 190 do_retry(svn_fs_t *fs,
 191          svn_error_t *(*txn_body)(void *baton, trail_t *trail),
 192          void *baton,
 193          svn_boolean_t use_txn,
 194          apr_pool_t *pool,
 195          const char *txn_body_fn_name,
 196          const char *filename,
 197          int line)
 198 {
 199   for (;;)
 200     {
 201       trail_t *trail;
 202       svn_error_t *svn_err, *err;
 203       svn_boolean_t deadlocked = FALSE;
 204
 205       SVN_ERR(begin_trail(&trail, fs, use_txn, pool));
 206
 207       /* Do the body of the transaction.  */
 208       svn_err = (*txn_body)(baton, trail);
 209
 210       if (! svn_err)
 211         {
 212           /* The transaction succeeded!  Commit it.  */
 213           SVN_ERR(commit_trail(trail));
 214
 215           if (use_txn)
 216             print_trail_debug(trail, txn_body_fn_name, filename, line);
 217
 218           return SVN_NO_ERROR;
 219         }
 220
 221       /* Search for a deadlock error on the stack. */
 222       for (err = svn_err; err; err = err->child)
 223         if (err->apr_err == SVN_ERR_FS_BERKELEY_DB_DEADLOCK)
 224           deadlocked = TRUE;
 225
 226       /* Is this a real error, or do we just need to retry?  */
 227       if (! deadlocked)
 228         {
 229           /* Ignore any error returns.  The first error is more valuable.  */
 230           svn_error_clear(abort_trail(trail));
 231           return svn_err;
 232         }
 233
 234       svn_error_clear(svn_err);
 235
 236       /* We deadlocked.  Abort the transaction, and try again.  */
 237       SVN_ERR(abort_trail(trail));
 238     }
 239 }
 240
 241
 242 svn_error_t *
 243 svn_fs_base__retry_debug(svn_fs_t *fs,
 244                          svn_error_t *(*txn_body)(void *baton, trail_t *trail),
 245                          void *baton,
 246                          apr_pool_t *pool,
 247                          const char *txn_body_fn_name,
 248                          const char *filename,
 249                          int line)
 250 {
 251   return do_retry(fs, txn_body, baton, TRUE, pool,
 252                   txn_body_fn_name, filename, line);
 253 }
 254
 255
 256 #if defined(SVN_FS__TRAIL_DEBUG)
 257 #undef svn_fs_base__retry_txn
 258 #endif
 259
 260 svn_error_t *
 261 svn_fs_base__retry_txn(svn_fs_t *fs,
 262                        svn_error_t *(*txn_body)(void *baton, trail_t *trail),
 263                        void *baton,
 264                        apr_pool_t *pool)
 265 {
 266   return do_retry(fs, txn_body, baton, TRUE, pool,
 267                   "unknown", "", 0);
 268 }
 269
 270
 271 svn_error_t *
 272 svn_fs_base__retry(svn_fs_t *fs,
 273                    svn_error_t *(*txn_body)(void *baton, trail_t *trail),
 274                    void *baton,
 275                    apr_pool_t *pool)
 276 {
 277   return do_retry(fs, txn_body, baton, FALSE, pool,
 278                   NULL, NULL, 0);
 279 }