Merge branch 'refs/heads/upstream-HEAD' into repo-HEAD

Delphix Engineering · Delphix Engineering · commit 0c52f5b72244 · 2020-03-28T03:29:33.000Z
diff --git a/libdrgn/kdump.c b/libdrgn/kdump.c
@@ -139,3 +139,61 @@ struct drgn_error *drgn_program_set_kdump(struct drgn_program *prog)
 	kdump_free(ctx);
 	return err;
 }
+
+struct drgn_error *drgn_program_cache_prstatus_kdump(struct drgn_program *prog)
+{
+	struct drgn_error *err;
+	kdump_num_t ncpus, i;
+	kdump_status ks;
+
+	ks = kdump_get_number_attr(prog->kdump_ctx, "cpu.number", &ncpus);
+	if (ks != KDUMP_OK) {
+		return drgn_error_format(DRGN_ERROR_OTHER,
+					 "kdump_get_number_attr(cpu.number): %s",
+					 kdump_get_err(prog->kdump_ctx));
+	}
+
+	/*
+	 * Note that in the following loop we never call kdump_attr_unref() on
+	 * prstatus_ref, nor kdump_blob_unpin() on the prstatus blob that we get
+	 * from libkdumpfile. Since drgn is completely read-only as a consumer
+	 * of that library, we "leak" both the attribute reference and blob pin
+	 * until kdump_free() is called which will clean up everything for us.
+	 */
+	for (i = 0; i < ncpus; i++) {
+		/* Enough for the longest possible PRSTATUS attribute name. */
+		char attr_name[64];
+		kdump_attr_ref_t prstatus_ref;
+		kdump_attr_t prstatus_attr;
+		void *prstatus_data;
+		size_t prstatus_size;
+
+		snprintf(attr_name, sizeof(attr_name),
+			 "cpu.%" PRIuFAST64 ".PRSTATUS", i);
+		ks = kdump_attr_ref(prog->kdump_ctx, attr_name, &prstatus_ref);
+		if (ks != KDUMP_OK) {
+			return drgn_error_format(DRGN_ERROR_OTHER,
+						 "kdump_attr_ref(%s): %s",
+						 attr_name,
+						 kdump_get_err(prog->kdump_ctx));
+		}
+
+		ks = kdump_attr_ref_get(prog->kdump_ctx, &prstatus_ref,
+					&prstatus_attr);
+		if (ks != KDUMP_OK) {
+			return drgn_error_format(DRGN_ERROR_OTHER,
+						 "kdump_attr_ref_get(%s): %s",
+						 attr_name,
+						 kdump_get_err(prog->kdump_ctx));
+		}
+
+		prstatus_data = kdump_blob_pin(prstatus_attr.val.blob);
+		prstatus_size = kdump_blob_size(prstatus_attr.val.blob);
+		err = drgn_program_cache_prstatus_entry(prog,
+							prstatus_data,
+							prstatus_size);
+		if (err)
+			return err;
+	}
+	return NULL;
+}
diff --git a/libdrgn/linux_kernel.h b/libdrgn/linux_kernel.h
@@ -34,13 +34,14 @@ linux_kernel_report_debug_info(struct drgn_program *prog,
 #define KDUMP_SIG_LEN (sizeof(KDUMP_SIGNATURE) - 1)
 
 #ifdef WITH_LIBKDUMPFILE
+struct drgn_error *drgn_program_cache_prstatus_kdump(struct drgn_program *prog);
 struct drgn_error *drgn_program_set_kdump(struct drgn_program *prog);
 #else
 static inline struct drgn_error *
 drgn_program_set_kdump(struct drgn_program *prog)
 {
         return drgn_error_create(DRGN_ERROR_INVALID_ARGUMENT,
-	                         "drgn was built without libkdumpfile support");
+				 "drgn was built without libkdumpfile support");
 }
 #endif
 
diff --git a/libdrgn/program.c b/libdrgn/program.c
@@ -684,16 +684,45 @@ drgn_program_load_debug_info(struct drgn_program *prog, const char **paths,
 	return err;
 }
 
