CNDB-9697: notify JVMStabilityInspector when encountered corruption exception on compaction task (#1901)

jasonstack · web-flow · commit b3d7c34ab8e7 · 2025-08-29T12:41:17.000+08:00
### What is the issue
Corruption excetion from compaction task didn't notify error handler.

Compaction aborted/failed metrics were not updated in some cases.

### What does this PR fix and why was it fixed

Trigger JVMStabilityInspector for corruption exception from compaction
task and update aborted/failed metircs properly.

Trigger JVMStabilityInspecto for error from repair validation.
diff --git a/src/java/org/apache/cassandra/db/compaction/BackgroundCompactionRunner.java b/src/java/org/apache/cassandra/db/compaction/BackgroundCompactionRunner.java
@@ -47,7 +47,10 @@
 import org.apache.cassandra.io.FSDiskFullWriteError;
 import org.apache.cassandra.io.FSError;
 import org.apache.cassandra.io.FSWriteError;
+import org.apache.cassandra.io.compress.CorruptBlockException;
+import org.apache.cassandra.io.sstable.CorruptSSTableException;
 import org.apache.cassandra.io.sstable.format.SSTableReader;
+import org.apache.cassandra.io.util.CorruptFileException;
 import org.apache.cassandra.utils.FBUtilities;
 import org.apache.cassandra.utils.JVMStabilityInspector;
 import org.apache.cassandra.utils.Throwables;
@@ -460,6 +463,7 @@ public static void handleCompactionError(Throwable t, ColumnFamilyStore cfs)
             // we might have to rely on error message parsing...
             t = t instanceof FSError ? t : new FSWriteError(t);
             JVMStabilityInspector.inspectThrowable(t);
+            CompactionManager.instance.incrementFailed();
         }
         // No-Space-Left IO exception is thrown by JDK when disk has reached its capacity. The key difference between this
         // and the earlier case with `FSDiskFullWriteError` is that here we have definitively run out of disk space, and
