/*

* Copyright (C) 2015 Niek Linnenbank

*

* This program is free software: you can redistribute it and/or modify

* it under the terms of the GNU General Public License as published by

* the Free Software Foundation, either version 3 of the License, or

* (at your option) any later version.

*

* This program is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

* GNU General Public License for more details.

*

* You should have received a copy of the GNU General Public License

* along with this program. If not, see <http://www.gnu.org/licenses/>.

*/

#include <FreeNOS/System.h>

#include <MemoryChannel.h>

#include <List.h>

#include <ListIterator.h>

#include <SplitAllocator.h>

#include "ProcessEvent.h"

#warning merge with Process please

ProcessShares::ProcessShares(ProcessID pid)

{

m_pid = pid;

m_memory = ZERO;

m_kernelChannel = new MemoryChannel;

}

ProcessShares::~ProcessShares()

{

ProcessManager *procs = Kernel::instance->getProcessManager();

List<ProcessID> pids;

// Cleanup members

delete m_kernelChannel;

// Make a list of unique process IDs which

// have a share with this Process

Size size = m_shares.size();

for (Size i = 0; i < size; i++)

{

MemoryShare *sh = (MemoryShare *) m_shares.get(i);

if (sh)

{

if (!pids.contains(sh->pid))

pids.append(sh->pid);

releaseShare(sh, i);

}

}

// Raise process terminated events

for (ListIterator<ProcessID> i(pids); i.hasCurrent(); i++)

{

ProcessID pid = i.current();

Process *proc = procs->get(pid);

if (proc)

{

ProcessEvent event;

event.type = ProcessTerminated;

event.number = m_pid;

proc->raiseEvent(&event);

}

}

}

const ProcessID ProcessShares::getProcessID() const

{

return m_pid;

}

MemoryContext * ProcessShares::getMemoryContext()

{

return m_memory;

}

ProcessShares::Result ProcessShares::setMemoryContext(MemoryContext *ctx)

{

m_memory = ctx;

return Success;

}

ProcessShares::Result ProcessShares::createShare(ProcessID pid,

Size coreId,

Size tagId,

Address virt,

Size size)

{

MemoryShare *share = ZERO;

if (size == 0 || size % PAGESIZE)

return InvalidArgument;

// Allocate MemoryShare objects

share = new MemoryShare;

if (!share)

return OutOfMemory;

// Fill the share object

share->pid = pid;

share->coreId = coreId;

share->tagId = tagId;

share->range.virt = virt;

share->range.size = size;

m_memory->lookup(share->range.virt, &share->range.phys);

m_memory->access(share->range.virt, &share->range.access);

// insert into shares list

m_shares.insert(*share);

return Success;

}

ProcessShares::Result ProcessShares::createShare(ProcessShares & instance,

ProcessShares::MemoryShare *share)

