DLPX-78888 [Backport of DLPX-78812 to 6.0.12] Disk IO analytics collector not running on aws

.github/scripts/flake8_stbtrace.sh

@@ -0,0 +1,33 @@
+#/bin/bash
+#
+# Copyright (c) 2020 by Delphix. All rights reserved.
+#
+# SPDX-License-Identifier: GPL-2.0-or-later
+#
+
+#
+# This provides flake8 linting for the various stbtrace templates. It uses
+# stbtrace with the '--bcc' flag to produce and print Python code, and then
+# runs flake8 against that.
+#
+
+set -o pipefail
+
+function die() {
+        echo "$(basename "$0"): $*" >&2
+        exit 1
+}
+
+prgms=$(find ./bpf/stbtrace -name '*.st' | xargs basename --suffix='.st') ||
+	die "Failed to generate list of stbtrace programs"
+
+for prgm in $prgms; do
+	echo "Checking stbtrace program $prgm..."
+	./cmd/stbtrace.py $prgm --bcc >/tmp/$prgm.py ||
+		die "Failed to generate python source"
+	flake8 /tmp/$prgm.py --show-source || die "flake8 errors found in" \
+		"'bpf/stbtrace/$prgm.st'. Line numbers in error messages" \
+		"correspond to the output of './cmd/stbtrace.py $prgm --bcc'"
+done
+
+exit 0

.github/workflows/flake8.yml

@@ -5,15 +5,15 @@ on: [pull_request, push]
 jobs:
   build:
     runs-on: ubuntu-latest
-
     steps:
     - uses: actions/checkout@v1
     - name: Set up Python
       uses: actions/setup-python@v1
       with:
-        python-version: 2.7
+        python-version: 3.6
     - name: flake8
       run: |
         python -m pip install --upgrade pip
         pip install flake8
         flake8 . --show-source --statistics
+        ./.github/scripts/flake8_stbtrace.sh

bpf/estat/backend-io.c

@@ -15,22 +15,20 @@
 #define	READ_STR "read "
 #define	WRITE_STR "write "
 #define	OP_NAME_LEN 7
-#define	DEV_NAME_LEN 8
 #define	NAME_LENGTH (OP_NAME_LEN + 1)
-#define	AXIS_LENGTH (DEV_NAME_LEN + 1)
+#define	AXIS_LENGTH (DISK_NAME_LEN + 1)
 
 // Structure to hold thread local data
 typedef struct {
 	u64 ts;
 	unsigned int size;
 	unsigned int cmd_flags;
 	u32 err;
-	char device[DEV_NAME_LEN];
+	char device[DISK_NAME_LEN];
 } io_data_t;
 
 BPF_HASH(io_base_data, u64, io_data_t);
 
-// @@ kprobe|blk_start_request|disk_io_start
 // @@ kprobe|blk_mq_start_request|disk_io_start
 int
 disk_io_start(struct pt_regs *ctx, struct request *reqp)
@@ -40,12 +38,12 @@ disk_io_start(struct pt_regs *ctx, struct request *reqp)
 	data.ts = bpf_ktime_get_ns();
 	data.cmd_flags = reqp->cmd_flags;
 	data.size = reqp->__data_len;
-	__builtin_memcpy(&data.device, diskp->disk_name, DEV_NAME_LEN);
+	bpf_probe_read_str(&data.device, DISK_NAME_LEN, diskp->disk_name);
 	io_base_data.update((u64 *) &reqp, &data);
 	return (0);
 }
 
