11633617038

Committed 01 Nov 2024 05:30PM UTC coverage: 52.875% (-0.01%) from 52.888%

Build # 11633617038

Build Type

push

github

Committed by

superm1

Commit Message

amd-gpu: Allow emulating getting the drm device file

Run Details

20469 of 35764 branches covered (57.23%)

Branch coverage included in aggregate %.

16 of 27 new or added lines in 1 file covered. (59.26%)

1098 existing lines in 16 files now uncovered.

64238 of 124438 relevant lines covered (51.62%)

25306.53 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

73.33

/plugins/bcm57xx/fu-bcm57xx-plugin.c

/*
 * Copyright 2020 Richard Hughes <richard@hughsie.com>
 *
 * SPDX-License-Identifier: LGPL-2.1-or-later
 */

#include "config.h"

#include "fu-bcm57xx-device.h"
#include "fu-bcm57xx-dict-image.h"
#include "fu-bcm57xx-firmware.h"
#include "fu-bcm57xx-plugin.h"
#include "fu-bcm57xx-recovery-device.h"
#include "fu-bcm57xx-stage1-image.h"
#include "fu-bcm57xx-stage2-image.h"

struct _FuBcm57XxPlugin {
        FuPlugin parent_instance;
};

G_DEFINE_TYPE(FuBcm57XxPlugin, fu_bcm57xx_plugin, FU_TYPE_PLUGIN)

static gboolean
fu_bcm57xx_plugin_backend_device_added(FuPlugin *plugin,
                                       FuDevice *device,
                                       FuProgress *progress,
                                       GError **error)
{
        gboolean exists_net = FALSE;
        g_autofree gchar *fn = NULL;
        g_autoptr(GPtrArray) ifaces = NULL;
        g_autoptr(FuDevice) dev = NULL;
        g_autoptr(FuDeviceLocker) locker = NULL;

        /* only enumerate number 0 */
        if (fu_udev_device_get_number(FU_UDEV_DEVICE(device)) != 0) {
                g_set_error_literal(error,
                                    FWUPD_ERROR,
                                    FWUPD_ERROR_NOT_SUPPORTED,
                                    "only device 0 supported on multi-device card");
                return FALSE;
        }

        /* is in recovery mode if has no ethtool interface */
        if (fu_device_has_flag(device, FWUPD_DEVICE_FLAG_EMULATED)) {
                dev = g_object_new(FU_TYPE_BCM57XX_DEVICE, "iface", "enp81s0f0", NULL);
        } else {
                fn = g_build_filename(fu_udev_device_get_sysfs_path(FU_UDEV_DEVICE(device)),
                                      "net",
                                      NULL);
                if (!fu_device_query_file_exists(device, fn, &exists_net, error))
                        return FALSE;
                if (!exists_net) {
                        g_debug("waiting for net devices to appear");
                        fu_device_sleep(device, 50); /* ms */
                }
                ifaces = fu_path_glob(fn, "en*", NULL);
                if (ifaces == NULL || ifaces->len == 0) {
                        dev = g_object_new(FU_TYPE_BCM57XX_RECOVERY_DEVICE, NULL);
                } else {
                        g_autofree gchar *ethtool_iface =
                            g_path_get_basename(g_ptr_array_index(ifaces, 0));
                        dev = g_object_new(FU_TYPE_BCM57XX_DEVICE, "iface", ethtool_iface, NULL);
                }
        }
        fu_device_incorporate(dev, device, FU_DEVICE_INCORPORATE_FLAG_ALL);
        locker = fu_device_locker_new(dev, error);
        if (locker == NULL)
                return FALSE;
        fu_plugin_device_add(plugin, dev);
        return TRUE;
}

static void
fu_bcm57xx_plugin_init(FuBcm57XxPlugin *self)
{
}

static void
fu_bcm57xx_plugin_object_constructed(GObject *obj)
{
        FuPlugin *plugin = FU_PLUGIN(obj);
        fu_plugin_set_name(plugin, "bcm57xx");
}

static void
fu_bcm57xx_plugin_constructed(GObject *obj)
{
        FuPlugin *plugin = FU_PLUGIN(obj);
        fu_plugin_add_udev_subsystem(plugin, "pci");
        fu_plugin_add_device_gtype(plugin, FU_TYPE_BCM57XX_DEVICE);
        fu_plugin_add_device_gtype(plugin, FU_TYPE_BCM57XX_RECOVERY_DEVICE);
        fu_plugin_add_firmware_gtype(plugin, NULL, FU_TYPE_BCM57XX_FIRMWARE);
        fu_plugin_add_firmware_gtype(plugin, NULL, FU_TYPE_BCM57XX_DICT_IMAGE);
        fu_plugin_add_firmware_gtype(plugin, NULL, FU_TYPE_BCM57XX_STAGE1_IMAGE);
        fu_plugin_add_firmware_gtype(plugin, NULL, FU_TYPE_BCM57XX_STAGE2_IMAGE);
        fu_plugin_add_rule(plugin, FU_PLUGIN_RULE_BETTER_THAN, "optionrom");
}

static void
fu_bcm57xx_plugin_class_init(FuBcm57XxPluginClass *klass)
{
        FuPluginClass *plugin_class = FU_PLUGIN_CLASS(klass);
        GObjectClass *object_class = G_OBJECT_CLASS(klass);
        object_class->constructed = fu_bcm57xx_plugin_object_constructed;
        plugin_class->constructed = fu_bcm57xx_plugin_constructed;
        plugin_class->backend_device_added = fu_bcm57xx_plugin_backend_device_added;
}

