X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=drivers%2Fchar%2Fipmi%2Fipmi_watchdog.c;h=1f3159eb1ede18fd146a23c6d14e670acb75860c;hb=987b0145d94eecf292d8b301228356f44611ab7c;hp=2d11ddd99e55e3439229ac2259695604cf2d008d;hpb=f7ed79d23a47594e7834d66a8f14449796d4f3e6;p=linux-2.6.git diff --git a/drivers/char/ipmi/ipmi_watchdog.c b/drivers/char/ipmi/ipmi_watchdog.c index 2d11ddd99..1f3159eb1 100644 --- a/drivers/char/ipmi/ipmi_watchdog.c +++ b/drivers/char/ipmi/ipmi_watchdog.c @@ -39,7 +39,6 @@ #include #include #include -#include #include #include #include @@ -304,22 +303,21 @@ static int ipmi_heartbeat(void); static void panic_halt_ipmi_heartbeat(void); -/* We use a mutex to make sure that only one thing can send a set +/* We use a semaphore to make sure that only one thing can send a set timeout at one time, because we only have one copy of the data. - The mutex is claimed when the set_timeout is sent and freed + The semaphore is claimed when the set_timeout is sent and freed when both messages are free. */ static atomic_t set_timeout_tofree = ATOMIC_INIT(0); -static DEFINE_MUTEX(set_timeout_lock); -static DECLARE_COMPLETION(set_timeout_wait); +static DECLARE_MUTEX(set_timeout_lock); static void set_timeout_free_smi(struct ipmi_smi_msg *msg) { if (atomic_dec_and_test(&set_timeout_tofree)) - complete(&set_timeout_wait); + up(&set_timeout_lock); } static void set_timeout_free_recv(struct ipmi_recv_msg *msg) { if (atomic_dec_and_test(&set_timeout_tofree)) - complete(&set_timeout_wait); + up(&set_timeout_lock); } static struct ipmi_smi_msg set_timeout_smi_msg = { @@ -401,7 +399,7 @@ static int ipmi_set_timeout(int do_heartbeat) /* We can only send one of these at a time. */ - mutex_lock(&set_timeout_lock); + down(&set_timeout_lock); atomic_set(&set_timeout_tofree, 2); @@ -409,21 +407,16 @@ static int ipmi_set_timeout(int do_heartbeat) &set_timeout_recv_msg, &send_heartbeat_now); if (rv) { - mutex_unlock(&set_timeout_lock); - goto out; - } - - wait_for_completion(&set_timeout_wait); - - if ((do_heartbeat == IPMI_SET_TIMEOUT_FORCE_HB) - || ((send_heartbeat_now) - && (do_heartbeat == IPMI_SET_TIMEOUT_HB_IF_NECESSARY))) - { - rv = ipmi_heartbeat(); + up(&set_timeout_lock); + } else { + if ((do_heartbeat == IPMI_SET_TIMEOUT_FORCE_HB) + || ((send_heartbeat_now) + && (do_heartbeat == IPMI_SET_TIMEOUT_HB_IF_NECESSARY))) + { + rv = ipmi_heartbeat(); + } } - mutex_unlock(&set_timeout_lock); -out: return rv; } @@ -465,17 +458,17 @@ static void panic_halt_ipmi_set_timeout(void) The semaphore is claimed when the set_timeout is sent and freed when both messages are free. */ static atomic_t heartbeat_tofree = ATOMIC_INIT(0); -static DEFINE_MUTEX(heartbeat_lock); -static DECLARE_COMPLETION(heartbeat_wait); +static DECLARE_MUTEX(heartbeat_lock); +static DECLARE_MUTEX_LOCKED(heartbeat_wait_lock); static void heartbeat_free_smi(struct ipmi_smi_msg *msg) { if (atomic_dec_and_test(&heartbeat_tofree)) - complete(&heartbeat_wait); + up(&heartbeat_wait_lock); } static void heartbeat_free_recv(struct ipmi_recv_msg *msg) { if (atomic_dec_and_test(&heartbeat_tofree)) - complete(&heartbeat_wait); + up(&heartbeat_wait_lock); } static struct ipmi_smi_msg heartbeat_smi_msg = { @@ -518,14 +511,14 @@ static int ipmi_heartbeat(void) return ipmi_set_timeout(IPMI_SET_TIMEOUT_HB_IF_NECESSARY); } - mutex_lock(&heartbeat_lock); + down(&heartbeat_lock); atomic_set(&heartbeat_tofree, 2); /* Don't reset the timer if we have the timer turned off, that re-enables the watchdog. */ if (ipmi_watchdog_state == WDOG_TIMEOUT_NONE) { - mutex_unlock(&heartbeat_lock); + up(&heartbeat_lock); return 0; } @@ -546,14 +539,14 @@ static int ipmi_heartbeat(void) &heartbeat_recv_msg, 1); if (rv) { - mutex_unlock(&heartbeat_lock); + up(&heartbeat_lock); printk(KERN_WARNING PFX "heartbeat failure: %d\n", rv); return rv; } /* Wait for the heartbeat to be sent. */ - wait_for_completion(&heartbeat_wait); + down(&heartbeat_wait_lock); if (heartbeat_recv_msg.msg.data[0] != 0) { /* Got an error in the heartbeat response. It was already @@ -562,7 +555,7 @@ static int ipmi_heartbeat(void) rv = -EINVAL; } - mutex_unlock(&heartbeat_lock); + up(&heartbeat_lock); return rv; } @@ -596,7 +589,7 @@ static void panic_halt_ipmi_heartbeat(void) 1); } -static struct watchdog_info ident = +static struct watchdog_info ident= { .options = 0, /* WDIOF_SETTIMEOUT, */ .firmware_version = 1, @@ -797,13 +790,13 @@ static int ipmi_fasync(int fd, struct file *file, int on) static int ipmi_close(struct inode *ino, struct file *filep) { - if (iminor(ino) == WATCHDOG_MINOR) { + if (iminor(ino)==WATCHDOG_MINOR) + { if (expect_close == 42) { ipmi_watchdog_state = WDOG_TIMEOUT_NONE; ipmi_set_timeout(IPMI_SET_TIMEOUT_NO_HB); } else { - printk(KERN_CRIT PFX - "Unexpected close, not stopping watchdog!\n"); + printk(KERN_CRIT PFX "Unexpected close, not stopping watchdog!\n"); ipmi_heartbeat(); } clear_bit(0, &ipmi_wdog_open); @@ -1003,7 +996,7 @@ static struct notifier_block wdog_panic_notifier = { }; -static void ipmi_new_smi(int if_num, struct device *device) +static void ipmi_new_smi(int if_num) { ipmi_register_watchdog(if_num); } @@ -1165,8 +1158,7 @@ static int __init ipmi_wdog_init(void) } register_reboot_notifier(&wdog_reboot_notifier); - atomic_notifier_chain_register(&panic_notifier_list, - &wdog_panic_notifier); + notifier_chain_register(&panic_notifier_list, &wdog_panic_notifier); printk(KERN_INFO PFX "driver initialized\n"); @@ -1184,8 +1176,7 @@ static __exit void ipmi_unregister_watchdog(void) release_nmi(&ipmi_nmi_handler); #endif - atomic_notifier_chain_unregister(&panic_notifier_list, - &wdog_panic_notifier); + notifier_chain_unregister(&panic_notifier_list, &wdog_panic_notifier); unregister_reboot_notifier(&wdog_reboot_notifier); if (! watchdog_user)