Subversion Repositories HelenOS

Compare Revisions

Ignore whitespace Rev 2445 → Rev 2444

/trunk/kernel/generic/include/lib/rd.h
40,7 → 40,7
/**
* RAM disk version
*/
#define RD_VERSION 1
#define RD_VERSION 0
 
/**
* RAM disk magic number
/trunk/kernel/generic/include/errno.h
37,7 → 37,6
 
/* 1-255 are kernel error codes, 256-512 are user error codes */
 
#define EOK 0 /* No error */
#define ENOENT -1 /* No such entry */
#define ENOMEM -2 /* Not enough memory */
#define ELIMIT -3 /* Limit exceeded */
/trunk/kernel/generic/src/lib/rd.c
42,16 → 42,9
#include <mm/frame.h>
#include <sysinfo/sysinfo.h>
#include <ddi/ddi.h>
#include <print.h>
#include <align.h>
 
static parea_t rd_parea; /**< Physical memory area for rd. */
 
/**
* RAM disk initialization routine. At this point, the RAM disk memory is shared
* and information about the share is provided as sysinfo values to the userspace
* tasks.
*/
int init_rd(rd_header * header, size_t size)
{
/* Identify RAM disk */
81,9 → 74,6
if ((hsize % FRAME_SIZE) || (dsize % FRAME_SIZE))
return RE_UNSUPPORTED;
if (dsize % FRAME_SIZE)
return RE_UNSUPPORTED;
 
if (hsize > size)
return RE_INVALID;
90,7 → 80,7
if ((uint64_t) hsize + dsize > size)
dsize = size - hsize;
rd_parea.pbase = ALIGN_DOWN((uintptr_t) KA2PA((void *) header + hsize), FRAME_SIZE);
rd_parea.pbase = KA2PA((void *) header + hsize);
rd_parea.vbase = (uintptr_t) ((void *) header + hsize);
rd_parea.frames = SIZE2FRAMES(dsize);
rd_parea.cacheable = true;
97,7 → 87,6
ddi_parea_register(&rd_parea);
 
sysinfo_set_item_val("rd", NULL, true);
sysinfo_set_item_val("rd.header_size", NULL, hsize);
sysinfo_set_item_val("rd.size", NULL, dsize);
sysinfo_set_item_val("rd.address.physical", NULL, (unative_t)
KA2PA((void *) header + hsize));
/trunk/kernel/generic/src/main/kinit.c
167,7 → 167,6
 
task_t *utask = task_run_program((void *) init.tasks[i].addr,
"uspace");
if (utask) {
/*
* Set capabilities to init userspace tasks.
182,7 → 181,7
init.tasks[i].size);
if (rd != RE_OK)
printf("Init binary %zd not used, error code %d.\n", i, rd);
printf("Init binary %zd not used.\n", i);
}
}
 
/trunk/kernel/doc/AUTHORS
4,5 → 4,4
Jakub Vana <vana@helenos.eu>
Josef Cejka <cejka@helenos.eu>
Sergey Bondari <bondari@helenos.eu>
Michal Konopa <mkonopa@seznam.cz>
 
/trunk/uspace/libc/generic/io/file.c
File deleted
/trunk/uspace/libc/include/ipc/services.h
42,7 → 42,6
#define SERVICE_VIDEO 3
#define SERVICE_CONSOLE 4
#define SERVICE_RD 5
#define SERVICE_FS 6
 
/* Memory area to be received from NS */
#define SERVICE_MEM_REALTIME 1
/trunk/uspace/libc/include/io/file.h
File deleted
/trunk/uspace/rd/rd.h
File deleted
/trunk/uspace/rd/rd.c
1,7 → 1,5
/*
* Copyright (c) 2007 Michal Konopa
* Copyright (c) 2007 Martin Jelen
* Copyright (c) 2007 Peter Majer
* Copyright (c) 2006 Martin Decky
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
47,17 → 45,7
#include <bool.h>
#include <errno.h>
#include <async.h>
#include <stdlib.h>
#include <unistd.h>
#include <align.h>
#include <async.h>
#include <ddi.h>
#include <libarch/ddi.h>
#include <stdio.h>
#include "rd.h"
 
static void *rd_addr;
static void *fs_addr;
 
static void rd_connection(ipc_callid_t iid, ipc_call_t *icall)
{
66,24 → 54,15
int retval;
 
ipc_answer_fast(iid, 0, 0, 0);
ipcarg_t offset;
 
while (1) {
callid = async_get_call(&call);
switch (IPC_GET_METHOD(call)) {
case IPC_M_PHONE_HUNGUP:
ipc_answer_fast(callid, 0,0,0);
return;
case IPC_M_AS_AREA_SEND:
ipc_answer_fast(callid, 0, (uintptr_t)fs_addr, 0);
continue;
case RD_READ_BLOCK:
offset = IPC_GET_ARG1(call);
memcpy((void *)fs_addr, rd_addr+offset, BLOCK_SIZE);
retval = EOK;
break;
default:
retval = EINVAL;
case IPC_M_PHONE_HUNGUP:
ipc_answer_fast(callid, 0,0,0);
return;
default:
retval = EINVAL;
}
ipc_answer_fast(callid, retval, 0, 0);
}
92,8 → 71,6
 
static bool rd_init(void)
{
int retval, flags;
 
size_t rd_size = sysinfo_value("rd.size");
void * rd_ph_addr = (void *) sysinfo_value("rd.address.physical");
100,20 → 77,14
if (rd_size == 0)
return false;
rd_addr = as_get_mappable_page(rd_size);
void * rd_addr = as_get_mappable_page(rd_size);
flags = AS_AREA_READ | AS_AREA_WRITE | AS_AREA_CACHEABLE;
retval = physmem_map(rd_ph_addr, rd_addr, ALIGN_UP(rd_size, PAGE_SIZE) >> PAGE_WIDTH, flags);
 
if (retval < 0)
return false;
physmem_map(rd_ph_addr, rd_addr, ALIGN_UP(rd_size, PAGE_SIZE) >> PAGE_WIDTH, AS_AREA_READ | AS_AREA_WRITE);
size_t fs_size = ALIGN_UP(BLOCK_SIZE * sizeof(char), PAGE_SIZE);
fs_addr = as_get_mappable_page(fs_size);
 
return true;
}
 
 
int main(int argc, char **argv)
{
if (rd_init()) {