Eric Lee / smarc-fsl-linux-kernel

1

2

*

2

*

3

* Marek Lindner, Simon Wunderlich, Antonio Quartulli

3

* Marek Lindner, Simon Wunderlich, Antonio Quartulli

4

*

4

*

5

* This program is free software; you can redistribute it and/or

5

* This program is free software; you can redistribute it and/or

6

* modify it under the terms of version 2 of the GNU General Public

6

* modify it under the terms of version 2 of the GNU General Public

7

* License as published by the Free Software Foundation.

7

* License as published by the Free Software Foundation.

8

*

8

*

9

* This program is distributed in the hope that it will be useful, but

9

* This program is distributed in the hope that it will be useful, but

10

* WITHOUT ANY WARRANTY; without even the implied warranty of

10

* WITHOUT ANY WARRANTY; without even the implied warranty of

11

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

11

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

12

* General Public License for more details.

12

* General Public License for more details.

13

*

13

*

14

* You should have received a copy of the GNU General Public License

14

* You should have received a copy of the GNU General Public License

15

* along with this program; if not, see <http://www.gnu.org/licenses/>.

15

* along with this program; if not, see <http://www.gnu.org/licenses/>.

16

*/

16

*/

17

18

#include "translation-table.h"

18

#include "translation-table.h"

19

#include "main.h"

19

#include "main.h"

20

21

#include <linux/atomic.h>

21

#include <linux/atomic.h>

22

#include <linux/bitops.h>

22

#include <linux/bitops.h>

23

#include <linux/bug.h>

23

#include <linux/bug.h>

24

#include <linux/byteorder/generic.h>

24

#include <linux/byteorder/generic.h>

25

#include <linux/compiler.h>

25

#include <linux/compiler.h>

26

#include <linux/crc32c.h>

26

#include <linux/crc32c.h>

27

#include <linux/errno.h>

27

#include <linux/errno.h>

28

#include <linux/etherdevice.h>

28

#include <linux/etherdevice.h>

29

#include <linux/fs.h>

29

#include <linux/fs.h>

30

#include <linux/if_ether.h>

30

#include <linux/if_ether.h>

31

#include <linux/jhash.h>

31

#include <linux/jhash.h>

32

#include <linux/jiffies.h>

32

#include <linux/jiffies.h>

33

#include <linux/kernel.h>

33

#include <linux/kernel.h>

34

#include <linux/list.h>

34

#include <linux/list.h>

35

#include <linux/lockdep.h>

35

#include <linux/lockdep.h>

36

#include <linux/netdevice.h>

36

#include <linux/netdevice.h>

37

#include <linux/rculist.h>

37

#include <linux/rculist.h>

38

#include <linux/rcupdate.h>

38

#include <linux/rcupdate.h>

39

#include <linux/seq_file.h>

39

#include <linux/seq_file.h>

40

#include <linux/slab.h>

40

#include <linux/slab.h>

41

#include <linux/spinlock.h>

41

#include <linux/spinlock.h>

42

#include <linux/stddef.h>

42

#include <linux/stddef.h>

43

#include <linux/string.h>

43

#include <linux/string.h>

44

#include <linux/workqueue.h>

44

#include <linux/workqueue.h>

45

#include <net/net_namespace.h>

45

#include <net/net_namespace.h>

46

47

#include "bridge_loop_avoidance.h"

47

#include "bridge_loop_avoidance.h"

48

#include "hard-interface.h"

48

#include "hard-interface.h"

49

#include "hash.h"

49

#include "hash.h"

50

#include "multicast.h"

50

#include "multicast.h"

51

#include "originator.h"

51

#include "originator.h"

52

#include "packet.h"

52

#include "packet.h"

53

#include "soft-interface.h"

53

#include "soft-interface.h"

54

55

/* hash class keys */

55

/* hash class keys */

56

static struct lock_class_key batadv_tt_local_hash_lock_class_key;

56

static struct lock_class_key batadv_tt_local_hash_lock_class_key;

57

static struct lock_class_key batadv_tt_global_hash_lock_class_key;

57

static struct lock_class_key batadv_tt_global_hash_lock_class_key;

58

59

static void batadv_send_roam_adv(struct batadv_priv *bat_priv, u8 *client,

59

static void batadv_send_roam_adv(struct batadv_priv *bat_priv, u8 *client,

60

unsigned short vid,

60

unsigned short vid,

61

struct batadv_orig_node *orig_node);

61

struct batadv_orig_node *orig_node);

62

static void batadv_tt_purge(struct work_struct *work);

62

static void batadv_tt_purge(struct work_struct *work);

63

static void

63

static void

64

batadv_tt_global_del_orig_list(struct batadv_tt_global_entry *tt_global_entry);

64

batadv_tt_global_del_orig_list(struct batadv_tt_global_entry *tt_global_entry);

65

static void batadv_tt_global_del(struct batadv_priv *bat_priv,

65

static void batadv_tt_global_del(struct batadv_priv *bat_priv,

66

struct batadv_orig_node *orig_node,

66

struct batadv_orig_node *orig_node,

67

const unsigned char *addr,

67

const unsigned char *addr,

68

unsigned short vid, const char *message,

68

unsigned short vid, const char *message,

69

bool roaming);

69

bool roaming);

70

71

/* returns 1 if they are the same mac addr */

71

/* returns 1 if they are the same mac addr */

72

static int batadv_compare_tt(const struct hlist_node *node, const void *data2)

72

static int batadv_compare_tt(const struct hlist_node *node, const void *data2)

73

{

73

{

74

const void *data1 = container_of(node, struct batadv_tt_common_entry,

74

const void *data1 = container_of(node, struct batadv_tt_common_entry,

75

hash_entry);

75

hash_entry);

76

77

return batadv_compare_eth(data1, data2);

77

return batadv_compare_eth(data1, data2);

78

}

78

}

79

80

/**

80

/**

81

* batadv_choose_tt - return the index of the tt entry in the hash table

81

* batadv_choose_tt - return the index of the tt entry in the hash table

82

* @data: pointer to the tt_common_entry object to map

82

* @data: pointer to the tt_common_entry object to map

83

* @size: the size of the hash table

83

* @size: the size of the hash table

84

*

84

*

85

* Returns the hash index where the object represented by 'data' should be

85

* Returns the hash index where the object represented by 'data' should be

86

* stored at.

86

* stored at.

87

*/

87

*/

88

static inline u32 batadv_choose_tt(const void *data, u32 size)

88

static inline u32 batadv_choose_tt(const void *data, u32 size)

89

{

89

{

90

struct batadv_tt_common_entry *tt;

90

struct batadv_tt_common_entry *tt;

91

u32 hash = 0;

91

u32 hash = 0;

92

93

tt = (struct batadv_tt_common_entry *)data;

93

tt = (struct batadv_tt_common_entry *)data;

94

hash = jhash(&tt->addr, ETH_ALEN, hash);

94

hash = jhash(&tt->addr, ETH_ALEN, hash);

95

hash = jhash(&tt->vid, sizeof(tt->vid), hash);

95

hash = jhash(&tt->vid, sizeof(tt->vid), hash);

96

97

return hash % size;

97

return hash % size;

98

}

98

}

99

100

/**

100

/**

101

* batadv_tt_hash_find - look for a client in the given hash table

101

* batadv_tt_hash_find - look for a client in the given hash table

102

* @hash: the hash table to search

102

* @hash: the hash table to search

103

* @addr: the mac address of the client to look for

103

* @addr: the mac address of the client to look for

104

* @vid: VLAN identifier

104

* @vid: VLAN identifier

105

*

105

*

106

* Returns a pointer to the tt_common struct belonging to the searched client if

106

* Returns a pointer to the tt_common struct belonging to the searched client if

107

* found, NULL otherwise.

107

* found, NULL otherwise.

108

*/

108

*/

109

static struct batadv_tt_common_entry *

109

static struct batadv_tt_common_entry *

110

batadv_tt_hash_find(struct batadv_hashtable *hash, const u8 *addr,

110

batadv_tt_hash_find(struct batadv_hashtable *hash, const u8 *addr,

111

unsigned short vid)

111

unsigned short vid)

112

{

112

{

113

struct hlist_head *head;

113

struct hlist_head *head;

114

struct batadv_tt_common_entry to_search, *tt, *tt_tmp = NULL;

114

struct batadv_tt_common_entry to_search, *tt, *tt_tmp = NULL;

115

u32 index;

115

u32 index;

116

117

if (!hash)

117

if (!hash)

118

return NULL;

118

return NULL;

119

120

ether_addr_copy(to_search.addr, addr);

120

ether_addr_copy(to_search.addr, addr);

121

to_search.vid = vid;

121

to_search.vid = vid;

122

123

index = batadv_choose_tt(&to_search, hash->size);

123

index = batadv_choose_tt(&to_search, hash->size);

124

head = &hash->table[index];

124

head = &hash->table[index];

125

126

rcu_read_lock();

126

rcu_read_lock();

127

hlist_for_each_entry_rcu(tt, head, hash_entry) {

127

hlist_for_each_entry_rcu(tt, head, hash_entry) {

128

if (!batadv_compare_eth(tt, addr))

128

if (!batadv_compare_eth(tt, addr))

129

continue;

129

continue;

130

131

if (tt->vid != vid)

131

if (tt->vid != vid)

132

continue;

132

continue;

133

134

if (!atomic_inc_not_zero(&tt->refcount))

134

if (!atomic_inc_not_zero(&tt->refcount))

135

continue;

135

continue;

136

137

tt_tmp = tt;

137

tt_tmp = tt;

138

break;

138

break;

139

}

139

}

140

rcu_read_unlock();

140

rcu_read_unlock();

141

142

return tt_tmp;

142

return tt_tmp;

143

}

143

}

144

145

/**

145

/**

146

* batadv_tt_local_hash_find - search the local table for a given client

146

* batadv_tt_local_hash_find - search the local table for a given client

147

* @bat_priv: the bat priv with all the soft interface information

147

* @bat_priv: the bat priv with all the soft interface information

148

* @addr: the mac address of the client to look for

148

* @addr: the mac address of the client to look for

149

* @vid: VLAN identifier

149

* @vid: VLAN identifier

150

*

150

*

151

* Returns a pointer to the corresponding tt_local_entry struct if the client is

151

* Returns a pointer to the corresponding tt_local_entry struct if the client is

152

* found, NULL otherwise.

152

* found, NULL otherwise.

153

*/

153

*/

154

static struct batadv_tt_local_entry *

154

static struct batadv_tt_local_entry *

155

batadv_tt_local_hash_find(struct batadv_priv *bat_priv, const u8 *addr,

155

batadv_tt_local_hash_find(struct batadv_priv *bat_priv, const u8 *addr,

156

unsigned short vid)

156

unsigned short vid)

157

{

157

{

158

struct batadv_tt_common_entry *tt_common_entry;

158

struct batadv_tt_common_entry *tt_common_entry;

159

struct batadv_tt_local_entry *tt_local_entry = NULL;

159

struct batadv_tt_local_entry *tt_local_entry = NULL;

160

161

tt_common_entry = batadv_tt_hash_find(bat_priv->tt.local_hash, addr,

161

tt_common_entry = batadv_tt_hash_find(bat_priv->tt.local_hash, addr,

162

vid);

162

vid);

163

if (tt_common_entry)

163

if (tt_common_entry)

164

tt_local_entry = container_of(tt_common_entry,

164

tt_local_entry = container_of(tt_common_entry,

165

struct batadv_tt_local_entry,

165

struct batadv_tt_local_entry,

166

common);

166

common);

167

return tt_local_entry;

167

return tt_local_entry;

168

}

168

}

169

170

/**

170

/**

171

* batadv_tt_global_hash_find - search the global table for a given client

171

* batadv_tt_global_hash_find - search the global table for a given client

172

* @bat_priv: the bat priv with all the soft interface information

172

* @bat_priv: the bat priv with all the soft interface information

173

* @addr: the mac address of the client to look for

173

* @addr: the mac address of the client to look for

174

* @vid: VLAN identifier

174

* @vid: VLAN identifier

175

*

175

*

176

* Returns a pointer to the corresponding tt_global_entry struct if the client

176

* Returns a pointer to the corresponding tt_global_entry struct if the client

177

* is found, NULL otherwise.

177

* is found, NULL otherwise.

178

*/

178

*/

179

static struct batadv_tt_global_entry *

179

static struct batadv_tt_global_entry *

180

batadv_tt_global_hash_find(struct batadv_priv *bat_priv, const u8 *addr,

180

batadv_tt_global_hash_find(struct batadv_priv *bat_priv, const u8 *addr,

181

unsigned short vid)

181

unsigned short vid)

182

{

182

{

183

struct batadv_tt_common_entry *tt_common_entry;

183

struct batadv_tt_common_entry *tt_common_entry;

184

struct batadv_tt_global_entry *tt_global_entry = NULL;

184

struct batadv_tt_global_entry *tt_global_entry = NULL;

185

186

tt_common_entry = batadv_tt_hash_find(bat_priv->tt.global_hash, addr,

186

tt_common_entry = batadv_tt_hash_find(bat_priv->tt.global_hash, addr,

187

vid);

187

vid);

188

if (tt_common_entry)

188

if (tt_common_entry)

189

tt_global_entry = container_of(tt_common_entry,

189

tt_global_entry = container_of(tt_common_entry,

190

struct batadv_tt_global_entry,

190

struct batadv_tt_global_entry,

191

common);

191

common);

192

return tt_global_entry;

192

return tt_global_entry;

193

}

193

}

194

195

static void

195

static void

196

batadv_tt_local_entry_free_ref(struct batadv_tt_local_entry *tt_local_entry)

196

batadv_tt_local_entry_free_ref(struct batadv_tt_local_entry *tt_local_entry)

197

{

197

{

198

if (atomic_dec_and_test(&tt_local_entry->common.refcount))

198

if (atomic_dec_and_test(&tt_local_entry->common.refcount))

199

kfree_rcu(tt_local_entry, common.rcu);

199

kfree_rcu(tt_local_entry, common.rcu);

200

}

200

}

201

202

/**

202

/**

203

* batadv_tt_global_entry_free_ref - decrement the refcounter for a

203

* batadv_tt_global_entry_free_ref - decrement the refcounter for a

204

* tt_global_entry and possibly free it

204

* tt_global_entry and possibly free it

205

* @tt_global_entry: the object to free

205

* @tt_global_entry: the object to free

206

*/

206

*/

207

static void

207

static void

208

batadv_tt_global_entry_free_ref(struct batadv_tt_global_entry *tt_global_entry)

208

batadv_tt_global_entry_free_ref(struct batadv_tt_global_entry *tt_global_entry)

209

{

209

{

210

if (atomic_dec_and_test(&tt_global_entry->common.refcount)) {

210

if (atomic_dec_and_test(&tt_global_entry->common.refcount)) {

211

batadv_tt_global_del_orig_list(tt_global_entry);

211

batadv_tt_global_del_orig_list(tt_global_entry);

212

kfree_rcu(tt_global_entry, common.rcu);

212

kfree_rcu(tt_global_entry, common.rcu);

213

}

213

}

214

}

214

}

215

216

/**

216

/**

217

* batadv_tt_global_hash_count - count the number of orig entries

217

* batadv_tt_global_hash_count - count the number of orig entries

218

* @hash: hash table containing the tt entries

218

* @hash: hash table containing the tt entries

219

* @addr: the mac address of the client to count entries for

219

* @addr: the mac address of the client to count entries for

220

* @vid: VLAN identifier

220

* @vid: VLAN identifier

221

*

221

*

222

* Return the number of originators advertising the given address/data

222

* Return the number of originators advertising the given address/data

223

* (excluding ourself).

223

* (excluding ourself).

224

*/

224

*/

225

int batadv_tt_global_hash_count(struct batadv_priv *bat_priv,

225

int batadv_tt_global_hash_count(struct batadv_priv *bat_priv,

226

const u8 *addr, unsigned short vid)

226

const u8 *addr, unsigned short vid)

227

{

227

{

228

struct batadv_tt_global_entry *tt_global_entry;

228

struct batadv_tt_global_entry *tt_global_entry;

229

int count;

229

int count;

230

231

tt_global_entry = batadv_tt_global_hash_find(bat_priv, addr, vid);

231

tt_global_entry = batadv_tt_global_hash_find(bat_priv, addr, vid);

232

if (!tt_global_entry)

232

if (!tt_global_entry)

233

return 0;

233

return 0;

234

235

count = atomic_read(&tt_global_entry->orig_list_count);

235

count = atomic_read(&tt_global_entry->orig_list_count);

236

batadv_tt_global_entry_free_ref(tt_global_entry);

236

batadv_tt_global_entry_free_ref(tt_global_entry);

237

238

return count;

238

return count;

239

}

239

}

240

241

static void batadv_tt_orig_list_entry_free_rcu(struct rcu_head *rcu)

241

static void batadv_tt_orig_list_entry_free_rcu(struct rcu_head *rcu)

242

{

242

{

243

struct batadv_tt_orig_list_entry *orig_entry;

243

struct batadv_tt_orig_list_entry *orig_entry;

244

245

orig_entry = container_of(rcu, struct batadv_tt_orig_list_entry, rcu);

245

orig_entry = container_of(rcu, struct batadv_tt_orig_list_entry, rcu);

246

247

/* We are in an rcu callback here, therefore we cannot use

247

/* We are in an rcu callback here, therefore we cannot use

248

* batadv_orig_node_free_ref() and its call_rcu():

248

* batadv_orig_node_free_ref() and its call_rcu():

249

* An rcu_barrier() wouldn't wait for that to finish

249

* An rcu_barrier() wouldn't wait for that to finish

250

*/

250

*/

251

batadv_orig_node_free_ref_now(orig_entry->orig_node);

251

batadv_orig_node_free_ref_now(orig_entry->orig_node);

252

kfree(orig_entry);

252

kfree(orig_entry);

253

}

253

}

254

255

/**

255

/**

256

* batadv_tt_local_size_mod - change the size by v of the local table identified

256

* batadv_tt_local_size_mod - change the size by v of the local table identified

257

* by vid

257

* by vid

258

* @bat_priv: the bat priv with all the soft interface information

258

* @bat_priv: the bat priv with all the soft interface information

259

* @vid: the VLAN identifier of the sub-table to change

259

* @vid: the VLAN identifier of the sub-table to change

260

* @v: the amount to sum to the local table size

260

* @v: the amount to sum to the local table size

261

*/

261

*/

262

static void batadv_tt_local_size_mod(struct batadv_priv *bat_priv,

262

static void batadv_tt_local_size_mod(struct batadv_priv *bat_priv,

263

unsigned short vid, int v)

263

unsigned short vid, int v)

264

{

264

{

265

struct batadv_softif_vlan *vlan;

265

struct batadv_softif_vlan *vlan;

266

267

vlan = batadv_softif_vlan_get(bat_priv, vid);

267

vlan = batadv_softif_vlan_get(bat_priv, vid);

268

if (!vlan)

268

if (!vlan)

269

return;

269

return;

270

271

atomic_add(v, &vlan->tt.num_entries);

271

atomic_add(v, &vlan->tt.num_entries);

272

273

batadv_softif_vlan_free_ref(vlan);

273

batadv_softif_vlan_free_ref(vlan);

274

}

274

}

275

276

/**

276

/**

277

* batadv_tt_local_size_inc - increase by one the local table size for the given

277

* batadv_tt_local_size_inc - increase by one the local table size for the given

278

* vid

278

* vid

279

* @bat_priv: the bat priv with all the soft interface information

279

* @bat_priv: the bat priv with all the soft interface information

280

* @vid: the VLAN identifier

280

* @vid: the VLAN identifier

281

*/

281

*/

282

static void batadv_tt_local_size_inc(struct batadv_priv *bat_priv,

282

static void batadv_tt_local_size_inc(struct batadv_priv *bat_priv,

283

unsigned short vid)

283

unsigned short vid)

284

{

284

{

285

batadv_tt_local_size_mod(bat_priv, vid, 1);

285

batadv_tt_local_size_mod(bat_priv, vid, 1);

286

}

286

}

287

288

/**

288

/**

289

* batadv_tt_local_size_dec - decrease by one the local table size for the given

289

* batadv_tt_local_size_dec - decrease by one the local table size for the given

290

* vid

290

* vid

291

* @bat_priv: the bat priv with all the soft interface information

291

* @bat_priv: the bat priv with all the soft interface information

292

* @vid: the VLAN identifier

292

* @vid: the VLAN identifier

293

*/

293

*/

294

static void batadv_tt_local_size_dec(struct batadv_priv *bat_priv,

294

static void batadv_tt_local_size_dec(struct batadv_priv *bat_priv,

295

unsigned short vid)

295

unsigned short vid)

296

{

296

{

297

batadv_tt_local_size_mod(bat_priv, vid, -1);

297

batadv_tt_local_size_mod(bat_priv, vid, -1);

298

}

298

}

299

300

/**

300

/**

301

* batadv_tt_global_size_mod - change the size by v of the local table

301

* batadv_tt_global_size_mod - change the size by v of the local table

302

* identified by vid

302

* identified by vid

303

* @bat_priv: the bat priv with all the soft interface information

303

* @bat_priv: the bat priv with all the soft interface information

304

* @vid: the VLAN identifier

304

* @vid: the VLAN identifier

305

* @v: the amount to sum to the global table size

305

* @v: the amount to sum to the global table size

306

*/

306

*/

307

static void batadv_tt_global_size_mod(struct batadv_orig_node *orig_node,

307

static void batadv_tt_global_size_mod(struct batadv_orig_node *orig_node,

308

unsigned short vid, int v)

308

unsigned short vid, int v)

309

{

309

{

310

struct batadv_orig_node_vlan *vlan;

310

struct batadv_orig_node_vlan *vlan;

311

312

vlan = batadv_orig_node_vlan_new(orig_node, vid);

312

vlan = batadv_orig_node_vlan_new(orig_node, vid);

313

if (!vlan)

313

if (!vlan)

314

return;

314

return;

315

316

if (atomic_add_return(v, &vlan->tt.num_entries) == 0) {

316

if (atomic_add_return(v, &vlan->tt.num_entries) == 0) {

317

spin_lock_bh(&orig_node->vlan_list_lock);

317

spin_lock_bh(&orig_node->vlan_list_lock);

318

hlist_del_rcu(&vlan->list);

318

hlist_del_init_rcu(&vlan->list);

319

spin_unlock_bh(&orig_node->vlan_list_lock);

319

spin_unlock_bh(&orig_node->vlan_list_lock);

320

batadv_orig_node_vlan_free_ref(vlan);

320

batadv_orig_node_vlan_free_ref(vlan);

321

}

321

}

322

323

batadv_orig_node_vlan_free_ref(vlan);

323

batadv_orig_node_vlan_free_ref(vlan);

324

}

324

}

325

326

/**

326

/**

327

* batadv_tt_global_size_inc - increase by one the global table size for the

327

* batadv_tt_global_size_inc - increase by one the global table size for the

328

* given vid

328

* given vid

329

* @orig_node: the originator which global table size has to be decreased

329

* @orig_node: the originator which global table size has to be decreased

330

* @vid: the vlan identifier

330

* @vid: the vlan identifier

331

*/

331

*/

332

static void batadv_tt_global_size_inc(struct batadv_orig_node *orig_node,

332

static void batadv_tt_global_size_inc(struct batadv_orig_node *orig_node,

333

unsigned short vid)

333

unsigned short vid)

334

{

334

{

335

batadv_tt_global_size_mod(orig_node, vid, 1);

335

batadv_tt_global_size_mod(orig_node, vid, 1);

336

}

336

}

337

338

/**

338

/**

339

* batadv_tt_global_size_dec - decrease by one the global table size for the

339

* batadv_tt_global_size_dec - decrease by one the global table size for the

340

* given vid

340

* given vid

341

* @orig_node: the originator which global table size has to be decreased

341

* @orig_node: the originator which global table size has to be decreased

342

* @vid: the vlan identifier

342

* @vid: the vlan identifier

343

*/

343

*/

344

static void batadv_tt_global_size_dec(struct batadv_orig_node *orig_node,

344

static void batadv_tt_global_size_dec(struct batadv_orig_node *orig_node,

345

unsigned short vid)

345

unsigned short vid)

346

{

346

{

347

batadv_tt_global_size_mod(orig_node, vid, -1);

347

batadv_tt_global_size_mod(orig_node, vid, -1);

348

}

348

}

349

350

static void

350

static void

351

batadv_tt_orig_list_entry_free_ref(struct batadv_tt_orig_list_entry *orig_entry)

351

batadv_tt_orig_list_entry_free_ref(struct batadv_tt_orig_list_entry *orig_entry)

352

{

352

{

353

if (!atomic_dec_and_test(&orig_entry->refcount))

353

if (!atomic_dec_and_test(&orig_entry->refcount))

354

return;

354

return;

355

356

call_rcu(&orig_entry->rcu, batadv_tt_orig_list_entry_free_rcu);

356

call_rcu(&orig_entry->rcu, batadv_tt_orig_list_entry_free_rcu);

357

}

357

}

358

359

/**

359

/**

360

* batadv_tt_local_event - store a local TT event (ADD/DEL)

360

* batadv_tt_local_event - store a local TT event (ADD/DEL)

361

* @bat_priv: the bat priv with all the soft interface information

361

* @bat_priv: the bat priv with all the soft interface information

362

* @tt_local_entry: the TT entry involved in the event

362

* @tt_local_entry: the TT entry involved in the event

363

* @event_flags: flags to store in the event structure

363

* @event_flags: flags to store in the event structure

364

*/

364

*/

365

static void batadv_tt_local_event(struct batadv_priv *bat_priv,

365

static void batadv_tt_local_event(struct batadv_priv *bat_priv,

366

struct batadv_tt_local_entry *tt_local_entry,

366

struct batadv_tt_local_entry *tt_local_entry,

367

u8 event_flags)

367

u8 event_flags)

368

{

368

{

369

struct batadv_tt_change_node *tt_change_node, *entry, *safe;

369

struct batadv_tt_change_node *tt_change_node, *entry, *safe;

370

struct batadv_tt_common_entry *common = &tt_local_entry->common;

370

struct batadv_tt_common_entry *common = &tt_local_entry->common;

371

u8 flags = common->flags | event_flags;

371

u8 flags = common->flags | event_flags;

372

bool event_removed = false;

372

bool event_removed = false;

373

bool del_op_requested, del_op_entry;

373

bool del_op_requested, del_op_entry;

374

375

tt_change_node = kmalloc(sizeof(*tt_change_node), GFP_ATOMIC);

375

tt_change_node = kmalloc(sizeof(*tt_change_node), GFP_ATOMIC);

376

if (!tt_change_node)

376

if (!tt_change_node)

377

return;

377

return;

378

379

tt_change_node->change.flags = flags;

379

tt_change_node->change.flags = flags;

380

memset(tt_change_node->change.reserved, 0,

380

memset(tt_change_node->change.reserved, 0,

381

sizeof(tt_change_node->change.reserved));

381

sizeof(tt_change_node->change.reserved));

382

ether_addr_copy(tt_change_node->change.addr, common->addr);

382

ether_addr_copy(tt_change_node->change.addr, common->addr);

383

tt_change_node->change.vid = htons(common->vid);

383

tt_change_node->change.vid = htons(common->vid);

384

385

del_op_requested = flags & BATADV_TT_CLIENT_DEL;

385

del_op_requested = flags & BATADV_TT_CLIENT_DEL;

386

387

/* check for ADD+DEL or DEL+ADD events */

387

/* check for ADD+DEL or DEL+ADD events */

388

spin_lock_bh(&bat_priv->tt.changes_list_lock);

388

spin_lock_bh(&bat_priv->tt.changes_list_lock);

389

list_for_each_entry_safe(entry, safe, &bat_priv->tt.changes_list,

389

list_for_each_entry_safe(entry, safe, &bat_priv->tt.changes_list,

390

list) {

390

list) {

391

if (!batadv_compare_eth(entry->change.addr, common->addr))

391

if (!batadv_compare_eth(entry->change.addr, common->addr))

392

continue;

392

continue;

393

394

/* DEL+ADD in the same orig interval have no effect and can be

394

/* DEL+ADD in the same orig interval have no effect and can be

395

* removed to avoid silly behaviour on the receiver side. The

395

* removed to avoid silly behaviour on the receiver side. The

396

* other way around (ADD+DEL) can happen in case of roaming of

396

* other way around (ADD+DEL) can happen in case of roaming of

397

* a client still in the NEW state. Roaming of NEW clients is

397

* a client still in the NEW state. Roaming of NEW clients is

398

* now possible due to automatically recognition of "temporary"

398

* now possible due to automatically recognition of "temporary"

399

* clients

399

* clients

400

*/

400

*/

401

del_op_entry = entry->change.flags & BATADV_TT_CLIENT_DEL;

401

del_op_entry = entry->change.flags & BATADV_TT_CLIENT_DEL;

402

if (!del_op_requested && del_op_entry)

402

if (!del_op_requested && del_op_entry)

403

goto del;

403

goto del;

404

if (del_op_requested && !del_op_entry)

404

if (del_op_requested && !del_op_entry)

405

goto del;

405

goto del;

406

407

/* this is a second add in the same originator interval. It

407

/* this is a second add in the same originator interval. It

408

* means that flags have been changed: update them!

408

* means that flags have been changed: update them!

409

*/

409

*/

410

if (!del_op_requested && !del_op_entry)

410

if (!del_op_requested && !del_op_entry)

411

entry->change.flags = flags;

411

entry->change.flags = flags;

412

413

continue;

413

continue;

414

del:

414

del:

415

list_del(&entry->list);

415

list_del(&entry->list);

416

kfree(entry);

416

kfree(entry);

417

kfree(tt_change_node);

417

kfree(tt_change_node);

418

event_removed = true;

418

event_removed = true;

419

goto unlock;

419

goto unlock;

420

}

420

}

421

422

/* track the change in the OGMinterval list */

422

/* track the change in the OGMinterval list */

423

list_add_tail(&tt_change_node->list, &bat_priv->tt.changes_list);

423

list_add_tail(&tt_change_node->list, &bat_priv->tt.changes_list);

424

425

unlock:

425

unlock:

426

spin_unlock_bh(&bat_priv->tt.changes_list_lock);

426

spin_unlock_bh(&bat_priv->tt.changes_list_lock);

427

428

if (event_removed)

428

if (event_removed)

429

atomic_dec(&bat_priv->tt.local_changes);

429

atomic_dec(&bat_priv->tt.local_changes);

430

else

430

else

431

atomic_inc(&bat_priv->tt.local_changes);

431

atomic_inc(&bat_priv->tt.local_changes);

432

}

432

}

433

434

/**

434

/**

435

* batadv_tt_len - compute length in bytes of given number of tt changes

435

* batadv_tt_len - compute length in bytes of given number of tt changes

436

* @changes_num: number of tt changes

436

* @changes_num: number of tt changes

437

*

437

*

438

* Returns computed length in bytes.

438

* Returns computed length in bytes.

439

*/

439

*/

440

static int batadv_tt_len(int changes_num)

440

static int batadv_tt_len(int changes_num)

441

{

441

{

442

return changes_num * sizeof(struct batadv_tvlv_tt_change);

442

return changes_num * sizeof(struct batadv_tvlv_tt_change);

443

}

443

}

444

445

/**

445

/**

446

* batadv_tt_entries - compute the number of entries fitting in tt_len bytes

446

* batadv_tt_entries - compute the number of entries fitting in tt_len bytes

447

* @tt_len: available space

447

* @tt_len: available space

448

*

448

*

449

* Returns the number of entries.

449

* Returns the number of entries.

450

*/

450

*/

451

static u16 batadv_tt_entries(u16 tt_len)

451

static u16 batadv_tt_entries(u16 tt_len)

452

{

452

{

453

return tt_len / batadv_tt_len(1);

453

return tt_len / batadv_tt_len(1);

454

}

454

}

455

456

/**

456

/**

457

* batadv_tt_local_table_transmit_size - calculates the local translation table

457

* batadv_tt_local_table_transmit_size - calculates the local translation table

458

* size when transmitted over the air

458

* size when transmitted over the air

459

* @bat_priv: the bat priv with all the soft interface information

459

* @bat_priv: the bat priv with all the soft interface information

460

*

460

*

461

* Returns local translation table size in bytes.

461

* Returns local translation table size in bytes.

462

*/

462

*/

463

static int batadv_tt_local_table_transmit_size(struct batadv_priv *bat_priv)

463

static int batadv_tt_local_table_transmit_size(struct batadv_priv *bat_priv)

464

{

464

{

465

u16 num_vlan = 0;

465

u16 num_vlan = 0;

466

u16 tt_local_entries = 0;

466

u16 tt_local_entries = 0;

467

struct batadv_softif_vlan *vlan;

467

struct batadv_softif_vlan *vlan;

468

int hdr_size;

468

int hdr_size;

469

470

rcu_read_lock();

470

rcu_read_lock();

471

hlist_for_each_entry_rcu(vlan, &bat_priv->softif_vlan_list, list) {

471

hlist_for_each_entry_rcu(vlan, &bat_priv->softif_vlan_list, list) {

472

num_vlan++;

472

num_vlan++;

473

tt_local_entries += atomic_read(&vlan->tt.num_entries);

473

tt_local_entries += atomic_read(&vlan->tt.num_entries);

474

}

474

}

475

rcu_read_unlock();

475

rcu_read_unlock();

476

477

/* header size of tvlv encapsulated tt response payload */

477

/* header size of tvlv encapsulated tt response payload */

478

hdr_size = sizeof(struct batadv_unicast_tvlv_packet);

478

hdr_size = sizeof(struct batadv_unicast_tvlv_packet);

479

hdr_size += sizeof(struct batadv_tvlv_hdr);

479

hdr_size += sizeof(struct batadv_tvlv_hdr);

480

hdr_size += sizeof(struct batadv_tvlv_tt_data);

480

hdr_size += sizeof(struct batadv_tvlv_tt_data);

481

hdr_size += num_vlan * sizeof(struct batadv_tvlv_tt_vlan_data);

481

hdr_size += num_vlan * sizeof(struct batadv_tvlv_tt_vlan_data);

482

483

return hdr_size + batadv_tt_len(tt_local_entries);

483

return hdr_size + batadv_tt_len(tt_local_entries);

484

}

484

}

485

486

static int batadv_tt_local_init(struct batadv_priv *bat_priv)

486

static int batadv_tt_local_init(struct batadv_priv *bat_priv)

487

{

487

{

488

if (bat_priv->tt.local_hash)

488

if (bat_priv->tt.local_hash)

489

return 0;

489

return 0;

490

491

bat_priv->tt.local_hash = batadv_hash_new(1024);

491

bat_priv->tt.local_hash = batadv_hash_new(1024);

492

493

if (!bat_priv->tt.local_hash)

493

if (!bat_priv->tt.local_hash)

494

return -ENOMEM;

494

return -ENOMEM;

495

496

batadv_hash_set_lock_class(bat_priv->tt.local_hash,

496

batadv_hash_set_lock_class(bat_priv->tt.local_hash,

497

&batadv_tt_local_hash_lock_class_key);

497

&batadv_tt_local_hash_lock_class_key);

498

499

return 0;

499

return 0;

500

}

500

}

501

502

static void batadv_tt_global_free(struct batadv_priv *bat_priv,

502

static void batadv_tt_global_free(struct batadv_priv *bat_priv,

503

struct batadv_tt_global_entry *tt_global,

503

struct batadv_tt_global_entry *tt_global,

504

const char *message)

504

const char *message)

505

{

505

{

506

batadv_dbg(BATADV_DBG_TT, bat_priv,

506

batadv_dbg(BATADV_DBG_TT, bat_priv,

507

"Deleting global tt entry %pM (vid: %d): %s\n",

507

"Deleting global tt entry %pM (vid: %d): %s\n",

508

tt_global->common.addr,

508

tt_global->common.addr,

509

BATADV_PRINT_VID(tt_global->common.vid), message);

509

BATADV_PRINT_VID(tt_global->common.vid), message);

510

511

batadv_hash_remove(bat_priv->tt.global_hash, batadv_compare_tt,

511

batadv_hash_remove(bat_priv->tt.global_hash, batadv_compare_tt,

512

batadv_choose_tt, &tt_global->common);

512

batadv_choose_tt, &tt_global->common);

513

batadv_tt_global_entry_free_ref(tt_global);

513

batadv_tt_global_entry_free_ref(tt_global);

514

}

514

}

515

516

/**

516

/**

517

* batadv_tt_local_add - add a new client to the local table or update an

517

* batadv_tt_local_add - add a new client to the local table or update an

518

* existing client

518

* existing client

519

* @soft_iface: netdev struct of the mesh interface

519

* @soft_iface: netdev struct of the mesh interface

520

* @addr: the mac address of the client to add

520

* @addr: the mac address of the client to add

521

* @vid: VLAN identifier

521

* @vid: VLAN identifier

522

* @ifindex: index of the interface where the client is connected to (useful to

522

* @ifindex: index of the interface where the client is connected to (useful to

523

* identify wireless clients)

523

* identify wireless clients)

524

* @mark: the value contained in the skb->mark field of the received packet (if

524

* @mark: the value contained in the skb->mark field of the received packet (if

525

* any)

525

* any)

526

*

526

*

527

* Returns true if the client was successfully added, false otherwise.

527

* Returns true if the client was successfully added, false otherwise.

528

*/

528

*/

529

bool batadv_tt_local_add(struct net_device *soft_iface, const u8 *addr,

529

bool batadv_tt_local_add(struct net_device *soft_iface, const u8 *addr,

530

unsigned short vid, int ifindex, u32 mark)

530

unsigned short vid, int ifindex, u32 mark)

531