1	/*
2	* Copyright 2020 Richard Hughes <richard@hughsie.com>
3	*
4	* SPDX-License-Identifier: LGPL-2.1-or-later
5	*/
6
7	#include "config.h"
8
9	#include "fu-bcm57xx-device.h"
10	#include "fu-bcm57xx-dict-image.h"
11	#include "fu-bcm57xx-firmware.h"
12	#include "fu-bcm57xx-plugin.h"
13	#include "fu-bcm57xx-recovery-device.h"
14	#include "fu-bcm57xx-stage1-image.h"
15	#include "fu-bcm57xx-stage2-image.h"
16
17	struct _FuBcm57XxPlugin {
18	FuPlugin parent_instance;
19	};
20
21	G_DEFINE_TYPE(FuBcm57XxPlugin, fu_bcm57xx_plugin, FU_TYPE_PLUGIN)	342✔
22
23	static gboolean
24	fu_bcm57xx_plugin_backend_device_added(FuPlugin *plugin,	2✔
25	FuDevice *device,
26	FuProgress *progress,
27	GError **error)
28	{
29	gboolean exists_net = FALSE;	2✔
30	g_autofree gchar *fn = NULL;	4✔
31	g_autoptr(GPtrArray) ifaces = NULL;	2✔
32	g_autoptr(FuDevice) dev = NULL;	2✔
33	g_autoptr(FuDeviceLocker) locker = NULL;	2✔
34
35	/* only enumerate number 0 */
36	if (fu_udev_device_get_number(FU_UDEV_DEVICE(device)) != 0) {	2✔
UNCOV 37	g_set_error_literal(error,	×
38	FWUPD_ERROR,
39	FWUPD_ERROR_NOT_SUPPORTED,
40	"only device 0 supported on multi-device card");
UNCOV 41	return FALSE;	×
42	}
43
44	/* is in recovery mode if has no ethtool interface */
45	if (fu_device_has_flag(device, FWUPD_DEVICE_FLAG_EMULATED)) {	2✔
46	dev = g_object_new(FU_TYPE_BCM57XX_DEVICE, "iface", "enp81s0f0", NULL);	2✔
47	} else {
UNCOV 48	fn = g_build_filename(fu_udev_device_get_sysfs_path(FU_UDEV_DEVICE(device)),	×
49	"net",
50	NULL);
51	if (!fu_device_query_file_exists(device, fn, &exists_net, error))	×
52	return FALSE;
UNCOV 53	if (!exists_net) {	×
54	g_debug("waiting for net devices to appear");	×
55	fu_device_sleep(device, 50); /* ms */	×
56	}
UNCOV 57	ifaces = fu_path_glob(fn, "en*", NULL);	×
58	if (ifaces == NULL \|\| ifaces->len == 0) {	×
59	dev = g_object_new(FU_TYPE_BCM57XX_RECOVERY_DEVICE, NULL);	×
60	} else {
UNCOV 61	g_autofree gchar *ethtool_iface =	×
UNCOV 62	g_path_get_basename(g_ptr_array_index(ifaces, 0));	×
UNCOV 63	dev = g_object_new(FU_TYPE_BCM57XX_DEVICE, "iface", ethtool_iface, NULL);	×
64	}
65	}
66	fu_device_incorporate(dev, device, FU_DEVICE_INCORPORATE_FLAG_ALL);	2✔
67	locker = fu_device_locker_new(dev, error);	2✔
68	if (locker == NULL)	2✔
69	return FALSE;
70	fu_plugin_device_add(plugin, dev);	2✔
71	return TRUE;	2✔
72	}
73
74	static void
75	fu_bcm57xx_plugin_init(FuBcm57XxPlugin *self)	69✔
76	{
77	}	69✔
78
79	static void
80	fu_bcm57xx_plugin_object_constructed(GObject *obj)	69✔
81	{
82	FuPlugin *plugin = FU_PLUGIN(obj);	69✔
83	fu_plugin_set_name(plugin, "bcm57xx");	69✔
84	}	69✔
85
86	static void
87	fu_bcm57xx_plugin_constructed(GObject *obj)	51✔
88	{
89	FuPlugin *plugin = FU_PLUGIN(obj);	51✔
90	fu_plugin_add_udev_subsystem(plugin, "pci");	51✔
91	fu_plugin_add_device_gtype(plugin, FU_TYPE_BCM57XX_DEVICE);	51✔
92	fu_plugin_add_device_gtype(plugin, FU_TYPE_BCM57XX_RECOVERY_DEVICE);	51✔
93	fu_plugin_add_firmware_gtype(plugin, NULL, FU_TYPE_BCM57XX_FIRMWARE);	51✔
94	fu_plugin_add_firmware_gtype(plugin, NULL, FU_TYPE_BCM57XX_DICT_IMAGE);	51✔
95	fu_plugin_add_firmware_gtype(plugin, NULL, FU_TYPE_BCM57XX_STAGE1_IMAGE);	51✔
96	fu_plugin_add_firmware_gtype(plugin, NULL, FU_TYPE_BCM57XX_STAGE2_IMAGE);	51✔
97	fu_plugin_add_rule(plugin, FU_PLUGIN_RULE_BETTER_THAN, "optionrom");	51✔
98	}	51✔
99
100	static void
101	fu_bcm57xx_plugin_class_init(FuBcm57XxPluginClass *klass)	51✔
102	{
103	FuPluginClass *plugin_class = FU_PLUGIN_CLASS(klass);	51✔
104	GObjectClass *object_class = G_OBJECT_CLASS(klass);	51✔
105	object_class->constructed = fu_bcm57xx_plugin_object_constructed;	51✔
106	plugin_class->constructed = fu_bcm57xx_plugin_constructed;	51✔
107	plugin_class->backend_device_added = fu_bcm57xx_plugin_backend_device_added;	51✔
108	}

fwupd / fwupd / 11633617038

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous