[hcoop/debian/openafs.git] / src / afs / DARWIN / osi_misc.c

/*
 * Copyright 2000, International Business Machines Corporation and others.
 * All Rights Reserved.
 * 
 * This software has been released under the terms of the IBM Public
 * License.  For details, see the LICENSE file in the top-level source
 * directory or online at http://www.openafs.org/dl/license10.html
 */

#include <afsconfig.h>
#include "afs/param.h"


#include "afs/sysincludes.h"
#include "afsincludes.h"
#include <sys/namei.h>

#ifndef PATHBUFLEN
#define PATHBUFLEN 256
#endif

#ifdef AFS_DARWIN80_ENV
static thread_t vfs_context_owner;

/* works like PFlushVolumeData */
void
darwin_notify_perms(struct unixuser *auser, int event)
{
    int i;
    struct afs_q *tq, *uq = NULL;
    struct vcache *tvc, *hnext;
    int isglock = ISAFS_GLOCK();
    struct vnode *vp;
    struct vnode_attr va;
    int isctxtowner = 0;

    if (!afs_darwin_fsevents)
	return;

    VATTR_INIT(&va);
    VATTR_SET(&va, va_mode, 0777);
    if (event & UTokensObtained)
	VATTR_SET(&va, va_uid, auser->uid);
    else
	VATTR_SET(&va, va_uid, -2); /* nobody */

    if (!isglock)
	AFS_GLOCK();
    if (!(vfs_context_owner == current_thread())) {
	get_vfs_context();
	isctxtowner = 1;
    }
loop:
    ObtainReadLock(&afs_xvcache);
    for (i = 0; i < VCSIZE; i++) {
	for (tq = afs_vhashTV[i].prev; tq != &afs_vhashTV[i]; tq = uq) {
	    uq = QPrev(tq);
	    tvc = QTOVH(tq);
	    if (tvc->f.states & CDeadVnode) {
		/* we can afford to be best-effort */
		continue;
	    }
	    /* no per-file acls, so only notify on directories */
	    if (!(vp = AFSTOV(tvc)) || !vnode_isdir(AFSTOV(tvc)))
		continue;
	    /* dynroot object. no callbacks. anonymous ACL. just no. */
	    if (afs_IsDynrootFid(&tvc->f.fid))
		continue;
	    /* no fake fsevents on mount point sources. leaks refs */
	    if (tvc->mvstat == AFS_MVSTAT_MTPT)
		continue;
	    /* if it's being reclaimed, just pass */
	    if (vnode_get(vp))
		continue;
	    if (vnode_ref(vp)) {
		AFS_GUNLOCK();
		vnode_put(vp);
		AFS_GLOCK();
		continue;
	    }
	    ReleaseReadLock(&afs_xvcache);
	    /* Avoid potentially re-entering on this lock */
	    if (0 == NBObtainWriteLock(&tvc->lock, 234)) {
		tvc->f.states |= CEvent;
		AFS_GUNLOCK();
		vnode_setattr(vp, &va, afs_osi_ctxtp);
		tvc->f.states &= ~CEvent;
		vnode_put(vp);
		AFS_GLOCK();
		ReleaseWriteLock(&tvc->lock);
	    } else {
		AFS_GUNLOCK();
		vnode_put(vp);
		AFS_GLOCK();
	    }
	    ObtainReadLock(&afs_xvcache);
	    uq = QPrev(tq);
	    /* our tvc ptr is still good until now */
	    AFS_FAST_RELE(tvc);
	}
    }
    ReleaseReadLock(&afs_xvcache);
    if (isctxtowner)
	put_vfs_context();
    if (!isglock)
	AFS_GUNLOCK();
}

int
osi_lookupname_user(user_addr_t aname, enum uio_seg seg, int followlink,
		    struct vnode **vpp) {
    char tname[PATHBUFLEN];
    size_t len;
    int code;

    if (seg == AFS_UIOUSER) { /* XXX 64bit */
	AFS_COPYINSTR(aname, tname, sizeof(tname), &len, code);
	if (code)
	    return code;
	return osi_lookupname(tname, seg, followlink, vpp);
    } else
	return osi_lookupname(CAST_DOWN(char *, aname), seg, followlink, vpp);

}

