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