-// @@ kprobe|blk_account_io_completion|disk_io_done
+// @@ kprobe|blk_account_io_done|disk_io_done
 int
 disk_io_done(struct pt_regs *ctx, struct request *reqp)
 {

bpf/estat/iscsi.c

@@ -4,6 +4,24 @@
  * SPDX-License-Identifier: GPL-2.0-or-later
  */
 
+/* 
+ * This tracer provides latency and througphput data for the iscsi target 
+ * read and writes. The latency is measured from entering 
+ * iscsit_process_scsi_cmd() to exiting iscsit_target_response(). The
+ * thread that enters iscsi_process_scsi_cmd() will put an entry on the
+ * request task queue. This entry will be removed from the queue and
+ * processed by another thread which calls iscsi_target_response.
+ * The tracing is performed by three probe functions.
+ * 1. iscsi_target_start - This function saves a timestamp of the entry
+ *    into iscsit_process_scsi_cmd() hashed by a pointer to the iscssi_cmd.
+ * 2. iscsi_target_response - This function serves the purpose of moving
+ *    the timestamp saved by iscsi_target_start to a thread id based hash.
+ *    Also the size and direction are stored in the hash since kretprobes
+ *    do not have access to parameters.
+ * 3. iscsi_target_end - This function retrieves the hashed base data by
+ *    thread id and performs the data aggregation.
+ */
+
 #include <uapi/linux/ptrace.h>
 #include <linux/bpf_common.h>
 #include <uapi/linux/bpf.h>
@@ -19,23 +37,21 @@
 
 typedef struct {
 	u64 ts;
-	u64 flags;
 	u64 size;
+	u32 direction;
 } iscsi_data_t;
 
 
-BPF_HASH(iscsi_base_data, u64, iscsi_data_t);
+BPF_HASH(iscsi_start_ts, u64, u64);
+BPF_HASH(iscsi_base_data, u32, iscsi_data_t);
 
 // @@ kprobe|iscsit_process_scsi_cmd|iscsi_target_start
 int
 iscsi_target_start(struct pt_regs *ctx, struct iscsi_conn *conn,
     struct iscsi_cmd *cmd, struct iscsi_scsi_req *hdr)
 {
-	iscsi_data_t data = {};
-	data.ts = bpf_ktime_get_ns();
-	data.flags = hdr->flags;
-	data.size = hdr->data_length;
-	iscsi_base_data.update((u64 *) &cmd, &data);
+	u64 ts = bpf_ktime_get_ns();
+	iscsi_start_ts.update((u64 *) &cmd, &ts);
 
 	return (0);
 }
@@ -55,24 +71,48 @@ aggregate_data(iscsi_data_t *data, u64 ts, char *opstr)
 	return (0);
 }
 
-// @@ kprobe|iscsit_build_rsp_pdu|iscsi_target_end
+
+
+// @@ kprobe|iscsit_response_queue|iscsi_target_response
 int