{

531

{

532

struct batadv_priv *bat_priv = netdev_priv(soft_iface);

532

struct batadv_priv *bat_priv = netdev_priv(soft_iface);

533

struct batadv_tt_local_entry *tt_local;

533

struct batadv_tt_local_entry *tt_local;

534

struct batadv_tt_global_entry *tt_global = NULL;

534

struct batadv_tt_global_entry *tt_global = NULL;

535

struct batadv_softif_vlan *vlan;

535

struct batadv_softif_vlan *vlan;

536

struct net_device *in_dev = NULL;

536

struct net_device *in_dev = NULL;

537

struct hlist_head *head;

537

struct hlist_head *head;

538

struct batadv_tt_orig_list_entry *orig_entry;

538

struct batadv_tt_orig_list_entry *orig_entry;

539

int hash_added, table_size, packet_size_max;

539

int hash_added, table_size, packet_size_max;

540

bool ret = false;

540

bool ret = false;

541

bool roamed_back = false;

541

bool roamed_back = false;

542

u8 remote_flags;

542

u8 remote_flags;

543

u32 match_mark;

543

u32 match_mark;

544

545

if (ifindex != BATADV_NULL_IFINDEX)

545

if (ifindex != BATADV_NULL_IFINDEX)

546

in_dev = dev_get_by_index(&init_net, ifindex);

546

in_dev = dev_get_by_index(&init_net, ifindex);

547

548

tt_local = batadv_tt_local_hash_find(bat_priv, addr, vid);

548

tt_local = batadv_tt_local_hash_find(bat_priv, addr, vid);

549

550

if (!is_multicast_ether_addr(addr))

550

if (!is_multicast_ether_addr(addr))

551

tt_global = batadv_tt_global_hash_find(bat_priv, addr, vid);

551

tt_global = batadv_tt_global_hash_find(bat_priv, addr, vid);

552

553

if (tt_local) {

553

if (tt_local) {

554

tt_local->last_seen = jiffies;

554

tt_local->last_seen = jiffies;

555

if (tt_local->common.flags & BATADV_TT_CLIENT_PENDING) {

555

if (tt_local->common.flags & BATADV_TT_CLIENT_PENDING) {

556

batadv_dbg(BATADV_DBG_TT, bat_priv,

556

batadv_dbg(BATADV_DBG_TT, bat_priv,

557

"Re-adding pending client %pM (vid: %d)\n",

557

"Re-adding pending client %pM (vid: %d)\n",

558

addr, BATADV_PRINT_VID(vid));

558

addr, BATADV_PRINT_VID(vid));

559

/* whatever the reason why the PENDING flag was set,

559

/* whatever the reason why the PENDING flag was set,

560

* this is a client which was enqueued to be removed in

560

* this is a client which was enqueued to be removed in

561

* this orig_interval. Since it popped up again, the

561

* this orig_interval. Since it popped up again, the

562

* flag can be reset like it was never enqueued

562

* flag can be reset like it was never enqueued

563

*/

563

*/

564

tt_local->common.flags &= ~BATADV_TT_CLIENT_PENDING;

564

tt_local->common.flags &= ~BATADV_TT_CLIENT_PENDING;

565

goto add_event;

565

goto add_event;

566

}

566

}

567

568

if (tt_local->common.flags & BATADV_TT_CLIENT_ROAM) {

568

if (tt_local->common.flags & BATADV_TT_CLIENT_ROAM) {

569

batadv_dbg(BATADV_DBG_TT, bat_priv,

569

batadv_dbg(BATADV_DBG_TT, bat_priv,

570

"Roaming client %pM (vid: %d) came back to its original location\n",

570

"Roaming client %pM (vid: %d) came back to its original location\n",

571

addr, BATADV_PRINT_VID(vid));

571

addr, BATADV_PRINT_VID(vid));

572

/* the ROAM flag is set because this client roamed away

572

/* the ROAM flag is set because this client roamed away

573

* and the node got a roaming_advertisement message. Now

573

* and the node got a roaming_advertisement message. Now

574

* that the client popped up again at its original

574

* that the client popped up again at its original

575

* location such flag can be unset

575

* location such flag can be unset

576

*/

576

*/

577

tt_local->common.flags &= ~BATADV_TT_CLIENT_ROAM;

577

tt_local->common.flags &= ~BATADV_TT_CLIENT_ROAM;

578

roamed_back = true;

578

roamed_back = true;

579

}

579

}

580

goto check_roaming;

580

goto check_roaming;

581

}

581

}

582

583

/* Ignore the client if we cannot send it in a full table response. */

583

/* Ignore the client if we cannot send it in a full table response. */

584

table_size = batadv_tt_local_table_transmit_size(bat_priv);

584

table_size = batadv_tt_local_table_transmit_size(bat_priv);

585

table_size += batadv_tt_len(1);

585

table_size += batadv_tt_len(1);

586

packet_size_max = atomic_read(&bat_priv->packet_size_max);

586

packet_size_max = atomic_read(&bat_priv->packet_size_max);

587

if (table_size > packet_size_max) {

587

if (table_size > packet_size_max) {

588

net_ratelimited_function(batadv_info, soft_iface,

588

net_ratelimited_function(batadv_info, soft_iface,

589

"Local translation table size (%i) exceeds maximum packet size (%i); Ignoring new local tt entry: %pM\n",

589

"Local translation table size (%i) exceeds maximum packet size (%i); Ignoring new local tt entry: %pM\n",

590

table_size, packet_size_max, addr);

590

table_size, packet_size_max, addr);

591

goto out;

591

goto out;

592

}

592

}

593

594

tt_local = kmalloc(sizeof(*tt_local), GFP_ATOMIC);

594

tt_local = kmalloc(sizeof(*tt_local), GFP_ATOMIC);

595

if (!tt_local)

595

if (!tt_local)

596

goto out;

596

goto out;

597

598

/* increase the refcounter of the related vlan */

598

/* increase the refcounter of the related vlan */

599

vlan = batadv_softif_vlan_get(bat_priv, vid);

599

vlan = batadv_softif_vlan_get(bat_priv, vid);

600

if (WARN(!vlan, "adding TT local entry %pM to non-existent VLAN %d",

600

if (WARN(!vlan, "adding TT local entry %pM to non-existent VLAN %d",

601

addr, BATADV_PRINT_VID(vid))) {

601

addr, BATADV_PRINT_VID(vid))) {

602

kfree(tt_local);

602

kfree(tt_local);

603

tt_local = NULL;

603

tt_local = NULL;

604

goto out;

604

goto out;

605

}

605

}

606

607

batadv_dbg(BATADV_DBG_TT, bat_priv,

607

batadv_dbg(BATADV_DBG_TT, bat_priv,

608

"Creating new local tt entry: %pM (vid: %d, ttvn: %d)\n",

608

"Creating new local tt entry: %pM (vid: %d, ttvn: %d)\n",

609

addr, BATADV_PRINT_VID(vid),

609

addr, BATADV_PRINT_VID(vid),

610

(u8)atomic_read(&bat_priv->tt.vn));

610

(u8)atomic_read(&bat_priv->tt.vn));

611

612

ether_addr_copy(tt_local->common.addr, addr);

612

ether_addr_copy(tt_local->common.addr, addr);

613

/* The local entry has to be marked as NEW to avoid to send it in

613

/* The local entry has to be marked as NEW to avoid to send it in

614

* a full table response going out before the next ttvn increment

614

* a full table response going out before the next ttvn increment

615

* (consistency check)

615

* (consistency check)

616

*/

616

*/

617

tt_local->common.flags = BATADV_TT_CLIENT_NEW;

617

tt_local->common.flags = BATADV_TT_CLIENT_NEW;

618

tt_local->common.vid = vid;

618

tt_local->common.vid = vid;

619

if (batadv_is_wifi_netdev(in_dev))

619

if (batadv_is_wifi_netdev(in_dev))

620

tt_local->common.flags |= BATADV_TT_CLIENT_WIFI;

620

tt_local->common.flags |= BATADV_TT_CLIENT_WIFI;

621

atomic_set(&tt_local->common.refcount, 2);

621

atomic_set(&tt_local->common.refcount, 2);

622

tt_local->last_seen = jiffies;

622

tt_local->last_seen = jiffies;

623

tt_local->common.added_at = tt_local->last_seen;

623

tt_local->common.added_at = tt_local->last_seen;

624

625

/* the batman interface mac and multicast addresses should never be

625

/* the batman interface mac and multicast addresses should never be

626

* purged

626

* purged

627

*/

627

*/

628

if (batadv_compare_eth(addr, soft_iface->dev_addr) ||

628

if (batadv_compare_eth(addr, soft_iface->dev_addr) ||

629

is_multicast_ether_addr(addr))

629

is_multicast_ether_addr(addr))

630

tt_local->common.flags |= BATADV_TT_CLIENT_NOPURGE;

630

tt_local->common.flags |= BATADV_TT_CLIENT_NOPURGE;

631

632

hash_added = batadv_hash_add(bat_priv->tt.local_hash, batadv_compare_tt,

632

hash_added = batadv_hash_add(bat_priv->tt.local_hash, batadv_compare_tt,

633

batadv_choose_tt, &tt_local->common,

633

batadv_choose_tt, &tt_local->common,

634

&tt_local->common.hash_entry);

634

&tt_local->common.hash_entry);

635

636

if (unlikely(hash_added != 0)) {

636

if (unlikely(hash_added != 0)) {

637

/* remove the reference for the hash */

637

/* remove the reference for the hash */

638

batadv_tt_local_entry_free_ref(tt_local);

638

batadv_tt_local_entry_free_ref(tt_local);

639

batadv_softif_vlan_free_ref(vlan);

639

batadv_softif_vlan_free_ref(vlan);

640

goto out;

640

goto out;

641

}

641

}

642

643

add_event:

643

add_event:

644

batadv_tt_local_event(bat_priv, tt_local, BATADV_NO_FLAGS);

644

batadv_tt_local_event(bat_priv, tt_local, BATADV_NO_FLAGS);

645

646

check_roaming:

646

check_roaming:

647

/* Check whether it is a roaming, but don't do anything if the roaming

647

/* Check whether it is a roaming, but don't do anything if the roaming

648

* process has already been handled

648

* process has already been handled

649

*/

649

*/

650

if (tt_global && !(tt_global->common.flags & BATADV_TT_CLIENT_ROAM)) {

650

if (tt_global && !(tt_global->common.flags & BATADV_TT_CLIENT_ROAM)) {

651

/* These node are probably going to update their tt table */

651

/* These node are probably going to update their tt table */

652

head = &tt_global->orig_list;

652

head = &tt_global->orig_list;

653

rcu_read_lock();

653

rcu_read_lock();

654

hlist_for_each_entry_rcu(orig_entry, head, list) {

654

hlist_for_each_entry_rcu(orig_entry, head, list) {

655

batadv_send_roam_adv(bat_priv, tt_global->common.addr,

655

batadv_send_roam_adv(bat_priv, tt_global->common.addr,

656

tt_global->common.vid,

656

tt_global->common.vid,

657

orig_entry->orig_node);

657

orig_entry->orig_node);

658

}

658

}

659

rcu_read_unlock();

659

rcu_read_unlock();

660

if (roamed_back) {

660

if (roamed_back) {

661

batadv_tt_global_free(bat_priv, tt_global,

661

batadv_tt_global_free(bat_priv, tt_global,

662

"Roaming canceled");

662

"Roaming canceled");

663

tt_global = NULL;

663

tt_global = NULL;

664

} else {

664

} else {

665

/* The global entry has to be marked as ROAMING and

665

/* The global entry has to be marked as ROAMING and

666

* has to be kept for consistency purpose

666

* has to be kept for consistency purpose

667

*/

667

*/

668

tt_global->common.flags |= BATADV_TT_CLIENT_ROAM;

668

tt_global->common.flags |= BATADV_TT_CLIENT_ROAM;

669

tt_global->roam_at = jiffies;

669

tt_global->roam_at = jiffies;

670

}

670

}

671

}

671

}

672

673

/* store the current remote flags before altering them. This helps

673

/* store the current remote flags before altering them. This helps

674

* understanding is flags are changing or not

674

* understanding is flags are changing or not

675

*/

675

*/

676

remote_flags = tt_local->common.flags & BATADV_TT_REMOTE_MASK;

676

remote_flags = tt_local->common.flags & BATADV_TT_REMOTE_MASK;

677

678

if (batadv_is_wifi_netdev(in_dev))

678

if (batadv_is_wifi_netdev(in_dev))

679

tt_local->common.flags |= BATADV_TT_CLIENT_WIFI;

679

tt_local->common.flags |= BATADV_TT_CLIENT_WIFI;

680

else

680

else

681

tt_local->common.flags &= ~BATADV_TT_CLIENT_WIFI;

681

tt_local->common.flags &= ~BATADV_TT_CLIENT_WIFI;

682

683

/* check the mark in the skb: if it's equal to the configured

683

/* check the mark in the skb: if it's equal to the configured

684

* isolation_mark, it means the packet is coming from an isolated

684

* isolation_mark, it means the packet is coming from an isolated

685

* non-mesh client

685

* non-mesh client

686

*/

686

*/

687

match_mark = (mark & bat_priv->isolation_mark_mask);

687

match_mark = (mark & bat_priv->isolation_mark_mask);

688

if (bat_priv->isolation_mark_mask &&

688

if (bat_priv->isolation_mark_mask &&

689

match_mark == bat_priv->isolation_mark)

689

match_mark == bat_priv->isolation_mark)

690

tt_local->common.flags |= BATADV_TT_CLIENT_ISOLA;

690

tt_local->common.flags |= BATADV_TT_CLIENT_ISOLA;

691

else

691

else

692

tt_local->common.flags &= ~BATADV_TT_CLIENT_ISOLA;

692

tt_local->common.flags &= ~BATADV_TT_CLIENT_ISOLA;

693

694

/* if any "dynamic" flag has been modified, resend an ADD event for this

694

/* if any "dynamic" flag has been modified, resend an ADD event for this

695

* entry so that all the nodes can get the new flags

695

* entry so that all the nodes can get the new flags

696

*/

696

*/

697

if (remote_flags ^ (tt_local->common.flags & BATADV_TT_REMOTE_MASK))

697

if (remote_flags ^ (tt_local->common.flags & BATADV_TT_REMOTE_MASK))

698

batadv_tt_local_event(bat_priv, tt_local, BATADV_NO_FLAGS);

698

batadv_tt_local_event(bat_priv, tt_local, BATADV_NO_FLAGS);

699

700

ret = true;

700

ret = true;

701

out:

701

out:

702

if (in_dev)

702

if (in_dev)

703

dev_put(in_dev);

703

dev_put(in_dev);

704

if (tt_local)

704

if (tt_local)

705

batadv_tt_local_entry_free_ref(tt_local);

705

batadv_tt_local_entry_free_ref(tt_local);

706

if (tt_global)

706

if (tt_global)

707

batadv_tt_global_entry_free_ref(tt_global);

707

batadv_tt_global_entry_free_ref(tt_global);

708

return ret;

708

return ret;

709

}

709

}

710

711

/**

711

/**

712

* batadv_tt_prepare_tvlv_global_data - prepare the TVLV TT header to send

712

* batadv_tt_prepare_tvlv_global_data - prepare the TVLV TT header to send

713

* within a TT Response directed to another node

713

* within a TT Response directed to another node

714

* @orig_node: originator for which the TT data has to be prepared

714

* @orig_node: originator for which the TT data has to be prepared

715

* @tt_data: uninitialised pointer to the address of the TVLV buffer

715

* @tt_data: uninitialised pointer to the address of the TVLV buffer

716

* @tt_change: uninitialised pointer to the address of the area where the TT

716

* @tt_change: uninitialised pointer to the address of the area where the TT

717

* changed can be stored

717

* changed can be stored

718

* @tt_len: pointer to the length to reserve to the tt_change. if -1 this

718

* @tt_len: pointer to the length to reserve to the tt_change. if -1 this

719

* function reserves the amount of space needed to send the entire global TT

719

* function reserves the amount of space needed to send the entire global TT

720

* table. In case of success the value is updated with the real amount of

720

* table. In case of success the value is updated with the real amount of

721

* reserved bytes

721

* reserved bytes

722

723

* Allocate the needed amount of memory for the entire TT TVLV and write its

723

* Allocate the needed amount of memory for the entire TT TVLV and write its

724

* header made up by one tvlv_tt_data object and a series of tvlv_tt_vlan_data

724

* header made up by one tvlv_tt_data object and a series of tvlv_tt_vlan_data

725

* objects, one per active VLAN served by the originator node.

725

* objects, one per active VLAN served by the originator node.

726

*

726

*

727

* Return the size of the allocated buffer or 0 in case of failure.

727

* Return the size of the allocated buffer or 0 in case of failure.

728

*/

728

*/

729

static u16

729

static u16

730

batadv_tt_prepare_tvlv_global_data(struct batadv_orig_node *orig_node,

730

batadv_tt_prepare_tvlv_global_data(struct batadv_orig_node *orig_node,

731

struct batadv_tvlv_tt_data **tt_data,

731

struct batadv_tvlv_tt_data **tt_data,

732

struct batadv_tvlv_tt_change **tt_change,

732

struct batadv_tvlv_tt_change **tt_change,

733

s32 *tt_len)

733

s32 *tt_len)

734

{

734

{

735

u16 num_vlan = 0;

735

u16 num_vlan = 0;

736

u16 num_entries = 0;

736

u16 num_entries = 0;

737

u16 change_offset;

737

u16 change_offset;

738

u16 tvlv_len;

738

u16 tvlv_len;

739

struct batadv_tvlv_tt_vlan_data *tt_vlan;

739

struct batadv_tvlv_tt_vlan_data *tt_vlan;

740

struct batadv_orig_node_vlan *vlan;

740

struct batadv_orig_node_vlan *vlan;

741

u8 *tt_change_ptr;

741

u8 *tt_change_ptr;

742

743

rcu_read_lock();

743

rcu_read_lock();

744

hlist_for_each_entry_rcu(vlan, &orig_node->vlan_list, list) {

744

hlist_for_each_entry_rcu(vlan, &orig_node->vlan_list, list) {

745

num_vlan++;

745

num_vlan++;

746

num_entries += atomic_read(&vlan->tt.num_entries);

746

num_entries += atomic_read(&vlan->tt.num_entries);

747

}

747

}

748

749

change_offset = sizeof(**tt_data);

749

change_offset = sizeof(**tt_data);

750

change_offset += num_vlan * sizeof(*tt_vlan);

750

change_offset += num_vlan * sizeof(*tt_vlan);

751

752

/* if tt_len is negative, allocate the space needed by the full table */

752

/* if tt_len is negative, allocate the space needed by the full table */

753

if (*tt_len < 0)

753

if (*tt_len < 0)

754

*tt_len = batadv_tt_len(num_entries);

754

*tt_len = batadv_tt_len(num_entries);

755

756

tvlv_len = *tt_len;

756

tvlv_len = *tt_len;

757

tvlv_len += change_offset;

757

tvlv_len += change_offset;

758

759

*tt_data = kmalloc(tvlv_len, GFP_ATOMIC);

759

*tt_data = kmalloc(tvlv_len, GFP_ATOMIC);

760

if (!*tt_data) {

760

if (!*tt_data) {

761

*tt_len = 0;

761

*tt_len = 0;

762

goto out;

762

goto out;

763

}

763

}

764

765

(*tt_data)->flags = BATADV_NO_FLAGS;

765

(*tt_data)->flags = BATADV_NO_FLAGS;

766

(*tt_data)->ttvn = atomic_read(&orig_node->last_ttvn);

766

(*tt_data)->ttvn = atomic_read(&orig_node->last_ttvn);

767

(*tt_data)->num_vlan = htons(num_vlan);

767

(*tt_data)->num_vlan = htons(num_vlan);

768

769

tt_vlan = (struct batadv_tvlv_tt_vlan_data *)(*tt_data + 1);

769

tt_vlan = (struct batadv_tvlv_tt_vlan_data *)(*tt_data + 1);

770

hlist_for_each_entry_rcu(vlan, &orig_node->vlan_list, list) {

770

hlist_for_each_entry_rcu(vlan, &orig_node->vlan_list, list) {

771

tt_vlan->vid = htons(vlan->vid);

771

tt_vlan->vid = htons(vlan->vid);

772

tt_vlan->crc = htonl(vlan->tt.crc);

772

tt_vlan->crc = htonl(vlan->tt.crc);

773

774

tt_vlan++;

774

tt_vlan++;

775

}

775

}

776

777

tt_change_ptr = (u8 *)*tt_data + change_offset;

777

tt_change_ptr = (u8 *)*tt_data + change_offset;

778

*tt_change = (struct batadv_tvlv_tt_change *)tt_change_ptr;

778

*tt_change = (struct batadv_tvlv_tt_change *)tt_change_ptr;

779

780

out:

780

out:

781

rcu_read_unlock();

781

rcu_read_unlock();

782

return tvlv_len;

782

return tvlv_len;

783

}

783

}

784

785

/**

785

/**

786

* batadv_tt_prepare_tvlv_local_data - allocate and prepare the TT TVLV for this

786

* batadv_tt_prepare_tvlv_local_data - allocate and prepare the TT TVLV for this

787

* node

787

* node

788

* @bat_priv: the bat priv with all the soft interface information

788

* @bat_priv: the bat priv with all the soft interface information

789

* @tt_data: uninitialised pointer to the address of the TVLV buffer

789

* @tt_data: uninitialised pointer to the address of the TVLV buffer

790

* @tt_change: uninitialised pointer to the address of the area where the TT

790

* @tt_change: uninitialised pointer to the address of the area where the TT

791

* changes can be stored

791

* changes can be stored

792

* @tt_len: pointer to the length to reserve to the tt_change. if -1 this

792

* @tt_len: pointer to the length to reserve to the tt_change. if -1 this

793

* function reserves the amount of space needed to send the entire local TT

793

* function reserves the amount of space needed to send the entire local TT

794

* table. In case of success the value is updated with the real amount of

794

* table. In case of success the value is updated with the real amount of

795

* reserved bytes

795

* reserved bytes

796

*

796

*

797

* Allocate the needed amount of memory for the entire TT TVLV and write its

797

* Allocate the needed amount of memory for the entire TT TVLV and write its

798

* header made up by one tvlv_tt_data object and a series of tvlv_tt_vlan_data

798

* header made up by one tvlv_tt_data object and a series of tvlv_tt_vlan_data

799

* objects, one per active VLAN.

799

* objects, one per active VLAN.

800

*

800

*

801

* Return the size of the allocated buffer or 0 in case of failure.

801

* Return the size of the allocated buffer or 0 in case of failure.

802

*/

802

*/

803

static u16

803

static u16

804

batadv_tt_prepare_tvlv_local_data(struct batadv_priv *bat_priv,

804

batadv_tt_prepare_tvlv_local_data(struct batadv_priv *bat_priv,

805

struct batadv_tvlv_tt_data **tt_data,

805

struct batadv_tvlv_tt_data **tt_data,

806

struct batadv_tvlv_tt_change **tt_change,

806

struct batadv_tvlv_tt_change **tt_change,

807

s32 *tt_len)

807

s32 *tt_len)

808

{

808

{

809

struct batadv_tvlv_tt_vlan_data *tt_vlan;

809

struct batadv_tvlv_tt_vlan_data *tt_vlan;

810

struct batadv_softif_vlan *vlan;

810

struct batadv_softif_vlan *vlan;

811

u16 num_vlan = 0;

811

u16 num_vlan = 0;

812

u16 num_entries = 0;

812

u16 num_entries = 0;

813

u16 tvlv_len;

813

u16 tvlv_len;

814

u8 *tt_change_ptr;

814

u8 *tt_change_ptr;

815

int change_offset;

815

int change_offset;

816

817

rcu_read_lock();

817

rcu_read_lock();

818

hlist_for_each_entry_rcu(vlan, &bat_priv->softif_vlan_list, list) {

818

hlist_for_each_entry_rcu(vlan, &bat_priv->softif_vlan_list, list) {

819

num_vlan++;

819

num_vlan++;

820

num_entries += atomic_read(&vlan->tt.num_entries);

820

num_entries += atomic_read(&vlan->tt.num_entries);

821

}

821

}

822

823

change_offset = sizeof(**tt_data);

823

change_offset = sizeof(**tt_data);

824

change_offset += num_vlan * sizeof(*tt_vlan);

824

change_offset += num_vlan * sizeof(*tt_vlan);

825

826

/* if tt_len is negative, allocate the space needed by the full table */

826

/* if tt_len is negative, allocate the space needed by the full table */

827

if (*tt_len < 0)

827

if (*tt_len < 0)

828

*tt_len = batadv_tt_len(num_entries);

828

*tt_len = batadv_tt_len(num_entries);

829

830

tvlv_len = *tt_len;

830

tvlv_len = *tt_len;

831

tvlv_len += change_offset;

831

tvlv_len += change_offset;

832

833

*tt_data = kmalloc(tvlv_len, GFP_ATOMIC);

833

*tt_data = kmalloc(tvlv_len, GFP_ATOMIC);

834

if (!*tt_data) {

834

if (!*tt_data) {

835

tvlv_len = 0;

835

tvlv_len = 0;

836

goto out;

836

goto out;

837

}

837

}

838

839

(*tt_data)->flags = BATADV_NO_FLAGS;

839

(*tt_data)->flags = BATADV_NO_FLAGS;

840

(*tt_data)->ttvn = atomic_read(&bat_priv->tt.vn);

840

(*tt_data)->ttvn = atomic_read(&bat_priv->tt.vn);

841

(*tt_data)->num_vlan = htons(num_vlan);

841

(*tt_data)->num_vlan = htons(num_vlan);

842

843

tt_vlan = (struct batadv_tvlv_tt_vlan_data *)(*tt_data + 1);

843

tt_vlan = (struct batadv_tvlv_tt_vlan_data *)(*tt_data + 1);

844

hlist_for_each_entry_rcu(vlan, &bat_priv->softif_vlan_list, list) {

844

hlist_for_each_entry_rcu(vlan, &bat_priv->softif_vlan_list, list) {

845

tt_vlan->vid = htons(vlan->vid);

845

tt_vlan->vid = htons(vlan->vid);

846

tt_vlan->crc = htonl(vlan->tt.crc);

846

tt_vlan->crc = htonl(vlan->tt.crc);

847

848

tt_vlan++;

848

tt_vlan++;

849

}

849

}

850

851

tt_change_ptr = (u8 *)*tt_data + change_offset;

851

tt_change_ptr = (u8 *)*tt_data + change_offset;

852

*tt_change = (struct batadv_tvlv_tt_change *)tt_change_ptr;

852

*tt_change = (struct batadv_tvlv_tt_change *)tt_change_ptr;

853

854

out:

854

out:

855

rcu_read_unlock();

855

rcu_read_unlock();

856

return tvlv_len;

856

return tvlv_len;

857

}

857

}

858

859

/**

859

/**

860

* batadv_tt_tvlv_container_update - update the translation table tvlv container

860

* batadv_tt_tvlv_container_update - update the translation table tvlv container

861

* after local tt changes have been committed

861

* after local tt changes have been committed

862

* @bat_priv: the bat priv with all the soft interface information

862

* @bat_priv: the bat priv with all the soft interface information

863

*/

863

*/

864

static void batadv_tt_tvlv_container_update(struct batadv_priv *bat_priv)

864

static void batadv_tt_tvlv_container_update(struct batadv_priv *bat_priv)

865

{

865

{

866

struct batadv_tt_change_node *entry, *safe;

866

struct batadv_tt_change_node *entry, *safe;

867

struct batadv_tvlv_tt_data *tt_data;

867

struct batadv_tvlv_tt_data *tt_data;

868

struct batadv_tvlv_tt_change *tt_change;

868

struct batadv_tvlv_tt_change *tt_change;

869

int tt_diff_len, tt_change_len = 0;

869

int tt_diff_len, tt_change_len = 0;

870

int tt_diff_entries_num = 0;

870

int tt_diff_entries_num = 0;

871

int tt_diff_entries_count = 0;

871

int tt_diff_entries_count = 0;

872

u16 tvlv_len;

872

u16 tvlv_len;

873

874

tt_diff_entries_num = atomic_read(&bat_priv->tt.local_changes);

874

tt_diff_entries_num = atomic_read(&bat_priv->tt.local_changes);

875

tt_diff_len = batadv_tt_len(tt_diff_entries_num);

875

tt_diff_len = batadv_tt_len(tt_diff_entries_num);

876

877

/* if we have too many changes for one packet don't send any

877

/* if we have too many changes for one packet don't send any

878

* and wait for the tt table request which will be fragmented

878

* and wait for the tt table request which will be fragmented

879

*/

879

*/

880

if (tt_diff_len > bat_priv->soft_iface->mtu)

880

if (tt_diff_len > bat_priv->soft_iface->mtu)

881

tt_diff_len = 0;

881

tt_diff_len = 0;

882

883

tvlv_len = batadv_tt_prepare_tvlv_local_data(bat_priv, &tt_data,

883

tvlv_len = batadv_tt_prepare_tvlv_local_data(bat_priv, &tt_data,

884

&tt_change, &tt_diff_len);

884

&tt_change, &tt_diff_len);

885

if (!tvlv_len)

885

if (!tvlv_len)

886

return;

886

return;

887

888

tt_data->flags = BATADV_TT_OGM_DIFF;

888

tt_data->flags = BATADV_TT_OGM_DIFF;

889

890

if (tt_diff_len == 0)

890

if (tt_diff_len == 0)

891

goto container_register;

891

goto container_register;

892

893

spin_lock_bh(&bat_priv->tt.changes_list_lock);

893

spin_lock_bh(&bat_priv->tt.changes_list_lock);

894

atomic_set(&bat_priv->tt.local_changes, 0);

894

atomic_set(&bat_priv->tt.local_changes, 0);

895

896

list_for_each_entry_safe(entry, safe, &bat_priv->tt.changes_list,

896

list_for_each_entry_safe(entry, safe, &bat_priv->tt.changes_list,

897

list) {

897

list) {

898

if (tt_diff_entries_count < tt_diff_entries_num) {

898

if (tt_diff_entries_count < tt_diff_entries_num) {

899

memcpy(tt_change + tt_diff_entries_count,

899

memcpy(tt_change + tt_diff_entries_count,

900

&entry->change,

900

&entry->change,

901

sizeof(struct batadv_tvlv_tt_change));

901

sizeof(struct batadv_tvlv_tt_change));

902

tt_diff_entries_count++;

902

tt_diff_entries_count++;

903

}

903

}

904

list_del(&entry->list);

904

list_del(&entry->list);

905

kfree(entry);

905

kfree(entry);

906

}

906

}

907

spin_unlock_bh(&bat_priv->tt.changes_list_lock);

907

spin_unlock_bh(&bat_priv->tt.changes_list_lock);

908

909

/* Keep the buffer for possible tt_request */

909

/* Keep the buffer for possible tt_request */

910

spin_lock_bh(&bat_priv->tt.last_changeset_lock);

910

spin_lock_bh(&bat_priv->tt.last_changeset_lock);

911

kfree(bat_priv->tt.last_changeset);

911

kfree(bat_priv->tt.last_changeset);

912

bat_priv->tt.last_changeset_len = 0;

912

bat_priv->tt.last_changeset_len = 0;

913

bat_priv->tt.last_changeset = NULL;

913

bat_priv->tt.last_changeset = NULL;

914

tt_change_len = batadv_tt_len(tt_diff_entries_count);

914

tt_change_len = batadv_tt_len(tt_diff_entries_count);

915

/* check whether this new OGM has no changes due to size problems */

915

/* check whether this new OGM has no changes due to size problems */

916

if (tt_diff_entries_count > 0) {

916

if (tt_diff_entries_count > 0) {

917

/* if kmalloc() fails we will reply with the full table

917

/* if kmalloc() fails we will reply with the full table

918

* instead of providing the diff

918

* instead of providing the diff

919

*/

919

*/

920

bat_priv->tt.last_changeset = kzalloc(tt_diff_len, GFP_ATOMIC);

920

bat_priv->tt.last_changeset = kzalloc(tt_diff_len, GFP_ATOMIC);

921

if (bat_priv->tt.last_changeset) {

921

if (bat_priv->tt.last_changeset) {

922

memcpy(bat_priv->tt.last_changeset,

922

memcpy(bat_priv->tt.last_changeset,

923

tt_change, tt_change_len);

923

tt_change, tt_change_len);

924

bat_priv->tt.last_changeset_len = tt_diff_len;

924

bat_priv->tt.last_changeset_len = tt_diff_len;

925

}

925

}

926

}

926

}

927

spin_unlock_bh(&bat_priv->tt.last_changeset_lock);

927

spin_unlock_bh(&bat_priv->tt.last_changeset_lock);

928

929

container_register:

929

container_register:

930

batadv_tvlv_container_register(bat_priv, BATADV_TVLV_TT, 1, tt_data,

930

batadv_tvlv_container_register(bat_priv, BATADV_TVLV_TT, 1, tt_data,

931

tvlv_len);

931

tvlv_len);

932

kfree(tt_data);

932

kfree(tt_data);

933

}

933

}

934

935

int batadv_tt_local_seq_print_text(struct seq_file *seq, void *offset)

935

int batadv_tt_local_seq_print_text(struct seq_file *seq, void *offset)

936

{

936

{

937

struct net_device *net_dev = (struct net_device *)seq->private;

937

struct net_device *net_dev = (struct net_device *)seq->private;

938

struct batadv_priv *bat_priv = netdev_priv(net_dev);

938

struct batadv_priv *bat_priv = netdev_priv(net_dev);

939

struct batadv_hashtable *hash = bat_priv->tt.local_hash;

939

struct batadv_hashtable *hash = bat_priv->tt.local_hash;

940

struct batadv_tt_common_entry *tt_common_entry;

940

struct batadv_tt_common_entry *tt_common_entry;

941

struct batadv_tt_local_entry *tt_local;

941

struct batadv_tt_local_entry *tt_local;

942

struct batadv_hard_iface *primary_if;

942

struct batadv_hard_iface *primary_if;

943

struct batadv_softif_vlan *vlan;

943

struct batadv_softif_vlan *vlan;

944

struct hlist_head *head;

944

struct hlist_head *head;

945

unsigned short vid;

945

unsigned short vid;

946

u32 i;

946

u32 i;

947

int last_seen_secs;

947

int last_seen_secs;

948

int last_seen_msecs;

948

int last_seen_msecs;

949

unsigned long last_seen_jiffies;

949

unsigned long last_seen_jiffies;

950

bool no_purge;

950

bool no_purge;

951

u16 np_flag = BATADV_TT_CLIENT_NOPURGE;

951

u16 np_flag = BATADV_TT_CLIENT_NOPURGE;

952

953

primary_if = batadv_seq_print_text_primary_if_get(seq);

953

primary_if = batadv_seq_print_text_primary_if_get(seq);

954

if (!primary_if)

954

if (!primary_if)

955

goto out;

955

goto out;

956

957

seq_printf(seq,

957

seq_printf(seq,

958

"Locally retrieved addresses (from %s) announced via TT (TTVN: %u):\n",

958

"Locally retrieved addresses (from %s) announced via TT (TTVN: %u):\n",

959

net_dev->name, (u8)atomic_read(&bat_priv->tt.vn));

959

net_dev->name, (u8)atomic_read(&bat_priv->tt.vn));

960

seq_printf(seq, " %-13s %s %-8s %-9s (%-10s)\n", "Client", "VID",

960

seq_printf(seq, " %-13s %s %-8s %-9s (%-10s)\n", "Client", "VID",

961

"Flags", "Last seen", "CRC");

961

"Flags", "Last seen", "CRC");

962

963

for (i = 0; i < hash->size; i++) {

963

for (i = 0; i < hash->size; i++) {

964

head = &hash->table[i];

964

head = &hash->table[i];

965

966

rcu_read_lock();

966

rcu_read_lock();

967

hlist_for_each_entry_rcu(tt_common_entry,

967

hlist_for_each_entry_rcu(tt_common_entry,

968

head, hash_entry) {

968

head, hash_entry) {

969

tt_local = container_of(tt_common_entry,

969

tt_local = container_of(tt_common_entry,

970

struct batadv_tt_local_entry,

970

struct batadv_tt_local_entry,

971

common);

971

common);

972

vid = tt_common_entry->vid;

972

vid = tt_common_entry->vid;

973

last_seen_jiffies = jiffies - tt_local->last_seen;

973

last_seen_jiffies = jiffies - tt_local->last_seen;

974

last_seen_msecs = jiffies_to_msecs(last_seen_jiffies);

974

last_seen_msecs = jiffies_to_msecs(last_seen_jiffies);

975

last_seen_secs = last_seen_msecs / 1000;

975

last_seen_secs = last_seen_msecs / 1000;

976

last_seen_msecs = last_seen_msecs % 1000;

976

last_seen_msecs = last_seen_msecs % 1000;

977

978

no_purge = tt_common_entry->flags & np_flag;

978

no_purge = tt_common_entry->flags & np_flag;

979

980

vlan = batadv_softif_vlan_get(bat_priv, vid);

980

vlan = batadv_softif_vlan_get(bat_priv, vid);

981

if (!vlan) {

981

if (!vlan) {

982

seq_printf(seq, "Cannot retrieve VLAN %d\n",

982

seq_printf(seq, "Cannot retrieve VLAN %d\n",

983

BATADV_PRINT_VID(vid));

983

BATADV_PRINT_VID(vid));

984

continue;

984

continue;

985

}

985

}

986

987

seq_printf(seq,

987

seq_printf(seq,

988

" * %pM %4i [%c%c%c%c%c%c] %3u.%03u (%#.8x)\n",

988

" * %pM %4i [%c%c%c%c%c%c] %3u.%03u (%#.8x)\n",

989

tt_common_entry->addr,

989

tt_common_entry->addr,

990

BATADV_PRINT_VID(tt_common_entry->vid),

990

BATADV_PRINT_VID(tt_common_entry->vid),

991

((tt_common_entry->flags &

991

((tt_common_entry->flags &

992

BATADV_TT_CLIENT_ROAM) ? 'R' : '.'),

992

BATADV_TT_CLIENT_ROAM) ? 'R' : '.'),

993

no_purge ? 'P' : '.',

993

no_purge ? 'P' : '.',

994

((tt_common_entry->flags &

994

((tt_common_entry->flags &

995

BATADV_TT_CLIENT_NEW) ? 'N' : '.'),

995

BATADV_TT_CLIENT_NEW) ? 'N' : '.'),

996

((tt_common_entry->flags &

996

((tt_common_entry->flags &

997

BATADV_TT_CLIENT_PENDING) ? 'X' : '.'),

997

BATADV_TT_CLIENT_PENDING) ? 'X' : '.'),

998

((tt_common_entry->flags &

998

((tt_common_entry->flags &

999

BATADV_TT_CLIENT_WIFI) ? 'W' : '.'),

999

BATADV_TT_CLIENT_WIFI) ? 'W' : '.'),

1000

((tt_common_entry->flags &

1000

((tt_common_entry->flags &

1001

BATADV_TT_CLIENT_ISOLA) ? 'I' : '.'),

1001

BATADV_TT_CLIENT_ISOLA) ? 'I' : '.'),

1002

no_purge ? 0 : last_seen_secs,

1002

no_purge ? 0 : last_seen_secs,

1003

no_purge ? 0 : last_seen_msecs,

1003

no_purge ? 0 : last_seen_msecs,

1004

vlan->tt.crc);

1004

vlan->tt.crc);

1005

1006

batadv_softif_vlan_free_ref(vlan);

1006

batadv_softif_vlan_free_ref(vlan);

1007

}

1007

}

1008

rcu_read_unlock();

1008

rcu_read_unlock();

1009

}

1009

}

1010

out:

1010

out:

1011

if (primary_if)

1011

if (primary_if)

1012

batadv_hardif_free_ref(primary_if);

1012

batadv_hardif_free_ref(primary_if);

1013

return 0;

1013

return 0;

1014

}

1014

}

