Version 1.19.

Signed-off-by: NIIBE Yutaka <gniibe@fsij.org>

ChangeLog

@@ -1,3 +1,37 @@
+2021-02-18  NIIBE Yutaka  <gniibe@fsij.org>
+
+	* VERSION: 1.19.
+	* doc/chopstx.texi (VERSION): 1.19.
+
+2021-02-17  NIIBE Yutaka  <gniibe@fsij.org>
+
+	Backport from master.
+	* contrib/ackbtn-gnu-linux.c: New.
+	* mcu/usb-usbip.c (usbip_run_server): Add start-up message.
+	* contrib/adc-gnu-linux.c (adc_start_conversion): Use getrandom.
+
+2021-02-12  NIIBE Yutaka  <gniibe@fsij.org>
+
+	Backport from 2.1.
+	* chopstx-gnu-linux.c (chopstx_create_arch): Clear TP.
+	* example-cdc-gnu-linux/usb-cdc.c (tty_recv): Cancel the input.
+	* example-cdc-gnu-linux/sample.c (main): Handle timeout by canceling
+	input.
+
+2019-12-30  NIIBE Yutaka  <gniibe@fsij.org>
+
+	* VERSION: 1.18.
+	* doc/chopstx.texi (VERSION): 1.18.
+
+2019-12-27  NIIBE Yutaka  <gniibe@fsij.org>
+
+	* chopstx.c (chopstx_poll): Call CHECK for condition
+	valiable after woken up.
+
+2019-12-04  NIIBE Yutaka  <gniibe@fsij.org>
+
+	* chopstx-gnu-linux.c (chx_thread_start): Fix return value.
+
 2019-11-21  NIIBE Yutaka  <gniibe@fsij.org>
 
 	* chopstx-cortex-m.c (chx_set_running): New.

NEWS

@@ -1,6 +1,45 @@
 NEWS - Noteworthy changes
 
 
+* Major changes in Chopstx 1.19
+
+  Released 2021-02-18
+
+** Acknowledge button support for GNU/Linux emulation
+User is asked acknowledge by RET with standard input.
+
+** USB driver for GNU/Linux emulation
+It shows start-up message now.
+
+** ADC driver for GNU/Linux emulation
+It uses getrandom(2), output is not deterministic any more.
+
+** Bug fix for GNU/Linux emulation
+When creating a thread, allocated memory for struct chx_thread was not
+initialized by chopstx_create_arch, assuming getcontext does it well.
+To make sure (getcontext would not update the area for FPU registers,
+when not used), it's now initialized by zeros.
+
+
+* Major changes in Chopstx 1.18
+
+  Released 2019-12-30
+
+** Fix of chopstx_poll
+When waiting for a condition variable, we supply CHECK method with a
+descriptor.  Since a condition variable may be fired for multiple
+reasons, old implementation of chopstx_poll may return with wrong
+information saying a condition of CHECK were met but actually not.  It
+should not return when condition is not satisfied and it should not
+give wrong information to application.  Fixed by calling the CHECK
+method again when woken up, and don't return when no condition meet.
+
+** Bug fix for GNU/Linux emulation
+When woken up, return value of chx_sched was wrong.  Because of this,
+timeout handling had problem.  Termination value of a thread was
+wrong.
+
+
 * Major changes in Chopstx 1.17
 
   Released 2019-11-20

README

@@ -1,6 +1,6 @@
 Chopstx - Threads and only Threads
-							Version 1.17
-							  2019-11-20
+							Version 1.19
+							  2021-02-18
 							Niibe Yutaka
 					     Flying Stone Technology
 
@@ -60,7 +60,8 @@ For STM32 Primer2, see the directory: example-primer2.
 Future Works
 ============
 
-RISC-V port (for GD32VF103) is under development.
+RISC-V port (for GD32VF103) is available in 2.x.  Please have a look
+at the master branch, and test it if possible.
 
 Convenience function to determine the bottom of thread stack,
 configuration of thread size by compiler's output would be next things

VERSION

@@ -1 +1 @@
-release/1.17
+release/1.19

chopstx-gnu-linux.c

@@ -2,7 +2,7 @@
  * chopstx-gnu-linux.c - Threads and only threads: Arch specific code
  *                       for GNU/Linux emulation
  *
- * Copyright (C) 2017, 2018, 2019 Flying Stone Technology
+ * Copyright (C) 2017, 2018, 2019, 2021 Flying Stone Technology
  * Author: NIIBE Yutaka <gniibe@fsij.org>
  *
  * This file is a part of Chopstx, a thread library for embedded.
