android_kernel_asus_tf201/kernel/module.c at master · AndroidRoot/android_kernel_asus_tf201 · GitHub

History

3447 lines (2971 loc) · 87.8 KB

Raw

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

390

391

392

393

394

395

396

397

398

399

400

401

402

403

404

405

406

407

408

409

410

411

412

413

414

415

416

417

418

419

420

421

422

423

424

425

426

427

428

429

430

431

432

433

434

435

436

437

438

439

440

441

442

443

444

445

446

447

448

449

450

451

452

453

454

455

456

457

458

459

460

461

462

463

464

465

466

467

468

469

470

471

472

473

474

475

476

477

478

479

480

481

482

483

484

485

486

487

488

489

490

491

492

493

494

495

496

497

498

499

500

501

502

503

504

505

506

507

508

509

510

511

512

513

514

515

516

517

518

519

520

521

522

523

524

525

526

527

528

529

530

531

532

533

534

535

536

537

538

539

540

541

542

543

544

545

546

547

548

549

550

551

552

553

554

555

556

557

558

559

560

561

562

563

564

565

566

567

568

569

570

571

572

573

574

575

576

577

578

579

580

581

582

583

584

585

586

587

588

589

590

591

592

593

594

595

596

597

598

599

600

601

602

603

604

605

606

607

608

609

610

611

612

613

614

615

616

617

618

619

620

621

622

623

624

625

626

627

628

629

630

631

632

633

634

635

636

637

638

639

640

641

642

643

644

645

646

647

648

649

650

651

652

653

654

655

656

657

658

659

660

661

662

663

664

665

666

667

668

669

670

671

672

673

674

675

676

677

678

679

680

681

682

683

684

685

686

687

688

689

690

691

692

693

694

695

696

697

698

699

700

701

702

703

704

705

706

707

708

709

710

711

712

713

714

715

716

717

718

719

720

721

722

723

724

725

726

727

728

729

730

731

732

733

734

735

736

737

738

739

740

741

742

743

744

745

746

747

748

749

750

751

752

753

754

755

756

757

758

759

760

761

762

763

764

765

766

767

768

769

770

771

772

773

774

775

776

777

778

779

780

781

782

783

784

785

786

787

788

789

790

791

792

793

794

795

796

797

798

799

800

801

802

803

804

805

806

807

808

809

810

811

812

813

814

815

816

817

818

819

820

821

822

823

824

825

826

827

828

829

830

831

832

833

834

835

836

837

838

839

840

841

842

843

844

845

846

847

848

849

850

851

852

853

854

855

856

857

858

859

860

861

862

863

864

865

866

867

868

869

870

871

872

873

874

875

876

877

878

879

880

881

882

883

884

885

886

887

888

889

890

891

892

893

894

895

896

897

898

899

900

901

902

903

904

905

906

907

908

909

910

911

912

913

914

915

916

917

918

919

920

921

922

923

924

925

926

927

928

929

930

931

932

933

934

935

936

937

938

939

940

941

942

943

944

945

946

947

948

949

950

951

952

953

954

955

956

957

958

959

960

961

962

963

964

965

966

967

968

969

970

971

972

973

974

975

976

977

978

979

980

981

982

983

984

985

986

987

988

989

990

991

992

993

994

995

996

997

998

999

1000

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/ftrace_event.h>

#include <linux/init.h>

#include <linux/kallsyms.h>

#include <linux/fs.h>

#include <linux/sysfs.h>

#include <linux/kernel.h>

#include <linux/slab.h>

#include <linux/vmalloc.h>

#include <linux/elf.h>

#include <linux/proc_fs.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/rculist.h>

#include <asm/uaccess.h>

#include <asm/cacheflush.h>

#include <asm/mmu_context.h>

#include <linux/license.h>

#include <asm/sections.h>

#include <linux/tracepoint.h>

#include <linux/ftrace.h>

#include <linux/async.h>

#include <linux/percpu.h>

#include <linux/kmemleak.h>

#include <linux/jump_label.h>

#include <linux/pfn.h>

#define CREATE_TRACE_POINTS

#include <trace/events/module.h>

#if 0

#define DEBUGP printk

#else

#define DEBUGP(fmt , a...)

#endif

