forked from Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
178 lines
4.4 KiB
178 lines
4.4 KiB
// SPDX-License-Identifier: GPL-2.0-only |
|
/* |
|
* Authors: |
|
* Branden Bonaby <[email protected]> |
|
*/ |
|
|
|
#include <linux/hyperv.h> |
|
#include <linux/debugfs.h> |
|
#include <linux/delay.h> |
|
#include <linux/err.h> |
|
|
|
#include "hyperv_vmbus.h" |
|
|
|
static struct dentry *hv_debug_root; |
|
|
|
static int hv_debugfs_delay_get(void *data, u64 *val) |
|
{ |
|
*val = *(u32 *)data; |
|
return 0; |
|
} |
|
|
|
static int hv_debugfs_delay_set(void *data, u64 val) |
|
{ |
|
if (val > 1000) |
|
return -EINVAL; |
|
*(u32 *)data = val; |
|
return 0; |
|
} |
|
|
|
DEFINE_DEBUGFS_ATTRIBUTE(hv_debugfs_delay_fops, hv_debugfs_delay_get, |
|
hv_debugfs_delay_set, "%llu\n"); |
|
|
|
static int hv_debugfs_state_get(void *data, u64 *val) |
|
{ |
|
*val = *(bool *)data; |
|
return 0; |
|
} |
|
|
|
static int hv_debugfs_state_set(void *data, u64 val) |
|
{ |
|
if (val == 1) |
|
*(bool *)data = true; |
|
else if (val == 0) |
|
*(bool *)data = false; |
|
else |
|
return -EINVAL; |
|
return 0; |
|
} |
|
|
|
DEFINE_DEBUGFS_ATTRIBUTE(hv_debugfs_state_fops, hv_debugfs_state_get, |
|
hv_debugfs_state_set, "%llu\n"); |
|
|
|
/* Setup delay files to store test values */ |
|
static int hv_debug_delay_files(struct hv_device *dev, struct dentry *root) |
|
{ |
|
struct vmbus_channel *channel = dev->channel; |
|
char *buffer = "fuzz_test_buffer_interrupt_delay"; |
|
char *message = "fuzz_test_message_delay"; |
|
int *buffer_val = &channel->fuzz_testing_interrupt_delay; |
|
int *message_val = &channel->fuzz_testing_message_delay; |
|
struct dentry *buffer_file, *message_file; |
|
|
|
buffer_file = debugfs_create_file(buffer, 0644, root, |
|
buffer_val, |
|
&hv_debugfs_delay_fops); |
|
if (IS_ERR(buffer_file)) { |
|
pr_debug("debugfs_hyperv: file %s not created\n", buffer); |
|
return PTR_ERR(buffer_file); |
|
} |
|
|
|
message_file = debugfs_create_file(message, 0644, root, |
|
message_val, |
|
&hv_debugfs_delay_fops); |
|
if (IS_ERR(message_file)) { |
|
pr_debug("debugfs_hyperv: file %s not created\n", message); |
|
return PTR_ERR(message_file); |
|
} |
|
|
|
return 0; |
|
} |
|
|
|
/* Setup test state value for vmbus device */ |
|
static int hv_debug_set_test_state(struct hv_device *dev, struct dentry *root) |
|
{ |
|
struct vmbus_channel *channel = dev->channel; |
|
bool *state = &channel->fuzz_testing_state; |
|
char *status = "fuzz_test_state"; |
|
struct dentry *test_state; |
|
|
|
test_state = debugfs_create_file(status, 0644, root, |
|
state, |
|
&hv_debugfs_state_fops); |
|
if (IS_ERR(test_state)) { |
|
pr_debug("debugfs_hyperv: file %s not created\n", status); |
|
return PTR_ERR(test_state); |
|
} |
|
|
|
return 0; |
|
} |
|
|
|
/* Bind hv device to a dentry for debugfs */ |
|
static void hv_debug_set_dir_dentry(struct hv_device *dev, struct dentry *root) |
|
{ |
|
if (hv_debug_root) |
|
dev->debug_dir = root; |
|
} |
|
|
|
/* Create all test dentry's and names for fuzz testing */ |
|
int hv_debug_add_dev_dir(struct hv_device *dev) |
|
{ |
|
const char *device = dev_name(&dev->device); |
|
char *delay_name = "delay"; |
|
struct dentry *delay, *dev_root; |
|
int ret; |
|
|
|
if (!IS_ERR(hv_debug_root)) { |
|
dev_root = debugfs_create_dir(device, hv_debug_root); |
|
if (IS_ERR(dev_root)) { |
|
pr_debug("debugfs_hyperv: hyperv/%s/ not created\n", |
|
device); |
|
return PTR_ERR(dev_root); |
|
} |
|
hv_debug_set_test_state(dev, dev_root); |
|
hv_debug_set_dir_dentry(dev, dev_root); |
|
delay = debugfs_create_dir(delay_name, dev_root); |
|
|
|
if (IS_ERR(delay)) { |
|
pr_debug("debugfs_hyperv: hyperv/%s/%s/ not created\n", |
|
device, delay_name); |
|
return PTR_ERR(delay); |
|
} |
|
ret = hv_debug_delay_files(dev, delay); |
|
|
|
return ret; |
|
} |
|
pr_debug("debugfs_hyperv: hyperv/ not in root debugfs path\n"); |
|
return PTR_ERR(hv_debug_root); |
|
} |
|
|
|
/* Remove dentry associated with released hv device */ |
|
void hv_debug_rm_dev_dir(struct hv_device *dev) |
|
{ |
|
if (!IS_ERR(hv_debug_root)) |
|
debugfs_remove_recursive(dev->debug_dir); |
|
} |
|
|
|
/* Remove all dentrys associated with vmbus testing */ |
|
void hv_debug_rm_all_dir(void) |
|
{ |
|
debugfs_remove_recursive(hv_debug_root); |
|
} |
|
|
|
/* Delay buffer/message reads on a vmbus channel */ |
|
void hv_debug_delay_test(struct vmbus_channel *channel, enum delay delay_type) |
|
{ |
|
struct vmbus_channel *test_channel = channel->primary_channel ? |
|
channel->primary_channel : |
|
channel; |
|
bool state = test_channel->fuzz_testing_state; |
|
|
|
if (state) { |
|
if (delay_type == 0) |
|
udelay(test_channel->fuzz_testing_interrupt_delay); |
|
else |
|
udelay(test_channel->fuzz_testing_message_delay); |
|
} |
|
} |
|
|
|
/* Initialize top dentry for vmbus testing */ |
|
int hv_debug_init(void) |
|
{ |
|
hv_debug_root = debugfs_create_dir("hyperv", NULL); |
|
if (IS_ERR(hv_debug_root)) { |
|
pr_debug("debugfs_hyperv: hyperv/ not created\n"); |
|
return PTR_ERR(hv_debug_root); |
|
} |
|
return 0; |
|
}
|
|
|