Changes in / [3df2907:09c954b] in mainline


Ignore:
Files:
10 edited

Legend:

Unmodified
Added
Removed

  • boot/arch/ia64/src/pal_asm.S

    r3df2907 r09c954b  
    3232
    3333pal_static_call:
    34         alloc loc0 = ar.pfs, 7, 6, 0, 0
    35 
    36         mov loc1 = psr ;;
    37         mov psr.l = r0 ;;
    38         srlz.i
    39         srlz.d
     34        alloc loc0 = ar.pfs, 7, 5, 0, 0
    4035       
    41         mov loc2 = gp
    42         mov loc3 = rp
     36        mov loc1 = gp
     37        mov loc2 = rp
    4338       
    44         addl loc4 = @gprel(pal_proc), gp
    45 
     39        addl loc3 = @gprel(pal_proc), gp
     40       
    4641        mov r28 = in0
    4742        mov r29 = in1
    … …  
    4944        mov r31 = in3 ;;
    5045       
    51         ld8 loc4 = [loc4]
    52         movl loc5 = 0f ;;
     46        ld8 loc3 = [loc3]
     47        movl loc4 = 0f ;;
    5348
    54         mov b6 = loc4
    55         mov rp = loc5 ;;
     49        mov b6 = loc3
     50        mov rp = loc4 ;;
    5651        br.cond.sptk.many b6
    5752
    58530:
    59         mov psr.l = loc1 ;;
    60         srlz.i
    61         srlz.d
    62 
    6354        cmp.ne p7,p0 = 0, in4
    6455        cmp.ne p8,p0 = 0, in5
    … …  
    6960(p9)    st8 [in6] = r11
    7061       
    71         mov gp = loc2
    72         mov rp = loc3 ;;
     62        mov gp = loc1
     63        mov rp = loc2 ;;
    7364       
    7465        mov ar.pfs = loc0

  • boot/arch/ia64/src/sal_asm.S

    r3df2907 r09c954b  
    2929.explicit
    3030
    31 #define STACK_SCRATCH_AREA      16
    32 #define STACK_IN8               (0 + STACK_SCRATCH_AREA)
    33 #define STACK_IN9               (8 + STACK_SCRATCH_AREA)
    34 #define STACK_IN10              (16 + STACK_SCRATCH_AREA)
    35 
    3631.global sal_call
    3732
    … …  
    4439#
    4540sal_call:
    46         alloc loc0 = ar.pfs, 8, 8, 8, 0
     41        alloc loc0 = ar.pfs, 11, 5, 8, 0
    4742       
    48         adds sp = -STACK_SCRATCH_AREA, sp
    49 
    5043        mov loc1 = gp
    5144        mov loc2 = rp
    … …  
    6457       
    6558        ld8 loc3 = [loc3]
    66         ld8 gp = [loc4]
    67 
    68         adds r14 = STACK_IN8 + STACK_SCRATCH_AREA, sp
    69         adds r15 = STACK_IN9 + STACK_SCRATCH_AREA, sp
    70         adds r16 = STACK_IN10 + STACK_SCRATCH_AREA, sp ;;
    71 
    72         ld8 loc5 = [r14]
    73         ld8 loc6 = [r15]
    74         ld8 loc7 = [r16]
     59        ld8 gp = [loc4] ;;
    7560       
    7661        mov b6 = loc3 ;;
    7762        br.call.sptk.many rp = b6
    7863       
    79         cmp.ne p7,p0 = 0, loc5
    80         cmp.ne p8,p0 = 0, loc6
    81         cmp.ne p9,p0 = 0, loc7 ;;
     64        cmp.ne p7,p0 = 0, in8
     65        cmp.ne p8,p0 = 0, in9
     66        cmp.ne p9,p0 = 0, in10 ;;
    8267       
    83 (p7)    st8 [loc5] = r9
    84 (p8)    st8 [loc6] = r10
    85 (p9)    st8 [loc7] = r11
     68(p7)    st8 [in8] = r9
     69(p8)    st8 [in9] = r10
     70(p9)    st8 [in10] = r11
    8671       
    8772        mov gp = loc1
    88         mov rp = loc2
    89 
    90         adds sp = STACK_SCRATCH_AREA, sp ;;
     73        mov rp = loc2 ;;
    9174       
    9275        mov ar.pfs = loc0
    9376        br.ret.sptk.many rp
    94 

  • kernel/arch/ia64/include/asm.h

    r3df2907 r09c954b  
    6161        asm volatile (
    6262                "mf\n"
    63                 "mf.a\n"
    6463                ::: "memory"
    6564        );
    … …  
    7574        asm volatile (
    7675                "mf\n"
    77                 "mf.a\n"
    7876                ::: "memory"
    7977        );
    … …  
    8987        asm volatile (
    9088                "mf\n"
    91                 "mf.a\n"
    9289                ::: "memory"
    9390        );
    … …  
    107104        else
    108105                v = *port;
    109 
    110         asm volatile (
    111                 "mf.a\n"
    112                 ::: "memory"
    113         );
    114106       
    115107        return v;
    … …  
    129121        else
    130122                v = *port;
    131 
    132         asm volatile (
    133                 "mf.a\n"
    134                 ::: "memory"
    135         );
    136123       
    137124        return v;
    … …  
    151138        else
    152139                v = *port;
    153 
    154         asm volatile (
    155                 "mf.a\n"
    156                 ::: "memory"
    157         );
    158140
    159141        return v;

  • kernel/arch/ia64/src/ia64.c

    r3df2907 r09c954b  
    144144#endif
    145145#ifdef MACHINE_i460GX
    146         platform = "pc";
     146        platform = "i460GX";
    147147#endif
    148148        sysinfo_set_item_data("platform", NULL, (void *) platform,

  • kernel/generic/src/ipc/irq.c

    r3df2907 r09c954b  
    358358        ASSERT(irq->notif_cfg.answerbox == box);
    359359       
     360        /* Free up the pseudo code and associated structures. */
     361        code_free(irq->notif_cfg.code);
     362       
    360363        /* Remove the IRQ from the answerbox's list. */
    361364        list_remove(&irq->notif_cfg.link);
    … …  
    375378        irq_spinlock_unlock(&box->irq_lock, false);
    376379        irq_spinlock_unlock(&irq_uspace_hash_table_lock, true);
    377        
    378         /* Free up the pseudo code and associated structures. */
    379         code_free(irq->notif_cfg.code);
    380380       
    381381        /* Free up the IRQ structure. */
    … …  
    425425                list_remove(&irq->notif_cfg.link);
    426426               
     427                /* Free up the pseudo code and associated structures. */
     428                code_free(irq->notif_cfg.code);
     429               
    427430                /*
    428431                 * We need to drop the IRQ lock now because hash_table_remove()
    … …  
    436439                /* Remove from the hash table. */
    437440                hash_table_remove(&irq_uspace_hash_table, key, 2);
    438 
    439                 /*
    440                  * Release both locks so that we can free the pseudo code.
    441                  */
    442                 irq_spinlock_unlock(&box->irq_lock, false);
    443                 irq_spinlock_unlock(&irq_uspace_hash_table_lock, true);
    444 
    445                 code_free(irq->notif_cfg.code);
     441               
    446442                free(irq);
    447                
    448                 /* Reacquire both locks before taking another round. */
    449                 irq_spinlock_lock(&irq_uspace_hash_table_lock, true);
    450                 irq_spinlock_lock(&box->irq_lock, false);
    451443        }
    452444       

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

    r3df2907 r09c954b  
    168168int page_find_mapping(uintptr_t virt, void **phys)
    169169{
    170         page_table_lock(AS, true);
     170        mutex_lock(&AS->lock);
    171171       
    172172        pte_t *pte = page_mapping_find(AS, virt, false);
    173173        if ((!PTE_VALID(pte)) || (!PTE_PRESENT(pte))) {
    174                 page_table_unlock(AS, true);
     174                mutex_unlock(&AS->lock);
    175175                return ENOENT;
    176176        }
    … …  
    179179            (virt - ALIGN_DOWN(virt, PAGE_SIZE));
    180180       
    181         page_table_unlock(AS, true);
     181        mutex_unlock(&AS->lock);
    182182       
    183183        return EOK;

  • uspace/drv/bus/usb/uhci/transfer_list.c

    r3df2907 r09c954b  
    110110        assert(instance);
    111111        assert(uhci_batch);
    112         usb_log_debug2("Batch %p adding to queue %s.\n",
    113             uhci_batch->usb_batch, instance->name);
     112        usb_log_debug2("Queue %s: Adding batch(%p).\n", instance->name,
     113            uhci_batch->usb_batch);
    114114
    115115        fibril_mutex_lock(&instance->guard);
    … …  
    139139        list_append(&uhci_batch->link, &instance->batch_list);
    140140
    141         usb_log_debug2("Batch %p " USB_TRANSFER_BATCH_FMT
    142             " scheduled in queue %s.\n", uhci_batch->usb_batch,
    143             USB_TRANSFER_BATCH_ARGS(*uhci_batch->usb_batch), instance->name);
     141        usb_log_debug2("Batch %p " USB_TRANSFER_BATCH_FMT " scheduled in queue %s.\n",
     142            uhci_batch, USB_TRANSFER_BATCH_ARGS(*uhci_batch->usb_batch),
     143            instance->name);
    144144        fibril_mutex_unlock(&instance->guard);
    145145}
    … …  
    205205        assert(fibril_mutex_is_locked(&instance->guard));
    206206
    207         usb_log_debug2("Batch %p removing from queue %s.\n",
    208             uhci_batch->usb_batch, instance->name);
     207        usb_log_debug2("Queue %s: removing batch(%p).\n",
     208            instance->name, uhci_batch->usb_batch);
    209209
    210210        /* Assume I'm the first */
    … …  
    228228        list_remove(&uhci_batch->link);
    229229        usb_log_debug2("Batch %p " USB_TRANSFER_BATCH_FMT " removed (%s) "
    230             "from %s, next: %x.\n", uhci_batch->usb_batch,
    231             USB_TRANSFER_BATCH_ARGS(*uhci_batch->usb_batch),
     230            "from %s, next: %x.\n",
     231            uhci_batch, USB_TRANSFER_BATCH_ARGS(*uhci_batch->usb_batch),
    232232            qpos, instance->name, uhci_batch->qh->next);
    233233}

  • uspace/drv/bus/usb/uhci/uhci_batch.c

    r3df2907 r09c954b  
    174174                        assert(uhci_batch->usb_batch->ep != NULL);
    175175
    176                         usb_log_debug("Batch %p found error TD(%zu->%p):%"
     176                        usb_log_debug("Batch(%p) found error TD(%zu):%"
    177177                            PRIx32 ".\n", uhci_batch->usb_batch, i,
    178                             &uhci_batch->tds[i], uhci_batch->tds[i].status);
     178                            uhci_batch->tds[i].status);
    179179                        td_print_status(&uhci_batch->tds[i]);
    180180

  • uspace/drv/infrastructure/root/root.c

    r3df2907 r09c954b  
    158158        if (asprintf(&match_id, PLATFORM_FUN_MATCH_ID_FMT, platform) == -1) {
    159159                ddf_msg(LVL_ERROR, "Memory allocation failed.");
    160                 free(platform);
    161                 return ENOMEM;
    162         }
    163 
    164         free(platform);
     160                return ENOMEM;
     161        }
    165162
    166163        /* Add function. */
    … …  
    172169        if (fun == NULL) {
    173170                ddf_msg(LVL_ERROR, "Error creating function %s", name);
    174                 free(match_id);
    175171                return ENOMEM;
    176172        }
    … …  
    180176                ddf_msg(LVL_ERROR, "Failed adding match IDs to function %s",
    181177                    name);
    182                 free(match_id);
    183178                ddf_fun_destroy(fun);
    184179                return rc;
    … …  
    213208         * vital for the system.
    214209         */
    215         (void) add_virtual_root_fun(dev);
     210        add_virtual_root_fun(dev);
    216211
    217212        /* Register root device's children. */

  • uspace/lib/c/arch/ia64/include/ddi.h

    r3df2907 r09c954b  
    6262
    6363        asm volatile ("mf\n" ::: "memory");
    64         asm volatile ("mf.a\n" ::: "memory");
    6564}
    6665
    … …  
    7776
    7877        asm volatile ("mf\n" ::: "memory");
    79         asm volatile ("mf.a\n" ::: "memory");
    8078}
    8179
    … …  
    9290
    9391        asm volatile ("mf\n" ::: "memory");
    94         asm volatile ("mf.a\n" ::: "memory");
    9592}
    9693
    … …  
    109106                v = *port;
    110107        }
    111 
    112         asm volatile ("mf.a\n" ::: "memory");
    113108
    114109        return v;
    … …  
    130125        }
    131126
    132         asm volatile ("mf.a\n" ::: "memory");
    133 
    134127        return v;
    135128}
    … …  
    141134        asm volatile ("mf\n" ::: "memory");
    142135
    143         if (port < (ioport32_t *) IO_SPACE_BOUNDARY) {
     136        if (port < (ioport32_t *) port) {
    144137                uintptr_t prt = (uintptr_t) port;
    145138
    … …  
    150143        }
    151144
    152         asm volatile ("mf.a\n" ::: "memory");
    153 
    154145        return v;
    155146}
Note: See TracChangeset for help on using the changeset viewer.