netfilter: nfnetlink_log: fix wrong skbuff size calculation

[safe/jmp/linux-2.6] / net / 9p / client.c

diff --git a/net/9p/client.c b/net/9p/client.c
index 2a166bf..1eb580c 100644 (file)
--- a/net/9p/client.c
+++ b/net/9p/client.c
@@ -159,6 +159,7 @@ static struct p9_req_t *p9_tag_alloc(struct p9_client *c, u16 tag)
 
                        if (!c->reqs[row]) {
                                printk(KERN_ERR "Couldn't grow tag array\n");
+                               spin_unlock_irqrestore(&c->lock, flags);
                                return ERR_PTR(-ENOMEM);
                        }
                        for (col = 0; col < P9_ROW_MAXTAG; col++) {
@@ -188,6 +189,9 @@ static struct p9_req_t *p9_tag_alloc(struct p9_client *c, u16 tag)
                        printk(KERN_ERR "Couldn't grow tag array\n");
                        kfree(req->tc);
                        kfree(req->rc);
+                       kfree(req->wq);
+                       req->tc = req->rc = NULL;
+                       req->wq = NULL;
                        return ERR_PTR(-ENOMEM);
                }
                req->tc->sdata = (char *) req->tc + sizeof(struct p9_fcall);
@@ -310,12 +314,6 @@ static void p9_free_req(struct p9_client *c, struct p9_req_t *r)
        r->status = REQ_STATUS_IDLE;
        if (tag != P9_NOTAG && p9_idpool_check(tag, c->tagpool))
                p9_idpool_put(tag, c->tagpool);