@@ -471,15 +475,26 @@ else if (Throwables.isCausedBy(t, IOException.class) && t.toString().contains(NO
             // wrap it with FSWriteError so that JVMStabilityInspector can properly stop or die
             t = t instanceof FSError ? t : new FSWriteError(t);
             JVMStabilityInspector.inspectThrowable(t);
+            CompactionManager.instance.incrementFailed();
         }
         else if (Throwables.isCausedBy(t, OutOfMemoryError.class))
         {
             logger.error("Encountered out of memory error on {}", cfs, t);
             JVMStabilityInspector.inspectThrowable(t);
+            CompactionManager.instance.incrementFailed();
+        }
+        else if (Throwables.anyCauseMatches(t, err -> err instanceof CorruptBlockException
+                                                      || err instanceof CorruptFileException
+                                                      || err instanceof CorruptSSTableException))
+        {
+            logger.error("Encountered corruption exception on {}", cfs, t);
+            JVMStabilityInspector.inspectThrowable(t);
+            CompactionManager.instance.incrementFailed();
         }
         else if (t instanceof CompactionInterruptedException)
         {
             logger.warn(String.format("Aborting background compaction of %s due to interruption", cfs), Throwables.unwrapped(t));
+            CompactionManager.instance.incrementAborted();
         }
         else
         {
diff --git a/src/java/org/apache/cassandra/io/FSDiskFullWriteError.java b/src/java/org/apache/cassandra/io/FSDiskFullWriteError.java
@@ -22,11 +22,20 @@
 
 public class FSDiskFullWriteError extends FSWriteError
 {
+    private final String keyspace;
+
     public FSDiskFullWriteError(String keyspace, long mutationSize)
     {
         super(new IOException(String.format("Insufficient disk space to write %d bytes into the %s keyspace",
                                             mutationSize,
                                             keyspace)));
+
+        this.keyspace = keyspace;
+    }
+
+    public String getKeyspace()
+    {
+        return keyspace;
     }
 
     @Override
diff --git a/src/java/org/apache/cassandra/io/FSNoDiskAvailableForWriteError.java b/src/java/org/apache/cassandra/io/FSNoDiskAvailableForWriteError.java
@@ -25,10 +25,19 @@
  */
 public class FSNoDiskAvailableForWriteError extends FSWriteError
 {
+    private final String keyspace;
+
     public FSNoDiskAvailableForWriteError(String keyspace)
     {
         super(new IOException(String.format("The data directories for the %s keyspace have been marked as unwritable",
                                             keyspace)));
+
+        this.keyspace = keyspace;
+    }
+
+    public String getKeyspace()
+    {
+        return keyspace;
     }
 
     @Override
diff --git a/src/java/org/apache/cassandra/io/compress/CompressedSequentialWriter.java b/src/java/org/apache/cassandra/io/compress/CompressedSequentialWriter.java
@@ -300,7 +300,7 @@ private synchronized void doResetAndTruncate(DataPosition mark)
             }
             catch (IOException e)
             {
-                throw new CorruptBlockException(getFile().toString(), chunkOffset, chunkSize, e);
+                throw new CorruptBlockException(getFile(), chunkOffset, chunkSize, e);
             }
 
             CRC32 checksum = new CRC32();
@@ -313,15 +313,15 @@ private synchronized void doResetAndTruncate(DataPosition mark)
             int storedChecksum = crcCheckBuffer.getInt();
             int computedChecksum = (int) checksum.getValue();
             if (storedChecksum != computedChecksum)
-                throw new CorruptBlockException(getFile().toString(), chunkOffset, chunkSize, storedChecksum, computedChecksum);
+                throw new CorruptBlockException(getFile(), chunkOffset, chunkSize, storedChecksum, computedChecksum);
         }
         catch (CorruptBlockException e)
         {
             throw new CorruptSSTableException(e, getFile());
         }
         catch (EOFException e)
         {
-            throw new CorruptSSTableException(new CorruptBlockException(getFile().toString(), chunkOffset, chunkSize), getFile());
+            throw new CorruptSSTableException(new CorruptBlockException(getFile(), chunkOffset, chunkSize), getFile());
         }
         catch (IOException e)
         {
diff --git a/src/java/org/apache/cassandra/io/compress/CorruptBlockException.java b/src/java/org/apache/cassandra/io/compress/CorruptBlockException.java
@@ -19,37 +19,47 @@
 
 import java.io.IOException;
 
+import org.apache.cassandra.io.util.File;
+
 public class CorruptBlockException extends IOException
 {
-    public CorruptBlockException(String filePath, CompressionMetadata.Chunk chunk)
+    private final File file;
+
+    public CorruptBlockException(File file, CompressionMetadata.Chunk chunk)
     {
-        this(filePath, chunk, null);
+        this(file, chunk, null);
     }
 
-    public CorruptBlockException(String filePath, CompressionMetadata.Chunk chunk, Throwable cause)
+    public CorruptBlockException(File file, CompressionMetadata.Chunk chunk, Throwable cause)
     {
-        this(filePath, chunk.offset, chunk.length, cause);
+        this(file, chunk.offset, chunk.length, cause);
     }
 
-    public CorruptBlockException(String filePath, long offset, int length)
+    public CorruptBlockException(File file, long offset, int length)
     {
-        this(filePath, offset, length, null);
+        this(file, offset, length, null);
     }
 
-    public CorruptBlockException(String filePath, long offset, int length, Throwable cause)
+    public CorruptBlockException(File file, long offset, int length, Throwable cause)
     {
-        super(String.format("(%s): corruption detected, chunk at %d of length %d.", filePath, offset, length), cause);
+        super(String.format("(%s): corruption detected, chunk at %d of length %d.", file.toString(), offset, length), cause);
+        this.file = file;
     }
 
-    public CorruptBlockException(String filePath, CompressionMetadata.Chunk chunk, int storedChecksum, int calculatedChecksum)
+    public CorruptBlockException(File file, CompressionMetadata.Chunk chunk, int storedChecksum, int calculatedChecksum)
     {
-        this(filePath, chunk.offset, chunk.length, storedChecksum, calculatedChecksum);
+        this(file, chunk.offset, chunk.length, storedChecksum, calculatedChecksum);
     }
 
-    public CorruptBlockException(String filePath, long offset, int length, int storedChecksum, int calculatedChecksum)
+    public CorruptBlockException(File file, long offset, int length, int storedChecksum, int calculatedChecksum)
     {
         super(String.format("(%s): corruption detected, chunk at %d of length %d has mismatched checksums. Expected %d, but calculated %d",
-                            filePath, offset, length, storedChecksum, calculatedChecksum));
+                            file.toString(), offset, length, storedChecksum, calculatedChecksum));
+        this.file = file;
     }
 
+    public File getFile()
+    {
+        return file;
+    }
 }
diff --git a/src/java/org/apache/cassandra/io/compress/EncryptedSequentialWriter.java b/src/java/org/apache/cassandra/io/compress/EncryptedSequentialWriter.java
@@ -221,7 +221,7 @@ public synchronized void resetAndTruncate(DataPosition mark)
             encrypted.limit(CHUNK_SIZE);
 
             if (encrypted.getInt(CHUNK_SIZE - 4) != (int) checksum.getValue())
-                throw new CorruptBlockException(getFile().toString(), truncateChunk, CHUNK_SIZE);
+                throw new CorruptBlockException(getFile(), truncateChunk, CHUNK_SIZE);
 
             try
             {
@@ -233,7 +233,7 @@ public synchronized void resetAndTruncate(DataPosition mark)
             }
             catch (IOException e)
             {
-                throw new CorruptBlockException(getFile().toString(), truncateChunk, CHUNK_SIZE, e);
+                throw new CorruptBlockException(getFile(), truncateChunk, CHUNK_SIZE, e);
             }
         }
         catch (CorruptBlockException e)
