[PATCH] named struct initialisers.

net/sched/sch_atm.c

@@ -668,39 +668,39 @@ static int atm_tc_dump(struct Qdisc *sch, struct sk_buff *skb)
 
 static struct Qdisc_class_ops atm_class_ops =
 {
-	atm_tc_graft,			/* graft */
-	atm_tc_leaf,			/* leaf */
-	atm_tc_get,			/* get */
-	atm_tc_put,			/* put */
-	atm_tc_change,			/* change */
-	atm_tc_delete,			/* delete */
-	atm_tc_walk,			/* walk */
-
-	atm_tc_find_tcf,		/* tcf_chain */
-	atm_tc_bind_filter,		/* bind_tcf */
-	atm_tc_put,			/* unbind_tcf */
-
-	atm_tc_dump_class,		/* dump */
+	.graft		= atm_tc_graft,
+	.leaf		= atm_tc_leaf,
+	.get		= atm_tc_get,
+	.put		= atm_tc_put,
+	.change		= atm_tc_change,
+	.delete		= atm_tc_delete,
+	.walk		= atm_tc_walk,
+
+	.tcf_chain	= atm_tc_find_tcf,
+	.bind_tcf	= atm_tc_bind_filter,
+	.unbind_tcf	= atm_tc_put,
+
+	.dump		= atm_tc_dump_class,
 };
 
 struct Qdisc_ops atm_qdisc_ops =
 {
-	NULL,				/* next */
-	&atm_class_ops,			/* cl_ops */
-	"atm",
-	sizeof(struct atm_qdisc_data),
-
-	atm_tc_enqueue,			/* enqueue */
-	atm_tc_dequeue,			/* dequeue */
-	atm_tc_requeue,			/* requeue */
-	atm_tc_drop,			/* drop */
-
-	atm_tc_init,			/* init */
-	atm_tc_reset,			/* reset */
-	atm_tc_destroy,			/* destroy */
-	NULL,				/* change */
-
-	atm_tc_dump			/* dump */
+	.next		= NULL,
+	.cl_ops		= &atm_class_ops,
+	.id		= "atm",
+	.priv_size	= sizeof(struct atm_qdisc_data),
+
+	.enqueue	= atm_tc_enqueue,
+	.dequeue	= atm_tc_dequeue,
+	.requeue	= atm_tc_requeue,
+	.drop		= atm_tc_drop,
+
+	.init		= atm_tc_init,
+	.reset		= atm_tc_reset,
+	.destroy	= atm_tc_destroy,
+	.change		= NULL,
+
+	.dump		= atm_tc_dump
 };
 
 

net/sched/sch_cbq.c

@@ -2066,39 +2066,39 @@ static void cbq_walk(struct Qdisc *sch, struct qdisc_walker *arg)
 
 static struct Qdisc_class_ops cbq_class_ops =
 {
-	cbq_graft,
-	cbq_leaf,
-	cbq_get,
-	cbq_put,
-	cbq_change_class,
-	cbq_delete,
-	cbq_walk,
-
-	cbq_find_tcf,
-	cbq_bind_filter,
-	cbq_unbind_filter,
-
-	cbq_dump_class,
+	.graft		= cbq_graft,
+	.leaf		= cbq_leaf,
+	.get		= cbq_get,
+	.put		= cbq_put,
+	.change		= cbq_change_class,
+	.delete		= cbq_delete,
+	.walk		= cbq_walk,
+
+	.tcf_chain	= cbq_find_tcf,
+	.bind_tcf	= cbq_bind_filter,
+	.unbind_tcf	= cbq_unbind_filter,
+
+	.dump		= cbq_dump_class,
 };
 
 struct Qdisc_ops cbq_qdisc_ops =
 {
-	NULL,
-	&cbq_class_ops,
-	"cbq",
-	sizeof(struct cbq_sched_data),
+	.next		= NULL,
+	.cl_ops		= &cbq_class_ops,
+	.id		= "cbq",
+	.priv_size	= sizeof(struct cbq_sched_data),
 
-	cbq_enqueue,
-	cbq_dequeue,
-	cbq_requeue,
-	cbq_drop,
+	.enqueue	= cbq_enqueue,
+	.dequeue	= cbq_dequeue,
+	.requeue	= cbq_requeue,
+	.drop		= cbq_drop,
 
-	cbq_init,
-	cbq_reset,
-	cbq_destroy,
-	NULL /* cbq_change */,
+	.init		= cbq_init,
+	.reset		= cbq_reset,
+	.destroy	= cbq_destroy,
+	.change		= NULL,
 
-	cbq_dump,
+	.dump		= cbq_dump,
 };
 
 #ifdef MODULE

