socket async io

Similar Threads:

1.Need help with a simple UNIX sockets server based on IO::Socket::UNIX

Hi. I've tried to create a simple client + server that communicate
through a unix socket.

As with all socket servers, it has a loop where it waits for
connections:

while ($client = $sock->accept()) {
  # handle client here
}

The problem is that $sock->accept() is returning undef on each
alternate client connection with error "No child processes".

I made this temporary workaround that does work but of course I must be
screwing up somewhere else:

while ($client = $sock->accept() || $client = $sock->accept()) {
  # handle client here
}

I hope someone can help or provide an example. I've included the client
+ server code below for those who are interrested in taking a peek.

Thanks,
Craig Manley

############ client ############
#!/usr/bin/perl -w
use strict;
use IO::Socket;

my $sockname = 'mysocket';

my $client = IO::Socket::UNIX->new('Peer' => $sockname,
                                   'Type' => SOCK_STREAM,
                                   'Timeout' => 50) or die "$0: error
connecting to '$sockname': $ [at] \n";
my $pid = fork();
unless(defined($pid)) {
  die("Fork this! I cannot forking fork!\n");
}
if ($pid) {
  write_sock();
  waitpid($pid, 0);
}
else {
  read_sock();
}

sub write_sock {
  for (1..10) {
    print $client "testline number $_\n"; # print to socket
  }
  print $client "\n"; # empty line causes server to terminate
connection
  print "Done writing.\n"; # (goes to stdout, not socket)
}

sub read_sock {
  while (my $line = <$client>) {
    print $line; # report to stdout
    # simulate someone reading slooowly (50ms/line):
    select(undef, undef, undef, 0.05);
  }
}




########### server ############
#!/usr/bin/perl -w
use strict;
use IO::Socket;
use POSIX ":sys_wait_h"; # (for WNOHANG)
use Data::Dumper qw(Dumper);

# example using unix domain socks
# once the file is created as a socket, any client can
# interact with it

my $sockname = 'mysocket';


service_clients( get_sock() ); # wait for incoming requests


sub get_sock {
  unlink $sockname;
  my $sock = IO::Socket::UNIX->new('Local'  => $sockname,
                                   'Type'   => SOCK_STREAM,
                                   'Listen' => SOMAXCONN) || die "$0:
error starting daemon on '$sockname': $ [at] \n";
  # you might want to change permissions and ownership, e.g.:
  #chmod 0600, $sockname;
  #chown scalar getpwnam('nobody'), 0, $sockname;
  return $sock;
}

sub service_clients {
  my $sock = shift;
  $SIG{CHLD} = \&reaper;
  my $client;
  while ($client = $sock->accept()) { # Why the hell does it return
undef on the next iteration?
  # while ($client = $sock->accept() || $client = $sock->accept()) { #
This strangely enough does work.

    # fork yet another process to prevent buffer deadlock. one proc
writes to
    # the sock, the other reads the deamons response
    my $pid = fork();
    unless(defined($pid)) {
      die("Fork this! I cannot forking fork!\n");
    }
    if ($pid) { # parent
      print "$pid $$: I'm the parent and am going to wait for another
client.\n";
      close($client); # no use to parent
      next; # be ready for another client
    }
    print "$pid $$: I'm the child and I'm going to service the
client.\n";
    # child
    close($sock); # no use to child
    process_requests($client);
    print "$pid $$: I'm the child and I'm going to exit.\n";
    exit; # terminate child
  }
  print "Damnit! I'm the server and I finished unexpectedly: $!\n";
}

sub process_requests {
  my $client = shift;
  $0 = "unixsockd: handling requests...";
  # read from client until empty line which causes it to close
connection
  while ( my $line = <$client> ) { # read line from socket
    if ($line =~ /^\s$/) {
      last; # exit on empty line
    }
    chomp($line);
    # put some more useful code here to read each line or whatever...
    printf $client "%s: %s, handled by PID %d\n",
    scalar localtime(time), $line, $$;
    # return something to client
  }
}

sub reaper {
  while (waitpid(-1,WNOHANG) > 0) {}
  $SIG{CHLD} = \&reaper;
}

2.directio and async io on redhat linux 3 and oracle 9i

Hi Folks

I have enabled directio and async io on my redhat box.

Async io is verified by running the classical cat
/etc/proc/slabinfo|grep kio

How do i verify direct io is being used by oracle.

I know of one way to do it is tracing the dbwr and seeing whether fopen
call is with o_direct flags.But the strange thing is when i say

sqlplus>conn /as sysdba;

sqlplus>oradebug setospid <<ospid-of-dbwriter>>

no trace file is being produced.Can somebody tell me what magic needs
to be done by me :-)

regards
Hrishy

3.Redhat linux and async io

Hi,

Oracle10g 10.2.0.1 (32 bit)
RHEL 4 update 3 (32 bit)

* I have installed the async io rpm's
$ rpm -qa | grep aio
libaio-0.3.102-1
libaio-devel-0.3.102-1

Questions:
1) How do i verify/check if the async io is enabled/loaded in RHEL
kernel?
I solaris I used to
$ modinfo | grep kaio
142  1344ccb   4916 178   1  kaio (kernel Async I/O)
142  1344ccb   4916 178   1  kaio (kernel Async I/O for 32 bit com)

One of the Metalink docs says check
$ cat /proc/slabinfo | grep kio

2) How do I determine if the redlat linux installed is 32 or 64 bit
version?
Is getconf LONG_BIT the only way to determine this or will uname -a
show something specific.

Thanks for your help.
wagen

4.async io

How do I enable async io on solaris 8 2/02 ?  How do I tell if it is enabled
if using veritas foundation suite?

5.How to provide Async IO support in a driver

Hi,

I am having trouble getting the aio_read and aio_suspend calls to work
properly with a driver we have written to do DMA transfers via the PCI bus.
I do not know if the driver is properly configured to enable the async
xxxaread cb_ops function.  I have searched high and low and cannot find
anything written on this topic.  Does anyone know under what conditions the
xxxaread cb_ops function is called?  In tracing my drivers activity, even
though I call aio_read from the user process, the xxxread cb_ops is always
called by the kernel.  Although I am able to start the DMA, I am having
trouble getting biodone to properly notify the user process, particularly
when it is called from a timeout routine.

I am running Solaris 8/9.  Any information on how to properly write drivers
that support async io or how to properly time out DMA completion would be
greatly appreciated.

Regards,

Mike

6. [PATCH] [1/3] writes: report truncate and io errors on async writes

7. [PATCH 5/5] direct-io: fix double completion on partially valid async requests

8. [PATCH 4/5] direct-io: unify sync and async completion paths