/**
Extract a role UUID.
@param aRole a TUUID object to update.
@param aOffset The role extracted is the aOffset the role in the packet.
valid values are zero and one.
@return KErrCorrupt Invalid UUID size.
@internalComponent
*/
TInt RBnepSetupConnectionRequestControl::GetRole (TUUID& aRole, TInt aOffset)
{
LOG_FUNC
aRole = TUUID(KRoleUnknown);
TBuf8<KSdpUUIDMaxLength> buf;
buf.SetLength(KUUIDSizeLength);
if(Length() < KUUIDSizeOffset + KUUIDSizeLength)
{
return KErrCorrupt;
}
CopyOut(buf, KUUIDSizeOffset);
TInt uuidSize = buf[0];
LOG1(_L8("uuidSize = %d"),uuidSize);
TInt offset;
switch (uuidSize)
{
case 2:
case 4:
case 16:
// If the UUID length is valid, extract its value.
buf.SetLength(uuidSize);
//Check the offset is within our buffer boundary
offset = KUUIDOffset + aOffset * uuidSize;
if(Length() < offset + uuidSize)
{
return KErrCorrupt;
}
CopyOut(buf, offset);
TRAPD(err, aRole.SetL(buf));
return err;
default:
return KErrCorrupt;
}
}
SYSCALL int WireMem (vm_addr addr, vm_addr *ret_phys)
{
struct Process *current;
struct Segment *seg;
vm_addr phys;
current = GetCurrentProcess();
if (!(current->flags & PROCF_ALLOW_IO))
return privilegeErr;
if ((seg = SegmentFind (addr)) == NULL || seg->owner != current
|| MEM_TYPE(seg->flags) != MEM_ALLOC)
{
return memoryErr;
}
if (seg->flags & SEG_WIRED)
return memoryErr;
if (seg->flags & SEG_COMPACT)
Sleep (&compact_rendez);
phys = seg->physical_addr + (addr - seg->base);
CopyOut (ret_phys, &phys, sizeof (vm_addr));
DisablePreemption();
seg->flags |= SEG_WIRED;
PmapCachePreDMA (seg);
return 0;
}
int CopyArgEnvToUserSpace (struct ArgInfo *ai, struct AddressSpace *new_as)
{
vm_addr ubase;
char **argv, **env;
KPRINTF ("CopyArgsToUserSpace()");
if ((ubase = UMap(0, ARG_MAX ,VM_PROT_READWRITE, 0)) != MAP_FAILED)
{
argv = ai->argv;
env = ai->env;
if (argv != NULL)
{
while (*argv != NULL)
{
*argv = (char *)ubase + ((char *)*argv - (char *)ai->buf);
argv++;
}
}
if (env != NULL)
{
while (*env != NULL)
{
*env = (char *)ubase + ((char *)*env - (char *)ai->buf);
env++;
}
}
ai->ubase = ubase;
ai->uargv = (char **)((uint8 *)ubase + ((uint8 *)ai->argv - (uint8 *)ai->buf));
ai->uenv = (char **)((uint8 *)ubase + ((uint8 *)ai->env - (uint8 *)ai->buf));
KPRINTF ("CopyOut() CopyArgsToUserSpace");
if (CopyOut (new_as, (void *)ubase, ai->buf, ARG_MAX) == 0)
{
return 0;
}
UUnmap (ubase);
}
return -1;
}
SYSCALL int PutCachedSegment (vm_addr addr, bits32_t flags, uint64 *out_segment_id)
{
struct Process *current;
struct Segment *seg;
uint64 segment_id;
uint64 key;
current = GetCurrentProcess();
seg = SegmentFind (addr);
if (seg == NULL || MEM_TYPE(seg->flags) != MEM_ALLOC || seg->owner != current)
return paramErr;
segment_id = seg->segment_id;
key = segment_id % CACHE_HASH_SZ;
CopyOut (out_segment_id, &segment_id, sizeof (segment_id));
DisablePreemption();
LIST_ADD_HEAD (&cache_hash[key], seg, hash_link);
if (flags & CACHE_AGE)
{
if (last_aged_seg != NULL) {
LIST_INSERT_BEFORE (&cache_lru_list, last_aged_seg, seg, lru_link);
}
else {
LIST_ADD_TAIL (&cache_lru_list, seg, lru_link);
}
last_aged_seg = seg;
}
else {
LIST_ADD_HEAD (&cache_lru_list, seg, lru_link);
}
PmapRemoveRegion (seg);
return 0;
}
SYSCALL int VirtualVersion (vm_addr addr, uint64 *segment_id)
{
struct Segment *seg;
struct Process *current;
current = GetCurrentProcess();
addr = ALIGN_DOWN (addr, PAGE_SIZE);
if ((seg = SegmentFind (addr)) == NULL || seg->owner != current
|| !(MEM_TYPE(seg->flags) == MEM_ALLOC || MEM_TYPE(seg->flags) == MEM_PHYS))
{
return memoryErr;
}
if (seg->flags & SEG_COMPACT)
Sleep (&compact_rendez);
CopyOut (segment_id, &seg->segment_id, sizeof (uint64));
DisablePreemption();
seg->flags |= MAP_VERSION;
return 0;
}
int DuplicateAddressSpace (struct AddressSpace *src_as, struct AddressSpace *dst_as)
{
struct MemRegion *mr;
struct Pageframe *pf;
int error = 0;
uint32 prot;
struct AddressSpace *old_as;
if (AllocDupAddressSpace (src_as, dst_as) == 0)
{
mr = LIST_HEAD (&dst_as->sorted_memregion_list);
while (mr != NULL && error == 0)
{
if (mr->type == MR_TYPE_ANON)
{
prot = mr->prot;
old_as = SwitchAddressSpace (dst_as);
UProtect (mr->base_addr, VM_PROT_READWRITE);
SwitchAddressSpace (old_as);
/* IMPROVEMENT:
*
* Try to copy upto 64k (VM_TEMP_BUF_SZ) worth of linear
* pages at a time, reduces number of task switches
* and concentrates on inner loops
*/
pf = LIST_HEAD (&mr->pageframe_list);
while (pf != NULL && error == 0)
{
error = CopyIn (src_as, (void *)vm_temp_buf, (void *)pf->virtual_addr, PAGE_SIZE);
if (error == 0)
error = CopyOut (dst_as, (void *)pf->virtual_addr, (void *)vm_temp_buf, PAGE_SIZE);
pf = LIST_NEXT (pf, memregion_entry);
}
old_as = SwitchAddressSpace (dst_as);
UProtect (mr->base_addr, prot);
SwitchAddressSpace (old_as);
}
mr = LIST_NEXT (mr, sorted_entry);
}
if (error != 0)
FreeAddressSpace (dst_as);
}
else
error = -1;
KASSERT (error != -1);
return error;
}
void root_beginio (void *ioreq)
{
struct FSReq *fsreq = ioreq;
struct RootFilp *filp;
struct Mount *mount;
int len;
KPRINTF ("root_beginio()");
fsreq->flags |= IOF_QUICK;
switch (fsreq->cmd)
{
case FS_CMD_OPEN:
fsreq->error = ENOSYS;
fsreq->rc = -1;
break;
case FS_CMD_PIPE:
fsreq->error = ENOSYS;
fsreq->rc = -1;
break;
case FS_CMD_CLOSE:
fsreq->error = ENOSYS;
fsreq->rc = -1;
break;
case FS_CMD_DUP: /* Might want to dup() the handle? */
fsreq->error = ENOSYS;
fsreq->rc = -1;
break;
case FS_CMD_READ:
fsreq->error = ENOSYS;
fsreq->nbytes_transferred = -1;
fsreq->rc = -1;
break;
case FS_CMD_WRITE:
fsreq->error = ENOSYS;
fsreq->nbytes_transferred = -1;
fsreq->rc = -1;
break;
case FS_CMD_LSEEK:
fsreq->error = ENOSYS;
fsreq->position = -1;
break;
case FS_CMD_UNLINK:
fsreq->error = ENOSYS;
fsreq->rc = -1;
break;
case FS_CMD_RENAME:
fsreq->error = ENOSYS;
fsreq->rc = -1;
break;
case FS_CMD_FTRUNCATE:
fsreq->error = ENOSYS;
fsreq->rc = -1;
break;
case FS_CMD_FSTAT:
fsreq->stat->st_mode = S_IFDIR | (S_IRUSR | S_IRGRP | S_IROTH);
fsreq->stat->st_nlink = 1; /* ??? 0 ??? */
fsreq->stat->st_uid = 1;
fsreq->stat->st_gid = 1;
fsreq->stat->st_rdev = 5;
fsreq->stat->st_size = 0;
fsreq->stat->st_atime = 0;
fsreq->stat->st_mtime = 0;
fsreq->stat->st_ctime = 0;
fsreq->stat->st_blocks = 0;
fsreq->error = 0;
fsreq->rc = 0;
break;
case FS_CMD_STAT:
fsreq->stat->st_mode = S_IFDIR | (S_IRUSR | S_IRGRP | S_IROTH);
fsreq->stat->st_nlink = 1; /* ??? 0 ??? */
fsreq->stat->st_uid = 1;
fsreq->stat->st_gid = 1;
fsreq->stat->st_rdev = 5;
fsreq->stat->st_size = 0;
fsreq->stat->st_atime = 0;
fsreq->stat->st_mtime = 0;
fsreq->stat->st_ctime = 0;
fsreq->stat->st_blocks = 0;
fsreq->error = 0;
fsreq->rc = 0;
break;
case FS_CMD_FSTATFS:
fsreq->error = ENOSYS;
fsreq->rc = -1;
break;
case FS_CMD_FSYNC:
fsreq->error = ENOSYS;
fsreq->rc = -1;
break;
case FS_CMD_SYNC:
fsreq->error = ENOSYS;
fsreq->rc = -1;
break;
case FS_CMD_MKDIR:
fsreq->error = ENOSYS;
fsreq->rc = -1;
break;
case FS_CMD_RMDIR:
fsreq->error = ENOSYS;
fsreq->rc = -1;
break;
case FS_CMD_OPENDIR:
{
if ((filp = KMalloc (sizeof (struct RootFilp))) != NULL)
{
filp->device = &root_handler;
filp->seek_mount = LIST_HEAD (&mount_list);
LIST_ADD_TAIL (&root_filp_list, filp, filp_entry);
fsreq->filp = filp;
fsreq->device = &root_handler;
fsreq->error = 0;
fsreq->rc = 0;
}
else
{
fsreq->error = ENOSYS;
fsreq->rc = -1;
}
break;
}
case FS_CMD_CLOSEDIR:
{
filp = fsreq->filp;
LIST_REM_ENTRY (&root_filp_list, filp, filp_entry);
KFree (filp);
fsreq->error = 0;
fsreq->rc = 0;
break;
}
case FS_CMD_READDIR:
filp = fsreq->filp;
mount = filp->seek_mount;
if (mount != NULL)
{
len = StrLen (mount->name);
if (len + 1 <= NAME_MAX)
{
CopyOut (fsreq->as, &fsreq->dirent->d_name, mount->name, len + 1);
filp->seek_mount = LIST_NEXT (mount, mount_list_entry);
fsreq->error = 0;
fsreq->rc = 0;
}
else
{
fsreq->dirent = NULL;
fsreq->error = ENAMETOOLONG;
fsreq->rc = -1;
}
}
else
{
fsreq->dirent = NULL;
fsreq->error = 0;
fsreq->rc = -1;
}
break;
case FS_CMD_REWINDDIR:
filp = fsreq->filp;
filp->seek_mount = LIST_HEAD (&mount_list);
fsreq->error = 0;
fsreq->rc = 0;
break;
case FS_CMD_ISATTY:
fsreq->error = 0;
fsreq->rc = 0;
break;
case FS_CMD_TCGETATTR:
fsreq->error = ENOTTY;
fsreq->rc = -1;
break;
case FS_CMD_TCSETATTR:
fsreq->error = ENOTTY;
fsreq->rc = -1;
break;
case FS_CMD_IOCTL:
fsreq->error = ENOSYS;
fsreq->rc = -1;
break;
default:
{
KPANIC ("ROOT Unknown command");
fsreq->error = ENOSYS;
fsreq->rc = -1;
break;
}
}
}