net/sched/sch_csz.c

@@ -1012,40 +1012,40 @@ static struct tcf_proto ** csz_find_tcf(struct Qdisc *sch, unsigned long cl)
 
 struct Qdisc_class_ops csz_class_ops =
 {
-	csz_graft,
-	csz_leaf,
+	.graft		= csz_graft,
+	.leaf		= csz_leaf,
 
-	csz_get,
-	csz_put,
-	csz_change,
-	csz_delete,
-	csz_walk,
+	.get		= csz_get,
+	.put		= csz_put,
+	.change		= csz_change,
+	.delete		= csz_delete,
+	.walk		= csz_walk,
 
-	csz_find_tcf,
-	csz_bind,
-	csz_put,
+	.tcf_chain	= csz_find_tcf,
+	.bind_tcf	= csz_bind,
+	.unbind_tcf	= csz_put,
 
-	csz_dump_class,
+	.dump		= csz_dump_class,
 };
 
 struct Qdisc_ops csz_qdisc_ops =
 {
-	NULL,
-	&csz_class_ops,
-	"csz",
-	sizeof(struct csz_sched_data),
-
-	csz_enqueue,
-	csz_dequeue,
-	NULL,
-	NULL,
-
-	csz_init,
-	csz_reset,
-	csz_destroy,
-	NULL /* csz_change */,
-
-	csz_dump,
+	.next		= NULL,
+	.cl_ops		= &csz_class_ops,
+	.id		= "csz",
+	.priv_size	= sizeof(struct csz_sched_data),
+
+	.enqueue	= csz_enqueue,
+	.dequeue	= csz_dequeue,
+	.requeue	= NULL,
+	.drop		= NULL,
+
+	.init		= csz_init,
+	.reset		= csz_reset,
+	.destroy	= csz_destroy,
+	.change		= NULL,
+
+	.dump		= csz_dump,
 };
 
 

net/sched/sch_dsmark.c

@@ -434,39 +434,39 @@ static int dsmark_dump(struct Qdisc *sch, struct sk_buff *skb)
 
 static struct Qdisc_class_ops dsmark_class_ops =
 {
-	dsmark_graft,			/* graft */
-	dsmark_leaf,			/* leaf */
-	dsmark_get,			/* get */
-	dsmark_put,			/* put */
-	dsmark_change,			/* change */
-	dsmark_delete,			/* delete */
-	dsmark_walk,			/* walk */
-
-	dsmark_find_tcf,		/* tcf_chain */
-	dsmark_bind_filter,		/* bind_tcf */
-	dsmark_put,			/* unbind_tcf */
-
-	dsmark_dump_class,		/* dump */
+	.graft		= dsmark_graft,
+	.leaf		= dsmark_leaf,
+	.get		= dsmark_get,
+	.put		= dsmark_put,
+	.change		= dsmark_change,
+	.delete		= dsmark_delete,
+	.walk		= dsmark_walk,
+
+	.tcf_chain	= dsmark_find_tcf,
+	.bind_tcf	= dsmark_bind_filter,
+	.unbind_tcf	= dsmark_put,
+
+	.dump		= dsmark_dump_class,
 };
 
 struct Qdisc_ops dsmark_qdisc_ops =
 {
-	NULL,				/* next */
-	&dsmark_class_ops,		/* cl_ops */
-	"dsmark",
-	sizeof(struct dsmark_qdisc_data),
-
-	dsmark_enqueue,			/* enqueue */
-	dsmark_dequeue,			/* dequeue */
-	dsmark_requeue,			/* requeue */
-	dsmark_drop,			/* drop */
-
-	dsmark_init,			/* init */
-	dsmark_reset,			/* reset */
-	dsmark_destroy,			/* destroy */
-	NULL,				/* change */
-
-	dsmark_dump			/* dump */
+	.next		= NULL,
+	.cl_ops		= &dsmark_class_ops,
+	.id		= "dsmark",
+	.priv_size	= sizeof(struct dsmark_qdisc_data),
+
+	.enqueue	= dsmark_enqueue,
+	.dequeue	= dsmark_dequeue,
+	.requeue	= dsmark_requeue,
+	.drop		= dsmark_drop,
+
+	.init		= dsmark_init,
+	.reset		= dsmark_reset,
+	.destroy	= dsmark_destroy,
+	.change		= NULL,
+
+	.dump		= dsmark_dump
 };
 
 #ifdef MODULE

