afsd: Pass cacheMountDir to aix_vmount
[openafs.git] / src / afsd / afsd_kernel.c
1 /*
2  * Copyright 2000, International Business Machines Corporation and others.
3  * All Rights Reserved.
4  *
5  * This software has been released under the terms of the IBM Public
6  * License.  For details, see the LICENSE file in the top-level source
7  * directory or online at http://www.openafs.org/dl/license10.html
8  */
9
10 #include <afsconfig.h>
11 #include <afs/param.h>
12
13 #define VFS 1
14
15 #include <afs/cmd.h>
16
17 #include "afsd.h"
18
19 #include <assert.h>
20 #include <afs/afsutil.h>
21 #include <stdlib.h>
22 #include <stdio.h>
23 #include <signal.h>
24 #include <string.h>
25 #include <stdlib.h>
26 #include <time.h>
27 #include <sys/types.h>
28 #include <sys/stat.h>
29 #include <sys/file.h>
30 #include <errno.h>
31 #include <sys/time.h>
32 #include <dirent.h>
33 #include <sys/wait.h>
34
35
36 #ifdef HAVE_SYS_PARAM_H
37 #include <sys/param.h>
38 #endif
39
40 #ifdef HAVE_SYS_FS_TYPES_H
41 #include <sys/fs_types.h>
42 #endif
43
44 #ifdef HAVE_SYS_MOUNT_H
45 #include <sys/mount.h>
46 #endif
47
48 #ifdef HAVE_SYS_FCNTL_H
49 #include <sys/fcntl.h>
50 #endif
51
52 #ifdef HAVE_SYS_MNTTAB_H
53 #include <sys/mnttab.h>
54 #endif
55
56 #ifdef HAVE_SYS_MNTENT_H
57 #include <sys/mntent.h>
58 #endif
59
60 #ifdef HAVE_MNTENT_H
61 #include <mntent.h>
62 #endif
63
64 #ifdef HAVE_SYS_MOUNT_H
65 #include <sys/mount.h>
66 #endif
67
68 #ifdef HAVE_SYS_VFS_H
69 #include <sys/vfs.h>
70 #endif
71
72 #ifdef HAVE_SYS_FSTYP_H
73 #include <sys/fstyp.h>
74 #endif
75
76 #ifdef HAVE_UNISTD_H
77 #include <unistd.h>
78 #endif
79
80 #ifdef HAVE_FCNTL_H
81 #include <fcntl.h>
82 #endif
83
84 #include <netinet/in.h>
85 #include <afs/afs_args.h>
86 #include <afs/cellconfig.h>
87 #include <ctype.h>
88 #include <afs/afssyscalls.h>
89 #include <afs/afsutil.h>
90
91 #ifdef AFS_DARWIN_ENV
92 #ifdef AFS_DARWIN80_ENV
93 #include <sys/ioctl.h>
94 #include <sys/xattr.h>
95 #endif
96 #include <mach/mach.h>
97 #ifndef AFS_DARWIN100_ENV
98 /* Symbols from the DiskArbitration framework */
99 kern_return_t DiskArbStart(mach_port_t *);
100 kern_return_t DiskArbDiskAppearedWithMountpointPing_auto(char *, unsigned int,
101                                                          char *);
102 #define DISK_ARB_NETWORK_DISK_FLAG 8
103 #endif
104 #include <mach/mach_port.h>
105 #include <mach/mach_interface.h>
106 #include <mach/mach_init.h>
107 #endif /* AFS_DARWIN_ENV */
108
109 #ifndef MOUNT_AFS
110 #define MOUNT_AFS AFS_MOUNT_AFS
111 #endif /* MOUNT_AFS */
112
113 #ifdef AFS_SGI65_ENV
114 # include <sched.h>
115 # define SET_RTPRI(P) {  \
116     struct sched_param sp; \
117     sp.sched_priority = P; \
118     if (sched_setscheduler(0, SCHED_RR, &sp)<0) { \
119         perror("sched_setscheduler"); \
120     } \
121 }
122 # define SET_AFSD_RTPRI() SET_RTPRI(68)
123 # define SET_RX_RTPRI()   SET_RTPRI(199)
124 #else
125 # ifdef AFS_LINUX20_ENV
126 #  define SET_AFSD_RTPRI()
127 #  define SET_RX_RTPRI() do { \
128     if (setpriority(PRIO_PROCESS, 0, -10) < 0) \
129         perror("setting rx priority"); \
130 } while (0)
131 # else
132 #  define SET_AFSD_RTPRI()
133 #  define SET_RX_RTPRI()
134 # endif
135 #endif
136
137 void
138 afsd_set_rx_rtpri(void)
139 {
140     SET_RX_RTPRI();
141 }
142
143 void
144 afsd_set_afsd_rtpri(void)
145 {
146     SET_AFSD_RTPRI();
147 }
148
149 #if !defined(AFS_SGI_ENV) && !defined(AFS_AIX32_ENV)
150
151 int
152 afsd_call_syscall(long param1, long param2, long param3, long param4, long param5,
153              long param6, long  param7)
154 {
155     int error;
156 # ifdef AFS_LINUX20_ENV
157     long eparm[4];
158     struct afsprocdata syscall_data;
159     int fd = open(PROC_SYSCALL_FNAME, O_RDWR);
160     if (fd < 0)
161         fd = open(PROC_SYSCALL_ARLA_FNAME, O_RDWR);
162     eparm[0] = param4;
163     eparm[1] = param5;
164     eparm[2] = param6;
165     eparm[3] = param7;
166
167     param4 = (long)eparm;
168
169     syscall_data.syscall = AFSCALL_CALL;
170     syscall_data.param1 = param1;
171     syscall_data.param2 = param2;
172     syscall_data.param3 = param3;
173     syscall_data.param4 = param4;
174     if (fd > 0) {
175         error = ioctl(fd, VIOC_SYSCALL, &syscall_data);
176         close(fd);
177     } else
178 # endif /* AFS_LINUX20_ENV */
179 # ifdef AFS_DARWIN80_ENV
180     struct afssysargs syscall_data;
181     void *ioctldata;
182     int fd = open(SYSCALL_DEV_FNAME,O_RDWR);
183     int syscallnum;
184 #ifdef AFS_DARWIN100_ENV
185     int is64 = 0;
186     struct afssysargs64 syscall64_data;
187     if (sizeof(param1) == 8) {
188         syscallnum = VIOC_SYSCALL64;
189         is64 = 1;
190         ioctldata = &syscall64_data;
191         syscall64_data.syscall = (int)AFSCALL_CALL;
192         syscall64_data.param1 = param1;
193         syscall64_data.param2 = param2;
194         syscall64_data.param3 = param3;
195         syscall64_data.param4 = param4;
196         syscall64_data.param5 = param5;
197         syscall64_data.param6 = param6;
198     } else {
199 #endif
200         syscallnum = VIOC_SYSCALL;
201         ioctldata = &syscall_data;
202         syscall_data.syscall = AFSCALL_CALL;
203         syscall_data.param1 = param1;
204         syscall_data.param2 = param2;
205         syscall_data.param3 = param3;
206         syscall_data.param4 = param4;
207         syscall_data.param5 = param5;
208         syscall_data.param6 = param6;
209 #ifdef AFS_DARWIN100_ENV
210     }
211 #endif
212     if(fd >= 0) {
213         error = ioctl(fd, syscallnum, ioctldata);
214         close(fd);
215     } else {
216         error = -1;
217     }
218     if (!error) {
219 #ifdef AFS_DARWIN100_ENV
220         if (is64)
221             error=syscall64_data.retval;
222         else
223 #endif
224             error=syscall_data.retval;
225     }
226 # else /* AFS_DARWIN80_ENV */
227         error =
228         syscall(AFS_SYSCALL, AFSCALL_CALL, param1, param2, param3, param4,
229                 param5, param6, param7);
230 # endif /* !AFS_DARWIN80_ENV */
231
232     if (afsd_debug) {
233 #ifdef AFS_NBSD40_ENV
234         char *s = strerror(errno);
235         printf("SScall(%d, %d, %d)=%d (%d, %s)\n", AFS_SYSCALL, AFSCALL_CALL,
236                 param1, error, errno, s);
237 #else
238         printf("SScall(%d, %d, %ld)=%d ", AFS_SYSCALL, AFSCALL_CALL, param1,
239                error);
240 #endif
241     }
242
243     return (error);
244 }
245 #else /* !AFS_SGI_ENV && !AFS_AIX32_ENV */
246 # if defined(AFS_SGI_ENV)
247 int
248 afsd_call_syscall(call, parm0, parm1, parm2, parm3, parm4)
249 {
250
251     int error;
252
253     error = afs_syscall(call, parm0, parm1, parm2, parm3, parm4);
254     if (afsd_verbose)
255         printf("SScall(%d, %d)=%d ", call, parm0, error);
256
257     return error;
258 }
259 # else /* AFS_SGI_ENV */
260 int
261 afsd_call_syscall(call, parm0, parm1, parm2, parm3, parm4, parm5, parm6)
262 {
263
264     return syscall(AFSCALL_CALL, call, parm0, parm1, parm2, parm3, parm4,
265                    parm5, parm6);
266 }
267 # endif /* !AFS_SGI_ENV */
268 #endif /* AFS_SGI_ENV || AFS_AIX32_ENV */
269
270
271 #ifdef  AFS_AIX_ENV
272 /* Special handling for AIX's afs mount operation since they require much more
273  * miscl. information before making the vmount(2) syscall */
274 #include <sys/vfs.h>
275
276 #define ROUNDUP(x)  (((x) + 3) & ~3)
277
278 aix_vmount(const char *cacheMountDir)
279 {
280     struct vmount *vmountp;
281     int size, error;
282
283     size = sizeof(struct vmount) + ROUNDUP(strlen(cacheMountDir) + 1) + 5 * 4;
284     /* Malloc the vmount structure */
285     if ((vmountp = (struct vmount *)malloc(size)) == (struct vmount *)NULL) {
286         printf("Can't allocate space for the vmount structure (AIX)\n");
287         exit(1);
288     }
289
290     /* zero out the vmount structure */
291     memset(vmountp, '\0', size);
292
293     /* transfer info into the vmount structure */
294     vmountp->vmt_revision = VMT_REVISION;
295     vmountp->vmt_length = size;
296     vmountp->vmt_fsid.fsid_dev = 0;
297     vmountp->vmt_fsid.fsid_type = AFS_MOUNT_AFS;
298     vmountp->vmt_vfsnumber = 0;
299     vmountp->vmt_time = 0;      /* We'll put the time soon! */
300     vmountp->vmt_flags = VFS_DEVMOUNT;  /* read/write permission */
301     vmountp->vmt_gfstype = AFS_MOUNT_AFS;
302     vmountdata(vmountp, "AFS", cacheMountDir, "", "", "", "rw");
303
304     /* Do the actual mount system call */
305     error = vmount(vmountp, size);
306     free(vmountp);
307     return (error);
308 }
309
310 vmountdata(struct vmount * vmtp, char *obj, char *stub, char *host,
311            char *hostsname, char *info, char *args)
312 {
313     struct data {
314         short vmt_off;
315         short vmt_size;
316     } *vdp, *vdprev;
317     int size;
318
319     vdp = (struct data *)vmtp->vmt_data;
320     vdp->vmt_off = sizeof(struct vmount);
321     size = ROUNDUP(strlen(obj) + 1);
322     vdp->vmt_size = size;
323     strcpy(vmt2dataptr(vmtp, VMT_OBJECT), obj);
324
325     vdprev = vdp;
326     vdp++;
327     vdp->vmt_off = vdprev->vmt_off + size;
328     size = ROUNDUP(strlen(stub) + 1);
329     vdp->vmt_size = size;
330     strcpy(vmt2dataptr(vmtp, VMT_STUB), stub);
331
332     vdprev = vdp;
333     vdp++;
334     vdp->vmt_off = vdprev->vmt_off + size;
335     size = ROUNDUP(strlen(host) + 1);
336     vdp->vmt_size = size;
337     strcpy(vmt2dataptr(vmtp, VMT_HOST), host);
338
339     vdprev = vdp;
340     vdp++;
341     vdp->vmt_off = vdprev->vmt_off + size;
342     size = ROUNDUP(strlen(hostsname) + 1);
343     vdp->vmt_size = size;
344     strcpy(vmt2dataptr(vmtp, VMT_HOSTNAME), hostsname);
345
346
347     vdprev = vdp;
348     vdp++;
349     vdp->vmt_off = vdprev->vmt_off + size;
350     size = ROUNDUP(strlen(info) + 1);
351     vdp->vmt_size = size;
352     strcpy(vmt2dataptr(vmtp, VMT_INFO), info);
353
354     vdprev = vdp;
355     vdp++;
356     vdp->vmt_off = vdprev->vmt_off + size;
357     size = ROUNDUP(strlen(args) + 1);
358     vdp->vmt_size = size;
359     strcpy(vmt2dataptr(vmtp, VMT_ARGS), args);
360 }
361 #endif /* AFS_AIX_ENV */
362
363 #ifdef  AFS_HPUX_ENV
364 #define MOUNTED_TABLE   MNT_MNTTAB
365 #else
366 #ifdef  AFS_SUN5_ENV
367 #define MOUNTED_TABLE   MNTTAB
368 #else
369 #define MOUNTED_TABLE   MOUNTED
370 #endif
371 #endif
372
373 static int
374 HandleMTab(char *cacheMountDir)
375 {
376 #if (defined (AFS_SUN_ENV) || defined (AFS_HPUX_ENV) || defined(AFS_SUN5_ENV) || defined(AFS_SGI_ENV) || defined(AFS_LINUX20_ENV)) && !defined(AFS_SUN58_ENV)
377     FILE *tfilep;
378 #ifdef  AFS_SUN5_ENV
379     char tbuf[16];
380     struct mnttab tmntent;
381
382     memset(&tmntent, '\0', sizeof(struct mnttab));
383     if (!(tfilep = fopen(MOUNTED_TABLE, "a+"))) {
384         printf("Can't open %s\n", MOUNTED_TABLE);
385         perror(MNTTAB);
386         exit(-1);
387     }
388     tmntent.mnt_special = "AFS";
389     tmntent.mnt_mountp = cacheMountDir;
390     tmntent.mnt_fstype = "xx";
391     tmntent.mnt_mntopts = "rw";
392     sprintf(tbuf, "%ld", (long)time((time_t *) 0));
393     tmntent.mnt_time = tbuf;
394     putmntent(tfilep, &tmntent);
395     fclose(tfilep);
396 #else
397 #if defined(AFS_SGI_ENV) || defined(AFS_LINUX20_ENV)
398     struct mntent tmntent;
399
400     tfilep = setmntent("/etc/mtab", "a+");
401     tmntent.mnt_fsname = "AFS";
402     tmntent.mnt_dir = cacheMountDir;
403     tmntent.mnt_type = "afs";
404     tmntent.mnt_opts = "rw";
405     tmntent.mnt_freq = 1;
406     tmntent.mnt_passno = 3;
407     addmntent(tfilep, &tmntent);
408     endmntent(tfilep);
409 #else
410     struct mntent tmntent;
411
412     memset(&tmntent, '\0', sizeof(struct mntent));
413     tfilep = setmntent(MOUNTED_TABLE, "a+");
414     if (!tfilep) {
415         printf("Can't open %s for write; Not adding afs entry to it\n",
416                MOUNTED_TABLE);
417         return 1;
418     }
419     tmntent.mnt_fsname = "AFS";
420     tmntent.mnt_dir = cacheMountDir;
421     tmntent.mnt_type = "xx";
422     tmntent.mnt_opts = "rw";
423     tmntent.mnt_freq = 1;
424     tmntent.mnt_passno = 3;
425 #ifdef  AFS_HPUX_ENV
426     tmntent.mnt_type = "afs";
427     tmntent.mnt_time = time(0);
428     tmntent.mnt_cnode = 0;
429 #endif
430     addmntent(tfilep, &tmntent);
431     endmntent(tfilep);
432 #endif /* AFS_SGI_ENV */
433 #endif /* AFS_SUN5_ENV */
434 #endif /* unreasonable systems */
435 #ifdef AFS_DARWIN_ENV
436 #ifndef AFS_DARWIN100_ENV
437     mach_port_t diskarb_port;
438     kern_return_t status;
439
440     status = DiskArbStart(&diskarb_port);
441     if (status == KERN_SUCCESS) {
442         status =
443             DiskArbDiskAppearedWithMountpointPing_auto("AFS",
444                                                        DISK_ARB_NETWORK_DISK_FLAG,
445                                                        cacheMountDir);
446     }
447
448     return status;
449 #endif
450 #endif /* AFS_DARWIN_ENV */
451     return 0;
452 }
453
454 void
455 afsd_mount_afs(const char *rn, const char *cacheMountDir)
456 {
457     int mountFlags;             /*Flags passed to mount() */
458     char *mountDir; /* For HandleMTab() */
459
460     mountFlags = 0;             /* Read/write file system, can do setuid() */
461 #if     defined(AFS_SUN_ENV) || defined(AFS_SUN5_ENV)
462 #ifdef  AFS_SUN5_ENV
463     mountFlags |= MS_DATA;
464 #else
465     mountFlags |= M_NEWTYPE;    /* This searches by name in vfs_conf.c so don't need to recompile vfs.c because MOUNT_MAXTYPE has changed; it seems that Sun fixed this at last... */
466 #endif
467 #endif
468
469 #if defined(AFS_HPUX100_ENV)
470     mountFlags |= MS_DATA;
471 #endif
472
473     if (afsd_verbose)
474         printf("%s: Mounting the AFS root on '%s', flags: %d.\n", rn,
475             cacheMountDir, mountFlags);
476 #if defined(AFS_FBSD60_ENV)
477     /* data must be non-NULL but is otherwise ignored */
478     if ((mount(MOUNT_AFS, cacheMountDir, mountFlags, rn)) < 0) {
479 #elif defined(AFS_FBSD_ENV)
480     if ((mount("AFS", cacheMountDir, mountFlags, (caddr_t) 0)) < 0) {
481 #elif defined(AFS_AIX_ENV)
482     if (aix_vmount(cacheMountDir)) {
483 #elif defined(AFS_HPUX100_ENV)
484     if ((mount("", cacheMountDir, mountFlags, "afs", NULL, 0)) < 0) {
485 #elif defined(AFS_SUN5_ENV)
486     if ((mount("AFS", cacheMountDir, mountFlags, "afs", NULL, 0)) < 0) {
487 #elif defined(AFS_SGI_ENV)
488     mountFlags = MS_FSS;
489     if ((mount(MOUNT_AFS, cacheMountDir, mountFlags, (caddr_t) MOUNT_AFS))
490         < 0) {
491 #elif defined(AFS_LINUX20_ENV)
492     if ((mount("AFS", cacheMountDir, MOUNT_AFS, 0, NULL)) < 0) {
493 #elif defined(AFS_NBSD50_ENV)
494     if ((mount(MOUNT_AFS, cacheMountDir, mountFlags, NULL, 0)) < 0) {
495 #else
496     /* This is the standard mount used by the suns and rts */
497     if ((mount(MOUNT_AFS, cacheMountDir, mountFlags, (caddr_t) 0)) < 0) {
498 #endif
499         printf("%s: Can't mount AFS on %s(%d)\n", rn, cacheMountDir,
500                 errno);
501         exit(1);
502     }
503
504     mountDir = strdup(cacheMountDir);
505     HandleMTab(mountDir);
506     free(mountDir);
507 }
508
509 int
510 afsd_fork(int wait, afsd_callback_func cb, void *rock)
511 {
512     int code;
513     code = fork();
514     if (code == 0) {
515         (*cb) (rock);
516         exit(1);
517     } else {
518         assert(code > 0);
519         if (wait) {
520             assert(waitpid(code, NULL, 0) != -1);
521         }
522     }
523     return 0;
524 }
525
526 int
527 afsd_daemon(int nochdir, int noclose)
528 {
529     return daemon(nochdir, noclose);
530 }
531
532 int
533 main(int argc, char **argv)
534 {
535     int code;
536
537     afsd_init();
538
539     code = afsd_parse(argc, argv);
540     if (code) {
541         return -1;
542     }
543
544     return afsd_run();
545 }