afs: clarify cold and warm shutdown logic
[openafs.git] / src / afs / NBSD / osi_vfsops.c
1 /*
2  * OpenBSD specific assistance routines & VFS ops
3  * Original NetBSD version for Transarc afs by John Kohl <jtk@MIT.EDU>
4  * OpenBSD version by Jim Rees <rees@umich.edu>
5  * Reported to NetBSD 4.0 by Matt Benjamin (matt@linuxbox.com)
6  *
7  * $Id: osi_vfsops.c,v 1.20 2005/03/08 21:58:04 shadow Exp $
8  */
9
10 /*
11 copyright 2002
12 the regents of the university of michigan
13 all rights reserved
14
15 permission is granted to use, copy, create derivative works
16 and redistribute this software and such derivative works
17 for any purpose, so long as the name of the university of
18 michigan is not used in any advertising or publicity
19 pertaining to the use or distribution of this software
20 without specific, written prior authorization.  if the
21 above copyright notice or any other identification of the
22 university of michigan is included in any copy of any
23 portion of this software, then the disclaimer below must
24 also be included.
25
26 this software is provided as is, without representation
27 from the university of michigan as to its fitness for any
28 purpose, and without warranty by the university of
29 michigan of any kind, either express or implied, including
30 without limitation the implied warranties of
31 merchantability and fitness for a particular purpose. the
32 regents of the university of michigan shall not be liable
33 for any damages, including special, indirect, incidental, or
34 consequential damages, with respect to any claim arising
35 out of or in connection with the use of the software, even
36 if it has been or is hereafter advised of the possibility of
37 such damages.
38 */
39
40 /*
41 Copyright 1995 Massachusetts Institute of Technology.  All Rights
42 Reserved.
43
44 You are hereby granted a worldwide, irrevocable, paid-up, right and
45 license to use, execute, display, modify, copy and distribute MIT's
46 Modifications, provided that (i) you abide by the terms and conditions
47 of the OpenAFS License Agreement, and (ii) you do not use the name
48 of MIT in any advertising or publicity without the prior written consent
49 of MIT.  MIT disclaims all liability for your use of MIT's
50 Modifications.  MIT's Modifications are provided "AS IS" WITHOUT
51 WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO,
52 ANY WARRANTY OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR
53 NONINFRINGEMENT.
54 */
55
56 /*
57  * Some code cribbed from ffs_vfsops and other NetBSD sources, which
58  * are marked:
59  */
60 /*
61  * Copyright (c) 1989, 1991, 1993, 1994
62  *      The Regents of the University of California.  All rights reserved.
63  *
64  * Redistribution and use in source and binary forms, with or without
65  * modification, are permitted provided that the following conditions
66  * are met:
67  * 1. Redistributions of source code must retain the above copyright
68  *    notice, this list of conditions and the following disclaimer.
69  * 2. Redistributions in binary form must reproduce the above copyright
70  *    notice, this list of conditions and the following disclaimer in the
71  *    documentation and/or other materials provided with the distribution.
72  * 3. All advertising materials mentioning features or use of this software
73  *    must display the following acknowledgement:
74  *      This product includes software developed by the University of
75  *      California, Berkeley and its contributors.
76  * 4. Neither the name of the University nor the names of its contributors
77  *    may be used to endorse or promote products derived from this software
78  *    without specific prior written permission.
79  *
80  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
81  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
82  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
83  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
84  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
85  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
86  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
87  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
88  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
89  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
90  * SUCH DAMAGE.
91  *
92  */
93
94 #include <afsconfig.h>
95 #include "afs/param.h"
96
97 #include "afs/sysincludes.h"    /* Standard vendor system headers */
98 #include "afs/afsincludes.h"    /* Afs-based standard headers */
99 #include "afs/afs_stats.h"      /* statistics */
100
101 #include <sys/ioctl.h>
102 #ifndef AFS_NBSD60_ENV
103 #include <sys/lkm.h>
104 #endif
105 #include <sys/namei.h>
106 #include <miscfs/genfs/genfs.h>
107
108 VFS_PROTOS(afs);
109
110 #ifndef AFS_NBSD60_ENV
111 extern int sys_lkmnosys(struct lwp *, const void *, register_t *);
112 extern int afs3_syscall(struct lwp *, const void *, register_t *);
113 extern int afs_xioctl(struct lwp *, const void *, register_t *);
114 extern int Afs_xsetgroups(struct lwp *, const void *, register_t *);
115 static int afs_badcall(struct lwp *, const void *, register_t *);
116
117 static int lkmid = -1;
118
119 struct sysent afs_sysent = { 6,
120                              sizeof(struct afs_sysargs),
121                              0,
122                              afs3_syscall};
123
124 static struct sysent old_sysent;
125 static struct sysent old_setgroups;
126 #endif
127
128 struct osi_vfs *afs_globalVFS;
129 struct vcache *afs_globalVp;
130 fsid_t afs_dynamic_fsid;
131
132 int afs_mount(struct mount *, const char *, void *, size_t *);
133 int afs_start(struct mount *, int);
134 int afs_unmount(struct mount *, int);
135 int afs_root(struct mount *, struct vnode **);
136 int afs_statvfs(struct mount *, struct statvfs *);
137 int afs_sync(struct mount *, int, kauth_cred_t);
138 void afs_init(void);
139 void afs_reinit(void);
140 void afs_done(void);
141
142 extern struct vnodeopv_desc afs_vnodeop_opv_desc;
143 static const struct vnodeopv_desc *afs_vnodeopv_descs[] = {
144         &afs_vnodeop_opv_desc,
145         NULL,
146 };
147
148 struct vfsops afs_vfsops = {
149     AFS_MOUNT_STR,
150 #ifdef AFS_NBSD50_ENV
151         0,                                              /* vfs_min_mount_data */
152 #endif
153     afs_mount,
154     afs_start,
155     afs_unmount,
156     afs_root,
157     (void *) eopnotsupp,        /* vfs_quotactl */
158     afs_statvfs,
159     afs_sync,
160     (void *) eopnotsupp,        /* vfs_vget */
161     (void *) eopnotsupp,        /* vfs_fhtovp */
162     (void *) eopnotsupp,        /* vfs_vptofh */
163     afs_init,
164     afs_reinit,
165     afs_done,
166     (void *) eopnotsupp,        /* vfs_mountroot */
167     (void *) eopnotsupp,        /* vfs_snapshot */
168     vfs_stdextattrctl,
169 #ifdef AFS_NBSD50_ENV
170     (void *) eopnotsupp,        /* vfs_suspendctl */
171     genfs_renamelock_enter,     /* vfs_renamelock_enter */
172     genfs_renamelock_exit,      /* vfs_renamelock_exit */
173     (void *) eopnotsupp,        /* vfs_fsync */
174 #endif
175     afs_vnodeopv_descs,
176     0,                          /* vfs_refcount */
177     { NULL, NULL },
178 };
179
180 int
181 afs_nbsd_lookupname(const char *fnamep, enum uio_seg segflg, int followlink,
182                     struct vnode **compvpp)
183 {
184     struct nameidata nd;
185     int niflag;
186     int error;
187
188     if ((afs_debug & AFSDEB_VNLAYER) != 0) {
189         afs_warn("afs_nbsd_lookupname enter (%s)\n", fnamep);
190     }
191
192     /*
193      * Lookup pathname "fnamep", returning leaf in *compvpp.  segflg says
194      * whether the pathname is user or system space.
195      */
196     /* XXX LOCKLEAF ? */
197     niflag = followlink ? FOLLOW : NOFOLLOW;
198         /*
199         *       NBSD50 seems to have stopped caring about the curproc of things.
200         *       mattjsm
201         */
202 #if defined(AFS_NBSD60_ENV)
203     struct pathbuf *ipb = NULL;
204     ipb = pathbuf_create(fnamep);
205     NDINIT(&nd, LOOKUP, niflag, ipb);
206 #elif defined(AFS_NBSD50_ENV)
207     NDINIT(&nd, LOOKUP, niflag, segflg, fnamep);
208 #else
209     NDINIT(&nd, LOOKUP, niflag, segflg, fnamep, osi_curproc());
210 #endif
211     if ((error = namei(&nd))) {
212         goto out;
213     }
214     *compvpp = nd.ni_vp;
215 out:
216 #if defined(AFS_NBSD60_ENV)
217     pathbuf_destroy(ipb);
218 #endif
219     return error;
220 }
221
222 int
223 afs_start(struct mount *mp, int flags)
224 {
225     return (0); /* nothing to do? */
226 }
227
228 void afs_done(void)
229 {
230     return; /* nothing to do? */
231 }
232
233 int
234 afs_mount(struct mount *mp, const char *path, void *data,
235           size_t *dlen)
236 {
237     /* ndp contains the mounted-from device.  Just ignore it.
238      * we also don't care about our proc struct. */
239     size_t size;
240
241     AFS_STATCNT(afs_mount);
242
243     if ((afs_debug & AFSDEB_VNLAYER) != 0) {
244         afs_warn("afs_mount enter\n");
245     }
246
247     if (mp->mnt_flag & MNT_UPDATE)
248         return EINVAL;
249
250     if (afs_globalVFS != NULL) {
251         /* Don't allow remounts */
252         return EBUSY;
253     }
254
255     AFS_GLOCK();
256 #ifdef AFS_DISCON_ENV
257     /* initialize the vcache entries before we start using them */
258
259     /* XXX find a better place for this if possible  */
260     init_vcache_entries();
261 #endif
262     afs_globalVFS = mp;
263     mp->mnt_stat.f_bsize = 8192;
264     mp->mnt_stat.f_frsize = 8192;
265     mp->mnt_stat.f_iosize = 8192;
266     mp->mnt_fs_bshift = DEV_BSHIFT;
267     mp->mnt_dev_bshift = DEV_BSHIFT;
268     vfs_getnewfsid(mp);
269     afs_dynamic_fsid = mp->mnt_stat.f_fsidx;
270     (void)copyinstr(path, mp->mnt_stat.f_mntonname, MNAMELEN - 1,
271                     &size);
272     memset(mp->mnt_stat.f_mntonname + size, 0, MNAMELEN - size);
273     memset(mp->mnt_stat.f_mntfromname, 0, MNAMELEN);
274     strcpy(mp->mnt_stat.f_mntfromname, "AFS");
275     /* null terminated string "AFS" will fit, just leave it be. */
276     strcpy(mp->mnt_stat.f_fstypename, AFS_MOUNT_STR);
277     AFS_GUNLOCK();
278     (void)afs_statvfs(mp, &mp->mnt_stat);
279
280     if ((afs_debug & AFSDEB_VNLAYER) != 0) {
281         afs_warn("afs_mount exit\n");
282     }
283
284     return 0;
285 }
286
287 int
288 afs_unmount(struct mount *mp, int mntflags)
289 {
290     AFS_STATCNT(afs_unmount);
291 #ifdef AFS_DISCON_ENV
292     give_up_cbs();
293 #endif
294     if (afs_globalVFS == NULL) {
295         printf("afs already unmounted\n");
296         return 0;
297     }
298     if (afs_globalVp)
299         vrele(AFSTOV(afs_globalVp));
300     afs_globalVp = NULL;
301
302     vflush(mp, NULLVP, 0);      /* don't support forced */
303     AFS_GLOCK();
304     afs_globalVFS = NULL;
305     afs_shutdown(AFS_COLD);
306     AFS_GUNLOCK();
307
308     mp->mnt_data = NULL;
309
310     printf("AFS unmounted.\n");
311     return 0;
312 }
313
314 #ifndef AFS_NBSD60_ENV
315 static int
316 afs_badcall(struct lwp *l, const void *xx, register_t *yy)
317 {
318     return ENOSYS;
319 }
320 #endif
321
322 int
323 afs_root(struct mount *mp, struct vnode **vpp)
324 {
325     struct vrequest treq;
326     struct vcache *tvp;
327     struct vcache *gvp;
328     int code;
329
330     AFS_STATCNT(afs_root);
331
332     if ((afs_debug & AFSDEB_VNLAYER) != 0) {
333         int glocked = ISAFS_GLOCK();
334         afs_warn("afs_root enter, glocked==%d\n", glocked);
335     }
336
337     AFS_GLOCK();
338
339     if ((afs_debug & AFSDEB_VNLAYER) != 0) {
340         afs_warn("afs_root: glocked\n");
341     }
342
343     tvp = NULL;
344 tryagain:
345     if (afs_globalVp && (afs_globalVp->f.states & CStatd)) {
346         tvp = afs_globalVp;
347         code = 0;
348     } else {
349         if (afs_globalVp) {
350             gvp = afs_globalVp;
351             afs_globalVp = NULL;
352             afs_PutVCache(gvp);
353         }
354
355         if (!(code = afs_InitReq(&treq, osi_curcred()))
356             && !(code = afs_CheckInit())) {
357             tvp = afs_GetVCache(&afs_rootFid, &treq);
358
359             if (tvp) {
360                 if (afs_globalVp) {
361
362                     afs_PutVCache(tvp);
363                     tvp = NULL;
364                     goto tryagain;
365                 }
366                 afs_globalVp = tvp;
367             } else
368                 code = EIO;
369         }
370     }
371     if (tvp) {
372         struct vnode *vp = AFSTOV(tvp);
373         AFS_GUNLOCK();
374         vref(vp);
375         if (code != 0) {
376                 vrele(vp);
377                 return code;
378         }
379         if (!VOP_ISLOCKED(*vpp))
380             code = vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
381         AFS_GLOCK();
382         if (!afs_globalVp || !(afs_globalVp->f.states & CStatd) ||
383             tvp != afs_globalVp) {
384             vput(vp);
385             afs_PutVCache(tvp);
386             tvp = NULL;
387             goto tryagain;
388         }
389         if (code != 0)
390             goto tryagain;
391         vp->v_vflag |= VV_ROOT;
392         if (afs_globalVFS != mp)
393             afs_globalVFS = mp;
394         *vpp = vp;
395     }
396     AFS_GUNLOCK();
397
398     if ((afs_debug & AFSDEB_VNLAYER) != 0) {
399         afs_warn("afs_root exit\n");
400     }
401
402     return code;
403 }
404
405 int
406 afs_statvfs(struct mount *mp, struct statvfs *abp)
407 {
408     AFS_STATCNT(afs_statfs);
409
410     if ((afs_debug & AFSDEB_VNLAYER) != 0) {
411         afs_warn("afs_statvfs enter\n");
412     }
413
414     /* thank you, NetBSD */
415     copy_statvfs_info(abp, mp);
416
417     /* not actually sure which we really must set, but
418      * pretty sure of the right values (and in 40, none touched by
419      * the above convenience function) */
420     abp->f_bsize = mp->osi_vfs_bsize;
421     abp->f_frsize = mp->osi_vfs_bsize;
422     abp->f_iosize = mp->osi_vfs_bsize;
423
424     abp->f_blocks = abp->f_bfree = abp->f_bavail = abp->f_files =
425         abp->f_ffree = AFS_VFS_FAKEFREE;
426
427     return (0);
428 }
429
430 int
431 afs_sync(struct mount *mp, int waitfor, kauth_cred_t cred)
432 {
433     AFS_STATCNT(afs_sync);
434 #if defined(AFS_DISCON_ENV)
435     /* Can't do this in OpenBSD 2.7, it faults when called from apm_suspend() */
436     store_dirty_vcaches();
437 #endif
438     return 0;
439 }
440
441 void
442 afs_init(void)
443 {
444     osi_Init();
445     return;
446 }
447
448 void
449 afs_reinit(void)
450 {
451     return;
452 }
453
454 #ifndef AFS_NBSD60_ENV
455 /* LKM */
456
457 /*
458  * declare the filesystem
459  */
460 MOD_VFS("afs", -1, &afs_vfsops);
461
462 static int
463 afs_vfs_load(struct lkm_table *lkmtp, int cmd)
464 {
465     lkmid = lkmtp->id;
466     if (sysent[AFS_SYSCALL].sy_call != sys_lkmnosys) {
467         printf("LKM afs_vfs_load(): AFS3 syscall %d already used\n",
468             AFS_SYSCALL);
469         /* return EEXIST; */
470     }
471
472     old_sysent = sysent[AFS_SYSCALL];
473     sysent[AFS_SYSCALL] = afs_sysent;
474     old_setgroups = sysent[SYS_setgroups];
475     sysent[SYS_setgroups].sy_call = Afs_xsetgroups;
476 #if NOTYET
477     old_ioctl = sysent[SYS_ioctl];
478     sysent[SYS_ioctl].sy_call = afs_xioctl;
479 #endif
480
481     aprint_verbose("OpenAFS loaded\n");
482
483     return (0);
484 }
485
486 static int
487 afs_vfs_unload(struct lkm_table *lktmp, int cmd)
488 {
489     if (afs_globalVp)
490         return EBUSY;
491
492     if (sysent[AFS_SYSCALL].sy_call != afs_sysent.sy_call) {
493         printf("LKM afs_vfs_load(): AFS3 syscall %d already used\n",
494                AFS_SYSCALL);
495         return EEXIST;
496     }
497
498     sysent[AFS_SYSCALL] = old_sysent;
499     sysent[SYS_setgroups] = old_setgroups;
500 #if NOTYET
501     sysent[SYS_ioctl] = old_ioctl;
502 #endif
503     printf("OpenAFS unloaded\n");
504
505     return (0);
506 }
507
508 int libafs_lkmentry(struct lkm_table *, int, int);
509
510 int
511 libafs_lkmentry(struct lkm_table *lkmtp, int cmd, int ver)
512 {
513     if (cmd == LKM_E_LOAD) {
514         if (sysent[AFS_SYSCALL].sy_call == afs3_syscall
515             || sysent[AFS_SYSCALL].sy_call == afs_badcall) {
516             printf("AFS already loaded\n");
517             return EINVAL;
518         }
519     }
520
521     DISPATCH(lkmtp, cmd, ver, afs_vfs_load, afs_vfs_unload, lkm_nofunc);
522 }
523 #endif