net/sched/sch_fifo.c

@@ -170,39 +170,40 @@ static int fifo_dump(struct Qdisc *sch, struct sk_buff *skb)
 
 struct Qdisc_ops pfifo_qdisc_ops =
 {
-	NULL,
-	NULL,
-	"pfifo",
-	sizeof(struct fifo_sched_data),
-
-	pfifo_enqueue,
-	pfifo_dequeue,
-	pfifo_requeue,
-	fifo_drop,
-
-	fifo_init,
-	fifo_reset,
-	NULL,
-	fifo_init,
-
-	fifo_dump,
+	.next		= NULL,
+	.cl_ops		= NULL,
+	.id		= "pfifo",
+	.priv_size	= sizeof(struct fifo_sched_data),
+
+	.enqueue	= pfifo_enqueue,
+	.dequeue	= pfifo_dequeue,
+	.requeue	= pfifo_requeue,
+	.drop		= fifo_drop,
+
+	.init		= fifo_init,
+	.reset		= fifo_reset,
+	.destroy	= NULL,
+	.change		= fifo_init,
+
+	.dump		= fifo_dump,
 };
 
 struct Qdisc_ops bfifo_qdisc_ops =
 {
-	NULL,
-	NULL,
-	"bfifo",
-	sizeof(struct fifo_sched_data),
-
-	bfifo_enqueue,
-	bfifo_dequeue,
-	bfifo_requeue,
-	fifo_drop,
-
-	fifo_init,
-	fifo_reset,
-	NULL,
-	fifo_init,
-	fifo_dump,
+	.next		= NULL,
+	.cl_ops		= NULL,
+	.id		= "bfifo",
+	.priv_size	= sizeof(struct fifo_sched_data),
+
+	.enqueue	= bfifo_enqueue,
+	.dequeue	= bfifo_dequeue,
+	.requeue	= bfifo_requeue,
+	.drop		= fifo_drop,
+
+	.init		= fifo_init,
+	.reset		= fifo_reset,
+	.destroy	= NULL,
+	.change		= fifo_init,
+
+	.dump		= fifo_dump,
 };

net/sched/sch_generic.c

@@ -224,49 +224,48 @@ noop_requeue(struct sk_buff *skb, struct Qdisc* qdisc)
 
 struct Qdisc_ops noop_qdisc_ops =
 {
-	NULL,
-	NULL,
-	"noop",
-	0,
-
-	noop_enqueue,
-	noop_dequeue,
-	noop_requeue,
+	.next		= NULL,
+	.cl_ops		= NULL,
+	.id		= "noop",
+	.priv_size	= 0,
+
+	.enqueue	= noop_enqueue,
+	.dequeue	= noop_dequeue,
+	.requeue	= noop_requeue,
 };
 
 struct Qdisc noop_qdisc =
 {
-	noop_enqueue,
-	noop_dequeue,
-	TCQ_F_BUILTIN,
-	&noop_qdisc_ops,	
+	.enqueue	= noop_enqueue,
+	.dequeue	= noop_dequeue,
+	.flags		= TCQ_F_BUILTIN,
+	.ops		= &noop_qdisc_ops,	
 };
 
 
 struct Qdisc_ops noqueue_qdisc_ops =
 {
-	NULL,
-	NULL,
-	"noqueue",
-	0,
-
-	noop_enqueue,
-	noop_dequeue,
-	noop_requeue,
-
+	.next		= NULL,
+	.cl_ops		= NULL,
+	.id		= "noqueue",
+	.priv_size	= 0,
+
+	.enqueue	= noop_enqueue,
+	.dequeue	= noop_dequeue,
+	.requeue	= noop_requeue,
 };
 
 struct Qdisc noqueue_qdisc =
 {
-	NULL,
-	noop_dequeue,
-	TCQ_F_BUILTIN,
-	&noqueue_qdisc_ops,
+	.enqueue	= NULL,
+	.dequeue	= noop_dequeue,
+	.flags		= TCQ_F_BUILTIN,
+	.ops		= &noqueue_qdisc_ops,
 };
 
 
 static const u8 prio2band[TC_PRIO_MAX+1] =
