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