Merge pull request #3052 from Pavithra1602/live_patching_2

Test case to verify live patching feature v3

Author: PraveenPenguin

ras/live_patching.py

@@ -55,24 +55,29 @@ def setUp(self):
                 self.cancel('%s is needed for the test to be run' % packages)
         for file_name in ['test.c', 'libc_livepatch1.c', 'libc_livepatch1.dsc',
                           'test_2func.c', 'libc_livepatch_2func.c', 'libc_livepatch_2func.dsc',
-                          'Makefile']:
+                          'libc_livepatch_nested.c', 'libc_livepatch_nested.dsc', 'Makefile',
+                          'live_patch_nested.tar.gz', 'test_long.c']:
             self.copyutil(file_name)
 
-    def apply_livepatch(self, test='test', livepatch='libc_livepatch1.so'):
+    def start_test(self, test='test'):
         """
-        function applies a live patch to the running test program and returns
-        the stderr output
+        function starts running test program
         """
         self.test_process = process.SubProcess(
             'LD_PRELOAD=/usr/lib64/libpulp.so.0 ./%s' % test, shell=True, sudo=True)
         self.pid = self.test_process.start()
-        a = self.test_process.get_stderr()
         time.sleep(10)
+
+    def apply_livepatch(self, livepatch='libc_livepatch1.so'):
+        """
+        function applies a live patch to the running test program and returns
+        the stderr output
+        """
         patch_process = process.SubProcess(
             'ulp trigger -p %s %s' % (self.pid, livepatch), shell=True, sudo=True)
         patch_process.start()
         time.sleep(20)