@@ -242,7 +242,7 @@ public synchronized void resetAndTruncate(DataPosition mark)
         }
         catch (EOFException e)
         {
-            throw new CorruptSSTableException(new CorruptBlockException(getFile().toString(), truncateChunk, CHUNK_SIZE), getFile());
+            throw new CorruptSSTableException(new CorruptBlockException(getFile(), truncateChunk, CHUNK_SIZE), getFile());
         }
         catch (IOException e)
         {
diff --git a/src/java/org/apache/cassandra/io/sstable/CorruptSSTableException.java b/src/java/org/apache/cassandra/io/sstable/CorruptSSTableException.java
@@ -20,6 +20,7 @@
 import java.nio.file.Path;
 
 import org.apache.cassandra.io.util.File;
+import org.apache.cassandra.io.util.PathUtils;
 import org.apache.cassandra.utils.DseLegacy;
 
 public class CorruptSSTableException extends RuntimeException
@@ -34,7 +35,7 @@ public CorruptSSTableException(Throwable cause, File file)
 
     public CorruptSSTableException(Throwable cause, String path)
     {
-        this(cause, new File(path));
+        this(cause, new File(PathUtils.getPath(path)));
     }
 
     protected CorruptSSTableException(String msg, Throwable cause, File file)
@@ -48,5 +49,4 @@ public CorruptSSTableException(Throwable cause, Path path)
     {
         this(cause, new File(path));
     }
-
 }
diff --git a/src/java/org/apache/cassandra/io/util/ChecksummedRebufferer.java b/src/java/org/apache/cassandra/io/util/ChecksummedRebufferer.java
@@ -50,7 +50,7 @@ public BufferHolder rebuffer(long desiredPosition)
         }
         catch (IOException e)
         {
-            throw new CorruptFileException(e, channel().filePath());
+            throw new CorruptFileException(e, channel().getFile());
         }
 
         return this;
