OpenE2K/linux
6
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
0b0a635f79
linux/drivers/isdn/hardware/eicon/divasi.c
Arnd Bergmann 76a64921da isdn: autoconvert trivial BKL users to private mutex 
All these files use the big kernel lock in a trivial
way to serialize their private file operations,
typically resulting from an earlier semi-automatic
pushdown from VFS.

None of these drivers appears to want to lock against
other code, and they all use the BKL as the top-level
lock in their file operations, meaning that there
is no lock-order inversion problem.

Consequently, we can remove the BKL completely,
replacing it with a per-file mutex in every case.
Using a scripted approach means we can avoid
typos.

file=$1
name=$2
if grep -q lock_kernel ${file} ; then
    if grep -q 'include.*linux.mutex.h' ${file} ; then
            sed -i '/include.*<linux\/smp_lock.h>/d' ${file}
    else
            sed -i 's/include.*<linux\/smp_lock.h>.*$/include <linux\/mutex.h>/g' ${file}
    fi
    sed -i ${file} \
        -e "/^#include.*linux.mutex.h/,$ {
                1,/^\(static\|int\|long\)/ {
                     /^\(static\|int\|long\)/istatic DEFINE_MUTEX(${name}_mutex);

} }"  \
    -e "s/\(un\)*lock_kernel\>[ ]*()/mutex_\1lock(\&${name}_mutex)/g" \
    -e '/[      ]*cycle_kernel_lock();/d'
else
    sed -i -e '/include.*\<smp_lock.h\>/d' ${file}  \
                -e '/cycle_kernel_lock()/d'
fi

Signed-off-by: Arnd Bergmann <arnd@arndb.de>
Cc: Karsten Keil <isdn@linux-pingi.de>
Cc: netdev@vger.kernel.org
Signed-off-by: David S. Miller <davem@davemloft.net>
2010-07-12 20:21:47 -07:00

578 lines
12 KiB
C
Raw Blame History