-{ 1, 2, 2, 2, 1, 2, 0, 0 , 1, 1, 1, 1, 1, 1, 1, 1 };
+	{ 1, 2, 2, 2, 1, 2, 0, 0 , 1, 1, 1, 1, 1, 1, 1, 1 };
 
 /* 3-band FIFO queue: old style, but should be a bit faster than
    generic prio+fifo combination.
@@ -346,18 +345,17 @@ static int pfifo_fast_init(struct Qdisc *qdisc, struct rtattr *opt)
 
 static struct Qdisc_ops pfifo_fast_ops =
 {
-	NULL,
-	NULL,
-	"pfifo_fast",
-	3 * sizeof(struct sk_buff_head),
-
-	pfifo_fast_enqueue,
-	pfifo_fast_dequeue,
-	pfifo_fast_requeue,
-	NULL,
-
-	pfifo_fast_init,
-	pfifo_fast_reset,
+	.next		= NULL,
+	.cl_ops		= NULL,
+	.id		= "pfifo_fast",
+	.priv_size	= 3 * sizeof(struct sk_buff_head),
+
+	.enqueue	= pfifo_fast_enqueue,
+	.dequeue	= pfifo_fast_dequeue,
+	.requeue	= pfifo_fast_requeue,
+
+	.init		= pfifo_fast_init,
+	.reset		= pfifo_fast_reset,
 };
 
 struct Qdisc * qdisc_create_dflt(struct net_device *dev, struct Qdisc_ops *ops)

net/sched/sch_gred.c

@@ -603,19 +603,22 @@ static void gred_destroy(struct Qdisc *sch)
 
 struct Qdisc_ops gred_qdisc_ops =
 {
-	NULL,
-	NULL,
-	"gred",
-	sizeof(struct gred_sched),
-	gred_enqueue,
-	gred_dequeue,
-	gred_requeue,
-	gred_drop,
-	gred_init,
-	gred_reset,
-	gred_destroy,
-	gred_change, /* change */
-	gred_dump,
+	.next		= NULL,
+	.cl_ops		= NULL,
+	.id		= "gred",
+	.priv_size	= sizeof(struct gred_sched),
+
+	.enqueue	= gred_enqueue,
+	.dequeue	= gred_dequeue,
+	.requeue	= gred_requeue,
+	.drop		= gred_drop,
+
+	.init		= gred_init,
+	.reset		= gred_reset,
+	.destroy	= gred_destroy,
+	.change		= gred_change,
+
+	.dump		= gred_dump,
 };
 
 

net/sched/sch_ingress.c

