Doug / smarc-fsl-linux-kernel

1

/*

1

/*

2

3

4

5

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

5

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

6

it under the terms of the GNU General Public License as published by

6

it under the terms of the GNU General Public License as published by

7

the Free Software Foundation; either version 2 of the License, or

7

the Free Software Foundation; either version 2 of the License, or

8

(at your option) any later version.

8

(at your option) any later version.

9

10

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

10

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

11

but WITHOUT ANY WARRANTY; without even the implied warranty of

11

but WITHOUT ANY WARRANTY; without even the implied warranty of

12

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

12

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

13

GNU General Public License for more details.

13

GNU General Public License for more details.

14

15

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

15

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

16

along with this program; if not, write to the Free Software

16

along with this program; if not, write to the Free Software

17

Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

17

Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

18

*/

18

*/

19

#include <linux/module.h>

19

#include <linux/module.h>

20

#include <linux/moduleloader.h>

20

#include <linux/moduleloader.h>

21

#include <linux/init.h>

21

#include <linux/init.h>

22

#include <linux/kallsyms.h>

22

#include <linux/kallsyms.h>

23

#include <linux/sysfs.h>

23

#include <linux/sysfs.h>

24

#include <linux/kernel.h>

24

#include <linux/kernel.h>

25

#include <linux/slab.h>

25

#include <linux/slab.h>

26

#include <linux/vmalloc.h>

26

#include <linux/vmalloc.h>

27

#include <linux/elf.h>

27

#include <linux/elf.h>

28

#include <linux/seq_file.h>

28

#include <linux/seq_file.h>

29

#include <linux/syscalls.h>

29

#include <linux/syscalls.h>

30

#include <linux/fcntl.h>

30

#include <linux/fcntl.h>

31

#include <linux/rcupdate.h>

31

#include <linux/rcupdate.h>

32

#include <linux/capability.h>

32

#include <linux/capability.h>

33

#include <linux/cpu.h>

33

#include <linux/cpu.h>

34

#include <linux/moduleparam.h>

34

#include <linux/moduleparam.h>

35

#include <linux/errno.h>

35

#include <linux/errno.h>

36

#include <linux/err.h>

36

#include <linux/err.h>

37

#include <linux/vermagic.h>

37

#include <linux/vermagic.h>

38

#include <linux/notifier.h>

38

#include <linux/notifier.h>

39

#include <linux/sched.h>

39

#include <linux/sched.h>

40

#include <linux/stop_machine.h>

40

#include <linux/stop_machine.h>

41

#include <linux/device.h>

41

#include <linux/device.h>

42

#include <linux/string.h>

42

#include <linux/string.h>

43

#include <linux/mutex.h>

43

#include <linux/mutex.h>

44

#include <linux/unwind.h>

44

#include <linux/unwind.h>

45

#include <asm/uaccess.h>

45

#include <asm/uaccess.h>

46

#include <asm/cacheflush.h>

46

#include <asm/cacheflush.h>

47

#include <linux/license.h>

47

#include <linux/license.h>

48

#include <asm/sections.h>

48

#include <asm/sections.h>

49

50

#if 0

50

#if 0

51

#define DEBUGP printk

51

#define DEBUGP printk

52

#else

52

#else

53

#define DEBUGP(fmt , a...)

53

#define DEBUGP(fmt , a...)

54

#endif

54

#endif

55

56

#ifndef ARCH_SHF_SMALL

56

#ifndef ARCH_SHF_SMALL

57

#define ARCH_SHF_SMALL 0

57

#define ARCH_SHF_SMALL 0

58

#endif

58

#endif

59

60

/* If this is set, the section belongs in the init part of the module */

60

/* If this is set, the section belongs in the init part of the module */

61

#define INIT_OFFSET_MASK (1UL << (BITS_PER_LONG-1))

61

#define INIT_OFFSET_MASK (1UL << (BITS_PER_LONG-1))

62

63

/* List of modules, protected by module_mutex or preempt_disable

63

/* List of modules, protected by module_mutex or preempt_disable

64

* (add/delete uses stop_machine). */

64

* (add/delete uses stop_machine). */

65

static DEFINE_MUTEX(module_mutex);

65

static DEFINE_MUTEX(module_mutex);

66

static LIST_HEAD(modules);

66

static LIST_HEAD(modules);

67

68

/* Waiting for a module to finish initializing? */

68

/* Waiting for a module to finish initializing? */

69

static DECLARE_WAIT_QUEUE_HEAD(module_wq);

69

static DECLARE_WAIT_QUEUE_HEAD(module_wq);

70

71

static BLOCKING_NOTIFIER_HEAD(module_notify_list);

71

static BLOCKING_NOTIFIER_HEAD(module_notify_list);

72

73

int register_module_notifier(struct notifier_block * nb)

73

int register_module_notifier(struct notifier_block * nb)

74

{

74

{

75

return blocking_notifier_chain_register(&module_notify_list, nb);

75

return blocking_notifier_chain_register(&module_notify_list, nb);

76

}

76

}

77

EXPORT_SYMBOL(register_module_notifier);

77

EXPORT_SYMBOL(register_module_notifier);

78

79

int unregister_module_notifier(struct notifier_block * nb)

79

int unregister_module_notifier(struct notifier_block * nb)

80

{

80

{

81

return blocking_notifier_chain_unregister(&module_notify_list, nb);

81

return blocking_notifier_chain_unregister(&module_notify_list, nb);

82

}

82

}

83

EXPORT_SYMBOL(unregister_module_notifier);

83

EXPORT_SYMBOL(unregister_module_notifier);

84

85

/* We require a truly strong try_module_get(): 0 means failure due to

85

/* We require a truly strong try_module_get(): 0 means failure due to

86

ongoing or failed initialization etc. */

86

ongoing or failed initialization etc. */

87

static inline int strong_try_module_get(struct module *mod)

87

static inline int strong_try_module_get(struct module *mod)

88

{

88

{

89

if (mod && mod->state == MODULE_STATE_COMING)

89

if (mod && mod->state == MODULE_STATE_COMING)

90

return -EBUSY;

90

return -EBUSY;

91

if (try_module_get(mod))

91

if (try_module_get(mod))

92

return 0;

92

return 0;

93

else

93

else

94

return -ENOENT;

94

return -ENOENT;

95

}

95

}

96

97

static inline void add_taint_module(struct module *mod, unsigned flag)

97

static inline void add_taint_module(struct module *mod, unsigned flag)

98

{

98

{

99

add_taint(flag);

99

add_taint(flag);

100

mod->taints |= flag;

100

mod->taints |= flag;

101

}

101

}

102

103

/*

103

/*

104

* A thread that wants to hold a reference to a module only while it

104

* A thread that wants to hold a reference to a module only while it

105

* is running can call this to safely exit. nfsd and lockd use this.

105

* is running can call this to safely exit. nfsd and lockd use this.

106

*/

106

*/

107

void __module_put_and_exit(struct module *mod, long code)

107

void __module_put_and_exit(struct module *mod, long code)

108

{

108

{

109

module_put(mod);

109

module_put(mod);

110

do_exit(code);

110

do_exit(code);

111

}

111

}

112

EXPORT_SYMBOL(__module_put_and_exit);

112

EXPORT_SYMBOL(__module_put_and_exit);

113

114

/* Find a module section: 0 means not found. */

114

/* Find a module section: 0 means not found. */

115

static unsigned int find_sec(Elf_Ehdr *hdr,

115

static unsigned int find_sec(Elf_Ehdr *hdr,

116

Elf_Shdr *sechdrs,

116

Elf_Shdr *sechdrs,

117

const char *secstrings,

117

const char *secstrings,

118

const char *name)

118

const char *name)

119

{

119

{

120

unsigned int i;

120

unsigned int i;

121

122

for (i = 1; i < hdr->e_shnum; i++)

122

for (i = 1; i < hdr->e_shnum; i++)

123

/* Alloc bit cleared means "ignore it." */

123

/* Alloc bit cleared means "ignore it." */

124

if ((sechdrs[i].sh_flags & SHF_ALLOC)

124

if ((sechdrs[i].sh_flags & SHF_ALLOC)

125

&& strcmp(secstrings+sechdrs[i].sh_name, name) == 0)

125

&& strcmp(secstrings+sechdrs[i].sh_name, name) == 0)

126

return i;

126

return i;

127

return 0;

127

return 0;

128

}

128

}

129

130

/* Provided by the linker */

130

/* Provided by the linker */

131

extern const struct kernel_symbol __start___ksymtab[];

131

extern const struct kernel_symbol __start___ksymtab[];

132

extern const struct kernel_symbol __stop___ksymtab[];

132

extern const struct kernel_symbol __stop___ksymtab[];

133

extern const struct kernel_symbol __start___ksymtab_gpl[];

133

extern const struct kernel_symbol __start___ksymtab_gpl[];

134

extern const struct kernel_symbol __stop___ksymtab_gpl[];

134

extern const struct kernel_symbol __stop___ksymtab_gpl[];

135

extern const struct kernel_symbol __start___ksymtab_gpl_future[];

135

extern const struct kernel_symbol __start___ksymtab_gpl_future[];

136

extern const struct kernel_symbol __stop___ksymtab_gpl_future[];

136

extern const struct kernel_symbol __stop___ksymtab_gpl_future[];

137

extern const struct kernel_symbol __start___ksymtab_unused[];

137

extern const struct kernel_symbol __start___ksymtab_unused[];

138

extern const struct kernel_symbol __stop___ksymtab_unused[];

138

extern const struct kernel_symbol __stop___ksymtab_unused[];

139

extern const struct kernel_symbol __start___ksymtab_unused_gpl[];

139

extern const struct kernel_symbol __start___ksymtab_unused_gpl[];

140

extern const struct kernel_symbol __stop___ksymtab_unused_gpl[];

140

extern const struct kernel_symbol __stop___ksymtab_unused_gpl[];

141

extern const struct kernel_symbol __start___ksymtab_gpl_future[];

141

extern const struct kernel_symbol __start___ksymtab_gpl_future[];

142

extern const struct kernel_symbol __stop___ksymtab_gpl_future[];

142

extern const struct kernel_symbol __stop___ksymtab_gpl_future[];

143

extern const unsigned long __start___kcrctab[];

143

extern const unsigned long __start___kcrctab[];

144

extern const unsigned long __start___kcrctab_gpl[];

144

extern const unsigned long __start___kcrctab_gpl[];

145

extern const unsigned long __start___kcrctab_gpl_future[];

145

extern const unsigned long __start___kcrctab_gpl_future[];

146

extern const unsigned long __start___kcrctab_unused[];

146

extern const unsigned long __start___kcrctab_unused[];

147

extern const unsigned long __start___kcrctab_unused_gpl[];

147

extern const unsigned long __start___kcrctab_unused_gpl[];

148

149

#ifndef CONFIG_MODVERSIONS

149

#ifndef CONFIG_MODVERSIONS

150

#define symversion(base, idx) NULL

150

#define symversion(base, idx) NULL

151

#else

151

#else

152

#define symversion(base, idx) ((base != NULL) ? ((base) + (idx)) : NULL)

152

#define symversion(base, idx) ((base != NULL) ? ((base) + (idx)) : NULL)

153

#endif

153

#endif

154

155

/* lookup symbol in given range of kernel_symbols */

155

/* lookup symbol in given range of kernel_symbols */

156

static const struct kernel_symbol *lookup_symbol(const char *name,

156

static const struct kernel_symbol *lookup_symbol(const char *name,

157

const struct kernel_symbol *start,

157

const struct kernel_symbol *start,

158

const struct kernel_symbol *stop)

158

const struct kernel_symbol *stop)

159

{

159

{

160

const struct kernel_symbol *ks = start;

160

const struct kernel_symbol *ks = start;

161

for (; ks < stop; ks++)

161

for (; ks < stop; ks++)

162

if (strcmp(ks->name, name) == 0)

162

if (strcmp(ks->name, name) == 0)

163

return ks;

163

return ks;

164

return NULL;

164

return NULL;

165

}

165

}

166

167

static void printk_unused_warning(const char *name)

167

static void printk_unused_warning(const char *name)

168

{

168

{

169

printk(KERN_WARNING "Symbol %s is marked as UNUSED, "

169

printk(KERN_WARNING "Symbol %s is marked as UNUSED, "

170

"however this module is using it.\n", name);

170

"however this module is using it.\n", name);

171

printk(KERN_WARNING "This symbol will go away in the future.\n");

171

printk(KERN_WARNING "This symbol will go away in the future.\n");

172

printk(KERN_WARNING "Please evalute if this is the right api to use, "

172

printk(KERN_WARNING "Please evalute if this is the right api to use, "

173

"and if it really is, submit a report the linux kernel "

173

"and if it really is, submit a report the linux kernel "

174

"mailinglist together with submitting your code for "

174

"mailinglist together with submitting your code for "

175

"inclusion.\n");

175

"inclusion.\n");

176

}

176

}

177

178

/* Find a symbol, return value, crc and module which owns it */

178

/* Find a symbol, return value, crc and module which owns it */

179

static unsigned long __find_symbol(const char *name,

179

static unsigned long __find_symbol(const char *name,

180

struct module **owner,

180

struct module **owner,

181

const unsigned long **crc,

181

const unsigned long **crc,

182

int gplok)

182

int gplok)

183

{

183

{

184

struct module *mod;

184

struct module *mod;

185

const struct kernel_symbol *ks;

185

const struct kernel_symbol *ks;

186

187

/* Core kernel first. */

187

/* Core kernel first. */

188

*owner = NULL;

188

*owner = NULL;

189

ks = lookup_symbol(name, __start___ksymtab, __stop___ksymtab);

189

ks = lookup_symbol(name, __start___ksymtab, __stop___ksymtab);

190

if (ks) {

190

if (ks) {

191

*crc = symversion(__start___kcrctab, (ks - __start___ksymtab));

191

*crc = symversion(__start___kcrctab, (ks - __start___ksymtab));

192

return ks->value;

192

return ks->value;

193

}

193

}

194

if (gplok) {

194

if (gplok) {

195

ks = lookup_symbol(name, __start___ksymtab_gpl,

195

ks = lookup_symbol(name, __start___ksymtab_gpl,

196

__stop___ksymtab_gpl);

196

__stop___ksymtab_gpl);

197

if (ks) {

197

if (ks) {

198

*crc = symversion(__start___kcrctab_gpl,

198

*crc = symversion(__start___kcrctab_gpl,

199

(ks - __start___ksymtab_gpl));

199

(ks - __start___ksymtab_gpl));

200

return ks->value;

200

return ks->value;

201

}

201

}

202

}

202

}

203

ks = lookup_symbol(name, __start___ksymtab_gpl_future,

203

ks = lookup_symbol(name, __start___ksymtab_gpl_future,

204

__stop___ksymtab_gpl_future);

204

__stop___ksymtab_gpl_future);

205

if (ks) {

205

if (ks) {

206

if (!gplok) {

206

if (!gplok) {

207

printk(KERN_WARNING "Symbol %s is being used "

207

printk(KERN_WARNING "Symbol %s is being used "

208

"by a non-GPL module, which will not "

208

"by a non-GPL module, which will not "

209

"be allowed in the future\n", name);

209

"be allowed in the future\n", name);

210

printk(KERN_WARNING "Please see the file "

210

printk(KERN_WARNING "Please see the file "

211

"Documentation/feature-removal-schedule.txt "

211

"Documentation/feature-removal-schedule.txt "

212

"in the kernel source tree for more "

212

"in the kernel source tree for more "

213

"details.\n");

213

"details.\n");

214

}

214

}

215

*crc = symversion(__start___kcrctab_gpl_future,

215

*crc = symversion(__start___kcrctab_gpl_future,

216

(ks - __start___ksymtab_gpl_future));

216

(ks - __start___ksymtab_gpl_future));

217

return ks->value;

217

return ks->value;

218

}

218

}

219

220

ks = lookup_symbol(name, __start___ksymtab_unused,

220

ks = lookup_symbol(name, __start___ksymtab_unused,

221

__stop___ksymtab_unused);

221

__stop___ksymtab_unused);

222

if (ks) {

222

if (ks) {

223

printk_unused_warning(name);

223

printk_unused_warning(name);

224

*crc = symversion(__start___kcrctab_unused,

224

*crc = symversion(__start___kcrctab_unused,

225

(ks - __start___ksymtab_unused));

225

(ks - __start___ksymtab_unused));

226

return ks->value;

226

return ks->value;

227

}

227

}

228

229

if (gplok)

229

if (gplok)

230

ks = lookup_symbol(name, __start___ksymtab_unused_gpl,

230

ks = lookup_symbol(name, __start___ksymtab_unused_gpl,

231

__stop___ksymtab_unused_gpl);

231

__stop___ksymtab_unused_gpl);

232

if (ks) {

232

if (ks) {

233

printk_unused_warning(name);

233

printk_unused_warning(name);

234

*crc = symversion(__start___kcrctab_unused_gpl,

234

*crc = symversion(__start___kcrctab_unused_gpl,

235

(ks - __start___ksymtab_unused_gpl));

235

(ks - __start___ksymtab_unused_gpl));

236

return ks->value;

236

return ks->value;

237

}

237

}

238

239

/* Now try modules. */

239

/* Now try modules. */

240

list_for_each_entry(mod, &modules, list) {

240

list_for_each_entry(mod, &modules, list) {

241

*owner = mod;

241

*owner = mod;

242

ks = lookup_symbol(name, mod->syms, mod->syms + mod->num_syms);

242

ks = lookup_symbol(name, mod->syms, mod->syms + mod->num_syms);

243

if (ks) {

243

if (ks) {

244

*crc = symversion(mod->crcs, (ks - mod->syms));

244

*crc = symversion(mod->crcs, (ks - mod->syms));

245

return ks->value;

245

return ks->value;

246

}

246

}

247

248

if (gplok) {

248

if (gplok) {

249

ks = lookup_symbol(name, mod->gpl_syms,

249

ks = lookup_symbol(name, mod->gpl_syms,

250

mod->gpl_syms + mod->num_gpl_syms);

250

mod->gpl_syms + mod->num_gpl_syms);

251

if (ks) {

251

if (ks) {

252

*crc = symversion(mod->gpl_crcs,

252

*crc = symversion(mod->gpl_crcs,

253

(ks - mod->gpl_syms));

253

(ks - mod->gpl_syms));

254

return ks->value;

254

return ks->value;

255

}

255

}

256

}

256

}

257

ks = lookup_symbol(name, mod->unused_syms, mod->unused_syms + mod->num_unused_syms);

257

ks = lookup_symbol(name, mod->unused_syms, mod->unused_syms + mod->num_unused_syms);

258

if (ks) {

258

if (ks) {

259

printk_unused_warning(name);

259

printk_unused_warning(name);

260

*crc = symversion(mod->unused_crcs, (ks - mod->unused_syms));

260

*crc = symversion(mod->unused_crcs, (ks - mod->unused_syms));

261

return ks->value;

261

return ks->value;

262

}

262

}

263

264

if (gplok) {

264

if (gplok) {

265

ks = lookup_symbol(name, mod->unused_gpl_syms,

265

ks = lookup_symbol(name, mod->unused_gpl_syms,

266

mod->unused_gpl_syms + mod->num_unused_gpl_syms);

266

mod->unused_gpl_syms + mod->num_unused_gpl_syms);

267

if (ks) {

267

if (ks) {

268

printk_unused_warning(name);

268

printk_unused_warning(name);

269

*crc = symversion(mod->unused_gpl_crcs,

269

*crc = symversion(mod->unused_gpl_crcs,

270

(ks - mod->unused_gpl_syms));

270

(ks - mod->unused_gpl_syms));

271

return ks->value;

271

return ks->value;

272

}

272

}

273

}

273

}

274

ks = lookup_symbol(name, mod->gpl_future_syms,

274

ks = lookup_symbol(name, mod->gpl_future_syms,

275

(mod->gpl_future_syms +

275

(mod->gpl_future_syms +

276

mod->num_gpl_future_syms));

276

mod->num_gpl_future_syms));

277

if (ks) {

277

if (ks) {

278

if (!gplok) {

278

if (!gplok) {

279

printk(KERN_WARNING "Symbol %s is being used "

279

printk(KERN_WARNING "Symbol %s is being used "

280

"by a non-GPL module, which will not "

280

"by a non-GPL module, which will not "

281

"be allowed in the future\n", name);

281

"be allowed in the future\n", name);

282

printk(KERN_WARNING "Please see the file "

282

printk(KERN_WARNING "Please see the file "

283

"Documentation/feature-removal-schedule.txt "

283

"Documentation/feature-removal-schedule.txt "

284

"in the kernel source tree for more "

284

"in the kernel source tree for more "

285

"details.\n");

285

"details.\n");

286

}

286

}

287

*crc = symversion(mod->gpl_future_crcs,

287

*crc = symversion(mod->gpl_future_crcs,

288

(ks - mod->gpl_future_syms));

288

(ks - mod->gpl_future_syms));

289

return ks->value;

289

return ks->value;

290

}

290

}

291

}

291

}

292

DEBUGP("Failed to find symbol %s\n", name);

292

DEBUGP("Failed to find symbol %s\n", name);

293

return -ENOENT;

293

return -ENOENT;

294

}

294

}

295

296

/* Search for module by name: must hold module_mutex. */

296

/* Search for module by name: must hold module_mutex. */

297

static struct module *find_module(const char *name)

297

static struct module *find_module(const char *name)

298

{

298

{

299

struct module *mod;

299

struct module *mod;

300

301

list_for_each_entry(mod, &modules, list) {

301

list_for_each_entry(mod, &modules, list) {

302

if (strcmp(mod->name, name) == 0)

302

if (strcmp(mod->name, name) == 0)

303

return mod;

303

return mod;

304

}

304

}

305

return NULL;

305

return NULL;

306

}

306

}

307

308

#ifdef CONFIG_SMP

308

#ifdef CONFIG_SMP

309

/* Number of blocks used and allocated. */

309

/* Number of blocks used and allocated. */

310

static unsigned int pcpu_num_used, pcpu_num_allocated;

310

static unsigned int pcpu_num_used, pcpu_num_allocated;

311

/* Size of each block. -ve means used. */

311

/* Size of each block. -ve means used. */

312

static int *pcpu_size;

312

static int *pcpu_size;

313

314

static int split_block(unsigned int i, unsigned short size)

314

static int split_block(unsigned int i, unsigned short size)

315

{

315

{

316

/* Reallocation required? */

316

/* Reallocation required? */

317

if (pcpu_num_used + 1 > pcpu_num_allocated) {

317

if (pcpu_num_used + 1 > pcpu_num_allocated) {

318

int *new;

318

int *new;

319

320

new = krealloc(pcpu_size, sizeof(new[0])*pcpu_num_allocated*2,

320

new = krealloc(pcpu_size, sizeof(new[0])*pcpu_num_allocated*2,

321

GFP_KERNEL);

321

GFP_KERNEL);

322

if (!new)

322

if (!new)

323

return 0;

323

return 0;

324

325

pcpu_num_allocated *= 2;

325

pcpu_num_allocated *= 2;

326

pcpu_size = new;

326

pcpu_size = new;

327

}

327

}

328

329

/* Insert a new subblock */

329

/* Insert a new subblock */

330

memmove(&pcpu_size[i+1], &pcpu_size[i],

330

memmove(&pcpu_size[i+1], &pcpu_size[i],

331

sizeof(pcpu_size[0]) * (pcpu_num_used - i));

331

sizeof(pcpu_size[0]) * (pcpu_num_used - i));

332

pcpu_num_used++;

332

pcpu_num_used++;

333

334

pcpu_size[i+1] -= size;

334

pcpu_size[i+1] -= size;

335

pcpu_size[i] = size;

335

pcpu_size[i] = size;

336

return 1;

336

return 1;

337

}

337

}

338

339

static inline unsigned int block_size(int val)

339

static inline unsigned int block_size(int val)

340

{

340

{

341

if (val < 0)

341

if (val < 0)

342

return -val;

342

return -val;

343

return val;

343

return val;

344

}

344

}

345

346

static void *percpu_modalloc(unsigned long size, unsigned long align,

346

static void *percpu_modalloc(unsigned long size, unsigned long align,

347

const char *name)

347

const char *name)

348

{

348

{

349

unsigned long extra;

349

unsigned long extra;

350

unsigned int i;

350

unsigned int i;

351

void *ptr;

351

void *ptr;

352

353

if (align > PAGE_SIZE) {

353

if (align > PAGE_SIZE) {

354

printk(KERN_WARNING "%s: per-cpu alignment %li > %li\n",

354

printk(KERN_WARNING "%s: per-cpu alignment %li > %li\n",

355

name, align, PAGE_SIZE);

355

name, align, PAGE_SIZE);

356

align = PAGE_SIZE;

356

align = PAGE_SIZE;

357

}

357

}

358

359

ptr = __per_cpu_start;

359

ptr = __per_cpu_start;

360

for (i = 0; i < pcpu_num_used; ptr += block_size(pcpu_size[i]), i++) {

360

for (i = 0; i < pcpu_num_used; ptr += block_size(pcpu_size[i]), i++) {

361

/* Extra for alignment requirement. */

361

/* Extra for alignment requirement. */

362

extra = ALIGN((unsigned long)ptr, align) - (unsigned long)ptr;

362

extra = ALIGN((unsigned long)ptr, align) - (unsigned long)ptr;

363

BUG_ON(i == 0 && extra != 0);

363

BUG_ON(i == 0 && extra != 0);

364

365

if (pcpu_size[i] < 0 || pcpu_size[i] < extra + size)

365

if (pcpu_size[i] < 0 || pcpu_size[i] < extra + size)

366

continue;

366

continue;

367

368

/* Transfer extra to previous block. */

368

/* Transfer extra to previous block. */

369

if (pcpu_size[i-1] < 0)

369

if (pcpu_size[i-1] < 0)

370

pcpu_size[i-1] -= extra;

370

pcpu_size[i-1] -= extra;

371

else

371

else

372

pcpu_size[i-1] += extra;

372

pcpu_size[i-1] += extra;

373

pcpu_size[i] -= extra;

373

pcpu_size[i] -= extra;

374

ptr += extra;

374

ptr += extra;

375

376

/* Split block if warranted */

376

/* Split block if warranted */

377

if (pcpu_size[i] - size > sizeof(unsigned long))

377

if (pcpu_size[i] - size > sizeof(unsigned long))

378

if (!split_block(i, size))

378

if (!split_block(i, size))

379

return NULL;

379

return NULL;

380

381

/* Mark allocated */

381

/* Mark allocated */

382

pcpu_size[i] = -pcpu_size[i];

382

pcpu_size[i] = -pcpu_size[i];

383

return ptr;

383

return ptr;

384

}

384

}

385

386

printk(KERN_WARNING "Could not allocate %lu bytes percpu data\n",

386

printk(KERN_WARNING "Could not allocate %lu bytes percpu data\n",

387

size);

387

size);

388

return NULL;

388

return NULL;

389

}

389

}

390

391

static void percpu_modfree(void *freeme)

391

static void percpu_modfree(void *freeme)

392

{

392

{

393

unsigned int i;

393

unsigned int i;

394

void *ptr = __per_cpu_start + block_size(pcpu_size[0]);

394

void *ptr = __per_cpu_start + block_size(pcpu_size[0]);

395

396

/* First entry is core kernel percpu data. */

396

/* First entry is core kernel percpu data. */

397

for (i = 1; i < pcpu_num_used; ptr += block_size(pcpu_size[i]), i++) {

397

for (i = 1; i < pcpu_num_used; ptr += block_size(pcpu_size[i]), i++) {

398

if (ptr == freeme) {

398

if (ptr == freeme) {

399

pcpu_size[i] = -pcpu_size[i];

399

pcpu_size[i] = -pcpu_size[i];

400

goto free;

400

goto free;

401

}

401

}

402

}

402

}

403

BUG();

403

BUG();

404

405

free:

405

free:

406

/* Merge with previous? */

406

/* Merge with previous? */

407

if (pcpu_size[i-1] >= 0) {

407

if (pcpu_size[i-1] >= 0) {

408

pcpu_size[i-1] += pcpu_size[i];

408

pcpu_size[i-1] += pcpu_size[i];

409

pcpu_num_used--;

409

pcpu_num_used--;

410

memmove(&pcpu_size[i], &pcpu_size[i+1],

410

memmove(&pcpu_size[i], &pcpu_size[i+1],

411

(pcpu_num_used - i) * sizeof(pcpu_size[0]));

411

(pcpu_num_used - i) * sizeof(pcpu_size[0]));

412

i--;

412

i--;

413

}

413

}

414

/* Merge with next? */

414

/* Merge with next? */

415

if (i+1 < pcpu_num_used && pcpu_size[i+1] >= 0) {

415

if (i+1 < pcpu_num_used && pcpu_size[i+1] >= 0) {

416

pcpu_size[i] += pcpu_size[i+1];

416

pcpu_size[i] += pcpu_size[i+1];

417

pcpu_num_used--;

417

pcpu_num_used--;

418

memmove(&pcpu_size[i+1], &pcpu_size[i+2],

418

memmove(&pcpu_size[i+1], &pcpu_size[i+2],

419

(pcpu_num_used - (i+1)) * sizeof(pcpu_size[0]));

419

(pcpu_num_used - (i+1)) * sizeof(pcpu_size[0]));

420

}

420

}

421

}

421

}

422

423

static unsigned int find_pcpusec(Elf_Ehdr *hdr,

423

static unsigned int find_pcpusec(Elf_Ehdr *hdr,

424

Elf_Shdr *sechdrs,

424

Elf_Shdr *sechdrs,

425

const char *secstrings)

425

const char *secstrings)

426

{

426

{

427

return find_sec(hdr, sechdrs, secstrings, ".data.percpu");

427

return find_sec(hdr, sechdrs, secstrings, ".data.percpu");

428

}

428

}

429

430

static void percpu_modcopy(void *pcpudest, const void *from, unsigned long size)

430

static void percpu_modcopy(void *pcpudest, const void *from, unsigned long size)

431

{

431

{

432

int cpu;

432

int cpu;

433

434

for_each_possible_cpu(cpu)

434

for_each_possible_cpu(cpu)

435

memcpy(pcpudest + per_cpu_offset(cpu), from, size);

435

memcpy(pcpudest + per_cpu_offset(cpu), from, size);

436

}

436

}

437

438

static int percpu_modinit(void)

438

static int percpu_modinit(void)

439

{

439

{

440

pcpu_num_used = 2;

440

pcpu_num_used = 2;

441

pcpu_num_allocated = 2;

441

pcpu_num_allocated = 2;

442

pcpu_size = kmalloc(sizeof(pcpu_size[0]) * pcpu_num_allocated,

442

pcpu_size = kmalloc(sizeof(pcpu_size[0]) * pcpu_num_allocated,

443

GFP_KERNEL);

443

GFP_KERNEL);

444

/* Static in-kernel percpu data (used). */

444

/* Static in-kernel percpu data (used). */

445

pcpu_size[0] = -(__per_cpu_end-__per_cpu_start);

445

pcpu_size[0] = -(__per_cpu_end-__per_cpu_start);

446

/* Free room. */

446

/* Free room. */

447

pcpu_size[1] = PERCPU_ENOUGH_ROOM + pcpu_size[0];

447

pcpu_size[1] = PERCPU_ENOUGH_ROOM + pcpu_size[0];

448

if (pcpu_size[1] < 0) {

448

if (pcpu_size[1] < 0) {

449

printk(KERN_ERR "No per-cpu room for modules.\n");

449

printk(KERN_ERR "No per-cpu room for modules.\n");

450

pcpu_num_used = 1;

450

pcpu_num_used = 1;

451

}

451

}

452

453

return 0;

453

return 0;

454

}

454

}

455

__initcall(percpu_modinit);

455

__initcall(percpu_modinit);

456

#else /* ... !CONFIG_SMP */

456

#else /* ... !CONFIG_SMP */

457

static inline void *percpu_modalloc(unsigned long size, unsigned long align,

457

static inline void *percpu_modalloc(unsigned long size, unsigned long align,

458

const char *name)

458

const char *name)

459

{

459

{

460

return NULL;

460

return NULL;

461

}

461

}

462

static inline void percpu_modfree(void *pcpuptr)

462

static inline void percpu_modfree(void *pcpuptr)

463

{

463

{

464

BUG();

464

BUG();

465

}

465

}

466

static inline unsigned int find_pcpusec(Elf_Ehdr *hdr,

466

static inline unsigned int find_pcpusec(Elf_Ehdr *hdr,

467

Elf_Shdr *sechdrs,

467

Elf_Shdr *sechdrs,

468

const char *secstrings)

468

const char *secstrings)

469

{

469

{

470

return 0;

470

return 0;

471

}

471

}

472

static inline void percpu_modcopy(void *pcpudst, const void *src,

472

static inline void percpu_modcopy(void *pcpudst, const void *src,

473

unsigned long size)

473

unsigned long size)

474

{

474

{

475

/* pcpusec should be 0, and size of that section should be 0. */

475

/* pcpusec should be 0, and size of that section should be 0. */

476

BUG_ON(size != 0);

476

BUG_ON(size != 0);

477

}

477

}

478

#endif /* CONFIG_SMP */

478

#endif /* CONFIG_SMP */

479

480

#define MODINFO_ATTR(field) \

480

#define MODINFO_ATTR(field) \

481

static void setup_modinfo_##field(struct module *mod, const char *s) \

481

static void setup_modinfo_##field(struct module *mod, const char *s) \

482

{ \

482

{ \

483

mod->field = kstrdup(s, GFP_KERNEL); \

483

mod->field = kstrdup(s, GFP_KERNEL); \

484

} \

484

} \

485

static ssize_t show_modinfo_##field(struct module_attribute *mattr, \

485

static ssize_t show_modinfo_##field(struct module_attribute *mattr, \

486

struct module *mod, char *buffer) \

486

struct module *mod, char *buffer) \

487

{ \

487

{ \

488

return sprintf(buffer, "%s\n", mod->field); \

488

return sprintf(buffer, "%s\n", mod->field); \

489

} \

489

} \

