New -zisofs parameters version_2=, block_size_v2=, max_bpt=, max_bpt_f=

xorriso/base_obj.c

@@ -195,6 +195,11 @@ int Xorriso_new(struct XorrisO ** xorriso,char *progname, int flag)
  m->zlib_level_default= m->zlib_level= 6;
  m->zisofs_block_size= m->zisofs_block_size_default= (1 << 15);
  m->zisofs_by_magic= 0;
+ m->zisofs_v2_enabled= 0;
+ m->zisofs_max_total_blocks= m->zisofs_max_total_blocks_default= 0x2000000;
+ m->zisofs_max_file_blocks= m->zisofs_max_file_blocks_default= 0x2000000;
+ m->zisofs_block_size= m->zisofs_block_size_default= (1 << 15);
+ m->zisofs_v2_block_size= m->zisofs_v2_block_size_default= (1 << 17);
  m->do_overwrite= 2;
  m->do_reassure= 0;
  m->drive_blacklist= NULL;

xorriso/filters.c

@@ -1,7 +1,7 @@
 
 /* xorriso - creates, loads, manipulates and burns ISO 9660 filesystem images.
 
-   Copyright 2007-2014 Thomas Schmitt, <scdbackup@gmx.net>
+   Copyright 2007-2020 Thomas Schmitt, <scdbackup@gmx.net>
 
    Provided under GPL version 2 or later.
 
@@ -659,10 +659,12 @@ int Xorriso_status_extf(struct XorrisO *xorriso, char *filter, FILE *fp,
 
 int Xorriso_set_zisofs_params(struct XorrisO *xorriso, int flag)
 {
- int ret;
+ int ret, i;
  struct iso_zisofs_ctrl ctrl;
 
- ctrl.version= 0;
+ memset(&ctrl, 0, sizeof(ctrl));
+ ctrl.version= 1;
+
  ctrl.compression_level= xorriso->zlib_level;
  if(xorriso->zisofs_block_size == (1 << 16))
    ctrl.block_size_log2= 16;
@@ -670,6 +672,15 @@ int Xorriso_set_zisofs_params(struct XorrisO *xorriso, int flag)
    ctrl.block_size_log2= 17;
  else
    ctrl.block_size_log2= 15;
+
+ ctrl.v2_enabled= xorriso->zisofs_v2_enabled;
+ ctrl.max_total_blocks= xorriso->zisofs_max_total_blocks;
+ ctrl.max_file_blocks= xorriso->zisofs_max_file_blocks;
+ ctrl.v2_block_size_log2= 17;
+ for(i= 15; i <= 17; i++)
+   if(xorriso->zisofs_v2_block_size == (1 << i))
+     ctrl.v2_block_size_log2= i;
+
  ret= iso_zisofs_set_params(&ctrl, 0);
  Xorriso_process_msg_queues(xorriso,0);
  if(ret < 0) {
@@ -681,21 +692,48 @@ int Xorriso_set_zisofs_params(struct XorrisO *xorriso, int flag)
 }
 
 
+uint64_t Xorriso_zisofs_current_blocks(struct XorrisO *xorriso, int flag)
+{
+ int ret;
+ struct iso_zisofs_ctrl ctrl;
+
+ memset(&ctrl, 0, sizeof(ctrl));
+ ctrl.version= 1;
+ ret = iso_zisofs_get_params(&ctrl, 0);
+ if(ret != 1)
+   return(0);
+ return(ctrl.current_total_blocks);
+}
+
+
 int Xorriso_status_zisofs(struct XorrisO *xorriso, char *filter, FILE *fp,
                           int flag)
 /*
- bit0= do only report non-default settings
- bit1= do only report to fp
+ bit0= only report non-default settings
+ bit1= only report to fp
 */ 
 {
  off_t ziso_count= 0, osiz_count= 0;
  off_t gzip_count= 0, gunzip_count= 0;
+ uint64_t used_blocks;
+ int always= 0;
 
  iso_zisofs_get_refcounts(&ziso_count, &osiz_count, 0);
  iso_gzip_get_refcounts(&gzip_count, &gunzip_count, 0);
+ if(!(flag & 1)) {
+   always= 1;
+ } else if(filter != NULL) {
+   if(filter[0] != 0)
+     always= 1;
+ }
+
+#ifdef NIX
  if((flag & 1) && xorriso->zlib_level == xorriso->zlib_level_default &&
     xorriso->zisofs_block_size == xorriso->zisofs_block_size_default &&
-    xorriso->zisofs_by_magic == 0 &&
+    xorriso->zisofs_by_magic == 0 && xorriso->zisofs_v2_enabled == 0 &&
+    xorriso->zisofs_max_file_blocks ==
+                                     xorriso->zisofs_max_file_blocks_default &&
+    xorriso->zisofs_v2_block_size == xorriso->zisofs_v2_block_size_default &&
     ziso_count == 0 && osiz_count == 0 &&
     gzip_count == 0 && gunzip_count == 0) {
    if(filter == NULL)
@@ -703,15 +741,52 @@ int Xorriso_status_zisofs(struct XorrisO *xorriso, char *filter, FILE *fp,
    if(filter[0] == 0)
      return 2;
  }
- sprintf(xorriso->result_line,
-     "-zisofs level=%d:block_size=%dk:by_magic=%s:ziso_used=%.f:osiz_used=%.f",
-     xorriso->zlib_level, xorriso->zisofs_block_size / 1024,
-     xorriso->zisofs_by_magic ? "on" : "off",
-     (double) ziso_count, (double) osiz_count);
- sprintf(xorriso->result_line + strlen(xorriso->result_line),
-         ":gzip_used=%.f:gunzip_used=%.f\n",
+#endif
+
+ if(always || !(
+      xorriso->zlib_level == xorriso->zlib_level_default &&
+      xorriso->zisofs_block_size == xorriso->zisofs_block_size_default &&
+      xorriso->zisofs_by_magic == 0)) {
+   sprintf(xorriso->result_line,
+           "-zisofs level=%d:block_size=%dk:by_magic=%s\n",
+           xorriso->zlib_level, xorriso->zisofs_block_size / 1024,
+           xorriso->zisofs_by_magic ? "on" : "off");
+   Xorriso_status_result(xorriso, filter, fp, flag & 2);
+ }
+ if(always || !(
+      xorriso->zisofs_v2_enabled == 0 &&
+      xorriso->zisofs_v2_block_size == xorriso->zisofs_v2_block_size_default)){
+   sprintf(xorriso->result_line,
+          "-zisofs version_2=%s:block_size_v2=%dk\n",
+           xorriso->zisofs_v2_enabled ? xorriso->zisofs_v2_enabled == 1 ?
+                                              "as_needed" : "on" : "off",
+           xorriso->zisofs_v2_block_size / 1024);
+   Xorriso_status_result(xorriso, filter, fp, flag & 2);
+ }
+
+ used_blocks= Xorriso_zisofs_current_blocks(xorriso, 0);
+ if(always || !(
+      xorriso->zisofs_max_total_blocks ==
+                                   xorriso->zisofs_max_total_blocks_default &&
+      xorriso->zisofs_max_file_blocks ==
+                                   xorriso->zisofs_max_file_blocks_default &&
+      used_blocks == 0)) {
+   sprintf(xorriso->result_line,
+          "-zisofs max_bpt=%.f:bpt_used=%.f:max_bpt_f=%.f\n",
+           (double) xorriso->zisofs_max_total_blocks * 8.0,
+           (double) used_blocks * 8.0,
+           (double) xorriso->zisofs_max_file_blocks * 8.0);
+   Xorriso_status_result(xorriso, filter, fp, flag & 2);
+ }
+ if(always || !(
+    ziso_count == 0 && osiz_count == 0 &&
+    gzip_count == 0 && gunzip_count == 0)) {
+   sprintf(xorriso->result_line,
+         "-zisofs ziso_used=%.f:osiz_used=%.f:gzip_used=%.f:gunzip_used=%.f\n",
+         (double) ziso_count, (double) osiz_count,
          (double) gzip_count, (double) gunzip_count);
- Xorriso_status_result(xorriso, filter, fp, flag&2);
+   Xorriso_status_result(xorriso, filter, fp, flag & 2);
+ }
  return(1);
 }
 

xorriso/iso_tree.c

@@ -1296,7 +1296,8 @@ ex:
 int Xorriso_stream_type(struct XorrisO *xorriso, IsoNode *node,
                         IsoStream *stream, char type_text[], int flag)
 {
- int ret, lba;
+ int ret, lba, stream_type, block_size_log2;
+ uint8_t zisofs_algo[2], algo_num;
  char text[5];
 
  strncpy(text, stream->class->type, 4);
@@ -1307,10 +1308,16 @@ int Xorriso_stream_type(struct XorrisO *xorriso, IsoNode *node,
      strcpy(type_text, "image");
    else
      strcpy(type_text, "disk");
- } else if(strcmp(text, "ziso") == 0) {
-   strcpy(type_text, "--zisofs");
- } else if(strcmp(text, "osiz") == 0) {
-   strcpy(type_text, "--zisofs-decode");
+ } else if(strcmp(text, "ziso") == 0 || strcmp(text, "osiz") == 0) {
+   if(strcmp(text, "ziso") == 0)
+     strcpy(type_text, "--zisofs");
+   else
+     strcpy(type_text, "--zisofs-decode");
+   ret= iso_stream_get_zisofs_par(stream, &stream_type, zisofs_algo, &algo_num,
+                                  &block_size_log2, 0);
+   if(ret == 1)
+     sprintf(type_text + strlen(type_text), ":%c%c:%d",
+             zisofs_algo[0], zisofs_algo[1], 1 << block_size_log2);
  } else if(strcmp(text, "gzip") == 0) {
    strcpy(type_text, "--gzip");
  } else if(strcmp(text, "pizg") == 0) {
@@ -2392,7 +2399,7 @@ int Xorriso_show_stream(struct XorrisO *xorriso, void *in_node,
  IsoFile *file;
  IsoStream *stream= NULL, *input_stream;
  IsoExternalFilterCommand *cmd;
- char type_text[16], *source_path= NULL;
+ char type_text[80], *source_path= NULL;
  unsigned int fs_id;
  dev_t dev_id;
  ino_t ino_id;

xorriso/lib_mgt.c

@@ -1,7 +1,7 @@
 
 /* xorriso - creates, loads, manipulates and burns ISO 9660 filesystem images.
 
-   Copyright 2007-2019 Thomas Schmitt, <scdbackup@gmx.net>
+   Copyright 2007-2020 Thomas Schmitt, <scdbackup@gmx.net>
 
    Provided under GPL version 2 or later.
 
@@ -120,7 +120,7 @@ int Xorriso_startup_libraries(struct XorrisO *xorriso, int flag)
 {
  int ret, major, minor, micro;
  char *queue_sev, *print_sev, reason[1024];
- struct iso_zisofs_ctrl zisofs_ctrl= {0, 6, 15};
+ struct iso_zisofs_ctrl zisofs_ctrl;
 
 
 /* First an ugly compile time check for header version compatibility.
@@ -213,12 +213,21 @@ LIBISOBURN_MISCONFIGURATION_ = 0;
  if(ret <= 0)
    return(ret);
 
+ memset(&zisofs_ctrl, 0, sizeof(zisofs_ctrl));
+ zisofs_ctrl.version = 1;
  ret = iso_zisofs_get_params(&zisofs_ctrl, 0);
  if (ret == 1) {
    xorriso->zisofs_block_size= xorriso->zisofs_block_size_default=
        (1 << zisofs_ctrl.block_size_log2);
    xorriso->zlib_level= xorriso->zlib_level_default=
        zisofs_ctrl.compression_level;
+   xorriso->zisofs_v2_enabled= zisofs_ctrl.v2_enabled;
+   xorriso->zisofs_max_total_blocks=
+     xorriso->zisofs_max_total_blocks_default= zisofs_ctrl.max_total_blocks;
+   xorriso->zisofs_max_file_blocks=
+     xorriso->zisofs_max_file_blocks_default= zisofs_ctrl.max_file_blocks;
+   xorriso->zisofs_v2_block_size= xorriso->zisofs_v2_block_size_default=
+       1 << zisofs_ctrl.v2_block_size_log2;
  }
 
  iso_node_xinfo_make_clonable(Xorriso__mark_update_xinfo,

xorriso/opts_d_h.c

@@ -2186,6 +2186,8 @@ int Xorriso_option_help(struct XorrisO *xorriso, int flag)
 "  -zisofs option[:options]",
 "                 Set global zisofs parameters:",
 "                   level=0|...|9 , block_size=32k|64k|128k , by_magic=on|off",
+"                   version_2=off|as_needed|on , block_size_v2=32k|...|1024k",
+"                   max_bpt=1k...128g , max_bpt_f=1k...128g",
 "",
 "Write-to-media commands:",
 "  -rollback      Discard the manipulated ISO image and reload it.",

xorriso/opts_p_z.c

@@ -2245,15 +2245,34 @@ int Xorriso_option_xattr(struct XorrisO *xorriso, char *mode, int flag)
 }
 
 
+static int parse_zisofs_param(char *cpt, int key_l, int l, double *num)
+{
+ char text[16];
+
+ *num= 0.0;
+ if(l <= key_l || l >= key_l + 16)
+   return(0);
+ strncpy(text, cpt + key_l, l - key_l);
+ text[l - key_l]= 0;
+ *num= Scanf_io_size(text, 0);
+ return(1);
+}
+
 /* Option -zisofs */
 int Xorriso_option_zisofs(struct XorrisO *xorriso, char *mode, int flag)
 {
- int was_level, was_blocksize, ret, l;
+ int was_level, was_blocksize, was_v2_enabled, was_blocksize_v2;
+ uint64_t was_max_total_blocks, was_max_file_blocks;
+ int ret, l, i;
  double num;
  char *cpt, *npt, text[16];
 
  was_level= xorriso->zlib_level;
  was_blocksize= xorriso->zisofs_block_size;
+ was_v2_enabled= xorriso->zisofs_v2_enabled;
+ was_max_total_blocks= xorriso->zisofs_max_total_blocks;
+ was_max_file_blocks= xorriso->zisofs_max_file_blocks;
+ was_blocksize_v2= xorriso->zisofs_v2_block_size;
  npt= cpt= mode;
  for(cpt= mode; npt!=NULL; cpt= npt+1) {
    npt= strchr(cpt,':');
@@ -2277,7 +2296,8 @@ int Xorriso_option_zisofs(struct XorrisO *xorriso, char *mode, int flag)
    } else if(strncmp(cpt, "ziso_used=", 10) == 0 ||
              strncmp(cpt, "osiz_used=", 10) == 0 ||
              strncmp(cpt, "gzip_used=", 10) == 0 ||
-             strncmp(cpt, "gunzip_used=", 12) == 0) {
+             strncmp(cpt, "gunzip_used=", 12) == 0 ||
+             strncmp(cpt, "bpt_used=", 9) == 0) {
      /* (ignored info from -status) */;
 
    } else if(strncmp(cpt, "block_size=", 11)==0) {
@@ -2294,16 +2314,67 @@ int Xorriso_option_zisofs(struct XorrisO *xorriso, char *mode, int flag)
      }
      xorriso->zisofs_block_size= num;
 
-   } else if(strncmp(cpt, "by_magic=", 8)==0) {
+   } else if(strncmp(cpt, "by_magic=", 9)==0) {
      if(strncmp(cpt + 9, "on", l - 9) == 0)
        xorriso->zisofs_by_magic= 1;
      else
        xorriso->zisofs_by_magic= 0;
 
+   } else if(strncmp(cpt, "version_2=", 10) == 0) {
+     if(strncmp(cpt + 10, "off", l - 10) == 0) {
+       xorriso->zisofs_v2_enabled= 0;
+     } else if(strncmp(cpt + 10, "as_needed", l - 11) == 0) {
+       xorriso->zisofs_v2_enabled= 1;
+     } else if(strncmp(cpt + 10, "on", l - 11) == 0) {
+       xorriso->zisofs_v2_enabled= 2;
+     } else {
+       sprintf(xorriso->info_text,
+         "-zisofs: Unrecognized version_2 mode (allowed: on, off, as_needed)");
+       goto sorry_ex;
+     }
+
+   } else if(strncmp(cpt, "max_bpt=", 8) == 0) {
+     parse_zisofs_param(cpt, 8, l, &num);
+     if(num < 1024.0 || num > 128.0 * 1024.0 * 1024.0 * 1024.0) {
+       sprintf(xorriso->info_text,
+         "-zisofs: Unsupported block pointer pool size (allowed: 1k to 128g)");
+       goto sorry_ex;
+     }
+     xorriso->zisofs_max_total_blocks= num / 8.0;
+     if(xorriso->zisofs_max_total_blocks < xorriso->zisofs_max_file_blocks)
+       xorriso->zisofs_max_file_blocks= xorriso->zisofs_max_total_blocks;
+
+   } else if(strncmp(cpt, "max_bpt_f=", 10) == 0) {
+     parse_zisofs_param(cpt, 10, l, &num);
+     if(num < 1024.0 || num > 128.0 * 1024.0 * 1024.0 * 1024.0) {
+       sprintf(xorriso->info_text,
+         "-zisofs: Unsupported block pointer list size (allowed: 1k to 128g)");
+       goto sorry_ex;
+     }
+     xorriso->zisofs_max_file_blocks= num / 8.0;
+     if(xorriso->zisofs_max_file_blocks > xorriso->zisofs_max_total_blocks)
+       xorriso->zisofs_max_total_blocks= xorriso->zisofs_max_file_blocks;
+
+   } else if(strncmp(cpt, "block_size_v2=", 14) == 0) {
+     parse_zisofs_param(cpt, 14, l, &num);
+     for(i= 15 ; i <= 20; i++)
+       if(num == (1 << i))
+     break;
+     if(i > 20) {
+       sprintf(xorriso->info_text,
+        "-zisofs: Unsupported block size (allowed 32k, 64k, 128k, ... 1024k)");
+       goto sorry_ex;
+     }
+     xorriso->zisofs_v2_block_size= num;
+
    } else if(strncmp(cpt, "default", l)==0) {
      xorriso->zlib_level= xorriso->zlib_level_default;
      xorriso->zisofs_block_size= xorriso->zisofs_block_size_default;
      xorriso->zisofs_by_magic= 0;
+     xorriso->zisofs_v2_enabled= 0;
+     xorriso->zisofs_max_total_blocks= xorriso->zisofs_max_total_blocks_default;
+     xorriso->zisofs_max_file_blocks= xorriso->zisofs_max_file_blocks_default;
+     xorriso->zisofs_v2_block_size= xorriso->zisofs_v2_block_size_default;
 
    } else {
 unknown_mode:;
@@ -2315,6 +2386,10 @@ sorry_ex:
      Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
      xorriso->zlib_level= was_level;
      xorriso->zisofs_block_size= was_blocksize;
+     xorriso->zisofs_v2_enabled= was_v2_enabled;
+     xorriso->zisofs_max_total_blocks= was_max_total_blocks;
+     xorriso->zisofs_max_file_blocks= was_max_file_blocks;
+     xorriso->zisofs_v2_block_size= was_blocksize_v2;
      return(0);
    }
  }

xorriso/xorriso.1

@@ -9,7 +9,7 @@
 .\" First parameter, NAME, should be all caps
 .\" Second parameter, SECTION, should be 1-8, maybe w/ subsection
 .\" other parameters are allowed: see man(7), man(1)
-.TH XORRISO 1 "Version 1.5.3, Sep 30, 2020"
+.TH XORRISO 1 "Version 1.5.3, Oct 14, 2020"
 .\" Please adjust this date whenever revising the manpage.
 .\"
 .\" Some roff macros, for reference:
@@ -3092,21 +3092,59 @@ User id to be used for all files when the new ISO tree gets written to media.
 \fB\-gid\fR gid
 Group id to be used for all files when the new ISO tree gets written to media.
 .TP
-\fB\-zisofs\fR option[:options]
+\fB\-zisofs\fR parameter[:parameters]
 Set global parameters for zisofs compression. This data format is recognized
 and transparently uncompressed by some Linux kernels. It is to be applied
 via command \-set_filter with built\-in filter "\-\-zisofs".
+.br
+Note: This command is only permitted while no \-\-zisofs filters are applied to
+any files.
+.br
 Parameters are:
 .br
  "level="[0\-9] zlib compression: 0=none, 1=fast,..., 9=slow
 .br
- "block_size="32k|64k|128k size of compression blocks
+ "block_size="32k|64k|128k sets the size of version 1 compression blocks.
 .br
  "by_magic=on" enables an expensive test at image generation time which checks
 files from disk whether they already are zisofs compressed, e.g. by program
 mkzftree.
 .br
- "default" same as "level=6:block_size=32k:by_magic=off"
+ "version_2="off|as_needed|on enables the use of experimental version zisofs2
+which can encode files of size 4 GiB or larger. The Linux kernel (as of 5.9)
+does not yet know this format and will complain like
+.br
+  isofs: Unknown ZF compression algorithm: PZ
+.br
+The files will then appear in their compressed form with zisofs2 header,
+block pointer list, and compressed data.
+.br
+zisofs2 is recognized by xorriso in files from loaded images and gets equipped
+with \-\-zisofs\-decode filters, unless restrictions on the number of
+block pointers prevent this.
+.br
+Mode "off" restricts compression to files smaller than 4 GiB uncompressed size.
+Mode "as_needed" uses zisofs2 for larger files. Mode "on" uses zisofs2 for all
+zisofs compressed files.
+.br
+ "block_size_v2="32k|64k|128k|256k|512k|1m sets the size of compression blocks
+for zisofs2.
+.br
+ "max_bpt="1k|...|128g sets the limit for the overall allocated block pointer
+memory. Block pointers occupy virtual memory while a file gets uncompressed
+and while a file, which shall be compressed, waits for ISO filesystem creation.
+.br
+One pointer occupies 8 bytes of memory and governs block_size or block_size_v2
+uncompressed bytes.
+I.e. with block size 128k, 1m of block pointer memory suffices for 16g of
+uncompressed file size.
+.br
+ "max_bpt_f="1k|...|128g sets the limit for the memory size of the block
+pointer list of a single file. max_bpt_f is never larger than max_bpt.
+If either is set to violate this rule, the other gets set to the same value.
+.br
+ "default" same as "level=6:block_size=32k:by_magic=off:
+version_2=off:block_size_v2=128k:max_bpt=256m:max_bpt_f=256m".
 .TP
 \fB\-speed\fR code|number[k|m|c|d|b]
 Set the burn speed. Default is "max" (or "0") = maximum speed as announced
@@ -4624,6 +4662,14 @@ Frequently used types are:
  cout:'disk_path offset count'  for \-cut_out files.
 .br
  extf:'filter_name' for external filters.
+.br
+ \-\-zisofs:algorithm:block_size  for zisofs compression filters.
+.br
+ \-\-zisofs\-decode:algorithm:block_size  for zisofs uncompression filters.
+.br
+ \-\-gzip for internal gzip compression filters.
+.br
+ \-\-gunzip for internal gzip uncompression filters.
 .br
 Example:
 .br

xorriso/xorriso.texi

@@ -50,7 +50,7 @@
 @c man .\" First parameter, NAME, should be all caps
 @c man .\" Second parameter, SECTION, should be 1-8, maybe w/ subsection
 @c man .\" other parameters are allowed: see man(7), man(1)
-@c man .TH XORRISO 1 "Version 1.5.3, Sep 30, 2020"
+@c man .TH XORRISO 1 "Version 1.5.3, Oct 14, 2020"
 @c man .\" Please adjust this date whenever revising the manpage.
 @c man .\"
 @c man .\" Some roff macros, for reference:
@@ -3603,23 +3603,61 @@ User id to be used for all files when the new ISO tree gets written to media.
 @cindex Group, global in ISO image, -gid
 Group id to be used for all files when the new ISO tree gets written to media.
 @c man .TP
-@item -zisofs option[:options]
+@item -zisofs parameter[:parameters]
 @kindex -zisofs   controls zisofs production
 @cindex Filter, zisofs parameters, -zisofs
 Set global parameters for zisofs compression. This data format is recognized
 and transparently uncompressed by some Linux kernels. It is to be applied
 via command -set_filter with built-in filter "@minus{}@minus{}zisofs".
+@*
+Note: This command is only permitted while no --zisofs filters are applied to
+any files.
+@*
 Parameters are:
 @*
  "level="[0-9] zlib compression: 0=none, 1=fast,..., 9=slow
 @*
- "block_size="32k|64k|128k size of compression blocks
+ "block_size="32k|64k|128k sets the size of version 1 compression blocks.
 @*
  "by_magic=on" enables an expensive test at image generation time which checks
 files from disk whether they already are zisofs compressed, e.g. by program
 mkzftree.
 @*
- "default" same as "level=6:block_size=32k:by_magic=off"
+ "version_2="off|as_needed|on enables the use of experimental version zisofs2
+which can encode files of size 4 GiB or larger. The Linux kernel (as of 5.9)
+does not yet know this format and will complain like
+@*
+  isofs: Unknown ZF compression algorithm: PZ
+@*
+The files will then appear in their compressed form with zisofs2 header,
+block pointer list, and compressed data.
+@*
+zisofs2 is recognized by xorriso in files from loaded images and gets equipped
+with --zisofs-decode filters, unless restrictions on the number of
+block pointers prevent this.
+@*
+Mode "off" restricts compression to files smaller than 4 GiB uncompressed size.
+Mode "as_needed" uses zisofs2 for larger files. Mode "on" uses zisofs2 for all
+zisofs compressed files.
+@*
+ "block_size_v2="32k|64k|128k|256k|512k|1m sets the size of compression blocks
+for zisofs2.
+@*
+ "max_bpt="1k|...|128g sets the limit for the overall allocated block pointer
+memory. Block pointers occupy virtual memory while a file gets uncompressed
+and while a file, which shall be compressed, waits for ISO filesystem creation.
+@*
+One pointer occupies 8 bytes of memory and governs block_size or block_size_v2
+uncompressed bytes.
+I.e. with block size 128k, 1m of block pointer memory suffices for 16g of
+uncompressed file size.
+@*
+ "max_bpt_f="1k|...|128g sets the limit for the memory size of the block
+pointer list of a single file. max_bpt_f is never larger than max_bpt.
+If either is set to violate this rule, the other gets set to the same value.
+@*
+ "default" same as "level=6:block_size=32k:by_magic=off:
+version_2=off:block_size_v2=128k:max_bpt=256m:max_bpt_f=256m".
 @c man .TP
 @item -speed code|number[k|m|c|d|b]
 @kindex -speed   set write speed
@@ -5333,6 +5371,14 @@ Frequently used types are:
  cout:'disk_path offset count'  for -cut_out files.
 @*
  extf:'filter_name' for external filters.
+@*
+ --zisofs:algorithm:block_size  for zisofs compression filters.
+@*
+ --zisofs-decode:algorithm:block_size  for zisofs uncompression filters.
+@*
+ --gzip for internal gzip compression filters.
+@*
+ --gunzip for internal gzip uncompression filters.
 @*
 Example:
 @*

xorriso/xorriso_private.h

@@ -2,7 +2,7 @@
 /* Command line oriented batch and dialog tool which creates, loads,
    manipulates and burns ISO 9660 filesystem images.
 
-   Copyright 2007-2019 Thomas Schmitt, <scdbackup@gmx.net>
+   Copyright 2007-2020 Thomas Schmitt, <scdbackup@gmx.net>
 
    Provided under GPL version 2 or later.
 
@@ -212,8 +212,8 @@ struct XorrisO { /* the global context of xorriso */
  mode_t global_dir_mode;
  mode_t global_file_mode;
 
- int do_tao; /* 1= Use TAO resp. Incremental
-               -1= Use SAO resp. DAO
+ int do_tao; /* 1= Use TAO or Incremental
+               -1= Use SAO or DAO
                 0= let libburn choose */
 
  struct Xorriso_lsT *filters;
@@ -224,6 +224,13 @@ struct XorrisO { /* the global context of xorriso */
  int zisofs_block_size;
  int zisofs_block_size_default;
  int zisofs_by_magic;
+ int zisofs_v2_enabled;  /* 0=no, 1=as_needed, 2=force */
+ uint64_t zisofs_max_total_blocks;
+ uint64_t zisofs_max_total_blocks_default;
+ uint64_t zisofs_max_file_blocks;
+ uint64_t zisofs_max_file_blocks_default;
+ int zisofs_v2_block_size;
+ int zisofs_v2_block_size_default;
 
  int do_overwrite; /* 0=off, 1=on, 2=nondir */
  int do_reassure;  /* 0=off, 1=on, 2=tree */

xorriso/xorriso_timestamp.h

@@ -1 +1 @@
-#define Xorriso_timestamP "2020.10.14.182119"
+#define Xorriso_timestamP "2020.10.14.205904"