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