490

static int modinfo_##field##_exists(struct module *mod) \

490

static int modinfo_##field##_exists(struct module *mod) \

491

{ \

491

{ \

492

return mod->field != NULL; \

492

return mod->field != NULL; \

493

} \

493

} \

494

static void free_modinfo_##field(struct module *mod) \

494

static void free_modinfo_##field(struct module *mod) \

495

{ \

495

{ \

496

kfree(mod->field); \

496

kfree(mod->field); \

497

mod->field = NULL; \

497

mod->field = NULL; \

498

} \

498

} \

499

static struct module_attribute modinfo_##field = { \

499

static struct module_attribute modinfo_##field = { \

500

.attr = { .name = __stringify(field), .mode = 0444 }, \

500

.attr = { .name = __stringify(field), .mode = 0444 }, \

501

.show = show_modinfo_##field, \

501

.show = show_modinfo_##field, \

502

.setup = setup_modinfo_##field, \

502

.setup = setup_modinfo_##field, \

503

.test = modinfo_##field##_exists, \

503

.test = modinfo_##field##_exists, \

504

.free = free_modinfo_##field, \

504

.free = free_modinfo_##field, \

505

};

505

};

506

507

MODINFO_ATTR(version);

507

MODINFO_ATTR(version);

508

MODINFO_ATTR(srcversion);

508

MODINFO_ATTR(srcversion);

509

510

static char last_unloaded_module[MODULE_NAME_LEN+1];

510

static char last_unloaded_module[MODULE_NAME_LEN+1];

511

512

#ifdef CONFIG_MODULE_UNLOAD

512

#ifdef CONFIG_MODULE_UNLOAD

513

/* Init the unload section of the module. */

513

/* Init the unload section of the module. */

514

static void module_unload_init(struct module *mod)

514

static void module_unload_init(struct module *mod)

515

{

515

{

516

unsigned int i;

516

unsigned int i;

517

518

INIT_LIST_HEAD(&mod->modules_which_use_me);

518

INIT_LIST_HEAD(&mod->modules_which_use_me);

519

for (i = 0; i < NR_CPUS; i++)

519

for (i = 0; i < NR_CPUS; i++)

520

local_set(&mod->ref[i].count, 0);

520

local_set(&mod->ref[i].count, 0);

521

/* Hold reference count during initialization. */

521

/* Hold reference count during initialization. */

522

local_set(&mod->ref[raw_smp_processor_id()].count, 1);

522

local_set(&mod->ref[raw_smp_processor_id()].count, 1);

523

/* Backwards compatibility macros put refcount during init. */

523

/* Backwards compatibility macros put refcount during init. */

524

mod->waiter = current;

524

mod->waiter = current;

525

}

525

}

526

527

/* modules using other modules */

527

/* modules using other modules */

528

struct module_use

528

struct module_use

529

{

529

{

530

struct list_head list;

530

struct list_head list;

531

struct module *module_which_uses;

531

struct module *module_which_uses;

532

};

532

};

533

534

/* Does a already use b? */

534

/* Does a already use b? */

535

static int already_uses(struct module *a, struct module *b)

535

static int already_uses(struct module *a, struct module *b)

536

{

536

{

537

struct module_use *use;

537

struct module_use *use;

538

539

list_for_each_entry(use, &b->modules_which_use_me, list) {

539

list_for_each_entry(use, &b->modules_which_use_me, list) {

540

if (use->module_which_uses == a) {

540

if (use->module_which_uses == a) {

541

DEBUGP("%s uses %s!\n", a->name, b->name);

541

DEBUGP("%s uses %s!\n", a->name, b->name);

542

return 1;

542

return 1;

543

}

543

}

544

}

544

}

545

DEBUGP("%s does not use %s!\n", a->name, b->name);

545

DEBUGP("%s does not use %s!\n", a->name, b->name);

546

return 0;

546

return 0;

547

}

547

}

548

549

/* Module a uses b */

549

/* Module a uses b */

550

static int use_module(struct module *a, struct module *b)

550

static int use_module(struct module *a, struct module *b)

551

{

551

{

552

struct module_use *use;

552

struct module_use *use;

553

int no_warn, err;

553

int no_warn, err;

554

555

if (b == NULL || already_uses(a, b)) return 1;

555

if (b == NULL || already_uses(a, b)) return 1;

556

557

/* If we're interrupted or time out, we fail. */

557

/* If we're interrupted or time out, we fail. */

558

if (wait_event_interruptible_timeout(

558

if (wait_event_interruptible_timeout(

559

module_wq, (err = strong_try_module_get(b)) != -EBUSY,

559

module_wq, (err = strong_try_module_get(b)) != -EBUSY,

560

30 * HZ) <= 0) {

560

30 * HZ) <= 0) {

561

printk("%s: gave up waiting for init of module %s.\n",

561

printk("%s: gave up waiting for init of module %s.\n",

562

a->name, b->name);

562

a->name, b->name);

563

return 0;

563

return 0;

564

}

564

}

565

566

/* If strong_try_module_get() returned a different error, we fail. */

566

/* If strong_try_module_get() returned a different error, we fail. */

567

if (err)

567

if (err)

568

return 0;

568

return 0;

569

570

DEBUGP("Allocating new usage for %s.\n", a->name);

570

DEBUGP("Allocating new usage for %s.\n", a->name);

571

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

571

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

572

if (!use) {

572

if (!use) {

573

printk("%s: out of memory loading\n", a->name);

573

printk("%s: out of memory loading\n", a->name);

574

module_put(b);

574

module_put(b);

575

return 0;

575

return 0;

576

}

576

}

577

578

use->module_which_uses = a;

578

use->module_which_uses = a;

579

list_add(&use->list, &b->modules_which_use_me);

579

list_add(&use->list, &b->modules_which_use_me);

580

no_warn = sysfs_create_link(b->holders_dir, &a->mkobj.kobj, a->name);

580

no_warn = sysfs_create_link(b->holders_dir, &a->mkobj.kobj, a->name);

581

return 1;

581

return 1;

582

}

582

}

583

584

/* Clear the unload stuff of the module. */

584

/* Clear the unload stuff of the module. */

585

static void module_unload_free(struct module *mod)

585

static void module_unload_free(struct module *mod)

586

{

586

{

587

struct module *i;

587

struct module *i;

588

589

list_for_each_entry(i, &modules, list) {

589

list_for_each_entry(i, &modules, list) {

590

struct module_use *use;

590

struct module_use *use;

591

592

list_for_each_entry(use, &i->modules_which_use_me, list) {

592

list_for_each_entry(use, &i->modules_which_use_me, list) {

593

if (use->module_which_uses == mod) {

593

if (use->module_which_uses == mod) {

594

DEBUGP("%s unusing %s\n", mod->name, i->name);

594

DEBUGP("%s unusing %s\n", mod->name, i->name);

595

module_put(i);

595

module_put(i);

596

list_del(&use->list);

596

list_del(&use->list);

597

kfree(use);

597

kfree(use);

598

sysfs_remove_link(i->holders_dir, mod->name);

598

sysfs_remove_link(i->holders_dir, mod->name);

599

/* There can be at most one match. */

599

/* There can be at most one match. */

600

break;

600

break;

601

}

601

}

602

}

602

}

603

}

603

}

604

}

604

}

605

606

#ifdef CONFIG_MODULE_FORCE_UNLOAD

606

#ifdef CONFIG_MODULE_FORCE_UNLOAD

607

static inline int try_force_unload(unsigned int flags)

607

static inline int try_force_unload(unsigned int flags)

608

{

608

{

609

int ret = (flags & O_TRUNC);

609

int ret = (flags & O_TRUNC);

610

if (ret)

610

if (ret)

611

add_taint(TAINT_FORCED_RMMOD);

611

add_taint(TAINT_FORCED_RMMOD);

612

return ret;

612

return ret;

613

}

613

}

614

#else

614

#else

615

static inline int try_force_unload(unsigned int flags)

615

static inline int try_force_unload(unsigned int flags)

616

{

616

{

617

return 0;

617

return 0;

618

}

618

}

619

#endif /* CONFIG_MODULE_FORCE_UNLOAD */

619

#endif /* CONFIG_MODULE_FORCE_UNLOAD */

620

621

struct stopref

621

struct stopref

622

{

622

{

623

struct module *mod;

623

struct module *mod;

624

int flags;

624

int flags;

625

int *forced;

625

int *forced;

626

};

626

};

627

628

/* Whole machine is stopped with interrupts off when this runs. */

628

/* Whole machine is stopped with interrupts off when this runs. */

629

static int __try_stop_module(void *_sref)

629

static int __try_stop_module(void *_sref)

630

{

630

{

631

struct stopref *sref = _sref;

631

struct stopref *sref = _sref;

632

633

/* If it's not unused, quit unless we are told to block. */

633

/* If it's not unused, quit unless we are told to block. */

634

if ((sref->flags & O_NONBLOCK) && module_refcount(sref->mod) != 0) {

634

if ((sref->flags & O_NONBLOCK) && module_refcount(sref->mod) != 0) {

635

if (!(*sref->forced = try_force_unload(sref->flags)))

635

if (!(*sref->forced = try_force_unload(sref->flags)))

636

return -EWOULDBLOCK;

636

return -EWOULDBLOCK;

637

}

637

}

638

639

/* Mark it as dying. */

639

/* Mark it as dying. */

640

sref->mod->state = MODULE_STATE_GOING;

640

sref->mod->state = MODULE_STATE_GOING;

641

return 0;

641

return 0;

642

}

642

}

643

644

static int try_stop_module(struct module *mod, int flags, int *forced)

644

static int try_stop_module(struct module *mod, int flags, int *forced)

645

{

645

{

646

struct stopref sref = { mod, flags, forced };

646

struct stopref sref = { mod, flags, forced };

647

648

return stop_machine_run(__try_stop_module, &sref, NR_CPUS);

648

return stop_machine_run(__try_stop_module, &sref, NR_CPUS);

649

}

649

}

650

651

unsigned int module_refcount(struct module *mod)

651

unsigned int module_refcount(struct module *mod)

652

{

652

{

653

unsigned int i, total = 0;

653

unsigned int i, total = 0;

654

655

for (i = 0; i < NR_CPUS; i++)

655

for (i = 0; i < NR_CPUS; i++)

656

total += local_read(&mod->ref[i].count);

656

total += local_read(&mod->ref[i].count);

657

return total;

657

return total;

658

}

658

}

659

EXPORT_SYMBOL(module_refcount);

659

EXPORT_SYMBOL(module_refcount);

660

661

/* This exists whether we can unload or not */

661

/* This exists whether we can unload or not */

662

static void free_module(struct module *mod);

662

static void free_module(struct module *mod);

663

664

static void wait_for_zero_refcount(struct module *mod)

664

static void wait_for_zero_refcount(struct module *mod)

665

{

665

{

666

/* Since we might sleep for some time, release the mutex first */

666

/* Since we might sleep for some time, release the mutex first */

667

mutex_unlock(&module_mutex);

667

mutex_unlock(&module_mutex);

668

for (;;) {

668

for (;;) {

669

DEBUGP("Looking at refcount...\n");

669

DEBUGP("Looking at refcount...\n");

670

set_current_state(TASK_UNINTERRUPTIBLE);

670

set_current_state(TASK_UNINTERRUPTIBLE);

671

if (module_refcount(mod) == 0)

671

if (module_refcount(mod) == 0)

672

break;

672

break;

673

schedule();

673

schedule();

674

}

674

}

675

current->state = TASK_RUNNING;

675

current->state = TASK_RUNNING;

676

mutex_lock(&module_mutex);

676

mutex_lock(&module_mutex);

677

}

677

}

678

679

asmlinkage long

679

asmlinkage long

680

sys_delete_module(const char __user *name_user, unsigned int flags)

680

sys_delete_module(const char __user *name_user, unsigned int flags)

681

{

681

{

682

struct module *mod;

682

struct module *mod;

683

char name[MODULE_NAME_LEN];

683

char name[MODULE_NAME_LEN];

684

int ret, forced = 0;

684

int ret, forced = 0;

685

686

if (!capable(CAP_SYS_MODULE))

686

if (!capable(CAP_SYS_MODULE))

687

return -EPERM;

687

return -EPERM;

688

689

if (strncpy_from_user(name, name_user, MODULE_NAME_LEN-1) < 0)

689

if (strncpy_from_user(name, name_user, MODULE_NAME_LEN-1) < 0)

690

return -EFAULT;

690

return -EFAULT;

691

name[MODULE_NAME_LEN-1] = '\0';

691

name[MODULE_NAME_LEN-1] = '\0';

692

693

if (mutex_lock_interruptible(&module_mutex) != 0)

693

if (mutex_lock_interruptible(&module_mutex) != 0)

694

return -EINTR;

694

return -EINTR;

695

696

mod = find_module(name);

696

mod = find_module(name);

697

if (!mod) {

697

if (!mod) {

698

ret = -ENOENT;

698

ret = -ENOENT;

699

goto out;

699

goto out;

700

}

700

}

701

702

if (!list_empty(&mod->modules_which_use_me)) {

702

if (!list_empty(&mod->modules_which_use_me)) {

703

/* Other modules depend on us: get rid of them first. */

703

/* Other modules depend on us: get rid of them first. */

704

ret = -EWOULDBLOCK;

704

ret = -EWOULDBLOCK;

705

goto out;

705

goto out;

706

}

706

}

707

708

/* Doing init or already dying? */

708

/* Doing init or already dying? */

709

if (mod->state != MODULE_STATE_LIVE) {

709

if (mod->state != MODULE_STATE_LIVE) {

710

/* FIXME: if (force), slam module count and wake up

710

/* FIXME: if (force), slam module count and wake up

711

waiter --RR */

711

waiter --RR */

712

DEBUGP("%s already dying\n", mod->name);

712

DEBUGP("%s already dying\n", mod->name);

713

ret = -EBUSY;

713

ret = -EBUSY;

714

goto out;

714

goto out;

715

}

715

}

716

717

/* If it has an init func, it must have an exit func to unload */

717

/* If it has an init func, it must have an exit func to unload */

718

if (mod->init && !mod->exit) {

718

if (mod->init && !mod->exit) {

719

forced = try_force_unload(flags);

719

forced = try_force_unload(flags);

720

if (!forced) {

720

if (!forced) {

721

/* This module can't be removed */

721

/* This module can't be removed */

722

ret = -EBUSY;

722

ret = -EBUSY;

723

goto out;

723

goto out;

724

}

724

}

725

}

725

}

726

727

/* Set this up before setting mod->state */

727

/* Set this up before setting mod->state */

728

mod->waiter = current;

728

mod->waiter = current;

729

730

/* Stop the machine so refcounts can't move and disable module. */

730

/* Stop the machine so refcounts can't move and disable module. */

731

ret = try_stop_module(mod, flags, &forced);

731

ret = try_stop_module(mod, flags, &forced);

732

if (ret != 0)

732

if (ret != 0)

733

goto out;

733

goto out;

734

735

/* Never wait if forced. */

735

/* Never wait if forced. */

736

if (!forced && module_refcount(mod) != 0)

736

if (!forced && module_refcount(mod) != 0)

737

wait_for_zero_refcount(mod);

737

wait_for_zero_refcount(mod);

738

739

/* Final destruction now noone is using it. */

739

/* Final destruction now noone is using it. */

740

if (mod->exit != NULL) {

740

if (mod->exit != NULL) {

741

mutex_unlock(&module_mutex);

741

mutex_unlock(&module_mutex);

742

mod->exit();

742

mod->exit();

743

mutex_lock(&module_mutex);

743

mutex_lock(&module_mutex);

744

}

744

}

745

/* Store the name of the last unloaded module for diagnostic purposes */

745

/* Store the name of the last unloaded module for diagnostic purposes */

746

strlcpy(last_unloaded_module, mod->name, sizeof(last_unloaded_module));

746

strlcpy(last_unloaded_module, mod->name, sizeof(last_unloaded_module));

747

free_module(mod);

747

free_module(mod);

748

749

out:

749

out:

750

mutex_unlock(&module_mutex);

750

mutex_unlock(&module_mutex);

751

return ret;

751

return ret;

752

}

752

}

753

754

static void print_unload_info(struct seq_file *m, struct module *mod)

754

static void print_unload_info(struct seq_file *m, struct module *mod)

755

{

755

{

756

struct module_use *use;

756

struct module_use *use;

757

int printed_something = 0;

757

int printed_something = 0;

758

759

seq_printf(m, " %u ", module_refcount(mod));

759

seq_printf(m, " %u ", module_refcount(mod));

760

761

/* Always include a trailing , so userspace can differentiate

761

/* Always include a trailing , so userspace can differentiate

762

between this and the old multi-field proc format. */

762

between this and the old multi-field proc format. */

763

list_for_each_entry(use, &mod->modules_which_use_me, list) {

763

list_for_each_entry(use, &mod->modules_which_use_me, list) {

764

printed_something = 1;

764

printed_something = 1;

765

seq_printf(m, "%s,", use->module_which_uses->name);

765

seq_printf(m, "%s,", use->module_which_uses->name);

766

}

766

}

767

768

if (mod->init != NULL && mod->exit == NULL) {

768

if (mod->init != NULL && mod->exit == NULL) {

769

printed_something = 1;

769

printed_something = 1;

770

seq_printf(m, "[permanent],");

770

seq_printf(m, "[permanent],");

771

}

771

}

772

773

if (!printed_something)

773

if (!printed_something)

774

seq_printf(m, "-");

774

seq_printf(m, "-");

775

}

775

}

776

777

void __symbol_put(const char *symbol)

777

void __symbol_put(const char *symbol)

778

{

778

{

779

struct module *owner;

779

struct module *owner;

780

const unsigned long *crc;

780

const unsigned long *crc;

781

782

preempt_disable();

782

preempt_disable();

783

if (IS_ERR_VALUE(__find_symbol(symbol, &owner, &crc, 1)))

783

if (IS_ERR_VALUE(__find_symbol(symbol, &owner, &crc, 1)))

784

BUG();

784

BUG();

785

module_put(owner);

785

module_put(owner);

786

preempt_enable();

786

preempt_enable();

787

}

787

}

788

EXPORT_SYMBOL(__symbol_put);

788

EXPORT_SYMBOL(__symbol_put);

789

790

void symbol_put_addr(void *addr)

790

void symbol_put_addr(void *addr)

791

{

791

{

792

struct module *modaddr;

792

struct module *modaddr;

793

794

if (core_kernel_text((unsigned long)addr))

794

if (core_kernel_text((unsigned long)addr))

795

return;

795

return;

796

797

if (!(modaddr = module_text_address((unsigned long)addr)))

797

if (!(modaddr = module_text_address((unsigned long)addr)))

798

BUG();

798

BUG();

799

module_put(modaddr);

799

module_put(modaddr);

800

}

800

}

801

EXPORT_SYMBOL_GPL(symbol_put_addr);

801

EXPORT_SYMBOL_GPL(symbol_put_addr);

802

803

static ssize_t show_refcnt(struct module_attribute *mattr,

803

static ssize_t show_refcnt(struct module_attribute *mattr,

804

struct module *mod, char *buffer)

804

struct module *mod, char *buffer)

805

{

805

{

806

return sprintf(buffer, "%u\n", module_refcount(mod));

806

return sprintf(buffer, "%u\n", module_refcount(mod));

807

}

807

}

808

809

static struct module_attribute refcnt = {

809

static struct module_attribute refcnt = {

810

.attr = { .name = "refcnt", .mode = 0444 },

810

.attr = { .name = "refcnt", .mode = 0444 },

811

.show = show_refcnt,

811

.show = show_refcnt,

812

};

812

};

813

814

void module_put(struct module *module)

814

void module_put(struct module *module)

815

{

815

{

816

if (module) {

816

if (module) {

817

unsigned int cpu = get_cpu();

817

unsigned int cpu = get_cpu();

818

local_dec(&module->ref[cpu].count);

818

local_dec(&module->ref[cpu].count);

819

/* Maybe they're waiting for us to drop reference? */

819

/* Maybe they're waiting for us to drop reference? */

820

if (unlikely(!module_is_live(module)))

820

if (unlikely(!module_is_live(module)))

821

wake_up_process(module->waiter);

821

wake_up_process(module->waiter);

822

put_cpu();

822

put_cpu();

823

}

823

}

824

}

824

}

825

EXPORT_SYMBOL(module_put);

825

EXPORT_SYMBOL(module_put);

826

827

#else /* !CONFIG_MODULE_UNLOAD */

827

#else /* !CONFIG_MODULE_UNLOAD */

828

static void print_unload_info(struct seq_file *m, struct module *mod)

828

static void print_unload_info(struct seq_file *m, struct module *mod)

829

{

829

{

830

/* We don't know the usage count, or what modules are using. */

830

/* We don't know the usage count, or what modules are using. */

831

seq_printf(m, " - -");

831

seq_printf(m, " - -");

832

}

832

}

833

834

static inline void module_unload_free(struct module *mod)

834

static inline void module_unload_free(struct module *mod)

835

{

835

{

836

}

836

}

837

838

static inline int use_module(struct module *a, struct module *b)

838

static inline int use_module(struct module *a, struct module *b)

839

{

839

{

840

return strong_try_module_get(b) == 0;

840

return strong_try_module_get(b) == 0;

841

}

841

}

842

843

static inline void module_unload_init(struct module *mod)

843

static inline void module_unload_init(struct module *mod)

844

{

844

{

845

}

845

}

846

#endif /* CONFIG_MODULE_UNLOAD */

846

#endif /* CONFIG_MODULE_UNLOAD */

847

848

static ssize_t show_initstate(struct module_attribute *mattr,

848

static ssize_t show_initstate(struct module_attribute *mattr,

849

struct module *mod, char *buffer)

849

struct module *mod, char *buffer)

850

{

850

{

851

const char *state = "unknown";

851

const char *state = "unknown";

852

853

switch (mod->state) {

853

switch (mod->state) {

854

case MODULE_STATE_LIVE:

854

case MODULE_STATE_LIVE:

855

state = "live";

855

state = "live";

856

break;

856

break;

857

case MODULE_STATE_COMING:

857

case MODULE_STATE_COMING:

858

state = "coming";

858

state = "coming";

859

break;

859

break;

860

case MODULE_STATE_GOING:

860

case MODULE_STATE_GOING:

861

state = "going";

861

state = "going";

862

break;

862

break;

863

}

863

}

864

return sprintf(buffer, "%s\n", state);

864

return sprintf(buffer, "%s\n", state);

865

}

865

}

866

867

static struct module_attribute initstate = {

867

static struct module_attribute initstate = {

868

.attr = { .name = "initstate", .mode = 0444 },

868

.attr = { .name = "initstate", .mode = 0444 },

869

.show = show_initstate,

869

.show = show_initstate,

870

};

870

};

871

872

static struct module_attribute *modinfo_attrs[] = {

872

static struct module_attribute *modinfo_attrs[] = {

873

&modinfo_version,

873

&modinfo_version,

874

&modinfo_srcversion,

874

&modinfo_srcversion,

875

&initstate,

875

&initstate,

876

#ifdef CONFIG_MODULE_UNLOAD

876

#ifdef CONFIG_MODULE_UNLOAD

877

&refcnt,

877

&refcnt,

878

#endif

878

#endif

879

NULL,

879

NULL,

880

};

880

};

881

882

static const char vermagic[] = VERMAGIC_STRING;

882

static const char vermagic[] = VERMAGIC_STRING;

883

884

#ifdef CONFIG_MODVERSIONS

884

#ifdef CONFIG_MODVERSIONS

885

static int check_version(Elf_Shdr *sechdrs,

885

static int check_version(Elf_Shdr *sechdrs,

886

unsigned int versindex,

886

unsigned int versindex,

887

const char *symname,

887

const char *symname,

888

struct module *mod,

888

struct module *mod,

889

const unsigned long *crc)

889

const unsigned long *crc)

890

{

890

{

891

unsigned int i, num_versions;

891

unsigned int i, num_versions;

892

struct modversion_info *versions;

892

struct modversion_info *versions;

893

894

/* Exporting module didn't supply crcs? OK, we're already tainted. */

894

/* Exporting module didn't supply crcs? OK, we're already tainted. */

895

if (!crc)

895

if (!crc)

896

return 1;

896

return 1;

897

898

versions = (void *) sechdrs[versindex].sh_addr;

898

versions = (void *) sechdrs[versindex].sh_addr;

899

num_versions = sechdrs[versindex].sh_size

899

num_versions = sechdrs[versindex].sh_size

900

/ sizeof(struct modversion_info);

900

/ sizeof(struct modversion_info);

901

902

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

902

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

903

if (strcmp(versions[i].name, symname) != 0)

903

if (strcmp(versions[i].name, symname) != 0)

904

continue;

904

continue;

905

906

if (versions[i].crc == *crc)

906

if (versions[i].crc == *crc)

907

return 1;

907

return 1;

908

printk("%s: disagrees about version of symbol %s\n",

908

printk("%s: disagrees about version of symbol %s\n",

909

mod->name, symname);

909

mod->name, symname);

910

DEBUGP("Found checksum %lX vs module %lX\n",

910

DEBUGP("Found checksum %lX vs module %lX\n",

911

*crc, versions[i].crc);

911

*crc, versions[i].crc);

912

return 0;

912

return 0;

913

}

913

}

914

/* Not in module's version table. OK, but that taints the kernel. */

914

/* Not in module's version table. OK, but that taints the kernel. */

915

if (!(tainted & TAINT_FORCED_MODULE))

915

if (!(tainted & TAINT_FORCED_MODULE))

916

printk("%s: no version for \"%s\" found: kernel tainted.\n",

916

printk("%s: no version for \"%s\" found: kernel tainted.\n",

917

mod->name, symname);

917

mod->name, symname);

918

add_taint_module(mod, TAINT_FORCED_MODULE);

918

add_taint_module(mod, TAINT_FORCED_MODULE);

919

return 1;

919

return 1;

920

}

920

}

921

922

static inline int check_modstruct_version(Elf_Shdr *sechdrs,

922

static inline int check_modstruct_version(Elf_Shdr *sechdrs,

923

unsigned int versindex,

923

unsigned int versindex,

924

struct module *mod)

924

struct module *mod)

925

{

925

{

926

const unsigned long *crc;

926

const unsigned long *crc;

927

struct module *owner;

927

struct module *owner;

928

929

if (IS_ERR_VALUE(__find_symbol("struct_module",

929

if (IS_ERR_VALUE(__find_symbol("struct_module",

930

&owner, &crc, 1)))

930

&owner, &crc, 1)))

931

BUG();

931

BUG();

932

return check_version(sechdrs, versindex, "struct_module", mod,

932

return check_version(sechdrs, versindex, "struct_module", mod,

933

crc);

933

crc);

934

}

934

}

935

936

/* First part is kernel version, which we ignore. */

936

/* First part is kernel version, which we ignore. */

937

static inline int same_magic(const char *amagic, const char *bmagic)

937

static inline int same_magic(const char *amagic, const char *bmagic)

938

{

938

{

939

amagic += strcspn(amagic, " ");

939

amagic += strcspn(amagic, " ");

940

bmagic += strcspn(bmagic, " ");

940

bmagic += strcspn(bmagic, " ");

941

return strcmp(amagic, bmagic) == 0;

941

return strcmp(amagic, bmagic) == 0;

942

}

942

}

943

#else

943

#else

944

static inline int check_version(Elf_Shdr *sechdrs,

944

static inline int check_version(Elf_Shdr *sechdrs,

945

unsigned int versindex,

945

unsigned int versindex,

946

const char *symname,

946

const char *symname,

947

struct module *mod,

947

struct module *mod,

948

const unsigned long *crc)

948

const unsigned long *crc)

949

{

949

{

950

return 1;

950

return 1;

951

}

951

}

952

953

static inline int check_modstruct_version(Elf_Shdr *sechdrs,

953

static inline int check_modstruct_version(Elf_Shdr *sechdrs,

954

unsigned int versindex,

954

unsigned int versindex,

955

struct module *mod)

955

struct module *mod)

956

{

956

{

957

return 1;

957

return 1;

958

}

958

}

959

960

static inline int same_magic(const char *amagic, const char *bmagic)

960

static inline int same_magic(const char *amagic, const char *bmagic)

961

{

961

{

962

return strcmp(amagic, bmagic) == 0;

962

return strcmp(amagic, bmagic) == 0;

963

}

963

}

964

#endif /* CONFIG_MODVERSIONS */

964

#endif /* CONFIG_MODVERSIONS */

965

966

/* Resolve a symbol for this module. I.e. if we find one, record usage.

966

/* Resolve a symbol for this module. I.e. if we find one, record usage.

967

Must be holding module_mutex. */

967

Must be holding module_mutex. */

968

static unsigned long resolve_symbol(Elf_Shdr *sechdrs,

968

static unsigned long resolve_symbol(Elf_Shdr *sechdrs,

969

unsigned int versindex,

969

unsigned int versindex,

970

const char *name,

970

const char *name,

971

struct module *mod)

971

struct module *mod)

972

{

972

{

973

struct module *owner;

973

struct module *owner;

974

unsigned long ret;

974

unsigned long ret;

975

const unsigned long *crc;

975

const unsigned long *crc;

976

977

ret = __find_symbol(name, &owner, &crc,

977

ret = __find_symbol(name, &owner, &crc,

978

!(mod->taints & TAINT_PROPRIETARY_MODULE));

978

!(mod->taints & TAINT_PROPRIETARY_MODULE));

979

if (!IS_ERR_VALUE(ret)) {

979

if (!IS_ERR_VALUE(ret)) {

980

/* use_module can fail due to OOM,

980

/* use_module can fail due to OOM,

981

or module initialization or unloading */

981

or module initialization or unloading */

982

if (!check_version(sechdrs, versindex, name, mod, crc) ||

982

if (!check_version(sechdrs, versindex, name, mod, crc) ||

983

!use_module(mod, owner))

983

!use_module(mod, owner))

984

ret = -EINVAL;

984

ret = -EINVAL;

985

}

985

}

986

return ret;

986

return ret;

987

}

987

}

988

989

/*

989

/*

990

* /sys/module/foo/sections stuff

990

* /sys/module/foo/sections stuff

991

* J. Corbet <corbet@lwn.net>

991

* J. Corbet <corbet@lwn.net>

992

*/

992

*/

993

#if defined(CONFIG_KALLSYMS) && defined(CONFIG_SYSFS)

993

#if defined(CONFIG_KALLSYMS) && defined(CONFIG_SYSFS)

994

struct module_sect_attr

994

struct module_sect_attr

995

{

995

{

996

struct module_attribute mattr;

996

struct module_attribute mattr;

997

char *name;

997

char *name;

998

unsigned long address;

998

unsigned long address;

999

};

999

};

1000

1001

struct module_sect_attrs

1001

struct module_sect_attrs

1002

{

1002

{

1003

struct attribute_group grp;

1003

struct attribute_group grp;

1004

unsigned int nsections;

1004

unsigned int nsections;

1005

struct module_sect_attr attrs[0];

1005

struct module_sect_attr attrs[0];

1006

};

1006

};

1007

1008

static ssize_t module_sect_show(struct module_attribute *mattr,

1008

static ssize_t module_sect_show(struct module_attribute *mattr,

1009

struct module *mod, char *buf)

1009

struct module *mod, char *buf)

1010

{

1010

{

1011

struct module_sect_attr *sattr =

1011

struct module_sect_attr *sattr =

1012

container_of(mattr, struct module_sect_attr, mattr);

1012

container_of(mattr, struct module_sect_attr, mattr);

1013

return sprintf(buf, "0x%lx\n", sattr->address);

1013

return sprintf(buf, "0x%lx\n", sattr->address);

1014

}

1014

}

1015

1016

static void free_sect_attrs(struct module_sect_attrs *sect_attrs)

1016

static void free_sect_attrs(struct module_sect_attrs *sect_attrs)

1017

{

1017

{

1018

unsigned int section;

1018

unsigned int section;

1019

1020

for (section = 0; section < sect_attrs->nsections; section++)

1020

for (section = 0; section < sect_attrs->nsections; section++)

1021

kfree(sect_attrs->attrs[section].name);

1021

kfree(sect_attrs->attrs[section].name);

1022

kfree(sect_attrs);

1022

kfree(sect_attrs);

1023

}

1023

}

1024

1025

static void add_sect_attrs(struct module *mod, unsigned int nsect,

1025

static void add_sect_attrs(struct module *mod, unsigned int nsect,

1026

char *secstrings, Elf_Shdr *sechdrs)

1026

char *secstrings, Elf_Shdr *sechdrs)

1027