#ifndef ARCH_SHF_SMALL

#define ARCH_SHF_SMALL 0

#endif

* Modules' sections will be aligned on page boundaries

* to ensure complete separation of code and data, but

* only when CONFIG_DEBUG_SET_MODULE_RONX=y

#ifdef CONFIG_DEBUG_SET_MODULE_RONX

# define debug_align(X) ALIGN(X, PAGE_SIZE)

#else

# define debug_align(X) (X)

#endif

* Given BASE and SIZE this macro calculates the number of pages the

* memory regions occupies

#define MOD_NUMBER_OF_PAGES(BASE, SIZE) (((SIZE) > 0) ? \

(PFN_DOWN((unsigned long)(BASE) + (SIZE) - 1) - \

PFN_DOWN((unsigned long)BASE) + 1) \

: (0UL))

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

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

* Mutex protects:

* 1) List of modules (also safely readable with preempt_disable),

* 2) module_use links,

* 3) module_addr_min/module_addr_max.

* (delete uses stop_machine/add uses RCU list operations). */

DEFINE_MUTEX(module_mutex);

EXPORT_SYMBOL_GPL(module_mutex);

static LIST_HEAD(modules);

#ifdef CONFIG_KGDB_KDB

struct list_head *kdb_modules = &modules; /* kdb needs the list of modules */

#endif /* CONFIG_KGDB_KDB */

/* Block module loading/unloading? */

int modules_disabled = 0;

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

static DECLARE_WAIT_QUEUE_HEAD(module_wq);

static BLOCKING_NOTIFIER_HEAD(module_notify_list);

/* Bounds of module allocation, for speeding __module_address.

* Protected by module_mutex. */

static unsigned long module_addr_min = -1UL, module_addr_max = 0;

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);

struct load_info {

Elf_Ehdr *hdr;

unsigned long len;

Elf_Shdr *sechdrs;

char *secstrings, *strtab;

unsigned long *strmap;

unsigned long symoffs, stroffs;

struct _ddebug *debug;

unsigned int num_debug;

struct {

unsigned int sym, str, mod, vers, info, pcpu;

} index;

};

/* 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 |= (1U << 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(const struct load_info *info, const char *name)

{

unsigned int i;

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

Elf_Shdr *shdr = &info->sechdrs[i];

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

if ((shdr->sh_flags & SHF_ALLOC)

&& strcmp(info->secstrings + shdr->sh_name, name) == 0)

return i;

}

return 0;

}

/* Find a module section, or NULL. */

static void *section_addr(const struct load_info *info, const char *name)

{

/* Section 0 has sh_addr 0. */

return (void *)info->sechdrs[find_sec(info, name)].sh_addr;

}

/* Find a module section, or NULL. Fill in number of "objects" in section. */

static void *section_objs(const struct load_info *info,

const char *name,

size_t object_size,

unsigned int *num)

{

unsigned int sec = find_sec(info, name);

/* Section 0 has sh_addr 0 and sh_size 0. */

*num = info->sechdrs[sec].sh_size / object_size;

return (void *)info->sechdrs[sec].sh_addr;

}

/* 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 unsigned long __start___kcrctab[];

extern const unsigned long __start___kcrctab_gpl[];

extern const unsigned long __start___kcrctab_gpl_future[];

#ifdef CONFIG_UNUSED_SYMBOLS

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 unsigned long __start___kcrctab_unused[];

extern const unsigned long __start___kcrctab_unused_gpl[];

#endif

#ifndef CONFIG_MODVERSIONS

#define symversion(base, idx) NULL

#else

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

#endif

static bool each_symbol_in_section(const struct symsearch *arr,

unsigned int arrsize,

struct module *owner,

bool (*fn)(const struct symsearch *syms,

struct module *owner,

unsigned int symnum, void *data),

void *data)

{

unsigned int i, j;

for (j = 0; j < arrsize; j++) {

for (i = 0; i < arr[j].stop - arr[j].start; i++)

if (fn(&arr[j], owner, i, data))

return true;

}

return false;

}

/* Returns true as soon as fn returns true, otherwise false. */

bool each_symbol(bool (*fn)(const struct symsearch *arr, struct module *owner,

unsigned int symnum, void *data), void *data)

