1 /*- 2 * Copyright (c) 2008 David E. O'Brien 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 3. Neither the name of the author nor the names of its contributors 14 * may be used to endorse or promote products derived from this software 15 * without specific prior written permission. 16 * 17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 20 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 27 * SUCH DAMAGE. 28 */ 29 30 #include <sys/cdefs.h> 31 __FBSDID("$FreeBSD$"); 32 33 #include "opt_compat.h" 34 35 #include <sys/param.h> 36 #include <sys/capsicum.h> 37 #include <sys/cdio.h> 38 #include <sys/fcntl.h> 39 #include <sys/filio.h> 40 #include <sys/file.h> 41 #include <sys/ioccom.h> 42 #include <sys/malloc.h> 43 #include <sys/mdioctl.h> 44 #include <sys/memrange.h> 45 #include <sys/pciio.h> 46 #include <sys/proc.h> 47 #include <sys/syscall.h> 48 #include <sys/syscallsubr.h> 49 #include <sys/sysctl.h> 50 #include <sys/sysent.h> 51 #include <sys/sysproto.h> 52 #include <sys/systm.h> 53 54 #include <compat/freebsd32/freebsd32.h> 55 #include <compat/freebsd32/freebsd32_ioctl.h> 56 #include <compat/freebsd32/freebsd32_proto.h> 57 58 /* Cannot get exact size in 64-bit due to alignment issue of entire struct. */ 59 CTASSERT((sizeof(struct md_ioctl32)+4) == 436); 60 CTASSERT(sizeof(struct ioc_read_toc_entry32) == 8); 61 CTASSERT(sizeof(struct ioc_toc_header32) == 4); 62 CTASSERT(sizeof(struct mem_range_op32) == 12); 63 CTASSERT(sizeof(struct pci_conf_io32) == 36); 64 CTASSERT(sizeof(struct pci_match_conf32) == 44); 65 CTASSERT(sizeof(struct pci_conf32) == 44); 66 67 68 static int 69 freebsd32_ioctl_md(struct thread *td, struct freebsd32_ioctl_args *uap, 70 struct file *fp) 71 { 72 struct md_ioctl mdv; 73 struct md_ioctl32 md32; 74 u_long com = 0; 75 int i, error; 76 77 if (uap->com & IOC_IN) { 78 if ((error = copyin(uap->data, &md32, sizeof(md32)))) { 79 return (error); 80 } 81 CP(md32, mdv, md_version); 82 CP(md32, mdv, md_unit); 83 CP(md32, mdv, md_type); 84 PTRIN_CP(md32, mdv, md_file); 85 CP(md32, mdv, md_mediasize); 86 CP(md32, mdv, md_sectorsize); 87 CP(md32, mdv, md_options); 88 CP(md32, mdv, md_base); 89 CP(md32, mdv, md_fwheads); 90 CP(md32, mdv, md_fwsectors); 91 } else if (uap->com & IOC_OUT) { 92 /* 93 * Zero the buffer so the user always 94 * gets back something deterministic. 95 */ 96 bzero(&mdv, sizeof mdv); 97 } 98 99 switch (uap->com) { 100 case MDIOCATTACH_32: 101 com = MDIOCATTACH; 102 break; 103 case MDIOCDETACH_32: 104 com = MDIOCDETACH; 105 break; 106 case MDIOCQUERY_32: 107 com = MDIOCQUERY; 108 break; 109 case MDIOCLIST_32: 110 com = MDIOCLIST; 111 break; 112 default: 113 panic("%s: unknown MDIOC %#x", __func__, uap->com); 114 } 115 error = fo_ioctl(fp, com, (caddr_t)&mdv, td->td_ucred, td); 116 if (error == 0 && (com & IOC_OUT)) { 117 CP(mdv, md32, md_version); 118 CP(mdv, md32, md_unit); 119 CP(mdv, md32, md_type); 120 PTROUT_CP(mdv, md32, md_file); 121 CP(mdv, md32, md_mediasize); 122 CP(mdv, md32, md_sectorsize); 123 CP(mdv, md32, md_options); 124 CP(mdv, md32, md_base); 125 CP(mdv, md32, md_fwheads); 126 CP(mdv, md32, md_fwsectors); 127 if (com == MDIOCLIST) { 128 /* 129 * Use MDNPAD, and not MDNPAD32. Padding is 130 * allocated and used by compat32 ABI. 131 */ 132 for (i = 0; i < MDNPAD; i++) 133 CP(mdv, md32, md_pad[i]); 134 } 135 error = copyout(&md32, uap->data, sizeof(md32)); 136 } 137 return error; 138 } 139 140 141 static int 142 freebsd32_ioctl_ioc_toc_header(struct thread *td, 143 struct freebsd32_ioctl_args *uap, struct file *fp) 144 { 145 struct ioc_toc_header toch; 146 struct ioc_toc_header32 toch32; 147 int error; 148 149 if ((error = copyin(uap->data, &toch32, sizeof(toch32)))) 150 return (error); 151 CP(toch32, toch, len); 152 CP(toch32, toch, starting_track); 153 CP(toch32, toch, ending_track); 154 error = fo_ioctl(fp, CDIOREADTOCHEADER, (caddr_t)&toch, 155 td->td_ucred, td); 156 return (error); 157 } 158 159 160 static int 161 freebsd32_ioctl_ioc_read_toc(struct thread *td, 162 struct freebsd32_ioctl_args *uap, struct file *fp) 163 { 164 struct ioc_read_toc_entry toce; 165 struct ioc_read_toc_entry32 toce32; 166 int error; 167 168 if ((error = copyin(uap->data, &toce32, sizeof(toce32)))) 169 return (error); 170 CP(toce32, toce, address_format); 171 CP(toce32, toce, starting_track); 172 CP(toce32, toce, data_len); 173 PTRIN_CP(toce32, toce, data); 174 175 if ((error = fo_ioctl(fp, CDIOREADTOCENTRYS, (caddr_t)&toce, 176 td->td_ucred, td))) { 177 CP(toce, toce32, address_format); 178 CP(toce, toce32, starting_track); 179 CP(toce, toce32, data_len); 180 PTROUT_CP(toce, toce32, data); 181 error = copyout(&toce32, uap->data, sizeof(toce32)); 182 } 183 return error; 184 } 185 186 static int 187 freebsd32_ioctl_fiodgname(struct thread *td, 188 struct freebsd32_ioctl_args *uap, struct file *fp) 189 { 190 struct fiodgname_arg fgn; 191 struct fiodgname_arg32 fgn32; 192 int error; 193 194 if ((error = copyin(uap->data, &fgn32, sizeof fgn32)) != 0) 195 return (error); 196 CP(fgn32, fgn, len); 197 PTRIN_CP(fgn32, fgn, buf); 198 error = fo_ioctl(fp, FIODGNAME, (caddr_t)&fgn, td->td_ucred, td); 199 return (error); 200 } 201 202 static int 203 freebsd32_ioctl_memrange(struct thread *td, 204 struct freebsd32_ioctl_args *uap, struct file *fp) 205 { 206 struct mem_range_op mro; 207 struct mem_range_op32 mro32; 208 int error; 209 u_long com; 210 211 if ((error = copyin(uap->data, &mro32, sizeof(mro32))) != 0) 212 return (error); 213 214 PTRIN_CP(mro32, mro, mo_desc); 215 CP(mro32, mro, mo_arg[0]); 216 CP(mro32, mro, mo_arg[1]); 217 218 com = 0; 219 switch (uap->com) { 220 case MEMRANGE_GET32: 221 com = MEMRANGE_GET; 222 break; 223 224 case MEMRANGE_SET32: 225 com = MEMRANGE_SET; 226 break; 227 228 default: 229 panic("%s: unknown MEMRANGE %#x", __func__, uap->com); 230 } 231 232 if ((error = fo_ioctl(fp, com, (caddr_t)&mro, td->td_ucred, td)) != 0) 233 return (error); 234 235 if ( (com & IOC_OUT) ) { 236 CP(mro, mro32, mo_arg[0]); 237 CP(mro, mro32, mo_arg[1]); 238 239 error = copyout(&mro32, uap->data, sizeof(mro32)); 240 } 241 242 return (error); 243 } 244 245 static int 246 freebsd32_ioctl_pciocgetconf(struct thread *td, 247 struct freebsd32_ioctl_args *uap, struct file *fp) 248 { 249 struct pci_conf_io pci; 250 struct pci_conf_io32 pci32; 251 struct pci_match_conf32 pmc32; 252 struct pci_match_conf32 *pmc32p; 253 struct pci_match_conf pmc; 254 struct pci_match_conf *pmcp; 255 struct pci_conf32 pc32; 256 struct pci_conf32 *pc32p; 257 struct pci_conf pc; 258 struct pci_conf *pcp; 259 u_int32_t i; 260 u_int32_t npat_to_convert; 261 u_int32_t nmatch_to_convert; 262 vm_offset_t addr; 263 int error; 264 265 if ((error = copyin(uap->data, &pci32, sizeof(pci32))) != 0) 266 return (error); 267 268 CP(pci32, pci, num_patterns); 269 CP(pci32, pci, offset); 270 CP(pci32, pci, generation); 271 272 npat_to_convert = pci32.pat_buf_len / sizeof(struct pci_match_conf32); 273 pci.pat_buf_len = npat_to_convert * sizeof(struct pci_match_conf); 274 pci.patterns = NULL; 275 nmatch_to_convert = pci32.match_buf_len / sizeof(struct pci_conf32); 276 pci.match_buf_len = nmatch_to_convert * sizeof(struct pci_conf); 277 pci.matches = NULL; 278 279 if ((error = copyout_map(td, &addr, pci.pat_buf_len)) != 0) 280 goto cleanup; 281 pci.patterns = (struct pci_match_conf *)addr; 282 if ((error = copyout_map(td, &addr, pci.match_buf_len)) != 0) 283 goto cleanup; 284 pci.matches = (struct pci_conf *)addr; 285 286 npat_to_convert = min(npat_to_convert, pci.num_patterns); 287 288 for (i = 0, pmc32p = (struct pci_match_conf32 *)PTRIN(pci32.patterns), 289 pmcp = pci.patterns; 290 i < npat_to_convert; i++, pmc32p++, pmcp++) { 291 if ((error = copyin(pmc32p, &pmc32, sizeof(pmc32))) != 0) 292 goto cleanup; 293 CP(pmc32,pmc,pc_sel); 294 strlcpy(pmc.pd_name, pmc32.pd_name, sizeof(pmc.pd_name)); 295 CP(pmc32,pmc,pd_unit); 296 CP(pmc32,pmc,pc_vendor); 297 CP(pmc32,pmc,pc_device); 298 CP(pmc32,pmc,pc_class); 299 CP(pmc32,pmc,flags); 300 if ((error = copyout(&pmc, pmcp, sizeof(pmc))) != 0) 301 goto cleanup; 302 } 303 304 if ((error = fo_ioctl(fp, PCIOCGETCONF, (caddr_t)&pci, 305 td->td_ucred, td)) != 0) 306 goto cleanup; 307 308 nmatch_to_convert = min(nmatch_to_convert, pci.num_matches); 309 310 for (i = 0, pcp = pci.matches, 311 pc32p = (struct pci_conf32 *)PTRIN(pci32.matches); 312 i < nmatch_to_convert; i++, pcp++, pc32p++) { 313 if ((error = copyin(pcp, &pc, sizeof(pc))) != 0) 314 goto cleanup; 315 CP(pc,pc32,pc_sel); 316 CP(pc,pc32,pc_hdr); 317 CP(pc,pc32,pc_subvendor); 318 CP(pc,pc32,pc_subdevice); 319 CP(pc,pc32,pc_vendor); 320 CP(pc,pc32,pc_device); 321 CP(pc,pc32,pc_class); 322 CP(pc,pc32,pc_subclass); 323 CP(pc,pc32,pc_progif); 324 CP(pc,pc32,pc_revid); 325 strlcpy(pc32.pd_name, pc.pd_name, sizeof(pc32.pd_name)); 326 CP(pc,pc32,pd_unit); 327 if ((error = copyout(&pc32, pc32p, sizeof(pc32))) != 0) 328 goto cleanup; 329 } 330 331 CP(pci, pci32, num_matches); 332 CP(pci, pci32, offset); 333 CP(pci, pci32, generation); 334 CP(pci, pci32, status); 335 336 error = copyout(&pci32, uap->data, sizeof(pci32)); 337 338 cleanup: 339 if (pci.patterns) 340 copyout_unmap(td, (vm_offset_t)pci.patterns, pci.pat_buf_len); 341 if (pci.matches) 342 copyout_unmap(td, (vm_offset_t)pci.matches, pci.match_buf_len); 343 344 return (error); 345 } 346 347 static int 348 freebsd32_ioctl_sg(struct thread *td, 349 struct freebsd32_ioctl_args *uap, struct file *fp) 350 { 351 struct sg_io_hdr io; 352 struct sg_io_hdr32 io32; 353 int error; 354 355 if ((error = copyin(uap->data, &io32, sizeof(io32))) != 0) 356 return (error); 357 358 CP(io32, io, interface_id); 359 CP(io32, io, dxfer_direction); 360 CP(io32, io, cmd_len); 361 CP(io32, io, mx_sb_len); 362 CP(io32, io, iovec_count); 363 CP(io32, io, dxfer_len); 364 PTRIN_CP(io32, io, dxferp); 365 PTRIN_CP(io32, io, cmdp); 366 PTRIN_CP(io32, io, sbp); 367 CP(io32, io, timeout); 368 CP(io32, io, flags); 369 CP(io32, io, pack_id); 370 PTRIN_CP(io32, io, usr_ptr); 371 CP(io32, io, status); 372 CP(io32, io, masked_status); 373 CP(io32, io, msg_status); 374 CP(io32, io, sb_len_wr); 375 CP(io32, io, host_status); 376 CP(io32, io, driver_status); 377 CP(io32, io, resid); 378 CP(io32, io, duration); 379 CP(io32, io, info); 380 381 if ((error = fo_ioctl(fp, SG_IO, (caddr_t)&io, td->td_ucred, td)) != 0) 382 return (error); 383 384 CP(io, io32, interface_id); 385 CP(io, io32, dxfer_direction); 386 CP(io, io32, cmd_len); 387 CP(io, io32, mx_sb_len); 388 CP(io, io32, iovec_count); 389 CP(io, io32, dxfer_len); 390 PTROUT_CP(io, io32, dxferp); 391 PTROUT_CP(io, io32, cmdp); 392 PTROUT_CP(io, io32, sbp); 393 CP(io, io32, timeout); 394 CP(io, io32, flags); 395 CP(io, io32, pack_id); 396 PTROUT_CP(io, io32, usr_ptr); 397 CP(io, io32, status); 398 CP(io, io32, masked_status); 399 CP(io, io32, msg_status); 400 CP(io, io32, sb_len_wr); 401 CP(io, io32, host_status); 402 CP(io, io32, driver_status); 403 CP(io, io32, resid); 404 CP(io, io32, duration); 405 CP(io, io32, info); 406 407 error = copyout(&io32, uap->data, sizeof(io32)); 408 409 return (error); 410 } 411 412 int 413 freebsd32_ioctl(struct thread *td, struct freebsd32_ioctl_args *uap) 414 { 415 struct ioctl_args ap /*{ 416 int fd; 417 u_long com; 418 caddr_t data; 419 }*/ ; 420 struct file *fp; 421 cap_rights_t rights; 422 int error; 423 424 error = fget(td, uap->fd, cap_rights_init(&rights, CAP_IOCTL), &fp); 425 if (error != 0) 426 return (error); 427 if ((fp->f_flag & (FREAD | FWRITE)) == 0) { 428 fdrop(fp, td); 429 return (EBADF); 430 } 431 432 switch (uap->com) { 433 case MDIOCATTACH_32: /* FALLTHROUGH */ 434 case MDIOCDETACH_32: /* FALLTHROUGH */ 435 case MDIOCQUERY_32: /* FALLTHROUGH */ 436 case MDIOCLIST_32: 437 error = freebsd32_ioctl_md(td, uap, fp); 438 break; 439 440 case CDIOREADTOCENTRYS_32: 441 error = freebsd32_ioctl_ioc_read_toc(td, uap, fp); 442 break; 443 444 case CDIOREADTOCHEADER_32: 445 error = freebsd32_ioctl_ioc_toc_header(td, uap, fp); 446 break; 447 448 case FIODGNAME_32: 449 error = freebsd32_ioctl_fiodgname(td, uap, fp); 450 break; 451 452 case MEMRANGE_GET32: /* FALLTHROUGH */ 453 case MEMRANGE_SET32: 454 error = freebsd32_ioctl_memrange(td, uap, fp); 455 break; 456 457 case PCIOCGETCONF_32: 458 error = freebsd32_ioctl_pciocgetconf(td, uap, fp); 459 break; 460 461 case SG_IO_32: 462 error = freebsd32_ioctl_sg(td, uap, fp); 463 break; 464 465 default: 466 fdrop(fp, td); 467 ap.fd = uap->fd; 468 ap.com = uap->com; 469 PTRIN_CP(*uap, ap, data); 470 return sys_ioctl(td, &ap); 471 } 472 473 fdrop(fp, td); 474 return error; 475 } 476