--- v6
+++ v12
@@ -1,24 +1,24 @@
 As well known, hvc backend can register its opertions to hvc backend.
-the opertions contain put_chars(), get_chars() and so on.
-
-Some hvc backend may do dma in its opertions. eg, put_chars() of
+the operations contain put_chars(), get_chars() and so on.
+
+Some hvc backend may do dma in its operations. eg, put_chars() of
 virtio-console. But in the code of hvc framework, it may pass DMA
 incapable memory to put_chars() under a specific configuration, which
 is explained in commit c4baad5029(virtio-console: avoid DMA from stack):
 1, c[] is on stack,
    hvc_console_print():
-	char c[N_OUTBUF] __ALIGNED__;
-	cons_ops[index]->put_chars(vtermnos[index], c, i);
+        char c[N_OUTBUF] __ALIGNED__;
+        cons_ops[index]->put_chars(vtermnos[index], c, i);
 2, ch is on stack,
    static void hvc_poll_put_char(,,char ch)
    {
-	struct tty_struct *tty = driver->ttys[0];
-	struct hvc_struct *hp = tty->driver_data;
-	int n;
-
-	do {
-		n = hp->ops->put_chars(hp->vtermno, &ch, 1);
-	} while (n <= 0);
+        struct tty_struct *tty = driver->ttys[0];
+        struct hvc_struct *hp = tty->driver_data;
+        int n;
+
+        do {
+                n = hp->ops->put_chars(hp->vtermno, &ch, 1);
+        } while (n <= 0);
    }
 
 Commit c4baad5029 is just the fix to avoid DMA from stack memory, which
@@ -30,27 +30,29 @@
 function in the first place. Otherwise, we still face the same issue if
 a new hvc backend using dma added in the furture.
 
-We make 'char c[N_OUTBUF]' part of 'struct hvc_struct', so hp->c is no
-longer the stack memory. we can use it in above two cases.
-
-Other fix is use L1_CACHE_BYTES as the alignment, use 'sizeof(long)' as
-dma alignment is wrong. And use struct_size() to calculate size of
-hvc_struct.
-
-Introduce another array(cons_outbuf[]) for the hp->c pointers next to
-the cons_ops[] and vtermnos[] arrays.
-
-With the patch, we can remove the fix c4baad5029.
+In this patch, add 'char cons_outbuf[]' as part of 'struct hvc_struct',
+so hp->cons_outbuf is no longer the stack memory, we can use it in above
+cases safely. We also add lock to protect cons_outbuf instead of using
+the global lock of hvc.
+
+Introduce array cons_hvcs[] for hvc pointers next to the cons_ops[] and
+vtermnos[] arrays. With the array, we can easily find hvc's cons_outbuf
+and its lock.
+
+Introduce array cons_early_outbuf[] to ensure the mechanism of early
+console still work normally.
+
+With the patch, we can revert the fix c4baad5029.
 
 Signed-off-by: Xianting Tian <xianting.tian@linux.alibaba.com>
-Tested-by: Xianting Tian <xianting.tian@linux.alibaba.com>
+Reviewed-by: Shile Zhang <shile.zhang@linux.alibaba.com>
 ---
- drivers/tty/hvc/hvc_console.c | 40 +++++++++++++++++++++--------------
- drivers/tty/hvc/hvc_console.h | 16 ++++++++++++--
- 2 files changed, 38 insertions(+), 18 deletions(-)
+ drivers/tty/hvc/hvc_console.c | 55 +++++++++++++++++++++++++----------
+ drivers/tty/hvc/hvc_console.h | 30 ++++++++++++++++++-
+ 2 files changed, 69 insertions(+), 16 deletions(-)
 
 diff --git a/drivers/tty/hvc/hvc_console.c b/drivers/tty/hvc/hvc_console.c
-index 5bb8c4e44..c56564eb7 100644
+index 5957ab728..b9521f0f0 100644
 --- a/drivers/tty/hvc/hvc_console.c
 +++ b/drivers/tty/hvc/hvc_console.c
 @@ -41,16 +41,6 @@
@@ -65,20 +67,21 @@
 -#define N_OUTBUF	16
 -#define N_INBUF		16
 -
--#define __ALIGNED__ __attribute__((__aligned__(sizeof(long))))
+-#define __ALIGNED__ __attribute__((__aligned__(L1_CACHE_BYTES)))
 -
  static struct tty_driver *hvc_driver;
  static struct task_struct *hvc_task;
  
