fssh_status_t
FileMap::_Add(fssh_file_io_vec* vecs, fssh_size_t vecCount,
fssh_off_t& lastOffset)
{
TRACE(("FileMap@%p::Add(vecCount = %ld)\n", this, vecCount));
uint32_t start = fCount;
fssh_off_t offset = 0;
fssh_status_t status = _MakeSpace(fCount + vecCount);
if (status != FSSH_B_OK)
return status;
file_extent* lastExtent = NULL;
if (start != 0) {
lastExtent = ExtentAt(start - 1);
offset = lastExtent->offset + lastExtent->disk.length;
}
for (uint32_t i = 0; i < vecCount; i++) {
if (lastExtent != NULL) {
if (lastExtent->disk.offset + lastExtent->disk.length
== vecs[i].offset) {
lastExtent->disk.length += vecs[i].length;
offset += vecs[i].length;
start--;
_MakeSpace(fCount - 1);
continue;
}
}
file_extent* extent = ExtentAt(start + i);
extent->offset = offset;
extent->disk = vecs[i];
offset += extent->disk.length;
lastExtent = extent;
}
#ifdef TRACE_FILE_MAP
for (uint32 i = 0; i < fCount; i++) {
file_extent* extent = ExtentAt(i);
dprintf("[%ld] extent offset %Ld, disk offset %Ld, length %Ld\n",
i, extent->offset, extent->disk.offset, extent->disk.length);
}
#endif
lastOffset = offset;
return FSSH_B_OK;
}
void
FileMap::_InvalidateAfter(fssh_off_t offset)
{
uint32_t index;
file_extent* extent = _FindExtent(offset, &index);
if (extent != NULL) {
_MakeSpace(index + 1);
if (extent->offset + extent->disk.length > offset) {
extent->disk.length = offset - extent->offset;
if (extent->disk.length == 0)
_MakeSpace(index);
}
}
}
trace_entry*
TracingMetaData::AllocateEntry(size_t size, uint16 flags)
{
if (fAfterLastEntry == NULL || size == 0
|| size >= kMaxTracingEntryByteSize) {
return NULL;
}
InterruptsSpinLocker _(fLock);
size = (size + 3) >> 2;
// 4 byte aligned, don't store the lower 2 bits
TRACE(("AllocateEntry(%lu), start %p, end %p, buffer %p\n", size * 4,
fFirstEntry, fAfterLastEntry, fBuffer));
if (!_MakeSpace(size))
return NULL;
trace_entry* entry = fAfterLastEntry;
entry->size = size;
entry->flags = flags;
fAfterLastEntry += size;
fAfterLastEntry->previous_size = size;
if (!(flags & BUFFER_ENTRY))
fEntries++;
TRACE((" entry: %p, end %p, start %p, entries %ld\n", entry,
fAfterLastEntry, fFirstEntry, fEntries));
return entry;
}
void
RemoteMessage::AddBitmap(const BBitmap& bitmap)
{
BRect bounds = bitmap.Bounds();
Add(bounds.IntegerWidth() + 1);
Add(bounds.IntegerHeight() + 1);
Add(bitmap.BytesPerRow());
Add(bitmap.ColorSpace());
Add(bitmap.Flags());
uint32 bitsLength = bitmap.BitsLength();
Add(bitsLength);
if (!_MakeSpace(bitsLength))
return;
memcpy(fBuffer + fWriteIndex, bitmap.Bits(), bitsLength);
fWriteIndex += bitsLength;
fAvailable -= bitsLength;
}
void
RemoteMessage::AddBitmap(const ServerBitmap& bitmap, bool minimal)
{
Add(bitmap.Width());
Add(bitmap.Height());
Add(bitmap.BytesPerRow());
if (!minimal) {
Add(bitmap.ColorSpace());
Add(bitmap.Flags());
}
uint32 bitsLength = bitmap.BitsLength();
Add(bitsLength);
if (!_MakeSpace(bitsLength))
return;
memcpy(fBuffer + fWriteIndex, bitmap.Bits(), bitsLength);
fWriteIndex += bitsLength;
fAvailable -= bitsLength;
}
void
CanvasMessage::AddBitmap(const ServerBitmap& bitmap, bool minimal)
{
//TODO:send PNG / as data: or as http: url
Add(bitmap.Width());
Add(bitmap.Height());
Add(bitmap.BytesPerRow());
if (!minimal) {
Add(bitmap.ColorSpace());
Add(bitmap.Flags());
}
uint32 bitsLength = bitmap.BitsLength();
Add(bitsLength);
if (!_MakeSpace(bitsLength))
return;
memcpy(fBuffer + fWriteIndex, bitmap.Bits(), bitsLength);
fWriteIndex += bitsLength;
fAvailable -= bitsLength;
}
/*
* Extended SVC entry
*/
LOCAL INT SegSVCentry( void *para, W fn )
{
INT ercd;
switch ( fn ) {
/* You can call it from all protection levels */
case SEG_FLUSHMEMCACHE_FN:
break;
default:
/* Caller protection level check */
ercd = ChkCallPLevel();
if ( ercd < E_OK ) {
goto err_ret;
}
}
switch ( fn ) {
case SEG_LOCKSPACE_FN:
case SEG_UNLOCKSPACE_FN:
ercd = E_OK;
break;
case SEG_CNVPHYSICALADDR_FN:
{ SEG_CNVPHYSICALADDR_PARA *p = para;
ercd = _CnvPhysicalAddr(p->laddr, p->len, p->paddr); }
break;
case SEG_CHKSPACE_FN:
{ SEG_CHKSPACE_PARA *p = para;
ercd = _ChkSpace(p->laddr, p->len, p->mode, p->env); }
break;
case SEG_CHKSPACETSTR_FN:
{ SEG_CHKSPACETSTR_PARA *p = para;
ercd = _ChkSpaceTstr(p->str, p->max, p->mode, p->env); }
break;
case SEG_CHKSPACEBSTR_FN:
{ SEG_CHKSPACEBSTR_PARA *p = para;
ercd = _ChkSpaceBstr(p->str, p->max, p->mode, p->env); }
break;
case SEG_MAPMEMORY_FN:
{ SEG_MAPMEMORY_PARA *p = para;
ercd = _MapMemory(p->paddr, p->len, p->attr, p->laddr); }
break;
case SEG_UNMAPMEMORY_FN:
{ SEG_UNMAPMEMORY_PARA *p = para;
ercd = _UnmapMemory(p->laddr); }
break;
case SEG_FLUSHMEMCACHE_FN:
{ SEG_FLUSHMEMCACHE_PARA *p = para;
ercd = _FlushMemCache(p->laddr, p->len, p->mode); }
break;
case SEG_CHKSPACELEN_FN:
{ SEG_CHKSPACELEN_PARA *p = para;
ercd = _ChkSpaceLen(p->laddr, p->len, p->mode, p->env, p->lsid); }
break;
case SEG_READMEMSPACE_FN:
case SEG_WRITEMEMSPACE_FN:
case SEG_SETMEMSPACEB_FN:
ercd = E_NOSPT;
break;
case SEG_MAKESPACE_FN:
{ SEG_MAKESPACE_PARA *p = para;
ercd = _MakeSpace(p->laddr, p->npage, p->lsid, p->pte); }
break;
case SEG_UNMAKESPACE_FN:
{ SEG_UNMAKESPACE_PARA *p = para;
ercd = _UnmakeSpace(p->laddr, p->npage, p->lsid); }
break;
case SEG_CHANGESPACE_FN:
{ SEG_CHANGESPACE_PARA *p = para;
ercd = _ChangeSpace(p->laddr, p->npage, p->lsid, p->pte); }
break;
/* T-Kernel 2.0 */
case SEG_CONTROLCACHE_FN:
{ SEG_CONTROLCACHE_PARA *p = para;
ercd = _ControlCache(p->addr, p->len, p->mode); }
break;
case SEG_GETSPACEINFO_FN:
{ SEG_GETSPACEINFO_PARA *p = para;
ercd = _GetSpaceInfo(p->addr, p->len, p->pk_spinfo); }
break;
case SEG_SETCACHEMODE_FN:
ercd = E_NOSPT;
break;
case SEG_SETMEMORYACCESS_FN:
{ SEG_SETMEMORYACCESS_PARA *p = para;
ercd = _SetMemoryAccess(p->addr, p->len, p->mode); }
break;
default:
ercd = E_RSFN;
}
err_ret:
return ercd;
}
