transaction.hpp

Go to the documentation of this file.

/*
 * Copyright 2016-2019, Intel Corporation
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in
 *       the documentation and/or other materials provided with the
 *       distribution.
 *
 *     * Neither the name of the copyright holder nor the names of its
 *       contributors may be used to endorse or promote products derived
 *       from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
#ifndef LIBPMEMOBJ_CPP_TRANSACTION_HPP
#define LIBPMEMOBJ_CPP_TRANSACTION_HPP
 
#include <array>
#include <functional>
#include <string>
#include <vector>
 
#include <libpmemobj++/detail/common.hpp>
#include <libpmemobj++/pexceptions.hpp>
#include <libpmemobj++/pool.hpp>
#include <libpmemobj/tx_base.h>
 
namespace pmem
{
 
namespace obj
{
 
class transaction {
public:
    class manual {
    public:
        template <typename... L>
        manual(obj::pool_base &pop, L &... locks)
        {
            int ret = 0;
 
            if (pmemobj_tx_stage() == TX_STAGE_NONE) {
                ret = pmemobj_tx_begin(pop.handle(), nullptr,
                               TX_PARAM_CB,
                               transaction::c_callback,
                               nullptr, TX_PARAM_NONE);
            } else {
                ret = pmemobj_tx_begin(pop.handle(), nullptr,
                               TX_PARAM_NONE);
            }
 
            if (ret != 0)
                throw pmem::transaction_error(
                    "failed to start transaction")
                    .with_pmemobj_errormsg();
 
            auto err = add_lock(locks...);
 
            if (err) {
                pmemobj_tx_abort(EINVAL);
                (void)pmemobj_tx_end();
                throw pmem::transaction_error(
                    "failed to add lock")
                    .with_pmemobj_errormsg();
            }
        }
 
        ~manual() noexcept
        {
            /* normal exit or with an active exception */
            if (pmemobj_tx_stage() == TX_STAGE_WORK)
                pmemobj_tx_abort(ECANCELED);
 
            (void)pmemobj_tx_end();
        }
 
        manual(const manual &p) = delete;
 
        manual(const manual &&p) = delete;
 
        manual &operator=(const manual &p) = delete;
 
        manual &operator=(manual &&p) = delete;
    };
 
/*
 * XXX The Microsoft compiler does not follow the ISO SD-6: SG10 Feature
 * Test Recommendations. "|| _MSC_VER >= 1900" is a workaround.
 */
#if __cpp_lib_uncaught_exceptions || _MSC_VER >= 1900
 
    class automatic {
    public:
        template <typename... L>
        automatic(obj::pool_base &pop, L &... locks)
            : tx_worker(pop, locks...)
        {
        }
 
        ~automatic() noexcept(false)
        {
            /* active exception, abort handled by tx_worker */
            if (exceptions.new_uncaught_exception())
                return;
 
            /* transaction ended normally */
            if (pmemobj_tx_stage() == TX_STAGE_WORK)
                pmemobj_tx_commit();
            /* transaction aborted, throw an exception */
            else if (pmemobj_tx_stage() == TX_STAGE_ONABORT ||
                 (pmemobj_tx_stage() == TX_STAGE_FINALLY &&
                  pmemobj_tx_errno() != 0))
                throw pmem::transaction_error(
                    "Transaction aborted");
        }
 
        automatic(const automatic &p) = delete;
 
        automatic(const automatic &&p) = delete;
 
        automatic &operator=(const automatic &p) = delete;
 
        automatic &operator=(automatic &&p) = delete;
 
    private:
        class uncaught_exception_counter {
        public:
            uncaught_exception_counter()
                : count(std::uncaught_exceptions())
            {
            }
 
            bool
            new_uncaught_exception()
            {
                return std::uncaught_exceptions() > this->count;
            }
 
        private:
            int count;
        } exceptions;
 
        transaction::manual tx_worker;
    };
