electrobun 0.0.1 → 0.0.3

package/src/bsdiff/zstd/contrib/linux-kernel/test/macro-test.sh

@@ -1,44 +0,0 @@
-#!/usr/bin/env sh
-
-set -e
-
-SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
-INCLUDE_DIR="$SCRIPT_DIR/../linux/include"
-LIB_DIR="$SCRIPT_DIR/../linux/lib"
-
-
-print() {
-    printf '%b' "${*}"
-}
-
-println() {
-    printf '%b\n' "${*}"
-}
-
-die() {
-    println "$@" 1>&2
-    exit 1
-}
-
-test_not_present() {
-    print "Testing that '$1' is not present... "
-    grep -r $1 "$INCLUDE_DIR" "$LIB_DIR" && die "Fail!"
-    println "Okay"
-}
-
-println "This test checks that the macro removal process worked as expected"
-println "If this test fails, then freestanding.py wasn't able to remove one of these"
-println "macros from the source code completely. You'll either need to rewrite the check"
-println "or improve freestanding.py."
-println ""
-
-test_not_present "ZSTD_NO_INTRINSICS"
-test_not_present "ZSTD_NO_UNUSED_FUNCTIONS"
-test_not_present "ZSTD_LEGACY_SUPPORT"
-test_not_present "STATIC_BMI2"
-test_not_present "ZSTD_DLL_EXPORT"
-test_not_present "ZSTD_DLL_IMPORT"
-test_not_present "__ICCARM__"
-test_not_present "_MSC_VER"
-test_not_present "_WIN32"
-test_not_present "__linux__"

package/src/bsdiff/zstd/contrib/linux-kernel/test/static_test.c

