diff --git a/src/main.py b/src/main.py
index 125a689..88c933d 100644
--- a/src/main.py
+++ b/src/main.py
@@ -32,7 +32,8 @@ def main():
     )
 
     parser.add_argument('--cli', action = 'store_true', help = 'Use a command prompt, allowing for interactive completion of commands.')
-    parser.add_argument('--efs-shell', action = 'store_true', help = 'Spawn an interactive shell to navigate within the embedded filesystem (EFS) of the baseband device.')
+    #parser.add_argument('--efs-shell', action = 'store_true', help = 'Spawn an interactive shell to navigate within the embedded filesystem (EFS) of the baseband device.')
+    parser.add_argument('--efs-shell', nargs='?', const='efs', default=False, choices=['efs', 'efs2'], help='Spawn an interactive shell to navigate within the embedded filesystem (EFS) of the baseband device. Optionally specify "primary" or "alternate" to choose the file system.')
     parser.add_argument('-v', '--verbose', action = 'store_true', help = 'Add output for each received or sent Diag packet.')
 
     input_mode = parser.add_argument_group(title = 'Input mode', description = 'Choose an one least input mode for DIAG data.')
@@ -174,13 +175,13 @@ def parse_modules_args(args):
         diag_input.add_module(CommandLineInterface(diag_input, parser, parse_modules_args))
 
     if args.efs_shell:
-        
+        #print("--efs-shell with", args.efs_shell)
         if diag_input.modules:
             error('You can not both specify the use of EFS shell and a module')
             exit()
             
         from .modules.efs_shell import EfsShell
-        diag_input.add_module(EfsShell(diag_input))
+        diag_input.add_module(EfsShell(diag_input,args.efs_shell))
             
 
 
diff --git a/src/modules/efs_shell.py b/src/modules/efs_shell.py
index 2aceed9..295af34 100644
--- a/src/modules/efs_shell.py
+++ b/src/modules/efs_shell.py
@@ -34,10 +34,11 @@
 
 class EfsShell:
     
-    def __init__(self, diag_input : BaseInput):
+    def __init__(self, diag_input : BaseInput,fs_type: str = 'efs'):
         
         self.diag_input : BaseInput = diag_input
-        
+        self.fs_type = fs_type
+        #print("EfsShell", self.fs_type)
         self.parser = ArgumentParser(description = 'Spawn an interactive shell to navigate within the embedded filesystem (EFS) of the baseband device.', prog = '')
         
         self.sub_parsers : _SubParsersAction = self.parser.add_subparsers()
@@ -45,8 +46,8 @@ def __init__(self, diag_input : BaseInput):
         self.sub_parser_command_name_to_command_object : Dict[str, BaseEfsShellCommand] = {}
         
         for command_class in ALL_COMMAND_CLASSES:
-            
-            command_object = command_class()
+           
+            command_object = command_class(fs_type)
             
             sub_parser = command_object.get_argument_parser(self.sub_parsers) # Will populate the "self.sub_parsers._name_parser_map" map, see the source of "argparse.py" in Python's standard library for reference
             
@@ -129,9 +130,14 @@ def on_init(self):
                         self.print_help()
     
     def send_efs_handshake(self):