diff --git a/src/java/org/apache/cassandra/io/util/CompressedChunkReader.java b/src/java/org/apache/cassandra/io/util/CompressedChunkReader.java
@@ -140,7 +140,7 @@ public void readChunk(long position, ByteBuffer uncompressed)
                     {
                         compressed.limit(length);
                         if (channel.read(compressed, chunkOffset) != length)
-                            throw new CorruptBlockException(channel.filePath(), chunk);
+                            throw new CorruptBlockException(channel.getFile(), chunk);
 
                         if (shouldCheckCrc)
                         {
@@ -151,7 +151,7 @@ public void readChunk(long position, ByteBuffer uncompressed)
                             compressed.limit(length);
                             int storedChecksum = compressed.getInt();
                             if (storedChecksum != checksum)
-                                throw new CorruptBlockException(channel.filePath(), chunk, storedChecksum, checksum);
+                                throw new CorruptBlockException(channel.getFile(), chunk, storedChecksum, checksum);
                         }
 
                         compressed.position(0).limit(chunk.length);
@@ -171,7 +171,7 @@ public void readChunk(long position, ByteBuffer uncompressed)
                         }
                         catch (IOException e)
                         {
-                            throw new CorruptBlockException(channel.filePath(), chunk, e);
+                            throw new CorruptBlockException(channel.getFile(), chunk, e);
                         }
                     }
                     finally
@@ -183,7 +183,7 @@ public void readChunk(long position, ByteBuffer uncompressed)
                 {
                     uncompressed.position(0).limit(chunk.length);
                     if (channel.read(uncompressed, chunkOffset) != chunk.length)
-                        throw new CorruptBlockException(channel.filePath(), chunk);
+                        throw new CorruptBlockException(channel.getFile(), chunk);
                 }
                 uncompressed.flip();
             }
@@ -239,7 +239,7 @@ public void readChunk(long position, ByteBuffer uncompressed)
                         compressedChunk.limit(compressedChunk.capacity());
                         int storedChecksum = compressedChunk.getInt();
                         if (storedChecksum != checksum)
-                            throw new CorruptBlockException(channel.filePath(), chunk, storedChecksum, checksum);
+                            throw new CorruptBlockException(channel.getFile(), chunk, storedChecksum, checksum);
                     }
 
                     compressedChunk.position(chunkOffsetInSegment).limit(chunkOffsetInSegment + chunk.length);
@@ -257,7 +257,7 @@ public void readChunk(long position, ByteBuffer uncompressed)
                 }
                 catch (IOException e)
                 {
-                    throw new CorruptBlockException(channel.filePath(), chunk, e);
+                    throw new CorruptBlockException(channel.getFile(), chunk, e);
                 }
                 uncompressed.flip();
             }
diff --git a/src/java/org/apache/cassandra/io/util/CorruptFileException.java b/src/java/org/apache/cassandra/io/util/CorruptFileException.java
@@ -21,11 +21,16 @@
 @SuppressWarnings("serial")
 public class CorruptFileException extends RuntimeException
 {
-    public final String filePath;
+    public final File file;
 
-    public CorruptFileException(Exception cause, String filePath)
+    public CorruptFileException(Exception cause, File file)
     {
         super(cause);
-        this.filePath = filePath;
+        this.file = file;
+    }
+
+    public File getFile()
+    {
+        return file;
     }
 }
diff --git a/src/java/org/apache/cassandra/io/util/EncryptedChunkReader.java b/src/java/org/apache/cassandra/io/util/EncryptedChunkReader.java
@@ -114,7 +114,7 @@ protected ByteBuffer decrypt(ByteBuffer input, int start, ByteBuffer output, lon
             //Change the limit to include the checksum
             input.limit(start + CHUNK_SIZE);
             if (input.getInt() != checksum)
-                throw new CorruptBlockException(channel.filePath(), position, CHUNK_SIZE);
+                throw new CorruptBlockException(channel.getFile(), position, CHUNK_SIZE);
         }
 
         int length = input.getInt(start + CHUNK_SIZE - FOOTER_LENGTH);
diff --git a/src/java/org/apache/cassandra/repair/ValidationManager.java b/src/java/org/apache/cassandra/repair/ValidationManager.java
@@ -38,6 +38,7 @@
 import org.apache.cassandra.metrics.CompactionMetrics;
 import org.apache.cassandra.metrics.TableMetrics;
 import org.apache.cassandra.utils.FBUtilities;
+import org.apache.cassandra.utils.JVMStabilityInspector;
 import org.apache.cassandra.utils.MerkleTree;
 import org.apache.cassandra.utils.MerkleTrees;
 import org.apache.cassandra.utils.NonThrowingCloseable;
