/*
 * Copyright 2009, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Copyright 2002-2009, Axel Dörfler, axeld@pinc-software.de.
 * Distributed under the terms of the MIT License.
 */
#ifndef VM_ADDRESS_SPACE_LOCKING_H
#define VM_ADDRESS_SPACE_LOCKING_H


#include <OS.h>

#include <vm/VMAddressSpace.h>


struct VMAddressSpace;
struct VMArea;
struct VMCache;


class AddressSpaceLockerBase {
public:
        static  VMAddressSpace*         GetAddressSpaceByAreaID(area_id id);
};


class AddressSpaceReadLocker : private AddressSpaceLockerBase {
public:
                                                                AddressSpaceReadLocker(team_id team);
                                                                AddressSpaceReadLocker(VMAddressSpace* space,
                                                                        bool getNewReference);
                                                                AddressSpaceReadLocker();
                                                                ~AddressSpaceReadLocker();

                        status_t                        SetTo(team_id team);
                        void                            SetTo(VMAddressSpace* space,
                                                                        bool getNewReference);
                        status_t                        SetFromArea(area_id areaID, VMArea*& area);

                        bool                            IsLocked() const { return fLocked; }
                        bool                            Lock();
                        void                            Unlock();

                        void                            Unset();

                        VMAddressSpace*         AddressSpace() const { return fSpace; }

private:
                        VMAddressSpace*         fSpace;
                        bool                            fLocked;
};


class AddressSpaceWriteLocker : private AddressSpaceLockerBase {
public:
                                                                AddressSpaceWriteLocker(team_id team);
                                                                AddressSpaceWriteLocker(VMAddressSpace* space,
                                                                        bool getNewReference);
                                                                AddressSpaceWriteLocker();
                                                                ~AddressSpaceWriteLocker();

                        status_t                        SetTo(team_id team);
                        void                            SetTo(VMAddressSpace* space,
                                                                        bool getNewReference);
                        status_t                        SetFromArea(area_id areaID, VMArea*& area);
                        status_t                        SetFromArea(team_id team, area_id areaID,
                                                                        bool allowKernel, VMArea*& area);
                        status_t                        SetFromArea(team_id team, area_id areaID,
                                                                        VMArea*& area);

                        bool                            IsLocked() const { return fLocked; }
                        void                            Unlock();

                        void                            DegradeToReadLock();
                        void                            Unset();

                        VMAddressSpace*         AddressSpace() const { return fSpace; }

private:
                        VMAddressSpace*         fSpace;
                        bool                            fLocked;
                        bool                            fDegraded;
};


class MultiAddressSpaceLocker : private AddressSpaceLockerBase {
public:
                                                                MultiAddressSpaceLocker();
                                                                ~MultiAddressSpaceLocker();

        inline  status_t                        AddTeam(team_id team, bool writeLock,
                                                                        VMAddressSpace** _space = NULL);
        inline  status_t                        AddArea(area_id area, bool writeLock,
                                                                        VMAddressSpace** _space = NULL);
        inline  status_t                        AddArea(VMArea* area, bool writeLock,
                                                                        VMAddressSpace** _space = NULL);

                        status_t                        AddAreaCacheAndLock(area_id areaID,
                                                                        bool writeLockThisOne, bool writeLockOthers,
                                                                        VMArea*& _area, VMCache** _cache = NULL);

                        status_t                        Lock();
                        void                            Unlock();
                        bool                            IsLocked() const { return fLocked; }

                        void                            Unset();

private:
                        struct lock_item {
                                VMAddressSpace* space;
                                bool                    write_lock;
                        };

                        bool                            _ResizeIfNeeded();
                        int32                           _IndexOfAddressSpace(VMAddressSpace* space)
                                                                        const;
                        status_t                        _AddAddressSpace(VMAddressSpace* space,
                                                                        bool writeLock, VMAddressSpace** _space);

        static  int                                     _CompareItems(const void* _a, const void* _b);

                        lock_item*                      fItems;
                        int32                           fCapacity;
                        int32                           fCount;
                        bool                            fLocked;
};


inline status_t
MultiAddressSpaceLocker::AddTeam(team_id team, bool writeLock,
        VMAddressSpace** _space)
{
        return _AddAddressSpace(VMAddressSpace::Get(team), writeLock, _space);
}


inline status_t
MultiAddressSpaceLocker::AddArea(area_id area, bool writeLock,
        VMAddressSpace** _space)
{
        return _AddAddressSpace(GetAddressSpaceByAreaID(area), writeLock, _space);
}


inline status_t
MultiAddressSpaceLocker::AddArea(VMArea* area, bool writeLock,
        VMAddressSpace** _space)
{
        area->address_space->Get();
        return _AddAddressSpace(area->address_space, writeLock, _space);
}


#endif  // VM_ADDRESS_SPACE_LOCKING_H