Exemple #1
0
void list_push_front(list_t* list, void* data) {
    list->head = list_create_node(data, 0, list->head);
    if (list->head->next)
        list->head->next->prev = list->head;
    if (!list->tail)
        list->tail = list->head;
}
Exemple #2
0
void list_push_back(list_t* list, void* data) {
    list->tail = list_create_node(data, list->tail, 0);
    if (list->tail->prev)
        list->tail->prev->next = list->tail;
    if (!list->head)
        list->head = list->tail;
}
list_t *list_insert_node(list_t *list, list_node *pos, void *value, int before)
{
    list_node *node = list_create_node(list, value);
    if (node == NULL) {
        return NULL;
    }
    if (before) {
        node->next = pos;
        node->prev = pos->prev;
        if (list->head == pos) {
            list->head = node;
        }
    } else {
        node->next = pos->next;
        node->prev = pos;
        if (list->tail == pos) {
            list->tail = node;
        }
    }
    if (node->prev != NULL) {
        node->prev->next = node;
    }
    if (node->next != NULL) {
        node->next->prev = node;
    }
    list->len += 1;
    return list;
}
Exemple #4
0
/** add item to any position
 */
void list_add (linked_list* _this, void* item, int position) {
     // index out of list size
     if (position > _this->size) {
       return;
    }
    // add to head
    if (position == 0) {
        list_add_first(_this, item);
    } else if (position == _this->size) {
        // add to tail
        list_add_last(_this, item);
    } else {
        // insert between head and tail

       node* n = _this->head;
        int i = 0;
        // loop until the position
        while (i < position) {
            n = n->next;
            i++;
        }
        // insert new node to position
        node* newNode = list_create_node(item);
        list_insert_before(_this, n, newNode);
        _this->size++;
    }
}
Exemple #5
0
TmId_t TimersCreateTimer(TimerHandler_t Callback,
	void *Args, MCoreTimerType_t Type, uint32_t Timeout)
{
	MCoreTimer_t *TimerInfo;
	TmId_t Id;

	/* Sanity */
	if (GlbTimersInitialized != 1)
		TimersInit();

	/* Allocate */
	TimerInfo = (MCoreTimer_t*)kmalloc(sizeof(MCoreTimer_t));
	TimerInfo->Callback = Callback;
	TimerInfo->Args = Args;
	TimerInfo->Type = Type;
	TimerInfo->PeriodicMs = Timeout;
	TimerInfo->MsLeft = Timeout;

	/* Append to list */
	list_append(GlbTimers, list_create_node(GlbTimerIds, TimerInfo));

	/* Increase */
	Id = GlbTimerIds;
	GlbTimerIds++;

	return Id;
}
Exemple #6
0
DevId_t DmCreateDevice(char *Name, MCoreDevice_t *Device)
{
	/* Grap lock */
	SpinlockAcquire(&GlbDmLock);
	
	/* Set name and data */
	Device->Name = strdup(Name);
	Device->Id = GlbDmIdentfier;

	/* Increase */
	GlbDmIdentfier++;

	/* Release */
	SpinlockRelease(&GlbDmLock);

	/* Add to list */
	list_append(GlbDmDeviceList, list_create_node(Device->Id, (void*)Device));

	/* Call some broadcast function so systems know a new device is avaiable
	 * depending on the device type */
	switch (Device->Type)
	{
		/* Give access to timer */
		case DeviceTimer:
		{
			/* Cast */
			MCoreTimerDevice_t *Timer = (MCoreTimerDevice_t*)Device->Data;
			Timer->ReportMs = TimersApplyMs;

		} break;

		/* Give access to input */
		case DeviceInput:
		{
			/* Cast */
			MCoreInputDevice_t *Input = (MCoreInputDevice_t*)Device->Data;
			Input->ReportEvent = EmCreateEvent;

		} break;

		/* Register with Vfs */
		case DeviceStorage:
		{
			/* Call */
			VfsRegisterDisk(Device->Id);

		} break;

		/* No special actions */
		default:
			break;
	}

	/* Info Log */
	LogInformation("DRVM", "New Device: %s", Name);

	/* Done */
	return Device->Id;
}
Exemple #7
0
int list_push_front(List* l, int data)
{
    ListNode *node = list_create_node(data, l->head, NULL);
    if (!node)
        return 0;
    l->head = node;
    return 1;
}
Exemple #8
0
t_bool list_add_elem_at_front(t_list *front_ptr, void *elem) {
	t_node *node = list_create_node(elem);
	if (!node) {
		return FALSE;
	}
	node->next = *front_ptr;
	*front_ptr = node;
	return TRUE;
}
Exemple #9
0
Fichier : list.c Projet : gm561/aos
/*
 * Inserts an element in the head of the list.
 */
