stv0g/metalsvm
1
0
Fork 0
Code Issues Pull requests Releases Wiki Activity

- tidy up the drivers folder

Browse source 
- all char driver could be find in drivers/char
This commit is contained in:
Marian Ohligs 2011-08-27 12:10:05 +02:00
parent 6ee8ee2be5
commit 591692f441
11 changed files with 327 additions and 469 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
Makefile.example
View file

@ -2,7 +2,7 @@ TOPDIR = $(shell pwd)
ARCH = x86
NAME = metalsvm
LWIPDIRS = lwip/src/arch lwip/src/api lwip/src/core lwip/src/core/ipv4 lwip/src/netif
DRIVERDIRS = drivers/net drivers/char drivers/stdin drivers/stdout drivers/stderr drivers/netchar
DRIVERDIRS = drivers/net drivers/char
KERNDIRS = libkern kernel mm fs arch/$(ARCH)/kernel arch/$(ARCH)/mm arch/$(ARCH)/scc $(LWIPDIRS) $(DRIVERDIRS)
SUBDIRS = $(KERNDIRS)

2
drivers/char/Makefile
View file

@ -1,4 +1,4 @@
C_source := null.c
C_source := stdio.c netio.c
MODULE := drivers_char

0
drivers/netchar/netchar.c → drivers/char/netio.c
View file

108
drivers/char/null.c
View file

@ -1,108 +0,0 @@
/*
* Copyright 2010 Stefan Lankes, Chair for Operating Systems,
* RWTH Aachen University
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* This file is part of MetalSVM.
*/
#include <metalsvm/stdlib.h>
#include <metalsvm/string.h>
#include <metalsvm/stdio.h>
#include <metalsvm/errno.h>
#include <metalsvm/fs.h>
#include <metalsvm/spinlock.h>
/* Implementation of a simple null device */
static ssize_t null_read(fildes_t* file, uint8_t* buffer, size_t size)
{
memset(buffer, 0x00, size);
file->offset += size;
return size;
}
static ssize_t null_write(fildes_t* file, uint8_t* buffer, size_t size)
{
return size;
}
static int null_open(fildes_t* file, const char* name)
{
return 0;
}
static int null_close(fildes_t* file)
{
return 0;
}
int null_init(vfs_node_t* node, const char* name)
{
uint32_t i, j;
vfs_node_t* new_node;
dir_block_t* blockdir;
dirent_t* dirent;
block_list_t* blist;
if (BUILTIN_EXPECT(!node || !name, 0))
return -EINVAL;
if (BUILTIN_EXPECT(node->type != FS_DIRECTORY, 0))
return -EINVAL;
if (finddir_fs(node, name))
return -EINVAL;
new_node = kmalloc(sizeof(vfs_node_t));
if (BUILTIN_EXPECT(!new_node, 0))
return -ENOMEM;
memset(new_node, 0x00, sizeof(vfs_node_t));
new_node->type = FS_CHARDEVICE;
new_node->open = &null_open;
new_node->close = &null_close;
new_node->read = &null_read;
new_node->write = &null_write;
spinlock_init(&new_node->lock);
blist= &node->block_list;
do {
for(i=0; i<MAX_DATABLOCKS; i++) {
if (blist->data[i]) {
blockdir = (dir_block_t*) blist->data[i];
for(j=0; j<MAX_DIRENTRIES; j++) {
dirent = &blockdir->entries[j];
if (!dirent->vfs_node) {
dirent->vfs_node = new_node;
strncpy(dirent->name, name, MAX_FNAME);
return 0;
}
}
}
}
if (!blist->next) {
blist->next = (block_list_t*) kmalloc(sizeof(block_list_t));
if (blist->next)
memset(blist->next, 0x00, sizeof(block_list_t));
}
} while(blist);
kfree(new_node, sizeof(vfs_node_t));
return -ENOMEM;
}

325
drivers/char/stdio.c Normal file
View file

