sata_via: style clean up, no indirect method call in LLD

[powerpc.git] / fs / gfs2 / lm.c

diff --git a/fs/gfs2/lm.c b/fs/gfs2/lm.c
index 5b3c56d..effe4a3 100644 (file)
--- a/fs/gfs2/lm.c
+++ b/fs/gfs2/lm.c
@@ -1,10 +1,10 @@
 /*
  * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
- * Copyright (C) 2004-2005 Red Hat, Inc.  All rights reserved.
+ * Copyright (C) 2004-2006 Red Hat, Inc.  All rights reserved.
  *
  * This copyrighted material is made available to anyone wishing to use,
  * modify, copy, or redistribute it subject to the terms and conditions
- * of the GNU General Public License v.2.
+ * of the GNU General Public License version 2.
  */
 
 #include <linux/sched.h>
@@ -14,16 +14,14 @@
 #include <linux/buffer_head.h>
 #include <linux/delay.h>
 #include <linux/gfs2_ondisk.h>
-#include <asm/semaphore.h>
+#include <linux/lm_interface.h>
 
 #include "gfs2.h"
-#include "lm_interface.h"
 #include "incore.h"
 #include "glock.h"
 #include "lm.h"
 #include "super.h"
 #include "util.h"
-#include "lvb.h"
 
 /**
  * gfs2_lm_mount - mount a locking protocol
@@ -78,7 +76,7 @@ int gfs2_lm_mount(struct gfs2_sbd *sdp, int silent)
                sdp->sd_args.ar_localcaching = 1;
        }
 
- out:
+out:
        return error;
 }
 
@@ -108,7 +106,7 @@ int gfs2_lm_withdraw(struct gfs2_sbd *sdp, char *fmt, ...)
 
        fs_err(sdp, "about to withdraw from the cluster\n");
        BUG_ON(sdp->sd_args.ar_debug);
-       
+
 
        fs_err(sdp, "waiting for outstanding I/O\n");
 
@@ -124,112 +122,88 @@ int gfs2_lm_withdraw(struct gfs2_sbd *sdp, char *fmt, ...)
 }
 
 int gfs2_lm_get_lock(struct gfs2_sbd *sdp, struct lm_lockname *name,
-                    lm_lock_t **lockp)
+                    void **lockp)
 {
-       int error;
-       if (unlikely(test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
-               error = -EIO;
-       else
+       int error = -EIO;
+       if (likely(!test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
                error = sdp->sd_lockstruct.ls_ops->lm_get_lock(
                                sdp->sd_lockstruct.ls_lockspace, name, lockp);
        return error;
 }
 
-void gfs2_lm_put_lock(struct gfs2_sbd *sdp, lm_lock_t *lock)
+void gfs2_lm_put_lock(struct gfs2_sbd *sdp, void *lock)
 {
        if (likely(!test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
                sdp->sd_lockstruct.ls_ops->lm_put_lock(lock);
 }
 
-unsigned int gfs2_lm_lock(struct gfs2_sbd *sdp, lm_lock_t *lock,
+unsigned int gfs2_lm_lock(struct gfs2_sbd *sdp, void *lock,
                          unsigned int cur_state, unsigned int req_state,
                          unsigned int flags)
 {
-       int ret;
-       if (unlikely(test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
-               ret = 0;
-       else
-               ret = sdp->sd_lockstruct.ls_ops->lm_lock(lock,
-                                                        cur_state,
+       int ret = 0;
+       if (likely(!test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
+               ret = sdp->sd_lockstruct.ls_ops->lm_lock(lock, cur_state,
                                                         req_state, flags);
        return ret;
 }
 
-unsigned int gfs2_lm_unlock(struct gfs2_sbd *sdp, lm_lock_t *lock,
+unsigned int gfs2_lm_unlock(struct gfs2_sbd *sdp, void *lock,
                            unsigned int cur_state)
 {
-       int ret;
-       if (unlikely(test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
-               ret = 0;
-       else
+       int ret = 0;
+       if (likely(!test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
                ret =  sdp->sd_lockstruct.ls_ops->lm_unlock(lock, cur_state);
        return ret;
 }
 
-void gfs2_lm_cancel(struct gfs2_sbd *sdp, lm_lock_t *lock)
+void gfs2_lm_cancel(struct gfs2_sbd *sdp, void *lock)
 {
        if (likely(!test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
                sdp->sd_lockstruct.ls_ops->lm_cancel(lock);
 }
 
-int gfs2_lm_hold_lvb(struct gfs2_sbd *sdp, lm_lock_t *lock, char **lvbp)
+int gfs2_lm_hold_lvb(struct gfs2_sbd *sdp, void *lock, char **lvbp)
 {
-       int error;
-       if (unlikely(test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
-               error = -EIO;
-       else
+       int error = -EIO;
+       if (likely(!test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
                error = sdp->sd_lockstruct.ls_ops->lm_hold_lvb(lock, lvbp);
        return error;
 }
 
-void gfs2_lm_unhold_lvb(struct gfs2_sbd *sdp, lm_lock_t *lock, char *lvb)
+void gfs2_lm_unhold_lvb(struct gfs2_sbd *sdp, void *lock, char *lvb)
 {
        if (likely(!test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
                sdp->sd_lockstruct.ls_ops->lm_unhold_lvb(lock, lvb);
 }
 
-void gfs2_lm_sync_lvb(struct gfs2_sbd *sdp, lm_lock_t *lock, char *lvb)
-{
-       if (likely(!test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
-               sdp->sd_lockstruct.ls_ops->lm_sync_lvb(lock, lvb);
-}
-
 int gfs2_lm_plock_get(struct gfs2_sbd *sdp, struct lm_lockname *name,
                      struct file *file, struct file_lock *fl)
 {
-       int error;
-       if (unlikely(test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
-               error = -EIO;
-       else
+       int error = -EIO;
+       if (likely(!test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
                error = sdp->sd_lockstruct.ls_ops->lm_plock_get(
-                       sdp->sd_lockstruct.ls_lockspace,
-                       name, file, fl);
+                               sdp->sd_lockstruct.ls_lockspace, name, file, fl);
        return error;
 }
 
 int gfs2_lm_plock(struct gfs2_sbd *sdp, struct lm_lockname *name,
                  struct file *file, int cmd, struct file_lock *fl)
 {
-       int error;
-       if (unlikely(test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
-               error = -EIO;
-       else
+       int error = -EIO;
+       if (likely(!test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
                error = sdp->sd_lockstruct.ls_ops->lm_plock(
-                       sdp->sd_lockstruct.ls_lockspace,
-                       name, file, cmd, fl);
+                               sdp->sd_lockstruct.ls_lockspace, name, file, cmd, fl);
        return error;
 }
 
 int gfs2_lm_punlock(struct gfs2_sbd *sdp, struct lm_lockname *name,
                    struct file *file, struct file_lock *fl)
 {
-       int error;
-       if (unlikely(test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
-               error = -EIO;
-       else
+       int error = -EIO;
+       if (likely(!test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
                error = sdp->sd_lockstruct.ls_ops->lm_punlock(
-                       sdp->sd_lockstruct.ls_lockspace,
-                       name, file, fl);
+                               sdp->sd_lockstruct.ls_lockspace, name, file, fl);
        return error;
 }