bsd/kern/kern_symfile.c

   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  */
  67 int
  68 get_kernel_symfile(__unused proc_t p, __unused char const **symfile)
  69 {
  70     return KERN_FAILURE;
  71 }
  72
  73 struct kern_direct_file_io_ref_t
  74 {
  75     vfs_context_t               ctx;
  76     struct vnode                *vp;
  77 };
  78
  79
  80 static 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
  88 static 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
  93 struct kern_direct_file_io_ref_t *
  94 kern_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
 260 out:
 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
 277 int
 278 kern_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
 287 void
 288 kern_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