{

1027

{

1028

unsigned int nloaded = 0, i, size[2];

1028

unsigned int nloaded = 0, i, size[2];

1029

struct module_sect_attrs *sect_attrs;

1029

struct module_sect_attrs *sect_attrs;

1030

struct module_sect_attr *sattr;

1030

struct module_sect_attr *sattr;

1031

struct attribute **gattr;

1031

struct attribute **gattr;

1032

1033

/* Count loaded sections and allocate structures */

1033

/* Count loaded sections and allocate structures */

1034

for (i = 0; i < nsect; i++)

1034

for (i = 0; i < nsect; i++)

1035

if (sechdrs[i].sh_flags & SHF_ALLOC)

1035

if (sechdrs[i].sh_flags & SHF_ALLOC)

1036

nloaded++;

1036

nloaded++;

1037

size[0] = ALIGN(sizeof(*sect_attrs)

1037

size[0] = ALIGN(sizeof(*sect_attrs)

1038

+ nloaded * sizeof(sect_attrs->attrs[0]),

1038

+ nloaded * sizeof(sect_attrs->attrs[0]),

1039

sizeof(sect_attrs->grp.attrs[0]));

1039

sizeof(sect_attrs->grp.attrs[0]));

1040

size[1] = (nloaded + 1) * sizeof(sect_attrs->grp.attrs[0]);

1040

size[1] = (nloaded + 1) * sizeof(sect_attrs->grp.attrs[0]);

1041

sect_attrs = kzalloc(size[0] + size[1], GFP_KERNEL);

1041

sect_attrs = kzalloc(size[0] + size[1], GFP_KERNEL);

1042

if (sect_attrs == NULL)

1042

if (sect_attrs == NULL)

1043

return;

1043

return;

1044

1045

/* Setup section attributes. */

1045

/* Setup section attributes. */

1046

sect_attrs->grp.name = "sections";

1046

sect_attrs->grp.name = "sections";

1047

sect_attrs->grp.attrs = (void *)sect_attrs + size[0];

1047

sect_attrs->grp.attrs = (void *)sect_attrs + size[0];

1048

1049

sect_attrs->nsections = 0;

1049

sect_attrs->nsections = 0;

1050

sattr = &sect_attrs->attrs[0];

1050

sattr = &sect_attrs->attrs[0];

1051

gattr = &sect_attrs->grp.attrs[0];

1051

gattr = &sect_attrs->grp.attrs[0];

1052

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

1052

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

1053

if (! (sechdrs[i].sh_flags & SHF_ALLOC))

1053

if (! (sechdrs[i].sh_flags & SHF_ALLOC))

1054

continue;

1054

continue;

1055

sattr->address = sechdrs[i].sh_addr;

1055

sattr->address = sechdrs[i].sh_addr;

1056

sattr->name = kstrdup(secstrings + sechdrs[i].sh_name,

1056

sattr->name = kstrdup(secstrings + sechdrs[i].sh_name,

1057

GFP_KERNEL);

1057

GFP_KERNEL);

1058

if (sattr->name == NULL)

1058

if (sattr->name == NULL)

1059

goto out;

1059

goto out;

1060

sect_attrs->nsections++;

1060

sect_attrs->nsections++;

1061

sattr->mattr.show = module_sect_show;

1061

sattr->mattr.show = module_sect_show;

1062

sattr->mattr.store = NULL;

1062

sattr->mattr.store = NULL;

1063

sattr->mattr.attr.name = sattr->name;

1063

sattr->mattr.attr.name = sattr->name;

1064

sattr->mattr.attr.mode = S_IRUGO;

1064

sattr->mattr.attr.mode = S_IRUGO;

1065

*(gattr++) = &(sattr++)->mattr.attr;

1065

*(gattr++) = &(sattr++)->mattr.attr;

1066

}

1066

}

1067

*gattr = NULL;

1067

*gattr = NULL;

1068

1069

if (sysfs_create_group(&mod->mkobj.kobj, &sect_attrs->grp))

1069

if (sysfs_create_group(&mod->mkobj.kobj, &sect_attrs->grp))

1070

goto out;

1070

goto out;

1071

1072

mod->sect_attrs = sect_attrs;

1072

mod->sect_attrs = sect_attrs;

1073

return;

1073

return;

1074

out:

1074

out:

1075

free_sect_attrs(sect_attrs);

1075

free_sect_attrs(sect_attrs);

1076

}

1076

}

1077

1078

static void remove_sect_attrs(struct module *mod)

1078

static void remove_sect_attrs(struct module *mod)

1079

{

1079

{

1080

if (mod->sect_attrs) {

1080

if (mod->sect_attrs) {

1081

sysfs_remove_group(&mod->mkobj.kobj,

1081

sysfs_remove_group(&mod->mkobj.kobj,

1082

&mod->sect_attrs->grp);

1082

&mod->sect_attrs->grp);

1083

/* We are positive that no one is using any sect attrs

1083

/* We are positive that no one is using any sect attrs

1084

* at this point. Deallocate immediately. */

1084

* at this point. Deallocate immediately. */

1085

free_sect_attrs(mod->sect_attrs);

1085

free_sect_attrs(mod->sect_attrs);

1086

mod->sect_attrs = NULL;

1086

mod->sect_attrs = NULL;

1087

}

1087

}

1088

}

1088

}

1089

1090

/*

1090

/*

1091

* /sys/module/foo/notes/.section.name gives contents of SHT_NOTE sections.

1091

* /sys/module/foo/notes/.section.name gives contents of SHT_NOTE sections.

1092

*/

1092

*/

1093

1094

struct module_notes_attrs {

1094

struct module_notes_attrs {

1095

struct kobject *dir;

1095

struct kobject *dir;

1096

unsigned int notes;

1096

unsigned int notes;

1097

struct bin_attribute attrs[0];

1097

struct bin_attribute attrs[0];

1098

};

1098

};

1099

1100

static ssize_t module_notes_read(struct kobject *kobj,

1100

static ssize_t module_notes_read(struct kobject *kobj,

1101

struct bin_attribute *bin_attr,

1101

struct bin_attribute *bin_attr,

1102

char *buf, loff_t pos, size_t count)

1102

char *buf, loff_t pos, size_t count)

1103

{

1103

{

1104

/*

1104

/*

1105

* The caller checked the pos and count against our size.

1105

* The caller checked the pos and count against our size.

1106

*/

1106

*/

1107

memcpy(buf, bin_attr->private + pos, count);

1107

memcpy(buf, bin_attr->private + pos, count);

1108

return count;

1108

return count;

1109

}

1109

}

1110

1111

static void free_notes_attrs(struct module_notes_attrs *notes_attrs,

1111

static void free_notes_attrs(struct module_notes_attrs *notes_attrs,

1112

unsigned int i)

1112

unsigned int i)

1113

{

1113

{

1114

if (notes_attrs->dir) {

1114

if (notes_attrs->dir) {

1115

while (i-- > 0)

1115

while (i-- > 0)

1116

sysfs_remove_bin_file(notes_attrs->dir,

1116

sysfs_remove_bin_file(notes_attrs->dir,

1117

&notes_attrs->attrs[i]);

1117

&notes_attrs->attrs[i]);

1118

kobject_del(notes_attrs->dir);

1118

kobject_del(notes_attrs->dir);

1119

}

1119

}

1120

kfree(notes_attrs);

1120

kfree(notes_attrs);

1121

}

1121

}

1122

1123

static void add_notes_attrs(struct module *mod, unsigned int nsect,

1123

static void add_notes_attrs(struct module *mod, unsigned int nsect,

1124

char *secstrings, Elf_Shdr *sechdrs)

1124

char *secstrings, Elf_Shdr *sechdrs)

1125

{

1125

{

1126

unsigned int notes, loaded, i;

1126

unsigned int notes, loaded, i;

1127

struct module_notes_attrs *notes_attrs;

1127

struct module_notes_attrs *notes_attrs;

1128

struct bin_attribute *nattr;

1128

struct bin_attribute *nattr;

1129

1130

/* Count notes sections and allocate structures. */

1130

/* Count notes sections and allocate structures. */

1131

notes = 0;

1131

notes = 0;

1132

for (i = 0; i < nsect; i++)

1132

for (i = 0; i < nsect; i++)

1133

if ((sechdrs[i].sh_flags & SHF_ALLOC) &&

1133

if ((sechdrs[i].sh_flags & SHF_ALLOC) &&

1134

(sechdrs[i].sh_type == SHT_NOTE))

1134

(sechdrs[i].sh_type == SHT_NOTE))

1135

++notes;

1135

++notes;

1136

1137

if (notes == 0)

1137

if (notes == 0)

1138

return;

1138

return;

1139

1140

notes_attrs = kzalloc(sizeof(*notes_attrs)

1140

notes_attrs = kzalloc(sizeof(*notes_attrs)

1141

+ notes * sizeof(notes_attrs->attrs[0]),

1141

+ notes * sizeof(notes_attrs->attrs[0]),

1142

GFP_KERNEL);

1142

GFP_KERNEL);

1143

if (notes_attrs == NULL)

1143

if (notes_attrs == NULL)

1144

return;

1144

return;

1145

1146

notes_attrs->notes = notes;

1146

notes_attrs->notes = notes;

1147

nattr = &notes_attrs->attrs[0];

1147

nattr = &notes_attrs->attrs[0];

1148

for (loaded = i = 0; i < nsect; ++i) {

1148

for (loaded = i = 0; i < nsect; ++i) {

1149

if (!(sechdrs[i].sh_flags & SHF_ALLOC))

1149

if (!(sechdrs[i].sh_flags & SHF_ALLOC))

1150

continue;

1150

continue;

1151

if (sechdrs[i].sh_type == SHT_NOTE) {

1151

if (sechdrs[i].sh_type == SHT_NOTE) {

1152

nattr->attr.name = mod->sect_attrs->attrs[loaded].name;

1152

nattr->attr.name = mod->sect_attrs->attrs[loaded].name;

1153

nattr->attr.mode = S_IRUGO;

1153

nattr->attr.mode = S_IRUGO;

1154

nattr->size = sechdrs[i].sh_size;

1154

nattr->size = sechdrs[i].sh_size;

1155

nattr->private = (void *) sechdrs[i].sh_addr;

1155

nattr->private = (void *) sechdrs[i].sh_addr;

1156

nattr->read = module_notes_read;

1156

nattr->read = module_notes_read;

1157

++nattr;

1157

++nattr;

1158

}

1158

}

1159

++loaded;

1159

++loaded;

1160

}

1160

}

1161

1162

notes_attrs->dir = kobject_create_and_add("notes", &mod->mkobj.kobj);

1162

notes_attrs->dir = kobject_create_and_add("notes", &mod->mkobj.kobj);

1163

if (!notes_attrs->dir)

1163

if (!notes_attrs->dir)

1164

goto out;

1164

goto out;

1165

1166

for (i = 0; i < notes; ++i)

1166

for (i = 0; i < notes; ++i)

1167

if (sysfs_create_bin_file(notes_attrs->dir,

1167

if (sysfs_create_bin_file(notes_attrs->dir,

1168

&notes_attrs->attrs[i]))

1168

&notes_attrs->attrs[i]))

1169

goto out;

1169

goto out;

1170

1171

mod->notes_attrs = notes_attrs;

1171

mod->notes_attrs = notes_attrs;

1172

return;

1172

return;

1173

1174

out:

1174

out:

1175

free_notes_attrs(notes_attrs, i);

1175

free_notes_attrs(notes_attrs, i);

1176

}

1176

}

1177

1178

static void remove_notes_attrs(struct module *mod)

1178

static void remove_notes_attrs(struct module *mod)

1179

{

1179

{

1180

if (mod->notes_attrs)

1180

if (mod->notes_attrs)

1181

free_notes_attrs(mod->notes_attrs, mod->notes_attrs->notes);

1181

free_notes_attrs(mod->notes_attrs, mod->notes_attrs->notes);

1182

}

1182

}

1183

1184

#else

1184

#else

1185

1186

static inline void add_sect_attrs(struct module *mod, unsigned int nsect,

1186

static inline void add_sect_attrs(struct module *mod, unsigned int nsect,

1187

char *sectstrings, Elf_Shdr *sechdrs)

1187

char *sectstrings, Elf_Shdr *sechdrs)

1188

{

1188

{

1189

}

1189

}

1190

1191

static inline void remove_sect_attrs(struct module *mod)

1191

static inline void remove_sect_attrs(struct module *mod)

1192

{

1192

{

1193

}

1193

}

1194

1195

static inline void add_notes_attrs(struct module *mod, unsigned int nsect,

1195

static inline void add_notes_attrs(struct module *mod, unsigned int nsect,

1196

char *sectstrings, Elf_Shdr *sechdrs)

1196

char *sectstrings, Elf_Shdr *sechdrs)

1197

{

1197

{

1198

}

1198

}

1199

1200

static inline void remove_notes_attrs(struct module *mod)

1200

static inline void remove_notes_attrs(struct module *mod)

1201

{

1201

{

1202

}

1202

}

1203

#endif

1203

#endif

1204

1205

#ifdef CONFIG_SYSFS

1205

#ifdef CONFIG_SYSFS

1206

int module_add_modinfo_attrs(struct module *mod)

1206

int module_add_modinfo_attrs(struct module *mod)

1207

{

1207

{

1208

struct module_attribute *attr;

1208

struct module_attribute *attr;

1209

struct module_attribute *temp_attr;

1209

struct module_attribute *temp_attr;

1210

int error = 0;

1210

int error = 0;

1211

int i;

1211

int i;

1212

1213

mod->modinfo_attrs = kzalloc((sizeof(struct module_attribute) *

1213

mod->modinfo_attrs = kzalloc((sizeof(struct module_attribute) *

1214

(ARRAY_SIZE(modinfo_attrs) + 1)),

1214

(ARRAY_SIZE(modinfo_attrs) + 1)),

1215

GFP_KERNEL);

1215

GFP_KERNEL);

1216

if (!mod->modinfo_attrs)

1216

if (!mod->modinfo_attrs)

1217

return -ENOMEM;

1217

return -ENOMEM;

1218

1219

temp_attr = mod->modinfo_attrs;

1219

temp_attr = mod->modinfo_attrs;

1220

for (i = 0; (attr = modinfo_attrs[i]) && !error; i++) {

1220

for (i = 0; (attr = modinfo_attrs[i]) && !error; i++) {

1221

if (!attr->test ||

1221

if (!attr->test ||

1222

(attr->test && attr->test(mod))) {

1222

(attr->test && attr->test(mod))) {

1223

memcpy(temp_attr, attr, sizeof(*temp_attr));

1223

memcpy(temp_attr, attr, sizeof(*temp_attr));

1224

error = sysfs_create_file(&mod->mkobj.kobj,&temp_attr->attr);

1224

error = sysfs_create_file(&mod->mkobj.kobj,&temp_attr->attr);

1225

++temp_attr;

1225

++temp_attr;

1226

}

1226

}

1227

}

1227

}

1228

return error;

1228

return error;

1229

}

1229

}

1230

1231

void module_remove_modinfo_attrs(struct module *mod)

1231

void module_remove_modinfo_attrs(struct module *mod)

1232

{

1232

{

1233

struct module_attribute *attr;

1233

struct module_attribute *attr;

1234

int i;

1234

int i;

1235

1236

for (i = 0; (attr = &mod->modinfo_attrs[i]); i++) {

1236

for (i = 0; (attr = &mod->modinfo_attrs[i]); i++) {

1237

/* pick a field to test for end of list */

1237

/* pick a field to test for end of list */

1238

if (!attr->attr.name)

1238

if (!attr->attr.name)

1239

break;

1239

break;

1240

sysfs_remove_file(&mod->mkobj.kobj,&attr->attr);

1240

sysfs_remove_file(&mod->mkobj.kobj,&attr->attr);

1241

if (attr->free)

1241

if (attr->free)

1242

attr->free(mod);

1242

attr->free(mod);

1243

}

1243

}

1244

kfree(mod->modinfo_attrs);

1244

kfree(mod->modinfo_attrs);

1245

}

1245

}

1246

1247

int mod_sysfs_init(struct module *mod)

1247

int mod_sysfs_init(struct module *mod)

1248

{

1248

{

1249

int err;

1249

int err;

1250

struct kobject *kobj;

1250

struct kobject *kobj;

1251

1252

if (!module_sysfs_initialized) {

1252

if (!module_sysfs_initialized) {

1253

printk(KERN_ERR "%s: module sysfs not initialized\n",

1253

printk(KERN_ERR "%s: module sysfs not initialized\n",

1254

mod->name);

1254

mod->name);

1255

err = -EINVAL;

1255

err = -EINVAL;

1256

goto out;

1256

goto out;

1257

}

1257

}

1258

1259

kobj = kset_find_obj(module_kset, mod->name);

1259

kobj = kset_find_obj(module_kset, mod->name);

1260

if (kobj) {

1260

if (kobj) {

1261

printk(KERN_ERR "%s: module is already loaded\n", mod->name);

1261

printk(KERN_ERR "%s: module is already loaded\n", mod->name);

1262

kobject_put(kobj);

1262

kobject_put(kobj);

1263

err = -EINVAL;

1263

err = -EINVAL;

1264

goto out;

1264

goto out;

1265

}

1265

}

1266

1267

mod->mkobj.mod = mod;

1267

mod->mkobj.mod = mod;

1268

1269

memset(&mod->mkobj.kobj, 0, sizeof(mod->mkobj.kobj));

1269

memset(&mod->mkobj.kobj, 0, sizeof(mod->mkobj.kobj));

1270

mod->mkobj.kobj.kset = module_kset;

1270

mod->mkobj.kobj.kset = module_kset;

1271

err = kobject_init_and_add(&mod->mkobj.kobj, &module_ktype, NULL,

1271

err = kobject_init_and_add(&mod->mkobj.kobj, &module_ktype, NULL,

1272

"%s", mod->name);

1272

"%s", mod->name);

1273

if (err)

1273

if (err)

1274

kobject_put(&mod->mkobj.kobj);

1274

kobject_put(&mod->mkobj.kobj);

1275

1276

/* delay uevent until full sysfs population */

1276

/* delay uevent until full sysfs population */

1277

out:

1277

out:

1278

return err;

1278

return err;

1279

}

1279

}

1280

1281

int mod_sysfs_setup(struct module *mod,

1281

int mod_sysfs_setup(struct module *mod,

1282

struct kernel_param *kparam,

1282

struct kernel_param *kparam,

1283

unsigned int num_params)

1283

unsigned int num_params)

1284

{

1284

{

1285

int err;

1285

int err;

1286

1287

mod->holders_dir = kobject_create_and_add("holders", &mod->mkobj.kobj);

1287

mod->holders_dir = kobject_create_and_add("holders", &mod->mkobj.kobj);

1288

if (!mod->holders_dir) {

1288

if (!mod->holders_dir) {

1289

err = -ENOMEM;

1289

err = -ENOMEM;

1290

goto out_unreg;

1290

goto out_unreg;

1291

}

1291

}

1292

1293

err = module_param_sysfs_setup(mod, kparam, num_params);

1293

err = module_param_sysfs_setup(mod, kparam, num_params);

1294

if (err)

1294

if (err)

1295

goto out_unreg_holders;

1295

goto out_unreg_holders;

1296

1297

err = module_add_modinfo_attrs(mod);

1297

err = module_add_modinfo_attrs(mod);

1298

if (err)

1298

if (err)

1299

goto out_unreg_param;

1299

goto out_unreg_param;

1300

1301

kobject_uevent(&mod->mkobj.kobj, KOBJ_ADD);

1301

kobject_uevent(&mod->mkobj.kobj, KOBJ_ADD);

1302

return 0;

1302

return 0;

1303

1304

out_unreg_param:

1304

out_unreg_param:

1305

module_param_sysfs_remove(mod);

1305

module_param_sysfs_remove(mod);

1306

out_unreg_holders:

1306

out_unreg_holders:

1307

kobject_put(mod->holders_dir);

1307

kobject_put(mod->holders_dir);

1308

out_unreg:

1308

out_unreg:

1309

kobject_put(&mod->mkobj.kobj);

1309

kobject_put(&mod->mkobj.kobj);

1310

return err;

1310

return err;

1311

}

1311

}

1312

#endif

1312

#endif

1313

1314

static void mod_kobject_remove(struct module *mod)

1314

static void mod_kobject_remove(struct module *mod)

1315

{

1315

{

1316

module_remove_modinfo_attrs(mod);

1316

module_remove_modinfo_attrs(mod);

1317

module_param_sysfs_remove(mod);

1317

module_param_sysfs_remove(mod);

1318

kobject_put(mod->mkobj.drivers_dir);

1318

kobject_put(mod->mkobj.drivers_dir);

1319

kobject_put(mod->holders_dir);

1319

kobject_put(mod->holders_dir);

1320

kobject_put(&mod->mkobj.kobj);

1320

kobject_put(&mod->mkobj.kobj);

1321

}

1321

}

1322

1323

/*

1323

/*

1324

* link the module with the whole machine is stopped with interrupts off

1324

* link the module with the whole machine is stopped with interrupts off

1325

* - this defends against kallsyms not taking locks

1325

* - this defends against kallsyms not taking locks

1326

*/

1326

*/

1327

static int __link_module(void *_mod)

1327

static int __link_module(void *_mod)

1328

{

1328

{

1329

struct module *mod = _mod;

1329

struct module *mod = _mod;

1330

list_add(&mod->list, &modules);

1330

list_add(&mod->list, &modules);

1331

return 0;

1331

return 0;

1332

}

1332

}

1333

1334

/*

1334

/*

1335

* unlink the module with the whole machine is stopped with interrupts off

1335

* unlink the module with the whole machine is stopped with interrupts off

1336

* - this defends against kallsyms not taking locks

1336

* - this defends against kallsyms not taking locks

1337

*/

1337

*/

1338

static int __unlink_module(void *_mod)

1338

static int __unlink_module(void *_mod)

1339

{

1339

{

1340

struct module *mod = _mod;

1340

struct module *mod = _mod;

1341

list_del(&mod->list);

1341

list_del(&mod->list);

1342

return 0;

1342

return 0;

1343

}

1343

}

1344

1345

/* Free a module, remove from lists, etc (must hold module_mutex). */

1345

/* Free a module, remove from lists, etc (must hold module_mutex). */

1346

static void free_module(struct module *mod)

1346

static void free_module(struct module *mod)

1347

{

1347

{

1348

/* Delete from various lists */

1348

/* Delete from various lists */

1349

stop_machine_run(__unlink_module, mod, NR_CPUS);

1349

stop_machine_run(__unlink_module, mod, NR_CPUS);

1350

remove_notes_attrs(mod);

1350

remove_notes_attrs(mod);

1351

remove_sect_attrs(mod);

1351

remove_sect_attrs(mod);

1352

mod_kobject_remove(mod);

1352

mod_kobject_remove(mod);

1353

1354

unwind_remove_table(mod->unwind_info, 0);

1354

unwind_remove_table(mod->unwind_info, 0);

1355

1356

/* Arch-specific cleanup. */

1356

/* Arch-specific cleanup. */

1357

module_arch_cleanup(mod);

1357

module_arch_cleanup(mod);

1358

1359

/* Module unload stuff */

1359

/* Module unload stuff */

1360

module_unload_free(mod);

1360

module_unload_free(mod);

1361

1362

/* This may be NULL, but that's OK */

1362

/* This may be NULL, but that's OK */

1363

module_free(mod, mod->module_init);

1363

module_free(mod, mod->module_init);

1364

kfree(mod->args);

1364

kfree(mod->args);

1365

if (mod->percpu)

1365

if (mod->percpu)

1366

percpu_modfree(mod->percpu);

1366

percpu_modfree(mod->percpu);

1367

1368

/* Free lock-classes: */

1368

/* Free lock-classes: */

1369

lockdep_free_key_range(mod->module_core, mod->core_size);

1369

lockdep_free_key_range(mod->module_core, mod->core_size);

1370

1371

/* Finally, free the core (containing the module structure) */

1371

/* Finally, free the core (containing the module structure) */

1372

module_free(mod, mod->module_core);

1372

module_free(mod, mod->module_core);

1373

}

1373

}

1374

1375

void *__symbol_get(const char *symbol)

1375

void *__symbol_get(const char *symbol)

1376

{

1376

{

1377

struct module *owner;

1377

struct module *owner;

1378

unsigned long value;

1378

unsigned long value;

1379

const unsigned long *crc;

1379

const unsigned long *crc;

1380

1381

preempt_disable();

1381

preempt_disable();

1382

value = __find_symbol(symbol, &owner, &crc, 1);

1382

value = __find_symbol(symbol, &owner, &crc, 1);

1383

if (IS_ERR_VALUE(value))

1383

if (IS_ERR_VALUE(value))

1384

value = 0;

1384

value = 0;

1385

else if (strong_try_module_get(owner))

1385

else if (strong_try_module_get(owner))

1386

value = 0;

1386

value = 0;

1387

preempt_enable();

1387

preempt_enable();

1388

1389

return (void *)value;

1389

return (void *)value;

1390

}

1390

}

1391

EXPORT_SYMBOL_GPL(__symbol_get);

1391

EXPORT_SYMBOL_GPL(__symbol_get);

1392

1393

/*

1393

/*

1394

* Ensure that an exported symbol [global namespace] does not already exist

1394

* Ensure that an exported symbol [global namespace] does not already exist

1395

* in the kernel or in some other module's exported symbol table.

1395

* in the kernel or in some other module's exported symbol table.

1396

*/

1396

*/

1397

static int verify_export_symbols(struct module *mod)

1397

static int verify_export_symbols(struct module *mod)

1398

{

1398

{

1399

const char *name = NULL;

1399

const char *name = NULL;

1400

unsigned long i, ret = 0;

1400

unsigned long i, ret = 0;

1401

struct module *owner;

1401

struct module *owner;

1402

const unsigned long *crc;

1402

const unsigned long *crc;

1403

1404

for (i = 0; i < mod->num_syms; i++)

1404

for (i = 0; i < mod->num_syms; i++)

1405

if (!IS_ERR_VALUE(__find_symbol(mod->syms[i].name,

1405

if (!IS_ERR_VALUE(__find_symbol(mod->syms[i].name,

1406

&owner, &crc, 1))) {

1406

&owner, &crc, 1))) {

1407

name = mod->syms[i].name;

1407

name = mod->syms[i].name;

1408

ret = -ENOEXEC;

1408

ret = -ENOEXEC;

1409

goto dup;

1409

goto dup;

1410

}

1410

}

1411

1412

for (i = 0; i < mod->num_gpl_syms; i++)

1412

for (i = 0; i < mod->num_gpl_syms; i++)

1413

if (!IS_ERR_VALUE(__find_symbol(mod->gpl_syms[i].name,

1413

if (!IS_ERR_VALUE(__find_symbol(mod->gpl_syms[i].name,

1414

&owner, &crc, 1))) {

1414

&owner, &crc, 1))) {

1415

name = mod->gpl_syms[i].name;

1415

name = mod->gpl_syms[i].name;

1416

ret = -ENOEXEC;

1416

ret = -ENOEXEC;

1417

goto dup;

1417

goto dup;

1418

}

1418

}

1419

1420

dup:

1420

dup:

1421

if (ret)

1421

if (ret)

1422

printk(KERN_ERR "%s: exports duplicate symbol %s (owned by %s)\n",

1422

printk(KERN_ERR "%s: exports duplicate symbol %s (owned by %s)\n",

1423

mod->name, name, module_name(owner));

1423

mod->name, name, module_name(owner));

1424

1425

return ret;

1425

return ret;

1426

}

1426

}

1427

1428

/* Change all symbols so that st_value encodes the pointer directly. */

1428

/* Change all symbols so that st_value encodes the pointer directly. */

1429

static int simplify_symbols(Elf_Shdr *sechdrs,

1429

static int simplify_symbols(Elf_Shdr *sechdrs,

1430

unsigned int symindex,

1430

unsigned int symindex,

1431

const char *strtab,

1431

const char *strtab,

1432

unsigned int versindex,

1432

unsigned int versindex,

1433

unsigned int pcpuindex,

1433

unsigned int pcpuindex,

1434

struct module *mod)

1434

struct module *mod)

1435

{

1435

{

1436

Elf_Sym *sym = (void *)sechdrs[symindex].sh_addr;

1436

Elf_Sym *sym = (void *)sechdrs[symindex].sh_addr;

1437

unsigned long secbase;

1437

unsigned long secbase;

1438

unsigned int i, n = sechdrs[symindex].sh_size / sizeof(Elf_Sym);

1438

unsigned int i, n = sechdrs[symindex].sh_size / sizeof(Elf_Sym);

1439

int ret = 0;

1439

int ret = 0;

1440

1441

for (i = 1; i < n; i++) {

1441

for (i = 1; i < n; i++) {

1442

switch (sym[i].st_shndx) {

1442

switch (sym[i].st_shndx) {

1443

case SHN_COMMON:

1443

case SHN_COMMON:

1444

/* We compiled with -fno-common. These are not

1444

/* We compiled with -fno-common. These are not

1445

supposed to happen. */

1445

supposed to happen. */

1446

DEBUGP("Common symbol: %s\n", strtab + sym[i].st_name);

1446

DEBUGP("Common symbol: %s\n", strtab + sym[i].st_name);

1447

printk("%s: please compile with -fno-common\n",

1447

printk("%s: please compile with -fno-common\n",

1448

mod->name);

1448

mod->name);

1449

ret = -ENOEXEC;

1449

ret = -ENOEXEC;

1450

break;

1450

break;

1451

1452

case SHN_ABS:

1452

case SHN_ABS:

1453

/* Don't need to do anything */

1453

/* Don't need to do anything */

1454

DEBUGP("Absolute symbol: 0x%08lx\n",

1454

DEBUGP("Absolute symbol: 0x%08lx\n",

1455

(long)sym[i].st_value);

1455

(long)sym[i].st_value);

1456

break;

1456

break;

1457

1458

case SHN_UNDEF:

1458

case SHN_UNDEF:

1459

sym[i].st_value

1459

sym[i].st_value

1460

= resolve_symbol(sechdrs, versindex,

1460

= resolve_symbol(sechdrs, versindex,

1461

strtab + sym[i].st_name, mod);

1461

strtab + sym[i].st_name, mod);

1462

1463

/* Ok if resolved. */

1463

/* Ok if resolved. */

1464

if (!IS_ERR_VALUE(sym[i].st_value))

1464

if (!IS_ERR_VALUE(sym[i].st_value))

1465

break;

1465

break;

1466

/* Ok if weak. */

1466

/* Ok if weak. */

1467

if (ELF_ST_BIND(sym[i].st_info) == STB_WEAK)

1467

if (ELF_ST_BIND(sym[i].st_info) == STB_WEAK)

1468

break;

1468

break;

1469

1470

printk(KERN_WARNING "%s: Unknown symbol %s\n",

1470

printk(KERN_WARNING "%s: Unknown symbol %s\n",

1471

mod->name, strtab + sym[i].st_name);

1471

mod->name, strtab + sym[i].st_name);

1472

ret = -ENOENT;

1472

ret = -ENOENT;

1473

break;

1473

break;

1474

1475

default:

1475

default:

1476

/* Divert to percpu allocation if a percpu var. */

1476

/* Divert to percpu allocation if a percpu var. */

1477

if (sym[i].st_shndx == pcpuindex)

1477

if (sym[i].st_shndx == pcpuindex)

1478

secbase = (unsigned long)mod->percpu;

1478

secbase = (unsigned long)mod->percpu;

1479

else

1479

else

1480

secbase = sechdrs[sym[i].st_shndx].sh_addr;

1480

secbase = sechdrs[sym[i].st_shndx].sh_addr;

1481

sym[i].st_value += secbase;

1481

sym[i].st_value += secbase;

1482

break;

1482

break;

1483

}

1483

}

1484

}

1484

}

1485

1486

return ret;

1486

return ret;

1487

}

1487

}

1488

1489

/* Update size with this section: return offset. */

1489

/* Update size with this section: return offset. */

1490

static long get_offset(unsigned long *size, Elf_Shdr *sechdr)

1490

static long get_offset(unsigned long *size, Elf_Shdr *sechdr)

1491

{

1491

{

1492

long ret;

1492

long ret;

1493

1494

ret = ALIGN(*size, sechdr->sh_addralign ?: 1);

1494

ret = ALIGN(*size, sechdr->sh_addralign ?: 1);

1495

*size = ret + sechdr->sh_size;

1495

*size = ret + sechdr->sh_size;

1496

return ret;

1496

return ret;

1497

}

1497

}

1498

1499

/* Lay out the SHF_ALLOC sections in a way not dissimilar to how ld

1499

/* Lay out the SHF_ALLOC sections in a way not dissimilar to how ld

1500

might -- code, read-only data, read-write data, small data. Tally

1500

might -- code, read-only data, read-write data, small data. Tally

1501

sizes, and place the offsets into sh_entsize fields: high bit means it

1501

sizes, and place the offsets into sh_entsize fields: high bit means it

1502

belongs in init. */

1502

belongs in init. */

1503

static void layout_sections(struct module *mod,

1503

static void layout_sections(struct module *mod,

1504

const Elf_Ehdr *hdr,

1504

const Elf_Ehdr *hdr,

1505

Elf_Shdr *sechdrs,

1505

Elf_Shdr *sechdrs,

1506

const char *secstrings)

1506

const char *secstrings)

1507

