OpenSource/PaperMC
OpenSource/PaperMC
1
0
Fork 0
mirror of https://github.com/PaperMC/Paper.git synced 2024-12-30 16:19:03 +01:00
Code Issues Projects Releases Packages Wiki Activity

Identify corrupt region file data and self recover

Browse source 
If we identify an invalid offset (negative, or the header sectors),
then back up the region file and erase that specific chunks offset
data.

This will avoid crashing the server with AIOBB errors and also avoids
server owners having to consider the entire region file 'lost'.

I'm not sure what leads to this state, I can only assume write cut
off mid bits.

In this scenario, there is absolutely no way to know where the chunk
actually is in the data file without loading every
single chunk in the file. And even to do that, would be quite extreme
due to the fact the file isn't in some orderly fashion.

Since the file is backed up, the user can use a region fixer tool
externally to try to restore that single chunk. We could even
add a command to restore a chunk from a backup file in a different
commit later on. But this at least prevents the server from crashing.

The server will just generate a new chunk and move on,
after printing an error to the console about it.

Also fixed the case reported in this issue about the server
hanging when a corrupt chunk is encountered, so this issue
is now fully closed.

Resolves #1541
This commit is contained in:
Aikar 2018-10-10 21:28:12 -04:00
parent 7f7b6df9bd
commit ed0d75e389
2 changed files with 99 additions and 18 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
Spigot-Server-Patches/Async-Chunk-Loading-and-Generation.patch
View file

