hollalinux
/
linux-sg2042
mirror of https://github.com/sophgo/linux-riscv.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'tipc_net-next' of git://git.kernel.org/pub/scm/linux/kernel/git/paulg/linux 

Paul Gortmaker says:

====================
This is the same eight commits as sent for review last week[1],
with just the incorporation of the pr_fmt change as suggested
by JoeP.  There was no additional change requests, so unless you
can see something else you'd like me to change, please pull.
 ...
Erik Hugne (5):
      tipc: use standard printk shortcut macros (pr_err etc.)
      tipc: remove TIPC packet debugging functions and macros
      tipc: simplify print buffer handling in tipc_printf
      tipc: phase out most of the struct print_buf usage
      tipc: remove print_buf and deprecated log buffer code

Paul Gortmaker (3):
      tipc: factor stats struct out of the larger link struct
      tipc: limit error messages relating to memory leak to one line
      tipc: simplify link_print by divorcing it from using tipc_printf
====================

Signed-off-by: David S. Miller <davem@davemloft.net>
This commit is contained in:
David S. Miller 2012-07-16 22:33:32 -07:00
parent 51d7cccf07 869dd4662f
commit 07689b0a5c
25 changed files with 439 additions and 1126 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
include/linux/tipc_config.h
View File

@ -102,8 +102,8 @@
#define TIPC_CMD_SET_LINK_TOL 0x4107 /* tx link_config, rx none */ #define TIPC_CMD_SET_LINK_TOL 0x4107 /* tx link_config, rx none */
#define TIPC_CMD_SET_LINK_PRI 0x4108 /* tx link_config, rx none */ #define TIPC_CMD_SET_LINK_PRI 0x4108 /* tx link_config, rx none */
#define TIPC_CMD_SET_LINK_WINDOW 0x4109 /* tx link_config, rx none */ #define TIPC_CMD_SET_LINK_WINDOW 0x4109 /* tx link_config, rx none */
#define TIPC_CMD_SET_LOG_SIZE 0x410A /* tx unsigned, rx none */ #define TIPC_CMD_SET_LOG_SIZE 0x410A /* obsoleted */
#define TIPC_CMD_DUMP_LOG 0x410B /* tx none, rx ultra_string */ #define TIPC_CMD_DUMP_LOG 0x410B /* obsoleted */
#define TIPC_CMD_RESET_LINK_STATS 0x410C /* tx link_name, rx none */ #define TIPC_CMD_RESET_LINK_STATS 0x410C /* tx link_name, rx none */
/* /*

25
net/tipc/Kconfig
View File

@ -41,29 +41,4 @@ config TIPC_PORTS
Setting this to a smaller value saves some memory, Setting this to a smaller value saves some memory,
setting it to higher allows for more ports. setting it to higher allows for more ports.
config TIPC_LOG
int "Size of log buffer"
depends on TIPC_ADVANCED
range 0 32768
default "0"
help
Size (in bytes) of TIPC's internal log buffer, which records the
occurrence of significant events. Can range from 0 to 32768 bytes;
default is 0.
There is no need to enable the log buffer unless the node will be
managed remotely via TIPC.
config TIPC_DEBUG
bool "Enable debugging support"
default n
help
Saying Y here enables TIPC debugging capabilities used by developers.
Most users do not need to bother; if unsure, just say N.
Enabling debugging support causes TIPC to display data about its
internal state when certain abnormal conditions occur. It also
makes it easy for developers to capture additional information of
interest using the dbg() or msg_dbg() macros.
endif # TIPC endif # TIPC

65
net/tipc/bcast.c
View File

@ -701,48 +701,43 @@ void tipc_bcbearer_sort(void)
int tipc_bclink_stats(char *buf, const u32 buf_size) int tipc_bclink_stats(char *buf, const u32 buf_size)
{ {
struct print_buf pb; int ret;
struct tipc_stats *s;
if (!bcl) if (!bcl)
return 0; return 0;
tipc_printbuf_init(&pb, buf, buf_size);
spin_lock_bh(&bc_lock); spin_lock_bh(&bc_lock);
tipc_printf(&pb, "Link <%s>\n" s = &bcl->stats;
" Window:%u packets\n",
bcl->name, bcl->queue_limit[0]); ret = tipc_snprintf(buf, buf_size, "Link <%s>\n"
tipc_printf(&pb, " RX packets:%u fragments:%u/%u bundles:%u/%u\n", " Window:%u packets\n",
bcl->stats.recv_info, bcl->name, bcl->queue_limit[0]);
bcl->stats.recv_fragments, ret += tipc_snprintf(buf + ret, buf_size - ret,
bcl->stats.recv_fragmented, " RX packets:%u fragments:%u/%u bundles:%u/%u\n",
bcl->stats.recv_bundles, s->recv_info, s->recv_fragments,
bcl->stats.recv_bundled); s->recv_fragmented, s->recv_bundles,
tipc_printf(&pb, " TX packets:%u fragments:%u/%u bundles:%u/%u\n", s->recv_bundled);
bcl->stats.sent_info, ret += tipc_snprintf(buf + ret, buf_size - ret,
bcl->stats.sent_fragments, " TX packets:%u fragments:%u/%u bundles:%u/%u\n",
bcl->stats.sent_fragmented, s->sent_info, s->sent_fragments,
bcl->stats.sent_bundles, s->sent_fragmented, s->sent_bundles,
bcl->stats.sent_bundled); s->sent_bundled);
tipc_printf(&pb, " RX naks:%u defs:%u dups:%u\n", ret += tipc_snprintf(buf + ret, buf_size - ret,
bcl->stats.recv_nacks, " RX naks:%u defs:%u dups:%u\n",
bcl->stats.deferred_recv, s->recv_nacks, s->deferred_recv, s->duplicates);
bcl->stats.duplicates); ret += tipc_snprintf(buf + ret, buf_size - ret,
tipc_printf(&pb, " TX naks:%u acks:%u dups:%u\n", " TX naks:%u acks:%u dups:%u\n",
bcl->stats.sent_nacks, s->sent_nacks, s->sent_acks, s->retransmitted);
bcl->stats.sent_acks, ret += tipc_snprintf(buf + ret, buf_size - ret,
bcl->stats.retransmitted); " Congestion bearer:%u link:%u Send queue max:%u avg:%u\n",
tipc_printf(&pb, " Congestion bearer:%u link:%u Send queue max:%u avg:%u\n", s->bearer_congs, s->link_congs, s->max_queue_sz,
bcl->stats.bearer_congs, s->queue_sz_counts ?
bcl->stats.link_congs, (s->accu_queue_sz / s->queue_sz_counts) : 0);
bcl->stats.max_queue_sz,
bcl->stats.queue_sz_counts
? (bcl->stats.accu_queue_sz / bcl->stats.queue_sz_counts)
: 0);
spin_unlock_bh(&bc_lock); spin_unlock_bh(&bc_lock);
return tipc_printbuf_validate(&pb); return ret;
} }
int tipc_bclink_reset_stats(void) int tipc_bclink_reset_stats(void)
@ -880,7 +875,7 @@ void tipc_port_list_add(struct tipc_port_list *pl_ptr, u32 port)
if (!item->next) { if (!item->next) {
item->next = kmalloc(sizeof(*item), GFP_ATOMIC); item->next = kmalloc(sizeof(*item), GFP_ATOMIC);
if (!item->next) { if (!item->next) {
warn("Incomplete multicast delivery, no memory\n"); pr_warn("Incomplete multicast delivery, no memory\n");
return; return;
} }
item->next->next = NULL; item->next->next = NULL;

62
net/tipc/bearer.c
View File

@ -123,28 +123,30 @@ int tipc_register_media(struct tipc_media *m_ptr)
exit: exit:
write_unlock_bh(&tipc_net_lock); write_unlock_bh(&tipc_net_lock);
if (res) if (res)
warn("Media <%s> registration error\n", m_ptr->name); pr_warn("Media <%s> registration error\n", m_ptr->name);
return res; return res;
} }
/** /**
* tipc_media_addr_printf - record media address in print buffer * tipc_media_addr_printf - record media address in print buffer
*/ */
void tipc_media_addr_printf(struct print_buf *pb, struct tipc_media_addr *a) void tipc_media_addr_printf(char *buf, int len, struct tipc_media_addr *a)
{ {
char addr_str[MAX_ADDR_STR]; char addr_str[MAX_ADDR_STR];
struct tipc_media *m_ptr; struct tipc_media *m_ptr;
int ret;
m_ptr = media_find_id(a->media_id); m_ptr = media_find_id(a->media_id);
if (m_ptr && !m_ptr->addr2str(a, addr_str, sizeof(addr_str))) if (m_ptr && !m_ptr->addr2str(a, addr_str, sizeof(addr_str)))
tipc_printf(pb, "%s(%s)", m_ptr->name, addr_str); ret = tipc_snprintf(buf, len, "%s(%s)", m_ptr->name, addr_str);
else { else {
u32 i; u32 i;
tipc_printf(pb, "UNKNOWN(%u)", a->media_id); ret = tipc_snprintf(buf, len, "UNKNOWN(%u)", a->media_id);
for (i = 0; i < sizeof(a->value); i++) for (i = 0; i < sizeof(a->value); i++)
tipc_printf(pb, "-%02x", a->value[i]); ret += tipc_snprintf(buf - ret, len + ret,
"-%02x", a->value[i]);
} }
} }
@ -418,12 +420,12 @@ int tipc_enable_bearer(const char *name, u32 disc_domain, u32 priority)
int res = -EINVAL; int res = -EINVAL;
if (!tipc_own_addr) { if (!tipc_own_addr) {
warn("Bearer <%s> rejected, not supported in standalone mode\n", pr_warn("Bearer <%s> rejected, not supported in standalone mode\n",
name); name);
return -ENOPROTOOPT; return -ENOPROTOOPT;
} }
if (!bearer_name_validate(name, &b_names)) { if (!bearer_name_validate(name, &b_names)) {
warn("Bearer <%s> rejected, illegal name\n", name); pr_warn("Bearer <%s> rejected, illegal name\n", name);
return -EINVAL; return -EINVAL;
} }
if (tipc_addr_domain_valid(disc_domain) && if (tipc_addr_domain_valid(disc_domain) &&
@ -435,12 +437,13 @@ int tipc_enable_bearer(const char *name, u32 disc_domain, u32 priority)
res = 0; /* accept specified node in own cluster */ res = 0; /* accept specified node in own cluster */
} }
if (res) { if (res) {
warn("Bearer <%s> rejected, illegal discovery domain\n", name); pr_warn("Bearer <%s> rejected, illegal discovery domain\n",
name);
return -EINVAL; return -EINVAL;
} }
if ((priority > TIPC_MAX_LINK_PRI) && if ((priority > TIPC_MAX_LINK_PRI) &&
(priority != TIPC_MEDIA_LINK_PRI)) { (priority != TIPC_MEDIA_LINK_PRI)) {
warn("Bearer <%s> rejected, illegal priority\n", name); pr_warn("Bearer <%s> rejected, illegal priority\n", name);
return -EINVAL; return -EINVAL;
} }
@ -448,8 +451,8 @@ int tipc_enable_bearer(const char *name, u32 disc_domain, u32 priority)
m_ptr = tipc_media_find(b_names.media_name); m_ptr = tipc_media_find(b_names.media_name);
if (!m_ptr) { if (!m_ptr) {
warn("Bearer <%s> rejected, media <%s> not registered\n", name, pr_warn("Bearer <%s> rejected, media <%s> not registered\n",
b_names.media_name); name, b_names.media_name);
goto exit; goto exit;
} }
@ -465,24 +468,25 @@ restart:
continue; continue;
} }
if (!strcmp(name, tipc_bearers[i].name)) { if (!strcmp(name, tipc_bearers[i].name)) {
warn("Bearer <%s> rejected, already enabled\n", name); pr_warn("Bearer <%s> rejected, already enabled\n",
name);
goto exit; goto exit;
} }
if ((tipc_bearers[i].priority == priority) && if ((tipc_bearers[i].priority == priority) &&
(++with_this_prio > 2)) { (++with_this_prio > 2)) {
if (priority-- == 0) { if (priority-- == 0) {
warn("Bearer <%s> rejected, duplicate priority\n", pr_warn("Bearer <%s> rejected, duplicate priority\n",
name); name);
goto exit; goto exit;
} }
warn("Bearer <%s> priority adjustment required %u->%u\n", pr_warn("Bearer <%s> priority adjustment required %u->%u\n",
name, priority + 1, priority); name, priority + 1, priority);
goto restart; goto restart;
} }
} }
if (bearer_id >= MAX_BEARERS) { if (bearer_id >= MAX_BEARERS) {
warn("Bearer <%s> rejected, bearer limit reached (%u)\n", pr_warn("Bearer <%s> rejected, bearer limit reached (%u)\n",
name, MAX_BEARERS); name, MAX_BEARERS);
goto exit; goto exit;
} }
@ -490,7 +494,8 @@ restart:
strcpy(b_ptr->name, name); strcpy(b_ptr->name, name);
res = m_ptr->enable_bearer(b_ptr); res = m_ptr->enable_bearer(b_ptr);
if (res) { if (res) {
warn("Bearer <%s> rejected, enable failure (%d)\n", name, -res); pr_warn("Bearer <%s> rejected, enable failure (%d)\n",
name, -res);
goto exit; goto exit;
} }
@ -508,12 +513,13 @@ restart:
res = tipc_disc_create(b_ptr, &m_ptr->bcast_addr, disc_domain); res = tipc_disc_create(b_ptr, &m_ptr->bcast_addr, disc_domain);
if (res) { if (res) {
bearer_disable(b_ptr); bearer_disable(b_ptr);
warn("Bearer <%s> rejected, discovery object creation failed\n", pr_warn("Bearer <%s> rejected, discovery object creation failed\n",
name); name);
goto exit; goto exit;
} }
info("Enabled bearer <%s>, discovery domain %s, priority %u\n", pr_info("Enabled bearer <%s>, discovery domain %s, priority %u\n",
name, tipc_addr_string_fill(addr_string, disc_domain), priority); name,
tipc_addr_string_fill(addr_string, disc_domain), priority);
exit: exit:
write_unlock_bh(&tipc_net_lock); write_unlock_bh(&tipc_net_lock);
return res; return res;
@ -531,12 +537,12 @@ int tipc_block_bearer(const char *name)
read_lock_bh(&tipc_net_lock); read_lock_bh(&tipc_net_lock);
b_ptr = tipc_bearer_find(name); b_ptr = tipc_bearer_find(name);
if (!b_ptr) { if (!b_ptr) {
warn("Attempt to block unknown bearer <%s>\n", name); pr_warn("Attempt to block unknown bearer <%s>\n", name);
read_unlock_bh(&tipc_net_lock); read_unlock_bh(&tipc_net_lock);
return -EINVAL; return -EINVAL;
} }
info("Blocking bearer <%s>\n", name); pr_info("Blocking bearer <%s>\n", name);
spin_lock_bh(&b_ptr->lock); spin_lock_bh(&b_ptr->lock);
b_ptr->blocked = 1; b_ptr->blocked = 1;
list_splice_init(&b_ptr->cong_links, &b_ptr->links); list_splice_init(&b_ptr->cong_links, &b_ptr->links);
@ -562,7 +568,7 @@ static void bearer_disable(struct tipc_bearer *b_ptr)
struct tipc_link *l_ptr; struct tipc_link *l_ptr;
struct tipc_link *temp_l_ptr; struct tipc_link *temp_l_ptr;
info("Disabling bearer <%s>\n", b_ptr->name); pr_info("Disabling bearer <%s>\n", b_ptr->name);
spin_lock_bh(&b_ptr->lock); spin_lock_bh(&b_ptr->lock);
b_ptr->blocked = 1; b_ptr->blocked = 1;
b_ptr->media->disable_bearer(b_ptr); b_ptr->media->disable_bearer(b_ptr);
@ -584,7 +590,7 @@ int tipc_disable_bearer(const char *name)
write_lock_bh(&tipc_net_lock); write_lock_bh(&tipc_net_lock);
b_ptr = tipc_bearer_find(name); b_ptr = tipc_bearer_find(name);
if (b_ptr == NULL) { if (b_ptr == NULL) {
warn("Attempt to disable unknown bearer <%s>\n", name); pr_warn("Attempt to disable unknown bearer <%s>\n", name);
res = -EINVAL; res = -EINVAL;
} else { } else {
bearer_disable(b_ptr); bearer_disable(b_ptr);

2
net/tipc/bearer.h
View File

@ -179,7 +179,7 @@ void tipc_eth_media_stop(void);
int tipc_media_set_priority(const char *name, u32 new_value); int tipc_media_set_priority(const char *name, u32 new_value);
int tipc_media_set_window(const char *name, u32 new_value); int tipc_media_set_window(const char *name, u32 new_value);
void tipc_media_addr_printf(struct print_buf *pb, struct tipc_media_addr *a); void tipc_media_addr_printf(char *buf, int len, struct tipc_media_addr *a);
struct sk_buff *tipc_media_get_names(void); struct sk_buff *tipc_media_get_names(void);
struct sk_buff *tipc_bearer_get_names(void); struct sk_buff *tipc_bearer_get_names(void);

41
net/tipc/config.c
View File

@ -39,6 +39,8 @@
#include "name_table.h" #include "name_table.h"
#include "config.h" #include "config.h"
#define REPLY_TRUNCATED "<truncated>\n"
static u32 config_port_ref; static u32 config_port_ref;
static DEFINE_SPINLOCK(config_lock); static DEFINE_SPINLOCK(config_lock);
@ -104,13 +106,12 @@ struct sk_buff *tipc_cfg_reply_string_type(u16 tlv_type, char *string)
return buf; return buf;
} }
#define MAX_STATS_INFO 2000
static struct sk_buff *tipc_show_stats(void) static struct sk_buff *tipc_show_stats(void)
{ {
struct sk_buff *buf; struct sk_buff *buf;
struct tlv_desc *rep_tlv; struct tlv_desc *rep_tlv;
struct print_buf pb; char *pb;
int pb_len;
int str_len; int str_len;
u32 value; u32 value;
@ -121,17 +122,16 @@ static struct sk_buff *tipc_show_stats(void)
if (value != 0) if (value != 0)
return tipc_cfg_reply_error_string("unsupported argument"); return tipc_cfg_reply_error_string("unsupported argument");
buf = tipc_cfg_reply_alloc(TLV_SPACE(MAX_STATS_INFO)); buf = tipc_cfg_reply_alloc(TLV_SPACE(ULTRA_STRING_MAX_LEN));
if (buf == NULL) if (buf == NULL)
return NULL; return NULL;
rep_tlv = (struct tlv_desc *)buf->data; rep_tlv = (struct tlv_desc *)buf->data;
tipc_printbuf_init(&pb, (char *)TLV_DATA(rep_tlv), MAX_STATS_INFO); pb = TLV_DATA(rep_tlv);
pb_len = ULTRA_STRING_MAX_LEN;
tipc_printf(&pb, "TIPC version " TIPC_MOD_VER "\n"); str_len = tipc_snprintf(pb, pb_len, "TIPC version " TIPC_MOD_VER "\n");
str_len += 1; /* for "\0" */
/* Use additional tipc_printf()'s to return more info ... */
str_len = tipc_printbuf_validate(&pb);
skb_put(buf, TLV_SPACE(str_len)); skb_put(buf, TLV_SPACE(str_len));
TLV_SET(rep_tlv, TIPC_TLV_ULTRA_STRING, NULL, str_len); TLV_SET(rep_tlv, TIPC_TLV_ULTRA_STRING, NULL, str_len);
@ -334,12 +334,6 @@ struct sk_buff *tipc_cfg_do_cmd(u32 orig_node, u16 cmd, const void *request_area
case TIPC_CMD_SHOW_PORTS: case TIPC_CMD_SHOW_PORTS:
rep_tlv_buf = tipc_port_get_ports(); rep_tlv_buf = tipc_port_get_ports();
break; break;
case TIPC_CMD_SET_LOG_SIZE:
rep_tlv_buf = tipc_log_resize_cmd(req_tlv_area, req_tlv_space);
break;
case TIPC_CMD_DUMP_LOG:
rep_tlv_buf = tipc_log_dump();
break;
case TIPC_CMD_SHOW_STATS: case TIPC_CMD_SHOW_STATS:
rep_tlv_buf = tipc_show_stats(); rep_tlv_buf = tipc_show_stats();
break; break;
@ -399,6 +393,8 @@ struct sk_buff *tipc_cfg_do_cmd(u32 orig_node, u16 cmd, const void *request_area
case TIPC_CMD_GET_MAX_CLUSTERS: case TIPC_CMD_GET_MAX_CLUSTERS:
case TIPC_CMD_SET_MAX_NODES: case TIPC_CMD_SET_MAX_NODES:
case TIPC_CMD_GET_MAX_NODES: case TIPC_CMD_GET_MAX_NODES:
case TIPC_CMD_SET_LOG_SIZE:
case TIPC_CMD_DUMP_LOG:
rep_tlv_buf = tipc_cfg_reply_error_string(TIPC_CFG_NOT_SUPPORTED rep_tlv_buf = tipc_cfg_reply_error_string(TIPC_CFG_NOT_SUPPORTED
" (obsolete command)"); " (obsolete command)");
break; break;
@ -408,6 +404,15 @@ struct sk_buff *tipc_cfg_do_cmd(u32 orig_node, u16 cmd, const void *request_area
break; break;
} }
WARN_ON(rep_tlv_buf->len > TLV_SPACE(ULTRA_STRING_MAX_LEN));
/* Append an error message if we cannot return all requested data */
if (rep_tlv_buf->len == TLV_SPACE(ULTRA_STRING_MAX_LEN)) {
if (*(rep_tlv_buf->data + ULTRA_STRING_MAX_LEN) != '\0')
sprintf(rep_tlv_buf->data + rep_tlv_buf->len -
sizeof(REPLY_TRUNCATED) - 1, REPLY_TRUNCATED);
}
/* Return reply buffer */ /* Return reply buffer */
exit: exit:
spin_unlock_bh(&config_lock); spin_unlock_bh(&config_lock);
@ -432,7 +437,7 @@ static void cfg_named_msg_event(void *userdata,
if ((size < sizeof(*req_hdr)) || if ((size < sizeof(*req_hdr)) ||
(size != TCM_ALIGN(ntohl(req_hdr->tcm_len))) || (size != TCM_ALIGN(ntohl(req_hdr->tcm_len))) ||
(ntohs(req_hdr->tcm_flags) != TCM_F_REQUEST)) { (ntohs(req_hdr->tcm_flags) != TCM_F_REQUEST)) {
warn("Invalid configuration message discarded\n"); pr_warn("Invalid configuration message discarded\n");
return; return;
} }
@ -478,7 +483,7 @@ int tipc_cfg_init(void)
return 0; return 0;
failed: failed:
err("Unable to create configuration service\n"); pr_err("Unable to create configuration service\n");
return res; return res;
} }
@ -494,7 +499,7 @@ void tipc_cfg_reinit(void)
seq.lower = seq.upper = tipc_own_addr; seq.lower = seq.upper = tipc_own_addr;
res = tipc_publish(config_port_ref, TIPC_ZONE_SCOPE, &seq); res = tipc_publish(config_port_ref, TIPC_ZONE_SCOPE, &seq);
if (res) if (res)
err("Unable to reinitialize configuration service\n"); pr_err("Unable to reinitialize configuration service\n");
} }
void tipc_cfg_stop(void) void tipc_cfg_stop(void)

