RDS: remove __init and __exit annotation

The trivial amount of memory saved isn't worth the cost of dealing with section
mismatches.

Signed-off-by: Zach Brown <zach.brown@oracle.com>

diff --git a/net/rds/af_rds.c b/net/rds/af_rds.c
index f16d2a9..57ef0ec 100644 (file)
--- a/net/rds/af_rds.c
+++ b/net/rds/af_rds.c
@@ -521,7 +521,7 @@ out:
        spin_unlock_irqrestore(&rds_sock_lock, flags);
 }
 
-static void __exit rds_exit(void)
+static void rds_exit(void)
 {
        sock_unregister(rds_family_ops.family);
        proto_unregister(&rds_proto);
@@ -536,7 +536,7 @@ static void __exit rds_exit(void)
 }
 module_exit(rds_exit);
 
-static int __init rds_init(void)
+static int rds_init(void)
 {
        int ret;
 

diff --git a/net/rds/connection.c b/net/rds/connection.c
index 7670b45..0de40d9 100644 (file)
--- a/net/rds/connection.c
+++ b/net/rds/connection.c
@@ -488,7 +488,7 @@ static void rds_conn_info(struct socket *sock, unsigned int len,
                                sizeof(struct rds_info_connection));
 }
 
-int __init rds_conn_init(void)
+int rds_conn_init(void)
 {
        rds_conn_slab = kmem_cache_create("rds_connection",
                                          sizeof(struct rds_connection),

diff --git a/net/rds/ib.c b/net/rds/ib.c
index d2007b9..3eb5617 100644 (file)
--- a/net/rds/ib.c
+++ b/net/rds/ib.c
@@ -381,7 +381,7 @@ struct rds_transport rds_ib_transport = {
        .t_type                 = RDS_TRANS_IB
 };
 
-int __init rds_ib_init(void)
+int rds_ib_init(void)
 {
        int ret;
 

diff --git a/net/rds/ib.h b/net/rds/ib.h
index fd4ea69..acda2db 100644 (file)
--- a/net/rds/ib.h
+++ b/net/rds/ib.h
@@ -282,7 +282,7 @@ void rds_ib_conn_free(void *arg);
 int rds_ib_conn_connect(struct rds_connection *conn);
 void rds_ib_conn_shutdown(struct rds_connection *conn);
 void rds_ib_state_change(struct sock *sk);
-int __init rds_ib_listen_init(void);
+int rds_ib_listen_init(void);
 void rds_ib_listen_stop(void);
 void __rds_ib_conn_error(struct rds_connection *conn, const char *, ...);
 int rds_ib_cm_handle_connect(struct rdma_cm_id *cm_id,
@@ -308,11 +308,11 @@ void *rds_ib_get_mr(struct scatterlist *sg, unsigned long nents,
 void rds_ib_sync_mr(void *trans_private, int dir);
 void rds_ib_free_mr(void *trans_private, int invalidate);
 void rds_ib_flush_mrs(void);
-int __init rds_ib_fmr_init(void);
-void __exit rds_ib_fmr_exit(void);
+int rds_ib_fmr_init(void);
+void rds_ib_fmr_exit(void);
 
 /* ib_recv.c */
-int __init rds_ib_recv_init(void);
+int rds_ib_recv_init(void);
 void rds_ib_recv_exit(void);
 int rds_ib_recv(struct rds_connection *conn);
 int rds_ib_recv_alloc_caches(struct rds_ib_connection *ic);
@@ -363,7 +363,7 @@ unsigned int rds_ib_stats_info_copy(struct rds_info_iterator *iter,
                                    unsigned int avail);
 
 /* ib_sysctl.c */
-int __init rds_ib_sysctl_init(void);
+int rds_ib_sysctl_init(void);
 void rds_ib_sysctl_exit(void);
 extern unsigned long rds_ib_sysctl_max_send_wr;
 extern unsigned long rds_ib_sysctl_max_recv_wr;

diff --git a/net/rds/ib_rdma.c b/net/rds/ib_rdma.c
index 0eb5976..3efdddc 100644 (file)
--- a/net/rds/ib_rdma.c
+++ b/net/rds/ib_rdma.c
@@ -693,7 +693,7 @@ out_nolock:
 
 struct workqueue_struct *rds_ib_fmr_wq;
 
-int __init rds_ib_fmr_init(void)
+int rds_ib_fmr_init(void)
 {
        rds_ib_fmr_wq = create_workqueue("rds_fmr_flushd");
        if (!rds_ib_fmr_wq)
@@ -706,7 +706,7 @@ int __init rds_ib_fmr_init(void)
  * had their pools freed.  As each pool is freed its work struct is waited on,
  * so the pool flushing work queue should be idle by the time we get here.
  */
-void __exit rds_ib_fmr_exit(void)
+void rds_ib_fmr_exit(void)
 {
        destroy_workqueue(rds_ib_fmr_wq);
 }

diff --git a/net/rds/ib_recv.c b/net/rds/ib_recv.c
index 37dab28..f25c483 100644 (file)
--- a/net/rds/ib_recv.c
+++ b/net/rds/ib_recv.c
@@ -1040,7 +1040,7 @@ int rds_ib_recv(struct rds_connection *conn)
        return ret;
 }
 
-int __init rds_ib_recv_init(void)
+int rds_ib_recv_init(void)
 {
        struct sysinfo si;
        int ret = -ENOMEM;

diff --git a/net/rds/ib_sysctl.c b/net/rds/ib_sysctl.c
index b556c5c..fc3da37 100644 (file)
--- a/net/rds/ib_sysctl.c
+++ b/net/rds/ib_sysctl.c
@@ -119,7 +119,7 @@ void rds_ib_sysctl_exit(void)
                unregister_sysctl_table(rds_ib_sysctl_hdr);
 }
 
-int __init rds_ib_sysctl_init(void)
+int rds_ib_sysctl_init(void)
 {
        rds_ib_sysctl_hdr = register_sysctl_paths(rds_ib_sysctl_path, rds_ib_sysctl_table);
        if (!rds_ib_sysctl_hdr)

diff --git a/net/rds/iw.c b/net/rds/iw.c
index 467790d..56808ca 100644 (file)
--- a/net/rds/iw.c
+++ b/net/rds/iw.c
@@ -287,7 +287,7 @@ struct rds_transport rds_iw_transport = {
        .t_prefer_loopback      = 1,
 };
 
-int __init rds_iw_init(void)
+int rds_iw_init(void)
 {
        int ret;
 

diff --git a/net/rds/iw.h b/net/rds/iw.h
index f112105..543e665 100644 (file)
--- a/net/rds/iw.h
+++ b/net/rds/iw.h
@@ -284,7 +284,7 @@ void rds_iw_conn_free(void *arg);
 int rds_iw_conn_connect(struct rds_connection *conn);
 void rds_iw_conn_shutdown(struct rds_connection *conn);
 void rds_iw_state_change(struct sock *sk);
-int __init rds_iw_listen_init(void);
+int rds_iw_listen_init(void);
 void rds_iw_listen_stop(void);
 void __rds_iw_conn_error(struct rds_connection *conn, const char *, ...);
 int rds_iw_cm_handle_connect(struct rdma_cm_id *cm_id,
@@ -321,7 +321,7 @@ void rds_iw_flush_mrs(void);
 void rds_iw_remove_cm_id(struct rds_iw_device *rds_iwdev, struct rdma_cm_id *cm_id);
 
 /* ib_recv.c */
-int __init rds_iw_recv_init(void);
+int rds_iw_recv_init(void);
 void rds_iw_recv_exit(void);
 int rds_iw_recv(struct rds_connection *conn);
 int rds_iw_recv_refill(struct rds_connection *conn, gfp_t kptr_gfp,
@@ -370,7 +370,7 @@ unsigned int rds_iw_stats_info_copy(struct rds_info_iterator *iter,
                                    unsigned int avail);
 
 /* ib_sysctl.c */
-int __init rds_iw_sysctl_init(void);
+int rds_iw_sysctl_init(void);
 void rds_iw_sysctl_exit(void);
 extern unsigned long rds_iw_sysctl_max_send_wr;
 extern unsigned long rds_iw_sysctl_max_recv_wr;

diff --git a/net/rds/iw_recv.c b/net/rds/iw_recv.c
index 7e929f7..5e57347 100644 (file)
--- a/net/rds/iw_recv.c
+++ b/net/rds/iw_recv.c
@@ -887,7 +887,7 @@ int rds_iw_recv(struct rds_connection *conn)
        return ret;
 }
 
-int __init rds_iw_recv_init(void)
+int rds_iw_recv_init(void)
 {
        struct sysinfo si;
        int ret = -ENOMEM;

diff --git a/net/rds/iw_sysctl.c b/net/rds/iw_sysctl.c
index 3cb0587..23e3a9a 100644 (file)
--- a/net/rds/iw_sysctl.c
+++ b/net/rds/iw_sysctl.c
@@ -122,7 +122,7 @@ void rds_iw_sysctl_exit(void)
                unregister_sysctl_table(rds_iw_sysctl_hdr);
 }
 
-int __init rds_iw_sysctl_init(void)
+int rds_iw_sysctl_init(void)
 {
        rds_iw_sysctl_hdr = register_sysctl_paths(rds_iw_sysctl_path, rds_iw_sysctl_table);
        if (!rds_iw_sysctl_hdr)

diff --git a/net/rds/rdma_transport.c b/net/rds/rdma_transport.c
index e599ba2..550d348 100644 (file)
--- a/net/rds/rdma_transport.c
+++ b/net/rds/rdma_transport.c
@@ -122,7 +122,7 @@ out:
        return ret;
 }
 
-static int __init rds_rdma_listen_init(void)
+static int rds_rdma_listen_init(void)
 {
        struct sockaddr_in sin;
        struct rdma_cm_id *cm_id;
@@ -177,7 +177,7 @@ static void rds_rdma_listen_stop(void)
        }
 }
 
-int __init rds_rdma_init(void)
+int rds_rdma_init(void)
 {
        int ret;
 

diff --git a/net/rds/rds.h b/net/rds/rds.h
index 4510344..8a8a482 100644 (file)
--- a/net/rds/rds.h
+++ b/net/rds/rds.h
@@ -606,7 +606,7 @@ void rds_cong_exit(void);
 struct rds_message *rds_cong_update_alloc(struct rds_connection *conn);
 
 /* conn.c */
-int __init rds_conn_init(void);
+int rds_conn_init(void);
 void rds_conn_exit(void);
 struct rds_connection *rds_conn_create(__be32 laddr, __be32 faddr,
                                       struct rds_transport *trans, gfp_t gfp);
@@ -769,14 +769,14 @@ DECLARE_PER_CPU_SHARED_ALIGNED(struct rds_statistics, rds_stats);
        put_cpu();                                      \
 } while (0)
 #define rds_stats_add(member, count) rds_stats_add_which(rds_stats, member, count)
-int __init rds_stats_init(void);
+int rds_stats_init(void);
 void rds_stats_exit(void);
 void rds_stats_info_copy(struct rds_info_iterator *iter,
                         uint64_t *values, const char *const *names,
                         size_t nr);
 
 /* sysctl.c */
-int __init rds_sysctl_init(void);
+int rds_sysctl_init(void);
 void rds_sysctl_exit(void);
 extern unsigned long rds_sysctl_sndbuf_min;
 extern unsigned long rds_sysctl_sndbuf_default;
@@ -790,7 +790,7 @@ extern unsigned long rds_sysctl_trace_flags;
 extern unsigned int  rds_sysctl_trace_level;
 
 /* threads.c */
-int __init rds_threads_init(void);
+int rds_threads_init(void);
 void rds_threads_exit(void);
 extern struct workqueue_struct *rds_wq;
 void rds_queue_reconnect(struct rds_connection *conn);
@@ -806,7 +806,7 @@ void rds_trans_unregister(struct rds_transport *trans);
 struct rds_transport *rds_trans_get_preferred(__be32 addr);
 unsigned int rds_trans_stats_info_copy(struct rds_info_iterator *iter,
                                       unsigned int avail);
-int __init rds_trans_init(void);
+int rds_trans_init(void);
 void rds_trans_exit(void);
 
 #endif

diff --git a/net/rds/stats.c b/net/rds/stats.c
index 344929a..10c759c 100644 (file)
--- a/net/rds/stats.c
+++ b/net/rds/stats.c
@@ -143,7 +143,7 @@ void rds_stats_exit(void)
        rds_info_deregister_func(RDS_INFO_COUNTERS, rds_stats_info);
 }
 
-int __init rds_stats_init(void)
+int rds_stats_init(void)
 {
        rds_info_register_func(RDS_INFO_COUNTERS, rds_stats_info);
        return 0;

diff --git a/net/rds/sysctl.c b/net/rds/sysctl.c
index 5a6dd81..25ad0c7 100644 (file)
--- a/net/rds/sysctl.c
+++ b/net/rds/sysctl.c
@@ -105,7 +105,7 @@ void rds_sysctl_exit(void)
                unregister_sysctl_table(rds_sysctl_reg_table);
 }
 
-int __init rds_sysctl_init(void)
+int rds_sysctl_init(void)
 {
        rds_sysctl_reconnect_min = msecs_to_jiffies(1);
        rds_sysctl_reconnect_min_jiffies = rds_sysctl_reconnect_min;

diff --git a/net/rds/tcp.c b/net/rds/tcp.c
index 3262992..eeb08e6 100644 (file)
--- a/net/rds/tcp.c
+++ b/net/rds/tcp.c
@@ -274,7 +274,7 @@ struct rds_transport rds_tcp_transport = {
        .t_prefer_loopback      = 1,
 };
 
-int __init rds_tcp_init(void)
+int rds_tcp_init(void)
 {
        int ret;
 

diff --git a/net/rds/tcp.h b/net/rds/tcp.h
index 16b1663..f5e6f7b 100644 (file)
--- a/net/rds/tcp.h
+++ b/net/rds/tcp.h
@@ -43,7 +43,7 @@ struct rds_tcp_statistics {
 };
 
 /* tcp.c */
-int __init rds_tcp_init(void);
+int rds_tcp_init(void);
 void rds_tcp_exit(void);
 void rds_tcp_tune(struct socket *sock);
 void rds_tcp_nonagle(struct socket *sock);
@@ -61,12 +61,12 @@ void rds_tcp_conn_shutdown(struct rds_connection *conn);
 void rds_tcp_state_change(struct sock *sk);
 
 /* tcp_listen.c */
-int __init rds_tcp_listen_init(void);
+int rds_tcp_listen_init(void);
 void rds_tcp_listen_stop(void);
 void rds_tcp_listen_data_ready(struct sock *sk, int bytes);
 
 /* tcp_recv.c */
-int __init rds_tcp_recv_init(void);
+int rds_tcp_recv_init(void);
 void rds_tcp_recv_exit(void);
 void rds_tcp_data_ready(struct sock *sk, int bytes);
 int rds_tcp_recv(struct rds_connection *conn);

diff --git a/net/rds/tcp_listen.c b/net/rds/tcp_listen.c
index 50b649e..ae27869 100644 (file)
--- a/net/rds/tcp_listen.c
+++ b/net/rds/tcp_listen.c
@@ -135,7 +135,7 @@ out:
        ready(sk, bytes);
 }
 
-int __init rds_tcp_listen_init(void)
+int rds_tcp_listen_init(void)
 {
        struct sockaddr_in sin;
        struct socket *sock = NULL;

diff --git a/net/rds/tcp_recv.c b/net/rds/tcp_recv.c
index 49c9660..7017f3a 100644 (file)
--- a/net/rds/tcp_recv.c
+++ b/net/rds/tcp_recv.c
@@ -342,7 +342,7 @@ out:
        ready(sk, bytes);
 }
 
-int __init rds_tcp_recv_init(void)
+int rds_tcp_recv_init(void)
 {
        rds_tcp_incoming_slab = kmem_cache_create("rds_tcp_incoming",
                                        sizeof(struct rds_tcp_incoming),

diff --git a/net/rds/threads.c b/net/rds/threads.c
index c08c220..0fd90f8 100644 (file)
--- a/net/rds/threads.c
+++ b/net/rds/threads.c
@@ -212,7 +212,7 @@ void rds_threads_exit(void)
        destroy_workqueue(rds_wq);
 }
 
-int __init rds_threads_init(void)
+int rds_threads_init(void)
 {
        rds_wq = create_singlethread_workqueue("krdsd");
        if (!rds_wq)