int32_t collections_list_insert(collections_listnode *start, void *data)
{
	collections_listnode *ret = list_create_node(start, start, data);
	if (ret) {
		// success ...
		return 0;
	}
	return 1;
}
Exemple #10
0
int list_push_front(List* l, int data)
{
    int pos;
    ListNode *node = list_create_node(l, data, l->head, &pos);
    if (!node)
        return 0;
    l->head = pos;
    ++l->total;
    return 1;
}
Exemple #11
0
int list_push_back(List *l, int data)
{
    ListNode *node;
    ListNode *last = list_get_tail(l);

    if (!last)
        return list_push_front(l, data);

    node = list_create_node(data, NULL, last);
    if (!node)
        return 0;
    return 1;
}
Exemple #12
0
/* Register fs */
void VfsInstallFileSystem(MCoreFileSystem_t *Fs)
{
	/* Ready the buffer */
	char IdentBuffer[8];
	memset(IdentBuffer, 0, 8);

	/* Copy the storage ident over */
	strcpy(IdentBuffer, "St");
	itoa(GlbFileSystemId, (IdentBuffer + 2), 10);

	/* Construct the identifier */
	Fs->Identifier = MStringCreate(&IdentBuffer, StrASCII);

	/* Setup last */
	Fs->Lock = MutexCreate();

	/* Add to list */
	list_append(GlbFileSystems, list_create_node(Fs->DiskId, Fs));

	/* Increament */
	GlbFileSystemId++;

	/* Start init? */
	if (Fs->Flags & VFS_MAIN_DRIVE
		&& !GlbVfsInitHasRun)
	{
		/* Process Request */
		MCoreProcessRequest_t *ProcRequest
			= (MCoreProcessRequest_t*)kmalloc(sizeof(MCoreProcessRequest_t));

		/* Print */
		LogInformation("VFSM", "Boot Drive Detected, Running Init");

		/* Append init path */
		MString_t *Path = MStringCreate(Fs->Identifier->Data, StrUTF8);
		MStringAppendChars(Path, FILESYSTEM_INIT);

		/* Create Request */
		ProcRequest->Type = ProcessSpawn;
		ProcRequest->Path = Path;
		ProcRequest->Arguments = NULL;
		ProcRequest->Cleanup = 1;

		/* Send */
		PmCreateRequest(ProcRequest);

		/* Set */
		GlbVfsInitHasRun = 1;
	}
}
int main(void)
{
	linked_list_t *list = (linked_list_t*)malloc(sizeof(linked_list_t));
	list_init(list);

	for (int i = 0; i < 10; i++){
		char string[100];
		sprintf(string, "Number: %d", i);
		list_add_first(list_create_node(i, string), list);
		list_add_last (list_create_node(i, string), list);
	}

	printf("Non-empty list\n");
	list_print(list);

	list_clear(list);

	printf("Empty list\n");
	list_print(list);

	list_free(list);
	free(list);
	return 0;
}
Exemple #14
0
int list_push_back(List *l, int data)
{
    ListNode *node;
    ListNode *last = list_get_tail(l);
    int pos;

    if (!last)
        return list_push_front(l, data);

    node = list_create_node(l, data, -1, &pos);
    if (!node)
        return 0;
    last->next = pos;
    ++l->total;
    return 1;
}
Exemple #15
0
int list_insert_at(List *l, int pos, int data)
{
    int i;
    ListNode *at = list_get_head(l), *node;

    if (pos==0)
        return list_push_front(l, data);

    for (i=0; i<pos; i++) {
        at = at->next;
        if (!at && i!=pos-1)
            return 0;
    }

    node = list_create_node(data, at, at->previous);
    return node!=NULL;
}
Exemple #16
0
/** add item to tail
 */
