Merge
diff --git a/.hgtags-top-repo b/.hgtags-top-repo
index 87e09b6..c9493e2 100644
--- a/.hgtags-top-repo
+++ b/.hgtags-top-repo
@@ -130,3 +130,4 @@
28cf2aec4dd7c3c75efc1c15078522467c781a6d jdk8-b06
0db7ae9f2b1017124c779bccd016c976928859a0 jdk8-b07
fb1bc13260d76447e269e843859eb593fe2a8ab2 jdk8-b08
+8adb70647b5af5273dfe6a540f07be667cd50216 jdk8-b09
diff --git a/corba/.hgtags b/corba/.hgtags
index 4811bf0..1706e28 100644
--- a/corba/.hgtags
+++ b/corba/.hgtags
@@ -130,3 +130,4 @@
45c43dde7ba7f176333a51a98f086275478836fa jdk8-b06
3d61f0856f349e2163bf98146465dab3b7437f63 jdk8-b07
0d52b1c87aa8fdea7fdc9c4126ea58f95ca6b351 jdk8-b08
+a891732c1a83082177ff7a4cf1506068d9cc0a47 jdk8-b09
diff --git a/hotspot/.hgtags b/hotspot/.hgtags
index 59a86b1..79a147e 100644
--- a/hotspot/.hgtags
+++ b/hotspot/.hgtags
@@ -181,7 +181,7 @@
dce7d24674f4d0bed00de24f00119057fdce7cfb jdk8-b05
0db80d8e77fccddf5e6fa49963226b54ac7d0f62 jdk8-b06
3f0cf875af83f55ec5e1a5cea80455315f9322a2 jdk8-b07
-3a2fb61165dfc72e6de2adab1f2649a408f5e577 hs22-b01
+0cc8a70952c368e06de2adab1f2649a408f5e577 hs22-b01
7c29742c41b44fb0cd5a13c7ac8834f3f2ca649e hs22-b02
3a2fb61165dfc72e398179a2796d740c8da5b8c0 hs22-b03
ce9bde819dcba4a5d2822229d9183e69c74326ca hs22-b04
@@ -189,3 +189,5 @@
650d15d8f37255d3b805aa00c5bd1c30984b203d hs22-b06
da883b9e6d3788057f9577e72712998ed82c9b7e hs23-b01
49ed7eacfd16616166ff066493143889741097af jdk8-b08
+7c20d272643f47195478708eff593a9cce40fec4 jdk8-b09
+e4f412d2b75d2c797acff965aa2c420e3d358f09 hs23-b02
diff --git a/hotspot/agent/make/Makefile b/hotspot/agent/make/Makefile
index 981d2c8..fd54993 100644
--- a/hotspot/agent/make/Makefile
+++ b/hotspot/agent/make/Makefile
@@ -1,5 +1,5 @@
#
-# Copyright (c) 2000, 2008, Oracle and/or its affiliates. All rights reserved.
+# Copyright (c) 2000, 2011, Oracle and/or its affiliates. All rights reserved.
# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
#
# This code is free software; you can redistribute it and/or modify it
@@ -84,6 +84,7 @@
sun.jvm.hotspot.debugger.windbg.x86 \
sun.jvm.hotspot.debugger.x86 \
sun.jvm.hotspot.gc_implementation \
+sun.jvm.hotspot.gc_implementation.g1 \
sun.jvm.hotspot.gc_implementation.parallelScavenge \
sun.jvm.hotspot.gc_implementation.shared \
sun.jvm.hotspot.gc_interface \
@@ -176,6 +177,9 @@
sun/jvm/hotspot/debugger/windbg/ia64/*.java \
sun/jvm/hotspot/debugger/windbg/x86/*.java \
sun/jvm/hotspot/debugger/x86/*.java \
+sun/jvm/hotspot/gc_implementation/g1/*.java \
+sun/jvm/hotspot/gc_implementation/parallelScavenge/*.java \
+sun/jvm/hotspot/gc_implementation/shared/*.java \
sun/jvm/hotspot/interpreter/*.java \
sun/jvm/hotspot/jdi/*.java \
sun/jvm/hotspot/livejvm/*.java \
diff --git a/hotspot/agent/src/share/classes/sun/jvm/hotspot/gc_implementation/g1/G1CollectedHeap.java b/hotspot/agent/src/share/classes/sun/jvm/hotspot/gc_implementation/g1/G1CollectedHeap.java
new file mode 100644
index 0000000..502d8e4
--- /dev/null
+++ b/hotspot/agent/src/share/classes/sun/jvm/hotspot/gc_implementation/g1/G1CollectedHeap.java
@@ -0,0 +1,116 @@
+/*
+ * Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ *
+ */
+
+package sun.jvm.hotspot.gc_implementation.g1;
+
+import java.util.Iterator;
+import java.util.Observable;
+import java.util.Observer;
+
+import sun.jvm.hotspot.debugger.Address;
+import sun.jvm.hotspot.gc_interface.CollectedHeapName;
+import sun.jvm.hotspot.memory.MemRegion;
+import sun.jvm.hotspot.memory.SharedHeap;
+import sun.jvm.hotspot.memory.SpaceClosure;
+import sun.jvm.hotspot.runtime.VM;
+import sun.jvm.hotspot.runtime.VMObjectFactory;
+import sun.jvm.hotspot.types.AddressField;
+import sun.jvm.hotspot.types.CIntegerField;
+import sun.jvm.hotspot.types.Type;
+import sun.jvm.hotspot.types.TypeDataBase;
+
+// Mirror class for G1CollectedHeap.
+
+public class G1CollectedHeap extends SharedHeap {
+ // HeapRegionSeq _seq;
+ static private long hrsFieldOffset;
+ // MemRegion _g1_committed;
+ static private long g1CommittedFieldOffset;
+ // size_t _summary_bytes_used;
+ static private CIntegerField summaryBytesUsedField;
+ // G1MonitoringSupport* _g1mm
+ static private AddressField g1mmField;
+
+ static {
+ VM.registerVMInitializedObserver(new Observer() {
+ public void update(Observable o, Object data) {
+ initialize(VM.getVM().getTypeDataBase());
+ }
+ });
+ }
+
+ static private synchronized void initialize(TypeDataBase db) {
+ Type type = db.lookupType("G1CollectedHeap");
+
+ hrsFieldOffset = type.getField("_hrs").getOffset();
+ g1CommittedFieldOffset = type.getField("_g1_committed").getOffset();
+ summaryBytesUsedField = type.getCIntegerField("_summary_bytes_used");
+ g1mmField = type.getAddressField("_g1mm");
+ }
+
+ public long capacity() {
+ Address g1CommittedAddr = addr.addOffsetTo(g1CommittedFieldOffset);
+ MemRegion g1_committed = new MemRegion(g1CommittedAddr);
+ return g1_committed.byteSize();
+ }
+
+ public long used() {
+ return summaryBytesUsedField.getValue(addr);
+ }
+
+ public long n_regions() {
+ return hrs().length();
+ }
+
+ private HeapRegionSeq hrs() {
+ Address hrsAddr = addr.addOffsetTo(hrsFieldOffset);
+ return (HeapRegionSeq) VMObjectFactory.newObject(HeapRegionSeq.class,
+ hrsAddr);
+ }
+
+ public G1MonitoringSupport g1mm() {
+ Address g1mmAddr = g1mmField.getValue(addr);
+ return (G1MonitoringSupport) VMObjectFactory.newObject(G1MonitoringSupport.class, g1mmAddr);
+ }
+
+ private Iterator<HeapRegion> heapRegionIterator() {
+ return hrs().heapRegionIterator();
+ }
+
+ public void heapRegionIterate(SpaceClosure scl) {
+ Iterator<HeapRegion> iter = heapRegionIterator();
+ while (iter.hasNext()) {
+ HeapRegion hr = iter.next();
+ scl.doSpace(hr);
+ }
+ }
+
+ public CollectedHeapName kind() {
+ return CollectedHeapName.G1_COLLECTED_HEAP;
+ }
+
+ public G1CollectedHeap(Address addr) {
+ super(addr);
+ }
+}
diff --git a/hotspot/agent/src/share/classes/sun/jvm/hotspot/gc_implementation/g1/G1MonitoringSupport.java b/hotspot/agent/src/share/classes/sun/jvm/hotspot/gc_implementation/g1/G1MonitoringSupport.java
new file mode 100644
index 0000000..7b03aed
--- /dev/null
+++ b/hotspot/agent/src/share/classes/sun/jvm/hotspot/gc_implementation/g1/G1MonitoringSupport.java
@@ -0,0 +1,99 @@
+/*
+ * Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ *
+ */
+
+package sun.jvm.hotspot.gc_implementation.g1;
+
+import java.util.Observable;
+import java.util.Observer;
+
+import sun.jvm.hotspot.debugger.Address;
+import sun.jvm.hotspot.runtime.VM;
+import sun.jvm.hotspot.runtime.VMObject;
+import sun.jvm.hotspot.types.CIntegerField;
+import sun.jvm.hotspot.types.Type;
+import sun.jvm.hotspot.types.TypeDataBase;
+
+// Mirror class for G1MonitoringSupport.
+
+public class G1MonitoringSupport extends VMObject {
+ // size_t _eden_committed;
+ static private CIntegerField edenCommittedField;
+ // size_t _eden_used;
+ static private CIntegerField edenUsedField;
+ // size_t _survivor_committed;
+ static private CIntegerField survivorCommittedField;
+ // size_t _survivor_used;
+ static private CIntegerField survivorUsedField;
+ // size_t _old_committed;
+ static private CIntegerField oldCommittedField;
+ // size_t _old_used;
+ static private CIntegerField oldUsedField;
+
+ static {
+ VM.registerVMInitializedObserver(new Observer() {
+ public void update(Observable o, Object data) {
+ initialize(VM.getVM().getTypeDataBase());
+ }
+ });
+ }
+
+ static private synchronized void initialize(TypeDataBase db) {
+ Type type = db.lookupType("G1MonitoringSupport");
+
+ edenCommittedField = type.getCIntegerField("_eden_committed");
+ edenUsedField = type.getCIntegerField("_eden_used");
+ survivorCommittedField = type.getCIntegerField("_survivor_committed");
+ survivorUsedField = type.getCIntegerField("_survivor_used");
+ oldCommittedField = type.getCIntegerField("_old_committed");
+ oldUsedField = type.getCIntegerField("_old_used");
+ }
+
+ public long edenCommitted() {
+ return edenCommittedField.getValue(addr);
+ }
+
+ public long edenUsed() {
+ return edenUsedField.getValue(addr);
+ }
+
+ public long survivorCommitted() {
+ return survivorCommittedField.getValue(addr);
+ }
+
+ public long survivorUsed() {
+ return survivorUsedField.getValue(addr);
+ }
+
+ public long oldCommitted() {
+ return oldCommittedField.getValue(addr);
+ }
+
+ public long oldUsed() {
+ return oldUsedField.getValue(addr);
+ }
+
+ public G1MonitoringSupport(Address addr) {
+ super(addr);
+ }
+}
diff --git a/hotspot/agent/src/share/classes/sun/jvm/hotspot/gc_implementation/g1/HeapRegion.java b/hotspot/agent/src/share/classes/sun/jvm/hotspot/gc_implementation/g1/HeapRegion.java
new file mode 100644
index 0000000..4aa7620
--- /dev/null
+++ b/hotspot/agent/src/share/classes/sun/jvm/hotspot/gc_implementation/g1/HeapRegion.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ *
+ */
+
+package sun.jvm.hotspot.gc_implementation.g1;
+
+import java.util.Observable;
+import java.util.Observer;
+
+import sun.jvm.hotspot.debugger.Address;
+import sun.jvm.hotspot.memory.ContiguousSpace;
+import sun.jvm.hotspot.runtime.VM;
+import sun.jvm.hotspot.types.CIntegerField;
+import sun.jvm.hotspot.types.Type;
+import sun.jvm.hotspot.types.TypeDataBase;
+
+// Mirror class for HeapRegion. Currently we don't actually include
+// any of its fields but only iterate over it (which we get "for free"
+// as HeapRegion ultimately inherits from ContiguousSpace).
+
+public class HeapRegion extends ContiguousSpace {
+ // static int GrainBytes;
+ static private CIntegerField grainBytesField;
+
+ static {
+ VM.registerVMInitializedObserver(new Observer() {
+ public void update(Observable o, Object data) {
+ initialize(VM.getVM().getTypeDataBase());
+ }
+ });
+ }
+
+ static private synchronized void initialize(TypeDataBase db) {
+ Type type = db.lookupType("HeapRegion");
+
+ grainBytesField = type.getCIntegerField("GrainBytes");
+ }
+
+ static public long grainBytes() {
+ return grainBytesField.getValue();
+ }
+
+ public HeapRegion(Address addr) {
+ super(addr);
+ }
+}
diff --git a/hotspot/agent/src/share/classes/sun/jvm/hotspot/gc_implementation/g1/HeapRegionSeq.java b/hotspot/agent/src/share/classes/sun/jvm/hotspot/gc_implementation/g1/HeapRegionSeq.java
new file mode 100644
index 0000000..d0da28b
--- /dev/null
+++ b/hotspot/agent/src/share/classes/sun/jvm/hotspot/gc_implementation/g1/HeapRegionSeq.java
@@ -0,0 +1,102 @@
+/*
+ * Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ *
+ */
+
+package sun.jvm.hotspot.gc_implementation.g1;
+
+import java.util.Iterator;
+import java.util.Observable;
+import java.util.Observer;
+
+import sun.jvm.hotspot.debugger.Address;
+import sun.jvm.hotspot.runtime.VM;
+import sun.jvm.hotspot.runtime.VMObject;
+import sun.jvm.hotspot.runtime.VMObjectFactory;
+import sun.jvm.hotspot.types.AddressField;
+import sun.jvm.hotspot.types.CIntegerField;
+import sun.jvm.hotspot.types.Type;
+import sun.jvm.hotspot.types.TypeDataBase;
+
+// Mirror class for HeapRegionSeq. It's essentially an index -> HeapRegion map.
+
+public class HeapRegionSeq extends VMObject {
+ // HeapRegion** _regions;
+ static private AddressField regionsField;
+ // size_t _length;
+ static private CIntegerField lengthField;
+
+ static {
+ VM.registerVMInitializedObserver(new Observer() {
+ public void update(Observable o, Object data) {
+ initialize(VM.getVM().getTypeDataBase());
+ }
+ });
+ }
+
+ static private synchronized void initialize(TypeDataBase db) {
+ Type type = db.lookupType("HeapRegionSeq");
+
+ regionsField = type.getAddressField("_regions");
+ lengthField = type.getCIntegerField("_length");
+ }
+
+ private HeapRegion at(long index) {
+ Address arrayAddr = regionsField.getValue(addr);
+ // Offset of &_region[index]
+ long offset = index * VM.getVM().getAddressSize();
+ Address regionAddr = arrayAddr.getAddressAt(offset);
+ return (HeapRegion) VMObjectFactory.newObject(HeapRegion.class,
+ regionAddr);
+ }
+
+ public long length() {
+ return lengthField.getValue(addr);
+ }
+
+ private class HeapRegionIterator implements Iterator<HeapRegion> {
+ private long index;
+ private long length;
+
+ @Override
+ public boolean hasNext() { return index < length; }
+
+ @Override
+ public HeapRegion next() { return at(index++); }
+
+ @Override
+ public void remove() { /* not supported */ }
+
+ HeapRegionIterator(Address addr) {
+ index = 0;
+ length = length();
+ }
+ }
+
+ public Iterator<HeapRegion> heapRegionIterator() {
+ return new HeapRegionIterator(addr);
+ }
+
+ public HeapRegionSeq(Address addr) {
+ super(addr);
+ }
+}
diff --git a/hotspot/agent/src/share/classes/sun/jvm/hotspot/gc_interface/CollectedHeapName.java b/hotspot/agent/src/share/classes/sun/jvm/hotspot/gc_interface/CollectedHeapName.java
index 1561a25..2e57740 100644
--- a/hotspot/agent/src/share/classes/sun/jvm/hotspot/gc_interface/CollectedHeapName.java
+++ b/hotspot/agent/src/share/classes/sun/jvm/hotspot/gc_interface/CollectedHeapName.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2000, 2003, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2000, 2011, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -34,6 +34,7 @@
public static final CollectedHeapName ABSTRACT = new CollectedHeapName("abstract");
public static final CollectedHeapName SHARED_HEAP = new CollectedHeapName("SharedHeap");
public static final CollectedHeapName GEN_COLLECTED_HEAP = new CollectedHeapName("GenCollectedHeap");
+ public static final CollectedHeapName G1_COLLECTED_HEAP = new CollectedHeapName("G1CollectedHeap");
public static final CollectedHeapName PARALLEL_SCAVENGE_HEAP = new CollectedHeapName("ParallelScavengeHeap");
public String toString() {
diff --git a/hotspot/agent/src/share/classes/sun/jvm/hotspot/memory/Universe.java b/hotspot/agent/src/share/classes/sun/jvm/hotspot/memory/Universe.java
index c25f7c7..41f45a5 100644
--- a/hotspot/agent/src/share/classes/sun/jvm/hotspot/memory/Universe.java
+++ b/hotspot/agent/src/share/classes/sun/jvm/hotspot/memory/Universe.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2000, 2009, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2000, 2011, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -28,6 +28,7 @@
import java.util.*;
import sun.jvm.hotspot.debugger.*;
import sun.jvm.hotspot.gc_interface.*;
+import sun.jvm.hotspot.gc_implementation.g1.G1CollectedHeap;
import sun.jvm.hotspot.gc_implementation.parallelScavenge.*;
import sun.jvm.hotspot.oops.*;
import sun.jvm.hotspot.types.*;
@@ -72,6 +73,7 @@
heapConstructor = new VirtualConstructor(db);
heapConstructor.addMapping("GenCollectedHeap", GenCollectedHeap.class);
heapConstructor.addMapping("ParallelScavengeHeap", ParallelScavengeHeap.class);
+ heapConstructor.addMapping("G1CollectedHeap", G1CollectedHeap.class);
mainThreadGroupField = type.getOopField("_main_thread_group");
systemThreadGroupField = type.getOopField("_system_thread_group");
diff --git a/hotspot/agent/src/share/classes/sun/jvm/hotspot/oops/ObjectHeap.java b/hotspot/agent/src/share/classes/sun/jvm/hotspot/oops/ObjectHeap.java
index 749c49d..961e167 100644
--- a/hotspot/agent/src/share/classes/sun/jvm/hotspot/oops/ObjectHeap.java
+++ b/hotspot/agent/src/share/classes/sun/jvm/hotspot/oops/ObjectHeap.java
@@ -33,6 +33,7 @@
import sun.jvm.hotspot.debugger.*;
import sun.jvm.hotspot.gc_interface.*;
+import sun.jvm.hotspot.gc_implementation.g1.*;
import sun.jvm.hotspot.gc_implementation.parallelScavenge.*;
import sun.jvm.hotspot.memory.*;
import sun.jvm.hotspot.runtime.*;
@@ -514,9 +515,16 @@
private void addPermGenLiveRegions(List output, CollectedHeap heap) {
LiveRegionsCollector lrc = new LiveRegionsCollector(output);
- if (heap instanceof GenCollectedHeap) {
- GenCollectedHeap genHeap = (GenCollectedHeap) heap;
- Generation gen = genHeap.permGen();
+ if (heap instanceof SharedHeap) {
+ if (Assert.ASSERTS_ENABLED) {
+ Assert.that(heap instanceof GenCollectedHeap ||
+ heap instanceof G1CollectedHeap,
+ "Expecting GenCollectedHeap or G1CollectedHeap, " +
+ "but got " + heap.getClass().getName());
+ }
+ // Handles both GenCollectedHeap and G1CollectedHeap
+ SharedHeap sharedHeap = (SharedHeap) heap;
+ Generation gen = sharedHeap.permGen();
gen.spaceIterate(lrc, true);
} else if (heap instanceof ParallelScavengeHeap) {
ParallelScavengeHeap psh = (ParallelScavengeHeap) heap;
@@ -524,8 +532,9 @@
addLiveRegions(permGen.objectSpace().getLiveRegions(), output);
} else {
if (Assert.ASSERTS_ENABLED) {
- Assert.that(false, "Expecting GenCollectedHeap or ParallelScavengeHeap, but got " +
- heap.getClass().getName());
+ Assert.that(false,
+ "Expecting SharedHeap or ParallelScavengeHeap, " +
+ "but got " + heap.getClass().getName());
}
}
}
@@ -588,10 +597,14 @@
addLiveRegions(youngGen.fromSpace().getLiveRegions(), liveRegions);
PSOldGen oldGen = psh.oldGen();
addLiveRegions(oldGen.objectSpace().getLiveRegions(), liveRegions);
+ } else if (heap instanceof G1CollectedHeap) {
+ G1CollectedHeap g1h = (G1CollectedHeap) heap;
+ g1h.heapRegionIterate(lrc);
} else {
if (Assert.ASSERTS_ENABLED) {
- Assert.that(false, "Expecting GenCollectedHeap or ParallelScavengeHeap, but got " +
- heap.getClass().getName());
+ Assert.that(false, "Expecting GenCollectedHeap, G1CollectedHeap, " +
+ "or ParallelScavengeHeap, but got " +
+ heap.getClass().getName());
}
}
diff --git a/hotspot/agent/src/share/classes/sun/jvm/hotspot/tools/HeapSummary.java b/hotspot/agent/src/share/classes/sun/jvm/hotspot/tools/HeapSummary.java
index 3e2cfa3..bbeab88 100644
--- a/hotspot/agent/src/share/classes/sun/jvm/hotspot/tools/HeapSummary.java
+++ b/hotspot/agent/src/share/classes/sun/jvm/hotspot/tools/HeapSummary.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2003, 2008, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2003, 2011, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -26,11 +26,11 @@
import java.util.*;
import sun.jvm.hotspot.gc_interface.*;
+import sun.jvm.hotspot.gc_implementation.g1.*;
import sun.jvm.hotspot.gc_implementation.parallelScavenge.*;
import sun.jvm.hotspot.gc_implementation.shared.*;
import sun.jvm.hotspot.memory.*;
import sun.jvm.hotspot.runtime.*;
-import sun.jvm.hotspot.tools.*;
public class HeapSummary extends Tool {
@@ -70,32 +70,45 @@
System.out.println();
System.out.println("Heap Usage:");
- if (heap instanceof GenCollectedHeap) {
- GenCollectedHeap genHeap = (GenCollectedHeap) heap;
- for (int n = 0; n < genHeap.nGens(); n++) {
- Generation gen = genHeap.getGen(n);
- if (gen instanceof sun.jvm.hotspot.memory.DefNewGeneration) {
- System.out.println("New Generation (Eden + 1 Survivor Space):");
- printGen(gen);
+ if (heap instanceof SharedHeap) {
+ SharedHeap sharedHeap = (SharedHeap) heap;
+ if (sharedHeap instanceof GenCollectedHeap) {
+ GenCollectedHeap genHeap = (GenCollectedHeap) sharedHeap;
+ for (int n = 0; n < genHeap.nGens(); n++) {
+ Generation gen = genHeap.getGen(n);
+ if (gen instanceof sun.jvm.hotspot.memory.DefNewGeneration) {
+ System.out.println("New Generation (Eden + 1 Survivor Space):");
+ printGen(gen);
- ContiguousSpace eden = ((DefNewGeneration)gen).eden();
- System.out.println("Eden Space:");
- printSpace(eden);
+ ContiguousSpace eden = ((DefNewGeneration)gen).eden();
+ System.out.println("Eden Space:");
+ printSpace(eden);
- ContiguousSpace from = ((DefNewGeneration)gen).from();
- System.out.println("From Space:");
- printSpace(from);
+ ContiguousSpace from = ((DefNewGeneration)gen).from();
+ System.out.println("From Space:");
+ printSpace(from);
- ContiguousSpace to = ((DefNewGeneration)gen).to();
- System.out.println("To Space:");
- printSpace(to);
- } else {
- System.out.println(gen.name() + ":");
- printGen(gen);
+ ContiguousSpace to = ((DefNewGeneration)gen).to();
+ System.out.println("To Space:");
+ printSpace(to);
+ } else {
+ System.out.println(gen.name() + ":");
+ printGen(gen);
+ }
}
+ } else if (sharedHeap instanceof G1CollectedHeap) {
+ G1CollectedHeap g1h = (G1CollectedHeap) sharedHeap;
+ G1MonitoringSupport g1mm = g1h.g1mm();
+ System.out.println("G1 Young Generation");
+ printG1Space("Eden Space:", g1mm.edenUsed(), g1mm.edenCommitted());
+ printG1Space("From Space:", g1mm.survivorUsed(), g1mm.survivorCommitted());
+ printG1Space("To Space:", 0, 0);
+ printG1Space("G1 Old Generation", g1mm.oldUsed(), g1mm.oldCommitted());
+ } else {
+ throw new RuntimeException("unknown SharedHeap type : " + heap.getClass());
}
- // Perm generation
- Generation permGen = genHeap.permGen();
+ // Perm generation shared by the above
+ Generation permGen = sharedHeap.permGen();
System.out.println("Perm Generation:");
printGen(permGen);
} else if (heap instanceof ParallelScavengeHeap) {
@@ -119,7 +132,7 @@
printValMB("free = ", permFree);
System.out.println(alignment + (double)permGen.used() * 100.0 / permGen.capacity() + "% used");
} else {
- throw new RuntimeException("unknown heap type : " + heap.getClass());
+ throw new RuntimeException("unknown CollectedHeap type : " + heap.getClass());
}
}
@@ -151,6 +164,14 @@
return;
}
+ l = getFlagValue("UseG1GC", flagMap);
+ if (l == 1L) {
+ System.out.print("Garbage-First (G1) GC ");
+ l = getFlagValue("ParallelGCThreads", flagMap);
+ System.out.println("with " + l + " thread(s)");
+ return;
+ }
+
System.out.println("Mark Sweep Compact GC");
}
@@ -191,6 +212,16 @@
System.out.println(alignment + (double)space.used() * 100.0 / space.capacity() + "% used");
}
+ private void printG1Space(String spaceName, long used, long capacity) {
+ long free = capacity - used;
+ System.out.println(spaceName);
+ printValMB("capacity = ", capacity);
+ printValMB("used = ", used);
+ printValMB("free = ", free);
+ double occPerc = (capacity > 0) ? (double) used * 100.0 / capacity : 0.0;
+ System.out.println(alignment + occPerc + "% used");
+ }
+
private static final double FACTOR = 1024*1024;
private void printValMB(String title, long value) {
if (value < 0) {
diff --git a/hotspot/make/hotspot_version b/hotspot/make/hotspot_version
index f5de8cd..086043d 100644
--- a/hotspot/make/hotspot_version
+++ b/hotspot/make/hotspot_version
@@ -35,7 +35,7 @@
HS_MAJOR_VER=23
HS_MINOR_VER=0
-HS_BUILD_NUMBER=01
+HS_BUILD_NUMBER=02
JDK_MAJOR_VER=1
JDK_MINOR_VER=8
diff --git a/hotspot/make/sa.files b/hotspot/make/sa.files
index 4836c96..c634590 100644
--- a/hotspot/make/sa.files
+++ b/hotspot/make/sa.files
@@ -1,5 +1,5 @@
#
-# Copyright (c) 2003, 2008, Oracle and/or its affiliates. All rights reserved.
+# Copyright (c) 2003, 2011, Oracle and/or its affiliates. All rights reserved.
# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
#
# This code is free software; you can redistribute it and/or modify it
@@ -82,6 +82,7 @@
$(AGENT_SRC_DIR)/sun/jvm/hotspot/debugger/windbg/ia64/*.java \
$(AGENT_SRC_DIR)/sun/jvm/hotspot/debugger/windbg/x86/*.java \
$(AGENT_SRC_DIR)/sun/jvm/hotspot/debugger/x86/*.java \
+$(AGENT_SRC_DIR)/sun/jvm/hotspot/gc_implementation/g1/*.java \
$(AGENT_SRC_DIR)/sun/jvm/hotspot/gc_implementation/parallelScavenge/*.java \
$(AGENT_SRC_DIR)/sun/jvm/hotspot/gc_implementation/shared/*.java \
$(AGENT_SRC_DIR)/sun/jvm/hotspot/gc_interface/*.java \
diff --git a/hotspot/src/os/posix/launcher/launcher.script b/hotspot/src/os/posix/launcher/launcher.script
index 21bf44e..c4db5a4 100644
--- a/hotspot/src/os/posix/launcher/launcher.script
+++ b/hotspot/src/os/posix/launcher/launcher.script
@@ -1,6 +1,6 @@
#!/bin/sh
-# Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved.
+# Copyright (c) 2010, 2011, Oracle and/or its affiliates. All rights reserved.
# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
#
# This code is free software; you can redistribute it and/or modify it
@@ -69,8 +69,8 @@
#
# Make sure the paths are fully specified, i.e. they must begin with /.
-SCRIPT=$(cd $(dirname $0) && pwd)/$(basename $0)
-RUNDIR=$(pwd)
+REL_MYDIR=`dirname $0`
+MYDIR=`cd $REL_MYDIR && pwd`
# Look whether the user wants to run inside gdb
case "$1" in
@@ -95,12 +95,9 @@
;;
esac
-# Find out the absolute path to this script
-MYDIR=$(cd $(dirname $SCRIPT) && pwd)
-
JDK=
if [ "${ALT_JAVA_HOME}" = "" ]; then
- source ${MYDIR}/jdkpath.sh
+ . ${MYDIR}/jdkpath.sh
else
JDK=${ALT_JAVA_HOME%%/jre};
fi
@@ -119,9 +116,6 @@
JAVA_HOME=$JDK
ARCH=@@LIBARCH@@
-# Find out the absolute path to this script
-MYDIR=$(cd $(dirname $SCRIPT) && pwd)
-
SBP=${MYDIR}:${JRE}/lib/${ARCH}
# Set up a suitable LD_LIBRARY_PATH
@@ -146,7 +140,7 @@
fi
GDBSRCDIR=$MYDIR
-BASEDIR=$(cd $MYDIR/../../.. && pwd)
+BASEDIR=`cd $MYDIR/../../.. && pwd`
init_gdb() {
# Create a gdb script in case we should run inside gdb
@@ -179,7 +173,7 @@
init_gdb
# First find out what emacs version we're using, so that we can
# use the new pretty GDB mode if emacs -version >= 22.1
- case $($EMACS -version 2> /dev/null) in
+ case `$EMACS -version 2> /dev/null` in
*GNU\ Emacs\ 2[23]*)
emacs_gud_cmd="gdba"
emacs_gud_args="--annotate=3"
diff --git a/hotspot/src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp b/hotspot/src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp
index c5bd4ca..54bbb24b 100644
--- a/hotspot/src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp
+++ b/hotspot/src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp
@@ -2004,7 +2004,7 @@
ReferenceProcessorMTDiscoveryMutator rp_mut_discovery(ref_processor(), false);
ref_processor()->set_enqueuing_is_done(false);
- ref_processor()->enable_discovery();
+ ref_processor()->enable_discovery(false /*verify_disabled*/, false /*check_no_refs*/);
ref_processor()->setup_policy(clear_all_soft_refs);
// If an asynchronous collection finishes, the _modUnionTable is
// all clear. If we are assuming the collection from an asynchronous
@@ -3490,8 +3490,8 @@
MutexLockerEx x(bitMapLock(),
Mutex::_no_safepoint_check_flag);
checkpointRootsInitialWork(asynch);
- rp->verify_no_references_recorded();
- rp->enable_discovery(); // enable ("weak") refs discovery
+ // enable ("weak") refs discovery
+ rp->enable_discovery(true /*verify_disabled*/, true /*check_no_refs*/);
_collectorState = Marking;
} else {
// (Weak) Refs discovery: this is controlled from genCollectedHeap::do_collection
@@ -3503,7 +3503,8 @@
"ref discovery for this generation kind");
// already have locks
checkpointRootsInitialWork(asynch);
- rp->enable_discovery(); // now enable ("weak") refs discovery
+ // now enable ("weak") refs discovery
+ rp->enable_discovery(true /*verify_disabled*/, false /*verify_no_refs*/);
_collectorState = Marking;
}
SpecializationStats::print();
diff --git a/hotspot/src/share/vm/gc_implementation/g1/collectionSetChooser.cpp b/hotspot/src/share/vm/gc_implementation/g1/collectionSetChooser.cpp
index 73d578d..0b78565 100644
--- a/hotspot/src/share/vm/gc_implementation/g1/collectionSetChooser.cpp
+++ b/hotspot/src/share/vm/gc_implementation/g1/collectionSetChooser.cpp
@@ -118,30 +118,6 @@
}
}
-// this is a bit expensive... but we expect that it should not be called
-// to often.
-void CSetChooserCache::remove(HeapRegion *hr) {
- assert(_occupancy > 0, "cache should not be empty");
- assert(hr->sort_index() < -1, "should already be in the cache");
- int index = get_index(hr->sort_index());
- assert(_cache[index] == hr, "index should be correct");
- int next_index = trim_index(index + 1);
- int last_index = trim_index(_first + _occupancy - 1);
- while (index != last_index) {
- assert(_cache[next_index] != NULL, "should not be null");
- _cache[index] = _cache[next_index];
- _cache[index]->set_sort_index(get_sort_index(index));
-
- index = next_index;
- next_index = trim_index(next_index+1);
- }
- assert(index == last_index, "should have reached the last one");
- _cache[index] = NULL;
- hr->set_sort_index(-1);
- --_occupancy;
- assert(verify(), "cache should be consistent");
-}
-
static inline int orderRegions(HeapRegion* hr1, HeapRegion* hr2) {
if (hr1 == NULL) {
if (hr2 == NULL) return 0;
@@ -197,43 +173,34 @@
HeapRegion *prev = NULL;
while (index < _numMarkedRegions) {
HeapRegion *curr = _markedRegions.at(index++);
- if (curr != NULL) {
- int si = curr->sort_index();
- guarantee(!curr->is_young(), "should not be young!");
- guarantee(si > -1 && si == (index-1), "sort index invariant");
- if (prev != NULL) {
- guarantee(orderRegions(prev, curr) != 1, "regions should be sorted");
- }
- prev = curr;
+ guarantee(curr != NULL, "Regions in _markedRegions array cannot be NULL");
+ int si = curr->sort_index();
+ guarantee(!curr->is_young(), "should not be young!");
+ guarantee(si > -1 && si == (index-1), "sort index invariant");
+ if (prev != NULL) {
+ guarantee(orderRegions(prev, curr) != 1, "regions should be sorted");
}
+ prev = curr;
}
return _cache.verify();
}
#endif
-bool
-CollectionSetChooser::addRegionToCache() {
- assert(!_cache.is_full(), "cache should not be full");
-
- HeapRegion *hr = NULL;
- while (hr == NULL && _curMarkedIndex < _numMarkedRegions) {
- hr = _markedRegions.at(_curMarkedIndex++);
- }
- if (hr == NULL)
- return false;
- assert(!hr->is_young(), "should not be young!");
- assert(hr->sort_index() == _curMarkedIndex-1, "sort_index invariant");
- _markedRegions.at_put(hr->sort_index(), NULL);
- _cache.insert(hr);
- assert(!_cache.is_empty(), "cache should not be empty");
- assert(verify(), "cache should be consistent");
- return false;
-}
-
void
CollectionSetChooser::fillCache() {
- while (!_cache.is_full() && addRegionToCache()) {
+ while (!_cache.is_full() && (_curMarkedIndex < _numMarkedRegions)) {
+ HeapRegion* hr = _markedRegions.at(_curMarkedIndex);
+ assert(hr != NULL,
+ err_msg("Unexpected NULL hr in _markedRegions at index %d",
+ _curMarkedIndex));
+ _curMarkedIndex += 1;
+ assert(!hr->is_young(), "should not be young!");
+ assert(hr->sort_index() == _curMarkedIndex-1, "sort_index invariant");
+ _markedRegions.at_put(hr->sort_index(), NULL);
+ _cache.insert(hr);
+ assert(!_cache.is_empty(), "cache should not be empty");
}
+ assert(verify(), "cache should be consistent");
}
void
@@ -334,20 +301,6 @@
clearMarkedHeapRegions();
}
-void CollectionSetChooser::removeRegion(HeapRegion *hr) {
- int si = hr->sort_index();
- assert(si == -1 || hr->is_marked(), "Sort index not valid.");
- if (si > -1) {
- assert(_markedRegions.at(si) == hr, "Sort index not valid." );
- _markedRegions.at_put(si, NULL);
- } else if (si < -1) {
- assert(_cache.region_in_cache(hr), "should be in the cache");
- _cache.remove(hr);
- assert(hr->sort_index() == -1, "sort index invariant");
- }
- hr->set_sort_index(-1);
-}
-
// if time_remaining < 0.0, then this method should try to return
// a region, whether it fits within the remaining time or not
HeapRegion*
diff --git a/hotspot/src/share/vm/gc_implementation/g1/collectionSetChooser.hpp b/hotspot/src/share/vm/gc_implementation/g1/collectionSetChooser.hpp
index c8e2233..ff4bca9 100644
--- a/hotspot/src/share/vm/gc_implementation/g1/collectionSetChooser.hpp
+++ b/hotspot/src/share/vm/gc_implementation/g1/collectionSetChooser.hpp
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2001, 2010, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2001, 2011, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -29,6 +29,26 @@
#include "utilities/growableArray.hpp"
// We need to sort heap regions by collection desirability.
+// This sorting is currently done in two "stages". An initial sort is
+// done following a cleanup pause as soon as all of the marked but
+// non-empty regions have been identified and the completely empty
+// ones reclaimed.
+// This gives us a global sort on a GC efficiency metric
+// based on predictive data available at that time. However,
+// any of these regions that are collected will only be collected
+// during a future GC pause, by which time it is possible that newer
+// data might allow us to revise and/or refine the earlier
+// pause predictions, leading to changes in expected gc efficiency
+// order. To somewhat mitigate this obsolescence, more so in the
+// case of regions towards the end of the list, which will be
+// picked later, these pre-sorted regions from the _markedRegions
+// array are not used as is, but a small prefix thereof is
+// insertion-sorted again into a small cache, based on more
+// recent remembered set information. Regions are then drawn
+// from this cache to construct the collection set at each
+// incremental GC.
+// This scheme and/or its implementation may be subject to
+// revision in the future.
class CSetChooserCache VALUE_OBJ_CLASS_SPEC {
private:
@@ -37,8 +57,8 @@
} PrivateConstants;
HeapRegion* _cache[CacheLength];
- int _occupancy; // number of region in cache
- int _first; // "first" region in the cache
+ int _occupancy; // number of regions in cache
+ int _first; // (index of) "first" region in the cache
// adding CacheLength to deal with negative values
inline int trim_index(int index) {
@@ -62,7 +82,6 @@
void clear(void);
void insert(HeapRegion *hr);
HeapRegion *remove_first(void);
- void remove (HeapRegion *hr);
inline HeapRegion *get_first(void) {
return _cache[_first];
}
@@ -102,7 +121,6 @@
void sortMarkedHeapRegions();
void fillCache();
- bool addRegionToCache(void);
void addMarkedHeapRegion(HeapRegion *hr);
// Must be called before calls to getParMarkedHeapRegionChunk.
@@ -122,9 +140,6 @@
void updateAfterFullCollection();
- // Ensure that "hr" is not a member of the marked region array or the cache
- void removeRegion(HeapRegion* hr);
-
bool unmarked_age_1_returned_as_new() { return _unmarked_age_1_returned_as_new; }
// Returns true if the used portion of "_markedRegions" is properly
diff --git a/hotspot/src/share/vm/gc_implementation/g1/concurrentMark.cpp b/hotspot/src/share/vm/gc_implementation/g1/concurrentMark.cpp
index 3679002..444cd03 100644
--- a/hotspot/src/share/vm/gc_implementation/g1/concurrentMark.cpp
+++ b/hotspot/src/share/vm/gc_implementation/g1/concurrentMark.cpp
@@ -818,10 +818,10 @@
NoteStartOfMarkHRClosure startcl;
g1h->heap_region_iterate(&startcl);
- // Start weak-reference discovery.
- ReferenceProcessor* rp = g1h->ref_processor();
- rp->verify_no_references_recorded();
- rp->enable_discovery(); // enable ("weak") refs discovery
+ // Start Concurrent Marking weak-reference discovery.
+ ReferenceProcessor* rp = g1h->ref_processor_cm();
+ // enable ("weak") refs discovery
+ rp->enable_discovery(true /*verify_disabled*/, true /*verify_no_refs*/);
rp->setup_policy(false); // snapshot the soft ref policy to be used in this cycle
SATBMarkQueueSet& satb_mq_set = JavaThread::satb_mark_queue_set();
@@ -1133,6 +1133,7 @@
// world is stopped at this checkpoint
assert(SafepointSynchronize::is_at_safepoint(),
"world should be stopped");
+
G1CollectedHeap* g1h = G1CollectedHeap::heap();
// If a full collection has happened, we shouldn't do this.
@@ -1837,6 +1838,10 @@
size_t cleaned_up_bytes = start_used_bytes - g1h->used();
g1p->decrease_known_garbage_bytes(cleaned_up_bytes);
+ // Clean up will have freed any regions completely full of garbage.
+ // Update the soft reference policy with the new heap occupancy.
+ Universe::update_heap_info_at_gc();
+
// We need to make this be a "collection" so any collection pause that
// races with it goes around and waits for completeCleanup to finish.
g1h->increment_total_collections();
@@ -2072,8 +2077,10 @@
}
};
-// Implementation of AbstractRefProcTaskExecutor for G1
-class G1RefProcTaskExecutor: public AbstractRefProcTaskExecutor {
+// Implementation of AbstractRefProcTaskExecutor for parallel
+// reference processing at the end of G1 concurrent marking
+
+class G1CMRefProcTaskExecutor: public AbstractRefProcTaskExecutor {
private:
G1CollectedHeap* _g1h;
ConcurrentMark* _cm;
@@ -2082,7 +2089,7 @@
int _active_workers;
public:
- G1RefProcTaskExecutor(G1CollectedHeap* g1h,
+ G1CMRefProcTaskExecutor(G1CollectedHeap* g1h,
ConcurrentMark* cm,
CMBitMap* bitmap,
WorkGang* workers,
@@ -2096,7 +2103,7 @@
virtual void execute(EnqueueTask& task);
};
-class G1RefProcTaskProxy: public AbstractGangTask {
+class G1CMRefProcTaskProxy: public AbstractGangTask {
typedef AbstractRefProcTaskExecutor::ProcessTask ProcessTask;
ProcessTask& _proc_task;
G1CollectedHeap* _g1h;
@@ -2104,7 +2111,7 @@
CMBitMap* _bitmap;
public:
- G1RefProcTaskProxy(ProcessTask& proc_task,
+ G1CMRefProcTaskProxy(ProcessTask& proc_task,
G1CollectedHeap* g1h,
ConcurrentMark* cm,
CMBitMap* bitmap) :
@@ -2122,10 +2129,10 @@
}
};
-void G1RefProcTaskExecutor::execute(ProcessTask& proc_task) {
+void G1CMRefProcTaskExecutor::execute(ProcessTask& proc_task) {
assert(_workers != NULL, "Need parallel worker threads.");
- G1RefProcTaskProxy proc_task_proxy(proc_task, _g1h, _cm, _bitmap);
+ G1CMRefProcTaskProxy proc_task_proxy(proc_task, _g1h, _cm, _bitmap);
// We need to reset the phase for each task execution so that
// the termination protocol of CMTask::do_marking_step works.
@@ -2135,12 +2142,12 @@
_g1h->set_par_threads(0);
}
-class G1RefEnqueueTaskProxy: public AbstractGangTask {
+class G1CMRefEnqueueTaskProxy: public AbstractGangTask {
typedef AbstractRefProcTaskExecutor::EnqueueTask EnqueueTask;
EnqueueTask& _enq_task;
public:
- G1RefEnqueueTaskProxy(EnqueueTask& enq_task) :
+ G1CMRefEnqueueTaskProxy(EnqueueTask& enq_task) :
AbstractGangTask("Enqueue reference objects in parallel"),
_enq_task(enq_task)
{ }
@@ -2150,10 +2157,10 @@
}
};
-void G1RefProcTaskExecutor::execute(EnqueueTask& enq_task) {
+void G1CMRefProcTaskExecutor::execute(EnqueueTask& enq_task) {
assert(_workers != NULL, "Need parallel worker threads.");
- G1RefEnqueueTaskProxy enq_task_proxy(enq_task);
+ G1CMRefEnqueueTaskProxy enq_task_proxy(enq_task);
_g1h->set_par_threads(_active_workers);
_workers->run_task(&enq_task_proxy);
@@ -2163,71 +2170,84 @@
void ConcurrentMark::weakRefsWork(bool clear_all_soft_refs) {
ResourceMark rm;
HandleMark hm;
- G1CollectedHeap* g1h = G1CollectedHeap::heap();
- ReferenceProcessor* rp = g1h->ref_processor();
- // See the comment in G1CollectedHeap::ref_processing_init()
- // about how reference processing currently works in G1.
+ G1CollectedHeap* g1h = G1CollectedHeap::heap();
- // Process weak references.
- rp->setup_policy(clear_all_soft_refs);
- assert(_markStack.isEmpty(), "mark stack should be empty");
+ // Is alive closure.
+ G1CMIsAliveClosure g1_is_alive(g1h);
- G1CMIsAliveClosure g1_is_alive(g1h);
- G1CMKeepAliveClosure g1_keep_alive(g1h, this, nextMarkBitMap());
- G1CMDrainMarkingStackClosure
- g1_drain_mark_stack(nextMarkBitMap(), &_markStack, &g1_keep_alive);
- // We use the work gang from the G1CollectedHeap and we utilize all
- // the worker threads.
- int active_workers = g1h->workers() ? g1h->workers()->total_workers() : 1;
- active_workers = MAX2(MIN2(active_workers, (int)_max_task_num), 1);
+ // Inner scope to exclude the cleaning of the string and symbol
+ // tables from the displayed time.
+ {
+ bool verbose = PrintGC && PrintGCDetails;
+ if (verbose) {
+ gclog_or_tty->put(' ');
+ }
+ TraceTime t("GC ref-proc", verbose, false, gclog_or_tty);
- G1RefProcTaskExecutor par_task_executor(g1h, this, nextMarkBitMap(),
- g1h->workers(), active_workers);
+ ReferenceProcessor* rp = g1h->ref_processor_cm();
+ // See the comment in G1CollectedHeap::ref_processing_init()
+ // about how reference processing currently works in G1.
- if (rp->processing_is_mt()) {
- // Set the degree of MT here. If the discovery is done MT, there
- // may have been a different number of threads doing the discovery
- // and a different number of discovered lists may have Ref objects.
- // That is OK as long as the Reference lists are balanced (see
- // balance_all_queues() and balance_queues()).
- rp->set_active_mt_degree(active_workers);
+ // Process weak references.
+ rp->setup_policy(clear_all_soft_refs);
+ assert(_markStack.isEmpty(), "mark stack should be empty");
- rp->process_discovered_references(&g1_is_alive,
+ G1CMKeepAliveClosure g1_keep_alive(g1h, this, nextMarkBitMap());
+ G1CMDrainMarkingStackClosure
+ g1_drain_mark_stack(nextMarkBitMap(), &_markStack, &g1_keep_alive);
+
+ // We use the work gang from the G1CollectedHeap and we utilize all
+ // the worker threads.
+ int active_workers = g1h->workers() ? g1h->workers()->total_workers() : 1;
+ active_workers = MAX2(MIN2(active_workers, (int)_max_task_num), 1);
+
+ G1CMRefProcTaskExecutor par_task_executor(g1h, this, nextMarkBitMap(),
+ g1h->workers(), active_workers);
+
+ if (rp->processing_is_mt()) {
+ // Set the degree of MT here. If the discovery is done MT, there
+ // may have been a different number of threads doing the discovery
+ // and a different number of discovered lists may have Ref objects.
+ // That is OK as long as the Reference lists are balanced (see
+ // balance_all_queues() and balance_queues()).
+ rp->set_active_mt_degree(active_workers);
+
+ rp->process_discovered_references(&g1_is_alive,
&g1_keep_alive,
&g1_drain_mark_stack,
&par_task_executor);
- // The work routines of the parallel keep_alive and drain_marking_stack
- // will set the has_overflown flag if we overflow the global marking
- // stack.
- } else {
- rp->process_discovered_references(&g1_is_alive,
- &g1_keep_alive,
- &g1_drain_mark_stack,
- NULL);
+ // The work routines of the parallel keep_alive and drain_marking_stack
+ // will set the has_overflown flag if we overflow the global marking
+ // stack.
+ } else {
+ rp->process_discovered_references(&g1_is_alive,
+ &g1_keep_alive,
+ &g1_drain_mark_stack,
+ NULL);
+ }
+ assert(_markStack.overflow() || _markStack.isEmpty(),
+ "mark stack should be empty (unless it overflowed)");
+ if (_markStack.overflow()) {
+ // Should have been done already when we tried to push an
+ // entry on to the global mark stack. But let's do it again.
+ set_has_overflown();
+ }
+
+ if (rp->processing_is_mt()) {
+ assert(rp->num_q() == active_workers, "why not");
+ rp->enqueue_discovered_references(&par_task_executor);
+ } else {
+ rp->enqueue_discovered_references();
+ }
+
+ rp->verify_no_references_recorded();
+ assert(!rp->discovery_enabled(), "Post condition");
}
- assert(_markStack.overflow() || _markStack.isEmpty(),
- "mark stack should be empty (unless it overflowed)");
- if (_markStack.overflow()) {
- // Should have been done already when we tried to push an
- // entry on to the global mark stack. But let's do it again.
- set_has_overflown();
- }
-
- if (rp->processing_is_mt()) {
- assert(rp->num_q() == active_workers, "why not");
- rp->enqueue_discovered_references(&par_task_executor);
- } else {
- rp->enqueue_discovered_references();
- }
-
- rp->verify_no_references_recorded();
- assert(!rp->discovery_enabled(), "should have been disabled");
-
// Now clean up stale oops in StringTable
StringTable::unlink(&g1_is_alive);
// Clean up unreferenced symbols in symbol table.
@@ -3329,7 +3349,7 @@
assert(_ref_processor == NULL, "should be initialized to NULL");
if (G1UseConcMarkReferenceProcessing) {
- _ref_processor = g1h->ref_processor();
+ _ref_processor = g1h->ref_processor_cm();
assert(_ref_processor != NULL, "should not be NULL");
}
}
@@ -4564,6 +4584,15 @@
G1PPRL_DOUBLE_H_FORMAT,
"type", "address-range",
"used", "prev-live", "next-live", "gc-eff");
+ _out->print_cr(G1PPRL_LINE_PREFIX
+ G1PPRL_TYPE_H_FORMAT
+ G1PPRL_ADDR_BASE_H_FORMAT
+ G1PPRL_BYTE_H_FORMAT
+ G1PPRL_BYTE_H_FORMAT
+ G1PPRL_BYTE_H_FORMAT
+ G1PPRL_DOUBLE_H_FORMAT,
+ "", "",
+ "(bytes)", "(bytes)", "(bytes)", "(bytes/ms)");
}
// It takes as a parameter a reference to one of the _hum_* fields, it
@@ -4575,7 +4604,7 @@
// The > 0 check is to deal with the prev and next live bytes which
// could be 0.
if (*hum_bytes > 0) {
- bytes = MIN2((size_t) HeapRegion::GrainBytes, *hum_bytes);
+ bytes = MIN2(HeapRegion::GrainBytes, *hum_bytes);
*hum_bytes -= bytes;
}
return bytes;
diff --git a/hotspot/src/share/vm/gc_implementation/g1/concurrentMark.hpp b/hotspot/src/share/vm/gc_implementation/g1/concurrentMark.hpp
index 0aca642..c724594 100644
--- a/hotspot/src/share/vm/gc_implementation/g1/concurrentMark.hpp
+++ b/hotspot/src/share/vm/gc_implementation/g1/concurrentMark.hpp
@@ -366,8 +366,8 @@
friend class CMConcurrentMarkingTask;
friend class G1ParNoteEndTask;
friend class CalcLiveObjectsClosure;
- friend class G1RefProcTaskProxy;
- friend class G1RefProcTaskExecutor;
+ friend class G1CMRefProcTaskProxy;
+ friend class G1CMRefProcTaskExecutor;
friend class G1CMParKeepAliveAndDrainClosure;
friend class G1CMParDrainMarkingStackClosure;
diff --git a/hotspot/src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp b/hotspot/src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp
index 9d62845..b7a30f9 100644
--- a/hotspot/src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp
+++ b/hotspot/src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp
@@ -42,6 +42,7 @@
#include "memory/gcLocker.inline.hpp"
#include "memory/genOopClosures.inline.hpp"
#include "memory/generationSpec.hpp"
+#include "memory/referenceProcessor.hpp"
#include "oops/oop.inline.hpp"
#include "oops/oop.pcgc.inline.hpp"
#include "runtime/aprofiler.hpp"
@@ -551,8 +552,7 @@
}
HeapRegion* G1CollectedHeap::new_region(size_t word_size, bool do_expand) {
- assert(!isHumongous(word_size) ||
- word_size <= (size_t) HeapRegion::GrainWords,
+ assert(!isHumongous(word_size) || word_size <= HeapRegion::GrainWords,
"the only time we use this to allocate a humongous region is "
"when we are allocating a single humongous region");
@@ -815,6 +815,11 @@
result =
humongous_obj_allocate_initialize_regions(first, num_regions, word_size);
assert(result != NULL, "it should always return a valid result");
+
+ // A successful humongous object allocation changes the used space
+ // information of the old generation so we need to recalculate the
+ // sizes and update the jstat counters here.
+ g1mm()->update_sizes();
}
verify_region_sets_optional();
@@ -1164,7 +1169,7 @@
if (!hr->isHumongous()) {
_hr_printer->post_compaction(hr, G1HRPrinter::Old);
} else if (hr->startsHumongous()) {
- if (hr->capacity() == (size_t) HeapRegion::GrainBytes) {
+ if (hr->capacity() == HeapRegion::GrainBytes) {
// single humongous region
_hr_printer->post_compaction(hr, G1HRPrinter::SingleHumongous);
} else {
@@ -1244,15 +1249,11 @@
COMPILER2_PRESENT(DerivedPointerTable::clear());
- // We want to discover references, but not process them yet.
- // This mode is disabled in
- // instanceRefKlass::process_discovered_references if the
- // generation does some collection work, or
- // instanceRefKlass::enqueue_discovered_references if the
- // generation returns without doing any work.
- ref_processor()->disable_discovery();
- ref_processor()->abandon_partial_discovery();
- ref_processor()->verify_no_references_recorded();
+ // Disable discovery and empty the discovered lists
+ // for the CM ref processor.
+ ref_processor_cm()->disable_discovery();
+ ref_processor_cm()->abandon_partial_discovery();
+ ref_processor_cm()->verify_no_references_recorded();
// Abandon current iterations of concurrent marking and concurrent
// refinement, if any are in progress.
@@ -1280,31 +1281,33 @@
empty_young_list();
g1_policy()->set_full_young_gcs(true);
- // See the comment in G1CollectedHeap::ref_processing_init() about
+ // See the comments in g1CollectedHeap.hpp and
+ // G1CollectedHeap::ref_processing_init() about
// how reference processing currently works in G1.
- // Temporarily make reference _discovery_ single threaded (non-MT).
- ReferenceProcessorMTDiscoveryMutator rp_disc_ser(ref_processor(), false);
+ // Temporarily make discovery by the STW ref processor single threaded (non-MT).
+ ReferenceProcessorMTDiscoveryMutator stw_rp_disc_ser(ref_processor_stw(), false);
- // Temporarily make refs discovery atomic
- ReferenceProcessorAtomicMutator rp_disc_atomic(ref_processor(), true);
+ // Temporarily clear the STW ref processor's _is_alive_non_header field.
+ ReferenceProcessorIsAliveMutator stw_rp_is_alive_null(ref_processor_stw(), NULL);
- // Temporarily clear _is_alive_non_header
- ReferenceProcessorIsAliveMutator rp_is_alive_null(ref_processor(), NULL);
+ ref_processor_stw()->enable_discovery(true /*verify_disabled*/, true /*verify_no_refs*/);
+ ref_processor_stw()->setup_policy(do_clear_all_soft_refs);
- ref_processor()->enable_discovery();
- ref_processor()->setup_policy(do_clear_all_soft_refs);
// Do collection work
{
HandleMark hm; // Discard invalid handles created during gc
- G1MarkSweep::invoke_at_safepoint(ref_processor(), do_clear_all_soft_refs);
+ G1MarkSweep::invoke_at_safepoint(ref_processor_stw(), do_clear_all_soft_refs);
}
+
assert(free_regions() == 0, "we should not have added any free regions");
rebuild_region_lists();
_summary_bytes_used = recalculate_used();
- ref_processor()->enqueue_discovered_references();
+ // Enqueue any discovered reference objects that have
+ // not been removed from the discovered lists.
+ ref_processor_stw()->enqueue_discovered_references();
COMPILER2_PRESENT(DerivedPointerTable::update_pointers());
@@ -1319,7 +1322,16 @@
/* option */ VerifyOption_G1UsePrevMarking);
}
- NOT_PRODUCT(ref_processor()->verify_no_references_recorded());
+
+ assert(!ref_processor_stw()->discovery_enabled(), "Postcondition");
+ ref_processor_stw()->verify_no_references_recorded();
+
+ // Note: since we've just done a full GC, concurrent
+ // marking is no longer active. Therefore we need not
+ // re-enable reference discovery for the CM ref processor.
+ // That will be done at the start of the next marking cycle.
+ assert(!ref_processor_cm()->discovery_enabled(), "Postcondition");
+ ref_processor_cm()->verify_no_references_recorded();
reset_gc_time_stamp();
// Since everything potentially moved, we will clear all remembered
@@ -1414,7 +1426,7 @@
if (PrintHeapAtGC) {
Universe::print_heap_after_gc();
}
- g1mm()->update_counters();
+ g1mm()->update_sizes();
post_full_gc_dump();
return true;
@@ -1772,14 +1784,17 @@
_g1_policy(policy_),
_dirty_card_queue_set(false),
_into_cset_dirty_card_queue_set(false),
- _is_alive_closure(this),
- _ref_processor(NULL),
+ _is_alive_closure_cm(this),
+ _is_alive_closure_stw(this),
+ _ref_processor_cm(NULL),
+ _ref_processor_stw(NULL),
_process_strong_tasks(new SubTasksDone(G1H_PS_NumElements)),
_bot_shared(NULL),
_objs_with_preserved_marks(NULL), _preserved_marks_of_objs(NULL),
_evac_failure_scan_stack(NULL) ,
_mark_in_progress(false),
_cg1r(NULL), _summary_bytes_used(0),
+ _g1mm(NULL),
_refine_cte_cl(NULL),
_full_collection(false),
_free_list("Master Free List"),
@@ -1955,7 +1970,7 @@
size_t max_cards_per_region = ((size_t)1 << (sizeof(CardIdx_t)*BitsPerByte-1)) - 1;
guarantee(HeapRegion::CardsPerRegion > 0, "make sure it's initialized");
- guarantee((size_t) HeapRegion::CardsPerRegion < max_cards_per_region,
+ guarantee(HeapRegion::CardsPerRegion < max_cards_per_region,
"too many cards per region");
HeapRegionSet::set_unrealistically_long_length(max_regions() + 1);
@@ -2059,7 +2074,7 @@
// Do create of the monitoring and management support so that
// values in the heap have been properly initialized.
- _g1mm = new G1MonitoringSupport(this, &_g1_storage);
+ _g1mm = new G1MonitoringSupport(this);
return JNI_OK;
}
@@ -2067,34 +2082,81 @@
void G1CollectedHeap::ref_processing_init() {
// Reference processing in G1 currently works as follows:
//
- // * There is only one reference processor instance that
- // 'spans' the entire heap. It is created by the code
- // below.
- // * Reference discovery is not enabled during an incremental
- // pause (see 6484982).
- // * Discoverered refs are not enqueued nor are they processed
- // during an incremental pause (see 6484982).
- // * Reference discovery is enabled at initial marking.
- // * Reference discovery is disabled and the discovered
- // references processed etc during remarking.
- // * Reference discovery is MT (see below).
- // * Reference discovery requires a barrier (see below).
- // * Reference processing is currently not MT (see 6608385).
- // * A full GC enables (non-MT) reference discovery and
- // processes any discovered references.
+ // * There are two reference processor instances. One is
+ // used to record and process discovered references
+ // during concurrent marking; the other is used to
+ // record and process references during STW pauses
+ // (both full and incremental).
+ // * Both ref processors need to 'span' the entire heap as
+ // the regions in the collection set may be dotted around.
+ //
+ // * For the concurrent marking ref processor:
+ // * Reference discovery is enabled at initial marking.
+ // * Reference discovery is disabled and the discovered
+ // references processed etc during remarking.
+ // * Reference discovery is MT (see below).
+ // * Reference discovery requires a barrier (see below).
+ // * Reference processing may or may not be MT
+ // (depending on the value of ParallelRefProcEnabled
+ // and ParallelGCThreads).
+ // * A full GC disables reference discovery by the CM
+ // ref processor and abandons any entries on it's
+ // discovered lists.
+ //
+ // * For the STW processor:
+ // * Non MT discovery is enabled at the start of a full GC.
+ // * Processing and enqueueing during a full GC is non-MT.
+ // * During a full GC, references are processed after marking.
+ //
+ // * Discovery (may or may not be MT) is enabled at the start
+ // of an incremental evacuation pause.
+ // * References are processed near the end of a STW evacuation pause.
+ // * For both types of GC:
+ // * Discovery is atomic - i.e. not concurrent.
+ // * Reference discovery will not need a barrier.
SharedHeap::ref_processing_init();
MemRegion mr = reserved_region();
- _ref_processor =
+
+ // Concurrent Mark ref processor
+ _ref_processor_cm =
new ReferenceProcessor(mr, // span
- ParallelRefProcEnabled && (ParallelGCThreads > 1), // mt processing
- (int) ParallelGCThreads, // degree of mt processing
- ParallelGCThreads > 1 || ConcGCThreads > 1, // mt discovery
- (int) MAX2(ParallelGCThreads, ConcGCThreads), // degree of mt discovery
- false, // Reference discovery is not atomic
- &_is_alive_closure, // is alive closure for efficiency
- true); // Setting next fields of discovered
- // lists requires a barrier.
+ ParallelRefProcEnabled && (ParallelGCThreads > 1),
+ // mt processing
+ (int) ParallelGCThreads,
+ // degree of mt processing
+ (ParallelGCThreads > 1) || (ConcGCThreads > 1),
+ // mt discovery
+ (int) MAX2(ParallelGCThreads, ConcGCThreads),
+ // degree of mt discovery
+ false,
+ // Reference discovery is not atomic
+ &_is_alive_closure_cm,
+ // is alive closure
+ // (for efficiency/performance)
+ true);
+ // Setting next fields of discovered
+ // lists requires a barrier.
+
+ // STW ref processor
+ _ref_processor_stw =
+ new ReferenceProcessor(mr, // span
+ ParallelRefProcEnabled && (ParallelGCThreads > 1),
+ // mt processing
+ MAX2((int)ParallelGCThreads, 1),
+ // degree of mt processing
+ (ParallelGCThreads > 1),
+ // mt discovery
+ MAX2((int)ParallelGCThreads, 1),
+ // degree of mt discovery
+ true,
+ // Reference discovery is atomic
+ &_is_alive_closure_stw,
+ // is alive closure
+ // (for efficiency/performance)
+ false);
+ // Setting next fields of discovered
+ // lists requires a barrier.
}
size_t G1CollectedHeap::capacity() const {
@@ -2988,8 +3050,7 @@
_g1_storage.high(),
_g1_storage.high_boundary());
st->cr();
- st->print(" region size " SIZE_FORMAT "K, ",
- HeapRegion::GrainBytes/K);
+ st->print(" region size " SIZE_FORMAT "K, ", HeapRegion::GrainBytes / K);
size_t young_regions = _young_list->length();
st->print(SIZE_FORMAT " young (" SIZE_FORMAT "K), ",
young_regions, young_regions * HeapRegion::GrainBytes / K);
@@ -3117,6 +3178,10 @@
COMPILER2_PRESENT(assert(DerivedPointerTable::is_empty(),
"derived pointer present"));
// always_do_update_barrier = true;
+
+ // We have just completed a GC. Update the soft reference
+ // policy with the new heap occupancy
+ Universe::update_heap_info_at_gc();
}
HeapWord* G1CollectedHeap::do_collection_pause(size_t word_size,
@@ -3298,6 +3363,14 @@
// for the duration of this pause.
g1_policy()->decide_on_conc_mark_initiation();
+ // We do not allow initial-mark to be piggy-backed on a
+ // partially-young GC.
+ assert(!g1_policy()->during_initial_mark_pause() ||
+ g1_policy()->full_young_gcs(), "sanity");
+
+ // We also do not allow partially-young GCs during marking.
+ assert(!mark_in_progress() || g1_policy()->full_young_gcs(), "sanity");
+
char verbose_str[128];
sprintf(verbose_str, "GC pause ");
if (g1_policy()->full_young_gcs()) {
@@ -3354,231 +3427,242 @@
COMPILER2_PRESENT(DerivedPointerTable::clear());
- // Please see comment in G1CollectedHeap::ref_processing_init()
- // to see how reference processing currently works in G1.
- //
- // We want to turn off ref discovery, if necessary, and turn it back on
- // on again later if we do. XXX Dubious: why is discovery disabled?
- bool was_enabled = ref_processor()->discovery_enabled();
- if (was_enabled) ref_processor()->disable_discovery();
+ // Please see comment in g1CollectedHeap.hpp and
+ // G1CollectedHeap::ref_processing_init() to see how
+ // reference processing currently works in G1.
- // Forget the current alloc region (we might even choose it to be part
- // of the collection set!).
- release_mutator_alloc_region();
-
- // We should call this after we retire the mutator alloc
- // region(s) so that all the ALLOC / RETIRE events are generated
- // before the start GC event.
- _hr_printer.start_gc(false /* full */, (size_t) total_collections());
-
- // The elapsed time induced by the start time below deliberately elides
- // the possible verification above.
- double start_time_sec = os::elapsedTime();
- size_t start_used_bytes = used();
-
-#if YOUNG_LIST_VERBOSE
- gclog_or_tty->print_cr("\nBefore recording pause start.\nYoung_list:");
- _young_list->print();
- g1_policy()->print_collection_set(g1_policy()->inc_cset_head(), gclog_or_tty);
-#endif // YOUNG_LIST_VERBOSE
-
- g1_policy()->record_collection_pause_start(start_time_sec,
- start_used_bytes);
-
-#if YOUNG_LIST_VERBOSE
- gclog_or_tty->print_cr("\nAfter recording pause start.\nYoung_list:");
- _young_list->print();
-#endif // YOUNG_LIST_VERBOSE
-
- if (g1_policy()->during_initial_mark_pause()) {
- concurrent_mark()->checkpointRootsInitialPre();
- }
- perm_gen()->save_marks();
-
- // We must do this before any possible evacuation that should propagate
- // marks.
- if (mark_in_progress()) {
- double start_time_sec = os::elapsedTime();
-
- _cm->drainAllSATBBuffers();
- double finish_mark_ms = (os::elapsedTime() - start_time_sec) * 1000.0;
- g1_policy()->record_satb_drain_time(finish_mark_ms);
- }
- // Record the number of elements currently on the mark stack, so we
- // only iterate over these. (Since evacuation may add to the mark
- // stack, doing more exposes race conditions.) If no mark is in
- // progress, this will be zero.
- _cm->set_oops_do_bound();
-
- if (mark_in_progress()) {
- concurrent_mark()->newCSet();
- }
-
-#if YOUNG_LIST_VERBOSE
- gclog_or_tty->print_cr("\nBefore choosing collection set.\nYoung_list:");
- _young_list->print();
- g1_policy()->print_collection_set(g1_policy()->inc_cset_head(), gclog_or_tty);
-#endif // YOUNG_LIST_VERBOSE
-
- g1_policy()->choose_collection_set(target_pause_time_ms);
-
- if (_hr_printer.is_active()) {
- HeapRegion* hr = g1_policy()->collection_set();
- while (hr != NULL) {
- G1HRPrinter::RegionType type;
- if (!hr->is_young()) {
- type = G1HRPrinter::Old;
- } else if (hr->is_survivor()) {
- type = G1HRPrinter::Survivor;
- } else {
- type = G1HRPrinter::Eden;
- }
- _hr_printer.cset(hr);
- hr = hr->next_in_collection_set();
- }
- }
-
- // We have chosen the complete collection set. If marking is
- // active then, we clear the region fields of any of the
- // concurrent marking tasks whose region fields point into
- // the collection set as these values will become stale. This
- // will cause the owning marking threads to claim a new region
- // when marking restarts.
- if (mark_in_progress()) {
- concurrent_mark()->reset_active_task_region_fields_in_cset();
- }
-
-#ifdef ASSERT
- VerifyCSetClosure cl;
- collection_set_iterate(&cl);
-#endif // ASSERT
-
- setup_surviving_young_words();
-
- // Initialize the GC alloc regions.
- init_gc_alloc_regions();
-
- // Actually do the work...
- evacuate_collection_set();
-
- free_collection_set(g1_policy()->collection_set());
- g1_policy()->clear_collection_set();
-
- cleanup_surviving_young_words();
-
- // Start a new incremental collection set for the next pause.
- g1_policy()->start_incremental_cset_building();
-
- // Clear the _cset_fast_test bitmap in anticipation of adding
- // regions to the incremental collection set for the next
- // evacuation pause.
- clear_cset_fast_test();
-
- _young_list->reset_sampled_info();
-
- // Don't check the whole heap at this point as the
- // GC alloc regions from this pause have been tagged
- // as survivors and moved on to the survivor list.
- // Survivor regions will fail the !is_young() check.
- assert(check_young_list_empty(false /* check_heap */),
- "young list should be empty");
-
-#if YOUNG_LIST_VERBOSE
- gclog_or_tty->print_cr("Before recording survivors.\nYoung List:");
- _young_list->print();
-#endif // YOUNG_LIST_VERBOSE
-
- g1_policy()->record_survivor_regions(_young_list->survivor_length(),
- _young_list->first_survivor_region(),
- _young_list->last_survivor_region());
-
- _young_list->reset_auxilary_lists();
-
- if (evacuation_failed()) {
- _summary_bytes_used = recalculate_used();
- } else {
- // The "used" of the the collection set have already been subtracted
- // when they were freed. Add in the bytes evacuated.
- _summary_bytes_used += g1_policy()->bytes_copied_during_gc();
- }
-
- if (g1_policy()->during_initial_mark_pause()) {
- concurrent_mark()->checkpointRootsInitialPost();
- set_marking_started();
- // CAUTION: after the doConcurrentMark() call below,
- // the concurrent marking thread(s) could be running
- // concurrently with us. Make sure that anything after
- // this point does not assume that we are the only GC thread
- // running. Note: of course, the actual marking work will
- // not start until the safepoint itself is released in
- // ConcurrentGCThread::safepoint_desynchronize().
- doConcurrentMark();
- }
-
- allocate_dummy_regions();
-
-#if YOUNG_LIST_VERBOSE
- gclog_or_tty->print_cr("\nEnd of the pause.\nYoung_list:");
- _young_list->print();
- g1_policy()->print_collection_set(g1_policy()->inc_cset_head(), gclog_or_tty);
-#endif // YOUNG_LIST_VERBOSE
-
- init_mutator_alloc_region();
+ // Enable discovery in the STW reference processor
+ ref_processor_stw()->enable_discovery(true /*verify_disabled*/,
+ true /*verify_no_refs*/);
{
- size_t expand_bytes = g1_policy()->expansion_amount();
- if (expand_bytes > 0) {
- size_t bytes_before = capacity();
- if (!expand(expand_bytes)) {
- // We failed to expand the heap so let's verify that
- // committed/uncommitted amount match the backing store
- assert(capacity() == _g1_storage.committed_size(), "committed size mismatch");
- assert(max_capacity() == _g1_storage.reserved_size(), "reserved size mismatch");
+ // We want to temporarily turn off discovery by the
+ // CM ref processor, if necessary, and turn it back on
+ // on again later if we do. Using a scoped
+ // NoRefDiscovery object will do this.
+ NoRefDiscovery no_cm_discovery(ref_processor_cm());
+
+ // Forget the current alloc region (we might even choose it to be part
+ // of the collection set!).
+ release_mutator_alloc_region();
+
+ // We should call this after we retire the mutator alloc
+ // region(s) so that all the ALLOC / RETIRE events are generated
+ // before the start GC event.
+ _hr_printer.start_gc(false /* full */, (size_t) total_collections());
+
+ // The elapsed time induced by the start time below deliberately elides
+ // the possible verification above.
+ double start_time_sec = os::elapsedTime();
+ size_t start_used_bytes = used();
+
+#if YOUNG_LIST_VERBOSE
+ gclog_or_tty->print_cr("\nBefore recording pause start.\nYoung_list:");
+ _young_list->print();
+ g1_policy()->print_collection_set(g1_policy()->inc_cset_head(), gclog_or_tty);
+#endif // YOUNG_LIST_VERBOSE
+
+ g1_policy()->record_collection_pause_start(start_time_sec,
+ start_used_bytes);
+
+#if YOUNG_LIST_VERBOSE
+ gclog_or_tty->print_cr("\nAfter recording pause start.\nYoung_list:");
+ _young_list->print();
+#endif // YOUNG_LIST_VERBOSE
+
+ if (g1_policy()->during_initial_mark_pause()) {
+ concurrent_mark()->checkpointRootsInitialPre();
+ }
+ perm_gen()->save_marks();
+
+ // We must do this before any possible evacuation that should propagate
+ // marks.
+ if (mark_in_progress()) {
+ double start_time_sec = os::elapsedTime();
+
+ _cm->drainAllSATBBuffers();
+ double finish_mark_ms = (os::elapsedTime() - start_time_sec) * 1000.0;
+ g1_policy()->record_satb_drain_time(finish_mark_ms);
+ }
+ // Record the number of elements currently on the mark stack, so we
+ // only iterate over these. (Since evacuation may add to the mark
+ // stack, doing more exposes race conditions.) If no mark is in
+ // progress, this will be zero.
+ _cm->set_oops_do_bound();
+
+ if (mark_in_progress()) {
+ concurrent_mark()->newCSet();
+ }
+
+#if YOUNG_LIST_VERBOSE
+ gclog_or_tty->print_cr("\nBefore choosing collection set.\nYoung_list:");
+ _young_list->print();
+ g1_policy()->print_collection_set(g1_policy()->inc_cset_head(), gclog_or_tty);
+#endif // YOUNG_LIST_VERBOSE
+
+ g1_policy()->choose_collection_set(target_pause_time_ms);
+
+ if (_hr_printer.is_active()) {
+ HeapRegion* hr = g1_policy()->collection_set();
+ while (hr != NULL) {
+ G1HRPrinter::RegionType type;
+ if (!hr->is_young()) {
+ type = G1HRPrinter::Old;
+ } else if (hr->is_survivor()) {
+ type = G1HRPrinter::Survivor;
+ } else {
+ type = G1HRPrinter::Eden;
+ }
+ _hr_printer.cset(hr);
+ hr = hr->next_in_collection_set();
}
}
+
+ // We have chosen the complete collection set. If marking is
+ // active then, we clear the region fields of any of the
+ // concurrent marking tasks whose region fields point into
+ // the collection set as these values will become stale. This
+ // will cause the owning marking threads to claim a new region
+ // when marking restarts.
+ if (mark_in_progress()) {
+ concurrent_mark()->reset_active_task_region_fields_in_cset();
+ }
+
+#ifdef ASSERT
+ VerifyCSetClosure cl;
+ collection_set_iterate(&cl);
+#endif // ASSERT
+
+ setup_surviving_young_words();
+
+ // Initialize the GC alloc regions.
+ init_gc_alloc_regions();
+
+ // Actually do the work...
+ evacuate_collection_set();
+
+ free_collection_set(g1_policy()->collection_set());
+ g1_policy()->clear_collection_set();
+
+ cleanup_surviving_young_words();
+
+ // Start a new incremental collection set for the next pause.
+ g1_policy()->start_incremental_cset_building();
+
+ // Clear the _cset_fast_test bitmap in anticipation of adding
+ // regions to the incremental collection set for the next
+ // evacuation pause.
+ clear_cset_fast_test();
+
+ _young_list->reset_sampled_info();
+
+ // Don't check the whole heap at this point as the
+ // GC alloc regions from this pause have been tagged
+ // as survivors and moved on to the survivor list.
+ // Survivor regions will fail the !is_young() check.
+ assert(check_young_list_empty(false /* check_heap */),
+ "young list should be empty");
+
+#if YOUNG_LIST_VERBOSE
+ gclog_or_tty->print_cr("Before recording survivors.\nYoung List:");
+ _young_list->print();
+#endif // YOUNG_LIST_VERBOSE
+
+ g1_policy()->record_survivor_regions(_young_list->survivor_length(),
+ _young_list->first_survivor_region(),
+ _young_list->last_survivor_region());
+
+ _young_list->reset_auxilary_lists();
+
+ if (evacuation_failed()) {
+ _summary_bytes_used = recalculate_used();
+ } else {
+ // The "used" of the the collection set have already been subtracted
+ // when they were freed. Add in the bytes evacuated.
+ _summary_bytes_used += g1_policy()->bytes_copied_during_gc();
+ }
+
+ if (g1_policy()->during_initial_mark_pause()) {
+ concurrent_mark()->checkpointRootsInitialPost();
+ set_marking_started();
+ // CAUTION: after the doConcurrentMark() call below,
+ // the concurrent marking thread(s) could be running
+ // concurrently with us. Make sure that anything after
+ // this point does not assume that we are the only GC thread
+ // running. Note: of course, the actual marking work will
+ // not start until the safepoint itself is released in
+ // ConcurrentGCThread::safepoint_desynchronize().
+ doConcurrentMark();
+ }
+
+ allocate_dummy_regions();
+
+#if YOUNG_LIST_VERBOSE
+ gclog_or_tty->print_cr("\nEnd of the pause.\nYoung_list:");
+ _young_list->print();
+ g1_policy()->print_collection_set(g1_policy()->inc_cset_head(), gclog_or_tty);
+#endif // YOUNG_LIST_VERBOSE
+
+ init_mutator_alloc_region();
+
+ {
+ size_t expand_bytes = g1_policy()->expansion_amount();
+ if (expand_bytes > 0) {
+ size_t bytes_before = capacity();
+ if (!expand(expand_bytes)) {
+ // We failed to expand the heap so let's verify that
+ // committed/uncommitted amount match the backing store
+ assert(capacity() == _g1_storage.committed_size(), "committed size mismatch");
+ assert(max_capacity() == _g1_storage.reserved_size(), "reserved size mismatch");
+ }
+ }
+ }
+
+ double end_time_sec = os::elapsedTime();
+ double pause_time_ms = (end_time_sec - start_time_sec) * MILLIUNITS;
+ g1_policy()->record_pause_time_ms(pause_time_ms);
+ g1_policy()->record_collection_pause_end();
+
+ MemoryService::track_memory_usage();
+
+ // In prepare_for_verify() below we'll need to scan the deferred
+ // update buffers to bring the RSets up-to-date if
+ // G1HRRSFlushLogBuffersOnVerify has been set. While scanning
+ // the update buffers we'll probably need to scan cards on the
+ // regions we just allocated to (i.e., the GC alloc
+ // regions). However, during the last GC we called
+ // set_saved_mark() on all the GC alloc regions, so card
+ // scanning might skip the [saved_mark_word()...top()] area of
+ // those regions (i.e., the area we allocated objects into
+ // during the last GC). But it shouldn't. Given that
+ // saved_mark_word() is conditional on whether the GC time stamp
+ // on the region is current or not, by incrementing the GC time
+ // stamp here we invalidate all the GC time stamps on all the
+ // regions and saved_mark_word() will simply return top() for
+ // all the regions. This is a nicer way of ensuring this rather
+ // than iterating over the regions and fixing them. In fact, the
+ // GC time stamp increment here also ensures that
+ // saved_mark_word() will return top() between pauses, i.e.,
+ // during concurrent refinement. So we don't need the
+ // is_gc_active() check to decided which top to use when
+ // scanning cards (see CR 7039627).
+ increment_gc_time_stamp();
+
+ if (VerifyAfterGC && total_collections() >= VerifyGCStartAt) {
+ HandleMark hm; // Discard invalid handles created during verification
+ gclog_or_tty->print(" VerifyAfterGC:");
+ prepare_for_verify();
+ Universe::verify(/* allow dirty */ true,
+ /* silent */ false,
+ /* option */ VerifyOption_G1UsePrevMarking);
+ }
+
+ assert(!ref_processor_stw()->discovery_enabled(), "Postcondition");
+ ref_processor_stw()->verify_no_references_recorded();
+
+ // CM reference discovery will be re-enabled if necessary.
}
- double end_time_sec = os::elapsedTime();
- double pause_time_ms = (end_time_sec - start_time_sec) * MILLIUNITS;
- g1_policy()->record_pause_time_ms(pause_time_ms);
- g1_policy()->record_collection_pause_end();
-
- MemoryService::track_memory_usage();
-
- // In prepare_for_verify() below we'll need to scan the deferred
- // update buffers to bring the RSets up-to-date if
- // G1HRRSFlushLogBuffersOnVerify has been set. While scanning
- // the update buffers we'll probably need to scan cards on the
- // regions we just allocated to (i.e., the GC alloc
- // regions). However, during the last GC we called
- // set_saved_mark() on all the GC alloc regions, so card
- // scanning might skip the [saved_mark_word()...top()] area of
- // those regions (i.e., the area we allocated objects into
- // during the last GC). But it shouldn't. Given that
- // saved_mark_word() is conditional on whether the GC time stamp
- // on the region is current or not, by incrementing the GC time
- // stamp here we invalidate all the GC time stamps on all the
- // regions and saved_mark_word() will simply return top() for
- // all the regions. This is a nicer way of ensuring this rather
- // than iterating over the regions and fixing them. In fact, the
- // GC time stamp increment here also ensures that
- // saved_mark_word() will return top() between pauses, i.e.,
- // during concurrent refinement. So we don't need the
- // is_gc_active() check to decided which top to use when
- // scanning cards (see CR 7039627).
- increment_gc_time_stamp();
-
- if (VerifyAfterGC && total_collections() >= VerifyGCStartAt) {
- HandleMark hm; // Discard invalid handles created during verification
- gclog_or_tty->print(" VerifyAfterGC:");
- prepare_for_verify();
- Universe::verify(/* allow dirty */ true,
- /* silent */ false,
- /* option */ VerifyOption_G1UsePrevMarking);
- }
-
- if (was_enabled) ref_processor()->enable_discovery();
-
{
size_t expand_bytes = g1_policy()->expansion_amount();
if (expand_bytes > 0) {
@@ -3630,7 +3714,7 @@
if (PrintHeapAtGC) {
Universe::print_heap_after_gc();
}
- g1mm()->update_counters();
+ g1mm()->update_sizes();
if (G1SummarizeRSetStats &&
(G1SummarizeRSetStatsPeriod > 0) &&
@@ -3728,34 +3812,6 @@
_evac_failure_scan_stack = NULL;
}
-// *** Sequential G1 Evacuation
-
-class G1IsAliveClosure: public BoolObjectClosure {
- G1CollectedHeap* _g1;
-public:
- G1IsAliveClosure(G1CollectedHeap* g1) : _g1(g1) {}
- void do_object(oop p) { assert(false, "Do not call."); }
- bool do_object_b(oop p) {
- // It is reachable if it is outside the collection set, or is inside
- // and forwarded.
- return !_g1->obj_in_cs(p) || p->is_forwarded();
- }
-};
-
-class G1KeepAliveClosure: public OopClosure {
- G1CollectedHeap* _g1;
-public:
- G1KeepAliveClosure(G1CollectedHeap* g1) : _g1(g1) {}
- void do_oop(narrowOop* p) { guarantee(false, "Not needed"); }
- void do_oop( oop* p) {
- oop obj = *p;
- if (_g1->obj_in_cs(obj)) {
- assert( obj->is_forwarded(), "invariant" );
- *p = obj->forwardee();
- }
- }
-};
-
class UpdateRSetDeferred : public OopsInHeapRegionClosure {
private:
G1CollectedHeap* _g1;
@@ -3946,7 +4002,8 @@
oop
G1CollectedHeap::handle_evacuation_failure_par(OopsInHeapRegionClosure* cl,
- oop old) {
+ oop old,
+ bool should_mark_root) {
assert(obj_in_cs(old),
err_msg("obj: "PTR_FORMAT" should still be in the CSet",
(HeapWord*) old));
@@ -3954,6 +4011,16 @@
oop forward_ptr = old->forward_to_atomic(old);
if (forward_ptr == NULL) {
// Forward-to-self succeeded.
+
+ // should_mark_root will be true when this routine is called
+ // from a root scanning closure during an initial mark pause.
+ // In this case the thread that succeeds in self-forwarding the
+ // object is also responsible for marking the object.
+ if (should_mark_root) {
+ assert(!oopDesc::is_null(old), "shouldn't be");
+ _cm->grayRoot(old);
+ }
+
if (_evac_failure_closure != cl) {
MutexLockerEx x(EvacFailureStack_lock, Mutex::_no_safepoint_check_flag);
assert(!_drain_in_progress,
@@ -4175,12 +4242,17 @@
#endif // ASSERT
void G1ParScanThreadState::trim_queue() {
+ assert(_evac_cl != NULL, "not set");
+ assert(_evac_failure_cl != NULL, "not set");
+ assert(_partial_scan_cl != NULL, "not set");
+
StarTask ref;
do {
// Drain the overflow stack first, so other threads can steal.
while (refs()->pop_overflow(ref)) {
deal_with_reference(ref);
}
+
while (refs()->pop_local(ref)) {
deal_with_reference(ref);
}
@@ -4208,7 +4280,8 @@
}
}
-oop G1ParCopyHelper::copy_to_survivor_space(oop old, bool should_mark_copy) {
+oop G1ParCopyHelper::copy_to_survivor_space(oop old, bool should_mark_root,
+ bool should_mark_copy) {
size_t word_sz = old->size();
HeapRegion* from_region = _g1->heap_region_containing_raw(old);
// +1 to make the -1 indexes valid...
@@ -4228,7 +4301,7 @@
// This will either forward-to-self, or detect that someone else has
// installed a forwarding pointer.
OopsInHeapRegionClosure* cl = _par_scan_state->evac_failure_closure();
- return _g1->handle_evacuation_failure_par(cl, old);
+ return _g1->handle_evacuation_failure_par(cl, old, should_mark_root);
}
// We're going to allocate linearly, so might as well prefetch ahead.
@@ -4330,11 +4403,26 @@
// we also need to handle marking of roots in the
// event of an evacuation failure. In the event of an
// evacuation failure, the object is forwarded to itself
- // and not copied so let's mark it here.
+ // and not copied. For root-scanning closures, the
+ // object would be marked after a successful self-forward
+ // but an object could be pointed to by both a root and non
+ // root location and be self-forwarded by a non-root-scanning
+ // closure. Therefore we also have to attempt to mark the
+ // self-forwarded root object here.
if (do_mark_object && obj->forwardee() == obj) {
mark_object(p);
}
} else {
+ // During an initial mark pause, objects that are pointed to
+ // by the roots need to be marked - even in the event of an
+ // evacuation failure. We pass the template parameter
+ // do_mark_object (which is true for root scanning closures
+ // during an initial mark pause) to copy_to_survivor_space
+ // which will pass it on to the evacuation failure handling
+ // code. The thread that successfully self-forwards a root
+ // object to itself is responsible for marking the object.
+ bool should_mark_root = do_mark_object;
+
// We need to mark the copied object if we're a root scanning
// closure during an initial mark pause (i.e. do_mark_object
// will be true), or the object is already marked and we need
@@ -4343,7 +4431,8 @@
_during_initial_mark ||
(_mark_in_progress && !_g1->is_obj_ill(obj));
- oop copy_oop = copy_to_survivor_space(obj, should_mark_copy);
+ oop copy_oop = copy_to_survivor_space(obj, should_mark_root,
+ should_mark_copy);
oopDesc::encode_store_heap_oop(p, copy_oop);
}
// When scanning the RS, we only care about objs in CS.
@@ -4501,35 +4590,34 @@
ResourceMark rm;
HandleMark hm;
+ ReferenceProcessor* rp = _g1h->ref_processor_stw();
+
G1ParScanThreadState pss(_g1h, i);
- G1ParScanHeapEvacClosure scan_evac_cl(_g1h, &pss);
- G1ParScanHeapEvacFailureClosure evac_failure_cl(_g1h, &pss);
- G1ParScanPartialArrayClosure partial_scan_cl(_g1h, &pss);
+ G1ParScanHeapEvacClosure scan_evac_cl(_g1h, &pss, rp);
+ G1ParScanHeapEvacFailureClosure evac_failure_cl(_g1h, &pss, rp);
+ G1ParScanPartialArrayClosure partial_scan_cl(_g1h, &pss, rp);
pss.set_evac_closure(&scan_evac_cl);
pss.set_evac_failure_closure(&evac_failure_cl);
pss.set_partial_scan_closure(&partial_scan_cl);
- G1ParScanExtRootClosure only_scan_root_cl(_g1h, &pss);
- G1ParScanPermClosure only_scan_perm_cl(_g1h, &pss);
- G1ParScanHeapRSClosure only_scan_heap_rs_cl(_g1h, &pss);
- G1ParPushHeapRSClosure push_heap_rs_cl(_g1h, &pss);
+ G1ParScanExtRootClosure only_scan_root_cl(_g1h, &pss, rp);
+ G1ParScanPermClosure only_scan_perm_cl(_g1h, &pss, rp);
- G1ParScanAndMarkExtRootClosure scan_mark_root_cl(_g1h, &pss);
- G1ParScanAndMarkPermClosure scan_mark_perm_cl(_g1h, &pss);
- G1ParScanAndMarkHeapRSClosure scan_mark_heap_rs_cl(_g1h, &pss);
+ G1ParScanAndMarkExtRootClosure scan_mark_root_cl(_g1h, &pss, rp);
+ G1ParScanAndMarkPermClosure scan_mark_perm_cl(_g1h, &pss, rp);
- OopsInHeapRegionClosure *scan_root_cl;
- OopsInHeapRegionClosure *scan_perm_cl;
+ OopClosure* scan_root_cl = &only_scan_root_cl;
+ OopsInHeapRegionClosure* scan_perm_cl = &only_scan_perm_cl;
if (_g1h->g1_policy()->during_initial_mark_pause()) {
+ // We also need to mark copied objects.
scan_root_cl = &scan_mark_root_cl;
scan_perm_cl = &scan_mark_perm_cl;
- } else {
- scan_root_cl = &only_scan_root_cl;
- scan_perm_cl = &only_scan_perm_cl;
}
+ G1ParPushHeapRSClosure push_heap_rs_cl(_g1h, &pss);
+
pss.start_strong_roots();
_g1h->g1_process_strong_roots(/* not collecting perm */ false,
SharedHeap::SO_AllClasses,
@@ -4577,6 +4665,7 @@
OopsInHeapRegionClosure* scan_rs,
OopsInGenClosure* scan_perm,
int worker_i) {
+
// First scan the strong roots, including the perm gen.
double ext_roots_start = os::elapsedTime();
double closure_app_time_sec = 0.0;
@@ -4595,12 +4684,13 @@
&eager_scan_code_roots,
&buf_scan_perm);
- // Now the ref_processor roots.
+ // Now the CM ref_processor roots.
if (!_process_strong_tasks->is_task_claimed(G1H_PS_refProcessor_oops_do)) {
- // We need to treat the discovered reference lists as roots and
- // keep entries (which are added by the marking threads) on them
- // live until they can be processed at the end of marking.
- ref_processor()->weak_oops_do(&buf_scan_non_heap_roots);
+ // We need to treat the discovered reference lists of the
+ // concurrent mark ref processor as roots and keep entries
+ // (which are added by the marking threads) on them live
+ // until they can be processed at the end of marking.
+ ref_processor_cm()->weak_oops_do(&buf_scan_non_heap_roots);
}
// Finish up any enqueued closure apps (attributed as object copy time).
@@ -4641,6 +4731,524 @@
SharedHeap::process_weak_roots(root_closure, &roots_in_blobs, non_root_closure);
}
+// Weak Reference Processing support
+
+// An always "is_alive" closure that is used to preserve referents.
+// If the object is non-null then it's alive. Used in the preservation
+// of referent objects that are pointed to by reference objects
+// discovered by the CM ref processor.
+class G1AlwaysAliveClosure: public BoolObjectClosure {
+ G1CollectedHeap* _g1;
+public:
+ G1AlwaysAliveClosure(G1CollectedHeap* g1) : _g1(g1) {}
+ void do_object(oop p) { assert(false, "Do not call."); }
+ bool do_object_b(oop p) {
+ if (p != NULL) {
+ return true;
+ }
+ return false;
+ }
+};
+
+bool G1STWIsAliveClosure::do_object_b(oop p) {
+ // An object is reachable if it is outside the collection set,
+ // or is inside and copied.
+ return !_g1->obj_in_cs(p) || p->is_forwarded();
+}
+
+// Non Copying Keep Alive closure
+class G1KeepAliveClosure: public OopClosure {
+ G1CollectedHeap* _g1;
+public:
+ G1KeepAliveClosure(G1CollectedHeap* g1) : _g1(g1) {}
+ void do_oop(narrowOop* p) { guarantee(false, "Not needed"); }
+ void do_oop( oop* p) {
+ oop obj = *p;
+
+ if (_g1->obj_in_cs(obj)) {
+ assert( obj->is_forwarded(), "invariant" );
+ *p = obj->forwardee();
+ }
+ }
+};
+
+// Copying Keep Alive closure - can be called from both
+// serial and parallel code as long as different worker
+// threads utilize different G1ParScanThreadState instances
+// and different queues.
+
+class G1CopyingKeepAliveClosure: public OopClosure {
+ G1CollectedHeap* _g1h;
+ OopClosure* _copy_non_heap_obj_cl;
+ OopsInHeapRegionClosure* _copy_perm_obj_cl;
+ G1ParScanThreadState* _par_scan_state;
+
+public:
+ G1CopyingKeepAliveClosure(G1CollectedHeap* g1h,
+ OopClosure* non_heap_obj_cl,
+ OopsInHeapRegionClosure* perm_obj_cl,
+ G1ParScanThreadState* pss):
+ _g1h(g1h),
+ _copy_non_heap_obj_cl(non_heap_obj_cl),
+ _copy_perm_obj_cl(perm_obj_cl),
+ _par_scan_state(pss)
+ {}
+
+ virtual void do_oop(narrowOop* p) { do_oop_work(p); }
+ virtual void do_oop( oop* p) { do_oop_work(p); }
+
+ template <class T> void do_oop_work(T* p) {
+ oop obj = oopDesc::load_decode_heap_oop(p);
+
+ if (_g1h->obj_in_cs(obj)) {
+ // If the referent object has been forwarded (either copied
+ // to a new location or to itself in the event of an
+ // evacuation failure) then we need to update the reference
+ // field and, if both reference and referent are in the G1
+ // heap, update the RSet for the referent.
+ //
+ // If the referent has not been forwarded then we have to keep
+ // it alive by policy. Therefore we have copy the referent.
+ //
+ // If the reference field is in the G1 heap then we can push
+ // on the PSS queue. When the queue is drained (after each
+ // phase of reference processing) the object and it's followers
+ // will be copied, the reference field set to point to the
+ // new location, and the RSet updated. Otherwise we need to
+ // use the the non-heap or perm closures directly to copy
+ // the refernt object and update the pointer, while avoiding
+ // updating the RSet.
+
+ if (_g1h->is_in_g1_reserved(p)) {
+ _par_scan_state->push_on_queue(p);
+ } else {
+ // The reference field is not in the G1 heap.
+ if (_g1h->perm_gen()->is_in(p)) {
+ _copy_perm_obj_cl->do_oop(p);
+ } else {
+ _copy_non_heap_obj_cl->do_oop(p);
+ }
+ }
+ }
+ }
+};
+
+// Serial drain queue closure. Called as the 'complete_gc'
+// closure for each discovered list in some of the
+// reference processing phases.
+
+class G1STWDrainQueueClosure: public VoidClosure {
+protected:
+ G1CollectedHeap* _g1h;
+ G1ParScanThreadState* _par_scan_state;
+
+ G1ParScanThreadState* par_scan_state() { return _par_scan_state; }
+
+public:
+ G1STWDrainQueueClosure(G1CollectedHeap* g1h, G1ParScanThreadState* pss) :
+ _g1h(g1h),
+ _par_scan_state(pss)
+ { }
+
+ void do_void() {
+ G1ParScanThreadState* const pss = par_scan_state();
+ pss->trim_queue();
+ }
+};
+
+// Parallel Reference Processing closures
+
+// Implementation of AbstractRefProcTaskExecutor for parallel reference
+// processing during G1 evacuation pauses.
+
+class G1STWRefProcTaskExecutor: public AbstractRefProcTaskExecutor {
+private:
+ G1CollectedHeap* _g1h;
+ RefToScanQueueSet* _queues;
+ WorkGang* _workers;
+ int _active_workers;
+
+public:
+ G1STWRefProcTaskExecutor(G1CollectedHeap* g1h,
+ WorkGang* workers,
+ RefToScanQueueSet *task_queues,
+ int n_workers) :
+ _g1h(g1h),
+ _queues(task_queues),
+ _workers(workers),
+ _active_workers(n_workers)
+ {
+ assert(n_workers > 0, "shouldn't call this otherwise");
+ }
+
+ // Executes the given task using concurrent marking worker threads.
+ virtual void execute(ProcessTask& task);
+ virtual void execute(EnqueueTask& task);
+};
+
+// Gang task for possibly parallel reference processing
+
+class G1STWRefProcTaskProxy: public AbstractGangTask {
+ typedef AbstractRefProcTaskExecutor::ProcessTask ProcessTask;
+ ProcessTask& _proc_task;
+ G1CollectedHeap* _g1h;
+ RefToScanQueueSet *_task_queues;
+ ParallelTaskTerminator* _terminator;
+
+public:
+ G1STWRefProcTaskProxy(ProcessTask& proc_task,
+ G1CollectedHeap* g1h,
+ RefToScanQueueSet *task_queues,
+ ParallelTaskTerminator* terminator) :
+ AbstractGangTask("Process reference objects in parallel"),
+ _proc_task(proc_task),
+ _g1h(g1h),
+ _task_queues(task_queues),
+ _terminator(terminator)
+ {}
+
+ virtual void work(int i) {
+ // The reference processing task executed by a single worker.
+ ResourceMark rm;
+ HandleMark hm;
+
+ G1STWIsAliveClosure is_alive(_g1h);
+
+ G1ParScanThreadState pss(_g1h, i);
+
+ G1ParScanHeapEvacClosure scan_evac_cl(_g1h, &pss, NULL);
+ G1ParScanHeapEvacFailureClosure evac_failure_cl(_g1h, &pss, NULL);
+ G1ParScanPartialArrayClosure partial_scan_cl(_g1h, &pss, NULL);
+
+ pss.set_evac_closure(&scan_evac_cl);
+ pss.set_evac_failure_closure(&evac_failure_cl);
+ pss.set_partial_scan_closure(&partial_scan_cl);
+
+ G1ParScanExtRootClosure only_copy_non_heap_cl(_g1h, &pss, NULL);
+ G1ParScanPermClosure only_copy_perm_cl(_g1h, &pss, NULL);
+
+ G1ParScanAndMarkExtRootClosure copy_mark_non_heap_cl(_g1h, &pss, NULL);
+ G1ParScanAndMarkPermClosure copy_mark_perm_cl(_g1h, &pss, NULL);
+
+ OopClosure* copy_non_heap_cl = &only_copy_non_heap_cl;
+ OopsInHeapRegionClosure* copy_perm_cl = &only_copy_perm_cl;
+
+ if (_g1h->g1_policy()->during_initial_mark_pause()) {
+ // We also need to mark copied objects.
+ copy_non_heap_cl = ©_mark_non_heap_cl;
+ copy_perm_cl = ©_mark_perm_cl;
+ }
+
+ // Keep alive closure.
+ G1CopyingKeepAliveClosure keep_alive(_g1h, copy_non_heap_cl, copy_perm_cl, &pss);
+
+ // Complete GC closure
+ G1ParEvacuateFollowersClosure drain_queue(_g1h, &pss, _task_queues, _terminator);
+
+ // Call the reference processing task's work routine.
+ _proc_task.work(i, is_alive, keep_alive, drain_queue);
+
+ // Note we cannot assert that the refs array is empty here as not all
+ // of the processing tasks (specifically phase2 - pp2_work) execute
+ // the complete_gc closure (which ordinarily would drain the queue) so
+ // the queue may not be empty.
+ }
+};
+
+// Driver routine for parallel reference processing.
+// Creates an instance of the ref processing gang
+// task and has the worker threads execute it.
+void G1STWRefProcTaskExecutor::execute(ProcessTask& proc_task) {
+ assert(_workers != NULL, "Need parallel worker threads.");
+
+ ParallelTaskTerminator terminator(_active_workers, _queues);
+ G1STWRefProcTaskProxy proc_task_proxy(proc_task, _g1h, _queues, &terminator);
+
+ _g1h->set_par_threads(_active_workers);
+ _workers->run_task(&proc_task_proxy);
+ _g1h->set_par_threads(0);
+}
+
+// Gang task for parallel reference enqueueing.
+
+class G1STWRefEnqueueTaskProxy: public AbstractGangTask {
+ typedef AbstractRefProcTaskExecutor::EnqueueTask EnqueueTask;
+ EnqueueTask& _enq_task;
+
+public:
+ G1STWRefEnqueueTaskProxy(EnqueueTask& enq_task) :
+ AbstractGangTask("Enqueue reference objects in parallel"),
+ _enq_task(enq_task)
+ { }
+
+ virtual void work(int i) {
+ _enq_task.work(i);
+ }
+};
+
+// Driver routine for parallel reference enqueing.
+// Creates an instance of the ref enqueueing gang
+// task and has the worker threads execute it.
+
+void G1STWRefProcTaskExecutor::execute(EnqueueTask& enq_task) {
+ assert(_workers != NULL, "Need parallel worker threads.");
+
+ G1STWRefEnqueueTaskProxy enq_task_proxy(enq_task);
+
+ _g1h->set_par_threads(_active_workers);
+ _workers->run_task(&enq_task_proxy);
+ _g1h->set_par_threads(0);
+}
+
+// End of weak reference support closures
+
+// Abstract task used to preserve (i.e. copy) any referent objects
+// that are in the collection set and are pointed to by reference
+// objects discovered by the CM ref processor.
+
+class G1ParPreserveCMReferentsTask: public AbstractGangTask {
+protected:
+ G1CollectedHeap* _g1h;
+ RefToScanQueueSet *_queues;
+ ParallelTaskTerminator _terminator;
+ int _n_workers;
+
+public:
+ G1ParPreserveCMReferentsTask(G1CollectedHeap* g1h,int workers, RefToScanQueueSet *task_queues) :
+ AbstractGangTask("ParPreserveCMReferents"),
+ _g1h(g1h),
+ _queues(task_queues),
+ _terminator(workers, _queues),
+ _n_workers(workers)
+ { }
+
+ void work(int i) {
+ ResourceMark rm;
+ HandleMark hm;
+
+ G1ParScanThreadState pss(_g1h, i);
+ G1ParScanHeapEvacClosure scan_evac_cl(_g1h, &pss, NULL);
+ G1ParScanHeapEvacFailureClosure evac_failure_cl(_g1h, &pss, NULL);
+ G1ParScanPartialArrayClosure partial_scan_cl(_g1h, &pss, NULL);
+
+ pss.set_evac_closure(&scan_evac_cl);
+ pss.set_evac_failure_closure(&evac_failure_cl);
+ pss.set_partial_scan_closure(&partial_scan_cl);
+
+ assert(pss.refs()->is_empty(), "both queue and overflow should be empty");
+
+
+ G1ParScanExtRootClosure only_copy_non_heap_cl(_g1h, &pss, NULL);
+ G1ParScanPermClosure only_copy_perm_cl(_g1h, &pss, NULL);
+
+ G1ParScanAndMarkExtRootClosure copy_mark_non_heap_cl(_g1h, &pss, NULL);
+ G1ParScanAndMarkPermClosure copy_mark_perm_cl(_g1h, &pss, NULL);
+
+ OopClosure* copy_non_heap_cl = &only_copy_non_heap_cl;
+ OopsInHeapRegionClosure* copy_perm_cl = &only_copy_perm_cl;
+
+ if (_g1h->g1_policy()->during_initial_mark_pause()) {
+ // We also need to mark copied objects.
+ copy_non_heap_cl = ©_mark_non_heap_cl;
+ copy_perm_cl = ©_mark_perm_cl;
+ }
+
+ // Is alive closure
+ G1AlwaysAliveClosure always_alive(_g1h);
+
+ // Copying keep alive closure. Applied to referent objects that need
+ // to be copied.
+ G1CopyingKeepAliveClosure keep_alive(_g1h, copy_non_heap_cl, copy_perm_cl, &pss);
+
+ ReferenceProcessor* rp = _g1h->ref_processor_cm();
+
+ int limit = ReferenceProcessor::number_of_subclasses_of_ref() * rp->max_num_q();
+ int stride = MIN2(MAX2(_n_workers, 1), limit);
+
+ // limit is set using max_num_q() - which was set using ParallelGCThreads.
+ // So this must be true - but assert just in case someone decides to
+ // change the worker ids.
+ assert(0 <= i && i < limit, "sanity");
+ assert(!rp->discovery_is_atomic(), "check this code");
+
+ // Select discovered lists [i, i+stride, i+2*stride,...,limit)
+ for (int idx = i; idx < limit; idx += stride) {
+ DiscoveredList& ref_list = rp->discovered_soft_refs()[idx];
+
+ DiscoveredListIterator iter(ref_list, &keep_alive, &always_alive);
+ while (iter.has_next()) {
+ // Since discovery is not atomic for the CM ref processor, we
+ // can see some null referent objects.
+ iter.load_ptrs(DEBUG_ONLY(true));
+ oop ref = iter.obj();
+
+ // This will filter nulls.
+ if (iter.is_referent_alive()) {
+ iter.make_referent_alive();
+ }
+ iter.move_to_next();
+ }
+ }
+
+ // Drain the queue - which may cause stealing
+ G1ParEvacuateFollowersClosure drain_queue(_g1h, &pss, _queues, &_terminator);
+ drain_queue.do_void();
+ // Allocation buffers were retired at the end of G1ParEvacuateFollowersClosure
+ assert(pss.refs()->is_empty(), "should be");
+ }
+};
+
+// Weak Reference processing during an evacuation pause (part 1).
+void G1CollectedHeap::process_discovered_references() {
+ double ref_proc_start = os::elapsedTime();
+
+ ReferenceProcessor* rp = _ref_processor_stw;
+ assert(rp->discovery_enabled(), "should have been enabled");
+
+ // Any reference objects, in the collection set, that were 'discovered'
+ // by the CM ref processor should have already been copied (either by
+ // applying the external root copy closure to the discovered lists, or
+ // by following an RSet entry).
+ //
+ // But some of the referents, that are in the collection set, that these
+ // reference objects point to may not have been copied: the STW ref
+ // processor would have seen that the reference object had already
+ // been 'discovered' and would have skipped discovering the reference,
+ // but would not have treated the reference object as a regular oop.
+ // As a reult the copy closure would not have been applied to the
+ // referent object.
+ //
+ // We need to explicitly copy these referent objects - the references
+ // will be processed at the end of remarking.
+ //
+ // We also need to do this copying before we process the reference
+ // objects discovered by the STW ref processor in case one of these
+ // referents points to another object which is also referenced by an
+ // object discovered by the STW ref processor.
+
+ int n_workers = (G1CollectedHeap::use_parallel_gc_threads() ?
+ workers()->total_workers() : 1);
+
+ set_par_threads(n_workers);
+ G1ParPreserveCMReferentsTask keep_cm_referents(this, n_workers, _task_queues);
+
+ if (G1CollectedHeap::use_parallel_gc_threads()) {
+ workers()->run_task(&keep_cm_referents);
+ } else {
+ keep_cm_referents.work(0);
+ }
+
+ set_par_threads(0);
+
+ // Closure to test whether a referent is alive.
+ G1STWIsAliveClosure is_alive(this);
+
+ // Even when parallel reference processing is enabled, the processing
+ // of JNI refs is serial and performed serially by the current thread
+ // rather than by a worker. The following PSS will be used for processing
+ // JNI refs.
+
+ // Use only a single queue for this PSS.
+ G1ParScanThreadState pss(this, 0);
+
+ // We do not embed a reference processor in the copying/scanning
+ // closures while we're actually processing the discovered
+ // reference objects.
+ G1ParScanHeapEvacClosure scan_evac_cl(this, &pss, NULL);
+ G1ParScanHeapEvacFailureClosure evac_failure_cl(this, &pss, NULL);
+ G1ParScanPartialArrayClosure partial_scan_cl(this, &pss, NULL);
+
+ pss.set_evac_closure(&scan_evac_cl);
+ pss.set_evac_failure_closure(&evac_failure_cl);
+ pss.set_partial_scan_closure(&partial_scan_cl);
+
+ assert(pss.refs()->is_empty(), "pre-condition");
+
+ G1ParScanExtRootClosure only_copy_non_heap_cl(this, &pss, NULL);
+ G1ParScanPermClosure only_copy_perm_cl(this, &pss, NULL);
+
+ G1ParScanAndMarkExtRootClosure copy_mark_non_heap_cl(this, &pss, NULL);
+ G1ParScanAndMarkPermClosure copy_mark_perm_cl(this, &pss, NULL);
+
+ OopClosure* copy_non_heap_cl = &only_copy_non_heap_cl;
+ OopsInHeapRegionClosure* copy_perm_cl = &only_copy_perm_cl;
+
+ if (_g1h->g1_policy()->during_initial_mark_pause()) {
+ // We also need to mark copied objects.
+ copy_non_heap_cl = ©_mark_non_heap_cl;
+ copy_perm_cl = ©_mark_perm_cl;
+ }
+
+ // Keep alive closure.
+ G1CopyingKeepAliveClosure keep_alive(this, copy_non_heap_cl, copy_perm_cl, &pss);
+
+ // Serial Complete GC closure
+ G1STWDrainQueueClosure drain_queue(this, &pss);
+
+ // Setup the soft refs policy...
+ rp->setup_policy(false);
+
+ if (!rp->processing_is_mt()) {
+ // Serial reference processing...
+ rp->process_discovered_references(&is_alive,
+ &keep_alive,
+ &drain_queue,
+ NULL);
+ } else {
+ // Parallel reference processing
+ int active_workers = (ParallelGCThreads > 0 ? workers()->total_workers() : 1);
+ assert(rp->num_q() == active_workers, "sanity");
+ assert(active_workers <= rp->max_num_q(), "sanity");
+
+ G1STWRefProcTaskExecutor par_task_executor(this, workers(), _task_queues, active_workers);
+ rp->process_discovered_references(&is_alive, &keep_alive, &drain_queue, &par_task_executor);
+ }
+
+ // We have completed copying any necessary live referent objects
+ // (that were not copied during the actual pause) so we can
+ // retire any active alloc buffers
+ pss.retire_alloc_buffers();
+ assert(pss.refs()->is_empty(), "both queue and overflow should be empty");
+
+ double ref_proc_time = os::elapsedTime() - ref_proc_start;
+ g1_policy()->record_ref_proc_time(ref_proc_time * 1000.0);
+}
+
+// Weak Reference processing during an evacuation pause (part 2).
+void G1CollectedHeap::enqueue_discovered_references() {
+ double ref_enq_start = os::elapsedTime();
+
+ ReferenceProcessor* rp = _ref_processor_stw;
+ assert(!rp->discovery_enabled(), "should have been disabled as part of processing");
+
+ // Now enqueue any remaining on the discovered lists on to
+ // the pending list.
+ if (!rp->processing_is_mt()) {
+ // Serial reference processing...
+ rp->enqueue_discovered_references();
+ } else {
+ // Parallel reference enqueuing
+
+ int active_workers = (ParallelGCThreads > 0 ? workers()->total_workers() : 1);
+ assert(rp->num_q() == active_workers, "sanity");
+ assert(active_workers <= rp->max_num_q(), "sanity");
+
+ G1STWRefProcTaskExecutor par_task_executor(this, workers(), _task_queues, active_workers);
+ rp->enqueue_discovered_references(&par_task_executor);
+ }
+
+ rp->verify_no_references_recorded();
+ assert(!rp->discovery_enabled(), "should have been disabled");
+
+ // FIXME
+ // CM's reference processing also cleans up the string and symbol tables.
+ // Should we do that here also? We could, but it is a serial operation
+ // and could signicantly increase the pause time.
+
+ double ref_enq_time = os::elapsedTime() - ref_enq_start;
+ g1_policy()->record_ref_enq_time(ref_enq_time * 1000.0);
+}
+
void G1CollectedHeap::evacuate_collection_set() {
set_evacuation_failed(false);
@@ -4658,6 +5266,7 @@
assert(dirty_card_queue_set().completed_buffers_num() == 0, "Should be empty");
double start_par = os::elapsedTime();
+
if (G1CollectedHeap::use_parallel_gc_threads()) {
// The individual threads will set their evac-failure closures.
StrongRootsScope srs(this);
@@ -4672,15 +5281,23 @@
g1_policy()->record_par_time(par_time);
set_par_threads(0);
+ // Process any discovered reference objects - we have
+ // to do this _before_ we retire the GC alloc regions
+ // as we may have to copy some 'reachable' referent
+ // objects (and their reachable sub-graphs) that were
+ // not copied during the pause.
+ process_discovered_references();
+
// Weak root processing.
// Note: when JSR 292 is enabled and code blobs can contain
// non-perm oops then we will need to process the code blobs
// here too.
{
- G1IsAliveClosure is_alive(this);
+ G1STWIsAliveClosure is_alive(this);
G1KeepAliveClosure keep_alive(this);
JNIHandles::weak_oops_do(&is_alive, &keep_alive);
}
+
release_gc_alloc_regions();
g1_rem_set()->cleanup_after_oops_into_collection_set_do();
@@ -4702,6 +5319,15 @@
}
}
+ // Enqueue any remaining references remaining on the STW
+ // reference processor's discovered lists. We need to do
+ // this after the card table is cleaned (and verified) as
+ // the act of enqueuing entries on to the pending list
+ // will log these updates (and dirty their associated
+ // cards). We need these updates logged to update any
+ // RSets.
+ enqueue_discovered_references();
+
if (G1DeferredRSUpdate) {
RedirtyLoggedCardTableEntryFastClosure redirty;
dirty_card_queue_set().set_closure(&redirty);
@@ -4902,7 +5528,7 @@
}
double elapsed = os::elapsedTime() - start;
- g1_policy()->record_clear_ct_time( elapsed * 1000.0);
+ g1_policy()->record_clear_ct_time(elapsed * 1000.0);
#ifndef PRODUCT
if (G1VerifyCTCleanup || VerifyAfterGC) {
G1VerifyCardTableCleanup cleanup_verifier(this, ct_bs);
@@ -5193,7 +5819,6 @@
g1_policy()->update_region_num(true /* next_is_young */);
set_region_short_lived_locked(new_alloc_region);
_hr_printer.alloc(new_alloc_region, G1HRPrinter::Eden, young_list_full);
- g1mm()->update_eden_counters();
return new_alloc_region;
}
}
@@ -5208,6 +5833,10 @@
g1_policy()->add_region_to_incremental_cset_lhs(alloc_region);
_summary_bytes_used += allocated_bytes;
_hr_printer.retire(alloc_region);
+ // We update the eden sizes here, when the region is retired,
+ // instead of when it's allocated, since this is the point that its
+ // used space has been recored in _summary_bytes_used.
+ g1mm()->update_eden_size();
}
HeapRegion* MutatorAllocRegion::allocate_new_region(size_t word_size,
diff --git a/hotspot/src/share/vm/gc_implementation/g1/g1CollectedHeap.hpp b/hotspot/src/share/vm/gc_implementation/g1/g1CollectedHeap.hpp
index 650e438..50dd810 100644
--- a/hotspot/src/share/vm/gc_implementation/g1/g1CollectedHeap.hpp
+++ b/hotspot/src/share/vm/gc_implementation/g1/g1CollectedHeap.hpp
@@ -155,6 +155,19 @@
: G1AllocRegion("Mutator Alloc Region", false /* bot_updates */) { }
};
+// The G1 STW is alive closure.
+// An instance is embedded into the G1CH and used as the
+// (optional) _is_alive_non_header closure in the STW
+// reference processor. It is also extensively used during
+// refence processing during STW evacuation pauses.
+class G1STWIsAliveClosure: public BoolObjectClosure {
+ G1CollectedHeap* _g1;
+public:
+ G1STWIsAliveClosure(G1CollectedHeap* g1) : _g1(g1) {}
+ void do_object(oop p) { assert(false, "Do not call."); }
+ bool do_object_b(oop p);
+};
+
class SurvivorGCAllocRegion : public G1AllocRegion {
protected:
virtual HeapRegion* allocate_new_region(size_t word_size, bool force);
@@ -174,6 +187,7 @@
};
class RefineCardTableEntryClosure;
+
class G1CollectedHeap : public SharedHeap {
friend class VM_G1CollectForAllocation;
friend class VM_GenCollectForPermanentAllocation;
@@ -573,9 +587,20 @@
// allocated block, or else "NULL".
HeapWord* expand_and_allocate(size_t word_size);
+ // Process any reference objects discovered during
+ // an incremental evacuation pause.
+ void process_discovered_references();
+
+ // Enqueue any remaining discovered references
+ // after processing.
+ void enqueue_discovered_references();
+
public:
- G1MonitoringSupport* g1mm() { return _g1mm; }
+ G1MonitoringSupport* g1mm() {
+ assert(_g1mm != NULL, "should have been initialized");
+ return _g1mm;
+ }
// Expand the garbage-first heap by at least the given size (in bytes!).
// Returns true if the heap was expanded by the requested amount;
@@ -822,17 +847,87 @@
void finalize_for_evac_failure();
// An attempt to evacuate "obj" has failed; take necessary steps.
- oop handle_evacuation_failure_par(OopsInHeapRegionClosure* cl, oop obj);
+ oop handle_evacuation_failure_par(OopsInHeapRegionClosure* cl, oop obj,
+ bool should_mark_root);
void handle_evacuation_failure_common(oop obj, markOop m);
- // Instance of the concurrent mark is_alive closure for embedding
- // into the reference processor as the is_alive_non_header. This
- // prevents unnecessary additions to the discovered lists during
- // concurrent discovery.
- G1CMIsAliveClosure _is_alive_closure;
+ // ("Weak") Reference processing support.
+ //
+ // G1 has 2 instances of the referece processor class. One
+ // (_ref_processor_cm) handles reference object discovery
+ // and subsequent processing during concurrent marking cycles.
+ //
+ // The other (_ref_processor_stw) handles reference object
+ // discovery and processing during full GCs and incremental
+ // evacuation pauses.
+ //
+ // During an incremental pause, reference discovery will be
+ // temporarily disabled for _ref_processor_cm and will be
+ // enabled for _ref_processor_stw. At the end of the evacuation
+ // pause references discovered by _ref_processor_stw will be
+ // processed and discovery will be disabled. The previous
+ // setting for reference object discovery for _ref_processor_cm
+ // will be re-instated.
+ //
+ // At the start of marking:
+ // * Discovery by the CM ref processor is verified to be inactive
+ // and it's discovered lists are empty.
+ // * Discovery by the CM ref processor is then enabled.
+ //
+ // At the end of marking:
+ // * Any references on the CM ref processor's discovered
+ // lists are processed (possibly MT).
+ //
+ // At the start of full GC we:
+ // * Disable discovery by the CM ref processor and
+ // empty CM ref processor's discovered lists
+ // (without processing any entries).
+ // * Verify that the STW ref processor is inactive and it's
+ // discovered lists are empty.
+ // * Temporarily set STW ref processor discovery as single threaded.
+ // * Temporarily clear the STW ref processor's _is_alive_non_header
+ // field.
+ // * Finally enable discovery by the STW ref processor.
+ //
+ // The STW ref processor is used to record any discovered
+ // references during the full GC.
+ //
+ // At the end of a full GC we:
+ // * Enqueue any reference objects discovered by the STW ref processor
+ // that have non-live referents. This has the side-effect of
+ // making the STW ref processor inactive by disabling discovery.
+ // * Verify that the CM ref processor is still inactive
+ // and no references have been placed on it's discovered
+ // lists (also checked as a precondition during initial marking).
- // ("Weak") Reference processing support
- ReferenceProcessor* _ref_processor;
+ // The (stw) reference processor...
+ ReferenceProcessor* _ref_processor_stw;
+
+ // During reference object discovery, the _is_alive_non_header
+ // closure (if non-null) is applied to the referent object to
+ // determine whether the referent is live. If so then the
+ // reference object does not need to be 'discovered' and can
+ // be treated as a regular oop. This has the benefit of reducing
+ // the number of 'discovered' reference objects that need to
+ // be processed.
+ //
+ // Instance of the is_alive closure for embedding into the
+ // STW reference processor as the _is_alive_non_header field.
+ // Supplying a value for the _is_alive_non_header field is
+ // optional but doing so prevents unnecessary additions to
+ // the discovered lists during reference discovery.
+ G1STWIsAliveClosure _is_alive_closure_stw;
+
+ // The (concurrent marking) reference processor...
+ ReferenceProcessor* _ref_processor_cm;
+
+ // Instance of the concurrent mark is_alive closure for embedding
+ // into the Concurrent Marking reference processor as the
+ // _is_alive_non_header field. Supplying a value for the
+ // _is_alive_non_header field is optional but doing so prevents
+ // unnecessary additions to the discovered lists during reference
+ // discovery.
+ G1CMIsAliveClosure _is_alive_closure_cm;
enum G1H_process_strong_roots_tasks {
G1H_PS_mark_stack_oops_do,
@@ -873,6 +968,7 @@
// specified by the policy object.
jint initialize();
+ // Initialize weak reference processing.
virtual void ref_processing_init();
void set_par_threads(int t) {
@@ -924,8 +1020,13 @@
// The shared block offset table array.
G1BlockOffsetSharedArray* bot_shared() const { return _bot_shared; }
- // Reference Processing accessor
- ReferenceProcessor* ref_processor() { return _ref_processor; }
+ // Reference Processing accessors
+
+ // The STW reference processor....
+ ReferenceProcessor* ref_processor_stw() const { return _ref_processor_stw; }
+
+ // The Concurent Marking reference processor...
+ ReferenceProcessor* ref_processor_cm() const { return _ref_processor_cm; }
virtual size_t capacity() const;
virtual size_t used() const;
@@ -1236,12 +1337,7 @@
// storage in the heap comes from a young region or not.
// See ReduceInitialCardMarks.
virtual bool can_elide_tlab_store_barriers() const {
- // 6920090: Temporarily disabled, because of lingering
- // instabilities related to RICM with G1. In the
- // interim, the option ReduceInitialCardMarksForG1
- // below is left solely as a debugging device at least
- // until 6920109 fixes the instabilities.
- return ReduceInitialCardMarksForG1;
+ return true;
}
virtual bool card_mark_must_follow_store() const {
@@ -1265,8 +1361,6 @@
// update logging post-barrier, we don't maintain remembered set
// information for young gen objects.
virtual bool can_elide_initializing_store_barrier(oop new_obj) {
- // Re 6920090, 6920109 above.
- assert(ReduceInitialCardMarksForG1, "Else cannot be here");
return is_in_young(new_obj);
}
diff --git a/hotspot/src/share/vm/gc_implementation/g1/g1CollectorPolicy.cpp b/hotspot/src/share/vm/gc_implementation/g1/g1CollectorPolicy.cpp
index d43d080..3cac59c 100644
--- a/hotspot/src/share/vm/gc_implementation/g1/g1CollectorPolicy.cpp
+++ b/hotspot/src/share/vm/gc_implementation/g1/g1CollectorPolicy.cpp
@@ -152,8 +152,12 @@
_summary(new Summary()),
-#ifndef PRODUCT
_cur_clear_ct_time_ms(0.0),
+
+ _cur_ref_proc_time_ms(0.0),
+ _cur_ref_enq_time_ms(0.0),
+
+#ifndef PRODUCT
_min_clear_cc_time_ms(-1.0),
_max_clear_cc_time_ms(-1.0),
_cur_clear_cc_time_ms(0.0),
@@ -294,10 +298,10 @@
}
// Verify PLAB sizes
- const uint region_size = HeapRegion::GrainWords;
+ const size_t region_size = HeapRegion::GrainWords;
if (YoungPLABSize > region_size || OldPLABSize > region_size) {
char buffer[128];
- jio_snprintf(buffer, sizeof(buffer), "%sPLABSize should be at most %u",
+ jio_snprintf(buffer, sizeof(buffer), "%sPLABSize should be at most "SIZE_FORMAT,
OldPLABSize > region_size ? "Old" : "Young", region_size);
vm_exit_during_initialization(buffer);
}
@@ -459,15 +463,16 @@
// ParallelScavengeHeap::initialize()). We might change this in the
// future, but it's a good start.
class G1YoungGenSizer : public TwoGenerationCollectorPolicy {
+private:
+ size_t size_to_region_num(size_t byte_size) {
+ return MAX2((size_t) 1, byte_size / HeapRegion::GrainBytes);
+ }
public:
G1YoungGenSizer() {
initialize_flags();
initialize_size_info();
}
- size_t size_to_region_num(size_t byte_size) {
- return MAX2((size_t) 1, byte_size / HeapRegion::GrainBytes);
- }
size_t min_young_region_num() {
return size_to_region_num(_min_gen0_size);
}
@@ -501,11 +506,10 @@
if (FLAG_IS_CMDLINE(NewRatio)) {
if (FLAG_IS_CMDLINE(NewSize) || FLAG_IS_CMDLINE(MaxNewSize)) {
- gclog_or_tty->print_cr("-XX:NewSize and -XX:MaxNewSize overrides -XX:NewRatio");
+ warning("-XX:NewSize and -XX:MaxNewSize override -XX:NewRatio");
} else {
// Treat NewRatio as a fixed size that is only recalculated when the heap size changes
- size_t heap_regions = sizer.size_to_region_num(_g1->n_regions());
- update_young_list_size_using_newratio(heap_regions);
+ update_young_list_size_using_newratio(_g1->n_regions());
_using_new_ratio_calculations = true;
}
}
@@ -1479,6 +1483,8 @@
#endif
print_stats(1, "Other", other_time_ms);
print_stats(2, "Choose CSet", _recorded_young_cset_choice_time_ms);
+ print_stats(2, "Ref Proc", _cur_ref_proc_time_ms);
+ print_stats(2, "Ref Enq", _cur_ref_enq_time_ms);
for (int i = 0; i < _aux_num; ++i) {
if (_cur_aux_times_set[i]) {
@@ -1519,11 +1525,17 @@
}
if (_last_full_young_gc) {
- ergo_verbose2(ErgoPartiallyYoungGCs,
- "start partially-young GCs",
- ergo_format_byte_perc("known garbage"),
- _known_garbage_bytes, _known_garbage_ratio * 100.0);
- set_full_young_gcs(false);
+ if (!last_pause_included_initial_mark) {
+ ergo_verbose2(ErgoPartiallyYoungGCs,
+ "start partially-young GCs",
+ ergo_format_byte_perc("known garbage"),
+ _known_garbage_bytes, _known_garbage_ratio * 100.0);
+ set_full_young_gcs(false);
+ } else {
+ ergo_verbose0(ErgoPartiallyYoungGCs,
+ "do not start partially-young GCs",
+ ergo_format_reason("concurrent cycle is about to start"));
+ }
_last_full_young_gc = false;
}
@@ -2485,6 +2497,13 @@
// initiate a new cycle.
set_during_initial_mark_pause();
+ // We do not allow non-full young GCs during marking.
+ if (!full_young_gcs()) {
+ set_full_young_gcs(true);
+ ergo_verbose0(ErgoPartiallyYoungGCs,
+ "end partially-young GCs",
+ ergo_format_reason("concurrent cycle is about to start"));
+ }
// And we can now clear initiate_conc_mark_if_possible() as
// we've already acted on it.
diff --git a/hotspot/src/share/vm/gc_implementation/g1/g1CollectorPolicy.hpp b/hotspot/src/share/vm/gc_implementation/g1/g1CollectorPolicy.hpp
index 9dc7349..4e61395 100644
--- a/hotspot/src/share/vm/gc_implementation/g1/g1CollectorPolicy.hpp
+++ b/hotspot/src/share/vm/gc_implementation/g1/g1CollectorPolicy.hpp
@@ -119,6 +119,8 @@
double _cur_satb_drain_time_ms;
double _cur_clear_ct_time_ms;
bool _satb_drain_time_set;
+ double _cur_ref_proc_time_ms;
+ double _cur_ref_enq_time_ms;
#ifndef PRODUCT
// Card Table Count Cache stats
@@ -986,6 +988,14 @@
_cur_aux_times_ms[i] += ms;
}
+ void record_ref_proc_time(double ms) {
+ _cur_ref_proc_time_ms = ms;
+ }
+
+ void record_ref_enq_time(double ms) {
+ _cur_ref_enq_time_ms = ms;
+ }
+
#ifndef PRODUCT
void record_cc_clear_time(double ms) {
if (_min_clear_cc_time_ms < 0.0 || ms <= _min_clear_cc_time_ms)
@@ -1139,6 +1149,10 @@
return young_list_length < young_list_max_length;
}
+ size_t young_list_max_length() {
+ return _young_list_max_length;
+ }
+
void update_region_num(bool young);
bool full_young_gcs() {
diff --git a/hotspot/src/share/vm/gc_implementation/g1/g1MarkSweep.cpp b/hotspot/src/share/vm/gc_implementation/g1/g1MarkSweep.cpp
index 1ed4f99..84bbadb 100644
--- a/hotspot/src/share/vm/gc_implementation/g1/g1MarkSweep.cpp
+++ b/hotspot/src/share/vm/gc_implementation/g1/g1MarkSweep.cpp
@@ -62,6 +62,8 @@
// hook up weak ref data so it can be used during Mark-Sweep
assert(GenMarkSweep::ref_processor() == NULL, "no stomping");
assert(rp != NULL, "should be non-NULL");
+ assert(rp == G1CollectedHeap::heap()->ref_processor_stw(), "Precondition");
+
GenMarkSweep::_ref_processor = rp;
rp->setup_policy(clear_all_softrefs);
@@ -139,6 +141,8 @@
// Process reference objects found during marking
ReferenceProcessor* rp = GenMarkSweep::ref_processor();
+ assert(rp == G1CollectedHeap::heap()->ref_processor_stw(), "Sanity");
+
rp->setup_policy(clear_all_softrefs);
rp->process_discovered_references(&GenMarkSweep::is_alive,
&GenMarkSweep::keep_alive,
@@ -166,7 +170,6 @@
GenMarkSweep::follow_mdo_weak_refs();
assert(GenMarkSweep::_marking_stack.is_empty(), "just drained");
-
// Visit interned string tables and delete unmarked oops
StringTable::unlink(&GenMarkSweep::is_alive);
// Clean up unreferenced symbols in symbol table.
@@ -346,7 +349,8 @@
NULL, // do not touch code cache here
&GenMarkSweep::adjust_pointer_closure);
- g1h->ref_processor()->weak_oops_do(&GenMarkSweep::adjust_root_pointer_closure);
+ assert(GenMarkSweep::ref_processor() == g1h->ref_processor_stw(), "Sanity");
+ g1h->ref_processor_stw()->weak_oops_do(&GenMarkSweep::adjust_root_pointer_closure);
// Now adjust pointers in remaining weak roots. (All of which should
// have been cleared if they pointed to non-surviving objects.)
diff --git a/hotspot/src/share/vm/gc_implementation/g1/g1MonitoringSupport.cpp b/hotspot/src/share/vm/gc_implementation/g1/g1MonitoringSupport.cpp
index aab16db..d22dc7a 100644
--- a/hotspot/src/share/vm/gc_implementation/g1/g1MonitoringSupport.cpp
+++ b/hotspot/src/share/vm/gc_implementation/g1/g1MonitoringSupport.cpp
@@ -27,19 +27,69 @@
#include "gc_implementation/g1/g1CollectedHeap.inline.hpp"
#include "gc_implementation/g1/g1CollectorPolicy.hpp"
-G1MonitoringSupport::G1MonitoringSupport(G1CollectedHeap* g1h,
- VirtualSpace* g1_storage_addr) :
+G1GenerationCounters::G1GenerationCounters(G1MonitoringSupport* g1mm,
+ const char* name,
+ int ordinal, int spaces,
+ size_t min_capacity,
+ size_t max_capacity,
+ size_t curr_capacity)
+ : GenerationCounters(name, ordinal, spaces, min_capacity,
+ max_capacity, curr_capacity), _g1mm(g1mm) { }
+
+// We pad the capacity three times given that the young generation
+// contains three spaces (eden and two survivors).
+G1YoungGenerationCounters::G1YoungGenerationCounters(G1MonitoringSupport* g1mm,
+ const char* name)
+ : G1GenerationCounters(g1mm, name, 0 /* ordinal */, 3 /* spaces */,
+ G1MonitoringSupport::pad_capacity(0, 3) /* min_capacity */,
+ G1MonitoringSupport::pad_capacity(g1mm->young_gen_max(), 3),
+ G1MonitoringSupport::pad_capacity(0, 3) /* curr_capacity */) {
+ update_all();
+}
+
+G1OldGenerationCounters::G1OldGenerationCounters(G1MonitoringSupport* g1mm,
+ const char* name)
+ : G1GenerationCounters(g1mm, name, 1 /* ordinal */, 1 /* spaces */,
+ G1MonitoringSupport::pad_capacity(0) /* min_capacity */,
+ G1MonitoringSupport::pad_capacity(g1mm->old_gen_max()),
+ G1MonitoringSupport::pad_capacity(0) /* curr_capacity */) {
+ update_all();
+}
+
+void G1YoungGenerationCounters::update_all() {
+ size_t committed =
+ G1MonitoringSupport::pad_capacity(_g1mm->young_gen_committed(), 3);
+ _current_size->set_value(committed);
+}
+
+void G1OldGenerationCounters::update_all() {
+ size_t committed =
+ G1MonitoringSupport::pad_capacity(_g1mm->old_gen_committed());
+ _current_size->set_value(committed);
+}
+
+G1MonitoringSupport::G1MonitoringSupport(G1CollectedHeap* g1h) :
_g1h(g1h),
_incremental_collection_counters(NULL),
_full_collection_counters(NULL),
- _non_young_collection_counters(NULL),
+ _old_collection_counters(NULL),
_old_space_counters(NULL),
_young_collection_counters(NULL),
_eden_counters(NULL),
_from_counters(NULL),
_to_counters(NULL),
- _g1_storage_addr(g1_storage_addr)
-{
+
+ _overall_reserved(0),
+ _overall_committed(0), _overall_used(0),
+ _young_region_num(0),
+ _young_gen_committed(0),
+ _eden_committed(0), _eden_used(0),
+ _survivor_committed(0), _survivor_used(0),
+ _old_committed(0), _old_used(0) {
+
+ _overall_reserved = g1h->max_capacity();
+ recalculate_sizes();
+
// Counters for GC collections
//
// name "collector.0". In a generational collector this would be the
@@ -69,110 +119,147 @@
// generational GC terms. The "1, 1" parameters are for
// the n-th generation (=1) with 1 space.
// Counters are created from minCapacity, maxCapacity, and capacity
- _non_young_collection_counters =
- new GenerationCounters("whole heap", 1, 1, _g1_storage_addr);
+ _old_collection_counters = new G1OldGenerationCounters(this, "old");
// name "generation.1.space.0"
// Counters are created from maxCapacity, capacity, initCapacity,
// and used.
- _old_space_counters = new HSpaceCounters("space", 0,
- _g1h->max_capacity(), _g1h->capacity(), _non_young_collection_counters);
+ _old_space_counters = new HSpaceCounters("space", 0 /* ordinal */,
+ pad_capacity(overall_reserved()) /* max_capacity */,
+ pad_capacity(old_space_committed()) /* init_capacity */,
+ _old_collection_counters);
// Young collection set
// name "generation.0". This is logically the young generation.
// The "0, 3" are paremeters for the n-th genertaion (=0) with 3 spaces.
- // See _non_young_collection_counters for additional counters
- _young_collection_counters = new GenerationCounters("young", 0, 3, NULL);
+ // See _old_collection_counters for additional counters
+ _young_collection_counters = new G1YoungGenerationCounters(this, "young");
- // Replace "max_heap_byte_size() with maximum young gen size for
- // g1Collectedheap
// name "generation.0.space.0"
// See _old_space_counters for additional counters
- _eden_counters = new HSpaceCounters("eden", 0,
- _g1h->max_capacity(), eden_space_committed(),
+ _eden_counters = new HSpaceCounters("eden", 0 /* ordinal */,
+ pad_capacity(overall_reserved()) /* max_capacity */,
+ pad_capacity(eden_space_committed()) /* init_capacity */,
_young_collection_counters);
// name "generation.0.space.1"
// See _old_space_counters for additional counters
// Set the arguments to indicate that this survivor space is not used.
- _from_counters = new HSpaceCounters("s0", 1, (long) 0, (long) 0,
+ _from_counters = new HSpaceCounters("s0", 1 /* ordinal */,
+ pad_capacity(0) /* max_capacity */,
+ pad_capacity(0) /* init_capacity */,
_young_collection_counters);
+ // Given that this survivor space is not used, we update it here
+ // once to reflect that its used space is 0 so that we don't have to
+ // worry about updating it again later.
+ _from_counters->update_used(0);
// name "generation.0.space.2"
// See _old_space_counters for additional counters
- _to_counters = new HSpaceCounters("s1", 2,
- _g1h->max_capacity(),
- survivor_space_committed(),
+ _to_counters = new HSpaceCounters("s1", 2 /* ordinal */,
+ pad_capacity(overall_reserved()) /* max_capacity */,
+ pad_capacity(survivor_space_committed()) /* init_capacity */,
_young_collection_counters);
}
-size_t G1MonitoringSupport::overall_committed() {
- return g1h()->capacity();
+void G1MonitoringSupport::recalculate_sizes() {
+ G1CollectedHeap* g1 = g1h();
+
+ // Recalculate all the sizes from scratch. We assume that this is
+ // called at a point where no concurrent updates to the various
+ // values we read here are possible (i.e., at a STW phase at the end
+ // of a GC).
+
+ size_t young_list_length = g1->young_list()->length();
+ size_t survivor_list_length = g1->g1_policy()->recorded_survivor_regions();
+ assert(young_list_length >= survivor_list_length, "invariant");
+ size_t eden_list_length = young_list_length - survivor_list_length;
+ // Max length includes any potential extensions to the young gen
+ // we'll do when the GC locker is active.
+ size_t young_list_max_length = g1->g1_policy()->young_list_max_length();
+ assert(young_list_max_length >= survivor_list_length, "invariant");
+ size_t eden_list_max_length = young_list_max_length - survivor_list_length;
+
+ _overall_used = g1->used_unlocked();
+ _eden_used = eden_list_length * HeapRegion::GrainBytes;
+ _survivor_used = survivor_list_length * HeapRegion::GrainBytes;
+ _young_region_num = young_list_length;
+ _old_used = subtract_up_to_zero(_overall_used, _eden_used + _survivor_used);
+
+ // First calculate the committed sizes that can be calculated independently.
+ _survivor_committed = _survivor_used;
+ _old_committed = HeapRegion::align_up_to_region_byte_size(_old_used);
+
+ // Next, start with the overall committed size.
+ _overall_committed = g1->capacity();
+ size_t committed = _overall_committed;
+
+ // Remove the committed size we have calculated so far (for the
+ // survivor and old space).
+ assert(committed >= (_survivor_committed + _old_committed), "sanity");
+ committed -= _survivor_committed + _old_committed;
+
+ // Next, calculate and remove the committed size for the eden.
+ _eden_committed = eden_list_max_length * HeapRegion::GrainBytes;
+ // Somewhat defensive: be robust in case there are inaccuracies in
+ // the calculations
+ _eden_committed = MIN2(_eden_committed, committed);
+ committed -= _eden_committed;
+
+ // Finally, give the rest to the old space...
+ _old_committed += committed;
+ // ..and calculate the young gen committed.
+ _young_gen_committed = _eden_committed + _survivor_committed;
+
+ assert(_overall_committed ==
+ (_eden_committed + _survivor_committed + _old_committed),
+ "the committed sizes should add up");
+ // Somewhat defensive: cap the eden used size to make sure it
+ // never exceeds the committed size.
+ _eden_used = MIN2(_eden_used, _eden_committed);
+ // _survivor_committed and _old_committed are calculated in terms of
+ // the corresponding _*_used value, so the next two conditions
+ // should hold.
+ assert(_survivor_used <= _survivor_committed, "post-condition");
+ assert(_old_used <= _old_committed, "post-condition");
}
-size_t G1MonitoringSupport::overall_used() {
- return g1h()->used_unlocked();
-}
+void G1MonitoringSupport::recalculate_eden_size() {
+ G1CollectedHeap* g1 = g1h();
-size_t G1MonitoringSupport::eden_space_committed() {
- return MAX2(eden_space_used(), (size_t) HeapRegion::GrainBytes);
-}
+ // When a new eden region is allocated, only the eden_used size is
+ // affected (since we have recalculated everything else at the last GC).
-size_t G1MonitoringSupport::eden_space_used() {
- size_t young_list_length = g1h()->young_list()->length();
- size_t eden_used = young_list_length * HeapRegion::GrainBytes;
- size_t survivor_used = survivor_space_used();
- eden_used = subtract_up_to_zero(eden_used, survivor_used);
- return eden_used;
-}
-
-size_t G1MonitoringSupport::survivor_space_committed() {
- return MAX2(survivor_space_used(),
- (size_t) HeapRegion::GrainBytes);
-}
-
-size_t G1MonitoringSupport::survivor_space_used() {
- size_t survivor_num = g1h()->g1_policy()->recorded_survivor_regions();
- size_t survivor_used = survivor_num * HeapRegion::GrainBytes;
- return survivor_used;
-}
-
-size_t G1MonitoringSupport::old_space_committed() {
- size_t committed = overall_committed();
- size_t eden_committed = eden_space_committed();
- size_t survivor_committed = survivor_space_committed();
- committed = subtract_up_to_zero(committed, eden_committed);
- committed = subtract_up_to_zero(committed, survivor_committed);
- committed = MAX2(committed, (size_t) HeapRegion::GrainBytes);
- return committed;
-}
-
-// See the comment near the top of g1MonitoringSupport.hpp for
-// an explanation of these calculations for "used" and "capacity".
-size_t G1MonitoringSupport::old_space_used() {
- size_t used = overall_used();
- size_t eden_used = eden_space_used();
- size_t survivor_used = survivor_space_used();
- used = subtract_up_to_zero(used, eden_used);
- used = subtract_up_to_zero(used, survivor_used);
- return used;
-}
-
-void G1MonitoringSupport::update_counters() {
- if (UsePerfData) {
- eden_counters()->update_capacity(eden_space_committed());
- eden_counters()->update_used(eden_space_used());
- to_counters()->update_capacity(survivor_space_committed());
- to_counters()->update_used(survivor_space_used());
- old_space_counters()->update_capacity(old_space_committed());
- old_space_counters()->update_used(old_space_used());
- non_young_collection_counters()->update_all();
+ size_t young_region_num = g1h()->young_list()->length();
+ if (young_region_num > _young_region_num) {
+ size_t diff = young_region_num - _young_region_num;
+ _eden_used += diff * HeapRegion::GrainBytes;
+ // Somewhat defensive: cap the eden used size to make sure it
+ // never exceeds the committed size.
+ _eden_used = MIN2(_eden_used, _eden_committed);
+ _young_region_num = young_region_num;
}
}
-void G1MonitoringSupport::update_eden_counters() {
+void G1MonitoringSupport::update_sizes() {
+ recalculate_sizes();
if (UsePerfData) {
- eden_counters()->update_capacity(eden_space_committed());
+ eden_counters()->update_capacity(pad_capacity(eden_space_committed()));
+ eden_counters()->update_used(eden_space_used());
+ // only the to survivor space (s1) is active, so we don't need to
+ // update the counteres for the from survivor space (s0)
+ to_counters()->update_capacity(pad_capacity(survivor_space_committed()));
+ to_counters()->update_used(survivor_space_used());
+ old_space_counters()->update_capacity(pad_capacity(old_space_committed()));
+ old_space_counters()->update_used(old_space_used());
+ old_collection_counters()->update_all();
+ young_collection_counters()->update_all();
+ }
+}
+
+void G1MonitoringSupport::update_eden_size() {
+ recalculate_eden_size();
+ if (UsePerfData) {
eden_counters()->update_used(eden_space_used());
}
}
diff --git a/hotspot/src/share/vm/gc_implementation/g1/g1MonitoringSupport.hpp b/hotspot/src/share/vm/gc_implementation/g1/g1MonitoringSupport.hpp
index 61de266..3d124ce 100644
--- a/hotspot/src/share/vm/gc_implementation/g1/g1MonitoringSupport.hpp
+++ b/hotspot/src/share/vm/gc_implementation/g1/g1MonitoringSupport.hpp
@@ -28,101 +28,95 @@
#include "gc_implementation/shared/hSpaceCounters.hpp"
class G1CollectedHeap;
-class G1SpaceMonitoringSupport;
-// Class for monitoring logical spaces in G1.
-// G1 defines a set of regions as a young
-// collection (analogous to a young generation).
-// The young collection is a logical generation
-// with no fixed chunk (see space.hpp) reflecting
-// the address space for the generation. In addition
-// to the young collection there is its complement
-// the non-young collection that is simply the regions
-// not in the young collection. The non-young collection
-// is treated here as a logical old generation only
-// because the monitoring tools expect a generational
-// heap. The monitoring tools expect that a Space
-// (see space.hpp) exists that describe the
-// address space of young collection and non-young
-// collection and such a view is provided here.
+// Class for monitoring logical spaces in G1. It provides data for
+// both G1's jstat counters as well as G1's memory pools.
//
-// This class provides interfaces to access
-// the value of variables for the young collection
-// that include the "capacity" and "used" of the
-// young collection along with constant values
-// for the minimum and maximum capacities for
-// the logical spaces. Similarly for the non-young
-// collection.
+// G1 splits the heap into heap regions and each heap region belongs
+// to one of the following categories:
//
-// Also provided are counters for G1 concurrent collections
-// and stop-the-world full heap collecitons.
+// * eden : regions that have been allocated since the last GC
+// * survivors : regions with objects that survived the last few GCs
+// * old : long-lived non-humongous regions
+// * humongous : humongous regions
+// * free : free regions
//
-// Below is a description of how "used" and "capactiy"
-// (or committed) is calculated for the logical spaces.
+// The combination of eden and survivor regions form the equivalent of
+// the young generation in the other GCs. The combination of old and
+// humongous regions form the equivalent of the old generation in the
+// other GCs. Free regions do not have a good equivalent in the other
+// GCs given that they can be allocated as any of the other region types.
//
-// 1) The used space calculation for a pool is not necessarily
-// independent of the others. We can easily get from G1 the overall
-// used space in the entire heap, the number of regions in the young
-// generation (includes both eden and survivors), and the number of
-// survivor regions. So, from that we calculate:
+// The monitoring tools expect the heap to contain a number of
+// generations (young, old, perm) and each generation to contain a
+// number of spaces (young: eden, survivors, old). Given that G1 does
+// not maintain those spaces physically (e.g., the set of
+// non-contiguous eden regions can be considered as a "logical"
+// space), we'll provide the illusion that those generations and
+// spaces exist. In reality, each generation and space refers to a set
+// of heap regions that are potentially non-contiguous.
//
-// survivor_used = survivor_num * region_size
-// eden_used = young_region_num * region_size - survivor_used
-// old_gen_used = overall_used - eden_used - survivor_used
+// This class provides interfaces to access the min, current, and max
+// capacity and current occupancy for each of G1's logical spaces and
+// generations we expose to the monitoring tools. Also provided are
+// counters for G1 concurrent collections and stop-the-world full heap
+// collections.
//
-// Note that survivor_used and eden_used are upper bounds. To get the
-// actual value we would have to iterate over the regions and add up
-// ->used(). But that'd be expensive. So, we'll accept some lack of
-// accuracy for those two. But, we have to be careful when calculating
-// old_gen_used, in case we subtract from overall_used more then the
-// actual number and our result goes negative.
+// Below is a description of how the various sizes are calculated.
//
-// 2) Calculating the used space is straightforward, as described
-// above. However, how do we calculate the committed space, given that
-// we allocate space for the eden, survivor, and old gen out of the
-// same pool of regions? One way to do this is to use the used value
-// as also the committed value for the eden and survivor spaces and
-// then calculate the old gen committed space as follows:
+// * Current Capacity
//
-// old_gen_committed = overall_committed - eden_committed - survivor_committed
+// - heap_capacity = current heap capacity (e.g., current committed size)
+// - young_gen_capacity = current max young gen target capacity
+// (i.e., young gen target capacity + max allowed expansion capacity)
+// - survivor_capacity = current survivor region capacity
+// - eden_capacity = young_gen_capacity - survivor_capacity
+// - old_capacity = heap_capacity - young_gen_capacity
//
-// Maybe a better way to do that would be to calculate used for eden
-// and survivor as a sum of ->used() over their regions and then
-// calculate committed as region_num * region_size (i.e., what we use
-// to calculate the used space now). This is something to consider
-// in the future.
+// What we do in the above is to distribute the free regions among
+// eden_capacity and old_capacity.
//
-// 3) Another decision that is again not straightforward is what is
-// the max size that each memory pool can grow to. One way to do this
-// would be to use the committed size for the max for the eden and
-// survivors and calculate the old gen max as follows (basically, it's
-// a similar pattern to what we use for the committed space, as
-// described above):
+// * Occupancy
//
-// old_gen_max = overall_max - eden_max - survivor_max
+// - young_gen_used = current young region capacity
+// - survivor_used = survivor_capacity
+// - eden_used = young_gen_used - survivor_used
+// - old_used = overall_used - young_gen_used
//
-// Unfortunately, the above makes the max of each pool fluctuate over
-// time and, even though this is allowed according to the spec, it
-// broke several assumptions in the M&M framework (there were cases
-// where used would reach a value greater than max). So, for max we
-// use -1, which means "undefined" according to the spec.
+// Unfortunately, we currently only keep track of the number of
+// currently allocated young and survivor regions + the overall used
+// bytes in the heap, so the above can be a little inaccurate.
//
-// 4) Now, there is a very subtle issue with all the above. The
-// framework will call get_memory_usage() on the three pools
-// asynchronously. As a result, each call might get a different value
-// for, say, survivor_num which will yield inconsistent values for
-// eden_used, survivor_used, and old_gen_used (as survivor_num is used
-// in the calculation of all three). This would normally be
-// ok. However, it's possible that this might cause the sum of
-// eden_used, survivor_used, and old_gen_used to go over the max heap
-// size and this seems to sometimes cause JConsole (and maybe other
-// clients) to get confused. There's not a really an easy / clean
-// solution to this problem, due to the asynchrounous nature of the
-// framework.
+// * Min Capacity
+//
+// We set this to 0 for all spaces. We could consider setting the old
+// min capacity to the min capacity of the heap (see 7078465).
+//
+// * Max Capacity
+//
+// For jstat, we set the max capacity of all spaces to heap_capacity,
+// given that we don't always have a reasonably upper bound on how big
+// each space can grow. For the memory pools, we actually make the max
+// capacity undefined. We could consider setting the old max capacity
+// to the max capacity of the heap (see 7078465).
+//
+// If we had more accurate occupancy / capacity information per
+// region set the above calculations would be greatly simplified and
+// be made more accurate.
+//
+// We update all the above synchronously and we store the results in
+// fields so that we just read said fields when needed. A subtle point
+// is that all the above sizes need to be recalculated when the old
+// gen changes capacity (after a GC or after a humongous allocation)
+// but only the eden occupancy changes when a new eden region is
+// allocated. So, in the latter case we have minimal recalcuation to
+// do which is important as we want to keep the eden region allocation
+// path as low-overhead as possible.
class G1MonitoringSupport : public CHeapObj {
+ friend class VMStructs;
+
G1CollectedHeap* _g1h;
- VirtualSpace* _g1_storage_addr;
// jstat performance counters
// incremental collections both fully and partially young
@@ -133,9 +127,9 @@
// _from_counters, and _to_counters are associated with
// this "generational" counter.
GenerationCounters* _young_collection_counters;
- // non-young collection set counters. The _old_space_counters
+ // old collection set counters. The _old_space_counters
// below are associated with this "generational" counter.
- GenerationCounters* _non_young_collection_counters;
+ GenerationCounters* _old_collection_counters;
// Counters for the capacity and used for
// the whole heap
HSpaceCounters* _old_space_counters;
@@ -145,6 +139,27 @@
HSpaceCounters* _from_counters;
HSpaceCounters* _to_counters;
+ // When it's appropriate to recalculate the various sizes (at the
+ // end of a GC, when a new eden region is allocated, etc.) we store
+ // them here so that we can easily report them when needed and not
+ // have to recalculate them every time.
+
+ size_t _overall_reserved;
+ size_t _overall_committed;
+ size_t _overall_used;
+
+ size_t _young_region_num;
+ size_t _young_gen_committed;
+ size_t _eden_committed;
+ size_t _eden_used;
+ size_t _survivor_committed;
+ size_t _survivor_used;
+
+ size_t _old_committed;
+ size_t _old_used;
+
+ G1CollectedHeap* g1h() { return _g1h; }
+
// It returns x - y if x > y, 0 otherwise.
// As described in the comment above, some of the inputs to the
// calculations we have to do are obtained concurrently and hence
@@ -160,15 +175,35 @@
}
}
+ // Recalculate all the sizes.
+ void recalculate_sizes();
+ // Recalculate only what's necessary when a new eden region is allocated.
+ void recalculate_eden_size();
+
public:
- G1MonitoringSupport(G1CollectedHeap* g1h, VirtualSpace* g1_storage_addr);
+ G1MonitoringSupport(G1CollectedHeap* g1h);
- G1CollectedHeap* g1h() { return _g1h; }
- VirtualSpace* g1_storage_addr() { return _g1_storage_addr; }
+ // Unfortunately, the jstat tool assumes that no space has 0
+ // capacity. In our case, given that each space is logical, it's
+ // possible that no regions will be allocated to it, hence to have 0
+ // capacity (e.g., if there are no survivor regions, the survivor
+ // space has 0 capacity). The way we deal with this is to always pad
+ // each capacity value we report to jstat by a very small amount to
+ // make sure that it's never zero. Given that we sometimes have to
+ // report a capacity of a generation that contains several spaces
+ // (e.g., young gen includes one eden, two survivor spaces), the
+ // mult parameter is provided in order to adding the appropriate
+ // padding multiple times so that the capacities add up correctly.
+ static size_t pad_capacity(size_t size_bytes, size_t mult = 1) {
+ return size_bytes + MinObjAlignmentInBytes * mult;
+ }
- // Performance Counter accessors
- void update_counters();
- void update_eden_counters();
+ // Recalculate all the sizes from scratch and update all the jstat
+ // counters accordingly.
+ void update_sizes();
+ // Recalculate only what's necessary when a new eden region is
+ // allocated and update any jstat counters that need to be updated.
+ void update_eden_size();
CollectorCounters* incremental_collection_counters() {
return _incremental_collection_counters;
@@ -176,8 +211,11 @@
CollectorCounters* full_collection_counters() {
return _full_collection_counters;
}
- GenerationCounters* non_young_collection_counters() {
- return _non_young_collection_counters;
+ GenerationCounters* young_collection_counters() {
+ return _young_collection_counters;
+ }
+ GenerationCounters* old_collection_counters() {
+ return _old_collection_counters;
}
HSpaceCounters* old_space_counters() { return _old_space_counters; }
HSpaceCounters* eden_counters() { return _eden_counters; }
@@ -187,17 +225,45 @@
// Monitoring support used by
// MemoryService
// jstat counters
- size_t overall_committed();
- size_t overall_used();
- size_t eden_space_committed();
- size_t eden_space_used();
+ size_t overall_reserved() { return _overall_reserved; }
+ size_t overall_committed() { return _overall_committed; }
+ size_t overall_used() { return _overall_used; }
- size_t survivor_space_committed();
- size_t survivor_space_used();
+ size_t young_gen_committed() { return _young_gen_committed; }
+ size_t young_gen_max() { return overall_reserved(); }
+ size_t eden_space_committed() { return _eden_committed; }
+ size_t eden_space_used() { return _eden_used; }
+ size_t survivor_space_committed() { return _survivor_committed; }
+ size_t survivor_space_used() { return _survivor_used; }
- size_t old_space_committed();
- size_t old_space_used();
+ size_t old_gen_committed() { return old_space_committed(); }
+ size_t old_gen_max() { return overall_reserved(); }
+ size_t old_space_committed() { return _old_committed; }
+ size_t old_space_used() { return _old_used; }
+};
+
+class G1GenerationCounters: public GenerationCounters {
+protected:
+ G1MonitoringSupport* _g1mm;
+
+public:
+ G1GenerationCounters(G1MonitoringSupport* g1mm,
+ const char* name, int ordinal, int spaces,
+ size_t min_capacity, size_t max_capacity,
+ size_t curr_capacity);
+};
+
+class G1YoungGenerationCounters: public G1GenerationCounters {
+public:
+ G1YoungGenerationCounters(G1MonitoringSupport* g1mm, const char* name);
+ virtual void update_all();
+};
+
+class G1OldGenerationCounters: public G1GenerationCounters {
+public:
+ G1OldGenerationCounters(G1MonitoringSupport* g1mm, const char* name);
+ virtual void update_all();
};
#endif // SHARE_VM_GC_IMPLEMENTATION_G1_G1MONITORINGSUPPORT_HPP
diff --git a/hotspot/src/share/vm/gc_implementation/g1/g1OopClosures.hpp b/hotspot/src/share/vm/gc_implementation/g1/g1OopClosures.hpp
index d3f1ce2..ace59ea 100644
--- a/hotspot/src/share/vm/gc_implementation/g1/g1OopClosures.hpp
+++ b/hotspot/src/share/vm/gc_implementation/g1/g1OopClosures.hpp
@@ -34,6 +34,7 @@
class CMMarkStack;
class G1ParScanThreadState;
class CMTask;
+class ReferenceProcessor;
// A class that scans oops in a given heap region (much as OopsInGenClosure
// scans oops in a generation.)
@@ -59,8 +60,10 @@
class G1ParPushHeapRSClosure : public G1ParClosureSuper {
public:
- G1ParPushHeapRSClosure(G1CollectedHeap* g1, G1ParScanThreadState* par_scan_state) :
+ G1ParPushHeapRSClosure(G1CollectedHeap* g1,
+ G1ParScanThreadState* par_scan_state):
G1ParClosureSuper(g1, par_scan_state) { }
+
template <class T> void do_oop_nv(T* p);
virtual void do_oop(oop* p) { do_oop_nv(p); }
virtual void do_oop(narrowOop* p) { do_oop_nv(p); }
@@ -68,8 +71,13 @@
class G1ParScanClosure : public G1ParClosureSuper {
public:
- G1ParScanClosure(G1CollectedHeap* g1, G1ParScanThreadState* par_scan_state) :
- G1ParClosureSuper(g1, par_scan_state) { }
+ G1ParScanClosure(G1CollectedHeap* g1, G1ParScanThreadState* par_scan_state, ReferenceProcessor* rp) :
+ G1ParClosureSuper(g1, par_scan_state)
+ {
+ assert(_ref_processor == NULL, "sanity");
+ _ref_processor = rp;
+ }
+
template <class T> void do_oop_nv(T* p);
virtual void do_oop(oop* p) { do_oop_nv(p); }
virtual void do_oop(narrowOop* p) { do_oop_nv(p); }
@@ -92,9 +100,18 @@
class G1ParScanPartialArrayClosure : public G1ParClosureSuper {
G1ParScanClosure _scanner;
+
public:
- G1ParScanPartialArrayClosure(G1CollectedHeap* g1, G1ParScanThreadState* par_scan_state) :
- G1ParClosureSuper(g1, par_scan_state), _scanner(g1, par_scan_state) { }
+ G1ParScanPartialArrayClosure(G1CollectedHeap* g1, G1ParScanThreadState* par_scan_state, ReferenceProcessor* rp) :
+ G1ParClosureSuper(g1, par_scan_state), _scanner(g1, par_scan_state, rp)
+ {
+ assert(_ref_processor == NULL, "sanity");
+ }
+
+ G1ParScanClosure* scanner() {
+ return &_scanner;
+ }
+
template <class T> void do_oop_nv(T* p);
virtual void do_oop(oop* p) { do_oop_nv(p); }
virtual void do_oop(narrowOop* p) { do_oop_nv(p); }
@@ -105,7 +122,8 @@
G1ParScanClosure *_scanner;
protected:
template <class T> void mark_object(T* p);
- oop copy_to_survivor_space(oop obj, bool should_mark_copy);
+ oop copy_to_survivor_space(oop obj, bool should_mark_root,
+ bool should_mark_copy);
public:
G1ParCopyHelper(G1CollectedHeap* g1, G1ParScanThreadState* par_scan_state,
G1ParScanClosure *scanner) :
@@ -116,10 +134,20 @@
bool do_mark_object>
class G1ParCopyClosure : public G1ParCopyHelper {
G1ParScanClosure _scanner;
+
template <class T> void do_oop_work(T* p);
+
public:
- G1ParCopyClosure(G1CollectedHeap* g1, G1ParScanThreadState* par_scan_state) :
- _scanner(g1, par_scan_state), G1ParCopyHelper(g1, par_scan_state, &_scanner) { }
+ G1ParCopyClosure(G1CollectedHeap* g1, G1ParScanThreadState* par_scan_state,
+ ReferenceProcessor* rp) :
+ _scanner(g1, par_scan_state, rp),
+ G1ParCopyHelper(g1, par_scan_state, &_scanner)
+ {
+ assert(_ref_processor == NULL, "sanity");
+ }
+
+ G1ParScanClosure* scanner() { return &_scanner; }
+
template <class T> void do_oop_nv(T* p) {
do_oop_work(p);
}
@@ -129,21 +157,25 @@
typedef G1ParCopyClosure<false, G1BarrierNone, false> G1ParScanExtRootClosure;
typedef G1ParCopyClosure<true, G1BarrierNone, false> G1ParScanPermClosure;
-typedef G1ParCopyClosure<false, G1BarrierRS, false> G1ParScanHeapRSClosure;
+
typedef G1ParCopyClosure<false, G1BarrierNone, true> G1ParScanAndMarkExtRootClosure;
typedef G1ParCopyClosure<true, G1BarrierNone, true> G1ParScanAndMarkPermClosure;
-typedef G1ParCopyClosure<false, G1BarrierRS, true> G1ParScanAndMarkHeapRSClosure;
-// This is the only case when we set skip_cset_test. Basically, this
-// closure is (should?) only be called directly while we're draining
-// the overflow and task queues. In that case we know that the
-// reference in question points into the collection set, otherwise we
-// would not have pushed it on the queue. The following is defined in
-// g1_specialized_oop_closures.hpp.
-// typedef G1ParCopyClosure<false, G1BarrierEvac, false, true> G1ParScanHeapEvacClosure;
-// We need a separate closure to handle references during evacuation
-// failure processing, as we cannot asume that the reference already
-// points into the collection set (like G1ParScanHeapEvacClosure does).
+// The following closure types are no longer used but are retained
+// for historical reasons:
+// typedef G1ParCopyClosure<false, G1BarrierRS, false> G1ParScanHeapRSClosure;
+// typedef G1ParCopyClosure<false, G1BarrierRS, true> G1ParScanAndMarkHeapRSClosure;
+
+// The following closure type is defined in g1_specialized_oop_closures.hpp:
+//
+// typedef G1ParCopyClosure<false, G1BarrierEvac, false> G1ParScanHeapEvacClosure;
+
+// We use a separate closure to handle references during evacuation
+// failure processing.
+// We could have used another instance of G1ParScanHeapEvacClosure
+// (since that closure no longer assumes that the references it
+// handles point into the collection set).
+
typedef G1ParCopyClosure<false, G1BarrierEvac, false> G1ParScanHeapEvacFailureClosure;
class FilterIntoCSClosure: public OopClosure {
@@ -152,9 +184,10 @@
DirtyCardToOopClosure* _dcto_cl;
public:
FilterIntoCSClosure( DirtyCardToOopClosure* dcto_cl,
- G1CollectedHeap* g1, OopClosure* oc) :
- _dcto_cl(dcto_cl), _g1(g1), _oc(oc)
- {}
+ G1CollectedHeap* g1,
+ OopClosure* oc) :
+ _dcto_cl(dcto_cl), _g1(g1), _oc(oc) { }
+
template <class T> void do_oop_nv(T* p);
virtual void do_oop(oop* p) { do_oop_nv(p); }
virtual void do_oop(narrowOop* p) { do_oop_nv(p); }
diff --git a/hotspot/src/share/vm/gc_implementation/g1/g1RemSet.cpp b/hotspot/src/share/vm/gc_implementation/g1/g1RemSet.cpp
index 568bb64..1e6373c 100644
--- a/hotspot/src/share/vm/gc_implementation/g1/g1RemSet.cpp
+++ b/hotspot/src/share/vm/gc_implementation/g1/g1RemSet.cpp
@@ -234,6 +234,7 @@
HeapRegion *startRegion = calculateStartRegion(worker_i);
ScanRSClosure scanRScl(oc, worker_i);
+
_g1->collection_set_iterate_from(startRegion, &scanRScl);
scanRScl.set_try_claimed();
_g1->collection_set_iterate_from(startRegion, &scanRScl);
@@ -283,6 +284,7 @@
double start = os::elapsedTime();
// Apply the given closure to all remaining log entries.
RefineRecordRefsIntoCSCardTableEntryClosure into_cset_update_rs_cl(_g1, into_cset_dcq);
+
_g1->iterate_dirty_card_closure(&into_cset_update_rs_cl, into_cset_dcq, false, worker_i);
// Now there should be no dirty cards.
diff --git a/hotspot/src/share/vm/gc_implementation/g1/g1_globals.hpp b/hotspot/src/share/vm/gc_implementation/g1/g1_globals.hpp
index 1e2ab28..861c947 100644
--- a/hotspot/src/share/vm/gc_implementation/g1/g1_globals.hpp
+++ b/hotspot/src/share/vm/gc_implementation/g1/g1_globals.hpp
@@ -290,10 +290,6 @@
"each evacuation pause in order to artificially fill up the " \
"heap and stress the marking implementation.") \
\
- develop(bool, ReduceInitialCardMarksForG1, false, \
- "When ReduceInitialCardMarks is true, this flag setting " \
- " controls whether G1 allows the RICM optimization") \
- \
develop(bool, G1ExitOnExpansionFailure, false, \
"Raise a fatal VM exit out of memory failure in the event " \
" that heap expansion fails due to running out of swap.") \
diff --git a/hotspot/src/share/vm/gc_implementation/g1/heapRegion.cpp b/hotspot/src/share/vm/gc_implementation/g1/heapRegion.cpp
index ec42314..8230e61 100644
--- a/hotspot/src/share/vm/gc_implementation/g1/heapRegion.cpp
+++ b/hotspot/src/share/vm/gc_implementation/g1/heapRegion.cpp
@@ -33,11 +33,11 @@
#include "memory/iterator.hpp"
#include "oops/oop.inline.hpp"
-int HeapRegion::LogOfHRGrainBytes = 0;
-int HeapRegion::LogOfHRGrainWords = 0;
-int HeapRegion::GrainBytes = 0;
-int HeapRegion::GrainWords = 0;
-int HeapRegion::CardsPerRegion = 0;
+int HeapRegion::LogOfHRGrainBytes = 0;
+int HeapRegion::LogOfHRGrainWords = 0;
+size_t HeapRegion::GrainBytes = 0;
+size_t HeapRegion::GrainWords = 0;
+size_t HeapRegion::CardsPerRegion = 0;
HeapRegionDCTOC::HeapRegionDCTOC(G1CollectedHeap* g1,
HeapRegion* hr, OopClosure* cl,
@@ -45,7 +45,7 @@
FilterKind fk) :
ContiguousSpaceDCTOC(hr, cl, precision, NULL),
_hr(hr), _fk(fk), _g1(g1)
-{}
+{ }
FilterOutOfRegionClosure::FilterOutOfRegionClosure(HeapRegion* r,
OopClosure* oc) :
@@ -210,15 +210,17 @@
HeapWord* top,
OopClosure* cl) {
G1CollectedHeap* g1h = _g1;
-
int oop_size;
+ OopClosure* cl2 = NULL;
- OopClosure* cl2 = cl;
FilterIntoCSClosure intoCSFilt(this, g1h, cl);
FilterOutOfRegionClosure outOfRegionFilt(_hr, cl);
+
switch (_fk) {
+ case NoFilterKind: cl2 = cl; break;
case IntoCSFilterKind: cl2 = &intoCSFilt; break;
case OutOfRegionFilterKind: cl2 = &outOfRegionFilt; break;
+ default: ShouldNotReachHere();
}
// Start filtering what we add to the remembered set. If the object is
@@ -239,16 +241,19 @@
case NoFilterKind:
bottom = walk_mem_region_loop(cl, g1h, _hr, bottom, top);
break;
+
case IntoCSFilterKind: {
FilterIntoCSClosure filt(this, g1h, cl);
bottom = walk_mem_region_loop(&filt, g1h, _hr, bottom, top);
break;
}
+
case OutOfRegionFilterKind: {
FilterOutOfRegionClosure filt(_hr, cl);
bottom = walk_mem_region_loop(&filt, g1h, _hr, bottom, top);
break;
}
+
default:
ShouldNotReachHere();
}
@@ -317,11 +322,11 @@
guarantee(GrainBytes == 0, "we should only set it once");
// The cast to int is safe, given that we've bounded region_size by
// MIN_REGION_SIZE and MAX_REGION_SIZE.
- GrainBytes = (int) region_size;
+ GrainBytes = (size_t)region_size;
guarantee(GrainWords == 0, "we should only set it once");
GrainWords = GrainBytes >> LogHeapWordSize;
- guarantee(1 << LogOfHRGrainWords == GrainWords, "sanity");
+ guarantee((size_t)(1 << LogOfHRGrainWords) == GrainWords, "sanity");
guarantee(CardsPerRegion == 0, "we should only set it once");
CardsPerRegion = GrainBytes >> CardTableModRefBS::card_shift;
@@ -374,8 +379,7 @@
void HeapRegion::par_clear() {
assert(used() == 0, "the region should have been already cleared");
- assert(capacity() == (size_t) HeapRegion::GrainBytes,
- "should be back to normal");
+ assert(capacity() == HeapRegion::GrainBytes, "should be back to normal");
HeapRegionRemSet* hrrs = rem_set();
hrrs->clear();
CardTableModRefBS* ct_bs =
@@ -431,7 +435,7 @@
assert(end() == _orig_end, "sanity");
}
- assert(capacity() == (size_t) HeapRegion::GrainBytes, "pre-condition");
+ assert(capacity() == HeapRegion::GrainBytes, "pre-condition");
_humongous_type = NotHumongous;
_humongous_start_region = NULL;
}
@@ -483,12 +487,13 @@
HeapRegion(size_t hrs_index, G1BlockOffsetSharedArray* sharedOffsetArray,
MemRegion mr, bool is_zeroed)
: G1OffsetTableContigSpace(sharedOffsetArray, mr, is_zeroed),
- _next_fk(HeapRegionDCTOC::NoFilterKind), _hrs_index(hrs_index),
+ _hrs_index(hrs_index),
_humongous_type(NotHumongous), _humongous_start_region(NULL),
_in_collection_set(false),
_next_in_special_set(NULL), _orig_end(NULL),
_claimed(InitialClaimValue), _evacuation_failed(false),
_prev_marked_bytes(0), _next_marked_bytes(0), _sort_index(-1),
+ _gc_efficiency(0.0),
_young_type(NotYoung), _next_young_region(NULL),
_next_dirty_cards_region(NULL), _next(NULL), _pending_removal(false),
#ifdef ASSERT
diff --git a/hotspot/src/share/vm/gc_implementation/g1/heapRegion.hpp b/hotspot/src/share/vm/gc_implementation/g1/heapRegion.hpp
index 774987d..e7b3581 100644
--- a/hotspot/src/share/vm/gc_implementation/g1/heapRegion.hpp
+++ b/hotspot/src/share/vm/gc_implementation/g1/heapRegion.hpp
@@ -118,7 +118,6 @@
FilterKind fk);
};
-
// The complicating factor is that BlockOffsetTable diverged
// significantly, and we need functionality that is only in the G1 version.
// So I copied that code, which led to an alternate G1 version of
@@ -223,10 +222,6 @@
ContinuesHumongous
};
- // The next filter kind that should be used for a "new_dcto_cl" call with
- // the "traditional" signature.
- HeapRegionDCTOC::FilterKind _next_fk;
-
// Requires that the region "mr" be dense with objects, and begin and end
// with an object.
void oops_in_mr_iterate(MemRegion mr, OopClosure* cl);
@@ -351,16 +346,17 @@
G1BlockOffsetSharedArray* sharedOffsetArray,
MemRegion mr, bool is_zeroed);
- static int LogOfHRGrainBytes;
- static int LogOfHRGrainWords;
- // The normal type of these should be size_t. However, they used to
- // be members of an enum before and they are assumed by the
- // compilers to be ints. To avoid going and fixing all their uses,
- // I'm declaring them as ints. I'm not anticipating heap region
- // sizes to reach anywhere near 2g, so using an int here is safe.
- static int GrainBytes;
- static int GrainWords;
- static int CardsPerRegion;
+ static int LogOfHRGrainBytes;
+ static int LogOfHRGrainWords;
+
+ static size_t GrainBytes;
+ static size_t GrainWords;
+ static size_t CardsPerRegion;
+
+ static size_t align_up_to_region_byte_size(size_t sz) {
+ return (sz + (size_t) GrainBytes - 1) &
+ ~((1 << (size_t) LogOfHRGrainBytes) - 1);
+ }
// It sets up the heap region size (GrainBytes / GrainWords), as
// well as other related fields that are based on the heap region
@@ -573,40 +569,14 @@
// allocated in the current region before the last call to "save_mark".
void oop_before_save_marks_iterate(OopClosure* cl);
- // This call determines the "filter kind" argument that will be used for
- // the next call to "new_dcto_cl" on this region with the "traditional"
- // signature (i.e., the call below.) The default, in the absence of a
- // preceding call to this method, is "NoFilterKind", and a call to this
- // method is necessary for each such call, or else it reverts to the
- // default.
- // (This is really ugly, but all other methods I could think of changed a
- // lot of main-line code for G1.)
- void set_next_filter_kind(HeapRegionDCTOC::FilterKind nfk) {
- _next_fk = nfk;
- }
-
DirtyCardToOopClosure*
new_dcto_closure(OopClosure* cl,
CardTableModRefBS::PrecisionStyle precision,
HeapRegionDCTOC::FilterKind fk);
-#if WHASSUP
- DirtyCardToOopClosure*
- new_dcto_closure(OopClosure* cl,
- CardTableModRefBS::PrecisionStyle precision,
- HeapWord* boundary) {
- assert(boundary == NULL, "This arg doesn't make sense here.");
- DirtyCardToOopClosure* res = new_dcto_closure(cl, precision, _next_fk);
- _next_fk = HeapRegionDCTOC::NoFilterKind;
- return res;
- }
-#endif
-
- //
// Note the start or end of marking. This tells the heap region
// that the collector is about to start or has finished (concurrently)
// marking the heap.
- //
// Note the start of a marking phase. Record the
// start of the unmarked area of the region here.
diff --git a/hotspot/src/share/vm/gc_implementation/g1/heapRegionRemSet.cpp b/hotspot/src/share/vm/gc_implementation/g1/heapRegionRemSet.cpp
index 8c5f15e..a6fbce1 100644
--- a/hotspot/src/share/vm/gc_implementation/g1/heapRegionRemSet.cpp
+++ b/hotspot/src/share/vm/gc_implementation/g1/heapRegionRemSet.cpp
@@ -148,7 +148,7 @@
CardIdx_t from_card = (CardIdx_t)
hw_offset >> (CardTableModRefBS::card_shift - LogHeapWordSize);
- assert(0 <= from_card && from_card < HeapRegion::CardsPerRegion,
+ assert(0 <= from_card && (size_t)from_card < HeapRegion::CardsPerRegion,
"Must be in range.");
add_card_work(from_card, par);
}
@@ -639,7 +639,7 @@
uintptr_t(from_hr->bottom())
>> CardTableModRefBS::card_shift;
CardIdx_t card_index = from_card - from_hr_bot_card_index;
- assert(0 <= card_index && card_index < HeapRegion::CardsPerRegion,
+ assert(0 <= card_index && (size_t)card_index < HeapRegion::CardsPerRegion,
"Must be in range.");
if (G1HRRSUseSparseTable &&
_sparse_table.add_card(from_hrs_ind, card_index)) {
@@ -1066,7 +1066,7 @@
uintptr_t(hr->bottom()) >> CardTableModRefBS::card_shift;
assert(from_card >= hr_bot_card_index, "Inv");
CardIdx_t card_index = from_card - hr_bot_card_index;
- assert(0 <= card_index && card_index < HeapRegion::CardsPerRegion,
+ assert(0 <= card_index && (size_t)card_index < HeapRegion::CardsPerRegion,
"Must be in range.");
return _sparse_table.contains_card(hr_ind, card_index);
}
@@ -1191,7 +1191,7 @@
_is = Sparse;
// Set these values so that we increment to the first region.
_coarse_cur_region_index = -1;
- _coarse_cur_region_cur_card = (HeapRegion::CardsPerRegion-1);;
+ _coarse_cur_region_cur_card = (HeapRegion::CardsPerRegion-1);
_cur_region_cur_card = 0;
@@ -1270,7 +1270,7 @@
bool HeapRegionRemSetIterator::fine_has_next() {
return
_fine_cur_prt != NULL &&
- _cur_region_cur_card < (size_t) HeapRegion::CardsPerRegion;
+ _cur_region_cur_card < HeapRegion::CardsPerRegion;
}
bool HeapRegionRemSetIterator::has_next(size_t& card_index) {
diff --git a/hotspot/src/share/vm/gc_implementation/g1/heapRegionRemSet.hpp b/hotspot/src/share/vm/gc_implementation/g1/heapRegionRemSet.hpp
index 09adcfa..4534350 100644
--- a/hotspot/src/share/vm/gc_implementation/g1/heapRegionRemSet.hpp
+++ b/hotspot/src/share/vm/gc_implementation/g1/heapRegionRemSet.hpp
@@ -395,8 +395,8 @@
// Coarse table iteration fields:
// Current region index;
- int _coarse_cur_region_index;
- int _coarse_cur_region_cur_card;
+ int _coarse_cur_region_index;
+ size_t _coarse_cur_region_cur_card;
bool coarse_has_next(size_t& card_index);
diff --git a/hotspot/src/share/vm/gc_implementation/g1/heapRegionSeq.hpp b/hotspot/src/share/vm/gc_implementation/g1/heapRegionSeq.hpp
index c47b648..3df8d73 100644
--- a/hotspot/src/share/vm/gc_implementation/g1/heapRegionSeq.hpp
+++ b/hotspot/src/share/vm/gc_implementation/g1/heapRegionSeq.hpp
@@ -56,6 +56,7 @@
// and maintain that: _length <= _allocated_length <= _max_length
class HeapRegionSeq: public CHeapObj {
+ friend class VMStructs;
// The array that holds the HeapRegions.
HeapRegion** _regions;
diff --git a/hotspot/src/share/vm/gc_implementation/g1/satbQueue.cpp b/hotspot/src/share/vm/gc_implementation/g1/satbQueue.cpp
index 5a7a7b6..ea0c19a 100644
--- a/hotspot/src/share/vm/gc_implementation/g1/satbQueue.cpp
+++ b/hotspot/src/share/vm/gc_implementation/g1/satbQueue.cpp
@@ -29,6 +29,7 @@
#include "memory/sharedHeap.hpp"
#include "runtime/mutexLocker.hpp"
#include "runtime/thread.hpp"
+#include "runtime/vmThread.hpp"
// This method removes entries from an SATB buffer that will not be
// useful to the concurrent marking threads. An entry is removed if it
@@ -252,9 +253,18 @@
t->satb_mark_queue().apply_closure(_par_closures[worker]);
}
}
- // We'll have worker 0 do this one.
- if (worker == 0) {
- shared_satb_queue()->apply_closure(_par_closures[0]);
+
+ // We also need to claim the VMThread so that its parity is updated
+ // otherwise the next call to Thread::possibly_parallel_oops_do inside
+ // a StrongRootsScope might skip the VMThread because it has a stale
+ // parity that matches the parity set by the StrongRootsScope
+ //
+ // Whichever worker succeeds in claiming the VMThread gets to do
+ // the shared queue.
+
+ VMThread* vmt = VMThread::vm_thread();
+ if (vmt->claim_oops_do(true, parity)) {
+ shared_satb_queue()->apply_closure(_par_closures[worker]);
}
}
diff --git a/hotspot/src/share/vm/gc_implementation/g1/vmStructs_g1.hpp b/hotspot/src/share/vm/gc_implementation/g1/vmStructs_g1.hpp
new file mode 100644
index 0000000..63c0e94
--- /dev/null
+++ b/hotspot/src/share/vm/gc_implementation/g1/vmStructs_g1.hpp
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ *
+ */
+
+#ifndef SHARE_VM_GC_IMPLEMENTATION_G1_VMSTRUCTS_G1_HPP
+#define SHARE_VM_GC_IMPLEMENTATION_G1_VMSTRUCTS_G1_HPP
+
+#include "gc_implementation/g1/heapRegion.hpp"
+#include "gc_implementation/g1/heapRegionSeq.inline.hpp"
+#include "gc_implementation/g1/g1CollectedHeap.inline.hpp"
+
+#define VM_STRUCTS_G1(nonstatic_field, static_field) \
+ \
+ static_field(HeapRegion, GrainBytes, size_t) \
+ \
+ nonstatic_field(HeapRegionSeq, _regions, HeapRegion**) \
+ nonstatic_field(HeapRegionSeq, _length, size_t) \
+ \
+ nonstatic_field(G1CollectedHeap, _hrs, HeapRegionSeq) \
+ nonstatic_field(G1CollectedHeap, _g1_committed, MemRegion) \
+ nonstatic_field(G1CollectedHeap, _summary_bytes_used, size_t) \
+ nonstatic_field(G1CollectedHeap, _g1mm, G1MonitoringSupport*) \
+ \
+ nonstatic_field(G1MonitoringSupport, _eden_committed, size_t) \
+ nonstatic_field(G1MonitoringSupport, _eden_used, size_t) \
+ nonstatic_field(G1MonitoringSupport, _survivor_committed, size_t) \
+ nonstatic_field(G1MonitoringSupport, _survivor_used, size_t) \
+ nonstatic_field(G1MonitoringSupport, _old_committed, size_t) \
+ nonstatic_field(G1MonitoringSupport, _old_used, size_t) \
+
+
+#define VM_TYPES_G1(declare_type, declare_toplevel_type) \
+ \
+ declare_type(G1CollectedHeap, SharedHeap) \
+ \
+ declare_type(HeapRegion, ContiguousSpace) \
+ declare_toplevel_type(HeapRegionSeq) \
+ declare_toplevel_type(G1MonitoringSupport) \
+ \
+ declare_toplevel_type(G1CollectedHeap*) \
+ declare_toplevel_type(HeapRegion*) \
+ declare_toplevel_type(G1MonitoringSupport*) \
+
+
+#endif // SHARE_VM_GC_IMPLEMENTATION_G1_VMSTRUCTS_G1_HPP
diff --git a/hotspot/src/share/vm/gc_implementation/parallelScavenge/psMarkSweep.cpp b/hotspot/src/share/vm/gc_implementation/parallelScavenge/psMarkSweep.cpp
index 3d7e0ba..f2965e6 100644
--- a/hotspot/src/share/vm/gc_implementation/parallelScavenge/psMarkSweep.cpp
+++ b/hotspot/src/share/vm/gc_implementation/parallelScavenge/psMarkSweep.cpp
@@ -198,10 +198,9 @@
allocate_stacks();
- NOT_PRODUCT(ref_processor()->verify_no_references_recorded());
COMPILER2_PRESENT(DerivedPointerTable::clear());
- ref_processor()->enable_discovery();
+ ref_processor()->enable_discovery(true /*verify_disabled*/, true /*verify_no_refs*/);
ref_processor()->setup_policy(clear_all_softrefs);
mark_sweep_phase1(clear_all_softrefs);
diff --git a/hotspot/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.cpp b/hotspot/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.cpp
index 55cb343..a62059c 100644
--- a/hotspot/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.cpp
+++ b/hotspot/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.cpp
@@ -2069,10 +2069,9 @@
CodeCache::gc_prologue();
Threads::gc_prologue();
- NOT_PRODUCT(ref_processor()->verify_no_references_recorded());
COMPILER2_PRESENT(DerivedPointerTable::clear());
- ref_processor()->enable_discovery();
+ ref_processor()->enable_discovery(true /*verify_disabled*/, true /*verify_no_refs*/);
ref_processor()->setup_policy(maximum_heap_compaction);
bool marked_for_unloading = false;
diff --git a/hotspot/src/share/vm/gc_implementation/parallelScavenge/psPromotionLAB.cpp b/hotspot/src/share/vm/gc_implementation/parallelScavenge/psPromotionLAB.cpp
index 3569ed7..fc05b2e 100644
--- a/hotspot/src/share/vm/gc_implementation/parallelScavenge/psPromotionLAB.cpp
+++ b/hotspot/src/share/vm/gc_implementation/parallelScavenge/psPromotionLAB.cpp
@@ -102,17 +102,15 @@
_state = flushed;
}
-bool PSPromotionLAB::unallocate_object(oop obj) {
+bool PSPromotionLAB::unallocate_object(HeapWord* obj, size_t obj_size) {
assert(Universe::heap()->is_in(obj), "Object outside heap");
if (contains(obj)) {
- HeapWord* object_end = (HeapWord*)obj + obj->size();
- assert(object_end <= top(), "Object crosses promotion LAB boundary");
+ HeapWord* object_end = obj + obj_size;
+ assert(object_end == top(), "Not matching last allocation");
- if (object_end == top()) {
- set_top((HeapWord*)obj);
- return true;
- }
+ set_top(obj);
+ return true;
}
return false;
diff --git a/hotspot/src/share/vm/gc_implementation/parallelScavenge/psPromotionLAB.hpp b/hotspot/src/share/vm/gc_implementation/parallelScavenge/psPromotionLAB.hpp
index bed0c0c..fd6a7bf 100644
--- a/hotspot/src/share/vm/gc_implementation/parallelScavenge/psPromotionLAB.hpp
+++ b/hotspot/src/share/vm/gc_implementation/parallelScavenge/psPromotionLAB.hpp
@@ -73,7 +73,7 @@
bool is_flushed() { return _state == flushed; }
- bool unallocate_object(oop obj);
+ bool unallocate_object(HeapWord* obj, size_t obj_size);
// Returns a subregion containing all objects in this space.
MemRegion used_region() { return MemRegion(bottom(), top()); }
diff --git a/hotspot/src/share/vm/gc_implementation/parallelScavenge/psPromotionManager.cpp b/hotspot/src/share/vm/gc_implementation/parallelScavenge/psPromotionManager.cpp
index ad58a90..255bb8e 100644
--- a/hotspot/src/share/vm/gc_implementation/parallelScavenge/psPromotionManager.cpp
+++ b/hotspot/src/share/vm/gc_implementation/parallelScavenge/psPromotionManager.cpp
@@ -380,10 +380,10 @@
// deallocate it, so we have to test. If the deallocation fails,
// overwrite with a filler object.
if (new_obj_is_tenured) {
- if (!_old_lab.unallocate_object(new_obj)) {
+ if (!_old_lab.unallocate_object((HeapWord*) new_obj, new_obj_size)) {
CollectedHeap::fill_with_object((HeapWord*) new_obj, new_obj_size);
}
- } else if (!_young_lab.unallocate_object(new_obj)) {
+ } else if (!_young_lab.unallocate_object((HeapWord*) new_obj, new_obj_size)) {
CollectedHeap::fill_with_object((HeapWord*) new_obj, new_obj_size);
}
diff --git a/hotspot/src/share/vm/gc_implementation/parallelScavenge/psScavenge.cpp b/hotspot/src/share/vm/gc_implementation/parallelScavenge/psScavenge.cpp
index b223467..1094d17 100644
--- a/hotspot/src/share/vm/gc_implementation/parallelScavenge/psScavenge.cpp
+++ b/hotspot/src/share/vm/gc_implementation/parallelScavenge/psScavenge.cpp
@@ -350,10 +350,9 @@
}
save_to_space_top_before_gc();
- NOT_PRODUCT(reference_processor()->verify_no_references_recorded());
COMPILER2_PRESENT(DerivedPointerTable::clear());
- reference_processor()->enable_discovery();
+ reference_processor()->enable_discovery(true /*verify_disabled*/, true /*verify_no_refs*/);
reference_processor()->setup_policy(false);
// We track how much was promoted to the next generation for
diff --git a/hotspot/src/share/vm/gc_implementation/shared/generationCounters.cpp b/hotspot/src/share/vm/gc_implementation/shared/generationCounters.cpp
index f07f486..68ab6ff 100644
--- a/hotspot/src/share/vm/gc_implementation/shared/generationCounters.cpp
+++ b/hotspot/src/share/vm/gc_implementation/shared/generationCounters.cpp
@@ -26,14 +26,10 @@
#include "gc_implementation/shared/generationCounters.hpp"
#include "memory/resourceArea.hpp"
-
-GenerationCounters::GenerationCounters(const char* name,
- int ordinal, int spaces,
- VirtualSpace* v):
- _virtual_space(v) {
-
+void GenerationCounters::initialize(const char* name, int ordinal, int spaces,
+ size_t min_capacity, size_t max_capacity,
+ size_t curr_capacity) {
if (UsePerfData) {
-
EXCEPTION_MARK;
ResourceMark rm;
@@ -51,18 +47,37 @@
cname = PerfDataManager::counter_name(_name_space, "minCapacity");
PerfDataManager::create_constant(SUN_GC, cname, PerfData::U_Bytes,
- _virtual_space == NULL ? 0 :
- _virtual_space->committed_size(), CHECK);
+ min_capacity, CHECK);
cname = PerfDataManager::counter_name(_name_space, "maxCapacity");
PerfDataManager::create_constant(SUN_GC, cname, PerfData::U_Bytes,
- _virtual_space == NULL ? 0 :
- _virtual_space->reserved_size(), CHECK);
+ max_capacity, CHECK);
cname = PerfDataManager::counter_name(_name_space, "capacity");
- _current_size = PerfDataManager::create_variable(SUN_GC, cname,
- PerfData::U_Bytes,
- _virtual_space == NULL ? 0 :
- _virtual_space->committed_size(), CHECK);
+ _current_size =
+ PerfDataManager::create_variable(SUN_GC, cname, PerfData::U_Bytes,
+ curr_capacity, CHECK);
}
}
+
+GenerationCounters::GenerationCounters(const char* name,
+ int ordinal, int spaces,
+ VirtualSpace* v)
+ : _virtual_space(v) {
+ assert(v != NULL, "don't call this constructor if v == NULL");
+ initialize(name, ordinal, spaces,
+ v->committed_size(), v->reserved_size(), v->committed_size());
+}
+
+GenerationCounters::GenerationCounters(const char* name,
+ int ordinal, int spaces,
+ size_t min_capacity, size_t max_capacity,
+ size_t curr_capacity)
+ : _virtual_space(NULL) {
+ initialize(name, ordinal, spaces, min_capacity, max_capacity, curr_capacity);
+}
+
+void GenerationCounters::update_all() {
+ assert(_virtual_space != NULL, "otherwise, override this method");
+ _current_size->set_value(_virtual_space->committed_size());
+}
diff --git a/hotspot/src/share/vm/gc_implementation/shared/generationCounters.hpp b/hotspot/src/share/vm/gc_implementation/shared/generationCounters.hpp
index 21f7691..f399b95 100644
--- a/hotspot/src/share/vm/gc_implementation/shared/generationCounters.hpp
+++ b/hotspot/src/share/vm/gc_implementation/shared/generationCounters.hpp
@@ -34,6 +34,11 @@
class GenerationCounters: public CHeapObj {
friend class VMStructs;
+private:
+ void initialize(const char* name, int ordinal, int spaces,
+ size_t min_capacity, size_t max_capacity,
+ size_t curr_capacity);
+
protected:
PerfVariable* _current_size;
VirtualSpace* _virtual_space;
@@ -48,11 +53,18 @@
char* _name_space;
// This constructor is only meant for use with the PSGenerationCounters
- // constructor. The need for such an constructor should be eliminated
+ // constructor. The need for such an constructor should be eliminated
// when VirtualSpace and PSVirtualSpace are unified.
- GenerationCounters() : _name_space(NULL), _current_size(NULL), _virtual_space(NULL) {}
- public:
+ GenerationCounters()
+ : _name_space(NULL), _current_size(NULL), _virtual_space(NULL) {}
+ // This constructor is used for subclasses that do not have a space
+ // associated with them (e.g, in G1).
+ GenerationCounters(const char* name, int ordinal, int spaces,
+ size_t min_capacity, size_t max_capacity,
+ size_t curr_capacity);
+
+ public:
GenerationCounters(const char* name, int ordinal, int spaces,
VirtualSpace* v);
@@ -60,10 +72,7 @@
if (_name_space != NULL) FREE_C_HEAP_ARRAY(char, _name_space);
}
- virtual void update_all() {
- _current_size->set_value(_virtual_space == NULL ? 0 :
- _virtual_space->committed_size());
- }
+ virtual void update_all();
const char* name_space() const { return _name_space; }
diff --git a/hotspot/src/share/vm/memory/genCollectedHeap.cpp b/hotspot/src/share/vm/memory/genCollectedHeap.cpp
index f233cbc..d6a54e1 100644
--- a/hotspot/src/share/vm/memory/genCollectedHeap.cpp
+++ b/hotspot/src/share/vm/memory/genCollectedHeap.cpp
@@ -599,8 +599,7 @@
// atomic wrt other collectors in this configuration, we
// are guaranteed to have empty discovered ref lists.
if (rp->discovery_is_atomic()) {
- rp->verify_no_references_recorded();
- rp->enable_discovery();
+ rp->enable_discovery(true /*verify_disabled*/, true /*verify_no_refs*/);
rp->setup_policy(do_clear_all_soft_refs);
} else {
// collect() below will enable discovery as appropriate
diff --git a/hotspot/src/share/vm/memory/referencePolicy.cpp b/hotspot/src/share/vm/memory/referencePolicy.cpp
index 2af4368..a667332 100644
--- a/hotspot/src/share/vm/memory/referencePolicy.cpp
+++ b/hotspot/src/share/vm/memory/referencePolicy.cpp
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2000, 2010, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2000, 2011, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -41,8 +41,9 @@
// The oop passed in is the SoftReference object, and not
// the object the SoftReference points to.
-bool LRUCurrentHeapPolicy::should_clear_reference(oop p) {
- jlong interval = java_lang_ref_SoftReference::clock() - java_lang_ref_SoftReference::timestamp(p);
+bool LRUCurrentHeapPolicy::should_clear_reference(oop p,
+ jlong timestamp_clock) {
+ jlong interval = timestamp_clock - java_lang_ref_SoftReference::timestamp(p);
assert(interval >= 0, "Sanity check");
// The interval will be zero if the ref was accessed since the last scavenge/gc.
@@ -71,8 +72,9 @@
// The oop passed in is the SoftReference object, and not
// the object the SoftReference points to.
-bool LRUMaxHeapPolicy::should_clear_reference(oop p) {
- jlong interval = java_lang_ref_SoftReference::clock() - java_lang_ref_SoftReference::timestamp(p);
+bool LRUMaxHeapPolicy::should_clear_reference(oop p,
+ jlong timestamp_clock) {
+ jlong interval = timestamp_clock - java_lang_ref_SoftReference::timestamp(p);
assert(interval >= 0, "Sanity check");
// The interval will be zero if the ref was accessed since the last scavenge/gc.
diff --git a/hotspot/src/share/vm/memory/referencePolicy.hpp b/hotspot/src/share/vm/memory/referencePolicy.hpp
index 9672ed9..6616f25 100644
--- a/hotspot/src/share/vm/memory/referencePolicy.hpp
+++ b/hotspot/src/share/vm/memory/referencePolicy.hpp
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2000, 2010, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2000, 2011, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -31,19 +31,27 @@
class ReferencePolicy : public CHeapObj {
public:
- virtual bool should_clear_reference(oop p) { ShouldNotReachHere(); return true; }
+ virtual bool should_clear_reference(oop p, jlong timestamp_clock) {
+ ShouldNotReachHere();
+ return true;
+ }
+
// Capture state (of-the-VM) information needed to evaluate the policy
virtual void setup() { /* do nothing */ }
};
class NeverClearPolicy : public ReferencePolicy {
public:
- bool should_clear_reference(oop p) { return false; }
+ virtual bool should_clear_reference(oop p, jlong timestamp_clock) {
+ return false;
+ }
};
class AlwaysClearPolicy : public ReferencePolicy {
public:
- bool should_clear_reference(oop p) { return true; }
+ virtual bool should_clear_reference(oop p, jlong timestamp_clock) {
+ return true;
+ }
};
class LRUCurrentHeapPolicy : public ReferencePolicy {
@@ -55,7 +63,7 @@
// Capture state (of-the-VM) information needed to evaluate the policy
void setup();
- bool should_clear_reference(oop p);
+ virtual bool should_clear_reference(oop p, jlong timestamp_clock);
};
class LRUMaxHeapPolicy : public ReferencePolicy {
@@ -67,7 +75,7 @@
// Capture state (of-the-VM) information needed to evaluate the policy
void setup();
- bool should_clear_reference(oop p);
+ virtual bool should_clear_reference(oop p, jlong timestamp_clock);
};
#endif // SHARE_VM_MEMORY_REFERENCEPOLICY_HPP
diff --git a/hotspot/src/share/vm/memory/referenceProcessor.cpp b/hotspot/src/share/vm/memory/referenceProcessor.cpp
index 9b593ef..f78fc9f 100644
--- a/hotspot/src/share/vm/memory/referenceProcessor.cpp
+++ b/hotspot/src/share/vm/memory/referenceProcessor.cpp
@@ -35,49 +35,20 @@
ReferencePolicy* ReferenceProcessor::_always_clear_soft_ref_policy = NULL;
ReferencePolicy* ReferenceProcessor::_default_soft_ref_policy = NULL;
-const int subclasses_of_ref = REF_PHANTOM - REF_OTHER;
bool ReferenceProcessor::_pending_list_uses_discovered_field = false;
-
-// List of discovered references.
-class DiscoveredList {
-public:
- DiscoveredList() : _len(0), _compressed_head(0), _oop_head(NULL) { }
- oop head() const {
- return UseCompressedOops ? oopDesc::decode_heap_oop(_compressed_head) :
- _oop_head;
- }
- HeapWord* adr_head() {
- return UseCompressedOops ? (HeapWord*)&_compressed_head :
- (HeapWord*)&_oop_head;
- }
- void set_head(oop o) {
- if (UseCompressedOops) {
- // Must compress the head ptr.
- _compressed_head = oopDesc::encode_heap_oop(o);
- } else {
- _oop_head = o;
- }
- }
- bool empty() const { return head() == NULL; }
- size_t length() { return _len; }
- void set_length(size_t len) { _len = len; }
- void inc_length(size_t inc) { _len += inc; assert(_len > 0, "Error"); }
- void dec_length(size_t dec) { _len -= dec; }
-private:
- // Set value depending on UseCompressedOops. This could be a template class
- // but then we have to fix all the instantiations and declarations that use this class.
- oop _oop_head;
- narrowOop _compressed_head;
- size_t _len;
-};
+jlong ReferenceProcessor::_soft_ref_timestamp_clock = 0;
void referenceProcessor_init() {
ReferenceProcessor::init_statics();
}
void ReferenceProcessor::init_statics() {
- // Initialize the master soft ref clock.
- java_lang_ref_SoftReference::set_clock(os::javaTimeMillis());
+ jlong now = os::javaTimeMillis();
+
+ // Initialize the soft ref timestamp clock.
+ _soft_ref_timestamp_clock = now;
+ // Also update the soft ref clock in j.l.r.SoftReference
+ java_lang_ref_SoftReference::set_clock(_soft_ref_timestamp_clock);
_always_clear_soft_ref_policy = new AlwaysClearPolicy();
_default_soft_ref_policy = new COMPILER2_PRESENT(LRUMaxHeapPolicy())
@@ -91,6 +62,28 @@
_pending_list_uses_discovered_field = JDK_Version::current().pending_list_uses_discovered_field();
}
+void ReferenceProcessor::enable_discovery(bool verify_disabled, bool check_no_refs) {
+#ifdef ASSERT
+ // Verify that we're not currently discovering refs
+ assert(!verify_disabled || !_discovering_refs, "nested call?");
+
+ if (check_no_refs) {
+ // Verify that the discovered lists are empty
+ verify_no_references_recorded();
+ }
+#endif // ASSERT
+
+ // Someone could have modified the value of the static
+ // field in the j.l.r.SoftReference class that holds the
+ // soft reference timestamp clock using reflection or
+ // Unsafe between GCs. Unconditionally update the static
+ // field in ReferenceProcessor here so that we use the new
+ // value during reference discovery.
+
+ _soft_ref_timestamp_clock = java_lang_ref_SoftReference::clock();
+ _discovering_refs = true;
+}
+
ReferenceProcessor::ReferenceProcessor(MemRegion span,
bool mt_processing,
int mt_processing_degree,
@@ -112,7 +105,8 @@
_discovery_is_mt = mt_discovery;
_num_q = MAX2(1, mt_processing_degree);
_max_num_q = MAX2(_num_q, mt_discovery_degree);
- _discoveredSoftRefs = NEW_C_HEAP_ARRAY(DiscoveredList, _max_num_q * subclasses_of_ref);
+ _discoveredSoftRefs = NEW_C_HEAP_ARRAY(DiscoveredList,
+ _max_num_q * number_of_subclasses_of_ref());
if (_discoveredSoftRefs == NULL) {
vm_exit_during_initialization("Could not allocated RefProc Array");
}
@@ -120,7 +114,7 @@
_discoveredFinalRefs = &_discoveredWeakRefs[_max_num_q];
_discoveredPhantomRefs = &_discoveredFinalRefs[_max_num_q];
// Initialized all entries to NULL
- for (int i = 0; i < _max_num_q * subclasses_of_ref; i++) {
+ for (int i = 0; i < _max_num_q * number_of_subclasses_of_ref(); i++) {
_discoveredSoftRefs[i].set_head(NULL);
_discoveredSoftRefs[i].set_length(0);
}
@@ -134,19 +128,15 @@
#ifndef PRODUCT
void ReferenceProcessor::verify_no_references_recorded() {
guarantee(!_discovering_refs, "Discovering refs?");
- for (int i = 0; i < _max_num_q * subclasses_of_ref; i++) {
- guarantee(_discoveredSoftRefs[i].empty(),
+ for (int i = 0; i < _max_num_q * number_of_subclasses_of_ref(); i++) {
+ guarantee(_discoveredSoftRefs[i].is_empty(),
"Found non-empty discovered list");
}
}
#endif
void ReferenceProcessor::weak_oops_do(OopClosure* f) {
- // Should this instead be
- // for (int i = 0; i < subclasses_of_ref; i++_ {
- // for (int j = 0; j < _num_q; j++) {
- // int index = i * _max_num_q + j;
- for (int i = 0; i < _max_num_q * subclasses_of_ref; i++) {
+ for (int i = 0; i < _max_num_q * number_of_subclasses_of_ref(); i++) {
if (UseCompressedOops) {
f->do_oop((narrowOop*)_discoveredSoftRefs[i].adr_head());
} else {
@@ -159,17 +149,21 @@
// Update (advance) the soft ref master clock field. This must be done
// after processing the soft ref list.
jlong now = os::javaTimeMillis();
- jlong clock = java_lang_ref_SoftReference::clock();
+ jlong soft_ref_clock = java_lang_ref_SoftReference::clock();
+ assert(soft_ref_clock == _soft_ref_timestamp_clock, "soft ref clocks out of sync");
+
NOT_PRODUCT(
- if (now < clock) {
- warning("time warp: %d to %d", clock, now);
+ if (now < _soft_ref_timestamp_clock) {
+ warning("time warp: "INT64_FORMAT" to "INT64_FORMAT,
+ _soft_ref_timestamp_clock, now);
}
)
// In product mode, protect ourselves from system time being adjusted
// externally and going backward; see note in the implementation of
// GenCollectedHeap::time_since_last_gc() for the right way to fix
// this uniformly throughout the VM; see bug-id 4741166. XXX
- if (now > clock) {
+ if (now > _soft_ref_timestamp_clock) {
+ _soft_ref_timestamp_clock = now;
java_lang_ref_SoftReference::set_clock(now);
}
// Else leave clock stalled at its old value until time progresses
@@ -187,6 +181,16 @@
// Stop treating discovered references specially.
disable_discovery();
+ // If discovery was concurrent, someone could have modified
+ // the value of the static field in the j.l.r.SoftReference
+ // class that holds the soft reference timestamp clock using
+ // reflection or Unsafe between when discovery was enabled and
+ // now. Unconditionally update the static field in ReferenceProcessor
+ // here so that we use the new value during processing of the
+ // discovered soft refs.
+
+ _soft_ref_timestamp_clock = java_lang_ref_SoftReference::clock();
+
bool trace_time = PrintGCDetails && PrintReferenceGC;
// Soft references
{
@@ -404,7 +408,7 @@
// allocated and are indexed into.
assert(_n_queues == (int) _ref_processor.max_num_q(), "Different number not expected");
for (int j = 0;
- j < subclasses_of_ref;
+ j < ReferenceProcessor::number_of_subclasses_of_ref();
j++, index += _n_queues) {
_ref_processor.enqueue_discovered_reflist(
_refs_lists[index], _pending_list_addr);
@@ -424,7 +428,7 @@
task_executor->execute(tsk);
} else {
// Serial code: call the parent class's implementation
- for (int i = 0; i < _max_num_q * subclasses_of_ref; i++) {
+ for (int i = 0; i < _max_num_q * number_of_subclasses_of_ref(); i++) {
enqueue_discovered_reflist(_discoveredSoftRefs[i], pending_list_addr);
_discoveredSoftRefs[i].set_head(NULL);
_discoveredSoftRefs[i].set_length(0);
@@ -432,119 +436,7 @@
}
}
-// Iterator for the list of discovered references.
-class DiscoveredListIterator {
-public:
- inline DiscoveredListIterator(DiscoveredList& refs_list,
- OopClosure* keep_alive,
- BoolObjectClosure* is_alive);
-
- // End Of List.
- inline bool has_next() const { return _ref != NULL; }
-
- // Get oop to the Reference object.
- inline oop obj() const { return _ref; }
-
- // Get oop to the referent object.
- inline oop referent() const { return _referent; }
-
- // Returns true if referent is alive.
- inline bool is_referent_alive() const;
-
- // Loads data for the current reference.
- // The "allow_null_referent" argument tells us to allow for the possibility
- // of a NULL referent in the discovered Reference object. This typically
- // happens in the case of concurrent collectors that may have done the
- // discovery concurrently, or interleaved, with mutator execution.
- inline void load_ptrs(DEBUG_ONLY(bool allow_null_referent));
-
- // Move to the next discovered reference.
- inline void next();
-
- // Remove the current reference from the list
- inline void remove();
-
- // Make the Reference object active again.
- inline void make_active() { java_lang_ref_Reference::set_next(_ref, NULL); }
-
- // Make the referent alive.
- inline void make_referent_alive() {
- if (UseCompressedOops) {
- _keep_alive->do_oop((narrowOop*)_referent_addr);
- } else {
- _keep_alive->do_oop((oop*)_referent_addr);
- }
- }
-
- // Update the discovered field.
- inline void update_discovered() {
- // First _prev_next ref actually points into DiscoveredList (gross).
- if (UseCompressedOops) {
- if (!oopDesc::is_null(*(narrowOop*)_prev_next)) {
- _keep_alive->do_oop((narrowOop*)_prev_next);
- }
- } else {
- if (!oopDesc::is_null(*(oop*)_prev_next)) {
- _keep_alive->do_oop((oop*)_prev_next);
- }
- }
- }
-
- // NULL out referent pointer.
- inline void clear_referent() { oop_store_raw(_referent_addr, NULL); }
-
- // Statistics
- NOT_PRODUCT(
- inline size_t processed() const { return _processed; }
- inline size_t removed() const { return _removed; }
- )
-
- inline void move_to_next();
-
-private:
- DiscoveredList& _refs_list;
- HeapWord* _prev_next;
- oop _prev;
- oop _ref;
- HeapWord* _discovered_addr;
- oop _next;
- HeapWord* _referent_addr;
- oop _referent;
- OopClosure* _keep_alive;
- BoolObjectClosure* _is_alive;
- DEBUG_ONLY(
- oop _first_seen; // cyclic linked list check
- )
- NOT_PRODUCT(
- size_t _processed;
- size_t _removed;
- )
-};
-
-inline DiscoveredListIterator::DiscoveredListIterator(DiscoveredList& refs_list,
- OopClosure* keep_alive,
- BoolObjectClosure* is_alive)
- : _refs_list(refs_list),
- _prev_next(refs_list.adr_head()),
- _prev(NULL),
- _ref(refs_list.head()),
-#ifdef ASSERT
- _first_seen(refs_list.head()),
-#endif
-#ifndef PRODUCT
- _processed(0),
- _removed(0),
-#endif
- _next(NULL),
- _keep_alive(keep_alive),
- _is_alive(is_alive)
-{ }
-
-inline bool DiscoveredListIterator::is_referent_alive() const {
- return _is_alive->do_object_b(_referent);
-}
-
-inline void DiscoveredListIterator::load_ptrs(DEBUG_ONLY(bool allow_null_referent)) {
+void DiscoveredListIterator::load_ptrs(DEBUG_ONLY(bool allow_null_referent)) {
_discovered_addr = java_lang_ref_Reference::discovered_addr(_ref);
oop discovered = java_lang_ref_Reference::discovered(_ref);
assert(_discovered_addr && discovered->is_oop_or_null(),
@@ -560,13 +452,7 @@
"bad referent");
}
-inline void DiscoveredListIterator::next() {
- _prev_next = _discovered_addr;
- _prev = _ref;
- move_to_next();
-}
-
-inline void DiscoveredListIterator::remove() {
+void DiscoveredListIterator::remove() {
assert(_ref->is_oop(), "Dropping a bad reference");
oop_store_raw(_discovered_addr, NULL);
@@ -592,15 +478,29 @@
_refs_list.dec_length(1);
}
-inline void DiscoveredListIterator::move_to_next() {
- if (_ref == _next) {
- // End of the list.
- _ref = NULL;
+// Make the Reference object active again.
+void DiscoveredListIterator::make_active() {
+ // For G1 we don't want to use set_next - it
+ // will dirty the card for the next field of
+ // the reference object and will fail
+ // CT verification.
+ if (UseG1GC) {
+ BarrierSet* bs = oopDesc::bs();
+ HeapWord* next_addr = java_lang_ref_Reference::next_addr(_ref);
+
+ if (UseCompressedOops) {
+ bs->write_ref_field_pre((narrowOop*)next_addr, NULL);
+ } else {
+ bs->write_ref_field_pre((oop*)next_addr, NULL);
+ }
+ java_lang_ref_Reference::set_next_raw(_ref, NULL);
} else {
- _ref = _next;
+ java_lang_ref_Reference::set_next(_ref, NULL);
}
- assert(_ref != _first_seen, "cyclic ref_list found");
- NOT_PRODUCT(_processed++);
+}
+
+void DiscoveredListIterator::clear_referent() {
+ oop_store_raw(_referent_addr, NULL);
}
// NOTE: process_phase*() are largely similar, and at a high level
@@ -627,7 +527,8 @@
while (iter.has_next()) {
iter.load_ptrs(DEBUG_ONLY(!discovery_is_atomic() /* allow_null_referent */));
bool referent_is_dead = (iter.referent() != NULL) && !iter.is_referent_alive();
- if (referent_is_dead && !policy->should_clear_reference(iter.obj())) {
+ if (referent_is_dead &&
+ !policy->should_clear_reference(iter.obj(), _soft_ref_timestamp_clock)) {
if (TraceReferenceGC) {
gclog_or_tty->print_cr("Dropping reference (" INTPTR_FORMAT ": %s" ") by policy",
iter.obj(), iter.obj()->blueprint()->internal_name());
@@ -786,10 +687,9 @@
void ReferenceProcessor::abandon_partial_discovery() {
// loop over the lists
- for (int i = 0; i < _max_num_q * subclasses_of_ref; i++) {
+ for (int i = 0; i < _max_num_q * number_of_subclasses_of_ref(); i++) {
if (TraceReferenceGC && PrintGCDetails && ((i % _max_num_q) == 0)) {
- gclog_or_tty->print_cr("\nAbandoning %s discovered list",
- list_name(i));
+ gclog_or_tty->print_cr("\nAbandoning %s discovered list", list_name(i));
}
abandon_partial_discovered_list(_discoveredSoftRefs[i]);
}
@@ -858,6 +758,14 @@
bool _clear_referent;
};
+void ReferenceProcessor::set_discovered(oop ref, oop value) {
+ if (_discovered_list_needs_barrier) {
+ java_lang_ref_Reference::set_discovered(ref, value);
+ } else {
+ java_lang_ref_Reference::set_discovered_raw(ref, value);
+ }
+}
+
// Balances reference queues.
// Move entries from all queues[0, 1, ..., _max_num_q-1] to
// queues[0, 1, ..., _num_q-1] because only the first _num_q
@@ -915,9 +823,9 @@
// Add the chain to the to list.
if (ref_lists[to_idx].head() == NULL) {
// to list is empty. Make a loop at the end.
- java_lang_ref_Reference::set_discovered(move_tail, move_tail);
+ set_discovered(move_tail, move_tail);
} else {
- java_lang_ref_Reference::set_discovered(move_tail, ref_lists[to_idx].head());
+ set_discovered(move_tail, ref_lists[to_idx].head());
}
ref_lists[to_idx].set_head(move_head);
ref_lists[to_idx].inc_length(refs_to_move);
@@ -1038,11 +946,7 @@
void ReferenceProcessor::clean_up_discovered_references() {
// loop over the lists
- // Should this instead be
- // for (int i = 0; i < subclasses_of_ref; i++_ {
- // for (int j = 0; j < _num_q; j++) {
- // int index = i * _max_num_q + j;
- for (int i = 0; i < _max_num_q * subclasses_of_ref; i++) {
+ for (int i = 0; i < _max_num_q * number_of_subclasses_of_ref(); i++) {
if (TraceReferenceGC && PrintGCDetails && ((i % _max_num_q) == 0)) {
gclog_or_tty->print_cr(
"\nScrubbing %s discovered list of Null referents",
@@ -1255,11 +1159,13 @@
// time-stamp policies advance the soft-ref clock only
// at a major collection cycle, this is always currently
// accurate.
- if (!_current_soft_ref_policy->should_clear_reference(obj)) {
+ if (!_current_soft_ref_policy->should_clear_reference(obj, _soft_ref_timestamp_clock)) {
return false;
}
}
+ ResourceMark rm; // Needed for tracing.
+
HeapWord* const discovered_addr = java_lang_ref_Reference::discovered_addr(obj);
const oop discovered = java_lang_ref_Reference::discovered(obj);
assert(discovered->is_oop_or_null(), "bad discovered field");
@@ -1472,7 +1378,9 @@
}
const char* ReferenceProcessor::list_name(int i) {
- assert(i >= 0 && i <= _max_num_q * subclasses_of_ref, "Out of bounds index");
+ assert(i >= 0 && i <= _max_num_q * number_of_subclasses_of_ref(),
+ "Out of bounds index");
+
int j = i / _max_num_q;
switch (j) {
case 0: return "SoftRef";
@@ -1493,7 +1401,7 @@
#ifndef PRODUCT
void ReferenceProcessor::clear_discovered_references() {
guarantee(!_discovering_refs, "Discovering refs?");
- for (int i = 0; i < _max_num_q * subclasses_of_ref; i++) {
+ for (int i = 0; i < _max_num_q * number_of_subclasses_of_ref(); i++) {
clear_discovered_references(_discoveredSoftRefs[i]);
}
}
diff --git a/hotspot/src/share/vm/memory/referenceProcessor.hpp b/hotspot/src/share/vm/memory/referenceProcessor.hpp
index 8178f60..d1a92a6 100644
--- a/hotspot/src/share/vm/memory/referenceProcessor.hpp
+++ b/hotspot/src/share/vm/memory/referenceProcessor.hpp
@@ -48,18 +48,177 @@
// forward references
class ReferencePolicy;
class AbstractRefProcTaskExecutor;
-class DiscoveredList;
+
+// List of discovered references.
+class DiscoveredList {
+public:
+ DiscoveredList() : _len(0), _compressed_head(0), _oop_head(NULL) { }
+ oop head() const {
+ return UseCompressedOops ? oopDesc::decode_heap_oop(_compressed_head) :
+ _oop_head;
+ }
+ HeapWord* adr_head() {
+ return UseCompressedOops ? (HeapWord*)&_compressed_head :
+ (HeapWord*)&_oop_head;
+ }
+ void set_head(oop o) {
+ if (UseCompressedOops) {
+ // Must compress the head ptr.
+ _compressed_head = oopDesc::encode_heap_oop(o);
+ } else {
+ _oop_head = o;
+ }
+ }
+ bool is_empty() const { return head() == NULL; }
+ size_t length() { return _len; }
+ void set_length(size_t len) { _len = len; }
+ void inc_length(size_t inc) { _len += inc; assert(_len > 0, "Error"); }
+ void dec_length(size_t dec) { _len -= dec; }
+private:
+ // Set value depending on UseCompressedOops. This could be a template class
+ // but then we have to fix all the instantiations and declarations that use this class.
+ oop _oop_head;
+ narrowOop _compressed_head;
+ size_t _len;
+};
+
+// Iterator for the list of discovered references.
+class DiscoveredListIterator {
+private:
+ DiscoveredList& _refs_list;
+ HeapWord* _prev_next;
+ oop _prev;
+ oop _ref;
+ HeapWord* _discovered_addr;
+ oop _next;
+ HeapWord* _referent_addr;
+ oop _referent;
+ OopClosure* _keep_alive;
+ BoolObjectClosure* _is_alive;
+
+ DEBUG_ONLY(
+ oop _first_seen; // cyclic linked list check
+ )
+
+ NOT_PRODUCT(
+ size_t _processed;
+ size_t _removed;
+ )
+
+public:
+ inline DiscoveredListIterator(DiscoveredList& refs_list,
+ OopClosure* keep_alive,
+ BoolObjectClosure* is_alive):
+ _refs_list(refs_list),
+ _prev_next(refs_list.adr_head()),
+ _prev(NULL),
+ _ref(refs_list.head()),
+#ifdef ASSERT
+ _first_seen(refs_list.head()),
+#endif
+#ifndef PRODUCT
+ _processed(0),
+ _removed(0),
+#endif
+ _next(NULL),
+ _keep_alive(keep_alive),
+ _is_alive(is_alive)
+{ }
+
+ // End Of List.
+ inline bool has_next() const { return _ref != NULL; }
+
+ // Get oop to the Reference object.
+ inline oop obj() const { return _ref; }
+
+ // Get oop to the referent object.
+ inline oop referent() const { return _referent; }
+
+ // Returns true if referent is alive.
+ inline bool is_referent_alive() const {
+ return _is_alive->do_object_b(_referent);
+ }
+
+ // Loads data for the current reference.
+ // The "allow_null_referent" argument tells us to allow for the possibility
+ // of a NULL referent in the discovered Reference object. This typically
+ // happens in the case of concurrent collectors that may have done the
+ // discovery concurrently, or interleaved, with mutator execution.
+ void load_ptrs(DEBUG_ONLY(bool allow_null_referent));
+
+ // Move to the next discovered reference.
+ inline void next() {
+ _prev_next = _discovered_addr;
+ _prev = _ref;
+ move_to_next();
+ }
+
+ // Remove the current reference from the list
+ void remove();
+
+ // Make the Reference object active again.
+ void make_active();
+
+ // Make the referent alive.
+ inline void make_referent_alive() {
+ if (UseCompressedOops) {
+ _keep_alive->do_oop((narrowOop*)_referent_addr);
+ } else {
+ _keep_alive->do_oop((oop*)_referent_addr);
+ }
+ }
+
+ // Update the discovered field.
+ inline void update_discovered() {
+ // First _prev_next ref actually points into DiscoveredList (gross).
+ if (UseCompressedOops) {
+ if (!oopDesc::is_null(*(narrowOop*)_prev_next)) {
+ _keep_alive->do_oop((narrowOop*)_prev_next);
+ }
+ } else {
+ if (!oopDesc::is_null(*(oop*)_prev_next)) {
+ _keep_alive->do_oop((oop*)_prev_next);
+ }
+ }
+ }
+
+ // NULL out referent pointer.
+ void clear_referent();
+
+ // Statistics
+ NOT_PRODUCT(
+ inline size_t processed() const { return _processed; }
+ inline size_t removed() const { return _removed; }
+ )
+
+ inline void move_to_next() {
+ if (_ref == _next) {
+ // End of the list.
+ _ref = NULL;
+ } else {
+ _ref = _next;
+ }
+ assert(_ref != _first_seen, "cyclic ref_list found");
+ NOT_PRODUCT(_processed++);
+ }
+};
class ReferenceProcessor : public CHeapObj {
protected:
// Compatibility with pre-4965777 JDK's
static bool _pending_list_uses_discovered_field;
- MemRegion _span; // (right-open) interval of heap
- // subject to wkref discovery
- bool _discovering_refs; // true when discovery enabled
- bool _discovery_is_atomic; // if discovery is atomic wrt
- // other collectors in configuration
- bool _discovery_is_mt; // true if reference discovery is MT.
+
+ // The SoftReference master timestamp clock
+ static jlong _soft_ref_timestamp_clock;
+
+ MemRegion _span; // (right-open) interval of heap
+ // subject to wkref discovery
+
+ bool _discovering_refs; // true when discovery enabled
+ bool _discovery_is_atomic; // if discovery is atomic wrt
+ // other collectors in configuration
+ bool _discovery_is_mt; // true if reference discovery is MT.
+
// If true, setting "next" field of a discovered refs list requires
// write barrier(s). (Must be true if used in a collector in which
// elements of a discovered list may be moved during discovery: for
@@ -67,18 +226,19 @@
// long-term concurrent marking phase that does weak reference
// discovery.)
bool _discovered_list_needs_barrier;
- BarrierSet* _bs; // Cached copy of BarrierSet.
- bool _enqueuing_is_done; // true if all weak references enqueued
- bool _processing_is_mt; // true during phases when
- // reference processing is MT.
- int _next_id; // round-robin mod _num_q counter in
- // support of work distribution
- // For collectors that do not keep GC marking information
+ BarrierSet* _bs; // Cached copy of BarrierSet.
+ bool _enqueuing_is_done; // true if all weak references enqueued
+ bool _processing_is_mt; // true during phases when
+ // reference processing is MT.
+ int _next_id; // round-robin mod _num_q counter in
+ // support of work distribution
+
+ // For collectors that do not keep GC liveness information
// in the object header, this field holds a closure that
// helps the reference processor determine the reachability
- // of an oop (the field is currently initialized to NULL for
- // all collectors but the CMS collector).
+ // of an oop. It is currently initialized to NULL for all
+ // collectors except for CMS and G1.
BoolObjectClosure* _is_alive_non_header;
// Soft ref clearing policies
@@ -102,10 +262,13 @@
DiscoveredList* _discoveredPhantomRefs;
public:
- int num_q() { return _num_q; }
- int max_num_q() { return _max_num_q; }
- void set_active_mt_degree(int v) { _num_q = v; }
- DiscoveredList* discovered_soft_refs() { return _discoveredSoftRefs; }
+ static int number_of_subclasses_of_ref() { return (REF_PHANTOM - REF_OTHER); }
+
+ int num_q() { return _num_q; }
+ int max_num_q() { return _max_num_q; }
+ void set_active_mt_degree(int v) { _num_q = v; }
+ DiscoveredList* discovered_soft_refs() { return _discoveredSoftRefs; }
+
ReferencePolicy* setup_policy(bool always_clear) {
_current_soft_ref_policy = always_clear ?
_always_clear_soft_ref_policy : _default_soft_ref_policy;
@@ -205,6 +368,11 @@
void enqueue_discovered_reflists(HeapWord* pending_list_addr, AbstractRefProcTaskExecutor* task_executor);
protected:
+ // Set the 'discovered' field of the given reference to
+ // the given value - emitting barriers depending upon
+ // the value of _discovered_list_needs_barrier.
+ void set_discovered(oop ref, oop value);
+
// "Preclean" the given discovered reference list
// by removing references with strongly reachable referents.
// Currently used in support of CMS only.
@@ -290,7 +458,7 @@
void set_span(MemRegion span) { _span = span; }
// start and stop weak ref discovery
- void enable_discovery() { _discovering_refs = true; }
+ void enable_discovery(bool verify_disabled, bool check_no_refs);
void disable_discovery() { _discovering_refs = false; }
bool discovery_enabled() { return _discovering_refs; }
@@ -365,7 +533,7 @@
~NoRefDiscovery() {
if (_was_discovering_refs) {
- _rp->enable_discovery();
+ _rp->enable_discovery(true /*verify_disabled*/, false /*check_no_refs*/);
}
}
};
diff --git a/hotspot/src/share/vm/runtime/thread.cpp b/hotspot/src/share/vm/runtime/thread.cpp
index bc70cd3..9a2e62e 100644
--- a/hotspot/src/share/vm/runtime/thread.cpp
+++ b/hotspot/src/share/vm/runtime/thread.cpp
@@ -753,8 +753,9 @@
jint thread_parity = _oops_do_parity;
if (thread_parity != strong_roots_parity) {
jint res = Atomic::cmpxchg(strong_roots_parity, &_oops_do_parity, thread_parity);
- if (res == thread_parity) return true;
- else {
+ if (res == thread_parity) {
+ return true;
+ } else {
guarantee(res == strong_roots_parity, "Or else what?");
assert(SharedHeap::heap()->n_par_threads() > 0,
"Should only fail when parallel.");
@@ -3909,8 +3910,9 @@
}
}
VMThread* vmt = VMThread::vm_thread();
- if (vmt->claim_oops_do(is_par, cp))
+ if (vmt->claim_oops_do(is_par, cp)) {
vmt->oops_do(f, cf);
+ }
}
#ifndef SERIALGC
diff --git a/hotspot/src/share/vm/runtime/vmStructs.cpp b/hotspot/src/share/vm/runtime/vmStructs.cpp
index 0ce636f..00fe358 100644
--- a/hotspot/src/share/vm/runtime/vmStructs.cpp
+++ b/hotspot/src/share/vm/runtime/vmStructs.cpp
@@ -182,6 +182,7 @@
#include "gc_implementation/parallelScavenge/psVirtualspace.hpp"
#include "gc_implementation/parallelScavenge/psYoungGen.hpp"
#include "gc_implementation/parallelScavenge/vmStructs_parallelgc.hpp"
+#include "gc_implementation/g1/vmStructs_g1.hpp"
#endif
#ifdef COMPILER2
#include "opto/addnode.hpp"
@@ -2878,6 +2879,9 @@
VM_STRUCTS_CMS(GENERATE_NONSTATIC_VM_STRUCT_ENTRY, \
GENERATE_NONSTATIC_VM_STRUCT_ENTRY, \
GENERATE_STATIC_VM_STRUCT_ENTRY)
+
+ VM_STRUCTS_G1(GENERATE_NONSTATIC_VM_STRUCT_ENTRY, \
+ GENERATE_STATIC_VM_STRUCT_ENTRY)
#endif // SERIALGC
VM_STRUCTS_CPU(GENERATE_NONSTATIC_VM_STRUCT_ENTRY, \
@@ -2921,6 +2925,9 @@
GENERATE_TOPLEVEL_VM_TYPE_ENTRY)
VM_TYPES_PARNEW(GENERATE_VM_TYPE_ENTRY)
+
+ VM_TYPES_G1(GENERATE_VM_TYPE_ENTRY,
+ GENERATE_TOPLEVEL_VM_TYPE_ENTRY)
#endif // SERIALGC
VM_TYPES_CPU(GENERATE_VM_TYPE_ENTRY,
@@ -3020,6 +3027,9 @@
VM_STRUCTS_CMS(CHECK_NONSTATIC_VM_STRUCT_ENTRY,
CHECK_VOLATILE_NONSTATIC_VM_STRUCT_ENTRY,
CHECK_STATIC_VM_STRUCT_ENTRY);
+
+ VM_STRUCTS_G1(CHECK_NONSTATIC_VM_STRUCT_ENTRY,
+ CHECK_STATIC_VM_STRUCT_ENTRY);
#endif // SERIALGC
VM_STRUCTS_CPU(CHECK_NONSTATIC_VM_STRUCT_ENTRY,
@@ -3060,6 +3070,9 @@
CHECK_SINGLE_ARG_VM_TYPE_NO_OP);
VM_TYPES_PARNEW(CHECK_VM_TYPE_ENTRY)
+
+ VM_TYPES_G1(CHECK_VM_TYPE_ENTRY,
+ CHECK_SINGLE_ARG_VM_TYPE_NO_OP);
#endif // SERIALGC
VM_TYPES_CPU(CHECK_VM_TYPE_ENTRY,
@@ -3125,6 +3138,8 @@
debug_only(VM_STRUCTS_CMS(ENSURE_FIELD_TYPE_PRESENT, \
ENSURE_FIELD_TYPE_PRESENT, \
ENSURE_FIELD_TYPE_PRESENT));
+ debug_only(VM_STRUCTS_G1(ENSURE_FIELD_TYPE_PRESENT, \
+ ENSURE_FIELD_TYPE_PRESENT));
#endif // SERIALGC
debug_only(VM_STRUCTS_CPU(ENSURE_FIELD_TYPE_PRESENT, \
ENSURE_FIELD_TYPE_PRESENT, \
diff --git a/hotspot/src/share/vm/services/g1MemoryPool.cpp b/hotspot/src/share/vm/services/g1MemoryPool.cpp
index ce64f0e..c621ecc 100644
--- a/hotspot/src/share/vm/services/g1MemoryPool.cpp
+++ b/hotspot/src/share/vm/services/g1MemoryPool.cpp
@@ -32,71 +32,44 @@
G1MemoryPoolSuper::G1MemoryPoolSuper(G1CollectedHeap* g1h,
const char* name,
size_t init_size,
+ size_t max_size,
bool support_usage_threshold) :
- _g1h(g1h), CollectedMemoryPool(name,
- MemoryPool::Heap,
- init_size,
- undefined_max(),
- support_usage_threshold) {
+ _g1mm(g1h->g1mm()), CollectedMemoryPool(name,
+ MemoryPool::Heap,
+ init_size,
+ max_size,
+ support_usage_threshold) {
assert(UseG1GC, "sanity");
}
-// See the comment at the top of g1MemoryPool.hpp
-size_t G1MemoryPoolSuper::eden_space_committed(G1CollectedHeap* g1h) {
- return MAX2(eden_space_used(g1h), (size_t) HeapRegion::GrainBytes);
-}
-
-// See the comment at the top of g1MemoryPool.hpp
-size_t G1MemoryPoolSuper::eden_space_used(G1CollectedHeap* g1h) {
- return g1h->g1mm()->eden_space_used();
-}
-
-// See the comment at the top of g1MemoryPool.hpp
-size_t G1MemoryPoolSuper::survivor_space_committed(G1CollectedHeap* g1h) {
- return g1h->g1mm()->survivor_space_committed();
-}
-
-// See the comment at the top of g1MemoryPool.hpp
-size_t G1MemoryPoolSuper::survivor_space_used(G1CollectedHeap* g1h) {
- return g1h->g1mm()->survivor_space_used();
-}
-
-// See the comment at the top of g1MemoryPool.hpp
-size_t G1MemoryPoolSuper::old_space_committed(G1CollectedHeap* g1h) {
- return g1h->g1mm()->old_space_committed();
-}
-
-// See the comment at the top of g1MemoryPool.hpp
-size_t G1MemoryPoolSuper::old_space_used(G1CollectedHeap* g1h) {
- return g1h->g1mm()->old_space_used();
-}
-
G1EdenPool::G1EdenPool(G1CollectedHeap* g1h) :
G1MemoryPoolSuper(g1h,
- "G1 Eden",
- eden_space_committed(g1h), /* init_size */
+ "G1 Eden Space",
+ g1h->g1mm()->eden_space_committed(), /* init_size */
+ _undefined_max,
false /* support_usage_threshold */) { }
MemoryUsage G1EdenPool::get_memory_usage() {
size_t initial_sz = initial_size();
size_t max_sz = max_size();
size_t used = used_in_bytes();
- size_t committed = eden_space_committed(_g1h);
+ size_t committed = _g1mm->eden_space_committed();
return MemoryUsage(initial_sz, used, committed, max_sz);
}
G1SurvivorPool::G1SurvivorPool(G1CollectedHeap* g1h) :
G1MemoryPoolSuper(g1h,
- "G1 Survivor",
- survivor_space_committed(g1h), /* init_size */
+ "G1 Survivor Space",
+ g1h->g1mm()->survivor_space_committed(), /* init_size */
+ _undefined_max,
false /* support_usage_threshold */) { }
MemoryUsage G1SurvivorPool::get_memory_usage() {
size_t initial_sz = initial_size();
size_t max_sz = max_size();
size_t used = used_in_bytes();
- size_t committed = survivor_space_committed(_g1h);
+ size_t committed = _g1mm->survivor_space_committed();
return MemoryUsage(initial_sz, used, committed, max_sz);
}
@@ -104,14 +77,15 @@
G1OldGenPool::G1OldGenPool(G1CollectedHeap* g1h) :
G1MemoryPoolSuper(g1h,
"G1 Old Gen",
- old_space_committed(g1h), /* init_size */
+ g1h->g1mm()->old_space_committed(), /* init_size */
+ _undefined_max,
true /* support_usage_threshold */) { }
MemoryUsage G1OldGenPool::get_memory_usage() {
size_t initial_sz = initial_size();
size_t max_sz = max_size();
size_t used = used_in_bytes();
- size_t committed = old_space_committed(_g1h);
+ size_t committed = _g1mm->old_space_committed();
return MemoryUsage(initial_sz, used, committed, max_sz);
}
diff --git a/hotspot/src/share/vm/services/g1MemoryPool.hpp b/hotspot/src/share/vm/services/g1MemoryPool.hpp
index 958a088..ce93d0e 100644
--- a/hotspot/src/share/vm/services/g1MemoryPool.hpp
+++ b/hotspot/src/share/vm/services/g1MemoryPool.hpp
@@ -26,12 +26,11 @@
#define SHARE_VM_SERVICES_G1MEMORYPOOL_HPP
#ifndef SERIALGC
+#include "gc_implementation/g1/g1MonitoringSupport.hpp"
#include "services/memoryPool.hpp"
#include "services/memoryUsage.hpp"
#endif
-class G1CollectedHeap;
-
// This file contains the three classes that represent the memory
// pools of the G1 spaces: G1EdenPool, G1SurvivorPool, and
// G1OldGenPool. In G1, unlike our other GCs, we do not have a
@@ -50,37 +49,19 @@
// on this model.
//
-
// This class is shared by the three G1 memory pool classes
-// (G1EdenPool, G1SurvivorPool, G1OldGenPool). Given that the way we
-// calculate used / committed bytes for these three pools is related
-// (see comment above), we put the calculations in this class so that
-// we can easily share them among the subclasses.
+// (G1EdenPool, G1SurvivorPool, G1OldGenPool).
class G1MemoryPoolSuper : public CollectedMemoryPool {
protected:
- G1CollectedHeap* _g1h;
+ const static size_t _undefined_max = (size_t) -1;
+ G1MonitoringSupport* _g1mm;
// Would only be called from subclasses.
G1MemoryPoolSuper(G1CollectedHeap* g1h,
const char* name,
size_t init_size,
+ size_t max_size,
bool support_usage_threshold);
-
- // The reason why all the code is in static methods is so that it
- // can be safely called from the constructors of the subclasses.
-
- static size_t undefined_max() {
- return (size_t) -1;
- }
-
- static size_t eden_space_committed(G1CollectedHeap* g1h);
- static size_t eden_space_used(G1CollectedHeap* g1h);
-
- static size_t survivor_space_committed(G1CollectedHeap* g1h);
- static size_t survivor_space_used(G1CollectedHeap* g1h);
-
- static size_t old_space_committed(G1CollectedHeap* g1h);
- static size_t old_space_used(G1CollectedHeap* g1h);
};
// Memory pool that represents the G1 eden.
@@ -89,10 +70,10 @@
G1EdenPool(G1CollectedHeap* g1h);
size_t used_in_bytes() {
- return eden_space_used(_g1h);
+ return _g1mm->eden_space_used();
}
size_t max_size() const {
- return undefined_max();
+ return _undefined_max;
}
MemoryUsage get_memory_usage();
};
@@ -103,10 +84,10 @@
G1SurvivorPool(G1CollectedHeap* g1h);
size_t used_in_bytes() {
- return survivor_space_used(_g1h);
+ return _g1mm->survivor_space_used();
}
size_t max_size() const {
- return undefined_max();
+ return _undefined_max;
}
MemoryUsage get_memory_usage();
};
@@ -117,10 +98,10 @@
G1OldGenPool(G1CollectedHeap* g1h);
size_t used_in_bytes() {
- return old_space_used(_g1h);
+ return _g1mm->old_space_used();
}
size_t max_size() const {
- return undefined_max();
+ return _undefined_max;
}
MemoryUsage get_memory_usage();
};
diff --git a/hotspot/src/share/vm/utilities/quickSort.cpp b/hotspot/src/share/vm/utilities/quickSort.cpp
index b377d9a..947b420 100644
--- a/hotspot/src/share/vm/utilities/quickSort.cpp
+++ b/hotspot/src/share/vm/utilities/quickSort.cpp
@@ -54,16 +54,18 @@
return 1;
}
-static int test_stdlib_comparator(const void* a, const void* b) {
- int ai = *(int*)a;
- int bi = *(int*)b;
- if (ai == bi) {
- return 0;
+extern "C" {
+ static int test_stdlib_comparator(const void* a, const void* b) {
+ int ai = *(int*)a;
+ int bi = *(int*)b;
+ if (ai == bi) {
+ return 0;
+ }
+ if (ai < bi) {
+ return -1;
+ }
+ return 1;
}
- if (ai < bi) {
- return -1;
- }
- return 1;
}
void QuickSort::print_array(const char* prefix, int* array, int length) {
@@ -92,7 +94,6 @@
}
bool QuickSort::test_quick_sort() {
-#if 0
tty->print_cr("test_quick_sort\n");
{
int* test_array = NULL;
@@ -213,7 +214,6 @@
delete[] test_array;
delete[] expected_array;
}
-#endif
return true;
}
diff --git a/jaxp/.hgtags b/jaxp/.hgtags
index a1687d8..e946d05 100644
--- a/jaxp/.hgtags
+++ b/jaxp/.hgtags
@@ -130,3 +130,4 @@
d7b8192e7277c49b9c702f4c4fd99bd83ba947ea jdk8-b06
c114306576dcc1cb871a48058b41bf7d87ce882a jdk8-b07
de4794dd69c48b08029d158a972993ff9d5627df jdk8-b08
+93554324c014282571aeeb48552ad00d3fedb089 jdk8-b09
diff --git a/jaxws/.hgtags b/jaxws/.hgtags
index b793da7..6599089 100644
--- a/jaxws/.hgtags
+++ b/jaxws/.hgtags
@@ -130,3 +130,4 @@
acffff22a9465005e8eb206224fae9f2ea4fd469 jdk8-b06
134b0debf7b04fe6e317394b04b8e7a4a0181b1b jdk8-b07
1c9d4f59acf8f71477473c170239b43b2c9dee24 jdk8-b08
+70172e57cf29efe271b068987eefb601c2a77780 jdk8-b09
diff --git a/jdk/.hgtags b/jdk/.hgtags
index 48a8142..dfa5634 100644
--- a/jdk/.hgtags
+++ b/jdk/.hgtags
@@ -130,3 +130,4 @@
bdb870cc269ef8b221d17a217be89092400b59d2 jdk8-b06
19f0a3db863cc491affc78b48c4a81a6679b2433 jdk8-b07
1c023bcd0c5a01ac07bc7eea728aafbb0d8991e9 jdk8-b08
+f1ec21b8142168ff40f3278d2f6b5fe4bd5f3b26 jdk8-b09
diff --git a/jdk/make/com/sun/org/apache/xml/Makefile b/jdk/make/com/sun/org/apache/xml/Makefile
index e0c25e9..f00135d 100644
--- a/jdk/make/com/sun/org/apache/xml/Makefile
+++ b/jdk/make/com/sun/org/apache/xml/Makefile
@@ -30,6 +30,8 @@
BUILDDIR = ../../../../..
PACKAGE = com.sun.org.apache.xml
PRODUCT = xml
+JAVAC_MAX_WARNINGS = true
+JAVAC_WARNINGS_FATAL = true
include $(BUILDDIR)/common/Defs.gmk
#
diff --git a/jdk/make/common/Defs-linux.gmk b/jdk/make/common/Defs-linux.gmk
index 1630f00..d20efc9 100644
--- a/jdk/make/common/Defs-linux.gmk
+++ b/jdk/make/common/Defs-linux.gmk
@@ -373,6 +373,7 @@
override LIBPOSIX4 =
override LIBSOCKET =
override LIBNSL =
+override LIBSCF =
override LIBTHREAD =
override MOOT_PRIORITIES = true
override NO_INTERRUPTIBLE_IO = true
diff --git a/jdk/make/common/Defs-solaris.gmk b/jdk/make/common/Defs-solaris.gmk
index 892cb36..666cdc1 100644
--- a/jdk/make/common/Defs-solaris.gmk
+++ b/jdk/make/common/Defs-solaris.gmk
@@ -711,6 +711,9 @@
# Network Services library
LIBNSL = -lnsl
+# service configuration facility library
+LIBSCF = -lscf
+
# GLOBAL_KPIC: If set means all libraries are PIC, position independent code
# EXCEPT for select compiles
# If a .o file is compiled non-PIC then it should be forced
diff --git a/jdk/make/java/java/Makefile b/jdk/make/java/java/Makefile
index 632cd39..73aa81d 100644
--- a/jdk/make/java/java/Makefile
+++ b/jdk/make/java/java/Makefile
@@ -208,7 +208,7 @@
-libpath:$(OBJDIR)/../../../verify/$(OBJDIRNAME) verify.lib \
shell32.lib delayimp.lib /DELAYLOAD:shell32.dll
else
-OTHER_LDLIBS += $(JVMLIB) -lverify $(LIBSOCKET) $(LIBNSL) -ldl \
+OTHER_LDLIBS += $(JVMLIB) -lverify $(LIBSOCKET) $(LIBNSL) $(LIBSCF) -ldl \
-L$(OBJDIR)/../../../fdlibm/$(OBJDIRNAME) -lfdlibm.$(ARCH)
endif
diff --git a/jdk/make/java/security/Makefile b/jdk/make/java/security/Makefile
index c05ecdd..60bcc75 100644
--- a/jdk/make/java/security/Makefile
+++ b/jdk/make/java/security/Makefile
@@ -26,8 +26,8 @@
BUILDDIR = ../..
PACKAGE = java.security
PRODUCT = sun
-JAVAC_MAX_WARNINGS = false
-JAVAC_LINT_OPTIONS = -Xlint:all,-deprecation
+JAVAC_MAX_WARNINGS = true
+JAVAC_LINT_OPTIONS = -Xlint:all
JAVAC_WARNINGS_FATAL = true
include $(BUILDDIR)/common/Defs.gmk
diff --git a/jdk/make/javax/Makefile b/jdk/make/javax/Makefile
index 251628c..ebeec3c 100644
--- a/jdk/make/javax/Makefile
+++ b/jdk/make/javax/Makefile
@@ -30,7 +30,7 @@
BUILDDIR = ..
include $(BUILDDIR)/common/Defs.gmk
-SUBDIRS = others
+SUBDIRS = others security
SUBDIRS_management = management
diff --git a/jdk/make/javax/others/Makefile b/jdk/make/javax/others/Makefile
index 1283dce..7740163 100644
--- a/jdk/make/javax/others/Makefile
+++ b/jdk/make/javax/others/Makefile
@@ -38,10 +38,6 @@
com/sun/naming/internal \
javax/net \
javax/script \
- javax/security/auth \
- javax/security/cert \
- javax/security/sasl \
- javax/smartcardio \
javax/tools \
javax/xml
diff --git a/jdk/make/javax/security/Makefile b/jdk/make/javax/security/Makefile
new file mode 100644
index 0000000..88d7abb
--- /dev/null
+++ b/jdk/make/javax/security/Makefile
@@ -0,0 +1,49 @@
+#
+# Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved.
+# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+#
+# This code is free software; you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 2 only, as
+# published by the Free Software Foundation. Oracle designates this
+# particular file as subject to the "Classpath" exception as provided
+# by Oracle in the LICENSE file that accompanied this code.
+#
+# This code is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+# version 2 for more details (a copy is included in the LICENSE file that
+# accompanied this code).
+#
+# You should have received a copy of the GNU General Public License version
+# 2 along with this work; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+#
+# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+# or visit www.oracle.com if you need additional information or have any
+# questions.
+#
+
+#
+# Makefile for building javax (security classes)
+#
+
+BUILDDIR = ../..
+JAVAC_MAX_WARNINGS = true
+JAVAC_WARNINGS_FATAL = true
+
+include $(BUILDDIR)/common/Defs.gmk
+
+#
+# Files to compile
+#
+AUTO_FILES_JAVA_DIRS = \
+ javax/security/auth \
+ javax/security/cert \
+ javax/security/sasl \
+ javax/smartcardio
+
+#
+# Rules
+#
+include $(BUILDDIR)/common/Classes.gmk
+
diff --git a/jdk/make/org/ietf/jgss/Makefile b/jdk/make/org/ietf/jgss/Makefile
index 9887e71..26f0219 100644
--- a/jdk/make/org/ietf/jgss/Makefile
+++ b/jdk/make/org/ietf/jgss/Makefile
@@ -26,6 +26,8 @@
BUILDDIR = ../../..
PACKAGE = org.ietf.jgss
PRODUCT = sun
+JAVAC_MAX_WARNINGS = true
+JAVAC_WARNINGS_FATAL = true
include $(BUILDDIR)/common/Defs.gmk
#
diff --git a/jdk/make/sun/security/other/Makefile b/jdk/make/sun/security/other/Makefile
index ab74d58..7889373 100644
--- a/jdk/make/sun/security/other/Makefile
+++ b/jdk/make/sun/security/other/Makefile
@@ -26,7 +26,7 @@
BUILDDIR = ../../..
PACKAGE = sun.security.other
PRODUCT = sun
-JAVAC_MAX_WARNINGS=false
+JAVAC_MAX_WARNINGS=true
JAVAC_LINT_OPTIONS=-Xlint:all,-deprecation
JAVAC_WARNINGS_FATAL=true
include $(BUILDDIR)/common/Defs.gmk
diff --git a/jdk/src/share/classes/com/sun/jndi/ldap/Connection.java b/jdk/src/share/classes/com/sun/jndi/ldap/Connection.java
index ee9ff2d..464e3d1 100644
--- a/jdk/src/share/classes/com/sun/jndi/ldap/Connection.java
+++ b/jdk/src/share/classes/com/sun/jndi/ldap/Connection.java
@@ -32,6 +32,7 @@
import java.io.OutputStream;
import java.io.InputStream;
import java.net.Socket;
+import javax.net.ssl.SSLSocket;
import javax.naming.CommunicationException;
import javax.naming.ServiceUnavailableException;
@@ -361,6 +362,19 @@
}
}
+ // For LDAP connect timeouts on LDAP over SSL connections must treat
+ // the SSL handshake following socket connection as part of the timeout.
+ // So explicitly set a socket read timeout, trigger the SSL handshake,
+ // then reset the timeout.
+ if (connectTimeout > 0 && socket instanceof SSLSocket) {
+ SSLSocket sslSocket = (SSLSocket) socket;
+ int socketTimeout = sslSocket.getSoTimeout();
+
+ sslSocket.setSoTimeout(connectTimeout); // reuse full timeout value
+ sslSocket.startHandshake();
+ sslSocket.setSoTimeout(socketTimeout);
+ }
+
return socket;
}
diff --git a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/Init.java b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/Init.java
index 5b1acfd..308d517 100644
--- a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/Init.java
+++ b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/Init.java
@@ -115,9 +115,9 @@
// provider mechanism instead if implementing their own
// transform or canonicalization algorithms.
// InputStream is = Class.forName("com.sun.org.apache.xml.internal.security.Init").getResourceAsStream("resource/config.xml");
- InputStream is = (InputStream) AccessController.doPrivileged(
- new PrivilegedAction() {
- public Object run() {
+ InputStream is = AccessController.doPrivileged(
+ new PrivilegedAction<InputStream>() {
+ public InputStream run() {
// String cfile = System.getProperty
// ("com.sun.org.apache.xml.internal.security.resource.config");
return getClass().getResourceAsStream
diff --git a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/algorithms/JCEMapper.java b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/algorithms/JCEMapper.java
index 7a23913..030795b 100644
--- a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/algorithms/JCEMapper.java
+++ b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/algorithms/JCEMapper.java
@@ -45,9 +45,9 @@
- private static Map uriToJCEName;
+ private static Map<String, String> uriToJCEName;
- private static Map algorithmsMap;
+ private static Map<String, Algorithm> algorithmsMap;
private static String providerName = null;
/**
@@ -63,8 +63,8 @@
static void loadAlgorithms( Element algorithmsEl) {
Element[] algorithms = XMLUtils.selectNodes(algorithmsEl.getFirstChild(),Init.CONF_NS,"Algorithm");
- uriToJCEName = new HashMap( algorithms.length * 2);
- algorithmsMap = new HashMap( algorithms.length * 2);
+ uriToJCEName = new HashMap<String, String>( algorithms.length * 2);
+ algorithmsMap = new HashMap<String, Algorithm>( algorithms.length * 2);
for (int i = 0 ;i < algorithms.length ;i ++) {
Element el = algorithms[i];
String id = el.getAttribute("URI");
@@ -76,7 +76,7 @@
}
static Algorithm getAlgorithmMapping(String algoURI) {
- return ((Algorithm)algorithmsMap.get(algoURI));
+ return algorithmsMap.get(algoURI);
}
/**
@@ -90,7 +90,7 @@
if (log.isLoggable(java.util.logging.Level.FINE))
log.log(java.util.logging.Level.FINE, "Request for URI " + AlgorithmURI);
- String jceName = (String) uriToJCEName.get(AlgorithmURI);
+ String jceName = uriToJCEName.get(AlgorithmURI);
return jceName;
}
@@ -106,7 +106,7 @@
if (log.isLoggable(java.util.logging.Level.FINE))
log.log(java.util.logging.Level.FINE, "Request for URI " + AlgorithmURI);
- return ((Algorithm) algorithmsMap.get(AlgorithmURI)).algorithmClass;
+ return (algorithmsMap.get(AlgorithmURI)).algorithmClass;
}
/**
@@ -116,7 +116,7 @@
* @return The length of the key used in the alogrithm
*/
public static int getKeyLengthFromURI(String AlgorithmURI) {
- return Integer.parseInt(((Algorithm) algorithmsMap.get(AlgorithmURI)).keyLength);
+ return Integer.parseInt((algorithmsMap.get(AlgorithmURI)).keyLength);
}
/**
@@ -128,7 +128,7 @@
*/
public static String getJCEKeyAlgorithmFromURI(String AlgorithmURI) {
- return ((Algorithm) algorithmsMap.get(AlgorithmURI)).requiredKey;
+ return (algorithmsMap.get(AlgorithmURI)).requiredKey;
}
diff --git a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/algorithms/MessageDigestAlgorithm.java b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/algorithms/MessageDigestAlgorithm.java
index fa62ef3..63a808b 100644
--- a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/algorithms/MessageDigestAlgorithm.java
+++ b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/algorithms/MessageDigestAlgorithm.java
@@ -71,9 +71,10 @@
this.algorithm = messageDigest;
}
- static ThreadLocal instances=new ThreadLocal() {
- protected Object initialValue() {
- return new HashMap();
+ static ThreadLocal<Map<String, MessageDigest>> instances=new
+ ThreadLocal<Map<String, MessageDigest>>() {
+ protected Map<String, MessageDigest> initialValue() {
+ return new HashMap<String, MessageDigest>();
};
};
@@ -92,7 +93,7 @@
}
private static MessageDigest getDigestInstance(String algorithmURI) throws XMLSignatureException {
- MessageDigest result=(MessageDigest) ((Map)instances.get()).get(algorithmURI);
+ MessageDigest result= instances.get().get(algorithmURI);
if (result!=null)
return result;
String algorithmID = JCEMapper.translateURItoJCEID(algorithmURI);
@@ -121,7 +122,7 @@
throw new XMLSignatureException("algorithms.NoSuchAlgorithm", exArgs);
}
- ((Map)instances.get()).put(algorithmURI, md);
+ instances.get().put(algorithmURI, md);
return md;
}
diff --git a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/algorithms/SignatureAlgorithm.java b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/algorithms/SignatureAlgorithm.java
index 567df3c..24fd47e 100644
--- a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/algorithms/SignatureAlgorithm.java
+++ b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/algorithms/SignatureAlgorithm.java
@@ -51,28 +51,28 @@
static boolean _alreadyInitialized = false;
/** All available algorithm classes are registered here */
- static HashMap _algorithmHash = null;
+ static Map<String, Class<? extends SignatureAlgorithmSpi>> _algorithmHash = null;
- static ThreadLocal instancesSigning=new ThreadLocal() {
- protected Object initialValue() {
- return new HashMap();
+ static ThreadLocal<Map<String, SignatureAlgorithmSpi>> instancesSigning=new ThreadLocal<Map<String, SignatureAlgorithmSpi>>() {
+ protected Map<String, SignatureAlgorithmSpi> initialValue() {
+ return new HashMap<String, SignatureAlgorithmSpi>();
};
};
- static ThreadLocal instancesVerify=new ThreadLocal() {
- protected Object initialValue() {
- return new HashMap();
+ static ThreadLocal<Map<String, SignatureAlgorithmSpi>> instancesVerify=new ThreadLocal<Map<String, SignatureAlgorithmSpi>>() {
+ protected Map<String, SignatureAlgorithmSpi> initialValue() {
+ return new HashMap<String, SignatureAlgorithmSpi>();
};
};
- static ThreadLocal keysSigning=new ThreadLocal() {
- protected Object initialValue() {
- return new HashMap();
+ static ThreadLocal<Map<String, Key>> keysSigning=new ThreadLocal<Map<String, Key>>() {
+ protected Map<String, Key> initialValue() {
+ return new HashMap<String, Key>();
};
};
- static ThreadLocal keysVerify=new ThreadLocal() {
- protected Object initialValue() {
- return new HashMap();
+ static ThreadLocal<Map<String, Key>> keysVerify=new ThreadLocal<Map<String, Key>>() {
+ protected Map<String, Key> initialValue() {
+ return new HashMap<String, Key>();
};
};
// boolean isForSigning=false;
@@ -105,34 +105,34 @@
.engineGetContextFromElement(this._constructionElement);
}
private static SignatureAlgorithmSpi getInstanceForSigning(String algorithmURI) throws XMLSignatureException {
- SignatureAlgorithmSpi result=(SignatureAlgorithmSpi) ((Map)instancesSigning.get()).get(algorithmURI);
+ SignatureAlgorithmSpi result= instancesSigning.get().get(algorithmURI);
if (result!=null) {
result.reset();
return result;
}
result=buildSigner(algorithmURI, result);
- ((Map)instancesSigning.get()).put(algorithmURI,result);
+ instancesSigning.get().put(algorithmURI,result);
return result;
}
private static SignatureAlgorithmSpi getInstanceForVerify(String algorithmURI) throws XMLSignatureException {
- SignatureAlgorithmSpi result=(SignatureAlgorithmSpi) ((Map)instancesVerify.get()).get(algorithmURI);
+ SignatureAlgorithmSpi result= instancesVerify.get().get(algorithmURI);
if (result!=null) {
result.reset();
return result;
}
result=buildSigner(algorithmURI, result);
- ((Map)instancesVerify.get()).put(algorithmURI,result);
+ instancesVerify.get().put(algorithmURI,result);
return result;
}
private static SignatureAlgorithmSpi buildSigner(String algorithmURI, SignatureAlgorithmSpi result) throws XMLSignatureException {
try {
- Class implementingClass =
+ Class<? extends SignatureAlgorithmSpi> implementingClass =
SignatureAlgorithm.getImplementingClass(algorithmURI);
if (log.isLoggable(java.util.logging.Level.FINE))
log.log(java.util.logging.Level.FINE, "Create URI \"" + algorithmURI + "\" class \""
+ implementingClass + "\"");
- result=(SignatureAlgorithmSpi) implementingClass.newInstance();
+ result= implementingClass.newInstance();
return result;
} catch (IllegalAccessException ex) {
Object exArgs[] = { algorithmURI, ex.getMessage() };
@@ -270,7 +270,7 @@
*/
public void initSign(Key signingKey) throws XMLSignatureException {
initializeAlgorithm(true);
- Map map=(Map)keysSigning.get();
+ Map<String, Key> map=keysSigning.get();
if (map.get(this.algorithmURI)==signingKey) {
return;
}
@@ -329,7 +329,7 @@
*/
public void initVerify(Key verificationKey) throws XMLSignatureException {
initializeAlgorithm(false);
- Map map=(Map)keysVerify.get();
+ Map<String, Key> map=keysVerify.get();
if (map.get(this.algorithmURI)==verificationKey) {
return;
}
@@ -375,7 +375,7 @@
log.log(java.util.logging.Level.FINE, "Init() called");
if (!SignatureAlgorithm._alreadyInitialized) {
- SignatureAlgorithm._algorithmHash = new HashMap(10);
+ SignatureAlgorithm._algorithmHash = new HashMap<String, Class<? extends SignatureAlgorithmSpi>>(10);
SignatureAlgorithm._alreadyInitialized = true;
}
}
@@ -388,6 +388,7 @@
* @throws AlgorithmAlreadyRegisteredException if specified algorithmURI is already registered
* @throws XMLSignatureException
*/
+ @SuppressWarnings("unchecked")
public static void register(String algorithmURI, String implementingClass)
throws AlgorithmAlreadyRegisteredException,XMLSignatureException {
@@ -396,7 +397,7 @@
log.log(java.util.logging.Level.FINE, "Try to register " + algorithmURI + " " + implementingClass);
// are we already registered?
- Class registeredClassClass =
+ Class<? extends SignatureAlgorithmSpi> registeredClassClass =
SignatureAlgorithm.getImplementingClass(algorithmURI);
if (registeredClassClass!=null) {
String registeredClass = registeredClassClass.getName();
@@ -409,7 +410,7 @@
}
}
try {
- SignatureAlgorithm._algorithmHash.put(algorithmURI, Class.forName(implementingClass));
+ SignatureAlgorithm._algorithmHash.put(algorithmURI, (Class <? extends SignatureAlgorithmSpi>)Class.forName(implementingClass));
} catch (ClassNotFoundException ex) {
Object exArgs[] = { algorithmURI, ex.getMessage() };
@@ -431,13 +432,13 @@
* @param URI
* @return the class that implements the URI
*/
- private static Class getImplementingClass(String URI) {
+ private static Class<? extends SignatureAlgorithmSpi> getImplementingClass(String URI) {
if (SignatureAlgorithm._algorithmHash == null) {
return null;
}
- return (Class) SignatureAlgorithm._algorithmHash.get(URI);
+ return SignatureAlgorithm._algorithmHash.get(URI);
}
/**
diff --git a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/c14n/Canonicalizer.java b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/c14n/Canonicalizer.java
index a418123..b435a98 100644
--- a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/c14n/Canonicalizer.java
+++ b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/c14n/Canonicalizer.java
@@ -28,6 +28,7 @@
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.xpath.XPath;
import com.sun.org.apache.xml.internal.security.exceptions.AlgorithmAlreadyRegisteredException;
import org.w3c.dom.Document;
@@ -83,7 +84,7 @@
ALGO_ID_C14N11_OMIT_COMMENTS + "#WithComments";
static boolean _alreadyInitialized = false;
- static Map _canonicalizerHash = null;
+ static Map<String,Class<? extends CanonicalizerSpi>> _canonicalizerHash = null;
protected CanonicalizerSpi canonicalizerSpi = null;
@@ -94,7 +95,7 @@
public static void init() {
if (!Canonicalizer._alreadyInitialized) {
- Canonicalizer._canonicalizerHash = new HashMap(10);
+ Canonicalizer._canonicalizerHash = new HashMap<String, Class<? extends CanonicalizerSpi>>(10);
Canonicalizer._alreadyInitialized = true;
}
}
@@ -109,10 +110,11 @@
throws InvalidCanonicalizerException {
try {
- Class implementingClass = getImplementingClass(algorithmURI);
+ Class<? extends CanonicalizerSpi> implementingClass =
+ getImplementingClass(algorithmURI);
this.canonicalizerSpi =
- (CanonicalizerSpi) implementingClass.newInstance();
+ implementingClass.newInstance();
this.canonicalizerSpi.reset=true;
} catch (Exception e) {
Object exArgs[] = { algorithmURI };
@@ -144,11 +146,12 @@
* @param implementingClass
* @throws AlgorithmAlreadyRegisteredException
*/
+ @SuppressWarnings("unchecked")
public static void register(String algorithmURI, String implementingClass)
throws AlgorithmAlreadyRegisteredException {
// check whether URI is already registered
- Class registeredClass = getImplementingClass(algorithmURI);
+ Class<? extends CanonicalizerSpi> registeredClass = getImplementingClass(algorithmURI);
if (registeredClass != null) {
Object exArgs[] = { algorithmURI, registeredClass };
@@ -158,7 +161,7 @@
}
try {
- _canonicalizerHash.put(algorithmURI, Class.forName(implementingClass));
+ _canonicalizerHash.put(algorithmURI, (Class<? extends CanonicalizerSpi>) Class.forName(implementingClass));
} catch (ClassNotFoundException e) {
throw new RuntimeException("c14n class not found");
}
@@ -304,7 +307,7 @@
* @return the result of the c14n.
* @throws CanonicalizationException
*/
- public byte[] canonicalizeXPathNodeSet(Set xpathNodeSet)
+ public byte[] canonicalizeXPathNodeSet(Set<Node> xpathNodeSet)
throws CanonicalizationException {
return this.canonicalizerSpi.engineCanonicalizeXPathNodeSet(xpathNodeSet);
}
@@ -317,7 +320,7 @@
* @return the result of the c14n.
* @throws CanonicalizationException
*/
- public byte[] canonicalizeXPathNodeSet(Set xpathNodeSet,
+ public byte[] canonicalizeXPathNodeSet(Set<Node> xpathNodeSet,
String inclusiveNamespaces) throws CanonicalizationException {
return this.canonicalizerSpi.engineCanonicalizeXPathNodeSet(xpathNodeSet,
inclusiveNamespaces);
@@ -347,8 +350,8 @@
* @param URI
* @return the name of the class that implements the given URI
*/
- private static Class getImplementingClass(String URI) {
- return (Class) _canonicalizerHash.get(URI);
+ private static Class<? extends CanonicalizerSpi> getImplementingClass(String URI) {
+ return _canonicalizerHash.get(URI);
}
/**
diff --git a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/c14n/CanonicalizerSpi.java b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/c14n/CanonicalizerSpi.java
index e55b67c..48294fe 100644
--- a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/c14n/CanonicalizerSpi.java
+++ b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/c14n/CanonicalizerSpi.java
@@ -28,6 +28,7 @@
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.xpath.XPath;
import com.sun.org.apache.xml.internal.security.utils.XMLUtils;
import org.w3c.dom.Document;
@@ -151,7 +152,7 @@
* @return the c14n bytes
* @throws CanonicalizationException
*/
- public abstract byte[] engineCanonicalizeXPathNodeSet(Set xpathNodeSet)
+ public abstract byte[] engineCanonicalizeXPathNodeSet(Set<Node> xpathNodeSet)
throws CanonicalizationException;
/**
@@ -162,7 +163,7 @@
* @return the c14n bytes
* @throws CanonicalizationException
*/
- public abstract byte[] engineCanonicalizeXPathNodeSet(Set xpathNodeSet, String inclusiveNamespaces)
+ public abstract byte[] engineCanonicalizeXPathNodeSet(Set<Node> xpathNodeSet, String inclusiveNamespaces)
throws CanonicalizationException;
/**
diff --git a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/c14n/helper/AttrCompare.java b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/c14n/helper/AttrCompare.java
index 802abda..8675b67 100644
--- a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/c14n/helper/AttrCompare.java
+++ b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/c14n/helper/AttrCompare.java
@@ -41,7 +41,7 @@
*
* @author Christian Geuer-Pollmann
*/
-public class AttrCompare implements Comparator, Serializable {
+public class AttrCompare implements Comparator<Attr>, Serializable {
private final static long serialVersionUID = -7113259629930576230L;
private final static int ATTR0_BEFORE_ATTR1 = -1;
@@ -62,16 +62,14 @@
* key (an empty namespace URI is lexicographically least).
* </UL>
*
- * @param obj0 casted Attr
- * @param obj1 casted Attr
+ * @param attr0
+ * @param attr1
* @return returns a negative integer, zero, or a positive integer as
* obj0 is less than, equal to, or greater than obj1
*
*/
- public int compare(Object obj0, Object obj1) {
+ public int compare(Attr attr0, Attr attr1) {
- Attr attr0 = (Attr) obj0;
- Attr attr1 = (Attr) obj1;
String namespaceURI0 = attr0.getNamespaceURI();
String namespaceURI1 = attr1.getNamespaceURI();
diff --git a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/c14n/implementations/Canonicalizer11.java b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/c14n/implementations/Canonicalizer11.java
index 4790fd8..e0a4696 100644
--- a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/c14n/implementations/Canonicalizer11.java
+++ b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/c14n/implementations/Canonicalizer11.java
@@ -25,6 +25,7 @@
import java.net.URISyntaxException;
import java.util.ArrayList;
import java.util.Collection;
+import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
@@ -33,6 +34,7 @@
import java.util.SortedSet;
import java.util.TreeSet;
import javax.xml.parsers.ParserConfigurationException;
+import javax.xml.xpath.XPath;
import org.w3c.dom.Attr;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
@@ -59,7 +61,7 @@
*/
public abstract class Canonicalizer11 extends CanonicalizerBase {
boolean firstCall = true;
- final SortedSet result = new TreeSet(COMPARE);
+ final SortedSet<Attr> result = new TreeSet<Attr>(COMPARE);
static final String XMLNS_URI = Constants.NamespaceSpecNS;
static final String XML_LANG_URI = Constants.XML_LANG_SPACE_SpecNS;
@@ -72,9 +74,9 @@
static class XmlsStackElement {
int level;
boolean rendered = false;
- List nodes = new ArrayList();
+ List<Attr> nodes = new ArrayList<Attr>();
};
- List levels = new ArrayList();
+ List<XmlsStackElement> levels = new ArrayList<XmlsStackElement>();
void push(int level) {
currentLevel = level;
if (currentLevel == -1)
@@ -86,7 +88,7 @@
lastlevel = 0;
return;
}
- lastlevel=((XmlsStackElement)levels.get(levels.size()-1)).level;
+ lastlevel=(levels.get(levels.size()-1)).level;
}
}
void addXmlnsAttr(Attr n) {
@@ -98,7 +100,7 @@
}
cur.nodes.add(n);
}
- void getXmlnsAttr(Collection col) {
+ void getXmlnsAttr(Collection<Attr> col) {
if (cur == null) {
cur = new XmlsStackElement();
cur.level = currentLevel;
@@ -111,7 +113,7 @@
if (size == -1) {
parentRendered = true;
} else {
- e = (XmlsStackElement) levels.get(size);
+ e = levels.get(size);
if (e.rendered && e.level+1 == currentLevel)
parentRendered = true;
}
@@ -121,17 +123,17 @@
return;
}
- Map loa = new HashMap();
- List baseAttrs = new ArrayList();
+ Map<String, Attr> loa = new HashMap<String, Attr>();
+ List<Attr> baseAttrs = new ArrayList<Attr>();
boolean successiveOmitted = true;
for (;size>=0;size--) {
- e = (XmlsStackElement) levels.get(size);
+ e = levels.get(size);
if (e.rendered) {
successiveOmitted = false;
}
- Iterator it = e.nodes.iterator();
+ Iterator<Attr> it = e.nodes.iterator();
while (it.hasNext() && successiveOmitted) {
- Attr n = (Attr) it.next();
+ Attr n = it.next();
if (n.getLocalName().equals("base")) {
if (!e.rendered) {
baseAttrs.add(n);
@@ -141,11 +143,11 @@
}
}
if (!baseAttrs.isEmpty()) {
- Iterator it = cur.nodes.iterator();
+ Iterator<Attr> it = cur.nodes.iterator();
String base = null;
Attr baseAttr = null;
while (it.hasNext()) {
- Attr n = (Attr) it.next();
+ Attr n = it.next();
if (n.getLocalName().equals("base")) {
base = n.getValue();
baseAttr = n;
@@ -154,7 +156,7 @@
}
it = baseAttrs.iterator();
while (it.hasNext()) {
- Attr n = (Attr) it.next();
+ Attr n = it.next();
if (base == null) {
base = n.getValue();
baseAttr = n;
@@ -202,13 +204,13 @@
* @return the Attr[]s to be outputted
* @throws CanonicalizationException
*/
- Iterator handleAttributesSubtree(Element E, NameSpaceSymbTable ns)
+ Iterator<Attr> handleAttributesSubtree(Element E, NameSpaceSymbTable ns)
throws CanonicalizationException {
if (!E.hasAttributes() && !firstCall) {
return null;
}
// result will contain the attrs which have to be outputted
- final SortedSet result = this.result;
+ final SortedSet<Attr> result = this.result;
result.clear();
NamedNodeMap attrs = E.getAttributes();
int attrsLength = attrs.getLength();
@@ -236,7 +238,7 @@
if (n != null) {
// Render the ns definition
- result.add(n);
+ result.add((Attr)n);
if (C14nHelper.namespaceIsRelative(N)) {
Object exArgs[] = {E.getTagName(), NName, N.getNodeValue()};
throw new CanonicalizationException(
@@ -251,13 +253,15 @@
// to the output.
ns.getUnrenderedNodes(result);
// output the attributes in the xml namespace.
- xmlattrStack.getXmlnsAttr(result);
+ xmlattrStack.getXmlnsAttr(getSortedSetAsCollection(result));
firstCall = false;
}
return result.iterator();
}
+
+
/**
* Returns the Attr[]s to be outputted for the given element.
* <br>
@@ -271,7 +275,7 @@
* @return the Attr[]s to be outputted
* @throws CanonicalizationException
*/
- Iterator handleAttributes(Element E, NameSpaceSymbTable ns)
+ Iterator<Attr> handleAttributes(Element E, NameSpaceSymbTable ns)
throws CanonicalizationException {
// result will contain the attrs which have to be output
xmlattrStack.push(ns.getLevel());
@@ -283,11 +287,11 @@
attrsLength = attrs.getLength();
}
- SortedSet result = this.result;
+ SortedSet<Attr> result = this.result;
result.clear();
for (int i = 0; i < attrsLength; i++) {
- Attr N = (Attr) attrs.item(i);
+ Attr N = (Attr)attrs.item(i);
String NUri = N.getNamespaceURI();
if (XMLNS_URI != NUri) {
@@ -332,7 +336,7 @@
// (NName, NValue, N, isRealVisible);
Node n = ns.addMappingAndRender(NName, NValue, N);
if (n != null) {
- result.add(n);
+ result.add((Attr)n);
if (C14nHelper.namespaceIsRelative(N)) {
Object exArgs[] =
{ E.getTagName(), NName, N.getNodeValue() };
@@ -362,7 +366,7 @@
}
// output the xmlns def if needed.
if (n != null) {
- result.add(n);
+ result.add((Attr)n);
}
// Float all xml:* attributes of the unselected parent elements to
// this one. addXmlAttributes(E,result);
@@ -381,7 +385,7 @@
* @return none it always fails
* @throws CanonicalizationException always
*/
- public byte[] engineCanonicalizeXPathNodeSet(Set xpathNodeSet,
+ public byte[] engineCanonicalizeXPathNodeSet(Set<Node> xpathNodeSet,
String inclusiveNamespaces) throws CanonicalizationException {
throw new CanonicalizationException(
"c14n.Canonicalizer.UnsupportedOperation");
diff --git a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/c14n/implementations/Canonicalizer20010315.java b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/c14n/implementations/Canonicalizer20010315.java
index 541c2d6..b0b2e0b 100644
--- a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/c14n/implementations/Canonicalizer20010315.java
+++ b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/c14n/implementations/Canonicalizer20010315.java
@@ -57,7 +57,7 @@
*/
public abstract class Canonicalizer20010315 extends CanonicalizerBase {
boolean firstCall=true;
- final SortedSet result= new TreeSet(COMPARE);
+ final SortedSet<Attr> result= new TreeSet<Attr>(COMPARE);
static final String XMLNS_URI=Constants.NamespaceSpecNS;
static final String XML_LANG_URI=Constants.XML_LANG_SPACE_SpecNS;
static class XmlAttrStack {
@@ -67,9 +67,9 @@
static class XmlsStackElement {
int level;
boolean rendered=false;
- List nodes=new ArrayList();
+ List<Attr> nodes=new ArrayList<Attr>();
};
- List levels=new ArrayList();
+ List<XmlsStackElement> levels=new ArrayList<XmlsStackElement>();
void push(int level) {
currentLevel=level;
if (currentLevel==-1)
@@ -81,7 +81,7 @@
lastlevel=0;
return;
}
- lastlevel=((XmlsStackElement)levels.get(levels.size()-1)).level;
+ lastlevel=(levels.get(levels.size()-1)).level;
}
}
void addXmlnsAttr(Attr n) {
@@ -93,7 +93,7 @@
}
cur.nodes.add(n);
}
- void getXmlnsAttr(Collection col) {
+ void getXmlnsAttr(Collection<Attr> col) {
int size=levels.size()-1;
if (cur==null) {
cur=new XmlsStackElement();
@@ -106,7 +106,7 @@
if (size==-1) {
parentRendered=true;
} else {
- e=(XmlsStackElement)levels.get(size);
+ e=levels.get(size);
if (e.rendered && e.level+1==currentLevel)
parentRendered=true;
@@ -117,12 +117,12 @@
return;
}
- Map loa = new HashMap();
+ Map<String,Attr> loa = new HashMap<String,Attr>();
for (;size>=0;size--) {
- e=(XmlsStackElement)levels.get(size);
- Iterator it=e.nodes.iterator();
+ e=levels.get(size);
+ Iterator<Attr> it=e.nodes.iterator();
while (it.hasNext()) {
- Attr n=(Attr)it.next();
+ Attr n=it.next();
if (!loa.containsKey(n.getName()))
loa.put(n.getName(),n);
}
@@ -161,13 +161,13 @@
* @return the Attr[]s to be outputted
* @throws CanonicalizationException
*/
- Iterator handleAttributesSubtree(Element E, NameSpaceSymbTable ns )
+ Iterator<Attr> handleAttributesSubtree(Element E, NameSpaceSymbTable ns )
throws CanonicalizationException {
if (!E.hasAttributes() && !firstCall) {
return null;
}
// result will contain the attrs which have to be outputted
- final SortedSet result = this.result;
+ final SortedSet<Attr> result = this.result;
result.clear();
NamedNodeMap attrs = E.getAttributes();
int attrsLength = attrs.getLength();
@@ -194,7 +194,7 @@
if (n!=null) {
//Render the ns definition
- result.add(n);
+ result.add((Attr)n);
if (C14nHelper.namespaceIsRelative(N)) {
Object exArgs[] = { E.getTagName(), NName, N.getNodeValue() };
throw new CanonicalizationException(
@@ -206,7 +206,7 @@
if (firstCall) {
//It is the first node of the subtree
//Obtain all the namespaces defined in the parents, and added to the output.
- ns.getUnrenderedNodes(result);
+ ns.getUnrenderedNodes(getSortedSetAsCollection(result));
//output the attributes in the xml namespace.
xmlattrStack.getXmlnsAttr(result);
firstCall=false;
@@ -227,7 +227,7 @@
* @return the Attr[]s to be outputted
* @throws CanonicalizationException
*/
- Iterator handleAttributes(Element E, NameSpaceSymbTable ns ) throws CanonicalizationException {
+ Iterator<Attr> handleAttributes(Element E, NameSpaceSymbTable ns ) throws CanonicalizationException {
// result will contain the attrs which have to be outputted
xmlattrStack.push(ns.getLevel());
boolean isRealVisible=isVisibleDO(E,ns.getLevel())==1;
@@ -239,7 +239,7 @@
}
- SortedSet result = this.result;
+ SortedSet<Attr> result = this.result;
result.clear();
for (int i = 0; i < attrsLength; i++) {
@@ -277,7 +277,7 @@
//Node n=ns.addMappingAndRenderXNodeSet(NName,NValue,N,isRealVisible);
Node n=ns.addMappingAndRender(NName,NValue,N);
if (n!=null) {
- result.add(n);
+ result.add((Attr)n);
if (C14nHelper.namespaceIsRelative(N)) {
Object exArgs[] = { E.getTagName(), NName, N.getNodeValue() };
throw new CanonicalizationException(
@@ -306,12 +306,12 @@
}
//output the xmlns def if needed.
if (n!=null) {
- result.add(n);
+ result.add((Attr)n);
}
//Float all xml:* attributes of the unselected parent elements to this one.
//addXmlAttributes(E,result);
xmlattrStack.getXmlnsAttr(result);
- ns.getUnrenderedNodes(result);
+ ns.getUnrenderedNodes(getSortedSetAsCollection(result));
}
@@ -325,7 +325,7 @@
* @return none it always fails
* @throws CanonicalizationException always
*/
- public byte[] engineCanonicalizeXPathNodeSet(Set xpathNodeSet, String inclusiveNamespaces)
+ public byte[] engineCanonicalizeXPathNodeSet(Set<Node> xpathNodeSet, String inclusiveNamespaces)
throws CanonicalizationException {
/** $todo$ well, should we throw UnsupportedOperationException ? */
diff --git a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/c14n/implementations/Canonicalizer20010315Excl.java b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/c14n/implementations/Canonicalizer20010315Excl.java
index 679c7b5..9dec09b 100644
--- a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/c14n/implementations/Canonicalizer20010315Excl.java
+++ b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/c14n/implementations/Canonicalizer20010315Excl.java
@@ -61,9 +61,9 @@
* This Set contains the names (Strings like "xmlns" or "xmlns:foo") of
* the inclusive namespaces.
*/
- TreeSet _inclusiveNSSet = new TreeSet();
+ TreeSet<String> _inclusiveNSSet = new TreeSet<String>();
static final String XMLNS_URI=Constants.NamespaceSpecNS;
- final SortedSet result = new TreeSet(COMPARE);
+ final SortedSet<Attr> result = new TreeSet<Attr>(COMPARE);
/**
* Constructor Canonicalizer20010315Excl
*
@@ -106,8 +106,7 @@
*/
public byte[] engineCanonicalizeSubTree(Node rootNode,
String inclusiveNamespaces,Node excl) throws CanonicalizationException {
- this._inclusiveNSSet = (TreeSet)InclusiveNamespaces
- .prefixStr2Set(inclusiveNamespaces);
+ this._inclusiveNSSet = getInclusiveNameSpace(inclusiveNamespaces);
return super.engineCanonicalizeSubTree(rootNode,excl);
}
/**
@@ -117,10 +116,10 @@
* @return the rootNode c14n.
* @throws CanonicalizationException
*/
+ @SuppressWarnings("unchecked")
public byte[] engineCanonicalize(XMLSignatureInput rootNode,
String inclusiveNamespaces) throws CanonicalizationException {
- this._inclusiveNSSet = (TreeSet)InclusiveNamespaces
- .prefixStr2Set(inclusiveNamespaces);
+ this._inclusiveNSSet = getInclusiveNameSpace(inclusiveNamespaces);
return super.engineCanonicalize(rootNode);
}
@@ -130,12 +129,12 @@
* @param E
* @throws CanonicalizationException
*/
- Iterator handleAttributesSubtree(Element E,NameSpaceSymbTable ns)
+ Iterator<Attr> handleAttributesSubtree(Element E,NameSpaceSymbTable ns)
throws CanonicalizationException {
// System.out.println("During the traversal, I encountered " +
// XMLUtils.getXPath(E));
// result will contain the attrs which have to be outputted
- SortedSet result = this.result;
+ SortedSet<Attr> result = this.result;
result.clear();
NamedNodeMap attrs=null;
@@ -145,7 +144,7 @@
attrsLength = attrs.getLength();
}
//The prefix visibly utilized(in the attribute or in the name) in the element
- SortedSet visiblyUtilized =(SortedSet) _inclusiveNSSet.clone();
+ SortedSet<String> visiblyUtilized = getNSSetClone();
for (int i = 0; i < attrsLength; i++) {
Attr N = (Attr) attrs.item(i);
@@ -187,9 +186,9 @@
visiblyUtilized.add(prefix);
//This can be optimezed by I don't have time
- Iterator it=visiblyUtilized.iterator();
+ Iterator<String> it=visiblyUtilized.iterator();
while (it.hasNext()) {
- String s=(String)it.next();
+ String s=it.next();
Attr key=ns.getMapping(s);
if (key==null) {
continue;
@@ -207,25 +206,35 @@
* @param inclusiveNamespaces
* @throws CanonicalizationException
*/
- public byte[] engineCanonicalizeXPathNodeSet(Set xpathNodeSet,
+ public byte[] engineCanonicalizeXPathNodeSet(Set<Node> xpathNodeSet,
String inclusiveNamespaces) throws CanonicalizationException {
-
- this._inclusiveNSSet = (TreeSet)InclusiveNamespaces
- .prefixStr2Set(inclusiveNamespaces);
+ this._inclusiveNSSet = getInclusiveNameSpace(inclusiveNamespaces);
return super.engineCanonicalizeXPathNodeSet(xpathNodeSet);
}
+ @SuppressWarnings("unchecked")
+ private TreeSet<String> getInclusiveNameSpace(String inclusiveNameSpaces) {
+ return (TreeSet<String>)InclusiveNamespaces.prefixStr2Set(inclusiveNameSpaces);
+ }
+
+
+ @SuppressWarnings("unchecked")
+ private SortedSet<String> getNSSetClone() {
+ return (SortedSet<String>) this._inclusiveNSSet.clone();
+ }
+
+
/**
* @inheritDoc
* @param E
* @throws CanonicalizationException
*/
- final Iterator handleAttributes(Element E, NameSpaceSymbTable ns)
+ final Iterator<Attr> handleAttributes(Element E, NameSpaceSymbTable ns)
throws CanonicalizationException {
// result will contain the attrs which have to be outputted
- SortedSet result = this.result;
+ SortedSet<Attr> result = this.result;
result.clear();
NamedNodeMap attrs = null;
int attrsLength = 0;
@@ -234,11 +243,11 @@
attrsLength = attrs.getLength();
}
//The prefix visibly utilized(in the attribute or in the name) in the element
- Set visiblyUtilized =null;
+ Set<String> visiblyUtilized =null;
//It's the output selected.
boolean isOutputElement=isVisibleDO(E,ns.getLevel())==1;
if (isOutputElement) {
- visiblyUtilized = (Set) this._inclusiveNSSet.clone();
+ visiblyUtilized = getNSSetClone();
}
for (int i = 0; i < attrsLength; i++) {
@@ -272,7 +281,7 @@
if (!isOutputElement && isVisible(N) && _inclusiveNSSet.contains(NName) && !ns.removeMappingIfRender(NName)) {
Node n=ns.addMappingAndRender(NName,NNodeValue,N);
if (n!=null) {
- result.add(n);
+ result.add((Attr)n);
if (C14nHelper.namespaceIsRelative(N)) {
Object exArgs[] = { E.getTagName(), NName, N.getNodeValue() };
throw new CanonicalizationException(
@@ -315,9 +324,9 @@
}
//This can be optimezed by I don't have time
//visiblyUtilized.addAll(this._inclusiveNSSet);
- Iterator it=visiblyUtilized.iterator();
+ Iterator<String> it=visiblyUtilized.iterator();
while (it.hasNext()) {
- String s=(String)it.next();
+ String s=it.next();
Attr key=ns.getMapping(s);
if (key==null) {
continue;
diff --git a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/c14n/implementations/CanonicalizerBase.java b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/c14n/implementations/CanonicalizerBase.java
index 05f22d8..77024c2 100644
--- a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/c14n/implementations/CanonicalizerBase.java
+++ b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/c14n/implementations/CanonicalizerBase.java
@@ -33,9 +33,12 @@
import java.util.ListIterator;
import java.util.Map;
import java.util.Set;
+import java.util.SortedSet;
+import java.util.Collection;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
+import javax.xml.xpath.XPath;
import com.sun.org.apache.xml.internal.security.c14n.CanonicalizationException;
import com.sun.org.apache.xml.internal.security.c14n.CanonicalizerSpi;
@@ -94,10 +97,10 @@
}
}
- List nodeFilter;
+ List<NodeFilter> nodeFilter;
boolean _includeComments;
- Set _xpathNodeSet = null;
+ Set<Node> _xpathNodeSet = null;
/**
* The node to be skiped/excluded from the DOM tree
* in subtree canonicalizations.
@@ -130,7 +133,7 @@
* @param xpathNodeSet
* @throws CanonicalizationException
*/
- public byte[] engineCanonicalizeXPathNodeSet(Set xpathNodeSet)
+ public byte[] engineCanonicalizeXPathNodeSet(Set<Node> xpathNodeSet)
throws CanonicalizationException {
this._xpathNodeSet = xpathNodeSet;
return engineCanonicalizeXPathNodeSetInternal(XMLUtils.getOwnerDocument(this._xpathNodeSet));
@@ -251,7 +254,7 @@
final OutputStream writer=this._writer;
final Node excludeNode=this._excludeNode;
final boolean includeComments=this._includeComments;
- Map cache=new HashMap();
+ Map<String, byte[]> cache=new HashMap<String, byte[]>();
do {
switch (currentNode.getNodeType()) {
@@ -298,11 +301,11 @@
String name=currentElement.getTagName();
UtfHelpper.writeByte(name,writer,cache);
- Iterator attrs = this.handleAttributesSubtree(currentElement,ns);
+ Iterator<Attr> attrs = this.handleAttributesSubtree(currentElement,ns);
if (attrs!=null) {
//we output all Attrs which are available
while (attrs.hasNext()) {
- Attr attr = (Attr) attrs.next();
+ Attr attr = attrs.next();
outputAttrToWriter(attr.getNodeName(),attr.getNodeValue(), writer,cache);
}
}
@@ -394,7 +397,7 @@
Node parentNode=null;
OutputStream writer=this._writer;
int documentLevel=NODE_BEFORE_DOCUMENT_ELEMENT;
- Map cache=new HashMap();
+ Map<String, byte[]> cache=new HashMap<String,byte[]>();
do {
switch (currentNode.getNodeType()) {
@@ -464,11 +467,11 @@
ns.push();
}
- Iterator attrs = handleAttributes(currentElement,ns);
+ Iterator<Attr> attrs = handleAttributes(currentElement,ns);
if (attrs!=null) {
//we output all Attrs which are available
while (attrs.hasNext()) {
- Attr attr = (Attr) attrs.next();
+ Attr attr = attrs.next();
outputAttrToWriter(attr.getNodeName(),attr.getNodeValue(), writer,cache);
}
}
@@ -522,9 +525,9 @@
}
int isVisibleDO(Node currentNode,int level) {
if (nodeFilter!=null) {
- Iterator it=nodeFilter.iterator();
+ Iterator<NodeFilter> it=nodeFilter.iterator();
while (it.hasNext()) {
- int i=((NodeFilter)it.next()).isNodeIncludeDO(currentNode,level);
+ int i=(it.next()).isNodeIncludeDO(currentNode,level);
if (i!=1)
return i;
}
@@ -535,9 +538,9 @@
}
int isVisibleInt(Node currentNode) {
if (nodeFilter!=null) {
- Iterator it=nodeFilter.iterator();
+ Iterator<NodeFilter> it=nodeFilter.iterator();
while (it.hasNext()) {
- int i=((NodeFilter)it.next()).isNodeInclude(currentNode);
+ int i=(it.next()).isNodeInclude(currentNode);
if (i!=1)
return i;
}
@@ -549,9 +552,9 @@
boolean isVisible(Node currentNode) {
if (nodeFilter!=null) {
- Iterator it=nodeFilter.iterator();
+ Iterator<NodeFilter> it=nodeFilter.iterator();
while (it.hasNext()) {
- if (((NodeFilter)it.next()).isNodeInclude(currentNode)!=1)
+ if ((it.next()).isNodeInclude(currentNode)!=1)
return false;
}
}
@@ -589,7 +592,7 @@
* @param ns
*/
final void getParentNameSpaces(Element el,NameSpaceSymbTable ns) {
- List parents=new ArrayList(10);
+ List<Element> parents=new ArrayList<Element>(10);
Node n1=el.getParentNode();
if (!(n1 instanceof Element)) {
return;
@@ -605,9 +608,9 @@
parent=(Element)n;
}
//Visit them in reverse order.
- ListIterator it=parents.listIterator(parents.size());
+ ListIterator<Element> it=parents.listIterator(parents.size());
while (it.hasPrevious()) {
- Element ele=(Element)it.previous();
+ Element ele=it.previous();
handleParent(ele, ns);
}
Attr nsprefix;
@@ -624,7 +627,7 @@
* @return the attributes nodes to output.
* @throws CanonicalizationException
*/
- abstract Iterator handleAttributes(Element E, NameSpaceSymbTable ns )
+ abstract Iterator<Attr> handleAttributes(Element E, NameSpaceSymbTable ns )
throws CanonicalizationException;
/**
@@ -635,7 +638,7 @@
* @return the attributes nodes to output.
* @throws CanonicalizationException
*/
- abstract Iterator handleAttributesSubtree(Element E, NameSpaceSymbTable ns)
+ abstract Iterator<Attr> handleAttributesSubtree(Element E, NameSpaceSymbTable ns)
throws CanonicalizationException;
abstract void circumventBugIfNeeded(XMLSignatureInput input) throws CanonicalizationException, ParserConfigurationException, IOException, SAXException;
@@ -660,7 +663,7 @@
* @throws IOException
*/
static final void outputAttrToWriter(final String name, final String value, final OutputStream writer,
- final Map cache) throws IOException {
+ final Map<String, byte[]> cache) throws IOException {
writer.write(' ');
UtfHelpper.writeByte(name,writer,cache);
writer.write(equalsStr);
@@ -841,4 +844,10 @@
}
}
+ @SuppressWarnings("unchecked")
+ protected Collection<Attr> getSortedSetAsCollection(SortedSet<Attr> result) {
+ return (Collection<Attr>)(Collection)result;
+ }
+
+
}
diff --git a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/c14n/implementations/NameSpaceSymbTable.java b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/c14n/implementations/NameSpaceSymbTable.java
index 538d369..114bf7e 100644
--- a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/c14n/implementations/NameSpaceSymbTable.java
+++ b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/c14n/implementations/NameSpaceSymbTable.java
@@ -44,7 +44,7 @@
/**The level of nameSpaces (for Inclusive visibility).*/
int nameSpaces=0;
/**The stacks for removing the definitions when doing pop.*/
- List level;
+ List<SymbMap> level;
boolean cloned=true;
static final String XMLNS="xmlns";
final static SymbMap initialMap=new SymbMap();
@@ -57,7 +57,7 @@
* Default constractor
**/
public NameSpaceSymbTable() {
- level = new ArrayList(10);
+ level = new ArrayList<SymbMap>(10);
//Insert the default binding for xmlns.
symb=(SymbMap) initialMap.clone();
}
@@ -67,11 +67,11 @@
* For Inclusive rendering
* @param result the list where to fill the unrendered xmlns definitions.
**/
- public void getUnrenderedNodes(Collection result) {
+ public void getUnrenderedNodes(Collection<Attr> result) {
//List result=new ArrayList();
- Iterator it=symb.entrySet().iterator();
+ Iterator<NameSpaceSymbEntry> it=symb.entrySet().iterator();
while (it.hasNext()) {
- NameSpaceSymbEntry n=(NameSpaceSymbEntry)(it.next());
+ NameSpaceSymbEntry n= it.next();
//put them rendered?
if ((!n.rendered) && (n.n!=null)) {
n=(NameSpaceSymbEntry) n.clone();
@@ -339,8 +339,8 @@
}
}
- List entrySet() {
- List a=new ArrayList();
+ List<NameSpaceSymbEntry> entrySet() {
+ List<NameSpaceSymbEntry> a=new ArrayList<NameSpaceSymbEntry>();
for (int i=0;i<entries.length;i++) {
if ((entries[i]!=null) && !("".equals(entries[i].uri))) {
a.add(entries[i]);
diff --git a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/c14n/implementations/UtfHelpper.java b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/c14n/implementations/UtfHelpper.java
index cfcc06d..b62dd3b 100644
--- a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/c14n/implementations/UtfHelpper.java
+++ b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/c14n/implementations/UtfHelpper.java
@@ -6,8 +6,8 @@
public class UtfHelpper {
- final static void writeByte(final String str,final OutputStream out,Map cache) throws IOException {
- byte []result=(byte[]) cache.get(str);
+ final static void writeByte(final String str,final OutputStream out,Map<String,byte[]> cache) throws IOException {
+ byte []result= cache.get(str);
if (result==null) {
result=getStringInUtf8(str);
cache.put(str,result);
diff --git a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/encryption/AgreementMethod.java b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/encryption/AgreementMethod.java
index 81a49b4..803fca8 100644
--- a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/encryption/AgreementMethod.java
+++ b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/encryption/AgreementMethod.java
@@ -95,7 +95,7 @@
* Returns aditional information regarding the <code>AgreementMethod</code>.
* @return
*/
- Iterator getAgreementMethodInformation();
+ Iterator<Element> getAgreementMethodInformation();
/**
* Adds additional <code>AgreementMethod</code> information.
diff --git a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/encryption/EncryptionMethod.java b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/encryption/EncryptionMethod.java
index 7700f45..2664db9 100644
--- a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/encryption/EncryptionMethod.java
+++ b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/encryption/EncryptionMethod.java
@@ -89,7 +89,7 @@
* @return an <code>Iterator</code> over all the additional infomation
* about the <code>EncryptionMethod</code>.
*/
- Iterator getEncryptionMethodInformation();
+ Iterator<Element> getEncryptionMethodInformation();
/**
* Adds encryption method information.
diff --git a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/encryption/EncryptionProperties.java b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/encryption/EncryptionProperties.java
index 307a134..da1eb65 100644
--- a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/encryption/EncryptionProperties.java
+++ b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/encryption/EncryptionProperties.java
@@ -67,7 +67,7 @@
*
* @return an <code>Iterator</code> over all the encryption properties.
*/
- Iterator getEncryptionProperties();
+ Iterator<EncryptionProperty> getEncryptionProperties();
/**
* Adds an <code>EncryptionProperty</code>.
diff --git a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/encryption/EncryptionProperty.java b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/encryption/EncryptionProperty.java
index 9f61495..4cd6c46 100644
--- a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/encryption/EncryptionProperty.java
+++ b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/encryption/EncryptionProperty.java
@@ -101,7 +101,7 @@
* @return an <code>Iterator</code> over all the addiitonal encryption
* information contained in this class.
*/
- Iterator getEncryptionInformation();
+ Iterator<Element> getEncryptionInformation();
/**
* Adds encryption information.
diff --git a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/encryption/Reference.java b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/encryption/Reference.java
index 0039a41..4523a89 100644
--- a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/encryption/Reference.java
+++ b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/encryption/Reference.java
@@ -74,7 +74,7 @@
*
* @return child elements.
*/
- Iterator getElementRetrievalInformation();
+ Iterator<Element> getElementRetrievalInformation();
/**
* Adds retrieval information.
diff --git a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/encryption/ReferenceList.java b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/encryption/ReferenceList.java
index 7fd5b85..2cf0ec5 100644
--- a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/encryption/ReferenceList.java
+++ b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/encryption/ReferenceList.java
@@ -87,7 +87,7 @@
*
* @return Iterator.
*/
- public Iterator getReferences();
+ public Iterator<Reference> getReferences();
/**
* <code>DataReference</code> factory method. Returns a
diff --git a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/encryption/XMLCipher.java b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/encryption/XMLCipher.java
index 683acdb..8479835 100644
--- a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/encryption/XMLCipher.java
+++ b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/encryption/XMLCipher.java
@@ -2772,7 +2772,7 @@
// </complexType>
private class AgreementMethodImpl implements AgreementMethod {
private byte[] kaNonce = null;
- private List agreementMethodInformation = null;
+ private List<Element> agreementMethodInformation = null;
private KeyInfo originatorKeyInfo = null;
private KeyInfo recipientKeyInfo = null;
private String algorithmURI = null;
@@ -2781,7 +2781,7 @@
* @param algorithm
*/
public AgreementMethodImpl(String algorithm) {
- agreementMethodInformation = new LinkedList();
+ agreementMethodInformation = new LinkedList<Element>();
URI tmpAlgorithm = null;
try {
tmpAlgorithm = new URI(algorithm);
@@ -2802,7 +2802,7 @@
}
/** @inheritDoc */
- public Iterator getAgreementMethodInformation() {
+ public Iterator<Element> getAgreementMethodInformation() {
return (agreementMethodInformation.iterator());
}
@@ -2879,9 +2879,9 @@
_contextDocument.createTextNode(new String(kaNonce)));
}
if (!agreementMethodInformation.isEmpty()) {
- Iterator itr = agreementMethodInformation.iterator();
+ Iterator<Element> itr = agreementMethodInformation.iterator();
while (itr.hasNext()) {
- result.appendChild((Element) itr.next());
+ result.appendChild(itr.next());
}
}
if (null != originatorKeyInfo) {
@@ -3486,7 +3486,7 @@
private String algorithm = null;
private int keySize = Integer.MIN_VALUE;
private byte[] oaepParams = null;
- private List encryptionMethodInformation = null;
+ private List<Element> encryptionMethodInformation = null;
/**
*
* @param algorithm
@@ -3499,7 +3499,7 @@
// complain
}
this.algorithm = tmpAlgorithm.toString();
- encryptionMethodInformation = new LinkedList();
+ encryptionMethodInformation = new LinkedList<Element>();
}
/** @inheritDoc */
public String getAlgorithm() {
@@ -3522,7 +3522,7 @@
oaepParams = params;
}
/** @inheritDoc */
- public Iterator getEncryptionMethodInformation() {
+ public Iterator<Element> getEncryptionMethodInformation() {
return (encryptionMethodInformation.iterator());
}
/** @inheritDoc */
@@ -3565,8 +3565,8 @@
new String(oaepParams))));
}
if (!encryptionMethodInformation.isEmpty()) {
- Iterator itr = encryptionMethodInformation.iterator();
- result.appendChild((Element) itr.next());
+ Iterator<Element> itr = encryptionMethodInformation.iterator();
+ result.appendChild(itr.next());
}
return (result);
@@ -3582,13 +3582,13 @@
// </complexType>
private class EncryptionPropertiesImpl implements EncryptionProperties {
private String id = null;
- private List encryptionProperties = null;
+ private List<EncryptionProperty> encryptionProperties = null;
/**
*
*
*/
public EncryptionPropertiesImpl() {
- encryptionProperties = new LinkedList();
+ encryptionProperties = new LinkedList<EncryptionProperty>();
}
/** @inheritDoc */
public String getId() {
@@ -3599,7 +3599,7 @@
this.id = id;
}
/** @inheritDoc */
- public Iterator getEncryptionProperties() {
+ public Iterator<EncryptionProperty> getEncryptionProperties() {
return (encryptionProperties.iterator());
}
/** @inheritDoc */
@@ -3625,7 +3625,7 @@
if (null != id) {
result.setAttributeNS(null, EncryptionConstants._ATT_ID, id);
}
- Iterator itr = getEncryptionProperties();
+ Iterator<EncryptionProperty> itr = getEncryptionProperties();
while (itr.hasNext()) {
result.appendChild(((EncryptionPropertyImpl)
itr.next()).toElement());
@@ -3647,15 +3647,15 @@
private class EncryptionPropertyImpl implements EncryptionProperty {
private String target = null;
private String id = null;
- private HashMap attributeMap = new HashMap();
- private List encryptionInformation = null;
+ private HashMap<String,String> attributeMap = new HashMap<String,String>();
+ private List<Element> encryptionInformation = null;
/**
*
*
*/
public EncryptionPropertyImpl() {
- encryptionInformation = new LinkedList();
+ encryptionInformation = new LinkedList<Element>();
}
/** @inheritDoc */
public String getTarget() {
@@ -3692,14 +3692,14 @@
}
/** @inheritDoc */
public String getAttribute(String attribute) {
- return (String) attributeMap.get(attribute);
+ return attributeMap.get(attribute);
}
/** @inheritDoc */
public void setAttribute(String attribute, String value) {
attributeMap.put(attribute, value);
}
/** @inheritDoc */
- public Iterator getEncryptionInformation() {
+ public Iterator<Element> getEncryptionInformation() {
return (encryptionInformation.iterator());
}
/** @inheritDoc */
@@ -3821,8 +3821,8 @@
// </complexType>
//</element>
private class ReferenceListImpl implements ReferenceList {
- private Class sentry;
- private List references;
+ private Class<?> sentry;
+ private List<Reference> references;
/**
*
* @param type
@@ -3835,7 +3835,7 @@
} else {
throw new IllegalArgumentException();
}
- references = new LinkedList();
+ references = new LinkedList<Reference>();
}
/** @inheritDoc */
public void add(Reference reference) {
@@ -3860,7 +3860,7 @@
return (references.isEmpty());
}
/** @inheritDoc */
- public Iterator getReferences() {
+ public Iterator<Reference> getReferences() {
return (references.iterator());
}
@@ -3869,9 +3869,9 @@
_contextDocument,
EncryptionConstants.EncryptionSpecNS,
EncryptionConstants._TAG_REFERENCELIST);
- Iterator eachReference = references.iterator();
+ Iterator<Reference> eachReference = references.iterator();
while (eachReference.hasNext()) {
- Reference reference = (Reference) eachReference.next();
+ Reference reference = eachReference.next();
result.appendChild(
((ReferenceImpl) reference).toElement());
}
@@ -3894,18 +3894,18 @@
*/
private abstract class ReferenceImpl implements Reference {
private String uri;
- private List referenceInformation;
+ private List<Element> referenceInformation;
ReferenceImpl(String _uri) {
this.uri = _uri;
- referenceInformation = new LinkedList();
+ referenceInformation = new LinkedList<Element>();
}
/** @inheritDoc */
public String getURI() {
return (uri);
}
/** @inheritDoc */
- public Iterator getElementRetrievalInformation() {
+ public Iterator<Element> getElementRetrievalInformation() {
return (referenceInformation.iterator());
}
/** @inheritDoc */
diff --git a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/keys/KeyInfo.java b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/keys/KeyInfo.java
index cf588b8..0a39b1a 100644
--- a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/keys/KeyInfo.java
+++ b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/keys/KeyInfo.java
@@ -97,12 +97,12 @@
/** {@link java.util.logging} logging facility */
static java.util.logging.Logger log =
java.util.logging.Logger.getLogger(KeyInfo.class.getName());
- List x509Datas=null;
- List encryptedKeys=null;
+ List<X509Data> x509Datas=null;
+ List<EncryptedKey> encryptedKeys=null;
- static final List nullList;
+ static final List<StorageResolver> nullList;
static {
- List list = new ArrayList();
+ List<StorageResolver> list = new ArrayList<StorageResolver>(1);
list.add(null);
nullList = Collections.unmodifiableList(list);
}
@@ -297,7 +297,7 @@
*/
public void add(X509Data x509data) {
if (x509Datas==null)
- x509Datas=new ArrayList();
+ x509Datas=new ArrayList<X509Data>();
x509Datas.add(x509data);
this._constructionElement.appendChild(x509data.getElement());
XMLUtils.addReturnToElement(this._constructionElement);
@@ -313,7 +313,7 @@
public void add(EncryptedKey encryptedKey)
throws XMLEncryptionException {
if (encryptedKeys==null)
- encryptedKeys=new ArrayList();
+ encryptedKeys=new ArrayList<EncryptedKey>();
encryptedKeys.add(encryptedKey);
XMLCipher cipher = XMLCipher.getInstance();
this._constructionElement.appendChild(cipher.martial(encryptedKey));
@@ -541,7 +541,7 @@
*/
public X509Data itemX509Data(int i) throws XMLSecurityException {
if (x509Datas!=null) {
- return (X509Data) x509Datas.get(i);
+ return x509Datas.get(i);
}
Element e = XMLUtils.selectDsNode(this._constructionElement.getFirstChild(),
Constants._TAG_X509DATA,i);
@@ -562,7 +562,7 @@
public EncryptedKey itemEncryptedKey(int i) throws XMLSecurityException {
if (encryptedKeys!=null) {
- return (EncryptedKey) encryptedKeys.get(i);
+ return encryptedKeys.get(i);
}
Element e =
XMLUtils.selectXencNode(this._constructionElement.getFirstChild(),
@@ -728,16 +728,16 @@
PublicKey getPublicKeyFromStaticResolvers() throws KeyResolverException {
int length=KeyResolver.length();
int storageLength=this._storageResolvers.size();
- Iterator it= KeyResolver.iterator();
+ Iterator<KeyResolverSpi> it= KeyResolver.iterator();
for (int i = 0; i < length; i++) {
- KeyResolverSpi keyResolver = (KeyResolverSpi) it.next();
+ KeyResolverSpi keyResolver = it.next();
Node currentChild=this._constructionElement.getFirstChild();
String uri= this.getBaseURI();
while (currentChild!=null) {
if (currentChild.getNodeType() == Node.ELEMENT_NODE) {
for (int k = 0; k < storageLength; k++) {
StorageResolver storage =
- (StorageResolver) this._storageResolvers.get(k);
+ this._storageResolvers.get(k);
PublicKey pk =
keyResolver.engineLookupAndResolvePublicKey((Element) currentChild,
@@ -776,7 +776,7 @@
if (currentChild.getNodeType() == Node.ELEMENT_NODE) {
for (int k = 0; k < storageLength; k++) {
StorageResolver storage =
- (StorageResolver) this._storageResolvers.get(k);
+ this._storageResolvers.get(k);
PublicKey pk = keyResolver
.engineLookupAndResolvePublicKey((Element) currentChild, uri, storage);
@@ -845,9 +845,9 @@
String uri=this.getBaseURI();
int length= KeyResolver.length();
int storageLength=this._storageResolvers.size();
- Iterator it = KeyResolver.iterator();
+ Iterator<KeyResolverSpi> it = KeyResolver.iterator();
for (int i = 0; i <length; i++) {
- KeyResolverSpi keyResolver = (KeyResolverSpi) it.next();
+ KeyResolverSpi keyResolver = it.next();
X509Certificate cert= applyCurrentResolver(uri, storageLength, keyResolver);
if (cert!=null) {
KeyResolver.hit(it);
@@ -863,7 +863,7 @@
if (currentChild.getNodeType() == Node.ELEMENT_NODE) {
for (int k = 0; k < storageLength; k++) {
StorageResolver storage =
- (StorageResolver) this._storageResolvers.get(k);
+ this._storageResolvers.get(k);
X509Certificate cert = keyResolver
.engineLookupResolveX509Certificate((Element) currentChild, uri,
@@ -944,9 +944,9 @@
SecretKey getSecretKeyFromStaticResolvers() throws KeyResolverException {
final int length=KeyResolver.length();
int storageLength=this._storageResolvers.size();
- Iterator it = KeyResolver.iterator();
+ Iterator<KeyResolverSpi> it = KeyResolver.iterator();
for (int i = 0; i < length; i++) {
- KeyResolverSpi keyResolver = (KeyResolverSpi) it.next();
+ KeyResolverSpi keyResolver = it.next();
Node currentChild=this._constructionElement.getFirstChild();
String uri=this.getBaseURI();
@@ -954,7 +954,7 @@
if (currentChild.getNodeType() == Node.ELEMENT_NODE) {
for (int k = 0; k < storageLength; k++) {
StorageResolver storage =
- (StorageResolver) this._storageResolvers.get(k);
+ this._storageResolvers.get(k);
SecretKey sk =
keyResolver.engineLookupAndResolveSecretKey((Element) currentChild,
@@ -992,7 +992,7 @@
if (currentChild.getNodeType() == Node.ELEMENT_NODE) {
for (int k = 0; k < storageLength; k++) {
StorageResolver storage =
- (StorageResolver) this._storageResolvers.get(k);
+ this._storageResolvers.get(k);
SecretKey sk = keyResolver
.engineLookupAndResolveSecretKey((Element) currentChild, uri, storage);
@@ -1012,7 +1012,7 @@
/**
* Stores the individual (per-KeyInfo) {@link KeyResolver}s
*/
- List _internalKeyResolvers = null;
+ List<KeyResolverSpi> _internalKeyResolvers = null;
/**
* This method is used to add a custom {@link KeyResolverSpi} to a KeyInfo
@@ -1022,7 +1022,7 @@
*/
public void registerInternalKeyResolver(KeyResolverSpi realKeyResolver) {
if (_internalKeyResolvers==null) {
- _internalKeyResolvers=new ArrayList();
+ _internalKeyResolvers=new ArrayList<KeyResolverSpi>();
}
this._internalKeyResolvers.add(realKeyResolver);
}
@@ -1044,11 +1044,11 @@
* @return the KeyResolverSpi for the index.
*/
KeyResolverSpi itemInternalKeyResolver(int i) {
- return (KeyResolverSpi) this._internalKeyResolvers.get(i);
+ return this._internalKeyResolvers.get(i);
}
/** Field _storageResolvers */
- List _storageResolvers = nullList;
+ List<StorageResolver> _storageResolvers = nullList;
/**
* Method addStorageResolver
@@ -1057,7 +1057,7 @@
*/
public void addStorageResolver(StorageResolver storageResolver) {
if (_storageResolvers == nullList ){
- _storageResolvers=new ArrayList();
+ _storageResolvers=new ArrayList<StorageResolver>();
}
this._storageResolvers.add(storageResolver);
diff --git a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/keys/keyresolver/KeyResolver.java b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/keys/keyresolver/KeyResolver.java
index 1da9dbb..a10cb41 100644
--- a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/keys/keyresolver/KeyResolver.java
+++ b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/keys/keyresolver/KeyResolver.java
@@ -52,7 +52,7 @@
static boolean _alreadyInitialized = false;
/** Field _resolverVector */
- static List _resolverVector = null;
+ static List<KeyResolver> _resolverVector = null;
/** Field _resolverSpi */
protected KeyResolverSpi _resolverSpi = null;
@@ -85,12 +85,12 @@
return KeyResolver._resolverVector.size();
}
- public static void hit(Iterator hintI) {
+ public static void hit(Iterator<KeyResolverSpi> hintI) {
ResolverIterator hint = (ResolverIterator) hintI;
int i = hint.i;
if (i!=1 && hint.res ==_resolverVector) {
- List resolverVector=(List)((ArrayList)_resolverVector).clone();
- Object ob=resolverVector.remove(i-1);
+ List<KeyResolver> resolverVector=getResolverVectorClone();
+ KeyResolver ob=resolverVector.remove(i-1);
resolverVector.add(0,ob);
_resolverVector=resolverVector;
} else {
@@ -113,12 +113,9 @@
throws KeyResolverException {
// use the old vector to not be hit by updates
- List resolverVector = KeyResolver._resolverVector;
- for (int i = 0; i < resolverVector.size(); i++) {
- KeyResolver resolver=
- (KeyResolver) resolverVector.get(i);
-
- if (resolver==null) {
+ List<KeyResolver> resolverVector = KeyResolver._resolverVector;
+ for (KeyResolver resolver : resolverVector) {
+ if (resolver==null) {
Object exArgs[] = {
(((element != null)
&& (element.getNodeType() == Node.ELEMENT_NODE))
@@ -157,10 +154,8 @@
Element element, String BaseURI, StorageResolver storage)
throws KeyResolverException {
- List resolverVector = KeyResolver._resolverVector;
- for (int i = 0; i < resolverVector.size(); i++) {
- KeyResolver resolver=
- (KeyResolver) resolverVector.get(i);
+ List<KeyResolver> resolverVector = KeyResolver._resolverVector;
+ for (KeyResolver resolver : resolverVector) {
if (resolver==null) {
Object exArgs[] = {
@@ -176,11 +171,11 @@
PublicKey cert=resolver.resolvePublicKey(element, BaseURI, storage);
if (cert!=null) {
- if (i!=0 && resolverVector==_resolverVector) {
+ if (resolverVector.indexOf(resolver)!=0 && resolverVector==_resolverVector) {
//update resolver.
- resolverVector=(List)((ArrayList)_resolverVector).clone();
- Object ob=resolverVector.remove(i);
- resolverVector.add(0,ob);
+ resolverVector=getResolverVectorClone();
+ resolverVector.remove(resolver);
+ resolverVector.add(0,resolver);
_resolverVector=resolverVector;
}
return cert;
@@ -195,13 +190,19 @@
throw new KeyResolverException("utils.resolver.noClass", exArgs);
}
+
+ @SuppressWarnings("unchecked")
+ private static List<KeyResolver> getResolverVectorClone() {
+ return (List<KeyResolver>)((ArrayList<KeyResolver>)_resolverVector).clone();
+ }
+
/**
* The init() function is called by com.sun.org.apache.xml.internal.security.Init.init()
*/
public static void init() {
if (!KeyResolver._alreadyInitialized) {
- KeyResolver._resolverVector = new ArrayList(10);
+ KeyResolver._resolverVector = new ArrayList<KeyResolver>(10);
_alreadyInitialized = true;
}
}
@@ -230,8 +231,8 @@
*
* @param className
*/
- public static void registerAtStart(String className) {
- KeyResolver._resolverVector.add(0, className);
+ public static void registerAtStart(String className) throws ClassNotFoundException, IllegalAccessException, InstantiationException {
+ register(className);
}
/**
@@ -322,11 +323,11 @@
return this._resolverSpi.getClass().getName();
}
- static class ResolverIterator implements Iterator {
- List res;
- Iterator it;
+ static class ResolverIterator implements Iterator<KeyResolverSpi> {
+ List<KeyResolver> res;
+ Iterator<KeyResolver> it;
int i;
- public ResolverIterator(List list) {
+ public ResolverIterator(List<KeyResolver> list) {
res = list;
it = res.iterator();
}
@@ -335,9 +336,9 @@
return it.hasNext();
}
- public Object next() {
+ public KeyResolverSpi next() {
i++;
- KeyResolver resolver = (KeyResolver) it.next();
+ KeyResolver resolver = it.next();
if (resolver==null) {
throw new RuntimeException("utils.resolver.noClass");
}
@@ -351,7 +352,7 @@
}
};
- public static Iterator iterator() {
+ public static Iterator<KeyResolverSpi> iterator() {
return new ResolverIterator(_resolverVector);
}
}
diff --git a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/keys/keyresolver/KeyResolverSpi.java b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/keys/keyresolver/KeyResolverSpi.java
index dc2865b..3e5c82c 100644
--- a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/keys/keyresolver/KeyResolverSpi.java
+++ b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/keys/keyresolver/KeyResolverSpi.java
@@ -32,7 +32,7 @@
/**
* This class is abstract class for a child KeyInfo Elemnet.
*
- * If you want the your KeyResolver, at firstly you must extand this class, and register
+ * If you want your KeyResolver, at first you must extend this class, and register
* as following in config.xml
* <PRE>
* <KeyResolver URI="http://www.w3.org/2000/09/xmldsig#KeyValue"
@@ -177,7 +177,7 @@
}
/** Field _properties */
- protected java.util.Map _properties = null;
+ protected java.util.Map<String,String> _properties = null;
protected boolean globalResolver=false;
@@ -189,7 +189,7 @@
*/
public void engineSetProperty(String key, String value) {
if (_properties==null)
- _properties=new HashMap();
+ _properties=new HashMap<String,String>();
this._properties.put(key, value);
}
@@ -203,7 +203,7 @@
if (_properties==null)
return null;
- return (String) this._properties.get(key);
+ return this._properties.get(key);
}
/**
diff --git a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/keys/keyresolver/implementations/RetrievalMethodResolver.java b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/keys/keyresolver/implementations/RetrievalMethodResolver.java
index 3dff218..8067442 100644
--- a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/keys/keyresolver/implementations/RetrievalMethodResolver.java
+++ b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/keys/keyresolver/implementations/RetrievalMethodResolver.java
@@ -278,18 +278,18 @@
return null;
}
- static Element getDocumentElement(Set set) {
- Iterator it=set.iterator();
+ static Element getDocumentElement(Set<Node> set) {
+ Iterator<Node> it=set.iterator();
Element e=null;
while (it.hasNext()) {
- Node currentNode=(Node)it.next();
+ Node currentNode=it.next();
if (currentNode instanceof Element) {
e=(Element)currentNode;
break;
}
}
- List parents=new ArrayList(10);
+ List<Element> parents=new ArrayList<Element>(10);
//Obtain all the parents of the elemnt
do {
@@ -301,10 +301,10 @@
e=(Element)n;
} while (e!=null);
//Visit them in reverse order.
- ListIterator it2=parents.listIterator(parents.size()-1);
+ ListIterator<Element> it2=parents.listIterator(parents.size()-1);
Element ele=null;
while (it2.hasPrevious()) {
- ele=(Element)it2.previous();
+ ele=it2.previous();
if (set.contains(ele)) {
return ele;
}
diff --git a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/keys/storage/StorageResolver.java b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/keys/storage/StorageResolver.java
index f1a8dd3..7b11e84 100644
--- a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/keys/storage/StorageResolver.java
+++ b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/keys/storage/StorageResolver.java
@@ -42,10 +42,10 @@
java.util.logging.Logger.getLogger(StorageResolver.class.getName());
/** Field _storageResolvers */
- List _storageResolvers = null;
+ List<Object> _storageResolvers = null;
/** Field _iterator */
- Iterator _iterator = null;
+ Iterator<Object> _iterator = null;
/**
* Constructor StorageResolver
@@ -69,7 +69,7 @@
*/
public void add(StorageResolverSpi resolver) {
if (_storageResolvers==null)
- _storageResolvers=new ArrayList();
+ _storageResolvers=new ArrayList<Object>();
this._storageResolvers.add(resolver);
this._iterator = null;
@@ -121,11 +121,11 @@
* @return the iterator for the resolvers.
*
*/
- public Iterator getIterator() {
+ public Iterator<Object> getIterator() {
if (this._iterator == null) {
if (_storageResolvers==null)
- _storageResolvers=new ArrayList();
+ _storageResolvers=new ArrayList<Object>();
this._iterator = new StorageResolverIterator(this._storageResolvers.iterator());
}
@@ -141,7 +141,7 @@
if (this._iterator == null) {
if (_storageResolvers==null)
- _storageResolvers=new ArrayList();
+ _storageResolvers=new ArrayList<Object>();
this._iterator = new StorageResolverIterator(this._storageResolvers.iterator());
}
@@ -163,17 +163,17 @@
* @author $Author: mullan $
* @version $Revision: 1.5 $
*/
- static class StorageResolverIterator implements Iterator {
+ static class StorageResolverIterator implements Iterator<Object> {
/** Field _resolvers */
- Iterator _resolvers = null;
+ Iterator<Object> _resolvers = null;
/**
* Constructor FilesystemIterator
*
* @param resolvers
*/
- public StorageResolverIterator(Iterator resolvers) {
+ public StorageResolverIterator(Iterator<Object> resolvers) {
this._resolvers = resolvers;
}
diff --git a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/keys/storage/StorageResolverSpi.java b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/keys/storage/StorageResolverSpi.java
index 25f3e28..0721125 100644
--- a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/keys/storage/StorageResolverSpi.java
+++ b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/keys/storage/StorageResolverSpi.java
@@ -36,5 +36,5 @@
*
* @return the iterator for the storage
*/
- public abstract Iterator getIterator();
+ public abstract Iterator<?> getIterator();
}
diff --git a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/keys/storage/implementations/CertsInFilesystemDirectoryResolver.java b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/keys/storage/implementations/CertsInFilesystemDirectoryResolver.java
index 06fb569..3b38e4a 100644
--- a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/keys/storage/implementations/CertsInFilesystemDirectoryResolver.java
+++ b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/keys/storage/implementations/CertsInFilesystemDirectoryResolver.java
@@ -54,10 +54,10 @@
String _merlinsCertificatesDir = null;
/** Field _certs */
- private List _certs = new ArrayList();
+ private List<X509Certificate> _certs = new ArrayList<X509Certificate>();
/** Field _iterator */
- Iterator _iterator = null;
+ Iterator<X509Certificate> _iterator = null;
/**
*
@@ -83,7 +83,7 @@
private void readCertsFromHarddrive() throws StorageResolverException {
File certDir = new File(this._merlinsCertificatesDir);
- ArrayList al = new ArrayList();
+ ArrayList<String> al = new ArrayList<String>();
String[] names = certDir.list();
for (int i = 0; i < names.length; i++) {
@@ -108,7 +108,7 @@
for (int i = 0; i < al.size(); i++) {
String filename = certDir.getAbsolutePath() + File.separator
- + (String) al.get(i);
+ + al.get(i);
File file = new File(filename);
boolean added = false;
String dn = null;
@@ -146,7 +146,7 @@
}
/** @inheritDoc */
- public Iterator getIterator() {
+ public Iterator<X509Certificate> getIterator() {
return this._iterator;
}
@@ -156,10 +156,10 @@
* @author $Author: mullan $
* @version $Revision: 1.5 $
*/
- private static class FilesystemIterator implements Iterator {
+ private static class FilesystemIterator implements Iterator<X509Certificate> {
/** Field _certs */
- List _certs = null;
+ List<X509Certificate> _certs = null;
/** Field _i */
int _i;
@@ -169,7 +169,7 @@
*
* @param certs
*/
- public FilesystemIterator(List certs) {
+ public FilesystemIterator(List<X509Certificate> certs) {
this._certs = certs;
this._i = 0;
}
@@ -180,7 +180,7 @@
}
/** @inheritDoc */
- public Object next() {
+ public X509Certificate next() {
return this._certs.get(this._i++);
}
@@ -206,8 +206,8 @@
new CertsInFilesystemDirectoryResolver(
"data/ie/baltimore/merlin-examples/merlin-xmldsig-eighteen/certs");
- for (Iterator i = krs.getIterator(); i.hasNext(); ) {
- X509Certificate cert = (X509Certificate) i.next();
+ for (Iterator<X509Certificate> i = krs.getIterator(); i.hasNext(); ) {
+ X509Certificate cert = i.next();
byte[] ski =
com.sun.org.apache.xml.internal.security.keys.content.x509.XMLX509SKI
.getSKIBytesFromCert(cert);
diff --git a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/keys/storage/implementations/KeyStoreResolver.java b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/keys/storage/implementations/KeyStoreResolver.java
index 1863243..2a56621 100644
--- a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/keys/storage/implementations/KeyStoreResolver.java
+++ b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/keys/storage/implementations/KeyStoreResolver.java
@@ -42,7 +42,7 @@
KeyStore _keyStore = null;
/** Field _iterator */
- Iterator _iterator = null;
+ Iterator<X509Certificate> _iterator = null;
/**
* Constructor KeyStoreResolver
@@ -56,7 +56,7 @@
}
/** @inheritDoc */
- public Iterator getIterator() {
+ public Iterator<X509Certificate> getIterator() {
return this._iterator;
}
@@ -66,13 +66,13 @@
* @author $Author: mullan $
* @version $Revision: 1.5 $
*/
- static class KeyStoreIterator implements Iterator {
+ static class KeyStoreIterator implements Iterator<X509Certificate> {
/** Field _keyStore */
KeyStore _keyStore = null;
/** Field _aliases */
- Enumeration _aliases = null;
+ Enumeration<String> _aliases = null;
/**
* Constructor KeyStoreIterator
@@ -97,12 +97,13 @@
}
/** @inheritDoc */
- public Object next() {
+ @SuppressWarnings("unchecked")
+ public X509Certificate next() {
- String alias = (String) this._aliases.nextElement();
+ String alias = this._aliases.nextElement();
try {
- return this._keyStore.getCertificate(alias);
+ return (X509Certificate)this._keyStore.getCertificate(alias);
} catch (KeyStoreException ex) {
return null;
}
@@ -135,8 +136,8 @@
KeyStoreResolver krs = new KeyStoreResolver(ks);
- for (Iterator i = krs.getIterator(); i.hasNext(); ) {
- X509Certificate cert = (X509Certificate) i.next();
+ for (Iterator<X509Certificate> i = krs.getIterator(); i.hasNext(); ) {
+ X509Certificate cert = i.next();
byte[] ski =
com.sun.org.apache.xml.internal.security.keys.content.x509.XMLX509SKI
.getSKIBytesFromCert(cert);
diff --git a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/keys/storage/implementations/SingleCertificateResolver.java b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/keys/storage/implementations/SingleCertificateResolver.java
index 7e61b2a..3048bb1 100644
--- a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/keys/storage/implementations/SingleCertificateResolver.java
+++ b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/keys/storage/implementations/SingleCertificateResolver.java
@@ -38,7 +38,7 @@
X509Certificate _certificate = null;
/** Field _iterator */
- Iterator _iterator = null;
+ Iterator<X509Certificate> _iterator = null;
/**
*
@@ -51,7 +51,7 @@
}
/** @inheritDoc */
- public Iterator getIterator() {
+ public Iterator<X509Certificate> getIterator() {
return this._iterator;
}
@@ -61,7 +61,7 @@
* @author $Author: mullan $
* @version $Revision: 1.5 $
*/
- static class InternalIterator implements Iterator {
+ static class InternalIterator implements Iterator<X509Certificate> {
/** Field _alreadyReturned */
boolean _alreadyReturned = false;
@@ -84,7 +84,7 @@
}
/** @inheritDoc */
- public Object next() {
+ public X509Certificate next() {
this._alreadyReturned = true;
diff --git a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/signature/Manifest.java b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/signature/Manifest.java
index 97ea751..440a0124 100644
--- a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/signature/Manifest.java
+++ b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/signature/Manifest.java
@@ -28,6 +28,7 @@
import java.util.Iterator;
import java.util.List;
import java.util.Set;
+import java.util.Map;
import javax.xml.parsers.ParserConfigurationException;
@@ -62,17 +63,17 @@
java.util.logging.Logger.getLogger(Manifest.class.getName());
/** Field _references */
- List _references;
+ List<Reference> _references;
Element[] _referencesEl;
/** Field verificationResults[] */
private boolean verificationResults[] = null;
/** Field _resolverProperties */
- HashMap _resolverProperties = null;
+ Map<String,String> _resolverProperties = null;
/** Field _perManifestResolvers */
- List _perManifestResolvers = null;
+ List<ResourceResolver> _perManifestResolvers = null;
/**
* Consturts {@link Manifest}
@@ -85,7 +86,7 @@
XMLUtils.addReturnToElement(this._constructionElement);
- this._references = new ArrayList();
+ this._references = new ArrayList<Reference>();
}
/**
@@ -117,7 +118,7 @@
}
// create Vector
- this._references = new ArrayList(le);
+ this._references = new ArrayList<Reference>(le);
for (int i = 0; i < le; i++) {
this._references.add(null);
@@ -175,7 +176,7 @@
for (int i = 0; i < this.getLength(); i++) {
// update the cached Reference object, the Element content is automatically updated
- Reference currentRef = (Reference) this._references.get(i);
+ Reference currentRef = this._references.get(i);
currentRef.generateDigestValue();
}
@@ -208,7 +209,7 @@
this._references.set(i, ref);
}
- return (Reference) this._references.get(i);
+ return this._references.get(i);
}
@@ -323,12 +324,12 @@
try {
XMLSignatureInput signedManifestNodes =
currentRef.dereferenceURIandPerformTransforms(null);
- Set nl = signedManifestNodes.getNodeSet();
+ Set<Node> nl = signedManifestNodes.getNodeSet();
Manifest referencedManifest = null;
- Iterator nlIterator = nl.iterator();
+ Iterator<Node> nlIterator = nl.iterator();
findManifest: while (nlIterator.hasNext()) {
- Node n = (Node) nlIterator.next();
+ Node n = nlIterator.next();
if ((n.getNodeType() == Node.ELEMENT_NODE) && ((Element) n)
.getNamespaceURI()
@@ -449,7 +450,7 @@
return;
}
if (_perManifestResolvers==null)
- _perManifestResolvers = new ArrayList();
+ _perManifestResolvers = new ArrayList<ResourceResolver>();
this._perManifestResolvers.add(resolver);
}
@@ -465,7 +466,7 @@
return;
}
if (_perManifestResolvers==null)
- _perManifestResolvers = new ArrayList();
+ _perManifestResolvers = new ArrayList<ResourceResolver>();
this._perManifestResolvers.add(new ResourceResolver(resolverSpi));
}
@@ -479,7 +480,7 @@
*/
public void setResolverProperty(String key, String value) {
if (_resolverProperties==null) {
- _resolverProperties=new HashMap(10);
+ _resolverProperties=new HashMap<String, String>(10);
}
this._resolverProperties.put(key, value);
}
@@ -491,7 +492,7 @@
* @return the value
*/
public String getResolverProperty(String key) {
- return (String) this._resolverProperties.get(key);
+ return this._resolverProperties.get(key);
}
/**
diff --git a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/signature/Reference.java b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/signature/Reference.java
index ed2c568..8e29839 100644
--- a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/signature/Reference.java
+++ b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/signature/Reference.java
@@ -436,6 +436,7 @@
*
* @deprecated use getContentsBeforeTransformation
*/
+ @Deprecated
public XMLSignatureInput getTransformsInput() throws ReferenceNotInitializedException
{
XMLSignatureInput input=getContentsBeforeTransformation();
@@ -557,7 +558,7 @@
try {
XMLSignatureInput nodes = this.getNodesetBeforeFirstCanonicalization();
- Set inclusiveNamespaces = new HashSet();
+ Set<String> inclusiveNamespaces = new HashSet<String>();
{
Transforms transforms = this.getTransforms();
@@ -710,7 +711,7 @@
XMLSignatureInput output=this.dereferenceURIandPerformTransforms(os);
// if signing and c14n11 property == true explicitly add
// C14N11 transform if needed
- if (this.useC14N11 && !validating &&
+ if (Reference.useC14N11 && !validating &&
!output.isOutputStreamSet() && !output.isOctetStream()) {
if (transforms == null) {
transforms = new Transforms(this._doc);
diff --git a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/signature/XMLSignatureInput.java b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/signature/XMLSignatureInput.java
index e02e889..2ba9e25 100644
--- a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/signature/XMLSignatureInput.java
+++ b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/signature/XMLSignatureInput.java
@@ -74,7 +74,7 @@
/**
* The original NodeSet for this XMLSignatureInput
*/
- Set _inputNodeSet = null;
+ Set<Node> _inputNodeSet = null;
/**
* The original Element
*/
@@ -107,7 +107,7 @@
/**
* Node Filter list.
*/
- List nodeFilters=new ArrayList();
+ List<NodeFilter> nodeFilters=new ArrayList<NodeFilter>();
boolean needsToBeExpanded=false;
OutputStream outputStream=null;
@@ -164,6 +164,7 @@
* @deprecated
* @param inputStr the input String which including XML document or node
*/
+ @Deprecated
public XMLSignatureInput(String inputStr) {
this(inputStr.getBytes());
}
@@ -179,6 +180,7 @@
* @param encoding the encoding of <code>inputStr</code>
* @throws UnsupportedEncodingException
*/
+ @Deprecated
public XMLSignatureInput(String inputStr, String encoding)
throws UnsupportedEncodingException {
this(inputStr.getBytes(encoding));
@@ -201,7 +203,7 @@
* @param inputNodeSet
* @param usedXPathAPI
*/
- public XMLSignatureInput(Set inputNodeSet) {
+ public XMLSignatureInput(Set<Node> inputNodeSet) {
this._inputNodeSet = inputNodeSet;
}
@@ -215,7 +217,7 @@
* @throws ParserConfigurationException
* @throws CanonicalizationException
*/
- public Set getNodeSet() throws CanonicalizationException,
+ public Set<Node> getNodeSet() throws CanonicalizationException,
ParserConfigurationException, IOException, SAXException {
return getNodeSet(false);
}
@@ -231,7 +233,7 @@
* @throws ParserConfigurationException
* @throws CanonicalizationException
*/
- public Set getNodeSet(boolean circumvent)
+ public Set<Node> getNodeSet(boolean circumvent)
throws ParserConfigurationException, IOException, SAXException,
CanonicalizationException {
if (this._inputNodeSet!=null) {
@@ -242,13 +244,13 @@
if (circumvent) {
XMLUtils.circumventBug2650(XMLUtils.getOwnerDocument(_subNode));
}
- this._inputNodeSet = new HashSet();
+ this._inputNodeSet = new HashSet<Node>();
XMLUtils.getSet(_subNode,this._inputNodeSet, excludeNode, this.excludeComments);
return this._inputNodeSet;
} else if (this.isOctetStream()) {
convertToNodes();
- HashSet result=new HashSet();
+ HashSet<Node> result=new HashSet<Node>();
XMLUtils.getSet(_subNode, result,null,false);
//this._inputNodeSet=result;
return result;
@@ -447,7 +449,7 @@
* @throws XMLSignatureException
* @return The HTML representation for this XMLSignature
*/
- public String getHTMLRepresentation(Set inclusiveNamespaces)
+ public String getHTMLRepresentation(Set<String> inclusiveNamespaces)
throws XMLSignatureException {
XMLSignatureInputDebugger db = new XMLSignatureInputDebugger( this,
@@ -584,7 +586,7 @@
/**
* @return the node filters
*/
- public List getNodeFilters() {
+ public List<NodeFilter> getNodeFilters() {
// TODO Auto-generated method stub
return nodeFilters;
}
diff --git a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/signature/XMLSignatureInputDebugger.java b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/signature/XMLSignatureInputDebugger.java
index 8fe1ca3..3186ef4 100644
--- a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/signature/XMLSignatureInputDebugger.java
+++ b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/signature/XMLSignatureInputDebugger.java
@@ -47,9 +47,9 @@
/** Field _xmlSignatureInput */
- private Set _xpathNodeSet;
+ private Set<Node> _xpathNodeSet;
- private Set _inclusiveNamespaces;
+ private Set<String> _inclusiveNamespaces;
/** Field _doc */
private Document _doc = null;
@@ -159,7 +159,7 @@
* @param inclusiveNamespace
*/
public XMLSignatureInputDebugger(
- XMLSignatureInput xmlSignatureInput, Set inclusiveNamespace) {
+ XMLSignatureInput xmlSignatureInput, Set<String> inclusiveNamespace) {
this(xmlSignatureInput);
@@ -182,7 +182,7 @@
{
// get only a single node as anchor to fetch the owner document
- Node n = (Node) this._xpathNodeSet.iterator().next();
+ Node n = this._xpathNodeSet.iterator().next();
this._doc = XMLUtils.getOwnerDocument(n);
}
@@ -341,10 +341,10 @@
// we output all Attrs which are available
NamedNodeMap attrs = currentElement.getAttributes();
int attrsLength = attrs.getLength();
- Object attrs2[] = new Object[attrsLength];
+ Attr attrs2[] = new Attr[attrsLength];
for (int i = 0; i < attrsLength; i++) {
- attrs2[i] = attrs.item(i);
+ attrs2[i] = (Attr)attrs.item(i);
}
Arrays.sort(attrs2, ATTR_COMPARE);
diff --git a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/transforms/Transform.java b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/transforms/Transform.java
index 7471313..7e1a519 100644
--- a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/transforms/Transform.java
+++ b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/transforms/Transform.java
@@ -25,6 +25,7 @@
import java.security.AccessController;
import java.security.PrivilegedAction;
import java.util.HashMap;
+import java.util.Map;
import javax.xml.parsers.ParserConfigurationException;
import com.sun.org.apache.xml.internal.security.c14n.CanonicalizationException;
@@ -65,9 +66,9 @@
private static boolean alreadyInitialized = false;
/** All available Transform classes are registered here */
- private static HashMap transformClassHash = null;
+ private static Map<String, Class<?>> transformClassHash = null;
- private static HashMap transformSpiHash = new HashMap();
+ private static Map<String, TransformSpi> transformSpiHash = new HashMap<String, TransformSpi>();
private TransformSpi transformSpi = null;
@@ -209,7 +210,7 @@
*/
public static void init() {
if (!alreadyInitialized) {
- transformClassHash = new HashMap(10);
+ transformClassHash = new HashMap<String,Class<?>>(10);
// make sure builtin algorithms are all registered first
com.sun.org.apache.xml.internal.security.Init.init();
alreadyInitialized = true;
@@ -231,7 +232,7 @@
throws AlgorithmAlreadyRegisteredException {
// are we already registered?
- Class registeredClass = getImplementingClass(algorithmURI);
+ Class<? extends TransformSpi> registeredClass = getImplementingClass(algorithmURI);
if ((registeredClass != null) ) {
Object exArgs[] = { algorithmURI, registeredClass };
throw new AlgorithmAlreadyRegisteredException(
@@ -331,20 +332,21 @@
* @param URI
* @return The name of the class implementing the URI.
*/
- private static Class getImplementingClass(String URI) {
- return (Class) transformClassHash.get(URI);
+ @SuppressWarnings("unchecked")
+ private static Class<? extends TransformSpi> getImplementingClass(String URI) {
+ return (Class<? extends TransformSpi>)transformClassHash.get(URI);
}
private static TransformSpi getTransformSpi(String URI)
throws InvalidTransformException {
try {
- Object value = transformSpiHash.get(URI);
+ TransformSpi value = transformSpiHash.get(URI);
if (value != null) {
- return (TransformSpi) value;
+ return value;
}
- Class cl = (Class) transformClassHash.get(URI);
+ Class<? extends TransformSpi> cl = getImplementingClass(URI);
if (cl != null) {
- TransformSpi tr = (TransformSpi) cl.newInstance();
+ TransformSpi tr = cl.newInstance();
transformSpiHash.put(URI, tr);
return tr;
}
diff --git a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/transforms/TransformSpi.java b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/transforms/TransformSpi.java
index 11cc8df..35aa9ff 100644
--- a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/transforms/TransformSpi.java
+++ b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/transforms/TransformSpi.java
@@ -41,6 +41,7 @@
* For API compatibility not thread safe.
* @deprecated
*/
+ @Deprecated
protected Transform _transformObject = null;
/**
* Set the transform object.
@@ -48,6 +49,7 @@
* @param transform the Transform
* @deprecated
*/
+ @Deprecated
protected void setTransform(Transform transform) {
this._transformObject = transform;
}
@@ -120,6 +122,7 @@
* @throws SAXException
* @throws TransformationException
*/
+ @Deprecated
protected XMLSignatureInput enginePerformTransform(
XMLSignatureInput input)
throws IOException,
diff --git a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/transforms/implementations/FuncHere.java b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/transforms/implementations/FuncHere.java
index 8f9766e..15c1b57 100644
--- a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/transforms/implementations/FuncHere.java
+++ b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/transforms/implementations/FuncHere.java
@@ -154,6 +154,7 @@
* @param vars
* @param globalsSize
*/
+ @SuppressWarnings("rawtypes")
public void fixupVariables(java.util.Vector vars, int globalsSize) {
// do nothing
diff --git a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/transforms/implementations/TransformXPath2Filter.java b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/transforms/implementations/TransformXPath2Filter.java
index 4f0f1bb..d58453c 100644
--- a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/transforms/implementations/TransformXPath2Filter.java
+++ b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/transforms/implementations/TransformXPath2Filter.java
@@ -96,9 +96,9 @@
throws TransformationException {
CachedXPathAPIHolder.setDoc(_transformObject.getElement().getOwnerDocument());
try {
- List unionNodes=new ArrayList();
- List substractNodes=new ArrayList();
- List intersectNodes=new ArrayList();
+ List<NodeList> unionNodes=new ArrayList<NodeList>();
+ List<NodeList> substractNodes=new ArrayList<NodeList>();
+ List<NodeList> intersectNodes=new ArrayList<NodeList>();
CachedXPathFuncHereAPI xPathFuncHereAPI =
new CachedXPathFuncHereAPI(CachedXPathAPIHolder.getCachedXPathAPI());
@@ -170,18 +170,15 @@
throw new TransformationException("empty", ex);
}
}
- static Set convertNodeListToSet(List l){
- Set result=new HashSet();
- for (int j=0;j<l.size();j++) {
- NodeList rootNodes=(NodeList) l.get(j);
- int length = rootNodes.getLength();
+ static Set<Node> convertNodeListToSet(List<NodeList> l){
+ Set<Node> result=new HashSet<Node>();
+ for (NodeList rootNodes : l) {
+ int length = rootNodes.getLength();
for (int i = 0; i < length; i++) {
Node rootNode = rootNodes.item(i);
result.add(rootNode);
-
}
-
}
return result;
}
@@ -191,8 +188,8 @@
boolean hasUnionNodes;
boolean hasSubstractNodes;
boolean hasIntersectNodes;
- XPath2NodeFilter(Set unionNodes, Set substractNodes,
- Set intersectNodes) {
+ XPath2NodeFilter(Set<Node> unionNodes, Set<Node> substractNodes,
+ Set<Node> intersectNodes) {
this.unionNodes=unionNodes;
hasUnionNodes=!unionNodes.isEmpty();
this.substractNodes=substractNodes;
@@ -200,9 +197,9 @@
this.intersectNodes=intersectNodes;
hasIntersectNodes=!intersectNodes.isEmpty();
}
- Set unionNodes;
- Set substractNodes;
- Set intersectNodes;
+ Set<Node> unionNodes;
+ Set<Node> substractNodes;
+ Set<Node> intersectNodes;
/**
@@ -282,16 +279,15 @@
*
* @return if rooted bye the rootnodes
*/
- static boolean rooted(Node currentNode, Set nodeList ) {
+ static boolean rooted(Node currentNode, Set<Node> nodeList ) {
if (nodeList.contains(currentNode)) {
return true;
}
- Iterator it=nodeList.iterator();
- while (it.hasNext()) {
- Node rootNode = (Node) it.next();
- if (XMLUtils.isDescendantOrSelf(rootNode,currentNode)) {
- return true;
- }
+
+ for(Node rootNode : nodeList) {
+ if (XMLUtils.isDescendantOrSelf(rootNode,currentNode)) {
+ return true;
+ }
}
return false;
}
@@ -303,7 +299,7 @@
*
* @return if rooted bye the rootnodes
*/
- static boolean inList(Node currentNode, Set nodeList ) {
+ static boolean inList(Node currentNode, Set<Node> nodeList ) {
return nodeList.contains(currentNode);
}
}
diff --git a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/transforms/implementations/TransformXSLT.java b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/transforms/implementations/TransformXSLT.java
index 13da913..8ff4b9f 100644
--- a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/transforms/implementations/TransformXSLT.java
+++ b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/transforms/implementations/TransformXSLT.java
@@ -62,14 +62,6 @@
static final String defaultXSLTSpecNSprefix = "xslt";
static final String XSLTSTYLESHEET = "stylesheet";
- // check for secure processing feature
- private static Class xClass = null;
- static {
- try {
- xClass = Class.forName("javax.xml.XMLConstants");
- } catch (Exception e) {}
- }
-
static java.util.logging.Logger log =
java.util.logging.Logger.getLogger(
TransformXSLT.class.getName());
@@ -101,10 +93,6 @@
protected XMLSignatureInput enginePerformTransform(XMLSignatureInput input,OutputStream baos, Transform _transformObject)
throws IOException,
TransformationException {
- if (xClass == null) {
- Object exArgs[] = { "SECURE_PROCESSING_FEATURE not supported" };
- throw new TransformationException("generic.EmptyMessage", exArgs);
- }
try {
Element transformElement = _transformObject.getElement();
@@ -119,11 +107,9 @@
}
TransformerFactory tFactory = TransformerFactory.newInstance();
- Class c = tFactory.getClass();
- Method m = c.getMethod("setFeature", new Class[] {String.class, boolean.class});
- // Process XSLT stylesheets in a secure manner
- m.invoke(tFactory, new Object[] {"http://javax.xml.XMLConstants/feature/secure-processing", Boolean.TRUE});
+ // Process XSLT stylesheets in a secure manner
+ tFactory.setFeature("http://javax.xml.XMLConstants/feature/secure-processing", Boolean.TRUE);
/*
* This transform requires an octet stream as input. If the actual
* input is an XPath node-set, then the signature application should
@@ -193,18 +179,6 @@
Object exArgs[] = { ex.getMessage() };
throw new TransformationException("generic.EmptyMessage", exArgs, ex);
- } catch (NoSuchMethodException ex) {
- Object exArgs[] = { ex.getMessage() };
-
- throw new TransformationException("generic.EmptyMessage", exArgs, ex);
- } catch (IllegalAccessException ex) {
- Object exArgs[] = { ex.getMessage() };
-
- throw new TransformationException("generic.EmptyMessage", exArgs, ex);
- } catch (java.lang.reflect.InvocationTargetException ex) {
- Object exArgs[] = { ex.getMessage() };
-
- throw new TransformationException("generic.EmptyMessage", exArgs, ex);
}
}
}
diff --git a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/transforms/params/InclusiveNamespaces.java b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/transforms/params/InclusiveNamespaces.java
index c953869..f615881 100644
--- a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/transforms/params/InclusiveNamespaces.java
+++ b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/transforms/params/InclusiveNamespaces.java
@@ -74,19 +74,16 @@
* @param doc
* @param prefixes
*/
- public InclusiveNamespaces(Document doc, Set prefixes) {
+ public InclusiveNamespaces(Document doc, Set<String> prefixes) {
super(doc);
StringBuffer sb = new StringBuffer();
- SortedSet prefixList = new TreeSet(prefixes);
+ SortedSet<String> prefixList = new TreeSet<String>(prefixes);
- Iterator it = prefixList.iterator();
- while (it.hasNext()) {
- String prefix = (String) it.next();
-
+ for (String prefix : prefixList) {
if (prefix.equals("xmlns")) {
sb.append("#default ");
} else {
@@ -138,9 +135,9 @@
* @param inclusiveNamespaces
* @return A set to string
*/
- public static SortedSet prefixStr2Set(String inclusiveNamespaces) {
+ public static SortedSet<String> prefixStr2Set(String inclusiveNamespaces) {
- SortedSet prefixes = new TreeSet();
+ SortedSet<String> prefixes = new TreeSet<String>();
if ((inclusiveNamespaces == null)
|| (inclusiveNamespaces.length() == 0)) {
diff --git a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/utils/CachedXPathAPIHolder.java b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/utils/CachedXPathAPIHolder.java
index fa32270..0a7503a 100644
--- a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/utils/CachedXPathAPIHolder.java
+++ b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/utils/CachedXPathAPIHolder.java
@@ -28,8 +28,8 @@
*/
public class CachedXPathAPIHolder {
- static ThreadLocal local=new ThreadLocal();
- static ThreadLocal localDoc=new ThreadLocal();
+ static ThreadLocal<CachedXPathAPI> local=new ThreadLocal<CachedXPathAPI>();
+ static ThreadLocal<Document> localDoc=new ThreadLocal<Document>();
/**
* Sets the doc for the xpath transformation. Resets the cache if needed
@@ -37,7 +37,7 @@
*/
public static void setDoc(Document doc) {
if (localDoc.get()!=doc) {
- CachedXPathAPI cx=(CachedXPathAPI)local.get();
+ CachedXPathAPI cx=local.get();
if (cx==null) {
cx=new CachedXPathAPI();
local.set(cx);
@@ -54,7 +54,7 @@
* @return the cachexpathapi for this thread
*/
public static CachedXPathAPI getCachedXPathAPI() {
- CachedXPathAPI cx=(CachedXPathAPI)local.get();
+ CachedXPathAPI cx=local.get();
if (cx==null) {
cx=new CachedXPathAPI();
local.set(cx);
diff --git a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/utils/CachedXPathFuncHereAPI.java b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/utils/CachedXPathFuncHereAPI.java
index cd19e5f..fe1ae84 100644
--- a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/utils/CachedXPathFuncHereAPI.java
+++ b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/utils/CachedXPathFuncHereAPI.java
@@ -173,6 +173,7 @@
* @throws TransformerException
* @deprecated
*/
+ @Deprecated
public NodeIterator selectNodeIterator(
Node contextNode, Node xpathnode, Node namespaceNode)
throws TransformerException {
@@ -195,6 +196,7 @@
* @throws TransformerException
* @deprecated
*/
+ @Deprecated
public NodeList selectNodeList(Node contextNode, Node xpathnode)
throws TransformerException {
return selectNodeList(contextNode, xpathnode, getStrFromNode(xpathnode), contextNode);
@@ -239,6 +241,7 @@
* @throws TransformerException
* @deprecated
*/
+ @Deprecated
public XObject eval(Node contextNode, Node xpathnode)
throws TransformerException {
return eval(contextNode, xpathnode, getStrFromNode(xpathnode),contextNode);
@@ -375,12 +378,12 @@
private XPath createXPath(String str, PrefixResolver prefixResolver) throws TransformerException {
XPath xpath = null;
- Class[] classes = new Class[]{String.class, SourceLocator.class, PrefixResolver.class, int.class,
+ Class<?>[] classes = new Class<?>[]{String.class, SourceLocator.class, PrefixResolver.class, int.class,
ErrorListener.class, FunctionTable.class};
Object[] objects = new Object[]{str, null, prefixResolver, new Integer(XPath.SELECT), null, _funcTable};
try {
- Constructor constructor = XPath.class.getConstructor(classes);
- xpath = (XPath) constructor.newInstance(objects);
+ Constructor<XPath> constructor = XPath.class.getConstructor(classes);
+ xpath = constructor.newInstance(objects);
} catch (Throwable t) {
}
if (xpath == null) {
diff --git a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/utils/ElementProxy.java b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/utils/ElementProxy.java
index 4a344b9..f44c76c 100644
--- a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/utils/ElementProxy.java
+++ b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/utils/ElementProxy.java
@@ -24,6 +24,7 @@
import java.math.BigInteger;
import java.util.HashMap;
+import java.util.Map;
import com.sun.org.apache.xml.internal.security.exceptions.Base64DecodingException;
import com.sun.org.apache.xml.internal.security.exceptions.XMLSecurityException;
@@ -370,6 +371,7 @@
* @return the bytes
* @throws XMLSecurityException
*/
+ @Deprecated
public byte[] getBytesFromChildElement(String localname, String namespace)
throws XMLSecurityException {
@@ -392,14 +394,12 @@
*/
public String getTextFromChildElement(String localname, String namespace) {
- Text t =
- (Text) XMLUtils.selectNode(
- this._constructionElement.getFirstChild(),
- namespace,
- localname,
- 0).getFirstChild();
+ return XMLUtils.selectNode(
+ this._constructionElement.getFirstChild(),
+ namespace,
+ localname,
+ 0).getFirstChild().getNodeValue();
- return t.getData();
}
/**
@@ -493,8 +493,8 @@
}
/** Field _prefixMappings */
- static HashMap _prefixMappings = new HashMap();
- static HashMap _prefixMappingsBindings = new HashMap();
+ static Map<String, String> _prefixMappings = new HashMap<String,String>();
+ static Map<String, String> _prefixMappingsBindings = new HashMap<String,String>();
/**
* Method setDefaultPrefix
@@ -533,10 +533,10 @@
* @return the default prefix bind to this element.
*/
public static String getDefaultPrefix(String namespace) {
- return (String) ElementProxy._prefixMappings.get(namespace);
+ return ElementProxy._prefixMappings.get(namespace);
}
public static String getDefaultPrefixBindings(String namespace) {
- return (String) ElementProxy._prefixMappingsBindings.get(namespace);
+ return ElementProxy._prefixMappingsBindings.get(namespace);
}
}
diff --git a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/utils/HelperNodeList.java b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/utils/HelperNodeList.java
index 360f099..cd40b79 100644
--- a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/utils/HelperNodeList.java
+++ b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/utils/HelperNodeList.java
@@ -21,6 +21,7 @@
package com.sun.org.apache.xml.internal.security.utils;
import java.util.ArrayList;
+import java.util.List;
import org.w3c.dom.Document;
import org.w3c.dom.Node;
@@ -34,7 +35,7 @@
public class HelperNodeList implements NodeList {
/** Field nodes */
- ArrayList nodes = new ArrayList(20);
+ List<Node> nodes = new ArrayList<Node>(20);
boolean _allNodesMustHaveSameParent = false;
/**
@@ -62,7 +63,7 @@
// log.log(java.util.logging.Level.FINE, "item(" + index + ") of " + this.getLength() + " nodes");
- return (Node) nodes.get(index);
+ return nodes.get(index);
}
/**
diff --git a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/utils/IdResolver.java b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/utils/IdResolver.java
index da5c496..61baa15 100644
--- a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/utils/IdResolver.java
+++ b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/utils/IdResolver.java
@@ -23,6 +23,7 @@
import java.lang.ref.WeakReference;
import java.util.Arrays;
import java.util.WeakHashMap;
+import java.util.Map;
import org.w3c.dom.Attr;
import org.w3c.dom.Document;
@@ -52,7 +53,8 @@
private static java.util.logging.Logger log =
java.util.logging.Logger.getLogger(IdResolver.class.getName());
- private static WeakHashMap docMap = new WeakHashMap();
+ private static Map<Document, Map<String, WeakReference<Element>>> docMap =
+ new WeakHashMap<Document, Map<String, WeakReference<Element>>>();
/**
* Constructor IdResolver
@@ -70,15 +72,15 @@
*/
public static void registerElementById(Element element, String idValue) {
Document doc = element.getOwnerDocument();
- WeakHashMap elementMap;
+ Map<String, WeakReference<Element>> elementMap;
synchronized (docMap) {
- elementMap = (WeakHashMap) docMap.get(doc);
+ elementMap = docMap.get(doc);
if (elementMap == null) {
- elementMap = new WeakHashMap();
+ elementMap = new WeakHashMap<String, WeakReference<Element>>();
docMap.put(doc, elementMap);
}
}
- elementMap.put(idValue, new WeakReference(element));
+ elementMap.put(idValue, new WeakReference<Element>(element));
}
/**
@@ -156,20 +158,20 @@
private static Element getElementByIdType(Document doc, String id) {
if (log.isLoggable(java.util.logging.Level.FINE))
log.log(java.util.logging.Level.FINE, "getElementByIdType() Search for ID " + id);
- WeakHashMap elementMap;
+ Map<String, WeakReference<Element>> elementMap;
synchronized (docMap) {
- elementMap = (WeakHashMap) docMap.get(doc);
+ elementMap = docMap.get(doc);
}
if (elementMap != null) {
- WeakReference weakReference = (WeakReference) elementMap.get(id);
+ WeakReference<Element> weakReference = elementMap.get(id);
if (weakReference != null) {
- return (Element) weakReference.get();
+ return weakReference.get();
}
}
return null;
}
- private static java.util.List names;
+ private static java.util.List<String> names;
private static int namesLength;
static {
String namespaces[]={
diff --git a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/utils/UnsyncBufferedOutputStream.java b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/utils/UnsyncBufferedOutputStream.java
index 3347b04..e9a7935 100644
--- a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/utils/UnsyncBufferedOutputStream.java
+++ b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/utils/UnsyncBufferedOutputStream.java
@@ -33,8 +33,8 @@
final byte[] buf;
static final int size=8*1024;
- private static ThreadLocal bufCahce = new ThreadLocal() {
- protected synchronized Object initialValue() {
+ private static ThreadLocal<byte[]> bufCahce = new ThreadLocal<byte[]>() {
+ protected synchronized byte[] initialValue() {
return new byte[size];
}
};
@@ -44,7 +44,7 @@
* @param out the outputstream to buffer
*/
public UnsyncBufferedOutputStream(OutputStream out) {
- buf=(byte[])bufCahce.get();
+ buf=bufCahce.get();
this.out=out;
}
diff --git a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/utils/UnsyncByteArrayOutputStream.java b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/utils/UnsyncByteArrayOutputStream.java
index bfba75d..2a2f7dd 100644
--- a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/utils/UnsyncByteArrayOutputStream.java
+++ b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/utils/UnsyncByteArrayOutputStream.java
@@ -29,8 +29,8 @@
*/
public class UnsyncByteArrayOutputStream extends OutputStream {
private static final int INITIAL_SIZE = 8192;
- private static ThreadLocal bufCache = new ThreadLocal() {
- protected synchronized Object initialValue() {
+ private static ThreadLocal<byte[]> bufCache = new ThreadLocal<byte[]>() {
+ protected synchronized byte[] initialValue() {
return new byte[INITIAL_SIZE];
}
};
@@ -40,7 +40,7 @@
private int pos = 0;
public UnsyncByteArrayOutputStream() {
- buf = (byte[])bufCache.get();
+ buf = bufCache.get();
}
public void write(byte[] arg0) {
diff --git a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/utils/XMLUtils.java b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/utils/XMLUtils.java
index 92ca11a..5df2b6e 100644
--- a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/utils/XMLUtils.java
+++ b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/utils/XMLUtils.java
@@ -82,13 +82,15 @@
* @param exclude
* @param com wheather comments or not
*/
- public static void getSet(Node rootNode,Set result,Node exclude ,boolean com) {
+ public static void getSet(Node rootNode,Set<Node> result,Node exclude ,boolean com) {
if ((exclude!=null) && isDescendantOrSelf(exclude,rootNode)){
return;
}
getSetRec(rootNode,result,exclude,com);
}
- static final void getSetRec(final Node rootNode,final Set result,
+
+ @SuppressWarnings("fallthrough")
+ static final void getSetRec(final Node rootNode,final Set<Node> result,
final Node exclude ,final boolean com) {
//Set result = new HashSet();
if (rootNode==exclude) {
@@ -104,7 +106,7 @@
result.add(nl.item(i));
}
}
- //no return keep working
+ //no return keep working - ignore fallthrough warning
case Node.DOCUMENT_NODE:
for (Node r=rootNode.getFirstChild();r!=null;r=r.getNextSibling()){
if (r.getNodeType()==Node.TEXT_NODE) {
@@ -230,7 +232,7 @@
static String dsPrefix=null;
- static Map namePrefixes=new HashMap();
+ static Map<String, String> namePrefixes=new HashMap<String, String>();
/**
* Creates an Element in the XML Signature specification namespace.
*
@@ -248,7 +250,7 @@
if ((dsPrefix == null) || (dsPrefix.length() == 0)) {
return doc.createElementNS(Constants.SignatureSpecNS, elementName);
}
- String namePrefix=(String) namePrefixes.get(elementName);
+ String namePrefix= namePrefixes.get(elementName);
if (namePrefix==null) {
StringBuffer tag=new StringBuffer(dsPrefix);
tag.append(':');
@@ -318,11 +320,9 @@
* @param xpathNodeSet
* @return the owner document
*/
- public static Document getOwnerDocument(Set xpathNodeSet) {
+ public static Document getOwnerDocument(Set<Node> xpathNodeSet) {
NullPointerException npe = null;
- Iterator iterator = xpathNodeSet.iterator();
- while(iterator.hasNext()) {
- Node node = (Node) iterator.next();
+ for (Node node : xpathNodeSet) {
int nodeType =node.getNodeType();
if (nodeType == Node.DOCUMENT_NODE) {
return (Document) node;
@@ -397,14 +397,14 @@
* @param xpathNodeSet
* @return the set with the nodelist
*/
- public static Set convertNodelistToSet(NodeList xpathNodeSet) {
+ public static Set<Node> convertNodelistToSet(NodeList xpathNodeSet) {
if (xpathNodeSet == null) {
- return new HashSet();
+ return new HashSet<Node>();
}
int length = xpathNodeSet.getLength();
- Set set = new HashSet(length);
+ Set<Node> set = new HashSet<Node>(length);
for (int i = 0; i < length; i++) {
set.add(xpathNodeSet.item(i));
@@ -446,6 +446,7 @@
* @param node
* @see <A HREF="http://nagoya.apache.org/bugzilla/show_bug.cgi?id=2650">Namespace axis resolution is not XPath compliant </A>
*/
+ @SuppressWarnings("fallthrough")
private static void circumventBug2650internal(Node node) {
Node parent=null;
Node sibling=null;
@@ -642,12 +643,12 @@
* @param inputSet
* @return nodes with the constrain
*/
- public static Set excludeNodeFromSet(Node signatureElement, Set inputSet) {
- Set resultSet = new HashSet();
- Iterator iterator = inputSet.iterator();
+ public static Set<Node> excludeNodeFromSet(Node signatureElement, Set<Node> inputSet) {
+ Set<Node> resultSet = new HashSet<Node>();
+ Iterator<Node> iterator = inputSet.iterator();
while (iterator.hasNext()) {
- Node inputNode = (Node) iterator.next();
+ Node inputNode = iterator.next();
if (!XMLUtils
.isDescendantOrSelf(signatureElement, inputNode)) {
diff --git a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/utils/resolver/ResourceResolver.java b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/utils/resolver/ResourceResolver.java
index 8a96076..5d5719b 100644
--- a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/utils/resolver/ResourceResolver.java
+++ b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/utils/resolver/ResourceResolver.java
@@ -56,7 +56,7 @@
static boolean _alreadyInitialized = false;
/** these are the system-wide resolvers */
- static List _resolverVector = null;
+ static List<ResourceResolver> _resolverVector = null;
static boolean allThreadSafeInList=true;
@@ -102,7 +102,7 @@
int length=ResourceResolver._resolverVector.size();
for (int i = 0; i < length; i++) {
ResourceResolver resolver =
- (ResourceResolver) ResourceResolver._resolverVector.get(i);
+ ResourceResolver._resolverVector.get(i);
ResourceResolver resolverTmp=null;
try {
resolverTmp = allThreadSafeInList || resolver._resolverSpi.engineIsThreadSafe() ? resolver :
@@ -120,7 +120,7 @@
if (i!=0) {
//update resolver.
//System.out.println("Swaping");
- List resolverVector=(List)((ArrayList)_resolverVector).clone();
+ List<ResourceResolver> resolverVector=getResolverVectorClone();
resolverVector.remove(i);
resolverVector.add(0,resolver);
_resolverVector=resolverVector;
@@ -139,6 +139,17 @@
throw new ResourceResolverException("utils.resolver.noClass", exArgs,
uri, BaseURI);
}
+
+ /**
+ * Method getResolverVectorClone
+ *
+ * @return clone of _resolverVector
+ */
+ @SuppressWarnings("unchecked")
+ private static List<ResourceResolver> getResolverVectorClone() {
+ return (List<ResourceResolver>)((ArrayList<ResourceResolver>)_resolverVector).clone();
+ }
+
/**
* Method getInstance
*
@@ -150,7 +161,7 @@
* @throws ResourceResolverException
*/
public static final ResourceResolver getInstance(
- Attr uri, String BaseURI, List individualResolvers)
+ Attr uri, String BaseURI, List<ResourceResolver> individualResolvers)
throws ResourceResolverException {
if (log.isLoggable(java.util.logging.Level.FINE)) {
@@ -163,7 +174,7 @@
if ((individualResolvers != null) && ((size=individualResolvers.size()) > 0)) {
for (int i = 0; i < size; i++) {
ResourceResolver resolver =
- (ResourceResolver) individualResolvers.get(i);
+ individualResolvers.get(i);
if (resolver != null) {
String currentClass = resolver._resolverSpi.getClass().getName();
@@ -186,7 +197,7 @@
public static void init() {
if (!ResourceResolver._alreadyInitialized) {
- ResourceResolver._resolverVector = new ArrayList(10);
+ ResourceResolver._resolverVector = new ArrayList<ResourceResolver>(10);
_alreadyInitialized = true;
}
}
@@ -288,7 +299,7 @@
*
* @param properties
*/
- public void addProperties(Map properties) {
+ public void addProperties(Map<String,String> properties) {
this._resolverSpi.engineAddProperies(properties);
}
diff --git a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/utils/resolver/ResourceResolverSpi.java b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/utils/resolver/ResourceResolverSpi.java
index bed9420..1ff89b7 100644
--- a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/utils/resolver/ResourceResolverSpi.java
+++ b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/utils/resolver/ResourceResolverSpi.java
@@ -41,7 +41,7 @@
ResourceResolverSpi.class.getName());
/** Field _properties */
- protected java.util.Map _properties = null;
+ protected java.util.Map<String,String> _properties = null;
/**
* This is the workhorse method used to resolve resources.
@@ -63,7 +63,7 @@
*/
public void engineSetProperty(String key, String value) {
if (_properties==null) {
- _properties=new HashMap();
+ _properties=new HashMap<String,String>();
}
this._properties.put(key, value);
}
@@ -78,17 +78,17 @@
if (_properties==null) {
return null;
}
- return (String) this._properties.get(key);
+ return this._properties.get(key);
}
/**
*
* @param properties
*/
- public void engineAddProperies(Map properties) {
+ public void engineAddProperies(Map<String,String> properties) {
if (properties!=null) {
if (_properties==null) {
- _properties=new HashMap();
+ _properties=new HashMap<String,String>();
}
this._properties.putAll(properties);
}
diff --git a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/utils/resolver/implementations/ResolverDirectHTTP.java b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/utils/resolver/implementations/ResolverDirectHTTP.java
index 7b23e7a..706cccc 100644
--- a/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/utils/resolver/implementations/ResolverDirectHTTP.java
+++ b/jdk/src/share/classes/com/sun/org/apache/xml/internal/security/utils/resolver/implementations/ResolverDirectHTTP.java
@@ -289,7 +289,7 @@
* @inheritDoc
*/
public String[] engineGetPropertyKeys() {
- return (String[]) ResolverDirectHTTP.properties.clone();
+ return ResolverDirectHTTP.properties.clone();
}
private URI getNewURI(String uri, String BaseURI)
diff --git a/jdk/src/share/classes/com/sun/security/auth/module/Krb5LoginModule.java b/jdk/src/share/classes/com/sun/security/auth/module/Krb5LoginModule.java
index 5c2580c..b6ffb01 100644
--- a/jdk/src/share/classes/com/sun/security/auth/module/Krb5LoginModule.java
+++ b/jdk/src/share/classes/com/sun/security/auth/module/Krb5LoginModule.java
@@ -725,7 +725,7 @@
cred = builder.action().getCreds();
}
if (storeKey) {
- encKeys = builder.getKeys();
+ encKeys = builder.getKeys(isInitiator);
// When encKeys is empty, the login actually fails.
// For compatibility, exception is thrown in commit().
}
diff --git a/jdk/src/share/classes/java/net/AbstractPlainDatagramSocketImpl.java b/jdk/src/share/classes/java/net/AbstractPlainDatagramSocketImpl.java
index 0d03a40..f1a4995 100644
--- a/jdk/src/share/classes/java/net/AbstractPlainDatagramSocketImpl.java
+++ b/jdk/src/share/classes/java/net/AbstractPlainDatagramSocketImpl.java
@@ -44,7 +44,7 @@
int timeout = 0;
boolean connected = false;
private int trafficClass = 0;
- private InetAddress connectedAddress = null;
+ protected InetAddress connectedAddress = null;
private int connectedPort = -1;
/* cached socket options */
diff --git a/jdk/src/share/classes/java/net/AbstractPlainSocketImpl.java b/jdk/src/share/classes/java/net/AbstractPlainSocketImpl.java
index 4265315..c510c61 100644
--- a/jdk/src/share/classes/java/net/AbstractPlainSocketImpl.java
+++ b/jdk/src/share/classes/java/net/AbstractPlainSocketImpl.java
@@ -71,7 +71,7 @@
/* whether this Socket is a stream (TCP) socket or not (UDP)
*/
- private boolean stream;
+ protected boolean stream;
/**
* Load net library into runtime.
@@ -86,10 +86,11 @@
* is a stream socket (true) or an unconnected UDP socket (false).
*/
protected synchronized void create(boolean stream) throws IOException {
- fd = new FileDescriptor();
this.stream = stream;
if (!stream) {
ResourceManager.beforeUdpCreate();
+ // only create the fd after we know we will be able to create the socket
+ fd = new FileDescriptor();
try {
socketCreate(false);
} catch (IOException ioe) {
@@ -98,6 +99,7 @@
throw ioe;
}
} else {
+ fd = new FileDescriptor();
socketCreate(true);
}
if (socket != null)
diff --git a/jdk/src/share/classes/java/net/DatagramSocket.java b/jdk/src/share/classes/java/net/DatagramSocket.java
index 5d73de6..9c9dec1 100644
--- a/jdk/src/share/classes/java/net/DatagramSocket.java
+++ b/jdk/src/share/classes/java/net/DatagramSocket.java
@@ -287,7 +287,7 @@
AccessController.doPrivileged(
new PrivilegedExceptionAction<Void>() {
public Void run() throws NoSuchMethodException {
- Class[] cl = new Class[1];
+ Class<?>[] cl = new Class<?>[1];
cl[0] = DatagramPacket.class;
impl.getClass().getDeclaredMethod("peekData", cl);
return null;
diff --git a/jdk/src/share/classes/java/net/InMemoryCookieStore.java b/jdk/src/share/classes/java/net/InMemoryCookieStore.java
index 6676d97..e885cdd 100644
--- a/jdk/src/share/classes/java/net/InMemoryCookieStore.java
+++ b/jdk/src/share/classes/java/net/InMemoryCookieStore.java
@@ -91,8 +91,10 @@
if (cookie.getDomain() != null) {
addIndex(domainIndex, cookie.getDomain(), cookie);
}
- // add it to uri index, too
- addIndex(uriIndex, getEffectiveURI(uri), cookie);
+ if (uri != null) {
+ // add it to uri index, too
+ addIndex(uriIndex, getEffectiveURI(uri), cookie);
+ }
}
} finally {
lock.unlock();
diff --git a/jdk/src/share/classes/java/security/Signature.java b/jdk/src/share/classes/java/security/Signature.java
index b92a16b..72d2b08 100644
--- a/jdk/src/share/classes/java/security/Signature.java
+++ b/jdk/src/share/classes/java/security/Signature.java
@@ -899,6 +899,7 @@
* and its original parent (Object).
*/
+ @SuppressWarnings("deprecation")
private static class Delegate extends Signature {
// The provider implementation (delegate)
@@ -1203,6 +1204,7 @@
}
// adapter for RSA/ECB/PKCS1Padding ciphers
+ @SuppressWarnings("deprecation")
private static class CipherAdapter extends SignatureSpi {
private final Cipher cipher;
diff --git a/jdk/src/share/classes/javax/security/auth/PrivateCredentialPermission.java b/jdk/src/share/classes/javax/security/auth/PrivateCredentialPermission.java
index 87afbed..3f5e708 100644
--- a/jdk/src/share/classes/javax/security/auth/PrivateCredentialPermission.java
+++ b/jdk/src/share/classes/javax/security/auth/PrivateCredentialPermission.java
@@ -117,7 +117,7 @@
* The set contains elements of type,
* <code>PrivateCredentialPermission.CredOwner</code>.
*/
- private Set principals; // ignored - kept around for compatibility
+ private Set<Principal> principals; // ignored - kept around for compatibility
private transient CredOwner[] credOwners;
/**
diff --git a/jdk/src/share/classes/javax/security/auth/Subject.java b/jdk/src/share/classes/javax/security/auth/Subject.java
index 56e864c..5a9ecea 100644
--- a/jdk/src/share/classes/javax/security/auth/Subject.java
+++ b/jdk/src/share/classes/javax/security/auth/Subject.java
@@ -1291,6 +1291,7 @@
oos.writeFields();
}
+ @SuppressWarnings("unchecked")
private void readObject(ObjectInputStream ois)
throws IOException, ClassNotFoundException
{
@@ -1329,6 +1330,7 @@
}
}
+ @SuppressWarnings("unchecked") /*To suppress warning from line 1374*/
private void populateSet() {
final Iterator<?> iterator;
switch(which) {
diff --git a/jdk/src/share/classes/javax/security/auth/SubjectDomainCombiner.java b/jdk/src/share/classes/javax/security/auth/SubjectDomainCombiner.java
index 676137f..9da411c 100644
--- a/jdk/src/share/classes/javax/security/auth/SubjectDomainCombiner.java
+++ b/jdk/src/share/classes/javax/security/auth/SubjectDomainCombiner.java
@@ -56,6 +56,7 @@
sun.security.util.Debug.getInstance("combiner",
"\t[SubjectDomainCombiner]");
+ @SuppressWarnings("deprecation")
// Note: check only at classloading time, not dynamically during combine()
private static final boolean useJavaxPolicy =
javax.security.auth.Policy.isCustomPolicySet(debug);
@@ -300,6 +301,7 @@
if (!allowCaching) {
java.security.AccessController.doPrivileged
(new PrivilegedAction<Void>() {
+ @SuppressWarnings("deprecation")
public Void run() {
// Call refresh only caching is disallowed
javax.security.auth.Policy.getPolicy().refresh();
@@ -308,6 +310,7 @@
});
}
+
int cLen = (currentDomains == null ? 0 : currentDomains.length);
int aLen = (assignedDomains == null ? 0 : assignedDomains.length);
@@ -348,13 +351,13 @@
// get the original perms
Permissions perms = new Permissions();
PermissionCollection coll = pd.getPermissions();
- java.util.Enumeration e;
+ java.util.Enumeration<Permission> e;
if (coll != null) {
synchronized (coll) {
e = coll.elements();
while (e.hasMoreElements()) {
Permission newPerm =
- (Permission)e.nextElement();
+ e.nextElement();
perms.add(newPerm);
}
}
@@ -367,6 +370,7 @@
PermissionCollection newPerms =
java.security.AccessController.doPrivileged
(new PrivilegedAction<PermissionCollection>() {
+ @SuppressWarnings("deprecation")
public PermissionCollection run() {
return
javax.security.auth.Policy.getPolicy().getPermissions
@@ -379,7 +383,7 @@
synchronized (newPerms) {
e = newPerms.elements();
while (e.hasMoreElements()) {
- Permission newPerm = (Permission)e.nextElement();
+ Permission newPerm = e.nextElement();
if (!perms.implies(newPerm)) {
perms.add(newPerm);
if (debug != null)
diff --git a/jdk/src/share/classes/javax/security/auth/kerberos/DelegationPermission.java b/jdk/src/share/classes/javax/security/auth/kerberos/DelegationPermission.java
index 3ab9beb..3304ac8 100644
--- a/jdk/src/share/classes/javax/security/auth/kerberos/DelegationPermission.java
+++ b/jdk/src/share/classes/javax/security/auth/kerberos/DelegationPermission.java
@@ -375,6 +375,7 @@
/*
* Reads in a Vector of DelegationPermissions and saves them in the perms field.
*/
+ @SuppressWarnings("unchecked")
private void readObject(ObjectInputStream in) throws IOException,
ClassNotFoundException {
// Don't call defaultReadObject()
diff --git a/jdk/src/share/classes/javax/security/auth/kerberos/ServicePermission.java b/jdk/src/share/classes/javax/security/auth/kerberos/ServicePermission.java
index 566c719..c79d0e1 100644
--- a/jdk/src/share/classes/javax/security/auth/kerberos/ServicePermission.java
+++ b/jdk/src/share/classes/javax/security/auth/kerberos/ServicePermission.java
@@ -583,6 +583,7 @@
/*
* Reads in a Vector of ServicePermissions and saves them in the perms field.
*/
+ @SuppressWarnings("unchecked")
private void readObject(ObjectInputStream in) throws IOException,
ClassNotFoundException {
// Don't call defaultReadObject()
diff --git a/jdk/src/share/classes/javax/security/auth/login/LoginContext.java b/jdk/src/share/classes/javax/security/auth/login/LoginContext.java
index 6fb484a..f76c6ed 100644
--- a/jdk/src/share/classes/javax/security/auth/login/LoginContext.java
+++ b/jdk/src/share/classes/javax/security/auth/login/LoginContext.java
@@ -214,14 +214,14 @@
private boolean subjectProvided = false;
private boolean loginSucceeded = false;
private CallbackHandler callbackHandler;
- private Map state = new HashMap();
+ private Map<String,?> state = new HashMap<String,Object>();
private Configuration config;
private boolean configProvided = false;
private AccessControlContext creatorAcc = null;
private ModuleInfo[] moduleStack;
private ClassLoader contextClassLoader = null;
- private static final Class[] PARAMS = { };
+ private static final Class<?>[] PARAMS = { };
// state saved in the event a user-specified asynchronous exception
// was specified and thrown
@@ -306,7 +306,7 @@
(DEFAULT_HANDLER);
if (defaultHandler == null || defaultHandler.length() == 0)
return null;
- Class c = Class.forName(defaultHandler,
+ Class<?> c = Class.forName(defaultHandler,
true,
finalLoader);
return (CallbackHandler)c.newInstance();
@@ -743,12 +743,12 @@
} else {
// instantiate the LoginModule
- Class c = Class.forName
+ Class<?> c = Class.forName
(moduleStack[i].entry.getLoginModuleName(),
true,
contextClassLoader);
- Constructor constructor = c.getConstructor(PARAMS);
+ Constructor<?> constructor = c.getConstructor(PARAMS);
Object[] args = { };
// allow any object to be a LoginModule
diff --git a/jdk/src/share/classes/javax/security/auth/x500/X500Principal.java b/jdk/src/share/classes/javax/security/auth/x500/X500Principal.java
index 5636856..64a54f1 100644
--- a/jdk/src/share/classes/javax/security/auth/x500/X500Principal.java
+++ b/jdk/src/share/classes/javax/security/auth/x500/X500Principal.java
@@ -118,7 +118,7 @@
* is improperly specified
*/
public X500Principal(String name) {
- this(name, (Map<String, String>) Collections.EMPTY_MAP);
+ this(name, Collections.<String, String>emptyMap());
}
/**
diff --git a/jdk/src/share/classes/javax/security/cert/CertificateEncodingException.java b/jdk/src/share/classes/javax/security/cert/CertificateEncodingException.java
index 9eb5315..866d104 100644
--- a/jdk/src/share/classes/javax/security/cert/CertificateEncodingException.java
+++ b/jdk/src/share/classes/javax/security/cert/CertificateEncodingException.java
@@ -41,6 +41,7 @@
*/
public class CertificateEncodingException extends CertificateException {
+ private static final long serialVersionUID = -8187642723048403470L;
/**
* Constructs a CertificateEncodingException with no detail message. A
* detail message is a String that describes this particular
diff --git a/jdk/src/share/classes/javax/security/cert/CertificateException.java b/jdk/src/share/classes/javax/security/cert/CertificateException.java
index 44cebf7..95d0d3f 100644
--- a/jdk/src/share/classes/javax/security/cert/CertificateException.java
+++ b/jdk/src/share/classes/javax/security/cert/CertificateException.java
@@ -41,6 +41,7 @@
*/
public class CertificateException extends Exception {
+ private static final long serialVersionUID = -5757213374030785290L;
/**
* Constructs a certificate exception with no detail message. A detail
* message is a String that describes this particular exception.
diff --git a/jdk/src/share/classes/javax/security/cert/CertificateExpiredException.java b/jdk/src/share/classes/javax/security/cert/CertificateExpiredException.java
index 405344e..889e786 100644
--- a/jdk/src/share/classes/javax/security/cert/CertificateExpiredException.java
+++ b/jdk/src/share/classes/javax/security/cert/CertificateExpiredException.java
@@ -43,6 +43,7 @@
*/
public class CertificateExpiredException extends CertificateException {
+ private static final long serialVersionUID = 5091601212177261883L;
/**
* Constructs a CertificateExpiredException with no detail message. A
* detail message is a String that describes this particular
diff --git a/jdk/src/share/classes/javax/security/cert/CertificateNotYetValidException.java b/jdk/src/share/classes/javax/security/cert/CertificateNotYetValidException.java
index 2e6b4c3..20ed156 100644
--- a/jdk/src/share/classes/javax/security/cert/CertificateNotYetValidException.java
+++ b/jdk/src/share/classes/javax/security/cert/CertificateNotYetValidException.java
@@ -43,6 +43,7 @@
*/
public class CertificateNotYetValidException extends CertificateException {
+ private static final long serialVersionUID = -8976172474266822818L;
/**
* Constructs a CertificateNotYetValidException with no detail message. A
* detail message is a String that describes this particular
diff --git a/jdk/src/share/classes/javax/security/cert/CertificateParsingException.java b/jdk/src/share/classes/javax/security/cert/CertificateParsingException.java
index d935e12..c60ffe4 100644
--- a/jdk/src/share/classes/javax/security/cert/CertificateParsingException.java
+++ b/jdk/src/share/classes/javax/security/cert/CertificateParsingException.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 1997, 2006, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -42,6 +42,8 @@
*/
public class CertificateParsingException extends CertificateException {
+ private static final long serialVersionUID = -8449352422951136229L;
+
/**
* Constructs a CertificateParsingException with no detail message. A
* detail message is a String that describes this particular
diff --git a/jdk/src/share/classes/javax/security/cert/X509Certificate.java b/jdk/src/share/classes/javax/security/cert/X509Certificate.java
index 7f16f02..39b24ec 100644
--- a/jdk/src/share/classes/javax/security/cert/X509Certificate.java
+++ b/jdk/src/share/classes/javax/security/cert/X509Certificate.java
@@ -219,11 +219,11 @@
className = "com.sun.security.cert.internal.x509.X509V1CertImpl";
}
try {
- Class[] params = null;
+ Class<?>[] params = null;
if (value instanceof InputStream) {
- params = new Class[] { InputStream.class };
+ params = new Class<?>[] { InputStream.class };
} else if (value instanceof byte[]) {
- params = new Class[] { value.getClass() };
+ params = new Class<?>[] { value.getClass() };
} else
throw new CertificateException("Unsupported argument type");
Class<?> certClass = Class.forName(className);
diff --git a/jdk/src/share/classes/javax/security/sasl/Sasl.java b/jdk/src/share/classes/javax/security/sasl/Sasl.java
index 4188c41..ca9eb2a 100644
--- a/jdk/src/share/classes/javax/security/sasl/Sasl.java
+++ b/jdk/src/share/classes/javax/security/sasl/Sasl.java
@@ -395,7 +395,7 @@
* will be thrown.
*/
ClassLoader cl = p.getClass().getClassLoader();
- Class implClass;
+ Class<?> implClass;
implClass = Class.forName(className, true, cl);
return implClass.newInstance();
} catch (ClassNotFoundException e) {
@@ -576,7 +576,7 @@
classes.clear();
// Check the keys for each provider.
- for (Enumeration e = providers[i].keys(); e.hasMoreElements(); ) {
+ for (Enumeration<Object> e = providers[i].keys(); e.hasMoreElements(); ) {
String currentKey = (String)e.nextElement();
if (currentKey.startsWith(serviceName)) {
// We should skip the currentKey if it contains a
diff --git a/jdk/src/share/classes/javax/smartcardio/TerminalFactory.java b/jdk/src/share/classes/javax/smartcardio/TerminalFactory.java
index d1d5983..38a80bc 100644
--- a/jdk/src/share/classes/javax/smartcardio/TerminalFactory.java
+++ b/jdk/src/share/classes/javax/smartcardio/TerminalFactory.java
@@ -113,7 +113,7 @@
type = "PC/SC";
Provider sun = Security.getProvider("SunPCSC");
if (sun == null) {
- Class clazz = Class.forName("sun.security.smartcardio.SunPCSC");
+ Class<?> clazz = Class.forName("sun.security.smartcardio.SunPCSC");
sun = (Provider)clazz.newInstance();
}
factory = TerminalFactory.getInstance(type, null, sun);
@@ -131,6 +131,8 @@
}
private static final class NoneProvider extends Provider {
+
+ private static final long serialVersionUID = 2745808869881593918L;
final static Provider INSTANCE = new NoneProvider();
private NoneProvider() {
super("None", 1.0d, "none");
diff --git a/jdk/src/share/classes/javax/swing/BufferStrategyPaintManager.java b/jdk/src/share/classes/javax/swing/BufferStrategyPaintManager.java
index 29c8fb4..66c9baa 100644
--- a/jdk/src/share/classes/javax/swing/BufferStrategyPaintManager.java
+++ b/jdk/src/share/classes/javax/swing/BufferStrategyPaintManager.java
@@ -24,20 +24,17 @@
*/
package javax.swing;
-import java.applet.Applet;
import java.awt.*;
import java.awt.event.*;
import java.awt.image.*;
import java.lang.reflect.*;
import java.lang.ref.WeakReference;
-import java.security.AccessController;
import java.util.*;
import com.sun.java.swing.SwingUtilities3;
import sun.awt.SubRegionShowable;
import sun.java2d.SunGraphics2D;
-import sun.security.action.GetPropertyAction;
import sun.java2d.pipe.hw.ExtendedBufferCapabilities;
import sun.awt.SunToolkit;
import sun.util.logging.PlatformLogger;
@@ -120,10 +117,6 @@
*/
private JComponent rootJ;
/**
- * Parent Applet/Window for the current paint/copyArea
- */
- private Container root;
- /**
* Location of component being painted relative to root.
*/
private int xOffset;
@@ -278,7 +271,9 @@
public boolean paint(JComponent paintingComponent,
JComponent bufferComponent, Graphics g,
int x, int y, int w, int h) {
- if (prepare(paintingComponent, true, x, y, w, h)) {
+ Container root = fetchRoot(paintingComponent);
+
+ if (prepare(paintingComponent, root, true, x, y, w, h)) {
if ((g instanceof SunGraphics2D) &&
((SunGraphics2D)g).getDestination() == root) {
// BufferStrategy may have already constrained the Graphics. To
@@ -319,7 +314,9 @@
//
// If the buffer isn't in sync there is no point in doing a copyArea,
// it has garbage.
- if (prepare(c, false, 0, 0, 0, 0) && bufferInfo.isInSync()) {
+ Container root = fetchRoot(c);
+
+ if (prepare(c, root, false, 0, 0, 0, 0) && bufferInfo.isInSync()) {
if (clip) {
Rectangle cBounds = c.getVisibleRect();
int relX = xOffset + x;
@@ -500,14 +497,14 @@
*
* @return true if should use buffering per window in painting.
*/
- private boolean prepare(JComponent c, boolean isPaint, int x, int y,
+ private boolean prepare(JComponent c, Container root, boolean isPaint, int x, int y,
int w, int h) {
if (bsg != null) {
bsg.dispose();
bsg = null;
}
bufferStrategy = null;
- if (fetchRoot(c)) {
+ if (root != null) {
boolean contentsLost = false;
BufferInfo bufferInfo = getBufferInfo(root);
if (bufferInfo == null) {
@@ -567,10 +564,10 @@
return false;
}
- private boolean fetchRoot(JComponent c) {
+ private Container fetchRoot(JComponent c) {
boolean encounteredHW = false;
rootJ = c;
- root = c;
+ Container root = c;
xOffset = yOffset = 0;
while (root != null &&
(!(root instanceof Window) &&
@@ -597,7 +594,7 @@
// heavyweights. If we didn't do this when we
// went to show the descendants of the nested hw
// you would see nothing, so, we bail out here.
- return false;
+ return null;
}
}
}
@@ -613,11 +610,11 @@
// bit tricky with Swing. This gives a good approximation
// of the various ways to turn on double buffering for
// components.
- return true;
+ return root;
}
}
// Don't do true double buffering.
- return false;
+ return null;
}
/**
diff --git a/jdk/src/share/classes/sun/net/www/protocol/http/HttpURLConnection.java b/jdk/src/share/classes/sun/net/www/protocol/http/HttpURLConnection.java
index e14ce8d..3a7737a 100644
--- a/jdk/src/share/classes/sun/net/www/protocol/http/HttpURLConnection.java
+++ b/jdk/src/share/classes/sun/net/www/protocol/http/HttpURLConnection.java
@@ -1661,7 +1661,7 @@
public IOException run() throws Exception {
return (IOException)
rememberedException.getClass()
- .getConstructor(new Class[] { String.class })
+ .getConstructor(new Class<?>[] { String.class })
.newInstance(args);
}
});
diff --git a/jdk/src/share/classes/sun/security/ec/ECPublicKeyImpl.java b/jdk/src/share/classes/sun/security/ec/ECPublicKeyImpl.java
index 6d471e9..aae485c 100644
--- a/jdk/src/share/classes/sun/security/ec/ECPublicKeyImpl.java
+++ b/jdk/src/share/classes/sun/security/ec/ECPublicKeyImpl.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2006, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2006, 2011, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -51,6 +51,7 @@
* Construct a key from its components. Used by the
* ECKeyFactory and SunPKCS11.
*/
+ @SuppressWarnings("deprecation")
public ECPublicKeyImpl(ECPoint w, ECParameterSpec params)
throws InvalidKeyException {
this.w = w;
@@ -85,6 +86,7 @@
// Internal API to get the encoded point. Currently used by SunPKCS11.
// This may change/go away depending on what we do with the public API.
+ @SuppressWarnings("deprecation")
public byte[] getEncodedPublicValue() {
return key.clone();
}
@@ -92,6 +94,7 @@
/**
* Parse the key. Called by X509Key.
*/
+ @SuppressWarnings("deprecation")
protected void parseKeyBits() throws InvalidKeyException {
try {
AlgorithmParameters algParams = this.algid.getParameters();
diff --git a/jdk/src/share/classes/sun/security/jgss/krb5/AcceptSecContextToken.java b/jdk/src/share/classes/sun/security/jgss/krb5/AcceptSecContextToken.java
index c3e2273..a2ad498 100644
--- a/jdk/src/share/classes/sun/security/jgss/krb5/AcceptSecContextToken.java
+++ b/jdk/src/share/classes/sun/security/jgss/krb5/AcceptSecContextToken.java
@@ -94,7 +94,7 @@
*/
EncryptionKey subKey = apRep.getSubKey();
if (subKey != null) {
- context.setKey(subKey);
+ context.setKey(Krb5Context.ACCEPTOR_SUBKEY, subKey);
/*
System.out.println("\n\nSub-Session key from AP-REP is: " +
getHexBytes(subKey.getBytes()) + "\n");
diff --git a/jdk/src/share/classes/sun/security/jgss/krb5/InitSecContextToken.java b/jdk/src/share/classes/sun/security/jgss/krb5/InitSecContextToken.java
index 8e35ef8..edd4bcf 100644
--- a/jdk/src/share/classes/sun/security/jgss/krb5/InitSecContextToken.java
+++ b/jdk/src/share/classes/sun/security/jgss/krb5/InitSecContextToken.java
@@ -74,9 +74,9 @@
EncryptionKey subKey = apReq.getSubKey();
if (subKey != null)
- context.setKey(subKey);
+ context.setKey(Krb5Context.INITIATOR_SUBKEY, subKey);
else
- context.setKey(serviceTicket.getSessionKey());
+ context.setKey(Krb5Context.SESSION_KEY, serviceTicket.getSessionKey());
if (!mutualRequired)
context.resetPeerSequenceNumber(0);
@@ -117,13 +117,13 @@
EncryptionKey subKey = apReq.getSubKey();
if (subKey != null) {
- context.setKey(subKey);
+ context.setKey(Krb5Context.INITIATOR_SUBKEY, subKey);
/*
System.out.println("Sub-Session key from authenticator is: " +
getHexBytes(subKey.getBytes()) + "\n");
*/
} else {
- context.setKey(sessionKey);
+ context.setKey(Krb5Context.SESSION_KEY, sessionKey);
//System.out.println("Sub-Session Key Missing in Authenticator.\n");
}
diff --git a/jdk/src/share/classes/sun/security/jgss/krb5/Krb5Context.java b/jdk/src/share/classes/sun/security/jgss/krb5/Krb5Context.java
index 3b6467d..37c7b98 100644
--- a/jdk/src/share/classes/sun/security/jgss/krb5/Krb5Context.java
+++ b/jdk/src/share/classes/sun/security/jgss/krb5/Krb5Context.java
@@ -67,6 +67,10 @@
private int state = STATE_NEW;
+ public static final int SESSION_KEY = 0;
+ public static final int INITIATOR_SUBKEY = 1;
+ public static final int ACCEPTOR_SUBKEY = 2;
+
/*
* Optional features that the application can set and their default
* values.
@@ -82,6 +86,7 @@
private int mySeqNumber;
private int peerSeqNumber;
+ private int keySrc;
private TokenTracker peerTokenTracker;
private CipherHelper cipherHelper = null;
@@ -384,12 +389,17 @@
}
}
- final void setKey(EncryptionKey key) throws GSSException {
+ final void setKey(int keySrc, EncryptionKey key) throws GSSException {
this.key = key;
+ this.keySrc = keySrc;
// %%% to do: should clear old cipherHelper first
cipherHelper = new CipherHelper(key); // Need to use new key
}
+ public final int getKeySrc() {
+ return keySrc;
+ }
+
private final EncryptionKey getKey() {
return key;
}
diff --git a/jdk/src/share/classes/sun/security/jgss/krb5/MessageToken_v2.java b/jdk/src/share/classes/sun/security/jgss/krb5/MessageToken_v2.java
index d76a58b..509773d 100644
--- a/jdk/src/share/classes/sun/security/jgss/krb5/MessageToken_v2.java
+++ b/jdk/src/share/classes/sun/security/jgss/krb5/MessageToken_v2.java
@@ -141,6 +141,7 @@
// Context properties
private boolean confState = true;
private boolean initiator = true;
+ private boolean have_acceptor_subkey = false;
/* cipher instance used by the corresponding GSSContext */
CipherHelper cipherHelper = null;
@@ -233,7 +234,6 @@
}
if (tokenId == Krb5Token.WRAP_ID_v2) {
- // Does non-confidential data needs a rotate?
rotate();
}
@@ -312,8 +312,7 @@
}
// Create a new gss token header as defined in RFC 4121
- tokenHeader = new MessageTokenHeader(tokenId,
- prop.getPrivacy(), true);
+ tokenHeader = new MessageTokenHeader(tokenId, prop.getPrivacy());
// debug("\n\t Message Header = " +
// getHexBytes(tokenHeader.getBytes(), tokenHeader.getBytes().length));
@@ -421,10 +420,12 @@
int conf_flag = tokenHeaderBytes[TOKEN_FLAG_POS] &
FLAG_WRAP_CONFIDENTIAL;
- // clear EC in token header for checksum calculation
+ // clear EC and RRC in token header for checksum calculation
if ((conf_flag == 0) && (tokenId == WRAP_ID_v2)) {
tokenHeaderBytes[4] = 0;
tokenHeaderBytes[5] = 0;
+ tokenHeaderBytes[6] = 0;
+ tokenHeaderBytes[7] = 0;
}
return cipherHelper.calculateChecksum(tokenHeaderBytes, data,
offset, len, key_usage);
@@ -460,6 +461,8 @@
this.initiator = context.isInitiator();
+ this.have_acceptor_subkey = context.getKeySrc() == Krb5Context.ACCEPTOR_SUBKEY;
+
this.cipherHelper = context.getCipherHelper(null);
// debug("In MessageToken.Cons");
}
@@ -500,8 +503,7 @@
private byte[] bytes = new byte[TOKEN_HEADER_SIZE];
// Writes a new token header
- public MessageTokenHeader(int tokenId, boolean conf,
- boolean have_acceptor_subkey) throws GSSException {
+ public MessageTokenHeader(int tokenId, boolean conf) throws GSSException {
this.tokenId = tokenId;
diff --git a/jdk/src/share/classes/sun/security/krb5/KrbAsReqBuilder.java b/jdk/src/share/classes/sun/security/krb5/KrbAsReqBuilder.java
index 3426d8b..23b4dd8 100644
--- a/jdk/src/share/classes/sun/security/krb5/KrbAsReqBuilder.java
+++ b/jdk/src/share/classes/sun/security/krb5/KrbAsReqBuilder.java
@@ -144,15 +144,18 @@
/**
* Retrieves an array of secret keys for the client. This is used when
- * the client supplies password but need keys to act as an acceptor
- * (in JAAS words, isInitiator=true and storeKey=true)
+ * the client supplies password but need keys to act as an acceptor. For
+ * an initiator, it must be called after AS-REQ is performed (state is OK).
+ * For an acceptor, it can be called when this KrbAsReqBuilder object is
+ * constructed (state is INIT).
+ * @param isInitiator if the caller is an initiator
* @return generated keys from password. PA-DATA from server might be used.
* All "default_tkt_enctypes" keys will be generated, Never null.
* @throws IllegalStateException if not constructed from a password
* @throws KrbException
*/
- public EncryptionKey[] getKeys() throws KrbException {
- checkState(State.REQ_OK, "Cannot get keys");
+ public EncryptionKey[] getKeys(boolean isInitiator) throws KrbException {
+ checkState(isInitiator?State.REQ_OK:State.INIT, "Cannot get keys");
if (password != null) {
int[] eTypes = EType.getDefaults("default_tkt_enctypes");
EncryptionKey[] result = new EncryptionKey[eTypes.length];
diff --git a/jdk/src/share/classes/sun/security/pkcs11/SunPKCS11.java b/jdk/src/share/classes/sun/security/pkcs11/SunPKCS11.java
index d54c561..b94ca87 100644
--- a/jdk/src/share/classes/sun/security/pkcs11/SunPKCS11.java
+++ b/jdk/src/share/classes/sun/security/pkcs11/SunPKCS11.java
@@ -1335,10 +1335,10 @@
return null;
}
- Class c = Class.forName
- (defaultHandler,
- true,
- Thread.currentThread().getContextClassLoader());
+ Class<?> c = Class.forName
+ (defaultHandler,
+ true,
+ Thread.currentThread().getContextClassLoader());
return (CallbackHandler)c.newInstance();
}
});
diff --git a/jdk/src/share/classes/sun/security/validator/PKIXValidator.java b/jdk/src/share/classes/sun/security/validator/PKIXValidator.java
index a1860a7..7c010e1 100644
--- a/jdk/src/share/classes/sun/security/validator/PKIXValidator.java
+++ b/jdk/src/share/classes/sun/security/validator/PKIXValidator.java
@@ -327,6 +327,7 @@
* Set the check date (for debugging).
*/
private void setDate(PKIXBuilderParameters params) {
+ @SuppressWarnings("deprecation")
Date date = validationDate;
if (date != null) {
params.setDate(date);
diff --git a/jdk/src/share/classes/sun/security/validator/SimpleValidator.java b/jdk/src/share/classes/sun/security/validator/SimpleValidator.java
index dc68032..850dfa0 100644
--- a/jdk/src/share/classes/sun/security/validator/SimpleValidator.java
+++ b/jdk/src/share/classes/sun/security/validator/SimpleValidator.java
@@ -131,6 +131,7 @@
// make sure chain includes a trusted cert
chain = buildTrustedChain(chain);
+ @SuppressWarnings("deprecation")
Date date = validationDate;
if (date == null) {
date = new Date();
diff --git a/jdk/src/share/classes/sun/security/x509/X509CertImpl.java b/jdk/src/share/classes/sun/security/x509/X509CertImpl.java
index 83f9588..178f797 100644
--- a/jdk/src/share/classes/sun/security/x509/X509CertImpl.java
+++ b/jdk/src/share/classes/sun/security/x509/X509CertImpl.java
@@ -1323,7 +1323,7 @@
for (Extension ex : exts.getAllExtensions()) {
ObjectIdentifier inCertOID = ex.getExtensionId();
- if (inCertOID.equals(findOID)) {
+ if (inCertOID.equals((Object)findOID)) {
certExt = ex;
break;
}
diff --git a/jdk/src/share/classes/sun/util/LocaleServiceProviderPool.java b/jdk/src/share/classes/sun/util/LocaleServiceProviderPool.java
index 5b6c04e..c45100d 100644
--- a/jdk/src/share/classes/sun/util/LocaleServiceProviderPool.java
+++ b/jdk/src/share/classes/sun/util/LocaleServiceProviderPool.java
@@ -40,6 +40,7 @@
import java.util.ServiceLoader;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
import java.util.spi.LocaleServiceProvider;
import sun.util.logging.PlatformLogger;
@@ -57,8 +58,8 @@
* A Map that holds singleton instances of this class. Each instance holds a
* set of provider implementations of a particular locale sensitive service.
*/
- private static Map<Class, LocaleServiceProviderPool> poolOfPools =
- new ConcurrentHashMap<Class, LocaleServiceProviderPool>();
+ private static ConcurrentMap<Class, LocaleServiceProviderPool> poolOfPools =
+ new ConcurrentHashMap<>();
/**
* A Set containing locale service providers that implement the
@@ -109,7 +110,7 @@
if (pool == null) {
LocaleServiceProviderPool newPool =
new LocaleServiceProviderPool(providerClass);
- pool = poolOfPools.put(providerClass, newPool);
+ pool = poolOfPools.putIfAbsent(providerClass, newPool);
if (pool == null) {
pool = newPool;
}
@@ -257,10 +258,11 @@
synchronized (LocaleServiceProviderPool.class) {
if (availableJRELocales == null) {
Locale[] allLocales = LocaleData.getAvailableLocales();
- availableJRELocales = new ArrayList<Locale>(allLocales.length);
+ List<Locale> tmpList = new ArrayList<>(allLocales.length);
for (Locale locale : allLocales) {
- availableJRELocales.add(getLookupLocale(locale));
+ tmpList.add(getLookupLocale(locale));
}
+ availableJRELocales = tmpList;
}
}
}
diff --git a/jdk/src/solaris/bin/java_md.c b/jdk/src/solaris/bin/java_md.c
index 361454f..e049450 100644
--- a/jdk/src/solaris/bin/java_md.c
+++ b/jdk/src/solaris/bin/java_md.c
@@ -820,7 +820,6 @@
jboolean
LoadJavaVM(const char *jvmpath, InvocationFunctions *ifn)
{
- Dl_info dlinfo;
void *libjvm;
JLI_TraceLauncher("JVM path is %s\n", jvmpath);
diff --git a/jdk/src/solaris/native/java/util/TimeZone_md.c b/jdk/src/solaris/native/java/util/TimeZone_md.c
index 9a2a0b4..7e95d53 100644
--- a/jdk/src/solaris/native/java/util/TimeZone_md.c
+++ b/jdk/src/solaris/native/java/util/TimeZone_md.c
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 1999, 2004, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1999, 2011, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -30,13 +30,13 @@
#include <limits.h>
#include <errno.h>
#include <stddef.h>
-
-#ifdef __linux__
-#include <string.h>
-#include <dirent.h>
#include <sys/stat.h>
#include <sys/types.h>
+#include <string.h>
+#include <dirent.h>
#include <unistd.h>
+#ifdef __solaris__
+#include <libscf.h>
#endif
#include "jvm.h"
@@ -54,17 +54,22 @@
static const char *ETC_TIMEZONE_FILE = "/etc/timezone";
static const char *ZONEINFO_DIR = "/usr/share/zoneinfo";
static const char *DEFAULT_ZONEINFO_FILE = "/etc/localtime";
+#else
+static const char *SYS_INIT_FILE = "/etc/default/init";
+static const char *ZONEINFO_DIR = "/usr/share/lib/zoneinfo";
+static const char *DEFAULT_ZONEINFO_FILE = "/usr/share/lib/zoneinfo/localtime";
+#endif /*__linux__*/
/*
- * Returns a point to the zone ID portion of the given zoneinfo file
- * name.
+ * Returns a pointer to the zone ID portion of the given zoneinfo file
+ * name, or NULL if the given string doesn't contain "zoneinfo/".
*/
static char *
getZoneName(char *str)
{
static const char *zidir = "zoneinfo/";
- char * pos = strstr((const char *)str, zidir);
+ char *pos = strstr((const char *)str, zidir);
if (pos == NULL) {
return NULL;
}
@@ -74,7 +79,7 @@
/*
* Returns a path name created from the given 'dir' and 'name' under
* UNIX. This function allocates memory for the pathname calling
- * malloc().
+ * malloc(). NULL is returned if malloc() fails.
*/
static char *
getPathName(const char *dir, const char *name) {
@@ -89,19 +94,18 @@
/*
* Scans the specified directory and its subdirectories to find a
- * zoneinfo file which has the same content as /etc/localtime given in
- * 'buf'. Returns a zone ID if found, otherwise, NULL is returned.
+ * zoneinfo file which has the same content as /etc/localtime on Linux
+ * or /usr/share/lib/zoneinfo/localtime (most likely a symbolic link)
+ * on Solaris given in 'buf'. Returns a zone ID if found, otherwise,
+ * NULL is returned.
*/
static char *
findZoneinfoFile(char *buf, size_t size, const char *dir)
{
DIR *dirp = NULL;
struct stat statbuf;
- union {
- struct dirent d;
- char b[offsetof (struct dirent, d_name) + NAME_MAX + 1];
- } entry;
- struct dirent *dp;
+ struct dirent *dp = NULL;
+ struct dirent *entry = NULL;
char *pathname = NULL;
int fd = -1;
char *dbuf = NULL;
@@ -112,7 +116,19 @@
return NULL;
}
- while (readdir_r(dirp, &entry.d, &dp) == 0 && dp != NULL) {
+ entry = (struct dirent *) malloc((size_t) pathconf(dir, _PC_NAME_MAX));
+ if (entry == NULL) {
+ (void) closedir(dirp);
+ return NULL;
+ }
+
+#if defined(__linux__) || (defined(__solaris__) && (defined(_POSIX_PTHREAD_SEMANTICS) || \
+ defined(_LP64)))
+ while (readdir_r(dirp, entry, &dp) == 0 && dp != NULL) {
+#else
+ while ((dp = readdir_r(dirp, entry)) != NULL) {
+#endif
+
/*
* Skip '.' and '..' (and possibly other .* files)
*/
@@ -121,11 +137,17 @@
}
/*
- * Skip "ROC", "posixrules", and "localtime" since Java doesn't
- * support them.
+ * Skip "ROC", "posixrules", and "localtime".
*/
if ((strcmp(dp->d_name, "ROC") == 0)
|| (strcmp(dp->d_name, "posixrules") == 0)
+#ifdef __solaris__
+ /*
+ * Skip the "src" and "tab" directories on Solaris.
+ */
+ || (strcmp(dp->d_name, "src") == 0)
+ || (strcmp(dp->d_name, "tab") == 0)
+#endif
|| (strcmp(dp->d_name, "localtime") == 0)) {
continue;
}
@@ -149,7 +171,6 @@
break;
}
if ((fd = open(pathname, O_RDONLY)) == -1) {
- fd = 0;
break;
}
if (read(fd, dbuf, size) != (ssize_t) size) {
@@ -165,19 +186,22 @@
free((void *) dbuf);
dbuf = NULL;
(void) close(fd);
- fd = 0;
+ fd = -1;
}
free((void *) pathname);
pathname = NULL;
}
+ if (entry != NULL) {
+ free((void *) entry);
+ }
if (dirp != NULL) {
(void) closedir(dirp);
}
if (pathname != NULL) {
free((void *) pathname);
}
- if (fd != 0) {
+ if (fd != -1) {
(void) close(fd);
}
if (dbuf != NULL) {
@@ -186,8 +210,10 @@
return tz;
}
+#ifdef __linux__
+
/*
- * Performs libc implementation specific mapping and returns a zone ID
+ * Performs Linux specific mapping and returns a zone ID
* if found. Otherwise, NULL is returned.
*/
static char *
@@ -408,12 +434,11 @@
}
#endif /* not __sparcv9 */
-static const char *sys_init_file = "/etc/default/init";
/*
- * Performs libc implementation dependent mapping. Returns a zone ID
- * if found. Otherwise, NULL is returned. Solaris libc looks up
- * "/etc/default/init" to get a default TZ value if TZ is not defined
+ * Performs Solaris dependent mapping. Returns a zone ID if
+ * found. Otherwise, NULL is returned. Solaris libc looks up
+ * "/etc/default/init" to get the default TZ value if TZ is not defined
* as an environment variable.
*/
static char *
@@ -425,7 +450,7 @@
/*
* Try the TZ entry in /etc/default/init.
*/
- if ((fp = fileopen(sys_init_file, "r")) != NULL) {
+ if ((fp = fileopen(SYS_INIT_FILE, "r")) != NULL) {
char line[256];
char quote = '\0';
@@ -473,8 +498,113 @@
return tz;
}
-#endif
-#endif
+#define TIMEZONE_FMRI "svc:/system/timezone:default"
+#define TIMEZONE_PG "timezone"
+#define LOCALTIME_PROP "localtime"
+
+static void
+cleanupScf(scf_handle_t *h,
+ scf_snapshot_t *snap,
+ scf_instance_t *inst,
+ scf_propertygroup_t *pg,
+ scf_property_t *prop,
+ scf_value_t *val,
+ char *buf) {
+ if (buf != NULL) {
+ free(buf);
+ }
+ if (snap != NULL) {
+ scf_snapshot_destroy(snap);
+ }
+ if (val != NULL) {
+ scf_value_destroy(val);
+ }
+ if (prop != NULL) {
+ scf_property_destroy(prop);
+ }
+ if (pg != NULL) {
+ scf_pg_destroy(pg);
+ }
+ if (inst != NULL) {
+ scf_instance_destroy(inst);
+ }
+ if (h != NULL) {
+ scf_handle_destroy(h);
+ }
+}
+
+/*
+ * Retruns a zone ID of Solaris when the TZ value is "localtime".
+ * First, it tries scf. If scf fails, it looks for the same file as
+ * /usr/share/lib/zoneinfo/localtime under /usr/share/lib/zoneinfo/.
+ */
+static char *
+getSolarisDefaultZoneID() {
+ char *tz = NULL;
+ struct stat statbuf;
+ size_t size;
+ char *buf;
+ int fd;
+ /* scf specific variables */
+ scf_handle_t *h = NULL;
+ scf_snapshot_t *snap = NULL;
+ scf_instance_t *inst = NULL;
+ scf_propertygroup_t *pg = NULL;
+ scf_property_t *prop = NULL;
+ scf_value_t *val = NULL;
+
+ if ((h = scf_handle_create(SCF_VERSION)) != NULL
+ && scf_handle_bind(h) == 0
+ && (inst = scf_instance_create(h)) != NULL
+ && (snap = scf_snapshot_create(h)) != NULL
+ && (pg = scf_pg_create(h)) != NULL
+ && (prop = scf_property_create(h)) != NULL
+ && (val = scf_value_create(h)) != NULL
+ && scf_handle_decode_fmri(h, TIMEZONE_FMRI, NULL, NULL, inst,
+ NULL, NULL, SCF_DECODE_FMRI_REQUIRE_INSTANCE) == 0
+ && scf_instance_get_snapshot(inst, "running", snap) == 0
+ && scf_instance_get_pg_composed(inst, snap, TIMEZONE_PG, pg) == 0
+ && scf_pg_get_property(pg, LOCALTIME_PROP, prop) == 0
+ && scf_property_get_value(prop, val) == 0) {
+ ssize_t len;
+
+ /* Gets the length of the zone ID string */
+ len = scf_value_get_astring(val, NULL, 0);
+ if (len != -1) {
+ tz = malloc(++len); /* +1 for a null byte */
+ if (tz != NULL && scf_value_get_astring(val, tz, len) != -1) {
+ cleanupScf(h, snap, inst, pg, prop, val, NULL);
+ return tz;
+ }
+ }
+ }
+ cleanupScf(h, snap, inst, pg, prop, val, tz);
+
+ if (stat(DEFAULT_ZONEINFO_FILE, &statbuf) == -1) {
+ return NULL;
+ }
+ size = (size_t) statbuf.st_size;
+ buf = malloc(size);
+ if (buf == NULL) {
+ return NULL;
+ }
+ if ((fd = open(DEFAULT_ZONEINFO_FILE, O_RDONLY)) == -1) {
+ free((void *) buf);
+ return NULL;
+ }
+
+ if (read(fd, buf, size) != (ssize_t) size) {
+ (void) close(fd);
+ free((void *) buf);
+ return NULL;
+ }
+ (void) close(fd);
+ tz = findZoneinfoFile(buf, size, ZONEINFO_DIR);
+ free((void *) buf);
+ return tz;
+}
+#endif /*__solaris__*/
+#endif /*__linux__*/
/*
* findJavaTZ_md() maps platform time zone ID to Java time zone ID
@@ -504,10 +634,21 @@
freetz = tz;
}
+ /*
+ * Remove any preceding ':'
+ */
+ if (tz != NULL && *tz == ':') {
+ tz++;
+ }
+
+#ifdef __solaris__
+ if (strcmp(tz, "localtime") == 0) {
+ tz = getSolarisDefaultZoneID();
+ freetz = tz;
+ }
+#endif
+
if (tz != NULL) {
- if (*tz == ':') {
- tz++;
- }
#ifdef __linux__
/*
* Ignore "posix/" prefix.
@@ -525,24 +666,36 @@
}
/**
- * Returns a GMT-offset-based time zone ID. (e.g., "GMT-08:00")
+ * Returns a GMT-offset-based zone ID. (e.g., "GMT-08:00")
*/
char *
getGMTOffsetID()
{
time_t offset;
- char sign, buf[16];
+ char sign, buf[32];
+#ifdef __solaris__
+ struct tm localtm;
+ time_t currenttime;
- if (timezone == 0) {
+ currenttime = time(NULL);
+ if (localtime_r(¤ttime, &localtm) == NULL) {
+ return NULL;
+ }
+
+ offset = localtm.tm_isdst ? altzone : timezone;
+#else
+ offset = timezone;
+#endif /*__linux__*/
+
+ if (offset == 0) {
return strdup("GMT");
}
/* Note that the time offset direction is opposite. */
- if (timezone > 0) {
- offset = timezone;
+ if (offset > 0) {
sign = '-';
} else {
- offset = -timezone;
+ offset = -offset;
sign = '+';
}
sprintf(buf, (const char *)"GMT%c%02d:%02d",
diff --git a/jdk/src/solaris/native/sun/awt/splashscreen/splashscreen_sys.c b/jdk/src/solaris/native/sun/awt/splashscreen/splashscreen_sys.c
index cf32e63..08c5ec7d 100644
--- a/jdk/src/solaris/native/sun/awt/splashscreen/splashscreen_sys.c
+++ b/jdk/src/solaris/native/sun/awt/splashscreen/splashscreen_sys.c
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2005, 2008, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2005, 2011, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -334,6 +334,7 @@
XDestroyImage(ximage);
SplashRemoveDecoration(splash);
XMapWindow(splash->display, splash->window);
+ XFlush(splash->display);
}
void SplashReconfigureNow(Splash * splash) {
diff --git a/jdk/src/windows/classes/java/net/TwoStacksPlainDatagramSocketImpl.java b/jdk/src/windows/classes/java/net/TwoStacksPlainDatagramSocketImpl.java
index ebd5e52..5fa9dbf 100644
--- a/jdk/src/windows/classes/java/net/TwoStacksPlainDatagramSocketImpl.java
+++ b/jdk/src/windows/classes/java/net/TwoStacksPlainDatagramSocketImpl.java
@@ -70,7 +70,7 @@
fd1 = new FileDescriptor();
try {
super.create();
- } catch (IOException e) {
+ } catch (SocketException e) {
fd1 = null;
throw e;
}
@@ -99,10 +99,11 @@
}
if (optID == SO_BINDADDR) {
- if (fd != null && fd1 != null) {
+ if ((fd != null && fd1 != null) && !connected) {
return anyLocalBoundAddr;
}
- return socketGetOption(optID);
+ int family = connectedAddress == null ? -1 : connectedAddress.family;
+ return socketLocalAddress(family);
} else
return super.getOption(optID);
}
@@ -161,6 +162,8 @@
protected native void connect0(InetAddress address, int port) throws SocketException;
+ protected native Object socketLocalAddress(int family) throws SocketException;
+
protected native void disconnect0(int family);
/**
diff --git a/jdk/src/windows/classes/java/net/TwoStacksPlainSocketImpl.java b/jdk/src/windows/classes/java/net/TwoStacksPlainSocketImpl.java
index 533a989..0b020b3 100644
--- a/jdk/src/windows/classes/java/net/TwoStacksPlainSocketImpl.java
+++ b/jdk/src/windows/classes/java/net/TwoStacksPlainSocketImpl.java
@@ -26,6 +26,7 @@
import java.io.IOException;
import java.io.FileDescriptor;
+import sun.net.ResourceManager;
/*
* This class defines the plain SocketImpl that is used for all
@@ -81,7 +82,12 @@
*/
protected synchronized void create(boolean stream) throws IOException {
fd1 = new FileDescriptor();
- super.create(stream);
+ try {
+ super.create(stream);
+ } catch (IOException e) {
+ fd1 = null;
+ throw e;
+ }
}
/**
@@ -120,6 +126,9 @@
protected void close() throws IOException {
synchronized(fdLock) {
if (fd != null || fd1 != null) {
+ if (!stream) {
+ ResourceManager.afterUdpClose();
+ }
if (fdUseCount == 0) {
if (closePending) {
return;
diff --git a/jdk/src/windows/classes/sun/awt/windows/WComponentPeer.java b/jdk/src/windows/classes/sun/awt/windows/WComponentPeer.java
index 01eb239..a482fd9 100644
--- a/jdk/src/windows/classes/sun/awt/windows/WComponentPeer.java
+++ b/jdk/src/windows/classes/sun/awt/windows/WComponentPeer.java
@@ -615,6 +615,14 @@
_dispose();
}
+ public void disposeLater() {
+ postEvent(new InvocationEvent(Toolkit.getDefaultToolkit(), new Runnable() {
+ public void run() {
+ dispose();
+ }
+ }));
+ }
+
public synchronized void setForeground(Color c) {
foreground = c;
_setForeground(c.getRGB());
diff --git a/jdk/src/windows/native/java/net/TwoStacksPlainDatagramSocketImpl.c b/jdk/src/windows/native/java/net/TwoStacksPlainDatagramSocketImpl.c
index 5ca6736..1610177 100644
--- a/jdk/src/windows/native/java/net/TwoStacksPlainDatagramSocketImpl.c
+++ b/jdk/src/windows/native/java/net/TwoStacksPlainDatagramSocketImpl.c
@@ -2181,30 +2181,6 @@
return getMulticastInterface(env, this, fd, fd1, opt);
}
- if (opt == java_net_SocketOptions_SO_BINDADDR) {
- /* find out local IP address */
- SOCKETADDRESS him;
- int len = 0;
- int port;
- jobject iaObj;
-
- len = sizeof (struct sockaddr_in);
-
- if (fd == -1) {
- fd = fd1; /* must be IPv6 only */
- len = sizeof (struct SOCKADDR_IN6);
- }
-
- if (getsockname(fd, (struct sockaddr *)&him, &len) == -1) {
- NET_ThrowByNameWithLastError(env, JNU_JAVANETPKG "SocketException",
- "Error getting socket name");
- return NULL;
- }
- iaObj = NET_SockaddrToInetAddress(env, (struct sockaddr *)&him, &port);
-
- return iaObj;
- }
-
/*
* Map the Java level socket option to the platform specific
* level and option name.
@@ -2253,6 +2229,61 @@
}
/*
+ * Returns local address of the socket.
+ *
+ * Class: java_net_TwoStacksPlainDatagramSocketImpl
+ * Method: socketLocalAddress
+ * Signature: (I)Ljava/lang/Object;
+ */
+JNIEXPORT jobject JNICALL
+Java_java_net_TwoStacksPlainDatagramSocketImpl_socketLocalAddress(JNIEnv *env, jobject this,
+ jint family) {
+
+ int fd=-1, fd1=-1;
+ SOCKETADDRESS him;
+ int len = 0;
+ int port;
+ jobject iaObj;
+ int ipv6_supported = ipv6_available();
+
+ fd = getFD(env, this);
+ if (ipv6_supported) {
+ fd1 = getFD1(env, this);
+ }
+
+ if (fd < 0 && fd1 < 0) {
+ JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",
+ "Socket closed");
+ return NULL;
+ }
+
+ /* find out local IP address */
+
+ len = sizeof (struct sockaddr_in);
+
+ /* family==-1 when socket is not connected */
+ if ((family == IPv6) || (family == -1 && fd == -1)) {
+ fd = fd1; /* must be IPv6 only */
+ len = sizeof (struct SOCKADDR_IN6);
+ }
+
+ if (fd == -1) {
+ JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",
+ "Socket closed");
+ return NULL;
+ }
+
+ if (getsockname(fd, (struct sockaddr *)&him, &len) == -1) {
+ NET_ThrowByNameWithLastError(env, JNU_JAVANETPKG "SocketException",
+ "Error getting socket name");
+ return NULL;
+ }
+ iaObj = NET_SockaddrToInetAddress(env, (struct sockaddr *)&him, &port);
+
+ return iaObj;
+}
+
+/*
* Class: java_net_TwoStacksPlainDatagramSocketImpl
* Method: setTimeToLive
* Signature: (I)V
diff --git a/jdk/src/windows/native/sun/windows/awt_Component.cpp b/jdk/src/windows/native/sun/windows/awt_Component.cpp
index a6ada9c..57d1733 100644
--- a/jdk/src/windows/native/sun/windows/awt_Component.cpp
+++ b/jdk/src/windows/native/sun/windows/awt_Component.cpp
@@ -183,6 +183,7 @@
jmethodID AwtComponent::getLocationOnScreenMID;
jmethodID AwtComponent::replaceSurfaceDataMID;
jmethodID AwtComponent::replaceSurfaceDataLaterMID;
+jmethodID AwtComponent::disposeLaterMID;
HKL AwtComponent::m_hkl = ::GetKeyboardLayout(0);
LANGID AwtComponent::m_idLang = LOWORD(::GetKeyboardLayout(0));
@@ -246,6 +247,7 @@
m_hCursorCache = NULL;
m_bSubclassed = FALSE;
+ m_bPauseDestroy = FALSE;
m_MessagesProcessing = 0;
m_wheelRotationAmount = 0;
@@ -319,6 +321,12 @@
m_brushBackground = NULL;
}
+ if (m_bPauseDestroy) {
+ // AwtComponent::WmNcDestroy could be released now
+ m_bPauseDestroy = FALSE;
+ m_hwnd = NULL;
+ }
+
// The component instance is deleted using AwtObject::Dispose() method
AwtObject::Dispose();
}
@@ -1377,6 +1385,7 @@
case WM_CREATE: mr = WmCreate(); break;
case WM_CLOSE: mr = WmClose(); break;
case WM_DESTROY: mr = WmDestroy(); break;
+ case WM_NCDESTROY: mr = WmNcDestroy(); break;
case WM_ERASEBKGND:
mr = WmEraseBkgnd((HDC)wParam, *(BOOL*)&retValue); break;
@@ -1965,10 +1974,24 @@
*/
MsgRouting AwtComponent::WmDestroy()
{
- // fix for 6259348: we should enter the SyncCall critical section before
- // disposing the native object, that is value 1 of lParam is intended for
- if(m_peerObject != NULL) { // is not being terminating
- AwtToolkit::GetInstance().SendMessage(WM_AWT_DISPOSE, (WPARAM)m_peerObject, (LPARAM)1);
+ return mrConsume;
+}
+
+/*
+ * This message should only be received when a window is destroyed by
+ * Windows, and not Java. It is sent only after child windows were destroyed.
+ */
+MsgRouting AwtComponent::WmNcDestroy()
+{
+ if (m_peerObject != NULL) { // is not being terminating
+ // Stay in this handler until AwtComponent::Dispose is called.
+ m_bPauseDestroy = TRUE;
+
+ JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
+ // Post invocation event for WObjectPeer.dispose to EDT
+ env->CallVoidMethod(m_peerObject, AwtComponent::disposeLaterMID);
+ // Wait until AwtComponent::Dispose is called
+ AwtToolkit::GetInstance().PumpToDestroy(this);
}
return mrConsume;
@@ -6300,6 +6323,7 @@
env->GetMethodID(peerCls, "replaceSurfaceData", "()V");
AwtComponent::replaceSurfaceDataLaterMID =
env->GetMethodID(peerCls, "replaceSurfaceDataLater", "()V");
+ AwtComponent::disposeLaterMID = env->GetMethodID(peerCls, "disposeLater", "()V");
DASSERT(AwtComponent::xID);
DASSERT(AwtComponent::yID);
@@ -6318,6 +6342,8 @@
DASSERT(AwtComponent::getLocationOnScreenMID);
DASSERT(AwtComponent::replaceSurfaceDataMID);
DASSERT(AwtComponent::replaceSurfaceDataLaterMID);
+ DASSERT(AwtComponent::disposeLaterMID);
+
CATCH_BAD_ALLOC;
}
diff --git a/jdk/src/windows/native/sun/windows/awt_Component.h b/jdk/src/windows/native/sun/windows/awt_Component.h
index ece5c3b..3257c51 100644
--- a/jdk/src/windows/native/sun/windows/awt_Component.h
+++ b/jdk/src/windows/native/sun/windows/awt_Component.h
@@ -119,6 +119,7 @@
static jmethodID getLocationOnScreenMID;
static jmethodID replaceSurfaceDataMID;
static jmethodID replaceSurfaceDataLaterMID;
+ static jmethodID disposeLaterMID;
static const UINT WmAwtIsComponent;
static jint * masks; //InputEvent mask array
@@ -490,6 +491,7 @@
virtual MsgRouting WmCreate() {return mrDoDefault;}
virtual MsgRouting WmClose() {return mrDoDefault;}
virtual MsgRouting WmDestroy();
+ virtual MsgRouting WmNcDestroy();
virtual MsgRouting WmActivate(UINT nState, BOOL fMinimized, HWND opposite)
{
@@ -711,6 +713,10 @@
return m_MessagesProcessing == 0;
}
+ BOOL IsDestroyPaused() const {
+ return m_bPauseDestroy;
+ }
+
protected:
static AwtComponent* GetComponentImpl(HWND hWnd);
@@ -752,6 +758,7 @@
UINT m_mouseButtonClickAllowed;
BOOL m_bSubclassed;
+ BOOL m_bPauseDestroy;
COLORREF m_colorForeground;
COLORREF m_colorBackground;
diff --git a/jdk/src/windows/native/sun/windows/awt_Toolkit.cpp b/jdk/src/windows/native/sun/windows/awt_Toolkit.cpp
index 00f9b32..9135403 100644
--- a/jdk/src/windows/native/sun/windows/awt_Toolkit.cpp
+++ b/jdk/src/windows/native/sun/windows/awt_Toolkit.cpp
@@ -733,26 +733,13 @@
return 0;
}
case WM_AWT_DISPOSE: {
- BOOL canDispose = TRUE;
- CriticalSection &syncCS = AwtToolkit::GetInstance().GetSyncCS();
- int shouldEnterCriticalSection = (int)lParam;
- if (shouldEnterCriticalSection == 1) {
- canDispose = syncCS.TryEnter();
- }
- if (canDispose) {
- if(wParam != NULL) {
- jobject self = (jobject)wParam;
- AwtObject *o = (AwtObject *) JNI_GET_PDATA(self);
- env->DeleteGlobalRef(self);
- if(o != NULL && theAwtObjectList.Remove(o)) {
- o->Dispose();
- }
- if (shouldEnterCriticalSection) {
- syncCS.Leave();
- }
+ if(wParam != NULL) {
+ jobject self = (jobject)wParam;
+ AwtObject *o = (AwtObject *) JNI_GET_PDATA(self);
+ env->DeleteGlobalRef(self);
+ if(o != NULL && theAwtObjectList.Remove(o)) {
+ o->Dispose();
}
- } else {
- AwtToolkit::GetInstance().PostMessage(WM_AWT_DISPOSE, wParam, lParam);
}
return 0;
}
@@ -1340,27 +1327,48 @@
while (!m_breakMessageLoop && (*lpPeekMessageFunc)(msg)) {
foundOne = TRUE;
- if (msg.message == WM_QUIT) {
- m_breakMessageLoop = TRUE;
- m_messageLoopResult = static_cast<UINT>(msg.wParam);
- if (m_messageLoopResult == EXIT_ALL_ENCLOSING_LOOPS)
- ::PostQuitMessage(static_cast<int>(msg.wParam)); // make sure all loops exit
- break;
- }
- else if (msg.message != WM_NULL) {
- /*
- * The AWT in standalone mode (that is, dynamically loaded from the
- * Java VM) doesn't have any translation tables to worry about, so
- * TranslateAccelerator isn't called.
- */
-
- ::TranslateMessage(&msg);
- ::DispatchMessage(&msg);
- }
+ ProcessMsg(msg);
}
return foundOne;
}
+void AwtToolkit::PumpToDestroy(class AwtComponent* p)
+{
+ MSG msg;
+
+ DASSERT(AwtToolkit::PrimaryIdleFunc != NULL);
+ DASSERT(AwtToolkit::CommonPeekMessageFunc != NULL);
+
+ while (p->IsDestroyPaused() && !m_breakMessageLoop) {
+
+ PrimaryIdleFunc();
+
+ while (p->IsDestroyPaused() && !m_breakMessageLoop && CommonPeekMessageFunc(msg)) {
+ ProcessMsg(msg);
+ }
+ }
+}
+
+void AwtToolkit::ProcessMsg(MSG& msg)
+{
+ if (msg.message == WM_QUIT) {
+ m_breakMessageLoop = TRUE;
+ m_messageLoopResult = static_cast<UINT>(msg.wParam);
+ if (m_messageLoopResult == EXIT_ALL_ENCLOSING_LOOPS)
+ ::PostQuitMessage(static_cast<int>(msg.wParam)); // make sure all loops exit
+ }
+ else if (msg.message != WM_NULL) {
+ /*
+ * The AWT in standalone mode (that is, dynamically loaded from the
+ * Java VM) doesn't have any translation tables to worry about, so
+ * TranslateAccelerator isn't called.
+ */
+
+ ::TranslateMessage(&msg);
+ ::DispatchMessage(&msg);
+ }
+}
+
VOID CALLBACK
AwtToolkit::PrimaryIdleFunc() {
AwtToolkit::SetBusy(FALSE);
diff --git a/jdk/src/windows/native/sun/windows/awt_Toolkit.h b/jdk/src/windows/native/sun/windows/awt_Toolkit.h
index 3ebd465..f3e7e74 100644
--- a/jdk/src/windows/native/sun/windows/awt_Toolkit.h
+++ b/jdk/src/windows/native/sun/windows/awt_Toolkit.h
@@ -305,6 +305,8 @@
UINT MessageLoop(IDLEPROC lpIdleFunc, PEEKMESSAGEPROC lpPeekMessageFunc);
BOOL PumpWaitingMessages(PEEKMESSAGEPROC lpPeekMessageFunc);
+ void PumpToDestroy(class AwtComponent* p);
+ void ProcessMsg(MSG& msg);
BOOL PreProcessMsg(MSG& msg);
BOOL PreProcessMouseMsg(class AwtComponent* p, MSG& msg);
BOOL PreProcessKeyMsg(class AwtComponent* p, MSG& msg);
diff --git a/jdk/test/com/sun/jndi/ldap/LdapsReadTimeoutTest.java b/jdk/test/com/sun/jndi/ldap/LdapsReadTimeoutTest.java
new file mode 100644
index 0000000..9fae77d
--- /dev/null
+++ b/jdk/test/com/sun/jndi/ldap/LdapsReadTimeoutTest.java
@@ -0,0 +1,118 @@
+/*
+ * Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/**
+ * @test
+ * @bug 7094377
+ * @summary Com.sun.jndi.ldap.read.timeout doesn't work with ldaps.
+ */
+
+import java.net.Socket;
+import java.net.ServerSocket;
+import java.io.*;
+import javax.naming.*;
+import javax.naming.directory.*;
+import java.util.Hashtable;
+
+public class LdapsReadTimeoutTest {
+
+ public static void main(String[] args) throws Exception {
+ boolean passed = false;
+
+ // create the server
+ try (Server server = Server.create()) {
+ // Set up the environment for creating the initial context
+ Hashtable<String,Object> env = new Hashtable<>(11);
+ env.put(Context.INITIAL_CONTEXT_FACTORY,
+ "com.sun.jndi.ldap.LdapCtxFactory");
+ env.put("com.sun.jndi.ldap.connect.timeout", "1000");
+ env.put("com.sun.jndi.ldap.read.timeout", "1000");
+ env.put(Context.PROVIDER_URL, "ldaps://localhost:" + server.port());
+
+
+ // Create initial context
+ DirContext ctx = new InitialDirContext(env);
+ try {
+ System.out.println("LDAP Client: Connected to the Server");
+
+ SearchControls scl = new SearchControls();
+ scl.setSearchScope(SearchControls.SUBTREE_SCOPE);
+ System.out.println("Performing Search");
+ NamingEnumeration<SearchResult> answer =
+ ctx.search("ou=People,o=JNDITutorial", "(objectClass=*)", scl);
+ } finally {
+ // Close the context when we're done
+ ctx.close();
+ }
+ } catch (NamingException e) {
+ passed = true;
+ e.printStackTrace();
+ }
+
+ if (!passed) {
+ throw new Exception("Read timeout test failed," +
+ " read timeout exception not thrown");
+ }
+ System.out.println("The test PASSED");
+ }
+
+ static class Server implements Runnable, Closeable {
+ private final ServerSocket ss;
+ private Socket sref;
+
+ private Server(ServerSocket ss) {
+ this.ss = ss;
+ }
+
+ static Server create() throws IOException {
+ Server server = new Server(new ServerSocket(0));
+ new Thread(server).start();
+ return server;
+ }
+
+ int port() {
+ return ss.getLocalPort();
+ }
+
+ public void run() {
+ try (Socket s = ss.accept()) {
+ sref = s;
+ System.out.println("Server: Connection accepted");
+ BufferedInputStream bis =
+ new BufferedInputStream(s.getInputStream());
+ byte[] buf = new byte[100];
+ int n;
+ do {
+ n = bis.read(buf);
+ } while (n > 0);
+ } catch (IOException e) {
+ // ignore
+ }
+ }
+
+ public void close() throws IOException {
+ ss.close();
+ sref.close();
+ }
+ }
+}
diff --git a/jdk/test/java/net/CookieHandler/NullUriCookieTest.java b/jdk/test/java/net/CookieHandler/NullUriCookieTest.java
new file mode 100644
index 0000000..60d0550
--- /dev/null
+++ b/jdk/test/java/net/CookieHandler/NullUriCookieTest.java
@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * @test
+ * @bug 6953455
+ * @summary CookieStore.add() cannot handle null URI parameter
+ */
+
+import java.net.CookieManager;
+import java.net.CookieStore;
+import java.net.HttpCookie;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.util.List;
+
+public class NullUriCookieTest {
+ static boolean fail = false;
+
+ public static void main(String[] args) throws Exception {
+ checkCookieNullUri();
+ }
+
+ static void checkCookieNullUri() throws Exception {
+ //get a cookie store implementation and add a cookie to the store with null URI
+ CookieStore cookieStore = (new CookieManager()).getCookieStore();
+ HttpCookie cookie = new HttpCookie("MY_COOKIE", "MY_COOKIE_VALUE");
+ cookie.setDomain("foo.com");
+ cookieStore.add(null, cookie);
+
+ //Retrieve added cookie
+ URI uri = new URI("http://foo.com");
+ List<HttpCookie> addedCookieList = cookieStore.get(uri);
+
+ //Verify CookieStore behaves well
+ if (addedCookieList.size() != 1) {
+ fail = true;
+ }
+ checkFail("Abnormal size of cookie jar");
+
+ for (HttpCookie chip : addedCookieList) {
+ if (!chip.equals(cookie)) {
+ fail = true;
+ }
+ }
+ checkFail("Cookie not retrieved from Cookie Jar");
+ boolean ret = cookieStore.remove(null,cookie);
+ if (!ret) {
+ fail = true;
+ }
+ checkFail("Abnormal removal behaviour from Cookie Jar");
+ }
+
+ static void checkFail(String exp) {
+ if (fail) {
+ throw new RuntimeException(exp);
+ }
+ }
+}
+
diff --git a/jdk/test/java/net/DatagramSocket/ChangingAddress.java b/jdk/test/java/net/DatagramSocket/ChangingAddress.java
new file mode 100644
index 0000000..42cc78b
--- /dev/null
+++ b/jdk/test/java/net/DatagramSocket/ChangingAddress.java
@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/* @test
+ * @bug 7084030
+ * @summary Tests that DatagramSocket.getLocalAddress returns the right local
+ * address after connect/disconnect.
+ */
+import java.net.*;
+
+public class ChangingAddress {
+
+ static void check(DatagramSocket ds, InetAddress expected) {
+ InetAddress actual = ds.getLocalAddress();
+ if (!expected.equals(actual)) {
+ throw new RuntimeException("Expected:"+expected+" Actual"+
+ actual);
+ }
+ }
+
+ public static void main(String[] args) throws Exception {
+ InetAddress lh = InetAddress.getLocalHost();
+ SocketAddress remote = new InetSocketAddress(lh, 1234);
+ InetAddress wildcard = InetAddress.getByAddress
+ ("localhost", new byte[]{0,0,0,0});
+ try (DatagramSocket ds = new DatagramSocket()) {
+ check(ds, wildcard);
+
+ ds.connect(remote);
+ check(ds, lh);
+
+ ds.disconnect();
+ check(ds, wildcard);
+ }
+ }
+}
diff --git a/jdk/test/java/net/URLConnection/Redirect307Test.java b/jdk/test/java/net/URLConnection/Redirect307Test.java
index b9e7749..d9e980f 100644
--- a/jdk/test/java/net/URLConnection/Redirect307Test.java
+++ b/jdk/test/java/net/URLConnection/Redirect307Test.java
@@ -23,7 +23,7 @@
/**
* @test
- * @bug 4380568
+ * @bug 4380568 7095949
* @summary HttpURLConnection does not support 307 redirects
*/
import java.io.*;
@@ -31,10 +31,9 @@
class RedirServer extends Thread {
- ServerSocket s;
- Socket s1;
- InputStream is;
- OutputStream os;
+ static final int TIMEOUT = 10 * 1000;
+
+ ServerSocket ss;
int port;
String reply1Part1 = "HTTP/1.1 307 Temporary Redirect\r\n" +
@@ -46,10 +45,10 @@
"Content-Type: text/html; charset=iso-8859-1\r\n\r\n" +
"<html>Hello</html>";
- RedirServer (ServerSocket y) {
- s = y;
- port = s.getLocalPort();
- System.out.println("Server created listening on " + port);
+ RedirServer (ServerSocket ss) throws IOException {
+ this.ss = ss;
+ this.ss.setSoTimeout(TIMEOUT);
+ port = this.ss.getLocalPort();
}
String reply2 = "HTTP/1.1 200 Ok\r\n" +
@@ -59,74 +58,63 @@
"Content-Type: text/html; charset=iso-8859-1\r\n\r\n" +
"World";
+ static final byte[] requestEnd = new byte[] {'\r', '\n', '\r', '\n' };
+
+ // Read until the end of a HTTP request
+ void readOneRequest(InputStream is) throws IOException {
+ int requestEndCount = 0, r;
+ while ((r = is.read()) != -1) {
+ if (r == requestEnd[requestEndCount]) {
+ requestEndCount++;
+ if (requestEndCount == 4) {
+ break;
+ }
+ } else {
+ requestEndCount = 0;
+ }
+ }
+ }
+
public void run () {
try {
- s1 = s.accept ();
- is = s1.getInputStream ();
- os = s1.getOutputStream ();
- is.read ();
- String reply = reply1Part1 + port + reply1Part2;
- os.write (reply.getBytes());
- os.close();
+ try (Socket s = ss.accept()) {
+ s.setSoTimeout(TIMEOUT);
+ readOneRequest(s.getInputStream());
+ String reply = reply1Part1 + port + reply1Part2;
+ s.getOutputStream().write(reply.getBytes());
+ }
+
/* wait for redirected connection */
- s.setSoTimeout (5000);
- s1 = s.accept ();
- is = s1.getInputStream ();
- os = s1.getOutputStream ();
- is.read();
- os.write (reply2.getBytes());
- os.close();
- }
- catch (Exception e) {
- /* Just need thread to terminate */
- System.out.println("Server: caught " + e);
+ try (Socket s = ss.accept()) {
+ s.setSoTimeout(TIMEOUT);
+ readOneRequest(s.getInputStream());
+ s.getOutputStream().write(reply2.getBytes());
+ }
+ } catch (Exception e) {
e.printStackTrace();
} finally {
- try { s.close(); } catch (IOException unused) {}
+ try { ss.close(); } catch (IOException unused) {}
}
}
};
-
public class Redirect307Test {
-
- public static final int DELAY = 10;
-
public static void main(String[] args) throws Exception {
- int port;
- RedirServer server;
- ServerSocket sock;
+ ServerSocket sock = new ServerSocket(0);
+ int port = sock.getLocalPort();
+ RedirServer server = new RedirServer(sock);
+ server.start();
- try {
- sock = new ServerSocket (0);
- port = sock.getLocalPort ();
- }
- catch (Exception e) {
- System.out.println ("Exception: " + e);
- return;
- }
+ URL url = new URL("http://localhost:" + port);
+ URLConnection conURL = url.openConnection();
+ conURL.setDoInput(true);
+ conURL.setAllowUserInteraction(false);
+ conURL.setUseCaches(false);
- server = new RedirServer(sock);
- server.start ();
-
- try {
-
- String s = "http://localhost:" + port;
- URL url = new URL(s);
- URLConnection conURL = url.openConnection();
-
- conURL.setDoInput(true);
- conURL.setAllowUserInteraction(false);
- conURL.setUseCaches(false);
-
- InputStream in = conURL.getInputStream();
+ try (InputStream in = conURL.getInputStream()) {
if ((in.read() != (int)'W') || (in.read()!=(int)'o')) {
throw new RuntimeException ("Unexpected string read");
}
}
- catch(IOException e) {
- e.printStackTrace();
- throw new RuntimeException ("Exception caught + " + e);
- }
}
}
diff --git a/jdk/test/java/net/URLConnection/RedirectLimit.java b/jdk/test/java/net/URLConnection/RedirectLimit.java
index 5fe65a1..ea90c69 100644
--- a/jdk/test/java/net/URLConnection/RedirectLimit.java
+++ b/jdk/test/java/net/URLConnection/RedirectLimit.java
@@ -23,7 +23,7 @@
/**
* @test
- * @bug 4458085
+ * @bug 4458085 7095949
* @summary Redirects Limited to 5
*/
@@ -57,29 +57,43 @@
final ServerSocket ss;
final int port;
- RedirLimitServer(ServerSocket ss) {
+ RedirLimitServer(ServerSocket ss) throws IOException {
this.ss = ss;
- port = ss.getLocalPort();
+ port = this.ss.getLocalPort();
+ this.ss.setSoTimeout(TIMEOUT);
+ }
+
+ static final byte[] requestEnd = new byte[] {'\r', '\n', '\r', '\n' };
+
+ // Read until the end of a HTTP request
+ void readOneRequest(InputStream is) throws IOException {
+ int requestEndCount = 0, r;
+ while ((r = is.read()) != -1) {
+ if (r == requestEnd[requestEndCount]) {
+ requestEndCount++;
+ if (requestEndCount == 4) {
+ break;
+ }
+ } else {
+ requestEndCount = 0;
+ }
+ }
}
public void run() {
try {
- ss.setSoTimeout(TIMEOUT);
for (int i=0; i<NUM_REDIRECTS; i++) {
try (Socket s = ss.accept()) {
s.setSoTimeout(TIMEOUT);
- InputStream is = s.getInputStream();
- OutputStream os = s.getOutputStream();
- is.read();
+ readOneRequest(s.getInputStream());
String reply = reply1 + port + "/redirect" + i + reply2;
- os.write(reply.getBytes());
+ s.getOutputStream().write(reply.getBytes());
}
}
try (Socket s = ss.accept()) {
- InputStream is = s.getInputStream();
- OutputStream os = s.getOutputStream();
- is.read();
- os.write(reply3.getBytes());
+ s.setSoTimeout(TIMEOUT);
+ readOneRequest(s.getInputStream());
+ s.getOutputStream().write(reply3.getBytes());
}
} catch (Exception e) {
e.printStackTrace();
@@ -96,21 +110,17 @@
RedirLimitServer server = new RedirLimitServer(ss);
server.start();
- InputStream in = null;
- try {
- URL url = new URL("http://localhost:" + port);
- URLConnection conURL = url.openConnection();
+ URL url = new URL("http://localhost:" + port);
+ URLConnection conURL = url.openConnection();
- conURL.setDoInput(true);
- conURL.setAllowUserInteraction(false);
- conURL.setUseCaches(false);
+ conURL.setDoInput(true);
+ conURL.setAllowUserInteraction(false);
+ conURL.setUseCaches(false);
- in = conURL.getInputStream();
+ try (InputStream in = conURL.getInputStream()) {
if ((in.read() != (int)'W') || (in.read()!=(int)'o')) {
throw new RuntimeException("Unexpected string read");
}
- } finally {
- if ( in != null ) { in.close(); }
}
}
}
diff --git a/jdk/test/java/util/Locale/Bug6989440.java b/jdk/test/java/util/Locale/Bug6989440.java
index ebf62f9..d524d05 100644
--- a/jdk/test/java/util/Locale/Bug6989440.java
+++ b/jdk/test/java/util/Locale/Bug6989440.java
@@ -37,26 +37,49 @@
import sun.util.LocaleServiceProviderPool;
public class Bug6989440 {
- public static void main(String[] args) {
- TestThread t1 = new TestThread(LocaleNameProvider.class);
- TestThread t2 = new TestThread(TimeZoneNameProvider.class);
- TestThread t3 = new TestThread(DateFormatProvider.class);
+ static volatile boolean failed; // false
+ static final int THREADS = 50;
- t1.start();
- t2.start();
- t3.start();
+ public static void main(String[] args) throws Exception {
+ Thread[] threads = new Thread[THREADS];
+ for (int i=0; i<threads.length; i++)
+ threads[i] = new TestThread();
+ for (int i=0; i<threads.length; i++)
+ threads[i].start();
+ for (int i=0; i<threads.length; i++)
+ threads[i].join();
+
+ if (failed)
+ throw new RuntimeException("Failed: check output");
}
static class TestThread extends Thread {
private Class<? extends LocaleServiceProvider> cls;
+ private static int count;
public TestThread(Class<? extends LocaleServiceProvider> providerClass) {
cls = providerClass;
}
+ public TestThread() {
+ int which = count++ % 3;
+ switch (which) {
+ case 0 : cls = LocaleNameProvider.class; break;
+ case 1 : cls = TimeZoneNameProvider.class; break;
+ case 2 : cls = DateFormatProvider.class; break;
+ default : throw new AssertionError("Should not reach here");
+ }
+ }
+
public void run() {
- LocaleServiceProviderPool pool = LocaleServiceProviderPool.getPool(cls);
- pool.getAvailableLocales();
+ try {
+ LocaleServiceProviderPool pool = LocaleServiceProviderPool.getPool(cls);
+ pool.getAvailableLocales();
+ } catch (Exception e) {
+ System.out.println(e);
+ e.printStackTrace();
+ failed = true;
+ }
}
}
}
diff --git a/jdk/test/javax/swing/JColorChooser/Test6827032.java b/jdk/test/javax/swing/JColorChooser/Test6827032.java
new file mode 100644
index 0000000..0cb8234
--- /dev/null
+++ b/jdk/test/javax/swing/JColorChooser/Test6827032.java
@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) 2007, 2011, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * @test
+ * @bug 6827032
+ * @summary Color chooser with drag enabled shouldn't throw NPE
+ * @author Peter Zhelezniakov
+ * @library ../regtesthelpers
+ */
+
+import sun.awt.SunToolkit;
+
+import java.awt.*;
+import java.awt.event.*;
+
+import javax.swing.*;
+import javax.swing.plaf.nimbus.NimbusLookAndFeel;
+
+
+public class Test6827032 {
+
+ private static volatile Point point;
+ private static JColorChooser cc;
+
+ public static void main(String[] args) throws Exception {
+ UIManager.setLookAndFeel(new NimbusLookAndFeel());
+
+ Robot robot = new Robot();
+ robot.setAutoDelay(50);
+
+ SunToolkit toolkit = (SunToolkit) Toolkit.getDefaultToolkit();
+
+ SwingUtilities.invokeAndWait(new Runnable() {
+ public void run() {
+ createAndShowGUI();
+ }
+ });
+
+ toolkit.realSync();
+
+ SwingUtilities.invokeAndWait(new Runnable() {
+ public void run() {
+ Component previewPanel = Util.findSubComponent(cc, "javax.swing.colorchooser.DefaultPreviewPanel");
+ point = previewPanel.getLocationOnScreen();
+ }
+ });
+
+ point.translate(5, 5);
+
+ robot.mouseMove(point.x, point.y);
+ robot.mousePress(InputEvent.BUTTON1_MASK);
+ robot.mouseRelease(InputEvent.BUTTON1_MASK);
+ }
+
+
+ private static void createAndShowGUI() {
+ JFrame frame = new JFrame(Test6827032.class.getName());
+ frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+ cc = new JColorChooser();
+ cc.setDragEnabled(true);
+ frame.add(cc);
+ frame.pack();
+ frame.setVisible(true);
+ }
+}
diff --git a/jdk/test/javax/swing/regtesthelpers/Util.java b/jdk/test/javax/swing/regtesthelpers/Util.java
index 76217ae..6e61ad3 100644
--- a/jdk/test/javax/swing/regtesthelpers/Util.java
+++ b/jdk/test/javax/swing/regtesthelpers/Util.java
@@ -116,4 +116,28 @@
System.out.println("Got OOME");
}
+
+ /**
+ * Find a sub component by class name.
+ * Always run this method on the EDT thread
+ */
+ public static Component findSubComponent(Component parent, String className) {
+ String parentClassName = parent.getClass().getName();
+
+ if (parentClassName.contains(className)) {
+ return parent;
+ }
+
+ if (parent instanceof Container) {
+ for (Component child : ((Container) parent).getComponents()) {
+ Component subComponent = findSubComponent(child, className);
+
+ if (subComponent != null) {
+ return subComponent;
+ }
+ }
+ }
+
+ return null;
+ }
}
diff --git a/jdk/test/sun/misc/JarIndex/metaInfFilenames/Basic.java b/jdk/test/sun/misc/JarIndex/metaInfFilenames/Basic.java
index ace09c2..3892054 100644
--- a/jdk/test/sun/misc/JarIndex/metaInfFilenames/Basic.java
+++ b/jdk/test/sun/misc/JarIndex/metaInfFilenames/Basic.java
@@ -154,8 +154,8 @@
/* run javac <args> */
static void compile(String... args) {
debug("Running: javac " + Arrays.toString(args));
- com.sun.tools.javac.main.Main compiler = new com.sun.tools.javac.main.Main("javac");
- if (compiler.compile(args) != com.sun.tools.javac.main.Main.Result.OK) {
+ com.sun.tools.javac.Main compiler = new com.sun.tools.javac.Main();
+ if (compiler.compile(args) != 0) {
throw new RuntimeException("javac failed: args=" + Arrays.toString(args));
}
}
diff --git a/jdk/test/sun/security/krb5/auto/AcceptorSubKey.java b/jdk/test/sun/security/krb5/auto/AcceptorSubKey.java
new file mode 100644
index 0000000..9aba5e4
--- /dev/null
+++ b/jdk/test/sun/security/krb5/auto/AcceptorSubKey.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * @test
+ * @bug 7077646
+ * @summary gssapi wrap for CFX per-message tokens always set FLAG_ACCEPTOR_SUBKEY
+ * @compile -XDignore.symbol.file AcceptorSubKey.java
+ * @run main/othervm AcceptorSubKey
+ */
+
+import java.util.Arrays;
+import sun.security.jgss.GSSUtil;
+
+// The basic krb5 test skeleton you can copy from
+public class AcceptorSubKey {
+
+ public static void main(String[] args) throws Exception {
+
+ new OneKDC(null).writeJAASConf();
+
+ Context c, s;
+ c = Context.fromJAAS("client");
+ s = Context.fromJAAS("server");
+
+ c.startAsClient(OneKDC.SERVER, GSSUtil.GSS_SPNEGO_MECH_OID);
+ s.startAsServer(GSSUtil.GSS_SPNEGO_MECH_OID);
+
+ Context.handshake(c, s);
+
+ byte[] msg = "i say high --".getBytes();
+ byte[] wrapped = s.wrap(msg, false);
+
+ // FLAG_ACCEPTOR_SUBKEY is 4
+ int flagOn = wrapped[2] & 4;
+ if (flagOn != 0) {
+ throw new Exception("Java GSS should not have set acceptor subkey");
+ }
+
+ s.dispose();
+ c.dispose();
+ }
+}
diff --git a/jdk/test/sun/security/krb5/auto/Context.java b/jdk/test/sun/security/krb5/auto/Context.java
index 1739f87..eb2a94a 100644
--- a/jdk/test/sun/security/krb5/auto/Context.java
+++ b/jdk/test/sun/security/krb5/auto/Context.java
@@ -375,6 +375,89 @@
}
}
+ public byte[] wrap(byte[] t, final boolean privacy)
+ throws Exception {
+ return doAs(new Action() {
+ @Override
+ public byte[] run(Context me, byte[] input) throws Exception {
+ System.out.printf("wrap %s privacy from %s: ", privacy?"with":"without", me.name);
+ MessageProp p1 = new MessageProp(0, privacy);
+ byte[] out;
+ if (usingStream) {
+ ByteArrayOutputStream os = new ByteArrayOutputStream();
+ me.x.wrap(new ByteArrayInputStream(input), os, p1);
+ out = os.toByteArray();
+ } else {
+ out = me.x.wrap(input, 0, input.length, p1);
+ }
+ System.out.println(printProp(p1));
+ return out;
+ }
+ }, t);
+ }
+
+ public byte[] unwrap(byte[] t, final boolean privacy)
+ throws Exception {
+ return doAs(new Action() {
+ @Override
+ public byte[] run(Context me, byte[] input) throws Exception {
+ System.out.printf("unwrap %s privacy from %s: ", privacy?"with":"without", me.name);
+ MessageProp p1 = new MessageProp(0, privacy);
+ byte[] bytes;
+ if (usingStream) {
+ ByteArrayOutputStream os = new ByteArrayOutputStream();
+ me.x.unwrap(new ByteArrayInputStream(input), os, p1);
+ bytes = os.toByteArray();
+ } else {
+ bytes = me.x.unwrap(input, 0, input.length, p1);
+ }
+ System.out.println(printProp(p1));
+ return bytes;
+ }
+ }, t);
+ }
+
+ public byte[] getMic(byte[] t) throws Exception {
+ return doAs(new Action() {
+ @Override
+ public byte[] run(Context me, byte[] input) throws Exception {
+ MessageProp p1 = new MessageProp(0, true);
+ byte[] bytes;
+ p1 = new MessageProp(0, true);
+ System.out.printf("getMic from %s: ", me.name);
+ if (usingStream) {
+ ByteArrayOutputStream os = new ByteArrayOutputStream();
+ me.x.getMIC(new ByteArrayInputStream(input), os, p1);
+ bytes = os.toByteArray();
+ } else {
+ bytes = me.x.getMIC(input, 0, input.length, p1);
+ }
+ System.out.println(printProp(p1));
+ return bytes;
+ }
+ }, t);
+ }
+
+ public void verifyMic(byte[] t, final byte[] msg) throws Exception {
+ doAs(new Action() {
+ @Override
+ public byte[] run(Context me, byte[] input) throws Exception {
+ MessageProp p1 = new MessageProp(0, true);
+ System.out.printf("verifyMic from %s: ", me.name);
+ if (usingStream) {
+ me.x.verifyMIC(new ByteArrayInputStream(input),
+ new ByteArrayInputStream(msg), p1);
+ } else {
+ me.x.verifyMIC(input, 0, input.length,
+ msg, 0, msg.length,
+ p1);
+ }
+ System.out.println(printProp(p1));
+ return null;
+ }
+ }, t);
+ }
+
/**
* Transmits a message from one Context to another. The sender wraps the
* message and sends it to the receiver. The receiver unwraps it, creates
@@ -390,73 +473,13 @@
final byte[] messageBytes = message.getBytes();
System.out.printf("-------------------- TRANSMIT from %s to %s------------------------\n",
s1.name, s2.name);
-
- byte[] t = s1.doAs(new Action() {
- @Override
- public byte[] run(Context me, byte[] dummy) throws Exception {
- System.out.println("wrap");
- MessageProp p1 = new MessageProp(0, true);
- byte[] out;
- if (usingStream) {
- ByteArrayOutputStream os = new ByteArrayOutputStream();
- me.x.wrap(new ByteArrayInputStream(messageBytes), os, p1);
- out = os.toByteArray();
- } else {
- out = me.x.wrap(messageBytes, 0, messageBytes.length, p1);
- }
- System.out.println(printProp(p1));
- return out;
- }
- }, null);
-
- t = s2.doAs(new Action() {
- @Override
- public byte[] run(Context me, byte[] input) throws Exception {
- MessageProp p1 = new MessageProp(0, true);
- byte[] bytes;
- if (usingStream) {
- ByteArrayOutputStream os = new ByteArrayOutputStream();
- me.x.unwrap(new ByteArrayInputStream(input), os, p1);
- bytes = os.toByteArray();
- } else {
- bytes = me.x.unwrap(input, 0, input.length, p1);
- }
- if (!Arrays.equals(messageBytes, bytes))
- throw new Exception("wrap/unwrap mismatch");
- System.out.println("unwrap");
- System.out.println(printProp(p1));
- p1 = new MessageProp(0, true);
- System.out.println("getMIC");
- if (usingStream) {
- ByteArrayOutputStream os = new ByteArrayOutputStream();
- me.x.getMIC(new ByteArrayInputStream(messageBytes), os, p1);
- bytes = os.toByteArray();
- } else {
- bytes = me.x.getMIC(messageBytes, 0, messageBytes.length, p1);
- }
- System.out.println(printProp(p1));
- return bytes;
- }
- }, t);
-
- // Re-unwrap should make p2.isDuplicateToken() returns true
- s1.doAs(new Action() {
- @Override
- public byte[] run(Context me, byte[] input) throws Exception {
- MessageProp p1 = new MessageProp(0, true);
- System.out.println("verifyMIC");
- if (usingStream) {
- me.x.verifyMIC(new ByteArrayInputStream(input),
- new ByteArrayInputStream(messageBytes), p1);
- } else {
- me.x.verifyMIC(input, 0, input.length,
- messageBytes, 0, messageBytes.length,
- p1);
- }
- System.out.println(printProp(p1));
- return null;
- }
- }, t);
+ byte[] wrapped = s1.wrap(messageBytes, true);
+ byte[] unwrapped = s2.unwrap(wrapped, true);
+ if (!Arrays.equals(messageBytes, unwrapped)) {
+ throw new Exception("wrap/unwrap mismatch");
+ }
+ byte[] mic = s2.getMic(unwrapped);
+ s1.verifyMic(mic, messageBytes);
}
/**
diff --git a/jdk/test/sun/security/krb5/auto/NoInitNoKeytab.java b/jdk/test/sun/security/krb5/auto/NoInitNoKeytab.java
new file mode 100644
index 0000000..cde2ec6
--- /dev/null
+++ b/jdk/test/sun/security/krb5/auto/NoInitNoKeytab.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * @test
+ * @bug 7089889
+ * @summary Krb5LoginModule.login() throws an exception if used without a keytab
+ * @compile -XDignore.symbol.file NoInitNoKeytab.java
+ * @run main/othervm NoInitNoKeytab
+ */
+
+import java.io.FileOutputStream;
+import sun.security.jgss.GSSUtil;
+
+// The basic krb5 test skeleton you can copy from
+public class NoInitNoKeytab {
+
+ public static void main(String[] args) throws Exception {
+
+ new OneKDC(null).writeJAASConf();
+ try (FileOutputStream fos =
+ new FileOutputStream(OneKDC.JAAS_CONF, true)) {
+ fos.write((
+ "noinit {\n" +
+ " com.sun.security.auth.module.Krb5LoginModule required\n" +
+ " principal=\"" + OneKDC.USER + "\"\n" +
+ " useKeyTab=false\n" +
+ " isInitiator=false\n" +
+ " storeKey=true;\n};\n").getBytes());
+ }
+ Context c, s;
+ c = Context.fromJAAS("client");
+ s = Context.fromJAAS("noinit");
+
+ c.startAsClient(OneKDC.USER, GSSUtil.GSS_SPNEGO_MECH_OID);
+ s.startAsServer(GSSUtil.GSS_SPNEGO_MECH_OID);
+
+ Context.handshake(c, s);
+
+ Context.transmit("i say high --", c, s);
+ Context.transmit(" you say low", s, c);
+
+ s.dispose();
+ c.dispose();
+ }
+}
diff --git a/jdk/test/sun/security/krb5/auto/RRC.java b/jdk/test/sun/security/krb5/auto/RRC.java
new file mode 100644
index 0000000..ade12a4
--- /dev/null
+++ b/jdk/test/sun/security/krb5/auto/RRC.java
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * @test
+ * @bug 7077640
+ * @summary gss wrap for cfx doesn't handle rrc != 0
+ * @compile -XDignore.symbol.file RRC.java
+ * @run main/othervm RRC
+ */
+
+import java.util.Arrays;
+import sun.security.jgss.GSSUtil;
+
+// The basic krb5 test skeleton you can copy from
+public class RRC {
+
+ public static void main(String[] args) throws Exception {
+
+ new OneKDC(null).writeJAASConf();
+
+ Context c, s;
+ c = Context.fromJAAS("client");
+ s = Context.fromJAAS("server");
+
+ c.startAsClient(OneKDC.SERVER, GSSUtil.GSS_SPNEGO_MECH_OID);
+ s.startAsServer(GSSUtil.GSS_SPNEGO_MECH_OID);
+
+ Context.handshake(c, s);
+
+ byte[] msg = "i say high --".getBytes();
+ byte[] wrapped = c.wrap(msg, false);
+
+ // Simulate RRC equals to EC
+ int rrc = wrapped[5];
+ byte[] rotated = new byte[wrapped.length];
+ System.arraycopy(wrapped, 0, rotated, 0, 16);
+ System.arraycopy(wrapped, wrapped.length-rrc, rotated, 16, rrc);
+ System.arraycopy(wrapped, 16, rotated, 16+rrc, wrapped.length-16-rrc);
+ rotated[7] = (byte)rrc;
+
+ byte[] unwrapped = s.unwrap(rotated, false);
+ if (!Arrays.equals(msg, unwrapped)) {
+ throw new Exception("Failure");
+ }
+
+ s.dispose();
+ c.dispose();
+ }
+}