@@ -328,9 +328,11 @@ chx_sched (uint32_t yield)
 static void __attribute__((__noreturn__))
 chx_thread_start (voidfunc thread_entry, void *arg)
 {
+  void *ret;
+
   chx_cpu_sched_unlock ();
-  thread_entry (arg);
-  chopstx_exit (0);
+  ret = thread_entry (arg);
+  chopstx_exit (ret);
 }
 
 static struct chx_thread *
@@ -347,6 +349,7 @@ chopstx_create_arch (uintptr_t stack_addr, size_t stack_size,
    * signal blocked.  The sigmask will be cleared in chx_thread_start.
    */
   chx_cpu_sched_lock ();
+  memset (tp, 0, sizeof (struct chx_thread));
   getcontext (&tp->tc);
   tp->tc.uc_stack.ss_sp = (void *)stack_addr;
   tp->tc.uc_stack.ss_size = stack_size;

chopstx.c

@@ -1411,6 +1411,7 @@ chopstx_poll (uint32_t *usec_p, int n, struct chx_poll_head *const pd_array[])
   for (i = 0; i < n; i++)
     chx_proxy_init (&px[i], &counter);
 
+ again:
   for (i = 0; i < n; i++)
     {
       pd = pd_array[i];
@@ -1473,6 +1474,20 @@ chopstx_poll (uint32_t *usec_p, int n, struct chx_poll_head *const pd_array[])
 	      ll_dequeue ((struct chx_pq *)&px[i]);
 	      chx_spin_unlock (&pc->cond->lock);
 	    }
+	  else
+	    { /* Check the condition again after woken up.  */
+	      if (pc->mutex)
+		chopstx_mutex_lock (pc->mutex);
+
+	      if ((*pc->check) (pc->arg) == 0)
+		{ /* Condition doesn't met.  */
+		  pc->ready = 0;
+		  counter--;
+		}
+
+	      if (pc->mutex)
+		chopstx_mutex_unlock (pc->mutex);
+	    }
 	}
       else if (pd->type == CHOPSTX_POLL_INTR)
 	{
@@ -1504,6 +1519,9 @@ chopstx_poll (uint32_t *usec_p, int n, struct chx_poll_head *const pd_array[])
   if (r < 0)
     chopstx_exit (CHOPSTX_CANCELED);
 
+  if (counter == 0 && (usec_p == NULL || *usec_p))
+    goto again;
+
   return counter;
 }
 

contrib/ackbtn-gnu-linux.c

