--- IO-AIO/AIO.pm	2018/08/26 03:17:35	1.296
+++ IO-AIO/AIO.pm	2019/03/10 12:11:46	1.300
@@ -173,7 +173,7 @@
 use base 'Exporter';
 
 BEGIN {
-   our $VERSION = 4.6;
+   our $VERSION = 4.71;
 
    our @AIO_REQ = qw(aio_sendfile aio_seek aio_read aio_write aio_open aio_close
                      aio_stat aio_lstat aio_unlink aio_rmdir aio_readdir aio_readdirx
@@ -1111,13 +1111,69 @@
          return $grp->result () if $_[0];
          my $now = time;
          my $hash1 = join ":", (stat _)[0,1,3,7,9];
+         my $rdxflags = READDIR_DIRS_FIRST;
+
+         if ((stat _)[3] < 2) {
+            # at least one non-POSIX filesystem exists
+            # that returns useful DT_type values: btrfs,
+            # so optimise for this here by requesting dents
+            $rdxflags |= READDIR_DENTS;
+         }
 
          # read the directory entries
          aioreq_pri $pri;
-         add $grp aio_readdirx $wd, READDIR_DIRS_FIRST, sub {
-            my $entries = shift
+         add $grp aio_readdirx $wd, $rdxflags, sub {
+            my ($entries, $flags) = @_
                or return $grp->result ();
 
+            if ($rdxflags & READDIR_DENTS) {
+               # if we requested type values, see if we can use them directly.
+
+               # if there were any DT_UNKNOWN entries then we assume we
+               # don't know. alternatively, we could assume that if we get
+               # one DT_DIR, then all directories are indeed marked with
+               # DT_DIR, but this seems not required for btrfs, and this
+               # is basically the "btrfs can't get it's act together" code
+               # branch.
+               unless ($flags & READDIR_FOUND_UNKNOWN) {
+                  # now we have valid DT_ information for all entries,
+                  # so use it as an optimisation without further stat's.
+                  # they must also all be at the beginning of @$entries
+                  # by now.
+
+                  my $dirs;
+
+                  if (@$entries) {
+                     for (0 .. $#$entries) {
+                        if ($entries->[$_][1] != DT_DIR) {
+                           # splice out directories
+                           $dirs = [splice @$entries, 0, $_];
+                           last;
+                        }
+                     }
+
+                     # if we didn't find any non-dir, then all entries are dirs
+                     unless ($dirs) {
+                        ($dirs, $entries) = ($entries, []);
+                     }
+                  } else {
+                     # directory is empty, so there are no sbdirs
+                     $dirs = [];
+                  }
+
+                  # either splice'd the directories out or the dir was empty.
+                  # convert dents to filenames
+                  $_ = $_->[0] for @$dirs;
+                  $_ = $_->[0] for @$entries;
+
+                  return $grp->result ($dirs, $entries);
+               }
+
+               # cannot use, so return to our old ways
+               # by pretending we only scanned for names.
+               $_ = $_->[0] for @$entries;
+            }
+
             # stat the dir another time
             aioreq_pri $pri;
             add $grp aio_stat $wd, sub {
@@ -1387,11 +1443,14 @@
 
 =item aio_mlockall $flags, $callback->($status)
 
-Calls the C<mlockall> function with the given C<$flags> (a combination of
-C<IO::AIO::MCL_CURRENT> and C<IO::AIO::MCL_FUTURE>).
+Calls the C<mlockall> function with the given C<$flags> (a
+combination of C<IO::AIO::MCL_CURRENT>, C<IO::AIO::MCL_FUTURE> and
+C<IO::AIO::MCL_ONFAULT>).
 
 On systems that do not implement C<mlockall>, this function returns C<-1>
-and sets errno to C<ENOSYS>.
+and sets errno to C<ENOSYS>. Similarly, flag combinations not supported
+by the system result in a return value of C<-1> with errno being set to
+C<EINVAL>.
 
 Note that the corresponding C<munlockall> is synchronous and is
 documented under L<MISCELLANEOUS FUNCTIONS>.
@@ -2297,6 +2356,11 @@
 On systems where this call is not supported or is not emulated, this call
 returns falls and sets C<$!> to C<ENOSYS>.
 
+=item IO::AIO::mlockall $flags
+
+Calls the C<eio_mlockall_sync> function, which is like C<aio_mlockall>,
+but is blocking.
+
 =item IO::AIO::munlock $scalar, $offset = 0, $length = undef
 
 Calls the C<munlock> function, undoing the effects of a previous