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