wpi(4): add support for TX fragmentation

[avos]

Test Plan

Tested with Intel 3945BG, HOSTAP and STA modes

[avos]

Fix order of operations.

[avos]

• Fix few races (TX/RX; deferred TX pointer commit w/ powersave enabled).
• Improve error handling.

sys/dev/wpi/if_wpi.c

 
 #define LBUF_SIZE 4096
 
 struct log_params {
         int dosyslog;
         int logpri;
         int noclose;
         int outfd;
+        const char *outfn;
 };
 
 static void restrict_process(const char *);
 static void handle_term(int);
 static void handle_chld(int);
+static void handle_hup(int);
+static int open_log(const char *);
+static void reopen_log(struct log_params *);
 static int  listen_child(int, struct log_params *);
 static int  get_log_mapping(const char *, const CODE *);
 static void open_pid_files(const char *, const char *, struct pidfh **,
                            struct pidfh **);
 static void do_output(const unsigned char *, size_t, struct log_params *);
 static void daemon_sleep(time_t, long);
 static void usage(void);
 
-static volatile sig_atomic_t terminate = 0, child_gone = 0, pid = 0;
+static volatile sig_atomic_t terminate = 0, child_gone = 0, pid = 0,
+  do_log_reopen = 0;
 
 int
 main(int argc, char *argv[])
 {
         const char *pidfile, *ppidfile, *title, *user, *outfn, *logtag;
         int ch, nochdir, noclose, restart, dosyslog, child_eof;
         sigset_t mask_susp, mask_orig, mask_read, mask_term;
         struct log_params logpar;
         int pfd[2] = { -1, -1 }, outfd = -1;
-        int stdmask, logpri, logfac;
+        int stdmask, logpri, logfac, log_reopen;
         struct pidfh *ppfh, *pfh;
         char *p;
 
         memset(&logpar, 0, sizeof(logpar));
         stdmask = STDOUT_FILENO | STDERR_FILENO;
         ppidfile = pidfile = user = NULL;
         nochdir = noclose = 1;
         logpri = LOG_NOTICE;
         logfac = LOG_DAEMON;
         logtag = "daemon";
         restart = 0;
         dosyslog = 0;
+        log_reopen = 0;
         outfn = NULL;
         title = NULL;
-        while ((ch = getopt(argc, argv, "cfSp:P:ru:o:s:l:t:l:m:R:T:")) != -1) {
+        while ((ch = getopt(argc, argv, "cfHSp:P:ru:o:s:l:t:l:m:R:T:")) != -1) {
                 switch (ch) {
                 case 'c':
                         nochdir = 0;
                         break;
                 case 'f':
                         noclose = 0;
                         break;
+                case 'H':
+                        log_reopen = 1;
+                        break;
                 case 'l':
                         logfac = get_log_mapping(optarg, facilitynames);
                         if (logfac == -1)
                                 errx(5, "unrecognized syslog facility");
                         dosyslog = 1;
                         break;
                 case 'm':
                         stdmask = strtol(optarg, &p, 10);
main(int argc, char *argv[])
 
         if (argc == 0)
                 usage();
 
         if (!title)
                 title = argv[0];
 
         if (outfn) {
-                outfd = open(outfn, O_CREAT | O_WRONLY | O_APPEND | O_CLOEXEC, 0600);
+                outfd = open_log(outfn);
                 if (outfd == -1)
                         err(7, "open");
         }
         
         if (dosyslog)
                 openlog(logtag, LOG_PID | LOG_NDELAY, logfac);
 
         ppfh = pfh = NULL;
main(int argc, char *argv[])
          * leaving the running process and the stale pidfile, so we
          * catch SIGTERM and forward it to the children expecting to
          * get SIGCHLD eventually. We also must fork() to obtain a
          * readable pipe with the child for writing to a log file
          * and syslog.
          */
         pid = -1;
         if (pidfile || ppidfile || restart || outfd != -1 || dosyslog) {
-                struct sigaction act_term, act_chld;
+                struct sigaction act_term, act_chld, act_hup;
 
                 /* Avoid PID racing with SIGCHLD and SIGTERM. */
                 memset(&act_term, 0, sizeof(act_term));
                 act_term.sa_handler = handle_term;
                 sigemptyset(&act_term.sa_mask);
                 sigaddset(&act_term.sa_mask, SIGCHLD);
 
                 memset(&act_chld, 0, sizeof(act_chld));
                 act_chld.sa_handler = handle_chld;
                 sigemptyset(&act_chld.sa_mask);
                 sigaddset(&act_chld.sa_mask, SIGTERM);
 
+                memset(&act_hup, 0, sizeof(act_hup));
+                act_hup.sa_handler = handle_hup;
+                sigemptyset(&act_hup.sa_mask);
+
                 /* Block these when avoiding racing before sigsuspend(). */
                 sigemptyset(&mask_susp);
                 sigaddset(&mask_susp, SIGTERM);
                 sigaddset(&mask_susp, SIGCHLD);
                 /* Block SIGTERM when we lack a valid child PID. */
                 sigemptyset(&mask_term);
                 sigaddset(&mask_term, SIGTERM);
                 /*
if (pidfile || ppidfile || restart || outfd != -1 || dosyslog) {
                  * error, madvise(2) will fail only if a process does
                  * not have superuser privileges.
                  */
                 (void)madvise(NULL, 0, MADV_PROTECT);
                 logpar.outfd = outfd;
                 logpar.dosyslog = dosyslog;
                 logpar.logpri = logpri;
                 logpar.noclose = noclose;
+                logpar.outfn = outfn;
+                if (log_reopen && outfd >= 0 &&
+                    sigaction(SIGHUP, &act_hup, NULL) == -1) {
+                        warn("sigaction");
+                        goto exit;
+                }
 restart:
                 if (pipe(pfd))
                         err(1, "pipe");
                 /*
                  * Spawn a child to exec the command.
                  */
                 child_gone = 0;
                 pid = fork();

 {
         static unsigned char buf[LBUF_SIZE];
         static size_t bytes_read = 0;
         int rv;
 
         assert(logpar);
         assert(bytes_read < LBUF_SIZE - 1);
 
+        if (do_log_reopen)
+                reopen_log(logpar);
         rv = read(fd, buf + bytes_read, LBUF_SIZE - bytes_read - 1);
         if (rv > 0) {
                 unsigned char *cp;
 
                 bytes_read += rv;
                 assert(bytes_read <= LBUF_SIZE - 1);
                 /* Always NUL-terminate just in case. */
                 buf[LBUF_SIZE - 1] = '\0';

 handle_term(int signo)
 {
         if (pid > 0 && !child_gone)
                 kill(pid, signo);
         terminate = 1;
 }
 
 static void
-handle_chld(int signo)
+handle_chld(int signo __unused)
 {
-        (void)signo;
+
         for (;;) {
                 int rv = waitpid(-1, NULL, WNOHANG);
                 if (pid == rv) {
                         child_gone = 1;
                         break;
                 } else if (rv == -1 && errno != EINTR) {
                         warn("waitpid");
                         return;
                 }
         }
 }
 
 static void
+handle_hup(int signo __unused)
+{
+
+        do_log_reopen = 1;
+}
+
+static int
+open_log(const char *outfn)
+{
+
+        return open(outfn, O_CREAT | O_WRONLY | O_APPEND | O_CLOEXEC, 0600);
+}
+
+static void
+reopen_log(struct log_params *lpp)
+{
+        int outfd;
+
+        do_log_reopen = 0;
+        outfd = open_log(lpp->outfn);
+        if (lpp->outfd >= 0)
+                close(lpp->outfd);
+        lpp->outfd = outfd;
+}
+
+static void
 usage(void)
 {
         (void)fprintf(stderr,
-            "usage: daemon [-cfrS] [-p child_pidfile] [-P supervisor_pidfile]\n"
+            "usage: daemon [-cfHrS] [-p child_pidfile] [-P supervisor_pidfile]\n"
             "              [-u user] [-o output_file] [-t title]\n"
             "              [-l syslog_facility] [-s syslog_priority]\n"
             "              [-T syslog_tag] [-m output_mask] [-R restart_delay_secs]\n"
             "command arguments ...\n");
         exit(1);
 }

sys/dev/wpi/if_wpireg.h

 
 #define LBUF_SIZE 4096
 
 struct log_params {
         int dosyslog;
         int logpri;
         int noclose;
         int outfd;
+        const char *outfn;
 };
 
 static void restrict_process(const char *);
 static void handle_term(int);
 static void handle_chld(int);
+static void handle_hup(int);
+static int open_log(const char *);
+static void reopen_log(struct log_params *);
 static int  listen_child(int, struct log_params *);
 static int  get_log_mapping(const char *, const CODE *);
 static void open_pid_files(const char *, const char *, struct pidfh **,
                            struct pidfh **);
 static void do_output(const unsigned char *, size_t, struct log_params *);
 static void daemon_sleep(time_t, long);
 static void usage(void);
 
-static volatile sig_atomic_t terminate = 0, child_gone = 0, pid = 0;
+static volatile sig_atomic_t terminate = 0, child_gone = 0, pid = 0,
+  do_log_reopen = 0;
 
 int
 main(int argc, char *argv[])
 {
         const char *pidfile, *ppidfile, *title, *user, *outfn, *logtag;
         int ch, nochdir, noclose, restart, dosyslog, child_eof;
         sigset_t mask_susp, mask_orig, mask_read, mask_term;
         struct log_params logpar;
         int pfd[2] = { -1, -1 }, outfd = -1;
-        int stdmask, logpri, logfac;
+        int stdmask, logpri, logfac, log_reopen;
         struct pidfh *ppfh, *pfh;
         char *p;
 
         memset(&logpar, 0, sizeof(logpar));
         stdmask = STDOUT_FILENO | STDERR_FILENO;
         ppidfile = pidfile = user = NULL;
         nochdir = noclose = 1;
         logpri = LOG_NOTICE;
         logfac = LOG_DAEMON;
         logtag = "daemon";
         restart = 0;
         dosyslog = 0;
+        log_reopen = 0;
         outfn = NULL;
         title = NULL;
-        while ((ch = getopt(argc, argv, "cfSp:P:ru:o:s:l:t:l:m:R:T:")) != -1) {
+        while ((ch = getopt(argc, argv, "cfHSp:P:ru:o:s:l:t:l:m:R:T:")) != -1) {
                 switch (ch) {
                 case 'c':
                         nochdir = 0;
                         break;
                 case 'f':
                         noclose = 0;
                         break;
+                case 'H':
+                        log_reopen = 1;
+                        break;
                 case 'l':
                         logfac = get_log_mapping(optarg, facilitynames);
                         if (logfac == -1)
                                 errx(5, "unrecognized syslog facility");
                         dosyslog = 1;
                         break;
                 case 'm':
                         stdmask = strtol(optarg, &p, 10);
main(int argc, char *argv[])
 
         if (argc == 0)
                 usage();
 
         if (!title)
                 title = argv[0];
 
         if (outfn) {
-                outfd = open(outfn, O_CREAT | O_WRONLY | O_APPEND | O_CLOEXEC, 0600);
+                outfd = open_log(outfn);
                 if (outfd == -1)
                         err(7, "open");
         }
         
         if (dosyslog)
                 openlog(logtag, LOG_PID | LOG_NDELAY, logfac);
 
         ppfh = pfh = NULL;
main(int argc, char *argv[])
          * leaving the running process and the stale pidfile, so we
          * catch SIGTERM and forward it to the children expecting to
          * get SIGCHLD eventually. We also must fork() to obtain a
          * readable pipe with the child for writing to a log file
          * and syslog.
          */
         pid = -1;
         if (pidfile || ppidfile || restart || outfd != -1 || dosyslog) {
-                struct sigaction act_term, act_chld;
+                struct sigaction act_term, act_chld, act_hup;
 
                 /* Avoid PID racing with SIGCHLD and SIGTERM. */
                 memset(&act_term, 0, sizeof(act_term));
                 act_term.sa_handler = handle_term;
                 sigemptyset(&act_term.sa_mask);
                 sigaddset(&act_term.sa_mask, SIGCHLD);
 
                 memset(&act_chld, 0, sizeof(act_chld));
                 act_chld.sa_handler = handle_chld;
                 sigemptyset(&act_chld.sa_mask);
                 sigaddset(&act_chld.sa_mask, SIGTERM);
 
+                memset(&act_hup, 0, sizeof(act_hup));
+                act_hup.sa_handler = handle_hup;
+                sigemptyset(&act_hup.sa_mask);
+
                 /* Block these when avoiding racing before sigsuspend(). */
                 sigemptyset(&mask_susp);
                 sigaddset(&mask_susp, SIGTERM);
                 sigaddset(&mask_susp, SIGCHLD);
                 /* Block SIGTERM when we lack a valid child PID. */
                 sigemptyset(&mask_term);
                 sigaddset(&mask_term, SIGTERM);
                 /*
if (pidfile || ppidfile || restart || outfd != -1 || dosyslog) {
                  * error, madvise(2) will fail only if a process does
                  * not have superuser privileges.
                  */
                 (void)madvise(NULL, 0, MADV_PROTECT);
                 logpar.outfd = outfd;
                 logpar.dosyslog = dosyslog;
                 logpar.logpri = logpri;
                 logpar.noclose = noclose;
+                logpar.outfn = outfn;
+                if (log_reopen && outfd >= 0 &&
+                    sigaction(SIGHUP, &act_hup, NULL) == -1) {
+                        warn("sigaction");
+                        goto exit;
+                }
 restart:
                 if (pipe(pfd))
                         err(1, "pipe");
                 /*
                  * Spawn a child to exec the command.
                  */
                 child_gone = 0;
                 pid = fork();

 {
         static unsigned char buf[LBUF_SIZE];
         static size_t bytes_read = 0;
         int rv;
 
         assert(logpar);
         assert(bytes_read < LBUF_SIZE - 1);
 
+        if (do_log_reopen)
+                reopen_log(logpar);
         rv = read(fd, buf + bytes_read, LBUF_SIZE - bytes_read - 1);
         if (rv > 0) {
                 unsigned char *cp;
 
                 bytes_read += rv;
                 assert(bytes_read <= LBUF_SIZE - 1);
                 /* Always NUL-terminate just in case. */
                 buf[LBUF_SIZE - 1] = '\0';

 handle_term(int signo)
 {
         if (pid > 0 && !child_gone)
                 kill(pid, signo);
         terminate = 1;
 }
 
 static void
-handle_chld(int signo)
+handle_chld(int signo __unused)
 {
-        (void)signo;
+
         for (;;) {
                 int rv = waitpid(-1, NULL, WNOHANG);
                 if (pid == rv) {
                         child_gone = 1;
                         break;
                 } else if (rv == -1 && errno != EINTR) {
                         warn("waitpid");
                         return;
                 }
         }
 }
 
 static void
+handle_hup(int signo __unused)
+{
+
+        do_log_reopen = 1;
+}
+
+static int
+open_log(const char *outfn)
+{
+
+        return open(outfn, O_CREAT | O_WRONLY | O_APPEND | O_CLOEXEC, 0600);
+}
+
+static void
+reopen_log(struct log_params *lpp)
+{
+        int outfd;
+
+        do_log_reopen = 0;
+        outfd = open_log(lpp->outfn);
+        if (lpp->outfd >= 0)
+                close(lpp->outfd);
+        lpp->outfd = outfd;
+}
+
+static void
 usage(void)
 {
         (void)fprintf(stderr,
-            "usage: daemon [-cfrS] [-p child_pidfile] [-P supervisor_pidfile]\n"
+            "usage: daemon [-cfHrS] [-p child_pidfile] [-P supervisor_pidfile]\n"
             "              [-u user] [-o output_file] [-t title]\n"
             "              [-l syslog_facility] [-s syslog_priority]\n"
             "              [-T syslog_tag] [-m output_mask] [-R restart_delay_secs]\n"
             "command arguments ...\n");
         exit(1);
 }

sys/dev/wpi/if_wpivar.h

 
 #define LBUF_SIZE 4096
 
 struct log_params {
         int dosyslog;
         int logpri;
         int noclose;
         int outfd;
+        const char *outfn;
 };
 
 static void restrict_process(const char *);
 static void handle_term(int);
 static void handle_chld(int);
+static void handle_hup(int);
+static int open_log(const char *);
+static void reopen_log(struct log_params *);
 static int  listen_child(int, struct log_params *);
 static int  get_log_mapping(const char *, const CODE *);
 static void open_pid_files(const char *, const char *, struct pidfh **,
                            struct pidfh **);
 static void do_output(const unsigned char *, size_t, struct log_params *);
 static void daemon_sleep(time_t, long);
 static void usage(void);
 
-static volatile sig_atomic_t terminate = 0, child_gone = 0, pid = 0;
+static volatile sig_atomic_t terminate = 0, child_gone = 0, pid = 0,
+  do_log_reopen = 0;
 
 int
 main(int argc, char *argv[])
 {
         const char *pidfile, *ppidfile, *title, *user, *outfn, *logtag;
         int ch, nochdir, noclose, restart, dosyslog, child_eof;
         sigset_t mask_susp, mask_orig, mask_read, mask_term;
         struct log_params logpar;
         int pfd[2] = { -1, -1 }, outfd = -1;
-        int stdmask, logpri, logfac;
+        int stdmask, logpri, logfac, log_reopen;
         struct pidfh *ppfh, *pfh;
         char *p;
 
         memset(&logpar, 0, sizeof(logpar));
         stdmask = STDOUT_FILENO | STDERR_FILENO;
         ppidfile = pidfile = user = NULL;
         nochdir = noclose = 1;
         logpri = LOG_NOTICE;
         logfac = LOG_DAEMON;
         logtag = "daemon";
         restart = 0;
         dosyslog = 0;
+        log_reopen = 0;
         outfn = NULL;
         title = NULL;
-        while ((ch = getopt(argc, argv, "cfSp:P:ru:o:s:l:t:l:m:R:T:")) != -1) {
+        while ((ch = getopt(argc, argv, "cfHSp:P:ru:o:s:l:t:l:m:R:T:")) != -1) {
                 switch (ch) {
                 case 'c':
                         nochdir = 0;
                         break;
                 case 'f':
                         noclose = 0;
                         break;
+                case 'H':
+                        log_reopen = 1;
+                        break;
                 case 'l':
                         logfac = get_log_mapping(optarg, facilitynames);
                         if (logfac == -1)
                                 errx(5, "unrecognized syslog facility");
                         dosyslog = 1;
                         break;
                 case 'm':
                         stdmask = strtol(optarg, &p, 10);
main(int argc, char *argv[])
 
         if (argc == 0)
                 usage();
 
         if (!title)
                 title = argv[0];
 
         if (outfn) {
-                outfd = open(outfn, O_CREAT | O_WRONLY | O_APPEND | O_CLOEXEC, 0600);
+                outfd = open_log(outfn);
                 if (outfd == -1)
                         err(7, "open");
         }
         
         if (dosyslog)
                 openlog(logtag, LOG_PID | LOG_NDELAY, logfac);
 
         ppfh = pfh = NULL;
main(int argc, char *argv[])
          * leaving the running process and the stale pidfile, so we
          * catch SIGTERM and forward it to the children expecting to
          * get SIGCHLD eventually. We also must fork() to obtain a
          * readable pipe with the child for writing to a log file
          * and syslog.
          */
         pid = -1;
         if (pidfile || ppidfile || restart || outfd != -1 || dosyslog) {
-                struct sigaction act_term, act_chld;
+                struct sigaction act_term, act_chld, act_hup;
 
                 /* Avoid PID racing with SIGCHLD and SIGTERM. */
                 memset(&act_term, 0, sizeof(act_term));
                 act_term.sa_handler = handle_term;
                 sigemptyset(&act_term.sa_mask);
                 sigaddset(&act_term.sa_mask, SIGCHLD);
 
                 memset(&act_chld, 0, sizeof(act_chld));
                 act_chld.sa_handler = handle_chld;
                 sigemptyset(&act_chld.sa_mask);
                 sigaddset(&act_chld.sa_mask, SIGTERM);
 
+                memset(&act_hup, 0, sizeof(act_hup));
+                act_hup.sa_handler = handle_hup;
+                sigemptyset(&act_hup.sa_mask);
+
                 /* Block these when avoiding racing before sigsuspend(). */
                 sigemptyset(&mask_susp);
                 sigaddset(&mask_susp, SIGTERM);
                 sigaddset(&mask_susp, SIGCHLD);
                 /* Block SIGTERM when we lack a valid child PID. */
                 sigemptyset(&mask_term);
                 sigaddset(&mask_term, SIGTERM);
                 /*
if (pidfile || ppidfile || restart || outfd != -1 || dosyslog) {
                  * error, madvise(2) will fail only if a process does
                  * not have superuser privileges.
                  */
                 (void)madvise(NULL, 0, MADV_PROTECT);
                 logpar.outfd = outfd;
                 logpar.dosyslog = dosyslog;
                 logpar.logpri = logpri;
                 logpar.noclose = noclose;
+                logpar.outfn = outfn;
+                if (log_reopen && outfd >= 0 &&
+                    sigaction(SIGHUP, &act_hup, NULL) == -1) {
+                        warn("sigaction");
+                        goto exit;
+                }
 restart:
                 if (pipe(pfd))
                         err(1, "pipe");
                 /*
                  * Spawn a child to exec the command.
                  */
                 child_gone = 0;
                 pid = fork();

 {
         static unsigned char buf[LBUF_SIZE];
         static size_t bytes_read = 0;
         int rv;
 
         assert(logpar);
         assert(bytes_read < LBUF_SIZE - 1);
 
+        if (do_log_reopen)
+                reopen_log(logpar);
         rv = read(fd, buf + bytes_read, LBUF_SIZE - bytes_read - 1);
         if (rv > 0) {
                 unsigned char *cp;
 
                 bytes_read += rv;
                 assert(bytes_read <= LBUF_SIZE - 1);
                 /* Always NUL-terminate just in case. */
                 buf[LBUF_SIZE - 1] = '\0';

 handle_term(int signo)
 {
         if (pid > 0 && !child_gone)
                 kill(pid, signo);
         terminate = 1;
 }
 
 static void
-handle_chld(int signo)
+handle_chld(int signo __unused)
 {
-        (void)signo;
+
         for (;;) {
                 int rv = waitpid(-1, NULL, WNOHANG);
                 if (pid == rv) {
                         child_gone = 1;
                         break;
                 } else if (rv == -1 && errno != EINTR) {
                         warn("waitpid");
                         return;
                 }
         }
 }
 
 static void
+handle_hup(int signo __unused)
+{
+
+        do_log_reopen = 1;
+}
+
+static int
+open_log(const char *outfn)
+{
+
+        return open(outfn, O_CREAT | O_WRONLY | O_APPEND | O_CLOEXEC, 0600);
+}
+
+static void
+reopen_log(struct log_params *lpp)
+{
+        int outfd;
+
+        do_log_reopen = 0;
+        outfd = open_log(lpp->outfn);
+        if (lpp->outfd >= 0)
+                close(lpp->outfd);
+        lpp->outfd = outfd;
+}
+
+static void
 usage(void)
 {
         (void)fprintf(stderr,
-            "usage: daemon [-cfrS] [-p child_pidfile] [-P supervisor_pidfile]\n"
+            "usage: daemon [-cfHrS] [-p child_pidfile] [-P supervisor_pidfile]\n"
             "              [-u user] [-o output_file] [-t title]\n"
             "              [-l syslog_facility] [-s syslog_priority]\n"
             "              [-T syslog_tag] [-m output_mask] [-R restart_delay_secs]\n"
             "command arguments ...\n");
         exit(1);
 }