@@ -176,6 +177,7 @@ public Object call() throws IOException
                     // we need to inform the remote end of our failure, otherwise it will hang on repair forever
                     validator.fail();
                     logger.error("Validation failed.", e);
+                    JVMStabilityInspector.inspectThrowable(e);
                     throw e;
                 }
                 return this;
diff --git a/src/java/org/apache/cassandra/utils/JVMStabilityInspector.java b/src/java/org/apache/cassandra/utils/JVMStabilityInspector.java
@@ -87,6 +87,16 @@ public static void setCommitLogErrorHandler(Function<String, Consumer<Throwable>
         commitLogHandler = errorHandler;
     }
 
+    public static Consumer<Throwable> getGlobalErrorHandler()
+    {
+        return globalHandler;
+    }
+
+    public static Consumer<Throwable> getDiskErrorHandler()
+    {
+        return diskHandler;
+    }
+
     /**
      * Certain Throwables and Exceptions represent "Die" conditions for the server.
      * This recursively checks the input Throwable's cause hierarchy until null.
diff --git a/test/unit/org/apache/cassandra/db/compaction/BackgroundCompactionRunnerTest.java b/test/unit/org/apache/cassandra/db/compaction/BackgroundCompactionRunnerTest.java

Original file line number	Diff line number	Diff line change
`@@ -22,11 +22,20 @@`
`22`	`22`
`23`	`23`	`public class FSDiskFullWriteError extends FSWriteError`
`24`	`24`	`{`
	`25`	`+ private final String keyspace;`
	`26`	`+`
`25`	`27`	`public FSDiskFullWriteError(String keyspace, long mutationSize)`
`26`	`28`	`{`
`27`	`29`	`super(new IOException(String.format("Insufficient disk space to write %d bytes into the %s keyspace",`
`28`	`30`	`mutationSize,`
`29`	`31`	`keyspace)));`
	`32`	`+`
	`33`	`+ this.keyspace = keyspace;`
	`34`	`+ }`
	`35`	`+`
	`36`	`+ public String getKeyspace()`
	`37`	`+ {`
	`38`	`+ return keyspace;`
`30`	`39`	`}`
`31`	`40`
`32`	`41`	`@Override`
Original file line number	Diff line number	Diff line change
`@@ -25,10 +25,19 @@`
`25`	`25`	`*/`
`26`	`26`	`public class FSNoDiskAvailableForWriteError extends FSWriteError`
`27`	`27`	`{`
	`28`	`+ private final String keyspace;`
	`29`	`+`
`28`	`30`	`public FSNoDiskAvailableForWriteError(String keyspace)`
`29`	`31`	`{`
`30`	`32`	`super(new IOException(String.format("The data directories for the %s keyspace have been marked as unwritable",`
`31`	`33`	`keyspace)));`
	`34`	`+`
	`35`	`+ this.keyspace = keyspace;`
	`36`	`+ }`
	`37`	`+`
	`38`	`+ public String getKeyspace()`
	`39`	`+ {`
	`40`	`+ return keyspace;`
`32`	`41`	`}`
`33`	`42`
`34`	`43`	`@Override`
Original file line number	Diff line number	Diff line change
`@@ -300,7 +300,7 @@ private synchronized void doResetAndTruncate(DataPosition mark)`
`300`	`300`	`}`
`301`	`301`	`catch (IOException e)`
`302`	`302`	`{`
`303`		`- throw new CorruptBlockException(getFile().toString(), chunkOffset, chunkSize, e);`
	`303`	`+ throw new CorruptBlockException(getFile(), chunkOffset, chunkSize, e);`
`304`	`304`	`}`
`305`	`305`
`306`	`306`	`CRC32 checksum = new CRC32();`
`@@ -313,15 +313,15 @@ private synchronized void doResetAndTruncate(DataPosition mark)`
`313`	`313`	`int storedChecksum = crcCheckBuffer.getInt();`
`314`	`314`	`int computedChecksum = (int) checksum.getValue();`
`315`	`315`	`if (storedChecksum != computedChecksum)`
`316`		`- throw new CorruptBlockException(getFile().toString(), chunkOffset, chunkSize, storedChecksum, computedChecksum);`
	`316`	`+ throw new CorruptBlockException(getFile(), chunkOffset, chunkSize, storedChecksum, computedChecksum);`
`317`	`317`	`}`
`318`	`318`	`catch (CorruptBlockException e)`
`319`	`319`	`{`
`320`	`320`	`throw new CorruptSSTableException(e, getFile());`
`321`	`321`	`}`
`322`	`322`	`catch (EOFException e)`
`323`	`323`	`{`
`324`		`- throw new CorruptSSTableException(new CorruptBlockException(getFile().toString(), chunkOffset, chunkSize), getFile());`
	`324`	`+ throw new CorruptSSTableException(new CorruptBlockException(getFile(), chunkOffset, chunkSize), getFile());`
`325`	`325`	`}`
`326`	`326`	`catch (IOException e)`
`327`	`327`	`{`
Original file line number	Diff line number	Diff line change
`@@ -19,37 +19,47 @@`
`19`	`19`
`20`	`20`	`import java.io.IOException;`
`21`	`21`
	`22`	`+import org.apache.cassandra.io.util.File;`
	`23`	`+`
`22`	`24`	`public class CorruptBlockException extends IOException`
`23`	`25`	`{`
`24`		`- public CorruptBlockException(String filePath, CompressionMetadata.Chunk chunk)`
	`26`	`+ private final File file;`
	`27`	`+`
	`28`	`+ public CorruptBlockException(File file, CompressionMetadata.Chunk chunk)`
`25`	`29`	`{`
`26`		`- this(filePath, chunk, null);`
	`30`	`+ this(file, chunk, null);`
`27`	`31`	`}`
`28`	`32`
`29`		`- public CorruptBlockException(String filePath, CompressionMetadata.Chunk chunk, Throwable cause)`
	`33`	`+ public CorruptBlockException(File file, CompressionMetadata.Chunk chunk, Throwable cause)`
`30`	`34`	`{`
`31`		`- this(filePath, chunk.offset, chunk.length, cause);`
	`35`	`+ this(file, chunk.offset, chunk.length, cause);`
`32`	`36`	`}`
`33`	`37`
`34`		`- public CorruptBlockException(String filePath, long offset, int length)`
	`38`	`+ public CorruptBlockException(File file, long offset, int length)`
`35`	`39`	`{`
`36`		`- this(filePath, offset, length, null);`
	`40`	`+ this(file, offset, length, null);`
`37`	`41`	`}`
`38`	`42`
`39`		`- public CorruptBlockException(String filePath, long offset, int length, Throwable cause)`
	`43`	`+ public CorruptBlockException(File file, long offset, int length, Throwable cause)`
`40`	`44`	`{`
`41`		`- super(String.format("(%s): corruption detected, chunk at %d of length %d.", filePath, offset, length), cause);`
	`45`	`+ super(String.format("(%s): corruption detected, chunk at %d of length %d.", file.toString(), offset, length), cause);`
	`46`	`+ this.file = file;`
`42`	`47`	`}`
`43`	`48`
`44`		`- public CorruptBlockException(String filePath, CompressionMetadata.Chunk chunk, int storedChecksum, int calculatedChecksum)`
	`49`	`+ public CorruptBlockException(File file, CompressionMetadata.Chunk chunk, int storedChecksum, int calculatedChecksum)`
`45`	`50`	`{`
`46`		`- this(filePath, chunk.offset, chunk.length, storedChecksum, calculatedChecksum);`
	`51`	`+ this(file, chunk.offset, chunk.length, storedChecksum, calculatedChecksum);`
`47`	`52`	`}`
`48`	`53`
`49`		`- public CorruptBlockException(String filePath, long offset, int length, int storedChecksum, int calculatedChecksum)`
	`54`	`+ public CorruptBlockException(File file, long offset, int length, int storedChecksum, int calculatedChecksum)`
`50`	`55`	`{`
`51`	`56`	`super(String.format("(%s): corruption detected, chunk at %d of length %d has mismatched checksums. Expected %d, but calculated %d",`
`52`		`- filePath, offset, length, storedChecksum, calculatedChecksum));`
	`57`	`+ file.toString(), offset, length, storedChecksum, calculatedChecksum));`
	`58`	`+ this.file = file;`
`53`	`59`	`}`
`54`	`60`
	`61`	`+ public File getFile()`
	`62`	`+ {`
	`63`	`+ return file;`
	`64`	`+ }`
`55`	`65`	`}`
Original file line number	Diff line number	Diff line change
`@@ -221,7 +221,7 @@ public synchronized void resetAndTruncate(DataPosition mark)`
`221`	`221`	`encrypted.limit(CHUNK_SIZE);`
`222`	`222`
`223`	`223`	`if (encrypted.getInt(CHUNK_SIZE - 4) != (int) checksum.getValue())`
`224`		`- throw new CorruptBlockException(getFile().toString(), truncateChunk, CHUNK_SIZE);`
	`224`	`+ throw new CorruptBlockException(getFile(), truncateChunk, CHUNK_SIZE);`
`225`	`225`
`226`	`226`	`try`
`227`	`227`	`{`
`@@ -233,7 +233,7 @@ public synchronized void resetAndTruncate(DataPosition mark)`
`233`	`233`	`}`
`234`	`234`	`catch (IOException e)`
`235`	`235`	`{`
`236`		`- throw new CorruptBlockException(getFile().toString(), truncateChunk, CHUNK_SIZE, e);`
	`236`	`+ throw new CorruptBlockException(getFile(), truncateChunk, CHUNK_SIZE, e);`
`237`	`237`	`}`
`238`	`238`	`}`
`239`	`239`	`catch (CorruptBlockException e)`
`@@ -242,7 +242,7 @@ public synchronized void resetAndTruncate(DataPosition mark)`
`242`	`242`	`}`
`243`	`243`	`catch (EOFException e)`
`244`	`244`	`{`
`245`		`- throw new CorruptSSTableException(new CorruptBlockException(getFile().toString(), truncateChunk, CHUNK_SIZE), getFile());`
	`245`	`+ throw new CorruptSSTableException(new CorruptBlockException(getFile(), truncateChunk, CHUNK_SIZE), getFile());`
`246`	`246`	`}`
`247`	`247`	`catch (IOException e)`
`248`	`248`	`{`
Original file line number	Diff line number	Diff line change
`@@ -20,6 +20,7 @@`
`20`	`20`	`import java.nio.file.Path;`
`21`	`21`
`22`	`22`	`import org.apache.cassandra.io.util.File;`
	`23`	`+import org.apache.cassandra.io.util.PathUtils;`
`23`	`24`	`import org.apache.cassandra.utils.DseLegacy;`
`24`	`25`
`25`	`26`	`public class CorruptSSTableException extends RuntimeException`
`@@ -34,7 +35,7 @@ public CorruptSSTableException(Throwable cause, File file)`
`34`	`35`
`35`	`36`	`public CorruptSSTableException(Throwable cause, String path)`
`36`	`37`	`{`
`37`		`- this(cause, new File(path));`
	`38`	`+ this(cause, new File(PathUtils.getPath(path)));`
`38`	`39`	`}`
`39`	`40`
`40`	`41`	`protected CorruptSSTableException(String msg, Throwable cause, File file)`
`@@ -48,5 +49,4 @@ public CorruptSSTableException(Throwable cause, Path path)`
`48`	`49`	`{`
`49`	`50`	`this(cause, new File(path));`
`50`	`51`	`}`
`51`		`-`
`52`	`52`	`}`
Original file line number	Diff line number	Diff line change
`@@ -50,7 +50,7 @@ public BufferHolder rebuffer(long desiredPosition)`
`50`	`50`	`}`
`51`	`51`	`catch (IOException e)`
`52`	`52`	`{`
`53`		`- throw new CorruptFileException(e, channel().filePath());`
	`53`	`+ throw new CorruptFileException(e, channel().getFile());`
`54`	`54`	`}`
`55`	`55`
`56`	`56`	`return this;`
Original file line number	Diff line number	Diff line change
`@@ -140,7 +140,7 @@ public void readChunk(long position, ByteBuffer uncompressed)`
`140`	`140`	`{`
`141`	`141`	`compressed.limit(length);`
`142`	`142`	`if (channel.read(compressed, chunkOffset) != length)`
`143`		`- throw new CorruptBlockException(channel.filePath(), chunk);`
	`143`	`+ throw new CorruptBlockException(channel.getFile(), chunk);`
`144`	`144`
`145`	`145`	`if (shouldCheckCrc)`
`146`	`146`	`{`
`@@ -151,7 +151,7 @@ public void readChunk(long position, ByteBuffer uncompressed)`
`151`	`151`	`compressed.limit(length);`
`152`	`152`	`int storedChecksum = compressed.getInt();`
`153`	`153`	`if (storedChecksum != checksum)`
`154`		`- throw new CorruptBlockException(channel.filePath(), chunk, storedChecksum, checksum);`
	`154`	`+ throw new CorruptBlockException(channel.getFile(), chunk, storedChecksum, checksum);`
`155`	`155`	`}`
`156`	`156`
`157`	`157`	`compressed.position(0).limit(chunk.length);`
`@@ -171,7 +171,7 @@ public void readChunk(long position, ByteBuffer uncompressed)`
`171`	`171`	`}`
`172`	`172`	`catch (IOException e)`
`173`	`173`	`{`
`174`		`- throw new CorruptBlockException(channel.filePath(), chunk, e);`
	`174`	`+ throw new CorruptBlockException(channel.getFile(), chunk, e);`
`175`	`175`	`}`
`176`	`176`	`}`
`177`	`177`	`finally`
`@@ -183,7 +183,7 @@ public void readChunk(long position, ByteBuffer uncompressed)`
`183`	`183`	`{`
`184`	`184`	`uncompressed.position(0).limit(chunk.length);`
`185`	`185`	`if (channel.read(uncompressed, chunkOffset) != chunk.length)`
`186`		`- throw new CorruptBlockException(channel.filePath(), chunk);`
	`186`	`+ throw new CorruptBlockException(channel.getFile(), chunk);`
`187`	`187`	`}`
`188`	`188`	`uncompressed.flip();`
`189`	`189`	`}`
`@@ -239,7 +239,7 @@ public void readChunk(long position, ByteBuffer uncompressed)`
`239`	`239`	`compressedChunk.limit(compressedChunk.capacity());`
`240`	`240`	`int storedChecksum = compressedChunk.getInt();`
`241`	`241`	`if (storedChecksum != checksum)`
`242`		`- throw new CorruptBlockException(channel.filePath(), chunk, storedChecksum, checksum);`
	`242`	`+ throw new CorruptBlockException(channel.getFile(), chunk, storedChecksum, checksum);`
`243`	`243`	`}`
`244`	`244`
`245`	`245`	`compressedChunk.position(chunkOffsetInSegment).limit(chunkOffsetInSegment + chunk.length);`
`@@ -257,7 +257,7 @@ public void readChunk(long position, ByteBuffer uncompressed)`
`257`	`257`	`}`
`258`	`258`	`catch (IOException e)`
`259`	`259`	`{`
`260`		`- throw new CorruptBlockException(channel.filePath(), chunk, e);`
	`260`	`+ throw new CorruptBlockException(channel.getFile(), chunk, e);`
`261`	`261`	`}`
`262`	`262`	`uncompressed.flip();`
`263`	`263`	`}`
Original file line number	Diff line number	Diff line change
`@@ -21,11 +21,16 @@`
`21`	`21`	`@SuppressWarnings("serial")`
`22`	`22`	`public class CorruptFileException extends RuntimeException`
`23`	`23`	`{`
`24`		`- public final String filePath;`
	`24`	`+ public final File file;`
`25`	`25`
`26`		`- public CorruptFileException(Exception cause, String filePath)`
	`26`	`+ public CorruptFileException(Exception cause, File file)`
`27`	`27`	`{`
`28`	`28`	`super(cause);`
`29`		`- this.filePath = filePath;`
	`29`	`+ this.file = file;`
	`30`	`+ }`
	`31`	`+`
	`32`	`+ public File getFile()`
	`33`	`+ {`
	`34`	`+ return file;`
`30`	`35`	`}`
`31`	`36`	`}`