@ -0,0 +1,325 @@
/*
* Copyright 2010 Stefan Lankes, Chair for Operating Systems,
* RWTH Aachen University
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* This file is part of MetalSVM.
*/
#include <metalsvm/stdlib.h>
#include <metalsvm/string.h>
#include <metalsvm/stdio.h>
#include <metalsvm/errno.h>
#include <metalsvm/fs.h>
#include <asm/kb.h>
#include <metalsvm/tasks.h>
#include <metalsvm/spinlock.h>
/* Functions of a simple null device */
static ssize_t null_read(fildes_t* file, uint8_t* buffer, size_t size)
{
memset(buffer, 0x00, size);
file->offset += size;
return size;
}
static ssize_t null_write(fildes_t* file, uint8_t* buffer, size_t size)
{
return size;
}
static int null_open(fildes_t* file, const char* name)
{
return 0;
}
static int null_close(fildes_t* file)
{
return 0;
}
/* Read Function of a stdio device */
static ssize_t stdio_read(fildes_t* file, uint8_t* buffer, size_t size)
{
kb_buffer.buffer = kmalloc(size * sizeof(char));
kb_buffer.maxsize = size;
kb_buffer.size = 0;
kb_buffer.tid = per_core(current_task)->id;
block_current_task();
//per_core(current_task)->status = TASK_BLOCKED;
reschedule();
size = kb_buffer.size;
memcpy(buffer, kb_buffer.buffer, size);
/*cleaning up */
kb_flush();
//kprintf("Size: %i, offset: %i, buffer: %s", size, buffer, offset);
file->offset += size;
return size;
}
/* Write Function of a stdio device */
static ssize_t stdio_write(fildes_t* file, uint8_t* buffer, size_t size)
{
int i;
for (i = 0; i<size; i++, buffer++) {
kputchar(*buffer);
}
file->offset += size;
return size;
}
/* Init Functions */
int null_init(vfs_node_t* node, const char* name)
{
uint32_t i, j;
vfs_node_t* new_node;
dir_block_t* blockdir;
dirent_t* dirent;
block_list_t* blist;
if (BUILTIN_EXPECT(!node || !name, 0))
return -EINVAL;
if (BUILTIN_EXPECT(node->type != FS_DIRECTORY, 0))
return -EINVAL;
if (finddir_fs(node, name))
return -EINVAL;
new_node = kmalloc(sizeof(vfs_node_t));
if (BUILTIN_EXPECT(!new_node, 0))
return -ENOMEM;
memset(new_node, 0x00, sizeof(vfs_node_t));
new_node->type = FS_CHARDEVICE;
new_node->open = &null_open;
new_node->close = &null_close;
new_node->read = &null_read;
new_node->write = &null_write;
spinlock_init(&new_node->lock);
blist= &node->block_list;
do {
for(i=0; i<MAX_DATABLOCKS; i++) {
if (blist->data[i]) {
blockdir = (dir_block_t*) blist->data[i];
for(j=0; j<MAX_DIRENTRIES; j++) {
dirent = &blockdir->entries[j];
if (!dirent->vfs_node) {
dirent->vfs_node = new_node;
strncpy(dirent->name, name, MAX_FNAME);
return 0;
}
}
}
}
if (!blist->next) {
blist->next = (block_list_t*) kmalloc(sizeof(block_list_t));
if (blist->next)
memset(blist->next, 0x00, sizeof(block_list_t));
}
} while(blist);
kfree(new_node, sizeof(vfs_node_t));
return -ENOMEM;
}
int stdin_init(vfs_node_t* node, const char* name)
{
uint32_t i, j;
vfs_node_t* new_node;
dir_block_t* blockdir;
dirent_t* dirent;
block_list_t* blist;
if (BUILTIN_EXPECT(!node || !name, 0))
return -EINVAL;
if (BUILTIN_EXPECT(node->type != FS_DIRECTORY, 0))
return -EINVAL;
if (finddir_fs(node, name))
return -EINVAL;
new_node = kmalloc(sizeof(vfs_node_t));
if (BUILTIN_EXPECT(!new_node, 0))
return -ENOMEM;
memset(new_node, 0x00, sizeof(vfs_node_t));
new_node->type = FS_CHARDEVICE;
new_node->open = &null_open;
new_node->close = &null_close;
new_node->read = &stdio_read;
new_node->write = &null_write;
spinlock_init(&new_node->lock);
blist= &node->block_list;
do {
for(i=0; i<MAX_DATABLOCKS; i++) {
if (blist->data[i]) {
blockdir = (dir_block_t*) blist->data[i];
for(j=0; j<MAX_DIRENTRIES; j++) {
dirent = &blockdir->entries[j];
if (!dirent->vfs_node) {
dirent->vfs_node = new_node;
strncpy(dirent->name, name, MAX_FNAME);
return 0;
}
}
}
}
if (!blist->next) {
blist->next = (block_list_t*) kmalloc(sizeof(block_list_t));
if (blist->next)
memset(blist->next, 0x00, sizeof(block_list_t));
}
} while(blist);
kfree(new_node, sizeof(vfs_node_t));
return -ENOMEM;
}
int stdout_init(vfs_node_t* node, const char* name)
{
uint32_t i, j;
vfs_node_t* new_node;
dir_block_t* blockdir;
dirent_t* dirent;
block_list_t* blist;
if (BUILTIN_EXPECT(!node || !name, 0))
return -EINVAL;
if (BUILTIN_EXPECT(node->type != FS_DIRECTORY, 0))
return -EINVAL;
if (finddir_fs(node, name))
return -EINVAL;
new_node = kmalloc(sizeof(vfs_node_t));
if (BUILTIN_EXPECT(!new_node, 0))
return -ENOMEM;
memset(new_node, 0x00, sizeof(vfs_node_t));
new_node->type = FS_CHARDEVICE;
new_node->open = &null_open;
new_node->close = &null_close;
new_node->read = &null_read;
new_node->write = &stdio_write;
spinlock_init(&new_node->lock);
blist= &node->block_list;
do {
for(i=0; i<MAX_DATABLOCKS; i++) {
if (blist->data[i]) {
blockdir = (dir_block_t*) blist->data[i];
for(j=0; j<MAX_DIRENTRIES; j++) {
dirent = &blockdir->entries[j];
if (!dirent->vfs_node) {
dirent->vfs_node = new_node;
strncpy(dirent->name, name, MAX_FNAME);
return 0;
}
}
}
}
if (!blist->next) {
blist->next = (block_list_t*) kmalloc(sizeof(block_list_t));
if (blist->next)
memset(blist->next, 0x00, sizeof(block_list_t));
}
} while(blist);
kfree(new_node, sizeof(vfs_node_t));
return -ENOMEM;
}
int stderr_init(vfs_node_t* node, const char* name)
{
uint32_t i, j;
vfs_node_t* new_node;
dir_block_t* blockdir;
dirent_t* dirent;
block_list_t* blist;
if (BUILTIN_EXPECT(!node || !name, 0))
return -EINVAL;
if (BUILTIN_EXPECT(node->type != FS_DIRECTORY, 0))
return -EINVAL;
if (finddir_fs(node, name))
return -EINVAL;
new_node = kmalloc(sizeof(vfs_node_t));
if (BUILTIN_EXPECT(!new_node, 0))
return -ENOMEM;
memset(new_node, 0x00, sizeof(vfs_node_t));
new_node->type = FS_CHARDEVICE;
new_node->open = &null_open;
new_node->close = &null_close;
new_node->read = &null_read;
new_node->write = &stdio_write;
spinlock_init(&new_node->lock);
blist= &node->block_list;
do {
for(i=0; i<MAX_DATABLOCKS; i++) {
if (blist->data[i]) {
blockdir = (dir_block_t*) blist->data[i];
for(j=0; j<MAX_DIRENTRIES; j++) {
dirent = &blockdir->entries[j];
if (!dirent->vfs_node) {
dirent->vfs_node = new_node;
strncpy(dirent->name, name, MAX_FNAME);
return 0;
}
}
}
}
if (!blist->next) {
blist->next = (block_list_t*) kmalloc(sizeof(block_list_t));
if (blist->next)
memset(blist->next, 0x00, sizeof(block_list_t));
}
} while(blist);
kfree(new_node, sizeof(vfs_node_t));
return -ENOMEM;
}

