fail_point.h

/*    Copyright 2014 MongoDB Inc.
 *
 *    Licensed under the Apache License, Version 2.0 (the "License");
 *    you may not use this file except in compliance with the License.
 *    You may obtain a copy of the License at
 *
 *    http://www.apache.org/licenses/LICENSE-2.0
 *
 *    Unless required by applicable law or agreed to in writing, software
 *    distributed under the License is distributed on an "AS IS" BASIS,
 *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *    See the License for the specific language governing permissions and
 *    limitations under the License.
 */
 
#pragma once
 
#include <boost/thread/mutex.hpp>
 
#include "mongo/base/disallow_copying.h"
#include "mongo/db/jsobj.h"
#include "mongo/platform/atomic_word.h"
 
namespace mongo {
class FailPoint {
    MONGO_DISALLOW_COPYING(FailPoint);
 
public:
    typedef AtomicUInt32::WordType ValType;
    enum Mode { off, alwaysOn, random, nTimes, numModes };
    enum RetCode { fastOff = 0, slowOff, slowOn };
 
    FailPoint();
 
    inline bool shouldFail() {
        RetCode ret = shouldFailOpenBlock();
 
        if (MONGO_likely(ret == fastOff)) {
            return false;
        }
 
        shouldFailCloseBlock();
        return ret == slowOn;
    }
 
    inline RetCode shouldFailOpenBlock() {
        if (MONGO_likely((_fpInfo.loadRelaxed() & ACTIVE_BIT) == 0)) {
            return fastOff;
        }
 
        return slowShouldFailOpenBlock();
    }
 
    void shouldFailCloseBlock();
 
    void setMode(Mode mode, ValType val = 0, const BSONObj& extra = BSONObj());
 
    BSONObj toBSON() const;
 
private:
    static const ValType ACTIVE_BIT = 1 << 31;
    static const ValType REF_COUNTER_MASK = ~ACTIVE_BIT;
 
    // Bit layout:
    // 31: tells whether this fail point is active.
    // 0~30: unsigned ref counter for active dynamic instances.
    AtomicUInt32 _fpInfo;
 
    // Invariant: These should be read only if ACTIVE_BIT of _fpInfo is set.
    Mode _mode;
    AtomicInt32 _timesOrPeriod;
    BSONObj _data;
 
    // protects _mode, _timesOrPeriod, _data
    mutable boost::mutex _modMutex;
 
    void enableFailPoint();
 
    void disableFailPoint();
 
    RetCode slowShouldFailOpenBlock();
 
    const BSONObj& getData() const;
 
    friend class ScopedFailPoint;
};
 
class ScopedFailPoint {
    MONGO_DISALLOW_COPYING(ScopedFailPoint);
 
public:
    ScopedFailPoint(FailPoint* failPoint);
    ~ScopedFailPoint();
 
    inline bool isActive() {
        if (_once) {
            return false;
        }
 
        _once = true;
 
        FailPoint::RetCode ret = _failPoint->shouldFailOpenBlock();
        _shouldClose = ret != FailPoint::fastOff;
        return ret == FailPoint::slowOn;
    }
 
    const BSONObj& getData() const;
 
private:
    FailPoint* _failPoint;
    bool _once;
    bool _shouldClose;
};
 
#define MONGO_FAIL_POINT(symbol) MONGO_unlikely(symbol.shouldFail())
 
#define MONGO_FAIL_POINT_BLOCK(symbol, blockSymbol) \
    for (mongo::ScopedFailPoint blockSymbol(&symbol); MONGO_unlikely(blockSymbol.isActive());)
}