| Message ID | 20240417075053.3273543-3-ruansy.fnst@fujitsu.com (mailing list archive) |
|---|---|
| State | New |
| Headers | show |
| Series | cxl: add poison creation event handler | expand |
On 4/17/24 12:50 AM, Shiyang Ruan wrote: > Currently driver only traces cxl events, poison creation (for both vmem > and pmem type) on cxl memdev is silent. OS needs to be notified then it > could handle poison pages in time. Per CXL spec, the device error event > could be signaled through FW-First and OS-First methods. Please consider below for better clarity: Currently the driver only traces CXL events. Poison creation (for both ram and pmem type) on a CXL memdev is silent. The OS needs to be notified so it can handle poison pages. Per CXL spec, the device error event can be signaled through the FW-First method or the OS-First method. > > So, add poison creation event handler in OS-First method: > - Qemu: > - CXL device reports POISON creation event to OS by MSI by sending > GMER/DER after injecting a poison record; Can probably drop the QEMU changes and this is the kernel commit log. > - CXL driver: > a. parse the POISON event from GMER/DER; > b. translate poisoned DPA to HPA (PFN); > c. enqueue poisoned PFN to memory_failure's work queue; > > Signed-off-by: Shiyang Ruan <ruansy.fnst@fujitsu.com> > --- > drivers/cxl/core/mbox.c | 119 +++++++++++++++++++++++++++++++++----- > drivers/cxl/cxlmem.h | 8 +-- > include/linux/cxl-event.h | 18 +++++- > 3 files changed, 125 insertions(+), 20 deletions(-) > > diff --git a/drivers/cxl/core/mbox.c b/drivers/cxl/core/mbox.c > index f0f54aeccc87..76af0d73859d 100644 > --- a/drivers/cxl/core/mbox.c > +++ b/drivers/cxl/core/mbox.c > @@ -837,25 +837,116 @@ int cxl_enumerate_cmds(struct cxl_memdev_state *mds) > } > EXPORT_SYMBOL_NS_GPL(cxl_enumerate_cmds, CXL); > > -void cxl_event_trace_record(const struct cxl_memdev *cxlmd, > - enum cxl_event_log_type type, > - enum cxl_event_type event_type, > - const uuid_t *uuid, union cxl_event *evt) > +static void cxl_report_poison(struct cxl_memdev *cxlmd, struct cxl_region *cxlr, I think this needs to be changed to __cxl_report_poison() and the function below to cxl_report_poison(). Otherwise it goes against typical Linux methodology of having the __functionX() as the raw functionality function called by a functionX() wrapper. DJ > + u64 dpa) > { > - if (event_type == CXL_CPER_EVENT_GEN_MEDIA) > + u64 hpa = cxl_trace_hpa(cxlr, cxlmd, dpa); > + unsigned long pfn = PHYS_PFN(hpa); > + > + if (!IS_ENABLED(CONFIG_MEMORY_FAILURE)) > + return; > + > + memory_failure_queue(pfn, MF_ACTION_REQUIRED); > +} > + > +static int __cxl_report_poison(struct device *dev, void *arg) > +{ > + struct cxl_endpoint_decoder *cxled; > + struct cxl_memdev *cxlmd; > + u64 dpa = *(u64 *)arg; > + > + cxled = to_cxl_endpoint_decoder(dev); > + if (!cxled || !cxled->dpa_res || !resource_size(cxled->dpa_res)) > + return 0; > + > + if (cxled->mode == CXL_DECODER_MIXED) { > + dev_dbg(dev, "poison list read unsupported in mixed mode\n"); > + return 0; > + } > + > + if (dpa > cxled->dpa_res->end || dpa < cxled->dpa_res->start) > + return 0; > + > + cxlmd = cxled_to_memdev(cxled); > + cxl_report_poison(cxlmd, cxled->cxld.region, dpa); > + > + return 1; > +} > + > +static void cxl_event_handle_poison(struct cxl_memdev *cxlmd, u64 dpa) > +{ > + struct cxl_port *port = cxlmd->endpoint; > + > + /* > + * No region is mapped to this endpoint, that is to say no HPA is > + * mapped. > + */ > + if (!port || !is_cxl_endpoint(port) || > + cxl_num_decoders_committed(port) == 0) > + return; > + > + device_for_each_child(&port->dev, &dpa, __cxl_report_poison); > +} > + > +static void cxl_event_handle_general_media(struct cxl_memdev *cxlmd, > + enum cxl_event_log_type type, > + struct cxl_event_gen_media *rec) > +{ > + u64 dpa = le64_to_cpu(rec->phys_addr) & CXL_DPA_MASK; > + > + if (type == CXL_EVENT_TYPE_FAIL) { > + switch (rec->transaction_type) { > + case CXL_EVENT_TRANSACTION_READ: > + case CXL_EVENT_TRANSACTION_WRITE: > + case CXL_EVENT_TRANSACTION_INJECT_POISON: > + cxl_event_handle_poison(cxlmd, dpa); > + break; > + default: > + break; > + } > + } > +} > + > +static void cxl_event_handle_dram(struct cxl_memdev *cxlmd, > + enum cxl_event_log_type type, > + struct cxl_event_dram *rec) > +{ > + u64 dpa = le64_to_cpu(rec->phys_addr) & CXL_DPA_MASK; > + > + if (type == CXL_EVENT_TYPE_FAIL) { > + switch (rec->transaction_type) { > + case CXL_EVENT_TRANSACTION_READ: > + case CXL_EVENT_TRANSACTION_WRITE: > + case CXL_EVENT_TRANSACTION_INJECT_POISON: > + cxl_event_handle_poison(cxlmd, dpa); > + break; > + default: > + break; > + } > + } > +} > + > +void cxl_event_handle_record(struct cxl_memdev *cxlmd, > + enum cxl_event_log_type type, > + enum cxl_event_type event_type, > + const uuid_t *uuid, union cxl_event *evt) > +{ > + if (event_type == CXL_CPER_EVENT_GEN_MEDIA) { > trace_cxl_general_media(cxlmd, type, &evt->gen_media); > - else if (event_type == CXL_CPER_EVENT_DRAM) > + cxl_event_handle_general_media(cxlmd, type, &evt->gen_media); > + } else if (event_type == CXL_CPER_EVENT_DRAM) { > trace_cxl_dram(cxlmd, type, &evt->dram); > - else if (event_type == CXL_CPER_EVENT_MEM_MODULE) > + cxl_event_handle_dram(cxlmd, type, &evt->dram); > + } else if (event_type == CXL_CPER_EVENT_MEM_MODULE) > trace_cxl_memory_module(cxlmd, type, &evt->mem_module); > else > trace_cxl_generic_event(cxlmd, type, uuid, &evt->generic); > } > -EXPORT_SYMBOL_NS_GPL(cxl_event_trace_record, CXL); > +EXPORT_SYMBOL_NS_GPL(cxl_event_handle_record, CXL); > > -static void __cxl_event_trace_record(const struct cxl_memdev *cxlmd, > - enum cxl_event_log_type type, > - struct cxl_event_record_raw *record) > +static void __cxl_event_handle_record(struct cxl_memdev *cxlmd, > + enum cxl_event_log_type type, > + struct cxl_event_record_raw *record) > { > enum cxl_event_type ev_type = CXL_CPER_EVENT_GENERIC; > const uuid_t *uuid = &record->id; > @@ -867,7 +958,7 @@ static void __cxl_event_trace_record(const struct cxl_memdev *cxlmd, > else if (uuid_equal(uuid, &CXL_EVENT_MEM_MODULE_UUID)) > ev_type = CXL_CPER_EVENT_MEM_MODULE; > > - cxl_event_trace_record(cxlmd, type, ev_type, uuid, &record->event); > + cxl_event_handle_record(cxlmd, type, ev_type, uuid, &record->event); > } > > static int cxl_clear_event_record(struct cxl_memdev_state *mds, > @@ -979,8 +1070,8 @@ static void cxl_mem_get_records_log(struct cxl_memdev_state *mds, > break; > > for (i = 0; i < nr_rec; i++) > - __cxl_event_trace_record(cxlmd, type, > - &payload->records[i]); > + __cxl_event_handle_record(cxlmd, type, > + &payload->records[i]); > > if (payload->flags & CXL_GET_EVENT_FLAG_OVERFLOW) > trace_cxl_overflow(cxlmd, type, payload); > diff --git a/drivers/cxl/cxlmem.h b/drivers/cxl/cxlmem.h > index 36cee9c30ceb..ba1347de5651 100644 > --- a/drivers/cxl/cxlmem.h > +++ b/drivers/cxl/cxlmem.h > @@ -822,10 +822,10 @@ void set_exclusive_cxl_commands(struct cxl_memdev_state *mds, > void clear_exclusive_cxl_commands(struct cxl_memdev_state *mds, > unsigned long *cmds); > void cxl_mem_get_event_records(struct cxl_memdev_state *mds, u32 status); > -void cxl_event_trace_record(const struct cxl_memdev *cxlmd, > - enum cxl_event_log_type type, > - enum cxl_event_type event_type, > - const uuid_t *uuid, union cxl_event *evt); > +void cxl_event_handle_record(struct cxl_memdev *cxlmd, > + enum cxl_event_log_type type, > + enum cxl_event_type event_type, > + const uuid_t *uuid, union cxl_event *evt); > int cxl_set_timestamp(struct cxl_memdev_state *mds); > int cxl_poison_state_init(struct cxl_memdev_state *mds); > int cxl_mem_get_poison(struct cxl_memdev *cxlmd, u64 offset, u64 len, > diff --git a/include/linux/cxl-event.h b/include/linux/cxl-event.h > index 03fa6d50d46f..8189bed76c12 100644 > --- a/include/linux/cxl-event.h > +++ b/include/linux/cxl-event.h > @@ -23,6 +23,20 @@ struct cxl_event_generic { > u8 data[CXL_EVENT_RECORD_DATA_LENGTH]; > } __packed; > > +/* > + * Event transaction type > + * CXL rev 3.0 Section 8.2.9.2.1.1; Table 8-43 > + */ > +enum cxl_event_transaction_type { > + CXL_EVENT_TRANSACTION_UNKNOWN = 0X00, > + CXL_EVENT_TRANSACTION_READ, > + CXL_EVENT_TRANSACTION_WRITE, > + CXL_EVENT_TRANSACTION_SCAN_MEDIA, > + CXL_EVENT_TRANSACTION_INJECT_POISON, > + CXL_EVENT_TRANSACTION_MEDIA_SCRUB, > + CXL_EVENT_TRANSACTION_MEDIA_MANAGEMENT, > +}; > + > /* > * General Media Event Record > * CXL rev 3.0 Section 8.2.9.2.1.1; Table 8-43 > @@ -33,7 +47,7 @@ struct cxl_event_gen_media { > __le64 phys_addr; > u8 descriptor; > u8 type; > - u8 transaction_type; > + u8 transaction_type; /* enum cxl_event_transaction_type */ > u8 validity_flags[2]; > u8 channel; > u8 rank; > @@ -52,7 +66,7 @@ struct cxl_event_dram { > __le64 phys_addr; > u8 descriptor; > u8 type; > - u8 transaction_type; > + u8 transaction_type; /* enum cxl_event_transaction_type */ > u8 validity_flags[2]; > u8 channel; > u8 rank;
在 2024/4/18 1:30, Dave Jiang 写道: > > > On 4/17/24 12:50 AM, Shiyang Ruan wrote: >> Currently driver only traces cxl events, poison creation (for both vmem >> and pmem type) on cxl memdev is silent. OS needs to be notified then it >> could handle poison pages in time. Per CXL spec, the device error event >> could be signaled through FW-First and OS-First methods. > > Please consider below for better clarity: > Currently the driver only traces CXL events. Poison creation (for both ram > and pmem type) on a CXL memdev is silent. The OS needs to be notified so it > can handle poison pages. Per CXL spec, the device error event > can be signaled through the FW-First method or the OS-First method. Thanks, this is better. > >> >> So, add poison creation event handler in OS-First method: >> - Qemu: >> - CXL device reports POISON creation event to OS by MSI by sending >> GMER/DER after injecting a poison record; > > Can probably drop the QEMU changes and this is the kernel commit log. Ok. > >> - CXL driver: >> a. parse the POISON event from GMER/DER; >> b. translate poisoned DPA to HPA (PFN); >> c. enqueue poisoned PFN to memory_failure's work queue; >> >> Signed-off-by: Shiyang Ruan <ruansy.fnst@fujitsu.com> >> --- >> drivers/cxl/core/mbox.c | 119 +++++++++++++++++++++++++++++++++----- >> drivers/cxl/cxlmem.h | 8 +-- >> include/linux/cxl-event.h | 18 +++++- >> 3 files changed, 125 insertions(+), 20 deletions(-) >> >> diff --git a/drivers/cxl/core/mbox.c b/drivers/cxl/core/mbox.c >> index f0f54aeccc87..76af0d73859d 100644 >> --- a/drivers/cxl/core/mbox.c >> +++ b/drivers/cxl/core/mbox.c >> @@ -837,25 +837,116 @@ int cxl_enumerate_cmds(struct cxl_memdev_state *mds) >> } >> EXPORT_SYMBOL_NS_GPL(cxl_enumerate_cmds, CXL); >> >> -void cxl_event_trace_record(const struct cxl_memdev *cxlmd, >> - enum cxl_event_log_type type, >> - enum cxl_event_type event_type, >> - const uuid_t *uuid, union cxl_event *evt) >> +static void cxl_report_poison(struct cxl_memdev *cxlmd, struct cxl_region *cxlr, > > I think this needs to be changed to __cxl_report_poison() and the function below to cxl_report_poison(). Otherwise it goes against typical Linux methodology of having the __functionX() as the raw functionality function called by a functionX() wrapper. This function was designed to do the real reporting work, and could be called at other places (actually did in previous version). Now that it is called only below in this version, yes, it's better to change the names. -- Thanks, Ruan. > > DJ >
Hi Shiyang,
kernel test robot noticed the following build errors:
[auto build test ERROR on cxl/next]
[also build test ERROR on linus/master v6.9-rc4 next-20240419]
[If your patch is applied to the wrong git tree, kindly drop us a note.
And when submitting patch, we suggest to use '--base' as documented in
https://git-scm.com/docs/git-format-patch#_base_tree_information]
url: https://github.com/intel-lab-lkp/linux/commits/Shiyang-Ruan/cxl-core-correct-length-of-DPA-field-masks/20240417-155443
base: https://git.kernel.org/pub/scm/linux/kernel/git/cxl/cxl.git next
patch link: https://lore.kernel.org/r/20240417075053.3273543-3-ruansy.fnst%40fujitsu.com
patch subject: [PATCH v3 2/2] cxl/core: add poison creation event handler
config: csky-randconfig-002-20240421 (https://download.01.org/0day-ci/archive/20240421/202404212044.uSxtGRtL-lkp@intel.com/config)
compiler: csky-linux-gcc (GCC) 13.2.0
reproduce (this is a W=1 build): (https://download.01.org/0day-ci/archive/20240421/202404212044.uSxtGRtL-lkp@intel.com/reproduce)
If you fix the issue in a separate patch/commit (i.e. not just a new version of
the same patch/commit), kindly add following tags
| Reported-by: kernel test robot <lkp@intel.com>
| Closes: https://lore.kernel.org/oe-kbuild-all/202404212044.uSxtGRtL-lkp@intel.com/
All errors (new ones prefixed by >>):
`.exit.text' referenced in section `__jump_table' of fs/ceph/super.o: defined in discarded section `.exit.text' of fs/ceph/super.o
`.exit.text' referenced in section `__jump_table' of fs/ceph/super.o: defined in discarded section `.exit.text' of fs/ceph/super.o
csky-linux-ld: drivers/cxl/core/mbox.o: in function `__cxl_report_poison':
mbox.c:(.text+0xa12): undefined reference to `cxl_trace_hpa'
>> csky-linux-ld: mbox.c:(.text+0xa44): undefined reference to `cxl_trace_hpa'
`.exit.text' referenced in section `__jump_table' of drivers/target/target_core_configfs.o: defined in discarded section `.exit.text' of drivers/target/target_core_configfs.o
`.exit.text' referenced in section `__jump_table' of drivers/target/target_core_configfs.o: defined in discarded section `.exit.text' of drivers/target/target_core_configfs.o
`.exit.text' referenced in section `__jump_table' of net/ceph/ceph_common.o: defined in discarded section `.exit.text' of net/ceph/ceph_common.o
`.exit.text' referenced in section `__jump_table' of net/ceph/ceph_common.o: defined in discarded section `.exit.text' of net/ceph/ceph_common.o
Shiyang Ruan wrote: > Currently driver only traces cxl events, poison creation (for both vmem > and pmem type) on cxl memdev is silent. OS needs to be notified then it > could handle poison pages in time. Per CXL spec, the device error event > could be signaled through FW-First and OS-First methods. > > So, add poison creation event handler in OS-First method: > - Qemu: > - CXL device reports POISON creation event to OS by MSI by sending > GMER/DER after injecting a poison record; > - CXL driver: > a. parse the POISON event from GMER/DER; > b. translate poisoned DPA to HPA (PFN); > c. enqueue poisoned PFN to memory_failure's work queue; I'm a bit confused by the need for this patch. Perhaps a bit more detail here? More comments below. > > Signed-off-by: Shiyang Ruan <ruansy.fnst@fujitsu.com> > --- > drivers/cxl/core/mbox.c | 119 +++++++++++++++++++++++++++++++++----- > drivers/cxl/cxlmem.h | 8 +-- > include/linux/cxl-event.h | 18 +++++- > 3 files changed, 125 insertions(+), 20 deletions(-) > > diff --git a/drivers/cxl/core/mbox.c b/drivers/cxl/core/mbox.c > index f0f54aeccc87..76af0d73859d 100644 > --- a/drivers/cxl/core/mbox.c > +++ b/drivers/cxl/core/mbox.c > @@ -837,25 +837,116 @@ int cxl_enumerate_cmds(struct cxl_memdev_state *mds) > } > EXPORT_SYMBOL_NS_GPL(cxl_enumerate_cmds, CXL); > > -void cxl_event_trace_record(const struct cxl_memdev *cxlmd, > - enum cxl_event_log_type type, > - enum cxl_event_type event_type, > - const uuid_t *uuid, union cxl_event *evt) > +static void cxl_report_poison(struct cxl_memdev *cxlmd, struct cxl_region *cxlr, > + u64 dpa) > { > - if (event_type == CXL_CPER_EVENT_GEN_MEDIA) > + u64 hpa = cxl_trace_hpa(cxlr, cxlmd, dpa); > + unsigned long pfn = PHYS_PFN(hpa); > + > + if (!IS_ENABLED(CONFIG_MEMORY_FAILURE)) > + return; > + > + memory_failure_queue(pfn, MF_ACTION_REQUIRED); I thought that ras daemon was supposed to take care of this when the trace event occurred. Alison is working on the HPA data for that path. > +} > + > +static int __cxl_report_poison(struct device *dev, void *arg) > +{ > + struct cxl_endpoint_decoder *cxled; > + struct cxl_memdev *cxlmd; > + u64 dpa = *(u64 *)arg; > + > + cxled = to_cxl_endpoint_decoder(dev); > + if (!cxled || !cxled->dpa_res || !resource_size(cxled->dpa_res)) > + return 0; > + > + if (cxled->mode == CXL_DECODER_MIXED) { > + dev_dbg(dev, "poison list read unsupported in mixed mode\n"); > + return 0; > + } > + > + if (dpa > cxled->dpa_res->end || dpa < cxled->dpa_res->start) > + return 0; > + > + cxlmd = cxled_to_memdev(cxled); > + cxl_report_poison(cxlmd, cxled->cxld.region, dpa); > + > + return 1; > +} > + > +static void cxl_event_handle_poison(struct cxl_memdev *cxlmd, u64 dpa) > +{ > + struct cxl_port *port = cxlmd->endpoint; > + > + /* > + * No region is mapped to this endpoint, that is to say no HPA is > + * mapped. > + */ > + if (!port || !is_cxl_endpoint(port) || > + cxl_num_decoders_committed(port) == 0) > + return; > + > + device_for_each_child(&port->dev, &dpa, __cxl_report_poison); > +} > + > +static void cxl_event_handle_general_media(struct cxl_memdev *cxlmd, > + enum cxl_event_log_type type, > + struct cxl_event_gen_media *rec) > +{ > + u64 dpa = le64_to_cpu(rec->phys_addr) & CXL_DPA_MASK; > + > + if (type == CXL_EVENT_TYPE_FAIL) { Why only FAIL and not FATAL? > + switch (rec->transaction_type) { > + case CXL_EVENT_TRANSACTION_READ: > + case CXL_EVENT_TRANSACTION_WRITE: > + case CXL_EVENT_TRANSACTION_INJECT_POISON: Why not scan media? > + cxl_event_handle_poison(cxlmd, dpa); > + break; > + default: > + break; > + } > + } > +} > + > +static void cxl_event_handle_dram(struct cxl_memdev *cxlmd, > + enum cxl_event_log_type type, > + struct cxl_event_dram *rec) > +{ > + u64 dpa = le64_to_cpu(rec->phys_addr) & CXL_DPA_MASK; > + > + if (type == CXL_EVENT_TYPE_FAIL) { > + switch (rec->transaction_type) { > + case CXL_EVENT_TRANSACTION_READ: > + case CXL_EVENT_TRANSACTION_WRITE: > + case CXL_EVENT_TRANSACTION_INJECT_POISON: > + cxl_event_handle_poison(cxlmd, dpa); > + break; > + default: > + break; > + } > + } > +} > + > +void cxl_event_handle_record(struct cxl_memdev *cxlmd, > + enum cxl_event_log_type type, > + enum cxl_event_type event_type, > + const uuid_t *uuid, union cxl_event *evt) > +{ > + if (event_type == CXL_CPER_EVENT_GEN_MEDIA) { > trace_cxl_general_media(cxlmd, type, &evt->gen_media); > - else if (event_type == CXL_CPER_EVENT_DRAM) > + cxl_event_handle_general_media(cxlmd, type, &evt->gen_media); > + } else if (event_type == CXL_CPER_EVENT_DRAM) { > trace_cxl_dram(cxlmd, type, &evt->dram); > - else if (event_type == CXL_CPER_EVENT_MEM_MODULE) > + cxl_event_handle_dram(cxlmd, type, &evt->dram); > + } else if (event_type == CXL_CPER_EVENT_MEM_MODULE) > trace_cxl_memory_module(cxlmd, type, &evt->mem_module); > else > trace_cxl_generic_event(cxlmd, type, uuid, &evt->generic); > } > -EXPORT_SYMBOL_NS_GPL(cxl_event_trace_record, CXL); > +EXPORT_SYMBOL_NS_GPL(cxl_event_handle_record, CXL); > Why all the churn with changing the names of functions? Ira > > -static void __cxl_event_trace_record(const struct cxl_memdev *cxlmd, > - enum cxl_event_log_type type, > - struct cxl_event_record_raw *record) > +static void __cxl_event_handle_record(struct cxl_memdev *cxlmd, > + enum cxl_event_log_type type, > + struct cxl_event_record_raw *record) > { > enum cxl_event_type ev_type = CXL_CPER_EVENT_GENERIC; > const uuid_t *uuid = &record->id; > @@ -867,7 +958,7 @@ static void __cxl_event_trace_record(const struct cxl_memdev *cxlmd, > else if (uuid_equal(uuid, &CXL_EVENT_MEM_MODULE_UUID)) > ev_type = CXL_CPER_EVENT_MEM_MODULE; > > - cxl_event_trace_record(cxlmd, type, ev_type, uuid, &record->event); > + cxl_event_handle_record(cxlmd, type, ev_type, uuid, &record->event); > } > > static int cxl_clear_event_record(struct cxl_memdev_state *mds, > @@ -979,8 +1070,8 @@ static void cxl_mem_get_records_log(struct cxl_memdev_state *mds, > break; > > for (i = 0; i < nr_rec; i++) > - __cxl_event_trace_record(cxlmd, type, > - &payload->records[i]); > + __cxl_event_handle_record(cxlmd, type, > + &payload->records[i]); > > if (payload->flags & CXL_GET_EVENT_FLAG_OVERFLOW) > trace_cxl_overflow(cxlmd, type, payload); > diff --git a/drivers/cxl/cxlmem.h b/drivers/cxl/cxlmem.h > index 36cee9c30ceb..ba1347de5651 100644 > --- a/drivers/cxl/cxlmem.h > +++ b/drivers/cxl/cxlmem.h > @@ -822,10 +822,10 @@ void set_exclusive_cxl_commands(struct cxl_memdev_state *mds, > void clear_exclusive_cxl_commands(struct cxl_memdev_state *mds, > unsigned long *cmds); > void cxl_mem_get_event_records(struct cxl_memdev_state *mds, u32 status); > -void cxl_event_trace_record(const struct cxl_memdev *cxlmd, > - enum cxl_event_log_type type, > - enum cxl_event_type event_type, > - const uuid_t *uuid, union cxl_event *evt); > +void cxl_event_handle_record(struct cxl_memdev *cxlmd, > + enum cxl_event_log_type type, > + enum cxl_event_type event_type, > + const uuid_t *uuid, union cxl_event *evt); > int cxl_set_timestamp(struct cxl_memdev_state *mds); > int cxl_poison_state_init(struct cxl_memdev_state *mds); > int cxl_mem_get_poison(struct cxl_memdev *cxlmd, u64 offset, u64 len, > diff --git a/include/linux/cxl-event.h b/include/linux/cxl-event.h > index 03fa6d50d46f..8189bed76c12 100644 > --- a/include/linux/cxl-event.h > +++ b/include/linux/cxl-event.h > @@ -23,6 +23,20 @@ struct cxl_event_generic { > u8 data[CXL_EVENT_RECORD_DATA_LENGTH]; > } __packed; > > +/* > + * Event transaction type > + * CXL rev 3.0 Section 8.2.9.2.1.1; Table 8-43 > + */ > +enum cxl_event_transaction_type { > + CXL_EVENT_TRANSACTION_UNKNOWN = 0X00, > + CXL_EVENT_TRANSACTION_READ, > + CXL_EVENT_TRANSACTION_WRITE, > + CXL_EVENT_TRANSACTION_SCAN_MEDIA, > + CXL_EVENT_TRANSACTION_INJECT_POISON, > + CXL_EVENT_TRANSACTION_MEDIA_SCRUB, > + CXL_EVENT_TRANSACTION_MEDIA_MANAGEMENT, > +}; > + > /* > * General Media Event Record > * CXL rev 3.0 Section 8.2.9.2.1.1; Table 8-43 > @@ -33,7 +47,7 @@ struct cxl_event_gen_media { > __le64 phys_addr; > u8 descriptor; > u8 type; > - u8 transaction_type; > + u8 transaction_type; /* enum cxl_event_transaction_type */ > u8 validity_flags[2]; > u8 channel; > u8 rank; > @@ -52,7 +66,7 @@ struct cxl_event_dram { > __le64 phys_addr; > u8 descriptor; > u8 type; > - u8 transaction_type; > + u8 transaction_type; /* enum cxl_event_transaction_type */ > u8 validity_flags[2]; > u8 channel; > u8 rank; > -- > 2.34.1 >
Shiyang Ruan wrote: > Currently driver only traces cxl events, poison creation (for both vmem > and pmem type) on cxl memdev is silent. As it should be. > OS needs to be notified then it could handle poison pages in time. No, it was always the case that latent poison is an "action optional" event. I am not understanding the justification for this approach. What breaks if the kernel does not forward events to memory_failure_queue()? Consider that in the CPU consumption case that the firmware first path will do its own memory_failure_queue() and in the native case the MCE handler will take care of this. So that leaves pages that are accessed by DMA or background operation that encounter poison. Those are "action optional" scenarios and it is not clear to me how the driver tells the difference. This needs more precision on which agent is repsonsible for what level of reporting. The distribution of responsibility between ACPI GHES, EDAC, and the CXL driver is messy and I expect this changelog to demonstrate it understands all those considerations. > Per CXL spec, the device error event could be signaled through > FW-First and OS-First methods. > > So, add poison creation event handler in OS-First method: > - Qemu: Why is QEMU relevant for this patch? QEMU is only a development vehicle the upstream enabling should be reference shipping or expected to be shipping hardware implementations. > - CXL device reports POISON creation event to OS by MSI by sending > GMER/DER after injecting a poison record; When you say "inject" here do you mean "add to the poison list if present". Because "inject" to me means the "Inject Poison" Memory Device Command. > - CXL driver: > a. parse the POISON event from GMER/DER; > b. translate poisoned DPA to HPA (PFN); > c. enqueue poisoned PFN to memory_failure's work queue; > > Signed-off-by: Shiyang Ruan <ruansy.fnst@fujitsu.com> > --- > drivers/cxl/core/mbox.c | 119 +++++++++++++++++++++++++++++++++----- > drivers/cxl/cxlmem.h | 8 +-- > include/linux/cxl-event.h | 18 +++++- > 3 files changed, 125 insertions(+), 20 deletions(-) > > diff --git a/drivers/cxl/core/mbox.c b/drivers/cxl/core/mbox.c > index f0f54aeccc87..76af0d73859d 100644 > --- a/drivers/cxl/core/mbox.c > +++ b/drivers/cxl/core/mbox.c > @@ -837,25 +837,116 @@ int cxl_enumerate_cmds(struct cxl_memdev_state *mds) > } > EXPORT_SYMBOL_NS_GPL(cxl_enumerate_cmds, CXL); > > -void cxl_event_trace_record(const struct cxl_memdev *cxlmd, > - enum cxl_event_log_type type, > - enum cxl_event_type event_type, > - const uuid_t *uuid, union cxl_event *evt) > +static void cxl_report_poison(struct cxl_memdev *cxlmd, struct cxl_region *cxlr, > + u64 dpa) > { > - if (event_type == CXL_CPER_EVENT_GEN_MEDIA) > + u64 hpa = cxl_trace_hpa(cxlr, cxlmd, dpa); > + unsigned long pfn = PHYS_PFN(hpa); > + > + if (!IS_ENABLED(CONFIG_MEMORY_FAILURE)) > + return; No need for this check, memory_failure_queue() is already stubbed out in the CONFIG_MEMORY_FAILURE=n case. > + memory_failure_queue(pfn, MF_ACTION_REQUIRED); My expectation is MF_ACTION_REQUIRED is not appropriate for CXL event reported errors since action is only required for direct consumption events and those need not be reported through the device event queue. It would be useful to collaborate with a BIOS firmware engineer so that the kernel ends up with similar logic as is used to set CPER record severity, or at least understands why it would want to be different. See how ghes_handle_memory_failure() determines the memory_failure_queue() flags.
diff --git a/drivers/cxl/core/mbox.c b/drivers/cxl/core/mbox.c index f0f54aeccc87..76af0d73859d 100644 --- a/drivers/cxl/core/mbox.c +++ b/drivers/cxl/core/mbox.c @@ -837,25 +837,116 @@ int cxl_enumerate_cmds(struct cxl_memdev_state *mds) } EXPORT_SYMBOL_NS_GPL(cxl_enumerate_cmds, CXL); -void cxl_event_trace_record(const struct cxl_memdev *cxlmd, - enum cxl_event_log_type type, - enum cxl_event_type event_type, - const uuid_t *uuid, union cxl_event *evt) +static void cxl_report_poison(struct cxl_memdev *cxlmd, struct cxl_region *cxlr, + u64 dpa) { - if (event_type == CXL_CPER_EVENT_GEN_MEDIA) + u64 hpa = cxl_trace_hpa(cxlr, cxlmd, dpa); + unsigned long pfn = PHYS_PFN(hpa); + + if (!IS_ENABLED(CONFIG_MEMORY_FAILURE)) + return; + + memory_failure_queue(pfn, MF_ACTION_REQUIRED); +} + +static int __cxl_report_poison(struct device *dev, void *arg) +{ + struct cxl_endpoint_decoder *cxled; + struct cxl_memdev *cxlmd; + u64 dpa = *(u64 *)arg; + + cxled = to_cxl_endpoint_decoder(dev); + if (!cxled || !cxled->dpa_res || !resource_size(cxled->dpa_res)) + return 0; + + if (cxled->mode == CXL_DECODER_MIXED) { + dev_dbg(dev, "poison list read unsupported in mixed mode\n"); + return 0; + } + + if (dpa > cxled->dpa_res->end || dpa < cxled->dpa_res->start) + return 0; + + cxlmd = cxled_to_memdev(cxled); + cxl_report_poison(cxlmd, cxled->cxld.region, dpa); + + return 1; +} + +static void cxl_event_handle_poison(struct cxl_memdev *cxlmd, u64 dpa) +{ + struct cxl_port *port = cxlmd->endpoint; + + /* + * No region is mapped to this endpoint, that is to say no HPA is + * mapped. + */ + if (!port || !is_cxl_endpoint(port) || + cxl_num_decoders_committed(port) == 0) + return; + + device_for_each_child(&port->dev, &dpa, __cxl_report_poison); +} + +static void cxl_event_handle_general_media(struct cxl_memdev *cxlmd, + enum cxl_event_log_type type, + struct cxl_event_gen_media *rec) +{ + u64 dpa = le64_to_cpu(rec->phys_addr) & CXL_DPA_MASK; + + if (type == CXL_EVENT_TYPE_FAIL) { + switch (rec->transaction_type) { + case CXL_EVENT_TRANSACTION_READ: + case CXL_EVENT_TRANSACTION_WRITE: + case CXL_EVENT_TRANSACTION_INJECT_POISON: + cxl_event_handle_poison(cxlmd, dpa); + break; + default: + break; + } + } +} + +static void cxl_event_handle_dram(struct cxl_memdev *cxlmd, + enum cxl_event_log_type type, + struct cxl_event_dram *rec) +{ + u64 dpa = le64_to_cpu(rec->phys_addr) & CXL_DPA_MASK; + + if (type == CXL_EVENT_TYPE_FAIL) { + switch (rec->transaction_type) { + case CXL_EVENT_TRANSACTION_READ: + case CXL_EVENT_TRANSACTION_WRITE: + case CXL_EVENT_TRANSACTION_INJECT_POISON: + cxl_event_handle_poison(cxlmd, dpa); + break; + default: + break; + } + } +} + +void cxl_event_handle_record(struct cxl_memdev *cxlmd, + enum cxl_event_log_type type, + enum cxl_event_type event_type, + const uuid_t *uuid, union cxl_event *evt) +{ + if (event_type == CXL_CPER_EVENT_GEN_MEDIA) { trace_cxl_general_media(cxlmd, type, &evt->gen_media); - else if (event_type == CXL_CPER_EVENT_DRAM) + cxl_event_handle_general_media(cxlmd, type, &evt->gen_media); + } else if (event_type == CXL_CPER_EVENT_DRAM) { trace_cxl_dram(cxlmd, type, &evt->dram); - else if (event_type == CXL_CPER_EVENT_MEM_MODULE) + cxl_event_handle_dram(cxlmd, type, &evt->dram); + } else if (event_type == CXL_CPER_EVENT_MEM_MODULE) trace_cxl_memory_module(cxlmd, type, &evt->mem_module); else trace_cxl_generic_event(cxlmd, type, uuid, &evt->generic); } -EXPORT_SYMBOL_NS_GPL(cxl_event_trace_record, CXL); +EXPORT_SYMBOL_NS_GPL(cxl_event_handle_record, CXL); -static void __cxl_event_trace_record(const struct cxl_memdev *cxlmd, - enum cxl_event_log_type type, - struct cxl_event_record_raw *record) +static void __cxl_event_handle_record(struct cxl_memdev *cxlmd, + enum cxl_event_log_type type, + struct cxl_event_record_raw *record) { enum cxl_event_type ev_type = CXL_CPER_EVENT_GENERIC; const uuid_t *uuid = &record->id; @@ -867,7 +958,7 @@ static void __cxl_event_trace_record(const struct cxl_memdev *cxlmd, else if (uuid_equal(uuid, &CXL_EVENT_MEM_MODULE_UUID)) ev_type = CXL_CPER_EVENT_MEM_MODULE; - cxl_event_trace_record(cxlmd, type, ev_type, uuid, &record->event); + cxl_event_handle_record(cxlmd, type, ev_type, uuid, &record->event); } static int cxl_clear_event_record(struct cxl_memdev_state *mds, @@ -979,8 +1070,8 @@ static void cxl_mem_get_records_log(struct cxl_memdev_state *mds, break; for (i = 0; i < nr_rec; i++) - __cxl_event_trace_record(cxlmd, type, - &payload->records[i]); + __cxl_event_handle_record(cxlmd, type, + &payload->records[i]); if (payload->flags & CXL_GET_EVENT_FLAG_OVERFLOW) trace_cxl_overflow(cxlmd, type, payload); diff --git a/drivers/cxl/cxlmem.h b/drivers/cxl/cxlmem.h index 36cee9c30ceb..ba1347de5651 100644 --- a/drivers/cxl/cxlmem.h +++ b/drivers/cxl/cxlmem.h @@ -822,10 +822,10 @@ void set_exclusive_cxl_commands(struct cxl_memdev_state *mds, void clear_exclusive_cxl_commands(struct cxl_memdev_state *mds, unsigned long *cmds); void cxl_mem_get_event_records(struct cxl_memdev_state *mds, u32 status); -void cxl_event_trace_record(const struct cxl_memdev *cxlmd, - enum cxl_event_log_type type, - enum cxl_event_type event_type, - const uuid_t *uuid, union cxl_event *evt); +void cxl_event_handle_record(struct cxl_memdev *cxlmd, + enum cxl_event_log_type type, + enum cxl_event_type event_type, + const uuid_t *uuid, union cxl_event *evt); int cxl_set_timestamp(struct cxl_memdev_state *mds); int cxl_poison_state_init(struct cxl_memdev_state *mds); int cxl_mem_get_poison(struct cxl_memdev *cxlmd, u64 offset, u64 len, diff --git a/include/linux/cxl-event.h b/include/linux/cxl-event.h index 03fa6d50d46f..8189bed76c12 100644 --- a/include/linux/cxl-event.h +++ b/include/linux/cxl-event.h @@ -23,6 +23,20 @@ struct cxl_event_generic { u8 data[CXL_EVENT_RECORD_DATA_LENGTH]; } __packed; +/* + * Event transaction type + * CXL rev 3.0 Section 8.2.9.2.1.1; Table 8-43 + */ +enum cxl_event_transaction_type { + CXL_EVENT_TRANSACTION_UNKNOWN = 0X00, + CXL_EVENT_TRANSACTION_READ, + CXL_EVENT_TRANSACTION_WRITE, + CXL_EVENT_TRANSACTION_SCAN_MEDIA, + CXL_EVENT_TRANSACTION_INJECT_POISON, + CXL_EVENT_TRANSACTION_MEDIA_SCRUB, + CXL_EVENT_TRANSACTION_MEDIA_MANAGEMENT, +}; + /* * General Media Event Record * CXL rev 3.0 Section 8.2.9.2.1.1; Table 8-43 @@ -33,7 +47,7 @@ struct cxl_event_gen_media { __le64 phys_addr; u8 descriptor; u8 type; - u8 transaction_type; + u8 transaction_type; /* enum cxl_event_transaction_type */ u8 validity_flags[2]; u8 channel; u8 rank; @@ -52,7 +66,7 @@ struct cxl_event_dram { __le64 phys_addr; u8 descriptor; u8 type; - u8 transaction_type; + u8 transaction_type; /* enum cxl_event_transaction_type */ u8 validity_flags[2]; u8 channel; u8 rank;
Currently driver only traces cxl events, poison creation (for both vmem and pmem type) on cxl memdev is silent. OS needs to be notified then it could handle poison pages in time. Per CXL spec, the device error event could be signaled through FW-First and OS-First methods. So, add poison creation event handler in OS-First method: - Qemu: - CXL device reports POISON creation event to OS by MSI by sending GMER/DER after injecting a poison record; - CXL driver: a. parse the POISON event from GMER/DER; b. translate poisoned DPA to HPA (PFN); c. enqueue poisoned PFN to memory_failure's work queue; Signed-off-by: Shiyang Ruan <ruansy.fnst@fujitsu.com> --- drivers/cxl/core/mbox.c | 119 +++++++++++++++++++++++++++++++++----- drivers/cxl/cxlmem.h | 8 +-- include/linux/cxl-event.h | 18 +++++- 3 files changed, 125 insertions(+), 20 deletions(-)