/* * Copyright (C) 2007-2010 Lawrence Livermore National Security, LLC. * Copyright (C) 2007 The Regents of the University of California. * Produced at Lawrence Livermore National Laboratory (cf, DISCLAIMER). * Written by Brian Behlendorf . * UCRL-CODE-235197 * * This file is part of the SPL, Solaris Porting Layer. * For details, see . * * The SPL is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License as published by the * Free Software Foundation; either version 2 of the License, or (at your * option) any later version. * * The SPL is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License * for more details. * * You should have received a copy of the GNU General Public License along * with the SPL. If not, see . ***************************************************************************** * Solaris Porting LAyer Tests (SPLAT) Atomic Tests. */ #include #include #include #include #include #include #include "splat-internal.h" #define SPLAT_ATOMIC_NAME "atomic" #define SPLAT_ATOMIC_DESC "Kernel Atomic Tests" #define SPLAT_ATOMIC_TEST1_ID 0x0b01 #define SPLAT_ATOMIC_TEST1_NAME "64-bit" #define SPLAT_ATOMIC_TEST1_DESC "Validate 64-bit atomic ops" #define SPLAT_ATOMIC_TEST_MAGIC 0x43435454UL #define SPLAT_ATOMIC_INIT_VALUE 10000000UL typedef enum { SPLAT_ATOMIC_INC_64 = 0, SPLAT_ATOMIC_DEC_64 = 1, SPLAT_ATOMIC_ADD_64 = 2, SPLAT_ATOMIC_SUB_64 = 3, SPLAT_ATOMIC_ADD_64_NV = 4, SPLAT_ATOMIC_SUB_64_NV = 5, SPLAT_ATOMIC_COUNT_64 = 6 } atomic_op_t; typedef struct atomic_priv { unsigned long ap_magic; struct file *ap_file; kmutex_t ap_lock; spl_wait_queue_head_t ap_waitq; volatile uint64_t ap_atomic; volatile uint64_t ap_atomic_exited; atomic_op_t ap_op; } atomic_priv_t; static void splat_atomic_work(void *priv) { atomic_priv_t *ap; atomic_op_t op; int i; ap = (atomic_priv_t *)priv; ASSERT(ap->ap_magic == SPLAT_ATOMIC_TEST_MAGIC); mutex_enter(&ap->ap_lock); op = ap->ap_op; wake_up(&ap->ap_waitq); mutex_exit(&ap->ap_lock); splat_vprint(ap->ap_file, SPLAT_ATOMIC_TEST1_NAME, "Thread %d successfully started: %lu/%lu\n", op, (long unsigned)ap->ap_atomic, (long unsigned)ap->ap_atomic_exited); for (i = 0; i < SPLAT_ATOMIC_INIT_VALUE / 10; i++) { /* Periodically sleep to mix up the ordering */ if ((i % (SPLAT_ATOMIC_INIT_VALUE / 100)) == 0) { splat_vprint(ap->ap_file, SPLAT_ATOMIC_TEST1_NAME, "Thread %d sleeping: %lu/%lu\n", op, (long unsigned)ap->ap_atomic, (long unsigned)ap->ap_atomic_exited); set_current_state(TASK_INTERRUPTIBLE); schedule_timeout(HZ / 100); } switch (op) { case SPLAT_ATOMIC_INC_64: atomic_inc_64(&ap->ap_atomic); break; case SPLAT_ATOMIC_DEC_64: atomic_dec_64(&ap->ap_atomic); break; case SPLAT_ATOMIC_ADD_64: atomic_add_64(&ap->ap_atomic, 3); break; case SPLAT_ATOMIC_SUB_64: atomic_sub_64(&ap->ap_atomic, 3); break; case SPLAT_ATOMIC_ADD_64_NV: atomic_add_64_nv(&ap->ap_atomic, 5); break; case SPLAT_ATOMIC_SUB_64_NV: atomic_sub_64_nv(&ap->ap_atomic, 5); break; default: PANIC("Undefined op %d\n", op); } } atomic_inc_64(&ap->ap_atomic_exited); splat_vprint(ap->ap_file, SPLAT_ATOMIC_TEST1_NAME, "Thread %d successfully exited: %lu/%lu\n", op, (long unsigned)ap->ap_atomic, (long unsigned)ap->ap_atomic_exited); wake_up(&ap->ap_waitq); thread_exit(); } static int splat_atomic_test1_cond(atomic_priv_t *ap, int started) { return (ap->ap_atomic_exited == started); } static int splat_atomic_test1(struct file *file, void *arg) { atomic_priv_t ap; DEFINE_WAIT(wait); kthread_t *thr; int i, rc = 0; ap.ap_magic = SPLAT_ATOMIC_TEST_MAGIC; ap.ap_file = file; mutex_init(&ap.ap_lock, SPLAT_ATOMIC_TEST1_NAME, MUTEX_DEFAULT, NULL); init_waitqueue_head(&ap.ap_waitq); ap.ap_atomic = SPLAT_ATOMIC_INIT_VALUE; ap.ap_atomic_exited = 0; for (i = 0; i < SPLAT_ATOMIC_COUNT_64; i++) { mutex_enter(&ap.ap_lock); ap.ap_op = i; thr = (kthread_t *)thread_create(NULL, 0, splat_atomic_work, &ap, 0, &p0, TS_RUN, defclsyspri); if (thr == NULL) { rc = -ESRCH; mutex_exit(&ap.ap_lock); break; } /* Prepare to wait, the new thread will wake us once it * has made a copy of the unique private passed data */ prepare_to_wait(&ap.ap_waitq, &wait, TASK_UNINTERRUPTIBLE); mutex_exit(&ap.ap_lock); schedule(); } wait_event(ap.ap_waitq, splat_atomic_test1_cond(&ap, i)); if (rc) { splat_vprint(file, SPLAT_ATOMIC_TEST1_NAME, "Only started " "%d/%d test threads\n", i, SPLAT_ATOMIC_COUNT_64); return rc; } if (ap.ap_atomic != SPLAT_ATOMIC_INIT_VALUE) { splat_vprint(file, SPLAT_ATOMIC_TEST1_NAME, "Final value %lu does not match initial value %lu\n", (long unsigned)ap.ap_atomic, SPLAT_ATOMIC_INIT_VALUE); return -EINVAL; } splat_vprint(file, SPLAT_ATOMIC_TEST1_NAME, "Success initial and final values match, %lu == %lu\n", (long unsigned)ap.ap_atomic, SPLAT_ATOMIC_INIT_VALUE); mutex_destroy(&ap.ap_lock); return 0; } splat_subsystem_t * splat_atomic_init(void) { splat_subsystem_t *sub; sub = kmalloc(sizeof(*sub), GFP_KERNEL); if (sub == NULL) return NULL; memset(sub, 0, sizeof(*sub)); strncpy(sub->desc.name, SPLAT_ATOMIC_NAME, SPLAT_NAME_SIZE); strncpy(sub->desc.desc, SPLAT_ATOMIC_DESC, SPLAT_DESC_SIZE); INIT_LIST_HEAD(&sub->subsystem_list); INIT_LIST_HEAD(&sub->test_list); spin_lock_init(&sub->test_lock); sub->desc.id = SPLAT_SUBSYSTEM_ATOMIC; splat_test_init(sub, SPLAT_ATOMIC_TEST1_NAME, SPLAT_ATOMIC_TEST1_DESC, SPLAT_ATOMIC_TEST1_ID, splat_atomic_test1); return sub; } void splat_atomic_fini(splat_subsystem_t *sub) { ASSERT(sub); splat_test_fini(sub, SPLAT_ATOMIC_TEST1_ID); kfree(sub); } int splat_atomic_id(void) { return SPLAT_SUBSYSTEM_ATOMIC; }