1015

1016

static void

1016

static void

1017

batadv_tt_local_set_pending(struct batadv_priv *bat_priv,

1017

batadv_tt_local_set_pending(struct batadv_priv *bat_priv,

1018

struct batadv_tt_local_entry *tt_local_entry,

1018

struct batadv_tt_local_entry *tt_local_entry,

1019

u16 flags, const char *message)

1019

u16 flags, const char *message)

1020

{

1020

{

1021

batadv_tt_local_event(bat_priv, tt_local_entry, flags);

1021

batadv_tt_local_event(bat_priv, tt_local_entry, flags);

1022

1023

/* The local client has to be marked as "pending to be removed" but has

1023

/* The local client has to be marked as "pending to be removed" but has

1024

* to be kept in the table in order to send it in a full table

1024

* to be kept in the table in order to send it in a full table

1025

* response issued before the net ttvn increment (consistency check)

1025

* response issued before the net ttvn increment (consistency check)

1026

*/

1026

*/

1027

tt_local_entry->common.flags |= BATADV_TT_CLIENT_PENDING;

1027

tt_local_entry->common.flags |= BATADV_TT_CLIENT_PENDING;

1028

1029

batadv_dbg(BATADV_DBG_TT, bat_priv,

1029

batadv_dbg(BATADV_DBG_TT, bat_priv,

1030

"Local tt entry (%pM, vid: %d) pending to be removed: %s\n",

1030

"Local tt entry (%pM, vid: %d) pending to be removed: %s\n",

1031

tt_local_entry->common.addr,

1031

tt_local_entry->common.addr,

1032

BATADV_PRINT_VID(tt_local_entry->common.vid), message);

1032

BATADV_PRINT_VID(tt_local_entry->common.vid), message);

1033

}

1033

}

1034

1035

/**

1035

/**

1036

* batadv_tt_local_remove - logically remove an entry from the local table

1036

* batadv_tt_local_remove - logically remove an entry from the local table

1037

* @bat_priv: the bat priv with all the soft interface information

1037

* @bat_priv: the bat priv with all the soft interface information

1038

* @addr: the MAC address of the client to remove

1038

* @addr: the MAC address of the client to remove

1039

* @vid: VLAN identifier

1039

* @vid: VLAN identifier

1040

* @message: message to append to the log on deletion

1040

* @message: message to append to the log on deletion

1041

* @roaming: true if the deletion is due to a roaming event

1041

* @roaming: true if the deletion is due to a roaming event

1042

*

1042

*

1043

* Returns the flags assigned to the local entry before being deleted

1043

* Returns the flags assigned to the local entry before being deleted

1044

*/

1044

*/

1045

u16 batadv_tt_local_remove(struct batadv_priv *bat_priv, const u8 *addr,

1045

u16 batadv_tt_local_remove(struct batadv_priv *bat_priv, const u8 *addr,

1046

unsigned short vid, const char *message,

1046

unsigned short vid, const char *message,

1047

bool roaming)

1047

bool roaming)

1048

{

1048

{

1049

struct batadv_tt_local_entry *tt_local_entry;

1049

struct batadv_tt_local_entry *tt_local_entry;

1050

u16 flags, curr_flags = BATADV_NO_FLAGS;

1050

u16 flags, curr_flags = BATADV_NO_FLAGS;

1051

struct batadv_softif_vlan *vlan;

1051

struct batadv_softif_vlan *vlan;

1052

void *tt_entry_exists;

1052

void *tt_entry_exists;

1053

1054

tt_local_entry = batadv_tt_local_hash_find(bat_priv, addr, vid);

1054

tt_local_entry = batadv_tt_local_hash_find(bat_priv, addr, vid);

1055

if (!tt_local_entry)

1055

if (!tt_local_entry)

1056

goto out;

1056

goto out;

1057

1058

curr_flags = tt_local_entry->common.flags;

1058

curr_flags = tt_local_entry->common.flags;

1059

1060

flags = BATADV_TT_CLIENT_DEL;

1060

flags = BATADV_TT_CLIENT_DEL;

1061

/* if this global entry addition is due to a roaming, the node has to

1061

/* if this global entry addition is due to a roaming, the node has to

1062

* mark the local entry as "roamed" in order to correctly reroute

1062

* mark the local entry as "roamed" in order to correctly reroute

1063

* packets later

1063

* packets later

1064

*/

1064

*/

1065

if (roaming) {

1065

if (roaming) {

1066

flags |= BATADV_TT_CLIENT_ROAM;

1066

flags |= BATADV_TT_CLIENT_ROAM;

1067

/* mark the local client as ROAMed */

1067

/* mark the local client as ROAMed */

1068

tt_local_entry->common.flags |= BATADV_TT_CLIENT_ROAM;

1068

tt_local_entry->common.flags |= BATADV_TT_CLIENT_ROAM;

1069

}

1069

}

1070

1071

if (!(tt_local_entry->common.flags & BATADV_TT_CLIENT_NEW)) {

1071

if (!(tt_local_entry->common.flags & BATADV_TT_CLIENT_NEW)) {

1072

batadv_tt_local_set_pending(bat_priv, tt_local_entry, flags,

1072

batadv_tt_local_set_pending(bat_priv, tt_local_entry, flags,

1073

message);

1073

message);

1074

goto out;

1074

goto out;

1075

}

1075

}

1076

/* if this client has been added right now, it is possible to

1076

/* if this client has been added right now, it is possible to

1077

* immediately purge it

1077

* immediately purge it

1078

*/

1078

*/

1079

batadv_tt_local_event(bat_priv, tt_local_entry, BATADV_TT_CLIENT_DEL);

1079

batadv_tt_local_event(bat_priv, tt_local_entry, BATADV_TT_CLIENT_DEL);

1080

1081

tt_entry_exists = batadv_hash_remove(bat_priv->tt.local_hash,

1081

tt_entry_exists = batadv_hash_remove(bat_priv->tt.local_hash,

1082

batadv_compare_tt,

1082

batadv_compare_tt,

1083

batadv_choose_tt,

1083

batadv_choose_tt,

1084

&tt_local_entry->common);

1084

&tt_local_entry->common);

1085

if (!tt_entry_exists)

1085

if (!tt_entry_exists)

1086

goto out;

1086

goto out;

1087

1088

/* extra call to free the local tt entry */

1088

/* extra call to free the local tt entry */

1089

batadv_tt_local_entry_free_ref(tt_local_entry);

1089

batadv_tt_local_entry_free_ref(tt_local_entry);

1090

1091

/* decrease the reference held for this vlan */

1091

/* decrease the reference held for this vlan */

1092

vlan = batadv_softif_vlan_get(bat_priv, vid);

1092

vlan = batadv_softif_vlan_get(bat_priv, vid);

1093

if (!vlan)

1093

if (!vlan)

1094

goto out;

1094

goto out;

1095

1096

batadv_softif_vlan_free_ref(vlan);

1096

batadv_softif_vlan_free_ref(vlan);

1097

batadv_softif_vlan_free_ref(vlan);

1097

batadv_softif_vlan_free_ref(vlan);

1098

1099

out:

1099

out:

1100

if (tt_local_entry)

1100

if (tt_local_entry)

1101

batadv_tt_local_entry_free_ref(tt_local_entry);

1101

batadv_tt_local_entry_free_ref(tt_local_entry);

1102

1103

return curr_flags;

1103

return curr_flags;

1104

}

1104

}

1105

1106

/**

1106

/**

1107

* batadv_tt_local_purge_list - purge inactive tt local entries

1107

* batadv_tt_local_purge_list - purge inactive tt local entries

1108

* @bat_priv: the bat priv with all the soft interface information

1108

* @bat_priv: the bat priv with all the soft interface information

1109

* @head: pointer to the list containing the local tt entries

1109

* @head: pointer to the list containing the local tt entries

1110

* @timeout: parameter deciding whether a given tt local entry is considered

1110

* @timeout: parameter deciding whether a given tt local entry is considered

1111

* inactive or not

1111

* inactive or not

1112

*/

1112

*/

1113

static void batadv_tt_local_purge_list(struct batadv_priv *bat_priv,

1113

static void batadv_tt_local_purge_list(struct batadv_priv *bat_priv,

1114

struct hlist_head *head,

1114

struct hlist_head *head,

1115

int timeout)

1115

int timeout)

1116

{

1116

{

1117

struct batadv_tt_local_entry *tt_local_entry;

1117

struct batadv_tt_local_entry *tt_local_entry;

1118

struct batadv_tt_common_entry *tt_common_entry;

1118

struct batadv_tt_common_entry *tt_common_entry;

1119

struct hlist_node *node_tmp;

1119

struct hlist_node *node_tmp;

1120

1121

hlist_for_each_entry_safe(tt_common_entry, node_tmp, head,

1121

hlist_for_each_entry_safe(tt_common_entry, node_tmp, head,

1122

hash_entry) {

1122

hash_entry) {

1123

tt_local_entry = container_of(tt_common_entry,

1123

tt_local_entry = container_of(tt_common_entry,

1124

struct batadv_tt_local_entry,

1124

struct batadv_tt_local_entry,

1125

common);

1125

common);

1126

if (tt_local_entry->common.flags & BATADV_TT_CLIENT_NOPURGE)

1126

if (tt_local_entry->common.flags & BATADV_TT_CLIENT_NOPURGE)

1127

continue;

1127

continue;

1128

1129

/* entry already marked for deletion */

1129

/* entry already marked for deletion */

1130

if (tt_local_entry->common.flags & BATADV_TT_CLIENT_PENDING)

1130

if (tt_local_entry->common.flags & BATADV_TT_CLIENT_PENDING)

1131

continue;

1131

continue;

1132

1133

if (!batadv_has_timed_out(tt_local_entry->last_seen, timeout))

1133

if (!batadv_has_timed_out(tt_local_entry->last_seen, timeout))

1134

continue;

1134

continue;

1135

1136

batadv_tt_local_set_pending(bat_priv, tt_local_entry,

1136

batadv_tt_local_set_pending(bat_priv, tt_local_entry,

1137

BATADV_TT_CLIENT_DEL, "timed out");

1137

BATADV_TT_CLIENT_DEL, "timed out");

1138

}

1138

}

1139

}

1139

}

1140

1141

/**

1141

/**

1142

* batadv_tt_local_purge - purge inactive tt local entries

1142

* batadv_tt_local_purge - purge inactive tt local entries

1143

* @bat_priv: the bat priv with all the soft interface information

1143

* @bat_priv: the bat priv with all the soft interface information

1144

* @timeout: parameter deciding whether a given tt local entry is considered

1144

* @timeout: parameter deciding whether a given tt local entry is considered

1145

* inactive or not

1145

* inactive or not

1146

*/

1146

*/

1147

static void batadv_tt_local_purge(struct batadv_priv *bat_priv,

1147

static void batadv_tt_local_purge(struct batadv_priv *bat_priv,

1148

int timeout)

1148

int timeout)

1149

{

1149

{

1150

struct batadv_hashtable *hash = bat_priv->tt.local_hash;

1150

struct batadv_hashtable *hash = bat_priv->tt.local_hash;

1151

struct hlist_head *head;

1151

struct hlist_head *head;

1152

spinlock_t *list_lock; /* protects write access to the hash lists */

1152

spinlock_t *list_lock; /* protects write access to the hash lists */

1153

u32 i;

1153

u32 i;

1154

1155

for (i = 0; i < hash->size; i++) {

1155

for (i = 0; i < hash->size; i++) {

1156

head = &hash->table[i];

1156

head = &hash->table[i];

1157

list_lock = &hash->list_locks[i];

1157

list_lock = &hash->list_locks[i];

1158

1159

spin_lock_bh(list_lock);

1159

spin_lock_bh(list_lock);

1160

batadv_tt_local_purge_list(bat_priv, head, timeout);

1160

batadv_tt_local_purge_list(bat_priv, head, timeout);

1161

spin_unlock_bh(list_lock);

1161

spin_unlock_bh(list_lock);

1162

}

1162

}

1163

}

1163

}

1164

1165

static void batadv_tt_local_table_free(struct batadv_priv *bat_priv)

1165

static void batadv_tt_local_table_free(struct batadv_priv *bat_priv)

1166

{

1166

{

1167

struct batadv_hashtable *hash;

1167

struct batadv_hashtable *hash;

1168

spinlock_t *list_lock; /* protects write access to the hash lists */

1168

spinlock_t *list_lock; /* protects write access to the hash lists */

1169

struct batadv_tt_common_entry *tt_common_entry;

1169

struct batadv_tt_common_entry *tt_common_entry;

1170

struct batadv_tt_local_entry *tt_local;

1170

struct batadv_tt_local_entry *tt_local;

1171

struct batadv_softif_vlan *vlan;

1171

struct batadv_softif_vlan *vlan;

1172

struct hlist_node *node_tmp;

1172

struct hlist_node *node_tmp;

1173

struct hlist_head *head;

1173

struct hlist_head *head;

1174

u32 i;

1174

u32 i;

1175

1176

if (!bat_priv->tt.local_hash)

1176

if (!bat_priv->tt.local_hash)

1177

return;

1177

return;

1178

1179

hash = bat_priv->tt.local_hash;

1179

hash = bat_priv->tt.local_hash;

1180

1181

for (i = 0; i < hash->size; i++) {

1181

for (i = 0; i < hash->size; i++) {

1182

head = &hash->table[i];

1182

head = &hash->table[i];

1183

list_lock = &hash->list_locks[i];

1183

list_lock = &hash->list_locks[i];

1184

1185

spin_lock_bh(list_lock);

1185

spin_lock_bh(list_lock);

1186

hlist_for_each_entry_safe(tt_common_entry, node_tmp,

1186

hlist_for_each_entry_safe(tt_common_entry, node_tmp,

1187

head, hash_entry) {

1187

head, hash_entry) {

1188

hlist_del_rcu(&tt_common_entry->hash_entry);

1188

hlist_del_rcu(&tt_common_entry->hash_entry);

1189

tt_local = container_of(tt_common_entry,

1189

tt_local = container_of(tt_common_entry,

1190

struct batadv_tt_local_entry,

1190

struct batadv_tt_local_entry,

1191

common);

1191

common);

1192

1193

/* decrease the reference held for this vlan */

1193

/* decrease the reference held for this vlan */

1194

vlan = batadv_softif_vlan_get(bat_priv,

1194

vlan = batadv_softif_vlan_get(bat_priv,

1195

tt_common_entry->vid);

1195

tt_common_entry->vid);

1196

if (vlan) {

1196

if (vlan) {

1197

batadv_softif_vlan_free_ref(vlan);

1197

batadv_softif_vlan_free_ref(vlan);

1198

batadv_softif_vlan_free_ref(vlan);

1198

batadv_softif_vlan_free_ref(vlan);

1199

}

1199

}

1200

1201

batadv_tt_local_entry_free_ref(tt_local);

1201

batadv_tt_local_entry_free_ref(tt_local);

1202

}

1202

}

1203

spin_unlock_bh(list_lock);

1203

spin_unlock_bh(list_lock);

1204

}

1204

}

1205

1206

batadv_hash_destroy(hash);

1206

batadv_hash_destroy(hash);

1207

1208

bat_priv->tt.local_hash = NULL;

1208

bat_priv->tt.local_hash = NULL;

1209

}

1209

}

1210

1211

static int batadv_tt_global_init(struct batadv_priv *bat_priv)

1211

static int batadv_tt_global_init(struct batadv_priv *bat_priv)

1212

{

1212

{

1213

if (bat_priv->tt.global_hash)

1213

if (bat_priv->tt.global_hash)

1214

return 0;

1214

return 0;

1215

1216

bat_priv->tt.global_hash = batadv_hash_new(1024);

1216

bat_priv->tt.global_hash = batadv_hash_new(1024);

1217

1218

if (!bat_priv->tt.global_hash)

1218

if (!bat_priv->tt.global_hash)

1219

return -ENOMEM;

1219

return -ENOMEM;

1220

1221

batadv_hash_set_lock_class(bat_priv->tt.global_hash,

1221

batadv_hash_set_lock_class(bat_priv->tt.global_hash,

1222

&batadv_tt_global_hash_lock_class_key);

1222

&batadv_tt_global_hash_lock_class_key);

1223

1224

return 0;

1224

return 0;

1225

}

1225

}

1226

1227

static void batadv_tt_changes_list_free(struct batadv_priv *bat_priv)

1227

static void batadv_tt_changes_list_free(struct batadv_priv *bat_priv)

1228

{

1228

{

1229

struct batadv_tt_change_node *entry, *safe;

1229

struct batadv_tt_change_node *entry, *safe;

1230

1231

spin_lock_bh(&bat_priv->tt.changes_list_lock);

1231

spin_lock_bh(&bat_priv->tt.changes_list_lock);

1232

1233

list_for_each_entry_safe(entry, safe, &bat_priv->tt.changes_list,

1233

list_for_each_entry_safe(entry, safe, &bat_priv->tt.changes_list,

1234

list) {

1234

list) {

1235

list_del(&entry->list);

1235

list_del(&entry->list);

1236

kfree(entry);

1236

kfree(entry);

1237

}

1237

}

1238

1239

atomic_set(&bat_priv->tt.local_changes, 0);

1239

atomic_set(&bat_priv->tt.local_changes, 0);

1240

spin_unlock_bh(&bat_priv->tt.changes_list_lock);

1240

spin_unlock_bh(&bat_priv->tt.changes_list_lock);

1241

}

1241

}

1242

1243

/* retrieves the orig_tt_list_entry belonging to orig_node from the

1243

/* retrieves the orig_tt_list_entry belonging to orig_node from the

1244

* batadv_tt_global_entry list

1244

* batadv_tt_global_entry list

1245

*

1245

*

1246

* returns it with an increased refcounter, NULL if not found

1246

* returns it with an increased refcounter, NULL if not found

1247

*/

1247

*/

1248

static struct batadv_tt_orig_list_entry *

1248

static struct batadv_tt_orig_list_entry *

1249

batadv_tt_global_orig_entry_find(const struct batadv_tt_global_entry *entry,

1249

batadv_tt_global_orig_entry_find(const struct batadv_tt_global_entry *entry,

1250

const struct batadv_orig_node *orig_node)

1250

const struct batadv_orig_node *orig_node)

1251

{

1251

{

1252

struct batadv_tt_orig_list_entry *tmp_orig_entry, *orig_entry = NULL;

1252

struct batadv_tt_orig_list_entry *tmp_orig_entry, *orig_entry = NULL;

1253

const struct hlist_head *head;

1253

const struct hlist_head *head;

1254

1255

rcu_read_lock();

1255

rcu_read_lock();

1256

head = &entry->orig_list;

1256

head = &entry->orig_list;

1257

hlist_for_each_entry_rcu(tmp_orig_entry, head, list) {

1257

hlist_for_each_entry_rcu(tmp_orig_entry, head, list) {

1258

if (tmp_orig_entry->orig_node != orig_node)

1258

if (tmp_orig_entry->orig_node != orig_node)

1259

continue;

1259

continue;

1260

if (!atomic_inc_not_zero(&tmp_orig_entry->refcount))

1260

if (!atomic_inc_not_zero(&tmp_orig_entry->refcount))

1261

continue;

1261

continue;

1262

1263

orig_entry = tmp_orig_entry;

1263

orig_entry = tmp_orig_entry;

1264

break;

1264

break;

1265

}

1265

}

1266

rcu_read_unlock();

1266

rcu_read_unlock();

1267

1268

return orig_entry;

1268

return orig_entry;

1269

}

1269

}

1270

1271

/* find out if an orig_node is already in the list of a tt_global_entry.

1271

/* find out if an orig_node is already in the list of a tt_global_entry.

1272

* returns true if found, false otherwise

1272

* returns true if found, false otherwise

1273

*/

1273

*/

1274

static bool

1274

static bool

1275

batadv_tt_global_entry_has_orig(const struct batadv_tt_global_entry *entry,

1275

batadv_tt_global_entry_has_orig(const struct batadv_tt_global_entry *entry,

1276

const struct batadv_orig_node *orig_node)

1276

const struct batadv_orig_node *orig_node)

1277

{

1277

{

1278

struct batadv_tt_orig_list_entry *orig_entry;

1278

struct batadv_tt_orig_list_entry *orig_entry;

1279

bool found = false;

1279

bool found = false;

1280

1281

orig_entry = batadv_tt_global_orig_entry_find(entry, orig_node);

1281

orig_entry = batadv_tt_global_orig_entry_find(entry, orig_node);

1282

if (orig_entry) {

1282

if (orig_entry) {

1283

found = true;

1283

found = true;

1284

batadv_tt_orig_list_entry_free_ref(orig_entry);

1284

batadv_tt_orig_list_entry_free_ref(orig_entry);

1285

}

1285

}

1286

1287

return found;

1287

return found;

1288

}

1288

}

1289

1290

static void

1290

static void

1291

batadv_tt_global_orig_entry_add(struct batadv_tt_global_entry *tt_global,

1291

batadv_tt_global_orig_entry_add(struct batadv_tt_global_entry *tt_global,

1292

struct batadv_orig_node *orig_node, int ttvn)

1292

struct batadv_orig_node *orig_node, int ttvn)

1293

{

1293

{

1294

struct batadv_tt_orig_list_entry *orig_entry;

1294

struct batadv_tt_orig_list_entry *orig_entry;

1295

1296

orig_entry = batadv_tt_global_orig_entry_find(tt_global, orig_node);

1296

orig_entry = batadv_tt_global_orig_entry_find(tt_global, orig_node);

1297

if (orig_entry) {

1297

if (orig_entry) {

1298

/* refresh the ttvn: the current value could be a bogus one that

1298

/* refresh the ttvn: the current value could be a bogus one that

1299

* was added during a "temporary client detection"

1299

* was added during a "temporary client detection"

1300

*/

1300

*/

1301

orig_entry->ttvn = ttvn;

1301

orig_entry->ttvn = ttvn;

1302

goto out;

1302

goto out;

1303

}

1303

}

1304

1305

orig_entry = kzalloc(sizeof(*orig_entry), GFP_ATOMIC);

1305

orig_entry = kzalloc(sizeof(*orig_entry), GFP_ATOMIC);

1306

if (!orig_entry)

1306

if (!orig_entry)

1307

goto out;

1307

goto out;

1308

1309

INIT_HLIST_NODE(&orig_entry->list);

1309

INIT_HLIST_NODE(&orig_entry->list);

1310

atomic_inc(&orig_node->refcount);

1310

atomic_inc(&orig_node->refcount);

1311

batadv_tt_global_size_inc(orig_node, tt_global->common.vid);

1311

batadv_tt_global_size_inc(orig_node, tt_global->common.vid);

1312

orig_entry->orig_node = orig_node;

1312

orig_entry->orig_node = orig_node;

1313

orig_entry->ttvn = ttvn;

1313

orig_entry->ttvn = ttvn;

1314

atomic_set(&orig_entry->refcount, 2);

1314

atomic_set(&orig_entry->refcount, 2);

1315

1316

spin_lock_bh(&tt_global->list_lock);

1316

spin_lock_bh(&tt_global->list_lock);

1317

hlist_add_head_rcu(&orig_entry->list,

1317

hlist_add_head_rcu(&orig_entry->list,

1318

&tt_global->orig_list);

1318

&tt_global->orig_list);

1319

spin_unlock_bh(&tt_global->list_lock);

1319

spin_unlock_bh(&tt_global->list_lock);

1320

atomic_inc(&tt_global->orig_list_count);

1320

atomic_inc(&tt_global->orig_list_count);

1321

1322

out:

1322

out:

1323

if (orig_entry)

1323

if (orig_entry)

1324

batadv_tt_orig_list_entry_free_ref(orig_entry);

1324

batadv_tt_orig_list_entry_free_ref(orig_entry);

1325

}

1325

}

1326

1327

/**

1327

/**

1328

* batadv_tt_global_add - add a new TT global entry or update an existing one

1328

* batadv_tt_global_add - add a new TT global entry or update an existing one

1329

* @bat_priv: the bat priv with all the soft interface information

1329

* @bat_priv: the bat priv with all the soft interface information

1330

* @orig_node: the originator announcing the client

1330

* @orig_node: the originator announcing the client

1331

* @tt_addr: the mac address of the non-mesh client

1331

* @tt_addr: the mac address of the non-mesh client

1332

* @vid: VLAN identifier

1332

* @vid: VLAN identifier

1333

* @flags: TT flags that have to be set for this non-mesh client

1333

* @flags: TT flags that have to be set for this non-mesh client

1334

* @ttvn: the tt version number ever announcing this non-mesh client

1334

* @ttvn: the tt version number ever announcing this non-mesh client

1335

*

1335

*

1336

* Add a new TT global entry for the given originator. If the entry already

1336

* Add a new TT global entry for the given originator. If the entry already

1337

* exists add a new reference to the given originator (a global entry can have

1337

* exists add a new reference to the given originator (a global entry can have

1338

* references to multiple originators) and adjust the flags attribute to reflect

1338

* references to multiple originators) and adjust the flags attribute to reflect

1339

* the function argument.

1339

* the function argument.

1340

* If a TT local entry exists for this non-mesh client remove it.

1340

* If a TT local entry exists for this non-mesh client remove it.

1341

*

1341

*

1342

* The caller must hold orig_node refcount.

1342

* The caller must hold orig_node refcount.

1343

*

1343

*

1344

* Return true if the new entry has been added, false otherwise

1344

* Return true if the new entry has been added, false otherwise

1345

*/

1345

*/

1346

static bool batadv_tt_global_add(struct batadv_priv *bat_priv,

1346

static bool batadv_tt_global_add(struct batadv_priv *bat_priv,

1347

struct batadv_orig_node *orig_node,

1347

struct batadv_orig_node *orig_node,

1348

const unsigned char *tt_addr,

1348

const unsigned char *tt_addr,

1349

unsigned short vid, u16 flags, u8 ttvn)

1349

unsigned short vid, u16 flags, u8 ttvn)

1350

{

1350

{

1351

struct batadv_tt_global_entry *tt_global_entry;

1351

struct batadv_tt_global_entry *tt_global_entry;

1352

struct batadv_tt_local_entry *tt_local_entry;

1352

struct batadv_tt_local_entry *tt_local_entry;

1353

bool ret = false;

1353

bool ret = false;

1354

int hash_added;

1354

int hash_added;

1355

struct batadv_tt_common_entry *common;

1355

struct batadv_tt_common_entry *common;

1356

u16 local_flags;

1356

u16 local_flags;

1357

1358

/* ignore global entries from backbone nodes */

1358

/* ignore global entries from backbone nodes */

1359

if (batadv_bla_is_backbone_gw_orig(bat_priv, orig_node->orig, vid))

1359

if (batadv_bla_is_backbone_gw_orig(bat_priv, orig_node->orig, vid))

1360

return true;

1360

return true;

1361

1362

tt_global_entry = batadv_tt_global_hash_find(bat_priv, tt_addr, vid);

1362

tt_global_entry = batadv_tt_global_hash_find(bat_priv, tt_addr, vid);

1363

tt_local_entry = batadv_tt_local_hash_find(bat_priv, tt_addr, vid);

1363

tt_local_entry = batadv_tt_local_hash_find(bat_priv, tt_addr, vid);

1364

1365

/* if the node already has a local client for this entry, it has to wait

1365

/* if the node already has a local client for this entry, it has to wait

1366

* for a roaming advertisement instead of manually messing up the global

1366

* for a roaming advertisement instead of manually messing up the global

1367

* table

1367

* table

1368

*/

1368

*/

1369

if ((flags & BATADV_TT_CLIENT_TEMP) && tt_local_entry &&

1369

if ((flags & BATADV_TT_CLIENT_TEMP) && tt_local_entry &&

1370

!(tt_local_entry->common.flags & BATADV_TT_CLIENT_NEW))

1370

!(tt_local_entry->common.flags & BATADV_TT_CLIENT_NEW))

1371

goto out;

1371

goto out;

1372

1373

if (!tt_global_entry) {

1373

if (!tt_global_entry) {

1374

tt_global_entry = kzalloc(sizeof(*tt_global_entry), GFP_ATOMIC);

1374

tt_global_entry = kzalloc(sizeof(*tt_global_entry), GFP_ATOMIC);

1375

if (!tt_global_entry)

1375

if (!tt_global_entry)

1376

goto out;

1376

goto out;

1377

1378

common = &tt_global_entry->common;

1378

common = &tt_global_entry->common;

1379

ether_addr_copy(common->addr, tt_addr);

1379

ether_addr_copy(common->addr, tt_addr);

1380

common->vid = vid;

1380

common->vid = vid;

1381

1382

common->flags = flags;

1382

common->flags = flags;

1383

tt_global_entry->roam_at = 0;

1383

tt_global_entry->roam_at = 0;

1384

/* node must store current time in case of roaming. This is

1384

/* node must store current time in case of roaming. This is

1385

* needed to purge this entry out on timeout (if nobody claims

1385

* needed to purge this entry out on timeout (if nobody claims

1386

* it)

1386

* it)

1387

*/

1387

*/

1388

if (flags & BATADV_TT_CLIENT_ROAM)

1388

if (flags & BATADV_TT_CLIENT_ROAM)

1389

tt_global_entry->roam_at = jiffies;

1389

tt_global_entry->roam_at = jiffies;

1390

atomic_set(&common->refcount, 2);

1390

atomic_set(&common->refcount, 2);

1391

common->added_at = jiffies;

1391

common->added_at = jiffies;

1392

1393

INIT_HLIST_HEAD(&tt_global_entry->orig_list);

1393

INIT_HLIST_HEAD(&tt_global_entry->orig_list);

1394

atomic_set(&tt_global_entry->orig_list_count, 0);

1394

atomic_set(&tt_global_entry->orig_list_count, 0);

1395

spin_lock_init(&tt_global_entry->list_lock);

1395

spin_lock_init(&tt_global_entry->list_lock);

1396

1397

hash_added = batadv_hash_add(bat_priv->tt.global_hash,

1397

hash_added = batadv_hash_add(bat_priv->tt.global_hash,

1398

batadv_compare_tt,

1398

batadv_compare_tt,

1399

batadv_choose_tt, common,

1399

batadv_choose_tt, common,

1400

&common->hash_entry);

1400

&common->hash_entry);

1401

1402

if (unlikely(hash_added != 0)) {

1402

if (unlikely(hash_added != 0)) {

1403

/* remove the reference for the hash */

1403

/* remove the reference for the hash */

1404

batadv_tt_global_entry_free_ref(tt_global_entry);

1404

batadv_tt_global_entry_free_ref(tt_global_entry);

1405

goto out_remove;

1405

goto out_remove;

1406

}

1406

}

1407

} else {

1407

} else {

1408

common = &tt_global_entry->common;

1408

common = &tt_global_entry->common;

1409

/* If there is already a global entry, we can use this one for

1409

/* If there is already a global entry, we can use this one for

1410

* our processing.

1410

* our processing.

1411

* But if we are trying to add a temporary client then here are

1411

* But if we are trying to add a temporary client then here are

1412

* two options at this point:

1412

* two options at this point:

1413

* 1) the global client is not a temporary client: the global

1413

* 1) the global client is not a temporary client: the global

1414

* client has to be left as it is, temporary information

1414

* client has to be left as it is, temporary information

1415

* should never override any already known client state

1415

* should never override any already known client state

1416

* 2) the global client is a temporary client: purge the

1416

* 2) the global client is a temporary client: purge the

1417

* originator list and add the new one orig_entry

1417

* originator list and add the new one orig_entry

1418

*/

1418

*/

1419

if (flags & BATADV_TT_CLIENT_TEMP) {

1419

if (flags & BATADV_TT_CLIENT_TEMP) {

1420

if (!(common->flags & BATADV_TT_CLIENT_TEMP))

1420

if (!(common->flags & BATADV_TT_CLIENT_TEMP))

1421

goto out;

1421

goto out;

1422

if (batadv_tt_global_entry_has_orig(tt_global_entry,

1422

if (batadv_tt_global_entry_has_orig(tt_global_entry,

1423

orig_node))

1423

orig_node))

1424

goto out_remove;

1424

goto out_remove;

1425

batadv_tt_global_del_orig_list(tt_global_entry);

1425

batadv_tt_global_del_orig_list(tt_global_entry);

1426

goto add_orig_entry;

1426

goto add_orig_entry;

1427

}

1427

}

1428

1429

/* if the client was temporary added before receiving the first

1429

/* if the client was temporary added before receiving the first

1430

* OGM announcing it, we have to clear the TEMP flag

1430

* OGM announcing it, we have to clear the TEMP flag

1431

*/

1431

*/

1432

common->flags &= ~BATADV_TT_CLIENT_TEMP;

1432

common->flags &= ~BATADV_TT_CLIENT_TEMP;

1433

1434

/* the change can carry possible "attribute" flags like the

1434

/* the change can carry possible "attribute" flags like the

1435

* TT_CLIENT_WIFI, therefore they have to be copied in the

1435

* TT_CLIENT_WIFI, therefore they have to be copied in the

1436

* client entry

1436

* client entry

1437

*/

1437

*/

1438

tt_global_entry->common.flags |= flags;

1438

tt_global_entry->common.flags |= flags;

1439

1440

/* If there is the BATADV_TT_CLIENT_ROAM flag set, there is only

1440

/* If there is the BATADV_TT_CLIENT_ROAM flag set, there is only

1441

* one originator left in the list and we previously received a

1441

* one originator left in the list and we previously received a

1442

* delete + roaming change for this originator.

1442

* delete + roaming change for this originator.

1443

*

1443

*

1444

* We should first delete the old originator before adding the

1444

* We should first delete the old originator before adding the

1445

* new one.

1445

* new one.

1446

*/

1446

*/

1447

if (common->flags & BATADV_TT_CLIENT_ROAM) {

1447

if (common->flags & BATADV_TT_CLIENT_ROAM) {

1448

batadv_tt_global_del_orig_list(tt_global_entry);

1448

batadv_tt_global_del_orig_list(tt_global_entry);

1449

common->flags &= ~BATADV_TT_CLIENT_ROAM;

1449

common->flags &= ~BATADV_TT_CLIENT_ROAM;

1450

tt_global_entry->roam_at = 0;

1450

tt_global_entry->roam_at = 0;

1451

}

1451

}

1452

}

1452

}

1453

add_orig_entry:

1453

add_orig_entry:

1454

/* add the new orig_entry (if needed) or update it */

1454

/* add the new orig_entry (if needed) or update it */

1455

batadv_tt_global_orig_entry_add(tt_global_entry, orig_node, ttvn);

1455

batadv_tt_global_orig_entry_add(tt_global_entry, orig_node, ttvn);

1456

1457

batadv_dbg(BATADV_DBG_TT, bat_priv,

1457

batadv_dbg(BATADV_DBG_TT, bat_priv,

1458

"Creating new global tt entry: %pM (vid: %d, via %pM)\n",

1458

"Creating new global tt entry: %pM (vid: %d, via %pM)\n",

1459

common->addr, BATADV_PRINT_VID(common->vid),

1459

common->addr, BATADV_PRINT_VID(common->vid),

1460

orig_node->orig);

1460

orig_node->orig);

1461

ret = true;

1461

ret = true;

1462

1463

out_remove:

1463

out_remove:

1464

/* Do not remove multicast addresses from the local hash on

1464

/* Do not remove multicast addresses from the local hash on

1465

* global additions

1465

* global additions

1466

*/

1466

*/

1467

if (is_multicast_ether_addr(tt_addr))

1467

if (is_multicast_ether_addr(tt_addr))

1468

goto out;

1468

goto out;

1469

1470

/* remove address from local hash if present */

1470

/* remove address from local hash if present */

1471

local_flags = batadv_tt_local_remove(bat_priv, tt_addr, vid,

1471

local_flags = batadv_tt_local_remove(bat_priv, tt_addr, vid,

1472

"global tt received",

1472

"global tt received",

1473

flags & BATADV_TT_CLIENT_ROAM);

1473

flags & BATADV_TT_CLIENT_ROAM);

1474

tt_global_entry->common.flags |= local_flags & BATADV_TT_CLIENT_WIFI;

1474

tt_global_entry->common.flags |= local_flags & BATADV_TT_CLIENT_WIFI;

1475

1476

if (!(flags & BATADV_TT_CLIENT_ROAM))

1476

if (!(flags & BATADV_TT_CLIENT_ROAM))

1477

/* this is a normal global add. Therefore the client is not in a

1477

/* this is a normal global add. Therefore the client is not in a

1478

* roaming state anymore.

1478

* roaming state anymore.

1479

*/

1479

*/

1480

tt_global_entry->common.flags &= ~BATADV_TT_CLIENT_ROAM;

1480

tt_global_entry->common.flags &= ~BATADV_TT_CLIENT_ROAM;

1481

1482

out:

1482

out:

1483

if (tt_global_entry)

1483

if (tt_global_entry)

1484

batadv_tt_global_entry_free_ref(tt_global_entry);

1484

batadv_tt_global_entry_free_ref(tt_global_entry);

1485

if (tt_local_entry)

1485

if (tt_local_entry)

1486

batadv_tt_local_entry_free_ref(tt_local_entry);

1486

batadv_tt_local_entry_free_ref(tt_local_entry);

1487

return ret;

1487

return ret;

1488

}

1488

}

