hw/cxl/cxl-events.c

   1 /*
   2  * CXL Event processing
   3  *
   4  * Copyright(C) 2023 Intel Corporation.
   5  *
   6  * This work is licensed under the terms of the GNU GPL, version 2. See the
   7  * COPYING file in the top-level directory.
   8  */
   9
  10 #include "qemu/osdep.h"
  11
  12 #include "qemu/bswap.h"
  13 #include "qemu/error-report.h"
  14 #include "hw/pci/msi.h"
  15 #include "hw/pci/msix.h"
  16 #include "hw/cxl/cxl.h"
  17 #include "hw/cxl/cxl_events.h"
  18
  19 /* Artificial limit on the number of events a log can hold */
  20 #define CXL_TEST_EVENT_OVERFLOW 8
  21
  22 static void reset_overflow(CXLEventLog *log)
  23 {
  24     log->overflow_err_count = 0;
  25     log->first_overflow_timestamp = 0;
  26     log->last_overflow_timestamp = 0;
  27 }
  28
  29 void cxl_event_init(CXLDeviceState *cxlds, int start_msg_num)
  30 {
  31     CXLEventLog *log;
  32     int i;
  33
  34     for (i = 0; i < CXL_EVENT_TYPE_MAX; i++) {
  35         log = &cxlds->event_logs[i];
  36         log->next_handle = 1;
  37         log->overflow_err_count = 0;
  38         log->first_overflow_timestamp = 0;
  39         log->last_overflow_timestamp = 0;
  40         log->irq_enabled = false;
  41         log->irq_vec = start_msg_num++;
  42         qemu_mutex_init(&log->lock);
  43         QSIMPLEQ_INIT(&log->events);
  44     }
  45
  46     /* Override -- Dynamic Capacity uses the same vector as info */
  47     cxlds->event_logs[CXL_EVENT_TYPE_DYNAMIC_CAP].irq_vec =
  48                       cxlds->event_logs[CXL_EVENT_TYPE_INFO].irq_vec;
  49
  50 }
  51
  52 static CXLEvent *cxl_event_get_head(CXLEventLog *log)
  53 {
  54     return QSIMPLEQ_FIRST(&log->events);
  55 }
  56
  57 static CXLEvent *cxl_event_get_next(CXLEvent *entry)
  58 {
  59     return QSIMPLEQ_NEXT(entry, node);
  60 }
  61
  62 static int cxl_event_count(CXLEventLog *log)
  63 {
  64     CXLEvent *event;
  65     int rc = 0;
  66
  67     QSIMPLEQ_FOREACH(event, &log->events, node) {
  68         rc++;
  69     }
  70
  71     return rc;
  72 }
  73
  74 static bool cxl_event_empty(CXLEventLog *log)
  75 {
  76     return QSIMPLEQ_EMPTY(&log->events);
  77 }
  78
  79 static void cxl_event_delete_head(CXLDeviceState *cxlds,
  80                                   CXLEventLogType log_type,
  81                                   CXLEventLog *log)
  82 {
  83     CXLEvent *entry = cxl_event_get_head(log);
  84
  85     reset_overflow(log);
  86     QSIMPLEQ_REMOVE_HEAD(&log->events, node);
  87     if (cxl_event_empty(log)) {
  88         cxl_event_set_status(cxlds, log_type, false);
  89     }
  90     g_free(entry);
  91 }
  92
  93 /*
  94  * return true if an interrupt should be generated as a result
  95  * of inserting this event.
  96  */
  97 bool cxl_event_insert(CXLDeviceState *cxlds, CXLEventLogType log_type,
  98                       CXLEventRecordRaw *event)
  99 {
 100     uint64_t time;
 101     CXLEventLog *log;
 102     CXLEvent *entry;
 103
 104     if (log_type >= CXL_EVENT_TYPE_MAX) {
 105         return false;
 106     }
 107
 108     time = cxl_device_get_timestamp(cxlds);
 109
 110     log = &cxlds->event_logs[log_type];
 111
 112     QEMU_LOCK_GUARD(&log->lock);
 113
 114     if (cxl_event_count(log) >= CXL_TEST_EVENT_OVERFLOW) {
 115         if (log->overflow_err_count == 0) {
 116             log->first_overflow_timestamp = time;
 117         }
 118         log->overflow_err_count++;
 119         log->last_overflow_timestamp = time;
 120         return false;
 121     }
 122
 123     entry = g_new0(CXLEvent, 1);
 124
 125     memcpy(&entry->data, event, sizeof(*event));
 126
 127     entry->data.hdr.handle = cpu_to_le16(log->next_handle);
 128     log->next_handle++;
 129     /* 0 handle is never valid */
 130     if (log->next_handle == 0) {
 131         log->next_handle++;
 132     }
 133     entry->data.hdr.timestamp = cpu_to_le64(time);
 134
 135     QSIMPLEQ_INSERT_TAIL(&log->events, entry, node);
 136     cxl_event_set_status(cxlds, log_type, true);
 137
 138     /* Count went from 0 to 1 */
 139     return cxl_event_count(log) == 1;
 140 }
 141
 142 void cxl_discard_all_event_records(CXLDeviceState *cxlds)
 143 {
 144     CXLEventLogType log_type;
 145     CXLEventLog *log;
 146
 147     for (log_type = 0; log_type < CXL_EVENT_TYPE_MAX; log_type++) {
 148         log = &cxlds->event_logs[log_type];
 149         while (!cxl_event_empty(log)) {
 150             cxl_event_delete_head(cxlds, log_type, log);
 151         }
 152     }
 153 }
 154
 155 CXLRetCode cxl_event_get_records(CXLDeviceState *cxlds, CXLGetEventPayload *pl,
 156                                  uint8_t log_type, int max_recs,
 157                                  size_t *len)
 158 {
 159     CXLEventLog *log;
 160     CXLEvent *entry;
 161     uint16_t nr;
 162
 163     if (log_type >= CXL_EVENT_TYPE_MAX) {
 164         return CXL_MBOX_INVALID_INPUT;
 165     }
 166
 167     log = &cxlds->event_logs[log_type];
 168
 169     QEMU_LOCK_GUARD(&log->lock);
 170
 171     entry = cxl_event_get_head(log);
 172     for (nr = 0; entry && nr < max_recs; nr++) {
 173         memcpy(&pl->records[nr], &entry->data, CXL_EVENT_RECORD_SIZE);
 174         entry = cxl_event_get_next(entry);
 175     }
 176
 177     if (!cxl_event_empty(log)) {
 178         pl->flags |= CXL_GET_EVENT_FLAG_MORE_RECORDS;
 179     }
 180
 181     if (log->overflow_err_count) {
 182         pl->flags |= CXL_GET_EVENT_FLAG_OVERFLOW;
 183         pl->overflow_err_count = cpu_to_le16(log->overflow_err_count);
 184         pl->first_overflow_timestamp =
 185             cpu_to_le64(log->first_overflow_timestamp);
 186         pl->last_overflow_timestamp =
 187             cpu_to_le64(log->last_overflow_timestamp);
 188     }
 189
 190     pl->record_count = cpu_to_le16(nr);
 191     *len = CXL_EVENT_PAYLOAD_HDR_SIZE + (CXL_EVENT_RECORD_SIZE * nr);
 192
 193     return CXL_MBOX_SUCCESS;
 194 }
 195
 196 CXLRetCode cxl_event_clear_records(CXLDeviceState *cxlds,
 197                                    CXLClearEventPayload *pl)
 198 {
 199     CXLEventLog *log;
 200     uint8_t log_type;
 201     CXLEvent *entry;
 202     int nr;
 203
 204     log_type = pl->event_log;
 205
 206     if (log_type >= CXL_EVENT_TYPE_MAX) {
 207         return CXL_MBOX_INVALID_INPUT;
 208     }
 209
 210     log = &cxlds->event_logs[log_type];
 211
 212     QEMU_LOCK_GUARD(&log->lock);
 213     /*
 214      * Must iterate the queue twice.
 215      * "The device shall verify the event record handles specified in the input
 216      * payload are in temporal order. If the device detects an older event
 217      * record that will not be cleared when Clear Event Records is executed,
 218      * the device shall return the Invalid Handle return code and shall not
 219      * clear any of the specified event records."
 220      *   -- CXL r3.1 Section 8.2.9.2.3: Clear Event Records (0101h)
 221      */
 222     entry = cxl_event_get_head(log);
 223     for (nr = 0; entry && nr < pl->nr_recs; nr++) {
 224         uint16_t handle = pl->handle[nr];
 225
 226         /* NOTE: Both handles are little endian. */
 227         if (handle == 0 || entry->data.hdr.handle != handle) {
 228             return CXL_MBOX_INVALID_INPUT;
 229         }
 230         entry = cxl_event_get_next(entry);
 231     }
 232
 233     entry = cxl_event_get_head(log);
 234     for (nr = 0; entry && nr < pl->nr_recs; nr++) {
 235         cxl_event_delete_head(cxlds, log_type, log);
 236         entry = cxl_event_get_head(log);
 237     }
 238
 239     return CXL_MBOX_SUCCESS;
 240 }
 241
 242 void cxl_event_irq_assert(CXLType3Dev *ct3d)
 243 {
 244     CXLDeviceState *cxlds = &ct3d->cxl_dstate;
 245     PCIDevice *pdev = &ct3d->parent_obj;
 246     int i;
 247
 248     for (i = 0; i < CXL_EVENT_TYPE_MAX; i++) {
 249         CXLEventLog *log = &cxlds->event_logs[i];
 250
 251         if (!log->irq_enabled || cxl_event_empty(log)) {
 252             continue;
 253         }
 254
 255         /*  Notifies interrupt, legacy IRQ is not supported */
 256         if (msix_enabled(pdev)) {
 257             msix_notify(pdev, log->irq_vec);
 258         } else if (msi_enabled(pdev)) {
 259             msi_notify(pdev, log->irq_vec);
 260         }
 261     }
 262 }