void list_add_last (linked_list* _this, void* item) {
   node* newNode = list_create_node(item);
   node* head = _this->head;
   node* tail = _this->tail;
    // list is empty
    if (head == NULL)
        _this->head = newNode;
    else { // has item(s)
       node* lastNode = tail;
        if (tail == NULL) // only head node
            lastNode = head;
        lastNode->next = newNode;
        newNode->prev = lastNode;
        _this->tail = newNode;
    }
    _this->size++;
}
Exemple #17
0
/* Create a request */
void DmCreateRequest(MCoreDeviceRequest_t *Request)
{
	/* Sanity */
	if (Request->Length > DEVICEMANAGER_MAX_IO_SIZE) {
		Request->Status = RequestInvalidParameters;
		return;
	}

	/* Append it to our request list */
	list_append(GlbDmEventQueue, list_create_node(0, Request));

	/* Set Pending */
	Request->Status = RequestPending;

	/* Notify request thread */
	SemaphoreV(GlbDmEventLock);
}
Exemple #18
0
t_bool list_add_elem_at_back(t_list* front_ptr, void *elem) {
	t_node *node = list_create_node(elem);
	t_list list = *front_ptr;
	if (!node) {
		return FALSE;
	}
	if (!list) {
		*front_ptr = node;
	}
	else {
		list = *front_ptr;
		while (list->next) {
			list = list->next;
		}
		list->next = node;
	}
	return TRUE;
}
list_t *list_add_node_head(list_t *list, void *value)
{
    list_node *node = list_create_node(list, value);
    if (node == NULL) {
        return NULL;
    }
    if (list->len == 0) {
        node->next = node->prev = NULL;
        list->head = list->tail = node;
    } else {
        node->next = list->head;
        node->prev = NULL;
        list->head->prev = node;
        list->head = node;
    }
    list->len += 1;
    return list;
}
Exemple #20
0
/*
 *	Add a Node to the Middle
 *	Of the Passed List
 *	The Node will Be Added
 *	AFTER the passed lnptr
 *	node pointer.
 *	Return a Pointer to the Data
 *
 *	position:
 *		ADD_BEFORE 	before the given lnptr node
 *		ADD_AFTER	after the given lnptr node
 */
void* list_add_node_middle(struct linkList* lptr,
	struct linkNode* lnptr, void* dptr, int position) {

	struct linkNode* nptr;

	if (lnptr == NULL)
		return NULL;
	if ((position != ADD_BEFORE) && (position != ADD_AFTER))
		return NULL;

	/*	Create the Node			*/
	nptr = list_create_node(dptr);

	/*	Link the Node into The List	*/
	if (lptr->root == NULL) {
		/*	Set as Root Node	*/
		lptr->root = nptr;
		lptr->last = nptr;
	} else if (lnptr->next != NULL) {
		/*	Link Node in Middle	*/
		if (position == ADD_AFTER) {
			/*	link before	*/
			lnptr->next->prev = nptr;
			nptr->next = lnptr->next;
			lnptr->next = nptr;
			nptr->prev = lnptr;
		} else {
			/*	link after	*/
			lnptr->prev->next = nptr;
			nptr->prev = lnptr->prev;
			nptr->next = lnptr;
			lnptr->prev = nptr;
		}
	} else {
		/*	Link Node as Last	*/
		lptr->last->next = nptr;
		nptr->prev = lptr->last;
		lptr->last = nptr;
	}
	return nptr->data;
}
Exemple #21
0
/*
 *	Add a Node to the End
 *	Of the Passed List
 *	Return a Pointer to the Data
 */
