[fusl] clang-format fusl

fusl/src/aio/lio_listio.c

 #include <aio.h>
 #include <errno.h>
 #include <unistd.h>
 #include <string.h>
 #include "pthread_impl.h"
 #include "libc.h"
 
 struct lio_state {
-        struct sigevent *sev;
-        int cnt;
-        struct aiocb *cbs[];
+  struct sigevent* sev;
+  int cnt;
+  struct aiocb* cbs[];
 };
 
-static int lio_wait(struct lio_state *st)
-{
-        int i, err, got_err = 0;
-        int cnt = st->cnt;
-        struct aiocb **cbs = st->cbs;
+static int lio_wait(struct lio_state* st) {
+  int i, err, got_err = 0;
+  int cnt = st->cnt;
+  struct aiocb** cbs = st->cbs;
 
-        for (;;) {
-                for (i=0; i<cnt; i++) {
-                        if (!cbs[i]) continue;
-                        err = aio_error(cbs[i]);
-                        if (err==EINPROGRESS)
-                                break;
-                        if (err) got_err=1;
-                        cbs[i] = 0;
-                }
-                if (i==cnt) {
-                        if (got_err) {
-                                errno = EIO;
-                                return -1;
-                        }
-                        return 0;
-                }
-                if (aio_suspend((void *)cbs, cnt, 0))
-                        return -1;
-        }
+  for (;;) {
+    for (i = 0; i < cnt; i++) {
+      if (!cbs[i])
+        continue;
+      err = aio_error(cbs[i]);
+      if (err == EINPROGRESS)
+        break;
+      if (err)
+        got_err = 1;
+      cbs[i] = 0;
+    }
+    if (i == cnt) {
+      if (got_err) {
+        errno = EIO;
+        return -1;
+      }
+      return 0;
+    }
+    if (aio_suspend((void*)cbs, cnt, 0))
+      return -1;
+  }
 }
 
-static void notify_signal(struct sigevent *sev)
-{
-        siginfo_t si = {
-                .si_signo = sev->sigev_signo,
-                .si_value = sev->sigev_value,
-                .si_code = SI_ASYNCIO,
-                .si_pid = getpid(),
-                .si_uid = getuid()
-        };
-        __syscall(SYS_rt_sigqueueinfo, si.si_pid, si.si_signo, &si);
+static void notify_signal(struct sigevent* sev) {
+  siginfo_t si = {.si_signo = sev->sigev_signo,
+                  .si_value = sev->sigev_value,
+                  .si_code = SI_ASYNCIO,
+                  .si_pid = getpid(),
+                  .si_uid = getuid()};
+  __syscall(SYS_rt_sigqueueinfo, si.si_pid, si.si_signo, &si);
 }
 
-static void *wait_thread(void *p)
-{
-        struct lio_state *st = p;
-        struct sigevent *sev = st->sev;
-        lio_wait(st);
-        free(st);
-        switch (sev->sigev_notify) {
-        case SIGEV_SIGNAL:
-                notify_signal(sev);
-                break;
-        case SIGEV_THREAD:
-                sev->sigev_notify_function(sev->sigev_value);
-                break;
-        }
-        return 0;
+static void* wait_thread(void* p) {
+  struct lio_state* st = p;
+  struct sigevent* sev = st->sev;
+  lio_wait(st);
+  free(st);
+  switch (sev->sigev_notify) {
+    case SIGEV_SIGNAL:
+      notify_signal(sev);
+      break;
+    case SIGEV_THREAD:
+      sev->sigev_notify_function(sev->sigev_value);
+      break;
+  }
+  return 0;
 }
 
-int lio_listio(int mode, struct aiocb *restrict const *restrict cbs, int cnt, struct sigevent *restrict sev)
-{
-        int i, ret;
-        struct lio_state *st=0;
+int lio_listio(int mode,
+               struct aiocb* restrict const* restrict cbs,
+               int cnt,
+               struct sigevent* restrict sev) {
+  int i, ret;
+  struct lio_state* st = 0;
 
-        if (cnt < 0) {
-                errno = EINVAL;
-                return -1;
-        }
+  if (cnt < 0) {
+    errno = EINVAL;
+    return -1;
+  }
 
-        if (mode == LIO_WAIT || (sev && sev->sigev_notify != SIGEV_NONE)) {
-                if (!(st = malloc(sizeof *st + cnt*sizeof *cbs))) {
-                        errno = EAGAIN;
-                        return -1;
-                }
-                st->cnt = cnt;
-                st->sev = sev;
-                memcpy(st->cbs, (void*) cbs, cnt*sizeof *cbs);
-        }
+  if (mode == LIO_WAIT || (sev && sev->sigev_notify != SIGEV_NONE)) {
+    if (!(st = malloc(sizeof *st + cnt * sizeof *cbs))) {
+      errno = EAGAIN;
+      return -1;
+    }
+    st->cnt = cnt;
+    st->sev = sev;
+    memcpy(st->cbs, (void*)cbs, cnt * sizeof *cbs);
+  }
 
-        for (i=0; i<cnt; i++) {
-                if (!cbs[i]) continue;
-                switch (cbs[i]->aio_lio_opcode) {
-                case LIO_READ:
-                        ret = aio_read(cbs[i]);
-                        break;
-                case LIO_WRITE:
-                        ret = aio_write(cbs[i]);
-                        break;
-                default:
-                        continue;
-                }
-                if (ret) {
-                        free(st);
-                        errno = EAGAIN;
-                        return -1;
-                }
-        }
+  for (i = 0; i < cnt; i++) {
+    if (!cbs[i])
+      continue;
+    switch (cbs[i]->aio_lio_opcode) {
+      case LIO_READ:
+        ret = aio_read(cbs[i]);
+        break;
+      case LIO_WRITE:
+        ret = aio_write(cbs[i]);
+        break;
+      default:
+        continue;
+    }
+    if (ret) {
+      free(st);
+      errno = EAGAIN;
+      return -1;
+    }
+  }
 
-        if (mode == LIO_WAIT) {
-                ret = lio_wait(st);
-                free(st);
-                return ret;
-        }
+  if (mode == LIO_WAIT) {
+    ret = lio_wait(st);
+    free(st);
+    return ret;
+  }
 
-        if (st) {
-                pthread_attr_t a;
-                sigset_t set;
-                pthread_t td;
+  if (st) {
+    pthread_attr_t a;
+    sigset_t set;
+    pthread_t td;
 
-                if (sev->sigev_notify == SIGEV_THREAD) {
-                        if (sev->sigev_notify_attributes)
-                                a = *sev->sigev_notify_attributes;
-                        else
-                                pthread_attr_init(&a);
-                } else {
-                        pthread_attr_init(&a);
-                        pthread_attr_setstacksize(&a, PAGE_SIZE);
-                        pthread_attr_setguardsize(&a, 0);
-                }
-                pthread_attr_setdetachstate(&a, PTHREAD_CREATE_DETACHED);
-                sigfillset(&set);
-                pthread_sigmask(SIG_BLOCK, &set, &set);
-                if (pthread_create(&td, &a, wait_thread, st)) {
-                        free(st);
-                        errno = EAGAIN;
-                        return -1;
-                }
-                pthread_sigmask(SIG_SETMASK, &set, 0);
-        }
+    if (sev->sigev_notify == SIGEV_THREAD) {
+      if (sev->sigev_notify_attributes)
+        a = *sev->sigev_notify_attributes;
+      else
+        pthread_attr_init(&a);
+    } else {
+      pthread_attr_init(&a);
+      pthread_attr_setstacksize(&a, PAGE_SIZE);
+      pthread_attr_setguardsize(&a, 0);
+    }
+    pthread_attr_setdetachstate(&a, PTHREAD_CREATE_DETACHED);
+    sigfillset(&set);
+    pthread_sigmask(SIG_BLOCK, &set, &set);
+    if (pthread_create(&td, &a, wait_thread, st)) {
+      free(st);
+      errno = EAGAIN;
+      return -1;
+    }
+    pthread_sigmask(SIG_SETMASK, &set, 0);
+  }
 
-        return 0;
+  return 0;
 }
 
 LFS64(lio_listio);