chore: some fixes around and cleanup.
{
// TODO: clear the interrupt status
// TODO: I/O-operation scheduler should be here
- kprintf(KDEBUG "HBA INTR\n");
+ // kprintf(KDEBUG "HBA INTR\n");
}
void
#include <hal/acpi/acpi.h>
#include <hal/apic.h>
#include <hal/pci.h>
+#include <lunaix/fs/twifs.h>
#include <lunaix/mm/valloc.h>
#include <lunaix/spike.h>
#include <lunaix/syslog.h>
#define PCI_PRINT_BAR_LISTING
+int
+__pci_read_cspace(struct v_inode* inode, void* buffer, size_t len, size_t fpos)
+{
+ if (len < 256) {
+ return ERANGE;
+ }
+
+ struct twifs_node* node = (struct twifs_node*)(inode->data);
+ struct pci_device* pcidev = (struct pci_device*)(node->data);
+
+ for (size_t i = 0; i < 256; i += sizeof(pci_reg_t)) {
+ *(pci_reg_t*)(buffer + i) = pci_read_cspace(pcidev->cspace_base, i);
+ }
+
+ return 256;
+}
+
void
-pci_print_device()
+pci_build_fsmapping()
{
+ struct twifs_node *pci_class = twifs_dir_node(NULL, "pci"), *pci_dev;
struct pci_device *pos, *n;
llist_for_each(pos, n, &pci_devices, dev_chain)
{
- kprintf(KINFO "(B%xh:D%xh:F%xh) Dev %x:%x, Class 0x%x\n",
- PCI_BUS_NUM(pos->cspace_base),
- PCI_SLOT_NUM(pos->cspace_base),
- PCI_FUNCT_NUM(pos->cspace_base),
- PCI_DEV_VENDOR(pos->device_info),
- PCI_DEV_DEVID(pos->device_info),
- PCI_DEV_CLASS(pos->class_info));
-
- kprintf(KINFO "\t IRQ: %d, INT#x: %d\n",
- PCI_INTR_IRQ(pos->intr_info),
- PCI_INTR_PIN(pos->intr_info));
-#ifdef PCI_PRINT_BAR_LISTING
- uint32_t bar;
- for (size_t i = 1; i <= 6; i++) {
- size_t size = pci_bar_sizing(pos, &bar, i);
- if (!bar)
- continue;
- if (PCI_BAR_MMIO(bar)) {
- kprintf(KINFO "\t BAR#%d (MMIO) %p [%d]\n",
- i,
- PCI_BAR_ADDR_MM(bar),
- size);
- } else {
- kprintf(KINFO "\t BAR#%d (I/O) %p [%d]\n",
- i,
- PCI_BAR_ADDR_IO(bar),
- size);
- }
- }
-#endif
- if (pos->msi_loc) {
- kprintf(KINFO "\t MSI supported (@%xh)\n", pos->msi_loc);
- }
+ pci_dev = twifs_dir_node(pci_class,
+ "B%d:D%d:F%d.%x:%x",
+ PCI_BUS_NUM(pos->cspace_base),
+ PCI_SLOT_NUM(pos->cspace_base),
+ PCI_FUNCT_NUM(pos->cspace_base),
+ PCI_DEV_VENDOR(pos->device_info),
+ PCI_DEV_DEVID(pos->device_info));
+ struct twifs_node* fnode = twifs_file_node(pci_dev, "cspace");
+ fnode->data = pos;
+ fnode->ops.read = __pci_read_cspace;
}
}
}
// Otherwise, fallback to use legacy PCI 3.0 method.
pci_probe();
+
+ pci_build_fsmapping();
}
\ No newline at end of file
void
pci_init();
-void
-pci_print_device();
-
/**
* @brief 根据类型代码（Class Code）去在拓扑中寻找一个设备
* 类型代码请参阅： PCI LB Spec. Appendix D.
#define VFS_VALID_CHAR(chr) \
(('A' <= (chr) && (chr) <= 'Z') || ('a' <= (chr) && (chr) <= 'z') || \
('0' <= (chr) && (chr) <= '9') || (chr) == '.' || (chr) == '_' || \
- (chr) == '-')
+ (chr) == '-' || (chr) == ':')
#define unlock_inode(inode) mutex_unlock(&inode->lock)
#define lock_inode(inode) \
void
pcache_set_dirty(struct pcache* pcache, struct pcache_pg* pg);
-struct pcache_pg*
+int
pcache_get_page(struct pcache* pcache,
uint32_t index,
uint32_t* offset,
inode_t ino_id;
void* data;
uint32_t itype;
+ char name_val[VFS_NAME_MAXLEN];
struct llist_header children;
struct llist_header siblings;
struct
twifs_init();
struct twifs_node*
-twifs_file_node(struct twifs_node* parent,
- const char* name,
- int name_len,
- uint32_t itype);
+twifs_file_node(struct twifs_node* parent, const char* fmt, ...);
struct twifs_node*
-twifs_dir_node(struct twifs_node* parent,
- const char* name,
- int name_len,
- uint32_t itype);
-
-struct twifs_node*
-twifs_toplevel_node(const char* name, int name_len, uint32_t itype);
+twifs_dir_node(struct twifs_node* parent, const char* fmt, ...);
int
twifs_rm_node(struct twifs_node* node);
#define EEXIST -12
#define EBADF -13
#define ENOTSUP -14
-#define ENXIO -15
+#define EIO -15
#define ELOOP -16
#define ENOTEMPTY -17
#define EROFS -18
int errno;
struct block_dev* bdev = (struct block_dev*)dev->underlay;
size_t acc_size = 0, rd_size = 0, bsize = bdev->hd_dev->block_size,
- rd_block = offset / bsize, r = offset % bsize;
+ rd_block = offset / bsize, r = offset % bsize,
+ max_blk = (size_t)bdev->hd_dev->max_lba;
void* block = vzalloc(bsize);
- while (acc_size < len) {
+ while (acc_size < len && rd_block < max_blk) {
if (!bdev->hd_dev->ops.read_buffer(
bdev->hd_dev, rd_block, block, bsize)) {
- errno = ENXIO;
+ errno = EIO;
goto error;
}
rd_size = MIN(len - acc_size, bsize - r);
}
vfree(block);
- return rd_block;
+ return acc_size;
error:
vfree(block);
memcpy(block + r, buf + acc_size, wr_size);
if (!bdev->hd_dev->ops.write_buffer(
bdev->hd_dev, wr_block, block, bsize)) {
- errno = ENXIO;
+ errno = EIO;
break;
}
acc_size += wr_size;
#include <ulibc/stdio.h>
char pwd[512];
+char cat_buf[1024];
/*
Simple shell - (actually this is not even a shell)
case ENOMEM:
printf("Error: Out of memory\n");
break;
+ case EISDIR:
+ printf("Error: This is a directory\n");
+ break;
default:
printf("Error: Fail to open (%d)\n", errno);
break;
close(fd);
}
+ } else if (streq(cmd, "cat")) {
+ int fd = open(argpart, 0);
+ if (fd < 0) {
+ sh_printerr();
+ } else {
+ int sz;
+ while ((sz = read(fd, cat_buf, 1024)) == 1024) {
+ write(stdout, cat_buf, 1024);
+ }
+ if (sz < 0) {
+ sh_printerr();
+ } else {
+ write(stdout, cat_buf, sz);
+ }
+ close(fd);
+ }
} else {
printf("unknow command");
}
if (!lookahead && (walk_options & VFS_WALK_PARENT)) {
if (component) {
- component->hash = name.hash;
- component->len = j;
- strcpy(component->value, fname_buffer);
+ hstrcpy(component, &name);
}
break;
}
}
}
-struct pcache_pg*
+int
pcache_get_page(struct pcache* pcache,
uint32_t index,
uint32_t* offset,
errno = inode->default_fops->read(inode, pg->pg, PG_SIZE, pg->fpos);
if (errno >= 0 && errno < PG_SIZE) {
// EOF
- len = buf_off + errno;
+ len = MIN(len, buf_off + errno);
} else if (errno < 0) {
break;
}
* @copyright Copyright (c) 2022
*
*/
+#include <klibc/stdio.h>
#include <klibc/string.h>
#include <lunaix/clock.h>
#include <lunaix/fs.h>
#include <lunaix/fs/twifs.h>
#include <lunaix/mm/cake.h>
#include <lunaix/mm/valloc.h>
+#include <lunaix/spike.h>
static struct twifs_node* fs_root;
struct twifs_node* node = cake_grab(twi_pile);
memset(node, 0, sizeof(*node));
- node->name = HSTR(name, name_len);
+ strncpy(node->name_val, name, VFS_NAME_MAXLEN);
+
+ node->name = HSTR(node->name_val, MIN(name_len, VFS_NAME_MAXLEN));
node->itype = itype;
node->ino_id = inode_id++;
hstr_rehash(&node->name, HSTR_FULL_HASH);
struct twifs_node* child_node = __twifs_get_node(twi_node, &dnode->name);
if (child_node) {
- struct v_inode* inode = vfs_i_find(inode->sb, child_node->ino_id);
- if (inode) {
+ struct v_inode* child_inode = vfs_i_find(inode->sb, child_node->ino_id);
+ if (child_inode) {
goto done;
}
- if (!(inode = vfs_i_alloc(inode->sb))) {
+ if (!(child_inode = vfs_i_alloc(inode->sb))) {
return ENOENT;
}
- inode->id = child_node->ino_id;
- inode->itype = child_node->itype;
- inode->data = child_node;
+ child_inode->id = child_node->ino_id;
+ child_inode->itype = child_node->itype;
+ child_inode->data = child_node;
- vfs_i_addhash(inode);
+ vfs_i_addhash(child_inode);
done:
dnode->data = child_node->data;
- vfs_assign_inode(dnode, inode);
+ vfs_assign_inode(dnode, child_inode);
return 0;
}
return ENOENT;
}
struct twifs_node*
-twifs_file_node(struct twifs_node* parent,
- const char* name,
- int name_len,
- uint32_t itype)
+twifs_file_node(struct twifs_node* parent, const char* fmt, ...)
{
+ va_list args;
+ va_start(args, fmt);
+
+ char buf[VFS_NAME_MAXLEN];
+ size_t len = __ksprintf_internal(buf, fmt, VFS_NAME_MAXLEN, args);
struct twifs_node* twi_node =
- __twifs_new_node(parent, name, name_len, VFS_IFFILE | itype);
+ __twifs_new_node(parent ? parent : fs_root, buf, len, VFS_IFSEQDEV);
+
+ va_end(args);
return twi_node;
}
struct twifs_node*
-twifs_dir_node(struct twifs_node* parent,
- const char* name,
- int name_len,
- uint32_t itype)
+twifs_dir_node(struct twifs_node* parent, const char* fmt, ...)
{
- struct hstr hname = HSTR(name, name_len);
- hstr_rehash(&hname, HSTR_FULL_HASH);
- struct twifs_node* node = __twifs_get_node(parent, &hname);
- if (node) {
- return node;
- }
+ va_list args;
+ va_start(args, fmt);
+ char buf[VFS_NAME_MAXLEN];
+ size_t len = __ksprintf_internal(buf, fmt, VFS_NAME_MAXLEN, args);
struct twifs_node* twi_node =
- __twifs_new_node(parent, name, name_len, VFS_IFDIR | itype);
+ __twifs_new_node(parent ? parent : fs_root, buf, len, VFS_IFDIR);
- return twi_node;
-}
+ va_end(args);
-struct twifs_node*
-twifs_toplevel_node(const char* name, int name_len, uint32_t itype)
-{
- return twifs_dir_node(fs_root, name, name_len, itype);
+ return twi_node;
}
void
file->inode->atime = clock_unixtime();
- __SYSCALL_INTERRUPTIBLE({
- if ((file->inode->itype & VFS_IFSEQDEV) || (fd_s->flags & FO_DIRECT)) {
- errno = file->ops->read(file->inode, buf, count, file->f_pos);
- } else {
- errno = pcache_read(file->inode, buf, count, file->f_pos);
- }
- })
+ if ((file->inode->itype & VFS_IFSEQDEV) || (fd_s->flags & FO_DIRECT)) {
+ errno = file->ops->read(file->inode, buf, count, file->f_pos);
+ } else {
+ errno = pcache_read(file->inode, buf, count, file->f_pos);
+ }
if (errno > 0) {
file->f_pos += errno;
current_addr = (current_addr & 0xffc00000) + MEM_4MB;
} else {
x86_page_table* ptd = (x86_page_table*)(L2_VADDR(l1inx));
- size_t i = L2_INDEX(current_addr);
- for (; i < PG_MAX_ENTRIES && examed_size < size; i++) {
+ size_t i = L2_INDEX(current_addr), j = 0;
+ for (; i < PG_MAX_ENTRIES && examed_size < size; i++, j++) {
if (!ptd->entry[i]) {
examed_size += PG_SIZE;
} else if (examed_size) {
// found a discontinuity, start from beginning
examed_size = 0;
- i++;
+ j++;
break;
}
}
- current_addr += i << 12;
+ current_addr += j << 12;
}
if (examed_size >= size) {
if (current_addr >= VMAP_END) {
wrapped = 1;
+ examed_size = 0;
current_addr = VMAP_START;
}
}
vmm_del_mapping(PD_REFERENCED, (void*)i);
pmm_free_page(KERNEL_PID, (void*)i);
}
+
+ for (size_t i = L1_INDEX(KERNEL_MM_BASE); i < 1023; i++) {
+ vmm_set_mapping(PD_REFERENCED, i << 22, 0, 0, VMAP_NOMAP);
+ }
}
void
uintptr_t rd_ptr = fbuf->rd_pos;
char c;
- int j = 0;
for (size_t i = 0; i < size; i++) {
c = data[i];
if (!c) {
}
if (c == '\n') {
console->lines++;
+ } else if (c == '\x08') {
+ ptr = ptr ? ptr - 1 : fbuf->size - 1;
+ continue;
}
- buffer[(ptr + j) % fbuf->size] = c;
- j++;
+ buffer[ptr] = c;
+ ptr = (ptr + 1) % fbuf->size;
}
- fifo_set_wrptr(fbuf, (ptr + j) % fbuf->size);
+ fifo_set_wrptr(fbuf, ptr);
while (console->lines >= TTY_HEIGHT) {
rd_ptr = __find_next_line(rd_ptr);
case '\r':
x = 0;
break;
- case '\x08':
- x = x ? x - 1 : 0;
- *(tty_vga_buffer + x + y * TTY_WIDTH) =
- (current_theme | 0x20);
- break;
+ // case '\x08':
+ // *(tty_vga_buffer + x + y * TTY_WIDTH) =
+ // (current_theme | 0x20);
+ // break;
default:
*(tty_vga_buffer + x + y * TTY_WIDTH) =
(current_theme | chr);
#include <klibc/string.h>
char*
-strcpy(char* dest, const char* src) {
+strcpy(char* dest, const char* src)
+{
char c;
unsigned int i = 0;
- while ((c = src[i]))
- {
+ while ((c = src[i])) {
dest[i] = c;
i++;
}
}
char*
-strncpy(char* dest, const char* src, size_t n) {
+strncpy(char* dest, const char* src, size_t n)
+{
char c;
unsigned int i = 0;
- while ((c = src[i]) && i < n) dest[i++] = c;
- while (i < n) dest[i++] = 0;
+ while ((c = src[i]) && i <= n)
+ dest[i++] = c;
+ while (i <= n)
+ dest[i++] = 0;
return dest;
}
\ No newline at end of file
git://scm.lunaixsky.com / lunaix-os.git / commitdiff