1489

1490

/**

1490

/**

1491

* batadv_transtable_best_orig - Get best originator list entry from tt entry

1491

* batadv_transtable_best_orig - Get best originator list entry from tt entry

1492

* @bat_priv: the bat priv with all the soft interface information

1492

* @bat_priv: the bat priv with all the soft interface information

1493

* @tt_global_entry: global translation table entry to be analyzed

1493

* @tt_global_entry: global translation table entry to be analyzed

1494

*

1494

*

1495

* This functon assumes the caller holds rcu_read_lock().

1495

* This functon assumes the caller holds rcu_read_lock().

1496

* Returns best originator list entry or NULL on errors.

1496

* Returns best originator list entry or NULL on errors.

1497

*/

1497

*/

1498

static struct batadv_tt_orig_list_entry *

1498

static struct batadv_tt_orig_list_entry *

1499

batadv_transtable_best_orig(struct batadv_priv *bat_priv,

1499

batadv_transtable_best_orig(struct batadv_priv *bat_priv,

1500

struct batadv_tt_global_entry *tt_global_entry)

1500

struct batadv_tt_global_entry *tt_global_entry)

1501

{

1501

{

1502

struct batadv_neigh_node *router, *best_router = NULL;

1502

struct batadv_neigh_node *router, *best_router = NULL;

1503

struct batadv_algo_ops *bao = bat_priv->bat_algo_ops;

1503

struct batadv_algo_ops *bao = bat_priv->bat_algo_ops;

1504

struct hlist_head *head;

1504

struct hlist_head *head;

1505

struct batadv_tt_orig_list_entry *orig_entry, *best_entry = NULL;

1505

struct batadv_tt_orig_list_entry *orig_entry, *best_entry = NULL;

1506

1507

head = &tt_global_entry->orig_list;

1507

head = &tt_global_entry->orig_list;

1508

hlist_for_each_entry_rcu(orig_entry, head, list) {

1508

hlist_for_each_entry_rcu(orig_entry, head, list) {

1509

router = batadv_orig_router_get(orig_entry->orig_node,

1509

router = batadv_orig_router_get(orig_entry->orig_node,

1510

BATADV_IF_DEFAULT);

1510

BATADV_IF_DEFAULT);

1511

if (!router)

1511

if (!router)

1512

continue;

1512

continue;

1513

1514

if (best_router &&

1514

if (best_router &&

1515

bao->bat_neigh_cmp(router, BATADV_IF_DEFAULT,

1515

bao->bat_neigh_cmp(router, BATADV_IF_DEFAULT,

1516

best_router, BATADV_IF_DEFAULT) <= 0) {

1516

best_router, BATADV_IF_DEFAULT) <= 0) {

1517

batadv_neigh_node_free_ref(router);

1517

batadv_neigh_node_free_ref(router);

1518

continue;

1518

continue;

1519

}

1519

}

1520

1521

/* release the refcount for the "old" best */

1521

/* release the refcount for the "old" best */

1522

if (best_router)

1522

if (best_router)

1523

batadv_neigh_node_free_ref(best_router);

1523

batadv_neigh_node_free_ref(best_router);

1524

1525

best_entry = orig_entry;

1525

best_entry = orig_entry;

1526

best_router = router;

1526

best_router = router;

1527

}

1527

}

1528

1529

if (best_router)

1529

if (best_router)

1530

batadv_neigh_node_free_ref(best_router);

1530

batadv_neigh_node_free_ref(best_router);

1531

1532

return best_entry;

1532

return best_entry;

1533

}

1533

}

1534

1535

/**

1535

/**

1536

* batadv_tt_global_print_entry - print all orig nodes who announce the address

1536

* batadv_tt_global_print_entry - print all orig nodes who announce the address

1537

* for this global entry

1537

* for this global entry

1538

* @bat_priv: the bat priv with all the soft interface information

1538

* @bat_priv: the bat priv with all the soft interface information

1539

* @tt_global_entry: global translation table entry to be printed

1539

* @tt_global_entry: global translation table entry to be printed

1540

* @seq: debugfs table seq_file struct

1540

* @seq: debugfs table seq_file struct

1541

*

1541

*

1542

* This functon assumes the caller holds rcu_read_lock().

1542

* This functon assumes the caller holds rcu_read_lock().

1543

*/

1543

*/

1544

static void

1544

static void

1545

batadv_tt_global_print_entry(struct batadv_priv *bat_priv,

1545

batadv_tt_global_print_entry(struct batadv_priv *bat_priv,

1546

struct batadv_tt_global_entry *tt_global_entry,

1546

struct batadv_tt_global_entry *tt_global_entry,

1547

struct seq_file *seq)

1547

struct seq_file *seq)

1548

{

1548

{

1549

struct batadv_tt_orig_list_entry *orig_entry, *best_entry;

1549

struct batadv_tt_orig_list_entry *orig_entry, *best_entry;

1550

struct batadv_tt_common_entry *tt_common_entry;

1550

struct batadv_tt_common_entry *tt_common_entry;

1551

struct batadv_orig_node_vlan *vlan;

1551

struct batadv_orig_node_vlan *vlan;

1552

struct hlist_head *head;

1552

struct hlist_head *head;

1553

u8 last_ttvn;

1553

u8 last_ttvn;

1554

u16 flags;

1554

u16 flags;

1555

1556

tt_common_entry = &tt_global_entry->common;

1556

tt_common_entry = &tt_global_entry->common;

1557

flags = tt_common_entry->flags;

1557

flags = tt_common_entry->flags;

1558

1559

best_entry = batadv_transtable_best_orig(bat_priv, tt_global_entry);

1559

best_entry = batadv_transtable_best_orig(bat_priv, tt_global_entry);

1560

if (best_entry) {

1560

if (best_entry) {

1561

vlan = batadv_orig_node_vlan_get(best_entry->orig_node,

1561

vlan = batadv_orig_node_vlan_get(best_entry->orig_node,

1562

tt_common_entry->vid);

1562

tt_common_entry->vid);

1563

if (!vlan) {

1563

if (!vlan) {

1564

seq_printf(seq,

1564

seq_printf(seq,

1565

" * Cannot retrieve VLAN %d for originator %pM\n",

1565

" * Cannot retrieve VLAN %d for originator %pM\n",

1566

BATADV_PRINT_VID(tt_common_entry->vid),

1566

BATADV_PRINT_VID(tt_common_entry->vid),

1567

best_entry->orig_node->orig);

1567

best_entry->orig_node->orig);

1568

goto print_list;

1568

goto print_list;

1569

}

1569

}

1570

1571

last_ttvn = atomic_read(&best_entry->orig_node->last_ttvn);

1571

last_ttvn = atomic_read(&best_entry->orig_node->last_ttvn);

1572

seq_printf(seq,

1572

seq_printf(seq,

1573

" %c %pM %4i (%3u) via %pM (%3u) (%#.8x) [%c%c%c%c]\n",

1573

" %c %pM %4i (%3u) via %pM (%3u) (%#.8x) [%c%c%c%c]\n",

1574

'*', tt_global_entry->common.addr,

1574

'*', tt_global_entry->common.addr,

1575

BATADV_PRINT_VID(tt_global_entry->common.vid),

1575

BATADV_PRINT_VID(tt_global_entry->common.vid),

1576

best_entry->ttvn, best_entry->orig_node->orig,

1576

best_entry->ttvn, best_entry->orig_node->orig,

1577

last_ttvn, vlan->tt.crc,

1577

last_ttvn, vlan->tt.crc,

1578

((flags & BATADV_TT_CLIENT_ROAM) ? 'R' : '.'),

1578

((flags & BATADV_TT_CLIENT_ROAM) ? 'R' : '.'),

1579

((flags & BATADV_TT_CLIENT_WIFI) ? 'W' : '.'),

1579

((flags & BATADV_TT_CLIENT_WIFI) ? 'W' : '.'),

1580

((flags & BATADV_TT_CLIENT_ISOLA) ? 'I' : '.'),

1580

((flags & BATADV_TT_CLIENT_ISOLA) ? 'I' : '.'),

1581

((flags & BATADV_TT_CLIENT_TEMP) ? 'T' : '.'));

1581

((flags & BATADV_TT_CLIENT_TEMP) ? 'T' : '.'));

1582

1583

batadv_orig_node_vlan_free_ref(vlan);

1583

batadv_orig_node_vlan_free_ref(vlan);

1584

}

1584

}

1585

1586

print_list:

1586

print_list:

1587

head = &tt_global_entry->orig_list;

1587

head = &tt_global_entry->orig_list;

1588

1589

hlist_for_each_entry_rcu(orig_entry, head, list) {

1589

hlist_for_each_entry_rcu(orig_entry, head, list) {

1590

if (best_entry == orig_entry)

1590

if (best_entry == orig_entry)

1591

continue;

1591

continue;

1592

1593

vlan = batadv_orig_node_vlan_get(orig_entry->orig_node,

1593

vlan = batadv_orig_node_vlan_get(orig_entry->orig_node,

1594

tt_common_entry->vid);

1594

tt_common_entry->vid);

1595

if (!vlan) {

1595

if (!vlan) {

1596

seq_printf(seq,

1596

seq_printf(seq,

1597

" + Cannot retrieve VLAN %d for originator %pM\n",

1597

" + Cannot retrieve VLAN %d for originator %pM\n",

1598

BATADV_PRINT_VID(tt_common_entry->vid),

1598

BATADV_PRINT_VID(tt_common_entry->vid),

1599

orig_entry->orig_node->orig);

1599

orig_entry->orig_node->orig);

1600

continue;

1600

continue;

1601

}

1601

}

1602

1603

last_ttvn = atomic_read(&orig_entry->orig_node->last_ttvn);

1603

last_ttvn = atomic_read(&orig_entry->orig_node->last_ttvn);

1604

seq_printf(seq,

1604

seq_printf(seq,

1605

" %c %pM %4d (%3u) via %pM (%3u) (%#.8x) [%c%c%c%c]\n",

1605

" %c %pM %4d (%3u) via %pM (%3u) (%#.8x) [%c%c%c%c]\n",

1606

'+', tt_global_entry->common.addr,

1606

'+', tt_global_entry->common.addr,

1607

BATADV_PRINT_VID(tt_global_entry->common.vid),

1607

BATADV_PRINT_VID(tt_global_entry->common.vid),

1608

orig_entry->ttvn, orig_entry->orig_node->orig,

1608

orig_entry->ttvn, orig_entry->orig_node->orig,

1609

last_ttvn, vlan->tt.crc,

1609

last_ttvn, vlan->tt.crc,

1610

((flags & BATADV_TT_CLIENT_ROAM) ? 'R' : '.'),

1610

((flags & BATADV_TT_CLIENT_ROAM) ? 'R' : '.'),

1611

((flags & BATADV_TT_CLIENT_WIFI) ? 'W' : '.'),

1611

((flags & BATADV_TT_CLIENT_WIFI) ? 'W' : '.'),

1612

((flags & BATADV_TT_CLIENT_ISOLA) ? 'I' : '.'),

1612

((flags & BATADV_TT_CLIENT_ISOLA) ? 'I' : '.'),

1613

((flags & BATADV_TT_CLIENT_TEMP) ? 'T' : '.'));

1613

((flags & BATADV_TT_CLIENT_TEMP) ? 'T' : '.'));

1614

1615

batadv_orig_node_vlan_free_ref(vlan);

1615

batadv_orig_node_vlan_free_ref(vlan);

1616

}

1616

}

1617

}

1617

}

1618

1619

int batadv_tt_global_seq_print_text(struct seq_file *seq, void *offset)

1619

int batadv_tt_global_seq_print_text(struct seq_file *seq, void *offset)

1620

{

1620

{

1621

struct net_device *net_dev = (struct net_device *)seq->private;

1621

struct net_device *net_dev = (struct net_device *)seq->private;

1622

struct batadv_priv *bat_priv = netdev_priv(net_dev);

1622

struct batadv_priv *bat_priv = netdev_priv(net_dev);

1623

struct batadv_hashtable *hash = bat_priv->tt.global_hash;

1623

struct batadv_hashtable *hash = bat_priv->tt.global_hash;

1624

struct batadv_tt_common_entry *tt_common_entry;

1624

struct batadv_tt_common_entry *tt_common_entry;

1625

struct batadv_tt_global_entry *tt_global;

1625

struct batadv_tt_global_entry *tt_global;

1626

struct batadv_hard_iface *primary_if;

1626

struct batadv_hard_iface *primary_if;

1627

struct hlist_head *head;

1627

struct hlist_head *head;

1628

u32 i;

1628

u32 i;

1629

1630

primary_if = batadv_seq_print_text_primary_if_get(seq);

1630

primary_if = batadv_seq_print_text_primary_if_get(seq);

1631

if (!primary_if)

1631

if (!primary_if)

1632

goto out;

1632

goto out;

1633

1634

seq_printf(seq,

1634

seq_printf(seq,

1635

"Globally announced TT entries received via the mesh %s\n",

1635

"Globally announced TT entries received via the mesh %s\n",

1636

net_dev->name);

1636

net_dev->name);

1637

seq_printf(seq, " %-13s %s %s %-15s %s (%-10s) %s\n",

1637

seq_printf(seq, " %-13s %s %s %-15s %s (%-10s) %s\n",

1638

"Client", "VID", "(TTVN)", "Originator", "(Curr TTVN)",

1638

"Client", "VID", "(TTVN)", "Originator", "(Curr TTVN)",

1639

"CRC", "Flags");

1639

"CRC", "Flags");

1640

1641

for (i = 0; i < hash->size; i++) {

1641

for (i = 0; i < hash->size; i++) {

1642

head = &hash->table[i];

1642

head = &hash->table[i];

1643

1644

rcu_read_lock();

1644

rcu_read_lock();

1645

hlist_for_each_entry_rcu(tt_common_entry,

1645

hlist_for_each_entry_rcu(tt_common_entry,

1646

head, hash_entry) {

1646

head, hash_entry) {

1647

tt_global = container_of(tt_common_entry,

1647

tt_global = container_of(tt_common_entry,

1648

struct batadv_tt_global_entry,

1648

struct batadv_tt_global_entry,

1649

common);

1649

common);

1650

batadv_tt_global_print_entry(bat_priv, tt_global, seq);

1650

batadv_tt_global_print_entry(bat_priv, tt_global, seq);

1651

}

1651

}

1652

rcu_read_unlock();

1652

rcu_read_unlock();

1653

}

1653

}

1654

out:

1654

out:

1655

if (primary_if)

1655

if (primary_if)

1656

batadv_hardif_free_ref(primary_if);

1656

batadv_hardif_free_ref(primary_if);

1657

return 0;

1657

return 0;

1658

}

1658

}

1659

1660

/**

1660

/**

1661

* _batadv_tt_global_del_orig_entry - remove and free an orig_entry

1661

* _batadv_tt_global_del_orig_entry - remove and free an orig_entry

1662

* @tt_global_entry: the global entry to remove the orig_entry from

1662

* @tt_global_entry: the global entry to remove the orig_entry from

1663

* @orig_entry: the orig entry to remove and free

1663

* @orig_entry: the orig entry to remove and free

1664

*

1664

*

1665

* Remove an orig_entry from its list in the given tt_global_entry and

1665

* Remove an orig_entry from its list in the given tt_global_entry and

1666

* free this orig_entry afterwards.

1666

* free this orig_entry afterwards.

1667

*

1667

*

1668

* Caller must hold tt_global_entry->list_lock and ensure orig_entry->list is

1668

* Caller must hold tt_global_entry->list_lock and ensure orig_entry->list is

1669

* part of a list.

1669

* part of a list.

1670

*/

1670

*/

1671

static void

1671

static void

1672

_batadv_tt_global_del_orig_entry(struct batadv_tt_global_entry *tt_global_entry,

1672

_batadv_tt_global_del_orig_entry(struct batadv_tt_global_entry *tt_global_entry,

1673

struct batadv_tt_orig_list_entry *orig_entry)

1673

struct batadv_tt_orig_list_entry *orig_entry)

1674

{

1674

{

1675

batadv_tt_global_size_dec(orig_entry->orig_node,

1675

batadv_tt_global_size_dec(orig_entry->orig_node,

1676

tt_global_entry->common.vid);

1676

tt_global_entry->common.vid);

1677

atomic_dec(&tt_global_entry->orig_list_count);

1677

atomic_dec(&tt_global_entry->orig_list_count);

1678

/* requires holding tt_global_entry->list_lock and orig_entry->list

1678

/* requires holding tt_global_entry->list_lock and orig_entry->list

1679

* being part of a list

1679

* being part of a list

1680

*/

1680

*/

1681

hlist_del_rcu(&orig_entry->list);

1681

hlist_del_rcu(&orig_entry->list);

1682

batadv_tt_orig_list_entry_free_ref(orig_entry);

1682

batadv_tt_orig_list_entry_free_ref(orig_entry);

1683

}

1683

}

1684

1685

/* deletes the orig list of a tt_global_entry */

1685

/* deletes the orig list of a tt_global_entry */

1686

static void

1686

static void

1687

batadv_tt_global_del_orig_list(struct batadv_tt_global_entry *tt_global_entry)

1687

batadv_tt_global_del_orig_list(struct batadv_tt_global_entry *tt_global_entry)

1688

{

1688

{

1689

struct hlist_head *head;

1689

struct hlist_head *head;

1690

struct hlist_node *safe;

1690

struct hlist_node *safe;

1691

struct batadv_tt_orig_list_entry *orig_entry;

1691

struct batadv_tt_orig_list_entry *orig_entry;

1692

1693

spin_lock_bh(&tt_global_entry->list_lock);

1693

spin_lock_bh(&tt_global_entry->list_lock);

1694

head = &tt_global_entry->orig_list;

1694

head = &tt_global_entry->orig_list;

1695

hlist_for_each_entry_safe(orig_entry, safe, head, list)

1695

hlist_for_each_entry_safe(orig_entry, safe, head, list)

1696

_batadv_tt_global_del_orig_entry(tt_global_entry, orig_entry);

1696

_batadv_tt_global_del_orig_entry(tt_global_entry, orig_entry);

1697

spin_unlock_bh(&tt_global_entry->list_lock);

1697

spin_unlock_bh(&tt_global_entry->list_lock);

1698

}

1698

}

1699

1700

/**

1700

/**

1701

* batadv_tt_global_del_orig_node - remove orig_node from a global tt entry

1701

* batadv_tt_global_del_orig_node - remove orig_node from a global tt entry

1702

* @bat_priv: the bat priv with all the soft interface information

1702

* @bat_priv: the bat priv with all the soft interface information

1703

* @tt_global_entry: the global entry to remove the orig_node from

1703

* @tt_global_entry: the global entry to remove the orig_node from

1704

* @orig_node: the originator announcing the client

1704

* @orig_node: the originator announcing the client

1705

* @message: message to append to the log on deletion

1705

* @message: message to append to the log on deletion

1706

*

1706

*

1707

* Remove the given orig_node and its according orig_entry from the given

1707

* Remove the given orig_node and its according orig_entry from the given

1708

* global tt entry.

1708

* global tt entry.

1709

*/

1709

*/

1710

static void

1710

static void

1711

batadv_tt_global_del_orig_node(struct batadv_priv *bat_priv,

1711

batadv_tt_global_del_orig_node(struct batadv_priv *bat_priv,

1712

struct batadv_tt_global_entry *tt_global_entry,

1712

struct batadv_tt_global_entry *tt_global_entry,

1713

struct batadv_orig_node *orig_node,

1713

struct batadv_orig_node *orig_node,

1714

const char *message)

1714

const char *message)

1715

{

1715

{

1716

struct hlist_head *head;

1716

struct hlist_head *head;

1717

struct hlist_node *safe;

1717

struct hlist_node *safe;

1718

struct batadv_tt_orig_list_entry *orig_entry;

1718

struct batadv_tt_orig_list_entry *orig_entry;

1719

unsigned short vid;

1719

unsigned short vid;

1720

1721

spin_lock_bh(&tt_global_entry->list_lock);

1721

spin_lock_bh(&tt_global_entry->list_lock);

1722

head = &tt_global_entry->orig_list;

1722

head = &tt_global_entry->orig_list;

1723

hlist_for_each_entry_safe(orig_entry, safe, head, list) {

1723

hlist_for_each_entry_safe(orig_entry, safe, head, list) {

1724

if (orig_entry->orig_node == orig_node) {

1724

if (orig_entry->orig_node == orig_node) {

1725

vid = tt_global_entry->common.vid;

1725

vid = tt_global_entry->common.vid;

1726

batadv_dbg(BATADV_DBG_TT, bat_priv,

1726

batadv_dbg(BATADV_DBG_TT, bat_priv,

1727

"Deleting %pM from global tt entry %pM (vid: %d): %s\n",

1727

"Deleting %pM from global tt entry %pM (vid: %d): %s\n",

1728

orig_node->orig,

1728

orig_node->orig,

1729

tt_global_entry->common.addr,

1729

tt_global_entry->common.addr,

1730

BATADV_PRINT_VID(vid), message);

1730

BATADV_PRINT_VID(vid), message);

1731

_batadv_tt_global_del_orig_entry(tt_global_entry,

1731

_batadv_tt_global_del_orig_entry(tt_global_entry,

1732

orig_entry);

1732

orig_entry);

1733

}

1733

}

1734

}

1734

}

1735

spin_unlock_bh(&tt_global_entry->list_lock);

1735

spin_unlock_bh(&tt_global_entry->list_lock);

1736

}

1736

}

1737

1738

/* If the client is to be deleted, we check if it is the last origantor entry

1738

/* If the client is to be deleted, we check if it is the last origantor entry

1739

* within tt_global entry. If yes, we set the BATADV_TT_CLIENT_ROAM flag and the

1739

* within tt_global entry. If yes, we set the BATADV_TT_CLIENT_ROAM flag and the

1740

* timer, otherwise we simply remove the originator scheduled for deletion.

1740

* timer, otherwise we simply remove the originator scheduled for deletion.

1741

*/

1741

*/

1742

static void

1742

static void

1743

batadv_tt_global_del_roaming(struct batadv_priv *bat_priv,

1743

batadv_tt_global_del_roaming(struct batadv_priv *bat_priv,

1744

struct batadv_tt_global_entry *tt_global_entry,

1744

struct batadv_tt_global_entry *tt_global_entry,

1745

struct batadv_orig_node *orig_node,

1745

struct batadv_orig_node *orig_node,

1746

const char *message)

1746

const char *message)

1747

{

1747

{

1748

bool last_entry = true;

1748

bool last_entry = true;

1749

struct hlist_head *head;

1749

struct hlist_head *head;

1750

struct batadv_tt_orig_list_entry *orig_entry;

1750

struct batadv_tt_orig_list_entry *orig_entry;

1751

1752

/* no local entry exists, case 1:

1752

/* no local entry exists, case 1:

1753

* Check if this is the last one or if other entries exist.

1753

* Check if this is the last one or if other entries exist.

1754

*/

1754

*/

1755

1756

rcu_read_lock();

1756

rcu_read_lock();

1757

head = &tt_global_entry->orig_list;

1757

head = &tt_global_entry->orig_list;

1758

hlist_for_each_entry_rcu(orig_entry, head, list) {

1758

hlist_for_each_entry_rcu(orig_entry, head, list) {

1759

if (orig_entry->orig_node != orig_node) {

1759

if (orig_entry->orig_node != orig_node) {

1760

last_entry = false;

1760

last_entry = false;

1761

break;

1761

break;

1762

}

1762

}

1763

}

1763

}

1764

rcu_read_unlock();

1764

rcu_read_unlock();

1765

1766

if (last_entry) {

1766

if (last_entry) {

1767

/* its the last one, mark for roaming. */

1767

/* its the last one, mark for roaming. */

1768

tt_global_entry->common.flags |= BATADV_TT_CLIENT_ROAM;

1768

tt_global_entry->common.flags |= BATADV_TT_CLIENT_ROAM;

1769

tt_global_entry->roam_at = jiffies;

1769

tt_global_entry->roam_at = jiffies;

1770

} else

1770

} else

1771

/* there is another entry, we can simply delete this

1771

/* there is another entry, we can simply delete this

1772

* one and can still use the other one.

1772

* one and can still use the other one.

1773

*/

1773

*/

1774

batadv_tt_global_del_orig_node(bat_priv, tt_global_entry,

1774

batadv_tt_global_del_orig_node(bat_priv, tt_global_entry,

1775

orig_node, message);

1775

orig_node, message);

1776

}

1776

}

1777

1778

/**

1778

/**

1779

* batadv_tt_global_del - remove a client from the global table

1779

* batadv_tt_global_del - remove a client from the global table

1780

* @bat_priv: the bat priv with all the soft interface information

1780

* @bat_priv: the bat priv with all the soft interface information

1781

* @orig_node: an originator serving this client

1781

* @orig_node: an originator serving this client

1782

* @addr: the mac address of the client

1782

* @addr: the mac address of the client

1783

* @vid: VLAN identifier

1783

* @vid: VLAN identifier

1784

* @message: a message explaining the reason for deleting the client to print

1784

* @message: a message explaining the reason for deleting the client to print

1785

* for debugging purpose

1785

* for debugging purpose

1786

* @roaming: true if the deletion has been triggered by a roaming event

1786

* @roaming: true if the deletion has been triggered by a roaming event

1787

*/

1787

*/

1788

static void batadv_tt_global_del(struct batadv_priv *bat_priv,

1788

static void batadv_tt_global_del(struct batadv_priv *bat_priv,

1789

struct batadv_orig_node *orig_node,

1789

struct batadv_orig_node *orig_node,

1790

const unsigned char *addr, unsigned short vid,

1790

const unsigned char *addr, unsigned short vid,

1791

const char *message, bool roaming)

1791

const char *message, bool roaming)

1792

{

1792

{

1793

struct batadv_tt_global_entry *tt_global_entry;

1793

struct batadv_tt_global_entry *tt_global_entry;

1794

struct batadv_tt_local_entry *local_entry = NULL;

1794

struct batadv_tt_local_entry *local_entry = NULL;

1795

1796

tt_global_entry = batadv_tt_global_hash_find(bat_priv, addr, vid);

1796

tt_global_entry = batadv_tt_global_hash_find(bat_priv, addr, vid);

1797

if (!tt_global_entry)

1797

if (!tt_global_entry)

1798

goto out;

1798

goto out;

1799

1800

if (!roaming) {

1800

if (!roaming) {

1801

batadv_tt_global_del_orig_node(bat_priv, tt_global_entry,

1801

batadv_tt_global_del_orig_node(bat_priv, tt_global_entry,

1802

orig_node, message);

1802

orig_node, message);

1803

1804

if (hlist_empty(&tt_global_entry->orig_list))

1804

if (hlist_empty(&tt_global_entry->orig_list))

1805

batadv_tt_global_free(bat_priv, tt_global_entry,

1805

batadv_tt_global_free(bat_priv, tt_global_entry,

1806

message);

1806

message);

1807

1808

goto out;

1808

goto out;

1809

}

1809

}

1810

1811

/* if we are deleting a global entry due to a roam

1811

/* if we are deleting a global entry due to a roam

1812

* event, there are two possibilities:

1812

* event, there are two possibilities:

1813

* 1) the client roamed from node A to node B => if there

1813

* 1) the client roamed from node A to node B => if there

1814

* is only one originator left for this client, we mark

1814

* is only one originator left for this client, we mark

1815

* it with BATADV_TT_CLIENT_ROAM, we start a timer and we

1815

* it with BATADV_TT_CLIENT_ROAM, we start a timer and we

1816

* wait for node B to claim it. In case of timeout

1816

* wait for node B to claim it. In case of timeout

1817

* the entry is purged.

1817

* the entry is purged.

1818

*

1818

*

1819

* If there are other originators left, we directly delete

1819

* If there are other originators left, we directly delete

1820

* the originator.

1820

* the originator.

1821

* 2) the client roamed to us => we can directly delete

1821

* 2) the client roamed to us => we can directly delete

1822

* the global entry, since it is useless now.

1822

* the global entry, since it is useless now.

1823

*/

1823

*/

1824

local_entry = batadv_tt_local_hash_find(bat_priv,

1824

local_entry = batadv_tt_local_hash_find(bat_priv,

1825

tt_global_entry->common.addr,

1825

tt_global_entry->common.addr,

1826

vid);

1826

vid);

1827

if (local_entry) {

1827

if (local_entry) {

1828

/* local entry exists, case 2: client roamed to us. */

1828

/* local entry exists, case 2: client roamed to us. */

1829

batadv_tt_global_del_orig_list(tt_global_entry);

1829

batadv_tt_global_del_orig_list(tt_global_entry);

1830

batadv_tt_global_free(bat_priv, tt_global_entry, message);

1830

batadv_tt_global_free(bat_priv, tt_global_entry, message);

1831

} else

1831

} else

1832

/* no local entry exists, case 1: check for roaming */

1832

/* no local entry exists, case 1: check for roaming */

1833

batadv_tt_global_del_roaming(bat_priv, tt_global_entry,

1833

batadv_tt_global_del_roaming(bat_priv, tt_global_entry,

1834

orig_node, message);

1834

orig_node, message);

1835

1836

out:

1836

out:

1837

if (tt_global_entry)

1837

if (tt_global_entry)

1838

batadv_tt_global_entry_free_ref(tt_global_entry);

1838

batadv_tt_global_entry_free_ref(tt_global_entry);

1839

if (local_entry)

1839

if (local_entry)

1840

batadv_tt_local_entry_free_ref(local_entry);

1840

batadv_tt_local_entry_free_ref(local_entry);

1841

}

1841

}

1842

1843

/**

1843

/**

1844

* batadv_tt_global_del_orig - remove all the TT global entries belonging to the

1844

* batadv_tt_global_del_orig - remove all the TT global entries belonging to the

1845

* given originator matching the provided vid

1845

* given originator matching the provided vid

1846

* @bat_priv: the bat priv with all the soft interface information

1846

* @bat_priv: the bat priv with all the soft interface information

1847

* @orig_node: the originator owning the entries to remove

1847

* @orig_node: the originator owning the entries to remove

1848

* @match_vid: the VLAN identifier to match. If negative all the entries will be

1848

* @match_vid: the VLAN identifier to match. If negative all the entries will be

1849

* removed

1849

* removed

1850

* @message: debug message to print as "reason"

1850

* @message: debug message to print as "reason"

1851

*/

1851

*/

1852

void batadv_tt_global_del_orig(struct batadv_priv *bat_priv,

1852

void batadv_tt_global_del_orig(struct batadv_priv *bat_priv,

1853

struct batadv_orig_node *orig_node,

1853

struct batadv_orig_node *orig_node,

1854

s32 match_vid,

1854

s32 match_vid,

1855

const char *message)

1855

const char *message)

1856

{

1856

{

1857

struct batadv_tt_global_entry *tt_global;

1857

struct batadv_tt_global_entry *tt_global;

1858

struct batadv_tt_common_entry *tt_common_entry;

1858

struct batadv_tt_common_entry *tt_common_entry;

1859

u32 i;

1859

u32 i;

1860

struct batadv_hashtable *hash = bat_priv->tt.global_hash;

1860

struct batadv_hashtable *hash = bat_priv->tt.global_hash;

1861

struct hlist_node *safe;

1861

struct hlist_node *safe;

1862

struct hlist_head *head;

1862

struct hlist_head *head;

1863

spinlock_t *list_lock; /* protects write access to the hash lists */

1863

spinlock_t *list_lock; /* protects write access to the hash lists */

1864

unsigned short vid;

1864

unsigned short vid;

1865

1866

if (!hash)

1866

if (!hash)

1867

return;

1867

return;

1868

1869

for (i = 0; i < hash->size; i++) {

1869

for (i = 0; i < hash->size; i++) {

1870

head = &hash->table[i];

1870

head = &hash->table[i];

1871

list_lock = &hash->list_locks[i];

1871

list_lock = &hash->list_locks[i];

1872

1873

spin_lock_bh(list_lock);

1873

spin_lock_bh(list_lock);

1874

hlist_for_each_entry_safe(tt_common_entry, safe,

1874

hlist_for_each_entry_safe(tt_common_entry, safe,

1875

head, hash_entry) {

1875

head, hash_entry) {

1876

/* remove only matching entries */

1876

/* remove only matching entries */

1877

if (match_vid >= 0 && tt_common_entry->vid != match_vid)

1877

if (match_vid >= 0 && tt_common_entry->vid != match_vid)

1878

continue;

1878

continue;

1879

1880

tt_global = container_of(tt_common_entry,

1880

tt_global = container_of(tt_common_entry,

1881

struct batadv_tt_global_entry,

1881

struct batadv_tt_global_entry,

1882

common);

1882

common);

1883

1884

batadv_tt_global_del_orig_node(bat_priv, tt_global,

1884

batadv_tt_global_del_orig_node(bat_priv, tt_global,

1885

orig_node, message);

1885

orig_node, message);

1886

1887

if (hlist_empty(&tt_global->orig_list)) {

1887

if (hlist_empty(&tt_global->orig_list)) {

1888

vid = tt_global->common.vid;

1888

vid = tt_global->common.vid;

1889

batadv_dbg(BATADV_DBG_TT, bat_priv,

1889

batadv_dbg(BATADV_DBG_TT, bat_priv,

1890

"Deleting global tt entry %pM (vid: %d): %s\n",

1890

"Deleting global tt entry %pM (vid: %d): %s\n",

1891

tt_global->common.addr,

1891

tt_global->common.addr,

1892

BATADV_PRINT_VID(vid), message);

1892

BATADV_PRINT_VID(vid), message);

1893

hlist_del_rcu(&tt_common_entry->hash_entry);

1893

hlist_del_rcu(&tt_common_entry->hash_entry);

1894

batadv_tt_global_entry_free_ref(tt_global);

1894

batadv_tt_global_entry_free_ref(tt_global);

1895

}

1895

}

1896

}

1896

}

1897

spin_unlock_bh(list_lock);

1897

spin_unlock_bh(list_lock);

1898

}

1898

}

1899

clear_bit(BATADV_ORIG_CAPA_HAS_TT, &orig_node->capa_initialized);

1899

clear_bit(BATADV_ORIG_CAPA_HAS_TT, &orig_node->capa_initialized);

1900

}

1900

}

1901

1902

static bool batadv_tt_global_to_purge(struct batadv_tt_global_entry *tt_global,

1902

static bool batadv_tt_global_to_purge(struct batadv_tt_global_entry *tt_global,

1903

char **msg)

1903

char **msg)

1904

{

1904

{

1905

bool purge = false;

1905

bool purge = false;

1906

unsigned long roam_timeout = BATADV_TT_CLIENT_ROAM_TIMEOUT;

1906

unsigned long roam_timeout = BATADV_TT_CLIENT_ROAM_TIMEOUT;

1907

unsigned long temp_timeout = BATADV_TT_CLIENT_TEMP_TIMEOUT;

1907

unsigned long temp_timeout = BATADV_TT_CLIENT_TEMP_TIMEOUT;

1908

1909

if ((tt_global->common.flags & BATADV_TT_CLIENT_ROAM) &&

1909

if ((tt_global->common.flags & BATADV_TT_CLIENT_ROAM) &&

1910

batadv_has_timed_out(tt_global->roam_at, roam_timeout)) {

1910

batadv_has_timed_out(tt_global->roam_at, roam_timeout)) {

1911

purge = true;

1911

purge = true;

1912

*msg = "Roaming timeout\n";

1912

*msg = "Roaming timeout\n";

1913

}

1913

}

1914

1915

if ((tt_global->common.flags & BATADV_TT_CLIENT_TEMP) &&

1915

if ((tt_global->common.flags & BATADV_TT_CLIENT_TEMP) &&

1916

batadv_has_timed_out(tt_global->common.added_at, temp_timeout)) {

1916

batadv_has_timed_out(tt_global->common.added_at, temp_timeout)) {

1917

purge = true;

1917

purge = true;

1918

*msg = "Temporary client timeout\n";

1918

*msg = "Temporary client timeout\n";

1919

}

1919

}

1920

1921

return purge;

1921

return purge;

1922

}

1922

}

1923

1924

static void batadv_tt_global_purge(struct batadv_priv *bat_priv)

1924

static void batadv_tt_global_purge(struct batadv_priv *bat_priv)

1925

