static int bond_change_mtu(struct net_device *bond_dev, int new_mtu){	struct bonding *bond = bond_dev->priv;	struct slave *slave, *stop_at;	int res = 0;	int i;	dprintk("bond=%p, name=%s, new_mtu=%d\n", bond,		(bond_dev ? bond_dev->name : "None"), new_mtu);	/* Can't hold bond->lock with bh disabled here since	 * some base drivers panic. On the other hand we can't	 * hold bond->lock without bh disabled because we'll	 * deadlock. The only solution is to rely on the fact	 * that we're under rtnl_lock here, and the slaves	 * list won't change. This doesn't solve the problem	 * of setting the slave's MTU while it is	 * transmitting, but the assumption is that the base	 * driver can handle that.	 *	 * TODO: figure out a way to safely iterate the slaves	 * list, but without holding a lock around the actual	 * call to the base driver.	 */	bond_for_each_slave(bond, slave, i) {		dprintk("s %p s->p %p c_m %p\n", slave,			slave->prev, slave->dev->change_mtu);		res = dev_set_mtu(slave->dev, new_mtu);		if (res) {			/* If we failed to set the slave's mtu to the new value			 * we must abort the operation even in ACTIVE_BACKUP			 * mode, because if we allow the backup slaves to have			 * different mtu values than the active slave we'll			 * need to change their mtu when doing a failover. That			 * means changing their mtu from timer context, which			 * is probably not a good idea.			 */			dprintk("err %d %s\n", res, slave->dev->name);			goto unwind;		}	}	bond_dev->mtu = new_mtu;	return 0;unwind:	/* unwind from head to the slave that failed */	stop_at = slave;	bond_for_each_slave_from_to(bond, slave, i, bond->first_slave, stop_at) {		int tmp_res;		tmp_res = dev_set_mtu(slave->dev, bond_dev->mtu);		if (tmp_res) {			dprintk("unwind err %d dev %s\n", tmp_res,				slave->dev->name);		}	}	return res;}
10457	/local/tlutelli/issta_data/temp/c/2005_temp/2005/10457/e944ef79184ff7f283e7bf79496d2873a0b0410b/bond_main.c/clean/drivers/net/bonding/bond_main.c