static void zfcp_erp_wakeup(struct zfcp_adapter *adapter)
{
unsigned long flags;
read_lock_irqsave(&zfcp_data.config_lock, flags);
read_lock(&adapter->erp_lock);
if (list_empty(&adapter->erp_ready_head) &&
list_empty(&adapter->erp_running_head)) {
atomic_clear_mask(ZFCP_STATUS_ADAPTER_ERP_PENDING,
&adapter->status);
wake_up(&adapter->erp_done_wqh);
}
read_unlock(&adapter->erp_lock);
read_unlock_irqrestore(&zfcp_data.config_lock, flags);
}
/**
* adf_interface_modelist - get interface's modelist
*
* @intf: the interface
* @modelist: storage for the modelist (optional)
* @n_modes: length of @modelist
*
* If @modelist is not NULL, adf_interface_modelist() will copy up to @n_modes
* modelist entries into @modelist.
*
* Returns the length of the modelist.
*/
size_t adf_interface_modelist(struct adf_interface *intf,
struct drm_mode_modeinfo *modelist, size_t n_modes)
{
unsigned long flags;
size_t retval;
read_lock_irqsave(&intf->hotplug_modelist_lock, flags);
if (modelist)
memcpy(modelist, intf->modelist, sizeof(modelist[0]) *
min(n_modes, intf->n_modes));
retval = intf->n_modes;
read_unlock_irqrestore(&intf->hotplug_modelist_lock, flags);
return retval;
}
int
EvSubscribeGroupEvents(EvUserID_t userID,
EvGroupID_t groupID, EvAccess_t accessCode,
int (*kernelCB)(EvUserID_t, int, EvGroupID_t,
EvGroupID_t, EvClassID_t, EvEventID_t,
int, int, int, int, int, void *))
{
EvKernelInfo_t *EventUser;
EvGroupInfo_t *EGroup;
unsigned long Flags;
read_lock_irqsave(&EvUsersLock, Flags);
if ((EventUser = EvCheckUser(userID)) == NULL) {
read_unlock_irqrestore(&EvUsersLock, Flags);
return -EV_ERROR_USER_EXISTS;
}
write_lock(&EvGroupLock);
read_unlock(&EvUsersLock);
if ((EGroup = EvGetGroupBase(groupID)) == NULL) {
write_unlock_irqrestore(&EvGroupLock, Flags);
return -EV_ERROR_GROUP_EXIST;
}
/* Check the access code for the group. */
if (EvCheckAccessCode(EGroup->EgiAccessCode, accessCode)) {
write_unlock_irqrestore(&EvGroupLock, Flags);
return -EV_ERROR_GROUP_ACCESS;
}
/* Check that there are no current control processes. */
if (EGroup->EgiGroupDest.EdID != 0) {
write_unlock_irqrestore(&EvGroupLock, Flags);
return -EV_ERROR_GROUP_BUSY;
}
EGroup->EgiGroupDest.EdPri = 0; /* Not used. */
EGroup->EgiGroupDest.EdID = userID;
EGroup->EgiGroupDest.EdUinfo = NULL;
EGroup->EgiGroupDest.EdCB = kernelCB;
EGroup->EgiGroupDest.EdKinfo = EventUser;
EGroup->EgiUseCount++;
write_unlock_irqrestore(&EvGroupLock, Flags);
return EV_NOERR;
}
int ib_get_cached_lmc(struct ib_device *device,
u8 port_num,
u8 *lmc)
{
unsigned long flags;
int ret = 0;
if (!rdma_is_port_valid(device, port_num))
return -EINVAL;
read_lock_irqsave(&device->cache.lock, flags);
*lmc = device->cache.ports[port_num - rdma_start_port(device)].lmc;
read_unlock_irqrestore(&device->cache.lock, flags);
return ret;
}
/**
* zfcp_get_unit_by_lun - find unit in unit list of port by FCP LUN
* @port: pointer to port to search for unit
* @fcp_lun: FCP LUN to search for
*
* Returns: pointer to zfcp_unit or NULL
*/
struct zfcp_unit *zfcp_get_unit_by_lun(struct zfcp_port *port, u64 fcp_lun)
{
unsigned long flags;
struct zfcp_unit *unit;
read_lock_irqsave(&port->unit_list_lock, flags);
list_for_each_entry(unit, &port->unit_list, list)
if (unit->fcp_lun == fcp_lun) {
if (!get_device(&unit->dev))
unit = NULL;
read_unlock_irqrestore(&port->unit_list_lock, flags);
return unit;
}
read_unlock_irqrestore(&port->unit_list_lock, flags);
return NULL;
}
int ib_get_cached_lmc(struct ib_device *device,
u8 port_num,
u8 *lmc)
{
unsigned long flags;
int ret = 0;
if (port_num < start_port(device) || port_num > end_port(device))
return -EINVAL;
read_lock_irqsave(&device->cache.lock, flags);
*lmc = device->cache.lmc_cache[port_num - start_port(device)];
read_unlock_irqrestore(&device->cache.lock, flags);
return ret;
}
static int mt_sched_debug_show(struct seq_file *m, void *v)
{
struct task_struct *g, *p;
unsigned long flags;
SEQ_printf(m, "=== mt Scheduler Profiling ===\n");
SEQ_printf(m,
"\nrunnable tasks:\n"
" task PID switches prio"
" exec-runtime sum-exec sum-sleep\n"
"------------------------------------------------------"
"----------------------------------------------------\n");
read_lock_irqsave(&tasklist_lock, flags);
do_each_thread(g, p) {
print_task(m, p);
} while_each_thread(g, p);
static ssize_t ksb_debug_show(struct seq_file *s, void *unused)
{
unsigned long flags;
struct ks_bridge *ksb = s->private;
int i;
read_lock_irqsave(&ksb->dbg_lock, flags);
for (i = 0; i < DBG_MAX_MSG; i++) {
if (i == (ksb->dbg_idx - 1))
seq_printf(s, "-->%s\n", ksb->dbgbuf[i]);
else
seq_printf(s, "%s\n", ksb->dbgbuf[i]);
}
read_unlock_irqrestore(&ksb->dbg_lock, flags);
return 0;
}
/* Care must be taken to only invoke hp_sdc_spin_ibf when
* absolutely needed, or in rarely invoked subroutines.
* Not only does it waste CPU cycles, it also wastes bus cycles.
*/
static inline void hp_sdc_spin_ibf(void) {
unsigned long flags;
rwlock_t *lock;
lock = &hp_sdc.ibf_lock;
read_lock_irqsave(lock, flags);
if (!hp_sdc.ibf) {
read_unlock_irqrestore(lock, flags);
return;
}
read_unlock(lock);
write_lock(lock);
while (sdc_readb(hp_sdc.status_io) & HP_SDC_STATUS_IBF) {};
hp_sdc.ibf = 0;
write_unlock_irqrestore(lock, flags);
}
/**
* zfcp_get_port_by_wwpn - find port in port list of adapter by wwpn
* @adapter: pointer to adapter to search for port
* @wwpn: wwpn to search for
*
* Returns: pointer to zfcp_port or NULL
*/
struct zfcp_port *zfcp_get_port_by_wwpn(struct zfcp_adapter *adapter,
u64 wwpn)
{
unsigned long flags;
struct zfcp_port *port;
read_lock_irqsave(&adapter->port_list_lock, flags);
list_for_each_entry(port, &adapter->port_list, list)
if (port->wwpn == wwpn) {
if (!get_device(&port->dev))
port = NULL;
read_unlock_irqrestore(&adapter->port_list_lock, flags);
return port;
}
read_unlock_irqrestore(&adapter->port_list_lock, flags);
return NULL;
}
/* determine if a buffer is from our "safe" pool */
static inline struct safe_buffer *
find_safe_buffer(struct dmabounce_device_info *device_info, dma_addr_t safe_dma_addr)
{
struct safe_buffer *b, *rb = NULL;
unsigned long flags;
read_lock_irqsave(&device_info->lock, flags);
list_for_each_entry(b, &device_info->safe_buffers, node)
if (b->safe_dma_addr == safe_dma_addr) {
rb = b;
break;
}
read_unlock_irqrestore(&device_info->lock, flags);
return rb;
}
void mlx4_en_fill_hwtstamps(struct mlx4_en_dev *mdev,
struct skb_shared_hwtstamps *hwts,
uint64_t timestamp)
{
panic("Disabled");
#if 0 // AKAROS_PORT
unsigned long flags;
uint64_t nsec;
read_lock_irqsave(&mdev->clock_lock, flags);
nsec = timecounter_cyc2time(&mdev->clock, timestamp);
read_unlock_irqrestore(&mdev->clock_lock, flags);
memset(hwts, 0, sizeof(struct skb_shared_hwtstamps));
hwts->hwtstamp = ns_to_ktime(nsec);
#endif
}
int ib_get_cached_subnet_prefix(struct ib_device *device,
u8 port_num,
u64 *sn_pfx)
{
unsigned long flags;
int p;
if (!rdma_is_port_valid(device, port_num))
return -EINVAL;
p = port_num - rdma_start_port(device);
read_lock_irqsave(&device->cache.lock, flags);
*sn_pfx = device->cache.ports[p].subnet_prefix;
read_unlock_irqrestore(&device->cache.lock, flags);
return 0;
}
/**
* mipv6_bcache_exists - check if entry exists
* @home_addr: address to check
*
* Determines if a binding exists for @home_addr. Returns type of the
* entry or negative if entry does not exist.
**/
int mipv6_bcache_exists(struct in6_addr *home_addr)
{
unsigned long flags;
struct mipv6_bcache_entry *entry;
DEBUG_FUNC();
if (home_addr == NULL) return -1;
read_lock_irqsave(&bcache->lock, flags);
entry = (struct mipv6_bcache_entry *)
hashlist_get(bcache->entries, home_addr);
read_unlock_irqrestore(&bcache->lock, flags);
if(entry == NULL) return -1;
return entry->type;
}
static int ehci_hsic_msm_ctrl_events_show(struct seq_file *s, void *unused)
{
unsigned long flags;
unsigned i;
read_lock_irqsave(&dbg_hsic_ctrl.lck, flags);
i = dbg_hsic_ctrl.idx;
for (dbg_inc(&i); i != dbg_hsic_ctrl.idx; dbg_inc(&i)) {
if (!strnlen(dbg_hsic_ctrl.buf[i], DBG_MSG_LEN))
continue;
seq_printf(s, "%s\n", dbg_hsic_ctrl.buf[i]);
}
read_unlock_irqrestore(&dbg_hsic_ctrl.lck, flags);
return 0;
}
int
pm_send_to_host(PM_MESSAGE opcode, void *msg, size_t len)
{
// FUNCTION_ENTRY;
int err = 0;
size_t psize = sizeof(pm_msg_header) + len;
char *payload;
unsigned long flags;
if (pm_scif->con_state != PM_CONNECTED) {
err = -EINVAL;
goto error;
}
if (!(payload = kmalloc(psize, GFP_ATOMIC))) {
err = -ENOMEM;
goto error;
}
read_lock_irqsave(&pmscif_send,flags);
if (atomic_xchg(&epinuse,1) != 0) {
read_unlock_irqrestore(&pmscif_send,flags);
kfree(payload);
return -1;
}
((pm_msg_header*)payload)->opcode = opcode;
((pm_msg_header*)payload)->len = len;
if (len)
memcpy((char*)payload + sizeof(pm_msg_header), msg, len);
//0 for non blocking
if ((err = scif_send(pm_scif->ep, payload, psize, 0)) < 0) {
PM_DB("scif_recv failed\n");
}
atomic_set(&epinuse,0);
//for (i = 0; i < psize; i++)
// printk(KERN_ALERT" buff: %X\n", payload[i]);
read_unlock_irqrestore(&pmscif_send,flags);
kfree(payload);
// FUNCTION_EXIT;
error:
return err;
}
/*
* This version of gettimeofday has near microsecond resolution.
*/
void do_gettimeofday(struct timeval *tv)
{
unsigned long flags;
unsigned long usec, sec;
read_lock_irqsave(&xtime_lock, flags);
usec = 0;
sec = xtime.tv_sec;
usec += (xtime.tv_nsec / 1000);
read_unlock_irqrestore(&xtime_lock, flags);
while (usec >= 1000000) {
usec -= 1000000;
sec++;
}
tv->tv_sec = sec;
tv->tv_usec = usec;
}
// Get map_entry if the map is present in the map hash table.
// Returns NULL if not present. Takes a read lock on __stp_tf_map_lock.
static struct __stp_tf_map_entry *
__stp_tf_get_map_entry(struct task_struct *tsk)
{
struct hlist_head *head;
struct hlist_node *node;
struct __stp_tf_map_entry *entry;
unsigned long flags;
read_lock_irqsave(&__stp_tf_map_lock, flags);
head = &__stp_tf_map_table[__stp_tf_map_hash(tsk)];
hlist_for_each_entry(entry, node, head, hlist) {
if (tsk->pid == entry->pid) {
read_unlock_irqrestore(&__stp_tf_map_lock, flags);
return entry;
}
}
read_unlock_irqrestore(&__stp_tf_map_lock, flags);
return NULL;
}
/* This can be called from any context since it saves CPU flags */
static eg_cache_entry *eg_cache_get_by_vcc(struct atm_vcc *vcc, struct mpoa_client *mpc)
{
unsigned long flags;
eg_cache_entry *entry;
read_lock_irqsave(&mpc->egress_lock, flags);
entry = mpc->eg_cache;
while (entry != NULL) {
if (entry->shortcut == vcc) {
atomic_inc(&entry->use);
read_unlock_irqrestore(&mpc->egress_lock, flags);
return entry;
}
entry = entry->next;
}
read_unlock_irqrestore(&mpc->egress_lock, flags);
return NULL;
}
/* This can be called from any context since it saves CPU flags */
static eg_cache_entry *eg_cache_get_by_tag(__be32 tag, struct mpoa_client *mpc)
{
unsigned long flags;
eg_cache_entry *entry;
read_lock_irqsave(&mpc->egress_lock, flags);
entry = mpc->eg_cache;
while (entry != NULL) {
if (entry->ctrl_info.tag == tag) {
atomic_inc(&entry->use);
read_unlock_irqrestore(&mpc->egress_lock, flags);
return entry;
}
entry = entry->next;
}
read_unlock_irqrestore(&mpc->egress_lock, flags);
return NULL;
}
int ib_find_cached_pkey(struct ib_device *device,
u8 port_num,
u16 pkey,
u16 *index)
{
struct ib_pkey_cache *cache;
unsigned long flags;
int i;
int ret = -ENOENT;
int partial_ix = -1;
if (port_num < start_port(device) || port_num > end_port(device))
return -EINVAL;
*index = -1;
read_lock_irqsave(&device->cache.lock, flags);
if (!device->cache.pkey_cache)
goto out;
cache = device->cache.pkey_cache[port_num - start_port(device)];
if (!cache)
goto out;
for (i = 0; i < cache->table_len; ++i)
if ((cache->table[i] & 0x7fff) == (pkey & 0x7fff)) {
if (cache->table[i] & 0x8000) {
*index = i;
ret = 0;
break;
} else
partial_ix = i;
}
if (ret && partial_ix >= 0) {
*index = partial_ix;
ret = 0;
}
out:
read_unlock_irqrestore(&device->cache.lock, flags);
return ret;
}
/* debugfs: cpu monitor (for all) */
static int debugfs_cpu_all_show(struct seq_file *m, void *v){
struct sysinfo_snapshot *p;
unsigned long flags;
int i;
u64 sum_user, sum_nice, sum_system, sum_idle, sum_iowait, sum_irq, sum_softirq;
read_lock_irqsave(&sysinfo_snapshot_lock, flags);
seq_printf(m, "\"epoch time\",\"user\",\"nice\",\"system\",\"idle\",\"iowait\",\"irq\",\"soft irq\"\n");
for(p = snapshot_head; p != NULL; p = p->next){
sum_user = 0;
sum_nice = 0;
sum_system = 0;
sum_idle = 0;
sum_iowait = 0;
sum_irq = 0;
sum_softirq = 0;
for(i = 0; i < p->num_cpu; i++){
sum_user += p->cpuinfo_list[i].user;
sum_nice += p->cpuinfo_list[i].nice;
sum_system += p->cpuinfo_list[i].system;
sum_idle += p->cpuinfo_list[i].idle;
sum_iowait += p->cpuinfo_list[i].iowait;
sum_irq += p->cpuinfo_list[i].irq;
sum_softirq += p->cpuinfo_list[i].softirq;
}
seq_printf(m, "%lld,%llu,%llu,%llu,%llu,%llu,%llu,%llu\n",
p->epoch_time,
sum_user,
sum_nice,
sum_system,
sum_idle,
sum_iowait,
sum_irq,
sum_softirq);
}
read_unlock_irqrestore(&sysinfo_snapshot_lock,flags);
return 0;
}
static int debugfs_memory_show(struct seq_file *m, void *v){
struct sysinfo_snapshot *p;
unsigned long flags;
read_lock_irqsave(&sysinfo_snapshot_lock, flags);
seq_printf(m, "\"epoch time\",\"Total RAM\",\"Free RAM\",\"Shared RAM\",\"Cached RAM\",\"Buffered RAM\",\"Total swap\",\"Free swap\"\n");
for(p = snapshot_head; p != NULL; p = p->next){
seq_printf(m, "%lld,%lu,%lu,%lu,%lu,%lu,%lu,%lu\n",
p->epoch_time,
K(p->total_ram),
K(p->free_ram),
K(p->shared_ram),
K(p->cached_ram),
K(p->buffer_ram),
K(p->total_swap),
K(p->free_swap)
);
}
read_unlock_irqrestore(&sysinfo_snapshot_lock,flags);
return 0;
}
/**
* rdma_read_gid_attr_ndev_rcu - Read GID attribute netdevice
* which must be in UP state.
*
* @attr:Pointer to the GID attribute
*
* Returns pointer to netdevice if the netdevice was attached to GID and
* netdevice is in UP state. Caller must hold RCU lock as this API
* reads the netdev flags which can change while netdevice migrates to
* different net namespace. Returns ERR_PTR with error code otherwise.
*
*/
struct net_device *rdma_read_gid_attr_ndev_rcu(const struct ib_gid_attr *attr)
{
struct ib_gid_table_entry *entry =
container_of(attr, struct ib_gid_table_entry, attr);
struct ib_device *device = entry->attr.device;
struct net_device *ndev = ERR_PTR(-ENODEV);
u8 port_num = entry->attr.port_num;
struct ib_gid_table *table;
unsigned long flags;
bool valid;
table = rdma_gid_table(device, port_num);
read_lock_irqsave(&table->rwlock, flags);
valid = is_gid_entry_valid(table->data_vec[attr->index]);
if (valid && attr->ndev && (READ_ONCE(attr->ndev->flags) & IFF_UP))
ndev = attr->ndev;
read_unlock_irqrestore(&table->rwlock, flags);
return ndev;
}
MHI_STATUS mhi_client_recycle_trb(mhi_client_handle *client_handle)
{
unsigned long flags;
u32 chan = client_handle->chan;
MHI_STATUS ret_val = MHI_STATUS_SUCCESS;
mhi_device_ctxt *mhi_dev_ctxt = client_handle->mhi_dev_ctxt;
struct mutex *chan_mutex = &mhi_dev_ctxt->mhi_chan_mutex[chan];
mhi_ring *local_ctxt = NULL;
u64 db_value;
local_ctxt = &client_handle->mhi_dev_ctxt->mhi_local_chan_ctxt[chan];
mutex_lock(chan_mutex);
MHI_TX_TRB_SET_LEN(TX_TRB_LEN,
(mhi_xfer_pkt *)local_ctxt->ack_rp,
TRB_MAX_DATA_SIZE);
*(mhi_xfer_pkt *)local_ctxt->wp =
*(mhi_xfer_pkt *)local_ctxt->ack_rp;
ret_val = delete_element(local_ctxt, &local_ctxt->ack_rp,
&local_ctxt->rp, NULL);
ret_val = ctxt_add_element(local_ctxt, NULL);
db_value = mhi_v2p_addr(mhi_dev_ctxt->mhi_ctrl_seg_info,
(uintptr_t)local_ctxt->wp);
read_lock_irqsave(&mhi_dev_ctxt->xfer_lock, flags);
atomic_inc(&mhi_dev_ctxt->flags.data_pending);
if (mhi_dev_ctxt->flags.link_up) {
if (MHI_STATE_M0 == mhi_dev_ctxt->mhi_state ||
MHI_STATE_M1 == mhi_dev_ctxt->mhi_state) {
mhi_assert_device_wake(mhi_dev_ctxt);
MHI_WRITE_DB(mhi_dev_ctxt, mhi_dev_ctxt->channel_db_addr, chan, db_value);
} else if (mhi_dev_ctxt->flags.pending_M3 ||
mhi_dev_ctxt->mhi_state == MHI_STATE_M3) {
mhi_wake_dev_from_m3(mhi_dev_ctxt);
}
}
atomic_dec(&mhi_dev_ctxt->flags.data_pending);
read_unlock_irqrestore(&mhi_dev_ctxt->xfer_lock, flags);
mhi_dev_ctxt->mhi_chan_cntr[chan].pkts_xferd++;
mutex_unlock(chan_mutex);
return ret_val;
}
void start_record_task(void)
{
unsigned long long ts;
struct task_struct *g, *p;
unsigned long flags;
int cpu = 0;
mtsched_enabled = 1;
prof_start_ts = sched_clock();
cpu0_idletime_start = mtprof_get_cpu_idle(cpu);// cpu'0', notified SMP
cpu0_iowait_start = mtprof_get_cpu_iowait(cpu);
#ifdef CONFIG_SMP
cpu1_idletime_start = mtprof_get_cpu_idle(1);
cpu1_iowait_start = mtprof_get_cpu_iowait(1);
#endif
ts = sched_clock();
// for_each_online_cpu(cpu){
read_lock_irqsave(&tasklist_lock, flags);
do_each_thread(g, p) {
setup_mtproc_info(p, ts);
} while_each_thread(g, p);
static void print_rq(struct seq_file *m, struct rq *rq, int rq_cpu)
{
struct task_struct *g, *p;
unsigned long flags;
SEQ_printf(m,
"\nrunnable tasks:\n"
" task PID tree-key switches prio"
" exec-runtime sum-exec sum-sleep\n"
"------------------------------------------------------"
"----------------------------------------------------\n");
read_lock_irqsave(&tasklist_lock, flags);
for_each_process_thread(g, p) {
if (!p->on_rq || task_cpu(p) != rq_cpu)
continue;
print_task(m, rq, p);
}
read_unlock_irqrestore(&tasklist_lock, flags);
}
void mlx5e_fill_hwstamp(struct mlx5e_tstamp *tstamp,
struct skb_shared_hwtstamps *hwts,
u64 timestamp)
{
#if defined (HAVE_PTP_CLOCK_INFO) && (defined (CONFIG_PTP_1588_CLOCK) || defined(CONFIG_PTP_1588_CLOCK_MODULE))
unsigned long flags;
u64 nsec;
memset(hwts, 0, sizeof(struct skb_shared_hwtstamps));
if (!tstamp->ptp)
return;
read_lock_irqsave(&tstamp->lock, flags);
nsec = timecounter_cyc2time(&tstamp->clock, timestamp);
read_unlock_irqrestore(&tstamp->lock, flags);
hwts->hwtstamp = ns_to_ktime(nsec);
#else
memset(hwts, 0, sizeof(struct skb_shared_hwtstamps));
#endif
}
static void octeon_irq_ciu1_enable(unsigned int irq)
{
int coreid = cvmx_get_core_num();
unsigned long flags;
uint64_t en1;
int bit = irq - OCTEON_IRQ_WDOG0; /* Bit 0-63 of EN1 */
/*
* A read lock is used here to make sure only one core is ever
* updating the CIU enable bits at a time. During an enable
* the cores don't interfere with each other. During a disable
* the write lock stops any enables that might cause a
* problem.
*/
read_lock_irqsave(&octeon_irq_ciu1_rwlock, flags);
en1 = cvmx_read_csr(CVMX_CIU_INTX_EN1(coreid * 2 + 1));
en1 |= 1ull << bit;
cvmx_write_csr(CVMX_CIU_INTX_EN1(coreid * 2 + 1), en1);
cvmx_read_csr(CVMX_CIU_INTX_EN1(coreid * 2 + 1));
read_unlock_irqrestore(&octeon_irq_ciu1_rwlock, flags);
}
static bool driver_filter(struct device *dev)
{
struct device_driver *drv;
unsigned long flags;
bool ret;
/* driver filter off */
if (likely(!current_driver_name[0]))
return true;
/* driver filter on and initialized */
if (current_driver && dev && dev->driver == current_driver)
return true;
/* driver filter on, but we can't filter on a NULL device... */
if (!dev)
return false;
if (current_driver || !current_driver_name[0])
return false;
/* driver filter on but not yet initialized */
drv = dev->driver;
if (!drv)
return false;
/* lock to protect against change of current_driver_name */
read_lock_irqsave(&driver_name_lock, flags);
ret = false;
if (drv->name &&
strncmp(current_driver_name, drv->name, NAME_MAX_LEN - 1) == 0) {
current_driver = drv;
ret = true;
}
read_unlock_irqrestore(&driver_name_lock, flags);
return ret;
}
