From db4ab5d13e52f38eb444c5cce3f97ceac7deccdc Mon Sep 17 00:00:00 2001 From: Bob Glossman Date: Mon, 15 May 2017 12:45:05 -0700 Subject: [PATCH] LU-9503 kernel: kernel update [SLES11 SP4 3.0.101-100] Update SLES11 SP4 kernel to 3.0.101-100 Refresh one ldiskfs patch for ext4 context changes. Test-Parameters: mdsdistro=sles11sp4 ossdistro=sles11sp4 \ clientdistro=sles11sp4 mdtfilesystemtype=ldiskfs \ ostfilesystemtype=ldiskfs testgroup=review-ldiskfs Signed-off-by: Bob Glossman Change-Id: Ia392004c12dda9d49c0f596b166f333e7fcae590 Reviewed-on: https://review.whamcloud.com/27132 Tested-by: Jenkins Reviewed-by: Minh Diep Tested-by: Maloo Reviewed-by: Yang Sheng Reviewed-by: Oleg Drokin --- config/lustre-build-ldiskfs.m4 | 4 +- .../patches/sles11sp4/ext4-large-dir.patch | 364 +++++++++++++++++++++ .../series/ldiskfs-3.0-sles11sp4.series | 46 +++ lustre/ChangeLog | 4 +- .../kernel-3.0-3.0-sles11sp4-x86_64.config | 2 +- .../kernel_patches/targets/3.0-sles11sp4.target.in | 2 +- lustre/kernel_patches/which_patch | 2 +- 7 files changed, 418 insertions(+), 6 deletions(-) create mode 100644 ldiskfs/kernel_patches/patches/sles11sp4/ext4-large-dir.patch create mode 100644 ldiskfs/kernel_patches/series/ldiskfs-3.0-sles11sp4.series diff --git a/config/lustre-build-ldiskfs.m4 b/config/lustre-build-ldiskfs.m4 index 7cff54f..83b4cbc 100644 --- a/config/lustre-build-ldiskfs.m4 +++ b/config/lustre-build-ldiskfs.m4 @@ -35,7 +35,9 @@ AS_IF([test x$RHEL_KERNEL = xyes], [ case $PLEV in 2) LDISKFS_SERIES="3.0-sles11.series" ;; - 3|4) LDISKFS_SERIES="3.0-sles11sp3.series" + 3) LDISKFS_SERIES="3.0-sles11sp3.series" + ;; + 4) LDISKFS_SERIES="3.0-sles11sp4.series" ;; esac ])],[LDISKFS_SERIES="3.12-sles12.series"],[ diff --git a/ldiskfs/kernel_patches/patches/sles11sp4/ext4-large-dir.patch b/ldiskfs/kernel_patches/patches/sles11sp4/ext4-large-dir.patch new file mode 100644 index 0000000..81b8f61 --- /dev/null +++ b/ldiskfs/kernel_patches/patches/sles11sp4/ext4-large-dir.patch @@ -0,0 +1,364 @@ +This INCOMPAT_LARGEDIR feature allows larger directories +to be created in ldiskfs, both with directory sizes over +2GB and and a maximum htree depth of 3 instead of the +current limit of 2. These features are needed in order +to exceed the current limit of approximately 10M entries +in a single directory. + +Index: linux-stage/fs/ext4/ext4.h +=================================================================== +--- linux-stage.orig/fs/ext4/ext4.h ++++ linux-stage/fs/ext4/ext4.h +@@ -1391,6 +1391,7 @@ static inline void ext4_clear_state_flag + #define EXT4_FEATURE_INCOMPAT_FLEX_BG 0x0200 + #define EXT4_FEATURE_INCOMPAT_EA_INODE 0x0400 /* EA in inode */ + #define EXT4_FEATURE_INCOMPAT_DIRDATA 0x1000 /* data in dirent */ ++#define EXT4_FEATURE_INCOMPAT_LARGEDIR 0x4000 + + #define EXT2_FEATURE_COMPAT_SUPP EXT4_FEATURE_COMPAT_EXT_ATTR + #define EXT2_FEATURE_INCOMPAT_SUPP (EXT4_FEATURE_INCOMPAT_FILETYPE| \ +@@ -1416,7 +1417,8 @@ static inline void ext4_clear_state_flag + EXT4_FEATURE_INCOMPAT_FLEX_BG| \ + EXT4_FEATURE_INCOMPAT_EA_INODE| \ + EXT4_FEATURE_INCOMPAT_MMP| \ +- EXT4_FEATURE_INCOMPAT_DIRDATA) ++ EXT4_FEATURE_INCOMPAT_DIRDATA| \ ++ EXT4_FEATURE_INCOMPAT_LARGEDIR) + + #define EXT4_FEATURE_RO_COMPAT_SUPP (EXT4_FEATURE_RO_COMPAT_SPARSE_SUPER| \ + EXT4_FEATURE_RO_COMPAT_LARGE_FILE| \ +@@ -1679,6 +1681,17 @@ ext4_group_first_block_no(struct super_b + */ + #define ERR_BAD_DX_DIR -75000 + ++/* htree levels for ext4 */ ++#define EXT4_HTREE_LEVEL_COMPAT 2 ++#define EXT4_HTREE_LEVEL 3 ++ ++static inline int ++ext4_dir_htree_level(struct super_block *sb) ++{ ++ return EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_LARGEDIR) ? ++ EXT4_HTREE_LEVEL : EXT4_HTREE_LEVEL_COMPAT; ++} ++ + void ext4_get_group_no_and_offset(struct super_block *sb, ext4_fsblk_t blocknr, + ext4_group_t *blockgrpp, ext4_grpblk_t *offsetp); + +@@ -2077,13 +2090,15 @@ static inline void ext4_r_blocks_count_s + es->s_r_blocks_count_hi = cpu_to_le32(blk >> 32); + } + +-static inline loff_t ext4_isize(struct ext4_inode *raw_inode) ++static inline loff_t ext4_isize(struct super_block *sb, ++ struct ext4_inode *raw_inode) + { +- if (S_ISREG(le16_to_cpu(raw_inode->i_mode))) ++ if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_LARGEDIR) || ++ S_ISREG(le16_to_cpu(raw_inode->i_mode))) + return ((loff_t)le32_to_cpu(raw_inode->i_size_high) << 32) | + le32_to_cpu(raw_inode->i_size_lo); +- else +- return (loff_t) le32_to_cpu(raw_inode->i_size_lo); ++ ++ return (loff_t) le32_to_cpu(raw_inode->i_size_lo); + } + + static inline void ext4_isize_set(struct ext4_inode *raw_inode, loff_t i_size) +Index: linux-stage/fs/ext4/inode.c +=================================================================== +--- linux-stage.orig/fs/ext4/inode.c ++++ linux-stage/fs/ext4/inode.c +@@ -5007,7 +5007,7 @@ struct inode *ext4_iget(struct super_blo + if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_64BIT)) + ei->i_file_acl |= + ((__u64)le16_to_cpu(raw_inode->i_file_acl_high)) << 32; +- inode->i_size = ext4_isize(raw_inode); ++ inode->i_size = ext4_isize(sb, raw_inode); + if ((size = i_size_read(inode)) < 0) { + EXT4_ERROR_INODE(inode, "bad i_size value: %lld", size); + ret = -EIO; +@@ -5253,7 +5253,7 @@ static int ext4_do_update_inode(handle_t + raw_inode->i_file_acl_high = + cpu_to_le16(ei->i_file_acl >> 32); + raw_inode->i_file_acl_lo = cpu_to_le32(ei->i_file_acl); +- if (ei->i_disksize != ext4_isize(raw_inode)) { ++ if (ei->i_disksize != ext4_isize(inode->i_sb, raw_inode)) { + ext4_isize_set(raw_inode, ei->i_disksize); + need_datasync = 1; + } +Index: linux-stage/fs/ext4/namei.c +=================================================================== +--- linux-stage.orig/fs/ext4/namei.c ++++ linux-stage/fs/ext4/namei.c +@@ -209,7 +209,7 @@ struct dx_root_info * dx_get_dx_info(str + + static inline ext4_lblk_t dx_get_block(struct dx_entry *entry) + { +- return le32_to_cpu(entry->block) & 0x00ffffff; ++ return le32_to_cpu(entry->block) & 0x0fffffff; + } + + static inline void dx_set_block(struct dx_entry *entry, ext4_lblk_t value) +@@ -372,7 +372,7 @@ dx_probe(const struct qstr *d_name, stru + struct dx_frame *frame = frame_in; + u32 hash; + +- frame->bh = NULL; ++ memset(frame_in, 0, EXT4_HTREE_LEVEL * sizeof(frame_in[0])); + if (!(bh = ext4_bread (NULL,dir, 0, 0, err))) + goto fail; + +@@ -402,9 +402,16 @@ dx_probe(const struct qstr *d_name, stru + goto fail; + } + +- if ((indirect = info->indirect_levels) > 1) { +- ext4_warning(dir->i_sb, "Unimplemented inode hash depth: %#06x", +- info->indirect_levels); ++ indirect = info->indirect_levels; ++ if (indirect >= ext4_dir_htree_level(dir->i_sb)) { ++ ext4_warning(dir->i_sb, ++ "Directory (ino: %lu) htree depth %#06x exceed " ++ "supported value", dir->i_ino, ++ ext4_dir_htree_level(dir->i_sb)); ++ if (ext4_dir_htree_level(dir->i_sb) < EXT4_HTREE_LEVEL) { ++ ext4_warning(dir->i_sb, "Enable large directory " ++ "feature to access it"); ++ } + brelse(bh); + *err = ERR_BAD_DX_DIR; + goto fail; +@@ -496,13 +503,18 @@ fail: + static void dx_release (struct dx_frame *frames) + { + struct dx_root_info *info; ++ int i; ++ + if (frames[0].bh == NULL) + return; + + info = dx_get_dx_info((struct ext4_dir_entry_2*)frames[0].bh->b_data); +- if (info->indirect_levels) +- brelse(frames[1].bh); +- brelse(frames[0].bh); ++ for (i = 0; i <= info->indirect_levels; i++) { ++ if (frames[i].bh == NULL) ++ break; ++ brelse(frames[i].bh); ++ frames[i].bh = NULL; ++ } + } + + /* +@@ -642,7 +654,7 @@ int ext4_htree_fill_tree(struct file *di + { + struct dx_hash_info hinfo; + struct ext4_dir_entry_2 *de; +- struct dx_frame frames[2], *frame; ++ struct dx_frame frames[EXT4_HTREE_LEVEL], *frame; + struct inode *dir; + ext4_lblk_t block; + int count = 0; +@@ -983,7 +995,7 @@ static struct buffer_head * ext4_dx_find + struct super_block * sb; + struct dx_hash_info hinfo; + u32 hash; +- struct dx_frame frames[2], *frame; ++ struct dx_frame frames[EXT4_HTREE_LEVEL], *frame; + struct buffer_head *bh; + ext4_lblk_t block; + int retval; +@@ -1423,7 +1435,7 @@ static int add_dirent_to_buf(handle_t *h + */ + dir->i_mtime = dir->i_ctime = ext4_current_time(dir); + ext4_update_dx_flag(dir); +- dir->i_version++; ++ inode_inc_iversion(dir); + ext4_mark_inode_dirty(handle, dir); + BUFFER_TRACE(bh, "call ext4_handle_dirty_metadata"); + err = ext4_handle_dirty_metadata(handle, dir, bh); +@@ -1443,7 +1455,7 @@ static int make_indexed_dir(handle_t *ha + const char *name = dentry->d_name.name; + int namelen = dentry->d_name.len; + struct buffer_head *bh2; +- struct dx_frame frames[2], *frame; ++ struct dx_frame frames[EXT4_HTREE_LEVEL], *frame; + struct dx_entry *entries; + struct ext4_dir_entry_2 *de, *de2, *dot_de, *dotdot_de; + char *data1, *top; +@@ -1692,15 +1704,18 @@ static int ext4_add_entry(handle_t *hand + static int ext4_dx_add_entry(handle_t *handle, struct dentry *dentry, + struct inode *inode) + { +- struct dx_frame frames[2], *frame; ++ struct dx_frame frames[EXT4_HTREE_LEVEL], *frame; + struct dx_entry *entries, *at; + struct dx_hash_info hinfo; + struct buffer_head *bh; + struct inode *dir = dentry->d_parent->d_inode; + struct super_block *sb = dir->i_sb; + struct ext4_dir_entry_2 *de; ++ int restart; + int err; + ++again: ++ restart = 0; + frame = dx_probe(&dentry->d_name, dir, &hinfo, frames, &err); + if (!frame) + return err; +@@ -1710,33 +1725,48 @@ static int ext4_dx_add_entry(handle_t *h + if (!(bh = ext4_bread(handle,dir, dx_get_block(frame->at), 0, &err))) + goto cleanup; + +- BUFFER_TRACE(bh, "get_write_access"); +- err = ext4_journal_get_write_access(handle, bh); +- if (err) +- goto journal_error; +- + err = add_dirent_to_buf(handle, dentry, inode, NULL, bh); + if (err != -ENOSPC) + goto cleanup; + ++ err = 0; + /* Block full, should compress but for now just split */ + dxtrace(printk(KERN_DEBUG "using %u of %u node entries\n", + dx_get_count(entries), dx_get_limit(entries))); + /* Need to split index? */ + if (dx_get_count(entries) == dx_get_limit(entries)) { + ext4_lblk_t newblock; +- unsigned icount = dx_get_count(entries); +- int levels = frame - frames; ++ int levels = frame - frames + 1; ++ unsigned icount; ++ int add_level = 1; + struct dx_entry *entries2; + struct dx_node *node2; + struct buffer_head *bh2; + +- if (levels && (dx_get_count(frames->entries) == +- dx_get_limit(frames->entries))) { +- ext4_warning(sb, "Directory index full!"); ++ while (frame > frames) { ++ if (dx_get_count((frame - 1)->entries) < ++ dx_get_limit((frame - 1)->entries)) { ++ add_level = 0; ++ break; ++ } ++ frame--; /* split higher index block */ ++ at = frame->at; ++ entries = frame->entries; ++ restart = 1; ++ } ++ if (add_level && levels == ext4_dir_htree_level(sb)) { ++ ext4_warning(sb, "Directory (ino: %lu) index full, " ++ "reach max htree level :%d", ++ dir->i_ino, levels); ++ if (ext4_dir_htree_level(sb) < EXT4_HTREE_LEVEL) { ++ ext4_warning(sb, "Large directory feature is" ++ "not enabled on this " ++ "filesystem"); ++ } + err = -ENOSPC; + goto cleanup; + } ++ icount = dx_get_count(entries); + bh2 = ext4_append (handle, dir, &newblock, &err); + if (!(bh2)) + goto cleanup; +@@ -1749,7 +1779,7 @@ static int ext4_dx_add_entry(handle_t *h + err = ext4_journal_get_write_access(handle, frame->bh); + if (err) + goto journal_error; +- if (levels) { ++ if (!add_level) { + unsigned icount1 = icount/2, icount2 = icount - icount1; + unsigned hash2 = dx_get_hash(entries + icount1); + dxtrace(printk(KERN_DEBUG "Split index %i/%i\n", +@@ -1757,7 +1787,7 @@ static int ext4_dx_add_entry(handle_t *h + + BUFFER_TRACE(frame->bh, "get_write_access"); /* index root */ + err = ext4_journal_get_write_access(handle, +- frames[0].bh); ++ (frame - 1)->bh); + if (err) + goto journal_error; + +@@ -1773,18 +1803,24 @@ static int ext4_dx_add_entry(handle_t *h + frame->entries = entries = entries2; + swap(frame->bh, bh2); + } +- dx_insert_block(frames + 0, hash2, newblock); +- dxtrace(dx_show_index("node", frames[1].entries)); ++ dx_insert_block((frame - 1), hash2, newblock); ++ dxtrace(dx_show_index("node", frame->entries)); + dxtrace(dx_show_index("node", + ((struct dx_node *) bh2->b_data)->entries)); + err = ext4_handle_dirty_metadata(handle, dir, bh2); + if (err) + goto journal_error; + brelse (bh2); ++ ext4_handle_dirty_metadata(handle, dir, ++ (frame - 1)->bh); ++ if (restart) { ++ ext4_handle_dirty_metadata(handle, dir, ++ frame->bh); ++ goto cleanup; ++ } + } else { + struct dx_root_info * info; +- dxtrace(printk(KERN_DEBUG +- "Creating second level index...\n")); ++ + memcpy((char *) entries2, (char *) entries, + icount * sizeof(struct dx_entry)); + dx_set_limit(entries2, dx_node_limit(dir)); +@@ -1794,19 +1830,16 @@ static int ext4_dx_add_entry(handle_t *h + dx_set_block(entries + 0, newblock); + info = dx_get_dx_info((struct ext4_dir_entry_2*) + frames[0].bh->b_data); +- info->indirect_levels = 1; +- +- /* Add new access path frame */ +- frame = frames + 1; +- frame->at = at = at - entries + entries2; +- frame->entries = entries = entries2; +- frame->bh = bh2; +- err = ext4_journal_get_write_access(handle, +- frame->bh); +- if (err) +- goto journal_error; ++ info->indirect_levels += 1; ++ dxtrace(printk(KERN_DEBUG ++ "Creating %d level index...\n", ++ info->indirect_levels)); ++ ext4_handle_dirty_metadata(handle, dir, frame->bh); ++ ext4_handle_dirty_metadata(handle, dir, bh2); ++ brelse(bh2); ++ restart = 1; ++ goto cleanup; + } +- err = ext4_handle_dirty_metadata(handle, dir, frames[0].bh); + if (err) { + ext4_std_error(inode->i_sb, err); + goto cleanup; +@@ -1824,6 +1857,10 @@ cleanup: + if (bh) + brelse(bh); + dx_release(frames); ++ /* @restart is true means htree-path has been changed, we need to ++ * repeat dx_probe() to find out valid htree-path */ ++ if (restart && err == 0) ++ goto again; + return err; + } + +@@ -1862,7 +1899,7 @@ int ext4_delete_entry(handle_t *handle, + blocksize); + else + de->inode = 0; +- dir->i_version++; ++ inode_inc_iversion(dir); + BUFFER_TRACE(bh, "call ext4_handle_dirty_metadata"); + err = ext4_handle_dirty_metadata(handle, dir, bh); + if (unlikely(err)) { diff --git a/ldiskfs/kernel_patches/series/ldiskfs-3.0-sles11sp4.series b/ldiskfs/kernel_patches/series/ldiskfs-3.0-sles11sp4.series new file mode 100644 index 0000000..99096f2 --- /dev/null +++ b/ldiskfs/kernel_patches/series/ldiskfs-3.0-sles11sp4.series @@ -0,0 +1,46 @@ +sles11sp2/ext4-introduce-ext4_kvmalloc-ext4_kzalloc-and-ext4_kvfree.patch +sles11sp2/ext4-speed-up-fitrim-by-recording-flags-in-ext4_group_info.patch +sles11sp2/ext4-use-ext4_kvzalloc-ext4_kvmalloc-for-s_group_desc-and-s_group_info.patch +sles11sp2/ext4-use-ext4_msg-instead-of-printk-in-mballoc.patch +sles11sp2/revert-ext4-avoid-uninitialized-memory-references-in-ext3_htree_next_block.patch +sles11sp2/ext4-journal-callback.patch +sles11sp2/ext4-make-quota-as-first-class-supported-feature.patch + +sles11sp2/ext4-handle-cleanup-after-quota-failure.patch +sles11sp2/ext4-map_inode_page-3.0.patch +sles11sp2/export-ext4-3.0.patch +rhel6.3/ext4-remove-cond_resched-calls.patch +rhel6.3/ext4-nlink-2.6.patch +sles11sp2/ext4-ext_generation.patch +rhel6.3/ext4-inode-version.patch +sles11sp2/ext4-lookup-dotdot.patch +rhel6.3/ext4-print-inum-in-htree-warning.patch +sles11sp2/ext4-prealloc.patch +sles11sp2/ext4-mballoc-extra-checks.patch +sles11sp2/restore-path-in-walk_extent_callback.patch +sles11sp2/ext4-misc.patch +rhel6.3/ext4-pdir-fix.patch +sles11sp2/ext4-osd-iop-common.patch +rhel6.3/ext4-osd-iam-exports.patch +rhel6.3/ext4-hash-indexed-dir-dotdot-update.patch +sles11sp2/ext4-kill-dx_root.patch +sles11sp2/ext4-mballoc-pa_free-mismatch.patch +sles11sp2/ext4-data-in-dirent.patch +sles11sp2/ext4-large-eas.patch +sles11sp2/ext4-disable-mb-cache.patch +rhel6.3/ext4-nocmtime-2.6.patch +sles11sp2/ext4-store-tree-generation-at-find.patch +sles11sp4/ext4-large-dir.patch +rhel6.3/ext4-pdirop.patch +rhel6.3/ext4-max-dir-size.patch +sles11sp2/ext4-max-dir-size-options.patch +rhel6.3/ext4-not-discard-preallocation-umount.patch +rhel6.3/ext4-journal-path-opt.patch +sles11sp2/ext4-corrupted-inode-block-bitmaps-handling-patches.patch +rhel6.5/ext4-give-warning-with-dir-htree-growing.patch +sles11sp3/ext4-mmp-brelse.patch +sles11sp3/ext4_s_max_ext_tree_depth.patch +sles11sp1/ext4-notalloc_under_idatasem.patch +rhel6.5/ext4-fix-journal-quota.patch +sles11sp3/ext4-dont-check-before-replay.patch +rhel6.3/ext4-dont-check-in-ro.patch diff --git a/lustre/ChangeLog b/lustre/ChangeLog index 4482e46..69b11e4 100644 --- a/lustre/ChangeLog +++ b/lustre/ChangeLog @@ -10,7 +10,7 @@ TBD Intel Corporation 2.6.32-696.1.1.el6 (RHEL6.9) 3.10.0-514.16.1.el7 (RHEL7.3) 3.0.101-0.47.71 (SLES11 SP3) - 3.0.101-97 (SLES11 SP4) + 3.0.101-100 (SLES11 SP4) 3.12.69-60.64.35 (SLES12 SP1) 4.4.59-92.17 (SLES12 SP2) vanilla linux 4.6.7 (ZFS only) @@ -22,7 +22,7 @@ TBD Intel Corporation 2.6.32-696.1.1.el6 (RHEL6.9) 3.10.0-514.16.1.el7 (RHEL7.3) 3.0.101-0.47.71 (SLES11 SP3) - 3.0.101-97 (SLES11 SP4) + 3.0.101-100 (SLES11 SP4) 3.12.69-60.64.35 (SLES12 SP1) 4.4.59-92.17 (SLES12 SP2) vanilla linux 4.6.7 diff --git a/lustre/kernel_patches/kernel_configs/kernel-3.0-3.0-sles11sp4-x86_64.config b/lustre/kernel_patches/kernel_configs/kernel-3.0-3.0-sles11sp4-x86_64.config index 337876e..54a9926 100644 --- a/lustre/kernel_patches/kernel_configs/kernel-3.0-3.0-sles11sp4-x86_64.config +++ b/lustre/kernel_patches/kernel_configs/kernel-3.0-3.0-sles11sp4-x86_64.config @@ -66,7 +66,7 @@ CONFIG_IRQ_WORK=y CONFIG_EXPERIMENTAL=y CONFIG_INIT_ENV_ARG_LIMIT=32 CONFIG_CROSS_COMPILE="" -CONFIG_LOCALVERSION="-97-default" +CONFIG_LOCALVERSION="-100-default" # CONFIG_LOCALVERSION_AUTO is not set CONFIG_HAVE_KERNEL_GZIP=y CONFIG_HAVE_KERNEL_BZIP2=y diff --git a/lustre/kernel_patches/targets/3.0-sles11sp4.target.in b/lustre/kernel_patches/targets/3.0-sles11sp4.target.in index 653bd14..c077094 100644 --- a/lustre/kernel_patches/targets/3.0-sles11sp4.target.in +++ b/lustre/kernel_patches/targets/3.0-sles11sp4.target.in @@ -1,6 +1,6 @@ lnxmaj="3.0" lnxmin=".101" -lnxrel="97" +lnxrel="100" # use this when there is an "RPM fix" which means that the name of the # (source) RPM has been updated but the version of the kernel inside the # RPM is not also updated diff --git a/lustre/kernel_patches/which_patch b/lustre/kernel_patches/which_patch index dfd919c..325e103 100644 --- a/lustre/kernel_patches/which_patch +++ b/lustre/kernel_patches/which_patch @@ -20,7 +20,7 @@ PATCH SERIES FOR SERVER KERNELS: 2.6-rhel6.8.series 2.6.32-696.1.1.el6 (RHEL 6.9) 3.10-rhel7.series 3.10.0-514.16.1.el7 (RHEL 7.3) 3.0-sles11sp3.series 3.0.101-0.47.71 (SLES11 SP3) -3.0-sles11sp3.series 3.0.101-97 (SLES11 SP4) +3.0-sles11sp3.series 3.0.101-100 (SLES11 SP4) 3.12-sles12.series 3.12.69-60.64.35 (SLES12 SP1) 4.4-sles12.series 4.4.59-92.17 (SLES12 SP2) -- 1.8.3.1