Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 5728a92e authored by Anu Sundararajan's avatar Anu Sundararajan Committed by Iliyan Malchev
Browse files

MemoryHeapBase: Save and binderize the offset 



The offset that is used in the creation of the MemoryHeapBase must be saved, so
that it can be used to recreate the Heap when an IMemory object is passed
across process boundary through the binder.

Change-Id: Ie618fb5c0718e6711f55ed9235616fd801e648dc
Signed-off-by: default avatarAnu Sundararajan <sanuradha@ti.com>
Signed-off-by: default avatarIliyan Malchev <malchev@google.com>
parent 35766cfc

include/binder/IMemory.h

+1 −0
Original line number Original line Diff line number Diff line
@@ -43,6 +43,7 @@ public: 
    virtual void*       getBase() const = 0;

    virtual void*       getBase() const = 0;

    virtual size_t      getSize() const = 0;

    virtual size_t      getSize() const = 0;

    virtual uint32_t    getFlags() const = 0;

    virtual uint32_t    getFlags() const = 0;

    virtual uint32_t    getOffset() const = 0;





    // these are there just for backward source compatibility

    // these are there just for backward source compatibility

    int32_t heapID() const { return getHeapID(); }

    int32_t heapID() const { return getHeapID(); }

include/binder/MemoryHeapBase.h

+8 −6
Original line number Original line Diff line number Diff line
@@ -61,6 +61,7 @@ public: 
    virtual void*       getBase() const;

    virtual void*       getBase() const;

    virtual size_t      getSize() const;

    virtual size_t      getSize() const;

    virtual uint32_t    getFlags() const;

    virtual uint32_t    getFlags() const;

    virtual uint32_t      getOffset() const;





    const char*         getDevice() const;

    const char*         getDevice() const;
@@ -90,6 +91,7 @@ private: 
    uint32_t    mFlags;

    uint32_t    mFlags;

    const char* mDevice;

    const char* mDevice;

    bool        mNeedUnmap;

    bool        mNeedUnmap;

    uint32_t    mOffset;

};

};





// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------

libs/binder/IMemory.cpp

+32 −21
Original line number Original line Diff line number Diff line
@@ -81,6 +81,7 @@ public: 
    virtual void* getBase() const;

    virtual void* getBase() const;

    virtual size_t getSize() const;

    virtual size_t getSize() const;

    virtual uint32_t getFlags() const;

    virtual uint32_t getFlags() const;

    virtual uint32_t getOffset() const;





private:

private:

    friend class IMemory;

    friend class IMemory;
@@ -107,6 +108,7 @@ private: 
    mutable void*       mBase;

    mutable void*       mBase;

    mutable size_t      mSize;

    mutable size_t      mSize;

    mutable uint32_t    mFlags;

    mutable uint32_t    mFlags;

    mutable uint32_t    mOffset;

    mutable bool        mRealHeap;

    mutable bool        mRealHeap;

    mutable Mutex       mLock;

    mutable Mutex       mLock;

};

};
@@ -229,7 +231,7 @@ status_t BnMemory::onTransact( 




BpMemoryHeap::BpMemoryHeap(const sp<IBinder>& impl)

BpMemoryHeap::BpMemoryHeap(const sp<IBinder>& impl)

    : BpInterface<IMemoryHeap>(impl),

    : BpInterface<IMemoryHeap>(impl),

        mHeapId(-1), mBase(MAP_FAILED), mSize(0), mFlags(0), mRealHeap(false)

        mHeapId(-1), mBase(MAP_FAILED), mSize(0), mFlags(0), mOffset(0), mRealHeap(false)

{

{

}

}
@@ -270,6 +272,7 @@ void BpMemoryHeap::assertMapped() const 
            if (mHeapId == -1) {

            if (mHeapId == -1) {

                mBase   = heap->mBase;

                mBase   = heap->mBase;

                mSize   = heap->mSize;

                mSize   = heap->mSize;

                mOffset = heap->mOffset;

                android_atomic_write( dup( heap->mHeapId ), &mHeapId );

                android_atomic_write( dup( heap->mHeapId ), &mHeapId );

            }

            }

        } else {

        } else {
@@ -293,6 +296,7 @@ void BpMemoryHeap::assertReallyMapped() const 
        int parcel_fd = reply.readFileDescriptor();

        int parcel_fd = reply.readFileDescriptor();

        ssize_t size = reply.readInt32();

        ssize_t size = reply.readInt32();

        uint32_t flags = reply.readInt32();

        uint32_t flags = reply.readInt32();

        uint32_t offset = reply.readInt32();





        LOGE_IF(err, "binder=%p transaction failed fd=%d, size=%ld, err=%d (%s)",

        LOGE_IF(err, "binder=%p transaction failed fd=%d, size=%ld, err=%d (%s)",

                asBinder().get(), parcel_fd, size, err, strerror(-err));

                asBinder().get(), parcel_fd, size, err, strerror(-err));
@@ -309,7 +313,7 @@ void BpMemoryHeap::assertReallyMapped() const 
        Mutex::Autolock _l(mLock);

        Mutex::Autolock _l(mLock);

        if (mHeapId == -1) {

        if (mHeapId == -1) {

            mRealHeap = true;

            mRealHeap = true;

            mBase = mmap(0, size, access, MAP_SHARED, fd, 0);

            mBase = mmap(0, size, access, MAP_SHARED, fd, offset);

            if (mBase == MAP_FAILED) {

            if (mBase == MAP_FAILED) {

                LOGE("cannot map BpMemoryHeap (binder=%p), size=%ld, fd=%d (%s)",

                LOGE("cannot map BpMemoryHeap (binder=%p), size=%ld, fd=%d (%s)",

                        asBinder().get(), size, fd, strerror(errno));

                        asBinder().get(), size, fd, strerror(errno));
@@ -317,6 +321,7 @@ void BpMemoryHeap::assertReallyMapped() const 
            } else {

            } else {

                mSize = size;

                mSize = size;

                mFlags = flags;

                mFlags = flags;

                mOffset = offset;

                android_atomic_write(fd, &mHeapId);

                android_atomic_write(fd, &mHeapId);

            }

            }

        }

        }
@@ -343,6 +348,11 @@ uint32_t BpMemoryHeap::getFlags() const { 
    return mFlags;

    return mFlags;

}

}





