Merge branch 'vendor/NCURSES'
[dragonfly.git] / contrib / amd / amd / amfs_nfsx.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_nfsx.c,v 1.2 1999/01/10 21:53:42 ezk Exp $
42  *
43  */
44
45 /*
46  * NFS hierarchical mounts
47  *
48  * TODO: Re-implement.
49  */
50
51 #ifdef HAVE_CONFIG_H
52 # include <config.h>
53 #endif /* HAVE_CONFIG_H */
54 #include <am_defs.h>
55 #include <amd.h>
56
57 /*
58  * The rfs field contains a list of mounts to be done from
59  * the remote host.
60  */
61 typedef struct amfs_nfsx_mnt {
62   mntfs *n_mnt;
63   int n_error;
64 } amfs_nfsx_mnt;
65
66 struct amfs_nfsx {
67   int nx_c;                     /* Number of elements in nx_v */
68   amfs_nfsx_mnt *nx_v;          /* Underlying mounts */
69   amfs_nfsx_mnt *nx_try;
70 };
71
72 /* forward definitions */
73 static char *amfs_nfsx_match(am_opts *fo);
74 static int amfs_nfsx_fmount (mntfs *);
75 static int amfs_nfsx_fmount(mntfs *mf);
76 static int amfs_nfsx_fumount(mntfs *mf);
77 static int amfs_nfsx_init(mntfs *mf);
78
79 /*
80  * Ops structure
81  */
82 am_ops amfs_nfsx_ops =
83 {
84   "nfsx",
85   amfs_nfsx_match,
86   amfs_nfsx_init,
87   amfs_auto_fmount,
88   amfs_nfsx_fmount,
89   amfs_auto_fumount,
90   amfs_nfsx_fumount,
91   amfs_error_lookuppn,
92   amfs_error_readdir,
93   0,                            /* amfs_nfsx_readlink */
94   0,                            /* amfs_nfsx_mounted */
95   0,                            /* amfs_nfsx_umounted */
96   find_nfs_srvr,                /* XXX */
97         /* FS_UBACKGROUND| */ FS_AMQINFO
98 };
99
100
101 static char *
102 amfs_nfsx_match(am_opts *fo)
103 {
104   char *xmtab;
105   char *ptr;
106   int len;
107
108   if (!fo->opt_rfs) {
109     plog(XLOG_USER, "amfs_nfsx: no remote filesystem specified");
110     return FALSE;
111   }
112
113   if (!fo->opt_rhost) {
114     plog(XLOG_USER, "amfs_nfsx: no remote host specified");
115     return FALSE;
116   }
117
118   /* set default sublink */
119   if (fo->opt_sublink == 0) {
120     ptr = strchr(fo->opt_rfs, ',');
121     if (ptr && ptr != (fo->opt_rfs + 1))
122       fo->opt_sublink = strnsave(fo->opt_rfs + 1, ptr - fo->opt_rfs - 1);
123   }
124
125   /*
126    * Remove trailing ",..." from ${fs}
127    * After deslashifying, overwrite the end of ${fs} with "/"
128    * to make sure it is unique.
129    */
130   if ((ptr = strchr(fo->opt_fs, ',')))
131     *ptr = '\0';
132   deslashify(fo->opt_fs);
133
134   /*
135    * Bump string length to allow trailing /
136    */
137   len = strlen(fo->opt_fs);
138   fo->opt_fs = xrealloc(fo->opt_fs, len + 1 + 1);
139   ptr = fo->opt_fs + len;
140
141   /*
142    * Make unique...
143    */
144   *ptr++ = '/';
145   *ptr = '\0';
146
147   /*
148    * Determine magic cookie to put in mtab
149    */
150   xmtab = str3cat((char *) 0, fo->opt_rhost, ":", fo->opt_rfs);
151 #ifdef DEBUG
152   dlog("NFS: mounting remote server \"%s\", remote fs \"%s\" on \"%s\"",
153        fo->opt_rhost, fo->opt_rfs, fo->opt_fs);
154 #endif /* DEBUG */
155
156   return xmtab;
157 }
158
159
160 static void
161 amfs_nfsx_prfree(voidp vp)
162 {
163   struct amfs_nfsx *nx = (struct amfs_nfsx *) vp;
164   int i;
165
166   for (i = 0; i < nx->nx_c; i++) {
167     mntfs *m = nx->nx_v[i].n_mnt;
168     if (m)
169       free_mntfs(m);
170   }
171
172   XFREE(nx->nx_v);
173   XFREE(nx);
174 }
175
176
177 static int
178 amfs_nfsx_init(mntfs *mf)
179 {
180   /*
181    * mf_info has the form:
182    *   host:/prefix/path,sub,sub,sub
183    */
184   int i;
185   int glob_error;
186   struct amfs_nfsx *nx;
187   int asked_for_wakeup = 0;
188
189   nx = (struct amfs_nfsx *) mf->mf_private;
190
191   if (nx == 0) {
192     char **ivec;
193     char *info = 0;
194     char *host;
195     char *pref;
196     int error = 0;
197
198     info = strdup(mf->mf_info);
199     host = strchr(info, ':');
200     if (!host) {
201       error = EINVAL;
202       goto errexit;
203     }
204     pref = host +1;
205     host = info;
206
207     /*
208      * Split the prefix off from the suffices
209      */
210     ivec = strsplit(pref, ',', '\'');
211
212     /*
213      * Count array size
214      */
215     for (i = 0; ivec[i]; i++) ;
216
217     nx = ALLOC(struct amfs_nfsx);
218     mf->mf_private = (voidp) nx;
219     mf->mf_prfree = amfs_nfsx_prfree;
220
221     nx->nx_c = i - 1;           /* i-1 because we don't want the prefix */
222     nx->nx_v = (amfs_nfsx_mnt *) xmalloc(nx->nx_c * sizeof(amfs_nfsx_mnt));
223     {
224       char *mp = 0;
225       char *xinfo = 0;
226       char *fs = mf->mf_fo->opt_fs;
227       char *rfs = 0;
228       for (i = 0; i < nx->nx_c; i++) {
229         char *path = ivec[i + 1];
230         rfs = str3cat(rfs, pref, "/", path);
231         /*
232          * Determine the mount point.
233          * If this is the root, then don't remove
234          * the trailing slash to avoid mntfs name clashes.
235          */
236         mp = str3cat(mp, fs, "/", rfs);
237         normalize_slash(mp);
238         deslashify(mp);
239         /*
240          * Determine the mount info
241          */
242         xinfo = str3cat(xinfo, host, *path == '/' ? "" : "/", path);
243         normalize_slash(xinfo);
244         if (pref[1] != '\0')
245           deslashify(xinfo);
246 #ifdef DEBUG
247         dlog("amfs_nfsx: init mount for %s on %s", xinfo, mp);
248 #endif /* DEBUG */
249         nx->nx_v[i].n_error = -1;
250         nx->nx_v[i].n_mnt = find_mntfs(&nfs_ops, mf->mf_fo, mp, xinfo, "", mf->mf_mopts, mf->mf_remopts);
251       }
252       if (rfs)
253         XFREE(rfs);
254       if (mp)
255         XFREE(mp);
256       if (xinfo)
257         XFREE(xinfo);
258     }
259
260     XFREE(ivec);
261   errexit:
262     if (info)
263       XFREE(info);
264     if (error)
265       return error;
266   }
267
268   /*
269    * Iterate through the mntfs's and call
270    * the underlying init routine on each
271    */
272   glob_error = 0;
273
274   for (i = 0; i < nx->nx_c; i++) {
275     amfs_nfsx_mnt *n = &nx->nx_v[i];
276     mntfs *m = n->n_mnt;
277     int error = (*m->mf_ops->fs_init) (m);
278     /*
279      * if you just "return error" here, you will have made a failure
280      * in any submounts to fail the whole group.  There was old unused code
281      * here before.
282      */
283     if (error > 0)
284       n->n_error = error;
285
286     else if (error < 0) {
287       glob_error = -1;
288       if (!asked_for_wakeup) {
289         asked_for_wakeup = 1;
290         sched_task(wakeup_task, (voidp) mf, (voidp) m);
291       }
292     }
293   }
294
295   return glob_error;
296 }
297
298
299 static void
300 amfs_nfsx_cont(int rc, int term, voidp closure)
301 {
302   mntfs *mf = (mntfs *) closure;
303   struct amfs_nfsx *nx = (struct amfs_nfsx *) mf->mf_private;
304   amfs_nfsx_mnt *n = nx->nx_try;
305
306   n->n_mnt->mf_flags &= ~(MFF_ERROR | MFF_MOUNTING);
307   mf->mf_flags &= ~MFF_ERROR;
308
309   /*
310    * Wakeup anything waiting for this mount
311    */
312   wakeup((voidp) n->n_mnt);
313
314   if (rc || term) {
315     if (term) {
316       /*
317        * Not sure what to do for an error code.
318        */
319       plog(XLOG_ERROR, "mount for %s got signal %d", n->n_mnt->mf_mount, term);
320       n->n_error = EIO;
321     } else {
322       /*
323        * Check for exit status
324        */
325       errno = rc;               /* XXX */
326       plog(XLOG_ERROR, "%s: mount (amfs_nfsx_cont): %m", n->n_mnt->mf_mount);
327       n->n_error = rc;
328     }
329     free_mntfs(n->n_mnt);
330     n->n_mnt = new_mntfs();
331     n->n_mnt->mf_error = n->n_error;
332     n->n_mnt->mf_flags |= MFF_ERROR;
333   } else {
334     /*
335      * The mount worked.
336      */
337     mf_mounted(n->n_mnt);
338     n->n_error = 0;
339   }
340
341   /*
342    * Do the remaining bits
343    */
344   if (amfs_nfsx_fmount(mf) >= 0) {
345     wakeup((voidp) mf);
346     mf->mf_flags &= ~MFF_MOUNTING;
347     mf_mounted(mf);
348   }
349 }
350
351
352 static int
353 try_amfs_nfsx_mount(voidp mv)
354 {
355   mntfs *mf = (mntfs *) mv;
356   int error;
357
358   mf->mf_flags |= MFF_MOUNTING;
359   error = (*mf->mf_ops->fmount_fs) (mf);
360   mf->mf_flags &= ~MFF_MOUNTING;
361
362   return error;
363 }
364
365
366 static int
367 amfs_nfsx_remount(mntfs *mf, int fg)
368 {
369   struct amfs_nfsx *nx = (struct amfs_nfsx *) mf->mf_private;
370   amfs_nfsx_mnt *n;
371   int glob_error = -1;
372
373   for (n = nx->nx_v; n < nx->nx_v + nx->nx_c; n++) {
374     mntfs *m = n->n_mnt;
375     if (n->n_error < 0) {
376       if (!(m->mf_flags & MFF_MKMNT) && m->mf_ops->fs_flags & FS_MKMNT) {
377         int error = mkdirs(m->mf_mount, 0555);
378         if (!error)
379           m->mf_flags |= MFF_MKMNT;
380       }
381     }
382   }
383
384   /*
385    * Iterate through the mntfs's and mount each filesystem
386    * which is not yet mounted.
387    */
388   for (n = nx->nx_v; n < nx->nx_v + nx->nx_c; n++) {
389     mntfs *m = n->n_mnt;
390     if (n->n_error < 0) {
391       /*
392        * Check fmount entry pt. exists
393        * and then mount...
394        */
395       if (!m->mf_ops->fmount_fs) {
396         n->n_error = EINVAL;
397       } else {
398 #ifdef DEBUG
399         dlog("calling underlying fmount on %s", m->mf_mount);
400 #endif /* DEBUG */
401         if (!fg && foreground && (m->mf_ops->fs_flags & FS_MBACKGROUND)) {
402           m->mf_flags |= MFF_MOUNTING;  /* XXX */
403 #ifdef DEBUG
404           dlog("backgrounding mount of \"%s\"", m->mf_info);
405 #endif /* DEBUG */
406           nx->nx_try = n;
407           run_task(try_amfs_nfsx_mount, (voidp) m, amfs_nfsx_cont, (voidp) mf);
408           n->n_error = -1;
409           return -1;
410         } else {
411 #ifdef DEBUG
412           dlog("foreground mount of \"%s\" ...", mf->mf_info);
413 #endif /* DEBUG */
414           n->n_error = (*m->mf_ops->fmount_fs) (m);
415         }
416       }
417
418 #ifdef DEBUG
419       if (n->n_error > 0) {
420         errno = n->n_error;     /* XXX */
421         dlog("underlying fmount of %s failed: %m", m->mf_mount);
422       }
423 #endif /* DEBUG */
424
425       if (n->n_error == 0) {
426         glob_error = 0;
427       } else if (glob_error < 0) {
428         glob_error = n->n_error;
429       }
430     }
431   }
432
433   return glob_error < 0 ? 0 : glob_error;
434 }
435
436
437 static int
438 amfs_nfsx_fmount(mntfs *mf)
439 {
440   return amfs_nfsx_remount(mf, FALSE);
441 }
442
443
444 /*
445  * Unmount an NFS hierarchy.
446  * Note that this is called in the foreground
447  * and so may hang under extremely rare conditions.
448  */
449 static int
450 amfs_nfsx_fumount(mntfs *mf)
451 {
452   struct amfs_nfsx *nx = (struct amfs_nfsx *) mf->mf_private;
453   amfs_nfsx_mnt *n;
454   int glob_error = 0;
455
456   /*
457    * Iterate in reverse through the mntfs's and unmount each filesystem
458    * which is mounted.
459    */
460   for (n = nx->nx_v + nx->nx_c - 1; n >= nx->nx_v; --n) {
461     mntfs *m = n->n_mnt;
462     /*
463      * If this node has not been messed with
464      * and there has been no error so far
465      * then try and unmount.
466      * If an error had occurred then zero
467      * the error code so that the remount
468      * only tries to unmount those nodes
469      * which had been successfully unmounted.
470      */
471     if (n->n_error == 0) {
472 #ifdef DEBUG
473       dlog("calling underlying fumount on %s", m->mf_mount);
474 #endif /* DEBUG */
475       n->n_error = (*m->mf_ops->fumount_fs) (m);
476       if (n->n_error) {
477         glob_error = n->n_error;
478         n->n_error = 0;
479       } else {
480         /*
481          * Make sure remount gets this node
482          */
483         n->n_error = -1;
484       }
485     }
486   }
487
488   /*
489    * If any unmounts failed then remount the
490    * whole lot...
491    */
492   if (glob_error) {
493     glob_error = amfs_nfsx_remount(mf, TRUE);
494     if (glob_error) {
495       errno = glob_error;       /* XXX */
496       plog(XLOG_USER, "amfs_nfsx: remount of %s failed: %m", mf->mf_mount);
497     }
498     glob_error = EBUSY;
499   } else {
500     /*
501      * Remove all the mount points
502      */
503     for (n = nx->nx_v; n < nx->nx_v + nx->nx_c; n++) {
504       mntfs *m = n->n_mnt;
505       am_node am;
506
507       /*
508        * XXX: all the umounted handler needs is a
509        * mntfs pointer, so pass an am_node with the right
510        * pointer in it.
511        */
512       memset((voidp) &am, 0, sizeof(am));
513       am.am_mnt = m;
514 #ifdef DEBUG
515       dlog("calling underlying umounted on %s", m->mf_mount);
516 #endif /* DEBUG */
517       (*m->mf_ops->umounted) (&am);
518
519       if (n->n_error < 0) {
520         if (m->mf_ops->fs_flags & FS_MKMNT) {
521           (void) rmdirs(m->mf_mount);
522           m->mf_flags &= ~MFF_MKMNT;
523         }
524       }
525       free_mntfs(m);
526       n->n_mnt = 0;
527       n->n_error = -1;
528     }
529   }
530
531   return glob_error;
532 }