@@ -0,0 +1,232 @@
+/*
+ * ackbtn-gnu-linux.c - Acknowledge button support for GNU/Linux
+ *
+ * Copyright (C) 2021  Free Software Initiative of Japan
+ * Author: NIIBE Yutaka <gniibe@fsij.org>
+ *
+ * This file is a part of Chopstx, a thread library for embedded.
+ *
+ * Chopstx is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Chopstx is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * As additional permission under GNU GPL version 3 section 7, you may
+ * distribute non-source form of the Program without the copy of the
+ * GNU GPL normally required by section 4, provided you inform the
+ * recipients of GNU GPL by a written offer.
+ *
+ */
+
+#include <pthread.h>
+
+#include <unistd.h>
+
+#include <stdint.h>
+#include <string.h>
+#include <chopstx.h>
+
+#include <stdio.h>
+#include <signal.h>
+#include <sys/eventfd.h>
+#include <poll.h>
+#include <errno.h>
+#include <stdlib.h>
+
+static pthread_t tid_main;
+static pthread_t tid_ui;
+
+static pthread_mutex_t mutex;
+static pthread_cond_t cond;
+static int enabled;
+static int event_fd;
+
+static void
+ackbtn_intr (int signum, siginfo_t *siginfo, void *arg)
+{
+  extern void chx_sigmask (ucontext_t *uc);
+  extern void chx_handle_intr (int signum);
+
+  ucontext_t *uc = arg;
+  (void)signum;
+  (void)siginfo;
+  chx_handle_intr (SIGUSR2);
+  chx_sigmask (uc);
+}
+
+
+#define ACKBTN_ACKED   (1 << 0)
+#define ACKBTN_TIMEOUT (1 << 2)
+
+static void *
+user_interaction (void *arg)
+{
+  struct pollfd pollfds[2];
+
+  (void)arg;
+
+  pollfds[0].fd = 0;		/* standard input */
+  pollfds[0].events = POLLIN;
+
+  pollfds[1].fd = event_fd;
+  pollfds[1].events = POLLIN;
+
+  fputs ("User interaction thread for AckBtn started.\n", stdout);
+
+  while (1)
+    {
+      unsigned int acked_or_timeout = 0;
+      char buf[256];
+
+      pthread_mutex_lock (&mutex);
+      while (!enabled)
+	pthread_cond_wait (&cond, &mutex);
+      pthread_mutex_unlock (&mutex);
+
+      /* Consume all input if any.  */
+      while (1)
+	{
+	  int r;
+
+	  pollfds[0].revents = 0;
+
+	  r = poll (pollfds, 1, 0);
+	  if (r < 0)
+	    {
+	      if (errno == EINTR)
+		continue;
+
+	      perror ("poll");
+	      exit (1);
+	    }
+
+	  if (r == 0)
+	    break;
+
+	  if ((pollfds[0].revents & POLLIN))
+	    read (0, buf, sizeof buf);
+	}
+
+      fputs ("Type RET to acknowledge (or wait for timeout) > ", stdout);
+      fflush (stdout);
+
+      while (!acked_or_timeout)
+	{
+	  pollfds[0].revents = 0;
+	  pollfds[1].revents = 0;
+
+	  if (poll (pollfds, 2, -1) < 0)
+	    {
+	      if (errno == EINTR)
+		continue;
+
+	      perror ("poll");
+	      exit (1);
+	    }
+
+	  if ((pollfds[0].revents & POLLIN))
+	    {
+	      read (0, buf, sizeof buf);
+	      acked_or_timeout |= ACKBTN_ACKED;
+	    }
+
+	  if ((pollfds[1].revents & POLLIN))
+	    acked_or_timeout |= ACKBTN_TIMEOUT;
+	}
+
+      pthread_mutex_lock (&mutex);
+      if ((acked_or_timeout & ACKBTN_ACKED))
+	{
+	  if ((acked_or_timeout & ACKBTN_TIMEOUT))
+	    /* No output of newline, as it follows timeout message.  */
+	    fputs ("Input ignored", stdout);
+	  else
+	    {
+	      pthread_kill (tid_main, SIGUSR2);
+	      fputs ("Acknowledged\n", stdout);
+	    }
+	}
+
+      if ((acked_or_timeout & ACKBTN_TIMEOUT))
+	fputs ("\nTimeout\n", stdout);
+
+      while (enabled)
+	pthread_cond_wait (&cond, &mutex);
+
+      read (event_fd, buf, sizeof (uint64_t));
+      pthread_mutex_unlock (&mutex);
+    }
+}
+
+void
+ackbtn_init (chopstx_intr_t *intr)
+{
+  int r;
+  sigset_t sigset;
+  struct sigaction act;
+
+  event_fd = eventfd (0, EFD_CLOEXEC);
+  if (event_fd < 0)
+    {
+      perror ("eventfd");
+      exit (1);
+    }
+
+  pthread_mutex_init (&mutex, NULL);
+  pthread_cond_init (&cond, NULL);
+  enabled = 0;
+
+  sigemptyset (&sigset);
+  sigaddset (&sigset, SIGUSR2);
+  sigaddset (&sigset, SIGALRM);
+
+  tid_main = pthread_self ();
+
+  /* Launch the thread for user interaction.  */
+  pthread_sigmask (SIG_BLOCK, &sigset, NULL);
+
+  r = pthread_create (&tid_ui, NULL, user_interaction, NULL);
+  if (r)
+    {
+      fprintf (stderr, "ackbtn_init: %s\n", strerror (r));
+      exit (1);
+    }
+
+  act.sa_sigaction = ackbtn_intr;
+  sigfillset (&act.sa_mask);
+  act.sa_flags = SA_SIGINFO|SA_RESTART;
+  sigaction (SIGUSR2, &act, NULL);
+
+  pthread_sigmask (SIG_UNBLOCK, &sigset, NULL);
+
+  chopstx_claim_irq (intr, SIGUSR2);
+}
+
+void
+ackbtn_enable (void)
+{
+  pthread_mutex_lock (&mutex);
+  enabled = 1;
+  pthread_cond_signal (&cond);
+  pthread_mutex_unlock (&mutex);
+}
+
+void
+ackbtn_disable (void)
+{
+  const uint64_t l = 1;
+
+  pthread_mutex_lock (&mutex);
+  enabled = 0;
+  write (event_fd, &l, sizeof (l));
+  pthread_cond_signal (&cond);
+  pthread_mutex_unlock (&mutex);
+}

contrib/adc-gnu-linux.c

@@ -3,7 +3,7 @@
  *                   This ADC driver just fills pseudo random values.
  *                   It's completely useless other than for NeuG.
  *
