compat.c 45 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806
  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@ucw.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/stddef.h>
  18. #include <linux/kernel.h>
  19. #include <linux/linkage.h>
  20. #include <linux/compat.h>
  21. #include <linux/errno.h>
  22. #include <linux/time.h>
  23. #include <linux/fs.h>
  24. #include <linux/fcntl.h>
  25. #include <linux/namei.h>
  26. #include <linux/file.h>
  27. #include <linux/fdtable.h>
  28. #include <linux/vfs.h>
  29. #include <linux/ioctl.h>
  30. #include <linux/init.h>
  31. #include <linux/ncp_mount.h>
  32. #include <linux/nfs4_mount.h>
  33. #include <linux/syscalls.h>
  34. #include <linux/ctype.h>
  35. #include <linux/module.h>
  36. #include <linux/dirent.h>
  37. #include <linux/fsnotify.h>
  38. #include <linux/highuid.h>
  39. #include <linux/personality.h>
  40. #include <linux/rwsem.h>
  41. #include <linux/tsacct_kern.h>
  42. #include <linux/security.h>
  43. #include <linux/highmem.h>
  44. #include <linux/signal.h>
  45. #include <linux/poll.h>
  46. #include <linux/mm.h>
  47. #include <linux/eventpoll.h>
  48. #include <linux/fs_struct.h>
  49. #include <linux/slab.h>
  50. #include <linux/pagemap.h>
  51. #include <asm/uaccess.h>
  52. #include <asm/mmu_context.h>
  53. #include <asm/ioctls.h>
  54. #include "internal.h"
  55. int compat_log = 1;
  56. int compat_printk(const char *fmt, ...)
  57. {
  58. va_list ap;
  59. int ret;
  60. if (!compat_log)
  61. return 0;
  62. va_start(ap, fmt);
  63. ret = vprintk(fmt, ap);
  64. va_end(ap);
  65. return ret;
  66. }
  67. #include "read_write.h"
  68. /*
  69. * Not all architectures have sys_utime, so implement this in terms
  70. * of sys_utimes.
  71. */
  72. asmlinkage long compat_sys_utime(const char __user *filename,
  73. struct compat_utimbuf __user *t)
  74. {
  75. struct timespec tv[2];
  76. if (t) {
  77. if (get_user(tv[0].tv_sec, &t->actime) ||
  78. get_user(tv[1].tv_sec, &t->modtime))
  79. return -EFAULT;
  80. tv[0].tv_nsec = 0;
  81. tv[1].tv_nsec = 0;
  82. }
  83. return do_utimes(AT_FDCWD, filename, t ? tv : NULL, 0);
  84. }
  85. asmlinkage long compat_sys_utimensat(unsigned int dfd, const char __user *filename, struct compat_timespec __user *t, int flags)
  86. {
  87. struct timespec tv[2];
  88. if (t) {
  89. if (get_compat_timespec(&tv[0], &t[0]) ||
  90. get_compat_timespec(&tv[1], &t[1]))
  91. return -EFAULT;
  92. if (tv[0].tv_nsec == UTIME_OMIT && tv[1].tv_nsec == UTIME_OMIT)
  93. return 0;
  94. }
  95. return do_utimes(dfd, filename, t ? tv : NULL, flags);
  96. }
  97. asmlinkage long compat_sys_futimesat(unsigned int dfd, const char __user *filename, struct compat_timeval __user *t)
  98. {
  99. struct timespec tv[2];
  100. if (t) {
  101. if (get_user(tv[0].tv_sec, &t[0].tv_sec) ||
  102. get_user(tv[0].tv_nsec, &t[0].tv_usec) ||
  103. get_user(tv[1].tv_sec, &t[1].tv_sec) ||
  104. get_user(tv[1].tv_nsec, &t[1].tv_usec))
  105. return -EFAULT;
  106. if (tv[0].tv_nsec >= 1000000 || tv[0].tv_nsec < 0 ||
  107. tv[1].tv_nsec >= 1000000 || tv[1].tv_nsec < 0)
  108. return -EINVAL;
  109. tv[0].tv_nsec *= 1000;
  110. tv[1].tv_nsec *= 1000;
  111. }
  112. return do_utimes(dfd, filename, t ? tv : NULL, 0);
  113. }
  114. asmlinkage long compat_sys_utimes(const char __user *filename, struct compat_timeval __user *t)
  115. {
  116. return compat_sys_futimesat(AT_FDCWD, filename, t);
  117. }
  118. static int cp_compat_stat(struct kstat *stat, struct compat_stat __user *ubuf)
  119. {
  120. compat_ino_t ino = stat->ino;
  121. typeof(ubuf->st_uid) uid = 0;
  122. typeof(ubuf->st_gid) gid = 0;
  123. int err;
  124. SET_UID(uid, stat->uid);
  125. SET_GID(gid, stat->gid);
  126. if ((u64) stat->size > MAX_NON_LFS ||
  127. !old_valid_dev(stat->dev) ||
  128. !old_valid_dev(stat->rdev))
  129. return -EOVERFLOW;
  130. if (sizeof(ino) < sizeof(stat->ino) && ino != stat->ino)
  131. return -EOVERFLOW;
  132. if (clear_user(ubuf, sizeof(*ubuf)))
  133. return -EFAULT;
  134. err = __put_user(old_encode_dev(stat->dev), &ubuf->st_dev);
  135. err |= __put_user(ino, &ubuf->st_ino);
  136. err |= __put_user(stat->mode, &ubuf->st_mode);
  137. err |= __put_user(stat->nlink, &ubuf->st_nlink);
  138. err |= __put_user(uid, &ubuf->st_uid);
  139. err |= __put_user(gid, &ubuf->st_gid);
  140. err |= __put_user(old_encode_dev(stat->rdev), &ubuf->st_rdev);
  141. err |= __put_user(stat->size, &ubuf->st_size);
  142. err |= __put_user(stat->atime.tv_sec, &ubuf->st_atime);
  143. err |= __put_user(stat->atime.tv_nsec, &ubuf->st_atime_nsec);
  144. err |= __put_user(stat->mtime.tv_sec, &ubuf->st_mtime);
  145. err |= __put_user(stat->mtime.tv_nsec, &ubuf->st_mtime_nsec);
  146. err |= __put_user(stat->ctime.tv_sec, &ubuf->st_ctime);
  147. err |= __put_user(stat->ctime.tv_nsec, &ubuf->st_ctime_nsec);
  148. err |= __put_user(stat->blksize, &ubuf->st_blksize);
  149. err |= __put_user(stat->blocks, &ubuf->st_blocks);
  150. return err;
  151. }
  152. asmlinkage long compat_sys_newstat(const char __user * filename,
  153. struct compat_stat __user *statbuf)
  154. {
  155. struct kstat stat;
  156. int error;
  157. error = vfs_stat(filename, &stat);
  158. if (error)
  159. return error;
  160. return cp_compat_stat(&stat, statbuf);
  161. }
  162. asmlinkage long compat_sys_newlstat(const char __user * filename,
  163. struct compat_stat __user *statbuf)
  164. {
  165. struct kstat stat;
  166. int error;
  167. error = vfs_lstat(filename, &stat);
  168. if (error)
  169. return error;
  170. return cp_compat_stat(&stat, statbuf);
  171. }
  172. #ifndef __ARCH_WANT_STAT64
  173. asmlinkage long compat_sys_newfstatat(unsigned int dfd,
  174. const char __user *filename,
  175. struct compat_stat __user *statbuf, int flag)
  176. {
  177. struct kstat stat;
  178. int error;
  179. error = vfs_fstatat(dfd, filename, &stat, flag);
  180. if (error)
  181. return error;
  182. return cp_compat_stat(&stat, statbuf);
  183. }
  184. #endif
  185. asmlinkage long compat_sys_newfstat(unsigned int fd,
  186. struct compat_stat __user * statbuf)
  187. {
  188. struct kstat stat;
  189. int error = vfs_fstat(fd, &stat);
  190. if (!error)
  191. error = cp_compat_stat(&stat, statbuf);
  192. return error;
  193. }
  194. static int put_compat_statfs(struct compat_statfs __user *ubuf, struct kstatfs *kbuf)
  195. {
  196. if (sizeof ubuf->f_blocks == 4) {
  197. if ((kbuf->f_blocks | kbuf->f_bfree | kbuf->f_bavail |
  198. kbuf->f_bsize | kbuf->f_frsize) & 0xffffffff00000000ULL)
  199. return -EOVERFLOW;
  200. /* f_files and f_ffree may be -1; it's okay
  201. * to stuff that into 32 bits */
  202. if (kbuf->f_files != 0xffffffffffffffffULL
  203. && (kbuf->f_files & 0xffffffff00000000ULL))
  204. return -EOVERFLOW;
  205. if (kbuf->f_ffree != 0xffffffffffffffffULL
  206. && (kbuf->f_ffree & 0xffffffff00000000ULL))
  207. return -EOVERFLOW;
  208. }
  209. if (!access_ok(VERIFY_WRITE, ubuf, sizeof(*ubuf)) ||
  210. __put_user(kbuf->f_type, &ubuf->f_type) ||
  211. __put_user(kbuf->f_bsize, &ubuf->f_bsize) ||
  212. __put_user(kbuf->f_blocks, &ubuf->f_blocks) ||
  213. __put_user(kbuf->f_bfree, &ubuf->f_bfree) ||
  214. __put_user(kbuf->f_bavail, &ubuf->f_bavail) ||
  215. __put_user(kbuf->f_files, &ubuf->f_files) ||
  216. __put_user(kbuf->f_ffree, &ubuf->f_ffree) ||
  217. __put_user(kbuf->f_namelen, &ubuf->f_namelen) ||
  218. __put_user(kbuf->f_fsid.val[0], &ubuf->f_fsid.val[0]) ||
  219. __put_user(kbuf->f_fsid.val[1], &ubuf->f_fsid.val[1]) ||
  220. __put_user(kbuf->f_frsize, &ubuf->f_frsize) ||
  221. __put_user(kbuf->f_flags, &ubuf->f_flags) ||
  222. __clear_user(ubuf->f_spare, sizeof(ubuf->f_spare)))
  223. return -EFAULT;
  224. return 0;
  225. }
  226. /*
  227. * The following statfs calls are copies of code from fs/statfs.c and
  228. * should be checked against those from time to time
  229. */
  230. asmlinkage long compat_sys_statfs(const char __user *pathname, struct compat_statfs __user *buf)
  231. {
  232. struct kstatfs tmp;
  233. int error = user_statfs(pathname, &tmp);
  234. if (!error)
  235. error = put_compat_statfs(buf, &tmp);
  236. return error;
  237. }
  238. asmlinkage long compat_sys_fstatfs(unsigned int fd, struct compat_statfs __user *buf)
  239. {
  240. struct kstatfs tmp;
  241. int error = fd_statfs(fd, &tmp);
  242. if (!error)
  243. error = put_compat_statfs(buf, &tmp);
  244. return error;
  245. }
  246. static int put_compat_statfs64(struct compat_statfs64 __user *ubuf, struct kstatfs *kbuf)
  247. {
  248. if (sizeof ubuf->f_blocks == 4) {
  249. if ((kbuf->f_blocks | kbuf->f_bfree | kbuf->f_bavail |
  250. kbuf->f_bsize | kbuf->f_frsize) & 0xffffffff00000000ULL)
  251. return -EOVERFLOW;
  252. /* f_files and f_ffree may be -1; it's okay
  253. * to stuff that into 32 bits */
  254. if (kbuf->f_files != 0xffffffffffffffffULL
  255. && (kbuf->f_files & 0xffffffff00000000ULL))
  256. return -EOVERFLOW;
  257. if (kbuf->f_ffree != 0xffffffffffffffffULL
  258. && (kbuf->f_ffree & 0xffffffff00000000ULL))
  259. return -EOVERFLOW;
  260. }
  261. if (!access_ok(VERIFY_WRITE, ubuf, sizeof(*ubuf)) ||
  262. __put_user(kbuf->f_type, &ubuf->f_type) ||
  263. __put_user(kbuf->f_bsize, &ubuf->f_bsize) ||
  264. __put_user(kbuf->f_blocks, &ubuf->f_blocks) ||
  265. __put_user(kbuf->f_bfree, &ubuf->f_bfree) ||
  266. __put_user(kbuf->f_bavail, &ubuf->f_bavail) ||
  267. __put_user(kbuf->f_files, &ubuf->f_files) ||
  268. __put_user(kbuf->f_ffree, &ubuf->f_ffree) ||
  269. __put_user(kbuf->f_namelen, &ubuf->f_namelen) ||
  270. __put_user(kbuf->f_fsid.val[0], &ubuf->f_fsid.val[0]) ||
  271. __put_user(kbuf->f_fsid.val[1], &ubuf->f_fsid.val[1]) ||
  272. __put_user(kbuf->f_frsize, &ubuf->f_frsize) ||
  273. __put_user(kbuf->f_flags, &ubuf->f_flags) ||
  274. __clear_user(ubuf->f_spare, sizeof(ubuf->f_spare)))
  275. return -EFAULT;
  276. return 0;
  277. }
  278. asmlinkage long compat_sys_statfs64(const char __user *pathname, compat_size_t sz, struct compat_statfs64 __user *buf)
  279. {
  280. struct kstatfs tmp;
  281. int error;
  282. if (sz != sizeof(*buf))
  283. return -EINVAL;
  284. error = user_statfs(pathname, &tmp);
  285. if (!error)
  286. error = put_compat_statfs64(buf, &tmp);
  287. return error;
  288. }
  289. asmlinkage long compat_sys_fstatfs64(unsigned int fd, compat_size_t sz, struct compat_statfs64 __user *buf)
  290. {
  291. struct kstatfs tmp;
  292. int error;
  293. if (sz != sizeof(*buf))
  294. return -EINVAL;
  295. error = fd_statfs(fd, &tmp);
  296. if (!error)
  297. error = put_compat_statfs64(buf, &tmp);
  298. return error;
  299. }
  300. /*
  301. * This is a copy of sys_ustat, just dealing with a structure layout.
  302. * Given how simple this syscall is that apporach is more maintainable
  303. * than the various conversion hacks.
  304. */
  305. asmlinkage long compat_sys_ustat(unsigned dev, struct compat_ustat __user *u)
  306. {
  307. struct super_block *sb;
  308. struct compat_ustat tmp;
  309. struct kstatfs sbuf;
  310. int err;
  311. sb = user_get_super(new_decode_dev(dev));
  312. if (!sb)
  313. return -EINVAL;
  314. err = statfs_by_dentry(sb->s_root, &sbuf);
  315. drop_super(sb);
  316. if (err)
  317. return err;
  318. memset(&tmp, 0, sizeof(struct compat_ustat));
  319. tmp.f_tfree = sbuf.f_bfree;
  320. tmp.f_tinode = sbuf.f_ffree;
  321. if (copy_to_user(u, &tmp, sizeof(struct compat_ustat)))
  322. return -EFAULT;
  323. return 0;
  324. }
  325. static int get_compat_flock(struct flock *kfl, struct compat_flock __user *ufl)
  326. {
  327. if (!access_ok(VERIFY_READ, ufl, sizeof(*ufl)) ||
  328. __get_user(kfl->l_type, &ufl->l_type) ||
  329. __get_user(kfl->l_whence, &ufl->l_whence) ||
  330. __get_user(kfl->l_start, &ufl->l_start) ||
  331. __get_user(kfl->l_len, &ufl->l_len) ||
  332. __get_user(kfl->l_pid, &ufl->l_pid))
  333. return -EFAULT;
  334. return 0;
  335. }
  336. static int put_compat_flock(struct flock *kfl, struct compat_flock __user *ufl)
  337. {
  338. if (!access_ok(VERIFY_WRITE, ufl, sizeof(*ufl)) ||
  339. __put_user(kfl->l_type, &ufl->l_type) ||
  340. __put_user(kfl->l_whence, &ufl->l_whence) ||
  341. __put_user(kfl->l_start, &ufl->l_start) ||
  342. __put_user(kfl->l_len, &ufl->l_len) ||
  343. __put_user(kfl->l_pid, &ufl->l_pid))
  344. return -EFAULT;
  345. return 0;
  346. }
  347. #ifndef HAVE_ARCH_GET_COMPAT_FLOCK64
  348. static int get_compat_flock64(struct flock *kfl, struct compat_flock64 __user *ufl)
  349. {
  350. if (!access_ok(VERIFY_READ, ufl, sizeof(*ufl)) ||
  351. __get_user(kfl->l_type, &ufl->l_type) ||
  352. __get_user(kfl->l_whence, &ufl->l_whence) ||
  353. __get_user(kfl->l_start, &ufl->l_start) ||
  354. __get_user(kfl->l_len, &ufl->l_len) ||
  355. __get_user(kfl->l_pid, &ufl->l_pid))
  356. return -EFAULT;
  357. return 0;
  358. }
  359. #endif
  360. #ifndef HAVE_ARCH_PUT_COMPAT_FLOCK64
  361. static int put_compat_flock64(struct flock *kfl, struct compat_flock64 __user *ufl)
  362. {
  363. if (!access_ok(VERIFY_WRITE, ufl, sizeof(*ufl)) ||
  364. __put_user(kfl->l_type, &ufl->l_type) ||
  365. __put_user(kfl->l_whence, &ufl->l_whence) ||
  366. __put_user(kfl->l_start, &ufl->l_start) ||
  367. __put_user(kfl->l_len, &ufl->l_len) ||
  368. __put_user(kfl->l_pid, &ufl->l_pid))
  369. return -EFAULT;
  370. return 0;
  371. }
  372. #endif
  373. asmlinkage long compat_sys_fcntl64(unsigned int fd, unsigned int cmd,
  374. unsigned long arg)
  375. {
  376. mm_segment_t old_fs;
  377. struct flock f;
  378. long ret;
  379. switch (cmd) {
  380. case F_GETLK:
  381. case F_SETLK:
  382. case F_SETLKW:
  383. ret = get_compat_flock(&f, compat_ptr(arg));
  384. if (ret != 0)
  385. break;
  386. old_fs = get_fs();
  387. set_fs(KERNEL_DS);
  388. ret = sys_fcntl(fd, cmd, (unsigned long)&f);
  389. set_fs(old_fs);
  390. if (cmd == F_GETLK && ret == 0) {
  391. /* GETLK was successful and we need to return the data...
  392. * but it needs to fit in the compat structure.
  393. * l_start shouldn't be too big, unless the original
  394. * start + end is greater than COMPAT_OFF_T_MAX, in which
  395. * case the app was asking for trouble, so we return
  396. * -EOVERFLOW in that case.
  397. * l_len could be too big, in which case we just truncate it,
  398. * and only allow the app to see that part of the conflicting
  399. * lock that might make sense to it anyway
  400. */
  401. if (f.l_start > COMPAT_OFF_T_MAX)
  402. ret = -EOVERFLOW;
  403. if (f.l_len > COMPAT_OFF_T_MAX)
  404. f.l_len = COMPAT_OFF_T_MAX;
  405. if (ret == 0)
  406. ret = put_compat_flock(&f, compat_ptr(arg));
  407. }
  408. break;
  409. case F_GETLK64:
  410. case F_SETLK64:
  411. case F_SETLKW64:
  412. ret = get_compat_flock64(&f, compat_ptr(arg));
  413. if (ret != 0)
  414. break;
  415. old_fs = get_fs();
  416. set_fs(KERNEL_DS);
  417. ret = sys_fcntl(fd, (cmd == F_GETLK64) ? F_GETLK :
  418. ((cmd == F_SETLK64) ? F_SETLK : F_SETLKW),
  419. (unsigned long)&f);
  420. set_fs(old_fs);
  421. if (cmd == F_GETLK64 && ret == 0) {
  422. /* need to return lock information - see above for commentary */
  423. if (f.l_start > COMPAT_LOFF_T_MAX)
  424. ret = -EOVERFLOW;
  425. if (f.l_len > COMPAT_LOFF_T_MAX)
  426. f.l_len = COMPAT_LOFF_T_MAX;
  427. if (ret == 0)
  428. ret = put_compat_flock64(&f, compat_ptr(arg));
  429. }
  430. break;
  431. default:
  432. ret = sys_fcntl(fd, cmd, arg);
  433. break;
  434. }
  435. return ret;
  436. }
  437. asmlinkage long compat_sys_fcntl(unsigned int fd, unsigned int cmd,
  438. unsigned long arg)
  439. {
  440. if ((cmd == F_GETLK64) || (cmd == F_SETLK64) || (cmd == F_SETLKW64))
  441. return -EINVAL;
  442. return compat_sys_fcntl64(fd, cmd, arg);
  443. }
  444. asmlinkage long
  445. compat_sys_io_setup(unsigned nr_reqs, u32 __user *ctx32p)
  446. {
  447. long ret;
  448. aio_context_t ctx64;
  449. mm_segment_t oldfs = get_fs();
  450. if (unlikely(get_user(ctx64, ctx32p)))
  451. return -EFAULT;
  452. set_fs(KERNEL_DS);
  453. /* The __user pointer cast is valid because of the set_fs() */
  454. ret = sys_io_setup(nr_reqs, (aio_context_t __user *) &ctx64);
  455. set_fs(oldfs);
  456. /* truncating is ok because it's a user address */
  457. if (!ret)
  458. ret = put_user((u32) ctx64, ctx32p);
  459. return ret;
  460. }
  461. asmlinkage long
  462. compat_sys_io_getevents(aio_context_t ctx_id,
  463. unsigned long min_nr,
  464. unsigned long nr,
  465. struct io_event __user *events,
  466. struct compat_timespec __user *timeout)
  467. {
  468. long ret;
  469. struct timespec t;
  470. struct timespec __user *ut = NULL;
  471. ret = -EFAULT;
  472. if (unlikely(!access_ok(VERIFY_WRITE, events,
  473. nr * sizeof(struct io_event))))
  474. goto out;
  475. if (timeout) {
  476. if (get_compat_timespec(&t, timeout))
  477. goto out;
  478. ut = compat_alloc_user_space(sizeof(*ut));
  479. if (copy_to_user(ut, &t, sizeof(t)) )
  480. goto out;
  481. }
  482. ret = sys_io_getevents(ctx_id, min_nr, nr, events, ut);
  483. out:
  484. return ret;
  485. }
  486. /* A write operation does a read from user space and vice versa */
  487. #define vrfy_dir(type) ((type) == READ ? VERIFY_WRITE : VERIFY_READ)
  488. ssize_t compat_rw_copy_check_uvector(int type,
  489. const struct compat_iovec __user *uvector, unsigned long nr_segs,
  490. unsigned long fast_segs, struct iovec *fast_pointer,
  491. struct iovec **ret_pointer)
  492. {
  493. compat_ssize_t tot_len;
  494. struct iovec *iov = *ret_pointer = fast_pointer;
  495. ssize_t ret = 0;
  496. int seg;
  497. /*
  498. * SuS says "The readv() function *may* fail if the iovcnt argument
  499. * was less than or equal to 0, or greater than {IOV_MAX}. Linux has
  500. * traditionally returned zero for zero segments, so...
  501. */
  502. if (nr_segs == 0)
  503. goto out;
  504. ret = -EINVAL;
  505. if (nr_segs > UIO_MAXIOV || nr_segs < 0)
  506. goto out;
  507. if (nr_segs > fast_segs) {
  508. ret = -ENOMEM;
  509. iov = kmalloc(nr_segs*sizeof(struct iovec), GFP_KERNEL);
  510. if (iov == NULL)
  511. goto out;
  512. }
  513. *ret_pointer = iov;
  514. /*
  515. * Single unix specification:
  516. * We should -EINVAL if an element length is not >= 0 and fitting an
  517. * ssize_t.
  518. *
  519. * In Linux, the total length is limited to MAX_RW_COUNT, there is
  520. * no overflow possibility.
  521. */
  522. tot_len = 0;
  523. ret = -EINVAL;
  524. for (seg = 0; seg < nr_segs; seg++) {
  525. compat_uptr_t buf;
  526. compat_ssize_t len;
  527. if (__get_user(len, &uvector->iov_len) ||
  528. __get_user(buf, &uvector->iov_base)) {
  529. ret = -EFAULT;
  530. goto out;
  531. }
  532. if (len < 0) /* size_t not fitting in compat_ssize_t .. */
  533. goto out;
  534. if (!access_ok(vrfy_dir(type), compat_ptr(buf), len)) {
  535. ret = -EFAULT;
  536. goto out;
  537. }
  538. if (len > MAX_RW_COUNT - tot_len)
  539. len = MAX_RW_COUNT - tot_len;
  540. tot_len += len;
  541. iov->iov_base = compat_ptr(buf);
  542. iov->iov_len = (compat_size_t) len;
  543. uvector++;
  544. iov++;
  545. }
  546. ret = tot_len;
  547. out:
  548. return ret;
  549. }
  550. static inline long
  551. copy_iocb(long nr, u32 __user *ptr32, struct iocb __user * __user *ptr64)
  552. {
  553. compat_uptr_t uptr;
  554. int i;
  555. for (i = 0; i < nr; ++i) {
  556. if (get_user(uptr, ptr32 + i))
  557. return -EFAULT;
  558. if (put_user(compat_ptr(uptr), ptr64 + i))
  559. return -EFAULT;
  560. }
  561. return 0;
  562. }
  563. #define MAX_AIO_SUBMITS (PAGE_SIZE/sizeof(struct iocb *))
  564. asmlinkage long
  565. compat_sys_io_submit(aio_context_t ctx_id, int nr, u32 __user *iocb)
  566. {
  567. struct iocb __user * __user *iocb64;
  568. long ret;
  569. if (unlikely(nr < 0))
  570. return -EINVAL;
  571. if (nr > MAX_AIO_SUBMITS)
  572. nr = MAX_AIO_SUBMITS;
  573. iocb64 = compat_alloc_user_space(nr * sizeof(*iocb64));
  574. ret = copy_iocb(nr, iocb, iocb64);
  575. if (!ret)
  576. ret = do_io_submit(ctx_id, nr, iocb64, 1);
  577. return ret;
  578. }
  579. struct compat_ncp_mount_data {
  580. compat_int_t version;
  581. compat_uint_t ncp_fd;
  582. __compat_uid_t mounted_uid;
  583. compat_pid_t wdog_pid;
  584. unsigned char mounted_vol[NCP_VOLNAME_LEN + 1];
  585. compat_uint_t time_out;
  586. compat_uint_t retry_count;
  587. compat_uint_t flags;
  588. __compat_uid_t uid;
  589. __compat_gid_t gid;
  590. compat_mode_t file_mode;
  591. compat_mode_t dir_mode;
  592. };
  593. struct compat_ncp_mount_data_v4 {
  594. compat_int_t version;
  595. compat_ulong_t flags;
  596. compat_ulong_t mounted_uid;
  597. compat_long_t wdog_pid;
  598. compat_uint_t ncp_fd;
  599. compat_uint_t time_out;
  600. compat_uint_t retry_count;
  601. compat_ulong_t uid;
  602. compat_ulong_t gid;
  603. compat_ulong_t file_mode;
  604. compat_ulong_t dir_mode;
  605. };
  606. static void *do_ncp_super_data_conv(void *raw_data)
  607. {
  608. int version = *(unsigned int *)raw_data;
  609. if (version == 3) {
  610. struct compat_ncp_mount_data *c_n = raw_data;
  611. struct ncp_mount_data *n = raw_data;
  612. n->dir_mode = c_n->dir_mode;
  613. n->file_mode = c_n->file_mode;
  614. n->gid = c_n->gid;
  615. n->uid = c_n->uid;
  616. memmove (n->mounted_vol, c_n->mounted_vol, (sizeof (c_n->mounted_vol) + 3 * sizeof (unsigned int)));
  617. n->wdog_pid = c_n->wdog_pid;
  618. n->mounted_uid = c_n->mounted_uid;
  619. } else if (version == 4) {
  620. struct compat_ncp_mount_data_v4 *c_n = raw_data;
  621. struct ncp_mount_data_v4 *n = raw_data;
  622. n->dir_mode = c_n->dir_mode;
  623. n->file_mode = c_n->file_mode;
  624. n->gid = c_n->gid;
  625. n->uid = c_n->uid;
  626. n->retry_count = c_n->retry_count;
  627. n->time_out = c_n->time_out;
  628. n->ncp_fd = c_n->ncp_fd;
  629. n->wdog_pid = c_n->wdog_pid;
  630. n->mounted_uid = c_n->mounted_uid;
  631. n->flags = c_n->flags;
  632. } else if (version != 5) {
  633. return NULL;
  634. }
  635. return raw_data;
  636. }
  637. struct compat_nfs_string {
  638. compat_uint_t len;
  639. compat_uptr_t data;
  640. };
  641. static inline void compat_nfs_string(struct nfs_string *dst,
  642. struct compat_nfs_string *src)
  643. {
  644. dst->data = compat_ptr(src->data);
  645. dst->len = src->len;
  646. }
  647. struct compat_nfs4_mount_data_v1 {
  648. compat_int_t version;
  649. compat_int_t flags;
  650. compat_int_t rsize;
  651. compat_int_t wsize;
  652. compat_int_t timeo;
  653. compat_int_t retrans;
  654. compat_int_t acregmin;
  655. compat_int_t acregmax;
  656. compat_int_t acdirmin;
  657. compat_int_t acdirmax;
  658. struct compat_nfs_string client_addr;
  659. struct compat_nfs_string mnt_path;
  660. struct compat_nfs_string hostname;
  661. compat_uint_t host_addrlen;
  662. compat_uptr_t host_addr;
  663. compat_int_t proto;
  664. compat_int_t auth_flavourlen;
  665. compat_uptr_t auth_flavours;
  666. };
  667. static int do_nfs4_super_data_conv(void *raw_data)
  668. {
  669. int version = *(compat_uint_t *) raw_data;
  670. if (version == 1) {
  671. struct compat_nfs4_mount_data_v1 *raw = raw_data;
  672. struct nfs4_mount_data *real = raw_data;
  673. /* copy the fields backwards */
  674. real->auth_flavours = compat_ptr(raw->auth_flavours);
  675. real->auth_flavourlen = raw->auth_flavourlen;
  676. real->proto = raw->proto;
  677. real->host_addr = compat_ptr(raw->host_addr);
  678. real->host_addrlen = raw->host_addrlen;
  679. compat_nfs_string(&real->hostname, &raw->hostname);
  680. compat_nfs_string(&real->mnt_path, &raw->mnt_path);
  681. compat_nfs_string(&real->client_addr, &raw->client_addr);
  682. real->acdirmax = raw->acdirmax;
  683. real->acdirmin = raw->acdirmin;
  684. real->acregmax = raw->acregmax;
  685. real->acregmin = raw->acregmin;
  686. real->retrans = raw->retrans;
  687. real->timeo = raw->timeo;
  688. real->wsize = raw->wsize;
  689. real->rsize = raw->rsize;
  690. real->flags = raw->flags;
  691. real->version = raw->version;
  692. }
  693. return 0;
  694. }
  695. #define NCPFS_NAME "ncpfs"
  696. #define NFS4_NAME "nfs4"
  697. asmlinkage long compat_sys_mount(const char __user * dev_name,
  698. const char __user * dir_name,
  699. const char __user * type, unsigned long flags,
  700. const void __user * data)
  701. {
  702. char *kernel_type;
  703. unsigned long data_page;
  704. char *kernel_dev;
  705. char *dir_page;
  706. int retval;
  707. retval = copy_mount_string(type, &kernel_type);
  708. if (retval < 0)
  709. goto out;
  710. dir_page = getname(dir_name);
  711. retval = PTR_ERR(dir_page);
  712. if (IS_ERR(dir_page))
  713. goto out1;
  714. retval = copy_mount_string(dev_name, &kernel_dev);
  715. if (retval < 0)
  716. goto out2;
  717. retval = copy_mount_options(data, &data_page);
  718. if (retval < 0)
  719. goto out3;
  720. retval = -EINVAL;
  721. if (kernel_type && data_page) {
  722. if (!strcmp(kernel_type, NCPFS_NAME)) {
  723. do_ncp_super_data_conv((void *)data_page);
  724. } else if (!strcmp(kernel_type, NFS4_NAME)) {
  725. if (do_nfs4_super_data_conv((void *) data_page))
  726. goto out4;
  727. }
  728. }
  729. retval = do_mount(kernel_dev, dir_page, kernel_type,
  730. flags, (void*)data_page);
  731. out4:
  732. free_page(data_page);
  733. out3:
  734. kfree(kernel_dev);
  735. out2:
  736. putname(dir_page);
  737. out1:
  738. kfree(kernel_type);
  739. out:
  740. return retval;
  741. }
  742. struct compat_old_linux_dirent {
  743. compat_ulong_t d_ino;
  744. compat_ulong_t d_offset;
  745. unsigned short d_namlen;
  746. char d_name[1];
  747. };
  748. struct compat_readdir_callback {
  749. struct compat_old_linux_dirent __user *dirent;
  750. int result;
  751. };
  752. static int compat_fillonedir(void *__buf, const char *name, int namlen,
  753. loff_t offset, u64 ino, unsigned int d_type)
  754. {
  755. struct compat_readdir_callback *buf = __buf;
  756. struct compat_old_linux_dirent __user *dirent;
  757. compat_ulong_t d_ino;
  758. if (buf->result)
  759. return -EINVAL;
  760. d_ino = ino;
  761. if (sizeof(d_ino) < sizeof(ino) && d_ino != ino) {
  762. buf->result = -EOVERFLOW;
  763. return -EOVERFLOW;
  764. }
  765. buf->result++;
  766. dirent = buf->dirent;
  767. if (!access_ok(VERIFY_WRITE, dirent,
  768. (unsigned long)(dirent->d_name + namlen + 1) -
  769. (unsigned long)dirent))
  770. goto efault;
  771. if ( __put_user(d_ino, &dirent->d_ino) ||
  772. __put_user(offset, &dirent->d_offset) ||
  773. __put_user(namlen, &dirent->d_namlen) ||
  774. __copy_to_user(dirent->d_name, name, namlen) ||
  775. __put_user(0, dirent->d_name + namlen))
  776. goto efault;
  777. return 0;
  778. efault:
  779. buf->result = -EFAULT;
  780. return -EFAULT;
  781. }
  782. asmlinkage long compat_sys_old_readdir(unsigned int fd,
  783. struct compat_old_linux_dirent __user *dirent, unsigned int count)
  784. {
  785. int error;
  786. struct file *file;
  787. struct compat_readdir_callback buf;
  788. error = -EBADF;
  789. file = fget(fd);
  790. if (!file)
  791. goto out;
  792. buf.result = 0;
  793. buf.dirent = dirent;
  794. error = vfs_readdir(file, compat_fillonedir, &buf);
  795. if (buf.result)
  796. error = buf.result;
  797. fput(file);
  798. out:
  799. return error;
  800. }
  801. struct compat_linux_dirent {
  802. compat_ulong_t d_ino;
  803. compat_ulong_t d_off;
  804. unsigned short d_reclen;
  805. char d_name[1];
  806. };
  807. struct compat_getdents_callback {
  808. struct compat_linux_dirent __user *current_dir;
  809. struct compat_linux_dirent __user *previous;
  810. int count;
  811. int error;
  812. };
  813. static int compat_filldir(void *__buf, const char *name, int namlen,
  814. loff_t offset, u64 ino, unsigned int d_type)
  815. {
  816. struct compat_linux_dirent __user * dirent;
  817. struct compat_getdents_callback *buf = __buf;
  818. compat_ulong_t d_ino;
  819. int reclen = ALIGN(offsetof(struct compat_linux_dirent, d_name) +
  820. namlen + 2, sizeof(compat_long_t));
  821. buf->error = -EINVAL; /* only used if we fail.. */
  822. if (reclen > buf->count)
  823. return -EINVAL;
  824. d_ino = ino;
  825. if (sizeof(d_ino) < sizeof(ino) && d_ino != ino) {
  826. buf->error = -EOVERFLOW;
  827. return -EOVERFLOW;
  828. }
  829. dirent = buf->previous;
  830. if (dirent) {
  831. if (__put_user(offset, &dirent->d_off))
  832. goto efault;
  833. }
  834. dirent = buf->current_dir;
  835. if (__put_user(d_ino, &dirent->d_ino))
  836. goto efault;
  837. if (__put_user(reclen, &dirent->d_reclen))
  838. goto efault;
  839. if (copy_to_user(dirent->d_name, name, namlen))
  840. goto efault;
  841. if (__put_user(0, dirent->d_name + namlen))
  842. goto efault;
  843. if (__put_user(d_type, (char __user *) dirent + reclen - 1))
  844. goto efault;
  845. buf->previous = dirent;
  846. dirent = (void __user *)dirent + reclen;
  847. buf->current_dir = dirent;
  848. buf->count -= reclen;
  849. return 0;
  850. efault:
  851. buf->error = -EFAULT;
  852. return -EFAULT;
  853. }
  854. asmlinkage long compat_sys_getdents(unsigned int fd,
  855. struct compat_linux_dirent __user *dirent, unsigned int count)
  856. {
  857. struct file * file;
  858. struct compat_linux_dirent __user * lastdirent;
  859. struct compat_getdents_callback buf;
  860. int error;
  861. error = -EFAULT;
  862. if (!access_ok(VERIFY_WRITE, dirent, count))
  863. goto out;
  864. error = -EBADF;
  865. file = fget(fd);
  866. if (!file)
  867. goto out;
  868. buf.current_dir = dirent;
  869. buf.previous = NULL;
  870. buf.count = count;
  871. buf.error = 0;
  872. error = vfs_readdir(file, compat_filldir, &buf);
  873. if (error >= 0)
  874. error = buf.error;
  875. lastdirent = buf.previous;
  876. if (lastdirent) {
  877. if (put_user(file->f_pos, &lastdirent->d_off))
  878. error = -EFAULT;
  879. else
  880. error = count - buf.count;
  881. }
  882. fput(file);
  883. out:
  884. return error;
  885. }
  886. #ifndef __ARCH_OMIT_COMPAT_SYS_GETDENTS64
  887. struct compat_getdents_callback64 {
  888. struct linux_dirent64 __user *current_dir;
  889. struct linux_dirent64 __user *previous;
  890. int count;
  891. int error;
  892. };
  893. static int compat_filldir64(void * __buf, const char * name, int namlen, loff_t offset,
  894. u64 ino, unsigned int d_type)
  895. {
  896. struct linux_dirent64 __user *dirent;
  897. struct compat_getdents_callback64 *buf = __buf;
  898. int reclen = ALIGN(offsetof(struct linux_dirent64, d_name) + namlen + 1,
  899. sizeof(u64));
  900. u64 off;
  901. buf->error = -EINVAL; /* only used if we fail.. */
  902. if (reclen > buf->count)
  903. return -EINVAL;
  904. dirent = buf->previous;
  905. if (dirent) {
  906. if (__put_user_unaligned(offset, &dirent->d_off))
  907. goto efault;
  908. }
  909. dirent = buf->current_dir;
  910. if (__put_user_unaligned(ino, &dirent->d_ino))
  911. goto efault;
  912. off = 0;
  913. if (__put_user_unaligned(off, &dirent->d_off))
  914. goto efault;
  915. if (__put_user(reclen, &dirent->d_reclen))
  916. goto efault;
  917. if (__put_user(d_type, &dirent->d_type))
  918. goto efault;
  919. if (copy_to_user(dirent->d_name, name, namlen))
  920. goto efault;
  921. if (__put_user(0, dirent->d_name + namlen))
  922. goto efault;
  923. buf->previous = dirent;
  924. dirent = (void __user *)dirent + reclen;
  925. buf->current_dir = dirent;
  926. buf->count -= reclen;
  927. return 0;
  928. efault:
  929. buf->error = -EFAULT;
  930. return -EFAULT;
  931. }
  932. asmlinkage long compat_sys_getdents64(unsigned int fd,
  933. struct linux_dirent64 __user * dirent, unsigned int count)
  934. {
  935. struct file * file;
  936. struct linux_dirent64 __user * lastdirent;
  937. struct compat_getdents_callback64 buf;
  938. int error;
  939. error = -EFAULT;
  940. if (!access_ok(VERIFY_WRITE, dirent, count))
  941. goto out;
  942. error = -EBADF;
  943. file = fget(fd);
  944. if (!file)
  945. goto out;
  946. buf.current_dir = dirent;
  947. buf.previous = NULL;
  948. buf.count = count;
  949. buf.error = 0;
  950. error = vfs_readdir(file, compat_filldir64, &buf);
  951. if (error >= 0)
  952. error = buf.error;
  953. lastdirent = buf.previous;
  954. if (lastdirent) {
  955. typeof(lastdirent->d_off) d_off = file->f_pos;
  956. if (__put_user_unaligned(d_off, &lastdirent->d_off))
  957. error = -EFAULT;
  958. else
  959. error = count - buf.count;
  960. }
  961. fput(file);
  962. out:
  963. return error;
  964. }
  965. #endif /* ! __ARCH_OMIT_COMPAT_SYS_GETDENTS64 */
  966. static ssize_t compat_do_readv_writev(int type, struct file *file,
  967. const struct compat_iovec __user *uvector,
  968. unsigned long nr_segs, loff_t *pos)
  969. {
  970. compat_ssize_t tot_len;
  971. struct iovec iovstack[UIO_FASTIOV];
  972. struct iovec *iov = iovstack;
  973. ssize_t ret;
  974. io_fn_t fn;
  975. iov_fn_t fnv;
  976. ret = -EINVAL;
  977. if (!file->f_op)
  978. goto out;
  979. ret = -EFAULT;
  980. if (!access_ok(VERIFY_READ, uvector, nr_segs*sizeof(*uvector)))
  981. goto out;
  982. tot_len = compat_rw_copy_check_uvector(type, uvector, nr_segs,
  983. UIO_FASTIOV, iovstack, &iov);
  984. if (tot_len == 0) {
  985. ret = 0;
  986. goto out;
  987. }
  988. ret = rw_verify_area(type, file, pos, tot_len);
  989. if (ret < 0)
  990. goto out;
  991. fnv = NULL;
  992. if (type == READ) {
  993. fn = file->f_op->read;
  994. fnv = file->f_op->aio_read;
  995. } else {
  996. fn = (io_fn_t)file->f_op->write;
  997. fnv = file->f_op->aio_write;
  998. }
  999. if (fnv)
  1000. ret = do_sync_readv_writev(file, iov, nr_segs, tot_len,
  1001. pos, fnv);
  1002. else
  1003. ret = do_loop_readv_writev(file, iov, nr_segs, pos, fn);
  1004. out:
  1005. if (iov != iovstack)
  1006. kfree(iov);
  1007. if ((ret + (type == READ)) > 0) {
  1008. if (type == READ)
  1009. fsnotify_access(file);
  1010. else
  1011. fsnotify_modify(file);
  1012. }
  1013. return ret;
  1014. }
  1015. static size_t compat_readv(struct file *file,
  1016. const struct compat_iovec __user *vec,
  1017. unsigned long vlen, loff_t *pos)
  1018. {
  1019. ssize_t ret = -EBADF;
  1020. if (!(file->f_mode & FMODE_READ))
  1021. goto out;
  1022. ret = -EINVAL;
  1023. if (!file->f_op || (!file->f_op->aio_read && !file->f_op->read))
  1024. goto out;
  1025. ret = compat_do_readv_writev(READ, file, vec, vlen, pos);
  1026. out:
  1027. if (ret > 0)
  1028. add_rchar(current, ret);
  1029. inc_syscr(current);
  1030. return ret;
  1031. }
  1032. asmlinkage ssize_t
  1033. compat_sys_readv(unsigned long fd, const struct compat_iovec __user *vec,
  1034. unsigned long vlen)
  1035. {
  1036. struct file *file;
  1037. int fput_needed;
  1038. ssize_t ret;
  1039. file = fget_light(fd, &fput_needed);
  1040. if (!file)
  1041. return -EBADF;
  1042. ret = compat_readv(file, vec, vlen, &file->f_pos);
  1043. fput_light(file, fput_needed);
  1044. return ret;
  1045. }
  1046. asmlinkage ssize_t
  1047. compat_sys_preadv(unsigned long fd, const struct compat_iovec __user *vec,
  1048. unsigned long vlen, u32 pos_low, u32 pos_high)
  1049. {
  1050. loff_t pos = ((loff_t)pos_high << 32) | pos_low;
  1051. struct file *file;
  1052. int fput_needed;
  1053. ssize_t ret;
  1054. if (pos < 0)
  1055. return -EINVAL;
  1056. file = fget_light(fd, &fput_needed);
  1057. if (!file)
  1058. return -EBADF;
  1059. ret = -ESPIPE;
  1060. if (file->f_mode & FMODE_PREAD)
  1061. ret = compat_readv(file, vec, vlen, &pos);
  1062. fput_light(file, fput_needed);
  1063. return ret;
  1064. }
  1065. static size_t compat_writev(struct file *file,
  1066. const struct compat_iovec __user *vec,
  1067. unsigned long vlen, loff_t *pos)
  1068. {
  1069. ssize_t ret = -EBADF;
  1070. if (!(file->f_mode & FMODE_WRITE))
  1071. goto out;
  1072. ret = -EINVAL;
  1073. if (!file->f_op || (!file->f_op->aio_write && !file->f_op->write))
  1074. goto out;
  1075. ret = compat_do_readv_writev(WRITE, file, vec, vlen, pos);
  1076. out:
  1077. if (ret > 0)
  1078. add_wchar(current, ret);
  1079. inc_syscw(current);
  1080. return ret;
  1081. }
  1082. asmlinkage ssize_t
  1083. compat_sys_writev(unsigned long fd, const struct compat_iovec __user *vec,
  1084. unsigned long vlen)
  1085. {
  1086. struct file *file;
  1087. int fput_needed;
  1088. ssize_t ret;
  1089. file = fget_light(fd, &fput_needed);
  1090. if (!file)
  1091. return -EBADF;
  1092. ret = compat_writev(file, vec, vlen, &file->f_pos);
  1093. fput_light(file, fput_needed);
  1094. return ret;
  1095. }
  1096. asmlinkage ssize_t
  1097. compat_sys_pwritev(unsigned long fd, const struct compat_iovec __user *vec,
  1098. unsigned long vlen, u32 pos_low, u32 pos_high)
  1099. {
  1100. loff_t pos = ((loff_t)pos_high << 32) | pos_low;
  1101. struct file *file;
  1102. int fput_needed;
  1103. ssize_t ret;
  1104. if (pos < 0)
  1105. return -EINVAL;
  1106. file = fget_light(fd, &fput_needed);
  1107. if (!file)
  1108. return -EBADF;
  1109. ret = -ESPIPE;
  1110. if (file->f_mode & FMODE_PWRITE)
  1111. ret = compat_writev(file, vec, vlen, &pos);
  1112. fput_light(file, fput_needed);
  1113. return ret;
  1114. }
  1115. asmlinkage long
  1116. compat_sys_vmsplice(int fd, const struct compat_iovec __user *iov32,
  1117. unsigned int nr_segs, unsigned int flags)
  1118. {
  1119. unsigned i;
  1120. struct iovec __user *iov;
  1121. if (nr_segs > UIO_MAXIOV)
  1122. return -EINVAL;
  1123. iov = compat_alloc_user_space(nr_segs * sizeof(struct iovec));
  1124. for (i = 0; i < nr_segs; i++) {
  1125. struct compat_iovec v;
  1126. if (get_user(v.iov_base, &iov32[i].iov_base) ||
  1127. get_user(v.iov_len, &iov32[i].iov_len) ||
  1128. put_user(compat_ptr(v.iov_base), &iov[i].iov_base) ||
  1129. put_user(v.iov_len, &iov[i].iov_len))
  1130. return -EFAULT;
  1131. }
  1132. return sys_vmsplice(fd, iov, nr_segs, flags);
  1133. }
  1134. /*
  1135. * Exactly like fs/open.c:sys_open(), except that it doesn't set the
  1136. * O_LARGEFILE flag.
  1137. */
  1138. asmlinkage long
  1139. compat_sys_open(const char __user *filename, int flags, int mode)
  1140. {
  1141. return do_sys_open(AT_FDCWD, filename, flags, mode);
  1142. }
  1143. /*
  1144. * Exactly like fs/open.c:sys_openat(), except that it doesn't set the
  1145. * O_LARGEFILE flag.
  1146. */
  1147. asmlinkage long
  1148. compat_sys_openat(unsigned int dfd, const char __user *filename, int flags, int mode)
  1149. {
  1150. return do_sys_open(dfd, filename, flags, mode);
  1151. }
  1152. #define __COMPAT_NFDBITS (8 * sizeof(compat_ulong_t))
  1153. static int poll_select_copy_remaining(struct timespec *end_time, void __user *p,
  1154. int timeval, int ret)
  1155. {
  1156. struct timespec ts;
  1157. if (!p)
  1158. return ret;
  1159. if (current->personality & STICKY_TIMEOUTS)
  1160. goto sticky;
  1161. /* No update for zero timeout */
  1162. if (!end_time->tv_sec && !end_time->tv_nsec)
  1163. return ret;
  1164. ktime_get_ts(&ts);
  1165. ts = timespec_sub(*end_time, ts);
  1166. if (ts.tv_sec < 0)
  1167. ts.tv_sec = ts.tv_nsec = 0;
  1168. if (timeval) {
  1169. struct compat_timeval rtv;
  1170. rtv.tv_sec = ts.tv_sec;
  1171. rtv.tv_usec = ts.tv_nsec / NSEC_PER_USEC;
  1172. if (!copy_to_user(p, &rtv, sizeof(rtv)))
  1173. return ret;
  1174. } else {
  1175. struct compat_timespec rts;
  1176. rts.tv_sec = ts.tv_sec;
  1177. rts.tv_nsec = ts.tv_nsec;
  1178. if (!copy_to_user(p, &rts, sizeof(rts)))
  1179. return ret;
  1180. }
  1181. /*
  1182. * If an application puts its timeval in read-only memory, we
  1183. * don't want the Linux-specific update to the timeval to
  1184. * cause a fault after the select has completed
  1185. * successfully. However, because we're not updating the
  1186. * timeval, we can't restart the system call.
  1187. */
  1188. sticky:
  1189. if (ret == -ERESTARTNOHAND)
  1190. ret = -EINTR;
  1191. return ret;
  1192. }
  1193. /*
  1194. * Ooo, nasty. We need here to frob 32-bit unsigned longs to
  1195. * 64-bit unsigned longs.
  1196. */
  1197. static
  1198. int compat_get_fd_set(unsigned long nr, compat_ulong_t __user *ufdset,
  1199. unsigned long *fdset)
  1200. {
  1201. nr = DIV_ROUND_UP(nr, __COMPAT_NFDBITS);
  1202. if (ufdset) {
  1203. unsigned long odd;
  1204. if (!access_ok(VERIFY_WRITE, ufdset, nr*sizeof(compat_ulong_t)))
  1205. return -EFAULT;
  1206. odd = nr & 1UL;
  1207. nr &= ~1UL;
  1208. while (nr) {
  1209. unsigned long h, l;
  1210. if (__get_user(l, ufdset) || __get_user(h, ufdset+1))
  1211. return -EFAULT;
  1212. ufdset += 2;
  1213. *fdset++ = h << 32 | l;
  1214. nr -= 2;
  1215. }
  1216. if (odd && __get_user(*fdset, ufdset))
  1217. return -EFAULT;
  1218. } else {
  1219. /* Tricky, must clear full unsigned long in the
  1220. * kernel fdset at the end, this makes sure that
  1221. * actually happens.
  1222. */
  1223. memset(fdset, 0, ((nr + 1) & ~1)*sizeof(compat_ulong_t));
  1224. }
  1225. return 0;
  1226. }
  1227. static
  1228. int compat_set_fd_set(unsigned long nr, compat_ulong_t __user *ufdset,
  1229. unsigned long *fdset)
  1230. {
  1231. unsigned long odd;
  1232. nr = DIV_ROUND_UP(nr, __COMPAT_NFDBITS);
  1233. if (!ufdset)
  1234. return 0;
  1235. odd = nr & 1UL;
  1236. nr &= ~1UL;
  1237. while (nr) {
  1238. unsigned long h, l;
  1239. l = *fdset++;
  1240. h = l >> 32;
  1241. if (__put_user(l, ufdset) || __put_user(h, ufdset+1))
  1242. return -EFAULT;
  1243. ufdset += 2;
  1244. nr -= 2;
  1245. }
  1246. if (odd && __put_user(*fdset, ufdset))
  1247. return -EFAULT;
  1248. return 0;
  1249. }
  1250. /*
  1251. * This is a virtual copy of sys_select from fs/select.c and probably
  1252. * should be compared to it from time to time
  1253. */
  1254. /*
  1255. * We can actually return ERESTARTSYS instead of EINTR, but I'd
  1256. * like to be certain this leads to no problems. So I return
  1257. * EINTR just for safety.
  1258. *
  1259. * Update: ERESTARTSYS breaks at least the xview clock binary, so
  1260. * I'm trying ERESTARTNOHAND which restart only when you want to.
  1261. */
  1262. int compat_core_sys_select(int n, compat_ulong_t __user *inp,
  1263. compat_ulong_t __user *outp, compat_ulong_t __user *exp,
  1264. struct timespec *end_time)
  1265. {
  1266. fd_set_bits fds;
  1267. void *bits;
  1268. int size, max_fds, ret = -EINVAL;
  1269. struct fdtable *fdt;
  1270. long stack_fds[SELECT_STACK_ALLOC/sizeof(long)];
  1271. if (n < 0)
  1272. goto out_nofds;
  1273. /* max_fds can increase, so grab it once to avoid race */
  1274. rcu_read_lock();
  1275. fdt = files_fdtable(current->files);
  1276. max_fds = fdt->max_fds;
  1277. rcu_read_unlock();
  1278. if (n > max_fds)
  1279. n = max_fds;
  1280. /*
  1281. * We need 6 bitmaps (in/out/ex for both incoming and outgoing),
  1282. * since we used fdset we need to allocate memory in units of
  1283. * long-words.
  1284. */
  1285. size = FDS_BYTES(n);
  1286. bits = stack_fds;
  1287. if (size > sizeof(stack_fds) / 6) {
  1288. bits = kmalloc(6 * size, GFP_KERNEL);
  1289. ret = -ENOMEM;
  1290. if (!bits)
  1291. goto out_nofds;
  1292. }
  1293. fds.in = (unsigned long *) bits;
  1294. fds.out = (unsigned long *) (bits + size);
  1295. fds.ex = (unsigned long *) (bits + 2*size);
  1296. fds.res_in = (unsigned long *) (bits + 3*size);
  1297. fds.res_out = (unsigned long *) (bits + 4*size);
  1298. fds.res_ex = (unsigned long *) (bits + 5*size);
  1299. if ((ret = compat_get_fd_set(n, inp, fds.in)) ||
  1300. (ret = compat_get_fd_set(n, outp, fds.out)) ||
  1301. (ret = compat_get_fd_set(n, exp, fds.ex)))
  1302. goto out;
  1303. zero_fd_set(n, fds.res_in);
  1304. zero_fd_set(n, fds.res_out);
  1305. zero_fd_set(n, fds.res_ex);
  1306. ret = do_select(n, &fds, end_time);
  1307. if (ret < 0)
  1308. goto out;
  1309. if (!ret) {
  1310. ret = -ERESTARTNOHAND;
  1311. if (signal_pending(current))
  1312. goto out;
  1313. ret = 0;
  1314. }
  1315. if (compat_set_fd_set(n, inp, fds.res_in) ||
  1316. compat_set_fd_set(n, outp, fds.res_out) ||
  1317. compat_set_fd_set(n, exp, fds.res_ex))
  1318. ret = -EFAULT;
  1319. out:
  1320. if (bits != stack_fds)
  1321. kfree(bits);
  1322. out_nofds:
  1323. return ret;
  1324. }
  1325. asmlinkage long compat_sys_select(int n, compat_ulong_t __user *inp,
  1326. compat_ulong_t __user *outp, compat_ulong_t __user *exp,
  1327. struct compat_timeval __user *tvp)
  1328. {
  1329. struct timespec end_time, *to = NULL;
  1330. struct compat_timeval tv;
  1331. int ret;
  1332. if (tvp) {
  1333. if (copy_from_user(&tv, tvp, sizeof(tv)))
  1334. return -EFAULT;
  1335. to = &end_time;
  1336. if (poll_select_set_timeout(to,
  1337. tv.tv_sec + (tv.tv_usec / USEC_PER_SEC),
  1338. (tv.tv_usec % USEC_PER_SEC) * NSEC_PER_USEC))
  1339. return -EINVAL;
  1340. }
  1341. ret = compat_core_sys_select(n, inp, outp, exp, to);
  1342. ret = poll_select_copy_remaining(&end_time, tvp, 1, ret);
  1343. return ret;
  1344. }
  1345. struct compat_sel_arg_struct {
  1346. compat_ulong_t n;
  1347. compat_uptr_t inp;
  1348. compat_uptr_t outp;
  1349. compat_uptr_t exp;
  1350. compat_uptr_t tvp;
  1351. };
  1352. asmlinkage long compat_sys_old_select(struct compat_sel_arg_struct __user *arg)
  1353. {
  1354. struct compat_sel_arg_struct a;
  1355. if (copy_from_user(&a, arg, sizeof(a)))
  1356. return -EFAULT;
  1357. return compat_sys_select(a.n, compat_ptr(a.inp), compat_ptr(a.outp),
  1358. compat_ptr(a.exp), compat_ptr(a.tvp));
  1359. }
  1360. #ifdef HAVE_SET_RESTORE_SIGMASK
  1361. static long do_compat_pselect(int n, compat_ulong_t __user *inp,
  1362. compat_ulong_t __user *outp, compat_ulong_t __user *exp,
  1363. struct compat_timespec __user *tsp, compat_sigset_t __user *sigmask,
  1364. compat_size_t sigsetsize)
  1365. {
  1366. compat_sigset_t ss32;
  1367. sigset_t ksigmask, sigsaved;
  1368. struct compat_timespec ts;
  1369. struct timespec end_time, *to = NULL;
  1370. int ret;
  1371. if (tsp) {
  1372. if (copy_from_user(&ts, tsp, sizeof(ts)))
  1373. return -EFAULT;
  1374. to = &end_time;
  1375. if (poll_select_set_timeout(to, ts.tv_sec, ts.tv_nsec))
  1376. return -EINVAL;
  1377. }
  1378. if (sigmask) {
  1379. if (sigsetsize != sizeof(compat_sigset_t))
  1380. return -EINVAL;
  1381. if (copy_from_user(&ss32, sigmask, sizeof(ss32)))
  1382. return -EFAULT;
  1383. sigset_from_compat(&ksigmask, &ss32);
  1384. sigdelsetmask(&ksigmask, sigmask(SIGKILL)|sigmask(SIGSTOP));
  1385. sigprocmask(SIG_SETMASK, &ksigmask, &sigsaved);
  1386. }
  1387. ret = compat_core_sys_select(n, inp, outp, exp, to);
  1388. ret = poll_select_copy_remaining(&end_time, tsp, 0, ret);
  1389. if (ret == -ERESTARTNOHAND) {
  1390. /*
  1391. * Don't restore the signal mask yet. Let do_signal() deliver
  1392. * the signal on the way back to userspace, before the signal
  1393. * mask is restored.
  1394. */
  1395. if (sigmask) {
  1396. memcpy(&current->saved_sigmask, &sigsaved,
  1397. sizeof(sigsaved));
  1398. set_restore_sigmask();
  1399. }
  1400. } else if (sigmask)
  1401. sigprocmask(SIG_SETMASK, &sigsaved, NULL);
  1402. return ret;
  1403. }
  1404. asmlinkage long compat_sys_pselect6(int n, compat_ulong_t __user *inp,
  1405. compat_ulong_t __user *outp, compat_ulong_t __user *exp,
  1406. struct compat_timespec __user *tsp, void __user *sig)
  1407. {
  1408. compat_size_t sigsetsize = 0;
  1409. compat_uptr_t up = 0;
  1410. if (sig) {
  1411. if (!access_ok(VERIFY_READ, sig,
  1412. sizeof(compat_uptr_t)+sizeof(compat_size_t)) ||
  1413. __get_user(up, (compat_uptr_t __user *)sig) ||
  1414. __get_user(sigsetsize,
  1415. (compat_size_t __user *)(sig+sizeof(up))))
  1416. return -EFAULT;
  1417. }
  1418. return do_compat_pselect(n, inp, outp, exp, tsp, compat_ptr(up),
  1419. sigsetsize);
  1420. }
  1421. asmlinkage long compat_sys_ppoll(struct pollfd __user *ufds,
  1422. unsigned int nfds, struct compat_timespec __user *tsp,
  1423. const compat_sigset_t __user *sigmask, compat_size_t sigsetsize)
  1424. {
  1425. compat_sigset_t ss32;
  1426. sigset_t ksigmask, sigsaved;
  1427. struct compat_timespec ts;
  1428. struct timespec end_time, *to = NULL;
  1429. int ret;
  1430. if (tsp) {
  1431. if (copy_from_user(&ts, tsp, sizeof(ts)))
  1432. return -EFAULT;
  1433. to = &end_time;
  1434. if (poll_select_set_timeout(to, ts.tv_sec, ts.tv_nsec))
  1435. return -EINVAL;
  1436. }
  1437. if (sigmask) {
  1438. if (sigsetsize != sizeof(compat_sigset_t))
  1439. return -EINVAL;
  1440. if (copy_from_user(&ss32, sigmask, sizeof(ss32)))
  1441. return -EFAULT;
  1442. sigset_from_compat(&ksigmask, &ss32);
  1443. sigdelsetmask(&ksigmask, sigmask(SIGKILL)|sigmask(SIGSTOP));
  1444. sigprocmask(SIG_SETMASK, &ksigmask, &sigsaved);
  1445. }
  1446. ret = do_sys_poll(ufds, nfds, to);
  1447. /* We can restart this syscall, usually */
  1448. if (ret == -EINTR) {
  1449. /*
  1450. * Don't restore the signal mask yet. Let do_signal() deliver
  1451. * the signal on the way back to userspace, before the signal
  1452. * mask is restored.
  1453. */
  1454. if (sigmask) {
  1455. memcpy(&current->saved_sigmask, &sigsaved,
  1456. sizeof(sigsaved));
  1457. set_restore_sigmask();
  1458. }
  1459. ret = -ERESTARTNOHAND;
  1460. } else if (sigmask)
  1461. sigprocmask(SIG_SETMASK, &sigsaved, NULL);
  1462. ret = poll_select_copy_remaining(&end_time, tsp, 0, ret);
  1463. return ret;
  1464. }
  1465. #endif /* HAVE_SET_RESTORE_SIGMASK */
  1466. #ifdef CONFIG_EPOLL
  1467. #ifdef HAVE_SET_RESTORE_SIGMASK
  1468. asmlinkage long compat_sys_epoll_pwait(int epfd,
  1469. struct compat_epoll_event __user *events,
  1470. int maxevents, int timeout,
  1471. const compat_sigset_t __user *sigmask,
  1472. compat_size_t sigsetsize)
  1473. {
  1474. long err;
  1475. compat_sigset_t csigmask;
  1476. sigset_t ksigmask, sigsaved;
  1477. /*
  1478. * If the caller wants a certain signal mask to be set during the wait,
  1479. * we apply it here.
  1480. */
  1481. if (sigmask) {
  1482. if (sigsetsize != sizeof(compat_sigset_t))
  1483. return -EINVAL;
  1484. if (copy_from_user(&csigmask, sigmask, sizeof(csigmask)))
  1485. return -EFAULT;
  1486. sigset_from_compat(&ksigmask, &csigmask);
  1487. sigdelsetmask(&ksigmask, sigmask(SIGKILL) | sigmask(SIGSTOP));
  1488. sigprocmask(SIG_SETMASK, &ksigmask, &sigsaved);
  1489. }
  1490. err = sys_epoll_wait(epfd, events, maxevents, timeout);
  1491. /*
  1492. * If we changed the signal mask, we need to restore the original one.
  1493. * In case we've got a signal while waiting, we do not restore the
  1494. * signal mask yet, and we allow do_signal() to deliver the signal on
  1495. * the way back to userspace, before the signal mask is restored.
  1496. */
  1497. if (sigmask) {
  1498. if (err == -EINTR) {
  1499. memcpy(&current->saved_sigmask, &sigsaved,
  1500. sizeof(sigsaved));
  1501. set_restore_sigmask();
  1502. } else
  1503. sigprocmask(SIG_SETMASK, &sigsaved, NULL);
  1504. }
  1505. return err;
  1506. }
  1507. #endif /* HAVE_SET_RESTORE_SIGMASK */
  1508. #endif /* CONFIG_EPOLL */
  1509. #ifdef CONFIG_SIGNALFD
  1510. asmlinkage long compat_sys_signalfd4(int ufd,
  1511. const compat_sigset_t __user *sigmask,
  1512. compat_size_t sigsetsize, int flags)
  1513. {
  1514. compat_sigset_t ss32;
  1515. sigset_t tmp;
  1516. sigset_t __user *ksigmask;
  1517. if (sigsetsize != sizeof(compat_sigset_t))
  1518. return -EINVAL;
  1519. if (copy_from_user(&ss32, sigmask, sizeof(ss32)))
  1520. return -EFAULT;
  1521. sigset_from_compat(&tmp, &ss32);
  1522. ksigmask = compat_alloc_user_space(sizeof(sigset_t));
  1523. if (copy_to_user(ksigmask, &tmp, sizeof(sigset_t)))
  1524. return -EFAULT;
  1525. return sys_signalfd4(ufd, ksigmask, sizeof(sigset_t), flags);
  1526. }
  1527. asmlinkage long compat_sys_signalfd(int ufd,
  1528. const compat_sigset_t __user *sigmask,
  1529. compat_size_t sigsetsize)
  1530. {
  1531. return compat_sys_signalfd4(ufd, sigmask, sigsetsize, 0);
  1532. }
  1533. #endif /* CONFIG_SIGNALFD */
  1534. #ifdef CONFIG_TIMERFD
  1535. asmlinkage long compat_sys_timerfd_settime(int ufd, int flags,
  1536. const struct compat_itimerspec __user *utmr,
  1537. struct compat_itimerspec __user *otmr)
  1538. {
  1539. int error;
  1540. struct itimerspec t;
  1541. struct itimerspec __user *ut;
  1542. if (get_compat_itimerspec(&t, utmr))
  1543. return -EFAULT;
  1544. ut = compat_alloc_user_space(2 * sizeof(struct itimerspec));
  1545. if (copy_to_user(&ut[0], &t, sizeof(t)))
  1546. return -EFAULT;
  1547. error = sys_timerfd_settime(ufd, flags, &ut[0], &ut[1]);
  1548. if (!error && otmr)
  1549. error = (copy_from_user(&t, &ut[1], sizeof(struct itimerspec)) ||
  1550. put_compat_itimerspec(otmr, &t)) ? -EFAULT: 0;
  1551. return error;
  1552. }
  1553. asmlinkage long compat_sys_timerfd_gettime(int ufd,
  1554. struct compat_itimerspec __user *otmr)
  1555. {
  1556. int error;
  1557. struct itimerspec t;
  1558. struct itimerspec __user *ut;
  1559. ut = compat_alloc_user_space(sizeof(struct itimerspec));
  1560. error = sys_timerfd_gettime(ufd, ut);
  1561. if (!error)
  1562. error = (copy_from_user(&t, ut, sizeof(struct itimerspec)) ||
  1563. put_compat_itimerspec(otmr, &t)) ? -EFAULT: 0;
  1564. return error;
  1565. }
  1566. #endif /* CONFIG_TIMERFD */
  1567. #ifdef CONFIG_FHANDLE
  1568. /*
  1569. * Exactly like fs/open.c:sys_open_by_handle_at(), except that it
  1570. * doesn't set the O_LARGEFILE flag.
  1571. */
  1572. asmlinkage long
  1573. compat_sys_open_by_handle_at(int mountdirfd,
  1574. struct file_handle __user *handle, int flags)
  1575. {
  1576. return do_handle_open(mountdirfd, handle, flags);
  1577. }
  1578. #endif