type stringclasses 5
values | content stringlengths 9 163k |
|---|---|
functions | long get_nr_dentry_unused(void)
{
int i;
long sum = 0;
for_each_possible_cpu(i)
sum += per_cpu(nr_dentry_unused, i);
return sum < 0 ? 0 : sum;
} |
functions | int proc_nr_dentry(ctl_table *table, int write, void __user *buffer,
size_t *lenp, loff_t *ppos)
{
dentry_stat.nr_dentry = get_nr_dentry();
dentry_stat.nr_unused = get_nr_dentry_unused();
return proc_doulongvec_minmax(table, write, buffer, lenp, ppos);
} |
functions | int dentry_string_cmp(const unsigned char *cs, const unsigned char *ct, unsigned tcount)
{
unsigned long a,b,mask;
for (;;) {
a = *(unsigned long *)cs;
b = load_unaligned_zeropad(ct);
if (tcount < sizeof(unsigned long))
break;
if (unlikely(a != b))
return 1;
cs += sizeof(unsigned long);
ct += sizeo... |
functions | int dentry_string_cmp(const unsigned char *cs, const unsigned char *ct, unsigned tcount)
{
do {
if (*cs != *ct)
return 1;
cs++;
ct++;
tcount--;
} |
functions | int dentry_cmp(const struct dentry *dentry, const unsigned char *ct, unsigned tcount)
{
const unsigned char *cs;
/*
* Be careful about RCU walk racing with rename:
* use ACCESS_ONCE to fetch the name pointer.
*
* NOTE! Even if a rename will mean that the length
* was not loaded atomically, we don't care. Th... |
functions | void __d_free(struct rcu_head *head)
{
struct dentry *dentry = container_of(head, struct dentry, d_u.d_rcu);
if (dname_external(dentry))
kfree(dentry->d_name.name);
kmem_cache_free(dentry_cache, dentry);
} |
functions | void dentry_free(struct dentry *dentry)
{
/* if dentry was never visible to RCU, immediate free is OK */
if (!(dentry->d_flags & DCACHE_RCUACCESS))
__d_free(&dentry->d_u.d_rcu);
else
call_rcu(&dentry->d_u.d_rcu, __d_free);
} |
functions | void dentry_rcuwalk_barrier(struct dentry *dentry)
{
assert_spin_locked(&dentry->d_lock);
/* Go through a barrier */
write_seqcount_barrier(&dentry->d_seq);
} |
functions | void d_lru_add(struct dentry *dentry)
{
D_FLAG_VERIFY(dentry, 0);
dentry->d_flags |= DCACHE_LRU_LIST;
this_cpu_inc(nr_dentry_unused);
WARN_ON_ONCE(!list_lru_add(&dentry->d_sb->s_dentry_lru, &dentry->d_lru));
} |
functions | void d_lru_del(struct dentry *dentry)
{
D_FLAG_VERIFY(dentry, DCACHE_LRU_LIST);
dentry->d_flags &= ~DCACHE_LRU_LIST;
this_cpu_dec(nr_dentry_unused);
WARN_ON_ONCE(!list_lru_del(&dentry->d_sb->s_dentry_lru, &dentry->d_lru));
} |
functions | void d_shrink_del(struct dentry *dentry)
{
D_FLAG_VERIFY(dentry, DCACHE_SHRINK_LIST | DCACHE_LRU_LIST);
list_del_init(&dentry->d_lru);
dentry->d_flags &= ~(DCACHE_SHRINK_LIST | DCACHE_LRU_LIST);
this_cpu_dec(nr_dentry_unused);
} |
functions | void d_shrink_add(struct dentry *dentry, struct list_head *list)
{
D_FLAG_VERIFY(dentry, 0);
list_add(&dentry->d_lru, list);
dentry->d_flags |= DCACHE_SHRINK_LIST | DCACHE_LRU_LIST;
this_cpu_inc(nr_dentry_unused);
} |
functions | void d_lru_isolate(struct dentry *dentry)
{
D_FLAG_VERIFY(dentry, DCACHE_LRU_LIST);
dentry->d_flags &= ~DCACHE_LRU_LIST;
this_cpu_dec(nr_dentry_unused);
list_del_init(&dentry->d_lru);
} |
functions | void d_lru_shrink_move(struct dentry *dentry, struct list_head *list)
{
D_FLAG_VERIFY(dentry, DCACHE_LRU_LIST);
dentry->d_flags |= DCACHE_SHRINK_LIST;
list_move_tail(&dentry->d_lru, list);
} |
functions | void dentry_lru_add(struct dentry *dentry)
{
if (unlikely(!(dentry->d_flags & DCACHE_LRU_LIST)))
d_lru_add(dentry);
} |
functions | void __d_drop(struct dentry *dentry)
{
if (!d_unhashed(dentry)) {
struct hlist_bl_head *b;
/*
* Hashed dentries are normally on the dentry hashtable,
* with the exception of those newly allocated by
* d_obtain_alias, which are always IS_ROOT:
*/
if (unlikely(IS_ROOT(dentry)))
b = &dentry->d_sb->s_... |
functions | void d_drop(struct dentry *dentry)
{
spin_lock(&dentry->d_lock);
__d_drop(dentry);
spin_unlock(&dentry->d_lock);
} |
functions | void dput(struct dentry *dentry)
{
if (unlikely(!dentry))
return;
repeat:
if (lockref_put_or_lock(&dentry->d_lockref))
return;
/* Unreachable? Get rid of it */
if (unlikely(d_unhashed(dentry)))
goto kill_it;
if (unlikely(dentry->d_flags & DCACHE_DISCONNECTED))
goto kill_it;
if (unlikely(dentry->d_flag... |
functions | int d_invalidate(struct dentry * dentry)
{
/*
* If it's already been dropped, return OK.
*/
spin_lock(&dentry->d_lock);
if (d_unhashed(dentry)) {
spin_unlock(&dentry->d_lock);
return 0;
} |
functions | void __dget_dlock(struct dentry *dentry)
{
dentry->d_lockref.count++;
} |
functions | void __dget(struct dentry *dentry)
{
lockref_get(&dentry->d_lockref);
} |
functions | else if (!want_discon) {
__dget_dlock(alias);
spin_unlock(&alias->d_lock);
return alias;
} |
functions | void d_prune_aliases(struct inode *inode)
{
struct dentry *dentry;
restart:
spin_lock(&inode->i_lock);
hlist_for_each_entry(dentry, &inode->i_dentry, d_u.d_alias) {
spin_lock(&dentry->d_lock);
if (!dentry->d_lockref.count) {
/*
* inform the fs via d_prune that this dentry
* is about to be unhashed and... |
functions | void shrink_dentry_list(struct list_head *list)
{
struct dentry *dentry, *parent;
while (!list_empty(list)) {
dentry = list_entry(list->prev, struct dentry, d_lru);
spin_lock(&dentry->d_lock);
/*
* The dispose list is isolated and dentries are not accounted
* to the LRU here, so we can simply remove it f... |
functions | lru_status
dentry_lru_isolate(struct list_head *item, spinlock_t *lru_lock, void *arg)
{
struct list_head *freeable = arg;
struct dentry *dentry = container_of(item, struct dentry, d_lru);
/*
* we are inverting the lru lock/dentry->d_lock here,
* so use a trylock. If we fail to get the lock, just skip
* it
... |
functions | long prune_dcache_sb(struct super_block *sb, unsigned long nr_to_scan,
int nid)
{
LIST_HEAD(dispose);
long freed;
freed = list_lru_walk_node(&sb->s_dentry_lru, nid, dentry_lru_isolate,
&dispose, &nr_to_scan);
shrink_dentry_list(&dispose);
return freed;
} |
functions | lru_status dentry_lru_isolate_shrink(struct list_head *item,
spinlock_t *lru_lock, void *arg)
{
struct list_head *freeable = arg;
struct dentry *dentry = container_of(item, struct dentry, d_lru);
/*
* we are inverting the lru lock/dentry->d_lock here,
* so use a trylock. If we fail to get the lock, just s... |
functions | void shrink_dcache_sb(struct super_block *sb)
{
long freed;
do {
LIST_HEAD(dispose);
freed = list_lru_walk(&sb->s_dentry_lru,
dentry_lru_isolate_shrink, &dispose, UINT_MAX);
this_cpu_sub(nr_dentry_unused, freed);
shrink_dentry_list(&dispose);
} |
functions | d_walk_ret check_mount(void *data, struct dentry *dentry)
{
int *ret = data;
if (d_mountpoint(dentry)) {
*ret = 1;
return D_WALK_QUIT;
} |
functions | int have_submounts(struct dentry *parent)
{
int ret = 0;
d_walk(parent, &ret, check_mount, NULL);
return ret;
} |
functions | int d_set_mounted(struct dentry *dentry)
{
struct dentry *p;
int ret = -ENOENT;
write_seqlock(&rename_lock);
for (p = dentry->d_parent; !IS_ROOT(p); p = p->d_parent) {
/* Need exclusion wrt. check_submounts_and_drop() */
spin_lock(&p->d_lock);
if (unlikely(d_unhashed(p))) {
spin_unlock(&p->d_lock);
goto... |
functions | d_walk_ret select_collect(void *_data, struct dentry *dentry)
{
struct select_data *data = _data;
enum d_walk_ret ret = D_WALK_CONTINUE;
if (data->start == dentry)
goto out;
if (dentry->d_flags & DCACHE_SHRINK_LIST) {
data->found++;
} |
functions | void shrink_dcache_parent(struct dentry *parent)
{
for (;;) {
struct select_data data;
INIT_LIST_HEAD(&data.dispose);
data.start = parent;
data.found = 0;
d_walk(parent, &data, select_collect, NULL);
if (!data.found)
break;
shrink_dentry_list(&data.dispose);
cond_resched();
} |
functions | d_walk_ret umount_check(void *_data, struct dentry *dentry)
{
/* it has busy descendents; complain about those instead */
if (!list_empty(&dentry->d_subdirs))
return D_WALK_CONTINUE;
/* root with refcount 1 is fine */
if (dentry == _data && dentry->d_lockref.count == 1)
return D_WALK_CONTINUE;
printk(KERN_ER... |
functions | void do_one_tree(struct dentry *dentry)
{
shrink_dcache_parent(dentry);
d_walk(dentry, dentry, umount_check, NULL);
d_drop(dentry);
dput(dentry);
} |
functions | void shrink_dcache_for_umount(struct super_block *sb)
{
struct dentry *dentry;
WARN(down_read_trylock(&sb->s_umount), "s_umount should've been locked");
dentry = sb->s_root;
sb->s_root = NULL;
do_one_tree(dentry);
while (!hlist_bl_empty(&sb->s_anon)) {
dentry = dget(hlist_bl_entry(hlist_bl_first(&sb->s_anon)... |
functions | d_walk_ret check_and_collect(void *_data, struct dentry *dentry)
{
struct select_data *data = _data;
if (d_mountpoint(dentry)) {
data->found = -EBUSY;
return D_WALK_QUIT;
} |
functions | void check_and_drop(void *_data)
{
struct select_data *data = _data;
if (d_mountpoint(data->start))
data->found = -EBUSY;
if (!data->found)
__d_drop(data->start);
} |
functions | int check_submounts_and_drop(struct dentry *dentry)
{
int ret = 0;
/* Negative dentries can be dropped without further checks */
if (!dentry->d_inode) {
d_drop(dentry);
goto out;
} |
functions | void d_set_d_op(struct dentry *dentry, const struct dentry_operations *op)
{
WARN_ON_ONCE(dentry->d_op);
WARN_ON_ONCE(dentry->d_flags & (DCACHE_OP_HASH |
DCACHE_OP_COMPARE |
DCACHE_OP_REVALIDATE |
DCACHE_OP_WEAK_REVALIDATE |
DCACHE_OP_DELETE ));
dentry->d_op = op;
if (!op)
return;
if (op->d_hash)... |
functions | unsigned d_flags_for_inode(struct inode *inode)
{
unsigned add_flags = DCACHE_FILE_TYPE;
if (!inode)
return DCACHE_MISS_TYPE;
if (S_ISDIR(inode->i_mode)) {
add_flags = DCACHE_DIRECTORY_TYPE;
if (unlikely(!(inode->i_opflags & IOP_LOOKUP))) {
if (unlikely(!inode->i_op->lookup))
add_flags = DCACHE_AUTODI... |
functions | void __d_instantiate(struct dentry *dentry, struct inode *inode)
{
unsigned add_flags = d_flags_for_inode(inode);
spin_lock(&dentry->d_lock);
__d_set_type(dentry, add_flags);
if (inode)
hlist_add_head(&dentry->d_u.d_alias, &inode->i_dentry);
dentry->d_inode = inode;
dentry_rcuwalk_barrier(dentry);
spin_unlock... |
functions | void d_instantiate(struct dentry *entry, struct inode * inode)
{
BUG_ON(!hlist_unhashed(&entry->d_u.d_alias));
if (inode)
spin_lock(&inode->i_lock);
__d_instantiate(entry, inode);
if (inode)
spin_unlock(&inode->i_lock);
security_d_instantiate(entry, inode);
} |
functions | int d_instantiate_no_diralias(struct dentry *entry, struct inode *inode)
{
BUG_ON(!hlist_unhashed(&entry->d_u.d_alias));
spin_lock(&inode->i_lock);
if (S_ISDIR(inode->i_mode) && !hlist_empty(&inode->i_dentry)) {
spin_unlock(&inode->i_lock);
iput(inode);
return -EBUSY;
} |
functions | slow_d_compare slow_dentry_cmp(
const struct dentry *parent,
struct dentry *dentry,
unsigned int seq,
const struct qstr *name)
{
int tlen = dentry->d_name.len;
const char *tname = dentry->d_name.name;
if (read_seqcount_retry(&dentry->d_seq, seq)) {
cpu_relax();
return D_COMP_SEQRETRY;
} |
functions | int d_validate(struct dentry *dentry, struct dentry *dparent)
{
struct dentry *child;
spin_lock(&dparent->d_lock);
list_for_each_entry(child, &dparent->d_subdirs, d_child) {
if (dentry == child) {
spin_lock_nested(&dentry->d_lock, DENTRY_D_LOCK_NESTED);
__dget_dlock(dentry);
spin_unlock(&dentry->d_lock);... |
functions | void d_delete(struct dentry * dentry)
{
struct inode *inode;
int isdir = 0;
/*
* Are we the only user?
*/
again:
spin_lock(&dentry->d_lock);
inode = dentry->d_inode;
isdir = S_ISDIR(inode->i_mode);
if (dentry->d_lockref.count == 1) {
if (!spin_trylock(&inode->i_lock)) {
spin_unlock(&dentry->d_lock);
... |
functions | void __d_rehash(struct dentry * entry, struct hlist_bl_head *b)
{
BUG_ON(!d_unhashed(entry));
hlist_bl_lock(b);
entry->d_flags |= DCACHE_RCUACCESS;
hlist_bl_add_head_rcu(&entry->d_hash, b);
hlist_bl_unlock(b);
} |
functions | void _d_rehash(struct dentry * entry)
{
__d_rehash(entry, d_hash(entry->d_parent, entry->d_name.hash));
} |
functions | void d_rehash(struct dentry * entry)
{
spin_lock(&entry->d_lock);
_d_rehash(entry);
spin_unlock(&entry->d_lock);
} |
functions | void dentry_update_name_case(struct dentry *dentry, struct qstr *name)
{
BUG_ON(!mutex_is_locked(&dentry->d_parent->d_inode->i_mutex));
BUG_ON(dentry->d_name.len != name->len); /* d_lookup gives this */
spin_lock(&dentry->d_lock);
write_seqcount_begin(&dentry->d_seq);
memcpy((unsigned char *)dentry->d_name.name, ... |
functions | void switch_names(struct dentry *dentry, struct dentry *target)
{
if (dname_external(target)) {
if (dname_external(dentry)) {
/*
* Both external: swap the pointers
*/
swap(target->d_name.name, dentry->d_name.name);
} |
functions | void dentry_lock_for_move(struct dentry *dentry, struct dentry *target)
{
/*
* XXXX: do we really need to take target->d_lock?
*/
if (IS_ROOT(dentry) || dentry->d_parent == target->d_parent)
spin_lock(&target->d_parent->d_lock);
else {
if (d_ancestor(dentry->d_parent, target->d_parent)) {
spin_lock(&dentr... |
functions | void dentry_unlock_parents_for_move(struct dentry *dentry,
struct dentry *target)
{
if (target->d_parent != dentry->d_parent)
spin_unlock(&dentry->d_parent->d_lock);
if (target->d_parent != target)
spin_unlock(&target->d_parent->d_lock);
} |
functions | void __d_move(struct dentry * dentry, struct dentry * target)
{
if (!dentry->d_inode)
printk(KERN_WARNING "VFS: moving negative dcache entry\n");
BUG_ON(d_ancestor(dentry, target));
BUG_ON(d_ancestor(target, dentry));
dentry_lock_for_move(dentry, target);
write_seqcount_begin(&dentry->d_seq);
write_seqcount_... |
functions | void d_move(struct dentry *dentry, struct dentry *target)
{
write_seqlock(&rename_lock);
__d_move(dentry, target);
write_sequnlock(&rename_lock);
} |
functions | void __d_materialise_dentry(struct dentry *dentry, struct dentry *anon)
{
struct dentry *dparent;
dentry_lock_for_move(anon, dentry);
write_seqcount_begin(&dentry->d_seq);
write_seqcount_begin_nested(&anon->d_seq, DENTRY_D_LOCK_NESTED);
dparent = dentry->d_parent;
switch_names(dentry, anon);
swap(dentry->d_n... |
functions | int prepend(char **buffer, int *buflen, const char *str, int namelen)
{
*buflen -= namelen;
if (*buflen < 0)
return -ENAMETOOLONG;
*buffer -= namelen;
memcpy(*buffer, str, namelen);
return 0;
} |
functions | int prepend_name(char **buffer, int *buflen, struct qstr *name)
{
const char *dname = ACCESS_ONCE(name->name);
u32 dlen = ACCESS_ONCE(name->len);
char *p;
smp_read_barrier_depends();
*buflen -= dlen + 1;
if (*buflen < 0)
return -ENAMETOOLONG;
p = *buffer -= dlen + 1;
*p++ = '/';
while (dlen--) {
char c =... |
functions | int prepend_path(const struct path *path,
const struct path *root,
char **buffer, int *buflen)
{
struct dentry *dentry;
struct vfsmount *vfsmnt;
struct mount *mnt;
int error = 0;
unsigned seq, m_seq = 0;
char *bptr;
int blen;
rcu_read_lock();
restart_mnt:
read_seqbegin_or_lock(&mount_lock, &m_seq);
seq... |
functions | int path_with_deleted(const struct path *path,
const struct path *root,
char **buf, int *buflen)
{
prepend(buf, buflen, "\0", 1);
if (d_unlinked(path->dentry)) {
int error = prepend(buf, buflen, " (deleted)", 10);
if (error)
return error;
} |
functions | int prepend_unreachable(char **buffer, int *buflen)
{
return prepend(buffer, buflen, "(unreachable)", 13);
} |
functions | void get_fs_root_rcu(struct fs_struct *fs, struct path *root)
{
unsigned seq;
do {
seq = read_seqcount_begin(&fs->seq);
*root = fs->root;
} |
functions | void get_fs_root_and_pwd_rcu(struct fs_struct *fs, struct path *root,
struct path *pwd)
{
unsigned seq;
do {
seq = read_seqcount_begin(&fs->seq);
*root = fs->root;
*pwd = fs->pwd;
} |
functions | int is_subdir(struct dentry *new_dentry, struct dentry *old_dentry)
{
int result;
unsigned seq;
if (new_dentry == old_dentry)
return 1;
do {
/* for restarting inner loop in case of seq retry */
seq = read_seqbegin(&rename_lock);
/*
* Need rcu_readlock to protect against the d_parent trashing
* due t... |
functions | d_walk_ret d_genocide_kill(void *data, struct dentry *dentry)
{
struct dentry *root = data;
if (dentry != root) {
if (d_unhashed(dentry) || !dentry->d_inode)
return D_WALK_SKIP;
if (!(dentry->d_flags & DCACHE_GENOCIDE)) {
dentry->d_flags |= DCACHE_GENOCIDE;
dentry->d_lockref.count--;
} |
functions | void d_genocide(struct dentry *parent)
{
d_walk(parent, parent, d_genocide_kill, NULL);
} |
functions | void d_tmpfile(struct dentry *dentry, struct inode *inode)
{
inode_dec_link_count(inode);
BUG_ON(dentry->d_name.name != dentry->d_iname ||
!hlist_unhashed(&dentry->d_u.d_alias) ||
!d_unlinked(dentry));
spin_lock(&dentry->d_parent->d_lock);
spin_lock_nested(&dentry->d_lock, DENTRY_D_LOCK_NESTED);
dentry->d_name... |
functions | __init set_dhash_entries(char *str)
{
if (!str)
return 0;
dhash_entries = simple_strtoul(str, &str, 0);
return 1;
} |
functions | __init dcache_init_early(void)
{
unsigned int loop;
/* If hashes are distributed across NUMA nodes, defer
* hash allocation until vmalloc space is available.
*/
if (hashdist)
return;
dentry_hashtable =
alloc_large_system_hash("Dentry cache",
sizeof(struct hlist_bl_head),
dhash_entries,
13,
... |
functions | __init dcache_init(void)
{
unsigned int loop;
/*
* A constructor could be added for stable state like the lists,
* but it is probably not worth it because of the cache nature
* of the dcache.
*/
dentry_cache = KMEM_CACHE(dentry,
SLAB_RECLAIM_ACCOUNT|SLAB_PANIC|SLAB_MEM_SPREAD);
/* Hash may have been s... |
functions | __init vfs_caches_init_early(void)
{
dcache_init_early();
inode_init_early();
} |
functions | __init vfs_caches_init(unsigned long mempages)
{
unsigned long reserve;
/* Base hash sizes on available memory, with a reserve equal to
150% of current kernel size */
reserve = min((mempages - nr_free_pages()) * 3/2, mempages - 1);
mempages -= reserve;
names_cachep = kmem_cache_create("names_cache", ... |
includes | #include <tinyara/wdog.h> |
defines |
#define ETH_P_IP 0x0800 /* Internet Protocol packet */ |
defines | #define ETH_P_ARP 0x0806 /* Address Resolution packet */ |
functions | void slsi_init_dath_path_stats(struct slsi_dev *sdev)
{
dp_stats_g = &sdev->dp_stats;
dp_stats_g->magic_number = SLSI_WLAN_STATS_MAGIC_NUM;
dp_stats_g->sdev = sdev;
} |
functions | void slsi_update_queue_stats(struct slsi_dev *sdev)
{
struct netdev *dev;
struct netdev_vif *ndev_vif;
struct slsi_peer *peer;
int i;
sdev->dp_stats.ac_q_update_status = SLSI_PEER_INVALID;
dev = slsi_get_netdev(sdev, SLSI_NET_INDEX_WLAN);
if (!dev) {
return;
} |
functions | void update_panic_stats(struct slsi_dev *sdev)
{
int i;
sdev->dp_stats.r4_panic_record_offset = __r4_panic_record_offset;
for (i = 0; i < __r4_panic_record_offset; i++) {
sdev->dp_stats.r4_panic_record_stats[i].panic_id = __r4_panic_record_stats[i].panic_id;
sdev->dp_stats.r4_panic_record_stats[i].panic_arg = _... |
functions | void slsi_reset_data_path_stats(void)
{
memset(dp_stats_g, 0, sizeof(struct data_path_stats));
} |
functions | int slsi_tx_eapol(struct slsi_dev *sdev, struct netdev *dev, struct max_buff *mbuf)
{
struct netdev_vif *ndev_vif = netdev_priv(dev);
struct slsi_peer *peer;
u8 *eapol;
u16 msg_type = 0;
u16 proto = ntohs(eth_hdr(mbuf)->h_proto);
int ret = 0;
SLSI_MUTEX_LOCK(ndev_vif->peer_lock);
peer = slsi_get_peer_from_mac(... |
functions | else if (eapol[SLSI_EAPOL_IEEE8021X_TYPE_POS] == SLSI_IEEE8021X_TYPE_EAPOL_KEY) {
msg_type = FAPI_MESSAGETYPE_EAPOL_KEY_M123;
if ((eapol[SLSI_EAPOL_TYPE_POS] == SLSI_EAPOL_TYPE_RSN_KEY || eapol[SLSI_EAPOL_TYPE_POS] == SLSI_EAPOL_TYPE_WPA_KEY) && (eapol[SLSI_EAPOL_KEY_INFO_LOWER_BYTE_POS] & SLSI_EAPOL_KEY_INFO_KE... |
functions | void slsi_alloc_tx_mbuf(struct slsi_dev *sdev)
{
sdev->tx_mbuf = mbuf_alloc(SLSI_TX_MBUF_SIZE);
if (!sdev->tx_mbuf) {
SLSI_ERR(sdev, "Failed to allocate TX mbuf\n");
} |
functions | void slsi_free_tx_mbuf(struct slsi_dev *sdev)
{
if (sdev->tx_mbuf) {
slsi_kfree_mbuf(sdev->tx_mbuf);
} |
functions | int slsi_tx_data(struct slsi_dev *sdev, struct netdev *dev, struct max_buff *mbuf)
{
struct netdev_vif *ndev_vif = netdev_priv(dev);
struct slsi_peer *peer;
u16 len = mbuf->data_len;
int ret = 0;
#ifdef CONFIG_SCSC_TX_FLOW_CONTROL
enum slsi_traffic_q traffic_q;
#endif
if (slsi_is_test_mode_enabled()) {
/* This... |
functions | CONFIG_SCSC_TX_FLOW_CONTROL
if (ret != ERR_OK) {
/* scsc_wifi_transmit_frame failed, decrement BoT counters */
scsc_wifi_fcq_receive_data(dev, &ndev_vif->ap.group_data_qs, slsi_frame_priority_to_ac_queue(mbuf->user_priority));
} |
functions | CONFIG_SLSI_WLAN_STATS
switch (traffic_q) {
case SLSI_TRAFFIC_Q_BE:
SLSI_INCR_DATA_PATH_STATS(sdev->dp_stats.tx_drop_flow_control_be);
break;
case SLSI_TRAFFIC_Q_BK:
SLSI_INCR_DATA_PATH_STATS(sdev->dp_stats.tx_drop_flow_control_bk);
break;
case SLSI_TRAFFIC_Q_VI:
SLSI_INCR_DATA_PATH_STATS(sdev->d... |
functions | int slsi_tx_data_lower(struct slsi_dev *sdev, struct max_buff *mbuf)
{
struct netdev *dev;
struct netdev_vif *ndev_vif;
struct slsi_peer *peer;
u16 vif;
u8 *dest;
int ret;
vif = fapi_get_vif(mbuf);
switch (fapi_get_u16(mbuf, u.ma_unitdata_req.data_unit_descriptor)) {
case FAPI_DATAUNITDESCRIPTOR_IEEE802_3_FR... |
functions | int slsi_tx_control(struct slsi_dev *sdev, struct netdev *dev, struct max_buff *mbuf, bool free_buf)
{
int res = 0;
struct fapi_signal_header *hdr;
if (WARN_ON(!mbuf)) {
res = ERR_VAL;
goto exit;
} |
includes |
#include <tinyara/config.h> |
includes |
#include <string.h> |
includes | #include <debug.h> |
includes |
#include <tinyara/bluetooth/bt_core.h> |
includes | #include <tinyara/bluetooth/bt_hci.h> |
defines |
#define bt_keys_foreach(list, cur, member) \ |
functions | void bt_keys_clear(FAR struct bt_keys_s *keys, int type)
{
FAR struct bt_keys_s **cur;
nvdbg("keys for %s type %d\n", bt_addr_le_str(&keys->addr), type);
if (((type & keys->keys) & BT_KEYS_SLAVE_LTK)) {
bt_keys_foreach(&g_slave_ltks, cur, slave_ltk.next) {
if (*cur == keys) {
*cur = (*cur)->slave_ltk.next... |
functions | void bt_keys_add_type(FAR struct bt_keys_s *keys, int type)
{
if ((keys->keys & type) != 0) {
return;
} |
includes |
#include <sys/time.h> |
includes | #include <stdlib.h> |
defines |
#define CSTRING(txt) \ |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.