{

1507

{

1508

static unsigned long const masks[][2] = {

1508

static unsigned long const masks[][2] = {

1509

/* NOTE: all executable code must be the first section

1509

/* NOTE: all executable code must be the first section

1510

* in this array; otherwise modify the text_size

1510

* in this array; otherwise modify the text_size

1511

* finder in the two loops below */

1511

* finder in the two loops below */

1512

{ SHF_EXECINSTR | SHF_ALLOC, ARCH_SHF_SMALL },

1512

{ SHF_EXECINSTR | SHF_ALLOC, ARCH_SHF_SMALL },

1513

{ SHF_ALLOC, SHF_WRITE | ARCH_SHF_SMALL },

1513

{ SHF_ALLOC, SHF_WRITE | ARCH_SHF_SMALL },

1514

{ SHF_WRITE | SHF_ALLOC, ARCH_SHF_SMALL },

1514

{ SHF_WRITE | SHF_ALLOC, ARCH_SHF_SMALL },

1515

{ ARCH_SHF_SMALL | SHF_ALLOC, 0 }

1515

{ ARCH_SHF_SMALL | SHF_ALLOC, 0 }

1516

};

1516

};

1517

unsigned int m, i;

1517

unsigned int m, i;

1518

1519

for (i = 0; i < hdr->e_shnum; i++)

1519

for (i = 0; i < hdr->e_shnum; i++)

1520

sechdrs[i].sh_entsize = ~0UL;

1520

sechdrs[i].sh_entsize = ~0UL;

1521

1522

DEBUGP("Core section allocation order:\n");

1522

DEBUGP("Core section allocation order:\n");

1523

for (m = 0; m < ARRAY_SIZE(masks); ++m) {

1523

for (m = 0; m < ARRAY_SIZE(masks); ++m) {

1524

for (i = 0; i < hdr->e_shnum; ++i) {

1524

for (i = 0; i < hdr->e_shnum; ++i) {

1525

Elf_Shdr *s = &sechdrs[i];

1525

Elf_Shdr *s = &sechdrs[i];

1526

1527

if ((s->sh_flags & masks[m][0]) != masks[m][0]

1527

if ((s->sh_flags & masks[m][0]) != masks[m][0]

1528

|| (s->sh_flags & masks[m][1])

1528

|| (s->sh_flags & masks[m][1])

1529

|| s->sh_entsize != ~0UL

1529

|| s->sh_entsize != ~0UL

1530

|| strncmp(secstrings + s->sh_name,

1530

|| strncmp(secstrings + s->sh_name,

1531

".init", 5) == 0)

1531

".init", 5) == 0)

1532

continue;

1532

continue;

1533

s->sh_entsize = get_offset(&mod->core_size, s);

1533

s->sh_entsize = get_offset(&mod->core_size, s);

1534

DEBUGP("\t%s\n", secstrings + s->sh_name);

1534

DEBUGP("\t%s\n", secstrings + s->sh_name);

1535

}

1535

}

1536

if (m == 0)

1536

if (m == 0)

1537

mod->core_text_size = mod->core_size;

1537

mod->core_text_size = mod->core_size;

1538

}

1538

}

1539

1540

DEBUGP("Init section allocation order:\n");

1540

DEBUGP("Init section allocation order:\n");

1541

for (m = 0; m < ARRAY_SIZE(masks); ++m) {

1541

for (m = 0; m < ARRAY_SIZE(masks); ++m) {

1542

for (i = 0; i < hdr->e_shnum; ++i) {

1542

for (i = 0; i < hdr->e_shnum; ++i) {

1543

Elf_Shdr *s = &sechdrs[i];

1543

Elf_Shdr *s = &sechdrs[i];

1544

1545

if ((s->sh_flags & masks[m][0]) != masks[m][0]

1545

if ((s->sh_flags & masks[m][0]) != masks[m][0]

1546

|| (s->sh_flags & masks[m][1])

1546

|| (s->sh_flags & masks[m][1])

1547

|| s->sh_entsize != ~0UL

1547

|| s->sh_entsize != ~0UL

1548

|| strncmp(secstrings + s->sh_name,

1548

|| strncmp(secstrings + s->sh_name,

1549

".init", 5) != 0)

1549

".init", 5) != 0)

1550

continue;

1550

continue;

1551

s->sh_entsize = (get_offset(&mod->init_size, s)

1551

s->sh_entsize = (get_offset(&mod->init_size, s)

1552

| INIT_OFFSET_MASK);

1552

| INIT_OFFSET_MASK);

1553

DEBUGP("\t%s\n", secstrings + s->sh_name);

1553

DEBUGP("\t%s\n", secstrings + s->sh_name);

1554

}

1554

}

1555

if (m == 0)

1555

if (m == 0)

1556

mod->init_text_size = mod->init_size;

1556

mod->init_text_size = mod->init_size;

1557

}

1557

}

1558

}

1558

}

1559

1560

static void set_license(struct module *mod, const char *license)

1560

static void set_license(struct module *mod, const char *license)

1561

{

1561

{

1562

if (!license)

1562

if (!license)

1563

license = "unspecified";

1563

license = "unspecified";

1564

1565

if (!license_is_gpl_compatible(license)) {

1565

if (!license_is_gpl_compatible(license)) {

1566

if (!(tainted & TAINT_PROPRIETARY_MODULE))

1566

if (!(tainted & TAINT_PROPRIETARY_MODULE))

1567

printk(KERN_WARNING "%s: module license '%s' taints "

1567

printk(KERN_WARNING "%s: module license '%s' taints "

1568

"kernel.\n", mod->name, license);

1568

"kernel.\n", mod->name, license);

1569

add_taint_module(mod, TAINT_PROPRIETARY_MODULE);

1569

add_taint_module(mod, TAINT_PROPRIETARY_MODULE);

1570

}

1570

}

1571

}

1571

}

1572

1573

/* Parse tag=value strings from .modinfo section */

1573

/* Parse tag=value strings from .modinfo section */

1574

static char *next_string(char *string, unsigned long *secsize)

1574

static char *next_string(char *string, unsigned long *secsize)

1575

{

1575

{

1576

/* Skip non-zero chars */

1576

/* Skip non-zero chars */

1577

while (string[0]) {

1577

while (string[0]) {

1578

string++;

1578

string++;

1579

if ((*secsize)-- <= 1)

1579

if ((*secsize)-- <= 1)

1580

return NULL;

1580

return NULL;

1581

}

1581

}

1582

1583

/* Skip any zero padding. */

1583

/* Skip any zero padding. */

1584

while (!string[0]) {

1584

while (!string[0]) {

1585

string++;

1585

string++;

1586

if ((*secsize)-- <= 1)

1586

if ((*secsize)-- <= 1)

1587

return NULL;

1587

return NULL;

1588

}

1588

}

1589

return string;

1589

return string;

1590

}

1590

}

1591

1592

static char *get_modinfo(Elf_Shdr *sechdrs,

1592

static char *get_modinfo(Elf_Shdr *sechdrs,

1593

unsigned int info,

1593

unsigned int info,

1594

const char *tag)

1594

const char *tag)

1595

{

1595

{

1596

char *p;

1596

char *p;

1597

unsigned int taglen = strlen(tag);

1597

unsigned int taglen = strlen(tag);

1598

unsigned long size = sechdrs[info].sh_size;

1598

unsigned long size = sechdrs[info].sh_size;

1599

1600

for (p = (char *)sechdrs[info].sh_addr; p; p = next_string(p, &size)) {

1600

for (p = (char *)sechdrs[info].sh_addr; p; p = next_string(p, &size)) {

1601

if (strncmp(p, tag, taglen) == 0 && p[taglen] == '=')

1601

if (strncmp(p, tag, taglen) == 0 && p[taglen] == '=')

1602

return p + taglen + 1;

1602

return p + taglen + 1;

1603

}

1603

}

1604

return NULL;

1604

return NULL;

1605

}

1605

}

1606

1607

static void setup_modinfo(struct module *mod, Elf_Shdr *sechdrs,

1607

static void setup_modinfo(struct module *mod, Elf_Shdr *sechdrs,

1608

unsigned int infoindex)

1608

unsigned int infoindex)

1609

{

1609

{

1610

struct module_attribute *attr;

1610

struct module_attribute *attr;

1611

int i;

1611

int i;

1612

1613

for (i = 0; (attr = modinfo_attrs[i]); i++) {

1613

for (i = 0; (attr = modinfo_attrs[i]); i++) {

1614

if (attr->setup)

1614

if (attr->setup)

1615

attr->setup(mod,

1615

attr->setup(mod,

1616

get_modinfo(sechdrs,

1616

get_modinfo(sechdrs,

1617

infoindex,

1617

infoindex,

1618

attr->attr.name));

1618

attr->attr.name));

1619

}

1619

}

1620

}

1620

}

1621

1622

#ifdef CONFIG_KALLSYMS

1622

#ifdef CONFIG_KALLSYMS

1623

static int is_exported(const char *name, const struct module *mod)

1623

static int is_exported(const char *name, const struct module *mod)

1624

{

1624

{

1625

if (!mod && lookup_symbol(name, __start___ksymtab, __stop___ksymtab))

1625

if (!mod && lookup_symbol(name, __start___ksymtab, __stop___ksymtab))

1626

return 1;

1626

return 1;

1627

else

1627

else

1628

if (mod && lookup_symbol(name, mod->syms, mod->syms + mod->num_syms))

1628

if (mod && lookup_symbol(name, mod->syms, mod->syms + mod->num_syms))

1629

return 1;

1629

return 1;

1630

else

1630

else

1631

return 0;

1631

return 0;

1632

}

1632

}

1633

1634

/* As per nm */

1634

/* As per nm */

1635

static char elf_type(const Elf_Sym *sym,

1635

static char elf_type(const Elf_Sym *sym,

1636

Elf_Shdr *sechdrs,

1636

Elf_Shdr *sechdrs,

1637

const char *secstrings,

1637

const char *secstrings,

1638

struct module *mod)

1638

struct module *mod)

1639

{

1639

{

1640

if (ELF_ST_BIND(sym->st_info) == STB_WEAK) {

1640

if (ELF_ST_BIND(sym->st_info) == STB_WEAK) {

1641

if (ELF_ST_TYPE(sym->st_info) == STT_OBJECT)

1641

if (ELF_ST_TYPE(sym->st_info) == STT_OBJECT)

1642

return 'v';

1642

return 'v';

1643

else

1643

else

1644

return 'w';

1644

return 'w';

1645

}

1645

}

1646

if (sym->st_shndx == SHN_UNDEF)

1646

if (sym->st_shndx == SHN_UNDEF)

1647

return 'U';

1647

return 'U';

1648

if (sym->st_shndx == SHN_ABS)

1648

if (sym->st_shndx == SHN_ABS)

1649

return 'a';

1649

return 'a';

1650

if (sym->st_shndx >= SHN_LORESERVE)

1650

if (sym->st_shndx >= SHN_LORESERVE)

1651

return '?';

1651

return '?';

1652

if (sechdrs[sym->st_shndx].sh_flags & SHF_EXECINSTR)

1652

if (sechdrs[sym->st_shndx].sh_flags & SHF_EXECINSTR)

1653

return 't';

1653

return 't';

1654

if (sechdrs[sym->st_shndx].sh_flags & SHF_ALLOC

1654

if (sechdrs[sym->st_shndx].sh_flags & SHF_ALLOC

1655

&& sechdrs[sym->st_shndx].sh_type != SHT_NOBITS) {

1655

&& sechdrs[sym->st_shndx].sh_type != SHT_NOBITS) {

1656

if (!(sechdrs[sym->st_shndx].sh_flags & SHF_WRITE))

1656

if (!(sechdrs[sym->st_shndx].sh_flags & SHF_WRITE))

1657

return 'r';

1657

return 'r';

1658

else if (sechdrs[sym->st_shndx].sh_flags & ARCH_SHF_SMALL)

1658

else if (sechdrs[sym->st_shndx].sh_flags & ARCH_SHF_SMALL)

1659

return 'g';

1659

return 'g';

1660

else

1660

else

1661

return 'd';

1661

return 'd';

1662

}

1662

}

1663

if (sechdrs[sym->st_shndx].sh_type == SHT_NOBITS) {

1663

if (sechdrs[sym->st_shndx].sh_type == SHT_NOBITS) {

1664

if (sechdrs[sym->st_shndx].sh_flags & ARCH_SHF_SMALL)

1664

if (sechdrs[sym->st_shndx].sh_flags & ARCH_SHF_SMALL)

1665

return 's';

1665

return 's';

1666

else

1666

else

1667

return 'b';

1667

return 'b';

1668

}

1668

}

1669

if (strncmp(secstrings + sechdrs[sym->st_shndx].sh_name,

1669

if (strncmp(secstrings + sechdrs[sym->st_shndx].sh_name,

1670

".debug", strlen(".debug")) == 0)

1670

".debug", strlen(".debug")) == 0)

1671

return 'n';

1671

return 'n';

1672

return '?';

1672

return '?';

1673

}

1673

}

1674

1675

static void add_kallsyms(struct module *mod,

1675

static void add_kallsyms(struct module *mod,

1676

Elf_Shdr *sechdrs,

1676

Elf_Shdr *sechdrs,

1677

unsigned int symindex,

1677

unsigned int symindex,

1678

unsigned int strindex,

1678

unsigned int strindex,

1679

const char *secstrings)

1679

const char *secstrings)

1680

{

1680

{

1681

unsigned int i;

1681

unsigned int i;

1682

1683

mod->symtab = (void *)sechdrs[symindex].sh_addr;

1683

mod->symtab = (void *)sechdrs[symindex].sh_addr;

1684

mod->num_symtab = sechdrs[symindex].sh_size / sizeof(Elf_Sym);

1684

mod->num_symtab = sechdrs[symindex].sh_size / sizeof(Elf_Sym);

1685

mod->strtab = (void *)sechdrs[strindex].sh_addr;

1685

mod->strtab = (void *)sechdrs[strindex].sh_addr;

1686

1687

/* Set types up while we still have access to sections. */

1687

/* Set types up while we still have access to sections. */

1688

for (i = 0; i < mod->num_symtab; i++)

1688

for (i = 0; i < mod->num_symtab; i++)

1689

mod->symtab[i].st_info

1689

mod->symtab[i].st_info

1690

= elf_type(&mod->symtab[i], sechdrs, secstrings, mod);

1690

= elf_type(&mod->symtab[i], sechdrs, secstrings, mod);

1691

}

1691

}

1692

#else

1692

#else

1693

static inline void add_kallsyms(struct module *mod,

1693

static inline void add_kallsyms(struct module *mod,

1694

Elf_Shdr *sechdrs,

1694

Elf_Shdr *sechdrs,

1695

unsigned int symindex,

1695

unsigned int symindex,

1696

unsigned int strindex,

1696

unsigned int strindex,

1697

const char *secstrings)

1697

const char *secstrings)

1698

{

1698

{

1699

}

1699

}

1700

#endif /* CONFIG_KALLSYMS */

1700

#endif /* CONFIG_KALLSYMS */

1701

1702

/* Allocate and load the module: note that size of section 0 is always

1702

/* Allocate and load the module: note that size of section 0 is always

1703

zero, and we rely on this for optional sections. */

1703

zero, and we rely on this for optional sections. */

1704

static struct module *load_module(void __user *umod,

1704

static struct module *load_module(void __user *umod,

1705

unsigned long len,

1705

unsigned long len,

1706

const char __user *uargs)

1706

const char __user *uargs)

1707

{

1707

{

1708

Elf_Ehdr *hdr;

1708

Elf_Ehdr *hdr;

1709

Elf_Shdr *sechdrs;

1709

Elf_Shdr *sechdrs;

1710

char *secstrings, *args, *modmagic, *strtab = NULL;

1710

char *secstrings, *args, *modmagic, *strtab = NULL;

1711

unsigned int i;

1711

unsigned int i;

1712

unsigned int symindex = 0;

1712

unsigned int symindex = 0;

1713

unsigned int strindex = 0;

1713

unsigned int strindex = 0;

1714

unsigned int setupindex;

1714

unsigned int setupindex;

1715

unsigned int exindex;

1715

unsigned int exindex;

1716

unsigned int exportindex;

1716

unsigned int exportindex;

1717

unsigned int modindex;

1717

unsigned int modindex;

1718

unsigned int obsparmindex;

1718

unsigned int obsparmindex;

1719

unsigned int infoindex;

1719

unsigned int infoindex;

1720

unsigned int gplindex;

1720

unsigned int gplindex;

1721

unsigned int crcindex;

1721

unsigned int crcindex;

1722

unsigned int gplcrcindex;

1722

unsigned int gplcrcindex;

1723

unsigned int versindex;

1723

unsigned int versindex;

1724

unsigned int pcpuindex;

1724

unsigned int pcpuindex;

1725

unsigned int gplfutureindex;

1725

unsigned int gplfutureindex;

1726

unsigned int gplfuturecrcindex;

1726

unsigned int gplfuturecrcindex;

1727

unsigned int unwindex = 0;

1727

unsigned int unwindex = 0;

1728

unsigned int unusedindex;

1728

unsigned int unusedindex;

1729

unsigned int unusedcrcindex;

1729

unsigned int unusedcrcindex;

1730

unsigned int unusedgplindex;

1730

unsigned int unusedgplindex;

1731

unsigned int unusedgplcrcindex;

1731

unsigned int unusedgplcrcindex;

1732

unsigned int markersindex;

1732

unsigned int markersindex;

1733

unsigned int markersstringsindex;

1733

unsigned int markersstringsindex;

1734

struct module *mod;

1734

struct module *mod;

1735

long err = 0;

1735

long err = 0;

1736

void *percpu = NULL, *ptr = NULL; /* Stops spurious gcc warning */

1736

void *percpu = NULL, *ptr = NULL; /* Stops spurious gcc warning */

1737

struct exception_table_entry *extable;

1737

struct exception_table_entry *extable;

1738

mm_segment_t old_fs;

1738

mm_segment_t old_fs;

1739

1740

DEBUGP("load_module: umod=%p, len=%lu, uargs=%p\n",

1740

DEBUGP("load_module: umod=%p, len=%lu, uargs=%p\n",

1741

umod, len, uargs);

1741

umod, len, uargs);

1742

if (len < sizeof(*hdr))

1742

if (len < sizeof(*hdr))

1743

return ERR_PTR(-ENOEXEC);

1743

return ERR_PTR(-ENOEXEC);

1744

1745

/* Suck in entire file: we'll want most of it. */

1745

/* Suck in entire file: we'll want most of it. */

1746

/* vmalloc barfs on "unusual" numbers. Check here */

1746

/* vmalloc barfs on "unusual" numbers. Check here */

1747

if (len > 64 * 1024 * 1024 || (hdr = vmalloc(len)) == NULL)

1747

if (len > 64 * 1024 * 1024 || (hdr = vmalloc(len)) == NULL)

1748

return ERR_PTR(-ENOMEM);

1748

return ERR_PTR(-ENOMEM);

1749

if (copy_from_user(hdr, umod, len) != 0) {

1749

if (copy_from_user(hdr, umod, len) != 0) {

1750

err = -EFAULT;

1750

err = -EFAULT;

1751

goto free_hdr;

1751

goto free_hdr;

1752

}

1752

}

1753

1754

/* Sanity checks against insmoding binaries or wrong arch,

1754

/* Sanity checks against insmoding binaries or wrong arch,

1755

weird elf version */

1755

weird elf version */

1756

if (memcmp(hdr->e_ident, ELFMAG, 4) != 0

1756

if (memcmp(hdr->e_ident, ELFMAG, 4) != 0

1757

|| hdr->e_type != ET_REL

1757

|| hdr->e_type != ET_REL

1758

|| !elf_check_arch(hdr)

1758

|| !elf_check_arch(hdr)

1759

|| hdr->e_shentsize != sizeof(*sechdrs)) {

1759

|| hdr->e_shentsize != sizeof(*sechdrs)) {

1760

err = -ENOEXEC;

1760

err = -ENOEXEC;

1761

goto free_hdr;

1761

goto free_hdr;

1762

}

1762

}

1763

1764

if (len < hdr->e_shoff + hdr->e_shnum * sizeof(Elf_Shdr))

1764

if (len < hdr->e_shoff + hdr->e_shnum * sizeof(Elf_Shdr))

1765

goto truncated;

1765

goto truncated;

1766

1767

/* Convenience variables */

1767

/* Convenience variables */

1768

sechdrs = (void *)hdr + hdr->e_shoff;

1768

sechdrs = (void *)hdr + hdr->e_shoff;

1769

secstrings = (void *)hdr + sechdrs[hdr->e_shstrndx].sh_offset;

1769

secstrings = (void *)hdr + sechdrs[hdr->e_shstrndx].sh_offset;

1770

sechdrs[0].sh_addr = 0;

1770

sechdrs[0].sh_addr = 0;

1771

1772

for (i = 1; i < hdr->e_shnum; i++) {

1772

for (i = 1; i < hdr->e_shnum; i++) {

1773

if (sechdrs[i].sh_type != SHT_NOBITS

1773

if (sechdrs[i].sh_type != SHT_NOBITS

1774

&& len < sechdrs[i].sh_offset + sechdrs[i].sh_size)

1774

&& len < sechdrs[i].sh_offset + sechdrs[i].sh_size)

1775

goto truncated;

1775

goto truncated;

1776

1777

/* Mark all sections sh_addr with their address in the

1777

/* Mark all sections sh_addr with their address in the

1778

temporary image. */

1778

temporary image. */

1779

sechdrs[i].sh_addr = (size_t)hdr + sechdrs[i].sh_offset;

1779

sechdrs[i].sh_addr = (size_t)hdr + sechdrs[i].sh_offset;

1780

1781

/* Internal symbols and strings. */

1781

/* Internal symbols and strings. */

1782

if (sechdrs[i].sh_type == SHT_SYMTAB) {

1782

if (sechdrs[i].sh_type == SHT_SYMTAB) {

1783

symindex = i;

1783

symindex = i;

1784

strindex = sechdrs[i].sh_link;

1784

strindex = sechdrs[i].sh_link;

1785

strtab = (char *)hdr + sechdrs[strindex].sh_offset;

1785

strtab = (char *)hdr + sechdrs[strindex].sh_offset;

1786

}

1786

}

1787

#ifndef CONFIG_MODULE_UNLOAD

1787

#ifndef CONFIG_MODULE_UNLOAD

1788

/* Don't load .exit sections */

1788

/* Don't load .exit sections */

1789

if (strncmp(secstrings+sechdrs[i].sh_name, ".exit", 5) == 0)

1789

if (strncmp(secstrings+sechdrs[i].sh_name, ".exit", 5) == 0)

1790

sechdrs[i].sh_flags &= ~(unsigned long)SHF_ALLOC;

1790

sechdrs[i].sh_flags &= ~(unsigned long)SHF_ALLOC;

1791

#endif

1791

#endif

1792

}

1792

}

1793

1794

modindex = find_sec(hdr, sechdrs, secstrings,

1794

modindex = find_sec(hdr, sechdrs, secstrings,

1795

".gnu.linkonce.this_module");

1795

".gnu.linkonce.this_module");

1796

if (!modindex) {

1796

if (!modindex) {

1797

printk(KERN_WARNING "No module found in object\n");

1797

printk(KERN_WARNING "No module found in object\n");

1798

err = -ENOEXEC;

1798

err = -ENOEXEC;

1799

goto free_hdr;

1799

goto free_hdr;

1800

}

1800

}

1801

mod = (void *)sechdrs[modindex].sh_addr;

1801

mod = (void *)sechdrs[modindex].sh_addr;

1802

1803

if (symindex == 0) {

1803

if (symindex == 0) {

1804

printk(KERN_WARNING "%s: module has no symbols (stripped?)\n",

1804

printk(KERN_WARNING "%s: module has no symbols (stripped?)\n",

1805

mod->name);

1805

mod->name);

1806

err = -ENOEXEC;

1806

err = -ENOEXEC;

1807

goto free_hdr;

1807

goto free_hdr;

1808

}

1808

}

1809

1810

/* Optional sections */

1810

/* Optional sections */

1811

exportindex = find_sec(hdr, sechdrs, secstrings, "__ksymtab");

1811

exportindex = find_sec(hdr, sechdrs, secstrings, "__ksymtab");

1812

gplindex = find_sec(hdr, sechdrs, secstrings, "__ksymtab_gpl");

1812

gplindex = find_sec(hdr, sechdrs, secstrings, "__ksymtab_gpl");

1813

gplfutureindex = find_sec(hdr, sechdrs, secstrings, "__ksymtab_gpl_future");

1813

gplfutureindex = find_sec(hdr, sechdrs, secstrings, "__ksymtab_gpl_future");

1814

unusedindex = find_sec(hdr, sechdrs, secstrings, "__ksymtab_unused");

1814

unusedindex = find_sec(hdr, sechdrs, secstrings, "__ksymtab_unused");

1815

unusedgplindex = find_sec(hdr, sechdrs, secstrings, "__ksymtab_unused_gpl");

1815

unusedgplindex = find_sec(hdr, sechdrs, secstrings, "__ksymtab_unused_gpl");

1816

crcindex = find_sec(hdr, sechdrs, secstrings, "__kcrctab");

1816

crcindex = find_sec(hdr, sechdrs, secstrings, "__kcrctab");

1817

gplcrcindex = find_sec(hdr, sechdrs, secstrings, "__kcrctab_gpl");

1817

gplcrcindex = find_sec(hdr, sechdrs, secstrings, "__kcrctab_gpl");

1818

gplfuturecrcindex = find_sec(hdr, sechdrs, secstrings, "__kcrctab_gpl_future");

1818

gplfuturecrcindex = find_sec(hdr, sechdrs, secstrings, "__kcrctab_gpl_future");

1819

unusedcrcindex = find_sec(hdr, sechdrs, secstrings, "__kcrctab_unused");

1819

unusedcrcindex = find_sec(hdr, sechdrs, secstrings, "__kcrctab_unused");

1820

unusedgplcrcindex = find_sec(hdr, sechdrs, secstrings, "__kcrctab_unused_gpl");

1820

unusedgplcrcindex = find_sec(hdr, sechdrs, secstrings, "__kcrctab_unused_gpl");

1821

setupindex = find_sec(hdr, sechdrs, secstrings, "__param");

1821

setupindex = find_sec(hdr, sechdrs, secstrings, "__param");

1822

exindex = find_sec(hdr, sechdrs, secstrings, "__ex_table");

1822

exindex = find_sec(hdr, sechdrs, secstrings, "__ex_table");

1823

obsparmindex = find_sec(hdr, sechdrs, secstrings, "__obsparm");

1823

obsparmindex = find_sec(hdr, sechdrs, secstrings, "__obsparm");

1824

versindex = find_sec(hdr, sechdrs, secstrings, "__versions");

1824

versindex = find_sec(hdr, sechdrs, secstrings, "__versions");

1825

infoindex = find_sec(hdr, sechdrs, secstrings, ".modinfo");

1825

infoindex = find_sec(hdr, sechdrs, secstrings, ".modinfo");

1826

pcpuindex = find_pcpusec(hdr, sechdrs, secstrings);

1826

pcpuindex = find_pcpusec(hdr, sechdrs, secstrings);

1827

#ifdef ARCH_UNWIND_SECTION_NAME

1827

#ifdef ARCH_UNWIND_SECTION_NAME

1828

unwindex = find_sec(hdr, sechdrs, secstrings, ARCH_UNWIND_SECTION_NAME);

1828

unwindex = find_sec(hdr, sechdrs, secstrings, ARCH_UNWIND_SECTION_NAME);

1829

#endif

1829

#endif

1830

1831

/* Don't keep modinfo section */

1831

/* Don't keep modinfo and version sections. */

1832

sechdrs[infoindex].sh_flags &= ~(unsigned long)SHF_ALLOC;

1832

sechdrs[infoindex].sh_flags &= ~(unsigned long)SHF_ALLOC;

1833

sechdrs[versindex].sh_flags &= ~(unsigned long)SHF_ALLOC;

1833

#ifdef CONFIG_KALLSYMS

1834

#ifdef CONFIG_KALLSYMS

1834

/* Keep symbol and string tables for decoding later. */

1835

/* Keep symbol and string tables for decoding later. */

1835

sechdrs[symindex].sh_flags |= SHF_ALLOC;

1836

sechdrs[symindex].sh_flags |= SHF_ALLOC;

1836

sechdrs[strindex].sh_flags |= SHF_ALLOC;

1837

sechdrs[strindex].sh_flags |= SHF_ALLOC;

1837

#endif

1838

#endif

1838

if (unwindex)

1839

if (unwindex)

1839

sechdrs[unwindex].sh_flags |= SHF_ALLOC;

1840

sechdrs[unwindex].sh_flags |= SHF_ALLOC;

1840

1841

/* Check module struct version now, before we try to use module. */

1842

/* Check module struct version now, before we try to use module. */

1842

if (!check_modstruct_version(sechdrs, versindex, mod)) {

1843

if (!check_modstruct_version(sechdrs, versindex, mod)) {

1843

err = -ENOEXEC;

1844

err = -ENOEXEC;

1844

goto free_hdr;

1845

goto free_hdr;

1845

}

1846

}

1846

1847

modmagic = get_modinfo(sechdrs, infoindex, "vermagic");

1848

modmagic = get_modinfo(sechdrs, infoindex, "vermagic");

1848

/* This is allowed: modprobe --force will invalidate it. */

1849

/* This is allowed: modprobe --force will invalidate it. */

1849

if (!modmagic) {

1850

if (!modmagic) {

1850

add_taint_module(mod, TAINT_FORCED_MODULE);

1851

add_taint_module(mod, TAINT_FORCED_MODULE);

1851

printk(KERN_WARNING "%s: no version magic, tainting kernel.\n",

1852

printk(KERN_WARNING "%s: no version magic, tainting kernel.\n",

1852

mod->name);

1853

mod->name);

1853

} else if (!same_magic(modmagic, vermagic)) {

1854

} else if (!same_magic(modmagic, vermagic)) {

1854

printk(KERN_ERR "%s: version magic '%s' should be '%s'\n",

1855

printk(KERN_ERR "%s: version magic '%s' should be '%s'\n",

1855

mod->name, modmagic, vermagic);

1856

mod->name, modmagic, vermagic);

1856

err = -ENOEXEC;

1857

err = -ENOEXEC;

1857

goto free_hdr;

1858

goto free_hdr;

1858

}

1859

}

1859

1860

/* Now copy in args */

1861

/* Now copy in args */

1861

args = strndup_user(uargs, ~0UL >> 1);

1862

args = strndup_user(uargs, ~0UL >> 1);

1862

if (IS_ERR(args)) {

1863

if (IS_ERR(args)) {

1863

err = PTR_ERR(args);

1864

err = PTR_ERR(args);

1864

goto free_hdr;

1865

goto free_hdr;

1865

}

1866

}

1866

1867

if (find_module(mod->name)) {

1868

if (find_module(mod->name)) {

1868

err = -EEXIST;

1869

err = -EEXIST;

1869

goto free_mod;

1870

goto free_mod;

1870

}

1871

}

1871

1872

mod->state = MODULE_STATE_COMING;

1873

mod->state = MODULE_STATE_COMING;

1873

1874

/* Allow arches to frob section contents and sizes. */

1875

/* Allow arches to frob section contents and sizes. */

1875

err = module_frob_arch_sections(hdr, sechdrs, secstrings, mod);

1876

err = module_frob_arch_sections(hdr, sechdrs, secstrings, mod);

1876

if (err < 0)

1877

if (err < 0)

1877

goto free_mod;

1878

goto free_mod;

1878

1879

if (pcpuindex) {

1880

if (pcpuindex) {

1880

/* We have a special allocation for this section. */

1881

/* We have a special allocation for this section. */

1881

percpu = percpu_modalloc(sechdrs[pcpuindex].sh_size,

1882

percpu = percpu_modalloc(sechdrs[pcpuindex].sh_size,

1882

sechdrs[pcpuindex].sh_addralign,

1883

sechdrs[pcpuindex].sh_addralign,

1883

mod->name);

1884

mod->name);

1884

if (!percpu) {

1885

if (!percpu) {

1885

err = -ENOMEM;

1886

err = -ENOMEM;

1886

goto free_mod;

1887

goto free_mod;

1887

}

1888

}

1888

sechdrs[pcpuindex].sh_flags &= ~(unsigned long)SHF_ALLOC;

1889

sechdrs[pcpuindex].sh_flags &= ~(unsigned long)SHF_ALLOC;

1889

mod->percpu = percpu;

1890

mod->percpu = percpu;

1890

}

1891

}

1891

1892

/* Determine total sizes, and put offsets in sh_entsize. For now

1893

/* Determine total sizes, and put offsets in sh_entsize. For now

1893

this is done generically; there doesn't appear to be any

1894

this is done generically; there doesn't appear to be any

1894

special cases for the architectures. */

1895

special cases for the architectures. */

1895

layout_sections(mod, hdr, sechdrs, secstrings);

1896

layout_sections(mod, hdr, sechdrs, secstrings);

1896

1897

/* Do the allocs. */

1898

/* Do the allocs. */

1898

ptr = module_alloc(mod->core_size);

1899

ptr = module_alloc(mod->core_size);

1899

if (!ptr) {

1900

if (!ptr) {

1900

err = -ENOMEM;

1901

err = -ENOMEM;

1901

goto free_percpu;

1902

goto free_percpu;

1902

}

1903

}

1903

memset(ptr, 0, mod->core_size);

1904

memset(ptr, 0, mod->core_size);

1904

mod->module_core = ptr;

1905

mod->module_core = ptr;

1905

1906

ptr = module_alloc(mod->init_size);

1907

ptr = module_alloc(mod->init_size);

1907

if (!ptr && mod->init_size) {

1908

if (!ptr && mod->init_size) {

1908

err = -ENOMEM;

1909

err = -ENOMEM;

1909

goto free_core;

1910

goto free_core;

1910

}

1911

}

1911

memset(ptr, 0, mod->init_size);

1912

memset(ptr, 0, mod->init_size);

1912

mod->module_init = ptr;

1913

mod->module_init = ptr;

1913

1914

/* Transfer each section which specifies SHF_ALLOC */

1915

/* Transfer each section which specifies SHF_ALLOC */

1915

DEBUGP("final section addresses:\n");

1916

DEBUGP("final section addresses:\n");

1916

for (i = 0; i < hdr->e_shnum; i++) {

1917

for (i = 0; i < hdr->e_shnum; i++) {

1917

void *dest;

1918

void *dest;

1918

1919

if (!(sechdrs[i].sh_flags & SHF_ALLOC))

1920

if (!(sechdrs[i].sh_flags & SHF_ALLOC))

1920

continue;

1921

continue;

1921

1922

if (sechdrs[i].sh_entsize & INIT_OFFSET_MASK)

1923

if (sechdrs[i].sh_entsize & INIT_OFFSET_MASK)

1923

dest = mod->module_init

1924

dest = mod->module_init

1924

+ (sechdrs[i].sh_entsize & ~INIT_OFFSET_MASK);

1925

+ (sechdrs[i].sh_entsize & ~INIT_OFFSET_MASK);

1925

else

1926

else

1926

dest = mod->module_core + sechdrs[i].sh_entsize;

1927

dest = mod->module_core + sechdrs[i].sh_entsize;

1927

1928

if (sechdrs[i].sh_type != SHT_NOBITS)

1929

if (sechdrs[i].sh_type != SHT_NOBITS)

1929

memcpy(dest, (void *)sechdrs[i].sh_addr,

1930

memcpy(dest, (void *)sechdrs[i].sh_addr,

1930

sechdrs[i].sh_size);

1931

sechdrs[i].sh_size);

1931

/* Update sh_addr to point to copy in image. */

1932

/* Update sh_addr to point to copy in image. */

1932

sechdrs[i].sh_addr = (unsigned long)dest;

1933

sechdrs[i].sh_addr = (unsigned long)dest;

1933

DEBUGP("\t0x%lx %s\n", sechdrs[i].sh_addr, secstrings + sechdrs[i].sh_name);

1934

DEBUGP("\t0x%lx %s\n", sechdrs[i].sh_addr, secstrings + sechdrs[i].sh_name);

1934

}

1935

}

1935

/* Module has been moved. */

1936

/* Module has been moved. */

1936

mod = (void *)sechdrs[modindex].sh_addr;

1937

mod = (void *)sechdrs[modindex].sh_addr;

1937

1938

/* Now we've moved module, initialize linked lists, etc. */

1939

/* Now we've moved module, initialize linked lists, etc. */

1939

module_unload_init(mod);

1940

module_unload_init(mod);

1940

1941

/* add kobject, so we can reference it. */

1942

/* add kobject, so we can reference it. */

1942

err = mod_sysfs_init(mod);

1943

err = mod_sysfs_init(mod);

1943

if (err)

1944

if (err)

1944

goto free_unload;

1945

goto free_unload;

1945

1946

/* Set up license info based on the info section */

1947

/* Set up license info based on the info section */

1947

set_license(mod, get_modinfo(sechdrs, infoindex, "license"));

1948

set_license(mod, get_modinfo(sechdrs, infoindex, "license"));

1948

1949

/*

1950

/*

1950

* ndiswrapper is under GPL by itself, but loads proprietary modules.

1951

* ndiswrapper is under GPL by itself, but loads proprietary modules.

1951

* Don't use add_taint_module(), as it would prevent ndiswrapper from

1952

* Don't use add_taint_module(), as it would prevent ndiswrapper from

1952

* using GPL-only symbols it needs.

1953

* using GPL-only symbols it needs.

1953

*/

1954

*/

1954

if (strcmp(mod->name, "ndiswrapper") == 0)

1955

if (strcmp(mod->name, "ndiswrapper") == 0)

1955

add_taint(TAINT_PROPRIETARY_MODULE);

1956

add_taint(TAINT_PROPRIETARY_MODULE);

1956

1957

/* driverloader was caught wrongly pretending to be under GPL */

1958

/* driverloader was caught wrongly pretending to be under GPL */

1958

if (strcmp(mod->name, "driverloader") == 0)

1959

if (strcmp(mod->name, "driverloader") == 0)

1959

add_taint_module(mod, TAINT_PROPRIETARY_MODULE);

1960

add_taint_module(mod, TAINT_PROPRIETARY_MODULE);

1960

1961

/* Set up MODINFO_ATTR fields */

1962

/* Set up MODINFO_ATTR fields */

1962

setup_modinfo(mod, sechdrs, infoindex);

1963

setup_modinfo(mod, sechdrs, infoindex);

1963

1964

/* Fix up syms, so that st_value is a pointer to location. */

1965

/* Fix up syms, so that st_value is a pointer to location. */

1965

err = simplify_symbols(sechdrs, symindex, strtab, versindex, pcpuindex,

1966

err = simplify_symbols(sechdrs, symindex, strtab, versindex, pcpuindex,

1966

mod);

1967

mod);

1967

if (err < 0)

1968

if (err < 0)

1968

goto cleanup;

1969

goto cleanup;

1969

1970

/* Set up EXPORTed & EXPORT_GPLed symbols (section 0 is 0 length) */

1971

/* Set up EXPORTed & EXPORT_GPLed symbols (section 0 is 0 length) */

1971

mod->num_syms = sechdrs[exportindex].sh_size / sizeof(*mod->syms);

1972

mod->num_syms = sechdrs[exportindex].sh_size / sizeof(*mod->syms);

1972

mod->syms = (void *)sechdrs[exportindex].sh_addr;

1973

mod->syms = (void *)sechdrs[exportindex].sh_addr;

1973

if (crcindex)

1974

if (crcindex)

1974

mod->crcs = (void *)sechdrs[crcindex].sh_addr;

1975

mod->crcs = (void *)sechdrs[crcindex].sh_addr;

1975

mod->num_gpl_syms = sechdrs[gplindex].sh_size / sizeof(*mod->gpl_syms);

1976

mod->num_gpl_syms = sechdrs[gplindex].sh_size / sizeof(*mod->gpl_syms);

1976

mod->gpl_syms = (void *)sechdrs[gplindex].sh_addr;

1977

mod->gpl_syms = (void *)sechdrs[gplindex].sh_addr;

1977

if (gplcrcindex)

1978

if (gplcrcindex)

1978

mod->gpl_crcs = (void *)sechdrs[gplcrcindex].sh_addr;

1979

mod->gpl_crcs = (void *)sechdrs[gplcrcindex].sh_addr;

1979

mod->num_gpl_future_syms = sechdrs[gplfutureindex].sh_size /

1980

mod->num_gpl_future_syms = sechdrs[gplfutureindex].sh_size /

1980

sizeof(*mod->gpl_future_syms);

1981

sizeof(*mod->gpl_future_syms);

1981

mod->num_unused_syms = sechdrs[unusedindex].sh_size /

1982

mod->num_unused_syms = sechdrs[unusedindex].sh_size /

1982

sizeof(*mod->unused_syms);

1983

sizeof(*mod->unused_syms);

1983

mod->num_unused_gpl_syms = sechdrs[unusedgplindex].sh_size /

1984

mod->num_unused_gpl_syms = sechdrs[unusedgplindex].sh_size /

1984

sizeof(*mod->unused_gpl_syms);

1985

sizeof(*mod->unused_gpl_syms);

1985

mod->gpl_future_syms = (void *)sechdrs[gplfutureindex].sh_addr;

1986

mod->gpl_future_syms = (void *)sechdrs[gplfutureindex].sh_addr;

1986

if (gplfuturecrcindex)

1987

if (gplfuturecrcindex)

1987

mod->gpl_future_crcs = (void *)sechdrs[gplfuturecrcindex].sh_addr;

1988

mod->gpl_future_crcs = (void *)sechdrs[gplfuturecrcindex].sh_addr;

1988

1989

mod->unused_syms = (void *)sechdrs[unusedindex].sh_addr;

1990

mod->unused_syms = (void *)sechdrs[unusedindex].sh_addr;

1990

if (unusedcrcindex)

1991

if (unusedcrcindex)

1991

mod->unused_crcs = (void *)sechdrs[unusedcrcindex].sh_addr;

1992

mod->unused_crcs = (void *)sechdrs[unusedcrcindex].sh_addr;

1992

mod->unused_gpl_syms = (void *)sechdrs[unusedgplindex].sh_addr;

1993

mod->unused_gpl_syms = (void *)sechdrs[unusedgplindex].sh_addr;

1993

if (unusedgplcrcindex)

1994

if (unusedgplcrcindex)

1994

mod->unused_crcs = (void *)sechdrs[unusedgplcrcindex].sh_addr;

1995

mod->unused_crcs = (void *)sechdrs[unusedgplcrcindex].sh_addr;

1995

1996

#ifdef CONFIG_MODVERSIONS

1997

#ifdef CONFIG_MODVERSIONS

1997

if ((mod->num_syms && !crcindex) ||

1998

if ((mod->num_syms && !crcindex) ||

1998

(mod->num_gpl_syms && !gplcrcindex) ||

1999

(mod->num_gpl_syms && !gplcrcindex) ||

1999

(mod->num_gpl_future_syms && !gplfuturecrcindex) ||

2000

(mod->num_gpl_future_syms && !gplfuturecrcindex) ||

2000

(mod->num_unused_syms && !unusedcrcindex) ||

2001

(mod->num_unused_syms && !unusedcrcindex) ||

2001

(mod->num_unused_gpl_syms && !unusedgplcrcindex)) {

2002

(mod->num_unused_gpl_syms && !unusedgplcrcindex)) {

2002

printk(KERN_WARNING "%s: No versions for exported symbols."

2003

printk(KERN_WARNING "%s: No versions for exported symbols."

2003

" Tainting kernel.\n", mod->name);

2004

" Tainting kernel.\n", mod->name);

2004

add_taint_module(mod, TAINT_FORCED_MODULE);

2005

add_taint_module(mod, TAINT_FORCED_MODULE);

2005

}

2006

}

2006

#endif

2007

#endif

2007

markersindex = find_sec(hdr, sechdrs, secstrings, "__markers");

2008

markersindex = find_sec(hdr, sechdrs, secstrings, "__markers");

2008

markersstringsindex = find_sec(hdr, sechdrs, secstrings,

2009

markersstringsindex = find_sec(hdr, sechdrs, secstrings,

2009

"__markers_strings");

2010

"__markers_strings");

2010

2011

/* Now do relocations. */

2012

/* Now do relocations. */

2012

for (i = 1; i < hdr->e_shnum; i++) {

2013

for (i = 1; i < hdr->e_shnum; i++) {

2013

const char *strtab = (char *)sechdrs[strindex].sh_addr;

2014

const char *strtab = (char *)sechdrs[strindex].sh_addr;

2014

unsigned int info = sechdrs[i].sh_info;

2015

unsigned int info = sechdrs[i].sh_info;

2015

2016

/* Not a valid relocation section? */

2017

/* Not a valid relocation section? */

2017

if (info >= hdr->e_shnum)

2018

if (info >= hdr->e_shnum)

2018

continue;

2019

continue;

2019

2020

/* Don't bother with non-allocated sections */

2021

/* Don't bother with non-allocated sections */

2021

if (!(sechdrs[info].sh_flags & SHF_ALLOC))

2022

if (!(sechdrs[info].sh_flags & SHF_ALLOC))

2022

continue;

2023

continue;

2023

2024

if (sechdrs[i].sh_type == SHT_REL)

2025

if (sechdrs[i].sh_type == SHT_REL)

2025

err = apply_relocate(sechdrs, strtab, symindex, i,mod);

2026

err = apply_relocate(sechdrs, strtab, symindex, i,mod);

2026

else if (sechdrs[i].sh_type == SHT_RELA)

2027

else if (sechdrs[i].sh_type == SHT_RELA)

2027

err = apply_relocate_add(sechdrs, strtab, symindex, i,

2028

err = apply_relocate_add(sechdrs, strtab, symindex, i,

2028

mod);

2029

mod);

2029

if (err < 0)

2030

if (err < 0)

2030

goto cleanup;

2031

goto cleanup;

2031

}

2032

}

2032

#ifdef CONFIG_MARKERS

2033

#ifdef CONFIG_MARKERS

2033

mod->markers = (void *)sechdrs[markersindex].sh_addr;

2034

mod->markers = (void *)sechdrs[markersindex].sh_addr;

2034

mod->num_markers =

2035

mod->num_markers =

2035

sechdrs[markersindex].sh_size / sizeof(*mod->markers);

2036

sechdrs[markersindex].sh_size / sizeof(*mod->markers);

2036

#endif

2037

#endif

2037

2038

/* Find duplicate symbols */

2039

/* Find duplicate symbols */

2039

err = verify_export_symbols(mod);

2040

err = verify_export_symbols(mod);

2040

2041

if (err < 0)

2042

if (err < 0)

2042

goto cleanup;

2043

goto cleanup;

2043

2044

/* Set up and sort exception table */

2045

/* Set up and sort exception table */

2045

mod->num_exentries = sechdrs[exindex].sh_size / sizeof(*mod->extable);

2046

mod->num_exentries = sechdrs[exindex].sh_size / sizeof(*mod->extable);

2046

mod->extable = extable = (void *)sechdrs[exindex].sh_addr;

2047

mod->extable = extable = (void *)sechdrs[exindex].sh_addr;

2047

sort_extable(extable, extable + mod->num_exentries);

2048

sort_extable(extable, extable + mod->num_exentries);

2048

2049

/* Finally, copy percpu area over. */

2050

/* Finally, copy percpu area over. */

2050

percpu_modcopy(mod->percpu, (void *)sechdrs[pcpuindex].sh_addr,

2051

percpu_modcopy(mod->percpu, (void *)sechdrs[pcpuindex].sh_addr,

2051

sechdrs[pcpuindex].sh_size);

2052

sechdrs[pcpuindex].sh_size);

2052

2053

add_kallsyms(mod, sechdrs, symindex, strindex, secstrings);

2054

add_kallsyms(mod, sechdrs, symindex, strindex, secstrings);

2054

2055

#ifdef CONFIG_MARKERS

2056

#ifdef CONFIG_MARKERS

2056

if (!mod->taints)

2057

if (!mod->taints)

2057

marker_update_probe_range(mod->markers,

2058

marker_update_probe_range(mod->markers,

2058

mod->markers + mod->num_markers);

2059

mod->markers + mod->num_markers);

2059

#endif

2060

#endif

2060

err = module_finalize(hdr, sechdrs, mod);

2061

err = module_finalize(hdr, sechdrs, mod);

2061

if (err < 0)

2062

if (err < 0)

2062

goto cleanup;

2063

goto cleanup;

2063

2064

/* flush the icache in correct context */

2065

/* flush the icache in correct context */

2065

old_fs = get_fs();

2066

old_fs = get_fs();

2066

set_fs(KERNEL_DS);

2067

set_fs(KERNEL_DS);

2067

2068

/*

2069

/*

2069

* Flush the instruction cache, since we've played with text.

2070

* Flush the instruction cache, since we've played with text.

2070

* Do it before processing of module parameters, so the module

2071

* Do it before processing of module parameters, so the module

2071

* can provide parameter accessor functions of its own.

2072

* can provide parameter accessor functions of its own.

2072

*/

2073

*/

2073

if (mod->module_init)

2074

if (mod->module_init)

2074

flush_icache_range((unsigned long)mod->module_init,

2075

flush_icache_range((unsigned long)mod->module_init,

2075

(unsigned long)mod->module_init

2076

(unsigned long)mod->module_init

2076

+ mod->init_size);

2077

+ mod->init_size);

2077

flush_icache_range((unsigned long)mod->module_core,

2078

flush_icache_range((unsigned long)mod->module_core,

2078

(unsigned long)mod->module_core + mod->core_size);

2079

(unsigned long)mod->module_core + mod->core_size);

2079

2080

set_fs(old_fs);

2081

set_fs(old_fs);

2081

2082

mod->args = args;

2083

mod->args = args;

2083

if (obsparmindex)

2084

if (obsparmindex)

2084

printk(KERN_WARNING "%s: Ignoring obsolete parameters\n",

2085

printk(KERN_WARNING "%s: Ignoring obsolete parameters\n",

2085

mod->name);

2086

mod->name);

2086

2087

/* Now sew it into the lists so we can get lockdep and oops

2088

/* Now sew it into the lists so we can get lockdep and oops

2088

* info during argument parsing. Noone should access us, since

2089

* info during argument parsing. Noone should access us, since

2089

* strong_try_module_get() will fail. */

2090

* strong_try_module_get() will fail. */

2090

stop_machine_run(__link_module, mod, NR_CPUS);

2091

stop_machine_run(__link_module, mod, NR_CPUS);

2091

2092

/* Size of section 0 is 0, so this works well if no params */

2093

/* Size of section 0 is 0, so this works well if no params */

2093

err = parse_args(mod->name, mod->args,

2094

err = parse_args(mod->name, mod->args,

2094

(struct kernel_param *)

2095

(struct kernel_param *)

2095

sechdrs[setupindex].sh_addr,

2096

sechdrs[setupindex].sh_addr,

2096

sechdrs[setupindex].sh_size

2097

sechdrs[setupindex].sh_size

2097

/ sizeof(struct kernel_param),

2098

/ sizeof(struct kernel_param),

2098

NULL);

2099

NULL);

2099

if (err < 0)

2100

if (err < 0)

2100

goto unlink;

2101

goto unlink;

2101

2102

err = mod_sysfs_setup(mod,

2103

err = mod_sysfs_setup(mod,

2103

(struct kernel_param *)

2104

(struct kernel_param *)

2104

sechdrs[setupindex].sh_addr,

2105

sechdrs[setupindex].sh_addr,

2105

sechdrs[setupindex].sh_size

2106

sechdrs[setupindex].sh_size

2106

/ sizeof(struct kernel_param));

2107

/ sizeof(struct kernel_param));

2107

if (err < 0)

2108

if (err < 0)

2108

goto unlink;

2109

goto unlink;

2109

add_sect_attrs(mod, hdr->e_shnum, secstrings, sechdrs);

2110

add_sect_attrs(mod, hdr->e_shnum, secstrings, sechdrs);

2110

add_notes_attrs(mod, hdr->e_shnum, secstrings, sechdrs);

2111

add_notes_attrs(mod, hdr->e_shnum, secstrings, sechdrs);

2111

2112

/* Size of section 0 is 0, so this works well if no unwind info. */

2113

/* Size of section 0 is 0, so this works well if no unwind info. */

2113

mod->unwind_info = unwind_add_table(mod,

2114

mod->unwind_info = unwind_add_table(mod,

2114

(void *)sechdrs[unwindex].sh_addr,

2115

(void *)sechdrs[unwindex].sh_addr,

2115

sechdrs[unwindex].sh_size);

2116

sechdrs[unwindex].sh_size);

2116

2117

/* Get rid of temporary copy */

2118

/* Get rid of temporary copy */

2118

vfree(hdr);

2119

vfree(hdr);

2119

2120

/* Done! */

2121

/* Done! */

2121

return mod;

2122

return mod;

2122

2123

unlink:

2124

unlink:

2124

stop_machine_run(__unlink_module, mod, NR_CPUS);

2125

stop_machine_run(__unlink_module, mod, NR_CPUS);

2125

module_arch_cleanup(mod);

2126

module_arch_cleanup(mod);

2126

cleanup:

2127

cleanup:

2127

kobject_del(&mod->mkobj.kobj);

2128

kobject_del(&mod->mkobj.kobj);

2128

kobject_put(&mod->mkobj.kobj);

2129

kobject_put(&mod->mkobj.kobj);

2129

free_unload:

2130

free_unload:

2130

module_unload_free(mod);

2131

module_unload_free(mod);

2131

module_free(mod, mod->module_init);

2132

module_free(mod, mod->module_init);

2132

free_core:

2133

free_core:

2133

module_free(mod, mod->module_core);

2134

module_free(mod, mod->module_core);

2134

free_percpu:

2135

free_percpu:

2135

if (percpu)

2136

if (percpu)

2136

percpu_modfree(percpu);

2137

percpu_modfree(percpu);

2137

free_mod:

2138

free_mod:

2138

kfree(args);

2139

kfree(args);

2139

free_hdr:

2140

free_hdr:

2140

vfree(hdr);

2141

vfree(hdr);

2141

return ERR_PTR(err);

2142

return ERR_PTR(err);

2142

2143

truncated:

2144

truncated:

2144

printk(KERN_ERR "Module len %lu truncated\n", len);

2145

printk(KERN_ERR "Module len %lu truncated\n", len);

2145

err = -ENOEXEC;

2146

err = -ENOEXEC;

2146

goto free_hdr;

2147

goto free_hdr;

2147

}

2148

}

