[cobalt] resync kernel configuration, enable netfilter and wireless extensions

[openwrt.git] / target / linux / generic-2.6 / patches-2.6.30 / 052-pcomp_lzma_support.patch

diff --git a/target/linux/generic-2.6/patches-2.6.30/052-pcomp_lzma_support.patch b/target/linux/generic-2.6/patches-2.6.30/052-pcomp_lzma_support.patch
index afb37a8..d20285c 100644 (file)
--- a/target/linux/generic-2.6/patches-2.6.30/052-pcomp_lzma_support.patch
+++ b/target/linux/generic-2.6/patches-2.6.30/052-pcomp_lzma_support.patch
@@ -1,6 +1,6 @@
 --- /dev/null
 +++ b/crypto/unlzma.c
 --- /dev/null
 +++ b/crypto/unlzma.c

-@@ -0,0 +1,748 @@
+@@ -0,0 +1,775 @@

 +/*
 + * LZMA uncompresion module for pcomp
 + * Copyright (C) 2009  Felix Fietkau <nbd@openwrt.org>
 +/*
 + * LZMA uncompresion module for pcomp
 + * Copyright (C) 2009  Felix Fietkau <nbd@openwrt.org>


@@ -50,7 +50,9 @@
 +struct unlzma_ctx {
 +      struct task_struct *thread;
 +      wait_queue_head_t next_req;
 +struct unlzma_ctx {
 +      struct task_struct *thread;
 +      wait_queue_head_t next_req;

++      wait_queue_head_t req_done;

 +      struct mutex mutex;
 +      struct mutex mutex;

++      bool waiting;

 +      bool active;
 +      bool cancel;
 +
 +      bool active;
 +      bool cancel;
 +


@@ -106,7 +108,9 @@
 +unlzma_request_buffer(struct unlzma_ctx *ctx, int *avail)
 +{
 +      do {
 +unlzma_request_buffer(struct unlzma_ctx *ctx, int *avail)
 +{
 +      do {

++              ctx->waiting = true;

 +              mutex_unlock(&ctx->mutex);
 +              mutex_unlock(&ctx->mutex);

++              wake_up(&ctx->req_done);

 +              if (wait_event_interruptible(ctx->next_req,
 +                      unlzma_should_stop(ctx) || (*avail > 0)))
 +                      schedule();
 +              if (wait_event_interruptible(ctx->next_req,
 +                      unlzma_should_stop(ctx) || (*avail > 0)))
 +                      schedule();


@@ -213,22 +217,35 @@
 +      int i = ctx->n_buffers;
 +      u32 pos;
 +
 +      int i = ctx->n_buffers;
 +      u32 pos;
 +

-+      BUG_ON(!ctx->n_buffers);
-+      pos = ctx->pos - offs;
-+      if (pos >= ctx->dict_size) {
-+              pos = (~pos % ctx->dict_size);
++      if (!ctx->n_buffers) {
++              printk(KERN_ERR "unlzma/%s: no buffer\n", __func__);
++              goto error;

 +      }
 +
 +      }
 +

++      pos = ctx->pos - offs;
++      if (unlikely(pos >= ctx->dict_size))
++              pos = ~pos & (ctx->dict_size - 1);
++

 +      while (bh->offset > pos) {
 +              bh--;
 +              i--;
 +      while (bh->offset > pos) {
 +              bh--;
 +              i--;

-+              BUG_ON(!i);
++              if (!i) {
++                      printk(KERN_ERR "unlzma/%s: position %d out of range\n", __func__, pos);
++                      goto error;
++              }

 +      }
 +
 +      pos -= bh->offset;
 +      }
 +
 +      pos -= bh->offset;

-+      BUG_ON(pos >= bh->size);
++      if (pos >= bh->size) {
++              printk(KERN_ERR "unlzma/%s: position %d out of range\n", __func__, pos);
++              goto error;
++      }

 +
 +      return bh->ptr[pos];
 +
 +      return bh->ptr[pos];

++
++error:
++      ctx->cancel = true;
++      return 0;

 +}
 +
 +static void
 +}
 +
 +static void


@@ -619,6 +636,9 @@
 +              return -EINVAL;
 +
 +      ret = nla_parse(tb, UNLZMA_DECOMP_MAX, p, len, NULL);
 +              return -EINVAL;
 +
 +      ret = nla_parse(tb, UNLZMA_DECOMP_MAX, p, len, NULL);

++      if (ret)
++              return ret;
++

 +      if (!tb[UNLZMA_DECOMP_OUT_BUFFERS])
 +              return -EINVAL;
 +
 +      if (!tb[UNLZMA_DECOMP_OUT_BUFFERS])
 +              return -EINVAL;
 +


@@ -635,8 +655,10 @@
 +      if (!ctx->buffers)
 +              return -ENOMEM;
 +
 +      if (!ctx->buffers)
 +              return -ENOMEM;
 +

++      ctx->waiting = false;

 +      mutex_init(&ctx->mutex);
 +      init_waitqueue_head(&ctx->next_req);
 +      mutex_init(&ctx->mutex);
 +      init_waitqueue_head(&ctx->next_req);

++      init_waitqueue_head(&ctx->req_done);

 +      ctx->thread = kthread_run(unlzma_thread, ctx, "unlzma/%d", instance++);
 +      if (IS_ERR(ctx->thread)) {
 +              ret = PTR_ERR(ctx->thread);
 +      ctx->thread = kthread_run(unlzma_thread, ctx, "unlzma/%d", instance++);
 +      if (IS_ERR(ctx->thread)) {
 +              ret = PTR_ERR(ctx->thread);


@@ -649,21 +671,22 @@
 +static int
 +unlzma_decompress_init(struct crypto_pcomp *tfm)
 +{
 +static int
 +unlzma_decompress_init(struct crypto_pcomp *tfm)
 +{

-+      struct unlzma_ctx *ctx = crypto_tfm_ctx(crypto_pcomp_tfm(tfm));
-+
-+      ctx->pos = 0;

 +      return 0;
 +}
 +
 +static void
 +unlzma_wait_complete(struct unlzma_ctx *ctx, bool finish)
 +{
 +      return 0;
 +}
 +
 +static void
 +unlzma_wait_complete(struct unlzma_ctx *ctx, bool finish)
 +{

++      DEFINE_WAIT(__wait);
++

 +      do {
 +      do {

-+              mutex_unlock(&ctx->mutex);

 +              wake_up(&ctx->next_req);
 +              wake_up(&ctx->next_req);

++              prepare_to_wait(&ctx->req_done, &__wait, TASK_INTERRUPTIBLE);
++              mutex_unlock(&ctx->mutex);

 +              schedule();
 +              mutex_lock(&ctx->mutex);
 +              schedule();
 +              mutex_lock(&ctx->mutex);

-+      } while (ctx->active && (ctx->avail_in > 0) && (ctx->avail_out > 0));
++      } while (!ctx->waiting && ctx->active);
++      finish_wait(&ctx->req_done, &__wait);

 +}
 +
 +static int
 +}
 +
 +static int


@@ -677,6 +700,7 @@
 +              goto out;
 +
 +      pos = ctx->pos;
 +              goto out;
 +
 +      pos = ctx->pos;

++      ctx->waiting = false;

 +      ctx->next_in = req->next_in;
 +      ctx->avail_in = req->avail_in;
 +      ctx->next_out = req->next_out;
 +      ctx->next_in = req->next_in;
 +      ctx->avail_in = req->avail_in;
 +      ctx->next_out = req->next_out;


@@ -694,6 +718,9 @@
 +
 +out:
 +      mutex_unlock(&ctx->mutex);
 +
 +out:
 +      mutex_unlock(&ctx->mutex);

++      if (ctx->cancel)
++              return -EINVAL;
++

 +      return pos;
 +}
 +
 +      return pos;
 +}
 +