diff options
author | Linus Torvalds <torvalds@linux-foundation.org> | 2009-12-08 10:55:01 -0500 |
---|---|---|
committer | Linus Torvalds <torvalds@linux-foundation.org> | 2009-12-08 10:55:01 -0500 |
commit | d7fc02c7bae7b1cf69269992cf880a43a350cdaa (patch) | |
tree | a43d56fa72913a1cc98a0bbebe054d08581b3a7c /fs | |
parent | ee1262dbc65ce0b6234a915d8432171e8d77f518 (diff) | |
parent | 28b4d5cc17c20786848cdc07b7ea237a309776bb (diff) |
Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/net-next-2.6
* git://git.kernel.org/pub/scm/linux/kernel/git/davem/net-next-2.6: (1815 commits)
mac80211: fix reorder buffer release
iwmc3200wifi: Enable wimax core through module parameter
iwmc3200wifi: Add wifi-wimax coexistence mode as a module parameter
iwmc3200wifi: Coex table command does not expect a response
iwmc3200wifi: Update wiwi priority table
iwlwifi: driver version track kernel version
iwlwifi: indicate uCode type when fail dump error/event log
iwl3945: remove duplicated event logging code
b43: fix two warnings
ipw2100: fix rebooting hang with driver loaded
cfg80211: indent regulatory messages with spaces
iwmc3200wifi: fix NULL pointer dereference in pmkid update
mac80211: Fix TX status reporting for injected data frames
ath9k: enable 2GHz band only if the device supports it
airo: Fix integer overflow warning
rt2x00: Fix padding bug on L2PAD devices.
WE: Fix set events not propagated
b43legacy: avoid PPC fault during resume
b43: avoid PPC fault during resume
tcp: fix a timewait refcnt race
...
Fix up conflicts due to sysctl cleanups (dead sysctl_check code and
CTL_UNNUMBERED removed) in
kernel/sysctl_check.c
net/ipv4/sysctl_net_ipv4.c
net/ipv6/addrconf.c
net/sctp/sysctl.c
Diffstat (limited to 'fs')
-rw-r--r-- | fs/compat_ioctl.c | 745 | ||||
-rw-r--r-- | fs/ocfs2/cluster/netdebug.c | 8 |
2 files changed, 4 insertions, 749 deletions
diff --git a/fs/compat_ioctl.c b/fs/compat_ioctl.c index d84e7058c298..229e72218165 100644 --- a/fs/compat_ioctl.c +++ b/fs/compat_ioctl.c | |||
@@ -246,428 +246,6 @@ static int do_video_set_spu_palette(unsigned int fd, unsigned int cmd, unsigned | |||
246 | return err; | 246 | return err; |
247 | } | 247 | } |
248 | 248 | ||
249 | #ifdef CONFIG_NET | ||
250 | static int do_siocgstamp(unsigned int fd, unsigned int cmd, unsigned long arg) | ||
251 | { | ||
252 | struct compat_timeval __user *up = compat_ptr(arg); | ||
253 | struct timeval ktv; | ||
254 | mm_segment_t old_fs = get_fs(); | ||
255 | int err; | ||
256 | |||
257 | set_fs(KERNEL_DS); | ||
258 | err = sys_ioctl(fd, cmd, (unsigned long)&ktv); | ||
259 | set_fs(old_fs); | ||
260 | if(!err) { | ||
261 | err = put_user(ktv.tv_sec, &up->tv_sec); | ||
262 | err |= __put_user(ktv.tv_usec, &up->tv_usec); | ||
263 | } | ||
264 | return err; | ||
265 | } | ||
266 | |||
267 | static int do_siocgstampns(unsigned int fd, unsigned int cmd, unsigned long arg) | ||
268 | { | ||
269 | struct compat_timespec __user *up = compat_ptr(arg); | ||
270 | struct timespec kts; | ||
271 | mm_segment_t old_fs = get_fs(); | ||
272 | int err; | ||
273 | |||
274 | set_fs(KERNEL_DS); | ||
275 | err = sys_ioctl(fd, cmd, (unsigned long)&kts); | ||
276 | set_fs(old_fs); | ||
277 | if (!err) { | ||
278 | err = put_user(kts.tv_sec, &up->tv_sec); | ||
279 | err |= __put_user(kts.tv_nsec, &up->tv_nsec); | ||
280 | } | ||
281 | return err; | ||
282 | } | ||
283 | |||
284 | struct ifmap32 { | ||
285 | compat_ulong_t mem_start; | ||
286 | compat_ulong_t mem_end; | ||
287 | unsigned short base_addr; | ||
288 | unsigned char irq; | ||
289 | unsigned char dma; | ||
290 | unsigned char port; | ||
291 | }; | ||
292 | |||
293 | struct ifreq32 { | ||
294 | #define IFHWADDRLEN 6 | ||
295 | #define IFNAMSIZ 16 | ||
296 | union { | ||
297 | char ifrn_name[IFNAMSIZ]; /* if name, e.g. "en0" */ | ||
298 | } ifr_ifrn; | ||
299 | union { | ||
300 | struct sockaddr ifru_addr; | ||
301 | struct sockaddr ifru_dstaddr; | ||
302 | struct sockaddr ifru_broadaddr; | ||
303 | struct sockaddr ifru_netmask; | ||
304 | struct sockaddr ifru_hwaddr; | ||
305 | short ifru_flags; | ||
306 | compat_int_t ifru_ivalue; | ||
307 | compat_int_t ifru_mtu; | ||
308 | struct ifmap32 ifru_map; | ||
309 | char ifru_slave[IFNAMSIZ]; /* Just fits the size */ | ||
310 | char ifru_newname[IFNAMSIZ]; | ||
311 | compat_caddr_t ifru_data; | ||
312 | /* XXXX? ifru_settings should be here */ | ||
313 | } ifr_ifru; | ||
314 | }; | ||
315 | |||
316 | struct ifconf32 { | ||
317 | compat_int_t ifc_len; /* size of buffer */ | ||
318 | compat_caddr_t ifcbuf; | ||
319 | }; | ||
320 | |||
321 | static int dev_ifname32(unsigned int fd, unsigned int cmd, unsigned long arg) | ||
322 | { | ||
323 | struct ifreq __user *uifr; | ||
324 | int err; | ||
325 | |||
326 | uifr = compat_alloc_user_space(sizeof(struct ifreq)); | ||
327 | if (copy_in_user(uifr, compat_ptr(arg), sizeof(struct ifreq32))) | ||
328 | return -EFAULT; | ||
329 | |||
330 | err = sys_ioctl(fd, SIOCGIFNAME, (unsigned long)uifr); | ||
331 | if (err) | ||
332 | return err; | ||
333 | |||
334 | if (copy_in_user(compat_ptr(arg), uifr, sizeof(struct ifreq32))) | ||
335 | return -EFAULT; | ||
336 | |||
337 | return 0; | ||
338 | } | ||
339 | |||
340 | static int dev_ifconf(unsigned int fd, unsigned int cmd, unsigned long arg) | ||
341 | { | ||
342 | struct ifconf32 ifc32; | ||
343 | struct ifconf ifc; | ||
344 | struct ifconf __user *uifc; | ||
345 | struct ifreq32 __user *ifr32; | ||
346 | struct ifreq __user *ifr; | ||
347 | unsigned int i, j; | ||
348 | int err; | ||
349 | |||
350 | if (copy_from_user(&ifc32, compat_ptr(arg), sizeof(struct ifconf32))) | ||
351 | return -EFAULT; | ||
352 | |||
353 | if (ifc32.ifcbuf == 0) { | ||
354 | ifc32.ifc_len = 0; | ||
355 | ifc.ifc_len = 0; | ||
356 | ifc.ifc_req = NULL; | ||
357 | uifc = compat_alloc_user_space(sizeof(struct ifconf)); | ||
358 | } else { | ||
359 | size_t len =((ifc32.ifc_len / sizeof (struct ifreq32)) + 1) * | ||
360 | sizeof (struct ifreq); | ||
361 | uifc = compat_alloc_user_space(sizeof(struct ifconf) + len); | ||
362 | ifc.ifc_len = len; | ||
363 | ifr = ifc.ifc_req = (void __user *)(uifc + 1); | ||
364 | ifr32 = compat_ptr(ifc32.ifcbuf); | ||
365 | for (i = 0; i < ifc32.ifc_len; i += sizeof (struct ifreq32)) { | ||
366 | if (copy_in_user(ifr, ifr32, sizeof(struct ifreq32))) | ||
367 | return -EFAULT; | ||
368 | ifr++; | ||
369 | ifr32++; | ||
370 | } | ||
371 | } | ||
372 | if (copy_to_user(uifc, &ifc, sizeof(struct ifconf))) | ||
373 | return -EFAULT; | ||
374 | |||
375 | err = sys_ioctl (fd, SIOCGIFCONF, (unsigned long)uifc); | ||
376 | if (err) | ||
377 | return err; | ||
378 | |||
379 | if (copy_from_user(&ifc, uifc, sizeof(struct ifconf))) | ||
380 | return -EFAULT; | ||
381 | |||
382 | ifr = ifc.ifc_req; | ||
383 | ifr32 = compat_ptr(ifc32.ifcbuf); | ||
384 | for (i = 0, j = 0; | ||
385 | i + sizeof (struct ifreq32) <= ifc32.ifc_len && j < ifc.ifc_len; | ||
386 | i += sizeof (struct ifreq32), j += sizeof (struct ifreq)) { | ||
387 | if (copy_in_user(ifr32, ifr, sizeof (struct ifreq32))) | ||
388 | return -EFAULT; | ||
389 | ifr32++; | ||
390 | ifr++; | ||
391 | } | ||
392 | |||
393 | if (ifc32.ifcbuf == 0) { | ||
394 | /* Translate from 64-bit structure multiple to | ||
395 | * a 32-bit one. | ||
396 | */ | ||
397 | i = ifc.ifc_len; | ||
398 | i = ((i / sizeof(struct ifreq)) * sizeof(struct ifreq32)); | ||
399 | ifc32.ifc_len = i; | ||
400 | } else { | ||
401 | ifc32.ifc_len = i; | ||
402 | } | ||
403 | if (copy_to_user(compat_ptr(arg), &ifc32, sizeof(struct ifconf32))) | ||
404 | return -EFAULT; | ||
405 | |||
406 | return 0; | ||
407 | } | ||
408 | |||
409 | static int ethtool_ioctl(unsigned int fd, unsigned int cmd, unsigned long arg) | ||
410 | { | ||
411 | struct ifreq __user *ifr; | ||
412 | struct ifreq32 __user *ifr32; | ||
413 | u32 data; | ||
414 | void __user *datap; | ||
415 | |||
416 | ifr = compat_alloc_user_space(sizeof(*ifr)); | ||
417 | ifr32 = compat_ptr(arg); | ||
418 | |||
419 | if (copy_in_user(&ifr->ifr_name, &ifr32->ifr_name, IFNAMSIZ)) | ||
420 | return -EFAULT; | ||
421 | |||
422 | if (get_user(data, &ifr32->ifr_ifru.ifru_data)) | ||
423 | return -EFAULT; | ||
424 | |||
425 | datap = compat_ptr(data); | ||
426 | if (put_user(datap, &ifr->ifr_ifru.ifru_data)) | ||
427 | return -EFAULT; | ||
428 | |||
429 | return sys_ioctl(fd, cmd, (unsigned long) ifr); | ||
430 | } | ||
431 | |||
432 | static int bond_ioctl(unsigned int fd, unsigned int cmd, unsigned long arg) | ||
433 | { | ||
434 | struct ifreq kifr; | ||
435 | struct ifreq __user *uifr; | ||
436 | struct ifreq32 __user *ifr32 = compat_ptr(arg); | ||
437 | mm_segment_t old_fs; | ||
438 | int err; | ||
439 | u32 data; | ||
440 | void __user *datap; | ||
441 | |||
442 | switch (cmd) { | ||
443 | case SIOCBONDENSLAVE: | ||
444 | case SIOCBONDRELEASE: | ||
445 | case SIOCBONDSETHWADDR: | ||
446 | case SIOCBONDCHANGEACTIVE: | ||
447 | if (copy_from_user(&kifr, ifr32, sizeof(struct ifreq32))) | ||
448 | return -EFAULT; | ||
449 | |||
450 | old_fs = get_fs(); | ||
451 | set_fs (KERNEL_DS); | ||
452 | err = sys_ioctl (fd, cmd, (unsigned long)&kifr); | ||
453 | set_fs (old_fs); | ||
454 | |||
455 | return err; | ||
456 | case SIOCBONDSLAVEINFOQUERY: | ||
457 | case SIOCBONDINFOQUERY: | ||
458 | uifr = compat_alloc_user_space(sizeof(*uifr)); | ||
459 | if (copy_in_user(&uifr->ifr_name, &ifr32->ifr_name, IFNAMSIZ)) | ||
460 | return -EFAULT; | ||
461 | |||
462 | if (get_user(data, &ifr32->ifr_ifru.ifru_data)) | ||
463 | return -EFAULT; | ||
464 | |||
465 | datap = compat_ptr(data); | ||
466 | if (put_user(datap, &uifr->ifr_ifru.ifru_data)) | ||
467 | return -EFAULT; | ||
468 | |||
469 | return sys_ioctl (fd, cmd, (unsigned long)uifr); | ||
470 | default: | ||
471 | return -EINVAL; | ||
472 | }; | ||
473 | } | ||
474 | |||
475 | static int siocdevprivate_ioctl(unsigned int fd, unsigned int cmd, unsigned long arg) | ||
476 | { | ||
477 | struct ifreq __user *u_ifreq64; | ||
478 | struct ifreq32 __user *u_ifreq32 = compat_ptr(arg); | ||
479 | char tmp_buf[IFNAMSIZ]; | ||
480 | void __user *data64; | ||
481 | u32 data32; | ||
482 | |||
483 | if (copy_from_user(&tmp_buf[0], &(u_ifreq32->ifr_ifrn.ifrn_name[0]), | ||
484 | IFNAMSIZ)) | ||
485 | return -EFAULT; | ||
486 | if (__get_user(data32, &u_ifreq32->ifr_ifru.ifru_data)) | ||
487 | return -EFAULT; | ||
488 | data64 = compat_ptr(data32); | ||
489 | |||
490 | u_ifreq64 = compat_alloc_user_space(sizeof(*u_ifreq64)); | ||
491 | |||
492 | /* Don't check these user accesses, just let that get trapped | ||
493 | * in the ioctl handler instead. | ||
494 | */ | ||
495 | if (copy_to_user(&u_ifreq64->ifr_ifrn.ifrn_name[0], &tmp_buf[0], | ||
496 | IFNAMSIZ)) | ||
497 | return -EFAULT; | ||
498 | if (__put_user(data64, &u_ifreq64->ifr_ifru.ifru_data)) | ||
499 | return -EFAULT; | ||
500 | |||
501 | return sys_ioctl(fd, cmd, (unsigned long) u_ifreq64); | ||
502 | } | ||
503 | |||
504 | static int dev_ifsioc(unsigned int fd, unsigned int cmd, unsigned long arg) | ||
505 | { | ||
506 | struct ifreq ifr; | ||
507 | struct ifreq32 __user *uifr32; | ||
508 | struct ifmap32 __user *uifmap32; | ||
509 | mm_segment_t old_fs; | ||
510 | int err; | ||
511 | |||
512 | uifr32 = compat_ptr(arg); | ||
513 | uifmap32 = &uifr32->ifr_ifru.ifru_map; | ||
514 | switch (cmd) { | ||
515 | case SIOCSIFMAP: | ||
516 | err = copy_from_user(&ifr, uifr32, sizeof(ifr.ifr_name)); | ||
517 | err |= __get_user(ifr.ifr_map.mem_start, &uifmap32->mem_start); | ||
518 | err |= __get_user(ifr.ifr_map.mem_end, &uifmap32->mem_end); | ||
519 | err |= __get_user(ifr.ifr_map.base_addr, &uifmap32->base_addr); | ||
520 | err |= __get_user(ifr.ifr_map.irq, &uifmap32->irq); | ||
521 | err |= __get_user(ifr.ifr_map.dma, &uifmap32->dma); | ||
522 | err |= __get_user(ifr.ifr_map.port, &uifmap32->port); | ||
523 | if (err) | ||
524 | return -EFAULT; | ||
525 | break; | ||
526 | case SIOCSHWTSTAMP: | ||
527 | if (copy_from_user(&ifr, uifr32, sizeof(*uifr32))) | ||
528 | return -EFAULT; | ||
529 | ifr.ifr_data = compat_ptr(uifr32->ifr_ifru.ifru_data); | ||
530 | break; | ||
531 | default: | ||
532 | if (copy_from_user(&ifr, uifr32, sizeof(*uifr32))) | ||
533 | return -EFAULT; | ||
534 | break; | ||
535 | } | ||
536 | old_fs = get_fs(); | ||
537 | set_fs (KERNEL_DS); | ||
538 | err = sys_ioctl (fd, cmd, (unsigned long)&ifr); | ||
539 | set_fs (old_fs); | ||
540 | if (!err) { | ||
541 | switch (cmd) { | ||
542 | /* TUNSETIFF is defined as _IOW, it should be _IORW | ||
543 | * as the data is copied back to user space, but that | ||
544 | * cannot be fixed without breaking all existing apps. | ||
545 | */ | ||
546 | case TUNSETIFF: | ||
547 | case TUNGETIFF: | ||
548 | case SIOCGIFFLAGS: | ||
549 | case SIOCGIFMETRIC: | ||
550 | case SIOCGIFMTU: | ||
551 | case SIOCGIFMEM: | ||
552 | case SIOCGIFHWADDR: | ||
553 | case SIOCGIFINDEX: | ||
554 | case SIOCGIFADDR: | ||
555 | case SIOCGIFBRDADDR: | ||
556 | case SIOCGIFDSTADDR: | ||
557 | case SIOCGIFNETMASK: | ||
558 | case SIOCGIFTXQLEN: | ||
559 | if (copy_to_user(uifr32, &ifr, sizeof(*uifr32))) | ||
560 | return -EFAULT; | ||
561 | break; | ||
562 | case SIOCGIFMAP: | ||
563 | err = copy_to_user(uifr32, &ifr, sizeof(ifr.ifr_name)); | ||
564 | err |= __put_user(ifr.ifr_map.mem_start, &uifmap32->mem_start); | ||
565 | err |= __put_user(ifr.ifr_map.mem_end, &uifmap32->mem_end); | ||
566 | err |= __put_user(ifr.ifr_map.base_addr, &uifmap32->base_addr); | ||
567 | err |= __put_user(ifr.ifr_map.irq, &uifmap32->irq); | ||
568 | err |= __put_user(ifr.ifr_map.dma, &uifmap32->dma); | ||
569 | err |= __put_user(ifr.ifr_map.port, &uifmap32->port); | ||
570 | if (err) | ||
571 | err = -EFAULT; | ||
572 | break; | ||
573 | } | ||
574 | } | ||
575 | return err; | ||
576 | } | ||
577 | |||
578 | struct rtentry32 { | ||
579 | u32 rt_pad1; | ||
580 | struct sockaddr rt_dst; /* target address */ | ||
581 | struct sockaddr rt_gateway; /* gateway addr (RTF_GATEWAY) */ | ||
582 | struct sockaddr rt_genmask; /* target network mask (IP) */ | ||
583 | unsigned short rt_flags; | ||
584 | short rt_pad2; | ||
585 | u32 rt_pad3; | ||
586 | unsigned char rt_tos; | ||
587 | unsigned char rt_class; | ||
588 | short rt_pad4; | ||
589 | short rt_metric; /* +1 for binary compatibility! */ | ||
590 | /* char * */ u32 rt_dev; /* forcing the device at add */ | ||
591 | u32 rt_mtu; /* per route MTU/Window */ | ||
592 | u32 rt_window; /* Window clamping */ | ||
593 | unsigned short rt_irtt; /* Initial RTT */ | ||
594 | |||
595 | }; | ||
596 | |||
597 | struct in6_rtmsg32 { | ||
598 | struct in6_addr rtmsg_dst; | ||
599 | struct in6_addr rtmsg_src; | ||
600 | struct in6_addr rtmsg_gateway; | ||
601 | u32 rtmsg_type; | ||
602 | u16 rtmsg_dst_len; | ||
603 | u16 rtmsg_src_len; | ||
604 | u32 rtmsg_metric; | ||
605 | u32 rtmsg_info; | ||
606 | u32 rtmsg_flags; | ||
607 | s32 rtmsg_ifindex; | ||
608 | }; | ||
609 | |||
610 | static int routing_ioctl(unsigned int fd, unsigned int cmd, unsigned long arg) | ||
611 | { | ||
612 | int ret; | ||
613 | void *r = NULL; | ||
614 | struct in6_rtmsg r6; | ||
615 | struct rtentry r4; | ||
616 | char devname[16]; | ||
617 | u32 rtdev; | ||
618 | mm_segment_t old_fs = get_fs(); | ||
619 | |||
620 | struct socket *mysock = sockfd_lookup(fd, &ret); | ||
621 | |||
622 | if (mysock && mysock->sk && mysock->sk->sk_family == AF_INET6) { /* ipv6 */ | ||
623 | struct in6_rtmsg32 __user *ur6 = compat_ptr(arg); | ||
624 | ret = copy_from_user (&r6.rtmsg_dst, &(ur6->rtmsg_dst), | ||
625 | 3 * sizeof(struct in6_addr)); | ||
626 | ret |= __get_user (r6.rtmsg_type, &(ur6->rtmsg_type)); | ||
627 | ret |= __get_user (r6.rtmsg_dst_len, &(ur6->rtmsg_dst_len)); | ||
628 | ret |= __get_user (r6.rtmsg_src_len, &(ur6->rtmsg_src_len)); | ||
629 | ret |= __get_user (r6.rtmsg_metric, &(ur6->rtmsg_metric)); | ||
630 | ret |= __get_user (r6.rtmsg_info, &(ur6->rtmsg_info)); | ||
631 | ret |= __get_user (r6.rtmsg_flags, &(ur6->rtmsg_flags)); | ||
632 | ret |= __get_user (r6.rtmsg_ifindex, &(ur6->rtmsg_ifindex)); | ||
633 | |||
634 | r = (void *) &r6; | ||
635 | } else { /* ipv4 */ | ||
636 | struct rtentry32 __user *ur4 = compat_ptr(arg); | ||
637 | ret = copy_from_user (&r4.rt_dst, &(ur4->rt_dst), | ||
638 | 3 * sizeof(struct sockaddr)); | ||
639 | ret |= __get_user (r4.rt_flags, &(ur4->rt_flags)); | ||
640 | ret |= __get_user (r4.rt_metric, &(ur4->rt_metric)); | ||
641 | ret |= __get_user (r4.rt_mtu, &(ur4->rt_mtu)); | ||
642 | ret |= __get_user (r4.rt_window, &(ur4->rt_window)); | ||
643 | ret |= __get_user (r4.rt_irtt, &(ur4->rt_irtt)); | ||
644 | ret |= __get_user (rtdev, &(ur4->rt_dev)); | ||
645 | if (rtdev) { | ||
646 | ret |= copy_from_user (devname, compat_ptr(rtdev), 15); | ||
647 | r4.rt_dev = devname; devname[15] = 0; | ||
648 | } else | ||
649 | r4.rt_dev = NULL; | ||
650 | |||
651 | r = (void *) &r4; | ||
652 | } | ||
653 | |||
654 | if (ret) { | ||
655 | ret = -EFAULT; | ||
656 | goto out; | ||
657 | } | ||
658 | |||
659 | set_fs (KERNEL_DS); | ||
660 | ret = sys_ioctl (fd, cmd, (unsigned long) r); | ||
661 | set_fs (old_fs); | ||
662 | |||
663 | out: | ||
664 | if (mysock) | ||
665 | sockfd_put(mysock); | ||
666 | |||
667 | return ret; | ||
668 | } | ||
669 | #endif | ||
670 | |||
671 | #ifdef CONFIG_BLOCK | 249 | #ifdef CONFIG_BLOCK |
672 | typedef struct sg_io_hdr32 { | 250 | typedef struct sg_io_hdr32 { |
673 | compat_int_t interface_id; /* [i] 'S' for SCSI generic (required) */ | 251 | compat_int_t interface_id; /* [i] 'S' for SCSI generic (required) */ |
@@ -1212,170 +790,6 @@ static int do_smb_getmountuid(unsigned int fd, unsigned int cmd, unsigned long a | |||
1212 | return err; | 790 | return err; |
1213 | } | 791 | } |
1214 | 792 | ||
1215 | struct atmif_sioc32 { | ||
1216 | compat_int_t number; | ||
1217 | compat_int_t length; | ||
1218 | compat_caddr_t arg; | ||
1219 | }; | ||
1220 | |||
1221 | struct atm_iobuf32 { | ||
1222 | compat_int_t length; | ||
1223 | compat_caddr_t buffer; | ||
1224 | }; | ||
1225 | |||
1226 | #define ATM_GETLINKRATE32 _IOW('a', ATMIOC_ITF+1, struct atmif_sioc32) | ||
1227 | #define ATM_GETNAMES32 _IOW('a', ATMIOC_ITF+3, struct atm_iobuf32) | ||
1228 | #define ATM_GETTYPE32 _IOW('a', ATMIOC_ITF+4, struct atmif_sioc32) | ||
1229 | #define ATM_GETESI32 _IOW('a', ATMIOC_ITF+5, struct atmif_sioc32) | ||
1230 | #define ATM_GETADDR32 _IOW('a', ATMIOC_ITF+6, struct atmif_sioc32) | ||
1231 | #define ATM_RSTADDR32 _IOW('a', ATMIOC_ITF+7, struct atmif_sioc32) | ||
1232 | #define ATM_ADDADDR32 _IOW('a', ATMIOC_ITF+8, struct atmif_sioc32) | ||
1233 | #define ATM_DELADDR32 _IOW('a', ATMIOC_ITF+9, struct atmif_sioc32) | ||
1234 | #define ATM_GETCIRANGE32 _IOW('a', ATMIOC_ITF+10, struct atmif_sioc32) | ||
1235 | #define ATM_SETCIRANGE32 _IOW('a', ATMIOC_ITF+11, struct atmif_sioc32) | ||
1236 | #define ATM_SETESI32 _IOW('a', ATMIOC_ITF+12, struct atmif_sioc32) | ||
1237 | #define ATM_SETESIF32 _IOW('a', ATMIOC_ITF+13, struct atmif_sioc32) | ||
1238 | #define ATM_GETSTAT32 _IOW('a', ATMIOC_SARCOM+0, struct atmif_sioc32) | ||
1239 | #define ATM_GETSTATZ32 _IOW('a', ATMIOC_SARCOM+1, struct atmif_sioc32) | ||
1240 | #define ATM_GETLOOP32 _IOW('a', ATMIOC_SARCOM+2, struct atmif_sioc32) | ||
1241 | #define ATM_SETLOOP32 _IOW('a', ATMIOC_SARCOM+3, struct atmif_sioc32) | ||
1242 | #define ATM_QUERYLOOP32 _IOW('a', ATMIOC_SARCOM+4, struct atmif_sioc32) | ||
1243 | |||
1244 | static struct { | ||
1245 | unsigned int cmd32; | ||
1246 | unsigned int cmd; | ||
1247 | } atm_ioctl_map[] = { | ||
1248 | { ATM_GETLINKRATE32, ATM_GETLINKRATE }, | ||
1249 | { ATM_GETNAMES32, ATM_GETNAMES }, | ||
1250 | { ATM_GETTYPE32, ATM_GETTYPE }, | ||
1251 | { ATM_GETESI32, ATM_GETESI }, | ||
1252 | { ATM_GETADDR32, ATM_GETADDR }, | ||
1253 | { ATM_RSTADDR32, ATM_RSTADDR }, | ||
1254 | { ATM_ADDADDR32, ATM_ADDADDR }, | ||
1255 | { ATM_DELADDR32, ATM_DELADDR }, | ||
1256 | { ATM_GETCIRANGE32, ATM_GETCIRANGE }, | ||
1257 | { ATM_SETCIRANGE32, ATM_SETCIRANGE }, | ||
1258 | { ATM_SETESI32, ATM_SETESI }, | ||
1259 | { ATM_SETESIF32, ATM_SETESIF }, | ||
1260 | { ATM_GETSTAT32, ATM_GETSTAT }, | ||
1261 | { ATM_GETSTATZ32, ATM_GETSTATZ }, | ||
1262 | { ATM_GETLOOP32, ATM_GETLOOP }, | ||
1263 | { ATM_SETLOOP32, ATM_SETLOOP }, | ||
1264 | { ATM_QUERYLOOP32, ATM_QUERYLOOP } | ||
1265 | }; | ||
1266 | |||
1267 | #define NR_ATM_IOCTL ARRAY_SIZE(atm_ioctl_map) | ||
1268 | |||
1269 | static int do_atm_iobuf(unsigned int fd, unsigned int cmd, unsigned long arg) | ||
1270 | { | ||
1271 | struct atm_iobuf __user *iobuf; | ||
1272 | struct atm_iobuf32 __user *iobuf32; | ||
1273 | u32 data; | ||
1274 | void __user *datap; | ||
1275 | int len, err; | ||
1276 | |||
1277 | iobuf = compat_alloc_user_space(sizeof(*iobuf)); | ||
1278 | iobuf32 = compat_ptr(arg); | ||
1279 | |||
1280 | if (get_user(len, &iobuf32->length) || | ||
1281 | get_user(data, &iobuf32->buffer)) | ||
1282 | return -EFAULT; | ||
1283 | datap = compat_ptr(data); | ||
1284 | if (put_user(len, &iobuf->length) || | ||
1285 | put_user(datap, &iobuf->buffer)) | ||
1286 | return -EFAULT; | ||
1287 | |||
1288 | err = sys_ioctl(fd, cmd, (unsigned long)iobuf); | ||
1289 | |||
1290 | if (!err) { | ||
1291 | if (copy_in_user(&iobuf32->length, &iobuf->length, | ||
1292 | sizeof(int))) | ||
1293 | err = -EFAULT; | ||
1294 | } | ||
1295 | |||
1296 | return err; | ||
1297 | } | ||
1298 | |||
1299 | static int do_atmif_sioc(unsigned int fd, unsigned int cmd, unsigned long arg) | ||
1300 | { | ||
1301 | struct atmif_sioc __user *sioc; | ||
1302 | struct atmif_sioc32 __user *sioc32; | ||
1303 | u32 data; | ||
1304 | void __user *datap; | ||
1305 | int err; | ||
1306 | |||
1307 | sioc = compat_alloc_user_space(sizeof(*sioc)); | ||
1308 | sioc32 = compat_ptr(arg); | ||
1309 | |||
1310 | if (copy_in_user(&sioc->number, &sioc32->number, 2 * sizeof(int)) || | ||
1311 | get_user(data, &sioc32->arg)) | ||
1312 | return -EFAULT; | ||
1313 | datap = compat_ptr(data); | ||
1314 | if (put_user(datap, &sioc->arg)) | ||
1315 | return -EFAULT; | ||
1316 | |||
1317 | err = sys_ioctl(fd, cmd, (unsigned long) sioc); | ||
1318 | |||
1319 | if (!err) { | ||
1320 | if (copy_in_user(&sioc32->length, &sioc->length, | ||
1321 | sizeof(int))) | ||
1322 | err = -EFAULT; | ||
1323 | } | ||
1324 | return err; | ||
1325 | } | ||
1326 | |||
1327 | static int do_atm_ioctl(unsigned int fd, unsigned int cmd32, unsigned long arg) | ||
1328 | { | ||
1329 | int i; | ||
1330 | unsigned int cmd = 0; | ||
1331 | |||
1332 | switch (cmd32) { | ||
1333 | case SONET_GETSTAT: | ||
1334 | case SONET_GETSTATZ: | ||
1335 | case SONET_GETDIAG: | ||
1336 | case SONET_SETDIAG: | ||
1337 | case SONET_CLRDIAG: | ||
1338 | case SONET_SETFRAMING: | ||
1339 | case SONET_GETFRAMING: | ||
1340 | case SONET_GETFRSENSE: | ||
1341 | return do_atmif_sioc(fd, cmd32, arg); | ||
1342 | } | ||
1343 | |||
1344 | for (i = 0; i < NR_ATM_IOCTL; i++) { | ||
1345 | if (cmd32 == atm_ioctl_map[i].cmd32) { | ||
1346 | cmd = atm_ioctl_map[i].cmd; | ||
1347 | break; | ||
1348 | } | ||
1349 | } | ||
1350 | if (i == NR_ATM_IOCTL) | ||
1351 | return -EINVAL; | ||
1352 | |||
1353 | switch (cmd) { | ||
1354 | case ATM_GETNAMES: | ||
1355 | return do_atm_iobuf(fd, cmd, arg); | ||
1356 | |||
1357 | case ATM_GETLINKRATE: | ||
1358 | case ATM_GETTYPE: | ||
1359 | case ATM_GETESI: | ||
1360 | case ATM_GETADDR: | ||
1361 | case ATM_RSTADDR: | ||
1362 | case ATM_ADDADDR: | ||
1363 | case ATM_DELADDR: | ||
1364 | case ATM_GETCIRANGE: | ||
1365 | case ATM_SETCIRANGE: | ||
1366 | case ATM_SETESI: | ||
1367 | case ATM_SETESIF: | ||
1368 | case ATM_GETSTAT: | ||
1369 | case ATM_GETSTATZ: | ||
1370 | case ATM_GETLOOP: | ||
1371 | case ATM_SETLOOP: | ||
1372 | case ATM_QUERYLOOP: | ||
1373 | return do_atmif_sioc(fd, cmd, arg); | ||
1374 | } | ||
1375 | |||
1376 | return -EINVAL; | ||
1377 | } | ||
1378 | |||
1379 | static __used int | 793 | static __used int |
1380 | ret_einval(unsigned int fd, unsigned int cmd, unsigned long arg) | 794 | ret_einval(unsigned int fd, unsigned int cmd, unsigned long arg) |
1381 | { | 795 | { |
@@ -1718,21 +1132,6 @@ static int do_i2c_smbus_ioctl(unsigned int fd, unsigned int cmd, unsigned long a | |||
1718 | return sys_ioctl(fd, cmd, (unsigned long)tdata); | 1132 | return sys_ioctl(fd, cmd, (unsigned long)tdata); |
1719 | } | 1133 | } |
1720 | 1134 | ||
1721 | /* Since old style bridge ioctl's endup using SIOCDEVPRIVATE | ||
1722 | * for some operations; this forces use of the newer bridge-utils that | ||
1723 | * use compatible ioctls | ||
1724 | */ | ||
1725 | static int old_bridge_ioctl(unsigned int fd, unsigned int cmd, unsigned long arg) | ||
1726 | { | ||
1727 | u32 tmp; | ||
1728 | |||
1729 | if (get_user(tmp, (u32 __user *) arg)) | ||
1730 | return -EFAULT; | ||
1731 | if (tmp == BRCTL_GET_VERSION) | ||
1732 | return BRCTL_VERSION + 1; | ||
1733 | return -EINVAL; | ||
1734 | } | ||
1735 | |||
1736 | #define RTC_IRQP_READ32 _IOR('p', 0x0b, compat_ulong_t) | 1135 | #define RTC_IRQP_READ32 _IOR('p', 0x0b, compat_ulong_t) |
1737 | #define RTC_IRQP_SET32 _IOW('p', 0x0c, compat_ulong_t) | 1136 | #define RTC_IRQP_SET32 _IOW('p', 0x0c, compat_ulong_t) |
1738 | #define RTC_EPOCH_READ32 _IOR('p', 0x0d, compat_ulong_t) | 1137 | #define RTC_EPOCH_READ32 _IOR('p', 0x0d, compat_ulong_t) |
@@ -1979,18 +1378,6 @@ COMPATIBLE_IOCTL(SCSI_IOCTL_SEND_COMMAND) | |||
1979 | COMPATIBLE_IOCTL(SCSI_IOCTL_PROBE_HOST) | 1378 | COMPATIBLE_IOCTL(SCSI_IOCTL_PROBE_HOST) |
1980 | COMPATIBLE_IOCTL(SCSI_IOCTL_GET_PCI) | 1379 | COMPATIBLE_IOCTL(SCSI_IOCTL_GET_PCI) |
1981 | #endif | 1380 | #endif |
1982 | /* Big T */ | ||
1983 | COMPATIBLE_IOCTL(TUNSETNOCSUM) | ||
1984 | COMPATIBLE_IOCTL(TUNSETDEBUG) | ||
1985 | COMPATIBLE_IOCTL(TUNSETPERSIST) | ||
1986 | COMPATIBLE_IOCTL(TUNSETOWNER) | ||
1987 | COMPATIBLE_IOCTL(TUNSETLINK) | ||
1988 | COMPATIBLE_IOCTL(TUNSETGROUP) | ||
1989 | COMPATIBLE_IOCTL(TUNGETFEATURES) | ||
1990 | COMPATIBLE_IOCTL(TUNSETOFFLOAD) | ||
1991 | COMPATIBLE_IOCTL(TUNSETTXFILTER) | ||
1992 | COMPATIBLE_IOCTL(TUNGETSNDBUF) | ||
1993 | COMPATIBLE_IOCTL(TUNSETSNDBUF) | ||
1994 | /* Big V */ | 1381 | /* Big V */ |
1995 | COMPATIBLE_IOCTL(VT_SETMODE) | 1382 | COMPATIBLE_IOCTL(VT_SETMODE) |
1996 | COMPATIBLE_IOCTL(VT_GETMODE) | 1383 | COMPATIBLE_IOCTL(VT_GETMODE) |
@@ -2032,30 +1419,6 @@ COMPATIBLE_IOCTL(_IOW('p', 21, int[7])) /* RTCSET */ | |||
2032 | COMPATIBLE_IOCTL(MTIOCTOP) | 1419 | COMPATIBLE_IOCTL(MTIOCTOP) |
2033 | /* Socket level stuff */ | 1420 | /* Socket level stuff */ |
2034 | COMPATIBLE_IOCTL(FIOQSIZE) | 1421 | COMPATIBLE_IOCTL(FIOQSIZE) |
2035 | COMPATIBLE_IOCTL(FIOSETOWN) | ||
2036 | COMPATIBLE_IOCTL(SIOCSPGRP) | ||
2037 | COMPATIBLE_IOCTL(FIOGETOWN) | ||
2038 | COMPATIBLE_IOCTL(SIOCGPGRP) | ||
2039 | COMPATIBLE_IOCTL(SIOCATMARK) | ||
2040 | COMPATIBLE_IOCTL(SIOCSIFLINK) | ||
2041 | COMPATIBLE_IOCTL(SIOCSIFENCAP) | ||
2042 | COMPATIBLE_IOCTL(SIOCGIFENCAP) | ||
2043 | COMPATIBLE_IOCTL(SIOCSIFNAME) | ||
2044 | COMPATIBLE_IOCTL(SIOCSARP) | ||
2045 | COMPATIBLE_IOCTL(SIOCGARP) | ||
2046 | COMPATIBLE_IOCTL(SIOCDARP) | ||
2047 | COMPATIBLE_IOCTL(SIOCSRARP) | ||
2048 | COMPATIBLE_IOCTL(SIOCGRARP) | ||
2049 | COMPATIBLE_IOCTL(SIOCDRARP) | ||
2050 | COMPATIBLE_IOCTL(SIOCADDDLCI) | ||
2051 | COMPATIBLE_IOCTL(SIOCDELDLCI) | ||
2052 | COMPATIBLE_IOCTL(SIOCGMIIPHY) | ||
2053 | COMPATIBLE_IOCTL(SIOCGMIIREG) | ||
2054 | COMPATIBLE_IOCTL(SIOCSMIIREG) | ||
2055 | COMPATIBLE_IOCTL(SIOCGIFVLAN) | ||
2056 | COMPATIBLE_IOCTL(SIOCSIFVLAN) | ||
2057 | COMPATIBLE_IOCTL(SIOCBRADDBR) | ||
2058 | COMPATIBLE_IOCTL(SIOCBRDELBR) | ||
2059 | #ifdef CONFIG_BLOCK | 1422 | #ifdef CONFIG_BLOCK |
2060 | /* SG stuff */ | 1423 | /* SG stuff */ |
2061 | COMPATIBLE_IOCTL(SG_SET_TIMEOUT) | 1424 | COMPATIBLE_IOCTL(SG_SET_TIMEOUT) |
@@ -2311,22 +1674,6 @@ COMPATIBLE_IOCTL(RAW_SETBIND) | |||
2311 | COMPATIBLE_IOCTL(RAW_GETBIND) | 1674 | COMPATIBLE_IOCTL(RAW_GETBIND) |
2312 | /* SMB ioctls which do not need any translations */ | 1675 | /* SMB ioctls which do not need any translations */ |
2313 | COMPATIBLE_IOCTL(SMB_IOC_NEWCONN) | 1676 | COMPATIBLE_IOCTL(SMB_IOC_NEWCONN) |
2314 | /* Little a */ | ||
2315 | COMPATIBLE_IOCTL(ATMSIGD_CTRL) | ||
2316 | COMPATIBLE_IOCTL(ATMARPD_CTRL) | ||
2317 | COMPATIBLE_IOCTL(ATMLEC_CTRL) | ||
2318 | COMPATIBLE_IOCTL(ATMLEC_MCAST) | ||
2319 | COMPATIBLE_IOCTL(ATMLEC_DATA) | ||
2320 | COMPATIBLE_IOCTL(ATM_SETSC) | ||
2321 | COMPATIBLE_IOCTL(SIOCSIFATMTCP) | ||
2322 | COMPATIBLE_IOCTL(SIOCMKCLIP) | ||
2323 | COMPATIBLE_IOCTL(ATMARP_MKIP) | ||
2324 | COMPATIBLE_IOCTL(ATMARP_SETENTRY) | ||
2325 | COMPATIBLE_IOCTL(ATMARP_ENCAP) | ||
2326 | COMPATIBLE_IOCTL(ATMTCP_CREATE) | ||
2327 | COMPATIBLE_IOCTL(ATMTCP_REMOVE) | ||
2328 | COMPATIBLE_IOCTL(ATMMPC_CTRL) | ||
2329 | COMPATIBLE_IOCTL(ATMMPC_DATA) | ||
2330 | /* Watchdog */ | 1677 | /* Watchdog */ |
2331 | COMPATIBLE_IOCTL(WDIOC_GETSUPPORT) | 1678 | COMPATIBLE_IOCTL(WDIOC_GETSUPPORT) |
2332 | COMPATIBLE_IOCTL(WDIOC_GETSTATUS) | 1679 | COMPATIBLE_IOCTL(WDIOC_GETSTATUS) |
@@ -2532,63 +1879,6 @@ COMPATIBLE_IOCTL(JSIOCGBUTTONS) | |||
2532 | COMPATIBLE_IOCTL(JSIOCGNAME(0)) | 1879 | COMPATIBLE_IOCTL(JSIOCGNAME(0)) |
2533 | 1880 | ||
2534 | /* now things that need handlers */ | 1881 | /* now things that need handlers */ |
2535 | #ifdef CONFIG_NET | ||
2536 | HANDLE_IOCTL(SIOCGIFNAME, dev_ifname32) | ||
2537 | HANDLE_IOCTL(SIOCGIFCONF, dev_ifconf) | ||
2538 | HANDLE_IOCTL(SIOCGIFFLAGS, dev_ifsioc) | ||
2539 | HANDLE_IOCTL(SIOCSIFFLAGS, dev_ifsioc) | ||
2540 | HANDLE_IOCTL(SIOCGIFMETRIC, dev_ifsioc) | ||
2541 | HANDLE_IOCTL(SIOCSIFMETRIC, dev_ifsioc) | ||
2542 | HANDLE_IOCTL(SIOCGIFMTU, dev_ifsioc) | ||
2543 | HANDLE_IOCTL(SIOCSIFMTU, dev_ifsioc) | ||
2544 | HANDLE_IOCTL(SIOCGIFMEM, dev_ifsioc) | ||
2545 | HANDLE_IOCTL(SIOCSIFMEM, dev_ifsioc) | ||
2546 | HANDLE_IOCTL(SIOCGIFHWADDR, dev_ifsioc) | ||
2547 | HANDLE_IOCTL(SIOCSIFHWADDR, dev_ifsioc) | ||
2548 | HANDLE_IOCTL(SIOCADDMULTI, dev_ifsioc) | ||
2549 | HANDLE_IOCTL(SIOCDELMULTI, dev_ifsioc) | ||
2550 | HANDLE_IOCTL(SIOCGIFINDEX, dev_ifsioc) | ||
2551 | HANDLE_IOCTL(SIOCGIFMAP, dev_ifsioc) | ||
2552 | HANDLE_IOCTL(SIOCSIFMAP, dev_ifsioc) | ||
2553 | HANDLE_IOCTL(SIOCGIFADDR, dev_ifsioc) | ||
2554 | HANDLE_IOCTL(SIOCSIFADDR, dev_ifsioc) | ||
2555 | HANDLE_IOCTL(SIOCSIFHWBROADCAST, dev_ifsioc) | ||
2556 | HANDLE_IOCTL(SIOCSHWTSTAMP, dev_ifsioc) | ||
2557 | |||
2558 | /* ioctls used by appletalk ddp.c */ | ||
2559 | HANDLE_IOCTL(SIOCATALKDIFADDR, dev_ifsioc) | ||
2560 | HANDLE_IOCTL(SIOCDIFADDR, dev_ifsioc) | ||
2561 | HANDLE_IOCTL(SIOCSARP, dev_ifsioc) | ||
2562 | HANDLE_IOCTL(SIOCDARP, dev_ifsioc) | ||
2563 | |||
2564 | HANDLE_IOCTL(SIOCGIFBRDADDR, dev_ifsioc) | ||
2565 | HANDLE_IOCTL(SIOCSIFBRDADDR, dev_ifsioc) | ||
2566 | HANDLE_IOCTL(SIOCGIFDSTADDR, dev_ifsioc) | ||
2567 | HANDLE_IOCTL(SIOCSIFDSTADDR, dev_ifsioc) | ||
2568 | HANDLE_IOCTL(SIOCGIFNETMASK, dev_ifsioc) | ||
2569 | HANDLE_IOCTL(SIOCSIFNETMASK, dev_ifsioc) | ||
2570 | HANDLE_IOCTL(SIOCSIFPFLAGS, dev_ifsioc) | ||
2571 | HANDLE_IOCTL(SIOCGIFPFLAGS, dev_ifsioc) | ||
2572 | HANDLE_IOCTL(SIOCGIFTXQLEN, dev_ifsioc) | ||
2573 | HANDLE_IOCTL(SIOCSIFTXQLEN, dev_ifsioc) | ||
2574 | HANDLE_IOCTL(TUNSETIFF, dev_ifsioc) | ||
2575 | HANDLE_IOCTL(TUNGETIFF, dev_ifsioc) | ||
2576 | HANDLE_IOCTL(SIOCETHTOOL, ethtool_ioctl) | ||
2577 | HANDLE_IOCTL(SIOCBONDENSLAVE, bond_ioctl) | ||
2578 | HANDLE_IOCTL(SIOCBONDRELEASE, bond_ioctl) | ||
2579 | HANDLE_IOCTL(SIOCBONDSETHWADDR, bond_ioctl) | ||
2580 | HANDLE_IOCTL(SIOCBONDSLAVEINFOQUERY, bond_ioctl) | ||
2581 | HANDLE_IOCTL(SIOCBONDINFOQUERY, bond_ioctl) | ||
2582 | HANDLE_IOCTL(SIOCBONDCHANGEACTIVE, bond_ioctl) | ||
2583 | HANDLE_IOCTL(SIOCADDRT, routing_ioctl) | ||
2584 | HANDLE_IOCTL(SIOCDELRT, routing_ioctl) | ||
2585 | HANDLE_IOCTL(SIOCBRADDIF, dev_ifsioc) | ||
2586 | HANDLE_IOCTL(SIOCBRDELIF, dev_ifsioc) | ||
2587 | /* Note SIOCRTMSG is no longer, so this is safe and * the user would have seen just an -EINVAL anyways. */ | ||
2588 | HANDLE_IOCTL(SIOCRTMSG, ret_einval) | ||
2589 | HANDLE_IOCTL(SIOCGSTAMP, do_siocgstamp) | ||
2590 | HANDLE_IOCTL(SIOCGSTAMPNS, do_siocgstampns) | ||
2591 | #endif | ||
2592 | #ifdef CONFIG_BLOCK | 1882 | #ifdef CONFIG_BLOCK |
2593 | HANDLE_IOCTL(SG_IO,sg_ioctl_trans) | 1883 | HANDLE_IOCTL(SG_IO,sg_ioctl_trans) |
2594 | HANDLE_IOCTL(SG_GET_REQUEST_TABLE, sg_grt_trans) | 1884 | HANDLE_IOCTL(SG_GET_REQUEST_TABLE, sg_grt_trans) |
@@ -2613,31 +1903,6 @@ HANDLE_IOCTL(KDFONTOP, do_kdfontop_ioctl) | |||
2613 | /* One SMB ioctl needs translations. */ | 1903 | /* One SMB ioctl needs translations. */ |
2614 | #define SMB_IOC_GETMOUNTUID_32 _IOR('u', 1, compat_uid_t) | 1904 | #define SMB_IOC_GETMOUNTUID_32 _IOR('u', 1, compat_uid_t) |
2615 | HANDLE_IOCTL(SMB_IOC_GETMOUNTUID_32, do_smb_getmountuid) | 1905 | HANDLE_IOCTL(SMB_IOC_GETMOUNTUID_32, do_smb_getmountuid) |
2616 | HANDLE_IOCTL(ATM_GETLINKRATE32, do_atm_ioctl) | ||
2617 | HANDLE_IOCTL(ATM_GETNAMES32, do_atm_ioctl) | ||
2618 | HANDLE_IOCTL(ATM_GETTYPE32, do_atm_ioctl) | ||
2619 | HANDLE_IOCTL(ATM_GETESI32, do_atm_ioctl) | ||
2620 | HANDLE_IOCTL(ATM_GETADDR32, do_atm_ioctl) | ||
2621 | HANDLE_IOCTL(ATM_RSTADDR32, do_atm_ioctl) | ||
2622 | HANDLE_IOCTL(ATM_ADDADDR32, do_atm_ioctl) | ||
2623 | HANDLE_IOCTL(ATM_DELADDR32, do_atm_ioctl) | ||
2624 | HANDLE_IOCTL(ATM_GETCIRANGE32, do_atm_ioctl) | ||
2625 | HANDLE_IOCTL(ATM_SETCIRANGE32, do_atm_ioctl) | ||
2626 | HANDLE_IOCTL(ATM_SETESI32, do_atm_ioctl) | ||
2627 | HANDLE_IOCTL(ATM_SETESIF32, do_atm_ioctl) | ||
2628 | HANDLE_IOCTL(ATM_GETSTAT32, do_atm_ioctl) | ||
2629 | HANDLE_IOCTL(ATM_GETSTATZ32, do_atm_ioctl) | ||
2630 | HANDLE_IOCTL(ATM_GETLOOP32, do_atm_ioctl) | ||
2631 | HANDLE_IOCTL(ATM_SETLOOP32, do_atm_ioctl) | ||
2632 | HANDLE_IOCTL(ATM_QUERYLOOP32, do_atm_ioctl) | ||
2633 | HANDLE_IOCTL(SONET_GETSTAT, do_atm_ioctl) | ||
2634 | HANDLE_IOCTL(SONET_GETSTATZ, do_atm_ioctl) | ||
2635 | HANDLE_IOCTL(SONET_GETDIAG, do_atm_ioctl) | ||
2636 | HANDLE_IOCTL(SONET_SETDIAG, do_atm_ioctl) | ||
2637 | HANDLE_IOCTL(SONET_CLRDIAG, do_atm_ioctl) | ||
2638 | HANDLE_IOCTL(SONET_SETFRAMING, do_atm_ioctl) | ||
2639 | HANDLE_IOCTL(SONET_GETFRAMING, do_atm_ioctl) | ||
2640 | HANDLE_IOCTL(SONET_GETFRSENSE, do_atm_ioctl) | ||
2641 | /* block stuff */ | 1906 | /* block stuff */ |
2642 | #ifdef CONFIG_BLOCK | 1907 | #ifdef CONFIG_BLOCK |
2643 | /* loop */ | 1908 | /* loop */ |
@@ -2672,11 +1937,7 @@ COMPATIBLE_IOCTL(USBDEVFS_IOCTL32) | |||
2672 | HANDLE_IOCTL(I2C_FUNCS, w_long) | 1937 | HANDLE_IOCTL(I2C_FUNCS, w_long) |
2673 | HANDLE_IOCTL(I2C_RDWR, do_i2c_rdwr_ioctl) | 1938 | HANDLE_IOCTL(I2C_RDWR, do_i2c_rdwr_ioctl) |
2674 | HANDLE_IOCTL(I2C_SMBUS, do_i2c_smbus_ioctl) | 1939 | HANDLE_IOCTL(I2C_SMBUS, do_i2c_smbus_ioctl) |
2675 | /* bridge */ | ||
2676 | HANDLE_IOCTL(SIOCSIFBR, old_bridge_ioctl) | ||
2677 | HANDLE_IOCTL(SIOCGIFBR, old_bridge_ioctl) | ||
2678 | /* Not implemented in the native kernel */ | 1940 | /* Not implemented in the native kernel */ |
2679 | IGNORE_IOCTL(SIOCGIFCOUNT) | ||
2680 | HANDLE_IOCTL(RTC_IRQP_READ32, rtc_ioctl) | 1941 | HANDLE_IOCTL(RTC_IRQP_READ32, rtc_ioctl) |
2681 | HANDLE_IOCTL(RTC_IRQP_SET32, rtc_ioctl) | 1942 | HANDLE_IOCTL(RTC_IRQP_SET32, rtc_ioctl) |
2682 | HANDLE_IOCTL(RTC_EPOCH_READ32, rtc_ioctl) | 1943 | HANDLE_IOCTL(RTC_EPOCH_READ32, rtc_ioctl) |
@@ -2831,12 +2092,6 @@ asmlinkage long compat_sys_ioctl(unsigned int fd, unsigned int cmd, | |||
2831 | goto found_handler; | 2092 | goto found_handler; |
2832 | } | 2093 | } |
2833 | 2094 | ||
2834 | #ifdef CONFIG_NET | ||
2835 | if (S_ISSOCK(filp->f_path.dentry->d_inode->i_mode) && | ||
2836 | cmd >= SIOCDEVPRIVATE && cmd <= (SIOCDEVPRIVATE + 15)) { | ||
2837 | error = siocdevprivate_ioctl(fd, cmd, arg); | ||
2838 | } else | ||
2839 | #endif | ||
2840 | { | 2095 | { |
2841 | static int count; | 2096 | static int count; |
2842 | 2097 | ||
diff --git a/fs/ocfs2/cluster/netdebug.c b/fs/ocfs2/cluster/netdebug.c index da794bc07a6c..a3f150e52b02 100644 --- a/fs/ocfs2/cluster/netdebug.c +++ b/fs/ocfs2/cluster/netdebug.c | |||
@@ -294,10 +294,10 @@ static int sc_seq_show(struct seq_file *seq, void *v) | |||
294 | if (sc->sc_sock) { | 294 | if (sc->sc_sock) { |
295 | inet = inet_sk(sc->sc_sock->sk); | 295 | inet = inet_sk(sc->sc_sock->sk); |
296 | /* the stack's structs aren't sparse endian clean */ | 296 | /* the stack's structs aren't sparse endian clean */ |
297 | saddr = (__force __be32)inet->saddr; | 297 | saddr = (__force __be32)inet->inet_saddr; |
298 | daddr = (__force __be32)inet->daddr; | 298 | daddr = (__force __be32)inet->inet_daddr; |
299 | sport = (__force __be16)inet->sport; | 299 | sport = (__force __be16)inet->inet_sport; |
300 | dport = (__force __be16)inet->dport; | 300 | dport = (__force __be16)inet->inet_dport; |
301 | } | 301 | } |
302 | 302 | ||
303 | /* XXX sigh, inet-> doesn't have sparse annotation so any | 303 | /* XXX sigh, inet-> doesn't have sparse annotation so any |