Branch data     Line data    Source code

       1                 :            : /***
       2                 :            :   SPDX-License-Identifier: LGPL-2.1+
       3                 :            : ***/
       4                 :            : 
       5                 :            : #include <fcntl.h>
       6                 :            : #include <signal.h>
       7                 :            : #include <sys/prctl.h>
       8                 :            : #include <sys/stat.h>
       9                 :            : #include <sys/types.h>
      10                 :            : #include <unistd.h>
      11                 :            : 
      12                 :            : #include "alloc-util.h"
      13                 :            : #include "dissect-image.h"
      14                 :            : #include "main-func.h"
      15                 :            : #include "process-util.h"
      16                 :            : #include "signal-util.h"
      17                 :            : #include "string-util.h"
      18                 :            : 
      19                 :          0 : static int makefs(const char *type, const char *device) {
      20                 :            :         const char *mkfs;
      21                 :            :         pid_t pid;
      22                 :            :         int r;
      23                 :            : 
      24         [ #  # ]:          0 :         if (streq(type, "swap"))
      25                 :          0 :                 mkfs = "/sbin/mkswap";
      26                 :            :         else
      27   [ #  #  #  #  :          0 :                 mkfs = strjoina("/sbin/mkfs.", type);
          #  #  #  #  #  
                #  #  # ]
      28         [ #  # ]:          0 :         if (access(mkfs, X_OK) != 0)
      29         [ #  # ]:          0 :                 return log_error_errno(errno, "%s is not executable: %m", mkfs);
      30                 :            : 
      31                 :          0 :         r = safe_fork("(mkfs)", FORK_RESET_SIGNALS|FORK_DEATHSIG|FORK_RLIMIT_NOFILE_SAFE|FORK_LOG, &pid);
      32         [ #  # ]:          0 :         if (r < 0)
      33                 :          0 :                 return r;
      34         [ #  # ]:          0 :         if (r == 0) {
      35                 :          0 :                 const char *cmdline[3] = { mkfs, device, NULL };
      36                 :            : 
      37                 :            :                 /* Child */
      38                 :            : 
      39                 :          0 :                 execv(cmdline[0], (char**) cmdline);
      40                 :          0 :                 _exit(EXIT_FAILURE);
      41                 :            :         }
      42                 :            : 
      43                 :          0 :         return wait_for_terminate_and_check(mkfs, pid, WAIT_LOG);
      44                 :            : }
      45                 :            : 
      46                 :          0 : static int run(int argc, char *argv[]) {
      47                 :            :         const char *device, *type;
      48                 :          0 :         _cleanup_free_ char *detected = NULL;
      49                 :            :         struct stat st;
      50                 :            :         int r;
      51                 :            : 
      52                 :          0 :         log_setup_service();
      53                 :            : 
      54         [ #  # ]:          0 :         if (argc != 3)
      55         [ #  # ]:          0 :                 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
      56                 :            :                                        "This program expects two arguments.");
      57                 :            : 
      58                 :          0 :         type = argv[1];
      59                 :          0 :         device = argv[2];
      60                 :            : 
      61         [ #  # ]:          0 :         if (stat(device, &st) < 0)
      62         [ #  # ]:          0 :                 return log_error_errno(errno, "Failed to stat \"%s\": %m", device);
      63                 :            : 
      64         [ #  # ]:          0 :         if (!S_ISBLK(st.st_mode))
      65         [ #  # ]:          0 :                 log_info("%s is not a block device.", device);
      66                 :            : 
      67                 :          0 :         r = probe_filesystem(device, &detected);
      68         [ #  # ]:          0 :         if (r < 0)
      69   [ #  #  #  # ]:          0 :                 return log_warning_errno(r,
      70                 :            :                                          r == -EUCLEAN ?
      71                 :            :                                          "Cannot reliably determine probe \"%s\", refusing to proceed." :
      72                 :            :                                          "Failed to probe \"%s\": %m",
      73                 :            :                                          device);
      74                 :            : 
      75         [ #  # ]:          0 :         if (detected) {
      76         [ #  # ]:          0 :                 log_info("%s is not empty (type %s), exiting", device, detected);
      77                 :          0 :                 return 0;
      78                 :            :         }
      79                 :            : 
      80                 :          0 :         return makefs(type, device);
      81                 :            : }
      82                 :            : 
      83                 :          0 : DEFINE_MAIN_FUNCTION(run);