int
osi_lookupname(char *aname, enum uio_seg seg, int followlink,
	       struct vnode **vpp) {
    vfs_context_t ctx;
    int code, flags;

    flags = 0;
    if (!followlink)
	flags |= VNODE_LOOKUP_NOFOLLOW;
    ctx=vfs_context_create(NULL);
    code = vnode_lookup(aname, flags, vpp, ctx);
    if (!code) { /* get a usecount */
	vnode_ref(*vpp);
	vnode_put(*vpp);
    }
    vfs_context_rele(ctx);
    return code;
}
#else
int
osi_lookupname(char *aname, enum uio_seg seg, int followlink,
	       struct vnode **vpp)
{
    struct nameidata n;
    int flags, error;
    flags = 0;
    flags = LOCKLEAF;
    if (followlink)
	flags |= FOLLOW;
    else
	flags |= NOFOLLOW;
    NDINIT(&n, LOOKUP, flags, seg, aname, current_proc());
    if (error = namei(&n))
	return error;
    *vpp = n.ni_vp;
   /* should we do this? */
    VOP_UNLOCK(n.ni_vp, 0, current_proc());
    return 0;
}
#endif

/*
 * afs_suser() returns true if the caller is superuser, false otherwise.
 *
 * Note that it must NOT set errno.
 */
int
afs_suser(void *credp)
{
    int error;
    struct proc *p = current_proc();

#ifdef AFS_DARWIN80_ENV
    if ((error = proc_suser(p)) == 0) {
	return (1);
    }
    return (0);
#else
    if ((error = suser(p->p_ucred, &p->p_acflag)) == 0) {
	return (1);
    }
    return (0);
#endif
}

#ifdef AFS_DARWIN80_ENV
struct uio *
afsio_partialcopy(struct uio *auio, size_t size)
{
    struct uio *res;
    int i;
    user_addr_t iovaddr;
    user_size_t iovsize;

    if (proc_is64bit(current_proc())) {
	res = uio_create(uio_iovcnt(auio), uio_offset(auio),
			 uio_isuserspace(auio) ? UIO_USERSPACE64 : UIO_SYSSPACE32,
			 uio_rw(auio));
    } else {
	res = uio_create(uio_iovcnt(auio), uio_offset(auio),
			 uio_isuserspace(auio) ? UIO_USERSPACE32 : UIO_SYSSPACE32,
			 uio_rw(auio));
    }

    for (i = 0;i < uio_iovcnt(auio) && size > 0;i++) {
	if (uio_getiov(auio, i, &iovaddr, &iovsize))
	    break;
	if (iovsize > size)
	    iovsize = size;
	if (uio_addiov(res, iovaddr, iovsize))
	    break;
	size -= iovsize;
    }
    return res;
}

vfs_context_t afs_osi_ctxtp;
int afs_osi_ctxtp_initialized;
static proc_t vfs_context_curproc;
int vfs_context_ref;

void
get_vfs_context(void)
{
    int isglock = ISAFS_GLOCK();

    if (!isglock)
	AFS_GLOCK();
    if (afs_osi_ctxtp_initialized) {
	if (!isglock)
	    AFS_GUNLOCK();
	return;
    }
    osi_Assert(vfs_context_owner != current_thread());
    if (afs_osi_ctxtp && current_proc() == vfs_context_curproc) {
	vfs_context_ref++;
	vfs_context_owner = current_thread();
	if (!isglock)
	    AFS_GUNLOCK();
	return;
    }
    while (afs_osi_ctxtp && vfs_context_ref) {
	afs_osi_Sleep(&afs_osi_ctxtp);
	if (afs_osi_ctxtp_initialized) {
	    if (!isglock)
		AFS_GUNLOCK();
	    return;
	}
    }
    vfs_context_rele(afs_osi_ctxtp);
    vfs_context_ref=1;
    afs_osi_ctxtp = vfs_context_create(NULL);
    vfs_context_owner = current_thread();
    vfs_context_curproc = current_proc();
    if (!isglock)
	AFS_GUNLOCK();
}

void
put_vfs_context(void)
{
    int isglock = ISAFS_GLOCK();

    if (!isglock)
	AFS_GLOCK();
    if (afs_osi_ctxtp_initialized) {
	if (!isglock)
	    AFS_GUNLOCK();
	return;
    }
    if (vfs_context_owner == current_thread())
	vfs_context_owner = (thread_t)0;
    vfs_context_ref--;
    afs_osi_Wakeup(&afs_osi_ctxtp);
    if (!isglock)
        AFS_GUNLOCK();
}