-@@ -142,6 +132,7 @@ static int hvc_flush(struct hvc_struct *hp)
+@@ -142,6 +132,8 @@ static int hvc_flush(struct hvc_struct *hp)
  static const struct hv_ops *cons_ops[MAX_NR_HVC_CONSOLES];
  static uint32_t vtermnos[MAX_NR_HVC_CONSOLES] =
  	{[0 ... MAX_NR_HVC_CONSOLES - 1] = -1};
-+static char *cons_outbuf[MAX_NR_HVC_CONSOLES];
++static struct hvc_struct *cons_hvcs[MAX_NR_HVC_CONSOLES];
++static struct hvc_early_outbuf *cons_early_outbufs[MAX_NR_HVC_CONSOLES];
  
  /*
   * Console APIs, NOT TTY.  These APIs are available immediately when
-@@ -151,18 +142,23 @@ static uint32_t vtermnos[MAX_NR_HVC_CONSOLES] =
+@@ -151,9 +143,12 @@ static uint32_t vtermnos[MAX_NR_HVC_CONSOLES] =
  static void hvc_console_print(struct console *co, const char *b,
  			      unsigned count)
  {
@@ -88,52 +91,72 @@
  	int r, donecr = 0, index = co->index;
 +	unsigned long flags;
 +	struct hvc_struct *hp;
++	spinlock_t *lock;
  
  	/* Console access attempt outside of acceptable console range. */
  	if (index >= MAX_NR_HVC_CONSOLES)
+@@ -163,6 +158,27 @@ static void hvc_console_print(struct console *co, const char *b,
+ 	if (vtermnos[index] == -1)
  		return;
  
- 	/* This console adapter was removed so it is not usable. */
--	if (vtermnos[index] == -1)
-+	if (vtermnos[index] == -1 || !cons_outbuf[index])
- 		return;
- 
-+	c = cons_outbuf[index];
-+
-+	spin_lock_irqsave(&hp->c_lock, flags);
++	hp = cons_hvcs[index];
++	if (hp) {
++		c = hp->cons_outbuf;
++		lock = &hp->cons_outbuf_lock;
++
++		/*
++		 * To make free early console outbuf locklessly,
++		 * free it here when we start to use hp's outbuf.
++		 * The actual free action is executed only once.
++		 */
++		if (cons_early_outbufs[index]) {
++			kfree(cons_early_outbufs[index]);
++			cons_early_outbufs[index] = NULL;
++		}
++	} else {
++		/* For early console print */
++		c = cons_early_outbufs[index]->outbuf;
++		lock = &cons_early_outbufs[index]->lock;
++	}
++
++	spin_lock_irqsave(lock, flags);
  	while (count > 0 || i > 0) {
  		if (count > 0 && i < sizeof(c)) {
  			if (b[n] == '\n' && !donecr) {
-@@ -191,6 +187,7 @@ static void hvc_console_print(struct console *co, const char *b,
+@@ -191,6 +207,7 @@ static void hvc_console_print(struct console *co, const char *b,
  			}
  		}
  	}
-+	spin_unlock_irqrestore(&hp->c_lock, flags);
++	spin_unlock_irqrestore(lock, flags);
  	hvc_console_flush(cons_ops[index], vtermnos[index]);
  }
  
-@@ -878,9 +875,19 @@ static void hvc_poll_put_char(struct tty_driver *driver, int line, char ch)
+@@ -299,6 +316,9 @@ int hvc_instantiate(uint32_t vtermno, int index, const struct hv_ops *ops)
+ 		return -1;
+ 	}
+ 
++	cons_early_outbufs[index] = kzalloc(sizeof(struct hvc_early_outbuf),
++					    GFP_KERNEL);
++	spin_lock_init(&cons_early_outbufs[index]->lock);
+ 	vtermnos[index] = vtermno;
+ 	cons_ops[index] = ops;
+ 
+@@ -878,9 +898,13 @@ static void hvc_poll_put_char(struct tty_driver *driver, int line, char ch)
  	struct tty_struct *tty = driver->ttys[0];
  	struct hvc_struct *hp = tty->driver_data;
  	int n;
 +	unsigned long flags;
-+	char *c;
-+
-+	if (!hp || !cons_outbuf[hp->index])
-+		return;
-+
-+	c = cons_outbuf[hp->index];
  
  	do {
 -		n = hp->ops->put_chars(hp->vtermno, &ch, 1);
-+		spin_lock_irqsave(&hp->c_lock, flags);
-+		c[0] = ch;
-+		n = hp->ops->put_chars(hp->vtermno, c, 1);
-+		spin_unlock_irqrestore(&hp->c_lock, flags);
++		spin_lock_irqsave(&hp->cons_outbuf_lock, flags);
++		hp->cons_outbuf[0] = ch;
++		n = hp->ops->put_chars(hp->vtermno, &hp->cons_outbuf[0], 1);
++		spin_unlock_irqrestore(&hp->cons_outbuf_lock, flags);
  	} while (n <= 0);
  }
  #endif
