git.saurik.com Git - apple/xnu.git/blob - bsd/miscfs/nullfs/null

1 /*

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 */

24 /*-

27 *

28 * This code is derived from software donated to Berkeley by

29 * Jan-Simon Pendry.

30 *

31 * Redistribution and use in source and binary forms, with or without

32 * modification, are permitted provided that the following conditions

33 * are met:

34 * 1. Redistributions of source code must retain the above copyright

35 * notice, this list of conditions and the following disclaimer.

36 * 2. Redistributions in binary form must reproduce the above copyright

37 * notice, this list of conditions and the following disclaimer in the

38 * documentation and/or other materials provided with the distribution.

39 * 4. Neither the name of the University nor the names of its contributors

40 * may be used to endorse or promote products derived from this software

41 * without specific prior written permission.

42 *

43 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND

44 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

45 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

46 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE

47 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

48 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS

49 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

50 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

51 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY

52 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

53 * SUCH DAMAGE.

54 *

55 * @(#)null_subr.c 8.7 (Berkeley) 5/14/95

56 *

57 * $FreeBSD$

58 */

59 #include <sys/param.h>

60 #include <sys/systm.h>

61 #include <sys/kernel.h>

62 #include <sys/lock.h>

63 #include <sys/malloc.h>

64 #include <sys/mount.h>

65 #include <sys/proc.h>

66 #include <sys/vnode.h>

68 #include "nullfs.h"

70 /*

71 * Null layer cache:

72 * Each cache entry holds a reference to the lower vnode

73 * along with a pointer to the alias vnode. When an

74 * entry is added the lower vnode is VREF'd. When the

75 * alias is removed the lower vnode is vrele'd.

76 */

78 #define NULL_HASH_SIZE (desiredvnodes / 10)

80 /* osx doesn't really have the functionality freebsd uses here..gonna try this

81 * hacked hash...*/

82 #define NULL_NHASH(vp) (&null_node_hashtbl[((((uintptr_t)vp) >> vnsz2log) + (uintptr_t)vnode_mount(vp)) & null_hash_mask])

 static LIST_HEAD(null_node_hashhead, null_node) * null_node_hashtbl;

 static LCK_GRP_DECLARE(null_hashlck_grp, "com.apple.filesystems.nullfs");

 static LCK_MTX_DECLARE(null_hashmtx, &null_hashlck_grp);

87 static u_long null_hash_mask;

89 /* os x doesn't have hashes built into vnode. gonna try doing what freebsd does

90 * anyway

91 * Don't want to create a dependency on vnode_internal.h and the real struct

92 * vnode.

93 * 9 is an eyeball of the log 2 size of vnode */

94 static int vnsz2log = 9;

 static int null_hashins(struct mount *, struct null_node *, struct vnode **);

98 void

99 nullfs_init_lck(lck_mtx_t * lck)

100 {

         lck_mtx_init(lck, &null_hashlck_grp, LCK_ATTR_NULL);

102 }

103

104 void

105 nullfs_destroy_lck(lck_mtx_t * lck)

106 {

107 lck_mtx_destroy(lck, &null_hashlck_grp);

108 }

109

110 /*

111 * Initialise cache headers

112 */

113 int

 nullfs_init(__unused struct vfsconf * vfsp)

115 {

         NULLFSDEBUG("%s\n", __FUNCTION__);

         null_node_hashtbl = hashinit(NULL_HASH_SIZE, M_TEMP, &null_hash_mask);

         NULLFSDEBUG("%s finished\n", __FUNCTION__);

119 return 0;

120 }

121

122 int

123 nullfs_uninit(void)

124 {

125 /* This gets called when the fs is uninstalled, there wasn't an exact

126 * equivalent in vfsops */

         hashdestroy(null_node_hashtbl, M_TEMP, null_hash_mask);

128 return 0;

129 }

130

131 /*

132 * Find the nullfs vnode mapped to lowervp. Return it in *vpp with an iocount if found.

133 * Return 0 on success. On failure *vpp will be null and a non-zero error code will be returned.

134 */