-static struct drgn_error *drgn_program_cache_prstatus(struct drgn_program *prog)
+struct drgn_error *drgn_program_cache_prstatus_entry(struct drgn_program *prog,
+						     char *data, size_t size)
 {
-	size_t phnum, i;
+	struct drgn_prstatus_map_entry entry;
 	size_t pr_pid_offset;
+	uint32_t pr_pid;
 	bool bswap;
 
 	pr_pid_offset = drgn_program_is_64_bit(prog) ? 32 : 24;
 	bswap = (drgn_program_is_little_endian(prog) !=
 		 (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__));
 
+	if (size < pr_pid_offset + sizeof(pr_pid))
+		return NULL;
+
+	memcpy(&pr_pid, data + pr_pid_offset, sizeof(pr_pid));
+	if (bswap)
+		pr_pid = bswap_32(pr_pid);
+	if (!pr_pid)
+		return NULL;
+
+	entry.key = pr_pid;
+	entry.value.str = data;
+	entry.value.len = size;
+	if (drgn_prstatus_map_insert(&prog->prstatus_cache, &entry,
+				     NULL) == -1) {
+		return &drgn_enomem;
+	}
+	return NULL;
+}
+
+static struct drgn_error *drgn_program_cache_prstatus(struct drgn_program *prog)
+{
+	size_t phnum, i;
+
+#ifdef WITH_LIBKDUMPFILE
+	if (prog->kdump_ctx)
+		return drgn_program_cache_prstatus_kdump(prog);
+#endif
 	if (elf_getphdrnum(prog->core, &phnum) != 0)
 		return drgn_error_libelf();
 	for (i = 0; i < phnum; i++) {
@@ -720,28 +749,18 @@ static struct drgn_error *drgn_program_cache_prstatus(struct drgn_program *prog)
 		       (offset = gelf_getnote(data, offset, &nhdr, &name_offset,
 					      &desc_offset))) {
 			const char *name;
-			uint32_t pr_pid;
-			struct drgn_prstatus_map_entry entry;
+			struct drgn_error *err;
 
 			name = (char *)data->d_buf + name_offset;
 			if (strncmp(name, "CORE", nhdr.n_namesz) != 0 ||
-			    nhdr.n_type != NT_PRSTATUS ||
-			    nhdr.n_descsz < pr_pid_offset + sizeof(pr_pid))
-				continue;
-			memcpy(&pr_pid,
-			       (char *)data->d_buf + desc_offset + pr_pid_offset,
-			       sizeof(pr_pid));
-			if (bswap)
-				pr_pid = bswap_32(pr_pid);
-			if (!pr_pid)
+			    nhdr.n_type != NT_PRSTATUS)
 				continue;
 
-			entry.key = pr_pid;
-			entry.value.str = (char *)data->d_buf + desc_offset;
-			entry.value.len = nhdr.n_descsz;
-			if (drgn_prstatus_map_insert(&prog->prstatus_cache,
-						     &entry, NULL) == -1)
-				return &drgn_enomem;
+			err = drgn_program_cache_prstatus_entry(prog,
+								(char *)data->d_buf + desc_offset,
+								nhdr.n_descsz);
+			if (err)
+				return err;
 		}
 	}
 	return NULL;
diff --git a/libdrgn/program.h b/libdrgn/program.h
@@ -157,6 +157,15 @@ struct drgn_error *drgn_program_get_dwfl(struct drgn_program *prog, Dwfl **ret);
 struct drgn_error *drgn_program_find_prstatus(struct drgn_program *prog,
 					      uint32_t tid, struct string *ret);
 
