diff options
author | Mike Frysinger <vapier@gentoo.org> | 2006-03-08 07:03:27 +0000 |
---|---|---|
committer | Mike Frysinger <vapier@gentoo.org> | 2006-03-08 07:03:27 +0000 |
commit | 874af85d5eb08b65476f406f6a1e7edc127ac210 (patch) | |
tree | 1cb4ee52f1592350dd9c4471b2a334957cc42b5e /e2fsprogs/blkid | |
parent | 0f2dd9f4eb9007bf44aa3f0cf30a35c36fbbd5b2 (diff) | |
download | busybox-w32-874af85d5eb08b65476f406f6a1e7edc127ac210.tar.gz busybox-w32-874af85d5eb08b65476f406f6a1e7edc127ac210.tar.bz2 busybox-w32-874af85d5eb08b65476f406f6a1e7edc127ac210.zip |
import most of e2fsprogs 1.38 updates
Diffstat (limited to 'e2fsprogs/blkid')
-rw-r--r-- | e2fsprogs/blkid/blkid.h | 6 | ||||
-rw-r--r-- | e2fsprogs/blkid/blkidP.h | 61 | ||||
-rw-r--r-- | e2fsprogs/blkid/cache.c | 2 | ||||
-rw-r--r-- | e2fsprogs/blkid/dev.c | 99 | ||||
-rw-r--r-- | e2fsprogs/blkid/devno.c | 4 | ||||
-rw-r--r-- | e2fsprogs/blkid/probe.c | 29 | ||||
-rw-r--r-- | e2fsprogs/blkid/probe.h | 31 | ||||
-rw-r--r-- | e2fsprogs/blkid/read.c | 33 | ||||
-rw-r--r-- | e2fsprogs/blkid/tag.c | 101 |
9 files changed, 286 insertions, 80 deletions
diff --git a/e2fsprogs/blkid/blkid.h b/e2fsprogs/blkid/blkid.h index 3bb0e78d8..c051b2b85 100644 --- a/e2fsprogs/blkid/blkid.h +++ b/e2fsprogs/blkid/blkid.h | |||
@@ -55,6 +55,8 @@ extern int blkid_get_cache(blkid_cache *cache, const char *filename); | |||
55 | extern const char *blkid_dev_devname(blkid_dev dev); | 55 | extern const char *blkid_dev_devname(blkid_dev dev); |
56 | 56 | ||
57 | extern blkid_dev_iterate blkid_dev_iterate_begin(blkid_cache cache); | 57 | extern blkid_dev_iterate blkid_dev_iterate_begin(blkid_cache cache); |
58 | extern int blkid_dev_set_search(blkid_dev_iterate iter, | ||
59 | char *search_type, char *search_value); | ||
58 | extern int blkid_dev_next(blkid_dev_iterate iterate, blkid_dev *dev); | 60 | extern int blkid_dev_next(blkid_dev_iterate iterate, blkid_dev *dev); |
59 | extern void blkid_dev_iterate_end(blkid_dev_iterate iterate); | 61 | extern void blkid_dev_iterate_end(blkid_dev_iterate iterate); |
60 | 62 | ||
@@ -63,6 +65,7 @@ extern char *blkid_devno_to_devname(dev_t devno); | |||
63 | 65 | ||
64 | /* devname.c */ | 66 | /* devname.c */ |
65 | extern int blkid_probe_all(blkid_cache cache); | 67 | extern int blkid_probe_all(blkid_cache cache); |
68 | extern int blkid_probe_all_new(blkid_cache cache); | ||
66 | extern blkid_dev blkid_get_dev(blkid_cache cache, const char *devname, | 69 | extern blkid_dev blkid_get_dev(blkid_cache cache, const char *devname, |
67 | int flags); | 70 | int flags); |
68 | 71 | ||
@@ -86,7 +89,8 @@ extern blkid_tag_iterate blkid_tag_iterate_begin(blkid_dev dev); | |||
86 | extern int blkid_tag_next(blkid_tag_iterate iterate, | 89 | extern int blkid_tag_next(blkid_tag_iterate iterate, |
87 | const char **type, const char **value); | 90 | const char **type, const char **value); |
88 | extern void blkid_tag_iterate_end(blkid_tag_iterate iterate); | 91 | extern void blkid_tag_iterate_end(blkid_tag_iterate iterate); |
89 | 92 | extern int blkid_dev_has_tag(blkid_dev dev, const char *type, | |
93 | const char *value); | ||
90 | extern blkid_dev blkid_find_dev_with_tag(blkid_cache cache, | 94 | extern blkid_dev blkid_find_dev_with_tag(blkid_cache cache, |
91 | const char *type, | 95 | const char *type, |
92 | const char *value); | 96 | const char *value); |
diff --git a/e2fsprogs/blkid/blkidP.h b/e2fsprogs/blkid/blkidP.h index 759dfcd87..4ae9763d2 100644 --- a/e2fsprogs/blkid/blkidP.h +++ b/e2fsprogs/blkid/blkidP.h | |||
@@ -147,65 +147,8 @@ extern int blkid_debug_mask; | |||
147 | #endif | 147 | #endif |
148 | 148 | ||
149 | #ifdef CONFIG_BLKID_DEBUG | 149 | #ifdef CONFIG_BLKID_DEBUG |
150 | static inline void DEB_DUMP_TAG(int mask, blkid_tag tag) | 150 | extern void blkid_debug_dump_dev(blkid_dev dev); |
151 | { | 151 | extern void blkid_debug_dump_tag(blkid_tag tag); |
152 | if (!(mask & blkid_debug_mask)) | ||
153 | return; | ||
154 | |||
155 | if (!tag) { | ||
156 | printf(" tag: NULL\n"); | ||
157 | return; | ||
158 | } | ||
159 | |||
160 | printf(" tag: %s=\"%s\"\n", tag->bit_name, tag->bit_val); | ||
161 | } | ||
162 | |||
163 | static inline void DEB_DUMP_DEV(int mask, blkid_dev dev) | ||
164 | { | ||
165 | struct list_head *p; | ||
166 | |||
167 | if (!(mask & blkid_debug_mask)) | ||
168 | return; | ||
169 | |||
170 | if (!dev) { | ||
171 | printf(" dev: NULL\n"); | ||
172 | return; | ||
173 | } | ||
174 | |||
175 | printf(" dev: name = %s\n", dev->bid_name); | ||
176 | printf(" dev: DEVNO=\"0x%0Lx\"\n", dev->bid_devno); | ||
177 | printf(" dev: TIME=\"%lu\"\n", dev->bid_time); | ||
178 | printf(" dev: PRI=\"%d\"\n", dev->bid_pri); | ||
179 | printf(" dev: flags = 0x%08X\n", dev->bid_flags); | ||
180 | |||
181 | list_for_each(p, &dev->bid_tags) { | ||
182 | blkid_tag tag = list_entry(p, struct blkid_struct_tag, bit_tags); | ||
183 | DEB_DUMP_TAG(mask, tag); | ||
184 | } | ||
185 | printf("\n"); | ||
186 | } | ||
187 | |||
188 | static inline void DEB_DUMP_CACHE(int mask, blkid_cache cache) | ||
189 | { | ||
190 | struct list_head *p; | ||
191 | |||
192 | if (!cache || !(mask & blkid_debug_mask)) { | ||
193 | printf("cache: NULL\n"); | ||
194 | return; | ||
195 | } | ||
196 | |||
197 | printf("cache: time = %lu\n", cache->bic_time); | ||
198 | printf("cache: flags = 0x%08X\n", cache->bic_flags); | ||
199 | |||
200 | list_for_each(p, &cache->bic_devs) { | ||
201 | blkid_dev dev = list_entry(p, struct blkid_struct_dev, bid_devs); | ||
202 | DEB_DUMP_DEV(mask, dev); | ||
203 | } | ||
204 | } | ||
205 | #else | ||
206 | #define DEB_DUMP_TAG(mask, tag) do {} while (0) | ||
207 | #define DEB_DUMP_DEV(mask, dev) do {} while (0) | ||
208 | #define DEB_DUMP_CACHE(mask, cache) do {} while (0) | ||
209 | #endif | 152 | #endif |
210 | 153 | ||
211 | /* lseek.c */ | 154 | /* lseek.c */ |
diff --git a/e2fsprogs/blkid/cache.c b/e2fsprogs/blkid/cache.c index daccb30b3..9c9b8c7e4 100644 --- a/e2fsprogs/blkid/cache.c +++ b/e2fsprogs/blkid/cache.c | |||
@@ -63,7 +63,7 @@ void blkid_put_cache(blkid_cache cache) | |||
63 | 63 | ||
64 | DBG(DEBUG_CACHE, printf("freeing cache struct\n")); | 64 | DBG(DEBUG_CACHE, printf("freeing cache struct\n")); |
65 | 65 | ||
66 | /* DEB_DUMP_CACHE(cache); */ | 66 | /* DBG(DEBUG_CACHE, blkid_debug_dump_cache(cache)); */ |
67 | 67 | ||
68 | while (!list_empty(&cache->bic_devs)) { | 68 | while (!list_empty(&cache->bic_devs)) { |
69 | blkid_dev dev = list_entry(cache->bic_devs.next, | 69 | blkid_dev dev = list_entry(cache->bic_devs.next, |
diff --git a/e2fsprogs/blkid/dev.c b/e2fsprogs/blkid/dev.c index 04cf8b5fa..5d56c5096 100644 --- a/e2fsprogs/blkid/dev.c +++ b/e2fsprogs/blkid/dev.c | |||
@@ -35,7 +35,7 @@ void blkid_free_dev(blkid_dev dev) | |||
35 | 35 | ||
36 | DBG(DEBUG_DEV, | 36 | DBG(DEBUG_DEV, |
37 | printf(" freeing dev %s (%s)\n", dev->bid_name, dev->bid_type)); | 37 | printf(" freeing dev %s (%s)\n", dev->bid_name, dev->bid_type)); |
38 | DEB_DUMP_DEV(DEBUG_DEV, dev); | 38 | DBG(DEBUG_DEV, blkid_debug_dump_dev(dev)); |
39 | 39 | ||
40 | list_del(&dev->bid_devs); | 40 | list_del(&dev->bid_devs); |
41 | while (!list_empty(&dev->bid_tags)) { | 41 | while (!list_empty(&dev->bid_tags)) { |
@@ -57,6 +57,34 @@ const char *blkid_dev_devname(blkid_dev dev) | |||
57 | return dev->bid_name; | 57 | return dev->bid_name; |
58 | } | 58 | } |
59 | 59 | ||
60 | #ifdef CONFIG_BLKID_DEBUG | ||
61 | void blkid_debug_dump_dev(blkid_dev dev) | ||
62 | { | ||
63 | struct list_head *p; | ||
64 | |||
65 | if (!dev) { | ||
66 | printf(" dev: NULL\n"); | ||
67 | return; | ||
68 | } | ||
69 | |||
70 | printf(" dev: name = %s\n", dev->bid_name); | ||
71 | printf(" dev: DEVNO=\"0x%0llx\"\n", dev->bid_devno); | ||
72 | printf(" dev: TIME=\"%lu\"\n", dev->bid_time); | ||
73 | printf(" dev: PRI=\"%d\"\n", dev->bid_pri); | ||
74 | printf(" dev: flags = 0x%08X\n", dev->bid_flags); | ||
75 | |||
76 | list_for_each(p, &dev->bid_tags) { | ||
77 | blkid_tag tag = list_entry(p, struct blkid_struct_tag, bit_tags); | ||
78 | if (tag) | ||
79 | printf(" tag: %s=\"%s\"\n", tag->bit_name, | ||
80 | tag->bit_val); | ||
81 | else | ||
82 | printf(" tag: NULL\n"); | ||
83 | } | ||
84 | printf("\n"); | ||
85 | } | ||
86 | #endif | ||
87 | |||
60 | /* | 88 | /* |
61 | * dev iteration routines for the public libblkid interface. | 89 | * dev iteration routines for the public libblkid interface. |
62 | * | 90 | * |
@@ -114,3 +142,72 @@ void blkid_dev_iterate_end(blkid_dev_iterate iter) | |||
114 | free(iter); | 142 | free(iter); |
115 | } | 143 | } |
116 | 144 | ||
145 | #ifdef TEST_PROGRAM | ||
146 | #ifdef HAVE_GETOPT_H | ||
147 | #include <getopt.h> | ||
148 | #else | ||
149 | extern char *optarg; | ||
150 | extern int optind; | ||
151 | #endif | ||
152 | |||
153 | void usage(char *prog) | ||
154 | { | ||
155 | fprintf(stderr, "Usage: %s [-f blkid_file] [-m debug_mask]\n", prog); | ||
156 | fprintf(stderr, "\tList all devices and exit\n", prog); | ||
157 | exit(1); | ||
158 | } | ||
159 | |||
160 | int main(int argc, char **argv) | ||
161 | { | ||
162 | blkid_dev_iterate iter; | ||
163 | blkid_cache cache = NULL; | ||
164 | blkid_dev dev; | ||
165 | int c, ret; | ||
166 | char *tmp; | ||
167 | char *file = NULL; | ||
168 | char *search_type = NULL; | ||
169 | char *search_value = NULL; | ||
170 | |||
171 | while ((c = getopt (argc, argv, "m:f:")) != EOF) | ||
172 | switch (c) { | ||
173 | case 'f': | ||
174 | file = optarg; | ||
175 | break; | ||
176 | case 'm': | ||
177 | blkid_debug_mask = strtoul (optarg, &tmp, 0); | ||
178 | if (*tmp) { | ||
179 | fprintf(stderr, "Invalid debug mask: %d\n", | ||
180 | optarg); | ||
181 | exit(1); | ||
182 | } | ||
183 | break; | ||
184 | case '?': | ||
185 | usage(argv[0]); | ||
186 | } | ||
187 | if (argc >= optind+2) { | ||
188 | search_type = argv[optind]; | ||
189 | search_value = argv[optind+1]; | ||
190 | optind += 2; | ||
191 | } | ||
192 | if (argc != optind) | ||
193 | usage(argv[0]); | ||
194 | |||
195 | if ((ret = blkid_get_cache(&cache, file)) != 0) { | ||
196 | fprintf(stderr, "%s: error creating cache (%d)\n", | ||
197 | argv[0], ret); | ||
198 | exit(1); | ||
199 | } | ||
200 | |||
201 | iter = blkid_dev_iterate_begin(cache); | ||
202 | if (search_type) | ||
203 | blkid_dev_set_search(iter, search_type, search_value); | ||
204 | while (blkid_dev_next(iter, &dev) == 0) { | ||
205 | printf("Device: %s\n", blkid_dev_devname(dev)); | ||
206 | } | ||
207 | blkid_dev_iterate_end(iter); | ||
208 | |||
209 | |||
210 | blkid_put_cache(cache); | ||
211 | return (0); | ||
212 | } | ||
213 | #endif | ||
diff --git a/e2fsprogs/blkid/devno.c b/e2fsprogs/blkid/devno.c index 2979280f7..89119945c 100644 --- a/e2fsprogs/blkid/devno.c +++ b/e2fsprogs/blkid/devno.c | |||
@@ -117,7 +117,7 @@ static void scan_dir(char *dir_name, dev_t devno, struct dir_list **list, | |||
117 | else if (S_ISBLK(st.st_mode) && st.st_rdev == devno) { | 117 | else if (S_ISBLK(st.st_mode) && st.st_rdev == devno) { |
118 | *devname = blkid_strdup(path); | 118 | *devname = blkid_strdup(path); |
119 | DBG(DEBUG_DEVNO, | 119 | DBG(DEBUG_DEVNO, |
120 | printf("found 0x%Lx at %s (%p)\n", devno, | 120 | printf("found 0x%llx at %s (%p)\n", devno, |
121 | path, *devname)); | 121 | path, *devname)); |
122 | break; | 122 | break; |
123 | } | 123 | } |
@@ -175,7 +175,7 @@ char *blkid_devno_to_devname(dev_t devno) | |||
175 | (unsigned long) devno)); | 175 | (unsigned long) devno)); |
176 | } else { | 176 | } else { |
177 | DBG(DEBUG_DEVNO, | 177 | DBG(DEBUG_DEVNO, |
178 | printf("found devno 0x%04Lx as %s\n", devno, devname)); | 178 | printf("found devno 0x%04llx as %s\n", devno, devname)); |
179 | } | 179 | } |
180 | 180 | ||
181 | 181 | ||
diff --git a/e2fsprogs/blkid/probe.c b/e2fsprogs/blkid/probe.c index 36f7177b8..5ee8a200e 100644 --- a/e2fsprogs/blkid/probe.c +++ b/e2fsprogs/blkid/probe.c | |||
@@ -98,7 +98,8 @@ static void get_ext2_info(blkid_dev dev, unsigned char *buf) | |||
98 | static int probe_ext3(int fd __BLKID_ATTR((unused)), | 98 | static int probe_ext3(int fd __BLKID_ATTR((unused)), |
99 | blkid_cache cache __BLKID_ATTR((unused)), | 99 | blkid_cache cache __BLKID_ATTR((unused)), |
100 | blkid_dev dev, | 100 | blkid_dev dev, |
101 | const struct blkid_magic *id, unsigned char *buf) | 101 | struct blkid_magic *id __BLKID_ATTR((unused)), |
102 | unsigned char *buf) | ||
102 | { | 103 | { |
103 | struct ext2_super_block *es; | 104 | struct ext2_super_block *es; |
104 | 105 | ||
@@ -124,10 +125,10 @@ static int probe_ext3(int fd __BLKID_ATTR((unused)), | |||
124 | static int probe_ext2(int fd __BLKID_ATTR((unused)), | 125 | static int probe_ext2(int fd __BLKID_ATTR((unused)), |
125 | blkid_cache cache __BLKID_ATTR((unused)), | 126 | blkid_cache cache __BLKID_ATTR((unused)), |
126 | blkid_dev dev, | 127 | blkid_dev dev, |
127 | const struct blkid_magic *id, unsigned char *buf) | 128 | struct blkid_magic *id __BLKID_ATTR((unused)), |
129 | unsigned char *buf) | ||
128 | { | 130 | { |
129 | struct ext2_super_block *es; | 131 | struct ext2_super_block *es; |
130 | // const char *sec_type = 0, *label = 0; | ||
131 | 132 | ||
132 | es = (struct ext2_super_block *)buf; | 133 | es = (struct ext2_super_block *)buf; |
133 | 134 | ||
@@ -303,6 +304,23 @@ static int probe_romfs(int fd __BLKID_ATTR((unused)), | |||
303 | return 0; | 304 | return 0; |
304 | } | 305 | } |
305 | 306 | ||
307 | static int probe_cramfs(int fd __BLKID_ATTR((unused)), | ||
308 | blkid_cache cache __BLKID_ATTR((unused)), | ||
309 | blkid_dev dev, | ||
310 | struct blkid_magic *id __BLKID_ATTR((unused)), | ||
311 | unsigned char *buf) | ||
312 | { | ||
313 | struct cramfs_super_block *csb; | ||
314 | const char *label = 0; | ||
315 | |||
316 | csb = (struct cramfs_super_block *)buf; | ||
317 | |||
318 | if (strlen((char *) csb->name)) | ||
319 | label = (char *) csb->name; | ||
320 | blkid_set_tag(dev, "LABEL", label, 0); | ||
321 | return 0; | ||
322 | } | ||
323 | |||
306 | static int probe_swap0(int fd __BLKID_ATTR((unused)), | 324 | static int probe_swap0(int fd __BLKID_ATTR((unused)), |
307 | blkid_cache cache __BLKID_ATTR((unused)), | 325 | blkid_cache cache __BLKID_ATTR((unused)), |
308 | blkid_dev dev, | 326 | blkid_dev dev, |
@@ -321,7 +339,6 @@ static int probe_swap1(int fd, | |||
321 | unsigned char *buf __BLKID_ATTR((unused))) | 339 | unsigned char *buf __BLKID_ATTR((unused))) |
322 | { | 340 | { |
323 | struct swap_id_block *sws; | 341 | struct swap_id_block *sws; |
324 | // const char *label = 0; | ||
325 | 342 | ||
326 | probe_swap0(fd, cache, dev, id, buf); | 343 | probe_swap0(fd, cache, dev, id, buf); |
327 | /* | 344 | /* |
@@ -489,7 +506,7 @@ static const struct blkid_magic type_array[] = { | |||
489 | { "xfs", 0, 0, 4, "XFSB", probe_xfs }, | 506 | { "xfs", 0, 0, 4, "XFSB", probe_xfs }, |
490 | { "romfs", 0, 0, 8, "-rom1fs-", probe_romfs }, | 507 | { "romfs", 0, 0, 8, "-rom1fs-", probe_romfs }, |
491 | { "bfs", 0, 0, 4, "\316\372\173\033", 0 }, | 508 | { "bfs", 0, 0, 4, "\316\372\173\033", 0 }, |
492 | { "cramfs", 0, 0, 4, "E=\315\034", 0 }, | 509 | { "cramfs", 0, 0, 4, "E=\315\050", probe_cramfs }, |
493 | { "qnx4", 0, 4, 6, "QNX4FS", 0 }, | 510 | { "qnx4", 0, 4, 6, "QNX4FS", 0 }, |
494 | { "udf", 32, 1, 5, "BEA01", probe_udf }, | 511 | { "udf", 32, 1, 5, "BEA01", probe_udf }, |
495 | { "udf", 32, 1, 5, "BOOT2", probe_udf }, | 512 | { "udf", 32, 1, 5, "BOOT2", probe_udf }, |
@@ -647,7 +664,7 @@ found_type: | |||
647 | 664 | ||
648 | blkid_set_tag(dev, "TYPE", type, 0); | 665 | blkid_set_tag(dev, "TYPE", type, 0); |
649 | 666 | ||
650 | DBG(DEBUG_PROBE, printf("%s: devno 0x%04Lx, type %s\n", | 667 | DBG(DEBUG_PROBE, printf("%s: devno 0x%04llx, type %s\n", |
651 | dev->bid_name, st.st_rdev, type)); | 668 | dev->bid_name, st.st_rdev, type)); |
652 | } | 669 | } |
653 | 670 | ||
diff --git a/e2fsprogs/blkid/probe.h b/e2fsprogs/blkid/probe.h index 530b8efe2..134913f59 100644 --- a/e2fsprogs/blkid/probe.h +++ b/e2fsprogs/blkid/probe.h | |||
@@ -108,13 +108,28 @@ struct romfs_super_block { | |||
108 | unsigned char ros_volume[16]; | 108 | unsigned char ros_volume[16]; |
109 | }; | 109 | }; |
110 | 110 | ||
111 | struct cramfs_super_block { | ||
112 | __u8 magic[4]; | ||
113 | __u32 size; | ||
114 | __u32 flags; | ||
115 | __u32 future; | ||
116 | __u8 signature[16]; | ||
117 | struct cramfs_info { | ||
118 | __u32 crc; | ||
119 | __u32 edition; | ||
120 | __u32 blocks; | ||
121 | __u32 files; | ||
122 | } info; | ||
123 | __u8 name[16]; | ||
124 | }; | ||
125 | |||
111 | struct swap_id_block { | 126 | struct swap_id_block { |
112 | /* unsigned char sws_boot[1024]; */ | 127 | /* unsigned char sws_boot[1024]; */ |
113 | __u32 sws_version; | 128 | __u32 sws_version; |
114 | __u32 sws_lastpage; | 129 | __u32 sws_lastpage; |
115 | __u32 sws_nrbad; | 130 | __u32 sws_nrbad; |
116 | unsigned char sws_uuid[16]; | 131 | unsigned char sws_uuid[16]; |
117 | unsigned char sws_volume[16]; | 132 | char sws_volume[16]; |
118 | unsigned char sws_pad[117]; | 133 | unsigned char sws_pad[117]; |
119 | __u32 sws_badpg; | 134 | __u32 sws_badpg; |
120 | }; | 135 | }; |
@@ -216,22 +231,22 @@ struct ocfs_volume_header { | |||
216 | unsigned char minor_version[4]; | 231 | unsigned char minor_version[4]; |
217 | unsigned char major_version[4]; | 232 | unsigned char major_version[4]; |
218 | unsigned char signature[128]; | 233 | unsigned char signature[128]; |
219 | unsigned char mount[128]; | 234 | char mount[128]; |
220 | unsigned char mount_len[2]; | 235 | unsigned char mount_len[2]; |
221 | }; | 236 | }; |
222 | 237 | ||
223 | struct ocfs_volume_label { | 238 | struct ocfs_volume_label { |
224 | unsigned char disk_lock[48]; | 239 | unsigned char disk_lock[48]; |
225 | unsigned char label[64]; | 240 | char label[64]; |
226 | unsigned char label_len[2]; | 241 | unsigned char label_len[2]; |
227 | unsigned char vol_id[16]; | 242 | unsigned char vol_id[16]; |
228 | unsigned char vol_id_len[2]; | 243 | unsigned char vol_id_len[2]; |
229 | }; | 244 | }; |
230 | 245 | ||
231 | #define ocfsmajor(o) ((__u32)o.major_version[0] \ | 246 | #define ocfsmajor(o) ((__u32)o.major_version[0] \ |
232 | + (((__u32) o.major_version[1]) << 8) \ | 247 | + (((__u32) o.major_version[1]) << 8) \ |
233 | + (((__u32) o.major_version[2]) << 16) \ | 248 | + (((__u32) o.major_version[2]) << 16) \ |
234 | + (((__u32) o.major_version[3]) << 24)) | 249 | + (((__u32) o.major_version[3]) << 24)) |
235 | #define ocfslabellen(o) ((__u32)o.label_len[0] + (((__u32) o.label_len[1]) << 8)) | 250 | #define ocfslabellen(o) ((__u32)o.label_len[0] + (((__u32) o.label_len[1]) << 8)) |
236 | #define ocfsmountlen(o) ((__u32)o.mount_len[0] + (((__u32) o.mount_len[1])<<8)) | 251 | #define ocfsmountlen(o) ((__u32)o.mount_len[0] + (((__u32) o.mount_len[1])<<8)) |
237 | 252 | ||
@@ -241,7 +256,7 @@ struct ocfs2_super_block { | |||
241 | unsigned char signature[8]; | 256 | unsigned char signature[8]; |
242 | unsigned char s_dummy1[184]; | 257 | unsigned char s_dummy1[184]; |
243 | unsigned char s_dummy2[80]; | 258 | unsigned char s_dummy2[80]; |
244 | unsigned char s_label[64]; | 259 | char s_label[64]; |
245 | unsigned char s_uuid[16]; | 260 | unsigned char s_uuid[16]; |
246 | }; | 261 | }; |
247 | 262 | ||
diff --git a/e2fsprogs/blkid/read.c b/e2fsprogs/blkid/read.c index 08a3162f3..5f7422b0c 100644 --- a/e2fsprogs/blkid/read.c +++ b/e2fsprogs/blkid/read.c | |||
@@ -33,6 +33,11 @@ | |||
33 | 33 | ||
34 | #include <stdlib.h> | 34 | #include <stdlib.h> |
35 | 35 | ||
36 | #ifdef TEST_PROGRAM | ||
37 | #define blkid_debug_dump_dev(dev) (debug_dump_dev(dev)) | ||
38 | static void debug_dump_dev(blkid_dev dev); | ||
39 | #endif | ||
40 | |||
36 | /* | 41 | /* |
37 | * File format: | 42 | * File format: |
38 | * | 43 | * |
@@ -355,7 +360,7 @@ static int blkid_parse_line(blkid_cache cache, blkid_dev *dev_p, char *cp) | |||
355 | blkid_free_dev(dev); | 360 | blkid_free_dev(dev); |
356 | } | 361 | } |
357 | 362 | ||
358 | DEB_DUMP_DEV(DEBUG_READ, dev); | 363 | DBG(DEBUG_READ, blkid_debug_dump_dev(dev)); |
359 | 364 | ||
360 | return ret; | 365 | return ret; |
361 | } | 366 | } |
@@ -433,6 +438,32 @@ errout: | |||
433 | } | 438 | } |
434 | 439 | ||
435 | #ifdef TEST_PROGRAM | 440 | #ifdef TEST_PROGRAM |
441 | static void debug_dump_dev(blkid_dev dev) | ||
442 | { | ||
443 | struct list_head *p; | ||
444 | |||
445 | if (!dev) { | ||
446 | printf(" dev: NULL\n"); | ||
447 | return; | ||
448 | } | ||
449 | |||
450 | printf(" dev: name = %s\n", dev->bid_name); | ||
451 | printf(" dev: DEVNO=\"0x%0llx\"\n", dev->bid_devno); | ||
452 | printf(" dev: TIME=\"%lu\"\n", dev->bid_time); | ||
453 | printf(" dev: PRI=\"%d\"\n", dev->bid_pri); | ||
454 | printf(" dev: flags = 0x%08X\n", dev->bid_flags); | ||
455 | |||
456 | list_for_each(p, &dev->bid_tags) { | ||
457 | blkid_tag tag = list_entry(p, struct blkid_struct_tag, bit_tags); | ||
458 | if (tag) | ||
459 | printf(" tag: %s=\"%s\"\n", tag->bit_name, | ||
460 | tag->bit_val); | ||
461 | else | ||
462 | printf(" tag: NULL\n"); | ||
463 | } | ||
464 | printf("\n"); | ||
465 | } | ||
466 | |||
436 | int main(int argc, char**argv) | 467 | int main(int argc, char**argv) |
437 | { | 468 | { |
438 | blkid_cache cache = NULL; | 469 | blkid_cache cache = NULL; |
diff --git a/e2fsprogs/blkid/tag.c b/e2fsprogs/blkid/tag.c index 51615d4a5..61642464d 100644 --- a/e2fsprogs/blkid/tag.c +++ b/e2fsprogs/blkid/tag.c | |||
@@ -29,6 +29,18 @@ static blkid_tag blkid_new_tag(void) | |||
29 | return tag; | 29 | return tag; |
30 | } | 30 | } |
31 | 31 | ||
32 | #ifdef CONFIG_BLKID_DEBUG | ||
33 | void blkid_debug_dump_tag(blkid_tag tag) | ||
34 | { | ||
35 | if (!tag) { | ||
36 | printf(" tag: NULL\n"); | ||
37 | return; | ||
38 | } | ||
39 | |||
40 | printf(" tag: %s=\"%s\"\n", tag->bit_name, tag->bit_val); | ||
41 | } | ||
42 | #endif | ||
43 | |||
32 | void blkid_free_tag(blkid_tag tag) | 44 | void blkid_free_tag(blkid_tag tag) |
33 | { | 45 | { |
34 | if (!tag) | 46 | if (!tag) |
@@ -36,7 +48,7 @@ void blkid_free_tag(blkid_tag tag) | |||
36 | 48 | ||
37 | DBG(DEBUG_TAG, printf(" freeing tag %s=%s\n", tag->bit_name, | 49 | DBG(DEBUG_TAG, printf(" freeing tag %s=%s\n", tag->bit_name, |
38 | tag->bit_val ? tag->bit_val : "(NULL)")); | 50 | tag->bit_val ? tag->bit_val : "(NULL)")); |
39 | DEB_DUMP_TAG(DEBUG_TAG, tag); | 51 | DBG(DEBUG_TAG, blkid_debug_dump_tag(tag)); |
40 | 52 | ||
41 | list_del(&tag->bit_tags); /* list of tags for this device */ | 53 | list_del(&tag->bit_tags); /* list of tags for this device */ |
42 | list_del(&tag->bit_names); /* list of tags with this type */ | 54 | list_del(&tag->bit_names); /* list of tags with this type */ |
@@ -330,3 +342,90 @@ try_again: | |||
330 | } | 342 | } |
331 | return dev; | 343 | return dev; |
332 | } | 344 | } |
345 | |||
346 | #ifdef TEST_PROGRAM | ||
347 | #ifdef HAVE_GETOPT_H | ||
348 | #include <getopt.h> | ||
349 | #else | ||
350 | extern char *optarg; | ||
351 | extern int optind; | ||
352 | #endif | ||
353 | |||
354 | void usage(char *prog) | ||
355 | { | ||
356 | fprintf(stderr, "Usage: %s [-f blkid_file] [-m debug_mask] device " | ||
357 | "[type value]\n", | ||
358 | prog); | ||
359 | fprintf(stderr, "\tList all tags for a device and exit\n", prog); | ||
360 | exit(1); | ||
361 | } | ||
362 | |||
363 | int main(int argc, char **argv) | ||
364 | { | ||
365 | blkid_tag_iterate iter; | ||
366 | blkid_cache cache = NULL; | ||
367 | blkid_dev dev; | ||
368 | int c, ret, found; | ||
369 | int flags = BLKID_DEV_FIND; | ||
370 | char *tmp; | ||
371 | char *file = NULL; | ||
372 | char *devname = NULL; | ||
373 | char *search_type = NULL; | ||
374 | char *search_value = NULL; | ||
375 | const char *type, *value; | ||
376 | |||
377 | while ((c = getopt (argc, argv, "m:f:")) != EOF) | ||
378 | switch (c) { | ||
379 | case 'f': | ||
380 | file = optarg; | ||
381 | break; | ||
382 | case 'm': | ||
383 | blkid_debug_mask = strtoul (optarg, &tmp, 0); | ||
384 | if (*tmp) { | ||
385 | fprintf(stderr, "Invalid debug mask: %d\n", | ||
386 | optarg); | ||
387 | exit(1); | ||
388 | } | ||
389 | break; | ||
390 | case '?': | ||
391 | usage(argv[0]); | ||
392 | } | ||
393 | if (argc > optind) | ||
394 | devname = argv[optind++]; | ||
395 | if (argc > optind) | ||
396 | search_type = argv[optind++]; | ||
397 | if (argc > optind) | ||
398 | search_value = argv[optind++]; | ||
399 | if (!devname || (argc != optind)) | ||
400 | usage(argv[0]); | ||
401 | |||
402 | if ((ret = blkid_get_cache(&cache, file)) != 0) { | ||
403 | fprintf(stderr, "%s: error creating cache (%d)\n", | ||
404 | argv[0], ret); | ||
405 | exit(1); | ||
406 | } | ||
407 | |||
408 | dev = blkid_get_dev(cache, devname, flags); | ||
409 | if (!dev) { | ||
410 | fprintf(stderr, "%s: Can not find device in blkid cache\n"); | ||
411 | exit(1); | ||
412 | } | ||
413 | if (search_type) { | ||
414 | found = blkid_dev_has_tag(dev, search_type, search_value); | ||
415 | printf("Device %s: (%s, %s) %s\n", blkid_dev_devname(dev), | ||
416 | search_type, search_value ? search_value : "NULL", | ||
417 | found ? "FOUND" : "NOT FOUND"); | ||
418 | return(!found); | ||
419 | } | ||
420 | printf("Device %s...\n", blkid_dev_devname(dev)); | ||
421 | |||
422 | iter = blkid_tag_iterate_begin(dev); | ||
423 | while (blkid_tag_next(iter, &type, &value) == 0) { | ||
424 | printf("\tTag %s has value %s\n", type, value); | ||
425 | } | ||
426 | blkid_tag_iterate_end(iter); | ||
427 | |||
428 | blkid_put_cache(cache); | ||
429 | return (0); | ||
430 | } | ||
431 | #endif | ||