{

1925

{

1926

struct batadv_hashtable *hash = bat_priv->tt.global_hash;

1926

struct batadv_hashtable *hash = bat_priv->tt.global_hash;

1927

struct hlist_head *head;

1927

struct hlist_head *head;

1928

struct hlist_node *node_tmp;

1928

struct hlist_node *node_tmp;

1929

spinlock_t *list_lock; /* protects write access to the hash lists */

1929

spinlock_t *list_lock; /* protects write access to the hash lists */

1930

u32 i;

1930

u32 i;

1931

char *msg = NULL;

1931

char *msg = NULL;

1932

struct batadv_tt_common_entry *tt_common;

1932

struct batadv_tt_common_entry *tt_common;

1933

struct batadv_tt_global_entry *tt_global;

1933

struct batadv_tt_global_entry *tt_global;

1934

1935

for (i = 0; i < hash->size; i++) {

1935

for (i = 0; i < hash->size; i++) {

1936

head = &hash->table[i];

1936

head = &hash->table[i];

1937

list_lock = &hash->list_locks[i];

1937

list_lock = &hash->list_locks[i];

1938

1939

spin_lock_bh(list_lock);

1939

spin_lock_bh(list_lock);

1940

hlist_for_each_entry_safe(tt_common, node_tmp, head,

1940

hlist_for_each_entry_safe(tt_common, node_tmp, head,

1941

hash_entry) {

1941

hash_entry) {

1942

tt_global = container_of(tt_common,

1942

tt_global = container_of(tt_common,

1943

struct batadv_tt_global_entry,

1943

struct batadv_tt_global_entry,

1944

common);

1944

common);

1945

1946

if (!batadv_tt_global_to_purge(tt_global, &msg))

1946

if (!batadv_tt_global_to_purge(tt_global, &msg))

1947

continue;

1947

continue;

1948

1949

batadv_dbg(BATADV_DBG_TT, bat_priv,

1949

batadv_dbg(BATADV_DBG_TT, bat_priv,

1950

"Deleting global tt entry %pM (vid: %d): %s\n",

1950

"Deleting global tt entry %pM (vid: %d): %s\n",

1951

tt_global->common.addr,

1951

tt_global->common.addr,

1952

BATADV_PRINT_VID(tt_global->common.vid),

1952

BATADV_PRINT_VID(tt_global->common.vid),

1953

msg);

1953

msg);

1954

1955

hlist_del_rcu(&tt_common->hash_entry);

1955

hlist_del_rcu(&tt_common->hash_entry);

1956

1957

batadv_tt_global_entry_free_ref(tt_global);

1957

batadv_tt_global_entry_free_ref(tt_global);

1958

}

1958

}

1959

spin_unlock_bh(list_lock);

1959

spin_unlock_bh(list_lock);

1960

}

1960

}

1961

}

1961

}

1962

1963

static void batadv_tt_global_table_free(struct batadv_priv *bat_priv)

1963

static void batadv_tt_global_table_free(struct batadv_priv *bat_priv)

1964

{

1964

{

1965

struct batadv_hashtable *hash;

1965

struct batadv_hashtable *hash;

1966

spinlock_t *list_lock; /* protects write access to the hash lists */

1966

spinlock_t *list_lock; /* protects write access to the hash lists */

1967

struct batadv_tt_common_entry *tt_common_entry;

1967

struct batadv_tt_common_entry *tt_common_entry;

1968

struct batadv_tt_global_entry *tt_global;

1968

struct batadv_tt_global_entry *tt_global;

1969

struct hlist_node *node_tmp;

1969

struct hlist_node *node_tmp;

1970

struct hlist_head *head;

1970

struct hlist_head *head;

1971

u32 i;

1971

u32 i;

1972

1973

if (!bat_priv->tt.global_hash)

1973

if (!bat_priv->tt.global_hash)

1974

return;

1974

return;

1975

1976

hash = bat_priv->tt.global_hash;

1976

hash = bat_priv->tt.global_hash;

1977

1978

for (i = 0; i < hash->size; i++) {

1978

for (i = 0; i < hash->size; i++) {

1979

head = &hash->table[i];

1979

head = &hash->table[i];

1980

list_lock = &hash->list_locks[i];

1980

list_lock = &hash->list_locks[i];

1981

1982

spin_lock_bh(list_lock);

1982

spin_lock_bh(list_lock);

1983

hlist_for_each_entry_safe(tt_common_entry, node_tmp,

1983

hlist_for_each_entry_safe(tt_common_entry, node_tmp,

1984

head, hash_entry) {

1984

head, hash_entry) {

1985

hlist_del_rcu(&tt_common_entry->hash_entry);

1985

hlist_del_rcu(&tt_common_entry->hash_entry);

1986

tt_global = container_of(tt_common_entry,

1986

tt_global = container_of(tt_common_entry,

1987

struct batadv_tt_global_entry,

1987

struct batadv_tt_global_entry,

1988

common);

1988

common);

1989

batadv_tt_global_entry_free_ref(tt_global);

1989

batadv_tt_global_entry_free_ref(tt_global);

1990

}

1990

}

1991

spin_unlock_bh(list_lock);

1991

spin_unlock_bh(list_lock);

1992

}

1992

}

1993

1994

batadv_hash_destroy(hash);

1994

batadv_hash_destroy(hash);

1995

1996

bat_priv->tt.global_hash = NULL;

1996

bat_priv->tt.global_hash = NULL;

1997

}

1997

}

1998

1999

static bool

1999

static bool

2000

_batadv_is_ap_isolated(struct batadv_tt_local_entry *tt_local_entry,

2000

_batadv_is_ap_isolated(struct batadv_tt_local_entry *tt_local_entry,

2001

struct batadv_tt_global_entry *tt_global_entry)

2001

struct batadv_tt_global_entry *tt_global_entry)

2002

{

2002

{

2003

bool ret = false;

2003

bool ret = false;

2004

2005

if (tt_local_entry->common.flags & BATADV_TT_CLIENT_WIFI &&

2005

if (tt_local_entry->common.flags & BATADV_TT_CLIENT_WIFI &&

2006

tt_global_entry->common.flags & BATADV_TT_CLIENT_WIFI)

2006

tt_global_entry->common.flags & BATADV_TT_CLIENT_WIFI)

2007

ret = true;

2007

ret = true;

2008

2009

/* check if the two clients are marked as isolated */

2009

/* check if the two clients are marked as isolated */

2010

if (tt_local_entry->common.flags & BATADV_TT_CLIENT_ISOLA &&

2010

if (tt_local_entry->common.flags & BATADV_TT_CLIENT_ISOLA &&

2011

tt_global_entry->common.flags & BATADV_TT_CLIENT_ISOLA)

2011

tt_global_entry->common.flags & BATADV_TT_CLIENT_ISOLA)

2012

ret = true;

2012

ret = true;

2013

2014

return ret;

2014

return ret;

2015

}

2015

}

2016

2017

/**

2017

/**

2018

* batadv_transtable_search - get the mesh destination for a given client

2018

* batadv_transtable_search - get the mesh destination for a given client

2019

* @bat_priv: the bat priv with all the soft interface information

2019

* @bat_priv: the bat priv with all the soft interface information

2020

* @src: mac address of the source client

2020

* @src: mac address of the source client

2021

* @addr: mac address of the destination client

2021

* @addr: mac address of the destination client

2022

* @vid: VLAN identifier

2022

* @vid: VLAN identifier

2023

*

2023

*

2024

* Returns a pointer to the originator that was selected as destination in the

2024

* Returns a pointer to the originator that was selected as destination in the

2025

* mesh for contacting the client 'addr', NULL otherwise.

2025

* mesh for contacting the client 'addr', NULL otherwise.

2026

* In case of multiple originators serving the same client, the function returns

2026

* In case of multiple originators serving the same client, the function returns

2027

* the best one (best in terms of metric towards the destination node).

2027

* the best one (best in terms of metric towards the destination node).

2028

*

2028

*

2029

* If the two clients are AP isolated the function returns NULL.

2029

* If the two clients are AP isolated the function returns NULL.

2030

*/

2030

*/

2031

struct batadv_orig_node *batadv_transtable_search(struct batadv_priv *bat_priv,

2031

struct batadv_orig_node *batadv_transtable_search(struct batadv_priv *bat_priv,

2032

const u8 *src,

2032

const u8 *src,

2033

const u8 *addr,

2033

const u8 *addr,

2034

unsigned short vid)

2034

unsigned short vid)

2035

{

2035

{

2036

struct batadv_tt_local_entry *tt_local_entry = NULL;

2036

struct batadv_tt_local_entry *tt_local_entry = NULL;

2037

struct batadv_tt_global_entry *tt_global_entry = NULL;

2037

struct batadv_tt_global_entry *tt_global_entry = NULL;

2038

struct batadv_orig_node *orig_node = NULL;

2038

struct batadv_orig_node *orig_node = NULL;

2039

struct batadv_tt_orig_list_entry *best_entry;

2039

struct batadv_tt_orig_list_entry *best_entry;

2040

2041

if (src && batadv_vlan_ap_isola_get(bat_priv, vid)) {

2041

if (src && batadv_vlan_ap_isola_get(bat_priv, vid)) {

2042

tt_local_entry = batadv_tt_local_hash_find(bat_priv, src, vid);

2042

tt_local_entry = batadv_tt_local_hash_find(bat_priv, src, vid);

2043

if (!tt_local_entry ||

2043

if (!tt_local_entry ||

2044

(tt_local_entry->common.flags & BATADV_TT_CLIENT_PENDING))

2044

(tt_local_entry->common.flags & BATADV_TT_CLIENT_PENDING))

2045

goto out;

2045

goto out;

2046

}

2046

}

2047

2048

tt_global_entry = batadv_tt_global_hash_find(bat_priv, addr, vid);

2048

tt_global_entry = batadv_tt_global_hash_find(bat_priv, addr, vid);

2049

if (!tt_global_entry)

2049

if (!tt_global_entry)

2050

goto out;

2050

goto out;

2051

2052

/* check whether the clients should not communicate due to AP

2052

/* check whether the clients should not communicate due to AP

2053

* isolation

2053

* isolation

2054

*/

2054

*/

2055

if (tt_local_entry &&

2055

if (tt_local_entry &&

2056

_batadv_is_ap_isolated(tt_local_entry, tt_global_entry))

2056

_batadv_is_ap_isolated(tt_local_entry, tt_global_entry))

2057

goto out;

2057

goto out;

2058

2059

rcu_read_lock();

2059

rcu_read_lock();

2060

best_entry = batadv_transtable_best_orig(bat_priv, tt_global_entry);

2060

best_entry = batadv_transtable_best_orig(bat_priv, tt_global_entry);

2061

/* found anything? */

2061

/* found anything? */

2062

if (best_entry)

2062

if (best_entry)

2063

orig_node = best_entry->orig_node;

2063

orig_node = best_entry->orig_node;

2064

if (orig_node && !atomic_inc_not_zero(&orig_node->refcount))

2064

if (orig_node && !atomic_inc_not_zero(&orig_node->refcount))

2065

orig_node = NULL;

2065

orig_node = NULL;

2066

rcu_read_unlock();

2066

rcu_read_unlock();

2067

2068

out:

2068

out:

2069

if (tt_global_entry)

2069

if (tt_global_entry)

2070

batadv_tt_global_entry_free_ref(tt_global_entry);

2070

batadv_tt_global_entry_free_ref(tt_global_entry);

2071

if (tt_local_entry)

2071

if (tt_local_entry)

2072

batadv_tt_local_entry_free_ref(tt_local_entry);

2072

batadv_tt_local_entry_free_ref(tt_local_entry);

2073

2074

return orig_node;

2074

return orig_node;

2075

}

2075

}

2076

2077

/**

2077

/**

2078

* batadv_tt_global_crc - calculates the checksum of the local table belonging

2078

* batadv_tt_global_crc - calculates the checksum of the local table belonging

2079

* to the given orig_node

2079

* to the given orig_node

2080

* @bat_priv: the bat priv with all the soft interface information

2080

* @bat_priv: the bat priv with all the soft interface information

2081

* @orig_node: originator for which the CRC should be computed

2081

* @orig_node: originator for which the CRC should be computed

2082

* @vid: VLAN identifier for which the CRC32 has to be computed

2082

* @vid: VLAN identifier for which the CRC32 has to be computed

2083

*

2083

*

2084

* This function computes the checksum for the global table corresponding to a

2084

* This function computes the checksum for the global table corresponding to a

2085

* specific originator. In particular, the checksum is computed as follows: For

2085

* specific originator. In particular, the checksum is computed as follows: For

2086

* each client connected to the originator the CRC32C of the MAC address and the

2086

* each client connected to the originator the CRC32C of the MAC address and the

2087

* VID is computed and then all the CRC32Cs of the various clients are xor'ed

2087

* VID is computed and then all the CRC32Cs of the various clients are xor'ed

2088

* together.

2088

* together.

2089

*

2089

*

2090

* The idea behind is that CRC32C should be used as much as possible in order to

2090

* The idea behind is that CRC32C should be used as much as possible in order to

2091

* produce a unique hash of the table, but since the order which is used to feed

2091

* produce a unique hash of the table, but since the order which is used to feed

2092

* the CRC32C function affects the result and since every node in the network

2092

* the CRC32C function affects the result and since every node in the network

2093

* probably sorts the clients differently, the hash function cannot be directly

2093

* probably sorts the clients differently, the hash function cannot be directly

2094

* computed over the entire table. Hence the CRC32C is used only on

2094

* computed over the entire table. Hence the CRC32C is used only on

2095

* the single client entry, while all the results are then xor'ed together

2095

* the single client entry, while all the results are then xor'ed together

2096

* because the XOR operation can combine them all while trying to reduce the

2096

* because the XOR operation can combine them all while trying to reduce the

2097

* noise as much as possible.

2097

* noise as much as possible.

2098

*

2098

*

2099

* Returns the checksum of the global table of a given originator.

2099

* Returns the checksum of the global table of a given originator.

2100

*/

2100

*/

2101

static u32 batadv_tt_global_crc(struct batadv_priv *bat_priv,

2101

static u32 batadv_tt_global_crc(struct batadv_priv *bat_priv,

2102

struct batadv_orig_node *orig_node,

2102

struct batadv_orig_node *orig_node,

2103

unsigned short vid)

2103

unsigned short vid)

2104

{

2104

{

2105

struct batadv_hashtable *hash = bat_priv->tt.global_hash;

2105

struct batadv_hashtable *hash = bat_priv->tt.global_hash;

2106

struct batadv_tt_common_entry *tt_common;

2106

struct batadv_tt_common_entry *tt_common;

2107

struct batadv_tt_global_entry *tt_global;

2107

struct batadv_tt_global_entry *tt_global;

2108

struct hlist_head *head;

2108

struct hlist_head *head;

2109

u32 i, crc_tmp, crc = 0;

2109

u32 i, crc_tmp, crc = 0;

2110

u8 flags;

2110

u8 flags;

2111

__be16 tmp_vid;

2111

__be16 tmp_vid;

2112

2113

for (i = 0; i < hash->size; i++) {

2113

for (i = 0; i < hash->size; i++) {

2114

head = &hash->table[i];

2114

head = &hash->table[i];

2115

2116

rcu_read_lock();

2116

rcu_read_lock();

2117

hlist_for_each_entry_rcu(tt_common, head, hash_entry) {

2117

hlist_for_each_entry_rcu(tt_common, head, hash_entry) {

2118

tt_global = container_of(tt_common,

2118

tt_global = container_of(tt_common,

2119

struct batadv_tt_global_entry,

2119

struct batadv_tt_global_entry,

2120

common);

2120

common);

2121

/* compute the CRC only for entries belonging to the

2121

/* compute the CRC only for entries belonging to the

2122

* VLAN identified by the vid passed as parameter

2122

* VLAN identified by the vid passed as parameter

2123

*/

2123

*/

2124

if (tt_common->vid != vid)

2124

if (tt_common->vid != vid)

2125

continue;

2125

continue;

2126

2127

/* Roaming clients are in the global table for

2127

/* Roaming clients are in the global table for

2128

* consistency only. They don't have to be

2128

* consistency only. They don't have to be

2129

* taken into account while computing the

2129

* taken into account while computing the

2130

* global crc

2130

* global crc

2131

*/

2131

*/

2132

if (tt_common->flags & BATADV_TT_CLIENT_ROAM)

2132

if (tt_common->flags & BATADV_TT_CLIENT_ROAM)

2133

continue;

2133

continue;

2134

/* Temporary clients have not been announced yet, so

2134

/* Temporary clients have not been announced yet, so

2135

* they have to be skipped while computing the global

2135

* they have to be skipped while computing the global

2136

* crc

2136

* crc

2137

*/

2137

*/

2138

if (tt_common->flags & BATADV_TT_CLIENT_TEMP)

2138

if (tt_common->flags & BATADV_TT_CLIENT_TEMP)

2139

continue;

2139

continue;

2140

2141

/* find out if this global entry is announced by this

2141

/* find out if this global entry is announced by this

2142

* originator

2142

* originator

2143

*/

2143

*/

2144

if (!batadv_tt_global_entry_has_orig(tt_global,

2144

if (!batadv_tt_global_entry_has_orig(tt_global,

2145

orig_node))

2145

orig_node))

2146

continue;

2146

continue;

2147

2148

/* use network order to read the VID: this ensures that

2148

/* use network order to read the VID: this ensures that

2149

* every node reads the bytes in the same order.

2149

* every node reads the bytes in the same order.

2150

*/

2150

*/

2151

tmp_vid = htons(tt_common->vid);

2151

tmp_vid = htons(tt_common->vid);

2152

crc_tmp = crc32c(0, &tmp_vid, sizeof(tmp_vid));

2152

crc_tmp = crc32c(0, &tmp_vid, sizeof(tmp_vid));

2153

2154

/* compute the CRC on flags that have to be kept in sync

2154

/* compute the CRC on flags that have to be kept in sync

2155

* among nodes

2155

* among nodes

2156

*/

2156

*/

2157

flags = tt_common->flags & BATADV_TT_SYNC_MASK;

2157

flags = tt_common->flags & BATADV_TT_SYNC_MASK;

2158

crc_tmp = crc32c(crc_tmp, &flags, sizeof(flags));

2158

crc_tmp = crc32c(crc_tmp, &flags, sizeof(flags));

2159

2160

crc ^= crc32c(crc_tmp, tt_common->addr, ETH_ALEN);

2160

crc ^= crc32c(crc_tmp, tt_common->addr, ETH_ALEN);

2161

}

2161

}

2162

rcu_read_unlock();

2162

rcu_read_unlock();

2163

}

2163

}

2164

2165

return crc;

2165

return crc;

2166

}

2166

}

2167

2168

/**

2168

/**

2169

* batadv_tt_local_crc - calculates the checksum of the local table

2169

* batadv_tt_local_crc - calculates the checksum of the local table

2170

* @bat_priv: the bat priv with all the soft interface information

2170

* @bat_priv: the bat priv with all the soft interface information

2171

* @vid: VLAN identifier for which the CRC32 has to be computed

2171

* @vid: VLAN identifier for which the CRC32 has to be computed

2172

*

2172

*

2173

* For details about the computation, please refer to the documentation for

2173

* For details about the computation, please refer to the documentation for

2174

* batadv_tt_global_crc().

2174

* batadv_tt_global_crc().

2175

*

2175

*

2176

* Returns the checksum of the local table

2176

* Returns the checksum of the local table

2177

*/

2177

*/

2178

static u32 batadv_tt_local_crc(struct batadv_priv *bat_priv,

2178

static u32 batadv_tt_local_crc(struct batadv_priv *bat_priv,

2179

unsigned short vid)

2179

unsigned short vid)

2180

{

2180

{

2181

struct batadv_hashtable *hash = bat_priv->tt.local_hash;

2181

struct batadv_hashtable *hash = bat_priv->tt.local_hash;

2182

struct batadv_tt_common_entry *tt_common;

2182

struct batadv_tt_common_entry *tt_common;

2183

struct hlist_head *head;

2183

struct hlist_head *head;

2184

u32 i, crc_tmp, crc = 0;

2184

u32 i, crc_tmp, crc = 0;

2185

u8 flags;

2185

u8 flags;

2186

__be16 tmp_vid;

2186

__be16 tmp_vid;

2187

2188

for (i = 0; i < hash->size; i++) {

2188

for (i = 0; i < hash->size; i++) {

2189

head = &hash->table[i];

2189

head = &hash->table[i];

2190

2191

rcu_read_lock();

2191

rcu_read_lock();

2192

hlist_for_each_entry_rcu(tt_common, head, hash_entry) {

2192

hlist_for_each_entry_rcu(tt_common, head, hash_entry) {

2193

/* compute the CRC only for entries belonging to the

2193

/* compute the CRC only for entries belonging to the

2194

* VLAN identified by vid

2194

* VLAN identified by vid

2195

*/

2195

*/

2196

if (tt_common->vid != vid)

2196

if (tt_common->vid != vid)

2197

continue;

2197

continue;

2198

2199

/* not yet committed clients have not to be taken into

2199

/* not yet committed clients have not to be taken into

2200

* account while computing the CRC

2200

* account while computing the CRC

2201

*/

2201

*/

2202

if (tt_common->flags & BATADV_TT_CLIENT_NEW)

2202

if (tt_common->flags & BATADV_TT_CLIENT_NEW)

2203

continue;

2203

continue;

2204

2205

/* use network order to read the VID: this ensures that

2205

/* use network order to read the VID: this ensures that

2206

* every node reads the bytes in the same order.

2206

* every node reads the bytes in the same order.

2207

*/

2207

*/

2208

tmp_vid = htons(tt_common->vid);

2208

tmp_vid = htons(tt_common->vid);

2209

crc_tmp = crc32c(0, &tmp_vid, sizeof(tmp_vid));

2209

crc_tmp = crc32c(0, &tmp_vid, sizeof(tmp_vid));

2210

2211

/* compute the CRC on flags that have to be kept in sync

2211

/* compute the CRC on flags that have to be kept in sync

2212

* among nodes

2212

* among nodes

2213

*/

2213

*/

2214

flags = tt_common->flags & BATADV_TT_SYNC_MASK;

2214

flags = tt_common->flags & BATADV_TT_SYNC_MASK;

2215

crc_tmp = crc32c(crc_tmp, &flags, sizeof(flags));

2215

crc_tmp = crc32c(crc_tmp, &flags, sizeof(flags));

2216

2217

crc ^= crc32c(crc_tmp, tt_common->addr, ETH_ALEN);

2217

crc ^= crc32c(crc_tmp, tt_common->addr, ETH_ALEN);

2218

}

2218

}

2219

rcu_read_unlock();

2219

rcu_read_unlock();

2220

}

2220

}

2221

2222

return crc;

2222

return crc;

2223

}

2223

}

2224

2225

static void batadv_tt_req_list_free(struct batadv_priv *bat_priv)

2225

static void batadv_tt_req_list_free(struct batadv_priv *bat_priv)

2226

{

2226

{

2227

struct batadv_tt_req_node *node, *safe;

2227

struct batadv_tt_req_node *node, *safe;

2228

2229

spin_lock_bh(&bat_priv->tt.req_list_lock);

2229

spin_lock_bh(&bat_priv->tt.req_list_lock);

2230

2231

list_for_each_entry_safe(node, safe, &bat_priv->tt.req_list, list) {

2231

list_for_each_entry_safe(node, safe, &bat_priv->tt.req_list, list) {

2232

list_del_init(&node->list);

2232

list_del_init(&node->list);

2233

kfree(node);

2233

kfree(node);

2234

}

2234

}

2235

2236

spin_unlock_bh(&bat_priv->tt.req_list_lock);

2236

spin_unlock_bh(&bat_priv->tt.req_list_lock);

2237

}

2237

}

2238

2239

static void batadv_tt_save_orig_buffer(struct batadv_priv *bat_priv,

2239

static void batadv_tt_save_orig_buffer(struct batadv_priv *bat_priv,

2240

struct batadv_orig_node *orig_node,

2240

struct batadv_orig_node *orig_node,

2241

const void *tt_buff,

2241

const void *tt_buff,

2242

u16 tt_buff_len)

2242

u16 tt_buff_len)

2243

{

2243

{

2244

/* Replace the old buffer only if I received something in the

2244

/* Replace the old buffer only if I received something in the

2245

* last OGM (the OGM could carry no changes)

2245

* last OGM (the OGM could carry no changes)

2246

*/

2246

*/

2247

spin_lock_bh(&orig_node->tt_buff_lock);

2247

spin_lock_bh(&orig_node->tt_buff_lock);

2248

if (tt_buff_len > 0) {

2248

if (tt_buff_len > 0) {

2249

kfree(orig_node->tt_buff);

2249

kfree(orig_node->tt_buff);

2250

orig_node->tt_buff_len = 0;

2250

orig_node->tt_buff_len = 0;

2251

orig_node->tt_buff = kmalloc(tt_buff_len, GFP_ATOMIC);

2251

orig_node->tt_buff = kmalloc(tt_buff_len, GFP_ATOMIC);

2252

if (orig_node->tt_buff) {

2252

if (orig_node->tt_buff) {

2253

memcpy(orig_node->tt_buff, tt_buff, tt_buff_len);

2253

memcpy(orig_node->tt_buff, tt_buff, tt_buff_len);

2254

orig_node->tt_buff_len = tt_buff_len;

2254

orig_node->tt_buff_len = tt_buff_len;

2255

}

2255

}

2256

}

2256

}

2257

spin_unlock_bh(&orig_node->tt_buff_lock);

2257

spin_unlock_bh(&orig_node->tt_buff_lock);

2258

}

2258

}

2259

2260

static void batadv_tt_req_purge(struct batadv_priv *bat_priv)

2260

static void batadv_tt_req_purge(struct batadv_priv *bat_priv)

2261

{

2261

{

2262

struct batadv_tt_req_node *node, *safe;

2262

struct batadv_tt_req_node *node, *safe;

2263

2264

spin_lock_bh(&bat_priv->tt.req_list_lock);

2264

spin_lock_bh(&bat_priv->tt.req_list_lock);

2265

list_for_each_entry_safe(node, safe, &bat_priv->tt.req_list, list) {

2265

list_for_each_entry_safe(node, safe, &bat_priv->tt.req_list, list) {

2266

if (batadv_has_timed_out(node->issued_at,

2266

if (batadv_has_timed_out(node->issued_at,

2267

BATADV_TT_REQUEST_TIMEOUT)) {

2267

BATADV_TT_REQUEST_TIMEOUT)) {

2268

list_del_init(&node->list);

2268

list_del_init(&node->list);

2269

kfree(node);

2269

kfree(node);

2270

}

2270

}

2271

}

2271

}

2272

spin_unlock_bh(&bat_priv->tt.req_list_lock);

2272

spin_unlock_bh(&bat_priv->tt.req_list_lock);

2273

}

2273

}

2274

2275

/**

2275

/**

2276

* batadv_tt_req_node_new - search and possibly create a tt_req_node object

2276

* batadv_tt_req_node_new - search and possibly create a tt_req_node object

2277

* @bat_priv: the bat priv with all the soft interface information

2277

* @bat_priv: the bat priv with all the soft interface information

2278

* @orig_node: orig node this request is being issued for

2278

* @orig_node: orig node this request is being issued for

2279

*

2279

*

2280

* Returns the pointer to the new tt_req_node struct if no request

2280

* Returns the pointer to the new tt_req_node struct if no request

2281

* has already been issued for this orig_node, NULL otherwise.

2281

* has already been issued for this orig_node, NULL otherwise.

2282

*/

2282

*/

2283

static struct batadv_tt_req_node *

2283

static struct batadv_tt_req_node *

2284

batadv_tt_req_node_new(struct batadv_priv *bat_priv,

2284

batadv_tt_req_node_new(struct batadv_priv *bat_priv,

2285

struct batadv_orig_node *orig_node)

2285

struct batadv_orig_node *orig_node)

2286

{

2286

{

2287

struct batadv_tt_req_node *tt_req_node_tmp, *tt_req_node = NULL;

2287

struct batadv_tt_req_node *tt_req_node_tmp, *tt_req_node = NULL;

2288

2289

spin_lock_bh(&bat_priv->tt.req_list_lock);

2289

spin_lock_bh(&bat_priv->tt.req_list_lock);

2290

list_for_each_entry(tt_req_node_tmp, &bat_priv->tt.req_list, list) {

2290

list_for_each_entry(tt_req_node_tmp, &bat_priv->tt.req_list, list) {

2291

if (batadv_compare_eth(tt_req_node_tmp, orig_node) &&

2291

if (batadv_compare_eth(tt_req_node_tmp, orig_node) &&

2292

!batadv_has_timed_out(tt_req_node_tmp->issued_at,

2292

!batadv_has_timed_out(tt_req_node_tmp->issued_at,

2293

BATADV_TT_REQUEST_TIMEOUT))

2293

BATADV_TT_REQUEST_TIMEOUT))

2294

goto unlock;

2294

goto unlock;

2295

}

2295

}

2296

2297

tt_req_node = kmalloc(sizeof(*tt_req_node), GFP_ATOMIC);

2297

tt_req_node = kmalloc(sizeof(*tt_req_node), GFP_ATOMIC);

2298

if (!tt_req_node)

2298

if (!tt_req_node)

2299

goto unlock;

2299

goto unlock;

2300

2301

ether_addr_copy(tt_req_node->addr, orig_node->orig);

2301

ether_addr_copy(tt_req_node->addr, orig_node->orig);

2302

tt_req_node->issued_at = jiffies;

2302

tt_req_node->issued_at = jiffies;

2303

2304

list_add(&tt_req_node->list, &bat_priv->tt.req_list);

2304

list_add(&tt_req_node->list, &bat_priv->tt.req_list);

2305

unlock:

2305

unlock:

2306

spin_unlock_bh(&bat_priv->tt.req_list_lock);

2306

spin_unlock_bh(&bat_priv->tt.req_list_lock);

2307

return tt_req_node;

2307

return tt_req_node;

2308

}

2308

}

2309

2310

/**

2310

/**

2311

* batadv_tt_local_valid - verify that given tt entry is a valid one

2311

* batadv_tt_local_valid - verify that given tt entry is a valid one

2312

* @entry_ptr: to be checked local tt entry

2312

* @entry_ptr: to be checked local tt entry

2313

* @data_ptr: not used but definition required to satisfy the callback prototype

2313

* @data_ptr: not used but definition required to satisfy the callback prototype

2314

*

2314

*

2315

* Returns 1 if the entry is a valid, 0 otherwise.

2315

* Returns 1 if the entry is a valid, 0 otherwise.

2316

*/

2316

*/

2317

static int batadv_tt_local_valid(const void *entry_ptr, const void *data_ptr)

2317

static int batadv_tt_local_valid(const void *entry_ptr, const void *data_ptr)

2318

{

2318

{

2319

const struct batadv_tt_common_entry *tt_common_entry = entry_ptr;

2319

const struct batadv_tt_common_entry *tt_common_entry = entry_ptr;

2320

2321

if (tt_common_entry->flags & BATADV_TT_CLIENT_NEW)

2321

if (tt_common_entry->flags & BATADV_TT_CLIENT_NEW)

2322

return 0;

2322

return 0;

2323

return 1;

2323

return 1;

2324

}

2324

}

2325

2326

static int batadv_tt_global_valid(const void *entry_ptr,

2326

static int batadv_tt_global_valid(const void *entry_ptr,

2327

const void *data_ptr)

2327

const void *data_ptr)

2328

{

2328

{

2329

const struct batadv_tt_common_entry *tt_common_entry = entry_ptr;

2329

const struct batadv_tt_common_entry *tt_common_entry = entry_ptr;

2330

const struct batadv_tt_global_entry *tt_global_entry;

2330

const struct batadv_tt_global_entry *tt_global_entry;

2331

const struct batadv_orig_node *orig_node = data_ptr;

2331

const struct batadv_orig_node *orig_node = data_ptr;

2332

2333

if (tt_common_entry->flags & BATADV_TT_CLIENT_ROAM ||

2333

if (tt_common_entry->flags & BATADV_TT_CLIENT_ROAM ||

2334

tt_common_entry->flags & BATADV_TT_CLIENT_TEMP)

2334

tt_common_entry->flags & BATADV_TT_CLIENT_TEMP)

2335

return 0;

2335

return 0;

2336

2337

tt_global_entry = container_of(tt_common_entry,

2337

tt_global_entry = container_of(tt_common_entry,

2338

struct batadv_tt_global_entry,

2338

struct batadv_tt_global_entry,

2339

common);

2339

common);

2340

2341

return batadv_tt_global_entry_has_orig(tt_global_entry, orig_node);

2341

return batadv_tt_global_entry_has_orig(tt_global_entry, orig_node);

2342

}

2342

}

2343

2344

/**

2344

/**

2345

* batadv_tt_tvlv_generate - fill the tvlv buff with the tt entries from the

2345

* batadv_tt_tvlv_generate - fill the tvlv buff with the tt entries from the

2346

* specified tt hash

2346

* specified tt hash

2347

* @bat_priv: the bat priv with all the soft interface information

2347

* @bat_priv: the bat priv with all the soft interface information

2348

* @hash: hash table containing the tt entries

2348

* @hash: hash table containing the tt entries

2349

* @tt_len: expected tvlv tt data buffer length in number of bytes

2349

* @tt_len: expected tvlv tt data buffer length in number of bytes

2350

* @tvlv_buff: pointer to the buffer to fill with the TT data

2350

* @tvlv_buff: pointer to the buffer to fill with the TT data

2351

* @valid_cb: function to filter tt change entries

2351

* @valid_cb: function to filter tt change entries

2352

* @cb_data: data passed to the filter function as argument

2352

* @cb_data: data passed to the filter function as argument

2353

*/

2353

*/

2354

static void batadv_tt_tvlv_generate(struct batadv_priv *bat_priv,

2354

static void batadv_tt_tvlv_generate(struct batadv_priv *bat_priv,

2355

struct batadv_hashtable *hash,

2355

struct batadv_hashtable *hash,

2356

void *tvlv_buff, u16 tt_len,

2356

void *tvlv_buff, u16 tt_len,

2357

int (*valid_cb)(const void *, const void *),

2357

int (*valid_cb)(const void *, const void *),

2358

void *cb_data)

2358

void *cb_data)

2359

{

2359

{

2360

struct batadv_tt_common_entry *tt_common_entry;

2360

struct batadv_tt_common_entry *tt_common_entry;

2361

struct batadv_tvlv_tt_change *tt_change;

2361

struct batadv_tvlv_tt_change *tt_change;

2362

struct hlist_head *head;

2362

struct hlist_head *head;

2363

u16 tt_tot, tt_num_entries = 0;

2363

u16 tt_tot, tt_num_entries = 0;

2364

u32 i;

2364

u32 i;

2365

2366

tt_tot = batadv_tt_entries(tt_len);

2366

tt_tot = batadv_tt_entries(tt_len);

2367

tt_change = (struct batadv_tvlv_tt_change *)tvlv_buff;

2367

tt_change = (struct batadv_tvlv_tt_change *)tvlv_buff;

2368

2369

rcu_read_lock();

2369

rcu_read_lock();

2370

for (i = 0; i < hash->size; i++) {

2370

for (i = 0; i < hash->size; i++) {

2371

head = &hash->table[i];

2371

head = &hash->table[i];

2372

2373

hlist_for_each_entry_rcu(tt_common_entry,

2373

hlist_for_each_entry_rcu(tt_common_entry,

2374

head, hash_entry) {

2374

head, hash_entry) {

2375

if (tt_tot == tt_num_entries)

2375

if (tt_tot == tt_num_entries)

2376

break;

2376

break;

2377

2378

if ((valid_cb) && (!valid_cb(tt_common_entry, cb_data)))

2378

if ((valid_cb) && (!valid_cb(tt_common_entry, cb_data)))

2379

continue;

2379

continue;

2380

2381

ether_addr_copy(tt_change->addr, tt_common_entry->addr);

2381

ether_addr_copy(tt_change->addr, tt_common_entry->addr);

2382

tt_change->flags = tt_common_entry->flags;

2382

tt_change->flags = tt_common_entry->flags;

2383

tt_change->vid = htons(tt_common_entry->vid);

2383

tt_change->vid = htons(tt_common_entry->vid);

2384

memset(tt_change->reserved, 0,

2384

memset(tt_change->reserved, 0,

2385

sizeof(tt_change->reserved));

2385

sizeof(tt_change->reserved));

2386

2387

tt_num_entries++;

2387

tt_num_entries++;

2388

tt_change++;

2388

tt_change++;

2389

}

2389

}

2390

}

2390

}

2391

rcu_read_unlock();

2391

rcu_read_unlock();

2392

}

2392

}

2393

2394

/**

2394

/**

2395

* batadv_tt_global_check_crc - check if all the CRCs are correct

2395

* batadv_tt_global_check_crc - check if all the CRCs are correct

2396

* @orig_node: originator for which the CRCs have to be checked

2396

* @orig_node: originator for which the CRCs have to be checked

2397

* @tt_vlan: pointer to the first tvlv VLAN entry

2397

* @tt_vlan: pointer to the first tvlv VLAN entry

2398

* @num_vlan: number of tvlv VLAN entries

2398

* @num_vlan: number of tvlv VLAN entries

2399

* @create: if true, create VLAN objects if not found

2399

* @create: if true, create VLAN objects if not found

2400

*

2400

*

2401

* Return true if all the received CRCs match the locally stored ones, false

2401

* Return true if all the received CRCs match the locally stored ones, false

2402

* otherwise

2402

* otherwise

2403

*/

2403

*/

2404

static bool batadv_tt_global_check_crc(struct batadv_orig_node *orig_node,

2404

static bool batadv_tt_global_check_crc(struct batadv_orig_node *orig_node,

2405

struct batadv_tvlv_tt_vlan_data *tt_vlan,

2405

struct batadv_tvlv_tt_vlan_data *tt_vlan,

2406

u16 num_vlan)

2406

u16 num_vlan)

2407