2148

2149

/* This is where the real work happens */

2150

/* This is where the real work happens */

2150

asmlinkage long

2151

asmlinkage long

2151

sys_init_module(void __user *umod,

2152

sys_init_module(void __user *umod,

2152

unsigned long len,

2153

unsigned long len,

2153

const char __user *uargs)

2154

const char __user *uargs)

2154

{

2155

{

2155

struct module *mod;

2156

struct module *mod;

2156

int ret = 0;

2157

int ret = 0;

2157

2158

/* Must have permission */

2159

/* Must have permission */

2159

if (!capable(CAP_SYS_MODULE))

2160

if (!capable(CAP_SYS_MODULE))

2160

return -EPERM;

2161

return -EPERM;

2161

2162

/* Only one module load at a time, please */

2163

/* Only one module load at a time, please */

2163

if (mutex_lock_interruptible(&module_mutex) != 0)

2164

if (mutex_lock_interruptible(&module_mutex) != 0)

2164

return -EINTR;

2165

return -EINTR;

2165

2166

/* Do all the hard work */

2167

/* Do all the hard work */

2167

mod = load_module(umod, len, uargs);

2168

mod = load_module(umod, len, uargs);

2168

if (IS_ERR(mod)) {

2169

if (IS_ERR(mod)) {

2169

mutex_unlock(&module_mutex);

2170

mutex_unlock(&module_mutex);

2170

return PTR_ERR(mod);

2171

return PTR_ERR(mod);

2171

}

2172

}

2172

2173

/* Drop lock so they can recurse */

2174

/* Drop lock so they can recurse */

2174

mutex_unlock(&module_mutex);

2175

mutex_unlock(&module_mutex);

2175

2176

blocking_notifier_call_chain(&module_notify_list,

2177

blocking_notifier_call_chain(&module_notify_list,

2177

MODULE_STATE_COMING, mod);

2178

MODULE_STATE_COMING, mod);

2178

2179

/* Start the module */

2180

/* Start the module */

2180

if (mod->init != NULL)

2181

if (mod->init != NULL)

2181

ret = mod->init();

2182

ret = mod->init();

2182

if (ret < 0) {

2183

if (ret < 0) {

2183

/* Init routine failed: abort. Try to protect us from

2184

/* Init routine failed: abort. Try to protect us from

2184

buggy refcounters. */

2185

buggy refcounters. */

2185

mod->state = MODULE_STATE_GOING;

2186

mod->state = MODULE_STATE_GOING;

2186

synchronize_sched();

2187

synchronize_sched();

2187

module_put(mod);

2188

module_put(mod);

2188

mutex_lock(&module_mutex);

2189

mutex_lock(&module_mutex);

2189

free_module(mod);

2190

free_module(mod);

2190

mutex_unlock(&module_mutex);

2191

mutex_unlock(&module_mutex);

2191

wake_up(&module_wq);

2192

wake_up(&module_wq);

2192

return ret;

2193

return ret;

2193

}

2194

}

2194

if (ret > 0) {

2195

if (ret > 0) {

2195

printk(KERN_WARNING "%s: '%s'->init suspiciously returned %d, "

2196

printk(KERN_WARNING "%s: '%s'->init suspiciously returned %d, "

2196

"it should follow 0/-E convention\n"

2197

"it should follow 0/-E convention\n"

2197

KERN_WARNING "%s: loading module anyway...\n",

2198

KERN_WARNING "%s: loading module anyway...\n",

2198

__func__, mod->name, ret,

2199

__func__, mod->name, ret,

2199

__func__);

2200

__func__);

2200

dump_stack();

2201

dump_stack();

2201

}

2202

}

2202

2203

/* Now it's a first class citizen! Wake up anyone waiting for it. */

2204

/* Now it's a first class citizen! Wake up anyone waiting for it. */

2204

mod->state = MODULE_STATE_LIVE;

2205

mod->state = MODULE_STATE_LIVE;

2205

wake_up(&module_wq);

2206

wake_up(&module_wq);

2206

2207

mutex_lock(&module_mutex);

2208

mutex_lock(&module_mutex);

2208

/* Drop initial reference. */

2209

/* Drop initial reference. */

2209

module_put(mod);

2210

module_put(mod);

2210

unwind_remove_table(mod->unwind_info, 1);

2211

unwind_remove_table(mod->unwind_info, 1);

2211

module_free(mod, mod->module_init);

2212

module_free(mod, mod->module_init);

2212

mod->module_init = NULL;

2213

mod->module_init = NULL;

2213

mod->init_size = 0;

2214

mod->init_size = 0;

2214

mod->init_text_size = 0;

2215

mod->init_text_size = 0;

2215

mutex_unlock(&module_mutex);

2216

mutex_unlock(&module_mutex);

2216

2217

return 0;

2218

return 0;

2218

}

2219

}

2219

2220

static inline int within(unsigned long addr, void *start, unsigned long size)

2221

static inline int within(unsigned long addr, void *start, unsigned long size)

2221

{

2222

{

2222

return ((void *)addr >= start && (void *)addr < start + size);

2223

return ((void *)addr >= start && (void *)addr < start + size);

2223

}

2224

}

2224

2225

#ifdef CONFIG_KALLSYMS

2226

#ifdef CONFIG_KALLSYMS

2226

/*

2227

/*

2227

* This ignores the intensely annoying "mapping symbols" found

2228

* This ignores the intensely annoying "mapping symbols" found

2228

* in ARM ELF files: $a, $t and $d.

2229

* in ARM ELF files: $a, $t and $d.

2229

*/

2230

*/

2230

static inline int is_arm_mapping_symbol(const char *str)

2231

static inline int is_arm_mapping_symbol(const char *str)

2231

{

2232

{

2232

return str[0] == '$' && strchr("atd", str[1])

2233

return str[0] == '$' && strchr("atd", str[1])

2233

&& (str[2] == '\0' || str[2] == '.');

2234

&& (str[2] == '\0' || str[2] == '.');

2234

}

2235

}

2235

2236

static const char *get_ksymbol(struct module *mod,

2237

static const char *get_ksymbol(struct module *mod,

2237

unsigned long addr,

2238

unsigned long addr,

2238

unsigned long *size,

2239

unsigned long *size,

2239

unsigned long *offset)

2240

unsigned long *offset)

2240

{

2241

{

2241

unsigned int i, best = 0;

2242

unsigned int i, best = 0;

2242

unsigned long nextval;

2243

unsigned long nextval;

2243

2244

/* At worse, next value is at end of module */

2245

/* At worse, next value is at end of module */

2245

if (within(addr, mod->module_init, mod->init_size))

2246

if (within(addr, mod->module_init, mod->init_size))

2246

nextval = (unsigned long)mod->module_init+mod->init_text_size;

2247

nextval = (unsigned long)mod->module_init+mod->init_text_size;

2247

else

2248

else

2248

nextval = (unsigned long)mod->module_core+mod->core_text_size;

2249

nextval = (unsigned long)mod->module_core+mod->core_text_size;

2249

2250

/* Scan for closest preceeding symbol, and next symbol. (ELF

2251

/* Scan for closest preceeding symbol, and next symbol. (ELF

2251

starts real symbols at 1). */

2252

starts real symbols at 1). */

2252

for (i = 1; i < mod->num_symtab; i++) {

2253

for (i = 1; i < mod->num_symtab; i++) {

2253

if (mod->symtab[i].st_shndx == SHN_UNDEF)

2254

if (mod->symtab[i].st_shndx == SHN_UNDEF)

2254

continue;

2255

continue;

2255

2256

/* We ignore unnamed symbols: they're uninformative

2257

/* We ignore unnamed symbols: they're uninformative

2257

* and inserted at a whim. */

2258

* and inserted at a whim. */

2258

if (mod->symtab[i].st_value <= addr

2259

if (mod->symtab[i].st_value <= addr

2259

&& mod->symtab[i].st_value > mod->symtab[best].st_value

2260

&& mod->symtab[i].st_value > mod->symtab[best].st_value

2260

&& *(mod->strtab + mod->symtab[i].st_name) != '\0'

2261

&& *(mod->strtab + mod->symtab[i].st_name) != '\0'

2261

&& !is_arm_mapping_symbol(mod->strtab + mod->symtab[i].st_name))

2262

&& !is_arm_mapping_symbol(mod->strtab + mod->symtab[i].st_name))

2262

best = i;

2263

best = i;

2263

if (mod->symtab[i].st_value > addr

2264

if (mod->symtab[i].st_value > addr

2264

&& mod->symtab[i].st_value < nextval

2265

&& mod->symtab[i].st_value < nextval

2265

&& *(mod->strtab + mod->symtab[i].st_name) != '\0'

2266

&& *(mod->strtab + mod->symtab[i].st_name) != '\0'

2266

&& !is_arm_mapping_symbol(mod->strtab + mod->symtab[i].st_name))

2267

&& !is_arm_mapping_symbol(mod->strtab + mod->symtab[i].st_name))

2267

nextval = mod->symtab[i].st_value;

2268

nextval = mod->symtab[i].st_value;

2268

}

2269

}

2269

2270

if (!best)

2271

if (!best)

2271

return NULL;

2272

return NULL;

2272

2273

if (size)

2274

if (size)

2274

*size = nextval - mod->symtab[best].st_value;

2275

*size = nextval - mod->symtab[best].st_value;

2275

if (offset)

2276

if (offset)

2276

*offset = addr - mod->symtab[best].st_value;

2277

*offset = addr - mod->symtab[best].st_value;

2277

return mod->strtab + mod->symtab[best].st_name;

2278

return mod->strtab + mod->symtab[best].st_name;

2278

}

2279

}

2279

2280

/* For kallsyms to ask for address resolution. NULL means not found. Careful

2281

/* For kallsyms to ask for address resolution. NULL means not found. Careful

2281

* not to lock to avoid deadlock on oopses, simply disable preemption. */

2282

* not to lock to avoid deadlock on oopses, simply disable preemption. */

2282

const char *module_address_lookup(unsigned long addr,

2283

const char *module_address_lookup(unsigned long addr,

2283

unsigned long *size,

2284

unsigned long *size,

2284

unsigned long *offset,

2285

unsigned long *offset,

2285

char **modname,

2286

char **modname,

2286

char *namebuf)

2287

char *namebuf)

2287

{

2288

{

2288

struct module *mod;

2289

struct module *mod;

2289

const char *ret = NULL;

2290

const char *ret = NULL;

2290

2291

preempt_disable();

2292

preempt_disable();

2292

list_for_each_entry(mod, &modules, list) {

2293

list_for_each_entry(mod, &modules, list) {

2293

if (within(addr, mod->module_init, mod->init_size)

2294

if (within(addr, mod->module_init, mod->init_size)

2294

|| within(addr, mod->module_core, mod->core_size)) {

2295

|| within(addr, mod->module_core, mod->core_size)) {

2295

if (modname)

2296

if (modname)

2296

*modname = mod->name;

2297

*modname = mod->name;

2297

ret = get_ksymbol(mod, addr, size, offset);

2298

ret = get_ksymbol(mod, addr, size, offset);

2298

break;

2299

break;

2299

}

2300

}

2300

}

2301

}

2301

/* Make a copy in here where it's safe */

2302

/* Make a copy in here where it's safe */

2302

if (ret) {

2303

if (ret) {

2303

strncpy(namebuf, ret, KSYM_NAME_LEN - 1);

2304

strncpy(namebuf, ret, KSYM_NAME_LEN - 1);

2304

ret = namebuf;

2305

ret = namebuf;

2305

}

2306

}

2306

preempt_enable();

2307

preempt_enable();

2307

return ret;

2308

return ret;

2308

}

2309

}

2309

2310

int lookup_module_symbol_name(unsigned long addr, char *symname)

2311

int lookup_module_symbol_name(unsigned long addr, char *symname)

2311

{

2312

{

2312

struct module *mod;

2313

struct module *mod;

2313

2314

preempt_disable();

2315

preempt_disable();

2315

list_for_each_entry(mod, &modules, list) {

2316

list_for_each_entry(mod, &modules, list) {

2316

if (within(addr, mod->module_init, mod->init_size) ||

2317

if (within(addr, mod->module_init, mod->init_size) ||

2317

within(addr, mod->module_core, mod->core_size)) {

2318

within(addr, mod->module_core, mod->core_size)) {

2318

const char *sym;

2319

const char *sym;

2319

2320

sym = get_ksymbol(mod, addr, NULL, NULL);

2321

sym = get_ksymbol(mod, addr, NULL, NULL);

2321

if (!sym)

2322

if (!sym)

2322

goto out;

2323

goto out;

2323

strlcpy(symname, sym, KSYM_NAME_LEN);

2324

strlcpy(symname, sym, KSYM_NAME_LEN);

2324

preempt_enable();

2325

preempt_enable();

2325

return 0;

2326

return 0;

2326

}

2327

}

2327

}

2328

}

2328

out:

2329

out:

2329

preempt_enable();

2330

preempt_enable();

2330

return -ERANGE;

2331

return -ERANGE;

2331

}

2332

}

2332

2333

int lookup_module_symbol_attrs(unsigned long addr, unsigned long *size,

2334

int lookup_module_symbol_attrs(unsigned long addr, unsigned long *size,

2334

unsigned long *offset, char *modname, char *name)

2335

unsigned long *offset, char *modname, char *name)

2335

{

2336

{

2336

struct module *mod;

2337

struct module *mod;

2337

2338

preempt_disable();

2339

preempt_disable();

2339

list_for_each_entry(mod, &modules, list) {

2340

list_for_each_entry(mod, &modules, list) {

2340

if (within(addr, mod->module_init, mod->init_size) ||

2341

if (within(addr, mod->module_init, mod->init_size) ||

2341

within(addr, mod->module_core, mod->core_size)) {

2342

within(addr, mod->module_core, mod->core_size)) {

2342

const char *sym;

2343

const char *sym;

2343

2344

sym = get_ksymbol(mod, addr, size, offset);

2345

sym = get_ksymbol(mod, addr, size, offset);

2345

if (!sym)

2346

if (!sym)

2346

goto out;

2347

goto out;

2347

if (modname)

2348

if (modname)

2348

strlcpy(modname, mod->name, MODULE_NAME_LEN);

2349

strlcpy(modname, mod->name, MODULE_NAME_LEN);

2349

if (name)

2350

if (name)

2350

strlcpy(name, sym, KSYM_NAME_LEN);

2351

strlcpy(name, sym, KSYM_NAME_LEN);

2351

preempt_enable();

2352

preempt_enable();

2352

return 0;

2353

return 0;

2353

}

2354

}

2354

}

2355

}

2355

out:

2356

out:

2356

preempt_enable();

2357

preempt_enable();

2357

return -ERANGE;

2358

return -ERANGE;

2358

}

2359

}

2359

2360

int module_get_kallsym(unsigned int symnum, unsigned long *value, char *type,

2361

int module_get_kallsym(unsigned int symnum, unsigned long *value, char *type,

2361

char *name, char *module_name, int *exported)

2362

char *name, char *module_name, int *exported)

2362

