kotovalexarian-likes-gitlab
/
sortix--sortix
mirror of https://gitlab.com/sortix/sortix.git
1
0
Fork 0
Code Releases Activity

Replace <libmaxsi/memory.h> with <string.h>.

This commit is contained in:
Jonas 'Sortie' Termansen 2012-09-22 20:38:34 +02:00
parent 5d082b3bbb
commit b4374f66b7
43 changed files with 112 additions and 184 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
libmaxsi/heap.cpp
View File

@ -24,7 +24,6 @@
#include <sys/mman.h>
#include <libmaxsi/platform.h>
#include <libmaxsi/memory.h>
#ifdef SORTIX_KERNEL
#define HEAP_GROWS_DOWNWARDS
@ -39,6 +38,7 @@
#include <assert.h>
#include <errno.h>
#include <malloc.h>
#include <string.h>
#define PARANOIA 1
@ -703,7 +703,7 @@ namespace Maxsi
size_t total = nmemb * size;
void* result = Allocate(total);
if ( !result ) { return NULL; }
Memory::Set(result, 0, total);
memset(result, 0, total);
return result;
}
@ -718,7 +718,7 @@ namespace Maxsi
if ( size < allocsize ) { return ptr; }
void* newptr = Allocate(size);
if ( !newptr ) { return NULL; }
Memory::Copy(newptr, ptr, allocsize);
memcpy(newptr, ptr, allocsize);
Free(ptr);
return newptr;
}

50
libmaxsi/include/libmaxsi/memory.h
View File

@ -1,50 +0,0 @@
/******************************************************************************
COPYRIGHT(C) JONAS 'SORTIE' TERMANSEN 2011.
This file is part of LibMaxsi.
LibMaxsi is free software: you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free
Software Foundation, either version 3 of the License, or (at your option)
any later version.
LibMaxsi is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for
more details.
You should have received a copy of the GNU Lesser General Public License
along with LibMaxsi. If not, see <http://www.gnu.org/licenses/>.
memory.h
Useful functions for manipulating memory, as well as the implementation
of the heap.
******************************************************************************/
#ifndef LIBMAXSI_MEMORY_H
#define LIBMAXSI_MEMORY_H
namespace Maxsi
{
namespace Memory
{
void Init();
void* Allocate(size_t Size);
void Free(void* Addr);
size_t GetChunkOverhead();
void* Copy(void* Dest, const void* Src, size_t Length);
void* Set(void* Dest, int Value, size_t Length);
int Compare(const void* a, const void* b, size_t size);
}
}
// Placement new.
inline void* operator new(size_t, void* p) { return p; }
inline void* operator new[](size_t, void* p) { return p; }
inline void operator delete (void*, void*) { };
inline void operator delete[](void*, void*) { };
#endif

4
libmaxsi/init.cpp
View File

@ -24,7 +24,7 @@
*******************************************************************************/
#include <libmaxsi/platform.h>
#include <libmaxsi/memory.h>
#include <malloc.h>
#include <string.h>
namespace Maxsi
@ -48,7 +48,7 @@ namespace Maxsi
init_signal();
// Initialize the dynamic heap.
Memory::Init();
_init_heap();
// Initialize stdio.
init_stdio();

6
libmaxsi/memory.cpp
View File

@ -23,10 +23,10 @@
******************************************************************************/
#include <libmaxsi/platform.h>
#include <libmaxsi/memory.h>
#ifndef SORTIX_KERNEL
#include <sys/syscall.h>
#endif
#include <string.h>
namespace Maxsi
{
@ -58,8 +58,8 @@ namespace Maxsi
uint8_t* dest = (uint8_t*) _dest;
const uint8_t* src = (const uint8_t*) _src;
uint8_t* tmp = new uint8_t[n];
Memory::Copy(tmp, src, n);
Memory::Copy(dest, tmp, n);
memcpy(tmp, src, n);
memcpy(dest, tmp, n);
delete[] tmp;
return _dest;
}

2
libmaxsi/signal.cpp
View File

@ -23,12 +23,12 @@
*******************************************************************************/
#include <libmaxsi/platform.h>
#include <libmaxsi/memory.h>
#include <libmaxsi/process.h>
#include <sys/syscall.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>
#include <string.h>
namespace Maxsi
{

5
libmaxsi/string.cpp
View File

@ -24,7 +24,6 @@
#include <libmaxsi/platform.h>
#include <libmaxsi/string.h>
#include <libmaxsi/memory.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
@ -196,7 +195,7 @@ namespace Maxsi
size_t InputSize = Length(Input);
char* Result = new char[InputSize + 1];
if ( Result == NULL ) { return NULL; }
Memory::Copy(Result, Input, InputSize + 1);
memcpy(Result, Input, InputSize + 1);
return Result;
}
@ -205,7 +204,7 @@ namespace Maxsi
size_t srclen = Length(src);
char* dest = new char[length + 1];
if ( !dest ) { return NULL; }
Memory::Copy(dest, src + offset, length * sizeof(char));
memcpy(dest, src + offset, length * sizeof(char));
dest[length] = 0;
return dest;
}

1
libmaxsi/time.cpp
View File

@ -23,7 +23,6 @@
*******************************************************************************/
#include <libmaxsi/platform.h>
#include <libmaxsi/memory.h>
#include <sys/syscall.h>
#include <errno.h>
#include <sys/time.h>