int
afs_cdev_nop_openclose(dev_t dev, int flags, int devtype,struct proc *p)
{
    return 0;
}

int
afs_cdev_ioctl(dev_t dev, u_long cmd, caddr_t data, int fflag, struct proc *p) {
    unsigned int retval=0;
    int code, is64 = proc_is64bit(p);
    struct afssysargs *a = (struct afssysargs *)data;
    struct afssysargs64 *a64 = (struct afssysargs64 *)data;

    if (((unsigned int)cmd != VIOC_SYSCALL) &&
	((unsigned int)cmd != VIOC_SYSCALL64))
	return EINVAL;

    if (((unsigned int)cmd == VIOC_SYSCALL64) && (is64 == 0))
	return EINVAL;

    if (((unsigned int)cmd == VIOC_SYSCALL) && (is64 != 0))
	return EINVAL;
    
    code=afs3_syscall(p, data, &retval);
    if (code)
	return code;

    if ((!is64) && retval && a->syscall != AFSCALL_CALL
	&& a->param1 != AFSOP_CACHEINODE)
    {
	printf("SSCall(%d,%d) is returning non-error value %d\n", a->syscall, a->param1, retval);
    }
    if ((is64) && retval && a64->syscall != AFSCALL_CALL
	&& a64->param1 != AFSOP_CACHEINODE)
    {
	printf("SSCall(%d,%llx) is returning non-error value %d\n", a64->syscall, a64->param1, retval);
    }

    if (!is64)
	a->retval = retval;
    else
	a64->retval = retval;
    return 0; 
}

