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