xfs_ioctl32.c 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441
  1. /*
  2. * Copyright (c) 2004-2005 Silicon Graphics, Inc.
  3. * All Rights Reserved.
  4. *
  5. * This program is free software; you can redistribute it and/or
  6. * modify it under the terms of the GNU General Public License as
  7. * published by the Free Software Foundation.
  8. *
  9. * This program is distributed in the hope that it would be useful,
  10. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  12. * GNU General Public License for more details.
  13. *
  14. * You should have received a copy of the GNU General Public License
  15. * along with this program; if not, write the Free Software Foundation,
  16. * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  17. */
  18. #include <linux/compat.h>
  19. #include <linux/init.h>
  20. #include <linux/ioctl.h>
  21. #include <linux/syscalls.h>
  22. #include <linux/types.h>
  23. #include <linux/fs.h>
  24. #include <asm/uaccess.h>
  25. #include "xfs.h"
  26. #include "xfs_fs.h"
  27. #include "xfs_bit.h"
  28. #include "xfs_log.h"
  29. #include "xfs_inum.h"
  30. #include "xfs_trans.h"
  31. #include "xfs_sb.h"
  32. #include "xfs_ag.h"
  33. #include "xfs_dir2.h"
  34. #include "xfs_dmapi.h"
  35. #include "xfs_mount.h"
  36. #include "xfs_bmap_btree.h"
  37. #include "xfs_attr_sf.h"
  38. #include "xfs_dir2_sf.h"
  39. #include "xfs_vnode.h"
  40. #include "xfs_dinode.h"
  41. #include "xfs_inode.h"
  42. #include "xfs_itable.h"
  43. #include "xfs_error.h"
  44. #include "xfs_dfrag.h"
  45. #include "xfs_vnodeops.h"
  46. #include "xfs_fsops.h"
  47. #include "xfs_ioctl.h"
  48. #include "xfs_ioctl32.h"
  49. #define _NATIVE_IOC(cmd, type) \
  50. _IOC(_IOC_DIR(cmd), _IOC_TYPE(cmd), _IOC_NR(cmd), sizeof(type))
  51. #ifdef BROKEN_X86_ALIGNMENT
  52. STATIC int
  53. xfs_compat_flock64_copyin(
  54. xfs_flock64_t *bf,
  55. compat_xfs_flock64_t __user *arg32)
  56. {
  57. if (get_user(bf->l_type, &arg32->l_type) ||
  58. get_user(bf->l_whence, &arg32->l_whence) ||
  59. get_user(bf->l_start, &arg32->l_start) ||
  60. get_user(bf->l_len, &arg32->l_len) ||
  61. get_user(bf->l_sysid, &arg32->l_sysid) ||
  62. get_user(bf->l_pid, &arg32->l_pid) ||
  63. copy_from_user(bf->l_pad, &arg32->l_pad, 4*sizeof(u32)))
  64. return -XFS_ERROR(EFAULT);
  65. return 0;
  66. }
  67. STATIC int
  68. xfs_compat_ioc_fsgeometry_v1(
  69. struct xfs_mount *mp,
  70. compat_xfs_fsop_geom_v1_t __user *arg32)
  71. {
  72. xfs_fsop_geom_t fsgeo;
  73. int error;
  74. error = xfs_fs_geometry(mp, &fsgeo, 3);
  75. if (error)
  76. return -error;
  77. /* The 32-bit variant simply has some padding at the end */
  78. if (copy_to_user(arg32, &fsgeo, sizeof(struct compat_xfs_fsop_geom_v1)))
  79. return -XFS_ERROR(EFAULT);
  80. return 0;
  81. }
  82. STATIC int
  83. xfs_inumbers_fmt_compat(
  84. void __user *ubuffer,
  85. const xfs_inogrp_t *buffer,
  86. long count,
  87. long *written)
  88. {
  89. compat_xfs_inogrp_t __user *p32 = ubuffer;
  90. long i;
  91. for (i = 0; i < count; i++) {
  92. if (put_user(buffer[i].xi_startino, &p32[i].xi_startino) ||
  93. put_user(buffer[i].xi_alloccount, &p32[i].xi_alloccount) ||
  94. put_user(buffer[i].xi_allocmask, &p32[i].xi_allocmask))
  95. return -XFS_ERROR(EFAULT);
  96. }
  97. *written = count * sizeof(*p32);
  98. return 0;
  99. }
  100. #else
  101. #define xfs_inumbers_fmt_compat xfs_inumbers_fmt
  102. #endif
  103. STATIC int
  104. xfs_ioctl32_bstime_copyin(
  105. xfs_bstime_t *bstime,
  106. compat_xfs_bstime_t __user *bstime32)
  107. {
  108. compat_time_t sec32; /* tv_sec differs on 64 vs. 32 */
  109. if (get_user(sec32, &bstime32->tv_sec) ||
  110. get_user(bstime->tv_nsec, &bstime32->tv_nsec))
  111. return -XFS_ERROR(EFAULT);
  112. bstime->tv_sec = sec32;
  113. return 0;
  114. }
  115. /* xfs_bstat_t has differing alignment on intel, & bstime_t sizes everywhere */
  116. STATIC int
  117. xfs_ioctl32_bstat_copyin(
  118. xfs_bstat_t *bstat,
  119. compat_xfs_bstat_t __user *bstat32)
  120. {
  121. if (get_user(bstat->bs_ino, &bstat32->bs_ino) ||
  122. get_user(bstat->bs_mode, &bstat32->bs_mode) ||
  123. get_user(bstat->bs_nlink, &bstat32->bs_nlink) ||
  124. get_user(bstat->bs_uid, &bstat32->bs_uid) ||
  125. get_user(bstat->bs_gid, &bstat32->bs_gid) ||
  126. get_user(bstat->bs_rdev, &bstat32->bs_rdev) ||
  127. get_user(bstat->bs_blksize, &bstat32->bs_blksize) ||
  128. get_user(bstat->bs_size, &bstat32->bs_size) ||
  129. xfs_ioctl32_bstime_copyin(&bstat->bs_atime, &bstat32->bs_atime) ||
  130. xfs_ioctl32_bstime_copyin(&bstat->bs_mtime, &bstat32->bs_mtime) ||
  131. xfs_ioctl32_bstime_copyin(&bstat->bs_ctime, &bstat32->bs_ctime) ||
  132. get_user(bstat->bs_blocks, &bstat32->bs_size) ||
  133. get_user(bstat->bs_xflags, &bstat32->bs_size) ||
  134. get_user(bstat->bs_extsize, &bstat32->bs_extsize) ||
  135. get_user(bstat->bs_extents, &bstat32->bs_extents) ||
  136. get_user(bstat->bs_gen, &bstat32->bs_gen) ||
  137. get_user(bstat->bs_projid, &bstat32->bs_projid) ||
  138. get_user(bstat->bs_dmevmask, &bstat32->bs_dmevmask) ||
  139. get_user(bstat->bs_dmstate, &bstat32->bs_dmstate) ||
  140. get_user(bstat->bs_aextents, &bstat32->bs_aextents))
  141. return -XFS_ERROR(EFAULT);
  142. return 0;
  143. }
  144. /* XFS_IOC_FSBULKSTAT and friends */
  145. STATIC int
  146. xfs_bstime_store_compat(
  147. compat_xfs_bstime_t __user *p32,
  148. const xfs_bstime_t *p)
  149. {
  150. __s32 sec32;
  151. sec32 = p->tv_sec;
  152. if (put_user(sec32, &p32->tv_sec) ||
  153. put_user(p->tv_nsec, &p32->tv_nsec))
  154. return -XFS_ERROR(EFAULT);
  155. return 0;
  156. }
  157. STATIC int
  158. xfs_bulkstat_one_fmt_compat(
  159. void __user *ubuffer,
  160. const xfs_bstat_t *buffer)
  161. {
  162. compat_xfs_bstat_t __user *p32 = ubuffer;
  163. if (put_user(buffer->bs_ino, &p32->bs_ino) ||
  164. put_user(buffer->bs_mode, &p32->bs_mode) ||
  165. put_user(buffer->bs_nlink, &p32->bs_nlink) ||
  166. put_user(buffer->bs_uid, &p32->bs_uid) ||
  167. put_user(buffer->bs_gid, &p32->bs_gid) ||
  168. put_user(buffer->bs_rdev, &p32->bs_rdev) ||
  169. put_user(buffer->bs_blksize, &p32->bs_blksize) ||
  170. put_user(buffer->bs_size, &p32->bs_size) ||
  171. xfs_bstime_store_compat(&p32->bs_atime, &buffer->bs_atime) ||
  172. xfs_bstime_store_compat(&p32->bs_mtime, &buffer->bs_mtime) ||
  173. xfs_bstime_store_compat(&p32->bs_ctime, &buffer->bs_ctime) ||
  174. put_user(buffer->bs_blocks, &p32->bs_blocks) ||
  175. put_user(buffer->bs_xflags, &p32->bs_xflags) ||
  176. put_user(buffer->bs_extsize, &p32->bs_extsize) ||
  177. put_user(buffer->bs_extents, &p32->bs_extents) ||
  178. put_user(buffer->bs_gen, &p32->bs_gen) ||
  179. put_user(buffer->bs_projid, &p32->bs_projid) ||
  180. put_user(buffer->bs_dmevmask, &p32->bs_dmevmask) ||
  181. put_user(buffer->bs_dmstate, &p32->bs_dmstate) ||
  182. put_user(buffer->bs_aextents, &p32->bs_aextents))
  183. return -XFS_ERROR(EFAULT);
  184. return sizeof(*p32);
  185. }
  186. /* copied from xfs_ioctl.c */
  187. STATIC int
  188. xfs_ioc_bulkstat_compat(
  189. xfs_mount_t *mp,
  190. unsigned int cmd,
  191. void __user *arg)
  192. {
  193. compat_xfs_fsop_bulkreq_t __user *p32 = (void __user *)arg;
  194. u32 addr;
  195. xfs_fsop_bulkreq_t bulkreq;
  196. int count; /* # of records returned */
  197. xfs_ino_t inlast; /* last inode number */
  198. int done;
  199. int error;
  200. /* done = 1 if there are more stats to get and if bulkstat */
  201. /* should be called again (unused here, but used in dmapi) */
  202. if (!capable(CAP_SYS_ADMIN))
  203. return -XFS_ERROR(EPERM);
  204. if (XFS_FORCED_SHUTDOWN(mp))
  205. return -XFS_ERROR(EIO);
  206. if (get_user(addr, &p32->lastip))
  207. return -XFS_ERROR(EFAULT);
  208. bulkreq.lastip = compat_ptr(addr);
  209. if (get_user(bulkreq.icount, &p32->icount) ||
  210. get_user(addr, &p32->ubuffer))
  211. return -XFS_ERROR(EFAULT);
  212. bulkreq.ubuffer = compat_ptr(addr);
  213. if (get_user(addr, &p32->ocount))
  214. return -XFS_ERROR(EFAULT);
  215. bulkreq.ocount = compat_ptr(addr);
  216. if (copy_from_user(&inlast, bulkreq.lastip, sizeof(__s64)))
  217. return -XFS_ERROR(EFAULT);
  218. if ((count = bulkreq.icount) <= 0)
  219. return -XFS_ERROR(EINVAL);
  220. if (bulkreq.ubuffer == NULL)
  221. return -XFS_ERROR(EINVAL);
  222. if (cmd == XFS_IOC_FSINUMBERS)
  223. error = xfs_inumbers(mp, &inlast, &count,
  224. bulkreq.ubuffer, xfs_inumbers_fmt_compat);
  225. else {
  226. /* declare a var to get a warning in case the type changes */
  227. bulkstat_one_fmt_pf formatter = xfs_bulkstat_one_fmt_compat;
  228. error = xfs_bulkstat(mp, &inlast, &count,
  229. xfs_bulkstat_one, formatter,
  230. sizeof(compat_xfs_bstat_t), bulkreq.ubuffer,
  231. BULKSTAT_FG_QUICK, &done);
  232. }
  233. if (error)
  234. return -error;
  235. if (bulkreq.ocount != NULL) {
  236. if (copy_to_user(bulkreq.lastip, &inlast,
  237. sizeof(xfs_ino_t)))
  238. return -XFS_ERROR(EFAULT);
  239. if (copy_to_user(bulkreq.ocount, &count, sizeof(count)))
  240. return -XFS_ERROR(EFAULT);
  241. }
  242. return 0;
  243. }
  244. STATIC int
  245. xfs_compat_handlereq_copyin(
  246. xfs_fsop_handlereq_t *hreq,
  247. compat_xfs_fsop_handlereq_t __user *arg32)
  248. {
  249. compat_xfs_fsop_handlereq_t hreq32;
  250. if (copy_from_user(&hreq32, arg32, sizeof(compat_xfs_fsop_handlereq_t)))
  251. return -XFS_ERROR(EFAULT);
  252. hreq->fd = hreq32.fd;
  253. hreq->path = compat_ptr(hreq32.path);
  254. hreq->oflags = hreq32.oflags;
  255. hreq->ihandle = compat_ptr(hreq32.ihandle);
  256. hreq->ihandlen = hreq32.ihandlen;
  257. hreq->ohandle = compat_ptr(hreq32.ohandle);
  258. hreq->ohandlen = compat_ptr(hreq32.ohandlen);
  259. return 0;
  260. }
  261. STATIC long
  262. xfs_compat_ioctl(
  263. xfs_inode_t *ip,
  264. struct file *filp,
  265. int ioflags,
  266. unsigned cmd,
  267. void __user *arg)
  268. {
  269. struct inode *inode = filp->f_path.dentry->d_inode;
  270. xfs_mount_t *mp = ip->i_mount;
  271. int error;
  272. xfs_itrace_entry(XFS_I(inode));
  273. switch (cmd) {
  274. case XFS_IOC_DIOINFO:
  275. case XFS_IOC_FSGEOMETRY:
  276. case XFS_IOC_FSGETXATTR:
  277. case XFS_IOC_FSSETXATTR:
  278. case XFS_IOC_FSGETXATTRA:
  279. case XFS_IOC_FSSETDM:
  280. case XFS_IOC_GETBMAP:
  281. case XFS_IOC_GETBMAPA:
  282. case XFS_IOC_GETBMAPX:
  283. /* not handled
  284. case XFS_IOC_FSSETDM_BY_HANDLE:
  285. case XFS_IOC_ATTRLIST_BY_HANDLE:
  286. case XFS_IOC_ATTRMULTI_BY_HANDLE:
  287. */
  288. case XFS_IOC_FSCOUNTS:
  289. case XFS_IOC_SET_RESBLKS:
  290. case XFS_IOC_GET_RESBLKS:
  291. case XFS_IOC_FSGROWFSDATA:
  292. case XFS_IOC_FSGROWFSLOG:
  293. case XFS_IOC_FSGROWFSRT:
  294. case XFS_IOC_FREEZE:
  295. case XFS_IOC_THAW:
  296. case XFS_IOC_GOINGDOWN:
  297. case XFS_IOC_ERROR_INJECTION:
  298. case XFS_IOC_ERROR_CLEARALL:
  299. break;
  300. case XFS_IOC_GETXFLAGS_32:
  301. case XFS_IOC_SETXFLAGS_32:
  302. case XFS_IOC_GETVERSION_32:
  303. cmd = _NATIVE_IOC(cmd, long);
  304. break;
  305. case XFS_IOC_SWAPEXT: {
  306. struct xfs_swapext sxp;
  307. struct compat_xfs_swapext __user *sxu = arg;
  308. /* Bulk copy in up to the sx_stat field, then grab bstat */
  309. if (copy_from_user(&sxp, sxu,
  310. offsetof(xfs_swapext_t, sx_stat)) ||
  311. xfs_ioctl32_bstat_copyin(&sxp.sx_stat, &sxu->sx_stat))
  312. return -XFS_ERROR(EFAULT);
  313. error = xfs_swapext(&sxp);
  314. return -error;
  315. }
  316. #ifdef BROKEN_X86_ALIGNMENT
  317. /* xfs_flock_t has wrong u32 vs u64 alignment */
  318. case XFS_IOC_ALLOCSP_32:
  319. case XFS_IOC_FREESP_32:
  320. case XFS_IOC_ALLOCSP64_32:
  321. case XFS_IOC_FREESP64_32:
  322. case XFS_IOC_RESVSP_32:
  323. case XFS_IOC_UNRESVSP_32:
  324. case XFS_IOC_RESVSP64_32:
  325. case XFS_IOC_UNRESVSP64_32: {
  326. struct xfs_flock64 bf;
  327. if (xfs_compat_flock64_copyin(&bf, arg))
  328. return -XFS_ERROR(EFAULT);
  329. cmd = _NATIVE_IOC(cmd, struct xfs_flock64);
  330. return xfs_ioc_space(ip, inode, filp, ioflags, cmd, &bf);
  331. }
  332. case XFS_IOC_FSGEOMETRY_V1_32:
  333. return xfs_compat_ioc_fsgeometry_v1(mp, arg);
  334. #else /* These are handled fine if no alignment issues */
  335. case XFS_IOC_ALLOCSP:
  336. case XFS_IOC_FREESP:
  337. case XFS_IOC_RESVSP:
  338. case XFS_IOC_UNRESVSP:
  339. case XFS_IOC_ALLOCSP64:
  340. case XFS_IOC_FREESP64:
  341. case XFS_IOC_RESVSP64:
  342. case XFS_IOC_UNRESVSP64:
  343. case XFS_IOC_FSGEOMETRY_V1:
  344. break;
  345. #endif
  346. case XFS_IOC_FSBULKSTAT_32:
  347. case XFS_IOC_FSBULKSTAT_SINGLE_32:
  348. case XFS_IOC_FSINUMBERS_32:
  349. cmd = _NATIVE_IOC(cmd, struct xfs_fsop_bulkreq);
  350. return xfs_ioc_bulkstat_compat(XFS_I(inode)->i_mount,
  351. cmd, (void __user*)arg);
  352. case XFS_IOC_FD_TO_HANDLE_32:
  353. case XFS_IOC_PATH_TO_HANDLE_32:
  354. case XFS_IOC_PATH_TO_FSHANDLE_32: {
  355. struct xfs_fsop_handlereq hreq;
  356. if (xfs_compat_handlereq_copyin(&hreq, arg))
  357. return -XFS_ERROR(EFAULT);
  358. cmd = _NATIVE_IOC(cmd, struct xfs_fsop_handlereq);
  359. return xfs_find_handle(cmd, &hreq);
  360. }
  361. case XFS_IOC_OPEN_BY_HANDLE_32: {
  362. struct xfs_fsop_handlereq hreq;
  363. if (xfs_compat_handlereq_copyin(&hreq, arg))
  364. return -XFS_ERROR(EFAULT);
  365. return xfs_open_by_handle(mp, &hreq, filp, inode);
  366. }
  367. case XFS_IOC_READLINK_BY_HANDLE_32: {
  368. struct xfs_fsop_handlereq hreq;
  369. if (xfs_compat_handlereq_copyin(&hreq, arg))
  370. return -XFS_ERROR(EFAULT);
  371. return xfs_readlink_by_handle(mp, &hreq, inode);
  372. }
  373. default:
  374. return -XFS_ERROR(ENOIOCTLCMD);
  375. }
  376. error = xfs_ioctl(ip, filp, ioflags, cmd, arg);
  377. return error;
  378. }
  379. long
  380. xfs_file_compat_ioctl(
  381. struct file *filp,
  382. unsigned int cmd,
  383. unsigned long p)
  384. {
  385. struct inode *inode = filp->f_path.dentry->d_inode;
  386. return xfs_compat_ioctl(XFS_I(inode), filp, 0, cmd, (void __user *)p);
  387. }
  388. long
  389. xfs_file_compat_invis_ioctl(
  390. struct file *filp,
  391. unsigned int cmd,
  392. unsigned long p)
  393. {
  394. struct inode *inode = filp->f_path.dentry->d_inode;
  395. return xfs_compat_ioctl(XFS_I(inode), filp, IO_INVIS, cmd,
  396. (void __user *)p);
  397. }