[OpenWrt-Devel] [PATCH] Use ram overlay when restoring sysupgrade.tgz
Sean Miller
seanmichaelmiller2014 at gmail.com
Mon Apr 6 23:41:02 EDT 2020
Dear John Crispin and Felix Fietkau,
*Description:* During the first boot following a sysupgrade, if the
rootfs_data
partition has not been formatted, the intended behavior is to mount a
temporary ram overlay filesystem, deferring the cleaning and formatting
of the rootfs_data partition and the switch to the jffs2 overlay until
later in the init sequence. If a sysupgrade call preserves a config across
the update (via sysupgrade.tgz), the jffs2 overlay is always immediately
mounted, regardless of whether or not the rootfs_data partition has
been formatted.
Launching the jffs2 overlay when the rootfs_data partition has not been
formatted blocks preinit_main for the duration of the formatting. This can
be fatal, especially on systems with large rootfs_data partitions.
Even on machines that can survive the preinit hang, the intermediate ram
overlay should be launched for consistency across boots.
This bug also causes the jffs2 driver to not clean up the first blocks
of rootfs_data used to store sysupgrade.tgz, leaving those blocks
to be cleaned before use during userspace run time.
*package name:* package/system/fstools
--- a/libfstools/volume.c
+++ b/libfstools/volume.c
@@ -12,11 +12,17 @@
*/
#include <sys/mount.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include “libfstools.h”
#include “volume.h”
+#include “crc32.h”
+
+#define CRC_BUF_LEN 4096
static LIST_HEAD(drivers);
@@ -41,3 +47,96 @@ struct volume* volume_find(char *name)
return NULL;
}
+
+/*
+ * if we are using a jffs2 rootfs_data partition,
+ * parse sysupgrade.tgz from rootfs_data, and move it
+ * to the newly mounted RAM read-write root
+ */
+int volume_read_tar_rootfs_data(const char* tar_destination)
+{
+ int destination_fd;
+ char *read_buf;
+ char *crc_buf;
+ unsigned int bytes_crc = 0;
+ unsigned int bytes_read = 0;
+ unsigned int bytes_written = 0;
+ unsigned int total_bytes_read = 0;
+ unsigned int rootfs_data_ofs = 0;
+ __u32 tar_page_marker;
+ __u32 calculated_crc;
+ struct tar_file_header header;
+ struct volume *rootfs_data = volume_find(“rootfs_data”);
+
+ volume_init(rootfs_data);
+ volume_read(rootfs_data, &header, 0, sizeof(header));
+
+ rootfs_data_ofs = sizeof(header);
+ if(header.tar_file_marker == 0xadddf111){
+ read_buf = malloc(rootfs_data->block_size);
+ if(read_buf){
+ destination_fd = open(tar_destination, O_RDWR | O_CREAT,
S_IRWXG);
+ if(destination_fd >= 0){
+ if(header.tar_file_size >= rootfs_data->block_size -
sizeof(header)){
+ volume_read(rootfs_data, read_buf, rootfs_data_ofs,
rootfs_data->block_size - sizeof(header));
+ bytes_read = rootfs_data->block_size - sizeof(header);
+ }
+ else{
+ volume_read(rootfs_data, read_buf, rootfs_data_ofs,
header.tar_file_size);
+ bytes_read = header.tar_file_size;
+ }
+ total_bytes_read += bytes_read;
+ rootfs_data_ofs += bytes_read;
+ bytes_written = write(destination_fd, read_buf, bytes_read);
+ while(bytes_written != header.tar_file_size &&
rootfs_data_ofs < rootfs_data->size){
+ volume_read(rootfs_data, &tar_page_marker,
rootfs_data_ofs, sizeof(tar_page_marker));
+ rootfs_data_ofs += sizeof(tar_page_marker);
+ if(tar_page_marker == 0xadddf111){
+ if(header.tar_file_size >= total_bytes_read +
rootfs_data->block_size - sizeof(tar_page_marker)){
+ volume_read(rootfs_data, read_buf,
rootfs_data_ofs, rootfs_data->block_size - sizeof(header));
+ bytes_read = rootfs_data->block_size -
sizeof(header);
+ }
+ else{
+ volume_read(rootfs_data, read_buf,
rootfs_data_ofs, header.tar_file_size - total_bytes_read -
sizeof(tar_page_marker));
+ bytes_read = header.tar_file_size -
total_bytes_read - sizeof(tar_page_marker);
+ }
+ total_bytes_read += bytes_read;
+ rootfs_data_ofs += bytes_read;
+ bytes_written += write(destination_fd, read_buf,
bytes_read);
+ }
+ else{
+ /* bad block, skip it */
+ rootfs_data_ofs += rootfs_data->block_size -
sizeof(tar_page_marker);
+ }
+ }
+ free(read_buf);
+ read_buf = NULL;
+
+ /* crc check */
+ if(bytes_written){
+ lseek(destination_fd, 0, SEEK_SET);
+ crc_buf = malloc(CRC_BUF_LEN);
+ if(crc_buf){
+ bytes_crc = read(destination_fd, crc_buf,
CRC_BUF_LEN);
+ calculated_crc = crc32(0, crc_buf, bytes_crc);
+ while(bytes_crc){
+ bytes_crc = read(destination_fd, crc_buf,
CRC_BUF_LEN);
+ calculated_crc = crc32(calculated_crc, crc_buf,
bytes_crc);
+ }
+ free(crc_buf);
+ if(calculated_crc == header.tar_file_crc){
+ close(destination_fd);
+ return 0;
+ }
+ }
+ }
+ /* uh oh... something went wrong */
+ close(destination_fd);
+ remove(tar_destination);
+ }
+ if(read_buf)
+ free(read_buf);
+ }
+ }
+ return -1;
+}
--- a/libfstools/volume.h
+++ b/libfstools/volume.h
@@ -42,6 +42,13 @@ struct driver {
volume_erase_all_t erase_all;
};
+struct tar_file_header {
+ __u32 deadcode;
+ __u32 tar_file_marker;
+ __u32 tar_file_crc;
+ __u32 tar_file_size;
+};
+
enum {
UNKNOWN_TYPE,
NANDFLASH,
@@ -62,6 +69,7 @@ struct volume {
extern struct volume* volume_find(char *name);
extern void volume_register_driver(struct driver *drv);
+extern int volume_read_tar_rootfs_data(const char* tar_destination);
static inline int volume_init(struct volume *v)
{
--- a/libfstools/mount.c
+++ b/libfstools/mount.c
@@ -21,6 +21,7 @@
#include <string.h>
#include “libfstools.h”
+#include “volume.h”
/* this is a raw syscall - man 2 pivot_root */
extern int pivot_root(const char *new_root, const char *put_old);
@@ -152,8 +153,17 @@ fopivot(char *rw_root, char *ro_root)
int
ramoverlay(void)
{
- mkdir(“/tmp/root”, 0755);
- mount(“tmpfs”, “/tmp/root”, “tmpfs”, MS_NOATIME, “mode=0755”);
+ char rw_root[64] = “/tmp/root”;
+ char sysupgrade_dest[64];
- return fopivot(“/tmp/root”, “/rom”);
+ mkdir(rw_root, 0755);
+ mount(“tmpfs”, rw_root, “tmpfs”, MS_NOATIME, “mode=0755”);
+
+ snprintf(sysupgrade_dest, sizeof(sysupgrade_dest), “%s/sysupgrade.tgz”,
rw_root);
+ if(!volume_read_tar_rootfs_data(sysupgrade_dest))
+ ULOG_NOTE(“config retreived from rootfs_data\n”);
+ else
+ ULOG_NOTE(“no config retrieved from rootfs_data\n”);
+
+ return fopivot(rw_root, “/rom”);
}
--- /dev/null
+++ b/libfstools/crc32.h
@@ -0,0 +1,26 @@
+#ifndef CRC32_H
+#define CRC32_H
+
+#include <stdint.h>
+
+extern const uint32_t crc32_table[256];
+
+/* Return a 32-bit CRC of the contents of the buffer. */
+
+static inline uint32_t
+crc32(uint32_t val, const void *ss, int len)
+{
+ const unsigned char *s = ss;
+ while (--len >= 0)
+ val = crc32_table[(val ^ *s++) & 0xff] ^ (val >> 8);
+ return val;
+}
+
+static inline unsigned int crc32buf(char *buf, size_t len)
+{
+ return crc32(0xFFFFFFFF, buf, len);
+}
+
+
+
+#endif
--- /dev/null
+++ b/libfstools/crc32.c
@@ -0,0 +1,95 @@
+/*
+ * COPYRIGHT (C) 1986 Gary S. Brown. You may use this program, or
+ * code or tables extracted from it, as desired without restriction.
+ *
+ * First, the polynomial itself and its table of feedback terms. The
+ * polynomial is
+ * X^32+X^26+X^23+X^22+X^16+X^12+X^11+X^10+X^8+X^7+X^5+X^4+X^2+X^1+X^0
+ *
+ * Note that we take it “backwards” and put the highest-order term in
+ * the lowest-order bit. The X^32 term is “implied”; the LSB is the
+ * X^31 term, etc. The X^0 term (usually shown as “+1") results in
+ * the MSB being 1
+ *
+ * Note that the usual hardware shift register implementation, which
+ * is what we’re using (we’re merely optimizing it by doing eight-bit
+ * chunks at a time) shifts bits into the lowest-order term. In our
+ * implementation, that means shifting towards the right. Why do we
+ * do it this way? Because the calculated CRC must be transmitted in
+ * order from highest-order term to lowest-order term. UARTs transmit
+ * characters in order from LSB to MSB. By storing the CRC this way
+ * we hand it to the UART in the order low-byte to high-byte; the UART
+ * sends each low-bit to hight-bit; and the result is transmission bit
+ * by bit from highest- to lowest-order term without requiring any bit
+ * shuffling on our part. Reception works similarly
+ *
+ * The feedback terms table consists of 256, 32-bit entries. Notes
+ *
+ * The table can be generated at runtime if desired; code to do so
+ * is shown later. It might not be obvious, but the feedback
+ * terms simply represent the results of eight shift/xor opera
+ * tions for all combinations of data and CRC register values
+ *
+ * The values must be right-shifted by eight bits by the “updcrc
+ * logic; the shift must be unsigned (bring in zeroes). On some
+ * hardware you could probably optimize the shift in assembler by
+ * using byte-swap instructions
+ * polynomial $edb88320
+ */
+
+#include <stdint.h>
+
+const uint32_t crc32_table[256] = {
+ 0x00000000L, 0x77073096L, 0xee0e612cL, 0x990951baL, 0x076dc419L,
+ 0x706af48fL, 0xe963a535L, 0x9e6495a3L, 0x0edb8832L, 0x79dcb8a4L,
+ 0xe0d5e91eL, 0x97d2d988L, 0x09b64c2bL, 0x7eb17cbdL, 0xe7b82d07L,
+ 0x90bf1d91L, 0x1db71064L, 0x6ab020f2L, 0xf3b97148L, 0x84be41deL,
+ 0x1adad47dL, 0x6ddde4ebL, 0xf4d4b551L, 0x83d385c7L, 0x136c9856L,
+ 0x646ba8c0L, 0xfd62f97aL, 0x8a65c9ecL, 0x14015c4fL, 0x63066cd9L,
+ 0xfa0f3d63L, 0x8d080df5L, 0x3b6e20c8L, 0x4c69105eL, 0xd56041e4L,
+ 0xa2677172L, 0x3c03e4d1L, 0x4b04d447L, 0xd20d85fdL, 0xa50ab56bL,
+ 0x35b5a8faL, 0x42b2986cL, 0xdbbbc9d6L, 0xacbcf940L, 0x32d86ce3L,
+ 0x45df5c75L, 0xdcd60dcfL, 0xabd13d59L, 0x26d930acL, 0x51de003aL,
+ 0xc8d75180L, 0xbfd06116L, 0x21b4f4b5L, 0x56b3c423L, 0xcfba9599L,
+ 0xb8bda50fL, 0x2802b89eL, 0x5f058808L, 0xc60cd9b2L, 0xb10be924L,
+ 0x2f6f7c87L, 0x58684c11L, 0xc1611dabL, 0xb6662d3dL, 0x76dc4190L,
+ 0x01db7106L, 0x98d220bcL, 0xefd5102aL, 0x71b18589L, 0x06b6b51fL,
+ 0x9fbfe4a5L, 0xe8b8d433L, 0x7807c9a2L, 0x0f00f934L, 0x9609a88eL,
+ 0xe10e9818L, 0x7f6a0dbbL, 0x086d3d2dL, 0x91646c97L, 0xe6635c01L,
+ 0x6b6b51f4L, 0x1c6c6162L, 0x856530d8L, 0xf262004eL, 0x6c0695edL,
+ 0x1b01a57bL, 0x8208f4c1L, 0xf50fc457L, 0x65b0d9c6L, 0x12b7e950L,
+ 0x8bbeb8eaL, 0xfcb9887cL, 0x62dd1ddfL, 0x15da2d49L, 0x8cd37cf3L,
+ 0xfbd44c65L, 0x4db26158L, 0x3ab551ceL, 0xa3bc0074L, 0xd4bb30e2L,
+ 0x4adfa541L, 0x3dd895d7L, 0xa4d1c46dL, 0xd3d6f4fbL, 0x4369e96aL,
+ 0x346ed9fcL, 0xad678846L, 0xda60b8d0L, 0x44042d73L, 0x33031de5L,
+ 0xaa0a4c5fL, 0xdd0d7cc9L, 0x5005713cL, 0x270241aaL, 0xbe0b1010L,
+ 0xc90c2086L, 0x5768b525L, 0x206f85b3L, 0xb966d409L, 0xce61e49fL,
+ 0x5edef90eL, 0x29d9c998L, 0xb0d09822L, 0xc7d7a8b4L, 0x59b33d17L,
+ 0x2eb40d81L, 0xb7bd5c3bL, 0xc0ba6cadL, 0xedb88320L, 0x9abfb3b6L,
+ 0x03b6e20cL, 0x74b1d29aL, 0xead54739L, 0x9dd277afL, 0x04db2615L,
+ 0x73dc1683L, 0xe3630b12L, 0x94643b84L, 0x0d6d6a3eL, 0x7a6a5aa8L,
+ 0xe40ecf0bL, 0x9309ff9dL, 0x0a00ae27L, 0x7d079eb1L, 0xf00f9344L,
+ 0x8708a3d2L, 0x1e01f268L, 0x6906c2feL, 0xf762575dL, 0x806567cbL,
+ 0x196c3671L, 0x6e6b06e7L, 0xfed41b76L, 0x89d32be0L, 0x10da7a5aL,
+ 0x67dd4accL, 0xf9b9df6fL, 0x8ebeeff9L, 0x17b7be43L, 0x60b08ed5L,
+ 0xd6d6a3e8L, 0xa1d1937eL, 0x38d8c2c4L, 0x4fdff252L, 0xd1bb67f1L,
+ 0xa6bc5767L, 0x3fb506ddL, 0x48b2364bL, 0xd80d2bdaL, 0xaf0a1b4cL,
+ 0x36034af6L, 0x41047a60L, 0xdf60efc3L, 0xa867df55L, 0x316e8eefL,
+ 0x4669be79L, 0xcb61b38cL, 0xbc66831aL, 0x256fd2a0L, 0x5268e236L,
+ 0xcc0c7795L, 0xbb0b4703L, 0x220216b9L, 0x5505262fL, 0xc5ba3bbeL,
+ 0xb2bd0b28L, 0x2bb45a92L, 0x5cb36a04L, 0xc2d7ffa7L, 0xb5d0cf31L,
+ 0x2cd99e8bL, 0x5bdeae1dL, 0x9b64c2b0L, 0xec63f226L, 0x756aa39cL,
+ 0x026d930aL, 0x9c0906a9L, 0xeb0e363fL, 0x72076785L, 0x05005713L,
+ 0x95bf4a82L, 0xe2b87a14L, 0x7bb12baeL, 0x0cb61b38L, 0x92d28e9bL,
+ 0xe5d5be0dL, 0x7cdcefb7L, 0x0bdbdf21L, 0x86d3d2d4L, 0xf1d4e242L,
+ 0x68ddb3f8L, 0x1fda836eL, 0x81be16cdL, 0xf6b9265bL, 0x6fb077e1L,
+ 0x18b74777L, 0x88085ae6L, 0xff0f6a70L, 0x66063bcaL, 0x11010b5cL,
+ 0x8f659effL, 0xf862ae69L, 0x616bffd3L, 0x166ccf45L, 0xa00ae278L,
+ 0xd70dd2eeL, 0x4e048354L, 0x3903b3c2L, 0xa7672661L, 0xd06016f7L,
+ 0x4969474dL, 0x3e6e77dbL, 0xaed16a4aL, 0xd9d65adcL, 0x40df0b66L,
+ 0x37d83bf0L, 0xa9bcae53L, 0xdebb9ec5L, 0x47b2cf7fL, 0x30b5ffe9L,
+ 0xbdbdf21cL, 0xcabac28aL, 0x53b39330L, 0x24b4a3a6L, 0xbad03605L,
+ 0xcdd70693L, 0x54de5729L, 0x23d967bfL, 0xb3667a2eL, 0xc4614ab8L,
+ 0x5d681b02L, 0x2a6f2b94L, 0xb40bbe37L, 0xc30c8ea1L, 0x5a05df1bL,
+ 0x2d02ef8dL
+};
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -14,7 +14,8 @@ ADD_LIBRARY(fstools SHARED
libfstools/mount.c
libfstools/ubi.c
libfstools/rootdisk.c
- libfstools/find.c)
+ libfstools/find.c
+ libfstools/crc32.c)
TARGET_LINK_LIBRARIES(fstools ubox)
INSTALL(TARGETS fstools LIBRARY DESTINATION lib)
*package name:* package/system/mtd
--- a/jffs2.c
+++ b/jffs2.c
@@ -26,6 +26,7 @@
#include <dirent.h>
#include <unistd.h>
#include <endian.h>
+#include <limits.h>
#include “jffs2.h”
#include “crc32.h”
#include “mtd.h”
@@ -34,10 +35,14 @@
#if BYTE_ORDER == BIG_ENDIAN
# define CLEANMARKER “\x19\x85\x20\x03\x00\x00\x00\x0c\xf0\x60\xdc\x98"
+# define TARFILEMARKER “\xad\xdd\xf1\x11”
#else
# define CLEANMARKER “\x85\x19\x03\x20\x0c\x00\x00\x00\xb1\xb0\x1e\xe4"
+# define TARFILEMARKER “\x11\xf1\xdd\xad”
#endif
+#define CRC_BUF_LEN 4096
+
static int last_ino = 0;
static int last_version = 0;
static char *buf = NULL;
@@ -236,24 +241,120 @@ static void add_file(const char *name, i
close(fd);
}
-int mtd_replace_jffs2(const char *mtd, int fd, int ofs, const char
*filename)
+void add_tar_cleanup(int fd, int in_mtdofs)
{
- outfd = fd;
- mtdofs = ofs;
-
- buf = malloc(erasesize);
- target_ino = 1;
- if (!last_ino)
- last_ino = 1;
- add_file(filename, target_ino);
- pad(erasesize);
+ ofs = 0;
+ mtdofs = in_mtdofs;
- /* add eof marker, pad to eraseblock size and write the data */
+ /* If at any point we fail, erase the first block
+ * and replace the JFFS2_EOF. In mtd_add_tar_file_jffs2(),
+ * return a ‘skip’ of 1 erase block so that we jump over 0xdeadc0de. */
+ mtd_erase_block(fd, mtdofs);
add_data(JFFS2_EOF, sizeof(JFFS2_EOF) - 1);
pad(erasesize);
- free(buf);
+}
+
+int mtd_add_tar_file_jffs2(const char *mtd, int fd, int in_mtdofs, const
char *filename)
+{
+ outfd = fd;
+ mtdofs = in_mtdofs;
+ struct stat tar_file_st;
+ int tar_fd;
+ int bytes_crc = 0;
+ int bytes_read = 0;
+ int total_bytes_read = 0;
+ char* crc_buf;
+ uint32_t temp_file_size = 0;
+ uint32_t tar_crc = 0;
+ uint32_t mask = 0xffffffff;
+
+ /* If sysupgrade.tgz passed in,
+ * write 16-byte header followed by file contents.
+ * TARFILEMARKER will head each subsequent block
+ * needed to write the rest of the file. */
+ if (!stat(filename, &tar_file_st)){
+ tar_fd = open(filename, 0);
+ if (tar_fd < 0) {
+ fprintf(stderr, “File %s does not exist\n”, filename);
+ add_tar_cleanup(outfd, in_mtdofs);
+ return erasesize;
+ }
+
+ /* Calculate crc */
+ crc_buf = malloc(CRC_BUF_LEN);
+ if(!crc_buf){
+ fprintf(stderr, “Out of memory\n”);
+ add_tar_cleanup(outfd, in_mtdofs);
+ return erasesize;
+ }
+ bytes_crc = read(tar_fd, crc_buf, CRC_BUF_LEN);
+ tar_crc = crc32(0, crc_buf, bytes_crc);
+ while(bytes_crc)
+ {
+ bytes_crc = read(tar_fd, crc_buf, CRC_BUF_LEN);
+ tar_crc = crc32(tar_crc, crc_buf, bytes_crc);
+ }
+ free(crc_buf);
+ lseek(tar_fd, 0, SEEK_SET);
+ buf = malloc(erasesize);
+ if(!buf){
+ fprintf(stderr, “Out of memory\n”);
+ add_tar_cleanup(outfd, in_mtdofs);
+ return erasesize;
+ }
+ ofs = 0;
+
+ add_data(JFFS2_EOF, sizeof(JFFS2_EOF) - 1);
+ add_data(TARFILEMARKER, sizeof(TARFILEMARKER) - 1);
+
+ /* sizeof(off_t) can be 16 to 64 bytes.
+ * Set the cut off at 4 bytes unsigned */
+ if(tar_file_st.st_size >= 0 && tar_file_st.st_size <= UINT_MAX){
+ temp_file_size = tar_file_st.st_size & mask;
+ }
+ else{
+ fprintf(stderr, “Incoming tar file too large. Tar file size is
%lld, max size is %u”
+ , tar_file_st.st_size
+ , UINT_MAX
+ );
+ add_tar_cleanup(outfd, in_mtdofs);
+ free(buf);
+ close(tar_fd);
+ return erasesize;
+ }
+
+ add_data((char*)&tar_crc, sizeof(tar_crc));
+ add_data((char*)&temp_file_size, sizeof(mask));
+
+ total_bytes_read = read(tar_fd, buf + ofs,
+ erasesize - (sizeof(JFFS2_EOF) - 1 + sizeof(TARFILEMARKER) - 1
+ sizeof(erasesize) + 4));
+ ofs += total_bytes_read;
+ pad(erasesize);
+
+ while(total_bytes_read != temp_file_size && mtdofs < mtdsize)
+ {
+ ofs = 0;
+ add_data(TARFILEMARKER, sizeof(TARFILEMARKER) - 1);
+ bytes_read = read(tar_fd, buf + ofs, erasesize -
sizeof(TARFILEMARKER) - 1);
+ ofs += bytes_read;
+ pad(erasesize);
+ total_bytes_read += bytes_read;
+ }
+ if(total_bytes_read != tar_file_st.st_size){
+ fprintf(stderr, “Error reading from file %s\n”, filename);
+ add_tar_cleanup(outfd, in_mtdofs);
+ free(buf);
+ close(tar_fd);
+ return erasesize;
+ }
+ free(buf);
+ close(tar_fd);
+ ofs = 0;
+ return (mtdofs - in_mtdofs);
+ }
- return (mtdofs - ofs);
+ add_tar_cleanup(outfd, in_mtdofs);
+ return mtdofs - in_mtdofs;
}
void mtd_parse_jffs2data(const char *buf, const char *dir)
--- a/mtd.c
+++ b/mtd.c
@@ -468,7 +468,7 @@ mtd_write(int imagefd, const char *mtd,
ssize_t r, w, e;
ssize_t skip = 0;
uint32_t offset = 0;
- int jffs2_replaced = 0;
+ int jffs2_tar_file_added = 0;
int skip_bad_blocks = 0;
#ifdef FIS_SUPPORT
@@ -597,8 +597,8 @@ resume:
if (quiet < 2)
fprintf(stderr, “\nAppending jffs2 data from %s to
%s..\n.“, jffs2file, mtd);
/* got an EOF marker - this is the place to add some jffs2
data */
- skip = mtd_replace_jffs2(mtd, fd, e, jffs2file);
- jffs2_replaced = 1;
+ skip = mtd_add_tar_file_jffs2(mtd, fd, e, jffs2file);
+ jffs2_tar_file_added = 1;
/* don’t add it again */
jffs2file = NULL;
@@ -675,7 +675,7 @@ resume:
offset = 0;
}
- if (jffs2_replaced) {
+ if (jffs2_tar_file_added) {
switch (imageformat) {
case MTD_IMAGE_FORMAT_TRX:
if (trx_fixup)
--- a/mtd.h
+++ b/mtd.h
@@ -19,7 +19,7 @@ extern int mtd_block_is_bad(int fd, int
extern int mtd_erase_block(int fd, int offset);
extern int mtd_write_buffer(int fd, const char *buf, int offset, int
length);
extern int mtd_write_jffs2(const char *mtd, const char *filename, const
char *dir);
-extern int mtd_replace_jffs2(const char *mtd, int fd, int ofs, const char
*filename);
+extern int mtd_add_tar_file_jffs2(const char *mtd, int fd, int ofs, const
char *filename);
extern void mtd_parse_jffs2data(const char *buf, const char *dir);
/* target specific functions */
Signed-off-by: Sean Miller <seanmichaelmiller2014 at gmail.com>
These two patches (both must be applied) fix this bug.
If always mounting the jffs2 overlay and skipping the ram overlay when
sysupgrade.tgz is saved across an upgrade is the desired behavior,
I will instead submit changes to the documentation.
Thanks for your time
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.infradead.org/pipermail/openwrt-devel/attachments/20200406/cef37477/attachment.htm>
-------------- next part --------------
_______________________________________________
openwrt-devel mailing list
openwrt-devel at lists.openwrt.org
https://lists.openwrt.org/mailman/listinfo/openwrt-devel
More information about the openwrt-devel
mailing list