{"id":18638,"date":"2026-09-22T08:57:49","date_gmt":"2026-09-22T08:57:49","guid":{"rendered":"https:\/\/www.examlabs.com\/certification\/?p=18638"},"modified":"2026-09-22T08:57:49","modified_gmt":"2026-09-22T08:57:49","slug":"lpi-101-500-practice-test-questions-and-exam-dumps-part-17-q321-340","status":"publish","type":"post","link":"https:\/\/www.examlabs.com\/certification\/lpi-101-500-practice-test-questions-and-exam-dumps-part-17-q321-340\/","title":{"rendered":"LPI 101-500 Practice Test Questions and Exam Dumps Part 17 Q321-340"},"content":{"rendered":"

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

 <\/p>\n

Question: 321. Which command can display the absolute pathname of the current working directory after resolving symbolic links?<\/b><\/p>\n

    \n
  1. <\/b> whereis<\/span>
    \n<\/span>2.<\/b> realpath<\/span>
    \n<\/span>3.<\/b> basename<\/span>
    \n<\/span>4.<\/b> dirname<\/span><\/li>\n<\/ol>\n

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

    Explanation:<\/b><\/p>\n

    The <\/span>realpath<\/span> command resolves a pathname into an absolute pathname and can resolve symbolic links along the path. This is useful when a script or administrator needs to determine the actual filesystem location represented by a pathname rather than simply displaying the pathname supplied by the user. For example, symbolic links may make several different pathnames refer to the same underlying location. <\/span>basename<\/span> extracts the final component of a pathname, while <\/span>dirname<\/span> extracts the directory portion. <\/span>whereis<\/span> searches for related files such as binaries and documentation rather than resolving a pathname.<\/span><\/p>\n

    Question: 322. Which filesystem object provides a pathname reference to another file or directory?<\/b><\/p>\n

      \n
    1. <\/b> Hard link<\/span>
      \n<\/span>2.<\/b> Inode<\/span>
      \n<\/span>3.<\/b> Symbolic link<\/span>
      \n<\/span>4.<\/b> File descriptor<\/span><\/li>\n<\/ol>\n

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

      Explanation:<\/b><\/p>\n

      A symbolic link is a filesystem object containing a pathname that refers to another file or directory. Unlike a hard link, which references the same inode as another directory entry, a symbolic link has its own inode and stores a target pathname. This allows symbolic links to reference directories and, on typical Linux systems, targets located on another filesystem. If the target is moved or removed, the symbolic link can become dangling. Symbolic links are widely used to provide convenient alternate names, compatibility paths, and configurable references to files or directories.<\/span><\/p>\n

      Question: 323. Which file commonly contains information used to define how filesystems are mounted automatically during system startup?<\/b><\/p>\n

        \n
      1. <\/b> \/etc\/fstab<\/span>
        \n<\/span>2.<\/b> \/etc\/mtab<\/span>
        \n<\/span>3.<\/b> \/etc\/mounts<\/span>
        \n<\/span>4.<\/b> \/etc\/filesystems<\/span><\/li>\n<\/ol>\n

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

        Explanation:<\/b><\/p>\n

        The <\/span>\/etc\/fstab<\/span> file contains static filesystem mount configuration. It can specify devices, filesystem types, mount points, and mount options that the operating system can use when mounting filesystems. Entries in this file can also control whether particular filesystems are mounted automatically during boot or when <\/span>mount -a<\/span> is executed. The exact syntax and available options depend on the system and filesystem. <\/span>\/etc\/fstab<\/span> should be edited carefully because incorrect entries can cause mounting failures. It is different from runtime information describing filesystems that are currently mounted.<\/span><\/p>\n

        Question: 324. Which option in <\/b>\/etc\/fstab<\/b> prevents a filesystem from being mounted automatically by <\/b>mount -a<\/b>?<\/b><\/p>\n

          \n
        1. <\/b> ro<\/span>
          \n<\/span>2.<\/b> auto<\/span>
          \n<\/span>3.<\/b> defaults<\/span>
          \n<\/span>4.<\/b> noauto<\/span><\/li>\n<\/ol>\n

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

          Explanation:<\/b><\/p>\n

          The <\/span>noauto<\/span> mount option tells the <\/span>mount<\/span> command not to mount the corresponding filesystem automatically when <\/span>mount -a<\/span> is used. This can be useful for filesystems that should be available only when explicitly requested, such as removable or infrequently used storage. The <\/span>auto<\/span> option has the opposite effect by allowing automatic mounting through mechanisms that honor the option. <\/span>ro<\/span> controls read-only access, while <\/span>defaults<\/span> represents a collection of commonly used default mount options. Understanding these options is important when configuring <\/span>\/etc\/fstab<\/span> safely.<\/span><\/p>\n

          Question: 325. What is the primary purpose of the <\/b>\/var\/run<\/b> path on systems that retain this traditional pathname?<\/b><\/p>\n

            \n
          1. <\/b> Store permanent application databases<\/span>
            \n<\/span>2.<\/b> Provide a location for runtime state information<\/span>
            \n<\/span>3.<\/b> Store bootloader configuration<\/span>
            \n<\/span>4.<\/b> Contain user home directories<\/span><\/li>\n<\/ol>\n

            Correct Answer: 2. Provide a location for runtime state information<\/b><\/p>\n

            Explanation:<\/b><\/p>\n

            \/var\/run<\/span> is a traditional pathname associated with runtime state information created by services and processes. On many modern Linux systems, <\/span>\/var\/run<\/span> is implemented as a symbolic link to <\/span>\/run<\/span>, which is the contemporary location for volatile runtime data. Such information can include process identifiers, sockets, and other state that is needed while the system is running but does not necessarily need to persist across reboots. This differs from <\/span>\/var\/lib<\/span>, which generally stores persistent variable application data. Understanding the relationship between <\/span>\/var\/run<\/span> and <\/span>\/run<\/span> helps when interpreting older documentation.<\/span><\/p>\n

            Question: 326. Which command displays the inode number associated with each listed filesystem entry?<\/b><\/p>\n

              \n
            1. <\/b> ls -i<\/span>
              \n<\/span>2.<\/b> ls -n<\/span>
              \n<\/span>3.<\/b> ls -I<\/span>
              \n<\/span>4.<\/b> ls -d<\/span><\/li>\n<\/ol>\n

              Correct Answer: 1. ls -i<\/b><\/p>\n

              Explanation:<\/b><\/p>\n

              The <\/span>-i<\/span> option of <\/span>ls<\/span> displays the inode number for each filesystem object in the listing. Inode numbers identify filesystem objects within a particular filesystem and are useful when investigating hard links, link counts, and filesystem metadata. Two different filenames can have the same inode number when they are hard links to the same underlying file. The <\/span>-d<\/span> option controls how directory arguments are handled, while <\/span>-n<\/span> changes ownership display to numeric user and group IDs. Therefore, <\/span>ls -i<\/span> is the appropriate option when inode identification is required.<\/span><\/p>\n

              Question: 327. Which <\/b>find<\/b> expression searches for regular files larger than 100 megabytes?<\/b><\/p>\n

                \n
              1. <\/b> find . -large 100M<\/span>
                \n<\/span>2.<\/b> find . -type f -size +100M<\/span>
                \n<\/span>3.<\/b> find . -file +100M<\/span>
                \n<\/span>4.<\/b> find . -size 100M -regular<\/span><\/li>\n<\/ol>\n

                Correct Answer: 2. find . -type f -size +100M<\/b><\/p>\n

                Explanation:<\/b><\/p>\n

                The expression <\/span>find . -type f -size +100M<\/span> combines two tests: <\/span>-type f<\/span> restricts the results to regular files, and <\/span>-size +100M<\/span> searches for files above the specified size threshold. This combination is useful when investigating disk usage because it excludes directories and other filesystem objects. The exact interpretation of size thresholds can depend on the unit syntax supported by the implementation, so administrators should consult the local <\/span>find<\/span> documentation for precise behavior. Combining multiple <\/span>find<\/span> tests is a powerful way to construct targeted filesystem searches.<\/span><\/p>\n

                Question: 328. Which command is commonly used to search a prebuilt filename database rather than scanning directories directly?<\/b><\/p>\n

                  \n
                1. <\/b> find<\/span>
                  \n<\/span>2.<\/b> grep<\/span>
                  \n<\/span>3.<\/b> locate<\/span>
                  \n<\/span>4.<\/b> stat<\/span><\/li>\n<\/ol>\n

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

                  Explanation:<\/b><\/p>\n

                  The <\/span>locate<\/span> command searches a prebuilt database containing filesystem pathnames. Because it searches indexed data rather than normally traversing the filesystem at the time of the query, it can return results very quickly. However, the database may not immediately reflect files that were recently created, moved, or removed. The <\/span>find<\/span> command generally performs a live filesystem search and therefore provides current results but may take longer. <\/span>grep<\/span> searches text content or command output, while <\/span>stat<\/span> displays metadata about specified filesystem objects. The distinction between database-based and live searching is important in Linux administration.<\/span><\/p>\n

                  Question: 329. Which signal is normally associated with stopping a process so that it cannot continue until resumed?<\/b><\/p>\n

                    \n
                  1. <\/b> SIGCONT<\/span>
                    \n<\/span>2.<\/b> SIGSTOP<\/span>
                    \n<\/span>3.<\/b> SIGTERM<\/span>
                    \n<\/span>4.<\/b> SIGCHLD<\/span><\/li>\n<\/ol>\n

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

                    Explanation:<\/b><\/p>\n

                    SIGSTOP<\/span> is a signal that stops a process’s execution. Unlike signals such as <\/span>SIGTERM<\/span>, it is not intended to request graceful termination. A stopped process can later be resumed using <\/span>SIGCONT<\/span>. <\/span>SIGSTOP<\/span> is also notable because the process cannot catch, block, or ignore it. This makes it useful when a process must be forcibly suspended. <\/span>SIGCONT<\/span> resumes a stopped process, <\/span>SIGTERM<\/span> requests termination, and <\/span>SIGCHLD<\/span> is commonly delivered to a parent when a child process changes state. Understanding signal purposes is important when managing Linux processes.<\/span><\/p>\n

                    Question: 330. What happens when a process becomes orphaned on a modern Linux system?<\/b><\/p>\n

                      \n
                    1. <\/b> It is automatically converted into a zombie<\/span>
                      \n<\/span>2.<\/b> It is immediately terminated<\/span>
                      \n<\/span>3.<\/b> It is adopted by an appropriate ancestor process such as PID 1<\/span>
                      \n<\/span>4.<\/b> It becomes a kernel thread<\/span><\/li>\n<\/ol>\n

                      Correct Answer: 3. It is adopted by an appropriate ancestor process such as PID 1<\/b><\/p>\n

                      Explanation:<\/b><\/p>\n

                      An orphan process is a running process whose original parent has terminated. Rather than remaining without a parent, the process is adopted by another suitable ancestor, traditionally PID 1 on many Linux systems. Modern systems using systemd commonly have systemd as PID 1. This adoption allows the process to continue operating while maintaining a valid parent relationship. An orphan is different from a zombie: a zombie has already terminated but remains in the process table until its parent collects its exit status. Understanding parent-child relationships helps explain process lifecycle behavior.<\/span><\/p>\n

                      Question: 331. Which command can display the current shell’s process ID?<\/b><\/p>\n

                        \n
                      1. <\/b> echo $$<\/span>
                        \n<\/span>2.<\/b> echo $PPID<\/span>
                        \n<\/span>3.<\/b> echo $!<\/span>
                        \n<\/span>4.<\/b> echo $?<\/span><\/li>\n<\/ol>\n

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

                        Explanation:<\/b><\/p>\n

                        The shell parameter <\/span>$$<\/span> expands to the process ID of the current shell. Therefore, <\/span>echo $$<\/span> displays the PID associated with that shell process. This is useful in shell scripts when a script needs to identify its own process or construct a temporary filename involving the shell’s PID. <\/span>$PPID<\/span> instead represents the parent process ID, <\/span>$!<\/span> commonly contains the PID of the most recently started background process, and <\/span>$?<\/span> contains the exit status of the most recently completed foreground command. These special parameters provide different types of process and execution information.<\/span><\/p>\n

                        Question: 332. Which shell parameter contains the process ID of the most recently started background command?<\/b><\/p>\n

                          \n
                        1. <\/b> $0<\/span>
                          \n<\/span>2.<\/b> $?<\/span>
                          \n<\/span>3.<\/b> $$<\/span>
                          \n<\/span>4.<\/b> $!<\/span><\/li>\n<\/ol>\n

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

                          Explanation:<\/b><\/p>\n

                          The special shell parameter <\/span>$!<\/span> expands to the process ID of the most recently executed background pipeline or asynchronous command. It is useful when a script needs to save or later wait for a process that was started with <\/span>&<\/span>. For example, a script can launch a background task, store <\/span>$!<\/span>, and then use that process identifier with <\/span>wait<\/span>. This differs from <\/span>$$<\/span>, which identifies the current shell, and <\/span>$?<\/span>, which represents the exit status of the most recently completed foreground command. Correctly distinguishing these parameters is important in shell scripting.<\/span><\/p>\n

                          Question: 333. Which command can show both running processes and their CPU and memory usage interactively?<\/b><\/p>\n

                            \n
                          1. <\/b> top<\/span>
                            \n<\/span>2.<\/b> touch<\/span>
                            \n<\/span>3.<\/b> tee<\/span>
                            \n<\/span>4.<\/b> tr<\/span><\/li>\n<\/ol>\n

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

                            Explanation:<\/b><\/p>\n

                            The <\/span>top<\/span> command provides a continuously updated interactive view of running processes and system resource usage. It commonly displays information such as process IDs, CPU utilization, memory utilization, process ownership, and process state. Administrators can use it to identify processes consuming unusually large amounts of system resources. Unlike commands that provide a static process listing, <\/span>top<\/span> refreshes its display while running, making it useful for observing changing workloads. Other utilities can provide process information, but <\/span>top<\/span> is specifically designed for interactive monitoring of processes and system activity.<\/span><\/p>\n

                            Question: 334. Which command can send a specified signal to a process using its process ID?<\/b><\/p>\n

                              \n
                            1. <\/b> signal<\/span>
                              \n<\/span>2.<\/b> kill<\/span>
                              \n<\/span>3.<\/b> terminate<\/span>
                              \n<\/span>4.<\/b> stop<\/span><\/li>\n<\/ol>\n

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

                              Explanation:<\/b><\/p>\n

                              The <\/span>kill<\/span> command sends a signal to one or more processes identified by process ID. Despite its name, <\/span>kill<\/span> does not always terminate a process because the signal can be selected explicitly. For example, an administrator can send <\/span>SIGTERM<\/span> for a normal termination request or another appropriate signal for a different purpose. A signal can be specified by name or number depending on the command syntax. The command requires appropriate permissions when targeting processes owned by another user. Understanding signals makes <\/span>kill<\/span> a general process-control utility rather than merely a termination command.<\/span><\/p>\n

                              Question: 335. Which shell command lists currently active jobs managed by the interactive shell?<\/b><\/p>\n

                                \n
                              1. <\/b> jobs<\/span>
                                \n<\/span>2.<\/b> tasks<\/span>
                                \n<\/span>3.<\/b> processes<\/span>
                                \n<\/span>4.<\/b> activities<\/span><\/li>\n<\/ol>\n

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

                                Explanation:<\/b><\/p>\n

                                The <\/span>jobs<\/span> shell builtin displays jobs currently managed by the interactive shell’s job-control system. Its output can identify jobs running in the background, stopped jobs, and their job numbers. These job numbers can then be used with commands such as <\/span>fg<\/span> and <\/span>bg<\/span> to manipulate the jobs. The <\/span>jobs<\/span> command is different from process-monitoring tools such as <\/span>ps<\/span>, because it focuses on the shell’s own job table rather than providing a general listing of system processes. Job control is particularly useful when several commands are being run interactively from one terminal.<\/span><\/p>\n

                                Question: 336. Which shell builtin can resume a stopped job in the background?<\/b><\/p>\n

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

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

                                  Explanation:<\/b><\/p>\n

                                  The <\/span>bg<\/span> shell builtin resumes a stopped job and allows it to continue executing in the background. A job can commonly be stopped using terminal job-control mechanisms and then resumed with <\/span>bg<\/span>, allowing the user to continue using the shell prompt. The job can later be brought back to the foreground with <\/span>fg<\/span>. The command works with shell job specifications, such as <\/span>%1<\/span>, when multiple jobs are being managed. This differs from starting a completely new process because <\/span>bg<\/span> operates on an existing shell-managed job.<\/span><\/p>\n

                                  Question: 337. Which command prevents a shell script from continuing after a command fails by enabling immediate exit on a nonzero status?<\/b><\/p>\n

                                    \n
                                  1. <\/b> set -e<\/span>
                                    \n<\/span>2.<\/b> set -f<\/span>
                                    \n<\/span>3.<\/b> set -a<\/span>
                                    \n<\/span>4.<\/b> set -m<\/span><\/li>\n<\/ol>\n

                                    Correct Answer: 1. set -e<\/b><\/p>\n

                                    Explanation:<\/b><\/p>\n

                                    The <\/span>set -e<\/span> shell option enables an error-exit behavior in which the shell exits when a command returns a nonzero status, subject to several shell-specific exceptions and contextual rules. It is often used in scripts to prevent later commands from running after an unexpected failure. However, because the exact behavior of <\/span>set -e<\/span> can be affected by constructs such as conditional commands, pipelines, and command lists, scripts should not assume that every nonzero status always causes immediate termination. Understanding these exceptions is important when writing reliable shell scripts.<\/span><\/p>\n

                                    Question: 338. Which shell builtin can assign a variable whose value is restricted from being changed later in the same shell?<\/b><\/p>\n

                                      \n
                                    1. <\/b> export<\/span>
                                      \n<\/span>2.<\/b> readonly<\/span>
                                      \n<\/span>3.<\/b> declare -x<\/span>
                                      \n<\/span>4.<\/b> protect<\/span><\/li>\n<\/ol>\n

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

                                      Explanation:<\/b><\/p>\n

                                      The <\/span>readonly<\/span> shell builtin marks variables as read-only so that later attempts to assign a different value or unset them are normally rejected by the shell. This can be useful for protecting configuration values or constants used by a script. It is different from <\/span>export<\/span>, which makes a shell variable available to child processes through the environment. Filesystem permissions do not control shell-variable assignment, so <\/span>chmod<\/span> cannot make a shell variable read-only. The exact syntax for creating and inspecting read-only variables can vary slightly between shells, but the underlying concept is broadly supported.<\/span><\/p>\n

                                      Question: 339. Which shell parameter expands to the name used to invoke the shell script?<\/b><\/p>\n

                                        \n
                                      1. <\/b> $0<\/span>
                                        \n<\/span>2.<\/b> $1<\/span>
                                        \n<\/span>3.<\/b> $#<\/span>
                                        \n<\/span>**4. <\/span>$@<\/span><\/li>\n<\/ol>\n

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

                                        Explanation:<\/b><\/p>\n

                                        In a typical shell script, <\/span>$0<\/span> expands to the name or pathname used to invoke the script. It is often used when producing usage messages because it allows a script to refer to itself by the invocation name. <\/span>$1<\/span> represents the first positional argument, <\/span>$#<\/span> contains the number of positional arguments, and <\/span>$@<\/span> expands to the positional arguments themselves. The exact representation of <\/span>$0<\/span> can depend on how the script was invoked, so it should not always be interpreted as a canonical absolute pathname. Nevertheless, it is the standard shell parameter for the script’s invocation name.<\/span><\/p>\n

                                        Question: 340. Which shell syntax allows a function to define a variable that is local to that function in shells supporting the <\/b>local<\/b> builtin?<\/b><\/p>\n

                                          \n
                                        1. <\/b> private variable=value<\/span>
                                          \n<\/span>2.<\/b> local variable=value<\/span>
                                          \n<\/span>3.<\/b> scope variable=value<\/span>
                                          \n<\/span>4.<\/b> internal variable=value<\/span><\/li>\n<\/ol>\n

                                          Correct Answer: 2. local variable=value<\/b><\/p>\n

                                          Explanation:<\/b><\/p>\n

                                          The <\/span>local<\/span> builtin is used by several common shells to create variables whose scope is limited to the current function invocation. For example, <\/span>local result=value<\/span> allows a function to use <\/span>result<\/span> without normally modifying a global variable of the same name. Local variables make larger shell scripts easier to maintain because functions can use temporary variable names without unintentionally changing surrounding shell state. The exact scope rules and availability of <\/span>local<\/span> can vary between shell implementations, so scripts intended for strict POSIX portability should account for those differences.<\/span><\/p>\n

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

                                          View Full LPI 101-500 Exam Dumps and Practice Test Dumps   Question: 321. Which command can display the absolute pathname of the current working directory after resolving symbolic links? whereis 2. realpath 3. basename 4. dirname Correct Answer: 2. realpath Explanation: The realpath command resolves a pathname into an absolute pathname and can resolve symbolic […]<\/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\/18638"}],"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=18638"}],"version-history":[{"count":1,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/18638\/revisions"}],"predecessor-version":[{"id":18639,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/18638\/revisions\/18639"}],"wp:attachment":[{"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/media?parent=18638"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/categories?post=18638"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/tags?post=18638"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}