compat_ioctl.c 82 KB

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