Merge branch 'vendor/GCC50'
[dragonfly.git] / contrib / amd / amd / amfs_auto.c
1 /*
2  * Copyright (c) 1997-1999 Erez Zadok
3  * Copyright (c) 1990 Jan-Simon Pendry
4  * Copyright (c) 1990 Imperial College of Science, Technology & Medicine
5  * Copyright (c) 1990 The Regents of the University of California.
6  * All rights reserved.
7  *
8  * This code is derived from software contributed to Berkeley by
9  * Jan-Simon Pendry at Imperial College, London.
10  *
11  * Redistribution and use in source and binary forms, with or without
12  * modification, are permitted provided that the following conditions
13  * are met:
14  * 1. Redistributions of source code must retain the above copyright
15  *    notice, this list of conditions and the following disclaimer.
16  * 2. Redistributions in binary form must reproduce the above copyright
17  *    notice, this list of conditions and the following disclaimer in the
18  *    documentation and/or other materials provided with the distribution.
19  * 3. All advertising materials mentioning features or use of this software
20  *    must display the following acknowledgment:
21  *      This product includes software developed by the University of
22  *      California, Berkeley and its contributors.
23  * 4. Neither the name of the University nor the names of its contributors
24  *    may be used to endorse or promote products derived from this software
25  *    without specific prior written permission.
26  *
27  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
28  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
29  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
30  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
31  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
32  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
33  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
34  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
35  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
36  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
37  * SUCH DAMAGE.
38  *
39  *      %W% (Berkeley) %G%
40  *
41  * $Id: amfs_auto.c,v 1.5 1999/09/30 21:01:29 ezk Exp $
42  *
43  */
44
45 /*
46  * Automount file system
47  */
48
49 #ifdef HAVE_CONFIG_H
50 # include <config.h>
51 #endif /* HAVE_CONFIG_H */
52 #include <am_defs.h>
53 #include <amd.h>
54
55 /****************************************************************************
56  *** MACROS                                                               ***
57  ****************************************************************************/
58 #define IN_PROGRESS(cp) ((cp)->mp->am_mnt->mf_flags & MFF_MOUNTING)
59
60 /* DEVELOPERS: turn this on for special debugging of readdir code */
61 #undef DEBUG_READDIR
62
63 #define DOT_DOT_COOKIE (u_int) 1
64
65 /****************************************************************************
66  *** STRUCTURES                                                           ***
67  ****************************************************************************/
68
69
70 /****************************************************************************
71  *** FORWARD DEFINITIONS                                                  ***
72  ****************************************************************************/
73 static int amfs_auto_bgmount(struct continuation * cp, int mpe);
74 static int amfs_auto_mount(am_node *mp);
75 static int amfs_auto_readdir_browsable(am_node *mp, nfscookie cookie, nfsdirlist *dp, nfsentry *ep, int count, int fully_browsable);
76 static void amfs_auto_umounted(am_node *mp);
77
78
79 /****************************************************************************
80  *** OPS STRUCTURES                                                       ***
81  ****************************************************************************/
82 am_ops amfs_auto_ops =
83 {
84   "auto",
85   amfs_auto_match,
86   0,                            /* amfs_auto_init */
87   amfs_auto_mount,
88   0,
89   amfs_auto_umount,
90   0,
91   amfs_auto_lookuppn,
92   amfs_auto_readdir,
93   0,                            /* amfs_auto_readlink */
94   0,                            /* amfs_auto_mounted */
95   amfs_auto_umounted,
96   find_amfs_auto_srvr,
97   FS_AMQINFO | FS_DIRECTORY
98 };
99
100
101 /****************************************************************************
102  *** FUNCTIONS                                                             ***
103  ****************************************************************************/
104 /*
105  * AMFS_AUTO needs nothing in particular.
106  */
107 char *
108 amfs_auto_match(am_opts *fo)
109 {
110   char *p = fo->opt_rfs;
111
112   if (!fo->opt_rfs) {
113     plog(XLOG_USER, "auto: no mount point named (rfs:=)");
114     return 0;
115   }
116   if (!fo->opt_fs) {
117     plog(XLOG_USER, "auto: no map named (fs:=)");
118     return 0;
119   }
120
121   /*
122    * Swap round fs:= and rfs:= options
123    * ... historical (jsp)
124    */
125   fo->opt_rfs = fo->opt_fs;
126   fo->opt_fs = p;
127
128   /*
129    * mtab entry turns out to be the name of the mount map
130    */
131   return strdup(fo->opt_rfs ? fo->opt_rfs : ".");
132 }
133
134
135
136
137 /*
138  * Build a new map cache for this node, or re-use
139  * an existing cache for the same map.
140  */
141 void
142 amfs_auto_mkcacheref(mntfs *mf)
143 {
144   char *cache;
145
146   if (mf->mf_fo && mf->mf_fo->opt_cache)
147     cache = mf->mf_fo->opt_cache;
148   else
149     cache = "none";
150   mf->mf_private = (voidp) mapc_find(mf->mf_info, cache,
151                                      mf->mf_fo->opt_maptype);
152   mf->mf_prfree = mapc_free;
153 }
154
155
156 /*
157  * Mount a sub-mount
158  */
159 static int
160 amfs_auto_mount(am_node *mp)
161 {
162   mntfs *mf = mp->am_mnt;
163
164   /*
165    * Pseudo-directories are used to provide some structure
166    * to the automounted directories instead
167    * of putting them all in the top-level automount directory.
168    *
169    * Here, just increment the parent's link count.
170    */
171   mp->am_parent->am_fattr.na_nlink++;
172
173   /*
174    * Info field of . means use parent's info field.
175    * Historical - not documented.
176    */
177   if (mf->mf_info[0] == '.' && mf->mf_info[1] == '\0')
178     mf->mf_info = strealloc(mf->mf_info, mp->am_parent->am_mnt->mf_info);
179
180   /*
181    * Compute prefix:
182    *
183    * If there is an option prefix then use that else
184    * If the parent had a prefix then use that with name
185    *      of this node appended else
186    * Use the name of this node.
187    *
188    * That means if you want no prefix you must say so
189    * in the map.
190    */
191   if (mf->mf_fo->opt_pref) {
192     /* allow pref:=null to set a real null prefix */
193     if (STREQ(mf->mf_fo->opt_pref, "null")) {
194       mp->am_pref = "";
195     } else {
196       /*
197        * the prefix specified as an option
198        */
199       mp->am_pref = strdup(mf->mf_fo->opt_pref);
200     }
201   } else {
202     /*
203      * else the parent's prefix
204      * followed by the name
205      * followed by /
206      */
207     char *ppref = mp->am_parent->am_pref;
208     if (ppref == 0)
209       ppref = "";
210     mp->am_pref = str3cat((char *) 0, ppref, mp->am_name, "/");
211   }
212
213   /*
214    * Attach a map cache
215    */
216   amfs_auto_mkcacheref(mf);
217
218   return 0;
219 }
220
221
222
223
224 /*
225  * Unmount an automount sub-node
226  */
227 int
228 amfs_auto_umount(am_node *mp)
229 {
230   return 0;
231 }
232
233
234 /*
235  * Unmount an automount node
236  */
237 static void
238 amfs_auto_umounted(am_node *mp)
239 {
240   /*
241    * If this is a pseudo-directory then just adjust the link count
242    * in the parent, otherwise call the generic unmount routine
243    */
244   if (mp->am_parent && mp->am_parent->am_parent)
245     --mp->am_parent->am_fattr.na_nlink;
246 }
247
248
249 /*
250  * Discard an old continuation
251  */
252 void
253 free_continuation(struct continuation *cp)
254 {
255   if (cp->callout)
256     untimeout(cp->callout);
257   XFREE(cp->key);
258   XFREE(cp->xivec);
259   XFREE(cp->info);
260   XFREE(cp->auto_opts);
261   XFREE(cp->def_opts);
262   free_opts(&cp->fs_opts);
263   XFREE(cp);
264 }
265
266
267 /*
268  * Discard the underlying mount point and replace
269  * with a reference to an error filesystem.
270  */
271 void
272 assign_error_mntfs(am_node *mp)
273 {
274   if (mp->am_error > 0) {
275     /*
276      * Save the old error code
277      */
278     int error = mp->am_error;
279     if (error <= 0)
280       error = mp->am_mnt->mf_error;
281     /*
282      * Discard the old filesystem
283      */
284     free_mntfs(mp->am_mnt);
285     /*
286      * Allocate a new error reference
287      */
288     mp->am_mnt = new_mntfs();
289     /*
290      * Put back the error code
291      */
292     mp->am_mnt->mf_error = error;
293     mp->am_mnt->mf_flags |= MFF_ERROR;
294     /*
295      * Zero the error in the mount point
296      */
297     mp->am_error = 0;
298   }
299 }
300
301
302 /*
303  * The continuation function.  This is called by
304  * the task notifier when a background mount attempt
305  * completes.
306  */
307 void
308 amfs_auto_cont(int rc, int term, voidp closure)
309 {
310   struct continuation *cp = (struct continuation *) closure;
311   mntfs *mf = cp->mp->am_mnt;
312
313   /*
314    * Definitely not trying to mount at the moment
315    */
316   mf->mf_flags &= ~MFF_MOUNTING;
317
318   /*
319    * While we are mounting - try to avoid race conditions
320    */
321   new_ttl(cp->mp);
322
323   /*
324    * Wakeup anything waiting for this mount
325    */
326   wakeup((voidp) mf);
327
328   /*
329    * Check for termination signal or exit status...
330    */
331   if (rc || term) {
332     am_node *xmp;
333
334     if (term) {
335       /*
336        * Not sure what to do for an error code.
337        */
338       mf->mf_error = EIO;       /* XXX ? */
339       mf->mf_flags |= MFF_ERROR;
340       plog(XLOG_ERROR, "mount for %s got signal %d", cp->mp->am_path, term);
341     } else {
342       /*
343        * Check for exit status...
344        */
345       mf->mf_error = rc;
346       mf->mf_flags |= MFF_ERROR;
347       errno = rc;               /* XXX */
348       if (!STREQ(cp->mp->am_mnt->mf_ops->fs_type, "linkx"))
349         plog(XLOG_ERROR, "%s: mount (amfs_auto_cont): %m", cp->mp->am_path);
350     }
351
352     /*
353      * If we get here then that attempt didn't work, so
354      * move the info vector pointer along by one and
355      * call the background mount routine again
356      */
357     amd_stats.d_merr++;
358     cp->ivec++;
359     xmp = cp->mp;
360     (void) amfs_auto_bgmount(cp, 0);
361     assign_error_mntfs(xmp);
362   } else {
363     /*
364      * The mount worked.
365      */
366     am_mounted(cp->mp);
367     free_continuation(cp);
368   }
369
370   reschedule_timeout_mp();
371 }
372
373
374 /*
375  * Retry a mount
376  */
377 void
378 amfs_auto_retry(int rc, int term, voidp closure)
379 {
380   struct continuation *cp = (struct continuation *) closure;
381   int error = 0;
382
383 #ifdef DEBUG
384   dlog("Commencing retry for mount of %s", cp->mp->am_path);
385 #endif /* DEBUG */
386
387   new_ttl(cp->mp);
388
389   if ((cp->start + ALLOWED_MOUNT_TIME) < clocktime()) {
390     /*
391      * The entire mount has timed out.  Set the error code and skip past all
392      * the info vectors so that amfs_auto_bgmount will not have any more
393      * ways to try the mount, so causing an error.
394      */
395     plog(XLOG_INFO, "mount of \"%s\" has timed out", cp->mp->am_path);
396     error = ETIMEDOUT;
397     while (*cp->ivec)
398       cp->ivec++;
399     /* explicitly forbid further retries after timeout */
400     cp->retry = FALSE;
401   }
402   if (error || !IN_PROGRESS(cp)) {
403     (void) amfs_auto_bgmount(cp, error);
404   }
405   reschedule_timeout_mp();
406 }
407
408
409 /*
410  * Try to mount a file system.  Can be called
411  * directly or in a sub-process by run_task.
412  */
413 int
414 try_mount(voidp mvp)
415 {
416   int error = 0;
417   am_node *mp = (am_node *) mvp;
418   mntfs *mf = mp->am_mnt;
419
420   /*
421    * If the directory is not yet made and it needs to be made, then make it!
422    * This may be run in a background process in which case the flag setting
423    * won't be noticed later - but it is set anyway just after run_task is
424    * called.  It should probably go away totally...
425    */
426   if (!(mf->mf_flags & MFF_MKMNT) && mf->mf_ops->fs_flags & FS_MKMNT) {
427     error = mkdirs(mf->mf_mount, 0555);
428     if (!error)
429       mf->mf_flags |= MFF_MKMNT;
430   }
431
432   /*
433    * Mount it!
434    */
435   error = mount_node(mp);
436
437 #ifdef DEBUG
438   if (error > 0) {
439     errno = error;
440     dlog("amfs_auto call to mount_node failed: %m");
441   }
442 #endif /* DEBUG */
443
444   return error;
445 }
446
447
448 /*
449  * Pick a file system to try mounting and
450  * do that in the background if necessary
451  *
452 For each location:
453         if it is new -defaults then
454                 extract and process
455                 continue;
456         fi
457         if it is a cut then
458                 if a location has been tried then
459                         break;
460                 fi
461                 continue;
462         fi
463         parse mount location
464         discard previous mount location if required
465         find matching mounted filesystem
466         if not applicable then
467                 this_error = No such file or directory
468                 continue
469         fi
470         if the filesystem failed to be mounted then
471                 this_error = error from filesystem
472         elif the filesystem is mounting or unmounting then
473                 this_error = -1
474         elif the fileserver is down then
475                 this_error = -1
476         elif the filesystem is already mounted
477                 this_error = 0
478                 break
479         fi
480         if no error on this mount then
481                 this_error = initialize mount point
482         fi
483         if no error on this mount and mount is delayed then
484                 this_error = -1
485         fi
486         if this_error < 0 then
487                 retry = true
488         fi
489         if no error on this mount then
490                 make mount point if required
491         fi
492         if no error on this mount then
493                 if mount in background then
494                         run mount in background
495                         return -1
496                 else
497                         this_error = mount in foreground
498                 fi
499         fi
500         if an error occurred on this mount then
501                 update stats
502                 save error in mount point
503         fi
504 endfor
505  */
506 static int
507 amfs_auto_bgmount(struct continuation * cp, int mpe)
508 {
509   mntfs *mf = cp->mp->am_mnt;   /* Current mntfs */
510   mntfs *mf_retry = 0;          /* First mntfs which needed retrying */
511   int this_error = -1;          /* Per-mount error */
512   int hard_error = -1;
513   int mp_error = mpe;
514
515   /*
516    * Try to mount each location.
517    * At the end:
518    * hard_error == 0 indicates something was mounted.
519    * hard_error > 0 indicates everything failed with a hard error
520    * hard_error < 0 indicates nothing could be mounted now
521    */
522   for (; this_error && *cp->ivec; cp->ivec++) {
523     am_ops *p;
524     am_node *mp = cp->mp;
525     char *link_dir;
526     int dont_retry;
527
528     if (hard_error < 0)
529       hard_error = this_error;
530
531     this_error = -1;
532
533     if (**cp->ivec == '-') {
534       /*
535        * Pick up new defaults
536        */
537       if (cp->auto_opts && *cp->auto_opts)
538         cp->def_opts = str3cat(cp->def_opts, cp->auto_opts, ";", *cp->ivec + 1);
539       else
540         cp->def_opts = strealloc(cp->def_opts, *cp->ivec + 1);
541 #ifdef DEBUG
542       dlog("Setting def_opts to \"%s\"", cp->def_opts);
543 #endif /* DEBUG */
544       continue;
545     }
546     /*
547      * If a mount has been attempted, and we find
548      * a cut then don't try any more locations.
549      */
550     if (STREQ(*cp->ivec, "/") || STREQ(*cp->ivec, "||")) {
551       if (cp->tried) {
552 #ifdef DEBUG
553         dlog("Cut: not trying any more locations for %s",
554              mp->am_path);
555 #endif /* DEBUG */
556         break;
557       }
558       continue;
559     }
560
561     /* match the operators */
562     p = ops_match(&cp->fs_opts, *cp->ivec, cp->def_opts, mp->am_path, cp->key, mp->am_parent->am_mnt->mf_info);
563
564     /*
565      * Find a mounted filesystem for this node.
566      */
567     mp->am_mnt = mf = realloc_mntfs(mf, p, &cp->fs_opts,
568                                     cp->fs_opts.opt_fs,
569                                     cp->fs_opts.fs_mtab,
570                                     cp->auto_opts,
571                                     cp->fs_opts.opt_opts,
572                                     cp->fs_opts.opt_remopts);
573
574     p = mf->mf_ops;
575 #ifdef DEBUG
576     dlog("Got a hit with %s", p->fs_type);
577 #endif /* DEBUG */
578
579     /*
580      * Note whether this is a real mount attempt
581      */
582     if (p == &amfs_error_ops) {
583       plog(XLOG_MAP, "Map entry %s for %s failed to match", *cp->ivec, mp->am_path);
584       if (this_error <= 0)
585         this_error = ENOENT;
586       continue;
587     } else {
588       if (cp->fs_opts.fs_mtab) {
589         plog(XLOG_MAP, "Trying mount of %s on %s fstype %s",
590              cp->fs_opts.fs_mtab, mp->am_path, p->fs_type);
591       }
592       cp->tried = TRUE;
593     }
594
595     this_error = 0;
596     dont_retry = FALSE;
597
598     if (mp->am_link) {
599       XFREE(mp->am_link);
600       mp->am_link = 0;
601     }
602     link_dir = mf->mf_fo->opt_sublink;
603
604     if (link_dir && *link_dir) {
605       if (*link_dir == '/') {
606         mp->am_link = strdup(link_dir);
607       } else {
608         /*
609          * try getting fs option from continuation, not mountpoint!
610          * Don't try logging the string from mf, since it may be bad!
611          */
612         if (cp->fs_opts.opt_fs != mf->mf_fo->opt_fs)
613           plog(XLOG_ERROR, "use %s instead of 0x%lx",
614                cp->fs_opts.opt_fs, (unsigned long) mf->mf_fo->opt_fs);
615
616         mp->am_link = str3cat((char *) 0,
617                               cp->fs_opts.opt_fs, "/", link_dir);
618
619         normalize_slash(mp->am_link);
620       }
621     }
622
623     if (mf->mf_error > 0) {
624       this_error = mf->mf_error;
625     } else if (mf->mf_flags & (MFF_MOUNTING | MFF_UNMOUNTING)) {
626       /*
627        * Still mounting - retry later
628        */
629 #ifdef DEBUG
630       dlog("Duplicate pending mount fstype %s", p->fs_type);
631 #endif /* DEBUG */
632       this_error = -1;
633     } else if (FSRV_ISDOWN(mf->mf_server)) {
634       /*
635        * Would just mount from the same place
636        * as a hung mount - so give up
637        */
638 #ifdef DEBUG
639       dlog("%s is already hung - giving up", mf->mf_mount);
640 #endif /* DEBUG */
641       mp_error = EWOULDBLOCK;
642       dont_retry = TRUE;
643       this_error = -1;
644     } else if (mf->mf_flags & MFF_MOUNTED) {
645 #ifdef DEBUG
646       dlog("duplicate mount of \"%s\" ...", mf->mf_info);
647 #endif /* DEBUG */
648
649       /*
650        * Just call mounted()
651        */
652       am_mounted(mp);
653
654       this_error = 0;
655       break;
656     }
657
658     /*
659      * Will usually need to play around with the mount nodes
660      * file attribute structure.  This must be done here.
661      * Try and get things initialized, even if the fileserver
662      * is not known to be up.  In the common case this will
663      * progress things faster.
664      */
665     if (!this_error) {
666       /*
667        * Fill in attribute fields.
668        */
669       if (mf->mf_ops->fs_flags & FS_DIRECTORY)
670         mk_fattr(mp, NFDIR);
671       else
672         mk_fattr(mp, NFLNK);
673
674       mp->am_fattr.na_fileid = mp->am_gen;
675
676       if (p->fs_init)
677         this_error = (*p->fs_init) (mf);
678     }
679
680     /*
681      * Make sure the fileserver is UP before doing any more work
682      */
683     if (!FSRV_ISUP(mf->mf_server)) {
684 #ifdef DEBUG
685       dlog("waiting for server %s to become available", mf->mf_server->fs_host);
686 #endif /* DEBUG */
687       this_error = -1;
688     }
689
690     if (!this_error && mf->mf_fo->opt_delay) {
691       /*
692        * If there is a delay timer on the mount
693        * then don't try to mount if the timer
694        * has not expired.
695        */
696       int i = atoi(mf->mf_fo->opt_delay);
697       if (i > 0 && clocktime() < (cp->start + i)) {
698 #ifdef DEBUG
699         dlog("Mount of %s delayed by %lds", mf->mf_mount, (long) (i - clocktime() + cp->start));
700 #endif /* DEBUG */
701         this_error = -1;
702       }
703     }
704
705     if (this_error < 0 && !dont_retry) {
706       if (!mf_retry)
707         mf_retry = dup_mntfs(mf);
708       cp->retry = TRUE;
709 #ifdef DEBUG
710       dlog("will retry ...\n");
711 #endif /* DEBUG */
712       break;
713     }
714
715     if (!this_error) {
716       if (p->fs_flags & FS_MBACKGROUND) {
717         mf->mf_flags |= MFF_MOUNTING;   /* XXX */
718 #ifdef DEBUG
719         dlog("backgrounding mount of \"%s\"", mf->mf_mount);
720 #endif /* DEBUG */
721         if (cp->callout) {
722           untimeout(cp->callout);
723           cp->callout = 0;
724         }
725         run_task(try_mount, (voidp) mp, amfs_auto_cont, (voidp) cp);
726         mf->mf_flags |= MFF_MKMNT;      /* XXX */
727         if (mf_retry)
728           free_mntfs(mf_retry);
729         return -1;
730       } else {
731 #ifdef DEBUG
732         dlog("foreground mount of \"%s\" ...", mf->mf_info);
733 #endif /* DEBUG */
734         this_error = try_mount((voidp) mp);
735         if (this_error < 0) {
736           if (!mf_retry)
737             mf_retry = dup_mntfs(mf);
738           cp->retry = TRUE;
739         }
740       }
741     }
742
743     if (this_error >= 0) {
744       if (this_error > 0) {
745         amd_stats.d_merr++;
746         if (mf != mf_retry) {
747           mf->mf_error = this_error;
748           mf->mf_flags |= MFF_ERROR;
749         }
750       }
751
752       /*
753        * Wakeup anything waiting for this mount
754        */
755       wakeup((voidp) mf);
756     }
757   }
758
759   if (this_error && cp->retry) {
760     free_mntfs(mf);
761     mf = cp->mp->am_mnt = mf_retry;
762     /*
763      * Not retrying again (so far)
764      */
765     cp->retry = FALSE;
766     cp->tried = FALSE;
767     /*
768      * Start at the beginning.
769      * Rewind the location vector and
770      * reset the default options.
771      */
772 #ifdef DEBUG
773     dlog("(skipping rewind)\n");
774 #endif /* DEBUG */
775     /*
776      * Arrange that amfs_auto_bgmount is called
777      * after anything else happens.
778      */
779 #ifdef DEBUG
780     dlog("Arranging to retry mount of %s", cp->mp->am_path);
781 #endif /* DEBUG */
782     sched_task(amfs_auto_retry, (voidp) cp, (voidp) mf);
783     if (cp->callout)
784       untimeout(cp->callout);
785     cp->callout = timeout(RETRY_INTERVAL, wakeup, (voidp) mf);
786
787     cp->mp->am_ttl = clocktime() + RETRY_INTERVAL;
788
789     /*
790      * Not done yet - so don't return anything
791      */
792     return -1;
793   }
794
795   if (hard_error < 0 || this_error == 0)
796     hard_error = this_error;
797
798   /*
799    * Discard handle on duff filesystem.
800    * This should never happen since it
801    * should be caught by the case above.
802    */
803   if (mf_retry) {
804     if (hard_error)
805       plog(XLOG_ERROR, "discarding a retry mntfs for %s", mf_retry->mf_mount);
806     free_mntfs(mf_retry);
807   }
808
809   /*
810    * If we get here, then either the mount succeeded or
811    * there is no more mount information available.
812    */
813   if (hard_error < 0 && mp_error)
814     hard_error = cp->mp->am_error = mp_error;
815   if (hard_error > 0) {
816     /*
817      * Set a small(ish) timeout on an error node if
818      * the error was not a time out.
819      */
820     switch (hard_error) {
821     case ETIMEDOUT:
822     case EWOULDBLOCK:
823       cp->mp->am_timeo = 17;
824       break;
825     default:
826       cp->mp->am_timeo = 5;
827       break;
828     }
829     new_ttl(cp->mp);
830   }
831
832   /*
833    * Make sure that the error value in the mntfs has a
834    * reasonable value.
835    */
836   if (mf->mf_error < 0) {
837     mf->mf_error = hard_error;
838     if (hard_error)
839       mf->mf_flags |= MFF_ERROR;
840   }
841
842   /*
843    * In any case we don't need the continuation any more
844    */
845   free_continuation(cp);
846
847   return hard_error;
848 }
849
850
851 /*
852  * Automount interface to RPC lookup routine
853  * Find the corresponding entry and return
854  * the file handle for it.
855  */
856 am_node *
857 amfs_auto_lookuppn(am_node *mp, char *fname, int *error_return, int op)
858 {
859   am_node *ap, *new_mp, *ap_hung;
860   char *info;                   /* Mount info - where to get the file system */
861   char **ivec, **xivec;         /* Split version of info */
862   char *auto_opts;              /* Automount options */
863   int error = 0;                /* Error so far */
864   char path_name[MAXPATHLEN];   /* General path name buffer */
865   char *pfname;                 /* Path for database lookup */
866   struct continuation *cp;      /* Continuation structure if need to mount */
867   int in_progress = 0;          /* # of (un)mount in progress */
868   char *dflts;
869   mntfs *mf;
870
871 #ifdef DEBUG
872   dlog("in amfs_auto_lookuppn");
873 #endif /* DEBUG */
874
875   /*
876    * If the server is shutting down
877    * then don't return information
878    * about the mount point.
879    */
880   if (amd_state == Finishing) {
881 #ifdef DEBUG
882     if ((mf = mp->am_mnt) == 0 || mf->mf_ops == &amfs_direct_ops) {
883       dlog("%s mount ignored - going down", fname);
884     } else {
885       dlog("%s/%s mount ignored - going down", mp->am_path, fname);
886     }
887 #endif /* DEBUG */
888     ereturn(ENOENT);
889   }
890
891   /*
892    * Handle special case of "." and ".."
893    */
894   if (fname[0] == '.') {
895     if (fname[1] == '\0')
896       return mp;                /* "." is the current node */
897     if (fname[1] == '.' && fname[2] == '\0') {
898       if (mp->am_parent) {
899 #ifdef DEBUG
900         dlog(".. in %s gives %s", mp->am_path, mp->am_parent->am_path);
901 #endif /* DEBUG */
902         return mp->am_parent;   /* ".." is the parent node */
903       }
904       ereturn(ESTALE);
905     }
906   }
907
908   /*
909    * Check for valid key name.
910    * If it is invalid then pretend it doesn't exist.
911    */
912   if (!valid_key(fname)) {
913     plog(XLOG_WARNING, "Key \"%s\" contains a disallowed character", fname);
914     ereturn(ENOENT);
915   }
916
917   /*
918    * Expand key name.
919    * fname is now a private copy.
920    */
921   fname = expand_key(fname);
922
923   for (ap_hung = 0, ap = mp->am_child; ap; ap = ap->am_osib) {
924     /*
925      * Otherwise search children of this node
926      */
927     if (FSTREQ(ap->am_name, fname)) {
928       mf = ap->am_mnt;
929       if (ap->am_error) {
930         error = ap->am_error;
931         continue;
932       }
933       /*
934        * If the error code is undefined then it must be
935        * in progress.
936        */
937       if (mf->mf_error < 0)
938         goto in_progrss;
939
940       /*
941        * Check for a hung node
942        */
943       if (FSRV_ISDOWN(mf->mf_server)) {
944 #ifdef DEBUG
945         dlog("server hung");
946 #endif /* DEBUG */
947         error = ap->am_error;
948         ap_hung = ap;
949         continue;
950       }
951       /*
952        * If there was a previous error with this node
953        * then return that error code.
954        */
955       if (mf->mf_flags & MFF_ERROR) {
956         error = mf->mf_error;
957         continue;
958       }
959       if (!(mf->mf_flags & MFF_MOUNTED) || (mf->mf_flags & MFF_UNMOUNTING)) {
960       in_progrss:
961         /*
962          * If the fs is not mounted or it is unmounting then there
963          * is a background (un)mount in progress.  In this case
964          * we just drop the RPC request (return nil) and
965          * wait for a retry, by which time the (un)mount may
966          * have completed.
967          */
968 #ifdef DEBUG
969         dlog("ignoring mount of %s in %s -- flags (%x) in progress",
970              fname, mf->mf_mount, mf->mf_flags);
971 #endif /* DEBUG */
972         in_progress++;
973         continue;
974       }
975
976       /*
977        * Otherwise we have a hit: return the current mount point.
978        */
979 #ifdef DEBUG
980       dlog("matched %s in %s", fname, ap->am_path);
981 #endif /* DEBUG */
982       XFREE(fname);
983       return ap;
984     }
985   }
986
987   if (in_progress) {
988 #ifdef DEBUG
989     dlog("Waiting while %d mount(s) in progress", in_progress);
990 #endif /* DEBUG */
991     XFREE(fname);
992     ereturn(-1);
993   }
994
995   /*
996    * If an error occurred then return it.
997    */
998   if (error) {
999 #ifdef DEBUG
1000     errno = error;              /* XXX */
1001     dlog("Returning error: %m");
1002 #endif /* DEBUG */
1003     XFREE(fname);
1004     ereturn(error);
1005   }
1006
1007   /*
1008    * If doing a delete then don't create again!
1009    */
1010   switch (op) {
1011   case VLOOK_DELETE:
1012     ereturn(ENOENT);
1013
1014   case VLOOK_CREATE:
1015     break;
1016
1017   default:
1018     plog(XLOG_FATAL, "Unknown op to amfs_auto_lookuppn: 0x%x", op);
1019     ereturn(EINVAL);
1020   }
1021
1022   /*
1023    * If the server is going down then just return,
1024    * don't try to mount any more file systems
1025    */
1026   if ((int) amd_state >= (int) Finishing) {
1027 #ifdef DEBUG
1028     dlog("not found - server going down anyway");
1029 #endif /* DEBUG */
1030     XFREE(fname);
1031     ereturn(ENOENT);
1032   }
1033
1034   /*
1035    * If we get there then this is a reference to an,
1036    * as yet, unknown name so we need to search the mount
1037    * map for it.
1038    */
1039   if (mp->am_pref) {
1040     sprintf(path_name, "%s%s", mp->am_pref, fname);
1041     pfname = path_name;
1042   } else {
1043     pfname = fname;
1044   }
1045
1046   mf = mp->am_mnt;
1047
1048 #ifdef DEBUG
1049   dlog("will search map info in %s to find %s", mf->mf_info, pfname);
1050 #endif /* DEBUG */
1051   /*
1052    * Consult the oracle for some mount information.
1053    * info is malloc'ed and belongs to this routine.
1054    * It ends up being free'd in free_continuation().
1055    *
1056    * Note that this may return -1 indicating that information
1057    * is not yet available.
1058    */
1059   error = mapc_search((mnt_map *) mf->mf_private, pfname, &info);
1060   if (error) {
1061     if (error > 0)
1062       plog(XLOG_MAP, "No map entry for %s", pfname);
1063     else
1064       plog(XLOG_MAP, "Waiting on map entry for %s", pfname);
1065     XFREE(fname);
1066     ereturn(error);
1067   }
1068 #ifdef DEBUG
1069   dlog("mount info is %s", info);
1070 #endif /* DEBUG */
1071
1072   /*
1073    * Split info into an argument vector.
1074    * The vector is malloc'ed and belongs to
1075    * this routine.  It is free'd in free_continuation()
1076    */
1077   xivec = ivec = strsplit(info, ' ', '\"');
1078
1079   /*
1080    * Default error code...
1081    */
1082   if (ap_hung)
1083     error = EWOULDBLOCK;
1084   else
1085     error = ENOENT;
1086
1087   /*
1088    * Allocate a new map
1089    */
1090   new_mp = exported_ap_alloc();
1091   if (new_mp == 0) {
1092     XFREE(xivec);
1093     XFREE(info);
1094     XFREE(fname);
1095     ereturn(ENOSPC);
1096   }
1097   if (mf->mf_auto)
1098     auto_opts = mf->mf_auto;
1099   else
1100     auto_opts = "";
1101
1102   auto_opts = strdup(auto_opts);
1103
1104 #ifdef DEBUG
1105   dlog("searching for /defaults entry");
1106 #endif /* DEBUG */
1107   if (mapc_search((mnt_map *) mf->mf_private, "/defaults", &dflts) == 0) {
1108     char *dfl;
1109     char **rvec;
1110 #ifdef DEBUG
1111     dlog("/defaults gave %s", dflts);
1112 #endif /* DEBUG */
1113     if (*dflts == '-')
1114       dfl = dflts + 1;
1115     else
1116       dfl = dflts;
1117
1118     /*
1119      * Chop the defaults up
1120      */
1121     rvec = strsplit(dfl, ' ', '\"');
1122
1123     if (gopt.flags & CFM_ENABLE_DEFAULT_SELECTORS) {
1124       /*
1125        * Pick whichever first entry matched the list of selectors.
1126        * Strip the selectors from the string, and assign to dfl the
1127        * rest of the string.
1128        */
1129       if (rvec) {
1130         am_opts ap;
1131         am_ops *pt;
1132         char **sp = rvec;
1133         while (*sp) {           /* loop until you find something, if any */
1134           memset((char *) &ap, 0, sizeof(am_opts));
1135           pt = ops_match(&ap, *sp, "", mp->am_path, "/defaults",
1136                          mp->am_parent->am_mnt->mf_info);
1137           free_opts(&ap);       /* don't leak */
1138           if (pt == &amfs_error_ops) {
1139             plog(XLOG_MAP, "failed to match defaults for \"%s\"", *sp);
1140           } else {
1141             dfl = strip_selectors(*sp, "/defaults");
1142             plog(XLOG_MAP, "matched default selectors \"%s\"", dfl);
1143             break;
1144           }
1145           ++sp;
1146         }
1147       }
1148     } else {                    /* not enable_default_selectors */
1149       /*
1150        * Extract first value
1151        */
1152       dfl = rvec[0];
1153     }
1154
1155     /*
1156      * If there were any values at all...
1157      */
1158     if (dfl) {
1159       /*
1160        * Log error if there were other values
1161        */
1162       if (!(gopt.flags & CFM_ENABLE_DEFAULT_SELECTORS) && rvec[1]) {
1163 # ifdef DEBUG
1164         dlog("/defaults chopped into %s", dfl);
1165 # endif /* DEBUG */
1166         plog(XLOG_USER, "More than a single value for /defaults in %s", mf->mf_info);
1167       }
1168
1169       /*
1170        * Prepend to existing defaults if they exist,
1171        * otherwise just use these defaults.
1172        */
1173       if (*auto_opts && *dfl) {
1174         char *nopts = (char *) xmalloc(strlen(auto_opts) + strlen(dfl) + 2);
1175         sprintf(nopts, "%s;%s", dfl, auto_opts);
1176         XFREE(auto_opts);
1177         auto_opts = nopts;
1178       } else if (*dfl) {
1179         auto_opts = strealloc(auto_opts, dfl);
1180       }
1181     }
1182     XFREE(dflts);
1183     /*
1184      * Don't need info vector any more
1185      */
1186     XFREE(rvec);
1187   }
1188
1189   /*
1190    * Fill it in
1191    */
1192   init_map(new_mp, fname);
1193
1194   /*
1195    * Put it in the table
1196    */
1197   insert_am(new_mp, mp);
1198
1199   /*
1200    * Fill in some other fields,
1201    * path and mount point.
1202    *
1203    * bugfix: do not prepend old am_path if direct map
1204    *         <wls@astro.umd.edu> William Sebok
1205    */
1206   new_mp->am_path = str3cat(new_mp->am_path,
1207                             mf->mf_ops == &amfs_direct_ops ? "" : mp->am_path,
1208                             *fname == '/' ? "" : "/", fname);
1209
1210 #ifdef DEBUG
1211   dlog("setting path to %s", new_mp->am_path);
1212 #endif /* DEBUG */
1213
1214   /*
1215    * Take private copy of pfname
1216    */
1217   pfname = strdup(pfname);
1218
1219   /*
1220    * Construct a continuation
1221    */
1222   cp = ALLOC(struct continuation);
1223   cp->callout = 0;
1224   cp->mp = new_mp;
1225   cp->xivec = xivec;
1226   cp->ivec = ivec;
1227   cp->info = info;
1228   cp->key = pfname;
1229   cp->auto_opts = auto_opts;
1230   cp->retry = FALSE;
1231   cp->tried = FALSE;
1232   cp->start = clocktime();
1233   cp->def_opts = strdup(auto_opts);
1234   memset((voidp) &cp->fs_opts, 0, sizeof(cp->fs_opts));
1235
1236   /*
1237    * Try and mount the file system.  If this succeeds immediately (possible
1238    * for a ufs file system) then return the attributes, otherwise just
1239    * return an error.
1240    */
1241   error = amfs_auto_bgmount(cp, error);
1242   reschedule_timeout_mp();
1243   if (!error) {
1244     XFREE(fname);
1245     return new_mp;
1246   }
1247
1248   /*
1249    * Code for quick reply.  If nfs_program_2_transp is set, then
1250    * its the transp that's been passed down from nfs_program_2().
1251    * If new_mp->am_transp is not already set, set it by copying in
1252    * nfs_program_2_transp.  Once am_transp is set, quick_reply() can
1253    * use it to send a reply to the client that requested this mount.
1254    */
1255   if (nfs_program_2_transp && !new_mp->am_transp) {
1256     new_mp->am_transp = (SVCXPRT *) xmalloc(sizeof(SVCXPRT));
1257     *(new_mp->am_transp) = *nfs_program_2_transp;
1258   }
1259   if (error && (new_mp->am_mnt->mf_ops == &amfs_error_ops))
1260     new_mp->am_error = error;
1261
1262   assign_error_mntfs(new_mp);
1263
1264   XFREE(fname);
1265
1266   ereturn(error);
1267 }
1268
1269
1270 /*
1271  * Locate next node in sibling list which is mounted
1272  * and is not an error node.
1273  */
1274 am_node *
1275 next_nonerror_node(am_node *xp)
1276 {
1277   mntfs *mf;
1278
1279   /*
1280    * Bug report (7/12/89) from Rein Tollevik <rein@ifi.uio.no>
1281    * Fixes a race condition when mounting direct automounts.
1282    * Also fixes a problem when doing a readdir on a directory
1283    * containing hung automounts.
1284    */
1285   while (xp &&
1286          (!(mf = xp->am_mnt) || /* No mounted filesystem */
1287           mf->mf_error != 0 ||  /* There was a mntfs error */
1288           xp->am_error != 0 ||  /* There was a mount error */
1289           !(mf->mf_flags & MFF_MOUNTED) ||      /* The fs is not mounted */
1290           (mf->mf_server->fs_flags & FSF_DOWN)) /* The fs may be down */
1291          )
1292     xp = xp->am_osib;
1293
1294   return xp;
1295 }
1296
1297
1298 /*
1299  * This readdir function which call a special version of it that allows
1300  * browsing if browsable_dirs=yes was set on the map.
1301  */
1302 int
1303 amfs_auto_readdir(am_node *mp, nfscookie cookie, nfsdirlist *dp, nfsentry *ep, int count)
1304 {
1305   u_int gen = *(u_int *) cookie;
1306   am_node *xp;
1307   mntent_t mnt;
1308
1309   dp->dl_eof = FALSE;           /* assume readdir not done */
1310
1311   /* check if map is browsable */
1312   if (mp->am_mnt && mp->am_mnt->mf_mopts) {
1313     mnt.mnt_opts = mp->am_mnt->mf_mopts;
1314     if (hasmntopt(&mnt, "fullybrowsable"))
1315       return amfs_auto_readdir_browsable(mp, cookie, dp, ep, count, TRUE);
1316     if (hasmntopt(&mnt, "browsable"))
1317       return amfs_auto_readdir_browsable(mp, cookie, dp, ep, count, FALSE);
1318   }
1319
1320   if (gen == 0) {
1321     /*
1322      * In the default instance (which is used to start a search) we return
1323      * "." and "..".
1324      *
1325      * This assumes that the count is big enough to allow both "." and ".."
1326      * to be returned in a single packet.  If it isn't (which would be
1327      * fairly unbelievable) then tough.
1328      */
1329 #ifdef DEBUG
1330     dlog("amfs_auto_readdir: default search");
1331 #endif /* DEBUG */
1332     /*
1333      * Check for enough room.  This is extremely approximate but is more
1334      * than enough space.  Really need 2 times:
1335      *      4byte fileid
1336      *      4byte cookie
1337      *      4byte name length
1338      *      4byte name
1339      * plus the dirlist structure */
1340     if (count < (2 * (2 * (sizeof(*ep) + sizeof("..") + 4) + sizeof(*dp))))
1341       return EINVAL;
1342
1343     xp = next_nonerror_node(mp->am_child);
1344     dp->dl_entries = ep;
1345
1346     /* construct "." */
1347     ep[0].ne_fileid = mp->am_gen;
1348     ep[0].ne_name = ".";
1349     ep[0].ne_nextentry = &ep[1];
1350     *(u_int *) ep[0].ne_cookie = 0;
1351
1352     /* construct ".." */
1353     if (mp->am_parent)
1354       ep[1].ne_fileid = mp->am_parent->am_gen;
1355     else
1356       ep[1].ne_fileid = mp->am_gen;
1357     ep[1].ne_name = "..";
1358     ep[1].ne_nextentry = 0;
1359     *(u_int *) ep[1].ne_cookie = (xp ? xp->am_gen : DOT_DOT_COOKIE);
1360
1361     if (!xp)
1362       dp->dl_eof = TRUE;        /* by default assume readdir done */
1363
1364     return 0;
1365   }
1366 #ifdef DEBUG
1367   dlog("amfs_auto_readdir: real child");
1368 #endif /* DEBUG */
1369
1370   if (gen == DOT_DOT_COOKIE) {
1371 #ifdef DEBUG
1372     dlog("amfs_auto_readdir: End of readdir in %s", mp->am_path);
1373 #endif /* DEBUG */
1374     dp->dl_eof = TRUE;
1375     dp->dl_entries = 0;
1376     return 0;
1377   }
1378
1379   /* non-browsable directories code */
1380   xp = mp->am_child;
1381   while (xp && xp->am_gen != gen)
1382     xp = xp->am_osib;
1383
1384   if (xp) {
1385     int nbytes = count / 2;     /* conservative */
1386     int todo = MAX_READDIR_ENTRIES;
1387
1388     dp->dl_entries = ep;
1389     do {
1390       am_node *xp_next = next_nonerror_node(xp->am_osib);
1391
1392       if (xp_next) {
1393         *(u_int *) ep->ne_cookie = xp_next->am_gen;
1394       } else {
1395         *(u_int *) ep->ne_cookie = DOT_DOT_COOKIE;
1396         dp->dl_eof = TRUE;
1397       }
1398
1399       ep->ne_fileid = xp->am_gen;
1400       ep->ne_name = xp->am_name;
1401       nbytes -= sizeof(*ep) + 1;
1402       if (xp->am_name)
1403         nbytes -= strlen(xp->am_name);
1404
1405       xp = xp_next;
1406
1407       if (nbytes > 0 && !dp->dl_eof && todo > 1) {
1408         ep->ne_nextentry = ep + 1;
1409         ep++;
1410         --todo;
1411       } else {
1412         todo = 0;
1413       }
1414     } while (todo > 0);
1415
1416     ep->ne_nextentry = 0;
1417
1418     return 0;
1419   }
1420   return ESTALE;
1421 }
1422
1423
1424 /* This one is called only if map is browsable */
1425 static int
1426 amfs_auto_readdir_browsable(am_node *mp, nfscookie cookie, nfsdirlist *dp, nfsentry *ep, int count, int fully_browsable)
1427 {
1428   u_int gen = *(u_int *) cookie;
1429   int chain_length, i;
1430   static nfsentry *te, *te_next;
1431 #ifdef DEBUG_READDIR
1432   nfsentry *ne;
1433   static int j;
1434 #endif /* DEBUG_READDIR */
1435
1436   dp->dl_eof = FALSE;           /* assume readdir not done */
1437
1438 #ifdef DEBUG_READDIR
1439   plog(XLOG_INFO, "amfs_auto_readdir_browsable gen=%u, count=%d",
1440        gen, count);
1441 #endif /* DEBUG_READDIR */
1442
1443   if (gen == 0) {
1444     /*
1445      * In the default instance (which is used to start a search) we return
1446      * "." and "..".
1447      *
1448      * This assumes that the count is big enough to allow both "." and ".."
1449      * to be returned in a single packet.  If it isn't (which would be
1450      * fairly unbelievable) then tough.
1451      */
1452 #ifdef DEBUG
1453     dlog("amfs_auto_readdir_browsable: default search");
1454 #endif /* DEBUG */
1455     /*
1456      * Check for enough room.  This is extremely approximate but is more
1457      * than enough space.  Really need 2 times:
1458      *      4byte fileid
1459      *      4byte cookie
1460      *      4byte name length
1461      *      4byte name
1462      * plus the dirlist structure */
1463     if (count < (2 * (2 * (sizeof(*ep) + sizeof("..") + 4) + sizeof(*dp))))
1464       return EINVAL;
1465
1466     /*
1467      * compute # of entries to send in this chain.
1468      * heuristics: 128 bytes per entry.
1469      * This is too much probably, but it seems to work better because
1470      * of the re-entrant nature of nfs_readdir, and esp. on systems
1471      * like OpenBSD 2.2.
1472      */
1473     chain_length = count / 128;
1474
1475     /* reset static state counters */
1476     te = te_next = NULL;
1477
1478     dp->dl_entries = ep;
1479
1480     /* construct "." */
1481     ep[0].ne_fileid = mp->am_gen;
1482     ep[0].ne_name = ".";
1483     ep[0].ne_nextentry = &ep[1];
1484     *(u_int *) ep[0].ne_cookie = 0;
1485
1486     /* construct ".." */
1487     if (mp->am_parent)
1488       ep[1].ne_fileid = mp->am_parent->am_gen;
1489     else
1490       ep[1].ne_fileid = mp->am_gen;
1491     ep[1].ne_name = "..";
1492     ep[1].ne_nextentry = 0;
1493     *(u_int *) ep[1].ne_cookie = DOT_DOT_COOKIE;
1494
1495     /*
1496      * If map is browsable, call a function make_entry_chain() to construct
1497      * a linked list of unmounted keys, and return it.  Then link the chain
1498      * to the regular list.  Get the chain only once, but return
1499      * chunks of it each time.
1500      */
1501     te = make_entry_chain(mp, dp->dl_entries, fully_browsable);
1502     if (!te)
1503       return 0;
1504 #ifdef DEBUG_READDIR
1505     for (j=0,ne=te; ne; ne=ne->ne_nextentry)
1506       plog(XLOG_INFO, "gen1 key %4d \"%s\"", j++, ne->ne_name);
1507 #endif /* DEBUG_READDIR */
1508
1509     /* return only "chain_length" entries */
1510     te_next = te;
1511     for (i=1; i<chain_length; ++i) {
1512       te_next = te_next->ne_nextentry;
1513       if (!te_next)
1514         break;
1515     }
1516     if (te_next) {
1517       nfsentry *te_saved = te_next->ne_nextentry;
1518       te_next->ne_nextentry = NULL; /* terminate "te" chain */
1519       te_next = te_saved;       /* save rest of "te" for next iteration */
1520       dp->dl_eof = FALSE;       /* tell readdir there's more */
1521     } else {
1522       dp->dl_eof = TRUE;        /* tell readdir that's it */
1523     }
1524     ep[1].ne_nextentry = te;    /* append this chunk of "te" chain */
1525 #ifdef DEBUG_READDIR
1526     for (j=0,ne=te; ne; ne=ne->ne_nextentry)
1527       plog(XLOG_INFO, "gen2 key %4d \"%s\"", j++, ne->ne_name);
1528     for (j=0,ne=ep; ne; ne=ne->ne_nextentry)
1529       plog(XLOG_INFO, "gen2+ key %4d \"%s\" fi=%d ck=%d",
1530            j++, ne->ne_name, ne->ne_fileid, *(u_int *)ne->ne_cookie);
1531     plog(XLOG_INFO, "EOF is %d", dp->dl_eof);
1532 #endif /* DEBUG_READDIR */
1533     return 0;
1534   } /* end of "if (gen == 0)" statement */
1535
1536 #ifdef DEBUG
1537   dlog("amfs_auto_readdir_browsable: real child");
1538 #endif /* DEBUG */
1539
1540   if (gen == DOT_DOT_COOKIE) {
1541 #ifdef DEBUG
1542     dlog("amfs_auto_readdir_browsable: End of readdir in %s", mp->am_path);
1543 #endif /* DEBUG */
1544     dp->dl_eof = TRUE;
1545     dp->dl_entries = 0;
1546     return 0;
1547   }
1548
1549   /*
1550    * If browsable directories, then continue serving readdir() with another
1551    * chunk of entries, starting from where we left off (when gen was equal
1552    * to 0).  Once again, assume last chunk served to readdir.
1553    */
1554   dp->dl_eof = TRUE;
1555   dp->dl_entries = ep;
1556
1557   te = te_next;                 /* reset 'te' from last saved te_next */
1558   if (!te) {                    /* another indicator of end of readdir */
1559     dp->dl_entries = 0;
1560     return 0;
1561   }
1562   /*
1563    * compute # of entries to send in this chain.
1564    * heuristics: 128 bytes per entry.
1565    */
1566   chain_length = count / 128;
1567
1568   /* return only "chain_length" entries */
1569   for (i=1; i<chain_length; ++i) {
1570     te_next = te_next->ne_nextentry;
1571     if (!te_next)
1572       break;
1573   }
1574   if (te_next) {
1575     nfsentry *te_saved = te_next->ne_nextentry;
1576     te_next->ne_nextentry = NULL; /* terminate "te" chain */
1577     te_next = te_saved;         /* save rest of "te" for next iteration */
1578     dp->dl_eof = FALSE;         /* tell readdir there's more */
1579   }
1580   ep = te;                      /* send next chunk of "te" chain */
1581   dp->dl_entries = ep;
1582 #ifdef DEBUG_READDIR
1583   plog(XLOG_INFO, "dl_entries=0x%x, te_next=0x%x, dl_eof=%d",
1584        (int) dp->dl_entries, (int) te_next, dp->dl_eof);
1585   for (ne=te; ne; ne=ne->ne_nextentry)
1586     plog(XLOG_INFO, "gen3 key %4d \"%s\"", j++, ne->ne_name);
1587 #endif /* DEBUG_READDIR */
1588   return 0;
1589 }
1590
1591
1592 int
1593 amfs_auto_fmount(am_node *mp)
1594 {
1595   mntfs *mf = mp->am_mnt;
1596   return (*mf->mf_ops->fmount_fs) (mf);
1597 }
1598
1599
1600 int
1601 amfs_auto_fumount(am_node *mp)
1602 {
1603   mntfs *mf = mp->am_mnt;
1604   return (*mf->mf_ops->fumount_fs) (mf);
1605 }