[contrib][linux] Follow style guide more closely

diff --git a/contrib/linux-kernel/linux_zstd.h b/contrib/linux-kernel/linux_zstd.h
index 415744950e6aa533283b4bcf43bc37775259dd56..b926840428509fe59efa42c5a0c8b4df8bd6be72 100644 (file)
--- a/contrib/linux-kernel/linux_zstd.h
+++ b/contrib/linux-kernel/linux_zstd.h
@@ -58,7 +58,7 @@ int zstd_get_error_code(size_t code);
  *
  * Return: An error string corresponding to the error code.
  */
-const char* zstd_get_error_name(size_t code);
+const char *zstd_get_error_name(size_t code);
 
 /* ======   Parameter Selection   ====== */
 
@@ -136,7 +136,7 @@ struct zstd_parameters {
  * @level:              The compression level
  * @estimated_src_size: The estimated source size to compress or 0
  *                      if unknown.
- * 
+ *
  * Return:              The selected zstd_parameters.
  */
 struct zstd_parameters zstd_get_params(int level,
@@ -185,7 +185,7 @@ zstd_cctx *zstd_init_cctx(void *workspace, size_t workspace_size);
  *                zstd_is_error().
  */
 size_t zstd_compress_cctx(zstd_cctx *cctx, void *dst, size_t dst_capacity,
-       const void *src, size_t src_size, const struct zstd_parameters* parameters);
+       const void *src, size_t src_size, const struct zstd_parameters *parameters);
 
 /* ======   Single-pass Decompression   ====== */
 
@@ -375,7 +375,7 @@ size_t zstd_dstream_workspace_bound(size_t max_window_size);
  *
  * Return:           The zstd streaming decompression context.
  */
-zstd_dstream *zstd_init_dstream(size_t max_window_size, void* workspace,
+zstd_dstream *zstd_init_dstream(size_t max_window_size, void *workspace,
        size_t workspace_size);
 
 /**

diff --git a/contrib/linux-kernel/zstd_compress_module.c b/contrib/linux-kernel/zstd_compress_module.c
index 1e917e722543a22699a657b153b32248e9f9fa57..bab79afb0f00722333ea3d6641df773f669b9788 100644 (file)
--- a/contrib/linux-kernel/zstd_compress_module.c
+++ b/contrib/linux-kernel/zstd_compress_module.c
@@ -11,22 +11,37 @@
 
 static void zstd_check_structs(void) {
        /* Check that the structs have the same size. */
-       ZSTD_STATIC_ASSERT(sizeof(ZSTD_parameters) == sizeof(struct zstd_parameters));
-       ZSTD_STATIC_ASSERT(sizeof(ZSTD_compressionParameters) == sizeof(struct zstd_compression_parameters));
-       ZSTD_STATIC_ASSERT(sizeof(ZSTD_frameParameters) == sizeof(struct zstd_frame_parameters));
+       ZSTD_STATIC_ASSERT(sizeof(ZSTD_parameters) ==
+               sizeof(struct zstd_parameters));
+       ZSTD_STATIC_ASSERT(sizeof(ZSTD_compressionParameters) ==
+               sizeof(struct zstd_compression_parameters));
+       ZSTD_STATIC_ASSERT(sizeof(ZSTD_frameParameters) ==
+               sizeof(struct zstd_frame_parameters));
        /* Zstd guarantees that the layout of the structs never change. Verify it. */
-       ZSTD_STATIC_ASSERT(offsetof(ZSTD_parameters, cParams) == offsetof(struct zstd_parameters, cparams));
-       ZSTD_STATIC_ASSERT(offsetof(ZSTD_parameters, fParams) == offsetof(struct zstd_parameters, fparams));
-       ZSTD_STATIC_ASSERT(offsetof(ZSTD_compressionParameters, windowLog) == offsetof(struct zstd_compression_parameters, window_log));
-       ZSTD_STATIC_ASSERT(offsetof(ZSTD_compressionParameters, chainLog) == offsetof(struct zstd_compression_parameters, chain_log));
-       ZSTD_STATIC_ASSERT(offsetof(ZSTD_compressionParameters, hashLog) == offsetof(struct zstd_compression_parameters, hash_log));
-       ZSTD_STATIC_ASSERT(offsetof(ZSTD_compressionParameters, searchLog) == offsetof(struct zstd_compression_parameters, search_log));
-       ZSTD_STATIC_ASSERT(offsetof(ZSTD_compressionParameters, minMatch) == offsetof(struct zstd_compression_parameters, search_length));
-       ZSTD_STATIC_ASSERT(offsetof(ZSTD_compressionParameters, targetLength) == offsetof(struct zstd_compression_parameters, target_length));
-       ZSTD_STATIC_ASSERT(offsetof(ZSTD_compressionParameters, strategy) == offsetof(struct zstd_compression_parameters, strategy));
-       ZSTD_STATIC_ASSERT(offsetof(ZSTD_frameParameters, contentSizeFlag) == offsetof(struct zstd_frame_parameters, content_size_flag));
-       ZSTD_STATIC_ASSERT(offsetof(ZSTD_frameParameters, checksumFlag) == offsetof(struct zstd_frame_parameters, checksum_flag));
-       ZSTD_STATIC_ASSERT(offsetof(ZSTD_frameParameters, noDictIDFlag) == offsetof(struct zstd_frame_parameters, no_dict_id_flag));
+       ZSTD_STATIC_ASSERT(offsetof(ZSTD_parameters, cParams) ==
+               offsetof(struct zstd_parameters, cparams));
+       ZSTD_STATIC_ASSERT(offsetof(ZSTD_parameters, fParams) ==
+               offsetof(struct zstd_parameters, fparams));
+       ZSTD_STATIC_ASSERT(offsetof(ZSTD_compressionParameters, windowLog) ==
+               offsetof(struct zstd_compression_parameters, window_log));
+       ZSTD_STATIC_ASSERT(offsetof(ZSTD_compressionParameters, chainLog) ==
+               offsetof(struct zstd_compression_parameters, chain_log));
+       ZSTD_STATIC_ASSERT(offsetof(ZSTD_compressionParameters, hashLog) ==
+               offsetof(struct zstd_compression_parameters, hash_log));
+       ZSTD_STATIC_ASSERT(offsetof(ZSTD_compressionParameters, searchLog) ==
+               offsetof(struct zstd_compression_parameters, search_log));
+       ZSTD_STATIC_ASSERT(offsetof(ZSTD_compressionParameters, minMatch) ==
+               offsetof(struct zstd_compression_parameters, search_length));
+       ZSTD_STATIC_ASSERT(offsetof(ZSTD_compressionParameters, targetLength) ==
+               offsetof(struct zstd_compression_parameters, target_length));
+       ZSTD_STATIC_ASSERT(offsetof(ZSTD_compressionParameters, strategy) ==
+               offsetof(struct zstd_compression_parameters, strategy));
+       ZSTD_STATIC_ASSERT(offsetof(ZSTD_frameParameters, contentSizeFlag) ==
+               offsetof(struct zstd_frame_parameters, content_size_flag));
+       ZSTD_STATIC_ASSERT(offsetof(ZSTD_frameParameters, checksumFlag) ==
+               offsetof(struct zstd_frame_parameters, checksum_flag));
+       ZSTD_STATIC_ASSERT(offsetof(ZSTD_frameParameters, noDictIDFlag) ==
+               offsetof(struct zstd_frame_parameters, no_dict_id_flag));
        /* Check that the strategies are the same. This can change. */
        ZSTD_STATIC_ASSERT((int)ZSTD_fast == (int)zstd_fast);
        ZSTD_STATIC_ASSERT((int)ZSTD_dfast == (int)zstd_dfast);
@@ -39,14 +54,21 @@ static void zstd_check_structs(void) {
        ZSTD_STATIC_ASSERT((int)ZSTD_btultra2 == (int)zstd_btultra2);
        /* Check input buffer */
        ZSTD_STATIC_ASSERT(sizeof(ZSTD_inBuffer) == sizeof(struct zstd_in_buffer));
-       ZSTD_STATIC_ASSERT(offsetof(ZSTD_inBuffer, src) == offsetof(struct zstd_in_buffer, src));
-       ZSTD_STATIC_ASSERT(offsetof(ZSTD_inBuffer, size) == offsetof(struct zstd_in_buffer, size));
-       ZSTD_STATIC_ASSERT(offsetof(ZSTD_inBuffer, pos) == offsetof(struct zstd_in_buffer, pos));
+       ZSTD_STATIC_ASSERT(offsetof(ZSTD_inBuffer, src) ==
+               offsetof(struct zstd_in_buffer, src));
+       ZSTD_STATIC_ASSERT(offsetof(ZSTD_inBuffer, size) ==
+               offsetof(struct zstd_in_buffer, size));
+       ZSTD_STATIC_ASSERT(offsetof(ZSTD_inBuffer, pos) ==
+               offsetof(struct zstd_in_buffer, pos));
        /* Check output buffer */
-       ZSTD_STATIC_ASSERT(sizeof(ZSTD_outBuffer) == sizeof(struct zstd_out_buffer));
-       ZSTD_STATIC_ASSERT(offsetof(ZSTD_outBuffer, dst) == offsetof(struct zstd_out_buffer, dst));
-       ZSTD_STATIC_ASSERT(offsetof(ZSTD_outBuffer, size) == offsetof(struct zstd_out_buffer, size));
-       ZSTD_STATIC_ASSERT(offsetof(ZSTD_outBuffer, pos) == offsetof(struct zstd_out_buffer, pos));
+       ZSTD_STATIC_ASSERT(sizeof(ZSTD_outBuffer) ==
+               sizeof(struct zstd_out_buffer));
+       ZSTD_STATIC_ASSERT(offsetof(ZSTD_outBuffer, dst) ==
+               offsetof(struct zstd_out_buffer, dst));
+       ZSTD_STATIC_ASSERT(offsetof(ZSTD_outBuffer, size) ==
+               offsetof(struct zstd_out_buffer, size));
+       ZSTD_STATIC_ASSERT(offsetof(ZSTD_outBuffer, pos) ==
+               offsetof(struct zstd_out_buffer, pos));
 }
 
 size_t zstd_compress_bound(size_t src_size)
@@ -55,7 +77,8 @@ size_t zstd_compress_bound(size_t src_size)
 }
 EXPORT_SYMBOL(zstd_compress_bound);
 
-struct zstd_parameters zstd_get_params(int level, unsigned long long estimated_src_size)
+struct zstd_parameters zstd_get_params(int level,
+       unsigned long long estimated_src_size)
 {
        const ZSTD_parameters params = ZSTD_getParams(level, estimated_src_size, 0);
        struct zstd_parameters out;
@@ -67,7 +90,8 @@ struct zstd_parameters zstd_get_params(int level, unsigned long long estimated_s
 }
 EXPORT_SYMBOL(zstd_get_params);
 
-size_t zstd_cctx_workspace_bound(const struct zstd_compression_parameters *cparams)
+size_t zstd_cctx_workspace_bound(
+       const struct zstd_compression_parameters *cparams)
 {
        ZSTD_compressionParameters p;
 
@@ -84,7 +108,8 @@ zstd_cctx *zstd_init_cctx(void *workspace, size_t 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 struct zstd_parameters* parameters)
+size_t zstd_compress_cctx(zstd_cctx *cctx, void *dst, size_t dst_capacity,
+       const void *src, size_t src_size, const struct zstd_parameters *parameters)
 {
        ZSTD_parameters p;
 
@@ -93,7 +118,8 @@ size_t zstd_compress_cctx(zstd_cctx *cctx, void *dst, size_t dst_capacity, const
 }
 EXPORT_SYMBOL(zstd_compress_cctx);
 
-size_t zstd_cstream_workspace_bound(const struct zstd_compression_parameters *cparams)
+size_t zstd_cstream_workspace_bound(
+       const struct zstd_compression_parameters *cparams)
 {
        ZSTD_compressionParameters p;
 
@@ -102,7 +128,8 @@ size_t zstd_cstream_workspace_bound(const struct zstd_compression_parameters *cp
 }
 EXPORT_SYMBOL(zstd_cstream_workspace_bound);
 
-zstd_cstream *zstd_init_cstream(const struct zstd_parameters *parameters, unsigned long long pledged_src_size, void *workspace, size_t workspace_size)
+zstd_cstream *zstd_init_cstream(const struct zstd_parameters *parameters,
+       unsigned long long pledged_src_size, void *workspace, size_t workspace_size)
 {
        ZSTD_parameters p;
        zstd_cstream *cstream;
@@ -128,13 +155,15 @@ zstd_cstream *zstd_init_cstream(const struct zstd_parameters *parameters, unsign
 }
 EXPORT_SYMBOL(zstd_init_cstream);
 
-size_t zstd_reset_cstream(zstd_cstream *cstream, unsigned long long pledged_src_size)
+size_t zstd_reset_cstream(zstd_cstream *cstream,
+       unsigned long long pledged_src_size)
 {
        return ZSTD_resetCStream(cstream, pledged_src_size);
 }
 EXPORT_SYMBOL(zstd_reset_cstream);
 
-size_t zstd_compress_stream(zstd_cstream *cstream, struct zstd_out_buffer *output, struct zstd_in_buffer *input)
+size_t zstd_compress_stream(zstd_cstream *cstream,
+       struct zstd_out_buffer *output, struct zstd_in_buffer *input)
 {
        ZSTD_outBuffer o;
        ZSTD_inBuffer i;

diff --git a/contrib/linux-kernel/zstd_decompress_module.c b/contrib/linux-kernel/zstd_decompress_module.c
index 37ba8d4e3735a48cd42a08f1b52c9f405c257f7f..988fdb57200e50289829fce7dbb0548b39402794 100644 (file)
--- a/contrib/linux-kernel/zstd_decompress_module.c
+++ b/contrib/linux-kernel/zstd_decompress_module.c
@@ -37,7 +37,7 @@ size_t zstd_dctx_workspace_bound(void)
 }
 EXPORT_SYMBOL(zstd_dctx_workspace_bound);
 
-zstd_dctx* zstd_init_dctx(void *workspace, size_t workspace_size)
+zstd_dctx *zstd_init_dctx(void *workspace, size_t workspace_size)
 {
        if (workspace == NULL)
                return NULL;
@@ -45,7 +45,8 @@ zstd_dctx* zstd_init_dctx(void *workspace, size_t 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)
+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);
 }
@@ -57,7 +58,8 @@ size_t zstd_dstream_workspace_bound(size_t 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)
+zstd_dstream *zstd_init_dstream(size_t max_window_size, void *workspace,
+       size_t workspace_size)
 {
        if (workspace == NULL)
                return NULL;
@@ -72,7 +74,8 @@ size_t zstd_reset_dstream(zstd_dstream *dstream)
 }
 EXPORT_SYMBOL(zstd_reset_dstream);
 
-size_t zstd_decompress_stream(zstd_dstream *dstream, struct zstd_out_buffer *output, struct zstd_in_buffer *input)
+size_t zstd_decompress_stream(zstd_dstream *dstream,
+       struct zstd_out_buffer *output, struct zstd_in_buffer *input)
 {
        ZSTD_outBuffer o;
        ZSTD_inBuffer i;
@@ -93,7 +96,8 @@ size_t zstd_find_frame_compressed_size(const void *src, size_t src_size)
 }
 EXPORT_SYMBOL(zstd_find_frame_compressed_size);
 
-size_t zstd_get_frame_params(struct zstd_frame_params *params, const void *src, size_t src_size)
+size_t zstd_get_frame_params(struct zstd_frame_params *params, const void *src,
+       size_t src_size)
 {
        ZSTD_frameHeader h;
        const size_t ret = ZSTD_getFrameHeader(&h, src, src_size);