18
net/tipc/core.c
View File

@ -34,22 +34,18 @@
* POSSIBILITY OF SUCH DAMAGE. * POSSIBILITY OF SUCH DAMAGE.
*/ */
#include <linux/module.h>
#include "core.h" #include "core.h"
#include "ref.h" #include "ref.h"
#include "name_table.h" #include "name_table.h"
#include "subscr.h" #include "subscr.h"
#include "config.h" #include "config.h"
#include <linux/module.h>
#ifndef CONFIG_TIPC_PORTS #ifndef CONFIG_TIPC_PORTS
#define CONFIG_TIPC_PORTS 8191 #define CONFIG_TIPC_PORTS 8191
#endif #endif
#ifndef CONFIG_TIPC_LOG
#define CONFIG_TIPC_LOG 0
#endif
/* global variables used by multiple sub-systems within TIPC */ /* global variables used by multiple sub-systems within TIPC */
int tipc_random; int tipc_random;
@ -125,7 +121,6 @@ static void tipc_core_stop(void)
tipc_nametbl_stop(); tipc_nametbl_stop();
tipc_ref_table_stop(); tipc_ref_table_stop();
tipc_socket_stop(); tipc_socket_stop();
tipc_log_resize(0);
} }
/** /**
@ -161,10 +156,7 @@ static int __init tipc_init(void)
{ {
int res; int res;
if (tipc_log_resize(CONFIG_TIPC_LOG) != 0) pr_info("Activated (version " TIPC_MOD_VER ")\n");
warn("Unable to create log buffer\n");
info("Activated (version " TIPC_MOD_VER ")\n");
tipc_own_addr = 0; tipc_own_addr = 0;
tipc_remote_management = 1; tipc_remote_management = 1;
@ -175,9 +167,9 @@ static int __init tipc_init(void)
res = tipc_core_start(); res = tipc_core_start();
if (res) if (res)
err("Unable to start in single node mode\n"); pr_err("Unable to start in single node mode\n");
else else
info("Started in single node mode\n"); pr_info("Started in single node mode\n");
return res; return res;
} }
@ -185,7 +177,7 @@ static void __exit tipc_exit(void)
{ {
tipc_core_stop_net(); tipc_core_stop_net();
tipc_core_stop(); tipc_core_stop();
info("Deactivated\n"); pr_info("Deactivated\n");
} }
module_init(tipc_init); module_init(tipc_init);

65
net/tipc/core.h
View File

@ -37,6 +37,8 @@
#ifndef _TIPC_CORE_H #ifndef _TIPC_CORE_H
#define _TIPC_CORE_H #define _TIPC_CORE_H
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
#include <linux/tipc.h> #include <linux/tipc.h>
#include <linux/tipc_config.h> #include <linux/tipc_config.h>
#include <linux/types.h> #include <linux/types.h>
@ -58,68 +60,11 @@
#define TIPC_MOD_VER "2.0.0" #define TIPC_MOD_VER "2.0.0"
#define ULTRA_STRING_MAX_LEN 32768
struct tipc_msg; /* msg.h */ struct tipc_msg; /* msg.h */
struct print_buf; /* log.h */
/*
* TIPC system monitoring code
*/
/*
* TIPC's print buffer subsystem supports the following print buffers:
*
* TIPC_NULL : null buffer (i.e. print nowhere)
* TIPC_CONS : system console
* TIPC_LOG : TIPC log buffer
* &buf : user-defined buffer (struct print_buf *)
*
* Note: TIPC_LOG is configured to echo its output to the system console;
* user-defined buffers can be configured to do the same thing.
*/
extern struct print_buf *const TIPC_NULL;
extern struct print_buf *const TIPC_CONS;
extern struct print_buf *const TIPC_LOG;
void tipc_printf(struct print_buf *, const char *fmt, ...);
/*
* TIPC_OUTPUT is the destination print buffer for system messages.
*/
#ifndef TIPC_OUTPUT
#define TIPC_OUTPUT TIPC_LOG
#endif
#define err(fmt, arg...) tipc_printf(TIPC_OUTPUT, \
KERN_ERR "TIPC: " fmt, ## arg)
#define warn(fmt, arg...) tipc_printf(TIPC_OUTPUT, \
KERN_WARNING "TIPC: " fmt, ## arg)
#define info(fmt, arg...) tipc_printf(TIPC_OUTPUT, \
KERN_NOTICE "TIPC: " fmt, ## arg)
#ifdef CONFIG_TIPC_DEBUG
/*
* DBG_OUTPUT is the destination print buffer for debug messages.
*/
#ifndef DBG_OUTPUT
#define DBG_OUTPUT TIPC_LOG
#endif
#define dbg(fmt, arg...) tipc_printf(DBG_OUTPUT, KERN_DEBUG fmt, ## arg);
#define msg_dbg(msg, txt) tipc_msg_dbg(DBG_OUTPUT, msg, txt);
void tipc_msg_dbg(struct print_buf *, struct tipc_msg *, const char *);
#else
#define dbg(fmt, arg...) do {} while (0)
#define msg_dbg(msg, txt) do {} while (0)
#define tipc_msg_dbg(buf, msg, txt) do {} while (0)
#endif
int tipc_snprintf(char *buf, int len, const char *fmt, ...);
/* /*
* TIPC-specific error codes * TIPC-specific error codes

10
net/tipc/discover.c
View File

@ -100,14 +100,12 @@ static void disc_dupl_alert(struct tipc_bearer *b_ptr, u32 node_addr,
{ {
char node_addr_str[16]; char node_addr_str[16];
char media_addr_str[64]; char media_addr_str[64];
struct print_buf pb;
tipc_addr_string_fill(node_addr_str, node_addr); tipc_addr_string_fill(node_addr_str, node_addr);
tipc_printbuf_init(&pb, media_addr_str, sizeof(media_addr_str)); tipc_media_addr_printf(media_addr_str, sizeof(media_addr_str),
tipc_media_addr_printf(&pb, media_addr); media_addr);
tipc_printbuf_validate(&pb); pr_warn("Duplicate %s using %s seen on <%s>\n", node_addr_str,
warn("Duplicate %s using %s seen on <%s>\n", media_addr_str, b_ptr->name);
node_addr_str, media_addr_str, b_ptr->name);
} }
/** /**

4
net/tipc/handler.c
View File

@ -57,14 +57,14 @@ unsigned int tipc_k_signal(Handler routine, unsigned long argument)
struct queue_item *item; struct queue_item *item;
if (!handler_enabled) { if (!handler_enabled) {
err("Signal request ignored by handler\n"); pr_err("Signal request ignored by handler\n");
return -ENOPROTOOPT; return -ENOPROTOOPT;
} }
spin_lock_bh(&qitem_lock); spin_lock_bh(&qitem_lock);
item = kmem_cache_alloc(tipc_queue_item_cache, GFP_ATOMIC); item = kmem_cache_alloc(tipc_queue_item_cache, GFP_ATOMIC);
if (!item) { if (!item) {
err("Signal queue out of memory\n"); pr_err("Signal queue out of memory\n");
spin_unlock_bh(&qitem_lock); spin_unlock_bh(&qitem_lock);
return -ENOMEM; return -ENOMEM;
} }

304
net/tipc/link.c
View File

@ -41,6 +41,12 @@
#include "discover.h" #include "discover.h"
#include "config.h" #include "config.h"
/*
* Error message prefixes
*/
static const char *link_co_err = "Link changeover error, ";
static const char *link_rst_msg = "Resetting link ";
static const char *link_unk_evt = "Unknown link event ";
/* /*
* Out-of-range value for link session numbers * Out-of-range value for link session numbers
@ -300,20 +306,20 @@ struct tipc_link *tipc_link_create(struct tipc_node *n_ptr,
if (n_ptr->link_cnt >= 2) { if (n_ptr->link_cnt >= 2) {
tipc_addr_string_fill(addr_string, n_ptr->addr); tipc_addr_string_fill(addr_string, n_ptr->addr);
err("Attempt to establish third link to %s\n", addr_string); pr_err("Attempt to establish third link to %s\n", addr_string);
return NULL; return NULL;
} }
if (n_ptr->links[b_ptr->identity]) { if (n_ptr->links[b_ptr->identity]) {
tipc_addr_string_fill(addr_string, n_ptr->addr); tipc_addr_string_fill(addr_string, n_ptr->addr);
err("Attempt to establish second link on <%s> to %s\n", pr_err("Attempt to establish second link on <%s> to %s\n",
b_ptr->name, addr_string); b_ptr->name, addr_string);
return NULL; return NULL;
} }
l_ptr = kzalloc(sizeof(*l_ptr), GFP_ATOMIC); l_ptr = kzalloc(sizeof(*l_ptr), GFP_ATOMIC);
if (!l_ptr) { if (!l_ptr) {
warn("Link creation failed, no memory\n"); pr_warn("Link creation failed, no memory\n");
return NULL; return NULL;
} }
@ -371,7 +377,7 @@ struct tipc_link *tipc_link_create(struct tipc_node *n_ptr,
void tipc_link_delete(struct tipc_link *l_ptr) void tipc_link_delete(struct tipc_link *l_ptr)
{ {
if (!l_ptr) { if (!l_ptr) {
err("Attempt to delete non-existent link\n"); pr_err("Attempt to delete non-existent link\n");
return; return;
} }
@ -632,8 +638,8 @@ static void link_state_event(struct tipc_link *l_ptr, unsigned int event)
link_set_timer(l_ptr, cont_intv / 4); link_set_timer(l_ptr, cont_intv / 4);
break; break;
case RESET_MSG: case RESET_MSG:
info("Resetting link <%s>, requested by peer\n", pr_info("%s<%s>, requested by peer\n", link_rst_msg,
l_ptr->name); l_ptr->name);
tipc_link_reset(l_ptr); tipc_link_reset(l_ptr);
l_ptr->state = RESET_RESET; l_ptr->state = RESET_RESET;
l_ptr->fsm_msg_cnt = 0; l_ptr->fsm_msg_cnt = 0;
@ -642,7 +648,7 @@ static void link_state_event(struct tipc_link *l_ptr, unsigned int event)
link_set_timer(l_ptr, cont_intv); link_set_timer(l_ptr, cont_intv);
break; break;
default: default:
err("Unknown link event %u in WW state\n", event); pr_err("%s%u in WW state\n", link_unk_evt, event);
} }
break; break;
case WORKING_UNKNOWN: case WORKING_UNKNOWN:
@ -654,8 +660,8 @@ static void link_state_event(struct tipc_link *l_ptr, unsigned int event)
link_set_timer(l_ptr, cont_intv); link_set_timer(l_ptr, cont_intv);
break; break;
case RESET_MSG: case RESET_MSG:
info("Resetting link <%s>, requested by peer " pr_info("%s<%s>, requested by peer while probing\n",
"while probing\n", l_ptr->name); link_rst_msg, l_ptr->name);
tipc_link_reset(l_ptr); tipc_link_reset(l_ptr);
l_ptr->state = RESET_RESET; l_ptr->state = RESET_RESET;
l_ptr->fsm_msg_cnt = 0; l_ptr->fsm_msg_cnt = 0;
@ -680,8 +686,8 @@ static void link_state_event(struct tipc_link *l_ptr, unsigned int event)
l_ptr->fsm_msg_cnt++; l_ptr->fsm_msg_cnt++;
link_set_timer(l_ptr, cont_intv / 4); link_set_timer(l_ptr, cont_intv / 4);
} else { /* Link has failed */ } else { /* Link has failed */
warn("Resetting link <%s>, peer not responding\n", pr_warn("%s<%s>, peer not responding\n",
l_ptr->name); link_rst_msg, l_ptr->name);
tipc_link_reset(l_ptr); tipc_link_reset(l_ptr);
l_ptr->state = RESET_UNKNOWN; l_ptr->state = RESET_UNKNOWN;
l_ptr->fsm_msg_cnt = 0; l_ptr->fsm_msg_cnt = 0;
@ -692,7 +698,7 @@ static void link_state_event(struct tipc_link *l_ptr, unsigned int event)
} }
break; break;
default: default:
err("Unknown link event %u in WU state\n", event); pr_err("%s%u in WU state\n", link_unk_evt, event);
} }
break; break;
case RESET_UNKNOWN: case RESET_UNKNOWN:
@ -726,7 +732,7 @@ static void link_state_event(struct tipc_link *l_ptr, unsigned int event)
link_set_timer(l_ptr, cont_intv); link_set_timer(l_ptr, cont_intv);
break; break;
default: default:
err("Unknown link event %u in RU state\n", event); pr_err("%s%u in RU state\n", link_unk_evt, event);
} }
break; break;
case RESET_RESET: case RESET_RESET:
@ -751,11 +757,11 @@ static void link_state_event(struct tipc_link *l_ptr, unsigned int event)
link_set_timer(l_ptr, cont_intv); link_set_timer(l_ptr, cont_intv);
break; break;
default: default:
err("Unknown link event %u in RR state\n", event); pr_err("%s%u in RR state\n", link_unk_evt, event);
} }
break; break;
default: default:
err("Unknown link state %u/%u\n", l_ptr->state, event); pr_err("Unknown link state %u/%u\n", l_ptr->state, event);
} }
} }
@ -856,7 +862,8 @@ int tipc_link_send_buf(struct tipc_link *l_ptr, struct sk_buff *buf)
} }
kfree_skb(buf); kfree_skb(buf);
if (imp > CONN_MANAGER) { if (imp > CONN_MANAGER) {
warn("Resetting link <%s>, send queue full", l_ptr->name); pr_warn("%s<%s>, send queue full", link_rst_msg,
l_ptr->name);
tipc_link_reset(l_ptr); tipc_link_reset(l_ptr);
} }
return dsz; return dsz;
@ -1409,8 +1416,8 @@ static void link_reset_all(unsigned long addr)
tipc_node_lock(n_ptr); tipc_node_lock(n_ptr);
warn("Resetting all links to %s\n", pr_warn("Resetting all links to %s\n",
tipc_addr_string_fill(addr_string, n_ptr->addr)); tipc_addr_string_fill(addr_string, n_ptr->addr));
for (i = 0; i < MAX_BEARERS; i++) { for (i = 0; i < MAX_BEARERS; i++) {
if (n_ptr->links[i]) { if (n_ptr->links[i]) {
@ -1428,7 +1435,7 @@ static void link_retransmit_failure(struct tipc_link *l_ptr,
{ {
struct tipc_msg *msg = buf_msg(buf); struct tipc_msg *msg = buf_msg(buf);
warn("Retransmission failure on link <%s>\n", l_ptr->name); pr_warn("Retransmission failure on link <%s>\n", l_ptr->name);
if (l_ptr->addr) { if (l_ptr->addr) {
/* Handle failure on standard link */ /* Handle failure on standard link */
@ -1440,21 +1447,23 @@ static void link_retransmit_failure(struct tipc_link *l_ptr,
struct tipc_node *n_ptr; struct tipc_node *n_ptr;
char addr_string[16]; char addr_string[16];
info("Msg seq number: %u, ", msg_seqno(msg)); pr_info("Msg seq number: %u, ", msg_seqno(msg));
info("Outstanding acks: %lu\n", pr_cont("Outstanding acks: %lu\n",
(unsigned long) TIPC_SKB_CB(buf)->handle); (unsigned long) TIPC_SKB_CB(buf)->handle);
n_ptr = tipc_bclink_retransmit_to(); n_ptr = tipc_bclink_retransmit_to();
tipc_node_lock(n_ptr); tipc_node_lock(n_ptr);
tipc_addr_string_fill(addr_string, n_ptr->addr); tipc_addr_string_fill(addr_string, n_ptr->addr);
info("Broadcast link info for %s\n", addr_string); pr_info("Broadcast link info for %s\n", addr_string);
info("Supportable: %d, ", n_ptr->bclink.supportable); pr_info("Supportable: %d, Supported: %d, Acked: %u\n",
info("Supported: %d, ", n_ptr->bclink.supported); n_ptr->bclink.supportable,
info("Acked: %u\n", n_ptr->bclink.acked); n_ptr->bclink.supported,
info("Last in: %u, ", n_ptr->bclink.last_in); n_ptr->bclink.acked);
info("Oos state: %u, ", n_ptr->bclink.oos_state); pr_info("Last in: %u, Oos state: %u, Last sent: %u\n",
info("Last sent: %u\n", n_ptr->bclink.last_sent); n_ptr->bclink.last_in,
n_ptr->bclink.oos_state,
n_ptr->bclink.last_sent);
tipc_k_signal((Handler)link_reset_all, (unsigned long)n_ptr->addr); tipc_k_signal((Handler)link_reset_all, (unsigned long)n_ptr->addr);
@ -1479,8 +1488,8 @@ void tipc_link_retransmit(struct tipc_link *l_ptr, struct sk_buff *buf,
l_ptr->retransm_queue_head = msg_seqno(msg); l_ptr->retransm_queue_head = msg_seqno(msg);
l_ptr->retransm_queue_size = retransmits; l_ptr->retransm_queue_size = retransmits;
} else { } else {
err("Unexpected retransmit on link %s (qsize=%d)\n", pr_err("Unexpected retransmit on link %s (qsize=%d)\n",
l_ptr->name, l_ptr->retransm_queue_size); l_ptr->name, l_ptr->retransm_queue_size);
} }
return; return;
} else { } else {
@ -2074,8 +2083,9 @@ static void link_recv_proto_msg(struct tipc_link *l_ptr, struct sk_buff *buf)
if (msg_linkprio(msg) && if (msg_linkprio(msg) &&
(msg_linkprio(msg) != l_ptr->priority)) { (msg_linkprio(msg) != l_ptr->priority)) {
warn("Resetting link <%s>, priority change %u->%u\n", pr_warn("%s<%s>, priority change %u->%u\n",
l_ptr->name, l_ptr->priority, msg_linkprio(msg)); link_rst_msg, l_ptr->name, l_ptr->priority,
msg_linkprio(msg));
l_ptr->priority = msg_linkprio(msg); l_ptr->priority = msg_linkprio(msg);
tipc_link_reset(l_ptr); /* Enforce change to take effect */ tipc_link_reset(l_ptr); /* Enforce change to take effect */
break; break;
@ -2139,15 +2149,13 @@ static void tipc_link_tunnel(struct tipc_link *l_ptr,
tunnel = l_ptr->owner->active_links[selector & 1]; tunnel = l_ptr->owner->active_links[selector & 1];
if (!tipc_link_is_up(tunnel)) { if (!tipc_link_is_up(tunnel)) {
warn("Link changeover error, " pr_warn("%stunnel link no longer available\n", link_co_err);
"tunnel link no longer available\n");
return; return;
} }
msg_set_size(tunnel_hdr, length + INT_H_SIZE); msg_set_size(tunnel_hdr, length + INT_H_SIZE);
buf = tipc_buf_acquire(length + INT_H_SIZE); buf = tipc_buf_acquire(length + INT_H_SIZE);
if (!buf) { if (!buf) {
warn("Link changeover error, " pr_warn("%sunable to send tunnel msg\n", link_co_err);
"unable to send tunnel msg\n");
return; return;
} }
skb_copy_to_linear_data(buf, tunnel_hdr, INT_H_SIZE); skb_copy_to_linear_data(buf, tunnel_hdr, INT_H_SIZE);
@ -2173,8 +2181,7 @@ void tipc_link_changeover(struct tipc_link *l_ptr)
return; return;
if (!l_ptr->owner->permit_changeover) { if (!l_ptr->owner->permit_changeover) {
warn("Link changeover error, " pr_warn("%speer did not permit changeover\n", link_co_err);
"peer did not permit changeover\n");
return; return;
} }
@ -2192,8 +2199,8 @@ void tipc_link_changeover(struct tipc_link *l_ptr)
msg_set_size(&tunnel_hdr, INT_H_SIZE); msg_set_size(&tunnel_hdr, INT_H_SIZE);
tipc_link_send_buf(tunnel, buf); tipc_link_send_buf(tunnel, buf);
} else { } else {
warn("Link changeover error, " pr_warn("%sunable to send changeover msg\n",
"unable to send changeover msg\n"); link_co_err);
} }
return; return;
} }
@ -2246,8 +2253,8 @@ void tipc_link_send_duplicate(struct tipc_link *l_ptr, struct tipc_link *tunnel)
msg_set_size(&tunnel_hdr, length + INT_H_SIZE); msg_set_size(&tunnel_hdr, length + INT_H_SIZE);
outbuf = tipc_buf_acquire(length + INT_H_SIZE); outbuf = tipc_buf_acquire(length + INT_H_SIZE);
if (outbuf == NULL) { if (outbuf == NULL) {
warn("Link changeover error, " pr_warn("%sunable to send duplicate msg\n",
"unable to send duplicate msg\n"); link_co_err);
return; return;
} }
skb_copy_to_linear_data(outbuf, &tunnel_hdr, INT_H_SIZE); skb_copy_to_linear_data(outbuf, &tunnel_hdr, INT_H_SIZE);
@ -2298,8 +2305,8 @@ static int link_recv_changeover_msg(struct tipc_link **l_ptr,
if (!dest_link) if (!dest_link)
goto exit; goto exit;
if (dest_link == *l_ptr) { if (dest_link == *l_ptr) {
err("Unexpected changeover message on link <%s>\n", pr_err("Unexpected changeover message on link <%s>\n",
(*l_ptr)->name); (*l_ptr)->name);
goto exit; goto exit;
} }
*l_ptr = dest_link; *l_ptr = dest_link;
@ -2310,7 +2317,7 @@ static int link_recv_changeover_msg(struct tipc_link **l_ptr,
goto exit; goto exit;
*buf = buf_extract(tunnel_buf, INT_H_SIZE); *buf = buf_extract(tunnel_buf, INT_H_SIZE);
if (*buf == NULL) { if (*buf == NULL) {
warn("Link changeover error, duplicate msg dropped\n"); pr_warn("%sduplicate msg dropped\n", link_co_err);
goto exit; goto exit;
} }
kfree_skb(tunnel_buf); kfree_skb(tunnel_buf);
@ -2319,8 +2326,8 @@ static int link_recv_changeover_msg(struct tipc_link **l_ptr,
/* First original message ?: */ /* First original message ?: */
if (tipc_link_is_up(dest_link)) { if (tipc_link_is_up(dest_link)) {
info("Resetting link <%s>, changeover initiated by peer\n", pr_info("%s<%s>, changeover initiated by peer\n", link_rst_msg,
dest_link->name); dest_link->name);
tipc_link_reset(dest_link); tipc_link_reset(dest_link);
dest_link->exp_msg_count = msg_count; dest_link->exp_msg_count = msg_count;
if (!msg_count) if (!msg_count)
@ -2333,8 +2340,7 @@ static int link_recv_changeover_msg(struct tipc_link **l_ptr,
/* Receive original message */ /* Receive original message */
if (dest_link->exp_msg_count == 0) { if (dest_link->exp_msg_count == 0) {
warn("Link switchover error, " pr_warn("%sgot too many tunnelled messages\n", link_co_err);
"got too many tunnelled messages\n");
goto exit; goto exit;
} }
dest_link->exp_msg_count--; dest_link->exp_msg_count--;
@ -2346,7 +2352,7 @@ static int link_recv_changeover_msg(struct tipc_link **l_ptr,
kfree_skb(tunnel_buf); kfree_skb(tunnel_buf);
return 1; return 1;
} else { } else {
warn("Link changeover error, original msg dropped\n"); pr_warn("%soriginal msg dropped\n", link_co_err);
} }
} }
exit: exit:
@ -2367,7 +2373,7 @@ void tipc_link_recv_bundle(struct sk_buff *buf)
while (msgcount--) { while (msgcount--) {
obuf = buf_extract(buf, pos); obuf = buf_extract(buf, pos);
if (obuf == NULL) { if (obuf == NULL) {
warn("Link unable to unbundle message(s)\n"); pr_warn("Link unable to unbundle message(s)\n");
break; break;
} }
pos += align(msg_size(buf_msg(obuf))); pos += align(msg_size(buf_msg(obuf)));
@ -2538,7 +2544,7 @@ int tipc_link_recv_fragment(struct sk_buff **pending, struct sk_buff **fb,
set_fragm_size(pbuf, fragm_sz); set_fragm_size(pbuf, fragm_sz);
set_expected_frags(pbuf, exp_fragm_cnt - 1); set_expected_frags(pbuf, exp_fragm_cnt - 1);
} else { } else {
dbg("Link unable to reassemble fragmented message\n"); pr_debug("Link unable to reassemble fragmented message\n");
kfree_skb(fbuf); kfree_skb(fbuf);
return -1; return -1;
} }
@ -2860,112 +2866,114 @@ static u32 percent(u32 count, u32 total)
*/ */
static int tipc_link_stats(const char *name, char *buf, const u32 buf_size) static int tipc_link_stats(const char *name, char *buf, const u32 buf_size)
{ {
struct print_buf pb; struct tipc_link *l;
struct tipc_link *l_ptr; struct tipc_stats *s;
struct tipc_node *node; struct tipc_node *node;
char *status; char *status;
u32 profile_total = 0; u32 profile_total = 0;
int ret;
if (!strcmp(name, tipc_bclink_name)) if (!strcmp(name, tipc_bclink_name))
return tipc_bclink_stats(buf, buf_size); return tipc_bclink_stats(buf, buf_size);
tipc_printbuf_init(&pb, buf, buf_size);
read_lock_bh(&tipc_net_lock); read_lock_bh(&tipc_net_lock);
l_ptr = link_find_link(name, &node); l = link_find_link(name, &node);
if (!l_ptr) { if (!l) {
read_unlock_bh(&tipc_net_lock); read_unlock_bh(&tipc_net_lock);
return 0; return 0;
} }
tipc_node_lock(node); tipc_node_lock(node);
s = &l->stats;
if (tipc_link_is_active(l_ptr)) if (tipc_link_is_active(l))
status = "ACTIVE"; status = "ACTIVE";
else if (tipc_link_is_up(l_ptr)) else if (tipc_link_is_up(l))
status = "STANDBY"; status = "STANDBY";
else else
status = "DEFUNCT"; status = "DEFUNCT";
tipc_printf(&pb, "Link <%s>\n"
" %s MTU:%u Priority:%u Tolerance:%u ms" ret = tipc_snprintf(buf, buf_size, "Link <%s>\n"
" Window:%u packets\n", " %s MTU:%u Priority:%u Tolerance:%u ms"
l_ptr->name, status, l_ptr->max_pkt, " Window:%u packets\n",
l_ptr->priority, l_ptr->tolerance, l_ptr->queue_limit[0]); l->name, status, l->max_pkt, l->priority,
tipc_printf(&pb, " RX packets:%u fragments:%u/%u bundles:%u/%u\n", l->tolerance, l->queue_limit[0]);
l_ptr->next_in_no - l_ptr->stats.recv_info,
l_ptr->stats.recv_fragments, ret += tipc_snprintf(buf + ret, buf_size - ret,
l_ptr->stats.recv_fragmented, " RX packets:%u fragments:%u/%u bundles:%u/%u\n",
l_ptr->stats.recv_bundles, l->next_in_no - s->recv_info, s->recv_fragments,
l_ptr->stats.recv_bundled); s->recv_fragmented, s->recv_bundles,
tipc_printf(&pb, " TX packets:%u fragments:%u/%u bundles:%u/%u\n", s->recv_bundled);
l_ptr->next_out_no - l_ptr->stats.sent_info,
l_ptr->stats.sent_fragments, ret += tipc_snprintf(buf + ret, buf_size - ret,
l_ptr->stats.sent_fragmented, " TX packets:%u fragments:%u/%u bundles:%u/%u\n",
l_ptr->stats.sent_bundles, l->next_out_no - s->sent_info, s->sent_fragments,
l_ptr->stats.sent_bundled); s->sent_fragmented, s->sent_bundles,
profile_total = l_ptr->stats.msg_length_counts; s->sent_bundled);
profile_total = s->msg_length_counts;
if (!profile_total) if (!profile_total)
profile_total = 1; profile_total = 1;
tipc_printf(&pb, " TX profile sample:%u packets average:%u octets\n"
" 0-64:%u%% -256:%u%% -1024:%u%% -4096:%u%% " ret += tipc_snprintf(buf + ret, buf_size - ret,
"-16384:%u%% -32768:%u%% -66000:%u%%\n", " TX profile sample:%u packets average:%u octets\n"
l_ptr->stats.msg_length_counts, " 0-64:%u%% -256:%u%% -1024:%u%% -4096:%u%% "
l_ptr->stats.msg_lengths_total / profile_total, "-16384:%u%% -32768:%u%% -66000:%u%%\n",
percent(l_ptr->stats.msg_length_profile[0], profile_total), s->msg_length_counts,
percent(l_ptr->stats.msg_length_profile[1], profile_total), s->msg_lengths_total / profile_total,
percent(l_ptr->stats.msg_length_profile[2], profile_total), percent(s->msg_length_profile[0], profile_total),
percent(l_ptr->stats.msg_length_profile[3], profile_total), percent(s->msg_length_profile[1], profile_total),
percent(l_ptr->stats.msg_length_profile[4], profile_total), percent(s->msg_length_profile[2], profile_total),
percent(l_ptr->stats.msg_length_profile[5], profile_total), percent(s->msg_length_profile[3], profile_total),
percent(l_ptr->stats.msg_length_profile[6], profile_total)); percent(s->msg_length_profile[4], profile_total),
tipc_printf(&pb, " RX states:%u probes:%u naks:%u defs:%u dups:%u\n", percent(s->msg_length_profile[5], profile_total),
l_ptr->stats.recv_states, percent(s->msg_length_profile[6], profile_total));
l_ptr->stats.recv_probes,
l_ptr->stats.recv_nacks, ret += tipc_snprintf(buf + ret, buf_size - ret,
l_ptr->stats.deferred_recv, " RX states:%u probes:%u naks:%u defs:%u"
l_ptr->stats.duplicates); " dups:%u\n", s->recv_states, s->recv_probes,
tipc_printf(&pb, " TX states:%u probes:%u naks:%u acks:%u dups:%u\n", s->recv_nacks, s->deferred_recv, s->duplicates);
l_ptr->stats.sent_states,
l_ptr->stats.sent_probes, ret += tipc_snprintf(buf + ret, buf_size - ret,
l_ptr->stats.sent_nacks, " TX states:%u probes:%u naks:%u acks:%u"
l_ptr->stats.sent_acks, " dups:%u\n", s->sent_states, s->sent_probes,
l_ptr->stats.retransmitted); s->sent_nacks, s->sent_acks, s->retransmitted);
tipc_printf(&pb, " Congestion bearer:%u link:%u Send queue max:%u avg:%u\n",
l_ptr->stats.bearer_congs, ret += tipc_snprintf(buf + ret, buf_size - ret,
l_ptr->stats.link_congs, " Congestion bearer:%u link:%u Send queue"
l_ptr->stats.max_queue_sz, " max:%u avg:%u\n", s->bearer_congs, s->link_congs,
l_ptr->stats.queue_sz_counts s->max_queue_sz, s->queue_sz_counts ?
? (l_ptr->stats.accu_queue_sz / l_ptr->stats.queue_sz_counts) (s->accu_queue_sz / s->queue_sz_counts) : 0);
: 0);
tipc_node_unlock(node); tipc_node_unlock(node);
read_unlock_bh(&tipc_net_lock); read_unlock_bh(&tipc_net_lock);
return tipc_printbuf_validate(&pb); return ret;
} }
#define MAX_LINK_STATS_INFO 2000
struct sk_buff *tipc_link_cmd_show_stats(const void *req_tlv_area, int req_tlv_space) struct sk_buff *tipc_link_cmd_show_stats(const void *req_tlv_area, int req_tlv_space)
{ {
struct sk_buff *buf; struct sk_buff *buf;
struct tlv_desc *rep_tlv; struct tlv_desc *rep_tlv;
int str_len; int str_len;
int pb_len;
char *pb;
if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_LINK_NAME)) if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_LINK_NAME))
return tipc_cfg_reply_error_string(TIPC_CFG_TLV_ERROR); return tipc_cfg_reply_error_string(TIPC_CFG_TLV_ERROR);
buf = tipc_cfg_reply_alloc(TLV_SPACE(MAX_LINK_STATS_INFO)); buf = tipc_cfg_reply_alloc(TLV_SPACE(ULTRA_STRING_MAX_LEN));
if (!buf) if (!buf)
return NULL; return NULL;
rep_tlv = (struct tlv_desc *)buf->data; rep_tlv = (struct tlv_desc *)buf->data;
pb = TLV_DATA(rep_tlv);
pb_len = ULTRA_STRING_MAX_LEN;
str_len = tipc_link_stats((char *)TLV_DATA(req_tlv_area), str_len = tipc_link_stats((char *)TLV_DATA(req_tlv_area),
(char *)TLV_DATA(rep_tlv), MAX_LINK_STATS_INFO); pb, pb_len);
if (!str_len) { if (!str_len) {
kfree_skb(buf); kfree_skb(buf);
return tipc_cfg_reply_error_string("link not found"); return tipc_cfg_reply_error_string("link not found");
} }
str_len += 1; /* for "\0" */
skb_put(buf, TLV_SPACE(str_len)); skb_put(buf, TLV_SPACE(str_len));
TLV_SET(rep_tlv, TIPC_TLV_ULTRA_STRING, NULL, str_len); TLV_SET(rep_tlv, TIPC_TLV_ULTRA_STRING, NULL, str_len);
@ -3003,62 +3011,16 @@ u32 tipc_link_get_max_pkt(u32 dest, u32 selector)
static void link_print(struct tipc_link *l_ptr, const char *str) static void link_print(struct tipc_link *l_ptr, const char *str)
{ {
char print_area[256]; pr_info("%s Link %x<%s>:", str, l_ptr->addr, l_ptr->b_ptr->name);
struct print_buf pb;
struct print_buf *buf = &pb;
tipc_printbuf_init(buf, print_area, sizeof(print_area));
tipc_printf(buf, str);
tipc_printf(buf, "Link %x<%s>:",
l_ptr->addr, l_ptr->b_ptr->name);
#ifdef CONFIG_TIPC_DEBUG
if (link_reset_reset(l_ptr) || link_reset_unknown(l_ptr))
goto print_state;
tipc_printf(buf, ": NXO(%u):", mod(l_ptr->next_out_no));
tipc_printf(buf, "NXI(%u):", mod(l_ptr->next_in_no));
tipc_printf(buf, "SQUE");
if (l_ptr->first_out) {
tipc_printf(buf, "[%u..", buf_seqno(l_ptr->first_out));
if (l_ptr->next_out)
tipc_printf(buf, "%u..", buf_seqno(l_ptr->next_out));
tipc_printf(buf, "%u]", buf_seqno(l_ptr->last_out));
if ((mod(buf_seqno(l_ptr->last_out) -
buf_seqno(l_ptr->first_out))
!= (l_ptr->out_queue_size - 1)) ||
(l_ptr->last_out->next != NULL)) {
tipc_printf(buf, "\nSend queue inconsistency\n");
tipc_printf(buf, "first_out= %p ", l_ptr->first_out);
tipc_printf(buf, "next_out= %p ", l_ptr->next_out);
tipc_printf(buf, "last_out= %p ", l_ptr->last_out);
}
} else
tipc_printf(buf, "[]");
tipc_printf(buf, "SQSIZ(%u)", l_ptr->out_queue_size);
if (l_ptr->oldest_deferred_in) {
u32 o = buf_seqno(l_ptr->oldest_deferred_in);
u32 n = buf_seqno(l_ptr->newest_deferred_in);
tipc_printf(buf, ":RQUE[%u..%u]", o, n);
if (l_ptr->deferred_inqueue_sz != mod((n + 1) - o)) {
tipc_printf(buf, ":RQSIZ(%u)",
l_ptr->deferred_inqueue_sz);
}
}
print_state:
#endif
if (link_working_unknown(l_ptr)) if (link_working_unknown(l_ptr))
tipc_printf(buf, ":WU"); pr_cont(":WU\n");
else if (link_reset_reset(l_ptr)) else if (link_reset_reset(l_ptr))
tipc_printf(buf, ":RR"); pr_cont(":RR\n");
else if (link_reset_unknown(l_ptr)) else if (link_reset_unknown(l_ptr))
tipc_printf(buf, ":RU"); pr_cont(":RU\n");
else if (link_working_working(l_ptr)) else if (link_working_working(l_ptr))
tipc_printf(buf, ":WW"); pr_cont(":WW\n");
tipc_printf(buf, "\n"); else
pr_cont("\n");
tipc_printbuf_validate(buf);
info("%s", print_area);
} }

63
net/tipc/link.h
View File

@ -37,7 +37,6 @@
#ifndef _TIPC_LINK_H #ifndef _TIPC_LINK_H
#define _TIPC_LINK_H #define _TIPC_LINK_H
#include "log.h"
#include "msg.h" #include "msg.h"
#include "node.h" #include "node.h"
@ -63,6 +62,37 @@
*/ */
#define MAX_PKT_DEFAULT 1500 #define MAX_PKT_DEFAULT 1500
struct tipc_stats {
u32 sent_info; /* used in counting # sent packets */
u32 recv_info; /* used in counting # recv'd packets */
u32 sent_states;
u32 recv_states;
u32 sent_probes;
u32 recv_probes;
u32 sent_nacks;
u32 recv_nacks;
u32 sent_acks;
u32 sent_bundled;
u32 sent_bundles;
u32 recv_bundled;
u32 recv_bundles;
u32 retransmitted;
u32 sent_fragmented;
u32 sent_fragments;
u32 recv_fragmented;
u32 recv_fragments;
u32 link_congs; /* # port sends blocked by congestion */
u32 bearer_congs;
u32 deferred_recv;
u32 duplicates;
u32 max_queue_sz; /* send queue size high water mark */
u32 accu_queue_sz; /* used for send queue size profiling */
u32 queue_sz_counts; /* used for send queue size profiling */
u32 msg_length_counts; /* used for message length profiling */
u32 msg_lengths_total; /* used for message length profiling */
u32 msg_length_profile[7]; /* used for msg. length profiling */
};
/** /**
* struct tipc_link - TIPC link data structure * struct tipc_link - TIPC link data structure
* @addr: network address of link's peer node * @addr: network address of link's peer node
@ -175,36 +205,7 @@ struct tipc_link {
struct sk_buff *defragm_buf; struct sk_buff *defragm_buf;
/* Statistics */ /* Statistics */
struct { struct tipc_stats stats;
u32 sent_info; /* used in counting # sent packets */
u32 recv_info; /* used in counting # recv'd packets */
u32 sent_states;
u32 recv_states;
u32 sent_probes;
u32 recv_probes;
u32 sent_nacks;
u32 recv_nacks;
u32 sent_acks;
u32 sent_bundled;
u32 sent_bundles;
u32 recv_bundled;
u32 recv_bundles;
u32 retransmitted;
u32 sent_fragmented;
u32 sent_fragments;
u32 recv_fragmented;
u32 recv_fragments;
u32 link_congs; /* # port sends blocked by congestion */
u32 bearer_congs;
u32 deferred_recv;
u32 duplicates;
u32 max_queue_sz; /* send queue size high water mark */
u32 accu_queue_sz; /* used for send queue size profiling */
u32 queue_sz_counts; /* used for send queue size profiling */
u32 msg_length_counts; /* used for message length profiling */
u32 msg_lengths_total; /* used for message length profiling */
u32 msg_length_profile[7]; /* used for msg. length profiling */
} stats;
}; };
struct tipc_port; struct tipc_port;

302
net/tipc/log.c
View File

@ -36,302 +36,20 @@
#include "core.h" #include "core.h"
#include "config.h" #include "config.h"
#include "log.h"
/*
* TIPC pre-defines the following print buffers:
*
* TIPC_NULL : null buffer (i.e. print nowhere)
* TIPC_CONS : system console
* TIPC_LOG : TIPC log buffer
*
* Additional user-defined print buffers are also permitted.
*/
static struct print_buf null_buf = { NULL, 0, NULL, 0 };
struct print_buf *const TIPC_NULL = &null_buf;
static struct print_buf cons_buf = { NULL, 0, NULL, 1 };
struct print_buf *const TIPC_CONS = &cons_buf;
static struct print_buf log_buf = { NULL, 0, NULL, 1 };
struct print_buf *const TIPC_LOG = &log_buf;
/*
* Locking policy when using print buffers.
*
* 1) tipc_printf() uses 'print_lock' to protect against concurrent access to
* 'print_string' when writing to a print buffer. This also protects against
* concurrent writes to the print buffer being written to.
*
* 2) tipc_log_XXX() leverages the aforementioned use of 'print_lock' to
* protect against all types of concurrent operations on their associated
* print buffer (not just write operations).
*
* Note: All routines of the form tipc_printbuf_XXX() are lock-free, and rely
* on the caller to prevent simultaneous use of the print buffer(s) being
* manipulated.
*/
static char print_string[TIPC_PB_MAX_STR];
static DEFINE_SPINLOCK(print_lock);
static void tipc_printbuf_move(struct print_buf *pb_to,
struct print_buf *pb_from);
#define FORMAT(PTR, LEN, FMT) \
{\
va_list args;\
va_start(args, FMT);\
LEN = vsprintf(PTR, FMT, args);\
va_end(args);\
*(PTR + LEN) = '\0';\
}
/** /**
* tipc_printbuf_init - initialize print buffer to empty * tipc_snprintf - append formatted output to print buffer
* @pb: pointer to print buffer structure * @buf: pointer to print buffer
* @raw: pointer to character array used by print buffer * @len: buffer length
* @size: size of character array
*
* Note: If the character array is too small (or absent), the print buffer
* becomes a null device that discards anything written to it.
*/
void tipc_printbuf_init(struct print_buf *pb, char *raw, u32 size)
{
pb->buf = raw;
pb->crs = raw;
pb->size = size;
pb->echo = 0;
if (size < TIPC_PB_MIN_SIZE) {
pb->buf = NULL;
} else if (raw) {
pb->buf[0] = 0;
pb->buf[size - 1] = ~0;
}
}
/**
* tipc_printbuf_reset - reinitialize print buffer to empty state
* @pb: pointer to print buffer structure
*/
static void tipc_printbuf_reset(struct print_buf *pb)
{
if (pb->buf) {
pb->crs = pb->buf;
pb->buf[0] = 0;
pb->buf[pb->size - 1] = ~0;
}
}
/**
* tipc_printbuf_empty - test if print buffer is in empty state
* @pb: pointer to print buffer structure
*
* Returns non-zero if print buffer is empty.
*/
static int tipc_printbuf_empty(struct print_buf *pb)
{
return !pb->buf || (pb->crs == pb->buf);
}
/**
* tipc_printbuf_validate - check for print buffer overflow
* @pb: pointer to print buffer structure
*
* Verifies that a print buffer has captured all data written to it.
* If data has been lost, linearize buffer and prepend an error message
*
* Returns length of print buffer data string (including trailing NUL)
*/
int tipc_printbuf_validate(struct print_buf *pb)
{
char *err = "\n\n*** PRINT BUFFER OVERFLOW ***\n\n";
char *cp_buf;
struct print_buf cb;
if (!pb->buf)
return 0;
if (pb->buf[pb->size - 1] == 0) {
cp_buf = kmalloc(pb->size, GFP_ATOMIC);
if (cp_buf) {
tipc_printbuf_init(&cb, cp_buf, pb->size);
tipc_printbuf_move(&cb, pb);
tipc_printbuf_move(pb, &cb);
kfree(cp_buf);
memcpy(pb->buf, err, strlen(err));
} else {
tipc_printbuf_reset(pb);
tipc_printf(pb, err);
}
}
return pb->crs - pb->buf + 1;
}
/**
* tipc_printbuf_move - move print buffer contents to another print buffer
* @pb_to: pointer to destination print buffer structure
* @pb_from: pointer to source print buffer structure
*
* Current contents of destination print buffer (if any) are discarded.
* Source print buffer becomes empty if a successful move occurs.
*/
static void tipc_printbuf_move(struct print_buf *pb_to,
struct print_buf *pb_from)
{
int len;
/* Handle the cases where contents can't be moved */
if (!pb_to->buf)
return;
if (!pb_from->buf) {
tipc_printbuf_reset(pb_to);
return;
}
if (pb_to->size < pb_from->size) {
strcpy(pb_to->buf, "*** PRINT BUFFER MOVE ERROR ***");
pb_to->buf[pb_to->size - 1] = ~0;
pb_to->crs = strchr(pb_to->buf, 0);
return;
}
/* Copy data from char after cursor to end (if used) */
len = pb_from->buf + pb_from->size - pb_from->crs - 2;
if ((pb_from->buf[pb_from->size - 1] == 0) && (len > 0)) {
strcpy(pb_to->buf, pb_from->crs + 1);
pb_to->crs = pb_to->buf + len;
} else
pb_to->crs = pb_to->buf;
/* Copy data from start to cursor (always) */
len = pb_from->crs - pb_from->buf;
strcpy(pb_to->crs, pb_from->buf);
pb_to->crs += len;
tipc_printbuf_reset(pb_from);
}
/**
* tipc_printf - append formatted output to print buffer
* @pb: pointer to print buffer
* @fmt: formatted info to be printed * @fmt: formatted info to be printed
*/ */
void tipc_printf(struct print_buf *pb, const char *fmt, ...) int tipc_snprintf(char *buf, int len, const char *fmt, ...)
{ {
int chars_to_add; int i;
int chars_left; va_list args;
char save_char;
spin_lock_bh(&print_lock); va_start(args, fmt);
i = vscnprintf(buf, len, fmt, args);
FORMAT(print_string, chars_to_add, fmt); va_end(args);
if (chars_to_add >= TIPC_PB_MAX_STR) return i;
strcpy(print_string, "*** PRINT BUFFER STRING TOO LONG ***");
if (pb->buf) {
chars_left = pb->buf + pb->size - pb->crs - 1;
if (chars_to_add <= chars_left) {
strcpy(pb->crs, print_string);
pb->crs += chars_to_add;
} else if (chars_to_add >= (pb->size - 1)) {
strcpy(pb->buf, print_string + chars_to_add + 1
- pb->size);
pb->crs = pb->buf + pb->size - 1;
} else {
strcpy(pb->buf, print_string + chars_left);
save_char = print_string[chars_left];
print_string[chars_left] = 0;
strcpy(pb->crs, print_string);
print_string[chars_left] = save_char;
pb->crs = pb->buf + chars_to_add - chars_left;
}
}
if (pb->echo)
printk("%s", print_string);
spin_unlock_bh(&print_lock);
}
/**
* tipc_log_resize - change the size of the TIPC log buffer
* @log_size: print buffer size to use
*/
int tipc_log_resize(int log_size)
{
int res = 0;
spin_lock_bh(&print_lock);
kfree(TIPC_LOG->buf);
TIPC_LOG->buf = NULL;
if (log_size) {
if (log_size < TIPC_PB_MIN_SIZE)
log_size = TIPC_PB_MIN_SIZE;
res = TIPC_LOG->echo;
tipc_printbuf_init(TIPC_LOG, kmalloc(log_size, GFP_ATOMIC),
log_size);
TIPC_LOG->echo = res;
res = !TIPC_LOG->buf;
}
spin_unlock_bh(&print_lock);
return res;
}
/**
* tipc_log_resize_cmd - reconfigure size of TIPC log buffer
*/
struct sk_buff *tipc_log_resize_cmd(const void *req_tlv_area, int req_tlv_space)
{
u32 value;
if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_UNSIGNED))
return tipc_cfg_reply_error_string(TIPC_CFG_TLV_ERROR);
value = ntohl(*(__be32 *)TLV_DATA(req_tlv_area));
if (value > 32768)
return tipc_cfg_reply_error_string(TIPC_CFG_INVALID_VALUE
" (log size must be 0-32768)");
if (tipc_log_resize(value))
return tipc_cfg_reply_error_string(
"unable to create specified log (log size is now 0)");
return tipc_cfg_reply_none();
}
/**
* tipc_log_dump - capture TIPC log buffer contents in configuration message
*/
struct sk_buff *tipc_log_dump(void)
{
struct sk_buff *reply;
spin_lock_bh(&print_lock);
if (!TIPC_LOG->buf) {
spin_unlock_bh(&print_lock);
reply = tipc_cfg_reply_ultra_string("log not activated\n");
} else if (tipc_printbuf_empty(TIPC_LOG)) {
spin_unlock_bh(&print_lock);
reply = tipc_cfg_reply_ultra_string("log is empty\n");
} else {
struct tlv_desc *rep_tlv;
struct print_buf pb;
int str_len;
str_len = min(TIPC_LOG->size, 32768u);
spin_unlock_bh(&print_lock);
reply = tipc_cfg_reply_alloc(TLV_SPACE(str_len));
if (reply) {
rep_tlv = (struct tlv_desc *)reply->data;
tipc_printbuf_init(&pb, TLV_DATA(rep_tlv), str_len);
spin_lock_bh(&print_lock);
tipc_printbuf_move(&pb, TIPC_LOG);
spin_unlock_bh(&print_lock);
str_len = strlen(TLV_DATA(rep_tlv)) + 1;
skb_put(reply, TLV_SPACE(str_len));
TLV_SET(rep_tlv, TIPC_TLV_ULTRA_STRING, NULL, str_len);
}
}
return reply;
} }

66
net/tipc/log.h
View File

@ -1,66 +0,0 @@
/*
* net/tipc/log.h: Include file for TIPC print buffer routines
*
* Copyright (c) 1997-2006, Ericsson AB
* Copyright (c) 2005-2007, Wind River Systems
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the names of the copyright holders nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* Alternatively, this software may be distributed under the terms of the
* GNU General Public License ("GPL") version 2 as published by the Free
* Software Foundation.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef _TIPC_LOG_H
#define _TIPC_LOG_H
/**
* struct print_buf - TIPC print buffer structure
* @buf: pointer to character array containing print buffer contents
* @size: size of character array
* @crs: pointer to first unused space in character array (i.e. final NUL)
* @echo: echo output to system console if non-zero
*/
struct print_buf {
char *buf;
u32 size;
char *crs;
int echo;
};
#define TIPC_PB_MIN_SIZE 64 /* minimum size for a print buffer's array */
#define TIPC_PB_MAX_STR 512 /* max printable string (with trailing NUL) */
void tipc_printbuf_init(struct print_buf *pb, char *buf, u32 size);
int tipc_printbuf_validate(struct print_buf *pb);
int tipc_log_resize(int log_size);
struct sk_buff *tipc_log_resize_cmd(const void *req_tlv_area,
int req_tlv_space);
struct sk_buff *tipc_log_dump(void);
#endif

242
net/tipc/msg.c
View File

@ -109,245 +109,3 @@ int tipc_msg_build(struct tipc_msg *hdr, struct iovec const *msg_sect,
*buf = NULL; *buf = NULL;
return -EFAULT; return -EFAULT;
} }
#ifdef CONFIG_TIPC_DEBUG
void tipc_msg_dbg(struct print_buf *buf, struct tipc_msg *msg, const char *str)
{
u32 usr = msg_user(msg);
tipc_printf(buf, KERN_DEBUG);
tipc_printf(buf, str);
switch (usr) {
case MSG_BUNDLER:
tipc_printf(buf, "BNDL::");
tipc_printf(buf, "MSGS(%u):", msg_msgcnt(msg));
break;
case BCAST_PROTOCOL:
tipc_printf(buf, "BCASTP::");
break;
case MSG_FRAGMENTER:
tipc_printf(buf, "FRAGM::");
switch (msg_type(msg)) {
case FIRST_FRAGMENT:
tipc_printf(buf, "FIRST:");
break;
case FRAGMENT:
tipc_printf(buf, "BODY:");
break;
case LAST_FRAGMENT:
tipc_printf(buf, "LAST:");
break;
default:
tipc_printf(buf, "UNKNOWN:%x", msg_type(msg));
}
tipc_printf(buf, "NO(%u/%u):", msg_long_msgno(msg),
msg_fragm_no(msg));
break;
case TIPC_LOW_IMPORTANCE:
case TIPC_MEDIUM_IMPORTANCE:
case TIPC_HIGH_IMPORTANCE:
case TIPC_CRITICAL_IMPORTANCE:
tipc_printf(buf, "DAT%u:", msg_user(msg));
if (msg_short(msg)) {
tipc_printf(buf, "CON:");
break;
}
switch (msg_type(msg)) {
case TIPC_CONN_MSG:
tipc_printf(buf, "CON:");
break;
case TIPC_MCAST_MSG:
tipc_printf(buf, "MCST:");
break;
case TIPC_NAMED_MSG:
tipc_printf(buf, "NAM:");
break;
case TIPC_DIRECT_MSG:
tipc_printf(buf, "DIR:");
break;
default:
tipc_printf(buf, "UNKNOWN TYPE %u", msg_type(msg));
}
if (msg_reroute_cnt(msg))
tipc_printf(buf, "REROUTED(%u):",
msg_reroute_cnt(msg));
break;
case NAME_DISTRIBUTOR:
tipc_printf(buf, "NMD::");
switch (msg_type(msg)) {
case PUBLICATION:
tipc_printf(buf, "PUBL(%u):", (msg_size(msg) - msg_hdr_sz(msg)) / 20); /* Items */
break;
case WITHDRAWAL:
tipc_printf(buf, "WDRW:");
break;
default:
tipc_printf(buf, "UNKNOWN:%x", msg_type(msg));
}
if (msg_reroute_cnt(msg))
tipc_printf(buf, "REROUTED(%u):",
msg_reroute_cnt(msg));
break;
case CONN_MANAGER:
tipc_printf(buf, "CONN_MNG:");
switch (msg_type(msg)) {
case CONN_PROBE:
tipc_printf(buf, "PROBE:");
break;
case CONN_PROBE_REPLY:
tipc_printf(buf, "PROBE_REPLY:");
break;
case CONN_ACK:
tipc_printf(buf, "CONN_ACK:");
tipc_printf(buf, "ACK(%u):", msg_msgcnt(msg));
break;
default:
tipc_printf(buf, "UNKNOWN TYPE:%x", msg_type(msg));
}
if (msg_reroute_cnt(msg))
tipc_printf(buf, "REROUTED(%u):", msg_reroute_cnt(msg));
break;
case LINK_PROTOCOL:
switch (msg_type(msg)) {
case STATE_MSG:
tipc_printf(buf, "STATE:");
tipc_printf(buf, "%s:", msg_probe(msg) ? "PRB" : "");
tipc_printf(buf, "NXS(%u):", msg_next_sent(msg));
tipc_printf(buf, "GAP(%u):", msg_seq_gap(msg));
tipc_printf(buf, "LSTBC(%u):", msg_last_bcast(msg));
break;
case RESET_MSG:
tipc_printf(buf, "RESET:");
if (msg_size(msg) != msg_hdr_sz(msg))
tipc_printf(buf, "BEAR:%s:", msg_data(msg));
break;
case ACTIVATE_MSG:
tipc_printf(buf, "ACTIVATE:");
break;
default:
tipc_printf(buf, "UNKNOWN TYPE:%x", msg_type(msg));
}
tipc_printf(buf, "PLANE(%c):", msg_net_plane(msg));
tipc_printf(buf, "SESS(%u):", msg_session(msg));
break;
case CHANGEOVER_PROTOCOL:
tipc_printf(buf, "TUNL:");
switch (msg_type(msg)) {
case DUPLICATE_MSG:
tipc_printf(buf, "DUPL:");
break;
case ORIGINAL_MSG:
tipc_printf(buf, "ORIG:");
tipc_printf(buf, "EXP(%u)", msg_msgcnt(msg));
break;
default:
tipc_printf(buf, "UNKNOWN TYPE:%x", msg_type(msg));
}
break;
case LINK_CONFIG:
tipc_printf(buf, "CFG:");
switch (msg_type(msg)) {
case DSC_REQ_MSG:
tipc_printf(buf, "DSC_REQ:");
break;
case DSC_RESP_MSG:
tipc_printf(buf, "DSC_RESP:");
break;
default:
tipc_printf(buf, "UNKNOWN TYPE:%x:", msg_type(msg));
break;
}
break;
default:
tipc_printf(buf, "UNKNOWN USER:");
}
switch (usr) {
case CONN_MANAGER:
case TIPC_LOW_IMPORTANCE:
case TIPC_MEDIUM_IMPORTANCE:
case TIPC_HIGH_IMPORTANCE:
case TIPC_CRITICAL_IMPORTANCE:
switch (msg_errcode(msg)) {
case TIPC_OK:
break;
case TIPC_ERR_NO_NAME:
tipc_printf(buf, "NO_NAME:");
break;
case TIPC_ERR_NO_PORT:
tipc_printf(buf, "NO_PORT:");
break;
case TIPC_ERR_NO_NODE:
tipc_printf(buf, "NO_PROC:");
break;
case TIPC_ERR_OVERLOAD:
tipc_printf(buf, "OVERLOAD:");
break;
case TIPC_CONN_SHUTDOWN:
tipc_printf(buf, "SHUTDOWN:");
break;
default:
tipc_printf(buf, "UNKNOWN ERROR(%x):",
msg_errcode(msg));
}
default:
break;
}
tipc_printf(buf, "HZ(%u):", msg_hdr_sz(msg));
tipc_printf(buf, "SZ(%u):", msg_size(msg));
tipc_printf(buf, "SQNO(%u):", msg_seqno(msg));
if (msg_non_seq(msg))
tipc_printf(buf, "NOSEQ:");
else
tipc_printf(buf, "ACK(%u):", msg_ack(msg));
tipc_printf(buf, "BACK(%u):", msg_bcast_ack(msg));
tipc_printf(buf, "PRND(%x)", msg_prevnode(msg));
if (msg_isdata(msg)) {
if (msg_named(msg)) {
tipc_printf(buf, "NTYP(%u):", msg_nametype(msg));
tipc_printf(buf, "NINST(%u)", msg_nameinst(msg));
}
}
if ((usr != LINK_PROTOCOL) && (usr != LINK_CONFIG) &&
(usr != MSG_BUNDLER)) {
if (!msg_short(msg)) {
tipc_printf(buf, ":ORIG(%x:%u):",
msg_orignode(msg), msg_origport(msg));
tipc_printf(buf, ":DEST(%x:%u):",
msg_destnode(msg), msg_destport(msg));
} else {
tipc_printf(buf, ":OPRT(%u):", msg_origport(msg));
tipc_printf(buf, ":DPRT(%u):", msg_destport(msg));
}
}
if (msg_user(msg) == NAME_DISTRIBUTOR) {
tipc_printf(buf, ":ONOD(%x):", msg_orignode(msg));
tipc_printf(buf, ":DNOD(%x):", msg_destnode(msg));
}
if (msg_user(msg) == LINK_CONFIG) {
struct tipc_media_addr orig;
tipc_printf(buf, ":DDOM(%x):", msg_dest_domain(msg));
tipc_printf(buf, ":NETID(%u):", msg_bc_netid(msg));
memcpy(orig.value, msg_media_addr(msg), sizeof(orig.value));
orig.media_id = 0;
orig.broadcast = 0;
tipc_media_addr_printf(buf, &orig);
}
if (msg_user(msg) == BCAST_PROTOCOL) {
tipc_printf(buf, "BCNACK:AFTER(%u):", msg_bcgap_after(msg));
tipc_printf(buf, "TO(%u):", msg_bcgap_to(msg));
}
tipc_printf(buf, "\n");
if ((usr == CHANGEOVER_PROTOCOL) && (msg_msgcnt(msg)))
tipc_msg_dbg(buf, msg_get_wrapped(msg), " /");
if ((usr == MSG_FRAGMENTER) && (msg_type(msg) == FIRST_FRAGMENT))
tipc_msg_dbg(buf, msg_get_wrapped(msg), " /");
}
#endif

25
net/tipc/name_distr.c
View File

@ -161,7 +161,7 @@ void tipc_named_publish(struct publication *publ)
buf = named_prepare_buf(PUBLICATION, ITEM_SIZE, 0); buf = named_prepare_buf(PUBLICATION, ITEM_SIZE, 0);
if (!buf) { if (!buf) {
warn("Publication distribution failure\n"); pr_warn("Publication distribution failure\n");
return; return;
} }
@ -186,7 +186,7 @@ void tipc_named_withdraw(struct publication *publ)
buf = named_prepare_buf(WITHDRAWAL, ITEM_SIZE, 0); buf = named_prepare_buf(WITHDRAWAL, ITEM_SIZE, 0);
if (!buf) { if (!buf) {
warn("Withdrawal distribution failure\n"); pr_warn("Withdrawal distribution failure\n");
return; return;
} }
@ -213,7 +213,7 @@ static void named_distribute(struct list_head *message_list, u32 node,
rest -= left; rest -= left;
buf = named_prepare_buf(PUBLICATION, left, node); buf = named_prepare_buf(PUBLICATION, left, node);
if (!buf) { if (!buf) {
warn("Bulk publication failure\n"); pr_warn("Bulk publication failure\n");
return; return;
} }
item = (struct distr_item *)msg_data(buf_msg(buf)); item = (struct distr_item *)msg_data(buf_msg(buf));
@ -283,9 +283,10 @@ static void named_purge_publ(struct publication *publ)
write_unlock_bh(&tipc_nametbl_lock); write_unlock_bh(&tipc_nametbl_lock);
if (p != publ) { if (p != publ) {
err("Unable to remove publication from failed node\n" pr_err("Unable to remove publication from failed node\n"
"(type=%u, lower=%u, node=0x%x, ref=%u, key=%u)\n", " (type=%u, lower=%u, node=0x%x, ref=%u, key=%u)\n",
publ->type, publ->lower, publ->node, publ->ref, publ->key); publ->type, publ->lower, publ->node, publ->ref,
publ->key);
} }
kfree(p); kfree(p);
@ -329,14 +330,14 @@ void tipc_named_recv(struct sk_buff *buf)
tipc_nodesub_unsubscribe(&publ->subscr); tipc_nodesub_unsubscribe(&publ->subscr);
kfree(publ); kfree(publ);
} else { } else {
err("Unable to remove publication by node 0x%x\n" pr_err("Unable to remove publication by node 0x%x\n"
"(type=%u, lower=%u, ref=%u, key=%u)\n", " (type=%u, lower=%u, ref=%u, key=%u)\n",
msg_orignode(msg), msg_orignode(msg), ntohl(item->type),
ntohl(item->type), ntohl(item->lower), ntohl(item->lower), ntohl(item->ref),
ntohl(item->ref), ntohl(item->key)); ntohl(item->key));
} }
} else { } else {
warn("Unrecognized name table message received\n"); pr_warn("Unrecognized name table message received\n");
} }
item++; item++;
} }

