cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

utlock.c (4001B)

      1// SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
      2/******************************************************************************
      3 *
      4 * Module Name: utlock - Reader/Writer lock interfaces
      5 *
      6 * Copyright (C) 2000 - 2022, Intel Corp.
      7 *
      8 *****************************************************************************/
      9
     10#include <acpi/acpi.h>
     11#include "accommon.h"
     12
     13#define _COMPONENT          ACPI_UTILITIES
     14ACPI_MODULE_NAME("utlock")
     15
     16/*******************************************************************************
     17 *
     18 * FUNCTION:    acpi_ut_create_rw_lock
     19 *              acpi_ut_delete_rw_lock
     20 *
     21 * PARAMETERS:  lock                - Pointer to a valid RW lock
     22 *
     23 * RETURN:      Status
     24 *
     25 * DESCRIPTION: Reader/writer lock creation and deletion interfaces.
     26 *
     27 ******************************************************************************/
     28acpi_status acpi_ut_create_rw_lock(struct acpi_rw_lock *lock)
     29{
     30	acpi_status status;
     31
     32	lock->num_readers = 0;
     33	status = acpi_os_create_mutex(&lock->reader_mutex);
     34	if (ACPI_FAILURE(status)) {
     35		return (status);
     36	}
     37
     38	status = acpi_os_create_mutex(&lock->writer_mutex);
     39	return (status);
     40}
     41
     42void acpi_ut_delete_rw_lock(struct acpi_rw_lock *lock)
     43{
     44
     45	acpi_os_delete_mutex(lock->reader_mutex);
     46	acpi_os_delete_mutex(lock->writer_mutex);
     47
     48	lock->num_readers = 0;
     49	lock->reader_mutex = NULL;
     50	lock->writer_mutex = NULL;
     51}
     52
     53/*******************************************************************************
     54 *
     55 * FUNCTION:    acpi_ut_acquire_read_lock
     56 *              acpi_ut_release_read_lock
     57 *
     58 * PARAMETERS:  lock                - Pointer to a valid RW lock
     59 *
     60 * RETURN:      Status
     61 *
     62 * DESCRIPTION: Reader interfaces for reader/writer locks. On acquisition,
     63 *              only the first reader acquires the write mutex. On release,
     64 *              only the last reader releases the write mutex. Although this
     65 *              algorithm can in theory starve writers, this should not be a
     66 *              problem with ACPICA since the subsystem is infrequently used
     67 *              in comparison to (for example) an I/O system.
     68 *
     69 ******************************************************************************/
     70
     71acpi_status acpi_ut_acquire_read_lock(struct acpi_rw_lock *lock)
     72{
     73	acpi_status status;
     74
     75	status = acpi_os_acquire_mutex(lock->reader_mutex, ACPI_WAIT_FOREVER);
     76	if (ACPI_FAILURE(status)) {
     77		return (status);
     78	}
     79
     80	/* Acquire the write lock only for the first reader */
     81
     82	lock->num_readers++;
     83	if (lock->num_readers == 1) {
     84		status =
     85		    acpi_os_acquire_mutex(lock->writer_mutex,
     86					  ACPI_WAIT_FOREVER);
     87	}
     88
     89	acpi_os_release_mutex(lock->reader_mutex);
     90	return (status);
     91}
     92
     93acpi_status acpi_ut_release_read_lock(struct acpi_rw_lock *lock)
     94{
     95	acpi_status status;
     96
     97	status = acpi_os_acquire_mutex(lock->reader_mutex, ACPI_WAIT_FOREVER);
     98	if (ACPI_FAILURE(status)) {
     99		return (status);
    100	}
    101
    102	/* Release the write lock only for the very last reader */
    103
    104	lock->num_readers--;
    105	if (lock->num_readers == 0) {
    106		acpi_os_release_mutex(lock->writer_mutex);
    107	}
    108
    109	acpi_os_release_mutex(lock->reader_mutex);
    110	return (status);
    111}
    112
    113/*******************************************************************************
    114 *
    115 * FUNCTION:    acpi_ut_acquire_write_lock
    116 *              acpi_ut_release_write_lock
    117 *
    118 * PARAMETERS:  lock                - Pointer to a valid RW lock
    119 *
    120 * RETURN:      Status
    121 *
    122 * DESCRIPTION: Writer interfaces for reader/writer locks. Simply acquire or
    123 *              release the writer mutex associated with the lock. Acquisition
    124 *              of the lock is fully exclusive and will block all readers and
    125 *              writers until it is released.
    126 *
    127 ******************************************************************************/
    128
    129acpi_status acpi_ut_acquire_write_lock(struct acpi_rw_lock *lock)
    130{
    131	acpi_status status;
    132
    133	status = acpi_os_acquire_mutex(lock->writer_mutex, ACPI_WAIT_FOREVER);
    134	return (status);
    135}
    136
    137void acpi_ut_release_write_lock(struct acpi_rw_lock *lock)
    138{
    139
    140	acpi_os_release_mutex(lock->writer_mutex);
    141}