notify.h File Reference

#include <uacpi/internal/types.h>
#include <uacpi/notify.h>

Include dependency graph for notify.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
uacpi_status	uacpi_initialize_notify (void)
void	uacpi_deinitialize_notify (void)
uacpi_status	uacpi_notify_all (uacpi_namespace_node *node, uacpi_u64 value)

Function Documentation

uacpi_deinitialize_notify()

void uacpi_deinitialize_notify

(

void

)

Definition at line 24 of file notify.c.

{
    if (notify_mutex != UACPI_NULL)
        uacpi_free_native_mutex(notify_mutex);
 
    notify_mutex = UACPI_NULL;
}

Referenced by uacpi_state_reset().

uacpi_initialize_notify()

uacpi_status uacpi_initialize_notify

(

void

)

Definition at line 15 of file notify.c.

{
    notify_mutex = uacpi_create_native_mutex();
    if (uacpi_unlikely(notify_mutex == UACPI_NULL))
        return UACPI_STATUS_OUT_OF_MEMORY;
 
    return UACPI_STATUS_OK;
}

Referenced by uacpi_initialize().

uacpi_notify_all()

uacpi_status uacpi_notify_all	(	uacpi_namespace_node *	node,
		uacpi_u64	value
	)

Definition at line 96 of file notify.c.

{
    uacpi_status ret;
    struct notification_ctx *ctx;
    uacpi_object *node_object;
 
    node_object = uacpi_namespace_node_get_object_typed(
        node, UACPI_OBJECT_DEVICE_BIT | UACPI_OBJECT_THERMAL_ZONE_BIT |
              UACPI_OBJECT_PROCESSOR_BIT
    );
    if (uacpi_unlikely(node_object == UACPI_NULL))
        return UACPI_STATUS_INVALID_ARGUMENT;
 
    ret = uacpi_acquire_native_mutex(notify_mutex);
    if (uacpi_unlikely_error(ret))
        return ret;
 
    if (node_object->handlers->notify_head == UACPI_NULL &&
        g_uacpi_rt_ctx.root_object->handlers->notify_head == UACPI_NULL) {
        ret = UACPI_STATUS_NO_HANDLER;
        goto error_out;
    }
 
    ctx = uacpi_kernel_alloc(sizeof(*ctx));
    if (uacpi_unlikely(ctx == UACPI_NULL)) {
        ret = UACPI_STATUS_OUT_OF_MEMORY;
        goto error_out;
    }
 
    ctx->work_item = uacpi_kernel_create_work_item();
    if (uacpi_unlikely(ctx->work_item == UACPI_NULL)) {
        uacpi_free(ctx, sizeof(*ctx));
        ret = UACPI_STATUS_OUT_OF_MEMORY;
        goto error_out;
    }
 
    ctx->node = node;
    // In case this node goes out of scope
    uacpi_shareable_ref(node);
 
    ctx->value = value;
    ctx->node_object = uacpi_namespace_node_get_object(node);
    uacpi_object_ref(ctx->node_object);
 
    /*
     * Nothing prevents the kernel from executing the work synchronously, e.g.
     * because it sees no reason to defer it if it's not in an interrupt
     * context. The handlers are free to call back into uACPI, be it to
     * evaluate an object or to install another handler, so make sure that
     * we're not holding onto anything that they might need. This includes the
     * namespace, which is locked by whoever is sending the notification.
     *
     * Everything that the work needs is referenced by now, and there's nothing
     * left for us to do after it's scheduled.
     */
    uacpi_release_native_mutex(notify_mutex);
    uacpi_namespace_write_unlock();
 
    uacpi_kernel_schedule_work(
        UACPI_WORK_NOTIFICATION, ctx->work_item, do_notify, ctx
    );
 
    uacpi_namespace_write_lock();
    return UACPI_STATUS_OK;
 
error_out:
    uacpi_release_native_mutex(notify_mutex);
    return ret;
}

Referenced by async_run_gpe_handler(), and handle_notify().