--- a/ChangeLog	Mon Mar 11 16:31:39 2013 +0000
+++ b/ChangeLog	Mon Mar 11 18:44:23 2013 +0000
@@ -1,3 +1,13 @@
+2013-03-11  Andrew John Hughes  <gnu.andrew@member.fsf.org>
+
+	* Makefile.am:
+	(ICEDTEA_PATCHES): Add new patch.
+	* patches/revert-7017193.patch:
+	Revert 7017193 due to performance issues,
+	adding a free call on error, until a better
+	fix is produced.
+	* NEWS: Updated.
+
 2013-03-11  Andrew John Hughes  <gnu.andrew@member.fsf.org>
 
 	PR1340: Simplify the rewriter, avoiding concurrency.

--- a/Makefile.am	Mon Mar 11 16:31:39 2013 +0000
+++ b/Makefile.am	Mon Mar 11 18:44:23 2013 +0000
@@ -240,7 +240,8 @@
 	patches/8004344-toolkiterrorhandler.patch \
 	patches/8006179-lookup_using_findvirtual.patch \
 	patches/8006882-sun.proxy.patch \
-	patches/pr1303-ifdef_fix.patch
+	patches/pr1303-ifdef_fix.patch \
+	patches/revert-7017193.patch
 
 # Conditional patches
 

--- a/NEWS	Mon Mar 11 16:31:39 2013 +0000
+++ b/NEWS	Mon Mar 11 18:44:23 2013 +0000
@@ -23,6 +23,7 @@
 * Bug fixes
   - PR1303: Correct #ifdef to #if
   - PR1340: Simplify the rhino class rewriter to avoid use of concurrency
+  - Revert 7017193 and add the missing free call, until a better fix is ready.
 
 New in release 2.2.6 (2013-02-20):
 

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/patches/revert-7017193.patch	Mon Mar 11 18:44:23 2013 +0000
@@ -0,0 +1,138 @@
+diff --git a/src/os/linux/vm/os_linux.cpp b/src/os/linux/vm/os_linux.cpp
+--- openjdk/hotspot/src/os/linux/vm/os_linux.cpp
++++ openjdk/hotspot/src/os/linux/vm/os_linux.cpp
+@@ -2763,39 +2763,47 @@
+ // writing thread stacks don't use growable mappings (i.e. those
+ // creeated with MAP_GROWSDOWN), and aren't marked "[stack]", so this
+ // only applies to the main thread.
+-
+-static
+-bool get_stack_bounds(uintptr_t *bottom, uintptr_t *top) {
+-
+-  char buf[128];
+-  int fd, sz;
+-
+-  if ((fd = ::open("/proc/self/maps", O_RDONLY)) < 0) {
++static bool
++get_stack_bounds(uintptr_t *bottom, uintptr_t *top)
++{
++  FILE *f = fopen("/proc/self/maps", "r");
++  if (f == NULL)
+     return false;
+-  }
+-
+-  const char kw[] = "[stack]";
+-  const int kwlen = sizeof(kw)-1;
+-
+-  // Address part of /proc/self/maps couldn't be more than 128 bytes
+-  while ((sz = os::get_line_chars(fd, buf, sizeof(buf))) > 0) {
+-     if (sz > kwlen && ::memcmp(buf+sz-kwlen, kw, kwlen) == 0) {
+-        // Extract addresses
+-        if (sscanf(buf, "%" SCNxPTR "-%" SCNxPTR, bottom, top) == 2) {
+-           uintptr_t sp = (uintptr_t) __builtin_frame_address(0);
+-           if (sp >= *bottom && sp <= *top) {
+-              ::close(fd);
+-              return true;
+-           }
++
++  while (!feof(f)) {
++    size_t dummy;
++    char *str = NULL;
++    ssize_t len = getline(&str, &dummy, f);
++    if (len == -1) {
++      fclose(f);
++      if (str != NULL)
++	free(str);
++      return false;
++    }
++
++    if (len > 0 && str[len-1] == '\n') {
++      str[len-1] = 0;
++      len--;
++    }
++
++    static const char *stack_str = "[stack]";
++    if (len > (ssize_t)strlen(stack_str)
++       && (strcmp(str + len - strlen(stack_str), stack_str) == 0)) {
++      if (sscanf(str, "%" SCNxPTR "-%" SCNxPTR, bottom, top) == 2) {
++        uintptr_t sp = (uintptr_t)__builtin_frame_address(0);
++        if (sp >= *bottom && sp <= *top) {
++          free(str);
++          fclose(f);
++          return true;
+         }
+-     }
+-  }
+-
+- ::close(fd);
++      }
++    }
++    free(str);
++  }
++  fclose(f);
+   return false;
+ }
+ 
+-
+ // If the (growable) stack mapping already extends beyond the point
+ // where we're going to put our guard pages, truncate the mapping at
+ // that point by munmap()ping it.  This ensures that when we later
+diff --git a/src/share/vm/runtime/os.cpp b/src/share/vm/runtime/os.cpp
+--- openjdk/hotspot/src/share/vm/runtime/os.cpp
++++ openjdk/hotspot/src/share/vm/runtime/os.cpp
+@@ -1331,41 +1331,3 @@
+   }
+   return result;
+ }
+-
+-// Read file line by line, if line is longer than bsize,
+-// skip rest of line.
+-int os::get_line_chars(int fd, char* buf, const size_t bsize){
+-  size_t sz, i = 0;
+-
+-  // read until EOF, EOL or buf is full
+-  while ((sz = (int) read(fd, &buf[i], 1)) == 1 && i < (bsize-2) && buf[i] != '\n') {
+-     ++i;
+-  }
+-
+-  if (buf[i] == '\n') {
+-    // EOL reached so ignore EOL character and return
+-
+-    buf[i] = 0;
+-    return (int) i;
+-  }
+-
+-  buf[i+1] = 0;
+-
+-  if (sz != 1) {
+-    // EOF reached. if we read chars before EOF return them and
+-    // return EOF on next call otherwise return EOF
+-
+-    return (i == 0) ? -1 : (int) i;
+-  }
+-
+-  // line is longer than size of buf, skip to EOL
+-  char ch;
+-  while (read(fd, &ch, 1) == 1 && ch != '\n') {
+-    // Do nothing
+-  }
+-
+-  // return initial part of line that fits in buf.
+-  // If we reached EOF, it will be returned on next call.
+-
+-  return (int) i;
+-}
+diff --git a/src/share/vm/runtime/os.hpp b/src/share/vm/runtime/os.hpp
+--- openjdk/hotspot/src/share/vm/runtime/os.hpp
++++ openjdk/hotspot/src/share/vm/runtime/os.hpp
+@@ -672,10 +672,6 @@
+   // Hook for os specific jvm options that we don't want to abort on seeing
+   static bool obsolete_option(const JavaVMOption *option);
+ 
+-  // Read file line by line. If line is longer than bsize,
+-  // rest of line is skipped. Returns number of bytes read or -1 on EOF
+-  static int get_line_chars(int fd, char *buf, const size_t bsize);
+-
+   // Extensions
+ #include "runtime/os_ext.hpp"
+