@@ -326,39 +326,39 @@ static int ingress_dump(struct Qdisc *sch, struct sk_buff *skb)
 
 static struct Qdisc_class_ops ingress_class_ops =
 {
-	ingress_graft,			/* graft */
-	ingress_leaf,			/* leaf */
-	ingress_get,			/* get */
-	ingress_put,			/* put */
-	ingress_change,			/* change */
-	NULL,				/* delete */
-	ingress_walk,				/* walk */
-
-	ingress_find_tcf,		/* tcf_chain */
-	ingress_bind_filter,		/* bind_tcf */
-	ingress_put,			/* unbind_tcf */
-
-	NULL,		/* dump */
+	.graft		= ingress_graft,
+	.leaf		= ingress_leaf,
+	.get		= ingress_get,
+	.put		= ingress_put,
+	.change		= ingress_change,
+	.delete		= NULL,
+	.walk		= ingress_walk,
+
+	.tcf_chain	= ingress_find_tcf,
+	.bind_tcf	= ingress_bind_filter,
+	.unbind_tcf	= ingress_put,
+
+	.dump		= NULL,
 };
 
 struct Qdisc_ops ingress_qdisc_ops =
 {
-	NULL,				/* next */
-	&ingress_class_ops,		/* cl_ops */
-	"ingress",
-	sizeof(struct ingress_qdisc_data),
-
-	ingress_enqueue,		/* enqueue */
-	ingress_dequeue,		/* dequeue */
-	ingress_requeue,		/* requeue */
-	ingress_drop,			/* drop */
-
-	ingress_init,			/* init */
-	ingress_reset,			/* reset */
-	ingress_destroy,		/* destroy */
-	NULL,				/* change */
-
-	ingress_dump,			/* dump */
+	.next		= NULL,
+	.cl_ops		= &ingress_class_ops,
+	.id		= "ingress",
+	.priv_size	= sizeof(struct ingress_qdisc_data),
+
+	.enqueue	= ingress_enqueue,
+	.dequeue	= ingress_dequeue,
+	.requeue	= ingress_requeue,
+	.drop		= ingress_drop,
+
+	.init		= ingress_init,
+	.reset		= ingress_reset,
+	.destroy	= ingress_destroy,
+	.change		= NULL,
+
+	.dump		= ingress_dump,
 };
 
 

net/sched/sch_prio.c

@@ -365,40 +365,40 @@ static struct tcf_proto ** prio_find_tcf(struct Qdisc *sch, unsigned long cl)
 
 static struct Qdisc_class_ops prio_class_ops =
 {
-	prio_graft,
-	prio_leaf,
+	.graft		= prio_graft,
+	.leaf		= prio_leaf,
 
-	prio_get,
-	prio_put,
-	prio_change,
-	prio_delete,
-	prio_walk,
+	.get		= prio_get,
+	.put		= prio_put,
+	.change		= prio_change,
+	.delete		= prio_delete,
+	.walk		= prio_walk,
 
-	prio_find_tcf,
-	prio_bind,
-	prio_put,
+	.tcf_chain	= prio_find_tcf,
+	.bind_tcf	= prio_bind,
+	.unbind_tcf	= prio_put,
 
-	prio_dump_class,
+	.dump		= prio_dump_class,
 };
 
 struct Qdisc_ops prio_qdisc_ops =
 {
-	NULL,
-	&prio_class_ops,
-	"prio",
-	sizeof(struct prio_sched_data),
-
-	prio_enqueue,
-	prio_dequeue,
-	prio_requeue,
-	prio_drop,
-
-	prio_init,
-	prio_reset,
-	prio_destroy,
-	prio_tune,
-
-	prio_dump,
+	next:		NULL,
+	cl_ops:		&prio_class_ops,
+	id:		"prio",
+	priv_size:	sizeof(struct prio_sched_data),
+
+	enqueue:	prio_enqueue,
+	dequeue:	prio_dequeue,
+	requeue:	prio_requeue,
+	drop:		prio_drop,
+
+	init:		prio_init,
+	reset:		prio_reset,
+	destroy:	prio_destroy,
+	change:		prio_tune,
+
+	dump:		prio_dump,
 };
 
 #ifdef MODULE

net/sched/sch_red.c

@@ -463,22 +463,22 @@ static void red_destroy(struct Qdisc *sch)
 
 struct Qdisc_ops red_qdisc_ops =
 {
-	NULL,
-	NULL,
-	"red",
-	sizeof(struct red_sched_data),
-
-	red_enqueue,
-	red_dequeue,
-	red_requeue,
-	red_drop,
-
-	red_init,
-	red_reset,
-	red_destroy,
-	red_change,
-
-	red_dump,
+	.next		= NULL,
+	.cl_ops		= NULL,
+	.id		= "red",
+	.priv_size	= sizeof(struct red_sched_data),
+
+	.enqueue	= red_enqueue,
+	.dequeue	= red_dequeue,
+	.requeue	= red_requeue,
+	.drop		= red_drop,
+
+	.init		= red_init,
+	.reset		= red_reset,
+	.destroy	= red_destroy,
+	.change		= red_change,
+
+	.dump		= red_dump,
 };
 
 