/* $Id: divasi.c,v 1.25.6.2 2005/01/31 12:22:20 armin Exp $
*
* Driver for Eicon DIVA Server ISDN cards.
* User Mode IDI Interface
*
* Copyright 2000-2003 by Armin Schindler (mac@melware.de)
* Copyright 2000-2003 Cytronics & Melware (info@melware.de)
*
* This software may be used and distributed according to the terms
* of the GNU General Public License, incorporated herein by reference.
*/
#include <linux/module.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/poll.h>
#include <linux/proc_fs.h>
#include <linux/skbuff.h>
#include <linux/seq_file.h>
#include <asm/uaccess.h>
#include "platform.h"
#include "di_defs.h"
#include "divasync.h"
#include "um_xdi.h"
#include "um_idi.h"
static char *main_revision = "$Revision: 1.25.6.2 $";
static int major;
MODULE_DESCRIPTION("User IDI Interface for Eicon ISDN cards");
MODULE_AUTHOR("Cytronics & Melware, Eicon Networks");
MODULE_SUPPORTED_DEVICE("DIVA card driver");
MODULE_LICENSE("GPL");
typedef struct _diva_um_idi_os_context {
wait_queue_head_t read_wait;
wait_queue_head_t close_wait;
struct timer_list diva_timer_id;
int aborted;
int adapter_nr;
} diva_um_idi_os_context_t;
static char *DRIVERNAME = "Eicon DIVA - User IDI (http://www.melware.net)";
static char *DRIVERLNAME = "diva_idi";
static char *DEVNAME = "DivasIDI";
char *DRIVERRELEASE_IDI = "2.0";
extern int idifunc_init(void);
extern void idifunc_finit(void);
/*
* helper functions
*/
static char *getrev(const char *revision)
{
char *rev;
char *p;
if ((p = strchr(revision, ':'))) {
rev = p + 2;
p = strchr(rev, '$');
*--p = 0;
} else
rev = "1.0";
return rev;
}
/*
* LOCALS
*/
static ssize_t um_idi_read(struct file *file, char __user *buf, size_t count,
loff_t * offset);
static ssize_t um_idi_write(struct file *file, const char __user *buf,
size_t count, loff_t * offset);
static unsigned int um_idi_poll(struct file *file, poll_table * wait);
static int um_idi_open(struct inode *inode, struct file *file);
static int um_idi_release(struct inode *inode, struct file *file);
static int remove_entity(void *entity);
static void diva_um_timer_function(unsigned long data);
/*
* proc entry
*/
extern struct proc_dir_entry *proc_net_eicon;
static struct proc_dir_entry *um_idi_proc_entry = NULL;
static int um_idi_proc_show(struct seq_file *m, void *v)
{
char tmprev[32];
seq_printf(m, "%s\n", DRIVERNAME);
seq_printf(m, "name : %s\n", DRIVERLNAME);
seq_printf(m, "release : %s\n", DRIVERRELEASE_IDI);
strcpy(tmprev, main_revision);
seq_printf(m, "revision : %s\n", getrev(tmprev));
seq_printf(m, "build : %s\n", DIVA_BUILD);
seq_printf(m, "major : %d\n", major);
return 0;
}
static int um_idi_proc_open(struct inode *inode, struct file *file)
{
return single_open(file, um_idi_proc_show, NULL);
}
static const struct file_operations um_idi_proc_fops = {
.owner = THIS_MODULE,
.open = um_idi_proc_open,
.read = seq_read,
.llseek = seq_lseek,
.release = single_release,
};
static int DIVA_INIT_FUNCTION create_um_idi_proc(void)
{
um_idi_proc_entry = proc_create(DRIVERLNAME, S_IRUGO, proc_net_eicon,
&um_idi_proc_fops);
if (!um_idi_proc_entry)
return (0);
return (1);
}
static void remove_um_idi_proc(void)
{
if (um_idi_proc_entry) {
remove_proc_entry(DRIVERLNAME, proc_net_eicon);
um_idi_proc_entry = NULL;
}
}
static const struct file_operations divas_idi_fops = {
.owner = THIS_MODULE,
.llseek = no_llseek,
.read = um_idi_read,
.write = um_idi_write,
.poll = um_idi_poll,
.open = um_idi_open,
.release = um_idi_release
};
static void divas_idi_unregister_chrdev(void)
{
unregister_chrdev(major, DEVNAME);
}
static int DIVA_INIT_FUNCTION divas_idi_register_chrdev(void)
{
if ((major = register_chrdev(0, DEVNAME, &divas_idi_fops)) < 0)
{
printk(KERN_ERR "%s: failed to create /dev entry.\n",
DRIVERLNAME);
return (0);
}
return (1);
}
/*
** Driver Load
*/
static int DIVA_INIT_FUNCTION divasi_init(void)
{
char tmprev[50];
int ret = 0;
printk(KERN_INFO "%s\n", DRIVERNAME);
printk(KERN_INFO "%s: Rel:%s Rev:", DRIVERLNAME, DRIVERRELEASE_IDI);
strcpy(tmprev, main_revision);
printk("%s Build: %s\n", getrev(tmprev), DIVA_BUILD);
if (!divas_idi_register_chrdev()) {
ret = -EIO;
goto out;
}
if (!create_um_idi_proc()) {
divas_idi_unregister_chrdev();
printk(KERN_ERR "%s: failed to create proc entry.\n",
DRIVERLNAME);
ret = -EIO;
goto out;
}
if (!(idifunc_init())) {
remove_um_idi_proc();
divas_idi_unregister_chrdev();
printk(KERN_ERR "%s: failed to connect to DIDD.\n",
DRIVERLNAME);
ret = -EIO;
goto out;
}
printk(KERN_INFO "%s: started with major %d\n", DRIVERLNAME, major);
out:
return (ret);
}
/*
** Driver Unload
*/
static void DIVA_EXIT_FUNCTION divasi_exit(void)
{
idifunc_finit();
remove_um_idi_proc();
divas_idi_unregister_chrdev();
printk(KERN_INFO "%s: module unloaded.\n", DRIVERLNAME);
}
module_init(divasi_init);
module_exit(divasi_exit);
/*
* FILE OPERATIONS
*/
static int
divas_um_idi_copy_to_user(void *os_handle, void *dst, const void *src,
int length)
{
memcpy(dst, src, length);
return (length);
}
static ssize_t
um_idi_read(struct file *file, char __user *buf, size_t count, loff_t * offset)
{
diva_um_idi_os_context_t *p_os;
int ret = -EINVAL;
void *data;
if (!file->private_data) {
return (-ENODEV);
}
if (!
(p_os =
(diva_um_idi_os_context_t *) diva_um_id_get_os_context(file->
private_data)))
{
return (-ENODEV);
}
if (p_os->aborted) {
return (-ENODEV);
}
if (!(data = diva_os_malloc(0, count))) {
return (-ENOMEM);
}
ret = diva_um_idi_read(file->private_data,
file, data, count,
divas_um_idi_copy_to_user);
switch (ret) {
case 0: /* no message available */
ret = (-EAGAIN);
break;
case (-1): /* adapter was removed */
ret = (-ENODEV);
break;
case (-2): /* message_length > length of user buffer */
ret = (-EFAULT);
break;
}
if (ret > 0) {
if (copy_to_user(buf, data, ret)) {
ret = (-EFAULT);
}
}
diva_os_free(0, data);
DBG_TRC(("read: ret %d", ret));
return (ret);
}
static int
divas_um_idi_copy_from_user(void *os_handle, void *dst, const void *src,
int length)
{
memcpy(dst, src, length);
return (length);
}
static int um_idi_open_adapter(struct file *file, int adapter_nr)
{
diva_um_idi_os_context_t *p_os;
void *e =
divas_um_idi_create_entity((dword) adapter_nr, (void *) file);
if (!(file->private_data = e)) {
return (0);
}
p_os = (diva_um_idi_os_context_t *) diva_um_id_get_os_context(e);
init_waitqueue_head(&p_os->read_wait);
init_waitqueue_head(&p_os->close_wait);
init_timer(&p_os->diva_timer_id);
p_os->diva_timer_id.function = (void *) diva_um_timer_function;
p_os->diva_timer_id.data = (unsigned long) p_os;
p_os->aborted = 0;
p_os->adapter_nr = adapter_nr;
return (1);
}
static ssize_t
um_idi_write(struct file *file, const char __user *buf, size_t count,
loff_t * offset)
{
diva_um_idi_os_context_t *p_os;
int ret = -EINVAL;
void *data;
int adapter_nr = 0;
if (!file->private_data) {
/* the first write() selects the adapter_nr */
if (count == sizeof(int)) {
if (copy_from_user
((void *) &adapter_nr, buf,
count)) return (-EFAULT);
if (!(um_idi_open_adapter(file, adapter_nr)))
return (-ENODEV);
return (count);
} else
return (-ENODEV);
}
if (!(p_os =
(diva_um_idi_os_context_t *) diva_um_id_get_os_context(file->
private_data)))
{
return (-ENODEV);
}
if (p_os->aborted) {
return (-ENODEV);
}
if (!(data = diva_os_malloc(0, count))) {
return (-ENOMEM);
}
if (copy_from_user(data, buf, count)) {
ret = -EFAULT;
} else {
ret = diva_um_idi_write(file->private_data,
file, data, count,
divas_um_idi_copy_from_user);
switch (ret) {
case 0: /* no space available */
ret = (-EAGAIN);
break;
case (-1): /* adapter was removed */
ret = (-ENODEV);
break;
case (-2): /* length of user buffer > max message_length */
ret = (-EFAULT);
break;
}
}
diva_os_free(0, data);
DBG_TRC(("write: ret %d", ret));
return (ret);
}
static unsigned int um_idi_poll(struct file *file, poll_table * wait)
{
diva_um_idi_os_context_t *p_os;
if (!file->private_data) {
return (POLLERR);
}
if ((!(p_os =
(diva_um_idi_os_context_t *)
diva_um_id_get_os_context(file->private_data)))
|| p_os->aborted) {
return (POLLERR);
}
poll_wait(file, &p_os->read_wait, wait);
if (p_os->aborted) {
return (POLLERR);
}
switch (diva_user_mode_idi_ind_ready(file->private_data, file)) {
case (-1):
return (POLLERR);
case 0:
return (0);
}
return (POLLIN | POLLRDNORM);
}
static int um_idi_open(struct inode *inode, struct file *file)
{
return (0);
}
static int um_idi_release(struct inode *inode, struct file *file)
{
diva_um_idi_os_context_t *p_os;
unsigned int adapter_nr;
int ret = 0;
if (!(file->private_data)) {
ret = -ENODEV;
goto out;
}
if (!(p_os =
(diva_um_idi_os_context_t *) diva_um_id_get_os_context(file->private_data))) {
ret = -ENODEV;
goto out;
}
adapter_nr = p_os->adapter_nr;
if ((ret = remove_entity(file->private_data))) {
goto out;
}
if (divas_um_idi_delete_entity
((int) adapter_nr, file->private_data)) {
ret = -ENODEV;
goto out;
}
out:
return (ret);
}
int diva_os_get_context_size(void)
{
return (sizeof(diva_um_idi_os_context_t));
}
void diva_os_wakeup_read(void *os_context)
{
diva_um_idi_os_context_t *p_os =
(diva_um_idi_os_context_t *) os_context;
wake_up_interruptible(&p_os->read_wait);
}
void diva_os_wakeup_close(void *os_context)
{
diva_um_idi_os_context_t *p_os =
(diva_um_idi_os_context_t *) os_context;
wake_up_interruptible(&p_os->close_wait);
}
static
void diva_um_timer_function(unsigned long data)
{
diva_um_idi_os_context_t *p_os = (diva_um_idi_os_context_t *) data;
p_os->aborted = 1;
wake_up_interruptible(&p_os->read_wait);
wake_up_interruptible(&p_os->close_wait);
DBG_ERR(("entity removal watchdog"))
}
/*
** If application exits without entity removal this function will remove
** entity and block until removal is complete
*/
static int remove_entity(void *entity)
{
struct task_struct *curtask = current;
diva_um_idi_os_context_t *p_os;
diva_um_idi_stop_wdog(entity);
if (!entity) {
DBG_FTL(("Zero entity on remove"))
return (0);
}
if (!(p_os =
(diva_um_idi_os_context_t *)
diva_um_id_get_os_context(entity))) {
DBG_FTL(("Zero entity os context on remove"))
return (0);
}
if (!divas_um_idi_entity_assigned(entity) || p_os->aborted) {
/*
Entity is not assigned, also can be removed
*/
return (0);
}
DBG_TRC(("E(%08x) check remove", entity))
/*
If adapter not answers on remove request inside of
10 Sec, then adapter is dead
*/
diva_um_idi_start_wdog(entity);
{
DECLARE_WAITQUEUE(wait, curtask);
add_wait_queue(&p_os->close_wait, &wait);
for (;;) {
set_current_state(TASK_INTERRUPTIBLE);
if (!divas_um_idi_entity_start_remove(entity)
|| p_os->aborted) {
break;
}
schedule();
}
set_current_state(TASK_RUNNING);
remove_wait_queue(&p_os->close_wait, &wait);
}
DBG_TRC(("E(%08x) start remove", entity))
{
DECLARE_WAITQUEUE(wait, curtask);
add_wait_queue(&p_os->close_wait, &wait);
for (;;) {
set_current_state(TASK_INTERRUPTIBLE);
if (!divas_um_idi_entity_assigned(entity)
|| p_os->aborted) {
break;
}
schedule();
}
set_current_state(TASK_RUNNING);
remove_wait_queue(&p_os->close_wait, &wait);
}
DBG_TRC(("E(%08x) remove complete, aborted:%d", entity,
p_os->aborted))
diva_um_idi_stop_wdog(entity);
p_os->aborted = 0;
return (0);
}
/*
* timer watchdog
*/
void diva_um_idi_start_wdog(void *entity)
{
diva_um_idi_os_context_t *p_os;
if (entity &&
((p_os =
(diva_um_idi_os_context_t *)
diva_um_id_get_os_context(entity)))) {
mod_timer(&p_os->diva_timer_id, jiffies + 10 * HZ);
}
}
void diva_um_idi_stop_wdog(void *entity)
{
diva_um_idi_os_context_t *p_os;
if (entity &&
((p_os =
(diva_um_idi_os_context_t *)
diva_um_id_get_os_context(entity)))) {
del_timer(&p_os->diva_timer_id);
}
}
Reference in New Issue View Git Blame Copy Permalink