Root/
1 | #include <linux/capability.h> |
2 | #include <linux/blkdev.h> |
3 | #include <linux/export.h> |
4 | #include <linux/gfp.h> |
5 | #include <linux/blkpg.h> |
6 | #include <linux/hdreg.h> |
7 | #include <linux/backing-dev.h> |
8 | #include <linux/fs.h> |
9 | #include <linux/blktrace_api.h> |
10 | #include <asm/uaccess.h> |
11 | |
12 | static int blkpg_ioctl(struct block_device *bdev, struct blkpg_ioctl_arg __user *arg) |
13 | { |
14 | struct block_device *bdevp; |
15 | struct gendisk *disk; |
16 | struct hd_struct *part; |
17 | struct blkpg_ioctl_arg a; |
18 | struct blkpg_partition p; |
19 | struct disk_part_iter piter; |
20 | long long start, length; |
21 | int partno; |
22 | |
23 | if (!capable(CAP_SYS_ADMIN)) |
24 | return -EACCES; |
25 | if (copy_from_user(&a, arg, sizeof(struct blkpg_ioctl_arg))) |
26 | return -EFAULT; |
27 | if (copy_from_user(&p, a.data, sizeof(struct blkpg_partition))) |
28 | return -EFAULT; |
29 | disk = bdev->bd_disk; |
30 | if (bdev != bdev->bd_contains) |
31 | return -EINVAL; |
32 | partno = p.pno; |
33 | if (partno <= 0) |
34 | return -EINVAL; |
35 | switch (a.op) { |
36 | case BLKPG_ADD_PARTITION: |
37 | start = p.start >> 9; |
38 | length = p.length >> 9; |
39 | /* check for fit in a hd_struct */ |
40 | if (sizeof(sector_t) == sizeof(long) && |
41 | sizeof(long long) > sizeof(long)) { |
42 | long pstart = start, plength = length; |
43 | if (pstart != start || plength != length |
44 | || pstart < 0 || plength < 0) |
45 | return -EINVAL; |
46 | } |
47 | |
48 | mutex_lock(&bdev->bd_mutex); |
49 | |
50 | /* overlap? */ |
51 | disk_part_iter_init(&piter, disk, |
52 | DISK_PITER_INCL_EMPTY); |
53 | while ((part = disk_part_iter_next(&piter))) { |
54 | if (!(start + length <= part->start_sect || |
55 | start >= part->start_sect + part->nr_sects)) { |
56 | disk_part_iter_exit(&piter); |
57 | mutex_unlock(&bdev->bd_mutex); |
58 | return -EBUSY; |
59 | } |
60 | } |
61 | disk_part_iter_exit(&piter); |
62 | |
63 | /* all seems OK */ |
64 | part = add_partition(disk, partno, start, length, |
65 | ADDPART_FLAG_NONE, NULL); |
66 | mutex_unlock(&bdev->bd_mutex); |
67 | return IS_ERR(part) ? PTR_ERR(part) : 0; |
68 | case BLKPG_DEL_PARTITION: |
69 | part = disk_get_part(disk, partno); |
70 | if (!part) |
71 | return -ENXIO; |
72 | |
73 | bdevp = bdget(part_devt(part)); |
74 | disk_put_part(part); |
75 | if (!bdevp) |
76 | return -ENOMEM; |
77 | |
78 | mutex_lock(&bdevp->bd_mutex); |
79 | if (bdevp->bd_openers) { |
80 | mutex_unlock(&bdevp->bd_mutex); |
81 | bdput(bdevp); |
82 | return -EBUSY; |
83 | } |
84 | /* all seems OK */ |
85 | fsync_bdev(bdevp); |
86 | invalidate_bdev(bdevp); |
87 | |
88 | mutex_lock_nested(&bdev->bd_mutex, 1); |
89 | delete_partition(disk, partno); |
90 | mutex_unlock(&bdev->bd_mutex); |
91 | mutex_unlock(&bdevp->bd_mutex); |
92 | bdput(bdevp); |
93 | |
94 | return 0; |
95 | default: |
96 | return -EINVAL; |
97 | } |
98 | } |
99 | |
100 | static int blkdev_reread_part(struct block_device *bdev) |
101 | { |
102 | struct gendisk *disk = bdev->bd_disk; |
103 | int res; |
104 | |
105 | if (!disk_part_scan_enabled(disk) || bdev != bdev->bd_contains) |
106 | return -EINVAL; |
107 | if (!capable(CAP_SYS_ADMIN)) |
108 | return -EACCES; |
109 | if (!mutex_trylock(&bdev->bd_mutex)) |
110 | return -EBUSY; |
111 | res = rescan_partitions(disk, bdev); |
112 | mutex_unlock(&bdev->bd_mutex); |
113 | return res; |
114 | } |
115 | |
116 | static int blk_ioctl_discard(struct block_device *bdev, uint64_t start, |
117 | uint64_t len, int secure) |
118 | { |
119 | unsigned long flags = 0; |
120 | |
121 | if (start & 511) |
122 | return -EINVAL; |
123 | if (len & 511) |
124 | return -EINVAL; |
125 | start >>= 9; |
126 | len >>= 9; |
127 | |
128 | if (start + len > (i_size_read(bdev->bd_inode) >> 9)) |
129 | return -EINVAL; |
130 | if (secure) |
131 | flags |= BLKDEV_DISCARD_SECURE; |
132 | return blkdev_issue_discard(bdev, start, len, GFP_KERNEL, flags); |
133 | } |
134 | |
135 | static int put_ushort(unsigned long arg, unsigned short val) |
136 | { |
137 | return put_user(val, (unsigned short __user *)arg); |
138 | } |
139 | |
140 | static int put_int(unsigned long arg, int val) |
141 | { |
142 | return put_user(val, (int __user *)arg); |
143 | } |
144 | |
145 | static int put_uint(unsigned long arg, unsigned int val) |
146 | { |
147 | return put_user(val, (unsigned int __user *)arg); |
148 | } |
149 | |
150 | static int put_long(unsigned long arg, long val) |
151 | { |
152 | return put_user(val, (long __user *)arg); |
153 | } |
154 | |
155 | static int put_ulong(unsigned long arg, unsigned long val) |
156 | { |
157 | return put_user(val, (unsigned long __user *)arg); |
158 | } |
159 | |
160 | static int put_u64(unsigned long arg, u64 val) |
161 | { |
162 | return put_user(val, (u64 __user *)arg); |
163 | } |
164 | |
165 | int __blkdev_driver_ioctl(struct block_device *bdev, fmode_t mode, |
166 | unsigned cmd, unsigned long arg) |
167 | { |
168 | struct gendisk *disk = bdev->bd_disk; |
169 | |
170 | if (disk->fops->ioctl) |
171 | return disk->fops->ioctl(bdev, mode, cmd, arg); |
172 | |
173 | return -ENOTTY; |
174 | } |
175 | /* |
176 | * For the record: _GPL here is only because somebody decided to slap it |
177 | * on the previous export. Sheer idiocy, since it wasn't copyrightable |
178 | * at all and could be open-coded without any exports by anybody who cares. |
179 | */ |
180 | EXPORT_SYMBOL_GPL(__blkdev_driver_ioctl); |
181 | |
182 | /* |
183 | * Is it an unrecognized ioctl? The correct returns are either |
184 | * ENOTTY (final) or ENOIOCTLCMD ("I don't know this one, try a |
185 | * fallback"). ENOIOCTLCMD gets turned into ENOTTY by the ioctl |
186 | * code before returning. |
187 | * |
188 | * Confused drivers sometimes return EINVAL, which is wrong. It |
189 | * means "I understood the ioctl command, but the parameters to |
190 | * it were wrong". |
191 | * |
192 | * We should aim to just fix the broken drivers, the EINVAL case |
193 | * should go away. |
194 | */ |
195 | static inline int is_unrecognized_ioctl(int ret) |
196 | { |
197 | return ret == -EINVAL || |
198 | ret == -ENOTTY || |
199 | ret == -ENOIOCTLCMD; |
200 | } |
201 | |
202 | /* |
203 | * always keep this in sync with compat_blkdev_ioctl() |
204 | */ |
205 | int blkdev_ioctl(struct block_device *bdev, fmode_t mode, unsigned cmd, |
206 | unsigned long arg) |
207 | { |
208 | struct gendisk *disk = bdev->bd_disk; |
209 | struct backing_dev_info *bdi; |
210 | loff_t size; |
211 | int ret, n; |
212 | |
213 | switch(cmd) { |
214 | case BLKFLSBUF: |
215 | if (!capable(CAP_SYS_ADMIN)) |
216 | return -EACCES; |
217 | |
218 | ret = __blkdev_driver_ioctl(bdev, mode, cmd, arg); |
219 | if (!is_unrecognized_ioctl(ret)) |
220 | return ret; |
221 | |
222 | fsync_bdev(bdev); |
223 | invalidate_bdev(bdev); |
224 | return 0; |
225 | |
226 | case BLKROSET: |
227 | ret = __blkdev_driver_ioctl(bdev, mode, cmd, arg); |
228 | if (!is_unrecognized_ioctl(ret)) |
229 | return ret; |
230 | if (!capable(CAP_SYS_ADMIN)) |
231 | return -EACCES; |
232 | if (get_user(n, (int __user *)(arg))) |
233 | return -EFAULT; |
234 | set_device_ro(bdev, n); |
235 | return 0; |
236 | |
237 | case BLKDISCARD: |
238 | case BLKSECDISCARD: { |
239 | uint64_t range[2]; |
240 | |
241 | if (!(mode & FMODE_WRITE)) |
242 | return -EBADF; |
243 | |
244 | if (copy_from_user(range, (void __user *)arg, sizeof(range))) |
245 | return -EFAULT; |
246 | |
247 | return blk_ioctl_discard(bdev, range[0], range[1], |
248 | cmd == BLKSECDISCARD); |
249 | } |
250 | |
251 | case HDIO_GETGEO: { |
252 | struct hd_geometry geo; |
253 | |
254 | if (!arg) |
255 | return -EINVAL; |
256 | if (!disk->fops->getgeo) |
257 | return -ENOTTY; |
258 | |
259 | /* |
260 | * We need to set the startsect first, the driver may |
261 | * want to override it. |
262 | */ |
263 | memset(&geo, 0, sizeof(geo)); |
264 | geo.start = get_start_sect(bdev); |
265 | ret = disk->fops->getgeo(bdev, &geo); |
266 | if (ret) |
267 | return ret; |
268 | if (copy_to_user((struct hd_geometry __user *)arg, &geo, |
269 | sizeof(geo))) |
270 | return -EFAULT; |
271 | return 0; |
272 | } |
273 | case BLKRAGET: |
274 | case BLKFRAGET: |
275 | if (!arg) |
276 | return -EINVAL; |
277 | bdi = blk_get_backing_dev_info(bdev); |
278 | if (bdi == NULL) |
279 | return -ENOTTY; |
280 | return put_long(arg, (bdi->ra_pages * PAGE_CACHE_SIZE) / 512); |
281 | case BLKROGET: |
282 | return put_int(arg, bdev_read_only(bdev) != 0); |
283 | case BLKBSZGET: /* get block device soft block size (cf. BLKSSZGET) */ |
284 | return put_int(arg, block_size(bdev)); |
285 | case BLKSSZGET: /* get block device logical block size */ |
286 | return put_int(arg, bdev_logical_block_size(bdev)); |
287 | case BLKPBSZGET: /* get block device physical block size */ |
288 | return put_uint(arg, bdev_physical_block_size(bdev)); |
289 | case BLKIOMIN: |
290 | return put_uint(arg, bdev_io_min(bdev)); |
291 | case BLKIOOPT: |
292 | return put_uint(arg, bdev_io_opt(bdev)); |
293 | case BLKALIGNOFF: |
294 | return put_int(arg, bdev_alignment_offset(bdev)); |
295 | case BLKDISCARDZEROES: |
296 | return put_uint(arg, bdev_discard_zeroes_data(bdev)); |
297 | case BLKSECTGET: |
298 | return put_ushort(arg, queue_max_sectors(bdev_get_queue(bdev))); |
299 | case BLKROTATIONAL: |
300 | return put_ushort(arg, !blk_queue_nonrot(bdev_get_queue(bdev))); |
301 | case BLKRASET: |
302 | case BLKFRASET: |
303 | if(!capable(CAP_SYS_ADMIN)) |
304 | return -EACCES; |
305 | bdi = blk_get_backing_dev_info(bdev); |
306 | if (bdi == NULL) |
307 | return -ENOTTY; |
308 | bdi->ra_pages = (arg * 512) / PAGE_CACHE_SIZE; |
309 | return 0; |
310 | case BLKBSZSET: |
311 | /* set the logical block size */ |
312 | if (!capable(CAP_SYS_ADMIN)) |
313 | return -EACCES; |
314 | if (!arg) |
315 | return -EINVAL; |
316 | if (get_user(n, (int __user *) arg)) |
317 | return -EFAULT; |
318 | if (!(mode & FMODE_EXCL)) { |
319 | bdgrab(bdev); |
320 | if (blkdev_get(bdev, mode | FMODE_EXCL, &bdev) < 0) |
321 | return -EBUSY; |
322 | } |
323 | ret = set_blocksize(bdev, n); |
324 | if (!(mode & FMODE_EXCL)) |
325 | blkdev_put(bdev, mode | FMODE_EXCL); |
326 | return ret; |
327 | case BLKPG: |
328 | ret = blkpg_ioctl(bdev, (struct blkpg_ioctl_arg __user *) arg); |
329 | break; |
330 | case BLKRRPART: |
331 | ret = blkdev_reread_part(bdev); |
332 | break; |
333 | case BLKGETSIZE: |
334 | size = i_size_read(bdev->bd_inode); |
335 | if ((size >> 9) > ~0UL) |
336 | return -EFBIG; |
337 | return put_ulong(arg, size >> 9); |
338 | case BLKGETSIZE64: |
339 | return put_u64(arg, i_size_read(bdev->bd_inode)); |
340 | case BLKTRACESTART: |
341 | case BLKTRACESTOP: |
342 | case BLKTRACESETUP: |
343 | case BLKTRACETEARDOWN: |
344 | ret = blk_trace_ioctl(bdev, cmd, (char __user *) arg); |
345 | break; |
346 | default: |
347 | ret = __blkdev_driver_ioctl(bdev, mode, cmd, arg); |
348 | } |
349 | return ret; |
350 | } |
351 | EXPORT_SYMBOL_GPL(blkdev_ioctl); |
352 |
Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master
Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9