{

2407

{

2408

struct batadv_tvlv_tt_vlan_data *tt_vlan_tmp;

2408

struct batadv_tvlv_tt_vlan_data *tt_vlan_tmp;

2409

struct batadv_orig_node_vlan *vlan;

2409

struct batadv_orig_node_vlan *vlan;

2410

u32 crc;

2410

u32 crc;

2411

int i;

2411

int i;

2412

2413

/* check if each received CRC matches the locally stored one */

2413

/* check if each received CRC matches the locally stored one */

2414

for (i = 0; i < num_vlan; i++) {

2414

for (i = 0; i < num_vlan; i++) {

2415

tt_vlan_tmp = tt_vlan + i;

2415

tt_vlan_tmp = tt_vlan + i;

2416

2417

/* if orig_node is a backbone node for this VLAN, don't check

2417

/* if orig_node is a backbone node for this VLAN, don't check

2418

* the CRC as we ignore all the global entries over it

2418

* the CRC as we ignore all the global entries over it

2419

*/

2419

*/

2420

if (batadv_bla_is_backbone_gw_orig(orig_node->bat_priv,

2420

if (batadv_bla_is_backbone_gw_orig(orig_node->bat_priv,

2421

orig_node->orig,

2421

orig_node->orig,

2422

ntohs(tt_vlan_tmp->vid)))

2422

ntohs(tt_vlan_tmp->vid)))

2423

continue;

2423

continue;

2424

2425

vlan = batadv_orig_node_vlan_get(orig_node,

2425

vlan = batadv_orig_node_vlan_get(orig_node,

2426

ntohs(tt_vlan_tmp->vid));

2426

ntohs(tt_vlan_tmp->vid));

2427

if (!vlan)

2427

if (!vlan)

2428

return false;

2428

return false;

2429

2430

crc = vlan->tt.crc;

2430

crc = vlan->tt.crc;

2431

batadv_orig_node_vlan_free_ref(vlan);

2431

batadv_orig_node_vlan_free_ref(vlan);

2432

2433

if (crc != ntohl(tt_vlan_tmp->crc))

2433

if (crc != ntohl(tt_vlan_tmp->crc))

2434

return false;

2434

return false;

2435

}

2435

}

2436

2437

return true;

2437

return true;

2438

}

2438

}

2439

2440

/**

2440

/**

2441

* batadv_tt_local_update_crc - update all the local CRCs

2441

* batadv_tt_local_update_crc - update all the local CRCs

2442

* @bat_priv: the bat priv with all the soft interface information

2442

* @bat_priv: the bat priv with all the soft interface information

2443

*/

2443

*/

2444

static void batadv_tt_local_update_crc(struct batadv_priv *bat_priv)

2444

static void batadv_tt_local_update_crc(struct batadv_priv *bat_priv)

2445

{

2445

{

2446

struct batadv_softif_vlan *vlan;

2446

struct batadv_softif_vlan *vlan;

2447

2448

/* recompute the global CRC for each VLAN */

2448

/* recompute the global CRC for each VLAN */

2449

rcu_read_lock();

2449

rcu_read_lock();

2450

hlist_for_each_entry_rcu(vlan, &bat_priv->softif_vlan_list, list) {

2450

hlist_for_each_entry_rcu(vlan, &bat_priv->softif_vlan_list, list) {

2451

vlan->tt.crc = batadv_tt_local_crc(bat_priv, vlan->vid);

2451

vlan->tt.crc = batadv_tt_local_crc(bat_priv, vlan->vid);

2452

}

2452

}

2453

rcu_read_unlock();

2453

rcu_read_unlock();

2454

}

2454

}

2455

2456

/**

2456

/**

2457

* batadv_tt_global_update_crc - update all the global CRCs for this orig_node

2457

* batadv_tt_global_update_crc - update all the global CRCs for this orig_node

2458

* @bat_priv: the bat priv with all the soft interface information

2458

* @bat_priv: the bat priv with all the soft interface information

2459

* @orig_node: the orig_node for which the CRCs have to be updated

2459

* @orig_node: the orig_node for which the CRCs have to be updated

2460

*/

2460

*/

2461

static void batadv_tt_global_update_crc(struct batadv_priv *bat_priv,

2461

static void batadv_tt_global_update_crc(struct batadv_priv *bat_priv,

2462

struct batadv_orig_node *orig_node)

2462

struct batadv_orig_node *orig_node)

2463

{

2463

{

2464

struct batadv_orig_node_vlan *vlan;

2464

struct batadv_orig_node_vlan *vlan;

2465

u32 crc;

2465

u32 crc;

2466

2467

/* recompute the global CRC for each VLAN */

2467

/* recompute the global CRC for each VLAN */

2468

rcu_read_lock();

2468

rcu_read_lock();

2469

hlist_for_each_entry_rcu(vlan, &orig_node->vlan_list, list) {

2469

hlist_for_each_entry_rcu(vlan, &orig_node->vlan_list, list) {

2470

/* if orig_node is a backbone node for this VLAN, don't compute

2470

/* if orig_node is a backbone node for this VLAN, don't compute

2471

* the CRC as we ignore all the global entries over it

2471

* the CRC as we ignore all the global entries over it

2472

*/

2472

*/

2473

if (batadv_bla_is_backbone_gw_orig(bat_priv, orig_node->orig,

2473

if (batadv_bla_is_backbone_gw_orig(bat_priv, orig_node->orig,

2474

vlan->vid))

2474

vlan->vid))

2475

continue;

2475

continue;

2476

2477

crc = batadv_tt_global_crc(bat_priv, orig_node, vlan->vid);

2477

crc = batadv_tt_global_crc(bat_priv, orig_node, vlan->vid);

2478

vlan->tt.crc = crc;

2478

vlan->tt.crc = crc;

2479

}

2479

}

2480

rcu_read_unlock();

2480

rcu_read_unlock();

2481

}

2481

}

2482

2483

/**

2483

/**

2484

* batadv_send_tt_request - send a TT Request message to a given node

2484

* batadv_send_tt_request - send a TT Request message to a given node

2485

* @bat_priv: the bat priv with all the soft interface information

2485

* @bat_priv: the bat priv with all the soft interface information

2486

* @dst_orig_node: the destination of the message

2486

* @dst_orig_node: the destination of the message

2487

* @ttvn: the version number that the source of the message is looking for

2487

* @ttvn: the version number that the source of the message is looking for

2488

* @tt_vlan: pointer to the first tvlv VLAN object to request

2488

* @tt_vlan: pointer to the first tvlv VLAN object to request

2489

* @num_vlan: number of tvlv VLAN entries

2489

* @num_vlan: number of tvlv VLAN entries

2490

* @full_table: ask for the entire translation table if true, while only for the

2490

* @full_table: ask for the entire translation table if true, while only for the

2491

* last TT diff otherwise

2491

* last TT diff otherwise

2492

*/

2492

*/

2493

static int batadv_send_tt_request(struct batadv_priv *bat_priv,

2493

static int batadv_send_tt_request(struct batadv_priv *bat_priv,

2494

struct batadv_orig_node *dst_orig_node,

2494

struct batadv_orig_node *dst_orig_node,

2495

u8 ttvn,

2495

u8 ttvn,

2496

struct batadv_tvlv_tt_vlan_data *tt_vlan,

2496

struct batadv_tvlv_tt_vlan_data *tt_vlan,

2497

u16 num_vlan, bool full_table)

2497

u16 num_vlan, bool full_table)

2498

{

2498

{

2499

struct batadv_tvlv_tt_data *tvlv_tt_data = NULL;

2499

struct batadv_tvlv_tt_data *tvlv_tt_data = NULL;

2500

struct batadv_tt_req_node *tt_req_node = NULL;

2500

struct batadv_tt_req_node *tt_req_node = NULL;

2501

struct batadv_tvlv_tt_vlan_data *tt_vlan_req;

2501

struct batadv_tvlv_tt_vlan_data *tt_vlan_req;

2502

struct batadv_hard_iface *primary_if;

2502

struct batadv_hard_iface *primary_if;

2503

bool ret = false;

2503

bool ret = false;

2504

int i, size;

2504

int i, size;

2505

2506

primary_if = batadv_primary_if_get_selected(bat_priv);

2506

primary_if = batadv_primary_if_get_selected(bat_priv);

2507

if (!primary_if)

2507

if (!primary_if)

2508

goto out;

2508

goto out;

2509

2510

/* The new tt_req will be issued only if I'm not waiting for a

2510

/* The new tt_req will be issued only if I'm not waiting for a

2511

* reply from the same orig_node yet

2511

* reply from the same orig_node yet

2512

*/

2512

*/

2513

tt_req_node = batadv_tt_req_node_new(bat_priv, dst_orig_node);

2513

tt_req_node = batadv_tt_req_node_new(bat_priv, dst_orig_node);

2514

if (!tt_req_node)

2514

if (!tt_req_node)

2515

goto out;

2515

goto out;

2516

2517

size = sizeof(*tvlv_tt_data) + sizeof(*tt_vlan_req) * num_vlan;

2517

size = sizeof(*tvlv_tt_data) + sizeof(*tt_vlan_req) * num_vlan;

2518

tvlv_tt_data = kzalloc(size, GFP_ATOMIC);

2518

tvlv_tt_data = kzalloc(size, GFP_ATOMIC);

2519

if (!tvlv_tt_data)

2519

if (!tvlv_tt_data)

2520

goto out;

2520

goto out;

2521

2522

tvlv_tt_data->flags = BATADV_TT_REQUEST;

2522

tvlv_tt_data->flags = BATADV_TT_REQUEST;

2523

tvlv_tt_data->ttvn = ttvn;

2523

tvlv_tt_data->ttvn = ttvn;

2524

tvlv_tt_data->num_vlan = htons(num_vlan);

2524

tvlv_tt_data->num_vlan = htons(num_vlan);

2525

2526

/* send all the CRCs within the request. This is needed by intermediate

2526

/* send all the CRCs within the request. This is needed by intermediate

2527

* nodes to ensure they have the correct table before replying

2527

* nodes to ensure they have the correct table before replying

2528

*/

2528

*/

2529

tt_vlan_req = (struct batadv_tvlv_tt_vlan_data *)(tvlv_tt_data + 1);

2529

tt_vlan_req = (struct batadv_tvlv_tt_vlan_data *)(tvlv_tt_data + 1);

2530

for (i = 0; i < num_vlan; i++) {

2530

for (i = 0; i < num_vlan; i++) {

2531

tt_vlan_req->vid = tt_vlan->vid;

2531

tt_vlan_req->vid = tt_vlan->vid;

2532

tt_vlan_req->crc = tt_vlan->crc;

2532

tt_vlan_req->crc = tt_vlan->crc;

2533

2534

tt_vlan_req++;

2534

tt_vlan_req++;

2535

tt_vlan++;

2535

tt_vlan++;

2536

}

2536

}

2537

2538

if (full_table)

2538

if (full_table)

2539

tvlv_tt_data->flags |= BATADV_TT_FULL_TABLE;

2539

tvlv_tt_data->flags |= BATADV_TT_FULL_TABLE;

2540

2541

batadv_dbg(BATADV_DBG_TT, bat_priv, "Sending TT_REQUEST to %pM [%c]\n",

2541

batadv_dbg(BATADV_DBG_TT, bat_priv, "Sending TT_REQUEST to %pM [%c]\n",

2542

dst_orig_node->orig, full_table ? 'F' : '.');

2542

dst_orig_node->orig, full_table ? 'F' : '.');

2543

2544

batadv_inc_counter(bat_priv, BATADV_CNT_TT_REQUEST_TX);

2544

batadv_inc_counter(bat_priv, BATADV_CNT_TT_REQUEST_TX);

2545

batadv_tvlv_unicast_send(bat_priv, primary_if->net_dev->dev_addr,

2545

batadv_tvlv_unicast_send(bat_priv, primary_if->net_dev->dev_addr,

2546

dst_orig_node->orig, BATADV_TVLV_TT, 1,

2546

dst_orig_node->orig, BATADV_TVLV_TT, 1,

2547

tvlv_tt_data, size);

2547

tvlv_tt_data, size);

2548

ret = true;

2548

ret = true;

2549

2550

out:

2550

out:

2551

if (primary_if)

2551

if (primary_if)

2552

batadv_hardif_free_ref(primary_if);

2552

batadv_hardif_free_ref(primary_if);

2553

if (ret && tt_req_node) {

2553

if (ret && tt_req_node) {

2554

spin_lock_bh(&bat_priv->tt.req_list_lock);

2554

spin_lock_bh(&bat_priv->tt.req_list_lock);

2555

/* list_del_init() verifies tt_req_node still is in the list */

2555

/* list_del_init() verifies tt_req_node still is in the list */

2556

list_del_init(&tt_req_node->list);

2556

list_del_init(&tt_req_node->list);

2557

spin_unlock_bh(&bat_priv->tt.req_list_lock);

2557

spin_unlock_bh(&bat_priv->tt.req_list_lock);

2558

kfree(tt_req_node);

2558

kfree(tt_req_node);

2559

}

2559

}

2560

kfree(tvlv_tt_data);

2560

kfree(tvlv_tt_data);

2561

return ret;

2561

return ret;

2562

}

2562

}

2563

2564

/**

2564

/**

2565

* batadv_send_other_tt_response - send reply to tt request concerning another

2565

* batadv_send_other_tt_response - send reply to tt request concerning another

2566

* node's translation table

2566

* node's translation table

2567

* @bat_priv: the bat priv with all the soft interface information

2567

* @bat_priv: the bat priv with all the soft interface information

2568

* @tt_data: tt data containing the tt request information

2568

* @tt_data: tt data containing the tt request information

2569

* @req_src: mac address of tt request sender

2569

* @req_src: mac address of tt request sender

2570

* @req_dst: mac address of tt request recipient

2570

* @req_dst: mac address of tt request recipient

2571

*

2571

*

2572

* Returns true if tt request reply was sent, false otherwise.

2572

* Returns true if tt request reply was sent, false otherwise.

2573

*/

2573

*/

2574

static bool batadv_send_other_tt_response(struct batadv_priv *bat_priv,

2574

static bool batadv_send_other_tt_response(struct batadv_priv *bat_priv,

2575

struct batadv_tvlv_tt_data *tt_data,

2575

struct batadv_tvlv_tt_data *tt_data,

2576

u8 *req_src, u8 *req_dst)

2576

u8 *req_src, u8 *req_dst)

2577

{

2577

{

2578

struct batadv_orig_node *req_dst_orig_node;

2578

struct batadv_orig_node *req_dst_orig_node;

2579

struct batadv_orig_node *res_dst_orig_node = NULL;

2579

struct batadv_orig_node *res_dst_orig_node = NULL;

2580

struct batadv_tvlv_tt_change *tt_change;

2580

struct batadv_tvlv_tt_change *tt_change;

2581

struct batadv_tvlv_tt_data *tvlv_tt_data = NULL;

2581

struct batadv_tvlv_tt_data *tvlv_tt_data = NULL;

2582

struct batadv_tvlv_tt_vlan_data *tt_vlan;

2582

struct batadv_tvlv_tt_vlan_data *tt_vlan;

2583

bool ret = false, full_table;

2583

bool ret = false, full_table;

2584

u8 orig_ttvn, req_ttvn;

2584

u8 orig_ttvn, req_ttvn;

2585

u16 tvlv_len;

2585

u16 tvlv_len;

2586

s32 tt_len;

2586

s32 tt_len;

2587

2588

batadv_dbg(BATADV_DBG_TT, bat_priv,

2588

batadv_dbg(BATADV_DBG_TT, bat_priv,

2589

"Received TT_REQUEST from %pM for ttvn: %u (%pM) [%c]\n",

2589

"Received TT_REQUEST from %pM for ttvn: %u (%pM) [%c]\n",

2590

req_src, tt_data->ttvn, req_dst,

2590

req_src, tt_data->ttvn, req_dst,

2591

((tt_data->flags & BATADV_TT_FULL_TABLE) ? 'F' : '.'));

2591

((tt_data->flags & BATADV_TT_FULL_TABLE) ? 'F' : '.'));

2592

2593

/* Let's get the orig node of the REAL destination */

2593

/* Let's get the orig node of the REAL destination */

2594

req_dst_orig_node = batadv_orig_hash_find(bat_priv, req_dst);

2594

req_dst_orig_node = batadv_orig_hash_find(bat_priv, req_dst);

2595

if (!req_dst_orig_node)

2595

if (!req_dst_orig_node)

2596

goto out;

2596

goto out;

2597

2598

res_dst_orig_node = batadv_orig_hash_find(bat_priv, req_src);

2598

res_dst_orig_node = batadv_orig_hash_find(bat_priv, req_src);

2599

if (!res_dst_orig_node)

2599

if (!res_dst_orig_node)

2600

goto out;

2600

goto out;

2601

2602

orig_ttvn = (u8)atomic_read(&req_dst_orig_node->last_ttvn);

2602

orig_ttvn = (u8)atomic_read(&req_dst_orig_node->last_ttvn);

2603

req_ttvn = tt_data->ttvn;

2603

req_ttvn = tt_data->ttvn;

2604

2605

tt_vlan = (struct batadv_tvlv_tt_vlan_data *)(tt_data + 1);

2605

tt_vlan = (struct batadv_tvlv_tt_vlan_data *)(tt_data + 1);

2606

/* this node doesn't have the requested data */

2606

/* this node doesn't have the requested data */

2607

if (orig_ttvn != req_ttvn ||

2607

if (orig_ttvn != req_ttvn ||

2608

!batadv_tt_global_check_crc(req_dst_orig_node, tt_vlan,

2608

!batadv_tt_global_check_crc(req_dst_orig_node, tt_vlan,

2609

ntohs(tt_data->num_vlan)))

2609

ntohs(tt_data->num_vlan)))

2610

goto out;

2610

goto out;

2611

2612

/* If the full table has been explicitly requested */

2612

/* If the full table has been explicitly requested */

2613

if (tt_data->flags & BATADV_TT_FULL_TABLE ||

2613

if (tt_data->flags & BATADV_TT_FULL_TABLE ||

2614

!req_dst_orig_node->tt_buff)

2614

!req_dst_orig_node->tt_buff)

2615

full_table = true;

2615

full_table = true;

2616

else

2616

else

2617

full_table = false;

2617

full_table = false;

2618

2619

/* TT fragmentation hasn't been implemented yet, so send as many

2619

/* TT fragmentation hasn't been implemented yet, so send as many

2620

* TT entries fit a single packet as possible only

2620

* TT entries fit a single packet as possible only

2621

*/

2621

*/

2622

if (!full_table) {

2622

if (!full_table) {

2623

spin_lock_bh(&req_dst_orig_node->tt_buff_lock);

2623

spin_lock_bh(&req_dst_orig_node->tt_buff_lock);

2624

tt_len = req_dst_orig_node->tt_buff_len;

2624

tt_len = req_dst_orig_node->tt_buff_len;

2625

2626

tvlv_len = batadv_tt_prepare_tvlv_global_data(req_dst_orig_node,

2626

tvlv_len = batadv_tt_prepare_tvlv_global_data(req_dst_orig_node,

2627

&tvlv_tt_data,

2627

&tvlv_tt_data,

2628

&tt_change,

2628

&tt_change,

2629

&tt_len);

2629

&tt_len);

2630

if (!tt_len)

2630

if (!tt_len)

2631

goto unlock;

2631

goto unlock;

2632

2633

/* Copy the last orig_node's OGM buffer */

2633

/* Copy the last orig_node's OGM buffer */

2634

memcpy(tt_change, req_dst_orig_node->tt_buff,

2634

memcpy(tt_change, req_dst_orig_node->tt_buff,

2635

req_dst_orig_node->tt_buff_len);

2635

req_dst_orig_node->tt_buff_len);

2636

spin_unlock_bh(&req_dst_orig_node->tt_buff_lock);

2636

spin_unlock_bh(&req_dst_orig_node->tt_buff_lock);

2637

} else {

2637

} else {

2638

/* allocate the tvlv, put the tt_data and all the tt_vlan_data

2638

/* allocate the tvlv, put the tt_data and all the tt_vlan_data

2639

* in the initial part

2639

* in the initial part

2640

*/

2640

*/

2641

tt_len = -1;

2641

tt_len = -1;

2642

tvlv_len = batadv_tt_prepare_tvlv_global_data(req_dst_orig_node,

2642

tvlv_len = batadv_tt_prepare_tvlv_global_data(req_dst_orig_node,

2643

&tvlv_tt_data,

2643

&tvlv_tt_data,

2644

&tt_change,

2644

&tt_change,

2645

&tt_len);

2645

&tt_len);

2646

if (!tt_len)

2646

if (!tt_len)

2647

goto out;

2647

goto out;

2648

2649

/* fill the rest of the tvlv with the real TT entries */

2649

/* fill the rest of the tvlv with the real TT entries */

2650

batadv_tt_tvlv_generate(bat_priv, bat_priv->tt.global_hash,

2650

batadv_tt_tvlv_generate(bat_priv, bat_priv->tt.global_hash,

2651

tt_change, tt_len,

2651

tt_change, tt_len,

2652

batadv_tt_global_valid,

2652

batadv_tt_global_valid,

2653

req_dst_orig_node);

2653

req_dst_orig_node);

2654

}

2654

}

2655

2656

/* Don't send the response, if larger than fragmented packet. */

2656

/* Don't send the response, if larger than fragmented packet. */

2657

tt_len = sizeof(struct batadv_unicast_tvlv_packet) + tvlv_len;

2657

tt_len = sizeof(struct batadv_unicast_tvlv_packet) + tvlv_len;

2658

if (tt_len > atomic_read(&bat_priv->packet_size_max)) {

2658

if (tt_len > atomic_read(&bat_priv->packet_size_max)) {

2659

net_ratelimited_function(batadv_info, bat_priv->soft_iface,

2659

net_ratelimited_function(batadv_info, bat_priv->soft_iface,

2660

"Ignoring TT_REQUEST from %pM; Response size exceeds max packet size.\n",

2660

"Ignoring TT_REQUEST from %pM; Response size exceeds max packet size.\n",

2661

res_dst_orig_node->orig);

2661

res_dst_orig_node->orig);

2662

goto out;

2662

goto out;

2663

}

2663

}

2664

2665

tvlv_tt_data->flags = BATADV_TT_RESPONSE;

2665

tvlv_tt_data->flags = BATADV_TT_RESPONSE;

2666

tvlv_tt_data->ttvn = req_ttvn;

2666

tvlv_tt_data->ttvn = req_ttvn;

2667

2668

if (full_table)

2668

if (full_table)

2669

tvlv_tt_data->flags |= BATADV_TT_FULL_TABLE;

2669

tvlv_tt_data->flags |= BATADV_TT_FULL_TABLE;

2670

2671

batadv_dbg(BATADV_DBG_TT, bat_priv,

2671

batadv_dbg(BATADV_DBG_TT, bat_priv,

2672

"Sending TT_RESPONSE %pM for %pM [%c] (ttvn: %u)\n",

2672

"Sending TT_RESPONSE %pM for %pM [%c] (ttvn: %u)\n",

2673

res_dst_orig_node->orig, req_dst_orig_node->orig,

2673

res_dst_orig_node->orig, req_dst_orig_node->orig,

2674

full_table ? 'F' : '.', req_ttvn);

2674

full_table ? 'F' : '.', req_ttvn);

2675

2676

batadv_inc_counter(bat_priv, BATADV_CNT_TT_RESPONSE_TX);

2676

batadv_inc_counter(bat_priv, BATADV_CNT_TT_RESPONSE_TX);

2677

2678

batadv_tvlv_unicast_send(bat_priv, req_dst_orig_node->orig,

2678

batadv_tvlv_unicast_send(bat_priv, req_dst_orig_node->orig,

2679

req_src, BATADV_TVLV_TT, 1, tvlv_tt_data,

2679

req_src, BATADV_TVLV_TT, 1, tvlv_tt_data,

2680

tvlv_len);

2680

tvlv_len);

2681

2682

ret = true;

2682

ret = true;

2683

goto out;

2683

goto out;

2684

2685

unlock:

2685

unlock:

2686

spin_unlock_bh(&req_dst_orig_node->tt_buff_lock);

2686

spin_unlock_bh(&req_dst_orig_node->tt_buff_lock);

2687

2688

out:

2688

out:

2689

if (res_dst_orig_node)

2689

if (res_dst_orig_node)

2690

batadv_orig_node_free_ref(res_dst_orig_node);

2690

batadv_orig_node_free_ref(res_dst_orig_node);

2691

if (req_dst_orig_node)

2691

if (req_dst_orig_node)

2692

batadv_orig_node_free_ref(req_dst_orig_node);

2692

batadv_orig_node_free_ref(req_dst_orig_node);

2693

kfree(tvlv_tt_data);

2693

kfree(tvlv_tt_data);

2694

return ret;

2694

return ret;

2695

}

2695

}

2696

2697

/**

2697

/**

2698

* batadv_send_my_tt_response - send reply to tt request concerning this node's

2698

* batadv_send_my_tt_response - send reply to tt request concerning this node's

2699

* translation table

2699

* translation table

2700

* @bat_priv: the bat priv with all the soft interface information

2700

* @bat_priv: the bat priv with all the soft interface information

2701

* @tt_data: tt data containing the tt request information

2701

* @tt_data: tt data containing the tt request information

2702

* @req_src: mac address of tt request sender

2702

* @req_src: mac address of tt request sender

2703

*

2703

*

2704

* Returns true if tt request reply was sent, false otherwise.

2704

* Returns true if tt request reply was sent, false otherwise.

2705

*/

2705

*/

2706

static bool batadv_send_my_tt_response(struct batadv_priv *bat_priv,

2706

static bool batadv_send_my_tt_response(struct batadv_priv *bat_priv,

2707

struct batadv_tvlv_tt_data *tt_data,

2707

struct batadv_tvlv_tt_data *tt_data,

2708

u8 *req_src)

2708

u8 *req_src)

2709

{

2709

{

2710

struct batadv_tvlv_tt_data *tvlv_tt_data = NULL;

2710

struct batadv_tvlv_tt_data *tvlv_tt_data = NULL;

2711

struct batadv_hard_iface *primary_if = NULL;

2711

struct batadv_hard_iface *primary_if = NULL;

2712

struct batadv_tvlv_tt_change *tt_change;

2712

struct batadv_tvlv_tt_change *tt_change;

2713

struct batadv_orig_node *orig_node;

2713

struct batadv_orig_node *orig_node;

2714

u8 my_ttvn, req_ttvn;

2714

u8 my_ttvn, req_ttvn;

2715

u16 tvlv_len;

2715

u16 tvlv_len;

2716

bool full_table;

2716

bool full_table;

2717

s32 tt_len;

2717

s32 tt_len;

2718

2719

batadv_dbg(BATADV_DBG_TT, bat_priv,

2719

batadv_dbg(BATADV_DBG_TT, bat_priv,

2720

"Received TT_REQUEST from %pM for ttvn: %u (me) [%c]\n",

2720

"Received TT_REQUEST from %pM for ttvn: %u (me) [%c]\n",

2721

req_src, tt_data->ttvn,

2721

req_src, tt_data->ttvn,

2722

((tt_data->flags & BATADV_TT_FULL_TABLE) ? 'F' : '.'));

2722

((tt_data->flags & BATADV_TT_FULL_TABLE) ? 'F' : '.'));

2723

2724

spin_lock_bh(&bat_priv->tt.commit_lock);

2724

spin_lock_bh(&bat_priv->tt.commit_lock);

2725

2726

my_ttvn = (u8)atomic_read(&bat_priv->tt.vn);

2726

my_ttvn = (u8)atomic_read(&bat_priv->tt.vn);

2727

req_ttvn = tt_data->ttvn;

2727

req_ttvn = tt_data->ttvn;

2728

2729

orig_node = batadv_orig_hash_find(bat_priv, req_src);

2729

orig_node = batadv_orig_hash_find(bat_priv, req_src);

2730

if (!orig_node)

2730

if (!orig_node)

2731

goto out;

2731

goto out;

2732

2733

primary_if = batadv_primary_if_get_selected(bat_priv);

2733

primary_if = batadv_primary_if_get_selected(bat_priv);

2734

if (!primary_if)

2734

if (!primary_if)

2735

goto out;

2735

goto out;

2736

2737

/* If the full table has been explicitly requested or the gap

2737

/* If the full table has been explicitly requested or the gap

2738

* is too big send the whole local translation table

2738

* is too big send the whole local translation table

2739

*/

2739

*/

2740

if (tt_data->flags & BATADV_TT_FULL_TABLE || my_ttvn != req_ttvn ||

2740

if (tt_data->flags & BATADV_TT_FULL_TABLE || my_ttvn != req_ttvn ||

2741

!bat_priv->tt.last_changeset)

2741

!bat_priv->tt.last_changeset)

2742

full_table = true;

2742

full_table = true;

2743

else

2743

else

2744

full_table = false;

2744

full_table = false;

2745

2746

/* TT fragmentation hasn't been implemented yet, so send as many

2746

/* TT fragmentation hasn't been implemented yet, so send as many

2747

* TT entries fit a single packet as possible only

2747

* TT entries fit a single packet as possible only

2748

*/

2748

*/

2749

if (!full_table) {

2749

if (!full_table) {

2750

spin_lock_bh(&bat_priv->tt.last_changeset_lock);

2750

spin_lock_bh(&bat_priv->tt.last_changeset_lock);

2751

2752

tt_len = bat_priv->tt.last_changeset_len;

2752

tt_len = bat_priv->tt.last_changeset_len;

2753

tvlv_len = batadv_tt_prepare_tvlv_local_data(bat_priv,

2753

tvlv_len = batadv_tt_prepare_tvlv_local_data(bat_priv,

2754

&tvlv_tt_data,

2754

&tvlv_tt_data,

2755

&tt_change,

2755

&tt_change,

2756

&tt_len);

2756

&tt_len);

2757

if (!tt_len)

2757

if (!tt_len)

2758

goto unlock;

2758

goto unlock;

2759

2760

/* Copy the last orig_node's OGM buffer */

2760

/* Copy the last orig_node's OGM buffer */

2761

memcpy(tt_change, bat_priv->tt.last_changeset,

2761

memcpy(tt_change, bat_priv->tt.last_changeset,

2762

bat_priv->tt.last_changeset_len);

2762

bat_priv->tt.last_changeset_len);

2763

spin_unlock_bh(&bat_priv->tt.last_changeset_lock);

2763

spin_unlock_bh(&bat_priv->tt.last_changeset_lock);

2764

} else {

2764

} else {

2765

req_ttvn = (u8)atomic_read(&bat_priv->tt.vn);

2765

req_ttvn = (u8)atomic_read(&bat_priv->tt.vn);

2766

2767

/* allocate the tvlv, put the tt_data and all the tt_vlan_data

2767

/* allocate the tvlv, put the tt_data and all the tt_vlan_data

2768

* in the initial part

2768

* in the initial part

2769

*/

2769

*/

2770

tt_len = -1;

2770

tt_len = -1;

2771

tvlv_len = batadv_tt_prepare_tvlv_local_data(bat_priv,

2771

tvlv_len = batadv_tt_prepare_tvlv_local_data(bat_priv,

2772

&tvlv_tt_data,

2772

&tvlv_tt_data,

2773

&tt_change,

2773

&tt_change,

2774

&tt_len);

2774

&tt_len);

2775

if (!tt_len)

2775

if (!tt_len)

2776

goto out;

2776

goto out;

2777

2778

/* fill the rest of the tvlv with the real TT entries */

2778

/* fill the rest of the tvlv with the real TT entries */

2779

batadv_tt_tvlv_generate(bat_priv, bat_priv->tt.local_hash,

2779

batadv_tt_tvlv_generate(bat_priv, bat_priv->tt.local_hash,

2780

tt_change, tt_len,

2780

tt_change, tt_len,

2781

batadv_tt_local_valid, NULL);

2781

batadv_tt_local_valid, NULL);

2782

}

2782

}

2783

2784

tvlv_tt_data->flags = BATADV_TT_RESPONSE;

2784

tvlv_tt_data->flags = BATADV_TT_RESPONSE;

2785

tvlv_tt_data->ttvn = req_ttvn;

2785

tvlv_tt_data->ttvn = req_ttvn;

2786

2787

if (full_table)

2787

if (full_table)

2788

tvlv_tt_data->flags |= BATADV_TT_FULL_TABLE;

2788

tvlv_tt_data->flags |= BATADV_TT_FULL_TABLE;

2789

2790

batadv_dbg(BATADV_DBG_TT, bat_priv,

2790

batadv_dbg(BATADV_DBG_TT, bat_priv,

2791

"Sending TT_RESPONSE to %pM [%c] (ttvn: %u)\n",

2791

"Sending TT_RESPONSE to %pM [%c] (ttvn: %u)\n",

2792

orig_node->orig, full_table ? 'F' : '.', req_ttvn);

2792

orig_node->orig, full_table ? 'F' : '.', req_ttvn);

2793

2794

batadv_inc_counter(bat_priv, BATADV_CNT_TT_RESPONSE_TX);

2794

batadv_inc_counter(bat_priv, BATADV_CNT_TT_RESPONSE_TX);

2795

2796

batadv_tvlv_unicast_send(bat_priv, primary_if->net_dev->dev_addr,

2796

batadv_tvlv_unicast_send(bat_priv, primary_if->net_dev->dev_addr,

2797

req_src, BATADV_TVLV_TT, 1, tvlv_tt_data,

2797

req_src, BATADV_TVLV_TT, 1, tvlv_tt_data,

2798

tvlv_len);

2798

tvlv_len);

2799

2800

goto out;

2800

goto out;

2801

2802

unlock:

2802

unlock:

2803

spin_unlock_bh(&bat_priv->tt.last_changeset_lock);

2803

spin_unlock_bh(&bat_priv->tt.last_changeset_lock);

2804

out:

2804

out:

2805

spin_unlock_bh(&bat_priv->tt.commit_lock);

2805

spin_unlock_bh(&bat_priv->tt.commit_lock);

2806

if (orig_node)

2806

if (orig_node)

2807

batadv_orig_node_free_ref(orig_node);

2807

batadv_orig_node_free_ref(orig_node);

2808

if (primary_if)

2808

if (primary_if)

2809

batadv_hardif_free_ref(primary_if);

2809

batadv_hardif_free_ref(primary_if);

2810

kfree(tvlv_tt_data);

2810

kfree(tvlv_tt_data);

2811

/* The packet was for this host, so it doesn't need to be re-routed */

2811

/* The packet was for this host, so it doesn't need to be re-routed */

2812

return true;

2812

return true;

2813

}

2813

}

2814

2815

/**

2815

/**

2816

* batadv_send_tt_response - send reply to tt request

2816

* batadv_send_tt_response - send reply to tt request

2817

* @bat_priv: the bat priv with all the soft interface information

2817

* @bat_priv: the bat priv with all the soft interface information

2818

* @tt_data: tt data containing the tt request information

2818

* @tt_data: tt data containing the tt request information

2819

* @req_src: mac address of tt request sender

2819

* @req_src: mac address of tt request sender

2820

* @req_dst: mac address of tt request recipient

2820

* @req_dst: mac address of tt request recipient

2821

*

2821

*

2822

* Returns true if tt request reply was sent, false otherwise.

2822

* Returns true if tt request reply was sent, false otherwise.

2823

*/

2823

*/

2824

static bool batadv_send_tt_response(struct batadv_priv *bat_priv,

2824

static bool batadv_send_tt_response(struct batadv_priv *bat_priv,

2825

struct batadv_tvlv_tt_data *tt_data,

2825

struct batadv_tvlv_tt_data *tt_data,

2826

u8 *req_src, u8 *req_dst)

2826

u8 *req_src, u8 *req_dst)

2827

{

2827

{

2828

if (batadv_is_my_mac(bat_priv, req_dst))

2828

if (batadv_is_my_mac(bat_priv, req_dst))

2829

return batadv_send_my_tt_response(bat_priv, tt_data, req_src);

2829

return batadv_send_my_tt_response(bat_priv, tt_data, req_src);

2830

return batadv_send_other_tt_response(bat_priv, tt_data, req_src,

2830

return batadv_send_other_tt_response(bat_priv, tt_data, req_src,

2831

req_dst);

2831

req_dst);

2832

}

2832

}

2833

2834

static void _batadv_tt_update_changes(struct batadv_priv *bat_priv,

2834

static void _batadv_tt_update_changes(struct batadv_priv *bat_priv,

2835

struct batadv_orig_node *orig_node,

2835

struct batadv_orig_node *orig_node,

2836

struct batadv_tvlv_tt_change *tt_change,

2836

struct batadv_tvlv_tt_change *tt_change,

2837

u16 tt_num_changes, u8 ttvn)

2837

u16 tt_num_changes, u8 ttvn)

2838

{

2838

{

2839

int i;

2839

int i;

2840

int roams;

2840

int roams;

2841

2842

for (i = 0; i < tt_num_changes; i++) {

2842

for (i = 0; i < tt_num_changes; i++) {

2843

if ((tt_change + i)->flags & BATADV_TT_CLIENT_DEL) {

2843

if ((tt_change + i)->flags & BATADV_TT_CLIENT_DEL) {

2844

roams = (tt_change + i)->flags & BATADV_TT_CLIENT_ROAM;

2844

roams = (tt_change + i)->flags & BATADV_TT_CLIENT_ROAM;

2845

batadv_tt_global_del(bat_priv, orig_node,

2845

batadv_tt_global_del(bat_priv, orig_node,

2846

(tt_change + i)->addr,

2846

(tt_change + i)->addr,

2847

ntohs((tt_change + i)->vid),

2847

ntohs((tt_change + i)->vid),

2848

"tt removed by changes",

2848

"tt removed by changes",

2849

roams);

2849

roams);

2850

} else {

2850

} else {

2851

if (!batadv_tt_global_add(bat_priv, orig_node,

2851

if (!batadv_tt_global_add(bat_priv, orig_node,

2852

(tt_change + i)->addr,

2852

(tt_change + i)->addr,

2853

ntohs((tt_change + i)->vid),

2853

ntohs((tt_change + i)->vid),

2854

(tt_change + i)->flags, ttvn))

2854

(tt_change + i)->flags, ttvn))

2855

/* In case of problem while storing a

2855

/* In case of problem while storing a

2856

* global_entry, we stop the updating

2856

* global_entry, we stop the updating

2857

* procedure without committing the

2857

* procedure without committing the

2858

* ttvn change. This will avoid to send

2858

* ttvn change. This will avoid to send

2859

* corrupted data on tt_request

2859

* corrupted data on tt_request

2860

*/

2860

*/

2861

return;

2861

return;

2862

}

2862

}

2863

}

2863

}

2864

set_bit(BATADV_ORIG_CAPA_HAS_TT, &orig_node->capa_initialized);

2864

set_bit(BATADV_ORIG_CAPA_HAS_TT, &orig_node->capa_initialized);

2865

}

2865

}

