compat.c 53 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060206120622063206420652066206720682069207020712072207320742075207620772078207920802081208220832084208520862087208820892090209120922093209420952096209720982099210021012102210321042105210621072108210921102111211221132114211521162117211821192120212121222123212421252126212721282129213021312132213321342135213621372138213921402141214221432144214521462147214821492150215121522153215421552156215721582159216021612162216321642165216621672168216921702171217221732174217521762177217821792180218121822183218421852186218721882189219021912192219321942195219621972198219922002201220222032204220522062207220822092210221122122213221422152216221722182219222022212222222322242225222622272228222922302231223222332234
  1. /*
  2. * linux/fs/compat.c
  3. *
  4. * Kernel compatibililty routines for e.g. 32 bit syscall support
  5. * on 64 bit kernels.
  6. *
  7. * Copyright (C) 2002 Stephen Rothwell, IBM Corporation
  8. * Copyright (C) 1997-2000 Jakub Jelinek (jakub@redhat.com)
  9. * Copyright (C) 1998 Eddie C. Dost (ecd@skynet.be)
  10. * Copyright (C) 2001,2002 Andi Kleen, SuSE Labs
  11. * Copyright (C) 2003 Pavel Machek (pavel@suse.cz)
  12. *
  13. * This program is free software; you can redistribute it and/or modify
  14. * it under the terms of the GNU General Public License version 2 as
  15. * published by the Free Software Foundation.
  16. */
  17. #include <linux/linkage.h>
  18. #include <linux/compat.h>
  19. #include <linux/errno.h>
  20. #include <linux/time.h>
  21. #include <linux/fs.h>
  22. #include <linux/fcntl.h>
  23. #include <linux/namei.h>
  24. #include <linux/file.h>
  25. #include <linux/vfs.h>
  26. #include <linux/ioctl32.h>
  27. #include <linux/ioctl.h>
  28. #include <linux/init.h>
  29. #include <linux/sockios.h> /* for SIOCDEVPRIVATE */
  30. #include <linux/smb.h>
  31. #include <linux/smb_mount.h>
  32. #include <linux/ncp_mount.h>
  33. #include <linux/nfs4_mount.h>
  34. #include <linux/smp_lock.h>
  35. #include <linux/syscalls.h>
  36. #include <linux/ctype.h>
  37. #include <linux/module.h>
  38. #include <linux/dirent.h>
  39. #include <linux/fsnotify.h>
  40. #include <linux/highuid.h>
  41. #include <linux/sunrpc/svc.h>
  42. #include <linux/nfsd/nfsd.h>
  43. #include <linux/nfsd/syscall.h>
  44. #include <linux/personality.h>
  45. #include <linux/rwsem.h>
  46. #include <linux/acct.h>
  47. #include <linux/mm.h>
  48. #include <net/sock.h> /* siocdevprivate_ioctl */
  49. #include <asm/uaccess.h>
  50. #include <asm/mmu_context.h>
  51. #include <asm/ioctls.h>
  52. #include "internal.h"
  53. int compat_log = 1;
  54. extern void sigset_from_compat(sigset_t *set, compat_sigset_t *compat);
  55. int compat_printk(const char *fmt, ...)
  56. {
  57. va_list ap;
  58. int ret;
  59. if (!compat_log)
  60. return 0;
  61. va_start(ap, fmt);
  62. ret = vprintk(fmt, ap);
  63. va_end(ap);
  64. return ret;
  65. }
  66. /*
  67. * Not all architectures have sys_utime, so implement this in terms
  68. * of sys_utimes.
  69. */
  70. asmlinkage long compat_sys_utime(char __user *filename, struct compat_utimbuf __user *t)
  71. {
  72. struct timeval tv[2];
  73. if (t) {
  74. if (get_user(tv[0].tv_sec, &t->actime) ||
  75. get_user(tv[1].tv_sec, &t->modtime))
  76. return -EFAULT;
  77. tv[0].tv_usec = 0;
  78. tv[1].tv_usec = 0;
  79. }
  80. return do_utimes(AT_FDCWD, filename, t ? tv : NULL);
  81. }
  82. asmlinkage long compat_sys_futimesat(unsigned int dfd, char __user *filename, struct compat_timeval __user *t)
  83. {
  84. struct timeval tv[2];
  85. if (t) {
  86. if (get_user(tv[0].tv_sec, &t[0].tv_sec) ||
  87. get_user(tv[0].tv_usec, &t[0].tv_usec) ||
  88. get_user(tv[1].tv_sec, &t[1].tv_sec) ||
  89. get_user(tv[1].tv_usec, &t[1].tv_usec))
  90. return -EFAULT;
  91. }
  92. return do_utimes(dfd, filename, t ? tv : NULL);
  93. }
  94. asmlinkage long compat_sys_utimes(char __user *filename, struct compat_timeval __user *t)
  95. {
  96. return compat_sys_futimesat(AT_FDCWD, filename, t);
  97. }
  98. asmlinkage long compat_sys_newstat(char __user * filename,
  99. struct compat_stat __user *statbuf)
  100. {
  101. struct kstat stat;
  102. int error = vfs_stat_fd(AT_FDCWD, filename, &stat);
  103. if (!error)
  104. error = cp_compat_stat(&stat, statbuf);
  105. return error;
  106. }
  107. asmlinkage long compat_sys_newlstat(char __user * filename,
  108. struct compat_stat __user *statbuf)
  109. {
  110. struct kstat stat;
  111. int error = vfs_lstat_fd(AT_FDCWD, filename, &stat);
  112. if (!error)
  113. error = cp_compat_stat(&stat, statbuf);
  114. return error;
  115. }
  116. #ifndef __ARCH_WANT_STAT64
  117. asmlinkage long compat_sys_newfstatat(unsigned int dfd, char __user *filename,
  118. struct compat_stat __user *statbuf, int flag)
  119. {
  120. struct kstat stat;
  121. int error = -EINVAL;
  122. if ((flag & ~AT_SYMLINK_NOFOLLOW) != 0)
  123. goto out;
  124. if (flag & AT_SYMLINK_NOFOLLOW)
  125. error = vfs_lstat_fd(dfd, filename, &stat);
  126. else
  127. error = vfs_stat_fd(dfd, filename, &stat);
  128. if (!error)
  129. error = cp_compat_stat(&stat, statbuf);
  130. out:
  131. return error;
  132. }
  133. #endif
  134. asmlinkage long compat_sys_newfstat(unsigned int fd,
  135. struct compat_stat __user * statbuf)
  136. {
  137. struct kstat stat;
  138. int error = vfs_fstat(fd, &stat);
  139. if (!error)
  140. error = cp_compat_stat(&stat, statbuf);
  141. return error;
  142. }
  143. static int put_compat_statfs(struct compat_statfs __user *ubuf, struct kstatfs *kbuf)
  144. {
  145. if (sizeof ubuf->f_blocks == 4) {
  146. if ((kbuf->f_blocks | kbuf->f_bfree | kbuf->f_bavail) &
  147. 0xffffffff00000000ULL)
  148. return -EOVERFLOW;
  149. /* f_files and f_ffree may be -1; it's okay
  150. * to stuff that into 32 bits */
  151. if (kbuf->f_files != 0xffffffffffffffffULL
  152. && (kbuf->f_files & 0xffffffff00000000ULL))
  153. return -EOVERFLOW;
  154. if (kbuf->f_ffree != 0xffffffffffffffffULL
  155. && (kbuf->f_ffree & 0xffffffff00000000ULL))
  156. return -EOVERFLOW;
  157. }
  158. if (!access_ok(VERIFY_WRITE, ubuf, sizeof(*ubuf)) ||
  159. __put_user(kbuf->f_type, &ubuf->f_type) ||
  160. __put_user(kbuf->f_bsize, &ubuf->f_bsize) ||
  161. __put_user(kbuf->f_blocks, &ubuf->f_blocks) ||
  162. __put_user(kbuf->f_bfree, &ubuf->f_bfree) ||
  163. __put_user(kbuf->f_bavail, &ubuf->f_bavail) ||
  164. __put_user(kbuf->f_files, &ubuf->f_files) ||
  165. __put_user(kbuf->f_ffree, &ubuf->f_ffree) ||
  166. __put_user(kbuf->f_namelen, &ubuf->f_namelen) ||
  167. __put_user(kbuf->f_fsid.val[0], &ubuf->f_fsid.val[0]) ||
  168. __put_user(kbuf->f_fsid.val[1], &ubuf->f_fsid.val[1]) ||
  169. __put_user(kbuf->f_frsize, &ubuf->f_frsize) ||
  170. __put_user(0, &ubuf->f_spare[0]) ||
  171. __put_user(0, &ubuf->f_spare[1]) ||
  172. __put_user(0, &ubuf->f_spare[2]) ||
  173. __put_user(0, &ubuf->f_spare[3]) ||
  174. __put_user(0, &ubuf->f_spare[4]))
  175. return -EFAULT;
  176. return 0;
  177. }
  178. /*
  179. * The following statfs calls are copies of code from fs/open.c and
  180. * should be checked against those from time to time
  181. */
  182. asmlinkage long compat_sys_statfs(const char __user *path, struct compat_statfs __user *buf)
  183. {
  184. struct nameidata nd;
  185. int error;
  186. error = user_path_walk(path, &nd);
  187. if (!error) {
  188. struct kstatfs tmp;
  189. error = vfs_statfs(nd.dentry, &tmp);
  190. if (!error)
  191. error = put_compat_statfs(buf, &tmp);
  192. path_release(&nd);
  193. }
  194. return error;
  195. }
  196. asmlinkage long compat_sys_fstatfs(unsigned int fd, struct compat_statfs __user *buf)
  197. {
  198. struct file * file;
  199. struct kstatfs tmp;
  200. int error;
  201. error = -EBADF;
  202. file = fget(fd);
  203. if (!file)
  204. goto out;
  205. error = vfs_statfs(file->f_dentry, &tmp);
  206. if (!error)
  207. error = put_compat_statfs(buf, &tmp);
  208. fput(file);
  209. out:
  210. return error;
  211. }
  212. static int put_compat_statfs64(struct compat_statfs64 __user *ubuf, struct kstatfs *kbuf)
  213. {
  214. if (sizeof ubuf->f_blocks == 4) {
  215. if ((kbuf->f_blocks | kbuf->f_bfree | kbuf->f_bavail) &
  216. 0xffffffff00000000ULL)
  217. return -EOVERFLOW;
  218. /* f_files and f_ffree may be -1; it's okay
  219. * to stuff that into 32 bits */
  220. if (kbuf->f_files != 0xffffffffffffffffULL
  221. && (kbuf->f_files & 0xffffffff00000000ULL))
  222. return -EOVERFLOW;
  223. if (kbuf->f_ffree != 0xffffffffffffffffULL
  224. && (kbuf->f_ffree & 0xffffffff00000000ULL))
  225. return -EOVERFLOW;
  226. }
  227. if (!access_ok(VERIFY_WRITE, ubuf, sizeof(*ubuf)) ||
  228. __put_user(kbuf->f_type, &ubuf->f_type) ||
  229. __put_user(kbuf->f_bsize, &ubuf->f_bsize) ||
  230. __put_user(kbuf->f_blocks, &ubuf->f_blocks) ||
  231. __put_user(kbuf->f_bfree, &ubuf->f_bfree) ||
  232. __put_user(kbuf->f_bavail, &ubuf->f_bavail) ||
  233. __put_user(kbuf->f_files, &ubuf->f_files) ||
  234. __put_user(kbuf->f_ffree, &ubuf->f_ffree) ||
  235. __put_user(kbuf->f_namelen, &ubuf->f_namelen) ||
  236. __put_user(kbuf->f_fsid.val[0], &ubuf->f_fsid.val[0]) ||
  237. __put_user(kbuf->f_fsid.val[1], &ubuf->f_fsid.val[1]) ||
  238. __put_user(kbuf->f_frsize, &ubuf->f_frsize))
  239. return -EFAULT;
  240. return 0;
  241. }
  242. asmlinkage long compat_sys_statfs64(const char __user *path, compat_size_t sz, struct compat_statfs64 __user *buf)
  243. {
  244. struct nameidata nd;
  245. int error;
  246. if (sz != sizeof(*buf))
  247. return -EINVAL;
  248. error = user_path_walk(path, &nd);
  249. if (!error) {
  250. struct kstatfs tmp;
  251. error = vfs_statfs(nd.dentry, &tmp);
  252. if (!error)
  253. error = put_compat_statfs64(buf, &tmp);
  254. path_release(&nd);
  255. }
  256. return error;
  257. }
  258. asmlinkage long compat_sys_fstatfs64(unsigned int fd, compat_size_t sz, struct compat_statfs64 __user *buf)
  259. {
  260. struct file * file;
  261. struct kstatfs tmp;
  262. int error;
  263. if (sz != sizeof(*buf))
  264. return -EINVAL;
  265. error = -EBADF;
  266. file = fget(fd);
  267. if (!file)
  268. goto out;
  269. error = vfs_statfs(file->f_dentry, &tmp);
  270. if (!error)
  271. error = put_compat_statfs64(buf, &tmp);
  272. fput(file);
  273. out:
  274. return error;
  275. }
  276. /* ioctl32 stuff, used by sparc64, parisc, s390x, ppc64, x86_64, MIPS */
  277. #define IOCTL_HASHSIZE 256
  278. static struct ioctl_trans *ioctl32_hash_table[IOCTL_HASHSIZE];
  279. static inline unsigned long ioctl32_hash(unsigned long cmd)
  280. {
  281. return (((cmd >> 6) ^ (cmd >> 4) ^ cmd)) % IOCTL_HASHSIZE;
  282. }
  283. static void ioctl32_insert_translation(struct ioctl_trans *trans)
  284. {
  285. unsigned long hash;
  286. struct ioctl_trans *t;
  287. hash = ioctl32_hash (trans->cmd);
  288. if (!ioctl32_hash_table[hash])
  289. ioctl32_hash_table[hash] = trans;
  290. else {
  291. t = ioctl32_hash_table[hash];
  292. while (t->next)
  293. t = t->next;
  294. trans->next = NULL;
  295. t->next = trans;
  296. }
  297. }
  298. static int __init init_sys32_ioctl(void)
  299. {
  300. int i;
  301. for (i = 0; i < ioctl_table_size; i++) {
  302. if (ioctl_start[i].next != 0) {
  303. printk("ioctl translation %d bad\n",i);
  304. return -1;
  305. }
  306. ioctl32_insert_translation(&ioctl_start[i]);
  307. }
  308. return 0;
  309. }
  310. __initcall(init_sys32_ioctl);
  311. static void compat_ioctl_error(struct file *filp, unsigned int fd,
  312. unsigned int cmd, unsigned long arg)
  313. {
  314. char buf[10];
  315. char *fn = "?";
  316. char *path;
  317. /* find the name of the device. */
  318. path = (char *)__get_free_page(GFP_KERNEL);
  319. if (path) {
  320. fn = d_path(filp->f_dentry, filp->f_vfsmnt, path, PAGE_SIZE);
  321. if (IS_ERR(fn))
  322. fn = "?";
  323. }
  324. sprintf(buf,"'%c'", (cmd>>24) & 0x3f);
  325. if (!isprint(buf[1]))
  326. sprintf(buf, "%02x", buf[1]);
  327. compat_printk("ioctl32(%s:%d): Unknown cmd fd(%d) "
  328. "cmd(%08x){%s} arg(%08x) on %s\n",
  329. current->comm, current->pid,
  330. (int)fd, (unsigned int)cmd, buf,
  331. (unsigned int)arg, fn);
  332. if (path)
  333. free_page((unsigned long)path);
  334. }
  335. asmlinkage long compat_sys_ioctl(unsigned int fd, unsigned int cmd,
  336. unsigned long arg)
  337. {
  338. struct file *filp;
  339. int error = -EBADF;
  340. struct ioctl_trans *t;
  341. int fput_needed;
  342. filp = fget_light(fd, &fput_needed);
  343. if (!filp)
  344. goto out;
  345. /* RED-PEN how should LSM module know it's handling 32bit? */
  346. error = security_file_ioctl(filp, cmd, arg);
  347. if (error)
  348. goto out_fput;
  349. /*
  350. * To allow the compat_ioctl handlers to be self contained
  351. * we need to check the common ioctls here first.
  352. * Just handle them with the standard handlers below.
  353. */
  354. switch (cmd) {
  355. case FIOCLEX:
  356. case FIONCLEX:
  357. case FIONBIO:
  358. case FIOASYNC:
  359. case FIOQSIZE:
  360. break;
  361. case FIBMAP:
  362. case FIGETBSZ:
  363. case FIONREAD:
  364. if (S_ISREG(filp->f_dentry->d_inode->i_mode))
  365. break;
  366. /*FALL THROUGH*/
  367. default:
  368. if (filp->f_op && filp->f_op->compat_ioctl) {
  369. error = filp->f_op->compat_ioctl(filp, cmd, arg);
  370. if (error != -ENOIOCTLCMD)
  371. goto out_fput;
  372. }
  373. if (!filp->f_op ||
  374. (!filp->f_op->ioctl && !filp->f_op->unlocked_ioctl))
  375. goto do_ioctl;
  376. break;
  377. }
  378. for (t = ioctl32_hash_table[ioctl32_hash(cmd)]; t; t = t->next) {
  379. if (t->cmd == cmd)
  380. goto found_handler;
  381. }
  382. if (S_ISSOCK(filp->f_dentry->d_inode->i_mode) &&
  383. cmd >= SIOCDEVPRIVATE && cmd <= (SIOCDEVPRIVATE + 15)) {
  384. error = siocdevprivate_ioctl(fd, cmd, arg);
  385. } else {
  386. static int count;
  387. if (++count <= 50)
  388. compat_ioctl_error(filp, fd, cmd, arg);
  389. error = -EINVAL;
  390. }
  391. goto out_fput;
  392. found_handler:
  393. if (t->handler) {
  394. lock_kernel();
  395. error = t->handler(fd, cmd, arg, filp);
  396. unlock_kernel();
  397. goto out_fput;
  398. }
  399. do_ioctl:
  400. error = vfs_ioctl(filp, fd, cmd, arg);
  401. out_fput:
  402. fput_light(filp, fput_needed);
  403. out:
  404. return error;
  405. }
  406. static int get_compat_flock(struct flock *kfl, struct compat_flock __user *ufl)
  407. {
  408. if (!access_ok(VERIFY_READ, ufl, sizeof(*ufl)) ||
  409. __get_user(kfl->l_type, &ufl->l_type) ||
  410. __get_user(kfl->l_whence, &ufl->l_whence) ||
  411. __get_user(kfl->l_start, &ufl->l_start) ||
  412. __get_user(kfl->l_len, &ufl->l_len) ||
  413. __get_user(kfl->l_pid, &ufl->l_pid))
  414. return -EFAULT;
  415. return 0;
  416. }
  417. static int put_compat_flock(struct flock *kfl, struct compat_flock __user *ufl)
  418. {
  419. if (!access_ok(VERIFY_WRITE, ufl, sizeof(*ufl)) ||
  420. __put_user(kfl->l_type, &ufl->l_type) ||
  421. __put_user(kfl->l_whence, &ufl->l_whence) ||
  422. __put_user(kfl->l_start, &ufl->l_start) ||
  423. __put_user(kfl->l_len, &ufl->l_len) ||
  424. __put_user(kfl->l_pid, &ufl->l_pid))
  425. return -EFAULT;
  426. return 0;
  427. }
  428. #ifndef HAVE_ARCH_GET_COMPAT_FLOCK64
  429. static int get_compat_flock64(struct flock *kfl, struct compat_flock64 __user *ufl)
  430. {
  431. if (!access_ok(VERIFY_READ, ufl, sizeof(*ufl)) ||
  432. __get_user(kfl->l_type, &ufl->l_type) ||
  433. __get_user(kfl->l_whence, &ufl->l_whence) ||
  434. __get_user(kfl->l_start, &ufl->l_start) ||
  435. __get_user(kfl->l_len, &ufl->l_len) ||
  436. __get_user(kfl->l_pid, &ufl->l_pid))
  437. return -EFAULT;
  438. return 0;
  439. }
  440. #endif
  441. #ifndef HAVE_ARCH_PUT_COMPAT_FLOCK64
  442. static int put_compat_flock64(struct flock *kfl, struct compat_flock64 __user *ufl)
  443. {
  444. if (!access_ok(VERIFY_WRITE, ufl, sizeof(*ufl)) ||
  445. __put_user(kfl->l_type, &ufl->l_type) ||
  446. __put_user(kfl->l_whence, &ufl->l_whence) ||
  447. __put_user(kfl->l_start, &ufl->l_start) ||
  448. __put_user(kfl->l_len, &ufl->l_len) ||
  449. __put_user(kfl->l_pid, &ufl->l_pid))
  450. return -EFAULT;
  451. return 0;
  452. }
  453. #endif
  454. asmlinkage long compat_sys_fcntl64(unsigned int fd, unsigned int cmd,
  455. unsigned long arg)
  456. {
  457. mm_segment_t old_fs;
  458. struct flock f;
  459. long ret;
  460. switch (cmd) {
  461. case F_GETLK:
  462. case F_SETLK:
  463. case F_SETLKW:
  464. ret = get_compat_flock(&f, compat_ptr(arg));
  465. if (ret != 0)
  466. break;
  467. old_fs = get_fs();
  468. set_fs(KERNEL_DS);
  469. ret = sys_fcntl(fd, cmd, (unsigned long)&f);
  470. set_fs(old_fs);
  471. if (cmd == F_GETLK && ret == 0) {
  472. /* GETLK was successfule and we need to return the data...
  473. * but it needs to fit in the compat structure.
  474. * l_start shouldn't be too big, unless the original
  475. * start + end is greater than COMPAT_OFF_T_MAX, in which
  476. * case the app was asking for trouble, so we return
  477. * -EOVERFLOW in that case.
  478. * l_len could be too big, in which case we just truncate it,
  479. * and only allow the app to see that part of the conflicting
  480. * lock that might make sense to it anyway
  481. */
  482. if (f.l_start > COMPAT_OFF_T_MAX)
  483. ret = -EOVERFLOW;
  484. if (f.l_len > COMPAT_OFF_T_MAX)
  485. f.l_len = COMPAT_OFF_T_MAX;
  486. if (ret == 0)
  487. ret = put_compat_flock(&f, compat_ptr(arg));
  488. }
  489. break;
  490. case F_GETLK64:
  491. case F_SETLK64:
  492. case F_SETLKW64:
  493. ret = get_compat_flock64(&f, compat_ptr(arg));
  494. if (ret != 0)
  495. break;
  496. old_fs = get_fs();
  497. set_fs(KERNEL_DS);
  498. ret = sys_fcntl(fd, (cmd == F_GETLK64) ? F_GETLK :
  499. ((cmd == F_SETLK64) ? F_SETLK : F_SETLKW),
  500. (unsigned long)&f);
  501. set_fs(old_fs);
  502. if (cmd == F_GETLK64 && ret == 0) {
  503. /* need to return lock information - see above for commentary */
  504. if (f.l_start > COMPAT_LOFF_T_MAX)
  505. ret = -EOVERFLOW;
  506. if (f.l_len > COMPAT_LOFF_T_MAX)
  507. f.l_len = COMPAT_LOFF_T_MAX;
  508. if (ret == 0)
  509. ret = put_compat_flock64(&f, compat_ptr(arg));
  510. }
  511. break;
  512. default:
  513. ret = sys_fcntl(fd, cmd, arg);
  514. break;
  515. }
  516. return ret;
  517. }
  518. asmlinkage long compat_sys_fcntl(unsigned int fd, unsigned int cmd,
  519. unsigned long arg)
  520. {
  521. if ((cmd == F_GETLK64) || (cmd == F_SETLK64) || (cmd == F_SETLKW64))
  522. return -EINVAL;
  523. return compat_sys_fcntl64(fd, cmd, arg);
  524. }
  525. asmlinkage long
  526. compat_sys_io_setup(unsigned nr_reqs, u32 __user *ctx32p)
  527. {
  528. long ret;
  529. aio_context_t ctx64;
  530. mm_segment_t oldfs = get_fs();
  531. if (unlikely(get_user(ctx64, ctx32p)))
  532. return -EFAULT;
  533. set_fs(KERNEL_DS);
  534. /* The __user pointer cast is valid because of the set_fs() */
  535. ret = sys_io_setup(nr_reqs, (aio_context_t __user *) &ctx64);
  536. set_fs(oldfs);
  537. /* truncating is ok because it's a user address */
  538. if (!ret)
  539. ret = put_user((u32) ctx64, ctx32p);
  540. return ret;
  541. }
  542. asmlinkage long
  543. compat_sys_io_getevents(aio_context_t ctx_id,
  544. unsigned long min_nr,
  545. unsigned long nr,
  546. struct io_event __user *events,
  547. struct compat_timespec __user *timeout)
  548. {
  549. long ret;
  550. struct timespec t;
  551. struct timespec __user *ut = NULL;
  552. ret = -EFAULT;
  553. if (unlikely(!access_ok(VERIFY_WRITE, events,
  554. nr * sizeof(struct io_event))))
  555. goto out;
  556. if (timeout) {
  557. if (get_compat_timespec(&t, timeout))
  558. goto out;
  559. ut = compat_alloc_user_space(sizeof(*ut));
  560. if (copy_to_user(ut, &t, sizeof(t)) )
  561. goto out;
  562. }
  563. ret = sys_io_getevents(ctx_id, min_nr, nr, events, ut);
  564. out:
  565. return ret;
  566. }
  567. static inline long
  568. copy_iocb(long nr, u32 __user *ptr32, struct iocb __user * __user *ptr64)
  569. {
  570. compat_uptr_t uptr;
  571. int i;
  572. for (i = 0; i < nr; ++i) {
  573. if (get_user(uptr, ptr32 + i))
  574. return -EFAULT;
  575. if (put_user(compat_ptr(uptr), ptr64 + i))
  576. return -EFAULT;
  577. }
  578. return 0;
  579. }
  580. #define MAX_AIO_SUBMITS (PAGE_SIZE/sizeof(struct iocb *))
  581. asmlinkage long
  582. compat_sys_io_submit(aio_context_t ctx_id, int nr, u32 __user *iocb)
  583. {
  584. struct iocb __user * __user *iocb64;
  585. long ret;
  586. if (unlikely(nr < 0))
  587. return -EINVAL;
  588. if (nr > MAX_AIO_SUBMITS)
  589. nr = MAX_AIO_SUBMITS;
  590. iocb64 = compat_alloc_user_space(nr * sizeof(*iocb64));
  591. ret = copy_iocb(nr, iocb, iocb64);
  592. if (!ret)
  593. ret = sys_io_submit(ctx_id, nr, iocb64);
  594. return ret;
  595. }
  596. struct compat_ncp_mount_data {
  597. compat_int_t version;
  598. compat_uint_t ncp_fd;
  599. __compat_uid_t mounted_uid;
  600. compat_pid_t wdog_pid;
  601. unsigned char mounted_vol[NCP_VOLNAME_LEN + 1];
  602. compat_uint_t time_out;
  603. compat_uint_t retry_count;
  604. compat_uint_t flags;
  605. __compat_uid_t uid;
  606. __compat_gid_t gid;
  607. compat_mode_t file_mode;
  608. compat_mode_t dir_mode;
  609. };
  610. struct compat_ncp_mount_data_v4 {
  611. compat_int_t version;
  612. compat_ulong_t flags;
  613. compat_ulong_t mounted_uid;
  614. compat_long_t wdog_pid;
  615. compat_uint_t ncp_fd;
  616. compat_uint_t time_out;
  617. compat_uint_t retry_count;
  618. compat_ulong_t uid;
  619. compat_ulong_t gid;
  620. compat_ulong_t file_mode;
  621. compat_ulong_t dir_mode;
  622. };
  623. static void *do_ncp_super_data_conv(void *raw_data)
  624. {
  625. int version = *(unsigned int *)raw_data;
  626. if (version == 3) {
  627. struct compat_ncp_mount_data *c_n = raw_data;
  628. struct ncp_mount_data *n = raw_data;
  629. n->dir_mode = c_n->dir_mode;
  630. n->file_mode = c_n->file_mode;
  631. n->gid = c_n->gid;
  632. n->uid = c_n->uid;
  633. memmove (n->mounted_vol, c_n->mounted_vol, (sizeof (c_n->mounted_vol) + 3 * sizeof (unsigned int)));
  634. n->wdog_pid = c_n->wdog_pid;
  635. n->mounted_uid = c_n->mounted_uid;
  636. } else if (version == 4) {
  637. struct compat_ncp_mount_data_v4 *c_n = raw_data;
  638. struct ncp_mount_data_v4 *n = raw_data;
  639. n->dir_mode = c_n->dir_mode;
  640. n->file_mode = c_n->file_mode;
  641. n->gid = c_n->gid;
  642. n->uid = c_n->uid;
  643. n->retry_count = c_n->retry_count;
  644. n->time_out = c_n->time_out;
  645. n->ncp_fd = c_n->ncp_fd;
  646. n->wdog_pid = c_n->wdog_pid;
  647. n->mounted_uid = c_n->mounted_uid;
  648. n->flags = c_n->flags;
  649. } else if (version != 5) {
  650. return NULL;
  651. }
  652. return raw_data;
  653. }
  654. struct compat_smb_mount_data {
  655. compat_int_t version;
  656. __compat_uid_t mounted_uid;
  657. __compat_uid_t uid;
  658. __compat_gid_t gid;
  659. compat_mode_t file_mode;
  660. compat_mode_t dir_mode;
  661. };
  662. static void *do_smb_super_data_conv(void *raw_data)
  663. {
  664. struct smb_mount_data *s = raw_data;
  665. struct compat_smb_mount_data *c_s = raw_data;
  666. if (c_s->version != SMB_MOUNT_OLDVERSION)
  667. goto out;
  668. s->dir_mode = c_s->dir_mode;
  669. s->file_mode = c_s->file_mode;
  670. s->gid = c_s->gid;
  671. s->uid = c_s->uid;
  672. s->mounted_uid = c_s->mounted_uid;
  673. out:
  674. return raw_data;
  675. }
  676. struct compat_nfs_string {
  677. compat_uint_t len;
  678. compat_uptr_t data;
  679. };
  680. static inline void compat_nfs_string(struct nfs_string *dst,
  681. struct compat_nfs_string *src)
  682. {
  683. dst->data = compat_ptr(src->data);
  684. dst->len = src->len;
  685. }
  686. struct compat_nfs4_mount_data_v1 {
  687. compat_int_t version;
  688. compat_int_t flags;
  689. compat_int_t rsize;
  690. compat_int_t wsize;
  691. compat_int_t timeo;
  692. compat_int_t retrans;
  693. compat_int_t acregmin;
  694. compat_int_t acregmax;
  695. compat_int_t acdirmin;
  696. compat_int_t acdirmax;
  697. struct compat_nfs_string client_addr;
  698. struct compat_nfs_string mnt_path;
  699. struct compat_nfs_string hostname;
  700. compat_uint_t host_addrlen;
  701. compat_uptr_t host_addr;
  702. compat_int_t proto;
  703. compat_int_t auth_flavourlen;
  704. compat_uptr_t auth_flavours;
  705. };
  706. static int do_nfs4_super_data_conv(void *raw_data)
  707. {
  708. int version = *(compat_uint_t *) raw_data;
  709. if (version == 1) {
  710. struct compat_nfs4_mount_data_v1 *raw = raw_data;
  711. struct nfs4_mount_data *real = raw_data;
  712. /* copy the fields backwards */
  713. real->auth_flavours = compat_ptr(raw->auth_flavours);
  714. real->auth_flavourlen = raw->auth_flavourlen;
  715. real->proto = raw->proto;
  716. real->host_addr = compat_ptr(raw->host_addr);
  717. real->host_addrlen = raw->host_addrlen;
  718. compat_nfs_string(&real->hostname, &raw->hostname);
  719. compat_nfs_string(&real->mnt_path, &raw->mnt_path);
  720. compat_nfs_string(&real->client_addr, &raw->client_addr);
  721. real->acdirmax = raw->acdirmax;
  722. real->acdirmin = raw->acdirmin;
  723. real->acregmax = raw->acregmax;
  724. real->acregmin = raw->acregmin;
  725. real->retrans = raw->retrans;
  726. real->timeo = raw->timeo;
  727. real->wsize = raw->wsize;
  728. real->rsize = raw->rsize;
  729. real->flags = raw->flags;
  730. real->version = raw->version;
  731. }
  732. else {
  733. return -EINVAL;
  734. }
  735. return 0;
  736. }
  737. #define SMBFS_NAME "smbfs"
  738. #define NCPFS_NAME "ncpfs"
  739. #define NFS4_NAME "nfs4"
  740. asmlinkage long compat_sys_mount(char __user * dev_name, char __user * dir_name,
  741. char __user * type, unsigned long flags,
  742. void __user * data)
  743. {
  744. unsigned long type_page;
  745. unsigned long data_page;
  746. unsigned long dev_page;
  747. char *dir_page;
  748. int retval;
  749. retval = copy_mount_options (type, &type_page);
  750. if (retval < 0)
  751. goto out;
  752. dir_page = getname(dir_name);
  753. retval = PTR_ERR(dir_page);
  754. if (IS_ERR(dir_page))
  755. goto out1;
  756. retval = copy_mount_options (dev_name, &dev_page);
  757. if (retval < 0)
  758. goto out2;
  759. retval = copy_mount_options (data, &data_page);
  760. if (retval < 0)
  761. goto out3;
  762. retval = -EINVAL;
  763. if (type_page) {
  764. if (!strcmp((char *)type_page, SMBFS_NAME)) {
  765. do_smb_super_data_conv((void *)data_page);
  766. } else if (!strcmp((char *)type_page, NCPFS_NAME)) {
  767. do_ncp_super_data_conv((void *)data_page);
  768. } else if (!strcmp((char *)type_page, NFS4_NAME)) {
  769. if (do_nfs4_super_data_conv((void *) data_page))
  770. goto out4;
  771. }
  772. }
  773. lock_kernel();
  774. retval = do_mount((char*)dev_page, dir_page, (char*)type_page,
  775. flags, (void*)data_page);
  776. unlock_kernel();
  777. out4:
  778. free_page(data_page);
  779. out3:
  780. free_page(dev_page);
  781. out2:
  782. putname(dir_page);
  783. out1:
  784. free_page(type_page);
  785. out:
  786. return retval;
  787. }
  788. #define NAME_OFFSET(de) ((int) ((de)->d_name - (char __user *) (de)))
  789. #define COMPAT_ROUND_UP(x) (((x)+sizeof(compat_long_t)-1) & \
  790. ~(sizeof(compat_long_t)-1))
  791. struct compat_old_linux_dirent {
  792. compat_ulong_t d_ino;
  793. compat_ulong_t d_offset;
  794. unsigned short d_namlen;
  795. char d_name[1];
  796. };
  797. struct compat_readdir_callback {
  798. struct compat_old_linux_dirent __user *dirent;
  799. int result;
  800. };
  801. static int compat_fillonedir(void *__buf, const char *name, int namlen,
  802. loff_t offset, ino_t ino, unsigned int d_type)
  803. {
  804. struct compat_readdir_callback *buf = __buf;
  805. struct compat_old_linux_dirent __user *dirent;
  806. if (buf->result)
  807. return -EINVAL;
  808. buf->result++;
  809. dirent = buf->dirent;
  810. if (!access_ok(VERIFY_WRITE, dirent,
  811. (unsigned long)(dirent->d_name + namlen + 1) -
  812. (unsigned long)dirent))
  813. goto efault;
  814. if ( __put_user(ino, &dirent->d_ino) ||
  815. __put_user(offset, &dirent->d_offset) ||
  816. __put_user(namlen, &dirent->d_namlen) ||
  817. __copy_to_user(dirent->d_name, name, namlen) ||
  818. __put_user(0, dirent->d_name + namlen))
  819. goto efault;
  820. return 0;
  821. efault:
  822. buf->result = -EFAULT;
  823. return -EFAULT;
  824. }
  825. asmlinkage long compat_sys_old_readdir(unsigned int fd,
  826. struct compat_old_linux_dirent __user *dirent, unsigned int count)
  827. {
  828. int error;
  829. struct file *file;
  830. struct compat_readdir_callback buf;
  831. error = -EBADF;
  832. file = fget(fd);
  833. if (!file)
  834. goto out;
  835. buf.result = 0;
  836. buf.dirent = dirent;
  837. error = vfs_readdir(file, compat_fillonedir, &buf);
  838. if (error >= 0)
  839. error = buf.result;
  840. fput(file);
  841. out:
  842. return error;
  843. }
  844. struct compat_linux_dirent {
  845. compat_ulong_t d_ino;
  846. compat_ulong_t d_off;
  847. unsigned short d_reclen;
  848. char d_name[1];
  849. };
  850. struct compat_getdents_callback {
  851. struct compat_linux_dirent __user *current_dir;
  852. struct compat_linux_dirent __user *previous;
  853. int count;
  854. int error;
  855. };
  856. static int compat_filldir(void *__buf, const char *name, int namlen,
  857. loff_t offset, ino_t ino, unsigned int d_type)
  858. {
  859. struct compat_linux_dirent __user * dirent;
  860. struct compat_getdents_callback *buf = __buf;
  861. int reclen = COMPAT_ROUND_UP(NAME_OFFSET(dirent) + namlen + 2);
  862. buf->error = -EINVAL; /* only used if we fail.. */
  863. if (reclen > buf->count)
  864. return -EINVAL;
  865. dirent = buf->previous;
  866. if (dirent) {
  867. if (__put_user(offset, &dirent->d_off))
  868. goto efault;
  869. }
  870. dirent = buf->current_dir;
  871. if (__put_user(ino, &dirent->d_ino))
  872. goto efault;
  873. if (__put_user(reclen, &dirent->d_reclen))
  874. goto efault;
  875. if (copy_to_user(dirent->d_name, name, namlen))
  876. goto efault;
  877. if (__put_user(0, dirent->d_name + namlen))
  878. goto efault;
  879. if (__put_user(d_type, (char __user *) dirent + reclen - 1))
  880. goto efault;
  881. buf->previous = dirent;
  882. dirent = (void __user *)dirent + reclen;
  883. buf->current_dir = dirent;
  884. buf->count -= reclen;
  885. return 0;
  886. efault:
  887. buf->error = -EFAULT;
  888. return -EFAULT;
  889. }
  890. asmlinkage long compat_sys_getdents(unsigned int fd,
  891. struct compat_linux_dirent __user *dirent, unsigned int count)
  892. {
  893. struct file * file;
  894. struct compat_linux_dirent __user * lastdirent;
  895. struct compat_getdents_callback buf;
  896. int error;
  897. error = -EFAULT;
  898. if (!access_ok(VERIFY_WRITE, dirent, count))
  899. goto out;
  900. error = -EBADF;
  901. file = fget(fd);
  902. if (!file)
  903. goto out;
  904. buf.current_dir = dirent;
  905. buf.previous = NULL;
  906. buf.count = count;
  907. buf.error = 0;
  908. error = vfs_readdir(file, compat_filldir, &buf);
  909. if (error < 0)
  910. goto out_putf;
  911. error = buf.error;
  912. lastdirent = buf.previous;
  913. if (lastdirent) {
  914. if (put_user(file->f_pos, &lastdirent->d_off))
  915. error = -EFAULT;
  916. else
  917. error = count - buf.count;
  918. }
  919. out_putf:
  920. fput(file);
  921. out:
  922. return error;
  923. }
  924. #ifndef __ARCH_OMIT_COMPAT_SYS_GETDENTS64
  925. #define COMPAT_ROUND_UP64(x) (((x)+sizeof(u64)-1) & ~(sizeof(u64)-1))
  926. struct compat_getdents_callback64 {
  927. struct linux_dirent64 __user *current_dir;
  928. struct linux_dirent64 __user *previous;
  929. int count;
  930. int error;
  931. };
  932. static int compat_filldir64(void * __buf, const char * name, int namlen, loff_t offset,
  933. ino_t ino, unsigned int d_type)
  934. {
  935. struct linux_dirent64 __user *dirent;
  936. struct compat_getdents_callback64 *buf = __buf;
  937. int jj = NAME_OFFSET(dirent);
  938. int reclen = COMPAT_ROUND_UP64(jj + namlen + 1);
  939. u64 off;
  940. buf->error = -EINVAL; /* only used if we fail.. */
  941. if (reclen > buf->count)
  942. return -EINVAL;
  943. dirent = buf->previous;
  944. if (dirent) {
  945. if (__put_user_unaligned(offset, &dirent->d_off))
  946. goto efault;
  947. }
  948. dirent = buf->current_dir;
  949. if (__put_user_unaligned(ino, &dirent->d_ino))
  950. goto efault;
  951. off = 0;
  952. if (__put_user_unaligned(off, &dirent->d_off))
  953. goto efault;
  954. if (__put_user(reclen, &dirent->d_reclen))
  955. goto efault;
  956. if (__put_user(d_type, &dirent->d_type))
  957. goto efault;
  958. if (copy_to_user(dirent->d_name, name, namlen))
  959. goto efault;
  960. if (__put_user(0, dirent->d_name + namlen))
  961. goto efault;
  962. buf->previous = dirent;
  963. dirent = (void __user *)dirent + reclen;
  964. buf->current_dir = dirent;
  965. buf->count -= reclen;
  966. return 0;
  967. efault:
  968. buf->error = -EFAULT;
  969. return -EFAULT;
  970. }
  971. asmlinkage long compat_sys_getdents64(unsigned int fd,
  972. struct linux_dirent64 __user * dirent, unsigned int count)
  973. {
  974. struct file * file;
  975. struct linux_dirent64 __user * lastdirent;
  976. struct compat_getdents_callback64 buf;
  977. int error;
  978. error = -EFAULT;
  979. if (!access_ok(VERIFY_WRITE, dirent, count))
  980. goto out;
  981. error = -EBADF;
  982. file = fget(fd);
  983. if (!file)
  984. goto out;
  985. buf.current_dir = dirent;
  986. buf.previous = NULL;
  987. buf.count = count;
  988. buf.error = 0;
  989. error = vfs_readdir(file, compat_filldir64, &buf);
  990. if (error < 0)
  991. goto out_putf;
  992. error = buf.error;
  993. lastdirent = buf.previous;
  994. if (lastdirent) {
  995. typeof(lastdirent->d_off) d_off = file->f_pos;
  996. __put_user_unaligned(d_off, &lastdirent->d_off);
  997. error = count - buf.count;
  998. }
  999. out_putf:
  1000. fput(file);
  1001. out:
  1002. return error;
  1003. }
  1004. #endif /* ! __ARCH_OMIT_COMPAT_SYS_GETDENTS64 */
  1005. static ssize_t compat_do_readv_writev(int type, struct file *file,
  1006. const struct compat_iovec __user *uvector,
  1007. unsigned long nr_segs, loff_t *pos)
  1008. {
  1009. typedef ssize_t (*io_fn_t)(struct file *, char __user *, size_t, loff_t *);
  1010. typedef ssize_t (*iov_fn_t)(struct file *, const struct iovec *, unsigned long, loff_t *);
  1011. compat_ssize_t tot_len;
  1012. struct iovec iovstack[UIO_FASTIOV];
  1013. struct iovec *iov=iovstack, *vector;
  1014. ssize_t ret;
  1015. int seg;
  1016. io_fn_t fn;
  1017. iov_fn_t fnv;
  1018. /*
  1019. * SuS says "The readv() function *may* fail if the iovcnt argument
  1020. * was less than or equal to 0, or greater than {IOV_MAX}. Linux has
  1021. * traditionally returned zero for zero segments, so...
  1022. */
  1023. ret = 0;
  1024. if (nr_segs == 0)
  1025. goto out;
  1026. /*
  1027. * First get the "struct iovec" from user memory and
  1028. * verify all the pointers
  1029. */
  1030. ret = -EINVAL;
  1031. if ((nr_segs > UIO_MAXIOV) || (nr_segs <= 0))
  1032. goto out;
  1033. if (!file->f_op)
  1034. goto out;
  1035. if (nr_segs > UIO_FASTIOV) {
  1036. ret = -ENOMEM;
  1037. iov = kmalloc(nr_segs*sizeof(struct iovec), GFP_KERNEL);
  1038. if (!iov)
  1039. goto out;
  1040. }
  1041. ret = -EFAULT;
  1042. if (!access_ok(VERIFY_READ, uvector, nr_segs*sizeof(*uvector)))
  1043. goto out;
  1044. /*
  1045. * Single unix specification:
  1046. * We should -EINVAL if an element length is not >= 0 and fitting an
  1047. * ssize_t. The total length is fitting an ssize_t
  1048. *
  1049. * Be careful here because iov_len is a size_t not an ssize_t
  1050. */
  1051. tot_len = 0;
  1052. vector = iov;
  1053. ret = -EINVAL;
  1054. for (seg = 0 ; seg < nr_segs; seg++) {
  1055. compat_ssize_t tmp = tot_len;
  1056. compat_ssize_t len;
  1057. compat_uptr_t buf;
  1058. if (__get_user(len, &uvector->iov_len) ||
  1059. __get_user(buf, &uvector->iov_base)) {
  1060. ret = -EFAULT;
  1061. goto out;
  1062. }
  1063. if (len < 0) /* size_t not fitting an compat_ssize_t .. */
  1064. goto out;
  1065. tot_len += len;
  1066. if (tot_len < tmp) /* maths overflow on the compat_ssize_t */
  1067. goto out;
  1068. vector->iov_base = compat_ptr(buf);
  1069. vector->iov_len = (compat_size_t) len;
  1070. uvector++;
  1071. vector++;
  1072. }
  1073. if (tot_len == 0) {
  1074. ret = 0;
  1075. goto out;
  1076. }
  1077. ret = rw_verify_area(type, file, pos, tot_len);
  1078. if (ret < 0)
  1079. goto out;
  1080. ret = security_file_permission(file, type == READ ? MAY_READ:MAY_WRITE);
  1081. if (ret)
  1082. goto out;
  1083. fnv = NULL;
  1084. if (type == READ) {
  1085. fn = file->f_op->read;
  1086. fnv = file->f_op->readv;
  1087. } else {
  1088. fn = (io_fn_t)file->f_op->write;
  1089. fnv = file->f_op->writev;
  1090. }
  1091. if (fnv) {
  1092. ret = fnv(file, iov, nr_segs, pos);
  1093. goto out;
  1094. }
  1095. /* Do it by hand, with file-ops */
  1096. ret = 0;
  1097. vector = iov;
  1098. while (nr_segs > 0) {
  1099. void __user * base;
  1100. size_t len;
  1101. ssize_t nr;
  1102. base = vector->iov_base;
  1103. len = vector->iov_len;
  1104. vector++;
  1105. nr_segs--;
  1106. nr = fn(file, base, len, pos);
  1107. if (nr < 0) {
  1108. if (!ret) ret = nr;
  1109. break;
  1110. }
  1111. ret += nr;
  1112. if (nr != len)
  1113. break;
  1114. }
  1115. out:
  1116. if (iov != iovstack)
  1117. kfree(iov);
  1118. if ((ret + (type == READ)) > 0) {
  1119. struct dentry *dentry = file->f_dentry;
  1120. if (type == READ)
  1121. fsnotify_access(dentry);
  1122. else
  1123. fsnotify_modify(dentry);
  1124. }
  1125. return ret;
  1126. }
  1127. asmlinkage ssize_t
  1128. compat_sys_readv(unsigned long fd, const struct compat_iovec __user *vec, unsigned long vlen)
  1129. {
  1130. struct file *file;
  1131. ssize_t ret = -EBADF;
  1132. file = fget(fd);
  1133. if (!file)
  1134. return -EBADF;
  1135. if (!(file->f_mode & FMODE_READ))
  1136. goto out;
  1137. ret = -EINVAL;
  1138. if (!file->f_op || (!file->f_op->readv && !file->f_op->read))
  1139. goto out;
  1140. ret = compat_do_readv_writev(READ, file, vec, vlen, &file->f_pos);
  1141. out:
  1142. fput(file);
  1143. return ret;
  1144. }
  1145. asmlinkage ssize_t
  1146. compat_sys_writev(unsigned long fd, const struct compat_iovec __user *vec, unsigned long vlen)
  1147. {
  1148. struct file *file;
  1149. ssize_t ret = -EBADF;
  1150. file = fget(fd);
  1151. if (!file)
  1152. return -EBADF;
  1153. if (!(file->f_mode & FMODE_WRITE))
  1154. goto out;
  1155. ret = -EINVAL;
  1156. if (!file->f_op || (!file->f_op->writev && !file->f_op->write))
  1157. goto out;
  1158. ret = compat_do_readv_writev(WRITE, file, vec, vlen, &file->f_pos);
  1159. out:
  1160. fput(file);
  1161. return ret;
  1162. }
  1163. asmlinkage long
  1164. compat_sys_vmsplice(int fd, const struct compat_iovec __user *iov32,
  1165. unsigned int nr_segs, unsigned int flags)
  1166. {
  1167. unsigned i;
  1168. struct iovec *iov;
  1169. if (nr_segs > UIO_MAXIOV)
  1170. return -EINVAL;
  1171. iov = compat_alloc_user_space(nr_segs * sizeof(struct iovec));
  1172. for (i = 0; i < nr_segs; i++) {
  1173. struct compat_iovec v;
  1174. if (get_user(v.iov_base, &iov32[i].iov_base) ||
  1175. get_user(v.iov_len, &iov32[i].iov_len) ||
  1176. put_user(compat_ptr(v.iov_base), &iov[i].iov_base) ||
  1177. put_user(v.iov_len, &iov[i].iov_len))
  1178. return -EFAULT;
  1179. }
  1180. return sys_vmsplice(fd, iov, nr_segs, flags);
  1181. }
  1182. /*
  1183. * Exactly like fs/open.c:sys_open(), except that it doesn't set the
  1184. * O_LARGEFILE flag.
  1185. */
  1186. asmlinkage long
  1187. compat_sys_open(const char __user *filename, int flags, int mode)
  1188. {
  1189. return do_sys_open(AT_FDCWD, filename, flags, mode);
  1190. }
  1191. /*
  1192. * Exactly like fs/open.c:sys_openat(), except that it doesn't set the
  1193. * O_LARGEFILE flag.
  1194. */
  1195. asmlinkage long
  1196. compat_sys_openat(unsigned int dfd, const char __user *filename, int flags, int mode)
  1197. {
  1198. return do_sys_open(dfd, filename, flags, mode);
  1199. }
  1200. /*
  1201. * compat_count() counts the number of arguments/envelopes. It is basically
  1202. * a copy of count() from fs/exec.c, except that it works with 32 bit argv
  1203. * and envp pointers.
  1204. */
  1205. static int compat_count(compat_uptr_t __user *argv, int max)
  1206. {
  1207. int i = 0;
  1208. if (argv != NULL) {
  1209. for (;;) {
  1210. compat_uptr_t p;
  1211. if (get_user(p, argv))
  1212. return -EFAULT;
  1213. if (!p)
  1214. break;
  1215. argv++;
  1216. if(++i > max)
  1217. return -E2BIG;
  1218. }
  1219. }
  1220. return i;
  1221. }
  1222. /*
  1223. * compat_copy_strings() is basically a copy of copy_strings() from fs/exec.c
  1224. * except that it works with 32 bit argv and envp pointers.
  1225. */
  1226. static int compat_copy_strings(int argc, compat_uptr_t __user *argv,
  1227. struct linux_binprm *bprm)
  1228. {
  1229. struct page *kmapped_page = NULL;
  1230. char *kaddr = NULL;
  1231. int ret;
  1232. while (argc-- > 0) {
  1233. compat_uptr_t str;
  1234. int len;
  1235. unsigned long pos;
  1236. if (get_user(str, argv+argc) ||
  1237. !(len = strnlen_user(compat_ptr(str), bprm->p))) {
  1238. ret = -EFAULT;
  1239. goto out;
  1240. }
  1241. if (bprm->p < len) {
  1242. ret = -E2BIG;
  1243. goto out;
  1244. }
  1245. bprm->p -= len;
  1246. /* XXX: add architecture specific overflow check here. */
  1247. pos = bprm->p;
  1248. while (len > 0) {
  1249. int i, new, err;
  1250. int offset, bytes_to_copy;
  1251. struct page *page;
  1252. offset = pos % PAGE_SIZE;
  1253. i = pos/PAGE_SIZE;
  1254. page = bprm->page[i];
  1255. new = 0;
  1256. if (!page) {
  1257. page = alloc_page(GFP_HIGHUSER);
  1258. bprm->page[i] = page;
  1259. if (!page) {
  1260. ret = -ENOMEM;
  1261. goto out;
  1262. }
  1263. new = 1;
  1264. }
  1265. if (page != kmapped_page) {
  1266. if (kmapped_page)
  1267. kunmap(kmapped_page);
  1268. kmapped_page = page;
  1269. kaddr = kmap(kmapped_page);
  1270. }
  1271. if (new && offset)
  1272. memset(kaddr, 0, offset);
  1273. bytes_to_copy = PAGE_SIZE - offset;
  1274. if (bytes_to_copy > len) {
  1275. bytes_to_copy = len;
  1276. if (new)
  1277. memset(kaddr+offset+len, 0,
  1278. PAGE_SIZE-offset-len);
  1279. }
  1280. err = copy_from_user(kaddr+offset, compat_ptr(str),
  1281. bytes_to_copy);
  1282. if (err) {
  1283. ret = -EFAULT;
  1284. goto out;
  1285. }
  1286. pos += bytes_to_copy;
  1287. str += bytes_to_copy;
  1288. len -= bytes_to_copy;
  1289. }
  1290. }
  1291. ret = 0;
  1292. out:
  1293. if (kmapped_page)
  1294. kunmap(kmapped_page);
  1295. return ret;
  1296. }
  1297. #ifdef CONFIG_MMU
  1298. #define free_arg_pages(bprm) do { } while (0)
  1299. #else
  1300. static inline void free_arg_pages(struct linux_binprm *bprm)
  1301. {
  1302. int i;
  1303. for (i = 0; i < MAX_ARG_PAGES; i++) {
  1304. if (bprm->page[i])
  1305. __free_page(bprm->page[i]);
  1306. bprm->page[i] = NULL;
  1307. }
  1308. }
  1309. #endif /* CONFIG_MMU */
  1310. /*
  1311. * compat_do_execve() is mostly a copy of do_execve(), with the exception
  1312. * that it processes 32 bit argv and envp pointers.
  1313. */
  1314. int compat_do_execve(char * filename,
  1315. compat_uptr_t __user *argv,
  1316. compat_uptr_t __user *envp,
  1317. struct pt_regs * regs)
  1318. {
  1319. struct linux_binprm *bprm;
  1320. struct file *file;
  1321. int retval;
  1322. int i;
  1323. retval = -ENOMEM;
  1324. bprm = kzalloc(sizeof(*bprm), GFP_KERNEL);
  1325. if (!bprm)
  1326. goto out_ret;
  1327. file = open_exec(filename);
  1328. retval = PTR_ERR(file);
  1329. if (IS_ERR(file))
  1330. goto out_kfree;
  1331. sched_exec();
  1332. bprm->p = PAGE_SIZE*MAX_ARG_PAGES-sizeof(void *);
  1333. bprm->file = file;
  1334. bprm->filename = filename;
  1335. bprm->interp = filename;
  1336. bprm->mm = mm_alloc();
  1337. retval = -ENOMEM;
  1338. if (!bprm->mm)
  1339. goto out_file;
  1340. retval = init_new_context(current, bprm->mm);
  1341. if (retval < 0)
  1342. goto out_mm;
  1343. bprm->argc = compat_count(argv, bprm->p / sizeof(compat_uptr_t));
  1344. if ((retval = bprm->argc) < 0)
  1345. goto out_mm;
  1346. bprm->envc = compat_count(envp, bprm->p / sizeof(compat_uptr_t));
  1347. if ((retval = bprm->envc) < 0)
  1348. goto out_mm;
  1349. retval = security_bprm_alloc(bprm);
  1350. if (retval)
  1351. goto out;
  1352. retval = prepare_binprm(bprm);
  1353. if (retval < 0)
  1354. goto out;
  1355. retval = copy_strings_kernel(1, &bprm->filename, bprm);
  1356. if (retval < 0)
  1357. goto out;
  1358. bprm->exec = bprm->p;
  1359. retval = compat_copy_strings(bprm->envc, envp, bprm);
  1360. if (retval < 0)
  1361. goto out;
  1362. retval = compat_copy_strings(bprm->argc, argv, bprm);
  1363. if (retval < 0)
  1364. goto out;
  1365. retval = search_binary_handler(bprm, regs);
  1366. if (retval >= 0) {
  1367. free_arg_pages(bprm);
  1368. /* execve success */
  1369. security_bprm_free(bprm);
  1370. acct_update_integrals(current);
  1371. kfree(bprm);
  1372. return retval;
  1373. }
  1374. out:
  1375. /* Something went wrong, return the inode and free the argument pages*/
  1376. for (i = 0 ; i < MAX_ARG_PAGES ; i++) {
  1377. struct page * page = bprm->page[i];
  1378. if (page)
  1379. __free_page(page);
  1380. }
  1381. if (bprm->security)
  1382. security_bprm_free(bprm);
  1383. out_mm:
  1384. if (bprm->mm)
  1385. mmdrop(bprm->mm);
  1386. out_file:
  1387. if (bprm->file) {
  1388. allow_write_access(bprm->file);
  1389. fput(bprm->file);
  1390. }
  1391. out_kfree:
  1392. kfree(bprm);
  1393. out_ret:
  1394. return retval;
  1395. }
  1396. #define __COMPAT_NFDBITS (8 * sizeof(compat_ulong_t))
  1397. #define ROUND_UP(x,y) (((x)+(y)-1)/(y))
  1398. /*
  1399. * Ooo, nasty. We need here to frob 32-bit unsigned longs to
  1400. * 64-bit unsigned longs.
  1401. */
  1402. static
  1403. int compat_get_fd_set(unsigned long nr, compat_ulong_t __user *ufdset,
  1404. unsigned long *fdset)
  1405. {
  1406. nr = ROUND_UP(nr, __COMPAT_NFDBITS);
  1407. if (ufdset) {
  1408. unsigned long odd;
  1409. if (!access_ok(VERIFY_WRITE, ufdset, nr*sizeof(compat_ulong_t)))
  1410. return -EFAULT;
  1411. odd = nr & 1UL;
  1412. nr &= ~1UL;
  1413. while (nr) {
  1414. unsigned long h, l;
  1415. __get_user(l, ufdset);
  1416. __get_user(h, ufdset+1);
  1417. ufdset += 2;
  1418. *fdset++ = h << 32 | l;
  1419. nr -= 2;
  1420. }
  1421. if (odd)
  1422. __get_user(*fdset, ufdset);
  1423. } else {
  1424. /* Tricky, must clear full unsigned long in the
  1425. * kernel fdset at the end, this makes sure that
  1426. * actually happens.
  1427. */
  1428. memset(fdset, 0, ((nr + 1) & ~1)*sizeof(compat_ulong_t));
  1429. }
  1430. return 0;
  1431. }
  1432. static
  1433. void compat_set_fd_set(unsigned long nr, compat_ulong_t __user *ufdset,
  1434. unsigned long *fdset)
  1435. {
  1436. unsigned long odd;
  1437. nr = ROUND_UP(nr, __COMPAT_NFDBITS);
  1438. if (!ufdset)
  1439. return;
  1440. odd = nr & 1UL;
  1441. nr &= ~1UL;
  1442. while (nr) {
  1443. unsigned long h, l;
  1444. l = *fdset++;
  1445. h = l >> 32;
  1446. __put_user(l, ufdset);
  1447. __put_user(h, ufdset+1);
  1448. ufdset += 2;
  1449. nr -= 2;
  1450. }
  1451. if (odd)
  1452. __put_user(*fdset, ufdset);
  1453. }
  1454. /*
  1455. * This is a virtual copy of sys_select from fs/select.c and probably
  1456. * should be compared to it from time to time
  1457. */
  1458. /*
  1459. * We can actually return ERESTARTSYS instead of EINTR, but I'd
  1460. * like to be certain this leads to no problems. So I return
  1461. * EINTR just for safety.
  1462. *
  1463. * Update: ERESTARTSYS breaks at least the xview clock binary, so
  1464. * I'm trying ERESTARTNOHAND which restart only when you want to.
  1465. */
  1466. #define MAX_SELECT_SECONDS \
  1467. ((unsigned long) (MAX_SCHEDULE_TIMEOUT / HZ)-1)
  1468. int compat_core_sys_select(int n, compat_ulong_t __user *inp,
  1469. compat_ulong_t __user *outp, compat_ulong_t __user *exp, s64 *timeout)
  1470. {
  1471. fd_set_bits fds;
  1472. char *bits;
  1473. int size, max_fdset, ret = -EINVAL;
  1474. struct fdtable *fdt;
  1475. if (n < 0)
  1476. goto out_nofds;
  1477. /* max_fdset can increase, so grab it once to avoid race */
  1478. rcu_read_lock();
  1479. fdt = files_fdtable(current->files);
  1480. max_fdset = fdt->max_fdset;
  1481. rcu_read_unlock();
  1482. if (n > max_fdset)
  1483. n = max_fdset;
  1484. /*
  1485. * We need 6 bitmaps (in/out/ex for both incoming and outgoing),
  1486. * since we used fdset we need to allocate memory in units of
  1487. * long-words.
  1488. */
  1489. ret = -ENOMEM;
  1490. size = FDS_BYTES(n);
  1491. bits = kmalloc(6 * size, GFP_KERNEL);
  1492. if (!bits)
  1493. goto out_nofds;
  1494. fds.in = (unsigned long *) bits;
  1495. fds.out = (unsigned long *) (bits + size);
  1496. fds.ex = (unsigned long *) (bits + 2*size);
  1497. fds.res_in = (unsigned long *) (bits + 3*size);
  1498. fds.res_out = (unsigned long *) (bits + 4*size);
  1499. fds.res_ex = (unsigned long *) (bits + 5*size);
  1500. if ((ret = compat_get_fd_set(n, inp, fds.in)) ||
  1501. (ret = compat_get_fd_set(n, outp, fds.out)) ||
  1502. (ret = compat_get_fd_set(n, exp, fds.ex)))
  1503. goto out;
  1504. zero_fd_set(n, fds.res_in);
  1505. zero_fd_set(n, fds.res_out);
  1506. zero_fd_set(n, fds.res_ex);
  1507. ret = do_select(n, &fds, timeout);
  1508. if (ret < 0)
  1509. goto out;
  1510. if (!ret) {
  1511. ret = -ERESTARTNOHAND;
  1512. if (signal_pending(current))
  1513. goto out;
  1514. ret = 0;
  1515. }
  1516. compat_set_fd_set(n, inp, fds.res_in);
  1517. compat_set_fd_set(n, outp, fds.res_out);
  1518. compat_set_fd_set(n, exp, fds.res_ex);
  1519. out:
  1520. kfree(bits);
  1521. out_nofds:
  1522. return ret;
  1523. }
  1524. asmlinkage long compat_sys_select(int n, compat_ulong_t __user *inp,
  1525. compat_ulong_t __user *outp, compat_ulong_t __user *exp,
  1526. struct compat_timeval __user *tvp)
  1527. {
  1528. s64 timeout = -1;
  1529. struct compat_timeval tv;
  1530. int ret;
  1531. if (tvp) {
  1532. if (copy_from_user(&tv, tvp, sizeof(tv)))
  1533. return -EFAULT;
  1534. if (tv.tv_sec < 0 || tv.tv_usec < 0)
  1535. return -EINVAL;
  1536. /* Cast to u64 to make GCC stop complaining */
  1537. if ((u64)tv.tv_sec >= (u64)MAX_INT64_SECONDS)
  1538. timeout = -1; /* infinite */
  1539. else {
  1540. timeout = ROUND_UP(tv.tv_usec, 1000000/HZ);
  1541. timeout += tv.tv_sec * HZ;
  1542. }
  1543. }
  1544. ret = compat_core_sys_select(n, inp, outp, exp, &timeout);
  1545. if (tvp) {
  1546. struct compat_timeval rtv;
  1547. if (current->personality & STICKY_TIMEOUTS)
  1548. goto sticky;
  1549. rtv.tv_usec = jiffies_to_usecs(do_div((*(u64*)&timeout), HZ));
  1550. rtv.tv_sec = timeout;
  1551. if (compat_timeval_compare(&rtv, &tv) >= 0)
  1552. rtv = tv;
  1553. if (copy_to_user(tvp, &rtv, sizeof(rtv))) {
  1554. sticky:
  1555. /*
  1556. * If an application puts its timeval in read-only
  1557. * memory, we don't want the Linux-specific update to
  1558. * the timeval to cause a fault after the select has
  1559. * completed successfully. However, because we're not
  1560. * updating the timeval, we can't restart the system
  1561. * call.
  1562. */
  1563. if (ret == -ERESTARTNOHAND)
  1564. ret = -EINTR;
  1565. }
  1566. }
  1567. return ret;
  1568. }
  1569. #ifdef TIF_RESTORE_SIGMASK
  1570. asmlinkage long compat_sys_pselect7(int n, compat_ulong_t __user *inp,
  1571. compat_ulong_t __user *outp, compat_ulong_t __user *exp,
  1572. struct compat_timespec __user *tsp, compat_sigset_t __user *sigmask,
  1573. compat_size_t sigsetsize)
  1574. {
  1575. compat_sigset_t ss32;
  1576. sigset_t ksigmask, sigsaved;
  1577. s64 timeout = MAX_SCHEDULE_TIMEOUT;
  1578. struct compat_timespec ts;
  1579. int ret;
  1580. if (tsp) {
  1581. if (copy_from_user(&ts, tsp, sizeof(ts)))
  1582. return -EFAULT;
  1583. if (ts.tv_sec < 0 || ts.tv_nsec < 0)
  1584. return -EINVAL;
  1585. }
  1586. if (sigmask) {
  1587. if (sigsetsize != sizeof(compat_sigset_t))
  1588. return -EINVAL;
  1589. if (copy_from_user(&ss32, sigmask, sizeof(ss32)))
  1590. return -EFAULT;
  1591. sigset_from_compat(&ksigmask, &ss32);
  1592. sigdelsetmask(&ksigmask, sigmask(SIGKILL)|sigmask(SIGSTOP));
  1593. sigprocmask(SIG_SETMASK, &ksigmask, &sigsaved);
  1594. }
  1595. do {
  1596. if (tsp) {
  1597. if ((unsigned long)ts.tv_sec < MAX_SELECT_SECONDS) {
  1598. timeout = ROUND_UP(ts.tv_nsec, 1000000000/HZ);
  1599. timeout += ts.tv_sec * (unsigned long)HZ;
  1600. ts.tv_sec = 0;
  1601. ts.tv_nsec = 0;
  1602. } else {
  1603. ts.tv_sec -= MAX_SELECT_SECONDS;
  1604. timeout = MAX_SELECT_SECONDS * HZ;
  1605. }
  1606. }
  1607. ret = compat_core_sys_select(n, inp, outp, exp, &timeout);
  1608. } while (!ret && !timeout && tsp && (ts.tv_sec || ts.tv_nsec));
  1609. if (ret == 0 && tsp && !(current->personality & STICKY_TIMEOUTS)) {
  1610. struct compat_timespec rts;
  1611. rts.tv_sec = timeout / HZ;
  1612. rts.tv_nsec = (timeout % HZ) * (NSEC_PER_SEC/HZ);
  1613. if (rts.tv_nsec >= NSEC_PER_SEC) {
  1614. rts.tv_sec++;
  1615. rts.tv_nsec -= NSEC_PER_SEC;
  1616. }
  1617. if (compat_timespec_compare(&rts, &ts) >= 0)
  1618. rts = ts;
  1619. if (copy_to_user(tsp, &rts, sizeof(rts)))
  1620. ret = -EFAULT;
  1621. }
  1622. if (ret == -ERESTARTNOHAND) {
  1623. /*
  1624. * Don't restore the signal mask yet. Let do_signal() deliver
  1625. * the signal on the way back to userspace, before the signal
  1626. * mask is restored.
  1627. */
  1628. if (sigmask) {
  1629. memcpy(&current->saved_sigmask, &sigsaved,
  1630. sizeof(sigsaved));
  1631. set_thread_flag(TIF_RESTORE_SIGMASK);
  1632. }
  1633. } else if (sigmask)
  1634. sigprocmask(SIG_SETMASK, &sigsaved, NULL);
  1635. return ret;
  1636. }
  1637. asmlinkage long compat_sys_pselect6(int n, compat_ulong_t __user *inp,
  1638. compat_ulong_t __user *outp, compat_ulong_t __user *exp,
  1639. struct compat_timespec __user *tsp, void __user *sig)
  1640. {
  1641. compat_size_t sigsetsize = 0;
  1642. compat_uptr_t up = 0;
  1643. if (sig) {
  1644. if (!access_ok(VERIFY_READ, sig,
  1645. sizeof(compat_uptr_t)+sizeof(compat_size_t)) ||
  1646. __get_user(up, (compat_uptr_t __user *)sig) ||
  1647. __get_user(sigsetsize,
  1648. (compat_size_t __user *)(sig+sizeof(up))))
  1649. return -EFAULT;
  1650. }
  1651. return compat_sys_pselect7(n, inp, outp, exp, tsp, compat_ptr(up),
  1652. sigsetsize);
  1653. }
  1654. asmlinkage long compat_sys_ppoll(struct pollfd __user *ufds,
  1655. unsigned int nfds, struct compat_timespec __user *tsp,
  1656. const compat_sigset_t __user *sigmask, compat_size_t sigsetsize)
  1657. {
  1658. compat_sigset_t ss32;
  1659. sigset_t ksigmask, sigsaved;
  1660. struct compat_timespec ts;
  1661. s64 timeout = -1;
  1662. int ret;
  1663. if (tsp) {
  1664. if (copy_from_user(&ts, tsp, sizeof(ts)))
  1665. return -EFAULT;
  1666. /* We assume that ts.tv_sec is always lower than
  1667. the number of seconds that can be expressed in
  1668. an s64. Otherwise the compiler bitches at us */
  1669. timeout = ROUND_UP(ts.tv_nsec, 1000000000/HZ);
  1670. timeout += ts.tv_sec * HZ;
  1671. }
  1672. if (sigmask) {
  1673. if (sigsetsize != sizeof(compat_sigset_t))
  1674. return -EINVAL;
  1675. if (copy_from_user(&ss32, sigmask, sizeof(ss32)))
  1676. return -EFAULT;
  1677. sigset_from_compat(&ksigmask, &ss32);
  1678. sigdelsetmask(&ksigmask, sigmask(SIGKILL)|sigmask(SIGSTOP));
  1679. sigprocmask(SIG_SETMASK, &ksigmask, &sigsaved);
  1680. }
  1681. ret = do_sys_poll(ufds, nfds, &timeout);
  1682. /* We can restart this syscall, usually */
  1683. if (ret == -EINTR) {
  1684. /*
  1685. * Don't restore the signal mask yet. Let do_signal() deliver
  1686. * the signal on the way back to userspace, before the signal
  1687. * mask is restored.
  1688. */
  1689. if (sigmask) {
  1690. memcpy(&current->saved_sigmask, &sigsaved,
  1691. sizeof(sigsaved));
  1692. set_thread_flag(TIF_RESTORE_SIGMASK);
  1693. }
  1694. ret = -ERESTARTNOHAND;
  1695. } else if (sigmask)
  1696. sigprocmask(SIG_SETMASK, &sigsaved, NULL);
  1697. if (tsp && timeout >= 0) {
  1698. struct compat_timespec rts;
  1699. if (current->personality & STICKY_TIMEOUTS)
  1700. goto sticky;
  1701. /* Yes, we know it's actually an s64, but it's also positive. */
  1702. rts.tv_nsec = jiffies_to_usecs(do_div((*(u64*)&timeout), HZ)) *
  1703. 1000;
  1704. rts.tv_sec = timeout;
  1705. if (compat_timespec_compare(&rts, &ts) >= 0)
  1706. rts = ts;
  1707. if (copy_to_user(tsp, &rts, sizeof(rts))) {
  1708. sticky:
  1709. /*
  1710. * If an application puts its timeval in read-only
  1711. * memory, we don't want the Linux-specific update to
  1712. * the timeval to cause a fault after the select has
  1713. * completed successfully. However, because we're not
  1714. * updating the timeval, we can't restart the system
  1715. * call.
  1716. */
  1717. if (ret == -ERESTARTNOHAND && timeout >= 0)
  1718. ret = -EINTR;
  1719. }
  1720. }
  1721. return ret;
  1722. }
  1723. #endif /* TIF_RESTORE_SIGMASK */
  1724. #if defined(CONFIG_NFSD) || defined(CONFIG_NFSD_MODULE)
  1725. /* Stuff for NFS server syscalls... */
  1726. struct compat_nfsctl_svc {
  1727. u16 svc32_port;
  1728. s32 svc32_nthreads;
  1729. };
  1730. struct compat_nfsctl_client {
  1731. s8 cl32_ident[NFSCLNT_IDMAX+1];
  1732. s32 cl32_naddr;
  1733. struct in_addr cl32_addrlist[NFSCLNT_ADDRMAX];
  1734. s32 cl32_fhkeytype;
  1735. s32 cl32_fhkeylen;
  1736. u8 cl32_fhkey[NFSCLNT_KEYMAX];
  1737. };
  1738. struct compat_nfsctl_export {
  1739. char ex32_client[NFSCLNT_IDMAX+1];
  1740. char ex32_path[NFS_MAXPATHLEN+1];
  1741. compat_dev_t ex32_dev;
  1742. compat_ino_t ex32_ino;
  1743. compat_int_t ex32_flags;
  1744. __compat_uid_t ex32_anon_uid;
  1745. __compat_gid_t ex32_anon_gid;
  1746. };
  1747. struct compat_nfsctl_fdparm {
  1748. struct sockaddr gd32_addr;
  1749. s8 gd32_path[NFS_MAXPATHLEN+1];
  1750. compat_int_t gd32_version;
  1751. };
  1752. struct compat_nfsctl_fsparm {
  1753. struct sockaddr gd32_addr;
  1754. s8 gd32_path[NFS_MAXPATHLEN+1];
  1755. compat_int_t gd32_maxlen;
  1756. };
  1757. struct compat_nfsctl_arg {
  1758. compat_int_t ca32_version; /* safeguard */
  1759. union {
  1760. struct compat_nfsctl_svc u32_svc;
  1761. struct compat_nfsctl_client u32_client;
  1762. struct compat_nfsctl_export u32_export;
  1763. struct compat_nfsctl_fdparm u32_getfd;
  1764. struct compat_nfsctl_fsparm u32_getfs;
  1765. } u;
  1766. #define ca32_svc u.u32_svc
  1767. #define ca32_client u.u32_client
  1768. #define ca32_export u.u32_export
  1769. #define ca32_getfd u.u32_getfd
  1770. #define ca32_getfs u.u32_getfs
  1771. };
  1772. union compat_nfsctl_res {
  1773. __u8 cr32_getfh[NFS_FHSIZE];
  1774. struct knfsd_fh cr32_getfs;
  1775. };
  1776. static int compat_nfs_svc_trans(struct nfsctl_arg *karg,
  1777. struct compat_nfsctl_arg __user *arg)
  1778. {
  1779. if (!access_ok(VERIFY_READ, &arg->ca32_svc, sizeof(arg->ca32_svc)) ||
  1780. get_user(karg->ca_version, &arg->ca32_version) ||
  1781. __get_user(karg->ca_svc.svc_port, &arg->ca32_svc.svc32_port) ||
  1782. __get_user(karg->ca_svc.svc_nthreads,
  1783. &arg->ca32_svc.svc32_nthreads))
  1784. return -EFAULT;
  1785. return 0;
  1786. }
  1787. static int compat_nfs_clnt_trans(struct nfsctl_arg *karg,
  1788. struct compat_nfsctl_arg __user *arg)
  1789. {
  1790. if (!access_ok(VERIFY_READ, &arg->ca32_client,
  1791. sizeof(arg->ca32_client)) ||
  1792. get_user(karg->ca_version, &arg->ca32_version) ||
  1793. __copy_from_user(&karg->ca_client.cl_ident[0],
  1794. &arg->ca32_client.cl32_ident[0],
  1795. NFSCLNT_IDMAX) ||
  1796. __get_user(karg->ca_client.cl_naddr,
  1797. &arg->ca32_client.cl32_naddr) ||
  1798. __copy_from_user(&karg->ca_client.cl_addrlist[0],
  1799. &arg->ca32_client.cl32_addrlist[0],
  1800. (sizeof(struct in_addr) * NFSCLNT_ADDRMAX)) ||
  1801. __get_user(karg->ca_client.cl_fhkeytype,
  1802. &arg->ca32_client.cl32_fhkeytype) ||
  1803. __get_user(karg->ca_client.cl_fhkeylen,
  1804. &arg->ca32_client.cl32_fhkeylen) ||
  1805. __copy_from_user(&karg->ca_client.cl_fhkey[0],
  1806. &arg->ca32_client.cl32_fhkey[0],
  1807. NFSCLNT_KEYMAX))
  1808. return -EFAULT;
  1809. return 0;
  1810. }
  1811. static int compat_nfs_exp_trans(struct nfsctl_arg *karg,
  1812. struct compat_nfsctl_arg __user *arg)
  1813. {
  1814. if (!access_ok(VERIFY_READ, &arg->ca32_export,
  1815. sizeof(arg->ca32_export)) ||
  1816. get_user(karg->ca_version, &arg->ca32_version) ||
  1817. __copy_from_user(&karg->ca_export.ex_client[0],
  1818. &arg->ca32_export.ex32_client[0],
  1819. NFSCLNT_IDMAX) ||
  1820. __copy_from_user(&karg->ca_export.ex_path[0],
  1821. &arg->ca32_export.ex32_path[0],
  1822. NFS_MAXPATHLEN) ||
  1823. __get_user(karg->ca_export.ex_dev,
  1824. &arg->ca32_export.ex32_dev) ||
  1825. __get_user(karg->ca_export.ex_ino,
  1826. &arg->ca32_export.ex32_ino) ||
  1827. __get_user(karg->ca_export.ex_flags,
  1828. &arg->ca32_export.ex32_flags) ||
  1829. __get_user(karg->ca_export.ex_anon_uid,
  1830. &arg->ca32_export.ex32_anon_uid) ||
  1831. __get_user(karg->ca_export.ex_anon_gid,
  1832. &arg->ca32_export.ex32_anon_gid))
  1833. return -EFAULT;
  1834. SET_UID(karg->ca_export.ex_anon_uid, karg->ca_export.ex_anon_uid);
  1835. SET_GID(karg->ca_export.ex_anon_gid, karg->ca_export.ex_anon_gid);
  1836. return 0;
  1837. }
  1838. static int compat_nfs_getfd_trans(struct nfsctl_arg *karg,
  1839. struct compat_nfsctl_arg __user *arg)
  1840. {
  1841. if (!access_ok(VERIFY_READ, &arg->ca32_getfd,
  1842. sizeof(arg->ca32_getfd)) ||
  1843. get_user(karg->ca_version, &arg->ca32_version) ||
  1844. __copy_from_user(&karg->ca_getfd.gd_addr,
  1845. &arg->ca32_getfd.gd32_addr,
  1846. (sizeof(struct sockaddr))) ||
  1847. __copy_from_user(&karg->ca_getfd.gd_path,
  1848. &arg->ca32_getfd.gd32_path,
  1849. (NFS_MAXPATHLEN+1)) ||
  1850. __get_user(karg->ca_getfd.gd_version,
  1851. &arg->ca32_getfd.gd32_version))
  1852. return -EFAULT;
  1853. return 0;
  1854. }
  1855. static int compat_nfs_getfs_trans(struct nfsctl_arg *karg,
  1856. struct compat_nfsctl_arg __user *arg)
  1857. {
  1858. if (!access_ok(VERIFY_READ,&arg->ca32_getfs,sizeof(arg->ca32_getfs)) ||
  1859. get_user(karg->ca_version, &arg->ca32_version) ||
  1860. __copy_from_user(&karg->ca_getfs.gd_addr,
  1861. &arg->ca32_getfs.gd32_addr,
  1862. (sizeof(struct sockaddr))) ||
  1863. __copy_from_user(&karg->ca_getfs.gd_path,
  1864. &arg->ca32_getfs.gd32_path,
  1865. (NFS_MAXPATHLEN+1)) ||
  1866. __get_user(karg->ca_getfs.gd_maxlen,
  1867. &arg->ca32_getfs.gd32_maxlen))
  1868. return -EFAULT;
  1869. return 0;
  1870. }
  1871. /* This really doesn't need translations, we are only passing
  1872. * back a union which contains opaque nfs file handle data.
  1873. */
  1874. static int compat_nfs_getfh_res_trans(union nfsctl_res *kres,
  1875. union compat_nfsctl_res __user *res)
  1876. {
  1877. int err;
  1878. err = copy_to_user(res, kres, sizeof(*res));
  1879. return (err) ? -EFAULT : 0;
  1880. }
  1881. asmlinkage long compat_sys_nfsservctl(int cmd,
  1882. struct compat_nfsctl_arg __user *arg,
  1883. union compat_nfsctl_res __user *res)
  1884. {
  1885. struct nfsctl_arg *karg;
  1886. union nfsctl_res *kres;
  1887. mm_segment_t oldfs;
  1888. int err;
  1889. karg = kmalloc(sizeof(*karg), GFP_USER);
  1890. kres = kmalloc(sizeof(*kres), GFP_USER);
  1891. if(!karg || !kres) {
  1892. err = -ENOMEM;
  1893. goto done;
  1894. }
  1895. switch(cmd) {
  1896. case NFSCTL_SVC:
  1897. err = compat_nfs_svc_trans(karg, arg);
  1898. break;
  1899. case NFSCTL_ADDCLIENT:
  1900. err = compat_nfs_clnt_trans(karg, arg);
  1901. break;
  1902. case NFSCTL_DELCLIENT:
  1903. err = compat_nfs_clnt_trans(karg, arg);
  1904. break;
  1905. case NFSCTL_EXPORT:
  1906. case NFSCTL_UNEXPORT:
  1907. err = compat_nfs_exp_trans(karg, arg);
  1908. break;
  1909. case NFSCTL_GETFD:
  1910. err = compat_nfs_getfd_trans(karg, arg);
  1911. break;
  1912. case NFSCTL_GETFS:
  1913. err = compat_nfs_getfs_trans(karg, arg);
  1914. break;
  1915. default:
  1916. err = -EINVAL;
  1917. break;
  1918. }
  1919. if (err)
  1920. goto done;
  1921. oldfs = get_fs();
  1922. set_fs(KERNEL_DS);
  1923. /* The __user pointer casts are valid because of the set_fs() */
  1924. err = sys_nfsservctl(cmd, (void __user *) karg, (void __user *) kres);
  1925. set_fs(oldfs);
  1926. if (err)
  1927. goto done;
  1928. if((cmd == NFSCTL_GETFD) ||
  1929. (cmd == NFSCTL_GETFS))
  1930. err = compat_nfs_getfh_res_trans(kres, res);
  1931. done:
  1932. kfree(karg);
  1933. kfree(kres);
  1934. return err;
  1935. }
  1936. #else /* !NFSD */
  1937. long asmlinkage compat_sys_nfsservctl(int cmd, void *notused, void *notused2)
  1938. {
  1939. return sys_ni_syscall();
  1940. }
  1941. #endif