{

struct module *mod;

static const struct symsearch arr[] = {

{ __start___ksymtab, __stop___ksymtab, __start___kcrctab,

NOT_GPL_ONLY, false },

{ __start___ksymtab_gpl, __stop___ksymtab_gpl,

__start___kcrctab_gpl,

GPL_ONLY, false },

{ __start___ksymtab_gpl_future, __stop___ksymtab_gpl_future,

__start___kcrctab_gpl_future,

WILL_BE_GPL_ONLY, false },

#ifdef CONFIG_UNUSED_SYMBOLS

{ __start___ksymtab_unused, __stop___ksymtab_unused,

__start___kcrctab_unused,

NOT_GPL_ONLY, true },

{ __start___ksymtab_unused_gpl, __stop___ksymtab_unused_gpl,

__start___kcrctab_unused_gpl,

GPL_ONLY, true },

#endif

};

if (each_symbol_in_section(arr, ARRAY_SIZE(arr), NULL, fn, data))

return true;

list_for_each_entry_rcu(mod, &modules, list) {

struct symsearch arr[] = {

{ mod->syms, mod->syms + mod->num_syms, mod->crcs,

NOT_GPL_ONLY, false },

{ mod->gpl_syms, mod->gpl_syms + mod->num_gpl_syms,

mod->gpl_crcs,

GPL_ONLY, false },

{ mod->gpl_future_syms,

mod->gpl_future_syms + mod->num_gpl_future_syms,

mod->gpl_future_crcs,

WILL_BE_GPL_ONLY, false },

#ifdef CONFIG_UNUSED_SYMBOLS

{ mod->unused_syms,

mod->unused_syms + mod->num_unused_syms,

mod->unused_crcs,

NOT_GPL_ONLY, true },

{ mod->unused_gpl_syms,

mod->unused_gpl_syms + mod->num_unused_gpl_syms,

mod->unused_gpl_crcs,

GPL_ONLY, true },

#endif

};

if (each_symbol_in_section(arr, ARRAY_SIZE(arr), mod, fn, data))

return true;

}

return false;

}

EXPORT_SYMBOL_GPL(each_symbol);

struct find_symbol_arg {

/* Input */

const char *name;

bool gplok;

bool warn;

/* Output */

struct module *owner;

const unsigned long *crc;

const struct kernel_symbol *sym;

};

static bool find_symbol_in_section(const struct symsearch *syms,

struct module *owner,

unsigned int symnum, void *data)

{

struct find_symbol_arg *fsa = data;

if (strcmp(syms->start[symnum].name, fsa->name) != 0)

return false;

if (!fsa->gplok) {

if (syms->licence == GPL_ONLY)

return false;

if (syms->licence == WILL_BE_GPL_ONLY && fsa->warn) {

printk(KERN_WARNING "Symbol %s is being used "

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

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

printk(KERN_WARNING "Please see the file "

"Documentation/feature-removal-schedule.txt "

"in the kernel source tree for more details.\n");

}

#ifdef CONFIG_UNUSED_SYMBOLS

if (syms->unused && fsa->warn) {

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

"however this module is using it.\n", fsa->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");

}

#endif

fsa->owner = owner;

fsa->crc = symversion(syms->crcs, symnum);

fsa->sym = &syms->start[symnum];

return true;

}

/* Find a symbol and return it, along with, (optional) crc and

* (optional) module which owns it. Needs preempt disabled or module_mutex. */

const struct kernel_symbol *find_symbol(const char *name,

struct module **owner,

const unsigned long **crc,

bool gplok,

bool warn)

{

struct find_symbol_arg fsa;

fsa.name = name;

fsa.gplok = gplok;

fsa.warn = warn;

if (each_symbol(find_symbol_in_section, &fsa)) {

if (owner)

*owner = fsa.owner;

if (crc)

*crc = fsa.crc;

return fsa.sym;

}

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

return NULL;

}

EXPORT_SYMBOL_GPL(find_symbol);

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

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;

}

EXPORT_SYMBOL_GPL(find_module);

#ifdef CONFIG_SMP

static inline void __percpu *mod_percpu(struct module *mod)

{

return mod->percpu;

}

static int percpu_modalloc(struct module *mod,

unsigned long size, unsigned long align)

{

if (align > PAGE_SIZE) {

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

mod->name, align, PAGE_SIZE);

align = PAGE_SIZE;

}

mod->percpu = __alloc_reserved_percpu(size, align);

if (!mod->percpu) {

printk(KERN_WARNING

"%s: Could not allocate %lu bytes percpu data\n",

mod->name, size);

return -ENOMEM;

}

mod->percpu_size = size;

return 0;

}

