1 | /* |
2 | * Copyright (c) 1998-2007 Apple 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 | |
29 | #include <IOKit/IOSubMemoryDescriptor.h> |
30 | |
31 | #include "IOKitKernelInternal.h" |
32 | |
33 | #define super IOMemoryDescriptor |
34 | |
35 | OSDefineMetaClassAndStructors(IOSubMemoryDescriptor, IOMemoryDescriptor) |
36 | |
37 | IOReturn IOSubMemoryDescriptor::redirect( task_t safeTask, bool doRedirect ) |
38 | { |
39 | #ifdef __LP64__ |
40 | super::redirect( safeTask, doRedirect ); |
41 | #endif /* __LP64__ */ |
42 | return( _parent->redirect( safeTask, doRedirect )); |
43 | } |
44 | |
45 | IOSubMemoryDescriptor * |
46 | IOSubMemoryDescriptor::withSubRange(IOMemoryDescriptor * of, |
47 | IOByteCount offset, |
48 | IOByteCount length, |
49 | IOOptionBits options) |
50 | { |
51 | IOSubMemoryDescriptor *self = new IOSubMemoryDescriptor; |
52 | |
53 | if (self && !self->initSubRange(of, offset, length, (IODirection) options)) { |
54 | self->release(); |
55 | self = 0; |
56 | } |
57 | return self; |
58 | } |
59 | |
60 | bool IOSubMemoryDescriptor::initSubRange( IOMemoryDescriptor * parent, |
61 | IOByteCount offset, IOByteCount length, |
62 | IODirection direction ) |
63 | { |
64 | if( parent && ((offset + length) > parent->getLength())) |
65 | return( false); |
66 | |
67 | /* |
68 | * We can check the _parent instance variable before having ever set it |
69 | * to an initial value because I/O Kit guarantees that all our instance |
70 | * variables are zeroed on an object's allocation. |
71 | */ |
72 | |
73 | if( !_parent) { |
74 | if( !super::init()) |
75 | return( false ); |
76 | } else { |
77 | /* |
78 | * An existing memory descriptor is being retargeted to |
79 | * point to somewhere else. Clean up our present state. |
80 | */ |
81 | |
82 | _parent->release(); |
83 | } |
84 | |
85 | if (parent) { |
86 | parent->retain(); |
87 | _tag = parent->getTag(); |
88 | } |
89 | else { |
90 | _tag = 0; |
91 | } |
92 | _parent = parent; |
93 | _start = offset; |
94 | _length = length; |
95 | _flags = direction; |
96 | _flags |= kIOMemoryThreadSafe; |
97 | |
98 | #ifndef __LP64__ |
99 | _direction = (IODirection) (_flags & kIOMemoryDirectionMask); |
100 | #endif /* !__LP64__ */ |
101 | |
102 | return( true ); |
103 | } |
104 | |
105 | void IOSubMemoryDescriptor::free( void ) |
106 | { |
107 | if( _parent) |
108 | _parent->release(); |
109 | |
110 | super::free(); |
111 | } |
112 | |
113 | addr64_t |
114 | IOSubMemoryDescriptor::getPhysicalSegment(IOByteCount offset, IOByteCount * length, IOOptionBits options) |
115 | { |
116 | addr64_t address; |
117 | IOByteCount actualLength; |
118 | |
119 | assert(offset <= _length); |
120 | |
121 | if( length) |
122 | *length = 0; |
123 | |
124 | if( offset >= _length) |
125 | return( 0 ); |
126 | |
127 | address = _parent->getPhysicalSegment( offset + _start, &actualLength, options ); |
128 | |
129 | if( address && length) |
130 | *length = min( _length - offset, actualLength ); |
131 | |
132 | return( address ); |
133 | } |
134 | |
135 | IOReturn IOSubMemoryDescriptor::setPurgeable( IOOptionBits newState, |
136 | IOOptionBits * oldState ) |
137 | { |
138 | IOReturn err; |
139 | |
140 | err = _parent->setPurgeable( newState, oldState ); |
141 | |
142 | return( err ); |
143 | } |
144 | |
145 | IOReturn IOSubMemoryDescriptor::prepare( |
146 | IODirection forDirection) |
147 | { |
148 | IOReturn err; |
149 | |
150 | err = _parent->prepare( forDirection); |
151 | |
152 | return( err ); |
153 | } |
154 | |
155 | IOReturn IOSubMemoryDescriptor::complete( |
156 | IODirection forDirection) |
157 | { |
158 | IOReturn err; |
159 | |
160 | err = _parent->complete( forDirection); |
161 | |
162 | return( err ); |
163 | } |
164 | |
165 | IOMemoryMap * IOSubMemoryDescriptor::makeMapping( |
166 | IOMemoryDescriptor * owner, |
167 | task_t intoTask, |
168 | IOVirtualAddress address, |
169 | IOOptionBits options, |
170 | IOByteCount offset, |
171 | IOByteCount length ) |
172 | { |
173 | IOMemoryMap * mapping = 0; |
174 | |
175 | #ifndef __LP64__ |
176 | if (!(kIOMap64Bit & options)) |
177 | { |
178 | panic("IOSubMemoryDescriptor::makeMapping !64bit" ); |
179 | } |
180 | #endif /* !__LP64__ */ |
181 | |
182 | mapping = (IOMemoryMap *) _parent->makeMapping( |
183 | owner, |
184 | intoTask, |
185 | address, |
186 | options, _start + offset, length ); |
187 | |
188 | return( mapping ); |
189 | } |
190 | |
191 | uint64_t |
192 | IOSubMemoryDescriptor::getPreparationID( void ) |
193 | { |
194 | uint64_t pID; |
195 | |
196 | if (!super::getKernelReserved()) |
197 | return (kIOPreparationIDUnsupported); |
198 | |
199 | pID = _parent->getPreparationID(); |
200 | if (reserved->kernReserved[0] != pID) |
201 | { |
202 | reserved->kernReserved[0] = pID; |
203 | reserved->preparationID = kIOPreparationIDUnprepared; |
204 | super::setPreparationID(); |
205 | } |
206 | |
207 | return (super::getPreparationID()); |
208 | } |
209 | |
210 | IOReturn |
211 | IOSubMemoryDescriptor::getPageCounts(IOByteCount * residentPageCount, |
212 | IOByteCount * dirtyPageCount) |
213 | { |
214 | return (_parent->getPageCounts(residentPageCount, dirtyPageCount)); |
215 | } |
216 | |