Chameleon

Chameleon Svn Source Tree

Root/branches/rewrite/i386/include/IOKit/storage/IOPartitionScheme.h

Source at commit 1146 created 12 years 11 months ago.
By azimutz, Sync with trunk (r1145). Add nVidia dev id's, 0DF4 for "GeForce GT 450M" (issue 99) and 1251 for "GeForce GTX 560M" (thanks to oSxFr33k for testing).
1/*
2 * Copyright (c) 1998-2009 Apple Inc. All rights reserved.
3 *
4 * @APPLE_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. Please obtain a copy of the License at
10 * http://www.opensource.apple.com/apsl/ and read it before using this
11 * file.
12 *
13 * The Original Code and all software distributed under the License are
14 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
15 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
16 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
18 * Please see the License for the specific language governing rights and
19 * limitations under the License.
20 *
21 * @APPLE_LICENSE_HEADER_END@
22 */
23
24/*!
25 * @header IOPartitionScheme
26 * @abstract
27 * This header contains the IOPartitionScheme class definition.
28 */
29
30#ifndef _IOPARTITIONSCHEME_H
31#define _IOPARTITIONSCHEME_H
32
33/*!
34 * @defined kIOPartitionSchemeClass
35 * @abstract
36 * The name of the IOPartitionScheme class.
37 * @discussion
38 * kIOPartitionSchemeClass is the name of the IOPartitionScheme class.
39 */
40
41#define kIOPartitionSchemeClass "IOPartitionScheme"
42
43/*!
44 * @defined kIOMediaLiveKey
45 * @abstract
46 * A property of IOMedia objects.
47 * @discussion
48 * The kIOMediaLiveKey property has an OSBoolean
49 * value and is placed into an IOMedia instance
50 * created via the partition scheme. It describes whether the
51 * partition is live, that is, it is up-to-date with respect
52 * to the on-disk partition table.
53 */
54
55#define kIOMediaLiveKey "Live"
56
57/*!
58 * @defined kIOMediaPartitionIDKey
59 * @abstract
60 * A property of IOMedia objects.
61 * @discussion
62 * The kIOMediaPartitionIDKey property has an OSNumber
63 * value and is placed into an IOMedia instance
64 * created via the partition scheme. It is an ID that differentiates one
65 * partition from the other (within a given scheme). It is typically an index
66 * into the on-disk partition table.
67 */
68
69#define kIOMediaPartitionIDKey "Partition ID"
70
71#ifdef KERNEL
72#ifdef __cplusplus
73
74/*
75 * Kernel
76 */
77
78#include <IOKit/storage/IOMedia.h>
79#include <IOKit/storage/IOStorage.h>
80
81/*!
82 * @class IOPartitionScheme
83 * @abstract
84 * The common base class for all partition scheme
85 * objects.
86 * @discussion
87 * The IOPartitionScheme class is the common base class for all partition scheme
88 * objects. It extends the IOStorage class by implementing the appropriate open
89 * and close semantics for partition objects (standard semantics are to act as a
90 * multiplexor for incoming opens, producing one outgoing open with the correct
91 * access). It also implements the default read and write semantics, which pass
92 * all reads and writes through to the provider media unprocessed. For simple
93 * schemes, the default behavior is sufficient. More complex partition schemes
94 * such as RAID will want to do extra processing for reads and writes.
95 */
96
97class IOPartitionScheme : public IOStorage
98{
99 OSDeclareDefaultStructors(IOPartitionScheme);
100
101protected:
102
103 struct ExpansionData { /* */ };
104 ExpansionData * _expansionData;
105
106 IOStorageAccess _openLevel;
107 OSSet * _openReaders;
108 OSSet * _openReaderWriters;
109
110 /*
111 * Free all of this object's outstanding resources.
112 */
113
114 virtual void free();
115
116 /*!
117 * @function handleOpen
118 * @discussion
119 * The handleOpen method grants or denies permission to access this object
120 * to an interested client. The argument is an IOStorageAccess value that
121 * specifies the level of access desired -- reader or reader-writer.
122 *
123 * This method can be invoked to upgrade or downgrade the access level for
124 * an existing client as well. The previous access level will prevail for
125 * upgrades that fail, of course. A downgrade should never fail. If the
126 * new access level should be the same as the old for a given client, this
127 * method will do nothing and return success. In all cases, one, singular
128 * close-per-client is expected for all opens-per-client received.
129 *
130 * This implementation replaces the IOService definition of handleOpen().
131 * @param client
132 * Client requesting the open.
133 * @param options
134 * Options for the open. Set to zero.
135 * @param access
136 * Access level for the open. Set to kIOStorageAccessReader or
137 * kIOStorageAccessReaderWriter.
138 * @result
139 * Returns true if the open was successful, false otherwise.
140 */
141
142 virtual bool handleOpen(IOService * client,
143 IOOptionBits options,
144 void * access);
145
146 /*!
147 * @function handleIsOpen
148 * @discussion
149 * The handleIsOpen method determines whether the specified client, or any
150 * client if none is specified, presently has an open on this object.
151 *
152 * This implementation replaces the IOService definition of handleIsOpen().
153 * @param client
154 * Client to check the open state of. Set to zero to check the open state
155 * of all clients.
156 * @result
157 * Returns true if the client was (or clients were) open, false otherwise.
158 */
159
160 virtual bool handleIsOpen(const IOService * client) const;
161
162 /*!
163 * @function handleClose
164 * @discussion
165 * The handleClose method closes the client's access to this object.
166 *
167 * This implementation replaces the IOService definition of handleClose().
168 * @param client
169 * Client requesting the close.
170 * @param options
171 * Options for the close. Set to zero.
172 */
173
174 virtual void handleClose(IOService * client, IOOptionBits options);
175
176 /*
177 * Attach the given media object to the device tree plane.
178 */
179
180#ifdef __LP64__
181 virtual bool attachMediaObjectToDeviceTree(IOMedia * media);
182#else /* !__LP64__ */
183 virtual bool attachMediaObjectToDeviceTree(IOMedia * media,
184 IOOptionBits options = 0); /* 10.5.0 */
185#endif /* !__LP64__ */
186
187 /*
188 * Detach the given media object from the device tree plane.
189 */
190
191#ifdef __LP64__
192 virtual void detachMediaObjectFromDeviceTree(IOMedia * media);
193#else /* !__LP64__ */
194 virtual void detachMediaObjectFromDeviceTree(IOMedia * media,
195 IOOptionBits options = 0); /* 10.5.0 */
196#endif /* !__LP64__ */
197
198 /*
199 * Updates a set of existing partitions, represented by partitionsOld,
200 * with possible updates from a rescan of the disk, represented by
201 * partitionsNew. It returns a new set of partitions with the results,
202 * removing partitions from partitionsOld where applicable, adding
203 * partitions from partitionsNew where applicable, and folding in property
204 * changes to partitions from partitionsNew into partitionsOld where
205 * applicable.
206 */
207
208 virtual OSSet * juxtaposeMediaObjects(OSSet * partitionsOld,
209 OSSet * partitionsNew); /* 10.5.0 */
210
211public:
212
213 using IOStorage::read;
214 using IOStorage::write;
215
216 /*
217 * Initialize this object's minimal state.
218 */
219
220 virtual bool init(OSDictionary * properties = 0);
221
222 /*!
223 * @function read
224 * @discussion
225 * Read data from the storage object at the specified byte offset into the
226 * specified buffer, asynchronously. When the read completes, the caller
227 * will be notified via the specified completion action.
228 *
229 * The buffer will be retained for the duration of the read.
230 *
231 * For simple partition schemes, the default behavior is to simply pass the
232 * read through to the provider media. More complex partition schemes such
233 * as RAID will need to do extra processing here.
234 * @param client
235 * Client requesting the read.
236 * @param byteStart
237 * Starting byte offset for the data transfer.
238 * @param buffer
239 * Buffer for the data transfer. The size of the buffer implies the size of
240 * the data transfer.
241 * @param attributes
242 * Attributes of the data transfer. See IOStorageAttributes. It is the
243 * responsibility of the callee to maintain the information for the duration
244 * of the data transfer, as necessary.
245 * @param completion
246 * Completion routine to call once the data transfer is complete. It is the
247 * responsibility of the callee to maintain the information for the duration
248 * of the data transfer, as necessary.
249 */
250
251 virtual void read(IOService * client,
252 UInt64 byteStart,
253 IOMemoryDescriptor * buffer,
254 IOStorageAttributes * attributes,
255 IOStorageCompletion * completion);
256
257 /*!
258 * @function write
259 * @discussion
260 * Write data into the storage object at the specified byte offset from the
261 * specified buffer, asynchronously. When the write completes, the caller
262 * will be notified via the specified completion action.
263 *
264 * The buffer will be retained for the duration of the write.
265 *
266 * For simple partition schemes, the default behavior is to simply pass the
267 * write through to the provider media. More complex partition schemes such
268 * as RAID will need to do extra processing here.
269 * @param client
270 * Client requesting the write.
271 * @param byteStart
272 * Starting byte offset for the data transfer.
273 * @param buffer
274 * Buffer for the data transfer. The size of the buffer implies the size of
275 * the data transfer.
276 * @param attributes
277 * Attributes of the data transfer. See IOStorageAttributes. It is the
278 * responsibility of the callee to maintain the information for the duration
279 * of the data transfer, as necessary.
280 * @param completion
281 * Completion routine to call once the data transfer is complete. It is the
282 * responsibility of the callee to maintain the information for the duration
283 * of the data transfer, as necessary.
284 */
285
286 virtual void write(IOService * client,
287 UInt64 byteStart,
288 IOMemoryDescriptor * buffer,
289 IOStorageAttributes * attributes,
290 IOStorageCompletion * completion);
291
292 /*!
293 * @function synchronizeCache
294 * @discussion
295 * Flush the cached data in the storage object, if any, synchronously.
296 * @param client
297 * Client requesting the cache synchronization.
298 * @result
299 * Returns the status of the cache synchronization.
300 */
301
302 virtual IOReturn synchronizeCache(IOService * client);
303
304 /*!
305 * @function discard
306 * @discussion
307 * Delete unused data from the storage object at the specified byte offset,
308 * synchronously.
309 * @param client
310 * Client requesting the operation.
311 * @param byteStart
312 * Starting byte offset for the operation.
313 * @param byteCount
314 * Size of the operation.
315 * @result
316 * Returns the status of the operation.
317 */
318
319 virtual IOReturn discard(IOService * client,
320 UInt64 byteStart,
321 UInt64 byteCount);
322
323 /*
324 * Obtain this object's provider. We override the superclass's method
325 * to return a more specific subclass of OSObject -- an IOMedia. This
326 * method serves simply as a convenience to subclass developers.
327 */
328
329 virtual IOMedia * getProvider() const;
330
331#ifdef __LP64__
332 OSMetaClassDeclareReservedUnused(IOPartitionScheme, 0);
333 OSMetaClassDeclareReservedUnused(IOPartitionScheme, 1);
334 OSMetaClassDeclareReservedUnused(IOPartitionScheme, 2);
335#else /* !__LP64__ */
336 OSMetaClassDeclareReservedUsed(IOPartitionScheme, 0);
337 OSMetaClassDeclareReservedUsed(IOPartitionScheme, 1);
338 OSMetaClassDeclareReservedUsed(IOPartitionScheme, 2);
339#endif /* !__LP64__ */
340 OSMetaClassDeclareReservedUnused(IOPartitionScheme, 3);
341 OSMetaClassDeclareReservedUnused(IOPartitionScheme, 4);
342 OSMetaClassDeclareReservedUnused(IOPartitionScheme, 5);
343 OSMetaClassDeclareReservedUnused(IOPartitionScheme, 6);
344 OSMetaClassDeclareReservedUnused(IOPartitionScheme, 7);
345 OSMetaClassDeclareReservedUnused(IOPartitionScheme, 8);
346 OSMetaClassDeclareReservedUnused(IOPartitionScheme, 9);
347 OSMetaClassDeclareReservedUnused(IOPartitionScheme, 10);
348 OSMetaClassDeclareReservedUnused(IOPartitionScheme, 11);
349 OSMetaClassDeclareReservedUnused(IOPartitionScheme, 12);
350 OSMetaClassDeclareReservedUnused(IOPartitionScheme, 13);
351 OSMetaClassDeclareReservedUnused(IOPartitionScheme, 14);
352 OSMetaClassDeclareReservedUnused(IOPartitionScheme, 15);
353 OSMetaClassDeclareReservedUnused(IOPartitionScheme, 16);
354 OSMetaClassDeclareReservedUnused(IOPartitionScheme, 17);
355 OSMetaClassDeclareReservedUnused(IOPartitionScheme, 18);
356 OSMetaClassDeclareReservedUnused(IOPartitionScheme, 19);
357 OSMetaClassDeclareReservedUnused(IOPartitionScheme, 20);
358 OSMetaClassDeclareReservedUnused(IOPartitionScheme, 21);
359 OSMetaClassDeclareReservedUnused(IOPartitionScheme, 22);
360 OSMetaClassDeclareReservedUnused(IOPartitionScheme, 23);
361 OSMetaClassDeclareReservedUnused(IOPartitionScheme, 24);
362 OSMetaClassDeclareReservedUnused(IOPartitionScheme, 25);
363 OSMetaClassDeclareReservedUnused(IOPartitionScheme, 26);
364 OSMetaClassDeclareReservedUnused(IOPartitionScheme, 27);
365 OSMetaClassDeclareReservedUnused(IOPartitionScheme, 28);
366 OSMetaClassDeclareReservedUnused(IOPartitionScheme, 29);
367 OSMetaClassDeclareReservedUnused(IOPartitionScheme, 30);
368 OSMetaClassDeclareReservedUnused(IOPartitionScheme, 31);
369};
370
371#endif /* __cplusplus */
372#endif /* KERNEL */
373#endif /* !_IOPARTITIONSCHEME_H */
374

Archive Download this file

Revision: 1146