void* list_add_node_end(struct linkList* lptr, void* dptr) {
	struct linkNode* nptr;

	if (lptr == NULL)
		return NULL;

	/*	Create the Node			*/
	nptr = list_create_node(dptr);

	/*	Link the Node into The List	*/
	if (lptr->root == NULL) {
		/*	Set as Root Node	*/
		lptr->root = nptr;
		lptr->last = nptr;
	} else {
		/*	Link Node as Last	*/
		lptr->last->next = nptr;
		nptr->prev = lptr->last;
		lptr->last = nptr;
	}
	return nptr->data;
}
Exemple #22
0
t_bool list_add_elem_at_position(t_list* front_ptr, void *elem, unsigned int position) {
	if (position == 0) {
		return list_add_elem_at_front(front_ptr, elem);
	}
	if (!*front_ptr) {
		return FALSE;
	}
	t_list list = *front_ptr;
	while (--position) {
		list = list->next;
		if (!list) {
			return FALSE;
		}
	}
	t_node *node = list_create_node(elem);
	if (!node) {
		return FALSE;
	}
	node->next = list->next;
	list->next = node;
	return TRUE;
}
Exemple #23
0
int list_insert_at(List *l, int pos, int data)
{
    ListNode *node;
    int i, position;
    int at = l->head, pat;

    if (pos==0)
        return list_push_front(l, data);

    for (i=0; i<pos; i++) {
        pat = at;
        at = list_get_node(l, at)->next;
        if (at<0 && i!=pos-1)
            return 0;
    }

    node = list_create_node(l, data, at, &position);
    if (node)
        list_get_node(l, pat)->next = position;
    ++l->total;
    return node!=NULL;
}
Exemple #24
0
/* For each function we create a 
 * pci_device and add it to the list */
void PciCheckFunction(list_t *Bridge, uint8_t Bus, uint8_t Device, uint8_t Function)
{
	uint8_t SecondBus;
	PciNativeHeader_t *Pcs;
	PciDevice_t *PciDevice;

	/* Allocate */
	Pcs = (PciNativeHeader_t*)kmalloc(sizeof(PciNativeHeader_t));
	PciDevice = (PciDevice_t*)kmalloc(sizeof(PciDevice_t));

	/* Get full information */
	PciReadFunction(Pcs, Bus, Device, Function);

	/* Set information */
	PciDevice->Header = Pcs;
	PciDevice->Bus = Bus;
	PciDevice->Device = Device;
	PciDevice->Function = Function;
	PciDevice->Children = NULL;

	/* Info 
	 * Ignore the spam of device_id 0x7a0 in VMWare*/
	if (Pcs->DeviceId != 0x7a0)
	{
#ifdef X86_PCI_DIAGNOSE
		printf("    * [%d:%d:%d][%d:%d:%d] Vendor 0x%x, Device 0x%x : %s\n",
			Pcs->Class, Pcs->Subclass, Pcs->Interface,
			Bus, Device, Function,
			Pcs->VendorId, Pcs->DeviceId,
			PciToString(Pcs->Class, Pcs->Subclass, Pcs->Interface));
#endif
	}

	/* Do some disabling, but NOT on the video or bridge */
	if ((Pcs->Class != PCI_DEVICE_CLASS_BRIDGE) && (Pcs->Class != PCI_DEVICE_CLASS_VIDEO))
	{
		/* Disable Device untill further notice */
		uint16_t PciSettings = PciRead16(Bus, Device, Function, 0x04);
		PciWrite16(Bus, Device, Function, 0x04, PciSettings | X86_PCI_COMMAND_INTDISABLE);
	}
	
	/* Add to list */
	if (Pcs->Class == PCI_DEVICE_CLASS_BRIDGE && Pcs->Subclass == PCI_DEVICE_SUBCLASS_PCI)
	{
		PciDevice->Type = X86_PCI_TYPE_BRIDGE;
		list_append(Bridge, list_create_node(X86_PCI_TYPE_BRIDGE, PciDevice));
	}
	else
	{
		PciDevice->Type = X86_PCI_TYPE_DEVICE;
		list_append(Bridge, list_create_node(X86_PCI_TYPE_DEVICE, PciDevice));
	}

	/* Is this a secondary (PCI) bus */
	if ((Pcs->Class == PCI_DEVICE_CLASS_BRIDGE) && (Pcs->Subclass == PCI_DEVICE_SUBCLASS_PCI))
	{
		/* Uh oh, this dude has children */
		PciDevice->Children = list_create(LIST_SAFE);

		SecondBus = PciReadSecondaryBusNumber(Bus, Device, Function);
		PciCheckBus(PciDevice->Children, SecondBus);
	}
}
Exemple #25
0
/* For each function we create a 
 * pci_device and add it to the list */
