1/* 2 * Copyright (c) 2000-2006 Apple Computer, Inc. All rights reserved. 3 * 4 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@ 5 * 6 * This file contains Original Code and/or Modifications of Original Code 7 * as defined in and that are subject to the Apple Public Source License 8 * Version 2.0 (the 'License'). You may not use this file except in 9 * compliance with the License. The rights granted to you under the License 10 * may not be used to create, or enable the creation or redistribution of, 11 * unlawful or unlicensed copies of an Apple operating system, or to 12 * circumvent, violate, or enable the circumvention or violation of, any 13 * terms of an Apple operating system software license agreement. 14 * 15 * Please obtain a copy of the License at 16 * http://www.opensource.apple.com/apsl/ and read it before using this file. 17 * 18 * The Original Code and all software distributed under the License are 19 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 20 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, 21 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, 22 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 23 * Please see the License for the specific language governing rights and 24 * limitations under the License. 25 * 26 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@ 27 */ 28/* Copyright (c) 1998 Apple Computer, Inc. All rights reserved. 29 * 30 * File: bsd/kern/kern_symfile.c 31 * 32 * HISTORY 33 */ 34 35#include <mach/vm_param.h> 36 37#include <sys/param.h> 38#include <sys/systm.h> 39#include <sys/signalvar.h> 40#include <sys/resourcevar.h> 41#include <sys/namei.h> 42#include <sys/vnode_internal.h> 43#include <sys/proc_internal.h> 44#include <sys/kauth.h> 45#include <sys/timeb.h> 46#include <sys/times.h> 47#include <sys/acct.h> 48#include <sys/file_internal.h> 49#include <sys/uio.h> 50#include <sys/kernel.h> 51#include <sys/stat.h> 52#include <sys/disk.h> 53#include <sys/conf.h> 54 55#include <mach-o/loader.h> 56#include <mach-o/nlist.h> 57 58#include <kern/kalloc.h> 59#include <vm/vm_kern.h> 60#include <pexpert/pexpert.h> 61#include <IOKit/IOHibernatePrivate.h> 62 63/* This function is called from kern_sysctl in the current process context; 64 * it is exported with the System6.0.exports, but this appears to be a legacy 65 * export, as there are no internal consumers. 66 */ 67int 68get_kernel_symfile(__unused proc_t p, __unused char const **symfile) 69{ 70 return KERN_FAILURE; 71} 72 73struct kern_direct_file_io_ref_t 74{ 75 vfs_context_t ctx; 76 struct vnode *vp; 77}; 78 79 80static int file_ioctl(void * p1, void * p2, int theIoctl, caddr_t result) 81{ 82 dev_t device = (dev_t) p1; 83 84 return ((*bdevsw[major(device)].d_ioctl) 85 (device, theIoctl, result, S_IFBLK, p2)); 86} 87 88static int device_ioctl(void * p1, __unused void * p2, int theIoctl, caddr_t result) 89{ 90 return (VNOP_IOCTL(p1, theIoctl, result, 0, p2)); 91} 92 93struct kern_direct_file_io_ref_t * 94kern_open_file_for_direct_io(const char * name, 95 kern_get_file_extents_callback_t callback, 96 void * callback_ref, 97 dev_t * device_result, 98 uint64_t * partitionbase_result, 99 uint64_t * maxiocount_result) 100{ 101 struct kern_direct_file_io_ref_t * ref; 102 103 proc_t p; 104 struct vnode_attr va; 105 int error; 106 off_t f_offset; 107 uint32_t blksize; 108 uint64_t size; 109 dev_t device; 110 off_t maxiocount, count; 111 112 int (*do_ioctl)(void * p1, void * p2, int theIoctl, caddr_t result); 113 void * p1; 114 void * p2; 115 116 error = EFAULT; 117 118 ref = (struct kern_direct_file_io_ref_t *) kalloc(sizeof(struct kern_direct_file_io_ref_t)); 119 if (!ref) 120 { 121 error = EFAULT; 122 goto out; 123 } 124 125 ref->vp = NULL; 126 p = current_proc(); // kernproc; 127 ref->ctx = vfs_context_create(vfs_context_current()); 128 129 if ((error = vnode_open(name, (O_CREAT | FWRITE), (0), 0, &ref->vp, ref->ctx))) 130 goto out; 131 132 VATTR_INIT(&va); 133 VATTR_WANTED(&va, va_rdev); 134 VATTR_WANTED(&va, va_fsid); 135 VATTR_WANTED(&va, va_data_size); 136 VATTR_WANTED(&va, va_nlink); 137 error = EFAULT; 138 if (vnode_getattr(ref->vp, &va, ref->ctx)) 139 goto out; 140 141 kprintf("vp va_rdev major %d minor %d\n", major(va.va_rdev), minor(va.va_rdev)); 142 kprintf("vp va_fsid major %d minor %d\n", major(va.va_fsid), minor(va.va_fsid)); 143 kprintf("vp size %qd\n", va.va_data_size); 144 145 if (ref->vp->v_type == VREG) 146 { 147 /* Don't dump files with links. */ 148 if (va.va_nlink != 1) 149 goto out; 150 151 device = va.va_fsid; 152 p1 = (void *) device; 153 p2 = p; 154 do_ioctl = &file_ioctl; 155 } 156 else if ((ref->vp->v_type == VBLK) || (ref->vp->v_type == VCHR)) 157 { 158 /* Partition. */ 159 device = va.va_rdev; 160 161 p1 = ref->vp; 162 p2 = ref->ctx; 163 do_ioctl = &device_ioctl; 164 } 165 else 166 { 167 /* Don't dump to non-regular files. */ 168 error = EFAULT; 169 goto out; 170 } 171 172 // get partition base 173 174 error = do_ioctl(p1, p2, DKIOCGETBASE, (caddr_t) partitionbase_result); 175 if (error) 176 goto out; 177 178 // get block size & constraints 179 180 error = do_ioctl(p1, p2, DKIOCGETBLOCKSIZE, (caddr_t) &blksize); 181 if (error) 182 goto out; 183 184 maxiocount = 1*1024*1024*1024; 185 186 error = do_ioctl(p1, p2, DKIOCGETMAXBLOCKCOUNTREAD, (caddr_t) &count); 187 if (error) 188 count = 0; 189 count *= blksize; 190 if (count && (count < maxiocount)) 191 maxiocount = count; 192 193 error = do_ioctl(p1, p2, DKIOCGETMAXBLOCKCOUNTWRITE, (caddr_t) &count); 194 if (error) 195 count = 0; 196 count *= blksize; 197 if (count && (count < maxiocount)) 198 maxiocount = count; 199 200 error = do_ioctl(p1, p2, DKIOCGETMAXBYTECOUNTREAD, (caddr_t) &count); 201 if (error) 202 count = 0; 203 if (count && (count < maxiocount)) 204 maxiocount = count; 205 206 error = do_ioctl(p1, p2, DKIOCGETMAXBYTECOUNTWRITE, (caddr_t) &count); 207 if (error) 208 count = 0; 209 if (count && (count < maxiocount)) 210 maxiocount = count; 211 212 error = do_ioctl(p1, p2, DKIOCGETMAXSEGMENTBYTECOUNTREAD, (caddr_t) &count); 213 if (error) 214 count = 0; 215 if (count && (count < maxiocount)) 216 maxiocount = count; 217 218 error = do_ioctl(p1, p2, DKIOCGETMAXSEGMENTBYTECOUNTWRITE, (caddr_t) &count); 219 if (error) 220 count = 0; 221 if (count && (count < maxiocount)) 222 maxiocount = count; 223 224 kprintf("max io 0x%qx bytes\n", maxiocount); 225 if (maxiocount_result) 226 *maxiocount_result = maxiocount; 227 228 // generate the block list 229 230 error = 0; 231 if (ref->vp->v_type == VREG) 232 { 233 f_offset = 0; 234 while(f_offset < (off_t) va.va_data_size) 235 { 236 size_t io_size = 1*1024*1024*1024; 237 daddr64_t blkno; 238 239 error = VNOP_BLOCKMAP(ref->vp, f_offset, io_size, &blkno, (size_t *)&io_size, NULL, 0, NULL); 240 if (error) 241 goto out; 242 callback(callback_ref, ((uint64_t) blkno) * blksize, (uint64_t) io_size); 243 f_offset += io_size; 244 } 245 callback(callback_ref, 0ULL, 0ULL); 246 } 247 else if ((ref->vp->v_type == VBLK) || (ref->vp->v_type == VCHR)) 248 { 249 error = do_ioctl(p1, p2, DKIOCGETBLOCKCOUNT, (caddr_t) &size); 250 if (error) 251 goto out; 252 size *= blksize; 253 callback(callback_ref, 0ULL, size); 254 callback(callback_ref, size, 0ULL); 255 } 256 257 if (device_result) 258 *device_result = device; 259 260out: 261 kprintf("kern_open_file_for_direct_io(%d)\n", error); 262 263 if (error && ref) { 264 if (ref->vp) { 265 vnode_close(ref->vp, FWRITE, ref->ctx); 266 ref->vp = NULLVP; 267 } 268 269 vfs_context_rele(ref->ctx); 270 kfree(ref, sizeof(struct kern_direct_file_io_ref_t)); 271 ref = NULL; 272 } 273 274 return(ref); 275} 276 277int 278kern_write_file(struct kern_direct_file_io_ref_t * ref, off_t offset, caddr_t addr, vm_size_t len) 279{ 280 return (vn_rdwr(UIO_WRITE, ref->vp, 281 addr, len, offset, 282 UIO_SYSSPACE32, IO_SYNC|IO_NODELOCKED|IO_UNIT, 283 vfs_context_ucred(ref->ctx), (int *) 0, 284 vfs_context_proc(ref->ctx))); 285} 286 287void 288kern_close_file_for_direct_io(struct kern_direct_file_io_ref_t * ref) 289{ 290 kprintf("kern_close_file_for_direct_io\n"); 291 292 if (ref) { 293 int error; 294 295 if (ref->vp) { 296 error = vnode_close(ref->vp, FWRITE, ref->ctx); 297 ref->vp = NULLVP; 298 kprintf("vnode_close(%d)\n", error); 299 } 300 vfs_context_rele(ref->ctx); 301 ref->ctx = NULL; 302 kfree(ref, sizeof(struct kern_direct_file_io_ref_t)); 303 } 304} 305 306