- * Copyright (C) 2017  Free Software Initiative of Japan
+ * Copyright (C) 2017, 2021  Free Software Initiative of Japan
  * Author: NIIBE Yutaka <gniibe@fsij.org>
  *
  * This file is a part of Chopstx, a thread library for embedded.
@@ -33,7 +33,7 @@
 #include <chopstx.h>
 #include "adc.h"
 
-#define ADC_RANDOM_SEED 0x01034649 /* "Hello, father!" in Japanese */
+#include <sys/random.h>
 
 /*
  * Do calibration for ADC.
@@ -41,7 +41,6 @@
 int
 adc_init (void)
 {
-  srandom (ADC_RANDOM_SEED);
   return 0;
 }
 
@@ -55,8 +54,7 @@ uint32_t adc_buf[64];
 void
 adc_start_conversion (int offset, int count)
 {
-  while (count--)
-    adc_buf[offset++] = random ();
+  getrandom (adc_buf+offset, count, 0);
 }
 
 

doc/chopstx.texi

@@ -1,7 +1,7 @@
 \input texinfo                      @c -*-texinfo-*-
 @c %**start of header
 @setfilename chopstx.info
-@set VERSION 1.17
+@set VERSION 1.19
 @settitle Chopstx Reference Manual
 @c Unify some of the indices.
 @syncodeindex tp fn

example-cdc-gnu-linux/sample.c

@@ -179,7 +179,14 @@ main (int argc, const char *argv[])
 	      if (size < 0)
 		goto connection_loop;
 
-	      if (size == 1)
+	      if (size == 0)
+		/* Timeout */
+		{
+		  if (tty_send (tty, "\r\n", 2) < 0)
+		    return 0;
+		  break;
+		}
+	      else if (size == 1)
 		/* Do nothing but prompt again.  */
 		break;
 	      else if (size)

example-cdc-gnu-linux/usb-cdc.c

@@ -768,7 +768,7 @@ tty_main (void *arg)
 	  && t->flag_send_ready)
 	{
 	  uint8_t line[32];
-	  int len = get_chars_from_ringbuffer (t, line, sizeof (len));
+	  int len = get_chars_from_ringbuffer (t, line, sizeof (line));
 
 	  if (len)
 	    {
@@ -904,8 +904,18 @@ tty_recv (struct tty *t, char *buf, uint32_t *timeout)
       chopstx_mutex_lock (&t->mtx);
       r = check_rx (t);
       chopstx_mutex_unlock (&t->mtx);
-      if (r || (timeout != NULL && *timeout == 0))
+      if (r)
 	break;
+      else if (timeout != NULL && *timeout == 0)
+	{
+	  int i;
+
+	  /* Cancel the input.	*/
+	  for (i = 0; i < t->inputline_len; i++)
+	    tty_send (t, "\x08\x20\x08", 3);
+	  t->inputline_len = 0;
+	  break;
+	}
     }
 
   chopstx_mutex_lock (&t->mtx);

example-cdc/usb-cdc.c

@@ -780,7 +780,7 @@ tty_main (void *arg)
 	  && t->flag_send_ready)
 	{
 	  uint8_t line[32];
-	  int len = get_chars_from_ringbuffer (t, line, sizeof (len));
+	  int len = get_chars_from_ringbuffer (t, line, sizeof (line));
 
 	  if (len)
 	    {

example-fs-bb48/usb-cdc.c

@@ -768,7 +768,7 @@ tty_main (void *arg)
 	  && t->flag_send_ready)
 	{
 	  uint8_t line[32];
-	  int len = get_chars_from_ringbuffer (t, line, sizeof (len));
+	  int len = get_chars_from_ringbuffer (t, line, sizeof (line));
 
 	  if (len)
 	    {

mcu/usb-usbip.c

@@ -1,7 +1,7 @@
 /*
  * usb-usbip.c - USB Device Emulation (server side) by USBIP
  *
- * Copyright (C) 2017, 2018  g10 Code GmbH
+ * Copyright (C) 2017, 2018, 2021  g10 Code GmbH
  * Author: NIIBE Yutaka <gniibe@fsij.org>
  *
  * This file is a part of Chopstx, a thread library for embedded.
@@ -1080,6 +1080,11 @@ usbip_run_server (void *arg)
       exit (1);
     }
 
+  fputs ("USBIP thread started.\n", stdout);
+  fputs ("You can use this by attaching following commands:\n", stdout);
+  fputs ("    # modprobe vhci_hcd\n", stdout);
+  fputs ("    # usbip attach -r 127.0.0.1 -b 1-1\n", stdout);
+
   pollfds[1].fd = shutdown_notify_fd;
   pollfds[1].events = POLLIN;
   pollfds[1].revents = 0;