@ -904,7 +904,7 @@ index 98d182fdb8..487d98eb1b 100644
diff --git a/src/main/java/net/minecraft/server/PaperAsyncChunkProvider.java b/src/main/java/net/minecraft/server/PaperAsyncChunkProvider.java
new file mode 100644
index 0000000000..dabc4184e5
index 0000000000..2dfa59b204
--- /dev/null
+++ b/src/main/java/net/minecraft/server/PaperAsyncChunkProvider.java
@@ -0,0 +0,0 @@
@ -1420,8 +1420,8 @@ index 0000000000..dabc4184e5
+ }
+ } catch (Exception ex) {
+ MinecraftServer.LOGGER.error("Couldn't load chunk (" +world.getWorld().getName() + ":" + x + "," + z + ")", ex);
+ if (!(ex instanceof IOException)) {
+ loadFinished(null);
+ if (ex instanceof IOException) {
+ generateFinished(null);
+ return;
+ }
+ }

111
Spigot-Server-Patches/Detect-and-repair-corrupt-Region-Files.patch
View file

@ -11,29 +11,110 @@ I don't know why mojang only checks for 4096, when anything less than 8192 is a
But to be safe, it will attempt to back up the file.
diff --git a/src/main/java/net/minecraft/server/RegionFile.java b/src/main/java/net/minecraft/server/RegionFile.java
index 5d2853b9ce..c35974aa7c 100644
index 5d2853b9ce..5c0d4f912a 100644
--- a/src/main/java/net/minecraft/server/RegionFile.java
+++ b/src/main/java/net/minecraft/server/RegionFile.java
@@ -0,0 +0,0 @@ import javax.annotation.Nullable;
public class RegionFile {
private static final byte[] a = new byte[4096];
- private final File b;
- private RandomAccessFile c;
- private final int[] d = new int[1024];
- private final int[] e = new int[1024];
+ private final File b;private File getFile() { return b; } // Paper - OBFHELPER
+ private RandomAccessFile c;private RandomAccessFile getDataFile() { return c; } // Paper - OBFHELPER
+ private final int[] d = new int[1024];private int[] offsets = d; // Paper - OBFHELPER
+ private final int[] e = new int[1024];private int[] timestamps = e; // Paper - OBFHELPER
private List<Boolean> f;
private int g;
private long h;
@@ -0,0 +0,0 @@ public class RegionFile {
}
this.c = new RandomAccessFile(file1, "rw");
- if (this.c.length() < 4096L) {
+ // Paper start - detect and fix incomplete headers
+ long length = this.c.length();
+ if (length < 8192 && length > 0) {
+ File corrupt = new File(file1.getParentFile(), file1.getName() + ".bak");
+ org.apache.logging.log4j.Logger logger = org.apache.logging.log4j.LogManager.getLogger();
+ logger.error("Region file " + file1 + " was incomplete. Backing up to " + corrupt + " and repairing");
+ try {
+ java.nio.file.Files.copy(file1.toPath(), corrupt.toPath());
+ } catch (IOException e) {
+ logger.error("Error backing up corrupt file", e);
+ }
+ }
+ if (length < 8192L) {
+ // Paper end
+ if (this.c.length() < 8192L) { // Paper - headers should be 8192
this.c.write(a);
this.c.write(a);
this.g += 8192;
@@ -0,0 +0,0 @@ public class RegionFile {
for(int j1 = 0; j1 < 1024; ++j1) {
int k = headerAsInts.get(); // Paper
this.d[j1] = k;
- if (k != 0 && (k >> 8) + (k & 255) <= this.f.size()) {
+ if (k > 0 && (k >> 8) > 1 && (k >> 8) + (k & 255) <= this.f.size()) { // Paper >= 1 as 0/1 are the headers, and negative isnt valid
for(int l = 0; l < (k & 255); ++l) {
this.f.set((k >> 8) + l, false);
}
- }
+ } else if (k != 0) deleteChunk(j1); // Paper
}
for(int k1 = 0; k1 < 1024; ++k1) {
int l1 = headerAsInts.get(); // Paper
- this.e[k1] = l1;
+ if (offsets[k1] != 0) this.timestamps[k1] = l1; // Paper - don't set timestamp if it got 0'd above due to corruption
}
} catch (IOException ioexception) {
ioexception.printStackTrace();
@@ -0,0 +0,0 @@ public class RegionFile {
}
+ // Paper start
+ public void deleteChunk(int x, int z) {
+ deleteChunk(x + z * 32);
+ }
+ public synchronized void deleteChunk(int j1) {
+ backup();
+ int k = offsets[j1];
+ int x = j1 & 1024;
+ int z = j1 >> 2;
+ int offset = (k >> 8);
+ int len = (k & 255);
+ org.apache.logging.log4j.Logger logger = org.apache.logging.log4j.LogManager.getLogger();
+ String debug = "idx:" + + j1 + " - " + x + "," + z + " - offset: " + offset + " - len: " + len;
+ try {
+ RandomAccessFile file = getDataFile();
+ file.seek(j1 * 4);
+ file.writeInt(0);
+ // clear the timestamp
+ file.seek(4096 + j1 * 4);
+ file.writeInt(0);
+ timestamps[j1] = 0;
+ offsets[j1] = 0;
+ logger.error("Deleted corrupt chunk (" + debug + ") " + getFile().getAbsolutePath(), e);
+ } catch (IOException e) {
+
+ logger.error("Error deleting corrupt chunk (" + debug + ") " + getFile().getAbsolutePath(), e);
+ }
+ }
+ private boolean backedUp = false;
+ private synchronized void backup() {
+ if (backedUp) {
+ return;
+ }
+ backedUp = true;
+ File file = this.getFile();
+ java.text.DateFormat formatter = new java.text.SimpleDateFormat("yyyy-MM-dd");
+ java.util.Date today = new java.util.Date();
+ File corrupt = new File(file.getParentFile(), file.getName() + "." + formatter.format(today) + ".corrupt");
+ if (corrupt.exists()) {
+ return;
+ }
+ org.apache.logging.log4j.Logger logger = org.apache.logging.log4j.LogManager.getLogger();
+ logger.error("Region file " + file.getAbsolutePath() + " was corrupt. Backing up to " + corrupt.getAbsolutePath() + " and repairing");
+ try {
+ java.nio.file.Files.copy(file.toPath(), corrupt.toPath());
+
+ } catch (IOException e) {
+ logger.error("Error backing up corrupt file" + file.getAbsolutePath(), e);
+ }
+ }
+ // Paper end
+
class ChunkBuffer extends ByteArrayOutputStream {
private final int b;
private final int c;
--