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; }