Lockfree Reloading and Sharing of const objects

My application's configuration is a const object that is shared with multiple threads. The configuration is stored in a centralized location and any thread may reach it. I've tried building a lockfree implementation that would allow me to be able to load new configuration while still allowing other threads to read the last known configuration.

My current implementation has a race between updating the shared_ptr and reading from it.

template<typename T>
class ConfigurationHolder
{
public:
    typedef std::shared_ptr<T> SPtr;
    typedef std::shared_ptr<const T> CSPtr;

    ConfigurationHolder() : m_active(new T()) {}

    CSPtr get() const { return m_active; } // RACE - read

    template<typename Reloader>
    bool reload(Reloader reloader)
    {
        SPtr tmp(new T());
        if (!tmp)
            return false;
        if (!reloader(tmp))
            return false;
        m_active=tmp; // RACE - write
        return true;
    }

private:
    CSPtr m_active;
};

I can add a shared_mutex for the problematic read/write access to the shared_ptr, but I'm looking for a solution that will keep the implementation lockfree.

EDIT: My version of GCC does not support atomic_exchange on shared_ptr