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 f16d2a92cb8999f710ebad172429b7c5043081e2..57ef0ec4f03df341a8505a97e34f84499ec3c6a5 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 7670b45680e155c69ff8873b220aab63e38c692c..0de40d9563ca82a0d2505c7e2381b79238a15dee 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 d2007b9316160e3c6bf9df526af316c4772c86dc..3eb5617649c6f5d62cf6cb850bdace8ea2e6a07a 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 fd4ea69d24431b1216f3ab86156d0557d0ea86d2..acda2dbc657624e81ed52eb69b7b7d0dcc90b4e1 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 0eb597670c5b5a655b94fa5ea033452298428d39..3efdddc39d49ba64fe894d815f198343fb8526f6 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 37dab2898ad013bc6f9aec091935bc6a891e790d..f25c4837d2f6cd85b14bdb09fa4ba84efc237ea6 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 b556c5c2a902c20016721b9a08257a193a1f7f99..fc3da37220fd671133326d5c915ae6f8a947c644 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 467790da1316ad86e8e617ea9239c249d5a72157..56808cac0fc795dc1564b1928f816be1502473ce 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 f112105facedc702d81361ec3ed8bfde75c1b2a1..543e665fafe3ae2cb92e3772425a79c1a6f95ffc 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 7e929f701a0cfcb0e2c861c923a71d343de1de9d..5e57347f49ff040968067b50ac35283e4463acd7 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 3cb0587d6f50073389aba1563f903086561161fb..23e3a9a26aaf36285fef39e8b909ce0d8b62327a 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 e599ba2f950d72e03c4bc98f7b1a9b86742134e7..550d34837fe7893cf5e8aafee486f9f597e0542c 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 4510344ce8ca3a527fa6ea46c790ff78b1fd050f..8a8a4822d02a98441dc733a2f25e031bd789971c 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 344929a663e544adb23f00c73c4c0849cb8f7db3..10c759ccac0c7a5d134e1cd49b41c45651e657c1 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 5a6dd81de1885f8a95593217e5f43233b94f7a2c..25ad0c77a26cd16cca2d96681fae4f77373757bf 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 3262992f5f2b24830074bc018f710c0be7a49e16..eeb08e6ab96b0c79b3553dbcef9899eee5fbdac2 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 16b166379ea96377eeaf5c3a97dde59be79dc117..f5e6f7bebb5013acbf6b74fe76faf44ab391bfcb 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 50b649eb6933b7a1ff38f1810673b4f6b72363c8..ae27869dfc2137a342918f558082c1e58e1d4e88 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 49c9660107882b0d1f2d8de973babf6102ea7e24..7017f3af80b671cca7b403d99e8006444eb1c8bb 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 c08c220efac5cf36023c51ffd0c774dc266b1502..0fd90f8c5f59c75c18c244701f3230f93c408d85 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)