diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..4fb94fc --- /dev/null +++ b/.gitignore @@ -0,0 +1 @@ +SOURCES/gzip-1.10.tar.xz diff --git a/.gzip.metadata b/.gzip.metadata new file mode 100644 index 0000000..ea01da4 --- /dev/null +++ b/.gzip.metadata @@ -0,0 +1 @@ +48d28c77cb8cac38573809fdd1665ecf75f91fa9 SOURCES/gzip-1.10.tar.xz diff --git a/SOURCES/colorzgrep.csh b/SOURCES/colorzgrep.csh new file mode 100644 index 0000000..5547b7a --- /dev/null +++ b/SOURCES/colorzgrep.csh @@ -0,0 +1,9 @@ +test -f /usr/libexec/grepconf.sh +if ( $status == 1 ) exit + +/usr/libexec/grepconf.sh -c +if ( $status == 1 ) exit + +alias zgrep 'zgrep --color=auto' +alias zfgrep 'zfgrep --color=auto' +alias zegrep 'zegrep --color=auto' diff --git a/SOURCES/colorzgrep.sh b/SOURCES/colorzgrep.sh new file mode 100644 index 0000000..7764a07 --- /dev/null +++ b/SOURCES/colorzgrep.sh @@ -0,0 +1,6 @@ +[ -f /usr/libexec/grepconf.sh ] || return + +/usr/libexec/grepconf.sh -c || return +alias zgrep='zgrep --color=auto' 2>/dev/null +alias zfgrep='zfgrep --color=auto' 2>/dev/null +alias zegrep='zegrep --color=auto' 2>/dev/null diff --git a/SOURCES/dfltcc-segfault.patch b/SOURCES/dfltcc-segfault.patch new file mode 100644 index 0000000..95a9efd --- /dev/null +++ b/SOURCES/dfltcc-segfault.patch @@ -0,0 +1,67 @@ +--- + dfltcc.c | 14 ++++++++------ + 1 file changed, 8 insertions(+), 6 deletions(-) + +diff --git a/dfltcc.c b/dfltcc.c +index 86aa56e..3a5b92d 100644 +--- a/dfltcc.c ++++ b/dfltcc.c +@@ -242,10 +242,8 @@ dfltcc_gdht (struct dfltcc_param_v0 *param) + dfltcc (DFLTCC_GDHT, param, NULL, NULL, &next_in, &avail_in, NULL); + } + +-static off_t total_in; +- + static dfltcc_cc +-dfltcc_cmpr_xpnd (struct dfltcc_param_v0 *param, int fn) ++dfltcc_cmpr_xpnd (struct dfltcc_param_v0 *param, int fn, off_t *total_in) + { + uch *next_out = outbuf + outcnt; + size_t avail_out = OUTBUFSIZ - outcnt; +@@ -257,7 +255,7 @@ dfltcc_cmpr_xpnd (struct dfltcc_param_v0 *param, int fn) + window); + off_t consumed_in = next_in - (inbuf + inptr); + inptr += consumed_in; +- total_in += consumed_in; ++ *total_in += consumed_in; + outcnt += ((OUTBUFSIZ - outcnt) - avail_out); + return cc; + } +@@ -349,6 +347,7 @@ dfltcc_deflate (int pack_level) + + union aligned_dfltcc_param_v0 ctx_v0; + struct dfltcc_param_v0 *param = init_param (&ctx_v0); ++ off_t total_in = 0; + + /* Compress ifd into ofd in a loop. */ + while (true) +@@ -398,7 +397,8 @@ dfltcc_deflate (int pack_level) + } + + /* Compress inbuf into outbuf. */ +- while (dfltcc_cmpr_xpnd (param, DFLTCC_CMPR) == DFLTCC_CC_AGAIN) ++ while (dfltcc_cmpr_xpnd (param, DFLTCC_CMPR, &total_in) ++ == DFLTCC_CC_AGAIN) + ; + + /* Unmask the input data. */ +@@ -427,6 +427,7 @@ dfltcc_inflate (void) + + union aligned_dfltcc_param_v0 ctx_v0; + struct dfltcc_param_v0 *param = init_param (&ctx_v0); ++ off_t total_in = 0; + + /* Decompress ifd into ofd in a loop. */ + while (true) +@@ -446,7 +447,8 @@ dfltcc_inflate (void) + + /* Decompress inbuf into outbuf. */ + dfltcc_cc cc; +- while ((cc = dfltcc_cmpr_xpnd (param, DFLTCC_XPND)) == DFLTCC_CC_AGAIN) ++ while ((cc = dfltcc_cmpr_xpnd (param, DFLTCC_XPND, &total_in)) ++ == DFLTCC_CC_AGAIN) + ; + if (cc == DFLTCC_CC_OK) + { +-- +2.25.4 diff --git a/SOURCES/fdl-1.3.txt b/SOURCES/fdl-1.3.txt new file mode 100644 index 0000000..2f7e03c --- /dev/null +++ b/SOURCES/fdl-1.3.txt @@ -0,0 +1,451 @@ + + GNU Free Documentation License + Version 1.3, 3 November 2008 + + + Copyright (C) 2000, 2001, 2002, 2007, 2008 Free Software Foundation, Inc. + + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + +0. PREAMBLE + +The purpose of this License is to make a manual, textbook, or other +functional and useful document "free" in the sense of freedom: to +assure everyone the effective freedom to copy and redistribute it, +with or without modifying it, either commercially or noncommercially. +Secondarily, this License preserves for the author and publisher a way +to get credit for their work, while not being considered responsible +for modifications made by others. + +This License is a kind of "copyleft", which means that derivative +works of the document must themselves be free in the same sense. It +complements the GNU General Public License, which is a copyleft +license designed for free software. + +We have designed this License in order to use it for manuals for free +software, because free software needs free documentation: a free +program should come with manuals providing the same freedoms that the +software does. But this License is not limited to software manuals; +it can be used for any textual work, regardless of subject matter or +whether it is published as a printed book. We recommend this License +principally for works whose purpose is instruction or reference. + + +1. APPLICABILITY AND DEFINITIONS + +This License applies to any manual or other work, in any medium, that +contains a notice placed by the copyright holder saying it can be +distributed under the terms of this License. Such a notice grants a +world-wide, royalty-free license, unlimited in duration, to use that +work under the conditions stated herein. The "Document", below, +refers to any such manual or work. Any member of the public is a +licensee, and is addressed as "you". You accept the license if you +copy, modify or distribute the work in a way requiring permission +under copyright law. + +A "Modified Version" of the Document means any work containing the +Document or a portion of it, either copied verbatim, or with +modifications and/or translated into another language. + +A "Secondary Section" is a named appendix or a front-matter section of +the Document that deals exclusively with the relationship of the +publishers or authors of the Document to the Document's overall +subject (or to related matters) and contains nothing that could fall +directly within that overall subject. (Thus, if the Document is in +part a textbook of mathematics, a Secondary Section may not explain +any mathematics.) The relationship could be a matter of historical +connection with the subject or with related matters, or of legal, +commercial, philosophical, ethical or political position regarding +them. + +The "Invariant Sections" are certain Secondary Sections whose titles +are designated, as being those of Invariant Sections, in the notice +that says that the Document is released under this License. If a +section does not fit the above definition of Secondary then it is not +allowed to be designated as Invariant. The Document may contain zero +Invariant Sections. If the Document does not identify any Invariant +Sections then there are none. + +The "Cover Texts" are certain short passages of text that are listed, +as Front-Cover Texts or Back-Cover Texts, in the notice that says that +the Document is released under this License. A Front-Cover Text may +be at most 5 words, and a Back-Cover Text may be at most 25 words. + +A "Transparent" copy of the Document means a machine-readable copy, +represented in a format whose specification is available to the +general public, that is suitable for revising the document +straightforwardly with generic text editors or (for images composed of +pixels) generic paint programs or (for drawings) some widely available +drawing editor, and that is suitable for input to text formatters or +for automatic translation to a variety of formats suitable for input +to text formatters. A copy made in an otherwise Transparent file +format whose markup, or absence of markup, has been arranged to thwart +or discourage subsequent modification by readers is not Transparent. +An image format is not Transparent if used for any substantial amount +of text. A copy that is not "Transparent" is called "Opaque". + +Examples of suitable formats for Transparent copies include plain +ASCII without markup, Texinfo input format, LaTeX input format, SGML +or XML using a publicly available DTD, and standard-conforming simple +HTML, PostScript or PDF designed for human modification. Examples of +transparent image formats include PNG, XCF and JPG. Opaque formats +include proprietary formats that can be read and edited only by +proprietary word processors, SGML or XML for which the DTD and/or +processing tools are not generally available, and the +machine-generated HTML, PostScript or PDF produced by some word +processors for output purposes only. + +The "Title Page" means, for a printed book, the title page itself, +plus such following pages as are needed to hold, legibly, the material +this License requires to appear in the title page. For works in +formats which do not have any title page as such, "Title Page" means +the text near the most prominent appearance of the work's title, +preceding the beginning of the body of the text. + +The "publisher" means any person or entity that distributes copies of +the Document to the public. + +A section "Entitled XYZ" means a named subunit of the Document whose +title either is precisely XYZ or contains XYZ in parentheses following +text that translates XYZ in another language. (Here XYZ stands for a +specific section name mentioned below, such as "Acknowledgements", +"Dedications", "Endorsements", or "History".) To "Preserve the Title" +of such a section when you modify the Document means that it remains a +section "Entitled XYZ" according to this definition. + +The Document may include Warranty Disclaimers next to the notice which +states that this License applies to the Document. These Warranty +Disclaimers are considered to be included by reference in this +License, but only as regards disclaiming warranties: any other +implication that these Warranty Disclaimers may have is void and has +no effect on the meaning of this License. + +2. VERBATIM COPYING + +You may copy and distribute the Document in any medium, either +commercially or noncommercially, provided that this License, the +copyright notices, and the license notice saying this License applies +to the Document are reproduced in all copies, and that you add no +other conditions whatsoever to those of this License. You may not use +technical measures to obstruct or control the reading or further +copying of the copies you make or distribute. However, you may accept +compensation in exchange for copies. If you distribute a large enough +number of copies you must also follow the conditions in section 3. + +You may also lend copies, under the same conditions stated above, and +you may publicly display copies. + + +3. COPYING IN QUANTITY + +If you publish printed copies (or copies in media that commonly have +printed covers) of the Document, numbering more than 100, and the +Document's license notice requires Cover Texts, you must enclose the +copies in covers that carry, clearly and legibly, all these Cover +Texts: Front-Cover Texts on the front cover, and Back-Cover Texts on +the back cover. Both covers must also clearly and legibly identify +you as the publisher of these copies. The front cover must present +the full title with all words of the title equally prominent and +visible. You may add other material on the covers in addition. +Copying with changes limited to the covers, as long as they preserve +the title of the Document and satisfy these conditions, can be treated +as verbatim copying in other respects. + +If the required texts for either cover are too voluminous to fit +legibly, you should put the first ones listed (as many as fit +reasonably) on the actual cover, and continue the rest onto adjacent +pages. + +If you publish or distribute Opaque copies of the Document numbering +more than 100, you must either include a machine-readable Transparent +copy along with each Opaque copy, or state in or with each Opaque copy +a computer-network location from which the general network-using +public has access to download using public-standard network protocols +a complete Transparent copy of the Document, free of added material. +If you use the latter option, you must take reasonably prudent steps, +when you begin distribution of Opaque copies in quantity, to ensure +that this Transparent copy will remain thus accessible at the stated +location until at least one year after the last time you distribute an +Opaque copy (directly or through your agents or retailers) of that +edition to the public. + +It is requested, but not required, that you contact the authors of the +Document well before redistributing any large number of copies, to +give them a chance to provide you with an updated version of the +Document. + + +4. MODIFICATIONS + +You may copy and distribute a Modified Version of the Document under +the conditions of sections 2 and 3 above, provided that you release +the Modified Version under precisely this License, with the Modified +Version filling the role of the Document, thus licensing distribution +and modification of the Modified Version to whoever possesses a copy +of it. In addition, you must do these things in the Modified Version: + +A. Use in the Title Page (and on the covers, if any) a title distinct + from that of the Document, and from those of previous versions + (which should, if there were any, be listed in the History section + of the Document). You may use the same title as a previous version + if the original publisher of that version gives permission. +B. List on the Title Page, as authors, one or more persons or entities + responsible for authorship of the modifications in the Modified + Version, together with at least five of the principal authors of the + Document (all of its principal authors, if it has fewer than five), + unless they release you from this requirement. +C. State on the Title page the name of the publisher of the + Modified Version, as the publisher. +D. Preserve all the copyright notices of the Document. +E. Add an appropriate copyright notice for your modifications + adjacent to the other copyright notices. +F. Include, immediately after the copyright notices, a license notice + giving the public permission to use the Modified Version under the + terms of this License, in the form shown in the Addendum below. +G. Preserve in that license notice the full lists of Invariant Sections + and required Cover Texts given in the Document's license notice. +H. Include an unaltered copy of this License. +I. Preserve the section Entitled "History", Preserve its Title, and add + to it an item stating at least the title, year, new authors, and + publisher of the Modified Version as given on the Title Page. If + there is no section Entitled "History" in the Document, create one + stating the title, year, authors, and publisher of the Document as + given on its Title Page, then add an item describing the Modified + Version as stated in the previous sentence. +J. Preserve the network location, if any, given in the Document for + public access to a Transparent copy of the Document, and likewise + the network locations given in the Document for previous versions + it was based on. These may be placed in the "History" section. + You may omit a network location for a work that was published at + least four years before the Document itself, or if the original + publisher of the version it refers to gives permission. +K. For any section Entitled "Acknowledgements" or "Dedications", + Preserve the Title of the section, and preserve in the section all + the substance and tone of each of the contributor acknowledgements + and/or dedications given therein. +L. Preserve all the Invariant Sections of the Document, + unaltered in their text and in their titles. Section numbers + or the equivalent are not considered part of the section titles. +M. Delete any section Entitled "Endorsements". Such a section + may not be included in the Modified Version. +N. Do not retitle any existing section to be Entitled "Endorsements" + or to conflict in title with any Invariant Section. +O. Preserve any Warranty Disclaimers. + +If the Modified Version includes new front-matter sections or +appendices that qualify as Secondary Sections and contain no material +copied from the Document, you may at your option designate some or all +of these sections as invariant. To do this, add their titles to the +list of Invariant Sections in the Modified Version's license notice. +These titles must be distinct from any other section titles. + +You may add a section Entitled "Endorsements", provided it contains +nothing but endorsements of your Modified Version by various +parties--for example, statements of peer review or that the text has +been approved by an organization as the authoritative definition of a +standard. + +You may add a passage of up to five words as a Front-Cover Text, and a +passage of up to 25 words as a Back-Cover Text, to the end of the list +of Cover Texts in the Modified Version. Only one passage of +Front-Cover Text and one of Back-Cover Text may be added by (or +through arrangements made by) any one entity. If the Document already +includes a cover text for the same cover, previously added by you or +by arrangement made by the same entity you are acting on behalf of, +you may not add another; but you may replace the old one, on explicit +permission from the previous publisher that added the old one. + +The author(s) and publisher(s) of the Document do not by this License +give permission to use their names for publicity for or to assert or +imply endorsement of any Modified Version. + + +5. COMBINING DOCUMENTS + +You may combine the Document with other documents released under this +License, under the terms defined in section 4 above for modified +versions, provided that you include in the combination all of the +Invariant Sections of all of the original documents, unmodified, and +list them all as Invariant Sections of your combined work in its +license notice, and that you preserve all their Warranty Disclaimers. + +The combined work need only contain one copy of this License, and +multiple identical Invariant Sections may be replaced with a single +copy. If there are multiple Invariant Sections with the same name but +different contents, make the title of each such section unique by +adding at the end of it, in parentheses, the name of the original +author or publisher of that section if known, or else a unique number. +Make the same adjustment to the section titles in the list of +Invariant Sections in the license notice of the combined work. + +In the combination, you must combine any sections Entitled "History" +in the various original documents, forming one section Entitled +"History"; likewise combine any sections Entitled "Acknowledgements", +and any sections Entitled "Dedications". You must delete all sections +Entitled "Endorsements". + + +6. COLLECTIONS OF DOCUMENTS + +You may make a collection consisting of the Document and other +documents released under this License, and replace the individual +copies of this License in the various documents with a single copy +that is included in the collection, provided that you follow the rules +of this License for verbatim copying of each of the documents in all +other respects. + +You may extract a single document from such a collection, and +distribute it individually under this License, provided you insert a +copy of this License into the extracted document, and follow this +License in all other respects regarding verbatim copying of that +document. + + +7. AGGREGATION WITH INDEPENDENT WORKS + +A compilation of the Document or its derivatives with other separate +and independent documents or works, in or on a volume of a storage or +distribution medium, is called an "aggregate" if the copyright +resulting from the compilation is not used to limit the legal rights +of the compilation's users beyond what the individual works permit. +When the Document is included in an aggregate, this License does not +apply to the other works in the aggregate which are not themselves +derivative works of the Document. + +If the Cover Text requirement of section 3 is applicable to these +copies of the Document, then if the Document is less than one half of +the entire aggregate, the Document's Cover Texts may be placed on +covers that bracket the Document within the aggregate, or the +electronic equivalent of covers if the Document is in electronic form. +Otherwise they must appear on printed covers that bracket the whole +aggregate. + + +8. TRANSLATION + +Translation is considered a kind of modification, so you may +distribute translations of the Document under the terms of section 4. +Replacing Invariant Sections with translations requires special +permission from their copyright holders, but you may include +translations of some or all Invariant Sections in addition to the +original versions of these Invariant Sections. You may include a +translation of this License, and all the license notices in the +Document, and any Warranty Disclaimers, provided that you also include +the original English version of this License and the original versions +of those notices and disclaimers. In case of a disagreement between +the translation and the original version of this License or a notice +or disclaimer, the original version will prevail. + +If a section in the Document is Entitled "Acknowledgements", +"Dedications", or "History", the requirement (section 4) to Preserve +its Title (section 1) will typically require changing the actual +title. + + +9. TERMINATION + +You may not copy, modify, sublicense, or distribute the Document +except as expressly provided under this License. Any attempt +otherwise to copy, modify, sublicense, or distribute it is void, and +will automatically terminate your rights under this License. + +However, if you cease all violation of this License, then your license +from a particular copyright holder is reinstated (a) provisionally, +unless and until the copyright holder explicitly and finally +terminates your license, and (b) permanently, if the copyright holder +fails to notify you of the violation by some reasonable means prior to +60 days after the cessation. + +Moreover, your license from a particular copyright holder is +reinstated permanently if the copyright holder notifies you of the +violation by some reasonable means, this is the first time you have +received notice of violation of this License (for any work) from that +copyright holder, and you cure the violation prior to 30 days after +your receipt of the notice. + +Termination of your rights under this section does not terminate the +licenses of parties who have received copies or rights from you under +this License. If your rights have been terminated and not permanently +reinstated, receipt of a copy of some or all of the same material does +not give you any rights to use it. + + +10. FUTURE REVISIONS OF THIS LICENSE + +The Free Software Foundation may publish new, revised versions of the +GNU Free Documentation License from time to time. Such new versions +will be similar in spirit to the present version, but may differ in +detail to address new problems or concerns. See +http://www.gnu.org/copyleft/. + +Each version of the License is given a distinguishing version number. +If the Document specifies that a particular numbered version of this +License "or any later version" applies to it, you have the option of +following the terms and conditions either of that specified version or +of any later version that has been published (not as a draft) by the +Free Software Foundation. If the Document does not specify a version +number of this License, you may choose any version ever published (not +as a draft) by the Free Software Foundation. If the Document +specifies that a proxy can decide which future versions of this +License can be used, that proxy's public statement of acceptance of a +version permanently authorizes you to choose that version for the +Document. + +11. RELICENSING + +"Massive Multiauthor Collaboration Site" (or "MMC Site") means any +World Wide Web server that publishes copyrightable works and also +provides prominent facilities for anybody to edit those works. A +public wiki that anybody can edit is an example of such a server. A +"Massive Multiauthor Collaboration" (or "MMC") contained in the site +means any set of copyrightable works thus published on the MMC site. + +"CC-BY-SA" means the Creative Commons Attribution-Share Alike 3.0 +license published by Creative Commons Corporation, a not-for-profit +corporation with a principal place of business in San Francisco, +California, as well as future copyleft versions of that license +published by that same organization. + +"Incorporate" means to publish or republish a Document, in whole or in +part, as part of another Document. + +An MMC is "eligible for relicensing" if it is licensed under this +License, and if all works that were first published under this License +somewhere other than this MMC, and subsequently incorporated in whole or +in part into the MMC, (1) had no cover texts or invariant sections, and +(2) were thus incorporated prior to November 1, 2008. + +The operator of an MMC Site may republish an MMC contained in the site +under CC-BY-SA on the same site at any time before August 1, 2009, +provided the MMC is eligible for relicensing. + + +ADDENDUM: How to use this License for your documents + +To use this License in a document you have written, include a copy of +the License in the document and put the following copyright and +license notices just after the title page: + + Copyright (c) YEAR YOUR NAME. + Permission is granted to copy, distribute and/or modify this document + under the terms of the GNU Free Documentation License, Version 1.3 + or any later version published by the Free Software Foundation; + with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts. + A copy of the license is included in the section entitled "GNU + Free Documentation License". + +If you have Invariant Sections, Front-Cover Texts and Back-Cover Texts, +replace the "with...Texts." line with this: + + with the Invariant Sections being LIST THEIR TITLES, with the + Front-Cover Texts being LIST, and with the Back-Cover Texts being LIST. + +If you have Invariant Sections without Cover Texts, or some other +combination of the three, merge those two alternatives to suit the +situation. + +If your document contains nontrivial examples of program code, we +recommend releasing these examples in parallel under your choice of +free software license, such as the GNU General Public License, +to permit their use in free software. diff --git a/SOURCES/gnulib.patch b/SOURCES/gnulib.patch new file mode 100644 index 0000000..68e8d51 --- /dev/null +++ b/SOURCES/gnulib.patch @@ -0,0 +1,189 @@ +From 1831628c0630ae96a43586b2a25ca51cbdba3e53 Mon Sep 17 00:00:00 2001 +From: Paul Eggert +Date: Mon, 5 Mar 2018 10:56:29 -0800 +Subject: [PATCH] fflush: adjust to glibc 2.28 libio.h removal +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +Problem reported by Daniel P. Berrangé in: +https://lists.gnu.org/r/bug-gnulib/2018-03/msg00000.html +* lib/fbufmode.c (fbufmode): +* lib/fflush.c (clear_ungetc_buffer_preserving_position) +(disable_seek_optimization, rpl_fflush): +* lib/fpending.c (__fpending): +* lib/fpurge.c (fpurge): +* lib/freadable.c (freadable): +* lib/freadahead.c (freadahead): +* lib/freading.c (freading): +* lib/freadptr.c (freadptr): +* lib/freadseek.c (freadptrinc): +* lib/fseeko.c (fseeko): +* lib/fseterr.c (fseterr): +* lib/fwritable.c (fwritable): +* lib/fwriting.c (fwriting): +Check _IO_EOF_SEEN instead of _IO_ftrylockfile. +* lib/stdio-impl.h (_IO_IN_BACKUP) [_IO_EOF_SEEN]: +Define if not already defined. +--- + ChangeLog | 23 +++++++++++++++++++++++ + lib/fbufmode.c | 2 +- + lib/fflush.c | 6 +++--- + lib/fpending.c | 2 +- + lib/fpurge.c | 2 +- + lib/freadable.c | 2 +- + lib/freadahead.c | 2 +- + lib/freading.c | 2 +- + lib/freadptr.c | 2 +- + lib/freadseek.c | 2 +- + lib/fseeko.c | 4 ++-- + lib/fseterr.c | 2 +- + lib/fwritable.c | 2 +- + lib/fwriting.c | 2 +- + lib/stdio-impl.h | 6 ++++++ + 15 files changed, 45 insertions(+), 16 deletions(-) + +diff --git a/ChangeLog b/ChangeLog +index 667f91663..beb835670 100644 +--- a/ChangeLog ++++ b/ChangeLog +@@ -1,3 +1,26 @@ ++2018-03-05 Paul Eggert ++ ++ fflush: adjust to glibc 2.28 libio.h removal ++ Problem reported by Daniel P. Berrangé in: ++ https://lists.gnu.org/r/bug-gnulib/2018-03/msg00000.html ++ * lib/fbufmode.c (fbufmode): ++ * lib/fflush.c (clear_ungetc_buffer_preserving_position) ++ (disable_seek_optimization, rpl_fflush): ++ * lib/fpending.c (__fpending): ++ * lib/fpurge.c (fpurge): ++ * lib/freadable.c (freadable): ++ * lib/freadahead.c (freadahead): ++ * lib/freading.c (freading): ++ * lib/freadptr.c (freadptr): ++ * lib/freadseek.c (freadptrinc): ++ * lib/fseeko.c (fseeko): ++ * lib/fseterr.c (fseterr): ++ * lib/fwritable.c (fwritable): ++ * lib/fwriting.c (fwriting): ++ Check _IO_EOF_SEEN instead of _IO_ftrylockfile. ++ * lib/stdio-impl.h (_IO_IN_BACKUP) [_IO_EOF_SEEN]: ++ Define if not already defined. ++ + 2018-01-07 Jim Meyering + + version 1.9 + * NEWS: Record release date. +diff --git a/lib/fflush.c b/lib/fflush.c +index 983ade0ff..a6edfa105 100644 +--- a/lib/fflush.c ++++ b/lib/fflush.c +@@ -33,7 +33,7 @@ + #undef fflush + + +-#if defined _IO_ftrylockfile || __GNU_LIBRARY__ == 1 /* GNU libc, BeOS, Haiku, Linux libc5 */ ++#if defined _IO_EOF_SEEN || __GNU_LIBRARY__ == 1 /* GNU libc, BeOS, Haiku, Linux libc5 */ + + /* Clear the stream's ungetc buffer, preserving the value of ftello (fp). */ + static void +@@ -72,7 +72,7 @@ clear_ungetc_buffer (FILE *fp) + + #endif + +-#if ! (defined _IO_ftrylockfile || __GNU_LIBRARY__ == 1 /* GNU libc, BeOS, Haiku, Linux libc5 */) ++#if ! (defined _IO_EOF_SEEN || __GNU_LIBRARY__ == 1 /* GNU libc, BeOS, Haiku, Linux libc5 */) + + # if (defined __sferror || defined __DragonFly__ || defined __ANDROID__) && defined __SNPT + /* FreeBSD, NetBSD, OpenBSD, DragonFly, Mac OS X, Cygwin, Minix 3, Android */ +@@ -148,7 +148,7 @@ rpl_fflush (FILE *stream) + if (stream == NULL || ! freading (stream)) + return fflush (stream); + +-#if defined _IO_ftrylockfile || __GNU_LIBRARY__ == 1 /* GNU libc, BeOS, Haiku, Linux libc5 */ ++#if defined _IO_EOF_SEEN || __GNU_LIBRARY__ == 1 /* GNU libc, BeOS, Haiku, Linux libc5 */ + + clear_ungetc_buffer_preserving_position (stream); + +diff --git a/lib/fpurge.c b/lib/fpurge.c +index b1d417c7a..3aedcc373 100644 +--- a/lib/fpurge.c ++++ b/lib/fpurge.c +@@ -62,7 +62,7 @@ fpurge (FILE *fp) + /* Most systems provide FILE as a struct and the necessary bitmask in + , because they need it for implementing getc() and putc() as + fast macros. */ +-# if defined _IO_ftrylockfile || __GNU_LIBRARY__ == 1 /* GNU libc, BeOS, Haiku, Linux libc5 */ ++# if defined _IO_EOF_SEEN || __GNU_LIBRARY__ == 1 /* GNU libc, BeOS, Haiku, Linux libc5 */ + fp->_IO_read_end = fp->_IO_read_ptr; + fp->_IO_write_ptr = fp->_IO_write_base; + /* Avoid memory leak when there is an active ungetc buffer. */ +diff --git a/lib/freading.c b/lib/freading.c +index 73c28acdd..c24d0c88a 100644 +--- a/lib/freading.c ++++ b/lib/freading.c +@@ -31,7 +31,7 @@ freading (FILE *fp) + /* Most systems provide FILE as a struct and the necessary bitmask in + , because they need it for implementing getc() and putc() as + fast macros. */ +-# if defined _IO_ftrylockfile || __GNU_LIBRARY__ == 1 /* GNU libc, BeOS, Haiku, Linux libc5 */ ++# if defined _IO_EOF_SEEN || __GNU_LIBRARY__ == 1 /* GNU libc, BeOS, Haiku, Linux libc5 */ + return ((fp->_flags & _IO_NO_WRITES) != 0 + || ((fp->_flags & (_IO_NO_READS | _IO_CURRENTLY_PUTTING)) == 0 + && fp->_IO_read_base != NULL)); +diff --git a/lib/fseeko.c b/lib/fseeko.c +index 0101ab55f..193f4e8ce 100644 +--- a/lib/fseeko.c ++++ b/lib/fseeko.c +@@ -47,7 +47,7 @@ fseeko (FILE *fp, off_t offset, int whence) + #endif + + /* These tests are based on fpurge.c. */ +-#if defined _IO_ftrylockfile || __GNU_LIBRARY__ == 1 /* GNU libc, BeOS, Haiku, Linux libc5 */ ++#if defined _IO_EOF_SEEN || __GNU_LIBRARY__ == 1 /* GNU libc, BeOS, Haiku, Linux libc5 */ + if (fp->_IO_read_end == fp->_IO_read_ptr + && fp->_IO_write_ptr == fp->_IO_write_base + && fp->_IO_save_base == NULL) +@@ -123,7 +123,7 @@ fseeko (FILE *fp, off_t offset, int whence) + return -1; + } + +-#if defined _IO_ftrylockfile || __GNU_LIBRARY__ == 1 /* GNU libc, BeOS, Haiku, Linux libc5 */ ++#if defined _IO_EOF_SEEN || __GNU_LIBRARY__ == 1 /* GNU libc, BeOS, Haiku, Linux libc5 */ + fp->_flags &= ~_IO_EOF_SEEN; + fp->_offset = pos; + #elif defined __sferror || defined __DragonFly__ || defined __ANDROID__ +diff --git a/lib/fseterr.c b/lib/fseterr.c +index 82649c3ac..adb637256 100644 +--- a/lib/fseterr.c ++++ b/lib/fseterr.c +@@ -29,7 +29,7 @@ fseterr (FILE *fp) + /* Most systems provide FILE as a struct and the necessary bitmask in + , because they need it for implementing getc() and putc() as + fast macros. */ +-#if defined _IO_ftrylockfile || __GNU_LIBRARY__ == 1 /* GNU libc, BeOS, Haiku, Linux libc5 */ ++#if defined _IO_EOF_SEEN || __GNU_LIBRARY__ == 1 /* GNU libc, BeOS, Haiku, Linux libc5 */ + fp->_flags |= _IO_ERR_SEEN; + #elif defined __sferror || defined __DragonFly__ || defined __ANDROID__ + /* FreeBSD, NetBSD, OpenBSD, DragonFly, Mac OS X, Cygwin, Minix 3, Android */ +diff --git a/lib/stdio-impl.h b/lib/stdio-impl.h +index 78d896e9f..05c5752a2 100644 +--- a/lib/stdio-impl.h ++++ b/lib/stdio-impl.h +@@ -18,6 +18,12 @@ + the same implementation of stdio extension API, except that some fields + have different naming conventions, or their access requires some casts. */ + ++/* Glibc 2.28 made _IO_IN_BACKUP private. For now, work around this ++ problem by defining it ourselves. FIXME: Do not rely on glibc ++ internals. */ ++#if !defined _IO_IN_BACKUP && defined _IO_EOF_SEEN ++# define _IO_IN_BACKUP 0x100 ++#endif + + /* BSD stdio derived implementations. */ + +-- +2.14.3 + diff --git a/SOURCES/gzexe.patch b/SOURCES/gzexe.patch new file mode 100644 index 0000000..e48fa2d --- /dev/null +++ b/SOURCES/gzexe.patch @@ -0,0 +1,75 @@ +From 21cd963565a43dabd59516bd4cca5c76a614f255 Mon Sep 17 00:00:00 2001 +From: Jakub Martisko +Date: Tue, 26 Mar 2019 12:29:30 +0100 +Subject: [PATCH] Fix: the value of the skip variable in the gzexe + +--- + gzexe.in | 4 ++-- + tests/Makefile.am | 1 + + tests/gzexe | 20 ++++++++++++++++++++ + 3 files changed, 23 insertions(+), 2 deletions(-) + create mode 100755 tests/gzexe + +diff --git a/gzexe.in b/gzexe.in +index 6c61183..cffa84e 100644 +--- a/gzexe.in ++++ b/gzexe.in +@@ -145,7 +145,7 @@ for i do + if test $decomp -eq 0; then + (cat <<'EOF' && + #!/bin/sh +-skip=44 ++skip=49 + + tab=' ' + nl=' +@@ -201,7 +201,7 @@ EOF + + else + # decompression +- skip=44 ++ skip=49 + skip_line=`sed -e 1d -e 2q "$file"` + case $skip_line in + skip=[0-9] | skip=[0-9][0-9] | skip=[0-9][0-9][0-9]) +diff --git a/tests/Makefile.am b/tests/Makefile.am +index ebdce5b..4dfbccf 100644 +--- a/tests/Makefile.am ++++ b/tests/Makefile.am +@@ -15,6 +15,7 @@ + # along with this program. If not, see . + + TESTS = \ ++ gzexe \ + gzip-env \ + helin-segv \ + help-version \ +diff --git a/tests/gzexe b/tests/gzexe +new file mode 100755 +index 0000000..45f71c7 +--- /dev/null ++++ b/tests/gzexe +@@ -0,0 +1,20 @@ ++#!/bin/sh ++#Try running simple shell script compressed by gzexe ++ ++. "${srcdir=.}/init.sh"; path_prepend_ .. ++ ++cat < foo || framework_failure_ ++#!/bin/sh ++echo "Hello World!" ++EOF ++ ++echo "Hello World!" > exp || framework_failure_ ++ ++fail=0 ++gzexe foo || fail=1 ++/bin/sh foo > out 2> err || fail=1 ++ ++compare exp out || fail=1 ++test -s err && fail=1 ++ ++Exit $fail +-- +2.21.0 + diff --git a/SOURCES/ibm.patch b/SOURCES/ibm.patch new file mode 100644 index 0000000..b08afd0 --- /dev/null +++ b/SOURCES/ibm.patch @@ -0,0 +1,841 @@ +diff --git a/Makefile.am b/Makefile.am +index 025c914..8b4120c 100644 +--- a/Makefile.am ++++ b/Makefile.am +@@ -55,6 +55,9 @@ gzip_SOURCES = \ + trees.c unlzh.c unlzw.c unpack.c unzip.c util.c zip.c + gzip_LDADD = libver.a lib/libgzip.a + gzip_LDADD += $(LIB_CLOCK_GETTIME) ++if IBM_Z_DFLTCC ++gzip_SOURCES += dfltcc.c ++endif + + BUILT_SOURCES += version.c + version.c: Makefile +diff --git a/bits.c b/bits.c +index b0df2fe..9effc32 100644 +--- a/bits.c ++++ b/bits.c +@@ -78,7 +78,7 @@ + + local file_t zfile; /* output gzip file */ + +-local unsigned short bi_buf; ++unsigned short bi_buf; + /* Output buffer. bits are inserted starting at the bottom (least significant + * bits). + */ +@@ -88,7 +88,7 @@ local unsigned short bi_buf; + * more than 16 bits on some systems.) + */ + +-local int bi_valid; ++int bi_valid; + /* Number of valid bits in bi_buf. All bits above the last valid bit + * are always zero. + */ +diff --git a/configure.ac b/configure.ac +index 9a2b635..76ac26f 100644 +--- a/configure.ac ++++ b/configure.ac +@@ -78,6 +78,16 @@ AC_ARG_ENABLE([gcc-warnings], + fi] + ) + ++AC_ARG_ENABLE([dfltcc], ++ [AS_HELP_STRING([--enable-dfltcc], ++ [use DEFLATE COMPRESSION CALL instruction on IBM Z])], ++ [case $enableval in ++ yes|no) gl_dfltcc=$enableval ;; ++ *) AC_MSG_ERROR([bad value $enableval for dfltcc option]) ;; ++ esac], ++ [gl_dfltcc=no] ++) ++ + # gl_GCC_VERSION_IFELSE([major], [minor], [run-if-found], [run-if-not-found]) + # ------------------------------------------------ + # If $CPP is gcc-MAJOR.MINOR or newer, then run RUN-IF-FOUND. +@@ -188,6 +198,12 @@ if test "$gl_gcc_warnings" = yes; then + AC_SUBST([GNULIB_WARN_CFLAGS]) + fi + ++if test "$gl_dfltcc" = yes; then ++ AC_DEFINE([IBM_Z_DFLTCC], , ++ [Use DEFLATE COMPRESSION CALL instruction on IBM Z machines.]) ++fi ++AM_CONDITIONAL([IBM_Z_DFLTCC], [test "$gl_dfltcc" = yes]) ++ + # cc -E produces incorrect asm files on SVR4, so postprocess it. + ASCPPPOST="sed '/^ *\\#/d; s,//.*,,; s/% /%/g; s/\\. /./g'" + AC_SUBST([ASCPPPOST]) +diff --git a/deflate.c b/deflate.c +index 8ffff3a..869b902 100644 +--- a/deflate.c ++++ b/deflate.c +@@ -123,10 +123,6 @@ + #define NIL 0 + /* Tail of hash chains */ + +-#define FAST 4 +-#define SLOW 2 +-/* speed options for the general purpose bit flag */ +- + #ifndef TOO_FAR + # define TOO_FAR 4096 + #endif +@@ -215,9 +211,6 @@ local unsigned int max_lazy_match; + * max_insert_length is used only for compression levels <= 3. + */ + +-local int compr_level; +-/* compression level (1..9) */ +- + unsigned good_match; + /* Use a faster search when the previous match is longer than this */ + +@@ -308,14 +301,12 @@ local void check_match (IPos start, IPos match, int length); + /* =========================================================================== + * Initialize the "longest match" routines for a new file + */ +-void lm_init (pack_level, flags) ++void lm_init (pack_level) + int pack_level; /* 0: store, 1: best speed, 9: best compression */ +- ush *flags; /* general purpose bit flag */ + { + register unsigned j; + + if (pack_level < 1 || pack_level > 9) gzip_error ("bad pack level"); +- compr_level = pack_level; + + /* Initialize the hash table. */ + #if defined MAXSEG_64K && HASH_BITS == 15 +@@ -337,11 +328,6 @@ void lm_init (pack_level, flags) + nice_match = configuration_table[pack_level].nice_length; + #endif + max_chain_length = configuration_table[pack_level].max_chain; +- if (pack_level == 1) { +- *flags |= FAST; +- } else if (pack_level == 9) { +- *flags |= SLOW; +- } + /* ??? reduce max_chain_length for binary files */ + + strstart = 0; +@@ -732,7 +718,7 @@ local off_t deflate_fast() + * evaluation for matches: a match is finally adopted only if there is + * no better match at the next window position. + */ +-off_t deflate() ++off_t deflate(int pack_level) + { + IPos hash_head; /* head of hash chain */ + IPos prev_match; /* previous match */ +@@ -740,7 +726,8 @@ off_t deflate() + int match_available = 0; /* set if previous match exists */ + register unsigned match_length = MIN_MATCH-1; /* length of best match */ + +- if (compr_level <= 3) return deflate_fast(); /* optimized for speed */ ++ lm_init(pack_level); ++ if (pack_level <= 3) return deflate_fast(); /* optimized for speed */ + + /* Process the input block. */ + while (lookahead != 0) { +diff --git a/dfltcc.c b/dfltcc.c +new file mode 100644 +index 0000000..9010475 +--- /dev/null ++++ b/dfltcc.c +@@ -0,0 +1,429 @@ ++/* dfltcc.c -- compress data using IBM Z DEFLATE COMPRESSION CALL ++ ++ Copyright (C) 2019 Free Software Foundation, Inc. ++ ++ This program is free software; you can redistribute it and/or modify ++ it under the terms of the GNU General Public License as published by ++ the Free Software Foundation; either version 3, or (at your option) ++ any later version. ++ ++ This program is distributed in the hope that it will be useful, ++ but WITHOUT ANY WARRANTY; without even the implied warranty of ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ GNU General Public License for more details. ++ ++ You should have received a copy of the GNU General Public License ++ along with this program; if not, write to the Free Software Foundation, ++ Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ ++ ++#include ++#include ++#ifdef DFLTCC_USDT ++#include ++#endif ++ ++#include "tailor.h" ++#include "gzip.h" ++ ++#ifdef DYN_ALLOC ++ error: DYN_ALLOC is not supported by DFLTCC ++#endif ++ ++/* =========================================================================== ++ * C wrappers for the DEFLATE CONVERSION CALL instruction. ++ */ ++ ++typedef enum ++{ ++ DFLTCC_CC_OK = 0, ++ DFLTCC_CC_OP1_TOO_SHORT = 1, ++ DFLTCC_CC_OP2_TOO_SHORT = 2, ++ DFLTCC_CC_OP2_CORRUPT = 2, ++ DFLTCC_CC_AGAIN = 3, ++} dfltcc_cc; ++ ++#define DFLTCC_QAF 0 ++#define DFLTCC_GDHT 1 ++#define DFLTCC_CMPR 2 ++#define DFLTCC_XPND 4 ++#define HBT_CIRCULAR (1 << 7) ++//#define HB_BITS 15 ++//#define HB_SIZE (1 << HB_BITS) ++#define DFLTCC_FACILITY 151 ++#define DFLTCC_FMT0 0 ++#define CVT_CRC32 0 ++#define HTT_FIXED 0 ++#define HTT_DYNAMIC 1 ++ ++struct dfltcc_qaf_param ++{ ++ char fns[16]; ++ char reserved1[8]; ++ char fmts[2]; ++ char reserved2[6]; ++}; ++ ++struct dfltcc_param_v0 ++{ ++ unsigned short pbvn; /* Parameter-Block-Version Number */ ++ unsigned char mvn; /* Model-Version Number */ ++ unsigned char ribm; /* Reserved for IBM use */ ++ unsigned reserved32 : 31; ++ unsigned cf : 1; /* Continuation Flag */ ++ unsigned char reserved64[8]; ++ unsigned nt : 1; /* New Task */ ++ unsigned reserved129 : 1; ++ unsigned cvt : 1; /* Check Value Type */ ++ unsigned reserved131 : 1; ++ unsigned htt : 1; /* Huffman-Table Type */ ++ unsigned bcf : 1; /* Block-Continuation Flag */ ++ unsigned bcc : 1; /* Block Closing Control */ ++ unsigned bhf : 1; /* Block Header Final */ ++ unsigned reserved136 : 1; ++ unsigned reserved137 : 1; ++ unsigned dhtgc : 1; /* DHT Generation Control */ ++ unsigned reserved139 : 5; ++ unsigned reserved144 : 5; ++ unsigned sbb : 3; /* Sub-Byte Boundary */ ++ unsigned char oesc; /* Operation-Ending-Supplemental Code */ ++ unsigned reserved160 : 12; ++ unsigned ifs : 4; /* Incomplete-Function Status */ ++ unsigned short ifl; /* Incomplete-Function Length */ ++ unsigned char reserved192[8]; ++ unsigned char reserved256[8]; ++ unsigned char reserved320[4]; ++ unsigned short hl; /* History Length */ ++ unsigned reserved368 : 1; ++ unsigned short ho : 15; /* History Offset */ ++ unsigned int cv; /* Check Value */ ++ unsigned eobs : 15; /* End-of-block Symbol */ ++ unsigned reserved431 : 1; ++ unsigned char eobl : 4; /* End-of-block Length */ ++ unsigned reserved436 : 12; ++ unsigned reserved448 : 4; ++ unsigned short cdhtl : 12; /* Compressed-Dynamic-Huffman Table ++ Length */ ++ unsigned char reserved464[6]; ++ unsigned char cdht[288]; ++ unsigned char reserved[32]; ++ unsigned char csb[1152]; ++}; ++ ++static int is_bit_set(const char *bits, int n) ++{ ++ return bits[n / 8] & (1 << (7 - (n % 8))); ++} ++ ++static int is_dfltcc_enabled(void) ++{ ++ const char *env; ++ char facilities[((DFLTCC_FACILITY / 64) + 1) * 8]; ++ register int r0 __asm__("r0"); ++ ++ env = getenv("DFLTCC"); ++ if (env && !strcmp(env, "0")) { ++ return 0; ++ } ++ ++ r0 = sizeof(facilities) / 8; ++ __asm__("stfle %[facilities]\n" ++ : [facilities] "=Q"(facilities) : [r0] "r"(r0) : "cc", "memory"); ++ return is_bit_set((const char *) facilities, DFLTCC_FACILITY); ++} ++ ++static dfltcc_cc dfltcc(int fn, void *param, ++ uch **op1, size_t *len1, ++ const uch **op2, size_t *len2, ++ void *hist) ++{ ++ uch *t2 = op1 ? *op1 : NULL; ++ size_t t3 = len1 ? *len1 : 0; ++ const uch *t4 = op2 ? *op2 : NULL; ++ size_t t5 = len2 ? *len2 : 0; ++ register int r0 __asm__("r0") = fn; ++ register void *r1 __asm__("r1") = param; ++ register uch *r2 __asm__("r2") = t2; ++ register size_t r3 __asm__("r3") = t3; ++ register const uch *r4 __asm__("r4") = t4; ++ register size_t r5 __asm__("r5") = t5; ++ int cc; ++ ++ __asm__ volatile( ++#ifdef DFLTCC_USDT ++ STAP_PROBE_ASM(zlib, dfltcc_entry, ++ STAP_PROBE_ASM_TEMPLATE(5)) ++#endif ++ ".insn rrf,0xb9390000,%[r2],%[r4],%[hist],0\n" ++#ifdef DFLTCC_USDT ++ STAP_PROBE_ASM(zlib, dfltcc_exit, ++ STAP_PROBE_ASM_TEMPLATE(5)) ++#endif ++ "ipm %[cc]\n" ++ : [r2] "+r" (r2) ++ , [r3] "+r" (r3) ++ , [r4] "+r" (r4) ++ , [r5] "+r" (r5) ++ , [cc] "=r" (cc) ++ : [r0] "r" (r0) ++ , [r1] "r" (r1) ++ , [hist] "r" (hist) ++#ifdef DFLTCC_USDT ++ , STAP_PROBE_ASM_OPERANDS(5, r2, r3, r4, r5, hist) ++#endif ++ : "cc", "memory"); ++ t2 = r2; t3 = r3; t4 = r4; t5 = r5; ++ ++ if (op1) ++ *op1 = t2; ++ if (len1) ++ *len1 = t3; ++ if (op2) ++ *op2 = t4; ++ if (len2) ++ *len2 = t5; ++ return (cc >> 28) & 3; ++} ++ ++static void dfltcc_qaf(struct dfltcc_qaf_param *param) ++{ ++ dfltcc(DFLTCC_QAF, param, NULL, NULL, NULL, NULL, NULL); ++} ++ ++static void dfltcc_gdht(struct dfltcc_param_v0 *param) ++{ ++ const uch *next_in = inbuf + inptr; ++ size_t avail_in = insize - inptr; ++ ++ dfltcc(DFLTCC_GDHT, param, NULL, NULL, &next_in, &avail_in, NULL); ++} ++ ++static off_t total_in; ++ ++static dfltcc_cc dfltcc_cmpr_xpnd(struct dfltcc_param_v0 *param, int fn) ++{ ++ uch *next_out = outbuf + outcnt; ++ size_t avail_out = OUTBUFSIZ - outcnt; ++ const uch *next_in = inbuf + inptr; ++ size_t avail_in = insize - inptr; ++ off_t consumed_in; ++ dfltcc_cc cc; ++ ++ cc = dfltcc(fn | HBT_CIRCULAR, param, ++ &next_out, &avail_out, ++ &next_in, &avail_in, ++ window); ++ consumed_in = next_in - (inbuf + inptr); ++ inptr += consumed_in; ++ total_in += consumed_in; ++ outcnt += ((OUTBUFSIZ - outcnt) - avail_out); ++ return cc; ++} ++ ++__attribute__((aligned(8))) ++static struct context ++{ ++ union ++ { ++ struct dfltcc_qaf_param af; ++ struct dfltcc_param_v0 param; ++ }; ++} ctx; ++ ++static struct dfltcc_param_v0 *init_param(struct dfltcc_param_v0 *param) ++{ ++ const char *s; ++ ++ memset(param, 0, sizeof(*param)); ++#ifndef DFLTCC_RIBM ++#define DFLTCC_RIBM 0 ++#endif ++ s = getenv("DFLTCC_RIBM"); ++ param->ribm = (s && *s) ? strtoul(s, NULL, 0) : DFLTCC_RIBM; ++ param->nt = 1; ++ param->cvt = CVT_CRC32; ++ param->cv = __builtin_bswap32(getcrc()); ++ return param; ++} ++ ++static void bi_close_block(struct dfltcc_param_v0 *param) ++{ ++ bi_valid = param->sbb; ++ bi_buf = bi_valid == 0 ? 0 : outbuf[outcnt] & ((1 << bi_valid) - 1); ++ send_bits( ++ bi_reverse(param->eobs >> (15 - param->eobl), param->eobl), ++ param->eobl); ++ param->bcf = 0; ++} ++ ++static void close_block(struct dfltcc_param_v0 *param) ++{ ++ bi_close_block(param); ++ bi_windup(); ++ param->sbb = (param->sbb + param->eobl) % 8; ++ if (param->sbb != 0) { ++ Assert(outcnt > 0, "outbuf must have enough space for EOBS"); ++ outcnt--; ++ } ++} ++ ++static void close_stream(struct dfltcc_param_v0 *param) ++{ ++ if (param->bcf) { ++ bi_close_block(param); ++ } ++ send_bits(1, 3); /* BFINAL=1, BTYPE=00 */ ++ bi_windup(); ++ put_short(0x0000); ++ put_short(0xFFFF); ++} ++ ++#define MAX(a, b) ((a) > (b) ? (a) : (b)) ++ ++/* =========================================================================== ++ * Compress ifd into ofd in hardware or fall back to software. ++ */ ++int dfltcc_deflate(int pack_level) ++{ ++ const char *s; ++ unsigned long level_mask; ++ unsigned long block_size; ++ off_t block_threshold; ++ struct dfltcc_param_v0 *param; ++ int extra; ++ ++ /* Check whether we can use hardware compression */ ++ if (!is_dfltcc_enabled() || getenv("SOURCE_DATE_EPOCH")) { ++ return deflate(pack_level); ++ } ++#ifndef DFLTCC_LEVEL_MASK ++#define DFLTCC_LEVEL_MASK 0x2 ++#endif ++ s = getenv("DFLTCC_LEVEL_MASK"); ++ level_mask = (s && *s) ? strtoul(s, NULL, 0) : DFLTCC_LEVEL_MASK; ++ if ((level_mask & (1 << pack_level)) == 0) { ++ return deflate(pack_level); ++ } ++ dfltcc_qaf(&ctx.af); ++ if (!is_bit_set(ctx.af.fns, DFLTCC_CMPR) || ++ !is_bit_set(ctx.af.fns, DFLTCC_GDHT) || ++ !is_bit_set(ctx.af.fmts, DFLTCC_FMT0)) { ++ return deflate(pack_level); ++ } ++ ++ /* Initialize tuning parameters */ ++#ifndef DFLTCC_BLOCK_SIZE ++#define DFLTCC_BLOCK_SIZE 1048576 ++#endif ++ s = getenv("DFLTCC_BLOCK_SIZE"); ++ block_size = (s && *s) ? strtoul(s, NULL, 0) : DFLTCC_BLOCK_SIZE; ++ (void)block_size; ++#ifndef DFLTCC_FIRST_FHT_BLOCK_SIZE ++#define DFLTCC_FIRST_FHT_BLOCK_SIZE 4096 ++#endif ++ s = getenv("DFLTCC_FIRST_FHT_BLOCK_SIZE"); ++ block_threshold = (s && *s) ? strtoul(s, NULL, 0) : ++ DFLTCC_FIRST_FHT_BLOCK_SIZE; ++ ++ /* Compress ifd into ofd in a loop */ ++ param = init_param(&ctx.param); ++ while (1) { ++ /* Flush the output data */ ++ if (outcnt > OUTBUFSIZ - 8) { ++ flush_outbuf(); ++ } ++ ++ /* Close the block */ ++ if (param->bcf && total_in == block_threshold && !param->cf) { ++ close_block(param); ++ block_threshold += block_size; ++ } ++ ++ /* Read the input data */ ++ if (inptr == insize) { ++ if (fill_inbuf(1) == EOF && !param->cf) { ++ break; ++ } ++ inptr = 0; ++ } ++ ++ /* Temporarily mask some input data */ ++ extra = MAX(0, total_in + (insize - inptr) - block_threshold); ++ insize -= extra; ++ ++ /* Start a new block */ ++ if (!param->bcf) { ++ if (total_in == 0 && block_threshold > 0) { ++ param->htt = HTT_FIXED; ++ } else { ++ param->htt = HTT_DYNAMIC; ++ dfltcc_gdht(param); ++ } ++ } ++ ++ /* Compress inbuf into outbuf */ ++ dfltcc_cmpr_xpnd(param, DFLTCC_CMPR); ++ ++ /* Unmask the input data */ ++ insize += extra; ++ ++ /* Continue the block */ ++ param->bcf = 1; ++ } ++ close_stream(param); ++ setcrc(__builtin_bswap32(param->cv)); ++ return 0; ++} ++ ++/* =========================================================================== ++ * Decompress ifd into ofd in hardware or fall back to software. ++ */ ++int dfltcc_inflate(void) ++{ ++ struct dfltcc_param_v0 *param; ++ dfltcc_cc cc; ++ ++ /* Check whether we can use hardware decompression */ ++ if (!is_dfltcc_enabled()) { ++ return inflate(); ++ } ++ dfltcc_qaf(&ctx.af); ++ if (!is_bit_set(ctx.af.fns, DFLTCC_XPND)) { ++ return inflate(); ++ } ++ ++ /* Decompress ifd into ofd in a loop */ ++ param = init_param(&ctx.param); ++ while (1) { ++ /* Perform I/O */ ++ if (outcnt == OUTBUFSIZ) { ++ flush_outbuf(); ++ } ++ if (inptr == insize) { ++ if (fill_inbuf(1) == EOF) { ++ /* Premature EOF */ ++ return 2; ++ } ++ inptr = 0; ++ } ++ /* Decompress inbuf into outbuf */ ++ cc = dfltcc_cmpr_xpnd(param, DFLTCC_XPND); ++ if (cc == DFLTCC_CC_OK) { ++ /* The entire deflate stream has been successfully decompressed */ ++ break; ++ } ++ if (cc == DFLTCC_CC_OP2_CORRUPT && param->oesc != 0) { ++ /* The deflate stream is corrupted */ ++ return 2; ++ } ++ /* There must be more data to decompress */ ++ } ++ if (param->sbb != 0) { ++ /* The deflate stream has ended in the middle of a byte - go to the next ++ * byte boundary, so that unzip() can read CRC and length. ++ */ ++ inptr++; ++ } ++ setcrc(__builtin_bswap32(param->cv)); /* set CRC value for unzip() */ ++ flush_outbuf(); /* update bytes_out for unzip() */ ++ return 0; ++} +diff --git a/gzip.c b/gzip.c +index 3ddfb7f..4fffc4f 100644 +--- a/gzip.c ++++ b/gzip.c +@@ -128,9 +128,21 @@ static char const *const license_msg[] = { + + /* global buffers */ + ++#ifdef IBM_Z_DFLTCC ++/* DEFLATE COMPRESSION CALL works faster with page-aligned input buffers */ ++__attribute__((aligned(4096))) ++#endif + DECLARE(uch, inbuf, INBUFSIZ +INBUF_EXTRA); ++#ifdef IBM_Z_DFLTCC ++/* DEFLATE COMPRESSION CALL works faster with page-aligned output buffers */ ++__attribute__((aligned(4096))) ++#endif + DECLARE(uch, outbuf, OUTBUFSIZ+OUTBUF_EXTRA); + DECLARE(ush, d_buf, DIST_BUFSIZE); ++#ifdef IBM_Z_DFLTCC ++/* DEFLATE COMPRESSION CALL works only with page-aligned windows */ ++__attribute__((aligned(4096))) ++#endif + DECLARE(uch, window, 2L*WSIZE); + #ifndef MAXSEG_64K + DECLARE(ush, tab_prefix, 1L< $name || framework_failure_ + + fail=0 + + znew -K $name || fail=1 +-test -f $name || fail=1 ++test -f $name || test -f $gzname || fail=1 + + Exit $fail +diff --git a/unzip.c b/unzip.c +index a7255d4..86ef664 100644 +--- a/unzip.c ++++ b/unzip.c +@@ -129,7 +129,11 @@ int unzip(in, out) + /* Decompress */ + if (method == DEFLATED) { + ++#ifdef IBM_Z_DFLTCC ++ int res = dfltcc_inflate(); ++#else + int res = inflate(); ++#endif + + if (res == 3) { + xalloc_die (); +diff --git a/util.c b/util.c +index 41e50d7..dc00f4a 100644 +--- a/util.c ++++ b/util.c +@@ -96,6 +96,11 @@ static const ulg crc_32_tab[] = { + 0x2d02ef8dL + }; + ++/* ======================================================================== ++ * Shift register contents ++ */ ++static ulg crc = (ulg)0xffffffffL; ++ + /* =========================================================================== + * Copy input to output unchanged: zcat == cat with --force. + * IN assertion: insize bytes have already been read in inbuf and inptr bytes +@@ -126,13 +131,11 @@ int copy(in, out) + * Return the current crc in either case. + */ + ulg updcrc(s, n) +- uch *s; /* pointer to bytes to pump through */ ++ const uch *s; /* pointer to bytes to pump through */ + unsigned n; /* number of bytes in s[] */ + { + register ulg c; /* temporary variable */ + +- static ulg crc = (ulg)0xffffffffL; /* shift register contents */ +- + if (s == NULL) { + c = 0xffffffffL; + } else { +@@ -145,6 +148,23 @@ ulg updcrc(s, n) + return c ^ 0xffffffffL; /* (instead of ~c for 64-bit machines) */ + } + ++/* =========================================================================== ++ * Return a current CRC value. ++ */ ++ulg getcrc() ++{ ++ return crc ^ 0xffffffffL; ++} ++ ++/* =========================================================================== ++ * Set a new CRC value. ++ */ ++void setcrc(c) ++ ulg c; ++{ ++ crc = c ^ 0xffffffffL; ++} ++ + /* =========================================================================== + * Clear input and output buffers + */ +@@ -238,7 +258,9 @@ void flush_outbuf() + { + if (outcnt == 0) return; + +- write_buf(ofd, (char *)outbuf, outcnt); ++ if (!test) { ++ write_buf(ofd, (char *)outbuf, outcnt); ++ } + bytes_out += (off_t)outcnt; + outcnt = 0; + } +diff --git a/zip.c b/zip.c +index 1bd4c78..ace7e5e 100644 +--- a/zip.c ++++ b/zip.c +@@ -23,9 +23,12 @@ + #include "tailor.h" + #include "gzip.h" + +-local ulg crc; /* crc on uncompressed file data */ + off_t header_bytes; /* number of bytes in gzip header */ + ++#define FAST 4 ++#define SLOW 2 ++/* speed options for the general purpose bit flag */ ++ + /* =========================================================================== + * Deflate in to out. + * IN assertions: the input and output buffers are cleared. +@@ -68,11 +71,15 @@ int zip(in, out) + put_long (stamp); + + /* Write deflated file to zip file */ +- crc = updcrc(0, 0); ++ updcrc(NULL, 0); + + bi_init(out); + ct_init(&attr, &method); +- lm_init(level, &deflate_flags); ++ if (level == 1) { ++ deflate_flags |= FAST; ++ } else if (level == 9) { ++ deflate_flags |= SLOW; ++ } + + put_byte((uch)deflate_flags); /* extra flags */ + put_byte(OS_CODE); /* OS identifier */ +@@ -85,7 +92,11 @@ int zip(in, out) + } + header_bytes = (off_t)outcnt; + +- (void)deflate(); ++#ifdef IBM_Z_DFLTCC ++ (void)dfltcc_deflate(level); ++#else ++ (void)deflate(level); ++#endif + + #ifndef NO_SIZE_CHECK + /* Check input size +@@ -98,7 +109,7 @@ int zip(in, out) + #endif + + /* Write the crc and uncompressed size */ +- put_long(crc); ++ put_long(getcrc()); + put_long((ulg)bytes_in); + header_bytes += 2*4; + +@@ -126,7 +137,7 @@ int file_read(buf, size) + read_error(); + } + +- crc = updcrc((uch*)buf, len); ++ updcrc((uch*)buf, len); + bytes_in += (off_t)len; + return (int)len; + } +2.21.0 diff --git a/SOURCES/ibm2.patch b/SOURCES/ibm2.patch new file mode 100644 index 0000000..1e4714f --- /dev/null +++ b/SOURCES/ibm2.patch @@ -0,0 +1,1025 @@ +From be0c5581e38332b2ffa8a4cf92076cfde02872b4 Mon Sep 17 00:00:00 2001 +From: Paul Eggert +Date: Tue, 2 Apr 2019 10:26:30 -0700 +Subject: Improve IBM Z patch + +Most of this is minor changes to use GNU style and C99 constructs. +* NEWS: Mention IBM Z. +* bootstrap.conf (gnulib_modules): Add stdalign. +* dfltcc.c: Include stdalign.h, stdbool.h. +(union aligned_dfltcc_qaf_param, union aligned_dfltcc_param_v0): +New types, used for C11-style alignment. All uses changed. +(init_param): +* gzip.c (BUFFER_ALIGNED): New macro. +(inbuf, outbuf, window): Use it, so buffers are aligned everywhere. +* gzip.h (INBUFSIZ, OUTBUFSIZE): Use big buffers everywhere, +unless SMALL_MEM. +* zip.c (SLOW, FAST): Now enums since they need not be macros: +--- + NEWS | 4 + + bootstrap.conf | 1 + + deflate.c | 8 +- + dfltcc.c | 632 +++++++++++++++++++++++++++++---------------------------- + gzip.c | 27 ++- + gzip.h | 16 +- + lib/.gitignore | 1 + + m4/.gitignore | 1 + + unzip.c | 2 +- + util.c | 30 ++- + zip.c | 24 +-- + 11 files changed, 376 insertions(+), 370 deletions(-) + +diff --git a/deflate.c b/deflate.c +index 869b902..eb697af 100644 +--- a/deflate.c ++++ b/deflate.c +@@ -718,7 +718,8 @@ local off_t deflate_fast() + * evaluation for matches: a match is finally adopted only if there is + * no better match at the next window position. + */ +-off_t deflate(int pack_level) ++off_t ++deflate (int pack_level) + { + IPos hash_head; /* head of hash chain */ + IPos prev_match; /* previous match */ +@@ -726,8 +727,9 @@ off_t deflate(int pack_level) + int match_available = 0; /* set if previous match exists */ + register unsigned match_length = MIN_MATCH-1; /* length of best match */ + +- lm_init(pack_level); +- if (pack_level <= 3) return deflate_fast(); /* optimized for speed */ ++ lm_init (pack_level); ++ if (pack_level <= 3) ++ return deflate_fast(); + + /* Process the input block. */ + while (lookahead != 0) { +diff --git a/dfltcc.c b/dfltcc.c +index 9010475..ba62968 100644 +--- a/dfltcc.c ++++ b/dfltcc.c +@@ -17,16 +17,20 @@ + Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ + + #include ++ ++#include ++#include + #include ++ + #ifdef DFLTCC_USDT +-#include ++# include + #endif + + #include "tailor.h" + #include "gzip.h" + + #ifdef DYN_ALLOC +- error: DYN_ALLOC is not supported by DFLTCC ++# error "DYN_ALLOC is not supported by DFLTCC" + #endif + + /* =========================================================================== +@@ -35,11 +39,11 @@ + + typedef enum + { +- DFLTCC_CC_OK = 0, +- DFLTCC_CC_OP1_TOO_SHORT = 1, +- DFLTCC_CC_OP2_TOO_SHORT = 2, +- DFLTCC_CC_OP2_CORRUPT = 2, +- DFLTCC_CC_AGAIN = 3, ++ DFLTCC_CC_OK = 0, ++ DFLTCC_CC_OP1_TOO_SHORT = 1, ++ DFLTCC_CC_OP2_TOO_SHORT = 2, ++ DFLTCC_CC_OP2_CORRUPT = 2, ++ DFLTCC_CC_AGAIN = 3, + } dfltcc_cc; + + #define DFLTCC_QAF 0 +@@ -47,383 +51,391 @@ typedef enum + #define DFLTCC_CMPR 2 + #define DFLTCC_XPND 4 + #define HBT_CIRCULAR (1 << 7) +-//#define HB_BITS 15 +-//#define HB_SIZE (1 << HB_BITS) ++/* #define HB_BITS 15 */ ++/* #define HB_SIZE (1 << HB_BITS) */ + #define DFLTCC_FACILITY 151 + #define DFLTCC_FMT0 0 + #define CVT_CRC32 0 + #define HTT_FIXED 0 + #define HTT_DYNAMIC 1 + ++#ifndef DFLTCC_BLOCK_SIZE ++# define DFLTCC_BLOCK_SIZE 1048576 ++#endif ++#ifndef DFLTCC_FIRST_FHT_BLOCK_SIZE ++# define DFLTCC_FIRST_FHT_BLOCK_SIZE 4096 ++#endif ++#ifndef DFLTCC_LEVEL_MASK ++# define DFLTCC_LEVEL_MASK 0x2 ++#endif ++#ifndef DFLTCC_RIBM ++# define DFLTCC_RIBM 0 ++#endif ++ ++#define MAX(a, b) ((a) > (b) ? (a) : (b)) ++ + struct dfltcc_qaf_param + { +- char fns[16]; +- char reserved1[8]; +- char fmts[2]; +- char reserved2[6]; ++ char fns[16]; ++ char reserved1[8]; ++ char fmts[2]; ++ char reserved2[6]; ++}; ++ ++union aligned_dfltcc_qaf_param ++{ ++ struct dfltcc_qaf_param af; ++ char alignas (8) aligned; + }; + + struct dfltcc_param_v0 + { +- unsigned short pbvn; /* Parameter-Block-Version Number */ +- unsigned char mvn; /* Model-Version Number */ +- unsigned char ribm; /* Reserved for IBM use */ +- unsigned reserved32 : 31; +- unsigned cf : 1; /* Continuation Flag */ +- unsigned char reserved64[8]; +- unsigned nt : 1; /* New Task */ +- unsigned reserved129 : 1; +- unsigned cvt : 1; /* Check Value Type */ +- unsigned reserved131 : 1; +- unsigned htt : 1; /* Huffman-Table Type */ +- unsigned bcf : 1; /* Block-Continuation Flag */ +- unsigned bcc : 1; /* Block Closing Control */ +- unsigned bhf : 1; /* Block Header Final */ +- unsigned reserved136 : 1; +- unsigned reserved137 : 1; +- unsigned dhtgc : 1; /* DHT Generation Control */ +- unsigned reserved139 : 5; +- unsigned reserved144 : 5; +- unsigned sbb : 3; /* Sub-Byte Boundary */ +- unsigned char oesc; /* Operation-Ending-Supplemental Code */ +- unsigned reserved160 : 12; +- unsigned ifs : 4; /* Incomplete-Function Status */ +- unsigned short ifl; /* Incomplete-Function Length */ +- unsigned char reserved192[8]; +- unsigned char reserved256[8]; +- unsigned char reserved320[4]; +- unsigned short hl; /* History Length */ +- unsigned reserved368 : 1; +- unsigned short ho : 15; /* History Offset */ +- unsigned int cv; /* Check Value */ +- unsigned eobs : 15; /* End-of-block Symbol */ +- unsigned reserved431 : 1; +- unsigned char eobl : 4; /* End-of-block Length */ +- unsigned reserved436 : 12; +- unsigned reserved448 : 4; +- unsigned short cdhtl : 12; /* Compressed-Dynamic-Huffman Table +- Length */ +- unsigned char reserved464[6]; +- unsigned char cdht[288]; +- unsigned char reserved[32]; +- unsigned char csb[1152]; ++ unsigned short pbvn; /* Parameter-Block-Version Number */ ++ unsigned char mvn; /* Model-Version Number */ ++ unsigned char ribm; /* Reserved for IBM use */ ++ unsigned reserved32 : 31; ++ unsigned cf : 1; /* Continuation Flag */ ++ unsigned char reserved64[8]; ++ unsigned nt : 1; /* New Task */ ++ unsigned reserved129 : 1; ++ unsigned cvt : 1; /* Check Value Type */ ++ unsigned reserved131 : 1; ++ unsigned htt : 1; /* Huffman-Table Type */ ++ unsigned bcf : 1; /* Block-Continuation Flag */ ++ unsigned bcc : 1; /* Block Closing Control */ ++ unsigned bhf : 1; /* Block Header Final */ ++ unsigned reserved136 : 1; ++ unsigned reserved137 : 1; ++ unsigned dhtgc : 1; /* DHT Generation Control */ ++ unsigned reserved139 : 5; ++ unsigned reserved144 : 5; ++ unsigned sbb : 3; /* Sub-Byte Boundary */ ++ unsigned char oesc; /* Operation-Ending-Supplemental Code */ ++ unsigned reserved160 : 12; ++ unsigned ifs : 4; /* Incomplete-Function Status */ ++ unsigned short ifl; /* Incomplete-Function Length */ ++ unsigned char reserved192[8]; ++ unsigned char reserved256[8]; ++ unsigned char reserved320[4]; ++ unsigned short hl; /* History Length */ ++ unsigned reserved368 : 1; ++ unsigned short ho : 15; /* History Offset */ ++ unsigned int cv; /* Check Value */ ++ unsigned eobs : 15; /* End-of-block Symbol */ ++ unsigned reserved431 : 1; ++ unsigned char eobl : 4; /* End-of-block Length */ ++ unsigned reserved436 : 12; ++ unsigned reserved448 : 4; ++ unsigned short cdhtl : 12; /* Compressed-Dynamic-Huffman Table ++ Length */ ++ unsigned char reserved464[6]; ++ unsigned char cdht[288]; ++ unsigned char reserved[32]; ++ unsigned char csb[1152]; + }; + +-static int is_bit_set(const char *bits, int n) ++union aligned_dfltcc_param_v0 + { +- return bits[n / 8] & (1 << (7 - (n % 8))); ++ struct dfltcc_param_v0 param; ++ char alignas (8) aligned; ++}; ++ ++static int ++is_bit_set (const char *bits, int n) ++{ ++ return bits[n / 8] & (1 << (7 - (n % 8))); + } + +-static int is_dfltcc_enabled(void) ++static int ++is_dfltcc_enabled (void) + { +- const char *env; +- char facilities[((DFLTCC_FACILITY / 64) + 1) * 8]; +- register int r0 __asm__("r0"); ++ char facilities[(DFLTCC_FACILITY / 64 + 1) * 8]; + +- env = getenv("DFLTCC"); +- if (env && !strcmp(env, "0")) { +- return 0; +- } ++ char const *env = getenv ("DFLTCC"); ++ if (env && !strcmp (env, "0")) ++ return 0; + +- r0 = sizeof(facilities) / 8; +- __asm__("stfle %[facilities]\n" +- : [facilities] "=Q"(facilities) : [r0] "r"(r0) : "cc", "memory"); +- return is_bit_set((const char *) facilities, DFLTCC_FACILITY); ++ register int r0 __asm__ ("r0") = sizeof facilities / 8; ++ __asm__ ("stfle %[facilities]\n" ++ : [facilities] "=Q"(facilities) : [r0] "r"(r0) : "cc", "memory"); ++ return is_bit_set (facilities, DFLTCC_FACILITY); + } + +-static dfltcc_cc dfltcc(int fn, void *param, +- uch **op1, size_t *len1, +- const uch **op2, size_t *len2, +- void *hist) ++static dfltcc_cc ++dfltcc (int fn, void *param, ++ uch **op1, size_t *len1, ++ uch const **op2, size_t *len2, ++ void *hist) + { +- uch *t2 = op1 ? *op1 : NULL; +- size_t t3 = len1 ? *len1 : 0; +- const uch *t4 = op2 ? *op2 : NULL; +- size_t t5 = len2 ? *len2 : 0; +- register int r0 __asm__("r0") = fn; +- register void *r1 __asm__("r1") = param; +- register uch *r2 __asm__("r2") = t2; +- register size_t r3 __asm__("r3") = t3; +- register const uch *r4 __asm__("r4") = t4; +- register size_t r5 __asm__("r5") = t5; +- int cc; +- +- __asm__ volatile( ++ uch *t2 = op1 ? *op1 : NULL; ++ size_t t3 = len1 ? *len1 : 0; ++ const uch *t4 = op2 ? *op2 : NULL; ++ size_t t5 = len2 ? *len2 : 0; ++ register int r0 __asm__ ("r0") = fn; ++ register void *r1 __asm__ ("r1") = param; ++ register uch *r2 __asm__ ("r2") = t2; ++ register size_t r3 __asm__ ("r3") = t3; ++ register const uch *r4 __asm__ ("r4") = t4; ++ register size_t r5 __asm__ ("r5") = t5; ++ int cc; ++ ++ __asm__ volatile ( + #ifdef DFLTCC_USDT +- STAP_PROBE_ASM(zlib, dfltcc_entry, +- STAP_PROBE_ASM_TEMPLATE(5)) ++ STAP_PROBE_ASM (zlib, dfltcc_entry, ++ STAP_PROBE_ASM_TEMPLATE (5)) + #endif +- ".insn rrf,0xb9390000,%[r2],%[r4],%[hist],0\n" ++ ".insn rrf,0xb9390000,%[r2],%[r4],%[hist],0\n" + #ifdef DFLTCC_USDT +- STAP_PROBE_ASM(zlib, dfltcc_exit, +- STAP_PROBE_ASM_TEMPLATE(5)) ++ STAP_PROBE_ASM (zlib, dfltcc_exit, ++ STAP_PROBE_ASM_TEMPLATE (5)) + #endif +- "ipm %[cc]\n" +- : [r2] "+r" (r2) +- , [r3] "+r" (r3) +- , [r4] "+r" (r4) +- , [r5] "+r" (r5) +- , [cc] "=r" (cc) +- : [r0] "r" (r0) +- , [r1] "r" (r1) +- , [hist] "r" (hist) ++ "ipm %[cc]\n" ++ : [r2] "+r" (r2) ++ , [r3] "+r" (r3) ++ , [r4] "+r" (r4) ++ , [r5] "+r" (r5) ++ , [cc] "=r" (cc) ++ : [r0] "r" (r0) ++ , [r1] "r" (r1) ++ , [hist] "r" (hist) + #ifdef DFLTCC_USDT +- , STAP_PROBE_ASM_OPERANDS(5, r2, r3, r4, r5, hist) ++ , STAP_PROBE_ASM_OPERANDS (5, r2, r3, r4, r5, hist) + #endif +- : "cc", "memory"); +- t2 = r2; t3 = r3; t4 = r4; t5 = r5; +- +- if (op1) +- *op1 = t2; +- if (len1) +- *len1 = t3; +- if (op2) +- *op2 = t4; +- if (len2) +- *len2 = t5; +- return (cc >> 28) & 3; ++ : "cc", "memory"); ++ t2 = r2; t3 = r3; t4 = r4; t5 = r5; ++ ++ if (op1) ++ *op1 = t2; ++ if (len1) ++ *len1 = t3; ++ if (op2) ++ *op2 = t4; ++ if (len2) ++ *len2 = t5; ++ return (cc >> 28) & 3; + } + +-static void dfltcc_qaf(struct dfltcc_qaf_param *param) ++static void ++dfltcc_qaf (struct dfltcc_qaf_param *param) + { +- dfltcc(DFLTCC_QAF, param, NULL, NULL, NULL, NULL, NULL); ++ dfltcc (DFLTCC_QAF, param, NULL, NULL, NULL, NULL, NULL); + } + +-static void dfltcc_gdht(struct dfltcc_param_v0 *param) ++static void ++dfltcc_gdht (struct dfltcc_param_v0 *param) + { +- const uch *next_in = inbuf + inptr; +- size_t avail_in = insize - inptr; ++ const uch *next_in = inbuf + inptr; ++ size_t avail_in = insize - inptr; + +- dfltcc(DFLTCC_GDHT, param, NULL, NULL, &next_in, &avail_in, NULL); ++ dfltcc (DFLTCC_GDHT, param, NULL, NULL, &next_in, &avail_in, NULL); + } + + static off_t total_in; + +-static dfltcc_cc dfltcc_cmpr_xpnd(struct dfltcc_param_v0 *param, int fn) ++static dfltcc_cc ++dfltcc_cmpr_xpnd (struct dfltcc_param_v0 *param, int fn) + { +- uch *next_out = outbuf + outcnt; +- size_t avail_out = OUTBUFSIZ - outcnt; +- const uch *next_in = inbuf + inptr; +- size_t avail_in = insize - inptr; +- off_t consumed_in; +- dfltcc_cc cc; +- +- cc = dfltcc(fn | HBT_CIRCULAR, param, +- &next_out, &avail_out, +- &next_in, &avail_in, +- window); +- consumed_in = next_in - (inbuf + inptr); +- inptr += consumed_in; +- total_in += consumed_in; +- outcnt += ((OUTBUFSIZ - outcnt) - avail_out); +- return cc; ++ uch *next_out = outbuf + outcnt; ++ size_t avail_out = OUTBUFSIZ - outcnt; ++ const uch *next_in = inbuf + inptr; ++ size_t avail_in = insize - inptr; ++ dfltcc_cc cc = dfltcc (fn | HBT_CIRCULAR, param, ++ &next_out, &avail_out, ++ &next_in, &avail_in, ++ window); ++ off_t consumed_in = next_in - (inbuf + inptr); ++ inptr += consumed_in; ++ total_in += consumed_in; ++ outcnt += ((OUTBUFSIZ - outcnt) - avail_out); ++ return cc; + } + +-__attribute__((aligned(8))) +-static struct context ++static struct dfltcc_param_v0 * ++init_param (union aligned_dfltcc_param_v0 *ctx) + { +- union +- { +- struct dfltcc_qaf_param af; +- struct dfltcc_param_v0 param; +- }; +-} ctx; +- +-static struct dfltcc_param_v0 *init_param(struct dfltcc_param_v0 *param) +-{ +- const char *s; +- +- memset(param, 0, sizeof(*param)); +-#ifndef DFLTCC_RIBM +-#define DFLTCC_RIBM 0 +-#endif +- s = getenv("DFLTCC_RIBM"); +- param->ribm = (s && *s) ? strtoul(s, NULL, 0) : DFLTCC_RIBM; +- param->nt = 1; +- param->cvt = CVT_CRC32; +- param->cv = __builtin_bswap32(getcrc()); +- return param; ++ char const *s = getenv ("DFLTCC_RIBM"); ++ struct dfltcc_param_v0 *param = &ctx->param; ++ memset (param, 0, sizeof *param); ++ param->ribm = s && *s ? strtoul (s, NULL, 0) : DFLTCC_RIBM; ++ param->nt = 1; ++ param->cvt = CVT_CRC32; ++ param->cv = __builtin_bswap32 (getcrc ()); ++ return param; + } + +-static void bi_close_block(struct dfltcc_param_v0 *param) ++static void ++bi_close_block (struct dfltcc_param_v0 *param) + { +- bi_valid = param->sbb; +- bi_buf = bi_valid == 0 ? 0 : outbuf[outcnt] & ((1 << bi_valid) - 1); +- send_bits( +- bi_reverse(param->eobs >> (15 - param->eobl), param->eobl), +- param->eobl); +- param->bcf = 0; ++ bi_valid = param->sbb; ++ bi_buf = bi_valid == 0 ? 0 : outbuf[outcnt] & ((1 << bi_valid) - 1); ++ send_bits (bi_reverse (param->eobs >> (15 - param->eobl), param->eobl), ++ param->eobl); ++ param->bcf = 0; + } + +-static void close_block(struct dfltcc_param_v0 *param) ++static void ++close_block (struct dfltcc_param_v0 *param) + { +- bi_close_block(param); +- bi_windup(); +- param->sbb = (param->sbb + param->eobl) % 8; +- if (param->sbb != 0) { +- Assert(outcnt > 0, "outbuf must have enough space for EOBS"); +- outcnt--; ++ bi_close_block (param); ++ bi_windup (); ++ param->sbb = (param->sbb + param->eobl) % 8; ++ if (param->sbb != 0) ++ { ++ Assert (outcnt > 0, "outbuf must have enough space for EOBS"); ++ outcnt--; + } + } + +-static void close_stream(struct dfltcc_param_v0 *param) ++static void ++close_stream (struct dfltcc_param_v0 *param) + { +- if (param->bcf) { +- bi_close_block(param); +- } +- send_bits(1, 3); /* BFINAL=1, BTYPE=00 */ +- bi_windup(); +- put_short(0x0000); +- put_short(0xFFFF); ++ if (param->bcf) ++ bi_close_block (param); ++ send_bits (1, 3); /* BFINAL=1, BTYPE=00 */ ++ bi_windup (); ++ put_short (0x0000); ++ put_short (0xFFFF); + } + +-#define MAX(a, b) ((a) > (b) ? (a) : (b)) ++/* Compress ifd into ofd in hardware or fall back to software. */ + +-/* =========================================================================== +- * Compress ifd into ofd in hardware or fall back to software. +- */ +-int dfltcc_deflate(int pack_level) ++int ++dfltcc_deflate (int pack_level) + { +- const char *s; +- unsigned long level_mask; +- unsigned long block_size; +- off_t block_threshold; +- struct dfltcc_param_v0 *param; +- int extra; +- +- /* Check whether we can use hardware compression */ +- if (!is_dfltcc_enabled() || getenv("SOURCE_DATE_EPOCH")) { +- return deflate(pack_level); +- } +-#ifndef DFLTCC_LEVEL_MASK +-#define DFLTCC_LEVEL_MASK 0x2 +-#endif +- s = getenv("DFLTCC_LEVEL_MASK"); +- level_mask = (s && *s) ? strtoul(s, NULL, 0) : DFLTCC_LEVEL_MASK; +- if ((level_mask & (1 << pack_level)) == 0) { +- return deflate(pack_level); +- } +- dfltcc_qaf(&ctx.af); +- if (!is_bit_set(ctx.af.fns, DFLTCC_CMPR) || +- !is_bit_set(ctx.af.fns, DFLTCC_GDHT) || +- !is_bit_set(ctx.af.fmts, DFLTCC_FMT0)) { +- return deflate(pack_level); +- } +- +- /* Initialize tuning parameters */ +-#ifndef DFLTCC_BLOCK_SIZE +-#define DFLTCC_BLOCK_SIZE 1048576 +-#endif +- s = getenv("DFLTCC_BLOCK_SIZE"); +- block_size = (s && *s) ? strtoul(s, NULL, 0) : DFLTCC_BLOCK_SIZE; +- (void)block_size; +-#ifndef DFLTCC_FIRST_FHT_BLOCK_SIZE +-#define DFLTCC_FIRST_FHT_BLOCK_SIZE 4096 +-#endif +- s = getenv("DFLTCC_FIRST_FHT_BLOCK_SIZE"); +- block_threshold = (s && *s) ? strtoul(s, NULL, 0) : +- DFLTCC_FIRST_FHT_BLOCK_SIZE; +- +- /* Compress ifd into ofd in a loop */ +- param = init_param(&ctx.param); +- while (1) { +- /* Flush the output data */ +- if (outcnt > OUTBUFSIZ - 8) { +- flush_outbuf(); +- } +- +- /* Close the block */ +- if (param->bcf && total_in == block_threshold && !param->cf) { +- close_block(param); +- block_threshold += block_size; ++ /* Check whether we can use hardware compression. */ ++ if (!is_dfltcc_enabled () || getenv ("SOURCE_DATE_EPOCH")) ++ return deflate (pack_level); ++ char const *s = getenv ("DFLTCC_LEVEL_MASK"); ++ unsigned long level_mask ++ = s && *s ? strtoul (s, NULL, 0) : DFLTCC_LEVEL_MASK; ++ if ((level_mask & (1 << pack_level)) == 0) ++ return deflate (pack_level); ++ union aligned_dfltcc_qaf_param ctx; ++ dfltcc_qaf (&ctx.af); ++ if (!is_bit_set (ctx.af.fns, DFLTCC_CMPR) ++ || !is_bit_set (ctx.af.fns, DFLTCC_GDHT) ++ || !is_bit_set (ctx.af.fmts, DFLTCC_FMT0)) ++ return deflate (pack_level); ++ ++ /* Initialize tuning parameters. */ ++ s = getenv ("DFLTCC_BLOCK_SIZE"); ++ unsigned long block_size ++ = s && *s ? strtoul (s, NULL, 0) : DFLTCC_BLOCK_SIZE; ++ ++ s = getenv ("DFLTCC_FIRST_FHT_BLOCK_SIZE"); ++ off_t block_threshold ++ = s && *s ? strtoul (s, NULL, 0) : DFLTCC_FIRST_FHT_BLOCK_SIZE; ++ ++ union aligned_dfltcc_param_v0 ctx_v0; ++ struct dfltcc_param_v0 *param = init_param (&ctx_v0); ++ ++ /* Compress ifd into ofd in a loop. */ ++ while (true) ++ { ++ /* Flush the output data. */ ++ if (outcnt > OUTBUFSIZ - 8) ++ flush_outbuf (); ++ ++ /* Close the block. */ ++ if (param->bcf && total_in == block_threshold && !param->cf) ++ { ++ close_block (param); ++ block_threshold += block_size; + } + +- /* Read the input data */ +- if (inptr == insize) { +- if (fill_inbuf(1) == EOF && !param->cf) { +- break; +- } +- inptr = 0; ++ /* Read the input data. */ ++ if (inptr == insize) ++ { ++ if (fill_inbuf (1) == EOF && !param->cf) ++ break; ++ inptr = 0; + } + +- /* Temporarily mask some input data */ +- extra = MAX(0, total_in + (insize - inptr) - block_threshold); +- insize -= extra; +- +- /* Start a new block */ +- if (!param->bcf) { +- if (total_in == 0 && block_threshold > 0) { +- param->htt = HTT_FIXED; +- } else { +- param->htt = HTT_DYNAMIC; +- dfltcc_gdht(param); +- } ++ /* Temporarily mask some input data. */ ++ int extra = MAX (0, total_in + (insize - inptr) - block_threshold); ++ insize -= extra; ++ ++ /* Start a new block. */ ++ if (!param->bcf) ++ { ++ if (total_in == 0 && block_threshold > 0) ++ param->htt = HTT_FIXED; ++ else { ++ param->htt = HTT_DYNAMIC; ++ dfltcc_gdht (param); ++ } + } + +- /* Compress inbuf into outbuf */ +- dfltcc_cmpr_xpnd(param, DFLTCC_CMPR); ++ /* Compress inbuf into outbuf. */ ++ dfltcc_cmpr_xpnd (param, DFLTCC_CMPR); + +- /* Unmask the input data */ +- insize += extra; ++ /* Unmask the input data. */ ++ insize += extra; + +- /* Continue the block */ +- param->bcf = 1; ++ /* Continue the block */ ++ param->bcf = 1; + } +- close_stream(param); +- setcrc(__builtin_bswap32(param->cv)); +- return 0; ++ ++ close_stream (param); ++ setcrc (__builtin_bswap32 (param->cv)); ++ return 0; + } + +-/* =========================================================================== +- * Decompress ifd into ofd in hardware or fall back to software. +- */ +-int dfltcc_inflate(void) ++/* Decompress ifd into ofd in hardware or fall back to software. */ ++int ++dfltcc_inflate (void) + { +- struct dfltcc_param_v0 *param; +- dfltcc_cc cc; +- +- /* Check whether we can use hardware decompression */ +- if (!is_dfltcc_enabled()) { +- return inflate(); +- } +- dfltcc_qaf(&ctx.af); +- if (!is_bit_set(ctx.af.fns, DFLTCC_XPND)) { +- return inflate(); +- } +- +- /* Decompress ifd into ofd in a loop */ +- param = init_param(&ctx.param); +- while (1) { +- /* Perform I/O */ +- if (outcnt == OUTBUFSIZ) { +- flush_outbuf(); +- } +- if (inptr == insize) { +- if (fill_inbuf(1) == EOF) { +- /* Premature EOF */ +- return 2; ++ /* Check whether we can use hardware decompression. */ ++ if (!is_dfltcc_enabled ()) ++ return inflate (); ++ union aligned_dfltcc_qaf_param ctx; ++ dfltcc_qaf (&ctx.af); ++ if (!is_bit_set (ctx.af.fns, DFLTCC_XPND)) ++ return inflate (); ++ ++ union aligned_dfltcc_param_v0 ctx_v0; ++ struct dfltcc_param_v0 *param = init_param (&ctx_v0); ++ ++ /* Decompress ifd into ofd in a loop. */ ++ while (true) ++ { ++ /* Perform I/O. */ ++ if (outcnt == OUTBUFSIZ) ++ flush_outbuf (); ++ if (inptr == insize) ++ { ++ if (fill_inbuf (1) == EOF) ++ { ++ /* Premature EOF. */ ++ return 2; + } +- inptr = 0; ++ inptr = 0; + } +- /* Decompress inbuf into outbuf */ +- cc = dfltcc_cmpr_xpnd(param, DFLTCC_XPND); +- if (cc == DFLTCC_CC_OK) { +- /* The entire deflate stream has been successfully decompressed */ ++ ++ /* Decompress inbuf into outbuf. */ ++ dfltcc_cc cc = dfltcc_cmpr_xpnd (param, DFLTCC_XPND); ++ if (cc == DFLTCC_CC_OK) ++ { ++ /* The entire deflate stream has been successfully decompressed. */ + break; +- } +- if (cc == DFLTCC_CC_OP2_CORRUPT && param->oesc != 0) { +- /* The deflate stream is corrupted */ ++ } ++ if (cc == DFLTCC_CC_OP2_CORRUPT && param->oesc != 0) ++ { ++ /* The deflate stream is corrupted. */ + return 2; +- } +- /* There must be more data to decompress */ ++ } ++ /* There must be more data to decompress. */ + } +- if (param->sbb != 0) { +- /* The deflate stream has ended in the middle of a byte - go to the next +- * byte boundary, so that unzip() can read CRC and length. +- */ +- inptr++; ++ ++ if (param->sbb != 0) ++ { ++ /* The deflate stream has ended in the middle of a byte. Go to ++ the next byte boundary, so that unzip can read CRC and length. */ ++ inptr++; + } +- setcrc(__builtin_bswap32(param->cv)); /* set CRC value for unzip() */ +- flush_outbuf(); /* update bytes_out for unzip() */ +- return 0; ++ ++ /* Set CRC value and update bytes_out for unzip. */ ++ setcrc (__builtin_bswap32 (param->cv)); ++ flush_outbuf (); ++ return 0; + } +diff --git a/gzip.c b/gzip.c +index 4fffc4f..f29edaf 100644 +--- a/gzip.c ++++ b/gzip.c +@@ -58,6 +58,7 @@ static char const *const license_msg[] = { + #include + #include + #include ++#include + #include + #include + #include +@@ -128,22 +129,20 @@ static char const *const license_msg[] = { + + /* global buffers */ + +-#ifdef IBM_Z_DFLTCC +-/* DEFLATE COMPRESSION CALL works faster with page-aligned input buffers */ +-__attribute__((aligned(4096))) +-#endif +-DECLARE(uch, inbuf, INBUFSIZ +INBUF_EXTRA); +-#ifdef IBM_Z_DFLTCC +-/* DEFLATE COMPRESSION CALL works faster with page-aligned output buffers */ +-__attribute__((aligned(4096))) ++/* With IBM_Z_DFLTCC, DEFLATE COMPRESSION works faster with ++ page-aligned input and output buffers, and requires page-aligned ++ windows; the alignment requirement is 4096. On other platforms ++ alignment doesn't hurt, and alignment up to 8192 is portable so ++ let's do that. */ ++#ifdef __alignas_is_defined ++# define BUFFER_ALIGNED alignas (8192) ++#else ++# define BUFFER_ALIGNED /**/ + #endif +-DECLARE(uch, outbuf, OUTBUFSIZ+OUTBUF_EXTRA); ++DECLARE(uch BUFFER_ALIGNED, inbuf, INBUFSIZ +INBUF_EXTRA); ++DECLARE(uch BUFFER_ALIGNED, outbuf, OUTBUFSIZ+OUTBUF_EXTRA); + DECLARE(ush, d_buf, DIST_BUFSIZE); +-#ifdef IBM_Z_DFLTCC +-/* DEFLATE COMPRESSION CALL works only with page-aligned windows */ +-__attribute__((aligned(4096))) +-#endif +-DECLARE(uch, window, 2L*WSIZE); ++DECLARE(uch BUFFER_ALIGNED, window, 2L*WSIZE); + #ifndef MAXSEG_64K + DECLARE(ush, tab_prefix, 1L< + #include + +-#ifdef DFLTCC_USDT ++#ifdef HAVE_SYS_SDT_H + # include + #endif + +@@ -39,11 +39,11 @@ + + typedef enum + { +- DFLTCC_CC_OK = 0, +- DFLTCC_CC_OP1_TOO_SHORT = 1, +- DFLTCC_CC_OP2_TOO_SHORT = 2, +- DFLTCC_CC_OP2_CORRUPT = 2, +- DFLTCC_CC_AGAIN = 3, ++ DFLTCC_CC_OK = 0, ++ DFLTCC_CC_OP1_TOO_SHORT = 1, ++ DFLTCC_CC_OP2_TOO_SHORT = 2, ++ DFLTCC_CC_OP2_CORRUPT = 2, ++ DFLTCC_CC_AGAIN = 3, + } dfltcc_cc; + + #define DFLTCC_QAF 0 +@@ -51,8 +51,6 @@ typedef enum + #define DFLTCC_CMPR 2 + #define DFLTCC_XPND 4 + #define HBT_CIRCULAR (1 << 7) +-/* #define HB_BITS 15 */ +-/* #define HB_SIZE (1 << HB_BITS) */ + #define DFLTCC_FACILITY 151 + #define DFLTCC_FMT0 0 + #define CVT_CRC32 0 +@@ -155,9 +153,16 @@ is_dfltcc_enabled (void) + if (env && !strcmp (env, "0")) + return 0; + +- register int r0 __asm__ ("r0") = sizeof facilities / 8; +- __asm__ ("stfle %[facilities]\n" +- : [facilities] "=Q"(facilities) : [r0] "r"(r0) : "cc", "memory"); ++ memset (facilities, 0, sizeof facilities); ++ register char r0 __asm__ ("r0") = sizeof facilities / 8 - 1; ++ /* STFLE is supported since z9-109 and only in z/Architecture mode. When ++ * compiling with -m31, gcc defaults to ESA mode, however, since the kernel ++ * is 64-bit, it's always z/Architecture mode at runtime. */ ++ __asm__ (".machinemode push\n" ++ ".machinemode zarch\n" ++ "stfle %[facilities]\n" ++ ".machinemode pop\n" ++ : [facilities] "=Q"(facilities), [r0] "+r"(r0) :: "cc"); + return is_bit_set (facilities, DFLTCC_FACILITY); + } + +@@ -180,12 +185,12 @@ dfltcc (int fn, void *param, + int cc; + + __asm__ volatile ( +-#ifdef DFLTCC_USDT ++#ifdef HAVE_SYS_SDT_H + STAP_PROBE_ASM (zlib, dfltcc_entry, + STAP_PROBE_ASM_TEMPLATE (5)) + #endif + ".insn rrf,0xb9390000,%[r2],%[r4],%[hist],0\n" +-#ifdef DFLTCC_USDT ++#ifdef HAVE_SYS_SDT_H + STAP_PROBE_ASM (zlib, dfltcc_exit, + STAP_PROBE_ASM_TEMPLATE (5)) + #endif +@@ -198,7 +203,7 @@ dfltcc (int fn, void *param, + : [r0] "r" (r0) + , [r1] "r" (r1) + , [hist] "r" (hist) +-#ifdef DFLTCC_USDT ++#ifdef HAVE_SYS_SDT_H + , STAP_PROBE_ASM_OPERANDS (5, r2, r3, r4, r5, hist) + #endif + : "cc", "memory"); +@@ -264,10 +269,16 @@ init_param (union aligned_dfltcc_param_v0 *ctx) + } + + static void +-bi_close_block (struct dfltcc_param_v0 *param) ++bi_load (struct dfltcc_param_v0 *param) + { + bi_valid = param->sbb; + bi_buf = bi_valid == 0 ? 0 : outbuf[outcnt] & ((1 << bi_valid) - 1); ++} ++ ++static void ++bi_close_block (struct dfltcc_param_v0 *param) ++{ ++ bi_load (param); + send_bits (bi_reverse (param->eobs >> (15 - param->eobl), param->eobl), + param->eobl); + param->bcf = 0; +@@ -278,6 +289,7 @@ close_block (struct dfltcc_param_v0 *param) + { + bi_close_block (param); + bi_windup (); ++ /* bi_windup has written out a possibly partial byte, fix up the position */ + param->sbb = (param->sbb + param->eobl) % 8; + if (param->sbb != 0) + { +@@ -291,6 +303,8 @@ close_stream (struct dfltcc_param_v0 *param) + { + if (param->bcf) + bi_close_block (param); ++ else ++ bi_load (param); + send_bits (1, 3); /* BFINAL=1, BTYPE=00 */ + bi_windup (); + put_short (0x0000); +@@ -334,7 +348,16 @@ dfltcc_deflate (int pack_level) + { + /* Flush the output data. */ + if (outcnt > OUTBUFSIZ - 8) +- flush_outbuf (); ++ { ++ if (param->sbb == 0) ++ flush_outbuf (); ++ else ++ { ++ uch partial = outbuf[outcnt]; ++ flush_outbuf (); ++ outbuf[outcnt] = partial; ++ } ++ } + + /* Close the block. */ + if (param->bcf && total_in == block_threshold && !param->cf) +@@ -360,14 +383,16 @@ dfltcc_deflate (int pack_level) + { + if (total_in == 0 && block_threshold > 0) + param->htt = HTT_FIXED; +- else { +- param->htt = HTT_DYNAMIC; +- dfltcc_gdht (param); +- } ++ else ++ { ++ param->htt = HTT_DYNAMIC; ++ dfltcc_gdht (param); ++ } + } + + /* Compress inbuf into outbuf. */ +- dfltcc_cmpr_xpnd (param, DFLTCC_CMPR); ++ while (dfltcc_cmpr_xpnd (param, DFLTCC_CMPR) == DFLTCC_CC_AGAIN) ++ ; + + /* Unmask the input data. */ + insize += extra; +@@ -413,7 +438,9 @@ dfltcc_inflate (void) + } + + /* Decompress inbuf into outbuf. */ +- dfltcc_cc cc = dfltcc_cmpr_xpnd (param, DFLTCC_XPND); ++ dfltcc_cc cc; ++ while ((cc = dfltcc_cmpr_xpnd (param, DFLTCC_XPND)) == DFLTCC_CC_AGAIN) ++ ; + if (cc == DFLTCC_CC_OK) + { + /* The entire deflate stream has been successfully decompressed. */ +@@ -422,6 +449,9 @@ dfltcc_inflate (void) + if (cc == DFLTCC_CC_OP2_CORRUPT && param->oesc != 0) + { + /* The deflate stream is corrupted. */ ++ fprintf (stderr, "Operation-Ending-Supplemental Code 0x%x\n", ++ param->oesc); ++ flush_outbuf (); + return 2; + } + /* There must be more data to decompress. */ diff --git a/SOURCES/ibm5.patch b/SOURCES/ibm5.patch new file mode 100644 index 0000000..ac85ac2 --- /dev/null +++ b/SOURCES/ibm5.patch @@ -0,0 +1,12 @@ +diff --git a/tests/hufts b/tests/hufts +index 5d8fb77..1b8ab3b 100755 +--- a/tests/hufts ++++ b/tests/hufts +@@ -28,6 +28,7 @@ returns_ 1 gzip -dc "$abs_srcdir/hufts-segv.gz" > out 2> err || fail=1 + compare /dev/null out || fail=1 + + sed 's/.*hufts-segv.gz: /...: /' err > k; mv k err || fail=1 ++grep -v 'Operation-Ending-Supplemental Code' err > k; mv k err || fail=1 + compare exp err || fail=1 + + printf '\037\213\010\000\060\060\060\060\060\060\144\000\000\000' > bug33501 \ diff --git a/SPECS/gzip.spec b/SPECS/gzip.spec new file mode 100644 index 0000000..f74dc19 --- /dev/null +++ b/SPECS/gzip.spec @@ -0,0 +1,558 @@ +Summary: The GNU data compression program +Name: gzip +Version: 1.10 +Release: 8%{?dist} +# info pages are under GFDL license +License: GPLv3+ and GFDL +Source0: http://ftp.gnu.org/gnu/gzip/gzip-%{version}.tar.xz +Source1: https://www.gnu.org/licenses/fdl-1.3.txt + +# downstream solution for coloured z*grep (#1034839) +Source100: colorzgrep.csh +Source101: colorzgrep.sh + +Patch1: gnulib.patch +Patch2: gzexe.patch +Patch3: ibm.patch +Patch4: ibm2.patch +Patch5: ibm4.patch +Patch6: dfltcc-segfault.patch +Patch7: ibm5.patch + +# Fixed in upstream code. +# http://thread.gmane.org/gmane.comp.gnu.gzip.bugs/378 +URL: http://www.gzip.org/ +# Requires should not be added for gzip wrappers (eg. zdiff, zgrep, +# zless) of another tools, because gzip "extends" the tools by its +# wrappers much more than it "requires" them. +Requires: coreutils +BuildRequires: texinfo, gcc, autoconf, automake, less +BuildRequires: make +Conflicts: filesystem < 3 +Provides: /bin/gunzip +Provides: /bin/gzip +Provides: /bin/zcat +# Gzip contains bundled Gnulib +# exception https://fedorahosted.org/fpc/ticket/174 +Provides: bundled(gnulib) + +%description +The gzip package contains the popular GNU gzip data compression +program. Gzipped files have a .gz extension. + +Gzip should be installed on your system, because it is a +very commonly used data compression program. + +%prep +%setup -q +#%patch1 -p1 -b .gnulib +%patch2 -p1 -b .gzexe +%patch3 -p1 +%patch4 -p1 +%patch5 -p1 +%patch6 -p1 +%patch7 -p1 +cp %{SOURCE1} . +autoreconf + +%build +export DEFS="NO_ASM" +export CPPFLAGS="-DHAVE_LSTAT" +export CC="%{__cc}" +export CPP="%{__cpp}" +export CXX="%{__cxx}" + +%ifarch s390x +export CFLAGS="$RPM_OPT_FLAGS -DDFLTCC_LEVEL_MASK=0x7e" +%configure --enable-dfltcc +%else +%configure +%endif + +make +make check +#make gzip.info + +%install +rm -rf ${RPM_BUILD_ROOT} +%makeinstall + +gzip -9nf ${RPM_BUILD_ROOT}%{_infodir}/gzip.info* + +# we don't ship it, so let's remove it from ${RPM_BUILD_ROOT} +rm -f ${RPM_BUILD_ROOT}%{_infodir}/dir +# uncompress is a part of ncompress package +rm -f ${RPM_BUILD_ROOT}/%{_bindir}/uncompress + +# coloured z*grep (#1034839) +%global profiledir %{_sysconfdir}/profile.d +mkdir -p %{buildroot}%{profiledir} +install -p -m 644 %{SOURCE100} %{buildroot}%{profiledir} +install -p -m 644 %{SOURCE101} %{buildroot}%{profiledir} + +%files +%doc NEWS README AUTHORS ChangeLog THANKS TODO +%{!?_licensedir:%global license %%doc} +%license COPYING fdl-1.3.txt +%{_bindir}/* +%{_mandir}/*/* +%{_infodir}/gzip.info* +%{profiledir}/* + +%changelog +* Mon Aug 09 2021 Mohan Boddu - 1.10-8 +- Rebuilt for IMA sigs, glibc 2.34, aarch64 flags + Related: rhbz#1991688 + +* Fri Jul 30 2021 Jakub Martisko - 1.10-7 +- Add the ibm patches dealing with s390x optimizations +Resolves: rhbz#1986357 + +* Fri Jul 30 2021 Jakub Martisko - 1.10-6 +- Add gating tests +Resolves: rhbz#1986357 + +* Fri Apr 16 2021 Mohan Boddu - 1.10-5 +- Rebuilt for RHEL 9 BETA on Apr 15th 2021. Related: rhbz#1947937 + +* Tue Jan 26 2021 Fedora Release Engineering - 1.10-4 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_34_Mass_Rebuild + +* Tue Jul 28 2020 Fedora Release Engineering - 1.10-3 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_33_Mass_Rebuild + +* Wed Jan 29 2020 Fedora Release Engineering - 1.10-2 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_32_Mass_Rebuild + +* Fri Aug 09 2019 Jakub Martisko - 1.10-1 +- Rebase to 1.10 + +* Thu Jul 25 2019 Fedora Release Engineering - 1.9-10 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_31_Mass_Rebuild + +* Tue Mar 26 2019 Jakub Martisko - 1.9-9 +- Fix wrong skip size in gzexe +- Add new test dealing with the ^^ (needs autoreconf) +- Enable make check (needs less) + Related: 1690825 + +* Fri Feb 01 2019 Fedora Release Engineering - 1.9-8 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_30_Mass_Rebuild + +* Thu Jul 26 2018 Jakub Martisko - 1.9-7 +- Fix FTBFS bug (gnulib problems) +- more details: https://lists.gnu.org/r/bug-gnulib/2018-03/msg00000.html + Resolves 1604303 + +* Fri Jul 13 2018 Fedora Release Engineering - 1.9-6 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_29_Mass_Rebuild + +* Thu Mar 01 2018 Jakub Martisko - 1.9-5 +- Fix previous commit (gcc was added to requires instead of buildrequires) + +* Thu Mar 01 2018 Jakub Martisko - 1.9-4 +- Add gcc to buildrequires + +* Fri Feb 09 2018 Igor Gnatenko - 1.9-3 +- Escape macros in %%changelog + +* Wed Feb 07 2018 Fedora Release Engineering - 1.9-2 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_28_Mass_Rebuild + +* Wed Jan 10 2018 Jakub Martisko - 1.9-1 +- rebase to v1.9 + +* Wed Aug 02 2017 Fedora Release Engineering - 1.8-4 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_27_Binutils_Mass_Rebuild + +* Wed Jul 26 2017 Fedora Release Engineering - 1.8-3 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_27_Mass_Rebuild + +* Fri Feb 10 2017 Fedora Release Engineering - 1.8-2 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_26_Mass_Rebuild + +* Fri Jul 01 2016 Petr Stodulka - 1.8-1 +- rebase to v1.8 +- gzip -l no longer falsely reports a write error when writing to a pipe + +* Tue Apr 05 2016 Petr Stodulka - 1.7-1 +- rebase to new upstream version 1.7 +- dropped all patches (almost all issues are fixed in new upstream version, + sometimes in different way) + - only patch gzip-1.3.12-openbsd-owl-tmp.patch is untested - code is changed + significantly and patch is undocumented from archaic time, so I drop it too + Resolves: #1321560 + +* Wed Feb 03 2016 Fedora Release Engineering - 1.6-10 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_24_Mass_Rebuild + +* Thu Jul 09 2015 Petr Stodulka - 1.6-9 +- fix zless for archive with empty file (#1238298) + +* Wed Jun 17 2015 Fedora Release Engineering - 1.6-8 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_23_Mass_Rebuild + +* Sat Feb 21 2015 Till Maas - 1.6-7 +- Rebuilt for Fedora 23 Change + https://fedoraproject.org/wiki/Changes/Harden_all_packages_with_position-independent_code + +* Tue Aug 26 2014 Petr Stodulka - 1.6-7 +- correct changelog + +* Tue Aug 26 2014 Petr Stodulka - 1.6-6 +- changed spec file - build section + obey compiler macros %%__cc, %%__cpp, %%__cxx (#667144) +- zgrep inherits color setup from grep (#1034839) + +* Sat Aug 16 2014 Fedora Release Engineering - 1.6-5 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_21_22_Mass_Rebuild + +* Sat Jul 12 2014 Tom Callaway - 1.6-4 +- fix license handling + +* Fri Jun 06 2014 Petr Stodulka - 1.6-3 +- Added description of rsyncable into the manpage (#988713) + +* Sat Aug 03 2013 Fedora Release Engineering - 1.6-2 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_20_Mass_Rebuild + +* Tue Jun 11 2013 Michal Luscon - 1.6-1 +- New upstream version +- Removed addsuffix.patch + +* Thu Mar 14 2013 Michal Luscon - 1.5-5 +- Adjust gzip-1.3.5-zforce patch + +* Thu Feb 14 2013 Fedora Release Engineering - 1.5-4 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_19_Mass_Rebuild + +* Tue Nov 13 2012 Daniel Drake - 1.5-3 +- Fix "gzip --rsyncable" functionality by removing a spurious blank line from + the patch. + +* Thu Jul 19 2012 Fedora Release Engineering - 1.5-2 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_18_Mass_Rebuild + +* Thu Jun 21 2012 Michal Luscon +- Added bundled(glib) + +* Tue Jun 19 2012 Michal Luscon 1.5-1 +- New upstream version +- Removed gzip-1.3.9-stderr.patch +- Removed gzip-1.3.10-zgreppipe.patch +- Removed gzip-1.3.13-noemptysuffix.patch + +* Wed Jan 25 2012 Harald Hoyer 1.4-6 +- add filesystem guard + +* Wed Jan 25 2012 Harald Hoyer 1.4-5 +- install everything in /usr + https://fedoraproject.org/wiki/Features/UsrMove + +* Fri Jan 13 2012 Fedora Release Engineering - 1.4-4 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_17_Mass_Rebuild + +* Wed Feb 09 2011 Fedora Release Engineering - 1.4-3 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_15_Mass_Rebuild + +* Mon Sep 6 2010 Karel Klic - 1.4-2 +- Removed the dependency on less (rhbz#629580) +- Removed the BuildRoot tag +- Removed the %%clean section + +* Tue Mar 16 2010 Karel Klic - 1.4-1 +- New upstream release +- Use XZ upstream source archive +- Removed cve-2010-0001 patch as it's fixed in this release +- Removed zdiff patch as it's fixed in this release + +* Mon Feb 22 2010 Karel Klic - 1.3.13-3 +- Added a patch to disallow -S '' parameter (noemptysuffix) + +* Fri Jan 22 2010 Karel Klic - 1.3.13-2 +- Fixed CVE-2010-0001 (rhbz#554418) + +* Tue Dec 1 2009 Karel Klic - 1.3.13-1 +- New upstream version +- Updated license from GPLv2 to GPLv3+ +- Removed gzip-1.3.12-futimens.patch, as it is fixed in the new version +- Updated rsync patch to the new upstream version +- Updated cve-2006-4337 patch to use gzip_error instead of error + +* Fri Oct 9 2009 Ivana Varekova - 1.3.12-12 +- change the source tag + +* Tue Aug 11 2009 Ivana Varekova - 1.3.12-11 +- fix installation with --excludedocs option (#515975) + +* Fri Jul 24 2009 Fedora Release Engineering - 1.3.12-10 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_12_Mass_Rebuild + +* Fri Mar 13 2009 Ivana Varekova - 1.3.12-9 +- fix #484213 - zdiff shows no output + +* Tue Feb 24 2009 Fedora Release Engineering - 1.3.12-8 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_11_Mass_Rebuild + +* Mon Sep 1 2008 Ivana Varekova - 1.3.12-7 +- update patches + +* Wed Feb 20 2008 Fedora Release Engineering - 1.3.12-6 +- Autorebuild for GCC 4.3 + +* Fri Jan 18 2008 Ivana Varekova - 1.3.12-5 +- rebuild + +* Tue Aug 28 2007 Fedora Release Engineering - 1.3.12-4 +- Rebuild for selinux ppc32 issue. + +* Fri Jun 15 2007 Ivana Varekova - 1.3.12-3 +- remove useless patches (fixed in upstream version) + +* Mon Jun 11 2007 Ivana Varekova - 1.3.12-2 +- remove useless patches + +* Mon Jun 4 2007 Ivana Varekova - 1.3.12-1 +- update to 1.3.12 + +* Mon Mar 5 2007 Ivana Varekova - 1.3.11-1 +- update to 1.3.11 + remove uncompress + +* Tue Feb 6 2007 Ivana Varekova - 1.3.10-1 +- Resolves: 225878 + update to 1.3.10 + change BuildRoot + +* Mon Jan 22 2007 Ivana Varekova - 1.3.9-2 +- Resolves: 223702 + fix non-failsafe install-info problem + +* Mon Jan 15 2007 Ivana Varekova - 1.3.9-1 +- rebuild to 1.3.9 +- spec cleanup + +* Wed Nov 22 2006 Ivana Varekova - 1.3.5-11 +- fix too strict uncompress function + +* Mon Oct 23 2006 Ivana Varekova - 1.3.5-10 +- fix package description (#208924) + +* Sun Oct 01 2006 Jesse Keating - 1.3.5-9 +- rebuilt for unwind info generation, broken in gcc-4.1.1-21 + +* Wed Sep 20 2006 Ivana Varekova 1.3.5-8 +- fix bug 204676 (patches by Tavis Ormandy) + - cve-2006-4334 - null dereference problem + - cve-2006-4335 - buffer overflow problem + - cve-2006-4336 - buffer underflow problem + - cve-2006-4338 - infinite loop problem + - cve-2006-4337 - buffer overflow problem + +* Fri Jul 14 2006 Karsten Hopp 1.3.5-7 +- buildrequire texinfo, otherwise gzip.info will be empty + +* Wed Jul 12 2006 Jesse Keating - 1.3.5-6.2.2 +- rebuild + +* Fri Feb 10 2006 Jesse Keating - 1.3.5-6.2.1 +- bump again for double-long bug on ppc(64) + +* Tue Feb 07 2006 Jesse Keating - 1.3.5-6.2 +- rebuilt for new gcc4.1 snapshot and glibc changes + +* Fri Dec 09 2005 Jesse Keating +- rebuilt + +* Mon May 02 2005 Ivana Varekova 1.3.5-6 +- rebuilt + +* Fri Apr 29 2005 Ivana Varekova 1.3.5-5 +- fix bug 156269 - CAN-2005-1228 directory traversal bug + (using the patch from Ulf Harnhammar) + +* Tue Apr 26 2005 Ivana Varekova 1.3.5-4 +- fix bug 155746 - CAN-2005-0988 Race condition in gzip (patch9) + +* Wed Mar 23 2005 Tomas Mraz 1.3.5-3 +- don't use the asm code again as it's slower than the gcc compiled one +- convert the .spec to UTF-8 + +* Tue Mar 22 2005 Tomas Mraz 1.3.5-2 +- upstream 1.3.5 +- dropped long ago obsolete dirinfo patch +- escape file names in zgrep (#123012) +- make stack in match.S nonexecutable + +* Fri Mar 04 2005 Jiri Ryska +- rebuilt + +* Mon Dec 13 2004 Ivana Varekova +- fix patch - remove brackets + +* Mon Dec 13 2004 Ivana Varekova +- fix bug #106551 problem with zmore which requires the suffix .gz in file name + +* Tue Jun 15 2004 Elliot Lee +- rebuilt + +* Fri Feb 13 2004 Elliot Lee +- rebuilt + +* Tue Oct 28 2003 Jeff Johnson 1.3.3-11 +- rebuilt. + +* Wed Jun 04 2003 Elliot Lee +- rebuilt + +* Fri Jan 31 2003 Jeff Johnson 1.3.3-9 +- enlarge window buffer to avoid accessing beyond end-of-buffer (#78413,#83095). +- re-enable rsync ready patch. + +* Wed Jan 22 2003 Tim Powers +- rebuilt + +* Fri Nov 22 2002 Jeff Johnson 1.3.3-7 +- workaround mis-compilation with gcc-3.2-4 on alpha for now (#78413). + +* Mon Nov 18 2002 Tim Powers +- rebuild on all arches +- remove file from buildroot we aren't shipping + +* Fri Jun 21 2002 Tim Powers +- automated rebuild + +* Fri Jun 21 2002 Trond Eivind Glomsrød 1.3.3-4 +- Fix the reading of unitialized memory problem (#66913) + +* Thu May 23 2002 Tim Powers +- automated rebuild + +* Thu Apr 25 2002 Trond Eivind Glomsrød 1.3.3-2 +- Rebuild + +* Wed Mar 13 2002 Trond Eivind Glomsrød 1.3.3-1 +- 1.3.3 + +* Sun Mar 10 2002 Florian La Roche +- add rsyncable patch #58888 + +* Thu Feb 21 2002 Trond Eivind Glomsrød 1.3.2-3 +- Rebuild + +* Wed Jan 09 2002 Tim Powers +- automated rebuild + +* Mon Nov 19 2001 Bernhard Rosenkraenzer 1.3.2-1 +- 1.3.2: no need for autoconf 2.5x hacks anymore + +* Sat Nov 17 2001 Florian La Roche +- update to 1.3.1: +- disable patch2 + +* Fri Oct 26 2001 Trond Eivind Glomsrød 1.3.0-16 +- replace tempfile patches with improved ones solar@openwall.com +- Add less to the dependency chain - zless needs it + +* Thu Aug 23 2001 Trond Eivind Glomsrød 1.3.0-15 +- Fix typo in comment in zgrep (#52465) +- Copyright -> License + +* Tue Jun 5 2001 Trond Eivind Glomsrød +- Patch various uses of $$ in the bundled scripts + +* Mon Jun 4 2001 Trond Eivind Glomsrød +- Fix the SIGPIPE patch to avoid blank lines (#43319) + +* Thu Feb 08 2001 Philipp Knirsch +- Fixed buzilla bug #26680. Wrong skip value after mktemp patch and forced + overwrite for output file during decompression. + +* Tue Jan 30 2001 Trond Eivind Glomsrød +- trap SIGPIPE in zgrep, so "zgrep | less" gets a happy ending + (#24104) + +* Sun Dec 10 2000 Trond Eivind Glomsrød +- add HAVE_LSTAT define, to avoid it doing weird things to symlinks + instead of ignoring them as the docs say it should (#22045) + +* Fri Dec 01 2000 Trond Eivind Glomsrød +- rebuild + +* Thu Nov 09 2000 Trond Eivind Glomsrød +- patch all scripts so usage error messages are written to + stderr (#20597) + +* Mon Oct 30 2000 Trond Eivind Glomsrød +- disable assembly, as it is faster without it (bug #19910) + +* Thu Jul 13 2000 Prospector +- automatic rebuild + +* Tue Jun 27 2000 Trond Eivind Glomsrød +- rebuild + +* Wed Jun 07 2000 Trond Eivind Glomsrød +- Use %%{_mandir}, %%{_infodir}, %%configure, %%makeinstall + and %%{_tmppath} + +* Fri May 12 2000 Trond Eivind Glomsrød +- Add root as default owner of the files, permits building + as non-root user + +* Wed May 10 2000 Trond Eivind Glomsrød +- Build system handles stripping +- Don't do thing the system does, like creating directories +- use --bindir /bin +- Added URL +- skip unnecesarry sed step +- Include THANKS, AUTHORS, ChangeLog, TODO + +* Mon Mar 20 2000 Bernhard Rosenkraenzer +- 1.3 +- handle RPM_OPT_FLAGS + +* Tue Feb 15 2000 Cristian Gafton +- handle compressed man pages even better + +* Tue Feb 08 2000 Cristian Gafton +- adopt patch from Paul Eggert to fix detection of the improper tables in + inflate.c(huft_build) +- the latest released version 1.2.4a, which provides documentation updates + only. But it lets us use small revision numbers again +- add an dirinfo entry for gzip.info so we can get rid of the ugly --entry + args to install-info + +* Mon Feb 7 2000 Bill Nottingham +- handle compressed manpages + +* Thu Feb 03 2000 Elliot Lee +- Fix bug #7970 + +* Sun Mar 21 1999 Cristian Gafton +- auto rebuild in the new build environment (release 14) + +* Thu Dec 17 1998 Cristian Gafton +- built against gliibc 2.1 + +* Thu May 07 1998 Prospector System +- translations modified for de, fr, tr + +* Thu Apr 09 1998 Cristian Gafton +- added /usr/bin/gzip and /usr/bin/gunzip symlinks as some programs are too + brain dead to figure out they should be at least trying to use $PATH +- added BuildRoot + +* Wed Jan 28 1998 Erik Troan +- fix /tmp races + +* Sun Sep 14 1997 Erik Troan +- uses install-info +- applied patch for gzexe + +* Mon Jun 02 1997 Erik Troan +- built against glibc + +* Tue Apr 22 1997 Marc Ewing +- (Entry added for Marc by Erik) fixed gzexe to use /bin/gzip +