asgardius/android_kernel_samsung_heroqlte
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
android_kernel_samsung_hero.../drivers/soc/qcom/glink_debugfs.c

784 lines
23 KiB
C
Raw Permalink Normal View History

init: OSRC G9300ZCU2APF7
2016-08-17 10:41:52 +02:00
/* Copyright (c) 2014-2015, The Linux Foundation. All rights reserved.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 and
* only version 2 as published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#include <linux/debugfs.h>
#include <linux/err.h>
#include <linux/ipc_logging.h>
#include <linux/list.h>
#include <linux/slab.h>
#include <soc/qcom/glink.h>
#include "glink_private.h"
#include "glink_core_if.h"
static const char * const ss_string[] = {
[GLINK_DBGFS_MPSS] = "mpss",
[GLINK_DBGFS_APSS] = "apss",
[GLINK_DBGFS_LPASS] = "lpass",
[GLINK_DBGFS_DSPS] = "dsps",
[GLINK_DBGFS_RPM] = "rpm",
[GLINK_DBGFS_WCNSS] = "wcnss",
[GLINK_DBGFS_LLOOP] = "lloop",
[GLINK_DBGFS_MOCK] = "mock"
};
static const char * const xprt_string[] = {
[GLINK_DBGFS_SMEM] = "smem",
[GLINK_DBGFS_SMD] = "smd",
[GLINK_DBGFS_XLLOOP] = "lloop",
[GLINK_DBGFS_XMOCK] = "mock",
[GLINK_DBGFS_XMOCK_LOW] = "mock_low",
[GLINK_DBGFS_XMOCK_HIGH] = "mock_high"
};
static const char * const ch_st_string[] = {
[GLINK_CHANNEL_CLOSED] = "CLOSED",
[GLINK_CHANNEL_OPENING] = "OPENING",
[GLINK_CHANNEL_OPENED] = "OPENED",
[GLINK_CHANNEL_CLOSING] = "CLOSING",
};
static const char * const xprt_st_string[] = {
[GLINK_XPRT_DOWN] = "DOWN",
[GLINK_XPRT_NEGOTIATING] = "NEGOT",
[GLINK_XPRT_OPENED] = "OPENED",
[GLINK_XPRT_FAILED] = "FAILED"
};
#if defined(CONFIG_DEBUG_FS)
#define GLINK_DBGFS_NAME_SIZE (2 * GLINK_NAME_SIZE + 1)
struct glink_dbgfs_dent {
struct list_head list_node;
char par_name[GLINK_DBGFS_NAME_SIZE];
char self_name[GLINK_DBGFS_NAME_SIZE];
struct dentry *parent;
struct dentry *self;
spinlock_t file_list_lock_lhb0;
struct list_head file_list;
};
static struct dentry *dent;
static LIST_HEAD(dent_list);
static DEFINE_MUTEX(dent_list_lock_lha0);
static int debugfs_show(struct seq_file *s, void *data)
{
struct glink_dbgfs_data *dfs_d;
dfs_d = s->private;
dfs_d->o_func(s);
return 0;
}
static int debug_open(struct inode *inode, struct file *file)
{
return single_open(file, debugfs_show, inode->i_private);
}
static const struct file_operations debug_ops = {
.open = debug_open,
.release = single_release,
.read = seq_read,
.llseek = seq_lseek,
};
#endif
/**
* glink_get_ss_enum_string() - get the name of the subsystem based on enum value
* @enum_id: enum id of a specific subsystem.
*
* Return: name of the subsystem, NULL in case of invalid input
*/
const char *glink_get_ss_enum_string(unsigned int enum_id)
{
if (enum_id >= ARRAY_SIZE(ss_string))
return NULL;
return ss_string[enum_id];
}
EXPORT_SYMBOL(glink_get_ss_enum_string);
/**
* glink_get_xprt_enum_string() - get the name of the transport based on enum value
* @enum_id: enum id of a specific transport.
*
* Return: name of the transport, NULL in case of invalid input
*/
const char *glink_get_xprt_enum_string(unsigned int enum_id)
{
if (enum_id >= ARRAY_SIZE(xprt_string))
return NULL;
return xprt_string[enum_id];
}
EXPORT_SYMBOL(glink_get_xprt_enum_string);
/**
* glink_get_xprt_state_string() - get the name of the transport based on enum value
* @enum_id: enum id of the state of the transport.
*
* Return: name of the transport state, NULL in case of invalid input
*/
const char *glink_get_xprt_state_string(
enum transport_state_e enum_id)
{
if (enum_id >= ARRAY_SIZE(xprt_st_string))
return NULL;
return xprt_st_string[enum_id];
}
EXPORT_SYMBOL(glink_get_xprt_state_string);
/**
* glink_get_ch_state_string() - get the name of the transport based on enum value
* @enum_id: enum id of a specific state of the channel.
*
* Return: name of the channel state, NULL in case of invalid input
*/
const char *glink_get_ch_state_string(
enum local_channel_state_e enum_id)
{
if (enum_id >= ARRAY_SIZE(ch_st_string))
return NULL;
return ch_st_string[enum_id];
}
EXPORT_SYMBOL(glink_get_ch_state_string);
#if defined(CONFIG_DEBUG_FS)
/**
* glink_dfs_create_file() - create the debugfs file
* @name: debugfs file name
* @parent: pointer to the parent dentry structure
* @show: pointer to the actual function which will be invoked upon
* opening this file.
*
* Return: pointer to the allocated glink_dbgfs_data structure or
* NULL in case of an error.
*
* This function actually create a debugfs file under the parent directory
*/
static struct glink_dbgfs_data *glink_dfs_create_file(const char *name,
struct dentry *parent, void (*show)(struct seq_file *s),
void *dbgfs_data, bool b_free_req)
{
struct dentry *file;
struct glink_dbgfs_data *dfs_d;
dfs_d = kzalloc(sizeof(struct glink_dbgfs_data), GFP_KERNEL);
if (dfs_d == NULL)
return NULL;
dfs_d->o_func = show;
if (dbgfs_data != NULL) {
dfs_d->priv_data = dbgfs_data;
dfs_d->b_priv_free_req = b_free_req;
}
file = debugfs_create_file(name, 0400, parent, dfs_d, &debug_ops);
if (!file)
GLINK_DBG("%s: unable to create file '%s'\n", __func__,
name);
dfs_d->dent = file;
return dfs_d;
}
/**
* write_ch_intent() - write channel intent details
* @s: pointer to the sequential file
* @intent: pointer glink core intent structure
* @i_type: type of intent
* @count: serial number of the intent.
*
* This function is a helper function of glink_dfs_update_ch_intents()
* that prints out details of any specific intent.
*/
static void write_ch_intent(struct seq_file *s,
struct glink_core_rx_intent *intent,
char *i_type, unsigned int count)
{
char *intent_type;
/*
* formatted, human readable channel state output, ie:
* TYPE |SN |ID |PKT_SIZE|W_OFFSET|INT_SIZE|
* --------------------------------------------------------------
* LOCAL_LIST|#2 |1 |0 |0 |8 |
*/
if (count == 1) {
intent_type = i_type;
seq_puts(s,
"\n--------------------------------------------------------\n");
} else {
intent_type = "";
}
seq_printf(s, "%-20s|#%-5d|%-6u|%-10zu|%-10zu|%-10zu|\n",
intent_type,
count,
intent->id,
intent->pkt_size,
intent->write_offset,
intent->intent_size);
}
/**
* glink_dfs_update_ch_intent() - writes the intent details of a specific
* channel to the corresponding debugfs file
* @s: pointer to the sequential file
*
* This function extracts the intent details of a channel & prints them to
* corrseponding debugfs file of that channel.
*/
static void glink_dfs_update_ch_intent(struct seq_file *s)
{
struct glink_dbgfs_data *dfs_d;
struct channel_ctx *ch_ctx;
struct glink_core_rx_intent *intent;
struct glink_core_rx_intent *intent_temp;
struct glink_ch_intent_info ch_intent_info;
unsigned long flags;
unsigned int count = 0;
dfs_d = s->private;
ch_ctx = dfs_d->priv_data;
if (ch_ctx != NULL) {
glink_get_ch_intent_info(ch_ctx, &ch_intent_info);
seq_puts(s,
"---------------------------------------------------------------\n");
seq_printf(s, "%-20s|%-6s|%-6s|%-10s|%-10s|%-10s|\n",
"INTENT TYPE",
"SN",
"ID",
"PKT_SIZE",
"W_OFFSET",
"INT_SIZE");
seq_puts(s,
"---------------------------------------------------------------\n");
spin_lock_irqsave(ch_intent_info.li_lst_lock, flags);
list_for_each_entry_safe(intent, intent_temp,
ch_intent_info.li_avail_list, list) {
count++;
write_ch_intent(s, intent, "LOCAL_AVAIL_LIST", count);
}
count = 0;
list_for_each_entry_safe(intent, intent_temp,
ch_intent_info.li_used_list, list) {
count++;
write_ch_intent(s, intent, "LOCAL_USED_LIST", count);
}
spin_unlock_irqrestore(ch_intent_info.li_lst_lock, flags);
count = 0;
spin_lock_irqsave(ch_intent_info.ri_lst_lock, flags);
list_for_each_entry_safe(intent, intent_temp,
ch_intent_info.ri_list, list) {
count++;
write_ch_intent(s, intent, "REMOTE_LIST", count);
}
spin_unlock_irqrestore(ch_intent_info.ri_lst_lock,
flags);
seq_puts(s,
"---------------------------------------------------------------\n");
}
}
/**
* glink_dfs_update_ch_stats() - writes statistics of a specific
* channel to the corresponding debugfs file
* @s: pointer to the sequential file
*
* This function extracts other statistics of a channel & prints them to
* corrseponding debugfs file of that channel
*/
static void glink_dfs_update_ch_stats(struct seq_file *s)
{
/* FUTURE: add channel statistics */
seq_puts(s, "not yet implemented\n");
}
/**
* glink_debugfs_remove_channel() - remove all channel specifc files & folder in
* debugfs when channel is fully closed
* @ch_ctx: pointer to the channel_contenxt
* @xprt_ctx: pointer to the transport_context
*
* This function is invoked when any channel is fully closed. It removes the
* folders & other files in debugfs for that channel.
*/
void glink_debugfs_remove_channel(struct channel_ctx *ch_ctx,
struct glink_core_xprt_ctx *xprt_ctx){
struct glink_dbgfs ch_rm_dbgfs;
char *edge_name;
char curr_dir_name[GLINK_DBGFS_NAME_SIZE];
char *xprt_name;
ch_rm_dbgfs.curr_name = glink_get_ch_name(ch_ctx);
edge_name = glink_get_xprt_edge_name(xprt_ctx);
xprt_name = glink_get_xprt_name(xprt_ctx);
if (!xprt_name || !edge_name) {
GLINK_ERR("%s: Invalid xprt_name or edge_name for ch '%s'\n",
__func__, ch_rm_dbgfs.curr_name);
return;
}
snprintf(curr_dir_name, sizeof(curr_dir_name), "%s_%s",
edge_name, xprt_name);
ch_rm_dbgfs.par_name = curr_dir_name;
glink_debugfs_remove_recur(&ch_rm_dbgfs);
}
EXPORT_SYMBOL(glink_debugfs_remove_channel);
/**
* glink_debugfs_add_channel() - create channel specifc files & folder in
* debugfs when channel is added
* @ch_ctx: pointer to the channel_contenxt
* @xprt_ctx: pointer to the transport_context
*
* This function is invoked when a new channel is created. It creates the
* folders & other files in debugfs for that channel
*/
void glink_debugfs_add_channel(struct channel_ctx *ch_ctx,
struct glink_core_xprt_ctx *xprt_ctx)
{
struct glink_dbgfs ch_dbgfs;
char *ch_name;
char *edge_name;
char *xprt_name;
char curr_dir_name[GLINK_DBGFS_NAME_SIZE];
if (ch_ctx == NULL) {
GLINK_ERR("%s: Channel Context is NULL\n", __func__);
return;
}
ch_name = glink_get_ch_name(ch_ctx);
edge_name = glink_get_xprt_edge_name(xprt_ctx);
xprt_name = glink_get_xprt_name(xprt_ctx);
if (!xprt_name || !edge_name) {
GLINK_ERR("%s: Invalid xprt_name or edge_name for ch '%s'\n",
__func__, ch_name);
return;
}
snprintf(curr_dir_name, sizeof(curr_dir_name), "%s_%s",
edge_name, xprt_name);
ch_dbgfs.curr_name = curr_dir_name;
ch_dbgfs.par_name = "channel";
ch_dbgfs.b_dir_create = true;
glink_debugfs_create(ch_name, NULL, &ch_dbgfs, NULL, false);
ch_dbgfs.par_name = ch_dbgfs.curr_name;
ch_dbgfs.curr_name = ch_name;
ch_dbgfs.b_dir_create = false;
glink_debugfs_create("stats", glink_dfs_update_ch_stats,
&ch_dbgfs, (void *)ch_ctx, false);
glink_debugfs_create("intents", glink_dfs_update_ch_intent,
&ch_dbgfs, (void *)ch_ctx, false);
}
EXPORT_SYMBOL(glink_debugfs_add_channel);
/**
* glink_debugfs_add_xprt() - create transport specifc files & folder in
* debugfs when new transport is registerd
* @xprt_ctx: pointer to the transport_context
*
* This function is invoked when a new transport is registered. It creates the
* folders & other files in debugfs for that transport
*/
void glink_debugfs_add_xprt(struct glink_core_xprt_ctx *xprt_ctx)
{
struct glink_dbgfs xprt_dbgfs;
char *xprt_name;
char *edge_name;
char curr_dir_name[GLINK_DBGFS_NAME_SIZE];
if (xprt_ctx == NULL)
GLINK_ERR("%s: Transport Context is NULL\n", __func__);
xprt_name = glink_get_xprt_name(xprt_ctx);
edge_name = glink_get_xprt_edge_name(xprt_ctx);
if (!xprt_name || !edge_name) {
GLINK_ERR("%s: xprt name or edge name is NULL\n", __func__);
return;
}
snprintf(curr_dir_name, sizeof(curr_dir_name), "%s_%s",
edge_name, xprt_name);
xprt_dbgfs.par_name = "glink";
xprt_dbgfs.curr_name = "xprt";
xprt_dbgfs.b_dir_create = true;
glink_debugfs_create(curr_dir_name, NULL, &xprt_dbgfs, NULL, false);
xprt_dbgfs.curr_name = "channel";
glink_debugfs_create(curr_dir_name, NULL, &xprt_dbgfs, NULL, false);
}
EXPORT_SYMBOL(glink_debugfs_add_xprt);
/**
* glink_dfs_create_channel_list() - create & update the channel details
* s: pointer to seq_file
*
* This function updates channel details in debugfs
* file present in /glink/channel/channels
*/
static void glink_dfs_create_channel_list(struct seq_file *s)
{
struct xprt_ctx_iterator xprt_iter;
struct ch_ctx_iterator ch_iter;
struct glink_core_xprt_ctx *xprt_ctx;
struct channel_ctx *ch_ctx;
int count = 0;
/*
* formatted, human readable channel state output, ie:
* NAME |LCID|RCID|XPRT|EDGE|LSTATE |RSTATE|LINT-Q|RINT-Q|
* --------------------------------------------------------------------
* LOCAL_LOOPBACK_CLNT|2 |1 |lloop|local|OPENED|OPENED|5 |6 |
* N.B. Number of TX & RX Packets not implemented yet. -ENOSYS is printed
*/
seq_printf(s, "%-20s|%-4s|%-4s|%-10s|%-6s|%-7s|%-7s|%-5s|%-5s|\n",
"NAME",
"LCID",
"RCID",
"XPRT",
"EDGE",
"LSTATE",
"RSTATE",
"LINTQ",
"RINTQ");
seq_puts(s,
"-------------------------------------------------------------------------------\n");
glink_xprt_ctx_iterator_init(&xprt_iter);
xprt_ctx = glink_xprt_ctx_iterator_next(&xprt_iter);
while (xprt_ctx != NULL) {
glink_ch_ctx_iterator_init(&ch_iter, xprt_ctx);
ch_ctx = glink_ch_ctx_iterator_next(&ch_iter);
while (ch_ctx != NULL) {
count++;
seq_printf(s, "%-20s|%-4i|%-4i|%-10s|%-6s|%-7s|",
glink_get_ch_name(ch_ctx),
glink_get_ch_lcid(ch_ctx),
glink_get_ch_rcid(ch_ctx),
glink_get_ch_xprt_name(ch_ctx),
glink_get_ch_edge_name(ch_ctx),
glink_get_ch_lstate(ch_ctx));
seq_printf(s, "%-7s|%-5i|%-5i|\n",
(glink_get_ch_rstate(ch_ctx) ? "OPENED" : "CLOSED"),
glink_get_ch_lintents_queued(ch_ctx),
glink_get_ch_rintents_queued(ch_ctx));
ch_ctx = glink_ch_ctx_iterator_next(&ch_iter);
}
glink_ch_ctx_iterator_end(&ch_iter, xprt_ctx);
xprt_ctx = glink_xprt_ctx_iterator_next(&xprt_iter);
}
glink_xprt_ctx_iterator_end(&xprt_iter);
}
/**
* glink_dfs_create_xprt_list() - create & update the transport details
* @s: pointer to seq_file
*
* This function updates channel details in debugfs file present
* in /glink/xprt/xprts
*/
static void glink_dfs_create_xprt_list(struct seq_file *s)
{
struct xprt_ctx_iterator xprt_iter;
struct glink_core_xprt_ctx *xprt_ctx;
const struct glink_core_version *gver;
uint32_t version;
uint32_t features;
int count = 0;
/*
* formatted, human readable channel state output, ie:
* XPRT_NAME|REMOTE |STATE|VERSION |FEATURES|
* ---------------------------------------------
* smd_trans|lpass |2 |0 |1 |
* smem |mpss |0 |0 |0 |
*/
seq_printf(s, "%-20s|%-20s|%-6s|%-8s|%-8s|\n",
"XPRT_NAME",
"REMOTE",
"STATE",
"VERSION",
"FEATURES");
seq_puts(s,
"-------------------------------------------------------------------------------\n");
glink_xprt_ctx_iterator_init(&xprt_iter);
xprt_ctx = glink_xprt_ctx_iterator_next(&xprt_iter);
while (xprt_ctx != NULL) {
count++;
seq_printf(s, "%-20s|%-20s|",
glink_get_xprt_name(xprt_ctx),
glink_get_xprt_edge_name(xprt_ctx));
gver = glink_get_xprt_version_features(xprt_ctx);
if (gver != NULL) {
version = gver->version;
features = gver->features;
seq_printf(s, "%-6s|%-8i|%-8i|\n",
glink_get_xprt_state(xprt_ctx),
version,
features);
} else {
seq_printf(s, "%-6s|%-8i|%-8i|\n",
glink_get_xprt_state(xprt_ctx),
-ENODATA,
-ENODATA);
}
xprt_ctx = glink_xprt_ctx_iterator_next(&xprt_iter);
}
glink_xprt_ctx_iterator_end(&xprt_iter);
}
/**
* glink_dfs_update_list() - update the internally maintained dentry linked list
* @curr_dent: pointer to the current dentry object
* @parent: pointer to the parent dentry object
* @curr: current directory name
* @par_dir: parent directory name
*/
void glink_dfs_update_list(struct dentry *curr_dent, struct dentry *parent,
const char *curr, const char *par_dir)
{
struct glink_dbgfs_dent *dbgfs_dent_s;
if (curr_dent != NULL) {
dbgfs_dent_s = kzalloc(sizeof(struct glink_dbgfs_dent),
GFP_KERNEL);
if (dbgfs_dent_s != NULL) {
INIT_LIST_HEAD(&dbgfs_dent_s->file_list);
spin_lock_init(&dbgfs_dent_s->file_list_lock_lhb0);
dbgfs_dent_s->parent = parent;
dbgfs_dent_s->self = curr_dent;
strlcpy(dbgfs_dent_s->self_name,
curr, strlen(curr) + 1);
strlcpy(dbgfs_dent_s->par_name, par_dir,
strlen(par_dir) + 1);
mutex_lock(&dent_list_lock_lha0);
list_add_tail(&dbgfs_dent_s->list_node, &dent_list);
mutex_unlock(&dent_list_lock_lha0);
}
} else {
GLINK_DBG("%s:create directory failed for par:curr [%s:%s]\n",
__func__, par_dir, curr);
}
return;
}
/**
* glink_remove_dfs_entry() - remove the the entries from dent_list
* @entry: pointer to the glink_dbgfs_dent structure
*
* This function removes the removes the entries from internally maintained
* linked list of dentries. It also deletes the file list and associated memory
* if present.
*/
void glink_remove_dfs_entry(struct glink_dbgfs_dent *entry)
{
struct glink_dbgfs_data *fentry, *fentry_temp;
unsigned long flags;
if (entry == NULL)
return;
if (!list_empty(&entry->file_list)) {
spin_lock_irqsave(&entry->file_list_lock_lhb0, flags);
list_for_each_entry_safe(fentry, fentry_temp,
&entry->file_list, flist) {
if (fentry->b_priv_free_req)
kfree(fentry->priv_data);
list_del(&fentry->flist);
kfree(fentry);
fentry = NULL;
}
spin_unlock_irqrestore(&entry->file_list_lock_lhb0, flags);
}
list_del(&entry->list_node);
kfree(entry);
entry = NULL;
}
/**
* glink_debugfs_remove_recur() - remove the the directory & files recursively
* @rm_dfs: pointer to the structure glink_dbgfs
*
* This function removes the files & directories below the given directory.
* This also takes care of freeing any memory associated with the debugfs file.
*/
void glink_debugfs_remove_recur(struct glink_dbgfs *rm_dfs)
{
const char *c_dir_name;
const char *p_dir_name;
struct glink_dbgfs_dent *entry, *entry_temp;
struct dentry *par_dent = NULL;
if (rm_dfs == NULL)
return;
c_dir_name = rm_dfs->curr_name;
p_dir_name = rm_dfs->par_name;
mutex_lock(&dent_list_lock_lha0);
list_for_each_entry_safe(entry, entry_temp, &dent_list, list_node) {
if (!strcmp(entry->par_name, c_dir_name)) {
glink_remove_dfs_entry(entry);
} else if (!strcmp(entry->self_name, c_dir_name)
&& !strcmp(entry->par_name, p_dir_name)) {
par_dent = entry->self;
glink_remove_dfs_entry(entry);
}
}
mutex_unlock(&dent_list_lock_lha0);
if (par_dent != NULL)
debugfs_remove_recursive(par_dent);
}
EXPORT_SYMBOL(glink_debugfs_remove_recur);
/**
* glink_debugfs_create() - create the debugfs file
* @name: debugfs file name
* @show: pointer to the actual function which will be invoked upon
* opening this file.
* @dir: pointer to a structure debugfs_dir
* dbgfs_data: pointer to any private data need to be associated with debugfs
* b_free_req: boolean value to decide to free the memory associated with
* @dbgfs_data during deletion of the file
*
* Return: pointer to the file/directory created, NULL in case of error
*
* This function checks which directory will be used to create the debugfs file
* and calls glink_dfs_create_file. Anybody who intend to allocate some memory
* for the dbgfs_data and required to free it in deletion, need to set
* b_free_req to true. Otherwise, there will be a memory leak.
*/
struct dentry *glink_debugfs_create(const char *name,
void (*show)(struct seq_file *),
struct glink_dbgfs *dir, void *dbgfs_data, bool b_free_req)
{
struct dentry *parent = NULL;
struct dentry *dent = NULL;
struct glink_dbgfs_dent *entry;
struct glink_dbgfs_data *file_data;
const char *c_dir_name;
const char *p_dir_name;
unsigned long flags;
if (dir == NULL) {
GLINK_ERR("%s: debugfs_dir strucutre is null\n", __func__);
return NULL;
}
c_dir_name = dir->curr_name;
p_dir_name = dir->par_name;
mutex_lock(&dent_list_lock_lha0);
list_for_each_entry(entry, &dent_list, list_node)
if (!strcmp(entry->par_name, p_dir_name)
&& !strcmp(entry->self_name, c_dir_name)) {
parent = entry->self;
break;
}
mutex_unlock(&dent_list_lock_lha0);
p_dir_name = c_dir_name;
c_dir_name = name;
if (parent != NULL) {
if (dir->b_dir_create) {
dent = debugfs_create_dir(name, parent);
if (dent != NULL)
glink_dfs_update_list(dent, parent,
c_dir_name, p_dir_name);
} else {
file_data = glink_dfs_create_file(name, parent, show,
dbgfs_data, b_free_req);
spin_lock_irqsave(&entry->file_list_lock_lhb0, flags);
if (file_data != NULL)
list_add_tail(&file_data->flist,
&entry->file_list);
spin_unlock_irqrestore(&entry->file_list_lock_lhb0,
flags);
}
} else {
GLINK_DBG("%s: parent dentry is null for [%s]\n",
__func__, name);
}
return dent;
}
EXPORT_SYMBOL(glink_debugfs_create);
/**
* glink_debugfs_init() - initialize the glink debugfs directory structure
*
* Return: 0 in success otherwise appropriate error code
*
* This function initializes the debugfs directory for glink
*/
int glink_debugfs_init(void)
{
struct glink_dbgfs dbgfs;
/* fake parent name */
dent = debugfs_create_dir("glink", NULL);
if (IS_ERR_OR_NULL(dent))
return PTR_ERR(dent);
glink_dfs_update_list(dent, NULL, "glink", "root");
dbgfs.b_dir_create = true;
dbgfs.curr_name = "glink";
dbgfs.par_name = "root";
glink_debugfs_create("xprt", NULL, &dbgfs, NULL, false);
glink_debugfs_create("channel", NULL, &dbgfs, NULL, false);
dbgfs.curr_name = "channel";
dbgfs.par_name = "glink";
dbgfs.b_dir_create = false;
glink_debugfs_create("channels", glink_dfs_create_channel_list,
&dbgfs, NULL, false);
dbgfs.curr_name = "xprt";
glink_debugfs_create("xprts", glink_dfs_create_xprt_list,
&dbgfs, NULL, false);
return 0;
}
EXPORT_SYMBOL(glink_debugfs_init);
/**
* glink_debugfs_exit() - removes the glink debugfs directory
*
* This function recursively remove all the debugfs directories
* starting from dent
*/
void glink_debugfs_exit(void)
{
if (dent != NULL)
debugfs_remove_recursive(dent);
}
EXPORT_SYMBOL(glink_debugfs_exit);
#else
void glink_debugfs_remove_recur(struct glink_dbgfs *dfs) { }
EXPORT_SYMBOL(glink_debugfs_remove_recur);
void glink_debugfs_remove_channel(struct channel_ctx *ch_ctx,
struct glink_core_xprt_ctx *xprt_ctx) { }
EXPORT_SYMBOL(glink_debugfs_remove_channel);
void glink_debugfs_add_channel(struct channel_ctx *ch_ctx,
struct glink_core_xprt_ctx *xprt_ctx) { }
EXPORT_SYMBOL(glink_debugfs_add_channel);
void glink_debugfs_add_xprt(struct glink_core_xprt_ctx *xprt_ctx) { }
EXPORT_SYMBOL(glink_debugfs_add_xprt);
int glink_debugfs_init(void) { return 0; }
EXPORT_SYMBOL(glink_debugfs_init);
void glink_debugfs_exit(void) { }
EXPORT_SYMBOL(glink_debugfs_exit);
#endif /* CONFIG_DEBUG_FS */
Reference in a new issue Copy permalink