orangefs: clean up debugfs globals
Mostly this is moving code into orangefs-debugfs.c so that globals turn into static globals. Then gossip_debug_mask is renamed orangefs_gossip_debug_mask but keeps global visibility, so it can be used from a macro. Signed-off-by: Martin Brandenburg <martin@omnibond.com>
This commit is contained in:
Martin Brandenburg
@@ -656,401 +656,3 @@ __s32 ORANGEFS_util_translate_mode(int mode)
|
||||
return ret;
|
||||
}
|
||||
#undef NUM_MODES
|
||||
|
||||
/*
|
||||
* After obtaining a string representation of the client's debug
|
||||
* keywords and their associated masks, this function is called to build an
|
||||
* array of these values.
|
||||
*/
|
||||
int orangefs_prepare_cdm_array(char *debug_array_string)
|
||||
{
|
||||
int i;
|
||||
int rc = -EINVAL;
|
||||
char *cds_head = NULL;
|
||||
char *cds_delimiter = NULL;
|
||||
int keyword_len = 0;
|
||||
|
||||
gossip_debug(GOSSIP_UTILS_DEBUG, "%s: start\n", __func__);
|
||||
|
||||
/*
|
||||
* figure out how many elements the cdm_array needs.
|
||||
*/
|
||||
for (i = 0; i < strlen(debug_array_string); i++)
|
||||
if (debug_array_string[i] == '\n')
|
||||
cdm_element_count++;
|
||||
|
||||
if (!cdm_element_count) {
|
||||
pr_info("No elements in client debug array string!\n");
|
||||
goto out;
|
||||
}
|
||||
|
||||
cdm_array =
|
||||
kzalloc(cdm_element_count * sizeof(struct client_debug_mask),
|
||||
GFP_KERNEL);
|
||||
if (!cdm_array) {
|
||||
pr_info("malloc failed for cdm_array!\n");
|
||||
rc = -ENOMEM;
|
||||
goto out;
|
||||
}
|
||||
|
||||
cds_head = debug_array_string;
|
||||
|
||||
for (i = 0; i < cdm_element_count; i++) {
|
||||
cds_delimiter = strchr(cds_head, '\n');
|
||||
*cds_delimiter = '\0';
|
||||
|
||||
keyword_len = strcspn(cds_head, " ");
|
||||
|
||||
cdm_array[i].keyword = kzalloc(keyword_len + 1, GFP_KERNEL);
|
||||
if (!cdm_array[i].keyword) {
|
||||
rc = -ENOMEM;
|
||||
goto out;
|
||||
}
|
||||
|
||||
sscanf(cds_head,
|
||||
"%s %llx %llx",
|
||||
cdm_array[i].keyword,
|
||||
(unsigned long long *)&(cdm_array[i].mask1),
|
||||
(unsigned long long *)&(cdm_array[i].mask2));
|
||||
|
||||
if (!strcmp(cdm_array[i].keyword, ORANGEFS_VERBOSE))
|
||||
client_verbose_index = i;
|
||||
|
||||
if (!strcmp(cdm_array[i].keyword, ORANGEFS_ALL))
|
||||
client_all_index = i;
|
||||
|
||||
cds_head = cds_delimiter + 1;
|
||||
}
|
||||
|
||||
rc = cdm_element_count;
|
||||
|
||||
gossip_debug(GOSSIP_UTILS_DEBUG, "%s: rc:%d:\n", __func__, rc);
|
||||
|
||||
out:
|
||||
|
||||
return rc;
|
||||
|
||||
}
|
||||
|
||||
/*
|
||||
* /sys/kernel/debug/orangefs/debug-help can be catted to
|
||||
* see all the available kernel and client debug keywords.
|
||||
*
|
||||
* When the kernel boots, we have no idea what keywords the
|
||||
* client supports, nor their associated masks.
|
||||
*
|
||||
* We pass through this function once at boot and stamp a
|
||||
* boilerplate "we don't know" message for the client in the
|
||||
* debug-help file. We pass through here again when the client
|
||||
* starts and then we can fill out the debug-help file fully.
|
||||
*
|
||||
* The client might be restarted any number of times between
|
||||
* reboots, we only build the debug-help file the first time.
|
||||
*/
|
||||
int orangefs_prepare_debugfs_help_string(int at_boot)
|
||||
{
|
||||
int rc = -EINVAL;
|
||||
int i;
|
||||
int byte_count = 0;
|
||||
char *client_title = "Client Debug Keywords:\n";
|
||||
char *kernel_title = "Kernel Debug Keywords:\n";
|
||||
|
||||
gossip_debug(GOSSIP_UTILS_DEBUG, "%s: start\n", __func__);
|
||||
|
||||
if (at_boot) {
|
||||
byte_count += strlen(HELP_STRING_UNINITIALIZED);
|
||||
client_title = HELP_STRING_UNINITIALIZED;
|
||||
} else {
|
||||
/*
|
||||
* fill the client keyword/mask array and remember
|
||||
* how many elements there were.
|
||||
*/
|
||||
cdm_element_count =
|
||||
orangefs_prepare_cdm_array(client_debug_array_string);
|
||||
if (cdm_element_count <= 0)
|
||||
goto out;
|
||||
|
||||
/* Count the bytes destined for debug_help_string. */
|
||||
byte_count += strlen(client_title);
|
||||
|
||||
for (i = 0; i < cdm_element_count; i++) {
|
||||
byte_count += strlen(cdm_array[i].keyword + 2);
|
||||
if (byte_count >= DEBUG_HELP_STRING_SIZE) {
|
||||
pr_info("%s: overflow 1!\n", __func__);
|
||||
goto out;
|
||||
}
|
||||
}
|
||||
|
||||
gossip_debug(GOSSIP_UTILS_DEBUG,
|
||||
"%s: cdm_element_count:%d:\n",
|
||||
__func__,
|
||||
cdm_element_count);
|
||||
}
|
||||
|
||||
byte_count += strlen(kernel_title);
|
||||
for (i = 0; i < num_kmod_keyword_mask_map; i++) {
|
||||
byte_count +=
|
||||
strlen(s_kmod_keyword_mask_map[i].keyword + 2);
|
||||
if (byte_count >= DEBUG_HELP_STRING_SIZE) {
|
||||
pr_info("%s: overflow 2!\n", __func__);
|
||||
goto out;
|
||||
}
|
||||
}
|
||||
|
||||
/* build debug_help_string. */
|
||||
debug_help_string = kzalloc(DEBUG_HELP_STRING_SIZE, GFP_KERNEL);
|
||||
if (!debug_help_string) {
|
||||
rc = -ENOMEM;
|
||||
goto out;
|
||||
}
|
||||
|
||||
strcat(debug_help_string, client_title);
|
||||
|
||||
if (!at_boot) {
|
||||
for (i = 0; i < cdm_element_count; i++) {
|
||||
strcat(debug_help_string, "\t");
|
||||
strcat(debug_help_string, cdm_array[i].keyword);
|
||||
strcat(debug_help_string, "\n");
|
||||
}
|
||||
}
|
||||
|
||||
strcat(debug_help_string, "\n");
|
||||
strcat(debug_help_string, kernel_title);
|
||||
|
||||
for (i = 0; i < num_kmod_keyword_mask_map; i++) {
|
||||
strcat(debug_help_string, "\t");
|
||||
strcat(debug_help_string, s_kmod_keyword_mask_map[i].keyword);
|
||||
strcat(debug_help_string, "\n");
|
||||
}
|
||||
|
||||
rc = 0;
|
||||
|
||||
out:
|
||||
|
||||
return rc;
|
||||
|
||||
}
|
||||
|
||||
/*
|
||||
* kernel = type 0
|
||||
* client = type 1
|
||||
*/
|
||||
void debug_mask_to_string(void *mask, int type)
|
||||
{
|
||||
int i;
|
||||
int len = 0;
|
||||
char *debug_string;
|
||||
int element_count = 0;
|
||||
|
||||
gossip_debug(GOSSIP_UTILS_DEBUG, "%s: start\n", __func__);
|
||||
|
||||
if (type) {
|
||||
debug_string = client_debug_string;
|
||||
element_count = cdm_element_count;
|
||||
} else {
|
||||
debug_string = kernel_debug_string;
|
||||
element_count = num_kmod_keyword_mask_map;
|
||||
}
|
||||
|
||||
memset(debug_string, 0, ORANGEFS_MAX_DEBUG_STRING_LEN);
|
||||
|
||||
/*
|
||||
* Some keywords, like "all" or "verbose", are amalgams of
|
||||
* numerous other keywords. Make a special check for those
|
||||
* before grinding through the whole mask only to find out
|
||||
* later...
|
||||
*/
|
||||
if (check_amalgam_keyword(mask, type))
|
||||
goto out;
|
||||
|
||||
/* Build the debug string. */
|
||||
for (i = 0; i < element_count; i++)
|
||||
if (type)
|
||||
do_c_string(mask, i);
|
||||
else
|
||||
do_k_string(mask, i);
|
||||
|
||||
len = strlen(debug_string);
|
||||
|
||||
if ((len) && (type))
|
||||
client_debug_string[len - 1] = '\0';
|
||||
else if (len)
|
||||
kernel_debug_string[len - 1] = '\0';
|
||||
else if (type)
|
||||
strcpy(client_debug_string, "none");
|
||||
else
|
||||
strcpy(kernel_debug_string, "none");
|
||||
|
||||
out:
|
||||
gossip_debug(GOSSIP_UTILS_DEBUG, "%s: string:%s:\n", __func__, debug_string);
|
||||
|
||||
return;
|
||||
|
||||
}
|
||||
|
||||
void do_k_string(void *k_mask, int index)
|
||||
{
|
||||
__u64 *mask = (__u64 *) k_mask;
|
||||
|
||||
if (keyword_is_amalgam((char *) s_kmod_keyword_mask_map[index].keyword))
|
||||
goto out;
|
||||
|
||||
if (*mask & s_kmod_keyword_mask_map[index].mask_val) {
|
||||
if ((strlen(kernel_debug_string) +
|
||||
strlen(s_kmod_keyword_mask_map[index].keyword))
|
||||
< ORANGEFS_MAX_DEBUG_STRING_LEN - 1) {
|
||||
strcat(kernel_debug_string,
|
||||
s_kmod_keyword_mask_map[index].keyword);
|
||||
strcat(kernel_debug_string, ",");
|
||||
} else {
|
||||
gossip_err("%s: overflow!\n", __func__);
|
||||
strcpy(kernel_debug_string, ORANGEFS_ALL);
|
||||
goto out;
|
||||
}
|
||||
}
|
||||
|
||||
out:
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
void do_c_string(void *c_mask, int index)
|
||||
{
|
||||
struct client_debug_mask *mask = (struct client_debug_mask *) c_mask;
|
||||
|
||||
if (keyword_is_amalgam(cdm_array[index].keyword))
|
||||
goto out;
|
||||
|
||||
if ((mask->mask1 & cdm_array[index].mask1) ||
|
||||
(mask->mask2 & cdm_array[index].mask2)) {
|
||||
if ((strlen(client_debug_string) +
|
||||
strlen(cdm_array[index].keyword) + 1)
|
||||
< ORANGEFS_MAX_DEBUG_STRING_LEN - 2) {
|
||||
strcat(client_debug_string,
|
||||
cdm_array[index].keyword);
|
||||
strcat(client_debug_string, ",");
|
||||
} else {
|
||||
gossip_err("%s: overflow!\n", __func__);
|
||||
strcpy(client_debug_string, ORANGEFS_ALL);
|
||||
goto out;
|
||||
}
|
||||
}
|
||||
out:
|
||||
return;
|
||||
}
|
||||
|
||||
int keyword_is_amalgam(char *keyword)
|
||||
{
|
||||
int rc = 0;
|
||||
|
||||
if ((!strcmp(keyword, ORANGEFS_ALL)) || (!strcmp(keyword, ORANGEFS_VERBOSE)))
|
||||
rc = 1;
|
||||
|
||||
return rc;
|
||||
}
|
||||
|
||||
/*
|
||||
* kernel = type 0
|
||||
* client = type 1
|
||||
*
|
||||
* return 1 if we found an amalgam.
|
||||
*/
|
||||
int check_amalgam_keyword(void *mask, int type)
|
||||
{
|
||||
__u64 *k_mask;
|
||||
struct client_debug_mask *c_mask;
|
||||
int k_all_index = num_kmod_keyword_mask_map - 1;
|
||||
int rc = 0;
|
||||
|
||||
if (type) {
|
||||
c_mask = (struct client_debug_mask *) mask;
|
||||
|
||||
if ((c_mask->mask1 == cdm_array[client_all_index].mask1) &&
|
||||
(c_mask->mask2 == cdm_array[client_all_index].mask2)) {
|
||||
strcpy(client_debug_string, ORANGEFS_ALL);
|
||||
rc = 1;
|
||||
goto out;
|
||||
}
|
||||
|
||||
if ((c_mask->mask1 == cdm_array[client_verbose_index].mask1) &&
|
||||
(c_mask->mask2 == cdm_array[client_verbose_index].mask2)) {
|
||||
strcpy(client_debug_string, ORANGEFS_VERBOSE);
|
||||
rc = 1;
|
||||
goto out;
|
||||
}
|
||||
|
||||
} else {
|
||||
k_mask = (__u64 *) mask;
|
||||
|
||||
if (*k_mask >= s_kmod_keyword_mask_map[k_all_index].mask_val) {
|
||||
strcpy(kernel_debug_string, ORANGEFS_ALL);
|
||||
rc = 1;
|
||||
goto out;
|
||||
}
|
||||
}
|
||||
|
||||
out:
|
||||
|
||||
return rc;
|
||||
}
|
||||
|
||||
/*
|
||||
* kernel = type 0
|
||||
* client = type 1
|
||||
*/
|
||||
void debug_string_to_mask(char *debug_string, void *mask, int type)
|
||||
{
|
||||
char *unchecked_keyword;
|
||||
int i;
|
||||
char *strsep_fodder = kstrdup(debug_string, GFP_KERNEL);
|
||||
char *original_pointer;
|
||||
int element_count = 0;
|
||||
struct client_debug_mask *c_mask;
|
||||
__u64 *k_mask;
|
||||
|
||||
gossip_debug(GOSSIP_UTILS_DEBUG, "%s: start\n", __func__);
|
||||
|
||||
if (type) {
|
||||
c_mask = (struct client_debug_mask *)mask;
|
||||
element_count = cdm_element_count;
|
||||
} else {
|
||||
k_mask = (__u64 *)mask;
|
||||
*k_mask = 0;
|
||||
element_count = num_kmod_keyword_mask_map;
|
||||
}
|
||||
|
||||
original_pointer = strsep_fodder;
|
||||
while ((unchecked_keyword = strsep(&strsep_fodder, ",")))
|
||||
if (strlen(unchecked_keyword)) {
|
||||
for (i = 0; i < element_count; i++)
|
||||
if (type)
|
||||
do_c_mask(i,
|
||||
unchecked_keyword,
|
||||
&c_mask);
|
||||
else
|
||||
do_k_mask(i,
|
||||
unchecked_keyword,
|
||||
&k_mask);
|
||||
}
|
||||
|
||||
kfree(original_pointer);
|
||||
}
|
||||
|
||||
void do_c_mask(int i,
|
||||
char *unchecked_keyword,
|
||||
struct client_debug_mask **sane_mask)
|
||||
{
|
||||
|
||||
if (!strcmp(cdm_array[i].keyword, unchecked_keyword)) {
|
||||
(**sane_mask).mask1 = (**sane_mask).mask1 | cdm_array[i].mask1;
|
||||
(**sane_mask).mask2 = (**sane_mask).mask2 | cdm_array[i].mask2;
|
||||
}
|
||||
}
|
||||
|
||||
void do_k_mask(int i, char *unchecked_keyword, __u64 **sane_mask)
|
||||
{
|
||||
|
||||
if (!strcmp(s_kmod_keyword_mask_map[i].keyword, unchecked_keyword))
|
||||
**sane_mask = (**sane_mask) |
|
||||
s_kmod_keyword_mask_map[i].mask_val;
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user