diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..4611386 --- /dev/null +++ b/.gitignore @@ -0,0 +1,15 @@ +/kvdo-36c3e1c.tar.gz +/kvdo-2e1a578.tar.gz +/kvdo-000a4c2.tar.gz +/kvdo-3f9bde5.tar.gz +/kvdo-f9d6d18.tar.gz +/kvdo-819203a.tar.gz +/kvdo-e209cfe.tar.gz +/kvdo-127a993.tar.gz +/kvdo-6077a12.tar.gz +/kvdo-883a960.tar.gz +/kvdo-e2a5ebb.tar.gz +/kvdo-c9bd224.tar.gz +/kvdo-c6254c6.tar.gz +/kvdo-9b37ab4.tar.gz +/kvdo-7c54552.tar.gz diff --git a/README.md b/README.md deleted file mode 100644 index 24b9ea2..0000000 --- a/README.md +++ /dev/null @@ -1,3 +0,0 @@ -# Package Not Available -This package is not available on CentOS Stream 10. -It may be available on another branch. \ No newline at end of file diff --git a/add_lz4_dependency.patch b/add_lz4_dependency.patch new file mode 100644 index 0000000..99e1aeb --- /dev/null +++ b/add_lz4_dependency.patch @@ -0,0 +1,1193 @@ +diff -Naur kvdo-127a993f34010e4d8b05e46c4af2a9295c4477d0.orig/vdo/lz4_compress.c kvdo-127a993f34010e4d8b05e46c4af2a9295c4477d0/vdo/lz4_compress.c +--- kvdo-127a993f34010e4d8b05e46c4af2a9295c4477d0.orig/vdo/lz4_compress.c 1969-12-31 19:00:00.000000000 -0500 ++++ kvdo-127a993f34010e4d8b05e46c4af2a9295c4477d0/vdo/lz4_compress.c 2022-07-27 21:39:51.288835411 -0400 +@@ -0,0 +1,940 @@ ++/* ++ * LZ4 - Fast LZ compression algorithm ++ * Copyright (C) 2011 - 2016, Yann Collet. ++ * BSD 2 - Clause License (http://www.opensource.org/licenses/bsd - license.php) ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions are ++ * met: ++ * * Redistributions of source code must retain the above copyright ++ * notice, this list of conditions and the following disclaimer. ++ * * Redistributions in binary form must reproduce the above ++ * copyright notice, this list of conditions and the following disclaimer ++ * in the documentation and/or other materials provided with the ++ * distribution. ++ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ++ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT ++ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR ++ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT ++ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, ++ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT ++ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, ++ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY ++ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT ++ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE ++ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ++ * You can contact the author at : ++ * - LZ4 homepage : http://www.lz4.org ++ * - LZ4 source repository : https://github.com/lz4/lz4 ++ * ++ * Changed for kernel usage by: ++ * Sven Schmidt <4sschmid@informatik.uni-hamburg.de> ++ */ ++ ++/*-************************************ ++ * Dependencies ++ **************************************/ ++#include ++#include "lz4defs.h" ++#include ++#include ++#include ++ ++static const int LZ4_minLength = (MFLIMIT + 1); ++static const int LZ4_64Klimit = ((64 * KB) + (MFLIMIT - 1)); ++ ++/*-****************************** ++ * Compression functions ++ ********************************/ ++static FORCE_INLINE U32 LZ4_hash4( ++ U32 sequence, ++ tableType_t const tableType) ++{ ++ if (tableType == byU16) ++ return ((sequence * 2654435761U) ++ >> ((MINMATCH * 8) - (LZ4_HASHLOG + 1))); ++ else ++ return ((sequence * 2654435761U) ++ >> ((MINMATCH * 8) - LZ4_HASHLOG)); ++} ++ ++static FORCE_INLINE U32 LZ4_hash5( ++ U64 sequence, ++ tableType_t const tableType) ++{ ++ const U32 hashLog = (tableType == byU16) ++ ? LZ4_HASHLOG + 1 ++ : LZ4_HASHLOG; ++ ++#if LZ4_LITTLE_ENDIAN ++ static const U64 prime5bytes = 889523592379ULL; ++ ++ return (U32)(((sequence << 24) * prime5bytes) >> (64 - hashLog)); ++#else ++ static const U64 prime8bytes = 11400714785074694791ULL; ++ ++ return (U32)(((sequence >> 24) * prime8bytes) >> (64 - hashLog)); ++#endif ++} ++ ++static FORCE_INLINE U32 LZ4_hashPosition( ++ const void *p, ++ tableType_t const tableType) ++{ ++#if LZ4_ARCH64 ++ if (tableType == byU32) ++ return LZ4_hash5(LZ4_read_ARCH(p), tableType); ++#endif ++ ++ return LZ4_hash4(LZ4_read32(p), tableType); ++} ++ ++static void LZ4_putPositionOnHash( ++ const BYTE *p, ++ U32 h, ++ void *tableBase, ++ tableType_t const tableType, ++ const BYTE *srcBase) ++{ ++ switch (tableType) { ++ case byPtr: ++ { ++ const BYTE **hashTable = (const BYTE **)tableBase; ++ ++ hashTable[h] = p; ++ return; ++ } ++ case byU32: ++ { ++ U32 *hashTable = (U32 *) tableBase; ++ ++ hashTable[h] = (U32)(p - srcBase); ++ return; ++ } ++ case byU16: ++ { ++ U16 *hashTable = (U16 *) tableBase; ++ ++ hashTable[h] = (U16)(p - srcBase); ++ return; ++ } ++ } ++} ++ ++static FORCE_INLINE void LZ4_putPosition( ++ const BYTE *p, ++ void *tableBase, ++ tableType_t tableType, ++ const BYTE *srcBase) ++{ ++ U32 const h = LZ4_hashPosition(p, tableType); ++ ++ LZ4_putPositionOnHash(p, h, tableBase, tableType, srcBase); ++} ++ ++static const BYTE *LZ4_getPositionOnHash( ++ U32 h, ++ void *tableBase, ++ tableType_t tableType, ++ const BYTE *srcBase) ++{ ++ if (tableType == byPtr) { ++ const BYTE **hashTable = (const BYTE **) tableBase; ++ ++ return hashTable[h]; ++ } ++ ++ if (tableType == byU32) { ++ const U32 * const hashTable = (U32 *) tableBase; ++ ++ return hashTable[h] + srcBase; ++ } ++ ++ { ++ /* default, to ensure a return */ ++ const U16 * const hashTable = (U16 *) tableBase; ++ ++ return hashTable[h] + srcBase; ++ } ++} ++ ++static FORCE_INLINE const BYTE *LZ4_getPosition( ++ const BYTE *p, ++ void *tableBase, ++ tableType_t tableType, ++ const BYTE *srcBase) ++{ ++ U32 const h = LZ4_hashPosition(p, tableType); ++ ++ return LZ4_getPositionOnHash(h, tableBase, tableType, srcBase); ++} ++ ++ ++/* ++ * LZ4_compress_generic() : ++ * inlined, to ensure branches are decided at compilation time ++ */ ++static FORCE_INLINE int LZ4_compress_generic( ++ LZ4_stream_t_internal * const dictPtr, ++ const char * const source, ++ char * const dest, ++ const int inputSize, ++ const int maxOutputSize, ++ const limitedOutput_directive outputLimited, ++ const tableType_t tableType, ++ const dict_directive dict, ++ const dictIssue_directive dictIssue, ++ const U32 acceleration) ++{ ++ const BYTE *ip = (const BYTE *) source; ++ const BYTE *base; ++ const BYTE *lowLimit; ++ const BYTE * const lowRefLimit = ip - dictPtr->dictSize; ++ const BYTE * const dictionary = dictPtr->dictionary; ++ const BYTE * const dictEnd = dictionary + dictPtr->dictSize; ++ const size_t dictDelta = dictEnd - (const BYTE *)source; ++ const BYTE *anchor = (const BYTE *) source; ++ const BYTE * const iend = ip + inputSize; ++ const BYTE * const mflimit = iend - MFLIMIT; ++ const BYTE * const matchlimit = iend - LASTLITERALS; ++ ++ BYTE *op = (BYTE *) dest; ++ BYTE * const olimit = op + maxOutputSize; ++ ++ U32 forwardH; ++ size_t refDelta = 0; ++ ++ /* Init conditions */ ++ if ((U32)inputSize > (U32)LZ4_MAX_INPUT_SIZE) { ++ /* Unsupported inputSize, too large (or negative) */ ++ return 0; ++ } ++ ++ switch (dict) { ++ case noDict: ++ default: ++ base = (const BYTE *)source; ++ lowLimit = (const BYTE *)source; ++ break; ++ case withPrefix64k: ++ base = (const BYTE *)source - dictPtr->currentOffset; ++ lowLimit = (const BYTE *)source - dictPtr->dictSize; ++ break; ++ case usingExtDict: ++ base = (const BYTE *)source - dictPtr->currentOffset; ++ lowLimit = (const BYTE *)source; ++ break; ++ } ++ ++ if ((tableType == byU16) ++ && (inputSize >= LZ4_64Klimit)) { ++ /* Size too large (not within 64K limit) */ ++ return 0; ++ } ++ ++ if (inputSize < LZ4_minLength) { ++ /* Input too small, no compression (all literals) */ ++ goto _last_literals; ++ } ++ ++ /* First Byte */ ++ LZ4_putPosition(ip, dictPtr->hashTable, tableType, base); ++ ip++; ++ forwardH = LZ4_hashPosition(ip, tableType); ++ ++ /* Main Loop */ ++ for ( ; ; ) { ++ const BYTE *match; ++ BYTE *token; ++ ++ /* Find a match */ ++ { ++ const BYTE *forwardIp = ip; ++ unsigned int step = 1; ++ unsigned int searchMatchNb = acceleration << LZ4_SKIPTRIGGER; ++ ++ do { ++ U32 const h = forwardH; ++ ++ ip = forwardIp; ++ forwardIp += step; ++ step = (searchMatchNb++ >> LZ4_SKIPTRIGGER); ++ ++ if (unlikely(forwardIp > mflimit)) ++ goto _last_literals; ++ ++ match = LZ4_getPositionOnHash(h, ++ dictPtr->hashTable, ++ tableType, base); ++ ++ if (dict == usingExtDict) { ++ if (match < (const BYTE *)source) { ++ refDelta = dictDelta; ++ lowLimit = dictionary; ++ } else { ++ refDelta = 0; ++ lowLimit = (const BYTE *)source; ++ } } ++ ++ forwardH = LZ4_hashPosition(forwardIp, ++ tableType); ++ ++ LZ4_putPositionOnHash(ip, h, dictPtr->hashTable, ++ tableType, base); ++ } while (((dictIssue == dictSmall) ++ ? (match < lowRefLimit) ++ : 0) ++ || ((tableType == byU16) ++ ? 0 ++ : (match + MAX_DISTANCE < ip)) ++ || (LZ4_read32(match + refDelta) ++ != LZ4_read32(ip))); ++ } ++ ++ /* Catch up */ ++ while (((ip > anchor) & (match + refDelta > lowLimit)) ++ && (unlikely(ip[-1] == match[refDelta - 1]))) { ++ ip--; ++ match--; ++ } ++ ++ /* Encode Literals */ ++ { ++ unsigned const int litLength = (unsigned int)(ip - anchor); ++ ++ token = op++; ++ ++ if ((outputLimited) && ++ /* Check output buffer overflow */ ++ (unlikely(op + litLength + ++ (2 + 1 + LASTLITERALS) + ++ (litLength / 255) > olimit))) ++ return 0; ++ ++ if (litLength >= RUN_MASK) { ++ int len = (int)litLength - RUN_MASK; ++ ++ *token = (RUN_MASK << ML_BITS); ++ ++ for (; len >= 255; len -= 255) ++ *op++ = 255; ++ *op++ = (BYTE)len; ++ } else ++ *token = (BYTE)(litLength << ML_BITS); ++ ++ /* Copy Literals */ ++ LZ4_wildCopy(op, anchor, op + litLength); ++ op += litLength; ++ } ++ ++_next_match: ++ /* Encode Offset */ ++ LZ4_writeLE16(op, (U16)(ip - match)); ++ op += 2; ++ ++ /* Encode MatchLength */ ++ { ++ unsigned int matchCode; ++ ++ if ((dict == usingExtDict) ++ && (lowLimit == dictionary)) { ++ const BYTE *limit; ++ ++ match += refDelta; ++ limit = ip + (dictEnd - match); ++ ++ if (limit > matchlimit) ++ limit = matchlimit; ++ ++ matchCode = LZ4_count(ip + MINMATCH, ++ match + MINMATCH, limit); ++ ++ ip += MINMATCH + matchCode; ++ ++ if (ip == limit) { ++ unsigned const int more = LZ4_count(ip, ++ (const BYTE *)source, ++ matchlimit); ++ ++ matchCode += more; ++ ip += more; ++ } ++ } else { ++ matchCode = LZ4_count(ip + MINMATCH, ++ match + MINMATCH, matchlimit); ++ ip += MINMATCH + matchCode; ++ } ++ ++ if (outputLimited && ++ /* Check output buffer overflow */ ++ (unlikely(op + ++ (1 + LASTLITERALS) + ++ (matchCode >> 8) > olimit))) ++ return 0; ++ ++ if (matchCode >= ML_MASK) { ++ *token += ML_MASK; ++ matchCode -= ML_MASK; ++ LZ4_write32(op, 0xFFFFFFFF); ++ ++ while (matchCode >= 4 * 255) { ++ op += 4; ++ LZ4_write32(op, 0xFFFFFFFF); ++ matchCode -= 4 * 255; ++ } ++ ++ op += matchCode / 255; ++ *op++ = (BYTE)(matchCode % 255); ++ } else ++ *token += (BYTE)(matchCode); ++ } ++ ++ anchor = ip; ++ ++ /* Test end of chunk */ ++ if (ip > mflimit) ++ break; ++ ++ /* Fill table */ ++ LZ4_putPosition(ip - 2, dictPtr->hashTable, tableType, base); ++ ++ /* Test next position */ ++ match = LZ4_getPosition(ip, dictPtr->hashTable, ++ tableType, base); ++ ++ if (dict == usingExtDict) { ++ if (match < (const BYTE *)source) { ++ refDelta = dictDelta; ++ lowLimit = dictionary; ++ } else { ++ refDelta = 0; ++ lowLimit = (const BYTE *)source; ++ } ++ } ++ ++ LZ4_putPosition(ip, dictPtr->hashTable, tableType, base); ++ ++ if (((dictIssue == dictSmall) ? (match >= lowRefLimit) : 1) ++ && (match + MAX_DISTANCE >= ip) ++ && (LZ4_read32(match + refDelta) == LZ4_read32(ip))) { ++ token = op++; ++ *token = 0; ++ goto _next_match; ++ } ++ ++ /* Prepare next loop */ ++ forwardH = LZ4_hashPosition(++ip, tableType); ++ } ++ ++_last_literals: ++ /* Encode Last Literals */ ++ { ++ size_t const lastRun = (size_t)(iend - anchor); ++ ++ if ((outputLimited) && ++ /* Check output buffer overflow */ ++ ((op - (BYTE *)dest) + lastRun + 1 + ++ ((lastRun + 255 - RUN_MASK) / 255) > (U32)maxOutputSize)) ++ return 0; ++ ++ if (lastRun >= RUN_MASK) { ++ size_t accumulator = lastRun - RUN_MASK; ++ *op++ = RUN_MASK << ML_BITS; ++ for (; accumulator >= 255; accumulator -= 255) ++ *op++ = 255; ++ *op++ = (BYTE) accumulator; ++ } else { ++ *op++ = (BYTE)(lastRun << ML_BITS); ++ } ++ ++ LZ4_memcpy(op, anchor, lastRun); ++ ++ op += lastRun; ++ } ++ ++ /* End */ ++ return (int) (((char *)op) - dest); ++} ++ ++static int LZ4_compress_fast_extState( ++ void *state, ++ const char *source, ++ char *dest, ++ int inputSize, ++ int maxOutputSize, ++ int acceleration) ++{ ++ LZ4_stream_t_internal *ctx = &((LZ4_stream_t *)state)->internal_donotuse; ++#if LZ4_ARCH64 ++ const tableType_t tableType = byU32; ++#else ++ const tableType_t tableType = byPtr; ++#endif ++ ++ LZ4_resetStream((LZ4_stream_t *)state); ++ ++ if (acceleration < 1) ++ acceleration = LZ4_ACCELERATION_DEFAULT; ++ ++ if (maxOutputSize >= LZ4_COMPRESSBOUND(inputSize)) { ++ if (inputSize < LZ4_64Klimit) ++ return LZ4_compress_generic(ctx, source, ++ dest, inputSize, 0, ++ noLimit, byU16, noDict, ++ noDictIssue, acceleration); ++ else ++ return LZ4_compress_generic(ctx, source, ++ dest, inputSize, 0, ++ noLimit, tableType, noDict, ++ noDictIssue, acceleration); ++ } else { ++ if (inputSize < LZ4_64Klimit) ++ return LZ4_compress_generic(ctx, source, ++ dest, inputSize, ++ maxOutputSize, limitedOutput, byU16, noDict, ++ noDictIssue, acceleration); ++ else ++ return LZ4_compress_generic(ctx, source, ++ dest, inputSize, ++ maxOutputSize, limitedOutput, tableType, noDict, ++ noDictIssue, acceleration); ++ } ++} ++ ++int LZ4_compress_fast(const char *source, char *dest, int inputSize, ++ int maxOutputSize, int acceleration, void *wrkmem) ++{ ++ return LZ4_compress_fast_extState(wrkmem, source, dest, inputSize, ++ maxOutputSize, acceleration); ++} ++EXPORT_SYMBOL(LZ4_compress_fast); ++ ++int LZ4_compress_default(const char *source, char *dest, int inputSize, ++ int maxOutputSize, void *wrkmem) ++{ ++ return LZ4_compress_fast(source, dest, inputSize, ++ maxOutputSize, LZ4_ACCELERATION_DEFAULT, wrkmem); ++} ++EXPORT_SYMBOL(LZ4_compress_default); ++ ++/*-****************************** ++ * *_destSize() variant ++ ********************************/ ++static int LZ4_compress_destSize_generic( ++ LZ4_stream_t_internal * const ctx, ++ const char * const src, ++ char * const dst, ++ int * const srcSizePtr, ++ const int targetDstSize, ++ const tableType_t tableType) ++{ ++ const BYTE *ip = (const BYTE *) src; ++ const BYTE *base = (const BYTE *) src; ++ const BYTE *lowLimit = (const BYTE *) src; ++ const BYTE *anchor = ip; ++ const BYTE * const iend = ip + *srcSizePtr; ++ const BYTE * const mflimit = iend - MFLIMIT; ++ const BYTE * const matchlimit = iend - LASTLITERALS; ++ ++ BYTE *op = (BYTE *) dst; ++ BYTE * const oend = op + targetDstSize; ++ BYTE * const oMaxLit = op + targetDstSize - 2 /* offset */ ++ - 8 /* because 8 + MINMATCH == MFLIMIT */ - 1 /* token */; ++ BYTE * const oMaxMatch = op + targetDstSize ++ - (LASTLITERALS + 1 /* token */); ++ BYTE * const oMaxSeq = oMaxLit - 1 /* token */; ++ ++ U32 forwardH; ++ ++ /* Init conditions */ ++ /* Impossible to store anything */ ++ if (targetDstSize < 1) ++ return 0; ++ /* Unsupported input size, too large (or negative) */ ++ if ((U32)*srcSizePtr > (U32)LZ4_MAX_INPUT_SIZE) ++ return 0; ++ /* Size too large (not within 64K limit) */ ++ if ((tableType == byU16) && (*srcSizePtr >= LZ4_64Klimit)) ++ return 0; ++ /* Input too small, no compression (all literals) */ ++ if (*srcSizePtr < LZ4_minLength) ++ goto _last_literals; ++ ++ /* First Byte */ ++ *srcSizePtr = 0; ++ LZ4_putPosition(ip, ctx->hashTable, tableType, base); ++ ip++; forwardH = LZ4_hashPosition(ip, tableType); ++ ++ /* Main Loop */ ++ for ( ; ; ) { ++ const BYTE *match; ++ BYTE *token; ++ ++ /* Find a match */ ++ { ++ const BYTE *forwardIp = ip; ++ unsigned int step = 1; ++ unsigned int searchMatchNb = 1 << LZ4_SKIPTRIGGER; ++ ++ do { ++ U32 h = forwardH; ++ ++ ip = forwardIp; ++ forwardIp += step; ++ step = (searchMatchNb++ >> LZ4_SKIPTRIGGER); ++ ++ if (unlikely(forwardIp > mflimit)) ++ goto _last_literals; ++ ++ match = LZ4_getPositionOnHash(h, ctx->hashTable, ++ tableType, base); ++ forwardH = LZ4_hashPosition(forwardIp, ++ tableType); ++ LZ4_putPositionOnHash(ip, h, ++ ctx->hashTable, tableType, ++ base); ++ ++ } while (((tableType == byU16) ++ ? 0 ++ : (match + MAX_DISTANCE < ip)) ++ || (LZ4_read32(match) != LZ4_read32(ip))); ++ } ++ ++ /* Catch up */ ++ while ((ip > anchor) ++ && (match > lowLimit) ++ && (unlikely(ip[-1] == match[-1]))) { ++ ip--; ++ match--; ++ } ++ ++ /* Encode Literal length */ ++ { ++ unsigned int litLength = (unsigned int)(ip - anchor); ++ ++ token = op++; ++ if (op + ((litLength + 240) / 255) ++ + litLength > oMaxLit) { ++ /* Not enough space for a last match */ ++ op--; ++ goto _last_literals; ++ } ++ if (litLength >= RUN_MASK) { ++ unsigned int len = litLength - RUN_MASK; ++ *token = (RUN_MASK<= 255; len -= 255) ++ *op++ = 255; ++ *op++ = (BYTE)len; ++ } else ++ *token = (BYTE)(litLength << ML_BITS); ++ ++ /* Copy Literals */ ++ LZ4_wildCopy(op, anchor, op + litLength); ++ op += litLength; ++ } ++ ++_next_match: ++ /* Encode Offset */ ++ LZ4_writeLE16(op, (U16)(ip - match)); op += 2; ++ ++ /* Encode MatchLength */ ++ { ++ size_t matchLength = LZ4_count(ip + MINMATCH, ++ match + MINMATCH, matchlimit); ++ ++ if (op + ((matchLength + 240)/255) > oMaxMatch) { ++ /* Match description too long : reduce it */ ++ matchLength = (15 - 1) + (oMaxMatch - op) * 255; ++ } ++ ip += MINMATCH + matchLength; ++ ++ if (matchLength >= ML_MASK) { ++ *token += ML_MASK; ++ matchLength -= ML_MASK; ++ while (matchLength >= 255) { ++ matchLength -= 255; ++ *op++ = 255; ++ } ++ *op++ = (BYTE)matchLength; ++ } else ++ *token += (BYTE)(matchLength); ++ } ++ ++ anchor = ip; ++ ++ /* Test end of block */ ++ if (ip > mflimit) ++ break; ++ if (op > oMaxSeq) ++ break; ++ ++ /* Fill table */ ++ LZ4_putPosition(ip - 2, ctx->hashTable, tableType, base); ++ ++ /* Test next position */ ++ match = LZ4_getPosition(ip, ctx->hashTable, tableType, base); ++ LZ4_putPosition(ip, ctx->hashTable, tableType, base); ++ ++ if ((match + MAX_DISTANCE >= ip) ++ && (LZ4_read32(match) == LZ4_read32(ip))) { ++ token = op++; *token = 0; ++ goto _next_match; ++ } ++ ++ /* Prepare next loop */ ++ forwardH = LZ4_hashPosition(++ip, tableType); ++ } ++ ++_last_literals: ++ /* Encode Last Literals */ ++ { ++ size_t lastRunSize = (size_t)(iend - anchor); ++ ++ if (op + 1 /* token */ ++ + ((lastRunSize + 240) / 255) /* litLength */ ++ + lastRunSize /* literals */ > oend) { ++ /* adapt lastRunSize to fill 'dst' */ ++ lastRunSize = (oend - op) - 1; ++ lastRunSize -= (lastRunSize + 240) / 255; ++ } ++ ip = anchor + lastRunSize; ++ ++ if (lastRunSize >= RUN_MASK) { ++ size_t accumulator = lastRunSize - RUN_MASK; ++ ++ *op++ = RUN_MASK << ML_BITS; ++ for (; accumulator >= 255; accumulator -= 255) ++ *op++ = 255; ++ *op++ = (BYTE) accumulator; ++ } else { ++ *op++ = (BYTE)(lastRunSize<= LZ4_COMPRESSBOUND(*srcSizePtr)) { ++ /* compression success is guaranteed */ ++ return LZ4_compress_fast_extState( ++ state, src, dst, *srcSizePtr, ++ targetDstSize, 1); ++ } else { ++ if (*srcSizePtr < LZ4_64Klimit) ++ return LZ4_compress_destSize_generic( ++ &state->internal_donotuse, ++ src, dst, srcSizePtr, ++ targetDstSize, byU16); ++ else ++ return LZ4_compress_destSize_generic( ++ &state->internal_donotuse, ++ src, dst, srcSizePtr, ++ targetDstSize, tableType); ++ } ++} ++ ++ ++int LZ4_compress_destSize( ++ const char *src, ++ char *dst, ++ int *srcSizePtr, ++ int targetDstSize, ++ void *wrkmem) ++{ ++ return LZ4_compress_destSize_extState(wrkmem, src, dst, srcSizePtr, ++ targetDstSize); ++} ++EXPORT_SYMBOL(LZ4_compress_destSize); ++ ++/*-****************************** ++ * Streaming functions ++ ********************************/ ++void LZ4_resetStream(LZ4_stream_t *LZ4_stream) ++{ ++ memset(LZ4_stream, 0, sizeof(LZ4_stream_t)); ++} ++ ++int LZ4_loadDict(LZ4_stream_t *LZ4_dict, ++ const char *dictionary, int dictSize) ++{ ++ LZ4_stream_t_internal *dict = &LZ4_dict->internal_donotuse; ++ const BYTE *p = (const BYTE *)dictionary; ++ const BYTE * const dictEnd = p + dictSize; ++ const BYTE *base; ++ ++ if ((dict->initCheck) ++ || (dict->currentOffset > 1 * GB)) { ++ /* Uninitialized structure, or reuse overflow */ ++ LZ4_resetStream(LZ4_dict); ++ } ++ ++ if (dictSize < (int)HASH_UNIT) { ++ dict->dictionary = NULL; ++ dict->dictSize = 0; ++ return 0; ++ } ++ ++ if ((dictEnd - p) > 64 * KB) ++ p = dictEnd - 64 * KB; ++ dict->currentOffset += 64 * KB; ++ base = p - dict->currentOffset; ++ dict->dictionary = p; ++ dict->dictSize = (U32)(dictEnd - p); ++ dict->currentOffset += dict->dictSize; ++ ++ while (p <= dictEnd - HASH_UNIT) { ++ LZ4_putPosition(p, dict->hashTable, byU32, base); ++ p += 3; ++ } ++ ++ return dict->dictSize; ++} ++EXPORT_SYMBOL(LZ4_loadDict); ++ ++static void LZ4_renormDictT(LZ4_stream_t_internal *LZ4_dict, ++ const BYTE *src) ++{ ++ if ((LZ4_dict->currentOffset > 0x80000000) || ++ ((uptrval)LZ4_dict->currentOffset > (uptrval)src)) { ++ /* address space overflow */ ++ /* rescale hash table */ ++ U32 const delta = LZ4_dict->currentOffset - 64 * KB; ++ const BYTE *dictEnd = LZ4_dict->dictionary + LZ4_dict->dictSize; ++ int i; ++ ++ for (i = 0; i < LZ4_HASH_SIZE_U32; i++) { ++ if (LZ4_dict->hashTable[i] < delta) ++ LZ4_dict->hashTable[i] = 0; ++ else ++ LZ4_dict->hashTable[i] -= delta; ++ } ++ LZ4_dict->currentOffset = 64 * KB; ++ if (LZ4_dict->dictSize > 64 * KB) ++ LZ4_dict->dictSize = 64 * KB; ++ LZ4_dict->dictionary = dictEnd - LZ4_dict->dictSize; ++ } ++} ++ ++int LZ4_saveDict(LZ4_stream_t *LZ4_dict, char *safeBuffer, int dictSize) ++{ ++ LZ4_stream_t_internal * const dict = &LZ4_dict->internal_donotuse; ++ const BYTE * const previousDictEnd = dict->dictionary + dict->dictSize; ++ ++ if ((U32)dictSize > 64 * KB) { ++ /* useless to define a dictionary > 64 * KB */ ++ dictSize = 64 * KB; ++ } ++ if ((U32)dictSize > dict->dictSize) ++ dictSize = dict->dictSize; ++ ++ memmove(safeBuffer, previousDictEnd - dictSize, dictSize); ++ ++ dict->dictionary = (const BYTE *)safeBuffer; ++ dict->dictSize = (U32)dictSize; ++ ++ return dictSize; ++} ++EXPORT_SYMBOL(LZ4_saveDict); ++ ++int LZ4_compress_fast_continue(LZ4_stream_t *LZ4_stream, const char *source, ++ char *dest, int inputSize, int maxOutputSize, int acceleration) ++{ ++ LZ4_stream_t_internal *streamPtr = &LZ4_stream->internal_donotuse; ++ const BYTE * const dictEnd = streamPtr->dictionary ++ + streamPtr->dictSize; ++ ++ const BYTE *smallest = (const BYTE *) source; ++ ++ if (streamPtr->initCheck) { ++ /* Uninitialized structure detected */ ++ return 0; ++ } ++ ++ if ((streamPtr->dictSize > 0) && (smallest > dictEnd)) ++ smallest = dictEnd; ++ ++ LZ4_renormDictT(streamPtr, smallest); ++ ++ if (acceleration < 1) ++ acceleration = LZ4_ACCELERATION_DEFAULT; ++ ++ /* Check overlapping input/dictionary space */ ++ { ++ const BYTE *sourceEnd = (const BYTE *) source + inputSize; ++ ++ if ((sourceEnd > streamPtr->dictionary) ++ && (sourceEnd < dictEnd)) { ++ streamPtr->dictSize = (U32)(dictEnd - sourceEnd); ++ if (streamPtr->dictSize > 64 * KB) ++ streamPtr->dictSize = 64 * KB; ++ if (streamPtr->dictSize < 4) ++ streamPtr->dictSize = 0; ++ streamPtr->dictionary = dictEnd - streamPtr->dictSize; ++ } ++ } ++ ++ /* prefix mode : source data follows dictionary */ ++ if (dictEnd == (const BYTE *)source) { ++ int result; ++ ++ if ((streamPtr->dictSize < 64 * KB) && ++ (streamPtr->dictSize < streamPtr->currentOffset)) { ++ result = LZ4_compress_generic( ++ streamPtr, source, dest, inputSize, ++ maxOutputSize, limitedOutput, byU32, ++ withPrefix64k, dictSmall, acceleration); ++ } else { ++ result = LZ4_compress_generic( ++ streamPtr, source, dest, inputSize, ++ maxOutputSize, limitedOutput, byU32, ++ withPrefix64k, noDictIssue, acceleration); ++ } ++ streamPtr->dictSize += (U32)inputSize; ++ streamPtr->currentOffset += (U32)inputSize; ++ return result; ++ } ++ ++ /* external dictionary mode */ ++ { ++ int result; ++ ++ if ((streamPtr->dictSize < 64 * KB) && ++ (streamPtr->dictSize < streamPtr->currentOffset)) { ++ result = LZ4_compress_generic( ++ streamPtr, source, dest, inputSize, ++ maxOutputSize, limitedOutput, byU32, ++ usingExtDict, dictSmall, acceleration); ++ } else { ++ result = LZ4_compress_generic( ++ streamPtr, source, dest, inputSize, ++ maxOutputSize, limitedOutput, byU32, ++ usingExtDict, noDictIssue, acceleration); ++ } ++ streamPtr->dictionary = (const BYTE *)source; ++ streamPtr->dictSize = (U32)inputSize; ++ streamPtr->currentOffset += (U32)inputSize; ++ return result; ++ } ++} ++EXPORT_SYMBOL(LZ4_compress_fast_continue); ++ ++MODULE_LICENSE("Dual BSD/GPL"); ++MODULE_DESCRIPTION("LZ4 compressor"); +diff -Naur kvdo-127a993f34010e4d8b05e46c4af2a9295c4477d0.orig/vdo/lz4defs.h kvdo-127a993f34010e4d8b05e46c4af2a9295c4477d0/vdo/lz4defs.h +--- kvdo-127a993f34010e4d8b05e46c4af2a9295c4477d0.orig/vdo/lz4defs.h 1969-12-31 19:00:00.000000000 -0500 ++++ kvdo-127a993f34010e4d8b05e46c4af2a9295c4477d0/vdo/lz4defs.h 2022-07-27 21:39:43.896830772 -0400 +@@ -0,0 +1,245 @@ ++#ifndef __LZ4DEFS_H__ ++#define __LZ4DEFS_H__ ++ ++/* ++ * lz4defs.h -- common and architecture specific defines for the kernel usage ++ ++ * LZ4 - Fast LZ compression algorithm ++ * Copyright (C) 2011-2016, Yann Collet. ++ * BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php) ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions are ++ * met: ++ * * Redistributions of source code must retain the above copyright ++ * notice, this list of conditions and the following disclaimer. ++ * * Redistributions in binary form must reproduce the above ++ * copyright notice, this list of conditions and the following disclaimer ++ * in the documentation and/or other materials provided with the ++ * distribution. ++ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ++ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT ++ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR ++ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT ++ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, ++ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT ++ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, ++ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY ++ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT ++ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE ++ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ++ * You can contact the author at : ++ * - LZ4 homepage : http://www.lz4.org ++ * - LZ4 source repository : https://github.com/lz4/lz4 ++ * ++ * Changed for kernel usage by: ++ * Sven Schmidt <4sschmid@informatik.uni-hamburg.de> ++ */ ++ ++#include ++#include /* memset, memcpy */ ++ ++#define FORCE_INLINE __always_inline ++ ++/*-************************************ ++ * Basic Types ++ **************************************/ ++#include ++ ++typedef uint8_t BYTE; ++typedef uint16_t U16; ++typedef uint32_t U32; ++typedef int32_t S32; ++typedef uint64_t U64; ++typedef uintptr_t uptrval; ++ ++/*-************************************ ++ * Architecture specifics ++ **************************************/ ++#if defined(CONFIG_64BIT) ++#define LZ4_ARCH64 1 ++#else ++#define LZ4_ARCH64 0 ++#endif ++ ++#if defined(__LITTLE_ENDIAN) ++#define LZ4_LITTLE_ENDIAN 1 ++#else ++#define LZ4_LITTLE_ENDIAN 0 ++#endif ++ ++/*-************************************ ++ * Constants ++ **************************************/ ++#define MINMATCH 4 ++ ++#define WILDCOPYLENGTH 8 ++#define LASTLITERALS 5 ++#define MFLIMIT (WILDCOPYLENGTH + MINMATCH) ++/* ++ * ensure it's possible to write 2 x wildcopyLength ++ * without overflowing output buffer ++ */ ++#define MATCH_SAFEGUARD_DISTANCE ((2 * WILDCOPYLENGTH) - MINMATCH) ++ ++/* Increase this value ==> compression run slower on incompressible data */ ++#define LZ4_SKIPTRIGGER 6 ++ ++#define HASH_UNIT sizeof(size_t) ++ ++#define KB (1 << 10) ++#define MB (1 << 20) ++#define GB (1U << 30) ++ ++#define MAXD_LOG 16 ++#define MAX_DISTANCE ((1 << MAXD_LOG) - 1) ++#define STEPSIZE sizeof(size_t) ++ ++#define ML_BITS 4 ++#define ML_MASK ((1U << ML_BITS) - 1) ++#define RUN_BITS (8 - ML_BITS) ++#define RUN_MASK ((1U << RUN_BITS) - 1) ++ ++/*-************************************ ++ * Reading and writing into memory ++ **************************************/ ++static FORCE_INLINE U16 LZ4_read16(const void *ptr) ++{ ++ return get_unaligned((const U16 *)ptr); ++} ++ ++static FORCE_INLINE U32 LZ4_read32(const void *ptr) ++{ ++ return get_unaligned((const U32 *)ptr); ++} ++ ++static FORCE_INLINE size_t LZ4_read_ARCH(const void *ptr) ++{ ++ return get_unaligned((const size_t *)ptr); ++} ++ ++static FORCE_INLINE void LZ4_write16(void *memPtr, U16 value) ++{ ++ put_unaligned(value, (U16 *)memPtr); ++} ++ ++static FORCE_INLINE void LZ4_write32(void *memPtr, U32 value) ++{ ++ put_unaligned(value, (U32 *)memPtr); ++} ++ ++static FORCE_INLINE U16 LZ4_readLE16(const void *memPtr) ++{ ++ return get_unaligned_le16(memPtr); ++} ++ ++static FORCE_INLINE void LZ4_writeLE16(void *memPtr, U16 value) ++{ ++ return put_unaligned_le16(value, memPtr); ++} ++ ++/* ++ * LZ4 relies on memcpy with a constant size being inlined. In freestanding ++ * environments, the compiler can't assume the implementation of memcpy() is ++ * standard compliant, so apply its specialized memcpy() inlining logic. When ++ * possible, use __builtin_memcpy() to tell the compiler to analyze memcpy() ++ * as-if it were standard compliant, so it can inline it in freestanding ++ * environments. This is needed when decompressing the Linux Kernel, for example. ++ */ ++#define LZ4_memcpy(dst, src, size) __builtin_memcpy(dst, src, size) ++#define LZ4_memmove(dst, src, size) __builtin_memmove(dst, src, size) ++ ++static FORCE_INLINE void LZ4_copy8(void *dst, const void *src) ++{ ++#if LZ4_ARCH64 ++ U64 a = get_unaligned((const U64 *)src); ++ ++ put_unaligned(a, (U64 *)dst); ++#else ++ U32 a = get_unaligned((const U32 *)src); ++ U32 b = get_unaligned((const U32 *)src + 1); ++ ++ put_unaligned(a, (U32 *)dst); ++ put_unaligned(b, (U32 *)dst + 1); ++#endif ++} ++ ++/* ++ * customized variant of memcpy, ++ * which can overwrite up to 7 bytes beyond dstEnd ++ */ ++static FORCE_INLINE void LZ4_wildCopy(void *dstPtr, ++ const void *srcPtr, void *dstEnd) ++{ ++ BYTE *d = (BYTE *)dstPtr; ++ const BYTE *s = (const BYTE *)srcPtr; ++ BYTE *const e = (BYTE *)dstEnd; ++ ++ do { ++ LZ4_copy8(d, s); ++ d += 8; ++ s += 8; ++ } while (d < e); ++} ++ ++static FORCE_INLINE unsigned int LZ4_NbCommonBytes(register size_t val) ++{ ++#if LZ4_LITTLE_ENDIAN ++ return __ffs(val) >> 3; ++#else ++ return (BITS_PER_LONG - 1 - __fls(val)) >> 3; ++#endif ++} ++ ++static FORCE_INLINE unsigned int LZ4_count( ++ const BYTE *pIn, ++ const BYTE *pMatch, ++ const BYTE *pInLimit) ++{ ++ const BYTE *const pStart = pIn; ++ ++ while (likely(pIn < pInLimit - (STEPSIZE - 1))) { ++ size_t const diff = LZ4_read_ARCH(pMatch) ^ LZ4_read_ARCH(pIn); ++ ++ if (!diff) { ++ pIn += STEPSIZE; ++ pMatch += STEPSIZE; ++ continue; ++ } ++ ++ pIn += LZ4_NbCommonBytes(diff); ++ ++ return (unsigned int)(pIn - pStart); ++ } ++ ++#if LZ4_ARCH64 ++ if ((pIn < (pInLimit - 3)) ++ && (LZ4_read32(pMatch) == LZ4_read32(pIn))) { ++ pIn += 4; ++ pMatch += 4; ++ } ++#endif ++ ++ if ((pIn < (pInLimit - 1)) ++ && (LZ4_read16(pMatch) == LZ4_read16(pIn))) { ++ pIn += 2; ++ pMatch += 2; ++ } ++ ++ if ((pIn < pInLimit) && (*pMatch == *pIn)) ++ pIn++; ++ ++ return (unsigned int)(pIn - pStart); ++} ++ ++typedef enum { noLimit = 0, limitedOutput = 1 } limitedOutput_directive; ++typedef enum { byPtr, byU32, byU16 } tableType_t; ++ ++typedef enum { noDict = 0, withPrefix64k, usingExtDict } dict_directive; ++typedef enum { noDictIssue = 0, dictSmall } dictIssue_directive; ++ ++typedef enum { endOnOutputSize = 0, endOnInputSize = 1 } endCondition_directive; ++typedef enum { decode_full_block = 0, partial_decode = 1 } earlyEnd_directive; ++ ++#define LZ4_STATIC_ASSERT(c) BUILD_BUG_ON(!(c)) ++ ++#endif diff --git a/dead.package b/dead.package deleted file mode 100644 index a83ab27..0000000 --- a/dead.package +++ /dev/null @@ -1 +0,0 @@ -kmod-kvdo package is retired on branch c10s for CS-2551 \ No newline at end of file diff --git a/gating.yaml b/gating.yaml new file mode 100644 index 0000000..648918d --- /dev/null +++ b/gating.yaml @@ -0,0 +1,6 @@ +--- !Policy +product_versions: + - rhel-9 +decision_context: osci_compose_gate +rules: + - !PassingTestCaseRule {test_case_name: osci.brew-build.tier0.functional} diff --git a/kmod-kvdo.spec b/kmod-kvdo.spec new file mode 100644 index 0000000..11c5fe2 --- /dev/null +++ b/kmod-kvdo.spec @@ -0,0 +1,824 @@ +%global commit 7c5455297c90653c85fb9f99aa1fe3f5b8008966 +%global gittag 8.2.4.15 +%global shortcommit %(c=%{commit}; echo ${c:0:7}) +%define spec_release 141 + +%define kmod_name kvdo +%define kmod_driver_version %{gittag} +%define kmod_rpm_release %{spec_release} +%define kmod_kernel_version 5.14.0-503.4.1.el9_5 +%define kmod_kernel_extra %(sed 's/.*-\\([0-9]\\+\\).*/\\1/' <<< "%{kmod_kernel_version}") +%define kmod_headers_version %(rpm -qa kernel-devel | sed 's/^kernel-devel-//') +%define kmod_kbuild_dir . +%define kmod_devel_package 0 + +Source0: https://github.com/dm-vdo/%{kmod_name}/archive/%{commit}/%{kmod_name}-%{shortcommit}.tar.gz +Patch0: add_lz4_dependency.patch +Patch1: removed-logical-space-check-from-table-line.patch + +%define findpat %( echo "%""P" ) + +Name: kmod-kvdo +Version: %{kmod_driver_version} +Release: %{kmod_rpm_release}%{?dist} +Summary: Kernel Modules for Virtual Data Optimizer +License: GPLv2+ +URL: http://github.com/dm-vdo/kvdo +BuildRoot: %(mktemp -ud %{_tmppath}/%{name}-%{version}-%{release}-XXXXXX) +BuildRequires: elfutils-libelf-devel +BuildRequires: glibc +BuildRequires: kernel-devel >= %{kmod_kernel_version} + +# Disable the kernel-debug requirement for now + +BuildRequires: libuuid-devel +BuildRequires: redhat-rpm-config +ExcludeArch: i686 +ExcludeArch: ppc +ExcludeArch: ppc64 +ExcludeArch: s390 + +%global kernel_source() /usr/src/kernels/%{kmod_headers_version} + +%global _use_internal_dependency_generator 0 +Provides: kmod-%{kmod_name} = %{?epoch:%{epoch}:}%{version}-%{release} +Requires(post): %{_sbindir}/weak-modules +Requires(postun): %{_sbindir}/weak-modules +Requires: kernel-core-uname-r >= %{kmod_kernel_version} +Requires: kernel-modules-uname-r >= %{kmod_kernel_version} +Conflicts: kernel-64k + +%description +Virtual Data Optimizer (VDO) is a device mapper target that delivers +block-level deduplication, compression, and thin provisioning. + +This package provides the kernel modules for VDO. + +%pre +# During the install, check whether kvdo or uds is loaded. A warning here +# indicates that a previous install was not completely removed. This message +# is purely informational to the user. +for module in kvdo uds; do + if grep -q "^${module}" /proc/modules; then + if [ "${module}" == "kvdo" ]; then + echo "WARNING: Found ${module} module previously loaded (Version: $(cat /sys/kvdo/version 2>/dev/null || echo Unknown)). A reboot is recommended before attempting to use the newly installed module." + else + echo "WARNING: Found ${module} module previously loaded. A reboot is recommended before attempting to use the newly installed module." + fi + fi +done + +%post +modules=( $(find /lib/modules/%{kmod_headers_version}/extra/kmod-%{kmod_name} | grep '\.ko$') ) +printf '%s\n' "${modules[@]}" >> /usr/lib/rpm-kmod-posttrans-weak-modules-add + +%pretrans -p +posix.unlink("/usr/lib/rpm-kmod-posttrans-weak-modules-add") + +%posttrans +if [ -f "/usr/lib/rpm-kmod-posttrans-weak-modules-add" ]; then + modules=( $(cat /usr/lib/rpm-kmod-posttrans-weak-modules-add) ) + rm -rf /usr/lib/rpm-kmod-posttrans-weak-modules-add + printf '%s\n' "${modules[@]}" | %{_sbindir}/weak-modules --dracut=/usr/bin/dracut --add-modules +fi + +%preun +rpm -ql kmod-kvdo-%{kmod_driver_version}-%{kmod_rpm_release}%{?dist}.$(arch) | grep '\.ko$' > /var/run/rpm-kmod-%{kmod_name}-modules +# Check whether kvdo or uds is loaded, and if so attempt to remove it. A +# failure to unload means there is still something using the module. To make +# sure the user is aware, we print a warning with recommended instructions. +for module in kvdo uds; do + if grep -q "^${module}" /proc/modules; then + warnMessage="WARNING: ${module} in use. Changes will take effect after a reboot." + modprobe -r ${module} 2>/dev/null || echo ${warnMessage} && /usr/bin/true + fi +done + +%postun +modules=( $(cat /var/run/rpm-kmod-%{kmod_name}-modules) ) +rm /var/run/rpm-kmod-%{kmod_name}-modules +printf '%s\n' "${modules[@]}" | %{_sbindir}/weak-modules --dracut=/usr/bin/dracut --remove-modules + +%files +%defattr(644,root,root,755) +/lib/modules/%{kmod_headers_version} +/etc/depmod.d/%{kmod_name}.conf +/usr/share/doc/kmod-%{kmod_name}/greylist.txt + +%prep +%setup -n %{kmod_name}-%{commit} +%patch0 -p1 +%patch1 -p1 +%{nil} +set -- * +mkdir source +mv "$@" source/ +mkdir obj + +%build +rm -rf obj +cp -r source obj +make -C %{kernel_source} M=$PWD/obj/%{kmod_kbuild_dir} V=1 \ + NOSTDINC_FLAGS="-I $PWD/obj/include -I $PWD/obj/include/uapi" \ + RHEL_RELEASE_EXTRA=%{kmod_kernel_extra} +# mark modules executable so that strip-to-file can strip them +find obj/%{kmod_kbuild_dir} -name "*.ko" -type f -exec chmod u+x '{}' + + +whitelist="/lib/modules/kabi-current/kabi_whitelist_%{_target_cpu}" + +for modules in $( find obj/%{kmod_kbuild_dir} -name "*.ko" -type f -printf "%{findpat}\n" | sed 's|\.ko$||' | sort -u ) ; do + # update depmod.conf + module_weak_path=$(echo $modules | sed 's/[\/]*[^\/]*$//') + if [ -z "$module_weak_path" ]; then + module_weak_path=%{name} + else + module_weak_path=%{name}/$module_weak_path + fi + echo "override $(echo $modules | sed 's/.*\///') $(echo %{kmod_headers_version} | sed 's/\.[^\.]*$//').* weak-updates/$module_weak_path" >> source/depmod.conf + + # update greylist + nm -u obj/%{kmod_kbuild_dir}/$modules.ko | sed 's/.*U //' | sed 's/^\.//' | sort -u | while read -r symbol; do + grep -q "^\s*$symbol\$" $whitelist || echo "$symbol" >> source/greylist + done +done +sort -u source/greylist | uniq > source/greylist.txt + +%install +export INSTALL_MOD_PATH=$RPM_BUILD_ROOT +export INSTALL_MOD_DIR=extra/%{name} +make -C %{kernel_source} modules_install V=1 \ + M=$PWD/obj/%{kmod_kbuild_dir} +# Cleanup unnecessary kernel-generated module dependency files. +find $INSTALL_MOD_PATH/lib/modules -iname 'modules.*' -exec rm {} \; + +install -m 644 -D source/depmod.conf $RPM_BUILD_ROOT/etc/depmod.d/%{kmod_name}.conf +install -m 644 -D source/greylist.txt $RPM_BUILD_ROOT/usr/share/doc/kmod-%{kmod_name}/greylist.txt + +%clean +rm -rf $RPM_BUILD_ROOT + +%changelog +* Tue Sep 17 2024 - Susan LeGendre-McGhee - 8.2.4.15-141.el9_5 +- Rebuilt for latest kernel. +- Related: RHEL-30884 + +* Tue Sep 17 2024 - Susan LeGendre-McGhee - 8.2.4.15-140.el9_5 +- Rebuilt for latest kernel. +- Related: RHEL-30884 + +* Tue Aug 27 2024 - Chung Chung - 8.2.4.15-139.el9 +- Rebuilt for latest kernel. +- Related: RHEL-30884 + +* Thu Aug 08 2024 - Chung Chung - 8.2.4.15-138.el9 +- Rebuilt for latest kernel. +- Related: RHEL-30884 + +* Mon Aug 05 2024 - Chung Chung - 8.2.4.15-137.el9 +- Rebuilt for latest kernel. +- Related: RHEL-30884 + +* Thu Aug 01 2024 - Susan LeGendre-McGhee - 8.2.4.15-136.el9 +- Fixed null pointer error with timed-out dedupt contexts. +- Made timed-out dedupe contexts available for reuse sooner. +- Added build support for more kernel versions. +- Resolves: RHEL-42515 + +* Tue Jul 30 2024 - Susan LeGendre-McGhee - 8.2.4.10-136.el9 +- Rebuilt for latest kernel. +- Related: RHEL-30884 + +* Thu Jul 11 2024 - Susan LeGendre-McGhee - 8.2.4.10-135.el9 +- Rebuilt for latest kernel. +- Related: RHEL-30884 + +* Mon Jul 08 2024 - Susan LeGendre-McGhee - 8.2.4.10-134.el9 +- Rebuilt for latest kernel. +- Related: RHEL-30884 + +* Wed Jul 03 2024 - Susan LeGendre-McGhee - 8.2.4.10-133.el9 +- Rebuilt for latest kernel. +- Related: RHEL-30884 + +* Thu Jun 20 2024 - Chung Chung - 8.2.4.10-132.el9 +- Rebuilt for latest kernel. +- Related: RHEL-30884 + +* Thu Jun 20 2024 - Chung Chung - 8.2.4.10-131.el9 +- Rebuilt for latest kernel. +- Related: RHEL-30884 + +* Fri Jun 14 2024 - Susan LeGendre-McGhee - 8.2.4.10-130.el9 +- Adapt to backported kernel changes and function deprecations. +- Resolves: RHEL-35753 + +* Wed Jun 12 2024 - Chung Chung - 8.2.3.3-129.el9 +- Rebuilt for latest kernel. +- Related: RHEL-30884 + +* Fri Jun 07 2024 - Chung Chung - 8.2.3.3-128.el9 +- Rebuilt for latest kernel. +- Related: RHEL-30884 + +* Tue Jun 04 2024 - Chung Chung - 8.2.3.3-127.el9 +- Rebuilt for latest kernel. +- Related: RHEL-30884 + +* Tue Jun 04 2024 - Chung Chung - 8.2.3.3-126.el9 +- Rebuilt for latest kernel. +- Related: RHEL-30884 + +* Wed May 22 2024 - Chung Chung - 8.2.3.3-125.el9 +- Rebuilt for latest kernel. +- Related: RHEL-30884 + +* Wed May 15 2024 - Chung Chung - 8.2.3.3-124.el9 +- Rebuilt for latest kernel. +- Related: RHEL-30884 + +* Tue May 07 2024 - Susan LeGendre-McGhee - 8.2.3.3-123.el9 +- Add temporary patch to correct build failures. +- Related: RHEL-30884 + +* Mon May 06 2024 - Susan LeGendre-McGhee - 8.2.3.3-123.el9 +- Rebuilt for latest kernel. +- Related: RHEL-30884 + +* Tue Apr 30 2024 - Susan LeGendre-McGhee - 8.2.3.3-122.el9 +- Rebuilt for latest kernel. +- Related: RHEL-30884 + +* Mon Apr 29 2024 - Susan LeGendre-McGhee - 8.2.3.3-121.el9 +- Rebuilt for latest kernel. +- Related: RHEL-30884 + +* Thu Apr 25 2024 - Susan LeGendre-McGhee - 8.2.3.3-120.el9 +- Rebuilt for latest kernel. +- Related: RHEL-30884 + +* Tue Apr 23 2024 - Susan LeGendre-McGhee - 8.2.3.3-119.el9 +- Rebuilt for latest kernel. +- Related: RHEL-30884 + +* Tue Apr 02 2024 - Susan LeGendre-McGhee - 8.2.3.3-118.el9 +- Rebuilt for latest kernel. +- Related: RHEL-30884 + +* Wed Feb 14 2024 - Susan LeGendre-McGhee - 8.2.3.3-117.el9 +- Rebuilt for latest kernel. +- Related: RHEL-11426 + +* Mon Feb 12 2024 - Susan LeGendre-McGhee - 8.2.3.3-116.el9 +- Rebuilt for latest kernel. +- Related: RHEL-11426 + +* Tue Jan 23 2024 - Chung Chung - 8.2.3.3-115.el9 +- Rebuilt for latest kernel. +- Related: RHEL-11426 + +* Fri Jan 19 2024 - Chung Chung - 8.2.3.3-114.el9 +- Rebuilt for latest kernel. +- Related: RHEL-11426 + +* Thu Jan 18 2024 - Chung Chung - 8.2.3.3-113.el9 +- Rebuilt for latest kernel. +- Related: RHEL-11426 + +* Mon Jan 15 2024 - Chung Chung - 8.2.3.3-112.el9 +- Rebuilt for latest kernel. +- Related: RHEL-11426 + +* Tue Jan 09 2024 - Chung Chung - 8.2.3.3-111.el9 +- Rebuilt for latest kernel. +- Related: RHEL-11426 + +* Wed Jan 03 2024 - Chung Chung - 8.2.3.3-110.el9 +- Rebuilt for latest kernel. +- Related: RHEL-11426 + +* Tue Dec 19 2023 - Susan LeGendre-McGhee - 8.2.3.3-109.el9 +- Rebuilt for latest kernel. +- Related: RHEL-11426 + +* Wed Dec 06 2023 - Susan LeGendre-McGhee - 8.2.3.3-108.el9 +- Rebuilt for latest kernel. +- Related: RHEL-11426 + +* Tue Dec 05 2023 - Susan LeGendre-McGhee - 8.2.3.3-107.el9 +- Revert previous changes and add kernel-64k as a conflict. +- Resolves: RHEL-8354 + +* Tue Nov 28 2023 - Susan LeGendre-McGhee - 8.2.3.3-106.el9 +- Modify to accommodate kernel-64k packages. +- Resolves: RHEL-8354 + +* Mon Nov 27 2023 - Susan LeGendre-McGhee - 8.2.3.3-105.el9 +- Rebuilt for latest kernel. +- Related: RHEL-11426 + +* Mon Nov 20 2023 - Susan LeGendre-McGhee - 8.2.3.3-104.el9 +- Rebuilt for latest kernel. +- Related: RHEL-11426 + +* Mon Nov 13 2023 - Susan LeGendre-McGhee - 8.2.3.3-103.el9 +- Rebuilt for latest kernel. +- Related: RHEL-11426 + +* Fri Nov 03 2023 - Susan LeGendre-McGhee - 8.2.3.3-102.el9 +- Rebuilt for latest kernel. +- Related: RHEL-11426 + +* Thu Oct 26 2023 - Susan LeGendre-McGhee - 8.2.3.3-101.el9 +- Rebuilt for latest kernel. +- Related: RHEL-11426 + +* Fri Oct 20 2023 - Susan LeGendre-McGhee - 8.2.3.3-100.el9 +- Adapted to backported kernel changes. +- Resolves: RHEL-11975 + +* Tue Oct 10 2023 - Susan LeGendre-McGhee - 8.2.1.6-100.el9 +- Rebuilt for latest kernel. +- Related: RHEL-11426 + +* Fri Oct 06 2023 - Susan LeGendre-McGhee - 8.2.1.6-99.el9 +- Added temporary patch file to correct build failures regarding io-factory.c +- Related: RHEL-11426 + +* Fri Oct 06 2023 - Susan LeGendre-McGhee - 8.2.1.6-99.el9 +- Rebuilt for latest kernel. +- Related: RHEL-11426 + +* Thu Aug 24 2023 - Susan LeGendre-McGhee - 8.2.1.6-98.el9 +- Rebuilt for latest kernel. +- Related: rhbz#2172911 + +* Mon Jul 31 2023 - Susan LeGendre-McGhee - 8.2.1.6-97.el9 +- Rebuilt for latest kernel. +- Related: rhbz#2172911 + +* Fri Jul 21 2023 - Susan LeGendre-McGhee - 8.2.1.6-96.el9 +- Rebuilt for latest kernel. +- Related: rhbz#2172911 + +* Tue Jul 18 2023 - Susan LeGendre-McGhee - 8.2.1.6-95.el9 +- Rebuilt for latest kernel. +- Related: rhbz#2172911 + +* Wed Jul 12 2023 - Susan LeGendre-McGhee - 8.2.1.6-94.el9 +- Rebuilt for latest kernel. +- Related: rhbz#2172911 + +* Wed Jul 05 2023 - Susan LeGendre-McGhee - 8.2.1.6-93.el9 +- Rebuilt for latest kernel. +- Related: rhbz#2172911 + +* Tue Jun 27 2023 - Susan LeGendre-McGhee - 8.2.1.6-92.el9 +- Rebuilt for latest kernel. +- Related: rhbz#2172911 + +* Tue Jun 20 2023 - Susan LeGendre-McGhee - 8.2.1.6-91.el9 +- Rebuilt for latest kernel. +- Related: rhbz#2172911 + +* Wed Jun 14 2023 - Susan LeGendre-McGhee - 8.2.1.6-90.el9 +- Rebuilt for latest kernel. +- Related: rhbz#2172911 + +* Mon Jun 12 2023 - Susan LeGendre-McGhee - 8.2.1.6-89.el9 +- Rebuilt for latest kernel. +- Related: rhbz#2172911 + +* Tue May 30 2023 - Susan LeGendre-McGhee - 8.2.1.6-88.el9 +- Rebuilt for latest kernel. +- Related: rhbz#2172911 + +* Tue May 23 2023 - Susan LeGendre-McGhee - 8.2.1.6-87.el9 +- Rebuilt for latest kernel. +- Related: rhbz#2172911 + +* Fri May 19 2023 - Susan LeGendre-McGhee - 8.2.1.6-86.el9 +- Rebuilt for latest kernel. +- Related: rhbz#2172911 + +* Wed May 17 2023 - Susan LeGendre-McGhee - 8.2.1.6-85.el9 +- Rebuilt for latest kernel. +- Related: rhbz#2172911 + +* Thu May 11 2023 - Susan LeGendre-McGhee - 8.2.1.6-84.el9 +- Rebuilt for latest kernel. +- Related: rhbz#2172911 + +* Thu May 04 2023 - Susan LeGendre-McGhee - 8.2.1.6-83.el9 +- Rebuilt for latest kernel. +- Related: rhbz#2172911 + +* Mon May 01 2023 - Susan LeGendre-McGhee - 8.2.1.6-82.el9 +- Rebuilt for latest kernel. +- Related: rhbz#2172911 + +* Tue Apr 25 2023 - Susan LeGendre-McGhee - 8.2.1.6-81.el9 +- Rebuilt for latest kernel. +- Related: rhbz#2172911 + +* Fri Apr 14 2023 - Susan LeGendre-McGhee - 8.2.1.6-80.el9 +- Rebuilt for latest kernel. +- Related: rhbz#2172911 + +* Tue Apr 11 2023 - Susan LeGendre-McGhee - 8.2.1.6-79.el9 +- Rebuilt for latest kernel. +- Related: rhbz#2172911 + +* Mon Apr 03 2023 - Susan LeGendre-McGhee - 8.2.1.6-78.el9 +- Rebuilt for latest kernel. +- Related: rhbz#2172911 + +* Thu Mar 30 2023 - Susan LeGendre-McGhee - 8.2.1.6-77.el9 +- Rebuilt for latest kernel. +- Related: rhbz#2172911 + +* Mon Mar 20 2023 - Susan LeGendre-McGhee - 8.2.1.6-76.el9 +- Rebuilt for latest kernel. +- Related: rhbz#2172911 + +* Mon Mar 13 2023 - Susan LeGendre-McGhee - 8.2.1.6-75.el9 +- Rebuilt for latest kernel. +- Related: rhbz#2172911 + +* Mon Feb 27 2023 - Susan LeGendre-McGhee - 8.2.1.6-74.el9 +- Rebuilt for latest kernel. +- Related: rhbz#2119820 + +* Tue Feb 21 2023 - Susan LeGendre-McGhee - 8.2.1.6-73.el9 +- Rebuilt for latest kernel. +- Related: rhbz#2119820 + +* Tue Feb 14 2023 - Susan LeGendre-McGhee - 8.2.1.6-72.el9 +- Fixed bug in read-only rebuild when the logical size of the volume is an + exact multiple of 821 4K blocks. +- Resolves: rhbz#2166132 + +* Thu Feb 09 2023 - Susan LeGendre-McGhee - 8.2.1.3-72.el9 +- Rebuilt for latest kernel. +- Related: rhbz#2119820 + +* Wed Feb 01 2023 - Susan LeGendre-McGhee - 8.2.1.3-71.el9 +- Rebuilt for latest kernel. +- Related: rhbz#2119820 + +* Mon Jan 30 2023 - Susan LeGendre-McGhee - 8.2.1.3-70.el9 +- Rebuilt for latest kernel. +- Related: rhbz#2119820 + +* Mon Jan 23 2023 - Susan LeGendre-McGhee - 8.2.1.3-69.el9 +- Rebuilt for latest kernel. +- Related: rhbz#2119820 + +* Fri Jan 13 2023 - Susan LeGendre-McGhee - 8.2.1.3-68.el9 +- Rebuilt for latest kernel. +- Related: rhbz#2119820 + +* Fri Jan 13 2023 - Susan LeGendre-McGhee - 8.2.1.3-67.el9 +- Rebuilt for latest kernel. +- Related: rhbz#2119820 + +* Wed Jan 04 2023 - Susan LeGendre-McGhee - 8.2.1.3-66.el9 +- Rebuilt for latest kernel. +- Related: rhbz#2119820 + +* Thu Dec 22 2022 - Susan LeGendre-McGhee - 8.2.1.3-65.el9_2 +- Rebuilt for latest kernel. +- Related: rhbz#2119820 + +* Thu Dec 15 2022 - Susan LeGendre-McGhee - 8.2.1.3-64.el9_2 +- Added a check for 0 length table line arguments. +- Resolves: rhbz#2142084 + +* Mon Dec 12 2022 - Susan LeGendre-McGhee - 8.2.1.2-64.el9_2 +- Rebuilt for latest kernel. +- Related: rhbz#2119820 + +* Wed Dec 07 2022 - Susan LeGendre-McGhee - 8.2.1.2-63.el9_2 +- Rebuilt for latest kernel. +- Related: rhbz#2119820 + +* Mon Nov 28 2022 - Susan LeGendre-McGhee - 8.2.1.2-62.el9_2 +- Rebuilt for latest kernel. +- Related: rhbz#2119820 + +* Tue Nov 22 2022 - Susan LeGendre-McGhee - 8.2.1.2-61.el9_2 +- Rebuilt for latest kernel. +- Related: rhbz#2119820 + +* Fri Nov 18 2022 - Susan LeGendre-McGhee - 8.2.1.2-60.el9_2 +- Rebuilt for latest kernel. +- Related: rhbz#2119820 + +* Tue Nov 15 2022 - Susan LeGendre-McGhee - 8.2.1.2-59.el9_2 +- Adapted to backported kernel changes. +- Resolves: rhbz#2139179 + +* Fri Nov 11 2022 - Susan LeGendre-McGhee - 8.2.0.18-59.el9_2 +- Rebuilt for latest kernel. +- Related: rhbz#2119820 + +* Wed Nov 9 2022 - Susan LeGendre-McGhee - 8.2.0.18-58.el9_2 +- Rebuilt for latest kernel. +- Related: rhbz#2119820 + +* Tue Nov 8 2022 - Susan LeGendre-McGhee - 8.2.0.18-57.el9_2 +- Rebuilt for latest kernel. +- Related: RHELPLAN-131751 + +* Mon Nov 7 2022 - Susan LeGendre-McGhee - 8.2.0.18-56.el9_2 +- Rebuilt for latest kernel. +- Related: rhbz#2119820 + +* Thu Nov 3 2022 - Susan LeGendre-McGhee - 8.2.0.18-55.el9_2 +- Rebuilt for latest kernel. +- Related: rhbz#2119820 + +* Mon Oct 31 2022 - Susan LeGendre-McGhee - 8.2.0.18-54.el9_2 +- Rebuilt for latest kernel. +- Related: rhbz#2119820 + +* Thu Oct 27 2022 - Susan LeGendre-McGhee - 8.2.0.18-53.el9_2 +- Rebuilt for latest kernel. +- Related: rhbz#2119820 + +* Wed Oct 26 2022 - Susan LeGendre-McGhee - 8.2.0.18-52.el9_2 +- Temporarily patched to remove bdevname usage and correct build failure. +- Related: rhbz#2119820 + +* Wed Oct 26 2022 - Susan LeGendre-McGhee - 8.2.0.18-52.el9_2 +- Rebuilt for latest kernel. +- Related: rhbz#2119820 + +* Mon Oct 17 2022 - Susan LeGendre-McGhee - 8.2.0.18-51.el9_2 +- Rebuilt for latest kernel. +- Related: rhbz#2119820 + +* Wed Oct 12 2022 - Susan LeGendre-McGhee - 8.2.0.18-50.el9_2 +- Rebuilt for latest kernel. +- Related: rhbz#2119820 + +* Wed Sep 28 2022 - Susan LeGendre-McGhee - 8.2.0.18-49.el9_2 +- Rebuilt for latest kernel. +- Related: rhbz#2119820 + +* Fri Sep 23 2022 - Susan LeGendre-McGhee - 8.2.0.18-48.el9_2 +- Rebuilt for latest kernel. +- Related: rhbz#2119820 + +* Mon Sep 19 2022 - Susan LeGendre-McGhee - 8.2.0.18-47.el9_2 +- Rebuilt for latest kernel. +- Related: rhbz#2119820 +- Adjust scriplets that use /var/lib to use /usr/lib for ostree environments. +- Resolves: rhbz#2105013 + +* Tue Sep 13 2022 - Andy Walsh - 8.2.0.18-46.el9_2 +- Rebuilt for latest kernel. +- Related: rhbz#2119820 + +* Wed Aug 24 2022 - Andy Walsh - 8.2.0.18-46 +- Temporarily dropped a check that validates the logical size specified from + the table line. +- Related: rhbz#2071648 + +* Tue Aug 23 2022 - Andy Walsh - 8.2.0.18-45 +- Fixed a race handling timeouts of dedupe requests. +- Resolves: rhbz#2115504 + +* Tue Aug 23 2022 - Susan LeGendre-McGhee - 8.2.0.2-45 +- Rebuilt for latest kernel. +- Related: rhbz#2060486 + +* Thu Aug 18 2022 - Susan LeGendre-McGhee - 8.2.0.2-44 +- Rebuilt for latest kernel. +- Related: rhbz#2060486 + +* Wed Aug 10 2022 - Chung Chung - 8.2.0.2-43 +- Rebuilt for latest kernel. +- Related: rhbz#2060486 + +* Wed Jul 27 2022 - Andy Walsh - 8.2.0.2-42 +- Added missing lz4 libs to rebased code +- Resolves: rhbz#2071648 + +* Tue Jul 19 2022 - Andy Walsh - 8.2.0.2-41 +- Rebased to latest upstream candidate. +- Resolves: rhbz#2071648 + +* Sat Jul 16 2022 - Susan LeGendre-McGhee - 8.1.1.371-41 +- Rebuilt for latest kernel. +- Related: rhbz#2060486 + +* Fri Jul 15 2022 - Susan LeGendre-McGhee - 8.1.1.371-40 +- Rebuilt for latest kernel. +- Related: rhbz#2060486 + +* Mon Jul 11 2022 - Chung Chung - 8.1.1.371-39 +- Rebuilt for latest kernel. +- Related: rhbz#2060486 + +* Tue Jul 05 2022 - Chung Chung - 8.1.1.371-38 +- Rebuilt for latest kernel. +- Related: rhbz#2060486 + +* Mon Jul 04 2022 - Chung Chung - 8.1.1.371-37 +- Rebuilt for latest kernel. +- Related: rhbz#2060486 + +* Tue Jun 28 2022 - Susan LeGendre-McGhee - 8.1.1.371-36 +- TEMPORARY FIX to correct build failures regarding bio_reset(), __bio_clone_fast(), and bio_init(). +- Related: rhbz#2060486 + +* Tue Jun 28 2022 - Susan LeGendre-McGhee - 8.1.1.371-36 +- Rebuilt for latest kernel. +- Related: rhbz#2060486 + +* Sun Jun 26 2022 - Chung Chung - 8.1.1.371-35 +- Rebuilt for latest kernel. +- Related: rhbz#2060486 + +* Wed Jun 15 2022 - Andy Walsh - 8.1.1.371-34 +- Rebuilt for latest kernel. +- Related: rhbz#2060486 + +* Tue Jun 07 2022 - Andy Walsh - 8.1.1.371-33 +- Rebuilt for latest kernel. +- Related: rhbz#2060486 + +* Wed Jun 01 2022 - Andy Walsh - 8.1.1.371-32 +- Rebased to newer version. +- Related: rhbz#2071648 + +* Tue May 31 2022 - Andy Walsh - 8.1.1.360-32 +- Rebuilt for latest kernel. +- Related: rhbz#2060486 + +* Sat May 28 2022 - Andy Walsh - 8.1.1.360-31 +- Rebuilt for latest kernel. +- Related: rhbz#2060486 + +* Mon May 23 2022 - Andy Walsh - 8.1.1.360-30 +- Rebuilt for latest kernel. +- Related: rhbz#2060486 + +* Mon May 16 2022 - Andy Walsh - 8.1.1.360-29 +- Rebuilt for latest kernel. +- Related: rhbz#2060486 + +* Fri May 13 2022 - Andy Walsh - 8.1.1.360-28 +- Rebuilt for latest kernel. +- Related: rhbz#2060486 + +* Thu May 12 2022 - Andy Walsh - 8.1.1.360-27 +- Rebuilt for latest kernel. +- Related: rhbz#2060486 + +* Tue May 10 2022 - Andy Walsh - 8.1.1.360-26 +- Rebuilt for latest kernel. +- Related: rhbz#2060486 + +* Sat May 07 2022 - Andy Walsh - 8.1.1.360-25 +- Rebuilt for latest kernel. +- Related: rhbz#2060486 + +* Thu May 05 2022 - Andy Walsh - 8.1.1.360-24 +- Rebuilt for latest kernel. +- Related: rhbz#2060486 + +* Wed May 04 2022 - Andy Walsh - 8.1.1.360-23 +- Rebuilt for latest kernel. +- Related: rhbz#2060486 + +* Fri Apr 29 2022 - Andy Walsh - 8.1.1.360-22 +- Rebuilt for latest kernel. +- Related: rhbz#2060486 + +* Fri Apr 22 2022 - Andy Walsh - 8.1.1.360-21 +- Rebuilt for latest kernel. +- Related: rhbz#2060486 + +* Thu Apr 21 2022 - Andy Walsh - 8.1.1.360-20 +- Rebuilt for latest kernel. +- Related: rhbz#2060486 + +* Wed Apr 13 2022 - Andy Walsh - 8.1.1.360-19 +- Rebuilt for latest kernel. +- Related: rhbz#2060486 + +* Mon Apr 11 2022 - Andy Walsh - 8.1.1.360-18 +- Rebuilt for latest kernel. +- Related: rhbz#2060486 + +* Mon Mar 28 2022 - Andy Walsh - 8.1.1.360-17 +- Rebuilt for latest kernel. +- Related: rhbz#2060486 + +* Mon Mar 21 2022 - Andy Walsh - 8.1.1.360-16 +- Rebuilt for latest kernel. +- Related: rhbz#2060486 + +* Mon Feb 28 2022 - Andy Walsh - 8.1.1.360-15 +- Rebuilt for latest kernel. +- Related: rhbz#2000926 + +* Mon Feb 21 2022 - Andy Walsh - 8.1.1.360-14 +- Rebuilt for latest kernel. +- Related: rhbz#2000926 + +* Wed Feb 16 2022 - Andy Walsh - 8.1.1.360-13 +- Rebuilt for latest kernel. +- Related: rhbz#2000926 + +* Sat Feb 12 2022 - Andy Walsh - 8.1.1.360-12 +- Fixed a compilation issue due to changes in stdarg.h. +- Resolves: rhbz#2035003 +- Modified the UDS index to handle backing store changes while suspended. +- Resolves: rhbz#2007803 +- Fixed a bug which prevented the resumption of a suspended read-only vdo. +- Resolves: rhbz#2004206 + +* Thu Feb 03 2022 - Andy Walsh - 8.1.1.287-12 +- Adjusted kernel dependencies to grab the right packages. +- Resolves: rhbz#2022464 +- Rebuilt for latest kernel. +- Related: rhbz#2000926 + +* Mon Jan 31 2022 - Andy Walsh - 8.1.1.287-11 +- Rebuilt for latest kernel. +- Related: rhbz#2000926 + +* Sun Jan 23 2022 - Andy Walsh - 8.1.1.287-10 +- Eliminated uses of "master" as part of the conscious language initiative. +- Resolves: rhbz#2023970 +- Fixed potential use-after-free error found by Coverity. +- Resolves: rhbz#1999056 +- Fixed bug which could result in empty flushes being issued to the storage + below vdo while suspended. +- Resolves: rhbz#2013057 +- Added optional table line parameters for enabling or disabling + deduplication and compression. +- Resolves: rhbz#2007444 +- Adapted to kernel API changes. +- Resolves: rhbz#2035003 + +* Thu Jan 06 2022 - Andy Walsh - 8.1.0.316-10 +- Rebuilt for latest kernel. +- Related: rhbz#2000926 +- Temporarily disabled creation of sysfs nodes. +- Related: rhbz#2035003 + +* Sun Dec 19 2021 - Andy Walsh - 8.1.0.316-9 +- Rebuilt for latest kernel. +- Related: rhbz#2000926 +- Stopped using bvec_kmap_irq as it has been removed. +- Removed usage of removed elevator constants +- Resolves: rhbz#2035003 + +* Wed Dec 15 2021 - Andy Walsh - 8.1.0.316-8 +- Rebuilt for latest kernel. +- Related: rhbz#2000926 + +* Tue Dec 07 2021 - Andy Walsh - 8.1.0.316-7 +- Rebuilt for latest kernel. +- Related: rhbz#2000926 + +* Tue Dec 07 2021 - Andy Walsh - 8.1.0.316-6 +- Rebuilt for latest kernel. +- Related: rhbz#2000926 + +* Thu Nov 11 2021 - Andy Walsh - 8.1.0.316-5 +- Rebuilt for latest kernel. +- Related: rhbz#2000926 + +* Wed Oct 13 2021 - Andy Walsh - 8.1.0.316-4 +- Rebuilt for latest kernel. +- Related: rhbz#2000926 + +* Thu Sep 30 2021 - Andy Walsh - 8.1.0.316-3 +- Rebuilt for latest kernel. +- Related: rhbz#2000926 + +* Mon Aug 09 2021 - Andy Walsh - 8.1.0.316-2 +- Rebased to upstream candidate. +- Resolves: rhbz#1955374 + +* Mon Aug 09 2021 Mohan Boddu - 8.1.0.316-1.1 +- Rebuilt for IMA sigs, glibc 2.34, aarch64 flags + Related: rhbz#1991688 + +* Sat Aug 07 2021 - Andy Walsh - 8.1.0.316-1 +- Rebased to upstream candidate. +- Resolves: rhbz#1955374 + +* Thu Jul 29 2021 - Andy Walsh - 8.1.0.264-1 +- Rebased to upstream candidate. +- Related: rhbz#1955374 +- Fixed GCC implicit-fallthrough errors when building for latest kernel +- Resolves: rhbz#1984814 + +* Tue May 04 2021 - Andy Walsh - 8.1.0.4-1 +- Initial build for EL9 +- Related: rhbz#1955374 diff --git a/removed-logical-space-check-from-table-line.patch b/removed-logical-space-check-from-table-line.patch new file mode 100644 index 0000000..3afc90d --- /dev/null +++ b/removed-logical-space-check-from-table-line.patch @@ -0,0 +1,34 @@ +From 8fb4ef85097e7b46cb3604612a49e480efd4465a Mon Sep 17 00:00:00 2001 +From: Andrew Walsh +Date: Wed, 24 Aug 2022 12:00:12 -0400 +Subject: [PATCH] Removed logical space check from table line. + +Until the LVM tooling can be updated to use accurate sizes, this check +can't be implemented. + +Signed-off-by: Andrew Walsh +--- + vdo/vdo-component.c | 7 ------- + 1 file changed, 7 deletions(-) + +diff --git a/vdo/vdo-component.c b/vdo/vdo-component.c +index ac1ac1f7..50ba438b 100644 +--- a/vdo/vdo-component.c ++++ b/vdo/vdo-component.c +@@ -303,13 +303,6 @@ int vdo_validate_config(const struct vdo_config *config, + if (result != UDS_SUCCESS) { + return result; + } +- +- if (logical_block_count != config->logical_blocks) { +- uds_log_error("A logical size of %llu blocks was specified, but that differs from the %llu blocks configured in the vdo super block", +- (unsigned long long) logical_block_count, +- (unsigned long long) config->logical_blocks); +- return VDO_PARAMETER_MISMATCH; +- } + } + + result = ASSERT(config->logical_blocks <= MAXIMUM_VDO_LOGICAL_BLOCKS, +-- +2.37.1 + diff --git a/sources b/sources new file mode 100644 index 0000000..1ac21d8 --- /dev/null +++ b/sources @@ -0,0 +1 @@ +SHA512 (kvdo-7c54552.tar.gz) = f931a3cf94263776a1a25caffd96e3a7084901c5d25af2ce7c19cc9e67d32b7ba18158efbf7138287937b7aa035ead5e49307b24fafcc19f6389f0f2d63eed41 diff --git a/tests/.fmf/version b/tests/.fmf/version new file mode 100644 index 0000000..d00491f --- /dev/null +++ b/tests/.fmf/version @@ -0,0 +1 @@ +1 diff --git a/tests/provision.fmf b/tests/provision.fmf new file mode 100644 index 0000000..c4bef80 --- /dev/null +++ b/tests/provision.fmf @@ -0,0 +1,4 @@ +--- +standard-inventory-qcow2: + qemu: + m: 4G diff --git a/tests/sanity/Makefile b/tests/sanity/Makefile new file mode 100644 index 0000000..84d7421 --- /dev/null +++ b/tests/sanity/Makefile @@ -0,0 +1,62 @@ +# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +# +# Makefile of /kernel/test_beakertask/Sanity/beaker_test +# Description: Install VDO +# +# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +# +# Copyright (c) 2018 Red Hat, 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 2 of +# the License, 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, see http://www.gnu.org/licenses/. +# +# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +export TEST=/beaker_test +export TESTVERSION=1.0 + +BUILT_FILES= + +FILES=$(METADATA) runtest.sh Makefile PURPOSE + +.PHONY: all install download clean + +run: $(FILES) build + ./runtest.sh + +build: $(BUILT_FILES) + test -x runtest.sh || chmod a+x runtest.sh + +clean: + rm -f *~ $(BUILT_FILES) + + +include /usr/share/rhts/lib/rhts-make.include + +$(METADATA): Makefile + @echo "Owner: Andy Walsh " > $(METADATA) + @echo "Name: $(TEST)" >> $(METADATA) + @echo "TestVersion: $(TESTVERSION)" >> $(METADATA) + @echo "Path: $(TEST_DIR)" >> $(METADATA) + @echo "Description: Loads VDO kernel modules" >> $(METADATA) + @echo "Type: Sanity" >> $(METADATA) + @echo "TestTime: 5m" >> $(METADATA) + @echo "RunFor: test_beakertask" >> $(METADATA) + @echo "Requires: test_beakertask" >> $(METADATA) + @echo "Priority: Normal" >> $(METADATA) + @echo "License: GPLv2+" >> $(METADATA) + @echo "Confidential: no" >> $(METADATA) + @echo "Destructive: no" >> $(METADATA) + @echo "Releases: -RHEL4 -RHELClient5 -RHELServer5" >> $(METADATA) + + rhts-lint $(METADATA) diff --git a/tests/sanity/PURPOSE b/tests/sanity/PURPOSE new file mode 100644 index 0000000..50439b3 --- /dev/null +++ b/tests/sanity/PURPOSE @@ -0,0 +1,3 @@ +PURPOSE Test the kmod-kvdo packaged drivers +Description: Load the VDO modules into the kernel. +Author: Andy Walsh diff --git a/tests/sanity/runtest.sh b/tests/sanity/runtest.sh new file mode 100644 index 0000000..1dbb288 --- /dev/null +++ b/tests/sanity/runtest.sh @@ -0,0 +1,57 @@ +#!/bin/bash +# vim: dict+=/usr/share/beakerlib/dictionary.vim cpt=.,w,b,u,t,i,k +# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +# +# runtest.sh of kmod-kvdo/sanity +# Description: Checking that the kmod-kvdo kernel modules can be loaded. +# Author: Andy Walsh +# +# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +# +# Copyright (c) 2019 Red Hat, 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 2 of +# the License, 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, see http://www.gnu.org/licenses/. +# +# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +# Include Beaker environment +. /usr/bin/rhts-environment.sh || exit 1 +. /usr/share/beakerlib/beakerlib.sh || exit 1 + +rlJournalStart + rlPhaseStartSetup + # Collect information + rlLog "uname: $(uname -a)" + rlPhaseEnd + + rlPhaseStartTest "Confirm kvdo module is installed" + rlRun "find /lib/modules -type f -name kvdo.ko" + rlPhaseEnd + + rlPhaseStartTest "Validate module information" + rlRun "modinfo -l kvdo" + rlPhaseEnd + + rlPhaseStartTest "Confirm the kvdo module can be loaded" + rlRun "modprobe kvdo" + rlRun "lsmod | grep kvdo" + rlPhaseEnd + + rlPhaseStartCleanup "Unload the kvdo module" + rlRun "modprobe -r kvdo" + rlPhaseEnd + + rlJournalPrintText +rlJournalEnd + diff --git a/tests/smoke/Makefile b/tests/smoke/Makefile new file mode 100644 index 0000000..86ef186 --- /dev/null +++ b/tests/smoke/Makefile @@ -0,0 +1,62 @@ +# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +# +# Makefile of /kernel/test_beakertask/Sanity/beaker_test +# Description: Install VDO +# +# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +# +# Copyright (c) 2018 Red Hat, 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 2 of +# the License, 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, see http://www.gnu.org/licenses/. +# +# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +export TEST=/beaker_test +export TESTVERSION=1.0 + +BUILT_FILES= + +FILES=$(METADATA) runtest.sh Makefile PURPOSE + +.PHONY: all install download clean + +run: $(FILES) build + ./runtest.sh + +build: $(BUILT_FILES) + test -x runtest.sh || chmod a+x runtest.sh + +clean: + rm -f *~ $(BUILT_FILES) + + +include /usr/share/rhts/lib/rhts-make.include + +$(METADATA): Makefile + @echo "Owner: Andy Walsh " > $(METADATA) + @echo "Name: $(TEST)" >> $(METADATA) + @echo "TestVersion: $(TESTVERSION)" >> $(METADATA) + @echo "Path: $(TEST_DIR)" >> $(METADATA) + @echo "Description: Installs VDO" >> $(METADATA) + @echo "Type: Sanity" >> $(METADATA) + @echo "TestTime: 5m" >> $(METADATA) + @echo "RunFor: test_beakertask" >> $(METADATA) + @echo "Requires: test_beakertask" >> $(METADATA) + @echo "Priority: Normal" >> $(METADATA) + @echo "License: GPLv2+" >> $(METADATA) + @echo "Confidential: no" >> $(METADATA) + @echo "Destructive: no" >> $(METADATA) + @echo "Releases: -RHEL4 -RHELClient5 -RHELServer5" >> $(METADATA) + + rhts-lint $(METADATA) diff --git a/tests/smoke/PURPOSE b/tests/smoke/PURPOSE new file mode 100644 index 0000000..bdd185d --- /dev/null +++ b/tests/smoke/PURPOSE @@ -0,0 +1,3 @@ +PURPOSE Test the kmod-kvdo package for basic functionality +Description: Tests the VDO software for basic functionality. +Author: Andy Walsh diff --git a/tests/smoke/runtest.sh b/tests/smoke/runtest.sh new file mode 100644 index 0000000..399b58e --- /dev/null +++ b/tests/smoke/runtest.sh @@ -0,0 +1,170 @@ +#!/bin/bash +# vim: dict+=/usr/share/beakerlib/dictionary.vim cpt=.,w,b,u,t,i,k +# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +# +# runtest.sh of VDO smoke test +# Description: Check that VDO is able to read/write data and start/stop +# Author: Andy Walsh +# +# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +# +# Copyright (c) 2018 Red Hat, 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 2 of +# the License, 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, see http://www.gnu.org/licenses/. +# +# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +# Include Beaker environment +. /usr/bin/rhts-environment.sh || exit 1 +. /usr/share/beakerlib/beakerlib.sh || exit 1 + +function insertModuleWithDMesgOutput() { + moduleName=$1 + + modulePath=$(rpm -ql kmod-kvdo | grep "${1}.ko$") + + exitVal=0 + rlRun "dmesg -c > /dev/null" + rlRun "insmod ${modulePath}" || exitVal=255 + rlRun "dmesg" + + if [ ${exitVal} -ne 0 ]; then + rlDie "Exiting with failure due to module/kernel incompatibility" + fi +} + +rlJournalStart + +rlPhaseStartSetup "Create backing device" + rlRun "TmpDir=\$(mktemp -d)" 0 "Creating tmp directory" + rlRun "pushd $TmpDir" + rlRun "df ." + + # If we end up with less than 15G of available space, then we can't + # create a VDO volume sufficient for testing. We should bail out as a + # result. + loopbackSize=$(($(df --sync --output=avail / | tail -1) * 1024 - 1024*1024*1024)) + if [ ${loopbackSize} -lt $((1024*1024*1024*15)) ]; then + rlDie "Not enough space to create loopback device." + fi + rlRun "truncate -s ${loopbackSize} $TmpDir/loop0.bin" 0 "Laying out loopfile backing" + rlRun "losetup /dev/loop0 $TmpDir/loop0.bin" 0 "Creating loopdevice" + rlRun "mkdir -p /mnt/testmount" 0 "Creating test mountpoint dir" +rlPhaseEnd + +rlPhaseStartTest "Gather Relevant Info" + # Gather some system information for debug purposes + rlRun "uname -a" + rlRun "find /lib/modules -name kvdo.ko" + rlRun "modinfo kvdo" || insertModuleWithDMesgOutput kvdo +rlPhaseEnd + +rlPhaseStartTest "Generate Test Data" + # Write some data, check statistics + rlRun "dd if=/dev/urandom of=${TmpDir}/urandom_fill_file bs=1M count=100" + rlRun "ls -lh ${TmpDir}/urandom_fill_file" +rlPhaseEnd + +for partition_type in "raw" "lvm" +do + case $partition_type in + "raw"*) + backing_device=/dev/loop0 + ;; + "lvm"*) + rlPhaseStartTest "Create LVM backing device" + rlRun "pvcreate /dev/loop0" 0 "Creating PV" + rlRun "vgcreate vdo_base /dev/loop0" 0 "Creating VG" + rlRun "lvcreate -n vdo_base -l100%FREE vdo_base" 0 "Creating LV" + rlPhaseEnd + backing_device=/dev/vdo_base/vdo_base + ;; + *) + ;; + esac + + rlPhaseStartTest "LVM-VDO Smoke Test" + # Create the VDO volume and get the initial statistics + rlRun "pvcreate --config devices/scan_lvs=1 ${backing_device}" + rlRun "vgcreate --config devices/scan_lvs=1 vdo_data ${backing_device}" + rlRun "lvcreate --config devices/scan_lvs=1 --type vdo -L 9G -V 100G -n vdo0 vdo_data/vdopool" + + # Create a filesystem and mount the device, check statistics + rlRun "mkfs.xfs -K /dev/vdo_data/vdo0" 0 "Making xfs filesystem on VDO volume" + rlRun "mount -o discard /dev/vdo_data/vdo0 /mnt/testmount" 0 "Mounting xfs filesystem on VDO volume" + rlRun "df --sync /mnt/testmount" + rlRun "vdostats vdo_data-vdopool-vpool" + + # Copy the test data onto VDO volume 4 times to get some deduplication + for i in {1..4} + do + rlRun "cp ${TmpDir}/urandom_fill_file /mnt/testmount/test_file-${i}" + done + rlRun "df --sync /mnt/testmount" + rlRun "vdostats vdo_data-vdopool-vpool" + + # Verify the data + for i in {1..4} + do + rlRun "cmp ${TmpDir}/urandom_fill_file /mnt/testmount/test_file-${i}" + done + + # Unmount and stop the volume, check statistics + rlRun "umount /mnt/testmount" 0 "Unmounting testmount" + rlRun "vdostats vdo_data-vdopool-vpool" + rlRun "lvchange --config devices/scan_lvs=1 -an vdo_data/vdo0" + + # Start the VDO volume, mount it, check statistics, verify data. + rlRun "lvchange --config devices/scan_lvs=1 -ay vdo_data/vdo0" + rlRun "mount -o discard /dev/vdo_data/vdo0 /mnt/testmount" 0 "Mounting xfs filesystem on VDO volume" + + rlRun "df --sync /mnt/testmount" + rlRun "vdostats vdo_data-vdopool-vpool" + + # Verify the data + for i in {1..4} + do + rlRun "cmp ${TmpDir}/urandom_fill_file /mnt/testmount/test_file-${i}" + done + rlPhaseEnd + + rlPhaseStartCleanup + rlRun "umount /mnt/testmount" 0 "Unmounting testmount" + rlRun "lvremove --config devices/scan_lvs=1 -ff vdo_data/vdo0" 0 "Removing VDO volume vdo0" + case $partition_type in + "lvm"*) + rlPhaseStartCleanup + rlRun "lvremove -ff ${backing_device}" 0 "Removing LV" + rlRun "vgremove vdo_base" 0 "Removing VG" + rlRun "pvremove /dev/loop0" 0 "Removing PV" + rlPhaseEnd + ;; + *) + ;; + esac + + rlRun "dd if=/dev/zero of=/dev/loop0 bs=1M count=10 oflag=direct" 0 "Wiping Block Device" + + rlPhaseEnd +done + +rlPhaseStartCleanup + rlRun "losetup -d /dev/loop0" 0 "Deleting loopdevice" + rlRun "rm -f $TmpDir/loop0.bin" 0 "Removing loopfile backing" + rlRun "popd" + rlRun "rm -r $TmpDir" 0 "Removing tmp directory" +rlPhaseEnd + +rlJournalPrintText +rlJournalEnd diff --git a/tests/tests.yml b/tests/tests.yml new file mode 100644 index 0000000..12ad9dc --- /dev/null +++ b/tests/tests.yml @@ -0,0 +1,16 @@ +- hosts: localhost + tags: + - classic + roles: + - role: standard-test-beakerlib + tests: + - sanity + - smoke + required_packages: + - vdo + - device-mapper-event + - device-mapper-event-libs + - device-mapper-persistent-data + - libaio + - lvm2 + - lvm2-libs