6
sortix/ata.cpp
View File

@ -25,8 +25,8 @@
#include <sortix/kernel/platform.h>
#include <sortix/kernel/kthread.h>
#include "cpu.h"
#include <libmaxsi/memory.h>
#include <errno.h>
#include <string.h>
#include "ata.h"
#include "fs/devfs.h"
@ -311,7 +311,7 @@ namespace Sortix
if ( numbytes < wanted ) { wanted = numbytes; }
uint8_t temp[512 /*sectorsize*/];
if ( !ReadSector(byteoffset/sectorsize, temp) ) { return sofar; }
Memory::Copy(dest + sofar, temp + leadingbytes, wanted);
memcpy(dest + sofar, temp + leadingbytes, wanted);
sofar += wanted;
numbytes -= wanted;
byteoffset += wanted;
@ -339,7 +339,7 @@ namespace Sortix
if ( numbytes < wanted ) { wanted = numbytes; }
uint8_t temp[512 /*sectorsize*/];
if ( !ReadSector(byteoffset/sectorsize, temp) ) { return sofar; }
Memory::Copy(temp + leadingbytes, src + sofar, wanted);
memcpy(temp + leadingbytes, src + sofar, wanted);
if ( !WriteSector(byteoffset/sectorsize, temp) ) { return sofar; }
sofar += wanted;
numbytes -= wanted;

12
sortix/bga.cpp
View File

@ -29,9 +29,9 @@
#include <sortix/kernel/memorymanagement.h>
#include <sortix/kernel/pci.h>
#include <sortix/mman.h>
#include <libmaxsi/memory.h>
#include <libmaxsi/string.h>
#include <errno.h>
#include <string.h>
#include "x86-family/memorymanagement.h"
#include "lfbtextbuffer.h"
#include "cpu.h"
@ -85,14 +85,14 @@ addr_t DetectBGAFramebuffer()
pcifind_t pcifind;
// Search for the bochs BGA device and compatible.
Maxsi::Memory::Set(&pcifind, 255, sizeof(pcifind));
memset(&pcifind, 255, sizeof(pcifind));
pcifind.vendorid = 0x1234;
pcifind.deviceid = 0x1111;
if ( (devaddr = PCI::SearchForDevice(pcifind)) )
return PCI::ParseDevBar0(devaddr);
// Search for a generic VGA compatible device.
Maxsi::Memory::Set(&pcifind, 255, sizeof(pcifind));
memset(&pcifind, 255, sizeof(pcifind));
pcifind.classid = 0x03;
pcifind.subclassid = 0x00;
pcifind.progif = 0x00;
@ -381,7 +381,7 @@ ssize_t BGADriver::WriteAt(off_t off, const void* buf, size_t count)
return 0;
if ( framesize < off + count )
count = framesize - off;
Maxsi::Memory::Copy(frame + off, buf, count);
memcpy(frame + off, buf, count);
return count;
}
@ -392,7 +392,7 @@ ssize_t BGADriver::ReadAt(off_t off, void* buf, size_t count)
return 0;
if ( framesize < off + count )
count = framesize - off;
Maxsi::Memory::Copy(buf, frame + off, count);
memcpy(buf, frame + off, count);
return count;
}
@ -411,7 +411,7 @@ bool BGADriver::DetectModes() const
}
modes = new char*[nummodes];
if ( !modes ) { return false; }
Maxsi::Memory::Set(modes, 0, sizeof(char*) * nummodes);
memset(modes, 0, sizeof(char*) * nummodes);
size_t curmodeid = 0;
for ( unsigned w = 0; w < maxxres; w += 4U )
{

8
sortix/descriptors.cpp
View File

@ -23,14 +23,12 @@
*******************************************************************************/
#include <sortix/kernel/platform.h>
#include <libmaxsi/memory.h>
#include <assert.h>
#include <string.h>
#include "descriptors.h"
#include "device.h"
#include <sortix/fcntl.h>
using namespace Maxsi;
namespace Sortix
{
// When in doubt use brute-force. This class could easily be optimized.
@ -84,11 +82,11 @@ namespace Sortix
if ( devices != NULL )
{
Memory::Copy(newlist, devices, sizeof(*devices) * numdevices);
memcpy(newlist, devices, sizeof(*devices) * numdevices);
}
size_t numpadded = newlistlength-numdevices;
Memory::Set(newlist + numdevices, 0, sizeof(*devices) * numpadded);
memset(newlist + numdevices, 0, sizeof(*devices) * numpadded);
delete[] devices;

2
sortix/device.cpp
View File

@ -24,7 +24,7 @@
#include <sortix/kernel/platform.h>
#include <sortix/kernel/kthread.h>
#include <libmaxsi/memory.h>
#include <string.h>
#include "device.h"
namespace Sortix

2
sortix/directory.cpp
View File

@ -23,10 +23,10 @@
******************************************************************************/
#include <sortix/kernel/platform.h>
#include <libmaxsi/memory.h>
#include <libmaxsi/string.h>
#include <assert.h>
#include <errno.h>
#include <string.h>
#include "syscall.h"
#include "process.h"
#include "device.h"

10
sortix/elf.cpp
View File

@ -24,9 +24,9 @@
#include <sortix/kernel/platform.h>
#include <sortix/mman.h>
#include <libmaxsi/memory.h>
#include <assert.h>
#include <errno.h>
#include <string.h>
#include "elf.h"
#include <sortix/kernel/memorymanagement.h>
#include <sortix/kernel/panic.h>
@ -132,8 +132,8 @@ namespace Sortix
// Copy as much data as possible and memset the rest to 0.
uint8_t* memdest = (uint8_t*) virtualaddr;
uint8_t* memsource = (uint8_t*) ( ((addr_t)file) + pht->offset);
Maxsi::Memory::Copy(memdest, memsource, pht->filesize);
Maxsi::Memory::Set(memdest + pht->filesize, 0, pht->memorysize - pht->filesize);
memcpy(memdest, memsource, pht->filesize);
memset(memdest + pht->filesize, 0, pht->memorysize - pht->filesize);
}
return entry;
@ -218,8 +218,8 @@ namespace Sortix
// Copy as much data as possible and memset the rest to 0.
uint8_t* memdest = (uint8_t*) virtualaddr;
uint8_t* memsource = (uint8_t*) ( ((addr_t)file) + pht->offset);
Maxsi::Memory::Copy(memdest, memsource, pht->filesize);
Maxsi::Memory::Set(memdest + pht->filesize, 0, pht->memorysize - pht->filesize);
memcpy(memdest, memsource, pht->filesize);
memset(memdest + pht->filesize, 0, pht->memorysize - pht->filesize);
}
return entry;