#endif /* __cpp_lib_uncaught_exceptions */
 
    /*
     * Deleted default constructor.
     */
    transaction() = delete;
 
    ~transaction() noexcept = delete;
 
    static void
    abort(int err)
    {
        if (pmemobj_tx_stage() != TX_STAGE_WORK)
            throw pmem::transaction_error("wrong stage for abort");
 
        pmemobj_tx_abort(err);
        throw pmem::manual_tx_abort("explicit abort " +
                        std::to_string(err));
    }
 
    static void
    commit()
    {
        if (pmemobj_tx_stage() != TX_STAGE_WORK)
            throw pmem::transaction_error("wrong stage for commit");
 
        pmemobj_tx_commit();
    }
 
    static int
    error() noexcept
    {
        return pmemobj_tx_errno();
    }
 
    POBJ_CPP_DEPRECATED static int
    get_last_tx_error() noexcept
    {
        return transaction::error();
    }
 
    template <typename... Locks>
    static void
    run(pool_base &pool, std::function<void()> tx, Locks &... locks)
    {
        int ret = 0;
 
        if (pmemobj_tx_stage() == TX_STAGE_NONE) {
            ret = pmemobj_tx_begin(pool.handle(), nullptr,
                           TX_PARAM_CB,
                           transaction::c_callback, nullptr,
                           TX_PARAM_NONE);
        } else {
            ret = pmemobj_tx_begin(pool.handle(), nullptr,
                           TX_PARAM_NONE);
        }
 
        if (ret != 0)
            throw pmem::transaction_error(
                "failed to start transaction")
                .with_pmemobj_errormsg();
 
        auto err = add_lock(locks...);
 
        if (err) {
            pmemobj_tx_abort(err);
            (void)pmemobj_tx_end();
            throw pmem::transaction_error(
                "failed to add a lock to the transaction")
                .with_pmemobj_errormsg();
        }
 
        try {
            tx();
        } catch (manual_tx_abort &) {
            (void)pmemobj_tx_end();
            throw;
        } catch (...) {
            /* first exception caught */
            if (pmemobj_tx_stage() == TX_STAGE_WORK)
                pmemobj_tx_abort(ECANCELED);
 
            /* waterfall tx_end for outer tx */
            (void)pmemobj_tx_end();
            throw;
        }
 
        auto stage = pmemobj_tx_stage();
 
        if (stage == TX_STAGE_WORK) {
            pmemobj_tx_commit();
        } else if (stage == TX_STAGE_ONABORT) {
            (void)pmemobj_tx_end();
            throw pmem::transaction_error("transaction aborted");
        } else if (stage == TX_STAGE_NONE) {
            throw pmem::transaction_error(
                "transaction ended prematurely");
        }
 
        (void)pmemobj_tx_end();
    }
 
    template <typename... Locks>
    POBJ_CPP_DEPRECATED static void
    exec_tx(pool_base &pool, std::function<void()> tx, Locks &... locks)
    {
        transaction::run(pool, tx, locks...);
    }
 
    template <
        typename T,
        typename std::enable_if<LIBPMEMOBJ_CPP_IS_TRIVIALLY_COPYABLE(T),
                    T>::type * = nullptr>
    static void
    snapshot(const T *addr, size_t num = 1)
    {
        if (TX_STAGE_WORK != pmemobj_tx_stage())
            throw pmem::transaction_error(
                "wrong stage for taking a snapshot.");
 
        if (pmemobj_tx_add_range_direct(addr, sizeof(*addr) * num)) {
            if (errno == ENOMEM)
                throw pmem::transaction_out_of_memory(
                    "Could not take a snapshot of given memory range.")
                    .with_pmemobj_errormsg();
            else
                throw pmem::transaction_error(
                    "Could not take a snapshot of given memory range.")
                    .with_pmemobj_errormsg();
        }
    }
 
    enum class stage {
        work = TX_STAGE_WORK,         /* transaction in progress */
        oncommit = TX_STAGE_ONCOMMIT, /* successfully committed */
        onabort = TX_STAGE_ONABORT,   /* tx_begin failed or transaction
                         aborted */
        finally = TX_STAGE_FINALLY,   /* ready for cleanup */
    };
 
    static void
    register_callback(stage stg, std::function<void()> cb)
    {
        if (pmemobj_tx_stage() != TX_STAGE_WORK)
            throw pmem::transaction_scope_error(
                "register_callback must be called during a transaction");
 
        get_tx_data()->callbacks[static_cast<size_t>(stg)].push_back(
            cb);
    }
 
private:
    template <typename L, typename... Locks>
    static int
    add_lock(L &lock, Locks &... locks) noexcept
    {
        auto err =
            pmemobj_tx_lock(lock.lock_type(), lock.native_handle());
 
        if (err)
            return err;
 
        return add_lock(locks...);
    }
 
    static inline int
    add_lock() noexcept
    {
        return 0;
    }
 
    using callbacks_list_type = std::vector<std::function<void()>>;
    using callbacks_map_type =
        std::array<callbacks_list_type, MAX_TX_STAGE>;
 
    static void
    c_callback(PMEMobjpool *pop, enum pobj_tx_stage obj_stage, void *arg)
    {
        /*
         * We cannot do anything when in TX_STAGE_NONE because
         * pmemobj_tx_get_user_data() can only be called when there is
         * an active transaction.
         */
        if (obj_stage == TX_STAGE_NONE)
            return;
 
        auto *data = static_cast<tx_data *>(pmemobj_tx_get_user_data());
        if (data == nullptr)
            return;
 
        for (auto &cb : data->callbacks[obj_stage])
            cb();
 
        /*
         * Callback for TX_STAGE_FINALLY is called as the last one so we
         * can free tx_data here
         */
        if (obj_stage == TX_STAGE_FINALLY) {
            delete data;
            pmemobj_tx_set_user_data(NULL);
        }
    }
 
    struct tx_data {
        callbacks_map_type callbacks;
    };
 
    static tx_data *
    get_tx_data()
    {
        auto *data = static_cast<tx_data *>(pmemobj_tx_get_user_data());
        if (data == nullptr) {
            data = new tx_data;
            pmemobj_tx_set_user_data(data);
        }
 
        return data;
    }
};
 
} /* namespace obj */
 
} /* namespace pmem */
 
#endif /* LIBPMEMOBJ_CPP_TRANSACTION_HPP */