Add LTP fsstress test for NFS mounted filesystem

Add new test to validate filesystem operations over NFS using LTP fsstress.
This test extends the existing io/disk/ltp_fsstress.py to support network
filesystem testing.

Test workflow:
- Configures host and peer network interfaces with private IPs
- Establishes SSH connection to peer via public/management IP
- Sets up NFS server on peer (exportfs, rpcbind, firewalld)
- Mounts NFS share on host from peer's private IP
- Downloads and builds LTP from source
- Runs fsstress with configurable parameters on NFS mount
- Monitors dmesg and console logs for errors
- Performs complete cleanup including session termination

Signed-off-by: Vaishnavi Bhat <vaishnavi@linux.vnet.ibm.com>

Author: vaishnavibhat

io/net/ltp_fsstress_nfs.py

@@ -0,0 +1,396 @@
+#!/usr/bin/env python
+
+# 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 LICENSE for more details.
+#
+# Copyright: 2026 IBM
+# Author: Vaishnavi Bhat <vaishnavi@linux.vnet.ibm.com>
+#
+# https://github.com/linux-test-project/ltp
+
+"""
+LTP fsstress test on NFS mounted filesystem
+:avocado: tags=net,fs,privileged
+"""
+
+import os
+import time
+from avocado import Test
+from avocado.utils import build
+from avocado.utils import dmesg
+from avocado.utils import process, archive
+from avocado.utils import distro
+from avocado.utils.software_manager.manager import SoftwareManager
+from avocado.utils.ssh import Session
+from avocado.utils.network.hosts import LocalHost, RemoteHost
+from avocado.utils.network.interfaces import NetworkInterface
+
+
+class LtpFsNfs(Test):
+    '''
+    Using LTP (Linux Test Project) fsstress to test NFS mounted filesystem
+    '''
+
+    def setUp(self):
+        '''
+        Setup network interfaces, NFS server on peer, and mount NFS on host
+        '''
+        self.err_mesg = []
+        
+        # Get test parameters
+        self.host_interface = self.params.get('host_interface', default=None)
+        self.host_ip = self.params.get('host_ip', default=None)
+        self.peer_interface = self.params.get('peer_interface', default=None)
+        self.peer_ip = self.params.get('peer_ip', default=None)
+        self.peer_public_ip = self.params.get('peer_public_ip', default=None)
+        self.peer_user = self.params.get('peer_user', default='root')
+        self.peer_password = self.params.get('peer_password', default=None)
+        self.netmask = self.params.get('netmask', default='255.255.255.0')
+        
+        # NFS mount parameters
+        self.nfs_mount_point = self.params.get('nfs_mount_point', default='/mnt/nfs')
+        self.nfs_server_path = self.params.get('nfs_server_path', default='/mnt/nfssrc')
+        
+        # fsstress parameters
+        self.fsstress_count = self.params.get('fsstress_loop', default='0')
+        self.n_val = self.params.get('n_val', default='200')
+        self.p_val = self.params.get('p_val', default='200')
+        
+        # Validate required parameters
+        if not all([self.host_interface, self.host_ip, self.peer_ip, 
+                    self.peer_public_ip, self.peer_password]):
+            self.cancel("Missing required parameters: host_interface, host_ip, "
+                       "peer_ip, peer_public_ip, peer_password")
+        
+        # Initialize localhost
+        self.localhost = LocalHost()
+        
+        # Check if host interface exists
+        interfaces = os.listdir('/sys/class/net')
+        if self.host_interface not in interfaces:
+            self.cancel(f"Host interface {self.host_interface} not available")
+        
+        # Install required packages
+        smm = SoftwareManager()
+        detected_distro = distro.detect()
+        packages = ['gcc', 'make', 'automake', 'autoconf', 'nfs-utils']
+        
+        if detected_distro.name == 'Ubuntu':
+            packages.extend(['nfs-common', 'openssh-client', 'iputils-ping'])
+        elif detected_distro.name in ['rhel', 'fedora', 'centos', 'redhat']:
+            packages.extend(['openssh-clients', 'iputils'])
+        else:
+            packages.extend(['openssh', 'iputils'])
+        
+        for package in packages:
+            if not smm.check_installed(package) and not smm.install(package):
+                self.cancel(f"{package} is needed for the test to be run")
+        
+        # Configure host interface
+        self.log.info(f"Configuring host interface {self.host_interface} with IP {self.host_ip}")
+        self.host_networkinterface = NetworkInterface(self.host_interface, self.localhost)
+        try:
+            self.host_networkinterface.add_ipaddr(self.host_ip, self.netmask)
+            self.host_networkinterface.bring_up()
+        except Exception as e:
+            self.log.info(f"Host interface configuration: {e}")
+        
+        # Establish SSH connection to peer using public IP
+        self.log.info(f"Connecting to peer at {self.peer_public_ip}")
+        self.session = Session(self.peer_public_ip, user=self.peer_user,
+                              password=self.peer_password)
+        if not self.session.connect():
+            self.cancel("Failed to connect to peer machine")
+        
+        # Initialize remote host with peer private IP for network operations
+        self.remotehost = RemoteHost(self.peer_ip, self.peer_user,
+                                     password=self.peer_password)
+        
+        # Get peer interface by IP or use specified interface
+        peer_iface = None
+        if self.peer_interface:
+            peer_iface = self.peer_interface
+        else:
+            # Try to get interface by IP address
+            try:
+                peer_iface = self.remotehost.get_interface_by_ipaddr(self.peer_ip).name
+            except Exception:
+                self.cancel("Could not determine peer interface. Please specify peer_interface in YAML")
+        
+        # Configure peer interface with private IP
+        if peer_iface:
+            self.log.info(f"Configuring peer interface {peer_iface} with IP {self.peer_ip}")
+            self.peer_networkinterface = NetworkInterface(peer_iface, self.remotehost)
+        else:
+            self.cancel("Peer interface not specified and could not be determined")
+        try:
+            self.peer_networkinterface.add_ipaddr(self.peer_ip, self.netmask)
+            self.peer_networkinterface.bring_up()
+        except Exception as e:
+            self.log.info(f"Peer interface configuration: {e}")
+        
+        # Ping check
+        self.log.info(f"Performing ping check to {self.peer_ip}")
+        ping_cmd = f"ping -c 5 {self.peer_ip}"
+        if process.system(ping_cmd, shell=True, ignore_status=True) != 0:
+            self.cancel(f"Ping to peer {self.peer_ip} failed")
+        
+        # Setup NFS server on peer
+        self.setup_nfs_server()
+        
+        # Mount NFS on host
+        self.mount_nfs()
+        
+        # Download and build LTP
+        self.log.info("Downloading and building LTP")
+        url = "https://github.com/linux-test-project/ltp/archive/master.zip"
+        tarball = self.fetch_asset("ltp-master.zip", locations=[url], expire='7d')
+        archive.extract(tarball, self.teststmpdir)
+        ltp_dir = os.path.join(self.teststmpdir, "ltp-master")
+        os.chdir(ltp_dir)
+        build.make(ltp_dir, extra_args='autotools')
+        process.system('./configure', ignore_status=True)
+        build.make(ltp_dir)
+        build.make(ltp_dir, extra_args='install')
+        self.fsstress_dir = os.path.join(ltp_dir, 'testcases/kernel/fs/fsstress')
+        os.chdir(self.fsstress_dir)
+        
+        # Clear dmesg
+        dmesg.clear_dmesg()
+
+    def setup_nfs_server(self):
+        """
+        Setup NFS server on peer machine:
+        - Create NFS export directory
+        - Start NFS server
+        - Stop firewalld
+        - Export the directory
+        """
+        self.log.info("Setting up NFS server on peer")
+        
+        # Create NFS export directory on peer
+        cmd = f"mkdir -p {self.nfs_server_path}"
+        result = self.session.cmd(cmd)
+        if result.exit_status != 0:
+            self.cancel(f"Failed to create NFS export directory on peer: {result.stderr}")
+        
+        # Install NFS server packages on peer
+        detected_distro = distro.detect()
+        if detected_distro.name == 'Ubuntu':
+            nfs_pkg_cmd = "apt-get update && apt-get install -y nfs-kernel-server"
+        else:
+            nfs_pkg_cmd = "yum install -y nfs-utils"
+        
+        result = self.session.cmd(nfs_pkg_cmd)
+        if result.exit_status != 0:
+            self.log.warning(f"NFS package installation on peer: {result.stderr}")
+        
+        # Start NFS server on peer
+        self.log.info("Starting NFS server on peer")
+        start_nfs_cmds = [
+            "systemctl start nfs-server",
+            "systemctl enable nfs-server",
+            "systemctl start rpcbind",
+            "systemctl enable rpcbind"
+        ]
+        for cmd in start_nfs_cmds:
+            result = self.session.cmd(cmd)
+            if result.exit_status != 0:
+                self.log.warning(f"Command '{cmd}' on peer: {result.stderr}")
+        
+        # Stop firewalld on peer
+        self.log.info("Stopping firewalld on peer")
+        firewall_cmds = [
+            "systemctl stop firewalld",
+            "systemctl disable firewalld"
+        ]
+        for cmd in firewall_cmds:
+            result = self.session.cmd(cmd)
+            # Ignore errors as firewalld might not be running
+        
+        # Export the directory on peer
+        self.log.info(f"Exporting {self.nfs_server_path} to {self.host_ip}")
+        export_cmd = f"exportfs -o rw,sync,no_root_squash {self.host_ip}:{self.nfs_server_path}"
+        result = self.session.cmd(export_cmd)
+        if result.exit_status != 0:
+            self.cancel(f"Failed to export NFS directory on peer: {result.stderr}")
+        
+        # Verify export
+        result = self.session.cmd("exportfs -v")
+        self.log.info(f"NFS exports on peer:\n{result.stdout}")
+
+    def mount_nfs(self):
+        """
+        Mount NFS filesystem on host
+        """
+        self.log.info(f"Mounting NFS from {self.peer_ip}:{self.nfs_server_path} to {self.nfs_mount_point}")
+        
+        # Create mount point on host
+        cmd = f"mkdir -p {self.nfs_mount_point}"
+        if process.system(cmd, shell=True, ignore_status=True) != 0:
+            self.cancel(f"Failed to create mount point {self.nfs_mount_point}")
+        
+        # Mount NFS
+        mount_cmd = f"mount -t nfs {self.peer_ip}:{self.nfs_server_path} {self.nfs_mount_point}"
+        if process.system(mount_cmd, shell=True, ignore_status=True) != 0:
+            self.cancel(f"Failed to mount NFS from {self.peer_ip}:{self.nfs_server_path}")
+        
+        # Verify mount
+        verify_cmd = f"mount | grep {self.nfs_mount_point}"
+        result = process.system_output(verify_cmd, shell=True, ignore_status=True)
+        self.log.info(f"NFS mount verification:\n{result.decode('utf-8')}")
+        
+        # Test write access
+        test_file = os.path.join(self.nfs_mount_point, 'test_write')
+        cmd = f"touch {test_file} && rm -f {test_file}"
+        if process.system(cmd, shell=True, ignore_status=True) != 0:
+            self.cancel(f"NFS mount {self.nfs_mount_point} is not writable")
+        
+        self.log.info("NFS mount successful and writable")
+
+    def test_fsstress_run(self):
+        '''
+        Run LTP fsstress test on NFS mounted filesystem
+        '''
+        self.log.info("Starting fsstress test on NFS mount")
+        arg = f"-d {self.nfs_mount_point} -n {self.n_val} -p {self.p_val} -r -l {self.fsstress_count}"
+        self.log.info(f"fsstress arguments: {arg}")
+        
+        # Clear dmesg before test
+        dmesg.clear_dmesg()
+        
+        # Run fsstress in background using nohup
+        cmd = f"nohup ./fsstress {arg} &"
+        self.log.info(f"Running command: {cmd}")
+        process.run(cmd, shell=True, ignore_status=True)
+        
+        # Get the PID of fsstress
+        time.sleep(2)
+        pid_cmd = "pgrep -f fsstress"
+        try:
+            pid_output = process.system_output(pid_cmd, shell=True, ignore_status=True)
+            if pid_output:
+                self.fsstress_pid = pid_output.decode('utf-8').strip().split()[0]
+                self.log.info(f"fsstress running with PID: {self.fsstress_pid}")
+            else:
+                self.log.warning("Could not get fsstress PID")
+                self.fsstress_pid = None
+        except Exception as e:
+            self.log.warning(f"Error getting fsstress PID: {e}")
+            self.fsstress_pid = None
+        
+        # Wait for fsstress to complete or monitor it
+        if self.fsstress_count == '0':
+            # Infinite loop - let it run for a reasonable time
+            self.log.info("fsstress running in infinite loop mode, monitoring for 60 seconds")
+            time.sleep(60)
+            # Kill fsstress after monitoring period
+            if self.fsstress_pid:
+                kill_cmd = f"kill {self.fsstress_pid}"
+                process.system(kill_cmd, shell=True, ignore_status=True)
+                self.log.info("Stopped fsstress after monitoring period")
+        else:
+            # Wait for fsstress to complete
+            self.log.info(f"Waiting for fsstress to complete {self.fsstress_count} loops")
+            max_wait = int(self.fsstress_count) * 10 + 300  # Estimate wait time
+            wait_time = 0
+            while wait_time < max_wait:
+                check_cmd = "pgrep -f fsstress"
+                result = process.system(check_cmd, shell=True, ignore_status=True)
+                if result != 0:
+                    self.log.info("fsstress completed")
+                    break
+                time.sleep(10)
+                wait_time += 10
+            else:
+                self.log.warning("fsstress did not complete in expected time, stopping it")
+                if self.fsstress_pid:
+                    kill_cmd = f"kill {self.fsstress_pid}"
+                    process.system(kill_cmd, shell=True, ignore_status=True)
+        
+        # Check dmesg for errors
+        self.log.info("Checking dmesg for errors")
+        cmd = "dmesg --level=err,crit,alert,emerg"
+        dmesg_output = process.system_output(cmd, shell=True, ignore_status=True, sudo=False)
+        if dmesg_output:
+            dmesg_str = dmesg_output.decode('utf-8')
+            self.log.warning(f"Errors found in dmesg:\n{dmesg_str}")
+            # Check for NFS-related errors
+            if 'nfs' in dmesg_str.lower() or 'rpc' in dmesg_str.lower():
+                self.fail("NFS-related errors found in dmesg during fsstress test")
+        else:
+            self.log.info("No errors found in dmesg")
+        
+        # Check console logs if available
+        console_log = "/var/log/messages"
+        if os.path.exists(console_log):
+            self.log.info("Checking console logs for NFS errors")
+            grep_cmd = f"grep -i 'nfs\\|rpc' {console_log} | tail -50"
+            console_output = process.system_output(grep_cmd, shell=True, ignore_status=True)
+            if console_output:
+                self.log.info(f"Recent NFS/RPC messages in console:\n{console_output.decode('utf-8')}")
+
+    def tearDown(self):
+        '''
+        Cleanup: unmount NFS, stop NFS server on peer, cleanup network configuration
+        '''
+        self.log.info("Starting cleanup")
+        
+        # Kill any remaining fsstress processes
+        kill_cmd = "pkill -9 fsstress"
+        process.system(kill_cmd, shell=True, ignore_status=True)
+        
+        # Unmount NFS on host
+        self.log.info(f"Unmounting NFS from {self.nfs_mount_point}")
+        umount_cmd = f"umount -f {self.nfs_mount_point}"
+        if process.system(umount_cmd, shell=True, ignore_status=True) != 0:
+            self.log.warning(f"Failed to unmount {self.nfs_mount_point}")
+            self.err_mesg.append(f"Failed to unmount {self.nfs_mount_point}")
+            # Try lazy unmount
+            lazy_umount = f"umount -l {self.nfs_mount_point}"
+            process.system(lazy_umount, shell=True, ignore_status=True)
+        
+        # Remove mount point
+        rm_cmd = f"rmdir {self.nfs_mount_point}"
+        process.system(rm_cmd, shell=True, ignore_status=True)
+        
+        # Cleanup NFS server on peer
+        if hasattr(self, 'session') and self.session:
+            self.log.info("Cleaning up NFS server on peer")
+            
+            # Unexport the directory
+            unexport_cmd = f"exportfs -u {self.host_ip}:{self.nfs_server_path}"
+            result = self.session.cmd(unexport_cmd)
+            if result.exit_status != 0:
+                self.log.warning(f"Failed to unexport NFS directory: {result.stderr}")
+            
+            # Remove NFS export directory
+            rm_nfs_dir = f"rm -rf {self.nfs_server_path}"
+            self.session.cmd(rm_nfs_dir)
+            
+            # Close SSH session
+            self.session.quit()
+        
+        # Close RemoteHost sessions
+        if hasattr(self, 'remotehost') and self.remotehost:
+            try:
+                self.remotehost.remote_session.quit()
+            except Exception as e:
+                self.log.debug(f"Error closing remotehost session: {e}")
+        
+        # Clear dmesg
+        dmesg.clear_dmesg()
+        
+        # Report any errors
+        if self.err_mesg:
+            self.log.warning(f"Test completed with errors: {self.err_mesg}")
+    
+# Made with AI Support