AMD IOMMU: fix lazy IO/TLB flushing in unmap path

[linux-2.6-omap-h63xx.git] / fs / ecryptfs / netlink.c

diff --git a/fs/ecryptfs/netlink.c b/fs/ecryptfs/netlink.c
index fe9186312d7c26c5349a01181fec25acc82e392e..e0abad62b39535fb8d98368266707af464b050be 100644 (file)
--- a/fs/ecryptfs/netlink.c
+++ b/fs/ecryptfs/netlink.c
@@ -44,8 +44,8 @@ static struct sock *ecryptfs_nl_sock;
  * upon sending the message; non-zero upon error.
  */
 int ecryptfs_send_netlink(char *data, int data_len,
-                         struct ecryptfs_msg_ctx *msg_ctx, u16 msg_type,
-                         u16 msg_flags, pid_t daemon_pid)
+                         struct ecryptfs_msg_ctx *msg_ctx, u8 msg_type,
+                         u16 msg_flags, struct pid *daemon_pid)
 {
        struct sk_buff *skb;
        struct nlmsghdr *nlh;
@@ -60,7 +60,7 @@ int ecryptfs_send_netlink(char *data, int data_len,
                ecryptfs_printk(KERN_ERR, "Failed to allocate socket buffer\n");
                goto out;
        }
-       nlh = NLMSG_PUT(skb, daemon_pid, msg_ctx ? msg_ctx->counter : 0,
+       nlh = NLMSG_PUT(skb, pid_nr(daemon_pid), msg_ctx ? msg_ctx->counter : 0,
                        msg_type, payload_len);
        nlh->nlmsg_flags = msg_flags;
        if (msg_ctx && payload_len) {
@@ -69,7 +69,7 @@ int ecryptfs_send_netlink(char *data, int data_len,
                msg->data_len = data_len;
                memcpy(msg->data, data, data_len);
        }
-       rc = netlink_unicast(ecryptfs_nl_sock, skb, daemon_pid, 0);
+       rc = netlink_unicast(ecryptfs_nl_sock, skb, pid_nr(daemon_pid), 0);
        if (rc < 0) {
                ecryptfs_printk(KERN_ERR, "Failed to send eCryptfs netlink "
                                "message; rc = [%d]\n", rc);
@@ -99,6 +99,7 @@ static int ecryptfs_process_nl_response(struct sk_buff *skb)
 {
        struct nlmsghdr *nlh = nlmsg_hdr(skb);
        struct ecryptfs_message *msg = NLMSG_DATA(nlh);
+       struct pid *pid;
        int rc;
 
        if (skb->len - NLMSG_HDRLEN - sizeof(*msg) != msg->data_len) {
@@ -107,8 +108,10 @@ static int ecryptfs_process_nl_response(struct sk_buff *skb)
                                "incorrectly specified data length\n");
                goto out;
        }
-       rc = ecryptfs_process_response(msg, NETLINK_CREDS(skb)->uid,
-                                      NETLINK_CREDS(skb)->pid, nlh->nlmsg_seq);
+       pid = find_get_pid(NETLINK_CREDS(skb)->pid);
+       rc = ecryptfs_process_response(msg, NETLINK_CREDS(skb)->uid, NULL,
+                                      pid, nlh->nlmsg_seq);
+       put_pid(pid);
        if (rc)
                printk(KERN_ERR
                       "Error processing response message; rc = [%d]\n", rc);
@@ -126,11 +129,13 @@ out:
  */
 static int ecryptfs_process_nl_helo(struct sk_buff *skb)
 {
+       struct pid *pid;
        int rc;
 
+       pid = find_get_pid(NETLINK_CREDS(skb)->pid);
        rc = ecryptfs_process_helo(ECRYPTFS_TRANSPORT_NETLINK,
-                                  NETLINK_CREDS(skb)->uid,
-                                  NETLINK_CREDS(skb)->pid);
+                                  NETLINK_CREDS(skb)->uid, NULL, pid);
+       put_pid(pid);
        if (rc)
                printk(KERN_WARNING "Error processing HELO; rc = [%d]\n", rc);
        return rc;
@@ -147,10 +152,12 @@ static int ecryptfs_process_nl_helo(struct sk_buff *skb)
  */
 static int ecryptfs_process_nl_quit(struct sk_buff *skb)
 {
+       struct pid *pid;
        int rc;
 
-       rc = ecryptfs_process_quit(NETLINK_CREDS(skb)->uid,
-                                  NETLINK_CREDS(skb)->pid);
+       pid = find_get_pid(NETLINK_CREDS(skb)->pid);
+       rc = ecryptfs_process_quit(NETLINK_CREDS(skb)->uid, NULL, pid);
+       put_pid(pid);
        if (rc)
                printk(KERN_WARNING
                       "Error processing QUIT message; rc = [%d]\n", rc);
@@ -165,22 +172,10 @@ static int ecryptfs_process_nl_quit(struct sk_buff *skb)
  * it to its desired netlink context element and wake up the process
  * that is waiting for a response.
  */
-static void ecryptfs_receive_nl_message(struct sock *sk, int len)
+static void ecryptfs_receive_nl_message(struct sk_buff *skb)
 {
-       struct sk_buff *skb;
        struct nlmsghdr *nlh;
-       int rc = 0;     /* skb_recv_datagram requires this */
 
-receive:
-       skb = skb_recv_datagram(sk, 0, 0, &rc);
-       if (rc == -EINTR)
-               goto receive;
-       else if (rc < 0) {
-               ecryptfs_printk(KERN_ERR, "Error occurred while "
-                               "receiving eCryptfs netlink message; "
-                               "rc = [%d]\n", rc);
-               return;
-       }
        nlh = nlmsg_hdr(skb);
        if (!NLMSG_OK(nlh, skb->len)) {
                ecryptfs_printk(KERN_ERR, "Received corrupt netlink "
@@ -188,20 +183,20 @@ receive:
                goto free;
        }
        switch (nlh->nlmsg_type) {
-               case ECRYPTFS_NLMSG_RESPONSE:
+               case ECRYPTFS_MSG_RESPONSE:
                        if (ecryptfs_process_nl_response(skb)) {
                                ecryptfs_printk(KERN_WARNING, "Failed to "
                                                "deliver netlink response to "
                                                "requesting operation\n");
                        }
                        break;
-               case ECRYPTFS_NLMSG_HELO:
+               case ECRYPTFS_MSG_HELO:
                        if (ecryptfs_process_nl_helo(skb)) {
                                ecryptfs_printk(KERN_WARNING, "Failed to "
                                                "fulfill HELO request\n");
                        }
                        break;
-               case ECRYPTFS_NLMSG_QUIT:
+               case ECRYPTFS_MSG_QUIT:
                        if (ecryptfs_process_nl_quit(skb)) {
                                ecryptfs_printk(KERN_WARNING, "Failed to "
                                                "fulfill QUIT request\n");
@@ -227,7 +222,7 @@ int ecryptfs_init_netlink(void)
 {
        int rc;
 
-       ecryptfs_nl_sock = netlink_kernel_create(NETLINK_ECRYPTFS, 0,
+       ecryptfs_nl_sock = netlink_kernel_create(&init_net, NETLINK_ECRYPTFS, 0,
                                                 ecryptfs_receive_nl_message,
                                                 NULL, THIS_MODULE);
        if (!ecryptfs_nl_sock) {
@@ -249,7 +244,6 @@ out:
  */
 void ecryptfs_release_netlink(void)
 {
-       if (ecryptfs_nl_sock && ecryptfs_nl_sock->sk_socket)
-               sock_release(ecryptfs_nl_sock->sk_socket);
+       netlink_kernel_release(ecryptfs_nl_sock);
        ecryptfs_nl_sock = NULL;
 }