1 /*
2 * No copyright is claimed. This code is in the public domain; do with
3 * it what you wish.
4 *
5 * Written by Karel Zak <kzak@redhat.com>
6 */
7 #include <sys/types.h>
8 #include <sys/stat.h>
9 #include <sys/file.h>
10 #include <sys/ioctl.h>
11 #include <errno.h>
12 #include <unistd.h>
13 #include <stdint.h>
14
15 #ifdef HAVE_LINUX_FD_H
16 #include <linux/fd.h>
17 #endif
18
19 #ifdef HAVE_LINUX_BLKZONED_H
20 #include <linux/blkzoned.h>
21 #endif
22
23 #ifdef HAVE_SYS_DISKLABEL_H
24 #include <sys/disklabel.h>
25 #endif
26
27 #ifdef HAVE_SYS_DISK_H
28 # include <sys/disk.h>
29 #endif
30
31 #ifndef EBADFD
32 # define EBADFD 77 /* File descriptor in bad state */
33 #endif
34
35 #include "all-io.h"
36 #include "blkdev.h"
37 #include "c.h"
38 #include "linux_version.h"
39 #include "fileutils.h"
40 #include "nls.h"
41
42 static long
43 blkdev_valid_offset (int fd, off_t offset) {
44 char ch;
45
46 if (lseek (fd, offset, 0) < 0)
47 return 0;
48 if (read_all (fd, &ch, 1) < 1)
49 return 0;
50 return 1;
51 }
52
53 int is_blkdev(int fd)
54 {
55 struct stat st;
56 return (fstat(fd, &st) == 0 && S_ISBLK(st.st_mode));
57 }
58
59 off_t
60 blkdev_find_size (int fd) {
61 off_t high, low = 0;
62
63 for (high = 1024; blkdev_valid_offset (fd, high); ) {
64 if (high == SINT_MAX(off_t)) {
65 errno = EFBIG;
66 return -1;
67 }
68
69 low = high;
70
71 if (high >= SINT_MAX(off_t)/2)
72 high = SINT_MAX(off_t);
73 else
74 high *= 2;
75 }
76
77 while (low < high - 1)
78 {
79 off_t mid = (low + high) / 2;
80
81 if (blkdev_valid_offset (fd, mid))
82 low = mid;
83 else
84 high = mid;
85 }
86 blkdev_valid_offset (fd, 0);
87 return (low + 1);
88 }
89
90 /* get size in bytes */
91 int
92 blkdev_get_size(int fd, unsigned long long *bytes)
93 {
94 #ifdef DKIOCGETBLOCKCOUNT
95 /* Apple Darwin */
96 if (ioctl(fd, DKIOCGETBLOCKCOUNT, bytes) >= 0) {
97 *bytes <<= 9;
98 return 0;
99 }
100 #endif
101
102 #ifdef BLKGETSIZE64
103 if (ioctl(fd, BLKGETSIZE64, bytes) >= 0)
104 return 0;
105 #endif
106
107 #ifdef BLKGETSIZE
108 {
109 unsigned long size;
110
111 if (ioctl(fd, BLKGETSIZE, &size) >= 0) {
112 *bytes = ((unsigned long long)size << 9);
113 return 0;
114 }
115 }
116
117 #endif /* BLKGETSIZE */
118
119 #ifdef DIOCGMEDIASIZE
120 /* FreeBSD */
121 if (ioctl(fd, DIOCGMEDIASIZE, bytes) >= 0)
122 return 0;
123 #endif
124
125 #ifdef FDGETPRM
126 {
127 struct floppy_struct this_floppy;
128
129 if (ioctl(fd, FDGETPRM, &this_floppy) >= 0) {
130 *bytes = ((unsigned long long) this_floppy.size) << 9;
131 return 0;
132 }
133 }
134 #endif /* FDGETPRM */
135
136 #if defined(HAVE_SYS_DISKLABEL_H) && defined(DIOCGDINFO)
137 {
138 /*
139 * This code works for FreeBSD 4.11 i386, except for the full device
140 * (such as /dev/ad0). It doesn't work properly for newer FreeBSD
141 * though. FreeBSD >= 5.0 should be covered by the DIOCGMEDIASIZE
142 * above however.
143 *
144 * Note that FreeBSD >= 4.0 has disk devices as unbuffered (raw,
145 * character) devices, so we need to check for S_ISCHR, too.
146 */
147 int part = -1;
148 struct disklabel lab;
149 struct partition *pp;
150 struct stat st;
151
152 if ((fstat(fd, &st) >= 0) &&
153 (S_ISBLK(st.st_mode) || S_ISCHR(st.st_mode)))
154 part = st.st_rdev & 7;
155
156 if (part >= 0 && (ioctl(fd, DIOCGDINFO, (char *)&lab) >= 0)) {
157 pp = &lab.d_partitions[part];
158 if (pp->p_size) {
159 *bytes = pp->p_size << 9;
160 return 0;
161 }
162 }
163 }
164 #endif /* defined(HAVE_SYS_DISKLABEL_H) && defined(DIOCGDINFO) */
165
166 {
167 struct stat st;
168
169 if (fstat(fd, &st) == 0 && S_ISREG(st.st_mode)) {
170 *bytes = st.st_size;
171 return 0;
172 }
173 if (!S_ISBLK(st.st_mode)) {
174 errno = ENOTBLK;
175 return -1;
176 }
177 }
178
179 *bytes = blkdev_find_size(fd);
180 return 0;
181 }
182
183 /* get 512-byte sector count */
184 int
185 blkdev_get_sectors(int fd, unsigned long long *sectors)
186 {
187 unsigned long long bytes;
188
189 if (blkdev_get_size(fd, &bytes) == 0) {
190 *sectors = (bytes >> 9);
191 return 0;
192 }
193
194 return -1;
195 }
196
197 /*
198 * Get logical sector size.
199 *
200 * This is the smallest unit the storage device can
201 * address. It is typically 512 bytes.
202 */
203 #ifdef BLKSSZGET
204 int blkdev_get_sector_size(int fd, int *sector_size)
205 {
206 if (ioctl(fd, BLKSSZGET, sector_size) >= 0)
207 return 0;
208 return -1;
209 }
210 #else
211 int blkdev_get_sector_size(int fd __attribute__((__unused__)), int *sector_size)
212 {
213 *sector_size = DEFAULT_SECTOR_SIZE;
214 return 0;
215 }
216 #endif
217
218 /*
219 * Get physical block device size. The BLKPBSZGET is supported since Linux
220 * 2.6.32. For old kernels is probably the best to assume that physical sector
221 * size is the same as logical sector size.
222 *
223 * Example:
224 *
225 * rc = blkdev_get_physector_size(fd, &physec);
226 * if (rc || physec == 0) {
227 * rc = blkdev_get_sector_size(fd, &physec);
228 * if (rc)
229 * physec = DEFAULT_SECTOR_SIZE;
230 * }
231 */
232 #ifdef BLKPBSZGET
233 int blkdev_get_physector_size(int fd, int *sector_size)
234 {
235 if (ioctl(fd, BLKPBSZGET, sector_size) >= 0)
236 {
237 return 0;
238 }
239 return -1;
240 }
241 #else
242 int blkdev_get_physector_size(int fd __attribute__((__unused__)), int *sector_size)
243 {
244 *sector_size = DEFAULT_SECTOR_SIZE;
245 return 0;
246 }
247 #endif
248
249 /*
250 * Return the alignment status of a device
251 */
252 #ifdef BLKALIGNOFF
253 int blkdev_is_misaligned(int fd)
254 {
255 int aligned;
256
257 if (ioctl(fd, BLKALIGNOFF, &aligned) < 0)
258 return 0; /* probably kernel < 2.6.32 */
259 /*
260 * Note that kernel returns -1 as alignment offset if no compatible
261 * sizes and alignments exist for stacked devices
262 */
263 return aligned != 0 ? 1 : 0;
264 }
265 #else
266 int blkdev_is_misaligned(int fd __attribute__((__unused__)))
267 {
268 return 0;
269 }
270 #endif
271
272 int open_blkdev_or_file(const struct stat *st, const char *name, const int oflag)
273 {
274 int fd;
275
276 if (S_ISBLK(st->st_mode)) {
277 fd = open(name, oflag | O_EXCL);
278 } else
279 fd = open(name, oflag);
280 if (-1 < fd && !is_same_inode(fd, st)) {
281 close(fd);
282 errno = EBADFD;
283 return -1;
284 }
285 if (-1 < fd && S_ISBLK(st->st_mode) && blkdev_is_misaligned(fd))
286 warnx(_("warning: %s is misaligned"), name);
287 return fd;
288 }
289
290 #ifdef CDROM_GET_CAPABILITY
291 int blkdev_is_cdrom(int fd)
292 {
293 int ret;
294
295 if ((ret = ioctl(fd, CDROM_GET_CAPABILITY, NULL)) < 0)
296 return 0;
297
298 return ret;
299 }
300 #else
301 int blkdev_is_cdrom(int fd __attribute__((__unused__)))
302 {
303 return 0;
304 }
305 #endif
306
307 /*
308 * Get kernel's interpretation of the device's geometry.
309 *
310 * Returns the heads and sectors - but not cylinders
311 * as it's truncated for disks with more than 65535 tracks.
312 *
313 * Note that this is deprecated in favor of LBA addressing.
314 */
315 #ifdef HDIO_GETGEO
316 int blkdev_get_geometry(int fd, unsigned int *h, unsigned int *s)
317 {
318 struct hd_geometry geometry;
319
320 if (ioctl(fd, HDIO_GETGEO, &geometry) == 0) {
321 *h = geometry.heads;
322 *s = geometry.sectors;
323 return 0;
324 }
325 #else
326 int blkdev_get_geometry(int fd __attribute__((__unused__)),
327 unsigned int *h, unsigned int *s)
328 {
329 *h = 0;
330 *s = 0;
331 #endif
332 return -1;
333 }
334
335 /*
336 * Convert scsi type to human readable string.
337 */
338 const char *blkdev_scsi_type_to_name(int type)
339 {
340 switch (type) {
341 case SCSI_TYPE_DISK:
342 return "disk";
343 case SCSI_TYPE_TAPE:
344 return "tape";
345 case SCSI_TYPE_PRINTER:
346 return "printer";
347 case SCSI_TYPE_PROCESSOR:
348 return "processor";
349 case SCSI_TYPE_WORM:
350 return "worm";
351 case SCSI_TYPE_ROM:
352 return "rom";
353 case SCSI_TYPE_SCANNER:
354 return "scanner";
355 case SCSI_TYPE_MOD:
356 return "mo-disk";
357 case SCSI_TYPE_MEDIUM_CHANGER:
358 return "changer";
359 case SCSI_TYPE_COMM:
360 return "comm";
361 case SCSI_TYPE_RAID:
362 return "raid";
363 case SCSI_TYPE_ENCLOSURE:
364 return "enclosure";
365 case SCSI_TYPE_RBC:
366 return "rbc";
367 case SCSI_TYPE_OSD:
368 return "osd";
369 case SCSI_TYPE_NO_LUN:
370 return "no-lun";
371 default:
372 break;
373 }
374 return NULL;
375 }
376
377 /* return 0 on success */
378 int blkdev_lock(int fd, const char *devname, const char *lockmode)
379 {
380 int oper, rc, msg = 0;
381
382 if (!lockmode)
383 lockmode = getenv("LOCK_BLOCK_DEVICE");
384 if (!lockmode)
385 return 0;
386
387 if (strcasecmp(lockmode, "yes") == 0 ||
388 strcmp(lockmode, "1") == 0)
389 oper = LOCK_EX;
390
391 else if (strcasecmp(lockmode, "nonblock") == 0)
392 oper = LOCK_EX | LOCK_NB;
393
394 else if (strcasecmp(lockmode, "no") == 0 ||
395 strcmp(lockmode, "0") == 0)
396 return 0;
397 else {
398 warnx(_("unsupported lock mode: %s"), lockmode);
399 return -EINVAL;
400 }
401
402 if (!(oper & LOCK_NB)) {
403 /* Try non-block first to provide message */
404 rc = flock(fd, oper | LOCK_NB);
405 if (rc == 0)
406 return 0;
407 if (rc != 0 && errno == EWOULDBLOCK) {
408 fprintf(stderr, _("%s: %s: device already locked, waiting to get lock ... "),
409 program_invocation_short_name, devname);
410 msg = 1;
411 }
412 }
413 rc = flock(fd, oper);
414 if (rc != 0) {
415 switch (errno) {
416 case EWOULDBLOCK: /* LOCK_NB */
417 warnx(_("%s: device already locked"), devname);
418 break;
419 default:
420 warn(_("%s: failed to get lock"), devname);
421 }
422 } else if (msg)
423 fprintf(stderr, _("OK\n"));
424 return rc;
425 }
426
427 #ifdef HAVE_LINUX_BLKZONED_H
428 struct blk_zone_report *blkdev_get_zonereport(int fd, uint64_t sector, uint32_t nzones)
429 {
430 struct blk_zone_report *rep;
431 size_t rep_size;
432 int ret;
433
434 rep_size = sizeof(struct blk_zone_report) + sizeof(struct blk_zone) * 2;
435 rep = calloc(1, rep_size);
436 if (!rep)
437 return NULL;
438
439 rep->sector = sector;
440 rep->nr_zones = nzones;
441
442 ret = ioctl(fd, BLKREPORTZONE, rep);
443 if (ret || rep->nr_zones != nzones) {
444 free(rep);
445 return NULL;
446 }
447
448 return rep;
449 }
450 #endif
451
452
453 #ifdef TEST_PROGRAM_BLKDEV
454 #include <stdio.h>
455 #include <stdlib.h>
456 #include <fcntl.h>
457 int
458 main(int argc, char **argv)
459 {
460 unsigned long long bytes;
461 unsigned long long sectors;
462 int sector_size, phy_sector_size;
463 int fd;
464
465 if (argc != 2) {
466 fprintf(stderr, "usage: %s device\n", argv[0]);
467 exit(EXIT_FAILURE);
468 }
469
470 if ((fd = open(argv[1], O_RDONLY|O_CLOEXEC)) < 0)
471 err(EXIT_FAILURE, "open %s failed", argv[1]);
472
473 if (blkdev_get_size(fd, &bytes) < 0)
474 err(EXIT_FAILURE, "blkdev_get_size() failed");
475 if (blkdev_get_sectors(fd, §ors) < 0)
476 err(EXIT_FAILURE, "blkdev_get_sectors() failed");
477 if (blkdev_get_sector_size(fd, §or_size) < 0)
478 err(EXIT_FAILURE, "blkdev_get_sector_size() failed");
479 if (blkdev_get_physector_size(fd, &phy_sector_size) < 0)
480 err(EXIT_FAILURE, "blkdev_get_physector_size() failed");
481
482 printf(" bytes: %llu\n", bytes);
483 printf(" sectors: %llu\n", sectors);
484 printf(" sector size: %d\n", sector_size);
485 printf("phy-sector size: %d\n", phy_sector_size);
486
487 return EXIT_SUCCESS;
488 }
489 #endif /* TEST_PROGRAM_BLKDEV */