static inline void bit_putcs_aligned(struct vc_data *vc, struct fb_info *info, const u16 *s, u32 attr, u32 cnt, u32 d_pitch, u32 s_pitch, u32 cellsize, struct fb_image *image, u8 *buf, u8 *dst) { u16 charmask = vc->vc_hi_font_mask ? 0x1ff : 0xff; u32 idx = vc->vc_font.width >> 3; u8 *src; while (cnt--) { src = vc->vc_font.data + (scr_readw(s++)& charmask)*cellsize; if (attr) { update_attr(buf, src, attr, vc); src = buf; } if (likely(idx == 1)) __fb_pad_aligned_buffer(dst, d_pitch, src, idx, image->height); else fb_pad_aligned_buffer(dst, d_pitch, src, idx, image->height); dst += s_pitch; } info->fbops->fb_imageblit(info, image); }
static inline void bit_putcs_unaligned(struct vc_data *vc, struct fb_info *info, const u16 *s, u32 attr, u32 cnt, u32 d_pitch, u32 s_pitch, u32 cellsize, struct fb_image *image, u8 *buf, u8 *dst) { u16 charmask = vc->vc_hi_font_mask ? 0x1ff : 0xff; u32 shift_low = 0, mod = vc->vc_font.width % 8; u32 shift_high = 8; u32 idx = vc->vc_font.width >> 3; u8 *src; while (cnt--) { src = vc->vc_font.data + (scr_readw(s++)& charmask)*cellsize; if (attr) { update_attr(buf, src, attr, vc); src = buf; } fb_pad_unaligned_buffer(dst, d_pitch, src, idx, image->height, shift_high, shift_low, mod); shift_low += mod; dst += (shift_low >= 8) ? s_pitch : s_pitch - 1; shift_low &= 7; shift_high = 8 - shift_low; } info->fbops->fb_imageblit(info, image); }
static void proc_read(void) { FILE * fd; char buf[512], *p, *s; int w; intf_t *i; if (!(fd = fopen(c_path, "r"))) quit("Unable to open file %s: %s\n", c_path, strerror(errno)); fgets(buf, sizeof(buf), fd); fgets(buf, sizeof(buf), fd); for (; fgets(buf, sizeof(buf), fd);) { b_cnt_t rx_errors, rx_drop, rx_fifo, rx_frame, rx_compressed; b_cnt_t rx_multicast, tx_errors, tx_drop, tx_fifo, tx_frame; b_cnt_t tx_compressed, tx_multicast; if (buf[0] == '\r' || buf[0] == '\n') continue; if (!(p = strchr(buf, ':'))) continue; *p = '\0'; s = (p + 1); for (p = &buf[0]; *p == ' '; p++); /* * XXX: get_show_only_running */ if ((i = lookup_intf(get_local_node(), p, 0, 0)) == NULL) continue; w = sscanf(s, "%llu %llu %llu %llu %llu %llu %llu %llu %llu %llu " "%llu %llu %llu %llu %llu %llu\n", &i->i_rx_bytes.r_total, &i->i_rx_packets.r_total, &rx_errors, &rx_drop, &rx_fifo, &rx_frame, &rx_compressed, &rx_multicast, &i->i_tx_bytes.r_total, &i->i_tx_packets.r_total, &tx_errors, &tx_drop, &tx_fifo, &tx_frame, &tx_compressed, &tx_multicast); if (w != 16) continue; update_attr(i, ERRORS, rx_errors, tx_errors, RX_PROVIDED|TX_PROVIDED); update_attr(i, DROP, rx_drop, tx_drop, RX_PROVIDED|TX_PROVIDED); update_attr(i, FIFO, rx_fifo, tx_fifo, RX_PROVIDED|TX_PROVIDED); update_attr(i, FRAME, rx_frame, tx_frame, RX_PROVIDED|TX_PROVIDED); update_attr(i, COMPRESSED, rx_compressed, tx_compressed, RX_PROVIDED|TX_PROVIDED); update_attr(i, MULTICAST, rx_multicast, tx_multicast, RX_PROVIDED|TX_PROVIDED); notify_update(i); increase_lifetime(i, 1); } fclose(fd); }
int main(int argc, char **argv) { cib_t * the_cib = NULL; enum cib_errors rc = cib_ok; int cib_opts = cib_sync_call; int argerr = 0; int flag; int option_index = 0; crm_system_name = basename(argv[0]); crm_set_options("V?$GDQqN:U:u:s:n:v:l:t:i:!r:d:", "command -n attribute [options]", long_options, "Manage node's attributes and cluster options." "\n\nAllows node attributes and cluster options to be queried, modified and deleted.\n"); if(argc < 2) { crm_help('?', LSB_EXIT_EINVAL); } while (1) { flag = crm_get_option(argc, argv, &option_index); if (flag == -1) break; switch(flag) { case 'V': cl_log_enable_stderr(TRUE); alter_debug(DEBUG_INC); break; case '$': case '?': crm_help(flag, LSB_EXIT_OK); break; case 'D': case 'G': case 'v': command = flag; attr_value = optarg; break; case 'q': case 'Q': BE_QUIET = TRUE; break; case 'U': case 'N': dest_uname = crm_strdup(optarg); break; case 'u': dest_node = crm_strdup(optarg); break; case 's': set_name = crm_strdup(optarg); break; case 'l': case 't': type = optarg; break; case 'n': attr_name = crm_strdup(optarg); break; case 'i': attr_id = crm_strdup(optarg); break; case 'r': rsc_id = optarg; break; case 'd': attr_default = optarg; break; case '!': crm_warn("Inhibiting notifications for this update"); cib_opts |= cib_inhibit_notify; break; default: printf("Argument code 0%o (%c) is not (?yet?) supported\n", flag, flag); ++argerr; break; } } if(BE_QUIET == FALSE) { crm_log_init(basename(argv[0]), LOG_ERR, FALSE, FALSE, argc, argv); } else { crm_log_init(basename(argv[0]), LOG_ERR, FALSE, FALSE, 0, NULL); } if (optind < argc) { printf("non-option ARGV-elements: "); while (optind < argc) printf("%s ", argv[optind++]); printf("\n"); } if (optind > argc) { ++argerr; } if (argerr) { crm_help('?', LSB_EXIT_GENERIC); } the_cib = cib_new(); rc = the_cib->cmds->signon(the_cib, crm_system_name, cib_command); if(rc != cib_ok) { fprintf(stderr, "Error signing on to the CIB service: %s\n", cib_error2string(rc)); return rc; } if(safe_str_eq(type, "reboot")) { type = XML_CIB_TAG_STATUS; } else if(safe_str_eq(type, "forever")) { type = XML_CIB_TAG_NODES; } if(type == NULL && dest_uname == NULL) { /* we're updating cluster options - dont populate dest_node */ type = XML_CIB_TAG_CRMCONFIG; } else { determine_host(the_cib, &dest_uname, &dest_node); } if(rc != cib_ok) { crm_info("Error during setup of %s=%s update", attr_name, command=='D'?"<none>":attr_value); } else if( (command=='v' || command=='D') && safe_str_eq(type, XML_CIB_TAG_STATUS) && attrd_lazy_update(command, dest_uname, attr_name, attr_value, type, set_name, NULL)) { crm_info("Update %s=%s sent via attrd", attr_name, command=='D'?"<none>":attr_value); } else if(command=='D') { rc = delete_attr(the_cib, cib_opts, type, dest_node, set_name, attr_id, attr_name, attr_value, TRUE); if(rc == cib_NOTEXISTS) { /* Nothing to delete... * which means its not there... * which is what the admin wanted */ rc = cib_ok; } else if(rc != cib_missing_data && safe_str_eq(crm_system_name, "crm_failcount")) { char *now_s = NULL; time_t now = time(NULL); now_s = crm_itoa(now); update_attr(the_cib, cib_sync_call, XML_CIB_TAG_CRMCONFIG, NULL, NULL, NULL, "last-lrm-refresh", now_s, TRUE); crm_free(now_s); } } else if(command=='v') { CRM_DEV_ASSERT(type != NULL); CRM_DEV_ASSERT(attr_name != NULL); CRM_DEV_ASSERT(attr_value != NULL); rc = update_attr(the_cib, cib_opts, type, dest_node, set_name, attr_id, attr_name, attr_value, TRUE); } else /* query */ { char *read_value = NULL; rc = read_attr(the_cib, type, dest_node, set_name, attr_id, attr_name, &read_value, TRUE); if(rc == cib_NOTEXISTS && attr_default) { read_value = crm_strdup(attr_default); rc = cib_ok; } crm_info("Read %s=%s %s%s", attr_name, crm_str(read_value), set_name?"in ":"", set_name?set_name:""); if(rc == cib_missing_data) { rc = cib_ok; } else if(BE_QUIET == FALSE) { fprintf(stdout, "%s%s %s%s %s%s value=%s\n", type?"scope=":"", type?type:"", attr_id?"id=":"", attr_id?attr_id:"", attr_name?"name=":"", attr_name?attr_name:"", read_value?read_value:"(null)"); } else if(read_value != NULL) { fprintf(stdout, "%s\n", read_value); } } the_cib->cmds->signoff(the_cib); if(rc == cib_missing_data) { printf("Please choose from one of the matches above and suppy the 'id' with --attr-id\n"); } else if(rc != cib_ok) { fprintf(stderr, "Error performing operation: %s\n", cib_error2string(rc)); } return rc; }
static void bit_cursor(struct vc_data *vc, struct fb_info *info, int mode, int softback_lines, int fg, int bg) { struct fb_cursor cursor; struct fbcon_ops *ops = info->fbcon_par; unsigned short charmask = vc->vc_hi_font_mask ? 0x1ff : 0xff; int w = DIV_ROUND_UP(vc->vc_font.width, 8), c; int y = real_y(ops->p, vc->vc_y); int attribute, use_sw = (vc->vc_cursor_type & 0x10); int err = 1; char *src; cursor.set = 0; if (softback_lines) { if (y + softback_lines >= vc->vc_rows) { mode = CM_ERASE; ops->cursor_flash = 0; return; } else y += softback_lines; } c = scr_readw((u16 *) vc->vc_pos); attribute = get_attribute(info, c); src = vc->vc_font.data + ((c & charmask) * (w * vc->vc_font.height)); if (ops->cursor_state.image.data != src || ops->cursor_reset) { ops->cursor_state.image.data = src; cursor.set |= FB_CUR_SETIMAGE; } if (attribute) { u8 *dst; dst = kmalloc(w * vc->vc_font.height, GFP_ATOMIC); if (!dst) return; kfree(ops->cursor_data); ops->cursor_data = dst; update_attr(dst, src, attribute, vc); src = dst; } if (ops->cursor_state.image.fg_color != fg || ops->cursor_state.image.bg_color != bg || ops->cursor_reset) { ops->cursor_state.image.fg_color = fg; ops->cursor_state.image.bg_color = bg; cursor.set |= FB_CUR_SETCMAP; } if ((ops->cursor_state.image.dx != (vc->vc_font.width * vc->vc_x)) || (ops->cursor_state.image.dy != (vc->vc_font.height * y)) || ops->cursor_reset) { ops->cursor_state.image.dx = vc->vc_font.width * vc->vc_x; ops->cursor_state.image.dy = vc->vc_font.height * y; cursor.set |= FB_CUR_SETPOS; } if (ops->cursor_state.image.height != vc->vc_font.height || ops->cursor_state.image.width != vc->vc_font.width || ops->cursor_reset) { ops->cursor_state.image.height = vc->vc_font.height; ops->cursor_state.image.width = vc->vc_font.width; cursor.set |= FB_CUR_SETSIZE; } if (ops->cursor_state.hot.x || ops->cursor_state.hot.y || ops->cursor_reset) { ops->cursor_state.hot.x = cursor.hot.y = 0; cursor.set |= FB_CUR_SETHOT; } if (cursor.set & FB_CUR_SETSIZE || vc->vc_cursor_type != ops->p->cursor_shape || ops->cursor_state.mask == NULL || ops->cursor_reset) { char *mask = kmalloc(w*vc->vc_font.height, GFP_ATOMIC); int cur_height, size, i = 0; u8 msk = 0xff; if (!mask) return; kfree(ops->cursor_state.mask); ops->cursor_state.mask = mask; ops->p->cursor_shape = vc->vc_cursor_type; cursor.set |= FB_CUR_SETSHAPE; switch (ops->p->cursor_shape & CUR_HWMASK) { case CUR_NONE: cur_height = 0; break; case CUR_UNDERLINE: cur_height = (vc->vc_font.height < 10) ? 1 : 2; break; case CUR_LOWER_THIRD: cur_height = vc->vc_font.height/3; break; case CUR_LOWER_HALF: cur_height = vc->vc_font.height >> 1; break; case CUR_TWO_THIRDS: cur_height = (vc->vc_font.height << 1)/3; break; case CUR_BLOCK: default: cur_height = vc->vc_font.height; break; } size = (vc->vc_font.height - cur_height) * w; while (size--) mask[i++] = ~msk; size = cur_height * w; while (size--) mask[i++] = msk; }
/* DCノード開始処理 */ void do_dc_takeover(long long action, enum crmd_fsa_cause cause, enum crmd_fsa_state cur_state, enum crmd_fsa_input current_input, fsa_data_t *msg_data) { int rc = cib_ok; xmlNode *cib = NULL; static const char *cluster_type = NULL; if(cluster_type == NULL) { cluster_type = getenv("HA_cluster_type"); } if(cluster_type == NULL) { cluster_type = "Heartbeat"; } crm_info("Taking over DC status for this partition"); /* -------- ★★★★★★★★フラグ的な意味あいでの、DCノードはここでセット --------- */ set_bit_inplace(fsa_input_register, R_THE_DC); #if SUPPORT_AIS if(is_openais_cluster()) { send_ais_text(crm_class_quorum, NULL, TRUE, NULL, crm_msg_ais); } #endif if(voted != NULL) { /* votedハッシュテーブルを破棄する */ crm_debug_2("Destroying voted hash"); g_hash_table_destroy(voted); voted = NULL; } /* R_JOIN_OK, R_INVOKE_PEフラグセット */ set_bit_inplace(fsa_input_register, R_JOIN_OK); set_bit_inplace(fsa_input_register, R_INVOKE_PE); /* CIBのset_master処理を実行する */ fsa_cib_conn->cmds->set_master(fsa_cib_conn, cib_scope_local); /* 初期CIBのXMLを生成する */ cib = create_xml_node(NULL, XML_TAG_CIB); /* 生成したXMLにCRM_FEATURE_SETをセットする */ crm_xml_add(cib, XML_ATTR_CRM_VERSION, CRM_FEATURE_SET); /* CIBを生成した初期XMLで更新する */ fsa_cib_update(XML_TAG_CIB, cib, cib_quorum_override, rc); /* 更新コールバックをセットする */ add_cib_op_callback(fsa_cib_conn, rc, FALSE, NULL, feature_update_callback); /* CIBの"dc-version","cluster-infrastructure"属性を更新する */ update_attr(fsa_cib_conn, cib_none, XML_CIB_TAG_CRMCONFIG, NULL, NULL, NULL, "dc-version", VERSION"-"BUILD_VERSION, FALSE); update_attr(fsa_cib_conn, cib_none, XML_CIB_TAG_CRMCONFIG, NULL, NULL, NULL, "cluster-infrastructure", cluster_type, FALSE); /* config_readトリガーを叩く */ mainloop_set_trigger(config_read); free_xml(cib); }
static gboolean crmd_ais_dispatch(AIS_Message * wrapper, char *data, int sender) { int seq = 0; xmlNode *xml = NULL; const char *seq_s = NULL; xml = string2xml(data); if (xml == NULL) { crm_err("Could not parse message content (%d): %.100s", wrapper->header.id, data); return TRUE; } switch (wrapper->header.id) { case crm_class_members: seq_s = crm_element_value(xml, "id"); seq = crm_int_helper(seq_s, NULL); set_bit_inplace(fsa_input_register, R_PEER_DATA); post_cache_update(seq); /* fall through */ case crm_class_quorum: crm_update_quorum(crm_have_quorum, FALSE); if (AM_I_DC) { const char *votes = crm_element_value(xml, "expected"); if (votes == NULL || check_number(votes) == FALSE) { crm_log_xml_err(xml, "Invalid quorum/membership update"); } else { int rc = update_attr(fsa_cib_conn, cib_quorum_override | cib_scope_local | cib_inhibit_notify, XML_CIB_TAG_CRMCONFIG, NULL, NULL, NULL, NULL, XML_ATTR_EXPECTED_VOTES, votes, FALSE); crm_info("Setting expected votes to %s", votes); if (cib_ok > rc) { crm_err("Quorum update failed: %s", cib_error2string(rc)); } } } break; case crm_class_cluster: crm_xml_add(xml, F_ORIG, wrapper->sender.uname); crm_xml_add_int(xml, F_SEQ, wrapper->id); crmd_ha_msg_filter(xml); break; case crm_class_rmpeer: /* Ignore */ break; case crm_class_notify: case crm_class_nodeid: crm_err("Unexpected message class (%d): %.100s", wrapper->header.id, data); break; default: crm_err("Invalid message class (%d): %.100s", wrapper->header.id, data); } free_xml(xml); return TRUE; }
static int process_intf(struct distr_msg_hdr *hdr, const char *nodename, struct distr_msg_intf *intf, char *from) { char *intfname; int remaining, offset; uint32_t handle = 0; int parent = 0, level = 0, link = 0, index = 0; intf_t *local_intf; node_t *remote_node; intfname = ((char *) intf) + sizeof(*intf); if (c_debug) fprintf(stderr, "Processing interface %s (offset: %d " \ "optslen: %d namelen: %d hdrsize: %d)\n", intfname ? intfname : "null", ntohs(intf->i_offset), intf->i_optslen, intf->i_namelen, sizeof(*intf)); if (intf->i_namelen < 4 || intf->i_namelen > IFNAME_MAX) { if (c_debug) fprintf(stderr, "Discarding malformed packet (invalid namelen %d)\n", intf->i_namelen); return -1; } if ('\0' == *intfname) { if (c_debug) fprintf(stderr, "Discarding malformed packet (empty linkname)\n"); return -1; } index = ntohs(intf->i_index); if (intf->i_optslen) { offset = sizeof(*intf) + intf->i_namelen; remaining = intf->i_optslen; while (remaining > 0) { struct distr_msg_ifopt *opt; opt = (struct distr_msg_ifopt *) (((char *) intf) + offset); if (opt->io_len > (remaining - sizeof(*opt))) { if (c_debug) fprintf(stderr, "Discarding malformed packet (invalid opt len)\n"); return -1; } switch (opt->io_type) { case IFOPT_HANDLE: if (opt->io_len != sizeof(uint32_t)) { if (c_debug) fprintf(stderr, "Discarding malformed packet " \ "(invalid opt len for handle)\n"); return -1; } handle = ntohl(*(uint32_t *) (((char *) opt) + sizeof (*opt))); break; case IFOPT_PARENT: parent = ntohs(opt->io_pad); break; case IFOPT_LEVEL: level = ntohs(opt->io_pad); break; case IFOPT_LINK: link = ntohs(opt->io_pad); break; } remaining -= (sizeof(*opt) + opt->io_len); offset += (sizeof(*opt) + opt->io_len); } if (remaining < 0) if (c_debug) fprintf(stderr, "Leftover from options: %d\n", abs(remaining)); } remote_node = lookup_node(nodename, 1); if (NULL == remote_node) { if (c_debug) fprintf(stderr, "Could not create node entry for remote node\n"); return -1; } if (remote_node->n_from) xfree((void *) remote_node->n_from); remote_node->n_from = strdup(from); local_intf = lookup_intf(remote_node, intfname, handle, parent); if (NULL == local_intf) { if (c_debug) fprintf(stderr, "Could not crate interface for remote interface\n"); return -1; } offset = sizeof(*intf) + intf->i_optslen + intf->i_namelen; remaining = ntohs(intf->i_offset) - offset; while (remaining > 0) { struct distr_msg_attr *attr; attr = (struct distr_msg_attr *) (((char *) intf) + offset); if (c_debug) fprintf(stderr, "Attribute type %d %llu %llu\n", attr->a_type, attr->a_rx, attr->a_tx); if (attr->a_type >= ATTR_MAX) goto skip; if (attr->a_type == BYTES) { local_intf->i_rx_bytes.r_total = attr->a_rx; local_intf->i_tx_bytes.r_total = attr->a_tx; local_intf->i_rx_bytes.r_overflows = attr->a_rx_overflows; local_intf->i_tx_bytes.r_overflows = attr->a_tx_overflows; } else if (attr->a_type == PACKETS) { local_intf->i_rx_packets.r_total = attr->a_rx; local_intf->i_tx_packets.r_total = attr->a_tx; local_intf->i_rx_packets.r_overflows = attr->a_rx_overflows; local_intf->i_tx_packets.r_overflows = attr->a_tx_overflows; } else { int flags = (attr->a_flags & ATTR_RX_PROVIDED ? RX_PROVIDED : 0) | (attr->a_flags & ATTR_TX_PROVIDED ? TX_PROVIDED : 0); update_attr(local_intf, attr->a_type, attr->a_rx, attr->a_tx, flags); } skip: remaining -= sizeof(*attr); offset += sizeof(*attr); } if (intf->i_flags & IF_IS_CHILD) local_intf->i_is_child = 1; local_intf->i_level = level; local_intf->i_link = link; notify_update(local_intf); increase_lifetime(local_intf, 1); if (remaining < 0) if (c_debug) fprintf(stderr, "Leftover from attributes: %d\n", abs(remaining)); return 0; }
static void sysctl_read(void) { int mib[] = {CTL_NET, PF_ROUTE, 0, 0, NET_RT_IFLIST, 0}; size_t n; char *buf, *next, *lim; if (sysctl(mib, 6, NULL, &n, NULL, 0) < 0) quit("sysctl() failed"); if (c_debug) fprintf(stderr, "sysctl 1-pass n=%d\n", (int) n); buf = xcalloc(1, n); if (sysctl(mib, 6, buf, &n, NULL, 0) < 0) quit("sysctl() failed"); if (c_debug) fprintf(stderr, "sysctl 2-pass n=%d\n", (int) n); lim = buf + n; next = buf; while (next < lim) { char ifname[IFNAME_MAX]; int iflen = sizeof(ifname) - 1; struct if_msghdr *ifm, *nextifm; struct sockaddr_dl *sdl; struct item *it; memset(ifname, 0, sizeof(ifname)); ifm = (struct if_msghdr *) next; if (ifm->ifm_type != RTM_IFINFO) break; next += ifm->ifm_msglen; while (next < lim) { nextifm = (struct if_msghdr *) next; if (nextifm->ifm_type != RTM_NEWADDR) break; next += nextifm->ifm_msglen; } sdl = (struct sockaddr_dl *) (ifm + 1); if (sdl->sdl_family != AF_LINK) continue; if (cfg_show_only_running && !(ifm->ifm_flags & IFF_UP)) continue; if (iflen > sd->sdl_nlen) iflen = sdl->sdl_nlen; memcpy(ifname, sdl->sdl_data, iflen); if (c_debug) fprintf(stderr, "Processing %s\n", ifname); it = lookup_item(get_local_node(), ifname, 0, 0); if (it == NULL) continue; set_item_attrs(it, ATTR(BYTES), ATTR(PACKETS), ATTR(BYTES)); update_attr(it, ATTR(PACKETS), ifm->ifm_data.ifi_ipackets, ifm->ifm_data.ifi_opackets, RX_PROVIDED | TX_PROVIDED); update_attr(it, ATTR(BYTES), ifm->ifm_data.ifi_ibytes, ifm->ifm_data.ifi_obytes, RX_PROVIDED | TX_PROVIDED); update_attr(it, ATTR(ERRORS), ifm->ifm_data.ifi_ierrors, ifm->ifm_data.ifi_oerrors, RX_PROVIDED | TX_PROVIDED); update_attr(it, ATTR(COLLISIONS), 0, ifm->ifm_data.ifi_collisions, TX_PROVIDED); update_attr(it, ATTR(MULTICAST), ifm->ifm_data.ifi_imcasts, 0, RX_PROVIDED); update_attr(it, ATTR(DROP), 0, ifm->ifm_data.ifi_iqdrops, TX_PROVIDED); notify_update(it, NULL); increase_lifetime(it, 1); } xfree(buf); }
static void kstat_do_read(void) { kstat_ctl_t * kc; kstat_t * kst; kstat_named_t * kn, *kn2; intf_t * i; if (!(kc = kstat_open())) quit("kstat_open() failed"); if ((kst = kstat_lookup(kc, NULL, -1, NULL))) { for (; kst; kst = kst->ks_next) { if (strcmp(kst->ks_class, "net")) continue; if (kstat_read(kc, kst, NULL) < 0) continue; if (!strcmp(kst->ks_name, "zero_copy")) continue; i = lookup_intf(get_local_node(), kst->ks_name, 0, 0); if (NULL == i) continue; #define KSTAT_GET(S) (kstat_named_t *) kstat_data_lookup(kst, #S) if ((kn = KSTAT_GET(rbytes64))) { i->i_rx_bytes.r_total = kn->value.ui64; i->i_rx_bytes.r_is64bit = 1; } else if ((kn = KSTAT_GET(rbytes))) i->i_rx_bytes.r_total = kn->value.ui32; if ((kn = KSTAT_GET(ipackets64))) { i->i_rx_packets.r_total = kn->value.ui64; i->i_rx_packets.r_is64bit = 1; } else if ((kn = KSTAT_GET(ipackets))) i->i_rx_packets.r_total = kn->value.ui32; if ((kn = KSTAT_GET(obytes64))) i->i_tx_bytes.r_total = kn->value.ui64; else if ((kn = KSTAT_GET(obytes))) i->i_tx_bytes.r_total = kn->value.ui32; if ((kn = KSTAT_GET(opackets64))) i->i_tx_packets.r_total = kn->value.ui64; else if ((kn = KSTAT_GET(opackets))) i->i_tx_packets.r_total = kn->value.ui32; if ((kn = KSTAT_GET(ierror)) && (kn2 = KSTAT_GET(oerrors))) update_attr(i, ERRORS, kn->value.ui32, kn2->value.ui32, RX_PROVIDED | TX_PROVIDED); if ((kn = KSTAT_GET(multircv64)) && (kn2 = KSTAT_GET(multixmt64))) update_attr(i, MULTICAST, kn->value.ui64, kn2->value.ui64, RX_PROVIDED | TX_PROVIDED); else if ((kn = KSTAT_GET(multircv)) && (kn2 = KSTAT_GET(multixmt))) update_attr(i, MULTICAST, kn->value.ui32, kn2->value.ui32, RX_PROVIDED | TX_PROVIDED); if ((kn = KSTAT_GET(brdcstrcv)) && (kn2 = KSTAT_GET(brdcstxmt))) update_attr(i, BROADCAST, kn->value.ui32, kn2->value.ui32, RX_PROVIDED | TX_PROVIDED); #undef KSTAT_GET notify_update(i); increase_lifetime(i, 1); } } kstat_close(kc); }