static void percpu_modfree(struct module *mod)

{

free_percpu(mod->percpu);

}

static unsigned int find_pcpusec(struct load_info *info)

{

return find_sec(info, ".data..percpu");

}

static void percpu_modcopy(struct module *mod,

const void *from, unsigned long size)

{

int cpu;

for_each_possible_cpu(cpu)

memcpy(per_cpu_ptr(mod->percpu, cpu), from, size);

}

/**

* is_module_percpu_address - test whether address is from module static percpu

* @addr: address to test

* Test whether @addr belongs to module static percpu area.

* RETURNS:

* %true if @addr is from module static percpu area

bool is_module_percpu_address(unsigned long addr)

{

struct module *mod;

unsigned int cpu;

preempt_disable();

list_for_each_entry_rcu(mod, &modules, list) {

if (!mod->percpu_size)

continue;

for_each_possible_cpu(cpu) {

void *start = per_cpu_ptr(mod->percpu, cpu);

if ((void *)addr >= start &&

(void *)addr < start + mod->percpu_size) {

preempt_enable();

return true;

}

preempt_enable();

return false;

}

#else /* ... !CONFIG_SMP */

static inline void __percpu *mod_percpu(struct module *mod)

{

return NULL;

}

static inline int percpu_modalloc(struct module *mod,

unsigned long size, unsigned long align)

{

return -ENOMEM;

}

static inline void percpu_modfree(struct module *mod)

{

}

static unsigned int find_pcpusec(struct load_info *info)

{

return 0;

}

static inline void percpu_modcopy(struct module *mod,

const void *from, unsigned long size)

{

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

BUG_ON(size != 0);

}

bool is_module_percpu_address(unsigned long addr)

{

return false;

}

#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

EXPORT_TRACEPOINT_SYMBOL(module_get);

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

static int module_unload_init(struct module *mod)

{

mod->refptr = alloc_percpu(struct module_ref);

if (!mod->refptr)

return -ENOMEM;

INIT_LIST_HEAD(&mod->source_list);

INIT_LIST_HEAD(&mod->target_list);

/* Hold reference count during initialization. */

__this_cpu_write(mod->refptr->incs, 1);

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

mod->waiter = current;

return 0;

}

/* 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->source_list, source_list) {

if (use->source == 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

* - we add 'a' as a "source", 'b' as a "target" of module use

* - the module_use is added to the list of 'b' sources (so

* 'b' can walk the list to see who sourced them), and of 'a'

* targets (so 'a' can see what modules it targets).

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

{

struct module_use *use;

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

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

if (!use) {

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

return -ENOMEM;

}

use->source = a;

use->target = b;

list_add(&use->source_list, &b->source_list);

list_add(&use->target_list, &a->target_list);

return 0;

}

/* Module a uses b: caller needs module_mutex() */

int ref_module(struct module *a, struct module *b)

{

int err;

if (b == NULL || already_uses(a, b))

return 0;

/* If module isn't available, we fail. */

err = strong_try_module_get(b);

if (err)

return err;

err = add_module_usage(a, b);

if (err) {

module_put(b);

return err;

}

return 0;

}

EXPORT_SYMBOL_GPL(ref_module);

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

static void module_unload_free(struct module *mod)

{

struct module_use *use, *tmp;

mutex_lock(&module_mutex);

list_for_each_entry_safe(use, tmp, &mod->target_list, target_list) {

struct module *i = use->target;

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

module_put(i);

list_del(&use->source_list);

list_del(&use->target_list);

kfree(use);

}

mutex_unlock(&module_mutex);

free_percpu(mod->refptr);

}

#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're forcing. */

if (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)

