1 /* $NetBSD: device.c,v 1.1.1.2 2009/12/02 00:26:34 haad Exp $ */
2
3 /*
4 * Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.
5 * Copyright (C) 2004-2007 Red Hat, Inc. All rights reserved.
6 *
7 * This file is part of LVM2.
8 *
9 * This copyrighted material is made available to anyone wishing to use,
10 * modify, copy, or redistribute it subject to the terms and conditions
11 * of the GNU Lesser General Public License v.2.1.
12 *
13 * You should have received a copy of the GNU Lesser General Public License
14 * along with this program; if not, write to the Free Software Foundation,
15 * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16 */
17
18 #include <libgen.h> /* dirname, basename */
19 #include "lib.h"
20 #include "lvm-types.h"
21 #include "device.h"
22 #include "metadata.h"
23 #include "filter.h"
24 #include "xlate.h"
25
26 /* See linux/genhd.h and fs/partitions/msdos */
27
28 #define PART_MAGIC 0xAA55
29 #define PART_MAGIC_OFFSET UINT64_C(0x1FE)
30 #define PART_OFFSET UINT64_C(0x1BE)
31
32 struct partition {
33 uint8_t boot_ind;
34 uint8_t head;
35 uint8_t sector;
36 uint8_t cyl;
37 uint8_t sys_ind; /* partition type */
38 uint8_t end_head;
39 uint8_t end_sector;
40 uint8_t end_cyl;
41 uint32_t start_sect;
42 uint32_t nr_sects;
43 } __attribute__((packed));
44
_is_partitionable(struct device * dev)45 static int _is_partitionable(struct device *dev)
46 {
47 int parts = max_partitions(MAJOR(dev->dev));
48
49 /* All MD devices are partitionable via blkext (as of 2.6.28) */
50 if (MAJOR(dev->dev) == md_major())
51 return 1;
52
53 if ((parts <= 1) || (MINOR(dev->dev) % parts))
54 return 0;
55
56 return 1;
57 }
58
_has_partition_table(struct device * dev)59 static int _has_partition_table(struct device *dev)
60 {
61 int ret = 0;
62 unsigned p;
63 uint16_t buf[SECTOR_SIZE/sizeof(uint16_t)];
64 uint16_t *part_magic;
65 struct partition *part;
66
67 if (!dev_open(dev)) {
68 stack;
69 return -1;
70 }
71
72 if (!dev_read(dev, UINT64_C(0), sizeof(buf), &buf))
73 goto_out;
74
75 /* FIXME Check for other types of partition table too */
76
77 /* Check for msdos partition table */
78 part_magic = buf + PART_MAGIC_OFFSET/sizeof(buf[0]);
79 if ((*part_magic == xlate16(PART_MAGIC))) {
80 part = (struct partition *) (buf + PART_OFFSET/sizeof(buf[0]));
81 for (p = 0; p < 4; p++, part++) {
82 /* Table is invalid if boot indicator not 0 or 0x80 */
83 if ((part->boot_ind & 0x7f)) {
84 ret = 0;
85 break;
86 }
87 /* Must have at least one non-empty partition */
88 if (part->nr_sects)
89 ret = 1;
90 }
91 }
92
93 out:
94 if (!dev_close(dev))
95 stack;
96
97 return ret;
98 }
99
is_partitioned_dev(struct device * dev)100 int is_partitioned_dev(struct device *dev)
101 {
102 if (!_is_partitionable(dev))
103 return 0;
104
105 return _has_partition_table(dev);
106 }
107
108 #if 0
109 #include <sys/stat.h>
110 #include <sys/mman.h>
111 #include <stdio.h>
112 #include <unistd.h>
113 #include <fcntl.h>
114 #include <ctype.h>
115
116 #include <errno.h>
117 #include <sys/ioctl.h>
118 #include <linux/fs.h>
119 #include <linux/major.h>
120 #include <linux/genhd.h>
121
122 int _get_partition_type(struct dev_filter *filter, struct device *d);
123
124 #define MINOR_PART(dev) (MINOR((dev)->dev) % max_partitions(MINOR((dev)->dev)))
125
126 int is_extended_partition(struct device *d)
127 {
128 return (MINOR_PART(d) > 4) ? 1 : 0;
129 }
130
131 struct device *dev_primary(struct dev_mgr *dm, struct device *d)
132 {
133 struct device *ret;
134
135 ret = dev_by_dev(dm, d->dev - MINOR_PART(dm, d));
136 /* FIXME: Needs replacing with a 'refresh' */
137 if (!ret) {
138 init_dev_scan(dm);
139 ret = dev_by_dev(dm, d->dev - MINOR_PART(dm, d));
140 }
141
142 return ret;
143
144 }
145
146 int partition_type_is_lvm(struct dev_mgr *dm, struct device *d)
147 {
148 int pt;
149
150 pt = _get_partition_type(dm, d);
151
152 if (!pt) {
153 if (is_whole_disk(dm, d))
154 /* FIXME: Overloaded pt=0 in error cases */
155 return 1;
156 else {
157 log_error
158 ("%s: missing partition table "
159 "on partitioned device", d->name);
160 return 0;
161 }
162 }
163
164 if (is_whole_disk(dm, d)) {
165 log_error("%s: looks to possess partition table", d->name);
166 return 0;
167 }
168
169 /* check part type */
170 if (pt != LVM_PARTITION && pt != LVM_NEW_PARTITION) {
171 log_error("%s: invalid partition type 0x%x "
172 "(must be 0x%x)", d->name, pt, LVM_NEW_PARTITION);
173 return 0;
174 }
175
176 if (pt == LVM_PARTITION) {
177 log_error
178 ("%s: old LVM partition type found - please change to 0x%x",
179 d->name, LVM_NEW_PARTITION);
180 return 0;
181 }
182
183 return 1;
184 }
185
186 int _get_partition_type(struct dev_mgr *dm, struct device *d)
187 {
188 int pv_handle = -1;
189 struct device *primary;
190 ssize_t read_ret;
191 ssize_t bytes_read = 0;
192 char *buffer;
193 unsigned short *s_buffer;
194 struct partition *part;
195 loff_t offset = 0;
196 loff_t extended_offset = 0;
197 int part_sought;
198 int part_found = 0;
199 int first_partition = 1;
200 int extended_partition = 0;
201 int p;
202
203 if (!(primary = dev_primary(dm, d))) {
204 log_error
205 ("Failed to find main device containing partition %s",
206 d->name);
207 return 0;
208 }
209
210 if (!(buffer = dm_malloc(SECTOR_SIZE))) {
211 log_error("Failed to allocate partition table buffer");
212 return 0;
213 }
214
215 /* Get partition table */
216 if ((pv_handle = open(primary->name, O_RDONLY)) < 0) {
217 log_error("%s: open failed: %s", primary->name,
218 strerror(errno));
219 return 0;
220 }
221
222 s_buffer = (unsigned short *) buffer;
223 part = (struct partition *) (buffer + 0x1be);
224 part_sought = MINOR_PART(dm, d);
225
226 do {
227 bytes_read = 0;
228
229 if (llseek(pv_handle, offset * SECTOR_SIZE, SEEK_SET) == -1) {
230 log_error("%s: llseek failed: %s",
231 primary->name, strerror(errno));
232 return 0;
233 }
234
235 while ((bytes_read < SECTOR_SIZE) &&
236 (read_ret =
237 read(pv_handle, buffer + bytes_read,
238 SECTOR_SIZE - bytes_read)) != -1)
239 bytes_read += read_ret;
240
241 if (read_ret == -1) {
242 log_error("%s: read failed: %s", primary->name,
243 strerror(errno));
244 return 0;
245 }
246
247 if (s_buffer[255] == 0xAA55) {
248 if (is_whole_disk(dm, d))
249 return -1;
250 } else
251 return 0;
252
253 extended_partition = 0;
254
255 /* Loop through primary partitions */
256 for (p = 0; p < 4; p++) {
257 if (part[p].sys_ind == DOS_EXTENDED_PARTITION ||
258 part[p].sys_ind == LINUX_EXTENDED_PARTITION
259 || part[p].sys_ind == WIN98_EXTENDED_PARTITION) {
260 extended_partition = 1;
261 offset = extended_offset + part[p].start_sect;
262 if (extended_offset == 0)
263 extended_offset = part[p].start_sect;
264 if (first_partition == 1)
265 part_found++;
266 } else if (first_partition == 1) {
267 if (p == part_sought) {
268 if (part[p].sys_ind == 0) {
269 /* missing primary? */
270 return 0;
271 }
272 } else
273 part_found++;
274 } else if (!part[p].sys_ind)
275 part_found++;
276
277 if (part_sought == part_found)
278 return part[p].sys_ind;
279
280 }
281 first_partition = 0;
282 }
283 while (extended_partition == 1);
284
285 return 0;
286 }
287 #endif
288
289 #ifdef linux
290
get_primary_dev(const char * sysfs_dir,struct device * dev,dev_t * result)291 int get_primary_dev(const char *sysfs_dir,
292 struct device *dev, dev_t *result)
293 {
294 char path[PATH_MAX+1];
295 char temp_path[PATH_MAX+1];
296 char buffer[64];
297 struct stat info;
298 FILE *fp;
299 uint32_t pri_maj, pri_min;
300 int ret = 0;
301
302 /* check if dev is a partition */
303 if (dm_snprintf(path, PATH_MAX, "%s/dev/block/%d:%d/partition",
304 sysfs_dir, (int)MAJOR(dev->dev), (int)MINOR(dev->dev)) < 0) {
305 log_error("dm_snprintf partition failed");
306 return ret;
307 }
308
309 if (stat(path, &info) == -1) {
310 if (errno != ENOENT)
311 log_sys_error("stat", path);
312 return ret;
313 }
314
315 /*
316 * extract parent's path from the partition's symlink, e.g.:
317 * - readlink /sys/dev/block/259:0 = ../../block/md0/md0p1
318 * - dirname ../../block/md0/md0p1 = ../../block/md0
319 * - basename ../../block/md0/md0 = md0
320 * Parent's 'dev' sysfs attribute = /sys/block/md0/dev
321 */
322 if (readlink(dirname(path), temp_path, PATH_MAX) < 0) {
323 log_sys_error("readlink", path);
324 return ret;
325 }
326
327 if (dm_snprintf(path, PATH_MAX, "%s/block/%s/dev",
328 sysfs_dir, basename(dirname(temp_path))) < 0) {
329 log_error("dm_snprintf dev failed");
330 return ret;
331 }
332
333 /* finally, parse 'dev' attribute and create corresponding dev_t */
334 if (stat(path, &info) == -1) {
335 if (errno == ENOENT)
336 log_error("sysfs file %s does not exist", path);
337 else
338 log_sys_error("stat", path);
339 return ret;
340 }
341
342 fp = fopen(path, "r");
343 if (!fp) {
344 log_sys_error("fopen", path);
345 return ret;
346 }
347
348 if (!fgets(buffer, sizeof(buffer), fp)) {
349 log_sys_error("fgets", path);
350 goto out;
351 }
352
353 if (sscanf(buffer, "%d:%d", &pri_maj, &pri_min) != 2) {
354 log_error("sysfs file %s not in expected MAJ:MIN format: %s",
355 path, buffer);
356 goto out;
357 }
358 *result = MKDEV(pri_maj, pri_min);
359 ret = 1;
360
361 out:
362 if (fclose(fp))
363 log_sys_error("fclose", path);
364
365 return ret;
366 }
367
_dev_topology_attribute(const char * attribute,const char * sysfs_dir,struct device * dev)368 static unsigned long _dev_topology_attribute(const char *attribute,
369 const char *sysfs_dir,
370 struct device *dev)
371 {
372 const char *sysfs_fmt_str = "%s/dev/block/%d:%d/%s";
373 char path[PATH_MAX+1], buffer[64];
374 FILE *fp;
375 struct stat info;
376 dev_t uninitialized_var(primary);
377 unsigned long result = 0UL;
378
379 if (!attribute || !*attribute)
380 return_0;
381
382 if (!sysfs_dir || !*sysfs_dir)
383 return_0;
384
385 if (dm_snprintf(path, PATH_MAX, sysfs_fmt_str, sysfs_dir,
386 (int)MAJOR(dev->dev), (int)MINOR(dev->dev),
387 attribute) < 0) {
388 log_error("dm_snprintf %s failed", attribute);
389 return 0;
390 }
391
392 /*
393 * check if the desired sysfs attribute exists
394 * - if not: either the kernel doesn't have topology support
395 * or the device could be a partition
396 */
397 if (stat(path, &info) == -1) {
398 if (errno != ENOENT) {
399 log_sys_error("stat", path);
400 return 0;
401 }
402 if (!get_primary_dev(sysfs_dir, dev, &primary))
403 return 0;
404
405 /* get attribute from partition's primary device */
406 if (dm_snprintf(path, PATH_MAX, sysfs_fmt_str, sysfs_dir,
407 (int)MAJOR(primary), (int)MINOR(primary),
408 attribute) < 0) {
409 log_error("primary dm_snprintf %s failed", attribute);
410 return 0;
411 }
412 if (stat(path, &info) == -1) {
413 if (errno != ENOENT)
414 log_sys_error("stat", path);
415 return 0;
416 }
417 }
418
419 if (!(fp = fopen(path, "r"))) {
420 log_sys_error("fopen", path);
421 return 0;
422 }
423
424 if (!fgets(buffer, sizeof(buffer), fp)) {
425 log_sys_error("fgets", path);
426 goto out;
427 }
428
429 if (sscanf(buffer, "%lu", &result) != 1) {
430 log_error("sysfs file %s not in expected format: %s", path,
431 buffer);
432 goto out;
433 }
434
435 log_very_verbose("Device %s %s is %lu bytes.",
436 dev_name(dev), attribute, result);
437
438 out:
439 if (fclose(fp))
440 log_sys_error("fclose", path);
441
442 return result >> SECTOR_SHIFT;
443 }
444
dev_alignment_offset(const char * sysfs_dir,struct device * dev)445 unsigned long dev_alignment_offset(const char *sysfs_dir,
446 struct device *dev)
447 {
448 return _dev_topology_attribute("alignment_offset",
449 sysfs_dir, dev);
450 }
451
dev_minimum_io_size(const char * sysfs_dir,struct device * dev)452 unsigned long dev_minimum_io_size(const char *sysfs_dir,
453 struct device *dev)
454 {
455 return _dev_topology_attribute("queue/minimum_io_size",
456 sysfs_dir, dev);
457 }
458
dev_optimal_io_size(const char * sysfs_dir,struct device * dev)459 unsigned long dev_optimal_io_size(const char *sysfs_dir,
460 struct device *dev)
461 {
462 return _dev_topology_attribute("queue/optimal_io_size",
463 sysfs_dir, dev);
464 }
465
466 #else
467
get_primary_dev(const char * sysfs_dir,struct device * dev,dev_t * result)468 int get_primary_dev(const char *sysfs_dir,
469 struct device *dev, dev_t *result)
470 {
471 return 0;
472 }
473
dev_alignment_offset(const char * sysfs_dir,struct device * dev)474 unsigned long dev_alignment_offset(const char *sysfs_dir,
475 struct device *dev)
476 {
477 return 0UL;
478 }
479
dev_minimum_io_size(const char * sysfs_dir,struct device * dev)480 unsigned long dev_minimum_io_size(const char *sysfs_dir,
481 struct device *dev)
482 {
483 return 0UL;
484 }
485
dev_optimal_io_size(const char * sysfs_dir,struct device * dev)486 unsigned long dev_optimal_io_size(const char *sysfs_dir,
487 struct device *dev)
488 {
489 return 0UL;
490 }
491
492 #endif
493