system/memserv/dataspace.c

13 #include "dataspace.h"
20     @brief Process Server anon RAM dataspace implementation. */
24 /* --------------------------- RAM dataspace OAT callback functions ----------------------------- */
29     in order to create dataspace objects. Here we malloc some memory for the structure, initialise
30     its data structures, initialise its page array, and mint the dataspace badge capability.
32     @param oat The parent dataspace list (struct ram_dspace_list*).
33     @param id The dataspace ID allocated by the OAT table.
34     @param arg Arg[0] is the dataspace size, the rest unused.
35     @return A new dataspace (struct ram_dspace *) on success, NULL on error. (Transfers ownership)
67     /* Mint the badged capability representing this ram dataspace. */
88     to delete dataspace objects created by ram_dspace_oat_create(). It unmaps the dataspace from
92     @param oat The parent dataspace list (struct ram_dspace_list*).
93     @param obj The dataspace to delete (struct ram_dspace *) (Takes ownership).
102     /* Unmap everywhere where this dataspace has been mapped, by notifying the global procServ
103        window list that this dataspace has been deleted. This will loop through the windowList,
111         ROS_WARNING("WARNING WARNING WARNING: RAM dataspace is being force released with hanging");
114         ROS_WARNING("dataspace, that belongs to a RDS list which has been freed.");
160                 /* We do own this anonymous dataspace frame. */
177 /* ------------------------------- RAM dataspace table functions -------------------------------- */
179 /*! @brief Calculates the page index into the dataspace based on the nbytes offset.
180     @param nbytes The offset into the ram dataspace.
181     @return The page index into the dataspace.
193     dprintf("Initialising RAM dataspace allocation table (max %d dspaces).\n",
227     /* Allocate the dataspace ID and structure. */
243         ROS_ERROR("ram_dspace_ref no such dataspace!");
244         assert(!"ram_dspace_ref no such dataspace! Procserv book keeping error.");
256         ROS_ERROR("ram_dspace_unref no such dataspace!");
257         assert(!"ram_dspace_unref no such dataspace! Procserv book keeping error.");
269 ram_dspace_check_page(struct ram_dspace *dataspace, uint32_t offset)
271     assert(dataspace && dataspace->magic == RAM_DATASPACE_MAGIC);
273     if (idx >= dataspace->npages) {
277     return dataspace->pages[idx].cptr;
281 ram_dspace_get_page(struct ram_dspace *dataspace, uint32_t offset)
283     assert(dataspace && dataspace->magic == RAM_DATASPACE_MAGIC);
285     if (idx >= dataspace->npages) {
289     if (!dataspace->pages[idx].cptr) {
290         if (dataspace->physicalAddrEnabled) {
293                     (void*) dataspace->physicalAddr + idx * REFOS_PAGE_SIZE, REFOS_PAGE_SIZE);
298             memset(&dataspace->pages[idx], 0, sizeof(vka_object_t));
299             dataspace->pages[idx].cptr = deviceFrame.capPtr;
302             int error = vka_alloc_frame(&procServ.vka, seL4_PageBits, &dataspace->pages[idx]);
303             if (error || !dataspace->pages[idx].cptr) {
309     return dataspace->pages[idx].cptr;
334 ram_dspace_get_size(struct ram_dspace *dataspace)
336     assert(dataspace && dataspace->magic == RAM_DATASPACE_MAGIC);
337     return dataspace->npages * REFOS_PAGE_SIZE;
341 ram_dspace_expand(struct ram_dspace *dataspace, uint32_t size)
343     assert(dataspace && dataspace->magic == RAM_DATASPACE_MAGIC);
346     if (npages < dataspace->npages) {
349     } else if (npages == dataspace->npages) {
353     uint32_t nbitmaskPrev = (dataspace->npages / 32) + 1;
355     /* Expand the dataspace. */
356     dataspace->pages = krealloc(dataspace->pages, sizeof(vka_object_t) * npages);
357     if (!dataspace->pages) {
361     uint32_t pageDiff = npages - dataspace->npages;
363     memset(&dataspace->pages[dataspace->npages], 0, sizeof(vka_object_t) * pageDiff);
365     /* Expand the dataspace content init mask. */
367     if (dataspace->contentInitBitmask && nbitmaskPrev < nbitmask) {
368         dataspace->contentInitBitmask = krealloc (
369                 dataspace->contentInitBitmask, nbitmask * sizeof(uint32_t)
371         if (!dataspace->contentInitBitmask) {
377         memset(&dataspace->contentInitBitmask[nbitmaskPrev], 0, bitmaskDiff * sizeof(uint32_t));
380     dataspace->npages = npages;
385 ram_dspace_set_to_paddr(struct ram_dspace *dataspace, uint32_t paddr)
387     /* Check that the dataspace isn't already occupied with something. */
388     if (dataspace->contentInitEnabled) {
392     if (dataspace->physicalAddrEnabled) {
397     /* Check that the dataspace is empty. */
399     for (int i = 0; i < dataspace->npages; i++) {
400         if (dataspace->pages[i].cptr) {
417     dataspace->physicalAddrEnabled = true;
418     dataspace->physicalAddr = paddr;
422 /* --------------------------- RAM dataspace read / write functions ----------------------------- */
424 /*! @brief Reads data from a single page within a ram dataspace.
426     Reads data from a single page within a ram dataspace. Can _NOT_ read across page boundaries.
435     @param dataspace The source ram dataspace. (No ownership)
436     @param offset The offset into the dataspace to read from.
440 ram_dspace_read_page(char *buf, size_t len, struct ram_dspace *dataspace, uint32_t offset)
447     seL4_CPtr frame = ram_dspace_get_page(dataspace, offset);
455 /*! @brief Writes data to a page within a ram dataspace.
457     Writes data to a page within a ram dataspace. Can _NOT_ write across page boundaries.
466     @param dataspace The destination dataspace to be written to. (No ownership)
467     @param offset The offset into the dataspace to write to.
471 ram_dspace_write_page(char *buf, size_t len, struct ram_dspace *dataspace, uint32_t offset)
478     seL4_CPtr frame = ram_dspace_get_page(dataspace, offset);
487 ram_dspace_read(char *buf, size_t len, struct ram_dspace *dataspace, uint32_t offset)
489     assert(buf && dataspace && dataspace->magic == RAM_DATASPACE_MAGIC);
493     /* Check if the read length runs off the end of the dataspace. */
494     if (len > ((dataspace->npages * REFOS_PAGE_SIZE) - offset)) {
504                 dataspace, start
518 ram_dspace_write(char *buf, size_t len, struct ram_dspace *dataspace, uint32_t offset)
520     assert(buf && dataspace && dataspace->magic == RAM_DATASPACE_MAGIC);
524     /* Check if the write length runs off the end of the dataspace. */
525     if (len > ((dataspace->npages * REFOS_PAGE_SIZE) - offset)) {
535                 dataspace, start
549 /* --------------------------- RAM dataspace content init functions ----------------------------- */
552 ram_dspace_content_init(struct ram_dspace *dataspace, cspacepath_t initEP, uint32_t initPID)
554     assert(dataspace && dataspace->magic == RAM_DATASPACE_MAGIC);
556     /* We can't content init a dataspace that is physical address bound. */
557     if (dataspace->physicalAddrEnabled) {
558         ROS_WARNING("Can't content init a dataspace that is physical address bound.");
563     if (dataspace->contentInitBitmask) {
564         kfree(dataspace->contentInitBitmask);
565         dataspace->contentInitBitmask = NULL;
569     if (dataspace->contentInitEnabled) {
570         assert(dataspace->contentInitEP.capPtr);
571         vka_cnode_revoke(&dataspace->contentInitEP);
572         vka_cnode_delete(&dataspace->contentInitEP);
573         vka_cspace_free(&procServ.vka, dataspace->contentInitEP.capPtr);
574         dataspace->contentInitEP.capPtr = 0;
579         dataspace->contentInitEnabled = false;
580         dataspace->contentInitPID = PID_NULL;
585     uint32_t nbitmask = (dataspace->npages / 32) + 1;
586     dataspace->contentInitBitmask = kmalloc(nbitmask * sizeof(uint32_t));
587     if (!dataspace->contentInitBitmask) {
591     memset(dataspace->contentInitBitmask, 0, nbitmask * sizeof(uint32_t));
594     int waitingListCount = cvector_count(&dataspace->contentInitWaitingList);
597                 cvector_get(&dataspace->contentInitWaitingList, i);
606     cvector_free(&dataspace->contentInitWaitingList);
607     cvector_init(&dataspace->contentInitWaitingList);
610     dataspace->contentInitEP = initEP;
611     dataspace->contentInitEnabled = true;
612     dataspace->contentInitPID = initPID;
617 ram_dspace_need_content_init(struct ram_dspace *dataspace, uint32_t offset)
619     assert(dataspace && dataspace->magic == RAM_DATASPACE_MAGIC);
621     if (!dataspace->contentInitEnabled || !dataspace->contentInitBitmask) {
624     if (offset > ram_dspace_get_size(dataspace)) {
631     assert(npage <= dataspace->npages);
633     return !((dataspace->contentInitBitmask[idxbitmask] >> idxshift) & 0x1);
637 ram_dspace_add_content_init_waiter(struct ram_dspace *dataspace, uint32_t offset,
640     assert(dataspace && dataspace->magic == RAM_DATASPACE_MAGIC);
645     if (offset > ram_dspace_get_size(dataspace)) {
648     if (!dataspace->contentInitEnabled) {
653     assert(npage < dataspace->npages);
666     cvector_add(&dataspace->contentInitWaitingList, (cvector_item_t) waiter);
671 ram_dspace_add_content_init_waiter_save_current_caller(struct ram_dspace *dataspace,
691     return ram_dspace_add_content_init_waiter(dataspace, offset, callerReply);
696 ram_dspace_content_init_reply_waiters(struct ram_dspace *dataspace, uint32_t offset)
698     assert(dataspace && dataspace->magic == RAM_DATASPACE_MAGIC);
702     if(npage >= dataspace->npages) {
709     int waitingListCount = cvector_count(&dataspace->contentInitWaitingList);
712                 cvector_get(&dataspace->contentInitWaitingList, i);
721             cvector_delete(&dataspace->contentInitWaitingList, i);
723             assert(waitingListCount == cvector_count(&dataspace->contentInitWaitingList));
736 ram_dspace_set_content_init_provided(struct ram_dspace *dataspace, uint32_t offset)
738     assert(dataspace && dataspace->magic == RAM_DATASPACE_MAGIC);
740     if (!dataspace->contentInitEnabled || !dataspace->contentInitBitmask) {
744     if (offset > ram_dspace_get_size(dataspace)) {
752     assert(npage <= dataspace->npages);
755     dataspace->contentInitBitmask[idxbitmask] |= (1 << idxshift);