-
-       /* if this was a flush request we have to free response fcall */
-       if (r->rc->id == P9_RFLUSH) {
-               kfree(r->tc);
-               kfree(r->rc);
-       }
 }
 
 /**
@@ -389,8 +387,8 @@ p9_parse_header(struct p9_fcall *pdu, int32_t *size, int8_t *type, int16_t *tag,
        pdu->id = r_type;
        pdu->tag = r_tag;
 
-       P9_DPRINTK(P9_DEBUG_MUX, "pdu: type: %d tag: %d size=%d offset=%d\n",
-                               pdu->id, pdu->tag, pdu->size, pdu->offset);
+       P9_DPRINTK(P9_DEBUG_9P, "<<< size=%d type: %d tag: %d\n", pdu->size,
+                                                       pdu->id, pdu->tag);
 
        if (type)
                *type = r_type;
@@ -610,48 +608,51 @@ reterr:
 
 static struct p9_fid *p9_fid_create(struct p9_client *clnt)
 {
-       int err;
+       int ret;
        struct p9_fid *fid;
+       unsigned long flags;
 
        P9_DPRINTK(P9_DEBUG_FID, "clnt %p\n", clnt);
        fid = kmalloc(sizeof(struct p9_fid), GFP_KERNEL);
        if (!fid)
                return ERR_PTR(-ENOMEM);
 
-       fid->fid = p9_idpool_get(clnt->fidpool);
-       if (fid->fid < 0) {
-               err = -ENOSPC;
+       ret = p9_idpool_get(clnt->fidpool);
+       if (ret < 0) {
+               ret = -ENOSPC;
                goto error;
        }
+       fid->fid = ret;
 
        memset(&fid->qid, 0, sizeof(struct p9_qid));
        fid->mode = -1;
        fid->rdir_fpos = 0;
-       fid->uid = current->fsuid;
+       fid->uid = current_fsuid();
        fid->clnt = clnt;
        fid->aux = NULL;
 
-       spin_lock(&clnt->lock);
+       spin_lock_irqsave(&clnt->lock, flags);
        list_add(&fid->flist, &clnt->fidlist);
-       spin_unlock(&clnt->lock);
+       spin_unlock_irqrestore(&clnt->lock, flags);
 
        return fid;
 
 error:
        kfree(fid);
-       return ERR_PTR(err);
+       return ERR_PTR(ret);
 }
 
 static void p9_fid_destroy(struct p9_fid *fid)
 {
        struct p9_client *clnt;
+       unsigned long flags;
 
        P9_DPRINTK(P9_DEBUG_FID, "fid %d\n", fid->fid);
        clnt = fid->clnt;
        p9_idpool_put(fid->fid, clnt->fidpool);
-       spin_lock(&clnt->lock);
+       spin_lock_irqsave(&clnt->lock, flags);
        list_del(&fid->flist);
-       spin_unlock(&clnt->lock);
+       spin_unlock_irqrestore(&clnt->lock, flags);
        kfree(fid);
 }
 
@@ -672,6 +673,7 @@ int p9_client_version(struct p9_client *c)
        err = p9pdu_readf(req->rc, c->dotu, "ds", &msize, &version);
        if (err) {
                P9_DPRINTK(P9_DEBUG_9P, "version error %d\n", err);
+               p9pdu_dump(1, req->rc);
                goto error;
        }
 
@@ -810,12 +812,15 @@ struct p9_fid *p9_client_attach(struct p9_client *clnt, struct p9_fid *afid,
 
        err = p9pdu_readf(req->rc, clnt->dotu, "Q", &qid);
        if (err) {
+               p9pdu_dump(1, req->rc);
                p9_free_req(clnt, req);
                goto error;
        }
 
        P9_DPRINTK(P9_DEBUG_9P, "<<< RATTACH qid %x.%llx.%x\n",
-                                       qid.type, qid.path, qid.version);
+                                       qid.type,
+                                       (unsigned long long)qid.path,
+                                       qid.version);
 
        memmove(&fid->qid, &qid, sizeof(struct p9_qid));
 
@@ -856,12 +861,15 @@ p9_client_auth(struct p9_client *clnt, char *uname, u32 n_uname, char *aname)
 
        err = p9pdu_readf(req->rc, clnt->dotu, "Q", &qid);
        if (err) {
+               p9pdu_dump(1, req->rc);
                p9_free_req(clnt, req);
                goto error;
        }
 
        P9_DPRINTK(P9_DEBUG_9P, "<<< RAUTH qid %x.%llx.%x\n",
-                                       qid.type, qid.path, qid.version);
+                                       qid.type,
+                                       (unsigned long long)qid.path,
+                                       qid.version);
 
        memmove(&afid->qid, &qid, sizeof(struct p9_qid));
        p9_free_req(clnt, req);
@@ -910,9 +918,12 @@ struct p9_fid *p9_client_walk(struct p9_fid *oldfid, int nwname, char **wnames,
        }
 
        err = p9pdu_readf(req->rc, clnt->dotu, "R", &nwqids, &wqids);
-       p9_free_req(clnt, req);
-       if (err)
+       if (err) {
+               p9pdu_dump(1, req->rc);
+               p9_free_req(clnt, req);
                goto clunk_fid;
+       }
+       p9_free_req(clnt, req);
 
        P9_DPRINTK(P9_DEBUG_9P, "<<< RWALK nwqid %d:\n", nwqids);
 
@@ -923,7 +934,8 @@ struct p9_fid *p9_client_walk(struct p9_fid *oldfid, int nwname, char **wnames,
 
        for (count = 0; count < nwqids; count++)
                P9_DPRINTK(P9_DEBUG_9P, "<<<     [%d] %x.%llx.%x\n",
-                       count, wqids[count].type, wqids[count].path,
+                       count, wqids[count].type,
+                       (unsigned long long)wqids[count].path,
                        wqids[count].version);
 
        if (nwname)
@@ -967,16 +979,21 @@ int p9_client_open(struct p9_fid *fid, int mode)
        }
 
        err = p9pdu_readf(req->rc, clnt->dotu, "Qd", &qid, &iounit);
-       p9_free_req(clnt, req);
-       if (err)
-               goto error;
+       if (err) {
+               p9pdu_dump(1, req->rc);
+               goto free_and_error;
+       }
 
        P9_DPRINTK(P9_DEBUG_9P, "<<< ROPEN qid %x.%llx.%x iounit %x\n",
-                               qid.type, qid.path, qid.version, iounit);
+                               qid.type,
+                               (unsigned long long)qid.path,
+                               qid.version, iounit);
 
        fid->mode = mode;
        fid->iounit = iounit;
 
+free_and_error:
+       p9_free_req(clnt, req);
 error:
        return err;
 }
@@ -1007,16 +1024,21 @@ int p9_client_fcreate(struct p9_fid *fid, char *name, u32 perm, int mode,
        }
 
        err = p9pdu_readf(req->rc, clnt->dotu, "Qd", &qid, &iounit);
-       p9_free_req(clnt, req);
-       if (err)
-               goto error;
+       if (err) {
+               p9pdu_dump(1, req->rc);
+               goto free_and_error;
+       }
 
        P9_DPRINTK(P9_DEBUG_9P, "<<< RCREATE qid %x.%llx.%x iounit %x\n",
-                               qid.type, qid.path, qid.version, iounit);
+                               qid.type,
+                               (unsigned long long)qid.path,
+                               qid.version, iounit);
 
        fid->mode = mode;
        fid->iounit = iounit;
 
+free_and_error:
+       p9_free_req(clnt, req);
 error:
        return err;
 }
@@ -1103,8 +1125,10 @@ p9_client_read(struct p9_fid *fid, char *data, char __user *udata, u64 offset,
        }
 
        err = p9pdu_readf(req->rc, clnt->dotu, "D", &count, &dataptr);
-       if (err)
+       if (err) {
+               p9pdu_dump(1, req->rc);
                goto free_and_error;
+       }
 
        P9_DPRINTK(P9_DEBUG_9P, "<<< RREAD count %d\n", count);
 
@@ -1163,8 +1187,11 @@ p9_client_write(struct p9_fid *fid, char *data, const char __user *udata,
        }
 
        err = p9pdu_readf(req->rc, clnt->dotu, "d", &count);
-       if (err)
+       if (err) {
+               p9pdu_dump(1, req->rc);
                goto free_and_error;
+       }
+
        P9_DPRINTK(P9_DEBUG_9P, "<<< RWRITE count %d\n", count);
 
        p9_free_req(clnt, req);
@@ -1200,20 +1227,27 @@ struct p9_wstat *p9_client_stat(struct p9_fid *fid)
        }
 
        err = p9pdu_readf(req->rc, clnt->dotu, "wS", &ignored, ret);
-       p9_free_req(clnt, req);
-       if (err)
-               goto error;
+       if (err) {
+               ret = ERR_PTR(err);
+               p9pdu_dump(1, req->rc);
+               goto free_and_error;
+       }
 
        P9_DPRINTK(P9_DEBUG_9P,
-               "<<< RSTAT sz=%x type=%x dev=%x qid=%2.2x %4.4x %8.8llx"
-               " mode=%8.8x uid=%d gid=%d size=%lld %s\n",
+               "<<< RSTAT sz=%x type=%x dev=%x qid=%x.%llx.%x\n"
+               "<<<    mode=%8.8x atime=%8.8x mtime=%8.8x length=%llx\n"
+               "<<<    name=%s uid=%s gid=%s muid=%s extension=(%s)\n"
+               "<<<    uid=%d gid=%d n_muid=%d\n",
                ret->size, ret->type, ret->dev, ret->qid.type,
-               ret->qid.version, ret->qid.path, ret->mode,
-               ret->n_uid, ret->n_gid, ret->length, ret->name);
+               (unsigned long long)ret->qid.path, ret->qid.version, ret->mode,
+               ret->atime, ret->mtime, (unsigned long long)ret->length,
+               ret->name, ret->uid, ret->gid, ret->muid, ret->extension,
+               ret->n_uid, ret->n_gid, ret->n_muid);
 
-       return ret;
+free_and_error:
+       p9_free_req(clnt, req);
 error:
-       return ERR_PTR(err);
+       return ret;
 }
 EXPORT_SYMBOL(p9_client_stat);
 
@@ -1224,6 +1258,16 @@ int p9_client_wstat(struct p9_fid *fid, struct p9_wstat *wst)
        struct p9_client *clnt;
 
        P9_DPRINTK(P9_DEBUG_9P, ">>> TWSTAT fid %d\n", fid->fid);
+       P9_DPRINTK(P9_DEBUG_9P,
+               "     sz=%x type=%x dev=%x qid=%x.%llx.%x\n"
+               "     mode=%8.8x atime=%8.8x mtime=%8.8x length=%llx\n"
+               "     name=%s uid=%s gid=%s muid=%s extension=(%s)\n"
+               "     uid=%d gid=%d n_muid=%d\n",
+               wst->size, wst->type, wst->dev, wst->qid.type,
+               (unsigned long long)wst->qid.path, wst->qid.version, wst->mode,
+               wst->atime, wst->mtime, (unsigned long long)wst->length,
+               wst->name, wst->uid, wst->gid, wst->muid, wst->extension,
+               wst->n_uid, wst->n_gid, wst->n_muid);
        err = 0;
        clnt = fid->clnt;