Commit | Line | Data |
---|---|---|
f58c4c0a AB |
1 | #include <linux/blkdev.h> |
2 | #include <linux/blkpg.h> | |
3 | #include <linux/blktrace_api.h> | |
4 | #include <linux/cdrom.h> | |
5 | #include <linux/compat.h> | |
6 | #include <linux/elevator.h> | |
7 | #include <linux/fd.h> | |
8 | #include <linux/hdreg.h> | |
5a0e3ad6 | 9 | #include <linux/slab.h> |
f58c4c0a | 10 | #include <linux/syscalls.h> |
f58c4c0a AB |
11 | #include <linux/types.h> |
12 | #include <linux/uaccess.h> | |
13 | ||
14 | static int compat_put_ushort(unsigned long arg, unsigned short val) | |
15 | { | |
16 | return put_user(val, (unsigned short __user *)compat_ptr(arg)); | |
17 | } | |
18 | ||
19 | static int compat_put_int(unsigned long arg, int val) | |
20 | { | |
21 | return put_user(val, (compat_int_t __user *)compat_ptr(arg)); | |
22 | } | |
23 | ||
ac481c20 MP |
24 | static int compat_put_uint(unsigned long arg, unsigned int val) |
25 | { | |
26 | return put_user(val, (compat_uint_t __user *)compat_ptr(arg)); | |
27 | } | |
28 | ||
f58c4c0a AB |
29 | static int compat_put_long(unsigned long arg, long val) |
30 | { | |
31 | return put_user(val, (compat_long_t __user *)compat_ptr(arg)); | |
32 | } | |
33 | ||
34 | static int compat_put_ulong(unsigned long arg, compat_ulong_t val) | |
35 | { | |
36 | return put_user(val, (compat_ulong_t __user *)compat_ptr(arg)); | |
37 | } | |
38 | ||
39 | static int compat_put_u64(unsigned long arg, u64 val) | |
40 | { | |
41 | return put_user(val, (compat_u64 __user *)compat_ptr(arg)); | |
42 | } | |
43 | ||
9617db08 AB |
44 | struct compat_hd_geometry { |
45 | unsigned char heads; | |
46 | unsigned char sectors; | |
47 | unsigned short cylinders; | |
48 | u32 start; | |
49 | }; | |
50 | ||
51 | static int compat_hdio_getgeo(struct gendisk *disk, struct block_device *bdev, | |
52 | struct compat_hd_geometry __user *ugeo) | |
53 | { | |
54 | struct hd_geometry geo; | |
55 | int ret; | |
56 | ||
57 | if (!ugeo) | |
58 | return -EINVAL; | |
59 | if (!disk->fops->getgeo) | |
60 | return -ENOTTY; | |
61 | ||
62 | /* | |
63 | * We need to set the startsect first, the driver may | |
64 | * want to override it. | |
65 | */ | |
66 | geo.start = get_start_sect(bdev); | |
67 | ret = disk->fops->getgeo(bdev, &geo); | |
68 | if (ret) | |
69 | return ret; | |
70 | ||
71 | ret = copy_to_user(ugeo, &geo, 4); | |
72 | ret |= __put_user(geo.start, &ugeo->start); | |
73 | if (ret) | |
74 | ret = -EFAULT; | |
75 | ||
76 | return ret; | |
77 | } | |
78 | ||
33c2dca4 AV |
79 | static int compat_hdio_ioctl(struct block_device *bdev, fmode_t mode, |
80 | unsigned int cmd, unsigned long arg) | |
9617db08 AB |
81 | { |
82 | mm_segment_t old_fs = get_fs(); | |
83 | unsigned long kval; | |
84 | unsigned int __user *uvp; | |
85 | int error; | |
86 | ||
87 | set_fs(KERNEL_DS); | |
33c2dca4 | 88 | error = __blkdev_driver_ioctl(bdev, mode, |
9617db08 AB |
89 | cmd, (unsigned long)(&kval)); |
90 | set_fs(old_fs); | |
91 | ||
92 | if (error == 0) { | |
93 | uvp = compat_ptr(arg); | |
94 | if (put_user(kval, uvp)) | |
95 | error = -EFAULT; | |
96 | } | |
97 | return error; | |
98 | } | |
99 | ||
b3087cc4 AB |
100 | struct compat_cdrom_read_audio { |
101 | union cdrom_addr addr; | |
102 | u8 addr_format; | |
103 | compat_int_t nframes; | |
104 | compat_caddr_t buf; | |
105 | }; | |
106 | ||
107 | struct compat_cdrom_generic_command { | |
108 | unsigned char cmd[CDROM_PACKET_SIZE]; | |
109 | compat_caddr_t buffer; | |
110 | compat_uint_t buflen; | |
111 | compat_int_t stat; | |
112 | compat_caddr_t sense; | |
113 | unsigned char data_direction; | |
114 | compat_int_t quiet; | |
115 | compat_int_t timeout; | |
116 | compat_caddr_t reserved[1]; | |
117 | }; | |
118 | ||
33c2dca4 AV |
119 | static int compat_cdrom_read_audio(struct block_device *bdev, fmode_t mode, |
120 | unsigned int cmd, unsigned long arg) | |
b3087cc4 AB |
121 | { |
122 | struct cdrom_read_audio __user *cdread_audio; | |
123 | struct compat_cdrom_read_audio __user *cdread_audio32; | |
124 | __u32 data; | |
125 | void __user *datap; | |
126 | ||
127 | cdread_audio = compat_alloc_user_space(sizeof(*cdread_audio)); | |
128 | cdread_audio32 = compat_ptr(arg); | |
129 | ||
130 | if (copy_in_user(&cdread_audio->addr, | |
131 | &cdread_audio32->addr, | |
132 | (sizeof(*cdread_audio32) - | |
133 | sizeof(compat_caddr_t)))) | |
134 | return -EFAULT; | |
135 | ||
136 | if (get_user(data, &cdread_audio32->buf)) | |
137 | return -EFAULT; | |
138 | datap = compat_ptr(data); | |
139 | if (put_user(datap, &cdread_audio->buf)) | |
140 | return -EFAULT; | |
141 | ||
33c2dca4 | 142 | return __blkdev_driver_ioctl(bdev, mode, cmd, |
b3087cc4 AB |
143 | (unsigned long)cdread_audio); |
144 | } | |
145 | ||
33c2dca4 AV |
146 | static int compat_cdrom_generic_command(struct block_device *bdev, fmode_t mode, |
147 | unsigned int cmd, unsigned long arg) | |
b3087cc4 AB |
148 | { |
149 | struct cdrom_generic_command __user *cgc; | |
150 | struct compat_cdrom_generic_command __user *cgc32; | |
151 | u32 data; | |
152 | unsigned char dir; | |
153 | int itmp; | |
154 | ||
155 | cgc = compat_alloc_user_space(sizeof(*cgc)); | |
156 | cgc32 = compat_ptr(arg); | |
157 | ||
158 | if (copy_in_user(&cgc->cmd, &cgc32->cmd, sizeof(cgc->cmd)) || | |
159 | get_user(data, &cgc32->buffer) || | |
160 | put_user(compat_ptr(data), &cgc->buffer) || | |
161 | copy_in_user(&cgc->buflen, &cgc32->buflen, | |
162 | (sizeof(unsigned int) + sizeof(int))) || | |
163 | get_user(data, &cgc32->sense) || | |
164 | put_user(compat_ptr(data), &cgc->sense) || | |
165 | get_user(dir, &cgc32->data_direction) || | |
166 | put_user(dir, &cgc->data_direction) || | |
167 | get_user(itmp, &cgc32->quiet) || | |
168 | put_user(itmp, &cgc->quiet) || | |
169 | get_user(itmp, &cgc32->timeout) || | |
170 | put_user(itmp, &cgc->timeout) || | |
171 | get_user(data, &cgc32->reserved[0]) || | |
172 | put_user(compat_ptr(data), &cgc->reserved[0])) | |
173 | return -EFAULT; | |
174 | ||
33c2dca4 | 175 | return __blkdev_driver_ioctl(bdev, mode, cmd, (unsigned long)cgc); |
b3087cc4 AB |
176 | } |
177 | ||
18cf7f87 AB |
178 | struct compat_blkpg_ioctl_arg { |
179 | compat_int_t op; | |
180 | compat_int_t flags; | |
181 | compat_int_t datalen; | |
182 | compat_caddr_t data; | |
183 | }; | |
184 | ||
56b26add | 185 | static int compat_blkpg_ioctl(struct block_device *bdev, fmode_t mode, |
18cf7f87 AB |
186 | unsigned int cmd, struct compat_blkpg_ioctl_arg __user *ua32) |
187 | { | |
188 | struct blkpg_ioctl_arg __user *a = compat_alloc_user_space(sizeof(*a)); | |
189 | compat_caddr_t udata; | |
190 | compat_int_t n; | |
191 | int err; | |
192 | ||
193 | err = get_user(n, &ua32->op); | |
194 | err |= put_user(n, &a->op); | |
195 | err |= get_user(n, &ua32->flags); | |
196 | err |= put_user(n, &a->flags); | |
197 | err |= get_user(n, &ua32->datalen); | |
198 | err |= put_user(n, &a->datalen); | |
199 | err |= get_user(udata, &ua32->data); | |
200 | err |= put_user(compat_ptr(udata), &a->data); | |
201 | if (err) | |
202 | return err; | |
203 | ||
56b26add | 204 | return blkdev_ioctl(bdev, mode, cmd, (unsigned long)a); |
18cf7f87 AB |
205 | } |
206 | ||
f58c4c0a AB |
207 | #define BLKBSZGET_32 _IOR(0x12, 112, int) |
208 | #define BLKBSZSET_32 _IOW(0x12, 113, int) | |
209 | #define BLKGETSIZE64_32 _IOR(0x12, 114, int) | |
210 | ||
1ca91cd0 AB |
211 | struct compat_floppy_struct { |
212 | compat_uint_t size; | |
213 | compat_uint_t sect; | |
214 | compat_uint_t head; | |
215 | compat_uint_t track; | |
216 | compat_uint_t stretch; | |
217 | unsigned char gap; | |
218 | unsigned char rate; | |
219 | unsigned char spec1; | |
220 | unsigned char fmt_gap; | |
221 | const compat_caddr_t name; | |
222 | }; | |
223 | ||
224 | struct compat_floppy_drive_params { | |
225 | char cmos; | |
226 | compat_ulong_t max_dtr; | |
227 | compat_ulong_t hlt; | |
228 | compat_ulong_t hut; | |
229 | compat_ulong_t srt; | |
230 | compat_ulong_t spinup; | |
231 | compat_ulong_t spindown; | |
232 | unsigned char spindown_offset; | |
233 | unsigned char select_delay; | |
234 | unsigned char rps; | |
235 | unsigned char tracks; | |
236 | compat_ulong_t timeout; | |
237 | unsigned char interleave_sect; | |
238 | struct floppy_max_errors max_errors; | |
239 | char flags; | |
240 | char read_track; | |
241 | short autodetect[8]; | |
242 | compat_int_t checkfreq; | |
243 | compat_int_t native_format; | |
244 | }; | |
245 | ||
246 | struct compat_floppy_drive_struct { | |
247 | signed char flags; | |
248 | compat_ulong_t spinup_date; | |
249 | compat_ulong_t select_date; | |
250 | compat_ulong_t first_read_date; | |
251 | short probed_format; | |
252 | short track; | |
253 | short maxblock; | |
254 | short maxtrack; | |
255 | compat_int_t generation; | |
256 | compat_int_t keep_data; | |
257 | compat_int_t fd_ref; | |
258 | compat_int_t fd_device; | |
259 | compat_int_t last_checked; | |
260 | compat_caddr_t dmabuf; | |
261 | compat_int_t bufblocks; | |
262 | }; | |
263 | ||
264 | struct compat_floppy_fdc_state { | |
265 | compat_int_t spec1; | |
266 | compat_int_t spec2; | |
267 | compat_int_t dtr; | |
268 | unsigned char version; | |
269 | unsigned char dor; | |
270 | compat_ulong_t address; | |
271 | unsigned int rawcmd:2; | |
272 | unsigned int reset:1; | |
273 | unsigned int need_configure:1; | |
274 | unsigned int perp_mode:2; | |
275 | unsigned int has_fifo:1; | |
276 | unsigned int driver_version; | |
277 | unsigned char track[4]; | |
278 | }; | |
279 | ||
280 | struct compat_floppy_write_errors { | |
281 | unsigned int write_errors; | |
282 | compat_ulong_t first_error_sector; | |
283 | compat_int_t first_error_generation; | |
284 | compat_ulong_t last_error_sector; | |
285 | compat_int_t last_error_generation; | |
286 | compat_uint_t badness; | |
287 | }; | |
288 | ||
289 | #define FDSETPRM32 _IOW(2, 0x42, struct compat_floppy_struct) | |
290 | #define FDDEFPRM32 _IOW(2, 0x43, struct compat_floppy_struct) | |
291 | #define FDGETPRM32 _IOR(2, 0x04, struct compat_floppy_struct) | |
292 | #define FDSETDRVPRM32 _IOW(2, 0x90, struct compat_floppy_drive_params) | |
293 | #define FDGETDRVPRM32 _IOR(2, 0x11, struct compat_floppy_drive_params) | |
294 | #define FDGETDRVSTAT32 _IOR(2, 0x12, struct compat_floppy_drive_struct) | |
295 | #define FDPOLLDRVSTAT32 _IOR(2, 0x13, struct compat_floppy_drive_struct) | |
296 | #define FDGETFDCSTAT32 _IOR(2, 0x15, struct compat_floppy_fdc_state) | |
297 | #define FDWERRORGET32 _IOR(2, 0x17, struct compat_floppy_write_errors) | |
298 | ||
299 | static struct { | |
300 | unsigned int cmd32; | |
301 | unsigned int cmd; | |
302 | } fd_ioctl_trans_table[] = { | |
303 | { FDSETPRM32, FDSETPRM }, | |
304 | { FDDEFPRM32, FDDEFPRM }, | |
305 | { FDGETPRM32, FDGETPRM }, | |
306 | { FDSETDRVPRM32, FDSETDRVPRM }, | |
307 | { FDGETDRVPRM32, FDGETDRVPRM }, | |
308 | { FDGETDRVSTAT32, FDGETDRVSTAT }, | |
309 | { FDPOLLDRVSTAT32, FDPOLLDRVSTAT }, | |
310 | { FDGETFDCSTAT32, FDGETFDCSTAT }, | |
311 | { FDWERRORGET32, FDWERRORGET } | |
312 | }; | |
313 | ||
314 | #define NR_FD_IOCTL_TRANS ARRAY_SIZE(fd_ioctl_trans_table) | |
315 | ||
33c2dca4 AV |
316 | static int compat_fd_ioctl(struct block_device *bdev, fmode_t mode, |
317 | unsigned int cmd, unsigned long arg) | |
1ca91cd0 AB |
318 | { |
319 | mm_segment_t old_fs = get_fs(); | |
320 | void *karg = NULL; | |
321 | unsigned int kcmd = 0; | |
322 | int i, err; | |
323 | ||
324 | for (i = 0; i < NR_FD_IOCTL_TRANS; i++) | |
325 | if (cmd == fd_ioctl_trans_table[i].cmd32) { | |
326 | kcmd = fd_ioctl_trans_table[i].cmd; | |
327 | break; | |
328 | } | |
329 | if (!kcmd) | |
330 | return -EINVAL; | |
331 | ||
332 | switch (cmd) { | |
333 | case FDSETPRM32: | |
334 | case FDDEFPRM32: | |
335 | case FDGETPRM32: | |
336 | { | |
337 | compat_uptr_t name; | |
338 | struct compat_floppy_struct __user *uf; | |
339 | struct floppy_struct *f; | |
340 | ||
341 | uf = compat_ptr(arg); | |
342 | f = karg = kmalloc(sizeof(struct floppy_struct), GFP_KERNEL); | |
343 | if (!karg) | |
344 | return -ENOMEM; | |
345 | if (cmd == FDGETPRM32) | |
346 | break; | |
347 | err = __get_user(f->size, &uf->size); | |
348 | err |= __get_user(f->sect, &uf->sect); | |
349 | err |= __get_user(f->head, &uf->head); | |
350 | err |= __get_user(f->track, &uf->track); | |
351 | err |= __get_user(f->stretch, &uf->stretch); | |
352 | err |= __get_user(f->gap, &uf->gap); | |
353 | err |= __get_user(f->rate, &uf->rate); | |
354 | err |= __get_user(f->spec1, &uf->spec1); | |
355 | err |= __get_user(f->fmt_gap, &uf->fmt_gap); | |
356 | err |= __get_user(name, &uf->name); | |
357 | f->name = compat_ptr(name); | |
358 | if (err) { | |
359 | err = -EFAULT; | |
360 | goto out; | |
361 | } | |
362 | break; | |
363 | } | |
364 | case FDSETDRVPRM32: | |
365 | case FDGETDRVPRM32: | |
366 | { | |
367 | struct compat_floppy_drive_params __user *uf; | |
368 | struct floppy_drive_params *f; | |
369 | ||
370 | uf = compat_ptr(arg); | |
371 | f = karg = kmalloc(sizeof(struct floppy_drive_params), GFP_KERNEL); | |
372 | if (!karg) | |
373 | return -ENOMEM; | |
374 | if (cmd == FDGETDRVPRM32) | |
375 | break; | |
376 | err = __get_user(f->cmos, &uf->cmos); | |
377 | err |= __get_user(f->max_dtr, &uf->max_dtr); | |
378 | err |= __get_user(f->hlt, &uf->hlt); | |
379 | err |= __get_user(f->hut, &uf->hut); | |
380 | err |= __get_user(f->srt, &uf->srt); | |
381 | err |= __get_user(f->spinup, &uf->spinup); | |
382 | err |= __get_user(f->spindown, &uf->spindown); | |
383 | err |= __get_user(f->spindown_offset, &uf->spindown_offset); | |
384 | err |= __get_user(f->select_delay, &uf->select_delay); | |
385 | err |= __get_user(f->rps, &uf->rps); | |
386 | err |= __get_user(f->tracks, &uf->tracks); | |
387 | err |= __get_user(f->timeout, &uf->timeout); | |
388 | err |= __get_user(f->interleave_sect, &uf->interleave_sect); | |
389 | err |= __copy_from_user(&f->max_errors, &uf->max_errors, sizeof(f->max_errors)); | |
390 | err |= __get_user(f->flags, &uf->flags); | |
391 | err |= __get_user(f->read_track, &uf->read_track); | |
392 | err |= __copy_from_user(f->autodetect, uf->autodetect, sizeof(f->autodetect)); | |
393 | err |= __get_user(f->checkfreq, &uf->checkfreq); | |
394 | err |= __get_user(f->native_format, &uf->native_format); | |
395 | if (err) { | |
396 | err = -EFAULT; | |
397 | goto out; | |
398 | } | |
399 | break; | |
400 | } | |
401 | case FDGETDRVSTAT32: | |
402 | case FDPOLLDRVSTAT32: | |
403 | karg = kmalloc(sizeof(struct floppy_drive_struct), GFP_KERNEL); | |
404 | if (!karg) | |
405 | return -ENOMEM; | |
406 | break; | |
407 | case FDGETFDCSTAT32: | |
408 | karg = kmalloc(sizeof(struct floppy_fdc_state), GFP_KERNEL); | |
409 | if (!karg) | |
410 | return -ENOMEM; | |
411 | break; | |
412 | case FDWERRORGET32: | |
413 | karg = kmalloc(sizeof(struct floppy_write_errors), GFP_KERNEL); | |
414 | if (!karg) | |
415 | return -ENOMEM; | |
416 | break; | |
417 | default: | |
418 | return -EINVAL; | |
419 | } | |
420 | set_fs(KERNEL_DS); | |
33c2dca4 | 421 | err = __blkdev_driver_ioctl(bdev, mode, kcmd, (unsigned long)karg); |
1ca91cd0 AB |
422 | set_fs(old_fs); |
423 | if (err) | |
424 | goto out; | |
425 | switch (cmd) { | |
426 | case FDGETPRM32: | |
427 | { | |
428 | struct floppy_struct *f = karg; | |
429 | struct compat_floppy_struct __user *uf = compat_ptr(arg); | |
430 | ||
431 | err = __put_user(f->size, &uf->size); | |
432 | err |= __put_user(f->sect, &uf->sect); | |
433 | err |= __put_user(f->head, &uf->head); | |
434 | err |= __put_user(f->track, &uf->track); | |
435 | err |= __put_user(f->stretch, &uf->stretch); | |
436 | err |= __put_user(f->gap, &uf->gap); | |
437 | err |= __put_user(f->rate, &uf->rate); | |
438 | err |= __put_user(f->spec1, &uf->spec1); | |
439 | err |= __put_user(f->fmt_gap, &uf->fmt_gap); | |
440 | err |= __put_user((u64)f->name, (compat_caddr_t __user *)&uf->name); | |
441 | break; | |
442 | } | |
443 | case FDGETDRVPRM32: | |
444 | { | |
445 | struct compat_floppy_drive_params __user *uf; | |
446 | struct floppy_drive_params *f = karg; | |
447 | ||
448 | uf = compat_ptr(arg); | |
449 | err = __put_user(f->cmos, &uf->cmos); | |
450 | err |= __put_user(f->max_dtr, &uf->max_dtr); | |
451 | err |= __put_user(f->hlt, &uf->hlt); | |
452 | err |= __put_user(f->hut, &uf->hut); | |
453 | err |= __put_user(f->srt, &uf->srt); | |
454 | err |= __put_user(f->spinup, &uf->spinup); | |
455 | err |= __put_user(f->spindown, &uf->spindown); | |
456 | err |= __put_user(f->spindown_offset, &uf->spindown_offset); | |
457 | err |= __put_user(f->select_delay, &uf->select_delay); | |
458 | err |= __put_user(f->rps, &uf->rps); | |
459 | err |= __put_user(f->tracks, &uf->tracks); | |
460 | err |= __put_user(f->timeout, &uf->timeout); | |
461 | err |= __put_user(f->interleave_sect, &uf->interleave_sect); | |
462 | err |= __copy_to_user(&uf->max_errors, &f->max_errors, sizeof(f->max_errors)); | |
463 | err |= __put_user(f->flags, &uf->flags); | |
464 | err |= __put_user(f->read_track, &uf->read_track); | |
465 | err |= __copy_to_user(uf->autodetect, f->autodetect, sizeof(f->autodetect)); | |
466 | err |= __put_user(f->checkfreq, &uf->checkfreq); | |
467 | err |= __put_user(f->native_format, &uf->native_format); | |
468 | break; | |
469 | } | |
470 | case FDGETDRVSTAT32: | |
471 | case FDPOLLDRVSTAT32: | |
472 | { | |
473 | struct compat_floppy_drive_struct __user *uf; | |
474 | struct floppy_drive_struct *f = karg; | |
475 | ||
476 | uf = compat_ptr(arg); | |
477 | err = __put_user(f->flags, &uf->flags); | |
478 | err |= __put_user(f->spinup_date, &uf->spinup_date); | |
479 | err |= __put_user(f->select_date, &uf->select_date); | |
480 | err |= __put_user(f->first_read_date, &uf->first_read_date); | |
481 | err |= __put_user(f->probed_format, &uf->probed_format); | |
482 | err |= __put_user(f->track, &uf->track); | |
483 | err |= __put_user(f->maxblock, &uf->maxblock); | |
484 | err |= __put_user(f->maxtrack, &uf->maxtrack); | |
485 | err |= __put_user(f->generation, &uf->generation); | |
486 | err |= __put_user(f->keep_data, &uf->keep_data); | |
487 | err |= __put_user(f->fd_ref, &uf->fd_ref); | |
488 | err |= __put_user(f->fd_device, &uf->fd_device); | |
489 | err |= __put_user(f->last_checked, &uf->last_checked); | |
490 | err |= __put_user((u64)f->dmabuf, &uf->dmabuf); | |
491 | err |= __put_user((u64)f->bufblocks, &uf->bufblocks); | |
492 | break; | |
493 | } | |
494 | case FDGETFDCSTAT32: | |
495 | { | |
496 | struct compat_floppy_fdc_state __user *uf; | |
497 | struct floppy_fdc_state *f = karg; | |
498 | ||
499 | uf = compat_ptr(arg); | |
500 | err = __put_user(f->spec1, &uf->spec1); | |
501 | err |= __put_user(f->spec2, &uf->spec2); | |
502 | err |= __put_user(f->dtr, &uf->dtr); | |
503 | err |= __put_user(f->version, &uf->version); | |
504 | err |= __put_user(f->dor, &uf->dor); | |
505 | err |= __put_user(f->address, &uf->address); | |
506 | err |= __copy_to_user((char __user *)&uf->address + sizeof(uf->address), | |
507 | (char *)&f->address + sizeof(f->address), sizeof(int)); | |
508 | err |= __put_user(f->driver_version, &uf->driver_version); | |
509 | err |= __copy_to_user(uf->track, f->track, sizeof(f->track)); | |
510 | break; | |
511 | } | |
512 | case FDWERRORGET32: | |
513 | { | |
514 | struct compat_floppy_write_errors __user *uf; | |
515 | struct floppy_write_errors *f = karg; | |
516 | ||
517 | uf = compat_ptr(arg); | |
518 | err = __put_user(f->write_errors, &uf->write_errors); | |
519 | err |= __put_user(f->first_error_sector, &uf->first_error_sector); | |
520 | err |= __put_user(f->first_error_generation, &uf->first_error_generation); | |
521 | err |= __put_user(f->last_error_sector, &uf->last_error_sector); | |
522 | err |= __put_user(f->last_error_generation, &uf->last_error_generation); | |
523 | err |= __put_user(f->badness, &uf->badness); | |
524 | break; | |
525 | } | |
526 | default: | |
527 | break; | |
528 | } | |
529 | if (err) | |
530 | err = -EFAULT; | |
531 | ||
532 | out: | |
533 | kfree(karg); | |
534 | return err; | |
535 | } | |
536 | ||
33c2dca4 AV |
537 | static int compat_blkdev_driver_ioctl(struct block_device *bdev, fmode_t mode, |
538 | unsigned cmd, unsigned long arg) | |
7199d4cd | 539 | { |
33013a88 | 540 | switch (cmd) { |
9617db08 AB |
541 | case HDIO_GET_UNMASKINTR: |
542 | case HDIO_GET_MULTCOUNT: | |
543 | case HDIO_GET_KEEPSETTINGS: | |
544 | case HDIO_GET_32BIT: | |
545 | case HDIO_GET_NOWERR: | |
546 | case HDIO_GET_DMA: | |
547 | case HDIO_GET_NICE: | |
548 | case HDIO_GET_WCACHE: | |
549 | case HDIO_GET_ACOUSTIC: | |
550 | case HDIO_GET_ADDRESS: | |
551 | case HDIO_GET_BUSSTATE: | |
33c2dca4 | 552 | return compat_hdio_ioctl(bdev, mode, cmd, arg); |
1ca91cd0 AB |
553 | case FDSETPRM32: |
554 | case FDDEFPRM32: | |
555 | case FDGETPRM32: | |
556 | case FDSETDRVPRM32: | |
557 | case FDGETDRVPRM32: | |
558 | case FDGETDRVSTAT32: | |
559 | case FDPOLLDRVSTAT32: | |
560 | case FDGETFDCSTAT32: | |
561 | case FDWERRORGET32: | |
33c2dca4 | 562 | return compat_fd_ioctl(bdev, mode, cmd, arg); |
b3087cc4 | 563 | case CDROMREADAUDIO: |
33c2dca4 | 564 | return compat_cdrom_read_audio(bdev, mode, cmd, arg); |
b3087cc4 | 565 | case CDROM_SEND_PACKET: |
33c2dca4 | 566 | return compat_cdrom_generic_command(bdev, mode, cmd, arg); |
b3087cc4 | 567 | |
7199d4cd AB |
568 | /* |
569 | * No handler required for the ones below, we just need to | |
570 | * convert arg to a 64 bit pointer. | |
571 | */ | |
572 | case BLKSECTSET: | |
573 | /* | |
574 | * 0x03 -- HD/IDE ioctl's used by hdparm and friends. | |
575 | * Some need translations, these do not. | |
576 | */ | |
577 | case HDIO_GET_IDENTITY: | |
578 | case HDIO_DRIVE_TASK: | |
579 | case HDIO_DRIVE_CMD: | |
7199d4cd AB |
580 | /* 0x330 is reserved -- it used to be HDIO_GETGEO_BIG */ |
581 | case 0x330: | |
582 | /* 0x02 -- Floppy ioctls */ | |
583 | case FDMSGON: | |
584 | case FDMSGOFF: | |
585 | case FDSETEMSGTRESH: | |
586 | case FDFLUSH: | |
587 | case FDWERRORCLR: | |
588 | case FDSETMAXERRS: | |
589 | case FDGETMAXERRS: | |
590 | case FDGETDRVTYP: | |
591 | case FDEJECT: | |
592 | case FDCLRPRM: | |
593 | case FDFMTBEG: | |
594 | case FDFMTEND: | |
595 | case FDRESET: | |
596 | case FDTWADDLE: | |
597 | case FDFMTTRK: | |
598 | case FDRAWCMD: | |
599 | /* CDROM stuff */ | |
600 | case CDROMPAUSE: | |
601 | case CDROMRESUME: | |
602 | case CDROMPLAYMSF: | |
603 | case CDROMPLAYTRKIND: | |
604 | case CDROMREADTOCHDR: | |
605 | case CDROMREADTOCENTRY: | |
606 | case CDROMSTOP: | |
607 | case CDROMSTART: | |
608 | case CDROMEJECT: | |
609 | case CDROMVOLCTRL: | |
610 | case CDROMSUBCHNL: | |
611 | case CDROMMULTISESSION: | |
612 | case CDROM_GET_MCN: | |
613 | case CDROMRESET: | |
614 | case CDROMVOLREAD: | |
615 | case CDROMSEEK: | |
616 | case CDROMPLAYBLK: | |
617 | case CDROMCLOSETRAY: | |
618 | case CDROM_DISC_STATUS: | |
619 | case CDROM_CHANGER_NSLOTS: | |
620 | case CDROM_GET_CAPABILITY: | |
621 | /* Ignore cdrom.h about these next 5 ioctls, they absolutely do | |
622 | * not take a struct cdrom_read, instead they take a struct cdrom_msf | |
623 | * which is compatible. | |
624 | */ | |
625 | case CDROMREADMODE2: | |
626 | case CDROMREADMODE1: | |
627 | case CDROMREADRAW: | |
628 | case CDROMREADCOOKED: | |
629 | case CDROMREADALL: | |
630 | /* DVD ioctls */ | |
631 | case DVD_READ_STRUCT: | |
632 | case DVD_WRITE_STRUCT: | |
633 | case DVD_AUTH: | |
634 | arg = (unsigned long)compat_ptr(arg); | |
1c925604 AS |
635 | /* These intepret arg as an unsigned long, not as a pointer, |
636 | * so we must not do compat_ptr() conversion. */ | |
637 | case HDIO_SET_MULTCOUNT: | |
638 | case HDIO_SET_UNMASKINTR: | |
639 | case HDIO_SET_KEEPSETTINGS: | |
640 | case HDIO_SET_32BIT: | |
641 | case HDIO_SET_NOWERR: | |
642 | case HDIO_SET_DMA: | |
643 | case HDIO_SET_PIO_MODE: | |
644 | case HDIO_SET_NICE: | |
645 | case HDIO_SET_WCACHE: | |
646 | case HDIO_SET_ACOUSTIC: | |
647 | case HDIO_SET_BUSSTATE: | |
648 | case HDIO_SET_ADDRESS: | |
649 | case CDROMEJECT_SW: | |
650 | case CDROM_SET_OPTIONS: | |
651 | case CDROM_CLEAR_OPTIONS: | |
652 | case CDROM_SELECT_SPEED: | |
653 | case CDROM_SELECT_DISC: | |
654 | case CDROM_MEDIA_CHANGED: | |
655 | case CDROM_DRIVE_STATUS: | |
656 | case CDROM_LOCKDOOR: | |
657 | case CDROM_DEBUG: | |
7199d4cd AB |
658 | break; |
659 | default: | |
660 | /* unknown ioctl number */ | |
661 | return -ENOIOCTLCMD; | |
662 | } | |
663 | ||
33c2dca4 | 664 | return __blkdev_driver_ioctl(bdev, mode, cmd, arg); |
7199d4cd AB |
665 | } |
666 | ||
45048d09 AV |
667 | /* Most of the generic ioctls are handled in the normal fallback path. |
668 | This assumes the blkdev's low level compat_ioctl always returns | |
669 | ENOIOCTLCMD for unknown ioctls. */ | |
670 | long compat_blkdev_ioctl(struct file *file, unsigned cmd, unsigned long arg) | |
f58c4c0a | 671 | { |
45048d09 AV |
672 | int ret = -ENOIOCTLCMD; |
673 | struct inode *inode = file->f_mapping->host; | |
674 | struct block_device *bdev = inode->i_bdev; | |
675 | struct gendisk *disk = bdev->bd_disk; | |
676 | fmode_t mode = file->f_mode; | |
f58c4c0a | 677 | struct backing_dev_info *bdi; |
45048d09 AV |
678 | loff_t size; |
679 | ||
fd4ce1ac CH |
680 | /* |
681 | * O_NDELAY can be altered using fcntl(.., F_SETFL, ..), so we have | |
682 | * to updated it before every ioctl. | |
683 | */ | |
45048d09 | 684 | if (file->f_flags & O_NDELAY) |
fd4ce1ac CH |
685 | mode |= FMODE_NDELAY; |
686 | else | |
687 | mode &= ~FMODE_NDELAY; | |
f58c4c0a AB |
688 | |
689 | switch (cmd) { | |
45048d09 AV |
690 | case HDIO_GETGEO: |
691 | return compat_hdio_getgeo(disk, bdev, compat_ptr(arg)); | |
ac481c20 MP |
692 | case BLKPBSZGET: |
693 | return compat_put_uint(arg, bdev_physical_block_size(bdev)); | |
694 | case BLKIOMIN: | |
695 | return compat_put_uint(arg, bdev_io_min(bdev)); | |
696 | case BLKIOOPT: | |
697 | return compat_put_uint(arg, bdev_io_opt(bdev)); | |
698 | case BLKALIGNOFF: | |
699 | return compat_put_int(arg, bdev_alignment_offset(bdev)); | |
98262f27 MP |
700 | case BLKDISCARDZEROES: |
701 | return compat_put_uint(arg, bdev_discard_zeroes_data(bdev)); | |
45048d09 AV |
702 | case BLKFLSBUF: |
703 | case BLKROSET: | |
704 | case BLKDISCARD: | |
8d57a98c | 705 | case BLKSECDISCARD: |
45048d09 AV |
706 | /* |
707 | * the ones below are implemented in blkdev_locked_ioctl, | |
708 | * but we call blkdev_ioctl, which gets the lock for us | |
709 | */ | |
710 | case BLKRRPART: | |
56b26add | 711 | return blkdev_ioctl(bdev, mode, cmd, |
45048d09 AV |
712 | (unsigned long)compat_ptr(arg)); |
713 | case BLKBSZSET_32: | |
56b26add | 714 | return blkdev_ioctl(bdev, mode, BLKBSZSET, |
45048d09 AV |
715 | (unsigned long)compat_ptr(arg)); |
716 | case BLKPG: | |
56b26add | 717 | return compat_blkpg_ioctl(bdev, mode, cmd, compat_ptr(arg)); |
f58c4c0a AB |
718 | case BLKRAGET: |
719 | case BLKFRAGET: | |
720 | if (!arg) | |
721 | return -EINVAL; | |
722 | bdi = blk_get_backing_dev_info(bdev); | |
723 | if (bdi == NULL) | |
724 | return -ENOTTY; | |
725 | return compat_put_long(arg, | |
726 | (bdi->ra_pages * PAGE_CACHE_SIZE) / 512); | |
727 | case BLKROGET: /* compatible */ | |
728 | return compat_put_int(arg, bdev_read_only(bdev) != 0); | |
729 | case BLKBSZGET_32: /* get the logical block size (cf. BLKSSZGET) */ | |
730 | return compat_put_int(arg, block_size(bdev)); | |
731 | case BLKSSZGET: /* get block device hardware sector size */ | |
e1defc4f | 732 | return compat_put_int(arg, bdev_logical_block_size(bdev)); |
f58c4c0a AB |
733 | case BLKSECTGET: |
734 | return compat_put_ushort(arg, | |
ae03bf63 | 735 | queue_max_sectors(bdev_get_queue(bdev))); |
f58c4c0a AB |
736 | case BLKRASET: /* compatible, but no compat_ptr (!) */ |
737 | case BLKFRASET: | |
738 | if (!capable(CAP_SYS_ADMIN)) | |
739 | return -EACCES; | |
740 | bdi = blk_get_backing_dev_info(bdev); | |
741 | if (bdi == NULL) | |
742 | return -ENOTTY; | |
743 | bdi->ra_pages = (arg * 512) / PAGE_CACHE_SIZE; | |
744 | return 0; | |
745 | case BLKGETSIZE: | |
77304d2a | 746 | size = i_size_read(bdev->bd_inode); |
45048d09 | 747 | if ((size >> 9) > ~0UL) |
f58c4c0a | 748 | return -EFBIG; |
45048d09 | 749 | return compat_put_ulong(arg, size >> 9); |
f58c4c0a AB |
750 | |
751 | case BLKGETSIZE64_32: | |
77304d2a | 752 | return compat_put_u64(arg, i_size_read(bdev->bd_inode)); |
171044d4 AB |
753 | |
754 | case BLKTRACESETUP32: | |
171044d4 AB |
755 | case BLKTRACESTART: /* compatible */ |
756 | case BLKTRACESTOP: /* compatible */ | |
757 | case BLKTRACETEARDOWN: /* compatible */ | |
45048d09 | 758 | ret = blk_trace_ioctl(bdev, cmd, compat_ptr(arg)); |
7199d4cd | 759 | return ret; |
45048d09 AV |
760 | default: |
761 | if (disk->fops->compat_ioctl) | |
762 | ret = disk->fops->compat_ioctl(bdev, mode, cmd, arg); | |
763 | if (ret == -ENOIOCTLCMD) | |
764 | ret = compat_blkdev_driver_ioctl(bdev, mode, cmd, arg); | |
765 | return ret; | |
766 | } | |
f58c4c0a | 767 | } |