sys/kern/kern_syscalls.c

   1 /*-
   2  * Copyright (c) 1999 Assar Westerlund
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  */
  26
  27 #include <sys/cdefs.h>
  28 __FBSDID("$FreeBSD$");
  29
  30 #include <sys/param.h>
  31 #include <sys/lock.h>
  32 #include <sys/module.h>
  33 #include <sys/sx.h>
  34 #include <sys/syscall.h>
  35 #include <sys/sysent.h>
  36 #include <sys/sysproto.h>
  37
  38 /*
  39  * Acts like "nosys" but can be identified in sysent for dynamic call
  40  * number assignment for a limited number of calls.
  41  *
  42  * Place holder for system call slots reserved for loadable modules.
  43  */
  44 int
  45 lkmnosys(struct thread *td, struct nosys_args *args)
  46 {
  47
  48         return (nosys(td, args));
  49 }
  50
  51 int
  52 lkmressys(struct thread *td, struct nosys_args *args)
  53 {
  54
  55         return (nosys(td, args));
  56 }
  57
  58 int
  59 syscall_register(int *offset, struct sysent *new_sysent,
  60     struct sysent *old_sysent)
  61 {
  62         int i;
  63
  64         if (*offset == NO_SYSCALL) {
  65                 for (i = 1; i < SYS_MAXSYSCALL; ++i)
  66                         if (sysent[i].sy_call == (sy_call_t *)lkmnosys)
  67                                 break;
  68                 if (i == SYS_MAXSYSCALL)
  69                         return (ENFILE);
  70                 *offset = i;
  71         } else if (*offset < 0 || *offset >= SYS_MAXSYSCALL)
  72                 return (EINVAL);
  73         else if (sysent[*offset].sy_call != (sy_call_t *)lkmnosys &&
  74             sysent[*offset].sy_call != (sy_call_t *)lkmressys)
  75                 return (EEXIST);
  76
  77         *old_sysent = sysent[*offset];
  78         sysent[*offset] = *new_sysent;
  79         return (0);
  80 }
  81
  82 int
  83 syscall_deregister(int *offset, struct sysent *old_sysent)
  84 {
  85
  86         if (*offset)
  87                 sysent[*offset] = *old_sysent;
  88         return (0);
  89 }
  90
  91 int
  92 syscall_module_handler(struct module *mod, int what, void *arg)
  93 {
  94         struct syscall_module_data *data = arg;
  95         modspecific_t ms;
  96         int error;
  97
  98         switch (what) {
  99         case MOD_LOAD:
 100                 error = syscall_register(data->offset, data->new_sysent,
 101                     &data->old_sysent);
 102                 if (error) {
 103                         /* Leave a mark so we know to safely unload below. */
 104                         data->offset = NULL;
 105                         return (error);
 106                 }
 107                 ms.intval = *data->offset;
 108                 MOD_XLOCK;
 109                 module_setspecific(mod, &ms);
 110                 MOD_XUNLOCK;
 111                 if (data->chainevh)
 112                         error = data->chainevh(mod, what, data->chainarg);
 113                 return (error);
 114         case MOD_UNLOAD:
 115                 /*
 116                  * MOD_LOAD failed, so just return without calling the
 117                  * chained handler since we didn't pass along the MOD_LOAD
 118                  * event.
 119                  */
 120                 if (data->offset == NULL)
 121                         return (0);
 122                 if (data->chainevh) {
 123                         error = data->chainevh(mod, what, data->chainarg);
 124                         if (error)
 125                                 return error;
 126                 }
 127                 error = syscall_deregister(data->offset, &data->old_sysent);
 128                 return (error);
 129         default:
 130                 return EOPNOTSUPP;
 131         }
 132
 133         if (data->chainevh)
 134                 return (data->chainevh(mod, what, data->chainarg));
 135         else
 136                 return (0);
 137 }
 138
 139 int
 140 syscall_helper_register(struct syscall_helper_data *sd)
 141 {
 142         struct syscall_helper_data *sd1;
 143         int error;
 144
 145         for (sd1 = sd; sd1->syscall_no != NO_SYSCALL; sd1++) {
 146                 error = syscall_register(&sd1->syscall_no, &sd1->new_sysent,
 147                     &sd1->old_sysent);
 148                 if (error != 0) {
 149                         syscall_helper_unregister(sd);
 150                         return (error);
 151                 }
 152                 sd1->registered = 1;
 153         }
 154         return (0);
 155 }
 156
 157 int
 158 syscall_helper_unregister(struct syscall_helper_data *sd)
 159 {
 160         struct syscall_helper_data *sd1;
 161
 162         for (sd1 = sd; sd1->registered != 0; sd1++) {
 163                 syscall_deregister(&sd1->syscall_no, &sd1->old_sysent);
 164                 sd1->registered = 0;
 165         }
 166         return (0);
 167 }