+/**
+ * Cache the @c NT_PRSTATUS note provided by @p data in @p prog.
+ *
+ * @param[in] data The pointer to the note data.
+ * @param[in] size Size of data in note.
+ */
+struct drgn_error *drgn_program_cache_prstatus_entry(struct drgn_program *prog,
+                                                     char *data, size_t size);
+
 /*
  * Like @ref drgn_program_find_symbol_by_address(), but @p ret is already
  * allocated, we may already know the module, and doesn't return a @ref
diff --git a/libdrgn/stack_trace.c b/libdrgn/stack_trace.c
@@ -398,8 +398,12 @@ static bool drgn_thread_set_initial_registers(Dwfl_Thread *thread,
 		}
 	}
 
-	/* Then, try the core dump. */
+	/* Then, try the core dump (and/or kdump if supported). */
+#ifdef WITH_LIBKDUMPFILE
+	if (prog->core || prog->kdump_ctx) {
+#else
 	if (prog->core) {
+#endif
 		uint32_t tid;
 		struct string prstatus;
 
diff --git a/tests/helpers/linux/test_block.py b/tests/helpers/linux/test_block.py
@@ -1,5 +1,9 @@
+import errno
+from fcntl import ioctl
 import os
 import os.path
+import sys
+import tempfile
 
 from drgn.helpers.linux.block import (
     disk_devt,
@@ -9,11 +13,63 @@
     part_devt,
     part_name,
 )
-from drgn.helpers.linux.device import MAJOR, MINOR
+from drgn.helpers.linux.device import MAJOR, MINOR, MKDEV
 from tests.helpers.linux import LinuxHelperTestCase
 
 
+LOOP_SET_FD = 0x4C00
+LOOP_SET_STATUS64 = 0x4C04
+LOOP_GET_STATUS64 = 0x4C05
+LOOP_CTL_GET_FREE = 0x4C82
+
+LO_FLAGS_AUTOCLEAR = 4
+
+
 class TestBlock(LinuxHelperTestCase):
+    @staticmethod
+    def _losetup():
+        with tempfile.TemporaryFile() as temp:
+            os.truncate(temp.fileno(), 1024 * 1024 * 1024)
+            with open("/dev/loop-control", "r") as loop_control:
+                while True:
+                    index = ioctl(loop_control.fileno(), LOOP_CTL_GET_FREE)
+                    close_loop = True
+                    loop = open(f"/dev/loop{index}", "r")
+                    try:
+                        try:
+                            ioctl(loop.fileno(), LOOP_SET_FD, temp.fileno())
+                        except OSError as e:
+                            if e.errno == errno.EBUSY:
+                                continue
+                            raise
+                        info = bytearray(232)  # sizeof(struct loop_info64)
+                        ioctl(loop.fileno(), LOOP_GET_STATUS64, info)
+                        lo_flags = int.from_bytes(info[52:56], sys.byteorder)
+                        lo_flags |= LO_FLAGS_AUTOCLEAR
+                        info[52:56] = lo_flags.to_bytes(4, sys.byteorder)
+                        ioctl(loop.fileno(), LOOP_SET_STATUS64, info, False)
+                        close_loop = False
+                        return loop
+                    finally:
+                        if close_loop:
+                            loop.close()
+
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+        # Try to set up a loop device so that there's at least one block
+        # device.
+        try:
+            cls.loop = cls._losetup()
+        except OSError:
+            cls.loop = None
+
+    @classmethod
+    def tearDownClass(cls):
+        if cls.loop:
+            cls.loop.close()
+        super().tearDownClass()
+
     def test_disk_devt(self):
         for disk in for_each_disk(self.prog):
             path = os.path.join(b"/sys/block", disk_name(disk), b"dev")
@@ -24,8 +80,8 @@ def test_disk_devt(self):
 
     def test_for_each_disk(self):
         self.assertEqual(
-            set(os.listdir("/sys/block")),
             {disk_name(disk).decode() for disk in for_each_disk(self.prog)},
+            set(os.listdir("/sys/block")),
         )
 
     def test_part_devt(self):
@@ -36,8 +92,32 @@ def test_part_devt(self):
             devt = part_devt(part).value_()
             self.assertEqual(f"{MAJOR(devt)}:{MINOR(devt)}", expected)
 
-    def test_for_each_part(self):
+    def test_for_each_partition(self):
         self.assertEqual(
-            set(os.listdir("/sys/class/block")),
             {part_name(part).decode() for part in for_each_partition(self.prog)},
+            set(os.listdir("/sys/class/block")),
         )
+
+    def test_loop_disk(self):
+        if not self.loop:
+            self.skipTest("could not create loop device")
+        rdev = os.stat(self.loop.fileno()).st_rdev
+        devt = MKDEV(os.major(rdev), os.minor(rdev))
+        for disk in for_each_disk(self.prog):
+            if disk_devt(disk) == devt:
+                break
+        else:
+            self.fail("loop disk not found")
+        self.assertEqual(disk_name(disk), os.path.basename(self.loop.name).encode())
+
+    def test_loop_part(self):
+        if not self.loop:
+            self.skipTest("could not create loop device")
+        rdev = os.stat(self.loop.fileno()).st_rdev
+        devt = MKDEV(os.major(rdev), os.minor(rdev))
+        for part in for_each_partition(self.prog):
+            if part_devt(part) == devt:
+                break
+        else:
+            self.fail("loop partition not found")
+        self.assertEqual(part_name(part), os.path.basename(self.loop.name).encode())

Original file line number	Diff line number	Diff line change
`@@ -34,13 +34,14 @@ linux_kernel_report_debug_info(struct drgn_program *prog,`
`34`	`34`	`#define KDUMP_SIG_LEN (sizeof(KDUMP_SIGNATURE) - 1)`
`35`	`35`
`36`	`36`	`#ifdef WITH_LIBKDUMPFILE`
	`37`	`+struct drgn_error drgn_program_cache_prstatus_kdump(struct drgn_program prog);`
`37`	`38`	`struct drgn_error drgn_program_set_kdump(struct drgn_program prog);`
`38`	`39`	`#else`
`39`	`40`	`static inline struct drgn_error *`
`40`	`41`	`drgn_program_set_kdump(struct drgn_program *prog)`
`41`	`42`	`{`
`42`	`43`	`return drgn_error_create(DRGN_ERROR_INVALID_ARGUMENT,`
`43`		`- "drgn was built without libkdumpfile support");`
	`44`	`+ "drgn was built without libkdumpfile support");`
`44`	`45`	`}`
`45`	`46`	`#endif`
`46`	`47`
Original file line number	Diff line number	Diff line change
`@@ -398,8 +398,12 @@ static bool drgn_thread_set_initial_registers(Dwfl_Thread *thread,`
`398`	`398`	`}`
`399`	`399`	`}`
`400`	`400`
`401`		`- /* Then, try the core dump. */`
	`401`	`+ /* Then, try the core dump (and/or kdump if supported). */`
	`402`	`+#ifdef WITH_LIBKDUMPFILE`
	`403`	`+ if (prog->core \|\| prog->kdump_ctx) {`
	`404`	`+#else`
`402`	`405`	`if (prog->core) {`
	`406`	`+#endif`
`403`	`407`	`uint32_t tid;`
`404`	`408`	`struct string prstatus;`
`405`	`409`