132
net/tipc/name_table.c
View File

@ -126,7 +126,7 @@ static struct publication *publ_create(u32 type, u32 lower, u32 upper,
{ {
struct publication *publ = kzalloc(sizeof(*publ), GFP_ATOMIC); struct publication *publ = kzalloc(sizeof(*publ), GFP_ATOMIC);
if (publ == NULL) { if (publ == NULL) {
warn("Publication creation failure, no memory\n"); pr_warn("Publication creation failure, no memory\n");
return NULL; return NULL;
} }
@ -163,7 +163,7 @@ static struct name_seq *tipc_nameseq_create(u32 type, struct hlist_head *seq_hea
struct sub_seq *sseq = tipc_subseq_alloc(1); struct sub_seq *sseq = tipc_subseq_alloc(1);
if (!nseq || !sseq) { if (!nseq || !sseq) {
warn("Name sequence creation failed, no memory\n"); pr_warn("Name sequence creation failed, no memory\n");
kfree(nseq); kfree(nseq);
kfree(sseq); kfree(sseq);
return NULL; return NULL;
@ -263,8 +263,8 @@ static struct publication *tipc_nameseq_insert_publ(struct name_seq *nseq,
/* Lower end overlaps existing entry => need an exact match */ /* Lower end overlaps existing entry => need an exact match */
if ((sseq->lower != lower) || (sseq->upper != upper)) { if ((sseq->lower != lower) || (sseq->upper != upper)) {
warn("Cannot publish {%u,%u,%u}, overlap error\n", pr_warn("Cannot publish {%u,%u,%u}, overlap error\n",
type, lower, upper); type, lower, upper);
return NULL; return NULL;
} }
@ -286,8 +286,8 @@ static struct publication *tipc_nameseq_insert_publ(struct name_seq *nseq,
/* Fail if upper end overlaps into an existing entry */ /* Fail if upper end overlaps into an existing entry */
if ((inspos < nseq->first_free) && if ((inspos < nseq->first_free) &&
(upper >= nseq->sseqs[inspos].lower)) { (upper >= nseq->sseqs[inspos].lower)) {
warn("Cannot publish {%u,%u,%u}, overlap error\n", pr_warn("Cannot publish {%u,%u,%u}, overlap error\n",
type, lower, upper); type, lower, upper);
return NULL; return NULL;
} }
@ -296,8 +296,8 @@ static struct publication *tipc_nameseq_insert_publ(struct name_seq *nseq,
struct sub_seq *sseqs = tipc_subseq_alloc(nseq->alloc * 2); struct sub_seq *sseqs = tipc_subseq_alloc(nseq->alloc * 2);
if (!sseqs) { if (!sseqs) {
warn("Cannot publish {%u,%u,%u}, no memory\n", pr_warn("Cannot publish {%u,%u,%u}, no memory\n",
type, lower, upper); type, lower, upper);
return NULL; return NULL;
} }
memcpy(sseqs, nseq->sseqs, memcpy(sseqs, nseq->sseqs,
@ -309,8 +309,8 @@ static struct publication *tipc_nameseq_insert_publ(struct name_seq *nseq,
info = kzalloc(sizeof(*info), GFP_ATOMIC); info = kzalloc(sizeof(*info), GFP_ATOMIC);
if (!info) { if (!info) {
warn("Cannot publish {%u,%u,%u}, no memory\n", pr_warn("Cannot publish {%u,%u,%u}, no memory\n",
type, lower, upper); type, lower, upper);
return NULL; return NULL;
} }
@ -492,8 +492,8 @@ struct publication *tipc_nametbl_insert_publ(u32 type, u32 lower, u32 upper,
if ((scope < TIPC_ZONE_SCOPE) || (scope > TIPC_NODE_SCOPE) || if ((scope < TIPC_ZONE_SCOPE) || (scope > TIPC_NODE_SCOPE) ||
(lower > upper)) { (lower > upper)) {
dbg("Failed to publish illegal {%u,%u,%u} with scope %u\n", pr_debug("Failed to publish illegal {%u,%u,%u} with scope %u\n",
type, lower, upper, scope); type, lower, upper, scope);
return NULL; return NULL;
} }
@ -668,8 +668,8 @@ struct publication *tipc_nametbl_publish(u32 type, u32 lower, u32 upper,
struct publication *publ; struct publication *publ;
if (table.local_publ_count >= tipc_max_publications) { if (table.local_publ_count >= tipc_max_publications) {
warn("Publication failed, local publication limit reached (%u)\n", pr_warn("Publication failed, local publication limit reached (%u)\n",
tipc_max_publications); tipc_max_publications);
return NULL; return NULL;
} }
@ -702,9 +702,9 @@ int tipc_nametbl_withdraw(u32 type, u32 lower, u32 ref, u32 key)
return 1; return 1;
} }
write_unlock_bh(&tipc_nametbl_lock); write_unlock_bh(&tipc_nametbl_lock);
err("Unable to remove local publication\n" pr_err("Unable to remove local publication\n"
"(type=%u, lower=%u, ref=%u, key=%u)\n", "(type=%u, lower=%u, ref=%u, key=%u)\n",
type, lower, ref, key); type, lower, ref, key);
return 0; return 0;
} }
@ -725,8 +725,8 @@ void tipc_nametbl_subscribe(struct tipc_subscription *s)
tipc_nameseq_subscribe(seq, s); tipc_nameseq_subscribe(seq, s);
spin_unlock_bh(&seq->lock); spin_unlock_bh(&seq->lock);
} else { } else {
warn("Failed to create subscription for {%u,%u,%u}\n", pr_warn("Failed to create subscription for {%u,%u,%u}\n",
s->seq.type, s->seq.lower, s->seq.upper); s->seq.type, s->seq.lower, s->seq.upper);
} }
write_unlock_bh(&tipc_nametbl_lock); write_unlock_bh(&tipc_nametbl_lock);
} }
@ -753,19 +753,20 @@ void tipc_nametbl_unsubscribe(struct tipc_subscription *s)
/** /**
* subseq_list - print specified sub-sequence contents into the given buffer * subseq_list - print specified sub-sequence contents into the given buffer
*/ */
static void subseq_list(struct sub_seq *sseq, struct print_buf *buf, u32 depth, static int subseq_list(struct sub_seq *sseq, char *buf, int len, u32 depth,
u32 index) u32 index)
{ {
char portIdStr[27]; char portIdStr[27];
const char *scope_str[] = {"", " zone", " cluster", " node"}; const char *scope_str[] = {"", " zone", " cluster", " node"};
struct publication *publ; struct publication *publ;
struct name_info *info; struct name_info *info;
int ret;
tipc_printf(buf, "%-10u %-10u ", sseq->lower, sseq->upper); ret = tipc_snprintf(buf, len, "%-10u %-10u ", sseq->lower, sseq->upper);
if (depth == 2) { if (depth == 2) {
tipc_printf(buf, "\n"); ret += tipc_snprintf(buf - ret, len + ret, "\n");
return; return ret;
} }
info = sseq->info; info = sseq->info;
@ -774,52 +775,58 @@ static void subseq_list(struct sub_seq *sseq, struct print_buf *buf, u32 depth,
sprintf(portIdStr, "<%u.%u.%u:%u>", sprintf(portIdStr, "<%u.%u.%u:%u>",
tipc_zone(publ->node), tipc_cluster(publ->node), tipc_zone(publ->node), tipc_cluster(publ->node),
tipc_node(publ->node), publ->ref); tipc_node(publ->node), publ->ref);
tipc_printf(buf, "%-26s ", portIdStr); ret += tipc_snprintf(buf + ret, len - ret, "%-26s ", portIdStr);
if (depth > 3) { if (depth > 3) {
tipc_printf(buf, "%-10u %s", publ->key, ret += tipc_snprintf(buf + ret, len - ret, "%-10u %s",
scope_str[publ->scope]); publ->key, scope_str[publ->scope]);
} }
if (!list_is_last(&publ->zone_list, &info->zone_list)) if (!list_is_last(&publ->zone_list, &info->zone_list))
tipc_printf(buf, "\n%33s", " "); ret += tipc_snprintf(buf + ret, len - ret,
"\n%33s", " ");
}; };
tipc_printf(buf, "\n"); ret += tipc_snprintf(buf + ret, len - ret, "\n");
return ret;
} }
/** /**
* nameseq_list - print specified name sequence contents into the given buffer * nameseq_list - print specified name sequence contents into the given buffer
*/ */
static void nameseq_list(struct name_seq *seq, struct print_buf *buf, u32 depth, static int nameseq_list(struct name_seq *seq, char *buf, int len, u32 depth,
u32 type, u32 lowbound, u32 upbound, u32 index) u32 type, u32 lowbound, u32 upbound, u32 index)
{ {
struct sub_seq *sseq; struct sub_seq *sseq;
char typearea[11]; char typearea[11];
int ret = 0;
if (seq->first_free == 0) if (seq->first_free == 0)
return; return 0;
sprintf(typearea, "%-10u", seq->type); sprintf(typearea, "%-10u", seq->type);
if (depth == 1) { if (depth == 1) {
tipc_printf(buf, "%s\n", typearea); ret += tipc_snprintf(buf, len, "%s\n", typearea);
return; return ret;
} }
for (sseq = seq->sseqs; sseq != &seq->sseqs[seq->first_free]; sseq++) { for (sseq = seq->sseqs; sseq != &seq->sseqs[seq->first_free]; sseq++) {
if ((lowbound <= sseq->upper) && (upbound >= sseq->lower)) { if ((lowbound <= sseq->upper) && (upbound >= sseq->lower)) {
tipc_printf(buf, "%s ", typearea); ret += tipc_snprintf(buf + ret, len - ret, "%s ",
typearea);
spin_lock_bh(&seq->lock); spin_lock_bh(&seq->lock);
subseq_list(sseq, buf, depth, index); ret += subseq_list(sseq, buf + ret, len - ret,
depth, index);
spin_unlock_bh(&seq->lock); spin_unlock_bh(&seq->lock);
sprintf(typearea, "%10s", " "); sprintf(typearea, "%10s", " ");
} }
} }
return ret;
} }
/** /**
* nametbl_header - print name table header into the given buffer * nametbl_header - print name table header into the given buffer
*/ */
static void nametbl_header(struct print_buf *buf, u32 depth) static int nametbl_header(char *buf, int len, u32 depth)
{ {
const char *header[] = { const char *header[] = {
"Type ", "Type ",
@ -829,24 +836,27 @@ static void nametbl_header(struct print_buf *buf, u32 depth)
}; };
int i; int i;
int ret = 0;
if (depth > 4) if (depth > 4)
depth = 4; depth = 4;
for (i = 0; i < depth; i++) for (i = 0; i < depth; i++)
tipc_printf(buf, header[i]); ret += tipc_snprintf(buf + ret, len - ret, header[i]);
tipc_printf(buf, "\n"); ret += tipc_snprintf(buf + ret, len - ret, "\n");
return ret;
} }
/** /**
* nametbl_list - print specified name table contents into the given buffer * nametbl_list - print specified name table contents into the given buffer
*/ */
static void nametbl_list(struct print_buf *buf, u32 depth_info, static int nametbl_list(char *buf, int len, u32 depth_info,
u32 type, u32 lowbound, u32 upbound) u32 type, u32 lowbound, u32 upbound)
{ {
struct hlist_head *seq_head; struct hlist_head *seq_head;
struct hlist_node *seq_node; struct hlist_node *seq_node;
struct name_seq *seq; struct name_seq *seq;
int all_types; int all_types;
int ret = 0;
u32 depth; u32 depth;
u32 i; u32 i;
@ -854,65 +864,69 @@ static void nametbl_list(struct print_buf *buf, u32 depth_info,
depth = (depth_info & ~TIPC_NTQ_ALLTYPES); depth = (depth_info & ~TIPC_NTQ_ALLTYPES);
if (depth == 0) if (depth == 0)
return; return 0;
if (all_types) { if (all_types) {
/* display all entries in name table to specified depth */ /* display all entries in name table to specified depth */
nametbl_header(buf, depth); ret += nametbl_header(buf, len, depth);
lowbound = 0; lowbound = 0;
upbound = ~0; upbound = ~0;
for (i = 0; i < tipc_nametbl_size; i++) { for (i = 0; i < tipc_nametbl_size; i++) {
seq_head = &table.types[i]; seq_head = &table.types[i];
hlist_for_each_entry(seq, seq_node, seq_head, ns_list) { hlist_for_each_entry(seq, seq_node, seq_head, ns_list) {
nameseq_list(seq, buf, depth, seq->type, ret += nameseq_list(seq, buf + ret, len - ret,
lowbound, upbound, i); depth, seq->type,
lowbound, upbound, i);
} }
} }
} else { } else {
/* display only the sequence that matches the specified type */ /* display only the sequence that matches the specified type */
if (upbound < lowbound) { if (upbound < lowbound) {
tipc_printf(buf, "invalid name sequence specified\n"); ret += tipc_snprintf(buf + ret, len - ret,
return; "invalid name sequence specified\n");
return ret;
} }
nametbl_header(buf, depth); ret += nametbl_header(buf + ret, len - ret, depth);
i = hash(type); i = hash(type);
seq_head = &table.types[i]; seq_head = &table.types[i];
hlist_for_each_entry(seq, seq_node, seq_head, ns_list) { hlist_for_each_entry(seq, seq_node, seq_head, ns_list) {
if (seq->type == type) { if (seq->type == type) {
nameseq_list(seq, buf, depth, type, ret += nameseq_list(seq, buf + ret, len - ret,
lowbound, upbound, i); depth, type,
lowbound, upbound, i);
break; break;
} }
} }
} }
return ret;
} }
#define MAX_NAME_TBL_QUERY 32768
struct sk_buff *tipc_nametbl_get(const void *req_tlv_area, int req_tlv_space) struct sk_buff *tipc_nametbl_get(const void *req_tlv_area, int req_tlv_space)
{ {
struct sk_buff *buf; struct sk_buff *buf;
struct tipc_name_table_query *argv; struct tipc_name_table_query *argv;
struct tlv_desc *rep_tlv; struct tlv_desc *rep_tlv;
struct print_buf b; char *pb;
int pb_len;
int str_len; int str_len;
if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_NAME_TBL_QUERY)) if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_NAME_TBL_QUERY))
return tipc_cfg_reply_error_string(TIPC_CFG_TLV_ERROR); return tipc_cfg_reply_error_string(TIPC_CFG_TLV_ERROR);
buf = tipc_cfg_reply_alloc(TLV_SPACE(MAX_NAME_TBL_QUERY)); buf = tipc_cfg_reply_alloc(TLV_SPACE(ULTRA_STRING_MAX_LEN));
if (!buf) if (!buf)
return NULL; return NULL;
rep_tlv = (struct tlv_desc *)buf->data; rep_tlv = (struct tlv_desc *)buf->data;
tipc_printbuf_init(&b, TLV_DATA(rep_tlv), MAX_NAME_TBL_QUERY); pb = TLV_DATA(rep_tlv);
pb_len = ULTRA_STRING_MAX_LEN;
argv = (struct tipc_name_table_query *)TLV_DATA(req_tlv_area); argv = (struct tipc_name_table_query *)TLV_DATA(req_tlv_area);
read_lock_bh(&tipc_nametbl_lock); read_lock_bh(&tipc_nametbl_lock);
nametbl_list(&b, ntohl(argv->depth), ntohl(argv->type), str_len = nametbl_list(pb, pb_len, ntohl(argv->depth),
ntohl(argv->lowbound), ntohl(argv->upbound)); ntohl(argv->type),
ntohl(argv->lowbound), ntohl(argv->upbound));
read_unlock_bh(&tipc_nametbl_lock); read_unlock_bh(&tipc_nametbl_lock);
str_len = tipc_printbuf_validate(&b); str_len += 1; /* for "\0" */
skb_put(buf, TLV_SPACE(str_len)); skb_put(buf, TLV_SPACE(str_len));
TLV_SET(rep_tlv, TIPC_TLV_ULTRA_STRING, NULL, str_len); TLV_SET(rep_tlv, TIPC_TLV_ULTRA_STRING, NULL, str_len);
@ -940,8 +954,10 @@ void tipc_nametbl_stop(void)
/* Verify name table is empty, then release it */ /* Verify name table is empty, then release it */
write_lock_bh(&tipc_nametbl_lock); write_lock_bh(&tipc_nametbl_lock);
for (i = 0; i < tipc_nametbl_size; i++) { for (i = 0; i < tipc_nametbl_size; i++) {
if (!hlist_empty(&table.types[i])) if (hlist_empty(&table.types[i]))
err("tipc_nametbl_stop(): hash chain %u is non-null\n", i); continue;
pr_err("nametbl_stop(): orphaned hash chain detected\n");
break;
} }
kfree(table.types); kfree(table.types);
table.types = NULL; table.types = NULL;

8
net/tipc/net.c
View File

@ -184,9 +184,9 @@ int tipc_net_start(u32 addr)
tipc_cfg_reinit(); tipc_cfg_reinit();
info("Started in network mode\n"); pr_info("Started in network mode\n");
info("Own node address %s, network identity %u\n", pr_info("Own node address %s, network identity %u\n",
tipc_addr_string_fill(addr_string, tipc_own_addr), tipc_net_id); tipc_addr_string_fill(addr_string, tipc_own_addr), tipc_net_id);
return 0; return 0;
} }
@ -202,5 +202,5 @@ void tipc_net_stop(void)
list_for_each_entry_safe(node, t_node, &tipc_node_list, list) list_for_each_entry_safe(node, t_node, &tipc_node_list, list)
tipc_node_delete(node); tipc_node_delete(node);
write_unlock_bh(&tipc_net_lock); write_unlock_bh(&tipc_net_lock);
info("Left network mode\n"); pr_info("Left network mode\n");
} }