2866

2867

static void batadv_tt_fill_gtable(struct batadv_priv *bat_priv,

2867

static void batadv_tt_fill_gtable(struct batadv_priv *bat_priv,

2868

struct batadv_tvlv_tt_change *tt_change,

2868

struct batadv_tvlv_tt_change *tt_change,

2869

u8 ttvn, u8 *resp_src,

2869

u8 ttvn, u8 *resp_src,

2870

u16 num_entries)

2870

u16 num_entries)

2871

{

2871

{

2872

struct batadv_orig_node *orig_node;

2872

struct batadv_orig_node *orig_node;

2873

2874

orig_node = batadv_orig_hash_find(bat_priv, resp_src);

2874

orig_node = batadv_orig_hash_find(bat_priv, resp_src);

2875

if (!orig_node)

2875

if (!orig_node)

2876

goto out;

2876

goto out;

2877

2878

/* Purge the old table first.. */

2878

/* Purge the old table first.. */

2879

batadv_tt_global_del_orig(bat_priv, orig_node, -1,

2879

batadv_tt_global_del_orig(bat_priv, orig_node, -1,

2880

"Received full table");

2880

"Received full table");

2881

2882

_batadv_tt_update_changes(bat_priv, orig_node, tt_change, num_entries,

2882

_batadv_tt_update_changes(bat_priv, orig_node, tt_change, num_entries,

2883

ttvn);

2883

ttvn);

2884

2885

spin_lock_bh(&orig_node->tt_buff_lock);

2885

spin_lock_bh(&orig_node->tt_buff_lock);

2886

kfree(orig_node->tt_buff);

2886

kfree(orig_node->tt_buff);

2887

orig_node->tt_buff_len = 0;

2887

orig_node->tt_buff_len = 0;

2888

orig_node->tt_buff = NULL;

2888

orig_node->tt_buff = NULL;

2889

spin_unlock_bh(&orig_node->tt_buff_lock);

2889

spin_unlock_bh(&orig_node->tt_buff_lock);

2890

2891

atomic_set(&orig_node->last_ttvn, ttvn);

2891

atomic_set(&orig_node->last_ttvn, ttvn);

2892

2893

out:

2893

out:

2894

if (orig_node)

2894

if (orig_node)

2895

batadv_orig_node_free_ref(orig_node);

2895

batadv_orig_node_free_ref(orig_node);

2896

}

2896

}

2897

2898

static void batadv_tt_update_changes(struct batadv_priv *bat_priv,

2898

static void batadv_tt_update_changes(struct batadv_priv *bat_priv,

2899

struct batadv_orig_node *orig_node,

2899

struct batadv_orig_node *orig_node,

2900

u16 tt_num_changes, u8 ttvn,

2900

u16 tt_num_changes, u8 ttvn,

2901

struct batadv_tvlv_tt_change *tt_change)

2901

struct batadv_tvlv_tt_change *tt_change)

2902

{

2902

{

2903

_batadv_tt_update_changes(bat_priv, orig_node, tt_change,

2903

_batadv_tt_update_changes(bat_priv, orig_node, tt_change,

2904

tt_num_changes, ttvn);

2904

tt_num_changes, ttvn);

2905

2906

batadv_tt_save_orig_buffer(bat_priv, orig_node, tt_change,

2906

batadv_tt_save_orig_buffer(bat_priv, orig_node, tt_change,

2907

batadv_tt_len(tt_num_changes));

2907

batadv_tt_len(tt_num_changes));

2908

atomic_set(&orig_node->last_ttvn, ttvn);

2908

atomic_set(&orig_node->last_ttvn, ttvn);

2909

}

2909

}

2910

2911

/**

2911

/**

2912

* batadv_is_my_client - check if a client is served by the local node

2912

* batadv_is_my_client - check if a client is served by the local node

2913

* @bat_priv: the bat priv with all the soft interface information

2913

* @bat_priv: the bat priv with all the soft interface information

2914

* @addr: the mac address of the client to check

2914

* @addr: the mac address of the client to check

2915

* @vid: VLAN identifier

2915

* @vid: VLAN identifier

2916

*

2916

*

2917

* Returns true if the client is served by this node, false otherwise.

2917

* Returns true if the client is served by this node, false otherwise.

2918

*/

2918

*/

2919

bool batadv_is_my_client(struct batadv_priv *bat_priv, const u8 *addr,

2919

bool batadv_is_my_client(struct batadv_priv *bat_priv, const u8 *addr,

2920

unsigned short vid)

2920

unsigned short vid)

2921

{

2921

{

2922

struct batadv_tt_local_entry *tt_local_entry;

2922

struct batadv_tt_local_entry *tt_local_entry;

2923

bool ret = false;

2923

bool ret = false;

2924

2925

tt_local_entry = batadv_tt_local_hash_find(bat_priv, addr, vid);

2925

tt_local_entry = batadv_tt_local_hash_find(bat_priv, addr, vid);

2926

if (!tt_local_entry)

2926

if (!tt_local_entry)

2927

goto out;

2927

goto out;

2928

/* Check if the client has been logically deleted (but is kept for

2928

/* Check if the client has been logically deleted (but is kept for

2929

* consistency purpose)

2929

* consistency purpose)

2930

*/

2930

*/

2931

if ((tt_local_entry->common.flags & BATADV_TT_CLIENT_PENDING) ||

2931

if ((tt_local_entry->common.flags & BATADV_TT_CLIENT_PENDING) ||

2932

(tt_local_entry->common.flags & BATADV_TT_CLIENT_ROAM))

2932

(tt_local_entry->common.flags & BATADV_TT_CLIENT_ROAM))

2933

goto out;

2933

goto out;

2934

ret = true;

2934

ret = true;

2935

out:

2935

out:

2936

if (tt_local_entry)

2936

if (tt_local_entry)

2937

batadv_tt_local_entry_free_ref(tt_local_entry);

2937

batadv_tt_local_entry_free_ref(tt_local_entry);

2938

return ret;

2938

return ret;

2939

}

2939

}

2940

2941

/**

2941

/**

2942

* batadv_handle_tt_response - process incoming tt reply

2942

* batadv_handle_tt_response - process incoming tt reply

2943

* @bat_priv: the bat priv with all the soft interface information

2943

* @bat_priv: the bat priv with all the soft interface information

2944

* @tt_data: tt data containing the tt request information

2944

* @tt_data: tt data containing the tt request information

2945

* @resp_src: mac address of tt reply sender

2945

* @resp_src: mac address of tt reply sender

2946

* @num_entries: number of tt change entries appended to the tt data

2946

* @num_entries: number of tt change entries appended to the tt data

2947

*/

2947

*/

2948

static void batadv_handle_tt_response(struct batadv_priv *bat_priv,

2948

static void batadv_handle_tt_response(struct batadv_priv *bat_priv,

2949

struct batadv_tvlv_tt_data *tt_data,

2949

struct batadv_tvlv_tt_data *tt_data,

2950

u8 *resp_src, u16 num_entries)

2950

u8 *resp_src, u16 num_entries)

2951

{

2951

{

2952

struct batadv_tt_req_node *node, *safe;

2952

struct batadv_tt_req_node *node, *safe;

2953

struct batadv_orig_node *orig_node = NULL;

2953

struct batadv_orig_node *orig_node = NULL;

2954

struct batadv_tvlv_tt_change *tt_change;

2954

struct batadv_tvlv_tt_change *tt_change;

2955

u8 *tvlv_ptr = (u8 *)tt_data;

2955

u8 *tvlv_ptr = (u8 *)tt_data;

2956

u16 change_offset;

2956

u16 change_offset;

2957

2958

batadv_dbg(BATADV_DBG_TT, bat_priv,

2958

batadv_dbg(BATADV_DBG_TT, bat_priv,

2959

"Received TT_RESPONSE from %pM for ttvn %d t_size: %d [%c]\n",

2959

"Received TT_RESPONSE from %pM for ttvn %d t_size: %d [%c]\n",

2960

resp_src, tt_data->ttvn, num_entries,

2960

resp_src, tt_data->ttvn, num_entries,

2961

((tt_data->flags & BATADV_TT_FULL_TABLE) ? 'F' : '.'));

2961

((tt_data->flags & BATADV_TT_FULL_TABLE) ? 'F' : '.'));

2962

2963

orig_node = batadv_orig_hash_find(bat_priv, resp_src);

2963

orig_node = batadv_orig_hash_find(bat_priv, resp_src);

2964

if (!orig_node)

2964

if (!orig_node)

2965

goto out;

2965

goto out;

2966

2967

spin_lock_bh(&orig_node->tt_lock);

2967

spin_lock_bh(&orig_node->tt_lock);

2968

2969

change_offset = sizeof(struct batadv_tvlv_tt_vlan_data);

2969

change_offset = sizeof(struct batadv_tvlv_tt_vlan_data);

2970

change_offset *= ntohs(tt_data->num_vlan);

2970

change_offset *= ntohs(tt_data->num_vlan);

2971

change_offset += sizeof(*tt_data);

2971

change_offset += sizeof(*tt_data);

2972

tvlv_ptr += change_offset;

2972

tvlv_ptr += change_offset;

2973

2974

tt_change = (struct batadv_tvlv_tt_change *)tvlv_ptr;

2974

tt_change = (struct batadv_tvlv_tt_change *)tvlv_ptr;

2975

if (tt_data->flags & BATADV_TT_FULL_TABLE) {

2975

if (tt_data->flags & BATADV_TT_FULL_TABLE) {

2976

batadv_tt_fill_gtable(bat_priv, tt_change, tt_data->ttvn,

2976

batadv_tt_fill_gtable(bat_priv, tt_change, tt_data->ttvn,

2977

resp_src, num_entries);

2977

resp_src, num_entries);

2978

} else {

2978

} else {

2979

batadv_tt_update_changes(bat_priv, orig_node, num_entries,

2979

batadv_tt_update_changes(bat_priv, orig_node, num_entries,

2980

tt_data->ttvn, tt_change);

2980

tt_data->ttvn, tt_change);

2981

}

2981

}

2982

2983

/* Recalculate the CRC for this orig_node and store it */

2983

/* Recalculate the CRC for this orig_node and store it */

2984

batadv_tt_global_update_crc(bat_priv, orig_node);

2984

batadv_tt_global_update_crc(bat_priv, orig_node);

2985

2986

spin_unlock_bh(&orig_node->tt_lock);

2986

spin_unlock_bh(&orig_node->tt_lock);

2987

2988

/* Delete the tt_req_node from pending tt_requests list */

2988

/* Delete the tt_req_node from pending tt_requests list */

2989

spin_lock_bh(&bat_priv->tt.req_list_lock);

2989

spin_lock_bh(&bat_priv->tt.req_list_lock);

2990

list_for_each_entry_safe(node, safe, &bat_priv->tt.req_list, list) {

2990

list_for_each_entry_safe(node, safe, &bat_priv->tt.req_list, list) {

2991

if (!batadv_compare_eth(node->addr, resp_src))

2991

if (!batadv_compare_eth(node->addr, resp_src))

2992

continue;

2992

continue;

2993

list_del_init(&node->list);

2993

list_del_init(&node->list);

2994

kfree(node);

2994

kfree(node);

2995

}

2995

}

2996

2997

spin_unlock_bh(&bat_priv->tt.req_list_lock);

2997

spin_unlock_bh(&bat_priv->tt.req_list_lock);

2998

out:

2998

out:

2999

if (orig_node)

2999

if (orig_node)

3000

batadv_orig_node_free_ref(orig_node);

3000

batadv_orig_node_free_ref(orig_node);

3001

}

3001

}

3002

3003

static void batadv_tt_roam_list_free(struct batadv_priv *bat_priv)

3003

static void batadv_tt_roam_list_free(struct batadv_priv *bat_priv)

3004

{

3004

{

3005

struct batadv_tt_roam_node *node, *safe;

3005

struct batadv_tt_roam_node *node, *safe;

3006

3007

spin_lock_bh(&bat_priv->tt.roam_list_lock);

3007

spin_lock_bh(&bat_priv->tt.roam_list_lock);

3008

3009

list_for_each_entry_safe(node, safe, &bat_priv->tt.roam_list, list) {

3009

list_for_each_entry_safe(node, safe, &bat_priv->tt.roam_list, list) {

3010

list_del(&node->list);

3010

list_del(&node->list);

3011

kfree(node);

3011

kfree(node);

3012

}

3012

}

3013

3014

spin_unlock_bh(&bat_priv->tt.roam_list_lock);

3014

spin_unlock_bh(&bat_priv->tt.roam_list_lock);

3015

}

3015

}

3016

3017

static void batadv_tt_roam_purge(struct batadv_priv *bat_priv)

3017

static void batadv_tt_roam_purge(struct batadv_priv *bat_priv)

3018

{

3018

{

3019

struct batadv_tt_roam_node *node, *safe;

3019

struct batadv_tt_roam_node *node, *safe;

3020

3021

spin_lock_bh(&bat_priv->tt.roam_list_lock);

3021

spin_lock_bh(&bat_priv->tt.roam_list_lock);

3022

list_for_each_entry_safe(node, safe, &bat_priv->tt.roam_list, list) {

3022

list_for_each_entry_safe(node, safe, &bat_priv->tt.roam_list, list) {

3023

if (!batadv_has_timed_out(node->first_time,

3023

if (!batadv_has_timed_out(node->first_time,

3024

BATADV_ROAMING_MAX_TIME))

3024

BATADV_ROAMING_MAX_TIME))

3025

continue;

3025

continue;

3026

3027

list_del(&node->list);

3027

list_del(&node->list);

3028

kfree(node);

3028

kfree(node);

3029

}

3029

}

3030

spin_unlock_bh(&bat_priv->tt.roam_list_lock);

3030

spin_unlock_bh(&bat_priv->tt.roam_list_lock);

3031

}

3031

}

3032

3033

/* This function checks whether the client already reached the

3033

/* This function checks whether the client already reached the

3034

* maximum number of possible roaming phases. In this case the ROAMING_ADV

3034

* maximum number of possible roaming phases. In this case the ROAMING_ADV

3035

* will not be sent.

3035

* will not be sent.

3036

*

3036

*

3037

* returns true if the ROAMING_ADV can be sent, false otherwise

3037

* returns true if the ROAMING_ADV can be sent, false otherwise

3038

*/

3038

*/

3039

static bool batadv_tt_check_roam_count(struct batadv_priv *bat_priv, u8 *client)

3039

static bool batadv_tt_check_roam_count(struct batadv_priv *bat_priv, u8 *client)

3040

{

3040

{

3041

struct batadv_tt_roam_node *tt_roam_node;

3041

struct batadv_tt_roam_node *tt_roam_node;

3042

bool ret = false;

3042

bool ret = false;

3043

3044

spin_lock_bh(&bat_priv->tt.roam_list_lock);

3044

spin_lock_bh(&bat_priv->tt.roam_list_lock);

3045

/* The new tt_req will be issued only if I'm not waiting for a

3045

/* The new tt_req will be issued only if I'm not waiting for a

3046

* reply from the same orig_node yet

3046

* reply from the same orig_node yet

3047

*/

3047

*/

3048

list_for_each_entry(tt_roam_node, &bat_priv->tt.roam_list, list) {

3048

list_for_each_entry(tt_roam_node, &bat_priv->tt.roam_list, list) {

3049

if (!batadv_compare_eth(tt_roam_node->addr, client))

3049

if (!batadv_compare_eth(tt_roam_node->addr, client))

3050

continue;

3050

continue;

3051

3052

if (batadv_has_timed_out(tt_roam_node->first_time,

3052

if (batadv_has_timed_out(tt_roam_node->first_time,

3053

BATADV_ROAMING_MAX_TIME))

3053

BATADV_ROAMING_MAX_TIME))

3054

continue;

3054

continue;

3055

3056

if (!batadv_atomic_dec_not_zero(&tt_roam_node->counter))

3056

if (!batadv_atomic_dec_not_zero(&tt_roam_node->counter))

3057

/* Sorry, you roamed too many times! */

3057

/* Sorry, you roamed too many times! */

3058

goto unlock;

3058

goto unlock;

3059

ret = true;

3059

ret = true;

3060

break;

3060

break;

3061

}

3061

}

3062

3063

if (!ret) {

3063

if (!ret) {

3064

tt_roam_node = kmalloc(sizeof(*tt_roam_node), GFP_ATOMIC);

3064

tt_roam_node = kmalloc(sizeof(*tt_roam_node), GFP_ATOMIC);

3065

if (!tt_roam_node)

3065

if (!tt_roam_node)

3066

goto unlock;

3066

goto unlock;

3067

3068

tt_roam_node->first_time = jiffies;

3068

tt_roam_node->first_time = jiffies;

3069

atomic_set(&tt_roam_node->counter,

3069

atomic_set(&tt_roam_node->counter,

3070

BATADV_ROAMING_MAX_COUNT - 1);

3070

BATADV_ROAMING_MAX_COUNT - 1);

3071

ether_addr_copy(tt_roam_node->addr, client);

3071

ether_addr_copy(tt_roam_node->addr, client);

3072

3073

list_add(&tt_roam_node->list, &bat_priv->tt.roam_list);

3073

list_add(&tt_roam_node->list, &bat_priv->tt.roam_list);

3074

ret = true;

3074

ret = true;

3075

}

3075

}

3076

3077

unlock:

3077

unlock:

3078

spin_unlock_bh(&bat_priv->tt.roam_list_lock);

3078

spin_unlock_bh(&bat_priv->tt.roam_list_lock);

3079

return ret;

3079

return ret;

3080

}

3080

}

3081

3082

/**

3082

/**

3083

* batadv_send_roam_adv - send a roaming advertisement message

3083

* batadv_send_roam_adv - send a roaming advertisement message

3084

* @bat_priv: the bat priv with all the soft interface information

3084

* @bat_priv: the bat priv with all the soft interface information

3085

* @client: mac address of the roaming client

3085

* @client: mac address of the roaming client

3086

* @vid: VLAN identifier

3086

* @vid: VLAN identifier

3087

* @orig_node: message destination

3087

* @orig_node: message destination

3088

*

3088

*

3089

* Send a ROAMING_ADV message to the node which was previously serving this

3089

* Send a ROAMING_ADV message to the node which was previously serving this

3090

* client. This is done to inform the node that from now on all traffic destined

3090

* client. This is done to inform the node that from now on all traffic destined

3091

* for this particular roamed client has to be forwarded to the sender of the

3091

* for this particular roamed client has to be forwarded to the sender of the

3092

* roaming message.

3092

* roaming message.

3093

*/

3093

*/

3094

static void batadv_send_roam_adv(struct batadv_priv *bat_priv, u8 *client,

3094

static void batadv_send_roam_adv(struct batadv_priv *bat_priv, u8 *client,

3095

unsigned short vid,

3095

unsigned short vid,

3096

struct batadv_orig_node *orig_node)

3096

struct batadv_orig_node *orig_node)

3097

{

3097

{

3098

struct batadv_hard_iface *primary_if;

3098

struct batadv_hard_iface *primary_if;

3099

struct batadv_tvlv_roam_adv tvlv_roam;

3099

struct batadv_tvlv_roam_adv tvlv_roam;

3100

3101

primary_if = batadv_primary_if_get_selected(bat_priv);

3101

primary_if = batadv_primary_if_get_selected(bat_priv);

3102

if (!primary_if)

3102

if (!primary_if)

3103

goto out;

3103

goto out;

3104

3105

/* before going on we have to check whether the client has

3105

/* before going on we have to check whether the client has

3106

* already roamed to us too many times

3106

* already roamed to us too many times

3107

*/

3107

*/

3108

if (!batadv_tt_check_roam_count(bat_priv, client))

3108

if (!batadv_tt_check_roam_count(bat_priv, client))

3109

goto out;

3109

goto out;

3110

3111

batadv_dbg(BATADV_DBG_TT, bat_priv,

3111

batadv_dbg(BATADV_DBG_TT, bat_priv,

3112

"Sending ROAMING_ADV to %pM (client %pM, vid: %d)\n",

3112

"Sending ROAMING_ADV to %pM (client %pM, vid: %d)\n",

3113

orig_node->orig, client, BATADV_PRINT_VID(vid));

3113

orig_node->orig, client, BATADV_PRINT_VID(vid));

3114

3115

batadv_inc_counter(bat_priv, BATADV_CNT_TT_ROAM_ADV_TX);

3115

batadv_inc_counter(bat_priv, BATADV_CNT_TT_ROAM_ADV_TX);

3116

3117

memcpy(tvlv_roam.client, client, sizeof(tvlv_roam.client));

3117

memcpy(tvlv_roam.client, client, sizeof(tvlv_roam.client));

3118

tvlv_roam.vid = htons(vid);

3118

tvlv_roam.vid = htons(vid);

3119

3120

batadv_tvlv_unicast_send(bat_priv, primary_if->net_dev->dev_addr,

3120

batadv_tvlv_unicast_send(bat_priv, primary_if->net_dev->dev_addr,

3121

orig_node->orig, BATADV_TVLV_ROAM, 1,

3121

orig_node->orig, BATADV_TVLV_ROAM, 1,

3122

&tvlv_roam, sizeof(tvlv_roam));

3122

&tvlv_roam, sizeof(tvlv_roam));

3123

3124

out:

3124

out:

3125

if (primary_if)

3125

if (primary_if)

3126

batadv_hardif_free_ref(primary_if);

3126

batadv_hardif_free_ref(primary_if);

3127

}

3127

}

3128

3129

static void batadv_tt_purge(struct work_struct *work)

3129

static void batadv_tt_purge(struct work_struct *work)

3130

{

3130

{

3131

struct delayed_work *delayed_work;

3131

struct delayed_work *delayed_work;

3132

struct batadv_priv_tt *priv_tt;

3132

struct batadv_priv_tt *priv_tt;

3133

struct batadv_priv *bat_priv;

3133

struct batadv_priv *bat_priv;

3134

3135

delayed_work = container_of(work, struct delayed_work, work);

3135

delayed_work = container_of(work, struct delayed_work, work);

3136

priv_tt = container_of(delayed_work, struct batadv_priv_tt, work);

3136

priv_tt = container_of(delayed_work, struct batadv_priv_tt, work);

3137

bat_priv = container_of(priv_tt, struct batadv_priv, tt);

3137

bat_priv = container_of(priv_tt, struct batadv_priv, tt);

3138

3139

batadv_tt_local_purge(bat_priv, BATADV_TT_LOCAL_TIMEOUT);

3139

batadv_tt_local_purge(bat_priv, BATADV_TT_LOCAL_TIMEOUT);

3140

batadv_tt_global_purge(bat_priv);

3140

batadv_tt_global_purge(bat_priv);

3141

batadv_tt_req_purge(bat_priv);

3141

batadv_tt_req_purge(bat_priv);

3142

batadv_tt_roam_purge(bat_priv);

3142

batadv_tt_roam_purge(bat_priv);

3143

3144

queue_delayed_work(batadv_event_workqueue, &bat_priv->tt.work,

3144

queue_delayed_work(batadv_event_workqueue, &bat_priv->tt.work,

3145

msecs_to_jiffies(BATADV_TT_WORK_PERIOD));

3145

msecs_to_jiffies(BATADV_TT_WORK_PERIOD));

3146

}

3146

}

3147

3148

void batadv_tt_free(struct batadv_priv *bat_priv)

3148

void batadv_tt_free(struct batadv_priv *bat_priv)

3149

{

3149

{

3150

batadv_tvlv_container_unregister(bat_priv, BATADV_TVLV_TT, 1);

3150

batadv_tvlv_container_unregister(bat_priv, BATADV_TVLV_TT, 1);

3151

batadv_tvlv_handler_unregister(bat_priv, BATADV_TVLV_TT, 1);

3151

batadv_tvlv_handler_unregister(bat_priv, BATADV_TVLV_TT, 1);

3152

3153

cancel_delayed_work_sync(&bat_priv->tt.work);

3153

cancel_delayed_work_sync(&bat_priv->tt.work);

3154

3155

batadv_tt_local_table_free(bat_priv);

3155

batadv_tt_local_table_free(bat_priv);

3156

batadv_tt_global_table_free(bat_priv);

3156

batadv_tt_global_table_free(bat_priv);

3157

batadv_tt_req_list_free(bat_priv);

3157

batadv_tt_req_list_free(bat_priv);

3158

batadv_tt_changes_list_free(bat_priv);

3158

batadv_tt_changes_list_free(bat_priv);

3159

batadv_tt_roam_list_free(bat_priv);

3159

batadv_tt_roam_list_free(bat_priv);

3160

3161

kfree(bat_priv->tt.last_changeset);

3161

kfree(bat_priv->tt.last_changeset);

3162

}

3162

}

3163

3164

/**

3164

/**

3165

* batadv_tt_local_set_flags - set or unset the specified flags on the local

3165

* batadv_tt_local_set_flags - set or unset the specified flags on the local

3166

* table and possibly count them in the TT size

3166

* table and possibly count them in the TT size

3167

* @bat_priv: the bat priv with all the soft interface information

3167

* @bat_priv: the bat priv with all the soft interface information

3168

* @flags: the flag to switch

3168

* @flags: the flag to switch

3169

* @enable: whether to set or unset the flag

3169

* @enable: whether to set or unset the flag

3170

* @count: whether to increase the TT size by the number of changed entries

3170

* @count: whether to increase the TT size by the number of changed entries

3171

*/

3171

*/

3172

static void batadv_tt_local_set_flags(struct batadv_priv *bat_priv, u16 flags,

3172

static void batadv_tt_local_set_flags(struct batadv_priv *bat_priv, u16 flags,

3173

bool enable, bool count)

3173

bool enable, bool count)

3174

{

3174

{

3175

struct batadv_hashtable *hash = bat_priv->tt.local_hash;

3175

struct batadv_hashtable *hash = bat_priv->tt.local_hash;

3176

struct batadv_tt_common_entry *tt_common_entry;

3176

struct batadv_tt_common_entry *tt_common_entry;

3177

u16 changed_num = 0;

3177

u16 changed_num = 0;

3178

struct hlist_head *head;

3178

struct hlist_head *head;

3179

u32 i;

3179

u32 i;

3180

3181

if (!hash)

3181

if (!hash)

3182

return;

3182

return;

3183

3184

for (i = 0; i < hash->size; i++) {

3184

for (i = 0; i < hash->size; i++) {

3185

head = &hash->table[i];

3185

head = &hash->table[i];

3186

3187

rcu_read_lock();

3187

rcu_read_lock();

3188

hlist_for_each_entry_rcu(tt_common_entry,

3188

hlist_for_each_entry_rcu(tt_common_entry,

3189

head, hash_entry) {

3189

head, hash_entry) {

3190

if (enable) {

3190

if (enable) {

3191

if ((tt_common_entry->flags & flags) == flags)

3191

if ((tt_common_entry->flags & flags) == flags)

3192

continue;

3192

continue;

3193

tt_common_entry->flags |= flags;

3193

tt_common_entry->flags |= flags;

3194

} else {

3194

} else {

3195

if (!(tt_common_entry->flags & flags))

3195

if (!(tt_common_entry->flags & flags))

3196

continue;

3196

continue;

3197

tt_common_entry->flags &= ~flags;

3197

tt_common_entry->flags &= ~flags;

3198

}

3198

}

3199

changed_num++;

3199

changed_num++;

3200

3201

if (!count)

3201

if (!count)

3202

continue;

3202

continue;

3203

3204

batadv_tt_local_size_inc(bat_priv,

3204

batadv_tt_local_size_inc(bat_priv,

3205

tt_common_entry->vid);

3205

tt_common_entry->vid);

3206

}

3206

}

3207

rcu_read_unlock();

3207

rcu_read_unlock();

3208

}

3208

}

3209

}

3209

}

3210

3211

/* Purge out all the tt local entries marked with BATADV_TT_CLIENT_PENDING */

3211

/* Purge out all the tt local entries marked with BATADV_TT_CLIENT_PENDING */

3212

static void batadv_tt_local_purge_pending_clients(struct batadv_priv *bat_priv)

3212

static void batadv_tt_local_purge_pending_clients(struct batadv_priv *bat_priv)

3213

{

3213

{

3214

struct batadv_hashtable *hash = bat_priv->tt.local_hash;

3214

struct batadv_hashtable *hash = bat_priv->tt.local_hash;

3215

struct batadv_tt_common_entry *tt_common;

3215

struct batadv_tt_common_entry *tt_common;

3216

struct batadv_tt_local_entry *tt_local;

3216

struct batadv_tt_local_entry *tt_local;

3217

struct batadv_softif_vlan *vlan;

3217

struct batadv_softif_vlan *vlan;

3218

struct hlist_node *node_tmp;

3218

struct hlist_node *node_tmp;

3219

struct hlist_head *head;

3219

struct hlist_head *head;

3220

spinlock_t *list_lock; /* protects write access to the hash lists */

3220

spinlock_t *list_lock; /* protects write access to the hash lists */

3221

u32 i;

3221

u32 i;

3222

3223

if (!hash)

3223

if (!hash)

3224

return;

3224

return;

3225

3226

for (i = 0; i < hash->size; i++) {

3226

for (i = 0; i < hash->size; i++) {

3227

head = &hash->table[i];

3227

head = &hash->table[i];

3228

list_lock = &hash->list_locks[i];

3228

list_lock = &hash->list_locks[i];

3229

3230

spin_lock_bh(list_lock);

3230

spin_lock_bh(list_lock);

3231

hlist_for_each_entry_safe(tt_common, node_tmp, head,

3231

hlist_for_each_entry_safe(tt_common, node_tmp, head,

3232

hash_entry) {

3232

hash_entry) {

3233

if (!(tt_common->flags & BATADV_TT_CLIENT_PENDING))

3233

if (!(tt_common->flags & BATADV_TT_CLIENT_PENDING))

3234

continue;

3234

continue;

3235

3236

batadv_dbg(BATADV_DBG_TT, bat_priv,

3236

batadv_dbg(BATADV_DBG_TT, bat_priv,

3237

"Deleting local tt entry (%pM, vid: %d): pending\n",

3237

"Deleting local tt entry (%pM, vid: %d): pending\n",

3238

tt_common->addr,

3238

tt_common->addr,

3239

BATADV_PRINT_VID(tt_common->vid));

3239

BATADV_PRINT_VID(tt_common->vid));

3240

3241

batadv_tt_local_size_dec(bat_priv, tt_common->vid);

3241

batadv_tt_local_size_dec(bat_priv, tt_common->vid);

3242

hlist_del_rcu(&tt_common->hash_entry);

3242

hlist_del_rcu(&tt_common->hash_entry);

3243

tt_local = container_of(tt_common,

3243

tt_local = container_of(tt_common,

3244

struct batadv_tt_local_entry,

3244

struct batadv_tt_local_entry,

3245

common);

3245

common);

3246

3247

/* decrease the reference held for this vlan */

3247

/* decrease the reference held for this vlan */

3248

vlan = batadv_softif_vlan_get(bat_priv, tt_common->vid);

3248

vlan = batadv_softif_vlan_get(bat_priv, tt_common->vid);

3249

if (vlan) {

3249

if (vlan) {

3250

batadv_softif_vlan_free_ref(vlan);

3250

batadv_softif_vlan_free_ref(vlan);

3251

batadv_softif_vlan_free_ref(vlan);

3251

batadv_softif_vlan_free_ref(vlan);

3252

}

3252

}

3253

3254

batadv_tt_local_entry_free_ref(tt_local);

3254

batadv_tt_local_entry_free_ref(tt_local);

3255

}

3255

}

3256

spin_unlock_bh(list_lock);

3256

spin_unlock_bh(list_lock);

3257

}

3257

}

3258

}

3258

}

3259

3260

/**

3260

/**

3261

* batadv_tt_local_commit_changes_nolock - commit all pending local tt changes

3261

* batadv_tt_local_commit_changes_nolock - commit all pending local tt changes

3262

* which have been queued in the time since the last commit

3262

* which have been queued in the time since the last commit

3263

* @bat_priv: the bat priv with all the soft interface information

3263

* @bat_priv: the bat priv with all the soft interface information

3264

*

3264

*

3265

* Caller must hold tt->commit_lock.

3265

* Caller must hold tt->commit_lock.

3266

*/

3266

*/

3267

static void batadv_tt_local_commit_changes_nolock(struct batadv_priv *bat_priv)

3267

static void batadv_tt_local_commit_changes_nolock(struct batadv_priv *bat_priv)

3268

{

3268

{

3269

/* Update multicast addresses in local translation table */

3269

/* Update multicast addresses in local translation table */

3270

batadv_mcast_mla_update(bat_priv);

3270

batadv_mcast_mla_update(bat_priv);

3271

3272

if (atomic_read(&bat_priv->tt.local_changes) < 1) {

3272

if (atomic_read(&bat_priv->tt.local_changes) < 1) {

3273

if (!batadv_atomic_dec_not_zero(&bat_priv->tt.ogm_append_cnt))

3273

if (!batadv_atomic_dec_not_zero(&bat_priv->tt.ogm_append_cnt))

3274

batadv_tt_tvlv_container_update(bat_priv);

3274

batadv_tt_tvlv_container_update(bat_priv);

3275

return;

3275

return;

3276

}

3276

}

3277

3278

batadv_tt_local_set_flags(bat_priv, BATADV_TT_CLIENT_NEW, false, true);

3278

batadv_tt_local_set_flags(bat_priv, BATADV_TT_CLIENT_NEW, false, true);

3279

3280

batadv_tt_local_purge_pending_clients(bat_priv);

3280

batadv_tt_local_purge_pending_clients(bat_priv);

3281

batadv_tt_local_update_crc(bat_priv);

3281

batadv_tt_local_update_crc(bat_priv);

3282

3283

/* Increment the TTVN only once per OGM interval */

3283

/* Increment the TTVN only once per OGM interval */

3284

atomic_inc(&bat_priv->tt.vn);

3284

atomic_inc(&bat_priv->tt.vn);

3285

batadv_dbg(BATADV_DBG_TT, bat_priv,

3285

batadv_dbg(BATADV_DBG_TT, bat_priv,

3286

"Local changes committed, updating to ttvn %u\n",

3286

"Local changes committed, updating to ttvn %u\n",

3287

(u8)atomic_read(&bat_priv->tt.vn));

3287

(u8)atomic_read(&bat_priv->tt.vn));

3288

3289

/* reset the sending counter */

3289

/* reset the sending counter */

3290

atomic_set(&bat_priv->tt.ogm_append_cnt, BATADV_TT_OGM_APPEND_MAX);

3290

atomic_set(&bat_priv->tt.ogm_append_cnt, BATADV_TT_OGM_APPEND_MAX);

3291

batadv_tt_tvlv_container_update(bat_priv);

3291

batadv_tt_tvlv_container_update(bat_priv);

3292

}

3292

}

3293

3294

/**

3294

/**

3295

* batadv_tt_local_commit_changes - commit all pending local tt changes which

3295

* batadv_tt_local_commit_changes - commit all pending local tt changes which

3296

* have been queued in the time since the last commit

3296

* have been queued in the time since the last commit

3297

* @bat_priv: the bat priv with all the soft interface information

3297

* @bat_priv: the bat priv with all the soft interface information

3298

*/

3298

*/

3299

void batadv_tt_local_commit_changes(struct batadv_priv *bat_priv)

3299

void batadv_tt_local_commit_changes(struct batadv_priv *bat_priv)

3300

{

3300

{

3301

spin_lock_bh(&bat_priv->tt.commit_lock);

3301

spin_lock_bh(&bat_priv->tt.commit_lock);

3302

batadv_tt_local_commit_changes_nolock(bat_priv);

3302

batadv_tt_local_commit_changes_nolock(bat_priv);

3303

spin_unlock_bh(&bat_priv->tt.commit_lock);

3303

spin_unlock_bh(&bat_priv->tt.commit_lock);

3304

}

3304

}

3305

3306

bool batadv_is_ap_isolated(struct batadv_priv *bat_priv, u8 *src, u8 *dst,

3306

bool batadv_is_ap_isolated(struct batadv_priv *bat_priv, u8 *src, u8 *dst,

3307

unsigned short vid)

3307

unsigned short vid)

3308

