struct Mount *AllocAssign (char *alias, char *path)
{
struct Mount *assign;
int alias_len;
alias_len = StrLen (alias) + 1;
if ((assign = KMalloc (sizeof (struct Mount))) != NULL)
{
if ((assign->name = KMalloc (alias_len)) != NULL)
{
StrLCpy (assign->name, alias, alias_len);
if (ValidAlias (assign->name) == 0)
{
if ((assign->pathname = TranslatePathnameAliases (path)) != NULL)
{
assign->type = MOUNT_ASSIGN;
AddMount (assign);
return assign;
}
}
KFree (assign->name);
}
KFree (assign);
}
return NULL;
}
char *TranslatePathnameAliases (char *canon)
{
char *pathname;
char *path;
struct Mount *assign;
if ((pathname = KMalloc (MAX_PATHNAME_SZ)) != NULL)
{
canon = Advance (canon);
assign = FindAssign (canon);
if (assign != NULL && assign->type == MOUNT_ASSIGN)
{
StrLCpy (pathname, "/", MAX_PATHNAME_SZ);
StrLCpy (pathname, assign->pathname, MAX_PATHNAME_SZ);
canon = Advance (canon);
if (*canon != '\0')
{
StrLCat (pathname, "/", MAX_PATHNAME_SZ);
StrLCat (pathname, canon, MAX_PATHNAME_SZ);
}
}
else
{
StrLCpy (pathname, canon, MAX_PATHNAME_SZ);
}
}
return pathname;
}
char *AllocPathname (char *src)
{
char *buf;
if ((buf = KMalloc (MAX_PATHNAME_SZ)) != NULL)
{
if (CopyInStr (current_process->user_as, buf, src, MAX_PATHNAME_SZ) == 0)
return buf;
else
KFree (buf);
}
return NULL;
}
struct CDNode *CDAllocNode (struct CDSB *cdsb, struct ISODirEntry *idir)
{
struct CDNode *node;
if ((node = KMalloc (sizeof (struct CDNode))) != NULL)
{
node->extent_start = Iso733 (idir->extent);
node->size = Iso733 (idir->size);
node->flags = idir->flags[0];
node->cdsb = cdsb;
node->reference_cnt = 1;
/* CDSetTime (cdsb, node, idir, ST_ATIME | ST_MTIME | ST_CTIME); */
LIST_ADD_TAIL (&cdsb->node_list, node, node_entry);
LIST_INIT (&node->filp_list);
}
return node;
}
void AtaTaskInit (void)
{
KPRINTF ("AtaTaskInit()");
ata_pid = GetPID();
if ((ata_buffer = KMalloc (ATA_BUFFER_SZ)) != NULL)
{
if ((ata_timer_signal = AllocSignal()) != -1)
{
if ((ata_alarm_signal = AllocSignal()) != -1)
{
if ((ata_msgport = CreateMsgPort()) != NULL)
{
if (AtaInitUnits() == 0)
{
ata_init_error = 0;
KSignal (GetPPID(), SIG_INIT);
return;
}
DeleteMsgPort (ata_msgport);
}
FreeSignal (ata_alarm_signal);
}
FreeSignal (ata_timer_signal);
}
KFree (ata_buffer);
}
ata_init_error = -1;
KSignal (GetPPID(), SIG_INIT);
Exit(-1);
}
struct FatNode *AllocNode (struct FatSB *fsb, struct FatDirEntry *dirent, uint32 sector, uint32 offset)
{
struct FatNode *node;
if ((node = KMalloc (sizeof (struct FatNode))) != NULL)
{
MemCpy (&node->dirent, dirent, sizeof (struct FatDirEntry));
node->fsb = fsb;
node->reference_cnt = 1;
node->dirent_sector = sector;
node->dirent_offset = offset;
node->hint_cluster = 0;
node->hint_offset = 0;
LIST_ADD_TAIL (&fsb->node_list, node, node_entry);
LIST_INIT (&node->filp_list);
}
return node;
}
static void kKonohaFactory_Init(KonohaContext *kctx, kObject *o, void *conf)
{
struct kKonohaFactoryVar *f = (struct kKonohaFactoryVar *)o;
f->factory = (KonohaFactory *)KMalloc(sizeof(KonohaFactory), NULL);
memcpy(f->factory, kctx->platApi, sizeof(KonohaFactory));
}
char *CanonPathname (char *pathname)
{
char *temp;
char *canon = NULL;
char *src;
int error = 0;
if ((temp = KMalloc (MAX_PATHNAME_SZ)) != NULL)
{
if (CopyInStr (current_process->user_as, temp, pathname, MAX_PATHNAME_SZ) == 0)
{
if ((canon = KMalloc (MAX_PATHNAME_SZ)) != NULL)
{
*canon = '\0';
if (*temp != '/')
{
StrLCpy (canon, current_process->current_dir, MAX_PATHNAME_SZ);
src = temp;
}
else
{
src = Advance (temp);
}
while (*src != '\0')
{
if (CompareComponent("..", src) == 0)
{
if (DeleteLastComponent(canon) != 0)
{
SetError(ENOENT);
error = -1;
break;
}
}
else if (CompareComponent(".", src) != 0)
{
if (AppendComponent (canon, src) != 0)
{
SetError(ENAMETOOLONG);
error = -1;
break;
}
}
src = Advance (src);
}
if (error == 0)
{
if (*canon == '\0')
StrLCpy (canon, "/", MAX_PATHNAME_SZ);
}
else
{
KFree (canon);
}
}
else
error = -1;
}
else
error = -1;
KFree (temp);
}
if (error == -1)
return NULL;
else
return canon;
}
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;
}
}
}
int cd_opendevice (int unit, void *ioreq, uint32 flags)
{
struct FSReq *fsreq = ioreq;
struct CDSB *cdsb;
struct MountEnviron *me;
struct BlkReq blkreq;
KPRINTF ("cd_opendevice ()");
if ((cdsb = KMalloc (sizeof (struct CDSB))) != NULL)
{
me = fsreq->me;
if (OpenDevice (me->device_name, me->device_unit, &blkreq, me->device_flags) == 0)
{
/* FIXME: Shouldn't need it (also in fat handler) */
MemSet (cdsb, 0, sizeof (struct CDSB)); /* Need it as cdsb->validated isn't initialized */
cdsb->device = blkreq.device;
cdsb->unitp = blkreq.unitp;
cdsb->me = fsreq->me;
cdsb->reference_cnt = 0;
LIST_INIT (&cdsb->node_list);
LIST_INIT (&cdsb->active_filp_list);
LIST_INIT (&cdsb->invalid_filp_list);
cdsb->root_node.flags = ISO_DIRECTORY;
cdsb->root_node.cdsb = cdsb;
cdsb->root_node.reference_cnt = 0;
if ((cdsb->buf = CreateBuf (cdsb->device, cdsb->unitp,
me->buffer_cnt, me->block_size,
me->partition_start, me->partition_end,
me->writethru_critical, me->writeback_delay,
me->max_transfer)) != NULL)
{
if (KSpawn (CDTask, cdsb, 10, "cd.handler") != -1)
{
KWait (SIGF_INIT);
RWWriteLock (&mountlist_rwlock);
cd_device.reference_cnt ++;
cdsb->device_mount = MakeMount (cdsb->me, &cd_device, cdsb);
AddMount (cdsb->device_mount);
RWUnlock (&mountlist_rwlock);
fsreq->unitp = cdsb;
fsreq->error = 0;
fsreq->rc = 0;
return 0;
}
}
CloseDevice (&blkreq);
}
KFree (cdsb);
}
fsreq->error = IOERR_OPENFAIL;
fsreq->rc = -1;
KPANIC ("CD OpenDevice FAIL");
return -1;
}
