compat_ioctl.c 73 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060206120622063206420652066206720682069207020712072207320742075207620772078207920802081208220832084208520862087208820892090209120922093209420952096209720982099210021012102210321042105210621072108210921102111211221132114211521162117211821192120212121222123212421252126212721282129213021312132213321342135213621372138213921402141214221432144214521462147214821492150215121522153215421552156215721582159216021612162216321642165216621672168216921702171217221732174217521762177217821792180218121822183218421852186218721882189219021912192219321942195219621972198219922002201220222032204220522062207220822092210221122122213221422152216221722182219222022212222222322242225222622272228222922302231223222332234223522362237223822392240224122422243224422452246224722482249225022512252225322542255225622572258225922602261226222632264226522662267226822692270227122722273227422752276227722782279228022812282228322842285228622872288228922902291229222932294229522962297229822992300230123022303230423052306230723082309231023112312231323142315231623172318231923202321232223232324232523262327232823292330233123322333233423352336233723382339234023412342234323442345234623472348234923502351235223532354235523562357235823592360236123622363236423652366236723682369237023712372237323742375237623772378237923802381238223832384238523862387238823892390239123922393239423952396239723982399240024012402240324042405240624072408240924102411241224132414241524162417241824192420242124222423242424252426242724282429243024312432243324342435243624372438243924402441244224432444244524462447244824492450245124522453245424552456245724582459246024612462246324642465246624672468246924702471247224732474247524762477247824792480248124822483248424852486248724882489249024912492249324942495249624972498249925002501250225032504250525062507250825092510251125122513251425152516251725182519252025212522252325242525252625272528252925302531253225332534253525362537253825392540254125422543254425452546254725482549255025512552255325542555255625572558255925602561256225632564256525662567256825692570257125722573257425752576257725782579258025812582258325842585258625872588258925902591259225932594259525962597259825992600260126022603260426052606260726082609261026112612261326142615261626172618261926202621
  1. /*
  2. * ioctl32.c: Conversion between 32bit and 64bit native ioctls.
  3. *
  4. * Copyright (C) 1997-2000 Jakub Jelinek (jakub@redhat.com)
  5. * Copyright (C) 1998 Eddie C. Dost (ecd@skynet.be)
  6. * Copyright (C) 2001,2002 Andi Kleen, SuSE Labs
  7. * Copyright (C) 2003 Pavel Machek (pavel@suse.cz)
  8. *
  9. * These routines maintain argument size conversion between 32bit and 64bit
  10. * ioctls.
  11. */
  12. #include <linux/types.h>
  13. #include <linux/compat.h>
  14. #include <linux/kernel.h>
  15. #include <linux/capability.h>
  16. #include <linux/compiler.h>
  17. #include <linux/sched.h>
  18. #include <linux/smp.h>
  19. #include <linux/smp_lock.h>
  20. #include <linux/ioctl.h>
  21. #include <linux/if.h>
  22. #include <linux/if_bridge.h>
  23. #include <linux/slab.h>
  24. #include <linux/hdreg.h>
  25. #include <linux/raid/md.h>
  26. #include <linux/kd.h>
  27. #include <linux/dirent.h>
  28. #include <linux/route.h>
  29. #include <linux/in6.h>
  30. #include <linux/ipv6_route.h>
  31. #include <linux/skbuff.h>
  32. #include <linux/netlink.h>
  33. #include <linux/vt.h>
  34. #include <linux/fs.h>
  35. #include <linux/file.h>
  36. #include <linux/fd.h>
  37. #include <linux/ppp_defs.h>
  38. #include <linux/if_ppp.h>
  39. #include <linux/if_pppox.h>
  40. #include <linux/mtio.h>
  41. #include <linux/cdrom.h>
  42. #include <linux/auto_fs.h>
  43. #include <linux/auto_fs4.h>
  44. #include <linux/tty.h>
  45. #include <linux/vt_kern.h>
  46. #include <linux/fb.h>
  47. #include <linux/videodev.h>
  48. #include <linux/netdevice.h>
  49. #include <linux/raw.h>
  50. #include <linux/smb_fs.h>
  51. #include <linux/blkpg.h>
  52. #include <linux/blkdev.h>
  53. #include <linux/elevator.h>
  54. #include <linux/rtc.h>
  55. #include <linux/pci.h>
  56. #include <linux/module.h>
  57. #include <linux/serial.h>
  58. #include <linux/if_tun.h>
  59. #include <linux/ctype.h>
  60. #include <linux/ioctl32.h>
  61. #include <linux/syscalls.h>
  62. #include <linux/i2c.h>
  63. #include <linux/i2c-dev.h>
  64. #include <linux/wireless.h>
  65. #include <linux/atalk.h>
  66. #include <linux/blktrace_api.h>
  67. #include <net/sock.h> /* siocdevprivate_ioctl */
  68. #include <net/bluetooth/bluetooth.h>
  69. #include <net/bluetooth/hci.h>
  70. #include <net/bluetooth/rfcomm.h>
  71. #include <linux/capi.h>
  72. #include <linux/gigaset_dev.h>
  73. #include <scsi/scsi.h>
  74. #include <scsi/scsi_ioctl.h>
  75. #include <scsi/sg.h>
  76. #include <asm/uaccess.h>
  77. #include <linux/ethtool.h>
  78. #include <linux/mii.h>
  79. #include <linux/if_bonding.h>
  80. #include <linux/watchdog.h>
  81. #include <linux/dm-ioctl.h>
  82. #include <linux/soundcard.h>
  83. #include <linux/lp.h>
  84. #include <linux/ppdev.h>
  85. #include <linux/atm.h>
  86. #include <linux/atmarp.h>
  87. #include <linux/atmclip.h>
  88. #include <linux/atmdev.h>
  89. #include <linux/atmioc.h>
  90. #include <linux/atmlec.h>
  91. #include <linux/atmmpc.h>
  92. #include <linux/atmsvc.h>
  93. #include <linux/atm_tcp.h>
  94. #include <linux/sonet.h>
  95. #include <linux/atm_suni.h>
  96. #include <linux/mtd/mtd.h>
  97. #include <linux/usb.h>
  98. #include <linux/usbdevice_fs.h>
  99. #include <linux/nbd.h>
  100. #include <linux/random.h>
  101. #include <linux/filter.h>
  102. #include <linux/pktcdvd.h>
  103. #include <linux/hiddev.h>
  104. #include <linux/dvb/audio.h>
  105. #include <linux/dvb/dmx.h>
  106. #include <linux/dvb/frontend.h>
  107. #include <linux/dvb/video.h>
  108. #include <linux/lp.h>
  109. static int do_ioctl32_pointer(unsigned int fd, unsigned int cmd,
  110. unsigned long arg, struct file *f)
  111. {
  112. return sys_ioctl(fd, cmd, (unsigned long)compat_ptr(arg));
  113. }
  114. static int w_long(unsigned int fd, unsigned int cmd, unsigned long arg)
  115. {
  116. mm_segment_t old_fs = get_fs();
  117. int err;
  118. unsigned long val;
  119. set_fs (KERNEL_DS);
  120. err = sys_ioctl(fd, cmd, (unsigned long)&val);
  121. set_fs (old_fs);
  122. if (!err && put_user(val, (u32 __user *)compat_ptr(arg)))
  123. return -EFAULT;
  124. return err;
  125. }
  126. static int rw_long(unsigned int fd, unsigned int cmd, unsigned long arg)
  127. {
  128. mm_segment_t old_fs = get_fs();
  129. u32 __user *argptr = compat_ptr(arg);
  130. int err;
  131. unsigned long val;
  132. if(get_user(val, argptr))
  133. return -EFAULT;
  134. set_fs (KERNEL_DS);
  135. err = sys_ioctl(fd, cmd, (unsigned long)&val);
  136. set_fs (old_fs);
  137. if (!err && put_user(val, argptr))
  138. return -EFAULT;
  139. return err;
  140. }
  141. struct compat_video_event {
  142. int32_t type;
  143. compat_time_t timestamp;
  144. union {
  145. video_size_t size;
  146. unsigned int frame_rate;
  147. } u;
  148. };
  149. static int do_video_get_event(unsigned int fd, unsigned int cmd, unsigned long arg)
  150. {
  151. struct video_event kevent;
  152. mm_segment_t old_fs = get_fs();
  153. int err;
  154. set_fs(KERNEL_DS);
  155. err = sys_ioctl(fd, cmd, (unsigned long) &kevent);
  156. set_fs(old_fs);
  157. if (!err) {
  158. struct compat_video_event __user *up = compat_ptr(arg);
  159. err = put_user(kevent.type, &up->type);
  160. err |= put_user(kevent.timestamp, &up->timestamp);
  161. err |= put_user(kevent.u.size.w, &up->u.size.w);
  162. err |= put_user(kevent.u.size.h, &up->u.size.h);
  163. err |= put_user(kevent.u.size.aspect_ratio,
  164. &up->u.size.aspect_ratio);
  165. if (err)
  166. err = -EFAULT;
  167. }
  168. return err;
  169. }
  170. struct compat_video_still_picture {
  171. compat_uptr_t iFrame;
  172. int32_t size;
  173. };
  174. static int do_video_stillpicture(unsigned int fd, unsigned int cmd, unsigned long arg)
  175. {
  176. struct compat_video_still_picture __user *up;
  177. struct video_still_picture __user *up_native;
  178. compat_uptr_t fp;
  179. int32_t size;
  180. int err;
  181. up = (struct compat_video_still_picture __user *) arg;
  182. err = get_user(fp, &up->iFrame);
  183. err |= get_user(size, &up->size);
  184. if (err)
  185. return -EFAULT;
  186. up_native =
  187. compat_alloc_user_space(sizeof(struct video_still_picture));
  188. err = put_user(compat_ptr(fp), &up_native->iFrame);
  189. err |= put_user(size, &up_native->size);
  190. if (err)
  191. return -EFAULT;
  192. err = sys_ioctl(fd, cmd, (unsigned long) up_native);
  193. return err;
  194. }
  195. struct compat_video_spu_palette {
  196. int length;
  197. compat_uptr_t palette;
  198. };
  199. static int do_video_set_spu_palette(unsigned int fd, unsigned int cmd, unsigned long arg)
  200. {
  201. struct compat_video_spu_palette __user *up;
  202. struct video_spu_palette __user *up_native;
  203. compat_uptr_t palp;
  204. int length, err;
  205. up = (struct compat_video_spu_palette __user *) arg;
  206. err = get_user(palp, &up->palette);
  207. err |= get_user(length, &up->length);
  208. up_native = compat_alloc_user_space(sizeof(struct video_spu_palette));
  209. err = put_user(compat_ptr(palp), &up_native->palette);
  210. err |= put_user(length, &up_native->length);
  211. if (err)
  212. return -EFAULT;
  213. err = sys_ioctl(fd, cmd, (unsigned long) up_native);
  214. return err;
  215. }
  216. #ifdef CONFIG_NET
  217. static int do_siocgstamp(unsigned int fd, unsigned int cmd, unsigned long arg)
  218. {
  219. struct compat_timeval __user *up = compat_ptr(arg);
  220. struct timeval ktv;
  221. mm_segment_t old_fs = get_fs();
  222. int err;
  223. set_fs(KERNEL_DS);
  224. err = sys_ioctl(fd, cmd, (unsigned long)&ktv);
  225. set_fs(old_fs);
  226. if(!err) {
  227. err = put_user(ktv.tv_sec, &up->tv_sec);
  228. err |= __put_user(ktv.tv_usec, &up->tv_usec);
  229. }
  230. return err;
  231. }
  232. struct ifmap32 {
  233. compat_ulong_t mem_start;
  234. compat_ulong_t mem_end;
  235. unsigned short base_addr;
  236. unsigned char irq;
  237. unsigned char dma;
  238. unsigned char port;
  239. };
  240. struct ifreq32 {
  241. #define IFHWADDRLEN 6
  242. #define IFNAMSIZ 16
  243. union {
  244. char ifrn_name[IFNAMSIZ]; /* if name, e.g. "en0" */
  245. } ifr_ifrn;
  246. union {
  247. struct sockaddr ifru_addr;
  248. struct sockaddr ifru_dstaddr;
  249. struct sockaddr ifru_broadaddr;
  250. struct sockaddr ifru_netmask;
  251. struct sockaddr ifru_hwaddr;
  252. short ifru_flags;
  253. compat_int_t ifru_ivalue;
  254. compat_int_t ifru_mtu;
  255. struct ifmap32 ifru_map;
  256. char ifru_slave[IFNAMSIZ]; /* Just fits the size */
  257. char ifru_newname[IFNAMSIZ];
  258. compat_caddr_t ifru_data;
  259. /* XXXX? ifru_settings should be here */
  260. } ifr_ifru;
  261. };
  262. struct ifconf32 {
  263. compat_int_t ifc_len; /* size of buffer */
  264. compat_caddr_t ifcbuf;
  265. };
  266. static int dev_ifname32(unsigned int fd, unsigned int cmd, unsigned long arg)
  267. {
  268. struct net_device *dev;
  269. struct ifreq32 ifr32;
  270. int err;
  271. if (copy_from_user(&ifr32, compat_ptr(arg), sizeof(ifr32)))
  272. return -EFAULT;
  273. dev = dev_get_by_index(ifr32.ifr_ifindex);
  274. if (!dev)
  275. return -ENODEV;
  276. strlcpy(ifr32.ifr_name, dev->name, sizeof(ifr32.ifr_name));
  277. dev_put(dev);
  278. err = copy_to_user(compat_ptr(arg), &ifr32, sizeof(ifr32));
  279. return (err ? -EFAULT : 0);
  280. }
  281. static int dev_ifconf(unsigned int fd, unsigned int cmd, unsigned long arg)
  282. {
  283. struct ifconf32 ifc32;
  284. struct ifconf ifc;
  285. struct ifconf __user *uifc;
  286. struct ifreq32 __user *ifr32;
  287. struct ifreq __user *ifr;
  288. unsigned int i, j;
  289. int err;
  290. if (copy_from_user(&ifc32, compat_ptr(arg), sizeof(struct ifconf32)))
  291. return -EFAULT;
  292. if (ifc32.ifcbuf == 0) {
  293. ifc32.ifc_len = 0;
  294. ifc.ifc_len = 0;
  295. ifc.ifc_req = NULL;
  296. uifc = compat_alloc_user_space(sizeof(struct ifconf));
  297. } else {
  298. size_t len =((ifc32.ifc_len / sizeof (struct ifreq32)) + 1) *
  299. sizeof (struct ifreq);
  300. uifc = compat_alloc_user_space(sizeof(struct ifconf) + len);
  301. ifc.ifc_len = len;
  302. ifr = ifc.ifc_req = (void __user *)(uifc + 1);
  303. ifr32 = compat_ptr(ifc32.ifcbuf);
  304. for (i = 0; i < ifc32.ifc_len; i += sizeof (struct ifreq32)) {
  305. if (copy_in_user(ifr, ifr32, sizeof(struct ifreq32)))
  306. return -EFAULT;
  307. ifr++;
  308. ifr32++;
  309. }
  310. }
  311. if (copy_to_user(uifc, &ifc, sizeof(struct ifconf)))
  312. return -EFAULT;
  313. err = sys_ioctl (fd, SIOCGIFCONF, (unsigned long)uifc);
  314. if (err)
  315. return err;
  316. if (copy_from_user(&ifc, uifc, sizeof(struct ifconf)))
  317. return -EFAULT;
  318. ifr = ifc.ifc_req;
  319. ifr32 = compat_ptr(ifc32.ifcbuf);
  320. for (i = 0, j = 0;
  321. i + sizeof (struct ifreq32) <= ifc32.ifc_len && j < ifc.ifc_len;
  322. i += sizeof (struct ifreq32), j += sizeof (struct ifreq)) {
  323. if (copy_in_user(ifr32, ifr, sizeof (struct ifreq32)))
  324. return -EFAULT;
  325. ifr32++;
  326. ifr++;
  327. }
  328. if (ifc32.ifcbuf == 0) {
  329. /* Translate from 64-bit structure multiple to
  330. * a 32-bit one.
  331. */
  332. i = ifc.ifc_len;
  333. i = ((i / sizeof(struct ifreq)) * sizeof(struct ifreq32));
  334. ifc32.ifc_len = i;
  335. } else {
  336. ifc32.ifc_len = i;
  337. }
  338. if (copy_to_user(compat_ptr(arg), &ifc32, sizeof(struct ifconf32)))
  339. return -EFAULT;
  340. return 0;
  341. }
  342. static int ethtool_ioctl(unsigned int fd, unsigned int cmd, unsigned long arg)
  343. {
  344. struct ifreq __user *ifr;
  345. struct ifreq32 __user *ifr32;
  346. u32 data;
  347. void __user *datap;
  348. ifr = compat_alloc_user_space(sizeof(*ifr));
  349. ifr32 = compat_ptr(arg);
  350. if (copy_in_user(&ifr->ifr_name, &ifr32->ifr_name, IFNAMSIZ))
  351. return -EFAULT;
  352. if (get_user(data, &ifr32->ifr_ifru.ifru_data))
  353. return -EFAULT;
  354. datap = compat_ptr(data);
  355. if (put_user(datap, &ifr->ifr_ifru.ifru_data))
  356. return -EFAULT;
  357. return sys_ioctl(fd, cmd, (unsigned long) ifr);
  358. }
  359. static int bond_ioctl(unsigned int fd, unsigned int cmd, unsigned long arg)
  360. {
  361. struct ifreq kifr;
  362. struct ifreq __user *uifr;
  363. struct ifreq32 __user *ifr32 = compat_ptr(arg);
  364. mm_segment_t old_fs;
  365. int err;
  366. u32 data;
  367. void __user *datap;
  368. switch (cmd) {
  369. case SIOCBONDENSLAVE:
  370. case SIOCBONDRELEASE:
  371. case SIOCBONDSETHWADDR:
  372. case SIOCBONDCHANGEACTIVE:
  373. if (copy_from_user(&kifr, ifr32, sizeof(struct ifreq32)))
  374. return -EFAULT;
  375. old_fs = get_fs();
  376. set_fs (KERNEL_DS);
  377. err = sys_ioctl (fd, cmd, (unsigned long)&kifr);
  378. set_fs (old_fs);
  379. return err;
  380. case SIOCBONDSLAVEINFOQUERY:
  381. case SIOCBONDINFOQUERY:
  382. uifr = compat_alloc_user_space(sizeof(*uifr));
  383. if (copy_in_user(&uifr->ifr_name, &ifr32->ifr_name, IFNAMSIZ))
  384. return -EFAULT;
  385. if (get_user(data, &ifr32->ifr_ifru.ifru_data))
  386. return -EFAULT;
  387. datap = compat_ptr(data);
  388. if (put_user(datap, &uifr->ifr_ifru.ifru_data))
  389. return -EFAULT;
  390. return sys_ioctl (fd, cmd, (unsigned long)uifr);
  391. default:
  392. return -EINVAL;
  393. };
  394. }
  395. int siocdevprivate_ioctl(unsigned int fd, unsigned int cmd, unsigned long arg)
  396. {
  397. struct ifreq __user *u_ifreq64;
  398. struct ifreq32 __user *u_ifreq32 = compat_ptr(arg);
  399. char tmp_buf[IFNAMSIZ];
  400. void __user *data64;
  401. u32 data32;
  402. if (copy_from_user(&tmp_buf[0], &(u_ifreq32->ifr_ifrn.ifrn_name[0]),
  403. IFNAMSIZ))
  404. return -EFAULT;
  405. if (__get_user(data32, &u_ifreq32->ifr_ifru.ifru_data))
  406. return -EFAULT;
  407. data64 = compat_ptr(data32);
  408. u_ifreq64 = compat_alloc_user_space(sizeof(*u_ifreq64));
  409. /* Don't check these user accesses, just let that get trapped
  410. * in the ioctl handler instead.
  411. */
  412. if (copy_to_user(&u_ifreq64->ifr_ifrn.ifrn_name[0], &tmp_buf[0],
  413. IFNAMSIZ))
  414. return -EFAULT;
  415. if (__put_user(data64, &u_ifreq64->ifr_ifru.ifru_data))
  416. return -EFAULT;
  417. return sys_ioctl(fd, cmd, (unsigned long) u_ifreq64);
  418. }
  419. static int dev_ifsioc(unsigned int fd, unsigned int cmd, unsigned long arg)
  420. {
  421. struct ifreq ifr;
  422. struct ifreq32 __user *uifr32;
  423. struct ifmap32 __user *uifmap32;
  424. mm_segment_t old_fs;
  425. int err;
  426. uifr32 = compat_ptr(arg);
  427. uifmap32 = &uifr32->ifr_ifru.ifru_map;
  428. switch (cmd) {
  429. case SIOCSIFMAP:
  430. err = copy_from_user(&ifr, uifr32, sizeof(ifr.ifr_name));
  431. err |= __get_user(ifr.ifr_map.mem_start, &uifmap32->mem_start);
  432. err |= __get_user(ifr.ifr_map.mem_end, &uifmap32->mem_end);
  433. err |= __get_user(ifr.ifr_map.base_addr, &uifmap32->base_addr);
  434. err |= __get_user(ifr.ifr_map.irq, &uifmap32->irq);
  435. err |= __get_user(ifr.ifr_map.dma, &uifmap32->dma);
  436. err |= __get_user(ifr.ifr_map.port, &uifmap32->port);
  437. if (err)
  438. return -EFAULT;
  439. break;
  440. default:
  441. if (copy_from_user(&ifr, uifr32, sizeof(*uifr32)))
  442. return -EFAULT;
  443. break;
  444. }
  445. old_fs = get_fs();
  446. set_fs (KERNEL_DS);
  447. err = sys_ioctl (fd, cmd, (unsigned long)&ifr);
  448. set_fs (old_fs);
  449. if (!err) {
  450. switch (cmd) {
  451. /* TUNSETIFF is defined as _IOW, it should be _IORW
  452. * as the data is copied back to user space, but that
  453. * cannot be fixed without breaking all existing apps.
  454. */
  455. case TUNSETIFF:
  456. case SIOCGIFFLAGS:
  457. case SIOCGIFMETRIC:
  458. case SIOCGIFMTU:
  459. case SIOCGIFMEM:
  460. case SIOCGIFHWADDR:
  461. case SIOCGIFINDEX:
  462. case SIOCGIFADDR:
  463. case SIOCGIFBRDADDR:
  464. case SIOCGIFDSTADDR:
  465. case SIOCGIFNETMASK:
  466. case SIOCGIFTXQLEN:
  467. if (copy_to_user(uifr32, &ifr, sizeof(*uifr32)))
  468. return -EFAULT;
  469. break;
  470. case SIOCGIFMAP:
  471. err = copy_to_user(uifr32, &ifr, sizeof(ifr.ifr_name));
  472. err |= __put_user(ifr.ifr_map.mem_start, &uifmap32->mem_start);
  473. err |= __put_user(ifr.ifr_map.mem_end, &uifmap32->mem_end);
  474. err |= __put_user(ifr.ifr_map.base_addr, &uifmap32->base_addr);
  475. err |= __put_user(ifr.ifr_map.irq, &uifmap32->irq);
  476. err |= __put_user(ifr.ifr_map.dma, &uifmap32->dma);
  477. err |= __put_user(ifr.ifr_map.port, &uifmap32->port);
  478. if (err)
  479. err = -EFAULT;
  480. break;
  481. }
  482. }
  483. return err;
  484. }
  485. struct rtentry32 {
  486. u32 rt_pad1;
  487. struct sockaddr rt_dst; /* target address */
  488. struct sockaddr rt_gateway; /* gateway addr (RTF_GATEWAY) */
  489. struct sockaddr rt_genmask; /* target network mask (IP) */
  490. unsigned short rt_flags;
  491. short rt_pad2;
  492. u32 rt_pad3;
  493. unsigned char rt_tos;
  494. unsigned char rt_class;
  495. short rt_pad4;
  496. short rt_metric; /* +1 for binary compatibility! */
  497. /* char * */ u32 rt_dev; /* forcing the device at add */
  498. u32 rt_mtu; /* per route MTU/Window */
  499. u32 rt_window; /* Window clamping */
  500. unsigned short rt_irtt; /* Initial RTT */
  501. };
  502. struct in6_rtmsg32 {
  503. struct in6_addr rtmsg_dst;
  504. struct in6_addr rtmsg_src;
  505. struct in6_addr rtmsg_gateway;
  506. u32 rtmsg_type;
  507. u16 rtmsg_dst_len;
  508. u16 rtmsg_src_len;
  509. u32 rtmsg_metric;
  510. u32 rtmsg_info;
  511. u32 rtmsg_flags;
  512. s32 rtmsg_ifindex;
  513. };
  514. static int routing_ioctl(unsigned int fd, unsigned int cmd, unsigned long arg)
  515. {
  516. int ret;
  517. void *r = NULL;
  518. struct in6_rtmsg r6;
  519. struct rtentry r4;
  520. char devname[16];
  521. u32 rtdev;
  522. mm_segment_t old_fs = get_fs();
  523. struct socket *mysock = sockfd_lookup(fd, &ret);
  524. if (mysock && mysock->sk && mysock->sk->sk_family == AF_INET6) { /* ipv6 */
  525. struct in6_rtmsg32 __user *ur6 = compat_ptr(arg);
  526. ret = copy_from_user (&r6.rtmsg_dst, &(ur6->rtmsg_dst),
  527. 3 * sizeof(struct in6_addr));
  528. ret |= __get_user (r6.rtmsg_type, &(ur6->rtmsg_type));
  529. ret |= __get_user (r6.rtmsg_dst_len, &(ur6->rtmsg_dst_len));
  530. ret |= __get_user (r6.rtmsg_src_len, &(ur6->rtmsg_src_len));
  531. ret |= __get_user (r6.rtmsg_metric, &(ur6->rtmsg_metric));
  532. ret |= __get_user (r6.rtmsg_info, &(ur6->rtmsg_info));
  533. ret |= __get_user (r6.rtmsg_flags, &(ur6->rtmsg_flags));
  534. ret |= __get_user (r6.rtmsg_ifindex, &(ur6->rtmsg_ifindex));
  535. r = (void *) &r6;
  536. } else { /* ipv4 */
  537. struct rtentry32 __user *ur4 = compat_ptr(arg);
  538. ret = copy_from_user (&r4.rt_dst, &(ur4->rt_dst),
  539. 3 * sizeof(struct sockaddr));
  540. ret |= __get_user (r4.rt_flags, &(ur4->rt_flags));
  541. ret |= __get_user (r4.rt_metric, &(ur4->rt_metric));
  542. ret |= __get_user (r4.rt_mtu, &(ur4->rt_mtu));
  543. ret |= __get_user (r4.rt_window, &(ur4->rt_window));
  544. ret |= __get_user (r4.rt_irtt, &(ur4->rt_irtt));
  545. ret |= __get_user (rtdev, &(ur4->rt_dev));
  546. if (rtdev) {
  547. ret |= copy_from_user (devname, compat_ptr(rtdev), 15);
  548. r4.rt_dev = devname; devname[15] = 0;
  549. } else
  550. r4.rt_dev = NULL;
  551. r = (void *) &r4;
  552. }
  553. if (ret) {
  554. ret = -EFAULT;
  555. goto out;
  556. }
  557. set_fs (KERNEL_DS);
  558. ret = sys_ioctl (fd, cmd, (unsigned long) r);
  559. set_fs (old_fs);
  560. out:
  561. if (mysock)
  562. sockfd_put(mysock);
  563. return ret;
  564. }
  565. #endif
  566. #ifdef CONFIG_BLOCK
  567. struct hd_geometry32 {
  568. unsigned char heads;
  569. unsigned char sectors;
  570. unsigned short cylinders;
  571. u32 start;
  572. };
  573. static int hdio_getgeo(unsigned int fd, unsigned int cmd, unsigned long arg)
  574. {
  575. mm_segment_t old_fs = get_fs();
  576. struct hd_geometry geo;
  577. struct hd_geometry32 __user *ugeo;
  578. int err;
  579. set_fs (KERNEL_DS);
  580. err = sys_ioctl(fd, HDIO_GETGEO, (unsigned long)&geo);
  581. set_fs (old_fs);
  582. ugeo = compat_ptr(arg);
  583. if (!err) {
  584. err = copy_to_user (ugeo, &geo, 4);
  585. err |= __put_user (geo.start, &ugeo->start);
  586. }
  587. return err ? -EFAULT : 0;
  588. }
  589. static int hdio_ioctl_trans(unsigned int fd, unsigned int cmd, unsigned long arg)
  590. {
  591. mm_segment_t old_fs = get_fs();
  592. unsigned long kval;
  593. unsigned int __user *uvp;
  594. int error;
  595. set_fs(KERNEL_DS);
  596. error = sys_ioctl(fd, cmd, (long)&kval);
  597. set_fs(old_fs);
  598. if(error == 0) {
  599. uvp = compat_ptr(arg);
  600. if(put_user(kval, uvp))
  601. error = -EFAULT;
  602. }
  603. return error;
  604. }
  605. typedef struct sg_io_hdr32 {
  606. compat_int_t interface_id; /* [i] 'S' for SCSI generic (required) */
  607. compat_int_t dxfer_direction; /* [i] data transfer direction */
  608. unsigned char cmd_len; /* [i] SCSI command length ( <= 16 bytes) */
  609. unsigned char mx_sb_len; /* [i] max length to write to sbp */
  610. unsigned short iovec_count; /* [i] 0 implies no scatter gather */
  611. compat_uint_t dxfer_len; /* [i] byte count of data transfer */
  612. compat_uint_t dxferp; /* [i], [*io] points to data transfer memory
  613. or scatter gather list */
  614. compat_uptr_t cmdp; /* [i], [*i] points to command to perform */
  615. compat_uptr_t sbp; /* [i], [*o] points to sense_buffer memory */
  616. compat_uint_t timeout; /* [i] MAX_UINT->no timeout (unit: millisec) */
  617. compat_uint_t flags; /* [i] 0 -> default, see SG_FLAG... */
  618. compat_int_t pack_id; /* [i->o] unused internally (normally) */
  619. compat_uptr_t usr_ptr; /* [i->o] unused internally */
  620. unsigned char status; /* [o] scsi status */
  621. unsigned char masked_status; /* [o] shifted, masked scsi status */
  622. unsigned char msg_status; /* [o] messaging level data (optional) */
  623. unsigned char sb_len_wr; /* [o] byte count actually written to sbp */
  624. unsigned short host_status; /* [o] errors from host adapter */
  625. unsigned short driver_status; /* [o] errors from software driver */
  626. compat_int_t resid; /* [o] dxfer_len - actual_transferred */
  627. compat_uint_t duration; /* [o] time taken by cmd (unit: millisec) */
  628. compat_uint_t info; /* [o] auxiliary information */
  629. } sg_io_hdr32_t; /* 64 bytes long (on sparc32) */
  630. typedef struct sg_iovec32 {
  631. compat_uint_t iov_base;
  632. compat_uint_t iov_len;
  633. } sg_iovec32_t;
  634. static int sg_build_iovec(sg_io_hdr_t __user *sgio, void __user *dxferp, u16 iovec_count)
  635. {
  636. sg_iovec_t __user *iov = (sg_iovec_t __user *) (sgio + 1);
  637. sg_iovec32_t __user *iov32 = dxferp;
  638. int i;
  639. for (i = 0; i < iovec_count; i++) {
  640. u32 base, len;
  641. if (get_user(base, &iov32[i].iov_base) ||
  642. get_user(len, &iov32[i].iov_len) ||
  643. put_user(compat_ptr(base), &iov[i].iov_base) ||
  644. put_user(len, &iov[i].iov_len))
  645. return -EFAULT;
  646. }
  647. if (put_user(iov, &sgio->dxferp))
  648. return -EFAULT;
  649. return 0;
  650. }
  651. static int sg_ioctl_trans(unsigned int fd, unsigned int cmd, unsigned long arg)
  652. {
  653. sg_io_hdr_t __user *sgio;
  654. sg_io_hdr32_t __user *sgio32;
  655. u16 iovec_count;
  656. u32 data;
  657. void __user *dxferp;
  658. int err;
  659. sgio32 = compat_ptr(arg);
  660. if (get_user(iovec_count, &sgio32->iovec_count))
  661. return -EFAULT;
  662. {
  663. void __user *top = compat_alloc_user_space(0);
  664. void __user *new = compat_alloc_user_space(sizeof(sg_io_hdr_t) +
  665. (iovec_count * sizeof(sg_iovec_t)));
  666. if (new > top)
  667. return -EINVAL;
  668. sgio = new;
  669. }
  670. /* Ok, now construct. */
  671. if (copy_in_user(&sgio->interface_id, &sgio32->interface_id,
  672. (2 * sizeof(int)) +
  673. (2 * sizeof(unsigned char)) +
  674. (1 * sizeof(unsigned short)) +
  675. (1 * sizeof(unsigned int))))
  676. return -EFAULT;
  677. if (get_user(data, &sgio32->dxferp))
  678. return -EFAULT;
  679. dxferp = compat_ptr(data);
  680. if (iovec_count) {
  681. if (sg_build_iovec(sgio, dxferp, iovec_count))
  682. return -EFAULT;
  683. } else {
  684. if (put_user(dxferp, &sgio->dxferp))
  685. return -EFAULT;
  686. }
  687. {
  688. unsigned char __user *cmdp;
  689. unsigned char __user *sbp;
  690. if (get_user(data, &sgio32->cmdp))
  691. return -EFAULT;
  692. cmdp = compat_ptr(data);
  693. if (get_user(data, &sgio32->sbp))
  694. return -EFAULT;
  695. sbp = compat_ptr(data);
  696. if (put_user(cmdp, &sgio->cmdp) ||
  697. put_user(sbp, &sgio->sbp))
  698. return -EFAULT;
  699. }
  700. if (copy_in_user(&sgio->timeout, &sgio32->timeout,
  701. 3 * sizeof(int)))
  702. return -EFAULT;
  703. if (get_user(data, &sgio32->usr_ptr))
  704. return -EFAULT;
  705. if (put_user(compat_ptr(data), &sgio->usr_ptr))
  706. return -EFAULT;
  707. if (copy_in_user(&sgio->status, &sgio32->status,
  708. (4 * sizeof(unsigned char)) +
  709. (2 * sizeof(unsigned (short))) +
  710. (3 * sizeof(int))))
  711. return -EFAULT;
  712. err = sys_ioctl(fd, cmd, (unsigned long) sgio);
  713. if (err >= 0) {
  714. void __user *datap;
  715. if (copy_in_user(&sgio32->pack_id, &sgio->pack_id,
  716. sizeof(int)) ||
  717. get_user(datap, &sgio->usr_ptr) ||
  718. put_user((u32)(unsigned long)datap,
  719. &sgio32->usr_ptr) ||
  720. copy_in_user(&sgio32->status, &sgio->status,
  721. (4 * sizeof(unsigned char)) +
  722. (2 * sizeof(unsigned short)) +
  723. (3 * sizeof(int))))
  724. err = -EFAULT;
  725. }
  726. return err;
  727. }
  728. struct compat_sg_req_info { /* used by SG_GET_REQUEST_TABLE ioctl() */
  729. char req_state;
  730. char orphan;
  731. char sg_io_owned;
  732. char problem;
  733. int pack_id;
  734. compat_uptr_t usr_ptr;
  735. unsigned int duration;
  736. int unused;
  737. };
  738. static int sg_grt_trans(unsigned int fd, unsigned int cmd, unsigned long arg)
  739. {
  740. int err, i;
  741. sg_req_info_t __user *r;
  742. struct compat_sg_req_info __user *o = (void __user *)arg;
  743. r = compat_alloc_user_space(sizeof(sg_req_info_t)*SG_MAX_QUEUE);
  744. err = sys_ioctl(fd,cmd,(unsigned long)r);
  745. if (err < 0)
  746. return err;
  747. for (i = 0; i < SG_MAX_QUEUE; i++) {
  748. void __user *ptr;
  749. int d;
  750. if (copy_in_user(o + i, r + i, offsetof(sg_req_info_t, usr_ptr)) ||
  751. get_user(ptr, &r[i].usr_ptr) ||
  752. get_user(d, &r[i].duration) ||
  753. put_user((u32)(unsigned long)(ptr), &o[i].usr_ptr) ||
  754. put_user(d, &o[i].duration))
  755. return -EFAULT;
  756. }
  757. return err;
  758. }
  759. #endif /* CONFIG_BLOCK */
  760. struct sock_fprog32 {
  761. unsigned short len;
  762. compat_caddr_t filter;
  763. };
  764. #define PPPIOCSPASS32 _IOW('t', 71, struct sock_fprog32)
  765. #define PPPIOCSACTIVE32 _IOW('t', 70, struct sock_fprog32)
  766. static int ppp_sock_fprog_ioctl_trans(unsigned int fd, unsigned int cmd, unsigned long arg)
  767. {
  768. struct sock_fprog32 __user *u_fprog32 = compat_ptr(arg);
  769. struct sock_fprog __user *u_fprog64 = compat_alloc_user_space(sizeof(struct sock_fprog));
  770. void __user *fptr64;
  771. u32 fptr32;
  772. u16 flen;
  773. if (get_user(flen, &u_fprog32->len) ||
  774. get_user(fptr32, &u_fprog32->filter))
  775. return -EFAULT;
  776. fptr64 = compat_ptr(fptr32);
  777. if (put_user(flen, &u_fprog64->len) ||
  778. put_user(fptr64, &u_fprog64->filter))
  779. return -EFAULT;
  780. if (cmd == PPPIOCSPASS32)
  781. cmd = PPPIOCSPASS;
  782. else
  783. cmd = PPPIOCSACTIVE;
  784. return sys_ioctl(fd, cmd, (unsigned long) u_fprog64);
  785. }
  786. struct ppp_option_data32 {
  787. compat_caddr_t ptr;
  788. u32 length;
  789. compat_int_t transmit;
  790. };
  791. #define PPPIOCSCOMPRESS32 _IOW('t', 77, struct ppp_option_data32)
  792. struct ppp_idle32 {
  793. compat_time_t xmit_idle;
  794. compat_time_t recv_idle;
  795. };
  796. #define PPPIOCGIDLE32 _IOR('t', 63, struct ppp_idle32)
  797. static int ppp_gidle(unsigned int fd, unsigned int cmd, unsigned long arg)
  798. {
  799. struct ppp_idle __user *idle;
  800. struct ppp_idle32 __user *idle32;
  801. __kernel_time_t xmit, recv;
  802. int err;
  803. idle = compat_alloc_user_space(sizeof(*idle));
  804. idle32 = compat_ptr(arg);
  805. err = sys_ioctl(fd, PPPIOCGIDLE, (unsigned long) idle);
  806. if (!err) {
  807. if (get_user(xmit, &idle->xmit_idle) ||
  808. get_user(recv, &idle->recv_idle) ||
  809. put_user(xmit, &idle32->xmit_idle) ||
  810. put_user(recv, &idle32->recv_idle))
  811. err = -EFAULT;
  812. }
  813. return err;
  814. }
  815. static int ppp_scompress(unsigned int fd, unsigned int cmd, unsigned long arg)
  816. {
  817. struct ppp_option_data __user *odata;
  818. struct ppp_option_data32 __user *odata32;
  819. __u32 data;
  820. void __user *datap;
  821. odata = compat_alloc_user_space(sizeof(*odata));
  822. odata32 = compat_ptr(arg);
  823. if (get_user(data, &odata32->ptr))
  824. return -EFAULT;
  825. datap = compat_ptr(data);
  826. if (put_user(datap, &odata->ptr))
  827. return -EFAULT;
  828. if (copy_in_user(&odata->length, &odata32->length,
  829. sizeof(__u32) + sizeof(int)))
  830. return -EFAULT;
  831. return sys_ioctl(fd, PPPIOCSCOMPRESS, (unsigned long) odata);
  832. }
  833. static int ppp_ioctl_trans(unsigned int fd, unsigned int cmd, unsigned long arg)
  834. {
  835. int err;
  836. switch (cmd) {
  837. case PPPIOCGIDLE32:
  838. err = ppp_gidle(fd, cmd, arg);
  839. break;
  840. case PPPIOCSCOMPRESS32:
  841. err = ppp_scompress(fd, cmd, arg);
  842. break;
  843. default:
  844. do {
  845. static int count;
  846. if (++count <= 20)
  847. printk("ppp_ioctl: Unknown cmd fd(%d) "
  848. "cmd(%08x) arg(%08x)\n",
  849. (int)fd, (unsigned int)cmd, (unsigned int)arg);
  850. } while(0);
  851. err = -EINVAL;
  852. break;
  853. };
  854. return err;
  855. }
  856. #ifdef CONFIG_BLOCK
  857. struct mtget32 {
  858. compat_long_t mt_type;
  859. compat_long_t mt_resid;
  860. compat_long_t mt_dsreg;
  861. compat_long_t mt_gstat;
  862. compat_long_t mt_erreg;
  863. compat_daddr_t mt_fileno;
  864. compat_daddr_t mt_blkno;
  865. };
  866. #define MTIOCGET32 _IOR('m', 2, struct mtget32)
  867. struct mtpos32 {
  868. compat_long_t mt_blkno;
  869. };
  870. #define MTIOCPOS32 _IOR('m', 3, struct mtpos32)
  871. static int mt_ioctl_trans(unsigned int fd, unsigned int cmd, unsigned long arg)
  872. {
  873. mm_segment_t old_fs = get_fs();
  874. struct mtget get;
  875. struct mtget32 __user *umget32;
  876. struct mtpos pos;
  877. struct mtpos32 __user *upos32;
  878. unsigned long kcmd;
  879. void *karg;
  880. int err = 0;
  881. switch(cmd) {
  882. case MTIOCPOS32:
  883. kcmd = MTIOCPOS;
  884. karg = &pos;
  885. break;
  886. case MTIOCGET32:
  887. kcmd = MTIOCGET;
  888. karg = &get;
  889. break;
  890. default:
  891. do {
  892. static int count;
  893. if (++count <= 20)
  894. printk("mt_ioctl: Unknown cmd fd(%d) "
  895. "cmd(%08x) arg(%08x)\n",
  896. (int)fd, (unsigned int)cmd, (unsigned int)arg);
  897. } while(0);
  898. return -EINVAL;
  899. }
  900. set_fs (KERNEL_DS);
  901. err = sys_ioctl (fd, kcmd, (unsigned long)karg);
  902. set_fs (old_fs);
  903. if (err)
  904. return err;
  905. switch (cmd) {
  906. case MTIOCPOS32:
  907. upos32 = compat_ptr(arg);
  908. err = __put_user(pos.mt_blkno, &upos32->mt_blkno);
  909. break;
  910. case MTIOCGET32:
  911. umget32 = compat_ptr(arg);
  912. err = __put_user(get.mt_type, &umget32->mt_type);
  913. err |= __put_user(get.mt_resid, &umget32->mt_resid);
  914. err |= __put_user(get.mt_dsreg, &umget32->mt_dsreg);
  915. err |= __put_user(get.mt_gstat, &umget32->mt_gstat);
  916. err |= __put_user(get.mt_erreg, &umget32->mt_erreg);
  917. err |= __put_user(get.mt_fileno, &umget32->mt_fileno);
  918. err |= __put_user(get.mt_blkno, &umget32->mt_blkno);
  919. break;
  920. }
  921. return err ? -EFAULT: 0;
  922. }
  923. struct cdrom_read_audio32 {
  924. union cdrom_addr addr;
  925. u8 addr_format;
  926. compat_int_t nframes;
  927. compat_caddr_t buf;
  928. };
  929. struct cdrom_generic_command32 {
  930. unsigned char cmd[CDROM_PACKET_SIZE];
  931. compat_caddr_t buffer;
  932. compat_uint_t buflen;
  933. compat_int_t stat;
  934. compat_caddr_t sense;
  935. unsigned char data_direction;
  936. compat_int_t quiet;
  937. compat_int_t timeout;
  938. compat_caddr_t reserved[1];
  939. };
  940. static int cdrom_do_read_audio(unsigned int fd, unsigned int cmd, unsigned long arg)
  941. {
  942. struct cdrom_read_audio __user *cdread_audio;
  943. struct cdrom_read_audio32 __user *cdread_audio32;
  944. __u32 data;
  945. void __user *datap;
  946. cdread_audio = compat_alloc_user_space(sizeof(*cdread_audio));
  947. cdread_audio32 = compat_ptr(arg);
  948. if (copy_in_user(&cdread_audio->addr,
  949. &cdread_audio32->addr,
  950. (sizeof(*cdread_audio32) -
  951. sizeof(compat_caddr_t))))
  952. return -EFAULT;
  953. if (get_user(data, &cdread_audio32->buf))
  954. return -EFAULT;
  955. datap = compat_ptr(data);
  956. if (put_user(datap, &cdread_audio->buf))
  957. return -EFAULT;
  958. return sys_ioctl(fd, cmd, (unsigned long) cdread_audio);
  959. }
  960. static int cdrom_do_generic_command(unsigned int fd, unsigned int cmd, unsigned long arg)
  961. {
  962. struct cdrom_generic_command __user *cgc;
  963. struct cdrom_generic_command32 __user *cgc32;
  964. u32 data;
  965. unsigned char dir;
  966. int itmp;
  967. cgc = compat_alloc_user_space(sizeof(*cgc));
  968. cgc32 = compat_ptr(arg);
  969. if (copy_in_user(&cgc->cmd, &cgc32->cmd, sizeof(cgc->cmd)) ||
  970. get_user(data, &cgc32->buffer) ||
  971. put_user(compat_ptr(data), &cgc->buffer) ||
  972. copy_in_user(&cgc->buflen, &cgc32->buflen,
  973. (sizeof(unsigned int) + sizeof(int))) ||
  974. get_user(data, &cgc32->sense) ||
  975. put_user(compat_ptr(data), &cgc->sense) ||
  976. get_user(dir, &cgc32->data_direction) ||
  977. put_user(dir, &cgc->data_direction) ||
  978. get_user(itmp, &cgc32->quiet) ||
  979. put_user(itmp, &cgc->quiet) ||
  980. get_user(itmp, &cgc32->timeout) ||
  981. put_user(itmp, &cgc->timeout) ||
  982. get_user(data, &cgc32->reserved[0]) ||
  983. put_user(compat_ptr(data), &cgc->reserved[0]))
  984. return -EFAULT;
  985. return sys_ioctl(fd, cmd, (unsigned long) cgc);
  986. }
  987. static int cdrom_ioctl_trans(unsigned int fd, unsigned int cmd, unsigned long arg)
  988. {
  989. int err;
  990. switch(cmd) {
  991. case CDROMREADAUDIO:
  992. err = cdrom_do_read_audio(fd, cmd, arg);
  993. break;
  994. case CDROM_SEND_PACKET:
  995. err = cdrom_do_generic_command(fd, cmd, arg);
  996. break;
  997. default:
  998. do {
  999. static int count;
  1000. if (++count <= 20)
  1001. printk("cdrom_ioctl: Unknown cmd fd(%d) "
  1002. "cmd(%08x) arg(%08x)\n",
  1003. (int)fd, (unsigned int)cmd, (unsigned int)arg);
  1004. } while(0);
  1005. err = -EINVAL;
  1006. break;
  1007. };
  1008. return err;
  1009. }
  1010. #endif /* CONFIG_BLOCK */
  1011. #ifdef CONFIG_VT
  1012. static int vt_check(struct file *file)
  1013. {
  1014. struct tty_struct *tty;
  1015. struct inode *inode = file->f_path.dentry->d_inode;
  1016. struct vc_data *vc;
  1017. if (file->f_op->ioctl != tty_ioctl)
  1018. return -EINVAL;
  1019. tty = (struct tty_struct *)file->private_data;
  1020. if (tty_paranoia_check(tty, inode, "tty_ioctl"))
  1021. return -EINVAL;
  1022. if (tty->driver->ioctl != vt_ioctl)
  1023. return -EINVAL;
  1024. vc = (struct vc_data *)tty->driver_data;
  1025. if (!vc_cons_allocated(vc->vc_num)) /* impossible? */
  1026. return -ENOIOCTLCMD;
  1027. /*
  1028. * To have permissions to do most of the vt ioctls, we either have
  1029. * to be the owner of the tty, or have CAP_SYS_TTY_CONFIG.
  1030. */
  1031. if (current->signal->tty == tty || capable(CAP_SYS_TTY_CONFIG))
  1032. return 1;
  1033. return 0;
  1034. }
  1035. struct consolefontdesc32 {
  1036. unsigned short charcount; /* characters in font (256 or 512) */
  1037. unsigned short charheight; /* scan lines per character (1-32) */
  1038. compat_caddr_t chardata; /* font data in expanded form */
  1039. };
  1040. static int do_fontx_ioctl(unsigned int fd, unsigned int cmd, unsigned long arg, struct file *file)
  1041. {
  1042. struct consolefontdesc32 __user *user_cfd = compat_ptr(arg);
  1043. struct console_font_op op;
  1044. compat_caddr_t data;
  1045. int i, perm;
  1046. perm = vt_check(file);
  1047. if (perm < 0) return perm;
  1048. switch (cmd) {
  1049. case PIO_FONTX:
  1050. if (!perm)
  1051. return -EPERM;
  1052. op.op = KD_FONT_OP_SET;
  1053. op.flags = 0;
  1054. op.width = 8;
  1055. if (get_user(op.height, &user_cfd->charheight) ||
  1056. get_user(op.charcount, &user_cfd->charcount) ||
  1057. get_user(data, &user_cfd->chardata))
  1058. return -EFAULT;
  1059. op.data = compat_ptr(data);
  1060. return con_font_op(vc_cons[fg_console].d, &op);
  1061. case GIO_FONTX:
  1062. op.op = KD_FONT_OP_GET;
  1063. op.flags = 0;
  1064. op.width = 8;
  1065. if (get_user(op.height, &user_cfd->charheight) ||
  1066. get_user(op.charcount, &user_cfd->charcount) ||
  1067. get_user(data, &user_cfd->chardata))
  1068. return -EFAULT;
  1069. if (!data)
  1070. return 0;
  1071. op.data = compat_ptr(data);
  1072. i = con_font_op(vc_cons[fg_console].d, &op);
  1073. if (i)
  1074. return i;
  1075. if (put_user(op.height, &user_cfd->charheight) ||
  1076. put_user(op.charcount, &user_cfd->charcount) ||
  1077. put_user((compat_caddr_t)(unsigned long)op.data,
  1078. &user_cfd->chardata))
  1079. return -EFAULT;
  1080. return 0;
  1081. }
  1082. return -EINVAL;
  1083. }
  1084. struct console_font_op32 {
  1085. compat_uint_t op; /* operation code KD_FONT_OP_* */
  1086. compat_uint_t flags; /* KD_FONT_FLAG_* */
  1087. compat_uint_t width, height; /* font size */
  1088. compat_uint_t charcount;
  1089. compat_caddr_t data; /* font data with height fixed to 32 */
  1090. };
  1091. static int do_kdfontop_ioctl(unsigned int fd, unsigned int cmd, unsigned long arg, struct file *file)
  1092. {
  1093. struct console_font_op op;
  1094. struct console_font_op32 __user *fontop = compat_ptr(arg);
  1095. int perm = vt_check(file), i;
  1096. struct vc_data *vc;
  1097. if (perm < 0) return perm;
  1098. if (copy_from_user(&op, fontop, sizeof(struct console_font_op32)))
  1099. return -EFAULT;
  1100. if (!perm && op.op != KD_FONT_OP_GET)
  1101. return -EPERM;
  1102. op.data = compat_ptr(((struct console_font_op32 *)&op)->data);
  1103. op.flags |= KD_FONT_FLAG_OLD;
  1104. vc = ((struct tty_struct *)file->private_data)->driver_data;
  1105. i = con_font_op(vc, &op);
  1106. if (i)
  1107. return i;
  1108. ((struct console_font_op32 *)&op)->data = (unsigned long)op.data;
  1109. if (copy_to_user(fontop, &op, sizeof(struct console_font_op32)))
  1110. return -EFAULT;
  1111. return 0;
  1112. }
  1113. struct unimapdesc32 {
  1114. unsigned short entry_ct;
  1115. compat_caddr_t entries;
  1116. };
  1117. static int do_unimap_ioctl(unsigned int fd, unsigned int cmd, unsigned long arg, struct file *file)
  1118. {
  1119. struct unimapdesc32 tmp;
  1120. struct unimapdesc32 __user *user_ud = compat_ptr(arg);
  1121. int perm = vt_check(file);
  1122. struct vc_data *vc;
  1123. if (perm < 0)
  1124. return perm;
  1125. if (copy_from_user(&tmp, user_ud, sizeof tmp))
  1126. return -EFAULT;
  1127. if (tmp.entries)
  1128. if (!access_ok(VERIFY_WRITE, compat_ptr(tmp.entries),
  1129. tmp.entry_ct*sizeof(struct unipair)))
  1130. return -EFAULT;
  1131. vc = ((struct tty_struct *)file->private_data)->driver_data;
  1132. switch (cmd) {
  1133. case PIO_UNIMAP:
  1134. if (!perm)
  1135. return -EPERM;
  1136. return con_set_unimap(vc, tmp.entry_ct,
  1137. compat_ptr(tmp.entries));
  1138. case GIO_UNIMAP:
  1139. if (!perm && fg_console != vc->vc_num)
  1140. return -EPERM;
  1141. return con_get_unimap(vc, tmp.entry_ct, &(user_ud->entry_ct),
  1142. compat_ptr(tmp.entries));
  1143. }
  1144. return 0;
  1145. }
  1146. #endif /* CONFIG_VT */
  1147. static int do_smb_getmountuid(unsigned int fd, unsigned int cmd, unsigned long arg)
  1148. {
  1149. mm_segment_t old_fs = get_fs();
  1150. __kernel_uid_t kuid;
  1151. int err;
  1152. cmd = SMB_IOC_GETMOUNTUID;
  1153. set_fs(KERNEL_DS);
  1154. err = sys_ioctl(fd, cmd, (unsigned long)&kuid);
  1155. set_fs(old_fs);
  1156. if (err >= 0)
  1157. err = put_user(kuid, (compat_uid_t __user *)compat_ptr(arg));
  1158. return err;
  1159. }
  1160. struct atmif_sioc32 {
  1161. compat_int_t number;
  1162. compat_int_t length;
  1163. compat_caddr_t arg;
  1164. };
  1165. struct atm_iobuf32 {
  1166. compat_int_t length;
  1167. compat_caddr_t buffer;
  1168. };
  1169. #define ATM_GETLINKRATE32 _IOW('a', ATMIOC_ITF+1, struct atmif_sioc32)
  1170. #define ATM_GETNAMES32 _IOW('a', ATMIOC_ITF+3, struct atm_iobuf32)
  1171. #define ATM_GETTYPE32 _IOW('a', ATMIOC_ITF+4, struct atmif_sioc32)
  1172. #define ATM_GETESI32 _IOW('a', ATMIOC_ITF+5, struct atmif_sioc32)
  1173. #define ATM_GETADDR32 _IOW('a', ATMIOC_ITF+6, struct atmif_sioc32)
  1174. #define ATM_RSTADDR32 _IOW('a', ATMIOC_ITF+7, struct atmif_sioc32)
  1175. #define ATM_ADDADDR32 _IOW('a', ATMIOC_ITF+8, struct atmif_sioc32)
  1176. #define ATM_DELADDR32 _IOW('a', ATMIOC_ITF+9, struct atmif_sioc32)
  1177. #define ATM_GETCIRANGE32 _IOW('a', ATMIOC_ITF+10, struct atmif_sioc32)
  1178. #define ATM_SETCIRANGE32 _IOW('a', ATMIOC_ITF+11, struct atmif_sioc32)
  1179. #define ATM_SETESI32 _IOW('a', ATMIOC_ITF+12, struct atmif_sioc32)
  1180. #define ATM_SETESIF32 _IOW('a', ATMIOC_ITF+13, struct atmif_sioc32)
  1181. #define ATM_GETSTAT32 _IOW('a', ATMIOC_SARCOM+0, struct atmif_sioc32)
  1182. #define ATM_GETSTATZ32 _IOW('a', ATMIOC_SARCOM+1, struct atmif_sioc32)
  1183. #define ATM_GETLOOP32 _IOW('a', ATMIOC_SARCOM+2, struct atmif_sioc32)
  1184. #define ATM_SETLOOP32 _IOW('a', ATMIOC_SARCOM+3, struct atmif_sioc32)
  1185. #define ATM_QUERYLOOP32 _IOW('a', ATMIOC_SARCOM+4, struct atmif_sioc32)
  1186. static struct {
  1187. unsigned int cmd32;
  1188. unsigned int cmd;
  1189. } atm_ioctl_map[] = {
  1190. { ATM_GETLINKRATE32, ATM_GETLINKRATE },
  1191. { ATM_GETNAMES32, ATM_GETNAMES },
  1192. { ATM_GETTYPE32, ATM_GETTYPE },
  1193. { ATM_GETESI32, ATM_GETESI },
  1194. { ATM_GETADDR32, ATM_GETADDR },
  1195. { ATM_RSTADDR32, ATM_RSTADDR },
  1196. { ATM_ADDADDR32, ATM_ADDADDR },
  1197. { ATM_DELADDR32, ATM_DELADDR },
  1198. { ATM_GETCIRANGE32, ATM_GETCIRANGE },
  1199. { ATM_SETCIRANGE32, ATM_SETCIRANGE },
  1200. { ATM_SETESI32, ATM_SETESI },
  1201. { ATM_SETESIF32, ATM_SETESIF },
  1202. { ATM_GETSTAT32, ATM_GETSTAT },
  1203. { ATM_GETSTATZ32, ATM_GETSTATZ },
  1204. { ATM_GETLOOP32, ATM_GETLOOP },
  1205. { ATM_SETLOOP32, ATM_SETLOOP },
  1206. { ATM_QUERYLOOP32, ATM_QUERYLOOP }
  1207. };
  1208. #define NR_ATM_IOCTL ARRAY_SIZE(atm_ioctl_map)
  1209. static int do_atm_iobuf(unsigned int fd, unsigned int cmd, unsigned long arg)
  1210. {
  1211. struct atm_iobuf __user *iobuf;
  1212. struct atm_iobuf32 __user *iobuf32;
  1213. u32 data;
  1214. void __user *datap;
  1215. int len, err;
  1216. iobuf = compat_alloc_user_space(sizeof(*iobuf));
  1217. iobuf32 = compat_ptr(arg);
  1218. if (get_user(len, &iobuf32->length) ||
  1219. get_user(data, &iobuf32->buffer))
  1220. return -EFAULT;
  1221. datap = compat_ptr(data);
  1222. if (put_user(len, &iobuf->length) ||
  1223. put_user(datap, &iobuf->buffer))
  1224. return -EFAULT;
  1225. err = sys_ioctl(fd, cmd, (unsigned long)iobuf);
  1226. if (!err) {
  1227. if (copy_in_user(&iobuf32->length, &iobuf->length,
  1228. sizeof(int)))
  1229. err = -EFAULT;
  1230. }
  1231. return err;
  1232. }
  1233. static int do_atmif_sioc(unsigned int fd, unsigned int cmd, unsigned long arg)
  1234. {
  1235. struct atmif_sioc __user *sioc;
  1236. struct atmif_sioc32 __user *sioc32;
  1237. u32 data;
  1238. void __user *datap;
  1239. int err;
  1240. sioc = compat_alloc_user_space(sizeof(*sioc));
  1241. sioc32 = compat_ptr(arg);
  1242. if (copy_in_user(&sioc->number, &sioc32->number, 2 * sizeof(int)) ||
  1243. get_user(data, &sioc32->arg))
  1244. return -EFAULT;
  1245. datap = compat_ptr(data);
  1246. if (put_user(datap, &sioc->arg))
  1247. return -EFAULT;
  1248. err = sys_ioctl(fd, cmd, (unsigned long) sioc);
  1249. if (!err) {
  1250. if (copy_in_user(&sioc32->length, &sioc->length,
  1251. sizeof(int)))
  1252. err = -EFAULT;
  1253. }
  1254. return err;
  1255. }
  1256. static int do_atm_ioctl(unsigned int fd, unsigned int cmd32, unsigned long arg)
  1257. {
  1258. int i;
  1259. unsigned int cmd = 0;
  1260. switch (cmd32) {
  1261. case SONET_GETSTAT:
  1262. case SONET_GETSTATZ:
  1263. case SONET_GETDIAG:
  1264. case SONET_SETDIAG:
  1265. case SONET_CLRDIAG:
  1266. case SONET_SETFRAMING:
  1267. case SONET_GETFRAMING:
  1268. case SONET_GETFRSENSE:
  1269. return do_atmif_sioc(fd, cmd32, arg);
  1270. }
  1271. for (i = 0; i < NR_ATM_IOCTL; i++) {
  1272. if (cmd32 == atm_ioctl_map[i].cmd32) {
  1273. cmd = atm_ioctl_map[i].cmd;
  1274. break;
  1275. }
  1276. }
  1277. if (i == NR_ATM_IOCTL)
  1278. return -EINVAL;
  1279. switch (cmd) {
  1280. case ATM_GETNAMES:
  1281. return do_atm_iobuf(fd, cmd, arg);
  1282. case ATM_GETLINKRATE:
  1283. case ATM_GETTYPE:
  1284. case ATM_GETESI:
  1285. case ATM_GETADDR:
  1286. case ATM_RSTADDR:
  1287. case ATM_ADDADDR:
  1288. case ATM_DELADDR:
  1289. case ATM_GETCIRANGE:
  1290. case ATM_SETCIRANGE:
  1291. case ATM_SETESI:
  1292. case ATM_SETESIF:
  1293. case ATM_GETSTAT:
  1294. case ATM_GETSTATZ:
  1295. case ATM_GETLOOP:
  1296. case ATM_SETLOOP:
  1297. case ATM_QUERYLOOP:
  1298. return do_atmif_sioc(fd, cmd, arg);
  1299. }
  1300. return -EINVAL;
  1301. }
  1302. static __attribute_used__ int
  1303. ret_einval(unsigned int fd, unsigned int cmd, unsigned long arg)
  1304. {
  1305. return -EINVAL;
  1306. }
  1307. #ifdef CONFIG_BLOCK
  1308. static int broken_blkgetsize(unsigned int fd, unsigned int cmd, unsigned long arg)
  1309. {
  1310. /* The mkswap binary hard codes it to Intel value :-((( */
  1311. return w_long(fd, BLKGETSIZE, arg);
  1312. }
  1313. struct blkpg_ioctl_arg32 {
  1314. compat_int_t op;
  1315. compat_int_t flags;
  1316. compat_int_t datalen;
  1317. compat_caddr_t data;
  1318. };
  1319. static int blkpg_ioctl_trans(unsigned int fd, unsigned int cmd, unsigned long arg)
  1320. {
  1321. struct blkpg_ioctl_arg32 __user *ua32 = compat_ptr(arg);
  1322. struct blkpg_ioctl_arg __user *a = compat_alloc_user_space(sizeof(*a));
  1323. compat_caddr_t udata;
  1324. compat_int_t n;
  1325. int err;
  1326. err = get_user(n, &ua32->op);
  1327. err |= put_user(n, &a->op);
  1328. err |= get_user(n, &ua32->flags);
  1329. err |= put_user(n, &a->flags);
  1330. err |= get_user(n, &ua32->datalen);
  1331. err |= put_user(n, &a->datalen);
  1332. err |= get_user(udata, &ua32->data);
  1333. err |= put_user(compat_ptr(udata), &a->data);
  1334. if (err)
  1335. return err;
  1336. return sys_ioctl(fd, cmd, (unsigned long)a);
  1337. }
  1338. #endif
  1339. static int ioc_settimeout(unsigned int fd, unsigned int cmd, unsigned long arg)
  1340. {
  1341. return rw_long(fd, AUTOFS_IOC_SETTIMEOUT, arg);
  1342. }
  1343. #ifdef CONFIG_BLOCK
  1344. /* Fix sizeof(sizeof()) breakage */
  1345. #define BLKBSZGET_32 _IOR(0x12,112,int)
  1346. #define BLKBSZSET_32 _IOW(0x12,113,int)
  1347. #define BLKGETSIZE64_32 _IOR(0x12,114,int)
  1348. static int do_blkbszget(unsigned int fd, unsigned int cmd, unsigned long arg)
  1349. {
  1350. return sys_ioctl(fd, BLKBSZGET, (unsigned long)compat_ptr(arg));
  1351. }
  1352. static int do_blkbszset(unsigned int fd, unsigned int cmd, unsigned long arg)
  1353. {
  1354. return sys_ioctl(fd, BLKBSZSET, (unsigned long)compat_ptr(arg));
  1355. }
  1356. static int do_blkgetsize64(unsigned int fd, unsigned int cmd,
  1357. unsigned long arg)
  1358. {
  1359. return sys_ioctl(fd, BLKGETSIZE64, (unsigned long)compat_ptr(arg));
  1360. }
  1361. #endif
  1362. /* Bluetooth ioctls */
  1363. #define HCIUARTSETPROTO _IOW('U', 200, int)
  1364. #define HCIUARTGETPROTO _IOR('U', 201, int)
  1365. #define BNEPCONNADD _IOW('B', 200, int)
  1366. #define BNEPCONNDEL _IOW('B', 201, int)
  1367. #define BNEPGETCONNLIST _IOR('B', 210, int)
  1368. #define BNEPGETCONNINFO _IOR('B', 211, int)
  1369. #define CMTPCONNADD _IOW('C', 200, int)
  1370. #define CMTPCONNDEL _IOW('C', 201, int)
  1371. #define CMTPGETCONNLIST _IOR('C', 210, int)
  1372. #define CMTPGETCONNINFO _IOR('C', 211, int)
  1373. #define HIDPCONNADD _IOW('H', 200, int)
  1374. #define HIDPCONNDEL _IOW('H', 201, int)
  1375. #define HIDPGETCONNLIST _IOR('H', 210, int)
  1376. #define HIDPGETCONNINFO _IOR('H', 211, int)
  1377. #ifdef CONFIG_BLOCK
  1378. struct floppy_struct32 {
  1379. compat_uint_t size;
  1380. compat_uint_t sect;
  1381. compat_uint_t head;
  1382. compat_uint_t track;
  1383. compat_uint_t stretch;
  1384. unsigned char gap;
  1385. unsigned char rate;
  1386. unsigned char spec1;
  1387. unsigned char fmt_gap;
  1388. const compat_caddr_t name;
  1389. };
  1390. struct floppy_drive_params32 {
  1391. char cmos;
  1392. compat_ulong_t max_dtr;
  1393. compat_ulong_t hlt;
  1394. compat_ulong_t hut;
  1395. compat_ulong_t srt;
  1396. compat_ulong_t spinup;
  1397. compat_ulong_t spindown;
  1398. unsigned char spindown_offset;
  1399. unsigned char select_delay;
  1400. unsigned char rps;
  1401. unsigned char tracks;
  1402. compat_ulong_t timeout;
  1403. unsigned char interleave_sect;
  1404. struct floppy_max_errors max_errors;
  1405. char flags;
  1406. char read_track;
  1407. short autodetect[8];
  1408. compat_int_t checkfreq;
  1409. compat_int_t native_format;
  1410. };
  1411. struct floppy_drive_struct32 {
  1412. signed char flags;
  1413. compat_ulong_t spinup_date;
  1414. compat_ulong_t select_date;
  1415. compat_ulong_t first_read_date;
  1416. short probed_format;
  1417. short track;
  1418. short maxblock;
  1419. short maxtrack;
  1420. compat_int_t generation;
  1421. compat_int_t keep_data;
  1422. compat_int_t fd_ref;
  1423. compat_int_t fd_device;
  1424. compat_int_t last_checked;
  1425. compat_caddr_t dmabuf;
  1426. compat_int_t bufblocks;
  1427. };
  1428. struct floppy_fdc_state32 {
  1429. compat_int_t spec1;
  1430. compat_int_t spec2;
  1431. compat_int_t dtr;
  1432. unsigned char version;
  1433. unsigned char dor;
  1434. compat_ulong_t address;
  1435. unsigned int rawcmd:2;
  1436. unsigned int reset:1;
  1437. unsigned int need_configure:1;
  1438. unsigned int perp_mode:2;
  1439. unsigned int has_fifo:1;
  1440. unsigned int driver_version;
  1441. unsigned char track[4];
  1442. };
  1443. struct floppy_write_errors32 {
  1444. unsigned int write_errors;
  1445. compat_ulong_t first_error_sector;
  1446. compat_int_t first_error_generation;
  1447. compat_ulong_t last_error_sector;
  1448. compat_int_t last_error_generation;
  1449. compat_uint_t badness;
  1450. };
  1451. #define FDSETPRM32 _IOW(2, 0x42, struct floppy_struct32)
  1452. #define FDDEFPRM32 _IOW(2, 0x43, struct floppy_struct32)
  1453. #define FDGETPRM32 _IOR(2, 0x04, struct floppy_struct32)
  1454. #define FDSETDRVPRM32 _IOW(2, 0x90, struct floppy_drive_params32)
  1455. #define FDGETDRVPRM32 _IOR(2, 0x11, struct floppy_drive_params32)
  1456. #define FDGETDRVSTAT32 _IOR(2, 0x12, struct floppy_drive_struct32)
  1457. #define FDPOLLDRVSTAT32 _IOR(2, 0x13, struct floppy_drive_struct32)
  1458. #define FDGETFDCSTAT32 _IOR(2, 0x15, struct floppy_fdc_state32)
  1459. #define FDWERRORGET32 _IOR(2, 0x17, struct floppy_write_errors32)
  1460. static struct {
  1461. unsigned int cmd32;
  1462. unsigned int cmd;
  1463. } fd_ioctl_trans_table[] = {
  1464. { FDSETPRM32, FDSETPRM },
  1465. { FDDEFPRM32, FDDEFPRM },
  1466. { FDGETPRM32, FDGETPRM },
  1467. { FDSETDRVPRM32, FDSETDRVPRM },
  1468. { FDGETDRVPRM32, FDGETDRVPRM },
  1469. { FDGETDRVSTAT32, FDGETDRVSTAT },
  1470. { FDPOLLDRVSTAT32, FDPOLLDRVSTAT },
  1471. { FDGETFDCSTAT32, FDGETFDCSTAT },
  1472. { FDWERRORGET32, FDWERRORGET }
  1473. };
  1474. #define NR_FD_IOCTL_TRANS ARRAY_SIZE(fd_ioctl_trans_table)
  1475. static int fd_ioctl_trans(unsigned int fd, unsigned int cmd, unsigned long arg)
  1476. {
  1477. mm_segment_t old_fs = get_fs();
  1478. void *karg = NULL;
  1479. unsigned int kcmd = 0;
  1480. int i, err;
  1481. for (i = 0; i < NR_FD_IOCTL_TRANS; i++)
  1482. if (cmd == fd_ioctl_trans_table[i].cmd32) {
  1483. kcmd = fd_ioctl_trans_table[i].cmd;
  1484. break;
  1485. }
  1486. if (!kcmd)
  1487. return -EINVAL;
  1488. switch (cmd) {
  1489. case FDSETPRM32:
  1490. case FDDEFPRM32:
  1491. case FDGETPRM32:
  1492. {
  1493. compat_uptr_t name;
  1494. struct floppy_struct32 __user *uf;
  1495. struct floppy_struct *f;
  1496. uf = compat_ptr(arg);
  1497. f = karg = kmalloc(sizeof(struct floppy_struct), GFP_KERNEL);
  1498. if (!karg)
  1499. return -ENOMEM;
  1500. if (cmd == FDGETPRM32)
  1501. break;
  1502. err = __get_user(f->size, &uf->size);
  1503. err |= __get_user(f->sect, &uf->sect);
  1504. err |= __get_user(f->head, &uf->head);
  1505. err |= __get_user(f->track, &uf->track);
  1506. err |= __get_user(f->stretch, &uf->stretch);
  1507. err |= __get_user(f->gap, &uf->gap);
  1508. err |= __get_user(f->rate, &uf->rate);
  1509. err |= __get_user(f->spec1, &uf->spec1);
  1510. err |= __get_user(f->fmt_gap, &uf->fmt_gap);
  1511. err |= __get_user(name, &uf->name);
  1512. f->name = compat_ptr(name);
  1513. if (err) {
  1514. err = -EFAULT;
  1515. goto out;
  1516. }
  1517. break;
  1518. }
  1519. case FDSETDRVPRM32:
  1520. case FDGETDRVPRM32:
  1521. {
  1522. struct floppy_drive_params32 __user *uf;
  1523. struct floppy_drive_params *f;
  1524. uf = compat_ptr(arg);
  1525. f = karg = kmalloc(sizeof(struct floppy_drive_params), GFP_KERNEL);
  1526. if (!karg)
  1527. return -ENOMEM;
  1528. if (cmd == FDGETDRVPRM32)
  1529. break;
  1530. err = __get_user(f->cmos, &uf->cmos);
  1531. err |= __get_user(f->max_dtr, &uf->max_dtr);
  1532. err |= __get_user(f->hlt, &uf->hlt);
  1533. err |= __get_user(f->hut, &uf->hut);
  1534. err |= __get_user(f->srt, &uf->srt);
  1535. err |= __get_user(f->spinup, &uf->spinup);
  1536. err |= __get_user(f->spindown, &uf->spindown);
  1537. err |= __get_user(f->spindown_offset, &uf->spindown_offset);
  1538. err |= __get_user(f->select_delay, &uf->select_delay);
  1539. err |= __get_user(f->rps, &uf->rps);
  1540. err |= __get_user(f->tracks, &uf->tracks);
  1541. err |= __get_user(f->timeout, &uf->timeout);
  1542. err |= __get_user(f->interleave_sect, &uf->interleave_sect);
  1543. err |= __copy_from_user(&f->max_errors, &uf->max_errors, sizeof(f->max_errors));
  1544. err |= __get_user(f->flags, &uf->flags);
  1545. err |= __get_user(f->read_track, &uf->read_track);
  1546. err |= __copy_from_user(f->autodetect, uf->autodetect, sizeof(f->autodetect));
  1547. err |= __get_user(f->checkfreq, &uf->checkfreq);
  1548. err |= __get_user(f->native_format, &uf->native_format);
  1549. if (err) {
  1550. err = -EFAULT;
  1551. goto out;
  1552. }
  1553. break;
  1554. }
  1555. case FDGETDRVSTAT32:
  1556. case FDPOLLDRVSTAT32:
  1557. karg = kmalloc(sizeof(struct floppy_drive_struct), GFP_KERNEL);
  1558. if (!karg)
  1559. return -ENOMEM;
  1560. break;
  1561. case FDGETFDCSTAT32:
  1562. karg = kmalloc(sizeof(struct floppy_fdc_state), GFP_KERNEL);
  1563. if (!karg)
  1564. return -ENOMEM;
  1565. break;
  1566. case FDWERRORGET32:
  1567. karg = kmalloc(sizeof(struct floppy_write_errors), GFP_KERNEL);
  1568. if (!karg)
  1569. return -ENOMEM;
  1570. break;
  1571. default:
  1572. return -EINVAL;
  1573. }
  1574. set_fs (KERNEL_DS);
  1575. err = sys_ioctl (fd, kcmd, (unsigned long)karg);
  1576. set_fs (old_fs);
  1577. if (err)
  1578. goto out;
  1579. switch (cmd) {
  1580. case FDGETPRM32:
  1581. {
  1582. struct floppy_struct *f = karg;
  1583. struct floppy_struct32 __user *uf = compat_ptr(arg);
  1584. err = __put_user(f->size, &uf->size);
  1585. err |= __put_user(f->sect, &uf->sect);
  1586. err |= __put_user(f->head, &uf->head);
  1587. err |= __put_user(f->track, &uf->track);
  1588. err |= __put_user(f->stretch, &uf->stretch);
  1589. err |= __put_user(f->gap, &uf->gap);
  1590. err |= __put_user(f->rate, &uf->rate);
  1591. err |= __put_user(f->spec1, &uf->spec1);
  1592. err |= __put_user(f->fmt_gap, &uf->fmt_gap);
  1593. err |= __put_user((u64)f->name, (compat_caddr_t __user *)&uf->name);
  1594. break;
  1595. }
  1596. case FDGETDRVPRM32:
  1597. {
  1598. struct floppy_drive_params32 __user *uf;
  1599. struct floppy_drive_params *f = karg;
  1600. uf = compat_ptr(arg);
  1601. err = __put_user(f->cmos, &uf->cmos);
  1602. err |= __put_user(f->max_dtr, &uf->max_dtr);
  1603. err |= __put_user(f->hlt, &uf->hlt);
  1604. err |= __put_user(f->hut, &uf->hut);
  1605. err |= __put_user(f->srt, &uf->srt);
  1606. err |= __put_user(f->spinup, &uf->spinup);
  1607. err |= __put_user(f->spindown, &uf->spindown);
  1608. err |= __put_user(f->spindown_offset, &uf->spindown_offset);
  1609. err |= __put_user(f->select_delay, &uf->select_delay);
  1610. err |= __put_user(f->rps, &uf->rps);
  1611. err |= __put_user(f->tracks, &uf->tracks);
  1612. err |= __put_user(f->timeout, &uf->timeout);
  1613. err |= __put_user(f->interleave_sect, &uf->interleave_sect);
  1614. err |= __copy_to_user(&uf->max_errors, &f->max_errors, sizeof(f->max_errors));
  1615. err |= __put_user(f->flags, &uf->flags);
  1616. err |= __put_user(f->read_track, &uf->read_track);
  1617. err |= __copy_to_user(uf->autodetect, f->autodetect, sizeof(f->autodetect));
  1618. err |= __put_user(f->checkfreq, &uf->checkfreq);
  1619. err |= __put_user(f->native_format, &uf->native_format);
  1620. break;
  1621. }
  1622. case FDGETDRVSTAT32:
  1623. case FDPOLLDRVSTAT32:
  1624. {
  1625. struct floppy_drive_struct32 __user *uf;
  1626. struct floppy_drive_struct *f = karg;
  1627. uf = compat_ptr(arg);
  1628. err = __put_user(f->flags, &uf->flags);
  1629. err |= __put_user(f->spinup_date, &uf->spinup_date);
  1630. err |= __put_user(f->select_date, &uf->select_date);
  1631. err |= __put_user(f->first_read_date, &uf->first_read_date);
  1632. err |= __put_user(f->probed_format, &uf->probed_format);
  1633. err |= __put_user(f->track, &uf->track);
  1634. err |= __put_user(f->maxblock, &uf->maxblock);
  1635. err |= __put_user(f->maxtrack, &uf->maxtrack);
  1636. err |= __put_user(f->generation, &uf->generation);
  1637. err |= __put_user(f->keep_data, &uf->keep_data);
  1638. err |= __put_user(f->fd_ref, &uf->fd_ref);
  1639. err |= __put_user(f->fd_device, &uf->fd_device);
  1640. err |= __put_user(f->last_checked, &uf->last_checked);
  1641. err |= __put_user((u64)f->dmabuf, &uf->dmabuf);
  1642. err |= __put_user((u64)f->bufblocks, &uf->bufblocks);
  1643. break;
  1644. }
  1645. case FDGETFDCSTAT32:
  1646. {
  1647. struct floppy_fdc_state32 __user *uf;
  1648. struct floppy_fdc_state *f = karg;
  1649. uf = compat_ptr(arg);
  1650. err = __put_user(f->spec1, &uf->spec1);
  1651. err |= __put_user(f->spec2, &uf->spec2);
  1652. err |= __put_user(f->dtr, &uf->dtr);
  1653. err |= __put_user(f->version, &uf->version);
  1654. err |= __put_user(f->dor, &uf->dor);
  1655. err |= __put_user(f->address, &uf->address);
  1656. err |= __copy_to_user((char __user *)&uf->address + sizeof(uf->address),
  1657. (char *)&f->address + sizeof(f->address), sizeof(int));
  1658. err |= __put_user(f->driver_version, &uf->driver_version);
  1659. err |= __copy_to_user(uf->track, f->track, sizeof(f->track));
  1660. break;
  1661. }
  1662. case FDWERRORGET32:
  1663. {
  1664. struct floppy_write_errors32 __user *uf;
  1665. struct floppy_write_errors *f = karg;
  1666. uf = compat_ptr(arg);
  1667. err = __put_user(f->write_errors, &uf->write_errors);
  1668. err |= __put_user(f->first_error_sector, &uf->first_error_sector);
  1669. err |= __put_user(f->first_error_generation, &uf->first_error_generation);
  1670. err |= __put_user(f->last_error_sector, &uf->last_error_sector);
  1671. err |= __put_user(f->last_error_generation, &uf->last_error_generation);
  1672. err |= __put_user(f->badness, &uf->badness);
  1673. break;
  1674. }
  1675. default:
  1676. break;
  1677. }
  1678. if (err)
  1679. err = -EFAULT;
  1680. out:
  1681. kfree(karg);
  1682. return err;
  1683. }
  1684. #endif
  1685. struct mtd_oob_buf32 {
  1686. u_int32_t start;
  1687. u_int32_t length;
  1688. compat_caddr_t ptr; /* unsigned char* */
  1689. };
  1690. #define MEMWRITEOOB32 _IOWR('M',3,struct mtd_oob_buf32)
  1691. #define MEMREADOOB32 _IOWR('M',4,struct mtd_oob_buf32)
  1692. static int mtd_rw_oob(unsigned int fd, unsigned int cmd, unsigned long arg)
  1693. {
  1694. struct mtd_oob_buf __user *buf = compat_alloc_user_space(sizeof(*buf));
  1695. struct mtd_oob_buf32 __user *buf32 = compat_ptr(arg);
  1696. u32 data;
  1697. char __user *datap;
  1698. unsigned int real_cmd;
  1699. int err;
  1700. real_cmd = (cmd == MEMREADOOB32) ?
  1701. MEMREADOOB : MEMWRITEOOB;
  1702. if (copy_in_user(&buf->start, &buf32->start,
  1703. 2 * sizeof(u32)) ||
  1704. get_user(data, &buf32->ptr))
  1705. return -EFAULT;
  1706. datap = compat_ptr(data);
  1707. if (put_user(datap, &buf->ptr))
  1708. return -EFAULT;
  1709. err = sys_ioctl(fd, real_cmd, (unsigned long) buf);
  1710. if (!err) {
  1711. if (copy_in_user(&buf32->start, &buf->start,
  1712. 2 * sizeof(u32)))
  1713. err = -EFAULT;
  1714. }
  1715. return err;
  1716. }
  1717. #ifdef CONFIG_BLOCK
  1718. struct raw32_config_request
  1719. {
  1720. compat_int_t raw_minor;
  1721. __u64 block_major;
  1722. __u64 block_minor;
  1723. } __attribute__((packed));
  1724. static int get_raw32_request(struct raw_config_request *req, struct raw32_config_request __user *user_req)
  1725. {
  1726. int ret;
  1727. if (!access_ok(VERIFY_READ, user_req, sizeof(struct raw32_config_request)))
  1728. return -EFAULT;
  1729. ret = __get_user(req->raw_minor, &user_req->raw_minor);
  1730. ret |= __get_user(req->block_major, &user_req->block_major);
  1731. ret |= __get_user(req->block_minor, &user_req->block_minor);
  1732. return ret ? -EFAULT : 0;
  1733. }
  1734. static int set_raw32_request(struct raw_config_request *req, struct raw32_config_request __user *user_req)
  1735. {
  1736. int ret;
  1737. if (!access_ok(VERIFY_WRITE, user_req, sizeof(struct raw32_config_request)))
  1738. return -EFAULT;
  1739. ret = __put_user(req->raw_minor, &user_req->raw_minor);
  1740. ret |= __put_user(req->block_major, &user_req->block_major);
  1741. ret |= __put_user(req->block_minor, &user_req->block_minor);
  1742. return ret ? -EFAULT : 0;
  1743. }
  1744. static int raw_ioctl(unsigned fd, unsigned cmd, unsigned long arg)
  1745. {
  1746. int ret;
  1747. switch (cmd) {
  1748. case RAW_SETBIND:
  1749. case RAW_GETBIND: {
  1750. struct raw_config_request req;
  1751. struct raw32_config_request __user *user_req = compat_ptr(arg);
  1752. mm_segment_t oldfs = get_fs();
  1753. if ((ret = get_raw32_request(&req, user_req)))
  1754. return ret;
  1755. set_fs(KERNEL_DS);
  1756. ret = sys_ioctl(fd,cmd,(unsigned long)&req);
  1757. set_fs(oldfs);
  1758. if ((!ret) && (cmd == RAW_GETBIND)) {
  1759. ret = set_raw32_request(&req, user_req);
  1760. }
  1761. break;
  1762. }
  1763. default:
  1764. ret = sys_ioctl(fd, cmd, arg);
  1765. break;
  1766. }
  1767. return ret;
  1768. }
  1769. #endif /* CONFIG_BLOCK */
  1770. struct serial_struct32 {
  1771. compat_int_t type;
  1772. compat_int_t line;
  1773. compat_uint_t port;
  1774. compat_int_t irq;
  1775. compat_int_t flags;
  1776. compat_int_t xmit_fifo_size;
  1777. compat_int_t custom_divisor;
  1778. compat_int_t baud_base;
  1779. unsigned short close_delay;
  1780. char io_type;
  1781. char reserved_char[1];
  1782. compat_int_t hub6;
  1783. unsigned short closing_wait; /* time to wait before closing */
  1784. unsigned short closing_wait2; /* no longer used... */
  1785. compat_uint_t iomem_base;
  1786. unsigned short iomem_reg_shift;
  1787. unsigned int port_high;
  1788. /* compat_ulong_t iomap_base FIXME */
  1789. compat_int_t reserved[1];
  1790. };
  1791. static int serial_struct_ioctl(unsigned fd, unsigned cmd, unsigned long arg)
  1792. {
  1793. typedef struct serial_struct SS;
  1794. typedef struct serial_struct32 SS32;
  1795. struct serial_struct32 __user *ss32 = compat_ptr(arg);
  1796. int err;
  1797. struct serial_struct ss;
  1798. mm_segment_t oldseg = get_fs();
  1799. __u32 udata;
  1800. unsigned int base;
  1801. if (cmd == TIOCSSERIAL) {
  1802. if (!access_ok(VERIFY_READ, ss32, sizeof(SS32)))
  1803. return -EFAULT;
  1804. if (__copy_from_user(&ss, ss32, offsetof(SS32, iomem_base)))
  1805. return -EFAULT;
  1806. if (__get_user(udata, &ss32->iomem_base))
  1807. return -EFAULT;
  1808. ss.iomem_base = compat_ptr(udata);
  1809. if (__get_user(ss.iomem_reg_shift, &ss32->iomem_reg_shift) ||
  1810. __get_user(ss.port_high, &ss32->port_high))
  1811. return -EFAULT;
  1812. ss.iomap_base = 0UL;
  1813. }
  1814. set_fs(KERNEL_DS);
  1815. err = sys_ioctl(fd,cmd,(unsigned long)(&ss));
  1816. set_fs(oldseg);
  1817. if (cmd == TIOCGSERIAL && err >= 0) {
  1818. if (!access_ok(VERIFY_WRITE, ss32, sizeof(SS32)))
  1819. return -EFAULT;
  1820. if (__copy_to_user(ss32,&ss,offsetof(SS32,iomem_base)))
  1821. return -EFAULT;
  1822. base = (unsigned long)ss.iomem_base >> 32 ?
  1823. 0xffffffff : (unsigned)(unsigned long)ss.iomem_base;
  1824. if (__put_user(base, &ss32->iomem_base) ||
  1825. __put_user(ss.iomem_reg_shift, &ss32->iomem_reg_shift) ||
  1826. __put_user(ss.port_high, &ss32->port_high))
  1827. return -EFAULT;
  1828. }
  1829. return err;
  1830. }
  1831. struct usbdevfs_ctrltransfer32 {
  1832. u8 bRequestType;
  1833. u8 bRequest;
  1834. u16 wValue;
  1835. u16 wIndex;
  1836. u16 wLength;
  1837. u32 timeout; /* in milliseconds */
  1838. compat_caddr_t data;
  1839. };
  1840. #define USBDEVFS_CONTROL32 _IOWR('U', 0, struct usbdevfs_ctrltransfer32)
  1841. static int do_usbdevfs_control(unsigned int fd, unsigned int cmd, unsigned long arg)
  1842. {
  1843. struct usbdevfs_ctrltransfer32 __user *p32 = compat_ptr(arg);
  1844. struct usbdevfs_ctrltransfer __user *p;
  1845. __u32 udata;
  1846. p = compat_alloc_user_space(sizeof(*p));
  1847. if (copy_in_user(p, p32, (sizeof(*p32) - sizeof(compat_caddr_t))) ||
  1848. get_user(udata, &p32->data) ||
  1849. put_user(compat_ptr(udata), &p->data))
  1850. return -EFAULT;
  1851. return sys_ioctl(fd, USBDEVFS_CONTROL, (unsigned long)p);
  1852. }
  1853. struct usbdevfs_bulktransfer32 {
  1854. compat_uint_t ep;
  1855. compat_uint_t len;
  1856. compat_uint_t timeout; /* in milliseconds */
  1857. compat_caddr_t data;
  1858. };
  1859. #define USBDEVFS_BULK32 _IOWR('U', 2, struct usbdevfs_bulktransfer32)
  1860. static int do_usbdevfs_bulk(unsigned int fd, unsigned int cmd, unsigned long arg)
  1861. {
  1862. struct usbdevfs_bulktransfer32 __user *p32 = compat_ptr(arg);
  1863. struct usbdevfs_bulktransfer __user *p;
  1864. compat_uint_t n;
  1865. compat_caddr_t addr;
  1866. p = compat_alloc_user_space(sizeof(*p));
  1867. if (get_user(n, &p32->ep) || put_user(n, &p->ep) ||
  1868. get_user(n, &p32->len) || put_user(n, &p->len) ||
  1869. get_user(n, &p32->timeout) || put_user(n, &p->timeout) ||
  1870. get_user(addr, &p32->data) || put_user(compat_ptr(addr), &p->data))
  1871. return -EFAULT;
  1872. return sys_ioctl(fd, USBDEVFS_BULK, (unsigned long)p);
  1873. }
  1874. /*
  1875. * USBDEVFS_SUBMITURB, USBDEVFS_REAPURB and USBDEVFS_REAPURBNDELAY
  1876. * are handled in usbdevfs core. -Christopher Li
  1877. */
  1878. struct usbdevfs_disconnectsignal32 {
  1879. compat_int_t signr;
  1880. compat_caddr_t context;
  1881. };
  1882. #define USBDEVFS_DISCSIGNAL32 _IOR('U', 14, struct usbdevfs_disconnectsignal32)
  1883. static int do_usbdevfs_discsignal(unsigned int fd, unsigned int cmd, unsigned long arg)
  1884. {
  1885. struct usbdevfs_disconnectsignal kdis;
  1886. struct usbdevfs_disconnectsignal32 __user *udis;
  1887. mm_segment_t old_fs;
  1888. u32 uctx;
  1889. int err;
  1890. udis = compat_ptr(arg);
  1891. if (get_user(kdis.signr, &udis->signr) ||
  1892. __get_user(uctx, &udis->context))
  1893. return -EFAULT;
  1894. kdis.context = compat_ptr(uctx);
  1895. old_fs = get_fs();
  1896. set_fs(KERNEL_DS);
  1897. err = sys_ioctl(fd, USBDEVFS_DISCSIGNAL, (unsigned long) &kdis);
  1898. set_fs(old_fs);
  1899. return err;
  1900. }
  1901. /*
  1902. * I2C layer ioctls
  1903. */
  1904. struct i2c_msg32 {
  1905. u16 addr;
  1906. u16 flags;
  1907. u16 len;
  1908. compat_caddr_t buf;
  1909. };
  1910. struct i2c_rdwr_ioctl_data32 {
  1911. compat_caddr_t msgs; /* struct i2c_msg __user *msgs */
  1912. u32 nmsgs;
  1913. };
  1914. struct i2c_smbus_ioctl_data32 {
  1915. u8 read_write;
  1916. u8 command;
  1917. u32 size;
  1918. compat_caddr_t data; /* union i2c_smbus_data *data */
  1919. };
  1920. struct i2c_rdwr_aligned {
  1921. struct i2c_rdwr_ioctl_data cmd;
  1922. struct i2c_msg msgs[0];
  1923. };
  1924. static int do_i2c_rdwr_ioctl(unsigned int fd, unsigned int cmd, unsigned long arg)
  1925. {
  1926. struct i2c_rdwr_ioctl_data32 __user *udata = compat_ptr(arg);
  1927. struct i2c_rdwr_aligned __user *tdata;
  1928. struct i2c_msg __user *tmsgs;
  1929. struct i2c_msg32 __user *umsgs;
  1930. compat_caddr_t datap;
  1931. int nmsgs, i;
  1932. if (get_user(nmsgs, &udata->nmsgs))
  1933. return -EFAULT;
  1934. if (nmsgs > I2C_RDRW_IOCTL_MAX_MSGS)
  1935. return -EINVAL;
  1936. if (get_user(datap, &udata->msgs))
  1937. return -EFAULT;
  1938. umsgs = compat_ptr(datap);
  1939. tdata = compat_alloc_user_space(sizeof(*tdata) +
  1940. nmsgs * sizeof(struct i2c_msg));
  1941. tmsgs = &tdata->msgs[0];
  1942. if (put_user(nmsgs, &tdata->cmd.nmsgs) ||
  1943. put_user(tmsgs, &tdata->cmd.msgs))
  1944. return -EFAULT;
  1945. for (i = 0; i < nmsgs; i++) {
  1946. if (copy_in_user(&tmsgs[i].addr, &umsgs[i].addr, 3*sizeof(u16)))
  1947. return -EFAULT;
  1948. if (get_user(datap, &umsgs[i].buf) ||
  1949. put_user(compat_ptr(datap), &tmsgs[i].buf))
  1950. return -EFAULT;
  1951. }
  1952. return sys_ioctl(fd, cmd, (unsigned long)tdata);
  1953. }
  1954. static int do_i2c_smbus_ioctl(unsigned int fd, unsigned int cmd, unsigned long arg)
  1955. {
  1956. struct i2c_smbus_ioctl_data __user *tdata;
  1957. struct i2c_smbus_ioctl_data32 __user *udata;
  1958. compat_caddr_t datap;
  1959. tdata = compat_alloc_user_space(sizeof(*tdata));
  1960. if (tdata == NULL)
  1961. return -ENOMEM;
  1962. if (!access_ok(VERIFY_WRITE, tdata, sizeof(*tdata)))
  1963. return -EFAULT;
  1964. udata = compat_ptr(arg);
  1965. if (!access_ok(VERIFY_READ, udata, sizeof(*udata)))
  1966. return -EFAULT;
  1967. if (__copy_in_user(&tdata->read_write, &udata->read_write, 2 * sizeof(u8)))
  1968. return -EFAULT;
  1969. if (__copy_in_user(&tdata->size, &udata->size, 2 * sizeof(u32)))
  1970. return -EFAULT;
  1971. if (__get_user(datap, &udata->data) ||
  1972. __put_user(compat_ptr(datap), &tdata->data))
  1973. return -EFAULT;
  1974. return sys_ioctl(fd, cmd, (unsigned long)tdata);
  1975. }
  1976. struct compat_iw_point {
  1977. compat_caddr_t pointer;
  1978. __u16 length;
  1979. __u16 flags;
  1980. };
  1981. static int do_wireless_ioctl(unsigned int fd, unsigned int cmd, unsigned long arg)
  1982. {
  1983. struct iwreq __user *iwr;
  1984. struct iwreq __user *iwr_u;
  1985. struct iw_point __user *iwp;
  1986. struct compat_iw_point __user *iwp_u;
  1987. compat_caddr_t pointer;
  1988. __u16 length, flags;
  1989. iwr_u = compat_ptr(arg);
  1990. iwp_u = (struct compat_iw_point __user *) &iwr_u->u.data;
  1991. iwr = compat_alloc_user_space(sizeof(*iwr));
  1992. if (iwr == NULL)
  1993. return -ENOMEM;
  1994. iwp = &iwr->u.data;
  1995. if (!access_ok(VERIFY_WRITE, iwr, sizeof(*iwr)))
  1996. return -EFAULT;
  1997. if (__copy_in_user(&iwr->ifr_ifrn.ifrn_name[0],
  1998. &iwr_u->ifr_ifrn.ifrn_name[0],
  1999. sizeof(iwr->ifr_ifrn.ifrn_name)))
  2000. return -EFAULT;
  2001. if (__get_user(pointer, &iwp_u->pointer) ||
  2002. __get_user(length, &iwp_u->length) ||
  2003. __get_user(flags, &iwp_u->flags))
  2004. return -EFAULT;
  2005. if (__put_user(compat_ptr(pointer), &iwp->pointer) ||
  2006. __put_user(length, &iwp->length) ||
  2007. __put_user(flags, &iwp->flags))
  2008. return -EFAULT;
  2009. return sys_ioctl(fd, cmd, (unsigned long) iwr);
  2010. }
  2011. /* Since old style bridge ioctl's endup using SIOCDEVPRIVATE
  2012. * for some operations; this forces use of the newer bridge-utils that
  2013. * use compatiable ioctls
  2014. */
  2015. static int old_bridge_ioctl(unsigned int fd, unsigned int cmd, unsigned long arg)
  2016. {
  2017. u32 tmp;
  2018. if (get_user(tmp, (u32 __user *) arg))
  2019. return -EFAULT;
  2020. if (tmp == BRCTL_GET_VERSION)
  2021. return BRCTL_VERSION + 1;
  2022. return -EINVAL;
  2023. }
  2024. #define RTC_IRQP_READ32 _IOR('p', 0x0b, compat_ulong_t)
  2025. #define RTC_IRQP_SET32 _IOW('p', 0x0c, compat_ulong_t)
  2026. #define RTC_EPOCH_READ32 _IOR('p', 0x0d, compat_ulong_t)
  2027. #define RTC_EPOCH_SET32 _IOW('p', 0x0e, compat_ulong_t)
  2028. static int rtc_ioctl(unsigned fd, unsigned cmd, unsigned long arg)
  2029. {
  2030. mm_segment_t oldfs = get_fs();
  2031. compat_ulong_t val32;
  2032. unsigned long kval;
  2033. int ret;
  2034. switch (cmd) {
  2035. case RTC_IRQP_READ32:
  2036. case RTC_EPOCH_READ32:
  2037. set_fs(KERNEL_DS);
  2038. ret = sys_ioctl(fd, (cmd == RTC_IRQP_READ32) ?
  2039. RTC_IRQP_READ : RTC_EPOCH_READ,
  2040. (unsigned long)&kval);
  2041. set_fs(oldfs);
  2042. if (ret)
  2043. return ret;
  2044. val32 = kval;
  2045. return put_user(val32, (unsigned int __user *)arg);
  2046. case RTC_IRQP_SET32:
  2047. return sys_ioctl(fd, RTC_IRQP_SET, arg);
  2048. case RTC_EPOCH_SET32:
  2049. return sys_ioctl(fd, RTC_EPOCH_SET, arg);
  2050. default:
  2051. /* unreached */
  2052. return -ENOIOCTLCMD;
  2053. }
  2054. }
  2055. static int
  2056. lp_timeout_trans(unsigned int fd, unsigned int cmd, unsigned long arg)
  2057. {
  2058. struct compat_timeval __user *tc = (struct compat_timeval __user *)arg;
  2059. struct timeval __user *tn = compat_alloc_user_space(sizeof(struct timeval));
  2060. struct timeval ts;
  2061. if (get_user(ts.tv_sec, &tc->tv_sec) ||
  2062. get_user(ts.tv_usec, &tc->tv_usec) ||
  2063. put_user(ts.tv_sec, &tn->tv_sec) ||
  2064. put_user(ts.tv_usec, &tn->tv_usec))
  2065. return -EFAULT;
  2066. return sys_ioctl(fd, cmd, (unsigned long)tn);
  2067. }
  2068. #define HANDLE_IOCTL(cmd,handler) \
  2069. { (cmd), (ioctl_trans_handler_t)(handler) },
  2070. /* pointer to compatible structure or no argument */
  2071. #define COMPATIBLE_IOCTL(cmd) \
  2072. { (cmd), do_ioctl32_pointer },
  2073. /* argument is an unsigned long integer, not a pointer */
  2074. #define ULONG_IOCTL(cmd) \
  2075. { (cmd), (ioctl_trans_handler_t)sys_ioctl },
  2076. struct ioctl_trans ioctl_start[] = {
  2077. #include <linux/compat_ioctl.h>
  2078. HANDLE_IOCTL(MEMREADOOB32, mtd_rw_oob)
  2079. HANDLE_IOCTL(MEMWRITEOOB32, mtd_rw_oob)
  2080. #ifdef CONFIG_NET
  2081. HANDLE_IOCTL(SIOCGIFNAME, dev_ifname32)
  2082. HANDLE_IOCTL(SIOCGIFCONF, dev_ifconf)
  2083. HANDLE_IOCTL(SIOCGIFFLAGS, dev_ifsioc)
  2084. HANDLE_IOCTL(SIOCSIFFLAGS, dev_ifsioc)
  2085. HANDLE_IOCTL(SIOCGIFMETRIC, dev_ifsioc)
  2086. HANDLE_IOCTL(SIOCSIFMETRIC, dev_ifsioc)
  2087. HANDLE_IOCTL(SIOCGIFMTU, dev_ifsioc)
  2088. HANDLE_IOCTL(SIOCSIFMTU, dev_ifsioc)
  2089. HANDLE_IOCTL(SIOCGIFMEM, dev_ifsioc)
  2090. HANDLE_IOCTL(SIOCSIFMEM, dev_ifsioc)
  2091. HANDLE_IOCTL(SIOCGIFHWADDR, dev_ifsioc)
  2092. HANDLE_IOCTL(SIOCSIFHWADDR, dev_ifsioc)
  2093. HANDLE_IOCTL(SIOCADDMULTI, dev_ifsioc)
  2094. HANDLE_IOCTL(SIOCDELMULTI, dev_ifsioc)
  2095. HANDLE_IOCTL(SIOCGIFINDEX, dev_ifsioc)
  2096. HANDLE_IOCTL(SIOCGIFMAP, dev_ifsioc)
  2097. HANDLE_IOCTL(SIOCSIFMAP, dev_ifsioc)
  2098. HANDLE_IOCTL(SIOCGIFADDR, dev_ifsioc)
  2099. HANDLE_IOCTL(SIOCSIFADDR, dev_ifsioc)
  2100. HANDLE_IOCTL(SIOCSIFHWBROADCAST, dev_ifsioc)
  2101. /* ioctls used by appletalk ddp.c */
  2102. HANDLE_IOCTL(SIOCATALKDIFADDR, dev_ifsioc)
  2103. HANDLE_IOCTL(SIOCDIFADDR, dev_ifsioc)
  2104. HANDLE_IOCTL(SIOCSARP, dev_ifsioc)
  2105. HANDLE_IOCTL(SIOCDARP, dev_ifsioc)
  2106. HANDLE_IOCTL(SIOCGIFBRDADDR, dev_ifsioc)
  2107. HANDLE_IOCTL(SIOCSIFBRDADDR, dev_ifsioc)
  2108. HANDLE_IOCTL(SIOCGIFDSTADDR, dev_ifsioc)
  2109. HANDLE_IOCTL(SIOCSIFDSTADDR, dev_ifsioc)
  2110. HANDLE_IOCTL(SIOCGIFNETMASK, dev_ifsioc)
  2111. HANDLE_IOCTL(SIOCSIFNETMASK, dev_ifsioc)
  2112. HANDLE_IOCTL(SIOCSIFPFLAGS, dev_ifsioc)
  2113. HANDLE_IOCTL(SIOCGIFPFLAGS, dev_ifsioc)
  2114. HANDLE_IOCTL(SIOCGIFTXQLEN, dev_ifsioc)
  2115. HANDLE_IOCTL(SIOCSIFTXQLEN, dev_ifsioc)
  2116. HANDLE_IOCTL(TUNSETIFF, dev_ifsioc)
  2117. HANDLE_IOCTL(SIOCETHTOOL, ethtool_ioctl)
  2118. HANDLE_IOCTL(SIOCBONDENSLAVE, bond_ioctl)
  2119. HANDLE_IOCTL(SIOCBONDRELEASE, bond_ioctl)
  2120. HANDLE_IOCTL(SIOCBONDSETHWADDR, bond_ioctl)
  2121. HANDLE_IOCTL(SIOCBONDSLAVEINFOQUERY, bond_ioctl)
  2122. HANDLE_IOCTL(SIOCBONDINFOQUERY, bond_ioctl)
  2123. HANDLE_IOCTL(SIOCBONDCHANGEACTIVE, bond_ioctl)
  2124. HANDLE_IOCTL(SIOCADDRT, routing_ioctl)
  2125. HANDLE_IOCTL(SIOCDELRT, routing_ioctl)
  2126. HANDLE_IOCTL(SIOCBRADDIF, dev_ifsioc)
  2127. HANDLE_IOCTL(SIOCBRDELIF, dev_ifsioc)
  2128. /* Note SIOCRTMSG is no longer, so this is safe and * the user would have seen just an -EINVAL anyways. */
  2129. HANDLE_IOCTL(SIOCRTMSG, ret_einval)
  2130. HANDLE_IOCTL(SIOCGSTAMP, do_siocgstamp)
  2131. #endif
  2132. #ifdef CONFIG_BLOCK
  2133. HANDLE_IOCTL(HDIO_GETGEO, hdio_getgeo)
  2134. HANDLE_IOCTL(BLKRAGET, w_long)
  2135. HANDLE_IOCTL(BLKGETSIZE, w_long)
  2136. HANDLE_IOCTL(0x1260, broken_blkgetsize)
  2137. HANDLE_IOCTL(BLKFRAGET, w_long)
  2138. HANDLE_IOCTL(BLKSECTGET, w_long)
  2139. HANDLE_IOCTL(BLKPG, blkpg_ioctl_trans)
  2140. HANDLE_IOCTL(HDIO_GET_UNMASKINTR, hdio_ioctl_trans)
  2141. HANDLE_IOCTL(HDIO_GET_MULTCOUNT, hdio_ioctl_trans)
  2142. HANDLE_IOCTL(HDIO_GET_KEEPSETTINGS, hdio_ioctl_trans)
  2143. HANDLE_IOCTL(HDIO_GET_32BIT, hdio_ioctl_trans)
  2144. HANDLE_IOCTL(HDIO_GET_NOWERR, hdio_ioctl_trans)
  2145. HANDLE_IOCTL(HDIO_GET_DMA, hdio_ioctl_trans)
  2146. HANDLE_IOCTL(HDIO_GET_NICE, hdio_ioctl_trans)
  2147. HANDLE_IOCTL(HDIO_GET_WCACHE, hdio_ioctl_trans)
  2148. HANDLE_IOCTL(HDIO_GET_ACOUSTIC, hdio_ioctl_trans)
  2149. HANDLE_IOCTL(HDIO_GET_ADDRESS, hdio_ioctl_trans)
  2150. HANDLE_IOCTL(HDIO_GET_BUSSTATE, hdio_ioctl_trans)
  2151. HANDLE_IOCTL(FDSETPRM32, fd_ioctl_trans)
  2152. HANDLE_IOCTL(FDDEFPRM32, fd_ioctl_trans)
  2153. HANDLE_IOCTL(FDGETPRM32, fd_ioctl_trans)
  2154. HANDLE_IOCTL(FDSETDRVPRM32, fd_ioctl_trans)
  2155. HANDLE_IOCTL(FDGETDRVPRM32, fd_ioctl_trans)
  2156. HANDLE_IOCTL(FDGETDRVSTAT32, fd_ioctl_trans)
  2157. HANDLE_IOCTL(FDPOLLDRVSTAT32, fd_ioctl_trans)
  2158. HANDLE_IOCTL(FDGETFDCSTAT32, fd_ioctl_trans)
  2159. HANDLE_IOCTL(FDWERRORGET32, fd_ioctl_trans)
  2160. HANDLE_IOCTL(SG_IO,sg_ioctl_trans)
  2161. HANDLE_IOCTL(SG_GET_REQUEST_TABLE, sg_grt_trans)
  2162. #endif
  2163. HANDLE_IOCTL(PPPIOCGIDLE32, ppp_ioctl_trans)
  2164. HANDLE_IOCTL(PPPIOCSCOMPRESS32, ppp_ioctl_trans)
  2165. HANDLE_IOCTL(PPPIOCSPASS32, ppp_sock_fprog_ioctl_trans)
  2166. HANDLE_IOCTL(PPPIOCSACTIVE32, ppp_sock_fprog_ioctl_trans)
  2167. #ifdef CONFIG_BLOCK
  2168. HANDLE_IOCTL(MTIOCGET32, mt_ioctl_trans)
  2169. HANDLE_IOCTL(MTIOCPOS32, mt_ioctl_trans)
  2170. HANDLE_IOCTL(CDROMREADAUDIO, cdrom_ioctl_trans)
  2171. HANDLE_IOCTL(CDROM_SEND_PACKET, cdrom_ioctl_trans)
  2172. #endif
  2173. #define AUTOFS_IOC_SETTIMEOUT32 _IOWR(0x93,0x64,unsigned int)
  2174. HANDLE_IOCTL(AUTOFS_IOC_SETTIMEOUT32, ioc_settimeout)
  2175. #ifdef CONFIG_VT
  2176. HANDLE_IOCTL(PIO_FONTX, do_fontx_ioctl)
  2177. HANDLE_IOCTL(GIO_FONTX, do_fontx_ioctl)
  2178. HANDLE_IOCTL(PIO_UNIMAP, do_unimap_ioctl)
  2179. HANDLE_IOCTL(GIO_UNIMAP, do_unimap_ioctl)
  2180. HANDLE_IOCTL(KDFONTOP, do_kdfontop_ioctl)
  2181. #endif
  2182. /* One SMB ioctl needs translations. */
  2183. #define SMB_IOC_GETMOUNTUID_32 _IOR('u', 1, compat_uid_t)
  2184. HANDLE_IOCTL(SMB_IOC_GETMOUNTUID_32, do_smb_getmountuid)
  2185. HANDLE_IOCTL(ATM_GETLINKRATE32, do_atm_ioctl)
  2186. HANDLE_IOCTL(ATM_GETNAMES32, do_atm_ioctl)
  2187. HANDLE_IOCTL(ATM_GETTYPE32, do_atm_ioctl)
  2188. HANDLE_IOCTL(ATM_GETESI32, do_atm_ioctl)
  2189. HANDLE_IOCTL(ATM_GETADDR32, do_atm_ioctl)
  2190. HANDLE_IOCTL(ATM_RSTADDR32, do_atm_ioctl)
  2191. HANDLE_IOCTL(ATM_ADDADDR32, do_atm_ioctl)
  2192. HANDLE_IOCTL(ATM_DELADDR32, do_atm_ioctl)
  2193. HANDLE_IOCTL(ATM_GETCIRANGE32, do_atm_ioctl)
  2194. HANDLE_IOCTL(ATM_SETCIRANGE32, do_atm_ioctl)
  2195. HANDLE_IOCTL(ATM_SETESI32, do_atm_ioctl)
  2196. HANDLE_IOCTL(ATM_SETESIF32, do_atm_ioctl)
  2197. HANDLE_IOCTL(ATM_GETSTAT32, do_atm_ioctl)
  2198. HANDLE_IOCTL(ATM_GETSTATZ32, do_atm_ioctl)
  2199. HANDLE_IOCTL(ATM_GETLOOP32, do_atm_ioctl)
  2200. HANDLE_IOCTL(ATM_SETLOOP32, do_atm_ioctl)
  2201. HANDLE_IOCTL(ATM_QUERYLOOP32, do_atm_ioctl)
  2202. HANDLE_IOCTL(SONET_GETSTAT, do_atm_ioctl)
  2203. HANDLE_IOCTL(SONET_GETSTATZ, do_atm_ioctl)
  2204. HANDLE_IOCTL(SONET_GETDIAG, do_atm_ioctl)
  2205. HANDLE_IOCTL(SONET_SETDIAG, do_atm_ioctl)
  2206. HANDLE_IOCTL(SONET_CLRDIAG, do_atm_ioctl)
  2207. HANDLE_IOCTL(SONET_SETFRAMING, do_atm_ioctl)
  2208. HANDLE_IOCTL(SONET_GETFRAMING, do_atm_ioctl)
  2209. HANDLE_IOCTL(SONET_GETFRSENSE, do_atm_ioctl)
  2210. /* block stuff */
  2211. #ifdef CONFIG_BLOCK
  2212. HANDLE_IOCTL(BLKBSZGET_32, do_blkbszget)
  2213. HANDLE_IOCTL(BLKBSZSET_32, do_blkbszset)
  2214. HANDLE_IOCTL(BLKGETSIZE64_32, do_blkgetsize64)
  2215. /* Raw devices */
  2216. HANDLE_IOCTL(RAW_SETBIND, raw_ioctl)
  2217. HANDLE_IOCTL(RAW_GETBIND, raw_ioctl)
  2218. #endif
  2219. /* Serial */
  2220. HANDLE_IOCTL(TIOCGSERIAL, serial_struct_ioctl)
  2221. HANDLE_IOCTL(TIOCSSERIAL, serial_struct_ioctl)
  2222. #ifdef TIOCGLTC
  2223. COMPATIBLE_IOCTL(TIOCGLTC)
  2224. COMPATIBLE_IOCTL(TIOCSLTC)
  2225. #endif
  2226. #ifdef TIOCSTART
  2227. /*
  2228. * For these two we have defintions in ioctls.h and/or termios.h on
  2229. * some architectures but no actual implemention. Some applications
  2230. * like bash call them if they are defined in the headers, so we provide
  2231. * entries here to avoid syslog message spew.
  2232. */
  2233. COMPATIBLE_IOCTL(TIOCSTART)
  2234. COMPATIBLE_IOCTL(TIOCSTOP)
  2235. #endif
  2236. /* Usbdevfs */
  2237. HANDLE_IOCTL(USBDEVFS_CONTROL32, do_usbdevfs_control)
  2238. HANDLE_IOCTL(USBDEVFS_BULK32, do_usbdevfs_bulk)
  2239. HANDLE_IOCTL(USBDEVFS_DISCSIGNAL32, do_usbdevfs_discsignal)
  2240. COMPATIBLE_IOCTL(USBDEVFS_IOCTL32)
  2241. /* i2c */
  2242. HANDLE_IOCTL(I2C_FUNCS, w_long)
  2243. HANDLE_IOCTL(I2C_RDWR, do_i2c_rdwr_ioctl)
  2244. HANDLE_IOCTL(I2C_SMBUS, do_i2c_smbus_ioctl)
  2245. /* wireless */
  2246. HANDLE_IOCTL(SIOCGIWRANGE, do_wireless_ioctl)
  2247. HANDLE_IOCTL(SIOCGIWPRIV, do_wireless_ioctl)
  2248. HANDLE_IOCTL(SIOCGIWSTATS, do_wireless_ioctl)
  2249. HANDLE_IOCTL(SIOCSIWSPY, do_wireless_ioctl)
  2250. HANDLE_IOCTL(SIOCGIWSPY, do_wireless_ioctl)
  2251. HANDLE_IOCTL(SIOCSIWTHRSPY, do_wireless_ioctl)
  2252. HANDLE_IOCTL(SIOCGIWTHRSPY, do_wireless_ioctl)
  2253. HANDLE_IOCTL(SIOCSIWMLME, do_wireless_ioctl)
  2254. HANDLE_IOCTL(SIOCGIWAPLIST, do_wireless_ioctl)
  2255. HANDLE_IOCTL(SIOCSIWSCAN, do_wireless_ioctl)
  2256. HANDLE_IOCTL(SIOCGIWSCAN, do_wireless_ioctl)
  2257. HANDLE_IOCTL(SIOCSIWESSID, do_wireless_ioctl)
  2258. HANDLE_IOCTL(SIOCGIWESSID, do_wireless_ioctl)
  2259. HANDLE_IOCTL(SIOCSIWNICKN, do_wireless_ioctl)
  2260. HANDLE_IOCTL(SIOCGIWNICKN, do_wireless_ioctl)
  2261. HANDLE_IOCTL(SIOCSIWENCODE, do_wireless_ioctl)
  2262. HANDLE_IOCTL(SIOCGIWENCODE, do_wireless_ioctl)
  2263. HANDLE_IOCTL(SIOCSIWGENIE, do_wireless_ioctl)
  2264. HANDLE_IOCTL(SIOCGIWGENIE, do_wireless_ioctl)
  2265. HANDLE_IOCTL(SIOCSIWENCODEEXT, do_wireless_ioctl)
  2266. HANDLE_IOCTL(SIOCGIWENCODEEXT, do_wireless_ioctl)
  2267. HANDLE_IOCTL(SIOCSIWPMKSA, do_wireless_ioctl)
  2268. HANDLE_IOCTL(SIOCSIFBR, old_bridge_ioctl)
  2269. HANDLE_IOCTL(SIOCGIFBR, old_bridge_ioctl)
  2270. HANDLE_IOCTL(RTC_IRQP_READ32, rtc_ioctl)
  2271. HANDLE_IOCTL(RTC_IRQP_SET32, rtc_ioctl)
  2272. HANDLE_IOCTL(RTC_EPOCH_READ32, rtc_ioctl)
  2273. HANDLE_IOCTL(RTC_EPOCH_SET32, rtc_ioctl)
  2274. /* dvb */
  2275. HANDLE_IOCTL(VIDEO_GET_EVENT, do_video_get_event)
  2276. HANDLE_IOCTL(VIDEO_STILLPICTURE, do_video_stillpicture)
  2277. HANDLE_IOCTL(VIDEO_SET_SPU_PALETTE, do_video_set_spu_palette)
  2278. /* parport */
  2279. COMPATIBLE_IOCTL(LPTIME)
  2280. COMPATIBLE_IOCTL(LPCHAR)
  2281. COMPATIBLE_IOCTL(LPABORTOPEN)
  2282. COMPATIBLE_IOCTL(LPCAREFUL)
  2283. COMPATIBLE_IOCTL(LPWAIT)
  2284. COMPATIBLE_IOCTL(LPSETIRQ)
  2285. COMPATIBLE_IOCTL(LPGETSTATUS)
  2286. COMPATIBLE_IOCTL(LPGETSTATUS)
  2287. COMPATIBLE_IOCTL(LPRESET)
  2288. /*LPGETSTATS not implemented, but no kernels seem to compile it in anyways*/
  2289. COMPATIBLE_IOCTL(LPGETFLAGS)
  2290. HANDLE_IOCTL(LPSETTIMEOUT, lp_timeout_trans)
  2291. };
  2292. int ioctl_table_size = ARRAY_SIZE(ioctl_start);