135 int

 null_hashget(struct mount * mp, struct vnode * lowervp, struct vnode ** vpp)

137 {

138 struct null_node_hashhead * hd = NULL;

139 struct null_node * a = NULL;

140 struct vnode * vp = NULL;

141 uint32_t vp_vid = 0;

142 int error = ENOENT;

143

144 /*

145 * Find hash base, and then search the (two-way) linked

146 * list looking for a null_node structure which is referencing

147 * the lower vnode. We only give up our reference at reclaim so

148 * just check whether the lowervp has gotten pulled from under us

149 */

150 hd = NULL_NHASH(lowervp);

151 // In the future we should consider using a per bucket lock

152 lck_mtx_lock(&null_hashmtx);

         LIST_FOREACH(a, hd, null_hash)

154 {

                 if (a->null_lowervp == lowervp && vnode_mount(NULLTOV(a)) == mp) {

156 vp = NULLTOV(a);

                         if (a->null_lowervid != vnode_vid(lowervp)) {

158 /*lowervp has reved */

159 error = EIO;

160 vp = NULL;

161 } else {

162 vp_vid = a->null_myvid;

163 }

164 // In the case of a succesful look-up we should consider moving the object to the top of the head

165 break;

166 }

167 }

168 lck_mtx_unlock(&null_hashmtx);

169 if (vp != NULL) {

                 error = vnode_getwithvid(vp, vp_vid);

                 if (error == 0) {

172 *vpp = vp;

173 }

174 }

175 return error;

176 }

177

178 /*

179 * Act like null_hashget, but add passed null_node to hash if no existing

180 * node found.

181 */

182 static int

 null_hashins(struct mount * mp, struct null_node * xp, struct vnode ** vpp)

184 {

185 struct null_node_hashhead * hd = NULL;

186 struct null_node * oxp = NULL;

187 struct vnode * ovp = NULL;

188 uint32_t oxp_vid = 0;

189 int error = 0;

190

         hd = NULL_NHASH(xp->null_lowervp);

192 lck_mtx_lock(&null_hashmtx);

         LIST_FOREACH(oxp, hd, null_hash)

194 {

                 if (oxp->null_lowervp == xp->null_lowervp && vnode_mount(NULLTOV(oxp)) == mp) {

196 /*

197 * See null_hashget for a description of this

198 * operation.

199 */

200 ovp = NULLTOV(oxp);

                         if (oxp->null_lowervid != vnode_vid(oxp->null_lowervp)) {

202 /*vp doesn't exist so return null (not sure we are actually gonna catch

203 * recycle right now

204 * This is an exceptional case right now, it suggests the vnode we are

205 * trying to add has been recycled

206 * don't add it.*/

207 error = EIO;

208 ovp = NULL;

209 } else {

210 oxp_vid = oxp->null_myvid;

211 }

212 goto end;

213 }

214 }

215 /* if it wasn't in the hash map then the vnode pointed to by xp already has a

216 * iocount so don't bother */

         LIST_INSERT_HEAD(hd, xp, null_hash);

218 xp->null_flags |= NULL_FLAG_HASHED;

219 end:

220 lck_mtx_unlock(&null_hashmtx);

221 if (ovp != NULL) {

222 /* if we found something in the hash map then grab an iocount */

                 error = vnode_getwithvid(ovp, oxp_vid);

                 if (error == 0) {

225 *vpp = ovp;

226 }

227 }

228 return error;

229 }

230

231 /*

232 * Remove node from hash.

233 */

234 void

 null_hashrem(struct null_node * xp)

236 {

237 lck_mtx_lock(&null_hashmtx);

238 LIST_REMOVE(xp, null_hash);

239 lck_mtx_unlock(&null_hashmtx);

240 }

241

242 static struct null_node *

 null_nodecreate(struct vnode * lowervp)

