a385ab86221234174370b5552d2c2288a668f062
[openafs.git] / src / afs / VNOPS / afs_vnop_create.c
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 /*
11  * Implements:
12  * afs_create
13  * afs_LocalHero
14  */
15
16 #include <afsconfig.h>
17 #include "../afs/param.h"
18
19 RCSID("$Header$");
20
21 #include "../afs/sysincludes.h" /* Standard vendor system headers */
22 #include "../afs/afsincludes.h" /* Afs-based standard headers */
23 #include "../afs/afs_stats.h" /* statistics */
24 #include "../afs/afs_cbqueue.h"
25 #include "../afs/nfsclient.h"
26 #include "../afs/afs_osidnlc.h"
27
28 extern afs_rwlock_t afs_xvcache;
29 extern afs_rwlock_t afs_xcbhash;
30
31 /* question: does afs_create need to set CDirty in the adp or the avc?
32  * I think we can get away without it, but I'm not sure.  Note that
33  * afs_setattr is called in here for truncation.
34  */
35 #ifdef  AFS_OSF_ENV
36 afs_create(ndp, attrs)
37     struct nameidata *ndp;
38     struct vattr *attrs; {
39     register struct vcache *adp = VTOAFS(ndp->ni_dvp);
40     char *aname = ndp->ni_dent.d_name;
41     enum vcexcl aexcl = NONEXCL; /* XXX - create called properly */
42     int amode = 0; /* XXX - checked in higher level */
43     struct vcache **avcp = (struct vcache **)&(ndp->ni_vp);
44     struct ucred *acred = ndp->ni_cred;
45 #else   /* AFS_OSF_ENV */
46 #ifdef AFS_SGI64_ENV
47 afs_create(OSI_VC_ARG(adp), aname, attrs, flags, amode, avcp, acred)
48     int flags;
49 #else /* AFS_SGI64_ENV */
50 afs_create(OSI_VC_ARG(adp), aname, attrs, aexcl, amode, avcp, acred)
51     enum vcexcl aexcl;
52 #endif /* AFS_SGI64_ENV */
53     OSI_VC_DECL(adp);
54     char *aname;
55     struct vattr *attrs;
56     int amode;
57     struct vcache **avcp;
58     struct AFS_UCRED *acred; {
59 #endif /* AFS_OSF_ENV */
60     afs_int32 origCBs, origZaps, finalZaps;
61     struct vrequest treq;
62     register afs_int32 code;
63     register struct conn *tc;
64     struct VenusFid newFid;
65     struct AFSStoreStatus InStatus;
66     struct AFSFetchStatus OutFidStatus, OutDirStatus;
67     struct AFSVolSync tsync;
68     struct AFSCallBack CallBack;
69     afs_int32 now;
70     struct dcache *tdc;
71     afs_size_t offset, len;
72     struct server *hostp=0;
73     struct vcache *tvc;
74     struct volume*      volp = 0;
75     XSTATS_DECLS
76     OSI_VC_CONVERT(adp)
77
78
79     AFS_STATCNT(afs_create);
80     if (code = afs_InitReq(&treq, acred)) 
81         goto done2;
82
83     afs_Trace3(afs_iclSetp, CM_TRACE_CREATE, ICL_TYPE_POINTER, adp,
84                ICL_TYPE_STRING, aname, ICL_TYPE_INT32, amode);
85
86 #ifdef AFS_SGI65_ENV
87     /* If avcp is passed not null, it's the old reference to this file.
88      * We can use this to avoid create races. For now, just decrement
89      * the reference count on it.
90      */
91     if (*avcp) {
92         AFS_RELE(AFSTOV(*avcp));
93         *avcp = NULL;
94     }
95 #endif
96
97     if (strlen(aname) > AFSNAMEMAX) {
98         code = ENAMETOOLONG;
99         goto done;
100     }
101
102     if (!afs_ENameOK(aname)) {
103         code = EINVAL;
104         goto done;
105     }
106 #if     defined(AFS_SUN5_ENV)
107     if ((attrs->va_type == VBLK) || (attrs->va_type == VCHR)) {
108 #else
109     if ((attrs->va_type == VBLK) || (attrs->va_type == VCHR) || (attrs->va_type == VSOCK)) {
110 #endif
111         /* We don't support special devices */
112         code = EINVAL;          
113         goto done;
114     }
115 tagain:
116     code = afs_VerifyVCache(adp, &treq);
117     if (code) goto done;
118
119     /** If the volume is read-only, return error without making an RPC to the
120       * fileserver
121       */
122     if ( adp->states & CRO ) {
123         code = EROFS;
124         goto done;
125     }
126
127     tdc = afs_GetDCache(adp, (afs_size_t) 0, &treq, &offset, &len, 1);
128     ObtainWriteLock(&adp->lock,135);
129     if (tdc) ObtainSharedLock(&tdc->lock,630);
130
131     /*
132      * Make sure that the data in the cache is current. We may have
133      * received a callback while we were waiting for the write lock.
134      */
135     if (!(adp->states & CStatd)
136         || (tdc && !hsame(adp->m.DataVersion, tdc->f.versionNo))) {
137         ReleaseWriteLock(&adp->lock);
138         if (tdc) {
139             ReleaseSharedLock(&tdc->lock);
140             afs_PutDCache(tdc);
141         }
142         goto tagain;
143     }
144     if (tdc) {
145         /* see if file already exists.  If it does, we only set 
146          * the size attributes (to handle O_TRUNC) */
147         code = afs_dir_Lookup(&tdc->f.inode, aname, &newFid.Fid); /* use dnlc first xxx */
148         if (code == 0) {
149             ReleaseSharedLock(&tdc->lock);
150             afs_PutDCache(tdc);
151             ReleaseWriteLock(&adp->lock);
152 #ifdef AFS_SGI64_ENV
153             if (flags & VEXCL) {
154 #else
155             if (aexcl != NONEXCL) {
156 #endif
157                 code = EEXIST;      /* file exists in excl mode open */
158                 goto done;
159             }
160             /* found the file, so use it */
161             newFid.Cell = adp->fid.Cell;
162             newFid.Fid.Volume = adp->fid.Fid.Volume;
163             tvc = (struct vcache *)0;
164             if (newFid.Fid.Unique == 0) {
165                 tvc = afs_LookupVCache(&newFid, &treq, (afs_int32 *)0, 
166                                        WRITE_LOCK, adp, aname); 
167             }
168             if (!tvc)  /* lookup failed or wasn't called */
169                tvc = afs_GetVCache(&newFid, &treq, (afs_int32 *)0,
170                                    (struct vcache*)0, WRITE_LOCK);
171
172             if (tvc) {
173                 /* if the thing exists, we need the right access to open it.
174                  * we must check that here, since no other checks are
175                  * made by the open system call */
176                 len = attrs->va_size;   /* only do the truncate */
177                 /*
178                  * We used to check always for READ access before; the
179                  * problem is that we will fail if the existing file
180                  * has mode -w-w-w, which is wrong.
181                  */
182                 if ((amode & VREAD) && 
183                       !afs_AccessOK(tvc, PRSFS_READ, &treq, CHECK_MODE_BITS)) { 
184                    afs_PutVCache(tvc, READ_LOCK);
185                    code = EACCES;
186                    goto done;
187                 }
188
189 #if defined(AFS_SUN5_ENV) || defined(AFS_SGI_ENV)
190                 if ((amode & VWRITE) || (attrs->va_mask & AT_SIZE)) 
191 #else
192                 if ((amode & VWRITE) || len != 0xffffffff) 
193 #endif
194                   {
195                     /* needed for write access check */
196                     tvc->parentVnode = adp->fid.Fid.Vnode;
197                     tvc->parentUnique = adp->fid.Fid.Unique;
198                     /* need write mode for these guys */
199                     if (!afs_AccessOK(tvc, PRSFS_WRITE, &treq, CHECK_MODE_BITS)) {
200                         afs_PutVCache(tvc, READ_LOCK);
201                         code = EACCES;
202                         goto done;
203                     }
204                 }
205 #if defined(AFS_SUN5_ENV) || defined(AFS_SGI_ENV)
206                 if (attrs->va_mask & AT_SIZE) 
207 #else
208                 if (len != 0xffffffff) 
209 #endif
210                   {
211                     if (vType(tvc) != VREG) {
212                         afs_PutVCache(tvc, READ_LOCK);
213                         code = EISDIR;
214                         goto done;
215                     }
216                     /* do a truncate */
217 #if defined(AFS_SUN5_ENV) || defined(AFS_SGI_ENV)
218                     attrs->va_mask = AT_SIZE;
219 #else
220                     VATTR_NULL(attrs);
221 #endif
222                     attrs->va_size = len;
223                     ObtainWriteLock(&tvc->lock,136);
224                     tvc->states |= CCreating;
225                     ReleaseWriteLock(&tvc->lock);
226 #if defined(AFS_SUN5_ENV) || defined(AFS_SGI_ENV)
227 #if defined(AFS_SGI64_ENV)
228                     code = afs_setattr(VNODE_TO_FIRST_BHV((vnode_t*)tvc),
229                                        attrs, 0, acred);
230 #else
231                     code = afs_setattr(tvc, attrs, 0, acred);
232 #endif /* AFS_SGI64_ENV */
233 #else /* SUN5 || SGI */
234                     code = afs_setattr(tvc, attrs, acred);
235 #endif /* SUN5 || SGI */
236                     ObtainWriteLock(&tvc->lock,137);
237                     tvc->states &= ~CCreating;
238                     ReleaseWriteLock(&tvc->lock);
239                     if (code) {
240                         afs_PutVCache(tvc, 0);
241                         goto done;
242                     }
243                 }
244                 *avcp = tvc;
245             }
246             else code = ENOENT;  /* shouldn't get here */
247             /* make sure vrefCount bumped only if code == 0 */
248             goto done;
249         }
250     }
251
252     /* if we create the file, we don't do any access checks, since
253      * that's how O_CREAT is supposed to work */
254     if (adp->states & CForeign) {
255         origCBs = afs_allCBs;   
256         origZaps = afs_allZaps; 
257     } else {
258         origCBs = afs_evenCBs; /* if changes, we don't really have a callback */
259         origZaps = afs_evenZaps;  /* number of even numbered vnodes discarded */
260     }
261     InStatus.Mask = AFS_SETMODTIME | AFS_SETMODE | AFS_SETGROUP;
262     InStatus.ClientModTime = osi_Time();
263     InStatus.Group = (afs_int32)acred->cr_gid;
264     if (AFS_NFSXLATORREQ(acred)) {
265         /*
266          * XXX The following is mainly used to fix a bug in the HP-UX
267          * nfs client where they create files with mode of 0 without
268          * doing any setattr later on to fix it.  * XXX
269          */
270 #if     defined(AFS_AIX_ENV)
271         if (attrs->va_mode != -1) {
272 #else
273 #if     defined(AFS_SUN5_ENV) || defined(AFS_SGI_ENV)
274         if (attrs->va_mask & AT_MODE) {
275 #else
276         if (attrs->va_mode != ((unsigned short)-1)) {
277 #endif
278 #endif
279             if (!attrs->va_mode)
280                 attrs->va_mode = 0x1b6;     /* XXX default mode: rw-rw-rw XXX */
281         }
282     }
283     InStatus.UnixModeBits = attrs->va_mode & 0xffff;   /* only care about protection bits */
284     do {
285         tc = afs_Conn(&adp->fid, &treq, SHARED_LOCK);
286         if (tc) {
287             hostp = tc->srvr->server;       /* remember for callback processing */
288             now = osi_Time();
289             XSTATS_START_TIME(AFS_STATS_FS_RPCIDX_CREATEFILE);
290 #ifdef RX_ENABLE_LOCKS
291             AFS_GUNLOCK();
292 #endif /* RX_ENABLE_LOCKS */
293             code = RXAFS_CreateFile(tc->id, (struct AFSFid *) &adp->fid.Fid,
294                                     aname, &InStatus, (struct AFSFid *)
295                                     &newFid.Fid, &OutFidStatus,
296                                     &OutDirStatus, &CallBack, &tsync);
297 #ifdef RX_ENABLE_LOCKS
298             AFS_GLOCK();
299 #endif /* RX_ENABLE_LOCKS */
300             XSTATS_END_TIME;
301             CallBack.ExpirationTime += now;
302         }
303         else code = -1;
304     } while
305       (afs_Analyze(tc, code, &adp->fid, &treq,
306                    AFS_STATS_FS_RPCIDX_CREATEFILE, SHARED_LOCK, (struct cell *)0));
307
308 #if defined(AFS_OSF_ENV) || defined(AFS_DARWIN_ENV)
309     if (code == EEXIST && aexcl == NONEXCL) {
310         /* This lookup was handled in the common vn_open code in the
311            vnode layer */
312         if (tdc) {
313             ReleaseSharedLock(&tdc->lock);
314             afs_PutDCache(tdc);
315         }
316         ReleaseWriteLock(&adp->lock);
317         goto done;
318     }
319 #else   /* AFS_OSF_ENV */
320 #ifdef AFS_SGI64_ENV
321     if (code == EEXIST && !(flags & VEXCL)) {
322 #else /* AFS_SGI64_ENV */
323     if (code == EEXIST && aexcl == NONEXCL) {
324 #endif /* AFS_SGI64_ENV */
325         /* if we get an EEXIST in nonexcl mode, just do a lookup */
326         if (tdc) {
327             ReleaseSharedLock(&tdc->lock);
328             afs_PutDCache(tdc);
329         }
330         ReleaseWriteLock(&adp->lock);
331 #if defined(AFS_SUN5_ENV) || defined(AFS_SGI_ENV)
332 #if defined(AFS_SGI64_ENV)
333         code = afs_lookup(VNODE_TO_FIRST_BHV((vnode_t*)adp), aname, avcp,
334                           (struct pathname *)0, 0,
335                           (struct vnode *)0, acred);
336 #else
337         code = afs_lookup(adp, aname, avcp, (struct pathname *)0, 0,
338                           (struct vnode *)0, acred);
339 #endif /* AFS_SGI64_ENV */
340 #else /* SUN5 || SGI */
341         code = afs_lookup(adp, aname, avcp, acred);
342 #endif /* SUN5 || SGI */
343         goto done;
344     }
345 #endif /* AFS_OSF_ENV */
346     if (code) {
347         if (code < 0) {
348           ObtainWriteLock(&afs_xcbhash, 488);
349           afs_DequeueCallback(adp);
350           adp->states &= ~CStatd;
351           ReleaseWriteLock(&afs_xcbhash);
352           osi_dnlc_purgedp(adp);
353         }
354         ReleaseWriteLock(&adp->lock);
355         if (tdc) {
356             ReleaseSharedLock(&tdc->lock);
357             afs_PutDCache(tdc);
358         }
359         goto done;
360     }
361     /* otherwise, we should see if we can make the change to the dir locally */
362     if (tdc) UpgradeSToWLock(&tdc->lock, 631);
363     if (afs_LocalHero(adp, tdc, &OutDirStatus, 1)) {
364         /* we can do it locally */
365         code = afs_dir_Create(&tdc->f.inode, aname, &newFid.Fid);
366         if (code) {
367            ZapDCE(tdc);
368            DZap(&tdc->f.inode);
369         }
370     }
371     if (tdc) {
372         ReleaseWriteLock(&tdc->lock);
373         afs_PutDCache(tdc);
374     }
375     newFid.Cell = adp->fid.Cell;
376     newFid.Fid.Volume = adp->fid.Fid.Volume;
377     ReleaseWriteLock(&adp->lock);
378     volp = afs_FindVolume(&newFid, READ_LOCK);
379
380     /* New tricky optimistic callback handling algorithm for file creation works
381         as follows.  We create the file essentially with no locks set at all.  File
382         server may thus handle operations from others cache managers as well as from
383         this very own cache manager that reference the file in question before
384         we managed to create the cache entry.  However, if anyone else changes
385         any of the status information for a file, we'll see afs_evenCBs increase
386         (files always have even fids).  If someone on this workstation manages
387         to do something to the file, they'll end up having to create a cache
388         entry for the new file.  Either we'll find it once we've got the afs_xvcache
389         lock set, or it was also *deleted* the vnode before we got there, in which case
390         we will find evenZaps has changed, too.  Thus, we only assume we have the right
391         status information if no callbacks or vnode removals have occurred to even
392         numbered files from the time the call started until the time that we got the xvcache
393         lock set.  Of course, this also assumes that any call that modifies a file first
394         gets a write lock on the file's vnode, but if that weren't true, the whole cache manager
395         would fail, since no call would be able to update the local vnode status after modifying
396         a file on a file server. */
397     ObtainWriteLock(&afs_xvcache,138);
398     if (adp->states & CForeign) 
399         finalZaps = afs_allZaps;            /* do this before calling newvcache */
400     else
401         finalZaps = afs_evenZaps;           /* do this before calling newvcache */
402     /* don't need to call RemoveVCB, since only path leaving a callback is the
403        one where we pass through afs_NewVCache.  Can't have queued a VCB unless
404        we created and freed an entry between file creation time and here, and the
405        freeing of the vnode will change evenZaps.  Don't need to update the VLRU
406        queue, since the find will only succeed in the event of a create race, and 
407        then the vcache will be at the front of the VLRU queue anyway...  */
408     if (!(tvc = afs_FindVCache(&newFid, 0, WRITE_LOCK, 
409                                0, DO_STATS))) {
410         tvc = afs_NewVCache(&newFid, hostp, 0, WRITE_LOCK);
411         if (tvc) {
412             int finalCBs;
413             ObtainWriteLock(&tvc->lock,139);
414
415             ObtainWriteLock(&afs_xcbhash, 489);
416             finalCBs = afs_evenCBs;
417             /* add the callback in */
418             if (adp->states & CForeign) {
419                 tvc->states |= CForeign;
420                 finalCBs = afs_allCBs;
421             }
422             if (origCBs == finalCBs && origZaps == finalZaps) {
423                 tvc->states |= CStatd;  /* we've fake entire thing, so don't stat */
424                 tvc->states &= ~CBulkFetching;
425                 tvc->cbExpires = CallBack.ExpirationTime;
426                 afs_QueueCallback(tvc, CBHash(CallBack.ExpirationTime), volp);
427             }
428             else {
429               afs_DequeueCallback(tvc);
430               tvc->states &= ~(CStatd | CUnique);       
431               tvc->callback = 0;
432               if (tvc->fid.Fid.Vnode & 1 || (vType(tvc) == VDIR))
433                 osi_dnlc_purgedp(tvc);
434             }
435             ReleaseWriteLock(&afs_xcbhash);
436             afs_ProcessFS(tvc, &OutFidStatus, &treq);
437             ReleaseWriteLock(&tvc->lock);
438             *avcp = tvc;
439             code = 0;
440         }
441         else code = ENOENT;
442     }
443     else {
444       /* otherwise cache entry already exists, someone else must
445        * have created it.  Comments used to say:  "don't need write
446        * lock to *clear* these flags" but we should do it anyway.
447        * Code used to clear stat bit and callback, but I don't see 
448        * the point -- we didn't have a create race, somebody else just
449        * snuck into NewVCache before we got here, probably a racing 
450        * lookup.
451        */
452         *avcp = tvc;
453         code = 0;
454     }
455     ReleaseWriteLock(&afs_xvcache);
456
457 done:
458     if ( volp )
459         afs_PutVolume(volp, READ_LOCK);
460
461     if (code == 0) {
462         afs_AddMarinerName(aname, *avcp);
463         /* return the new status in vattr */
464         afs_CopyOutAttrs(*avcp, attrs);
465     }
466
467 #ifdef  AFS_OSF_ENV
468     if (!code && !strcmp(aname, "core"))
469         tvc->states |= CCore1;
470 #endif
471
472     code = afs_CheckCode(code, &treq, 20);
473
474 done2:
475 #ifdef  AFS_OSF_ENV
476     afs_PutVCache(adp, 0);
477 #endif  /* AFS_OSF_ENV */
478
479     return code;
480 }
481
482
483 /*
484  * Check to see if we can track the change locally: requires that
485  * we have sufficiently recent info in data cache.  If so, we
486  * know the new DataVersion number, and place it correctly in both the
487  * data and stat cache entries.  This routine returns 1 if we should
488  * do the operation locally, and 0 otherwise.
489  *
490  * This routine must be called with the stat cache entry write-locked,
491  * and dcache entry write-locked.
492  */
493 afs_LocalHero(avc, adc, astat, aincr)
494     register struct vcache *avc;
495     register AFSFetchStatus *astat;
496     register struct dcache *adc;
497     register int aincr; {
498     register afs_int32 ok;
499     afs_hyper_t avers;
500
501     AFS_STATCNT(afs_LocalHero);
502     hset64(avers, astat->dataVersionHigh, astat->DataVersion);
503     /* this *is* the version number, no matter what */
504     if (adc) {
505         ok = (hsame(avc->m.DataVersion, adc->f.versionNo) && avc->callback 
506               && (avc->states & CStatd) && avc->cbExpires >= osi_Time());
507     }
508     else {
509         ok = 0;
510     }
511 #if defined(AFS_SGI_ENV)
512         osi_Assert(avc->v.v_type == VDIR);
513 #endif
514     /* The bulk status code used the length as a sequence number.  */
515     /* Don't update the vcache entry unless the stats are current. */
516     if (avc->states & CStatd) {
517         hset(avc->m.DataVersion, avers);
518 #ifdef AFS_64BIT_CLIENT
519         FillInt64(avc->m.Length, astat->Length_hi, astat->Length);
520 #else /* AFS_64BIT_ENV */
521         avc->m.Length = astat->Length;
522 #endif /* AFS_64BIT_ENV */
523         avc->m.Date = astat->ClientModTime;
524     }
525     if (ok) {
526         /* we've been tracking things correctly */
527         adc->dflags |= DFEntryMod;
528         adc->f.versionNo = avers;
529         return 1;
530     }
531     else {
532         if (adc) {
533             ZapDCE(adc);
534             DZap(&adc->f.inode);
535         }
536         if (avc->states & CStatd) {
537             osi_dnlc_purgedp(avc);
538         }
539         return 0;
540     }
541 }