4
drivers/stderr/Makefile
View file

@ -1,4 +0,0 @@
C_source := stderr.c
MODULE := drivers_stderr
include $(TOPDIR)/Makefile.inc

112
drivers/stderr/stderr.c
View file

@ -1,112 +0,0 @@
/*
* Copyright 2010 Stefan Lankes, Chair for Operating Systems,
* RWTH Aachen University
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* This file is part of MetalSVM.
*/
#include <metalsvm/stdlib.h>
#include <metalsvm/string.h>
#include <metalsvm/stdio.h>
#include <metalsvm/errno.h>
#include <metalsvm/fs.h>
#include <metalsvm/spinlock.h>
/* Implementation of a simple stderr device */
static ssize_t stderr_read(fildes_t* file, uint8_t* buffer, size_t size)
{
return size;
}
static ssize_t stderr_write(fildes_t* file, uint8_t* buffer, size_t size)
{
kprintf("\nError: ");
int i;
for (i = 0; i<size; i++, buffer++) {
kputchar(*buffer);
}
file->offset += size;
return size;
}
static int stderr_open(fildes_t* file, const char* name)
{
return 0;
}
static int stderr_close(fildes_t* file)
{
return 0;
}
int stderr_init(vfs_node_t* node, const char* name)
{
uint32_t i, j;
vfs_node_t* new_node;
dir_block_t* blockdir;
dirent_t* dirent;
block_list_t* blist;
if (BUILTIN_EXPECT(!node || !name, 0))
return -EINVAL;
if (BUILTIN_EXPECT(node->type != FS_DIRECTORY, 0))
return -EINVAL;
if (finddir_fs(node, name))
return -EINVAL;
new_node = kmalloc(sizeof(vfs_node_t));
if (BUILTIN_EXPECT(!new_node, 0))
return -ENOMEM;
memset(new_node, 0x00, sizeof(vfs_node_t));
new_node->type = FS_CHARDEVICE;
new_node->open = &stderr_open;
new_node->close = &stderr_close;
new_node->read = &stderr_read;
new_node->write = &stderr_write;
spinlock_init(&new_node->lock);
blist= &node->block_list;
do {
for(i=0; i<MAX_DATABLOCKS; i++) {
if (blist->data[i]) {
blockdir = (dir_block_t*) blist->data[i];
for(j=0; j<MAX_DIRENTRIES; j++) {
dirent = &blockdir->entries[j];
if (!dirent->vfs_node) {
dirent->vfs_node = new_node;
strncpy(dirent->name, name, MAX_FNAME);
return 0;
}
}
}
}
if (!blist->next) {
blist->next = (block_list_t*) kmalloc(sizeof(block_list_t));
if (blist->next)
memset(blist->next, 0x00, sizeof(block_list_t));
}
} while(blist);
kfree(new_node, sizeof(vfs_node_t));
return -ENOMEM;
}

