![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to hfs_vnodeops.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / bsd / hfs|
Return to hfs_vnodeops.c CVS log | Up to [Apple XNU] / XNU / bsd / hfs |
1.1 root 1: /*
2: * Copyright (c) 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: /* @(#)hfs_vnodeops.c 3.0
23: *
24: * (c) 1997-1999 Apple Computer, Inc. All Rights Reserved
25: * (c) 1990, 1992 NeXT Computer, Inc. All Rights Reserved
26: *
27: *
28: * hfs_vnodeops.c -- vnode layer for loadable Macintosh file system
29: *
30: * MODIFICATION HISTORY:
31: * 11-Nov-1999 Scott Roberts Does not update if times have not changed (#2409116)
32: * 9-Nov-1999 Scott Roberts Added cluster_close to hfs_fsync(#2398208)
33: * 9-Nov-1999 Don Brady Fix locking bug in hfs_close [#2399157].
34: * 15-Sep-1999 Pat Dirks Changed hfs_setattrlist to allow changing flags on plain-HFS volumes w/o ownership [#2365108];
35: * Changed to use hfs_write_access instead of obsolete hfs_writepermission uniformly throughout.
36: * 7-Sep-1999 Don Brady Add HFS Plus hard-link support.
37: * 8-Sep-1999 Pat Dirks Changed hfs_rename to change mod. date on parent directory [#2297825].
38: * 26-Aug-1999 Pat Dirks Changed hfs_chflags to allow locking on HFS volumes w. write access only as workaround [#2313439].
39: * 2-Sep-1999 Pat Dirks Fixed hfs_pathconf to return same info for hfs/hfs+ for max. name length [#2382208]
40: * 26-Aug-1999 Pat Dirks Changed hfs_chflags to allow locking on HFS volumes w. write access only as workaround [#2313439].
41: * 24-Jul-1999 Earsh Nandkeshwar Rewrote readdirattr.
42: * 15-Jul-1999 Pat Dirks Fixed hfs_readdir to return EINVAL if design assumption of uio->uio_iovcnt�== 1 is violated
43: * and cleaned up call to uiomove to check space available first.
44: * 2-Jul-1999 Pat Dirks Fixed hfs_setattrlist to ignore attempts to set null volume name (#2331829).
45: * 18-May-1999 Don Brady Add support for rooting from HFS Plus.
46: * 4-May-1999 Don Brady Split off hfs_search.c
47: * 15-Apr-1999 Don Brady Change va_nlink back to 1 for directories in hfs_getattr.
48: * 6-Apr-1999 Don Brady Fix deference of NULL h_sibling in hfs_chid.
49: * 29-Mar-1999 Scott Roberts Put in the correct . and .. entries for readdir
50: * 22-Mar-1999 Don Brady Add UFS delete semantic support to hfs_remove.
51: * 1-Mar-1999 Scott Roberts h_meta is now released when the complex vnode is relesed
52: * 26-Feb-1999 Pat Dirks (copied by Chw) Fixed hfs_lookup to check for
53: * error return on vget.
54: * 25-Feb-1999 Pat Dirks Fixed hfs_remove to use a local copy of the h_sibling pointer around vnode_uncache.
55: * 3-Feb-1999 Pat Dirks Changed to stop updating wrapper volume name in MDB since wrapper volume's
56: * catalog isn't updated and this inconsistency trips Disk First Aid's checks.
57: * 22-Jan-1999 Pat Dirks Changed hfs_rename, hfs_remove, and hfs_rmdir to call cache_purge.
58: * 22-Jan-1999 Don Brady After calling hfsMoveRename call hfsLookup to get new name.
59: * 12-Jan-1999 Don Brady Fixed the size of ATTR_CMN_NAME buffer to NAME_MAX + 1.
60: * 8-Jan-1999 Pat Dirks Added hfs_writepermission and change hfs_setattrlist to use it instead of
61: * including an incorrect derivative of hfs_access in-line.
62: * 15-Dec-1998 Pat Dirks Changed setattrlist to do permission checking as appropriate (Radar #2290212).
63: * 17-Nov-1998 Scott Roberts Added support for long volume names in SetAttrList().
64: * 6-Nov-1998 Don Brady Add support for UTF-8 names.
65: * 3-Nov-1998 Umesh Vaishampayan Changes to deal with "struct timespec"
66: * change in the kernel.
67: * 21-Oct-1998 Scott Roberts Added support for advisory locking (Radar #2237914).
68: * 25-Sep-1998 Don Brady Changed hfs_exchange to call hfs_chid after updating catalog (radar #2276605).
69: * 23-Sep-1998 Don Brady hfs_setattrlist now calls hfs_chown and hfs_chmod to change values.
70: * 15-Sep-1998 Pat Dirks Cleaned up vnode unlocking on various error exit paths and changed
71: * to use new error stub routines in place of hfs_mknod and hfs_link.
72: * 16-Sep-1998 Don Brady When renaming a volume in hfs_setattrlist, also update hfs+ wrapper name (radar #2272925).
73: * 1-Sep-1998 Don Brady Fix uninitiazed time variable in hfs_makenode (radar #2270372).
74: * 31-Aug-1998 Don Brady Adjust change time for DST in hfs_update (radar #2265075).
75: * 12-Aug-1998 Don Brady Update complex node name in hfs_rename (radar #2262111).
76: * 5-Aug-1998 Don Brady In hfs_setattrlist call MacToVFSError after calling UpdateCatalogNode (radar #2261247).
77: * 21-Jul-1998 Don Brady Fixed broken preflight in hfs_getattrlist.
78: * 17-Jul-1998 Clark Warner Fixed the one left out case of freeing M_NAMEI in hfs_abort
79: * 13-Jul-1998 Don Brady Add uio_resid preflight check to hfs_search (radar #2251855).
80: * 30-Jun-1998 Scott Roberts Changed hfs_makenode and its callers to free M_NAMEI.
81: * 29-Jun-1998 Don Brady Fix unpacking order in UnpackSearchAttributeBlock (radar #2249248).
82: * 13-Jun-1998 Scott Roberts Integrated changes to hfs_lock (radar #2237243).
83: * 4-Jun-1998 Pat Dirks Split off hfs_lookup.c and hfs_readwrite.c
84: * 3-Jun-1998 Don Brady Fix hfs_rename bugs (radar #2229259, #2239823, 2231108 and #2237380).
85: * Removed extra vputs in hfs_rmdir (radar #2240309).
86: * 28-May-1998 Don Brady Fix hfs_truncate to correctly extend files (radar #2237242).
87: * 20-May-1998 Don Brady In hfs_close shrink the peof to the smallest size neccessary (radar #2230094).
88: * 5-May-1998 Don Brady Fixed typo in hfs_rename (apply H_FILEID macro to VTOH result).
89: * 29-Apr-1998 Joe Sokol Don't do cluster I/O when logical block size is not 4K multiple.
90: * 28-Apr-1998 Pat Dirks Cleaned up unused variable physBlockNo in hfs_write.
91: * 28-Apr-1998 Joe Sokol Touched up support for cluster_read/cluster_write and enabled it.
92: * 27-Apr-1998 Don Brady Remove some DEBUG_BREAK calls in DbgVopTest.
93: * 24-Apr-1998 Pat Dirks Fixed read logic to read-ahead only ONE block, and of only logBlockSize instead of 64K...
94: * Added calls to brelse() on errors from bread[n]().
95: * Changed logic to add overall length field to AttrBlockSize only on attribute return operations.
96: * 23-Apr-1998 Don Brady The hfs_symlink call is only supported on HFS Plus disks.
97: * 23-Apr-1998 Deric Horn Fixed hfs_search bug where matches were skipped when buffer was full.
98: * 22-Apr-1998 Scott Roberts Return on error if catalog mgr returns an error in truncate.
99: * 21-Apr-1998 Don Brady Fix up time/date conversions.
100: * 20-Apr-1998 Don Brady Remove course-grained hfs metadata locking.
101: * 17-Apr-1998 Pat Dirks Officially enabled searchfs in vops table.
102: * 17-Apr-1998 Deric Horn Bug fixes to hfs_search, reenabled searchfs trap for upcoming kernel build.
103: * 15-Apr-1998 Don Brady Add locking for HFS B-trees. Don't lock file meta lock for VSYSTEM files.
104: * Don't call VOP_UPDATE for system files. Roll set_time into hfs_update.
105: * 14-Apr-1998 Pat Dirks Cleaned up fsync to skip complex nodes and not hit sibling nodes.
106: * 14-Apr-1998 Deric Horn Added hfs_search() and related routines for searchfs() support.
107: * 14-Apr-1998 Scott Roberts Fixed paramaters to ExchangeFileIDs()
108: * 13-Apr-1998 Pat Dirks Changed to update H_HINT whenever hfsLookup was called.
109: * 8-Apr-1998 Pat Dirks Added page-in and page-out passthrough routines to keep MapFS happy.
110: * 6-Apr-1998 Pat Dirks Changed hfs_write to clean up code and fix bug that caused
111: * zeroes to be interspersed in data. Added debug printf to hfs_read.
112: * 6-Apr-1998 Scott Roberts Added complex file support.
113: * 02-apr-1998 Don Brady UpdateCatalogNode now takes parID and name as input.
114: * 31-mar-1998 Don Brady Sync up with final HFSVolumes.h header file.
115: * 27-mar-1998 Don Brady Check result from UFSToHFSStr to make sure hfs/hfs+ names are not greater than 31 characters.
116: * 27-mar-1998 chw minor link fixes.
117: * 19-Mar-1998 ser Added hfs_readdirattr.
118: * 17-Mar-1998 ser Removed CheckUserAccess. Added code to implement ExchangeFileIDs
119: * 16-Mar-1998 Pat Dirks Fixed logic in hfs_read to properly account for space
120: * remaining past selected offset and avoid premature panic.
121: * 16-jun-1997 Scott Roberts
122: * Dec-1991 Kevin Wells at NeXT:
123: * Significantly modified for Macintosh file system.
124: * Added support for NFS exportability.
125: * 25-Jun-1990 Doug Mitchell at NeXT:
126: * Created (for DOS file system).
127: */
128:
129: #include <sys/systm.h>
130: #include <sys/kernel.h>
131: #include <sys/file.h>
132: #include <sys/dirent.h>
133: #include <sys/stat.h>
134: #include <sys/buf.h>
135: #include <sys/mount.h>
136: #include <sys/vnode.h>
137: #include <sys/malloc.h>
138: #include <sys/namei.h>
139: #include <sys/attr.h>
140: #include <miscfs/specfs/specdev.h>
141: #include <miscfs/fifofs/fifo.h>
142:
143: #include <machine/spl.h>
144: #include <kern/mapfs.h>
145:
146: #include "hfs.h"
147: #include "hfs_lockf.h"
148: #include "hfs_dbg.h"
149:
150: #include "hfscommon/headers/CatalogPrivate.h"
151: #include "hfscommon/headers/BTreesInternal.h"
152: #include "hfscommon/headers/FileMgrInternal.h"
153: #include "hfscommon/headers/HFSUnicodeWrappers.h"
154:
155: #define OWNERSHIP_ONLY_ATTRS (ATTR_CMN_OWNERID | ATTR_CMN_GRPID | ATTR_CMN_ACCESSMASK | ATTR_CMN_FLAGS)
156:
157: #define MAKE_DELETED_NAME(NAME,FID) \
158: (void) sprintf((NAME), "%s%d", HFS_DELETE_PREFIX, (FID))
159:
160:
161: /* Global vfs data structures for hfs */
162: int (**hfs_vnodeop_p)();
163:
164: /* external routines defined in hfs_vhash.c */
165: extern void hfs_vhashrem(struct hfsnode *hp);
166: extern int vinvalbuf_vhash(register struct vnode *vp, int flags, struct ucred *cred, struct proc *p);
167: extern void hfs_vhashmove( struct hfsnode *hp,UInt32 nodeID);
168:
169: /* external routines defined in vfs_cache.c */
170:
171: void hfs_vhashrem(struct hfsnode *hp);
172:
173: extern OSErr PositionIterator(CatalogIterator *cip, UInt32 offset, BTreeIterator *bip, UInt16 *op);
174:
175: extern void cache_purge (struct vnode *vp);
176: extern int cache_lookup (struct vnode *dvp, struct vnode **vpp, struct componentname *cnp);
177: extern void cache_enter (struct vnode *dvp, struct vnode *vpp, struct componentname *cnp);
178:
179: extern void vnode_pager_setsize( struct vnode *vp, u_long nsize);
180: extern int vnode_uncache( struct vnode *vp);
181:
182: extern cluster_close(struct vnode *vp, int bsize, long secsize);
183:
184: extern void hfs_set_metaname(char *name, struct hfsfilemeta *fm);
185:
186: extern groupmember(gid_t gid, struct ucred *cred);
187:
188: static int hfs_makenode( int mode, dev_t rawdev, struct vnode *dvp, struct vnode **vpp, struct componentname *cnp);
189:
190: static void hfs_chid(struct hfsnode *hp, u_int32_t fid, u_int32_t pid, char* name);
191:
192: static int hfs_write_access(struct vnode *vp, struct ucred *cred, struct proc *p, Boolean considerFlags);
193:
194: static int hfs_chown( struct vnode *vp, uid_t uid, gid_t gid, struct ucred *cred, struct proc *p);
195: static int hfs_chmod( struct vnode *vp, int mode, struct ucred *cred, struct proc *p);
196: static int hfs_chflags( struct vnode *vp, u_long flags, struct ucred *cred, struct proc *p);
197:
198: /*
199: * Enabling cluster read/write operations.
200: */
201: extern int doclusterread;
202: extern int doclusterwrite;
203:
204: int hfs_cache_lookup(); /* in hfs_lookup.c */
205: int hfs_lookup(); /* in hfs_lookup.c */
206: int hfs_read(); /* in hfs_readwrite.c */
207: int hfs_write(); /* in hfs_readwrite.c */
208: int hfs_ioctl(); /* in hfs_readwrite.c */
209: int hfs_select(); /* in hfs_readwrite.c */
210: int hfs_mmap(); /* in hfs_readwrite.c */
211: int hfs_seek(); /* in hfs_readwrite.c */
212: int hfs_bmap(); /* in hfs_readwrite.c */
213: int hfs_strategy(); /* in hfs_readwrite.c */
214: int hfs_reallocblks(); /* in hfs_readwrite.c */
215: int hfs_truncate(); /* in hfs_readwrite.c */
216: int hfs_allocate(); /* in hfs_readwrite.c */
217: int hfs_pagein(); /* in hfs_readwrite.c */
218: int hfs_pageout(); /* in hfs_readwrite.c */
219: int hfs_search(); /* in hfs_search.c */
220: int hfs_link(); /* in hfs_link.c */
221:
222: /*****************************************************************************
223: *
224: * Operations on vnodes
225: *
226: *****************************************************************************/
227:
228: /*
229: * Create a regular file
230: #% create dvp L U U
231: #% create vpp - L -
232: #
233: vop_create {
234: IN WILLRELE struct vnode *dvp;
235: OUT struct vnode **vpp;
236: IN struct componentname *cnp;
237: IN struct vattr *vap;
238:
239: We are responsible for freeing the namei buffer, it is done in hfs_makenode(), unless there is
240: a previous error.
241:
242: */
243:
244: static int
245: hfs_create(ap)
246: struct vop_create_args /* {
247: struct vnode *a_dvp;
248: struct vnode **a_vpp;
249: struct componentname *a_cnp;
250: struct vattr *a_vap;
251: } */ *ap;
252: {
253: struct proc *p = current_proc();
254: int retval;
255: int mode = MAKEIMODE(ap->a_vap->va_type, ap->a_vap->va_mode);
256: DBG_FUNC_NAME("create");
257: DBG_VOP_LOCKS_DECL(2);
258: DBG_VOP_PRINT_FUNCNAME();
259: DBG_VOP_PRINT_VNODE_INFO(ap->a_dvp);
260: DBG_VOP_PRINT_CPN_INFO(ap->a_cnp);
261:
262: DBG_VOP_LOCKS_INIT(0,ap->a_dvp, VOPDBG_LOCKED, VOPDBG_UNLOCKED, VOPDBG_UNLOCKED, VOPDBG_POS);
263: DBG_VOP_LOCKS_INIT(1,*ap->a_vpp, VOPDBG_IGNORE, VOPDBG_LOCKED, VOPDBG_IGNORE, VOPDBG_POS);
264: DBG_VOP_CONT(("\tva_type %d va_mode 0x%x\n",
265: ap->a_vap->va_type, ap->a_vap->va_mode));
266:
267: #if HFS_DIAGNOSTIC
268: DBG_HFS_NODE_CHECK(ap->a_dvp);
269: DBG_ASSERT(ap->a_dvp->v_type == VDIR);
270: if(ap->a_vap == NULL) {
271: panic("NULL attr on create");
272: }
273:
274: switch(ap->a_vap->va_type) {
275: case VDIR:
276: VOP_ABORTOP(ap->a_dvp, ap->a_cnp);
277: VPUT(ap->a_dvp);
278: DBG_VOP_LOCKS_TEST(EISDIR);
279: return (EISDIR); /* use hfs_mkdir instead */
280: case VREG:
281: case VLNK:
282: break;
283: default:
284: DBG_ERR(("%s: INVALID va_type: %d, %s, %s\n", funcname, ap->a_vap->va_type, H_NAME(VTOH(ap->a_dvp)), ap->a_cnp->cn_nameptr));
285: VOP_ABORTOP(ap->a_dvp, ap->a_cnp);
286: VPUT(ap->a_dvp);
287: DBG_VOP_LOCKS_TEST(EINVAL);
288: return (EINVAL);
289: }
290: // if(ap->a_vap->va_mode & (VSUID | VSGID | VSVTX)) {
291: // DBG_ERR(("%s: INVALID va_mode (%o): %s, %s\n", funcname, ap->a_vap->va_mode, H_NAME(VTOH(ap->a_dvp)), ap->a_cnp->cn_nameptr));
292: // DBG_VOP_LOCKS_TEST(EINVAL);
293: // VOP_ABORTOP(ap->a_dvp, ap->a_cnp);
294: // VPUT(ap->a_dvp);
295: // return (EINVAL); /* Can't do these */
296: // };
297: #endif
298:
299: /* lock catalog b-tree */
300: retval = hfs_metafilelocking(VTOHFS(ap->a_dvp), kHFSCatalogFileID, LK_EXCLUSIVE, p);
301: if (retval != E_NONE) {
302: VOP_ABORTOP(ap->a_dvp, ap->a_cnp);
303: VPUT(ap->a_dvp);
304: DBG_VOP_LOCKS_TEST( retval);
305: return (retval);
306: }
307:
308: /* Create the vnode */
309: retval = hfs_makenode(mode, 0, ap->a_dvp, ap->a_vpp, ap->a_cnp);
310: DBG_VOP_UPDATE_VP(1, *ap->a_vpp);
311:
312: /* unlock catalog b-tree */
313: (void) hfs_metafilelocking(VTOHFS(ap->a_dvp), kHFSCatalogFileID, LK_RELEASE, p);
314:
315: if (retval != E_NONE) {
316: DBG_ERR(("%s: hfs_makenode FAILED: %s, %s\n", funcname, ap->a_cnp->cn_nameptr, H_NAME(VTOH(ap->a_dvp))));
317: }
318: DBG_VOP_LOCKS_TEST(retval);
319: return (retval);
320: }
321:
322:
323: /*
324: * Mknod vnode call
325:
326: #% mknod dvp L U U
327: #% mknod vpp - X -
328: #
329: vop_mknod {
330: IN WILLRELE struct vnode *dvp;
331: OUT WILLRELE struct vnode **vpp;
332: IN struct componentname *cnp;
333: IN struct vattr *vap;
334: */
335: /* ARGSUSED */
336:
337: static int
338: hfs_mknod(ap)
339: struct vop_mknod_args /* {
340: struct vnode *a_dvp;
341: struct vnode **a_vpp;
342: struct componentname *a_cnp;
343: struct vattr *a_vap;
344: } */ *ap;
345: {
346: struct vattr *vap = ap->a_vap;
347: struct vnode **vpp = ap->a_vpp;
348: struct proc *p = current_proc();
349: dev_t rawdev = 0;
350: int error;
351:
352: if (VTOVCB(ap->a_dvp)->vcbSigWord != kHFSPlusSigWord) {
353: VOP_ABORTOP(ap->a_dvp, ap->a_cnp);
354: VPUT(ap->a_dvp);
355: return (EOPNOTSUPP);
356: }
357:
358: if (vap->va_rdev != VNOVAL) {
359: /*
360: * Want to be able to use this to make badblock
361: * inodes, so don't truncate the dev number.
362: */
363: rawdev = vap->va_rdev;
364: }
365:
366: /* lock catalog b-tree */
367: error = hfs_metafilelocking(VTOHFS(ap->a_dvp), kHFSCatalogFileID, LK_EXCLUSIVE, p);
368: if (error != E_NONE) {
369: VOP_ABORTOP(ap->a_dvp, ap->a_cnp);
370: VPUT(ap->a_dvp);
371: return (error);
372: }
373:
374: /* Create the vnode */
375: error = hfs_makenode(MAKEIMODE(vap->va_type, vap->va_mode), rawdev, ap->a_dvp, vpp, ap->a_cnp);
376:
377: /* unlock catalog b-tree */
378: (void) hfs_metafilelocking(VTOHFS(ap->a_dvp), kHFSCatalogFileID, LK_RELEASE, p);
379:
380: if (error != E_NONE) {
381: return (error);
382: }
383:
384: /*
385: * Remove inode so that it will be reloaded by lookup and
386: * checked to see if it is an alias of an existing vnode.
387: * Note: unlike UFS, we don't bash v_type here.
388: */
389: VPUT(*vpp);
390: vgone(*vpp);
391: *vpp = 0;
392: return (0);
393: }
394:
395:
396: /*
397: * mkcomplex vnode call
398: *
399:
400: #% mkcomplex dvp L U U
401: #% mkcomplex vpp - L -
402: #
403: vop_mkcomplex {
404: IN WILLRELE struct vnode *dvp;
405: OUT struct vnode **vpp;
406: IN struct componentname *cnp;
407: IN struct vattr *vap;
408: IN u_long type;
409: }
410:
411: */
412:
413: static int
414: hfs_mkcomplex(ap)
415: struct vop_mkcomplex_args /* {
416: struct vnode *a_dvp;
417: struct vnode **a_vpp;
418: struct componentname *a_cnp;
419: struct vattr *a_vap;
420: u_long a_type;
421: } */ *ap;
422: {
423: int retval = E_NONE;
424: DBG_FUNC_NAME("make_complex");
425: DBG_VOP_LOCKS_DECL(2);
426: DBG_VOP_PRINT_FUNCNAME();
427: DBG_VOP_PRINT_VNODE_INFO(ap->a_dvp);
428: DBG_VOP_PRINT_CPN_INFO(ap->a_cnp);DBG_VOP_CONT(("\n"));
429:
430: DBG_VOP_LOCKS_INIT(0,ap->a_dvp, VOPDBG_LOCKED, VOPDBG_UNLOCKED, VOPDBG_UNLOCKED, VOPDBG_POS);
431: DBG_VOP_LOCKS_INIT(1,*ap->a_vpp, VOPDBG_IGNORE, VOPDBG_LOCKED, VOPDBG_IGNORE, VOPDBG_POS);
432:
433: retval = VOP_CREATE(ap->a_dvp, ap->a_vpp, ap->a_cnp, ap->a_vap);
434:
435: DBG_VOP_LOCKS_TEST(retval);
436: return retval;
437: }
438:
439:
440: /*
441: * Open called.
442: #% open vp L L L
443: #
444: vop_open {
445: IN struct vnode *vp;
446: IN int mode;
447: IN struct ucred *cred;
448: IN struct proc *p;
449: */
450:
451:
452: static int
453: hfs_open(ap)
454: struct vop_open_args /* {
455: struct vnode *a_vp;
456: int a_mode;
457: struct ucred *a_cred;
458: struct proc *a_p;
459: } */ *ap;
460: {
461: struct hfsnode *hp = VTOH(ap->a_vp);
462: int retval = E_NONE;
463: DBG_FUNC_NAME("open");
464: DBG_VOP_LOCKS_DECL(1);
465: DBG_VOP_PRINT_FUNCNAME();
466: DBG_VOP_CONT((" "));DBG_VOP_PRINT_VNODE_INFO(ap->a_vp);DBG_VOP_CONT(("\n"));
467: DBG_VOP_LOCKS_INIT(0,ap->a_vp, VOPDBG_LOCKED, VOPDBG_LOCKED, VOPDBG_LOCKED, VOPDBG_POS);
468:
469: if (ap->a_vp->v_type == VREG) /* Only files */
470: {
471: /*
472: * Files marked append-only must be opened for appending.
473: */
474: if ((hp->h_meta->h_pflags & APPEND) &&
475: (ap->a_mode & (FWRITE | O_APPEND)) == FWRITE)
476: retval = EPERM;
477: }
478:
479:
480: DBG_VOP_LOCKS_TEST(retval);
481: return (retval);
482: }
483:
484: /*
485: * Close called.
486: *
487: * Update the times on the hfsnode.
488: #% close vp U U U
489: #
490: vop_close {
491: IN struct vnode *vp;
492: IN int fflag;
493: IN struct ucred *cred;
494: IN struct proc *p;
495: */
496:
497:
498: static int
499: hfs_close(ap)
500: struct vop_close_args /* {
501: struct vnode *a_vp;
502: int a_fflag;
503: struct ucred *a_cred;
504: struct proc *a_p;
505: } */ *ap;
506: {
507: register struct vnode *vp = ap->a_vp;
508: struct hfsnode *hp = VTOH(vp);
509: struct proc *p = ap->a_p;
510: FCB *fcb;
511: struct timeval tv;
512: off_t leof;
513: u_long blks, blocksize;
514: int retval = E_NONE;
515:
516: DBG_FUNC_NAME("close");
517: DBG_VOP_LOCKS_DECL(1);
518: DBG_VOP_PRINT_FUNCNAME();
519: DBG_VOP_CONT((" "));DBG_VOP_PRINT_VNODE_INFO(ap->a_vp);DBG_VOP_CONT(("\n"));
520: DBG_VOP_LOCKS_INIT(0,ap->a_vp, VOPDBG_UNLOCKED, VOPDBG_UNLOCKED, VOPDBG_UNLOCKED, VOPDBG_POS);
521:
522: simple_lock(&vp->v_interlock);
523: if (vp->v_usecount > 1) {
524: tv = time;
525: HFSTIMES(hp, &tv, &tv);
526: }
527: simple_unlock(&vp->v_interlock);
528:
529: /*
530: * VOP_CLOSE can be called with vp locked (from vclean).
531: * We check for this case using VOP_ISLOCKED and bail.
532: *
533: * also, ignore complex nodes; there's no data associated with them.
534: */
535: if (H_FORKTYPE(hp) == kDirectory || VOP_ISLOCKED(vp)) {
536: DBG_VOP_LOCKS_TEST(E_NONE);
537: return E_NONE;
538: };
539:
540: fcb = HTOFCB(hp);
541: leof = fcb->fcbEOF;
542:
543: if (leof != 0) {
544: enum vtype our_type = vp->v_type;
545: u_long our_id = vp->v_id;
546:
547: vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
548: /*
549: * Since we can contact switch in vn_lock our vnode
550: * could get recycled (eg umount -f). Double check
551: * that its still ours.
552: */
553: if (vp->v_type != our_type || vp->v_id != our_id) {
554: VOP_UNLOCK(vp, 0, p);
555: DBG_VOP_LOCKS_TEST(E_NONE);
556: return(E_NONE);
557: }
558:
559: blocksize = HTOVCB(hp)->blockSize;
560: blks = leof / blocksize;
561: if ((blks * blocksize) != leof)
562: blks++;
563:
564: /*
565: * Shrink the peof to the smallest size neccessary to contain the leof.
566: */
567: if ((blks * blocksize) < fcb->fcbPLen) {
568: retval = VOP_TRUNCATE(vp, leof, 0, ap->a_cred, p);
569: }
570:
571: if (doclusterwrite) {
572: long devBlockSize = 0;
573:
574: VOP_DEVBLOCKSIZE(hp->h_meta->h_devvp, &devBlockSize);
575: cluster_close(vp, PAGE_SIZE, devBlockSize);
576: }
577:
578: VOP_UNLOCK(vp, 0, p);
579: }
580:
581: DBG_VOP_LOCKS_TEST(retval);
582: return (retval);
583: }
584:
585: /*
586: #% access vp L L L
587: #
588: vop_access {
589: IN struct vnode *vp;
590: IN int mode;
591: IN struct ucred *cred;
592: IN struct proc *p;
593:
594: */
595:
596: static int
597: hfs_access(ap)
598: struct vop_access_args /* {
599: struct vnode *a_vp;
600: int a_mode;
601: struct ucred *a_cred;
602: struct proc *a_p;
603: } */ *ap;
604: {
605: struct vnode *vp = ap->a_vp;
606: struct ucred *cred = ap->a_cred;
607: struct hfsnode *hp = VTOH(vp);
608: ExtendedVCB *vcb = HTOVCB(hp);
609: register gid_t *gp;
610: mode_t mask, mode;
611: Boolean isHFSPlus;
612: int retval = E_NONE;
613: int i;
614: DBG_FUNC_NAME("access");
615: DBG_VOP_LOCKS_DECL(1);
616: // DBG_VOP_PRINT_FUNCNAME();
617: // DBG_VOP_PRINT_VNODE_INFO(ap->a_vp);DBG_VOP_CONT(("\n"));
618:
619: DBG_VOP_LOCKS_INIT(0,ap->a_vp, VOPDBG_LOCKED, VOPDBG_LOCKED, VOPDBG_LOCKED, VOPDBG_POS);
620:
621: mode = ap->a_mode;
622: isHFSPlus = (vcb->vcbSigWord == kHFSPlusSigWord );
623:
624: /*
625: * Disallow write attempts on read-only file systems;
626: * unless the file is a socket, fifo, or a block or
627: * character device resident on the file system.
628: */
629: if (mode & VWRITE) {
630: switch (vp->v_type) {
631: case VDIR:
632: case VLNK:
633: case VREG:
634: if (VTOVFS(vp)->mnt_flag & MNT_RDONLY)
635: return (EROFS);
636: break;
637: default:
638: break;
639: }
640: }
641:
642: /* If immutable bit set, nobody gets to write it. */
643: if ((mode & VWRITE) && (hp->h_meta->h_pflags & IMMUTABLE))
644: return (EPERM);
645:
646: /* Otherwise, user id 0 always gets access. */
647: if (ap->a_cred->cr_uid == 0) {
648: retval = 0;
649: goto Exit;
650: };
651:
652: mask = 0;
653:
654: /* Otherwise, check the owner. */
655: if (cred->cr_uid == hp->h_meta->h_uid) {
656: if (mode & VEXEC)
657: mask |= S_IXUSR;
658: if (mode & VREAD)
659: mask |= S_IRUSR;
660: if (mode & VWRITE)
661: mask |= S_IWUSR;
662: retval = ((hp->h_meta->h_mode & mask) == mask ? 0 : EACCES);
663: goto Exit;
664: }
665:
666: /* Otherwise, check the groups. */
667: for (i = 0, gp = cred->cr_groups; i < cred->cr_ngroups; i++, gp++)
668: if (hp->h_meta->h_gid == *gp) {
669: if (mode & VEXEC)
670: mask |= S_IXGRP;
671: if (mode & VREAD)
672: mask |= S_IRGRP;
673: if (mode & VWRITE)
674: mask |= S_IWGRP;
675: retval = ((hp->h_meta->h_mode & mask) == mask ? 0 : EACCES);
676: goto Exit;
677: }
678:
679: /* Otherwise, check everyone else. */
680: if (mode & VEXEC)
681: mask |= S_IXOTH;
682: if (mode & VREAD)
683: mask |= S_IROTH;
684: if (mode & VWRITE)
685: mask |= S_IWOTH;
686: retval = ((hp->h_meta->h_mode & mask) == mask ? 0 : EACCES);
687:
688: Exit:
689: DBG_VOP_LOCKS_TEST(retval);
690: return (retval);
691: }
692:
693:
694:
695: /*
696: #% getattr vp = = =
697: #
698: vop_getattr {
699: IN struct vnode *vp;
700: IN struct vattr *vap;
701: IN struct ucred *cred;
702: IN struct proc *p;
703:
704: */
705:
706:
707: /* ARGSUSED */
708: static int
709: hfs_getattr(ap)
710: struct vop_getattr_args /* {
711: struct vnode *a_vp;
712: struct vattr *a_vap;
713: struct ucred *a_cred;
714: struct proc *a_p;
715: } */ *ap;
716: {
717: register struct vnode *vp = ap->a_vp;
718: register struct hfsnode *hp = VTOH(vp);
719: register struct vattr *vap = ap->a_vap;
720: struct timeval tv;
721: DBG_FUNC_NAME("getattr");
722: DBG_VOP_LOCKS_DECL(1);
723: DBG_VOP_PRINT_FUNCNAME();
724: DBG_VOP_PRINT_VNODE_INFO(ap->a_vp);DBG_VOP_CONT(("\n"));
725:
726: DBG_VOP_LOCKS_INIT(0,ap->a_vp, VOPDBG_SAME, VOPDBG_SAME, VOPDBG_SAME, VOPDBG_POS);
727:
728: DBG_HFS_NODE_CHECK(ap->a_vp);
729:
730: tv = time;
731: HFSTIMES(hp, &tv, &tv);
732:
733: vap->va_fsid = H_DEV(hp);
734: vap->va_fileid = H_FILEID(hp);
735: vap->va_mode = hp->h_meta->h_mode;
736: vap->va_uid = hp->h_meta->h_uid;
737: vap->va_gid = hp->h_meta->h_gid;
738: vap->va_rdev = hp->h_meta->h_rdev;
739: #if MACH_NBC
740: if ((vp->v_type == VREG) && vp->v_vm_info && vp->v_vm_info->mapped &&
741: (!vp->v_vm_info->filesize)) {
742: vap->va_size = vp->v_vm_info->vnode_size;
743: }
744: else
745: #endif /* MACH_NBC */
746: if (vp->v_type == VDIR) {
747: vap->va_size = hp->h_meta->h_size;
748: vap->va_bytes = 0;
749: vap->va_nlink = 2 + hp->h_meta->h_valence;
750: /*
751: * account for hidden data nodes directory
752: */
753: if ((H_FILEID(hp) == kRootDirID) &&
754: (VTOHFS(vp)->hfs_private_metadata_dir != 0)) {
755: vap->va_size -= AVERAGE_HFSDIRENTRY_SIZE;
756: vap->va_nlink--;
757: }
758: }
759: else {
760: vap->va_size = hp->fcbEOF;
761: vap->va_bytes = hp->h_meta->h_size;
762:
763: if (hp->h_meta->h_metaflags & IN_DELETED)
764: vap->va_nlink = 0;
765: #if HFS_HARDLINKS
766: else if ((hp->h_meta->h_metaflags & IN_DATANODE) &&
767: (hp->h_meta->h_nlink > 0))
768: vap->va_nlink = hp->h_meta->h_nlink;
769: #endif
770: else
771: vap->va_nlink = 1;
772:
773: }
774:
775: vap->va_atime.tv_nsec = 0;
776: vap->va_atime.tv_sec = hp->h_meta->h_atime;
777: vap->va_mtime.tv_nsec = 0;
778: vap->va_mtime.tv_sec = hp->h_meta->h_mtime;
779: vap->va_ctime.tv_nsec = 0;
780: vap->va_ctime.tv_sec = hp->h_meta->h_ctime;
781: vap->va_flags = hp->h_meta->h_pflags;
782: vap->va_gen = 0;
783: /* this doesn't belong here */
784: if (vp->v_type == VBLK)
785: vap->va_blocksize = BLKDEV_IOSIZE;
786: else if (vp->v_type == VCHR)
787: vap->va_blocksize = MAXPHYSIO;
788: else
789: vap->va_blocksize = VTOVFS(vp)->mnt_stat.f_iosize;
790: vap->va_type = vp->v_type;
791: vap->va_filerev = 0;
792:
793: DBG_VOP_LOCKS_TEST(E_NONE);
794: return (E_NONE);
795: }
796:
797: /*
798: * Set attribute vnode op. called from several syscalls
799: #% setattr vp L L L
800: #
801: vop_setattr {
802: IN struct vnode *vp;
803: IN struct vattr *vap;
804: IN struct ucred *cred;
805: IN struct proc *p;
806:
807: */
808:
809: static int
810: hfs_setattr(ap)
811: struct vop_setattr_args /* {
812: struct vnode *a_vp;
813: struct vattr *a_vap;
814: struct ucred *a_cred;
815: struct proc *a_p;
816: } */ *ap;
817: {
818: struct vnode *vp = ap->a_vp;
819: struct hfsnode *hp = VTOH(vp);
820: struct vattr *vap = ap->a_vap;
821: struct ucred *cred = ap->a_cred;
822: struct proc *p = ap->a_p;
823: struct timeval atimeval, mtimeval;
824: int retval;
825: DBG_FUNC_NAME("setattr");
826: DBG_VOP_LOCKS_DECL(1);
827: DBG_VOP_PRINT_FUNCNAME();
828: DBG_VOP_PRINT_VNODE_INFO(ap->a_vp);DBG_VOP_CONT(("\n"));
829: DBG_VOP_LOCKS_INIT(0,ap->a_vp, VOPDBG_LOCKED, VOPDBG_LOCKED, VOPDBG_LOCKED, VOPDBG_POS);
830: WRITE_CK(vp, funcname);
831: DBG_HFS_NODE_CHECK(ap->a_vp);
832:
833: /*
834: * Check for unsettable attributes.
835: */
836: if ((vap->va_type != VNON) || (vap->va_nlink != VNOVAL) ||
837: (vap->va_fsid != VNOVAL) || (vap->va_fileid != VNOVAL) ||
838: (vap->va_blocksize != VNOVAL) || (vap->va_rdev != VNOVAL) ||
839: ((int)vap->va_bytes != VNOVAL) || (vap->va_gen != VNOVAL)) {
840: retval = EINVAL;
841: goto ErrorExit;
842: }
843:
844: if (vap->va_flags != VNOVAL) {
845: if (VTOVFS(vp)->mnt_flag & MNT_RDONLY) {
846: retval = EROFS;
847: goto ErrorExit;
848: };
849: if ((retval = hfs_chflags(vp, vap->va_flags, cred, p))) {
850: goto ErrorExit;
851: };
852: if (vap->va_flags & (IMMUTABLE | APPEND)) {
853: retval = 0;
854: goto ErrorExit;
855: };
856: }
857:
858: if (hp->h_meta->h_pflags & (IMMUTABLE | APPEND)) {
859: retval = EPERM;
860: goto ErrorExit;
861: };
862: /*
863: * Go through the fields and update iff not VNOVAL.
864: */
865: if (vap->va_uid != (uid_t)VNOVAL || vap->va_gid != (gid_t)VNOVAL) {
866: if (VTOVFS(vp)->mnt_flag & MNT_RDONLY) {
867: retval = EROFS;
868: goto ErrorExit;
869: };
870: if ((retval = hfs_chown(vp, vap->va_uid, vap->va_gid, cred, p))) {
871: goto ErrorExit;
872: };
873: }
874: if (vap->va_size != VNOVAL) {
875: /*
876: * Disallow write attempts on read-only file systems;
877: * unless the file is a socket, fifo, or a block or
878: * character device resident on the file system.
879: */
880: switch (vp->v_type) {
881: case VDIR:
882: retval = EISDIR;
883: goto ErrorExit;
884: case VLNK:
885: case VREG:
886: if (VTOVFS(vp)->mnt_flag & MNT_RDONLY) {
887: retval = EROFS;
888: goto ErrorExit;
889: };
890: break;
891: default:
892: break;
893: }
894: if ((retval = VOP_TRUNCATE(vp, vap->va_size, 0, cred, p))) {
895: goto ErrorExit;
896: };
897: }
898: hp = VTOH(vp);
899: if (vap->va_atime.tv_sec != VNOVAL || vap->va_mtime.tv_sec != VNOVAL) {
900: if (VTOVFS(vp)->mnt_flag & MNT_RDONLY) {
901: retval = EROFS;
902: goto ErrorExit;
903: };
904: if (cred->cr_uid != hp->h_meta->h_uid &&
905: (retval = suser(cred, &p->p_acflag)) &&
906: ((vap->va_vaflags & VA_UTIMES_NULL) == 0 ||
907: (retval = VOP_ACCESS(vp, VWRITE, cred, p)))) {
908: goto ErrorExit;
909: };
910: if (vap->va_atime.tv_sec != VNOVAL)
911: hp->h_nodeflags |= IN_ACCESS;
912: if (vap->va_mtime.tv_sec != VNOVAL)
913: hp->h_nodeflags |= IN_CHANGE | IN_UPDATE;
914: atimeval.tv_sec = vap->va_atime.tv_sec;
915: atimeval.tv_usec = 0;
916: mtimeval.tv_sec = vap->va_mtime.tv_sec;
917: mtimeval.tv_usec = 0;
918: if ((retval = VOP_UPDATE(vp, &atimeval, &mtimeval, 1))) {
919: goto ErrorExit;
920: };
921: }
922: retval = 0;
923: if (vap->va_mode != (mode_t)VNOVAL) {
924: if (VTOVFS(vp)->mnt_flag & MNT_RDONLY) {
925: retval = EROFS;
926: goto ErrorExit;
927: };
928: retval = hfs_chmod(vp, (int)vap->va_mode, cred, p);
929: };
930:
931: ErrorExit: ;
932:
933: DBG_VOP(("hfs_setattr: returning %d...\n", retval));
934: DBG_VOP_LOCKS_TEST(retval);
935: return (retval);
936: }
937:
938:
939: /*
940:
941: #
942: #% getattrlist vp = = =
943: #
944: vop_getattrlist {
945: IN struct vnode *vp;
946: IN struct attrlist *alist;
947: INOUT struct uio *uio;
948: IN struct ucred *cred;
949: IN struct proc *p;
950: };
951:
952: */
953:
954: static int
955: hfs_getattrlist(ap)
956: struct vop_getattrlist_args /* {
957: struct vnode *a_vp;
958: struct attrlist *a_alist
959: struct uio *a_uio;
960: struct ucred *a_cred;
961: struct proc *a_p;
962: } */ *ap;
963: {
964: struct vnode *vp = ap->a_vp;
965: struct hfsnode *hp = VTOH(vp);
966: struct attrlist *alist = ap->a_alist;
967: int error = 0;
968: struct hfsCatalogInfo catalogInfo;
969: struct hfsCatalogInfo *catInfoPtr = NULL;
970: int fixedblocksize;
971: int attrblocksize;
972: int attrbufsize;
973: void *attrbufptr;
974: void *attrptr;
975: void *varptr;
976: u_int32_t fileID;
977: DBG_FUNC_NAME("getattrlist");
978: DBG_VOP_LOCKS_DECL(1);
979:
980: DBG_VOP_LOCKS_INIT(0,ap->a_vp, VOPDBG_SAME, VOPDBG_SAME, VOPDBG_SAME, VOPDBG_POS);
981: DBG_HFS_NODE_CHECK(ap->a_vp);
982: DBG_VOP(("%s: Common attr:0x%lx, buff size Ox%lX,\n",funcname, (u_long)alist->commonattr,(u_long)ap->a_uio->uio_resid));
983:
984: DBG_ASSERT(ap->a_uio->uio_rw == UIO_READ);
985:
986: if ((alist->bitmapcount != ATTR_BIT_MAP_COUNT) ||
987: ((alist->commonattr & ~ATTR_CMN_VALIDMASK) != 0) ||
988: ((alist->volattr & ~ATTR_VOL_VALIDMASK) != 0) ||
989: ((alist->dirattr & ~ATTR_DIR_VALIDMASK) != 0) ||
990: ((alist->fileattr & ~ATTR_FILE_VALIDMASK) != 0) ||
991: ((alist->forkattr & ~ATTR_FORK_VALIDMASK) != 0)) {
992: DBG_ERR(("%s: bad attrlist\n", funcname));
993: DBG_VOP_LOCKS_TEST(EINVAL);
994: return EINVAL;
995: };
996:
997: /* Requesting volume information requires setting the ATTR_VOL_INFO bit and
998: volume info requests are mutually exclusive with all other info requests: */
999: if ((alist->volattr != 0) && (((alist->volattr & ATTR_VOL_INFO) == 0) ||
1000: (alist->dirattr != 0) || (alist->fileattr != 0) || (alist->forkattr != 0)
1001: )) {
1002: DBG_ERR(("%s: conflicting information requested\n", funcname));
1003: DBG_VOP_LOCKS_TEST(EINVAL);
1004: return EINVAL;
1005: };
1006:
1007: /* Reject requests for unsupported options for now: */
1008: if ((alist->commonattr & (ATTR_CMN_NAMEDATTRCOUNT | ATTR_CMN_NAMEDATTRLIST)) ||
1009: (alist->fileattr & (ATTR_FILE_FILETYPE | ATTR_FILE_FORKCOUNT | ATTR_FILE_FORKLIST))) {
1010: DBG_ERR(("%s: illegal bits in attlist\n", funcname));
1011: DBG_VOP_LOCKS_TEST(EINVAL);
1012: return EINVAL;
1013: };
1014:
1015: /* Requesting volume information requires root vnode */
1016: if ((alist->volattr) && (H_FILEID(hp) != kRootDirID)) {
1017: DBG_ERR(("%s: not root vnode\n", funcname));
1018: DBG_VOP_LOCKS_TEST(EINVAL);
1019: return EINVAL;
1020: };
1021:
1022: /* If a FileID (ATTR_CMN_OBJPERMANENTID) is requested on an HFS volume we must be sure
1023: to create the thread record before returning it:
1024: */
1025: if ((vp->v_type == VREG) &&
1026: (alist->commonattr & ATTR_CMN_OBJPERMANENTID)) {
1027: /* Only HFS-Plus volumes are guaranteed to have a thread record in place already: */
1028: if (VTOVCB(vp)->vcbSigWord != kHFSPlusSigWord) {
1029: /* Create a thread record and return the FileID [which is the file's fileNumber] */
1030: /* lock catalog b-tree */
1031: error = hfs_metafilelocking(VTOHFS(vp), kHFSCatalogFileID, LK_EXCLUSIVE, ap->a_p);
1032: error = hfsCreateFileID(VTOVCB(vp), H_DIRID(hp), H_NAME(hp), H_HINT(hp), &fileID);
1033: (void) hfs_metafilelocking(VTOHFS(vp), kHFSCatalogFileID, LK_RELEASE, ap->a_p);
1034: if (error) {
1035: DBG_VOP_LOCKS_TEST(error);
1036: DBG_ERR(("hfs_getattrlist: error %d on CreateFileIDRef.\n", error));
1037: return error;
1038: };
1039: DBG_ASSERT(fileID == H_FILEID(hp));
1040: };
1041: };
1042:
1043: /*
1044: * Avoid unnecessary catalog lookups for volume info which is available directly
1045: * in the VCB and root vnode, or can be synthesized.
1046: */
1047: if (((alist->volattr == 0) && ((alist->commonattr & HFS_ATTR_CMN_LOOKUPMASK) != 0)) ||
1048: ((alist->dirattr & HFS_ATTR_DIR_LOOKUPMASK) != 0) ||
1049: ((alist->fileattr & HFS_ATTR_FILE_LOOKUPMASK) != 0)) {
1050:
1051: /* lock catalog b-tree */
1052: error = hfs_metafilelocking(VTOHFS(vp), kHFSCatalogFileID, LK_SHARED, ap->a_p);
1053: if (error) {
1054: DBG_VOP_LOCKS_TEST(error);
1055: return (error);
1056: }
1057:
1058: if (alist->volattr != 0) {
1059: /* Look up the root info, regardless of the vnode provided */
1060: catalogInfo.hint = kNoHint;
1061: error = hfsLookup(VTOVCB(vp), 2, NULL, -1, &catalogInfo);
1062: } else {
1063: catalogInfo.hint = kNoHint;
1064: error = hfsLookup(VTOVCB(vp), H_DIRID(hp), H_NAME(hp), -1, &catalogInfo);
1065: if (error == 0) H_HINT(hp) = catalogInfo.hint; /* Remember the last valid hint */
1066: };
1067: catInfoPtr = &catalogInfo;
1068:
1069: /* unlock catalog b-tree */
1070: (void) hfs_metafilelocking(VTOHFS(vp), kHFSCatalogFileID, LK_RELEASE, ap->a_p);
1071: };
1072:
1073: fixedblocksize = AttributeBlockSize(alist);
1074: attrblocksize = fixedblocksize + (sizeof(u_long)); /* u_long for length longword */
1075: if (alist->commonattr & ATTR_CMN_NAME) attrblocksize += NAME_MAX + 1;
1076: if (alist->commonattr & ATTR_CMN_NAMEDATTRLIST) attrblocksize += 0; /* XXX PPD */
1077: if (alist->volattr & ATTR_VOL_MOUNTPOINT) attrblocksize += PATH_MAX;
1078: if (alist->volattr & ATTR_VOL_NAME) attrblocksize += NAME_MAX + 1;
1079: if (alist->fileattr & ATTR_FILE_FORKLIST) attrblocksize += 0; /* XXX PPD */
1080:
1081: attrbufsize = MIN(ap->a_uio->uio_resid, attrblocksize);
1082: DBG_VOP(("hfs_getattrlist: allocating Ox%X byte buffer (Ox%X + Ox%X) for attributes...\n",
1083: attrblocksize,
1084: fixedblocksize,
1085: attrblocksize - fixedblocksize));
1086: MALLOC(attrbufptr, void *, attrblocksize, M_TEMP, M_WAITOK);
1087: attrptr = attrbufptr;
1088: *((u_long *)attrptr) = 0; /* Set buffer length in case of errors */
1089: ++((u_long *)attrptr); /* Reserve space for length field */
1090: varptr = ((char *)attrptr) + fixedblocksize; /* Point to variable-length storage */
1091: DBG_VOP(("hfs_getattrlist: attrptr = 0x%08X, varptr = 0x%08X...\n", (u_int)attrptr, (u_int)varptr));
1092:
1093: PackAttributeBlock(alist, vp, catInfoPtr, &attrptr, &varptr);
1094: attrbufsize = MIN(attrbufsize, (u_int)varptr - (u_int)attrbufptr); /* Don't copy out more data than was generated */
1095: DBG_VOP(("hfs_getattrlist: copying Ox%X bytes to user address 0x%08X.\n", attrbufsize, (u_int)ap->a_uio->uio_iov->iov_base));
1096: error = uiomove((caddr_t)attrbufptr, attrbufsize, ap->a_uio);
1097: if (error != E_NONE) {
1098: DBG_ERR(("hfs_getattrlist: error %d on uiomove.\n", error));
1099: };
1100:
1101: FREE(attrbufptr, M_TEMP);
1102:
1103: DBG_VOP_LOCKS_TEST(error);
1104: return error;
1105: }
1106:
1107:
1108:
1109: #if 0 // OBSOLETE
1110: /* This is a special permission-checking routine that tests for "write" access without
1111: regard for the UF_IMMUTABLE or SF_IMMUTABLE bits in the flags. hfs_setattrlist cannot
1112: use VOP_ACCESS for this check so this is a derivative of that code that does this check.
1113: */
1114: static int hfs_writepermission(struct vnode *vp, struct ucred *cred, struct proc *p) {
1115: struct hfsnode *hp = VTOH(vp);
1116: int i;
1117: register gid_t *gp;
1118:
1119: /* Start by checking for root */
1120: if (suser(cred, &p->p_acflag) == 0) return 0;
1121:
1122: /* Check the owner: */
1123: if (cred->cr_uid == hp->h_meta->h_uid) {
1124: return (hp->h_meta->h_mode & S_IWUSR) ? 0 : EACCES;
1125: };
1126:
1127: /* Otherwise, check the groups: */
1128: for (i = 0, gp = cred->cr_groups; i < cred->cr_ngroups; i++, gp++) {
1129: if (hp->h_meta->h_gid == *gp) {
1130: return (hp->h_meta->h_mode & S_IWGRP) ? 0 : EACCES;
1131: };
1132: };
1133:
1134: /* Otherwise, check everyone else. */
1135: return (hp->h_meta->h_mode & S_IWOTH) ? 0 : EACCES;
1136: }
1137: #endif
1138:
1139:
1140:
1141: /*
1142:
1143: #
1144: #% setattrlist vp L L L
1145: #
1146: vop_setattrlist {
1147: IN struct vnode *vp;
1148: IN struct attrlist *alist;
1149: INOUT struct uio *uio;
1150: IN struct ucred *cred;
1151: IN struct proc *p;
1152: };
1153:
1154: */
1155:
1156: static int
1157: hfs_setattrlist(ap)
1158: struct vop_setattrlist_args /* {
1159: struct vnode *a_vp;
1160: struct attrlist *a_alist
1161: struct uio *a_uio;
1162: struct ucred *a_cred;
1163: struct proc *a_p;
1164: } */ *ap;
1165: {
1166: struct vnode *vp = ap->a_vp;
1167: struct hfsnode *hp = VTOH(vp);
1168: struct attrlist *alist = ap->a_alist;
1169: struct ucred *cred = ap->a_cred;
1170: struct proc *p = ap->a_p;
1171: int error;
1172: struct hfsCatalogInfo catalogInfo;
1173: int attrblocksize;
1174: void *attrbufptr = NULL;
1175: void *attrptr;
1176: void *varptr = NULL;
1177: uid_t saved_uid;
1178: gid_t saved_gid;
1179: mode_t saved_mode;
1180: u_long saved_flags;
1181: char * filename;
1182: u_int32_t pid;
1183: int retval = 0;
1184:
1185: DBG_FUNC_NAME("setattrlist");
1186: DBG_VOP_LOCKS_DECL(1);
1187:
1188: DBG_VOP_LOCKS_INIT(0,ap->a_vp, VOPDBG_SAME, VOPDBG_SAME, VOPDBG_SAME, VOPDBG_POS);
1189: DBG_HFS_NODE_CHECK(ap->a_vp);
1190: DBG_VOP(("%s: Common attr:0x%x, buff size Ox%X,\n",funcname, (u_int)alist->commonattr,(u_int)ap->a_uio->uio_resid));
1191:
1192: DBG_ASSERT(ap->a_uio->uio_rw == UIO_WRITE);
1193:
1194: if ((alist->bitmapcount != ATTR_BIT_MAP_COUNT) ||
1195: ((alist->commonattr & ~ATTR_CMN_SETMASK) != 0) ||
1196: ((alist->volattr & ~ATTR_VOL_SETMASK) != 0) ||
1197: ((alist->dirattr & ~ATTR_DIR_SETMASK) != 0) ||
1198: ((alist->fileattr & ~ATTR_FILE_SETMASK) != 0) ||
1199: ((alist->forkattr & ~ATTR_FORK_SETMASK) != 0)) {
1200: DBG_ERR(("%s: Bad attrlist\n", funcname));
1201: DBG_VOP_LOCKS_TEST(EINVAL);
1202: return EINVAL;
1203: };
1204:
1205: if ((alist->volattr != 0) && /* Setting volume info */
1206: (((alist->volattr & ATTR_VOL_INFO) == 0) || /* Not explicitly indicating this or ... */
1207: (alist->commonattr & ~ATTR_CMN_VOLSETMASK))) /* ... setting invalid attributes for volume */
1208: {
1209: DBG_ERR(("%s: Bad attrlist\n", funcname));
1210: DBG_VOP_LOCKS_TEST(EINVAL);
1211: return EINVAL;
1212: };
1213:
1214: if (VTOVFS(vp)->mnt_flag & MNT_RDONLY) {
1215: DBG_VOP_LOCKS_TEST(EROFS);
1216: return EROFS;
1217: };
1218:
1219: /*
1220: Ownership of the file (in addition to write access, checked below,
1221: is required in one of two classes of calls:
1222:
1223: (a) When setting any ownership-requiring attribute other than ATTR_CMN_FLAGS, or
1224: (b) When setting ATTR_CMN_FLAGS on a volume that's not plain HFS (for which no
1225: real per-object ownership information is stored):
1226: */
1227: if ((alist->commonattr & (OWNERSHIP_ONLY_ATTRS & ~ATTR_CMN_FLAGS)) ||
1228: ((alist->commonattr & ATTR_CMN_FLAGS) && (VTOVCB(vp)->vcbSigWord != kHFSSigWord))) {
1229: /* NOTE: The following isn't ENTIRELY complete: even if you're the superuser
1230: you cannot change the flags as long as SF_IMMUTABLE or SF_APPEND is
1231: set and securelevel > 0. This is verified in hfs_chflags which gets
1232: invoked to do the actual flags field change so this check is sufficient
1233: for now.
1234: */
1235: /* Check to see if the user owns the object [or is superuser]: */
1236: if (cred->cr_uid != hp->h_meta->h_uid &&
1237: (retval = suser(cred, &p->p_acflag))) {
1238: DBG_VOP_LOCKS_TEST(retval);
1239: return retval;
1240: };
1241: } else {
1242: DBG_ASSERT(((alist->commonattr & OWNERSHIP_ONLY_ATTRS) == 0) ||
1243: (((alist->commonattr & OWNERSHIP_ONLY_ATTRS) == ATTR_CMN_FLAGS) &&
1244: (VTOVCB(vp)->vcbSigWord == kHFSSigWord)));
1245: /* No ownership access is required: mere write access (checked below) will do... */
1246: };
1247:
1248: /* For any other attributes, check to see if the user has write access to
1249: the object in question [unlike VOP_ACCESS, ignore IMMUTABLE here]: */
1250:
1251: if ((((alist->commonattr & ~(OWNERSHIP_ONLY_ATTRS)) != 0) ||
1252: (alist->volattr != 0) ||
1253: (alist->dirattr != 0) ||
1254: (alist->fileattr != 0) ||
1255: (alist->forkattr != 0)) &&
1256: ((retval = hfs_write_access(vp, cred, p, false)) != 0)) {
1257: DBG_VOP_LOCKS_TEST(retval);
1258: return retval;
1259: }; /* end of if ownership attr */
1260:
1261: /* Allocate the buffer now to minimize the time we might be blocked holding the catalog lock */
1262: attrblocksize = ap->a_uio->uio_resid;
1263: if (attrblocksize < AttributeBlockSize(alist)) {
1264: DBG_ERR(("%s: bad attrblocksize\n", funcname));
1265: DBG_VOP_LOCKS_TEST(EINVAL);
1266: return EINVAL;
1267: };
1268:
1269: MALLOC(attrbufptr, void *, attrblocksize, M_TEMP, M_WAITOK);
1270:
1271: /* lock catalog b-tree */
1272: error = hfs_metafilelocking(VTOHFS(vp), kHFSCatalogFileID, LK_EXCLUSIVE, p);
1273: if (error != E_NONE) {
1274: goto FreeBuffer;
1275: };
1276:
1277: filename = H_NAME(hp);
1278: pid = H_DIRID(hp);
1279:
1280: #if HFS_HARDLINKS
1281: /*
1282: * Force an update of the data node instead of the link node
1283: * by passing the fileID instead of parID and name.
1284: */
1285: if (hp->h_meta->h_metaflags & IN_DATANODE) {
1286: filename = NULL;
1287: pid = H_FILEID(hp);
1288: }
1289: #endif
1290: catalogInfo.hint = kNoHint;
1291: error = hfsLookup(VTOVCB(vp), pid, filename, -1, &catalogInfo);
1292: if (error != E_NONE) {
1293: DBG_ERR(("%s: Lookup failed on file '%s'\n", funcname, filename));
1294: goto ErrorExit;
1295: };
1296: H_HINT(hp) = catalogInfo.hint; /* Remember the last valid hint */
1297:
1298: error = uiomove((caddr_t)attrbufptr, attrblocksize, ap->a_uio);
1299: if (error) goto ErrorExit;
1300:
1301: if ((alist->volattr) && (H_FILEID(hp) != kRootDirID)) {
1302: error = EINVAL;
1303: goto ErrorExit;
1304: };
1305:
1306: /* do we have permission to change the dates? */
1307: // if (alist->commonattr & (ATTR_CMN_CRTIME | ATTR_CMN_MODTIME | ATTR_CMN_CHGTIME | ATTR_CMN_ACCTIME | ATTR_CMN_BKUPTIME)) {
1308: if (alist->commonattr & (ATTR_CMN_CHGTIME | ATTR_CMN_ACCTIME)) {
1309: if (cred->cr_uid != hp->h_meta->h_uid && (error = suser(cred, &p->p_acflag))) {
1310: goto ErrorExit;
1311: };
1312: };
1313:
1314: /* save these in case hfs_chown() or hfs_chmod() fail */
1315: saved_uid = hp->h_meta->h_uid;
1316: saved_gid = hp->h_meta->h_gid;
1317: saved_mode = hp->h_meta->h_mode;
1318: saved_flags = hp->h_meta->h_pflags;
1319:
1320: attrptr = attrbufptr;
1321: UnpackAttributeBlock(alist, vp, &catalogInfo, &attrptr, &varptr);
1322:
1323: /* if unpacking changed the owner or group then call hfs_chown() */
1324: if (saved_uid != hp->h_meta->h_uid || saved_gid != hp->h_meta->h_gid) {
1325: uid_t uid;
1326: gid_t gid;
1327:
1328: uid = hp->h_meta->h_uid;
1329: hp->h_meta->h_uid = saved_uid;
1330: gid = hp->h_meta->h_gid;
1331: hp->h_meta->h_gid = saved_gid;
1332: if ((error = hfs_chown(vp, uid, gid, cred, p)))
1333: goto ErrorExit;
1334: }
1335:
1336: /* if unpacking changed the mode then call hfs_chmod() */
1337: if (saved_mode != hp->h_meta->h_mode) {
1338: mode_t mode;
1339:
1340: mode = hp->h_meta->h_mode;
1341: hp->h_meta->h_mode = saved_mode;
1342: if ((error = hfs_chmod(vp, mode, cred, p)))
1343: goto ErrorExit;
1344: };
1345:
1346: /* if unpacking changed the flags then call hfs_chflags */
1347: if (saved_flags != hp->h_meta->h_pflags) {
1348: u_long flags;
1349:
1350: flags = hp->h_meta->h_pflags;
1351: hp->h_meta->h_pflags = saved_flags;
1352: if ((error = hfs_chflags(vp, flags, cred, p)))
1353: goto ErrorExit;
1354: };
1355:
1356: if (alist->volattr == 0) {
1357: error = MacToVFSError( UpdateCatalogNode(HTOVCB(hp), pid, filename, H_HINT(hp), &catalogInfo.nodeData));
1358: }
1359:
1360: if (alist->volattr & ATTR_VOL_NAME) {
1361: ExtendedVCB *vcb = VTOVCB(vp);
1362: int namelen = strlen(vcb->vcbVN);
1363:
1364: if (vcb->vcbVN[0] == 0) {
1365: /*
1366: Ignore attempts to rename a volume to a zero-length name:
1367: restore the original name from the metadata.
1368: */
1369: copystr(H_NAME(hp), vcb->vcbVN, sizeof(vcb->vcbVN), NULL);
1370: } else {
1371: error = MoveRenameCatalogNode(vcb, kRootParID, H_NAME(hp), H_HINT(hp), kRootParID, vcb->vcbVN, &H_HINT(hp));
1372: if (error) {
1373: VCB_LOCK(vcb);
1374: copystr(H_NAME(hp), vcb->vcbVN, sizeof(vcb->vcbVN), NULL); /* Restore the old name in the VCB */
1375: vcb->vcbFlags |= 0xFF00; // Mark the VCB dirty
1376: VCB_UNLOCK(vcb);
1377: goto ErrorExit;
1378: };
1379:
1380: hfs_set_metaname(vcb->vcbVN, hp->h_meta);
1381: hp->h_nodeflags |= IN_CHANGE;
1382:
1383: #if 0
1384: /* if hfs wrapper exists, update its name too */
1385: if (vcb->vcbSigWord == kHFSPlusSigWord && vcb->vcbAlBlSt != 0) {
1386: HFSMasterDirectoryBlock *mdb;
1387: struct buf *bp = NULL;
1388: int size = kMDBSize; /* 512 */
1389: int volnamelen = MIN(sizeof(Str27), namelen);
1390:
1391: if ( bread(VTOHFS(vp)->hfs_devvp, IOBLKNOFORBLK(kMasterDirectoryBlock, size),
1392: IOBYTECCNTFORBLK(kMasterDirectoryBlock, kMDBSize, size), NOCRED, &bp) == 0) {
1393:
1394: mdb = (HFSMasterDirectoryBlock *)((char *)bp->b_data + IOBYTEOFFSETFORBLK(kMasterDirectoryBlock, size));
1395: if (mdb->drSigWord == kHFSSigWord) {
1396: /* Convert the string to MacRoman, ignoring any errors, */
1397: (void) utf8_to_hfs(vcb, volnamelen, vcb->vcbVN, Str31 mdb->drVN)
1398: bawrite(bp);
1399: bp = NULL;
1400: }
1401: }
1402:
1403: if (bp) brelse(bp);
1404: }
1405: #endif
1406: }; /* vcb->vcbVN[0] == 0 ... else ... */
1407: }; /* alist->volattr & ATTR_VOL_NAME */
1408:
1409: ErrorExit:
1410: /* unlock catalog b-tree */
1411: (void) hfs_metafilelocking(VTOHFS(vp), kHFSCatalogFileID, LK_RELEASE, p);
1412:
1413: FreeBuffer:
1414: if (attrbufptr) FREE(attrbufptr, M_TEMP);
1415:
1416: DBG_VOP_LOCKS_TEST(error);
1417: return error;
1418: }
1419:
1420: /*
1421: * Change the mode on a file.
1422: * Inode must be locked before calling.
1423: */
1424: static int
1425: hfs_chmod(vp, mode, cred, p)
1426: register struct vnode *vp;
1427: register int mode;
1428: register struct ucred *cred;
1429: struct proc *p;
1430: {
1431: register struct hfsnode *hp = VTOH(vp);
1432: int retval;
1433:
1434: if (VTOVCB(vp)->vcbSigWord != kHFSPlusSigWord)
1435: return E_NONE;
1436:
1437: if (cred->cr_uid != hp->h_meta->h_uid &&
1438: (retval = suser(cred, &p->p_acflag)))
1439: return (retval);
1440: if (cred->cr_uid) {
1441: if (vp->v_type != VDIR && (mode & S_ISTXT))
1442: return (EFTYPE);
1443: if (!groupmember(hp->h_meta->h_gid, cred) && (mode & ISGID))
1444: return (EPERM);
1445: }
1446: hp->h_meta->h_mode &= ~ALLPERMS;
1447: hp->h_meta->h_mode |= (mode & ALLPERMS);
1448: hp->h_meta->h_metaflags &= ~IN_UNSETACCESS;
1449: hp->h_nodeflags |= IN_CHANGE;
1450: if ((vp->v_flag & VTEXT) && (hp->h_meta->h_mode & S_ISTXT) == 0)
1451: (void) vnode_uncache(vp);
1452: return (0);
1453: }
1454:
1455:
1456: static int
1457: hfs_write_access(struct vnode *vp, struct ucred *cred, struct proc *p, Boolean considerFlags)
1458: {
1459: struct hfsnode *hp = VTOH(vp);
1460: ExtendedVCB *vcb = HTOVCB(hp);
1461: gid_t *gp;
1462: Boolean isHFSPlus;
1463: int retval = E_NONE;
1464: int i;
1465:
1466: isHFSPlus = (vcb->vcbSigWord == kHFSPlusSigWord );
1467:
1468: /*
1469: * Disallow write attempts on read-only file systems;
1470: * unless the file is a socket, fifo, or a block or
1471: * character device resident on the file system.
1472: */
1473: switch (vp->v_type) {
1474: case VDIR:
1475: case VLNK:
1476: case VREG:
1477: if (VTOVFS(vp)->mnt_flag & MNT_RDONLY)
1478: return (EROFS);
1479: break;
1480: default:
1481: break;
1482: }
1483:
1484: /* If immutable bit set, nobody gets to write it. */
1485: if (considerFlags && (hp->h_meta->h_pflags & IMMUTABLE))
1486: return (EPERM);
1487:
1488: /* Otherwise, user id 0 always gets access. */
1489: if (cred->cr_uid == 0) {
1490: retval = 0;
1491: goto Exit;
1492: };
1493:
1494: /* Otherwise, check the owner. */
1495: if (cred->cr_uid == hp->h_meta->h_uid) {
1496: retval = ((hp->h_meta->h_mode & S_IWUSR) == S_IWUSR ? 0 : EACCES);
1497: goto Exit;
1498: }
1499:
1500: /* Otherwise, check the groups. */
1501: for (i = 0, gp = cred->cr_groups; i < cred->cr_ngroups; i++, gp++)
1502: if (hp->h_meta->h_gid == *gp) {
1503: retval = ((hp->h_meta->h_mode & S_IWGRP) == S_IWGRP ? 0 : EACCES);
1504: goto Exit;
1505: }
1506:
1507: /* Otherwise, check everyone else. */
1508: retval = ((hp->h_meta->h_mode & S_IWOTH) == S_IWOTH ? 0 : EACCES);
1509:
1510: Exit:
1511: return (retval);
1512: }
1513:
1514: /*
1515: * Change the flags on a file or directory.
1516: * Inode must be locked before calling.
1517: */
1518: static int
1519: hfs_chflags(vp, flags, cred, p)
1520: register struct vnode *vp;
1521: register u_long flags;
1522: register struct ucred *cred;
1523: struct proc *p;
1524: {
1525: register struct hfsnode *hp = VTOH(vp);
1526: int retval;
1527:
1528: if (VTOVCB(vp)->vcbSigWord == kHFSSigWord) {
1529: if ((retval = hfs_write_access(vp, cred, p, false)) != 0) {
1530: return retval;
1531: };
1532: } else if ((cred->cr_uid != hp->h_meta->h_uid) &&
1533: (retval = suser(cred, &p->p_acflag))) {
1534: return retval;
1535: };
1536:
1537: if (cred->cr_uid == 0) {
1538: if ((hp->h_meta->h_pflags & (SF_IMMUTABLE | SF_APPEND)) &&
1539: securelevel > 0) {
1540: return EPERM;
1541: };
1542: hp->h_meta->h_pflags = flags;
1543: } else {
1544: if (hp->h_meta->h_pflags & (SF_IMMUTABLE | SF_APPEND) ||
1545: (flags & UF_SETTABLE) != flags) {
1546: return EPERM;
1547: };
1548: hp->h_meta->h_pflags &= SF_SETTABLE;
1549: hp->h_meta->h_pflags |= (flags & UF_SETTABLE);
1550: }
1551: hp->h_meta->h_metaflags &= ~IN_UNSETACCESS;
1552: hp->h_nodeflags |= IN_CHANGE;
1553:
1554: return 0;
1555: }
1556:
1557:
1558: /*
1559: * Perform chown operation on hfsnode hp;
1560: * hfsnode must be locked prior to call.
1561: */
1562: static int
1563: hfs_chown(vp, uid, gid, cred, p)
1564: register struct vnode *vp;
1565: uid_t uid;
1566: gid_t gid;
1567: struct ucred *cred;
1568: struct proc *p;
1569: {
1570: register struct hfsnode *hp = VTOH(vp);
1571: uid_t ouid;
1572: gid_t ogid;
1573: int retval = 0;
1574:
1575: if (VTOVCB(vp)->vcbSigWord != kHFSPlusSigWord)
1576: return EOPNOTSUPP;
1577:
1578: if (uid == (uid_t)VNOVAL)
1579: uid = hp->h_meta->h_uid;
1580: if (gid == (gid_t)VNOVAL)
1581: gid = hp->h_meta->h_gid;
1582: /*
1583: * If we don't own the file, are trying to change the owner
1584: * of the file, or are not a member of the target group,
1585: * the caller must be superuser or the call fails.
1586: */
1587: if ((cred->cr_uid != hp->h_meta->h_uid || uid != hp->h_meta->h_uid ||
1588: (gid != hp->h_meta->h_gid && !groupmember((gid_t)gid, cred))) &&
1589: (retval = suser(cred, &p->p_acflag)))
1590: return (retval);
1591: ogid = hp->h_meta->h_gid;
1592: ouid = hp->h_meta->h_uid;
1593:
1594: hp->h_meta->h_gid = gid;
1595: hp->h_meta->h_uid = uid;
1596:
1597: hp->h_meta->h_metaflags &= ~IN_UNSETACCESS;
1598: if (ouid != uid || ogid != gid)
1599: hp->h_nodeflags |= IN_CHANGE;
1600: if (ouid != uid && cred->cr_uid != 0)
1601: hp->h_meta->h_mode &= ~ISUID;
1602: if (ogid != gid && cred->cr_uid != 0)
1603: hp->h_meta->h_mode &= ~ISGID;
1604: return (0);
1605: }
1606:
1607:
1608:
1609: /*
1610: #
1611: #% exchange fvp L L L
1612: #% exchange tvp L L L
1613: #
1614: vop_exchange {
1615: IN struct vnode *fvp;
1616: IN struct vnode *tvp;
1617: IN struct ucred *cred;
1618: IN struct proc *p;
1619: };
1620:
1621: */
1622: /*
1623: * exchange is a very tricky routine, because we might have to unlock the
1624: * passed in vnode, and then retry locking it and all its siblings, and then
1625: * unlocking them in reverse.
1626: * Also the sibling list lock must be kept during the whole operation to
1627: * make sure nothing changes underneath us.
1628: * Also it depends on behavior of the sibling list and hash, so
1629: * careful if you change anything.
1630: */
1631:
1632: static int
1633: hfs_exchange(ap)
1634: struct vop_exchange_args /* {
1635: struct vnode *a_fvp;
1636: struct vnode *a_tvp;
1637: struct ucred *a_cred;
1638: struct proc *a_p;
1639: } */ *ap;
1640: {
1641: struct hfsnode *from_hp, *to_hp, *nhp;
1642: struct hfsnode *fromSkipIfFirst, *toSkipIfFirst;
1643: struct vnode *from_vp, *to_vp;
1644: struct hfsmount *hfsmp;
1645: u_char tmp_name[NAME_MAX+1]; /* 256 bytes! */
1646: ExtendedVCB *vcb;
1647: u_int32_t fromFileID, toFileID;
1648: u_int32_t fromParID;
1649: u_int32_t tmpLong;
1650: int retval = E_NONE;
1651: DBG_FUNC_NAME("exchange");
1652: DBG_VOP_LOCKS_DECL(2);
1653: DBG_VOP_PRINT_FUNCNAME();
1654: DBG_VOP_PRINT_VNODE_INFO(ap->a_fvp);DBG_VOP_CONT(("\n"));
1655: DBG_VOP_PRINT_VNODE_INFO(ap->a_tvp);DBG_VOP_CONT(("\n"));
1656:
1657: DBG_VOP_LOCKS_INIT(0,ap->a_fvp, VOPDBG_LOCKED, VOPDBG_LOCKED, VOPDBG_LOCKED, VOPDBG_POS);
1658: DBG_VOP_LOCKS_INIT(1,ap->a_tvp, VOPDBG_LOCKED, VOPDBG_LOCKED, VOPDBG_LOCKED, VOPDBG_POS);
1659:
1660: /* Set up variables and checks */
1661: from_vp = ap->a_fvp;
1662: to_vp = ap->a_tvp;
1663: from_hp = VTOH(from_vp);
1664: to_hp = VTOH(to_vp);
1665: hfsmp = VTOHFS(from_vp);
1666: vcb = HTOVCB(from_hp);
1667: toFileID = H_FILEID(to_hp);
1668: fromFileID = H_FILEID(from_hp);
1669: fromParID = H_DIRID(from_hp);
1670:
1671: if (from_vp->v_mount != to_vp->v_mount) {
1672: DBG_VOP_LOCKS_TEST(EXDEV);
1673: return EXDEV;
1674: }
1675:
1676: /* Can only exchange file objects */
1677: if (from_vp->v_type != VREG || to_vp->v_type != VREG) {
1678: DBG_VOP_LOCKS_TEST(EINVAL);
1679: return EINVAL;
1680: }
1681:
1682: /*
1683: * Lock the siblink list
1684: * Check for multiple forks
1685: * If there are, we would need to:
1686: * 1. Unlock ourselves
1687: * 3. Traverse the list in a forward order...locking all vnodes
1688: * 4. Flush all buffers
1689: * 5. Perform the exchange
1690: * 6. Traverse the list in a reverse order...unlocking all vnodes, except orignal
1691: * Notice that the sibling lock is kept during the whole operation. This quarentees
1692: * that no new forks are taken off or put on
1693: */
1694: DBG_ASSERT(H_FORKTYPE(from_hp)==kDataFork && H_FORKTYPE(to_hp)==kDataFork);
1695: fromSkipIfFirst = toSkipIfFirst = NULL;
1696: simple_lock(&from_hp->h_meta->h_siblinglock);
1697: if (from_hp->h_meta->h_usecount > 1) {
1698: /*
1699: * This has siblings, so remember the passed-in vnode,
1700: * unlock it if it is not the 'first' sibling,
1701: * and then lock the rest of the vnodes by sibling order.
1702: * Notice that the passed-in vnode is not vrele(), this
1703: * keeps the usecount>0, so it wont go away.
1704: */
1705: if (from_hp->h_meta->h_siblinghead.cqh_first == from_hp) {
1706: fromSkipIfFirst = from_hp;
1707: nhp = from_hp->h_sibling.cqe_next;
1708: }
1709: else {
1710: VOP_UNLOCK(from_vp, 0, ap->a_p);
1711: nhp = from_hp->h_meta->h_siblinghead.cqh_first;
1712: };
1713:
1714: for (; nhp != (void *)&from_hp->h_meta->h_siblinghead; nhp = nhp->h_sibling.cqe_next) {
1715:
1716: if (vget(HTOV(nhp), LK_EXCLUSIVE | LK_RETRY, ap->a_p))
1717: continue; /* skip it, this shouldnt happen */
1718:
1719: /* Ignore any errors, we are doing a 'best effort' on flushing */
1720: (void) vinvalbuf(HTOV(nhp), V_SAVE, ap->a_cred, ap->a_p, 0, 0);
1721: };
1722: };
1723:
1724: simple_lock(&to_hp->h_meta->h_siblinglock);
1725: if (to_hp->h_meta->h_usecount > 1) {
1726:
1727: if (to_hp->h_meta->h_siblinghead.cqh_first == to_hp) {
1728: toSkipIfFirst = to_hp;
1729: nhp = to_hp->h_sibling.cqe_next;
1730: }
1731: else {
1732: VOP_UNLOCK(to_vp, 0, ap->a_p);
1733: nhp = to_hp->h_meta->h_siblinghead.cqh_first;
1734: };
1735:
1736:
1737: for (; nhp != (void *)&to_hp->h_meta->h_siblinghead; nhp = nhp->h_sibling.cqe_next) {
1738:
1739:
1740: if (vget(HTOV(nhp), LK_EXCLUSIVE | LK_RETRY, ap->a_p))
1741: continue; /* skip it, this shouldnt happen */
1742:
1743: /* Ignore any errors, we are doing a 'best effort' on flushing */
1744: (void) vinvalbuf(HTOV(nhp), V_SAVE, ap->a_cred, ap->a_p, 0, 0);
1745: };
1746: };
1747:
1748: /* lock catalog b-tree */
1749: retval = hfs_metafilelocking(hfsmp, kHFSCatalogFileID, LK_EXCLUSIVE, ap->a_p);
1750: if (retval) goto Err_Exit;
1751:
1752: /* lock extents b-tree iff there are overflow extents */
1753: /* XXX SER ExchangeFileIDs() always tries to delete the virtual extent id for exchanging files
1754: so we neeed the tree to be always locked.
1755: */
1756: retval = hfs_metafilelocking(hfsmp, kHFSExtentsFileID, LK_EXCLUSIVE, ap->a_p);
1757: if (retval) goto Err_Exit_Relse;
1758:
1759: /* Do the exchange */
1760: retval = MacToVFSError( ExchangeFileIDs(vcb, H_NAME(from_hp), H_NAME(to_hp), H_DIRID(from_hp), H_DIRID(to_hp), H_HINT(from_hp), H_HINT(to_hp) ));
1761:
1762: (void) hfs_metafilelocking(hfsmp, kHFSExtentsFileID, LK_RELEASE, ap->a_p);
1763:
1764: if (retval != E_NONE) {
1765: DBG_ERR(("/tError trying to exchange: %d\n", retval));
1766: goto Err_Exit_Relse;
1767: }
1768:
1769:
1770: /* Now exchange fileID, parID, name for the vnode itself */
1771: copystr(H_NAME(from_hp), (char*) tmp_name, strlen(H_NAME(from_hp))+1, NULL);
1772: hfs_chid(from_hp, toFileID, H_DIRID(to_hp), H_NAME(to_hp));
1773: hfs_chid(to_hp, fromFileID, fromParID, (char*) tmp_name);
1774:
1775: /* copy rest */
1776: tmpLong = HTOFCB(from_hp)->fcbFlags;
1777: HTOFCB(from_hp)->fcbFlags = HTOFCB(to_hp)->fcbFlags;
1778: HTOFCB(to_hp)->fcbFlags = tmpLong;
1779:
1780: tmpLong = from_hp->h_meta->h_crtime;
1781: from_hp->h_meta->h_crtime = to_hp->h_meta->h_crtime;
1782: to_hp->h_meta->h_crtime = tmpLong;
1783:
1784: tmpLong = from_hp->h_meta->h_butime;
1785: from_hp->h_meta->h_butime = to_hp->h_meta->h_butime;
1786: to_hp->h_meta->h_butime = tmpLong;
1787:
1788: tmpLong = from_hp->h_meta->h_atime;
1789: from_hp->h_meta->h_atime = to_hp->h_meta->h_atime;
1790: to_hp->h_meta->h_atime = tmpLong;
1791:
1792: tmpLong = from_hp->h_meta->h_ctime;
1793: from_hp->h_meta->h_ctime = to_hp->h_meta->h_ctime;
1794: to_hp->h_meta->h_ctime = tmpLong;
1795:
1796:
1797: tmpLong = from_hp->h_meta->h_gid;
1798: from_hp->h_meta->h_gid = to_hp->h_meta->h_gid;
1799: to_hp->h_meta->h_gid = tmpLong;
1800:
1801: tmpLong = from_hp->h_meta->h_uid;
1802: from_hp->h_meta->h_uid = to_hp->h_meta->h_uid;
1803: to_hp->h_meta->h_uid = tmpLong;
1804:
1805: tmpLong = from_hp->h_meta->h_pflags;
1806: from_hp->h_meta->h_pflags = to_hp->h_meta->h_pflags;
1807: to_hp->h_meta->h_pflags = tmpLong;
1808:
1809: tmpLong = from_hp->h_meta->h_mode;
1810: from_hp->h_meta->h_mode = to_hp->h_meta->h_mode;
1811: to_hp->h_meta->h_mode = tmpLong;
1812:
1813: tmpLong = from_hp->h_meta->h_rdev;
1814: from_hp->h_meta->h_rdev = to_hp->h_meta->h_rdev;
1815: to_hp->h_meta->h_rdev = tmpLong;
1816:
1817: tmpLong = from_hp->h_meta->h_size;
1818: from_hp->h_meta->h_size = to_hp->h_meta->h_size;
1819: to_hp->h_meta->h_size = tmpLong;
1820:
1821:
1822:
1823: Err_Exit_Relse:;
1824:
1825: /* unlock catalog b-tree */
1826: (void) hfs_metafilelocking(hfsmp, kHFSCatalogFileID, LK_RELEASE, ap->a_p);
1827:
1828:
1829:
1830: Err_Exit:;
1831:
1832: /* Unlock any forks, and the sibling list */
1833: if (to_hp->h_meta->h_usecount > 1) {
1834: for (nhp = to_hp->h_meta->h_siblinghead.cqh_last;
1835: nhp != (void *)&to_hp->h_meta->h_siblinghead; nhp = nhp->h_sibling.cqe_prev) {
1836: if (toSkipIfFirst && (nhp == toSkipIfFirst))
1837: continue;
1838: else if (HTOV(nhp)==to_vp)
1839: VRELE(HTOV(nhp)); /* decrement, return it locked */
1840: /*
1841: * A gotcha here, is that when locking, it might of failed
1842: * because the vnode was going away. Since vput() does not test for this,
1843: * we have to do this ourselves....but using the VXLOCK is bad, because
1844: * it should be private to vfs routines...but until another way is thought of...
1845: */
1846: else if (!(HTOV(nhp)->v_flag & VXLOCK)) {
1847: cache_purge(HTOV(nhp));
1848: VPUT(HTOV(nhp));
1849: };
1850: };
1851: };
1852:
1853: simple_unlock(&to_hp->h_meta->h_siblinglock);
1854:
1855: if (from_hp->h_meta->h_usecount > 1) {
1856: for (nhp = from_hp->h_meta->h_siblinghead.cqh_last;
1857: nhp != (void *)&from_hp->h_meta->h_siblinghead; nhp = nhp->h_sibling.cqe_prev) {
1858: if (fromSkipIfFirst && (nhp == fromSkipIfFirst))
1859: continue;
1860: else if (HTOV(nhp)==from_vp)
1861: VRELE(HTOV(nhp)); /* decrement, return it locked */
1862: else if (!(HTOV(nhp)->v_flag & VXLOCK)){
1863: cache_purge(HTOV(nhp));
1864: VPUT(HTOV(nhp));
1865: };
1866: };
1867: };
1868:
1869: simple_unlock(&from_hp->h_meta->h_siblinglock);
1870:
1871: /* Purge the vnodes from the namei...the names do not match vnodes now */
1872: cache_purge(from_vp);
1873: cache_purge(to_vp);
1874:
1875: /* XXX SER
1876: * At this point, the vnodes' data is switched, but are on the old hash list.
1877: * so move them to the right bucket. This couldnt be done until now, because the h_siblinglock
1878: * was being held.
1879: * Scenario:
1880: * A fork is trying to be added while exchanging...It got the hash lock,
1881: * but is waiting for the h_siblinglock. So we cannot try get the hash lock
1882: * until we release h_siblinglock, so it could continue, so it adds to the sibling list
1883: * and at the old place, so hfs_vhashmove has to move all vnodes with the old file id.
1884: * Not very pretty, becarefull that this works ok
1885: * Scenario 2:
1886: * Same as the above, but before the move is made (like at this very spot), the new vnode
1887: * is added and a vget is requested for that new vnode, it would have old data
1888: * WE MIGHT NEED TO LOCK THE HASH BECAUSE OF THIS !!!
1889: * Scenario 3:
1890: * Hey! Same as above, but it is added after all the moving
1891: * So now there is a vnode with the old data, on the old hash...it will become
1892: * lost next time that a vget() is done
1893: *
1894: * XXX SER A solution might be to NOT move the hash, but the data (extents) or the
1895: * opposite that we are doing now
1896: */
1897: hfs_vhashmove(from_hp, fromFileID);
1898: hfs_vhashmove(to_hp, toFileID);
1899:
1900: DBG_VOP_LOCKS_TEST(retval);
1901: return (retval);
1902: }
1903:
1904:
1905: /*
1906: * Change a vnode's file id, parent id and name
1907: *
1908: * Assumes the vnode is locked and is of type VREG
1909: */
1910: static void
1911: hfs_chid(struct hfsnode *hp, u_int32_t fid, u_int32_t pid, char* name)
1912: {
1913: DBG_ASSERT(HTOV(hp)->v_type == VREG);
1914:
1915: H_HINT(hp) = 0;
1916: H_FILEID(hp) = fid; /* change h_nodeID */
1917: H_DIRID(hp) = pid;
1918:
1919: hfs_set_metaname(name, hp->h_meta);
1920:
1921:
1922: }
1923:
1924:
1925: /*
1926:
1927: #% fsync vp L L L
1928: #
1929: vop_fsync {
1930: IN struct vnode *vp;
1931: IN struct ucred *cred;
1932: IN int waitfor;
1933: IN struct proc *p;
1934:
1935: */
1936:
1937:
1938: static int
1939: hfs_fsync(ap)
1940: struct vop_fsync_args /* {
1941: struct vnode *a_vp;
1942: struct ucred *a_cred;
1943: int a_waitfor;
1944: struct proc *a_p;
1945: } */ *ap;
1946: {
1947: struct vnode *vp = ap->a_vp ;
1948: struct hfsnode *hp = VTOH(vp);
1949: int retval = 0;
1950: register struct buf *bp;
1951: struct timeval tv;
1952: struct buf *nbp;
1953: int s;
1954:
1955: DBG_FUNC_NAME("fsync");
1956: DBG_VOP_LOCKS_DECL(1);
1957: DBG_VOP_PRINT_FUNCNAME();DBG_VOP_CONT((" "));
1958: DBG_VOP_PRINT_VNODE_INFO(ap->a_vp);DBG_VOP_CONT(("\n"));
1959: DBG_VOP_LOCKS_INIT(0,ap->a_vp, VOPDBG_LOCKED, VOPDBG_LOCKED, VOPDBG_LOCKED, VOPDBG_ZERO);
1960: DBG_HFS_NODE_CHECK(ap->a_vp);
1961:
1962: #if HFS_DIAGNOSTIC
1963: DBG_ASSERT(*((int*)&vp->v_interlock) == 0);
1964: #endif
1965:
1966:
1967: /*
1968: * First of all, write out any clusters.
1969: */
1970: if (doclusterwrite) {
1971: long devBlockSize = 0;
1972:
1973: VOP_DEVBLOCKSIZE(hp->h_meta->h_devvp, &devBlockSize);
1974: cluster_close(vp, PAGE_SIZE, devBlockSize);
1975: };
1976:
1977: /*
1978: * Flush all dirty buffers associated with a vnode.
1979: */
1980: loop:
1981: s = splbio();
1982: for (bp = vp->v_dirtyblkhd.lh_first; bp; bp = nbp) {
1983: nbp = bp->b_vnbufs.le_next;
1984: if ((bp->b_flags & B_BUSY))
1985: continue;
1986: if ((bp->b_flags & B_DELWRI) == 0)
1987: panic("hfs_fsync: not dirty");
1988: bremfree(bp);
1989: bp->b_flags |= B_BUSY;
1990: bp->b_flags &= ~B_LOCKED; /* Clear flag, should only be set on meta files */
1991: splx(s);
1992: /*
1993: * Wait for I/O associated with indirect blocks to complete,
1994: * since there is no way to quickly wait for them below.
1995: */
1996: DBG_VOP(("\t\t\tFlushing out phys block %d == log block %d\n", bp->b_blkno, bp->b_lblkno));
1997: if (bp->b_vp == vp || ap->a_waitfor == MNT_NOWAIT) {
1998: (void) bawrite(bp);
1999: } else {
2000: (void) bwrite(bp);
2001: }
2002: goto loop;
2003: }
2004:
2005: if (ap->a_waitfor == MNT_WAIT) {
2006: while (vp->v_numoutput) {
2007: vp->v_flag |= VBWAIT;
2008: tsleep((caddr_t)&vp->v_numoutput, PRIBIO + 1, "hfs_fsync", 0);
2009: }
2010:
2011: /* I have seen this happen for swapfile. So it is safer to
2012: * check for dirty buffers again. --Umesh
2013: */
2014: if (vp->v_dirtyblkhd.lh_first) {
2015: vprint("hfs_fsync: dirty", vp);
2016: splx(s);
2017: goto loop;
2018: }
2019: }
2020: splx(s);
2021:
2022: #if HFS_DIAGNOSTIC
2023: DBG_ASSERT(*((int*)&vp->v_interlock) == 0);
2024: #endif
2025:
2026: tv = time;
2027: if ((vp->v_flag & VSYSTEM) && (hp->fcbBTCBPtr!=NULL))
2028: BTSetLastSync(HTOFCB(hp), tv.tv_sec);
2029:
2030: if (H_FORKTYPE(hp) != kSysFile) {
2031: retval = VOP_UPDATE(ap->a_vp, &tv, &tv, ap->a_waitfor == MNT_WAIT);
2032:
2033: if (retval != E_NONE) {
2034: DBG_ERR(("%s: FLUSH FAILED: %s\n", funcname, H_NAME(hp)));
2035: }
2036: }
2037: else
2038: hp->h_nodeflags &= ~(IN_ACCESS | IN_CHANGE | IN_MODIFIED | IN_UPDATE);
2039:
2040: if (ap->a_waitfor == MNT_WAIT) {
2041: DBG_ASSERT(vp->v_dirtyblkhd.lh_first == NULL);
2042: };
2043: DBG_VOP_LOCKS_TEST(retval);
2044: DBG_ASSERT(*((int*)&vp->v_interlock) == 0);
2045: return (retval);
2046: }
2047:
2048:
2049: int
2050: hfs_fsync_transaction(struct vnode *vp)
2051: {
2052: struct hfsnode *hp = VTOH(vp);
2053: register struct buf *bp;
2054: struct timeval tv;
2055: struct buf *nbp;
2056: int s;
2057:
2058: /*
2059: * Flush all dirty buffers associated with a vnode.
2060: */
2061: loop:
2062: s = splbio();
2063:
2064: for (bp = vp->v_dirtyblkhd.lh_first; bp; bp = nbp) {
2065: nbp = bp->b_vnbufs.le_next;
2066: if ((bp->b_flags & B_BUSY))
2067: continue;
2068: if ((bp->b_flags & B_DELWRI) == 0)
2069: panic("hfs_fsync: not dirty");
2070: if ( !(bp->b_flags & B_LOCKED))
2071: continue;
2072:
2073: bremfree(bp);
2074: bp->b_flags |= B_BUSY;
2075: bp->b_flags &= ~B_LOCKED; /* Clear flag, should only be set on meta files */
2076: splx(s);
2077:
2078: (void) bawrite(bp);
2079:
2080: goto loop;
2081: }
2082: splx(s);
2083:
2084: tv = time;
2085: if ((vp->v_flag & VSYSTEM) && (hp->fcbBTCBPtr!=NULL))
2086: (void) BTSetLastSync(VTOFCB(vp), tv.tv_sec);
2087: hp->h_nodeflags &= ~(IN_ACCESS | IN_CHANGE | IN_MODIFIED | IN_UPDATE);
2088:
2089: return 0;
2090: }
2091:
2092: /*
2093:
2094: #% remove dvp L U U
2095: #% remove vp L U U
2096: #
2097: vop_remove {
2098: IN WILLRELE struct vnode *dvp;
2099: IN WILLRELE struct vnode *vp;
2100: IN struct componentname *cnp;
2101:
2102: */
2103:
2104: int
2105: hfs_remove(ap)
2106: struct vop_remove_args /* {
2107: struct vnode *a_dvp;
2108: struct vnode *a_vp;
2109: struct componentname *a_cnp;
2110: } */ *ap;
2111: {
2112: struct vnode *vp = ap->a_vp;
2113: struct vnode *dvp = ap->a_dvp;
2114: struct hfsnode *hp = VTOH(ap->a_vp);
2115: struct hfsmount *hfsmp = HTOHFS(hp);
2116: struct proc *p = current_proc();
2117: struct timeval tv;
2118: int retval, use_count, hasSiblings;
2119: int filebusy = 0;
2120: DBG_FUNC_NAME("remove");
2121: DBG_VOP_LOCKS_DECL(2);
2122: DBG_VOP_PRINT_FUNCNAME();
2123: DBG_VOP_PRINT_VNODE_INFO(ap->a_vp);
2124: DBG_VOP_PRINT_CPN_INFO(ap->a_cnp);DBG_VOP_CONT(("\n"));
2125: DBG_VOP_LOCKS_INIT(0,ap->a_dvp, VOPDBG_LOCKED, VOPDBG_UNLOCKED, VOPDBG_UNLOCKED, VOPDBG_POS);
2126: DBG_VOP_LOCKS_INIT(1,ap->a_vp, VOPDBG_LOCKED, VOPDBG_UNLOCKED, VOPDBG_UNLOCKED, VOPDBG_POS);
2127:
2128: hasSiblings = false;
2129: retval = E_NONE;
2130:
2131: if ((hp->h_meta->h_pflags & (IMMUTABLE | APPEND)) ||
2132: (VTOH(dvp)->h_meta->h_pflags & APPEND)) {
2133: retval = EPERM;
2134: goto out;
2135: }
2136:
2137: if (vp->v_usecount > 1) {
2138: /* Mac OS clients can't delete busy files */
2139: if ((ap->a_cnp->cn_flags & NODELETEBUSY) || (hfsmp->hfs_private_metadata_dir == 0)) {
2140: retval = EBUSY;
2141: goto out;
2142: } else
2143: filebusy = 1;
2144: }
2145:
2146: tv = time; /* Done here, so all times are the same */
2147:
2148: /* Check other siblings for in use also */
2149: /* XXX SER MUST BE CHANGED BY MACOS X because of vnode_uncache */
2150: /* Uncache everything and make sure no other usecount */
2151: /*
2152: * a. loop through the siblings looking for matches
2153: * b. If we find ourselves...skip it
2154: * If there was a sibling:
2155: * a. Check for a positve usecount
2156: * b. uncache any pages
2157: * c. Write out and memory changes
2158: * The idea is to keep the h_siblinglock as little as possible
2159: */
2160: if (hp->h_meta->h_siblinghead.cqh_first && (hp->h_meta->h_siblinghead.cqh_first != hp->h_meta->h_siblinghead.cqh_last)) {
2161: simple_lock(&hp->h_meta->h_siblinglock);
2162: hasSiblings = true;
2163: }
2164:
2165: if (hasSiblings) {
2166: struct vnode *tvp;
2167: struct hfsnode *nhp;
2168:
2169: DBG_ASSERT(H_FORKTYPE(hp)==kDataFork || H_FORKTYPE(hp)==kRsrcFork);
2170: /* Lock the sibling list, this ensures no entry leaves or is added unexpectanly */
2171:
2172: /* Loop through all siblings, skipping ourselves */
2173: for (nhp = hp->h_meta->h_siblinghead.cqh_first; nhp != (void *)&hp->h_meta->h_siblinghead; nhp = nhp->h_sibling.cqe_next) {
2174: if (nhp == hp) /* skip ourselves */
2175: continue;
2176: tvp = HTOV(nhp);
2177:
2178: /* Check to see if other forks are in use */
2179: simple_lock(&tvp->v_interlock);
2180: use_count = tvp->v_usecount;
2181: simple_unlock(&tvp->v_interlock);
2182: if (use_count > 0) {
2183: if (ap->a_cnp->cn_flags & NODELETEBUSY || hfsmp->hfs_private_metadata_dir == 0) {
2184: retval = EBUSY;
2185: break;
2186: }
2187: else
2188: filebusy = 1;
2189: };
2190:
2191: /* Get a lock, for the rest */
2192: /* The only error that vget returns is when the vnode is going away, so ignore it */
2193: if (vget(tvp, LK_EXCLUSIVE | LK_RETRY, p))
2194: continue;
2195:
2196: /*
2197: * XXX SER vnode_uncache() unlocks the vnode and the wait
2198: * to regain the lock. VERY BAD. This behavior should be changed in
2199: * the future.
2200: * See the comment in vnode_uncache()
2201: */
2202: (void) vnode_uncache(tvp);
2203:
2204: /*
2205: * Should be relocked at this point..now flush out the memory
2206: * XXX SER An intelligient person would ask, why flush out changes
2207: * that are going to be deleted? See the next comment.
2208: */
2209: if ((nhp->h_nodeflags & IN_MODIFIED) || (VTOFCB(tvp)->fcbFlags & fcbModifiedMask))
2210: {
2211: DBG_ASSERT((VTOH(tvp)->h_nodeflags & IN_MODIFIED) != 0);
2212: VOP_UPDATE(tvp, &tv, &tv, 0);
2213: };
2214:
2215: VPUT(tvp);
2216:
2217: };
2218:
2219: simple_unlock(&hp->h_meta->h_siblinglock);
2220:
2221: if (retval)
2222: goto out;
2223:
2224: };
2225:
2226: /*
2227: * remove the entry from the namei cache:
2228: * We do it early before any linking/busy file wierdness, make sure the
2229: * original is gone
2230: */
2231: cache_purge(vp);
2232:
2233: /* Flush out any catalog changes */
2234: /* XXX SER: This is a hack, becasue hfsDelete reads the data from the disk
2235: * and not from memory which is more correct
2236: */
2237: if ((hp->h_nodeflags & IN_MODIFIED) || (HTOFCB(hp)->fcbFlags & fcbModifiedMask))
2238: {
2239: DBG_ASSERT((hp->h_nodeflags & IN_MODIFIED) != 0);
2240: VOP_UPDATE(vp, &tv, &tv, 0);
2241: }
2242:
2243: /* lock catalog b-tree */
2244: retval = hfs_metafilelocking(hfsmp, kHFSCatalogFileID, LK_EXCLUSIVE, p);
2245: if (retval != E_NONE) {
2246: retval = EBUSY;
2247: goto out;
2248: }
2249:
2250:
2251: #if HFS_HARDLINKS
2252: /*
2253: * Multi-linked files just need their link node deleted from the catalog
2254: */
2255: if (hp->h_meta->h_metaflags & IN_DATANODE) {
2256:
2257: if ((ap->a_cnp->cn_flags & HASBUF) == 0 ||
2258: ap->a_cnp->cn_nameptr[0] == '\0') {
2259: retval = ENOENT; /* name missing */
2260: goto out2;
2261: }
2262:
2263: /* lock extents b-tree (also protects volume bitmap) */
2264: retval = hfs_metafilelocking(hfsmp, kHFSExtentsFileID, LK_EXCLUSIVE, p);
2265: if (retval != E_NONE) {
2266: retval = EBUSY;
2267: goto out2; /* unlock catalog b-tree on the way out */
2268: }
2269:
2270: retval = hfsDelete (HTOVCB(hp), H_FILEID(VTOH(dvp)),
2271: ap->a_cnp->cn_nameptr, TRUE, H_HINT(hp));
2272:
2273: (void) hfs_metafilelocking(hfsmp, kHFSExtentsFileID, LK_RELEASE, p);
2274:
2275: if (retval != 0)
2276: goto out2;
2277:
2278: hp->h_nodeflags |= IN_CHANGE;
2279: if (--hp->h_meta->h_nlink < 1)
2280: hp->h_meta->h_metaflags |= IN_DELETED;
2281:
2282: /* name and parent fields are no longer valid so invalidate them */
2283: H_DIRID(hp) = kUnknownID;
2284: hfs_set_metaname("\0", hp->h_meta);
2285:
2286: if ((ap->a_cnp->cn_flags & (HASBUF | SAVENAME)) == (HASBUF | SAVENAME))
2287: FREE_ZONE(ap->a_cnp->cn_pnbuf, ap->a_cnp->cn_pnlen, M_NAMEI);
2288:
2289: goto out2; /* link deleted, all done */
2290: }
2291: #endif
2292:
2293: /*
2294: * To make the HFS filesystem follow UFS unlink semantics, a remove of
2295: * an active vnode is translated to a move/rename so the file appears
2296: * deleted. Later, the file is removed by hfs_inactive on the hfsnode.
2297: */
2298: if (filebusy) {
2299: UInt32 hint = H_HINT(hp);
2300: char nodeName[32];
2301:
2302: MAKE_DELETED_NAME(nodeName, H_FILEID(hp));
2303:
2304: retval = hfsMoveRename (HTOVCB(hp), H_DIRID(hp), H_NAME(hp),
2305: hfsmp->hfs_private_metadata_dir, nodeName, &hint);
2306: if (retval) goto out2;
2307:
2308: hp->h_meta->h_metaflags |= IN_DELETED;
2309: hp->h_nodeflags |= IN_CHANGE;
2310:
2311: /* update name so Catalog lookups succeed */
2312: H_HINT(hp) = hint;
2313: H_DIRID(hp) = hfsmp->hfs_private_metadata_dir;
2314: hfs_set_metaname(nodeName, hp->h_meta);
2315:
2316: goto out2; /* all done, unlock the catalog */
2317: }
2318:
2319: /* Invalidate the buffers */
2320: if ((retval= vinvalbuf(vp, 0, NOCRED, p, 0, 0)))
2321: goto out2;
2322:
2323: /* lock extents b-tree (also protects volume bitmap) */
2324: retval = hfs_metafilelocking(hfsmp, kHFSExtentsFileID, LK_EXCLUSIVE, p);
2325: if (retval != E_NONE) {
2326: retval = EBUSY;
2327: goto out2; /* unlock catalog b-tree on the way out */
2328: }
2329:
2330: /* remove entry from catalog and free any blocks used */
2331: retval = hfsDelete (HTOVCB(hp), H_DIRID(hp), H_NAME(hp), TRUE, H_HINT(hp));
2332:
2333: /* Clean up */
2334: (void) hfs_metafilelocking(hfsmp, kHFSExtentsFileID, LK_RELEASE, p);
2335:
2336: hp->h_meta->h_mode = 0; /* Makes the node go away...see inactive */
2337: /* XXX SER Anything else so that sibling, if any, goes away */
2338:
2339: out2:
2340: (void) hfs_metafilelocking(hfsmp, kHFSCatalogFileID, LK_RELEASE, p);
2341:
2342: out:;
2343:
2344: if (! retval)
2345: VTOH(dvp)->h_nodeflags |= IN_CHANGE | IN_UPDATE;
2346:
2347: if (dvp == vp) {
2348: VRELE(vp);
2349: } else {
2350: VPUT(vp);
2351: };
2352:
2353: VPUT(dvp);
2354: DBG_VOP_LOCKS_TEST(retval);
2355: return (retval);
2356: }
2357:
2358:
2359: /*
2360:
2361: #% rename sourcePar_vp U U U
2362: #% rename source_vp U U U
2363: #% rename targetPar_vp L U U
2364: #% rename target_vp X U U
2365: #
2366: vop_rename {
2367: IN WILLRELE struct vnode *sourcePar_vp;
2368: IN WILLRELE struct vnode *source_vp;
2369: IN struct componentname *source_cnp;
2370: IN WILLRELE struct vnode *targetPar_vp;
2371: IN WILLRELE struct vnode *target_vp;
2372: IN struct componentname *target_cnp;
2373:
2374:
2375: */
2376: /*
2377: * On entry:
2378: * source's parent directory is unlocked
2379: * source file or directory is unlocked
2380: * destination's parent directory is locked
2381: * destination file or directory is locked if it exists
2382: *
2383: * On exit:
2384: * all denodes should be released
2385: *
2386: */
2387:
2388: static int
2389: hfs_rename(ap)
2390: struct vop_rename_args /* {
2391: struct vnode *a_fdvp;
2392: struct vnode *a_fvp;
2393: struct componentname *a_fcnp;
2394: struct vnode *a_tdvp;
2395: struct vnode *a_tvp;
2396: struct componentname *a_tcnp;
2397: } */ *ap;
2398: {
2399: struct vnode *target_vp = ap->a_tvp;
2400: struct vnode *targetPar_vp = ap->a_tdvp;
2401: struct vnode *source_vp = ap->a_fvp;
2402: struct vnode *sourcePar_vp = ap->a_fdvp;
2403: struct componentname *target_cnp = ap->a_tcnp;
2404: struct componentname *source_cnp = ap->a_fcnp;
2405: struct proc *p = source_cnp->cn_proc;
2406: struct hfsnode *target_hp, *targetPar_hp, *source_hp, *sourcePar_hp;
2407: u_short doingdirectory = 0, oldparent = 0, newparent = 0;
2408: int retval = 0;
2409: struct timeval tv;
2410: struct hfsCatalogInfo catInfo;
2411: DBG_VOP_LOCKS_DECL(4);
2412:
2413: DBG_FUNC_NAME("rename");DBG_VOP_PRINT_FUNCNAME();DBG_VOP_CONT(("\n"));
2414: DBG_VOP_CONT(("\t"));DBG_VOP_CONT(("Source:\t"));DBG_VOP_PRINT_VNODE_INFO(ap->a_fvp);DBG_VOP_CONT(("\n"));
2415: DBG_VOP_CONT(("\t"));DBG_VOP_CONT(("SourcePar: "));DBG_VOP_PRINT_VNODE_INFO(ap->a_fdvp);DBG_VOP_CONT(("\n"));
2416: DBG_VOP_CONT(("\t"));DBG_VOP_CONT(("Target:\t"));DBG_VOP_PRINT_VNODE_INFO(ap->a_tvp);DBG_VOP_CONT(("\n"));
2417: DBG_VOP_CONT(("\t"));DBG_VOP_CONT(("TargetPar: "));DBG_VOP_PRINT_VNODE_INFO(ap->a_tdvp);DBG_VOP_CONT(("\n"));
2418: DBG_VOP_CONT(("\t"));DBG_VOP_CONT(("SourceName:\t"));DBG_VOP_PRINT_CPN_INFO(ap->a_fcnp);DBG_VOP_CONT(("\n"));
2419: DBG_VOP_CONT(("\t"));DBG_VOP_CONT(("TargetName:\t"));DBG_VOP_PRINT_CPN_INFO(ap->a_tcnp);DBG_VOP_CONT(("\n"));
2420: DBG_VOP_LOCKS_INIT(0,ap->a_fdvp, VOPDBG_UNLOCKED, VOPDBG_UNLOCKED, VOPDBG_UNLOCKED, VOPDBG_POS);
2421: DBG_VOP_LOCKS_INIT(1,ap->a_fvp, VOPDBG_UNLOCKED, VOPDBG_UNLOCKED, VOPDBG_UNLOCKED, VOPDBG_POS);
2422: DBG_VOP_LOCKS_INIT(2,ap->a_tdvp, VOPDBG_LOCKED, VOPDBG_UNLOCKED, VOPDBG_UNLOCKED, VOPDBG_POS);
2423: DBG_VOP_LOCKS_INIT(3,ap->a_tvp, VOPDBG_LOCKNOTNIL, VOPDBG_UNLOCKED, VOPDBG_UNLOCKED, VOPDBG_POS);
2424: WRITE_CK(ap->a_fdvp, funcname);
2425: DBG_HFS_NODE_CHECK(ap->a_fdvp);
2426: DBG_HFS_NODE_CHECK(ap->a_tdvp);
2427:
2428: #if HFS_DIAGNOSTIC
2429: if ((target_cnp->cn_flags & HASBUF) == 0 ||
2430: (source_cnp->cn_flags & HASBUF) == 0)
2431: panic("hfs_rename: no name");
2432: #endif
2433:
2434: DBG_ASSERT((ap->a_fdvp->v_type == VDIR) && (ap->a_tdvp->v_type == VDIR));
2435: target_hp = targetPar_hp = source_hp = sourcePar_hp = 0;
2436:
2437: /*
2438: * Check for cross-device rename.
2439: */
2440: if ((source_vp->v_mount != targetPar_vp->v_mount) ||
2441: (target_vp && (source_vp->v_mount != target_vp->v_mount))) {
2442: retval = EXDEV;
2443: goto abortit;
2444: }
2445:
2446: /*
2447: * Check for access permissions
2448: */
2449: if (target_vp && ((VTOH(target_vp)->h_meta->h_pflags & (IMMUTABLE | APPEND)) ||
2450: (VTOH(targetPar_vp)->h_meta->h_pflags & APPEND))) {
2451: retval = EPERM;
2452: goto abortit;
2453: }
2454:
2455: if ((retval = vn_lock(source_vp, LK_EXCLUSIVE, p)))
2456: goto abortit;
2457:
2458: sourcePar_hp = VTOH(sourcePar_vp);
2459: source_hp = VTOH(source_vp);
2460: oldparent = H_FILEID(sourcePar_hp);
2461: if ((source_hp->h_meta->h_pflags & (IMMUTABLE | APPEND)) || (sourcePar_hp->h_meta->h_pflags & APPEND)) {
2462: VOP_UNLOCK(source_vp, 0, p);
2463: retval = EPERM;
2464: goto abortit;
2465: }
2466:
2467: /*
2468: * Be sure we are not renaming ".", "..", or an alias of ".". This
2469: * leads to a crippled directory tree. It's pretty tough to do a
2470: * "ls" or "pwd" with the "." directory entry missing, and "cd .."
2471: * doesn't work if the ".." entry is missing.
2472: */
2473: if ((source_hp->h_meta->h_mode & IFMT) == IFDIR) {
2474: if ((source_cnp->cn_namelen == 1 && source_cnp->cn_nameptr[0] == '.')
2475: || sourcePar_hp == source_hp
2476: || (source_cnp->cn_flags&ISDOTDOT)
2477: || (source_hp->h_nodeflags & IN_RENAME)) {
2478: VOP_UNLOCK(source_vp, 0, p);
2479: retval = EINVAL;
2480: goto abortit;
2481: }
2482: source_hp->h_nodeflags |= IN_RENAME;
2483: doingdirectory = TRUE;
2484: }
2485:
2486: /*
2487: *
2488: * >>>> Transit between abort and bad <<<<
2489: *
2490: */
2491:
2492: targetPar_hp = VTOH(targetPar_vp);
2493: if (target_vp)
2494: target_hp = VTOH(target_vp);
2495: else
2496: DBG_ASSERT(target_hp == NULL);
2497:
2498: newparent = H_FILEID(targetPar_hp);
2499:
2500: /* Test to make sure we are not crossing devices */
2501: /* XXX SER Is this necesary, does catalog manager take care of this? */
2502: if (target_vp) {
2503: if (H_DEV(target_hp) != H_DEV(targetPar_hp) || H_DEV(target_hp) != H_DEV(source_hp))
2504: panic("rename: EXDEV");
2505: }
2506: else {
2507: if (H_DEV(targetPar_hp) != H_DEV(source_hp))
2508: panic("rename: EXDEV");
2509: };
2510:
2511: retval = VOP_ACCESS(source_vp, VWRITE, target_cnp->cn_cred, target_cnp->cn_proc);
2512: if (doingdirectory && (newparent != oldparent)) {
2513: if (retval) /* write access check above */
2514: goto bad;
2515: }
2516: retval = 0; /* Reset value from above, we dont care about it anymore */
2517:
2518: /*
2519: * If the destination exists, then be sure its type (file or dir)
2520: * matches that of the source. And, if it is a directory make sure
2521: * it is empty. Then delete the destination.
2522: */
2523: if (target_vp) {
2524:
2525: /*
2526: * If the parent directory is "sticky", then the user must
2527: * own the parent directory, or the destination of the rename,
2528: * otherwise the destination may not be changed (except by
2529: * root). This implements append-only directories.
2530: */
2531: if ((targetPar_hp->h_meta->h_mode & S_ISTXT) && (target_cnp->cn_cred->cr_uid != 0) &&
2532: target_cnp->cn_cred->cr_uid != targetPar_hp->h_meta->h_uid &&
2533: target_cnp->cn_cred->cr_uid != target_hp->h_meta->h_uid) {
2534: retval = EPERM;
2535: goto bad;
2536: }
2537:
2538: /*
2539: * VOP_REMOVE will vput targetPar_vp so we better bump
2540: * its ref count and relockit, always set target_vp to
2541: * NULL afterwards to indicate that were done with it.
2542: */
2543: VREF(targetPar_vp);
2544: if (target_vp->v_type == VREG) {
2545: (void) vnode_uncache(target_vp);
2546: if (ISMAPPEDFILE(target_vp)) {
2547: ubc_unlink(target_vp);
2548: }
2549: }
2550: cache_purge(target_vp);
2551:
2552: #if HFS_HARDLINKS
2553: target_cnp->cn_flags &= ~SAVENAME;
2554: #endif
2555: retval = VOP_REMOVE(targetPar_vp, target_vp, target_cnp);
2556: (void) vn_lock(targetPar_vp, LK_EXCLUSIVE | LK_RETRY, p);
2557:
2558: target_vp = NULL;
2559: target_hp = NULL;
2560:
2561: if (retval) goto bad;
2562:
2563: };
2564:
2565:
2566: if (newparent != oldparent)
2567: vn_lock(sourcePar_vp, LK_EXCLUSIVE | LK_RETRY, p);
2568:
2569: /* lock catalog b-tree */
2570: retval = hfs_metafilelocking(VTOHFS(source_vp), kHFSCatalogFileID, LK_EXCLUSIVE, p);
2571: if (retval) {
2572: if (newparent != oldparent) /* unlock the lock we just got */
2573: VOP_UNLOCK(sourcePar_vp, 0, p);
2574: goto bad;
2575: };
2576:
2577: /* remove the existing entry from the namei cache: */
2578: cache_purge(source_vp);
2579:
2580: /* use source_cnp instead of H_NAME(source_hp) in case source is a hard link */
2581: retval = hfsMoveRename( HTOVCB(source_hp), H_DIRID(source_hp), source_cnp->cn_nameptr,
2582: H_FILEID(VTOH(targetPar_vp)), target_cnp->cn_nameptr, &H_HINT(source_hp));
2583:
2584: if (retval == 0) {
2585: /* Look up the catalog entry just renamed since it might have been auto-decomposed */
2586: catInfo.hint = H_HINT(source_hp);
2587: retval = hfsLookup(HTOVCB(source_hp), H_FILEID(targetPar_hp), target_cnp->cn_nameptr, target_cnp->cn_namelen, &catInfo);
2588: }
2589:
2590: /* unlock catalog b-tree */
2591: (void) hfs_metafilelocking(VTOHFS(source_vp), kHFSCatalogFileID, LK_RELEASE, p);
2592:
2593: if (newparent != oldparent)
2594: VOP_UNLOCK(sourcePar_vp, 0, p);
2595:
2596: if (retval) goto bad;
2597:
2598: H_DIRID(source_hp) = H_FILEID(targetPar_hp);
2599:
2600: hfs_set_metaname(catInfo.spec.name, source_hp->h_meta);
2601:
2602: source_hp->h_nodeflags &= ~IN_RENAME;
2603:
2604:
2605: /*
2606: * Timestamp both parent directories.
2607: * Note that if this is a rename within the same directory,
2608: * (where targetPar_hp == sourcePar_hp)
2609: * the code below is still safe and correct.
2610: */
2611: targetPar_hp->h_nodeflags |= IN_UPDATE;
2612: sourcePar_hp->h_nodeflags |= IN_UPDATE;
2613: tv = time;
2614: HFSTIMES(targetPar_hp, &tv, &tv);
2615: HFSTIMES(sourcePar_hp, &tv, &tv);
2616:
2617: VPUT(targetPar_vp);
2618: VRELE(sourcePar_vp);
2619: VPUT(source_vp);
2620:
2621: DBG_VOP_LOCKS_TEST(retval);
2622: if (retval != E_NONE) {
2623: DBG_VOP_PRINT_FUNCNAME();DBG_VOP_CONT(("\tReturning with error %d\n",retval));
2624: }
2625: return (retval);
2626:
2627: bad:;
2628: if (retval && doingdirectory)
2629: source_hp->h_nodeflags &= ~IN_RENAME;
2630:
2631: if (targetPar_vp == target_vp)
2632: VRELE(targetPar_vp);
2633: else
2634: VPUT(targetPar_vp);
2635:
2636: if (target_vp)
2637: VPUT(target_vp);
2638:
2639: VRELE(sourcePar_vp);
2640:
2641: if (VOP_ISLOCKED(source_vp))
2642: VPUT(source_vp);
2643: else
2644: VRELE(source_vp);
2645:
2646: DBG_VOP_LOCKS_TEST(retval);
2647: if (retval != E_NONE) {
2648: DBG_VOP_PRINT_FUNCNAME();DBG_VOP_CONT(("\tReturning with error %d\n",retval));
2649: }
2650: return (retval);
2651:
2652: abortit:;
2653:
2654: VOP_ABORTOP(targetPar_vp, target_cnp); /* XXX, why not in NFS? */
2655:
2656: if (targetPar_vp == target_vp)
2657: VRELE(targetPar_vp);
2658: else
2659: VPUT(targetPar_vp);
2660:
2661: if (target_vp)
2662: VPUT(target_vp);
2663:
2664: VOP_ABORTOP(sourcePar_vp, source_cnp); /* XXX, why not in NFS? */
2665:
2666: VRELE(sourcePar_vp);
2667: VRELE(source_vp);
2668:
2669: DBG_VOP_LOCKS_TEST(retval);
2670: if (retval != E_NONE) {
2671: DBG_VOP_PRINT_FUNCNAME();DBG_VOP_CONT(("\tReturning with error %d\n",retval));
2672: }
2673: return (retval);
2674: }
2675:
2676:
2677:
2678: /*
2679: * Mkdir system call
2680: #% mkdir dvp L U U
2681: #% mkdir vpp - L -
2682: #
2683: vop_mkdir {
2684: IN WILLRELE struct vnode *dvp;
2685: OUT struct vnode **vpp;
2686: IN struct componentname *cnp;
2687: IN struct vattr *vap;
2688:
2689: We are responsible for freeing the namei buffer, it is done in hfs_makenode(), unless there is
2690: a previous error.
2691:
2692: */
2693:
2694: int
2695: hfs_mkdir(ap)
2696: struct vop_mkdir_args /* {
2697: struct vnode *a_dvp;
2698: struct vnode **a_vpp;
2699: struct componentname *a_cnp;
2700: struct vattr *a_vap;
2701: } */ *ap;
2702: {
2703: struct proc *p = current_proc();
2704: int retval;
2705: int mode = MAKEIMODE(ap->a_vap->va_type, ap->a_vap->va_mode);
2706:
2707: DBG_FUNC_NAME("mkdir");
2708: DBG_VOP_LOCKS_DECL(2);
2709: DBG_VOP_PRINT_FUNCNAME();
2710: DBG_VOP_PRINT_VNODE_INFO(ap->a_dvp);
2711: DBG_VOP_PRINT_CPN_INFO(ap->a_cnp);DBG_VOP_CONT(("\n"));
2712:
2713: DBG_VOP_LOCKS_INIT(0,ap->a_dvp, VOPDBG_LOCKED, VOPDBG_UNLOCKED, VOPDBG_UNLOCKED, VOPDBG_POS);
2714: DBG_VOP_LOCKS_INIT(1,*ap->a_vpp, VOPDBG_IGNORE, VOPDBG_LOCKED, VOPDBG_IGNORE, VOPDBG_POS);
2715:
2716: DBG_VOP(("%s: parent 0x%x (%s) ap->a_cnp->cn_nameptr %s\n", funcname, (u_int)VTOH(ap->a_dvp), H_NAME(VTOH(ap->a_dvp)), ap->a_cnp->cn_nameptr));
2717: WRITE_CK( ap->a_dvp, funcname);
2718: DBG_HFS_NODE_CHECK(ap->a_dvp);
2719: DBG_ASSERT(ap->a_dvp->v_type == VDIR);
2720:
2721: /* lock catalog b-tree */
2722: retval = hfs_metafilelocking(VTOHFS(ap->a_dvp), kHFSCatalogFileID, LK_EXCLUSIVE, p);
2723: if (retval != E_NONE) {
2724: VOP_ABORTOP(ap->a_dvp, ap->a_cnp);
2725: VPUT(ap->a_dvp);
2726: DBG_VOP_LOCKS_TEST( retval);
2727: return (retval);
2728: }
2729:
2730: /* Create the vnode */
2731: DBG_ASSERT((ap->a_cnp->cn_flags & SAVESTART) == 0);
2732: retval = hfs_makenode(mode, 0, ap->a_dvp, ap->a_vpp, ap->a_cnp);
2733: DBG_VOP_UPDATE_VP(1, *ap->a_vpp);
2734:
2735: /* unlock catalog b-tree */
2736: (void) hfs_metafilelocking(VTOHFS(ap->a_dvp), kHFSCatalogFileID, LK_RELEASE, p);
2737:
2738: if (retval != E_NONE) {
2739: DBG_ERR(("%s: hfs_makenode FAILED: %s, %s\n", funcname, ap->a_cnp->cn_nameptr, H_NAME(VTOH(ap->a_dvp))));
2740: DBG_VOP_LOCKS_TEST(retval);
2741: return (retval);
2742: }
2743:
2744: DBG_VOP_LOCKS_TEST(E_NONE);
2745: return (E_NONE);
2746: }
2747:
2748: /*
2749: * Rmdir system call.
2750: #% rmdir dvp L U U
2751: #% rmdir vp L U U
2752: #
2753: vop_rmdir {
2754: IN WILLRELE struct vnode *dvp;
2755: IN WILLRELE struct vnode *vp;
2756: IN struct componentname *cnp;
2757:
2758: */
2759:
2760: int
2761: hfs_rmdir(ap)
2762: struct vop_rmdir_args /* {
2763: struct vnode *a_dvp;
2764: struct vnode *a_vp;
2765: struct componentname *a_cnp;
2766: } */ *ap;
2767: {
2768: struct vnode *vp = ap->a_vp;
2769: struct vnode *dvp = ap->a_dvp;
2770: struct hfsnode *hp = VTOH(vp);
2771: struct proc *p = current_proc();
2772: int retval;
2773: DBG_FUNC_NAME("rmdir");
2774: DBG_VOP_LOCKS_DECL(2);
2775: DBG_VOP_PRINT_FUNCNAME();
2776: DBG_VOP(("\tParent: "));DBG_VOP_PRINT_VNODE_INFO(ap->a_dvp);DBG_VOP_CONT(("\n"));
2777: DBG_VOP(("\tTarget: "));DBG_VOP_PRINT_VNODE_INFO(ap->a_vp);DBG_VOP_CONT(("\n"));
2778: DBG_VOP(("\tTarget Name: "));DBG_VOP_PRINT_CPN_INFO(ap->a_cnp);DBG_VOP_CONT(("\n"));
2779:
2780: DBG_VOP_LOCKS_INIT(0,ap->a_dvp, VOPDBG_LOCKED, VOPDBG_UNLOCKED, VOPDBG_UNLOCKED, VOPDBG_POS);
2781: DBG_VOP_LOCKS_INIT(1,ap->a_vp, VOPDBG_LOCKED, VOPDBG_UNLOCKED, VOPDBG_UNLOCKED, VOPDBG_POS);
2782:
2783: if (dvp == vp) {
2784: VRELE(vp);
2785: VPUT(vp);
2786: DBG_VOP_LOCKS_TEST(EINVAL);
2787: return (EINVAL);
2788: }
2789:
2790: /*
2791: * HFS differs from UFS here in that we don't allow removing
2792: * a directory that in use by others - even if its empty.
2793: *
2794: * In the future we might want to allow this just like we do
2795: * for files (by renaming the busy directory).
2796: */
2797: #if 0
2798: if (vp->v_usecount > 1) {
2799: DBG_ERR(("%s: dir is busy, usecount is %d\n", funcname, vp->v_usecount ));
2800: retval = EBUSY;
2801: goto Err_Exit;
2802: }
2803: #endif
2804: /* remove the entry from the namei cache: */
2805: cache_purge(vp);
2806:
2807: /* lock catalog b-tree */
2808: retval = hfs_metafilelocking(VTOHFS(vp), kHFSCatalogFileID, LK_EXCLUSIVE, p);
2809: if (retval != E_NONE) {
2810: goto Err_Exit;
2811: }
2812:
2813: /* remove entry from catalog */
2814: retval = hfsDelete (HTOVCB(hp), H_DIRID(hp), H_NAME(hp), FALSE, H_HINT(hp));
2815: hp->h_meta->h_mode = 0; /* Makes the vnode go away...see inactive */
2816:
2817: /* unlock catalog b-tree */
2818: (void) hfs_metafilelocking(VTOHFS(vp), kHFSCatalogFileID, LK_RELEASE, p);
2819:
2820: /* Set the parent to be updated */
2821: if (! retval)
2822: VTOH(dvp)->h_nodeflags |= IN_CHANGE | IN_UPDATE;
2823:
2824: Err_Exit:;
2825: if (dvp != 0)
2826: VPUT(dvp);
2827: VPUT(vp);
2828:
2829: DBG_VOP_LOCKS_TEST(retval);
2830: return (retval);
2831: }
2832:
2833: /*
2834: * symlink -- make a symbolic link
2835: #% symlink dvp L U U
2836: #% symlink vpp - U -
2837: #
2838: # XXX - note that the return vnode has already been VRELE'ed
2839: # by the filesystem layer. To use it you must use vget,
2840: # possibly with a further namei.
2841: #
2842: vop_symlink {
2843: IN WILLRELE struct vnode *dvp;
2844: OUT WILLRELE struct vnode **vpp;
2845: IN struct componentname *cnp;
2846: IN struct vattr *vap;
2847: IN char *target;
2848:
2849: We are responsible for freeing the namei buffer, it is done in hfs_makenode(), unless there is
2850: a previous error.
2851:
2852:
2853: */
2854:
2855: int
2856: hfs_symlink(ap)
2857: struct vop_symlink_args /* {
2858: struct vnode *a_dvp;
2859: struct vnode **a_vpp;
2860: struct componentname *a_cnp;
2861: struct vattr *a_vap;
2862: char *a_target;
2863: } */ *ap;
2864: {
2865: register struct vnode *vp, **vpp = ap->a_vpp;
2866: struct proc *p = current_proc();
2867: struct hfsnode *hp;
2868: u_int32_t dfltClump;
2869: int len, retval;
2870: DBG_FUNC_NAME("symlink");
2871: DBG_VOP_LOCKS_DECL(2);
2872: DBG_VOP_PRINT_FUNCNAME();
2873: DBG_VOP_LOCKS_INIT(0,ap->a_dvp, VOPDBG_LOCKED, VOPDBG_UNLOCKED, VOPDBG_UNLOCKED, VOPDBG_POS);
2874: DBG_VOP_LOCKS_INIT(1,*ap->a_vpp, VOPDBG_IGNORE, VOPDBG_UNLOCKED, VOPDBG_IGNORE, VOPDBG_POS);
2875:
2876: if (VTOVCB(ap->a_dvp)->vcbSigWord != kHFSPlusSigWord) {
2877: VOP_ABORTOP(ap->a_dvp, ap->a_cnp);
2878: VPUT(ap->a_dvp);
2879: DBG_VOP((" ...sorry HFS disks don't support symbolic links.\n"));
2880: DBG_VOP_LOCKS_TEST(EOPNOTSUPP);
2881: return (EOPNOTSUPP);
2882: }
2883:
2884: /* lock catalog b-tree */
2885: retval = hfs_metafilelocking(VTOHFS(ap->a_dvp), kHFSCatalogFileID, LK_EXCLUSIVE, p);
2886: if (retval != E_NONE) {
2887: VOP_ABORTOP(ap->a_dvp, ap->a_cnp);
2888: VPUT(ap->a_dvp);
2889: DBG_VOP_LOCKS_TEST( retval);
2890: return (retval);
2891: }
2892:
2893: /* Create the vnode */
2894: retval = hfs_makenode(IFLNK | ap->a_vap->va_mode, 0, ap->a_dvp, vpp, ap->a_cnp);
2895: DBG_VOP_UPDATE_VP(1, *ap->a_vpp);
2896:
2897: /* unlock catalog b-tree */
2898: (void) hfs_metafilelocking(VTOHFS(ap->a_dvp), kHFSCatalogFileID, LK_RELEASE, p);
2899:
2900: if (retval != E_NONE) {
2901: DBG_VOP_LOCKS_TEST(retval);
2902: return (retval);
2903: }
2904:
2905:
2906: vp = *vpp;
2907: len = strlen(ap->a_target);
2908: hp = VTOH(vp);
2909: dfltClump = hp->fcbClmpSize;
2910: /* make clump size minimal */
2911: hp->fcbClmpSize = VTOVCB(vp)->blockSize;
2912: retval = vn_rdwr(UIO_WRITE, vp, ap->a_target, len, (off_t)0,
2913: UIO_SYSSPACE, IO_NODELOCKED, ap->a_cnp->cn_cred, (int *)0,
2914: (struct proc *)0);
2915: hp->fcbClmpSize = dfltClump;
2916:
2917:
2918: VPUT(vp);
2919: DBG_VOP_LOCKS_TEST(retval);
2920: return (retval);
2921: }
2922:
2923:
2924: /*
2925: * Dummy dirents to simulate the "." and ".." entries of the directory
2926: * in a hfs filesystem. HFS doesn't provide these on disk. Note that
2927: * the size of these entries is the smallest needed to represent them
2928: * (only 12 byte each).
2929: */
2930: static hfsdotentry rootdots[2] = {
2931: {
2932: 1, /* d_fileno */
2933: sizeof(struct hfsdotentry), /* d_reclen */
2934: DT_DIR, /* d_type */
2935: 1, /* d_namlen */
2936: "." /* d_name */
2937: },
2938: {
2939: 1, /* d_fileno */
2940: sizeof(struct hfsdotentry), /* d_reclen */
2941: DT_DIR, /* d_type */
2942: 2, /* d_namlen */
2943: ".." /* d_name */
2944: }
2945: };
2946:
2947: static hfsdotentry emptyentry = { 0 };
2948:
2949: /* 4.3 Note:
2950: * There is some confusion as to what the semantics of uio_offset are.
2951: * In ufs, it represents the actual byte offset within the directory
2952: * "file." HFS, however, just uses it as an entry counter - essentially
2953: * assuming that it has no meaning except to the hfs_readdir function.
2954: * This approach would be more efficient here, but some callers may
2955: * assume the uio_offset acts like a byte offset. NFS in fact
2956: * monkeys around with the offset field a lot between readdir calls.
2957: *
2958: * The use of the resid uiop->uio_resid and uiop->uio_iov->iov_len
2959: * fields is a mess as well. The libc function readdir() returns
2960: * NULL (indicating the end of a directory) when either
2961: * the getdirentries() syscall (which calls this and returns
2962: * the size of the buffer passed in less the value of uiop->uio_resid)
2963: * returns 0, or a direct record with a d_reclen of zero.
2964: * nfs_server.c:rfs_readdir(), on the other hand, checks for the end
2965: * of the directory by testing uiop->uio_resid == 0. The solution
2966: * is to pad the size of the last struct direct in a given
2967: * block to fill the block if we are not at the end of the directory.
2968: */
2969:
2970: struct callbackstate {
2971: u_int32_t cbs_parentID;
2972: u_int32_t cbs_hiddenDirID;
2973: off_t cbs_lastoffset;
2974: struct uio * cbs_uio;
2975: ExtendedVCB * cbs_vcb;
2976: int16_t cbs_hfsPlus;
2977: int16_t cbs_result;
2978: };
2979:
2980:
2981: SInt32
2982: ProcessCatalogEntry(const CatalogKey *ckp, const CatalogRecord *crp,
2983: u_int16_t recordLen, struct callbackstate *state)
2984: {
2985: CatalogName *cnp;
2986: ByteCount utf8chars;
2987: u_int32_t curID;
2988: OSErr result;
2989: struct dirent catent;
2990:
2991: if (state->cbs_hfsPlus)
2992: curID = ckp->hfsPlus.parentID;
2993: else
2994: curID = ckp->hfs.parentID;
2995:
2996: /* We're done when parent directory changes */
2997: if (state->cbs_parentID != curID) {
2998: lastitem:
2999: /*
3000: * The NSDirectoryList class chokes on empty records (it doesnt check d_reclen!)
3001: * so remove padding for now...
3002: */
3003: #if 0
3004: /*
3005: * Pad the end of list with an empty record.
3006: * This eliminates an extra call by readdir(3c).
3007: */
3008: catent.d_fileno = 0;
3009: catent.d_reclen = 0;
3010: catent.d_type = 0;
3011: catent.d_namlen = 0;
3012: *(int32_t*)&catent.d_name[0] = 0;
3013:
3014: state->cbs_lastoffset = state->cbs_uio->uio_offset;
3015:
3016: state->cbs_result = uiomove((caddr_t) &catent, 12, state->cbs_uio);
3017: if (state->cbs_result == 0)
3018: state->cbs_result = ENOENT;
3019: #else
3020: state->cbs_lastoffset = state->cbs_uio->uio_offset;
3021: state->cbs_result = ENOENT;
3022: #endif
3023: return (0); /* stop */
3024: }
3025:
3026: if (state->cbs_hfsPlus) {
3027: switch(crp->recordType) {
3028: case kHFSPlusFolderRecord:
3029: catent.d_type = DT_DIR;
3030: catent.d_fileno = crp->hfsPlusFolder.folderID;
3031: break;
3032: case kHFSPlusFileRecord:
3033: catent.d_type = DT_REG;
3034: catent.d_fileno = crp->hfsPlusFile.fileID;
3035: break;
3036: default:
3037: return (0); /* stop */
3038: };
3039:
3040: cnp = (CatalogName*) &ckp->hfsPlus.nodeName;
3041: /*XXX need to add name mangling for long names */
3042: result = ConvertUnicodeToUTF8(cnp->ustr.length * sizeof(UniChar),
3043: cnp->ustr.unicode, NAME_MAX + 1, &utf8chars, catent.d_name);
3044: } else { /* hfs */
3045: switch(crp->recordType) {
3046: case kHFSFolderRecord:
3047: catent.d_type = DT_DIR;
3048: catent.d_fileno = crp->hfsFolder.folderID;
3049: break;
3050: case kHFSFileRecord:
3051: catent.d_type = DT_REG;
3052: catent.d_fileno = crp->hfsFile.fileID;
3053: break;
3054: default:
3055: return (0); /* stop */
3056: };
3057:
3058: cnp = (CatalogName*) ckp->hfs.nodeName;
3059: result = hfs_to_utf8(state->cbs_vcb, cnp->pstr, NAME_MAX + 1,
3060: &utf8chars, catent.d_name);
3061: }
3062:
3063: catent.d_namlen = utf8chars;
3064: catent.d_reclen = DIRENTRY_SIZE(utf8chars);
3065:
3066: /* hide our private meta data directory */
3067: if (curID == kRootDirID &&
3068: catent.d_fileno == state->cbs_hiddenDirID &&
3069: catent.d_type == DT_DIR)
3070: goto lastitem;
3071:
3072: /* if this entry won't fit then we're done */
3073: if (catent.d_reclen > state->cbs_uio->uio_resid)
3074: return (0); /* stop */
3075:
3076: state->cbs_lastoffset = state->cbs_uio->uio_offset;
3077:
3078: state->cbs_result = uiomove((caddr_t) &catent, catent.d_reclen, state->cbs_uio);
3079:
3080: /* continue iteration if there's room */
3081: return (state->cbs_result == 0 &&
3082: state->cbs_uio->uio_resid >= AVERAGE_HFSDIRENTRY_SIZE);
3083: }
3084:
3085: /*
3086: * NOTE: We require a minimal buffer size of DIRBLKSIZ for two reasons. One, it is the same value
3087: * returned be stat() call as the block size. This is mentioned in the man page for getdirentries():
3088: * "Nbytes must be greater than or equal to the block size associated with the file,
3089: * see stat(2)". Might as well settle on the same size of ufs. Second, this makes sure there is enough
3090: * room for the . and .. entries that have to added manually.
3091: */
3092:
3093: /*
3094: #% readdir vp L L L
3095: #
3096: vop_readdir {
3097: IN struct vnode *vp;
3098: INOUT struct uio *uio;
3099: IN struct ucred *cred;
3100: INOUT int *eofflag;
3101: OUT int *ncookies;
3102: INOUT u_long **cookies;
3103: */
3104: static int
3105: hfs_readdir(ap)
3106: struct vop_readdir_args /* {
3107: struct vnode *vp;
3108: struct uio *uio;
3109: struct ucred *cred;
3110: int *eofflag;
3111: int *ncookies;
3112: u_long **cookies;
3113: } */ *ap;
3114: {
3115: register struct uio *uio = ap->a_uio;
3116: struct hfsnode *hp = VTOH(ap->a_vp);
3117: struct proc *p = current_proc();
3118: ExtendedVCB *vcb = HTOVCB(hp);
3119: off_t off = uio->uio_offset;
3120: u_int32_t dirID = H_FILEID(hp);
3121: int retval = 0;
3122: OSErr result = noErr;
3123: u_int32_t diroffset;
3124: BTreeIterator bi;
3125: CatalogIterator *cip;
3126: u_int16_t op;
3127: struct callbackstate state;
3128: int eofflag = 0;
3129:
3130: DBG_FUNC_NAME("readdir");
3131: DBG_VOP_LOCKS_DECL(1);
3132:
3133: DBG_VOP_LOCKS_INIT(0,ap->a_vp, VOPDBG_LOCKED, VOPDBG_LOCKED, VOPDBG_LOCKED, VOPDBG_POS);
3134: DBG_VOP_PRINT_FUNCNAME();
3135: DBG_VOP_PRINT_VNODE_INFO(ap->a_vp);DBG_VOP_CONT(("\n"));
3136: DBG_HFS_NODE_CHECK(ap->a_vp);
3137:
3138: /* We assume it's all one big buffer... */
3139: if (uio->uio_iovcnt > 1 || uio->uio_resid < AVERAGE_HFSDIRENTRY_SIZE) {
3140: return EINVAL;
3141: };
3142:
3143: /* Create the entries for . and .. */
3144: if (uio->uio_offset < sizeof(rootdots)) {
3145: caddr_t dep;
3146: size_t dotsize;
3147:
3148: rootdots[0].d_fileno = dirID;
3149: rootdots[1].d_fileno = H_DIRID(hp);
3150:
3151: if (uio->uio_offset == 0) {
3152: dep = (caddr_t) &rootdots[0];
3153: dotsize = 2* sizeof(struct hfsdotentry);
3154: } else if (uio->uio_offset == sizeof(struct hfsdotentry)) {
3155: dep = (caddr_t) &rootdots[1];
3156: dotsize = sizeof(struct hfsdotentry);
3157: } else {
3158: retval = EINVAL;
3159: goto Exit;
3160: }
3161:
3162: retval = uiomove(dep, dotsize, uio);
3163: if (retval != 0)
3164: goto Exit;
3165: }
3166:
3167: diroffset = uio->uio_offset;
3168:
3169: /* lock catalog b-tree */
3170: retval = hfs_metafilelocking(VTOHFS(ap->a_vp), kHFSCatalogFileID, LK_SHARED, p);
3171: if (retval != E_NONE)
3172: goto Exit;
3173:
3174: /* get an iterator and position it */
3175: cip = GetCatalogIterator(vcb, dirID, diroffset);
3176:
3177: result = PositionIterator(cip, diroffset, &bi, &op);
3178: if (result == cmNotFound) {
3179: eofflag = 1;
3180: retval = 0;
3181: AgeCatalogIterator(cip);
3182: goto cleanup;
3183: } else if ((retval = MacToVFSError(result)))
3184: goto cleanup;
3185:
3186: state.cbs_hiddenDirID = VCBTOHFS(vcb)->hfs_private_metadata_dir;
3187: state.cbs_lastoffset = cip->currentOffset;
3188: state.cbs_vcb = vcb;
3189: state.cbs_uio = uio;
3190: state.cbs_result = 0;
3191: state.cbs_parentID = dirID;
3192:
3193: if (vcb->vcbSigWord == kHFSPlusSigWord)
3194: state.cbs_hfsPlus = 1;
3195: else
3196: state.cbs_hfsPlus = 0;
3197:
3198: /* process as many entries as possible... */
3199: result = BTIterateRecords(GetFileControlBlock(vcb->catalogRefNum), op, &bi,
3200: (IterateCallBackProcPtr)ProcessCatalogEntry, &state);
3201:
3202: if (state.cbs_result)
3203: retval = state.cbs_result;
3204: else
3205: retval = MacToVFSError(result);
3206:
3207: if (retval == ENOENT) {
3208: eofflag = 1;
3209: retval = 0;
3210: }
3211:
3212: if (retval == 0) {
3213: cip->currentOffset = state.cbs_lastoffset;
3214: cip->nextOffset = uio->uio_offset;
3215: UpdateCatalogIterator(&bi, cip);
3216: }
3217:
3218: cleanup:
3219: if (retval) {
3220: cip->volume = 0;
3221: cip->folderID = 0;
3222: AgeCatalogIterator(cip);
3223: }
3224:
3225: (void) ReleaseCatalogIterator(cip);
3226:
3227: /* unlock catalog b-tree */
3228: (void) hfs_metafilelocking(VTOHFS(ap->a_vp), kHFSCatalogFileID, LK_RELEASE, p);
3229:
3230: if (retval != E_NONE) {
3231: DBG_ERR(("%s: retval %d when trying to read directory %ld: %s\n",funcname, retval,
3232: H_FILEID(hp), H_NAME(hp)));
3233: goto Exit;
3234:
3235: }
3236:
3237: /* were we already past eof ? */
3238: if (uio->uio_offset == off) {
3239: uio->uio_offset = 0;
3240: retval = E_NONE;
3241: goto Exit;
3242: }
3243:
3244: if (vcb->vcbSigWord == kHFSPlusSigWord)
3245: hp->h_nodeflags |= IN_ACCESS;
3246:
3247: #if 0
3248: /* Bake any cookies */
3249: if (!retval && ap->a_ncookies != NULL) {
3250: struct dirent* dpStart;
3251: struct dirent* dpEnd;
3252: struct dirent* dp;
3253: int ncookies;
3254: u_long *cookies;
3255: u_long *cookiep;
3256:
3257: /*
3258: * Only the NFS server uses cookies, and it loads the
3259: * directory block into system space, so we can just look at
3260: * it directly.
3261: */
3262: if (uio->uio_segflg != UIO_SYSSPACE)
3263: panic("hfs_readdir: unexpected uio from NFS server");
3264: dpStart = (struct dirent *)
3265: (uio->uio_iov->iov_base - (uio->uio_offset - off));
3266: dpEnd = (struct dirent *) uio->uio_iov->iov_base;
3267: for (dp = dpStart, ncookies = 0;
3268: dp < dpEnd && dp->d_reclen != 0;
3269: dp = (struct dirent *)((caddr_t)dp + dp->d_reclen))
3270: ncookies++;
3271: MALLOC(cookies, u_long *, ncookies * sizeof(u_long), M_TEMP,
3272: M_WAITOK);
3273: for (dp = dpStart, cookiep = cookies;
3274: dp < dpEnd;
3275: dp = (struct dirent *)((caddr_t) dp + dp->d_reclen)) {
3276: off += dp->d_reclen;
3277: *cookiep++ = (u_long) off;
3278: }
3279: *ap->a_ncookies = ncookies;
3280: *ap->a_cookies = cookies;
3281: }
3282: #endif
3283:
3284: Exit:;
3285:
3286: if (ap->a_eofflag)
3287: *ap->a_eofflag = eofflag;
3288:
3289: DBG_VOP_LOCKS_TEST(retval);
3290: return (retval);
3291: }
3292:
3293:
3294: /*
3295: * readdirattr operation will return attributes for the items in the
3296: * directory specified.
3297: *
3298: * It does not do . and .. entries. The problem is if you are at the root of the
3299: * hfs directory and go to .. you could be crossing a mountpoint into a
3300: * different (ufs) file system. The attributes that apply for it may not
3301: * apply for the file system you are doing the readdirattr on. To make life
3302: * simpler, this call will only return entries in its directory, hfs like.
3303: * TO DO LATER:
3304: * 1.getattrlist creates a thread record if the objpermanentid attribute
3305: * is requested. Just do EINVAL for now and fix later.
3306: * 2. more than one for uiovcnt support.
3307: * 3. put knohint (hints) in state for next call in
3308: * 4. credentials checking when rest of hfs does it.
3309: * 5. Do return permissions concatenation ???
3310: */
3311:
3312: /*
3313: #
3314: #% readdirattr vp L L L
3315: #
3316: vop_readdirattr {
3317: IN struct vnode *vp;
3318: IN struct attrlist *alist;
3319: INOUT struct uio *uio;
3320: IN u_long maxcount:
3321: IN u_long options;
3322: OUT u_long *newstate;
3323: OUT int *eofflag;
3324: OUT u_long *actualCount;
3325: OUT u_long **cookies;
3326: IN struct ucred *cred;
3327: };
3328: */
3329: static int
3330: hfs_readdirattr(ap)
3331: struct vop_readdirattr_args /* {
3332: struct vnode *vp;
3333: struct attrlist *alist;
3334: struct uio *uio;
3335: u_long maxcount:
3336: u_long options;
3337: int *newstate;
3338: int *eofflag;
3339: u_long *actualcount;
3340: u_long **cookies;
3341: struct ucred *cred;
3342: } */ *ap;
3343: {
3344: struct vnode *vp = ap->a_vp;
3345: struct attrlist *alist = ap->a_alist;
3346: register struct uio *uio = ap->a_uio;
3347: u_long maxcount = ap->a_maxcount;
3348: u_long ncookies;
3349: ExtendedVCB *vcb = HTOVCB(VTOH(vp));
3350: UInt32 dirID = H_FILEID(VTOH(vp));
3351: struct proc *proc = current_proc(); /* could get this out of uio */
3352: off_t startoffset = uio->uio_offset;
3353: struct hfsCatalogInfo catalogInfo;
3354: UInt32 index;
3355: int retval = 0;
3356: u_long fixedblocksize;
3357: u_long maxattrblocksize;
3358: u_long currattrbufsize;
3359: void *attrbufptr = NULL;
3360: void *attrptr;
3361: void *varptr;
3362:
3363:
3364: *(ap->a_actualcount) = 0;
3365: *(ap->a_eofflag) = 0;
3366:
3367: /* not using options (don't follow symlinks = 0), check vnode, and buffer space */
3368: if ((ap->a_options != 0) || (vp == NULL) ||
3369: (uio->uio_resid <= 0) || (uio->uio_iovcnt > 1))
3370: return EINVAL;
3371:
3372: /* this call doesn't take volume attributes */
3373: if ((alist->bitmapcount != ATTR_BIT_MAP_COUNT) ||
3374: ((alist->commonattr & ~ATTR_CMN_VALIDMASK) != 0) ||
3375: (alist->volattr != 0) ||
3376: ((alist->dirattr & ~ATTR_DIR_VALIDMASK) != 0) ||
3377: ((alist->fileattr & ~ATTR_FILE_VALIDMASK) != 0) ||
3378: ((alist->forkattr & ~ATTR_FORK_VALIDMASK) != 0))
3379: return EINVAL;
3380:
3381: /* Reject requests for unsupported options for now: */
3382: if ((alist->commonattr & (ATTR_CMN_NAMEDATTRCOUNT | ATTR_CMN_NAMEDATTRLIST)) ||
3383: (alist->fileattr & (ATTR_FILE_FILETYPE | ATTR_FILE_FORKCOUNT | ATTR_FILE_FORKLIST)) ||
3384: (alist->commonattr & ATTR_CMN_OBJPERMANENTID) )
3385: return EINVAL;
3386:
3387: /* getattrlist and searchfs use a secondary buffer to malloc and then use
3388: * uiomove afterwards. It's an extra copy, but for now leave it alone
3389: */
3390: fixedblocksize = (sizeof(u_long) + AttributeBlockSize(alist)); /* u_long for length */
3391: maxattrblocksize = fixedblocksize;
3392: if (alist->commonattr & ATTR_CMN_NAME)
3393: maxattrblocksize += NAME_MAX + 1;
3394: MALLOC(attrbufptr, void *, maxattrblocksize, M_TEMP, M_WAITOK);
3395: attrptr = attrbufptr;
3396: varptr = (char *)attrbufptr + fixedblocksize; /* Point to variable-length storage */
3397:
3398: /* Since attributes passed back can contain variable ones (name), we can't just use
3399: * uio_offset as is. We thus force it to represent fixed size of hfsdirentries
3400: * as hfs_readdir was originally doing. If this all we need to represent the current
3401: * state, then ap->a_state is not needed at all.
3402: */
3403: /* index = ap->a_state; should not be less than 1 */
3404: index = (uio->uio_offset / sizeof(struct dirent)) + 1;
3405:
3406: /* Lock catalog b-tree */
3407: if ((retval = hfs_metafilelocking(VTOHFS(vp), kHFSCatalogFileID, LK_SHARED, proc)) != E_NONE)
3408: goto exit;
3409:
3410: /* HFS Catalog does not have a bulk directory enumeration call. Do it one at
3411: * time, using hints. GetCatalogOffspring takes care of hfsplus and name issues
3412: * for us, so that's a win. Later, implement GetCatalogOffspringBulk.
3413: */
3414: catalogInfo.hint = kNoHint; /* note, we may want to save the latest in state */
3415: while ((uio->uio_resid >= 0) && (maxcount !=0 )) {
3416: /* better to check uio_resid against max or fixedblocksize, but won't work.
3417: * Depending on if dir or file, the attributes returned will be different.
3418: * Thus fixedblocksize is too large in some cases.Also, the variable
3419: * part (like name) could be between fixedblocksize and the max.
3420: */
3421: OSErr result = GetCatalogOffspring(vcb, dirID, index, &catalogInfo.spec,
3422: &catalogInfo.nodeData, NULL, NULL);
3423: if (result != noErr) {
3424: if (result == cmNotFound) {
3425: *(ap->a_eofflag) = TRUE;
3426: retval = E_NONE;
3427: }
3428: else retval = MacToVFSError(result);
3429: break;
3430: }
3431:
3432: /* hide our private meta data directory as does hfs_readdir */
3433: if ((dirID == kRootDirID) &&
3434: catalogInfo.nodeData.cnd_nodeID == VCBTOHFS(vcb)->hfs_private_metadata_dir &&
3435: catalogInfo.nodeData.cnd_type == kCatalogFolderNode) {
3436:
3437: ++index;
3438: continue;
3439: }
3440:
3441: *((u_long *)attrptr)++ = 0; /* move it past length */
3442:
3443: /* vp okay to use instead of root vp */
3444: PackCatalogInfoAttributeBlock(alist, vp, &catalogInfo, &attrptr, &varptr);
3445: currattrbufsize = *((u_long *)attrbufptr) = ((char *)varptr - (char *)attrbufptr);
3446:
3447: /* now check if we can't fit in the buffer space remaining */
3448: if (currattrbufsize > uio->uio_resid)
3449: break;
3450: else {
3451: retval = uiomove((caddr_t)attrbufptr, currattrbufsize, ap->a_uio);
3452: if (retval != E_NONE)
3453: break;
3454: attrptr = attrbufptr;
3455: index++;
3456: *ap->a_actualcount += 1;
3457: maxcount--;
3458: }
3459: };
3460: *ap->a_newstate = VTOH(vp)->h_meta->h_mtime;/* before we unlock, know the mod date */
3461: /* Unlock catalog b-tree, finally. Ties up the everything during enumeration */
3462: (void) hfs_metafilelocking( VTOHFS(ap->a_vp), kHFSCatalogFileID, LK_RELEASE, proc );
3463:
3464: if (!retval && ap->a_cookies != NULL) { /* CHECK THAT 0 wasn't passed in */
3465: void* dpStart;
3466: void* dpEnd;
3467: void* dp;
3468: u_long *cookies;
3469: u_long *cookiep;
3470:
3471: /* Only the NFS server uses cookies, and it loads the
3472: * directory block into system space, so we can just look at
3473: * it directly.
3474: */
3475: if (uio->uio_segflg != UIO_SYSSPACE) /* || uio->uio_iovcnt != 1 checked earlier */
3476: panic("hfs_readdirattr: unexpected uio from NFS server");
3477: dpStart = uio->uio_iov->iov_base - (uio->uio_offset - startoffset);
3478: dpEnd = uio->uio_iov->iov_base;
3479: MALLOC(cookies, u_long *, (*ap->a_actualcount)*sizeof(u_long), M_TEMP, M_WAITOK);
3480: for (dp = dpStart, cookiep = cookies;
3481: dp < dpEnd;
3482: dp = ((caddr_t) dp + *((u_long *)dp))) {
3483: *cookiep++ = (u_long)((caddr_t)dp + sizeof(u_long));
3484: }
3485: *ap->a_cookies = cookies;
3486: }
3487:
3488: uio->uio_offset = startoffset + (*ap->a_actualcount)*sizeof(struct dirent);
3489:
3490: exit:
3491: if (attrbufptr != NULL)
3492: FREE(attrbufptr, M_TEMP);
3493: return (retval);
3494: }
3495:
3496:
3497: /*
3498: * Return target name of a symbolic link
3499: #% readlink vp L L L
3500: #
3501: vop_readlink {
3502: IN struct vnode *vp;
3503: INOUT struct uio *uio;
3504: IN struct ucred *cred;
3505: */
3506:
3507: int
3508: hfs_readlink(ap)
3509: struct vop_readlink_args /* {
3510: struct vnode *a_vp;
3511: struct uio *a_uio;
3512: struct ucred *a_cred;
3513: } */ *ap;
3514: {
3515: int retval;
3516: DBG_FUNC_NAME("readlink");
3517: DBG_VOP_LOCKS_DECL(1);
3518: DBG_VOP_PRINT_FUNCNAME();
3519: DBG_VOP_PRINT_VNODE_INFO(ap->a_vp);DBG_VOP_CONT(("\n"));
3520:
3521: DBG_VOP_LOCKS_INIT(0,ap->a_vp, VOPDBG_LOCKED, VOPDBG_LOCKED, VOPDBG_LOCKED, VOPDBG_POS);
3522: retval = VOP_READ(ap->a_vp, ap->a_uio, 0, ap->a_cred);
3523: /* clear IN_ACCESS to prevent needless update of symlink vnode */
3524: VTOH(ap->a_vp)->h_nodeflags &= ~IN_ACCESS;
3525:
3526: DBG_VOP_LOCKS_TEST(retval);
3527: return (retval);
3528:
3529: }
3530:
3531:
3532: /*
3533: * hfs abort op, called after namei() when a CREATE/DELETE isn't actually
3534: * done. If a buffer has been saved in anticipation of a CREATE, delete it.
3535: #% abortop dvp = = =
3536: #
3537: vop_abortop {
3538: IN struct vnode *dvp;
3539: IN struct componentname *cnp;
3540:
3541: */
3542:
3543: /* ARGSUSED */
3544:
3545: static int
3546: hfs_abortop(ap)
3547: struct vop_abortop_args /* {
3548: struct vnode *a_dvp;
3549: struct componentname *a_cnp;
3550: } */ *ap;
3551: {
3552: DBG_FUNC_NAME("abortop");
3553: DBG_VOP_LOCKS_DECL(1);
3554: DBG_VOP_PRINT_FUNCNAME();
3555: DBG_VOP_PRINT_VNODE_INFO(ap->a_dvp);
3556: DBG_VOP_PRINT_CPN_INFO(ap->a_cnp);DBG_VOP_CONT(("\n"));
3557:
3558:
3559: DBG_VOP_LOCKS_INIT(0,ap->a_dvp, VOPDBG_IGNORE, VOPDBG_IGNORE, VOPDBG_IGNORE, VOPDBG_POS);
3560:
3561: if ((ap->a_cnp->cn_flags & (HASBUF | SAVESTART)) == HASBUF) {
3562: FREE_ZONE(ap->a_cnp->cn_pnbuf, ap->a_cnp->cn_pnlen, M_NAMEI);
3563: }
3564: DBG_VOP_LOCKS_TEST(E_NONE);
3565: return (E_NONE);
3566: }
3567:
3568: // int prthfsactive = 0; /* 1 => print out reclaim of active vnodes */
3569:
3570: /*
3571: #% inactive vp L U U
3572: #
3573: vop_inactive {
3574: IN struct vnode *vp;
3575: IN struct proc *p;
3576:
3577: */
3578:
3579: static int
3580: hfs_inactive(ap)
3581: struct vop_inactive_args /* {
3582: struct vnode *a_vp;
3583: } */ *ap;
3584: {
3585: struct vnode *vp = ap->a_vp;
3586: struct hfsnode *hp = VTOH(vp);
3587: struct proc *p = ap->a_p;
3588: struct timeval tv;
3589: int error = 0;
3590: extern int prtactive;
3591:
3592: DBG_FUNC_NAME("inactive");
3593: DBG_VOP_LOCKS_DECL(1);
3594: DBG_VOP_PRINT_FUNCNAME();
3595: DBG_VOP_PRINT_VNODE_INFO(ap->a_vp);DBG_VOP_CONT(("\n"));
3596:
3597: DBG_VOP_LOCKS_INIT(0,ap->a_vp, VOPDBG_LOCKED, VOPDBG_UNLOCKED, VOPDBG_UNLOCKED, VOPDBG_ZERO);
3598:
3599:
3600: if (prtactive && vp->v_usecount <= 0)
3601: vprint("hfs_inactive: pushing active", vp);
3602:
3603: if (vp->v_usecount != 0)
3604: DBG_VOP(("%s: bad usecount = %d\n",funcname,vp->v_usecount ));
3605:
3606: /*
3607: * Ignore nodes related to stale file handles.
3608: */
3609: if ((vp->v_type == VNON) || (hp->h_meta->h_mode == 0))
3610: goto out;
3611:
3612: /*
3613: * Check for a postponed deletion
3614: */
3615: if (hp->h_meta->h_metaflags & IN_DELETED) {
3616: hp->h_meta->h_metaflags &= ~IN_DELETED;
3617:
3618: error = vinvalbuf(vp, 0, NOCRED, p, 0, 0);
3619: if (error) goto out;
3620:
3621: /* Lock both trees
3622: * Note: we do not need a lock on the private metadata directory
3623: * since it never has a vnode associated with it.
3624: */
3625: error = hfs_metafilelocking(VTOHFS(vp), kHFSCatalogFileID, LK_EXCLUSIVE, p);
3626: if (error) goto out;
3627: error = hfs_metafilelocking(VTOHFS(vp), kHFSExtentsFileID, LK_EXCLUSIVE, p);
3628: if (error) {
3629: (void) hfs_metafilelocking(VTOHFS(vp), kHFSCatalogFileID, LK_RELEASE, p);
3630: goto out;
3631: }
3632:
3633: /* XXX can we leave orphaned sibling? */
3634: error = hfsDelete(HTOVCB(hp), H_DIRID(hp), H_NAME(hp), TRUE, H_HINT(hp));
3635: if (error == ENOENT) {
3636: /* try by fileID as a backup */
3637: error = hfsDelete(HTOVCB(hp), H_FILEID(hp), NULL, TRUE, H_HINT(hp));
3638: }
3639: (void) hfs_metafilelocking(VTOHFS(vp), kHFSExtentsFileID, LK_RELEASE, p);
3640: (void) hfs_metafilelocking(VTOHFS(vp), kHFSCatalogFileID, LK_RELEASE, p);
3641: if (error) goto out;
3642:
3643: #if MACH_NBC
3644: if ((vp->v_type == VREG) && (vp->v_vm_info && !(vp->v_vm_info->mapped))) {
3645: #endif /* MACH_NBC */
3646: vnode_pager_setsize(vp, 0);
3647: #if MACH_NBC
3648: }
3649: #endif /* MACH_NBC */
3650:
3651: hp->h_meta->h_mode = 0;
3652: hp->h_nodeflags &= ~(IN_ACCESS | IN_CHANGE | IN_MODIFIED | IN_UPDATE);
3653: }
3654:
3655: if (hp->h_nodeflags & (IN_ACCESS | IN_CHANGE | IN_MODIFIED | IN_UPDATE)) {
3656: tv = time;
3657: VOP_UPDATE(vp, &tv, &tv, 0);
3658: }
3659:
3660: out:
3661: VOP_UNLOCK(vp, 0, p);
3662: /*
3663: * If we are done with the inode, reclaim it
3664: * so that it can be reused immediately.
3665: */
3666: if ((vp->v_type == VNON) || (hp->h_meta->h_mode == 0))
3667: vrecycle(vp, (struct slock *)0, p);
3668:
3669: /* XXX SER Here we might want to get rid of any other forks
3670: * The problem is that if we call vrecycle(), our structure
3671: * disappear from under us, we would need to remember, and expect
3672: * things to go to null or to disappear
3673: * But it stillw would be a good thing to remove vnodes
3674: * referencing stale data
3675: */
3676:
3677: DBG_VOP_LOCKS_TEST(E_NONE);
3678: return (E_NONE);
3679: }
3680:
3681: /*
3682: Ignored since the locks are gone......
3683: #% reclaim vp U I I
3684: #
3685: vop_reclaim {
3686: IN struct vnode *vp;
3687: IN struct proc *p;
3688:
3689: */
3690:
3691: static int
3692: hfs_reclaim(ap)
3693: struct vop_reclaim_args /* {
3694: struct vnode *a_vp;
3695: } */ *ap;
3696: {
3697: struct vnode *vp = ap->a_vp;
3698: struct hfsnode *hp = VTOH(vp);
3699: void *tdata = vp->v_data;
3700: char *tname;
3701: Boolean freeMeta = true;
3702: struct vnode *devvp = NULL;
3703:
3704: extern int prtactive;
3705: DBG_FUNC_NAME("reclaim");
3706: DBG_VOP_LOCKS_DECL(1);
3707: DBG_VOP_PRINT_FUNCNAME();
3708: DBG_VOP_PRINT_VNODE_INFO(ap->a_vp);DBG_VOP_CONT(("\n"));
3709:
3710: DBG_VOP_LOCKS_INIT(0, ap->a_vp, VOPDBG_UNLOCKED, VOPDBG_IGNORE, VOPDBG_IGNORE, VOPDBG_ZERO);
3711:
3712: /*
3713: NOTE: XXX vnodes need careful handling because fork vnodes that failed to be
3714: created in their entirity could be getting cleaned up here, in which
3715: case v_type == VNON and h_meta == NULL... (when????)
3716: */
3717:
3718: if (prtactive && vp->v_usecount != 0)
3719: vprint("hfs_reclaim(): pushing active", vp);
3720:
3721: hp->h_nodeflags |= IN_ALLOCATING; /* Mark this as being incomplete */
3722: /*
3723: * This will remove the entry from the hash AND the sibling list
3724: * This will make sure everything is in a stable state to see if we can remove the meta
3725: * i.e. if this is the only fork...the sibling list will be empty
3726: */
3727: hfs_vhashrem(hp);
3728:
3729: DBG_ASSERT(tdata != NULL);
3730: DBG_ASSERT(hp->h_meta != NULL);
3731:
3732: devvp = hp->h_meta->h_devvp; /* For later releasing */
3733: hp->h_meta->h_usecount--;
3734:
3735: /* release the file meta if this is the last fork */
3736: if (H_FORKTYPE(hp)==kDataFork || H_FORKTYPE(hp)==kRsrcFork) {
3737: if (hp->h_meta->h_siblinghead.cqh_first != (void *) &hp->h_meta->h_siblinghead)
3738: freeMeta = false;
3739: };
3740:
3741: if (freeMeta) {
3742: DBG_ASSERT(hp->h_meta->h_usecount == 0);
3743: if (hp->h_meta->h_metaflags & IN_LONGNAME) {
3744: tname = H_NAME(hp);
3745: DBG_ASSERT(tname != NULL);
3746: FREE(tname, M_TEMP);
3747: }
3748: FREE(hp->h_meta, M_HFSFMETA);
3749: hp->h_meta = NULL;
3750: }
3751: else
3752: DBG_ASSERT(hp->h_meta->h_usecount == 1);
3753:
3754:
3755:
3756: /*
3757: * Purge old data structures associated with the inode.
3758: */
3759: cache_purge(vp);
3760: if ((vp->v_type != VNON) && devvp) {
3761: VRELE(devvp);
3762: };
3763:
3764: /* Free our data structs */
3765: if (vp->v_type != VNON) {
3766: FREE(tdata, M_HFSNODE);
3767: vp->v_data = NULL;
3768: };
3769:
3770: DBG_VOP_LOCKS_TEST(E_NONE);
3771: return (E_NONE);
3772: }
3773:
3774:
3775: /*
3776: * Lock an hfsnode. If its already locked, set the WANT bit and sleep.
3777: #% lock vp U L U
3778: #
3779: vop_lock {
3780: IN struct vnode *vp;
3781: IN int flags;
3782: IN struct proc *p;
3783: */
3784:
3785: static int
3786: hfs_lock(ap)
3787: struct vop_lock_args /* {
3788: struct vnode *a_vp;
3789: int a_flags;
3790: struct proc *a_p;
3791: } */ *ap;
3792: {
3793: struct vnode * vp = ap->a_vp;
3794: struct hfsnode *hp = VTOH(ap->a_vp);
3795: int retval;
3796:
3797: DBG_FUNC_NAME("lock");
3798: DBG_VOP_LOCKS_DECL(1);
3799: DBG_VOP_PRINT_FUNCNAME();DBG_VOP_CONT((" "));
3800: DBG_VOP_PRINT_VNODE_INFO(ap->a_vp);DBG_VOP_CONT((" flags = 0x%08X.\n", ap->a_flags));
3801: DBG_VOP_LOCKS_INIT(0,ap->a_vp, VOPDBG_UNLOCKED, VOPDBG_LOCKED, VOPDBG_UNLOCKED, VOPDBG_ZERO);
3802:
3803: retval = lockmgr(&hp->h_lock, ap->a_flags, &vp->v_interlock, ap->a_p);
3804: if (retval != E_NONE) {
3805: if ((ap->a_flags & LK_NOWAIT) == 0)
3806: DBG_ERR(("hfs_lock: error %d trying to lock vnode (flags = 0x%08X).\n", retval, ap->a_flags));
3807: goto Err_Exit;
3808: };
3809:
3810: Err_Exit:;
3811: DBG_ASSERT(*((int*)&vp->v_interlock) == 0);
3812: DBG_VOP_LOCKS_TEST(retval);
3813: return (retval);
3814: }
3815:
3816: /*
3817: * Unlock an hfsnode.
3818: #% unlock vp L U L
3819: #
3820: vop_unlock {
3821: IN struct vnode *vp;
3822: IN int flags;
3823: IN struct proc *p;
3824:
3825: */
3826: int
3827: hfs_unlock(ap)
3828: struct vop_unlock_args /* {
3829: struct vnode *a_vp;
3830: int a_flags;
3831: struct proc *a_p;
3832: } */ *ap;
3833: {
3834: struct hfsnode *hp = VTOH(ap->a_vp);
3835: struct vnode *vp = ap->a_vp;
3836: int retval = E_NONE;
3837:
3838: DBG_FUNC_NAME("unlock");
3839: DBG_VOP_LOCKS_DECL(1);
3840: DBG_VOP_PRINT_FUNCNAME();
3841: DBG_VOP_PRINT_VNODE_INFO(vp);DBG_VOP_CONT((" flags = 0x%08X.\n", ap->a_flags));
3842: DBG_VOP_LOCKS_INIT(0,vp, VOPDBG_LOCKED, VOPDBG_UNLOCKED, VOPDBG_LOCKED, VOPDBG_ZERO);
3843:
3844:
3845: DBG_ASSERT((ap->a_flags & (LK_EXCLUSIVE|LK_SHARED)) == 0);
3846: retval = lockmgr(&hp->h_lock, ap->a_flags | LK_RELEASE, &vp->v_interlock, ap->a_p);
3847: if (retval != E_NONE) {
3848: DEBUG_BREAK_MSG(("hfs_unlock: error %d trying to unlock vnode (forktype = %d).\n", retval, H_FORKTYPE(hp)));
3849: };
3850:
3851: DBG_ASSERT(*((int*)&vp->v_interlock) == 0);
3852: DBG_VOP_LOCKS_TEST(retval);
3853: return (retval);
3854: }
3855:
3856:
3857: /*
3858: * Print out the contents of an hfsnode.
3859: #% print vp = = =
3860: #
3861: vop_print {
3862: IN struct vnode *vp;
3863: */
3864: int
3865: hfs_print(ap)
3866: struct vop_print_args /* {
3867: struct vnode *a_vp;
3868: } */ *ap;
3869: {
3870: register struct vnode * vp = ap->a_vp;
3871: register struct hfsnode *hp = VTOH( vp);
3872: DBG_FUNC_NAME("print");
3873: DBG_VOP_LOCKS_DECL(1);
3874: DBG_VOP_PRINT_FUNCNAME();
3875: DBG_VOP_PRINT_VNODE_INFO(ap->a_vp);
3876:
3877: DBG_VOP_LOCKS_INIT(0,ap->a_vp, VOPDBG_IGNORE, VOPDBG_IGNORE, VOPDBG_IGNORE, VOPDBG_POS);
3878:
3879: printf("tag VT_HFS, dirID %d, on dev %d, %d", H_DIRID(hp),
3880: major(H_DEV(hp)), minor(H_DEV(hp)));
3881: /* lockmgr_printinfo(&hp->h_lock); */
3882: printf("\n");
3883: DBG_VOP_LOCKS_TEST(E_NONE);
3884: return (E_NONE);
3885: }
3886:
3887:
3888: /*
3889: * Check for a locked hfsnode.
3890: #% islocked vp = = =
3891: #
3892: vop_islocked {
3893: IN struct vnode *vp;
3894:
3895: */
3896: int
3897: hfs_islocked(ap)
3898: struct vop_islocked_args /* {
3899: struct vnode *a_vp;
3900: } */ *ap;
3901: {
3902: int lockStatus;
3903: //DBG_FUNC_NAME("islocked");
3904: //DBG_VOP_LOCKS_DECL(1);
3905: //DBG_VOP_PRINT_FUNCNAME();
3906: //DBG_VOP_PRINT_VNODE_INFO(ap->a_vp);
3907:
3908: //DBG_VOP_LOCKS_INIT(0,ap->a_vp, VOPDBG_IGNORE, VOPDBG_IGNORE, VOPDBG_IGNORE, VOPDBG_ZERO);
3909:
3910: lockStatus = lockstatus(&VTOH( ap->a_vp)->h_lock);
3911: //DBG_VOP_LOCKS_TEST(E_NONE);
3912: return (lockStatus);
3913: }
3914:
3915: /*
3916:
3917: #% pathconf vp L L L
3918: #
3919: vop_pathconf {
3920: IN struct vnode *vp;
3921: IN int name;
3922: OUT register_t *retval;
3923:
3924: */
3925: static int
3926: hfs_pathconf(ap)
3927: struct vop_pathconf_args /* {
3928: struct vnode *a_vp;
3929: int a_name;
3930: int *a_retval;
3931: } */ *ap;
3932: {
3933: int retval = E_NONE;
3934: DBG_FUNC_NAME("pathconf");
3935: DBG_VOP_LOCKS_DECL(1);
3936: DBG_VOP_PRINT_FUNCNAME();
3937: DBG_VOP_PRINT_VNODE_INFO(ap->a_vp);
3938:
3939: DBG_VOP_LOCKS_INIT(0,ap->a_vp, VOPDBG_LOCKED, VOPDBG_LOCKED, VOPDBG_LOCKED, VOPDBG_POS);
3940:
3941: DBG_HFS_NODE_CHECK (ap->a_vp);
3942:
3943: switch (ap->a_name) {
3944: case _PC_LINK_MAX:
3945: #if HFS_HARDLINKS
3946: if (VTOVCB(ap->a_vp)->vcbSigWord == kHFSPlusSigWord)
3947: *ap->a_retval = HFS_LINK_MAX;
3948: else
3949: *ap->a_retval = 1;
3950: #else
3951: *ap->a_retval = 1;
3952: #endif
3953: break;
3954: case _PC_NAME_MAX:
3955: *ap->a_retval = (kHFSPlusMaxFileNameChars * 3); /* max # of characters x max utf8 representation */
3956: break;
3957: case _PC_PATH_MAX:
3958: *ap->a_retval = PATH_MAX; /* 1024 */
3959: break;
3960: case _PC_CHOWN_RESTRICTED:
3961: *ap->a_retval = 1;
3962: break;
3963: case _PC_NO_TRUNC:
3964: *ap->a_retval = 0;
3965: break;
3966: default:
3967: retval = EINVAL;
3968: }
3969:
3970: DBG_VOP_LOCKS_TEST(retval);
3971: return (retval);
3972: }
3973:
3974:
3975:
3976:
3977:
3978: /*
3979: * Advisory record locking support
3980: #% advlock vp U U U
3981: #
3982: vop_advlock {
3983: IN struct vnode *vp;
3984: IN caddr_t id;
3985: IN int op;
3986: IN struct flock *fl;
3987: IN int flags;
3988:
3989: */
3990: int
3991: hfs_advlock(ap)
3992: struct vop_advlock_args /* {
3993: struct vnode *a_vp;
3994: caddr_t a_id;
3995: int a_op;
3996: struct flock *a_fl;
3997: int a_flags;
3998: } */ *ap;
3999: {
4000: register struct hfsnode *hp = VTOH(ap->a_vp);
4001: register struct flock *fl = ap->a_fl;
4002: register struct hfslockf *lock;
4003: off_t start, end;
4004: int retval;
4005: DBG_FUNC_NAME("advlock");
4006: DBG_VOP_LOCKS_DECL(1);
4007: DBG_VOP_PRINT_FUNCNAME();
4008: DBG_VOP_PRINT_VNODE_INFO(ap->a_vp);DBG_VOP(("\n"));
4009: DBG_VOP_LOCKS_INIT(0,ap->a_vp, VOPDBG_UNLOCKED, VOPDBG_UNLOCKED, VOPDBG_UNLOCKED, VOPDBG_POS);
4010: /*
4011: * Avoid the common case of unlocking when inode has no locks.
4012: */
4013: if (hp->h_lockf == (struct hfslockf *)0) {
4014: if (ap->a_op != F_SETLK) {
4015: fl->l_type = F_UNLCK;
4016: return (0);
4017: }
4018: }
4019: /*
4020: * Convert the flock structure into a start and end.
4021: */
4022: start = 0;
4023: switch (fl->l_whence) {
4024: case SEEK_SET:
4025: case SEEK_CUR:
4026: /*
4027: * Caller is responsible for adding any necessary offset
4028: * when SEEK_CUR is used.
4029: */
4030: start = fl->l_start;
4031: break;
4032:
4033: case SEEK_END:
4034: start = HTOFCB(hp)->fcbEOF + fl->l_start;
4035: break;
4036:
4037: default:
4038: return (EINVAL);
4039: }
4040:
4041: if (start < 0)
4042: return (EINVAL);
4043: if (fl->l_len == 0)
4044: end = -1;
4045: else
4046: end = start + fl->l_len - 1;
4047:
4048: /*
4049: * Create the hfslockf structure
4050: */
4051: MALLOC(lock, struct hfslockf *, sizeof *lock, M_LOCKF, M_WAITOK);
4052: lock->lf_start = start;
4053: lock->lf_end = end;
4054: lock->lf_id = ap->a_id;
4055: lock->lf_hfsnode = hp;
4056: lock->lf_type = fl->l_type;
4057: lock->lf_next = (struct hfslockf *)0;
4058: TAILQ_INIT(&lock->lf_blkhd);
4059: lock->lf_flags = ap->a_flags;
4060: /*
4061: * Do the requested operation.
4062: */
4063: switch(ap->a_op) {
4064: case F_SETLK:
4065: retval = hfs_setlock(lock);
4066: break;
4067:
4068: case F_UNLCK:
4069: retval = hfs_clearlock(lock);
4070: FREE(lock, M_LOCKF);
4071: break;
4072:
4073: case F_GETLK:
4074: retval = hfs_getlock(lock, fl);
4075: FREE(lock, M_LOCKF);
4076: break;
4077:
4078: default:
4079: retval = EINVAL;
4080: _FREE(lock, M_LOCKF);
4081: break;
4082: }
4083:
4084: DBG_VOP_LOCKS_TEST(retval);
4085: return (retval);
4086: }
4087:
4088:
4089:
4090: /*
4091: * Update the access, modified, and node change times as specified by the
4092: * IACCESS, IUPDATE, and ICHANGE flags respectively. The IMODIFIED flag is
4093: * used to specify that the node needs to be updated but that the times have
4094: * already been set. The access and modified times are taken from the second
4095: * and third parameters; the node change time is always taken from the current
4096: * time. If waitfor is set, then wait for the disk write of the node to
4097: * complete.
4098: */
4099: /*
4100: #% update vp L L L
4101: IN struct vnode *vp;
4102: IN struct timeval *access;
4103: IN struct timeval *modify;
4104: IN int waitfor;
4105: */
4106:
4107: int
4108: hfs_update(ap)
4109: struct vop_update_args /* {
4110: struct vnode *a_vp;
4111: struct timeval *a_access;
4112: struct timeval *a_modify;
4113: int a_waitfor;
4114: } */ *ap;
4115: {
4116: struct hfsnode *hp;
4117: struct proc *p;
4118: hfsCatalogInfo catInfo;
4119: char *filename;
4120: u_int32_t pid;
4121: int retval;
4122: ExtendedVCB *vcb;
4123: DBG_FUNC_NAME("update");
4124: DBG_VOP_LOCKS_DECL(1);
4125: DBG_VOP_PRINT_FUNCNAME();
4126: DBG_VOP_PRINT_VNODE_INFO(ap->a_vp);DBG_VOP_CONT(("\n"));
4127: DBG_VOP_LOCKS_INIT(0,ap->a_vp, VOPDBG_LOCKED, VOPDBG_LOCKED, VOPDBG_LOCKED, VOPDBG_ZERO);
4128:
4129: hp = VTOH(ap->a_vp);
4130:
4131: DBG_ASSERT(hp && hp->h_meta);
4132: DBG_ASSERT(*((int*)&ap->a_vp->v_interlock) == 0);
4133:
4134: if ((H_FORKTYPE(hp) == kSysFile) ||
4135: (VTOVFS(ap->a_vp)->mnt_flag & MNT_RDONLY) ||
4136: (hp->h_meta->h_mode == 0)) {
4137: hp->h_nodeflags &= ~(IN_ACCESS | IN_CHANGE | IN_MODIFIED | IN_UPDATE);
4138: DBG_VOP_LOCKS_TEST(0);
4139: return (0);
4140: }
4141:
4142: if (H_FORKTYPE(hp) == kSysFile) {
4143: hp->h_nodeflags &= ~(IN_ACCESS | IN_CHANGE | IN_MODIFIED | IN_UPDATE);
4144: DBG_VOP_LOCKS_TEST(0);
4145: return (0);
4146: }
4147:
4148: if (VTOVFS(ap->a_vp)->mnt_flag & MNT_RDONLY) {
4149: hp->h_nodeflags &= ~(IN_ACCESS | IN_CHANGE | IN_MODIFIED | IN_UPDATE);
4150: DBG_VOP_LOCKS_TEST(0);
4151: DBG_VOP(("hfs_update: returning 0 (all flags were cleared because the volume is read-only.\n"));
4152: return (0);
4153: }
4154:
4155: /* Check to see if MacOS set the fcb to be dirty, if so, translate it to IN_MODIFIED */
4156: if (HTOFCB(hp)->fcbFlags &fcbModifiedMask)
4157: hp->h_nodeflags |= IN_MODIFIED;
4158:
4159: if ((hp->h_nodeflags & (IN_ACCESS | IN_CHANGE | IN_MODIFIED | IN_UPDATE)) == 0) {
4160: DBG_VOP_LOCKS_TEST(0);
4161: DBG_VOP(("hfs_update: returning 0 because the metadata is unchanged.\n"));
4162: return (0);
4163: };
4164:
4165: if (hp->h_nodeflags & IN_ACCESS)
4166: hp->h_meta->h_atime = ap->a_access->tv_sec;
4167: if (hp->h_nodeflags & IN_UPDATE)
4168: hp->h_meta->h_mtime = ap->a_modify->tv_sec;
4169: if (hp->h_nodeflags & IN_CHANGE) {
4170: hp->h_meta->h_ctime = time.tv_sec;
4171: /*
4172: * HFS dates that WE set must be adjusted for DST
4173: */
4174: if ((HTOVCB(hp)->vcbSigWord == kHFSSigWord) && gTimeZone.tz_dsttime) {
4175: hp->h_meta->h_ctime += 3600;
4176: hp->h_meta->h_mtime = hp->h_meta->h_ctime;
4177: }
4178: }
4179:
4180: p = current_proc();
4181: /*
4182: * Since VOP_UPDATE can be called from withing another VOP (eg VOP_RENAME),
4183: * the Catalog b-tree may aready be locked by the current thread. So we
4184: * allow recursive locking of the Catalog from within VOP_UPDATE.
4185: */
4186:
4187: /* Lock the Catalog b-tree file */
4188: retval = hfs_metafilelocking(HTOHFS(hp), kHFSCatalogFileID, LK_EXCLUSIVE | LK_CANRECURSE, p);
4189: if (retval) {
4190: DBG_ERR(("Could not lock catalog tree"));
4191: DBG_VOP_LOCKS_TEST(retval);
4192: DBG_ASSERT(*((int*)&ap->a_vp->v_interlock) == 0);
4193: return (retval);
4194: };
4195: DBG_ASSERT(*((int*)&ap->a_vp->v_interlock) == 0);
4196:
4197: filename = H_NAME(hp);
4198: pid = H_DIRID(hp);
4199:
4200: #if HFS_HARDLINKS
4201: /*
4202: * Force an update of the data node instead of the link node
4203: * by passing the fileID instead of parID and name.
4204: */
4205: if (hp->h_meta->h_metaflags & IN_DATANODE) {
4206: filename = NULL;
4207: pid = H_FILEID(hp);
4208: }
4209: #endif
4210: vcb = HTOVCB(hp);
4211: catInfo.hint = H_HINT(hp);
4212: retval = hfsLookup(vcb, pid, filename, -1, &catInfo);
4213:
4214: H_HINT(hp) = catInfo.hint;
4215: if (retval != noErr) {
4216: DBG_ERR(("hfs_update: error %d on GetCatalogNode...\n", retval));
4217: goto exit_relse;
4218: };
4219:
4220: CopyVNodeToCatalogNode (HTOV(hp), &catInfo.nodeData);
4221:
4222: retval = UpdateCatalogNode(vcb, pid, filename, H_HINT(hp), &catInfo.nodeData);
4223:
4224: if (retval != noErr) {
4225: DBG_ERR(("hfs_update: error %d on UpdateCatalogNode...\n", retval));
4226: retval = MacToVFSError(retval);
4227: goto exit_relse;
4228: };
4229:
4230: /* After the updates are finished, clear the flags */
4231: hp->h_nodeflags &= ~(IN_ACCESS | IN_CHANGE | IN_MODIFIED | IN_UPDATE);
4232: HTOFCB(hp)->fcbFlags &= ~fcbModifiedMask;
4233:
4234: /* Update general data */
4235: if (ap->a_vp->v_type == VDIR) {
4236: hp->h_meta->h_valence = catInfo.nodeData.cnd_valence;
4237: hp->h_meta->h_size = sizeof(rootdots) +
4238: (catInfo.nodeData.cnd_valence * AVERAGE_HFSDIRENTRY_SIZE);
4239: if (hp->h_meta->h_size < MAX_HFSDIRENTRY_SIZE)
4240: hp->h_meta->h_size < MAX_HFSDIRENTRY_SIZE;
4241: } else {
4242: hp->h_meta->h_size = vcb->blockSize *
4243: (catInfo.nodeData.cnd_rsrcfork.totalBlocks +
4244: catInfo.nodeData.cnd_datafork.totalBlocks);
4245: }
4246:
4247:
4248: exit_relse:
4249: /* unlock the Catalog b-tree file */
4250: (void) hfs_metafilelocking(HTOHFS(hp), kHFSCatalogFileID, LK_RELEASE, p);
4251:
4252: DBG_VOP(("hfs_update: returning %d.\n", retval));
4253: DBG_VOP_LOCKS_TEST(retval);
4254: DBG_ASSERT(*((int*)&ap->a_vp->v_interlock) == 0);
4255: return (retval);
4256: }
4257:
4258:
4259: /*
4260: * Initialize the vnode associated with a new hfsnode,
4261: * handle aliased vnodes.
4262: */
4263: int
4264: hfs_vinit(mntp, specops, fifoops, vpp)
4265: struct mount *mntp;
4266: int (**specops)();
4267: int (**fifoops)();
4268: struct vnode **vpp;
4269: {
4270: struct hfsnode *hp;
4271: struct vnode *vp, *nvp;
4272:
4273: vp = *vpp;
4274: hp = VTOH(vp);
4275: /* vp->v_type set in CopyCatalogToHFSNode */
4276: switch(vp->v_type) {
4277: case VCHR:
4278: case VBLK:
4279: vp->v_op = specops;
4280: if ((nvp = checkalias(vp, hp->h_meta->h_rdev, mntp))) {
4281: /*
4282: * Discard unneeded vnode, but save its hfsnode.
4283: * Note that the lock is carried over in the hfsnode
4284: * to the replacement vnode.
4285: */
4286: nvp->v_data = vp->v_data;
4287: vp->v_data = NULL;
4288: vp->v_op = spec_vnodeop_p;
4289: VRELE(vp);
4290: vgone(vp);
4291: /*
4292: * Reinitialize aliased hfsnode.
4293: */
4294:
4295: hp->h_vp = nvp;
4296: vp = nvp;
4297: }
4298: break;
4299: case VFIFO:
4300: #if FIFO
4301: vp->v_op = fifoops;
4302: break;
4303: #else
4304: return (EOPNOTSUPP);
4305: #endif
4306: default:
4307: break;
4308: }
4309: if (H_FILEID(hp) == kRootDirID)
4310: vp->v_flag |= VROOT;
4311:
4312: *vpp = vp;
4313: return (0);
4314: }
4315:
4316: /*
4317: * Allocate a new node
4318: *
4319: * Assumes that the catalog b-tree is locked
4320: *
4321: * Upon leaving, namei buffer must be freed.
4322: *
4323: */
4324: static int
4325: hfs_makenode(mode, rawdev, dvp, vpp, cnp)
4326: int mode;
4327: dev_t rawdev;
4328: struct vnode *dvp;
4329: struct vnode **vpp;
4330: struct componentname *cnp;
4331: {
4332: register struct hfsnode *hp, *parhp;
4333: struct timeval tv;
4334: struct vnode *tvp;
4335: struct hfsCatalogInfo catInfo;
4336: ExtendedVCB *vcb;
4337: UInt8 forkType;
4338: int retval;
4339: DBG_FUNC_NAME("makenode");
4340:
4341: parhp = VTOH(dvp);
4342: vcb = HTOVCB(parhp);
4343: *vpp = NULL;
4344: tvp = NULL;
4345: if ((mode & IFMT) == 0)
4346: mode |= IFREG;
4347:
4348: #if HFS_DIAGNOSTIC
4349: if ((cnp->cn_flags & HASBUF) == 0)
4350: panic("hfs_makenode: no name");
4351: #endif
4352:
4353: /* Create the Catalog B*-Tree entry */
4354: retval = hfsCreate(vcb, H_FILEID(parhp), cnp->cn_nameptr, mode);
4355: if (retval != E_NONE) {
4356: DBG_ERR(("%s: hfsCreate FAILED: %s, %s\n", funcname, cnp->cn_nameptr, H_NAME(parhp)));
4357: goto bad1;
4358: }
4359:
4360: /* Look up the catalog entry just created: */
4361: catInfo.hint = kNoHint;
4362: retval = hfsLookup(vcb, H_FILEID(parhp), cnp->cn_nameptr, cnp->cn_namelen, &catInfo);
4363: if (retval != E_NONE) {
4364: DBG_ERR(("%s: hfsLookup FAILED: %s, %s\n", funcname, cnp->cn_nameptr, H_NAME(parhp)));
4365: goto bad1;
4366: }
4367:
4368: /* hfs plus has additional metadata to initialize */
4369: if (vcb->vcbSigWord == kHFSPlusSigWord) {
4370: u_int32_t pflags;
4371: int catmode;
4372:
4373: catmode = mode;
4374: catInfo.nodeData.cnd_ownerID = cnp->cn_cred->cr_uid;
4375: catInfo.nodeData.cnd_groupID = parhp->h_meta->h_gid;
4376: /* XXX should we move this to post hfsGet? */
4377: catInfo.nodeData.cnd_specialDevice = rawdev;
4378:
4379: switch (catmode & IFMT) {
4380: case IFLNK:
4381: catInfo.nodeData.cnd_ownerID = parhp->h_meta->h_uid;
4382: break;
4383:
4384: case IFCHR:
4385: case IFBLK:
4386: /*
4387: * Don't tag as a special file (BLK or CHR) until *after*
4388: * hfsGet is called. This insures that the checkalias call
4389: * is defered until hfs_mknod completes.
4390: */
4391: catmode = (catmode & ~IFMT) | IFREG;
4392: break;
4393: }
4394:
4395: if ((catmode & ISGID) && !groupmember(parhp->h_meta->h_gid, cnp->cn_cred) &&
4396: suser(cnp->cn_cred, NULL))
4397: catmode &= ~ISGID;
4398:
4399: if (cnp->cn_flags & ISWHITEOUT)
4400: pflags = UF_OPAQUE;
4401: else
4402: pflags = 0;
4403:
4404: /*
4405: * The 32-bit pflags field has two bytes of significance which are
4406: * combined with the mode to yield a 32-bit permissions field as follows:
4407: *
4408: * +------------------------------------+
4409: * pflags: |XXXXXXXX| A |XXXXXXXX| B |
4410: * +------------------------------------+
4411: * |
4412: * V
4413: * +------------------------------------+
4414: * permissions: | A | B | mode |
4415: * +------------------------------------+
4416: */
4417: catInfo.nodeData.cnd_permissions =
4418: (((pflags << 8) & 0xFF000000) | /* A */
4419: ((pflags << 16) & 0x00FF0000) | /* B */
4420: (catmode & 0x0000FFFF)); /* mode */
4421: }
4422:
4423: /* Create a vnode for the object just created: */
4424: forkType = (catInfo.nodeData.cnd_type == kCatalogFolderNode) ? kDirectory : kDataFork;
4425: if ((retval = hfs_vcreate(vcb, &catInfo, forkType, &tvp))) {
4426: goto bad1;
4427: }
4428:
4429: /* flush out pflags, mode, gid, uid and rdev */
4430: tv = time;
4431: if (vcb->vcbSigWord == kHFSPlusSigWord) {
4432: hp = VTOH(tvp);
4433: /* reset mode and v_type in case it was BLK/CHR */
4434: hp->h_meta->h_mode = mode;
4435: tvp->v_type = IFTOVT(mode);
4436: hp->h_meta->h_metaflags &= ~IN_UNSETACCESS;
4437: hp->h_nodeflags |= IN_ACCESS | IN_CHANGE | IN_UPDATE;
4438: if ((retval = VOP_UPDATE(tvp, &tv, &tv, 1)))
4439: goto bad2;
4440: }
4441:
4442: VTOH(dvp)->h_nodeflags |= IN_CHANGE | IN_UPDATE;
4443: if ((retval = VOP_UPDATE(dvp, &tv, &tv, 1)))
4444: goto bad2;
4445:
4446: if ((cnp->cn_flags & (HASBUF | SAVESTART)) == HASBUF) {
4447: FREE_ZONE(cnp->cn_pnbuf, cnp->cn_pnlen, M_NAMEI);
4448: };
4449: VPUT(dvp);
4450: #if MACH_NBC
4451: if ((tvp->v_type == VREG) && !(tvp->v_vm_info)){
4452: vm_info_init(tvp);
4453: }
4454: #endif /* MACH_NBC */
4455: *vpp = tvp;
4456: return (0);
4457:
4458: bad2:
4459: /*
4460: * Write retval occurred trying to update the node
4461: * or the directory so must deallocate the node.
4462: */
4463: /* XXX SER In the future maybe set *vpp to 0xdeadbeef for testing */
4464: VPUT(tvp);
4465:
4466: bad1:
4467: if ((cnp->cn_flags & (HASBUF | SAVESTART)) == HASBUF) {
4468: FREE_ZONE(cnp->cn_pnbuf, cnp->cn_pnlen, M_NAMEI);
4469: };
4470: VPUT(dvp);
4471:
4472: return (retval);
4473:
4474: }
4475:
4476:
4477: #if DBG_VOP_TEST_LOCKS
4478:
4479: /* XXX SER Add passing in the flags...might not be a serious error if locked */
4480:
4481: void DbgVopTest( int maxSlots,
4482: int retval,
4483: VopDbgStoreRec *VopDbgStore,
4484: char *funcname)
4485: {
4486: int index;
4487:
4488: for (index = 0; index < maxSlots; index++)
4489: {
4490: if (VopDbgStore[index].id != index) {
4491: DEBUG_BREAK_MSG(("%s: DBG_VOP_LOCK: invalid id field (%d) in target entry (#%d).\n", funcname, VopDbgStore[index].id, index));
4492: };
4493:
4494: if ((VopDbgStore[index].vp != NULL) &&
4495: ((VopDbgStore[index].vp->v_data==NULL) || (VTOH(VopDbgStore[index].vp)->h_valid != HFS_VNODE_MAGIC)))
4496: continue;
4497:
4498: if (VopDbgStore[index].vp != NULL)
4499: debug_check_vnode(VopDbgStore[index].vp, 0);
4500:
4501: switch (VopDbgStore[index].inState)
4502: {
4503: case VOPDBG_IGNORE:
4504: case VOPDBG_SAME:
4505: /* Do Nothing !!! */
4506: break;
4507: case VOPDBG_LOCKED:
4508: case VOPDBG_UNLOCKED:
4509: case VOPDBG_LOCKNOTNIL:
4510: {
4511: if (VopDbgStore[index].vp == NULL && (VopDbgStore[index].inState != VOPDBG_LOCKNOTNIL)) {
4512: DBG_ERR (("%s: InState check: Null vnode ptr in entry #%d\n", funcname, index));
4513: } else if (VopDbgStore[index].vp != NULL) {
4514: switch (VopDbgStore[index].inState)
4515: {
4516: case VOPDBG_LOCKED:
4517: case VOPDBG_LOCKNOTNIL:
4518: if (VopDbgStore[index].inValue == 0)
4519: {
4520: DBG_ERR (("%s: Entry: not LOCKED:", funcname));
4521: DBG_VOP_PRINT_VNODE_INFO(VopDbgStore[index].vp);
4522: DBG_ERR (("\n"));
4523: }
4524: break;
4525: case VOPDBG_UNLOCKED:
4526: if (VopDbgStore[index].inValue != 0)
4527: {
4528: DBG_ERR (("%s: Entry: not UNLOCKED:", funcname));
4529: DBG_VOP_PRINT_VNODE_INFO(VopDbgStore[index].vp);
4530: DBG_ERR (("\n"));
4531: }
4532: break;
4533: }
4534: }
4535: break;
4536: }
4537: default:
4538: DBG_ERR (("%s: DBG_VOP_LOCK on entry: bad lock test value: %d\n", funcname, VopDbgStore[index].errState));
4539: }
4540:
4541:
4542: if (retval != 0)
4543: {
4544: switch (VopDbgStore[index].errState)
4545: {
4546: case VOPDBG_IGNORE:
4547: /* Do Nothing !!! */
4548: break;
4549: case VOPDBG_LOCKED:
4550: case VOPDBG_UNLOCKED:
4551: case VOPDBG_SAME:
4552: {
4553: if (VopDbgStore[index].vp == NULL) {
4554: DBG_ERR (("%s: ErrState check: Null vnode ptr in entry #%d\n", funcname, index));
4555: } else {
4556: VopDbgStore[index].outValue = lockstatus(&VTOH(VopDbgStore[index].vp)->h_lock);
4557: switch (VopDbgStore[index].errState)
4558: {
4559: case VOPDBG_LOCKED:
4560: if (VopDbgStore[index].outValue == 0)
4561: {
4562: DBG_ERR (("%s: Error: not LOCKED:", funcname));
4563: DBG_VOP_PRINT_VNODE_INFO(VopDbgStore[index].vp);
4564: DBG_ERR(("\n"));
4565: }
4566: break;
4567: case VOPDBG_UNLOCKED:
4568: if (VopDbgStore[index].outValue != 0)
4569: {
4570: DBG_ERR (("%s: Error: not UNLOCKED:", funcname));
4571: DBG_VOP_PRINT_VNODE_INFO(VopDbgStore[index].vp);
4572: DBG_ERR(("\n"));
4573: }
4574: break;
4575: case VOPDBG_SAME:
4576: if (VopDbgStore[index].outValue != VopDbgStore[index].inValue)
4577: DBG_ERR (("%s: Error: In/Out locks are DIFFERENT: 0x%x, inis %d and out is %d\n", funcname, (u_int)VopDbgStore[index].vp, VopDbgStore[index].inValue, VopDbgStore[index].outValue));
4578: break;
4579: }
4580: }
4581: break;
4582: }
4583: case VOPDBG_LOCKNOTNIL:
4584: if (VopDbgStore[index].vp != NULL) {
4585: VopDbgStore[index].outValue = lockstatus(&VTOH(VopDbgStore[index].vp)->h_lock);
4586: if (VopDbgStore[index].outValue == 0)
4587: DBG_ERR (("%s: Error: Not LOCKED: 0x%x\n", funcname, (u_int)VopDbgStore[index].vp));
4588: }
4589: break;
4590: default:
4591: DBG_ERR (("%s: Error: bad lock test value: %d\n", funcname, VopDbgStore[index].errState));
4592: }
4593: }
4594: else
4595: {
4596: switch (VopDbgStore[index].outState)
4597: {
4598: case VOPDBG_IGNORE:
4599: /* Do Nothing !!! */
4600: break;
4601: case VOPDBG_LOCKED:
4602: case VOPDBG_UNLOCKED:
4603: case VOPDBG_SAME:
4604: if (VopDbgStore[index].vp == NULL) {
4605: DBG_ERR (("%s: OutState: Null vnode ptr in entry #%d\n", funcname, index));
4606: };
4607: if (VopDbgStore[index].vp != NULL)
4608: {
4609: VopDbgStore[index].outValue = lockstatus(&VTOH(VopDbgStore[index].vp)->h_lock);
4610: switch (VopDbgStore[index].outState)
4611: {
4612: case VOPDBG_LOCKED:
4613: if (VopDbgStore[index].outValue == 0)
4614: {
4615: DBG_ERR (("%s: Out: not LOCKED:", funcname));
4616: DBG_VOP_PRINT_VNODE_INFO(VopDbgStore[index].vp);
4617: DBG_ERR (("\n"));
4618: }
4619: break;
4620: case VOPDBG_UNLOCKED:
4621: if (VopDbgStore[index].outValue != 0)
4622: {
4623: DBG_ERR (("%s: Out: not UNLOCKED:", funcname));
4624: DBG_VOP_PRINT_VNODE_INFO(VopDbgStore[index].vp);
4625: DBG_ERR (("\n"));
4626: }
4627: break;
4628: case VOPDBG_SAME:
4629: if (VopDbgStore[index].outValue != VopDbgStore[index].inValue)
4630: DBG_ERR (("%s: Out: In/Out locks are DIFFERENT: 0x%x, in is %d and out is %d\n", funcname, (u_int)VopDbgStore[index].vp, VopDbgStore[index].inValue, VopDbgStore[index].outValue));
4631: break;
4632: }
4633: }
4634: break;
4635: case VOPDBG_LOCKNOTNIL:
4636: if (VopDbgStore[index].vp != NULL) {
4637: if (&VTOH(VopDbgStore[index].vp)->h_lock == NULL) {
4638: DBG_ERR (("%s: DBG_VOP_LOCK on out: Null lock on vnode 0x%x\n", funcname, (u_int)VopDbgStore[index].vp));
4639: }
4640: else {
4641: VopDbgStore[index].outValue = lockstatus(&VTOH(VopDbgStore[index].vp)->h_lock);
4642: if (VopDbgStore[index].outValue == 0)
4643: {
4644: DBG_ERR (("%s: DBG_VOP_LOCK on out: Should be LOCKED:", funcname));
4645: DBG_VOP_PRINT_VNODE_INFO(VopDbgStore[index].vp); DBG_ERR (("\n"));
4646: }
4647: }
4648: }
4649: break;
4650: default:
4651: DBG_ERR (("%s: DBG_VOP_LOCK on out: bad lock test value: %d\n", funcname, VopDbgStore[index].outState));
4652: }
4653: }
4654:
4655: VopDbgStore[index].id = -1; /* Invalidate the entry to allow panic-free re-use */
4656: }
4657: }
4658:
4659: #endif /* DBG_VOP_TEST_LOCKS */
4660:
4661: /*
4662: * Wrapper for special device reads
4663: */
4664: int
4665: hfsspec_read(ap)
4666: struct vop_read_args /* {
4667: struct vnode *a_vp;
4668: struct uio *a_uio;
4669: int a_ioflag;
4670: struct ucred *a_cred;
4671: } */ *ap;
4672: {
4673:
4674: /*
4675: * Set access flag.
4676: */
4677: VTOH(ap->a_vp)->h_nodeflags |= IN_ACCESS;
4678: return (VOCALL (spec_vnodeop_p, VOFFSET(vop_read), ap));
4679: }
4680:
4681: /*
4682: * Wrapper for special device writes
4683: */
4684: int
4685: hfsspec_write(ap)
4686: struct vop_write_args /* {
4687: struct vnode *a_vp;
4688: struct uio *a_uio;
4689: int a_ioflag;
4690: struct ucred *a_cred;
4691: } */ *ap;
4692: {
4693:
4694: /*
4695: * Set update and change flags.
4696: */
4697: VTOH(ap->a_vp)->h_nodeflags |= IN_CHANGE | IN_UPDATE;
4698: return (VOCALL (spec_vnodeop_p, VOFFSET(vop_write), ap));
4699: }
4700:
4701: /*
4702: * Wrapper for special device close
4703: *
4704: * Update the times on the hfsnode then do device close.
4705: */
4706: int
4707: hfsspec_close(ap)
4708: struct vop_close_args /* {
4709: struct vnode *a_vp;
4710: int a_fflag;
4711: struct ucred *a_cred;
4712: struct proc *a_p;
4713: } */ *ap;
4714: {
4715: struct vnode *vp = ap->a_vp;
4716: struct hfsnode *hp = VTOH(vp);
4717:
4718: simple_lock(&vp->v_interlock);
4719: if (ap->a_vp->v_usecount > 1)
4720: HFSTIMES(hp, &time, &time);
4721: simple_unlock(&vp->v_interlock);
4722: return (VOCALL (spec_vnodeop_p, VOFFSET(vop_close), ap));
4723: }
4724:
4725: #if FIFO
4726: /*
4727: * Wrapper for fifo reads
4728: */
4729: int
4730: hfsfifo_read(ap)
4731: struct vop_read_args /* {
4732: struct vnode *a_vp;
4733: struct uio *a_uio;
4734: int a_ioflag;
4735: struct ucred *a_cred;
4736: } */ *ap;
4737: {
4738: extern int (**fifo_vnodeop_p)();
4739:
4740: /*
4741: * Set access flag.
4742: */
4743: VTOH(ap->a_vp)->h_nodeflags |= IN_ACCESS;
4744: return (VOCALL (fifo_vnodeop_p, VOFFSET(vop_read), ap));
4745: }
4746:
4747: /*
4748: * Wrapper for fifo writes
4749: */
4750: int
4751: hfsfifo_write(ap)
4752: struct vop_write_args /* {
4753: struct vnode *a_vp;
4754: struct uio *a_uio;
4755: int a_ioflag;
4756: struct ucred *a_cred;
4757: } */ *ap;
4758: {
4759: extern int (**fifo_vnodeop_p)();
4760:
4761: /*
4762: * Set update and change flags.
4763: */
4764: VTOH(ap->a_vp)->h_nodeflags |= IN_CHANGE | IN_UPDATE;
4765: return (VOCALL (fifo_vnodeop_p, VOFFSET(vop_write), ap));
4766: }
4767:
4768: /*
4769: * Wrapper for fifo close
4770: *
4771: * Update the times on the hfsnode then do device close.
4772: */
4773: int
4774: hfsfifo_close(ap)
4775: struct vop_close_args /* {
4776: struct vnode *a_vp;
4777: int a_fflag;
4778: struct ucred *a_cred;
4779: struct proc *a_p;
4780: } */ *ap;
4781: {
4782: extern int (**fifo_vnodeop_p)();
4783: struct vnode *vp = ap->a_vp;
4784: struct hfsnode *hp = VTOH(vp);
4785:
4786: simple_lock(&vp->v_interlock);
4787: if (ap->a_vp->v_usecount > 1)
4788: HFSTIMES(hp, &time, &time);
4789: simple_unlock(&vp->v_interlock);
4790: return (VOCALL (fifo_vnodeop_p, VOFFSET(vop_close), ap));
4791: }
4792: #endif /* FIFO */
4793:
4794:
4795: /*****************************************************************************
4796: *
4797: * VOP Tables
4798: *
4799: *****************************************************************************/
4800:
4801: struct vnodeopv_entry_desc hfs_vnodeop_entries[] = {
4802: { &vop_default_desc, vn_default_error },
4803: { &vop_lookup_desc, hfs_cache_lookup }, /* lookup */
4804: { &vop_create_desc, hfs_create }, /* create */
4805: { &vop_mknod_desc, hfs_mknod }, /* mknod */
4806: { &vop_open_desc, hfs_open }, /* open */
4807: { &vop_close_desc, hfs_close }, /* close */
4808: { &vop_access_desc, hfs_access }, /* access */
4809: { &vop_getattr_desc, hfs_getattr }, /* getattr */
4810: { &vop_setattr_desc, hfs_setattr }, /* setattr */
4811: { &vop_read_desc, hfs_read }, /* read */
4812: { &vop_write_desc, hfs_write }, /* write */
4813: { &vop_ioctl_desc, hfs_ioctl }, /* ioctl */
4814: { &vop_select_desc, hfs_select }, /* select */
4815: { &vop_exchange_desc, hfs_exchange }, /* exchange */
4816: { &vop_mmap_desc, hfs_mmap }, /* mmap */
4817: { &vop_fsync_desc, hfs_fsync }, /* fsync */
4818: { &vop_seek_desc, hfs_seek }, /* seek */
4819: { &vop_remove_desc, hfs_remove }, /* remove */
4820: #if HFS_HARDLINKS
4821: { &vop_link_desc, hfs_link }, /* link */
4822: #else
4823: { &vop_link_desc, err_link }, /* link (NOT SUPPORTED) */
4824: #endif
4825: { &vop_rename_desc, hfs_rename }, /* rename */
4826: { &vop_mkdir_desc, hfs_mkdir }, /* mkdir */
4827: { &vop_rmdir_desc, hfs_rmdir }, /* rmdir */
4828: { &vop_mkcomplex_desc,hfs_mkcomplex }, /* mkcomplex */
4829: { &vop_getattrlist_desc,hfs_getattrlist }, /* getattrlist */
4830: { &vop_setattrlist_desc,hfs_setattrlist }, /* setattrlist */
4831: { &vop_symlink_desc, hfs_symlink }, /* symlink */
4832: { &vop_readdir_desc, hfs_readdir }, /* readdir */
4833: { &vop_readdirattr_desc, hfs_readdirattr }, /* readdirattr */
4834: { &vop_readlink_desc, hfs_readlink }, /* readlink */
4835: { &vop_abortop_desc, hfs_abortop }, /* abortop */
4836: { &vop_inactive_desc, hfs_inactive }, /* inactive */
4837: { &vop_reclaim_desc, hfs_reclaim }, /* reclaim */
4838: { &vop_lock_desc, hfs_lock }, /* lock */
4839: { &vop_unlock_desc, hfs_unlock }, /* unlock */
4840: { &vop_bmap_desc, hfs_bmap }, /* bmap */
4841: { &vop_strategy_desc, hfs_strategy }, /* strategy */
4842: { &vop_print_desc, hfs_print }, /* print */
4843: { &vop_islocked_desc, hfs_islocked }, /* islocked */
4844: { &vop_pathconf_desc, hfs_pathconf }, /* pathconf */
4845: { &vop_advlock_desc, hfs_advlock }, /* advlock */
4846: { &vop_reallocblks_desc, hfs_reallocblks }, /* reallocblks */
4847: { &vop_truncate_desc, hfs_truncate }, /* truncate */
4848: { &vop_allocate_desc, hfs_allocate }, /* allocate */
4849: { &vop_update_desc, hfs_update }, /* update */
4850: { &vop_searchfs_desc,hfs_search }, /* search fs */
4851: { &vop_bwrite_desc, vn_bwrite }, /* bwrite */
4852: { &vop_pagein_desc, hfs_pagein }, /* pagein */
4853: { &vop_pageout_desc, hfs_pageout }, /* pageout */
4854: { &vop_copyfile_desc, err_copyfile }, /* copyfile */
4855: { NULL, NULL }
4856: };
4857:
4858: struct vnodeopv_desc hfs_vnodeop_opv_desc =
4859: { &hfs_vnodeop_p, hfs_vnodeop_entries };
4860:
4861: int (**hfs_specop_p)();
4862: struct vnodeopv_entry_desc hfs_specop_entries[] = {
4863: { &vop_default_desc, vn_default_error },
4864: { &vop_lookup_desc, spec_lookup }, /* lookup */
4865: { &vop_create_desc, spec_create }, /* create */
4866: { &vop_mknod_desc, spec_mknod }, /* mknod */
4867: { &vop_open_desc, spec_open }, /* open */
4868: { &vop_close_desc, hfsspec_close }, /* close */
4869: { &vop_access_desc, hfs_access }, /* access */
4870: { &vop_getattr_desc, hfs_getattr }, /* getattr */
4871: { &vop_setattr_desc, hfs_setattr }, /* setattr */
4872: { &vop_read_desc, hfsspec_read }, /* read */
4873: { &vop_write_desc, hfsspec_write }, /* write */
4874: { &vop_lease_desc, spec_lease_check }, /* lease */
4875: { &vop_ioctl_desc, spec_ioctl }, /* ioctl */
4876: { &vop_select_desc, spec_select }, /* select */
4877: { &vop_revoke_desc, spec_revoke }, /* revoke */
4878: { &vop_mmap_desc, spec_mmap }, /* mmap */
4879: { &vop_fsync_desc, hfs_fsync }, /* fsync */
4880: { &vop_seek_desc, spec_seek }, /* seek */
4881: { &vop_remove_desc, spec_remove }, /* remove */
4882: { &vop_link_desc, spec_link }, /* link */
4883: { &vop_rename_desc, spec_rename }, /* rename */
4884: { &vop_mkdir_desc, spec_mkdir }, /* mkdir */
4885: { &vop_rmdir_desc, spec_rmdir }, /* rmdir */
4886: { &vop_symlink_desc, spec_symlink }, /* symlink */
4887: { &vop_readdir_desc, spec_readdir }, /* readdir */
4888: { &vop_readlink_desc, spec_readlink }, /* readlink */
4889: { &vop_abortop_desc, spec_abortop }, /* abortop */
4890: { &vop_inactive_desc, hfs_inactive }, /* inactive */
4891: { &vop_reclaim_desc, hfs_reclaim }, /* reclaim */
4892: { &vop_lock_desc, hfs_lock }, /* lock */
4893: { &vop_unlock_desc, hfs_unlock }, /* unlock */
4894: { &vop_bmap_desc, spec_bmap }, /* bmap */
4895: { &vop_strategy_desc, spec_strategy }, /* strategy */
4896: { &vop_print_desc, hfs_print }, /* print */
4897: { &vop_islocked_desc, hfs_islocked }, /* islocked */
4898: { &vop_pathconf_desc, spec_pathconf }, /* pathconf */
4899: { &vop_advlock_desc, spec_advlock }, /* advlock */
4900: { &vop_blkatoff_desc, spec_blkatoff }, /* blkatoff */
4901: { &vop_valloc_desc, spec_valloc }, /* valloc */
4902: { &vop_reallocblks_desc, spec_reallocblks }, /* reallocblks */
4903: { &vop_vfree_desc, err_vfree }, /* vfree */
4904: { &vop_truncate_desc, spec_truncate }, /* truncate */
4905: { &vop_update_desc, hfs_update }, /* update */
4906: { &vop_bwrite_desc, vn_bwrite },
4907: #ifdef NeXT
4908: { &vop_devblocksize_desc, spec_devblocksize }, /* devblocksize */
4909: #endif /* NeXT */
4910: { &vop_pagein_desc, hfs_pagein }, /* Pagein */
4911: { &vop_pageout_desc, hfs_pageout }, /* Pageout */
4912: { &vop_copyfile_desc, err_copyfile }, /* copyfile */
4913: { (struct vnodeop_desc*)NULL, (int(*)())NULL }
4914: };
4915: struct vnodeopv_desc hfs_specop_opv_desc =
4916: { &hfs_specop_p, hfs_specop_entries };
4917:
4918: #if FIFO
4919: int (**hfs_fifoop_p)();
4920: struct vnodeopv_entry_desc hfs_fifoop_entries[] = {
4921: { &vop_default_desc, vn_default_error },
4922: { &vop_lookup_desc, fifo_lookup }, /* lookup */
4923: { &vop_create_desc, fifo_create }, /* create */
4924: { &vop_mknod_desc, fifo_mknod }, /* mknod */
4925: { &vop_open_desc, fifo_open }, /* open */
4926: { &vop_close_desc, hfsfifo_close }, /* close */
4927: { &vop_access_desc, hfs_access }, /* access */
4928: { &vop_getattr_desc, hfs_getattr }, /* getattr */
4929: { &vop_setattr_desc, hfs_setattr }, /* setattr */
4930: { &vop_read_desc, hfsfifo_read }, /* read */
4931: { &vop_write_desc, hfsfifo_write }, /* write */
4932: { &vop_lease_desc, fifo_lease_check }, /* lease */
4933: { &vop_ioctl_desc, fifo_ioctl }, /* ioctl */
4934: { &vop_select_desc, fifo_select }, /* select */
4935: { &vop_revoke_desc, fifo_revoke }, /* revoke */
4936: { &vop_mmap_desc, fifo_mmap }, /* mmap */
4937: { &vop_fsync_desc, hfs_fsync }, /* fsync */
4938: { &vop_seek_desc, fifo_seek }, /* seek */
4939: { &vop_remove_desc, fifo_remove }, /* remove */
4940: { &vop_link_desc, fifo_link }, /* link */
4941: { &vop_rename_desc, fifo_rename }, /* rename */
4942: { &vop_mkdir_desc, fifo_mkdir }, /* mkdir */
4943: { &vop_rmdir_desc, fifo_rmdir }, /* rmdir */
4944: { &vop_symlink_desc, fifo_symlink }, /* symlink */
4945: { &vop_readdir_desc, fifo_readdir }, /* readdir */
4946: { &vop_readlink_desc, fifo_readlink }, /* readlink */
4947: { &vop_abortop_desc, fifo_abortop }, /* abortop */
4948: { &vop_inactive_desc, hfs_inactive }, /* inactive */
4949: { &vop_reclaim_desc, hfs_reclaim }, /* reclaim */
4950: { &vop_lock_desc, hfs_lock }, /* lock */
4951: { &vop_unlock_desc, hfs_unlock }, /* unlock */
4952: { &vop_bmap_desc, fifo_bmap }, /* bmap */
4953: { &vop_strategy_desc, fifo_strategy }, /* strategy */
4954: { &vop_print_desc, hfs_print }, /* print */
4955: { &vop_islocked_desc, hfs_islocked }, /* islocked */
4956: { &vop_pathconf_desc, fifo_pathconf }, /* pathconf */
4957: { &vop_advlock_desc, fifo_advlock }, /* advlock */
4958: { &vop_blkatoff_desc, fifo_blkatoff }, /* blkatoff */
4959: { &vop_valloc_desc, fifo_valloc }, /* valloc */
4960: { &vop_reallocblks_desc, fifo_reallocblks }, /* reallocblks */
4961: { &vop_vfree_desc, err_vfree }, /* vfree */
4962: { &vop_truncate_desc, fifo_truncate }, /* truncate */
4963: { &vop_update_desc, hfs_update }, /* update */
4964: { &vop_bwrite_desc, vn_bwrite },
4965: { &vop_pagein_desc, hfs_pagein }, /* Pagein */
4966: { &vop_pageout_desc, hfs_pageout }, /* Pageout */
4967: { &vop_copyfile_desc, err_copyfile }, /* copyfile */
4968: { (struct vnodeop_desc*)NULL, (int(*)())NULL }
4969: };
4970: struct vnodeopv_desc hfs_fifoop_opv_desc =
4971: { &hfs_fifoop_p, hfs_fifoop_entries };
4972: #endif /* FIFO */
4973:
4974:
4975:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.