{

3308

{

3309

struct batadv_tt_local_entry *tt_local_entry = NULL;

3309

struct batadv_tt_local_entry *tt_local_entry = NULL;

3310

struct batadv_tt_global_entry *tt_global_entry = NULL;

3310

struct batadv_tt_global_entry *tt_global_entry = NULL;

3311

struct batadv_softif_vlan *vlan;

3311

struct batadv_softif_vlan *vlan;

3312

bool ret = false;

3312

bool ret = false;

3313

3314

vlan = batadv_softif_vlan_get(bat_priv, vid);

3314

vlan = batadv_softif_vlan_get(bat_priv, vid);

3315

if (!vlan || !atomic_read(&vlan->ap_isolation))

3315

if (!vlan || !atomic_read(&vlan->ap_isolation))

3316

goto out;

3316

goto out;

3317

3318

tt_local_entry = batadv_tt_local_hash_find(bat_priv, dst, vid);

3318

tt_local_entry = batadv_tt_local_hash_find(bat_priv, dst, vid);

3319

if (!tt_local_entry)

3319

if (!tt_local_entry)

3320

goto out;

3320

goto out;

3321

3322

tt_global_entry = batadv_tt_global_hash_find(bat_priv, src, vid);

3322

tt_global_entry = batadv_tt_global_hash_find(bat_priv, src, vid);

3323

if (!tt_global_entry)

3323

if (!tt_global_entry)

3324

goto out;

3324

goto out;

3325

3326

if (!_batadv_is_ap_isolated(tt_local_entry, tt_global_entry))

3326

if (!_batadv_is_ap_isolated(tt_local_entry, tt_global_entry))

3327

goto out;

3327

goto out;

3328

3329

ret = true;

3329

ret = true;

3330

3331

out:

3331

out:

3332

if (vlan)

3332

if (vlan)

3333

batadv_softif_vlan_free_ref(vlan);

3333

batadv_softif_vlan_free_ref(vlan);

3334

if (tt_global_entry)

3334

if (tt_global_entry)

3335

batadv_tt_global_entry_free_ref(tt_global_entry);

3335

batadv_tt_global_entry_free_ref(tt_global_entry);

3336

if (tt_local_entry)

3336

if (tt_local_entry)

3337

batadv_tt_local_entry_free_ref(tt_local_entry);

3337

batadv_tt_local_entry_free_ref(tt_local_entry);

3338

return ret;

3338

return ret;

3339

}

3339

}

3340

3341

/**

3341

/**

3342

* batadv_tt_update_orig - update global translation table with new tt

3342

* batadv_tt_update_orig - update global translation table with new tt

3343

* information received via ogms

3343

* information received via ogms

3344

* @bat_priv: the bat priv with all the soft interface information

3344

* @bat_priv: the bat priv with all the soft interface information

3345

* @orig: the orig_node of the ogm

3345

* @orig: the orig_node of the ogm

3346

* @tt_vlan: pointer to the first tvlv VLAN entry

3346

* @tt_vlan: pointer to the first tvlv VLAN entry

3347

* @tt_num_vlan: number of tvlv VLAN entries

3347

* @tt_num_vlan: number of tvlv VLAN entries

3348

* @tt_change: pointer to the first entry in the TT buffer

3348

* @tt_change: pointer to the first entry in the TT buffer

3349

* @tt_num_changes: number of tt changes inside the tt buffer

3349

* @tt_num_changes: number of tt changes inside the tt buffer

3350

* @ttvn: translation table version number of this changeset

3350

* @ttvn: translation table version number of this changeset

3351

* @tt_crc: crc32 checksum of orig node's translation table

3351

* @tt_crc: crc32 checksum of orig node's translation table

3352

*/

3352

*/

3353

static void batadv_tt_update_orig(struct batadv_priv *bat_priv,

3353

static void batadv_tt_update_orig(struct batadv_priv *bat_priv,

3354

struct batadv_orig_node *orig_node,

3354

struct batadv_orig_node *orig_node,

3355

const void *tt_buff, u16 tt_num_vlan,

3355

const void *tt_buff, u16 tt_num_vlan,

3356

struct batadv_tvlv_tt_change *tt_change,

3356

struct batadv_tvlv_tt_change *tt_change,

3357

u16 tt_num_changes, u8 ttvn)

3357

u16 tt_num_changes, u8 ttvn)

3358

{

3358

{

3359

u8 orig_ttvn = (u8)atomic_read(&orig_node->last_ttvn);

3359

u8 orig_ttvn = (u8)atomic_read(&orig_node->last_ttvn);

3360

struct batadv_tvlv_tt_vlan_data *tt_vlan;

3360

struct batadv_tvlv_tt_vlan_data *tt_vlan;

3361

bool full_table = true;

3361

bool full_table = true;

3362

bool has_tt_init;

3362

bool has_tt_init;

3363

3364

tt_vlan = (struct batadv_tvlv_tt_vlan_data *)tt_buff;

3364

tt_vlan = (struct batadv_tvlv_tt_vlan_data *)tt_buff;

3365

has_tt_init = test_bit(BATADV_ORIG_CAPA_HAS_TT,

3365

has_tt_init = test_bit(BATADV_ORIG_CAPA_HAS_TT,

3366

&orig_node->capa_initialized);

3366

&orig_node->capa_initialized);

3367

3368

/* orig table not initialised AND first diff is in the OGM OR the ttvn

3368

/* orig table not initialised AND first diff is in the OGM OR the ttvn

3369

* increased by one -> we can apply the attached changes

3369

* increased by one -> we can apply the attached changes

3370

*/

3370

*/

3371

if ((!has_tt_init && ttvn == 1) || ttvn - orig_ttvn == 1) {

3371

if ((!has_tt_init && ttvn == 1) || ttvn - orig_ttvn == 1) {

3372

/* the OGM could not contain the changes due to their size or

3372

/* the OGM could not contain the changes due to their size or

3373

* because they have already been sent BATADV_TT_OGM_APPEND_MAX

3373

* because they have already been sent BATADV_TT_OGM_APPEND_MAX

3374

* times.

3374

* times.

3375

* In this case send a tt request

3375

* In this case send a tt request

3376

*/

3376

*/

3377

if (!tt_num_changes) {

3377

if (!tt_num_changes) {

3378

full_table = false;

3378

full_table = false;

3379

goto request_table;

3379

goto request_table;

3380

}

3380

}

3381

3382

spin_lock_bh(&orig_node->tt_lock);

3382

spin_lock_bh(&orig_node->tt_lock);

3383

3384

batadv_tt_update_changes(bat_priv, orig_node, tt_num_changes,

3384

batadv_tt_update_changes(bat_priv, orig_node, tt_num_changes,

3385

ttvn, tt_change);

3385

ttvn, tt_change);

3386

3387

/* Even if we received the precomputed crc with the OGM, we

3387

/* Even if we received the precomputed crc with the OGM, we

3388

* prefer to recompute it to spot any possible inconsistency

3388

* prefer to recompute it to spot any possible inconsistency

3389

* in the global table

3389

* in the global table

3390

*/

3390

*/

3391

batadv_tt_global_update_crc(bat_priv, orig_node);

3391

batadv_tt_global_update_crc(bat_priv, orig_node);

3392

3393

spin_unlock_bh(&orig_node->tt_lock);

3393

spin_unlock_bh(&orig_node->tt_lock);

3394

3395

/* The ttvn alone is not enough to guarantee consistency

3395

/* The ttvn alone is not enough to guarantee consistency

3396

* because a single value could represent different states

3396

* because a single value could represent different states

3397

* (due to the wrap around). Thus a node has to check whether

3397

* (due to the wrap around). Thus a node has to check whether

3398

* the resulting table (after applying the changes) is still

3398

* the resulting table (after applying the changes) is still

3399

* consistent or not. E.g. a node could disconnect while its

3399

* consistent or not. E.g. a node could disconnect while its

3400

* ttvn is X and reconnect on ttvn = X + TTVN_MAX: in this case

3400

* ttvn is X and reconnect on ttvn = X + TTVN_MAX: in this case

3401

* checking the CRC value is mandatory to detect the

3401

* checking the CRC value is mandatory to detect the

3402

* inconsistency

3402

* inconsistency

3403

*/

3403

*/

3404

if (!batadv_tt_global_check_crc(orig_node, tt_vlan,

3404

if (!batadv_tt_global_check_crc(orig_node, tt_vlan,

3405

tt_num_vlan))

3405

tt_num_vlan))

3406

goto request_table;

3406

goto request_table;

3407

} else {

3407

} else {

3408

/* if we missed more than one change or our tables are not

3408

/* if we missed more than one change or our tables are not

3409

* in sync anymore -> request fresh tt data

3409

* in sync anymore -> request fresh tt data

3410

*/

3410

*/

3411

if (!has_tt_init || ttvn != orig_ttvn ||

3411

if (!has_tt_init || ttvn != orig_ttvn ||

3412

!batadv_tt_global_check_crc(orig_node, tt_vlan,

3412

!batadv_tt_global_check_crc(orig_node, tt_vlan,

3413

tt_num_vlan)) {

3413

tt_num_vlan)) {

3414

request_table:

3414

request_table:

3415

batadv_dbg(BATADV_DBG_TT, bat_priv,

3415

batadv_dbg(BATADV_DBG_TT, bat_priv,

3416

"TT inconsistency for %pM. Need to retrieve the correct information (ttvn: %u last_ttvn: %u num_changes: %u)\n",

3416

"TT inconsistency for %pM. Need to retrieve the correct information (ttvn: %u last_ttvn: %u num_changes: %u)\n",

3417

orig_node->orig, ttvn, orig_ttvn,

3417

orig_node->orig, ttvn, orig_ttvn,

3418

tt_num_changes);

3418

tt_num_changes);

3419

batadv_send_tt_request(bat_priv, orig_node, ttvn,

3419

batadv_send_tt_request(bat_priv, orig_node, ttvn,

3420

tt_vlan, tt_num_vlan,

3420

tt_vlan, tt_num_vlan,

3421

full_table);

3421

full_table);

3422

return;

3422

return;

3423

}

3423

}

3424

}

3424

}

3425

}

3425

}

3426

3427

/**

3427

/**

3428

* batadv_tt_global_client_is_roaming - check if a client is marked as roaming

3428

* batadv_tt_global_client_is_roaming - check if a client is marked as roaming

3429

* @bat_priv: the bat priv with all the soft interface information

3429

* @bat_priv: the bat priv with all the soft interface information

3430

* @addr: the mac address of the client to check

3430

* @addr: the mac address of the client to check

3431

* @vid: VLAN identifier

3431

* @vid: VLAN identifier

3432

*

3432

*

3433

* Returns true if we know that the client has moved from its old originator

3433

* Returns true if we know that the client has moved from its old originator

3434

* to another one. This entry is still kept for consistency purposes and will be

3434

* to another one. This entry is still kept for consistency purposes and will be

3435

* deleted later by a DEL or because of timeout

3435

* deleted later by a DEL or because of timeout

3436

*/

3436

*/

3437

bool batadv_tt_global_client_is_roaming(struct batadv_priv *bat_priv,

3437

bool batadv_tt_global_client_is_roaming(struct batadv_priv *bat_priv,

3438

u8 *addr, unsigned short vid)

3438

u8 *addr, unsigned short vid)

3439

{

3439

{

3440

struct batadv_tt_global_entry *tt_global_entry;

3440

struct batadv_tt_global_entry *tt_global_entry;

3441

bool ret = false;

3441

bool ret = false;

3442

3443

tt_global_entry = batadv_tt_global_hash_find(bat_priv, addr, vid);

3443

tt_global_entry = batadv_tt_global_hash_find(bat_priv, addr, vid);

3444

if (!tt_global_entry)

3444

if (!tt_global_entry)

3445

goto out;

3445

goto out;

3446

3447

ret = tt_global_entry->common.flags & BATADV_TT_CLIENT_ROAM;

3447

ret = tt_global_entry->common.flags & BATADV_TT_CLIENT_ROAM;

3448

batadv_tt_global_entry_free_ref(tt_global_entry);

3448

batadv_tt_global_entry_free_ref(tt_global_entry);

3449

out:

3449

out:

3450

return ret;

3450

return ret;

3451

}

3451

}

3452

3453

/**

3453

/**

3454

* batadv_tt_local_client_is_roaming - tells whether the client is roaming

3454

* batadv_tt_local_client_is_roaming - tells whether the client is roaming

3455

* @bat_priv: the bat priv with all the soft interface information

3455

* @bat_priv: the bat priv with all the soft interface information

3456

* @addr: the mac address of the local client to query

3456

* @addr: the mac address of the local client to query

3457

* @vid: VLAN identifier

3457

* @vid: VLAN identifier

3458

*

3458

*

3459

* Returns true if the local client is known to be roaming (it is not served by

3459

* Returns true if the local client is known to be roaming (it is not served by

3460

* this node anymore) or not. If yes, the client is still present in the table

3460

* this node anymore) or not. If yes, the client is still present in the table

3461

* to keep the latter consistent with the node TTVN

3461

* to keep the latter consistent with the node TTVN

3462

*/

3462

*/

3463

bool batadv_tt_local_client_is_roaming(struct batadv_priv *bat_priv,

3463

bool batadv_tt_local_client_is_roaming(struct batadv_priv *bat_priv,

3464

u8 *addr, unsigned short vid)

3464

u8 *addr, unsigned short vid)

3465

{

3465

{

3466

struct batadv_tt_local_entry *tt_local_entry;

3466

struct batadv_tt_local_entry *tt_local_entry;

3467

bool ret = false;

3467

bool ret = false;

3468

3469

tt_local_entry = batadv_tt_local_hash_find(bat_priv, addr, vid);

3469

tt_local_entry = batadv_tt_local_hash_find(bat_priv, addr, vid);

3470

if (!tt_local_entry)

3470

if (!tt_local_entry)

3471

goto out;

3471

goto out;

3472

3473

ret = tt_local_entry->common.flags & BATADV_TT_CLIENT_ROAM;

3473

ret = tt_local_entry->common.flags & BATADV_TT_CLIENT_ROAM;

3474

batadv_tt_local_entry_free_ref(tt_local_entry);

3474

batadv_tt_local_entry_free_ref(tt_local_entry);

3475

out:

3475

out:

3476

return ret;

3476

return ret;

3477

}

3477

}

3478

3479

bool batadv_tt_add_temporary_global_entry(struct batadv_priv *bat_priv,

3479

bool batadv_tt_add_temporary_global_entry(struct batadv_priv *bat_priv,

3480

struct batadv_orig_node *orig_node,

3480

struct batadv_orig_node *orig_node,

3481

const unsigned char *addr,

3481

const unsigned char *addr,

3482

unsigned short vid)

3482

unsigned short vid)

3483

{

3483

{

3484

bool ret = false;

3484

bool ret = false;

3485

3486

if (!batadv_tt_global_add(bat_priv, orig_node, addr, vid,

3486

if (!batadv_tt_global_add(bat_priv, orig_node, addr, vid,

3487

BATADV_TT_CLIENT_TEMP,

3487

BATADV_TT_CLIENT_TEMP,

3488

atomic_read(&orig_node->last_ttvn)))

3488

atomic_read(&orig_node->last_ttvn)))

3489

goto out;

3489

goto out;

3490

3491

batadv_dbg(BATADV_DBG_TT, bat_priv,

3491

batadv_dbg(BATADV_DBG_TT, bat_priv,

3492

"Added temporary global client (addr: %pM, vid: %d, orig: %pM)\n",

3492

"Added temporary global client (addr: %pM, vid: %d, orig: %pM)\n",

3493

addr, BATADV_PRINT_VID(vid), orig_node->orig);

3493

addr, BATADV_PRINT_VID(vid), orig_node->orig);

3494

ret = true;

3494

ret = true;

3495

out:

3495

out:

3496

return ret;

3496

return ret;

3497

}

3497

}

3498

3499

/**

3499

/**

3500

* batadv_tt_local_resize_to_mtu - resize the local translation table fit the

3500

* batadv_tt_local_resize_to_mtu - resize the local translation table fit the

3501

* maximum packet size that can be transported through the mesh

3501

* maximum packet size that can be transported through the mesh

3502

* @soft_iface: netdev struct of the mesh interface

3502

* @soft_iface: netdev struct of the mesh interface

3503

*

3503

*

3504

* Remove entries older than 'timeout' and half timeout if more entries need

3504

* Remove entries older than 'timeout' and half timeout if more entries need

3505

* to be removed.

3505

* to be removed.

3506

*/

3506

*/

3507

void batadv_tt_local_resize_to_mtu(struct net_device *soft_iface)

3507

void batadv_tt_local_resize_to_mtu(struct net_device *soft_iface)

3508

{

3508

{

3509

struct batadv_priv *bat_priv = netdev_priv(soft_iface);

3509

struct batadv_priv *bat_priv = netdev_priv(soft_iface);

3510

int packet_size_max = atomic_read(&bat_priv->packet_size_max);

3510

int packet_size_max = atomic_read(&bat_priv->packet_size_max);

3511

int table_size, timeout = BATADV_TT_LOCAL_TIMEOUT / 2;

3511

int table_size, timeout = BATADV_TT_LOCAL_TIMEOUT / 2;

3512

bool reduced = false;

3512

bool reduced = false;

3513

3514

spin_lock_bh(&bat_priv->tt.commit_lock);

3514

spin_lock_bh(&bat_priv->tt.commit_lock);

3515

3516

while (true) {

3516

while (true) {

3517

table_size = batadv_tt_local_table_transmit_size(bat_priv);

3517

table_size = batadv_tt_local_table_transmit_size(bat_priv);

3518

if (packet_size_max >= table_size)

3518

if (packet_size_max >= table_size)

3519

break;

3519

break;

3520

3521

batadv_tt_local_purge(bat_priv, timeout);

3521

batadv_tt_local_purge(bat_priv, timeout);

3522

batadv_tt_local_purge_pending_clients(bat_priv);

3522

batadv_tt_local_purge_pending_clients(bat_priv);

3523

3524

timeout /= 2;

3524

timeout /= 2;

3525

reduced = true;

3525

reduced = true;

3526

net_ratelimited_function(batadv_info, soft_iface,

3526

net_ratelimited_function(batadv_info, soft_iface,

3527

"Forced to purge local tt entries to fit new maximum fragment MTU (%i)\n",

3527

"Forced to purge local tt entries to fit new maximum fragment MTU (%i)\n",

3528

packet_size_max);

3528

packet_size_max);

3529

}

3529

}

3530

3531

/* commit these changes immediately, to avoid synchronization problem

3531

/* commit these changes immediately, to avoid synchronization problem

3532

* with the TTVN

3532

* with the TTVN

3533

*/

3533

*/

3534

if (reduced)

3534

if (reduced)

3535

batadv_tt_local_commit_changes_nolock(bat_priv);

3535

batadv_tt_local_commit_changes_nolock(bat_priv);

3536

3537

spin_unlock_bh(&bat_priv->tt.commit_lock);

3537

spin_unlock_bh(&bat_priv->tt.commit_lock);

3538

}

3538

}

3539

3540

/**

3540

/**

3541

* batadv_tt_tvlv_ogm_handler_v1 - process incoming tt tvlv container

3541

* batadv_tt_tvlv_ogm_handler_v1 - process incoming tt tvlv container

3542

* @bat_priv: the bat priv with all the soft interface information

3542

* @bat_priv: the bat priv with all the soft interface information

3543

* @orig: the orig_node of the ogm

3543

* @orig: the orig_node of the ogm

3544

* @flags: flags indicating the tvlv state (see batadv_tvlv_handler_flags)

3544

* @flags: flags indicating the tvlv state (see batadv_tvlv_handler_flags)

3545

* @tvlv_value: tvlv buffer containing the gateway data

3545

* @tvlv_value: tvlv buffer containing the gateway data

3546

* @tvlv_value_len: tvlv buffer length

3546

* @tvlv_value_len: tvlv buffer length

3547

*/

3547

*/

3548

static void batadv_tt_tvlv_ogm_handler_v1(struct batadv_priv *bat_priv,

3548

static void batadv_tt_tvlv_ogm_handler_v1(struct batadv_priv *bat_priv,

3549

struct batadv_orig_node *orig,

3549

struct batadv_orig_node *orig,

3550

u8 flags, void *tvlv_value,

3550

u8 flags, void *tvlv_value,

3551

u16 tvlv_value_len)

3551

u16 tvlv_value_len)

3552

{

3552

{

3553

struct batadv_tvlv_tt_vlan_data *tt_vlan;

3553

struct batadv_tvlv_tt_vlan_data *tt_vlan;

3554

struct batadv_tvlv_tt_change *tt_change;

3554

struct batadv_tvlv_tt_change *tt_change;

3555

struct batadv_tvlv_tt_data *tt_data;

3555

struct batadv_tvlv_tt_data *tt_data;

3556

u16 num_entries, num_vlan;

3556

u16 num_entries, num_vlan;

3557

3558

if (tvlv_value_len < sizeof(*tt_data))

3558

if (tvlv_value_len < sizeof(*tt_data))

3559

return;

3559

return;

3560

3561

tt_data = (struct batadv_tvlv_tt_data *)tvlv_value;

3561

tt_data = (struct batadv_tvlv_tt_data *)tvlv_value;

3562

tvlv_value_len -= sizeof(*tt_data);

3562

tvlv_value_len -= sizeof(*tt_data);

3563

3564

num_vlan = ntohs(tt_data->num_vlan);

3564

num_vlan = ntohs(tt_data->num_vlan);

3565

3566

if (tvlv_value_len < sizeof(*tt_vlan) * num_vlan)

3566

if (tvlv_value_len < sizeof(*tt_vlan) * num_vlan)

3567

return;

3567

return;

3568

3569

tt_vlan = (struct batadv_tvlv_tt_vlan_data *)(tt_data + 1);

3569

tt_vlan = (struct batadv_tvlv_tt_vlan_data *)(tt_data + 1);

3570

tt_change = (struct batadv_tvlv_tt_change *)(tt_vlan + num_vlan);

3570

tt_change = (struct batadv_tvlv_tt_change *)(tt_vlan + num_vlan);

3571

tvlv_value_len -= sizeof(*tt_vlan) * num_vlan;

3571

tvlv_value_len -= sizeof(*tt_vlan) * num_vlan;

3572

3573

num_entries = batadv_tt_entries(tvlv_value_len);

3573

num_entries = batadv_tt_entries(tvlv_value_len);

3574

3575

batadv_tt_update_orig(bat_priv, orig, tt_vlan, num_vlan, tt_change,

3575

batadv_tt_update_orig(bat_priv, orig, tt_vlan, num_vlan, tt_change,

3576

num_entries, tt_data->ttvn);

3576

num_entries, tt_data->ttvn);

3577

}

3577

}

3578

3579

/**

3579

/**

3580

* batadv_tt_tvlv_unicast_handler_v1 - process incoming (unicast) tt tvlv

3580

* batadv_tt_tvlv_unicast_handler_v1 - process incoming (unicast) tt tvlv

3581

* container

3581

* container

3582

* @bat_priv: the bat priv with all the soft interface information

3582

* @bat_priv: the bat priv with all the soft interface information

3583

* @src: mac address of tt tvlv sender

3583

* @src: mac address of tt tvlv sender

3584

* @dst: mac address of tt tvlv recipient

3584

* @dst: mac address of tt tvlv recipient

3585

* @tvlv_value: tvlv buffer containing the tt data

3585

* @tvlv_value: tvlv buffer containing the tt data

3586

* @tvlv_value_len: tvlv buffer length

3586

* @tvlv_value_len: tvlv buffer length

3587

*

3587

*

3588

* Returns NET_RX_DROP if the tt tvlv is to be re-routed, NET_RX_SUCCESS

3588

* Returns NET_RX_DROP if the tt tvlv is to be re-routed, NET_RX_SUCCESS

3589

* otherwise.

3589

* otherwise.

3590

*/

3590

*/

3591

static int batadv_tt_tvlv_unicast_handler_v1(struct batadv_priv *bat_priv,

3591

static int batadv_tt_tvlv_unicast_handler_v1(struct batadv_priv *bat_priv,

3592

u8 *src, u8 *dst,

3592

u8 *src, u8 *dst,

3593

void *tvlv_value,

3593

void *tvlv_value,

3594

u16 tvlv_value_len)

3594

u16 tvlv_value_len)

3595

{

3595

{

3596

struct batadv_tvlv_tt_data *tt_data;

3596

struct batadv_tvlv_tt_data *tt_data;

3597

u16 tt_vlan_len, tt_num_entries;

3597

u16 tt_vlan_len, tt_num_entries;

3598

char tt_flag;

3598

char tt_flag;

3599

bool ret;

3599

bool ret;

3600

3601

if (tvlv_value_len < sizeof(*tt_data))

3601

if (tvlv_value_len < sizeof(*tt_data))

3602

return NET_RX_SUCCESS;

3602

return NET_RX_SUCCESS;

3603

3604

tt_data = (struct batadv_tvlv_tt_data *)tvlv_value;

3604

tt_data = (struct batadv_tvlv_tt_data *)tvlv_value;

3605

tvlv_value_len -= sizeof(*tt_data);

3605

tvlv_value_len -= sizeof(*tt_data);

3606

3607

tt_vlan_len = sizeof(struct batadv_tvlv_tt_vlan_data);

3607

tt_vlan_len = sizeof(struct batadv_tvlv_tt_vlan_data);

3608

tt_vlan_len *= ntohs(tt_data->num_vlan);

3608

tt_vlan_len *= ntohs(tt_data->num_vlan);

3609

3610

if (tvlv_value_len < tt_vlan_len)

3610

if (tvlv_value_len < tt_vlan_len)

3611

return NET_RX_SUCCESS;

3611

return NET_RX_SUCCESS;

3612

3613

tvlv_value_len -= tt_vlan_len;

3613

tvlv_value_len -= tt_vlan_len;

3614

tt_num_entries = batadv_tt_entries(tvlv_value_len);

3614

tt_num_entries = batadv_tt_entries(tvlv_value_len);

3615

3616

switch (tt_data->flags & BATADV_TT_DATA_TYPE_MASK) {

3616

switch (tt_data->flags & BATADV_TT_DATA_TYPE_MASK) {

3617

case BATADV_TT_REQUEST:

3617

case BATADV_TT_REQUEST:

3618

batadv_inc_counter(bat_priv, BATADV_CNT_TT_REQUEST_RX);

3618

batadv_inc_counter(bat_priv, BATADV_CNT_TT_REQUEST_RX);

3619

3620

/* If this node cannot provide a TT response the tt_request is

3620

/* If this node cannot provide a TT response the tt_request is

3621

* forwarded

3621

* forwarded

3622

*/

3622

*/

3623

ret = batadv_send_tt_response(bat_priv, tt_data, src, dst);

3623

ret = batadv_send_tt_response(bat_priv, tt_data, src, dst);

3624

if (!ret) {

3624

if (!ret) {

3625

if (tt_data->flags & BATADV_TT_FULL_TABLE)

3625

if (tt_data->flags & BATADV_TT_FULL_TABLE)

3626

tt_flag = 'F';

3626

tt_flag = 'F';

3627

else

3627

else

3628

tt_flag = '.';

3628

tt_flag = '.';

3629

3630

batadv_dbg(BATADV_DBG_TT, bat_priv,

3630

batadv_dbg(BATADV_DBG_TT, bat_priv,

3631

"Routing TT_REQUEST to %pM [%c]\n",

3631

"Routing TT_REQUEST to %pM [%c]\n",

3632

dst, tt_flag);

3632

dst, tt_flag);

3633

/* tvlv API will re-route the packet */

3633

/* tvlv API will re-route the packet */

3634

return NET_RX_DROP;

3634

return NET_RX_DROP;

3635

}

3635

}

3636

break;

3636

break;

3637

case BATADV_TT_RESPONSE:

3637

case BATADV_TT_RESPONSE:

3638

batadv_inc_counter(bat_priv, BATADV_CNT_TT_RESPONSE_RX);

3638

batadv_inc_counter(bat_priv, BATADV_CNT_TT_RESPONSE_RX);

3639

3640

if (batadv_is_my_mac(bat_priv, dst)) {

3640

if (batadv_is_my_mac(bat_priv, dst)) {

3641

batadv_handle_tt_response(bat_priv, tt_data,

3641

batadv_handle_tt_response(bat_priv, tt_data,

3642

src, tt_num_entries);

3642

src, tt_num_entries);

3643

return NET_RX_SUCCESS;

3643

return NET_RX_SUCCESS;

3644

}

3644

}

3645

3646

if (tt_data->flags & BATADV_TT_FULL_TABLE)

3646

if (tt_data->flags & BATADV_TT_FULL_TABLE)

3647

tt_flag = 'F';

3647

tt_flag = 'F';

3648

else

3648

else

3649

tt_flag = '.';

3649

tt_flag = '.';

3650

3651

batadv_dbg(BATADV_DBG_TT, bat_priv,

3651

batadv_dbg(BATADV_DBG_TT, bat_priv,

3652

"Routing TT_RESPONSE to %pM [%c]\n", dst, tt_flag);

3652

"Routing TT_RESPONSE to %pM [%c]\n", dst, tt_flag);

3653

3654

/* tvlv API will re-route the packet */

3654

/* tvlv API will re-route the packet */

3655

return NET_RX_DROP;

3655

return NET_RX_DROP;

3656

}

3656

}

3657

3658

return NET_RX_SUCCESS;

3658

return NET_RX_SUCCESS;

3659

}

3659

}

3660

3661

/**

3661

/**

3662

* batadv_roam_tvlv_unicast_handler_v1 - process incoming tt roam tvlv container

3662

* batadv_roam_tvlv_unicast_handler_v1 - process incoming tt roam tvlv container

3663

* @bat_priv: the bat priv with all the soft interface information

3663

* @bat_priv: the bat priv with all the soft interface information

3664

* @src: mac address of tt tvlv sender

3664

* @src: mac address of tt tvlv sender

3665

* @dst: mac address of tt tvlv recipient

3665

* @dst: mac address of tt tvlv recipient

3666

* @tvlv_value: tvlv buffer containing the tt data

3666

* @tvlv_value: tvlv buffer containing the tt data

3667

* @tvlv_value_len: tvlv buffer length

3667

* @tvlv_value_len: tvlv buffer length

3668

*

3668

*

3669

* Returns NET_RX_DROP if the tt roam tvlv is to be re-routed, NET_RX_SUCCESS

3669

* Returns NET_RX_DROP if the tt roam tvlv is to be re-routed, NET_RX_SUCCESS

3670

* otherwise.

3670

* otherwise.

3671

*/

3671

*/

3672

static int batadv_roam_tvlv_unicast_handler_v1(struct batadv_priv *bat_priv,

3672

static int batadv_roam_tvlv_unicast_handler_v1(struct batadv_priv *bat_priv,

3673

u8 *src, u8 *dst,

3673

u8 *src, u8 *dst,

3674

void *tvlv_value,

3674

void *tvlv_value,

3675

u16 tvlv_value_len)

3675

u16 tvlv_value_len)

3676

{

3676

{

3677

struct batadv_tvlv_roam_adv *roaming_adv;

3677

struct batadv_tvlv_roam_adv *roaming_adv;

3678

struct batadv_orig_node *orig_node = NULL;

3678

struct batadv_orig_node *orig_node = NULL;

3679

3680

/* If this node is not the intended recipient of the

3680

/* If this node is not the intended recipient of the

3681

* roaming advertisement the packet is forwarded

3681

* roaming advertisement the packet is forwarded

3682

* (the tvlv API will re-route the packet).

3682

* (the tvlv API will re-route the packet).

3683

*/

3683

*/

3684

if (!batadv_is_my_mac(bat_priv, dst))

3684

if (!batadv_is_my_mac(bat_priv, dst))

3685

return NET_RX_DROP;

3685

return NET_RX_DROP;

3686

3687

if (tvlv_value_len < sizeof(*roaming_adv))

3687

if (tvlv_value_len < sizeof(*roaming_adv))

3688

goto out;

3688

goto out;

3689

3690

orig_node = batadv_orig_hash_find(bat_priv, src);

3690

orig_node = batadv_orig_hash_find(bat_priv, src);

3691

if (!orig_node)

3691

if (!orig_node)

3692

goto out;

3692

goto out;

3693

3694

batadv_inc_counter(bat_priv, BATADV_CNT_TT_ROAM_ADV_RX);

3694

batadv_inc_counter(bat_priv, BATADV_CNT_TT_ROAM_ADV_RX);

3695

roaming_adv = (struct batadv_tvlv_roam_adv *)tvlv_value;

3695

roaming_adv = (struct batadv_tvlv_roam_adv *)tvlv_value;

3696

3697

batadv_dbg(BATADV_DBG_TT, bat_priv,

3697

batadv_dbg(BATADV_DBG_TT, bat_priv,

3698

"Received ROAMING_ADV from %pM (client %pM)\n",

3698

"Received ROAMING_ADV from %pM (client %pM)\n",

3699

src, roaming_adv->client);

3699

src, roaming_adv->client);

3700

3701

batadv_tt_global_add(bat_priv, orig_node, roaming_adv->client,

3701

batadv_tt_global_add(bat_priv, orig_node, roaming_adv->client,

3702

ntohs(roaming_adv->vid), BATADV_TT_CLIENT_ROAM,

3702

ntohs(roaming_adv->vid), BATADV_TT_CLIENT_ROAM,

3703

atomic_read(&orig_node->last_ttvn) + 1);

3703

atomic_read(&orig_node->last_ttvn) + 1);

3704

3705

out:

3705

out:

3706

if (orig_node)

3706

if (orig_node)

3707

batadv_orig_node_free_ref(orig_node);

3707

batadv_orig_node_free_ref(orig_node);

3708

return NET_RX_SUCCESS;

3708

return NET_RX_SUCCESS;

3709

}

3709

}

3710

3711

/**

3711

/**

3712

* batadv_tt_init - initialise the translation table internals

3712

* batadv_tt_init - initialise the translation table internals

3713

* @bat_priv: the bat priv with all the soft interface information

3713

* @bat_priv: the bat priv with all the soft interface information

3714

*

3714

*

3715

* Return 0 on success or negative error number in case of failure.

3715

* Return 0 on success or negative error number in case of failure.

3716

*/

3716

*/

3717

int batadv_tt_init(struct batadv_priv *bat_priv)

3717

int batadv_tt_init(struct batadv_priv *bat_priv)

3718

{

3718

{

3719

int ret;

3719

int ret;

3720

3721

/* synchronized flags must be remote */

3721

/* synchronized flags must be remote */

3722

BUILD_BUG_ON(!(BATADV_TT_SYNC_MASK & BATADV_TT_REMOTE_MASK));

3722

BUILD_BUG_ON(!(BATADV_TT_SYNC_MASK & BATADV_TT_REMOTE_MASK));

3723

3724

ret = batadv_tt_local_init(bat_priv);

3724

ret = batadv_tt_local_init(bat_priv);

3725

if (ret < 0)

3725

if (ret < 0)

3726

return ret;

3726

return ret;

3727

3728

ret = batadv_tt_global_init(bat_priv);

3728

ret = batadv_tt_global_init(bat_priv);

3729

if (ret < 0)

3729

if (ret < 0)

3730

return ret;

3730

return ret;

3731

3732

batadv_tvlv_handler_register(bat_priv, batadv_tt_tvlv_ogm_handler_v1,

3732

batadv_tvlv_handler_register(bat_priv, batadv_tt_tvlv_ogm_handler_v1,

3733

batadv_tt_tvlv_unicast_handler_v1,

3733

batadv_tt_tvlv_unicast_handler_v1,

3734

BATADV_TVLV_TT, 1, BATADV_NO_FLAGS);

3734

BATADV_TVLV_TT, 1, BATADV_NO_FLAGS);

3735

3736

batadv_tvlv_handler_register(bat_priv, NULL,

3736

batadv_tvlv_handler_register(bat_priv, NULL,

3737

batadv_roam_tvlv_unicast_handler_v1,

3737

batadv_roam_tvlv_unicast_handler_v1,

3738

BATADV_TVLV_ROAM, 1, BATADV_NO_FLAGS);

3738

BATADV_TVLV_ROAM, 1, BATADV_NO_FLAGS);

3739

3740

INIT_DELAYED_WORK(&bat_priv->tt.work, batadv_tt_purge);

3740

INIT_DELAYED_WORK(&bat_priv->tt.work, batadv_tt_purge);

3741

queue_delayed_work(batadv_event_workqueue, &bat_priv->tt.work,

3741

queue_delayed_work(batadv_event_workqueue, &bat_priv->tt.work,

3742

msecs_to_jiffies(BATADV_TT_WORK_PERIOD));

3742

msecs_to_jiffies(BATADV_TT_WORK_PERIOD));

3743

3744

return 1;

3744

return 1;

3745

}

3745

}

3746

3747

/**

3747

/**

3748

* batadv_tt_global_is_isolated - check if a client is marked as isolated

3748

* batadv_tt_global_is_isolated - check if a client is marked as isolated

3749

* @bat_priv: the bat priv with all the soft interface information

3749

* @bat_priv: the bat priv with all the soft interface information

3750

* @addr: the mac address of the client

3750

* @addr: the mac address of the client

3751

* @vid: the identifier of the VLAN where this client is connected

3751

* @vid: the identifier of the VLAN where this client is connected

3752

*

3752

*

3753

* Returns true if the client is marked with the TT_CLIENT_ISOLA flag, false

3753

* Returns true if the client is marked with the TT_CLIENT_ISOLA flag, false

3754

* otherwise

3754

* otherwise

3755

*/

3755

*/

3756

bool batadv_tt_global_is_isolated(struct batadv_priv *bat_priv,

3756

bool batadv_tt_global_is_isolated(struct batadv_priv *bat_priv,

3757

const u8 *addr, unsigned short vid)

3757

const u8 *addr, unsigned short vid)

3758

{

3758

{

3759

struct batadv_tt_global_entry *tt;

3759

struct batadv_tt_global_entry *tt;

3760

bool ret;

3760

bool ret;

3761

3762

tt = batadv_tt_global_hash_find(bat_priv, addr, vid);

3762

tt = batadv_tt_global_hash_find(bat_priv, addr, vid);

3763

if (!tt)

3763

if (!tt)

3764

return false;

3764

return false;

3765

3766

ret = tt->common.flags & BATADV_TT_CLIENT_ISOLA;

3766

ret = tt->common.flags & BATADV_TT_CLIENT_ISOLA;

3767

3768

batadv_tt_global_entry_free_ref(tt);

3768

batadv_tt_global_entry_free_ref(tt);

3769

3770

return ret;

3770

return ret;

3771

}

3771

}

3772

GITLAB

Eric Lee / smarc-fsl-linux-kernel

batman-adv: prevent potential hlist double deletion