-        return (self.test_process.get_stderr())
+        return(self.test_process.get_stderr())
 
     def revert_livepatch(self, livepatch='libc_livepatch1.so'):
         """
@@ -103,6 +108,7 @@ def test_basic(self):
         os.chdir(self.teststmpdir)
         process.system('make', shell=True)
         process.system('ulp packer libc_livepatch1.dsc', shell=True)
+        self.start_test()
         livepatch_output = self.apply_livepatch()
         apply_count = self.count_string(livepatch_output)
         if apply_count < 10:
@@ -167,10 +173,15 @@ def test_multiple_process_livepatching(self):
             self.fail("Livepatch revert failed for %s processes" % (patch_number - patch_revert_number))
 
     def test_two_function_livepatching(self):
+        """
+        This test function ensures that a livepatch with two functions is successfully applied,
+        both functions are live-patched, and the livepatch can be correctly reverted.
+        """
         os.chdir(self.teststmpdir)
         process.system('make', shell=True)
         process.system('ulp packer libc_livepatch_2func.dsc', shell=True)
-        livepatch_output = self.apply_livepatch('test_2func', 'libc_livepatch_2func.so')
+        self.start_test('test_2func')
+        livepatch_output = self.apply_livepatch('libc_livepatch_2func.so')
         apply_count = self.count_string(livepatch_output)
         apply_count_2 = livepatch_output.count(b'glibc-livepatch-realloc\n')
         if apply_count_2 < 10:
@@ -182,3 +193,81 @@ def test_two_function_livepatching(self):
         revert_output = self.revert_livepatch('libc_livepatch_2func.so')
         if self.count_string(revert_output) - apply_count > 1:
             self.fail("Reverting patch is not successful")
+
+    def test_nested_function_livepatching(self):
+        """
+        This test function ensures that both a primary livepatch and a nested livepatch
+        are successfully applied and later reverted.
+        """
+        os.chdir(self.teststmpdir)
+        process.system('make', shell=True)
+        process.system('ulp packer libc_livepatch1.dsc', shell=True)
+        self.start_test()
+        livepatch_output = self.apply_livepatch()
+        apply_count_1 = livepatch_output.count(b'glibc-livepatch\n')
+        if apply_count_1 < 10:
+            self.fail("Applying first livepatch failed.")
+        else:
+            self.log.info("Successfully applied first livepatch")
+        process.system('ulp packer libc_livepatch_nested.dsc', shell=True)
+        livepatch_output = self.apply_livepatch('libc_livepatch_nested.so')
+        time.sleep(10)
+        apply_count_2 = livepatch_output.count(b'glibc-livepatch-nested\n')
+        if apply_count_2 < 10:
+            self.fail("Applying nested livepatch failed.")
+        else:
+            self.log.info("Successfully applied nested livepatch")
+        process.system_output('ulp trigger --revert -p %s libc_livepatch_nested.so' % self.pid, shell=True)
+        time.sleep(10)
+        process.system_output('ulp trigger --revert -p %s libc_livepatch1.so' % self.pid, shell=True)
+
+    def test_nested_function_livepatching_multiple(self):
+        """
+        This test function ensures that 12 nested livepatches are successfully applied and
+        later reverted, with each iteration checked for proper application.
+        """
+        os.chdir(self.teststmpdir)
+        process.system('tar -xf live_patch_nested.tar.gz', shell=True)
+        process.system('make', shell=True)
+        self.start_test('test_long')
+        os.chdir('live_patch_nested')
+        for i in range(1, 13):
+            process.system('gcc -fPIC -fpatchable-function-entry=16,14 -shared -o libc_livepatch%s.so'
+                           ' libc_livepatch%s.c -msplit-patch-nops' % (i, i), shell=True)
+            process.system('ulp packer %s/live_patch_nested/libc_livepatch%s.dsc' % (self.teststmpdir, i), shell=True)
+            livepatch_output = self.apply_livepatch('libc_livepatch%s.so' % i)
+        for i in range(2, 13):
+            apply_count = livepatch_output.count(('glibc-livepatch' + str(i)).encode('utf-8'))
+            if apply_count < 10:
+                self.fail("Applying livepatch failed for %s iteration." % i)
+            else:
+                self.log.info("Successfully applied livepatch for %s iteration" % i)
+        for i in range(1, 13):
+            process.system_output('ulp trigger --revert -p %s libc_livepatch%s.so' % (self.pid, i), shell=True)
+            time.sleep(2)
+
+    def test_nested_function_livepatching_multiple2(self):
+        """
+        This test function ensures that 12 nested livepatches are successfully applied and later reverted,
+        with each iteration checked for proper application. The main difference between this test function and
+        the previous one is the order of reverting livepatches, which happens in reverse order (from 12 to 1) in this version.
+        """
+        os.chdir(self.teststmpdir)
+        process.system('tar -xf live_patch_nested.tar.gz', shell=True)
+        process.system('make', shell=True)
+        self.start_test('test_long')
+        os.chdir('live_patch_nested')
+        for i in range(1, 13):
+            process.system('gcc -fPIC -fpatchable-function-entry=16,14 -shared -o libc_livepatch%s.so'
+                           ' libc_livepatch%s.c -msplit-patch-nops' % (i, i), shell=True)
+            process.system('ulp packer %s/live_patch_nested/libc_livepatch%s.dsc' % (self.teststmpdir, i), shell=True)
+            livepatch_output = self.apply_livepatch('libc_livepatch%s.so' % i)
+        for i in range(2, 13):
+            apply_count = livepatch_output.count(('glibc-livepatch' + str(i)).encode('utf-8'))
+            if apply_count < 10:
+                self.fail("Applying livepatch failed for %s iteration." % i)
+            else:
+                self.log.info("Successfully applied livepatch for %s iteration" % i)
+        for i in range(12, 0, -1):
+            process.system_output('ulp trigger --revert -p %s libc_livepatch%s.so' % (self.pid, i), shell=True)
+            time.sleep(2)

ras/live_patching.py.data/Makefile

@@ -1,13 +1,20 @@
-all: libc_livepatch1.so test libc_livepatch_2func.so test_2func
+all: libc_livepatch1.so test test_long libc_livepatch_2func.so test_2func libc_livepatch_nested.so
 
 libc_livepatch1.so: libc_livepatch1.c
 	gcc -fPIC -fpatchable-function-entry=16,14 -shared -o libc_livepatch1.so libc_livepatch1.c
 
 test: test.c
 	gcc -o test test.c
 
+test_long: test_long.c
+	gcc -o test_long test_long.c
+
 libc_livepatch_2func.so: libc_livepatch_2func.c
 	gcc -fPIC -fpatchable-function-entry=16,14 -shared -o libc_livepatch_2func.so libc_livepatch_2func.c
 
 test_2func: test_2func.c
 	gcc -o test_2func test_2func.c
+
+libc_livepatch_nested.so: libc_livepatch_nested.c
+	gcc -fPIC -fpatchable-function-entry=16,14 -shared -o libc_livepatch_nested.so libc_livepatch_nested.c
+

ras/live_patching.py.data/libc_livepatch_nested.c

@@ -0,0 +1,19 @@
+#include <stdlib.h>
+#include <string.h>
+
+#define MIN(x, y) ((x) < (y) ? (x) : (y))
+
+static const char *const lp_string = "glibc-livepatch-nested";
+
+void *malloc_lp_2(size_t s)
+{
+  char *block = calloc(1, s);
+  if (block && s > 0) {
+    int lp_string_len = strlen(lp_string);
+    int copy_len = MIN(lp_string_len + 1, s);
+
+    memcpy(block, lp_string, copy_len);
+    block[s-1] = '\0';
+  }
+  return block;
+}

ras/live_patching.py.data/libc_livepatch_nested.dsc

@@ -0,0 +1,3 @@
+libc_livepatch_nested.so
+@libc_livepatch1.so
+malloc_lp:malloc_lp_2

ras/live_patching.py.data/live_patch_nested.tar.gz

@@ -0,0 +1,38 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <stdbool.h>
+#include <string.h>
+
+#define NUM_ATTEMPTS 500
+#define LEN 32
+
+static const char *const lp_string = "glibc-livepatch";
+
+int main(int argc, char *argv[])
+{
+  for (int i = 0; i < NUM_ATTEMPTS; i++) {
+    bool flag = false;
+    char *m = malloc(LEN);
+    m[LEN-1] = '\0';
+
+    fprintf(stderr, "%s\n", m);
+
+    if (m) {
+      if (!strcmp(m, lp_string)) {
+        flag = true;
+      }
+      free(m);
+    }
+
+    m = calloc(1, 32);
+    if (m) {
+      free(m);
+    } else if (flag) {
+      return 0;
+    }
+    sleep(1);
+  }
+
+  return 1;
+}