Expose File in disk full exception and corruption exception

jasonstack · jasonstack · commit f9bfcf9b1498 · 2025-08-11T10:56:39.000+08:00
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/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);

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
`@@ -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`	`}`
Original file line number	Diff line number	Diff line change
`@@ -114,7 +114,7 @@ protected ByteBuffer decrypt(ByteBuffer input, int start, ByteBuffer output, lon`
`114`	`114`	`//Change the limit to include the checksum`
`115`	`115`	`input.limit(start + CHUNK_SIZE);`
`116`	`116`	`if (input.getInt() != checksum)`
`117`		`- throw new CorruptBlockException(channel.filePath(), position, CHUNK_SIZE);`
	`117`	`+ throw new CorruptBlockException(channel.getFile(), position, CHUNK_SIZE);`
`118`	`118`	`}`
`119`	`119`
`120`	`120`	`int length = input.getInt(start + CHUNK_SIZE - FOOTER_LENGTH);`