4
drivers/stdin/Makefile
View file

@ -1,4 +0,0 @@
C_source := stdin.c
MODULE := drivers_stdin
include $(TOPDIR)/Makefile.inc

124
drivers/stdin/stdin.c
View file

@ -1,124 +0,0 @@
/*
* Copyright 2010 Stefan Lankes, Chair for Operating Systems,
* RWTH Aachen University
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* This file is part of MetalSVM.
*/
#include <metalsvm/stdlib.h>
#include <metalsvm/string.h>
#include <metalsvm/stdio.h>
#include <metalsvm/errno.h>
#include <metalsvm/fs.h>
#include <metalsvm/spinlock.h>
#include <asm/kb.h>
#include <metalsvm/tasks.h>
/* Implementation of a simple stdin device */
static ssize_t stdin_read(fildes_t* file, uint8_t* buffer, size_t size)
{
kb_buffer.buffer = kmalloc(size * sizeof(char));
kb_buffer.maxsize = size;
kb_buffer.size = 0;
kb_buffer.tid = per_core(current_task)->id;
block_current_task();
//per_core(current_task)->status = TASK_BLOCKED;
reschedule();
size = kb_buffer.size;
memcpy(buffer, kb_buffer.buffer, size);
/*cleaning up */
kb_flush();
//kprintf("Size: %i, offset: %i, buffer: %s", size, buffer, offset);
file->offset += size;
return size;
}
static ssize_t stdin_write(fildes_t* file, uint8_t* buffer, size_t size)
{
return size;
}
static int stdin_open(fildes_t* file, const char* name)
{
return 0;
}
static int stdin_close(fildes_t* file)
{
return 0;
}
int stdin_init(vfs_node_t* node, const char* name)
{
uint32_t i, j;
vfs_node_t* new_node;
dir_block_t* blockdir;
dirent_t* dirent;
block_list_t* blist;
if (BUILTIN_EXPECT(!node || !name, 0))
return -EINVAL;
if (BUILTIN_EXPECT(node->type != FS_DIRECTORY, 0))
return -EINVAL;
if (finddir_fs(node, name))
return -EINVAL;
new_node = kmalloc(sizeof(vfs_node_t));
if (BUILTIN_EXPECT(!new_node, 0))
return -ENOMEM;
memset(new_node, 0x00, sizeof(vfs_node_t));
new_node->type = FS_CHARDEVICE;
new_node->open = &stdin_open;
new_node->close = &stdin_close;
new_node->read = &stdin_read;
new_node->write = &stdin_write;
spinlock_init(&new_node->lock);
blist= &node->block_list;
do {
for(i=0; i<MAX_DATABLOCKS; i++) {
if (blist->data[i]) {
blockdir = (dir_block_t*) blist->data[i];
for(j=0; j<MAX_DIRENTRIES; j++) {
dirent = &blockdir->entries[j];
if (!dirent->vfs_node) {
dirent->vfs_node = new_node;
strncpy(dirent->name, name, MAX_FNAME);
return 0;
}
}
}
}
if (!blist->next) {
blist->next = (block_list_t*) kmalloc(sizeof(block_list_t));
if (blist->next)
memset(blist->next, 0x00, sizeof(block_list_t));
}
} while(blist);
kfree(new_node, sizeof(vfs_node_t));
return -ENOMEM;
}

