*/
 static void request_end(struct fuse_conn *fc, struct fuse_req *req)
 {
+       list_del(&req->list);
        req->state = FUSE_REQ_FINISHED;
        spin_unlock(&fuse_lock);
        if (req->background) {
 
        req = list_entry(fc->pending.next, struct fuse_req, list);
        req->state = FUSE_REQ_READING;
-       list_del_init(&req->list);
+       list_move(&req->list, &fc->io);
 
        in = &req->in;
        reqsize = in->h.len;
                request_end(fc, req);
        else {
                req->state = FUSE_REQ_SENT;
-               list_add_tail(&req->list, &fc->processing);
+               list_move_tail(&req->list, &fc->processing);
                spin_unlock(&fuse_lock);
        }
        return reqsize;
        if (!req)
                goto err_unlock;
 
-       list_del_init(&req->list);
        if (req->interrupted) {
                spin_unlock(&fuse_lock);
                fuse_copy_finish(&cs);
                request_end(fc, req);
                return -ENOENT;
        }
+       list_move(&req->list, &fc->io);
        req->out.h = oh;
        req->locked = 1;
        cs.req = req;
        while (!list_empty(head)) {
                struct fuse_req *req;
                req = list_entry(head->next, struct fuse_req, list);
-               list_del_init(&req->list);
                req->out.h.error = -ECONNABORTED;
                request_end(fc, req);
                spin_lock(&fuse_lock);
 
  * A request to the client
  */
 struct fuse_req {
-       /** This can be on either unused_list, pending or processing
-           lists in fuse_conn */
+       /** This can be on either unused_list, pending processing or
+           io lists in fuse_conn */
        struct list_head list;
 
        /** Entry on the background list */
        /** The list of requests being processed */
        struct list_head processing;
 
+       /** The list of requests under I/O */
+       struct list_head io;
+
        /** Requests put in the background (RELEASE or any other
            interrupted request) */
        struct list_head background;
 
                init_waitqueue_head(&fc->waitq);
                INIT_LIST_HEAD(&fc->pending);
                INIT_LIST_HEAD(&fc->processing);
+               INIT_LIST_HEAD(&fc->io);
                INIT_LIST_HEAD(&fc->unused_list);
                INIT_LIST_HEAD(&fc->background);
                sema_init(&fc->outstanding_sem, 1); /* One for INIT */