Magellan Linux

  • Back to homepage
    • /[pkg-src]/trunk/kernel-alx-legacy/patches-4.9/0146-4.9.47-all-fixes.patch

    Annotation of /trunk/kernel-alx-legacy/patches-4.9/0146-4.9.47-all-fixes.patch

    Parent Directory Parent Directory | Revision Log Revision Log

    Revision 3608 - (hide annotations) (download)
    Fri Aug 14 07:34:29 2020 UTC (3 years, 8 months ago) by niro
    File size: 16062 byte(s) 
    -added kerenl-alx-legacy pkg
    1 niro 3608 diff --git a/Makefile b/Makefile
    2     index 846ef1b57a02..a0abbfc15a49 100644
    3     --- a/Makefile
    4     +++ b/Makefile
    5     @@ -1,6 +1,6 @@
    6     VERSION = 4
    7     PATCHLEVEL = 9
    8     -SUBLEVEL = 46
    9     +SUBLEVEL = 47
    10     EXTRAVERSION =
    11     NAME = Roaring Lionus
    12    
    13     diff --git a/arch/arm/kvm/mmu.c b/arch/arm/kvm/mmu.c
    14     index 710511cadd50..0c060c5e844a 100644
    15     --- a/arch/arm/kvm/mmu.c
    16     +++ b/arch/arm/kvm/mmu.c
    17     @@ -829,22 +829,22 @@ void stage2_unmap_vm(struct kvm *kvm)
    18     * Walks the level-1 page table pointed to by kvm->arch.pgd and frees all
    19     * underlying level-2 and level-3 tables before freeing the actual level-1 table
    20     * and setting the struct pointer to NULL.
    21     - *
    22     - * Note we don't need locking here as this is only called when the VM is
    23     - * destroyed, which can only be done once.
    24     */
    25     void kvm_free_stage2_pgd(struct kvm *kvm)
    26     {
    27     - if (kvm->arch.pgd == NULL)
    28     - return;
    29     + void *pgd = NULL;
    30    
    31     spin_lock(&kvm->mmu_lock);
    32     - unmap_stage2_range(kvm, 0, KVM_PHYS_SIZE);
    33     + if (kvm->arch.pgd) {
    34     + unmap_stage2_range(kvm, 0, KVM_PHYS_SIZE);
    35     + pgd = kvm->arch.pgd;
    36     + kvm->arch.pgd = NULL;
    37     + }
    38     spin_unlock(&kvm->mmu_lock);
    39    
    40     /* Free the HW pgd, one page at a time */
    41     - free_pages_exact(kvm->arch.pgd, S2_PGD_SIZE);
    42     - kvm->arch.pgd = NULL;
    43     + if (pgd)
    44     + free_pages_exact(pgd, S2_PGD_SIZE);
    45     }
    46    
    47     static pud_t *stage2_get_pud(struct kvm *kvm, struct kvm_mmu_memory_cache *cache,
    48     diff --git a/arch/arm64/kernel/fpsimd.c b/arch/arm64/kernel/fpsimd.c
    49     index 394c61db5566..1d5890f19ca3 100644
    50     --- a/arch/arm64/kernel/fpsimd.c
    51     +++ b/arch/arm64/kernel/fpsimd.c
    52     @@ -157,9 +157,11 @@ void fpsimd_thread_switch(struct task_struct *next)
    53    
    54     void fpsimd_flush_thread(void)
    55     {
    56     + preempt_disable();
    57     memset(&current->thread.fpsimd_state, 0, sizeof(struct fpsimd_state));
    58     fpsimd_flush_task_state(current);
    59     set_thread_flag(TIF_FOREIGN_FPSTATE);
    60     + preempt_enable();
    61     }
    62    
    63     /*
    64     diff --git a/arch/arm64/mm/fault.c b/arch/arm64/mm/fault.c
    65     index 0e90c7e0279c..fec5b1ce97f8 100644
    66     --- a/arch/arm64/mm/fault.c
    67     +++ b/arch/arm64/mm/fault.c
    68     @@ -373,8 +373,11 @@ static int __kprobes do_page_fault(unsigned long addr, unsigned int esr,
    69     * signal first. We do not need to release the mmap_sem because it
    70     * would already be released in __lock_page_or_retry in mm/filemap.c.
    71     */
    72     - if ((fault & VM_FAULT_RETRY) && fatal_signal_pending(current))
    73     + if ((fault & VM_FAULT_RETRY) && fatal_signal_pending(current)) {
    74     + if (!user_mode(regs))
    75     + goto no_context;
    76     return 0;
    77     + }
    78    
    79     /*
    80     * Major/minor page fault accounting is only done on the initial
    81     diff --git a/arch/x86/include/asm/io.h b/arch/x86/include/asm/io.h
    82     index d34bd370074b..6c5020163db0 100644
    83     --- a/arch/x86/include/asm/io.h
    84     +++ b/arch/x86/include/asm/io.h
    85     @@ -304,13 +304,13 @@ static inline unsigned type in##bwl##_p(int port) \
    86     static inline void outs##bwl(int port, const void *addr, unsigned long count) \
    87     { \
    88     asm volatile("rep; outs" #bwl \
    89     - : "+S"(addr), "+c"(count) : "d"(port)); \
    90     + : "+S"(addr), "+c"(count) : "d"(port) : "memory"); \
    91     } \
    92     \
    93     static inline void ins##bwl(int port, void *addr, unsigned long count) \
    94     { \
    95     asm volatile("rep; ins" #bwl \
    96     - : "+D"(addr), "+c"(count) : "d"(port)); \
    97     + : "+D"(addr), "+c"(count) : "d"(port) : "memory"); \
    98     }
    99    
    100     BUILDIO(b, b, char)
    101     diff --git a/drivers/net/wireless/intersil/p54/fwio.c b/drivers/net/wireless/intersil/p54/fwio.c
    102     index 257a9eadd595..4ac6764f4897 100644
    103     --- a/drivers/net/wireless/intersil/p54/fwio.c
    104     +++ b/drivers/net/wireless/intersil/p54/fwio.c
    105     @@ -488,7 +488,7 @@ int p54_scan(struct p54_common *priv, u16 mode, u16 dwell)
    106    
    107     entry += sizeof(__le16);
    108     chan->pa_points_per_curve = 8;
    109     - memset(chan->curve_data, 0, sizeof(*chan->curve_data));
    110     + memset(chan->curve_data, 0, sizeof(chan->curve_data));
    111     memcpy(chan->curve_data, entry,
    112     sizeof(struct p54_pa_curve_data_sample) *
    113     min((u8)8, curve_data->points_per_channel));
    114     diff --git a/drivers/scsi/isci/remote_node_context.c b/drivers/scsi/isci/remote_node_context.c
    115     index 1910100638a2..00602abec0ea 100644
    116     --- a/drivers/scsi/isci/remote_node_context.c
    117     +++ b/drivers/scsi/isci/remote_node_context.c
    118     @@ -66,6 +66,9 @@ const char *rnc_state_name(enum scis_sds_remote_node_context_states state)
    119     {
    120     static const char * const strings[] = RNC_STATES;
    121    
    122     + if (state >= ARRAY_SIZE(strings))
    123     + return "UNKNOWN";
    124     +
    125     return strings[state];
    126     }
    127     #undef C
    128     diff --git a/drivers/scsi/sg.c b/drivers/scsi/sg.c
    129     index f753df25ba34..fed37aabf828 100644
    130     --- a/drivers/scsi/sg.c
    131     +++ b/drivers/scsi/sg.c
    132     @@ -142,6 +142,7 @@ typedef struct sg_fd { /* holds the state of a file descriptor */
    133     struct sg_device *parentdp; /* owning device */
    134     wait_queue_head_t read_wait; /* queue read until command done */
    135     rwlock_t rq_list_lock; /* protect access to list in req_arr */
    136     + struct mutex f_mutex; /* protect against changes in this fd */
    137     int timeout; /* defaults to SG_DEFAULT_TIMEOUT */
    138     int timeout_user; /* defaults to SG_DEFAULT_TIMEOUT_USER */
    139     Sg_scatter_hold reserve; /* buffer held for this file descriptor */
    140     @@ -155,6 +156,7 @@ typedef struct sg_fd { /* holds the state of a file descriptor */
    141     unsigned char next_cmd_len; /* 0: automatic, >0: use on next write() */
    142     char keep_orphan; /* 0 -> drop orphan (def), 1 -> keep for read() */
    143     char mmap_called; /* 0 -> mmap() never called on this fd */
    144     + char res_in_use; /* 1 -> 'reserve' array in use */
    145     struct kref f_ref;
    146     struct execute_work ew;
    147     } Sg_fd;
    148     @@ -198,7 +200,6 @@ static void sg_remove_sfp(struct kref *);
    149     static Sg_request *sg_get_rq_mark(Sg_fd * sfp, int pack_id);
    150     static Sg_request *sg_add_request(Sg_fd * sfp);
    151     static int sg_remove_request(Sg_fd * sfp, Sg_request * srp);
    152     -static int sg_res_in_use(Sg_fd * sfp);
    153     static Sg_device *sg_get_dev(int dev);
    154     static void sg_device_destroy(struct kref *kref);
    155    
    156     @@ -614,6 +615,7 @@ sg_write(struct file *filp, const char __user *buf, size_t count, loff_t * ppos)
    157     }
    158     buf += SZ_SG_HEADER;
    159     __get_user(opcode, buf);
    160     + mutex_lock(&sfp->f_mutex);
    161     if (sfp->next_cmd_len > 0) {
    162     cmd_size = sfp->next_cmd_len;
    163     sfp->next_cmd_len = 0; /* reset so only this write() effected */
    164     @@ -622,6 +624,7 @@ sg_write(struct file *filp, const char __user *buf, size_t count, loff_t * ppos)
    165     if ((opcode >= 0xc0) && old_hdr.twelve_byte)
    166     cmd_size = 12;
    167     }
    168     + mutex_unlock(&sfp->f_mutex);
    169     SCSI_LOG_TIMEOUT(4, sg_printk(KERN_INFO, sdp,
    170     "sg_write: scsi opcode=0x%02x, cmd_size=%d\n", (int) opcode, cmd_size));
    171     /* Determine buffer size. */
    172     @@ -721,7 +724,7 @@ sg_new_write(Sg_fd *sfp, struct file *file, const char __user *buf,
    173     sg_remove_request(sfp, srp);
    174     return -EINVAL; /* either MMAP_IO or DIRECT_IO (not both) */
    175     }
    176     - if (sg_res_in_use(sfp)) {
    177     + if (sfp->res_in_use) {
    178     sg_remove_request(sfp, srp);
    179     return -EBUSY; /* reserve buffer already being used */
    180     }
    181     @@ -892,7 +895,7 @@ sg_ioctl(struct file *filp, unsigned int cmd_in, unsigned long arg)
    182     return result;
    183     if (val) {
    184     sfp->low_dma = 1;
    185     - if ((0 == sfp->low_dma) && (0 == sg_res_in_use(sfp))) {
    186     + if ((0 == sfp->low_dma) && !sfp->res_in_use) {
    187     val = (int) sfp->reserve.bufflen;
    188     sg_remove_scat(sfp, &sfp->reserve);
    189     sg_build_reserve(sfp, val);
    190     @@ -967,12 +970,18 @@ sg_ioctl(struct file *filp, unsigned int cmd_in, unsigned long arg)
    191     return -EINVAL;
    192     val = min_t(int, val,
    193     max_sectors_bytes(sdp->device->request_queue));
    194     + mutex_lock(&sfp->f_mutex);
    195     if (val != sfp->reserve.bufflen) {
    196     - if (sg_res_in_use(sfp) || sfp->mmap_called)
    197     + if (sfp->mmap_called ||
    198     + sfp->res_in_use) {
    199     + mutex_unlock(&sfp->f_mutex);
    200     return -EBUSY;
    201     + }
    202     +
    203     sg_remove_scat(sfp, &sfp->reserve);
    204     sg_build_reserve(sfp, val);
    205     }
    206     + mutex_unlock(&sfp->f_mutex);
    207     return 0;
    208     case SG_GET_RESERVED_SIZE:
    209     val = min_t(int, sfp->reserve.bufflen,
    210     @@ -1727,13 +1736,22 @@ sg_start_req(Sg_request *srp, unsigned char *cmd)
    211     md = &map_data;
    212    
    213     if (md) {
    214     - if (!sg_res_in_use(sfp) && dxfer_len <= rsv_schp->bufflen)
    215     + mutex_lock(&sfp->f_mutex);
    216     + if (dxfer_len <= rsv_schp->bufflen &&
    217     + !sfp->res_in_use) {
    218     + sfp->res_in_use = 1;
    219     sg_link_reserve(sfp, srp, dxfer_len);
    220     - else {
    221     + } else if ((hp->flags & SG_FLAG_MMAP_IO) && sfp->res_in_use) {
    222     + mutex_unlock(&sfp->f_mutex);
    223     + return -EBUSY;
    224     + } else {
    225     res = sg_build_indirect(req_schp, sfp, dxfer_len);
    226     - if (res)
    227     + if (res) {
    228     + mutex_unlock(&sfp->f_mutex);
    229     return res;
    230     + }
    231     }
    232     + mutex_unlock(&sfp->f_mutex);
    233    
    234     md->pages = req_schp->pages;
    235     md->page_order = req_schp->page_order;
    236     @@ -2024,6 +2042,8 @@ sg_unlink_reserve(Sg_fd * sfp, Sg_request * srp)
    237     req_schp->sglist_len = 0;
    238     sfp->save_scat_len = 0;
    239     srp->res_used = 0;
    240     + /* Called without mutex lock to avoid deadlock */
    241     + sfp->res_in_use = 0;
    242     }
    243    
    244     static Sg_request *
    245     @@ -2135,6 +2155,7 @@ sg_add_sfp(Sg_device * sdp)
    246     rwlock_init(&sfp->rq_list_lock);
    247    
    248     kref_init(&sfp->f_ref);
    249     + mutex_init(&sfp->f_mutex);
    250     sfp->timeout = SG_DEFAULT_TIMEOUT;
    251     sfp->timeout_user = SG_DEFAULT_TIMEOUT_USER;
    252     sfp->force_packid = SG_DEF_FORCE_PACK_ID;
    253     @@ -2210,20 +2231,6 @@ sg_remove_sfp(struct kref *kref)
    254     schedule_work(&sfp->ew.work);
    255     }
    256    
    257     -static int
    258     -sg_res_in_use(Sg_fd * sfp)
    259     -{
    260     - const Sg_request *srp;
    261     - unsigned long iflags;
    262     -
    263     - read_lock_irqsave(&sfp->rq_list_lock, iflags);
    264     - for (srp = sfp->headrp; srp; srp = srp->nextrp)
    265     - if (srp->res_used)
    266     - break;
    267     - read_unlock_irqrestore(&sfp->rq_list_lock, iflags);
    268     - return srp ? 1 : 0;
    269     -}
    270     -
    271     #ifdef CONFIG_SCSI_PROC_FS
    272     static int
    273     sg_idr_max_id(int id, void *p, void *data)
    274     diff --git a/drivers/staging/wilc1000/linux_wlan.c b/drivers/staging/wilc1000/linux_wlan.c
    275     index 6370a5efe343..defffa75ae1c 100644
    276     --- a/drivers/staging/wilc1000/linux_wlan.c
    277     +++ b/drivers/staging/wilc1000/linux_wlan.c
    278     @@ -269,23 +269,12 @@ static struct net_device *get_if_handler(struct wilc *wilc, u8 *mac_header)
    279    
    280     int wilc_wlan_set_bssid(struct net_device *wilc_netdev, u8 *bssid, u8 mode)
    281     {
    282     - int i = 0;
    283     - int ret = -1;
    284     - struct wilc_vif *vif;
    285     - struct wilc *wilc;
    286     -
    287     - vif = netdev_priv(wilc_netdev);
    288     - wilc = vif->wilc;
    289     + struct wilc_vif *vif = netdev_priv(wilc_netdev);
    290    
    291     - for (i = 0; i < wilc->vif_num; i++)
    292     - if (wilc->vif[i]->ndev == wilc_netdev) {
    293     - memcpy(wilc->vif[i]->bssid, bssid, 6);
    294     - wilc->vif[i]->mode = mode;
    295     - ret = 0;
    296     - break;
    297     - }
    298     + memcpy(vif->bssid, bssid, 6);
    299     + vif->mode = mode;
    300    
    301     - return ret;
    302     + return 0;
    303     }
    304    
    305     int wilc_wlan_get_num_conn_ifcs(struct wilc *wilc)
    306     @@ -1212,16 +1201,11 @@ void WILC_WFI_mgmt_rx(struct wilc *wilc, u8 *buff, u32 size)
    307    
    308     void wilc_netdev_cleanup(struct wilc *wilc)
    309     {
    310     - int i = 0;
    311     - struct wilc_vif *vif[NUM_CONCURRENT_IFC];
    312     + int i;
    313    
    314     - if (wilc && (wilc->vif[0]->ndev || wilc->vif[1]->ndev)) {
    315     + if (wilc && (wilc->vif[0]->ndev || wilc->vif[1]->ndev))
    316     unregister_inetaddr_notifier(&g_dev_notifier);
    317    
    318     - for (i = 0; i < NUM_CONCURRENT_IFC; i++)
    319     - vif[i] = netdev_priv(wilc->vif[i]->ndev);
    320     - }
    321     -
    322     if (wilc && wilc->firmware) {
    323     release_firmware(wilc->firmware);
    324     wilc->firmware = NULL;
    325     @@ -1230,7 +1214,7 @@ void wilc_netdev_cleanup(struct wilc *wilc)
    326     if (wilc && (wilc->vif[0]->ndev || wilc->vif[1]->ndev)) {
    327     for (i = 0; i < NUM_CONCURRENT_IFC; i++)
    328     if (wilc->vif[i]->ndev)
    329     - if (vif[i]->mac_opened)
    330     + if (wilc->vif[i]->mac_opened)
    331     wilc_mac_close(wilc->vif[i]->ndev);
    332    
    333     for (i = 0; i < NUM_CONCURRENT_IFC; i++) {
    334     @@ -1278,9 +1262,9 @@ int wilc_netdev_init(struct wilc **wilc, struct device *dev, int io_type,
    335    
    336     vif->idx = wl->vif_num;
    337     vif->wilc = *wilc;
    338     + vif->ndev = ndev;
    339     wl->vif[i] = vif;
    340     - wl->vif[wl->vif_num]->ndev = ndev;
    341     - wl->vif_num++;
    342     + wl->vif_num = i;
    343     ndev->netdev_ops = &wilc_netdev_ops;
    344    
    345     {
    346     diff --git a/kernel/gcov/base.c b/kernel/gcov/base.c
    347     index 2f9df37940a0..c51a49c9be70 100644
    348     --- a/kernel/gcov/base.c
    349     +++ b/kernel/gcov/base.c
    350     @@ -98,6 +98,12 @@ void __gcov_merge_icall_topn(gcov_type *counters, unsigned int n_counters)
    351     }
    352     EXPORT_SYMBOL(__gcov_merge_icall_topn);
    353    
    354     +void __gcov_exit(void)
    355     +{
    356     + /* Unused. */
    357     +}
    358     +EXPORT_SYMBOL(__gcov_exit);
    359     +
    360     /**
    361     * gcov_enable_events - enable event reporting through gcov_event()
    362     *
    363     diff --git a/kernel/gcov/gcc_4_7.c b/kernel/gcov/gcc_4_7.c
    364     index 6a5c239c7669..46a18e72bce6 100644
    365     --- a/kernel/gcov/gcc_4_7.c
    366     +++ b/kernel/gcov/gcc_4_7.c
    367     @@ -18,7 +18,9 @@
    368     #include <linux/vmalloc.h>
    369     #include "gcov.h"
    370    
    371     -#if (__GNUC__ > 5) || (__GNUC__ == 5 && __GNUC_MINOR__ >= 1)
    372     +#if (__GNUC__ >= 7)
    373     +#define GCOV_COUNTERS 9
    374     +#elif (__GNUC__ > 5) || (__GNUC__ == 5 && __GNUC_MINOR__ >= 1)
    375     #define GCOV_COUNTERS 10
    376     #elif __GNUC__ == 4 && __GNUC_MINOR__ >= 9
    377     #define GCOV_COUNTERS 9
    378     diff --git a/kernel/locking/spinlock_debug.c b/kernel/locking/spinlock_debug.c
    379     index 0374a596cffa..9aa0fccd5d43 100644
    380     --- a/kernel/locking/spinlock_debug.c
    381     +++ b/kernel/locking/spinlock_debug.c
    382     @@ -103,38 +103,14 @@ static inline void debug_spin_unlock(raw_spinlock_t *lock)
    383     lock->owner_cpu = -1;
    384     }
    385    
    386     -static void __spin_lock_debug(raw_spinlock_t *lock)
    387     -{
    388     - u64 i;
    389     - u64 loops = loops_per_jiffy * HZ;
    390     -
    391     - for (i = 0; i < loops; i++) {
    392     - if (arch_spin_trylock(&lock->raw_lock))
    393     - return;
    394     - __delay(1);
    395     - }
    396     - /* lockup suspected: */
    397     - spin_dump(lock, "lockup suspected");
    398     -#ifdef CONFIG_SMP
    399     - trigger_all_cpu_backtrace();
    400     -#endif
    401     -
    402     - /*
    403     - * The trylock above was causing a livelock. Give the lower level arch
    404     - * specific lock code a chance to acquire the lock. We have already
    405     - * printed a warning/backtrace at this point. The non-debug arch
    406     - * specific code might actually succeed in acquiring the lock. If it is
    407     - * not successful, the end-result is the same - there is no forward
    408     - * progress.
    409     - */
    410     - arch_spin_lock(&lock->raw_lock);
    411     -}
    412     -
    413     +/*
    414     + * We are now relying on the NMI watchdog to detect lockup instead of doing
    415     + * the detection here with an unfair lock which can cause problem of its own.
    416     + */
    417     void do_raw_spin_lock(raw_spinlock_t *lock)
    418     {
    419     debug_spin_lock_before(lock);
    420     - if (unlikely(!arch_spin_trylock(&lock->raw_lock)))
    421     - __spin_lock_debug(lock);
    422     + arch_spin_lock(&lock->raw_lock);
    423     debug_spin_lock_after(lock);
    424     }
    425    
    426     @@ -172,32 +148,6 @@ static void rwlock_bug(rwlock_t *lock, const char *msg)
    427    
    428     #define RWLOCK_BUG_ON(cond, lock, msg) if (unlikely(cond)) rwlock_bug(lock, msg)
    429    
    430     -#if 0 /* __write_lock_debug() can lock up - maybe this can too? */
    431     -static void __read_lock_debug(rwlock_t *lock)
    432     -{
    433     - u64 i;
    434     - u64 loops = loops_per_jiffy * HZ;
    435     - int print_once = 1;
    436     -
    437     - for (;;) {
    438     - for (i = 0; i < loops; i++) {
    439     - if (arch_read_trylock(&lock->raw_lock))
    440     - return;
    441     - __delay(1);
    442     - }
    443     - /* lockup suspected: */
    444     - if (print_once) {
    445     - print_once = 0;
    446     - printk(KERN_EMERG "BUG: read-lock lockup on CPU#%d, "
    447     - "%s/%d, %p\n",
    448     - raw_smp_processor_id(), current->comm,
    449     - current->pid, lock);
    450     - dump_stack();
    451     - }
    452     - }
    453     -}
    454     -#endif
    455     -
    456     void do_raw_read_lock(rwlock_t *lock)
    457     {
    458     RWLOCK_BUG_ON(lock->magic != RWLOCK_MAGIC, lock, "bad magic");
    459     @@ -247,32 +197,6 @@ static inline void debug_write_unlock(rwlock_t *lock)
    460     lock->owner_cpu = -1;
    461     }
    462    
    463     -#if 0 /* This can cause lockups */
    464     -static void __write_lock_debug(rwlock_t *lock)
    465     -{
    466     - u64 i;
    467     - u64 loops = loops_per_jiffy * HZ;
    468     - int print_once = 1;
    469     -
    470     - for (;;) {
    471     - for (i = 0; i < loops; i++) {
    472     - if (arch_write_trylock(&lock->raw_lock))
    473     - return;
    474     - __delay(1);
    475     - }
    476     - /* lockup suspected: */
    477     - if (print_once) {
    478     - print_once = 0;
    479     - printk(KERN_EMERG "BUG: write-lock lockup on CPU#%d, "
    480     - "%s/%d, %p\n",
    481     - raw_smp_processor_id(), current->comm,
    482     - current->pid, lock);
    483     - dump_stack();
    484     - }
    485     - }
    486     -}
    487     -#endif
    488     -
    489     void do_raw_write_lock(rwlock_t *lock)
    490     {
    491     debug_write_lock_before(lock);
    492     diff --git a/lib/lz4/lz4hc_compress.c b/lib/lz4/lz4hc_compress.c
    493     index f344f76b6559..6b2e046a9c61 100644
    494     --- a/lib/lz4/lz4hc_compress.c
    495     +++ b/lib/lz4/lz4hc_compress.c
    496     @@ -131,7 +131,7 @@ static inline int lz4hc_insertandfindbestmatch(struct lz4hc_data *hc4,
    497     #endif
    498     int nbattempts = MAX_NB_ATTEMPTS;
    499     size_t repl = 0, ml = 0;
    500     - u16 delta;
    501     + u16 delta = 0;
    502    
    503     /* HC4 match finder */
    504     lz4hc_insert(hc4, ip);