4
drivers/stdout/Makefile
View file

@ -1,4 +0,0 @@
C_source := stdout.c
MODULE := drivers_stdout
include $(TOPDIR)/Makefile.inc

111
drivers/stdout/stdout.c
View file

@ -1,111 +0,0 @@
/*
* Copyright 2010 Stefan Lankes, Chair for Operating Systems,
* RWTH Aachen University
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* This file is part of MetalSVM.
*/
#include <metalsvm/stdlib.h>
#include <metalsvm/string.h>
#include <metalsvm/stdio.h>
#include <metalsvm/errno.h>
#include <metalsvm/fs.h>
#include <metalsvm/spinlock.h>
/* Implementation of a simple stdout device */
static ssize_t stdout_read(fildes_t* file, uint8_t* buffer, size_t size)
{
return size;
}
static ssize_t stdout_write(fildes_t* file, uint8_t* buffer, size_t size)
{
int i;
for (i = 0; i<size; i++, buffer++) {
kputchar(*buffer);
}
file->offset += size;
return size;
}
static int stdout_open(fildes_t* file, const char* name)
{
return 0;
}
static int stdout_close(fildes_t* file)
{
return 0;
}
int stdout_init(vfs_node_t* node, const char* name)
{
uint32_t i, j;
vfs_node_t* new_node;
dir_block_t* blockdir;
dirent_t* dirent;
block_list_t* blist;
if (BUILTIN_EXPECT(!node || !name, 0))
return -EINVAL;
if (BUILTIN_EXPECT(node->type != FS_DIRECTORY, 0))
return -EINVAL;
if (finddir_fs(node, name))
return -EINVAL;
new_node = kmalloc(sizeof(vfs_node_t));
if (BUILTIN_EXPECT(!new_node, 0))
return -ENOMEM;
memset(new_node, 0x00, sizeof(vfs_node_t));
new_node->type = FS_CHARDEVICE;
new_node->open = &stdout_open;
new_node->close = &stdout_close;
new_node->read = &stdout_read;
new_node->write = &stdout_write;
spinlock_init(&new_node->lock);
blist= &node->block_list;
do {
for(i=0; i<MAX_DATABLOCKS; i++) {
if (blist->data[i]) {
blockdir = (dir_block_t*) blist->data[i];
for(j=0; j<MAX_DIRENTRIES; j++) {
dirent = &blockdir->entries[j];
if (!dirent->vfs_node) {
dirent->vfs_node = new_node;
strncpy(dirent->name, name, MAX_FNAME);
return 0;
}
}
}
}
if (!blist->next) {
blist->next = (block_list_t*) kmalloc(sizeof(block_list_t));
if (blist->next)
memset(blist->next, 0x00, sizeof(block_list_t));
}
} while(blist);
kfree(new_node, sizeof(vfs_node_t));
return -ENOMEM;
}