{

2363

{

2363

struct module *mod;

2364

struct module *mod;

2364

2365

preempt_disable();

2366

preempt_disable();

2366

list_for_each_entry(mod, &modules, list) {

2367

list_for_each_entry(mod, &modules, list) {

2367

if (symnum < mod->num_symtab) {

2368

if (symnum < mod->num_symtab) {

2368

*value = mod->symtab[symnum].st_value;

2369

*value = mod->symtab[symnum].st_value;

2369

*type = mod->symtab[symnum].st_info;

2370

*type = mod->symtab[symnum].st_info;

2370

strlcpy(name, mod->strtab + mod->symtab[symnum].st_name,

2371

strlcpy(name, mod->strtab + mod->symtab[symnum].st_name,

2371

KSYM_NAME_LEN);

2372

KSYM_NAME_LEN);

2372

strlcpy(module_name, mod->name, MODULE_NAME_LEN);

2373

strlcpy(module_name, mod->name, MODULE_NAME_LEN);

2373

*exported = is_exported(name, mod);

2374

*exported = is_exported(name, mod);

2374

preempt_enable();

2375

preempt_enable();

2375

return 0;

2376

return 0;

2376

}

2377

}

2377

symnum -= mod->num_symtab;

2378

symnum -= mod->num_symtab;

2378

}

2379

}

2379

preempt_enable();

2380

preempt_enable();

2380

return -ERANGE;

2381

return -ERANGE;

2381

}

2382

}

2382

2383

static unsigned long mod_find_symname(struct module *mod, const char *name)

2384

static unsigned long mod_find_symname(struct module *mod, const char *name)

2384

{

2385

{

2385

unsigned int i;

2386

unsigned int i;

2386

2387

for (i = 0; i < mod->num_symtab; i++)

2388

for (i = 0; i < mod->num_symtab; i++)

2388

if (strcmp(name, mod->strtab+mod->symtab[i].st_name) == 0 &&

2389

if (strcmp(name, mod->strtab+mod->symtab[i].st_name) == 0 &&

2389

mod->symtab[i].st_info != 'U')

2390

mod->symtab[i].st_info != 'U')

2390

return mod->symtab[i].st_value;

2391

return mod->symtab[i].st_value;

2391

return 0;

2392

return 0;

2392

}

2393

}

2393

2394

/* Look for this name: can be of form module:name. */

2395

/* Look for this name: can be of form module:name. */

2395

unsigned long module_kallsyms_lookup_name(const char *name)

2396

unsigned long module_kallsyms_lookup_name(const char *name)

2396

{

2397

{

2397

struct module *mod;

2398

struct module *mod;

2398

char *colon;

2399

char *colon;

2399

unsigned long ret = 0;

2400

unsigned long ret = 0;

2400

2401

/* Don't lock: we're in enough trouble already. */

2402

/* Don't lock: we're in enough trouble already. */

2402

preempt_disable();

2403

preempt_disable();

2403

if ((colon = strchr(name, ':')) != NULL) {

2404

if ((colon = strchr(name, ':')) != NULL) {

2404

*colon = '\0';

2405

*colon = '\0';

2405

if ((mod = find_module(name)) != NULL)

2406

if ((mod = find_module(name)) != NULL)

2406

ret = mod_find_symname(mod, colon+1);

2407

ret = mod_find_symname(mod, colon+1);

2407

*colon = ':';

2408

*colon = ':';

2408

} else {

2409

} else {

2409

list_for_each_entry(mod, &modules, list)

2410

list_for_each_entry(mod, &modules, list)

2410

if ((ret = mod_find_symname(mod, name)) != 0)

2411

if ((ret = mod_find_symname(mod, name)) != 0)

2411

break;

2412

break;

2412

}

2413

}

2413

preempt_enable();

2414

preempt_enable();

2414

return ret;

2415

return ret;

2415

}

2416

}

2416

#endif /* CONFIG_KALLSYMS */

2417

#endif /* CONFIG_KALLSYMS */

2417

2418

/* Called by the /proc file system to return a list of modules. */

2419

/* Called by the /proc file system to return a list of modules. */

2419

static void *m_start(struct seq_file *m, loff_t *pos)

2420

static void *m_start(struct seq_file *m, loff_t *pos)

2420

{

2421

{

2421

mutex_lock(&module_mutex);

2422

mutex_lock(&module_mutex);

2422

return seq_list_start(&modules, *pos);

2423

return seq_list_start(&modules, *pos);

2423

}

2424

}

2424

2425

static void *m_next(struct seq_file *m, void *p, loff_t *pos)

2426

static void *m_next(struct seq_file *m, void *p, loff_t *pos)

2426

{

2427

{

2427

return seq_list_next(p, &modules, pos);

2428

return seq_list_next(p, &modules, pos);

2428

}

2429

}

2429

2430

static void m_stop(struct seq_file *m, void *p)

2431

static void m_stop(struct seq_file *m, void *p)

2431

{

2432

{

2432

mutex_unlock(&module_mutex);

2433

mutex_unlock(&module_mutex);

2433

}

2434

}

2434

2435

static char *module_flags(struct module *mod, char *buf)

2436

static char *module_flags(struct module *mod, char *buf)

2436

{

2437

{

2437

int bx = 0;

2438

int bx = 0;

2438

2439

if (mod->taints ||

2440

if (mod->taints ||

2440

mod->state == MODULE_STATE_GOING ||

2441

mod->state == MODULE_STATE_GOING ||

2441

mod->state == MODULE_STATE_COMING) {

2442

mod->state == MODULE_STATE_COMING) {

2442

buf[bx++] = '(';

2443

buf[bx++] = '(';

2443

if (mod->taints & TAINT_PROPRIETARY_MODULE)

2444

if (mod->taints & TAINT_PROPRIETARY_MODULE)

2444

buf[bx++] = 'P';

2445

buf[bx++] = 'P';

2445

if (mod->taints & TAINT_FORCED_MODULE)

2446

if (mod->taints & TAINT_FORCED_MODULE)

2446

buf[bx++] = 'F';

2447

buf[bx++] = 'F';

2447

/*

2448

/*

2448

* TAINT_FORCED_RMMOD: could be added.

2449

* TAINT_FORCED_RMMOD: could be added.

2449

* TAINT_UNSAFE_SMP, TAINT_MACHINE_CHECK, TAINT_BAD_PAGE don't

2450

* TAINT_UNSAFE_SMP, TAINT_MACHINE_CHECK, TAINT_BAD_PAGE don't

2450

* apply to modules.

2451

* apply to modules.

2451

*/

2452

*/

2452

2453

/* Show a - for module-is-being-unloaded */

2454

/* Show a - for module-is-being-unloaded */

2454

if (mod->state == MODULE_STATE_GOING)

2455

if (mod->state == MODULE_STATE_GOING)

2455

buf[bx++] = '-';

2456

buf[bx++] = '-';

2456

/* Show a + for module-is-being-loaded */

2457

/* Show a + for module-is-being-loaded */

2457

if (mod->state == MODULE_STATE_COMING)

2458

if (mod->state == MODULE_STATE_COMING)

2458

buf[bx++] = '+';

2459

buf[bx++] = '+';

2459

buf[bx++] = ')';

2460

buf[bx++] = ')';

2460

}

2461

}

2461

buf[bx] = '\0';

2462

buf[bx] = '\0';

2462

2463

return buf;

2464

return buf;

2464

}

2465

}

2465

2466

static int m_show(struct seq_file *m, void *p)

2467

static int m_show(struct seq_file *m, void *p)

2467

{

2468

{

2468

struct module *mod = list_entry(p, struct module, list);

2469

struct module *mod = list_entry(p, struct module, list);

2469

char buf[8];

2470

char buf[8];

2470

2471

seq_printf(m, "%s %lu",

2472

seq_printf(m, "%s %lu",

2472

mod->name, mod->init_size + mod->core_size);

2473

mod->name, mod->init_size + mod->core_size);

2473

print_unload_info(m, mod);

2474

print_unload_info(m, mod);

2474

2475

/* Informative for users. */

2476

/* Informative for users. */

2476

seq_printf(m, " %s",

2477

seq_printf(m, " %s",

2477

mod->state == MODULE_STATE_GOING ? "Unloading":

2478

mod->state == MODULE_STATE_GOING ? "Unloading":

2478

mod->state == MODULE_STATE_COMING ? "Loading":

2479

mod->state == MODULE_STATE_COMING ? "Loading":

2479

"Live");

2480

"Live");

2480

/* Used by oprofile and other similar tools. */

2481

/* Used by oprofile and other similar tools. */

2481

seq_printf(m, " 0x%p", mod->module_core);

2482

seq_printf(m, " 0x%p", mod->module_core);

2482

2483

/* Taints info */

2484

/* Taints info */

2484

if (mod->taints)

2485

if (mod->taints)

2485

seq_printf(m, " %s", module_flags(mod, buf));

2486

seq_printf(m, " %s", module_flags(mod, buf));

2486

2487

seq_printf(m, "\n");

2488

seq_printf(m, "\n");

2488

return 0;

2489

return 0;

2489

}

2490

}

2490

2491

/* Format: modulename size refcount deps address

2492

/* Format: modulename size refcount deps address

2492

2493

Where refcount is a number or -, and deps is a comma-separated list

2494

Where refcount is a number or -, and deps is a comma-separated list

2494

of depends or -.

2495

of depends or -.

2495

*/

2496

*/

2496

const struct seq_operations modules_op = {

2497

const struct seq_operations modules_op = {

2497

.start = m_start,

2498

.start = m_start,

2498

.next = m_next,

2499

.next = m_next,

2499

.stop = m_stop,

2500

.stop = m_stop,

2500

.show = m_show

2501

.show = m_show

2501

};

2502

};

2502

2503

/* Given an address, look for it in the module exception tables. */

2504

/* Given an address, look for it in the module exception tables. */

2504

const struct exception_table_entry *search_module_extables(unsigned long addr)

2505

const struct exception_table_entry *search_module_extables(unsigned long addr)

2505

{

2506

{

2506

const struct exception_table_entry *e = NULL;

2507

const struct exception_table_entry *e = NULL;

2507

struct module *mod;

2508

struct module *mod;

2508

2509

preempt_disable();

2510

preempt_disable();

2510

list_for_each_entry(mod, &modules, list) {

2511

list_for_each_entry(mod, &modules, list) {

2511

if (mod->num_exentries == 0)

2512

if (mod->num_exentries == 0)

2512

continue;

2513

continue;

2513

2514

e = search_extable(mod->extable,

2515

e = search_extable(mod->extable,

2515

mod->extable + mod->num_exentries - 1,

2516

mod->extable + mod->num_exentries - 1,

2516

addr);

2517

addr);

2517

if (e)

2518

if (e)

2518

break;

2519

break;

2519

}

2520

}

2520

preempt_enable();

2521

preempt_enable();

2521

2522

/* Now, if we found one, we are running inside it now, hence

2523

/* Now, if we found one, we are running inside it now, hence

2523

we cannot unload the module, hence no refcnt needed. */

2524

we cannot unload the module, hence no refcnt needed. */

2524

return e;

2525

return e;

2525

}

2526

}

2526

2527

/*

2528

/*

2528

* Is this a valid module address?

2529

* Is this a valid module address?

2529

*/

2530

*/

2530

int is_module_address(unsigned long addr)

2531

int is_module_address(unsigned long addr)

2531

{

2532

{

2532

struct module *mod;

2533

struct module *mod;

2533

2534

preempt_disable();

2535

preempt_disable();

2535

2536

list_for_each_entry(mod, &modules, list) {

2537

list_for_each_entry(mod, &modules, list) {

2537

if (within(addr, mod->module_core, mod->core_size)) {

2538

if (within(addr, mod->module_core, mod->core_size)) {

2538

preempt_enable();

2539

preempt_enable();

2539

return 1;

2540

return 1;

2540

}

2541

}

2541

}

2542

}

2542

2543

preempt_enable();

2544

preempt_enable();

2544

2545

return 0;

2546

return 0;

2546

}

2547

}

2547

2548

2549

/* Is this a valid kernel address? */

2550

/* Is this a valid kernel address? */

2550

struct module *__module_text_address(unsigned long addr)

2551

struct module *__module_text_address(unsigned long addr)

2551

{

2552

{

2552

struct module *mod;

2553

struct module *mod;

2553

2554

list_for_each_entry(mod, &modules, list)

2555

list_for_each_entry(mod, &modules, list)

2555

if (within(addr, mod->module_init, mod->init_text_size)

2556

if (within(addr, mod->module_init, mod->init_text_size)

2556

|| within(addr, mod->module_core, mod->core_text_size))

2557

|| within(addr, mod->module_core, mod->core_text_size))

2557

return mod;

2558

return mod;

2558

return NULL;

2559

return NULL;

2559

}

2560

}

2560

2561

struct module *module_text_address(unsigned long addr)

2562

struct module *module_text_address(unsigned long addr)

2562

{

2563

{

2563

struct module *mod;

2564

struct module *mod;

2564

2565

preempt_disable();

2566

preempt_disable();

2566

mod = __module_text_address(addr);

2567

mod = __module_text_address(addr);

2567

preempt_enable();

2568

preempt_enable();

2568

2569

return mod;

2570

return mod;

2570

}

2571

}

2571

2572

/* Don't grab lock, we're oopsing. */

2573

/* Don't grab lock, we're oopsing. */

2573

void print_modules(void)

2574

void print_modules(void)

2574

{

2575

{

2575

struct module *mod;

2576

struct module *mod;

2576

char buf[8];

2577

char buf[8];

2577

2578

printk("Modules linked in:");

2579

printk("Modules linked in:");

2579

list_for_each_entry(mod, &modules, list)

2580

list_for_each_entry(mod, &modules, list)

2580

printk(" %s%s", mod->name, module_flags(mod, buf));

2581

printk(" %s%s", mod->name, module_flags(mod, buf));

2581

if (last_unloaded_module[0])

2582

if (last_unloaded_module[0])

2582

printk(" [last unloaded: %s]", last_unloaded_module);

2583

printk(" [last unloaded: %s]", last_unloaded_module);

2583

printk("\n");

2584

printk("\n");

2584

}

2585

}

2585

2586

#ifdef CONFIG_MODVERSIONS

2587

#ifdef CONFIG_MODVERSIONS

2587

/* Generate the signature for struct module here, too, for modversions. */

2588

/* Generate the signature for struct module here, too, for modversions. */

2588

void struct_module(struct module *mod) { return; }

2589

void struct_module(struct module *mod) { return; }

2589

EXPORT_SYMBOL(struct_module);

2590

EXPORT_SYMBOL(struct_module);

2590

#endif

2591

#endif

2591

2592

#ifdef CONFIG_MARKERS

2593

#ifdef CONFIG_MARKERS

2593

void module_update_markers(void)

2594

void module_update_markers(void)

2594

{

2595

{

2595

struct module *mod;

2596

struct module *mod;

2596

2597

mutex_lock(&module_mutex);

2598

mutex_lock(&module_mutex);

2598

list_for_each_entry(mod, &modules, list)

2599

list_for_each_entry(mod, &modules, list)

2599

if (!mod->taints)

2600

if (!mod->taints)

2600

marker_update_probe_range(mod->markers,

2601

marker_update_probe_range(mod->markers,

2601

mod->markers + mod->num_markers);

2602

mod->markers + mod->num_markers);

2602

mutex_unlock(&module_mutex);

2603

mutex_unlock(&module_mutex);

2603

}

2604

}

2604

#endif

2605

#endif

2605

2606

GITLAB

