Add changes from the Linux-2.6 tree.

[linux-2.6.git] / fs / smbfs / request.c

diff --git a/fs/smbfs/request.c b/fs/smbfs/request.c
index 8432a55..a4bcae8 100644 (file)
--- a/fs/smbfs/request.c
+++ b/fs/smbfs/request.c
@@ -25,7 +25,9 @@
 #define ROUND_UP(x) (((x)+3) & ~3)
 
 /* cache for request structures */
-static kmem_cache_t *req_cachep;
+static struct kmem_cache *req_cachep;
+
+static int smb_request_send_req(struct smb_request *req);
 
 /*
   /proc/slabinfo:
@@ -47,8 +49,7 @@ int smb_init_request_cache(void)
 
 void smb_destroy_request_cache(void)
 {
-       if (kmem_cache_destroy(req_cachep))
-               printk(KERN_INFO "smb_destroy_request_cache: not all structures were freed\n");
+       kmem_cache_destroy(req_cachep);
 }
 
 /*
@@ -60,13 +61,13 @@ static struct smb_request *smb_do_alloc_request(struct smb_sb_info *server,
        struct smb_request *req;
        unsigned char *buf = NULL;
 
-       req = kmem_cache_alloc(req_cachep, SLAB_KERNEL);
+       req = kmem_cache_alloc(req_cachep, GFP_KERNEL);
        VERBOSE("allocating request: %p\n", req);
        if (!req)
                goto out;
 
        if (bufsize > 0) {
-               buf = smb_kmalloc(bufsize, GFP_NOFS);
+               buf = kmalloc(bufsize, GFP_NOFS);
                if (!buf) {
                        kmem_cache_free(req_cachep, req);
                        return NULL;
@@ -122,9 +123,8 @@ static void smb_free_request(struct smb_request *req)
 {
        atomic_dec(&req->rq_server->nr_requests);
        if (req->rq_buffer && !(req->rq_flags & SMB_REQ_STATIC))
-               smb_kfree(req->rq_buffer);
-       if (req->rq_trans2buffer)
-               smb_kfree(req->rq_trans2buffer);
+               kfree(req->rq_buffer);
+       kfree(req->rq_trans2buffer);
        kmem_cache_free(req_cachep, req);
 }
 
@@ -132,7 +132,7 @@ static void smb_free_request(struct smb_request *req)
  * What prevents a rget to race with a rput? The count must never drop to zero
  * while it is in use. Only rput if it is ok that it is free'd.
  */
-void smb_rget(struct smb_request *req)
+static void smb_rget(struct smb_request *req)
 {
        atomic_inc(&req->rq_count);
 }
@@ -181,8 +181,7 @@ static int smb_setup_request(struct smb_request *req)
        req->rq_err = 0;
        req->rq_errno = 0;
        req->rq_fragment = 0;
-       if (req->rq_trans2buffer)
-               smb_kfree(req->rq_trans2buffer);
+       kfree(req->rq_trans2buffer);
 
        return 0;
 }
@@ -339,9 +338,11 @@ int smb_add_request(struct smb_request *req)
                /*
                 * On timeout or on interrupt we want to try and remove the
                 * request from the recvq/xmitq.
+                * First check if the request is still part of a queue. (May
+                * have been removed by some error condition)
                 */
                smb_lock_server(server);
-               if (!(req->rq_flags & SMB_REQ_RECEIVED)) {
+               if (!list_empty(&req->rq_queue)) {
                        list_del_init(&req->rq_queue);
                        smb_rput(req);
                }
@@ -379,7 +380,7 @@ int smb_add_request(struct smb_request *req)
  * Send a request and place it on the recvq if successfully sent.
  * Must be called with the server lock held.
  */
-int smb_request_send_req(struct smb_request *req)
+static int smb_request_send_req(struct smb_request *req)
 {
        struct smb_sb_info *server = req->rq_server;
        int result;
@@ -398,8 +399,7 @@ int smb_request_send_req(struct smb_request *req)
        if (!(req->rq_flags & SMB_REQ_TRANSMITTED))
                goto out;
 
-       list_del_init(&req->rq_queue);
-       list_add_tail(&req->rq_queue, &server->recvq);
+       list_move_tail(&req->rq_queue, &server->recvq);
        result = 1;
 out:
        return result;
@@ -433,8 +433,7 @@ int smb_request_send_server(struct smb_sb_info *server)
        result = smb_request_send_req(req);
        if (result < 0) {
                server->conn_error = result;
-               list_del_init(&req->rq_queue);
-               list_add(&req->rq_queue, &server->xmitq);
+               list_move(&req->rq_queue, &server->xmitq);
                result = -EIO;
                goto out;
        }
@@ -645,10 +644,9 @@ static int smb_recv_trans2(struct smb_sb_info *server, struct smb_request *req)
                        goto out_too_long;
 
                req->rq_trans2bufsize = buf_len;
-               req->rq_trans2buffer = smb_kmalloc(buf_len, GFP_NOFS);
+               req->rq_trans2buffer = kzalloc(buf_len, GFP_NOFS);
                if (!req->rq_trans2buffer)
                        goto out_no_mem;
-               memset(req->rq_trans2buffer, 0, buf_len);
 
                req->rq_parm = req->rq_trans2buffer;
                req->rq_data = req->rq_trans2buffer + parm_tot;
@@ -784,8 +782,7 @@ int smb_request_recv(struct smb_sb_info *server)
                /* We should never be called with any of these states */
        case SMB_RECV_END:
        case SMB_RECV_REQUEST:
-               server->rstate = SMB_RECV_END;
-               break;
+               BUG();
        }
 
        if (result < 0) {