4
sortix/filesystem.cpp
View File

@ -23,9 +23,9 @@
******************************************************************************/
#include <sortix/kernel/platform.h>
#include <libmaxsi/memory.h>
#include <libmaxsi/string.h>
#include <errno.h>
#include <string.h>
#include "syscall.h"
#include "process.h"
#include "filesystem.h"
@ -140,7 +140,7 @@ namespace Sortix
void HackStat(Device* dev, struct stat* st)
{
Memory::Set(st, 0, sizeof(*st));
memset(st, 0, sizeof(*st));
st->st_mode = 0777;
st->st_nlink = 1;
if ( dev->IsType(Device::BUFFER) )

6
sortix/fs/devfs.cpp
View File

@ -24,9 +24,9 @@
#include <sortix/kernel/platform.h>
#include <libmaxsi/string.h>
#include <libmaxsi/memory.h>
#include <assert.h>
#include <errno.h>
#include <string.h>
#include "../filesystem.h"
#include "../directory.h"
#include "../stream.h"
@ -212,7 +212,7 @@ namespace Sortix
DevEntry* newdeventries = new DevEntry[newentrieslength];
if ( !newdeventries ) { return false; }
size_t bytes = sizeof(DevEntry) * entriesused;
Memory::Copy(newdeventries, deventries, bytes);
memcpy(newdeventries, deventries, bytes);
delete[] deventries;
entrieslength = newentrieslength;
deventries = newdeventries;
@ -334,7 +334,7 @@ namespace Sortix
return -1;
}
Memory::Copy(dirent->d_name, name, namelen + 1);
memcpy(dirent->d_name, name, namelen + 1);
dirent->d_namelen = namelen;
position++;
return 0;

6
sortix/fs/initfs.cpp
View File

@ -25,8 +25,8 @@
#include <sortix/kernel/platform.h>
#include <sortix/kernel/kthread.h>
#include <libmaxsi/string.h>
#include <libmaxsi/memory.h>
#include <errno.h>
#include <string.h>
#include "../filesystem.h"
#include "../directory.h"
#include "../stream.h"
@ -120,7 +120,7 @@ namespace Sortix
size_t available = count;
if ( buffersize < offset + count ) { available = buffersize - offset; }
if ( available == 0 ) { return 0; }
Memory::Copy(dest, buffer + offset, available);
memcpy(dest, buffer + offset, available);
offset += available;
return available;
}
@ -198,7 +198,7 @@ namespace Sortix
return -1;
}
Memory::Copy(dirent->d_name, name, namelen + 1);
memcpy(dirent->d_name, name, namelen + 1);
dirent->d_namelen = namelen;
position++;
return 0;

10
sortix/fs/ramfs.cpp
View File

@ -24,9 +24,9 @@
#include <sortix/kernel/platform.h>
#include <libmaxsi/string.h>
#include <libmaxsi/memory.h>
#include <assert.h>
#include <errno.h>
#include <string.h>
#include "../filesystem.h"
#include "../directory.h"
#include "../stream.h"
@ -110,7 +110,7 @@ namespace Sortix
uint8_t* newbuffer = new uint8_t[size];
if ( !newbuffer ) { errno = ENOSPC; return false; }
size_t sharedmemsize = ( size < bufferused ) ? size : bufferused;
Memory::Copy(newbuffer, buffer, sharedmemsize);
memcpy(newbuffer, buffer, sharedmemsize);
delete[] buffer;
buffer = newbuffer;
bufferused = sharedmemsize;
@ -124,7 +124,7 @@ namespace Sortix
size_t available = count;
if ( bufferused < offset + count ) { available = bufferused - offset; }
if ( available == 0 ) { return 0; }
Memory::Copy(dest, buffer + offset, available);
memcpy(dest, buffer + offset, available);
offset += available;
return available;
}
@ -139,7 +139,7 @@ namespace Sortix
if ( !Resize(newsize) ) { return -1; }
}
Memory::Copy(buffer + offset, src, count);
memcpy(buffer + offset, src, count);
offset += count;
if ( bufferused < offset ) { bufferused = offset; }
return count;
@ -227,7 +227,7 @@ namespace Sortix
return -1;
}
Memory::Copy(dirent->d_name, name, namelen + 1);
memcpy(dirent->d_name, name, namelen + 1);
dirent->d_namelen = namelen;
position++;
return 0;

