![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to IOPartitionScheme.cpp CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / iokit / Families / IOStorage|
Return to IOPartitionScheme.cpp CVS log | Up to [Apple XNU] / XNU / iokit / Families / IOStorage |
1.1 root 1: /*
2: * Copyright (c) 1998-2000 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * The contents of this file constitute Original Code as defined in and
7: * are subject to the Apple Public Source License Version 1.1 (the
8: * "License"). You may not use this file except in compliance with the
9: * License. Please obtain a copy of the License at
10: * http://www.apple.com/publicsource and read it before using this file.
11: *
12: * This Original Code and all software distributed under the License are
13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
17: * License for the specific language governing rights and limitations
18: * under the License.
19: *
20: * @APPLE_LICENSE_HEADER_END@
21: */
22:
23: #include <IOKit/storage/IOPartitionScheme.h>
24:
25: #define super IOStorage
26: OSDefineMetaClassAndStructors(IOPartitionScheme, IOStorage)
27:
28: // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
29:
30: bool IOPartitionScheme::init(OSDictionary * properties = 0)
31: {
32: //
33: // Initialize this object's minimal state.
34: //
35:
36: if (super::init(properties) == false) return false;
37:
38: _openLevel = kAccessNone;
39: _openReaders = OSSet::withCapacity(16);
40: _openReaderWriters = OSSet::withCapacity(16);
41:
42: if (_openReaders == 0 || _openReaderWriters == 0) return false;
43:
44: return true;
45: }
46:
47: // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
48:
49: void IOPartitionScheme::free()
50: {
51: //
52: // Free all of this object's outstanding resources.
53: //
54:
55: if (_openReaders) _openReaders->release();
56: if (_openReaderWriters) _openReaderWriters->release();
57:
58: super::free();
59: }
60:
61: // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
62:
63: bool IOPartitionScheme::handleOpen(IOService * client,
64: IOOptionBits options,
65: void * argument)
66: {
67: //
68: // The handleOpen method grants or denies permission to access this object
69: // to an interested client. The argument is an IOStorageAccess value that
70: // specifies the level of access desired -- reader or reader-writer.
71: //
72: // This method can be invoked to upgrade or downgrade the access level for
73: // an existing client as well. The previous access level will prevail for
74: // upgrades that fail, of course. A downgrade should never fail. If the
75: // new access level should be the same as the old for a given client, this
76: // method will do nothing and return success. In all cases, one, singular
77: // close-per-client is expected for all opens-per-client received.
78: //
79: // This implementation replaces the IOService definition of handleOpen().
80: //
81: // We are guaranteed that no other opens or closes will be processed until
82: // we make our decision, change our state, and return from this method.
83: //
84:
85: IOStorageAccess access = (IOStorageAccess) (int) argument;
86: IOStorageAccess level;
87:
88: assert(client);
89: assert(access == kAccessReader || access == kAccessReaderWriter);
90:
91: //
92: // A partition scheme multiplexes the opens it receives from several clients
93: // and sends one open to the level below that satisfies the highest level of
94: // access.
95: //
96:
97: unsigned writers = _openReaderWriters->getCount();
98:
99: if (_openReaderWriters->containsObject(client)) writers--;
100: if (access == kAccessReaderWriter) writers++;
101:
102: level = (writers) ? kAccessReaderWriter : kAccessReader;
103:
104: //
105: // Determine whether the levels below us accept this open or not (we avoid
106: // the open if the required access is the access we already hold).
107: //
108:
109: if (_openLevel != level) // (has open level changed?)
110: {
111: IOStorage * provider = OSDynamicCast(IOStorage, getProvider());
112:
113: if (provider && provider->open(this, options, level) == false)
114: return false;
115: }
116:
117: //
118: // Process the open.
119: //
120:
121: if (access == kAccessReader)
122: {
123: _openReaders->setObject(client);
124:
125: _openReaderWriters->removeObject(client); // (for a downgrade)
126: }
127: else // (access == kAccessReaderWriter)
128: {
129: _openReaderWriters->setObject(client);
130:
131: _openReaders->removeObject(client); // (for an upgrade)
132: }
133:
134: _openLevel = level;
135:
136: return true;
137: }
138:
139: // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
140:
141: bool IOPartitionScheme::handleIsOpen(const IOService * client) const
142: {
143: //
144: // The handleIsOpen method determines whether the specified client, or any
145: // client if none is specificed, presently has an open on this object.
146: //
147: // This implementation replaces the IOService definition of handleIsOpen().
148: //
149: // We are guaranteed that no other opens or closes will be processed until
150: // we return from this method.
151: //
152:
153: if (client == 0) return (_openLevel != kAccessNone);
154:
155: return ( _openReaderWriters->containsObject(client) ||
156: _openReaders->containsObject(client) );
157: }
158:
159: // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
160:
161: void IOPartitionScheme::handleClose(IOService * client, IOOptionBits options)
162: {
163: //
164: // The handleClose method closes the client's access to this object.
165: //
166: // This implementation replaces the IOService definition of handleClose().
167: //
168: // We are guaranteed that no other opens or closes will be processed until
169: // we change our state and return from this method.
170: //
171:
172: assert(client);
173:
174: //
175: // Process the close.
176: //
177:
178: if (_openReaderWriters->containsObject(client)) // (is it a reader-writer?)
179: {
180: _openReaderWriters->removeObject(client);
181: }
182: else if (_openReaders->containsObject(client)) // (is the client a reader?)
183: {
184: _openReaders->removeObject(client);
185: }
186: else // (is the client is an imposter?)
187: {
188: assert(0);
189: return;
190: }
191:
192: //
193: // Reevaluate the open we have on the level below us. If no opens remain,
194: // we close, or if no reader-writer remains, but readers do, we downgrade.
195: //
196:
197: IOStorageAccess level;
198:
199: if (_openReaderWriters->getCount()) level = kAccessReaderWriter;
200: else if (_openReaders->getCount()) level = kAccessReader;
201: else level = kAccessNone;
202:
203: if (_openLevel != level) // (has open level changed?)
204: {
205: IOStorage * provider = OSDynamicCast(IOStorage, getProvider());
206:
207: assert(level != kAccessReaderWriter);
208:
209: if (provider)
210: {
211: if (level == kAccessNone) // (is a close in order?)
212: {
213: provider->close(this, options);
214: }
215: else // (is a downgrade in order?)
216: {
217: bool success;
218: success = provider->open(this, 0, level);
219: assert(success); // (should never fail, unless avoided deadlock)
220: }
221: }
222:
223: _openLevel = level; // (set new open level)
224: }
225: }
226:
227: // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
228:
229: void IOPartitionScheme::read(IOService * /* client */,
230: UInt64 byteStart,
231: IOMemoryDescriptor * buffer,
232: IOStorageCompletion completion)
233: {
234: //
235: // Read data from the storage object at the specified byte offset into the
236: // specified buffer, asynchronously. When the read completes, the caller
237: // will be notified via the specified completion action.
238: //
239: // The buffer will be retained for the duration of the read.
240: //
241: // For simple partition schemes, the default behavior is to simply pass the
242: // read through to the provider media. More complex partition schemes such
243: // as RAID will need to do extra processing here.
244: //
245:
246: getProvider()->read(this, byteStart, buffer, completion);
247: }
248:
249: // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
250:
251: void IOPartitionScheme::write(IOService * /* client */,
252: UInt64 byteStart,
253: IOMemoryDescriptor * buffer,
254: IOStorageCompletion completion)
255: {
256: //
257: // Write data into the storage object at the specified byte offset from the
258: // specified buffer, asynchronously. When the write completes, the caller
259: // will be notified via the specified completion action.
260: //
261: // The buffer will be retained for the duration of the write.
262: //
263: // For simple partition schemes, the default behavior is to simply pass the
264: // write through to the provider media. More complex partition schemes such
265: // as RAID will need to do extra processing here.
266: //
267:
268: getProvider()->write(this, byteStart, buffer, completion);
269: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.