uint32_t BpMemoryHeap::getOffset() const {

    assertMapped();

    return mOffset;

}



// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------





IMPLEMENT_META_INTERFACE(MemoryHeap, "android.utils.IMemoryHeap");

IMPLEMENT_META_INTERFACE(MemoryHeap, "android.utils.IMemoryHeap");
@@ -362,6 +372,7 @@ status_t BnMemoryHeap::onTransact( 
            reply->writeFileDescriptor(getHeapID());

            reply->writeFileDescriptor(getHeapID());

            reply->writeInt32(getSize());

            reply->writeInt32(getSize());

            reply->writeInt32(getFlags());

            reply->writeInt32(getFlags());

            reply->writeInt32(getOffset());

            return NO_ERROR;

            return NO_ERROR;

        } break;

        } break;

        default:

        default:

libs/binder/MemoryHeapBase.cpp

+10 −5
Original line number Original line Diff line number Diff line
@@ -42,13 +42,13 @@ namespace android { 




MemoryHeapBase::MemoryHeapBase()

MemoryHeapBase::MemoryHeapBase()

    : mFD(-1), mSize(0), mBase(MAP_FAILED),

    : mFD(-1), mSize(0), mBase(MAP_FAILED),

      mDevice(NULL), mNeedUnmap(false) 

      mDevice(NULL), mNeedUnmap(false), mOffset(0)

{

{

}

}





MemoryHeapBase::MemoryHeapBase(size_t size, uint32_t flags, char const * name)

MemoryHeapBase::MemoryHeapBase(size_t size, uint32_t flags, char const * name)

    : mFD(-1), mSize(0), mBase(MAP_FAILED), mFlags(flags),

    : mFD(-1), mSize(0), mBase(MAP_FAILED), mFlags(flags),

      mDevice(0), mNeedUnmap(false)

      mDevice(0), mNeedUnmap(false), mOffset(0)

{

{

    const size_t pagesize = getpagesize();

    const size_t pagesize = getpagesize();

    size = ((size + pagesize-1) & ~(pagesize-1));

    size = ((size + pagesize-1) & ~(pagesize-1));
@@ -65,7 +65,7 @@ MemoryHeapBase::MemoryHeapBase(size_t size, uint32_t flags, char const * name) 




MemoryHeapBase::MemoryHeapBase(const char* device, size_t size, uint32_t flags)

MemoryHeapBase::MemoryHeapBase(const char* device, size_t size, uint32_t flags)

    : mFD(-1), mSize(0), mBase(MAP_FAILED), mFlags(flags),

    : mFD(-1), mSize(0), mBase(MAP_FAILED), mFlags(flags),

      mDevice(0), mNeedUnmap(false)

      mDevice(0), mNeedUnmap(false), mOffset(0)

{

{

    int open_flags = O_RDWR;

    int open_flags = O_RDWR;

    if (flags & NO_CACHING)

    if (flags & NO_CACHING)
@@ -84,7 +84,7 @@ MemoryHeapBase::MemoryHeapBase(const char* device, size_t size, uint32_t flags) 




MemoryHeapBase::MemoryHeapBase(int fd, size_t size, uint32_t flags, uint32_t offset)

MemoryHeapBase::MemoryHeapBase(int fd, size_t size, uint32_t flags, uint32_t offset)

    : mFD(-1), mSize(0), mBase(MAP_FAILED), mFlags(flags),

    : mFD(-1), mSize(0), mBase(MAP_FAILED), mFlags(flags),

      mDevice(0), mNeedUnmap(false)

      mDevice(0), mNeedUnmap(false), mOffset(0)

{

{

    const size_t pagesize = getpagesize();

    const size_t pagesize = getpagesize();

    size = ((size + pagesize-1) & ~(pagesize-1));

    size = ((size + pagesize-1) & ~(pagesize-1));
@@ -141,6 +141,7 @@ status_t MemoryHeapBase::mapfd(int fd, size_t size, uint32_t offset) 
    }

    }

    mFD = fd;

    mFD = fd;

    mSize = size;

    mSize = size;

    mOffset = offset;

    return NO_ERROR;

    return NO_ERROR;

}

}
@@ -183,5 +184,9 @@ const char* MemoryHeapBase::getDevice() const { 
    return mDevice;

    return mDevice;

}

}





uint32_t MemoryHeapBase::getOffset() const {

    return mOffset;

}



// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------

}; // namespace android
 
}; // namespace android