244 {

245 struct null_node * xp;

246

         MALLOC(xp, struct null_node *, sizeof(struct null_node), M_TEMP, M_WAITOK | M_ZERO);

248 if (xp != NULL) {

249 if (lowervp) {

250 xp->null_lowervp = lowervp;

                         xp->null_lowervid = vnode_vid(lowervp);

252 }

253 }

254 return xp;

255 }

256

257 /* assumption is that vnode has iocount on it after vnode create */

258 int

259 null_getnewvnode(

         struct mount * mp, struct vnode * lowervp, struct vnode * dvp, struct vnode ** vpp, struct componentname * cnp, int root)

261 {

262 struct vnode_fsparam vnfs_param;

263 int error = 0;

264 enum vtype type = VDIR;

         struct null_node * xp = null_nodecreate(lowervp);

266

267 if (xp == NULL) {

268 return ENOMEM;

269 }

270

271 if (lowervp) {

272 type = vnode_vtype(lowervp);

273 }

274

275 vnfs_param.vnfs_mp = mp;

276 vnfs_param.vnfs_vtype = type;

277 vnfs_param.vnfs_str = "nullfs";

278 vnfs_param.vnfs_dvp = dvp;

         vnfs_param.vnfs_fsnode     = (void *)xp;

280 vnfs_param.vnfs_vops = nullfs_vnodeop_p;

281 vnfs_param.vnfs_markroot = root;

282 vnfs_param.vnfs_marksystem = 0;

283 vnfs_param.vnfs_rdev = 0;

         vnfs_param.vnfs_filesize   = 0; // set this to 0 since we should only be shadowing non-regular files

285 vnfs_param.vnfs_cnp = cnp;

286 vnfs_param.vnfs_flags = VNFS_ADDFSREF;

287

         error = vnode_create(VNCREATE_FLAVOR, VCREATESIZE, &vnfs_param, vpp);

         if (error == 0) {

290 xp->null_vnode = *vpp;

                 xp->null_myvid = vnode_vid(*vpp);

292 vnode_settag(*vpp, VT_NULL);

293 } else {

294 FREE(xp, M_TEMP);

295 }

296 return error;

297 }

298

299 /*

300 * Make a new or get existing nullfs node.

301 * Vp is the alias vnode, lowervp is the lower vnode.

302 *

303 * lowervp is assumed to have an iocount on it from the caller

304 */

305 int

306 null_nodeget(

         struct mount * mp, struct vnode * lowervp, struct vnode * dvp, struct vnode ** vpp, struct componentname * cnp, int root)

308 {

309 struct vnode * vp;

310 int error;

311

312 /* Lookup the hash firstly. */

         error = null_hashget(mp, lowervp, vpp);

314 /* ENOENT means it wasn't found, EIO is a failure we should bail from, 0 is it

315 * was found */

316 if (error != ENOENT) {

317 /* null_hashget checked the vid, so if we got something here its legit to

318 * the best of our knowledge*/

319 /* if we found something then there is an iocount on vpp,

320 * if we didn't find something then vpp shouldn't be used by the caller */

321 return error;

322 }

323

324 /*

325 * We do not serialize vnode creation, instead we will check for

326 * duplicates later, when adding new vnode to hash.

327 */

         error = vnode_ref(lowervp); // take a ref on lowervp so we let the system know we care about it

329 if (error) {

330 // Failed to get a reference on the lower vp so bail. Lowervp may be gone already.

331 return error;

332 }

333

         error = null_getnewvnode(mp, lowervp, dvp, &vp, cnp, root);

335

336 if (error) {

337 vnode_rele(lowervp);

338 return error;

339 }

340

341 /*

342 * Atomically insert our new node into the hash or vget existing

343 * if someone else has beaten us to it.

344 */

         error = null_hashins(mp, VTONULL(vp), vpp);

         if (error || *vpp != NULL) {

347 /* recycle will call reclaim which will get rid of the internals */

348 vnode_recycle(vp);

349 vnode_put(vp);

350 /* if we found vpp, then null_hashins put an iocount on it */

351 return error;

352 }

353

354 /* vp has an iocount from null_getnewvnode */

355 *vpp = vp;

356

357 return 0;

358 }