powerpc/perf/hv-24x7: Define add_event_to_24x7_request()

[firefly-linux-kernel-4.4.55.git] / arch / powerpc / perf / hv-24x7.c

diff --git a/arch/powerpc/perf/hv-24x7.c b/arch/powerpc/perf/hv-24x7.c
index c185dcfe6271e3f30cf4d95d6fb48eeb1e8af390..fe74221a35ffbb535a3921cba19b5349e12bc9ab 100644 (file)
--- a/arch/powerpc/perf/hv-24x7.c
+++ b/arch/powerpc/perf/hv-24x7.c
@@ -985,15 +985,67 @@ static const struct attribute_group *attr_groups[] = {
        NULL,
 };
 
-static unsigned long single_24x7_request(u8 domain, u32 offset, u16 ix,
-                                        u16 lpar, u64 *count)
+static void log_24x7_hcall(struct hv_24x7_request_buffer *request_buffer,
+                       struct hv_24x7_data_result_buffer *result_buffer,
+                       unsigned long ret)
+{
+       struct hv_24x7_request *req;
+
+       req = &request_buffer->requests[0];
+       pr_notice_ratelimited("hcall failed: [%d %#x %#x %d] => "
+                       "ret 0x%lx (%ld) detail=0x%x failing ix=%x\n",
+                       req->performance_domain, req->data_offset,
+                       req->starting_ix, req->starting_lpar_ix, ret, ret,
+                       result_buffer->detailed_rc,
+                       result_buffer->failing_request_ix);
+}
+
+/*
+ * Add the given @event to the next slot in the 24x7 request_buffer.
+ *
+ * Note that H_GET_24X7_DATA hcall allows reading several counters'
+ * values in a single HCALL. We expect the caller to add events to the
+ * request buffer one by one, make the HCALL and process the results.
+ */
+static int add_event_to_24x7_request(struct perf_event *event,
+                               struct hv_24x7_request_buffer *request_buffer)
+{
+       u16 idx;
+       int i;
+       struct hv_24x7_request *req;
+
+       if (request_buffer->num_requests > 254) {
+               pr_devel("Too many requests for 24x7 HCALL %d\n",
+                               request_buffer->num_requests);
+               return -EINVAL;
+       }
+
+       if (is_physical_domain(event_get_domain(event)))
+               idx = event_get_core(event);
+       else
+               idx = event_get_vcpu(event);
+
+       i = request_buffer->num_requests++;
+       req = &request_buffer->requests[i];
+
+       req->performance_domain = event_get_domain(event);
+       req->data_size = cpu_to_be16(8);
+       req->data_offset = cpu_to_be32(event_get_offset(event));
+       req->starting_lpar_ix = cpu_to_be16(event_get_lpar(event)),
+       req->max_num_lpars = cpu_to_be16(1);
+       req->starting_ix = cpu_to_be16(idx);
+       req->max_ix = cpu_to_be16(1);
+
+       return 0;
+}
+
+static unsigned long single_24x7_request(struct perf_event *event, u64 *count)
 {
        unsigned long ret;
 
        struct hv_24x7_request_buffer *request_buffer;
        struct hv_24x7_data_result_buffer *result_buffer;
        struct hv_24x7_result *resb;
-       struct hv_24x7_request *req;
 
        BUILD_BUG_ON(sizeof(*request_buffer) > 4096);
        BUILD_BUG_ON(sizeof(*result_buffer) > 4096);
@@ -1005,17 +1057,10 @@ static unsigned long single_24x7_request(u8 domain, u32 offset, u16 ix,
        memset(result_buffer, 0, 4096);
 
        request_buffer->interface_version = HV_24X7_IF_VERSION_CURRENT;
-       request_buffer->num_requests = 1;
-
-       req = &request_buffer->requests[0];
 
-       req->performance_domain = domain;
-       req->data_size = cpu_to_be16(8);
-       req->data_offset = cpu_to_be32(offset);
-       req->starting_lpar_ix = cpu_to_be16(lpar),
-       req->max_num_lpars = cpu_to_be16(1);
-       req->starting_ix = cpu_to_be16(ix);
-       req->max_ix = cpu_to_be16(1);
+       ret = add_event_to_24x7_request(event, request_buffer);
+       if (ret)
+               return ret;
 
        /*
         * NOTE: Due to variable number of array elements in request and
@@ -1027,11 +1072,7 @@ static unsigned long single_24x7_request(u8 domain, u32 offset, u16 ix,
                        virt_to_phys(result_buffer),  H24x7_DATA_BUFFER_SIZE);
 
        if (ret) {
-               pr_err_ratelimited("hcall failed: %d %#x %#x %d => "
-                               "0x%lx (%ld) detail=0x%x failing ix=%x\n",
-                               domain, offset, ix, lpar, ret, ret,
-                               result_buffer->detailed_rc,
-                               result_buffer->failing_request_ix);
+               log_24x7_hcall(request_buffer, result_buffer, ret);
                goto out;
        }
 
@@ -1042,22 +1083,6 @@ out:
        return ret;
 }
 
-static unsigned long event_24x7_request(struct perf_event *event, u64 *res)
-{
-       u16 idx;
-       unsigned domain = event_get_domain(event);
-
-       if (is_physical_domain(domain))
-               idx = event_get_core(event);
-       else
-               idx = event_get_vcpu(event);
-
-       return single_24x7_request(event_get_domain(event),
-                               event_get_offset(event),
-                               idx,
-                               event_get_lpar(event),
-                               res);
-}
 
 static int h_24x7_event_init(struct perf_event *event)
 {
@@ -1126,7 +1151,7 @@ static int h_24x7_event_init(struct perf_event *event)
        }
 
        /* see if the event complains */
-       if (event_24x7_request(event, &ct)) {
+       if (single_24x7_request(event, &ct)) {
                pr_devel("test hcall failed\n");
                return -EIO;
        }
@@ -1138,7 +1163,7 @@ static u64 h_24x7_get_value(struct perf_event *event)
 {
        unsigned long ret;
        u64 ct;
-       ret = event_24x7_request(event, &ct);
+       ret = single_24x7_request(event, &ct);
        if (ret)
                /* We checked this in event init, shouldn't fail here... */
                return 0;
@@ -1146,7 +1171,7 @@ static u64 h_24x7_get_value(struct perf_event *event)
        return ct;
 }
 
-static void h_24x7_event_update(struct perf_event *event)
+static void h_24x7_event_read(struct perf_event *event)
 {
        s64 prev;
        u64 now;
@@ -1163,7 +1188,7 @@ static void h_24x7_event_start(struct perf_event *event, int flags)
 
 static void h_24x7_event_stop(struct perf_event *event, int flags)
 {
-       h_24x7_event_update(event);
+       h_24x7_event_read(event);
 }
 
 static int h_24x7_event_add(struct perf_event *event, int flags)
@@ -1184,7 +1209,7 @@ static struct pmu h_24x7_pmu = {
        .del         = h_24x7_event_stop,
        .start       = h_24x7_event_start,
        .stop        = h_24x7_event_stop,
-       .read        = h_24x7_event_update,
+       .read        = h_24x7_event_read,
 };
 
 static int hv_24x7_init(void)