-@@ -922,8 +929,7 @@ struct hvc_struct *hvc_alloc(uint32_t vtermno, int data,
+@@ -922,8 +946,7 @@ struct hvc_struct *hvc_alloc(uint32_t vtermno, int data,
  			return ERR_PTR(err);
  	}
  
@@ -143,7 +166,7 @@
  	if (!hp)
  		return ERR_PTR(-ENOMEM);
  
-@@ -931,13 +937,13 @@ struct hvc_struct *hvc_alloc(uint32_t vtermno, int data,
+@@ -931,13 +954,13 @@ struct hvc_struct *hvc_alloc(uint32_t vtermno, int data,
  	hp->data = data;
  	hp->ops = ops;
  	hp->outbuf_size = outbuf_size;
@@ -154,31 +177,31 @@
  
  	INIT_WORK(&hp->tty_resize, hvc_set_winsz);
  	spin_lock_init(&hp->lock);
-+	spin_lock_init(&hp->c_lock);
++	spin_lock_init(&hp->cons_outbuf_lock);
  	mutex_lock(&hvc_structs_mutex);
  
  	/*
-@@ -964,6 +970,7 @@ struct hvc_struct *hvc_alloc(uint32_t vtermno, int data,
+@@ -964,6 +987,7 @@ struct hvc_struct *hvc_alloc(uint32_t vtermno, int data,
  	if (i < MAX_NR_HVC_CONSOLES) {
  		cons_ops[i] = ops;
  		vtermnos[i] = vtermno;
-+		cons_outbuf[i] = hp->c;
++		cons_hvcs[i] = hp;
  	}
  
  	list_add_tail(&(hp->next), &hvc_structs);
-@@ -988,6 +995,7 @@ int hvc_remove(struct hvc_struct *hp)
+@@ -988,6 +1012,7 @@ int hvc_remove(struct hvc_struct *hp)
  	if (hp->index < MAX_NR_HVC_CONSOLES) {
  		vtermnos[hp->index] = -1;
  		cons_ops[hp->index] = NULL;
-+		cons_outbuf[hp->index] = NULL;
++		cons_hvcs[hp->index] = NULL;
  	}
  
  	/* Don't whack hp->irq because tty_hangup() will need to free the irq. */
 diff --git a/drivers/tty/hvc/hvc_console.h b/drivers/tty/hvc/hvc_console.h
-index 18d005814..52374e2da 100644
+index 18d005814..3a9fe9275 100644
 --- a/drivers/tty/hvc/hvc_console.h
 +++ b/drivers/tty/hvc/hvc_console.h
-@@ -32,13 +32,21 @@
+@@ -32,12 +32,30 @@
   */
  #define HVC_ALLOC_TTY_ADAPTERS	8
  
@@ -192,24 +215,38 @@
 +
 +#define __ALIGNED__ __attribute__((__aligned__(L1_CACHE_BYTES)))
 +
++/*
++ * This is for early console print when hvc backend calls
++ * hvc_instantiate() to create an early console.
++ */
++struct hvc_early_outbuf {
++	spinlock_t lock;
++	char outbuf[N_OUTBUF] __ALIGNED__;
++};
++
  struct hvc_struct {
  	struct tty_port port;
  	spinlock_t lock;
  	int index;
  	int do_wakeup;
 -	char *outbuf;
--	int outbuf_size;
+ 	int outbuf_size;
  	int n_outbuf;
  	uint32_t vtermno;
- 	const struct hv_ops *ops;
-@@ -48,6 +56,10 @@ struct hvc_struct {
+@@ -48,6 +66,16 @@ struct hvc_struct {
  	struct work_struct tty_resize;
  	struct list_head next;
  	unsigned long flags;
-+	spinlock_t c_lock;
-+	char c[N_OUTBUF] __ALIGNED__;
-+	int outbuf_size;
-+	char outbuf[0] __ALIGNED__;
++
++	/*
++	 * the buf and its lock are used in hvc console api for putting chars,
++	 * and also used in hvc_poll_put_char() for putting single char.
++	 */
++	spinlock_t cons_outbuf_lock;
++	char cons_outbuf[N_OUTBUF] __ALIGNED__;
++
++	/* the buf is used for putting chars to tty */
++	char outbuf[] __ALIGNED__;
  };
  
  /* implemented by a low level driver */