Changeset da1bafb in mainline for kernel/generic/src/ddi


Ignore:
Timestamp:
2010-05-24T18:57:31Z (16 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
0095368
Parents:
666f492
Message:

major code revision

  • replace spinlocks taken with interrupts disabled with irq_spinlocks
  • change spacing (not indendation) to be tab-size independent
  • use unsigned integer types where appropriate (especially bit flags)
  • visual separation
  • remove argument names in function prototypes
  • string changes
  • correct some formating directives
  • replace various cryptic single-character variables (t, a, m, c, b, etc.) with proper identifiers (thread, task, timeout, as, itm, itc, etc.)
  • unify some assembler constructs
  • unused page table levels are now optimized out in compile time
  • replace several ints (with boolean semantics) with bools
  • use specifically sized types instead of generic types where appropriate (size_t, uint32_t, btree_key_t)
  • improve comments
  • split asserts with conjuction into multiple independent asserts
Location:
kernel/generic/src/ddi
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • kernel/generic/src/ddi/ddi.c

    r666f492 rda1bafb  
    5959static btree_t parea_btree;
    6060
    61 /** Initialize DDI. */
     61/** Initialize DDI.
     62 *
     63 */
    6264void ddi_init(void)
    6365{
    … …  
    9799 *
    98100 */
    99 static int ddi_physmem_map(uintptr_t pf, uintptr_t vp, size_t pages, int flags)
     101static int ddi_physmem_map(uintptr_t pf, uintptr_t vp, size_t pages,
     102    unsigned int flags)
    100103{
    101104        ASSERT(TASK);
    … …  
    114117        backend_data.frames = pages;
    115118       
    116         ipl_t ipl = interrupts_disable();
    117        
    118119        /* Find the zone of the physical memory */
    119         spinlock_lock(&zones.lock);
     120        irq_spinlock_lock(&zones.lock, true);
    120121        size_t znum = find_zone(ADDR2PFN(pf), pages, 0);
    121122       
    … …  
    124125                 * -> assume it is hardware device and allow mapping
    125126                 */
    126                 spinlock_unlock(&zones.lock);
     127                irq_spinlock_unlock(&zones.lock, true);
    127128                goto map;
    128129        }
    … …  
    130131        if (zones.info[znum].flags & ZONE_FIRMWARE) {
    131132                /* Frames are part of firmware */
    132                 spinlock_unlock(&zones.lock);
     133                irq_spinlock_unlock(&zones.lock, true);
    133134                goto map;
    134135        }
    135136       
    136137        if (zone_flags_available(zones.info[znum].flags)) {
    137                 /* Frames are part of physical memory, check if the memory
     138                /*
     139                 * Frames are part of physical memory, check if the memory
    138140                 * region is enabled for mapping.
    139141                 */
    140                 spinlock_unlock(&zones.lock);
     142                irq_spinlock_unlock(&zones.lock, true);
    141143               
    142144                mutex_lock(&parea_lock);
    … …  
    154156        }
    155157       
    156         spinlock_unlock(&zones.lock);
     158        irq_spinlock_unlock(&zones.lock, true);
     159       
    157160err:
    158         interrupts_restore(ipl);
    159161        return ENOENT;
    160162       
    161163map:
    162         interrupts_restore(ipl);
    163 
    164164        if (!as_area_create(TASK->as, flags, pages * PAGE_SIZE, vp,
    165165            AS_AREA_ATTR_NONE, &phys_backend, &backend_data)) {
    … …  
    196196                return EPERM;
    197197       
    198         ipl_t ipl = interrupts_disable();
    199         spinlock_lock(&tasks_lock);
     198        irq_spinlock_lock(&tasks_lock, true);
    200199       
    201200        task_t *task = task_find_by_id(id);
    … …  
    207206                 * context.
    208207                 */
    209                 spinlock_unlock(&tasks_lock);
    210                 interrupts_restore(ipl);
     208                irq_spinlock_unlock(&tasks_lock, true);
    211209                return ENOENT;
    212210        }
    213211       
    214212        /* Lock the task and release the lock protecting tasks_btree. */
    215         spinlock_lock(&task->lock);
    216         spinlock_unlock(&tasks_lock);
     213        irq_spinlock_exchange(&tasks_lock, &task->lock);
    217214       
    218215        int rc = ddi_iospace_enable_arch(task, ioaddr, size);
    219216       
    220         spinlock_unlock(&task->lock);
    221         interrupts_restore(ipl);
     217        irq_spinlock_unlock(&task->lock, true);
    222218       
    223219        return rc;

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

    r666f492 rda1bafb  
    3232/**
    3333 * @file
    34  * @brief       IRQ dispatcher.
     34 * @brief IRQ dispatcher.
    3535 *
    3636 * This file provides means of connecting IRQs with particular
    … …  
    7878#include <arch.h>
    7979
    80 #define KEY_INR         0
    81 #define KEY_DEVNO       1
    82 
    83 /**
    84  * Spinlock protecting the kernel IRQ hash table.
     80#define KEY_INR    0
     81#define KEY_DEVNO  1
     82
     83/** Spinlock protecting the kernel IRQ hash table.
     84 *
    8585 * This lock must be taken only when interrupts are disabled.
    86  */
    87 SPINLOCK_INITIALIZE(irq_kernel_hash_table_lock);
     86 *
     87 */
     88IRQ_SPINLOCK_STATIC_INITIALIZE(irq_kernel_hash_table_lock);
     89
    8890/** The kernel IRQ hash table. */
    8991static hash_table_t irq_kernel_hash_table;
    9092
    91 /**
    92  * Spinlock protecting the uspace IRQ hash table.
     93/** Spinlock protecting the uspace IRQ hash table.
     94 *
    9395 * This lock must be taken only when interrupts are disabled.
    94  */
    95 SPINLOCK_INITIALIZE(irq_uspace_hash_table_lock);
     96 *
     97 */
     98IRQ_SPINLOCK_INITIALIZE(irq_uspace_hash_table_lock);
     99
    96100/** The uspace IRQ hash table. */
    97101hash_table_t irq_uspace_hash_table;
    … …  
    100104 * Hash table operations for cases when we know that
    101105 * there will be collisions between different keys.
     106 *
    102107 */
    103108static size_t irq_ht_hash(unative_t *key);
    … …  
    116121 * However, there might be still collisions among
    117122 * elements with single key (sharing of one IRQ).
     123 *
    118124 */
    119125static size_t irq_lin_hash(unative_t *key);
    … …  
    132138/** Initialize IRQ subsystem.
    133139 *
    134  * @param inrs Numbers of unique IRQ numbers or INRs.
     140 * @param inrs   Numbers of unique IRQ numbers or INRs.
    135141 * @param chains Number of chains in the hash table.
     142 *
    136143 */
    137144void irq_init(size_t inrs, size_t chains)
    … …  
    166173        memsetb(irq, sizeof(irq_t), 0);
    167174        link_initialize(&irq->link);
    168         spinlock_initialize(&irq->lock, "irq.lock");
     175        irq_spinlock_initialize(&irq->lock, "irq.lock");
    169176        link_initialize(&irq->notif_cfg.link);
    170177        irq->inr = -1;
    171178        irq->devno = -1;
    172 
     179       
    173180        irq_initialize_arch(irq);
    174181}
    … …  
    180187 * function pointer and handler() function pointer.
    181188 *
    182  * @param irq           IRQ structure belonging to a device.
    183  * @return              True on success, false on failure.
     189 * @param irq IRQ structure belonging to a device.
     190 *
     191 * @return True on success, false on failure.
     192 *
    184193 */
    185194void irq_register(irq_t *irq)
    186195{
    187         ipl_t ipl;
    188196        unative_t key[] = {
    189197                (unative_t) irq->inr,
    … …  
    191199        };
    192200       
    193         ipl = interrupts_disable();
    194         spinlock_lock(&irq_kernel_hash_table_lock);
    195         spinlock_lock(&irq->lock);
     201        irq_spinlock_lock(&irq_kernel_hash_table_lock, true);
     202        irq_spinlock_lock(&irq->lock, false);
    196203        hash_table_insert(&irq_kernel_hash_table, key, &irq->link);
    197         spinlock_unlock(&irq->lock);   
    198         spinlock_unlock(&irq_kernel_hash_table_lock);
    199         interrupts_restore(ipl);
     204        irq_spinlock_unlock(&irq->lock, false);
     205        irq_spinlock_unlock(&irq_kernel_hash_table_lock, true);
    200206}
    201207
    … …  
    208214        unative_t key[] = {
    209215                (unative_t) inr,
    210                 (unative_t) -1    /* search will use claim() instead of devno */
     216                (unative_t) -1    /* Search will use claim() instead of devno */
    211217        };
    212218       
    213         spinlock_lock(&irq_uspace_hash_table_lock);
     219        irq_spinlock_lock(&irq_uspace_hash_table_lock, false);
    214220        lnk = hash_table_find(&irq_uspace_hash_table, key);
    215221        if (lnk) {
    216                 irq_t *irq;
    217                
    218                 irq = hash_table_get_instance(lnk, irq_t, link);
    219                 spinlock_unlock(&irq_uspace_hash_table_lock);
     222                irq_t *irq = hash_table_get_instance(lnk, irq_t, link);
     223                irq_spinlock_unlock(&irq_uspace_hash_table_lock, false);
    220224                return irq;
    221225        }
    222         spinlock_unlock(&irq_uspace_hash_table_lock);
     226        irq_spinlock_unlock(&irq_uspace_hash_table_lock, false);
    223227       
    224228        return NULL;
    … …  
    233237        unative_t key[] = {
    234238                (unative_t) inr,
    235                 (unative_t) -1    /* search will use claim() instead of devno */
     239                (unative_t) -1    /* Search will use claim() instead of devno */
    236240        };
    237241       
    238         spinlock_lock(&irq_kernel_hash_table_lock);
     242        irq_spinlock_lock(&irq_kernel_hash_table_lock, false);
    239243        lnk = hash_table_find(&irq_kernel_hash_table, key);
    240244        if (lnk) {
    241                 irq_t *irq;
    242                
    243                 irq = hash_table_get_instance(lnk, irq_t, link);
    244                 spinlock_unlock(&irq_kernel_hash_table_lock);
     245                irq_t *irq = hash_table_get_instance(lnk, irq_t, link);
     246                irq_spinlock_unlock(&irq_kernel_hash_table_lock, false);
    245247                return irq;
    246248        }
    247         spinlock_unlock(&irq_kernel_hash_table_lock);
     249        irq_spinlock_unlock(&irq_kernel_hash_table_lock, false);
    248250       
    249251        return NULL;
    … …  
    263265 *
    264266 * @return IRQ structure of the respective device or NULL.
     267 *
    265268 */
    266269irq_t *irq_dispatch_and_lock(inr_t inr)
    267270{
    268         irq_t *irq;
    269        
    270271        /*
    271272         * If the kernel console is silenced,
    … …  
    277278         */
    278279        if (silent) {
    279                 irq = irq_dispatch_and_lock_uspace(inr);
     280                irq_t *irq = irq_dispatch_and_lock_uspace(inr);
    280281                if (irq)
    281282                        return irq;
     283               
    282284                return irq_dispatch_and_lock_kernel(inr);
    283285        }
    284286       
    285         irq = irq_dispatch_and_lock_kernel(inr);
     287        irq_t *irq = irq_dispatch_and_lock_kernel(inr);
    286288        if (irq)
    287289                return irq;
     290       
    288291        return irq_dispatch_and_lock_uspace(inr);
    289292}
    … …  
    301304 *
    302305 * @return Index into the hash table.
     306 *
    303307 */
    304308size_t irq_ht_hash(unative_t key[])
    … …  
    322326 * This function assumes interrupts are already disabled.
    323327 *
    324  * @param key Keys (i.e. inr and devno).
     328 * @param key  Keys (i.e. inr and devno).
    325329 * @param keys This is 2.
    326330 * @param item The item to compare the key with.
    327331 *
    328332 * @return True on match or false otherwise.
     333 *
    329334 */
    330335bool irq_ht_compare(unative_t key[], size_t keys, link_t *item)
    … …  
    333338        inr_t inr = (inr_t) key[KEY_INR];
    334339        devno_t devno = (devno_t) key[KEY_DEVNO];
    335 
     340       
    336341        bool rv;
    337342       
    338         spinlock_lock(&irq->lock);
     343        irq_spinlock_lock(&irq->lock, false);
    339344        if (devno == -1) {
    340345                /* Invoked by irq_dispatch_and_lock(). */
    … …  
    348353        /* unlock only on non-match */
    349354        if (!rv)
    350                 spinlock_unlock(&irq->lock);
    351 
     355                irq_spinlock_unlock(&irq->lock, false);
     356       
    352357        return rv;
    353358}
    … …  
    361366        irq_t *irq __attribute__((unused))
    362367            = hash_table_get_instance(lnk, irq_t, link);
    363         spinlock_unlock(&irq->lock);
     368        irq_spinlock_unlock(&irq->lock, false);
    364369}
    365370
    … …  
    374379 *
    375380 * @return Index into the hash table.
     381 *
    376382 */
    377383size_t irq_lin_hash(unative_t key[])
    … …  
    395401 * This function assumes interrupts are already disabled.
    396402 *
    397  * @param key Keys (i.e. inr and devno).
     403 * @param key  Keys (i.e. inr and devno).
    398404 * @param keys This is 2.
    399405 * @param item The item to compare the key with.
    400406 *
    401407 * @return True on match or false otherwise.
     408 *
    402409 */
    403410bool irq_lin_compare(unative_t key[], size_t keys, link_t *item)
    … …  
    407414        bool rv;
    408415       
    409         spinlock_lock(&irq->lock);
     416        irq_spinlock_lock(&irq->lock, false);
    410417        if (devno == -1) {
    411418                /* Invoked by irq_dispatch_and_lock() */
    … …  
    418425        /* unlock only on non-match */
    419426        if (!rv)
    420                 spinlock_unlock(&irq->lock);
     427                irq_spinlock_unlock(&irq->lock, false);
    421428       
    422429        return rv;
    … …  
    425432/** Unlock IRQ structure after hash_table_remove().
    426433 *
    427  * @param lnk           Link in the removed and locked IRQ structure.
     434 * @param lnk Link in the removed and locked IRQ structure.
     435 *
    428436 */
    429437void irq_lin_remove(link_t *lnk)
    … …  
    431439        irq_t *irq __attribute__((unused))
    432440            = hash_table_get_instance(lnk, irq_t, link);
    433         spinlock_unlock(&irq->lock);
     441        irq_spinlock_unlock(&irq->lock, false);
    434442}
    435443
Note: See TracChangeset for help on using the changeset viewer.