@@ -1,52 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- * You may select, at your option, one of the above-listed licenses.
- */
-#include <stddef.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "decompress_sources.h"
-#include <linux/zstd.h>
-
-#define CONTROL(x)                                                             \
-  do {                                                                         \
-    if (!(x)) {                                                                \
-      fprintf(stderr, "%s:%u: %s failed!\n", __FUNCTION__, __LINE__, #x);      \
-      abort();                                                                 \
-    }                                                                          \
-  } while (0)
-
-
-static const char kEmptyZstdFrame[] = {
-    0x28, 0xb5, 0x2f, 0xfd, 0x24, 0x00, 0x01, 0x00, 0x00, 0x99, 0xe9, 0xd8, 0x51
-};
-
-static void test_decompress_unzstd(void) {
-    fprintf(stderr, "Testing decompress unzstd... ");
-    {
-        size_t const wkspSize = zstd_dctx_workspace_bound();
-        void* wksp = malloc(wkspSize);
-        ZSTD_DCtx* dctx = zstd_init_dctx(wksp, wkspSize);
-        CONTROL(wksp != NULL);
-        CONTROL(dctx != NULL);
-        {
-          size_t const dSize = zstd_decompress_dctx(dctx, NULL, 0, kEmptyZstdFrame, sizeof(kEmptyZstdFrame));
-          CONTROL(!zstd_is_error(dSize));
-          CONTROL(dSize == 0);
-        }
-        free(wksp);
-    }
-    fprintf(stderr, "Ok\n");
-}
-
-int main(void) {
-  test_decompress_unzstd();
-  return 0;
-}

package/src/bsdiff/zstd/contrib/linux-kernel/test/test.c

@@ -1,229 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- * You may select, at your option, one of the above-listed licenses.
- */
-#include <stddef.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include <linux/zstd.h>
-
-#define CONTROL(x)                                                             \
-  do {                                                                         \
-    if (!(x)) {                                                                \
-      fprintf(stderr, "%s:%u: %s failed!\n", __FUNCTION__, __LINE__, #x);      \
-      abort();                                                                 \
-    }                                                                          \
-  } while (0)
-
-typedef struct {
-  char *data;
-  char *data2;
-  size_t dataSize;
-  char *comp;
-  size_t compSize;
-} test_data_t;
-
-static test_data_t create_test_data(void) {
-  test_data_t data;
-  data.dataSize = 128 * 1024;
-  data.data = (char*)malloc(data.dataSize);
-  CONTROL(data.data != NULL);
-  data.data2 = (char*)malloc(data.dataSize);
-  CONTROL(data.data2 != NULL);
-  data.compSize = zstd_compress_bound(data.dataSize);
-  data.comp = (char*)malloc(data.compSize);
-  CONTROL(data.comp != NULL);
-  memset(data.data, 0, data.dataSize);
-  return data;
-}
-
-static void free_test_data(test_data_t const *data) {
-  free(data->data);
-  free(data->data2);
-  free(data->comp);
-}
-
-#define MIN(a, b) ((a) < (b) ? (a) : (b))
-#define MAX(a, b) ((a) > (b) ? (a) : (b))
-
-static void test_btrfs(test_data_t const *data) {
-  size_t const size = MIN(data->dataSize, 128 * 1024);
-  fprintf(stderr, "testing btrfs use cases... ");
-  for (int level = -1; level < 16; ++level) {
-    zstd_parameters params = zstd_get_params(level, size);
-    size_t const workspaceSize =
-        MAX(zstd_cstream_workspace_bound(&params.cParams),
-            zstd_dstream_workspace_bound(size));
-    void *workspace = malloc(workspaceSize);
-
-    char const *ip = data->data;
-    char const *iend = ip + size;
-    char *op = data->comp;
-    char *oend = op + data->compSize;
-
-    CONTROL(params.cParams.windowLog <= 17);
-    CONTROL(workspace != NULL);
-    {
-      zstd_cstream *cctx = zstd_init_cstream(&params, size, workspace, workspaceSize);
-      zstd_out_buffer out = {NULL, 0, 0};
-      zstd_in_buffer in = {NULL, 0, 0};
-      CONTROL(cctx != NULL);
-      for (;;) {
-        if (in.pos == in.size) {
-          in.src = ip;
-          in.size = MIN(4096, iend - ip);
-          in.pos = 0;
-          ip += in.size;
-        }
-
-        if (out.pos == out.size) {
-          out.dst = op;
-          out.size = MIN(4096, oend - op);
-          out.pos = 0;
-          op += out.size;
-        }
-
-        if (ip != iend || in.pos < in.size) {
-          CONTROL(!zstd_is_error(zstd_compress_stream(cctx, &out, &in)));
-        } else {
-          size_t const ret = zstd_end_stream(cctx, &out);
-          CONTROL(!zstd_is_error(ret));
-          if (ret == 0) {
-            break;
-          }
-        }
-      }
-      op += out.pos;
-    }
-
-    ip = data->comp;
-    iend = op;
-    op = data->data2;
-    oend = op + size;
-    {
-      zstd_dstream *dctx = zstd_init_dstream(1ULL << params.cParams.windowLog, workspace, workspaceSize);
-      zstd_out_buffer out = {NULL, 0, 0};
-      zstd_in_buffer in = {NULL, 0, 0};
-      CONTROL(dctx != NULL);
-      for (;;) {
-        if (in.pos == in.size) {
-          in.src = ip;
-          in.size = MIN(4096, iend - ip);
-          in.pos = 0;
-          ip += in.size;
-        }
-
-        if (out.pos == out.size) {
-          out.dst = op;
-          out.size = MIN(4096, oend - op);
-          out.pos = 0;
-          op += out.size;
-        }
-        {
-          size_t const ret = zstd_decompress_stream(dctx, &out, &in);
-          CONTROL(!zstd_is_error(ret));
-          if (ret == 0) {
-            break;
-          }
-        }
-      }
-    }
-    CONTROL((size_t)(op - data->data2) == data->dataSize);
-    CONTROL(!memcmp(data->data, data->data2, data->dataSize));
-    free(workspace);
-  }
-  fprintf(stderr, "Ok\n");
-}
-
-static void test_decompress_unzstd(test_data_t const *data) {
-    size_t cSize;
-    fprintf(stderr, "Testing decompress unzstd... ");
-    {
-        zstd_parameters params = zstd_get_params(19, 0);
-        size_t const wkspSize = zstd_cctx_workspace_bound(&params.cParams);
-        void* wksp = malloc(wkspSize);
-        zstd_cctx* cctx = zstd_init_cctx(wksp, wkspSize);
-        CONTROL(wksp != NULL);
-        CONTROL(cctx != NULL);
-        cSize = zstd_compress_cctx(cctx, data->comp, data->compSize, data->data, data->dataSize, &params);
-        CONTROL(!zstd_is_error(cSize));
-        free(wksp);
-    }
-    {
-        size_t const wkspSize = zstd_dctx_workspace_bound();
-        void* wksp = malloc(wkspSize);
-        zstd_dctx* dctx = zstd_init_dctx(wksp, wkspSize);
-        CONTROL(wksp != NULL);
-        CONTROL(dctx != NULL);
-        {
-          size_t const dSize = zstd_decompress_dctx(dctx, data->data2, data->dataSize, data->comp, cSize);
-          CONTROL(!zstd_is_error(dSize));
-          CONTROL(dSize == data->dataSize);
-        }
-        CONTROL(!memcmp(data->data, data->data2, data->dataSize));
-        free(wksp);
-    }
-    fprintf(stderr, "Ok\n");
-}
-
-static void test_f2fs(void) {
-  fprintf(stderr, "testing f2fs uses... ");
-  CONTROL(zstd_min_clevel() < 0);
-  CONTROL(zstd_max_clevel() == 22);
-  fprintf(stderr, "Ok\n");
-}
-
-static char *g_stack = NULL;
-
-static void __attribute__((noinline)) use(void *x) {
-  asm volatile("" : "+r"(x));
-}
-
-static void __attribute__((noinline)) fill_stack(void) {
-  memset(g_stack, 0x33, 8192);
-}
-
-static void __attribute__((noinline)) set_stack(void) {
-
-  char stack[8192];
-  g_stack = stack;
-  use(g_stack);
-}
-
-static void __attribute__((noinline)) check_stack(void) {
-  size_t cleanStack = 0;
-  while (cleanStack < 8192 && g_stack[cleanStack] == 0x33) {
-    ++cleanStack;
-  }
-  {
-    size_t const stackSize = 8192 - cleanStack;
-    fprintf(stderr, "Maximum stack size: %zu\n", stackSize);
-    CONTROL(stackSize <= 2048 + 512);
-  }
-}
-
-static void test_stack_usage(test_data_t const *data) {
-  set_stack();
-  fill_stack();
-  test_f2fs();
-  test_btrfs(data);
-  test_decompress_unzstd(data);
-  check_stack();
-}
-
-int main(void) {
-  test_data_t data = create_test_data();
-  test_f2fs();
-  test_btrfs(&data);
-  test_decompress_unzstd(&data);
-  test_stack_usage(&data);
-  free_test_data(&data);
-  return 0;
-}

package/src/bsdiff/zstd/contrib/linux-kernel/zstd_common_module.c

@@ -1,29 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0+ OR BSD-3-Clause
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- * You may select, at your option, one of the above-listed licenses.
- */
-
-#include <linux/module.h>
-
-#include "common/huf.h"
-#include "common/fse.h"
-#include "common/zstd_internal.h"
-
-// Export symbols shared by compress and decompress into a common module
-
-#undef ZSTD_isError   /* defined within zstd_internal.h */
-EXPORT_SYMBOL_GPL(FSE_readNCount);
-EXPORT_SYMBOL_GPL(HUF_readStats);
-EXPORT_SYMBOL_GPL(HUF_readStats_wksp);
-EXPORT_SYMBOL_GPL(ZSTD_isError);
-EXPORT_SYMBOL_GPL(ZSTD_getErrorName);
-EXPORT_SYMBOL_GPL(ZSTD_getErrorCode);
-
-MODULE_LICENSE("Dual BSD/GPL");
-MODULE_DESCRIPTION("Zstd Common");

package/src/bsdiff/zstd/contrib/linux-kernel/zstd_compress_module.c

@@ -1,164 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0+ OR BSD-3-Clause
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- * You may select, at your option, one of the above-listed licenses.
- */
-
-#include <linux/kernel.h>
-#include <linux/module.h>
-#include <linux/string.h>
-#include <linux/zstd.h>
-
-#include "common/zstd_deps.h"
-#include "common/zstd_internal.h"
-
-#define ZSTD_FORWARD_IF_ERR(ret)            \
-	do {                                \
-		size_t const __ret = (ret); \
-		if (ZSTD_isError(__ret))    \
-			return __ret;       \
-	} while (0)
-
-static size_t zstd_cctx_init(zstd_cctx *cctx, const zstd_parameters *parameters,
-	unsigned long long pledged_src_size)
-{
-	ZSTD_FORWARD_IF_ERR(ZSTD_CCtx_reset(
-		cctx, ZSTD_reset_session_and_parameters));
-	ZSTD_FORWARD_IF_ERR(ZSTD_CCtx_setPledgedSrcSize(
-		cctx, pledged_src_size));
-	ZSTD_FORWARD_IF_ERR(ZSTD_CCtx_setParameter(
-		cctx, ZSTD_c_windowLog, parameters->cParams.windowLog));
-	ZSTD_FORWARD_IF_ERR(ZSTD_CCtx_setParameter(
-		cctx, ZSTD_c_hashLog, parameters->cParams.hashLog));
-	ZSTD_FORWARD_IF_ERR(ZSTD_CCtx_setParameter(
-		cctx, ZSTD_c_chainLog, parameters->cParams.chainLog));
-	ZSTD_FORWARD_IF_ERR(ZSTD_CCtx_setParameter(
-		cctx, ZSTD_c_searchLog, parameters->cParams.searchLog));
-	ZSTD_FORWARD_IF_ERR(ZSTD_CCtx_setParameter(
-		cctx, ZSTD_c_minMatch, parameters->cParams.minMatch));
-	ZSTD_FORWARD_IF_ERR(ZSTD_CCtx_setParameter(
-		cctx, ZSTD_c_targetLength, parameters->cParams.targetLength));
-	ZSTD_FORWARD_IF_ERR(ZSTD_CCtx_setParameter(
-		cctx, ZSTD_c_strategy, parameters->cParams.strategy));
-	ZSTD_FORWARD_IF_ERR(ZSTD_CCtx_setParameter(
-		cctx, ZSTD_c_contentSizeFlag, parameters->fParams.contentSizeFlag));
-	ZSTD_FORWARD_IF_ERR(ZSTD_CCtx_setParameter(
-		cctx, ZSTD_c_checksumFlag, parameters->fParams.checksumFlag));
-	ZSTD_FORWARD_IF_ERR(ZSTD_CCtx_setParameter(
-		cctx, ZSTD_c_dictIDFlag, !parameters->fParams.noDictIDFlag));
-	return 0;
-}
-
-int zstd_min_clevel(void)
-{
-	return ZSTD_minCLevel();
-}
-EXPORT_SYMBOL(zstd_min_clevel);
-
-int zstd_max_clevel(void)
-{
-	return ZSTD_maxCLevel();
-}
-EXPORT_SYMBOL(zstd_max_clevel);
-
-size_t zstd_compress_bound(size_t src_size)
-{
-	return ZSTD_compressBound(src_size);
-}
-EXPORT_SYMBOL(zstd_compress_bound);
-
-zstd_parameters zstd_get_params(int level,
-	unsigned long long estimated_src_size)
-{
-	return ZSTD_getParams(level, estimated_src_size, 0);
-}
-EXPORT_SYMBOL(zstd_get_params);
-
-size_t zstd_cctx_workspace_bound(const zstd_compression_parameters *cparams)
-{
-	return ZSTD_estimateCCtxSize_usingCParams(*cparams);
-}
-EXPORT_SYMBOL(zstd_cctx_workspace_bound);
-
-zstd_cctx *zstd_init_cctx(void *workspace, size_t workspace_size)
-{
-	if (workspace == NULL)
-		return NULL;
-	return ZSTD_initStaticCCtx(workspace, workspace_size);
-}
-EXPORT_SYMBOL(zstd_init_cctx);
-
-size_t zstd_compress_cctx(zstd_cctx *cctx, void *dst, size_t dst_capacity,
-	const void *src, size_t src_size, const zstd_parameters *parameters)
-{
-	ZSTD_FORWARD_IF_ERR(zstd_cctx_init(cctx, parameters, src_size));
-	return ZSTD_compress2(cctx, dst, dst_capacity, src, src_size);
-}
-EXPORT_SYMBOL(zstd_compress_cctx);
-
-size_t zstd_cstream_workspace_bound(const zstd_compression_parameters *cparams)
-{
-	return ZSTD_estimateCStreamSize_usingCParams(*cparams);
-}
-EXPORT_SYMBOL(zstd_cstream_workspace_bound);
-
-zstd_cstream *zstd_init_cstream(const zstd_parameters *parameters,
-	unsigned long long pledged_src_size, void *workspace, size_t workspace_size)
-{
-	zstd_cstream *cstream;
-
-	if (workspace == NULL)
-		return NULL;
-
-	cstream = ZSTD_initStaticCStream(workspace, workspace_size);
-	if (cstream == NULL)
-		return NULL;
-
-	/* 0 means unknown in linux zstd API but means 0 in new zstd API */
-	if (pledged_src_size == 0)
-		pledged_src_size = ZSTD_CONTENTSIZE_UNKNOWN;
-
-	if (ZSTD_isError(zstd_cctx_init(cstream, parameters, pledged_src_size)))
-		return NULL;
-
-	return cstream;
-}
-EXPORT_SYMBOL(zstd_init_cstream);
-
-size_t zstd_reset_cstream(zstd_cstream *cstream,
-	unsigned long long pledged_src_size)
-{
-	if (pledged_src_size == 0)
-		pledged_src_size = ZSTD_CONTENTSIZE_UNKNOWN;
-	ZSTD_FORWARD_IF_ERR( ZSTD_CCtx_reset(cstream, ZSTD_reset_session_only) );
-	ZSTD_FORWARD_IF_ERR( ZSTD_CCtx_setPledgedSrcSize(cstream, pledged_src_size) );
-	return 0;
-}
-EXPORT_SYMBOL(zstd_reset_cstream);
-
-size_t zstd_compress_stream(zstd_cstream *cstream, zstd_out_buffer *output,
-	zstd_in_buffer *input)
-{
-	return ZSTD_compressStream(cstream, output, input);
-}
-EXPORT_SYMBOL(zstd_compress_stream);
-
-size_t zstd_flush_stream(zstd_cstream *cstream, zstd_out_buffer *output)
-{
-	return ZSTD_flushStream(cstream, output);
-}
-EXPORT_SYMBOL(zstd_flush_stream);
-
-size_t zstd_end_stream(zstd_cstream *cstream, zstd_out_buffer *output)
-{
-	return ZSTD_endStream(cstream, output);
-}
-EXPORT_SYMBOL(zstd_end_stream);
-
-MODULE_LICENSE("Dual BSD/GPL");
-MODULE_DESCRIPTION("Zstd Compressor");

package/src/bsdiff/zstd/contrib/linux-kernel/zstd_decompress_module.c

@@ -1,105 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0+ OR BSD-3-Clause
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- * You may select, at your option, one of the above-listed licenses.
- */
-
-#include <linux/kernel.h>
-#include <linux/module.h>
-#include <linux/string.h>
-#include <linux/zstd.h>
-
-#include "common/zstd_deps.h"
-
-/* Common symbols. zstd_compress must depend on zstd_decompress. */
-
-unsigned int zstd_is_error(size_t code)
-{
-	return ZSTD_isError(code);
-}
-EXPORT_SYMBOL(zstd_is_error);
-
-zstd_error_code zstd_get_error_code(size_t code)
-{
-	return ZSTD_getErrorCode(code);
-}
-EXPORT_SYMBOL(zstd_get_error_code);
-
-const char *zstd_get_error_name(size_t code)
-{
-	return ZSTD_getErrorName(code);
-}
-EXPORT_SYMBOL(zstd_get_error_name);
-
-/* Decompression symbols. */
-
-size_t zstd_dctx_workspace_bound(void)
-{
-	return ZSTD_estimateDCtxSize();
-}
-EXPORT_SYMBOL(zstd_dctx_workspace_bound);
-
-zstd_dctx *zstd_init_dctx(void *workspace, size_t workspace_size)
-{
-	if (workspace == NULL)
-		return NULL;
-	return ZSTD_initStaticDCtx(workspace, workspace_size);
-}
-EXPORT_SYMBOL(zstd_init_dctx);
-
-size_t zstd_decompress_dctx(zstd_dctx *dctx, void *dst, size_t dst_capacity,
-	const void *src, size_t src_size)
-{
-	return ZSTD_decompressDCtx(dctx, dst, dst_capacity, src, src_size);
-}
-EXPORT_SYMBOL(zstd_decompress_dctx);
-
-size_t zstd_dstream_workspace_bound(size_t max_window_size)
-{
-	return ZSTD_estimateDStreamSize(max_window_size);
-}
-EXPORT_SYMBOL(zstd_dstream_workspace_bound);
-
-zstd_dstream *zstd_init_dstream(size_t max_window_size, void *workspace,
-	size_t workspace_size)
-{
-	if (workspace == NULL)
-		return NULL;
-	(void)max_window_size;
-	return ZSTD_initStaticDStream(workspace, workspace_size);
-}
-EXPORT_SYMBOL(zstd_init_dstream);
-
-size_t zstd_reset_dstream(zstd_dstream *dstream)
-{
-	return ZSTD_DCtx_reset(dstream, ZSTD_reset_session_only);
-}
-EXPORT_SYMBOL(zstd_reset_dstream);
-
-size_t zstd_decompress_stream(zstd_dstream *dstream, zstd_out_buffer *output,
-	zstd_in_buffer *input)
-{
-	return ZSTD_decompressStream(dstream, output, input);
-}
-EXPORT_SYMBOL(zstd_decompress_stream);
-
-size_t zstd_find_frame_compressed_size(const void *src, size_t src_size)
-{
-	return ZSTD_findFrameCompressedSize(src, src_size);
-}
-EXPORT_SYMBOL(zstd_find_frame_compressed_size);
-
-size_t zstd_get_frame_header(zstd_frame_header *header, const void *src,
-	size_t src_size)
-{
-	return ZSTD_getFrameHeader(header, src, src_size);
-}
-EXPORT_SYMBOL(zstd_get_frame_header);
-
-MODULE_LICENSE("Dual BSD/GPL");
-MODULE_DESCRIPTION("Zstd Decompressor");