{

if (flags & O_NONBLOCK) {

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

return stop_machine(__try_stop_module, &sref, NULL);

} else {

/* We don't need to stop the machine for this. */

mod->state = MODULE_STATE_GOING;

synchronize_sched();

return 0;

}

unsigned int module_refcount(struct module *mod)

{

unsigned int incs = 0, decs = 0;

int cpu;

for_each_possible_cpu(cpu)

decs += per_cpu_ptr(mod->refptr, cpu)->decs;

* ensure the incs are added up after the decs.

* module_put ensures incs are visible before decs with smp_wmb.

* This 2-count scheme avoids the situation where the refcount

* for CPU0 is read, then CPU0 increments the module refcount,

* then CPU1 drops that refcount, then the refcount for CPU1 is

* read. We would record a decrement but not its corresponding

* increment so we would see a low count (disaster).

* Rare situation? But module_refcount can be preempted, and we

* might be tallying up 4096+ CPUs. So it is not impossible.

smp_rmb();

for_each_possible_cpu(cpu)

incs += per_cpu_ptr(mod->refptr, cpu)->incs;

return incs - decs;

}

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);

}

SYSCALL_DEFINE2(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) || modules_disabled)

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->source_list)) {

/* 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);

mutex_unlock(&module_mutex);

/* Final destruction now no one is using it. */

if (mod->exit != NULL)

mod->exit();

blocking_notifier_call_chain(&module_notify_list,

MODULE_STATE_GOING, mod);

async_synchronize_full();

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

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

free_module(mod);

return 0;

out:

mutex_unlock(&module_mutex);

return ret;

}

static inline 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->source_list, source_list) {

printed_something = 1;

seq_printf(m, "%s,", use->source->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;

preempt_disable();

if (!find_symbol(symbol, &owner, NULL, true, false))

BUG();

module_put(owner);

preempt_enable();

}

EXPORT_SYMBOL(__symbol_put);

/* Note this assumes addr is a function, which it currently always is. */

void symbol_put_addr(void *addr)

{

struct module *modaddr;

unsigned long a = (unsigned long)dereference_function_descriptor(addr);

if (core_kernel_text(a))

return;

/* module_text_address is safe here: we're supposed to have reference

* to module from symbol_get, so it can't go away. */

modaddr = __module_text_address(a);

BUG_ON(!modaddr);

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) {

preempt_disable();

smp_wmb(); /* see comment in module_refcount */

__this_cpu_inc(module->refptr->decs);

trace_module_put(module, _RET_IP_);

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

if (unlikely(!module_is_live(module)))

wake_up_process(module->waiter);

preempt_enable();

}

EXPORT_SYMBOL(module_put);

#else /* !CONFIG_MODULE_UNLOAD */

static inline 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)

{

}

int ref_module(struct module *a, struct module *b)

{

return strong_try_module_get(b);

}

EXPORT_SYMBOL_GPL(ref_module);

static inline int module_unload_init(struct module *mod)

{

return 0;

}

#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;

static int try_to_force_load(struct module *mod, const char *reason)

{

#ifdef CONFIG_MODULE_FORCE_LOAD

if (!test_taint(TAINT_FORCED_MODULE))

printk(KERN_WARNING "%s: %s: kernel tainted.\n",

mod->name, reason);

add_taint_module(mod, TAINT_FORCED_MODULE);

return 0;

#else

return -ENOEXEC;

#endif

}

#ifdef CONFIG_MODVERSIONS

/* If the arch applies (non-zero) relocations to kernel kcrctab, unapply it. */

static unsigned long maybe_relocated(unsigned long crc,

const struct module *crc_owner)

{

#ifdef ARCH_RELOCATES_KCRCTAB

if (crc_owner == NULL)

return crc - (unsigned long)reloc_start;

#endif

return crc;

}

static int check_version(Elf_Shdr *sechdrs,

unsigned int versindex,

const char *symname,

struct module *mod,

const unsigned long *crc,

const struct module *crc_owner)

{

unsigned int i, num_versions;

struct modversion_info *versions;

View remainder of file in raw view

android_kernel_asus_tf201/kernel/module.c at master · AndroidRoot/android_kernel_asus_tf201 · GitHub

Uh oh!

Expand file tree

Breadcrumbs

module.c

Latest commit

History

Breadcrumbs

module.c

File metadata and controls