afs: Avoid panics on failed return from afs_CFileOpen
[openafs.git] / src / afs / afs_disconnected.c
1 /*
2  * This software has been released under the terms of the IBM Public
3  * License.  For details, see the LICENSE file in the top-level source
4  * directory or online at http://www.openafs.org/dl/license10.html
5  */
6
7 #include <afsconfig.h>
8 #include "afs/param.h"
9
10
11 #include "afs/sysincludes.h"
12 #include "afsincludes.h"
13 #include "afs/afs_stats.h"      /* statistics */
14 #include "afs/lock.h"
15 #include "afs/afs_cbqueue.h"
16
17 #define dv_match(vc, fstat)                              \
18         ((vc->f.m.DataVersion.low == fstat.DataVersion) && \
19         (vc->f.m.DataVersion.high == fstat.dataVersionHigh))
20
21 /*! Circular queue of dirty vcaches */
22 struct afs_q afs_disconDirty;
23
24 /*! Circular queue of vcaches with shadow directories */
25 struct afs_q afs_disconShadow;
26
27 /*! Locks both of these lists. Must be write locked for anything other than
28  *  list traversal */
29 afs_rwlock_t afs_disconDirtyLock;
30
31 extern afs_int32 *afs_dvhashTbl;        /*Data cache hash table */
32 extern afs_int32 *afs_dchashTbl;        /*Data cache hash table */
33 extern afs_int32 *afs_dvnextTbl;        /*Dcache hash table links */
34 extern afs_int32 *afs_dcnextTbl;        /*Dcache hash table links */
35 extern struct dcache **afs_indexTable;  /*Pointers to dcache entries */
36
37 /*! Vnode number. On file creation, use the current value and increment it.
38  */
39 afs_uint32 afs_DisconVnode = 2;
40
41 /*! Conflict policy. */
42 enum {
43         CLIENT_WINS = 0,
44         SERVER_WINS,
45         LAST_CLOSER_WINS,
46         ASK
47 };
48
49 afs_int32 afs_ConflictPolicy = SERVER_WINS;
50
51 static void afs_DisconDiscardAllShadows(int, afs_ucred_t *);
52 void afs_DbgListDirEntries(struct VenusFid *afid);
53
54
55 /*!
56  * Find the first dcache of a file that has the specified fid.
57  * Similar to afs_FindDCache, only that it takes a fid instead
58  * of a vcache and it can get the first dcache.
59  *
60  * \param afid
61  *
62  * \return The found dcache or NULL.
63  */
64 struct dcache *
65 afs_FindDCacheByFid(struct VenusFid *afid)
66 {
67     afs_int32 i, index;
68     struct dcache *tdc = NULL;
69
70     i = DVHash(afid);
71     ObtainWriteLock(&afs_xdcache, 758);
72     for (index = afs_dvhashTbl[i]; index != NULLIDX;) {
73         if (afs_indexUnique[index] == afid->Fid.Unique) {
74             tdc = afs_GetValidDSlot(index);
75             if (!tdc) {
76                 index = NULLIDX;
77                 break;
78             }
79             ReleaseReadLock(&tdc->tlock);
80             if (!FidCmp(&tdc->f.fid, afid)) {
81                 break;          /* leaving refCount high for caller */
82             }
83             afs_PutDCache(tdc);
84         }
85         index = afs_dvnextTbl[index];
86     }
87     ReleaseWriteLock(&afs_xdcache);
88
89     if (index == NULLIDX)
90         tdc = NULL;
91     return tdc;
92 }
93
94 /*!
95  * Generate a store status from a dirty vcache entry.
96  *
97  * \param avc Dirty vcache entry.
98  * \param astat
99  *
100  * \note The vnode must be share locked. It is called only on resync,
101  * where the vnode is write locked locally and and the server.
102  *
103  * \return Mask of operations.
104  */
105 int
106 afs_GenStoreStatus(struct vcache *avc, struct AFSStoreStatus *astat)
107 {
108     if (!avc || !astat || !avc->f.ddirty_flags)
109         return 0;
110
111     /* Clean up store stat. */
112     memset(astat, 0, sizeof(struct AFSStoreStatus));
113
114     if (avc->f.ddirty_flags & VDisconSetTime) {
115         /* Update timestamp. */
116         astat->ClientModTime = avc->f.m.Date;
117         astat->Mask |= AFS_SETMODTIME;
118     }
119
120     if (avc->f.ddirty_flags & VDisconSetMode) {
121         /* Copy the mode bits. */
122         astat->UnixModeBits = avc->f.m.Mode;
123         astat->Mask |= AFS_SETMODE;
124    }
125
126    /* XXX: more to come... ?*/
127
128    return astat->Mask;
129 }
130
131 /*!
132  * Hook for filtering the local dir fid by searching the "." entry.
133  *
134  * \param hdata The fid to be filled.
135  */
136 static int
137 get_parent_dir_fid_hook(void *hdata, char *aname, afs_int32 vnode,
138                         afs_int32 unique)
139 {
140     struct VenusFid *tfid = (struct VenusFid *) hdata;
141
142     if ((aname[0] == '.') && (aname[1] == '.') && !aname[2]) {
143         tfid->Fid.Vnode = vnode;
144         tfid->Fid.Unique = unique;
145         return 1;
146     }
147
148     return 0;
149 }
150
151 /*!
152  * Get a the dir's fid by looking in the vcache for simple files and
153  * in the ".." entry for directories.
154  *
155  * \param avc The file's vhash entry.
156  * \param afid Put the fid here.
157  *
158  * \return 0 on success, -1 on failure
159  */
160 int
161 afs_GetParentDirFid(struct vcache *avc, struct VenusFid *afid)
162 {
163     struct dcache *tdc;
164
165     afid->Cell = avc->f.fid.Cell;
166     afid->Fid.Volume = avc->f.fid.Fid.Volume;
167
168     switch (vType(avc)) {
169     case VREG:
170     case VLNK:
171         /* Normal files have the dir fid embedded in the vcache. */
172         afid->Fid.Vnode = avc->f.parent.vnode;
173         afid->Fid.Unique = avc->f.parent.unique;
174         break;
175     case VDIR:
176         /* If dir or parent dir created locally*/
177         tdc = afs_FindDCacheByFid(&avc->f.fid);
178         if (tdc) {
179             afid->Fid.Unique = 0;
180             /* Lookup each entry for the fid. It should be the first. */
181             afs_dir_EnumerateDir(tdc, &get_parent_dir_fid_hook, afid);
182             afs_PutDCache(tdc);
183             if (afid->Fid.Unique == 0) {
184                 return -1;
185             }
186         } else {
187             return -1;
188         }
189         break;
190     default:
191         return -1;
192     }
193
194     return 0;
195 }
196
197 struct NameAndFid {
198     struct VenusFid *fid;
199     char *name;
200     int name_len;
201 };
202
203 /*!
204  * Hook that searches a certain fid's name.
205  *
206  * \param hdata NameAndFid structure containin a pointer to a fid
207  * and an allocate name. The name will be filled when hit.
208  */
209 static int
210 get_vnode_name_hook(void *hdata, char *aname, afs_int32 vnode,
211                     afs_int32 unique)
212 {
213     struct NameAndFid *nf = (struct NameAndFid *) hdata;
214
215     if ((nf->fid->Fid.Vnode == vnode) &&
216         (nf->fid->Fid.Unique == unique)) {
217         nf->name_len = strlen(aname);
218         memcpy(nf->name, aname, nf->name_len);
219         nf->name[nf->name_len] = 0;
220
221         return 1;
222     }
223
224     return 0;
225 }
226
227 /*!
228  * Try to get a vnode's name by comparing all parent dir's entries
229  * to the given fid. It can also return the dir's dcache.
230  *
231  * \param avc The file's vcache.
232  * \param afid The parent dir's fid.
233  * \param aname A preallocated string for the name.
234  * \param deleted Has this file been deleted? If yes, use the shadow
235  * dir for looking up the name.
236  */
237 int
238 afs_GetVnodeName(struct vcache *avc, struct VenusFid *afid, char *aname,
239                  int deleted)
240 {
241     int code = 0;
242     struct dcache *tdc;
243     struct vcache *parent_vc;
244     struct NameAndFid tnf;
245     struct VenusFid parent_fid;
246     struct VenusFid shadow_fid;
247
248     /* List dir contents and get it's tdc. */
249     if (deleted) {
250         /* For deleted files, get the shadow dir's tdc: */
251
252         /* Get the parent dir's vcache that contains the shadow fid. */
253         parent_fid.Cell = avc->f.fid.Cell;
254         parent_fid.Fid.Volume = avc->f.fid.Fid.Volume;
255         if (avc->f.ddirty_flags & VDisconRename) {
256             /* For renames the old dir fid is needed. */
257             parent_fid.Fid.Vnode = avc->f.oldParent.vnode;
258             parent_fid.Fid.Unique = avc->f.oldParent.unique;
259         } else {
260             parent_fid.Fid.Vnode = afid->Fid.Vnode;
261             parent_fid.Fid.Unique = afid->Fid.Unique;
262         }
263
264         /* Get the parent dir's vcache that contains the shadow fid. */
265         ObtainSharedLock(&afs_xvcache, 755);
266         parent_vc = afs_FindVCache(&parent_fid, 0, 1);
267         ReleaseSharedLock(&afs_xvcache);
268         if (!parent_vc) {
269             return ENETDOWN;
270         }
271
272         shadow_fid.Cell = parent_vc->f.fid.Cell;
273         shadow_fid.Fid.Volume = parent_vc->f.fid.Fid.Volume;
274         shadow_fid.Fid.Vnode = parent_vc->f.shadow.vnode;
275         shadow_fid.Fid.Unique = parent_vc->f.shadow.unique;
276
277         afs_PutVCache(parent_vc);
278
279         /* Get shadow dir's dcache. */
280         tdc = afs_FindDCacheByFid(&shadow_fid);
281
282     } else {
283
284         /* For normal files, look into the current dir's entry. */
285         tdc = afs_FindDCacheByFid(afid);
286     }                   /* if (deleted) */
287
288     if (tdc) {
289         tnf.fid = &avc->f.fid;
290         tnf.name_len = -1;
291         tnf.name = aname;
292         afs_dir_EnumerateDir(tdc, &get_vnode_name_hook, &tnf);
293         afs_PutDCache(tdc);
294         if (tnf.name_len == -1)
295             code = ENOENT;
296     } else {
297         /* printf("Directory dcache not found!\n"); */
298         code = ENETDOWN;
299     }
300
301     return code;
302 }
303
304 struct DirtyChildrenCount {
305     struct vcache *vc;
306     afs_uint32 count;
307 };
308
309 /*!
310  * Lookup dirty deleted vnodes in this dir.
311  */
312 static int
313 chk_del_children_hook(void *hdata, char *aname, afs_int32 vnode,
314                       afs_int32 unique)
315 {
316     struct VenusFid tfid;
317     struct DirtyChildrenCount *v = (struct DirtyChildrenCount *) hdata;
318     struct vcache *tvc;
319
320     if ((aname[0] == '.') && !aname[1])
321         /* Skip processing this dir again.
322          * It would result in an endless loop.
323          */
324         return 0;
325
326     if ((aname[0] == '.') && (aname[1] == '.') && !aname[2])
327         /* Don't process parent dir. */
328         return 0;
329
330     /* Get this file's vcache. */
331     tfid.Cell = v->vc->f.fid.Cell;
332     tfid.Fid.Volume = v->vc->f.fid.Fid.Volume;
333     tfid.Fid.Vnode = vnode;
334     tfid.Fid.Unique = unique;
335
336     ObtainSharedLock(&afs_xvcache, 757);
337     tvc = afs_FindVCache(&tfid, 0, 1);
338     ReleaseSharedLock(&afs_xvcache);
339
340     /* Count unfinished dirty children. */
341     if (tvc) {
342         ObtainReadLock(&tvc->lock);
343         if (tvc->f.ddirty_flags)
344             v->count++;
345         ReleaseReadLock(&tvc->lock);
346
347         afs_PutVCache(tvc);
348     }
349
350     return 0;
351 }
352
353 /*!
354  * Check if entries have been deleted in a vnode's shadow
355  * dir.
356  *
357  * \return Returns the number of dirty children.
358  *
359  * \note afs_DDirtyVCListLock must be write locked.
360  */
361 int
362 afs_CheckDeletedChildren(struct vcache *avc)
363 {
364     struct dcache *tdc;
365     struct DirtyChildrenCount dcc;
366     struct VenusFid shadow_fid;
367
368     if (!avc->f.shadow.vnode)
369         /* Empty dir. */
370         return 0;
371
372     shadow_fid.Cell = avc->f.fid.Cell;
373     shadow_fid.Fid.Volume = avc->f.fid.Fid.Volume;
374     shadow_fid.Fid.Vnode = avc->f.shadow.vnode;
375     shadow_fid.Fid.Unique = avc->f.shadow.unique;
376
377     dcc.count = 0;
378
379     /* Get shadow dir's dcache. */
380     tdc = afs_FindDCacheByFid(&shadow_fid);
381     if (tdc) {
382         dcc.vc = avc;
383         afs_dir_EnumerateDir(tdc, &chk_del_children_hook, &dcc);
384         afs_PutDCache(tdc);
385     }
386
387     return dcc.count;
388 }
389
390 /*!
391  * Changes a file's parent fid references.
392  */
393 static int
394 fix_children_fids_hook(void *hdata, char *aname, afs_int32 vnode,
395                        afs_int32 unique)
396 {
397     struct VenusFid tfid;
398     struct VenusFid *afid = (struct VenusFid *) hdata;
399     struct vcache *tvc;
400     struct dcache *tdc = NULL;
401
402     if ((aname[0] == '.') && !aname[1])
403         return 0;
404
405     if ((aname[0] == '.') && (aname[1] == '.') && !aname[2])
406         return 0;
407
408     tfid.Cell = afid->Cell;
409     tfid.Fid.Volume = afid->Fid.Volume;
410     tfid.Fid.Vnode = vnode;
411     tfid.Fid.Unique = unique;
412
413     if (!(vnode % 2)) {
414         /* vnode's parity indicates that it's a file. */
415
416         /* Get the vcache. */
417         ObtainSharedLock(&afs_xvcache, 759);
418         tvc = afs_FindVCache(&tfid, 0, 1);
419         ReleaseSharedLock(&afs_xvcache);
420
421         /* Change the fields. */
422         if (tvc) {
423             tvc->f.parent.vnode = afid->Fid.Vnode;
424             tvc->f.parent.unique = afid->Fid.Unique;
425
426             afs_PutVCache(tvc);
427         }
428     } else {
429         /* It's a dir. Fix this dir's .. entry to contain the new fid. */
430         /* Seek the dir's dcache. */
431         tdc = afs_FindDCacheByFid(&tfid);
432         if (tdc) {
433             /* Change the .. entry fid. */
434             afs_dir_ChangeFid(tdc, "..", NULL, &afid->Fid.Vnode);
435             afs_PutDCache(tdc);
436         }
437     }                   /* if (!(vnode % 2))*/
438
439     return 0;
440 }
441
442 /*!
443  * Fixes the parentVnode and parentUnique fields of all
444  * files (not dirs) contained in the directory pointed by
445  * old_fid. This is useful on resync, when a locally created dir
446  * get's a new fid and all the children references must be updated
447  * to reflect the new fid.
448  *
449  * \note The dir's fid hasn't been changed yet, it is still referenced
450  * with the old fid.
451  *
452  * \param old_fid The current dir's fid.
453  * \param new_fid The new dir's fid.
454  */
455 void
456 afs_FixChildrenFids(struct VenusFid *old_fid, struct VenusFid *new_fid)
457 {
458     struct dcache *tdc;
459
460     /* Get shadow dir's dcache. */
461     tdc = afs_FindDCacheByFid(old_fid);
462     /* Change the fids. */
463     if (tdc) {
464         afs_dir_EnumerateDir(tdc, &fix_children_fids_hook, new_fid);
465         afs_PutDCache(tdc);
466     }
467 }
468
469 static int
470 list_dir_hook(void *hdata, char *aname, afs_int32 vnode, afs_int32 unique)
471 {
472     /* printf("list_dir_hook: %s v:%u u:%u\n", aname, vnode, unique); */
473     return 0;
474 }
475
476 void
477 afs_DbgListDirEntries(struct VenusFid *afid)
478 {
479     struct dcache *tdc;
480
481     /* Get shadow dir's dcache. */
482     tdc = afs_FindDCacheByFid(afid);
483     if (tdc) {
484         afs_dir_EnumerateDir(tdc, &list_dir_hook, NULL);
485         afs_PutDCache(tdc);
486     }
487 }
488
489 /*!
490  * Find the parent vcache for a given child
491  *
492  * \param avc   The vcache whose parent is required
493  * \param afid  Fid structure in which parent's fid should be stored
494  * \param aname An AFSNAMEMAX sized buffer to hold the parents name
495  * \param adp   A pointer to a struct vcache* which will be set to the
496  *              parent vcache
497  *
498  * \return An error code. 0 indicates success, EAGAIN that the vnode should
499  *         be deferred to later in the resync process
500  */
501
502 int
503 afs_GetParentVCache(struct vcache *avc, int deleted, struct VenusFid *afid,
504                     char *aname, struct vcache **adp)
505 {
506     int code;
507
508     *adp = NULL;
509
510     if (afs_GetParentDirFid(avc, afid)) {
511         /* printf("afs_GetParentVCache: Couldn't find parent dir's FID.\n"); */
512         return ENETDOWN;
513     }
514
515     code = afs_GetVnodeName(avc, afid, aname, deleted);
516     if (code) {
517         /* printf("afs_GetParentVCache: Couldn't find file name\n"); */
518         goto end;
519     }
520
521     ObtainSharedLock(&afs_xvcache, 766);
522     *adp = afs_FindVCache(afid, 0, 1);
523     ReleaseSharedLock(&afs_xvcache);
524     if (!*adp) {
525         /* printf("afs_GetParentVCache: Couldn't find parent dir's vcache\n"); */
526         code = ENETDOWN;
527         goto end;
528     }
529
530     if ((*adp)->f.ddirty_flags & VDisconCreate) {
531         /* printf("afs_GetParentVCache: deferring until parent exists\n"); */
532         code = EAGAIN;
533         goto end;
534     }
535
536 end:
537     if (code && *adp) {
538         afs_PutVCache(*adp);
539         *adp = NULL;
540     }
541     return code;
542 }
543
544
545 /*!
546  * Handles file renaming on reconnection:
547  * - Get the old name from the old dir's shadow dir.
548  * - Get the new name from the current dir.
549  * - Old dir fid and new dir fid are collected along the way.
550  * */
551 int
552 afs_ProcessOpRename(struct vcache *avc, struct vrequest *areq)
553 {
554     struct VenusFid old_pdir_fid, new_pdir_fid;
555     char *old_name = NULL, *new_name = NULL;
556     struct AFSFetchStatus OutOldDirStatus, OutNewDirStatus;
557     struct AFSVolSync tsync;
558     struct afs_conn *tc;
559     struct rx_connection *rxconn;
560     afs_uint32 code = 0;
561     XSTATS_DECLS;
562
563     /* Get old dir vcache. */
564     old_pdir_fid.Cell = avc->f.fid.Cell;
565     old_pdir_fid.Fid.Volume = avc->f.fid.Fid.Volume;
566     old_pdir_fid.Fid.Vnode = avc->f.oldParent.vnode;
567     old_pdir_fid.Fid.Unique = avc->f.oldParent.unique;
568
569     /* Get old name. */
570     old_name = afs_osi_Alloc(AFSNAMEMAX);
571     if (!old_name) {
572         /* printf("afs_ProcessOpRename: Couldn't alloc space for old name.\n"); */
573         return ENOMEM;
574     }
575     code = afs_GetVnodeName(avc, &old_pdir_fid, old_name, 1);
576     if (code) {
577         /* printf("afs_ProcessOpRename: Couldn't find old name.\n"); */
578         goto done;
579     }
580
581     /* Alloc data first. */
582     new_name = afs_osi_Alloc(AFSNAMEMAX);
583     if (!new_name) {
584         /* printf("afs_ProcessOpRename: Couldn't alloc space for new name.\n"); */
585         code = ENOMEM;
586         goto done;
587     }
588
589     if (avc->f.ddirty_flags & VDisconRenameSameDir) {
590         /* If we're in the same dir, don't do the lookups all over again,
591          * just copy fid and vcache from the old dir.
592          */
593         memcpy(&new_pdir_fid, &old_pdir_fid, sizeof(struct VenusFid));
594     } else {
595         /* Get parent dir's FID.*/
596         if (afs_GetParentDirFid(avc, &new_pdir_fid)) {
597             /* printf("afs_ProcessOpRename: Couldn't find new parent dir FID.\n"); */
598             code = ENETDOWN;
599             goto done;
600         }
601     }
602
603     /* And finally get the new name. */
604     code = afs_GetVnodeName(avc, &new_pdir_fid, new_name, 0);
605     if (code) {
606         /* printf("afs_ProcessOpRename: Couldn't find new name.\n"); */
607         goto done;
608     }
609
610     /* Send to data to server. */
611     do {
612         tc = afs_Conn(&old_pdir_fid, areq, SHARED_LOCK, &rxconn);
613         if (tc) {
614             XSTATS_START_TIME(AFS_STATS_FS_RPCIDX_RENAME);
615             RX_AFS_GUNLOCK();
616             code = RXAFS_Rename(rxconn,
617                 (struct AFSFid *)&old_pdir_fid.Fid,
618                 old_name,
619                 (struct AFSFid *)&new_pdir_fid.Fid,
620                 new_name,
621                 &OutOldDirStatus,
622                 &OutNewDirStatus,
623                 &tsync);
624             RX_AFS_GLOCK();
625             XSTATS_END_TIME;
626         } else
627             code = -1;
628
629     } while (afs_Analyze(tc,
630                 rxconn,
631                 code,
632                 &new_pdir_fid,
633                 areq,
634                 AFS_STATS_FS_RPCIDX_RENAME,
635                 SHARED_LOCK,
636                 NULL));
637
638     /* if (code) printf("afs_ProcessOpRename: server code=%u\n", code); */
639 done:
640     if (new_name)
641         afs_osi_Free(new_name, AFSNAMEMAX);
642     if (old_name)
643         afs_osi_Free(old_name, AFSNAMEMAX);
644     return code;
645 }
646
647 /*!
648  * Handles all the reconnection details:
649  * - Get all the details about the vnode: name, fid, and parent dir fid.
650  * - Send data to server.
651  * - Handle errors.
652  * - Reorder vhash and dcaches in their hashes, using the newly acquired fid.
653  */
654 int
655 afs_ProcessOpCreate(struct vcache *avc, struct vrequest *areq,
656                     afs_ucred_t *acred)
657 {
658     char *tname = NULL, *ttargetName = NULL;
659     struct AFSStoreStatus InStatus;
660     struct AFSFetchStatus OutFidStatus, OutDirStatus;
661     struct VenusFid pdir_fid, newFid;
662     struct AFSCallBack CallBack;
663     struct AFSVolSync tsync;
664     struct vcache *tdp = NULL, *tvc = NULL;
665     struct dcache *tdc = NULL;
666     struct afs_conn *tc;
667     struct rx_connection *rxconn;
668     afs_int32 hash, new_hash, index;
669     afs_size_t tlen;
670     int code, op = 0;
671     XSTATS_DECLS;
672
673     tname = afs_osi_Alloc(AFSNAMEMAX);
674     if (!tname)
675         return ENOMEM;
676     memset(&InStatus, 0, sizeof(InStatus));
677
678     code = afs_GetParentVCache(avc, 0, &pdir_fid, tname, &tdp);
679     if (code)
680         goto end;
681
682     /* This data may also be in linkData, but then we have to deal with
683      * the joy of terminating NULLs and . and file modes. So just get
684      * it from the dcache where it won't have been fiddled with.
685      */
686     if (vType(avc) == VLNK) {
687         afs_size_t offset;
688         struct dcache *tdc;
689         struct osi_file *tfile;
690
691         tdc = afs_GetDCache(avc, 0, areq, &offset, &tlen, 0);
692         if (!tdc) {
693             code = ENETDOWN;
694             goto end;
695         }
696
697         if (tlen > 1024) {
698             afs_PutDCache(tdc);
699             code = EFAULT;
700             goto end;
701         }
702
703         tlen++; /* space for NULL */
704         ttargetName = afs_osi_Alloc(tlen);
705         if (!ttargetName) {
706             afs_PutDCache(tdc);
707             code = ENOMEM;
708             goto end;
709         }
710         ObtainReadLock(&tdc->lock);
711         tfile = afs_CFileOpen(&tdc->f.inode);
712         if (!tfile) {
713             ReleaseReadLock(&tdc->lock);
714             afs_PutDCache(tdc);
715             code = EIO;
716             goto end;
717         }
718         code = afs_CFileRead(tfile, 0, ttargetName, tlen);
719         ttargetName[tlen-1] = '\0';
720         afs_CFileClose(tfile);
721         ReleaseReadLock(&tdc->lock);
722         afs_PutDCache(tdc);
723     }
724
725     /* Set status. */
726     InStatus.Mask = AFS_SETMODTIME | AFS_SETMODE | AFS_SETGROUP;
727     InStatus.ClientModTime = avc->f.m.Date;
728     InStatus.Owner = avc->f.m.Owner;
729     InStatus.Group = (afs_int32) afs_cr_gid(acred);
730     /* Only care about protection bits. */
731     InStatus.UnixModeBits = avc->f.m.Mode & 0xffff;
732
733     do {
734         tc = afs_Conn(&tdp->f.fid, areq, SHARED_LOCK, &rxconn);
735         if (tc) {
736             switch (vType(avc)) {
737             case VREG:
738                 /* Make file on server. */
739                 op = AFS_STATS_FS_RPCIDX_CREATEFILE;
740                 XSTATS_START_TIME(op);
741                 RX_AFS_GUNLOCK();
742                 code = RXAFS_CreateFile(rxconn,
743                                         (struct AFSFid *)&tdp->f.fid.Fid,
744                                         tname, &InStatus,
745                                         (struct AFSFid *) &newFid.Fid,
746                                         &OutFidStatus, &OutDirStatus,
747                                         &CallBack, &tsync);
748                 RX_AFS_GLOCK();
749                 XSTATS_END_TIME;
750                 break;
751             case VDIR:
752                 /* Make dir on server. */
753                 op = AFS_STATS_FS_RPCIDX_MAKEDIR;
754                 XSTATS_START_TIME(op);
755                 RX_AFS_GUNLOCK();
756                 code = RXAFS_MakeDir(rxconn, (struct AFSFid *) &tdp->f.fid.Fid,
757                                      tname, &InStatus,
758                                      (struct AFSFid *) &newFid.Fid,
759                                      &OutFidStatus, &OutDirStatus,
760                                      &CallBack, &tsync);
761                 RX_AFS_GLOCK();
762                 XSTATS_END_TIME;
763                 break;
764             case VLNK:
765                 /* Make symlink on server. */
766                 op = AFS_STATS_FS_RPCIDX_SYMLINK;
767                 XSTATS_START_TIME(op);
768                 RX_AFS_GUNLOCK();
769                 code = RXAFS_Symlink(rxconn,
770                                 (struct AFSFid *) &tdp->f.fid.Fid,
771                                 tname, ttargetName, &InStatus,
772                                 (struct AFSFid *) &newFid.Fid,
773                                 &OutFidStatus, &OutDirStatus, &tsync);
774                 RX_AFS_GLOCK();
775                 XSTATS_END_TIME;
776                 break;
777             default:
778                 op = AFS_STATS_FS_RPCIDX_CREATEFILE;
779                 code = 1;
780                 break;
781             }
782         } else
783             code = -1;
784     } while (afs_Analyze(tc, rxconn, code, &tdp->f.fid, areq, op, SHARED_LOCK, NULL));
785
786     /* TODO: Handle errors. */
787     if (code) {
788         /* printf("afs_ProcessOpCreate: error while creating vnode on server, code=%d .\n", code); */
789         goto end;
790     }
791
792     /* The rpc doesn't set the cell number. */
793     newFid.Cell = avc->f.fid.Cell;
794
795     /*
796      * Change the fid in the dir entry.
797      */
798
799     /* Seek the dir's dcache. */
800     tdc = afs_FindDCacheByFid(&tdp->f.fid);
801     if (tdc) {
802         /* And now change the fid in the parent dir entry. */
803         afs_dir_ChangeFid(tdc, tname, &avc->f.fid.Fid.Vnode, &newFid.Fid.Vnode);
804         afs_PutDCache(tdc);
805     }
806
807     if (vType(avc) == VDIR) {
808         /* Change fid in the dir for the "." entry. ".." has alredy been
809          * handled by afs_FixChildrenFids when processing the parent dir.
810          */
811         tdc = afs_FindDCacheByFid(&avc->f.fid);
812         if (tdc) {
813             afs_dir_ChangeFid(tdc, ".", &avc->f.fid.Fid.Vnode,
814                               &newFid.Fid.Vnode);
815
816             if (avc->f.m.LinkCount >= 2)
817                 /* For non empty dirs, fix children's parentVnode and
818                  * parentUnique reference.
819                  */
820                 afs_FixChildrenFids(&avc->f.fid, &newFid);
821
822             afs_PutDCache(tdc);
823         }
824     }
825
826     /* Recompute hash chain positions for vnode and dcaches.
827      * Then change to the new FID.
828      */
829
830     /* The vcache goes first. */
831     ObtainWriteLock(&afs_xvcache, 735);
832
833     /* Old fid hash. */
834     hash = VCHash(&avc->f.fid);
835     /* New fid hash. */
836     new_hash = VCHash(&newFid);
837
838     /* Remove hash from old position. */
839     /* XXX: not checking array element contents. It shouldn't be empty.
840      * If it oopses, then something else might be wrong.
841      */
842     if (afs_vhashT[hash] == avc) {
843         /* First in hash chain (might be the only one). */
844         afs_vhashT[hash] = avc->hnext;
845     } else {
846         /* More elements in hash chain. */
847         for (tvc = afs_vhashT[hash]; tvc; tvc = tvc->hnext) {
848             if (tvc->hnext == avc) {
849                 tvc->hnext = avc->hnext;
850                 break;
851             }
852         }
853     }                           /* if (!afs_vhashT[i]->hnext) */
854     QRemove(&avc->vhashq);
855
856     /* Insert hash in new position. */
857     avc->hnext = afs_vhashT[new_hash];
858     afs_vhashT[new_hash] = avc;
859     QAdd(&afs_vhashTV[VCHashV(&newFid)], &avc->vhashq);
860
861     ReleaseWriteLock(&afs_xvcache);
862
863     /* Do the same thing for all dcaches. */
864     hash = DVHash(&avc->f.fid);
865     ObtainWriteLock(&afs_xdcache, 743);
866     for (index = afs_dvhashTbl[hash]; index != NULLIDX; index = hash) {
867         hash = afs_dvnextTbl[index];
868         tdc = afs_GetValidDSlot(index);
869         if (!tdc) {
870             ReleaseWriteLock(&afs_xdcache);
871             code = EIO;
872             goto end;
873         }
874         ReleaseReadLock(&tdc->tlock);
875         if (afs_indexUnique[index] == avc->f.fid.Fid.Unique) {
876             if (!FidCmp(&tdc->f.fid, &avc->f.fid)) {
877
878                 /* Safer but slower. */
879                 afs_HashOutDCache(tdc, 0);
880
881                 /* Put dcache in new positions in the dchash and dvhash. */
882                 new_hash = DCHash(&newFid, tdc->f.chunk);
883                 afs_dcnextTbl[tdc->index] = afs_dchashTbl[new_hash];
884                 afs_dchashTbl[new_hash] = tdc->index;
885
886                 new_hash = DVHash(&newFid);
887                 afs_dvnextTbl[tdc->index] = afs_dvhashTbl[new_hash];
888                 afs_dvhashTbl[new_hash] = tdc->index;
889
890                 afs_indexUnique[tdc->index] = newFid.Fid.Unique;
891                 memcpy(&tdc->f.fid, &newFid, sizeof(struct VenusFid));
892            }                   /* if fid match */
893         }                       /* if uniquifier match */
894         afs_PutDCache(tdc);
895     }                           /* for all dcaches in this hash bucket */
896     ReleaseWriteLock(&afs_xdcache);
897
898     /* Now we can set the new fid. */
899     memcpy(&avc->f.fid, &newFid, sizeof(struct VenusFid));
900
901 end:
902     if (tdp)
903         afs_PutVCache(tdp);
904     afs_osi_Free(tname, AFSNAMEMAX);
905     if (ttargetName)
906         afs_osi_Free(ttargetName, tlen);
907     return code;
908 }
909
910 /*!
911  * Remove a vnode on the server, be it file or directory.
912  * Not much to do here only get the parent dir's fid and call the
913  * removal rpc.
914  *
915  * \param avc The deleted vcache
916  * \param areq
917  *
918  * \note The vcache refcount should be dropped because it points to
919  * a deleted vnode and has served it's purpouse, but we drop refcount
920  * on shadow dir deletio (we still need it for that).
921  *
922  * \note avc must be write locked.
923  */
924 int
925 afs_ProcessOpRemove(struct vcache *avc, struct vrequest *areq)
926 {
927     char *tname = NULL;
928     struct AFSFetchStatus OutDirStatus;
929     struct VenusFid pdir_fid;
930     struct AFSVolSync tsync;
931     struct afs_conn *tc;
932     struct rx_connection *rxconn;
933     struct vcache *tdp = NULL;
934     int code = 0;
935     XSTATS_DECLS;
936
937     tname = afs_osi_Alloc(AFSNAMEMAX);
938     if (!tname) {
939         /* printf("afs_ProcessOpRemove: Couldn't alloc space for file name\n"); */
940         return ENOMEM;
941     }
942
943     code = afs_GetParentVCache(avc, 1, &pdir_fid, tname, &tdp);
944     if (code)
945         goto end;
946
947     if ((vType(avc) == VDIR) && (afs_CheckDeletedChildren(avc))) {
948         /* Deleted children of this dir remain unsynchronized.
949          * Defer this vcache.
950          */
951         code = EAGAIN;
952         goto end;
953     }
954
955     if (vType(avc) == VREG || vType(avc) == VLNK) {
956         /* Remove file on server. */
957         do {
958             tc = afs_Conn(&pdir_fid, areq, SHARED_LOCK, &rxconn);
959             if (tc) {
960                 XSTATS_START_TIME(AFS_STATS_FS_RPCIDX_REMOVEFILE);
961                 RX_AFS_GUNLOCK();
962                 code = RXAFS_RemoveFile(rxconn,
963                                 &pdir_fid.Fid,
964                                 tname,
965                                 &OutDirStatus,
966                                 &tsync);
967
968                 RX_AFS_GLOCK();
969                 XSTATS_END_TIME;
970             } else
971                 code = -1;
972         } while (afs_Analyze(tc,
973                         rxconn,
974                         code,
975                         &pdir_fid,
976                         areq,
977                         AFS_STATS_FS_RPCIDX_REMOVEFILE,
978                         SHARED_LOCK,
979                         NULL));
980
981     } else if (vType(avc) == VDIR) {
982         /* Remove dir on server. */
983         do {
984             tc = afs_Conn(&pdir_fid, areq, SHARED_LOCK, &rxconn);
985             if (tc) {
986                 XSTATS_START_TIME(AFS_STATS_FS_RPCIDX_REMOVEDIR);
987                 RX_AFS_GUNLOCK();
988                 code = RXAFS_RemoveDir(rxconn,
989                                 &pdir_fid.Fid,
990                                 tname,
991                                 &OutDirStatus,
992                                 &tsync);
993                 RX_AFS_GLOCK();
994                 XSTATS_END_TIME;
995            } else
996                 code = -1;
997         } while (afs_Analyze(tc,
998                         rxconn,
999                         code,
1000                         &pdir_fid,
1001                         areq,
1002                         AFS_STATS_FS_RPCIDX_REMOVEDIR,
1003                         SHARED_LOCK,
1004                         NULL));
1005
1006     }                           /* if (vType(avc) == VREG) */
1007
1008     /* if (code) printf("afs_ProcessOpRemove: server returned code=%u\n", code); */
1009
1010 end:
1011     afs_osi_Free(tname, AFSNAMEMAX);
1012     return code;
1013 }
1014
1015 /*!
1016  * Send disconnected file changes to the server.
1017  *
1018  * \note Call with vnode locked both locally and on the server.
1019  *
1020  * \param avc Vnode that gets synchronized to the server.
1021  * \param areq Used for obtaining a conn struct.
1022  *
1023  * \return 0 for success. On failure, other error codes.
1024  */
1025 int
1026 afs_SendChanges(struct vcache *avc, struct vrequest *areq)
1027 {
1028     struct afs_conn *tc;
1029     struct rx_connection *rxconn;
1030     struct AFSStoreStatus sstat;
1031     struct AFSFetchStatus fstat;
1032     struct AFSVolSync tsync;
1033     int code = 0;
1034     int flags = 0;
1035     XSTATS_DECLS;
1036
1037     /* Start multiplexing dirty operations from ddirty_flags field: */
1038     if (avc->f.ddirty_flags & VDisconSetAttrMask) {
1039         /* Setattr OPS: */
1040         /* Turn dirty vc data into a new store status... */
1041         if (afs_GenStoreStatus(avc, &sstat) > 0) {
1042             do {
1043                 tc = afs_Conn(&avc->f.fid, areq, SHARED_LOCK, &rxconn);
1044                 if (tc) {
1045                     /* ... and send it. */
1046                     XSTATS_START_TIME(AFS_STATS_FS_RPCIDX_STORESTATUS);
1047                     RX_AFS_GUNLOCK();
1048                     code = RXAFS_StoreStatus(rxconn,
1049                                 (struct AFSFid *) &avc->f.fid.Fid,
1050                                 &sstat,
1051                                 &fstat,
1052                                 &tsync);
1053
1054                     RX_AFS_GLOCK();
1055                     XSTATS_END_TIME;
1056                 } else
1057                     code = -1;
1058
1059         } while (afs_Analyze(tc,
1060                         rxconn,
1061                         code,
1062                         &avc->f.fid,
1063                         areq,
1064                         AFS_STATS_FS_RPCIDX_STORESTATUS,
1065                         SHARED_LOCK,
1066                         NULL));
1067
1068         }               /* if (afs_GenStoreStatus() > 0)*/
1069     }                   /* disconnected SETATTR */
1070
1071     if (code)
1072         return code;
1073
1074     if (avc->f.ddirty_flags &
1075         (VDisconTrunc
1076         | VDisconWriteClose
1077         | VDisconWriteFlush
1078         | VDisconWriteOsiFlush)) {
1079
1080         /* Truncate OP: */
1081         do {
1082             tc = afs_Conn(&avc->f.fid, areq, SHARED_LOCK, &rxconn);
1083             if (tc) {
1084                 /* Set storing flags. XXX: A tad inefficient ... */
1085                 if (avc->f.ddirty_flags & VDisconWriteClose)
1086                     flags |= AFS_LASTSTORE;
1087                 if (avc->f.ddirty_flags & VDisconWriteOsiFlush)
1088                     flags |= (AFS_SYNC | AFS_LASTSTORE);
1089                 if (avc->f.ddirty_flags & VDisconWriteFlush)
1090                     flags |= AFS_SYNC;
1091
1092                 /* Try to send store to server. */
1093                 /* XXX: AFS_LASTSTORE for writes? Or just AFS_SYNC for all? */
1094                 code = afs_StoreAllSegments(avc, areq, flags);
1095             } else
1096                 code = -1;
1097
1098         } while (afs_Analyze(tc,
1099                         rxconn,
1100                         code,
1101                         &avc->f.fid,
1102                         areq,
1103                         AFS_STATS_FS_RPCIDX_STOREDATA,
1104                         SHARED_LOCK,
1105                         NULL));
1106
1107     }                   /* disconnected TRUNC | WRITE */
1108
1109     return code;
1110 }
1111
1112 /*!
1113  * All files that have been dirty before disconnection are going to
1114  * be replayed back to the server.
1115  *
1116  * \param areq Request from the user.
1117  * \param acred User credentials.
1118  *
1119  * \return If all files synchronized succesfully, return 0, otherwise
1120  * return error code
1121  *
1122  * \note For now, it's the request from the PDiscon pioctl.
1123  *
1124  */
1125 int
1126 afs_ResyncDisconFiles(struct vrequest *areq, afs_ucred_t *acred)
1127 {
1128     struct afs_conn *tc;
1129     struct rx_connection *rxconn;
1130     struct vcache *tvc;
1131     struct AFSFetchStatus fstat;
1132     struct AFSCallBack callback;
1133     struct AFSVolSync tsync;
1134     int code = 0;
1135     afs_int32 start = 0;
1136     XSTATS_DECLS;
1137     /*AFS_STATCNT(afs_ResyncDisconFiles);*/
1138
1139     ObtainWriteLock(&afs_disconDirtyLock, 707);
1140
1141     while (!QEmpty(&afs_disconDirty)) {
1142         tvc = QEntry(QPrev(&afs_disconDirty), struct vcache, dirtyq);
1143
1144         /* Can't lock tvc whilst holding the discon dirty lock */
1145         ReleaseWriteLock(&afs_disconDirtyLock);
1146
1147         /* Get local write lock. */
1148         ObtainWriteLock(&tvc->lock, 705);
1149
1150         if (tvc->f.ddirty_flags & VDisconRemove) {
1151             /* Delete the file on the server and just move on
1152              * to the next file. After all, it has been deleted
1153              * we can't replay any other operation it.
1154              */
1155             code = afs_ProcessOpRemove(tvc, areq);
1156             goto next_file;
1157
1158         } else if (tvc->f.ddirty_flags & VDisconCreate) {
1159             /* For newly created files, we don't need a server lock. */
1160             code = afs_ProcessOpCreate(tvc, areq, acred);
1161             if (code)
1162                 goto next_file;
1163
1164             tvc->f.ddirty_flags &= ~VDisconCreate;
1165             tvc->f.ddirty_flags |= VDisconCreated;
1166         }
1167         if (tvc->f.ddirty_flags & VDisconRename) {
1168             /* If we're renaming the file, do so now */
1169             code = afs_ProcessOpRename(tvc, areq);
1170             if (code)
1171                 goto unlock_srv_file;
1172         }
1173
1174         /* Issue a FetchStatus to get info about DV and callbacks. */
1175         do {
1176             tc = afs_Conn(&tvc->f.fid, areq, SHARED_LOCK, &rxconn);
1177             if (tc) {
1178                 tvc->callback = tc->parent->srvr->server;
1179                 start = osi_Time();
1180                 XSTATS_START_TIME(AFS_STATS_FS_RPCIDX_FETCHSTATUS);
1181                 RX_AFS_GUNLOCK();
1182                 code = RXAFS_FetchStatus(rxconn,
1183                                 (struct AFSFid *)&tvc->f.fid.Fid,
1184                                 &fstat,
1185                                 &callback,
1186                                 &tsync);
1187                 RX_AFS_GLOCK();
1188                 XSTATS_END_TIME;
1189             } else
1190                 code = -1;
1191
1192         } while (afs_Analyze(tc,
1193                         rxconn,
1194                         code,
1195                         &tvc->f.fid,
1196                         areq,
1197                         AFS_STATS_FS_RPCIDX_FETCHSTATUS,
1198                         SHARED_LOCK,
1199                         NULL));
1200
1201         if (code) {
1202             goto unlock_srv_file;
1203         }
1204
1205         if ((dv_match(tvc, fstat) && (tvc->f.m.Date == fstat.ServerModTime)) ||
1206                 (afs_ConflictPolicy == CLIENT_WINS) ||
1207                 (tvc->f.ddirty_flags & VDisconCreated)) {
1208             /*
1209              * Send changes to the server if there's data version match, or
1210              * client wins policy has been selected or file has been created
1211              * but doesn't have it's the contents on to the server yet.
1212              */
1213            /*
1214             * XXX: Checking server attr changes by timestamp might not the
1215             * most elegant solution, but it's the most viable one that we could find.
1216             */
1217             afs_UpdateStatus(tvc, &tvc->f.fid, areq, &fstat, &callback, start);
1218             code = afs_SendChanges(tvc, areq);
1219
1220         } else if (afs_ConflictPolicy == SERVER_WINS) {
1221             /* DV mismatch, apply collision resolution policy. */
1222             /* Discard this files chunks and remove from current dir. */
1223             afs_ResetVCache(tvc, acred, 0);
1224             tvc->f.truncPos = AFS_NOTRUNC;
1225         } else {
1226             /* printf("afs_ResyncDisconFiles: no resolution policy selected.\n"); */
1227         }               /* if DV match or client wins policy */
1228
1229 unlock_srv_file:
1230         /* If we ever lock files while replaying changes, we should unlock the
1231          * file here. */
1232
1233 next_file:
1234         ObtainWriteLock(&afs_disconDirtyLock, 710);
1235         if (code == 0) {
1236             /* Replayed successfully - pull the vcache from the
1237              * disconnected list */
1238             tvc->f.ddirty_flags = 0;
1239             QRemove(&tvc->dirtyq);
1240             afs_PutVCache(tvc);
1241         } else {
1242             if (code == EAGAIN) {
1243                 /* Operation was deferred. Pull it from the current place in
1244                  * the list, and stick it at the end again */
1245                 QRemove(&tvc->dirtyq);
1246                 QAdd(&afs_disconDirty, &tvc->dirtyq);
1247             } else {
1248                 /* Failed - keep state as is, and let the user know we died */
1249
1250                 ReleaseWriteLock(&tvc->lock);
1251                 break;
1252             }
1253         }
1254
1255         /* Release local write lock. */
1256         ReleaseWriteLock(&tvc->lock);
1257     }                   /* while (tvc) */
1258
1259     if (code) {
1260         ReleaseWriteLock(&afs_disconDirtyLock);
1261         return code;
1262     }
1263
1264     /* Dispose of all of the shadow directories */
1265     afs_DisconDiscardAllShadows(0, acred);
1266
1267     ReleaseWriteLock(&afs_disconDirtyLock);
1268     return code;
1269 }
1270
1271 /*!
1272  * Discard all of our shadow directory copies. If squash is true, then
1273  * we also invalidate the vcache holding the shadow directory, to ensure
1274  * that any disconnected changes are deleted
1275  *
1276  * \param squash
1277  * \param acred
1278  *
1279  * \note afs_disconDirtyLock must be held on entry. It will be released
1280  * and reobtained
1281  */
1282
1283 static void
1284 afs_DisconDiscardAllShadows(int squash, afs_ucred_t *acred)
1285 {
1286    struct vcache *tvc;
1287
1288    while (!QEmpty(&afs_disconShadow)) {
1289         tvc = QEntry(QNext(&afs_disconShadow), struct vcache, shadowq);
1290
1291         /* Must release the dirty lock to be able to get a vcache lock */
1292         ReleaseWriteLock(&afs_disconDirtyLock);
1293         ObtainWriteLock(&tvc->lock, 706);
1294
1295         if (squash)
1296            afs_ResetVCache(tvc, acred, 0);
1297
1298         afs_DeleteShadowDir(tvc);
1299
1300         ReleaseWriteLock(&tvc->lock);
1301         ObtainWriteLock(&afs_disconDirtyLock, 709);
1302     }                           /* while (tvc) */
1303 }
1304
1305 /*!
1306  * This function throws away the whole disconnected state, allowing
1307  * the cache manager to reconnect to a server if we get into a state
1308  * where reconiliation is impossible.
1309  *
1310  * \param acred
1311  *
1312  */
1313 void
1314 afs_DisconDiscardAll(afs_ucred_t *acred)
1315 {
1316     struct vcache *tvc;
1317
1318     ObtainWriteLock(&afs_disconDirtyLock, 717);
1319     while (!QEmpty(&afs_disconDirty)) {
1320         tvc = QEntry(QPrev(&afs_disconDirty), struct vcache, dirtyq);
1321         QRemove(&tvc->dirtyq);
1322         ReleaseWriteLock(&afs_disconDirtyLock);
1323
1324         ObtainWriteLock(&tvc->lock, 718);
1325         afs_ResetVCache(tvc, acred, 0);
1326         tvc->f.truncPos = AFS_NOTRUNC;
1327         ReleaseWriteLock(&tvc->lock);
1328         ObtainWriteLock(&afs_disconDirtyLock, 719);
1329         afs_PutVCache(tvc);
1330     }
1331
1332     afs_DisconDiscardAllShadows(1, acred);
1333
1334     ReleaseWriteLock(&afs_disconDirtyLock);
1335 }
1336
1337 /*!
1338  * Print list of disconnected files.
1339  *
1340  * \note Call with afs_DDirtyVCListLock read locked.
1341  */
1342 void
1343 afs_DbgDisconFiles(void)
1344 {
1345     struct vcache *tvc;
1346     struct afs_q *q;
1347     int i = 0;
1348
1349     afs_warn("List of dirty files: \n");
1350
1351     ObtainReadLock(&afs_disconDirtyLock);
1352     for (q = QPrev(&afs_disconDirty); q != &afs_disconDirty; q = QPrev(q)) {
1353         tvc = QEntry(q, struct vcache, dirtyq);
1354
1355         afs_warn("Cell=%u Volume=%u VNode=%u Unique=%u\n",
1356                 tvc->f.fid.Cell,
1357                 tvc->f.fid.Fid.Volume,
1358                 tvc->f.fid.Fid.Vnode,
1359                 tvc->f.fid.Fid.Unique);
1360
1361         i++;
1362         if (i >= 30)
1363             osi_Panic("afs_DbgDisconFiles: loop in dirty list\n");
1364     }
1365     ReleaseReadLock(&afs_disconDirtyLock);
1366 }
1367
1368 /*!
1369  * Generate a fake fid for a disconnected shadow dir.
1370  * Similar to afs_GenFakeFid, only that it uses the dhash
1371  * to search for a uniquifier because a shadow dir lives only
1372  * in the dcache.
1373  *
1374  * \param afid
1375  *
1376  * \note Don't forget to fill in afid with Cell and Volume.
1377  */
1378 void
1379 afs_GenShadowFid(struct VenusFid *afid)
1380 {
1381     afs_uint32 i, index, max_unique = 1;
1382     struct vcache *tvc = NULL;
1383
1384     /* Try generating a fid that isn't used in the vhash. */
1385     do {
1386         /* Shadow Fids are always directories */
1387         afid->Fid.Vnode = afs_DisconVnode + 1;
1388
1389         i = DVHash(afid);
1390         ObtainWriteLock(&afs_xdcache, 737);
1391         for (index = afs_dvhashTbl[i]; index != NULLIDX; index = i) {
1392             i = afs_dvnextTbl[index];
1393             if (afs_indexUnique[index] > max_unique)
1394                 max_unique = afs_indexUnique[index];
1395         }
1396
1397         ReleaseWriteLock(&afs_xdcache);
1398         afid->Fid.Unique = max_unique + 1;
1399         afs_DisconVnode += 2;
1400         if (!afs_DisconVnode)
1401             afs_DisconVnode = 2;
1402
1403         /* Is this a used vnode? */
1404         ObtainSharedLock(&afs_xvcache, 762);
1405         tvc = afs_FindVCache(afid, 0, 1);
1406         ReleaseSharedLock(&afs_xvcache);
1407         if (tvc)
1408             afs_PutVCache(tvc);
1409     } while (tvc);
1410 }
1411
1412 /*!
1413  * Generate a fake fid (vnode and uniquifier) for a vcache
1414  * (either dir or normal file). The vnode is generated via
1415  * afs_DisconVNode and the uniquifier by getting the highest
1416  * uniquifier on a hash chain and incrementing it by one.
1417  *
1418  * \param afid   The fid structre that will be filled.
1419  * \param avtype Vnode type: VDIR/VREG.
1420  * \param lock   True indicates that xvcache may be obtained,
1421  *               False that it is already held
1422  *
1423  * \note The cell number must be completed somewhere else.
1424  */
1425 void
1426 afs_GenFakeFid(struct VenusFid *afid, afs_uint32 avtype, int lock)
1427 {
1428     struct vcache *tvc;
1429     afs_uint32 max_unique = 0, i;
1430
1431     switch (avtype) {
1432     case VDIR:
1433         afid->Fid.Vnode = afs_DisconVnode + 1;
1434         break;
1435     case VREG:
1436     case VLNK:
1437         afid->Fid.Vnode = afs_DisconVnode;
1438         break;
1439     }
1440
1441     if (lock)
1442         ObtainWriteLock(&afs_xvcache, 736);
1443     i = VCHash(afid);
1444     for (tvc = afs_vhashT[i]; tvc; tvc = tvc->hnext) {
1445         if (tvc->f.fid.Fid.Unique > max_unique)
1446             max_unique = tvc->f.fid.Fid.Unique;
1447     }
1448     if (lock)
1449         ReleaseWriteLock(&afs_xvcache);
1450
1451     afid->Fid.Unique = max_unique + 1;
1452     afs_DisconVnode += 2;
1453     if (!afs_DisconVnode)
1454         afs_DisconVnode = 2;
1455 }
1456
1457 /*!
1458  * Fill in stats for a newly created file/directory.
1459  *
1460  * \param adp The parent dir's vcache.
1461  * \param avc The created vnode.
1462  * \param afid The new fid.
1463  * \param attrs
1464  * \param areq
1465  * \param file_type Specify if file or directory.
1466  *
1467  * \note Call with avc write locked.
1468  */
1469 void
1470 afs_GenDisconStatus(struct vcache *adp, struct vcache *avc,
1471                     struct VenusFid *afid, struct vattr *attrs,
1472                     struct vrequest *areq, int file_type)
1473 {
1474     afs_hyper_t zero;
1475     memcpy(&avc->f.fid, afid, sizeof(struct VenusFid));
1476     avc->f.m.Mode = attrs->va_mode;
1477     /* Used to do this:
1478      * avc->f.m.Owner = attrs->va_uid;
1479      * But now we use the parent dir's ownership,
1480      * there's no other way to get a server owner id.
1481      * XXX: Does it really matter?
1482      */
1483     avc->f.m.Group = adp->f.m.Group;
1484     avc->f.m.Owner = adp->f.m.Owner;
1485     hzero(zero);
1486     afs_SetDataVersion(avc, &zero);
1487     avc->f.m.Length = attrs->va_size;
1488     avc->f.m.Date = osi_Time();
1489     switch(file_type) {
1490       case VREG:
1491         vSetType(avc, VREG);
1492         avc->f.m.Mode |= S_IFREG;
1493         avc->f.m.LinkCount = 1;
1494         avc->f.parent.vnode = adp->f.fid.Fid.Vnode;
1495         avc->f.parent.unique = adp->f.fid.Fid.Unique;
1496         break;
1497       case VDIR:
1498         vSetType(avc, VDIR);
1499         avc->f.m.Mode |= S_IFDIR;
1500         avc->f.m.LinkCount = 2;
1501         break;
1502       case VLNK:
1503         vSetType(avc, VLNK);
1504         avc->f.m.Mode |= S_IFLNK;
1505         if ((avc->f.m.Mode & 0111) == 0)
1506             avc->mvstat = AFS_MVSTAT_MTPT;
1507         avc->f.parent.vnode = adp->f.fid.Fid.Vnode;
1508         avc->f.parent.unique = adp->f.fid.Fid.Unique;
1509         break;
1510       default:
1511         break;
1512     }
1513     avc->f.anyAccess = adp->f.anyAccess;
1514     afs_AddAxs(avc->Access, areq->uid, adp->Access->axess);
1515
1516     avc->callback = NULL;
1517     avc->f.states |= CStatd;
1518     avc->f.states &= ~CBulkFetching;
1519 }