getsize.c revision 3e554cc116a55c9fffe17f4e819d5f2ecf8ad0af 
1/*
2 * getsize.c --- get the size of a partition.
3 *
4 * Copyright (C) 1995, 1995 Theodore Ts'o.
5 * Copyright (C) 2003 VMware, Inc.
6 *
7 * Windows version of ext2fs_get_device_size by Chris Li, VMware.
8 *
9 * %Begin-Header%
10 * This file may be redistributed under the terms of the GNU Library
11 * General Public License, version 2.
12 * %End-Header%
13 */
14
15#define _LARGEFILE_SOURCE
16#define _LARGEFILE64_SOURCE
17
18#include "config.h"
19#include <stdio.h>
20#if HAVE_UNISTD_H
21#include <unistd.h>
22#endif
23#if HAVE_ERRNO_H
24#include <errno.h>
25#endif
26#include <fcntl.h>
27#ifdef HAVE_SYS_IOCTL_H
28#include <sys/ioctl.h>
29#endif
30#ifdef HAVE_LINUX_FD_H
31#include <linux/fd.h>
32#endif
33#ifdef HAVE_SYS_DISKLABEL_H
34#include <sys/disklabel.h>
35#endif
36#ifdef HAVE_SYS_DISK_H
37#ifdef HAVE_SYS_QUEUE_H
38#include <sys/queue.h> /* for LIST_HEAD */
39#endif
40#include <sys/disk.h>
41#endif
42#ifdef __linux__
43#include <sys/utsname.h>
44#endif
45#if HAVE_SYS_STAT_H
46#include <sys/stat.h>
47#endif
48#include <ctype.h>
49
50#if defined(__linux__) && defined(_IO) && !defined(BLKGETSIZE)
51#define BLKGETSIZE _IO(0x12,96)	/* return device size */
52#endif
53
54#if defined(__linux__) && defined(_IOR) && !defined(BLKGETSIZE64)
55#define BLKGETSIZE64 _IOR(0x12,114,size_t)	/* return device size in bytes (u64 *arg) */
56#endif
57
58#ifdef APPLE_DARWIN
59#define BLKGETSIZE DKIOCGETBLOCKCOUNT32
60#endif /* APPLE_DARWIN */
61
62#include "ext2_fs.h"
63#include "ext2fs.h"
64
65#if defined(__CYGWIN__) || defined (WIN32)
66#include "windows.h"
67#include "winioctl.h"
68
69#if (_WIN32_WINNT >= 0x0500)
70#define HAVE_GET_FILE_SIZE_EX 1
71#endif
72
73errcode_t ext2fs_get_device_size(const char *file, int blocksize,
74				 blk_t *retblocks)
75{
76	HANDLE dev;
77	PARTITION_INFORMATION pi;
78	DISK_GEOMETRY gi;
79	DWORD retbytes;
80#ifdef HAVE_GET_FILE_SIZE_EX
81	LARGE_INTEGER filesize;
82#else
83	DWORD filesize;
84#endif /* HAVE_GET_FILE_SIZE_EX */
85
86	dev = CreateFile(file, GENERIC_READ,
87			 FILE_SHARE_READ | FILE_SHARE_WRITE ,
88                	 NULL,  OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL,  NULL);
89
90	if (dev == INVALID_HANDLE_VALUE)
91		return EBADF;
92	if (DeviceIoControl(dev, IOCTL_DISK_GET_PARTITION_INFO,
93			    &pi, sizeof(PARTITION_INFORMATION),
94			    &pi, sizeof(PARTITION_INFORMATION),
95			    &retbytes, NULL)) {
96
97		*retblocks = pi.PartitionLength.QuadPart / blocksize;
98
99	} else if (DeviceIoControl(dev, IOCTL_DISK_GET_DRIVE_GEOMETRY,
100				&gi, sizeof(DISK_GEOMETRY),
101				&gi, sizeof(DISK_GEOMETRY),
102				&retbytes, NULL)) {
103
104		*retblocks = gi.BytesPerSector *
105			     gi.SectorsPerTrack *
106			     gi.TracksPerCylinder *
107			     gi.Cylinders.QuadPart / blocksize;
108
109#ifdef HAVE_GET_FILE_SIZE_EX
110	} else if (GetFileSizeEx(dev, &filesize)) {
111		*retblocks = filesize.QuadPart / blocksize;
112	}
113#else
114	} else {
115		filesize = GetFileSize(dev, NULL);
116		if (INVALID_FILE_SIZE != filesize) {
117			*retblocks = filesize / blocksize;
118		}
119	}
120#endif /* HAVE_GET_FILE_SIZE_EX */
121
122	CloseHandle(dev);
123	return 0;
124}
125
126#else
127
128static int valid_offset (int fd, ext2_loff_t offset)
129{
130	char ch;
131
132	if (ext2fs_llseek (fd, offset, 0) < 0)
133		return 0;
134	if (read (fd, &ch, 1) < 1)
135		return 0;
136	return 1;
137}
138
139/*
140 * Returns the number of blocks in a partition
141 */
142errcode_t ext2fs_get_device_size2(const char *file, int blocksize,
143				  blk64_t *retblocks)
144{
145	int	fd, rc = 0;
146	unsigned long long size64;
147	ext2_loff_t high, low;
148
149	fd = ext2fs_open_file(file, O_RDONLY, 0);
150	if (fd < 0)
151		return errno;
152
153#ifdef DKIOCGETBLOCKCOUNT	/* For Apple Darwin */
154	if (ioctl(fd, DKIOCGETBLOCKCOUNT, &size64) >= 0) {
155		*retblocks = size64 / (blocksize / 512);
156		goto out;
157	}
158#endif
159
160#ifdef BLKGETSIZE64
161	{
162		int valid_blkgetsize64 = 1;
163#ifdef __linux__
164		struct utsname ut;
165
166		if ((uname(&ut) == 0) &&
167		    ((ut.release[0] == '2') && (ut.release[1] == '.') &&
168		     (ut.release[2] < '6') && (ut.release[3] == '.')))
169			valid_blkgetsize64 = 0;
170#endif
171		if (valid_blkgetsize64 &&
172		    ioctl(fd, BLKGETSIZE64, &size64) >= 0) {
173			*retblocks = size64 / blocksize;
174			goto out;
175		}
176	}
177#endif /* BLKGETSIZE64 */
178
179#ifdef BLKGETSIZE
180	{
181		unsigned long	size;
182
183		if (ioctl(fd, BLKGETSIZE, &size) >= 0) {
184			*retblocks = size / (blocksize / 512);
185			goto out;
186		}
187	}
188#endif
189
190#ifdef FDGETPRM
191	{
192		struct floppy_struct this_floppy;
193
194		if (ioctl(fd, FDGETPRM, &this_floppy) >= 0) {
195			*retblocks = this_floppy.size / (blocksize / 512);
196			goto out;
197		}
198	}
199#endif
200
201#ifdef HAVE_SYS_DISKLABEL_H
202	{
203		int part;
204		struct disklabel lab;
205		struct partition *pp;
206		char ch;
207
208#if defined(DIOCGMEDIASIZE)
209		{
210			off_t ms;
211			u_int bs;
212			if (ioctl(fd, DIOCGMEDIASIZE, &ms) >= 0) {
213				*retblocks = ms / blocksize;
214				goto out;
215			}
216		}
217#elif defined(DIOCGDINFO)
218		/* old disklabel interface */
219		part = strlen(file) - 1;
220		if (part >= 0) {
221			ch = file[part];
222			if (isdigit(ch))
223				part = 0;
224			else if (ch >= 'a' && ch <= 'h')
225				part = ch - 'a';
226			else
227				part = -1;
228		}
229		if (part >= 0 && (ioctl(fd, DIOCGDINFO, (char *)&lab) >= 0)) {
230			pp = &lab.d_partitions[part];
231			if (pp->p_size) {
232				*retblocks = pp->p_size / (blocksize / 512);
233				goto out;
234			}
235		}
236#endif /* defined(DIOCG*) */
237	}
238#endif /* HAVE_SYS_DISKLABEL_H */
239
240	{
241		ext2fs_struct_stat st;
242
243		if (ext2fs_fstat(fd, &st) == 0)
244			if (S_ISREG(st.st_mode)) {
245				*retblocks = st.st_size / blocksize;
246				goto out;
247			}
248	}
249
250	/*
251	 * OK, we couldn't figure it out by using a specialized ioctl,
252	 * which is generally the best way.  So do binary search to
253	 * find the size of the partition.
254	 */
255	low = 0;
256	for (high = 1024; valid_offset(fd, high); high *= 2)
257		low = high;
258	while (low < high - 1) {
259		const ext2_loff_t mid = (low + high) / 2;
260
261		if (valid_offset (fd, mid))
262			low = mid;
263		else
264			high = mid;
265	}
266	valid_offset(fd, 0);
267	size64 = low + 1;
268	*retblocks = size64 / blocksize;
269out:
270	close(fd);
271	return rc;
272}
273
274errcode_t ext2fs_get_device_size(const char *file, int blocksize,
275				 blk_t *retblocks)
276{
277	errcode_t retval;
278	blk64_t	blocks;
279
280	retval = ext2fs_get_device_size2(file, blocksize, &blocks);
281	if (retval)
282		return retval;
283	if (blocks >= (1ULL << 32))
284		return EFBIG;
285	*retblocks = (blk_t) blocks;
286	return 0;
287}
288
289#endif /* WIN32 */
290
291#ifdef DEBUG
292int main(int argc, char **argv)
293{
294	blk_t	blocks;
295	int	retval;
296
297	if (argc < 2) {
298		fprintf(stderr, "Usage: %s device\n", argv[0]);
299		exit(1);
300	}
301
302	retval = ext2fs_get_device_size(argv[1], 1024, &blocks);
303	if (retval) {
304		com_err(argv[0], retval,
305			"while calling ext2fs_get_device_size");
306		exit(1);
307	}
308	printf("Device %s has %u 1k blocks.\n", argv[1], blocks);
309	exit(0);
310}
311#endif
312