-        
+        if self.fs_type == 'efs':
+            subsys_code = DIAG_SUBSYS_FS  # Assuming DIAG_SUBSYS_FS is the code for primary
+        elif self.fs_type == 'efs2':
+            subsys_code = DIAG_SUBSYS_FS_ALTERNATE
+        else:
+            raise ValueError("Invalid filesystem type specified.")
         opcode, payload = self.diag_input.send_recv(DIAG_SUBSYS_CMD_F, pack('<BH6I3II',
-            DIAG_SUBSYS_FS, # Command subsystem number
+            subsys_code, # Command subsystem number
             EFS2_DIAG_HELLO, # Command code
             0x100000, # Put all the windows size to high values, let the device negociate these down
             0x100000,
diff --git a/src/modules/efs_shell_commands/_base_efs_shell_command.py b/src/modules/efs_shell_commands/_base_efs_shell_command.py
index d89c031..236acb6 100644
--- a/src/modules/efs_shell_commands/_base_efs_shell_command.py
+++ b/src/modules/efs_shell_commands/_base_efs_shell_command.py
@@ -2,11 +2,14 @@
 from argparse import ArgumentParser, _SubParsersAction, Namespace
 
 class BaseEfsShellCommand:
+
+    # Initialization method, add an attribute used to store the file system type
+    def __init__(self, fs_type='efs'):
+        self.fs_type = fs_type
     
     def get_argument_parser(self, subparsers_object : _SubParsersAction) -> ArgumentParser:
         
         pass
     
     def execute_command(self, diag_input, args : Namespace):
-        
         pass
diff --git a/src/modules/efs_shell_commands/cat.py b/src/modules/efs_shell_commands/cat.py
index 7e299cb..2461009 100644
--- a/src/modules/efs_shell_commands/cat.py
+++ b/src/modules/efs_shell_commands/cat.py
@@ -15,6 +15,13 @@
 
 class CatCommand(BaseEfsShellCommand):
     
+    #Add new parameter efs_type to the initialization method
+    def __init__(self, efs_type=None):
+        # Save efs_type for use by other methods of the class
+        self.efs_type = efs_type
+        # Call the parent class's initialization method, if necessary
+        super().__init__(fs_type=efs_type)
+
     def get_argument_parser(self, subparsers_object : _SubParsersAction) -> ArgumentParser:
         
         argument_parser = subparsers_object.add_parser('cat',
@@ -26,9 +33,14 @@ def get_argument_parser(self, subparsers_object : _SubParsersAction) -> Argument
         return argument_parser
         
     def execute_command(self, diag_input, args : Namespace):
-        
+        if self.fs_type == 'efs':
+            subsys_code = DIAG_SUBSYS_FS  # Assuming DIAG_SUBSYS_FS is the code for primary
+        elif self.fs_type == 'efs2':
+            subsys_code = DIAG_SUBSYS_FS_ALTERNATE
+        else:
+            raise ValueError("Invalid filesystem type specified.")
         opcode, payload = diag_input.send_recv(DIAG_SUBSYS_CMD_F, pack('<BHii',
-            DIAG_SUBSYS_FS, # Command subsystem number
+            subsys_code, # Command subsystem number
             EFS2_DIAG_OPEN,
             0x0, # oflag - "O_RDONLY"
             0, # mode (ignored)
@@ -55,7 +67,7 @@ def execute_command(self, diag_input, args : Namespace):
             while True:
                 
                 opcode, payload = diag_input.send_recv(DIAG_SUBSYS_CMD_F, pack('<BHiII',
-                    DIAG_SUBSYS_FS, # Command subsystem number
+                    subsys_code, # Command subsystem number
                     EFS2_DIAG_READ,
                     file_fd, # File descriptor to read from
                     BYTES_TO_READ, # Bytes to read at once
@@ -123,7 +135,7 @@ def execute_command(self, diag_input, args : Namespace):
         finally:
             
             opcode, payload = diag_input.send_recv(DIAG_SUBSYS_CMD_F, pack('<BHi',
-                DIAG_SUBSYS_FS, # Command subsystem number
+                subsys_code, # Command subsystem number
                 EFS2_DIAG_CLOSE,
                 file_fd
             ))
diff --git a/src/modules/efs_shell_commands/chmod.py b/src/modules/efs_shell_commands/chmod.py
index 29b3225..5dd68a1 100644
--- a/src/modules/efs_shell_commands/chmod.py
+++ b/src/modules/efs_shell_commands/chmod.py
@@ -15,7 +15,13 @@
 from ...protocol.efs2 import *
 
 class ChmodCommand(BaseEfsShellCommand):
-    
+    #Add new parameter efs_type to the initialization method
+    def __init__(self, efs_type=None):
+        # Save efs_type for use by other methods of the class
+        self.efs_type = efs_type
+        # Call the parent class's initialization method, if necessary
+        super().__init__(fs_type=efs_type)
+
     def get_argument_parser(self, subparsers_object : _SubParsersAction) -> ArgumentParser:
         
         argument_parser = subparsers_object.add_parser('chmod',
@@ -34,7 +40,13 @@ def get_argument_parser(self, subparsers_object : _SubParsersAction) -> Argument
         return argument_parser
         
     def execute_command(self, diag_input, args : Namespace):
-    
+        if self.fs_type == 'efs':
+            subsys_code = DIAG_SUBSYS_FS  # Assuming DIAG_SUBSYS_FS is the code for primary
+        elif self.fs_type == 'efs2':
+            subsys_code = DIAG_SUBSYS_FS_ALTERNATE
+        else:
+            raise ValueError("Invalid filesystem type specified.")
+        
         try:
             assert int(args.octal_perms, 8) & ~0o777 == 0
         except Exception:
@@ -47,7 +59,7 @@ def execute_command(self, diag_input, args : Namespace):
         is_directory : bool = False
         
         opcode, payload = diag_input.send_recv(DIAG_SUBSYS_CMD_F, pack('<BH',
-            DIAG_SUBSYS_FS, # Command subsystem number
+            subsys_code, # Command subsystem number
             EFS2_DIAG_STAT,
         ) + args.file_path.encode('latin1').decode('unicode_escape').encode('latin1') + b'\x00', accept_error = True)
         
@@ -106,7 +118,7 @@ def execute_command(self, diag_input, args : Namespace):
         # Then, actually open the file for write and/or creation
         
         opcode, payload = diag_input.send_recv(DIAG_SUBSYS_CMD_F, pack('<BHH',
-            DIAG_SUBSYS_FS, # Command subsystem number
+            subsys_code, # Command subsystem number
             EFS2_DIAG_CHMOD,
             file_mode
         ) + args.file_path.encode('latin1').decode('unicode_escape').encode('latin1') + b'\x00', accept_error = True)
diff --git a/src/modules/efs_shell_commands/device_info.py b/src/modules/efs_shell_commands/device_info.py
index 0d59475..c7e5111 100644
--- a/src/modules/efs_shell_commands/device_info.py
+++ b/src/modules/efs_shell_commands/device_info.py
@@ -15,7 +15,13 @@
 from ...protocol.efs2 import *
 
 class DeviceInfoCommand(BaseEfsShellCommand):
-    
+    #Add new parameter efs_type to the initialization method
+    def __init__(self, efs_type=None):
+        # Save efs_type for use by other methods of the class
+        self.efs_type = efs_type
+        # Call the parent class's initialization method, if necessary
+        super().__init__(fs_type=efs_type)
+
     def get_argument_parser(self, subparsers_object : _SubParsersAction) -> ArgumentParser:
         
         argument_parser = subparsers_object.add_parser('device_info',
@@ -24,13 +30,18 @@ def get_argument_parser(self, subparsers_object : _SubParsersAction) -> Argument
         return argument_parser
         
     def execute_command(self, diag_input, args : Namespace):
-        
+        if self.fs_type == 'efs':
+            subsys_code = DIAG_SUBSYS_FS  # Assuming DIAG_SUBSYS_FS is the code for primary
+        elif self.fs_type == 'efs2':
+            subsys_code = DIAG_SUBSYS_FS_ALTERNATE
+        else:
+            raise ValueError("Invalid filesystem type specified.")
         # Obtain the EFS underlying flash device information
         
         sequence_number = randint(0, 0xffff)
         
         opcode, payload = diag_input.send_recv(DIAG_SUBSYS_CMD_F, pack('<BH',
-            DIAG_SUBSYS_FS, # Command subsystem number
+            subsys_code, # Command subsystem number
             EFS2_DIAG_DEV_INFO), accept_error = True)
         
         if opcode != DIAG_SUBSYS_CMD_F:
diff --git a/src/modules/efs_shell_commands/get.py b/src/modules/efs_shell_commands/get.py
index fcde8d4..4828d2e 100644
--- a/src/modules/efs_shell_commands/get.py
+++ b/src/modules/efs_shell_commands/get.py
@@ -15,7 +15,12 @@
 from ...protocol.efs2 import *
 
 class GetCommand(BaseEfsShellCommand):
-    
+    #Add new parameter efs_type to the initialization method
+    def __init__(self, efs_type=None):
+        # Save efs_type for use by other methods of the class
+        self.efs_type = efs_type
+        # Call the parent class's initialization method, if necessary
+        super().__init__(fs_type=efs_type)
     def get_argument_parser(self, subparsers_object : _SubParsersAction) -> ArgumentParser:
         
         argument_parser = subparsers_object.add_parser('get',
@@ -27,7 +32,12 @@ def get_argument_parser(self, subparsers_object : _SubParsersAction) -> Argument
         return argument_parser
         
     def execute_command(self, diag_input, args : Namespace):
-        
+        if self.fs_type == 'efs':
+            subsys_code = DIAG_SUBSYS_FS  # Assuming DIAG_SUBSYS_FS is the code for primary
+        elif self.fs_type == 'efs2':
+            subsys_code = DIAG_SUBSYS_FS_ALTERNATE
+        else:
+            raise ValueError("Invalid filesystem type specified.")
         remote_src : str = args.remote_src
         local_dst : str = expanduser(args.local_dst or (getcwd() + '/' + basename(remote_src)))
         
@@ -39,7 +49,7 @@ def execute_command(self, diag_input, args : Namespace):
             return
         
         opcode, payload = diag_input.send_recv(DIAG_SUBSYS_CMD_F, pack('<BHii',
-            DIAG_SUBSYS_FS, # Command subsystem number
+            subsys_code, # Command subsystem number
             EFS2_DIAG_OPEN,
             0x0, # oflag - "O_RDONLY"
             0, # mode (ignored)
@@ -66,7 +76,7 @@ def execute_command(self, diag_input, args : Namespace):
                 while True:
                     
                     opcode, payload = diag_input.send_recv(DIAG_SUBSYS_CMD_F, pack('<BHiII',
-                        DIAG_SUBSYS_FS, # Command subsystem number
+                        subsys_code, # Command subsystem number
                         EFS2_DIAG_READ,
                         file_fd, # File descriptor to read from
                         BYTES_TO_READ, # Bytes to read at once
@@ -94,7 +104,7 @@ def execute_command(self, diag_input, args : Namespace):
         finally:
             
             opcode, payload = diag_input.send_recv(DIAG_SUBSYS_CMD_F, pack('<BHi',
-                DIAG_SUBSYS_FS, # Command subsystem number
+                subsys_code, # Command subsystem number
                 EFS2_DIAG_CLOSE,
                 file_fd
             ))
diff --git a/src/modules/efs_shell_commands/ln.py b/src/modules/efs_shell_commands/ln.py
index 5799331..b714bd6 100644
--- a/src/modules/efs_shell_commands/ln.py
+++ b/src/modules/efs_shell_commands/ln.py
@@ -15,7 +15,12 @@
 from ...protocol.efs2 import *
 
 class LnCommand(BaseEfsShellCommand):
-    
+    #Add new parameter efs_type to the initialization method
+    def __init__(self, efs_type=None):
+        # Save efs_type for use by other methods of the class
+        self.efs_type = efs_type
+        # Call the parent class's initialization method, if necessary
+        super().__init__(fs_type=efs_type)
     def get_argument_parser(self, subparsers_object : _SubParsersAction) -> ArgumentParser:
         
         argument_parser = subparsers_object.add_parser('ln',
@@ -27,11 +32,16 @@ def get_argument_parser(self, subparsers_object : _SubParsersAction) -> Argument
         return argument_parser
         
     def execute_command(self, diag_input, args : Namespace):
-        
+        if self.fs_type == 'efs':
+            subsys_code = DIAG_SUBSYS_FS  # Assuming DIAG_SUBSYS_FS is the code for primary
+        elif self.fs_type == 'efs2':
+            subsys_code = DIAG_SUBSYS_FS_ALTERNATE
+        else:
+            raise ValueError("Invalid filesystem type specified.")
         # Rename the target path
         
         opcode, payload = diag_input.send_recv(DIAG_SUBSYS_CMD_F, pack('<BH',
-            DIAG_SUBSYS_FS, # Command subsystem number
+            subsys_code, # Command subsystem number
             EFS2_DIAG_SYMLINK,
         ) + args.remote_newlink.encode('latin1').decode('unicode_escape').encode('latin1') + b'\x00'
           + args.remote_target.encode('latin1').decode('unicode_escape').encode('latin1') + b'\x00', accept_error = True)
diff --git a/src/modules/efs_shell_commands/ls.py b/src/modules/efs_shell_commands/ls.py
index b66a1a8..d5c8a59 100644
--- a/src/modules/efs_shell_commands/ls.py
+++ b/src/modules/efs_shell_commands/ls.py
@@ -14,7 +14,13 @@
 from os import strerror
 
 class LsCommand(BaseEfsShellCommand):
-    
+    #Add new parameter efs_type to the initialization method
+    def __init__(self, efs_type=None):
+        # Save efs_type for use by other methods of the class
+        self.efs_type = efs_type
+        # Call the parent class's initialization method, if necessary
+        super().__init__(fs_type=efs_type)
+
     def get_argument_parser(self, subparsers_object : _SubParsersAction) -> ArgumentParser:
         
         argument_parser = subparsers_object.add_parser('ls',
@@ -26,9 +32,15 @@ def get_argument_parser(self, subparsers_object : _SubParsersAction) -> Argument
         return argument_parser
         
     def execute_command(self, diag_input, args : Namespace):
-        
+        #print("LsCommand", self.fs_type)
+        if self.fs_type == 'efs':
+            subsys_code = DIAG_SUBSYS_FS  # Assuming DIAG_SUBSYS_FS is the code for primary
+        elif self.fs_type == 'efs2':
+            subsys_code = DIAG_SUBSYS_FS_ALTERNATE
+        else:
+            raise ValueError("Invalid filesystem type specified.")
         opcode, payload = diag_input.send_recv(DIAG_SUBSYS_CMD_F, pack('<BH',
-            DIAG_SUBSYS_FS, # Command subsystem number
+            subsys_code, # Command subsystem number
             EFS2_DIAG_OPENDIR
         ) + args.path.encode('latin1').decode('unicode_escape').encode('latin1') + b'\x00', accept_error = True)
         
@@ -53,7 +65,7 @@ def execute_command(self, diag_input, args : Namespace):
             while True: # Iterate over directory files
             
                 opcode, payload = diag_input.send_recv(DIAG_SUBSYS_CMD_F, pack('<BHIi',
-                    DIAG_SUBSYS_FS, # Command subsystem number,
+                    subsys_code, # Command subsystem number,
                     EFS2_DIAG_READDIR,
                     dir_fd, sequence_number), accept_error = False)
                     
@@ -92,7 +104,7 @@ def execute_command(self, diag_input, args : Namespace):
                 if mode & 0o170000 == 0o120000: # S_IFLNK
 
                     opcode, payload = diag_input.send_recv(DIAG_SUBSYS_CMD_F, pack('<BH',
-                        DIAG_SUBSYS_FS, # Command subsystem number,
+                        subsys_code, # Command subsystem number,
                         EFS2_DIAG_READLINK) + entry_path.rstrip(b'\x00') + b'\x00', accept_error = False)
                         
                     readlink_struct = '<BHI'
@@ -146,7 +158,7 @@ def execute_command(self, diag_input, args : Namespace):
         finally:
             
             opcode, payload = diag_input.send_recv(DIAG_SUBSYS_CMD_F, pack('<BHi',
-                DIAG_SUBSYS_FS, # Command subsystem number
+                subsys_code, # Command subsystem number
                 EFS2_DIAG_CLOSEDIR,
                 dir_fd
             ))
diff --git a/src/modules/efs_shell_commands/md5sum.py b/src/modules/efs_shell_commands/md5sum.py
index 125c463..2443278 100644
--- a/src/modules/efs_shell_commands/md5sum.py
+++ b/src/modules/efs_shell_commands/md5sum.py
@@ -15,7 +15,12 @@
 from ...protocol.efs2 import *
 
 class Md5sumCommand(BaseEfsShellCommand):
-    
+    #Add new parameter efs_type to the initialization method
+    def __init__(self, efs_type=None):
+        # Save efs_type for use by other methods of the class
+        self.efs_type = efs_type
+        # Call the parent class's initialization method, if necessary
+        super().__init__(fs_type=efs_type)
     def get_argument_parser(self, subparsers_object : _SubParsersAction) -> ArgumentParser:
         
         argument_parser = subparsers_object.add_parser('md5sum',
@@ -26,13 +31,18 @@ def get_argument_parser(self, subparsers_object : _SubParsersAction) -> Argument
         return argument_parser
         
     def execute_command(self, diag_input, args : Namespace):
-        
+        if self.fs_type == 'efs':
+            subsys_code = DIAG_SUBSYS_FS  # Assuming DIAG_SUBSYS_FS is the code for primary
+        elif self.fs_type == 'efs2':
+            subsys_code = DIAG_SUBSYS_FS_ALTERNATE
+        else:
+            raise ValueError("Invalid filesystem type specified.")
         # Obtain the file checksum
         
         sequence_number = randint(0, 0xffff)
         
         opcode, payload = diag_input.send_recv(DIAG_SUBSYS_CMD_F, pack('<BHH',
-            DIAG_SUBSYS_FS, # Command subsystem number
+            subsys_code, # Command subsystem number
             EFS2_DIAG_MKDIR,
             sequence_number
         ) + args.path.encode('latin1').decode('unicode_escape').encode('latin1') + b'\x00', accept_error = True)
diff --git a/src/modules/efs_shell_commands/mkdir.py b/src/modules/efs_shell_commands/mkdir.py
index 1214f89..4f62988 100644
--- a/src/modules/efs_shell_commands/mkdir.py
+++ b/src/modules/efs_shell_commands/mkdir.py
@@ -15,7 +15,12 @@
 from ...protocol.efs2 import *
 
 class MkdirCommand(BaseEfsShellCommand):
-    
+    #Add new parameter efs_type to the initialization method
+    def __init__(self, efs_type=None):
+        # Save efs_type for use by other methods of the class
+        # self.efs_type = efs_type
+        # Call the parent class's initialization method, if necessary
+        super().__init__(fs_type=efs_type)
     def get_argument_parser(self, subparsers_object : _SubParsersAction) -> ArgumentParser:
         
         argument_parser = subparsers_object.add_parser('mkdir',
@@ -26,11 +31,16 @@ def get_argument_parser(self, subparsers_object : _SubParsersAction) -> Argument
         return argument_parser
         
     def execute_command(self, diag_input, args : Namespace):
-        
+        if self.fs_type == 'efs':
+            subsys_code = DIAG_SUBSYS_FS  # Assuming DIAG_SUBSYS_FS is the code for primary
+        elif self.fs_type == 'efs2':
+            subsys_code = DIAG_SUBSYS_FS_ALTERNATE
+        else:
+            raise ValueError("Invalid filesystem type specified.")
         # Create the directory
         
         opcode, payload = diag_input.send_recv(DIAG_SUBSYS_CMD_F, pack('<BHh',
-            DIAG_SUBSYS_FS, # Command subsystem number
+            subsys_code, # Command subsystem number
             EFS2_DIAG_MKDIR,
             0o777 | 0o040000 # S_IFDIR (directory) + all permissions
         ) + args.path.encode('latin1').decode('unicode_escape').encode('latin1') + b'\x00', accept_error = True)
diff --git a/src/modules/efs_shell_commands/mv.py b/src/modules/efs_shell_commands/mv.py
index fa1ce94..2c396bc 100644
--- a/src/modules/efs_shell_commands/mv.py
+++ b/src/modules/efs_shell_commands/mv.py
@@ -15,7 +15,12 @@
 from ...protocol.efs2 import *
 
 class MvCommand(BaseEfsShellCommand):
-    
+    #Add new parameter efs_type to the initialization method
+    def __init__(self, efs_type=None):
+        # Save efs_type for use by other methods of the class
+        self.efs_type = efs_type
+        # Call the parent class's initialization method, if necessary
+        super().__init__(fs_type=efs_type)
     def get_argument_parser(self, subparsers_object : _SubParsersAction) -> ArgumentParser:
         
         argument_parser = subparsers_object.add_parser('mv',
@@ -27,11 +32,16 @@ def get_argument_parser(self, subparsers_object : _SubParsersAction) -> Argument
         return argument_parser
         
     def execute_command(self, diag_input, args : Namespace):
-        
+        if self.fs_type == 'efs':
+            subsys_code = DIAG_SUBSYS_FS  # Assuming DIAG_SUBSYS_FS is the code for primary
+        elif self.fs_type == 'efs2':
+            subsys_code = DIAG_SUBSYS_FS_ALTERNATE
+        else:
+            raise ValueError("Invalid filesystem type specified.")
         # Rename the target path
         
         opcode, payload = diag_input.send_recv(DIAG_SUBSYS_CMD_F, pack('<BH',
-            DIAG_SUBSYS_FS, # Command subsystem number
+            subsys_code, # Command subsystem number
             EFS2_DIAG_RENAME,
         ) + args.remote_src.encode('latin1').decode('unicode_escape').encode('latin1') + b'\x00'
           + args.remote_dst.encode('latin1').decode('unicode_escape').encode('latin1') + b'\x00', accept_error = True)
diff --git a/src/modules/efs_shell_commands/put.py b/src/modules/efs_shell_commands/put.py
index b492b42..6baa118 100644
--- a/src/modules/efs_shell_commands/put.py
+++ b/src/modules/efs_shell_commands/put.py
@@ -15,7 +15,12 @@
 from ...protocol.efs2 import *
 
 class PutCommand(BaseEfsShellCommand):
-    
+    #Add new parameter efs_type to the initialization method
+    def __init__(self, efs_type=None):
+        # Save efs_type for use by other methods of the class
+        self.efs_type = efs_type
+        # Call the parent class's initialization method, if necessary
+        super().__init__(fs_type=efs_type)
     def get_argument_parser(self, subparsers_object : _SubParsersAction) -> ArgumentParser:
         
         argument_parser = subparsers_object.add_parser('put',
@@ -27,7 +32,12 @@ def get_argument_parser(self, subparsers_object : _SubParsersAction) -> Argument
         return argument_parser
         
     def execute_command(self, diag_input, args : Namespace):
-        
+        if self.fs_type == 'efs':
+            subsys_code = DIAG_SUBSYS_FS  # Assuming DIAG_SUBSYS_FS is the code for primary
+        elif self.fs_type == 'efs2':
+            subsys_code = DIAG_SUBSYS_FS_ALTERNATE
+        else:
+            raise ValueError("Invalid filesystem type specified.")
         local_src : str = expanduser(args.local_src)
         remote_dst : str = args.remote_dst
         
@@ -48,7 +58,7 @@ def execute_command(self, diag_input, args : Namespace):
             is_directory : bool = False
             
             opcode, payload = diag_input.send_recv(DIAG_SUBSYS_CMD_F, pack('<BH',
-                DIAG_SUBSYS_FS, # Command subsystem number
+                subsys_code, # Command subsystem number
                 EFS2_DIAG_STAT,
             ) + remote_dst.encode('latin1').decode('unicode_escape').encode('latin1') + b'\x00', accept_error = True)
             
@@ -73,7 +83,7 @@ def execute_command(self, diag_input, args : Namespace):
             # Then, actually open the file for write and/or creation
             
             opcode, payload = diag_input.send_recv(DIAG_SUBSYS_CMD_F, pack('<BHii',
-                DIAG_SUBSYS_FS, # Command subsystem number
+                subsys_code, # Command subsystem number
                 EFS2_DIAG_OPEN,
                 0o1101, # oflag - "O_WRONLY | O_TRUNC | O_CREAT "
                 file_mode_int, # mode
@@ -104,7 +114,7 @@ def execute_command(self, diag_input, args : Namespace):
                         break
                     
                     opcode, payload = diag_input.send_recv(DIAG_SUBSYS_CMD_F, pack('<BHiI',
-                        DIAG_SUBSYS_FS, # Command subsystem number
+                        subsys_code, # Command subsystem number
                         EFS2_DIAG_WRITE,
                         file_fd, # File descriptor to write to
                         read_position # File position to write at
@@ -122,7 +132,7 @@ def execute_command(self, diag_input, args : Namespace):
             finally:
                 
                 opcode, payload = diag_input.send_recv(DIAG_SUBSYS_CMD_F, pack('<BHi',
-                    DIAG_SUBSYS_FS, # Command subsystem number
+                    subsys_code, # Command subsystem number
                     EFS2_DIAG_CLOSE,
                     file_fd
                 ))
diff --git a/src/modules/efs_shell_commands/rm.py b/src/modules/efs_shell_commands/rm.py
index f48f7d4..f8aa943 100644
--- a/src/modules/efs_shell_commands/rm.py
+++ b/src/modules/efs_shell_commands/rm.py
@@ -15,7 +15,12 @@
 from ...protocol.efs2 import *
 
 class RmCommand(BaseEfsShellCommand):
-    
+    #Add new parameter efs_type to the initialization method
+    def __init__(self, efs_type=None):
+        # Save efs_type for use by other methods of the class
+        self.efs_type = efs_type
+        # Call the parent class's initialization method, if necessary
+        super().__init__(fs_type=efs_type)
     def get_argument_parser(self, subparsers_object : _SubParsersAction) -> ArgumentParser:
         
         argument_parser = subparsers_object.add_parser('rm',
@@ -26,14 +31,19 @@ def get_argument_parser(self, subparsers_object : _SubParsersAction) -> Argument
         return argument_parser
         
     def execute_command(self, diag_input, args : Namespace):
-    
+        if self.fs_type == 'efs':
+            subsys_code = DIAG_SUBSYS_FS  # Assuming DIAG_SUBSYS_FS is the code for primary
+        elif self.fs_type == 'efs2':
+            subsys_code = DIAG_SUBSYS_FS_ALTERNATE
+        else:
+            raise ValueError("Invalid filesystem type specified.")
         # First, emit a stat() (EFS2_DIAG_STAT) call in order to understand whether
         # the remote path input by the user is a directory or not
         
         is_directory : bool = False
         
         opcode, payload = diag_input.send_recv(DIAG_SUBSYS_CMD_F, pack('<BH',
-            DIAG_SUBSYS_FS, # Command subsystem number
+            subsys_code, # Command subsystem number
             EFS2_DIAG_STAT,
         ) + args.path.encode('latin1').decode('unicode_escape').encode('latin1') + b'\x00', accept_error = True)
         
@@ -58,7 +68,7 @@ def execute_command(self, diag_input, args : Namespace):
         # Then, actually open the file for write and/or creation
         
         opcode, payload = diag_input.send_recv(DIAG_SUBSYS_CMD_F, pack('<BH',
-            DIAG_SUBSYS_FS, # Command subsystem number
+            subsys_code, # Command subsystem number
             EFS2_DIAG_RMDIR if is_directory else EFS2_DIAG_UNLINK,
         ) + args.path.encode('latin1').decode('unicode_escape').encode('latin1') + b'\x00', accept_error = True)
         
diff --git a/src/modules/efs_shell_commands/stat.py b/src/modules/efs_shell_commands/stat.py
index aabf546..d820c09 100644
--- a/src/modules/efs_shell_commands/stat.py
+++ b/src/modules/efs_shell_commands/stat.py
@@ -14,7 +14,12 @@
 from os import strerror
 
 class StatCommand(BaseEfsShellCommand):
-    
+    #Add new parameter efs_type to the initialization method
+    def __init__(self, efs_type=None):
+        # Save efs_type for use by other methods of the class
+        self.efs_type = efs_type
+        # Call the parent class's initialization method, if necessary
+        super().__init__(fs_type=efs_type)
     def get_argument_parser(self, subparsers_object : _SubParsersAction) -> ArgumentParser:
         
         argument_parser = subparsers_object.add_parser('stat',
@@ -26,11 +31,16 @@ def get_argument_parser(self, subparsers_object : _SubParsersAction) -> Argument
         return argument_parser
         
     def execute_command(self, diag_input, args : Namespace):
-
+        if self.fs_type == 'efs':
+            subsys_code = DIAG_SUBSYS_FS  # Assuming DIAG_SUBSYS_FS is the code for primary
+        elif self.fs_type == 'efs2':
+            subsys_code = DIAG_SUBSYS_FS_ALTERNATE
+        else:
+            raise ValueError("Invalid filesystem type specified.")
         encoded_path : bytes = args.path.encode('latin1').decode('unicode_escape').encode('latin1') + b'\x00'
 
         opcode, payload = diag_input.send_recv(DIAG_SUBSYS_CMD_F, pack('<BH',
-            DIAG_SUBSYS_FS, # Command subsystem number,
+            subsys_code, # Command subsystem number,
             EFS2_DIAG_STAT) + encoded_path, accept_error = True)
             
         readdir_struct = '<BHI8i'
@@ -68,7 +78,7 @@ def execute_command(self, diag_input, args : Namespace):
         if mode & 0o170000 == 0o120000: # S_IFLNK
 
             opcode, payload = diag_input.send_recv(DIAG_SUBSYS_CMD_F, pack('<BH',
-                DIAG_SUBSYS_FS, # Command subsystem number,
+                subsys_code, # Command subsystem number,
                 EFS2_DIAG_READLINK) + encoded_path, accept_error = False)
                 
             readlink_struct = '<BHI'