← Back to branch summary

~ubuntu-branches/ubuntu/trusty/util-linux/trusty-proposed

« back to all changes in this revision

Viewing changes to libblkid/src/superblocks/gfs.c

  • Committer: Package Import Robot
  • Author(s): LaMont Jones
  • Date: 2011-11-03 15:38:23 UTC
  • mto: (4.5.5 sid) (1.6.4)
  • mto: This revision was merged to the branch mainline in revision 85.
  • Revision ID: package-import@ubuntu.com-20111103153823-10sx16jprzxlhkqf
Import upstream version 2.20.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
libblkid/src/superblocks/gfs.c
 
1
/*
 
2
 * Copyright (C) 2008 Karel Zak <kzak@redhat.com>
 
3
 *
 
4
 * This file may be redistributed under the terms of the
 
5
 * GNU Lesser General Public License.
 
6
 */
 
7
#include <stdio.h>
 
8
#include <stdlib.h>
 
9
#include <unistd.h>
 
10
#include <string.h>
 
11
#include <stdint.h>
 
12
 
 
13
#include "superblocks.h"
 
14
 
 
15
/* Common gfs/gfs2 constants: */
 
16
#define GFS_LOCKNAME_LEN        64
 
17
 
 
18
/* gfs1 constants: */
 
19
#define GFS_FORMAT_FS           1309
 
20
#define GFS_FORMAT_MULTI        1401
 
21
/* gfs2 constants: */
 
22
#define GFS2_FORMAT_FS          1801
 
23
#define GFS2_FORMAT_MULTI       1900
 
24
 
 
25
struct gfs2_meta_header {
 
26
        uint32_t mh_magic;
 
27
        uint32_t mh_type;
 
28
        uint64_t __pad0;          /* Was generation number in gfs1 */
 
29
        uint32_t mh_format;
 
30
        uint32_t __pad1;          /* Was incarnation number in gfs1 */
 
31
};
 
32
 
 
33
struct gfs2_inum {
 
34
        uint64_t no_formal_ino;
 
35
        uint64_t no_addr;
 
36
};
 
37
 
 
38
struct gfs2_sb {
 
39
        struct gfs2_meta_header sb_header;
 
40
 
 
41
        uint32_t sb_fs_format;
 
42
        uint32_t sb_multihost_format;
 
43
        uint32_t  __pad0;  /* Was superblock flags in gfs1 */
 
44
 
 
45
        uint32_t sb_bsize;
 
46
        uint32_t sb_bsize_shift;
 
47
        uint32_t __pad1;   /* Was journal segment size in gfs1 */
 
48
 
 
49
        struct gfs2_inum sb_master_dir; /* Was jindex dinode in gfs1 */
 
50
        struct gfs2_inum __pad2; /* Was rindex dinode in gfs1 */
 
51
        struct gfs2_inum sb_root_dir;
 
52
 
 
53
        char sb_lockproto[GFS_LOCKNAME_LEN];
 
54
        char sb_locktable[GFS_LOCKNAME_LEN];
 
55
 
 
56
        struct gfs2_inum __pad3; /* Was quota inode in gfs1 */
 
57
        struct gfs2_inum __pad4; /* Was licence inode in gfs1 */
 
58
        uint8_t sb_uuid[16]; /* The UUID maybe 0 for backwards compat */
 
59
} __attribute__((packed));
 
60
 
 
61
static int probe_gfs(blkid_probe pr, const struct blkid_idmag *mag)
 
62
{
 
63
        struct gfs2_sb *sbd;
 
64
 
 
65
        sbd = blkid_probe_get_sb(pr, mag, struct gfs2_sb);
 
66
        if (!sbd)
 
67
                return -1;
 
68
 
 
69
        if (be32_to_cpu(sbd->sb_fs_format) == GFS_FORMAT_FS &&
 
70
            be32_to_cpu(sbd->sb_multihost_format) == GFS_FORMAT_MULTI)
 
71
        {
 
72
                if (*sbd->sb_locktable)
 
73
                        blkid_probe_set_label(pr,
 
74
                                (unsigned char *) sbd->sb_locktable,
 
75
                                sizeof(sbd->sb_locktable));
 
76
 
 
77
                blkid_probe_set_uuid(pr, sbd->sb_uuid);
 
78
                return 0;
 
79
        }
 
80
 
 
81
        return -1;
 
82
}
 
83
 
 
84
static int probe_gfs2(blkid_probe pr, const struct blkid_idmag *mag)
 
85
{
 
86
        struct gfs2_sb *sbd;
 
87
 
 
88
        sbd = blkid_probe_get_sb(pr, mag, struct gfs2_sb);
 
89
        if (!sbd)
 
90
                return -1;
 
91
 
 
92
        if (be32_to_cpu(sbd->sb_fs_format) == GFS2_FORMAT_FS &&
 
93
            be32_to_cpu(sbd->sb_multihost_format) == GFS2_FORMAT_MULTI)
 
94
        {
 
95
                if (*sbd->sb_locktable)
 
96
                        blkid_probe_set_label(pr,
 
97
                                (unsigned char *) sbd->sb_locktable,
 
98
                                sizeof(sbd->sb_locktable));
 
99
                blkid_probe_set_uuid(pr, sbd->sb_uuid);
 
100
                blkid_probe_set_version(pr, "1");
 
101
                return 0;
 
102
        }
 
103
        return -1;
 
104
}
 
105
 
 
106
const struct blkid_idinfo gfs_idinfo =
 
107
{
 
108
        .name           = "gfs",
 
109
        .usage          = BLKID_USAGE_FILESYSTEM,
 
110
        .probefunc      = probe_gfs,
 
111
        .minsz          = 32 * 1024 * 1024,     /* minimal size of GFS journal */
 
112
        .magics         =
 
113
        {
 
114
                { .magic = "\x01\x16\x19\x70", .len = 4, .kboff = 64 },
 
115
                { NULL }
 
116
        }
 
117
};
 
118
 
 
119
const struct blkid_idinfo gfs2_idinfo =
 
120
{
 
121
        .name           = "gfs2",
 
122
        .usage          = BLKID_USAGE_FILESYSTEM,
 
123
        .probefunc      = probe_gfs2,
 
124
        .minsz          = 32 * 1024 * 1024,     /* minimal size of GFS journal */
 
125
        .magics         =
 
126
        {
 
127
                { .magic = "\x01\x16\x19\x70", .len = 4, .kboff = 64 },
 
128
                { NULL }
 
129
        }
 
130
};
 
131