{"id":18616,"date":"2026-09-22T08:53:41","date_gmt":"2026-09-22T08:53:41","guid":{"rendered":"https:\/\/www.examlabs.com\/certification\/?p=18616"},"modified":"2026-09-22T08:53:41","modified_gmt":"2026-09-22T08:53:41","slug":"lpi-101-500-practice-test-questions-and-exam-dumps-part-5-q81-100","status":"publish","type":"post","link":"https:\/\/www.examlabs.com\/certification\/lpi-101-500-practice-test-questions-and-exam-dumps-part-5-q81-100\/","title":{"rendered":"LPI 101-500 Practice Test Questions and Exam Dumps Part 5 Q81-100"},"content":{"rendered":"

View Full<\/b> LPI 101-500<\/b> Exam Dumps<\/b><\/a> and Practice Test Dumps<\/b><\/p>\n

 <\/p>\n

Question: 81. Which command removes a previously defined shell variable from the current shell environment?<\/b><\/p>\n

    \n
  1. <\/b>export<\/span>
    \n<\/span>2.<\/b> unset<\/span>
    \n<\/span>3. <\/b>env<\/span>
    \n<\/span>4.<\/b> set<\/span><\/li>\n<\/ol>\n

    Correct Answer: 2. <\/b>unset<\/b><\/p>\n

    Explanation:<\/b>
    \n<\/b>The <\/span>unset<\/span> command removes a shell variable or function from the current shell environment. For example, <\/span>unset MYVAR<\/span> removes the variable named <\/span>MYVAR<\/span>. After it has been unset, attempting to reference <\/span>$MYVAR<\/span> normally produces an empty value unless the variable is defined again. This is different from <\/span>export<\/span>, which marks a shell variable for inheritance by child processes. The <\/span>env<\/span> command displays or modifies environment variables for a command invocation, while <\/span>set<\/span> is used to display or modify shell options and positional parameters. Understanding variable management is important for shell scripting and Linux command-line administration.<\/span><\/p>\n

    Question: 82. Which command creates a shortcut name for another shell command?<\/b><\/p>\n

      \n
    1. <\/b> alias<\/span>
      \n<\/span>2. <\/b>type<\/span>
      \n<\/span>3.<\/b> history<\/span>
      \n<\/span>4.<\/b> source<\/span><\/li>\n<\/ol>\n

      Correct Answer: 1. <\/b>alias<\/b><\/p>\n

      Explanation:<\/b>
      \n<\/b>The <\/span>alias<\/span> command creates a convenient alternative name for a command or command sequence. For example, <\/span>alias ll=’ls -l’<\/span> allows the user to type <\/span>ll<\/span> instead of the longer <\/span>ls -l<\/span> command. Aliases are commonly used in interactive shells to save typing and create preferred command shortcuts. They are normally shell-specific and may disappear when the shell session ends unless placed in an appropriate shell startup configuration file. The <\/span>type<\/span> command identifies how a command name is interpreted, <\/span>history<\/span> displays previously executed commands, and <\/span>source<\/span> executes commands from a file in the current shell.<\/span><\/p>\n

      Question: 83. Which command removes an existing shell alias?<\/b><\/p>\n

        \n
      1. <\/b>remove<\/span>
        \n<\/span>2.<\/b> unalias<\/span>
        \n<\/span>3. <\/b>unsetalias<\/span>
        \n<\/span>4. <\/b>delete<\/span><\/li>\n<\/ol>\n

        Correct Answer: 2. <\/b>unalias<\/b><\/p>\n

        Explanation:<\/b>
        \n<\/b>The <\/span>unalias<\/span> command removes an alias from the current shell. For example, <\/span>unalias ll<\/span> removes an alias named <\/span>ll<\/span>. This is useful when a shortcut is no longer wanted or when troubleshooting unexpected command behavior caused by an alias. Using <\/span>unalias<\/span> normally affects the current shell session; if the alias is defined in a startup file, it may be recreated when a new shell starts. The <\/span>unset<\/span> command is used for shell variables and functions rather than aliases. Commands such as <\/span>remove<\/span>, <\/span>unsetalias<\/span>, and <\/span>delete<\/span> are not standard Bash commands for removing aliases.<\/span><\/p>\n

        Question: 84. Which shell command displays previously executed commands?<\/b><\/p>\n

          \n
        1. <\/b>recall<\/span>
          \n<\/span>2.<\/b> commands<\/span>
          \n<\/span>3. <\/b>history<\/span>
          \n<\/span>4.<\/b> previous<\/span><\/li>\n<\/ol>\n

          Correct Answer: 3. <\/b>history<\/b><\/p>\n

          Explanation:<\/b>
          \n<\/b>The <\/span>history<\/span> command displays commands that have previously been entered into the shell’s command history. In Bash, the history mechanism allows users to review earlier commands and reuse them without typing everything again. For example, <\/span>history<\/span> may display numbered entries, and a command can often be recalled using shell history expansion or keyboard shortcuts. The history mechanism is especially useful when repeating administrative commands or reviewing recent command-line activity. Commands such as <\/span>recall<\/span>, <\/span>commands<\/span>, and <\/span>previous<\/span> are not standard Bash commands for displaying the shell history.<\/span><\/p>\n

          Question: 85. Which command can be used to determine how the shell interprets a command name?<\/b><\/p>\n

            \n
          1. <\/b>where<\/span>
            \n<\/span>2. <\/b>locate<\/span>
            \n<\/span>3<\/b>. <\/span>whichfile<\/span>
            \n<\/span>4. <\/b>type<\/span><\/li>\n<\/ol>\n

            Correct Answer: 4. <\/b>type<\/b><\/p>\n

            Explanation:<\/b>
            \n<\/b>The <\/span>type<\/span> command tells the shell how a command name would be interpreted. It can identify whether a name refers to an alias, shell builtin, function, keyword, or executable file. For example, <\/span>type cd<\/span> normally identifies <\/span>cd<\/span> as a shell builtin, while <\/span>type ls<\/span> can show the executable path or indicate that <\/span>ls<\/span> is an alias. This makes <\/span>type<\/span> particularly useful when troubleshooting situations where a command behaves unexpectedly. Although <\/span>which<\/span> can locate executable files in the <\/span>PATH<\/span>, it does not provide the same comprehensive information about shell command resolution as <\/span>type<\/span>.<\/span><\/p>\n

            Question: 86. Which command displays the shell’s list of recently executed commands?<\/b><\/p>\n

              \n
            1. <\/b> history<\/span>
              \n<\/span>2. <\/b>lastcmd<\/span>
              \n<\/span>3. <\/b>recent<\/span>
              \n<\/span>4. <\/b>logcmd<\/span><\/li>\n<\/ol>\n

              Correct Answer: 1. <\/b>history<\/b><\/p>\n

              Explanation:<\/b>
              \n<\/b>The <\/span>history<\/span> command is the standard shell command for displaying previously entered commands. In an interactive Bash session, command history allows users to quickly review and reuse commands. It can be particularly useful when working with long command lines, troubleshooting, or repeating administrative tasks. The shell typically assigns numbers to history entries, which can then be referenced through history expansion or keyboard navigation. Commands named <\/span>lastcmd<\/span>, <\/span>recent<\/span>, and <\/span>logcmd<\/span> are not standard Bash commands for this purpose. The exact amount of stored history depends on shell configuration and variables such as <\/span>HISTSIZE<\/span> and <\/span>HISTFILESIZE<\/span>.<\/span><\/p>\n

              Question: 87. What does the <\/b>jobs<\/b> command display in a shell?<\/b><\/p>\n

                \n
              1. <\/b> All users logged into the system<\/span>
                \n<\/span>2.<\/b> Files currently being modified<\/span>
                \n<\/b>3. <\/b>Jobs controlled by the current shell<\/span>
                \n<\/span>4.<\/b> Installed software packages<\/span><\/li>\n<\/ol>\n

                Correct Answer: 3. Jobs controlled by the current shell<\/b><\/p>\n

                Explanation:<\/b>
                \n<\/b>The <\/span>jobs<\/span> command displays information about jobs that are being managed by the current interactive shell. These jobs are commonly created by placing commands in the background or suspending foreground processes. The output may show job numbers and states such as running or stopped. This job-control information can then be used with commands such as <\/span>fg<\/span> and <\/span>bg<\/span>. <\/span>jobs<\/span> does not list every process on the system, nor does it display logged-in users or installed packages. Understanding shell job control is important when managing multiple interactive tasks from a single terminal session.<\/span><\/p>\n

                Question: 88. Which command brings a stopped or background job into the foreground?<\/b><\/p>\n

                  \n
                1. <\/b> bg<\/span>
                  \n<\/span>2.<\/b> fg<\/span>
                  \n<\/span>3. <\/b>front<\/span>
                  \n<\/span>4.<\/b> resume<\/span><\/li>\n<\/ol>\n

                  Correct Answer: 2. <\/b>fg<\/b><\/p>\n

                  Explanation:<\/b>
                  \n<\/b>The <\/span>fg<\/span> command brings a job into the foreground of the current shell. For example, <\/span>fg %1<\/span> can bring job number 1 to the foreground. Once in the foreground, the terminal normally becomes associated with that job, allowing it to receive interactive input. This is different from <\/span>bg<\/span>, which resumes a stopped job in the background. Shell job control uses job identifiers such as <\/span>%1<\/span>, while process IDs identify operating-system processes. The <\/span>fg<\/span> command is therefore useful when a command was previously suspended or started in the background and now needs to continue interactively.<\/span><\/p>\n

                  Question: 89. Which command resumes a stopped shell job in the background?<\/b><\/p>\n

                    \n
                  1. <\/b>resume<\/span>
                    \n<\/span>2. <\/b>start<\/span>
                    \n<\/span>3. <\/b>fg<\/span>
                    \n<\/span>4. <\/b>bg<\/span><\/li>\n<\/ol>\n

                    Correct Answer: 4. <\/b>bg<\/b><\/p>\n

                    Explanation:<\/b>
                    \n<\/b>The <\/span>bg<\/span> command resumes a stopped job while allowing it to continue running in the background. A common sequence is to press <\/span>Ctrl+Z<\/span> to suspend a foreground job and then use <\/span>bg<\/span> to continue that job without occupying the terminal interactively. A job number can be specified, such as <\/span>bg %1<\/span>. The <\/span>fg<\/span> command performs the opposite job-control operation by bringing a job into the foreground. This distinction is important when managing multiple commands from one shell, especially when some tasks need to continue running while the user works on other commands.<\/span><\/p>\n

                    Question: 90. Which shell operator starts a command as a background job?<\/b><\/p>\n

                      \n
                    1. <\/b> &<\/span>
                      \n<\/span>2. <\/b>|<\/span>
                      \n<\/span>3. <\/b>><\/span>
                      \n<\/span>4.<\/b> &&<\/span><\/li>\n<\/ol>\n

                      Correct Answer: 1. <\/b>&<\/b><\/p>\n

                      Explanation:<\/b>
                      \n<\/b>The ampersand operator, <\/span>&<\/span>, causes a shell command to be started as a background job. For example, <\/span>long_command &<\/span> allows the shell to return a prompt while the command continues running. The shell normally assigns a job number and displays information about the associated process. This is different from <\/span>&&<\/span>, which conditionally runs a following command when the previous command succeeds. The pipe operator <\/span>|<\/span> connects the standard output of one command to the standard input of another, while <\/span>><\/span> redirects output to a file. Understanding these operators is fundamental to effective shell usage.<\/span><\/p>\n

                      Question: 91. Which command is commonly used to run a command so it can continue after the terminal session is disconnected?<\/b><\/p>\n

                        \n
                      1. <\/b>detach<\/span>
                        \n<\/span>2. <\/b>nohup<\/span>
                        \n<\/span>3. <\/b>persist<\/span>
                        \n<\/b>4.<\/b> keep<\/span><\/li>\n<\/ol>\n

                        Correct Answer: 2. <\/b>nohup<\/b><\/p>\n

                        Explanation:<\/b>
                        \n<\/b>The <\/span>nohup<\/span> command runs another command while making it resistant to the hangup signal that is normally associated with closing a terminal session. It is commonly used for long-running commands that should continue after the user logs out. For example, <\/span>nohup command &<\/span> can start a command in the background while reducing its dependence on the terminal session. Output is commonly redirected to a file such as <\/span>nohup.out<\/span> when appropriate redirection is not explicitly provided. <\/span>nohup<\/span> does not make a process immortal or guarantee protection from every possible termination method; it specifically addresses hangup-related behavior.<\/span><\/p>\n

                        Question: 92. What does PPID represent in Linux process information?<\/b><\/p>\n

                          \n
                        1. 1<\/b>. Primary Process Identifier<\/span>
                          \n<\/span> <\/b>Previous Program Input Data<\/span>
                          \n<\/span>3. <\/b>Parent Process ID<\/span>
                          \n<\/span>4.<\/b> Protected Process Index<\/span><\/li>\n<\/ol>\n

                          Correct Answer: 3. Parent Process ID<\/b><\/p>\n

                          Explanation:<\/b>
                          \n<\/b>PPID stands for Parent Process ID. Every process, with special system-level exceptions, is associated with a parent process that created it. The PPID identifies that parent process. This relationship is useful when examining process hierarchies and understanding how commands or services were started. The PID identifies the process itself, while the PPID identifies its parent. Tools such as <\/span>ps<\/span> can display both identifiers, allowing administrators to investigate process relationships. PPID should not be confused with terms such as Primary Process Identifier or Protected Process Index, which are not the standard meanings of PPID in Linux process management.<\/span><\/p>\n

                          Question: 93. Which command displays the signals that can be sent to processes?<\/b><\/p>\n

                            \n
                          1. <\/b>kill -l<\/span>
                            \n<\/span>2. <\/b>signals<\/span>
                            \n<\/b>3.<\/b> signal-list<\/span>
                            \n<\/span>4. <\/b>kill –show<\/span><\/li>\n<\/ol>\n

                            Correct Answer: 1. <\/b>kill -l<\/b><\/p>\n

                            Explanation:<\/b>
                            \n<\/b>The <\/span>kill -l<\/span> command lists the signal names and, depending on the implementation, their corresponding signal numbers. Signals provide a mechanism for communicating with processes. For example, administrators can use signals to request that a process terminate, stop, continue, or perform other signal-defined actions. The <\/span>kill<\/span> command is therefore not limited to forcibly terminating processes; its broader purpose is sending signals. The <\/span>-l<\/span> option specifically requests a list of available signals. Commands such as <\/span>signals<\/span>, <\/span>signal-list<\/span>, and <\/span>kill –show<\/span> are not the standard portable syntax for obtaining this signal list.<\/span><\/p>\n

                            Question: 94. Which command changes the scheduling priority of an already running process?<\/b><\/p>\n

                              \n
                            1. <\/b>priority<\/span>
                              \n<\/span>2. <\/b>nice<\/span>
                              \n<\/span>3. <\/b>renice<\/span>
                              \n<\/span>4.<\/b> reprioritize<\/span><\/li>\n<\/ol>\n

                              Correct Answer: 3. <\/b>renice<\/b><\/p>\n

                              Explanation:<\/b>
                              \n<\/b>The <\/span>renice<\/span> command changes the nice value, and therefore the scheduling priority, of processes that are already running. This is different from <\/span>nice<\/span>, which is commonly used when starting a new command with a specified nice value. Adjusting a process’s nice value can influence how much CPU scheduling preference it receives relative to other processes. Permission requirements apply when changing process priority, particularly when attempting to increase scheduling priority. <\/span>renice<\/span> is therefore useful for administrators managing CPU-intensive workloads. Commands named <\/span>priority<\/span> and <\/span>reprioritize<\/span> are not standard Linux commands for changing a running process’s nice value.<\/span><\/p>\n

                              Question: 95. Which wildcard matches any sequence of zero or more characters in a shell pathname pattern?<\/b><\/p>\n

                                \n
                              1. <\/b> ?<\/span>
                                \n<\/span>2. <\/b>[]<\/span>
                                \n<\/span>3. <\/b>*<\/span>
                                \n<\/span>4. <\/b>#<\/span><\/li>\n<\/ol>\n

                                Correct Answer: 3. <\/b>*<\/b><\/p>\n

                                Explanation:<\/b>
                                \n<\/b>In standard shell pathname expansion, the asterisk <\/span>*<\/span> matches any sequence of characters, including an empty sequence, subject to the shell’s pathname expansion rules. For example, <\/span>*.txt<\/span> can match filenames ending in <\/span>.txt<\/span>. The question mark <\/span>?<\/span> normally matches exactly one character, while bracket expressions such as <\/span>[abc]<\/span> match one character from the specified set or range. These patterns are expanded by the shell before the command receives its arguments. Understanding wildcard expansion is essential because the shell performs this expansion rather than the target command itself in the usual case.<\/span><\/p>\n

                                Question: 96. Which wildcard normally matches exactly one character in shell pathname expansion?<\/b><\/p>\n

                                  \n
                                1. <\/b>?<\/span>
                                  \n<\/span>2. <\/b>*<\/span>
                                  \n<\/span>3.<\/b> []<\/span>
                                  \n<\/span>4. <\/b>**<\/span><\/li>\n<\/ol>\n

                                  Correct Answer: 1. <\/b>?<\/b><\/p>\n

                                  Explanation:<\/b>
                                  \n<\/b>The question mark <\/span>?<\/span> is a shell pathname expansion pattern that normally matches exactly one character. For example, <\/span>file?.txt<\/span> can match <\/span>file1.txt<\/span> or <\/span>fileA.txt<\/span>, but it would not normally match <\/span>file10.txt<\/span> because that contains two characters in the position represented by <\/span>?<\/span>. The asterisk <\/span>*<\/span> can match zero or more characters, while bracket expressions such as <\/span>[abc]<\/span> match one character from a specified set. Shell pattern matching should be distinguished from regular expressions because the syntax and behavior are not identical, even though both are commonly used for text and filename selection.<\/span><\/p>\n

                                  Question: 97. Which directory traditionally contains the Linux kernel and boot-related files?<\/b><\/p>\n

                                    \n
                                  1. <\/b>\/opt<\/span>
                                    \n<\/span>2. <\/b>\/boot<\/span>
                                    \n<\/span>3. <\/b>\/srv<\/span>
                                    \n<\/span>4. <\/b>\/media<\/span><\/li>\n<\/ol>\n

                                    Correct Answer: 2. <\/b>\/boot<\/b><\/p>\n

                                    Explanation:<\/b>
                                    \n<\/b>The <\/span>\/boot<\/span> directory contains files needed during the system’s boot process. It commonly includes the Linux kernel, initial RAM filesystem images, and bootloader-related files, although exact contents vary by distribution and configuration. The <\/span>\/opt<\/span> directory is traditionally used for optional add-on application software, <\/span>\/srv<\/span> is intended for data served by system services, and <\/span>\/media<\/span> is commonly used as a mount point for removable media. Understanding standard filesystem hierarchy locations helps administrators locate important system components and distinguish boot files from application, service, and removable-device data.<\/span><\/p>\n

                                    Question: 98. Which command is used to mount a filesystem in Linux?<\/b><\/p>\n

                                      \n
                                    1. <\/b>attach<\/span>
                                      \n<\/span>2. <\/b>mount<\/span>
                                      \n<\/span>3.<\/b> connectfs<\/span>
                                      \n<\/span>4. <\/b>linkfs<\/span><\/li>\n<\/ol>\n

                                      Correct Answer: 2. <\/b>mount<\/b><\/p>\n

                                      Explanation:<\/b>
                                      \n<\/b>The <\/span>mount<\/span> command attaches a filesystem to the Linux directory tree at a specified mount point. For example, a filesystem can be mounted so that its contents become accessible through a directory such as <\/span>\/mnt\/data<\/span>. Linux uses a unified directory hierarchy, so filesystems are integrated into that hierarchy rather than being accessed through separate drive-letter conventions. The <\/span>umount<\/span> command performs the corresponding unmount operation. Proper permissions and filesystem details are required for successful mounting. Commands such as <\/span>attach<\/span>, <\/span>connectfs<\/span>, and <\/span>linkfs<\/span> are not standard Linux commands for mounting filesystems.<\/span><\/p>\n

                                      Question: 99. Which command displays block devices and their relationships in a tree-like format?<\/b><\/p>\n

                                        \n
                                      1. <\/b>lsblk<\/span>
                                        \n<\/span>2. <\/b>blkshow<\/span>
                                        \n<\/span>3. <\/b>devices<\/span>
                                        \n<\/span>4.<\/b> disklist<\/span><\/li>\n<\/ol>\n

                                        Correct Answer: 1. <\/b>lsblk<\/b><\/p>\n

                                        Explanation:<\/b>
                                        \n<\/b>The <\/span>lsblk<\/span> command lists information about block devices and commonly presents their relationships in a tree-like structure. It can show disks, partitions, and related device information, making it useful when examining storage layouts. For example, it can help an administrator determine which partitions belong to which physical disks. This is different from commands focused on filesystem usage or free space. <\/span>df<\/span> reports filesystem space usage, while <\/span>du<\/span> estimates space used by files and directories. <\/span>lsblk<\/span> is therefore particularly useful during storage administration, partition identification, and troubleshooting device layouts.<\/span><\/p>\n

                                        Question: 100. Which command displays the amount of available and used memory in a human-readable form?<\/b><\/p>\n

                                          \n
                                        1. <\/b> memory<\/span>
                                          \n<\/span>2. <\/b>ram<\/span>
                                          \n<\/span>3.<\/b> meminfo<\/span>
                                          \n<\/span>4.<\/b> free -h<\/span><\/li>\n<\/ol>\n

                                          Correct Answer: 4. <\/b>free -h<\/b><\/p>\n

                                          Explanation:<\/b>
                                          \n<\/b>The <\/span>free<\/span> command reports information about system memory, including used and available memory. The <\/span>-h<\/span> option requests human-readable units such as MiB or GiB, making the output easier to interpret. This command is useful when checking memory consumption and determining whether the system has sufficient available RAM. The <\/span>\/proc\/meminfo<\/span> file provides much more detailed memory information, but <\/span>free -h<\/span> offers a convenient summary. Commands such as <\/span>memory<\/span> and <\/span>ram<\/span> are not standard Linux commands for this purpose. Understanding memory reporting is useful for basic Linux performance monitoring and troubleshooting.<\/span><\/p>\n

                                           <\/p>\n","protected":false},"excerpt":{"rendered":"

                                          View Full LPI 101-500 Exam Dumps and Practice Test Dumps   Question: 81. Which command removes a previously defined shell variable from the current shell environment? export 2. unset 3. env 4. set Correct Answer: 2. unset Explanation: The unset command removes a shell variable or function from the current shell environment. For example, unset […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":[],"categories":[1648,1647],"tags":[],"_links":{"self":[{"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/18616"}],"collection":[{"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/comments?post=18616"}],"version-history":[{"count":1,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/18616\/revisions"}],"predecessor-version":[{"id":18617,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/18616\/revisions\/18617"}],"wp:attachment":[{"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/media?parent=18616"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/categories?post=18616"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/tags?post=18616"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}