coda: fixup clash with block layer REQ_* defines
Jens Axboe [Tue, 3 Aug 2010 11:22:51 +0000 (13:22 +0200)]
CODA should not be using defines in the global name space of
that nature, prefix them with CODA_.

Signed-off-by: Jens Axboe <jaxboe@fusionio.com>

fs/coda/psdev.c
fs/coda/upcall.c
include/linux/coda_psdev.h

index 66b9cf7..de89645 100644 (file)
@@ -177,7 +177,7 @@ static ssize_t coda_psdev_write(struct file *file, const char __user *buf,
                nbytes = req->uc_outSize; /* don't have more space! */
        }
         if (copy_from_user(req->uc_data, buf, nbytes)) {
-               req->uc_flags |= REQ_ABORT;
+               req->uc_flags |= CODA_REQ_ABORT;
                wake_up(&req->uc_sleep);
                retval = -EFAULT;
                goto out;
@@ -254,8 +254,8 @@ static ssize_t coda_psdev_read(struct file * file, char __user * buf,
                retval = -EFAULT;
         
        /* If request was not a signal, enqueue and don't free */
-       if (!(req->uc_flags & REQ_ASYNC)) {
-               req->uc_flags |= REQ_READ;
+       if (!(req->uc_flags & CODA_REQ_ASYNC)) {
+               req->uc_flags |= CODA_REQ_READ;
                list_add_tail(&(req->uc_chain), &vcp->vc_processing);
                goto out;
        }
@@ -315,19 +315,19 @@ static int coda_psdev_release(struct inode * inode, struct file * file)
                list_del(&req->uc_chain);
 
                /* Async requests need to be freed here */
-               if (req->uc_flags & REQ_ASYNC) {
+               if (req->uc_flags & CODA_REQ_ASYNC) {
                        CODA_FREE(req->uc_data, sizeof(struct coda_in_hdr));
                        kfree(req);
                        continue;
                }
-               req->uc_flags |= REQ_ABORT;
+               req->uc_flags |= CODA_REQ_ABORT;
                wake_up(&req->uc_sleep);
        }
 
        list_for_each_entry_safe(req, tmp, &vcp->vc_processing, uc_chain) {
                list_del(&req->uc_chain);
 
-               req->uc_flags |= REQ_ABORT;
+               req->uc_flags |= CODA_REQ_ABORT;
                wake_up(&req->uc_sleep);
        }
 
index f09c5ed..b8893ab 100644 (file)
@@ -604,7 +604,7 @@ static void coda_unblock_signals(sigset_t *old)
                               (((r)->uc_opcode != CODA_CLOSE && \
                                 (r)->uc_opcode != CODA_STORE && \
                                 (r)->uc_opcode != CODA_RELEASE) || \
-                               (r)->uc_flags & REQ_READ))
+                               (r)->uc_flags & CODA_REQ_READ))
 
 static inline void coda_waitfor_upcall(struct upc_req *req)
 {
@@ -624,7 +624,7 @@ static inline void coda_waitfor_upcall(struct upc_req *req)
                        set_current_state(TASK_UNINTERRUPTIBLE);
 
                /* got a reply */
-               if (req->uc_flags & (REQ_WRITE | REQ_ABORT))
+               if (req->uc_flags & (CODA_REQ_WRITE | CODA_REQ_ABORT))
                        break;
 
                if (blocked && time_after(jiffies, timeout) &&
@@ -708,7 +708,7 @@ static int coda_upcall(struct venus_comm *vcp,
        coda_waitfor_upcall(req);
 
        /* Op went through, interrupt or not... */
-       if (req->uc_flags & REQ_WRITE) {
+       if (req->uc_flags & CODA_REQ_WRITE) {
                out = (union outputArgs *)req->uc_data;
                /* here we map positive Venus errors to kernel errors */
                error = -out->oh.result;
@@ -717,13 +717,13 @@ static int coda_upcall(struct venus_comm *vcp,
        }
 
        error = -EINTR;
-       if ((req->uc_flags & REQ_ABORT) || !signal_pending(current)) {
+       if ((req->uc_flags & CODA_REQ_ABORT) || !signal_pending(current)) {
                printk(KERN_WARNING "coda: Unexpected interruption.\n");
                goto exit;
        }
 
        /* Interrupted before venus read it. */
-       if (!(req->uc_flags & REQ_READ))
+       if (!(req->uc_flags & CODA_REQ_READ))
                goto exit;
 
        /* Venus saw the upcall, make sure we can send interrupt signal */
@@ -747,7 +747,7 @@ static int coda_upcall(struct venus_comm *vcp,
        sig_inputArgs->ih.opcode = CODA_SIGNAL;
        sig_inputArgs->ih.unique = req->uc_unique;
 
-       sig_req->uc_flags = REQ_ASYNC;
+       sig_req->uc_flags = CODA_REQ_ASYNC;
        sig_req->uc_opcode = sig_inputArgs->ih.opcode;
        sig_req->uc_unique = sig_inputArgs->ih.unique;
        sig_req->uc_inSize = sizeof(struct coda_in_hdr);
index 8859e2e..284b520 100644 (file)
@@ -86,9 +86,9 @@ struct upc_req {
        wait_queue_head_t   uc_sleep;   /* process' wait queue */
 };
 
-#define REQ_ASYNC  0x1
-#define REQ_READ   0x2
-#define REQ_WRITE  0x4
-#define REQ_ABORT  0x8
+#define CODA_REQ_ASYNC  0x1
+#define CODA_REQ_READ   0x2
+#define CODA_REQ_WRITE  0x4
+#define CODA_REQ_ABORT  0x8
 
 #endif