net/sched/sch_sfq.c

@@ -470,22 +470,22 @@ static int sfq_dump(struct Qdisc *sch, struct sk_buff *skb)
 
 struct Qdisc_ops sfq_qdisc_ops =
 {
-	NULL,
-	NULL,
-	"sfq",
-	sizeof(struct sfq_sched_data),
-
-	sfq_enqueue,
-	sfq_dequeue,
-	sfq_requeue,
-	sfq_drop,
-
-	sfq_init,
-	sfq_reset,
-	sfq_destroy,
-	NULL, /* sfq_change */
-
-	sfq_dump,
+	.next		= NULL,
+	.cl_ops		= NULL,
+	.id		= "sfq",
+	.priv_size	= sizeof(struct sfq_sched_data),
+
+	.enqueue	= sfq_enqueue,
+	.dequeue	= sfq_dequeue,
+	.requeue	= sfq_requeue,
+	.drop		= sfq_drop,
+
+	.init		= sfq_init,
+	.reset		= sfq_reset,
+	.destroy	= sfq_destroy,
+	.change		= NULL,
+
+	.dump		= sfq_dump,
 };
 
 #ifdef MODULE

net/sched/sch_tbf.c

@@ -393,22 +393,22 @@ static int tbf_dump(struct Qdisc *sch, struct sk_buff *skb)
 
 struct Qdisc_ops tbf_qdisc_ops =
 {
-	NULL,
-	NULL,
-	"tbf",
-	sizeof(struct tbf_sched_data),
-
-	tbf_enqueue,
-	tbf_dequeue,
-	tbf_requeue,
-	tbf_drop,
-
-	tbf_init,
-	tbf_reset,
-	tbf_destroy,
-	tbf_change,
-
-	tbf_dump,
+	.next		= NULL,
+	.cl_ops		= NULL,
+	.id		= "tbf",
+	.priv_size	= sizeof(struct tbf_sched_data),
+
+	.enqueue	= tbf_enqueue,
+	.dequeue	= tbf_dequeue,
+	.requeue	= tbf_requeue,
+	.drop		= tbf_drop,
+
+	.init		= tbf_init,
+	.reset		= tbf_reset,
+	.destroy	= tbf_destroy,
+	.change		= tbf_change,
+
+	.dump		= tbf_dump,
 };
 
 

net/sched/sch_teql.c

@@ -440,20 +440,20 @@ static int teql_master_init(struct net_device *dev)
 
 static struct teql_master the_master = {
 {
-	NULL,
-	NULL,
-	"",
-	sizeof(struct teql_sched_data),
-
-	teql_enqueue,
-	teql_dequeue,
-	teql_requeue,
-	NULL,
-
-	teql_qdisc_init,
-	teql_reset,
-	teql_destroy,
-	NULL,
+	.next		= NULL,
+	.cl_ops		= NULL,
+	.id		= "",
+	.priv_size	= sizeof(struct teql_sched_data),
+
+	.enqueue	= teql_enqueue,
+	.dequeue	= teql_dequeue,
+	.requeue	= teql_requeue,
+	.drop		= NULL,
+
+	.init		= teql_qdisc_init,
+	.reset		= teql_reset,
+	.destroy	= teql_destroy,
+	.dump		= NULL,
 },};
 
 

net/sunrpc/auth_null.c

@@ -125,20 +125,20 @@ nul_validate(struct rpc_task *task, u32 *p)
 }
 
 struct rpc_authops	authnull_ops = {
-	RPC_AUTH_NULL,
+	.au_flavor	= RPC_AUTH_NULL,
 #ifdef RPC_DEBUG
-	"NULL",
+	.au_name	= "NULL",
 #endif
-	nul_create,
-	nul_destroy,
-	nul_create_cred
+	.create		= nul_create,
+	.destroy	= nul_destroy,
+	.crcreate	= nul_create_cred,
 };
 
 static
 struct rpc_credops	null_credops = {
-	nul_destroy_cred,
-	nul_match,
-	nul_marshal,
-	nul_refresh,
-	nul_validate
+	.crdestroy	= nul_destroy_cred,
+	.crmatch	= nul_match,
+	.crmarshal	= nul_marshal,
+	.crrefresh	= nul_refresh,
+	.crvalidate	= nul_validate,
 };

