Fork us on GitHub Follow us on Facebook Follow us on Twitter

Changeset e3306d04 in mainline


Ignore:
Timestamp:
2018-09-07T15:54:32Z (4 years ago)
Author:
Jiří Zárevúcky <jiri.zarevucky@…>
Branches:
lfn, master, serial
Children:
5f1d850
Parents:
036e97c
Message:

Convert atomic_t to atomic_size_t (4): Use atomic_store instead of atomic_set

Location:
kernel
Files:
19 edited

Legend:

Unmodified
Added
Removed
  • kernel/arch/mips32/src/debugger.c

    r036e97c re3306d04  
    412412                 *   so this is a good idea
    413413                 */
    414                 atomic_set(&haltstate, 1);
     414                atomic_store(&haltstate, 1);
    415415                irq_spinlock_unlock(&bkpoint_lock, false);
    416416
     
    418418
    419419                irq_spinlock_lock(&bkpoint_lock, false);
    420                 atomic_set(&haltstate, 0);
     420                atomic_store(&haltstate, 0);
    421421#endif
    422422        }
  • kernel/arch/sparc64/src/smp/sun4v/smp.c

    r036e97c re3306d04  
    230230                                exec_units[i].exec_unit_id = exec_unit_id;
    231231                                exec_units[i].strand_count = 0;
    232                                 atomic_set(&(exec_units[i].nrdy), 0);
     232                                atomic_store(&(exec_units[i].nrdy), 0);
    233233                                spinlock_initialize(&(exec_units[i].proposed_nrdy_lock), "exec_units[].proposed_nrdy_lock");
    234234                                exec_unit_count++;
     
    270270                exec_units[0].exec_unit_id = 1;
    271271                spinlock_initialize(&(exec_units[0].proposed_nrdy_lock), "exec_units[0].proposed_nrdy_lock");
    272                 atomic_set(&(exec_units[0].nrdy), 0);
     272                atomic_store(&(exec_units[0].nrdy), 0);
    273273                max_core_strands = cpu_count;
    274274
  • kernel/generic/include/atomic.h

    r036e97c re3306d04  
    4444typedef atomic_size_t atomic_t;
    4545
    46 static inline void atomic_set(atomic_t *val, atomic_count_t i)
    47 {
    48         atomic_store(val, i);
    49 }
    50 
    5146static inline size_t atomic_predec(atomic_t *val)
    5247{
  • kernel/generic/src/adt/cht.c

    r036e97c re3306d04  
    537537        h->new_b = NULL;
    538538        h->op = op;
    539         atomic_set(&h->item_cnt, 0);
    540         atomic_set(&h->resize_reqs, 0);
     539        atomic_store(&h->item_cnt, 0);
     540        atomic_store(&h->resize_reqs, 0);
    541541
    542542        if (NULL == op->remove_callback) {
  • kernel/generic/src/cap/cap.c

    r036e97c re3306d04  
    353353    kobject_ops_t *ops)
    354354{
    355         atomic_set(&kobj->refcnt, 1);
     355        atomic_store(&kobj->refcnt, 1);
    356356        kobj->type = type;
    357357        kobj->raw = raw;
  • kernel/generic/src/console/console.c

    r036e97c re3306d04  
    202202
    203203        event_set_unmask_callback(EVENT_KIO, kio_update);
    204         atomic_set(&kio_inited, true);
     204        atomic_store(&kio_inited, true);
    205205}
    206206
  • kernel/generic/src/ipc/ipc.c

    r036e97c re3306d04  
    154154        list_initialize(&box->answers);
    155155        list_initialize(&box->irq_notifs);
    156         atomic_set(&box->active_calls, 0);
     156        atomic_store(&box->active_calls, 0);
    157157        box->task = task;
    158158}
     
    204204        phone->callee = NULL;
    205205        phone->state = IPC_PHONE_FREE;
    206         atomic_set(&phone->active_calls, 0);
     206        atomic_store(&phone->active_calls, 0);
    207207        phone->kobject = NULL;
    208208}
  • kernel/generic/src/lib/halt.c

    r036e97c re3306d04  
    5757
    5858        if (!atomic_load(&haltstate)) {
    59                 atomic_set(&haltstate, 1);
     59                atomic_store(&haltstate, 1);
    6060                rundebugger = true;
    6161        }
    6262#else
    63         atomic_set(&haltstate, 1);
     63        atomic_store(&haltstate, 1);
    6464#endif
    6565
  • kernel/generic/src/log/log.c

    r036e97c re3306d04  
    9494{
    9595        event_set_unmask_callback(EVENT_KLOG, log_update);
    96         atomic_set(&log_inited, true);
     96        atomic_store(&log_inited, true);
    9797}
    9898
  • kernel/generic/src/proc/task.c

    r036e97c re3306d04  
    166166                return rc;
    167167
    168         atomic_set(&task->refcount, 0);
    169         atomic_set(&task->lifecount, 0);
     168        atomic_store(&task->refcount, 0);
     169        atomic_store(&task->lifecount, 0);
    170170
    171171        irq_spinlock_initialize(&task->lock, "task_t_lock");
  • kernel/generic/src/proc/thread.c

    r036e97c re3306d04  
    240240        THREAD = NULL;
    241241
    242         atomic_set(&nrdy, 0);
     242        atomic_store(&nrdy, 0);
    243243        thread_cache = slab_cache_create("thread_t", sizeof(thread_t), 0,
    244244            thr_constructor, thr_destructor, 0);
  • kernel/generic/src/smp/smp_call.c

    r036e97c re3306d04  
    246246         * messing up the preemption count).
    247247         */
    248         atomic_set(&call_info->pending, 1);
     248        atomic_store(&call_info->pending, 1);
    249249
    250250        /* Let initialization complete before continuing. */
     
    259259         */
    260260        memory_barrier();
    261         atomic_set(&call_info->pending, 0);
     261        atomic_store(&call_info->pending, 0);
    262262}
    263263
  • kernel/generic/src/synch/rcu.c

    r036e97c re3306d04  
    312312
    313313        mutex_initialize(&rcu.barrier_mtx, MUTEX_PASSIVE);
    314         atomic_set(&rcu.barrier_wait_cnt, 0);
     314        atomic_store(&rcu.barrier_wait_cnt, 0);
    315315        waitq_initialize(&rcu.barrier_wq);
    316316
     
    322322        rcu.req_gp_end_cnt = 0;
    323323        rcu.req_expedited_cnt = 0;
    324         atomic_set(&rcu.delaying_cpu_cnt, 0);
     324        atomic_store(&rcu.delaying_cpu_cnt, 0);
    325325#endif
    326326
     
    594594         * enqueued barrier callbacks start signaling completion.
    595595         */
    596         atomic_set(&rcu.barrier_wait_cnt, 1);
     596        atomic_store(&rcu.barrier_wait_cnt, 1);
    597597
    598598        DEFINE_CPU_MASK(cpu_mask);
     
    14121412static void interrupt_delaying_cpus(cpu_mask_t *cpu_mask)
    14131413{
    1414         atomic_set(&rcu.delaying_cpu_cnt, 0);
     1414        atomic_store(&rcu.delaying_cpu_cnt, 0);
    14151415
    14161416        sample_cpus(cpu_mask, NULL);
  • kernel/test/atomic/atomic1.c

    r036e97c re3306d04  
    3636        atomic_t a;
    3737
    38         atomic_set(&a, 10);
     38        atomic_store(&a, 10);
    3939        if (atomic_load(&a) != 10)
    40                 return "Failed atomic_set()/atomic_load()";
     40                return "Failed atomic_store()/atomic_load()";
    4141
    4242        if (atomic_postinc(&a) != 10)
  • kernel/test/mm/falloc2.c

    r036e97c re3306d04  
    117117const char *test_falloc2(void)
    118118{
    119         atomic_set(&thread_count, THREADS);
    120         atomic_set(&thread_fail, 0);
     119        atomic_store(&thread_count, THREADS);
     120        atomic_store(&thread_fail, 0);
    121121
    122122        for (unsigned int i = 0; i < THREADS; i++) {
  • kernel/test/synch/rcu1.c

    r036e97c re3306d04  
    268268static bool do_nop_callbacks(void)
    269269{
    270         atomic_set(&nop_callbacks_cnt, 0);
     270        atomic_store(&nop_callbacks_cnt, 0);
    271271
    272272        size_t exp_cnt = nop_updater_iters * get_thread_cnt();
     
    448448        seq_test_result = EOK;
    449449        max_upd_done_time = 0;
    450         atomic_set(&cur_time, 1);
     450        atomic_store(&cur_time, 1);
    451451
    452452        const size_t iters = 100;
     
    821821{
    822822        barrier_t *b = member_to_inst(item, barrier_t, rcu_item);
    823         atomic_set(&b->done, 1);
     823        atomic_store(&b->done, 1);
    824824}
    825825
     
    835835        }
    836836
    837         atomic_set(&barrier->done, 0);
     837        atomic_store(&barrier->done, 0);
    838838
    839839        rcu_call(&barrier->rcu_item, barrier_callback);
  • kernel/test/synch/semaphore1.c

    r036e97c re3306d04  
    8282                thread_t *thrd;
    8383
    84                 atomic_set(&items_produced, 0);
    85                 atomic_set(&items_consumed, 0);
     84                atomic_store(&items_produced, 0);
     85                atomic_store(&items_consumed, 0);
    8686
    8787                consumers = i * CONSUMERS;
  • kernel/test/synch/workq-test-core.h

    r036e97c re3306d04  
    149149{
    150150        for (int i = 0; i < WAVES; ++i) {
    151                 atomic_set(&call_cnt[i], 0);
     151                atomic_store(&call_cnt[i], 0);
    152152        }
    153153
  • kernel/test/thread/thread1.c

    r036e97c re3306d04  
    5858        atomic_count_t total = 0;
    5959
    60         atomic_set(&finish, 1);
    61         atomic_set(&threads_finished, 0);
     60        atomic_store(&finish, 1);
     61        atomic_store(&threads_finished, 0);
    6262
    6363        for (i = 0; i < THREADS; i++) {
     
    7575        thread_sleep(10);
    7676
    77         atomic_set(&finish, 0);
     77        atomic_store(&finish, 0);
    7878        while (atomic_load(&threads_finished) < total) {
    7979                TPRINTF("Threads left: %zu\n", total - atomic_load(&threads_finished));
Note: See TracChangeset for help on using the changeset viewer.