include/sys/neti.h

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 /*
  22  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
  23  * Use is subject to license terms.
  24  */
  25
  26 #ifndef _SYS_NETI_H
  27 #define _SYS_NETI_H
  28
  29 #include <netinet/in.h>
  30 #include <sys/int_types.h>
  31 #include <sys/queue.h>
  32 #include <sys/hook_impl.h>
  33 #include <sys/netstack.h>
  34 #include <sys/stream.h>
  35
  36 #ifdef  __cplusplus
  37 extern "C" {
  38 #endif
  39
  40 #define NETINFO_VERSION 1
  41
  42 /*
  43  * Network hooks framework stack protocol name
  44  */
  45 #define NHF_INET        "NHF_INET"
  46 #define NHF_INET6       "NHF_INET6"
  47 #define NHF_ARP         "NHF_ARP"
  48
  49 /*
  50  * Event identification
  51  */
  52 #define NH_PHYSICAL_IN  "PHYSICAL_IN"
  53 #define NH_PHYSICAL_OUT "PHYSICAL_OUT"
  54 #define NH_FORWARDING   "FORWARDING"
  55 #define NH_LOOPBACK_IN  "LOOPBACK_IN"
  56 #define NH_LOOPBACK_OUT "LOOPBACK_OUT"
  57 #define NH_NIC_EVENTS   "NIC_EVENTS"
  58 #define NH_OBSERVE      "OBSERVING"
  59
  60 /*
  61  * Network NIC hardware checksum capability
  62  */
  63 #define NET_HCK_NONE    0x00
  64 #define NET_HCK_L3_FULL 0x01
  65 #define NET_HCK_L3_PART 0x02
  66 #define NET_HCK_L4_FULL 0x10
  67 #define NET_HCK_L4_PART 0x20
  68
  69 #define NET_IS_HCK_L3_FULL(n, x)                                             \
  70         ((net_ispartialchecksum(n, x) & NET_HCK_L3_FULL) == NET_HCK_L3_FULL)
  71 #define NET_IS_HCK_L3_PART(n, x)                                             \
  72         ((net_ispartialchecksum(n, x) & NET_HCK_L3_PART) == NET_HCK_L3_PART)
  73 #define NET_IS_HCK_L4_FULL(n, x)                                             \
  74         ((net_ispartialchecksum(n, x) & NET_HCK_L4_FULL) == NET_HCK_L4_FULL)
  75 #define NET_IS_HCK_L4_PART(n, x)                                             \
  76         ((net_ispartialchecksum(n, x) & NET_HCK_L4_PART) == NET_HCK_L4_PART)
  77 #define NET_IS_HCK_L34_FULL(n, x)                                            \
  78         ((net_ispartialchecksum(n, x) & (NET_HCK_L3_FULL|NET_HCK_L4_FULL))   \
  79             == (NET_HCK_L3_FULL | NET_HCK_L4_FULL))
  80
  81 typedef uintptr_t       phy_if_t;
  82 typedef intptr_t        lif_if_t;
  83 typedef uintptr_t       net_ifdata_t;
  84 typedef id_t            netid_t;
  85
  86 /*
  87  * Netinfo interface specification
  88  *
  89  * Netinfo provides an extensible and easy to use interface for
  90  * accessing data and functionality already embedded within network
  91  * code that exists within the kernel.
  92  */
  93 typedef enum net_ifaddr {
  94         NA_ADDRESS = 1,
  95         NA_PEER,
  96         NA_BROADCAST,
  97         NA_NETMASK
  98 } net_ifaddr_t;
  99
 100
 101 typedef enum inject {
 102         NI_QUEUE_IN = 1,
 103         NI_QUEUE_OUT,
 104         NI_DIRECT_OUT
 105 } inject_t;
 106
 107 /*
 108  * net_inject - public interface
 109  */
 110 typedef struct net_inject {
 111         int                     ni_version;
 112         netid_t                 ni_netid;
 113         mblk_t                  *ni_packet;
 114         struct sockaddr_storage ni_addr;
 115         phy_if_t                ni_physical;
 116 } net_inject_t;
 117
 118 typedef struct net_data *net_handle_t;
 119
 120 /*
 121  * net_protocol_t private interface
 122  */
 123 struct net_protocol_s {
 124         int             netp_version;
 125         char            *netp_name;
 126         int             (*netp_getifname)(net_handle_t, phy_if_t, char *,
 127                             const size_t);
 128         int             (*netp_getmtu)(net_handle_t, phy_if_t, lif_if_t);
 129         int             (*netp_getpmtuenabled)(net_handle_t);
 130         int             (*netp_getlifaddr)(net_handle_t, phy_if_t, lif_if_t,
 131                             size_t, net_ifaddr_t [], void *);
 132         int             (*neti_getlifzone)(net_handle_t, phy_if_t, lif_if_t,
 133                             zoneid_t *);
 134         int             (*neti_getlifflags)(net_handle_t, phy_if_t, lif_if_t,
 135                             uint64_t *);
 136         phy_if_t        (*netp_phygetnext)(net_handle_t, phy_if_t);
 137         phy_if_t        (*netp_phylookup)(net_handle_t, const char *);
 138         lif_if_t        (*netp_lifgetnext)(net_handle_t, phy_if_t, lif_if_t);
 139         int             (*netp_inject)(net_handle_t, inject_t, net_inject_t *);
 140         phy_if_t        (*netp_routeto)(net_handle_t, struct sockaddr *,
 141                             struct sockaddr *);
 142         int             (*netp_ispartialchecksum)(net_handle_t, mblk_t *);
 143         int             (*netp_isvalidchecksum)(net_handle_t, mblk_t *);
 144 };
 145 typedef struct net_protocol_s net_protocol_t;
 146
 147
 148 /*
 149  * Private data structures
 150  */
 151 struct net_data {
 152         LIST_ENTRY(net_data)            netd_list;
 153         net_protocol_t                  netd_info;
 154         int                             netd_refcnt;
 155         hook_family_int_t               *netd_hooks;
 156         struct neti_stack_s             *netd_stack;
 157         int                             netd_condemned;
 158 };
 159
 160
 161 typedef struct injection_s {
 162         net_inject_t    inj_data;
 163         boolean_t       inj_isv6;
 164         void *          inj_ptr;
 165 } injection_t;
 166
 167 /*
 168  * The ipif_id space is [0,MAX) but this interface wants to return [1,MAX] as
 169  * a valid range of logical interface numbers so that it can return 0 to mean
 170  * "end of list" with net_lifgetnext.  Changing ipif_id's to use the [1,MAX]
 171  * space is something to be considered for the future, if it is worthwhile.
 172  */
 173 #define MAP_IPIF_ID(x)          ((x) + 1)
 174 #define UNMAP_IPIF_ID(x)        (((x) > 0) ? (x) - 1 : (x))
 175
 176 struct net_instance_s {
 177         int                             nin_version;
 178         char                            *nin_name;
 179         void                            *(*nin_create)(const netid_t);
 180         void                            (*nin_destroy)(const netid_t, void *);
 181         void                            (*nin_shutdown)(const netid_t, void *);
 182 };
 183 typedef struct net_instance_s net_instance_t;
 184
 185 struct net_instance_int_s {
 186         LIST_ENTRY(net_instance_int_s)  nini_next;
 187         uint_t                          nini_ref;
 188         void                            *nini_created;
 189         struct net_instance_int_s       *nini_parent;
 190         net_instance_t                  *nini_instance;
 191         hook_notify_t                   nini_notify;
 192         uint32_t                        nini_flags;
 193         kcondvar_t                      nini_cv;
 194         boolean_t                       nini_condemned;
 195 };
 196 typedef struct net_instance_int_s net_instance_int_t;
 197 LIST_HEAD(nini_head_s, net_instance_int_s);
 198 typedef struct nini_head_s nini_head_t;
 199
 200 #define nini_version    nini_instance->nin_version
 201 #define nini_name       nini_instance->nin_name
 202 #define nini_create     nini_instance->nin_create
 203 #define nini_destroy    nini_instance->nin_destroy
 204 #define nini_shutdown   nini_instance->nin_shutdown
 205
 206 /*
 207  * netinfo stack instances
 208  */
 209 struct neti_stack_s {
 210         kmutex_t                        nts_lock;
 211         LIST_ENTRY(neti_stack_s)        nts_next;
 212         netid_t                         nts_id;
 213         zoneid_t                        nts_zoneid;
 214         netstackid_t                    nts_stackid;
 215         netstack_t                      *nts_netstack;
 216         nini_head_t                     nts_instances;
 217         uint32_t                        nts_flags;
 218         kcondvar_t                      nts_cv;
 219         /* list of net_handle_t */
 220         LIST_HEAD(netd_listhead, net_data) nts_netd_head;
 221 };
 222 typedef struct neti_stack_s neti_stack_t;
 223 LIST_HEAD(neti_stack_head_s, neti_stack_s);
 224 typedef struct neti_stack_head_s neti_stack_head_t;
 225
 226 /*
 227  * Internal functions that need to be exported within the module.
 228  */
 229 extern void neti_init(void);
 230 extern void neti_fini(void);
 231 extern neti_stack_t *net_getnetistackbyid(netid_t);
 232 extern netstackid_t net_getnetstackidbynetid(netid_t);
 233 extern netid_t net_getnetidbynetstackid(netstackid_t);
 234 extern netid_t net_zoneidtonetid(zoneid_t);
 235 extern zoneid_t net_getzoneidbynetid(netid_t);
 236
 237 /*
 238  * Functions available for public use.
 239  */
 240 extern hook_event_token_t net_event_register(net_handle_t, hook_event_t *);
 241 extern int net_event_shutdown(net_handle_t, hook_event_t *);
 242 extern int net_event_unregister(net_handle_t, hook_event_t *);
 243 extern int net_event_notify_register(net_handle_t, char *,
 244     hook_notify_fn_t, void *);
 245 extern int net_event_notify_unregister(net_handle_t, char *, hook_notify_fn_t);
 246
 247 extern int net_family_register(net_handle_t, hook_family_t *);
 248 extern int net_family_shutdown(net_handle_t, hook_family_t *);
 249 extern int net_family_unregister(net_handle_t, hook_family_t *);
 250
 251 extern int net_hook_register(net_handle_t, char *, hook_t *);
 252 extern int net_hook_unregister(net_handle_t, char *, hook_t *);
 253
 254 extern int net_inject(net_handle_t, inject_t, net_inject_t *);
 255 extern net_inject_t *net_inject_alloc(const int);
 256 extern void net_inject_free(net_inject_t *);
 257
 258 extern net_instance_t *net_instance_alloc(const int version);
 259 extern void net_instance_free(net_instance_t *);
 260 extern int net_instance_register(net_instance_t *);
 261 extern int net_instance_unregister(net_instance_t *);
 262 extern int net_instance_notify_register(netid_t, hook_notify_fn_t, void *);
 263 extern int net_instance_notify_unregister(netid_t netid, hook_notify_fn_t);
 264
 265 extern kstat_t *net_kstat_create(netid_t, char *, int, char *, char *,
 266     uchar_t, ulong_t, uchar_t);
 267 extern void net_kstat_delete(netid_t, kstat_t *);
 268
 269 extern net_handle_t net_protocol_lookup(netid_t, const char *);
 270 extern net_handle_t net_protocol_register(netid_t, const net_protocol_t *);
 271 extern int net_protocol_release(net_handle_t);
 272 extern int net_protocol_unregister(net_handle_t);
 273 extern net_handle_t net_protocol_walk(netid_t, net_handle_t);
 274 extern int net_protocol_notify_register(net_handle_t, hook_notify_fn_t, void *);
 275 extern int net_protocol_notify_unregister(net_handle_t, hook_notify_fn_t);
 276
 277
 278 extern int net_getifname(net_handle_t, phy_if_t, char *, const size_t);
 279 extern int net_getmtu(net_handle_t, phy_if_t, lif_if_t);
 280 extern int net_getpmtuenabled(net_handle_t);
 281 extern int net_getlifaddr(net_handle_t, phy_if_t, lif_if_t,
 282     int, net_ifaddr_t [], void *);
 283 extern zoneid_t net_getlifzone(net_handle_t, phy_if_t, lif_if_t, zoneid_t *);
 284 extern int net_getlifflags(net_handle_t, phy_if_t, lif_if_t, uint64_t *);
 285 extern phy_if_t net_phygetnext(net_handle_t, phy_if_t);
 286 extern phy_if_t net_phylookup(net_handle_t, const char *);
 287 extern lif_if_t net_lifgetnext(net_handle_t, phy_if_t, lif_if_t);
 288 extern phy_if_t net_routeto(net_handle_t, struct sockaddr *,
 289     struct sockaddr *);
 290 extern int net_ispartialchecksum(net_handle_t, mblk_t *);
 291 extern int net_isvalidchecksum(net_handle_t, mblk_t *);
 292
 293 #ifdef  __cplusplus
 294 }
 295 #endif
 296
 297 #endif /* _SYS_NETI_H */