net/sunrpc/auth_unix.c

@@ -239,20 +239,20 @@ unx_validate(struct rpc_task *task, u32 *p)
 }
 
 struct rpc_authops	authunix_ops = {
-	RPC_AUTH_UNIX,
+	.au_flavor	= RPC_AUTH_UNIX,
 #ifdef RPC_DEBUG
-	"UNIX",
+	.au_name	= "UNIX",
 #endif
-	unx_create,
-	unx_destroy,
-	unx_create_cred
+	.create		= unx_create,
+	.destroy	= unx_destroy,
+	.crcreate	= unx_create_cred,
 };
 
 static
 struct rpc_credops	unix_credops = {
-	unx_destroy_cred,
-	unx_match,
-	unx_marshal,
-	unx_refresh,
-	unx_validate
+	.crdestroy	= unx_destroy_cred,
+	.crmatch	= unx_match,
+	.crmarshal	= unx_marshal,
+	.crrefresh	= unx_refresh,
+	.crvalidate	= unx_validate,
 };

net/sunrpc/pmap_clnt.c

@@ -243,36 +243,50 @@ xdr_decode_bool(struct rpc_rqst *req, u32 *p, unsigned int *boolp)
 }
 
 static struct rpc_procinfo	pmap_procedures[4] = {
-	{ "pmap_null",
-		(kxdrproc_t) xdr_error,	
-		(kxdrproc_t) xdr_error,	0, 0 },
-	{ "pmap_set",
-		(kxdrproc_t) xdr_encode_mapping,	
-		(kxdrproc_t) xdr_decode_bool, 4, 1 },
-	{ "pmap_unset",
-		(kxdrproc_t) xdr_encode_mapping,	
-		(kxdrproc_t) xdr_decode_bool, 4, 1 },
-	{ "pmap_get",
-		(kxdrproc_t) xdr_encode_mapping,
-		(kxdrproc_t) xdr_decode_port, 4, 1 },
+	{ .p_procname		= "pmap_null",
+	  .p_encode		= (kxdrproc_t) xdr_error,	
+	  .p_decode		= (kxdrproc_t) xdr_error,
+	  .p_bufsiz		= 0,
+	  .p_count		= 0,
+	},
+	{ .p_procname		= "pmap_set",
+	  .p_encode		= (kxdrproc_t) xdr_encode_mapping,	
+	  .p_decode		= (kxdrproc_t) xdr_decode_bool,
+	  .p_bufsiz		= 4,
+	  .p_count		= 1,
+	},
+	{ .p_procname		= "pmap_unset",
+	  .p_encode		= (kxdrproc_t) xdr_encode_mapping,	
+	  .p_decode		= (kxdrproc_t) xdr_decode_bool,
+	  .p_bufsiz		= 4,
+	  .p_count		= 1,
+	},
+	{ .p_procname		= "pmap_get",
+	  .p_encode		= (kxdrproc_t) xdr_encode_mapping,
+	  .p_decode		= (kxdrproc_t) xdr_decode_port,
+	  .p_bufsiz		= 4,
+	  .p_count		= 1,
+	},
 };
 
 static struct rpc_version	pmap_version2 = {
-	2, 4, pmap_procedures
+	.number		= 2,
+	.nrprocs	= 4,
+	.procs		= pmap_procedures
 };
 
 static struct rpc_version *	pmap_version[] = {
 	NULL,
 	NULL,
-	&pmap_version2,
+	&pmap_version2
 };
 
 static struct rpc_stat		pmap_stats;
 
 struct rpc_program	pmap_program = {
-	"portmap",
-	RPC_PMAP_PROGRAM,
-	sizeof(pmap_version)/sizeof(pmap_version[0]),
-	pmap_version,
-	&pmap_stats,
+	.name		= "portmap",
+	.number		= RPC_PMAP_PROGRAM,
+	.nrvers		= sizeof(pmap_version)/sizeof(pmap_version[0]),
+	.version	= pmap_version,
+	.stats		= &pmap_stats,
 };