10
sortix/fs/util.cpp
View File

@ -23,9 +23,9 @@
*******************************************************************************/
#include <sortix/kernel/platform.h>
#include <libmaxsi/memory.h>
#include <libmaxsi/string.h>
#include <errno.h>
#include <string.h>
#include "util.h"
using namespace Maxsi;
@ -76,7 +76,7 @@ ssize_t DevStringBuffer::Read(uint8_t* dest, size_t count)
{
size_t available = strlength - off;
if ( available < count ) { count = available; }
Memory::Copy(dest, str + off, count);
memcpy(dest, str + off, count);
off += count;
return count;
}
@ -122,7 +122,7 @@ ssize_t DevLineCommand::Write(const uint8_t* src, size_t count)
size_t available = CMDMAX - sofar;
if ( !available && count ) { errno = ENOSPC; return -1; }
if ( available < count ) { count = available; }
Memory::Copy(cmd + sofar, src, count);
memcpy(cmd + sofar, src, count);
cmd[sofar += count] = 0;
size_t newlinepos = String::Reject(cmd, "\n");
if ( !cmd[newlinepos] ) { return count; }
@ -189,7 +189,7 @@ ssize_t DevMemoryBuffer::Read(uint8_t* dest, size_t count)
if ( bufsize <= off ) { return 0; }
size_t available = bufsize - off;
if ( available < count ) { count = available; }
Memory::Copy(dest, buf + off, count);
memcpy(dest, buf + off, count);
off += count;
return count;
}
@ -200,7 +200,7 @@ ssize_t DevMemoryBuffer::Write(const uint8_t* src, size_t count)
if ( bufsize <= off ) { errno = EPERM; return -1; }
size_t available = bufsize - off;
if ( available < count ) { count = available; }
Memory::Copy(buf + off, src, count);
memcpy(buf + off, src, count);
off += count;
return count;
}

4
sortix/fs/videofs.cpp
View File

@ -24,9 +24,9 @@
#include <sortix/kernel/platform.h>
#include <sortix/kernel/video.h>
#include <libmaxsi/memory.h>
#include <libmaxsi/string.h>
#include <errno.h>
#include <string.h>
#include "../directory.h"
#include "util.h"
#include "videofs.h"
@ -279,7 +279,7 @@ int DevVideoFSDir::Read(sortix_dirent* dirent, size_t available)
return -1;
}
Memory::Copy(dirent->d_name, name, namelen + 1);
memcpy(dirent->d_name, name, namelen + 1);
dirent->d_namelen = namelen;
position++;
return 0;

2
sortix/initrd.cpp
View File

@ -27,10 +27,10 @@
#include <sortix/stat.h>
#include <sortix/mman.h>
#include <sortix/initrd.h>
#include <libmaxsi/memory.h>
#include <libmaxsi/string.h>
#include <libmaxsi/crc32.h>
#include <errno.h>
#include <string.h>
#include "initrd.h"
#include "syscall.h"

8
sortix/interrupt.cpp
View File

