Page MenuHomeFreeBSD
Files F136040564

D11722.id31150.diff
No OneTemporary
Actions

D11722.id31150.diff
View Options

Index: sys/amd64/amd64/minidump_machdep.c
===================================================================
--- sys/amd64/amd64/minidump_machdep.c
+++ sys/amd64/amd64/minidump_machdep.c
@@ -56,7 +56,6 @@
int vm_page_dump_size;
static struct kerneldumpheader kdh;
-static off_t dumplo;
/* Handle chunked writes. */
static size_t fragsz;
@@ -93,8 +92,7 @@
if (fragsz == 0)
return (0);
- error = dump_write(di, dump_va, 0, dumplo, fragsz);
- dumplo += fragsz;
+ error = dump_write(di, dump_va, 0, fragsz);
fragsz = 0;
return (error);
}
@@ -177,10 +175,9 @@
wdog_kern_pat(WD_LASTVAL);
if (ptr) {
- error = dump_write(di, ptr, 0, dumplo, len);
+ error = dump_write(di, ptr, 0, len);
if (error)
return (error);
- dumplo += len;
ptr += len;
sz -= len;
} else {
@@ -333,7 +330,7 @@
printf("Dumping %llu out of %ju MB:", (long long)dumpsize >> 20,
ptoa((uintmax_t)physmem) / 1048576);
- error = dump_start(di, &kdh, &dumplo);
+ error = dump_start(di, &kdh);
if (error != 0)
goto fail;
@@ -419,7 +416,7 @@
if (error)
goto fail;
- error = dump_finish(di, &kdh, dumplo);
+ error = dump_finish(di, &kdh);
if (error != 0)
goto fail;
Index: sys/arm/arm/minidump_machdep.c
===================================================================
--- sys/arm/arm/minidump_machdep.c
+++ sys/arm/arm/minidump_machdep.c
@@ -58,8 +58,6 @@
static struct kerneldumpheader kdh;
-static off_t dumplo;
-
/* Handle chunked writes. */
static size_t fragsz;
static void *dump_va;
@@ -89,8 +87,7 @@
if (fragsz == 0)
return (0);
- error = dump_write(di, dump_va, 0, dumplo, fragsz);
- dumplo += fragsz;
+ error = dump_write(di, dump_va, 0, fragsz);
fragsz = 0;
return (error);
}
@@ -141,10 +138,9 @@
wdog_kern_pat(WD_LASTVAL);
#endif
if (ptr) {
- error = dump_write(di, ptr, 0, dumplo, len);
+ error = dump_write(di, ptr, 0, len);
if (error)
return (error);
- dumplo += len;
ptr += len;
sz -= len;
} else {
@@ -251,7 +247,7 @@
printf("Physical memory: %u MB\n", ptoa((uintmax_t)physmem) / 1048576);
printf("Dumping %llu MB:", (long long)dumpsize >> 20);
- error = dump_start(di, &kdh, &dumplo);
+ error = dump_start(di, &kdh);
if (error != 0)
goto fail;
@@ -329,7 +325,7 @@
if (error)
goto fail;
- error = dump_finish(di, &kdh, dumplo);
+ error = dump_finish(di, &kdh);
if (error != 0)
goto fail;
Index: sys/arm64/arm64/minidump_machdep.c
===================================================================
--- sys/arm64/arm64/minidump_machdep.c
+++ sys/arm64/arm64/minidump_machdep.c
@@ -62,7 +62,6 @@
int vm_page_dump_size;
static struct kerneldumpheader kdh;
-static off_t dumplo;
/* Handle chunked writes. */
static size_t fragsz;
@@ -96,8 +95,7 @@
if (fragsz == 0)
return (0);
- error = dump_write(di, dump_va, 0, dumplo, fragsz);
- dumplo += fragsz;
+ error = dump_write(di, dump_va, 0, fragsz);
fragsz = 0;
return (error);
}
@@ -183,10 +181,9 @@
wdog_kern_pat(WD_LASTVAL);
if (ptr) {
- error = dump_write(di, ptr, 0, dumplo, len);
+ error = dump_write(di, ptr, 0, len);
if (error)
return (error);
- dumplo += len;
ptr += len;
sz -= len;
} else {
@@ -295,7 +292,7 @@
printf("Dumping %llu out of %ju MB:", (long long)dumpsize >> 20,
ptoa((uintmax_t)physmem) / 1048576);
- error = dump_start(di, &kdh, &dumplo);
+ error = dump_start(di, &kdh);
if (error != 0)
goto fail;
@@ -395,7 +392,7 @@
if (error)
goto fail;
- error = dump_finish(di, &kdh, dumplo);
+ error = dump_finish(di, &kdh);
if (error != 0)
goto fail;
Index: sys/ddb/db_textdump.c
===================================================================
--- sys/ddb/db_textdump.c
+++ sys/ddb/db_textdump.c
@@ -245,7 +245,7 @@
return (EIO);
if (offset < SIZEOF_METADATA)
return (ENOSPC);
- textdump_error = dump_write(di, buffer, 0, offset + di->mediaoffset,
+ textdump_error = dump_raw_write(di, buffer, 0, offset + di->mediaoffset,
TEXTDUMP_BLOCKSIZE);
if (textdump_error)
printf("textdump_writeblock: offset %jd, error %d\n", (intmax_t)offset,
@@ -499,7 +499,7 @@
* Terminate the dump, report any errors, and clear the pending flag.
*/
if (textdump_error == 0)
- (void)dump_write(di, NULL, 0, 0, 0);
+ (void)dump_raw_write(di, NULL, 0, 0, 0);
if (textdump_error == ENOSPC)
printf("Textdump: Insufficient space on dump partition\n");
else if (textdump_error != 0)
Index: sys/geom/raid/g_raid.c
===================================================================
--- sys/geom/raid/g_raid.c
+++ sys/geom/raid/g_raid.c
@@ -1419,7 +1419,7 @@
return (ENXIO);
if (sd->sd_disk->d_kd.di.dumper == NULL)
return (EOPNOTSUPP);
- return (dump_write(&sd->sd_disk->d_kd.di,
+ return (dump_raw_write(&sd->sd_disk->d_kd.di,
virtual, physical,
sd->sd_disk->d_kd.di.mediaoffset + sd->sd_offset + offset,
length));
Index: sys/i386/i386/minidump_machdep.c
===================================================================
--- sys/i386/i386/minidump_machdep.c
+++ sys/i386/i386/minidump_machdep.c
@@ -54,7 +54,6 @@
int vm_page_dump_size;
static struct kerneldumpheader kdh;
-static off_t dumplo;
/* Handle chunked writes. */
static size_t fragsz;
@@ -86,8 +85,7 @@
if (fragsz == 0)
return (0);
- error = dump_write(di, dump_va, 0, dumplo, fragsz);
- dumplo += fragsz;
+ error = dump_write(di, dump_va, 0, fragsz);
fragsz = 0;
return (error);
}
@@ -135,10 +133,9 @@
wdog_kern_pat(WD_LASTVAL);
if (ptr) {
- error = dump_write(di, ptr, 0, dumplo, len);
+ error = dump_write(di, ptr, 0, len);
if (error)
return (error);
- dumplo += len;
ptr += len;
sz -= len;
} else {
@@ -258,7 +255,7 @@
printf("Physical memory: %ju MB\n", ptoa((uintmax_t)physmem) / 1048576);
printf("Dumping %llu MB:", (long long)dumpsize >> 20);
- error = dump_start(di, &kdh, &dumplo);
+ error = dump_start(di, &kdh);
if (error != 0)
goto fail;
@@ -334,7 +331,7 @@
if (error)
goto fail;
- error = dump_finish(di, &kdh, dumplo);
+ error = dump_finish(di, &kdh);
if (error != 0)
goto fail;
Index: sys/kern/kern_dump.c
===================================================================
--- sys/kern/kern_dump.c
+++ sys/kern/kern_dump.c
@@ -51,8 +51,6 @@
#define MD_ALIGN(x) roundup2((off_t)(x), PAGE_SIZE)
-off_t dumplo;
-
/* Handle buffered writes. */
static size_t fragsz;
@@ -122,11 +120,9 @@
while (sz > 0) {
nbytes = MIN(sz, sizeof(buf));
- error = dump_write(di, buf, 0, dumplo, nbytes);
+ error = dump_write(di, buf, 0, nbytes);
if (error)
return (error);
- dumplo += nbytes;
-
sz -= nbytes;
}
@@ -148,11 +144,9 @@
ptr += len;
sz -= len;
if (fragsz == di->blocksize) {
- error = dump_write(di, di->blockbuf, 0, dumplo,
- di->blocksize);
+ error = dump_write(di, di->blockbuf, 0, di->blocksize);
if (error)
return (error);
- dumplo += di->blocksize;
fragsz = 0;
}
}
@@ -167,8 +161,7 @@
if (fragsz == 0)
return (0);
- error = dump_write(di, di->blockbuf, 0, dumplo, di->blocksize);
- dumplo += di->blocksize;
+ error = dump_write(di, di->blockbuf, 0, di->blocksize);
fragsz = 0;
return (error);
}
@@ -216,11 +209,10 @@
wdog_kern_pat(WD_LASTVAL);
#endif
- error = dump_write(di, va, 0, dumplo, sz);
+ error = dump_write(di, va, 0, sz);
dumpsys_unmap_chunk(pa, chunk, va);
if (error)
break;
- dumplo += sz;
pgs -= chunk;
pa += sz;
@@ -347,7 +339,7 @@
printf("Dumping %ju MB (%d chunks)\n", (uintmax_t)dumpsize >> 20,
ehdr.e_phnum - DUMPSYS_NUM_AUX_HDRS);
- error = dump_start(di, &kdh, &dumplo);
+ error = dump_start(di, &kdh);
if (error != 0)
goto fail;
@@ -369,19 +361,18 @@
* All headers are written using blocked I/O, so we know the
* current offset is (still) block aligned. Skip the alignement
* in the file to have the segment contents aligned at page
- * boundary. We cannot use MD_ALIGN on dumplo, because we don't
- * care and may very well be unaligned within the dump device.
+ * boundary.
*/
error = dumpsys_buf_seek(di, (size_t)hdrgap);
if (error)
goto fail;
- /* Dump memory chunks (updates dumplo) */
+ /* Dump memory chunks. */
error = dumpsys_foreach_chunk(dumpsys_cb_dumpdata, di);
if (error < 0)
goto fail;
- error = dump_finish(di, &kdh, dumplo);
+ error = dump_finish(di, &kdh);
if (error != 0)
goto fail;
Index: sys/kern/kern_shutdown.c
===================================================================
--- sys/kern/kern_shutdown.c
+++ sys/kern/kern_shutdown.c
@@ -157,7 +157,6 @@
uint8_t kdc_iv[KERNELDUMP_IV_MAX_SIZE];
keyInstance kdc_ki;
cipherInstance kdc_ci;
- off_t kdc_nextoffset;
uint32_t kdc_dumpkeysize;
struct kerneldumpkey kdc_dumpkey[];
};
@@ -172,6 +171,7 @@
int dumping; /* system is dumping */
int rebooting; /* system is rebooting */
static struct dumperinfo dumper; /* our selected dumper */
+static off_t dumpoff; /* current dump offset */
/* Context information for dump-debuggers. */
static struct pcb dumppcb; /* Registers. */
@@ -931,8 +931,6 @@
goto out;
}
- kdc->kdc_nextoffset = 0;
-
kdk = kdc->kdc_dumpkey;
memcpy(kdk->kdk_iv, kdc->kdc_iv, sizeof(kdk->kdk_iv));
out:
@@ -1024,24 +1022,20 @@
(uintmax_t)length, (intmax_t)di->mediasize);
return (ENOSPC);
}
+ if (length % di->blocksize != 0) {
+ printf("Attempt to write partial block of length %ju.\n",
+ (uintmax_t)length);
+ return (EINVAL);
+ }
+ if (offset % di->blocksize != 0) {
+ printf("Attempt to write at unaligned offset %jd.\n",
+ (intmax_t)offset);
+ return (EINVAL);
+ }
return (0);
}
-/* Call dumper with bounds checking. */
-static int
-dump_raw_write(struct dumperinfo *di, void *virtual, vm_offset_t physical,
- off_t offset, size_t length)
-{
- int error;
-
- error = dump_check_bounds(di, offset, length);
- if (error != 0)
- return (error);
-
- return (di->dumper(di->priv, virtual, physical, offset, length));
-}
-
#ifdef EKCD
static int
dump_encrypt(struct kerneldumpcrypto *kdc, uint8_t *buf, size_t size)
@@ -1074,33 +1068,9 @@
struct kerneldumpcrypto *kdc;
int error;
size_t nbytes;
- off_t nextoffset;
kdc = di->kdc;
- error = dump_check_bounds(di, offset, length);
- if (error != 0)
- return (error);
-
- /* Signal completion. */
- if (virtual == NULL && physical == 0 && offset == 0 && length == 0) {
- return (di->dumper(di->priv, virtual, physical, offset,
- length));
- }
-
- /* Data have to be aligned to block size. */
- if ((length % di->blocksize) != 0)
- return (EINVAL);
-
- /*
- * Data have to be written continuously becase we're encrypting using
- * CBC mode which has this assumption.
- */
- if (kdc->kdc_nextoffset != 0 && kdc->kdc_nextoffset != offset)
- return (EINVAL);
-
- nextoffset = offset + (off_t)length;
-
while (length > 0) {
nbytes = MIN(length, sizeof(buf));
bcopy(virtual, buf, nbytes);
@@ -1108,7 +1078,7 @@
if (dump_encrypt(kdc, buf, nbytes) != 0)
return (EIO);
- error = di->dumper(di->priv, buf, physical, offset, nbytes);
+ error = dump_raw_write(di, buf, physical, offset, nbytes);
if (error != 0)
return (error);
@@ -1117,8 +1087,6 @@
length -= nbytes;
}
- kdc->kdc_nextoffset = nextoffset;
-
return (0);
}
@@ -1136,21 +1104,6 @@
}
#endif /* EKCD */
-int
-dump_write(struct dumperinfo *di, void *virtual, vm_offset_t physical,
- off_t offset, size_t length)
-{
-
-#ifdef EKCD
- if (di->kdc != NULL) {
- return (dump_encrypted_write(di, virtual, physical, offset,
- length));
- }
-#endif
-
- return (dump_raw_write(di, virtual, physical, offset, length));
-}
-
static int
dump_write_header(struct dumperinfo *di, struct kerneldumpheader *kdh,
vm_offset_t physical, off_t offset)
@@ -1185,7 +1138,7 @@
* key.
*/
int
-dump_start(struct dumperinfo *di, struct kerneldumpheader *kdh, off_t *dumplop)
+dump_start(struct dumperinfo *di, struct kerneldumpheader *kdh)
{
uint64_t dumpsize;
uint32_t keysize;
@@ -1204,18 +1157,18 @@
if (di->mediasize < SIZEOF_METADATA + dumpsize)
return (ENOSPC);
- *dumplop = di->mediaoffset + di->mediasize - dumpsize;
+ dumpoff = di->mediaoffset + di->mediasize - dumpsize;
- error = dump_write_header(di, kdh, 0, *dumplop);
+ error = dump_write_header(di, kdh, 0, dumpoff);
if (error != 0)
return (error);
- *dumplop += di->blocksize;
+ dumpoff += di->blocksize;
#ifdef EKCD
- error = dump_write_key(di, 0, *dumplop);
+ error = dump_write_key(di, 0, dumpoff);
if (error != 0)
return (error);
- *dumplop += keysize;
+ dumpoff += keysize;
#endif
return (0);
@@ -1226,15 +1179,46 @@
* dump has completed.
*/
int
-dump_finish(struct dumperinfo *di, struct kerneldumpheader *kdh, off_t dumplo)
+dump_write(struct dumperinfo *di, void *virtual, vm_offset_t physical,
+ size_t length)
+{
+ int error;
+
+#ifdef EKCD
+ if (di->kdc != NULL)
+ error = dump_encrypted_write(di, virtual, physical, dumpoff,
+ length);
+ else
+#endif
+ error = dump_raw_write(di, virtual, physical, dumpoff, length);
+ if (error == 0)
+ dumpoff += length;
+ return (error);
+}
+
+int
+dump_raw_write(struct dumperinfo *di, void *virtual, vm_offset_t physical,
+ off_t offset, size_t length)
+{
+ int error;
+
+ error = dump_check_bounds(di, offset, length);
+ if (error != 0)
+ return (error);
+
+ return (di->dumper(di->priv, virtual, physical, offset, length));
+}
+
+int
+dump_finish(struct dumperinfo *di, struct kerneldumpheader *kdh)
{
int error;
- error = dump_write_header(di, kdh, 0, dumplo);
+ error = dump_write_header(di, kdh, 0, dumpoff);
if (error != 0)
return (error);
- (void)dump_write(di, NULL, 0, 0, 0);
+ (void)dump_raw_write(di, NULL, 0, 0, 0);
return (0);
}
Index: sys/mips/mips/minidump_machdep.c
===================================================================
--- sys/mips/mips/minidump_machdep.c
+++ sys/mips/mips/minidump_machdep.c
@@ -56,7 +56,6 @@
int vm_page_dump_size;
static struct kerneldumpheader kdh;
-static off_t dumplo;
/* Handle chunked writes. */
static uint64_t counter, progress, dumpsize;
@@ -166,10 +165,9 @@
wdog_kern_pat(WD_LASTVAL);
if (ptr) {
- error = dump_write(di, ptr, 0, dumplo, len);
+ error = dump_write(di, ptr, 0, len);
if (error)
return (error);
- dumplo += len;
ptr += len;
sz -= len;
} else {
@@ -267,7 +265,7 @@
printf("Dumping %llu out of %ju MB:", (long long)dumpsize >> 20,
ptoa((uintmax_t)physmem) / 1048576);
- error = dump_start(di, &kdh, &dumplo);
+ error = dump_start(di, &kdh);
if (error != 0)
goto fail;
@@ -335,7 +333,7 @@
}
}
- error = dump_finish(di, &kdh, dumplo);
+ error = dump_finish(di, &kdh);
if (error != 0)
goto fail;
Index: sys/sparc64/sparc64/dump_machdep.c
===================================================================
--- sys/sparc64/sparc64/dump_machdep.c
+++ sys/sparc64/sparc64/dump_machdep.c
@@ -49,7 +49,6 @@
static off_t fileofs;
-extern off_t dumplo;
extern struct dump_pa dump_map[DUMPSYS_MD_PA_NPAIRS];
int do_minidump = 0;
@@ -99,7 +98,7 @@
printf("Dumping %lu MB (%d chunks)\n", (u_long)(size >> 20), nreg);
- error = dump_start(di, &kdh, &dumplo);
+ error = dump_start(di, &kdh);
if (error != 0)
goto fail;
@@ -128,7 +127,7 @@
if (error < 0)
goto fail;
- error = dump_finish(di, &kdh, dumplo);
+ error = dump_finish(di, &kdh);
if (error != 0)
goto fail;
Index: sys/sys/conf.h
===================================================================
--- sys/sys/conf.h
+++ sys/sys/conf.h
@@ -342,11 +342,10 @@
int set_dumper(struct dumperinfo *di, const char *devname, struct thread *td,
uint8_t encrypt, const uint8_t *key, uint32_t encryptedkeysize,
const uint8_t *encryptedkey);
-int dump_start(struct dumperinfo *di, struct kerneldumpheader *kdh,
- off_t *dumplop);
-int dump_finish(struct dumperinfo *di, struct kerneldumpheader *kdh,
- off_t dumplo);
-int dump_write(struct dumperinfo *, void *, vm_offset_t, off_t, size_t);
+int dump_start(struct dumperinfo *di, struct kerneldumpheader *kdh);
+int dump_finish(struct dumperinfo *di, struct kerneldumpheader *kdh);
+int dump_write(struct dumperinfo *, void *, vm_offset_t, size_t);
+int dump_raw_write(struct dumperinfo *, void *, vm_offset_t, off_t, size_t);
int doadump(boolean_t);
extern int dumping; /* system is dumping */

File Metadata

Mime Type
text/plain
Expires
Sun, Nov 16, 8:13 AM (55 m, 58 s)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
25358870
Default Alt Text
D11722.id31150.diff (16 KB)

Event Timeline