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 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;
}

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;
}

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;
}