@ -23,9 +23,9 @@
*******************************************************************************/
#include <sortix/kernel/platform.h>
#include <libmaxsi/memory.h>
#include <assert.h>
#include <errno.h>
#include <string.h>
#include "x86-family/idt.h"
#include "interrupt.h"
#include "scheduler.h"
@ -35,8 +35,6 @@
#include "sound.h" // Hack for SIGSEGV
using namespace Maxsi;
namespace Sortix {
namespace Interrupt {
@ -348,7 +346,7 @@ static void WriteToQueue(const void* src, size_t size)
size_t writeat = (queueoffset + queueused) % queuesize;
size_t available = queuesize - writeat;
size_t count = available < size ? available : size;
Memory::Copy(queue + writeat, buf, count);
memcpy(queue + writeat, buf, count);
queueused += count;
if ( count < size ) { WriteToQueue(buf + count, size - count); }
}
@ -358,7 +356,7 @@ static void ReadFromQueue(void* dest, size_t size)
uint8_t* buf = (uint8_t*) dest;
size_t available = queuesize - queueoffset;
size_t count = available < size ? available : size;
Memory::Copy(buf, queue + queueoffset, count);
memcpy(buf, queue + queueoffset, count);
queueused -= count;
queueoffset = (queueoffset + count) % queuesize;
if ( count < size ) { ReadFromQueue(buf + count, size - count); }

8
sortix/kb/ps2.cpp
View File

@ -23,15 +23,13 @@
*******************************************************************************/
#include <sortix/kernel/platform.h>
#include <libmaxsi/memory.h>
#include <assert.h>
#include <string.h>
#include "../interrupt.h"
#include "../keyboard.h"
#include <sortix/keycodes.h>
#include "ps2.h"
using namespace Maxsi;
namespace Sortix
{
const uint16_t DATA = 0x0;
@ -187,8 +185,8 @@ namespace Sortix
size_t leadingavai = queuelength-queueoffset;
size_t leading = (leadingavai < queueused) ? leadingavai : queueused;
size_t trailing = queueused - leading;
Memory::Copy(newqueue, queue + queueoffset, leading * elemsize);
Memory::Copy(newqueue + leading, queue, trailing * elemsize);
memcpy(newqueue, queue + queueoffset, leading * elemsize);
memcpy(newqueue + leading, queue, trailing * elemsize);
delete[] queue;
queue = newqueue;
queuelength = newqueuelength;

12
sortix/lfbtextbuffer.cpp
View File

@ -27,12 +27,10 @@
#include <sortix/kernel/refcount.h>
#include <sortix/kernel/textbuffer.h>
#include <sortix/vga.h>
#include <libmaxsi/memory.h>
#include <string.h>
#include "vga.h"
#include "lfbtextbuffer.h"
using namespace Maxsi;
namespace Sortix {
static uint32_t ColorFromRGB(uint8_t r, uint8_t g, uint8_t b)
@ -65,7 +63,7 @@ LFBTextBuffer* CreateLFBTextBuffer(uint8_t* lfb, uint32_t lfbformat,
if ( !(ret = new LFBTextBuffer) )
goto cleanup_attrs;
Memory::Copy(font, VGA::GetFont(), fontsize);
memcpy(font, VGA::GetFont(), fontsize);
ret->lfb = lfb;
ret->lfbformat = lfbformat;
ret->pixelsx = xres;
@ -74,9 +72,9 @@ LFBTextBuffer* CreateLFBTextBuffer(uint8_t* lfb, uint32_t lfbformat,
ret->columns = columns;
ret->rows = rows;
ret->font = font;
Memory::Set(chars, 0, sizeof(uint16_t) * columns * rows);
memset(chars, 0, sizeof(uint16_t) * columns * rows);
ret->chars = chars;
Memory::Set(attrs, 0, sizeof(uint16_t) * columns * rows);
memset(attrs, 0, sizeof(uint16_t) * columns * rows);
ret->attrs = attrs;
for ( size_t i = 0; i < 16UL; i++ )
{
@ -88,7 +86,7 @@ LFBTextBuffer* CreateLFBTextBuffer(uint8_t* lfb, uint32_t lfbformat,
ret->cursorenabled = true;
ret->cursorpos = TextPos(0, 0);
for ( size_t y = 0; y < yres; y++ )
Memory::Set(lfb + scansize * y, 0, lfbformat/8UL * xres);
memset(lfb + scansize * y, 0, lfbformat/8UL * xres);
return ret;
cleanup_attrs:

8
sortix/linebuffer.cpp
View File

@ -23,11 +23,9 @@
******************************************************************************/
#include <sortix/kernel/platform.h>
#include <libmaxsi/memory.h>
#include <string.h>
#include "linebuffer.h"
using namespace Maxsi;
namespace Sortix
{
static size_t OffsetIndex(size_t offset, size_t index, size_t length)
@ -63,8 +61,8 @@ namespace Sortix
size_t leadingavai = bufferlength-bufferoffset;
size_t leading = (leadingavai < bufferused) ? leadingavai : bufferused;
size_t trailing = bufferused - leading;
Memory::Copy(newbuffer, buffer + bufferoffset, leading * elemsize);
Memory::Copy(newbuffer + leading, buffer, trailing * elemsize);
memcpy(newbuffer, buffer + bufferoffset, leading * elemsize);
memcpy(newbuffer + leading, buffer, trailing * elemsize);
delete[] buffer;
buffer = newbuffer;
bufferlength = newbufferlength;

2
sortix/log.cpp
View File

@ -24,7 +24,7 @@
#include <sortix/kernel/platform.h>
#include <libmaxsi/string.h>
#include <libmaxsi/memory.h>
#include <string.h>
#include <sortix/kernel/log.h>
#include "syscall.h"

4
sortix/logterminal.cpp
View File

@ -25,8 +25,8 @@
#include <sortix/kernel/platform.h>
#include <sortix/keycodes.h>
#include <sortix/signal.h>
#include <libmaxsi/memory.h>
#include <errno.h>
#include <string.h>
#include "utf8.h"
#include "keyboard.h"
#include "process.h"
@ -288,7 +288,7 @@ namespace Sortix
bufsize -= partiallywritten;
if ( sofar && left < bufsize ) { return sofar; }
size_t amount = left < bufsize ? left : bufsize;
Memory::Copy(dest + sofar, buf, amount);
memcpy(dest + sofar, buf, amount);
partiallywritten = (amount < bufsize) ? partiallywritten + amount : 0;
left -= amount;
sofar += amount;

4
sortix/mount.cpp
View File

@ -23,9 +23,9 @@
******************************************************************************/
#include <sortix/kernel/platform.h>
#include <libmaxsi/memory.h>
#include <libmaxsi/string.h>
#include <sortix/kernel/panic.h>
#include <libmaxsi/string.h>
#include <string.h>
#include "mount.h"
#include "fs/ramfs.h"
#include "fs/initfs.h"

2
sortix/panic.cpp
View File

@ -24,7 +24,7 @@
#include <sortix/kernel/platform.h>
#include <libmaxsi/string.h>
#include <libmaxsi/memory.h>
#include <string.h>
#include "interrupt.h"
#include <sortix/kernel/log.h>
#include "calltrace.h"

12
sortix/pipe.cpp
View File

@ -25,9 +25,9 @@
#include <sortix/kernel/platform.h>
#include <sortix/kernel/kthread.h>
#include <sortix/signal.h>
#include <libmaxsi/memory.h>
#include <assert.h>
#include <errno.h>
#include <string.h>
#ifdef GOT_FAKE_KTHREAD
#include "event.h"
#endif
@ -37,8 +37,6 @@
#include "syscall.h"
#include "pipe.h"
using namespace Maxsi;
namespace Sortix
{
class DevPipeStorage : public DevStream
@ -118,7 +116,7 @@ namespace Sortix
size_t linear = buffersize - bufferoffset;
if ( linear < amount ) { amount = linear; }
assert(amount);
Memory::Copy(dest, buffer + bufferoffset, amount);
memcpy(dest, buffer + bufferoffset, amount);
bufferoffset = (bufferoffset + amount) % buffersize;
bufferused -= amount;
kthread_cond_broadcast(&writecond);
@ -131,7 +129,7 @@ namespace Sortix
size_t linear = buffersize - bufferoffset;
if ( linear < amount ) { amount = linear; }
assert(amount);
Memory::Copy(dest, buffer + bufferoffset, amount);
memcpy(dest, buffer + bufferoffset, amount);
bufferoffset = (bufferoffset + amount) % buffersize;
bufferused -= amount;
writeevent.Signal();
@ -172,7 +170,7 @@ namespace Sortix
size_t linear = buffersize - writeoffset;
if ( linear < amount ) { amount = linear; }
assert(amount);
Memory::Copy(buffer + writeoffset, src, amount);
memcpy(buffer + writeoffset, src, amount);
bufferused += amount;
kthread_cond_broadcast(&readcond);
return amount;
@ -185,7 +183,7 @@ namespace Sortix
size_t linear = buffersize - writeoffset;
if ( linear < amount ) { amount = linear; }
assert(amount);
Memory::Copy(buffer + writeoffset, src, amount);
memcpy(buffer + writeoffset, src, amount);
bufferused += amount;
readevent.Signal();
return amount;

12
sortix/process.cpp
View File

@ -31,11 +31,11 @@
#include <sortix/fork.h>
#include <sortix/mman.h>
#include <sortix/wait.h>
#include <libmaxsi/memory.h>
#include <libmaxsi/string.h>
#include <libmaxsi/sortedlist.h>
#include <assert.h>
#include <errno.h>
#include <string.h>
#include "thread.h"
#include "process.h"
#include "device.h"
@ -533,7 +533,7 @@ namespace Sortix
argvsize += len;
char* dest = ((char*) argvpos) - argvsize;
stackargv[i] = dest;
Maxsi::Memory::Copy(dest, argv[i], len);
memcpy(dest, argv[i], len);
}
stackargv[argc] = NULL;
@ -551,7 +551,7 @@ namespace Sortix
envpsize += len;
char* dest = ((char*) envppos) - envpsize;
stackenvp[i] = dest;
Maxsi::Memory::Copy(dest, envp[i], len);
memcpy(dest, envp[i], len);
}
stackenvp[envc] = NULL;
@ -596,7 +596,7 @@ namespace Sortix
int result = -1;
Process* process = CurrentProcess();
CPU::InterruptRegisters regs;
Maxsi::Memory::Set(&regs, 0, sizeof(regs));
memset(&regs, 0, sizeof(regs));
filename = String::Clone(_filename);
if ( !filename ) { goto cleanup_done; }
@ -606,7 +606,7 @@ namespace Sortix
argv = new char*[argc+1];
if ( !argv ) { goto cleanup_filename; }
Maxsi::Memory::Set(argv, 0, sizeof(char*) * (argc+1));
memset(argv, 0, sizeof(char*) * (argc+1));
for ( int i = 0; i < argc; i++ )
{
@ -617,7 +617,7 @@ namespace Sortix
envp = new char*[envc+1];
if ( !envp ) { goto cleanup_argv; }
envc = envc;
Maxsi::Memory::Set(envp, 0, sizeof(char*) * (envc+1));
memset(envp, 0, sizeof(char*) * (envc+1));
for ( int i = 0; i < envc; i++ )
{

6
sortix/scheduler.cpp
View File

@ -24,8 +24,8 @@
#include <sortix/kernel/platform.h>
#include <sortix/kernel/memorymanagement.h>
#include <libmaxsi/memory.h>
#include <assert.h>
#include <string.h>
#include "x86-family/gdt.h"
#include "x86-family/float.h"
#include "syscall.h"
@ -36,8 +36,6 @@
#include "signal.h"
#include "scheduler.h"
using namespace Maxsi;
namespace Sortix {
namespace Scheduler {
@ -274,7 +272,7 @@ void Init()
// current thread is accessed. This lets us avoid checking whether it is
// NULL (which it only will be once), which gives simpler code.
dummythread = (Thread*) &dummythreaddata;
Maxsi::Memory::Set(dummythread, 0, sizeof(*dummythread));
memset(dummythread, 0, sizeof(*dummythread));
dummythread->schedulerlistprev = dummythread;
dummythread->schedulerlistnext = dummythread;
currentthread = dummythread;

4
sortix/signal.cpp
View File

@ -25,14 +25,12 @@
#include <sortix/kernel/platform.h>
#include <sortix/kernel/panic.h>
#include <sortix/signal.h>
#include <libmaxsi/memory.h>
#include <assert.h>
#include <string.h>
#include "interrupt.h"
#include "thread.h"
#include "signal.h"
using namespace Maxsi;
namespace Sortix {
// A per-cpu value whether a signal is pending in the running task.

10
sortix/thread.cpp
View File

@ -27,9 +27,9 @@
#include <sortix/kernel/memorymanagement.h>
#include <sortix/mman.h>
#include <sortix/signal.h>
#include <libmaxsi/memory.h>
#include <assert.h>
#include <errno.h>
#include <string.h>
#include "process.h"
#include "thread.h"
#include "scheduler.h"
@ -37,8 +37,6 @@
#include "time.h"
#include "syscall.h"
using namespace Maxsi;
namespace Sortix
{
Thread::Thread()
@ -50,7 +48,7 @@ namespace Sortix
schedulerlistprev = NULL;
schedulerlistnext = NULL;
state = NONE;
Maxsi::Memory::Set(&registers, 0, sizeof(registers));
memset(&registers, 0, sizeof(registers));
stackpos = 0;
stacksize = 0;
kernelstackpos = 0;
@ -211,7 +209,7 @@ namespace Sortix
int level = siglevel++;
signums[level] = currentsignal = signum;
Maxsi::Memory::Copy(sigregs + level, regs, sizeof(*regs));
memcpy(sigregs + level, regs, sizeof(*regs));
HandleSignalCPU(regs);
}
@ -224,7 +222,7 @@ namespace Sortix
siglevel--;
currentsignal = siglevel ? signums[siglevel-1] : 0;
Maxsi::Memory::Copy(regs, sigregs + siglevel, sizeof(*regs));
memcpy(regs, sigregs + siglevel, sizeof(*regs));
regs->signal_pending = 0;
// Check if a more important signal is pending.

2
sortix/uart.cpp
View File

@ -25,7 +25,7 @@
#include <sortix/kernel/platform.h>
#include "cpu.h"
#include <libmaxsi/string.h>
#include <libmaxsi/memory.h>
#include <string.h>
#include "vga.h"
#include "uart.h"

10
sortix/vga.cpp
View File

@ -23,8 +23,8 @@
*******************************************************************************/
#include <sortix/kernel/platform.h>
#include <libmaxsi/memory.h>
#include <errno.h>
#include <string.h>
#include "fs/util.h"
#include "fs/devfs.h"
#include "vga.h"
@ -35,8 +35,6 @@
#define TEST_VGAFONT 0
using namespace Maxsi;
namespace Sortix {
namespace VGA {
@ -86,7 +84,7 @@ static void FetchVGAFont(uint8_t* font)
{
const uint8_t* src = data + (32*8)/8 * i;
uint8_t* dest = font + VGA_FONT_CHARSIZE * i;
Memory::Copy(dest, src, VGA_FONT_CHARSIZE);
memcpy(dest, src, VGA_FONT_CHARSIZE);
}
// Restore the VGA state.
WriteIndex(0x03C4, 0x02, old_03c4_02);
@ -176,7 +174,7 @@ DevVGA::~DevVGA()
ssize_t DevVGA::Read(uint8_t* dest, size_t count)
{
if ( VGA::VGA_SIZE - offset < count ) { count = VGA::VGA_SIZE - offset; }
Maxsi::Memory::Copy(dest, VGA::VGA + offset, count);
memcpy(dest, VGA::VGA + offset, count);
offset += count;
return count;
}
@ -185,7 +183,7 @@ ssize_t DevVGA::Write(const uint8_t* src, size_t count)
{
if ( offset == VGA::VGA_SIZE && count ) { errno = ENOSPC; return -1; }
if ( VGA::VGA_SIZE - offset < count ) { count = VGA::VGA_SIZE - offset; }
Maxsi::Memory::Copy(VGA::VGA + offset, src, count);
memcpy(VGA::VGA + offset, src, count);
offset = (offset + count) % VGA::VGA_SIZE;
VGA::SetCursor(VGA::WIDTH, VGA::HEIGHT-1);
#ifdef PLATFORM_SERIAL

6
sortix/video.cpp
View File

@ -28,8 +28,8 @@
#include <sortix/kernel/video.h>
#include <stdarg.h>
#include <errno.h>
#include <libmaxsi/memory.h>
#include <libmaxsi/string.h>
#include <string.h>
using namespace Maxsi;
@ -136,7 +136,7 @@ bool RegisterDriver(const char* name, VideoDriver* driver)
size_t newdriverslen = driverslen ? 2 * driverslen : 8UL;
DriverEntry* newdrivers = new DriverEntry[newdriverslen];
if ( !newdrivers ) { return false; }
Memory::Copy(newdrivers, drivers, sizeof(*drivers) * numdrivers);
memcpy(newdrivers, drivers, sizeof(*drivers) * numdrivers);
delete[] drivers; drivers = newdrivers;
driverslen = driverslen;
}
@ -161,7 +161,7 @@ static bool ExpandModesArray(size_t needed)
if ( newmodeslen < modesneeded ) { newmodeslen = modesneeded; }
char** newmodes = new char*[newmodeslen];
if ( !newmodes ) { return false; }
Memory::Copy(newmodes, modes, sizeof(char*) * nummodes);
memcpy(newmodes, modes, sizeof(char*) * nummodes);
delete[] modes; modes = newmodes;
modeslen = newmodeslen;
return true;

2
sortix/x64/memorymanagement.cpp
View File

@ -24,7 +24,7 @@
#include <sortix/kernel/platform.h>
#include <sortix/kernel/memorymanagement.h>
#include <libmaxsi/memory.h>
#include <string.h>
#include "multiboot.h"
#include "x86-family/memorymanagement.h"
#include "interrupt.h"

4
sortix/x64/process.cpp
View File

@ -24,7 +24,7 @@
#include <sortix/kernel/platform.h>
#include <sortix/fork.h>
#include <libmaxsi/memory.h>
#include <string.h>
#include "process.h"
namespace Sortix
@ -53,7 +53,7 @@ namespace Sortix
void InitializeThreadRegisters(CPU::InterruptRegisters* regs,
const tforkregs_t* requested)
{
Maxsi::Memory::Set(regs, 0, sizeof(*regs));
memset(regs, 0, sizeof(*regs));
regs->rip = requested->rip;
regs->userrsp = requested->rsp;
regs->rax = requested->rax;

4
sortix/x86-family/gdt.cpp
View File

@ -23,7 +23,7 @@
*******************************************************************************/
#include <sortix/kernel/platform.h>
#include <libmaxsi/memory.h>
#include <string.h>
#include "gdt.h"
using namespace Maxsi;
@ -122,7 +122,7 @@ namespace Sortix
#endif
// Ensure the descriptor is initially zero.
Memory::Set(&tss_entry, 0, sizeof(tss_entry));
memset(&tss_entry, 0, sizeof(tss_entry));
#ifdef PLATFORM_X86
tss_entry.ss0 = ss0; // Set the kernel stack segment.

4
sortix/x86-family/idt.cpp
View File

@ -23,7 +23,7 @@
*******************************************************************************/
#include <sortix/kernel/platform.h>
#include <libmaxsi/memory.h>
#include <string.h>
#include "idt.h"
using namespace Maxsi;
@ -42,7 +42,7 @@ namespace Sortix
idt_ptr.limit = sizeof(idt_entry_t) * 256 - 1;
idt_ptr.base = (addr_t) &idt_entries;
Memory::Set(&idt_entries, 0, sizeof(idt_entry_t)*256);
memset(&idt_entries, 0, sizeof(idt_entry_t)*256);
}
void Flush()

8
sortix/x86-family/memorymanagement.cpp
View File

@ -27,9 +27,9 @@
#include <sortix/kernel/kthread.h>
#include <sortix/kernel/memorymanagement.h>
#include <sortix/mman.h>
#include <libmaxsi/memory.h>
#include <assert.h>
#include <errno.h>
#include <string.h>
#include "multiboot.h"
#include "memorymanagement.h"
#include "syscall.h"
@ -230,7 +230,7 @@ namespace Sortix
// Invalidate the new PML and reset it to zeroes.
addr_t pmladdr = (addr_t) (PMLS[TOPPMLLEVEL-1] + i);
InvalidatePage(pmladdr);
Maxsi::Memory::Set((void*) pmladdr, 0, sizeof(PML));
memset((void*) pmladdr, 0, sizeof(PML));
}
}
}
@ -556,7 +556,7 @@ namespace Sortix
// Invalidate the new PML and reset it to zeroes.
addr_t pmladdr = (addr_t) (PMLS[i-1] + childoffset);
InvalidatePage(pmladdr);
Maxsi::Memory::Set((void*) pmladdr, 0, sizeof(PML));
memset((void*) pmladdr, 0, sizeof(PML));
}
offset = childoffset;
@ -713,7 +713,7 @@ namespace Sortix
// Determine the destination page's address.
void* dest = (void*) (FORKPML + level - 1);
Maxsi::Memory::Copy(dest, src, 4096UL);
memcpy(dest, src, 4096UL);
}
return true;

4
sortix/x86/memorymanagement.cpp
View File

@ -23,7 +23,7 @@
*******************************************************************************/
#include <sortix/kernel/platform.h>
#include <libmaxsi/memory.h>
#include <string.h>
#include "multiboot.h"
#include <sortix/kernel/panic.h>
#include <sortix/kernel/memorymanagement.h>
@ -50,7 +50,7 @@ namespace Sortix
PML* const IDENPML1 = (PML* const) 0x14000UL;
// Initialize the memory structures with zeroes.
Maxsi::Memory::Set((PML* const) 0x11000UL, 0, 0x6000UL);
memset((PML* const) 0x11000UL, 0, 0x6000UL);
// Identity map the first 4 MiB.
addr_t flags = PML_PRESENT | PML_WRITABLE;

4
sortix/x86/process.cpp
View File

@ -24,7 +24,7 @@
#include <sortix/kernel/platform.h>
#include <sortix/fork.h>
#include <libmaxsi/memory.h>
#include <string.h>
#include "process.h"
namespace Sortix
@ -49,7 +49,7 @@ namespace Sortix
void InitializeThreadRegisters(CPU::InterruptRegisters* regs,
const tforkregs_t* requested)
{
Maxsi::Memory::Set(regs, 0, sizeof(*regs));
memset(regs, 0, sizeof(*regs));
regs->eip = requested->eip;
regs->useresp = requested->esp;
regs->eax = requested->eax;