Piteball
/
android_kernel_samsung_msm8976
mirror of https://github.com/team-infusion-developers/android_kernel_samsung_msm8976.git
1
1
Fork 0
Code Issues Projects Releases Wiki Activity

net: ipc: Add common string for IPC Router error message 

IPC Router logs error messages to kernel log. These error messages
do not have a common string to search for in kernel logs which makes
it difficult to identify the IPC Router error message while debugging
issues.

Add a common string as a part of error message printed from IPC Router.

Change-Id: Ie87e4bdb215fe7d7ef4c5788a77f862e312f80f2
Signed-off-by: Zaheerulla Meer <zmeer@codeaurora.org>
This commit is contained in:
Zaheerulla Meer 2014-03-20 19:10:45 +05:30
parent 538c521c76
commit bb6521ef1c
5 changed files with 205 additions and 169 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

51
drivers/soc/qcom/ipc_router_hsic_xprt.c
View File

@ -215,34 +215,34 @@ static int msm_ipc_router_hsic_remote_write(void *data,
int ret;
if (!pkt || pkt->length != len || !xprt) {
pr_err("%s: Invalid input parameters\n", __func__);
IPC_RTR_ERR("%s: Invalid input parameters\n", __func__);
return -EINVAL;
}
hsic_xprtp = container_of(xprt, struct msm_ipc_router_hsic_xprt, xprt);
mutex_lock(&hsic_xprtp->ss_reset_lock);
if (hsic_xprtp->ss_reset) {
pr_err("%s: Trying to write on a reset link\n", __func__);
IPC_RTR_ERR("%s: Trying to write on a reset link\n", __func__);
mutex_unlock(&hsic_xprtp->ss_reset_lock);
return -ENETRESET;
}
if (!hsic_xprtp->pdev) {
pr_err("%s: Trying to write on a closed link\n", __func__);
IPC_RTR_ERR("%s: Trying to write on a closed link\n", __func__);
mutex_unlock(&hsic_xprtp->ss_reset_lock);
return -ENODEV;
}
pdata = hsic_xprtp->pdev->dev.platform_data;
if (!pdata || !pdata->write) {
pr_err("%s on a uninitialized link\n", __func__);
IPC_RTR_ERR("%s on a uninitialized link\n", __func__);
mutex_unlock(&hsic_xprtp->ss_reset_lock);
return -EFAULT;
}
skb = skb_peek(pkt->pkt_fragment_q);
if (!skb) {
pr_err("%s SKB is NULL\n", __func__);
IPC_RTR_ERR("%s SKB is NULL\n", __func__);
mutex_unlock(&hsic_xprtp->ss_reset_lock);
return -EINVAL;
}
@ -315,7 +315,8 @@ static void hsic_xprt_read_data(struct work_struct *work)
GFP_KERNEL);
if (hsic_xprtp->in_pkt)
break;
pr_err("%s: packet allocation failure\n", __func__);
IPC_RTR_ERR("%s: packet allocation failure\n",
__func__);
msleep(100);
}
while (!hsic_xprtp->in_pkt->pkt_fragment_q) {
@ -324,7 +325,7 @@ static void hsic_xprt_read_data(struct work_struct *work)
GFP_KERNEL);
if (hsic_xprtp->in_pkt->pkt_fragment_q)
break;
pr_err("%s: Couldn't alloc pkt_fragment_q\n",
IPC_RTR_ERR("%s: Couldn't alloc pkt_fragment_q\n",
__func__);
msleep(100);
}
@ -335,14 +336,14 @@ static void hsic_xprt_read_data(struct work_struct *work)
skb = alloc_skb(pdata->max_read_size, GFP_KERNEL);
if (skb)
break;
pr_err("%s: Couldn't alloc SKB\n", __func__);
IPC_RTR_ERR("%s: Couldn't alloc SKB\n", __func__);
msleep(100);
}
data = skb_put(skb, pdata->max_read_size);
pkt_size = pdata->read(hsic_xprtp->pdev, data,
pdata->max_read_size);
if (pkt_size < 0) {
pr_err("%s: Error %d @ read operation\n",
IPC_RTR_ERR("%s: Error %d @ read operation\n",
__func__, pkt_size);
kfree_skb(skb);
kfree(hsic_xprtp->in_pkt->pkt_fragment_q);
@ -391,7 +392,8 @@ static int msm_ipc_router_hsic_remote_remove(struct platform_device *pdev)
hsic_xprtp = find_hsic_xprt_list(pdev->name);
if (!hsic_xprtp) {
pr_err("%s No device with name %s\n", __func__, pdev->name);
IPC_RTR_ERR("%s No device with name %s\n",
__func__, pdev->name);
return -ENODEV;
}
@ -431,27 +433,29 @@ static int msm_ipc_router_hsic_remote_probe(struct platform_device *pdev)
pdata = pdev->dev.platform_data;
if (!pdata || !pdata->open || !pdata->read ||
!pdata->write || !pdata->close) {
pr_err("%s: pdata or pdata->operations is NULL\n", __func__);
IPC_RTR_ERR("%s: pdata or pdata->operations is NULL\n",
__func__);
return -EINVAL;
}
hsic_xprtp = find_hsic_xprt_list(pdev->name);
if (!hsic_xprtp) {
pr_err("%s No device with name %s\n", __func__, pdev->name);
IPC_RTR_ERR("%s No device with name %s\n",
__func__, pdev->name);
return -ENODEV;
}
hsic_xprtp->hsic_xprt_wq =
create_singlethread_workqueue(pdev->name);
if (!hsic_xprtp->hsic_xprt_wq) {
pr_err("%s: WQ creation failed for %s\n",
IPC_RTR_ERR("%s: WQ creation failed for %s\n",
__func__, pdev->name);
return -EFAULT;
}
rc = pdata->open(pdev);
if (rc < 0) {
pr_err("%s: Channel open failed for %s.%d\n",
IPC_RTR_ERR("%s: Channel open failed for %s.%d\n",
__func__, pdev->name, pdev->id);
destroy_workqueue(hsic_xprtp->hsic_xprt_wq);
return rc;
@ -496,12 +500,13 @@ static int msm_ipc_router_hsic_driver_register(
ret = platform_driver_register(&hsic_xprtp->driver);
if (ret) {
pr_err("%s: Failed to register platform driver[%s]\n",
IPC_RTR_ERR(
"%s: Failed to register platform driver[%s]\n",
__func__, hsic_xprtp->ch_name);
return ret;
}
} else {
pr_err("%s Already driver registered %s\n",
IPC_RTR_ERR("%s Already driver registered %s\n",
__func__, hsic_xprtp->ch_name);
}
@ -526,7 +531,7 @@ static int msm_ipc_router_hsic_config_init(
hsic_xprtp = kzalloc(sizeof(struct msm_ipc_router_hsic_xprt),
GFP_KERNEL);
if (IS_ERR_OR_NULL(hsic_xprtp)) {
pr_err("%s: kzalloc() failed for hsic_xprtp id:%s\n",
IPC_RTR_ERR("%s: kzalloc() failed for hsic_xprtp id:%s\n",
__func__, hsic_xprt_config->ch_name);
return -ENOMEM;
}
@ -612,7 +617,7 @@ static int parse_devicetree(struct device_node *node,
return 0;
error:
pr_err("%s: missing key: %s\n", __func__, key);
IPC_RTR_ERR("%s: missing key: %s\n", __func__, key);
return -ENODEV;
}
@ -639,14 +644,15 @@ static int msm_ipc_router_hsic_xprt_probe(
ret = parse_devicetree(pdev->dev.of_node,
&hsic_xprt_config);
if (ret) {
pr_err(" failed to parse device tree\n");
IPC_RTR_ERR("%s: Failed to parse device tree\n",
__func__);
return ret;
}
ret = msm_ipc_router_hsic_config_init(
&hsic_xprt_config);
if (ret) {
pr_err(" %s init failed\n", __func__);
IPC_RTR_ERR(" %s init failed\n", __func__);
return ret;
}
}
@ -675,7 +681,7 @@ static void ipc_router_hsic_xprt_probe_worker(struct work_struct *work)
ret = msm_ipc_router_hsic_config_init(
&hsic_xprt_cfg[i]);
if (ret)
pr_err(" %s init failed config idx %d\n",
IPC_RTR_ERR(" %s init failed config idx %d\n",
__func__, i);
}
mutex_lock(&hsic_remote_xprt_list_lock_lha1);
@ -703,7 +709,8 @@ static int __init msm_ipc_router_hsic_xprt_init(void)
rc = platform_driver_register(&msm_ipc_router_hsic_xprt_driver);
if (rc) {
pr_err("%s: msm_ipc_router_hsic_xprt_driver register failed %d\n",
IPC_RTR_ERR(
"%s: msm_ipc_router_hsic_xprt_driver register failed %d\n",
__func__, rc);
return rc;
}

54
drivers/soc/qcom/ipc_router_smd_xprt.c
View File

@ -187,12 +187,13 @@ static int msm_ipc_router_smd_remote_write(void *data,
if (smd_xprtp->ss_reset) {
spin_unlock_irqrestore(&smd_xprtp->ss_reset_lock,
flags);
pr_err("%s: %s chnl reset\n", __func__, xprt->name);
IPC_RTR_ERR("%s: %s chnl reset\n",
__func__, xprt->name);
return -ENETRESET;
}
spin_unlock_irqrestore(&smd_xprtp->ss_reset_lock, flags);
if (num_retries >= 5) {
pr_err("%s: Error %d @smd_write_start for %s\n",
IPC_RTR_ERR("%s: Error %d @smd_write_start for %s\n",
__func__, ret, xprt->name);
return ret;
}
@ -215,7 +216,7 @@ static int msm_ipc_router_smd_remote_write(void *data,
if (smd_xprtp->ss_reset) {
spin_unlock_irqrestore(
&smd_xprtp->ss_reset_lock, flags);
pr_err("%s: %s chnl reset\n",
IPC_RTR_ERR("%s: %s chnl reset\n",
__func__, xprt->name);
return -ENETRESET;
}
@ -275,7 +276,7 @@ static void smd_xprt_read_data(struct work_struct *work)
if (smd_xprtp->in_pkt)
release_pkt(smd_xprtp->in_pkt);
smd_xprtp->is_partial_in_pkt = 0;
pr_err("%s: %s channel reset\n",
IPC_RTR_ERR("%s: %s channel reset\n",
__func__, smd_xprtp->xprt.name);
return;
}
@ -290,7 +291,7 @@ static void smd_xprt_read_data(struct work_struct *work)
smd_xprtp->in_pkt = kzalloc(sizeof(struct rr_packet),
GFP_KERNEL);
if (!smd_xprtp->in_pkt) {
pr_err("%s: Couldn't alloc rr_packet\n",
IPC_RTR_ERR("%s: Couldn't alloc rr_packet\n",
__func__);
return;
}
@ -299,7 +300,8 @@ static void smd_xprt_read_data(struct work_struct *work)
kmalloc(sizeof(struct sk_buff_head),
GFP_KERNEL);
if (!smd_xprtp->in_pkt->pkt_fragment_q) {
pr_err("%s: Couldn't alloc pkt_fragment_q\n",
IPC_RTR_ERR(
"%s: Couldn't alloc pkt_fragment_q\n",
__func__);
kfree(smd_xprtp->in_pkt);
return;
@ -334,7 +336,7 @@ static void smd_xprt_read_data(struct work_struct *work)
data = skb_put(ipc_rtr_pkt, sz);
sz_read = smd_read(smd_xprtp->channel, data, sz);
if (sz_read != sz) {
pr_err("%s: Couldn't read %s completely\n",
IPC_RTR_ERR("%s: Couldn't read %s completely\n",
__func__, smd_xprtp->xprt.name);
kfree_skb(ipc_rtr_pkt);
release_pkt(smd_xprtp->in_pkt);
@ -419,7 +421,8 @@ static void msm_ipc_router_smd_remote_notify(void *_dev, unsigned event)
xprt_work = kmalloc(sizeof(struct msm_ipc_router_smd_xprt_work),
GFP_ATOMIC);
if (!xprt_work) {
pr_err("%s: Couldn't notify %d event to IPC Router\n",
IPC_RTR_ERR(
"%s: Couldn't notify %d event to IPC Router\n",
__func__, event);
return;
}
@ -436,7 +439,8 @@ static void msm_ipc_router_smd_remote_notify(void *_dev, unsigned event)
xprt_work = kmalloc(sizeof(struct msm_ipc_router_smd_xprt_work),
GFP_ATOMIC);
if (!xprt_work) {
pr_err("%s: Couldn't notify %d event to IPC Router\n",
IPC_RTR_ERR(
"%s: Couldn't notify %d event to IPC Router\n",
__func__, event);
return;
}
@ -456,7 +460,7 @@ static void *msm_ipc_load_subsystem(uint32_t edge)
if (!IS_ERR_OR_NULL(peripheral)) {
pil = subsystem_get(peripheral);
if (IS_ERR(pil)) {
pr_err("%s: Failed to load %s\n",
IPC_RTR_ERR("%s: Failed to load %s\n",
__func__, peripheral);
pil = NULL;
}
@ -507,19 +511,20 @@ static int msm_ipc_router_smd_remote_probe(struct platform_device *pdev)
smd_xprtp = find_smd_xprt_list(pdev);
if (!smd_xprtp) {
pr_err("%s No device with name %s\n", __func__, pdev->name);
IPC_RTR_ERR("%s No device with name %s\n",
__func__, pdev->name);
return -EPROBE_DEFER;
}
if (strcmp(pdev->name, smd_xprtp->ch_name)
|| (pdev->id != smd_xprtp->edge)) {
pr_err("%s wrong item name:%s edge:%d\n",
IPC_RTR_ERR("%s wrong item name:%s edge:%d\n",
__func__, smd_xprtp->ch_name, smd_xprtp->edge);
return -ENODEV;
}
smd_xprtp->smd_xprt_wq =
create_singlethread_workqueue(pdev->name);
if (!smd_xprtp->smd_xprt_wq) {
pr_err("%s: WQ creation failed for %s\n",
IPC_RTR_ERR("%s: WQ creation failed for %s\n",
__func__, pdev->name);
return -EFAULT;
}
@ -532,7 +537,7 @@ static int msm_ipc_router_smd_remote_probe(struct platform_device *pdev)
smd_xprtp,
msm_ipc_router_smd_remote_notify);
if (rc < 0) {
pr_err("%s: Channel open failed for %s\n",
IPC_RTR_ERR("%s: Channel open failed for %s\n",
__func__, smd_xprtp->ch_name);
if (smd_xprtp->pil) {
subsystem_put(smd_xprtp->pil);
@ -574,7 +579,7 @@ static void pil_vote_load_worker(struct work_struct *work)
if (!IS_ERR_OR_NULL(peripheral) && !strcmp(peripheral, "modem")) {
vote_info->pil_handle = subsystem_get(peripheral);
if (IS_ERR(vote_info->pil_handle)) {
pr_err("%s: Failed to load %s\n",
IPC_RTR_ERR("%s: Failed to load %s\n",
__func__, peripheral);
vote_info->pil_handle = NULL;
}
@ -684,12 +689,13 @@ static int msm_ipc_router_smd_driver_register(
ret = platform_driver_register(&smd_xprtp->driver);
if (ret) {
pr_err("%s: Failed to register platform driver [%s]\n",
IPC_RTR_ERR(
"%s: Failed to register platform driver [%s]\n",
__func__, smd_xprtp->ch_name);
return ret;
}
} else {
pr_err("%s Already driver registered %s\n",
IPC_RTR_ERR("%s Already driver registered %s\n",
__func__, smd_xprtp->ch_name);
}
return 0;
@ -712,7 +718,7 @@ static int msm_ipc_router_smd_config_init(
smd_xprtp = kzalloc(sizeof(struct msm_ipc_router_smd_xprt), GFP_KERNEL);
if (IS_ERR_OR_NULL(smd_xprtp)) {
pr_err("%s: kzalloc() failed for smd_xprtp id:%s\n",
IPC_RTR_ERR("%s: kzalloc() failed for smd_xprtp id:%s\n",
__func__, smd_xprt_config->ch_name);
return -ENOMEM;
}
@ -809,7 +815,7 @@ static int parse_devicetree(struct device_node *node,
return 0;
error:
pr_err("%s: missing key: %s\n", __func__, key);
IPC_RTR_ERR("%s: missing key: %s\n", __func__, key);
return -ENODEV;
}
@ -837,13 +843,14 @@ static int msm_ipc_router_smd_xprt_probe(struct platform_device *pdev)
ret = parse_devicetree(pdev->dev.of_node,
&smd_xprt_config);
if (ret) {
pr_err(" failed to parse device tree\n");
IPC_RTR_ERR("%s: Failed to parse device tree\n",
__func__);
return ret;
}
ret = msm_ipc_router_smd_config_init(&smd_xprt_config);
if (ret) {
pr_err("%s init failed\n", __func__);
IPC_RTR_ERR("%s init failed\n", __func__);
return ret;
}
}
@ -872,7 +879,7 @@ static void ipc_router_smd_xprt_probe_worker(struct work_struct *work)
for (i = 0; i < ARRAY_SIZE(smd_xprt_cfg); i++) {
ret = msm_ipc_router_smd_config_init(&smd_xprt_cfg[i]);
if (ret)
pr_err(" %s init failed config idx %d\n",
IPC_RTR_ERR(" %s init failed config idx %d\n",
__func__, i);
}
mutex_lock(&smd_remote_xprt_list_lock_lha1);
@ -900,7 +907,8 @@ static int __init msm_ipc_router_smd_xprt_init(void)
rc = platform_driver_register(&msm_ipc_router_smd_xprt_driver);
if (rc) {
pr_err("%s: msm_ipc_router_smd_xprt_driver register failed %d\n",
IPC_RTR_ERR(
"%s: msm_ipc_router_smd_xprt_driver register failed %d\n",
__func__, rc);
return rc;
}

3
include/linux/ipc_router.h
View File

@ -25,6 +25,9 @@
/* Maximum Wakeup Source Name Size */
#define MAX_WS_NAME_SZ 32
#define IPC_RTR_ERR(buf, ...) \
pr_err("IPC_RTR: " buf, __VA_ARGS__)
/**
* enum msm_ipc_router_event - Events that will be generated by IPC Router
*/

219
net/ipc_router/ipc_router_core.c
View File

@ -215,7 +215,7 @@ static struct msm_ipc_routing_table_entry *alloc_routing_table_entry(
rt_entry = kmalloc(sizeof(struct msm_ipc_routing_table_entry),
GFP_KERNEL);
if (!rt_entry) {
pr_err("%s: rt_entry allocation failed for %d\n",
IPC_RTR_ERR("%s: rt_entry allocation failed for %d\n",
__func__, node_id);
return NULL;
}
@ -267,7 +267,7 @@ struct rr_packet *rr_read(struct msm_ipc_router_xprt_info *xprt_info)
mutex_lock(&xprt_info->rx_lock_lhb2);
if (xprt_info->abort_data_read) {
mutex_unlock(&xprt_info->rx_lock_lhb2);
pr_err("%s detected SSR & exiting now\n",
IPC_RTR_ERR("%s detected SSR & exiting now\n",
xprt_info->xprt->name);
return NULL;
}
@ -294,7 +294,7 @@ struct rr_packet *clone_pkt(struct rr_packet *pkt)
cloned_pkt = kzalloc(sizeof(struct rr_packet), GFP_KERNEL);
if (!cloned_pkt) {
pr_err("%s: failure\n", __func__);
IPC_RTR_ERR("%s: failure\n", __func__);
return NULL;
}
memcpy(&(cloned_pkt->hdr), &(pkt->hdr), sizeof(struct rr_header_v1));
@ -302,7 +302,7 @@ struct rr_packet *clone_pkt(struct rr_packet *pkt)
pkt_fragment_q = kmalloc(sizeof(struct sk_buff_head), GFP_KERNEL);
if (!pkt_fragment_q) {
pr_err("%s: pkt_frag_q alloc failure\n", __func__);
IPC_RTR_ERR("%s: pkt_frag_q alloc failure\n", __func__);
kfree(cloned_pkt);
return NULL;
}
@ -336,7 +336,7 @@ struct rr_packet *create_pkt(struct sk_buff_head *data)
pkt = kzalloc(sizeof(struct rr_packet), GFP_KERNEL);
if (!pkt) {
pr_err("%s: failure\n", __func__);
IPC_RTR_ERR("%s: failure\n", __func__);
return NULL;
}
@ -381,7 +381,7 @@ static struct sk_buff_head *msm_ipc_router_buf_to_skb(void *buf,
skb_head = kmalloc(sizeof(struct sk_buff_head), GFP_KERNEL);
if (!skb_head) {
pr_err("%s: Couldnot allocate skb_head\n", __func__);
IPC_RTR_ERR("%s: Couldnot allocate skb_head\n", __func__);
return NULL;
}
skb_queue_head_init(skb_head);
@ -398,7 +398,8 @@ static struct sk_buff_head *msm_ipc_router_buf_to_skb(void *buf,
skb = alloc_skb(skb_size, GFP_KERNEL);
if (!skb) {
if (skb_size <= (PAGE_SIZE/2)) {
pr_err("%s: cannot allocate skb\n", __func__);
IPC_RTR_ERR("%s: cannot allocate skb\n",
__func__);
goto buf_to_skb_error;
}
data_size = data_size / 2;
@ -437,7 +438,7 @@ static void *msm_ipc_router_skb_to_buf(struct sk_buff_head *skb_head,
void *buf;
if (!skb_head) {
pr_err("%s: NULL skb_head\n", __func__);
IPC_RTR_ERR("%s: NULL skb_head\n", __func__);
return NULL;
}
@ -445,7 +446,7 @@ static void *msm_ipc_router_skb_to_buf(struct sk_buff_head *skb_head,
buf_len = len;
buf = kmalloc(buf_len, GFP_KERNEL);
if (!buf) {
pr_err("%s: cannot allocate buf\n", __func__);
IPC_RTR_ERR("%s: cannot allocate buf\n", __func__);
return NULL;
}
skb_queue_walk(skb_head, temp) {
@ -481,7 +482,7 @@ void msm_ipc_router_free_skb(struct sk_buff_head *skb_head)
static int extract_header_v1(struct rr_packet *pkt, struct sk_buff *skb)
{
if (!pkt || !skb) {
pr_err("%s: Invalid pkt or skb\n", __func__);
IPC_RTR_ERR("%s: Invalid pkt or skb\n", __func__);
return -EINVAL;
}
@ -503,7 +504,7 @@ static int extract_header_v2(struct rr_packet *pkt, struct sk_buff *skb)
struct rr_header_v2 *hdr;
if (!pkt || !skb) {
pr_err("%s: Invalid pkt or skb\n", __func__);
IPC_RTR_ERR("%s: Invalid pkt or skb\n", __func__);
return -EINVAL;
}
@ -536,13 +537,13 @@ static int extract_header(struct rr_packet *pkt)
int ret;
if (!pkt) {
pr_err("%s: NULL PKT\n", __func__);
IPC_RTR_ERR("%s: NULL PKT\n", __func__);
return -EINVAL;
}
temp_skb = skb_peek(pkt->pkt_fragment_q);
if (!temp_skb || !temp_skb->data) {
pr_err("%s: No SKBs in skb_queue\n", __func__);
IPC_RTR_ERR("%s: No SKBs in skb_queue\n", __func__);
return -EINVAL;
}
@ -552,7 +553,7 @@ static int extract_header(struct rr_packet *pkt)
ret = extract_header_v2(pkt, temp_skb);
/* TODO: Extract optional headers if present */
} else {
pr_err("%s: Invalid Header version %02x\n",
IPC_RTR_ERR("%s: Invalid Header version %02x\n",
__func__, temp_skb->data[0]);
print_hex_dump(KERN_ERR, "Header: ", DUMP_PREFIX_ADDRESS,
16, 1, temp_skb->data, pkt->length, true);
@ -582,14 +583,14 @@ static int calc_tx_header_size(struct rr_packet *pkt,
struct msm_ipc_router_xprt_info *xprt_info = dst_xprt_info;
if (!pkt) {
pr_err("%s: NULL PKT\n", __func__);
IPC_RTR_ERR("%s: NULL PKT\n", __func__);
return -EINVAL;
}
if (!xprt_info) {
rt_entry = lookup_routing_table(pkt->hdr.dst_node_id);
if (!rt_entry || !(rt_entry->xprt_info)) {
pr_err("%s: Node %d is not up\n",
IPC_RTR_ERR("%s: Node %d is not up\n",
__func__, pkt->hdr.dst_node_id);
return -ENODEV;
}
@ -607,7 +608,7 @@ static int calc_tx_header_size(struct rr_packet *pkt,
hdr_size = sizeof(struct rr_header_v2);
/* TODO: Calculate optional header length, if present */
} else {
pr_err("%s: Invalid xprt_version %d\n",
IPC_RTR_ERR("%s: Invalid xprt_version %d\n",
__func__, xprt_version);
hdr_size = -EINVAL;
}
@ -649,20 +650,20 @@ static int prepend_header_v1(struct rr_packet *pkt, int hdr_size)
struct rr_header_v1 *hdr;
if (!pkt || hdr_size <= 0) {
pr_err("%s: Invalid input parameters\n", __func__);
IPC_RTR_ERR("%s: Invalid input parameters\n", __func__);
return -EINVAL;
}
temp_skb = skb_peek(pkt->pkt_fragment_q);
if (!temp_skb || !temp_skb->data) {
pr_err("%s: No SKBs in skb_queue\n", __func__);
IPC_RTR_ERR("%s: No SKBs in skb_queue\n", __func__);
return -EINVAL;
}
if (skb_headroom(temp_skb) < hdr_size) {
temp_skb = alloc_skb(hdr_size, GFP_KERNEL);
if (!temp_skb) {
pr_err("%s: Could not allocate SKB of size %d\n",
IPC_RTR_ERR("%s: Could not allocate SKB of size %d\n",
__func__, hdr_size);
return -ENOMEM;
}
@ -690,20 +691,20 @@ static int prepend_header_v2(struct rr_packet *pkt, int hdr_size)
struct rr_header_v2 *hdr;
if (!pkt || hdr_size <= 0) {
pr_err("%s: Invalid input parameters\n", __func__);
IPC_RTR_ERR("%s: Invalid input parameters\n", __func__);
return -EINVAL;
}
temp_skb = skb_peek(pkt->pkt_fragment_q);
if (!temp_skb || !temp_skb->data) {
pr_err("%s: No SKBs in skb_queue\n", __func__);
IPC_RTR_ERR("%s: No SKBs in skb_queue\n", __func__);
return -EINVAL;
}
if (skb_headroom(temp_skb) < hdr_size) {
temp_skb = alloc_skb(hdr_size, GFP_KERNEL);
if (!temp_skb) {
pr_err("%s: Could not allocate SKB of size %d\n",
IPC_RTR_ERR("%s: Could not allocate SKB of size %d\n",
__func__, hdr_size);
return -ENOMEM;
}
@ -744,13 +745,13 @@ static int prepend_header(struct rr_packet *pkt,
struct sk_buff *temp_skb;
if (!pkt) {
pr_err("%s: NULL PKT\n", __func__);
IPC_RTR_ERR("%s: NULL PKT\n", __func__);
return -EINVAL;
}
temp_skb = skb_peek(pkt->pkt_fragment_q);
if (!temp_skb || !temp_skb->data) {
pr_err("%s: No SKBs in skb_queue\n", __func__);
IPC_RTR_ERR("%s: No SKBs in skb_queue\n", __func__);
return -EINVAL;
}
@ -784,7 +785,7 @@ static int defragment_pkt(struct rr_packet *pkt)
int align_size;
if (!pkt || pkt->length <= 0) {
pr_err("%s: Invalid PKT\n", __func__);
IPC_RTR_ERR("%s: Invalid PKT\n", __func__);
return -EINVAL;
}
@ -794,7 +795,7 @@ static int defragment_pkt(struct rr_packet *pkt)
align_size = ALIGN_SIZE(pkt->length);
dst_skb = alloc_skb(pkt->length + align_size, GFP_KERNEL);
if (!dst_skb) {
pr_err("%s: could not allocate one skb of size %d\n",
IPC_RTR_ERR("%s: could not allocate one skb of size %d\n",
__func__, pkt->length);
return -ENOMEM;
}
@ -829,7 +830,8 @@ static int post_pkt_to_port(struct msm_ipc_port *port_ptr,
if (clone) {
temp_pkt = clone_pkt(pkt);
if (!temp_pkt) {
pr_err("%s: Error cloning packet for port %08x:%08x\n",
IPC_RTR_ERR(
"%s: Error cloning packet for port %08x:%08x\n",
__func__, port_ptr->this_port.node_id,
port_ptr->this_port.port_id);
return -ENOMEM;
@ -939,7 +941,7 @@ struct msm_ipc_port *msm_ipc_router_create_raw_port(void *endpoint,
port_ptr->this_port.node_id = IPC_ROUTER_NID_LOCAL;
port_ptr->this_port.port_id = allocate_port_id();
if (!port_ptr->this_port.port_id) {
pr_err("%s: All port ids are in use\n", __func__);
IPC_RTR_ERR("%s: All port ids are in use\n", __func__);
kfree(port_ptr);
return NULL;
}
@ -986,7 +988,7 @@ static struct msm_ipc_router_remote_port *msm_ipc_router_lookup_remote_port(
rt_entry = lookup_routing_table(node_id);
if (!rt_entry) {
pr_err("%s: Node is not up\n", __func__);
IPC_RTR_ERR("%s: Node is not up\n", __func__);
return NULL;
}
@ -1013,14 +1015,14 @@ static struct msm_ipc_router_remote_port *msm_ipc_router_create_remote_port(
rt_entry = lookup_routing_table(node_id);
if (!rt_entry) {
pr_err("%s: Node is not up\n", __func__);
IPC_RTR_ERR("%s: Node is not up\n", __func__);
return NULL;
}
rport_ptr = kmalloc(sizeof(struct msm_ipc_router_remote_port),
GFP_KERNEL);
if (!rport_ptr) {
pr_err("%s: Remote port alloc failed\n", __func__);
IPC_RTR_ERR("%s: Remote port alloc failed\n", __func__);
return NULL;
}
rport_ptr->port_id = port_id;
@ -1113,7 +1115,7 @@ static void post_resume_tx(struct msm_ipc_router_remote_port *rport_ptr,
else if (local_port)
post_pkt_to_port(local_port, pkt, 1);
else
pr_err("%s: Local Port %d not Found",
IPC_RTR_ERR("%s: Local Port %d not Found",
__func__, rtx_port->port_id);
list_del(&rtx_port->list);
kfree(rtx_port);
@ -1133,7 +1135,7 @@ static void msm_ipc_router_destroy_remote_port(
node_id = rport_ptr->node_id;
rt_entry = lookup_routing_table(node_id);
if (!rt_entry) {
pr_err("%s: Node %d is not up\n", __func__, node_id);
IPC_RTR_ERR("%s: Node %d is not up\n", __func__, node_id);
return;
}
down_write(&rt_entry->lock_lha4);
@ -1224,7 +1226,7 @@ static struct msm_ipc_server *msm_ipc_router_create_server(
server = kzalloc(sizeof(struct msm_ipc_server), GFP_KERNEL);
if (!server) {
pr_err("%s: Server allocation failed\n", __func__);
IPC_RTR_ERR("%s: Server allocation failed\n", __func__);
return NULL;
}
server->name.service = service;
@ -1243,7 +1245,7 @@ create_srv_port:
list_del(&server->list);
kfree(server);
}
pr_err("%s: Server Port allocation failed\n", __func__);
IPC_RTR_ERR("%s: Server Port allocation failed\n", __func__);
return NULL;
}
server_port->server_addr.node_id = node_id;
@ -1311,7 +1313,7 @@ static int msm_ipc_router_send_control_msg(
if (!xprt_info || ((msg->cmd != IPC_ROUTER_CTRL_CMD_HELLO) &&
!xprt_info->initialized)) {
pr_err("%s: xprt_info not initialized\n", __func__);
IPC_RTR_ERR("%s: xprt_info not initialized\n", __func__);
return -EINVAL;
}
@ -1320,13 +1322,13 @@ static int msm_ipc_router_send_control_msg(
pkt = kzalloc(sizeof(struct rr_packet), GFP_KERNEL);
if (!pkt) {
pr_err("%s: pkt alloc failed\n", __func__);
IPC_RTR_ERR("%s: pkt alloc failed\n", __func__);
return -ENOMEM;
}
pkt_fragment_q = kmalloc(sizeof(struct sk_buff_head), GFP_KERNEL);
if (!pkt_fragment_q) {
pr_err("%s: pkt_fragment_q alloc failed\n", __func__);
IPC_RTR_ERR("%s: pkt_fragment_q alloc failed\n", __func__);
kfree(pkt);
return -ENOMEM;
}
@ -1335,7 +1337,7 @@ static int msm_ipc_router_send_control_msg(
pkt_size = IPC_ROUTER_HDR_SIZE + sizeof(*msg);
ipc_rtr_pkt = alloc_skb(pkt_size, GFP_KERNEL);
if (!ipc_rtr_pkt) {
pr_err("%s: ipc_rtr_pkt alloc failed\n", __func__);
IPC_RTR_ERR("%s: ipc_rtr_pkt alloc failed\n", __func__);
kfree(pkt_fragment_q);
kfree(pkt);
return -ENOMEM;
@ -1365,7 +1367,7 @@ static int msm_ipc_router_send_control_msg(
ret = prepend_header(pkt, xprt_info);
if (ret < 0) {
mutex_unlock(&xprt_info->tx_lock_lhb2);
pr_err("%s: Prepend Header failed\n", __func__);
IPC_RTR_ERR("%s: Prepend Header failed\n", __func__);
release_pkt(pkt);
return ret;
}
@ -1386,7 +1388,7 @@ static int msm_ipc_router_send_server_list(uint32_t node_id,
int i;
if (!xprt_info || !xprt_info->initialized) {
pr_err("%s: Xprt info not initialized\n", __func__);
IPC_RTR_ERR("%s: Xprt info not initialized\n", __func__);
return -EINVAL;
}
@ -1452,13 +1454,13 @@ static int broadcast_ctl_msg_locally(union rr_control_msg *msg)
pkt = kzalloc(sizeof(struct rr_packet), GFP_KERNEL);
if (!pkt) {
pr_err("%s: pkt alloc failed\n", __func__);
IPC_RTR_ERR("%s: pkt alloc failed\n", __func__);
return -ENOMEM;
}
pkt_fragment_q = kmalloc(sizeof(struct sk_buff_head), GFP_KERNEL);
if (!pkt_fragment_q) {
pr_err("%s: pkt_fragment_q alloc failed\n", __func__);
IPC_RTR_ERR("%s: pkt_fragment_q alloc failed\n", __func__);
kfree(pkt);
return -ENOMEM;
}
@ -1467,7 +1469,7 @@ static int broadcast_ctl_msg_locally(union rr_control_msg *msg)
pkt_size = sizeof(*msg);
ipc_rtr_pkt = alloc_skb(pkt_size, GFP_KERNEL);
if (!ipc_rtr_pkt) {
pr_err("%s: ipc_rtr_pkt alloc failed\n", __func__);
IPC_RTR_ERR("%s: ipc_rtr_pkt alloc failed\n", __func__);
kfree(pkt_fragment_q);
kfree(pkt);
return -ENOMEM;
@ -1542,7 +1544,7 @@ static int forward_msg(struct msm_ipc_router_xprt_info *xprt_info,
down_read(&routing_table_lock_lha3);
rt_entry = lookup_routing_table(hdr->dst_node_id);
if (!(rt_entry) || !(rt_entry->xprt_info)) {
pr_err("%s: Routing table not initialized\n", __func__);
IPC_RTR_ERR("%s: Routing table not initialized\n", __func__);
ret = -ENODEV;
goto fm_error1;
}
@ -1551,7 +1553,7 @@ static int forward_msg(struct msm_ipc_router_xprt_info *xprt_info,
fwd_xprt_info = rt_entry->xprt_info;
ret = prepend_header(pkt, fwd_xprt_info);
if (ret < 0) {
pr_err("%s: Prepend Header failed\n", __func__);
IPC_RTR_ERR("%s: Prepend Header failed\n", __func__);
goto fm_error2;
}
fwd_xprt_option = fwd_xprt_info->xprt->get_option(fwd_xprt_info->xprt);
@ -1563,13 +1565,13 @@ static int forward_msg(struct msm_ipc_router_xprt_info *xprt_info,
mutex_lock(&fwd_xprt_info->tx_lock_lhb2);
if (xprt_info->remote_node_id == fwd_xprt_info->remote_node_id) {
pr_err("%s: Discarding Command to route back\n", __func__);
IPC_RTR_ERR("%s: Discarding Command to route back\n", __func__);
ret = -EINVAL;
goto fm_error3;
}
if (xprt_info->xprt->link_id == fwd_xprt_info->xprt->link_id) {
pr_err("%s: DST in the same cluster\n", __func__);
IPC_RTR_ERR("%s: DST in the same cluster\n", __func__);
ret = 0;
goto fm_error3;
}
@ -1595,7 +1597,7 @@ static int msm_ipc_router_send_remove_client(struct comm_mode_info *mode_info,
int rc = 0;
if (!mode_info) {
pr_err("%s: NULL mode_info\n", __func__);
IPC_RTR_ERR("%s: NULL mode_info\n", __func__);
return -EINVAL;
}
mode = mode_info->mode;
@ -1622,7 +1624,8 @@ static int msm_ipc_router_send_remove_client(struct comm_mode_info *mode_info,
broadcast_ctl_msg(&msg);
broadcast_ctl_msg_locally(&msg);
} else if (mode != NULL_MODE) {
pr_err("%s: Invalid mode(%d) + xprt_inf(%p) for %08x:%08x\n",
IPC_RTR_ERR(
"%s: Invalid mode(%d) + xprt_inf(%p) for %08x:%08x\n",
__func__, mode, xprt_info, node_id, port_id);
rc = -EINVAL;
}
@ -1633,7 +1636,7 @@ static void update_comm_mode_info(struct comm_mode_info *mode_info,
struct msm_ipc_router_xprt_info *xprt_info)
{
if (!mode_info) {
pr_err("%s: NULL mode_info\n", __func__);
IPC_RTR_ERR("%s: NULL mode_info\n", __func__);
return;
}
@ -1705,7 +1708,7 @@ static void msm_ipc_cleanup_routing_table(
struct msm_ipc_routing_table_entry *rt_entry, *tmp_rt_entry;
if (!xprt_info) {
pr_err("%s: Invalid xprt_info\n", __func__);
IPC_RTR_ERR("%s: Invalid xprt_info\n", __func__);
return;
}
@ -1846,7 +1849,8 @@ static int process_hello_msg(struct msm_ipc_router_xprt_info *xprt_info,
rt_entry = alloc_routing_table_entry(hdr->src_node_id);
if (!rt_entry) {
up_write(&routing_table_lock_lha3);
pr_err("%s: rt_entry allocation failed\n", __func__);
IPC_RTR_ERR("%s: rt_entry allocation failed\n",
__func__);
return -ENOMEM;
}
add_routing_table_entry(rt_entry);
@ -1863,7 +1867,8 @@ static int process_hello_msg(struct msm_ipc_router_xprt_info *xprt_info,
rc = msm_ipc_router_send_control_msg(xprt_info, &ctl,
IPC_ROUTER_DUMMY_DEST_NODE);
if (rc < 0) {
pr_err("%s: Error sending reply HELLO message\n", __func__);
IPC_RTR_ERR("%s: Error sending reply HELLO message\n",
__func__);
return rc;
}
xprt_info->initialized = 1;
@ -1908,7 +1913,7 @@ static int process_resume_tx_msg(union rr_control_msg *msg,
rport_ptr = msm_ipc_router_lookup_remote_port(msg->cli.node_id,
msg->cli.port_id);
if (!rport_ptr) {
pr_err("%s: Unable to resume client\n", __func__);
IPC_RTR_ERR("%s: Unable to resume client\n", __func__);
ret = -ENODEV;
goto prtm_out;
}
@ -1930,7 +1935,7 @@ static int process_new_server_msg(struct msm_ipc_router_xprt_info *xprt_info,
struct msm_ipc_router_remote_port *rport_ptr;
if (msg->srv.instance == 0) {
pr_err("%s: Server %08x create rejected, version = 0\n",
IPC_RTR_ERR("%s: Server %08x create rejected, version = 0\n",
__func__, msg->srv.service);
return -EINVAL;
}
@ -1950,7 +1955,8 @@ static int process_new_server_msg(struct msm_ipc_router_xprt_info *xprt_info,
rt_entry = alloc_routing_table_entry(msg->srv.node_id);
if (!rt_entry) {
up_write(&routing_table_lock_lha3);
pr_err("%s: rt_entry allocation failed\n", __func__);
IPC_RTR_ERR("%s: rt_entry allocation failed\n",
__func__);
return -ENOMEM;
}
down_write(&rt_entry->lock_lha4);
@ -1975,7 +1981,7 @@ static int process_new_server_msg(struct msm_ipc_router_xprt_info *xprt_info,
msg->srv.node_id, msg->srv.port_id, xprt_info);
if (!server) {
up_write(&server_list_lock_lha2);
pr_err("%s: Server Create failed\n", __func__);
IPC_RTR_ERR("%s: Server Create failed\n", __func__);
return -ENOMEM;
}
@ -2058,15 +2064,15 @@ static int process_control_msg(struct msm_ipc_router_xprt_info *xprt_info,
struct rr_header_v1 *hdr;
if (pkt->length != sizeof(*msg)) {
pr_err("%s: r2r msg size %d != %zu\n", __func__, pkt->length,
sizeof(*msg));
IPC_RTR_ERR("%s: r2r msg size %d != %zu\n",
__func__, pkt->length, sizeof(*msg));
return -EINVAL;
}
hdr = &(pkt->hdr);
msg = msm_ipc_router_skb_to_buf(pkt->pkt_fragment_q, sizeof(*msg));
if (!msg) {
pr_err("%s: Error extracting control msg\n", __func__);
IPC_RTR_ERR("%s: Error extracting control msg\n", __func__);
return -ENOMEM;
}
@ -2110,7 +2116,7 @@ static void do_read_data(struct work_struct *work)
while ((pkt = rr_read(xprt_info)) != NULL) {
if (pkt->length < calc_rx_header_size(xprt_info) ||
pkt->length > MAX_IPC_PKT_SIZE) {
pr_err("%s: Invalid pkt length %d\n",
IPC_RTR_ERR("%s: Invalid pkt length %d\n",
__func__, pkt->length);
goto fail_data;
}
@ -2153,7 +2159,7 @@ static void do_read_data(struct work_struct *work)
down_read(&local_ports_lock_lha2);
port_ptr = msm_ipc_router_lookup_local_port(hdr->dst_port_id);
if (!port_ptr) {
pr_err("%s: No local port id %08x\n", __func__,
IPC_RTR_ERR("%s: No local port id %08x\n", __func__,
hdr->dst_port_id);
up_read(&local_ports_lock_lha2);
release_pkt(pkt);
@ -2168,9 +2174,9 @@ static void do_read_data(struct work_struct *work)
hdr->src_node_id,
hdr->src_port_id);
if (!rport_ptr) {
pr_err("%s: Rmt Prt %08x:%08x create failed\n",
__func__, hdr->src_node_id,
hdr->src_port_id);
IPC_RTR_ERR(
"%s: Rmt Prt %08x:%08x create failed\n",
__func__, hdr->src_node_id, hdr->src_port_id);
up_read(&routing_table_lock_lha3);
up_read(&local_ports_lock_lha2);
release_pkt(pkt);
@ -2185,7 +2191,7 @@ static void do_read_data(struct work_struct *work)
fail_data:
release_pkt(pkt);
pr_err("ipc_router has died\n");
IPC_RTR_ERR("%s: ipc_router has died\n", __func__);
}
int msm_ipc_router_register_server(struct msm_ipc_port *port_ptr,
@ -2208,7 +2214,7 @@ int msm_ipc_router_register_server(struct msm_ipc_port *port_ptr,
port_ptr->this_port.port_id);
if (server) {
up_write(&server_list_lock_lha2);
pr_err("%s: Server already present\n", __func__);
IPC_RTR_ERR("%s: Server already present\n", __func__);
return -EINVAL;
}
@ -2219,7 +2225,7 @@ int msm_ipc_router_register_server(struct msm_ipc_port *port_ptr,
NULL);
if (!server) {
up_write(&server_list_lock_lha2);
pr_err("%s: Server Creation failed\n", __func__);
IPC_RTR_ERR("%s: Server Creation failed\n", __func__);
return -EINVAL;
}
@ -2251,13 +2257,14 @@ int msm_ipc_router_unregister_server(struct msm_ipc_port *port_ptr)
return -EINVAL;
if (port_ptr->type != SERVER_PORT) {
pr_err("%s: Trying to unregister a non-server port\n",
IPC_RTR_ERR("%s: Trying to unregister a non-server port\n",
__func__);
return -EINVAL;
}
if (port_ptr->this_port.node_id != IPC_ROUTER_NID_LOCAL) {
pr_err("%s: Trying to unregister a remote server locally\n",
IPC_RTR_ERR(
"%s: Trying to unregister a remote server locally\n",
__func__);
return -EINVAL;
}
@ -2269,7 +2276,7 @@ int msm_ipc_router_unregister_server(struct msm_ipc_port *port_ptr)
port_ptr->this_port.port_id);
if (!server) {
up_write(&server_list_lock_lha2);
pr_err("%s: Server lookup failed\n", __func__);
IPC_RTR_ERR("%s: Server lookup failed\n", __func__);
return -ENODEV;
}
@ -2302,13 +2309,13 @@ static int loopback_data(struct msm_ipc_port *src,
int align_size;
if (!data) {
pr_err("%s: Invalid pkt pointer\n", __func__);
IPC_RTR_ERR("%s: Invalid pkt pointer\n", __func__);
return -EINVAL;
}
pkt = create_pkt(data);
if (!pkt) {
pr_err("%s: New pkt create failed\n", __func__);
IPC_RTR_ERR("%s: New pkt create failed\n", __func__);
return -ENOMEM;
}
hdr = &(pkt->hdr);
@ -2329,7 +2336,8 @@ static int loopback_data(struct msm_ipc_port *src,
down_read(&local_ports_lock_lha2);
port_ptr = msm_ipc_router_lookup_local_port(port_id);
if (!port_ptr) {
pr_err("%s: Local port %d not present\n", __func__, port_id);
IPC_RTR_ERR("%s: Local port %d not present\n",
__func__, port_id);
up_read(&local_ports_lock_lha2);
pkt->pkt_fragment_q = NULL;
release_pkt(pkt);
@ -2380,7 +2388,7 @@ static int msm_ipc_router_write_pkt(struct msm_ipc_port *src,
kzalloc(sizeof(struct msm_ipc_resume_tx_port),
GFP_KERNEL);
if (!resume_tx_port) {
pr_err("%s: Resume_Tx port allocation failed\n",
IPC_RTR_ERR("%s: Resume_Tx port allocation failed\n",
__func__);
mutex_unlock(&rport_ptr->quota_lock_lhb2);
return -ENOMEM;
@ -2400,7 +2408,7 @@ static int msm_ipc_router_write_pkt(struct msm_ipc_port *src,
rt_entry = lookup_routing_table(hdr->dst_node_id);
if (!rt_entry || !rt_entry->xprt_info) {
pr_err("%s: Remote node %d not up\n",
IPC_RTR_ERR("%s: Remote node %d not up\n",
__func__, hdr->dst_node_id);
return -ENODEV;
}
@ -2409,7 +2417,7 @@ static int msm_ipc_router_write_pkt(struct msm_ipc_port *src,
ret = prepend_header(pkt, xprt_info);
if (ret < 0) {
up_read(&rt_entry->lock_lha4);
pr_err("%s: Prepend Header failed\n", __func__);
IPC_RTR_ERR("%s: Prepend Header failed\n", __func__);
return ret;
}
xprt_option = xprt_info->xprt->get_option(xprt_info->xprt);
@ -2431,7 +2439,7 @@ static int msm_ipc_router_write_pkt(struct msm_ipc_port *src,
up_read(&rt_entry->lock_lha4);
if (ret < 0) {
pr_err("%s: Write on XPRT failed\n", __func__);
IPC_RTR_ERR("%s: Write on XPRT failed\n", __func__);
return ret;
}
update_comm_mode_info(&src->mode_info, xprt_info);
@ -2470,7 +2478,7 @@ int msm_ipc_router_send_to(struct msm_ipc_port *src,
int ret;
if (!src || !data || !dest) {
pr_err("%s: Invalid Parameters\n", __func__);
IPC_RTR_ERR("%s: Invalid Parameters\n", __func__);
return -EINVAL;
}
@ -2486,7 +2494,8 @@ int msm_ipc_router_send_to(struct msm_ipc_port *src,
0, 0);
if (!server) {
up_read(&server_list_lock_lha2);
pr_err("%s: Destination not reachable\n", __func__);
IPC_RTR_ERR("%s: Destination not reachable\n",
__func__);
return -ENODEV;
}
server_port = list_first_entry(&server->server_port_list,
@ -2506,7 +2515,7 @@ int msm_ipc_router_send_to(struct msm_ipc_port *src,
dst_port_id);
if (!rport_ptr) {
up_read(&routing_table_lock_lha3);
pr_err("%s: Remote port not found\n", __func__);
IPC_RTR_ERR("%s: Remote port not found\n", __func__);
return -ENODEV;
}
@ -2514,7 +2523,7 @@ int msm_ipc_router_send_to(struct msm_ipc_port *src,
ret = src->check_send_permissions(rport_ptr->sec_rule);
if (ret <= 0) {
up_read(&routing_table_lock_lha3);
pr_err("%s: permission failure for %s\n",
IPC_RTR_ERR("%s: permission failure for %s\n",
__func__, current->comm);
return -EPERM;
}
@ -2523,7 +2532,7 @@ int msm_ipc_router_send_to(struct msm_ipc_port *src,
pkt = create_pkt(data);
if (!pkt) {
up_read(&routing_table_lock_lha3);
pr_err("%s: Pkt creation failed\n", __func__);
IPC_RTR_ERR("%s: Pkt creation failed\n", __func__);
return -ENOMEM;
}
@ -2545,14 +2554,15 @@ int msm_ipc_router_send_msg(struct msm_ipc_port *src,
out_skb_head = msm_ipc_router_buf_to_skb(data, data_len);
if (!out_skb_head) {
pr_err("%s: SKB conversion failed\n", __func__);
IPC_RTR_ERR("%s: SKB conversion failed\n", __func__);
return -EFAULT;
}
ret = msm_ipc_router_send_to(src, out_skb_head, dest);
if (ret < 0) {
if (ret != -EAGAIN)
pr_err("%s: msm_ipc_router_send_to failed - ret: %d\n",
IPC_RTR_ERR(
"%s: msm_ipc_router_send_to failed - ret: %d\n",
__func__, ret);
msm_ipc_router_free_skb(out_skb_head);
return ret;
@ -2586,7 +2596,7 @@ static int msm_ipc_router_send_resume_tx(void *data)
down_read(&routing_table_lock_lha3);
rt_entry = lookup_routing_table(hdr->src_node_id);
if (!rt_entry) {
pr_err("%s: %d Node is not present",
IPC_RTR_ERR("%s: %d Node is not present",
__func__, hdr->src_node_id);
up_read(&routing_table_lock_lha3);
return -ENODEV;
@ -2597,7 +2607,8 @@ static int msm_ipc_router_send_resume_tx(void *data)
hdr->src_node_id);
up_read(&routing_table_lock_lha3);
if (ret < 0)
pr_err("%s: Send Resume_Tx Failed SRC_NODE: %d SRC_PORT: %d DEST_NODE: %d",
IPC_RTR_ERR(
"%s: Send Resume_Tx Failed SRC_NODE: %d SRC_PORT: %d DEST_NODE: %d",
__func__, hdr->dst_node_id, hdr->dst_port_id,
hdr->src_node_id);
@ -2710,7 +2721,7 @@ int msm_ipc_router_recv_from(struct msm_ipc_port *port_ptr,
struct rr_header_v1 *hdr = NULL;
if (!port_ptr || !pkt) {
pr_err("%s: Invalid pointers being passed\n", __func__);
IPC_RTR_ERR("%s: Invalid pointers being passed\n", __func__);
return -EINVAL;
}
@ -2751,14 +2762,15 @@ int msm_ipc_router_read_msg(struct msm_ipc_port *port_ptr,
ret = msm_ipc_router_recv_from(port_ptr, &pkt, src, 0);
if (ret < 0) {
if (ret != -ENOMSG)
pr_err("%s: msm_ipc_router_recv_from failed - ret: %d\n",
IPC_RTR_ERR(
"%s: msm_ipc_router_recv_from failed - ret: %d\n",
__func__, ret);
return ret;
}
*data = msm_ipc_router_skb_to_buf(pkt->pkt_fragment_q, ret);
if (!(*data))
pr_err("%s: Buf conversion failed\n", __func__);
IPC_RTR_ERR("%s: Buf conversion failed\n", __func__);
*len = ret;
release_pkt(pkt);
@ -2786,13 +2798,13 @@ struct msm_ipc_port *msm_ipc_router_create_port(
ret = wait_for_completion_interruptible(&msm_ipc_local_router_up);
if (ret < 0) {
pr_err("%s: Error waiting for local router\n", __func__);
IPC_RTR_ERR("%s: Error waiting for local router\n", __func__);
return NULL;
}
port_ptr = msm_ipc_router_create_raw_port(NULL, notify, priv);
if (!port_ptr)
pr_err("%s: port_ptr alloc failed\n", __func__);
IPC_RTR_ERR("%s: port_ptr alloc failed\n", __func__);
return port_ptr;
}
@ -2915,12 +2927,12 @@ int msm_ipc_router_lookup_server_name(struct msm_ipc_port_name *srv_name,
int key, i = 0; /*num_entries_found*/
if (!srv_name) {
pr_err("%s: Invalid srv_name\n", __func__);
IPC_RTR_ERR("%s: Invalid srv_name\n", __func__);
return -EINVAL;
}
if (num_entries_in_array && !srv_info) {
pr_err("%s: srv_info NULL\n", __func__);
IPC_RTR_ERR("%s: srv_info NULL\n", __func__);
return -EINVAL;
}
@ -3308,7 +3320,8 @@ void msm_ipc_router_xprt_notify(struct msm_ipc_router_xprt *xprt,
ret = wait_for_completion_timeout(&msm_ipc_local_router_up,
IPC_ROUTER_INIT_TIMEOUT);
if (!ret || !msm_ipc_router_workqueue) {
pr_err("%s: IPC Router not initialized\n", __func__);
IPC_RTR_ERR("%s: IPC Router not initialized\n",
__func__);
return;
}
}
@ -3323,7 +3336,8 @@ void msm_ipc_router_xprt_notify(struct msm_ipc_router_xprt *xprt,
INIT_WORK(&xprt_work->work, xprt_open_worker);
queue_work(msm_ipc_router_workqueue, &xprt_work->work);
} else {
pr_err("%s: malloc failure - Couldn't notify OPEN event",
IPC_RTR_ERR(
"%s: malloc failure - Couldn't notify OPEN event",
__func__);
}
break;
@ -3337,7 +3351,8 @@ void msm_ipc_router_xprt_notify(struct msm_ipc_router_xprt *xprt,
INIT_WORK(&xprt_work->work, xprt_close_worker);
queue_work(msm_ipc_router_workqueue, &xprt_work->work);
} else {
pr_err("%s: malloc failure - Couldn't notify CLOSE event",
IPC_RTR_ERR(
"%s: malloc failure - Couldn't notify CLOSE event",
__func__);
}
break;
@ -3371,7 +3386,7 @@ static int __init msm_ipc_router_init(void)
ipc_rtr_log_ctxt = ipc_log_context_create(IPC_RTR_LOG_PAGES,
"ipc_router");
if (!ipc_rtr_log_ctxt)
pr_err("%s: Unable to create IPC logging for IPC RTR",
IPC_RTR_ERR("%s: Unable to create IPC logging for IPC RTR",
__func__);
msm_ipc_router_workqueue =
@ -3398,11 +3413,11 @@ static int __init msm_ipc_router_init(void)
ret = msm_ipc_router_init_sockets();
if (ret < 0)
pr_err("%s: Init sockets failed\n", __func__);
IPC_RTR_ERR("%s: Init sockets failed\n", __func__);
ret = msm_ipc_router_security_init();
if (ret < 0)
pr_err("%s: Security Init failed\n", __func__);
IPC_RTR_ERR("%s: Security Init failed\n", __func__);
complete_all(&msm_ipc_local_router_up);
return ret;

47
net/ipc_router/ipc_router_socket.c
View File

@ -142,7 +142,7 @@ static struct sk_buff_head *msm_ipc_router_build_msg(unsigned int num_sect,
msg_head = kmalloc(sizeof(struct sk_buff_head), GFP_KERNEL);
if (!msg_head) {
pr_err("%s: cannot allocate skb_head\n", __func__);
IPC_RTR_ERR("%s: cannot allocate skb_head\n", __func__);
return NULL;
}
skb_queue_head_init(msg_head);
@ -162,8 +162,9 @@ static struct sk_buff_head *msm_ipc_router_build_msg(unsigned int num_sect,
msg = alloc_skb(request_size, GFP_KERNEL);
if (!msg) {
if (request_size <= (PAGE_SIZE/2)) {
pr_err("%s: cannot allocated skb\n",
__func__);
IPC_RTR_ERR(
"%s: cannot allocated skb\n",
__func__);
goto msg_build_failure;
}
data_size = data_size / 2;
@ -181,7 +182,7 @@ static struct sk_buff_head *msm_ipc_router_build_msg(unsigned int num_sect,
msg_sect[i].iov_base + offset,
data_size);
if (!copied) {
pr_err("%s: copy_from_user failed\n",
IPC_RTR_ERR("%s: copy_from_user failed\n",
__func__);
kfree_skb(msg);
goto msg_build_failure;
@ -214,7 +215,7 @@ static int msm_ipc_router_extract_msg(struct msghdr *m,
int offset = 0, data_len = 0, copy_len;
if (!m || !pkt) {
pr_err("%s: Invalid pointers passed\n", __func__);
IPC_RTR_ERR("%s: Invalid pointers passed\n", __func__);
return -EINVAL;
}
addr = (struct sockaddr_msm_ipc *)m->msg_name;
@ -243,7 +244,7 @@ static int msm_ipc_router_extract_msg(struct msghdr *m,
copy_len = data_len < temp->len ? data_len : temp->len;
if (copy_to_user(m->msg_iov->iov_base + offset, temp->data,
copy_len)) {
pr_err("%s: Copy to user failed\n", __func__);
IPC_RTR_ERR("%s: Copy to user failed\n", __func__);
return -EFAULT;
}
offset += copy_len;
@ -261,7 +262,7 @@ static int msm_ipc_router_create(struct net *net,
struct msm_ipc_port *port_ptr;
if (unlikely(protocol != 0)) {
pr_err("%s: Protocol not supported\n", __func__);
IPC_RTR_ERR("%s: Protocol not supported\n", __func__);
return -EPROTONOSUPPORT;
}
@ -269,19 +270,19 @@ static int msm_ipc_router_create(struct net *net,
case SOCK_DGRAM:
break;
default:
pr_err("%s: Protocol type not supported\n", __func__);
IPC_RTR_ERR("%s: Protocol type not supported\n", __func__);
return -EPROTOTYPE;
}
sk = sk_alloc(net, AF_MSM_IPC, GFP_KERNEL, &msm_ipc_proto);
if (!sk) {
pr_err("%s: sk_alloc failed\n", __func__);
IPC_RTR_ERR("%s: sk_alloc failed\n", __func__);
return -ENOMEM;
}
port_ptr = msm_ipc_router_create_raw_port(sk, NULL, NULL);
if (!port_ptr) {
pr_err("%s: port_ptr alloc failed\n", __func__);
IPC_RTR_ERR("%s: port_ptr alloc failed\n", __func__);
sk_free(sk);
return -ENOMEM;
}
@ -309,23 +310,23 @@ int msm_ipc_router_bind(struct socket *sock, struct sockaddr *uaddr,
return -EINVAL;
if (!check_permissions()) {
pr_err("%s: %s Do not have permissions\n",
IPC_RTR_ERR("%s: %s Do not have permissions\n",
__func__, current->comm);
return -EPERM;
}
if (!uaddr_len) {
pr_err("%s: Invalid address length\n", __func__);
IPC_RTR_ERR("%s: Invalid address length\n", __func__);
return -EINVAL;
}
if (addr->family != AF_MSM_IPC) {
pr_err("%s: Address family is incorrect\n", __func__);
IPC_RTR_ERR("%s: Address family is incorrect\n", __func__);
return -EAFNOSUPPORT;
}
if (addr->address.addrtype != MSM_IPC_ADDR_NAME) {
pr_err("%s: Address type is incorrect\n", __func__);
IPC_RTR_ERR("%s: Address type is incorrect\n", __func__);
return -EINVAL;
}
@ -366,7 +367,7 @@ static int msm_ipc_router_sendmsg(struct kiocb *iocb, struct socket *sock,
lock_sock(sk);
msg = msm_ipc_router_build_msg(m->msg_iovlen, m->msg_iov, total_len);
if (!msg) {
pr_err("%s: Msg build failure\n", __func__);
IPC_RTR_ERR("%s: Msg build failure\n", __func__);
ret = -ENOMEM;
goto out_sendmsg;
}
@ -381,7 +382,7 @@ static int msm_ipc_router_sendmsg(struct kiocb *iocb, struct socket *sock,
if (ret != total_len) {
if (ret < 0) {
if (ret != -EAGAIN)
pr_err("%s: Send_to failure %d\n",
IPC_RTR_ERR("%s: Send_to failure %d\n",
__func__, ret);
msm_ipc_router_free_skb(msg);
} else if (ret >= 0) {
@ -491,7 +492,7 @@ static int msm_ipc_router_ioctl(struct socket *sock,
if (server_arg.num_entries_in_array) {
if (server_arg.num_entries_in_array >
(SIZE_MAX / sizeof(*srv_info))) {
pr_err("%s: Integer Overflow %zu * %d\n",
IPC_RTR_ERR("%s: Integer Overflow %zu * %d\n",
__func__, sizeof(*srv_info),
server_arg.num_entries_in_array);
ret = -EINVAL;
@ -509,7 +510,7 @@ static int msm_ipc_router_ioctl(struct socket *sock,
srv_info, server_arg.num_entries_in_array,
server_arg.lookup_mask);
if (ret < 0) {
pr_err("%s: Server not found\n", __func__);
IPC_RTR_ERR("%s: Server not found\n", __func__);
ret = -ENODEV;
kfree(srv_info);
break;
@ -635,13 +636,13 @@ void msm_ipc_router_ipc_log_init(void)
ipc_log_context_create(REQ_RESP_IPC_LOG_PAGES,
"ipc_rtr_req_resp");
if (!ipc_req_resp_log_txt) {
pr_err("%s: Unable to create IPC logging for Req/Resp",
IPC_RTR_ERR("%s: Unable to create IPC logging for Req/Resp",
__func__);
}
ipc_ind_log_txt =
ipc_log_context_create(IND_IPC_LOG_PAGES, "ipc_rtr_ind");
if (!ipc_ind_log_txt) {
pr_err("%s: Unable to create IPC logging for Indications",
IPC_RTR_ERR("%s: Unable to create IPC logging for Indications",
__func__);
}
}
@ -652,13 +653,15 @@ int msm_ipc_router_init_sockets(void)
ret = proto_register(&msm_ipc_proto, 1);
if (ret) {
pr_err("Failed to register MSM_IPC protocol type\n");
IPC_RTR_ERR("%s: Failed to register MSM_IPC protocol type\n",
__func__);
goto out_init_sockets;
}
ret = sock_register(&msm_ipc_family_ops);
if (ret) {
pr_err("Failed to register MSM_IPC socket type\n");
IPC_RTR_ERR("%s: Failed to register MSM_IPC socket type\n",
__func__);
proto_unregister(&msm_ipc_proto);
goto out_init_sockets;
}