3.5.3
        [...]

        If a computation requires more heap than can be made available by the 
        automatic storage management system, the Java virtual machine throws 
        an OutOfMemoryError

    3.5.6 Native Method Stacks

    An implementation of the Java virtual machine may use conventional 
    stacks, colloquially called "C stacks," to support native methods, 
    methods written in a language other than the Java programming language. 
    Native method stacks may also be used by the implementation of an 
    interpreter for the Java virtual machine's instruction set in a language 
    such as C. Java virtual machine implementations that cannot load native 
    methods and that do not themselves rely on conventional stacks need not 
    supply native method stacks. If supplied, native method stacks are 
    typically allocated per thread when each thread is created. 

    The Java virtual machine specification permits native method stacks 
    either to be of a fixed size or to dynamically expand and contract as 
    required by the computation. If the native method stacks are of a
    fixed size, the size of each native method stack may be chosen 
    independently when that stack is created. In any case, a Java virtual 
    machine implementation may provide the programmer or the user control 
    over the initial size of the native method stacks. In the case of 
    varying-size native method stacks, it may also make available control 
    over the maximum and minimum method stack sizes.7

    The following exceptional conditions are associated with native method 
    stacks:

        If the computation in a thread requires a larger native method 
        stack than is permitted, the Java virtual machine throws a 
        StackOverflowError. 

        If native method stacks can be dynamically expanded and native method 
        stack expansion is attempted but insufficient memory can be made 
        available, or if insufficient memory can be made available to create 
        the initial native method stack for a new thread, the Java virtual 
        machine throws an OutOfMemoryError. 

        - Godmar

#!/usr/local/bin/perl -w

# this is a lovely hack for recovering from Out Of Memory Errors in jserv

$log='/opt/apache/logs/jserv.log';
$ap='/opt/apache/bin/apachectl';

open(LOG, $log) || die "couldn't open $log: $!\n";

# jump to the end of the log

seek(LOG, 0, 2);
$| = 1;

# recover from log roll-overs by keeping track of the size of the log

$s = -s $log;

while(1){
  while(<LOG>){
    if(/\(ERROR\) ajp11\: Servlet Error\: /){
      next if $' =~ /ClassNotFoundException\:/;
      system("$ap stop") || die $!;
      sleep 1;
      system("$ap start") || die $!;
      sleep 1;
      system("$ap stop") || die $!;
      sleep 1;
      seek(LOG, 0, 2);
      system("$ap start") || die $!;
      my @lt = localtime(time);
      printf("%d/%.2d/%.2d %.2d:%.2d:%.2d $'\n", $lt[5] + 1900, $lt[4] + 1, $lt[3], $lt[2], $lt[1], $lt[0]);
    }
  }
  seek(LOG, 0, 1);
  sleep 1;
  my $s1 = -s $log;
  if(defined($s1)){
    if($s1 < $s){
      close(LOG);
      open(LOG, $log);
    }
    $s = $s1;
  }
}