lisa/android_kernel_xiaomi_sm8350
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

qcacld-3.0: Integrate DSC (debugfs)

Browse Source 
As part of DSC integration, replace remaining cds_ssr_protect/unprotect
with appropriate osif_sync op start/stop calls in debugfs callback
handlers.

Change-Id: I416743c713997fa8ba98c69e2876efcefe8af9cb
CRs-Fixed: 2409166
This commit is contained in:
Dustin Brown 2019-03-04 11:49:24 -08:00 committed by nshrivas
parent e3eca74d76
commit 094ce6b202
3 changed files with 178 additions and 159 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

109
core/hdd/src/wlan_hdd_debugfs.c
View File

@ -26,6 +26,7 @@
*/ */
#ifdef WLAN_OPEN_SOURCE #ifdef WLAN_OPEN_SOURCE
#include "osif_sync.h"
#include <wlan_hdd_includes.h> #include <wlan_hdd_includes.h>
#include <wlan_hdd_debugfs.h> #include <wlan_hdd_debugfs.h>
#include <wlan_osif_request_manager.h> #include <wlan_osif_request_manager.h>
@ -84,18 +85,18 @@ bool hdd_wait_for_debugfs_threads_completion(void)
/** /**
* __wcnss_wowpattern_write() - wow_pattern debugfs handler * __wcnss_wowpattern_write() - wow_pattern debugfs handler
* @file: debugfs file handle * @net_dev: net_device context used to register the debugfs file
* @buf: text being written to the debugfs * @buf: text being written to the debugfs
* @count: size of @buf * @count: size of @buf
* @ppos: (unused) offset into the virtual file system * @ppos: (unused) offset into the virtual file system
* *
* Return: number of bytes processed * Return: number of bytes processed
*/ */
static ssize_t __wcnss_wowpattern_write(struct file *file, static ssize_t __wcnss_wowpattern_write(struct net_device *net_dev,
const char __user *buf, size_t count, const char __user *buf, size_t count,
loff_t *ppos) loff_t *ppos)
{ {
struct hdd_adapter *adapter = (struct hdd_adapter *) file->private_data; struct hdd_adapter *adapter = WLAN_HDD_GET_PRIV_PTR(net_dev);
struct hdd_context *hdd_ctx; struct hdd_context *hdd_ctx;
char cmd[MAX_USER_COMMAND_SIZE_WOWL_PATTERN + 1]; char cmd[MAX_USER_COMMAND_SIZE_WOWL_PATTERN + 1];
char *sptr, *token; char *sptr, *token;
@ -107,7 +108,7 @@ static ssize_t __wcnss_wowpattern_write(struct file *file,
hdd_enter(); hdd_enter();
if ((NULL == adapter) || (WLAN_HDD_ADAPTER_MAGIC != adapter->magic)) { if (adapter->magic != WLAN_HDD_ADAPTER_MAGIC) {
hdd_err("Invalid adapter or adapter has invalid magic"); hdd_err("Invalid adapter or adapter has invalid magic");
return -EINVAL; return -EINVAL;
} }
@ -192,29 +193,35 @@ static ssize_t wcnss_wowpattern_write(struct file *file,
const char __user *buf, const char __user *buf,
size_t count, loff_t *ppos) size_t count, loff_t *ppos)
{ {
ssize_t ret; struct net_device *net_dev = file_inode(file)->i_private;
struct osif_vdev_sync *vdev_sync;
ssize_t err_size;
cds_ssr_protect(__func__); err_size = osif_vdev_sync_op_start(net_dev, &vdev_sync);
ret = __wcnss_wowpattern_write(file, buf, count, ppos); if (err_size)
cds_ssr_unprotect(__func__); return err_size;
return ret; err_size = __wcnss_wowpattern_write(net_dev, buf, count, ppos);
osif_vdev_sync_op_stop(vdev_sync);
return err_size;
} }
/** /**
* wcnss_patterngen_write() - pattern_gen debugfs handler * wcnss_patterngen_write() - pattern_gen debugfs handler
* @file: debugfs file handle * @net_dev: net_device context used to register the debugfs file
* @buf: text being written to the debugfs * @buf: text being written to the debugfs
* @count: size of @buf * @count: size of @buf
* @ppos: (unused) offset into the virtual file system * @ppos: (unused) offset into the virtual file system
* *
* Return: number of bytes processed * Return: number of bytes processed
*/ */
static ssize_t __wcnss_patterngen_write(struct file *file, static ssize_t __wcnss_patterngen_write(struct net_device *net_dev,
const char __user *buf, size_t count, const char __user *buf, size_t count,
loff_t *ppos) loff_t *ppos)
{ {
struct hdd_adapter *adapter; struct hdd_adapter *adapter = WLAN_HDD_GET_PRIV_PTR(net_dev);
struct hdd_context *hdd_ctx; struct hdd_context *hdd_ctx;
tSirAddPeriodicTxPtrn *addPeriodicTxPtrnParams; tSirAddPeriodicTxPtrn *addPeriodicTxPtrnParams;
tSirDelPeriodicTxPtrn *delPeriodicTxPtrnParams; tSirDelPeriodicTxPtrn *delPeriodicTxPtrnParams;
@ -230,8 +237,7 @@ static ssize_t __wcnss_patterngen_write(struct file *file,
hdd_enter(); hdd_enter();
adapter = (struct hdd_adapter *)file->private_data; if (adapter->magic != WLAN_HDD_ADAPTER_MAGIC) {
if ((NULL == adapter) || (WLAN_HDD_ADAPTER_MAGIC != adapter->magic)) {
hdd_err("Invalid adapter or adapter has invalid magic"); hdd_err("Invalid adapter or adapter has invalid magic");
return -EINVAL; return -EINVAL;
} }
@ -410,45 +416,46 @@ static ssize_t wcnss_patterngen_write(struct file *file,
const char __user *buf, const char __user *buf,
size_t count, loff_t *ppos) size_t count, loff_t *ppos)
{ {
ssize_t ret; struct net_device *net_dev = file_inode(file)->i_private;
struct osif_vdev_sync *vdev_sync;
ssize_t err_size;
cds_ssr_protect(__func__); err_size = osif_vdev_sync_op_start(net_dev, &vdev_sync);
ret = __wcnss_patterngen_write(file, buf, count, ppos); if (err_size)
cds_ssr_unprotect(__func__); return err_size;
return ret; err_size = __wcnss_patterngen_write(net_dev, buf, count, ppos);
osif_vdev_sync_op_stop(vdev_sync);
return err_size;
} }
/** /**
* __wcnss_debugfs_open() - Generic debugfs open() handler * __wcnss_debugfs_open() - Generic debugfs open() handler
* @inode: inode of the debugfs file * @net_dev: net_device context used to register the debugfs file
* @file: file handle of the debugfs file
* *
* Return: 0 * Return: Errno
*/ */
static int __wcnss_debugfs_open(struct inode *inode, struct file *file) static int __wcnss_debugfs_open(struct net_device *net_dev)
{ {
struct hdd_adapter *adapter; struct hdd_adapter *adapter = WLAN_HDD_GET_PRIV_PTR(net_dev);
struct hdd_context *hdd_ctx; struct hdd_context *hdd_ctx;
int ret; int errno;
hdd_enter(); hdd_enter();
if (inode->i_private) if (adapter->magic != WLAN_HDD_ADAPTER_MAGIC) {
file->private_data = inode->i_private;
adapter = (struct hdd_adapter *)file->private_data;
if ((NULL == adapter) || (WLAN_HDD_ADAPTER_MAGIC != adapter->magic)) {
hdd_err("Invalid adapter or adapter has invalid magic"); hdd_err("Invalid adapter or adapter has invalid magic");
return -EINVAL; return -EINVAL;
} }
hdd_ctx = WLAN_HDD_GET_CTX(adapter); hdd_ctx = WLAN_HDD_GET_CTX(adapter);
ret = wlan_hdd_validate_context(hdd_ctx); errno = wlan_hdd_validate_context(hdd_ctx);
if (0 != ret)
return ret;
hdd_exit(); hdd_exit();
return 0;
return errno;
} }
/** /**
@ -460,13 +467,19 @@ static int __wcnss_debugfs_open(struct inode *inode, struct file *file)
*/ */
static int wcnss_debugfs_open(struct inode *inode, struct file *file) static int wcnss_debugfs_open(struct inode *inode, struct file *file)
{ {
int ret; struct net_device *net_dev = inode->i_private;
struct osif_vdev_sync *vdev_sync;
int errno;
cds_ssr_protect(__func__); errno = osif_vdev_sync_op_start(net_dev, &vdev_sync);
ret = __wcnss_debugfs_open(inode, file); if (errno)
cds_ssr_unprotect(__func__); return errno;
return ret; errno = __wcnss_debugfs_open(net_dev);
osif_vdev_sync_op_stop(vdev_sync);
return errno;
} }
static const struct file_operations fops_wowpattern = { static const struct file_operations fops_wowpattern = {
@ -497,24 +510,24 @@ static const struct file_operations fops_patterngen = {
*/ */
QDF_STATUS hdd_debugfs_init(struct hdd_adapter *adapter) QDF_STATUS hdd_debugfs_init(struct hdd_adapter *adapter)
{ {
struct net_device *dev = adapter->dev; struct net_device *net_dev = adapter->dev;
adapter->debugfs_phy = debugfs_create_dir(dev->name, 0); adapter->debugfs_phy = debugfs_create_dir(net_dev->name, 0);
if (NULL == adapter->debugfs_phy) if (NULL == adapter->debugfs_phy)
return QDF_STATUS_E_FAILURE; return QDF_STATUS_E_FAILURE;
if (NULL == debugfs_create_file("wow_pattern", 00400 | 00200, if (NULL == debugfs_create_file("wow_pattern", 00400 | 00200,
adapter->debugfs_phy, adapter, adapter->debugfs_phy, net_dev,
&fops_wowpattern)) &fops_wowpattern))
return QDF_STATUS_E_FAILURE; return QDF_STATUS_E_FAILURE;
if (NULL == debugfs_create_file("pattern_gen", 00400 | 00200, if (NULL == debugfs_create_file("pattern_gen", 00400 | 00200,
adapter->debugfs_phy, adapter, adapter->debugfs_phy, net_dev,
&fops_patterngen)) &fops_patterngen))
return QDF_STATUS_E_FAILURE; return QDF_STATUS_E_FAILURE;
if (0 != wlan_hdd_create_ll_stats_file(adapter)) if (wlan_hdd_create_ll_stats_file(adapter))
return QDF_STATUS_E_FAILURE; return QDF_STATUS_E_FAILURE;
return QDF_STATUS_SUCCESS; return QDF_STATUS_SUCCESS;

110
core/hdd/src/wlan_hdd_debugfs_csr.c
View File

@ -23,6 +23,7 @@
* debugfs with roaming related information * debugfs with roaming related information
*/ */
#include "osif_sync.h"
#include <wlan_hdd_debugfs_csr.h> #include <wlan_hdd_debugfs_csr.h>
#include <wlan_hdd_main.h> #include <wlan_hdd_main.h>
#include <cds_sched.h> #include <cds_sched.h>
@ -95,7 +96,7 @@ wlan_hdd_debugfs_update_csr(struct hdd_context *hdd_ctx,
/** /**
* __wlan_hdd_read_debugfs_csr() - Function to read debug stats * __wlan_hdd_read_debugfs_csr() - Function to read debug stats
* @file: file pointer * @info: buffer info allocated when the debugfs file was opened
* @buf: buffer * @buf: buffer
* @count: count * @count: count
* @pos: position pointer * @pos: position pointer
@ -103,25 +104,17 @@ wlan_hdd_debugfs_update_csr(struct hdd_context *hdd_ctx,
* Return: Number of bytes read on success, zero otherwise * Return: Number of bytes read on success, zero otherwise
*/ */
static ssize_t static ssize_t
__wlan_hdd_read_debugfs_csr(struct file *file, char __user *buf, __wlan_hdd_read_debugfs_csr(struct wlan_hdd_debugfs_buffer_info *info,
size_t count, loff_t *pos) char __user *buf, size_t count, loff_t *pos)
{ {
struct wlan_hdd_debugfs_buffer_info *info; struct hdd_adapter *adapter = info->adapter;
struct hdd_adapter *adapter;
struct hdd_context *hdd_ctx; struct hdd_context *hdd_ctx;
int ret; int ret;
ssize_t length; ssize_t length;
hdd_enter(); hdd_enter();
info = file->private_data; if (adapter->magic != WLAN_HDD_ADAPTER_MAGIC) {
if (!info || !info->data) {
hdd_err("No valid private data");
return 0;
}
adapter = info->adapter;
if ((!adapter) || (adapter->magic != WLAN_HDD_ADAPTER_MAGIC)) {
hdd_err("Invalid adapter or adapter has invalid magic"); hdd_err("Invalid adapter or adapter has invalid magic");
return 0; return 0;
} }
@ -165,42 +158,40 @@ static ssize_t
wlan_hdd_read_debugfs_csr(struct file *file, char __user *buf, wlan_hdd_read_debugfs_csr(struct file *file, char __user *buf,
size_t count, loff_t *pos) size_t count, loff_t *pos)
{ {
int ret; struct wlan_hdd_debugfs_buffer_info *info = file->private_data;
struct osif_vdev_sync *vdev_sync;
ssize_t err_size;
cds_ssr_protect(__func__); err_size = osif_vdev_sync_op_start(info->adapter->dev, &vdev_sync);
ret = __wlan_hdd_read_debugfs_csr(file, buf, count, pos); if (err_size)
cds_ssr_unprotect(__func__); return err_size;
return ret; err_size = __wlan_hdd_read_debugfs_csr(info, buf, count, pos);
osif_vdev_sync_op_stop(vdev_sync);
return err_size;
} }
/** /**
* __wlan_hdd_open_debugfs_csr() - Allocates memory for private data * __wlan_hdd_open_debugfs_csr() - Allocates memory for private data
* @inode: Pointer to inode structure * @adapter: the HDD adapter to operate against
* @csr: file info used to register the debugfs file
* @file: file pointer * @file: file pointer
* *
* Return: zero * Return: Errno
*/ */
static int __wlan_hdd_open_debugfs_csr(struct inode *inode, static int __wlan_hdd_open_debugfs_csr(struct hdd_adapter *adapter,
struct hdd_debugfs_file_info *csr,
struct file *file) struct file *file)
{ {
struct wlan_hdd_debugfs_buffer_info *info; struct wlan_hdd_debugfs_buffer_info *info;
struct hdd_debugfs_file_info *csr;
struct hdd_adapter *adapter = NULL;
struct hdd_context *hdd_ctx; struct hdd_context *hdd_ctx;
int ret; int ret;
hdd_enter(); hdd_enter();
csr = inode->i_private; if (adapter->magic != WLAN_HDD_ADAPTER_MAGIC) {
if (!csr) {
hdd_err("No private data");
return -EINVAL;
}
adapter = qdf_container_of(csr, struct hdd_adapter,
csr_file[csr->id]);
if (!adapter || (adapter->magic != WLAN_HDD_ADAPTER_MAGIC)) {
hdd_err("Invalid adapter or adapter has invalid magic"); hdd_err("Invalid adapter or adapter has invalid magic");
return -EINVAL; return -EINVAL;
} }
@ -240,47 +231,48 @@ static int __wlan_hdd_open_debugfs_csr(struct inode *inode,
/** /**
* wlan_hdd_open_debugfs_csr() - SSR wrapper function to allocate memory for * wlan_hdd_open_debugfs_csr() - SSR wrapper function to allocate memory for
* private data on file open * private data on file open
* @inode: Pointer to inode structure * @inode: Pointer to inode structure
* @file: file pointer * @file: file pointer
* *
* Return: zero * Return: Errno
*/ */
static int wlan_hdd_open_debugfs_csr(struct inode *inode, static int wlan_hdd_open_debugfs_csr(struct inode *inode, struct file *file)
struct file *file)
{ {
int ret; struct hdd_debugfs_file_info *csr = inode->i_private;
struct hdd_adapter *adapter = qdf_container_of(csr, struct hdd_adapter,
csr_file[csr->id]);
struct osif_vdev_sync *vdev_sync;
int errno;
cds_ssr_protect(__func__); errno = osif_vdev_sync_op_start(adapter->dev, &vdev_sync);
if (errno)
return errno;
hdd_debugfs_thread_increment(); hdd_debugfs_thread_increment();
ret = __wlan_hdd_open_debugfs_csr(inode, file); errno = __wlan_hdd_open_debugfs_csr(adapter, csr, file);
if (ret) if (errno)
hdd_debugfs_thread_decrement(); hdd_debugfs_thread_decrement();
cds_ssr_unprotect(__func__); osif_vdev_sync_op_stop(vdev_sync);
return ret; return errno;
} }
/** /**
* __wlan_hdd_release_debugfs_csr() - Function to free private memory on * __wlan_hdd_release_debugfs_csr() - Function to free private memory on
* release * release
* @inode: Pointer to inode structure
* @file: file pointer * @file: file pointer
* *
* Return: zero * Return: Errno
*/ */
static int __wlan_hdd_release_debugfs_csr(struct inode *inode, static int
struct file *file) __wlan_hdd_release_debugfs_csr(struct file *file)
{ {
struct wlan_hdd_debugfs_buffer_info *info = file->private_data; struct wlan_hdd_debugfs_buffer_info *info = file->private_data;
hdd_enter(); hdd_enter();
if (!info)
return 0;
file->private_data = NULL; file->private_data = NULL;
qdf_mem_free(info->data); qdf_mem_free(info->data);
qdf_mem_free(info); qdf_mem_free(info);
@ -296,18 +288,24 @@ static int __wlan_hdd_release_debugfs_csr(struct inode *inode,
* @inode: Pointer to inode structure * @inode: Pointer to inode structure
* @file: file pointer * @file: file pointer
* *
* Return: zero * Return: Errno
*/ */
static int wlan_hdd_release_debugfs_csr(struct inode *inode, struct file *file) static int wlan_hdd_release_debugfs_csr(struct inode *inode, struct file *file)
{ {
int ret; struct wlan_hdd_debugfs_buffer_info *info = file->private_data;
struct osif_vdev_sync *vdev_sync;
int errno;
cds_ssr_protect(__func__); errno = osif_vdev_sync_op_start(info->adapter->dev, &vdev_sync);
ret = __wlan_hdd_release_debugfs_csr(inode, file); if (errno)
return errno;
errno = __wlan_hdd_release_debugfs_csr(file);
hdd_debugfs_thread_decrement(); hdd_debugfs_thread_decrement();
cds_ssr_unprotect(__func__);
return ret; osif_vdev_sync_op_stop(vdev_sync);
return errno;
} }
static const struct file_operations fops_csr_debugfs = { static const struct file_operations fops_csr_debugfs = {

118
core/hdd/src/wlan_hdd_debugfs_llstat.c
View File

@ -1,5 +1,5 @@
/* /*
* Copyright (c) 2012-2018 The Linux Foundation. All rights reserved. * Copyright (c) 2012-2019 The Linux Foundation. All rights reserved.
* *
* Permission to use, copy, modify, and/or distribute this software for * Permission to use, copy, modify, and/or distribute this software for
* any purpose with or without fee is hereby granted, provided that the * any purpose with or without fee is hereby granted, provided that the
@ -23,8 +23,9 @@
* debugfs with Link Layer statistics * debugfs with Link Layer statistics
*/ */
#include <wlan_hdd_debugfs_llstat.h>
#include <cds_sched.h> #include <cds_sched.h>
#include "osif_sync.h"
#include <wlan_hdd_debugfs_llstat.h>
#include <wlan_hdd_stats.h> #include <wlan_hdd_stats.h>
#include <wma_api.h> #include <wma_api.h>
@ -357,31 +358,31 @@ static ssize_t hdd_debugfs_stats_update(char __user *buf, size_t count,
/** /**
* __wlan_hdd_read_ll_stats_debugfs() - API to collect LL stats from FW * __wlan_hdd_read_ll_stats_debugfs() - API to collect LL stats from FW
* @file: file pointer * @net_dev: net_device context used to register the debugfs file
* @buf: buffer * @buf: buffer
* @count: count * @count: count
* @pos: position pointer * @pos: position pointer
* *
* Return: Number of bytes read on success, error number otherwise * Return: Number of bytes read on success, error number otherwise
*/ */
static ssize_t __wlan_hdd_read_ll_stats_debugfs(struct file *file, static ssize_t __wlan_hdd_read_ll_stats_debugfs(struct net_device *net_dev,
char __user *buf, size_t count, loff_t *pos) char __user *buf, size_t count,
loff_t *pos)
{ {
struct hdd_adapter *adapter; struct hdd_adapter *adapter = WLAN_HDD_GET_PRIV_PTR(net_dev);
struct hdd_context *hdd_ctx; struct hdd_context *hdd_ctx;
ssize_t ret = 0; ssize_t ret;
hdd_enter(); hdd_enter();
adapter = (struct hdd_adapter *)file->private_data; if (adapter->magic != WLAN_HDD_ADAPTER_MAGIC) {
if ((!adapter) || (WLAN_HDD_ADAPTER_MAGIC != adapter->magic)) {
hdd_err("Invalid adapter or adapter has invalid magic"); hdd_err("Invalid adapter or adapter has invalid magic");
return -EINVAL; return -EINVAL;
} }
hdd_ctx = WLAN_HDD_GET_CTX(adapter); hdd_ctx = WLAN_HDD_GET_CTX(adapter);
ret = wlan_hdd_validate_context(hdd_ctx); ret = wlan_hdd_validate_context(hdd_ctx);
if (0 != ret) if (ret)
return ret; return ret;
/* All the events are received and buffer is populated */ /* All the events are received and buffer is populated */
@ -389,8 +390,8 @@ static ssize_t __wlan_hdd_read_ll_stats_debugfs(struct file *file,
hdd_info("%zu characters written into debugfs", ret); hdd_info("%zu characters written into debugfs", ret);
hdd_exit(); hdd_exit();
return ret;
return ret;
} }
/** /**
@ -403,38 +404,38 @@ static ssize_t __wlan_hdd_read_ll_stats_debugfs(struct file *file,
* Return: Number of bytes read on success, error number otherwise * Return: Number of bytes read on success, error number otherwise
*/ */
static ssize_t wlan_hdd_read_ll_stats_debugfs(struct file *file, static ssize_t wlan_hdd_read_ll_stats_debugfs(struct file *file,
char __user *buf, char __user *buf, size_t count,
size_t count, loff_t *pos) loff_t *pos)
{ {
int ret; struct net_device *net_dev = file_inode(file)->i_private;
struct osif_vdev_sync *vdev_sync;
ssize_t err_size;
cds_ssr_protect(__func__); err_size = osif_vdev_sync_op_start(net_dev, &vdev_sync);
ret = __wlan_hdd_read_ll_stats_debugfs(file, buf, count, pos); if (err_size)
cds_ssr_unprotect(__func__); return err_size;
return ret; err_size = __wlan_hdd_read_ll_stats_debugfs(net_dev, buf, count, pos);
osif_vdev_sync_op_stop(vdev_sync);
return err_size;
} }
/** /**
* __wlan_hdd_open_ll_stats_debugfs() - Function to save private on open * __wlan_hdd_open_ll_stats_debugfs() - Function to save private on open
* @inode: Pointer to inode structure * @net_dev: net_device context used to register the debugfs file
* @file: file pointer
* *
* Return: zero * Return: Errno
*/ */
static int __wlan_hdd_open_ll_stats_debugfs(struct inode *inode, static int __wlan_hdd_open_ll_stats_debugfs(struct net_device *net_dev)
struct file *file)
{ {
struct hdd_adapter *adapter; struct hdd_adapter *adapter = WLAN_HDD_GET_PRIV_PTR(net_dev);
struct hdd_context *hdd_ctx; struct hdd_context *hdd_ctx;
int errno; int errno;
hdd_enter(); hdd_enter();
if (inode->i_private)
file->private_data = inode->i_private;
adapter = (struct hdd_adapter *)file->private_data;
errno = hdd_validate_adapter(adapter); errno = hdd_validate_adapter(adapter);
if (errno) if (errno)
return errno; return errno;
@ -467,57 +468,58 @@ free_buf:
/** /**
* wlan_hdd_open_ll_stats_debugfs() - SSR wrapper function to save private * wlan_hdd_open_ll_stats_debugfs() - SSR wrapper function to save private
* on open * on open
* @inode: Pointer to inode structure * @inode: Pointer to inode structure
* @file: file pointer * @file: file pointer
* *
* Return: zero * Return: Errno
*/ */
static int wlan_hdd_open_ll_stats_debugfs(struct inode *inode, static int wlan_hdd_open_ll_stats_debugfs(struct inode *inode,
struct file *file) struct file *file)
{ {
int ret; struct net_device *net_dev = inode->i_private;
struct osif_vdev_sync *vdev_sync;
int errno;
cds_ssr_protect(__func__); errno = osif_vdev_sync_op_start(net_dev, &vdev_sync);
ret = __wlan_hdd_open_ll_stats_debugfs(inode, file); if (errno)
cds_ssr_unprotect(__func__); return errno;
return ret; errno = __wlan_hdd_open_ll_stats_debugfs(net_dev);
osif_vdev_sync_op_stop(vdev_sync);
return errno;
} }
/** /**
* __wlan_hdd_release_ll_stats_debugfs() - Function to save private on release * __wlan_hdd_release_ll_stats_debugfs() - Function to save private on release
* @inode: Pointer to inode structure * @net_dev: net_device context used to register the debugfs file
* @file: file pointer
* *
* Return: zero * Return: Errno
*/ */
static int __wlan_hdd_release_ll_stats_debugfs(struct inode *inode, static int __wlan_hdd_release_ll_stats_debugfs(struct net_device *net_dev)
struct file *file)
{ {
struct hdd_adapter *adapter; struct hdd_adapter *adapter = WLAN_HDD_GET_PRIV_PTR(net_dev);
struct hdd_context *hdd_ctx; struct hdd_context *hdd_ctx;
int ret; int ret;
hdd_enter(); hdd_enter();
if (inode->i_private) if (adapter->magic != WLAN_HDD_ADAPTER_MAGIC) {
file->private_data = inode->i_private;
adapter = (struct hdd_adapter *)file->private_data;
if ((NULL == adapter) || (WLAN_HDD_ADAPTER_MAGIC != adapter->magic)) {
hdd_err("Invalid adapter or adapter has invalid magic"); hdd_err("Invalid adapter or adapter has invalid magic");
return -EINVAL; return -EINVAL;
} }
hdd_ctx = WLAN_HDD_GET_CTX(adapter); hdd_ctx = WLAN_HDD_GET_CTX(adapter);
ret = wlan_hdd_validate_context(hdd_ctx); ret = wlan_hdd_validate_context(hdd_ctx);
if (0 != ret) if (ret)
return ret; return ret;
wlan_hdd_llstats_free_buf(); wlan_hdd_llstats_free_buf();
hdd_exit(); hdd_exit();
return 0; return 0;
} }
@ -527,18 +529,24 @@ static int __wlan_hdd_release_ll_stats_debugfs(struct inode *inode,
* @inode: Pointer to inode structure * @inode: Pointer to inode structure
* @file: file pointer * @file: file pointer
* *
* Return: zero * Return: Errno
*/ */
static int wlan_hdd_release_ll_stats_debugfs(struct inode *inode, static int wlan_hdd_release_ll_stats_debugfs(struct inode *inode,
struct file *file) struct file *file)
{ {
int ret; struct net_device *net_dev = file_inode(file)->i_private;
struct osif_vdev_sync *vdev_sync;
int errno;
cds_ssr_protect(__func__); errno = osif_vdev_sync_op_start(net_dev, &vdev_sync);
ret = __wlan_hdd_release_ll_stats_debugfs(inode, file); if (errno)
cds_ssr_unprotect(__func__); return errno;
return ret; errno = __wlan_hdd_release_ll_stats_debugfs(net_dev);
osif_vdev_sync_op_stop(vdev_sync);
return errno;
} }
static const struct file_operations fops_ll_stats_debugfs = { static const struct file_operations fops_ll_stats_debugfs = {
@ -552,7 +560,7 @@ static const struct file_operations fops_ll_stats_debugfs = {
int wlan_hdd_create_ll_stats_file(struct hdd_adapter *adapter) int wlan_hdd_create_ll_stats_file(struct hdd_adapter *adapter)
{ {
if (!debugfs_create_file("ll_stats", 0444, adapter->debugfs_phy, if (!debugfs_create_file("ll_stats", 0444, adapter->debugfs_phy,
adapter, &fops_ll_stats_debugfs)) adapter->dev, &fops_ll_stats_debugfs))
return -EINVAL; return -EINVAL;
return 0; return 0;