-iscsi_target_end(struct pt_regs *ctx, struct iscsi_cmd *cmd)
+iscsi_target_response(struct pt_regs *ctx, struct iscsi_conn *conn, struct iscsi_cmd *cmd, int state)
+{
+	u32 tid = bpf_get_current_pid_tgid();
+	iscsi_data_t data = {};
+
+	u64 *tsp = iscsi_start_ts.lookup((u64 *) &cmd);
+	if (tsp == 0) {
+		return (0);   // missed issue
+	}
+
+	data.ts = *tsp;
+	data.size = cmd->se_cmd.data_length;
+	data.direction = cmd->data_direction;
+
+	iscsi_base_data.update(&tid, &data);
+	iscsi_start_ts.delete((u64 *) &cmd);
+
+	return (0);
+}
+
+// @@ kretprobe|iscsit_response_queue|iscsi_target_end
+int
+iscsi_target_end(struct pt_regs *ctx)
 {
 	u64 ts = bpf_ktime_get_ns();
-	iscsi_data_t *data = iscsi_base_data.lookup((u64 *) &cmd);
-	u64 delta;
+	u32 tid = bpf_get_current_pid_tgid();
+	iscsi_data_t *data = iscsi_base_data.lookup(&tid);
 
 	if (data == 0) {
 		return (0);   // missed issue
 	}
 
-	if (data->flags & ISCSI_FLAG_CMD_READ) {
+	if (data->direction == DMA_FROM_DEVICE) {
 		aggregate_data(data, ts, READ_STR);
-	} else if (data->flags & ISCSI_FLAG_CMD_WRITE) {
+	} else if (data->direction == DMA_TO_DEVICE) {
 		aggregate_data(data, ts, WRITE_STR);
 	}
-	iscsi_base_data.delete((u64 *) &cmd);
+	iscsi_base_data.delete(&tid);
 
 	return (0);
 }

bpf/estat/metaslab-alloc.c

@@ -0,0 +1,141 @@
+/*
+ * Copyright 2020 Delphix. All rights reserved.
+ *
+ * SPDX-License-Identifier: GPL-2.0-or-later
+ */
+
+#include <sys/metaslab.h>
+#include <sys/metaslab_impl.h>
+#include <sys/vdev_impl.h>
+#include <sys/spa_impl.h>
+
+#define VD_NAME_SIZE 32
+typedef struct {
+	u64 ts;
+	u64 size;
+	u64 asize;
+	u64 alloc_time;
+	char vd_name[VD_NAME_SIZE];
+} data_t;
+
+BPF_HASH(data_map, u32, data_t);
+
+#ifndef OPTARG
+#define	POOL "domain0"
+#else
+#define	POOL (OPTARG)
+#endif
+
+static inline bool
+equal_to_pool(char *str)
+{
+	char comparand[sizeof (POOL)];
+	bpf_probe_read(&comparand, sizeof (comparand), str);
+	char compare[] = POOL;
+
+	for (int i = 0; i < sizeof (comparand); ++i)
+		if (compare[i] != comparand[i])
+			return (false);
+
+	return (true);
+}
+
+// @@ kprobe|metaslab_alloc_dva|metaslab_alloc_dva_entry
+int
+metaslab_alloc_dva_entry(struct pt_regs *ctx,
+    spa_t *spa, metaslab_class_t *mc, uint64_t psize)
+{
+	u32 tid = bpf_get_current_pid_tgid();
+	data_t data = {};
+
+	if (!equal_to_pool(spa->spa_name))
+		return (0);
+
+	data.ts = bpf_ktime_get_ns();
+	data.size = psize;
+
+	data_map.update(&tid, &data);
+
+	return (0);
+}
+
+// @@ kprobe|metaslab_group_alloc|metaslab_group_alloc_entry
+int
+metaslab_group_alloc_entry(struct pt_regs *ctx,
+    metaslab_group_t *mg, zio_alloc_list_t *zal, uint64_t asize)
+{
+	u32 tid = bpf_get_current_pid_tgid();
+	data_t *data = data_map.lookup(&tid);
+
+	if (data == NULL || data->ts == 0)
+		return (0);
+
+	data->asize = asize;
+	data->alloc_time = bpf_ktime_get_ns();
+
+	if (mg->mg_vd->vdev_path != NULL) {
+		bpf_probe_read_str(data->vd_name,
+		    sizeof(data->vd_name), mg->mg_vd->vdev_path);
+	} else {
+		bpf_probe_read_str(data->vd_name,
+		    sizeof(data->vd_name), mg->mg_vd->vdev_ops->vdev_op_type);
+	}
+
+	return (0);
+}
+
+// @@ kretprobe|metaslab_group_alloc|metaslab_group_alloc_exit
+int
+metaslab_group_alloc_exit(struct pt_regs *ctx)
+{
+	u32 tid = bpf_get_current_pid_tgid();
+	data_t *data = data_map.lookup(&tid);
+	char failure[] = "failure";
+	char success[] = "success";
+	char *axis;
+
+	if (data == NULL || data->ts == 0)
+		return (0);
+
+	if (PT_REGS_RC(ctx) == -1ULL) {
+		axis = failure;
+	} else {
+		axis = success;
+	}
+
+	AGGREGATE_DATA(data->vd_name, axis,
+		bpf_ktime_get_ns() - data->ts, data->asize);
+
+	data->asize = 0;
+	data->alloc_time = 0;
+	data->vd_name[0] = '\0';
+
+	return (0);
+}
+
+// @@ kretprobe|metaslab_alloc_dva|metaslab_alloc_dva_exit
+int
+metaslab_alloc_dva_exit(struct pt_regs *ctx,
+    spa_t *spa, metaslab_class_t *mc, uint64_t psize)
+{
+	u32 tid = bpf_get_current_pid_tgid();
+	data_t *data = data_map.lookup(&tid);
+
+	if (data == NULL || data->ts == 0)
+		return (0);
+
+	if (PT_REGS_RC(ctx) == 0)
+		return (0);
+
+	char name[] = "allocation failures";
+	char axis = 0;
+	AGGREGATE_DATA(name, &axis,
+		bpf_ktime_get_ns() - data->ts, data->size);
+
+	data->ts = 0;
+	data->size = 0;
+
+	data_map.delete(&tid);
+
+	return (0);
+}