#endif
Commit	Line	Data
805e021f CE	1	/*
	2	* Copyright 2000, International Business Machines Corporation and others.
	3	* All Rights Reserved.
	4	*
	5	* This software has been released under the terms of the IBM Public
	6	* License. For details, see the LICENSE file in the top-level source
	7	* directory or online at http://www.openafs.org/dl/license10.html
	8	*/
	9
	10	#include <afsconfig.h>
	11	#include "afs/param.h"
	12
	13
	14	#include "afs/sysincludes.h"
	15	#include "afsincludes.h"
	16	#include <sys/namei.h>
	17
	18	#ifndef PATHBUFLEN
	19	#define PATHBUFLEN 256
	20	#endif
	21
	22	#ifdef AFS_DARWIN80_ENV
	23	static thread_t vfs_context_owner;
	24
	25	/* works like PFlushVolumeData */
	26	void
	27	darwin_notify_perms(struct unixuser *auser, int event)
	28	{
	29	int i;
	30	struct afs_q tq, uq = NULL;
	31	struct vcache tvc, hnext;
	32	int isglock = ISAFS_GLOCK();
	33	struct vnode *vp;
	34	struct vnode_attr va;
	35	int isctxtowner = 0;
	36
	37	if (!afs_darwin_fsevents)
	38	return;
	39
	40	VATTR_INIT(&va);
	41	VATTR_SET(&va, va_mode, 0777);
	42	if (event & UTokensObtained)
	43	VATTR_SET(&va, va_uid, auser->uid);
	44	else
	45	VATTR_SET(&va, va_uid, -2); /* nobody */
	46
	47	if (!isglock)
	48	AFS_GLOCK();
	49	if (!(vfs_context_owner == current_thread())) {
	50	get_vfs_context();
	51	isctxtowner = 1;
	52	}
	53	loop:
	54	ObtainReadLock(&afs_xvcache);
	55	for (i = 0; i < VCSIZE; i++) {
	56	for (tq = afs_vhashTV[i].prev; tq != &afs_vhashTV[i]; tq = uq) {
	57	uq = QPrev(tq);
	58	tvc = QTOVH(tq);
	59	if (tvc->f.states & CDeadVnode) {
	60	/* we can afford to be best-effort */
	61	continue;
	62	}
	63	/* no per-file acls, so only notify on directories */
	64	if (!(vp = AFSTOV(tvc)) \|\| !vnode_isdir(AFSTOV(tvc)))
65	continue;
66	/* dynroot object. no callbacks. anonymous ACL. just no. */
67	if (afs_IsDynrootFid(&tvc->f.fid))
68	continue;
69	/* no fake fsevents on mount point sources. leaks refs */
70	if (tvc->mvstat == AFS_MVSTAT_MTPT)
71	continue;
72	/* if it's being reclaimed, just pass */
73	if (vnode_get(vp))
74	continue;
75	if (vnode_ref(vp)) {
76	AFS_GUNLOCK();
77	vnode_put(vp);
78	AFS_GLOCK();
79	continue;
80	}
81	ReleaseReadLock(&afs_xvcache);
82	/* Avoid potentially re-entering on this lock */
83	if (0 == NBObtainWriteLock(&tvc->lock, 234)) {
84	tvc->f.states \|= CEvent;
85	AFS_GUNLOCK();
86	vnode_setattr(vp, &va, afs_osi_ctxtp);
87	tvc->f.states &= ~CEvent;
88	vnode_put(vp);
89	AFS_GLOCK();
90	ReleaseWriteLock(&tvc->lock);
91	} else {
92	AFS_GUNLOCK();
93	vnode_put(vp);
94	AFS_GLOCK();
95	}
96	ObtainReadLock(&afs_xvcache);
97	uq = QPrev(tq);
98	/* our tvc ptr is still good until now */
99	AFS_FAST_RELE(tvc);
100	}
101	}
102	ReleaseReadLock(&afs_xvcache);
103	if (isctxtowner)
104	put_vfs_context();
105	if (!isglock)
106	AFS_GUNLOCK();
107	}
108
109	int
110	osi_lookupname_user(user_addr_t aname, enum uio_seg seg, int followlink,
111	struct vnode **vpp) {
112	char tname[PATHBUFLEN];
113	size_t len;
114	int code;
115
116	if (seg == AFS_UIOUSER) { /* XXX 64bit */
117	AFS_COPYINSTR(aname, tname, sizeof(tname), &len, code);
118	if (code)
119	return code;
120	return osi_lookupname(tname, seg, followlink, vpp);
121	} else
122	return osi_lookupname(CAST_DOWN(char *, aname), seg, followlink, vpp);
123
124	}
125
126	int
127	osi_lookupname(char *aname, enum uio_seg seg, int followlink,
128	struct vnode **vpp) {
129	vfs_context_t ctx;
130	int code, flags;
131
132	flags = 0;
133	if (!followlink)
134	flags \|= VNODE_LOOKUP_NOFOLLOW;
135	ctx=vfs_context_create(NULL);
136	code = vnode_lookup(aname, flags, vpp, ctx);
137	if (!code) { /* get a usecount */
138	vnode_ref(*vpp);
139	vnode_put(*vpp);
140	}
141	vfs_context_rele(ctx);
142	return code;
143	}
144	#else
145	int
146	osi_lookupname(char *aname, enum uio_seg seg, int followlink,
147	struct vnode **vpp)
148	{
149	struct nameidata n;
150	int flags, error;
151	flags = 0;
152	flags = LOCKLEAF;
153	if (followlink)
154	flags \|= FOLLOW;
155	else
156	flags \|= NOFOLLOW;
157	NDINIT(&n, LOOKUP, flags, seg, aname, current_proc());
158	if (error = namei(&n))
159	return error;
160	*vpp = n.ni_vp;
161	/* should we do this? */
162	VOP_UNLOCK(n.ni_vp, 0, current_proc());
163	return 0;
164	}
165	#endif
166
167	/*
168	* afs_suser() returns true if the caller is superuser, false otherwise.
169	*
170	* Note that it must NOT set errno.
171	*/
172	int
173	afs_suser(void *credp)
174	{
175	int error;
176	struct proc *p = current_proc();
177
178	#ifdef AFS_DARWIN80_ENV
179	if ((error = proc_suser(p)) == 0) {
180	return (1);
181	}
182	return (0);
183	#else
184	if ((error = suser(p->p_ucred, &p->p_acflag)) == 0) {
185	return (1);
186	}
187	return (0);
188	#endif
189	}
190
191	#ifdef AFS_DARWIN80_ENV
192	struct uio *
193	afsio_partialcopy(struct uio *auio, size_t size)
194	{
195	struct uio *res;
196	int i;
197	user_addr_t iovaddr;
198	user_size_t iovsize;
199
200	if (proc_is64bit(current_proc())) {
201	res = uio_create(uio_iovcnt(auio), uio_offset(auio),
202	uio_isuserspace(auio) ? UIO_USERSPACE64 : UIO_SYSSPACE32,
203	uio_rw(auio));
204	} else {
205	res = uio_create(uio_iovcnt(auio), uio_offset(auio),
206	uio_isuserspace(auio) ? UIO_USERSPACE32 : UIO_SYSSPACE32,
207	uio_rw(auio));
208	}
209
210	for (i = 0;i < uio_iovcnt(auio) && size > 0;i++) {
211	if (uio_getiov(auio, i, &iovaddr, &iovsize))
212	break;
213	if (iovsize > size)
214	iovsize = size;
215	if (uio_addiov(res, iovaddr, iovsize))
216	break;
217	size -= iovsize;
218	}
219	return res;
220	}
221
222	vfs_context_t afs_osi_ctxtp;
223	int afs_osi_ctxtp_initialized;
224	static proc_t vfs_context_curproc;
225	int vfs_context_ref;
226
227	void
228	get_vfs_context(void)
229	{
230	int isglock = ISAFS_GLOCK();
231
232	if (!isglock)
233	AFS_GLOCK();
234	if (afs_osi_ctxtp_initialized) {
235	if (!isglock)
236	AFS_GUNLOCK();
237	return;
238	}
239	osi_Assert(vfs_context_owner != current_thread());
240	if (afs_osi_ctxtp && current_proc() == vfs_context_curproc) {
241	vfs_context_ref++;
242	vfs_context_owner = current_thread();
243	if (!isglock)
244	AFS_GUNLOCK();
245	return;
246	}
247	while (afs_osi_ctxtp && vfs_context_ref) {
248	afs_osi_Sleep(&afs_osi_ctxtp);
249	if (afs_osi_ctxtp_initialized) {
250	if (!isglock)
251	AFS_GUNLOCK();
252	return;
253	}
254	}
255	vfs_context_rele(afs_osi_ctxtp);
256	vfs_context_ref=1;
257	afs_osi_ctxtp = vfs_context_create(NULL);
258	vfs_context_owner = current_thread();
259	vfs_context_curproc = current_proc();
260	if (!isglock)
261	AFS_GUNLOCK();
262	}
263
264	void
265	put_vfs_context(void)
266	{
267	int isglock = ISAFS_GLOCK();
268
269	if (!isglock)
270	AFS_GLOCK();
271	if (afs_osi_ctxtp_initialized) {
272	if (!isglock)
273	AFS_GUNLOCK();
274	return;
275	}
276	if (vfs_context_owner == current_thread())
277	vfs_context_owner = (thread_t)0;
278	vfs_context_ref--;
279	afs_osi_Wakeup(&afs_osi_ctxtp);
280	if (!isglock)
281	AFS_GUNLOCK();
282	}
283
284	int
285	afs_cdev_nop_openclose(dev_t dev, int flags, int devtype,struct proc *p)
286	{
287	return 0;
288	}
289
290	int
291	afs_cdev_ioctl(dev_t dev, u_long cmd, caddr_t data, int fflag, struct proc *p) {
292	unsigned int retval=0;
293	int code, is64 = proc_is64bit(p);
294	struct afssysargs a = (struct afssysargs )data;
295	struct afssysargs64 a64 = (struct afssysargs64 )data;
296
297	if (((unsigned int)cmd != VIOC_SYSCALL) &&
298	((unsigned int)cmd != VIOC_SYSCALL64))
299	return EINVAL;
300
301	if (((unsigned int)cmd == VIOC_SYSCALL64) && (is64 == 0))
302	return EINVAL;
303
304	if (((unsigned int)cmd == VIOC_SYSCALL) && (is64 != 0))
305	return EINVAL;
306
307	code=afs3_syscall(p, data, &retval);
308	if (code)
309	return code;
310
311	if ((!is64) && retval && a->syscall != AFSCALL_CALL
312	&& a->param1 != AFSOP_CACHEINODE)
313	{
314	printf("SSCall(%d,%d) is returning non-error value %d\n", a->syscall, a->param1, retval);
315	}
316	if ((is64) && retval && a64->syscall != AFSCALL_CALL
317	&& a64->param1 != AFSOP_CACHEINODE)
318	{
319	printf("SSCall(%d,%llx) is returning non-error value %d\n", a64->syscall, a64->param1, retval);
320	}
321
322	if (!is64)
323	a->retval = retval;
324	else
325	a64->retval = retval;
326	return 0;
327	}
328
329	#endif