module: reduce module image and resident size

 /*
    Copyright (C) 2002 Richard Henderson
    Copyright (C) 2001 Rusty Russell, 2002 Rusty Russell IBM.
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
     the Free Software Foundation; either version 2 of the License, or
     (at your option) any later version.
     This program is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     GNU General Public License for more details.
     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
 #include <linux/module.h>
 #include <linux/moduleloader.h>
 #include <linux/init.h>
 #include <linux/kallsyms.h>
 #include <linux/sysfs.h>
 #include <linux/kernel.h>
 #include <linux/slab.h>
 #include <linux/vmalloc.h>
 #include <linux/elf.h>
 #include <linux/seq_file.h>
 #include <linux/syscalls.h>
 #include <linux/fcntl.h>
 #include <linux/rcupdate.h>
 #include <linux/capability.h>
 #include <linux/cpu.h>
 #include <linux/moduleparam.h>
 #include <linux/errno.h>
 #include <linux/err.h>
 #include <linux/vermagic.h>
 #include <linux/notifier.h>
 #include <linux/sched.h>
 #include <linux/stop_machine.h>
 #include <linux/device.h>
 #include <linux/string.h>
 #include <linux/mutex.h>
 #include <linux/unwind.h>
 #include <asm/uaccess.h>
 #include <asm/cacheflush.h>
 #include <linux/license.h>
 #include <asm/sections.h>
 #if 0
 #define DEBUGP printk
 #else
 #define DEBUGP(fmt , a...)
 #endif
 #ifndef ARCH_SHF_SMALL
 #define ARCH_SHF_SMALL 0
 #endif
 /* If this is set, the section belongs in the init part of the module */
 #define INIT_OFFSET_MASK (1UL << (BITS_PER_LONG-1))
 /* List of modules, protected by module_mutex or preempt_disable
  * (add/delete uses stop_machine). */
 static DEFINE_MUTEX(module_mutex);
 static LIST_HEAD(modules);
 /* Waiting for a module to finish initializing? */
 static DECLARE_WAIT_QUEUE_HEAD(module_wq);
 static BLOCKING_NOTIFIER_HEAD(module_notify_list);
 int register_module_notifier(struct notifier_block * nb)
 {
 	return blocking_notifier_chain_register(&module_notify_list, nb);
 }
 EXPORT_SYMBOL(register_module_notifier);
 int unregister_module_notifier(struct notifier_block * nb)
 {
 	return blocking_notifier_chain_unregister(&module_notify_list, nb);
 }
 EXPORT_SYMBOL(unregister_module_notifier);
 /* We require a truly strong try_module_get(): 0 means failure due to
    ongoing or failed initialization etc. */
 static inline int strong_try_module_get(struct module *mod)
 {
 	if (mod && mod->state == MODULE_STATE_COMING)
 		return -EBUSY;
 	if (try_module_get(mod))
 		return 0;
 	else
 		return -ENOENT;
 }
 static inline void add_taint_module(struct module *mod, unsigned flag)
 {
 	add_taint(flag);
 	mod->taints |= flag;
 }
 /*
  * A thread that wants to hold a reference to a module only while it
  * is running can call this to safely exit.  nfsd and lockd use this.
  */
 void __module_put_and_exit(struct module *mod, long code)
 {
 	module_put(mod);
 	do_exit(code);
 }
 EXPORT_SYMBOL(__module_put_and_exit);
 /* Find a module section: 0 means not found. */
 static unsigned int find_sec(Elf_Ehdr *hdr,
 			     Elf_Shdr *sechdrs,
 			     const char *secstrings,
 			     const char *name)
 {
 	unsigned int i;
 	for (i = 1; i < hdr->e_shnum; i++)
 		/* Alloc bit cleared means "ignore it." */
 		if ((sechdrs[i].sh_flags & SHF_ALLOC)
 		    && strcmp(secstrings+sechdrs[i].sh_name, name) == 0)
 			return i;
 	return 0;
 }
 /* Provided by the linker */
 extern const struct kernel_symbol __start___ksymtab[];
 extern const struct kernel_symbol __stop___ksymtab[];
 extern const struct kernel_symbol __start___ksymtab_gpl[];
 extern const struct kernel_symbol __stop___ksymtab_gpl[];
 extern const struct kernel_symbol __start___ksymtab_gpl_future[];
 extern const struct kernel_symbol __stop___ksymtab_gpl_future[];
 extern const struct kernel_symbol __start___ksymtab_unused[];
 extern const struct kernel_symbol __stop___ksymtab_unused[];
 extern const struct kernel_symbol __start___ksymtab_unused_gpl[];
 extern const struct kernel_symbol __stop___ksymtab_unused_gpl[];
 extern const struct kernel_symbol __start___ksymtab_gpl_future[];
 extern const struct kernel_symbol __stop___ksymtab_gpl_future[];
 extern const unsigned long __start___kcrctab[];
 extern const unsigned long __start___kcrctab_gpl[];
 extern const unsigned long __start___kcrctab_gpl_future[];
 extern const unsigned long __start___kcrctab_unused[];
 extern const unsigned long __start___kcrctab_unused_gpl[];
 #ifndef CONFIG_MODVERSIONS
 #define symversion(base, idx) NULL
 #else
 #define symversion(base, idx) ((base != NULL) ? ((base) + (idx)) : NULL)
 #endif
 /* lookup symbol in given range of kernel_symbols */
 static const struct kernel_symbol *lookup_symbol(const char *name,
 	const struct kernel_symbol *start,
 	const struct kernel_symbol *stop)
 {
 	const struct kernel_symbol *ks = start;
 	for (; ks < stop; ks++)
 		if (strcmp(ks->name, name) == 0)
 			return ks;
 	return NULL;
 }
 static void printk_unused_warning(const char *name)
 {
 	printk(KERN_WARNING "Symbol %s is marked as UNUSED, "
 		"however this module is using it.\n", name);
 	printk(KERN_WARNING "This symbol will go away in the future.\n");
 	printk(KERN_WARNING "Please evalute if this is the right api to use, "
 		"and if it really is, submit a report the linux kernel "
 		"mailinglist together with submitting your code for "
 		"inclusion.\n");
 }
 /* Find a symbol, return value, crc and module which owns it */
 static unsigned long __find_symbol(const char *name,
 				   struct module **owner,
 				   const unsigned long **crc,
 				   int gplok)
 {
 	struct module *mod;
 	const struct kernel_symbol *ks;
 	/* Core kernel first. */
 	*owner = NULL;
 	ks = lookup_symbol(name, __start___ksymtab, __stop___ksymtab);
 	if (ks) {
 		*crc = symversion(__start___kcrctab, (ks - __start___ksymtab));
 		return ks->value;
 	}
 	if (gplok) {
 		ks = lookup_symbol(name, __start___ksymtab_gpl,
 					 __stop___ksymtab_gpl);
 		if (ks) {
 			*crc = symversion(__start___kcrctab_gpl,
 					  (ks - __start___ksymtab_gpl));
 			return ks->value;
 		}
 	}
 	ks = lookup_symbol(name, __start___ksymtab_gpl_future,
 				 __stop___ksymtab_gpl_future);
 	if (ks) {
 		if (!gplok) {
 			printk(KERN_WARNING "Symbol %s is being used "
 			       "by a non-GPL module, which will not "
 			       "be allowed in the future\n", name);
 			printk(KERN_WARNING "Please see the file "
 			       "Documentation/feature-removal-schedule.txt "
 			       "in the kernel source tree for more "
 			       "details.\n");
 		}
 		*crc = symversion(__start___kcrctab_gpl_future,
 				  (ks - __start___ksymtab_gpl_future));
 		return ks->value;
 	}
 	ks = lookup_symbol(name, __start___ksymtab_unused,
 				 __stop___ksymtab_unused);
 	if (ks) {
 		printk_unused_warning(name);
 		*crc = symversion(__start___kcrctab_unused,
 				  (ks - __start___ksymtab_unused));
 		return ks->value;
 	}
 	if (gplok)
 		ks = lookup_symbol(name, __start___ksymtab_unused_gpl,
 				 __stop___ksymtab_unused_gpl);
 	if (ks) {
 		printk_unused_warning(name);
 		*crc = symversion(__start___kcrctab_unused_gpl,
 				  (ks - __start___ksymtab_unused_gpl));
 		return ks->value;
 	}
 	/* Now try modules. */
 	list_for_each_entry(mod, &modules, list) {
 		*owner = mod;
 		ks = lookup_symbol(name, mod->syms, mod->syms + mod->num_syms);
 		if (ks) {
 			*crc = symversion(mod->crcs, (ks - mod->syms));
 			return ks->value;
 		}
 		if (gplok) {
 			ks = lookup_symbol(name, mod->gpl_syms,
 					   mod->gpl_syms + mod->num_gpl_syms);
 			if (ks) {
 				*crc = symversion(mod->gpl_crcs,
 						  (ks - mod->gpl_syms));
 				return ks->value;
 			}
 		}
 		ks = lookup_symbol(name, mod->unused_syms, mod->unused_syms + mod->num_unused_syms);
 		if (ks) {
 			printk_unused_warning(name);
 			*crc = symversion(mod->unused_crcs, (ks - mod->unused_syms));
 			return ks->value;
 		}
 		if (gplok) {
 			ks = lookup_symbol(name, mod->unused_gpl_syms,
 					   mod->unused_gpl_syms + mod->num_unused_gpl_syms);
 			if (ks) {
 				printk_unused_warning(name);
 				*crc = symversion(mod->unused_gpl_crcs,
 						  (ks - mod->unused_gpl_syms));
 				return ks->value;
 			}
 		}
 		ks = lookup_symbol(name, mod->gpl_future_syms,
 				   (mod->gpl_future_syms +
 				    mod->num_gpl_future_syms));
 		if (ks) {
 			if (!gplok) {
 				printk(KERN_WARNING "Symbol %s is being used "
 				       "by a non-GPL module, which will not "
 				       "be allowed in the future\n", name);
 				printk(KERN_WARNING "Please see the file "
 				       "Documentation/feature-removal-schedule.txt "
 				       "in the kernel source tree for more "
 				       "details.\n");
 			}
 			*crc = symversion(mod->gpl_future_crcs,
 					  (ks - mod->gpl_future_syms));
 			return ks->value;
 		}
 	}
 	DEBUGP("Failed to find symbol %s\n", name);
 	return -ENOENT;
 }
 /* Search for module by name: must hold module_mutex. */
 static struct module *find_module(const char *name)
 {
 	struct module *mod;
 	list_for_each_entry(mod, &modules, list) {
 		if (strcmp(mod->name, name) == 0)
 			return mod;
 	}
 	return NULL;
 }
 #ifdef CONFIG_SMP
 /* Number of blocks used and allocated. */
 static unsigned int pcpu_num_used, pcpu_num_allocated;
 /* Size of each block.  -ve means used. */
 static int *pcpu_size;
 static int split_block(unsigned int i, unsigned short size)
 {
 	/* Reallocation required? */
 	if (pcpu_num_used + 1 > pcpu_num_allocated) {
 		int *new;
 		new = krealloc(pcpu_size, sizeof(new[0])*pcpu_num_allocated*2,
 			       GFP_KERNEL);
 		if (!new)
 			return 0;
 		pcpu_num_allocated *= 2;
 		pcpu_size = new;
 	}
 	/* Insert a new subblock */
 	memmove(&pcpu_size[i+1], &pcpu_size[i],
 		sizeof(pcpu_size[0]) * (pcpu_num_used - i));
 	pcpu_num_used++;
 	pcpu_size[i+1] -= size;
 	pcpu_size[i] = size;
 	return 1;
 }
 static inline unsigned int block_size(int val)
 {
 	if (val < 0)
 		return -val;
 	return val;
 }
 static void *percpu_modalloc(unsigned long size, unsigned long align,
 			     const char *name)
 {
 	unsigned long extra;
 	unsigned int i;
 	void *ptr;
 	if (align > PAGE_SIZE) {
 		printk(KERN_WARNING "%s: per-cpu alignment %li > %li\n",
 		       name, align, PAGE_SIZE);
 		align = PAGE_SIZE;
 	}
 	ptr = __per_cpu_start;
 	for (i = 0; i < pcpu_num_used; ptr += block_size(pcpu_size[i]), i++) {
 		/* Extra for alignment requirement. */
 		extra = ALIGN((unsigned long)ptr, align) - (unsigned long)ptr;
 		BUG_ON(i == 0 && extra != 0);
 		if (pcpu_size[i] < 0 || pcpu_size[i] < extra + size)
 			continue;
 		/* Transfer extra to previous block. */
 		if (pcpu_size[i-1] < 0)
 			pcpu_size[i-1] -= extra;
 		else
 			pcpu_size[i-1] += extra;
 		pcpu_size[i] -= extra;
 		ptr += extra;
 		/* Split block if warranted */
 		if (pcpu_size[i] - size > sizeof(unsigned long))
 			if (!split_block(i, size))
 				return NULL;
 		/* Mark allocated */
 		pcpu_size[i] = -pcpu_size[i];
 		return ptr;
 	}
 	printk(KERN_WARNING "Could not allocate %lu bytes percpu data\n",
 	       size);
 	return NULL;
 }
 static void percpu_modfree(void *freeme)
 {
 	unsigned int i;
 	void *ptr = __per_cpu_start + block_size(pcpu_size[0]);
 	/* First entry is core kernel percpu data. */
 	for (i = 1; i < pcpu_num_used; ptr += block_size(pcpu_size[i]), i++) {
 		if (ptr == freeme) {
 			pcpu_size[i] = -pcpu_size[i];
 			goto free;
 		}
 	}
 	BUG();
  free:
 	/* Merge with previous? */
 	if (pcpu_size[i-1] >= 0) {
 		pcpu_size[i-1] += pcpu_size[i];
 		pcpu_num_used--;
 		memmove(&pcpu_size[i], &pcpu_size[i+1],
 			(pcpu_num_used - i) * sizeof(pcpu_size[0]));
 		i--;
 	}
 	/* Merge with next? */
 	if (i+1 < pcpu_num_used && pcpu_size[i+1] >= 0) {
 		pcpu_size[i] += pcpu_size[i+1];
 		pcpu_num_used--;
 		memmove(&pcpu_size[i+1], &pcpu_size[i+2],
 			(pcpu_num_used - (i+1)) * sizeof(pcpu_size[0]));
 	}
 }
 static unsigned int find_pcpusec(Elf_Ehdr *hdr,
 				 Elf_Shdr *sechdrs,
 				 const char *secstrings)
 {
 	return find_sec(hdr, sechdrs, secstrings, ".data.percpu");
 }
 static void percpu_modcopy(void *pcpudest, const void *from, unsigned long size)
 {
 	int cpu;
 	for_each_possible_cpu(cpu)
 		memcpy(pcpudest + per_cpu_offset(cpu), from, size);
 }
 static int percpu_modinit(void)
 {
 	pcpu_num_used = 2;
 	pcpu_num_allocated = 2;
 	pcpu_size = kmalloc(sizeof(pcpu_size[0]) * pcpu_num_allocated,
 			    GFP_KERNEL);
 	/* Static in-kernel percpu data (used). */
 	pcpu_size[0] = -(__per_cpu_end-__per_cpu_start);
 	/* Free room. */
 	pcpu_size[1] = PERCPU_ENOUGH_ROOM + pcpu_size[0];
 	if (pcpu_size[1] < 0) {
 		printk(KERN_ERR "No per-cpu room for modules.\n");
 		pcpu_num_used = 1;
 	}
 	return 0;
 }
 __initcall(percpu_modinit);
 #else /* ... !CONFIG_SMP */
 static inline void *percpu_modalloc(unsigned long size, unsigned long align,
 				    const char *name)
 {
 	return NULL;
 }
 static inline void percpu_modfree(void *pcpuptr)
 {
 	BUG();
 }
 static inline unsigned int find_pcpusec(Elf_Ehdr *hdr,
 					Elf_Shdr *sechdrs,
 					const char *secstrings)
 {
 	return 0;
 }
 static inline void percpu_modcopy(void *pcpudst, const void *src,
 				  unsigned long size)
 {
 	/* pcpusec should be 0, and size of that section should be 0. */
 	BUG_ON(size != 0);
 }
 #endif /* CONFIG_SMP */
 #define MODINFO_ATTR(field)	\
 static void setup_modinfo_##field(struct module *mod, const char *s)  \
 {                                                                     \
 	mod->field = kstrdup(s, GFP_KERNEL);                          \
 }                                                                     \
 static ssize_t show_modinfo_##field(struct module_attribute *mattr,   \
 	                struct module *mod, char *buffer)             \
 {                                                                     \
 	return sprintf(buffer, "%s\n", mod->field);                   \
 }                                                                     \
 static int modinfo_##field##_exists(struct module *mod)               \
 {                                                                     \
 	return mod->field != NULL;                                    \
 }                                                                     \
 static void free_modinfo_##field(struct module *mod)                  \
 {                                                                     \
 	kfree(mod->field);                                            \
 	mod->field = NULL;                                            \
 }                                                                     \
 static struct module_attribute modinfo_##field = {                    \
 	.attr = { .name = __stringify(field), .mode = 0444 },         \
 	.show = show_modinfo_##field,                                 \
 	.setup = setup_modinfo_##field,                               \
 	.test = modinfo_##field##_exists,                             \
 	.free = free_modinfo_##field,                                 \
 };
 MODINFO_ATTR(version);
 MODINFO_ATTR(srcversion);
 static char last_unloaded_module[MODULE_NAME_LEN+1];
 #ifdef CONFIG_MODULE_UNLOAD
 /* Init the unload section of the module. */
 static void module_unload_init(struct module *mod)
 {
 	unsigned int i;
 	INIT_LIST_HEAD(&mod->modules_which_use_me);
 	for (i = 0; i < NR_CPUS; i++)
 		local_set(&mod->ref[i].count, 0);
 	/* Hold reference count during initialization. */
 	local_set(&mod->ref[raw_smp_processor_id()].count, 1);
 	/* Backwards compatibility macros put refcount during init. */
 	mod->waiter = current;
 }
 /* modules using other modules */
 struct module_use
 {
 	struct list_head list;
 	struct module *module_which_uses;
 };
 /* Does a already use b? */
 static int already_uses(struct module *a, struct module *b)
 {
 	struct module_use *use;
 	list_for_each_entry(use, &b->modules_which_use_me, list) {
 		if (use->module_which_uses == a) {
 			DEBUGP("%s uses %s!\n", a->name, b->name);
 			return 1;
 		}
 	}
 	DEBUGP("%s does not use %s!\n", a->name, b->name);
 	return 0;
 }
 /* Module a uses b */
 static int use_module(struct module *a, struct module *b)
 {
 	struct module_use *use;
 	int no_warn, err;
 	if (b == NULL || already_uses(a, b)) return 1;
 	/* If we're interrupted or time out, we fail. */
 	if (wait_event_interruptible_timeout(
 		    module_wq, (err = strong_try_module_get(b)) != -EBUSY,
 		    30 * HZ) <= 0) {
 		printk("%s: gave up waiting for init of module %s.\n",
 		       a->name, b->name);
 		return 0;
 	}
 	/* If strong_try_module_get() returned a different error, we fail. */
 	if (err)
 		return 0;
 	DEBUGP("Allocating new usage for %s.\n", a->name);
 	use = kmalloc(sizeof(*use), GFP_ATOMIC);
 	if (!use) {
 		printk("%s: out of memory loading\n", a->name);
 		module_put(b);
 		return 0;
 	}
 	use->module_which_uses = a;
 	list_add(&use->list, &b->modules_which_use_me);
 	no_warn = sysfs_create_link(b->holders_dir, &a->mkobj.kobj, a->name);
 	return 1;
 }
 /* Clear the unload stuff of the module. */
 static void module_unload_free(struct module *mod)
 {
 	struct module *i;
 	list_for_each_entry(i, &modules, list) {
 		struct module_use *use;
 		list_for_each_entry(use, &i->modules_which_use_me, list) {
 			if (use->module_which_uses == mod) {
 				DEBUGP("%s unusing %s\n", mod->name, i->name);
 				module_put(i);
 				list_del(&use->list);
 				kfree(use);
 				sysfs_remove_link(i->holders_dir, mod->name);
 				/* There can be at most one match. */
 				break;
 			}
 		}
 	}
 }
 #ifdef CONFIG_MODULE_FORCE_UNLOAD
 static inline int try_force_unload(unsigned int flags)
 {
 	int ret = (flags & O_TRUNC);
 	if (ret)
 		add_taint(TAINT_FORCED_RMMOD);
 	return ret;
 }
 #else
 static inline int try_force_unload(unsigned int flags)
 {
 	return 0;
 }
 #endif /* CONFIG_MODULE_FORCE_UNLOAD */
 struct stopref
 {
 	struct module *mod;
 	int flags;
 	int *forced;
 };
 /* Whole machine is stopped with interrupts off when this runs. */
 static int __try_stop_module(void *_sref)
 {
 	struct stopref *sref = _sref;
 	/* If it's not unused, quit unless we are told to block. */
 	if ((sref->flags & O_NONBLOCK) && module_refcount(sref->mod) != 0) {
 		if (!(*sref->forced = try_force_unload(sref->flags)))
 			return -EWOULDBLOCK;
 	}
 	/* Mark it as dying. */
 	sref->mod->state = MODULE_STATE_GOING;
 	return 0;
 }
 static int try_stop_module(struct module *mod, int flags, int *forced)
 {
 	struct stopref sref = { mod, flags, forced };
 	return stop_machine_run(__try_stop_module, &sref, NR_CPUS);
 }
 unsigned int module_refcount(struct module *mod)
 {
 	unsigned int i, total = 0;
 	for (i = 0; i < NR_CPUS; i++)
 		total += local_read(&mod->ref[i].count);
 	return total;
 }
 EXPORT_SYMBOL(module_refcount);
 /* This exists whether we can unload or not */
 static void free_module(struct module *mod);
 static void wait_for_zero_refcount(struct module *mod)
 {
 	/* Since we might sleep for some time, release the mutex first */
 	mutex_unlock(&module_mutex);
 	for (;;) {
 		DEBUGP("Looking at refcount...\n");
 		set_current_state(TASK_UNINTERRUPTIBLE);
 		if (module_refcount(mod) == 0)
 			break;
 		schedule();
 	}
 	current->state = TASK_RUNNING;
 	mutex_lock(&module_mutex);
 }
 asmlinkage long
 sys_delete_module(const char __user *name_user, unsigned int flags)
 {
 	struct module *mod;
 	char name[MODULE_NAME_LEN];
 	int ret, forced = 0;
 	if (!capable(CAP_SYS_MODULE))
 		return -EPERM;
 	if (strncpy_from_user(name, name_user, MODULE_NAME_LEN-1) < 0)
 		return -EFAULT;
 	name[MODULE_NAME_LEN-1] = '\0';
 	if (mutex_lock_interruptible(&module_mutex) != 0)
 		return -EINTR;
 	mod = find_module(name);
 	if (!mod) {
 		ret = -ENOENT;
 		goto out;
 	}
 	if (!list_empty(&mod->modules_which_use_me)) {
 		/* Other modules depend on us: get rid of them first. */
 		ret = -EWOULDBLOCK;
 		goto out;
 	}
 	/* Doing init or already dying? */
 	if (mod->state != MODULE_STATE_LIVE) {
 		/* FIXME: if (force), slam module count and wake up
                    waiter --RR */
 		DEBUGP("%s already dying\n", mod->name);
 		ret = -EBUSY;
 		goto out;
 	}
 	/* If it has an init func, it must have an exit func to unload */
 	if (mod->init && !mod->exit) {
 		forced = try_force_unload(flags);
 		if (!forced) {
 			/* This module can't be removed */
 			ret = -EBUSY;
 			goto out;
 		}
 	}
 	/* Set this up before setting mod->state */
 	mod->waiter = current;
 	/* Stop the machine so refcounts can't move and disable module. */
 	ret = try_stop_module(mod, flags, &forced);
 	if (ret != 0)
 		goto out;
 	/* Never wait if forced. */
 	if (!forced && module_refcount(mod) != 0)
 		wait_for_zero_refcount(mod);
 	/* Final destruction now noone is using it. */
 	if (mod->exit != NULL) {
 		mutex_unlock(&module_mutex);
 		mod->exit();
 		mutex_lock(&module_mutex);
 	}
 	/* Store the name of the last unloaded module for diagnostic purposes */
 	strlcpy(last_unloaded_module, mod->name, sizeof(last_unloaded_module));
 	free_module(mod);
  out:
 	mutex_unlock(&module_mutex);
 	return ret;
 }
 static void print_unload_info(struct seq_file *m, struct module *mod)
 {
 	struct module_use *use;
 	int printed_something = 0;
 	seq_printf(m, " %u ", module_refcount(mod));
 	/* Always include a trailing , so userspace can differentiate
            between this and the old multi-field proc format. */
 	list_for_each_entry(use, &mod->modules_which_use_me, list) {
 		printed_something = 1;
 		seq_printf(m, "%s,", use->module_which_uses->name);
 	}
 	if (mod->init != NULL && mod->exit == NULL) {
 		printed_something = 1;
 		seq_printf(m, "[permanent],");
 	}
 	if (!printed_something)
 		seq_printf(m, "-");
 }
 void __symbol_put(const char *symbol)
 {
 	struct module *owner;
 	const unsigned long *crc;
 	preempt_disable();
 	if (IS_ERR_VALUE(__find_symbol(symbol, &owner, &crc, 1)))
 		BUG();
 	module_put(owner);
 	preempt_enable();
 }
 EXPORT_SYMBOL(__symbol_put);
 void symbol_put_addr(void *addr)
 {
 	struct module *modaddr;
 	if (core_kernel_text((unsigned long)addr))
 		return;
 	if (!(modaddr = module_text_address((unsigned long)addr)))
 		BUG();
 	module_put(modaddr);
 }
 EXPORT_SYMBOL_GPL(symbol_put_addr);
 static ssize_t show_refcnt(struct module_attribute *mattr,
 			   struct module *mod, char *buffer)
 {
 	return sprintf(buffer, "%u\n", module_refcount(mod));
 }
 static struct module_attribute refcnt = {
 	.attr = { .name = "refcnt", .mode = 0444 },
 	.show = show_refcnt,
 };
 void module_put(struct module *module)
 {
 	if (module) {
 		unsigned int cpu = get_cpu();
 		local_dec(&module->ref[cpu].count);
 		/* Maybe they're waiting for us to drop reference? */
 		if (unlikely(!module_is_live(module)))
 			wake_up_process(module->waiter);
 		put_cpu();
 	}
 }
 EXPORT_SYMBOL(module_put);
 #else /* !CONFIG_MODULE_UNLOAD */
 static void print_unload_info(struct seq_file *m, struct module *mod)
 {
 	/* We don't know the usage count, or what modules are using. */
 	seq_printf(m, " - -");
 }
 static inline void module_unload_free(struct module *mod)
 {
 }
 static inline int use_module(struct module *a, struct module *b)
 {
 	return strong_try_module_get(b) == 0;
 }
 static inline void module_unload_init(struct module *mod)
 {
 }
 #endif /* CONFIG_MODULE_UNLOAD */
 static ssize_t show_initstate(struct module_attribute *mattr,
 			   struct module *mod, char *buffer)
 {
 	const char *state = "unknown";
 	switch (mod->state) {
 	case MODULE_STATE_LIVE:
 		state = "live";
 		break;
 	case MODULE_STATE_COMING:
 		state = "coming";
 		break;
 	case MODULE_STATE_GOING:
 		state = "going";
 		break;
 	}
 	return sprintf(buffer, "%s\n", state);
 }
 static struct module_attribute initstate = {
 	.attr = { .name = "initstate", .mode = 0444 },
 	.show = show_initstate,
 };
 static struct module_attribute *modinfo_attrs[] = {
 	&modinfo_version,
 	&modinfo_srcversion,
 	&initstate,
 #ifdef CONFIG_MODULE_UNLOAD
 	&refcnt,
 #endif
 	NULL,
 };
 static const char vermagic[] = VERMAGIC_STRING;
 #ifdef CONFIG_MODVERSIONS
 static int check_version(Elf_Shdr *sechdrs,
 			 unsigned int versindex,
 			 const char *symname,
 			 struct module *mod,
 			 const unsigned long *crc)
 {
 	unsigned int i, num_versions;
 	struct modversion_info *versions;
 	/* Exporting module didn't supply crcs?  OK, we're already tainted. */
 	if (!crc)
 		return 1;
 	versions = (void *) sechdrs[versindex].sh_addr;
 	num_versions = sechdrs[versindex].sh_size
 		/ sizeof(struct modversion_info);
 	for (i = 0; i < num_versions; i++) {
 		if (strcmp(versions[i].name, symname) != 0)
 			continue;
 		if (versions[i].crc == *crc)
 			return 1;
 		printk("%s: disagrees about version of symbol %s\n",
 		       mod->name, symname);
 		DEBUGP("Found checksum %lX vs module %lX\n",
 		       *crc, versions[i].crc);
 		return 0;
 	}
 	/* Not in module's version table.  OK, but that taints the kernel. */
 	if (!(tainted & TAINT_FORCED_MODULE))
 		printk("%s: no version for \"%s\" found: kernel tainted.\n",
 		       mod->name, symname);
 	add_taint_module(mod, TAINT_FORCED_MODULE);
 	return 1;
 }
 static inline int check_modstruct_version(Elf_Shdr *sechdrs,
 					  unsigned int versindex,
 					  struct module *mod)
 {
 	const unsigned long *crc;
 	struct module *owner;
 	if (IS_ERR_VALUE(__find_symbol("struct_module",
 						&owner, &crc, 1)))
 		BUG();
 	return check_version(sechdrs, versindex, "struct_module", mod,
 			     crc);
 }
 /* First part is kernel version, which we ignore. */
 static inline int same_magic(const char *amagic, const char *bmagic)
 {
 	amagic += strcspn(amagic, " ");
 	bmagic += strcspn(bmagic, " ");
 	return strcmp(amagic, bmagic) == 0;
 }
 #else
 static inline int check_version(Elf_Shdr *sechdrs,
 				unsigned int versindex,
 				const char *symname,
 				struct module *mod,
 				const unsigned long *crc)
 {
 	return 1;
 }
 static inline int check_modstruct_version(Elf_Shdr *sechdrs,
 					  unsigned int versindex,
 					  struct module *mod)
 {
 	return 1;
 }
 static inline int same_magic(const char *amagic, const char *bmagic)
 {
 	return strcmp(amagic, bmagic) == 0;
 }
 #endif /* CONFIG_MODVERSIONS */
 /* Resolve a symbol for this module.  I.e. if we find one, record usage.
    Must be holding module_mutex. */
 static unsigned long resolve_symbol(Elf_Shdr *sechdrs,
 				    unsigned int versindex,
 				    const char *name,
 				    struct module *mod)
 {
 	struct module *owner;
 	unsigned long ret;
 	const unsigned long *crc;
 	ret = __find_symbol(name, &owner, &crc,
 			!(mod->taints & TAINT_PROPRIETARY_MODULE));
 	if (!IS_ERR_VALUE(ret)) {
 		/* use_module can fail due to OOM,
 		   or module initialization or unloading */
 		if (!check_version(sechdrs, versindex, name, mod, crc) ||
 		    !use_module(mod, owner))
 			ret = -EINVAL;
 	}
 	return ret;
 }
 /*
  * /sys/module/foo/sections stuff
  * J. Corbet <corbet@lwn.net>
  */
 #if defined(CONFIG_KALLSYMS) && defined(CONFIG_SYSFS)
 struct module_sect_attr
 {
 	struct module_attribute mattr;
 	char *name;
 	unsigned long address;
 };
 struct module_sect_attrs
 {
 	struct attribute_group grp;
 	unsigned int nsections;
 	struct module_sect_attr attrs[0];
 };
 static ssize_t module_sect_show(struct module_attribute *mattr,
 				struct module *mod, char *buf)
 {
 	struct module_sect_attr *sattr =
 		container_of(mattr, struct module_sect_attr, mattr);
 	return sprintf(buf, "0x%lx\n", sattr->address);
 }
 static void free_sect_attrs(struct module_sect_attrs *sect_attrs)
 {
 	unsigned int section;
 	for (section = 0; section < sect_attrs->nsections; section++)
 		kfree(sect_attrs->attrs[section].name);
 	kfree(sect_attrs);
 }
 static void add_sect_attrs(struct module *mod, unsigned int nsect,
 		char *secstrings, Elf_Shdr *sechdrs)
 {
 	unsigned int nloaded = 0, i, size[2];
 	struct module_sect_attrs *sect_attrs;
 	struct module_sect_attr *sattr;
 	struct attribute **gattr;
 	/* Count loaded sections and allocate structures */
 	for (i = 0; i < nsect; i++)
 		if (sechdrs[i].sh_flags & SHF_ALLOC)
 			nloaded++;
 	size[0] = ALIGN(sizeof(*sect_attrs)
 			+ nloaded * sizeof(sect_attrs->attrs[0]),
 			sizeof(sect_attrs->grp.attrs[0]));
 	size[1] = (nloaded + 1) * sizeof(sect_attrs->grp.attrs[0]);
 	sect_attrs = kzalloc(size[0] + size[1], GFP_KERNEL);
 	if (sect_attrs == NULL)
 		return;
 	/* Setup section attributes. */
 	sect_attrs->grp.name = "sections";
 	sect_attrs->grp.attrs = (void *)sect_attrs + size[0];
 	sect_attrs->nsections = 0;
 	sattr = &sect_attrs->attrs[0];
 	gattr = &sect_attrs->grp.attrs[0];
 	for (i = 0; i < nsect; i++) {
 		if (! (sechdrs[i].sh_flags & SHF_ALLOC))
 			continue;
 		sattr->address = sechdrs[i].sh_addr;
 		sattr->name = kstrdup(secstrings + sechdrs[i].sh_name,
 					GFP_KERNEL);
 		if (sattr->name == NULL)
 			goto out;
 		sect_attrs->nsections++;
 		sattr->mattr.show = module_sect_show;
 		sattr->mattr.store = NULL;
 		sattr->mattr.attr.name = sattr->name;
 		sattr->mattr.attr.mode = S_IRUGO;
 		*(gattr++) = &(sattr++)->mattr.attr;
 	}
 	*gattr = NULL;
 	if (sysfs_create_group(&mod->mkobj.kobj, &sect_attrs->grp))
 		goto out;
 	mod->sect_attrs = sect_attrs;
 	return;
   out:
 	free_sect_attrs(sect_attrs);
 }
 static void remove_sect_attrs(struct module *mod)
 {
 	if (mod->sect_attrs) {
 		sysfs_remove_group(&mod->mkobj.kobj,
 				   &mod->sect_attrs->grp);
 		/* We are positive that no one is using any sect attrs
 		 * at this point.  Deallocate immediately. */
 		free_sect_attrs(mod->sect_attrs);
 		mod->sect_attrs = NULL;
 	}
 }
 /*
  * /sys/module/foo/notes/.section.name gives contents of SHT_NOTE sections.
  */
 struct module_notes_attrs {
 	struct kobject *dir;
 	unsigned int notes;
 	struct bin_attribute attrs[0];
 };
 static ssize_t module_notes_read(struct kobject *kobj,
 				 struct bin_attribute *bin_attr,
 				 char *buf, loff_t pos, size_t count)
 {
 	/*
 	 * The caller checked the pos and count against our size.
 	 */
 	memcpy(buf, bin_attr->private + pos, count);
 	return count;
 }
 static void free_notes_attrs(struct module_notes_attrs *notes_attrs,
 			     unsigned int i)
 {
 	if (notes_attrs->dir) {
 		while (i-- > 0)
 			sysfs_remove_bin_file(notes_attrs->dir,
 					      &notes_attrs->attrs[i]);
 		kobject_del(notes_attrs->dir);
 	}
 	kfree(notes_attrs);
 }
 static void add_notes_attrs(struct module *mod, unsigned int nsect,
 			    char *secstrings, Elf_Shdr *sechdrs)
 {
 	unsigned int notes, loaded, i;
 	struct module_notes_attrs *notes_attrs;
 	struct bin_attribute *nattr;
 	/* Count notes sections and allocate structures.  */
 	notes = 0;
 	for (i = 0; i < nsect; i++)
 		if ((sechdrs[i].sh_flags & SHF_ALLOC) &&
 		    (sechdrs[i].sh_type == SHT_NOTE))
 			++notes;
 	if (notes == 0)
 		return;
 	notes_attrs = kzalloc(sizeof(*notes_attrs)
 			      + notes * sizeof(notes_attrs->attrs[0]),
 			      GFP_KERNEL);
 	if (notes_attrs == NULL)
 		return;
 	notes_attrs->notes = notes;
 	nattr = &notes_attrs->attrs[0];
 	for (loaded = i = 0; i < nsect; ++i) {
 		if (!(sechdrs[i].sh_flags & SHF_ALLOC))
 			continue;
 		if (sechdrs[i].sh_type == SHT_NOTE) {
 			nattr->attr.name = mod->sect_attrs->attrs[loaded].name;
 			nattr->attr.mode = S_IRUGO;
 			nattr->size = sechdrs[i].sh_size;
 			nattr->private = (void *) sechdrs[i].sh_addr;
 			nattr->read = module_notes_read;
 			++nattr;
 		}
 		++loaded;
 	}
 	notes_attrs->dir = kobject_create_and_add("notes", &mod->mkobj.kobj);
 	if (!notes_attrs->dir)
 		goto out;
 	for (i = 0; i < notes; ++i)
 		if (sysfs_create_bin_file(notes_attrs->dir,
 					  &notes_attrs->attrs[i]))
 			goto out;
 	mod->notes_attrs = notes_attrs;
 	return;
   out:
 	free_notes_attrs(notes_attrs, i);
 }
 static void remove_notes_attrs(struct module *mod)
 {
 	if (mod->notes_attrs)
 		free_notes_attrs(mod->notes_attrs, mod->notes_attrs->notes);
 }
 #else
 static inline void add_sect_attrs(struct module *mod, unsigned int nsect,
 		char *sectstrings, Elf_Shdr *sechdrs)
 {
 }
 static inline void remove_sect_attrs(struct module *mod)
 {
 }
 static inline void add_notes_attrs(struct module *mod, unsigned int nsect,
 				   char *sectstrings, Elf_Shdr *sechdrs)
 {
 }
 static inline void remove_notes_attrs(struct module *mod)
 {
 }
 #endif
 #ifdef CONFIG_SYSFS
 int module_add_modinfo_attrs(struct module *mod)
 {
 	struct module_attribute *attr;
 	struct module_attribute *temp_attr;
 	int error = 0;
 	int i;
 	mod->modinfo_attrs = kzalloc((sizeof(struct module_attribute) *
 					(ARRAY_SIZE(modinfo_attrs) + 1)),
 					GFP_KERNEL);
 	if (!mod->modinfo_attrs)
 		return -ENOMEM;
 	temp_attr = mod->modinfo_attrs;
 	for (i = 0; (attr = modinfo_attrs[i]) && !error; i++) {
 		if (!attr->test ||
 		    (attr->test && attr->test(mod))) {
 			memcpy(temp_attr, attr, sizeof(*temp_attr));
 			error = sysfs_create_file(&mod->mkobj.kobj,&temp_attr->attr);
 			++temp_attr;
 		}
 	}
 	return error;
 }
 void module_remove_modinfo_attrs(struct module *mod)
 {
 	struct module_attribute *attr;
 	int i;
 	for (i = 0; (attr = &mod->modinfo_attrs[i]); i++) {
 		/* pick a field to test for end of list */
 		if (!attr->attr.name)
 			break;
 		sysfs_remove_file(&mod->mkobj.kobj,&attr->attr);
 		if (attr->free)
 			attr->free(mod);
 	}
 	kfree(mod->modinfo_attrs);
 }
 int mod_sysfs_init(struct module *mod)
 {
 	int err;
 	struct kobject *kobj;
 	if (!module_sysfs_initialized) {
 		printk(KERN_ERR "%s: module sysfs not initialized\n",
 		       mod->name);
 		err = -EINVAL;
 		goto out;
 	}
 	kobj = kset_find_obj(module_kset, mod->name);
 	if (kobj) {
 		printk(KERN_ERR "%s: module is already loaded\n", mod->name);
 		kobject_put(kobj);
 		err = -EINVAL;
 		goto out;
 	}
 	mod->mkobj.mod = mod;
 	memset(&mod->mkobj.kobj, 0, sizeof(mod->mkobj.kobj));
 	mod->mkobj.kobj.kset = module_kset;
 	err = kobject_init_and_add(&mod->mkobj.kobj, &module_ktype, NULL,
 				   "%s", mod->name);
 	if (err)
 		kobject_put(&mod->mkobj.kobj);
 	/* delay uevent until full sysfs population */
 out:
 	return err;
 }
 int mod_sysfs_setup(struct module *mod,
 			   struct kernel_param *kparam,
 			   unsigned int num_params)
 {
 	int err;
 	mod->holders_dir = kobject_create_and_add("holders", &mod->mkobj.kobj);
 	if (!mod->holders_dir) {
 		err = -ENOMEM;
 		goto out_unreg;
 	}
 	err = module_param_sysfs_setup(mod, kparam, num_params);
 	if (err)
 		goto out_unreg_holders;
 	err = module_add_modinfo_attrs(mod);
 	if (err)
 		goto out_unreg_param;
 	kobject_uevent(&mod->mkobj.kobj, KOBJ_ADD);
 	return 0;
 out_unreg_param:
 	module_param_sysfs_remove(mod);
 out_unreg_holders:
 	kobject_put(mod->holders_dir);
 out_unreg:
 	kobject_put(&mod->mkobj.kobj);
 	return err;
 }
 #endif
 static void mod_kobject_remove(struct module *mod)
 {
 	module_remove_modinfo_attrs(mod);
 	module_param_sysfs_remove(mod);
 	kobject_put(mod->mkobj.drivers_dir);
 	kobject_put(mod->holders_dir);
 	kobject_put(&mod->mkobj.kobj);
 }
 /*
  * link the module with the whole machine is stopped with interrupts off
  * - this defends against kallsyms not taking locks
  */
 static int __link_module(void *_mod)
 {
 	struct module *mod = _mod;
 	list_add(&mod->list, &modules);
 	return 0;
 }
 /*
  * unlink the module with the whole machine is stopped with interrupts off
  * - this defends against kallsyms not taking locks
  */
 static int __unlink_module(void *_mod)
 {
 	struct module *mod = _mod;
 	list_del(&mod->list);
 	return 0;
 }
 /* Free a module, remove from lists, etc (must hold module_mutex). */
 static void free_module(struct module *mod)
 {
 	/* Delete from various lists */
 	stop_machine_run(__unlink_module, mod, NR_CPUS);
 	remove_notes_attrs(mod);
 	remove_sect_attrs(mod);
 	mod_kobject_remove(mod);
 	unwind_remove_table(mod->unwind_info, 0);
 	/* Arch-specific cleanup. */
 	module_arch_cleanup(mod);
 	/* Module unload stuff */
 	module_unload_free(mod);
 	/* This may be NULL, but that's OK */
 	module_free(mod, mod->module_init);
 	kfree(mod->args);
 	if (mod->percpu)
 		percpu_modfree(mod->percpu);
 	/* Free lock-classes: */
 	lockdep_free_key_range(mod->module_core, mod->core_size);
 	/* Finally, free the core (containing the module structure) */
 	module_free(mod, mod->module_core);
 }
 void *__symbol_get(const char *symbol)
 {
 	struct module *owner;
 	unsigned long value;
 	const unsigned long *crc;
 	preempt_disable();
 	value = __find_symbol(symbol, &owner, &crc, 1);
 	if (IS_ERR_VALUE(value))
 		value = 0;
 	else if (strong_try_module_get(owner))
 		value = 0;
 	preempt_enable();
 	return (void *)value;
 }
 EXPORT_SYMBOL_GPL(__symbol_get);
 /*
  * Ensure that an exported symbol [global namespace] does not already exist
  * in the kernel or in some other module's exported symbol table.
  */
 static int verify_export_symbols(struct module *mod)
 {
 	const char *name = NULL;
 	unsigned long i, ret = 0;
 	struct module *owner;
 	const unsigned long *crc;
 	for (i = 0; i < mod->num_syms; i++)
 		if (!IS_ERR_VALUE(__find_symbol(mod->syms[i].name,
 							&owner, &crc, 1))) {
 			name = mod->syms[i].name;
 			ret = -ENOEXEC;
 			goto dup;
 		}
 	for (i = 0; i < mod->num_gpl_syms; i++)
 		if (!IS_ERR_VALUE(__find_symbol(mod->gpl_syms[i].name,
 							&owner, &crc, 1))) {
 			name = mod->gpl_syms[i].name;
 			ret = -ENOEXEC;
 			goto dup;
 		}
 dup:
 	if (ret)
 		printk(KERN_ERR "%s: exports duplicate symbol %s (owned by %s)\n",
 			mod->name, name, module_name(owner));
 	return ret;
 }
 /* Change all symbols so that st_value encodes the pointer directly. */
 static int simplify_symbols(Elf_Shdr *sechdrs,
 			    unsigned int symindex,
 			    const char *strtab,
 			    unsigned int versindex,
 			    unsigned int pcpuindex,
 			    struct module *mod)
 {
 	Elf_Sym *sym = (void *)sechdrs[symindex].sh_addr;
 	unsigned long secbase;
 	unsigned int i, n = sechdrs[symindex].sh_size / sizeof(Elf_Sym);
 	int ret = 0;
 	for (i = 1; i < n; i++) {
 		switch (sym[i].st_shndx) {
 		case SHN_COMMON:
 			/* We compiled with -fno-common.  These are not
 			   supposed to happen.  */
 			DEBUGP("Common symbol: %s\n", strtab + sym[i].st_name);
 			printk("%s: please compile with -fno-common\n",
 			       mod->name);
 			ret = -ENOEXEC;
 			break;
 		case SHN_ABS:
 			/* Don't need to do anything */
 			DEBUGP("Absolute symbol: 0x%08lx\n",
 			       (long)sym[i].st_value);
 			break;
 		case SHN_UNDEF:
 			sym[i].st_value
 			  = resolve_symbol(sechdrs, versindex,
 					   strtab + sym[i].st_name, mod);
 			/* Ok if resolved.  */
 			if (!IS_ERR_VALUE(sym[i].st_value))
 				break;
 			/* Ok if weak.  */
 			if (ELF_ST_BIND(sym[i].st_info) == STB_WEAK)
 				break;
 			printk(KERN_WARNING "%s: Unknown symbol %s\n",
 			       mod->name, strtab + sym[i].st_name);
 			ret = -ENOENT;
 			break;
 		default:
 			/* Divert to percpu allocation if a percpu var. */
 			if (sym[i].st_shndx == pcpuindex)
 				secbase = (unsigned long)mod->percpu;
 			else
 				secbase = sechdrs[sym[i].st_shndx].sh_addr;
 			sym[i].st_value += secbase;
 			break;
 		}
 	}
 	return ret;
 }
 /* Update size with this section: return offset. */
 static long get_offset(unsigned long *size, Elf_Shdr *sechdr)
 {
 	long ret;
 	ret = ALIGN(*size, sechdr->sh_addralign ?: 1);
 	*size = ret + sechdr->sh_size;
 	return ret;
 }
 /* Lay out the SHF_ALLOC sections in a way not dissimilar to how ld
    might -- code, read-only data, read-write data, small data.  Tally
    sizes, and place the offsets into sh_entsize fields: high bit means it
    belongs in init. */
 static void layout_sections(struct module *mod,
 			    const Elf_Ehdr *hdr,
 			    Elf_Shdr *sechdrs,
 			    const char *secstrings)
 {
 	static unsigned long const masks[][2] = {
 		/* NOTE: all executable code must be the first section
 		 * in this array; otherwise modify the text_size
 		 * finder in the two loops below */
 		{ SHF_EXECINSTR | SHF_ALLOC, ARCH_SHF_SMALL },
 		{ SHF_ALLOC, SHF_WRITE | ARCH_SHF_SMALL },
 		{ SHF_WRITE | SHF_ALLOC, ARCH_SHF_SMALL },
 		{ ARCH_SHF_SMALL | SHF_ALLOC, 0 }
 	};
 	unsigned int m, i;
 	for (i = 0; i < hdr->e_shnum; i++)
 		sechdrs[i].sh_entsize = ~0UL;
 	DEBUGP("Core section allocation order:\n");
 	for (m = 0; m < ARRAY_SIZE(masks); ++m) {
 		for (i = 0; i < hdr->e_shnum; ++i) {
 			Elf_Shdr *s = &sechdrs[i];
 			if ((s->sh_flags & masks[m][0]) != masks[m][0]
 			    || (s->sh_flags & masks[m][1])
 			    || s->sh_entsize != ~0UL
 			    || strncmp(secstrings + s->sh_name,
 				       ".init", 5) == 0)
 				continue;
 			s->sh_entsize = get_offset(&mod->core_size, s);
 			DEBUGP("\t%s\n", secstrings + s->sh_name);
 		}
 		if (m == 0)
 			mod->core_text_size = mod->core_size;
 	}
 	DEBUGP("Init section allocation order:\n");
 	for (m = 0; m < ARRAY_SIZE(masks); ++m) {
 		for (i = 0; i < hdr->e_shnum; ++i) {
 			Elf_Shdr *s = &sechdrs[i];
 			if ((s->sh_flags & masks[m][0]) != masks[m][0]
 			    || (s->sh_flags & masks[m][1])
 			    || s->sh_entsize != ~0UL
 			    || strncmp(secstrings + s->sh_name,
 				       ".init", 5) != 0)
 				continue;
 			s->sh_entsize = (get_offset(&mod->init_size, s)
 					 | INIT_OFFSET_MASK);
 			DEBUGP("\t%s\n", secstrings + s->sh_name);
 		}
 		if (m == 0)
 			mod->init_text_size = mod->init_size;
 	}
 }
 static void set_license(struct module *mod, const char *license)
 {
 	if (!license)
 		license = "unspecified";
 	if (!license_is_gpl_compatible(license)) {
 		if (!(tainted & TAINT_PROPRIETARY_MODULE))
 			printk(KERN_WARNING "%s: module license '%s' taints "
 				"kernel.\n", mod->name, license);
 		add_taint_module(mod, TAINT_PROPRIETARY_MODULE);
 	}
 }
 /* Parse tag=value strings from .modinfo section */
 static char *next_string(char *string, unsigned long *secsize)
 {
 	/* Skip non-zero chars */
 	while (string[0]) {
 		string++;
 		if ((*secsize)-- <= 1)
 			return NULL;
 	}
 	/* Skip any zero padding. */
 	while (!string[0]) {
 		string++;
 		if ((*secsize)-- <= 1)
 			return NULL;
 	}
 	return string;
 }
 static char *get_modinfo(Elf_Shdr *sechdrs,
 			 unsigned int info,
 			 const char *tag)
 {
 	char *p;
 	unsigned int taglen = strlen(tag);
 	unsigned long size = sechdrs[info].sh_size;
 	for (p = (char *)sechdrs[info].sh_addr; p; p = next_string(p, &size)) {
 		if (strncmp(p, tag, taglen) == 0 && p[taglen] == '=')
 			return p + taglen + 1;
 	}
 	return NULL;
 }
 static void setup_modinfo(struct module *mod, Elf_Shdr *sechdrs,
 			  unsigned int infoindex)
 {
 	struct module_attribute *attr;
 	int i;
 	for (i = 0; (attr = modinfo_attrs[i]); i++) {
 		if (attr->setup)
 			attr->setup(mod,
 				    get_modinfo(sechdrs,
 						infoindex,
 						attr->attr.name));
 	}
 }
 #ifdef CONFIG_KALLSYMS
 static int is_exported(const char *name, const struct module *mod)
 {
 	if (!mod && lookup_symbol(name, __start___ksymtab, __stop___ksymtab))
 		return 1;
 	else
 		if (mod && lookup_symbol(name, mod->syms, mod->syms + mod->num_syms))
 			return 1;
 		else
 			return 0;
 }
 /* As per nm */
 static char elf_type(const Elf_Sym *sym,
 		     Elf_Shdr *sechdrs,
 		     const char *secstrings,
 		     struct module *mod)
 {
 	if (ELF_ST_BIND(sym->st_info) == STB_WEAK) {
 		if (ELF_ST_TYPE(sym->st_info) == STT_OBJECT)
 			return 'v';
 		else
 			return 'w';
 	}
 	if (sym->st_shndx == SHN_UNDEF)
 		return 'U';
 	if (sym->st_shndx == SHN_ABS)
 		return 'a';
 	if (sym->st_shndx >= SHN_LORESERVE)
 		return '?';
 	if (sechdrs[sym->st_shndx].sh_flags & SHF_EXECINSTR)
 		return 't';
 	if (sechdrs[sym->st_shndx].sh_flags & SHF_ALLOC
 	    && sechdrs[sym->st_shndx].sh_type != SHT_NOBITS) {
 		if (!(sechdrs[sym->st_shndx].sh_flags & SHF_WRITE))
 			return 'r';
 		else if (sechdrs[sym->st_shndx].sh_flags & ARCH_SHF_SMALL)
 			return 'g';
 		else
 			return 'd';
 	}
 	if (sechdrs[sym->st_shndx].sh_type == SHT_NOBITS) {
 		if (sechdrs[sym->st_shndx].sh_flags & ARCH_SHF_SMALL)
 			return 's';
 		else
 			return 'b';
 	}
 	if (strncmp(secstrings + sechdrs[sym->st_shndx].sh_name,
 		    ".debug", strlen(".debug")) == 0)
 		return 'n';
 	return '?';
 }
 static void add_kallsyms(struct module *mod,
 			 Elf_Shdr *sechdrs,
 			 unsigned int symindex,
 			 unsigned int strindex,
 			 const char *secstrings)
 {
 	unsigned int i;
 	mod->symtab = (void *)sechdrs[symindex].sh_addr;
 	mod->num_symtab = sechdrs[symindex].sh_size / sizeof(Elf_Sym);
 	mod->strtab = (void *)sechdrs[strindex].sh_addr;
 	/* Set types up while we still have access to sections. */
 	for (i = 0; i < mod->num_symtab; i++)
 		mod->symtab[i].st_info
 			= elf_type(&mod->symtab[i], sechdrs, secstrings, mod);
 }
 #else
 static inline void add_kallsyms(struct module *mod,
 				Elf_Shdr *sechdrs,
 				unsigned int symindex,
 				unsigned int strindex,
 				const char *secstrings)
 {
 }
 #endif /* CONFIG_KALLSYMS */
 /* Allocate and load the module: note that size of section 0 is always
    zero, and we rely on this for optional sections. */
 static struct module *load_module(void __user *umod,
 				  unsigned long len,
 				  const char __user *uargs)
 {
 	Elf_Ehdr *hdr;
 	Elf_Shdr *sechdrs;
 	char *secstrings, *args, *modmagic, *strtab = NULL;
 	unsigned int i;
 	unsigned int symindex = 0;
 	unsigned int strindex = 0;
 	unsigned int setupindex;
 	unsigned int exindex;
 	unsigned int exportindex;
 	unsigned int modindex;
 	unsigned int obsparmindex;
 	unsigned int infoindex;
 	unsigned int gplindex;
 	unsigned int crcindex;
 	unsigned int gplcrcindex;
 	unsigned int versindex;
 	unsigned int pcpuindex;
 	unsigned int gplfutureindex;
 	unsigned int gplfuturecrcindex;
 	unsigned int unwindex = 0;
 	unsigned int unusedindex;
 	unsigned int unusedcrcindex;
 	unsigned int unusedgplindex;
 	unsigned int unusedgplcrcindex;
 	unsigned int markersindex;
 	unsigned int markersstringsindex;
 	struct module *mod;
 	long err = 0;
 	void *percpu = NULL, *ptr = NULL; /* Stops spurious gcc warning */
 	struct exception_table_entry *extable;
 	mm_segment_t old_fs;
 	DEBUGP("load_module: umod=%p, len=%lu, uargs=%p\n",
 	       umod, len, uargs);
 	if (len < sizeof(*hdr))
 		return ERR_PTR(-ENOEXEC);
 	/* Suck in entire file: we'll want most of it. */
 	/* vmalloc barfs on "unusual" numbers.  Check here */
 	if (len > 64 * 1024 * 1024 || (hdr = vmalloc(len)) == NULL)
 		return ERR_PTR(-ENOMEM);
 	if (copy_from_user(hdr, umod, len) != 0) {
 		err = -EFAULT;
 		goto free_hdr;
 	}
 	/* Sanity checks against insmoding binaries or wrong arch,
            weird elf version */
 	if (memcmp(hdr->e_ident, ELFMAG, 4) != 0
 	    || hdr->e_type != ET_REL
 	    || !elf_check_arch(hdr)
 	    || hdr->e_shentsize != sizeof(*sechdrs)) {
 		err = -ENOEXEC;
 		goto free_hdr;
 	}
 	if (len < hdr->e_shoff + hdr->e_shnum * sizeof(Elf_Shdr))
 		goto truncated;
 	/* Convenience variables */
 	sechdrs = (void *)hdr + hdr->e_shoff;
 	secstrings = (void *)hdr + sechdrs[hdr->e_shstrndx].sh_offset;
 	sechdrs[0].sh_addr = 0;
 	for (i = 1; i < hdr->e_shnum; i++) {
 		if (sechdrs[i].sh_type != SHT_NOBITS
 		    && len < sechdrs[i].sh_offset + sechdrs[i].sh_size)
 			goto truncated;
 		/* Mark all sections sh_addr with their address in the
 		   temporary image. */
 		sechdrs[i].sh_addr = (size_t)hdr + sechdrs[i].sh_offset;
 		/* Internal symbols and strings. */
 		if (sechdrs[i].sh_type == SHT_SYMTAB) {
 			symindex = i;
 			strindex = sechdrs[i].sh_link;
 			strtab = (char *)hdr + sechdrs[strindex].sh_offset;
 		}
 #ifndef CONFIG_MODULE_UNLOAD
 		/* Don't load .exit sections */
 		if (strncmp(secstrings+sechdrs[i].sh_name, ".exit", 5) == 0)
 			sechdrs[i].sh_flags &= ~(unsigned long)SHF_ALLOC;
 #endif
 	}
 	modindex = find_sec(hdr, sechdrs, secstrings,
 			    ".gnu.linkonce.this_module");
 	if (!modindex) {
 		printk(KERN_WARNING "No module found in object\n");
 		err = -ENOEXEC;
 		goto free_hdr;
 	}
 	mod = (void *)sechdrs[modindex].sh_addr;
 	if (symindex == 0) {
 		printk(KERN_WARNING "%s: module has no symbols (stripped?)\n",
 		       mod->name);
 		err = -ENOEXEC;
 		goto free_hdr;
 	}
 	/* Optional sections */
 	exportindex = find_sec(hdr, sechdrs, secstrings, "__ksymtab");
 	gplindex = find_sec(hdr, sechdrs, secstrings, "__ksymtab_gpl");
 	gplfutureindex = find_sec(hdr, sechdrs, secstrings, "__ksymtab_gpl_future");
 	unusedindex = find_sec(hdr, sechdrs, secstrings, "__ksymtab_unused");
 	unusedgplindex = find_sec(hdr, sechdrs, secstrings, "__ksymtab_unused_gpl");
 	crcindex = find_sec(hdr, sechdrs, secstrings, "__kcrctab");
 	gplcrcindex = find_sec(hdr, sechdrs, secstrings, "__kcrctab_gpl");
 	gplfuturecrcindex = find_sec(hdr, sechdrs, secstrings, "__kcrctab_gpl_future");
 	unusedcrcindex = find_sec(hdr, sechdrs, secstrings, "__kcrctab_unused");
 	unusedgplcrcindex = find_sec(hdr, sechdrs, secstrings, "__kcrctab_unused_gpl");
 	setupindex = find_sec(hdr, sechdrs, secstrings, "__param");
 	exindex = find_sec(hdr, sechdrs, secstrings, "__ex_table");
 	obsparmindex = find_sec(hdr, sechdrs, secstrings, "__obsparm");
 	versindex = find_sec(hdr, sechdrs, secstrings, "__versions");
 	infoindex = find_sec(hdr, sechdrs, secstrings, ".modinfo");
 	pcpuindex = find_pcpusec(hdr, sechdrs, secstrings);
 #ifdef ARCH_UNWIND_SECTION_NAME
 	unwindex = find_sec(hdr, sechdrs, secstrings, ARCH_UNWIND_SECTION_NAME);
 #endif
-	/* Don't keep modinfo section */
+	/* Don't keep modinfo and version sections. */
 	sechdrs[infoindex].sh_flags &= ~(unsigned long)SHF_ALLOC;
+	sechdrs[versindex].sh_flags &= ~(unsigned long)SHF_ALLOC;
 #ifdef CONFIG_KALLSYMS
 	/* Keep symbol and string tables for decoding later. */
 	sechdrs[symindex].sh_flags |= SHF_ALLOC;
 	sechdrs[strindex].sh_flags |= SHF_ALLOC;
 #endif
 	if (unwindex)
 		sechdrs[unwindex].sh_flags |= SHF_ALLOC;
 	/* Check module struct version now, before we try to use module. */
 	if (!check_modstruct_version(sechdrs, versindex, mod)) {
 		err = -ENOEXEC;
 		goto free_hdr;
 	}
 	modmagic = get_modinfo(sechdrs, infoindex, "vermagic");
 	/* This is allowed: modprobe --force will invalidate it. */
 	if (!modmagic) {
 		add_taint_module(mod, TAINT_FORCED_MODULE);
 		printk(KERN_WARNING "%s: no version magic, tainting kernel.\n",
 		       mod->name);
 	} else if (!same_magic(modmagic, vermagic)) {
 		printk(KERN_ERR "%s: version magic '%s' should be '%s'\n",
 		       mod->name, modmagic, vermagic);
 		err = -ENOEXEC;
 		goto free_hdr;
 	}
 	/* Now copy in args */
 	args = strndup_user(uargs, ~0UL >> 1);
 	if (IS_ERR(args)) {
 		err = PTR_ERR(args);
 		goto free_hdr;
 	}
 	if (find_module(mod->name)) {
 		err = -EEXIST;
 		goto free_mod;
 	}
 	mod->state = MODULE_STATE_COMING;
 	/* Allow arches to frob section contents and sizes.  */
 	err = module_frob_arch_sections(hdr, sechdrs, secstrings, mod);
 	if (err < 0)
 		goto free_mod;
 	if (pcpuindex) {
 		/* We have a special allocation for this section. */
 		percpu = percpu_modalloc(sechdrs[pcpuindex].sh_size,
 					 sechdrs[pcpuindex].sh_addralign,
 					 mod->name);
 		if (!percpu) {
 			err = -ENOMEM;
 			goto free_mod;
 		}
 		sechdrs[pcpuindex].sh_flags &= ~(unsigned long)SHF_ALLOC;
 		mod->percpu = percpu;
 	}
 	/* Determine total sizes, and put offsets in sh_entsize.  For now
 	   this is done generically; there doesn't appear to be any
 	   special cases for the architectures. */
 	layout_sections(mod, hdr, sechdrs, secstrings);
 	/* Do the allocs. */
 	ptr = module_alloc(mod->core_size);
 	if (!ptr) {
 		err = -ENOMEM;
 		goto free_percpu;
 	}
 	memset(ptr, 0, mod->core_size);
 	mod->module_core = ptr;
 	ptr = module_alloc(mod->init_size);
 	if (!ptr && mod->init_size) {
 		err = -ENOMEM;
 		goto free_core;
 	}
 	memset(ptr, 0, mod->init_size);
 	mod->module_init = ptr;
 	/* Transfer each section which specifies SHF_ALLOC */
 	DEBUGP("final section addresses:\n");
 	for (i = 0; i < hdr->e_shnum; i++) {
 		void *dest;
 		if (!(sechdrs[i].sh_flags & SHF_ALLOC))
 			continue;
 		if (sechdrs[i].sh_entsize & INIT_OFFSET_MASK)
 			dest = mod->module_init
 				+ (sechdrs[i].sh_entsize & ~INIT_OFFSET_MASK);
 		else
 			dest = mod->module_core + sechdrs[i].sh_entsize;
 		if (sechdrs[i].sh_type != SHT_NOBITS)
 			memcpy(dest, (void *)sechdrs[i].sh_addr,
 			       sechdrs[i].sh_size);
 		/* Update sh_addr to point to copy in image. */
 		sechdrs[i].sh_addr = (unsigned long)dest;
 		DEBUGP("\t0x%lx %s\n", sechdrs[i].sh_addr, secstrings + sechdrs[i].sh_name);
 	}
 	/* Module has been moved. */
 	mod = (void *)sechdrs[modindex].sh_addr;
 	/* Now we've moved module, initialize linked lists, etc. */
 	module_unload_init(mod);
 	/* add kobject, so we can reference it. */
 	err = mod_sysfs_init(mod);
 	if (err)
 		goto free_unload;
 	/* Set up license info based on the info section */
 	set_license(mod, get_modinfo(sechdrs, infoindex, "license"));
 	/*
 	 * ndiswrapper is under GPL by itself, but loads proprietary modules.
 	 * Don't use add_taint_module(), as it would prevent ndiswrapper from
 	 * using GPL-only symbols it needs.
 	 */
 	if (strcmp(mod->name, "ndiswrapper") == 0)
 		add_taint(TAINT_PROPRIETARY_MODULE);
 	/* driverloader was caught wrongly pretending to be under GPL */
 	if (strcmp(mod->name, "driverloader") == 0)
 		add_taint_module(mod, TAINT_PROPRIETARY_MODULE);
 	/* Set up MODINFO_ATTR fields */
 	setup_modinfo(mod, sechdrs, infoindex);
 	/* Fix up syms, so that st_value is a pointer to location. */
 	err = simplify_symbols(sechdrs, symindex, strtab, versindex, pcpuindex,
 			       mod);
 	if (err < 0)
 		goto cleanup;
 	/* Set up EXPORTed & EXPORT_GPLed symbols (section 0 is 0 length) */
 	mod->num_syms = sechdrs[exportindex].sh_size / sizeof(*mod->syms);
 	mod->syms = (void *)sechdrs[exportindex].sh_addr;
 	if (crcindex)
 		mod->crcs = (void *)sechdrs[crcindex].sh_addr;
 	mod->num_gpl_syms = sechdrs[gplindex].sh_size / sizeof(*mod->gpl_syms);
 	mod->gpl_syms = (void *)sechdrs[gplindex].sh_addr;
 	if (gplcrcindex)
 		mod->gpl_crcs = (void *)sechdrs[gplcrcindex].sh_addr;
 	mod->num_gpl_future_syms = sechdrs[gplfutureindex].sh_size /
 					sizeof(*mod->gpl_future_syms);
 	mod->num_unused_syms = sechdrs[unusedindex].sh_size /
 					sizeof(*mod->unused_syms);
 	mod->num_unused_gpl_syms = sechdrs[unusedgplindex].sh_size /
 					sizeof(*mod->unused_gpl_syms);
 	mod->gpl_future_syms = (void *)sechdrs[gplfutureindex].sh_addr;
 	if (gplfuturecrcindex)
 		mod->gpl_future_crcs = (void *)sechdrs[gplfuturecrcindex].sh_addr;
 	mod->unused_syms = (void *)sechdrs[unusedindex].sh_addr;
 	if (unusedcrcindex)
 		mod->unused_crcs = (void *)sechdrs[unusedcrcindex].sh_addr;
 	mod->unused_gpl_syms = (void *)sechdrs[unusedgplindex].sh_addr;
 	if (unusedgplcrcindex)
 		mod->unused_crcs = (void *)sechdrs[unusedgplcrcindex].sh_addr;
 #ifdef CONFIG_MODVERSIONS
 	if ((mod->num_syms && !crcindex) ||
 	    (mod->num_gpl_syms && !gplcrcindex) ||
 	    (mod->num_gpl_future_syms && !gplfuturecrcindex) ||
 	    (mod->num_unused_syms && !unusedcrcindex) ||
 	    (mod->num_unused_gpl_syms && !unusedgplcrcindex)) {
 		printk(KERN_WARNING "%s: No versions for exported symbols."
 		       " Tainting kernel.\n", mod->name);
 		add_taint_module(mod, TAINT_FORCED_MODULE);
 	}
 #endif
 	markersindex = find_sec(hdr, sechdrs, secstrings, "__markers");
  	markersstringsindex = find_sec(hdr, sechdrs, secstrings,
 					"__markers_strings");
 	/* Now do relocations. */
 	for (i = 1; i < hdr->e_shnum; i++) {
 		const char *strtab = (char *)sechdrs[strindex].sh_addr;
 		unsigned int info = sechdrs[i].sh_info;
 		/* Not a valid relocation section? */
 		if (info >= hdr->e_shnum)
 			continue;
 		/* Don't bother with non-allocated sections */
 		if (!(sechdrs[info].sh_flags & SHF_ALLOC))
 			continue;
 		if (sechdrs[i].sh_type == SHT_REL)
 			err = apply_relocate(sechdrs, strtab, symindex, i,mod);
 		else if (sechdrs[i].sh_type == SHT_RELA)
 			err = apply_relocate_add(sechdrs, strtab, symindex, i,
 						 mod);
 		if (err < 0)
 			goto cleanup;
 	}
 #ifdef CONFIG_MARKERS
 	mod->markers = (void *)sechdrs[markersindex].sh_addr;
 	mod->num_markers =
 		sechdrs[markersindex].sh_size / sizeof(*mod->markers);
 #endif
         /* Find duplicate symbols */
 	err = verify_export_symbols(mod);
 	if (err < 0)
 		goto cleanup;
   	/* Set up and sort exception table */
 	mod->num_exentries = sechdrs[exindex].sh_size / sizeof(*mod->extable);
 	mod->extable = extable = (void *)sechdrs[exindex].sh_addr;
 	sort_extable(extable, extable + mod->num_exentries);
 	/* Finally, copy percpu area over. */
 	percpu_modcopy(mod->percpu, (void *)sechdrs[pcpuindex].sh_addr,
 		       sechdrs[pcpuindex].sh_size);
 	add_kallsyms(mod, sechdrs, symindex, strindex, secstrings);
 #ifdef CONFIG_MARKERS
 	if (!mod->taints)
 		marker_update_probe_range(mod->markers,
 			mod->markers + mod->num_markers);
 #endif
 	err = module_finalize(hdr, sechdrs, mod);
 	if (err < 0)
 		goto cleanup;
 	/* flush the icache in correct context */
 	old_fs = get_fs();
 	set_fs(KERNEL_DS);
 	/*
 	 * Flush the instruction cache, since we've played with text.
 	 * Do it before processing of module parameters, so the module
 	 * can provide parameter accessor functions of its own.
 	 */
 	if (mod->module_init)
 		flush_icache_range((unsigned long)mod->module_init,
 				   (unsigned long)mod->module_init
 				   + mod->init_size);
 	flush_icache_range((unsigned long)mod->module_core,
 			   (unsigned long)mod->module_core + mod->core_size);
 	set_fs(old_fs);
 	mod->args = args;
 	if (obsparmindex)
 		printk(KERN_WARNING "%s: Ignoring obsolete parameters\n",
 		       mod->name);
 	/* Now sew it into the lists so we can get lockdep and oops
          * info during argument parsing.  Noone should access us, since
          * strong_try_module_get() will fail. */
 	stop_machine_run(__link_module, mod, NR_CPUS);
 	/* Size of section 0 is 0, so this works well if no params */
 	err = parse_args(mod->name, mod->args,
 			 (struct kernel_param *)
 			 sechdrs[setupindex].sh_addr,
 			 sechdrs[setupindex].sh_size
 			 / sizeof(struct kernel_param),
 			 NULL);
 	if (err < 0)
 		goto unlink;
 	err = mod_sysfs_setup(mod,
 			      (struct kernel_param *)
 			      sechdrs[setupindex].sh_addr,
 			      sechdrs[setupindex].sh_size
 			      / sizeof(struct kernel_param));
 	if (err < 0)
 		goto unlink;
 	add_sect_attrs(mod, hdr->e_shnum, secstrings, sechdrs);
 	add_notes_attrs(mod, hdr->e_shnum, secstrings, sechdrs);
 	/* Size of section 0 is 0, so this works well if no unwind info. */
 	mod->unwind_info = unwind_add_table(mod,
 					    (void *)sechdrs[unwindex].sh_addr,
 					    sechdrs[unwindex].sh_size);
 	/* Get rid of temporary copy */
 	vfree(hdr);
 	/* Done! */
 	return mod;
  unlink:
 	stop_machine_run(__unlink_module, mod, NR_CPUS);
 	module_arch_cleanup(mod);
  cleanup:
 	kobject_del(&mod->mkobj.kobj);
 	kobject_put(&mod->mkobj.kobj);
  free_unload:
 	module_unload_free(mod);
 	module_free(mod, mod->module_init);
  free_core:
 	module_free(mod, mod->module_core);
  free_percpu:
 	if (percpu)
 		percpu_modfree(percpu);
  free_mod:
 	kfree(args);
  free_hdr:
 	vfree(hdr);
 	return ERR_PTR(err);
  truncated:
 	printk(KERN_ERR "Module len %lu truncated\n", len);
 	err = -ENOEXEC;
 	goto free_hdr;
 }
 /* This is where the real work happens */
 asmlinkage long
 sys_init_module(void __user *umod,
 		unsigned long len,
 		const char __user *uargs)
 {
 	struct module *mod;
 	int ret = 0;
 	/* Must have permission */
 	if (!capable(CAP_SYS_MODULE))
 		return -EPERM;
 	/* Only one module load at a time, please */
 	if (mutex_lock_interruptible(&module_mutex) != 0)
 		return -EINTR;
 	/* Do all the hard work */
 	mod = load_module(umod, len, uargs);
 	if (IS_ERR(mod)) {
 		mutex_unlock(&module_mutex);
 		return PTR_ERR(mod);
 	}
 	/* Drop lock so they can recurse */
 	mutex_unlock(&module_mutex);
 	blocking_notifier_call_chain(&module_notify_list,
 			MODULE_STATE_COMING, mod);
 	/* Start the module */
 	if (mod->init != NULL)
 		ret = mod->init();
 	if (ret < 0) {
 		/* Init routine failed: abort.  Try to protect us from
                    buggy refcounters. */
 		mod->state = MODULE_STATE_GOING;
 		synchronize_sched();
 		module_put(mod);
 		mutex_lock(&module_mutex);
 		free_module(mod);
 		mutex_unlock(&module_mutex);
 		wake_up(&module_wq);
 		return ret;
 	}
 	if (ret > 0) {
 		printk(KERN_WARNING "%s: '%s'->init suspiciously returned %d, "
 				    "it should follow 0/-E convention\n"
 		       KERN_WARNING "%s: loading module anyway...\n",
 		       __func__, mod->name, ret,
 		       __func__);
 		dump_stack();
 	}
 	/* Now it's a first class citizen!  Wake up anyone waiting for it. */
 	mod->state = MODULE_STATE_LIVE;
 	wake_up(&module_wq);
 	mutex_lock(&module_mutex);
 	/* Drop initial reference. */
 	module_put(mod);
 	unwind_remove_table(mod->unwind_info, 1);
 	module_free(mod, mod->module_init);
 	mod->module_init = NULL;
 	mod->init_size = 0;
 	mod->init_text_size = 0;
 	mutex_unlock(&module_mutex);
 	return 0;
 }
 static inline int within(unsigned long addr, void *start, unsigned long size)
 {
 	return ((void *)addr >= start && (void *)addr < start + size);
 }
 #ifdef CONFIG_KALLSYMS
 /*
  * This ignores the intensely annoying "mapping symbols" found
  * in ARM ELF files: $a, $t and $d.
  */
 static inline int is_arm_mapping_symbol(const char *str)
 {
 	return str[0] == '$' && strchr("atd", str[1])
 	       && (str[2] == '\0' || str[2] == '.');
 }
 static const char *get_ksymbol(struct module *mod,
 			       unsigned long addr,
 			       unsigned long *size,
 			       unsigned long *offset)
 {
 	unsigned int i, best = 0;
 	unsigned long nextval;
 	/* At worse, next value is at end of module */
 	if (within(addr, mod->module_init, mod->init_size))
 		nextval = (unsigned long)mod->module_init+mod->init_text_size;
 	else
 		nextval = (unsigned long)mod->module_core+mod->core_text_size;
 	/* Scan for closest preceeding symbol, and next symbol. (ELF
 	   starts real symbols at 1). */
 	for (i = 1; i < mod->num_symtab; i++) {
 		if (mod->symtab[i].st_shndx == SHN_UNDEF)
 			continue;
 		/* We ignore unnamed symbols: they're uninformative
 		 * and inserted at a whim. */
 		if (mod->symtab[i].st_value <= addr
 		    && mod->symtab[i].st_value > mod->symtab[best].st_value
 		    && *(mod->strtab + mod->symtab[i].st_name) != '\0'
 		    && !is_arm_mapping_symbol(mod->strtab + mod->symtab[i].st_name))
 			best = i;
 		if (mod->symtab[i].st_value > addr
 		    && mod->symtab[i].st_value < nextval
 		    && *(mod->strtab + mod->symtab[i].st_name) != '\0'
 		    && !is_arm_mapping_symbol(mod->strtab + mod->symtab[i].st_name))
 			nextval = mod->symtab[i].st_value;
 	}
 	if (!best)
 		return NULL;
 	if (size)
 		*size = nextval - mod->symtab[best].st_value;
 	if (offset)
 		*offset = addr - mod->symtab[best].st_value;
 	return mod->strtab + mod->symtab[best].st_name;
 }
 /* For kallsyms to ask for address resolution.  NULL means not found.  Careful
  * not to lock to avoid deadlock on oopses, simply disable preemption. */
 const char *module_address_lookup(unsigned long addr,
 			    unsigned long *size,
 			    unsigned long *offset,
 			    char **modname,
 			    char *namebuf)
 {
 	struct module *mod;
 	const char *ret = NULL;
 	preempt_disable();
 	list_for_each_entry(mod, &modules, list) {
 		if (within(addr, mod->module_init, mod->init_size)
 		    || within(addr, mod->module_core, mod->core_size)) {
 			if (modname)
 				*modname = mod->name;
 			ret = get_ksymbol(mod, addr, size, offset);
 			break;
 		}
 	}
 	/* Make a copy in here where it's safe */
 	if (ret) {
 		strncpy(namebuf, ret, KSYM_NAME_LEN - 1);
 		ret = namebuf;
 	}
 	preempt_enable();
 	return ret;
 }
 int lookup_module_symbol_name(unsigned long addr, char *symname)
 {
 	struct module *mod;
 	preempt_disable();
 	list_for_each_entry(mod, &modules, list) {
 		if (within(addr, mod->module_init, mod->init_size) ||
 		    within(addr, mod->module_core, mod->core_size)) {
 			const char *sym;
 			sym = get_ksymbol(mod, addr, NULL, NULL);
 			if (!sym)
 				goto out;
 			strlcpy(symname, sym, KSYM_NAME_LEN);
 			preempt_enable();
 			return 0;
 		}
 	}
 out:
 	preempt_enable();
 	return -ERANGE;
 }
 int lookup_module_symbol_attrs(unsigned long addr, unsigned long *size,
 			unsigned long *offset, char *modname, char *name)
 {
 	struct module *mod;
 	preempt_disable();
 	list_for_each_entry(mod, &modules, list) {
 		if (within(addr, mod->module_init, mod->init_size) ||
 		    within(addr, mod->module_core, mod->core_size)) {
 			const char *sym;
 			sym = get_ksymbol(mod, addr, size, offset);
 			if (!sym)
 				goto out;
 			if (modname)
 				strlcpy(modname, mod->name, MODULE_NAME_LEN);
 			if (name)
 				strlcpy(name, sym, KSYM_NAME_LEN);
 			preempt_enable();
 			return 0;
 		}
 	}
 out:
 	preempt_enable();
 	return -ERANGE;
 }
 int module_get_kallsym(unsigned int symnum, unsigned long *value, char *type,
 			char *name, char *module_name, int *exported)
 {
 	struct module *mod;
 	preempt_disable();
 	list_for_each_entry(mod, &modules, list) {
 		if (symnum < mod->num_symtab) {
 			*value = mod->symtab[symnum].st_value;
 			*type = mod->symtab[symnum].st_info;
 			strlcpy(name, mod->strtab + mod->symtab[symnum].st_name,
 				KSYM_NAME_LEN);
 			strlcpy(module_name, mod->name, MODULE_NAME_LEN);
 			*exported = is_exported(name, mod);
 			preempt_enable();
 			return 0;
 		}
 		symnum -= mod->num_symtab;
 	}
 	preempt_enable();
 	return -ERANGE;
 }
 static unsigned long mod_find_symname(struct module *mod, const char *name)
 {
 	unsigned int i;
 	for (i = 0; i < mod->num_symtab; i++)
 		if (strcmp(name, mod->strtab+mod->symtab[i].st_name) == 0 &&
 		    mod->symtab[i].st_info != 'U')
 			return mod->symtab[i].st_value;
 	return 0;
 }
 /* Look for this name: can be of form module:name. */
 unsigned long module_kallsyms_lookup_name(const char *name)
 {
 	struct module *mod;
 	char *colon;
 	unsigned long ret = 0;
 	/* Don't lock: we're in enough trouble already. */
 	preempt_disable();
 	if ((colon = strchr(name, ':')) != NULL) {
 		*colon = '\0';
 		if ((mod = find_module(name)) != NULL)
 			ret = mod_find_symname(mod, colon+1);
 		*colon = ':';
 	} else {
 		list_for_each_entry(mod, &modules, list)
 			if ((ret = mod_find_symname(mod, name)) != 0)
 				break;
 	}
 	preempt_enable();
 	return ret;
 }
 #endif /* CONFIG_KALLSYMS */
 /* Called by the /proc file system to return a list of modules. */
 static void *m_start(struct seq_file *m, loff_t *pos)
 {
 	mutex_lock(&module_mutex);
 	return seq_list_start(&modules, *pos);
 }
 static void *m_next(struct seq_file *m, void *p, loff_t *pos)
 {
 	return seq_list_next(p, &modules, pos);
 }
 static void m_stop(struct seq_file *m, void *p)
 {
 	mutex_unlock(&module_mutex);
 }
 static char *module_flags(struct module *mod, char *buf)
 {
 	int bx = 0;
 	if (mod->taints ||
 	    mod->state == MODULE_STATE_GOING ||
 	    mod->state == MODULE_STATE_COMING) {
 		buf[bx++] = '(';
 		if (mod->taints & TAINT_PROPRIETARY_MODULE)
 			buf[bx++] = 'P';
 		if (mod->taints & TAINT_FORCED_MODULE)
 			buf[bx++] = 'F';
 		/*
 		 * TAINT_FORCED_RMMOD: could be added.
 		 * TAINT_UNSAFE_SMP, TAINT_MACHINE_CHECK, TAINT_BAD_PAGE don't
 		 * apply to modules.
 		 */
 		/* Show a - for module-is-being-unloaded */
 		if (mod->state == MODULE_STATE_GOING)
 			buf[bx++] = '-';
 		/* Show a + for module-is-being-loaded */
 		if (mod->state == MODULE_STATE_COMING)
 			buf[bx++] = '+';
 		buf[bx++] = ')';
 	}
 	buf[bx] = '\0';
 	return buf;
 }
 static int m_show(struct seq_file *m, void *p)
 {
 	struct module *mod = list_entry(p, struct module, list);
 	char buf[8];
 	seq_printf(m, "%s %lu",
 		   mod->name, mod->init_size + mod->core_size);
 	print_unload_info(m, mod);
 	/* Informative for users. */
 	seq_printf(m, " %s",
 		   mod->state == MODULE_STATE_GOING ? "Unloading":
 		   mod->state == MODULE_STATE_COMING ? "Loading":
 		   "Live");
 	/* Used by oprofile and other similar tools. */
 	seq_printf(m, " 0x%p", mod->module_core);
 	/* Taints info */
 	if (mod->taints)
 		seq_printf(m, " %s", module_flags(mod, buf));
 	seq_printf(m, "\n");
 	return 0;
 }
 /* Format: modulename size refcount deps address
    Where refcount is a number or -, and deps is a comma-separated list
    of depends or -.
 */
 const struct seq_operations modules_op = {
 	.start	= m_start,
 	.next	= m_next,
 	.stop	= m_stop,
 	.show	= m_show
 };
 /* Given an address, look for it in the module exception tables. */
 const struct exception_table_entry *search_module_extables(unsigned long addr)
 {
 	const struct exception_table_entry *e = NULL;
 	struct module *mod;
 	preempt_disable();
 	list_for_each_entry(mod, &modules, list) {
 		if (mod->num_exentries == 0)
 			continue;
 		e = search_extable(mod->extable,
 				   mod->extable + mod->num_exentries - 1,
 				   addr);
 		if (e)
 			break;
 	}
 	preempt_enable();
 	/* Now, if we found one, we are running inside it now, hence
 	   we cannot unload the module, hence no refcnt needed. */
 	return e;
 }
 /*
  * Is this a valid module address?
  */
 int is_module_address(unsigned long addr)
 {
 	struct module *mod;
 	preempt_disable();
 	list_for_each_entry(mod, &modules, list) {
 		if (within(addr, mod->module_core, mod->core_size)) {
 			preempt_enable();
 			return 1;
 		}
 	}
 	preempt_enable();
 	return 0;
 }
 /* Is this a valid kernel address? */
 struct module *__module_text_address(unsigned long addr)
 {
 	struct module *mod;
 	list_for_each_entry(mod, &modules, list)
 		if (within(addr, mod->module_init, mod->init_text_size)
 		    || within(addr, mod->module_core, mod->core_text_size))
 			return mod;
 	return NULL;
 }
 struct module *module_text_address(unsigned long addr)
 {
 	struct module *mod;
 	preempt_disable();
 	mod = __module_text_address(addr);
 	preempt_enable();
 	return mod;
 }
 /* Don't grab lock, we're oopsing. */
 void print_modules(void)
 {
 	struct module *mod;
 	char buf[8];
 	printk("Modules linked in:");
 	list_for_each_entry(mod, &modules, list)
 		printk(" %s%s", mod->name, module_flags(mod, buf));
 	if (last_unloaded_module[0])
 		printk(" [last unloaded: %s]", last_unloaded_module);
 	printk("\n");
 }
 #ifdef CONFIG_MODVERSIONS
 /* Generate the signature for struct module here, too, for modversions. */
 void struct_module(struct module *mod) { return; }
 EXPORT_SYMBOL(struct_module);
 #endif
 #ifdef CONFIG_MARKERS
 void module_update_markers(void)
 {
 	struct module *mod;
 	mutex_lock(&module_mutex);
 	list_for_each_entry(mod, &modules, list)
 		if (!mod->taints)
 			marker_update_probe_range(mod->markers,
 				mod->markers + mod->num_markers);
 	mutex_unlock(&module_mutex);
 }
 #endif