Line data    Source code

       1             : #include <stdio.h>
       2             : #include <stdlib.h>
       3             : #include <sysexits.h>
       4             : #include <sys/types.h>
       5             : #include <sys/stat.h>
       6             : #include <errno.h>
       7             : #include <fcntl.h>
       8             : #include <unistd.h>
       9             : #include <ctype.h>
      10             : #include <string.h>
      11             : #include <libintl.h>
      12             : #define _(String) gettext(String)
      13             : #include <libgfs2.h>
      14             : #include <uuid.h>
      15             : #include "tunegfs2.h"
      16             : 
      17           8 : int read_super(struct tunegfs2 *tfs)
      18             : {
      19             :         void *block;
      20             :         int n;
      21           8 :         tfs->sb_start = GFS2_SB_ADDR << GFS2_BASIC_BLOCK_SHIFT;
      22           8 :         block = malloc(sizeof(char) * LGFS2_DEFAULT_BSIZE);
      23           8 :         if (!block) {
      24           0 :                 perror("read_super: malloc");
      25           0 :                 return EX_UNAVAILABLE;
      26             :         }
      27           8 :         n = pread(tfs->fd, block, LGFS2_DEFAULT_BSIZE, tfs->sb_start);
      28           8 :         if (n < 0) {
      29           0 :                 perror("read_super: pread");
      30           0 :                 free(block);
      31           0 :                 return EX_IOERR;
      32             :         }
      33           8 :         tfs->sb = block;
      34           8 :         if (be32_to_cpu(tfs->sb->sb_header.mh_magic) != GFS2_MAGIC) {
      35           2 :                 fprintf(stderr, _("Device does not contain a GFS or GFS2 file system\n"));
      36           2 :                 tfs->sb = NULL;
      37           2 :                 free(block);
      38           2 :                 return EX_IOERR;
      39             :         }
      40             :         /* Ensure that table and proto are NULL terminated */
      41           6 :         tfs->sb->sb_lockproto[GFS2_LOCKNAME_LEN - 1] = '\0';
      42           6 :         tfs->sb->sb_locktable[GFS2_LOCKNAME_LEN - 1] = '\0';
      43           6 :         return 0;
      44             : }
      45             : 
      46           1 : static int is_gfs2(const struct tunegfs2 *tfs)
      47             : {
      48           1 :         return be32_to_cpu(tfs->sb->sb_fs_format) == GFS2_FORMAT_FS;
      49             : }
      50             : 
      51           1 : int print_super(const struct tunegfs2 *tfs)
      52             : {
      53             :         char readable_uuid[36+1];
      54             : 
      55           1 :         uuid_unparse(tfs->sb->sb_uuid, readable_uuid);
      56           1 :         printf(_("File system volume name: %s\n"), tfs->sb->sb_locktable);
      57           1 :         printf(_("File system UUID: %s\n"), readable_uuid);
      58           1 :         printf( _("File system magic number: 0x%X\n"), be32_to_cpu(tfs->sb->sb_header.mh_magic));
      59           1 :         printf(_("File system format version: %"PRIu32"\n"), be32_to_cpu(tfs->sb->sb_fs_format));
      60           1 :         printf(_("Block size: %d\n"), be32_to_cpu(tfs->sb->sb_bsize));
      61           1 :         printf(_("Block shift: %d\n"), be32_to_cpu(tfs->sb->sb_bsize_shift));
      62           1 :         printf(_("Root inode: %"PRIu64"\n"), be64_to_cpu(tfs->sb->sb_root_dir.no_addr));
      63           1 :         if (is_gfs2(tfs))
      64           1 :                 printf(_("Master inode: %"PRIu64"\n"), be64_to_cpu(tfs->sb->sb_master_dir.no_addr));
      65           1 :         printf(_("Lock protocol: %s\n"), tfs->sb->sb_lockproto);
      66           1 :         printf(_("Lock table: %s\n"), tfs->sb->sb_locktable);
      67             : 
      68           1 :         return 0;
      69             : }
      70             : 
      71           2 : int write_super(const struct tunegfs2 *tfs)
      72             : {
      73             :         int n;
      74           2 :         n = pwrite(tfs->fd, tfs->sb, LGFS2_DEFAULT_BSIZE, tfs->sb_start);
      75           2 :         if (n < 0) {
      76           0 :                 perror("write_super: pwrite");
      77           0 :                 return EX_IOERR;
      78             :         }
      79           2 :         return 0;
      80             : }
      81             : 
      82           1 : int change_uuid(struct tunegfs2 *tfs, const char *str)
      83             : {
      84             :         uuid_t uuid;
      85             :         int status;
      86             : 
      87           1 :         status = uuid_parse(str, uuid);
      88           1 :         if (status == 0)
      89           1 :                 uuid_copy(tfs->sb->sb_uuid, uuid);
      90           1 :         return status;
      91             : }
      92             : 
      93           0 : int change_lockproto(struct tunegfs2 *tfs, const char *lockproto)
      94             : {
      95           0 :         int l = strlen(lockproto);
      96             : 
      97           0 :         if (l >= GFS2_LOCKNAME_LEN) {
      98           0 :                 fprintf(stderr, _("Invalid lock protocol: %s\n"), _("too long"));
      99           0 :                 return EX_DATAERR;
     100             :         }
     101             : 
     102           0 :         if (strncmp(lockproto, "lock_dlm", 8) &&
     103           0 :             strncmp(lockproto, "lock_nolock", 11)) {
     104           0 :                 fprintf(stderr, _("Invalid lock protocol: %s\n"), lockproto);
     105           0 :                 return EX_DATAERR;
     106             :         }
     107           0 :         memset(tfs->sb->sb_lockproto, '\0', GFS2_LOCKNAME_LEN);
     108           0 :         memcpy(tfs->sb->sb_lockproto, lockproto, l);
     109           0 :         return 0;
     110             : }
     111             : 
     112           0 : int change_locktable(struct tunegfs2 *tfs, const char *locktable)
     113             : {
     114           0 :         const char *errpre = _("Invalid lock table:");
     115             : 
     116           0 :         if (strlen(locktable) >= GFS2_LOCKNAME_LEN) {
     117           0 :                 fprintf(stderr, "%s %s\n", errpre, _("too long"));
     118           0 :                 return EX_DATAERR;
     119             :         }
     120             : 
     121           0 :         if (strcmp(tfs->sb->sb_lockproto, "lock_dlm") == 0) {
     122           0 :                 char *fsname = strchr(locktable, ':');
     123           0 :                 if (fsname == NULL) {
     124           0 :                         fprintf(stderr, "%s %s\n", errpre, _("missing colon"));
     125           0 :                         return EX_DATAERR;
     126             :                 }
     127           0 :                 if (strlen(++fsname) > 30) {
     128           0 :                         fprintf(stderr, "%s %s\n", errpre, _("file system name is too long"));
     129           0 :                         return EX_DATAERR;
     130             :                 }
     131           0 :                 if (strchr(fsname, ':')) {
     132           0 :                         fprintf(stderr, "%s %s\n", errpre, _("contains more than one colon"));
     133           0 :                         return EX_DATAERR;
     134             :                 }
     135             :         }
     136             : 
     137           0 :         strcpy(tfs->sb->sb_locktable, locktable);
     138           0 :         return 0;
     139             : }
     140             : 
     141           4 : int change_format(struct tunegfs2 *tfs, const char *format)
     142             : {
     143             :         char *end;
     144             :         long ln;
     145             : 
     146           4 :         errno = 0;
     147           4 :         ln = strtol(format, &end, 10);
     148           4 :         if (errno || end == format || !LGFS2_FS_FORMAT_VALID(ln)) {
     149           2 :                 fprintf(stderr, _("Invalid format option '%s'\n"), format);
     150           2 :                 return EX_DATAERR;
     151             :         }
     152           2 :         if (ln < be32_to_cpu(tfs->sb->sb_fs_format)) {
     153           1 :                 fprintf(stderr, _("Regressing the filesystem format is not supported\n"));
     154           1 :                 return EX_DATAERR;
     155             :         }
     156           1 :         tfs->sb->sb_fs_format = cpu_to_be32(ln);
     157           1 :         return 0;
     158             : }