2
net/tipc/netlink.c
View File

@ -90,7 +90,7 @@ int tipc_netlink_start(void)
res = genl_register_family_with_ops(&tipc_genl_family, res = genl_register_family_with_ops(&tipc_genl_family,
&tipc_genl_ops, 1); &tipc_genl_ops, 1);
if (res) { if (res) {
err("Failed to register netlink interface\n"); pr_err("Failed to register netlink interface\n");
return res; return res;
} }

22
net/tipc/node.c
View File

@ -105,7 +105,7 @@ struct tipc_node *tipc_node_create(u32 addr)
n_ptr = kzalloc(sizeof(*n_ptr), GFP_ATOMIC); n_ptr = kzalloc(sizeof(*n_ptr), GFP_ATOMIC);
if (!n_ptr) { if (!n_ptr) {
spin_unlock_bh(&node_create_lock); spin_unlock_bh(&node_create_lock);
warn("Node creation failed, no memory\n"); pr_warn("Node creation failed, no memory\n");
return NULL; return NULL;
} }
@ -151,8 +151,8 @@ void tipc_node_link_up(struct tipc_node *n_ptr, struct tipc_link *l_ptr)
n_ptr->working_links++; n_ptr->working_links++;
info("Established link <%s> on network plane %c\n", pr_info("Established link <%s> on network plane %c\n",
l_ptr->name, l_ptr->b_ptr->net_plane); l_ptr->name, l_ptr->b_ptr->net_plane);
if (!active[0]) { if (!active[0]) {
active[0] = active[1] = l_ptr; active[0] = active[1] = l_ptr;
@ -160,7 +160,7 @@ void tipc_node_link_up(struct tipc_node *n_ptr, struct tipc_link *l_ptr)
return; return;
} }
if (l_ptr->priority < active[0]->priority) { if (l_ptr->priority < active[0]->priority) {
info("New link <%s> becomes standby\n", l_ptr->name); pr_info("New link <%s> becomes standby\n", l_ptr->name);
return; return;
} }
tipc_link_send_duplicate(active[0], l_ptr); tipc_link_send_duplicate(active[0], l_ptr);
@ -168,9 +168,9 @@ void tipc_node_link_up(struct tipc_node *n_ptr, struct tipc_link *l_ptr)
active[0] = l_ptr; active[0] = l_ptr;
return; return;
} }
info("Old link <%s> becomes standby\n", active[0]->name); pr_info("Old link <%s> becomes standby\n", active[0]->name);
if (active[1] != active[0]) if (active[1] != active[0])
info("Old link <%s> becomes standby\n", active[1]->name); pr_info("Old link <%s> becomes standby\n", active[1]->name);
active[0] = active[1] = l_ptr; active[0] = active[1] = l_ptr;
} }
@ -211,11 +211,11 @@ void tipc_node_link_down(struct tipc_node *n_ptr, struct tipc_link *l_ptr)
n_ptr->working_links--; n_ptr->working_links--;
if (!tipc_link_is_active(l_ptr)) { if (!tipc_link_is_active(l_ptr)) {
info("Lost standby link <%s> on network plane %c\n", pr_info("Lost standby link <%s> on network plane %c\n",
l_ptr->name, l_ptr->b_ptr->net_plane); l_ptr->name, l_ptr->b_ptr->net_plane);
return; return;
} }
info("Lost link <%s> on network plane %c\n", pr_info("Lost link <%s> on network plane %c\n",
l_ptr->name, l_ptr->b_ptr->net_plane); l_ptr->name, l_ptr->b_ptr->net_plane);
active = &n_ptr->active_links[0]; active = &n_ptr->active_links[0];
@ -290,8 +290,8 @@ static void node_lost_contact(struct tipc_node *n_ptr)
char addr_string[16]; char addr_string[16];
u32 i; u32 i;
info("Lost contact with %s\n", pr_info("Lost contact with %s\n",
tipc_addr_string_fill(addr_string, n_ptr->addr)); tipc_addr_string_fill(addr_string, n_ptr->addr));
/* Flush broadcast link info associated with lost node */ /* Flush broadcast link info associated with lost node */
if (n_ptr->bclink.supported) { if (n_ptr->bclink.supported) {

3
net/tipc/node_subscr.c
View File

@ -51,7 +51,8 @@ void tipc_nodesub_subscribe(struct tipc_node_subscr *node_sub, u32 addr,
node_sub->node = tipc_node_find(addr); node_sub->node = tipc_node_find(addr);
if (!node_sub->node) { if (!node_sub->node) {
warn("Node subscription rejected, unknown node 0x%x\n", addr); pr_warn("Node subscription rejected, unknown node 0x%x\n",
addr);
return; return;
} }
node_sub->handle_node_down = handle_down; node_sub->handle_node_down = handle_down;

66
net/tipc/port.c
View File

@ -191,7 +191,7 @@ void tipc_port_recv_mcast(struct sk_buff *buf, struct tipc_port_list *dp)
struct sk_buff *b = skb_clone(buf, GFP_ATOMIC); struct sk_buff *b = skb_clone(buf, GFP_ATOMIC);
if (b == NULL) { if (b == NULL) {
warn("Unable to deliver multicast message(s)\n"); pr_warn("Unable to deliver multicast message(s)\n");
goto exit; goto exit;
} }
if ((index == 0) && (cnt != 0)) if ((index == 0) && (cnt != 0))
@ -221,12 +221,12 @@ struct tipc_port *tipc_createport_raw(void *usr_handle,
p_ptr = kzalloc(sizeof(*p_ptr), GFP_ATOMIC); p_ptr = kzalloc(sizeof(*p_ptr), GFP_ATOMIC);
if (!p_ptr) { if (!p_ptr) {
warn("Port creation failed, no memory\n"); pr_warn("Port creation failed, no memory\n");
return NULL; return NULL;
} }
ref = tipc_ref_acquire(p_ptr, &p_ptr->lock); ref = tipc_ref_acquire(p_ptr, &p_ptr->lock);
if (!ref) { if (!ref) {
warn("Port creation failed, reference table exhausted\n"); pr_warn("Port creation failed, ref. table exhausted\n");
kfree(p_ptr); kfree(p_ptr);
return NULL; return NULL;
} }
@ -581,67 +581,73 @@ exit:
kfree_skb(buf); kfree_skb(buf);
} }
static void port_print(struct tipc_port *p_ptr, struct print_buf *buf, int full_id) static int port_print(struct tipc_port *p_ptr, char *buf, int len, int full_id)
{ {
struct publication *publ; struct publication *publ;
int ret;
if (full_id) if (full_id)
tipc_printf(buf, "<%u.%u.%u:%u>:", ret = tipc_snprintf(buf, len, "<%u.%u.%u:%u>:",
tipc_zone(tipc_own_addr), tipc_cluster(tipc_own_addr), tipc_zone(tipc_own_addr),
tipc_node(tipc_own_addr), p_ptr->ref); tipc_cluster(tipc_own_addr),
tipc_node(tipc_own_addr), p_ptr->ref);
else else
tipc_printf(buf, "%-10u:", p_ptr->ref); ret = tipc_snprintf(buf, len, "%-10u:", p_ptr->ref);
if (p_ptr->connected) { if (p_ptr->connected) {
u32 dport = port_peerport(p_ptr); u32 dport = port_peerport(p_ptr);
u32 destnode = port_peernode(p_ptr); u32 destnode = port_peernode(p_ptr);
tipc_printf(buf, " connected to <%u.%u.%u:%u>", ret += tipc_snprintf(buf + ret, len - ret,
tipc_zone(destnode), tipc_cluster(destnode), " connected to <%u.%u.%u:%u>",
tipc_node(destnode), dport); tipc_zone(destnode),
tipc_cluster(destnode),
tipc_node(destnode), dport);
if (p_ptr->conn_type != 0) if (p_ptr->conn_type != 0)
tipc_printf(buf, " via {%u,%u}", ret += tipc_snprintf(buf + ret, len - ret,
p_ptr->conn_type, " via {%u,%u}", p_ptr->conn_type,
p_ptr->conn_instance); p_ptr->conn_instance);
} else if (p_ptr->published) { } else if (p_ptr->published) {
tipc_printf(buf, " bound to"); ret += tipc_snprintf(buf + ret, len - ret, " bound to");
list_for_each_entry(publ, &p_ptr->publications, pport_list) { list_for_each_entry(publ, &p_ptr->publications, pport_list) {
if (publ->lower == publ->upper) if (publ->lower == publ->upper)
tipc_printf(buf, " {%u,%u}", publ->type, ret += tipc_snprintf(buf + ret, len - ret,
publ->lower); " {%u,%u}", publ->type,
publ->lower);
else else
tipc_printf(buf, " {%u,%u,%u}", publ->type, ret += tipc_snprintf(buf + ret, len - ret,
publ->lower, publ->upper); " {%u,%u,%u}", publ->type,
publ->lower, publ->upper);
} }
} }
tipc_printf(buf, "\n"); ret += tipc_snprintf(buf + ret, len - ret, "\n");
return ret;
} }
#define MAX_PORT_QUERY 32768
struct sk_buff *tipc_port_get_ports(void) struct sk_buff *tipc_port_get_ports(void)
{ {
struct sk_buff *buf; struct sk_buff *buf;
struct tlv_desc *rep_tlv; struct tlv_desc *rep_tlv;
struct print_buf pb; char *pb;
int pb_len;
struct tipc_port *p_ptr; struct tipc_port *p_ptr;
int str_len; int str_len = 0;
buf = tipc_cfg_reply_alloc(TLV_SPACE(MAX_PORT_QUERY)); buf = tipc_cfg_reply_alloc(TLV_SPACE(ULTRA_STRING_MAX_LEN));
if (!buf) if (!buf)
return NULL; return NULL;
rep_tlv = (struct tlv_desc *)buf->data; rep_tlv = (struct tlv_desc *)buf->data;
pb = TLV_DATA(rep_tlv);
pb_len = ULTRA_STRING_MAX_LEN;
tipc_printbuf_init(&pb, TLV_DATA(rep_tlv), MAX_PORT_QUERY);
spin_lock_bh(&tipc_port_list_lock); spin_lock_bh(&tipc_port_list_lock);
list_for_each_entry(p_ptr, &ports, port_list) { list_for_each_entry(p_ptr, &ports, port_list) {
spin_lock_bh(p_ptr->lock); spin_lock_bh(p_ptr->lock);
port_print(p_ptr, &pb, 0); str_len += port_print(p_ptr, pb, pb_len, 0);
spin_unlock_bh(p_ptr->lock); spin_unlock_bh(p_ptr->lock);
} }
spin_unlock_bh(&tipc_port_list_lock); spin_unlock_bh(&tipc_port_list_lock);
str_len = tipc_printbuf_validate(&pb); str_len += 1; /* for "\0" */
skb_put(buf, TLV_SPACE(str_len)); skb_put(buf, TLV_SPACE(str_len));
TLV_SET(rep_tlv, TIPC_TLV_ULTRA_STRING, NULL, str_len); TLV_SET(rep_tlv, TIPC_TLV_ULTRA_STRING, NULL, str_len);
@ -906,7 +912,7 @@ int tipc_createport(void *usr_handle,
up_ptr = kmalloc(sizeof(*up_ptr), GFP_ATOMIC); up_ptr = kmalloc(sizeof(*up_ptr), GFP_ATOMIC);
if (!up_ptr) { if (!up_ptr) {
warn("Port creation failed, no memory\n"); pr_warn("Port creation failed, no memory\n");
return -ENOMEM; return -ENOMEM;
} }
p_ptr = tipc_createport_raw(NULL, port_dispatcher, port_wakeup, p_ptr = tipc_createport_raw(NULL, port_dispatcher, port_wakeup,

10
net/tipc/ref.c
View File

@ -153,11 +153,11 @@ u32 tipc_ref_acquire(void *object, spinlock_t **lock)
struct reference *entry = NULL; struct reference *entry = NULL;
if (!object) { if (!object) {
err("Attempt to acquire reference to non-existent object\n"); pr_err("Attempt to acquire ref. to non-existent obj\n");
return 0; return 0;
} }
if (!tipc_ref_table.entries) { if (!tipc_ref_table.entries) {
err("Reference table not found during acquisition attempt\n"); pr_err("Ref. table not found in acquisition attempt\n");
return 0; return 0;
} }
@ -211,7 +211,7 @@ void tipc_ref_discard(u32 ref)
u32 index_mask; u32 index_mask;
if (!tipc_ref_table.entries) { if (!tipc_ref_table.entries) {
err("Reference table not found during discard attempt\n"); pr_err("Ref. table not found during discard attempt\n");
return; return;
} }
@ -222,11 +222,11 @@ void tipc_ref_discard(u32 ref)
write_lock_bh(&ref_table_lock); write_lock_bh(&ref_table_lock);
if (!entry->object) { if (!entry->object) {
err("Attempt to discard reference to non-existent object\n"); pr_err("Attempt to discard ref. to non-existent obj\n");
goto exit; goto exit;
} }
if (entry->ref != ref) { if (entry->ref != ref) {
err("Attempt to discard non-existent reference\n"); pr_err("Attempt to discard non-existent reference\n");
goto exit; goto exit;
} }

10
net/tipc/socket.c
View File

@ -34,12 +34,12 @@
* POSSIBILITY OF SUCH DAMAGE. * POSSIBILITY OF SUCH DAMAGE.
*/ */
#include <linux/export.h>
#include <net/sock.h>
#include "core.h" #include "core.h"
#include "port.h" #include "port.h"
#include <linux/export.h>
#include <net/sock.h>
#define SS_LISTENING -1 /* socket is listening */ #define SS_LISTENING -1 /* socket is listening */
#define SS_READY -2 /* socket is connectionless */ #define SS_READY -2 /* socket is connectionless */
@ -1787,13 +1787,13 @@ int tipc_socket_init(void)
res = proto_register(&tipc_proto, 1); res = proto_register(&tipc_proto, 1);
if (res) { if (res) {
err("Failed to register TIPC protocol type\n"); pr_err("Failed to register TIPC protocol type\n");
goto out; goto out;
} }
res = sock_register(&tipc_family_ops); res = sock_register(&tipc_family_ops);
if (res) { if (res) {
err("Failed to register TIPC socket type\n"); pr_err("Failed to register TIPC socket type\n");
proto_unregister(&tipc_proto); proto_unregister(&tipc_proto);
goto out; goto out;
} }

14
net/tipc/subscr.c
View File

@ -305,8 +305,8 @@ static struct tipc_subscription *subscr_subscribe(struct tipc_subscr *s,
/* Refuse subscription if global limit exceeded */ /* Refuse subscription if global limit exceeded */
if (atomic_read(&topsrv.subscription_count) >= tipc_max_subscriptions) { if (atomic_read(&topsrv.subscription_count) >= tipc_max_subscriptions) {
warn("Subscription rejected, subscription limit reached (%u)\n", pr_warn("Subscription rejected, limit reached (%u)\n",
tipc_max_subscriptions); tipc_max_subscriptions);
subscr_terminate(subscriber); subscr_terminate(subscriber);
return NULL; return NULL;
} }
@ -314,7 +314,7 @@ static struct tipc_subscription *subscr_subscribe(struct tipc_subscr *s,
/* Allocate subscription object */ /* Allocate subscription object */
sub = kmalloc(sizeof(*sub), GFP_ATOMIC); sub = kmalloc(sizeof(*sub), GFP_ATOMIC);
if (!sub) { if (!sub) {
warn("Subscription rejected, no memory\n"); pr_warn("Subscription rejected, no memory\n");
subscr_terminate(subscriber); subscr_terminate(subscriber);
return NULL; return NULL;
} }
@ -328,7 +328,7 @@ static struct tipc_subscription *subscr_subscribe(struct tipc_subscr *s,
if ((!(sub->filter & TIPC_SUB_PORTS) == if ((!(sub->filter & TIPC_SUB_PORTS) ==
!(sub->filter & TIPC_SUB_SERVICE)) || !(sub->filter & TIPC_SUB_SERVICE)) ||
(sub->seq.lower > sub->seq.upper)) { (sub->seq.lower > sub->seq.upper)) {
warn("Subscription rejected, illegal request\n"); pr_warn("Subscription rejected, illegal request\n");
kfree(sub); kfree(sub);
subscr_terminate(subscriber); subscr_terminate(subscriber);
return NULL; return NULL;
@ -440,7 +440,7 @@ static void subscr_named_msg_event(void *usr_handle,
/* Create subscriber object */ /* Create subscriber object */
subscriber = kzalloc(sizeof(struct tipc_subscriber), GFP_ATOMIC); subscriber = kzalloc(sizeof(struct tipc_subscriber), GFP_ATOMIC);
if (subscriber == NULL) { if (subscriber == NULL) {
warn("Subscriber rejected, no memory\n"); pr_warn("Subscriber rejected, no memory\n");
return; return;
} }
INIT_LIST_HEAD(&subscriber->subscription_list); INIT_LIST_HEAD(&subscriber->subscription_list);
@ -458,7 +458,7 @@ static void subscr_named_msg_event(void *usr_handle,
NULL, NULL,
&subscriber->port_ref); &subscriber->port_ref);
if (subscriber->port_ref == 0) { if (subscriber->port_ref == 0) {
warn("Subscriber rejected, unable to create port\n"); pr_warn("Subscriber rejected, unable to create port\n");
kfree(subscriber); kfree(subscriber);
return; return;
} }
@ -517,7 +517,7 @@ int tipc_subscr_start(void)
return 0; return 0;
failed: failed:
err("Failed to create subscription service\n"); pr_err("Failed to create subscription service\n");
return res; return res;
} }