Changeset 69146b93 in mainline for kernel/generic/src


Ignore:
Timestamp:
2012-11-26T19:02:45Z (13 years ago)
Author:
Adam Hraska <adam.hraska+hos@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
04552324
Parents:
5d230a30 (diff), 7462674 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merged mainline,1723.

Location:
kernel/generic/src
Files:
11 edited

Legend:

Unmodified
Added
Removed

  • kernel/generic/src/console/cmd.c

    r5d230a30 r69146b93  
    5656#include <cpu.h>
    5757#include <mm/tlb.h>
     58#include <mm/km.h>
    5859#include <arch/mm/tlb.h>
    5960#include <mm/frame.h>
    … …  
    8384        .func = cmd_help,
    8485        .argc = 0
     86};
     87
     88/* Data and methods for pio_read_8 command */
     89static int cmd_pio_read_8(cmd_arg_t *argv);
     90static cmd_arg_t pio_read_8_argv[] = { { .type = ARG_TYPE_INT } };
     91static cmd_info_t pio_read_8_info = {
     92        .name = "pio_read_8",
     93        .description = "pio_read_8 <address> Read 1 byte from memory (or port).",
     94        .func = cmd_pio_read_8,
     95        .argc = 1,
     96        .argv = pio_read_8_argv
     97};
     98
     99/* Data and methods for pio_read_16 command */
     100static int cmd_pio_read_16(cmd_arg_t *argv);
     101static cmd_arg_t pio_read_16_argv[] = { { .type = ARG_TYPE_INT } };
     102static cmd_info_t pio_read_16_info = {
     103        .name = "pio_read_16",
     104        .description = "pio_read_16 <address> Read 2 bytes from memory (or port).",
     105        .func = cmd_pio_read_16,
     106        .argc = 1,
     107        .argv = pio_read_16_argv
     108};
     109
     110/* Data and methods for pio_read_32 command */
     111static int cmd_pio_read_32(cmd_arg_t *argv);
     112static cmd_arg_t pio_read_32_argv[] = { { .type = ARG_TYPE_INT } };
     113static cmd_info_t pio_read_32_info = {
     114        .name = "pio_read_32",
     115        .description = "pio_read_32 <address> Read 4 bytes from memory (or port).",
     116        .func = cmd_pio_read_32,
     117        .argc = 1,
     118        .argv = pio_read_32_argv
     119};
     120
     121/* Data and methods for pio_write_8 command */
     122static int cmd_pio_write_8(cmd_arg_t *argv);
     123static cmd_arg_t pio_write_8_argv[] = {
     124        { .type = ARG_TYPE_INT },
     125        { .type = ARG_TYPE_INT }
     126};
     127static cmd_info_t pio_write_8_info = {
     128        .name = "pio_write_8",
     129        .description = "pio_write_8 <address> <value> Write 1 byte to memory (or port).",
     130        .func = cmd_pio_write_8,
     131        .argc = 2,
     132        .argv = pio_write_8_argv
     133};
     134
     135/* Data and methods for pio_write_16 command */
     136static int cmd_pio_write_16(cmd_arg_t *argv);
     137static cmd_arg_t pio_write_16_argv[] = {
     138        { .type = ARG_TYPE_INT },
     139        { .type = ARG_TYPE_INT }
     140};
     141static cmd_info_t pio_write_16_info = {
     142        .name = "pio_write_16",
     143        .description = "pio_write_16 <address> <value> Write 2 bytes to memory (or port).",
     144        .func = cmd_pio_write_16,
     145        .argc = 2,
     146        .argv = pio_write_16_argv
     147};
     148
     149/* Data and methods for pio_write_32 command */
     150static int cmd_pio_write_32(cmd_arg_t *argv);
     151static cmd_arg_t pio_write_32_argv[] = {
     152        { .type = ARG_TYPE_INT },
     153        { .type = ARG_TYPE_INT }
     154};
     155static cmd_info_t pio_write_32_info = {
     156        .name = "pio_write_32",
     157        .description = "pio_write_32 <address> <value> Write 4 bytes to memory (or port).",
     158        .func = cmd_pio_write_32,
     159        .argc = 2,
     160        .argv = pio_write_32_argv
    85161};
    86162
    … …  
    553629        &btrace_info,
    554630#endif
     631        &pio_read_8_info,
     632        &pio_read_16_info,
     633        &pio_read_32_info,
     634        &pio_write_8_info,
     635        &pio_write_16_info,
     636        &pio_write_32_info,
    555637        NULL
    556638};
    … …  
    623705        spinlock_unlock(&cmd_lock);
    624706       
     707        return 1;
     708}
     709
     710/** Read 1 byte from phys memory or io port.
     711 *
     712 * @param argv Argument vector.
     713 *
     714 * @return 0 on failure, 1 on success.
     715 */
     716static int cmd_pio_read_8(cmd_arg_t *argv)
     717{
     718        uint8_t *ptr = NULL;
     719       
     720#ifdef IO_SPACE_BOUNDARY
     721        if ((void *) argv->intval < IO_SPACE_BOUNDARY)
     722                ptr = (void *) argv[0].intval;
     723        else
     724#endif
     725                ptr = (uint8_t *) km_map(argv[0].intval, sizeof(uint8_t),
     726                    PAGE_NOT_CACHEABLE);
     727       
     728        const uint8_t val = pio_read_8(ptr);
     729        printf("read %" PRIxn ": %" PRIx8 "\n", argv[0].intval, val);
     730       
     731#ifdef IO_SPACE_BOUNDARY
     732        if ((void *) argv->intval < IO_SPACE_BOUNDARY)
     733                return 1;
     734#endif
     735       
     736        km_unmap((uintptr_t) ptr, sizeof(uint8_t));
     737        return 1;
     738}
     739
     740/** Read 2 bytes from phys memory or io port.
     741 *
     742 * @param argv Argument vector.
     743 *
     744 * @return 0 on failure, 1 on success.
     745 */
     746static int cmd_pio_read_16(cmd_arg_t *argv)
     747{
     748        uint16_t *ptr = NULL;
     749       
     750#ifdef IO_SPACE_BOUNDARY
     751        if ((void *) argv->intval < IO_SPACE_BOUNDARY)
     752                ptr = (void *) argv[0].intval;
     753        else
     754#endif
     755                ptr = (uint16_t *) km_map(argv[0].intval, sizeof(uint16_t),
     756                    PAGE_NOT_CACHEABLE);
     757       
     758        const uint16_t val = pio_read_16(ptr);
     759        printf("read %" PRIxn ": %" PRIx16 "\n", argv[0].intval, val);
     760       
     761#ifdef IO_SPACE_BOUNDARY
     762        if ((void *) argv->intval < IO_SPACE_BOUNDARY)
     763                return 1;
     764#endif
     765       
     766        km_unmap((uintptr_t) ptr, sizeof(uint16_t));
     767        return 1;
     768}
     769
     770/** Read 4 bytes from phys memory or io port.
     771 *
     772 * @param argv Argument vector.
     773 *
     774 * @return 0 on failure, 1 on success.
     775 */
     776static int cmd_pio_read_32(cmd_arg_t *argv)
     777{
     778        uint32_t *ptr = NULL;
     779       
     780#ifdef IO_SPACE_BOUNDARY
     781        if ((void *) argv->intval < IO_SPACE_BOUNDARY)
     782                ptr = (void *) argv[0].intval;
     783        else
     784#endif
     785                ptr = (uint32_t *) km_map(argv[0].intval, sizeof(uint32_t),
     786                    PAGE_NOT_CACHEABLE);
     787       
     788        const uint32_t val = pio_read_32(ptr);
     789        printf("read %" PRIxn ": %" PRIx32 "\n", argv[0].intval, val);
     790       
     791#ifdef IO_SPACE_BOUNDARY
     792        if ((void *) argv->intval < IO_SPACE_BOUNDARY)
     793                return 1;
     794#endif
     795       
     796        km_unmap((uintptr_t) ptr, sizeof(uint32_t));
     797        return 1;
     798}
     799
     800/** Write 1 byte to phys memory or io port.
     801 *
     802 * @param argv Argument vector.
     803 *
     804 * @return 0 on failure, 1 on success.
     805 */
     806static int cmd_pio_write_8(cmd_arg_t *argv)
     807{
     808        uint8_t *ptr = NULL;
     809       
     810#ifdef IO_SPACE_BOUNDARY
     811        if ((void *) argv->intval < IO_SPACE_BOUNDARY)
     812                ptr = (void *) argv[0].intval;
     813        else
     814#endif
     815                ptr = (uint8_t *) km_map(argv[0].intval, sizeof(uint8_t),
     816                    PAGE_NOT_CACHEABLE);
     817       
     818        printf("write %" PRIxn ": %" PRIx8 "\n", argv[0].intval,
     819            (uint8_t) argv[1].intval);
     820        pio_write_8(ptr, (uint8_t) argv[1].intval);
     821       
     822#ifdef IO_SPACE_BOUNDARY
     823        if ((void *) argv->intval < IO_SPACE_BOUNDARY)
     824                return 1;
     825#endif
     826       
     827        km_unmap((uintptr_t) ptr, sizeof(uint8_t));
     828        return 1;
     829}
     830
     831/** Write 2 bytes to phys memory or io port.
     832 *
     833 * @param argv Argument vector.
     834 *
     835 * @return 0 on failure, 1 on success.
     836 */
     837static int cmd_pio_write_16(cmd_arg_t *argv)
     838{
     839        uint16_t *ptr = NULL;
     840       
     841#ifdef IO_SPACE_BOUNDARY
     842        if ((void *) argv->intval < IO_SPACE_BOUNDARY)
     843                ptr = (void *) argv[0].intval;
     844        else
     845#endif
     846                ptr = (uint16_t *) km_map(argv[0].intval, sizeof(uint16_t),
     847                    PAGE_NOT_CACHEABLE);
     848       
     849        printf("write %" PRIxn ": %" PRIx16 "\n", argv[0].intval,
     850            (uint16_t) argv[1].intval);
     851        pio_write_16(ptr, (uint16_t) argv[1].intval);
     852       
     853#ifdef IO_SPACE_BOUNDARY
     854        if ((void *) argv->intval < IO_SPACE_BOUNDARY)
     855                return 1;
     856#endif
     857       
     858        km_unmap((uintptr_t) ptr, sizeof(uint16_t));
     859        return 1;
     860}
     861
     862/** Write 4 bytes to phys memory or io port.
     863 *
     864 * @param argv Argument vector.
     865 *
     866 * @return 0 on failure, 1 on success.
     867 */
     868static int cmd_pio_write_32(cmd_arg_t *argv)
     869{
     870        uint32_t *ptr = NULL;
     871       
     872#ifdef IO_SPACE_BOUNDARY
     873        if ((void *) argv->intval < IO_SPACE_BOUNDARY)
     874                ptr = (void *) argv[0].intval;
     875        else
     876#endif
     877                ptr = (uint32_t *) km_map(argv[0].intval, sizeof(uint32_t),
     878                    PAGE_NOT_CACHEABLE);
     879       
     880        printf("write %" PRIxn ": %" PRIx32 "\n", argv[0].intval,
     881            (uint32_t) argv[1].intval);
     882        pio_write_32(ptr, (uint32_t) argv[1].intval);
     883       
     884#ifdef IO_SPACE_BOUNDARY
     885        if ((void *) argv->intval < IO_SPACE_BOUNDARY)
     886                return 1;
     887#endif
     888       
     889        km_unmap((uintptr_t) ptr, sizeof(uint32_t));
    625890        return 1;
    626891}

  • kernel/generic/src/console/kconsole.c

    r5d230a30 r69146b93  
    525525                /* It's a number - convert it */
    526526                uint64_t value;
    527                 int rc = str_uint64_t(text, NULL, 0, true, &value);
     527                char *end;
     528                int rc = str_uint64_t(text, &end, 0, false, &value);
     529                if (end != text + len)
     530                        rc = EINVAL;
    528531                switch (rc) {
    529532                case EINVAL:
    530                         printf("Invalid number.\n");
     533                        printf("Invalid number '%s'.\n", text);
    531534                        return false;
    532535                case EOVERFLOW:
    533                         printf("Integer overflow.\n");
     536                        printf("Integer overflow in '%s'.\n", text);
    534537                        return false;
    535538                case EOK:
    … …  
    539542                        break;
    540543                default:
    541                         printf("Unknown error.\n");
     544                        printf("Unknown error parsing '%s'.\n", text);
    542545                        return false;
    543546                }

  • kernel/generic/src/interrupt/interrupt.c

    r5d230a30 r69146b93  
    164164}
    165165
    166 static NO_TRACE void fault_from_uspace_core(istate_t *istate, const char *fmt, va_list args)
     166static NO_TRACE
     167void fault_from_uspace_core(istate_t *istate, const char *fmt, va_list args)
    167168{
    168169        printf("Task %s (%" PRIu64 ") killed due to an exception at "

  • kernel/generic/src/main/kinit.c

    r5d230a30 r69146b93  
    182182#endif /* CONFIG_KCONSOLE */
    183183       
     184        /*
     185         * Store the default stack size in sysinfo so that uspace can create
     186         * stack with this default size.
     187         */
     188        sysinfo_set_item_val("default.stack_size", NULL, STACK_SIZE_USER);
     189       
    184190        interrupts_enable();
    185191       

  • kernel/generic/src/mm/as.c

    r5d230a30 r69146b93  
    7979#include <syscall/copy.h>
    8080#include <arch/interrupt.h>
     81#include <interrupt.h>
    8182
    8283/**
    … …  
    426427        /*
    427428         * So far, the area does not conflict with other areas.
    428          * Check if it doesn't conflict with kernel address space.
     429         * Check if it is contained in the user address space.
    429430         */
    430431        if (!KERNEL_ADDRESS_SPACE_SHADOWED) {
    431                 return !overlaps(addr, P2SZ(count), KERNEL_ADDRESS_SPACE_START,
    432                     KERNEL_ADDRESS_SPACE_END - KERNEL_ADDRESS_SPACE_START);
     432                return iswithin(USER_ADDRESS_SPACE_START,
     433                    (USER_ADDRESS_SPACE_END - USER_ADDRESS_SPACE_START) + 1,
     434                    addr, P2SZ(count));
    433435        }
    434436       
    … …  
    696698                return ENOENT;
    697699        }
    698        
    699         if (area->backend == &phys_backend) {
    700                 /*
    701                  * Remapping of address space areas associated
    702                  * with memory mapped devices is not supported.
     700
     701        if (!area->backend->is_resizable(area)) {
     702                /*
     703                 * The backend does not support resizing for this area.
    703704                 */
    704705                mutex_unlock(&area->lock);
    … …  
    10571058        }
    10581059       
    1059         if ((!src_area->backend) || (!src_area->backend->share)) {
    1060                 /*
    1061                  * There is no backend or the backend does not
    1062                  * know how to share the area.
     1060        if (!src_area->backend->is_shareable(src_area)) {
     1061                /*
     1062                 * The backend does not permit sharing of this area.
    10631063                 */
    10641064                mutex_unlock(&src_area->lock);
    … …  
    13631363int as_page_fault(uintptr_t page, pf_access_t access, istate_t *istate)
    13641364{
     1365        int rc = AS_PF_FAULT;
     1366
    13651367        if (!THREAD)
    1366                 return AS_PF_FAULT;
     1368                goto page_fault;
    13671369       
    13681370        if (!AS)
    1369                 return AS_PF_FAULT;
     1371                goto page_fault;
    13701372       
    13711373        mutex_lock(&AS->lock);
    … …  
    14231425         * Resort to the backend page fault handler.
    14241426         */
    1425         if (area->backend->page_fault(area, page, access) != AS_PF_OK) {
     1427        rc = area->backend->page_fault(area, page, access);
     1428        if (rc != AS_PF_OK) {
    14261429                page_table_unlock(AS, false);
    14271430                mutex_unlock(&area->lock);
    … …  
    14441447                istate_set_retaddr(istate,
    14451448                    (uintptr_t) &memcpy_to_uspace_failover_address);
     1449        } else if (rc == AS_PF_SILENT) {
     1450                printf("Killing task %" PRIu64 " due to a "
     1451                    "failed late reservation request.\n", TASK->taskid);
     1452                task_kill_self(true);
    14461453        } else {
    1447                 return AS_PF_FAULT;
     1454                fault_if_from_uspace(istate, "Page fault: %p.", (void *) page);
     1455                panic_memtrap(istate, access, page, NULL);
    14481456        }
    14491457       
    … …  
    21322140{
    21332141        uintptr_t virt = base;
    2134         as_area_t *area = as_area_create(AS, flags | AS_AREA_CACHEABLE, size,
     2142        as_area_t *area = as_area_create(AS, flags, size,
    21352143            AS_AREA_ATTR_NONE, &anon_backend, NULL, &virt, bound);
    21362144        if (area == NULL)

  • kernel/generic/src/mm/backend_anon.c

    r5d230a30 r69146b93  
    5959static void anon_destroy(as_area_t *);
    6060
     61static bool anon_is_resizable(as_area_t *);
     62static bool anon_is_shareable(as_area_t *);
     63
    6164static int anon_page_fault(as_area_t *, uintptr_t, pf_access_t);
    6265static void anon_frame_free(as_area_t *, uintptr_t, uintptr_t);
    … …  
    6871        .destroy = anon_destroy,
    6972
     73        .is_resizable = anon_is_resizable,
     74        .is_shareable = anon_is_shareable,
     75
    7076        .page_fault = anon_page_fault,
    7177        .frame_free = anon_frame_free,
    … …  
    7480bool anon_create(as_area_t *area)
    7581{
     82        if (area->flags & AS_AREA_LATE_RESERVE)
     83                return true;
     84
    7685        return reserve_try_alloc(area->pages);
    7786}
    … …  
    7988bool anon_resize(as_area_t *area, size_t new_pages)
    8089{
     90        if (area->flags & AS_AREA_LATE_RESERVE)
     91                return true;
     92
    8193        if (new_pages > area->pages)
    8294                return reserve_try_alloc(new_pages - area->pages);
    … …  
    100112        ASSERT(mutex_locked(&area->as->lock));
    101113        ASSERT(mutex_locked(&area->lock));
     114        ASSERT(!(area->flags & AS_AREA_LATE_RESERVE));
    102115
    103116        /*
    … …  
    139152void anon_destroy(as_area_t *area)
    140153{
     154        if (area->flags & AS_AREA_LATE_RESERVE)
     155                return;
     156
    141157        reserve_free(area->pages);
    142158}
    143159
     160bool anon_is_resizable(as_area_t *area)
     161{
     162        return true;
     163}
     164
     165bool anon_is_shareable(as_area_t *area)
     166{
     167        return !(area->flags & AS_AREA_LATE_RESERVE);
     168}
    144169
    145170/** Service a page fault in the anonymous memory address space area.
    … …  
    225250                 *   the different causes
    226251                 */
     252
     253                if (area->flags & AS_AREA_LATE_RESERVE) {
     254                        /*
     255                         * Reserve the memory for this page now.
     256                         */
     257                        if (!reserve_try_alloc(1))
     258                                return AS_PF_SILENT;
     259                }
     260
    227261                kpage = km_temporary_page_get(&frame, FRAME_NO_RESERVE);
    228262                memsetb((void *) kpage, PAGE_SIZE, 0);
    … …  
    255289        ASSERT(mutex_locked(&area->lock));
    256290
    257         frame_free_noreserve(frame);
     291        if (area->flags & AS_AREA_LATE_RESERVE) {
     292                /*
     293                 * In case of the late reserve areas, physical memory will not
     294                 * be unreserved when the area is destroyed so we need to use
     295                 * the normal unreserving frame_free().
     296                 */
     297                frame_free(frame);
     298        } else {
     299                /*
     300                 * The reserve will be given back when the area is destroyed or
     301                 * resized, so use the frame_free_noreserve() which does not
     302                 * manipulate the reserve or it would be given back twice.
     303                 */
     304                frame_free_noreserve(frame);
     305        }
    258306}
    259307

  • kernel/generic/src/mm/backend_elf.c

    r5d230a30 r69146b93  
    5858static void elf_destroy(as_area_t *);
    5959
     60static bool elf_is_resizable(as_area_t *);
     61static bool elf_is_shareable(as_area_t *);
     62
    6063static int elf_page_fault(as_area_t *, uintptr_t, pf_access_t);
    6164static void elf_frame_free(as_area_t *, uintptr_t, uintptr_t);
    … …  
    6669        .share = elf_share,
    6770        .destroy = elf_destroy,
     71
     72        .is_resizable = elf_is_resizable,
     73        .is_shareable = elf_is_shareable,
    6874
    6975        .page_fault = elf_page_fault,
    … …  
    213219}
    214220
     221bool elf_is_resizable(as_area_t *area)
     222{
     223        return true;
     224}
     225
     226bool elf_is_shareable(as_area_t *area)
     227{
     228        return true;
     229}
     230
     231
    215232/** Service a page fault in the ELF backend address space area.
    216233 *

  • kernel/generic/src/mm/backend_phys.c

    r5d230a30 r69146b93  
    5252static void phys_destroy(as_area_t *);
    5353
     54static bool phys_is_resizable(as_area_t *);
     55static bool phys_is_shareable(as_area_t *);
     56
     57
    5458static int phys_page_fault(as_area_t *, uintptr_t, pf_access_t);
    5559
    … …  
    5963        .share = phys_share,
    6064        .destroy = phys_destroy,
     65
     66        .is_resizable = phys_is_resizable,
     67        .is_shareable = phys_is_shareable,
    6168
    6269        .page_fault = phys_page_fault,
    … …  
    8794        /* Nothing to do. */
    8895}
     96
     97bool phys_is_resizable(as_area_t *area)
     98{
     99        return false;
     100}
     101
     102bool phys_is_shareable(as_area_t *area)
     103{
     104        return true;
     105}
     106
    89107
    90108/** Service a page fault in the address space area backed by physical memory.

  • kernel/generic/src/mm/km.c

    r5d230a30 r69146b93  
    234234 * @param[inout] framep Pointer to a variable which will receive the physical
    235235 *                      address of the allocated frame.
    236  * @param[in] flags     Frame allocation flags. FRAME_NONE or FRAME_NO_RESERVE.
     236 * @param[in] flags     Frame allocation flags. FRAME_NONE, FRAME_NO_RESERVE
     237 *                      and FRAME_ATOMIC bits are allowed.
    237238 * @return              Virtual address of the allocated frame.
    238239 */
    … …  
    244245        ASSERT(THREAD);
    245246        ASSERT(framep);
    246         ASSERT(!(flags & ~FRAME_NO_RESERVE));
     247        ASSERT(!(flags & ~(FRAME_NO_RESERVE | FRAME_ATOMIC)));
    247248
    248249        /*
    … …  
    256257                ASSERT(page);   // FIXME
    257258        } else {
    258                 frame = (uintptr_t) frame_alloc_noreserve(ONE_FRAME,
    259                     FRAME_LOWMEM);
     259                frame = (uintptr_t) frame_alloc(ONE_FRAME,
     260                    FRAME_LOWMEM | flags);
     261                if (!frame)
     262                        return (uintptr_t) NULL;
    260263                page = PA2KA(frame);
    261264        }

  • kernel/generic/src/proc/program.c

    r5d230a30 r69146b93  
    7979         * Create the stack address space area.
    8080         */
    81         uintptr_t virt = USTACK_ADDRESS;
     81        uintptr_t virt = (uintptr_t) -1;
     82        uintptr_t bound = USER_ADDRESS_SPACE_END - (STACK_SIZE_USER - 1);
     83
     84        /* Adjust bound to create space for the desired guard page. */
     85        bound -= PAGE_SIZE;
     86
    8287        as_area_t *area = as_area_create(as,
    83             AS_AREA_READ | AS_AREA_WRITE | AS_AREA_CACHEABLE,
    84             STACK_SIZE, AS_AREA_ATTR_NONE, &anon_backend, NULL, &virt, 0);
     88            AS_AREA_READ | AS_AREA_WRITE | AS_AREA_CACHEABLE | AS_AREA_GUARD |
     89            AS_AREA_LATE_RESERVE, STACK_SIZE_USER, AS_AREA_ATTR_NONE,
     90            &anon_backend, NULL, &virt, bound);
    8591        if (!area) {
    8692                task_destroy(prg->task);
    … …  
    9399        kernel_uarg->uspace_entry = (void *) entry_addr;
    94100        kernel_uarg->uspace_stack = (void *) virt;
    95         kernel_uarg->uspace_stack_size = STACK_SIZE;
     101        kernel_uarg->uspace_stack_size = STACK_SIZE_USER;
    96102        kernel_uarg->uspace_thread_function = NULL;
    97103        kernel_uarg->uspace_thread_arg = NULL;

  • kernel/generic/src/proc/task.c

    r5d230a30 r69146b93  
    196196        task->ucycles = 0;
    197197        task->kcycles = 0;
    198        
     198
    199199        task->ipc_info.call_sent = 0;
    200200        task->ipc_info.call_received = 0;
Note: See TracChangeset for help on using the changeset viewer.