void PciCheckFunction(list_t *Bridge, PciBus_t *BusIo, uint8_t Bus, uint8_t Device, uint8_t Function)
{
	/* Vars */
	MCoreDevice_t *mDevice;
	uint8_t SecondBus;
	PciNativeHeader_t *Pcs;
	PciDevice_t *PciDevice;

	/* Allocate */
	Pcs = (PciNativeHeader_t*)kmalloc(sizeof(PciNativeHeader_t));
	PciDevice = (PciDevice_t*)kmalloc(sizeof(PciDevice_t));

	/* Get full information */
	PciReadFunction(Pcs, BusIo, Bus, Device, Function);

	/* Set information */
	PciDevice->PciBus = BusIo;
	PciDevice->Header = Pcs;
	PciDevice->Bus = Bus;
	PciDevice->Device = Device;
	PciDevice->Function = Function;
	PciDevice->Children = NULL;

	/* Info 
	 * Ignore the spam of device_id 0x7a0 in VMWare*/
	if (Pcs->DeviceId != 0x7a0)
	{
#ifdef X86_PCI_DIAGNOSE
		printf("    * [%d:%d:%d][%d:%d:%d] Vendor 0x%x, Device 0x%x : %s\n",
			Pcs->Class, Pcs->Subclass, Pcs->Interface,
			Bus, Device, Function,
			Pcs->VendorId, Pcs->DeviceId,
			PciToString(Pcs->Class, Pcs->Subclass, Pcs->Interface));
#endif
	}

	/* Do some disabling, but NOT on the video or bridge */
	if ((Pcs->Class != PCI_DEVICE_CLASS_BRIDGE) 
		&& (Pcs->Class != PCI_DEVICE_CLASS_VIDEO))
	{
		/* Disable Device untill further notice */
		uint16_t PciSettings = PciRead16(BusIo, Bus, Device, Function, 0x04);
		PciWrite16(BusIo, Bus, Device, Function, 0x04, PciSettings | X86_PCI_COMMAND_INTDISABLE);
	}
	
	/* Add to list */
	if (Pcs->Class == PCI_DEVICE_CLASS_BRIDGE && Pcs->Subclass == PCI_DEVICE_SUBCLASS_PCI)
	{
		PciDevice->Type = X86_PCI_TYPE_BRIDGE;
		list_append(Bridge, list_create_node(X86_PCI_TYPE_BRIDGE, PciDevice));

		/* Uh oh, this dude has children */
		PciDevice->Children = list_create(LIST_SAFE);

		/* Get secondary bus no and iterate */
		SecondBus = PciReadSecondaryBusNumber(BusIo, Bus, Device, Function);
		PciCheckBus(PciDevice->Children, BusIo, SecondBus);
	}
	else
	{
		/* This is an device */
		PciDevice->Type = X86_PCI_TYPE_DEVICE;
		list_append(Bridge, list_create_node(X86_PCI_TYPE_DEVICE, PciDevice));

		/* Register device with the OS */
		mDevice = (MCoreDevice_t*)kmalloc(sizeof(MCoreDevice_t));
		memset(mDevice, 0, sizeof(MCoreDevice_t));
		
		/* Setup information */
		mDevice->VendorId = Pcs->VendorId;
		mDevice->DeviceId = Pcs->DeviceId;
		mDevice->Class = Pcs->Class;
		mDevice->Subclass = Pcs->Subclass;
		mDevice->Interface = Pcs->Interface;

		mDevice->Segment = (DevInfo_t)BusIo->Segment;
		mDevice->Bus = Bus;
		mDevice->Device = Device;
		mDevice->Function = Function;

		mDevice->IrqLine = -1;
		mDevice->IrqPin = (int)Pcs->InterruptPin;
		mDevice->IrqAvailable[0] = Pcs->InterruptLine;

		/* Type */
		mDevice->Type = DeviceUnknown;
		mDevice->Data = NULL;

		/* Save bus information */
		mDevice->BusInformation = PciDevice;

		/* Initial */
		mDevice->Driver.Name = NULL;
		mDevice->Driver.Version = -1;
		mDevice->Driver.Data = NULL;
		mDevice->Driver.Status = DriverNone;

		/* Read Bars */
		PciReadBars(BusIo, mDevice, Pcs->HeaderType);

		/* Register */
		DmCreateDevice((char*)PciToString(Pcs->Class, Pcs->Subclass, Pcs->Interface), mDevice);
	}
}
Exemple #26
0
/* Loads the RD */
void ModuleMgrInit(MCoreBootDescriptor *BootDescriptor)
{
	/* Get pointers */
	MCoreRamDiskHeader_t *RdHeader = (MCoreRamDiskHeader_t*)BootDescriptor->RamDiskAddress;

	/* Sanity */
	if (BootDescriptor->RamDiskAddress == 0
		|| BootDescriptor->RamDiskSize == 0)
		return;

	/* Info */
	LogInformation("MDMG", "Initializing");

	/* Parse Kernel Exports */
	PeLoadKernelExports(BootDescriptor->KernelAddress, BootDescriptor->ExportsAddress);

	/* Validate Members */
	if (RdHeader->Magic != RAMDISK_MAGIC)
	{
		/* Error! */
		LogFatal("MDMG", "Invalid Magic in Ramdisk - 0x%x", RdHeader->Magic);
		return;
	}

	/* Valid Version? */
	if (RdHeader->Version != RAMDISK_VERSION_1)
	{
		/* Error! */
		LogFatal("MDMG", "Invalid RamDisk Version - 0x%x", RdHeader->Version);
		return;
	}

	/* Allocate list */
	GlbModMgrModules = list_create(LIST_NORMAL);

	/* Save Module-Count */
	uint32_t FileCount = RdHeader->FileCount;
	Addr_t RdPtr = BootDescriptor->RamDiskAddress + sizeof(MCoreRamDiskHeader_t);

	/* Point to first entry */
	MCoreRamDiskFileHeader_t *FilePtr = (MCoreRamDiskFileHeader_t*)RdPtr;

	/* Iterate */
	while (FileCount != 0)
	{
		/* We only care about modules */
		if (FilePtr->Type == RAMDISK_MODULE)
		{
			/* Get a pointer to the module header */
			MCoreRamDiskModuleHeader_t *ModuleHeader = 
				(MCoreRamDiskModuleHeader_t*)(BootDescriptor->RamDiskAddress + FilePtr->DataOffset);

			/* Allocate a new module */
			MCoreModule_t *Module = (MCoreModule_t*)kmalloc(sizeof(MCoreModule_t));

			/* Set */
			Module->Name = MStringCreate(ModuleHeader->ModuleName, StrUTF8);
			Module->Header = ModuleHeader;
			Module->Descriptor = NULL;

			/* Add to list */
			list_append(GlbModMgrModules, list_create_node(0, Module));
		}

		/* Next! */
		FilePtr++;
		FileCount--;
	}

	/* Info */
	LogInformation("MDMG", "Found %i Modules", GlbModMgrModules->length);

	/* Done! */
	GlbModMgrInitialized = 1;
}