{

MemoryShare *localShare = ZERO;

MemoryShare *remoteShare = ZERO;

MemoryContext *localMem = m_memory;

MemoryContext *remoteMem = instance.getMemoryContext();

Address paddr, vaddr;

Arch::Cache cache;

if (share->range.size == 0)

return InvalidArgument;

// Check if the share already exists

if (readShare(share) == Success)

return AlreadyExists;

// Allocate local

localShare = new MemoryShare;

if (!localShare)

return OutOfMemory;

// Allocate remote

remoteShare = new MemoryShare;

if (!remoteShare)

{

delete localShare;

return OutOfMemory;

}

// Allocate actual pages

if (Kernel::instance->getAllocator()->allocateLow(share->range.size, &paddr) != Allocator::Success)

return OutOfMemory;

// Zero out the pages

vaddr = (Address) Kernel::instance->getAllocator()->toVirtual(paddr);

MemoryBlock::set((void *)vaddr, 0, share->range.size);

for (Size i = 0; i < share->range.size; i+=PAGESIZE)

cache.cleanData(vaddr + i);

// Fill the local share object

localShare->pid = instance.getProcessID();

localShare->coreId = Kernel::instance->getCoreInfo()->coreId;

localShare->tagId = share->tagId;

localShare->range.phys = paddr;

localShare->range.size = share->range.size;

localShare->range.access = Memory::User | share->range.access;

localShare->attached = true;

// Map in the local process

if (localMem->findFree(localShare->range.size, MemoryMap::UserShare, &localShare->range.virt) != MemoryContext::Success ||

localMem->mapRange(&localShare->range) != MemoryContext::Success)

{

delete localShare;

delete remoteShare;

return OutOfMemory;

}

// Fill the remote share object

remoteShare->pid = m_pid;

remoteShare->coreId = localShare->coreId;

remoteShare->tagId = localShare->tagId;

remoteShare->range.phys = localShare->range.phys;

remoteShare->range.size = localShare->range.size;

remoteShare->range.access = localShare->range.access;

remoteShare->attached = true;

// Map in the remote process

if (remoteMem->findFree(remoteShare->range.size, MemoryMap::UserShare, &remoteShare->range.virt) != MemoryContext::Success ||

remoteMem->mapRange(&remoteShare->range) != MemoryContext::Success)

{

delete localShare;

delete remoteShare;

return OutOfMemory;

}

// TODO: for MemoryChannel: update access permissions, ro/rw for data/feedback

// insert into shares list

m_shares.insert(*localShare);

instance.m_shares.insert(*remoteShare);

// raise event on the remote process

Process *proc = Kernel::instance->getProcessManager()->get(instance.getProcessID());

ProcessEvent event;

event.type = ShareCreated;

event.number = m_pid;

MemoryBlock::copy(&event.share, remoteShare, sizeof(*remoteShare));

proc->raiseEvent(&event);

// Update parameter outputs

MemoryBlock::copy(share, localShare, sizeof(*share));

return Success;

}

ProcessShares::Result ProcessShares::removeShares(ProcessID pid)

{

// TODO: remove all shares for the given pid

// TODO: in case the share exists in the remote share AND in our share,

// just remove it here, mark it detached in the remote share.

// TODO: in case the share exists only in our side (detached), unmap and release all memory

// TODO: call this function from VMShare() and from IPCServer (when a ProcessTerminated message comes in)

Size size = m_shares.size();

MemoryShare *s = 0;

for (Size i = 0; i < size; i++)

{

if ((s = (MemoryShare *) m_shares.get(i)) != ZERO)

{

if (s->pid != pid)

continue;

releaseShare(s, i);

}

}

return Success;

}

ProcessShares::Result ProcessShares::releaseShare(MemoryShare *s, Size idx)

{

// Only release physical memory if both processes have detached.

// Note that in case all memory shares for a certain ProcessID have

// been detached but not yet released, and due to a very unlikely race

// condition (ProcessID reuse) a new memory share was just created (before old ones were released)

// the new memory share would also be detached here, resulting in a memory

// share with is detached in this process but attached and useless in the

// other process.

if (s->attached)

{

Process *proc = Kernel::instance->getProcessManager()->get(s->pid);

if (proc)

{

ProcessShares & shares = proc->getShares();

Size size = shares.m_shares.size();

// Mark all process shares detached in the other process

for (Size i = 0; i < size; i++)

{

MemoryShare *otherShare = (MemoryShare *) shares.m_shares.get(i);

if (otherShare && otherShare->pid == m_pid

&& otherShare->coreId == s->coreId)

{

otherShare->attached = false;

}

}

}

}

else

{

// Only release physical memory pages if the other

// process already detached earlier

Allocator *alloc = Kernel::instance->getAllocator();

for (Size i = 0; i < s->range.size; i += PAGESIZE)

alloc->release(s->range.phys + i);

}

// Unmap the share

m_memory->unmapRange(&s->range);

// Remove share from our administration

m_shares.remove(idx);

delete s;

return Success;

}

ProcessShares::Result ProcessShares::readShare(MemoryShare *share)

{

Size size = m_shares.size();

const MemoryShare *s = 0;

for (Size i = 0; i < size; i++)

{

if ((s = m_shares.get(i)) != ZERO)

{

if (s->pid == share->pid &&

s->coreId == share->coreId &&

s->tagId == share->tagId)

{

MemoryBlock::copy(share, s, sizeof(MemoryShare));

return Success;

}

}

}

return NotFound;

}