SYSCALL vm_addr GetCachedSegment (uint64 *in_segment_id)
{
struct Process *current;
struct Segment *seg;
uint64 segment_id;
uint64 key;
current = GetCurrentProcess();
CopyIn (&segment_id, in_segment_id, sizeof (segment_id));
key = segment_id % CACHE_HASH_SZ;
seg = LIST_HEAD (&cache_hash[key]);
DisablePreemption();
while (seg != NULL)
{
if (seg->segment_id == segment_id && seg->owner == current)
{
LIST_REM_ENTRY (&cache_lru_list, seg, lru_link);
LIST_REM_ENTRY (&cache_hash[key], seg, hash_link);
if (seg == last_aged_seg)
last_aged_seg = NULL;
return seg->base;
}
seg = LIST_NEXT (seg, hash_link);
}
return (vm_addr)NULL;
}
int DoCloseInterruptHandler (int handle)
{
struct ISRHandler *isr_handler;
struct Process *current;
int irq;
current = GetCurrentProcess();
if ((isr_handler = GetObject(current, handle, HANDLE_TYPE_ISR)) == NULL)
return paramErr;
DisablePreemption();
irq = isr_handler->irq;
DisableInterrupts();
LIST_REM_ENTRY (&isr_handler_list[irq], isr_handler, isr_handler_entry);
irq_handler_cnt[irq] --;
if (irq_handler_cnt[irq] == 0)
MaskInterrupt(irq);
EnableInterrupts();
LIST_ADD_HEAD (&free_isr_handler_list, isr_handler, isr_handler_entry);
free_isr_handler_cnt ++;
FreeHandle (handle);
return 0;
}
SYSCALL int ExpungeCachedSegment (uint64 *in_segment_id)
{
struct Process *current;
struct Segment *seg;
uint64 segment_id;
uint64 key;
current = GetCurrentProcess();
CopyIn (&segment_id, in_segment_id, sizeof (segment_id));
key = segment_id % CACHE_HASH_SZ;
seg = LIST_HEAD (&cache_hash[key]);
DisablePreemption();
while (seg != NULL)
{
if (seg->segment_id == segment_id && seg->owner == current)
{
LIST_REM_ENTRY (&cache_lru_list, seg, lru_link);
LIST_REM_ENTRY (&cache_hash[key], seg, hash_link);
if (seg == last_aged_seg)
last_aged_seg = NULL;
HEAP_ADD_HEAD (&free_segment_list[seg->bucket_q], seg, link);
seg->size = 0;
seg->physical_addr = (vm_addr)NULL;
seg->flags = MEM_FREE;
seg->owner = NULL;
PmapRemoveRegion (seg);
return 0;
}
else if (seg->segment_id == segment_id && seg->owner != current)
{
return memoryErr;
}
seg = LIST_NEXT (seg, hash_link);
}
return memoryErr;
}
void DoAtaRemCallback (struct BlkReq *blkreq)
{
struct Ata *ata;
ata = blkreq->unitp;
LIST_REM_ENTRY (&ata->callback_list, blkreq->callback, callback_entry);
blkreq->error = 0;
blkreq->rc = 0;
}
void WakeupProcess (struct Process *proc)
{
struct Rendez *rendez;
DisablePreemption();
KASSERT (proc->state == PROC_STATE_SLEEP);
rendez = proc->sleeping_on;
LIST_REM_ENTRY (&rendez->process_list, proc, rendez_link);
proc->sleeping_on = NULL;
proc->state = PROC_STATE_READY;
SchedReady(proc);
}
void CDFreeNode (struct CDSB *cdsb, struct CDNode *node)
{
node->reference_cnt--;
if (node == &cdsb->root_node)
{
return;
}
if (node->reference_cnt == 0)
{
LIST_REM_ENTRY (&cdsb->node_list, node, node_entry);
KFree (node);
}
}
void FreeNode (struct FatSB *fsb, struct FatNode *node)
{
node->reference_cnt--;
if (node == &fsb->root_node)
{
return;
}
FlushDirent (fsb, node);
if (node->reference_cnt == 0)
{
LIST_REM_ENTRY (&fsb->node_list, node, node_entry);
KFree (node);
}
}
void FreeAddressSpace (struct AddressSpace *as)
{
struct MemRegion *mr;
struct Pageframe *pf;
if (as->active == FALSE)
return;
MutexLock (&vm_mutex);
while ((mr = LIST_HEAD (&as->sorted_memregion_list)) != NULL)
{
while ((pf = LIST_HEAD (&mr->pageframe_list)) != NULL)
{
LIST_REM_HEAD (&mr->pageframe_list, memregion_entry);
pf->virtual_addr = 0;
pf->state = PF_FREE;
LIST_ADD_HEAD (&unused_pageframe_list, pf, unused_entry);
free_pageframe_cnt ++;
}
LIST_REM_ENTRY (&as->sorted_memregion_list, mr, sorted_entry);
LIST_ADD_HEAD (&unused_memregion_list, mr, unused_entry);
free_memregion_cnt ++;
}
PmapDestroy (as);
as->active = FALSE;
MutexUnlock (&vm_mutex);
}
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;
}
}
}
