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